diff --git a/.buildkite/ci.mjs b/.buildkite/ci.mjs
new file mode 100755
index 0000000000..a4af8802b7
--- /dev/null
+++ b/.buildkite/ci.mjs
@@ -0,0 +1,1131 @@
+#!/usr/bin/env node
+
+/**
+ * Build and test Bun on macOS, Linux, and Windows.
+ * @link https://buildkite.com/docs/pipelines/defining-steps
+ */
+
+import { join } from "node:path";
+import {
+  getBootstrapVersion,
+  getBuildkiteEmoji,
+  getBuildMetadata,
+  getBuildNumber,
+  getCommitMessage,
+  getEmoji,
+  getEnv,
+  getLastSuccessfulBuild,
+  isBuildkite,
+  isBuildManual,
+  isFork,
+  isMainBranch,
+  isMergeQueue,
+  parseBoolean,
+  spawnSafe,
+  startGroup,
+  toYaml,
+  uploadArtifact,
+  writeFile,
+} from "../scripts/utils.mjs";
+
+/**
+ * @typedef {"linux" | "darwin" | "windows"} Os
+ * @typedef {"aarch64" | "x64"} Arch
+ * @typedef {"musl"} Abi
+ * @typedef {"debian" | "ubuntu" | "alpine" | "amazonlinux"} Distro
+ * @typedef {"latest" | "previous" | "oldest" | "eol"} Tier
+ * @typedef {"release" | "assert" | "debug"} Profile
+ */
+
+/**
+ * @typedef Target
+ * @property {Os} os
+ * @property {Arch} arch
+ * @property {Abi} [abi]
+ * @property {boolean} [baseline]
+ * @property {boolean} [canary]
+ * @property {Profile} [profile]
+ */
+
+/**
+ * @param {Target} target
+ * @returns {string}
+ */
+function getTargetKey(target) {
+  const { os, arch, abi, baseline, profile } = target;
+  let key = `${os}-${arch}`;
+  if (abi) {
+    key += `-${abi}`;
+  }
+  if (baseline) {
+    key += "-baseline";
+  }
+  if (profile && profile !== "release") {
+    key += `-${profile}`;
+  }
+  return key;
+}
+
+/**
+ * @param {Target} target
+ * @returns {string}
+ */
+function getTargetLabel(target) {
+  const { os, arch, abi, baseline, profile } = target;
+  let label = `${getBuildkiteEmoji(os)} ${arch}`;
+  if (abi) {
+    label += `-${abi}`;
+  }
+  if (baseline) {
+    label += "-baseline";
+  }
+  if (profile && profile !== "release") {
+    label += `-${profile}`;
+  }
+  return label;
+}
+
+/**
+ * @typedef Platform
+ * @property {Os} os
+ * @property {Arch} arch
+ * @property {Abi} [abi]
+ * @property {boolean} [baseline]
+ * @property {boolean} [canary]
+ * @property {Profile} [profile]
+ * @property {Distro} [distro]
+ * @property {string} release
+ * @property {Tier} [tier]
+ */
+
+/**
+ * @type {Platform[]}
+ */
+const buildPlatforms = [
+  { 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", release: "14", tier: "latest" },
+  { os: "darwin", arch: "aarch64", release: "13", tier: "previous" },
+  { os: "darwin", arch: "x64", release: "14", tier: "latest" },
+  { os: "darwin", arch: "x64", release: "13", tier: "previous" },
+  { os: "linux", arch: "aarch64", distro: "debian", release: "12", tier: "latest" },
+  { os: "linux", arch: "aarch64", distro: "debian", release: "11", tier: "previous" },
+  { os: "linux", arch: "x64", distro: "debian", release: "12", tier: "latest" },
+  { os: "linux", arch: "x64", distro: "debian", release: "11", tier: "previous" },
+  { os: "linux", arch: "x64", baseline: true, distro: "debian", release: "12", tier: "latest" },
+  { os: "linux", arch: "x64", baseline: true, distro: "debian", release: "11", tier: "previous" },
+  { os: "linux", arch: "aarch64", distro: "ubuntu", release: "24.04", tier: "latest" },
+  { os: "linux", arch: "aarch64", distro: "ubuntu", release: "22.04", tier: "previous" },
+  { os: "linux", arch: "aarch64", distro: "ubuntu", release: "20.04", tier: "oldest" },
+  { os: "linux", arch: "x64", distro: "ubuntu", release: "24.04", tier: "latest" },
+  { os: "linux", arch: "x64", distro: "ubuntu", release: "22.04", tier: "previous" },
+  { os: "linux", arch: "x64", distro: "ubuntu", release: "20.04", tier: "oldest" },
+  { os: "linux", arch: "x64", baseline: true, distro: "ubuntu", release: "24.04", tier: "latest" },
+  { os: "linux", arch: "x64", baseline: true, distro: "ubuntu", release: "22.04", tier: "previous" },
+  { os: "linux", arch: "x64", baseline: true, distro: "ubuntu", release: "20.04", tier: "oldest" },
+  { os: "linux", arch: "aarch64", abi: "musl", distro: "alpine", release: "3.20", tier: "latest" },
+  { os: "linux", arch: "x64", abi: "musl", distro: "alpine", release: "3.20", tier: "latest" },
+  { os: "linux", arch: "x64", abi: "musl", baseline: true, distro: "alpine", release: "3.20", tier: "latest" },
+  { os: "windows", arch: "x64", release: "2025", tier: "latest" },
+  { os: "windows", arch: "x64", release: "2022", tier: "previous" },
+  { os: "windows", arch: "x64", release: "2019", tier: "oldest" },
+  { os: "windows", arch: "x64", release: "2025", baseline: true, tier: "latest" },
+  { os: "windows", arch: "x64", release: "2022", baseline: true, tier: "previous" },
+  { os: "windows", arch: "x64", release: "2019", baseline: true, tier: "oldest" },
+];
+
+/**
+ * @param {Platform} platform
+ * @returns {string}
+ */
+function getPlatformKey(platform) {
+  const { distro, release } = platform;
+  const target = getTargetKey(platform);
+  const version = release.replace(/\./g, "");
+  if (distro) {
+    return `${target}-${distro}-${version}`;
+  }
+  return `${target}-${version}`;
+}
+
+/**
+ * @param {Platform} platform
+ * @returns {string}
+ */
+function getPlatformLabel(platform) {
+  const { os, arch, baseline, profile, distro, release } = platform;
+  let label = `${getBuildkiteEmoji(distro || os)} ${release} ${arch}`;
+  if (baseline) {
+    label += "-baseline";
+  }
+  if (profile && profile !== "release") {
+    label += `-${profile}`;
+  }
+  return label;
+}
+
+/**
+ * @param {Platform} platform
+ * @returns {string}
+ */
+function getImageKey(platform) {
+  const { os, arch, distro, release } = platform;
+  const version = release.replace(/\./g, "");
+  if (distro) {
+    return `${os}-${arch}-${distro}-${version}`;
+  }
+  return `${os}-${arch}-${version}`;
+}
+
+/**
+ * @param {Platform} platform
+ * @returns {string}
+ */
+function getImageLabel(platform) {
+  const { os, arch, distro, release } = platform;
+  return `${getBuildkiteEmoji(distro || os)} ${release} ${arch}`;
+}
+
+/**
+ * @param {Platform} platform
+ * @param {boolean} [dryRun]
+ * @returns {string}
+ */
+function getImageName(platform, dryRun) {
+  const { os, arch, distro, release } = platform;
+  const name = distro ? `${os}-${arch}-${distro}-${release}` : `${os}-${arch}-${release}`;
+  if (dryRun) {
+    return `${name}-build-${getBuildNumber()}`;
+  }
+  return `${name}-v${getBootstrapVersion(os)}`;
+}
+
+/**
+ * @param {number} [limit]
+ * @link https://buildkite.com/docs/pipelines/command-step#retry-attributes
+ */
+function getRetry(limit = 0) {
+  return {
+    manual: {
+      permit_on_passed: true,
+    },
+    automatic: [
+      { exit_status: 1, limit },
+      { exit_status: -1, limit: 3 },
+      { exit_status: 255, limit: 3 },
+      { signal_reason: "cancel", limit: 3 },
+      { signal_reason: "agent_stop", limit: 3 },
+    ],
+  };
+}
+
+/**
+ * @returns {number}
+ * @link https://buildkite.com/docs/pipelines/managing-priorities
+ */
+function getPriority() {
+  if (isFork()) {
+    return -1;
+  }
+  if (isMainBranch()) {
+    return 2;
+  }
+  if (isMergeQueue()) {
+    return 1;
+  }
+  return 0;
+}
+
+/**
+ * Agents
+ */
+
+/**
+ * @typedef {Object} Ec2Options
+ * @property {string} instanceType
+ * @property {number} cpuCount
+ * @property {number} threadsPerCore
+ */
+
+/**
+ * @param {Platform} platform
+ * @param {Ec2Options} options
+ * @returns {Agent}
+ */
+function getEc2Agent(platform, options) {
+  const { os, arch, abi, distro, release } = platform;
+  const { instanceType, cpuCount, threadsPerCore } = options;
+  return {
+    os,
+    arch,
+    abi,
+    distro,
+    release,
+    // The agent is created by robobun, see more details here:
+    // https://github.com/oven-sh/robobun/blob/d46c07e0ac5ac0f9ffe1012f0e98b59e1a0d387a/src/robobun.ts#L1707
+    robobun: true,
+    robobun2: true,
+    "image-name": getImageName(platform),
+    "instance-type": instanceType,
+    "cpu-count": cpuCount,
+    "threads-per-core": threadsPerCore,
+    "preemptible": false,
+  };
+}
+
+/**
+ * @param {Platform} platform
+ * @returns {string}
+ */
+function getCppAgent(platform) {
+  const { os, arch } = platform;
+
+  if (os === "darwin") {
+    return {
+      queue: `build-${os}`,
+      os,
+      arch,
+    };
+  }
+
+  return getEc2Agent(platform, {
+    instanceType: arch === "aarch64" ? "c8g.16xlarge" : "c7i.16xlarge",
+    cpuCount: 32,
+    threadsPerCore: 1,
+  });
+}
+
+/**
+ * @param {Platform} platform
+ * @returns {Agent}
+ */
+function getZigAgent(platform) {
+  const { arch } = platform;
+
+  return {
+    queue: "build-zig",
+  };
+
+  // return getEc2Agent(
+  //   {
+  //     os: "linux",
+  //     arch,
+  //     distro: "debian",
+  //     release: "11",
+  //   },
+  //   {
+  //     instanceType: arch === "aarch64" ? "c8g.2xlarge" : "c7i.2xlarge",
+  //     cpuCount: 4,
+  //     threadsPerCore: 1,
+  //   },
+  // );
+}
+
+/**
+ * @param {Platform} platform
+ * @returns {Agent}
+ */
+function getTestAgent(platform) {
+  const { os, arch } = platform;
+
+  if (os === "darwin") {
+    return {
+      queue: `test-${os}`,
+      os,
+      arch,
+    };
+  }
+
+  // TODO: `dev-server-ssr-110.test.ts` and `next-build.test.ts` run out of memory
+  // at 8GB of memory, so use 16GB instead.
+  if (os === "windows") {
+    return getEc2Agent(platform, {
+      instanceType: "c7i.2xlarge",
+      cpuCount: 1,
+      threadsPerCore: 1,
+    });
+  }
+
+  if (arch === "aarch64") {
+    return getEc2Agent(platform, {
+      instanceType: "c8g.xlarge",
+      cpuCount: 1,
+      threadsPerCore: 1,
+    });
+  }
+
+  return getEc2Agent(platform, {
+    instanceType: "c7i.xlarge",
+    cpuCount: 1,
+    threadsPerCore: 1,
+  });
+}
+
+/**
+ * Steps
+ */
+
+/**
+ * @param {Target} target
+ * @returns {Record<string, string | undefined>}
+ */
+function getBuildEnv(target) {
+  const { profile, baseline, canary, abi } = target;
+  const release = !profile || profile === "release";
+
+  return {
+    CMAKE_BUILD_TYPE: release ? "Release" : profile === "debug" ? "Debug" : "RelWithDebInfo",
+    ENABLE_BASELINE: baseline ? "ON" : "OFF",
+    ENABLE_CANARY: canary ? "ON" : "OFF",
+    ENABLE_ASSERTIONS: release ? "OFF" : "ON",
+    ENABLE_LOGS: release ? "OFF" : "ON",
+    ABI: abi === "musl" ? "musl" : undefined,
+  };
+}
+
+/**
+ * @param {Platform} platform
+ * @returns {Step}
+ */
+function getBuildVendorStep(platform) {
+  return {
+    key: `${getTargetKey(platform)}-build-vendor`,
+    label: `${getTargetLabel(platform)} - build-vendor`,
+    agents: getCppAgent(platform),
+    retry: getRetry(),
+    cancel_on_build_failing: isMergeQueue(),
+    env: getBuildEnv(platform),
+    command: "bun run build:ci --target dependencies",
+  };
+}
+
+/**
+ * @param {Platform} platform
+ * @returns {Step}
+ */
+function getBuildCppStep(platform) {
+  return {
+    key: `${getTargetKey(platform)}-build-cpp`,
+    label: `${getTargetLabel(platform)} - build-cpp`,
+    agents: getCppAgent(platform),
+    retry: getRetry(),
+    cancel_on_build_failing: isMergeQueue(),
+    env: {
+      BUN_CPP_ONLY: "ON",
+      ...getBuildEnv(platform),
+    },
+    command: "bun run build:ci --target bun",
+  };
+}
+
+/**
+ * @param {Target} target
+ * @returns {string}
+ */
+function getBuildToolchain(target) {
+  const { os, arch, abi, baseline } = target;
+  let key = `${os}-${arch}`;
+  if (abi) {
+    key += `-${abi}`;
+  }
+  if (baseline) {
+    key += "-baseline";
+  }
+  return key;
+}
+
+/**
+ * @param {Platform} platform
+ * @returns {Step}
+ */
+function getBuildZigStep(platform) {
+  const toolchain = getBuildToolchain(platform);
+  return {
+    key: `${getTargetKey(platform)}-build-zig`,
+    label: `${getTargetLabel(platform)} - build-zig`,
+    agents: getZigAgent(platform),
+    retry: getRetry(),
+    cancel_on_build_failing: isMergeQueue(),
+    env: getBuildEnv(platform),
+    command: `bun run build:ci --target bun-zig --toolchain ${toolchain}`,
+  };
+}
+
+/**
+ * @param {Platform} platform
+ * @returns {Step}
+ */
+function getLinkBunStep(platform) {
+  return {
+    key: `${getTargetKey(platform)}-build-bun`,
+    label: `${getTargetLabel(platform)} - build-bun`,
+    depends_on: [
+      `${getTargetKey(platform)}-build-vendor`,
+      `${getTargetKey(platform)}-build-cpp`,
+      `${getTargetKey(platform)}-build-zig`,
+    ],
+    agents: getCppAgent(platform),
+    retry: getRetry(),
+    cancel_on_build_failing: isMergeQueue(),
+    env: {
+      BUN_LINK_ONLY: "ON",
+      ...getBuildEnv(platform),
+    },
+    command: "bun run build:ci --target bun",
+  };
+}
+
+/**
+ * @param {Platform} platform
+ * @returns {Step}
+ */
+function getBuildBunStep(platform) {
+  return {
+    key: `${getTargetKey(platform)}-build-bun`,
+    label: `${getTargetLabel(platform)} - build-bun`,
+    agents: getCppAgent(platform),
+    retry: getRetry(),
+    cancel_on_build_failing: isMergeQueue(),
+    env: getBuildEnv(platform),
+    command: "bun run build:ci",
+  };
+}
+
+/**
+ * @typedef {Object} TestOptions
+ * @property {string} [buildId]
+ * @property {boolean} [unifiedTests]
+ * @property {string[]} [testFiles]
+ */
+
+/**
+ * @param {Platform} platform
+ * @param {TestOptions} [options]
+ * @returns {Step}
+ */
+function getTestBunStep(platform, options = {}) {
+  const { os } = platform;
+  const { buildId, unifiedTests, testFiles } = options;
+
+  const args = [`--step=${getTargetKey(platform)}-build-bun`];
+  if (buildId) {
+    args.push(`--build-id=${buildId}`);
+  }
+  if (testFiles) {
+    args.push(...testFiles.map(testFile => `--include=${testFile}`));
+  }
+
+  const depends = [];
+  if (!buildId) {
+    depends.push(`${getTargetKey(platform)}-build-bun`);
+  }
+
+  return {
+    key: `${getPlatformKey(platform)}-test-bun`,
+    label: `${getPlatformLabel(platform)} - test-bun`,
+    depends_on: depends,
+    agents: getTestAgent(platform),
+    cancel_on_build_failing: isMergeQueue(),
+    retry: getRetry(),
+    soft_fail: isMainBranch() ? true : [{ exit_status: 2 }],
+    parallelism: unifiedTests ? undefined : os === "darwin" ? 2 : 10,
+    command:
+      os === "windows"
+        ? `node .\\scripts\\runner.node.mjs ${args.join(" ")}`
+        : `./scripts/runner.node.mjs ${args.join(" ")}`,
+  };
+}
+
+/**
+ * @param {Platform} platform
+ * @param {boolean} [dryRun]
+ * @returns {Step}
+ */
+function getBuildImageStep(platform, dryRun) {
+  const { os, arch, distro, release } = platform;
+  const action = dryRun ? "create-image" : "publish-image";
+  const command = [
+    "node",
+    "./scripts/machine.mjs",
+    action,
+    `--os=${os}`,
+    `--arch=${arch}`,
+    distro && `--distro=${distro}`,
+    `--release=${release}`,
+    "--cloud=aws",
+    "--ci",
+    "--authorized-org=oven-sh",
+  ];
+  return {
+    key: `${getImageKey(platform)}-build-image`,
+    label: `${getImageLabel(platform)} - build-image`,
+    agents: {
+      queue: "build-image",
+    },
+    env: {
+      DEBUG: "1",
+    },
+    retry: getRetry(),
+    command: command.filter(Boolean).join(" "),
+    timeout_in_minutes: 3 * 60,
+  };
+}
+
+/**
+ * @param {Platform[]} [buildPlatforms]
+ * @returns {Step}
+ */
+function getReleaseStep(buildPlatforms) {
+  return {
+    key: "release",
+    label: getBuildkiteEmoji("rocket"),
+    agents: {
+      queue: "test-darwin",
+    },
+    depends_on: buildPlatforms.map(platform => `${getTargetKey(platform)}-build-bun`),
+    command: ".buildkite/scripts/upload-release.sh",
+  };
+}
+
+/**
+ * @typedef {Object} Pipeline
+ * @property {Step[]} [steps]
+ * @property {number} [priority]
+ */
+
+/**
+ * @typedef {Record<string, string | undefined>} Agent
+ */
+
+/**
+ * @typedef {GroupStep | CommandStep | BlockStep} Step
+ */
+
+/**
+ * @typedef {Object} GroupStep
+ * @property {string} key
+ * @property {string} group
+ * @property {Step[]} steps
+ * @property {string[]} [depends_on]
+ */
+
+/**
+ * @typedef {Object} CommandStep
+ * @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
+ */
+
+/**
+ * @typedef {Object} BlockStep
+ * @property {string} key
+ * @property {string} block
+ * @property {string} [prompt]
+ * @property {"passed" | "failed" | "running"} [blocked_state]
+ * @property {(SelectInput | TextInput)[]} [fields]
+ */
+
+/**
+ * @typedef {Object} TextInput
+ * @property {string} key
+ * @property {string} text
+ * @property {string} [default]
+ * @property {boolean} [required]
+ * @property {string} [hint]
+ */
+
+/**
+ * @typedef {Object} SelectInput
+ * @property {string} key
+ * @property {string} select
+ * @property {string | string[]} [default]
+ * @property {boolean} [required]
+ * @property {boolean} [multiple]
+ * @property {string} [hint]
+ * @property {SelectOption[]} [options]
+ */
+
+/**
+ * @typedef {Object} SelectOption
+ * @property {string} label
+ * @property {string} value
+ */
+
+/**
+ * @typedef {Object} PipelineOptions
+ * @property {string | boolean} [skipEverything]
+ * @property {string | boolean} [skipBuilds]
+ * @property {string | boolean} [skipTests]
+ * @property {string | boolean} [forceBuilds]
+ * @property {string | boolean} [forceTests]
+ * @property {string | boolean} [buildImages]
+ * @property {string | boolean} [publishImages]
+ * @property {boolean} [canary]
+ * @property {Profile[]} [buildProfiles]
+ * @property {Platform[]} [buildPlatforms]
+ * @property {Platform[]} [testPlatforms]
+ * @property {string[]} [testFiles]
+ * @property {boolean} [unifiedBuilds]
+ * @property {boolean} [unifiedTests]
+ */
+
+/**
+ * @param {Step} step
+ * @param {(string | undefined)[]} dependsOn
+ * @returns {Step}
+ */
+function getStepWithDependsOn(step, ...dependsOn) {
+  const { depends_on: existingDependsOn = [] } = step;
+  return {
+    ...step,
+    depends_on: [...existingDependsOn, ...dependsOn.filter(Boolean)],
+  };
+}
+
+/**
+ * @returns {BlockStep}
+ */
+function getOptionsStep() {
+  const booleanOptions = [
+    {
+      label: `${getEmoji("true")} Yes`,
+      value: "true",
+    },
+    {
+      label: `${getEmoji("false")} No`,
+      value: "false",
+    },
+  ];
+
+  return {
+    key: "options",
+    block: getBuildkiteEmoji("clipboard"),
+    blocked_state: "running",
+    fields: [
+      {
+        key: "canary",
+        select: "If building, is this a canary build?",
+        hint: "If you are building for a release, this should be false",
+        required: false,
+        default: "true",
+        options: booleanOptions,
+      },
+      {
+        key: "skip-builds",
+        select: "Do you want to skip the build?",
+        hint: "If true, artifacts will be downloaded from the last successful build",
+        required: false,
+        default: "false",
+        options: booleanOptions,
+      },
+      {
+        key: "skip-tests",
+        select: "Do you want to skip the tests?",
+        required: false,
+        default: "false",
+        options: booleanOptions,
+      },
+      {
+        key: "force-builds",
+        select: "Do you want to force run the build?",
+        hint: "If true, the build will run even if no source files have changed",
+        required: false,
+        default: "false",
+        options: booleanOptions,
+      },
+      {
+        key: "force-tests",
+        select: "Do you want to force run the tests?",
+        hint: "If true, the tests will run even if no test files have changed",
+        required: false,
+        default: "false",
+        options: booleanOptions,
+      },
+      {
+        key: "build-profiles",
+        select: "If building, which profiles do you want to build?",
+        required: false,
+        multiple: true,
+        default: ["release"],
+        options: [
+          {
+            label: `${getEmoji("release")} Release`,
+            value: "release",
+          },
+          {
+            label: `${getEmoji("assert")} Release with Assertions`,
+            value: "assert",
+          },
+          {
+            label: `${getEmoji("debug")} Debug`,
+            value: "debug",
+          },
+        ],
+      },
+      {
+        key: "build-platforms",
+        select: "If building, which platforms do you want to build?",
+        hint: "If this is left blank, all platforms are built",
+        required: false,
+        multiple: true,
+        default: [],
+        options: buildPlatforms.map(platform => {
+          const { os, arch, abi, baseline } = platform;
+          let label = `${getEmoji(os)} ${arch}`;
+          if (abi) {
+            label += `-${abi}`;
+          }
+          if (baseline) {
+            label += `-baseline`;
+          }
+          return {
+            label,
+            value: getTargetKey(platform),
+          };
+        }),
+      },
+      {
+        key: "test-platforms",
+        select: "If testing, which platforms do you want to test?",
+        hint: "If this is left blank, all platforms are tested",
+        required: false,
+        multiple: true,
+        default: [],
+        options: [...new Map(testPlatforms.map(platform => [getImageKey(platform), platform])).entries()].map(
+          ([key, platform]) => {
+            const { os, arch, abi, distro, release } = platform;
+            let label = `${getEmoji(os)} ${arch}`;
+            if (abi) {
+              label += `-${abi}`;
+            }
+            if (distro) {
+              label += ` ${distro}`;
+            }
+            if (release) {
+              label += ` ${release}`;
+            }
+            return {
+              label,
+              value: key,
+            };
+          },
+        ),
+      },
+      {
+        key: "test-files",
+        text: "If testing, which files do you want to test?",
+        hint: "If specified, only run test paths that include the list of strings (e.g. 'test/js', 'test/cli/hot/watch.ts')",
+        required: false,
+      },
+      {
+        key: "build-images",
+        select: "Do you want to re-build the base images?",
+        hint: "This can take 2-3 hours to complete, only do so if you've tested locally",
+        required: false,
+        default: "false",
+        options: booleanOptions,
+      },
+      {
+        key: "publish-images",
+        select: "Do you want to re-build and publish the base images?",
+        hint: "This can take 2-3 hours to complete, only do so if you've tested locally",
+        required: false,
+        default: "false",
+        options: booleanOptions,
+      },
+      {
+        key: "unified-builds",
+        select: "Do you want to build each platform in a single step?",
+        hint: "If true, builds will not be split into seperate steps (this will likely slow down the build)",
+        required: false,
+        default: "false",
+        options: booleanOptions,
+      },
+      {
+        key: "unified-tests",
+        select: "Do you want to run tests in a single step?",
+        hint: "If true, tests will not be split into seperate steps (this will be very slow)",
+        required: false,
+        default: "false",
+        options: booleanOptions,
+      },
+    ],
+  };
+}
+
+/**
+ * @returns {Step}
+ */
+function getOptionsApplyStep() {
+  const command = getEnv("BUILDKITE_COMMAND");
+  return {
+    key: "options-apply",
+    label: getBuildkiteEmoji("gear"),
+    command: `${command} --apply`,
+    depends_on: ["options"],
+    agents: {
+      queue: getEnv("BUILDKITE_AGENT_META_DATA_QUEUE", false),
+    },
+  };
+}
+
+/**
+ * @returns {Promise<PipelineOptions | undefined>}
+ */
+async function getPipelineOptions() {
+  const isManual = isBuildManual();
+  if (isManual && !process.argv.includes("--apply")) {
+    return;
+  }
+
+  const buildPlatformsMap = new Map(buildPlatforms.map(platform => [getTargetKey(platform), platform]));
+  const testPlatformsMap = new Map(testPlatforms.map(platform => [getPlatformKey(platform), platform]));
+
+  if (isManual) {
+    const { fields } = getOptionsStep();
+    const keys = fields?.map(({ key }) => key) ?? [];
+    const values = await Promise.all(keys.map(getBuildMetadata));
+    const options = Object.fromEntries(keys.map((key, index) => [key, values[index]]));
+
+    /**
+     * @param {string} value
+     * @returns {string[] | undefined}
+     */
+    const parseArray = value =>
+      value
+        ?.split("\n")
+        ?.map(item => item.trim())
+        ?.filter(Boolean);
+
+    const buildPlatformKeys = parseArray(options["build-platforms"]);
+    const testPlatformKeys = parseArray(options["test-platforms"]);
+    return {
+      canary: parseBoolean(options["canary"]),
+      skipBuilds: parseBoolean(options["skip-builds"]),
+      forceBuilds: parseBoolean(options["force-builds"]),
+      skipTests: parseBoolean(options["skip-tests"]),
+      testFiles: parseArray(options["test-files"]),
+      buildImages: parseBoolean(options["build-images"]),
+      publishImages: parseBoolean(options["publish-images"]),
+      unifiedBuilds: parseBoolean(options["unified-builds"]),
+      unifiedTests: parseBoolean(options["unified-tests"]),
+      buildProfiles: parseArray(options["build-profiles"]),
+      buildPlatforms: buildPlatformKeys?.length
+        ? buildPlatformKeys.map(key => buildPlatformsMap.get(key))
+        : Array.from(buildPlatformsMap.values()),
+      testPlatforms: testPlatformKeys?.length
+        ? testPlatformKeys.map(key => testPlatformsMap.get(key))
+        : Array.from(testPlatformsMap.values()),
+    };
+  }
+
+  const commitMessage = getCommitMessage();
+
+  /**
+   * @param {RegExp} pattern
+   * @returns {string | boolean}
+   */
+  const parseOption = pattern => {
+    const match = pattern.exec(commitMessage);
+    if (match) {
+      const [, value] = match;
+      return value;
+    }
+    return false;
+  };
+
+  return {
+    canary:
+      !parseBoolean(getEnv("RELEASE", false) || "false") &&
+      !/\[(release|build release|release build)\]/i.test(commitMessage),
+    skipEverything: parseOption(/\[(skip ci|no ci)\]/i),
+    skipBuilds: parseOption(/\[(skip builds?|no builds?|only tests?)\]/i),
+    forceBuilds: parseOption(/\[(force builds?)\]/i),
+    skipTests: parseOption(/\[(skip tests?|no tests?|only builds?)\]/i),
+    buildPlatforms: Array.from(buildPlatformsMap.values()),
+    testPlatforms: Array.from(testPlatformsMap.values()),
+    buildProfiles: ["release"],
+  };
+}
+
+/**
+ * @param {PipelineOptions} [options]
+ * @returns {Promise<Pipeline | undefined>}
+ */
+async function getPipeline(options = {}) {
+  const priority = getPriority();
+
+  if (isBuildManual() && !Object.keys(options).length) {
+    return {
+      priority,
+      steps: [getOptionsStep(), getOptionsApplyStep()],
+    };
+  }
+
+  const { skipEverything } = options;
+  if (skipEverything) {
+    return;
+  }
+
+  const { buildProfiles = [], buildPlatforms = [], testPlatforms = [], buildImages, publishImages } = options;
+  const imagePlatforms = new Map(
+    buildImages || publishImages
+      ? [...buildPlatforms, ...testPlatforms]
+          .filter(({ os }) => os === "linux" || os === "windows")
+          .map(platform => [getImageKey(platform), platform])
+      : [],
+  );
+
+  /** @type {Step[]} */
+  const steps = [];
+
+  if (imagePlatforms.size) {
+    steps.push({
+      key: "build-images",
+      group: getBuildkiteEmoji("aws"),
+      steps: [...imagePlatforms.values()].map(platform => getBuildImageStep(platform, !publishImages)),
+    });
+  }
+
+  const { skipBuilds, forceBuilds, unifiedBuilds } = options;
+
+  /** @type {string | undefined} */
+  let buildId;
+  if (skipBuilds && !forceBuilds) {
+    const lastBuild = await getLastSuccessfulBuild();
+    if (lastBuild) {
+      const { id } = lastBuild;
+      buildId = id;
+    } else {
+      console.warn("No last successful build found, must force builds...");
+    }
+  }
+
+  if (!buildId) {
+    steps.push(
+      ...buildPlatforms
+        .flatMap(platform => buildProfiles.map(profile => ({ ...platform, profile })))
+        .map(target => {
+          const imageKey = getImageKey(target);
+          const imagePlatform = imagePlatforms.get(imageKey);
+
+          return getStepWithDependsOn(
+            {
+              key: getTargetKey(target),
+              group: getTargetLabel(target),
+              steps: unifiedBuilds
+                ? [getBuildBunStep(target)]
+                : [
+                    getBuildVendorStep(target),
+                    getBuildCppStep(target),
+                    getBuildZigStep(target),
+                    getLinkBunStep(target),
+                  ],
+            },
+            imagePlatform ? `${imageKey}-build-image` : undefined,
+          );
+        }),
+    );
+  }
+
+  const { skipTests, forceTests, unifiedTests, testFiles } = options;
+  if (!skipTests || forceTests) {
+    steps.push(
+      ...testPlatforms
+        .flatMap(platform => buildProfiles.map(profile => ({ ...platform, profile })))
+        .map(target => ({
+          key: getTargetKey(target),
+          group: getTargetLabel(target),
+          steps: [getTestBunStep(target, { unifiedTests, testFiles, buildId })],
+        })),
+    );
+  }
+
+  if (isMainBranch()) {
+    steps.push(getReleaseStep(buildPlatforms));
+  }
+
+  /** @type {Map<string, GroupStep>} */
+  const stepsByGroup = new Map();
+
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    if (!("group" in step)) {
+      continue;
+    }
+
+    const { group, steps: groupSteps } = step;
+    if (stepsByGroup.has(group)) {
+      stepsByGroup.get(group).steps.push(...groupSteps);
+    } else {
+      stepsByGroup.set(group, step);
+    }
+
+    steps[i] = undefined;
+  }
+
+  return {
+    priority,
+    steps: [...steps.filter(step => typeof step !== "undefined"), ...Array.from(stepsByGroup.values())],
+  };
+}
+
+async function main() {
+  startGroup("Generating options...");
+  const options = await getPipelineOptions();
+  if (options) {
+    console.log("Generated options:", options);
+  }
+
+  startGroup("Generating pipeline...");
+  const pipeline = await getPipeline(options);
+  if (!pipeline) {
+    console.log("Generated pipeline is empty, skipping...");
+    return;
+  }
+
+  const content = toYaml(pipeline);
+  const contentPath = join(process.cwd(), ".buildkite", "ci.yml");
+  writeFile(contentPath, content);
+
+  console.log("Generated pipeline:");
+  console.log(" - Path:", contentPath);
+  console.log(" - Size:", (content.length / 1024).toFixed(), "KB");
+
+  if (isBuildkite) {
+    startGroup("Uploading pipeline...");
+    try {
+      await spawnSafe(["buildkite-agent", "pipeline", "upload", contentPath], { stdio: "inherit" });
+    } finally {
+      await uploadArtifact(contentPath);
+    }
+  }
+}
+
+await main();
diff --git a/.buildkite/ci.yml b/.buildkite/ci.yml
deleted file mode 100644
index a0ab6dcf03..0000000000
--- a/.buildkite/ci.yml
+++ /dev/null
@@ -1,790 +0,0 @@
-# Build and test Bun on macOS, Linux, and Windows.
-# https://buildkite.com/docs/pipelines/defining-steps
-#
-# If a step has the `robobun: true` label, robobun will listen
-# to webhooks from Buildkite and provision a VM to run the step.
-#
-# Changes to this file will be automatically uploaded on the next run
-# for a particular commit.
-
-steps:
-  # macOS aarch64
-  - key: "darwin-aarch64"
-    group: ":darwin: aarch64"
-    steps:
-      - key: "darwin-aarch64-build-deps"
-        label: ":darwin: aarch64 - build-deps"
-        agents:
-          queue: "build-darwin"
-          os: "darwin"
-          arch: "aarch64"
-        command:
-          - "bun run build:ci --target dependencies"
-
-      - key: "darwin-aarch64-build-cpp"
-        label: ":darwin: aarch64 - build-cpp"
-        agents:
-          queue: "build-darwin"
-          os: "darwin"
-          arch: "aarch64"
-        env:
-          BUN_CPP_ONLY: "ON"
-        command:
-          - "bun run build:ci --target bun"
-
-      - key: "darwin-aarch64-build-zig"
-        label: ":darwin: aarch64 - build-zig"
-        agents:
-          queue: "build-zig"
-        command:
-          - "bun run build:ci --target bun-zig --toolchain darwin-aarch64"
-
-      - key: "darwin-aarch64-build-bun"
-        label: ":darwin: aarch64 - build-bun"
-        agents:
-          queue: "build-darwin"
-          os: "darwin"
-          arch: "aarch64"
-        depends_on:
-          - "darwin-aarch64-build-deps"
-          - "darwin-aarch64-build-cpp"
-          - "darwin-aarch64-build-zig"
-        env:
-          BUN_LINK_ONLY: "ON"
-        command:
-          - "bun run build:ci --target bun"
-
-      - key: "darwin-aarch64-test-macos-14"
-        label: ":darwin: 14 aarch64 - test-bun"
-        if: "build.branch != 'main'"
-        parallelism: 3
-        soft_fail:
-          - exit_status: 2
-        retry:
-          automatic:
-            - exit_status: 1
-              limit: 1
-            - exit_status: -1
-              limit: 3
-            - exit_status: 255
-              limit: 3
-            - signal_reason: agent_stop
-              limit: 3
-            - signal: SIGTERM
-              limit: 3
-        depends_on:
-          - "darwin-aarch64-build-bun"
-        agents:
-          queue: "test-darwin"
-          os: "darwin"
-          arch: "aarch64"
-          release: "14"
-        command:
-          - "./scripts/runner.node.mjs --step darwin-aarch64-build-bun"
-
-      - key: "darwin-aarch64-test-macos-13"
-        label: ":darwin: 13 aarch64 - test-bun"
-        if: "build.branch != 'main'"
-        parallelism: 3
-        soft_fail:
-          - exit_status: 2
-        retry:
-          automatic:
-            - exit_status: 1
-              limit: 1
-            - exit_status: -1
-              limit: 3
-            - exit_status: 255
-              limit: 3
-            - signal_reason: agent_stop
-              limit: 3
-            - signal: SIGTERM
-              limit: 3
-        depends_on:
-          - "darwin-aarch64-build-bun"
-        agents:
-          queue: "test-darwin"
-          os: "darwin"
-          arch: "aarch64"
-          release: "13"
-        command:
-          - "./scripts/runner.node.mjs --step darwin-aarch64-build-bun"
-
-  # macOS x64
-  - key: "darwin-x64"
-    group: ":darwin: x64"
-    steps:
-      - key: "darwin-x64-build-deps"
-        label: ":darwin: x64 - build-deps"
-        agents:
-          queue: "build-darwin"
-          os: "darwin"
-          arch: "x64"
-        command:
-          - "bun run build:ci --target dependencies"
-
-      - key: "darwin-x64-build-cpp"
-        label: ":darwin: x64 - build-cpp"
-        agents:
-          queue: "build-darwin"
-          os: "darwin"
-          arch: "x64"
-        env:
-          BUN_CPP_ONLY: "ON"
-        command:
-          - "bun run build:ci --target bun"
-
-      - key: "darwin-x64-build-zig"
-        label: ":darwin: x64 - build-zig"
-        agents:
-          queue: "build-zig"
-        command:
-          - "bun run build:ci --target bun-zig --toolchain darwin-x64"
-
-      - key: "darwin-x64-build-bun"
-        label: ":darwin: x64 - build-bun"
-        agents:
-          queue: "build-darwin"
-          os: "darwin"
-          arch: "x64"
-        depends_on:
-          - "darwin-x64-build-deps"
-          - "darwin-x64-build-cpp"
-          - "darwin-x64-build-zig"
-        env:
-          BUN_LINK_ONLY: "ON"
-        command:
-          - "bun run build:ci --target bun"
-
-      - key: "darwin-x64-test-macos-14"
-        label: ":darwin: 14 x64 - test-bun"
-        if: "build.branch != 'main'"
-        parallelism: 3
-        soft_fail:
-          - exit_status: 2
-        retry:
-          automatic:
-            - exit_status: 1
-              limit: 1
-            - exit_status: -1
-              limit: 3
-            - exit_status: 255
-              limit: 3
-            - signal_reason: agent_stop
-              limit: 3
-            - signal: SIGTERM
-              limit: 3
-        depends_on:
-          - "darwin-x64-build-bun"
-        agents:
-          queue: "test-darwin"
-          os: "darwin"
-          arch: "x64"
-          release: "14"
-        command:
-          - "./scripts/runner.node.mjs --step darwin-x64-build-bun"
-
-      - key: "darwin-x64-test-macos-13"
-        label: ":darwin: 13 x64 - test-bun"
-        if: "build.branch != 'main'"
-        parallelism: 3
-        soft_fail:
-          - exit_status: 2
-        retry:
-          automatic:
-            - exit_status: 1
-              limit: 1
-            - exit_status: -1
-              limit: 3
-            - exit_status: 255
-              limit: 3
-            - signal_reason: agent_stop
-              limit: 3
-            - signal: SIGTERM
-              limit: 3
-        depends_on:
-          - "darwin-x64-build-bun"
-        agents:
-          queue: "test-darwin"
-          os: "darwin"
-          arch: "x64"
-          release: "13"
-        command:
-          - "./scripts/runner.node.mjs --step darwin-x64-build-bun"
-
-  # Linux x64
-  - key: "linux-x64"
-    group: ":linux: x64"
-    steps:
-      - key: "linux-x64-build-deps"
-        label: ":linux: x64 - build-deps"
-        agents:
-          queue: "build-linux"
-          os: "linux"
-          arch: "x64"
-        command:
-          - "bun run build:ci --target dependencies"
-
-      - key: "linux-x64-build-cpp"
-        label: ":linux: x64 - build-cpp"
-        agents:
-          queue: "build-linux"
-          os: "linux"
-          arch: "x64"
-        env:
-          BUN_CPP_ONLY: "ON"
-        command:
-          - "bun run build:ci --target bun"
-
-      - key: "linux-x64-build-zig"
-        label: ":linux: x64 - build-zig"
-        agents:
-          queue: "build-zig"
-        command:
-          - "bun run build:ci --target bun-zig --toolchain linux-x64"
-
-      - key: "linux-x64-build-bun"
-        label: ":linux: x64 - build-bun"
-        agents:
-          queue: "build-linux"
-          os: "linux"
-          arch: "x64"
-        depends_on:
-          - "linux-x64-build-deps"
-          - "linux-x64-build-cpp"
-          - "linux-x64-build-zig"
-        env:
-          BUN_LINK_ONLY: "ON"
-        command:
-          - "bun run build:ci --target bun"
-
-      - key: "linux-x64-test-debian-12"
-        label: ":debian: 12 x64 - test-bun"
-        if: "build.branch != 'main'"
-        parallelism: 10
-        soft_fail:
-          - exit_status: 2
-        retry:
-          automatic:
-            - exit_status: 1
-              limit: 1
-            - exit_status: -1
-              limit: 3
-            - exit_status: 255
-              limit: 3
-            - signal_reason: agent_stop
-              limit: 3
-            - signal: SIGTERM
-              limit: 3
-        depends_on:
-          - "linux-x64-build-bun"
-        agents:
-          robobun: "true"
-          os: "linux"
-          arch: "x64"
-          distro: "debian"
-          release: "12"
-        command:
-          - "./scripts/runner.node.mjs --step linux-x64-build-bun"
-
-      - key: "linux-x64-test-ubuntu-2204"
-        label: ":ubuntu: 22.04 x64 - test-bun"
-        if: "build.branch != 'main'"
-        parallelism: 10
-        soft_fail:
-          - exit_status: 2
-        retry:
-          automatic:
-            - exit_status: 1
-              limit: 1
-            - exit_status: -1
-              limit: 3
-            - exit_status: 255
-              limit: 3
-            - signal_reason: agent_stop
-              limit: 3
-            - signal: SIGTERM
-              limit: 3
-        depends_on:
-          - "linux-x64-build-bun"
-        agents:
-          robobun: "true"
-          os: "linux"
-          arch: "x64"
-          distro: "ubuntu"
-          release: "22.04"
-        command:
-          - "./scripts/runner.node.mjs --step linux-x64-build-bun"
-
-      - key: "linux-x64-test-ubuntu-2004"
-        label: ":ubuntu: 20.04 x64 - test-bun"
-        if: "build.branch != 'main'"
-        parallelism: 10
-        soft_fail:
-          - exit_status: 2
-        retry:
-          automatic:
-            - exit_status: 1
-              limit: 1
-            - exit_status: -1
-              limit: 3
-            - exit_status: 255
-              limit: 3
-            - signal_reason: agent_stop
-              limit: 3
-            - signal: SIGTERM
-              limit: 3
-        depends_on:
-          - "linux-x64-build-bun"
-        agents:
-          robobun: "true"
-          os: "linux"
-          arch: "x64"
-          distro: "ubuntu"
-          release: "20.04"
-        command:
-          - "./scripts/runner.node.mjs --step linux-x64-build-bun"
-
-  # Linux x64-baseline
-  - key: "linux-x64-baseline"
-    group: ":linux: x64-baseline"
-    steps:
-      - key: "linux-x64-baseline-build-deps"
-        label: ":linux: x64-baseline - build-deps"
-        agents:
-          queue: "build-linux"
-          os: "linux"
-          arch: "x64"
-        env:
-          ENABLE_BASELINE: "ON"
-        command:
-          - "bun run build:ci --target dependencies"
-
-      - key: "linux-x64-baseline-build-cpp"
-        label: ":linux: x64-baseline - build-cpp"
-        agents:
-          queue: "build-linux"
-          os: "linux"
-          arch: "x64"
-        env:
-          ENABLE_BASELINE: "ON"
-          BUN_CPP_ONLY: "ON"
-        command:
-          - "bun run build:ci --target bun"
-
-      - key: "linux-x64-baseline-build-zig"
-        label: ":linux: x64-baseline - build-zig"
-        agents:
-          queue: "build-zig"
-        env:
-          ENABLE_BASELINE: "ON"
-        command:
-          - "bun run build:ci --target bun-zig --toolchain linux-x64-baseline"
-
-      - key: "linux-x64-baseline-build-bun"
-        label: ":linux: x64-baseline - build-bun"
-        agents:
-          queue: "build-linux"
-          os: "linux"
-          arch: "x64"
-        depends_on:
-          - "linux-x64-baseline-build-deps"
-          - "linux-x64-baseline-build-cpp"
-          - "linux-x64-baseline-build-zig"
-        env:
-          ENABLE_BASELINE: "ON"
-          BUN_LINK_ONLY: "ON"
-        command:
-          - "bun run build:ci --target bun"
-
-      - key: "linux-x64-baseline-test-debian-12"
-        label: ":debian: 12 x64-baseline - test-bun"
-        if: "build.branch != 'main'"
-        parallelism: 10
-        soft_fail:
-          - exit_status: 2
-        retry:
-          automatic:
-            - exit_status: 1
-              limit: 1
-            - exit_status: -1
-              limit: 3
-            - exit_status: 255
-              limit: 3
-            - signal_reason: agent_stop
-              limit: 3
-            - signal: SIGTERM
-              limit: 3
-        depends_on:
-          - "linux-x64-baseline-build-bun"
-        agents:
-          robobun: "true"
-          os: "linux"
-          arch: "x64"
-          distro: "debian"
-          release: "12"
-        command:
-          - "./scripts/runner.node.mjs --step linux-x64-baseline-build-bun"
-
-      - key: "linux-x64-baseline-test-ubuntu-2204"
-        label: ":ubuntu: 22.04 x64-baseline - test-bun"
-        if: "build.branch != 'main'"
-        parallelism: 10
-        soft_fail:
-          - exit_status: 2
-        retry:
-          automatic:
-            - exit_status: 1
-              limit: 1
-            - exit_status: -1
-              limit: 3
-            - exit_status: 255
-              limit: 3
-            - signal_reason: agent_stop
-              limit: 3
-            - signal: SIGTERM
-              limit: 3
-        depends_on:
-          - "linux-x64-baseline-build-bun"
-        agents:
-          robobun: "true"
-          os: "linux"
-          arch: "x64"
-          distro: "ubuntu"
-          release: "22.04"
-        command:
-          - "./scripts/runner.node.mjs --step linux-x64-baseline-build-bun"
-
-      - key: "linux-x64-baseline-test-ubuntu-2004"
-        label: ":ubuntu: 20.04 x64-baseline - test-bun"
-        if: "build.branch != 'main'"
-        parallelism: 10
-        soft_fail:
-          - exit_status: 2
-        retry:
-          automatic:
-            - exit_status: 1
-              limit: 1
-            - exit_status: -1
-              limit: 3
-            - exit_status: 255
-              limit: 3
-            - signal_reason: agent_stop
-              limit: 3
-            - signal: SIGTERM
-              limit: 3
-        depends_on:
-          - "linux-x64-baseline-build-bun"
-        agents:
-          robobun: "true"
-          os: "linux"
-          arch: "x64"
-          distro: "ubuntu"
-          release: "20.04"
-        command:
-          - "./scripts/runner.node.mjs --step linux-x64-baseline-build-bun"
-
-  # Linux aarch64
-  - key: "linux-aarch64"
-    group: ":linux: aarch64"
-    steps:
-      - key: "linux-aarch64-build-deps"
-        label: ":linux: aarch64 - build-deps"
-        agents:
-          queue: "build-linux"
-          os: "linux"
-          arch: "aarch64"
-        command:
-          - "bun run build:ci --target dependencies"
-
-      - key: "linux-aarch64-build-cpp"
-        label: ":linux: aarch64 - build-cpp"
-        agents:
-          queue: "build-linux"
-          os: "linux"
-          arch: "aarch64"
-        env:
-          BUN_CPP_ONLY: "ON"
-        command:
-          - "bun run build:ci --target bun"
-
-      - key: "linux-aarch64-build-zig"
-        label: ":linux: aarch64 - build-zig"
-        agents:
-          queue: "build-zig"
-        command:
-          - "bun run build:ci --target bun-zig --toolchain linux-aarch64"
-
-      - key: "linux-aarch64-build-bun"
-        label: ":linux: aarch64 - build-bun"
-        agents:
-          queue: "build-linux"
-          os: "linux"
-          arch: "aarch64"
-        depends_on:
-          - "linux-aarch64-build-deps"
-          - "linux-aarch64-build-cpp"
-          - "linux-aarch64-build-zig"
-        env:
-          BUN_LINK_ONLY: "ON"
-        command:
-          - "bun run build:ci --target bun"
-
-      - key: "linux-aarch64-test-debian-12"
-        label: ":debian: 12 aarch64 - test-bun"
-        if: "build.branch != 'main'"
-        parallelism: 10
-        soft_fail:
-          - exit_status: 2
-        retry:
-          automatic:
-            - exit_status: 1
-              limit: 1
-            - exit_status: -1
-              limit: 3
-            - exit_status: 255
-              limit: 3
-            - signal_reason: agent_stop
-              limit: 3
-            - signal: SIGTERM
-              limit: 3
-        depends_on:
-          - "linux-aarch64-build-bun"
-        agents:
-          robobun: "true"
-          os: "linux"
-          arch: "aarch64"
-          distro: "debian"
-          release: "12"
-        command:
-          - "./scripts/runner.node.mjs --step linux-aarch64-build-bun"
-
-      - key: "linux-aarch64-test-ubuntu-2204"
-        label: ":ubuntu: 22.04 aarch64 - test-bun"
-        if: "build.branch != 'main'"
-        parallelism: 10
-        soft_fail:
-          - exit_status: 2
-        retry:
-          automatic:
-            - exit_status: 1
-              limit: 1
-            - exit_status: -1
-              limit: 3
-            - exit_status: 255
-              limit: 3
-            - signal_reason: agent_stop
-              limit: 3
-            - signal: SIGTERM
-              limit: 3
-        depends_on:
-          - "linux-aarch64-build-bun"
-        agents:
-          robobun: "true"
-          os: "linux"
-          arch: "aarch64"
-          distro: "ubuntu"
-          release: "22.04"
-        command:
-          - "./scripts/runner.node.mjs --step linux-aarch64-build-bun"
-
-      - key: "linux-aarch64-test-ubuntu-2004"
-        label: ":ubuntu: 20.04 aarch64 - test-bun"
-        if: "build.branch != 'main'"
-        parallelism: 10
-        soft_fail:
-          - exit_status: 2
-        retry:
-          automatic:
-            - exit_status: 1
-              limit: 1
-            - exit_status: -1
-              limit: 3
-            - exit_status: 255
-              limit: 3
-            - signal_reason: agent_stop
-              limit: 3
-            - signal: SIGTERM
-              limit: 3
-        depends_on:
-          - "linux-aarch64-build-bun"
-        agents:
-          robobun: "true"
-          os: "linux"
-          arch: "aarch64"
-          distro: "ubuntu"
-          release: "20.04"
-        command:
-          - "./scripts/runner.node.mjs --step linux-aarch64-build-bun"
-
-  # Windows x64
-  - key: "windows-x64"
-    group: ":windows: x64"
-    steps:
-      - key: "windows-x64-build-deps"
-        label: ":windows: x64 - build-deps"
-        agents:
-          queue: "build-windows"
-          os: "windows"
-          arch: "x64"
-        retry:
-          automatic:
-            - exit_status: 255
-              limit: 5
-        command:
-          - "bun run build:ci --target dependencies"
-
-      - key: "windows-x64-build-cpp"
-        label: ":windows: x64 - build-cpp"
-        agents:
-          queue: "build-windows"
-          os: "windows"
-          arch: "x64"
-        retry:
-          automatic:
-            - exit_status: 255
-              limit: 5
-        env:
-          BUN_CPP_ONLY: "ON"
-        command:
-          - "bun run build:ci --target bun"
-
-      - key: "windows-x64-build-zig"
-        label: ":windows: x64 - build-zig"
-        agents:
-          queue: "build-zig"
-        command:
-          - "bun run build:ci --target bun-zig --toolchain windows-x64"
-
-      - key: "windows-x64-build-bun"
-        label: ":windows: x64 - build-bun"
-        agents:
-          queue: "build-windows"
-          os: "windows"
-          arch: "x64"
-        depends_on:
-          - "windows-x64-build-deps"
-          - "windows-x64-build-cpp"
-          - "windows-x64-build-zig"
-        retry:
-          automatic:
-            - exit_status: 255
-              limit: 5
-        env:
-          BUN_LINK_ONLY: "ON"
-        command:
-          - "bun run build:ci --target bun"
-
-      - key: "windows-x64-test-bun"
-        label: ":windows: x64 - test-bun"
-        if: "build.branch != 'main'"
-        parallelism: 10
-        soft_fail:
-          - exit_status: 1
-        retry:
-          automatic:
-            - exit_status: -1
-              limit: 3
-            - exit_status: 255
-              limit: 3
-            - signal_reason: agent_stop
-              limit: 3
-            - signal: SIGTERM
-              limit: 3
-        depends_on:
-          - "windows-x64-build-bun"
-        agents:
-          robobun: "true"
-          os: "windows"
-          arch: "x64"
-        command:
-          - "node .\\scripts\\runner.node.mjs --step windows-x64-build-bun"
-
-  # Windows x64-baseline
-  - key: "windows-x64-baseline"
-    group: ":windows: x64-baseline"
-    steps:
-      - key: "windows-x64-baseline-build-deps"
-        label: ":windows: x64-baseline - build-deps"
-        agents:
-          queue: "build-windows"
-          os: "windows"
-          arch: "x64"
-        retry:
-          automatic:
-            - exit_status: 255
-              limit: 5
-        env:
-          ENABLE_BASELINE: "ON"
-        command:
-          - "bun run build:ci --target dependencies"
-
-      - key: "windows-x64-baseline-build-cpp"
-        label: ":windows: x64-baseline - build-cpp"
-        agents:
-          queue: "build-windows"
-          os: "windows"
-          arch: "x64"
-        retry:
-          automatic:
-            - exit_status: 255
-              limit: 5
-        env:
-          ENABLE_BASELINE: "ON"
-          BUN_CPP_ONLY: "ON"
-        command:
-          - "bun run build:ci --target bun"
-
-      - key: "windows-x64-baseline-build-zig"
-        label: ":windows: x64-baseline - build-zig"
-        agents:
-          queue: "build-zig"
-        env:
-          ENABLE_BASELINE: "ON"
-        command:
-          - "bun run build:ci --target bun-zig --toolchain windows-x64-baseline"
-
-      - key: "windows-x64-baseline-build-bun"
-        label: ":windows: x64-baseline - build-bun"
-        agents:
-          queue: "build-windows"
-          os: "windows"
-          arch: "x64"
-        depends_on:
-          - "windows-x64-baseline-build-deps"
-          - "windows-x64-baseline-build-cpp"
-          - "windows-x64-baseline-build-zig"
-        retry:
-          automatic:
-            - exit_status: 255
-              limit: 5
-        env:
-          ENABLE_BASELINE: "ON"
-          BUN_LINK_ONLY: "ON"
-        command:
-          - "bun run build:ci --target bun"
-
-      - key: "windows-x64-baseline-test-bun"
-        label: ":windows: x64-baseline - test-bun"
-        if: "build.branch != 'main'"
-        parallelism: 10
-        soft_fail:
-          - exit_status: 1
-        retry:
-          automatic:
-            - exit_status: -1
-              limit: 3
-            - exit_status: 255
-              limit: 3
-            - signal_reason: agent_stop
-              limit: 3
-            - signal: SIGTERM
-              limit: 3
-        depends_on:
-          - "windows-x64-baseline-build-bun"
-        agents:
-          robobun: "true"
-          os: "windows"
-          arch: "x64"
-        command:
-          - "node .\\scripts\\runner.node.mjs --step windows-x64-baseline-build-bun"
diff --git a/.buildkite/scripts/prepare-build.sh b/.buildkite/scripts/prepare-build.sh
index 1c245d9618..b0b3f9f37e 100755
--- a/.buildkite/scripts/prepare-build.sh
+++ b/.buildkite/scripts/prepare-build.sh
@@ -2,96 +2,10 @@
 
 set -eo pipefail
 
-function assert_build() {
-  if [ -z "$BUILDKITE_REPO" ]; then
-    echo "error: Cannot find repository for this build"
-    exit 1
-  fi
-  if [ -z "$BUILDKITE_COMMIT" ]; then
-    echo "error: Cannot find commit for this build"
-    exit 1
-  fi
-}
-
-function assert_buildkite_agent() {
-  if ! command -v buildkite-agent &> /dev/null; then
-    echo "error: Cannot find buildkite-agent, please install it:"
-    echo "https://buildkite.com/docs/agent/v3/install"
-    exit 1
-  fi
-}
-
-function assert_jq() {
-  assert_command "jq" "jq" "https://stedolan.github.io/jq/"
-}
-
-function assert_curl() {
-  assert_command "curl" "curl" "https://curl.se/download.html"
-}
-
-function assert_command() {
-  local command="$1"
-  local package="$2"
-  local help_url="$3"
-  if ! command -v "$command" &> /dev/null; then
-    echo "warning: $command is not installed, installing..."
-    if command -v brew &> /dev/null; then
-      HOMEBREW_NO_AUTO_UPDATE=1 brew install "$package"
-    else
-      echo "error: Cannot install $command, please install it"
-      if [ -n "$help_url" ]; then
-        echo ""
-        echo "hint: See $help_url for help"
-      fi
-      exit 1
-    fi
-  fi
-}
-
-function assert_release() {
-  if [ "$RELEASE" == "1" ]; then
-    run_command buildkite-agent meta-data set canary "0"
-  fi
-}
-
-function assert_canary() {
-  local canary="$(buildkite-agent meta-data get canary 2>/dev/null)"
-  if [ -z "$canary" ]; then
-    local repo=$(echo "$BUILDKITE_REPO" | sed -E 's#https://github.com/([^/]+)/([^/]+).git#\1/\2#g')
-    local tag="$(curl -sL "https://api.github.com/repos/$repo/releases/latest" | jq -r ".tag_name")"
-    if [ "$tag" == "null" ]; then
-      canary="1"
-    else
-      local revision=$(curl -sL "https://api.github.com/repos/$repo/compare/$tag...$BUILDKITE_COMMIT" | jq -r ".ahead_by")
-      if [ "$revision" == "null" ]; then
-        canary="1"
-      else
-        canary="$revision"
-      fi
-    fi
-    run_command buildkite-agent meta-data set canary "$canary"
-  fi
-}
-
-function upload_buildkite_pipeline() {
-  local path="$1"
-  if [ ! -f "$path" ]; then
-    echo "error: Cannot find pipeline: $path"
-    exit 1
-  fi
-  run_command buildkite-agent pipeline upload "$path"
-}
-
 function run_command() {
   set -x
   "$@"
   { set +x; } 2>/dev/null
 }
 
-assert_build
-assert_buildkite_agent
-assert_jq
-assert_curl
-assert_release
-assert_canary
-upload_buildkite_pipeline ".buildkite/ci.yml"
+run_command node ".buildkite/ci.mjs" "$@"
diff --git a/.buildkite/scripts/upload-release.sh b/.buildkite/scripts/upload-release.sh
index 68b9af307c..b684dfb4a3 100755
--- a/.buildkite/scripts/upload-release.sh
+++ b/.buildkite/scripts/upload-release.sh
@@ -162,6 +162,27 @@ function upload_s3_file() {
   run_command aws --endpoint-url="$AWS_ENDPOINT" s3 cp "$file" "s3://$AWS_BUCKET/$folder/$file"
 }
 
+function send_bench_webhook() {
+  if [ -z "$BENCHMARK_URL" ]; then
+    echo "error: \$BENCHMARK_URL is not set"
+    # exit 1 # TODO: this isn't live yet
+    return
+  fi
+
+  local tag="$1"
+  local commit="$BUILDKITE_COMMIT"
+  local artifact_path="${commit}"
+
+  if [ "$tag" == "canary" ]; then
+    artifact_path="${commit}-canary"
+  fi
+
+  local artifact_url="https://pub-5e11e972747a44bf9aaf9394f185a982.r2.dev/releases/$artifact_path/bun-linux-x64.zip"
+  local webhook_url="$BENCHMARK_URL?tag=$tag&commit=$commit&artifact_url=$artifact_url"
+  
+  curl -X POST "$webhook_url"
+}
+
 function create_release() {
   assert_main
   assert_buildkite_agent
@@ -181,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
@@ -206,6 +233,7 @@ function create_release() {
 
   update_github_release "$tag"
   create_sentry_release "$tag"
+  send_bench_webhook "$tag"
 }
 
 function assert_canary() {
diff --git a/.dockerignore b/.dockerignore
index 239d9da881..6a0ae98134 100644
--- a/.dockerignore
+++ b/.dockerignore
@@ -11,5 +11,8 @@ packages/**/bun-profile
 src/bun.js/WebKit
 src/bun.js/WebKit/LayoutTests
 zig-build
-zig-cache
-zig-out
\ No newline at end of file
+.zig-cache
+zig-out
+build
+vendor
+node_modules
diff --git a/.gitattributes b/.gitattributes
index 7f44299cfc..1b3908f258 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -49,3 +49,5 @@ vendor/brotli/** linguist-vendored
 
 test/js/node/test/fixtures linguist-vendored
 test/js/node/test/common linguist-vendored
+
+test/js/bun/css/files linguist-vendored
diff --git a/.github/ISSUE_TEMPLATE/3-typescript-bug-report.yml b/.github/ISSUE_TEMPLATE/3-typescript-bug-report.yml
index 7b745a4aef..3913e25272 100644
--- a/.github/ISSUE_TEMPLATE/3-typescript-bug-report.yml
+++ b/.github/ISSUE_TEMPLATE/3-typescript-bug-report.yml
@@ -1,6 +1,6 @@
 name: 🇹 TypeScript Type Bug Report
 description: Report an issue with TypeScript types
-labels: [bug, typescript]
+labels: [bug, types]
 body:
 - type: markdown
   attributes:
diff --git a/.github/ISSUE_TEMPLATE/7-install-crash-report.yml b/.github/ISSUE_TEMPLATE/7-install-crash-report.yml
index 2e39becab0..e88397b393 100644
--- a/.github/ISSUE_TEMPLATE/7-install-crash-report.yml
+++ b/.github/ISSUE_TEMPLATE/7-install-crash-report.yml
@@ -11,8 +11,8 @@ body:
   - type: textarea
     id: package_json
     attributes:
-      label: `package.json` file
-      description: Can you upload your `package.json` file? This helps us reproduce the crash.
+      label: "`package.json` file"
+      description: "Can you upload your `package.json` file? This helps us reproduce the crash."
       render: json
   - type: textarea
     id: repro
diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index 193225603c..bb2cca1880 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -7,18 +7,7 @@ on:
   workflow_call:
   workflow_dispatch:
   pull_request:
-    paths:
-      - ".github/workflows/clang-format.yml"
-      - ".clang-format"
-      - "package.json"
-      - "scripts/**"
-      - "cmake/**"
-      - "src/**/*.c"
-      - "src/**/*.cpp"
-      - "src/**/*.h"
-      - "packages/**/*.c"
-      - "packages/**/*.cpp"
-      - "packages/**/*.h"
+  merge_group:
 
 env:
   BUN_VERSION: "1.1.27"
@@ -33,14 +22,7 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v4
         with:
-          sparse-checkout: |
-            .github
-            .clang-format
-            package.json
-            scripts
-            cmake
-            src
-            packages
+          fetch-depth: 0
       - name: Setup Bun
         uses: ./.github/actions/setup-bun
         with:
@@ -50,10 +32,9 @@ jobs:
           curl -fsSL https://apt.llvm.org/llvm.sh | sudo bash -s -- ${{ env.LLVM_VERSION_MAJOR }} all
       - name: Clang Format
         env:
-          ENABLE_CCACHE: OFF
           LLVM_VERSION: ${{ env.LLVM_VERSION }}
         run: |
-          bun run clang-format:diff
+          bun run clang-format
       - name: Commit
         uses: stefanzweifel/git-auto-commit-action@v5
         with:
diff --git a/.github/workflows/clang-tidy.yml b/.github/workflows/clang-tidy.yml
index 27441c7b55..a6f06ad620 100644
--- a/.github/workflows/clang-tidy.yml
+++ b/.github/workflows/clang-tidy.yml
@@ -7,18 +7,7 @@ on:
   workflow_call:
   workflow_dispatch:
   pull_request:
-    paths:
-      - ".github/workflows/clang-tidy.yml"
-      - ".clang-tidy"
-      - "package.json"
-      - "scripts/**"
-      - "cmake/**"
-      - "src/**/*.c"
-      - "src/**/*.cpp"
-      - "src/**/*.h"
-      - "packages/**/*.c"
-      - "packages/**/*.cpp"
-      - "packages/**/*.h"
+  merge_group:
 
 env:
   BUN_VERSION: "1.1.27"
@@ -33,14 +22,7 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v4
         with:
-          sparse-checkout: |
-            .github
-            .clang-tidy
-            package.json
-            scripts
-            cmake
-            src
-            packages
+          fetch-depth: 0
       - name: Setup Bun
         uses: ./.github/actions/setup-bun
         with:
@@ -50,7 +32,6 @@ jobs:
           curl -fsSL https://apt.llvm.org/llvm.sh | sudo bash -s -- ${{ env.LLVM_VERSION_MAJOR }} all
       - name: Clang Tidy
         env:
-          ENABLE_CCACHE: OFF
           LLVM_VERSION: ${{ env.LLVM_VERSION }}
         run: |
           bun run clang-tidy:diff
diff --git a/.github/workflows/labeled.yml b/.github/workflows/labeled.yml
index f0240aa0c3..3529f724b4 100644
--- a/.github/workflows/labeled.yml
+++ b/.github/workflows/labeled.yml
@@ -83,6 +83,26 @@ jobs:
           echo "latest=$(cat LATEST)" >> $GITHUB_OUTPUT
 
           rm -rf is-outdated.txt outdated.txt latest.txt
+      - name: Generate comment text with Sentry Link
+        if: github.event.label.name == 'crash'
+        # ignore if fail
+        continue-on-error: true
+        id: generate-comment-text
+        env:
+          GITHUB_ISSUE_BODY: ${{ github.event.issue.body }}
+          SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_EVENTS_SECRET }}
+        shell: bash
+        run: |
+          bun scripts/associate-issue-with-sentry.ts
+
+          if [[ -f "sentry-link.txt" ]]; then
+            echo "sentry-link=$(cat sentry-link.txt)" >> $GITHUB_OUTPUT
+          fi
+
+          if [[ -f "sentry-id.txt" ]]; then
+            echo "sentry-id=$(cat sentry-id.txt)" >> $GITHUB_OUTPUT
+          fi
+
       - name: Add labels
         uses: actions-cool/issues-helper@v3
         if: github.event.label.name == 'crash'
@@ -92,7 +112,7 @@ jobs:
           issue-number: ${{ github.event.issue.number }}
           labels: ${{ steps.add-labels.outputs.labels }}
       - name: Comment outdated
-        if: steps.add-labels.outputs.is-outdated == 'true' && github.event.label.name == 'crash'
+        if: steps.add-labels.outputs.is-outdated == 'true' && github.event.label.name == 'crash' && steps.generate-comment-text.outputs.sentry-link == ''
         uses: actions-cool/issues-helper@v3
         with:
           actions: "create-comment"
@@ -106,6 +126,40 @@ jobs:
             ```sh
             bun upgrade
             ```
+      - name: Comment with Sentry Link and outdated version
+        if: steps.generate-comment-text.outputs.sentry-link != '' && github.event.label.name == 'crash' && steps.add-labels.outputs.is-outdated == 'true'
+        uses: actions-cool/issues-helper@v3
+        with:
+          actions: "create-comment"
+          token: ${{ secrets.GITHUB_TOKEN }}
+          issue-number: ${{ github.event.issue.number }}
+          body: |
+            @${{ github.event.issue.user.login }}, thank you for reporting this crash. The latest version of Bun is v${{ steps.add-labels.outputs.latest }}, but this crash was reported on Bun v${{ steps.add-labels.outputs.oudated }}.
+
+            Are you able to reproduce this crash on the latest version of Bun?
+
+            ```sh
+            bun upgrade
+            ```
+
+            For Bun's internal tracking, this issue is [${{ steps.generate-comment-text.outputs.sentry-id }}](${{ steps.generate-comment-text.outputs.sentry-link }}).
+
+            <!-- sentry-id: ${{ steps.generate-comment-text.outputs.sentry-id }} -->
+            <!-- sentry-link: ${{ steps.generate-comment-text.outputs.sentry-link }} -->
+      - name: Comment with Sentry Link
+        if: steps.generate-comment-text.outputs.sentry-link != '' && github.event.label.name == 'crash' && steps.add-labels.outputs.is-outdated != 'true'
+        uses: actions-cool/issues-helper@v3
+        with:
+          actions: "create-comment"
+          token: ${{ secrets.GITHUB_TOKEN }}
+          issue-number: ${{ github.event.issue.number }}
+          body: |
+            Thank you for reporting this crash. 
+
+            For Bun's internal tracking, this issue is [${{ steps.generate-comment-text.outputs.sentry-id }}](${{ steps.generate-comment-text.outputs.sentry-link }}).
+
+            <!-- sentry-id: ${{ steps.generate-comment-text.outputs.sentry-id }} -->
+            <!-- sentry-link: ${{ steps.generate-comment-text.outputs.sentry-link }} -->
       - name: Comment needs repro
         if: github.event.label.name == 'needs repro'
         uses: actions-cool/issues-helper@v3
@@ -114,4 +168,4 @@ jobs:
           token: ${{ secrets.GITHUB_TOKEN }}
           issue-number: ${{ github.event.issue.number }}
           body: |
-            Hello @${{ github.event.issue.user.login }}. Please provide a [minimal reproduction](https://stackoverflow.com/help/minimal-reproducible-example) using a GitHub repository, [Replit](https://replit.com/@replit/Bun), or [CodeSandbox](https://codesandbox.io/templates/bun). Issues marked with `needs repro` will be closed if they have no activity within 3 days.
+            Hello @${{ github.event.issue.user.login }}. Please provide a [minimal reproduction](https://stackoverflow.com/help/minimal-reproducible-example) using a GitHub repository, [Replit](https://replit.com/@replit/Bun), [CodeSandbox](https://codesandbox.io/templates/bun), or provide a bulleted list of commands to run that reproduce this issue. Issues marked with `needs repro` will be closed if they have no activity within 3 days.
diff --git a/.github/workflows/lint-cpp.yml b/.github/workflows/lint-cpp.yml
deleted file mode 100644
index 5841745ac3..0000000000
--- a/.github/workflows/lint-cpp.yml
+++ /dev/null
@@ -1,30 +0,0 @@
-name: lint-cpp
-
-permissions:
-  contents: read
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event_name == 'workflow_dispatch' && inputs.run-id  || github.ref }}
-  cancel-in-progress: true
-
-on:
-  workflow_dispatch:
-    inputs:
-      run-id:
-        type: string
-        description: The workflow ID to download artifacts (skips the build step)
-  # pull_request:
-  #   paths:
-  #     - ".github/workflows/lint-cpp.yml"
-  #     - "**/*.cpp"
-  #     - "vendor/**/*"
-  #     - "CMakeLists.txt"
-
-jobs:
-  lint-cpp:
-    if: ${{ !inputs.run-id }}
-    name: Lint C++
-    uses: ./.github/workflows/run-lint-cpp.yml
-    secrets: inherit
-    with:
-      pr-number: ${{ github.event.number }}
diff --git a/.github/workflows/prettier-format.yml b/.github/workflows/prettier-format.yml
index ef7a8fe697..43a407443e 100644
--- a/.github/workflows/prettier-format.yml
+++ b/.github/workflows/prettier-format.yml
@@ -7,18 +7,7 @@ on:
   workflow_call:
   workflow_dispatch:
   pull_request:
-    paths:
-      - ".github/workflows/prettier-format.yml"
-      - "package.json"
-      - "scripts/**"
-      - "**.yml"
-      - "**.json"
-      - "**.js"
-      - "**.jsx"
-      - "**.ts"
-      - "**.tsx"
-      - "**.mjs"
-      - "**.cjs"
+  merge_group:
 
 env:
   BUN_VERSION: "1.1.27"
@@ -30,6 +19,8 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
       - name: Setup Bun
         uses: ./.github/actions/setup-bun
         with:
@@ -38,9 +29,6 @@ jobs:
         run: |
           bun install
       - name: Prettier Format
-        env:
-          ENABLE_CCACHE: OFF
-          SKIP_LLVM: ON
         run: |
           bun run prettier:diff
       - name: Commit
diff --git a/.github/workflows/run-lint-cpp.yml b/.github/workflows/run-lint-cpp.yml
deleted file mode 100644
index 539ec62f20..0000000000
--- a/.github/workflows/run-lint-cpp.yml
+++ /dev/null
@@ -1,84 +0,0 @@
-name: lint-cpp
-
-permissions:
-  contents: read
-env:
-  LLVM_VERSION: 18
-  LC_CTYPE: "en_US.UTF-8"
-  LC_ALL: "en_US.UTF-8"
-
-on:
-  workflow_call:
-    inputs:
-      pr-number:
-        required: true
-        type: number
-
-jobs:
-  lint-cpp:
-    name: Lint C++
-    runs-on: ${{ github.repository_owner == 'oven-sh' && 'macos-13-xlarge' || 'macos-13' }}
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          submodules: recursive
-      - name: Setup Bun
-        uses: ./.github/actions/setup-bun
-        with:
-          bun-version: 1.1.23
-      - name: Install Dependencies
-        env:
-          HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK: 1
-          HOMEBREW_NO_AUTO_UPDATE: 1
-          HOMEBREW_NO_INSTALL_CLEANUP: 1
-        run: |
-          brew install \
-            llvm@${{ env.LLVM_VERSION }} \
-            ninja \
-            coreutils \
-            openssl@1.1 \
-            libiconv \
-            gnu-sed --force --overwrite
-          echo "$(brew --prefix coreutils)/libexec/gnubin" >> $GITHUB_PATH
-          echo "$(brew --prefix llvm@$LLVM_VERSION)/bin" >> $GITHUB_PATH
-          brew link --overwrite llvm@$LLVM_VERSION
-      - name: Bun install
-        run: |
-          bun install
-      - name: clang-tidy
-        id: format
-        env:
-          CPU_TARGET: native
-          BUN_SILENT: 1
-        run: |
-          rm -f did_fail format.log
-          echo "${{ inputs.pr-number }}" > pr-number.txt
-          echo "pr_number=$(cat pr-number.txt)" >> $GITHUB_OUTPUT
-          bun run --silent build:tidy &> >(tee -p format.log) && echo 0 > did_succeed.txt
-          # Upload format.log as github artifact for the workflow
-          if [ -f did_succeed.txt ]; then
-            echo "0" > did_fail.txt
-          else
-            echo "1" > did_fail.txt
-          fi
-          echo "did_fail=$(cat did_fail.txt)" >> $GITHUB_OUTPUT
-
-      - name: Upload format.log
-        uses: actions/upload-artifact@v4
-        with:
-          name: format.log
-          path: format.log
-      - name: Upload PR
-        uses: actions/upload-artifact@v4
-        with:
-          name: pr-number.txt
-          path: pr-number.txt
-      - name: Upload PR
-        uses: actions/upload-artifact@v4
-        with:
-          name: did_fail.txt
-          path: did_fail.txt
-      - name: Fail if formatting failed
-        if: ${{ steps.format.outputs.did_fail == '1' }}
-        run: exit 1
diff --git a/.github/workflows/update-cares.yml b/.github/workflows/update-cares.yml
new file mode 100644
index 0000000000..d5d111b663
--- /dev/null
+++ b/.github/workflows/update-cares.yml
@@ -0,0 +1,92 @@
+name: Update c-ares
+
+on:
+  schedule:
+    - cron: "0 4 * * 0"
+  workflow_dispatch:
+
+jobs:
+  check-update:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Check c-ares version
+        id: check-version
+        run: |
+          set -euo pipefail
+
+          # Extract the commit hash from the line after COMMIT
+          CURRENT_VERSION=$(awk '/[[:space:]]*COMMIT[[:space:]]*$/{getline; gsub(/^[[:space:]]+|[[:space:]]+$/,"",$0); print}' cmake/targets/BuildCares.cmake)
+
+          if [ -z "$CURRENT_VERSION" ]; then
+            echo "Error: Could not find COMMIT line in BuildCares.cmake"
+            exit 1
+          fi
+
+          # Validate that it looks like a git hash
+          if ! [[ $CURRENT_VERSION =~ ^[0-9a-f]{40}$ ]]; then
+            echo "Error: Invalid git hash format in BuildCares.cmake"
+            echo "Found: $CURRENT_VERSION"
+            echo "Expected: 40 character hexadecimal string"
+            exit 1
+          fi
+
+          echo "current=$CURRENT_VERSION" >> $GITHUB_OUTPUT
+
+          LATEST_RELEASE=$(curl -sL https://api.github.com/repos/c-ares/c-ares/releases/latest)
+          if [ -z "$LATEST_RELEASE" ]; then
+            echo "Error: Failed to fetch latest release from GitHub API"
+            exit 1
+          fi
+
+          LATEST_TAG=$(echo "$LATEST_RELEASE" | jq -r '.tag_name')
+          if [ -z "$LATEST_TAG" ] || [ "$LATEST_TAG" = "null" ]; then
+            echo "Error: Could not extract tag name from GitHub API response"
+            exit 1
+          fi
+
+          LATEST_SHA=$(curl -sL "https://api.github.com/repos/c-ares/c-ares/git/ref/tags/$LATEST_TAG" | jq -r '.object.sha')
+          if [ -z "$LATEST_SHA" ] || [ "$LATEST_SHA" = "null" ]; then
+            echo "Error: Could not fetch SHA for tag $LATEST_TAG"
+            exit 1
+          fi
+
+          if ! [[ $LATEST_SHA =~ ^[0-9a-f]{40}$ ]]; then
+            echo "Error: Invalid SHA format received from GitHub"
+            echo "Found: $LATEST_SHA"
+            echo "Expected: 40 character hexadecimal string"
+            exit 1
+          fi
+
+          echo "latest=$LATEST_SHA" >> $GITHUB_OUTPUT
+          echo "tag=$LATEST_TAG" >> $GITHUB_OUTPUT
+
+      - name: Update version if needed
+        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
+        run: |
+          set -euo pipefail
+          # Handle multi-line format where COMMIT and its value are on separate lines
+          sed -i -E '/[[:space:]]*COMMIT[[:space:]]*$/{n;s/[[:space:]]*([0-9a-f]+)[[:space:]]*$/    ${{ steps.check-version.outputs.latest }}/}' cmake/targets/BuildCares.cmake
+
+      - name: Create Pull Request
+        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
+        uses: peter-evans/create-pull-request@v4
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          add-paths: |
+            cmake/targets/BuildCares.cmake
+          commit-message: "deps: update c-ares to ${{ steps.check-version.outputs.tag }} (${{ steps.check-version.outputs.latest }})"
+          title: "deps: update c-ares to ${{ steps.check-version.outputs.tag }}"
+          delete-branch: true
+          branch: deps/update-cares-${{ github.run_number }}
+          body: |
+            ## What does this PR do?
+
+            Updates c-ares to version ${{ steps.check-version.outputs.tag }}
+
+            Auto-updated by [this workflow](https://github.com/oven-sh/bun/actions/workflows/update-cares.yml)
diff --git a/.github/workflows/update-libarchive.yml b/.github/workflows/update-libarchive.yml
new file mode 100644
index 0000000000..f4dce7cfce
--- /dev/null
+++ b/.github/workflows/update-libarchive.yml
@@ -0,0 +1,92 @@
+name: Update libarchive
+
+on:
+  schedule:
+    - cron: "0 3 * * 0"
+  workflow_dispatch:
+
+jobs:
+  check-update:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Check libarchive version
+        id: check-version
+        run: |
+          set -euo pipefail
+
+          # Extract the commit hash from the line after COMMIT
+          CURRENT_VERSION=$(awk '/[[:space:]]*COMMIT[[:space:]]*$/{getline; gsub(/^[[:space:]]+|[[:space:]]+$/,"",$0); print}' cmake/targets/BuildLibArchive.cmake)
+
+          if [ -z "$CURRENT_VERSION" ]; then
+            echo "Error: Could not find COMMIT line in BuildLibArchive.cmake"
+            exit 1
+          fi
+
+          # Validate that it looks like a git hash
+          if ! [[ $CURRENT_VERSION =~ ^[0-9a-f]{40}$ ]]; then
+            echo "Error: Invalid git hash format in BuildLibArchive.cmake"
+            echo "Found: $CURRENT_VERSION"
+            echo "Expected: 40 character hexadecimal string"
+            exit 1
+          fi
+
+          echo "current=$CURRENT_VERSION" >> $GITHUB_OUTPUT
+
+          LATEST_RELEASE=$(curl -sL https://api.github.com/repos/libarchive/libarchive/releases/latest)
+          if [ -z "$LATEST_RELEASE" ]; then
+            echo "Error: Failed to fetch latest release from GitHub API"
+            exit 1
+          fi
+
+          LATEST_TAG=$(echo "$LATEST_RELEASE" | jq -r '.tag_name')
+          if [ -z "$LATEST_TAG" ] || [ "$LATEST_TAG" = "null" ]; then
+            echo "Error: Could not extract tag name from GitHub API response"
+            exit 1
+          fi
+
+          LATEST_SHA=$(curl -sL "https://api.github.com/repos/libarchive/libarchive/git/ref/tags/$LATEST_TAG" | jq -r '.object.sha')
+          if [ -z "$LATEST_SHA" ] || [ "$LATEST_SHA" = "null" ]; then
+            echo "Error: Could not fetch SHA for tag $LATEST_TAG"
+            exit 1
+          fi
+
+          if ! [[ $LATEST_SHA =~ ^[0-9a-f]{40}$ ]]; then
+            echo "Error: Invalid SHA format received from GitHub"
+            echo "Found: $LATEST_SHA"
+            echo "Expected: 40 character hexadecimal string"
+            exit 1
+          fi
+
+          echo "latest=$LATEST_SHA" >> $GITHUB_OUTPUT
+          echo "tag=$LATEST_TAG" >> $GITHUB_OUTPUT
+
+      - name: Update version if needed
+        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
+        run: |
+          set -euo pipefail
+          # Handle multi-line format where COMMIT and its value are on separate lines
+          sed -i -E '/[[:space:]]*COMMIT[[:space:]]*$/{n;s/[[:space:]]*([0-9a-f]+)[[:space:]]*$/    ${{ steps.check-version.outputs.latest }}/}' cmake/targets/BuildLibArchive.cmake
+
+      - name: Create Pull Request
+        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
+        uses: peter-evans/create-pull-request@v4
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          add-paths: |
+            cmake/targets/BuildLibArchive.cmake
+          commit-message: "deps: update libarchive to ${{ steps.check-version.outputs.tag }} (${{ steps.check-version.outputs.latest }})"
+          title: "deps: update libarchive to ${{ steps.check-version.outputs.tag }}"
+          delete-branch: true
+          branch: deps/update-libarchive-${{ github.run_number }}
+          body: |
+            ## What does this PR do?
+
+            Updates libarchive to version ${{ steps.check-version.outputs.tag }}
+
+            Auto-updated by [this workflow](https://github.com/oven-sh/bun/actions/workflows/update-libarchive.yml)
diff --git a/.github/workflows/update-libdeflate.yml b/.github/workflows/update-libdeflate.yml
new file mode 100644
index 0000000000..7e0be86a1c
--- /dev/null
+++ b/.github/workflows/update-libdeflate.yml
@@ -0,0 +1,92 @@
+name: Update libdeflate
+
+on:
+  schedule:
+    - cron: "0 2 * * 0"
+  workflow_dispatch:
+
+jobs:
+  check-update:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Check libdeflate version
+        id: check-version
+        run: |
+          set -euo pipefail
+
+          # Extract the commit hash from the line after COMMIT
+          CURRENT_VERSION=$(awk '/[[:space:]]*COMMIT[[:space:]]*$/{getline; gsub(/^[[:space:]]+|[[:space:]]+$/,"",$0); print}' cmake/targets/BuildLibDeflate.cmake)
+
+          if [ -z "$CURRENT_VERSION" ]; then
+            echo "Error: Could not find COMMIT line in BuildLibDeflate.cmake"
+            exit 1
+          fi
+
+          # Validate that it looks like a git hash
+          if ! [[ $CURRENT_VERSION =~ ^[0-9a-f]{40}$ ]]; then
+            echo "Error: Invalid git hash format in BuildLibDeflate.cmake"
+            echo "Found: $CURRENT_VERSION"
+            echo "Expected: 40 character hexadecimal string"
+            exit 1
+          fi
+
+          echo "current=$CURRENT_VERSION" >> $GITHUB_OUTPUT
+
+          LATEST_RELEASE=$(curl -sL https://api.github.com/repos/ebiggers/libdeflate/releases/latest)
+          if [ -z "$LATEST_RELEASE" ]; then
+            echo "Error: Failed to fetch latest release from GitHub API"
+            exit 1
+          fi
+
+          LATEST_TAG=$(echo "$LATEST_RELEASE" | jq -r '.tag_name')
+          if [ -z "$LATEST_TAG" ] || [ "$LATEST_TAG" = "null" ]; then
+            echo "Error: Could not extract tag name from GitHub API response"
+            exit 1
+          fi
+
+          LATEST_SHA=$(curl -sL "https://api.github.com/repos/ebiggers/libdeflate/git/ref/tags/$LATEST_TAG" | jq -r '.object.sha')
+          if [ -z "$LATEST_SHA" ] || [ "$LATEST_SHA" = "null" ]; then
+            echo "Error: Could not fetch SHA for tag $LATEST_TAG"
+            exit 1
+          fi
+
+          if ! [[ $LATEST_SHA =~ ^[0-9a-f]{40}$ ]]; then
+            echo "Error: Invalid SHA format received from GitHub"
+            echo "Found: $LATEST_SHA"
+            echo "Expected: 40 character hexadecimal string"
+            exit 1
+          fi
+
+          echo "latest=$LATEST_SHA" >> $GITHUB_OUTPUT
+          echo "tag=$LATEST_TAG" >> $GITHUB_OUTPUT
+
+      - name: Update version if needed
+        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
+        run: |
+          set -euo pipefail
+          # Handle multi-line format where COMMIT and its value are on separate lines
+          sed -i -E '/[[:space:]]*COMMIT[[:space:]]*$/{n;s/[[:space:]]*([0-9a-f]+)[[:space:]]*$/    ${{ steps.check-version.outputs.latest }}/}' cmake/targets/BuildLibDeflate.cmake
+
+      - name: Create Pull Request
+        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
+        uses: peter-evans/create-pull-request@v4
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          add-paths: |
+            cmake/targets/BuildLibDeflate.cmake
+          commit-message: "deps: update libdeflate to ${{ steps.check-version.outputs.tag }} (${{ steps.check-version.outputs.latest }})"
+          title: "deps: update libdeflate to ${{ steps.check-version.outputs.tag }}"
+          delete-branch: true
+          branch: deps/update-libdeflate-${{ github.run_number }}
+          body: |
+            ## What does this PR do?
+
+            Updates libdeflate to version ${{ steps.check-version.outputs.tag }}
+
+            Auto-updated by [this workflow](https://github.com/oven-sh/bun/actions/workflows/update-libdeflate.yml)
diff --git a/.github/workflows/update-lolhtml.yml b/.github/workflows/update-lolhtml.yml
new file mode 100644
index 0000000000..f48c4b5ce9
--- /dev/null
+++ b/.github/workflows/update-lolhtml.yml
@@ -0,0 +1,92 @@
+name: Update lolhtml
+
+on:
+  schedule:
+    - cron: "0 1 * * 0"
+  workflow_dispatch:
+
+jobs:
+  check-update:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Check lolhtml version
+        id: check-version
+        run: |
+          set -euo pipefail
+
+          # Extract the commit hash from the line after COMMIT
+          CURRENT_VERSION=$(awk '/[[:space:]]*COMMIT[[:space:]]*$/{getline; gsub(/^[[:space:]]+|[[:space:]]+$/,"",$0); print}' cmake/targets/BuildLolHtml.cmake)
+
+          if [ -z "$CURRENT_VERSION" ]; then
+            echo "Error: Could not find COMMIT line in BuildLolHtml.cmake"
+            exit 1
+          fi
+
+          # Validate that it looks like a git hash
+          if ! [[ $CURRENT_VERSION =~ ^[0-9a-f]{40}$ ]]; then
+            echo "Error: Invalid git hash format in BuildLolHtml.cmake"
+            echo "Found: $CURRENT_VERSION"
+            echo "Expected: 40 character hexadecimal string"
+            exit 1
+          fi
+
+          echo "current=$CURRENT_VERSION" >> $GITHUB_OUTPUT
+
+          LATEST_RELEASE=$(curl -sL https://api.github.com/repos/cloudflare/lol-html/releases/latest)
+          if [ -z "$LATEST_RELEASE" ]; then
+            echo "Error: Failed to fetch latest release from GitHub API"
+            exit 1
+          fi
+
+          LATEST_TAG=$(echo "$LATEST_RELEASE" | jq -r '.tag_name')
+          if [ -z "$LATEST_TAG" ] || [ "$LATEST_TAG" = "null" ]; then
+            echo "Error: Could not extract tag name from GitHub API response"
+            exit 1
+          fi
+
+          LATEST_SHA=$(curl -sL "https://api.github.com/repos/cloudflare/lol-html/git/ref/tags/$LATEST_TAG" | jq -r '.object.sha')
+          if [ -z "$LATEST_SHA" ] || [ "$LATEST_SHA" = "null" ]; then
+            echo "Error: Could not fetch SHA for tag $LATEST_TAG"
+            exit 1
+          fi
+
+          if ! [[ $LATEST_SHA =~ ^[0-9a-f]{40}$ ]]; then
+            echo "Error: Invalid SHA format received from GitHub"
+            echo "Found: $LATEST_SHA"
+            echo "Expected: 40 character hexadecimal string"
+            exit 1
+          fi
+
+          echo "latest=$LATEST_SHA" >> $GITHUB_OUTPUT
+          echo "tag=$LATEST_TAG" >> $GITHUB_OUTPUT
+
+      - name: Update version if needed
+        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
+        run: |
+          set -euo pipefail
+          # Handle multi-line format where COMMIT and its value are on separate lines
+          sed -i -E '/[[:space:]]*COMMIT[[:space:]]*$/{n;s/[[:space:]]*([0-9a-f]+)[[:space:]]*$/    ${{ steps.check-version.outputs.latest }}/}' cmake/targets/BuildLolHtml.cmake
+
+      - name: Create Pull Request
+        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
+        uses: peter-evans/create-pull-request@v4
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          add-paths: |
+            cmake/targets/BuildLolHtml.cmake
+          commit-message: "deps: update lolhtml to ${{ steps.check-version.outputs.tag }} (${{ steps.check-version.outputs.latest }})"
+          title: "deps: update lolhtml to ${{ steps.check-version.outputs.tag }}"
+          delete-branch: true
+          branch: deps/update-lolhtml-${{ github.run_number }}
+          body: |
+            ## What does this PR do?
+
+            Updates lolhtml to version ${{ steps.check-version.outputs.tag }}
+
+            Auto-updated by [this workflow](https://github.com/oven-sh/bun/actions/workflows/update-lolhtml.yml)
diff --git a/.github/workflows/update-lshpack.yml b/.github/workflows/update-lshpack.yml
new file mode 100644
index 0000000000..ae917cc3e9
--- /dev/null
+++ b/.github/workflows/update-lshpack.yml
@@ -0,0 +1,92 @@
+name: Update lshpack
+
+on:
+  schedule:
+    - cron: "0 5 * * 0"
+  workflow_dispatch:
+
+jobs:
+  check-update:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Check lshpack version
+        id: check-version
+        run: |
+          set -euo pipefail
+
+          # Extract the commit hash from the line after COMMIT
+          CURRENT_VERSION=$(awk '/[[:space:]]*COMMIT[[:space:]]*$/{getline; gsub(/^[[:space:]]+|[[:space:]]+$/,"",$0); print}' cmake/targets/BuildLshpack.cmake)
+
+          if [ -z "$CURRENT_VERSION" ]; then
+            echo "Error: Could not find COMMIT line in BuildLshpack.cmake"
+            exit 1
+          fi
+
+          # Validate that it looks like a git hash
+          if ! [[ $CURRENT_VERSION =~ ^[0-9a-f]{40}$ ]]; then
+            echo "Error: Invalid git hash format in BuildLshpack.cmake"
+            echo "Found: $CURRENT_VERSION"
+            echo "Expected: 40 character hexadecimal string"
+            exit 1
+          fi
+
+          echo "current=$CURRENT_VERSION" >> $GITHUB_OUTPUT
+
+          LATEST_RELEASE=$(curl -sL https://api.github.com/repos/litespeedtech/ls-hpack/releases/latest)
+          if [ -z "$LATEST_RELEASE" ]; then
+            echo "Error: Failed to fetch latest release from GitHub API"
+            exit 1
+          fi
+
+          LATEST_TAG=$(echo "$LATEST_RELEASE" | jq -r '.tag_name')
+          if [ -z "$LATEST_TAG" ] || [ "$LATEST_TAG" = "null" ]; then
+            echo "Error: Could not extract tag name from GitHub API response"
+            exit 1
+          fi
+
+          LATEST_SHA=$(curl -sL "https://api.github.com/repos/litespeedtech/ls-hpack/git/ref/tags/$LATEST_TAG" | jq -r '.object.sha')
+          if [ -z "$LATEST_SHA" ] || [ "$LATEST_SHA" = "null" ]; then
+            echo "Error: Could not fetch SHA for tag $LATEST_TAG"
+            exit 1
+          fi
+
+          if ! [[ $LATEST_SHA =~ ^[0-9a-f]{40}$ ]]; then
+            echo "Error: Invalid SHA format received from GitHub"
+            echo "Found: $LATEST_SHA"
+            echo "Expected: 40 character hexadecimal string"
+            exit 1
+          fi
+
+          echo "latest=$LATEST_SHA" >> $GITHUB_OUTPUT
+          echo "tag=$LATEST_TAG" >> $GITHUB_OUTPUT
+
+      - name: Update version if needed
+        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
+        run: |
+          set -euo pipefail
+          # Handle multi-line format where COMMIT and its value are on separate lines
+          sed -i -E '/[[:space:]]*COMMIT[[:space:]]*$/{n;s/[[:space:]]*([0-9a-f]+)[[:space:]]*$/    ${{ steps.check-version.outputs.latest }}/}' cmake/targets/BuildLshpack.cmake
+
+      - name: Create Pull Request
+        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
+        uses: peter-evans/create-pull-request@v4
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          add-paths: |
+            cmake/targets/BuildLshpack.cmake
+          commit-message: "deps: update lshpack to ${{ steps.check-version.outputs.tag }} (${{ steps.check-version.outputs.latest }})"
+          title: "deps: update lshpack to ${{ steps.check-version.outputs.tag }}"
+          delete-branch: true
+          branch: deps/update-lshpack-${{ github.run_number }}
+          body: |
+            ## What does this PR do?
+
+            Updates lshpack to version ${{ steps.check-version.outputs.tag }}
+
+            Auto-updated by [this workflow](https://github.com/oven-sh/bun/actions/workflows/update-lshpack.yml)
diff --git a/.github/workflows/update-sqlite3.yml b/.github/workflows/update-sqlite3.yml
new file mode 100644
index 0000000000..66b5753cca
--- /dev/null
+++ b/.github/workflows/update-sqlite3.yml
@@ -0,0 +1,109 @@
+name: Update SQLite3
+
+on:
+  schedule:
+    - cron: "0 6 * * 0" # Run weekly
+  workflow_dispatch:
+
+jobs:
+  check-update:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Check SQLite version
+        id: check-version
+        run: |
+          set -euo pipefail
+
+          # Get current version from the header file using SQLITE_VERSION_NUMBER
+          CURRENT_VERSION_NUM=$(grep -o '#define SQLITE_VERSION_NUMBER [0-9]\+' src/bun.js/bindings/sqlite/sqlite3_local.h | awk '{print $3}' | tr -d '\n\r')
+          if [ -z "$CURRENT_VERSION_NUM" ]; then
+            echo "Error: Could not find SQLITE_VERSION_NUMBER in sqlite3_local.h"
+            exit 1
+          fi
+
+          # Convert numeric version to semantic version for display
+          CURRENT_MAJOR=$((CURRENT_VERSION_NUM / 1000000))
+          CURRENT_MINOR=$((($CURRENT_VERSION_NUM / 1000) % 1000))
+          CURRENT_PATCH=$((CURRENT_VERSION_NUM % 1000))
+          CURRENT_VERSION="$CURRENT_MAJOR.$CURRENT_MINOR.$CURRENT_PATCH"
+
+          echo "current=$CURRENT_VERSION" >> $GITHUB_OUTPUT
+          echo "current_num=$CURRENT_VERSION_NUM" >> $GITHUB_OUTPUT
+
+          # Fetch SQLite download page
+          DOWNLOAD_PAGE=$(curl -sL https://sqlite.org/download.html)
+          if [ -z "$DOWNLOAD_PAGE" ]; then
+            echo "Error: Failed to fetch SQLite download page"
+            exit 1
+          fi
+
+          # Extract latest version and year from the amalgamation link
+          LATEST_INFO=$(echo "$DOWNLOAD_PAGE" | grep -o 'sqlite-amalgamation-[0-9]\{7\}.zip' | head -n1)
+          LATEST_YEAR=$(echo "$DOWNLOAD_PAGE" | grep -o '[0-9]\{4\}/sqlite-amalgamation-[0-9]\{7\}.zip' | head -n1 | cut -d'/' -f1 | tr -d '\n\r')
+          LATEST_VERSION_NUM=$(echo "$LATEST_INFO" | grep -o '[0-9]\{7\}' | tr -d '\n\r')
+
+          if [ -z "$LATEST_VERSION_NUM" ] || [ -z "$LATEST_YEAR" ]; then
+            echo "Error: Could not extract latest version info"
+            exit 1
+          fi
+
+          # Convert numeric version to semantic version for display
+          LATEST_MAJOR=$((10#$LATEST_VERSION_NUM / 1000000))
+          LATEST_MINOR=$((($LATEST_VERSION_NUM / 1000) % 1000))
+          LATEST_PATCH=$((10#$LATEST_VERSION_NUM % 1000))
+          LATEST_VERSION="$LATEST_MAJOR.$LATEST_MINOR.$LATEST_PATCH"
+
+          echo "latest=$LATEST_VERSION" >> $GITHUB_OUTPUT
+          echo "latest_year=$LATEST_YEAR" >> $GITHUB_OUTPUT
+          echo "latest_num=$LATEST_VERSION_NUM" >> $GITHUB_OUTPUT
+
+          # Debug output
+          echo "Current version: $CURRENT_VERSION ($CURRENT_VERSION_NUM)"
+          echo "Latest version: $LATEST_VERSION ($LATEST_VERSION_NUM)"
+
+      - name: Update SQLite if needed
+        if: success() && steps.check-version.outputs.current_num < steps.check-version.outputs.latest_num
+        run: |
+          set -euo pipefail
+
+          TEMP_DIR=$(mktemp -d)
+          cd $TEMP_DIR
+
+          echo "Downloading from: https://sqlite.org/${{ steps.check-version.outputs.latest_year }}/sqlite-amalgamation-${{ steps.check-version.outputs.latest_num }}.zip"
+
+          # Download and extract latest version
+          wget "https://sqlite.org/${{ steps.check-version.outputs.latest_year }}/sqlite-amalgamation-${{ steps.check-version.outputs.latest_num }}.zip"
+          unzip "sqlite-amalgamation-${{ steps.check-version.outputs.latest_num }}.zip"
+          cd "sqlite-amalgamation-${{ steps.check-version.outputs.latest_num }}"
+
+          # Add header comment and copy files
+          echo "// clang-format off" > $GITHUB_WORKSPACE/src/bun.js/bindings/sqlite/sqlite3.c
+          cat sqlite3.c >> $GITHUB_WORKSPACE/src/bun.js/bindings/sqlite/sqlite3.c
+
+          echo "// clang-format off" > $GITHUB_WORKSPACE/src/bun.js/bindings/sqlite/sqlite3_local.h
+          cat sqlite3.h >> $GITHUB_WORKSPACE/src/bun.js/bindings/sqlite/sqlite3_local.h
+
+      - name: Create Pull Request
+        if: success() && steps.check-version.outputs.current_num < steps.check-version.outputs.latest_num
+        uses: peter-evans/create-pull-request@v4
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          add-paths: |
+            src/bun.js/bindings/sqlite/sqlite3.c
+            src/bun.js/bindings/sqlite/sqlite3_local.h
+          commit-message: "deps: update sqlite to ${{ steps.check-version.outputs.latest }}"
+          title: "deps: update sqlite to ${{ steps.check-version.outputs.latest }}"
+          delete-branch: true
+          branch: deps/update-sqlite-${{ steps.check-version.outputs.latest }}
+          body: |
+            ## What does this PR do?
+
+            Updates SQLite to version ${{ steps.check-version.outputs.latest }}
+
+            Auto-updated by [this workflow](https://github.com/oven-sh/bun/actions/workflows/update-sqlite3.yml)
diff --git a/.github/workflows/zig-format.yml b/.github/workflows/zig-format.yml
index 2f5ad91593..24d5577ad7 100644
--- a/.github/workflows/zig-format.yml
+++ b/.github/workflows/zig-format.yml
@@ -7,12 +7,7 @@ on:
   workflow_call:
   workflow_dispatch:
   pull_request:
-    paths:
-      - ".github/workflows/zig-format.yml"
-      - "package.json"
-      - "scripts/**"
-      - "cmake/**"
-      - "src/**/*.zig"
+  merge_group:
 
 env:
   BUN_VERSION: "1.1.27"
@@ -25,21 +20,12 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v4
         with:
-          sparse-checkout: |
-            .github
-            package.json
-            scripts
-            cmake
-            src
-            packages
+          fetch-depth: 0
       - name: Setup Bun
         uses: ./.github/actions/setup-bun
         with:
           bun-version: ${{ env.BUN_VERSION }}
       - name: Zig Format
-        env:
-          ENABLE_CCACHE: OFF
-          SKIP_LLVM: ON
         run: |
           bun run zig-format:diff
       - name: Commit
diff --git a/.gitignore b/.gitignore
index 126af7cebd..3822491fcb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -26,6 +26,7 @@
 *.db
 *.dmg
 *.dSYM
+*.generated.ts
 *.jsb
 *.lib
 *.log
@@ -53,8 +54,8 @@
 /test-report.md
 /test.js
 /test.ts
-/testdir
 /test.zig
+/testdir
 build
 build.ninja
 bun-binary
@@ -111,8 +112,10 @@ pnpm-lock.yaml
 profile.json
 README.md.template
 release/
+scripts/env.local
 sign.*.json
 sign.json
+src/bake/generated.ts
 src/bun.js/bindings-obj
 src/bun.js/bindings/GeneratedJS2Native.zig
 src/bun.js/debug-bindings-obj
@@ -131,6 +134,7 @@ src/runtime.version
 src/tests.zig
 test.txt
 test/js/bun/glob/fixtures
+test/node.js/upstream
 tsconfig.tsbuildinfo
 txt.js
 x64
@@ -141,6 +145,10 @@ test/node.js/upstream
 .zig-cache
 scripts/env.local
 *.generated.ts
+src/bake/generated.ts
+test/cli/install/registry/packages/publish-pkg-*
+test/cli/install/registry/packages/@secret/publish-pkg-8
+test/js/third_party/prisma/prisma/sqlite/dev.db-journal
 
 # Dependencies
 /vendor
@@ -148,18 +156,24 @@ scripts/env.local
 # Dependencies (before CMake)
 # These can be removed in the far future
 /src/bun.js/WebKit
-/src/deps/WebKit
 /src/deps/boringssl
 /src/deps/brotli
 /src/deps/c*ares
-/src/deps/lol*html
 /src/deps/libarchive
 /src/deps/libdeflate
 /src/deps/libuv
+/src/deps/lol*html
 /src/deps/ls*hpack
 /src/deps/mimalloc
 /src/deps/picohttpparser
 /src/deps/tinycc
-/src/deps/zstd
-/src/deps/zlib
+/src/deps/WebKit
 /src/deps/zig
+/src/deps/zlib
+/src/deps/zstd
+
+# Generated files
+
+.buildkite/ci.yml
+*.sock
+scratch*.{js,ts,tsx,cjs,mjs}
\ No newline at end of file
diff --git a/.prettierignore b/.prettierignore
index da765c9c28..42d0c454a9 100644
--- a/.prettierignore
+++ b/.prettierignore
@@ -5,6 +5,5 @@ test/js/deno
 test/node.js
 src/react-refresh.js
 *.min.js
-test/js/node/test/fixtures
-test/js/node/test/common
 test/snippets
+test/js/node/test
diff --git a/.vscode/launch.json b/.vscode/launch.json
index 23205ab1f1..dc019a5445 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -14,7 +14,7 @@
       "name": "bun test [file]",
       "program": "${workspaceFolder}/build/debug/bun-debug",
       "args": ["test", "${file}"],
-      "cwd": "${workspaceFolder}/test",
+      "cwd": "${workspaceFolder}",
       "env": {
         "FORCE_COLOR": "1",
         "BUN_DEBUG_QUIET_LOGS": "1",
@@ -22,6 +22,8 @@
         "BUN_GARBAGE_COLLECTOR_LEVEL": "1",
       },
       "console": "internalConsole",
+      // Don't pause when the GC runs while the debugger is open.
+      "postRunCommands": ["process handle -p true -s false -n false SIGUSR1"],
     },
     {
       "type": "lldb",
@@ -29,7 +31,7 @@
       "name": "bun test [file] --only",
       "program": "${workspaceFolder}/build/debug/bun-debug",
       "args": ["test", "--only", "${file}"],
-      "cwd": "${workspaceFolder}/test",
+      "cwd": "${workspaceFolder}",
       "env": {
         "FORCE_COLOR": "1",
         "BUN_DEBUG_QUIET_LOGS": "1",
@@ -37,6 +39,8 @@
         "BUN_DEBUG_jest": "1",
       },
       "console": "internalConsole",
+      // Don't pause when the GC runs while the debugger is open.
+      "postRunCommands": ["process handle -p true -s false -n false SIGUSR1"],
     },
     {
       "type": "lldb",
@@ -50,7 +54,7 @@
       "name": "bun test [file] (fast)",
       "program": "${workspaceFolder}/build/debug/bun-debug",
       "args": ["test", "${file}"],
-      "cwd": "${workspaceFolder}/test",
+      "cwd": "${workspaceFolder}",
       "env": {
         "FORCE_COLOR": "1",
         "BUN_DEBUG_QUIET_LOGS": "1",
@@ -58,6 +62,8 @@
         "BUN_GARBAGE_COLLECTOR_LEVEL": "0",
       },
       "console": "internalConsole",
+      // Don't pause when the GC runs while the debugger is open.
+      "postRunCommands": ["process handle -p true -s false -n false SIGUSR1"],
     },
     {
       "type": "lldb",
@@ -65,7 +71,7 @@
       "name": "bun test [file] (verbose)",
       "program": "${workspaceFolder}/build/debug/bun-debug",
       "args": ["test", "${file}"],
-      "cwd": "${workspaceFolder}/test",
+      "cwd": "${workspaceFolder}",
       "env": {
         "FORCE_COLOR": "1",
         "BUN_DEBUG_QUIET_LOGS": "0",
@@ -73,6 +79,8 @@
         "BUN_GARBAGE_COLLECTOR_LEVEL": "2",
       },
       "console": "internalConsole",
+      // Don't pause when the GC runs while the debugger is open.
+      "postRunCommands": ["process handle -p true -s false -n false SIGUSR1"],
     },
     {
       "type": "lldb",
@@ -80,7 +88,7 @@
       "name": "bun test [file] --watch",
       "program": "${workspaceFolder}/build/debug/bun-debug",
       "args": ["test", "--watch", "${file}"],
-      "cwd": "${workspaceFolder}/test",
+      "cwd": "${workspaceFolder}",
       "env": {
         "FORCE_COLOR": "1",
         "BUN_DEBUG_QUIET_LOGS": "1",
@@ -88,6 +96,8 @@
         "BUN_GARBAGE_COLLECTOR_LEVEL": "2",
       },
       "console": "internalConsole",
+      // Don't pause when the GC runs while the debugger is open.
+      "postRunCommands": ["process handle -p true -s false -n false SIGUSR1"],
     },
     {
       "type": "lldb",
@@ -95,7 +105,7 @@
       "name": "bun test [file] --hot",
       "program": "${workspaceFolder}/build/debug/bun-debug",
       "args": ["test", "--hot", "${file}"],
-      "cwd": "${workspaceFolder}/test",
+      "cwd": "${workspaceFolder}",
       "env": {
         "FORCE_COLOR": "1",
         "BUN_DEBUG_QUIET_LOGS": "1",
@@ -103,6 +113,8 @@
         "BUN_GARBAGE_COLLECTOR_LEVEL": "2",
       },
       "console": "internalConsole",
+      // Don't pause when the GC runs while the debugger is open.
+      "postRunCommands": ["process handle -p true -s false -n false SIGUSR1"],
     },
     {
       "type": "lldb",
@@ -110,7 +122,7 @@
       "name": "bun test [file] --inspect",
       "program": "${workspaceFolder}/build/debug/bun-debug",
       "args": ["test", "${file}"],
-      "cwd": "${workspaceFolder}/test",
+      "cwd": "${workspaceFolder}",
       "env": {
         "FORCE_COLOR": "1",
         "BUN_DEBUG_QUIET_LOGS": "1",
@@ -119,6 +131,8 @@
         "BUN_INSPECT": "ws://localhost:0/?wait=1",
       },
       "console": "internalConsole",
+      // Don't pause when the GC runs while the debugger is open.
+      "postRunCommands": ["process handle -p true -s false -n false SIGUSR1"],
       "serverReadyAction": {
         "pattern": "https://debug.bun.sh/#localhost:([0-9]+)/",
         "uriFormat": "https://debug.bun.sh/#ws://localhost:%s/",
@@ -131,7 +145,7 @@
       "name": "bun test [file] --inspect-brk",
       "program": "${workspaceFolder}/build/debug/bun-debug",
       "args": ["test", "${file}"],
-      "cwd": "${workspaceFolder}/test",
+      "cwd": "${workspaceFolder}",
       "env": {
         "FORCE_COLOR": "1",
         "BUN_DEBUG_QUIET_LOGS": "1",
@@ -140,6 +154,8 @@
         "BUN_INSPECT": "ws://localhost:0/?break=1",
       },
       "console": "internalConsole",
+      // Don't pause when the GC runs while the debugger is open.
+      "postRunCommands": ["process handle -p true -s false -n false SIGUSR1"],
       "serverReadyAction": {
         "pattern": "https://debug.bun.sh/#localhost:([0-9]+)/",
         "uriFormat": "https://debug.bun.sh/#ws://localhost:%s/",
@@ -160,6 +176,8 @@
         "BUN_GARBAGE_COLLECTOR_LEVEL": "2",
       },
       "console": "internalConsole",
+      // Don't pause when the GC runs while the debugger is open.
+      "postRunCommands": ["process handle -p true -s false -n false SIGUSR1"],
     },
     {
       "type": "lldb",
@@ -172,8 +190,14 @@
         "FORCE_COLOR": "1",
         "BUN_DEBUG_QUIET_LOGS": "1",
         "BUN_GARBAGE_COLLECTOR_LEVEL": "0",
+        "BUN_DEBUG_IncrementalGraph": "1",
+        "BUN_DEBUG_Bake": "1",
+        "BUN_DEBUG_reload_file_list": "1",
+        "GOMAXPROCS": "1",
       },
       "console": "internalConsole",
+      // Don't pause when the GC runs while the debugger is open.
+      "postRunCommands": ["process handle -p true -s false -n false SIGUSR1"],
     },
     {
       "type": "lldb",
@@ -188,6 +212,8 @@
         "BUN_GARBAGE_COLLECTOR_LEVEL": "2",
       },
       "console": "internalConsole",
+      // Don't pause when the GC runs while the debugger is open.
+      "postRunCommands": ["process handle -p true -s false -n false SIGUSR1"],
     },
     {
       "type": "lldb",
@@ -198,10 +224,15 @@
       "cwd": "${fileDirname}",
       "env": {
         "FORCE_COLOR": "1",
+        // "BUN_DEBUG_DEBUGGER": "1",
+        // "BUN_DEBUG_INTERNAL_DEBUGGER": "1",
         "BUN_DEBUG_QUIET_LOGS": "1",
         "BUN_GARBAGE_COLLECTOR_LEVEL": "2",
+        // "BUN_INSPECT": "ws+unix:///var/folders/jk/8fzl9l5119598vsqrmphsw7m0000gn/T/tl15npi7qtf.sock?report=1",
       },
       "console": "internalConsole",
+      // Don't pause when the GC runs while the debugger is open.
+      "postRunCommands": ["process handle -p true -s false -n false SIGUSR1"],
     },
     {
       "type": "lldb",
@@ -216,6 +247,8 @@
         "BUN_GARBAGE_COLLECTOR_LEVEL": "2",
       },
       "console": "internalConsole",
+      // Don't pause when the GC runs while the debugger is open.
+      "postRunCommands": ["process handle -p true -s false -n false SIGUSR1"],
     },
     {
       "type": "lldb",
@@ -231,6 +264,8 @@
         "BUN_INSPECT": "ws://localhost:0/?wait=1",
       },
       "console": "internalConsole",
+      // Don't pause when the GC runs while the debugger is open.
+      "postRunCommands": ["process handle -p true -s false -n false SIGUSR1"],
       "serverReadyAction": {
         "pattern": "https://debug.bun.sh/#localhost:([0-9]+)/",
         "uriFormat": "https://debug.bun.sh/#ws://localhost:%s/",
@@ -251,6 +286,8 @@
         "BUN_INSPECT": "ws://localhost:0/?break=1",
       },
       "console": "internalConsole",
+      // Don't pause when the GC runs while the debugger is open.
+      "postRunCommands": ["process handle -p true -s false -n false SIGUSR1"],
       "serverReadyAction": {
         "pattern": "https://debug.bun.sh/#localhost:([0-9]+)/",
         "uriFormat": "https://debug.bun.sh/#ws://localhost:%s/",
@@ -264,7 +301,7 @@
       "name": "bun test [...]",
       "program": "${workspaceFolder}/build/debug/bun-debug",
       "args": ["test", "${input:testName}"],
-      "cwd": "${workspaceFolder}/test",
+      "cwd": "${workspaceFolder}",
       "env": {
         "FORCE_COLOR": "1",
         "BUN_DEBUG_QUIET_LOGS": "1",
@@ -272,6 +309,8 @@
         "BUN_GARBAGE_COLLECTOR_LEVEL": "2",
       },
       "console": "internalConsole",
+      // Don't pause when the GC runs while the debugger is open.
+      "postRunCommands": ["process handle -p true -s false -n false SIGUSR1"],
     },
     {
       "type": "lldb",
@@ -279,7 +318,7 @@
       "name": "bun test [...] (fast)",
       "program": "${workspaceFolder}/build/debug/bun-debug",
       "args": ["test", "${input:testName}"],
-      "cwd": "${workspaceFolder}/test",
+      "cwd": "${workspaceFolder}",
       "env": {
         "FORCE_COLOR": "1",
         "BUN_DEBUG_QUIET_LOGS": "1",
@@ -287,6 +326,8 @@
         "BUN_GARBAGE_COLLECTOR_LEVEL": "0",
       },
       "console": "internalConsole",
+      // Don't pause when the GC runs while the debugger is open.
+      "postRunCommands": ["process handle -p true -s false -n false SIGUSR1"],
     },
     {
       "type": "lldb",
@@ -294,7 +335,7 @@
       "name": "bun test [...] (verbose)",
       "program": "${workspaceFolder}/build/debug/bun-debug",
       "args": ["test", "${input:testName}"],
-      "cwd": "${workspaceFolder}/test",
+      "cwd": "${workspaceFolder}",
       "env": {
         "FORCE_COLOR": "1",
         "BUN_DEBUG_QUIET_LOGS": "1",
@@ -302,6 +343,8 @@
         "BUN_GARBAGE_COLLECTOR_LEVEL": "2",
       },
       "console": "internalConsole",
+      // Don't pause when the GC runs while the debugger is open.
+      "postRunCommands": ["process handle -p true -s false -n false SIGUSR1"],
     },
     {
       "type": "lldb",
@@ -309,7 +352,7 @@
       "name": "bun test [...] --watch",
       "program": "${workspaceFolder}/build/debug/bun-debug",
       "args": ["test", "--watch", "${input:testName}"],
-      "cwd": "${workspaceFolder}/test",
+      "cwd": "${workspaceFolder}",
       "env": {
         "FORCE_COLOR": "1",
         "BUN_DEBUG_QUIET_LOGS": "1",
@@ -317,6 +360,8 @@
         "BUN_GARBAGE_COLLECTOR_LEVEL": "2",
       },
       "console": "internalConsole",
+      // Don't pause when the GC runs while the debugger is open.
+      "postRunCommands": ["process handle -p true -s false -n false SIGUSR1"],
     },
     {
       "type": "lldb",
@@ -324,7 +369,7 @@
       "name": "bun test [...] --hot",
       "program": "${workspaceFolder}/build/debug/bun-debug",
       "args": ["test", "--hot", "${input:testName}"],
-      "cwd": "${workspaceFolder}/test",
+      "cwd": "${workspaceFolder}",
       "env": {
         "FORCE_COLOR": "1",
         "BUN_DEBUG_QUIET_LOGS": "1",
@@ -332,6 +377,8 @@
         "BUN_GARBAGE_COLLECTOR_LEVEL": "2",
       },
       "console": "internalConsole",
+      // Don't pause when the GC runs while the debugger is open.
+      "postRunCommands": ["process handle -p true -s false -n false SIGUSR1"],
     },
     {
       "type": "lldb",
@@ -339,7 +386,7 @@
       "name": "bun test [...] --inspect",
       "program": "${workspaceFolder}/build/debug/bun-debug",
       "args": ["test", "${input:testName}"],
-      "cwd": "${workspaceFolder}/test",
+      "cwd": "${workspaceFolder}",
       "env": {
         "FORCE_COLOR": "1",
         "BUN_DEBUG_QUIET_LOGS": "1",
@@ -348,6 +395,8 @@
         "BUN_INSPECT": "ws://localhost:0/?wait=1",
       },
       "console": "internalConsole",
+      // Don't pause when the GC runs while the debugger is open.
+      "postRunCommands": ["process handle -p true -s false -n false SIGUSR1"],
       "serverReadyAction": {
         "pattern": "https://debug.bun.sh/#localhost:([0-9]+)/",
         "uriFormat": "https://debug.bun.sh/#ws://localhost:%s/",
@@ -360,7 +409,7 @@
       "name": "bun test [...] --inspect-brk",
       "program": "${workspaceFolder}/build/debug/bun-debug",
       "args": ["test", "${input:testName}"],
-      "cwd": "${workspaceFolder}/test",
+      "cwd": "${workspaceFolder}",
       "env": {
         "FORCE_COLOR": "1",
         "BUN_DEBUG_QUIET_LOGS": "1",
@@ -369,6 +418,8 @@
         "BUN_INSPECT": "ws://localhost:0/?break=1",
       },
       "console": "internalConsole",
+      // Don't pause when the GC runs while the debugger is open.
+      "postRunCommands": ["process handle -p true -s false -n false SIGUSR1"],
       "serverReadyAction": {
         "pattern": "https://debug.bun.sh/#localhost:([0-9]+)/",
         "uriFormat": "https://debug.bun.sh/#ws://localhost:%s/",
@@ -389,6 +440,8 @@
         "BUN_GARBAGE_COLLECTOR_LEVEL": "2",
       },
       "console": "internalConsole",
+      // Don't pause when the GC runs while the debugger is open.
+      "postRunCommands": ["process handle -p true -s false -n false SIGUSR1"],
     },
     // bun test [*]
     {
@@ -397,13 +450,15 @@
       "name": "bun test [*]",
       "program": "${workspaceFolder}/build/debug/bun-debug",
       "args": ["test"],
-      "cwd": "${workspaceFolder}/test",
+      "cwd": "${workspaceFolder}",
       "env": {
         "FORCE_COLOR": "1",
         "BUN_DEBUG_QUIET_LOGS": "1",
         "BUN_GARBAGE_COLLECTOR_LEVEL": "2",
       },
       "console": "internalConsole",
+      // Don't pause when the GC runs while the debugger is open.
+      "postRunCommands": ["process handle -p true -s false -n false SIGUSR1"],
     },
     {
       "type": "lldb",
@@ -411,13 +466,15 @@
       "name": "bun test [*] (fast)",
       "program": "${workspaceFolder}/build/debug/bun-debug",
       "args": ["test"],
-      "cwd": "${workspaceFolder}/test",
+      "cwd": "${workspaceFolder}",
       "env": {
         "FORCE_COLOR": "1",
         "BUN_DEBUG_QUIET_LOGS": "1",
         "BUN_GARBAGE_COLLECTOR_LEVEL": "0",
       },
       "console": "internalConsole",
+      // Don't pause when the GC runs while the debugger is open.
+      "postRunCommands": ["process handle -p true -s false -n false SIGUSR1"],
     },
     {
       "type": "lldb",
@@ -425,7 +482,7 @@
       "name": "bun test [*] --inspect",
       "program": "${workspaceFolder}/build/debug/bun-debug",
       "args": ["test"],
-      "cwd": "${workspaceFolder}/test",
+      "cwd": "${workspaceFolder}",
       "env": {
         "FORCE_COLOR": "1",
         "BUN_DEBUG_QUIET_LOGS": "1",
@@ -433,6 +490,8 @@
         "BUN_INSPECT": "ws://localhost:0/",
       },
       "console": "internalConsole",
+      // Don't pause when the GC runs while the debugger is open.
+      "postRunCommands": ["process handle -p true -s false -n false SIGUSR1"],
       "serverReadyAction": {
         "pattern": "https://debug.bun.sh/#localhost:([0-9]+)/",
         "uriFormat": "https://debug.bun.sh/#ws://localhost:%s/",
@@ -452,6 +511,8 @@
         "BUN_GARBAGE_COLLECTOR_LEVEL": "2",
       },
       "console": "internalConsole",
+      // Don't pause when the GC runs while the debugger is open.
+      "postRunCommands": ["process handle -p true -s false -n false SIGUSR1"],
     },
     {
       "type": "lldb",
@@ -466,6 +527,8 @@
         "BUN_GARBAGE_COLLECTOR_LEVEL": "2",
       },
       "console": "internalConsole",
+      // Don't pause when the GC runs while the debugger is open.
+      "postRunCommands": ["process handle -p true -s false -n false SIGUSR1"],
     },
     // Windows: bun test [file]
     {
@@ -477,7 +540,7 @@
       "name": "Windows: bun test [file]",
       "program": "${workspaceFolder}/build/debug/bun-debug.exe",
       "args": ["test", "${file}"],
-      "cwd": "${workspaceFolder}/test",
+      "cwd": "${workspaceFolder}",
       "environment": [
         {
           "name": "FORCE_COLOR",
@@ -506,7 +569,7 @@
       "name": "Windows: bun test --only [file]",
       "program": "${workspaceFolder}/build/debug/bun-debug.exe",
       "args": ["test", "--only", "${file}"],
-      "cwd": "${workspaceFolder}/test",
+      "cwd": "${workspaceFolder}",
       "environment": [
         {
           "name": "FORCE_COLOR",
@@ -535,7 +598,7 @@
       "name": "Windows: bun test [file] (fast)",
       "program": "${workspaceFolder}/build/debug/bun-debug.exe",
       "args": ["test", "${file}"],
-      "cwd": "${workspaceFolder}/test",
+      "cwd": "${workspaceFolder}",
       "environment": [
         {
           "name": "FORCE_COLOR",
@@ -564,7 +627,7 @@
       "name": "Windows: bun test [file] (verbose)",
       "program": "${workspaceFolder}/build/debug/bun-debug.exe",
       "args": ["test", "${file}"],
-      "cwd": "${workspaceFolder}/test",
+      "cwd": "${workspaceFolder}",
       "environment": [
         {
           "name": "FORCE_COLOR",
@@ -593,7 +656,7 @@
       "name": "Windows: bun test [file] --inspect",
       "program": "${workspaceFolder}/build/debug/bun-debug.exe",
       "args": ["test", "${file}"],
-      "cwd": "${workspaceFolder}/test",
+      "cwd": "${workspaceFolder}",
       "environment": [
         {
           "name": "FORCE_COLOR",
@@ -631,7 +694,7 @@
       "name": "Windows: bun test [file] --inspect-brk",
       "program": "${workspaceFolder}/build/debug/bun-debug.exe",
       "args": ["test", "${file}"],
-      "cwd": "${workspaceFolder}/test",
+      "cwd": "${workspaceFolder}",
       "environment": [
         {
           "name": "FORCE_COLOR",
@@ -818,7 +881,7 @@
       "name": "Windows: bun test [...]",
       "program": "${workspaceFolder}/build/debug/bun-debug.exe",
       "args": ["test", "${input:testName}"],
-      "cwd": "${workspaceFolder}/test",
+      "cwd": "${workspaceFolder}",
       "environment": [
         {
           "name": "FORCE_COLOR",
@@ -847,7 +910,7 @@
       "name": "Windows: bun test [...] (fast)",
       "program": "${workspaceFolder}/build/debug/bun-debug.exe",
       "args": ["test", "${input:testName}"],
-      "cwd": "${workspaceFolder}/test",
+      "cwd": "${workspaceFolder}",
       "environment": [
         {
           "name": "FORCE_COLOR",
@@ -876,7 +939,7 @@
       "name": "Windows: bun test [...] (verbose)",
       "program": "${workspaceFolder}/build/debug/bun-debug.exe",
       "args": ["test", "${input:testName}"],
-      "cwd": "${workspaceFolder}/test",
+      "cwd": "${workspaceFolder}",
       "environment": [
         {
           "name": "FORCE_COLOR",
@@ -905,7 +968,7 @@
       "name": "Windows: bun test [...] --watch",
       "program": "${workspaceFolder}/build/debug/bun-debug.exe",
       "args": ["test", "--watch", "${input:testName}"],
-      "cwd": "${workspaceFolder}/test",
+      "cwd": "${workspaceFolder}",
       "environment": [
         {
           "name": "FORCE_COLOR",
@@ -934,7 +997,7 @@
       "name": "Windows: bun test [...] --hot",
       "program": "${workspaceFolder}/build/debug/bun-debug.exe",
       "args": ["test", "--hot", "${input:testName}"],
-      "cwd": "${workspaceFolder}/test",
+      "cwd": "${workspaceFolder}",
       "environment": [
         {
           "name": "FORCE_COLOR",
@@ -963,7 +1026,7 @@
       "name": "Windows: bun test [...] --inspect",
       "program": "${workspaceFolder}/build/debug/bun-debug.exe",
       "args": ["test", "${input:testName}"],
-      "cwd": "${workspaceFolder}/test",
+      "cwd": "${workspaceFolder}",
       "environment": [
         {
           "name": "FORCE_COLOR",
@@ -1001,7 +1064,7 @@
       "name": "Windows: bun test [...] --inspect-brk",
       "program": "${workspaceFolder}/build/debug/bun-debug.exe",
       "args": ["test", "${input:testName}"],
-      "cwd": "${workspaceFolder}/test",
+      "cwd": "${workspaceFolder}",
       "environment": [
         {
           "name": "FORCE_COLOR",
@@ -1066,7 +1129,7 @@
       "name": "Windows: bun test [*]",
       "program": "${workspaceFolder}/build/debug/bun-debug.exe",
       "args": ["test"],
-      "cwd": "${workspaceFolder}/test",
+      "cwd": "${workspaceFolder}",
       "environment": [
         {
           "name": "FORCE_COLOR",
@@ -1091,7 +1154,7 @@
       "name": "Windows: bun test [*] (fast)",
       "program": "${workspaceFolder}/build/debug/bun-debug.exe",
       "args": ["test"],
-      "cwd": "${workspaceFolder}/test",
+      "cwd": "${workspaceFolder}",
       "environment": [
         {
           "name": "FORCE_COLOR",
@@ -1120,7 +1183,7 @@
       "name": "Windows: bun test [*] --inspect",
       "program": "${workspaceFolder}/build/debug/bun-debug.exe",
       "args": ["test"],
-      "cwd": "${workspaceFolder}/test",
+      "cwd": "${workspaceFolder}",
       "environment": [
         {
           "name": "FORCE_COLOR",
@@ -1178,6 +1241,8 @@
         },
       ],
       "console": "internalConsole",
+      // Don't pause when the GC runs while the debugger is open.
+      "postRunCommands": ["process handle -p true -s false -n false SIGUSR1"],
     },
   ],
   "inputs": [
@@ -1192,4 +1257,4 @@
       "description": "Usage: bun test [...]",
     },
   ],
-}
+}
\ No newline at end of file
diff --git a/.vscode/settings.json b/.vscode/settings.json
index 58ded00a0a..e1cc89f0a9 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -52,12 +52,15 @@
   "cmake.configureOnOpen": false,
   "C_Cpp.errorSquiggles": "enabled",
   "[cpp]": {
+    "editor.tabSize": 4,
     "editor.defaultFormatter": "xaver.clang-format",
   },
   "[c]": {
+    "editor.tabSize": 4,
     "editor.defaultFormatter": "xaver.clang-format",
   },
   "[h]": {
+    "editor.tabSize": 4,
     "editor.defaultFormatter": "xaver.clang-format",
   },
   "clangd.arguments": ["-header-insertion=never"],
@@ -75,7 +78,7 @@
   "prettier.prettierPath": "./node_modules/prettier",
 
   // TypeScript
-  "typescript.tsdk": "${workspaceFolder}/node_modules/typescript/lib",
+  "typescript.tsdk": "node_modules/typescript/lib",
   "[typescript]": {
     "editor.defaultFormatter": "esbenp.prettier-vscode",
   },
diff --git a/.vscode/tasks.json b/.vscode/tasks.json
index faf1dc0d22..5ead186425 100644
--- a/.vscode/tasks.json
+++ b/.vscode/tasks.json
@@ -2,50 +2,57 @@
   "version": "2.0.0",
   "tasks": [
     {
-      "type": "process",
-      "label": "Install Dependencies",
-      "command": "scripts/all-dependencies.sh",
-      "windows": {
-        "command": "scripts/all-dependencies.ps1",
-      },
-      "icon": {
-        "id": "arrow-down",
-      },
-      "options": {
-        "cwd": "${workspaceFolder}",
-      },
-    },
-    {
-      "type": "process",
-      "label": "Setup Environment",
-      "dependsOn": ["Install Dependencies"],
-      "command": "scripts/setup.sh",
-      "windows": {
-        "command": "scripts/setup.ps1",
-      },
-      "icon": {
-        "id": "check",
-      },
-      "options": {
-        "cwd": "${workspaceFolder}",
-      },
-    },
-    {
-      "type": "process",
       "label": "Build Bun",
-      "dependsOn": ["Setup Environment"],
-      "command": "bun",
-      "args": ["run", "build"],
-      "icon": {
-        "id": "gear",
+      "type": "shell",
+      "command": "bun run build",
+      "group": {
+        "kind": "build",
+        "isDefault": true,
       },
-      "options": {
-        "cwd": "${workspaceFolder}",
-      },
-      "isBuildCommand": true,
-      "runOptions": {
-        "instanceLimit": 1,
-        "reevaluateOnRerun": true,
+      "problemMatcher": [
+        {
+          "owner": "zig",
+          "fileLocation": ["relative", "${workspaceFolder}"],
+          "pattern": [
+            {
+              "regexp": "^(.+?):(\\d+):(\\d+): (error|warning|note): (.+)$",
+              "file": 1,
+              "line": 2,
+              "column": 3,
+              "severity": 4,
+              "message": 5,
+            },
+            {
+              "regexp": "^\\s+(.+)$",
+              "message": 1,
+              "loop": true,
+            },
+          ],
+        },
+        {
+          "owner": "clang",
+          "fileLocation": ["relative", "${workspaceFolder}"],
+          "pattern": [
+            {
+              "regexp": "^([^:]+):(\\d+):(\\d+):\\s+(warning|error|note|remark):\\s+(.*)$",
+              "file": 1,
+              "line": 2,
+              "column": 3,
+              "severity": 4,
+              "message": 5,
+            },
+            {
+              "regexp": "^\\s*(.*)$",
+              "message": 1,
+              "loop": true,
+            },
+          ],
+        },
+      ],
+      "presentation": {
+        "reveal": "always",
+        "panel": "shared",
+        "clear": true,
       },
     },
   ],
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3fe5cf20c1..b9249d8993 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -43,7 +43,9 @@ include(BuildBun)
 
 # --- Analysis ---
 
-include(RunClangFormat)
-include(RunClangTidy)
-include(RunZigFormat)
-include(RunPrettier)
+if(ENABLE_ANALYSIS)
+  include(RunClangFormat)
+  include(RunClangTidy)
+  include(RunZigFormat)
+  include(RunPrettier)
+endif()
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 6d3dbb0fd2..1a7f41ae5c 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,6 +1,6 @@
 Configuring a development environment for Bun can take 10-30 minutes depending on your internet connection and computer speed. You will need ~10GB of free disk space for the repository and build artifacts.
 
-If you are using Windows, please refer to [this guide](/docs/project/building-windows)
+If you are using Windows, please refer to [this guide](/docs/project/building-windows.md)
 
 {% details summary="For Ubuntu users" %}
 TL;DR: Ubuntu 22.04 is suggested.
@@ -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
@@ -30,7 +30,7 @@ $ sudo dnf install cargo ccache cmake git golang libtool ninja-build pkg-config
 ```
 
 ```bash#openSUSE Tumbleweed
-$ sudo zypper install go cmake ninja automake git rustup && rustup toolchain install stable
+$ sudo zypper install go cmake ninja automake git icu rustup && rustup toolchain install stable
 ```
 
 {% /codetabs %}
@@ -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
@@ -77,8 +77,8 @@ $ sudo pacman -S llvm clang lld
 
 ```bash#Fedora
 $ sudo dnf install 'dnf-command(copr)'
-$ sudo dnf copr enable -y @fedora-llvm-team/llvm-snapshots
-$ sudo dnf install llvm clang lld
+$ sudo dnf copr enable -y @fedora-llvm-team/llvm17
+$ sudo dnf install llvm16 clang16 lld16-devel
 ```
 
 ```bash#openSUSE Tumbleweed
@@ -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
@@ -116,42 +116,26 @@ $ export PATH="$PATH:/usr/lib/llvm16/bin"
 
 ## Building Bun
 
-After cloning the repository, run the following command to run the first build. This may take a while as it will clone submodules and build dependencies.
-
-```bash
-$ bun setup
-```
-
-The binary will be located at `./build/bun-debug`. It is recommended to add this to your `$PATH`. To verify the build worked, let's print the version number on the development build of Bun.
-
-```bash
-$ build/bun-debug --version
-x.y.z_debug
-```
-
-To rebuild, you can invoke `bun run build`
+After cloning the repository, run the following command to build. This may take a while as it will clone submodules and build dependencies.
 
 ```bash
 $ bun run build
 ```
 
-These two scripts, `setup` and `build`, are aliases to do roughly the following:
+The binary will be located at `./build/debug/bun-debug`. It is recommended to add this to your `$PATH`. To verify the build worked, let's print the version number on the development build of Bun.
 
 ```bash
-$ ./scripts/setup.sh
-$ cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Debug
-$ ninja -C build # 'bun run build' runs just this
+$ build/debug/bun-debug --version
+x.y.z_debug
 ```
 
-Advanced users can pass CMake flags to customize the build.
-
 ## VSCode
 
 VSCode is the recommended IDE for working on Bun, as it has been configured. Once opening, you can run `Extensions: Show Recommended Extensions` to install the recommended extensions for Zig and C++. ZLS is automatically configured.
 
-If you use a different editor, make sure that you tell ZLS to use the automatically installed Zig compiler, which is located at `./.cache/zig/zig.exe`. The filename is `zig.exe` so that it works as expected on Windows, but it still works on macOS/Linux (it just has a surprising file extension).
+If you use a different editor, make sure that you tell ZLS to use the automatically installed Zig compiler, which is located at `./vendor/zig/zig.exe`. The filename is `zig.exe` so that it works as expected on Windows, but it still works on macOS/Linux (it just has a surprising file extension).
 
-We recommend adding `./build` to your `$PATH` so that you can run `bun-debug` in your terminal:
+We recommend adding `./build/debug` to your `$PATH` so that you can run `bun-debug` in your terminal:
 
 ```sh
 $ bun-debug
@@ -180,7 +164,7 @@ To compile a release build of Bun, run:
 $ bun run build:release
 ```
 
-The binary will be located at `./build-release/bun` and `./build-release/bun-profile`.
+The binary will be located at `./build/release/bun` and `./build/release/bun-profile`.
 
 ### Download release build from pull requests
 
@@ -189,8 +173,8 @@ To save you time spent building a release build locally, we provide a way to run
 To run a release build from a pull request, you can use the `bun-pr` npm package:
 
 ```sh
-bunx bun-pr pr-number
-bunx bun-pr branch/branch-name
+bunx bun-pr <pr-number>
+bunx bun-pr <branch-name>
 bunx bun-pr "https://github.com/oven-sh/bun/pull/1234566"
 ```
 
@@ -222,24 +206,18 @@ $ valgrind --fair-sched=try --track-origins=yes bun-debug <args>
 
 ## Building WebKit locally + Debug mode of JSC
 
-{% callout %}
-
-**TODO**: This is out of date. TLDR is pass `-DUSE_DEBUG_JSC=1` or `-DWEBKIT_DIR=...` to CMake. it will probably need more fiddling. ask @paperdave if you need this.
-
-{% /callout %}
-
 WebKit is not cloned by default (to save time and disk space). To clone and build WebKit locally, run:
 
 ```bash
-# once you run this, `make submodule` can be used to automatically
-# update WebKit and the other submodules
-$ git submodule update --init --depth 1 --checkout src/bun.js/WebKit
-# to make a jsc release build
-$ make jsc
-# JSC debug build does not work perfectly with Bun yet, this is actively being
-# worked on and will eventually become the default.
-$ make jsc-build-linux-compile-debug cpp
-$ make jsc-build-mac-compile-debug cpp
+# Clone WebKit into ./vendor/WebKit
+$ git clone https://github.com/oven-sh/WebKit vendor/WebKit
+
+# Make a debug build of JSC. This will output build artifacts in ./vendor/WebKit/WebKitBuild/Debug
+# Optionally, you can use `make jsc` for a release build
+$ make jsc-debug
+
+# Build bun with the local JSC build
+$ bun run build:local
 ```
 
 Note that the WebKit folder, including build artifacts, is 8GB+ in size.
@@ -307,17 +285,17 @@ 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:
 
 ```bash
-$ bun setup -DUSE_STATIC_LIBATOMIC=OFF
+$ 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
 
@@ -325,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 fae04a2a19..c99926d330 100644
--- a/LATEST
+++ b/LATEST
@@ -1 +1 @@
-1.1.29
\ No newline at end of file
+1.1.38
\ No newline at end of file
diff --git a/Makefile b/Makefile
index 49a040f203..f1a8be2646 100644
--- a/Makefile
+++ b/Makefile
@@ -77,7 +77,7 @@ BUN_RELEASE_BIN = $(PACKAGE_DIR)/bun
 PRETTIER ?= $(shell which prettier 2>/dev/null || echo "./node_modules/.bin/prettier")
 ESBUILD = "$(shell which esbuild 2>/dev/null || echo "./node_modules/.bin/esbuild")"
 DSYMUTIL ?= $(shell which dsymutil 2>/dev/null || which dsymutil-15 2>/dev/null)
-WEBKIT_DIR ?= $(realpath src/bun.js/WebKit)
+WEBKIT_DIR ?= $(realpath vendor/WebKit)
 WEBKIT_RELEASE_DIR ?= $(WEBKIT_DIR)/WebKitBuild/Release
 WEBKIT_DEBUG_DIR ?= $(WEBKIT_DIR)/WebKitBuild/Debug
 WEBKIT_RELEASE_DIR_LTO ?= $(WEBKIT_DIR)/WebKitBuild/ReleaseLTO
@@ -138,8 +138,8 @@ endif
 SED = $(shell which gsed 2>/dev/null || which sed 2>/dev/null)
 
 BUN_DIR ?= $(shell dirname $(realpath $(firstword $(MAKEFILE_LIST))))
-BUN_DEPS_DIR ?= $(shell pwd)/src/deps
-BUN_DEPS_OUT_DIR ?= $(shell pwd)/build/bun-deps
+BUN_DEPS_DIR ?= $(shell pwd)/vendor
+BUN_DEPS_OUT_DIR ?= $(shell pwd)/build/release
 CPU_COUNT = 2
 ifeq ($(OS_NAME),darwin)
 CPU_COUNT = $(shell sysctl -n hw.logicalcpu)
@@ -689,19 +689,10 @@ assert-deps:
 	@test $(shell cargo --version | awk '{print $$2}' | cut -d. -f2) -gt 57 || (echo -e "ERROR: cargo version must be at least 1.57."; exit 1)
 	@echo "You have the dependencies installed! Woo"
 
-# the following allows you to run `make submodule` to update or init submodules. but we will exclude webkit
-# unless you explicitly clone it yourself (a huge download)
-SUBMODULE_NAMES=$(shell cat .gitmodules | grep 'path = ' | awk '{print $$3}')
-ifeq ("$(wildcard src/bun.js/WebKit/.git)", "")
-	SUBMODULE_NAMES := $(filter-out src/bun.js/WebKit, $(SUBMODULE_NAMES))
-endif
 
 .PHONY: init-submodules
 init-submodules: submodule # (backwards-compatibility alias)
 
-.PHONY: submodule
-submodule: ## to init or update all submodules
-	git submodule update --init --recursive --progress --depth=1 --checkout $(SUBMODULE_NAMES)
 
 .PHONY: build-obj
 build-obj:
@@ -804,7 +795,7 @@ cls:
 	@echo -e "\n\n---\n\n"
 
 jsc-check:
-	@ls $(JSC_BASE_DIR)  >/dev/null 2>&1 || (echo -e "Failed to access WebKit build. Please compile the WebKit submodule using the Dockerfile at $(shell pwd)/src/javascript/WebKit/Dockerfile and then copy from /output in the Docker container to $(JSC_BASE_DIR). You can override the directory via JSC_BASE_DIR. \n\n 	DOCKER_BUILDKIT=1 docker build -t bun-webkit $(shell pwd)/src/bun.js/WebKit -f $(shell pwd)/src/bun.js/WebKit/Dockerfile --progress=plain\n\n 	docker container create bun-webkit\n\n 	# Get the container ID\n	docker container ls\n\n 	docker cp DOCKER_CONTAINER_ID_YOU_JUST_FOUND:/output $(JSC_BASE_DIR)" && exit 1)
+	@ls $(JSC_BASE_DIR)  >/dev/null 2>&1 || (echo -e "Failed to access WebKit build. Please compile the WebKit submodule using the Dockerfile at $(shell pwd)/src/javascript/WebKit/Dockerfile and then copy from /output in the Docker container to $(JSC_BASE_DIR). You can override the directory via JSC_BASE_DIR. \n\n 	DOCKER_BUILDKIT=1 docker build -t bun-webkit $(shell pwd)/vendor/WebKit -f $(shell pwd)/vendor/WebKit/Dockerfile --progress=plain\n\n 	docker container create bun-webkit\n\n 	# Get the container ID\n	docker container ls\n\n 	docker cp DOCKER_CONTAINER_ID_YOU_JUST_FOUND:/output $(JSC_BASE_DIR)" && exit 1)
 	@ls $(JSC_INCLUDE_DIR)  >/dev/null 2>&1 || (echo "Failed to access WebKit include directory at $(JSC_INCLUDE_DIR)." && exit 1)
 	@ls $(JSC_LIB)  >/dev/null 2>&1 || (echo "Failed to access WebKit lib directory at $(JSC_LIB)." && exit 1)
 
@@ -945,7 +936,7 @@ jsc-bindings: headers bindings
 
 .PHONY: clone-submodules
 clone-submodules:
-	git -c submodule."src/bun.js/WebKit".update=none submodule update --init --recursive --depth=1 --progress
+	git -c submodule."vendor/WebKit".update=none submodule update --init --recursive --depth=1 --progress
 
 
 .PHONY: headers
@@ -1265,7 +1256,7 @@ jsc-build-mac-compile:
 			-DENABLE_STATIC_JSC=ON \
 			-DENABLE_SINGLE_THREADED_VM_ENTRY_SCOPE=ON \
 			-DALLOW_LINE_AND_COLUMN_NUMBER_IN_BUILTINS=ON \
-			-DCMAKE_BUILD_TYPE=Release \
+			-DCMAKE_BUILD_TYPE=RelWithDebInfo \
 			-DUSE_THIN_ARCHIVES=OFF \
 			-DBUN_FAST_TLS=ON \
 			-DENABLE_FTL_JIT=ON \
@@ -1277,7 +1268,7 @@ jsc-build-mac-compile:
 			$(WEBKIT_DIR) \
 			$(WEBKIT_RELEASE_DIR) && \
 	CFLAGS="$(CFLAGS) -ffat-lto-objects" CXXFLAGS="$(CXXFLAGS)  -ffat-lto-objects" \
-		cmake --build $(WEBKIT_RELEASE_DIR) --config Release --target jsc
+		cmake --build $(WEBKIT_RELEASE_DIR) --config RelWithDebInfo --target jsc
 
 .PHONY: jsc-build-mac-compile-lto
 jsc-build-mac-compile-lto:
@@ -1379,7 +1370,7 @@ jsc-build-linux-compile-config-debug:
 			$(WEBKIT_DEBUG_DIR)
 
 # If you get "Error: could not load cache"
-# run  rm -rf src/bun.js/WebKit/CMakeCache.txt
+# run  rm -rf vendor/WebKit/CMakeCache.txt
 .PHONY: jsc-build-linux-compile-build
 jsc-build-linux-compile-build:
 		mkdir -p $(WEBKIT_RELEASE_DIR)  && \
@@ -1414,7 +1405,7 @@ jsc-build-copy-debug:
 	cp $(WEBKIT_DEBUG_DIR)/lib/libbmalloc.a $(BUN_DEPS_OUT_DIR)/libbmalloc.a
 
 clean-jsc:
-	cd src/bun.js/WebKit && rm -rf **/CMakeCache.txt **/CMakeFiles && rm -rf src/bun.js/WebKit/WebKitBuild
+	cd vendor/WebKit && rm -rf **/CMakeCache.txt **/CMakeFiles && rm -rf vendor/WebKit/WebKitBuild
 clean-bindings:
 	rm -rf $(OBJ_DIR)/*.o $(DEBUG_OBJ_DIR)/*.o $(DEBUG_OBJ_DIR)/webcore/*.o $(DEBUG_BINDINGS_OBJ) $(OBJ_DIR)/webcore/*.o $(BINDINGS_OBJ) $(OBJ_DIR)/*.d $(DEBUG_OBJ_DIR)/*.d
 
diff --git a/README.md b/README.md
index cf407d1a25..4b748b865c 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,5 @@
 <p align="center">
-  <a href="https://bun.sh"><img src="https://user-images.githubusercontent.com/709451/182802334-d9c42afe-f35d-4a7b-86ea-9985f73f20c3.png" alt="Logo" height=170></a>
+  <a href="https://bun.sh"><img src="https://github.com/user-attachments/assets/50282090-adfd-4ddb-9e27-c30753c6b161" alt="Logo" height=170></a>
 </p>
 <h1 align="center">Bun</h1>
 
diff --git a/bench/async/bun.js b/bench/async/bun.js
index e99e05a2dc..b5f91da558 100644
--- a/bench/async/bun.js
+++ b/bench/async/bun.js
@@ -1,4 +1,4 @@
-import { bench, run } from "mitata";
+import { bench, run } from "../runner.mjs";
 
 bench("sync", () => {});
 bench("async", async () => {});
diff --git a/bench/async/deno.js b/bench/async/deno.js
index 4e691a1cdb..b5f91da558 100644
--- a/bench/async/deno.js
+++ b/bench/async/deno.js
@@ -1,4 +1,4 @@
-import { bench, run } from "../node_modules/mitata/src/cli.mjs";
+import { bench, run } from "../runner.mjs";
 
 bench("sync", () => {});
 bench("async", async () => {});
diff --git a/bench/async/node.mjs b/bench/async/node.mjs
index e99e05a2dc..b5f91da558 100644
--- a/bench/async/node.mjs
+++ b/bench/async/node.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "mitata";
+import { bench, run } from "../runner.mjs";
 
 bench("sync", () => {});
 bench("async", async () => {});
diff --git a/bench/async/package.json b/bench/async/package.json
index f5c377686b..bb84ce4cf6 100644
--- a/bench/async/package.json
+++ b/bench/async/package.json
@@ -3,9 +3,9 @@
   "scripts": {
     "deps": "exit 0",
     "build": "exit 0",
-    "bench:bun": "$BUN bun.js",
-    "bench:node": "$NODE node.mjs",
-    "bench:deno": "$DENO run -A --unstable deno.js",
+    "bench:bun": "bun bun.js",
+    "bench:node": "node node.mjs",
+    "bench:deno": "deno run -A --unstable deno.js",
     "bench": "bun run bench:bun && bun run bench:node && bun run bench:deno"
   }
 }
diff --git a/bench/bun.lockb b/bench/bun.lockb
index 679ce8aba1..e77a3b406c 100755
Binary files a/bench/bun.lockb and b/bench/bun.lockb differ
diff --git a/bench/copyfile/node.mitata.mjs b/bench/copyfile/node.mitata.mjs
index 90bf6fe0f6..de0e76beab 100644
--- a/bench/copyfile/node.mitata.mjs
+++ b/bench/copyfile/node.mitata.mjs
@@ -1,5 +1,5 @@
-import { bench, run } from "mitata";
 import { copyFileSync, statSync, writeFileSync } from "node:fs";
+import { bench, run } from "../runner.mjs";
 
 function runner(ready) {
   for (let size of [1, 10, 100, 1000, 10000, 100000, 1000000, 10000000]) {
diff --git a/bench/crypto/asymmetricCipher.js b/bench/crypto/asymmetricCipher.js
index 4f7c623b7d..7fa92b20e0 100644
--- a/bench/crypto/asymmetricCipher.js
+++ b/bench/crypto/asymmetricCipher.js
@@ -1,4 +1,4 @@
-import { bench, run } from "mitata";
+import { bench, run } from "../runner.mjs";
 const crypto = require("node:crypto");
 
 const keyPair = crypto.generateKeyPairSync("rsa", {
diff --git a/bench/crypto/asymmetricSign.js b/bench/crypto/asymmetricSign.js
index fe0f146459..e00634963e 100644
--- a/bench/crypto/asymmetricSign.js
+++ b/bench/crypto/asymmetricSign.js
@@ -1,4 +1,4 @@
-import { bench, run } from "mitata";
+import { bench, run } from "../runner.mjs";
 const crypto = require("node:crypto");
 
 const keyPair = crypto.generateKeyPairSync("rsa", {
diff --git a/bench/deepEqual/map.js b/bench/deepEqual/map.js
index 51070e466f..3d89d61eea 100644
--- a/bench/deepEqual/map.js
+++ b/bench/deepEqual/map.js
@@ -1,5 +1,5 @@
 import { expect } from "bun:test";
-import { bench, run } from "mitata";
+import { bench, run } from "../runner.mjs";
 
 const MAP_SIZE = 10_000;
 
diff --git a/bench/deepEqual/set.js b/bench/deepEqual/set.js
index 4deef8847b..1f16d09e9c 100644
--- a/bench/deepEqual/set.js
+++ b/bench/deepEqual/set.js
@@ -1,5 +1,5 @@
 import { expect } from "bun:test";
-import { bench, run } from "mitata";
+import { bench, run } from "../runner.mjs";
 
 const SET_SIZE = 10_000;
 
diff --git a/bench/emitter/implementations.mjs b/bench/emitter/implementations.mjs
index a925bdce78..abf025645f 100644
--- a/bench/emitter/implementations.mjs
+++ b/bench/emitter/implementations.mjs
@@ -1,5 +1,5 @@
-import { group } from "mitata";
 import EventEmitterNative from "node:events";
+import { group } from "../runner.mjs";
 
 export const implementations = [
   {
diff --git a/bench/emitter/microbench.mjs b/bench/emitter/microbench.mjs
index eae59d4c19..4f3ebb465d 100644
--- a/bench/emitter/microbench.mjs
+++ b/bench/emitter/microbench.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "mitata";
+import { bench, run } from "../runner.mjs";
 import { groupForEmitter } from "./implementations.mjs";
 
 var id = 0;
diff --git a/bench/emitter/microbench_once.mjs b/bench/emitter/microbench_once.mjs
index b24fb21031..fa5ca9496a 100644
--- a/bench/emitter/microbench_once.mjs
+++ b/bench/emitter/microbench_once.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "mitata";
+import { bench, run } from "../runner.mjs";
 import { groupForEmitter } from "./implementations.mjs";
 
 var id = 0;
diff --git a/bench/emitter/realworld_stream.mjs b/bench/emitter/realworld_stream.mjs
index 1b2d19945b..6d2428df24 100644
--- a/bench/emitter/realworld_stream.mjs
+++ b/bench/emitter/realworld_stream.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "mitata";
+import { bench, run } from "../runner.mjs";
 import { groupForEmitter } from "./implementations.mjs";
 
 // Pseudo RNG is derived from https://stackoverflow.com/a/424445
diff --git a/bench/fetch/bun.js b/bench/fetch/bun.js
index 96e7275a85..1241aa7d4f 100644
--- a/bench/fetch/bun.js
+++ b/bench/fetch/bun.js
@@ -1,4 +1,4 @@
-import { bench, run } from "mitata";
+import { bench, run } from "../runner.mjs";
 
 const count = 100;
 
diff --git a/bench/fetch/node.mjs b/bench/fetch/node.mjs
index 96e7275a85..1241aa7d4f 100644
--- a/bench/fetch/node.mjs
+++ b/bench/fetch/node.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "mitata";
+import { bench, run } from "../runner.mjs";
 
 const count = 100;
 
diff --git a/bench/ffi/bun.js b/bench/ffi/bun.js
index bceebc20b9..5ef13e234a 100644
--- a/bench/ffi/bun.js
+++ b/bench/ffi/bun.js
@@ -1,5 +1,5 @@
 import { CString, dlopen, ptr } from "bun:ffi";
-import { bench, group, run } from "mitata";
+import { bench, group, run } from "../runner.mjs";
 
 const { napiNoop, napiHash, napiString } = require(import.meta.dir + "/src/ffi_napi_bench.node");
 
diff --git a/bench/ffi/deno.js b/bench/ffi/deno.js
index 72d0a849b8..a1e7ae0ee4 100644
--- a/bench/ffi/deno.js
+++ b/bench/ffi/deno.js
@@ -1,4 +1,4 @@
-import { bench, group, run } from "../node_modules/mitata/src/cli.mjs";
+import { bench, group, run } from "../runner.mjs";
 
 const extension = "darwin" !== Deno.build.os ? "so" : "dylib";
 const path = new URL("src/target/release/libffi_napi_bench." + extension, import.meta.url).pathname;
diff --git a/bench/ffi/node.mjs b/bench/ffi/node.mjs
index db743024b8..c6c9f67c3d 100644
--- a/bench/ffi/node.mjs
+++ b/bench/ffi/node.mjs
@@ -1,5 +1,5 @@
-import { bench, group, run } from "mitata";
 import { createRequire } from "node:module";
+import { bench, group, run } from "../runner.mjs";
 
 const require = createRequire(import.meta.url);
 const { napiNoop, napiHash, napiString } = require("./src/ffi_napi_bench.node");
diff --git a/bench/ffi/package.json b/bench/ffi/package.json
index b7de8e9dd9..3bef4583fd 100644
--- a/bench/ffi/package.json
+++ b/bench/ffi/package.json
@@ -1,11 +1,11 @@
 {
   "name": "bench",
   "scripts": {
-    "bench:bun": "$BUN bun.js",
-    "bench:node": "$NODE node.mjs",
+    "bench:bun": "bun bun.js",
+    "bench:node": "node node.mjs",
     "deps": "cd src && bun run deps",
     "build": "cd src && bun run build",
-    "bench:deno": "$DENO run -A --unstable deno.js",
+    "bench:deno": "deno run -A --unstable deno.js",
     "bench": "bun run bench:bun && bun run bench:node && bun run bench:deno"
   }
 }
diff --git a/bench/glob/braces.mjs b/bench/glob/braces.mjs
index 2e4a9c1c21..fa67614259 100644
--- a/bench/glob/braces.mjs
+++ b/bench/glob/braces.mjs
@@ -1,5 +1,5 @@
 import braces from "braces";
-import { bench, group, run } from "mitata";
+import { bench, group, run } from "../runner.mjs";
 
 // const iterations = 1000;
 const iterations = 100;
@@ -10,15 +10,16 @@ const veryComplexPattern = "{a,b,HI{c,e,LMAO{d,f}Q}}{1,2,{3,4},5}";
 
 console.log(braces(complexPattern, { expand: true }));
 function benchPattern(pattern, name) {
-  group({ name: `${name} pattern: "${pattern}"`, summary: true }, () => {
+  const _name = `${name} pattern: "${pattern}"`;
+  group({ name: _name, summary: true }, () => {
     if (typeof Bun !== "undefined")
-      bench("Bun", () => {
+      bench(`Bun (${_name})`, () => {
         for (let i = 0; i < iterations; i++) {
           Bun.$.braces(pattern);
         }
       });
 
-    bench("micromatch/braces", () => {
+    bench(`micromatch/braces ${_name}`, () => {
       for (let i = 0; i < iterations; i++) {
         braces(pattern, { expand: true });
       }
diff --git a/bench/glob/match.mjs b/bench/glob/match.mjs
index 66150daf25..c81a972c41 100644
--- a/bench/glob/match.mjs
+++ b/bench/glob/match.mjs
@@ -1,5 +1,5 @@
 import micromatch from "micromatch";
-import { bench, run } from "mitata";
+import { bench, run } from "../runner.mjs";
 
 const Glob = typeof Bun !== "undefined" ? Bun.Glob : undefined;
 const doMatch = typeof Bun === "undefined" ? micromatch.isMatch : (a, b) => new Glob(b).match(a);
diff --git a/bench/glob/scan.mjs b/bench/glob/scan.mjs
index ce6721a16f..b5292eba1e 100644
--- a/bench/glob/scan.mjs
+++ b/bench/glob/scan.mjs
@@ -1,6 +1,6 @@
 import fg from "fast-glob";
 import { fdir } from "fdir";
-import { bench, group, run } from "mitata";
+import { bench, group, run } from "../runner.mjs";
 
 const normalPattern = "*.ts";
 const recursivePattern = "**/*.ts";
diff --git a/bench/grpc-server/benchmark.proto b/bench/grpc-server/benchmark.proto
new file mode 100644
index 0000000000..cdbbd32400
--- /dev/null
+++ b/bench/grpc-server/benchmark.proto
@@ -0,0 +1,14 @@
+syntax = "proto3";
+package benchmark;
+
+service BenchmarkService {
+  rpc Ping(Request) returns (Response);
+}
+
+message Request {
+  string message = 1;
+}
+
+message Response {
+  string message = 1;
+}
\ No newline at end of file
diff --git a/bench/grpc-server/cert.pem b/bench/grpc-server/cert.pem
new file mode 100644
index 0000000000..df1f536127
--- /dev/null
+++ b/bench/grpc-server/cert.pem
@@ -0,0 +1,33 @@
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
diff --git a/bench/grpc-server/index.js b/bench/grpc-server/index.js
new file mode 100644
index 0000000000..07edf3a4d6
--- /dev/null
+++ b/bench/grpc-server/index.js
@@ -0,0 +1,31 @@
+const grpc = require("@grpc/grpc-js");
+const protoLoader = require("@grpc/proto-loader");
+const packageDefinition = protoLoader.loadSync("benchmark.proto", {});
+const proto = grpc.loadPackageDefinition(packageDefinition).benchmark;
+const fs = require("fs");
+
+function ping(call, callback) {
+  callback(null, { message: "Hello, World" });
+}
+
+function main() {
+  const server = new grpc.Server();
+  server.addService(proto.BenchmarkService.service, { ping: ping });
+  const tls = !!process.env.TLS && (process.env.TLS === "1" || process.env.TLS === "true");
+  const port = process.env.PORT || 50051;
+  const host = process.env.HOST || "localhost";
+  let credentials;
+  if (tls) {
+    const ca = fs.readFileSync("./cert.pem");
+    const key = fs.readFileSync("./key.pem");
+    const cert = fs.readFileSync("./cert.pem");
+    credentials = grpc.ServerCredentials.createSsl(ca, [{ private_key: key, cert_chain: cert }]);
+  } else {
+    credentials = grpc.ServerCredentials.createInsecure();
+  }
+  server.bindAsync(`${host}:${port}`, credentials, () => {
+    console.log(`Server running at ${tls ? "https" : "http"}://${host}:${port}`);
+  });
+}
+
+main();
diff --git a/bench/grpc-server/key.pem b/bench/grpc-server/key.pem
new file mode 100644
index 0000000000..fb87dccfd2
--- /dev/null
+++ b/bench/grpc-server/key.pem
@@ -0,0 +1,52 @@
+-----BEGIN PRIVATE KEY-----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+-----END PRIVATE KEY-----
diff --git a/bench/grpc-server/package.json b/bench/grpc-server/package.json
new file mode 100644
index 0000000000..191a6ad719
--- /dev/null
+++ b/bench/grpc-server/package.json
@@ -0,0 +1,15 @@
+{
+  "name": "bench",
+  "scripts": {
+    "deps": "exit 0",
+    "build": "exit 0",
+    "bun:server": "TLS=1 PORT=50051 bun ./index.js",
+    "node:server": "TLS=1 PORT=50051 node ./index.js",
+    "bench": "ghz --cacert ./cert.pem --proto ./benchmark.proto --call benchmark.BenchmarkService.Ping -d '{\"message\": \"Hello\"}' --total=100000 localhost:50051",
+    "bench:insecure": "ghz --insecure --proto ./benchmark.proto --call benchmark.BenchmarkService.Ping -d '{\"message\": \"Hello\"}' --total=100000 localhost:50051"
+  },
+  "dependencies": {
+    "@grpc/grpc-js": "1.12.0",
+    "@grpc/proto-loader": "0.7.10"
+  }
+}
diff --git a/bench/gzip/bun.js b/bench/gzip/bun.js
index cfe8615f80..6b7b66cb66 100644
--- a/bench/gzip/bun.js
+++ b/bench/gzip/bun.js
@@ -1,5 +1,5 @@
 import { gunzipSync, gzipSync } from "bun";
-import { bench, group, run } from "mitata";
+import { bench, group, run } from "../runner.mjs";
 
 const data = await Bun.file(require.resolve("@babel/standalone/babel.min.js")).arrayBuffer();
 
diff --git a/bench/gzip/deno.js b/bench/gzip/deno.js
index 0c7f73b37c..fa425e917a 100644
--- a/bench/gzip/deno.js
+++ b/bench/gzip/deno.js
@@ -1,4 +1,4 @@
-import { bench, run } from "../node_modules/mitata/src/cli.mjs";
+import { bench, run } from "../runner.mjs";
 
 const data = new TextEncoder().encode("Hello World!".repeat(9999));
 
diff --git a/bench/gzip/node.mjs b/bench/gzip/node.mjs
index 4d1125b368..f4c867ce58 100644
--- a/bench/gzip/node.mjs
+++ b/bench/gzip/node.mjs
@@ -1,7 +1,7 @@
 import { readFileSync } from "fs";
-import { bench, run } from "mitata";
 import { createRequire } from "module";
 import { gunzipSync, gzipSync } from "zlib";
+import { bench, run } from "../runner.mjs";
 
 const require = createRequire(import.meta.url);
 const data = readFileSync(require.resolve("@babel/standalone/babel.min.js"));
diff --git a/bench/gzip/package.json b/bench/gzip/package.json
index 49e6c3a890..a6a6cd4652 100644
--- a/bench/gzip/package.json
+++ b/bench/gzip/package.json
@@ -3,9 +3,9 @@
   "scripts": {
     "deps": "exit 0",
     "build": "exit 0",
-    "bench:bun": "$BUN bun.js",
-    "bench:node": "$NODE node.mjs",
-    "bench:deno": "$DENO run -A --unstable deno.js",
+    "bench:bun": "bun bun.js",
+    "bench:node": "node node.mjs",
+    "bench:deno": "deno run -A --unstable deno.js",
     "bench": "bun run bench:bun && bun run bench:node && bun run bench:deno"
   },
   "dependencies": {
diff --git a/bench/json-stringify/bun.js b/bench/json-stringify/bun.js
deleted file mode 100644
index 22f29deb40..0000000000
--- a/bench/json-stringify/bun.js
+++ /dev/null
@@ -1,8 +0,0 @@
-import { bench, run } from "mitata";
-
-bench("JSON.stringify({hello: 'world'})", () => JSON.stringify({ hello: "world" }));
-
-const otherUint8Array = new Uint8Array(1024);
-bench("Uint8Array.from(otherUint8Array)", () => Uint8Array.from(otherUint8Array));
-
-run();
diff --git a/bench/log/bun.js b/bench/log/bun.js
index 43728fd648..3e78eb4206 100644
--- a/bench/log/bun.js
+++ b/bench/log/bun.js
@@ -1,4 +1,4 @@
-import { bench, run } from "mitata";
+import { bench, run } from "../runner.mjs";
 
 bench("console.log('hello')", () => console.log("hello"));
 bench("console.log({ hello: 'object' })", () => console.log({ hello: "object" }));
diff --git a/bench/log/deno.mjs b/bench/log/deno.mjs
index 24d7244633..4bfa1a3cc2 100644
--- a/bench/log/deno.mjs
+++ b/bench/log/deno.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "../node_modules/mitata/src/cli.mjs";
+import { bench, run } from "../runner.mjs";
 
 bench("console.log", () => console.log("hello"));
 bench("console.log({ hello: 'object' })", () => console.log({ hello: "object" }));
diff --git a/bench/log/node.mjs b/bench/log/node.mjs
index 6ec73f7438..4bfa1a3cc2 100644
--- a/bench/log/node.mjs
+++ b/bench/log/node.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "mitata";
+import { bench, run } from "../runner.mjs";
 
 bench("console.log", () => console.log("hello"));
 bench("console.log({ hello: 'object' })", () => console.log({ hello: "object" }));
diff --git a/bench/log/package.json b/bench/log/package.json
index 1dc6e46020..821c1c3064 100644
--- a/bench/log/package.json
+++ b/bench/log/package.json
@@ -3,9 +3,9 @@
   "scripts": {
     "deps": "exit 0",
     "build": "exit 0",
-    "bench:bun": "$BUN bun.js | grep iter",
-    "bench:node": "$NODE node.mjs | grep iter",
-    "bench:deno": "$DENO run -A --unstable deno.mjs | grep iter",
+    "bench:bun": "bun bun.js | grep iter",
+    "bench:node": "node node.mjs | grep iter",
+    "bench:deno": "deno run -A --unstable deno.mjs | grep iter",
     "bench": "bun run bench:bun && bun run bench:node && bun run bench:deno"
   }
 }
diff --git a/bench/modules/node_os/bun.js b/bench/modules/node_os/bun.js
index 4405c9a456..713f9483a9 100644
--- a/bench/modules/node_os/bun.js
+++ b/bench/modules/node_os/bun.js
@@ -1,4 +1,4 @@
-import { bench, run } from "mitata";
+import { bench, run } from "../../runner.mjs";
 import {
   arch,
   cpus,
diff --git a/bench/modules/node_os/node.mjs b/bench/modules/node_os/node.mjs
index 4405c9a456..36139b29ef 100644
--- a/bench/modules/node_os/node.mjs
+++ b/bench/modules/node_os/node.mjs
@@ -1,4 +1,3 @@
-import { bench, run } from "mitata";
 import {
   arch,
   cpus,
@@ -19,6 +18,7 @@ import {
   userInfo,
   version,
 } from "node:os";
+import { bench, run } from "../../runner.mjs";
 
 bench("cpus()", () => cpus());
 bench("networkInterfaces()", () => networkInterfaces());
diff --git a/bench/modules/node_os/package.json b/bench/modules/node_os/package.json
index 2a095e28b6..d198465b9e 100644
--- a/bench/modules/node_os/package.json
+++ b/bench/modules/node_os/package.json
@@ -3,8 +3,8 @@
   "scripts": {
     "deps": "exit 0",
     "build": "exit 0",
-    "bench:bun": "$BUN bun.js",
-    "bench:node": "$NODE node.mjs",
+    "bench:bun": "bun bun.js",
+    "bench:node": "node node.mjs",
     "bench": "bun run bench:bun && bun run bench:node"
   }
 }
diff --git a/bench/package.json b/bench/package.json
index 6ea67f5c99..a80d7566dc 100644
--- a/bench/package.json
+++ b/bench/package.json
@@ -7,13 +7,17 @@
     "@swc/core": "^1.2.133",
     "benchmark": "^2.1.4",
     "braces": "^3.0.2",
+    "color": "^4.2.3",
     "esbuild": "^0.14.12",
     "eventemitter3": "^5.0.0",
     "execa": "^8.0.1",
     "fast-glob": "3.3.1",
     "fdir": "^6.1.0",
-    "mitata": "^0.1.6",
+    "mitata": "^1.0.10",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
     "string-width": "7.1.0",
+    "tinycolor2": "^1.6.0",
     "zx": "^7.2.3"
   },
   "scripts": {
diff --git a/bench/runner.mjs b/bench/runner.mjs
new file mode 100644
index 0000000000..9f6bcee16f
--- /dev/null
+++ b/bench/runner.mjs
@@ -0,0 +1,19 @@
+import * as Mitata from "mitata";
+import process from "node:process";
+
+const asJSON = !!process?.env?.BENCHMARK_RUNNER;
+
+/** @param {Parameters<typeof Mitata["run"]>["0"]} opts */
+export function run(opts = {}) {
+  if (asJSON) {
+    opts.format = "json";
+  }
+
+  return Mitata.run(opts);
+}
+
+export const bench = Mitata.bench;
+
+export function group(_name, fn) {
+  return Mitata.group(fn);
+}
diff --git a/bench/snippets/array-arguments-slice.mjs b/bench/snippets/array-arguments-slice.mjs
index 5d1139b8b3..8470ab79a6 100644
--- a/bench/snippets/array-arguments-slice.mjs
+++ b/bench/snippets/array-arguments-slice.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 function doIt(...args) {
   // we use .at() to prevent constant folding optimizations
diff --git a/bench/snippets/array-map.mjs b/bench/snippets/array-map.mjs
index 7b8bc6fdcf..b467e9cd3e 100644
--- a/bench/snippets/array-map.mjs
+++ b/bench/snippets/array-map.mjs
@@ -1,5 +1,5 @@
 // https://github.com/oven-sh/bun/issues/1096
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 const identity = x => x;
 
diff --git a/bench/snippets/array-shift.mjs b/bench/snippets/array-shift.mjs
index 7039026706..15733f940b 100644
--- a/bench/snippets/array-shift.mjs
+++ b/bench/snippets/array-shift.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 var myArray = new Array(5);
 bench("[1, 2, 3, 4, 5].shift()", () => {
diff --git a/bench/snippets/array-sort.mjs b/bench/snippets/array-sort.mjs
index 9ed257740e..8951d716a6 100644
--- a/bench/snippets/array-sort.mjs
+++ b/bench/snippets/array-sort.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 var comparator = (a, b) => a - b;
 
 const numbers = [
diff --git a/bench/snippets/arraybuffersink.mjs b/bench/snippets/arraybuffersink.mjs
index f90fae69fd..566f9bd630 100644
--- a/bench/snippets/arraybuffersink.mjs
+++ b/bench/snippets/arraybuffersink.mjs
@@ -1,6 +1,6 @@
 // @runtime bun
 import { ArrayBufferSink } from "bun";
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 var short = "Hello World!";
 var shortUTF16 = "Hello World 💕💕💕";
diff --git a/bench/snippets/assert.mjs b/bench/snippets/assert.mjs
index 120363aa07..7ed8cf7596 100644
--- a/bench/snippets/assert.mjs
+++ b/bench/snippets/assert.mjs
@@ -1,5 +1,5 @@
 import * as assert from "assert";
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 bench("deepEqual", () => {
   assert.deepEqual({ foo: "123", bar: "baz" }, { foo: "123", bar: "baz" });
diff --git a/bench/snippets/async-overhead.mjs b/bench/snippets/async-overhead.mjs
index e285c7edd6..ec171dae54 100644
--- a/bench/snippets/async-overhead.mjs
+++ b/bench/snippets/async-overhead.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "mitata";
+import { bench, run } from "../runner.mjs";
 
 bench("noop", function () {});
 bench("async function(){}", async function () {});
diff --git a/bench/snippets/atob.mjs b/bench/snippets/atob.mjs
index 3a848300c0..de7d128265 100644
--- a/bench/snippets/atob.mjs
+++ b/bench/snippets/atob.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 function makeBenchmark(size) {
   const latin1 = btoa("A".repeat(size));
diff --git a/bench/snippets/blob.mjs b/bench/snippets/blob.mjs
index 68ebc1ce4d..7486f56fc9 100644
--- a/bench/snippets/blob.mjs
+++ b/bench/snippets/blob.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "../node_modules/mitata/src/cli.mjs";
+import { bench, run } from "../runner.mjs";
 
 bench("new Blob(['hello world'])", function () {
   return new Blob(["hello world"]);
diff --git a/bench/snippets/buffer-base64.mjs b/bench/snippets/buffer-base64.mjs
index 96bab6f039..73dc3bccf8 100644
--- a/bench/snippets/buffer-base64.mjs
+++ b/bench/snippets/buffer-base64.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 function makeBenchmark(size, isToString) {
   const base64Input = Buffer.alloc(size, "latin1").toString("base64");
diff --git a/bench/snippets/buffer-concat.mjs b/bench/snippets/buffer-concat.mjs
index 0a6e4a0c85..c2812796a7 100644
--- a/bench/snippets/buffer-concat.mjs
+++ b/bench/snippets/buffer-concat.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 for (let size of [32, 2048, 1024 * 16, 1024 * 1024 * 2, 1024 * 1024 * 16]) {
   const first = Buffer.allocUnsafe(size);
diff --git a/bench/snippets/buffer-create.mjs b/bench/snippets/buffer-create.mjs
index 0093f6de83..ded7f02cab 100644
--- a/bench/snippets/buffer-create.mjs
+++ b/bench/snippets/buffer-create.mjs
@@ -1,7 +1,7 @@
 // @runtime bun,node,deno
 import { Buffer } from "node:buffer";
 import process from "node:process";
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 const N = parseInt(process.env.RUN_COUNTER ?? "10000", 10);
 var isBuffer = new Buffer(0);
diff --git a/bench/snippets/buffer-fill.mjs b/bench/snippets/buffer-fill.mjs
new file mode 100644
index 0000000000..47b5babbc4
--- /dev/null
+++ b/bench/snippets/buffer-fill.mjs
@@ -0,0 +1,15 @@
+import { bench, run } from "../runner.mjs";
+
+for (let size of [32, 2048, 1024 * 16, 1024 * 1024 * 2, 1024 * 1024 * 16]) {
+  for (let fillSize of [4, 8, 16, 11]) {
+    const buffer = Buffer.allocUnsafe(size);
+
+    const pattern = "x".repeat(fillSize);
+
+    bench(`Buffer.fill ${size} bytes with ${fillSize} byte value`, () => {
+      buffer.fill(pattern);
+    });
+  }
+}
+
+await run();
diff --git a/bench/snippets/buffer-to-string.mjs b/bench/snippets/buffer-to-string.mjs
index f59470f6fa..2d26535838 100644
--- a/bench/snippets/buffer-to-string.mjs
+++ b/bench/snippets/buffer-to-string.mjs
@@ -1,6 +1,6 @@
 import { Buffer } from "node:buffer";
 import crypto from "node:crypto";
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 const bigBuffer = Buffer.from("hello world".repeat(10000));
 const converted = bigBuffer.toString("base64");
diff --git a/bench/snippets/color.mjs b/bench/snippets/color.mjs
new file mode 100644
index 0000000000..4a505630fc
--- /dev/null
+++ b/bench/snippets/color.mjs
@@ -0,0 +1,25 @@
+import Color from "color";
+import tinycolor from "tinycolor2";
+import { bench, group, run } from "../runner.mjs";
+
+const inputs = ["#f00", "rgb(255, 0, 0)", "rgba(255, 0, 0, 1)", "hsl(0, 100%, 50%)"];
+
+for (const input of inputs) {
+  group(`${input}`, () => {
+    if (typeof Bun !== "undefined") {
+      bench(`Bun.color() (${input})`, () => {
+        Bun.color(input, "css");
+      });
+    }
+
+    bench(`color (${input})`, () => {
+      Color(input).hex();
+    });
+
+    bench(`'tinycolor2' (${input})`, () => {
+      tinycolor(input).toHexString();
+    });
+  });
+}
+
+await run();
diff --git a/bench/snippets/concat.js b/bench/snippets/concat.js
index 85a15c2896..15e418f05e 100644
--- a/bench/snippets/concat.js
+++ b/bench/snippets/concat.js
@@ -1,6 +1,6 @@
 import { allocUnsafe } from "bun";
 import { readFileSync } from "fs";
-import { bench, group, run } from "./runner.mjs";
+import { bench, group, run } from "../runner.mjs";
 
 function polyfill(chunks) {
   var size = 0;
@@ -41,15 +41,16 @@ const chunkGroups = [
 ];
 
 for (const chunks of chunkGroups) {
-  group(`${chunks.reduce((prev, curr, i, a) => prev + curr.byteLength, 0)} bytes for ${chunks.length} chunks`, () => {
-    bench("Bun.concatArrayBuffers", () => {
+  const name = `${chunks.reduce((prev, curr, i, a) => prev + curr.byteLength, 0)} bytes for ${chunks.length} chunks`
+  group(name, () => {
+    bench(`Bun.concatArrayBuffers (${name})`, () => {
       Bun.concatArrayBuffers(chunks);
     });
-    bench("Uint8Array.set", () => {
+    bench(`Uint8Array.set (${name})`, () => {
       polyfill(chunks);
     });
 
-    bench("Uint8Array.set (uninitialized memory)", () => {
+    bench(`Uint8Array.set (uninitialized memory) (${name})`, () => {
       polyfillUninitialized(chunks);
     });
   });
diff --git a/bench/snippets/console-log.mjs b/bench/snippets/console-log.mjs
index b95533f012..274af84d67 100644
--- a/bench/snippets/console-log.mjs
+++ b/bench/snippets/console-log.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "../node_modules/mitata/src/cli.mjs";
+import { bench, run } from "../runner.mjs";
 
 const json = {
   login: "wongmjane",
diff --git a/bench/snippets/cp.mjs b/bench/snippets/cp.mjs
index 898375439f..1572296e62 100644
--- a/bench/snippets/cp.mjs
+++ b/bench/snippets/cp.mjs
@@ -2,7 +2,7 @@ import { mkdirSync, rmSync, writeFileSync } from "fs";
 import { cp } from "fs/promises";
 import { tmpdir } from "os";
 import { join, resolve } from "path";
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 import { fileURLToPath } from "url";
 const hugeDirectory = (() => {
diff --git a/bench/snippets/crypto-2190.mjs b/bench/snippets/crypto-2190.mjs
index dab54f1fdf..1ff6536788 100644
--- a/bench/snippets/crypto-2190.mjs
+++ b/bench/snippets/crypto-2190.mjs
@@ -1,6 +1,6 @@
 // https://github.com/oven-sh/bun/issues/2190
-import { bench, run } from "mitata";
 import { createHash } from "node:crypto";
+import { bench, run } from "../runner.mjs";
 
 const data =
   "Delightful remarkably mr on announcing themselves entreaties favourable. About to in so terms voice at. Equal an would is found seems of. The particular friendship one sufficient terminated frequently themselves. It more shed went up is roof if loud case. Delay music in lived noise an. Beyond genius really enough passed is up.";
diff --git a/bench/snippets/crypto-hasher.mjs b/bench/snippets/crypto-hasher.mjs
index 36f67739ad..e08e360753 100644
--- a/bench/snippets/crypto-hasher.mjs
+++ b/bench/snippets/crypto-hasher.mjs
@@ -1,5 +1,5 @@
 // so it can run in environments without node module resolution
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 import crypto from "node:crypto";
 
diff --git a/bench/snippets/crypto-randomUUID.mjs b/bench/snippets/crypto-randomUUID.mjs
index f6a4c0aa68..f8faeb6c9e 100644
--- a/bench/snippets/crypto-randomUUID.mjs
+++ b/bench/snippets/crypto-randomUUID.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 bench("crypto.randomUUID()", () => {
   return crypto.randomUUID();
diff --git a/bench/snippets/crypto-stream.mjs b/bench/snippets/crypto-stream.mjs
index 3560563d9d..f931f2ed73 100644
--- a/bench/snippets/crypto-stream.mjs
+++ b/bench/snippets/crypto-stream.mjs
@@ -1,6 +1,6 @@
 // https://github.com/oven-sh/bun/issues/2190
-import { bench, run } from "mitata";
 import { createHash } from "node:crypto";
+import { bench, run } from "../runner.mjs";
 
 const data =
   "Delightful remarkably mr on announcing themselves entreaties favourable. About to in so terms voice at. Equal an would is found seems of. The particular friendship one sufficient terminated frequently themselves. It more shed went up is roof if loud case. Delay music in lived noise an. Beyond genius really enough passed is up.";
diff --git a/bench/snippets/crypto.mjs b/bench/snippets/crypto.mjs
index 7c49fe92ee..c285722056 100644
--- a/bench/snippets/crypto.mjs
+++ b/bench/snippets/crypto.mjs
@@ -1,6 +1,6 @@
 // so it can run in environments without node module resolution
 import crypto from "node:crypto";
-import { bench, run } from "../node_modules/mitata/src/cli.mjs";
+import { bench, run } from "../runner.mjs";
 var foo = new Uint8Array(65536);
 bench("crypto.getRandomValues(65536)", () => {
   crypto.getRandomValues(foo);
diff --git a/bench/snippets/deep-equals.js b/bench/snippets/deep-equals.js
index 0b69492342..87d68ce030 100644
--- a/bench/snippets/deep-equals.js
+++ b/bench/snippets/deep-equals.js
@@ -1,5 +1,5 @@
 import fastDeepEquals from "fast-deep-equal/es6/index";
-import { bench, group, run } from "./runner.mjs";
+import { bench, group, run } from "../runner.mjs";
 // const Date = globalThis.Date;
 
 function func1() {}
@@ -490,7 +490,7 @@ for (let { tests, description } of fixture) {
     var expected;
     group(describe, () => {
       for (let equalsFn of [Bun.deepEquals, fastDeepEquals]) {
-        bench(equalsFn.name, () => {
+        bench(`${describe}: ${equalsFn.name}`, () => {
           expected = equalsFn(value1, value2);
           if (expected !== equal) {
             throw new Error(`Expected ${expected} to be ${equal} for ${description}`);
diff --git a/bench/snippets/define-properties.mjs b/bench/snippets/define-properties.mjs
index 6a10ab1832..f26d3c7188 100644
--- a/bench/snippets/define-properties.mjs
+++ b/bench/snippets/define-properties.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "../node_modules/mitata/src/cli.mjs";
+import { bench, run } from "../runner.mjs";
 
 const properties = {
   closed: {
diff --git a/bench/snippets/dns.node.mjs b/bench/snippets/dns.node.mjs
index ffa58ff236..fe065edf06 100644
--- a/bench/snippets/dns.node.mjs
+++ b/bench/snippets/dns.node.mjs
@@ -1,5 +1,5 @@
 import { lookup, resolve } from "node:dns/promises";
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 bench("(cached) dns.lookup remote x 50", async () => {
   var tld = "example.com";
diff --git a/bench/snippets/dns.ts b/bench/snippets/dns.ts
index 12ecfe1198..cb350a808d 100644
--- a/bench/snippets/dns.ts
+++ b/bench/snippets/dns.ts
@@ -1,10 +1,10 @@
 import { dns } from "bun";
-import { bench, group, run } from "./runner.mjs";
+import { bench, group, run } from "../runner.mjs";
 
 async function forEachBackend(name, fn) {
   group(name, () => {
     for (let backend of ["libc", "c-ares", process.platform === "darwin" ? "system" : ""].filter(Boolean))
-      bench(backend, fn(backend));
+      bench(`${backend} (${name})`, fn(backend));
   });
 }
 
diff --git a/bench/snippets/encode-into.mjs b/bench/snippets/encode-into.mjs
index 70cb242f36..20ac486bad 100644
--- a/bench/snippets/encode-into.mjs
+++ b/bench/snippets/encode-into.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "../node_modules/mitata/src/cli.mjs";
+import { bench, run } from "../runner.mjs";
 
 const encoder = new TextEncoder();
 
diff --git a/bench/snippets/error-capturestack.mjs b/bench/snippets/error-capturestack.mjs
index 0c59ff9c84..3b715b3961 100644
--- a/bench/snippets/error-capturestack.mjs
+++ b/bench/snippets/error-capturestack.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 var err = new Error();
 bench("Error.captureStackTrace(err)", () => {
diff --git a/bench/snippets/escapeHTML.js b/bench/snippets/escapeHTML.js
index 96da26d973..48b12bf61d 100644
--- a/bench/snippets/escapeHTML.js
+++ b/bench/snippets/escapeHTML.js
@@ -1,4 +1,4 @@
-import { bench, group, run } from "./runner.mjs";
+import { bench, group, run } from "../runner.mjs";
 
 var bunEscapeHTML = globalThis.escapeHTML || Bun.escapeHTML;
 
@@ -92,24 +92,21 @@ function reactEscapeHtml(string) {
 // }
 
 for (let input of [
-  `long string, nothing to escape... `.repeat(9999999 * 3),
+  "long string, nothing to escape... ".repeat(9999999 * 3),
   FIXTURE.repeat(8000),
   // "[unicode]" + FIXTURE_WITH_UNICODE,
 ]) {
+  const name = `"${input.substring(0, Math.min(input.length, 32))}" (${new Intl.NumberFormat().format(input.length / 100_000_000_0)} GB)`
   group(
     {
       summary: true,
-      name:
-        `"` +
-        input.substring(0, Math.min(input.length, 32)) +
-        `"` +
-        ` (${new Intl.NumberFormat().format(input.length / 100_000_000_0)} GB)`,
+      name
     },
     () => {
       // bench(`ReactDOM.escapeHTML`, () => reactEscapeHtml(input));
       // bench(`html-entities.encode`, () => htmlEntityEncode(input));
       // bench(`he.escape`, () => heEscape(input));
-      bench(`Bun.escapeHTML`, () => bunEscapeHTML(input));
+      bench(`Bun.escapeHTML (${name})`, () => bunEscapeHTML(input));
     },
   );
 }
diff --git a/bench/snippets/ffi-overhead.mjs b/bench/snippets/ffi-overhead.mjs
index fed3228574..d0f11e907c 100644
--- a/bench/snippets/ffi-overhead.mjs
+++ b/bench/snippets/ffi-overhead.mjs
@@ -1,5 +1,5 @@
 import { dlopen } from "bun:ffi";
-import { bench, group, run } from "./runner.mjs";
+import { bench, group, run } from "../runner.mjs";
 
 const types = {
   returns_true: {
diff --git a/bench/snippets/form-data.mjs b/bench/snippets/form-data.mjs
index a12cf4b134..b78edbfbe7 100644
--- a/bench/snippets/form-data.mjs
+++ b/bench/snippets/form-data.mjs
@@ -1,5 +1,5 @@
 // so it can run in environments without node module resolution
-import { bench, run } from "../node_modules/mitata/src/cli.mjs";
+import { bench, run } from "../runner.mjs";
 
 const blob = new Blob(["foo", "bar", "baz"]);
 bench("FormData.append", () => {
diff --git a/bench/snippets/headers.mjs b/bench/snippets/headers.mjs
index 7057db02a7..8c0c0ec450 100644
--- a/bench/snippets/headers.mjs
+++ b/bench/snippets/headers.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "../node_modules/mitata/src/cli.mjs";
+import { bench, run } from "../runner.mjs";
 
 // pure JS implementation will optimze this out
 bench("new Headers", function () {
diff --git a/bench/snippets/index-of.mjs b/bench/snippets/index-of.mjs
index 04b9704e96..8f22ab3518 100644
--- a/bench/snippets/index-of.mjs
+++ b/bench/snippets/index-of.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 const input =
   "Hello, World! foo bar baz qux quux corge grault garply waldo fred plugh xyzzy thud z a b c d e f g h i j k l m n o p q r s t u v w x y z".split(
diff --git a/bench/snippets/json-parse-stringify.mjs b/bench/snippets/json-parse-stringify.mjs
index c58041e100..f516f5364c 100644
--- a/bench/snippets/json-parse-stringify.mjs
+++ b/bench/snippets/json-parse-stringify.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 var obj = {
   "restApiRoot": "/api",
diff --git a/bench/snippets/json-stringify.js b/bench/snippets/json-stringify.js
new file mode 100644
index 0000000000..e50ab7be10
--- /dev/null
+++ b/bench/snippets/json-stringify.js
@@ -0,0 +1,8 @@
+import { bench, run } from "../runner.mjs";
+
+bench("JSON.stringify({hello: 'world'})", () => JSON.stringify({ hello: "world" }));
+
+const otherUint8Array = new Uint8Array(1024);
+bench("Uint8Array.from(otherUint8Array)", () => Uint8Array.from(otherUint8Array));
+
+run();
diff --git a/bench/snippets/module-exports-putter.cjs b/bench/snippets/module-exports-putter.cjs
index 9bef17b90e..7afb1e3aa6 100644
--- a/bench/snippets/module-exports-putter.cjs
+++ b/bench/snippets/module-exports-putter.cjs
@@ -1,6 +1,6 @@
 // This is a stress test of some internals in How Bun does the module.exports assignment.
 // If it crashes or throws then this fails
-import("./runner.mjs").then(({ bench, run }) => {
+import("../runner.mjs").then(({ bench, run }) => {
   bench("Object.defineProperty(module, 'exports', { get() { return 42; } })", () => {
     Object.defineProperty(module, "exports", {
       get() {
@@ -36,7 +36,9 @@ import("./runner.mjs").then(({ bench, run }) => {
       a: 1,
     };
 
-    console.log(
+    const log = !process?.env?.BENCHMARK_RUNNER ? console.log : () => {};
+
+    log(
       module?.exports,
       require.cache[module.id].exports,
       module?.exports === require.cache[module.id],
@@ -49,10 +51,11 @@ import("./runner.mjs").then(({ bench, run }) => {
       return 42;
     };
 
-    console.log(module.exports, module.exports());
+    log(module.exports);
+    log(module.exports, module.exports());
 
     queueMicrotask(() => {
-      console.log(
+      log(
         module?.exports,
         require.cache[module.id].exports,
         module?.exports === require.cache[module.id]?.exports,
diff --git a/bench/snippets/native-overhead.mjs b/bench/snippets/native-overhead.mjs
index 2c33c46fab..32d459247e 100644
--- a/bench/snippets/native-overhead.mjs
+++ b/bench/snippets/native-overhead.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 // These are no-op C++ functions that are exported to JS.
 const lazy = globalThis[Symbol.for("Bun.lazy")];
diff --git a/bench/snippets/new-incomingmessage.mjs b/bench/snippets/new-incomingmessage.mjs
index 2821ee876a..13cd172646 100644
--- a/bench/snippets/new-incomingmessage.mjs
+++ b/bench/snippets/new-incomingmessage.mjs
@@ -1,5 +1,5 @@
 import { IncomingMessage } from "node:http";
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 const headers = {
   date: "Mon, 06 Nov 2023 05:12:49 GMT",
diff --git a/bench/snippets/node-vm.mjs b/bench/snippets/node-vm.mjs
index c8c2ac41bb..74bed6a4be 100644
--- a/bench/snippets/node-vm.mjs
+++ b/bench/snippets/node-vm.mjs
@@ -1,6 +1,6 @@
 // @runtime node, bun
 import * as vm from "node:vm";
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 const context = {
   animal: "cat",
diff --git a/bench/snippets/noop.js b/bench/snippets/noop.js
index 9b9f1a1d12..6b647064c1 100644
--- a/bench/snippets/noop.js
+++ b/bench/snippets/noop.js
@@ -1,4 +1,4 @@
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 var noop = globalThis[Symbol.for("Bun.lazy")]("noop");
 var { function: noopFn, callback } = noop;
diff --git a/bench/snippets/object-entries.mjs b/bench/snippets/object-entries.mjs
index c3e4bf9e5b..8c4b331b51 100644
--- a/bench/snippets/object-entries.mjs
+++ b/bench/snippets/object-entries.mjs
@@ -1,5 +1,5 @@
 // so it can run in environments without node module resolution
-import { bench, run } from "../../node_modules/mitata/src/cli.mjs";
+import { bench, run } from "../runner.mjs";
 
 const obj = {
   a: 1,
diff --git a/bench/snippets/object-values.mjs b/bench/snippets/object-values.mjs
index 5ca6db473b..86e4bef2c1 100644
--- a/bench/snippets/object-values.mjs
+++ b/bench/snippets/object-values.mjs
@@ -24,7 +24,7 @@ const obj = {
   w: 23,
 };
 
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 var val = 0;
 bench("Object.values(literal)", () => {
diff --git a/bench/snippets/path-resolve.mjs b/bench/snippets/path-resolve.mjs
index 1e0a40456f..8263a7b048 100644
--- a/bench/snippets/path-resolve.mjs
+++ b/bench/snippets/path-resolve.mjs
@@ -1,5 +1,5 @@
-import { bench, run } from "mitata";
 import { posix } from "path";
+import { bench, run } from "../runner.mjs";
 
 const pathConfigurations = [
   "",
diff --git a/bench/snippets/pbkdf2.mjs b/bench/snippets/pbkdf2.mjs
index a4f6ac8b58..3b286543ec 100644
--- a/bench/snippets/pbkdf2.mjs
+++ b/bench/snippets/pbkdf2.mjs
@@ -1,6 +1,6 @@
 import { pbkdf2 } from "node:crypto";
 
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 const password = "password";
 const salt = "salt";
diff --git a/bench/snippets/peek-promise.mjs b/bench/snippets/peek-promise.mjs
index f883d4d4c5..9468efca25 100644
--- a/bench/snippets/peek-promise.mjs
+++ b/bench/snippets/peek-promise.mjs
@@ -1,5 +1,5 @@
 import { peek } from "bun";
-import { bench, run } from "mitata";
+import { bench, run } from "../runner.mjs";
 
 let pending = Bun.sleep(1000);
 let resolved = Promise.resolve(1);
diff --git a/bench/snippets/performance-now-overhead.js b/bench/snippets/performance-now-overhead.js
index b5283b6ff2..b7626e3312 100644
--- a/bench/snippets/performance-now-overhead.js
+++ b/bench/snippets/performance-now-overhead.js
@@ -1,4 +1,4 @@
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 bench("performance.now x 1000", () => {
   for (let i = 0; i < 1000; i++) {
     performance.now();
diff --git a/bench/snippets/private.mjs b/bench/snippets/private.mjs
index 452dab06b7..2cf72a3ced 100644
--- a/bench/snippets/private.mjs
+++ b/bench/snippets/private.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "../node_modules/mitata/src/cli.mjs";
+import { bench, run } from "../runner.mjs";
 // This is a benchmark of the performance impact of using private properties.
 
 bench("Polyfillprivate", () => {
diff --git a/bench/snippets/process-cwd.mjs b/bench/snippets/process-cwd.mjs
index 28df045acb..9d7576e253 100644
--- a/bench/snippets/process-cwd.mjs
+++ b/bench/snippets/process-cwd.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "mitata";
+import { bench, run } from "../runner.mjs";
 
 bench("process.cwd()", () => {
   process.cwd();
diff --git a/bench/snippets/process-info.mjs b/bench/snippets/process-info.mjs
index 13e54e50e7..bb053a205f 100644
--- a/bench/snippets/process-info.mjs
+++ b/bench/snippets/process-info.mjs
@@ -1,5 +1,5 @@
 import { performance } from "perf_hooks";
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 bench("process.memoryUsage()", () => {
   process.memoryUsage();
diff --git a/bench/snippets/process.mjs b/bench/snippets/process.mjs
index 40bb48e0e1..666fc8dcaf 100644
--- a/bench/snippets/process.mjs
+++ b/bench/snippets/process.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 bench("process.stderr.write('hey')", () => {
   process.stderr.write("hey");
diff --git a/bench/snippets/react-dom-render.bun.js b/bench/snippets/react-dom-render.bun.js
index 11485b021e..d808b9547f 100644
--- a/bench/snippets/react-dom-render.bun.js
+++ b/bench/snippets/react-dom-render.bun.js
@@ -1,6 +1,6 @@
 import { renderToReadableStream as renderToReadableStreamBun } from "react-dom/server";
 import { renderToReadableStream } from "react-dom/server.browser";
-import { bench, group, run } from "./runner.mjs";
+import { bench, group, run } from "../runner.mjs";
 
 const App = () => (
   <div>
diff --git a/bench/snippets/read-file-chunk.mjs b/bench/snippets/read-file-chunk.mjs
index fafdd76b41..7a0526e1f1 100644
--- a/bench/snippets/read-file-chunk.mjs
+++ b/bench/snippets/read-file-chunk.mjs
@@ -1,7 +1,7 @@
 import { createReadStream, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { sep } from "node:path";
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 if (!Promise.withResolvers) {
   Promise.withResolvers = function () {
diff --git a/bench/snippets/read-file.mjs b/bench/snippets/read-file.mjs
index b808dee792..8a9e1f1825 100644
--- a/bench/snippets/read-file.mjs
+++ b/bench/snippets/read-file.mjs
@@ -1,5 +1,5 @@
 import { readFileSync, writeFileSync } from "node:fs";
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 var short = (function () {
   const text = "Hello World!";
diff --git a/bench/snippets/readdir.mjs b/bench/snippets/readdir.mjs
index 4afd214438..7a43cc6fdc 100644
--- a/bench/snippets/readdir.mjs
+++ b/bench/snippets/readdir.mjs
@@ -4,7 +4,7 @@ import { readdir } from "fs/promises";
 import { relative, resolve } from "path";
 import { argv } from "process";
 import { fileURLToPath } from "url";
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 let dir = resolve(argv.length > 2 ? argv[2] : fileURLToPath(new URL("../../node_modules", import.meta.url)));
 if (dir.includes(process.cwd())) {
@@ -43,8 +43,11 @@ bench(`await readdir("${dir}", {recursive: false})`, async () => {
 });
 
 await run();
-console.log("\n", count, "files/dirs in", dir, "\n", "SHA256:", hash, "\n");
 
-if (count !== syncCount) {
-  throw new Error(`Mismatched file counts: ${count} async !== ${syncCount} sync`);
+if (!process?.env?.BENCHMARK_RUNNER) {
+  console.log("\n", count, "files/dirs in", dir, "\n", "SHA256:", hash, "\n");
+
+  if (count !== syncCount) {
+    throw new Error(`Mismatched file counts: ${count} async !== ${syncCount} sync`);
+  }
 }
diff --git a/bench/snippets/readfile-not-found.mjs b/bench/snippets/readfile-not-found.mjs
index 65c3a30e8c..af90ba1f6b 100644
--- a/bench/snippets/readfile-not-found.mjs
+++ b/bench/snippets/readfile-not-found.mjs
@@ -1,6 +1,6 @@
 import { readFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 bench(`readFileSync(/tmp/404-not-found)`, () => {
   try {
diff --git a/bench/snippets/realpath.mjs b/bench/snippets/realpath.mjs
index d7fd2ec7a7..30f2bf8da0 100644
--- a/bench/snippets/realpath.mjs
+++ b/bench/snippets/realpath.mjs
@@ -1,5 +1,5 @@
 import { realpathSync } from "node:fs";
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 const count = parseInt(process.env.ITERATIONS || "1", 10) || 1;
 const arg = process.argv[process.argv.length - 1];
 
diff --git a/bench/snippets/request-response-clone.mjs b/bench/snippets/request-response-clone.mjs
index 05a9806560..9ba1f25d93 100644
--- a/bench/snippets/request-response-clone.mjs
+++ b/bench/snippets/request-response-clone.mjs
@@ -1,5 +1,5 @@
 // This mostly exists to check for a memory leak in response.clone()
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 const req = new Request("http://localhost:3000/");
 const resp = await fetch("http://example.com");
diff --git a/bench/snippets/response-arrayBuffer.mjs b/bench/snippets/response-arrayBuffer.mjs
index a3b1f0a730..255c46e7d8 100644
--- a/bench/snippets/response-arrayBuffer.mjs
+++ b/bench/snippets/response-arrayBuffer.mjs
@@ -1,6 +1,6 @@
 // This snippet mostly exists to reproduce a memory leak
 //
-import { bench, run } from "mitata";
+import { bench, run } from "../runner.mjs";
 
 const obj = {
   "id": 1296269,
diff --git a/bench/snippets/response-json.mjs b/bench/snippets/response-json.mjs
index dd28203f0b..2cd20523b6 100644
--- a/bench/snippets/response-json.mjs
+++ b/bench/snippets/response-json.mjs
@@ -1,5 +1,5 @@
 // This snippet mostly exists to reproduce a memory leak
-import { bench, run } from "mitata";
+import { bench, run } from "../runner.mjs";
 
 const obj = {
   "id": 1296269,
diff --git a/bench/snippets/return-await.mjs b/bench/snippets/return-await.mjs
index 079eb4bdd0..4ccdccf549 100644
--- a/bench/snippets/return-await.mjs
+++ b/bench/snippets/return-await.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "../node_modules/mitata/src/cli.mjs";
+import { bench, run } from "../runner.mjs";
 
 bench("return await Promise.resolve(1)", async function () {
   return await Promise.resolve(1);
diff --git a/bench/snippets/rewriter.mjs b/bench/snippets/rewriter.mjs
index abdc7f0af5..4cb1143aac 100644
--- a/bench/snippets/rewriter.mjs
+++ b/bench/snippets/rewriter.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 const blob = new Blob(["<p id='foo'>Hello</p>"]);
 bench("prepend", async () => {
diff --git a/bench/snippets/runner.mjs b/bench/snippets/runner.mjs
deleted file mode 100644
index 1b985c716b..0000000000
--- a/bench/snippets/runner.mjs
+++ /dev/null
@@ -1,22 +0,0 @@
-import process from "node:process";
-import * as Mitata from "../node_modules/mitata/src/cli.mjs";
-
-const asJSON = !!process?.env?.BENCHMARK_RUNNER;
-
-export function run(opts = {}) {
-  opts ??= {};
-
-  if (asJSON) {
-    opts.json = true;
-  }
-
-  return Mitata.run(opts);
-}
-
-export function bench(name, fn) {
-  return Mitata.bench(name, fn);
-}
-
-export function group(name, fn) {
-  return Mitata.group(name, fn);
-}
diff --git a/bench/snippets/semver.mjs b/bench/snippets/semver.mjs
index bacacef214..7b3d599a58 100644
--- a/bench/snippets/semver.mjs
+++ b/bench/snippets/semver.mjs
@@ -1,5 +1,5 @@
 import { satisfies } from "semver";
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 const tests = [
   ["~1.2.3", "1.2.3", true],
   ["~1.2", "1.2.0", true],
diff --git a/bench/snippets/serialize.mjs b/bench/snippets/serialize.mjs
index acd21c5c6c..80da320dfb 100644
--- a/bench/snippets/serialize.mjs
+++ b/bench/snippets/serialize.mjs
@@ -1,5 +1,5 @@
 import { deserialize, serialize } from "node:v8";
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 const obj = {
   "id": 1296269,
   "node_id": "MDEwOlJlcG9zaXRvcnkxMjk2MjY5",
diff --git a/bench/snippets/sha512.js b/bench/snippets/sha512.js
index 9b3dcdd7a5..548bbc096b 100644
--- a/bench/snippets/sha512.js
+++ b/bench/snippets/sha512.js
@@ -1,5 +1,5 @@
 import { SHA512 } from "bun";
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 bench('SHA512.hash("hello world")', () => {
   SHA512.hash("hello world");
diff --git a/bench/snippets/sha512.node.mjs b/bench/snippets/sha512.node.mjs
index e373c4cb36..26268ea0ab 100644
--- a/bench/snippets/sha512.node.mjs
+++ b/bench/snippets/sha512.node.mjs
@@ -1,5 +1,5 @@
 import { createHash } from "crypto";
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 bench('createHash("sha256").update("hello world").digest()', () => {
   createHash("sha256").update("hello world").digest();
diff --git a/bench/snippets/shell-spawn.mjs b/bench/snippets/shell-spawn.mjs
index eab129eae9..c3aaf557db 100644
--- a/bench/snippets/shell-spawn.mjs
+++ b/bench/snippets/shell-spawn.mjs
@@ -1,6 +1,6 @@
 import { $ as execa$ } from "execa";
 import { $ as zx } from "zx";
-import { bench, group, run } from "./runner.mjs";
+import { bench, group, run } from "../runner.mjs";
 
 const execa = execa$({ stdio: "ignore", cwd: import.meta.dirname });
 
diff --git a/bench/snippets/spawn-hugemem.mjs b/bench/snippets/spawn-hugemem.mjs
index 177382c743..792381ab0d 100644
--- a/bench/snippets/spawn-hugemem.mjs
+++ b/bench/snippets/spawn-hugemem.mjs
@@ -1,5 +1,5 @@
 import { spawnSync } from "bun";
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 var memory = new Uint8Array(128 * 1024 * 1024);
 memory.fill(10);
diff --git a/bench/snippets/spawn-hugemem.node.mjs b/bench/snippets/spawn-hugemem.node.mjs
index d33a5d4bd4..489c1c33e9 100644
--- a/bench/snippets/spawn-hugemem.node.mjs
+++ b/bench/snippets/spawn-hugemem.node.mjs
@@ -1,5 +1,5 @@
 import { spawnSync } from "child_process";
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 var memory = new Uint8Array(128 * 1024 * 1024);
 memory.fill(10);
diff --git a/bench/snippets/spawn.deno.mjs b/bench/snippets/spawn.deno.mjs
index 0e96d9e93e..198d3d43ce 100644
--- a/bench/snippets/spawn.deno.mjs
+++ b/bench/snippets/spawn.deno.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "../node_modules/mitata/src/cli.mjs";
+import { bench, run } from "../runner.mjs";
 
 bench("spawnSync echo hi", () => {
   Deno.spawnSync("echo", {
diff --git a/bench/snippets/spawn.mjs b/bench/snippets/spawn.mjs
index 9c259b096f..8836f19aab 100644
--- a/bench/snippets/spawn.mjs
+++ b/bench/snippets/spawn.mjs
@@ -1,5 +1,5 @@
 import { spawnSync } from "bun";
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 bench("spawnSync echo hi", () => {
   spawnSync({ cmd: ["echo", "hi"] });
diff --git a/bench/snippets/spawn.node.mjs b/bench/snippets/spawn.node.mjs
index c72a3bf036..008949d990 100644
--- a/bench/snippets/spawn.node.mjs
+++ b/bench/snippets/spawn.node.mjs
@@ -1,6 +1,6 @@
 // @runtime bun,node,deno
 import { spawnSync } from "node:child_process";
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 bench("spawnSync echo hi", () => {
   spawnSync("echo", ["hi"], { encoding: "buffer", shell: false });
diff --git a/bench/snippets/stat.mjs b/bench/snippets/stat.mjs
index f39840123f..68fd1f5135 100644
--- a/bench/snippets/stat.mjs
+++ b/bench/snippets/stat.mjs
@@ -1,6 +1,6 @@
 import { statSync } from "fs";
 import { argv } from "process";
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 const dir = argv.length > 2 ? argv[2] : "/tmp";
 
diff --git a/bench/snippets/stderr.mjs b/bench/snippets/stderr.mjs
index 1c348a3f46..e06c388588 100644
--- a/bench/snippets/stderr.mjs
+++ b/bench/snippets/stderr.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 var writer = globalThis.Bun ? Bun.stderr.writer() : undefined;
 if (writer)
diff --git a/bench/snippets/string-decoder.mjs b/bench/snippets/string-decoder.mjs
index 950bce9c56..1969937441 100644
--- a/bench/snippets/string-decoder.mjs
+++ b/bench/snippets/string-decoder.mjs
@@ -1,5 +1,5 @@
 import { StringDecoder } from "string_decoder";
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 var short = Buffer.from("Hello World!");
 var shortUTF16 = Buffer.from("Hello World 💕💕💕");
diff --git a/bench/snippets/string-width.mjs b/bench/snippets/string-width.mjs
index d37046f832..d75507657a 100644
--- a/bench/snippets/string-width.mjs
+++ b/bench/snippets/string-width.mjs
@@ -1,5 +1,5 @@
 import npmStringWidth from "string-width";
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 const bunStringWidth = globalThis?.Bun?.stringWidth;
 
diff --git a/bench/snippets/structuredClone.mjs b/bench/snippets/structuredClone.mjs
index 3007b22f56..684acd3b19 100644
--- a/bench/snippets/structuredClone.mjs
+++ b/bench/snippets/structuredClone.mjs
@@ -31,7 +31,7 @@ var testArray = [
   },
 ];
 
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 bench("structuredClone(array)", () => structuredClone(testArray));
 bench("structuredClone(123)", () => structuredClone(123));
diff --git a/bench/snippets/text-decoder-stream.mjs b/bench/snippets/text-decoder-stream.mjs
index 5495fdc09b..c30e45f1b5 100644
--- a/bench/snippets/text-decoder-stream.mjs
+++ b/bench/snippets/text-decoder-stream.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 const latin1 = `hello hello hello!!!! `.repeat(10240);
 
diff --git a/bench/snippets/text-decoder.mjs b/bench/snippets/text-decoder.mjs
index 340815e9df..5bf0e90cbf 100644
--- a/bench/snippets/text-decoder.mjs
+++ b/bench/snippets/text-decoder.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "../node_modules/mitata/src/cli.mjs";
+import { bench, run } from "../runner.mjs";
 
 var short = new TextEncoder().encode("Hello World!");
 var shortUTF16 = new TextEncoder().encode("Hello World 💕💕💕");
diff --git a/bench/snippets/text-encoder-stream.mjs b/bench/snippets/text-encoder-stream.mjs
index 788e3fb50b..ee83f90d5c 100644
--- a/bench/snippets/text-encoder-stream.mjs
+++ b/bench/snippets/text-encoder-stream.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 const latin1 = `hello hello hello!!!! `.repeat(10240);
 
diff --git a/bench/snippets/text-encoder.mjs b/bench/snippets/text-encoder.mjs
index d0f5c40a4d..674345177d 100644
--- a/bench/snippets/text-encoder.mjs
+++ b/bench/snippets/text-encoder.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 var short = "Hello World!";
 var shortUTF16 = "Hello World 💕💕💕";
diff --git a/bench/snippets/transpiler-2.mjs b/bench/snippets/transpiler-2.mjs
index 702fda9d18..fdf3deb713 100644
--- a/bench/snippets/transpiler-2.mjs
+++ b/bench/snippets/transpiler-2.mjs
@@ -1,5 +1,5 @@
-import { bench, run } from "mitata";
 import { join } from "path";
+import { bench, run } from "../runner.mjs";
 
 const code = require("fs").readFileSync(
   process.argv[2] || join(import.meta.dir, "../node_modules/@babel/standalone/babel.min.js"),
diff --git a/bench/snippets/transpiler.mjs b/bench/snippets/transpiler.mjs
index 5423416067..f453270435 100644
--- a/bench/snippets/transpiler.mjs
+++ b/bench/snippets/transpiler.mjs
@@ -2,7 +2,7 @@ import { readFileSync } from "fs";
 import { createRequire } from "module";
 import { dirname } from "path";
 import { fileURLToPath } from "url";
-import { bench, group, run } from "./runner.mjs";
+import { bench, group, run } from "../runner.mjs";
 const require = createRequire(import.meta.url);
 const esbuild_ = require("esbuild/lib/main");
 const swc_ = require("@swc/core");
diff --git a/bench/snippets/url.mjs b/bench/snippets/url.mjs
index 1cb6e7a8f1..d794b7f6d6 100644
--- a/bench/snippets/url.mjs
+++ b/bench/snippets/url.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 bench(`new URL('https://example.com/')`, () => {
   const url = new URL("https://example.com/");
diff --git a/bench/snippets/urlsearchparams.mjs b/bench/snippets/urlsearchparams.mjs
index af653c917f..83a874dc5f 100644
--- a/bench/snippets/urlsearchparams.mjs
+++ b/bench/snippets/urlsearchparams.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 // bench("new URLSearchParams({})", () => {
 //   return new URLSearchParams({});
diff --git a/bench/snippets/util-deprecate.mjs b/bench/snippets/util-deprecate.mjs
index 364601d79a..1acd31f5a1 100644
--- a/bench/snippets/util-deprecate.mjs
+++ b/bench/snippets/util-deprecate.mjs
@@ -1,4 +1,4 @@
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 function deprecateUsingClosure(fn, msg, code) {
   if (process.noDeprecation === true) {
     return fn;
diff --git a/bench/snippets/webcrypto.mjs b/bench/snippets/webcrypto.mjs
index 2d1256cf8f..2ae35652d7 100644
--- a/bench/snippets/webcrypto.mjs
+++ b/bench/snippets/webcrypto.mjs
@@ -1,5 +1,4 @@
-import { group } from "mitata";
-import { bench, run } from "./runner.mjs";
+import { bench, group, run } from "../runner.mjs";
 
 const sizes = [
   ["small (63 bytes)", 63],
@@ -10,7 +9,7 @@ for (let [name, size] of sizes) {
   group(name, () => {
     var buf = new Uint8Array(size);
     for (let algorithm of ["SHA-1", "SHA-256", "SHA-384", "SHA-512"]) {
-      bench(algorithm, async () => {
+      bench(`${algorithm} (${name})`, async () => {
         await crypto.subtle.digest(algorithm, buf);
       });
     }
diff --git a/bench/snippets/write-file-huge.mjs b/bench/snippets/write-file-huge.mjs
index fe874c9399..f79a8ca991 100644
--- a/bench/snippets/write-file-huge.mjs
+++ b/bench/snippets/write-file-huge.mjs
@@ -1,6 +1,6 @@
 import { Buffer } from "node:buffer";
 import { writeFile } from "node:fs/promises";
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 var hugeFile = Buffer.alloc(1024 * 1024 * 64);
 var medFile = Buffer.alloc(1024 * 1024 * 16);
diff --git a/bench/snippets/write-file.mjs b/bench/snippets/write-file.mjs
index 1b054c4daa..e16732cb7e 100644
--- a/bench/snippets/write-file.mjs
+++ b/bench/snippets/write-file.mjs
@@ -1,5 +1,5 @@
 import { writeFileSync } from "node:fs";
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 var short = "Hello World!";
 var shortUTF16 = "Hello World 💕💕💕";
diff --git a/bench/snippets/write.bun.js b/bench/snippets/write.bun.js
index 0a747bf958..a3ea86b871 100644
--- a/bench/snippets/write.bun.js
+++ b/bench/snippets/write.bun.js
@@ -1,6 +1,6 @@
 import { write } from "bun";
 import { openSync } from "fs";
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 bench('write(/tmp/foo.txt, "short string")', async () => {
   await write("/tmp/foo.txt", "short string");
diff --git a/bench/snippets/write.node.mjs b/bench/snippets/write.node.mjs
index 823648a50b..92b97f77c8 100644
--- a/bench/snippets/write.node.mjs
+++ b/bench/snippets/write.node.mjs
@@ -2,7 +2,7 @@
 import { Buffer } from "node:buffer";
 import { openSync, writeSync as write } from "node:fs";
 import { writeFile } from "node:fs/promises";
-import { bench, run } from "./runner.mjs";
+import { bench, run } from "../runner.mjs";
 
 bench("writeFile(/tmp/foo.txt, short string)", async () => {
   await writeFile("/tmp/foo.txt", "short string", "utf8");
diff --git a/bench/sqlite/better-sqlite3.mjs b/bench/sqlite/better-sqlite3.mjs
index 2412d141bd..cf32b3e912 100644
--- a/bench/sqlite/better-sqlite3.mjs
+++ b/bench/sqlite/better-sqlite3.mjs
@@ -1,5 +1,5 @@
-import { bench, run } from "mitata";
 import { createRequire } from "module";
+import { bench, run } from "../runner.mjs";
 
 const require = createRequire(import.meta.url);
 const db = require("better-sqlite3")("./src/northwind.sqlite");
diff --git a/bench/sqlite/bun.js b/bench/sqlite/bun.js
index 3e0bc417ae..9d2167c30b 100644
--- a/bench/sqlite/bun.js
+++ b/bench/sqlite/bun.js
@@ -1,5 +1,5 @@
 import { Database } from "bun:sqlite";
-import { bench, run } from "mitata";
+import { bench, run } from "../runner.mjs";
 import { join } from "path";
 
 const db = Database.open(join(import.meta.dir, "src", "northwind.sqlite"));
diff --git a/bench/sqlite/deno.js b/bench/sqlite/deno.js
index f4e4cc1b3b..74ab5b9ebe 100644
--- a/bench/sqlite/deno.js
+++ b/bench/sqlite/deno.js
@@ -1,5 +1,5 @@
 import { Database } from "https://deno.land/x/sqlite3@0.11.1/mod.ts";
-import { bench, run } from "../node_modules/mitata/src/cli.mjs";
+import { bench, run } from "../runner.mjs";
 
 const db = new Database("./src/northwind.sqlite");
 
diff --git a/bench/sqlite/node.mjs b/bench/sqlite/node.mjs
index 6e2fb2dc9f..e620913aaa 100644
--- a/bench/sqlite/node.mjs
+++ b/bench/sqlite/node.mjs
@@ -1,7 +1,7 @@
 // Run `node --experimental-sqlite bench/sqlite/node.mjs` to run the script.
 // You will need `--experimental-sqlite` flag to run this script and node v22.5.0 or higher.
-import { bench, run } from "mitata";
 import { DatabaseSync as Database } from "node:sqlite";
+import { bench, run } from "../runner.mjs";
 
 const db = new Database("./src/northwind.sqlite");
 
diff --git a/bench/sqlite/package.json b/bench/sqlite/package.json
index 593a0c83fc..42330f727d 100644
--- a/bench/sqlite/package.json
+++ b/bench/sqlite/package.json
@@ -5,10 +5,10 @@
   },
   "scripts": {
     "build": "exit 0",
-    "bench:bun": "$BUN bun.js",
-    "bench:node": "$NODE node.mjs",
+    "bench:bun": "bun bun.js",
+    "bench:node": "node node.mjs",
     "deps": "npm install && bash src/download.sh",
-    "bench:deno": "$DENO run -A --unstable-ffi deno.js",
+    "bench:deno": "deno run -A --unstable-ffi deno.js",
     "bench": "bun run bench:bun && bun run bench:node && bun run bench:deno"
   }
 }
diff --git a/build.zig b/build.zig
index 064f47852e..cfc512ad8d 100644
--- a/build.zig
+++ b/build.zig
@@ -52,14 +52,14 @@ const BunBuildOptions = struct {
     /// instead of at compile time. This is disabled in release or if this flag
     /// is set (to allow CI to build a portable executable). Affected files:
     ///
-    /// - src/kit/runtime.ts (bundled)
+    /// - src/bake/runtime.ts (bundled)
     /// - src/bun.js/api/FFI.h
     ///
     /// A similar technique is used in C++ code for JavaScript builtins
-    force_embed_code: bool = false,
+    codegen_embed: bool = false,
 
     /// `./build/codegen` or equivalent
-    generated_code_dir: []const u8,
+    codegen_path: []const u8,
     no_llvm: bool,
 
     cached_options_module: ?*Module = null,
@@ -71,7 +71,7 @@ const BunBuildOptions = struct {
     }
 
     pub fn shouldEmbedCode(opts: *const BunBuildOptions) bool {
-        return opts.optimize != .Debug or opts.force_embed_code;
+        return opts.optimize != .Debug or opts.codegen_embed;
     }
 
     pub fn buildOptionsModule(this: *BunBuildOptions, b: *Build) *Module {
@@ -83,10 +83,10 @@ const BunBuildOptions = struct {
         opts.addOption([]const u8, "base_path", b.pathFromRoot("."));
         opts.addOption([]const u8, "codegen_path", std.fs.path.resolve(b.graph.arena, &.{
             b.build_root.path.?,
-            this.generated_code_dir,
+            this.codegen_path,
         }) catch @panic("OOM"));
 
-        opts.addOption(bool, "embed_code", this.shouldEmbedCode());
+        opts.addOption(bool, "codegen_embed", this.shouldEmbedCode());
         opts.addOption(u32, "canary_revision", this.canary_revision orelse 0);
         opts.addOption(bool, "is_canary", this.canary_revision != null);
         opts.addOption(Version, "version", this.version);
@@ -157,7 +157,7 @@ pub fn build(b: *Build) !void {
 
     // TODO: Upgrade path for 0.14.0
     // b.graph.zig_lib_directory = brk: {
-    //     const sub_path = "src/deps/zig/lib";
+    //     const sub_path = "vendor/zig/lib";
     //     const dir = try b.build_root.handle.openDir(sub_path, .{});
     //     break :brk .{ .handle = dir, .path = try b.build_root.join(b.graph.arena, &.{sub_path}) };
     // };
@@ -165,7 +165,7 @@ pub fn build(b: *Build) !void {
     var target_query = b.standardTargetOptionsQueryOnly(.{});
     const optimize = b.standardOptimizeOption(.{});
 
-    const os, const arch = brk: {
+    const os, const arch, const abi = brk: {
         // resolve the target query to pick up what operating system and cpu
         // architecture that is desired. this information is used to slightly
         // refine the query.
@@ -179,7 +179,8 @@ pub fn build(b: *Build) !void {
             .windows => .windows,
             else => |t| std.debug.panic("Unsupported OS tag {}", .{t}),
         };
-        break :brk .{ os, arch };
+        const abi = temp_resolved.result.abi;
+        break :brk .{ os, arch, abi };
     };
 
     // target must be refined to support older but very popular devices on
@@ -191,16 +192,17 @@ pub fn build(b: *Build) !void {
     }
 
     target_query.os_version_min = getOSVersionMin(os);
-    target_query.glibc_version = getOSGlibCVersion(os);
+    target_query.glibc_version = if (abi.isGnu()) getOSGlibCVersion(os) else null;
 
     const target = b.resolveTargetQuery(target_query);
 
-    const generated_code_dir = b.pathFromRoot(
-        b.option([]const u8, "generated-code", "Set the generated code directory") orelse
+    const codegen_path = b.pathFromRoot(
+        b.option([]const u8, "codegen_path", "Set the generated code directory") orelse
             "build/debug/codegen",
     );
+    const codegen_embed = b.option(bool, "codegen_embed", "If codegen files should be embedded in the binary") orelse false;
+
     const bun_version = b.option([]const u8, "version", "Value of `Bun.version`") orelse "0.0.0";
-    const force_embed_js_code = b.option(bool, "force_embed_js_code", "Always embed JavaScript builtins") orelse false;
 
     b.reference_trace = ref_trace: {
         const trace = b.option(u32, "reference-trace", "Set the reference trace") orelse 16;
@@ -218,8 +220,8 @@ pub fn build(b: *Build) !void {
         .os = os,
         .arch = arch,
 
-        .generated_code_dir = generated_code_dir,
-        .force_embed_code = force_embed_js_code,
+        .codegen_path = codegen_path,
+        .codegen_embed = codegen_embed,
         .no_llvm = no_llvm,
 
         .version = try Version.parse(bun_version),
@@ -234,9 +236,10 @@ pub fn build(b: *Build) !void {
         ),
 
         .sha = sha: {
-            const sha = b.option([]const u8, "sha", "Force the git sha") orelse
-                b.graph.env_map.get("GITHUB_SHA") orelse
-                b.graph.env_map.get("GIT_SHA") orelse fetch_sha: {
+            const sha_buildoption = b.option([]const u8, "sha", "Force the git sha");
+            const sha_github = b.graph.env_map.get("GITHUB_SHA");
+            const sha_env = b.graph.env_map.get("GIT_SHA");
+            const sha = sha_buildoption orelse sha_github orelse sha_env orelse fetch_sha: {
                 const result = std.process.Child.run(.{
                     .allocator = b.allocator,
                     .argv = &.{
@@ -295,7 +298,7 @@ pub fn build(b: *Build) !void {
         bun_check_obj.generated_bin = null;
         step.dependOn(&bun_check_obj.step);
 
-        // The default install step will run zig build check This is so ZLS
+        // The default install step will run zig build check. This is so ZLS
         // identifies the codebase, as well as performs checking if build on
         // save is enabled.
 
@@ -312,6 +315,8 @@ pub fn build(b: *Build) !void {
             .{ .os = .mac, .arch = .aarch64 },
             .{ .os = .linux, .arch = .x86_64 },
             .{ .os = .linux, .arch = .aarch64 },
+            .{ .os = .linux, .arch = .x86_64, .musl = true },
+            .{ .os = .linux, .arch = .aarch64, .musl = true },
         });
     }
 
@@ -324,20 +329,20 @@ pub fn build(b: *Build) !void {
     }
 }
 
-pub inline fn addMultiCheck(
+pub fn addMultiCheck(
     b: *Build,
     parent_step: *Step,
     root_build_options: BunBuildOptions,
-    to_check: []const struct { os: OperatingSystem, arch: Arch },
+    to_check: []const struct { os: OperatingSystem, arch: Arch, musl: bool = false },
 ) void {
-    inline for (to_check) |check| {
-        inline for (.{ .Debug, .ReleaseFast }) |mode| {
+    for (to_check) |check| {
+        for ([_]std.builtin.Mode{ .Debug, .ReleaseFast }) |mode| {
             const check_target = b.resolveTargetQuery(.{
                 .os_tag = OperatingSystem.stdOSTag(check.os),
                 .cpu_arch = check.arch,
                 .cpu_model = getCpuModel(check.os, check.arch) orelse .determined_by_cpu_arch,
                 .os_version_min = getOSVersionMin(check.os),
-                .glibc_version = getOSGlibCVersion(check.os),
+                .glibc_version = if (check.musl) null else getOSGlibCVersion(check.os),
             });
 
             var options: BunBuildOptions = .{
@@ -351,7 +356,7 @@ pub inline fn addMultiCheck(
                 .tracy_callstack_depth = root_build_options.tracy_callstack_depth,
                 .version = root_build_options.version,
                 .reported_nodejs_version = root_build_options.reported_nodejs_version,
-                .generated_code_dir = root_build_options.generated_code_dir,
+                .codegen_path = root_build_options.codegen_path,
                 .no_llvm = root_build_options.no_llvm,
             };
 
@@ -368,6 +373,7 @@ pub fn addBunObject(b: *Build, opts: *BunBuildOptions) *Compile {
         .root_source_file = switch (opts.os) {
             .wasm => b.path("root_wasm.zig"),
             else => b.path("root.zig"),
+            // else => b.path("root_css.zig"),
         },
         .target = opts.target,
         .optimize = opts.optimize,
@@ -408,6 +414,15 @@ pub fn addBunObject(b: *Build, opts: *BunBuildOptions) *Compile {
     }
     addInternalPackages(b, obj, opts);
     obj.root_module.addImport("build_options", opts.buildOptionsModule(b));
+
+    const translate_plugin_api = b.addTranslateC(.{
+        .root_source_file = b.path("./packages/bun-native-bundler-plugin-api/bundler_plugin.h"),
+        .target = opts.target,
+        .optimize = opts.optimize,
+        .link_libc = true,
+    });
+    obj.root_module.addImport("bun-native-bundler-plugin-api", translate_plugin_api.createModule());
+
     return obj;
 }
 
@@ -474,13 +489,45 @@ fn addInternalPackages(b: *Build, obj: *Compile, opts: *BunBuildOptions) void {
         .{ .file = "ZigGeneratedClasses.zig", .import = "ZigGeneratedClasses" },
         .{ .file = "ResolvedSourceTag.zig", .import = "ResolvedSourceTag" },
         .{ .file = "ErrorCode.zig", .import = "ErrorCode" },
-        .{ .file = "kit.client.js", .import = "kit-codegen/kit.client.js", .enable = opts.shouldEmbedCode() },
-        .{ .file = "kit.server.js", .import = "kit-codegen/kit.server.js", .enable = opts.shouldEmbedCode() },
+        .{ .file = "runtime.out.js" },
+        .{ .file = "bake.client.js", .import = "bake-codegen/bake.client.js", .enable = opts.shouldEmbedCode() },
+        .{ .file = "bake.error.js", .import = "bake-codegen/bake.error.js", .enable = opts.shouldEmbedCode() },
+        .{ .file = "bake.server.js", .import = "bake-codegen/bake.server.js", .enable = opts.shouldEmbedCode() },
+        .{ .file = "bun-error/index.js", .enable = opts.shouldEmbedCode() },
+        .{ .file = "bun-error/bun-error.css", .enable = opts.shouldEmbedCode() },
+        .{ .file = "fallback-decoder.js", .enable = opts.shouldEmbedCode() },
+        .{ .file = "node-fallbacks/assert.js" },
+        .{ .file = "node-fallbacks/buffer.js" },
+        .{ .file = "node-fallbacks/console.js" },
+        .{ .file = "node-fallbacks/constants.js" },
+        .{ .file = "node-fallbacks/crypto.js" },
+        .{ .file = "node-fallbacks/domain.js" },
+        .{ .file = "node-fallbacks/events.js" },
+        .{ .file = "node-fallbacks/http.js" },
+        .{ .file = "node-fallbacks/https.js" },
+        .{ .file = "node-fallbacks/net.js" },
+        .{ .file = "node-fallbacks/os.js" },
+        .{ .file = "node-fallbacks/path.js" },
+        .{ .file = "node-fallbacks/process.js" },
+        .{ .file = "node-fallbacks/punycode.js" },
+        .{ .file = "node-fallbacks/querystring.js" },
+        .{ .file = "node-fallbacks/stream.js" },
+        .{ .file = "node-fallbacks/string_decoder.js" },
+        .{ .file = "node-fallbacks/sys.js" },
+        .{ .file = "node-fallbacks/timers.js" },
+        .{ .file = "node-fallbacks/tty.js" },
+        .{ .file = "node-fallbacks/url.js" },
+        .{ .file = "node-fallbacks/util.js" },
+        .{ .file = "node-fallbacks/zlib.js" },
     }) |entry| {
         if (!@hasField(@TypeOf(entry), "enable") or entry.enable) {
-            const path = b.pathJoin(&.{ opts.generated_code_dir, entry.file });
+            const path = b.pathJoin(&.{ opts.codegen_path, entry.file });
             validateGeneratedPath(path);
-            obj.root_module.addAnonymousImport(entry.import, .{
+            const import_path = if (@hasField(@TypeOf(entry), "import"))
+                entry.import
+            else
+                entry.file;
+            obj.root_module.addAnonymousImport(import_path, .{
                 .root_source_file = .{ .cwd_relative = path },
             });
         }
diff --git a/bun.lockb b/bun.lockb
index 9e6b62e3f2..4ccfae2715 100755
Binary files a/bun.lockb and b/bun.lockb differ
diff --git a/ci/README.md b/ci/README.md
new file mode 100644
index 0000000000..fbd89a34dd
--- /dev/null
+++ b/ci/README.md
@@ -0,0 +1,84 @@
+# CI
+
+This directory contains scripts for building CI images for Bun.
+
+## Building
+
+### `macOS`
+
+On macOS, images are built using [`tart`](https://tart.run/), a tool that abstracts over the [`Virtualization.Framework`](https://developer.apple.com/documentation/virtualization) APIs, to run macOS VMs.
+
+To install the dependencies required, run:
+
+```sh
+$ cd ci
+$ bun run bootstrap
+```
+
+To build a vanilla macOS VM, run:
+
+```sh
+$ bun run build:darwin-aarch64-vanilla
+```
+
+This builds a vanilla macOS VM with the current macOS release on your machine. It runs scripts to disable things like spotlight and siri, but it does not install any software.
+
+> Note: The image size is 50GB, so make sure you have enough disk space.
+
+If you want to build a specific macOS release, you can run:
+
+```sh
+$ bun run build:darwin-aarch64-vanilla-15
+```
+
+> Note: You cannot build a newer release of macOS on an older macOS machine.
+
+To build a macOS VM with software installed to build and test Bun, run:
+
+```sh
+$ bun run build:darwin-aarch64
+```
+
+## Running
+
+### `macOS`
+
+## How To
+
+### Support a new macOS release
+
+1. Visit [`ipsw.me`](https://ipsw.me/VirtualMac2,1) and find the IPSW of the macOS release you want to build.
+
+2. Add an entry to [`ci/darwin/variables.pkr.hcl`](/ci/darwin/variables.pkr.hcl) with the following format:
+
+```hcl
+sonoma = {
+  distro  = "sonoma"
+  release = "15"
+  ipsw    = "https://updates.cdn-apple.com/..."
+}
+```
+
+3. Add matching scripts to [`ci/package.json`](/ci/package.json) to build the image, then test it:
+
+```sh
+$ bun run build:darwin-aarch64-vanilla-15
+```
+
+> Note: If you need to troubleshoot the build, you can remove the `headless = true` property from [`ci/darwin/image-vanilla.pkr.hcl`](/ci/darwin/image-vanilla.pkr.hcl) and the VM's screen will be displayed.
+
+4. Test and build the non-vanilla image:
+
+```sh
+$ bun run build:darwin-aarch64-15
+```
+
+This will use the vanilla image and run the [`scripts/bootstrap.sh`](/scripts/bootstrap.sh) script to install the required software to build and test Bun.
+
+5. Publish the images:
+
+```sh
+$ bun run login
+$ bun run publish:darwin-aarch64-vanilla-15
+$ bun run publish:darwin-aarch64-15
+```
diff --git a/ci/alpine/build.Dockerfile b/ci/alpine/build.Dockerfile
new file mode 100644
index 0000000000..f1f9aabb87
--- /dev/null
+++ b/ci/alpine/build.Dockerfile
@@ -0,0 +1,22 @@
+FROM alpine:edge AS build
+ARG GIT_SHA
+ENV GIT_SHA=${GIT_SHA}
+WORKDIR /app/bun
+ENV HOME=/root
+
+COPY . .
+RUN touch $HOME/.bashrc
+RUN ./scripts/bootstrap.sh
+RUN . $HOME/.bashrc && bun run build:release
+
+RUN apk add file
+RUN file ./build/release/bun
+RUN ldd ./build/release/bun
+RUN ./build/release/bun
+
+RUN cp -R /app/bun/build/* /output
+
+FROM scratch AS artifact
+COPY --from=build /output /
+
+# docker build -f ./ci/alpine/build.Dockerfile --progress=plain --build-arg GIT_SHA="$(git rev-parse HEAD)" --target=artifact --output type=local,dest=./build-alpine .
diff --git a/ci/alpine/test.Dockerfile b/ci/alpine/test.Dockerfile
new file mode 100644
index 0000000000..e6836fe9d2
--- /dev/null
+++ b/ci/alpine/test.Dockerfile
@@ -0,0 +1,20 @@
+FROM alpine:edge
+ENV HOME=/root
+WORKDIR /root
+COPY ./build-alpine/release/bun .
+COPY ./test ./test
+COPY ./scripts ./scripts
+COPY ./package.json ./package.json
+COPY ./packages ./packages
+
+RUN apk update
+RUN apk add nodejs lsb-release-minimal git python3 npm make g++
+RUN apk add file
+
+RUN file /root/bun
+RUN ldd /root/bun
+RUN /root/bun
+
+RUN ./scripts/runner.node.mjs --exec-path /root/bun
+
+# docker build -f ./ci/alpine/test.Dockerfile --progress=plain .
diff --git a/ci/darwin/image-vanilla.pkr.hcl b/ci/darwin/image-vanilla.pkr.hcl
new file mode 100644
index 0000000000..40455713b4
--- /dev/null
+++ b/ci/darwin/image-vanilla.pkr.hcl
@@ -0,0 +1,46 @@
+# Generates a vanilla macOS VM with optimized settings for virtualized environments.
+# See login.sh and optimize.sh for details.
+
+data "external-raw" "boot-script" {
+  program = ["sh", "-c", templatefile("scripts/boot-image.sh", var)]
+}
+
+source "tart-cli" "bun-darwin-aarch64-vanilla" {
+  vm_name      = "bun-darwin-aarch64-vanilla-${local.release.distro}-${local.release.release}"
+  from_ipsw    = local.release.ipsw
+  cpu_count    = local.cpu_count
+  memory_gb    = local.memory_gb
+  disk_size_gb = local.disk_size_gb
+  ssh_username = local.username
+  ssh_password = local.password
+  ssh_timeout  = "120s"
+  create_grace_time = "30s"
+  boot_command = split("\n", data.external-raw.boot-script.result)
+  headless     = true # Disable if you need to debug why the boot_command is not working
+}
+
+build {
+  sources = ["source.tart-cli.bun-darwin-aarch64-vanilla"]
+
+  provisioner "file" {
+    content = file("scripts/setup-login.sh")
+    destination = "/tmp/setup-login.sh"
+  }
+
+  provisioner "shell" {
+    inline = ["echo \"${local.password}\" | sudo -S sh -c 'sh /tmp/setup-login.sh \"${local.username}\" \"${local.password}\"'"]
+  }
+
+  provisioner "file" {
+    content = file("scripts/optimize-machine.sh")
+    destination = "/tmp/optimize-machine.sh"
+  }
+
+  provisioner "shell" {
+    inline = ["sudo sh /tmp/optimize-machine.sh"]
+  }
+
+  provisioner "shell" {
+    inline = ["sudo rm -rf /tmp/*"]
+  }
+}
diff --git a/ci/darwin/image.pkr.hcl b/ci/darwin/image.pkr.hcl
new file mode 100644
index 0000000000..b536efbecb
--- /dev/null
+++ b/ci/darwin/image.pkr.hcl
@@ -0,0 +1,44 @@
+# Generates a macOS VM with software installed to build and test Bun.
+
+source "tart-cli" "bun-darwin-aarch64" {
+  vm_name      = "bun-darwin-aarch64-${local.release.distro}-${local.release.release}"
+  vm_base_name = "bun-darwin-aarch64-vanilla-${local.release.distro}-${local.release.release}"
+  cpu_count    = local.cpu_count
+  memory_gb    = local.memory_gb
+  disk_size_gb = local.disk_size_gb
+  ssh_username = local.username
+  ssh_password = local.password
+  ssh_timeout  = "120s"
+  headless     = true
+}
+
+build {
+  sources = ["source.tart-cli.bun-darwin-aarch64"]
+
+  provisioner "file" {
+    content = file("../../scripts/bootstrap.sh")
+    destination = "/tmp/bootstrap.sh"
+  }
+
+  provisioner "shell" {
+    inline = ["CI=true sh /tmp/bootstrap.sh"]
+  }
+
+  provisioner "file" {
+    source = "darwin/plists/"
+    destination = "/tmp/"
+  }
+
+  provisioner "shell" {
+    inline = [
+      "sudo ls /tmp/",
+      "sudo mv /tmp/*.plist /Library/LaunchDaemons/",
+      "sudo chown root:wheel /Library/LaunchDaemons/*.plist",
+      "sudo chmod 644 /Library/LaunchDaemons/*.plist",
+    ]
+  }
+
+  provisioner "shell" {
+    inline = ["sudo rm -rf /tmp/*"]
+  }
+}
diff --git a/ci/darwin/plists/buildkite-agent.plist b/ci/darwin/plists/buildkite-agent.plist
new file mode 100644
index 0000000000..23c058913f
--- /dev/null
+++ b/ci/darwin/plists/buildkite-agent.plist
@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+  <dict>
+    <key>Label</key>
+    <string>com.buildkite.buildkite-agent</string>
+
+    <key>ProgramArguments</key>
+    <array>
+      <string>/usr/local/bin/buildkite-agent</string>
+      <string>start</string>
+    </array>
+
+    <key>KeepAlive</key>
+    <dict>
+      <key>SuccessfulExit</key>
+      <false />
+    </dict>
+
+    <key>RunAtLoad</key>
+    <true />
+
+    <key>StandardOutPath</key>
+    <string>/var/buildkite-agent/logs/buildkite-agent.log</string>
+
+    <key>StandardErrorPath</key>
+    <string>/var/buildkite-agent/logs/buildkite-agent.log</string>
+
+    <key>EnvironmentVariables</key>
+    <dict>
+      <key>BUILDKITE_AGENT_CONFIG</key>
+      <string>/etc/buildkite-agent/buildkite-agent.cfg</string>
+    </dict>
+
+    <key>LimitLoadToSessionType</key>
+    <array>
+      <string>Aqua</string>
+      <string>LoginWindow</string>
+      <string>Background</string>
+      <string>StandardIO</string>
+      <string>System</string>
+    </array>
+  </dict>
+</plist>
\ No newline at end of file
diff --git a/ci/darwin/plists/tailscale.plist b/ci/darwin/plists/tailscale.plist
new file mode 100644
index 0000000000..cbe3f001b0
--- /dev/null
+++ b/ci/darwin/plists/tailscale.plist
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+  <dict>
+    <key>Label</key>
+    <string>com.tailscale.tailscaled</string>
+
+    <key>ProgramArguments</key>
+    <array>
+      <string>/usr/local/bin/tailscale</string>
+      <string>up</string>
+      <string>--ssh</string>
+      <string>--authkey</string>
+      <string>${TAILSCALE_AUTHKEY}</string>
+    </array>
+
+    <key>RunAtLoad</key>
+    <true />
+  </dict>
+</plist>
\ No newline at end of file
diff --git a/ci/darwin/plists/tailscaled.plist b/ci/darwin/plists/tailscaled.plist
new file mode 100644
index 0000000000..12d316f1ab
--- /dev/null
+++ b/ci/darwin/plists/tailscaled.plist
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+  <dict>
+    <key>Label</key>
+    <string>com.tailscale.tailscaled</string>
+
+    <key>ProgramArguments</key>
+    <array>
+      <string>/usr/local/bin/tailscaled</string>
+    </array>
+
+    <key>RunAtLoad</key>
+    <true />
+  </dict>
+</plist>
\ No newline at end of file
diff --git a/ci/darwin/scripts/boot-image.sh b/ci/darwin/scripts/boot-image.sh
new file mode 100755
index 0000000000..02ae01db03
--- /dev/null
+++ b/ci/darwin/scripts/boot-image.sh
@@ -0,0 +1,124 @@
+#!/bin/sh
+
+# This script generates the boot commands for the macOS installer GUI.
+# It is run on your local machine, not inside the VM.
+
+# Sources:
+# - https://github.com/cirruslabs/macos-image-templates/blob/master/templates/vanilla-sequoia.pkr.hcl
+
+if ! [ "${release}" ] || ! [ "${username}" ] || ! [ "${password}" ]; then
+  echo "Script must be run with variables: release, username, and password" >&2
+  exit 1
+fi
+
+# Hello, hola, bonjour, etc.
+echo "<wait120s><spacebar>"
+
+# Select Your Country and Region
+echo "<wait30s>italiano<esc>english<enter>"
+echo "<wait30s>united states<leftShiftOn><tab><leftShiftOff><spacebar>"
+
+# Written and Spoken Languages
+echo "<wait30s><leftShiftOn><tab><leftShiftOff><spacebar>"
+
+# Accessibility
+echo "<wait30s><leftShiftOn><tab><leftShiftOff><spacebar>"
+
+# Data & Privacy
+echo "<wait30s><leftShiftOn><tab><leftShiftOff><spacebar>"
+
+# Migration Assistant
+echo "<wait30s><tab><tab><tab><spacebar>"
+
+# Sign In with Your Apple ID
+echo "<wait30s><leftShiftOn><tab><leftShiftOff><leftShiftOn><tab><leftShiftOff><spacebar>"
+
+# Are you sure you want to skip signing in with an Apple ID?
+echo "<wait30s><tab><spacebar>"
+
+# Terms and Conditions
+echo "<wait30s><leftShiftOn><tab><leftShiftOff><spacebar>"
+
+# I have read and agree to the macOS Software License Agreement
+echo "<wait30s><tab><spacebar>"
+
+# Create a Computer Account
+echo "<wait30s>${username}<tab><tab>${password}<tab>${password}<tab><tab><tab><spacebar>"
+
+# Enable Location Services
+echo "<wait60s><leftShiftOn><tab><leftShiftOff><spacebar>"
+
+# Are you sure you don't want to use Location Services?
+echo "<wait30s><tab><spacebar>"
+
+# Select Your Time Zone
+echo "<wait30s><tab>UTC<enter><leftShiftOn><tab><leftShiftOff><spacebar>"
+
+# Analytics
+echo "<wait30s><leftShiftOn><tab><leftShiftOff><spacebar>"
+
+# Screen Time
+echo "<wait30s><tab><spacebar>"
+
+# Siri
+echo "<wait30s><tab><spacebar><leftShiftOn><tab><leftShiftOff><spacebar>"
+
+# Choose Your Look
+echo "<wait30s><leftShiftOn><tab><leftShiftOff><spacebar>"
+
+if [ "${release}" = "13" ] || [ "${release}" = "14" ]; then
+  # Enable Voice Over
+  echo "<wait30s><leftAltOn><f5><leftAltOff><wait5s>v"
+else
+  # Welcome to Mac
+  echo "<wait30s><spacebar>"
+
+  # Enable Keyboard navigation
+  echo "<wait30s><leftAltOn><spacebar><leftAltOff>Terminal<enter>"
+  echo "<wait30s>defaults write NSGlobalDomain AppleKeyboardUIMode -int 3<enter>"
+  echo "<wait30s><leftAltOn>q<leftAltOff>"
+fi
+
+# Now that the installation is done, open "System Settings"
+echo "<wait30s><leftAltOn><spacebar><leftAltOff>System Settings<enter>"
+
+# Navigate to "Sharing"
+echo "<wait30s><leftAltOn>f<leftAltOff>sharing<enter>"
+
+if [ "${release}" = "13" ]; then
+  # Navigate to "Screen Sharing" and enable it
+  echo "<wait30s><tab><down><spacebar>"
+
+  # Navigate to "Remote Login" and enable it
+  echo "<wait30s><tab><tab><tab><tab><tab><tab><spacebar>"
+
+  # Open "Remote Login" details
+  echo "<wait30s><tab><spacebar>"
+
+  # Enable "Full Disk Access"
+  echo "<wait30s><tab><spacebar>"
+
+  # Click "Done"
+  echo "<wait30s><leftShiftOn><tab><leftShiftOff><leftShiftOn><tab><leftShiftOff><spacebar>"
+
+  # Disable Voice Over
+  echo "<leftAltOn><f5><leftAltOff>"
+elif [ "${release}" = "14" ]; then
+  # Navigate to "Screen Sharing" and enable it
+  echo "<wait30s><tab><tab><tab><tab><tab><spacebar>"
+
+  # Navigate to "Remote Login" and enable it
+  echo "<wait30s><tab><tab><tab><tab><tab><tab><tab><tab><tab><tab><tab><tab><spacebar>"
+
+  # Disable Voice Over
+  echo "<wait30s><leftAltOn><f5><leftAltOff>"
+elif [ "${release}" = "15" ]; then  
+  # Navigate to "Screen Sharing" and enable it
+  echo "<wait30s><tab><tab><tab><tab><tab><spacebar>"
+
+  # Navigate to "Remote Login" and enable it
+  echo "<wait30s><tab><tab><tab><tab><tab><tab><tab><tab><tab><tab><tab><tab><spacebar>"
+fi
+
+# Quit System Settings
+echo "<wait30s><leftAltOn>q<leftAltOff>"
diff --git a/ci/darwin/scripts/optimize-machine.sh b/ci/darwin/scripts/optimize-machine.sh
new file mode 100644
index 0000000000..1d58ff4bb3
--- /dev/null
+++ b/ci/darwin/scripts/optimize-machine.sh
@@ -0,0 +1,122 @@
+#!/bin/sh
+
+# This script optimizes macOS for virtualized environments.
+# It disables things like spotlight, screen saver, and sleep.
+
+# Sources:
+# - https://github.com/sickcodes/osx-optimizer
+# - https://github.com/koding88/MacBook-Optimization-Script
+# - https://www.macstadium.com/blog/simple-optimizations-for-macos-and-ios-build-agents
+
+if [ "$(id -u)" != "0" ]; then
+  echo "This script must be run using sudo." >&2
+  exit 1
+fi
+
+execute() {
+  echo "$ $@" >&2
+  if ! "$@"; then
+    echo "Command failed: $@" >&2
+    exit 1
+  fi
+}
+
+disable_software_update() {
+  execute softwareupdate --schedule off
+  execute defaults write com.apple.SoftwareUpdate AutomaticDownload -bool false
+  execute defaults write com.apple.SoftwareUpdate AutomaticCheckEnabled -bool false
+  execute defaults write com.apple.SoftwareUpdate ConfigDataInstall -int 0
+  execute defaults write com.apple.SoftwareUpdate CriticalUpdateInstall -int 0
+  execute defaults write com.apple.SoftwareUpdate ScheduleFrequency -int 0
+  execute defaults write com.apple.SoftwareUpdate AutomaticDownload -int 0
+  execute defaults write com.apple.commerce AutoUpdate -bool false
+  execute defaults write com.apple.commerce AutoUpdateRestartRequired -bool false
+}
+
+disable_spotlight() {
+  execute mdutil -i off -a
+  execute mdutil -E /
+}
+
+disable_siri() {
+  execute launchctl unload -w /System/Library/LaunchAgents/com.apple.Siri.agent.plist
+  execute defaults write com.apple.Siri StatusMenuVisible -bool false
+  execute defaults write com.apple.Siri UserHasDeclinedEnable -bool true
+  execute defaults write com.apple.assistant.support "Assistant Enabled" 0
+}
+
+disable_sleep() {
+  execute systemsetup -setsleep Never
+  execute systemsetup -setcomputersleep Never
+  execute systemsetup -setdisplaysleep Never
+  execute systemsetup -setharddisksleep Never
+}
+
+disable_screen_saver() {
+  execute defaults write com.apple.screensaver loginWindowIdleTime 0
+  execute defaults write com.apple.screensaver idleTime 0
+}
+
+disable_screen_lock() {
+  execute defaults write com.apple.loginwindow DisableScreenLock -bool true
+}
+
+disable_wallpaper() {
+  execute defaults write com.apple.loginwindow DesktopPicture ""
+}
+
+disable_application_state() {
+  execute defaults write com.apple.loginwindow TALLogoutSavesState -bool false
+}
+
+disable_accessibility() {
+  execute defaults write com.apple.Accessibility DifferentiateWithoutColor -int 1
+  execute defaults write com.apple.Accessibility ReduceMotionEnabled -int 1
+  execute defaults write com.apple.universalaccess reduceMotion -int 1
+  execute defaults write com.apple.universalaccess reduceTransparency -int 1
+}
+
+disable_dashboard() {
+  execute defaults write com.apple.dashboard mcx-disabled -boolean YES
+  execute killall Dock
+}
+
+disable_animations() {
+  execute defaults write NSGlobalDomain NSAutomaticWindowAnimationsEnabled -bool false
+  execute defaults write -g QLPanelAnimationDuration -float 0
+  execute defaults write com.apple.finder DisableAllAnimations -bool true
+}
+
+disable_time_machine() {
+  execute tmutil disable
+}
+
+enable_performance_mode() {
+  # https://support.apple.com/en-us/101992
+  if ! [ $(nvram boot-args 2>/dev/null | grep -q serverperfmode) ]; then
+    execute nvram boot-args="serverperfmode=1 $(nvram boot-args 2>/dev/null | cut -f 2-)"
+  fi
+}
+
+add_terminal_to_desktop() {
+  execute ln -sf /System/Applications/Utilities/Terminal.app ~/Desktop/Terminal
+}
+
+main() {
+  disable_software_update
+  disable_spotlight
+  disable_siri
+  disable_sleep
+  disable_screen_saver
+  disable_screen_lock
+  disable_wallpaper
+  disable_application_state
+  disable_accessibility
+  disable_dashboard
+  disable_animations
+  disable_time_machine
+  enable_performance_mode
+  add_terminal_to_desktop
+}
+
+main
diff --git a/ci/darwin/scripts/setup-login.sh b/ci/darwin/scripts/setup-login.sh
new file mode 100755
index 0000000000..f68beb26f2
--- /dev/null
+++ b/ci/darwin/scripts/setup-login.sh
@@ -0,0 +1,78 @@
+#!/bin/sh
+
+# This script generates a /etc/kcpassword file to enable auto-login on macOS.
+# Yes, this stores your password in plain text. Do NOT do this on your local machine.
+
+# Sources:
+# - https://github.com/xfreebird/kcpassword/blob/master/kcpassword
+
+if [ "$(id -u)" != "0" ]; then
+  echo "This script must be run using sudo." >&2
+  exit 1
+fi
+
+execute() {
+  echo "$ $@" >&2
+  if ! "$@"; then
+    echo "Command failed: $@" >&2
+    exit 1
+  fi
+}
+
+kcpassword() {
+  passwd="$1"
+  key="7d 89 52 23 d2 bc dd ea a3 b9 1f"
+  passwd_hex=$(printf "%s" "$passwd" | xxd -p | tr -d '\n')
+  
+  key_len=33
+  passwd_len=${#passwd_hex}
+  remainder=$((passwd_len % key_len))
+  if [ $remainder -ne 0 ]; then
+    padding=$((key_len - remainder))
+    passwd_hex="${passwd_hex}$(printf '%0*x' $((padding / 2)) 0)"
+  fi
+
+  result=""
+  i=0
+  while [ $i -lt ${#passwd_hex} ]; do
+    for byte in $key; do
+      [ $i -ge ${#passwd_hex} ] && break
+      p="${passwd_hex:$i:2}"
+      r=$(printf '%02x' $((0x$p ^ 0x$byte)))
+      result="${result}${r}"
+      i=$((i + 2))
+    done
+  done
+
+  echo "$result"
+}
+
+login() {
+  username="$1"
+  password="$2"
+
+  enable_passwordless_sudo() {
+    execute mkdir -p /etc/sudoers.d/
+    echo "${username} ALL=(ALL) NOPASSWD: ALL" | EDITOR=tee execute visudo "/etc/sudoers.d/${username}-nopasswd"
+  }
+
+  enable_auto_login() {
+    echo "00000000: 1ced 3f4a bcbc ba2c caca 4e82" | execute xxd -r - /etc/kcpassword
+    execute defaults write /Library/Preferences/com.apple.loginwindow autoLoginUser "${username}"
+  }
+
+  disable_screen_lock() {
+    execute sysadminctl -screenLock off -password "${password}"
+  }
+
+  enable_passwordless_sudo
+  enable_auto_login
+  disable_screen_lock
+}
+
+if [ $# -ne 2 ]; then
+  echo "Usage: $0 <username> <password>" >&2
+  exit 1
+fi
+
+login "$@"
diff --git a/ci/darwin/variables.pkr.hcl b/ci/darwin/variables.pkr.hcl
new file mode 100644
index 0000000000..d1133eb04a
--- /dev/null
+++ b/ci/darwin/variables.pkr.hcl
@@ -0,0 +1,78 @@
+packer {
+  required_plugins {
+    tart = {
+      version = ">= 1.12.0"
+      source  = "github.com/cirruslabs/tart"
+    }
+    external = {
+      version = ">= 0.0.2"
+      source  = "github.com/joomcode/external"
+    }
+  }
+}
+
+variable "release" {
+  type    = number
+  default = 13
+}
+
+variable "username" {
+  type    = string
+  default = "admin"
+}
+
+variable "password" {
+  type    = string
+  default = "admin"
+}
+
+variable "cpu_count" {
+  type    = number
+  default = 2
+}
+
+variable "memory_gb" {
+  type    = number
+  default = 4
+}
+
+variable "disk_size_gb" {
+  type    = number
+  default = 50
+}
+
+locals {
+  sequoia = {
+    tier    = 1
+    distro  = "sequoia"
+    release = "15"
+    ipsw    = "https://updates.cdn-apple.com/2024FallFCS/fullrestores/062-78489/BDA44327-C79E-4608-A7E0-455A7E91911F/UniversalMac_15.0_24A335_Restore.ipsw"
+  }
+
+  sonoma = {
+    tier    = 2
+    distro  = "sonoma"
+    release = "14"
+    ipsw    = "https://updates.cdn-apple.com/2023FallFCS/fullrestores/042-54934/0E101AD6-3117-4B63-9BF1-143B6DB9270A/UniversalMac_14.0_23A344_Restore.ipsw"
+  }
+
+  ventura = {
+    tier    = 2
+    distro  = "ventura"
+    release = "13"
+    ipsw    = "https://updates.cdn-apple.com/2022FallFCS/fullrestores/012-92188/2C38BCD1-2BFF-4A10-B358-94E8E28BE805/UniversalMac_13.0_22A380_Restore.ipsw"
+  }
+
+  releases = {
+    15 = local.sequoia
+    14 = local.sonoma
+    13 = local.ventura
+  }
+
+  release      = local.releases[var.release]
+  username     = var.username
+  password     = var.password
+  cpu_count    = var.cpu_count
+  memory_gb    = var.memory_gb
+  disk_size_gb = var.disk_size_gb
+}
diff --git a/ci/linux/Dockerfile b/ci/linux/Dockerfile
new file mode 100644
index 0000000000..3b46e73f6c
--- /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 0000000000..e529f74ce0
--- /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 0000000000..3b519bfdf5
--- /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
new file mode 100644
index 0000000000..28bd56c959
--- /dev/null
+++ b/ci/package.json
@@ -0,0 +1,27 @@
+{
+  "private": true,
+  "scripts": {
+    "bootstrap": "brew install gh jq cirruslabs/cli/tart cirruslabs/cli/sshpass hashicorp/tap/packer && packer init darwin",
+    "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",
+    "fetch:script-version": "cat ../scripts/bootstrap.sh | grep 'v=' | sed 's/v=\"//;s/\"//' | head -n 1",
+    "build:darwin-aarch64-vanilla": "packer build '-only=*.bun-darwin-aarch64-vanilla' -var release=$(bun fetch:macos-version) darwin/",
+    "build:darwin-aarch64-vanilla-15": "packer build '-only=*.bun-darwin-aarch64-vanilla' -var release=15 darwin/",
+    "build:darwin-aarch64-vanilla-14": "packer build '-only=*.bun-darwin-aarch64-vanilla' -var release=14 darwin/",
+    "build:darwin-aarch64-vanilla-13": "packer build '-only=*.bun-darwin-aarch64-vanilla' -var release=13 darwin/",
+    "build:darwin-aarch64": "packer build '-only=*.bun-darwin-aarch64' -var release=$(bun fetch:macos-version) darwin/",
+    "build:darwin-aarch64-15": "packer build '-only=*.bun-darwin-aarch64' -var release=15 darwin/",
+    "build:darwin-aarch64-14": "packer build '-only=*.bun-darwin-aarch64' -var release=14 darwin/",
+    "build:darwin-aarch64-13": "packer build '-only=*.bun-darwin-aarch64' -var release=13 darwin/",
+    "publish:darwin-aarch64-vanilla": "image=$(tart list --format json | jq -r \".[] | select(.Name | test(\\\"^bun-darwin-aarch64-vanilla-.*-$(bun fetch:macos-version)$\\\")) | .Name\" | head -n 1 | sed 's/bun-//'); tart push \"bun-$image\" \"ghcr.io/oven-sh/bun-vm:$image-v$(bun fetch:darwin-version)\"",
+    "publish:darwin-aarch64-vanilla-15": "tart push bun-darwin-aarch64-vanilla-sequoia-15 \"$(bun fetch:image-name):darwin-aarch64-vanilla-sequoia-15-v$(bun fetch:darwin-version)\"",
+    "publish:darwin-aarch64-vanilla-14": "tart push bun-darwin-aarch64-vanilla-sonoma-14 \"$(bun fetch:image-name):darwin-aarch64-vanilla-sonoma-14-v$(bun fetch:darwin-version)\"",
+    "publish:darwin-aarch64-vanilla-13": "tart push bun-darwin-aarch64-vanilla-ventura-13 \"$(bun fetch:image-name):darwin-aarch64-vanilla-ventura-13-v$(bun fetch:darwin-version)\"",
+    "publish:darwin-aarch64": "image=$(tart list --format json | jq -r \".[] | select(.Name | test(\\\"^bun-darwin-aarch64-.*-$(bun fetch:macos-version)$\\\")) | .Name\" | head -n 1 | sed 's/bun-//'); tart push \"bun-$image\" \"ghcr.io/oven-sh/bun-vm:$image-v$(bun fetch:script-version)\"",
+    "publish:darwin-aarch64-15": "tart push bun-darwin-aarch64-sequoia-15 \"$(bun fetch:image-name):darwin-aarch64-sequoia-15-v$(bun fetch:script-version)\"",
+    "publish:darwin-aarch64-14": "tart push bun-darwin-aarch64-sonoma-14 \"$(bun fetch:image-name):darwin-aarch64-sonoma-14-v$(bun fetch:script-version)\"",
+    "publish:darwin-aarch64-13": "tart push bun-darwin-aarch64-ventura-13 \"$(bun fetch:image-name):darwin-aarch64-ventura-13-v$(bun fetch:script-version)\""
+  }
+}
diff --git a/cmake/CompilerFlags.cmake b/cmake/CompilerFlags.cmake
index bf8cf576ab..31d738134a 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 303e49802a..3066bb2033 100644
--- a/cmake/Globals.cmake
+++ b/cmake/Globals.cmake
@@ -30,6 +30,10 @@ macro(optionx variable type description)
   set(multiValueArgs)
   cmake_parse_arguments(${variable} "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
 
+  if(DEFINED ${variable})
+    set(${variable}_VALUE ${${variable}})
+  endif()
+
   if(NOT ${type} MATCHES "^(BOOL|STRING|FILEPATH|PATH|INTERNAL)$")
     set(${variable}_REGEX ${type})
     set(${variable}_TYPE STRING)
@@ -65,7 +69,9 @@ macro(optionx variable type description)
     message(FATAL_ERROR "Invalid ${${variable}_SOURCE}: ${${variable}_PREVIEW}=\"${${variable}}\", please use ${${variable}_PREVIEW}=<${${variable}_REGEX}>")
   endif()
 
-  message(STATUS "Set ${variable}: ${${variable}}")
+  if(NOT ${variable}_VALUE STREQUAL ${variable})
+    message(STATUS "Set ${variable}: ${${variable}}")
+  endif()
 endmacro()
 
 # unsupported()
@@ -122,6 +128,7 @@ optionx(CACHE_PATH FILEPATH "The path to the cache directory" DEFAULT ${BUILD_PA
 optionx(CACHE_STRATEGY "read-write|read-only|write-only|none" "The strategy to use for caching" DEFAULT "read-write")
 
 optionx(CI BOOL "If CI is enabled" DEFAULT OFF)
+optionx(ENABLE_ANALYSIS BOOL "If static analysis targets should be enabled" DEFAULT OFF)
 
 if(CI)
   set(WARNING FATAL_ERROR)
@@ -139,24 +146,8 @@ endif()
 optionx(VENDOR_PATH FILEPATH "The path to the vendor directory" DEFAULT ${CWD}/vendor)
 optionx(TMP_PATH FILEPATH "The path to the temporary directory" DEFAULT ${BUILD_PATH}/tmp)
 
-optionx(FRESH BOOL "Set when --fresh is used" DEFAULT OFF)
-optionx(CLEAN BOOL "Set when --clean is used" DEFAULT OFF)
-
 # --- Helper functions ---
 
-function(parse_semver value variable)
-  string(REGEX MATCH "([0-9]+)\\.([0-9]+)\\.([0-9]+)" match "${value}")
-  
-  if(NOT match)
-    message(FATAL_ERROR "Invalid semver: \"${value}\"")
-  endif()
-  
-  set(${variable}_VERSION "${CMAKE_MATCH_1}.${CMAKE_MATCH_2}.${CMAKE_MATCH_3}" PARENT_SCOPE)
-  set(${variable}_VERSION_MAJOR "${CMAKE_MATCH_1}" PARENT_SCOPE)
-  set(${variable}_VERSION_MINOR "${CMAKE_MATCH_2}" PARENT_SCOPE)
-  set(${variable}_VERSION_PATCH "${CMAKE_MATCH_3}" PARENT_SCOPE)
-endfunction()
-
 # setenv()
 # Description:
 #   Sets an environment variable during the build step, and writes it to a .env file.
@@ -194,102 +185,154 @@ function(setenv variable value)
   message(STATUS "Set ENV ${variable}: ${value}")
 endfunction()
 
-# check_command()
+# satisfies_range()
 # Description:
-#   Checks if a command is available, used by `find_command()` as a validator.
+#   Check if a version satisfies a version range
 # Arguments:
-#   FOUND bool   - The variable to set to true if the version is found
-#   CMD   string - The executable to check the version of
-function(check_command FOUND CMD)
-  set(${FOUND} OFF PARENT_SCOPE)
-
-  if(${CMD} MATCHES "zig")
-    set(CHECK_COMMAND ${CMD} version)
-  else()
-    set(CHECK_COMMAND ${CMD} --version)
-  endif()
-
-  execute_process(
-    COMMAND ${CHECK_COMMAND}
-    RESULT_VARIABLE RESULT
-    OUTPUT_VARIABLE OUTPUT
-    OUTPUT_STRIP_TRAILING_WHITESPACE
-  )
-
-  if(NOT RESULT EQUAL 0 OR NOT OUTPUT)
-    message(DEBUG "${CHECK_COMMAND}, exited with code ${RESULT}")
+#   version  string - The version to check (e.g. "1.2.3")
+#   range    string - The range to check against (e.g. ">=1.2.3")
+#   variable string - The variable to store the result in
+function(satisfies_range version range variable)
+  if(range STREQUAL "ignore")
+    set(${variable} ON PARENT_SCOPE)
     return()
   endif()
 
-  parse_semver(${OUTPUT} CMD)
-  parse_semver(${CHECK_COMMAND_VERSION} CHECK)
+  set(${variable} OFF PARENT_SCOPE)
 
-  if(CHECK_COMMAND_VERSION MATCHES ">=")
-    if(NOT CMD_VERSION VERSION_GREATER_EQUAL ${CHECK_VERSION})
-      message(DEBUG "${CHECK_COMMAND}, actual: ${CMD_VERSION}, expected: ${CHECK_COMMAND_VERSION}")
-      return()
-    endif()
-  elseif(CHECK_COMMAND_VERSION MATCHES ">")
-    if(NOT CMD_VERSION VERSION_GREATER ${CHECK_VERSION})
-      message(DEBUG "${CHECK_COMMAND}, actual: ${CMD_VERSION}, expected: ${CHECK_COMMAND_VERSION}")
-      return()
-    endif()
+  string(REGEX MATCH "([0-9]+)\\.([0-9]+)\\.([0-9]+)" match "${version}")
+  if(NOT match)
+    return()
+  endif()
+  set(version ${CMAKE_MATCH_1}.${CMAKE_MATCH_2}.${CMAKE_MATCH_3})
+
+  string(REGEX MATCH "(>=|<=|>|<)?([0-9]+)\\.([0-9]+)\\.([0-9]+)" match "${range}")
+  if(NOT match)
+    return()
+  endif()
+  set(comparator ${CMAKE_MATCH_1})
+  set(range ${CMAKE_MATCH_2}.${CMAKE_MATCH_3}.${CMAKE_MATCH_4})
+
+  if(comparator STREQUAL ">=")
+    set(comparator VERSION_GREATER_EQUAL)
+  elseif(comparator STREQUAL ">")
+    set(comparator VERSION_GREATER)
+  elseif(comparator STREQUAL "<=")
+    set(comparator VERSION_LESS_EQUAL)
+  elseif(comparator STREQUAL "<")
+    set(comparator VERSION_LESS)
   else()
-    if(NOT CMD_VERSION VERSION_EQUAL ${CHECK_VERSION})
-      message(DEBUG "${CHECK_COMMAND}, actual: ${CMD_VERSION}, expected: =${CHECK_COMMAND_VERSION}")
-      return()
-    endif()
+    set(comparator VERSION_EQUAL)
   endif()
 
-  set(${FOUND} TRUE PARENT_SCOPE)
+  if(version ${comparator} ${range})
+    set(${variable} ON PARENT_SCOPE)
+  endif()
 endfunction()
 
 # find_command()
 # Description:
 #   Finds a command, similar to `find_program()`, but allows for version checking.
 # Arguments:
-#   VARIABLE  string   - The variable to set
-#   COMMAND   string[] - The names of the command to find
-#   PATHS     string[] - The paths to search for the command
-#   REQUIRED  bool     - If false, the command is optional
-#   VERSION   string   - The version of the command to find (e.g. "1.2.3" or ">1.2.3")
+#   VARIABLE         string   - The variable to set
+#   VERSION_VARIABLE string   - The variable to check for the version
+#   COMMAND          string[] - The names of the command to find
+#   PATHS            string[] - The paths to search for the command
+#   REQUIRED         bool     - If false, the command is optional
+#   VERSION          string   - The version of the command to find (e.g. "1.2.3" or ">1.2.3")
 function(find_command)
-  set(options)
-  set(args VARIABLE VERSION MIN_VERSION REQUIRED)
+  set(args VARIABLE VERSION_VARIABLE REQUIRED VERSION)
   set(multiArgs COMMAND PATHS)
-  cmake_parse_arguments(CMD "${options}" "${args}" "${multiArgs}" ${ARGN})
+  cmake_parse_arguments(FIND "" "${args}" "${multiArgs}" ${ARGN})
 
-  if(NOT CMD_VARIABLE)
-    message(FATAL_ERROR "find_command: VARIABLE is required")
+  if(NOT FIND_VARIABLE OR NOT FIND_COMMAND)
+    message(FATAL_ERROR "${CMAKE_CURRENT_FUNCTION}: VARIABLE and COMMAND are required")
   endif()
 
-  if(NOT CMD_COMMAND)
-    message(FATAL_ERROR "find_command: COMMAND is required")
+  if(NOT FIND_VERSION_VARIABLE)
+    set(FIND_VERSION_VARIABLE ${FIND_VARIABLE}_VERSION)
   endif()
 
-  if(CMD_VERSION)
-    set(CHECK_COMMAND_VERSION ${CMD_VERSION}) # special global variable
-    set(CMD_VALIDATOR VALIDATOR check_command)
+  list(GET FIND_COMMAND 0 FIND_NAME)
+  if(FIND_VERSION)
+    optionx(${FIND_VERSION_VARIABLE} STRING "The version of ${FIND_NAME} to find" DEFAULT "${FIND_VERSION}")
+
+    function(find_command_version variable exe)
+      set(${variable} OFF PARENT_SCOPE)
+
+      if(${exe} MATCHES "(go|zig)(\.exe)?$")
+        set(command ${exe} version)
+      else()
+        set(command ${exe} --version)
+      endif()
+
+      execute_process(
+        COMMAND ${command}
+        RESULT_VARIABLE result
+        OUTPUT_VARIABLE output
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+        ERROR_QUIET
+      )
+
+      if(NOT result EQUAL 0)
+        set(reason "exited with ${result}")
+      elseif(NOT output)
+        set(reason "no output")
+      else()
+        string(REGEX MATCH "([0-9]+)\\.([0-9]+)\\.([0-9]+)" match "${output}")
+        if(match)
+          set(version ${CMAKE_MATCH_1}.${CMAKE_MATCH_2}.${CMAKE_MATCH_3})
+          set(reason "\"${version}\"")
+        else()
+          set(reason "no version")
+        endif()
+      endif()
+
+      set_property(GLOBAL PROPERTY ${FIND_NAME} "${exe}: ${reason}" APPEND)
+
+      if(version)
+        satisfies_range(${version} ${${FIND_VERSION_VARIABLE}} ${variable})
+        set(${variable} ${${variable}} PARENT_SCOPE)
+      endif()
+    endfunction()
+
+    set(FIND_VALIDATOR VALIDATOR find_command_version)
   endif()
 
   find_program(
-    ${CMD_VARIABLE}
-    NAMES ${CMD_COMMAND}
-    PATHS ${CMD_PATHS}
-    ${CMD_VALIDATOR}
+    ${FIND_VARIABLE}
+    NAMES ${FIND_COMMAND}
+    PATHS ${FIND_PATHS}
+    ${FIND_VALIDATOR}
   )
 
-  if(NOT CMD_REQUIRED STREQUAL "OFF" AND ${CMD_VARIABLE} MATCHES "NOTFOUND")
-    if(CMD_VERSION)
-      message(FATAL_ERROR "Command not found: \"${CMD_COMMAND}\" that matches version \"${CHECK_COMMAND_VERSION}\"")
+  if(NOT FIND_REQUIRED STREQUAL "OFF" AND ${FIND_VARIABLE} MATCHES "NOTFOUND")
+    set(error "Command not found: \"${FIND_NAME}\"")
+
+    if(FIND_VERSION)
+      set(error "${error} that satisfies version \"${${FIND_VERSION_VARIABLE}}\"")
     endif()
-    message(FATAL_ERROR "Command not found: \"${CMD_COMMAND}\"")
+
+    get_property(FIND_RESULTS GLOBAL PROPERTY ${FIND_NAME})
+    if(NOT FIND_RESULTS MATCHES "NOTFOUND")
+      set(error "${error}\nThe following commands did not satisfy the requirement:")
+      foreach(result ${FIND_RESULTS})
+        set(error "${error}\n  ${result}")
+      endforeach()
+    endif()
+
+    set(error "${error}\nTo fix this, either:
+  1. Install ${FIND_NAME} ${${FIND_VERSION_VARIABLE}}
+  2. Set -D${FIND_VERSION_VARIABLE}=<version> to require a different version
+  3. Set -D${FIND_VERSION_VARIABLE}=ignore to allow any version
+")
+    message(FATAL_ERROR ${error})
   endif()
 
-  if(${CMD_VARIABLE} MATCHES "NOTFOUND")
-    unset(${CMD_VARIABLE} PARENT_SCOPE)
+  if(${FIND_VARIABLE} MATCHES "NOTFOUND")
+    unset(${FIND_VARIABLE} PARENT_SCOPE)
   else()
-    setx(${CMD_VARIABLE} ${${CMD_VARIABLE}} PARENT_SCOPE)
+    setx(${FIND_VARIABLE} ${${FIND_VARIABLE}} PARENT_SCOPE)
   endif()
 endfunction()
 
@@ -326,7 +369,7 @@ function(register_command)
   if(CMD_ENVIRONMENT)
     set(CMD_COMMAND ${CMAKE_COMMAND} -E env ${CMD_ENVIRONMENT} ${CMD_COMMAND})
   endif()
-  
+
   if(NOT CMD_COMMENT)
     string(JOIN " " CMD_COMMENT ${CMD_COMMAND})
   endif()
@@ -476,7 +519,7 @@ function(parse_package_json)
     set(NPM_NODE_MODULES)
     set(NPM_NODE_MODULES_PATH ${NPM_CWD}/node_modules)
     set(NPM_NODE_MODULES_PROPERTIES "devDependencies" "dependencies")
-    
+
     foreach(property ${NPM_NODE_MODULES_PROPERTIES})
       string(JSON NPM_${property} ERROR_VARIABLE error GET "${NPM_PACKAGE_JSON}" "${property}")
       if(error MATCHES "not found")
@@ -832,7 +875,7 @@ function(register_compiler_flags)
       if(NOT COMPILER_TARGETS)
         add_compile_options($<$<COMPILE_LANGUAGE:${lang}>:${flag}>)
       endif()
-      
+
       foreach(target ${COMPILER_TARGETS})
         get_target_property(type ${target} TYPE)
         if(type MATCHES "EXECUTABLE|LIBRARY")
@@ -844,7 +887,7 @@ function(register_compiler_flags)
 endfunction()
 
 function(register_compiler_definitions)
-  
+
 endfunction()
 
 # register_linker_flags()
diff --git a/cmake/Options.cmake b/cmake/Options.cmake
index 44ea99042d..201bf8c8e1 100644
--- a/cmake/Options.cmake
+++ b/cmake/Options.cmake
@@ -10,7 +10,6 @@ optionx(GITHUB_ACTIONS BOOL "If GitHub Actions is enabled" DEFAULT OFF)
 
 if(BUILDKITE)
   optionx(BUILDKITE_COMMIT STRING "The commit hash")
-  optionx(BUILDKITE_MESSAGE STRING "The commit message")
 endif()
 
 optionx(CMAKE_BUILD_TYPE "Debug|Release|RelWithDebInfo|MinSizeRel" "The build type to use" REQUIRED)
@@ -21,7 +20,7 @@ else()
   setx(RELEASE OFF)
 endif()
 
-if(CMAKE_BUILD_TYPE MATCHES "Debug|RelWithDebInfo")
+if(CMAKE_BUILD_TYPE MATCHES "Debug")
   setx(DEBUG ON)
 else()
   setx(DEBUG OFF)
@@ -49,6 +48,16 @@ else()
   message(FATAL_ERROR "Unsupported architecture: ${CMAKE_SYSTEM_PROCESSOR}")
 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()
+
 if(ARCH STREQUAL "x64")
   optionx(ENABLE_BASELINE BOOL "If baseline features should be used for older CPUs (e.g. disables AVX, AVX2)" DEFAULT OFF)
 endif()
@@ -56,14 +65,7 @@ endif()
 optionx(ENABLE_LOGS BOOL "If debug logs should be enabled" DEFAULT ${DEBUG})
 optionx(ENABLE_ASSERTIONS BOOL "If debug assertions should be enabled" DEFAULT ${DEBUG})
 
-if(BUILDKITE_MESSAGE AND BUILDKITE_MESSAGE MATCHES "\\[release build\\]")
-  message(STATUS "Switched to release build, since commit message contains: \"[release build]\"")
-  set(DEFAULT_CANARY OFF)
-else()
-  set(DEFAULT_CANARY ON)
-endif()
-
-optionx(ENABLE_CANARY BOOL "If canary features should be enabled" DEFAULT ${DEFAULT_CANARY})
+optionx(ENABLE_CANARY BOOL "If canary features should be enabled" DEFAULT ON)
 
 if(ENABLE_CANARY AND BUILDKITE)
   execute_process(
@@ -79,7 +81,7 @@ endif()
 
 optionx(CANARY_REVISION STRING "The canary revision of the build" DEFAULT ${DEFAULT_CANARY_REVISION})
 
-if(RELEASE AND LINUX)
+if(RELEASE AND LINUX AND CI)
   set(DEFAULT_LTO ON)
 else()
   set(DEFAULT_LTO OFF)
@@ -91,6 +93,8 @@ if(LINUX)
   optionx(ENABLE_VALGRIND BOOL "If Valgrind support should be enabled" DEFAULT OFF)
 endif()
 
+optionx(ENABLE_PRETTIER BOOL "If prettier should be ran" DEFAULT OFF)
+
 if(USE_VALGRIND AND NOT USE_BASELINE)
   message(WARNING "If valgrind is enabled, baseline must also be enabled")
   setx(USE_BASELINE ON)
@@ -106,7 +110,7 @@ else()
     OUTPUT_STRIP_TRAILING_WHITESPACE
     ERROR_QUIET
   )
-  if(NOT DEFAULT_REVISION)
+  if(NOT DEFAULT_REVISION AND NOT DEFINED ENV{GIT_SHA} AND NOT DEFINED ENV{GITHUB_SHA})
     set(DEFAULT_REVISION "unknown")
   endif()
 endif()
@@ -136,7 +140,7 @@ if(CMAKE_HOST_LINUX AND NOT WIN32 AND NOT APPLE)
     OUTPUT_STRIP_TRAILING_WHITESPACE
     ERROR_QUIET
   )
-  if(LINUX_DISTRO MATCHES "NAME=\"(Arch|Manjaro|Artix) Linux\"|NAME=\"openSUSE Tumbleweed\"")
+  if(LINUX_DISTRO MATCHES "NAME=\"(Arch|Manjaro|Artix) Linux( ARM)?\"|NAME=\"openSUSE Tumbleweed\"")
     set(DEFAULT_STATIC_LIBATOMIC OFF)
   endif()
 endif()
@@ -154,4 +158,3 @@ optionx(USE_WEBKIT_ICU BOOL "Use the ICU libraries from WebKit" DEFAULT ${DEFAUL
 optionx(ERROR_LIMIT STRING "Maximum number of errors to show when compiling C++ code" DEFAULT "100")
 
 list(APPEND CMAKE_ARGS -DCMAKE_EXPORT_COMPILE_COMMANDS=ON)
-
diff --git a/cmake/analysis/RunClangFormat.cmake b/cmake/analysis/RunClangFormat.cmake
index 7586e68aeb..106ac54ef6 100644
--- a/cmake/analysis/RunClangFormat.cmake
+++ b/cmake/analysis/RunClangFormat.cmake
@@ -1,15 +1,11 @@
 # https://clang.llvm.org/docs/ClangFormat.html
 
-find_command(
-  VARIABLE
-    CLANG_FORMAT_PROGRAM
-  COMMAND
-    clang-format
-  REQUIRED
-    OFF
+file(GLOB BUN_H_SOURCES LIST_DIRECTORIES false ${CONFIGURE_DEPENDS}
+  ${CWD}/src/bun.js/bindings/*.h
+  ${CWD}/src/bun.js/modules/*.h
 )
 
-set(CLANG_FORMAT_SOURCES ${BUN_C_SOURCES} ${BUN_CXX_SOURCES})
+set(CLANG_FORMAT_SOURCES ${BUN_C_SOURCES} ${BUN_CXX_SOURCES} ${BUN_H_SOURCES})
 
 register_command(
   TARGET
diff --git a/cmake/analysis/RunClangTidy.cmake b/cmake/analysis/RunClangTidy.cmake
index 36f60306b9..ee5782ade8 100644
--- a/cmake/analysis/RunClangTidy.cmake
+++ b/cmake/analysis/RunClangTidy.cmake
@@ -1,16 +1,5 @@
 # https://clang.llvm.org/extra/clang-tidy/
 
-find_command(
-  VARIABLE
-    CLANG_TIDY_PROGRAM
-  COMMAND
-    clang-tidy
-  VERSION
-    ${LLVM_VERSION}
-  REQUIRED
-    OFF
-)
-
 set(CLANG_TIDY_SOURCES ${BUN_C_SOURCES} ${BUN_CXX_SOURCES})
 
 set(CLANG_TIDY_COMMAND ${CLANG_TIDY_PROGRAM}
diff --git a/cmake/analysis/RunIWYU.cmake b/cmake/analysis/RunIWYU.cmake
index 340e44f780..0ea555f2f5 100644
--- a/cmake/analysis/RunIWYU.cmake
+++ b/cmake/analysis/RunIWYU.cmake
@@ -1,7 +1,7 @@
 # IWYU = "Include What You Use"
 # https://include-what-you-use.org/
 
-setx(IWYU_SOURCE_PATH ${CACHE_PATH}/iwyu-${LLVM_VERSION_MAJOR})
+setx(IWYU_SOURCE_PATH ${CACHE_PATH}/iwyu-${LLVM_VERSION})
 setx(IWYU_BUILD_PATH ${IWYU_SOURCE_PATH}/build)
 setx(IWYU_PROGRAM ${IWYU_BUILD_PATH}/bin/include-what-you-use)
 
@@ -11,7 +11,7 @@ register_repository(
   REPOSITORY
     include-what-you-use/include-what-you-use
   BRANCH
-    clang_${LLVM_VERSION_MAJOR}
+    clang_${LLVM_VERSION}
   PATH
     ${IWYU_SOURCE_PATH}
 )
diff --git a/cmake/analysis/RunPrettier.cmake b/cmake/analysis/RunPrettier.cmake
index 7d509af2d0..8c8ceb1ba1 100644
--- a/cmake/analysis/RunPrettier.cmake
+++ b/cmake/analysis/RunPrettier.cmake
@@ -95,7 +95,7 @@ register_command(
 if(GIT_CHANGED_SOURCES)
   set(PRETTIER_CHANGED_SOURCES)
   foreach(source ${PRETTIER_SOURCES})
-    list(FIND PRETTIER_CHANGED_SOURCES ${source} index)
+    list(FIND GIT_CHANGED_SOURCES ${source} index)
     if(NOT ${index} EQUAL -1)
       list(APPEND PRETTIER_CHANGED_SOURCES ${source})
     endif()
diff --git a/cmake/targets/BuildBun.cmake b/cmake/targets/BuildBun.cmake
index e023a7db18..20cbb8293e 100644
--- a/cmake/targets/BuildBun.cmake
+++ b/cmake/targets/BuildBun.cmake
@@ -21,10 +21,16 @@ else()
   set(buns ${bun})
 endif()
 
-# Some commands use this path, and some do not.
-# In the future, change those commands so that generated files are written to this path.
 optionx(CODEGEN_PATH FILEPATH "Path to the codegen directory" DEFAULT ${BUILD_PATH}/codegen)
 
+if(RELEASE OR CI)
+  set(DEFAULT_CODEGEN_EMBED ON)
+else()
+  set(DEFAULT_CODEGEN_EMBED OFF)
+endif()
+
+optionx(CODEGEN_EMBED BOOL "If codegen files should be embedded in the binary" DEFAULT ${DEFAULT_CODEGEN_EMBED})
+
 if((NOT DEFINED CONFIGURE_DEPENDS AND NOT CI) OR CONFIGURE_DEPENDS)
   set(CONFIGURE_DEPENDS "CONFIGURE_DEPENDS")
 else()
@@ -33,39 +39,6 @@ endif()
 
 # --- Codegen ---
 
-set(BUN_ZIG_IDENTIFIER_SOURCE ${CWD}/src/js_lexer)
-set(BUN_ZIG_IDENTIFIER_SCRIPT ${BUN_ZIG_IDENTIFIER_SOURCE}/identifier_data.zig)
-
-file(GLOB BUN_ZIG_IDENTIFIER_SOURCES ${CONFIGURE_DEPENDS}
-  ${BUN_ZIG_IDENTIFIER_SCRIPT}
-  ${BUN_ZIG_IDENTIFIER_SOURCE}/*.zig
-)
-
-set(BUN_ZIG_IDENTIFIER_OUTPUTS
-  ${BUN_ZIG_IDENTIFIER_SOURCE}/id_continue_bitset.blob
-  ${BUN_ZIG_IDENTIFIER_SOURCE}/id_continue_bitset.meta.blob
-  ${BUN_ZIG_IDENTIFIER_SOURCE}/id_start_bitset.blob
-  ${BUN_ZIG_IDENTIFIER_SOURCE}/id_start_bitset.meta.blob
-)
-
-register_command(
-  TARGET
-    bun-identifier-data
-  COMMENT
-    "Generating src/js_lexer/*.blob"
-  COMMAND
-    ${ZIG_EXECUTABLE}
-      run
-      ${CMAKE_ZIG_FLAGS}
-      ${BUN_ZIG_IDENTIFIER_SCRIPT}
-  SOURCES
-    ${BUN_ZIG_IDENTIFIER_SOURCES}
-  TARGETS
-    clone-zig
-  OUTPUTS
-    ${BUN_ZIG_IDENTIFIER_OUTPUTS}
-)
-
 set(BUN_ERROR_SOURCE ${CWD}/packages/bun-error)
 
 file(GLOB BUN_ERROR_SOURCES ${CONFIGURE_DEPENDS}
@@ -76,7 +49,7 @@ file(GLOB BUN_ERROR_SOURCES ${CONFIGURE_DEPENDS}
   ${BUN_ERROR_SOURCE}/img/*
 )
 
-set(BUN_ERROR_OUTPUT ${BUN_ERROR_SOURCE}/dist)
+set(BUN_ERROR_OUTPUT ${CODEGEN_PATH}/bun-error)
 set(BUN_ERROR_OUTPUTS
   ${BUN_ERROR_OUTPUT}/index.js
   ${BUN_ERROR_OUTPUT}/bun-error.css
@@ -114,13 +87,13 @@ register_command(
 )
 
 set(BUN_FALLBACK_DECODER_SOURCE ${CWD}/src/fallback.ts)
-set(BUN_FALLBACK_DECODER_OUTPUT ${CWD}/src/fallback.out.js)
+set(BUN_FALLBACK_DECODER_OUTPUT ${CODEGEN_PATH}/fallback-decoder.js)
 
 register_command(
   TARGET
     bun-fallback-decoder
   COMMENT
-    "Building src/fallback.out.js"
+    "Building fallback-decoder.js"
   COMMAND
     ${ESBUILD_EXECUTABLE} ${ESBUILD_ARGS}
       ${BUN_FALLBACK_DECODER_SOURCE}
@@ -137,7 +110,7 @@ register_command(
 )
 
 set(BUN_RUNTIME_JS_SOURCE ${CWD}/src/runtime.bun.js)
-set(BUN_RUNTIME_JS_OUTPUT ${CWD}/src/runtime.out.js)
+set(BUN_RUNTIME_JS_OUTPUT ${CODEGEN_PATH}/runtime.out.js)
 
 register_command(
   TARGET
@@ -167,7 +140,7 @@ file(GLOB BUN_NODE_FALLBACKS_SOURCES ${CONFIGURE_DEPENDS}
   ${BUN_NODE_FALLBACKS_SOURCE}/*.js
 )
 
-set(BUN_NODE_FALLBACKS_OUTPUT ${BUN_NODE_FALLBACKS_SOURCE}/out)
+set(BUN_NODE_FALLBACKS_OUTPUT ${CODEGEN_PATH}/node-fallbacks)
 set(BUN_NODE_FALLBACKS_OUTPUTS)
 foreach(source ${BUN_NODE_FALLBACKS_SOURCES})
   get_filename_component(filename ${source} NAME)
@@ -187,7 +160,7 @@ register_command(
   TARGET
     bun-node-fallbacks
   COMMENT
-    "Building src/node-fallbacks/*.js"
+    "Building node-fallbacks/*.js"
   CWD
     ${BUN_NODE_FALLBACKS_SOURCE}
   COMMAND
@@ -324,40 +297,41 @@ register_command(
     ${BUN_JAVASCRIPT_OUTPUTS}
 )
 
-set(BUN_KIT_RUNTIME_CODEGEN_SCRIPT ${CWD}/src/codegen/kit-codegen.ts)
+set(BUN_BAKE_RUNTIME_CODEGEN_SCRIPT ${CWD}/src/codegen/bake-codegen.ts)
 
-file(GLOB_RECURSE BUN_KIT_RUNTIME_SOURCES ${CONFIGURE_DEPENDS}
-  ${CWD}/src/kit/*.ts
-  ${CWD}/src/kit/*/*.ts
+file(GLOB_RECURSE BUN_BAKE_RUNTIME_SOURCES ${CONFIGURE_DEPENDS}
+  ${CWD}/src/bake/*.ts
+  ${CWD}/src/bake/*/*.ts
+  ${CWD}/src/bake/*/*.css
 )
 
-list(APPEND BUN_KIT_RUNTIME_CODEGEN_SOURCES
+list(APPEND BUN_BAKE_RUNTIME_CODEGEN_SOURCES
   ${CWD}/src/bun.js/bindings/InternalModuleRegistry.cpp
 )
 
-set(BUN_KIT_RUNTIME_OUTPUTS
-  ${CODEGEN_PATH}/kit_empty_file
-  ${CODEGEN_PATH}/kit.client.js
-  ${CODEGEN_PATH}/kit.server.js
+set(BUN_BAKE_RUNTIME_OUTPUTS
+  ${CODEGEN_PATH}/bake.client.js
+  ${CODEGEN_PATH}/bake.server.js
 )
 
 register_command(
   TARGET
-    bun-kit-codegen
+    bun-bake-codegen
   COMMENT
     "Bundling Kit Runtime"
   COMMAND
     ${BUN_EXECUTABLE}
       run
-      ${BUN_KIT_RUNTIME_CODEGEN_SCRIPT}
+      ${BUN_BAKE_RUNTIME_CODEGEN_SCRIPT}
         --debug=${DEBUG}
         --codegen_root=${CODEGEN_PATH}
   SOURCES
-    ${BUN_KIT_RUNTIME_SOURCES}
-    ${BUN_KIT_RUNTIME_CODEGEN_SOURCES}
-    ${BUN_KIT_RUNTIME_CODEGEN_SCRIPT}
+    ${BUN_BAKE_RUNTIME_SOURCES}
+    ${BUN_BAKE_RUNTIME_CODEGEN_SOURCES}
+    ${BUN_BAKE_RUNTIME_CODEGEN_SCRIPT}
   OUTPUTS
-    ${BUN_KIT_RUNTIME_OUTPUTS}
+    ${CODEGEN_PATH}/bake_empty_file
+    ${BUN_BAKE_RUNTIME_OUTPUTS}
 )
 
 set(BUN_JS_SINK_SCRIPT ${CWD}/src/codegen/generate-jssink.ts)
@@ -398,6 +372,7 @@ set(BUN_OBJECT_LUT_SOURCES
   ${CWD}/src/bun.js/bindings/BunProcess.cpp
   ${CWD}/src/bun.js/bindings/ProcessBindingConstants.cpp
   ${CWD}/src/bun.js/bindings/ProcessBindingNatives.cpp
+  ${CWD}/src/bun.js/modules/NodeModuleModule.cpp
 )
 
 set(BUN_OBJECT_LUT_OUTPUTS
@@ -407,8 +382,10 @@ set(BUN_OBJECT_LUT_OUTPUTS
   ${CODEGEN_PATH}/BunProcess.lut.h
   ${CODEGEN_PATH}/ProcessBindingConstants.lut.h
   ${CODEGEN_PATH}/ProcessBindingNatives.lut.h
+  ${CODEGEN_PATH}/NodeModuleModule.lut.h
 )
 
+
 macro(WEBKIT_ADD_SOURCE_DEPENDENCIES _source _deps)
   set(_tmp)
   get_source_file_property(_tmp ${_source} OBJECT_DEPENDS)
@@ -487,7 +464,6 @@ list(APPEND BUN_ZIG_SOURCES
 )
 
 set(BUN_ZIG_GENERATED_SOURCES
-  ${BUN_ZIG_IDENTIFIER_OUTPUTS}
   ${BUN_ERROR_OUTPUTS}
   ${BUN_FALLBACK_DECODER_OUTPUT}
   ${BUN_RUNTIME_JS_OUTPUT}
@@ -499,13 +475,14 @@ set(BUN_ZIG_GENERATED_SOURCES
 
 # In debug builds, these are not embedded, but rather referenced at runtime.
 if (DEBUG)
-  list(APPEND BUN_ZIG_GENERATED_SOURCES ${CODEGEN_PATH}/kit_empty_file)
+  list(APPEND BUN_ZIG_GENERATED_SOURCES ${CODEGEN_PATH}/bake_empty_file)
 else()
-  list(APPEND BUN_ZIG_GENERATED_SOURCES ${BUN_KIT_RUNTIME_OUTPUTS})
+  list(APPEND BUN_ZIG_GENERATED_SOURCES ${BUN_BAKE_RUNTIME_OUTPUTS})
 endif()
 
 set(BUN_ZIG_OUTPUT ${BUILD_PATH}/bun-zig.o)
 
+
 if(CMAKE_SYSTEM_PROCESSOR MATCHES "arm|ARM|arm64|ARM64|aarch64|AARCH64")
   if(APPLE)
     set(ZIG_CPU "apple_m1")
@@ -522,6 +499,11 @@ else()
   unsupported(CMAKE_SYSTEM_PROCESSOR)
 endif()
 
+set(ZIG_FLAGS_BUN)
+if(NOT "${REVISION}" STREQUAL "")
+  set(ZIG_FLAGS_BUN ${ZIG_FLAGS_BUN} -Dsha=${REVISION})
+endif()
+
 register_command(
   TARGET
     bun-zig
@@ -540,10 +522,12 @@ register_command(
       -Dcpu=${ZIG_CPU}
       -Denable_logs=$<IF:$<BOOL:${ENABLE_LOGS}>,true,false>
       -Dversion=${VERSION}
-      -Dsha=${REVISION}
       -Dreported_nodejs_version=${NODEJS_VERSION}
       -Dcanary=${CANARY_REVISION}
-      -Dgenerated-code=${CODEGEN_PATH}
+      -Dcodegen_path=${CODEGEN_PATH}
+      -Dcodegen_embed=$<IF:$<BOOL:${CODEGEN_EMBED}>,true,false>
+      --prominent-compile-errors
+      ${ZIG_FLAGS_BUN}
   ARTIFACTS
     ${BUN_ZIG_OUTPUT}
   TARGETS
@@ -569,7 +553,8 @@ file(GLOB BUN_CXX_SOURCES ${CONFIGURE_DEPENDS}
   ${CWD}/src/bun.js/bindings/webcrypto/*.cpp
   ${CWD}/src/bun.js/bindings/webcrypto/*/*.cpp
   ${CWD}/src/bun.js/bindings/v8/*.cpp
-  ${CWD}/src/kit/*.cpp
+  ${CWD}/src/bun.js/bindings/v8/shim/*.cpp
+  ${CWD}/src/bake/*.cpp
   ${CWD}/src/deps/*.cpp
   ${BUN_USOCKETS_SOURCE}/src/crypto/*.cpp
 )
@@ -616,6 +601,7 @@ list(APPEND BUN_CPP_SOURCES
   ${BUN_C_SOURCES}
   ${BUN_CXX_SOURCES}
   ${VENDOR_PATH}/picohttpparser/picohttpparser.c
+  ${NODEJS_HEADERS_PATH}/include/node/node_version.h
   ${BUN_ZIG_GENERATED_CLASSES_OUTPUTS}
   ${BUN_JS_SINK_OUTPUTS}
   ${BUN_JAVASCRIPT_OUTPUTS}
@@ -693,6 +679,7 @@ target_include_directories(${bun} PRIVATE
   ${CWD}/src/bun.js/bindings/webcore
   ${CWD}/src/bun.js/bindings/webcrypto
   ${CWD}/src/bun.js/bindings/sqlite
+  ${CWD}/src/bun.js/bindings/v8
   ${CWD}/src/bun.js/modules
   ${CWD}/src/js/builtins
   ${CWD}/src/napi
@@ -700,8 +687,17 @@ target_include_directories(${bun} PRIVATE
   ${CODEGEN_PATH}
   ${VENDOR_PATH}
   ${VENDOR_PATH}/picohttpparser
+  ${NODEJS_HEADERS_PATH}/include
 )
 
+if(LINUX)
+  include(CheckIncludeFiles)
+  check_include_files("sys/queue.h" HAVE_SYS_QUEUE_H)
+  if(NOT HAVE_SYS_QUEUE_H)
+    target_include_directories(${bun} PRIVATE vendor/lshpack/compat/queue)
+  endif()
+endif()
+
 # --- C/C++ Definitions ---
 
 if(ENABLE_ASSERTIONS)
@@ -762,6 +758,24 @@ if(NOT WIN32)
     -faddrsig
   )
   if(DEBUG)
+    # TODO: this shouldn't be necessary long term
+    if (NOT ABI STREQUAL "musl")
+      target_compile_options(${bun} PUBLIC
+        -fsanitize=null
+        -fsanitize-recover=all
+        -fsanitize=bounds
+        -fsanitize=return
+        -fsanitize=nullability-arg
+        -fsanitize=nullability-assign
+        -fsanitize=nullability-return
+        -fsanitize=returns-nonnull-attribute
+        -fsanitize=unreachable
+      )
+      target_link_libraries(${bun} PRIVATE
+        -fsanitize=null
+      )
+    endif()
+
     target_compile_options(${bun} PUBLIC
       -Werror=return-type
       -Werror=return-stack-address
@@ -777,17 +791,7 @@ if(NOT WIN32)
       -Wno-unused-function
       -Wno-nullability-completeness
       -Werror
-      -fsanitize=null
-      -fsanitize-recover=all
-      -fsanitize=bounds
-      -fsanitize=return
-      -fsanitize=nullability-arg
-      -fsanitize=nullability-assign
-      -fsanitize=nullability-return
-      -fsanitize=returns-nonnull-attribute
-      -fsanitize=unreachable
     )
-    target_link_libraries(${bun} PRIVATE -fsanitize=null)
   else()
     # Leave -Werror=unused off in release builds so we avoid errors from being used in ASSERT
     target_compile_options(${bun} PUBLIC ${LTO_FLAG}
@@ -831,73 +835,95 @@ if(WIN32)
       /delayload:IPHLPAPI.dll
     )
   endif()
-elseif(APPLE)
-  target_link_options(${bun} PUBLIC 
+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})
+endif()
 
-    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)
+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()
 
-    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}")
-    endif()
+    target_link_options(${bun} PUBLIC
+      -Wl,--wrap=cosf
+      -Wl,--wrap=exp
+      -Wl,--wrap=expf
+      -Wl,--wrap=fmod
+      -Wl,--wrap=fmodf
+      -Wl,--wrap=log
+      -Wl,--wrap=log10f
+      -Wl,--wrap=log2
+      -Wl,--wrap=log2f
+      -Wl,--wrap=logf
+      -Wl,--wrap=pow
+      -Wl,--wrap=powf
+      -Wl,--wrap=sincosf
+      -Wl,--wrap=sinf
+      -Wl,--wrap=tanf
+    )
+  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})
+  if(NOT ABI STREQUAL "musl")
+    target_link_options(${bun} PUBLIC
+      -static-libstdc++
+      -static-libgcc
+    )
+  else()
+    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
-    -Wl,--wrap=fcntl
-    -Wl,--wrap=fcntl64
-    -Wl,--wrap=stat64
-    -Wl,--wrap=pow
-    -Wl,--wrap=exp
-    -Wl,--wrap=expf
-    -Wl,--wrap=log
-    -Wl,--wrap=log2
-    -Wl,--wrap=lstat
-    -Wl,--wrap=stat64
-    -Wl,--wrap=stat
-    -Wl,--wrap=fstat
-    -Wl,--wrap=fstatat
-    -Wl,--wrap=lstat64
-    -Wl,--wrap=fstat64
-    -Wl,--wrap=fstatat64
-    -Wl,--wrap=mknod
-    -Wl,--wrap=mknodat
-    -Wl,--wrap=statx
-    -Wl,--wrap=fmod
     -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()
 
@@ -1037,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
@@ -1048,6 +1086,7 @@ if(NOT BUN_CPP_ONLY)
       COMMAND
         ${CMAKE_STRIP}
           ${bunExe}
+          ${CMAKE_STRIP_FLAGS}
           --strip-all
           --strip-debug
           --discard-all
@@ -1123,10 +1162,12 @@ if(NOT BUN_CPP_ONLY)
   endif()
 
   if(CI)
+    set(bunTriplet bun-${OS}-${ARCH})
+    if(LINUX AND 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)
@@ -1135,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/BuildCares.cmake b/cmake/targets/BuildCares.cmake
index 9a3f0b9ef0..373369b543 100644
--- a/cmake/targets/BuildCares.cmake
+++ b/cmake/targets/BuildCares.cmake
@@ -4,7 +4,7 @@ register_repository(
   REPOSITORY
     c-ares/c-ares
   COMMIT
-    d1722e6e8acaf10eb73fa995798a9cd421d9f85e
+    41ee334af3e3d0027dca5e477855d0244936bd49
 )
 
 register_cmake_command(
@@ -18,6 +18,7 @@ register_cmake_command(
     -DCMAKE_POSITION_INDEPENDENT_CODE=ON
     -DCARES_SHARED=OFF
     -DCARES_BUILD_TOOLS=OFF # this was set to ON?
+    -DCMAKE_INSTALL_LIBDIR=lib
   LIB_PATH
     lib
   LIBRARIES
diff --git a/cmake/targets/BuildLibDeflate.cmake b/cmake/targets/BuildLibDeflate.cmake
index 3faf5963a7..f629d52fe5 100644
--- a/cmake/targets/BuildLibDeflate.cmake
+++ b/cmake/targets/BuildLibDeflate.cmake
@@ -4,7 +4,7 @@ register_repository(
   REPOSITORY
     ebiggers/libdeflate
   COMMIT
-    dc76454a39e7e83b68c3704b6e3784654f8d5ac5
+    9d624d1d8ba82c690d6d6be1d0a961fc5a983ea4
 )
 
 register_cmake_command(
diff --git a/cmake/targets/BuildLolHtml.cmake b/cmake/targets/BuildLolHtml.cmake
index 9a02362723..3b0d80a723 100644
--- a/cmake/targets/BuildLolHtml.cmake
+++ b/cmake/targets/BuildLolHtml.cmake
@@ -4,7 +4,7 @@ register_repository(
   REPOSITORY
     cloudflare/lol-html
   COMMIT
-    8d4c273ded322193d017042d1f48df2766b0f88b
+    4f8becea13a0021c8b71abd2dcc5899384973b66
 )
 
 set(LOLHTML_CWD ${VENDOR_PATH}/lolhtml/c-api)
@@ -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,13 @@ 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}
+    CARGO_HOME=${CARGO_HOME}
+    RUSTUP_HOME=${RUSTUP_HOME}
 )
 
 target_link_libraries(${bun} PRIVATE ${LOLHTML_LIBRARY})
diff --git a/cmake/targets/BuildLshpack.cmake b/cmake/targets/BuildLshpack.cmake
index c1cbb12ff5..845f9bf011 100644
--- a/cmake/targets/BuildLshpack.cmake
+++ b/cmake/targets/BuildLshpack.cmake
@@ -4,7 +4,7 @@ register_repository(
   REPOSITORY
     litespeedtech/ls-hpack
   COMMIT
-    3d0f1fc1d6e66a642e7a98c55deb38aa986eb4b0
+    32e96f10593c7cb8553cd8c9c12721100ae9e924
 )
 
 if(WIN32)
diff --git a/cmake/targets/BuildMimalloc.cmake b/cmake/targets/BuildMimalloc.cmake
index 2161e20603..1e88a1a5f0 100644
--- a/cmake/targets/BuildMimalloc.cmake
+++ b/cmake/targets/BuildMimalloc.cmake
@@ -4,7 +4,7 @@ register_repository(
   REPOSITORY
     oven-sh/mimalloc
   COMMIT
-    4c283af60cdae205df5a872530c77e2a6a307d43
+    82b2c2277a4d570187c07b376557dc5bde81d848
 )
 
 set(MIMALLOC_CMAKE_ARGS
diff --git a/cmake/toolchains/linux-aarch64-musl.cmake b/cmake/toolchains/linux-aarch64-musl.cmake
new file mode 100644
index 0000000000..e4a33f709e
--- /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 bc23a06302..657594dae8 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 f521cfcc4a..73d6bc61e4 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 0000000000..ea28a1757a
--- /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 0000000000..db4998bba9
--- /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 66bc7a592f..4104a1c5df 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/SetupCcache.cmake b/cmake/tools/SetupCcache.cmake
index 7e14cc8a41..d2367205c8 100644
--- a/cmake/tools/SetupCcache.cmake
+++ b/cmake/tools/SetupCcache.cmake
@@ -11,9 +11,13 @@ find_command(
   COMMAND
     ccache
   REQUIRED
-    ON
+    ${CI}
 )
 
+if(NOT CCACHE_PROGRAM)
+  return()
+endif()
+
 set(CCACHE_ARGS CMAKE_C_COMPILER_LAUNCHER CMAKE_CXX_COMPILER_LAUNCHER)
 foreach(arg ${CCACHE_ARGS})
   setx(${arg} ${CCACHE_PROGRAM})
diff --git a/cmake/tools/SetupGit.cmake b/cmake/tools/SetupGit.cmake
index 33e11b5503..769735b7b0 100644
--- a/cmake/tools/SetupGit.cmake
+++ b/cmake/tools/SetupGit.cmake
@@ -11,7 +11,7 @@ if(NOT GIT_PROGRAM)
   return()
 endif()
 
-set(GIT_DIFF_COMMAND ${GIT_PROGRAM} diff --no-color --name-only --diff-filter=AMCR)
+set(GIT_DIFF_COMMAND ${GIT_PROGRAM} diff --no-color --name-only --diff-filter=AMCR origin/main HEAD)
 
 execute_process(
   COMMAND
@@ -29,10 +29,15 @@ 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()
 
 string(REPLACE "\n" ";" GIT_CHANGED_SOURCES "${GIT_DIFF}")
+
+if(CI)
+  setx(GIT_CHANGED_SOURCES ${GIT_CHANGED_SOURCES})
+endif()
+
 list(TRANSFORM GIT_CHANGED_SOURCES PREPEND ${CWD}/)
 list(LENGTH GIT_CHANGED_SOURCES GIT_CHANGED_SOURCES_COUNT)
diff --git a/cmake/tools/SetupLLVM.cmake b/cmake/tools/SetupLLVM.cmake
index c01aaab822..9db637b60d 100644
--- a/cmake/tools/SetupLLVM.cmake
+++ b/cmake/tools/SetupLLVM.cmake
@@ -1,55 +1,101 @@
-optionx(SKIP_LLVM BOOL "If LLVM setup should be skipped" DEFAULT OFF)
+optionx(ENABLE_LLVM BOOL "If LLVM should be used for compilation" DEFAULT ON)
 
-if(SKIP_LLVM)
+if(NOT ENABLE_LLVM)
   return()
 endif()
 
-if(CMAKE_HOST_WIN32 OR CMAKE_HOST_APPLE)
+if(CMAKE_HOST_WIN32 OR CMAKE_HOST_APPLE OR EXISTS "/etc/alpine-release")
   set(DEFAULT_LLVM_VERSION "18.1.8")
 else()
   set(DEFAULT_LLVM_VERSION "16.0.6")
 endif()
 
 optionx(LLVM_VERSION STRING "The version of LLVM to use" DEFAULT ${DEFAULT_LLVM_VERSION})
-parse_semver(${LLVM_VERSION} LLVM)
+
+string(REGEX MATCH "([0-9]+)\\.([0-9]+)\\.([0-9]+)" USE_LLVM_VERSION ${LLVM_VERSION})
+if(USE_LLVM_VERSION)
+  set(LLVM_VERSION_MAJOR ${CMAKE_MATCH_1})
+  set(LLVM_VERSION_MINOR ${CMAKE_MATCH_2})
+  set(LLVM_VERSION_PATCH ${CMAKE_MATCH_3})
+endif()
+
+set(LLVM_PATHS)
 
 if(APPLE)
   execute_process(
-    COMMAND brew --prefix llvm@${LLVM_VERSION_MAJOR}
-    OUTPUT_VARIABLE DEFAULT_LLVM_PREFIX
+    COMMAND brew --prefix
+    OUTPUT_VARIABLE HOMEBREW_PREFIX
     OUTPUT_STRIP_TRAILING_WHITESPACE
     ERROR_QUIET
   )
-  if(NOT DEFAULT_LLVM_PREFIX)
-    set(DEFAULT_LLVM_PREFIX /opt/homebrew/opt/llvm)
+
+  if(NOT HOMEBREW_PREFIX)
+    if(CMAKE_SYSTEM_PROCESSOR MATCHES "arm64|ARM64|aarch64|AARCH64")
+      set(HOMEBREW_PREFIX /opt/homebrew)
+    else()
+      set(HOMEBREW_PREFIX /usr/local)
+    endif()
+  endif()
+
+  list(APPEND LLVM_PATHS ${HOMEBREW_PREFIX}/opt/llvm/bin)
+
+  if(USE_LLVM_VERSION)
+    list(APPEND LLVM_PATHS ${HOMEBREW_PREFIX}/opt/llvm@${LLVM_VERSION_MAJOR}/bin)
   endif()
-elseif(NOT WIN32)
-  set(DEFAULT_LLVM_PREFIX /usr/lib/llvm-${LLVM_VERSION_MAJOR})
-else()
-  set(DEFAULT_LLVM_PREFIX /usr/lib)
 endif()
 
-optionx(LLVM_PREFIX FILEPATH "The path to the LLVM installation" DEFAULT ${DEFAULT_LLVM_PREFIX})
-set(LLVM_PATH ${LLVM_PREFIX}/bin)
+if(UNIX)
+  list(APPEND LLVM_PATHS /usr/lib/llvm/bin)
+
+  if(USE_LLVM_VERSION)
+    list(APPEND LLVM_PATHS
+      /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()
+
+macro(find_llvm_command variable command)
+  set(commands ${command})
+
+  if(USE_LLVM_VERSION)
+    list(APPEND commands
+      ${command}-${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}.${LLVM_VERSION_PATCH}
+      ${command}-${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}
+      ${command}-${LLVM_VERSION_MAJOR}
+    )
+  endif()
 
-macro(find_llvm_command VARIABLE COMMAND)
   find_command(
-    VARIABLE ${VARIABLE}
-    COMMAND ${COMMAND} ${COMMAND}-${LLVM_VERSION_MAJOR}
-    PATHS ${LLVM_PATH}
+    VARIABLE ${variable}
+    VERSION_VARIABLE LLVM_VERSION
+    COMMAND ${commands}
+    PATHS ${LLVM_PATHS}
     VERSION ${LLVM_VERSION}
   )
-  list(APPEND CMAKE_ARGS -D${VARIABLE}=${${VARIABLE}})
+  list(APPEND CMAKE_ARGS -D${variable}=${${variable}})
 endmacro()
 
-macro(find_llvm_command_no_version VARIABLE COMMAND)
+macro(find_llvm_command_no_version variable command)
+  set(commands ${command})
+
+  if(USE_LLVM_VERSION)
+    list(APPEND commands
+      ${command}-${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}.${LLVM_VERSION_PATCH}
+      ${command}-${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}
+      ${command}-${LLVM_VERSION_MAJOR}
+    )
+  endif()
+
   find_command(
-    VARIABLE ${VARIABLE}
-    COMMAND ${COMMAND} ${COMMAND}-${LLVM_VERSION_MAJOR}
-    PATHS ${LLVM_PATH}
-    REQUIRED ON
+    VARIABLE ${variable}
+    VERSION_VARIABLE LLVM_VERSION
+    COMMAND ${commands}
+    PATHS ${LLVM_PATHS}
   )
-  list(APPEND CMAKE_ARGS -D${VARIABLE}=${${VARIABLE}})
+  list(APPEND CMAKE_ARGS -D${variable}=${${variable}})
 endmacro()
 
 if(WIN32)
@@ -63,9 +109,29 @@ 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()
 endif()
+
+if(ENABLE_ANALYSIS)
+  find_llvm_command(CLANG_FORMAT_PROGRAM clang-format)
+  find_llvm_command(CLANG_TIDY_PROGRAM clang-tidy)
+endif()
diff --git a/cmake/tools/SetupRust.cmake b/cmake/tools/SetupRust.cmake
index a83b28bc5f..8a45d243eb 100644
--- a/cmake/tools/SetupRust.cmake
+++ b/cmake/tools/SetupRust.cmake
@@ -1,15 +1,42 @@
+if(DEFINED ENV{CARGO_HOME})
+  set(CARGO_HOME $ENV{CARGO_HOME})
+elseif(CMAKE_HOST_WIN32)
+  set(CARGO_HOME $ENV{USERPROFILE}/.cargo)
+  if(NOT EXISTS ${CARGO_HOME})
+    set(CARGO_HOME $ENV{PROGRAMFILES}/Rust/cargo)
+  endif()
+else()
+  set(CARGO_HOME $ENV{HOME}/.cargo)
+endif()
+
+if(DEFINED ENV{RUSTUP_HOME})
+  set(RUSTUP_HOME $ENV{RUSTUP_HOME})
+elseif(CMAKE_HOST_WIN32)
+  set(RUSTUP_HOME $ENV{USERPROFILE}/.rustup)
+  if(NOT EXISTS ${RUSTUP_HOME})
+    set(RUSTUP_HOME $ENV{PROGRAMFILES}/Rust/rustup)
+  endif()
+else()
+  set(RUSTUP_HOME $ENV{HOME}/.rustup)
+endif()
+
 find_command(
   VARIABLE
     CARGO_EXECUTABLE
   COMMAND
     cargo
   PATHS
-    $ENV{HOME}/.cargo/bin
+    ${CARGO_HOME}/bin
   REQUIRED
     OFF
 )
 
 if(EXISTS ${CARGO_EXECUTABLE})
+  if(CARGO_EXECUTABLE MATCHES "^${CARGO_HOME}")
+    setx(CARGO_HOME ${CARGO_HOME})
+    setx(RUSTUP_HOME ${RUSTUP_HOME})
+  endif()
+
   return()
 endif()
 
diff --git a/cmake/tools/SetupWebKit.cmake b/cmake/tools/SetupWebKit.cmake
index 5b31574a6a..e7cb26be5e 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 4a2db3254a9535949a5d5380eb58cf0f77c8e15a)
+  set(WEBKIT_VERSION 8f9ae4f01a047c666ef548864294e01df731d4ea)
 endif()
 
 if(WEBKIT_LOCAL)
@@ -63,12 +63,16 @@ else()
   message(FATAL_ERROR "Unsupported architecture: ${CMAKE_SYSTEM_PROCESSOR}")
 endif()
 
+if(LINUX AND ABI STREQUAL "musl")
+  set(WEBKIT_SUFFIX "-musl")
+endif()
+
 if(DEBUG)
-  set(WEBKIT_SUFFIX "-debug")
+  set(WEBKIT_SUFFIX "${WEBKIT_SUFFIX}-debug")
 elseif(ENABLE_LTO AND NOT WIN32)
-  set(WEBKIT_SUFFIX "-lto")
+  set(WEBKIT_SUFFIX "${WEBKIT_SUFFIX}-lto")
 else()
-  set(WEBKIT_SUFFIX "")
+  set(WEBKIT_SUFFIX "${WEBKIT_SUFFIX}")
 endif()
 
 set(WEBKIT_NAME bun-webkit-${WEBKIT_OS}-${WEBKIT_ARCH}${WEBKIT_SUFFIX})
diff --git a/cmake/tools/SetupZig.cmake b/cmake/tools/SetupZig.cmake
index e679423861..e5a5e574ef 100644
--- a/cmake/tools/SetupZig.cmake
+++ b/cmake/tools/SetupZig.cmake
@@ -11,7 +11,11 @@ if(APPLE)
 elseif(WIN32)
   set(DEFAULT_ZIG_TARGET ${DEFAULT_ZIG_ARCH}-windows-msvc)
 elseif(LINUX)
-  set(DEFAULT_ZIG_TARGET ${DEFAULT_ZIG_ARCH}-linux-gnu)
+  if(ABI STREQUAL "musl")
+    set(DEFAULT_ZIG_TARGET ${DEFAULT_ZIG_ARCH}-linux-musl)
+  else()
+    set(DEFAULT_ZIG_TARGET ${DEFAULT_ZIG_ARCH}-linux-gnu)
+  endif()
 else()
   unsupported(CMAKE_SYSTEM_NAME)
 endif()
diff --git a/dockerhub/alpine/Dockerfile b/dockerhub/alpine/Dockerfile
index e2bbba7aa4..0ef8ce5f6e 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/api/color.md b/docs/api/color.md
new file mode 100644
index 0000000000..da27adc625
--- /dev/null
+++ b/docs/api/color.md
@@ -0,0 +1,262 @@
+`Bun.color(input, outputFormat?)` leverages Bun's CSS parser to parse, normalize, and convert colors from user input to a variety of output formats, including:
+
+| Format       | Example                          |
+| ------------ | -------------------------------- |
+| `"css"`      | `"red"`                          |
+| `"ansi"`     | `"\x1b[38;2;255;0;0m"`           |
+| `"ansi-16"`  | `"\x1b[38;5;\tm"`                |
+| `"ansi-256"` | `"\x1b[38;5;196m"`               |
+| `"ansi-16m"` | `"\x1b[38;2;255;0;0m"`           |
+| `"number"`   | `0x1a2b3c`                       |
+| `"rgb"`      | `"rgb(255, 99, 71)"`             |
+| `"rgba"`     | `"rgba(255, 99, 71, 0.5)"`       |
+| `"hsl"`      | `"hsl(120, 50%, 50%)"`           |
+| `"hex"`      | `"#1a2b3c"`                      |
+| `"HEX"`      | `"#1A2B3C"`                      |
+| `"{rgb}"`    | `{ r: 255, g: 99, b: 71 }`       |
+| `"{rgba}"`   | `{ r: 255, g: 99, b: 71, a: 1 }` |
+| `"[rgb]"`    | `[ 255, 99, 71 ]`                |
+| `"[rgba]"`   | `[ 255, 99, 71, 255]`            |
+
+There are many different ways to use this API:
+
+- Validate and normalize colors to persist in a database (`number` is the most database-friendly)
+- Convert colors to different formats
+- Colorful logging beyond the 16 colors many use today (use `ansi` if you don't want to figure out what the user's terminal supports, otherwise use `ansi-16`, `ansi-256`, or `ansi-16m` for how many colors the terminal supports)
+- Format colors for use in CSS injected into HTML
+- Get the `r`, `g`, `b`, and `a` color components as JavaScript objects or numbers from a CSS color string
+
+You can think of this as an alternative to the popular npm packages [`color`](https://github.com/Qix-/color) and [`tinycolor2`](https://github.com/bgrins/TinyColor) except with full support for parsing CSS color strings and zero dependencies built directly into Bun.
+
+### Flexible input
+
+You can pass in any of the following:
+
+- Standard CSS color names like `"red"`
+- Numbers like `0xff0000`
+- Hex strings like `"#f00"`
+- RGB strings like `"rgb(255, 0, 0)"`
+- RGBA strings like `"rgba(255, 0, 0, 1)"`
+- HSL strings like `"hsl(0, 100%, 50%)"`
+- HSLA strings like `"hsla(0, 100%, 50%, 1)"`
+- RGB objects like `{ r: 255, g: 0, b: 0 }`
+- RGBA objects like `{ r: 255, g: 0, b: 0, a: 1 }`
+- RGB arrays like `[255, 0, 0]`
+- RGBA arrays like `[255, 0, 0, 255]`
+- LAB strings like `"lab(50% 50% 50%)"`
+- ... anything else that CSS can parse as a single color value
+
+### Format colors as CSS
+
+The `"css"` format outputs valid CSS for use in stylesheets, inline styles, CSS variables, css-in-js, etc. It returns the most compact representation of the color as a string.
+
+```ts
+Bun.color("red", "css"); // "red"
+Bun.color(0xff0000, "css"); // "#f000"
+Bun.color("#f00", "css"); // "red"
+Bun.color("#ff0000", "css"); // "red"
+Bun.color("rgb(255, 0, 0)", "css"); // "red"
+Bun.color("rgba(255, 0, 0, 1)", "css"); // "red"
+Bun.color("hsl(0, 100%, 50%)", "css"); // "red"
+Bun.color("hsla(0, 100%, 50%, 1)", "css"); // "red"
+Bun.color({ r: 255, g: 0, b: 0 }, "css"); // "red"
+Bun.color({ r: 255, g: 0, b: 0, a: 1 }, "css"); // "red"
+Bun.color([255, 0, 0], "css"); // "red"
+Bun.color([255, 0, 0, 255], "css"); // "red"
+```
+
+If the input is unknown or fails to parse, `Bun.color` returns `null`.
+
+### Format colors as ANSI (for terminals)
+
+The `"ansi"` format outputs ANSI escape codes for use in terminals to make text colorful.
+
+```ts
+Bun.color("red", "ansi"); // "\u001b[38;2;255;0;0m"
+Bun.color(0xff0000, "ansi"); // "\u001b[38;2;255;0;0m"
+Bun.color("#f00", "ansi"); // "\u001b[38;2;255;0;0m"
+Bun.color("#ff0000", "ansi"); // "\u001b[38;2;255;0;0m"
+Bun.color("rgb(255, 0, 0)", "ansi"); // "\u001b[38;2;255;0;0m"
+Bun.color("rgba(255, 0, 0, 1)", "ansi"); // "\u001b[38;2;255;0;0m"
+Bun.color("hsl(0, 100%, 50%)", "ansi"); // "\u001b[38;2;255;0;0m"
+Bun.color("hsla(0, 100%, 50%, 1)", "ansi"); // "\u001b[38;2;255;0;0m"
+Bun.color({ r: 255, g: 0, b: 0 }, "ansi"); // "\u001b[38;2;255;0;0m"
+Bun.color({ r: 255, g: 0, b: 0, a: 1 }, "ansi"); // "\u001b[38;2;255;0;0m"
+Bun.color([255, 0, 0], "ansi"); // "\u001b[38;2;255;0;0m"
+Bun.color([255, 0, 0, 255], "ansi"); // "\u001b[38;2;255;0;0m"
+```
+
+This gets the color depth of stdout and automatically chooses one of `"ansi-16m"`, `"ansi-256"`, `"ansi-16"` based on the environment variables. If stdout doesn't support any form of ANSI color, it returns an empty string. As with the rest of Bun's color API, if the input is unknown or fails to parse, it returns `null`.
+
+#### 24-bit ANSI colors (`ansi-16m`)
+
+The `"ansi-16m"` format outputs 24-bit ANSI colors for use in terminals to make text colorful. 24-bit color means you can display 16 million colors on supported terminals, and requires a modern terminal that supports it.
+
+This converts the input color to RGBA, and then outputs that as an ANSI color.
+
+```ts
+Bun.color("red", "ansi-16m"); // "\x1b[38;2;255;0;0m"
+Bun.color(0xff0000, "ansi-16m"); // "\x1b[38;2;255;0;0m"
+Bun.color("#f00", "ansi-16m"); // "\x1b[38;2;255;0;0m"
+Bun.color("#ff0000", "ansi-16m"); // "\x1b[38;2;255;0;0m"
+```
+
+#### 256 ANSI colors (`ansi-256`)
+
+The `"ansi-256"` format approximates the input color to the nearest of the 256 ANSI colors supported by some terminals.
+
+```ts
+Bun.color("red", "ansi-256"); // "\u001b[38;5;196m"
+Bun.color(0xff0000, "ansi-256"); // "\u001b[38;5;196m"
+Bun.color("#f00", "ansi-256"); // "\u001b[38;5;196m"
+Bun.color("#ff0000", "ansi-256"); // "\u001b[38;5;196m"
+```
+
+To convert from RGBA to one of the 256 ANSI colors, we ported the algorithm that [`tmux` uses](https://github.com/tmux/tmux/blob/dae2868d1227b95fd076fb4a5efa6256c7245943/colour.c#L44-L55).
+
+#### 16 ANSI colors (`ansi-16`)
+
+The `"ansi-16"` format approximates the input color to the nearest of the 16 ANSI colors supported by most terminals.
+
+```ts
+Bun.color("red", "ansi-16"); // "\u001b[38;5;\tm"
+Bun.color(0xff0000, "ansi-16"); // "\u001b[38;5;\tm"
+Bun.color("#f00", "ansi-16"); // "\u001b[38;5;\tm"
+Bun.color("#ff0000", "ansi-16"); // "\u001b[38;5;\tm"
+```
+
+This works by first converting the input to a 24-bit RGB color space, then to `ansi-256`, and then we convert that to the nearest 16 ANSI color.
+
+### Format colors as numbers
+
+The `"number"` format outputs a 24-bit number for use in databases, configuration, or any other use case where a compact representation of the color is desired.
+
+```ts
+Bun.color("red", "number"); // 16711680
+Bun.color(0xff0000, "number"); // 16711680
+Bun.color({ r: 255, g: 0, b: 0 }, "number"); // 16711680
+Bun.color([255, 0, 0], "number"); // 16711680
+Bun.color("rgb(255, 0, 0)", "number"); // 16711680
+Bun.color("rgba(255, 0, 0, 1)", "number"); // 16711680
+Bun.color("hsl(0, 100%, 50%)", "number"); // 16711680
+Bun.color("hsla(0, 100%, 50%, 1)", "number"); // 16711680
+```
+
+### Get the red, green, blue, and alpha channels
+
+You can use the `"{rgba}"`, `"{rgb}"`, `"[rgba]"` and `"[rgb]"` formats to get the red, green, blue, and alpha channels as objects or arrays.
+
+#### `{rgba}` object
+
+The `"{rgba}"` format outputs an object with the red, green, blue, and alpha channels.
+
+```ts
+type RGBAObject = {
+  // 0 - 255
+  r: number;
+  // 0 - 255
+  g: number;
+  // 0 - 255
+  b: number;
+  // 0 - 1
+  a: number;
+};
+```
+
+Example:
+
+```ts
+Bun.color("hsl(0, 0%, 50%)", "{rgba}"); // { r: 128, g: 128, b: 128, a: 1 }
+Bun.color("red", "{rgba}"); // { r: 255, g: 0, b: 0, a: 1 }
+Bun.color(0xff0000, "{rgba}"); // { r: 255, g: 0, b: 0, a: 1 }
+Bun.color({ r: 255, g: 0, b: 0 }, "{rgba}"); // { r: 255, g: 0, b: 0, a: 1 }
+Bun.color([255, 0, 0], "{rgba}"); // { r: 255, g: 0, b: 0, a: 1 }
+```
+
+To behave similarly to CSS, the `a` channel is a decimal number between `0` and `1`.
+
+The `"{rgb}"` format is similar, but it doesn't include the alpha channel.
+
+```ts
+Bun.color("hsl(0, 0%, 50%)", "{rgb}"); // { r: 128, g: 128, b: 128 }
+Bun.color("red", "{rgb}"); // { r: 255, g: 0, b: 0 }
+Bun.color(0xff0000, "{rgb}"); // { r: 255, g: 0, b: 0 }
+Bun.color({ r: 255, g: 0, b: 0 }, "{rgb}"); // { r: 255, g: 0, b: 0 }
+Bun.color([255, 0, 0], "{rgb}"); // { r: 255, g: 0, b: 0 }
+```
+
+#### `[rgba]` array
+
+The `"[rgba]"` format outputs an array with the red, green, blue, and alpha channels.
+
+```ts
+// All values are 0 - 255
+type RGBAArray = [number, number, number, number];
+```
+
+Example:
+
+```ts
+Bun.color("hsl(0, 0%, 50%)", "[rgba]"); // [128, 128, 128, 255]
+Bun.color("red", "[rgba]"); // [255, 0, 0, 255]
+Bun.color(0xff0000, "[rgba]"); // [255, 0, 0, 255]
+Bun.color({ r: 255, g: 0, b: 0 }, "[rgba]"); // [255, 0, 0, 255]
+Bun.color([255, 0, 0], "[rgba]"); // [255, 0, 0, 255]
+```
+
+Unlike the `"{rgba}"` format, the alpha channel is an integer between `0` and `255`. This is useful for typed arrays where each channel must be the same underlying type.
+
+The `"[rgb]"` format is similar, but it doesn't include the alpha channel.
+
+```ts
+Bun.color("hsl(0, 0%, 50%)", "[rgb]"); // [128, 128, 128]
+Bun.color("red", "[rgb]"); // [255, 0, 0]
+Bun.color(0xff0000, "[rgb]"); // [255, 0, 0]
+Bun.color({ r: 255, g: 0, b: 0 }, "[rgb]"); // [255, 0, 0]
+Bun.color([255, 0, 0], "[rgb]"); // [255, 0, 0]
+```
+
+### Format colors as hex strings
+
+The `"hex"` format outputs a lowercase hex string for use in CSS or other contexts.
+
+```ts
+Bun.color("hsl(0, 0%, 50%)", "hex"); // "#808080"
+Bun.color("red", "hex"); // "#ff0000"
+Bun.color(0xff0000, "hex"); // "#ff0000"
+Bun.color({ r: 255, g: 0, b: 0 }, "hex"); // "#ff0000"
+Bun.color([255, 0, 0], "hex"); // "#ff0000"
+```
+
+The `"HEX"` format is similar, but it outputs a hex string with uppercase letters instead of lowercase letters.
+
+```ts
+Bun.color("hsl(0, 0%, 50%)", "HEX"); // "#808080"
+Bun.color("red", "HEX"); // "#FF0000"
+Bun.color(0xff0000, "HEX"); // "#FF0000"
+Bun.color({ r: 255, g: 0, b: 0 }, "HEX"); // "#FF0000"
+Bun.color([255, 0, 0], "HEX"); // "#FF0000"
+```
+
+### Bundle-time client-side color formatting
+
+Like many of Bun's APIs, you can use macros to invoke `Bun.color` at bundle-time for use in client-side JavaScript builds:
+
+```ts#client-side.ts
+import { color } from "bun" with { type: "macro" };
+
+console.log(color("#f00", "css"));
+```
+
+Then, build the client-side code:
+
+```sh
+bun build ./client-side.ts
+```
+
+This will output the following to `client-side.js`:
+
+```js
+// client-side.ts
+console.log("red");
+```
diff --git a/docs/api/dns.md b/docs/api/dns.md
index bdc6c83e86..4553263fab 100644
--- a/docs/api/dns.md
+++ b/docs/api/dns.md
@@ -14,7 +14,7 @@ In Bun v1.1.9, we added support for DNS caching. This cache makes repeated conne
 
 At the time of writing, we cache up to 255 entries for a maximum of 30 seconds (each). If any connections to a host fail, we remove the entry from the cache. When multiple connections are made to the same host simultaneously, DNS lookups are deduplicated to avoid making multiple requests for the same host.
 
-This cache is automatically used by;
+This cache is automatically used by:
 
 - `bun install`
 - `fetch()`
@@ -99,7 +99,7 @@ console.log(stats);
 
 ### Configuring DNS cache TTL
 
-Bun defaults to 30 seconds for the TTL of DNS cache entries. To change this, you can set the envionrment variable `$BUN_CONFIG_DNS_TIME_TO_LIVE_SECONDS`. For example, to set the TTL to 5 seconds:
+Bun defaults to 30 seconds for the TTL of DNS cache entries. To change this, you can set the environment variable `$BUN_CONFIG_DNS_TIME_TO_LIVE_SECONDS`. For example, to set the TTL to 5 seconds:
 
 ```sh
 BUN_CONFIG_DNS_TIME_TO_LIVE_SECONDS=5 bun run my-script.ts
diff --git a/docs/api/hashing.md b/docs/api/hashing.md
index 1ff4a83f4f..5cc40e2a75 100644
--- a/docs/api/hashing.md
+++ b/docs/api/hashing.md
@@ -65,6 +65,73 @@ const isMatch = Bun.password.verifySync(password, hash);
 // => true
 ```
 
+### Salt
+
+When you use `Bun.password.hash`, a salt is automatically generated and included in the hash.
+
+### bcrypt - Modular Crypt Format
+
+In the following [Modular Crypt Format](https://passlib.readthedocs.io/en/stable/modular_crypt_format.html) hash (used by `bcrypt`):
+
+Input:
+
+```ts
+await Bun.password.hash("hello", {
+  algorithm: "bcrypt",
+});
+```
+
+Output:
+
+```sh
+$2b$10$Lyj9kHYZtiyfxh2G60TEfeqs7xkkGiEFFDi3iJGc50ZG/XJ1sxIFi;
+```
+
+The format is composed of:
+
+- `bcrypt`: `$2b`
+- `rounds`: `$10` - rounds (log10 of the actual number of rounds)
+- `salt`: `$Lyj9kHYZtiyfxh2G60TEfeqs7xkkGiEFFDi3iJGc50ZG/XJ1sxIFi`
+- `hash`: `$GzJ8PuBi+K+BVojzPfS5mjnC8OpLGtv8KJqF99eP6a4`
+
+By default, the bcrypt library truncates passwords longer than 72 bytes. In Bun, if you pass `Bun.password.hash` a password longer than 72 bytes and use the `bcrypt` algorithm, the password will be hashed via SHA-512 before being passed to bcrypt.
+
+```ts
+await Bun.password.hash("hello".repeat(100), {
+  algorithm: "bcrypt",
+});
+```
+
+So instead of sending bcrypt a 500-byte password silently truncated to 72 bytes, Bun will hash the password using SHA-512 and send the hashed password to bcrypt (only if it exceeds 72 bytes). This is a more secure default behavior.
+
+### argon2 - PHC format
+
+In the following [PHC format](https://github.com/P-H-C/phc-string-format/blob/master/phc-sf-spec.md) hash (used by `argon2`):
+
+Input:
+
+```ts
+await Bun.password.hash("hello", {
+  algorithm: "argon2id",
+});
+```
+
+Output:
+
+```sh
+$argon2id$v=19$m=65536,t=2,p=1$xXnlSvPh4ym5KYmxKAuuHVlDvy2QGHBNuI6bJJrRDOs$2YY6M48XmHn+s5NoBaL+ficzXajq2Yj8wut3r0vnrwI
+```
+
+The format is composed of:
+
+- `algorithm`: `$argon2id`
+- `version`: `$v=19`
+- `memory cost`: `65536`
+- `iterations`: `t=2`
+- `parallelism`: `p=1`
+- `salt`: `$xXnlSvPh4ym5KYmxKAuuHVlDvy2QGHBNuI6bJJrRDOs`
+- `hash`: `$2YY6M48XmHn+s5NoBaL+ficzXajq2Yj8wut3r0vnrwI`
+
 ## `Bun.hash`
 
 `Bun.hash` is a collection of utilities for _non-cryptographic_ hashing. Non-cryptographic hashing algorithms are optimized for speed of computation over collision-resistance or security.
@@ -206,4 +273,42 @@ console.log(arr);
 // => Uint8Array(32) [ 185, 77, 39, 185, 147, ... ]
 ```
 
-<!-- Bun.sha; -->
+### HMAC in `Bun.CryptoHasher`
+
+`Bun.CryptoHasher` can be used to compute HMAC digests. To do so, pass the key to the constructor.
+
+```ts
+const hasher = new Bun.CryptoHasher("sha256", "secret-key");
+hasher.update("hello world");
+console.log(hasher.digest("hex"));
+// => "095d5a21fe6d0646db223fdf3de6436bb8dfb2fab0b51677ecf6441fcf5f2a67"
+```
+
+When using HMAC, a more limited set of algorithms are supported:
+
+- `"blake2b512"`
+- `"md5"`
+- `"sha1"`
+- `"sha224"`
+- `"sha256"`
+- `"sha384"`
+- `"sha512-224"`
+- `"sha512-256"`
+- `"sha512"`
+
+Unlike the non-HMAC `Bun.CryptoHasher`, the HMAC `Bun.CryptoHasher` instance is not reset after `.digest()` is called, and attempting to use the same instance again will throw an error.
+
+Other methods like `.copy()` and `.update()` are supported (as long as it's before `.digest()`), but methods like `.digest()` that finalize the hasher are not.
+
+```ts
+const hasher = new Bun.CryptoHasher("sha256", "secret-key");
+hasher.update("hello world");
+
+const copy = hasher.copy();
+copy.update("!");
+console.log(copy.digest("hex"));
+// => "3840176c3d8923f59ac402b7550404b28ab11cb0ef1fa199130a5c37864b5497"
+
+console.log(hasher.digest("hex"));
+// => "095d5a21fe6d0646db223fdf3de6436bb8dfb2fab0b51677ecf6441fcf5f2a67"
+```
diff --git a/docs/api/http.md b/docs/api/http.md
index 7b5c7636d6..f6e6499dc4 100644
--- a/docs/api/http.md
+++ b/docs/api/http.md
@@ -402,7 +402,7 @@ Bun.serve({
 });
 ```
 
-### Sever name indication (SNI)
+### Server name indication (SNI)
 
 To configure the server name indication (SNI) for the server, set the `serverName` field in the `tls` object.
 
diff --git a/docs/api/spawn.md b/docs/api/spawn.md
index e540cc8316..3097af8585 100644
--- a/docs/api/spawn.md
+++ b/docs/api/spawn.md
@@ -179,7 +179,7 @@ proc.kill(); // specify an exit code
 
 The parent `bun` process will not terminate until all child processes have exited. Use `proc.unref()` to detach the child process from the parent.
 
-```
+```ts
 const proc = Bun.spawn(["bun", "--version"]);
 proc.unref();
 ```
diff --git a/docs/api/sqlite.md b/docs/api/sqlite.md
index fc71467829..49c84136bb 100644
--- a/docs/api/sqlite.md
+++ b/docs/api/sqlite.md
@@ -75,7 +75,7 @@ To instead throw an error when a parameter is missing and allow binding without
 import { Database } from "bun:sqlite";
 
 const strict = new Database(
-  ":memory:", 
+  ":memory:",
   { strict: true }
 );
 
@@ -177,7 +177,7 @@ const query = db.prepare("SELECT * FROM foo WHERE bar = ?");
 
 ## WAL mode
 
-SQLite supports [write-ahead log mode](https://www.sqlite.org/wal.html) (WAL) which dramatically improves performance, especially in situations with many concurrent writes. It's broadly recommended to enable WAL mode for most typical applications.
+SQLite supports [write-ahead log mode](https://www.sqlite.org/wal.html) (WAL) which dramatically improves performance, especially in situations with many concurrent readers and a single writer. It's broadly recommended to enable WAL mode for most typical applications.
 
 To enable WAL mode, run this pragma query at the beginning of your application:
 
@@ -325,6 +325,28 @@ As a performance optimization, the class constructor is not called, default init
 
 The database columns are set as properties on the class instance.
 
+### `.iterate()` (`@@iterator`)
+
+Use `.iterate()` to run a query and incrementally return results. This is useful for large result sets that you want to process one row at a time without loading all the results into memory.
+
+```ts
+const query = db.query("SELECT * FROM foo");
+for (const row of query.iterate()) {
+  console.log(row);
+}
+```
+
+You can also use the `@@iterator` protocol:
+
+```ts
+const query = db.query("SELECT * FROM foo");
+for (const row of query) {
+  console.log(row);
+}
+```
+
+This feature was added in Bun v1.1.31.
+
 ### `.values()`
 
 Use `values()` to run a query and get back all results as an array of arrays.
diff --git a/docs/api/utils.md b/docs/api/utils.md
index d4e46441e0..3b87922106 100644
--- a/docs/api/utils.md
+++ b/docs/api/utils.md
@@ -106,6 +106,57 @@ const ls = Bun.which("ls", {
 console.log(ls); // null
 ```
 
+You can think of this as a builtin alternative to the [`which`](https://www.npmjs.com/package/which) npm package.
+
+## `Bun.randomUUIDv7()`
+
+`Bun.randomUUIDv7()` returns a [UUID v7](https://www.ietf.org/archive/id/draft-peabody-dispatch-new-uuid-format-01.html#name-uuidv7-layout-and-bit-order), which is monotonic and suitable for sorting and databases.
+
+```ts
+import { randomUUIDv7 } from "bun";
+
+const id = randomUUIDv7();
+// => "0192ce11-26d5-7dc3-9305-1426de888c5a"
+```
+
+A UUID v7 is a 128-bit value that encodes the current timestamp, a random value, and a counter. The timestamp is encoded using the lowest 48 bits, and the random value and counter are encoded using the remaining bits.
+
+The `timestamp` parameter defaults to the current time in milliseconds. When the timestamp changes, the counter is reset to a psuedo-random integer wrapped to 4096. This counter is atomic and threadsafe, meaning that using `Bun.randomUUIDv7()` in many Workers within the same process running at the same timestamp will not have colliding counter values.
+
+The final 8 bytes of the UUID are a cryptographically secure random value. It uses the same random number generator used by `crypto.randomUUID()` (which comes from BoringSSL, which in turn comes from the platform-specific system random number generator usually provided by the underlying hardware).
+
+```ts
+namespace Bun {
+  function randomUUIDv7(
+    encoding?: "hex" | "base64" | "base64url" = "hex",
+    timestamp?: number = Date.now(),
+  ): string;
+  /**
+   * If you pass "buffer", you get a 16-byte buffer instead of a string.
+   */
+  function randomUUIDv7(
+    encoding: "buffer",
+    timestamp?: number = Date.now(),
+  ): Buffer;
+
+  // If you only pass a timestamp, you get a hex string
+  function randomUUIDv7(timestamp?: number = Date.now()): string;
+}
+```
+
+You can optionally set encoding to `"buffer"` to get a 16-byte buffer instead of a string. This can sometimes avoid string conversion overhead.
+
+```ts#buffer.ts
+const buffer = Bun.randomUUIDv7("buffer");
+```
+
+`base64` and `base64url` encodings are also supported when you want a slightly shorter string.
+
+```ts#base64.ts
+const base64 = Bun.randomUUIDv7("base64");
+const base64url = Bun.randomUUIDv7("base64url");
+```
+
 ## `Bun.peek()`
 
 `Bun.peek(prom: Promise)`
@@ -580,6 +631,65 @@ const foo = new Foo();
 console.log(foo); // => "foo"
 ```
 
+## `Bun.inspect.table(tabularData, properties, options)`
+
+Format tabular data into a string. Like [`console.table`](https://developer.mozilla.org/en-US/docs/Web/API/console/table_static), except it returns a string rather than printing to the console.
+
+```ts
+console.log(
+  Bun.inspect.table([
+    { a: 1, b: 2, c: 3 },
+    { a: 4, b: 5, c: 6 },
+    { a: 7, b: 8, c: 9 },
+  ]),
+);
+//
+// ┌───┬───┬───┬───┐
+// │   │ a │ b │ c │
+// ├───┼───┼───┼───┤
+// │ 0 │ 1 │ 2 │ 3 │
+// │ 1 │ 4 │ 5 │ 6 │
+// │ 2 │ 7 │ 8 │ 9 │
+// └───┴───┴───┴───┘
+```
+
+Additionally, you can pass an array of property names to display only a subset of properties.
+
+```ts
+console.log(
+  Bun.inspect.table(
+    [
+      { a: 1, b: 2, c: 3 },
+      { a: 4, b: 5, c: 6 },
+    ],
+    ["a", "c"],
+  ),
+);
+//
+// ┌───┬───┬───┐
+// │   │ a │ c │
+// ├───┼───┼───┤
+// │ 0 │ 1 │ 3 │
+// │ 1 │ 4 │ 6 │
+// └───┴───┴───┘
+```
+
+You can also conditionally enable ANSI colors by passing `{ colors: true }`.
+
+```ts
+console.log(
+  Bun.inspect.table(
+    [
+      { a: 1, b: 2, c: 3 },
+      { a: 4, b: 5, c: 6 },
+    ],
+    {
+      colors: true,
+    },
+  ),
+);
+```
+
 ## `Bun.nanoseconds()`
 
 Returns the number of nanoseconds since the current `bun` process started, as a `number`. Useful for high-precision timing and benchmarking.
diff --git a/docs/api/workers.md b/docs/api/workers.md
index b20fb78085..04e1ff8f8d 100644
--- a/docs/api/workers.md
+++ b/docs/api/workers.md
@@ -50,6 +50,28 @@ const worker = new Worker("/not-found.js");
 
 The specifier passed to `Worker` is resolved relative to the project root (like typing `bun ./path/to/file.js`).
 
+### `preload` - load modules before the worker starts
+
+You can pass an array of module specifiers to the `preload` option to load modules before the worker starts. This is useful when you want to ensure some code is always loaded before the application starts, like loading OpenTelemetry, Sentry, DataDog, etc.
+
+```js
+const worker = new Worker("./worker.ts", {
+  preload: ["./load-sentry.js"],
+});
+```
+
+Like the `--preload` CLI argument, the `preload` option is processed before the worker starts.
+
+You can also pass a single string to the `preload` option:
+
+```js
+const worker = new Worker("./worker.ts", {
+  preload: "./load-sentry.js",
+});
+```
+
+This feature was added in Bun v1.1.35.
+
 ### `blob:` URLs
 
 As of Bun v1.1.13, you can also pass a `blob:` URL to `Worker`. This is useful for creating workers from strings or other sources.
diff --git a/docs/bundler/executables.md b/docs/bundler/executables.md
index 7a7f05693f..6ae39a574c 100644
--- a/docs/bundler/executables.md
+++ b/docs/bundler/executables.md
@@ -100,12 +100,30 @@ When deploying to production, we recommend the following:
 bun build --compile --minify --sourcemap ./path/to/my/app.ts --outfile myapp
 ```
 
-**What do these flags do?**
+### Bytecode compilation
+
+To improve startup time, enable bytecode compilation:
+
+```sh
+bun build --compile --minify --sourcemap --bytecode ./path/to/my/app.ts --outfile myapp
+```
+
+Using bytecode compilation, `tsc` starts 2x faster:
+
+{% image src="https://github.com/user-attachments/assets/dc8913db-01d2-48f8-a8ef-ac4e984f9763" width="689" /%}
+
+Bytecode compilation moves parsing overhead for large input files from runtime to bundle time. Your app starts faster, in exchange for making the `bun build` command a little slower. It doesn't obscure source code.
+
+**Experimental:** Bytecode compilation is an experimental feature introduced in Bun v1.1.30. Only `cjs` format is supported (which means no top-level-await). Let us know if you run into any issues!
+
+### What do these flags do?
 
 The `--minify` argument optimizes the size of the transpiled output code. If you have a large application, this can save megabytes of space. For smaller applications, it might still improve start time a little.
 
 The `--sourcemap` argument embeds a sourcemap compressed with zstd, so that errors & stacktraces point to their original locations instead of the transpiled location. Bun will automatically decompress & resolve the sourcemap when an error occurs.
 
+The `--bytecode` argument enables bytecode compilation. Every time you run JavaScript code in Bun, JavaScriptCore (the engine) will compile your source code into bytecode. We can move this parsing work from runtime to bundle time, saving you startup time.
+
 ## Worker
 
 To use workers in a standalone executable, add the worker's entrypoint to the CLI arguments:
diff --git a/docs/bundler/index.md b/docs/bundler/index.md
index a3b166e8b4..4680d8cc5a 100644
--- a/docs/bundler/index.md
+++ b/docs/bundler/index.md
@@ -330,6 +330,8 @@ Depending on the target, Bun will apply different module resolution rules and op
 
   If any entrypoints contains a Bun shebang (`#!/usr/bin/env bun`) the bundler will default to `target: "bun"` instead of `"browser"`.
 
+  When using `target: "bun"` and `format: "cjs"` together, the `// @bun @bun-cjs` pragma is added and the CommonJS wrapper function is not compatible with Node.js.
+
 ---
 
 - `node`
@@ -341,7 +343,11 @@ Depending on the target, Bun will apply different module resolution rules and op
 
 Specifies the module format to be used in the generated bundles.
 
-Currently the bundler only supports one module format: `"esm"`. Support for `"cjs"` and `"iife"` are planned.
+Bun defaults to `"esm"`, and provides experimental support for `"cjs"` and `"iife"`.
+
+#### `format: "esm"` - ES Module
+
+This is the default format, which supports ES Module syntax including top-level `await`, import.meta, and more.
 
 {% codetabs %}
 
@@ -359,44 +365,31 @@ $ bun build ./index.tsx --outdir ./out --format esm
 
 {% /codetabs %}
 
-<!-- ### `bundling`
+To use ES Module syntax in browsers, set `format` to `"esm"` and make sure your `<script type="module">` tag has `type="module"` set.
 
-Whether to enable bundling.
+#### `format: "cjs"` - CommonJS
 
-{% codetabs group="a" %}
+To build a CommonJS module, set `format` to `"cjs"`. When choosing `"cjs"`, the default target changes from `"browser"` (esm) to `"node"` (cjs). CommonJS modules transpiled with `format: "cjs", target: "node"` can be executed in both Bun and Node.js (assuming the APIs in use are supported by both).
+
+{% codetabs %}
 
 ```ts#JavaScript
 await Bun.build({
   entrypoints: ['./index.tsx'],
   outdir: './out',
-  bundling: true, // default
+  format: "cjs",
 })
 ```
 
 ```bash#CLI
-# bundling is enabled by default
-$ bun build ./index.tsx --outdir ./out
+$ bun build ./index.tsx --outdir ./out --format cjs
 ```
 
 {% /codetabs %}
 
-Set to `false` to disable bundling. Instead, files will be transpiled and individually written to `outdir`.
+#### `format: "iife"` - IIFE
 
-{% codetabs group="a" %}
-
-```ts#JavaScript
-await Bun.build({
-  entrypoints: ['./index.tsx'],
-  outdir: './out',
-  bundling: false,
-})
-```
-
-```bash#CLI
-$ bun build ./index.tsx --outdir ./out --no-bundling
-```
-
-{% /codetabs %} -->
+TODO: document IIFE once we support globalNames.
 
 ### `splitting`
 
@@ -758,7 +751,7 @@ $ bun build ./index.tsx --outdir ./out --external '*'
 
 ### `packages`
 
-Control whatever package dependencies are included to bundle or not. Possible values: `bundle` (default), `external`. Bun threats any import which path do not start with `.`, `..` or `/` as package.
+Control whatever package dependencies are included to bundle or not. Possible values: `bundle` (default), `external`. Bun treats any import which path do not start with `.`, `..` or `/` as package.
 
 {% codetabs group="a" %}
 
@@ -1097,6 +1090,84 @@ $ bun build ./index.tsx --outdir ./out --loader .png:dataurl --loader .txt:file
 
 {% /codetabs %}
 
+### `banner`
+
+A banner to be added to the final bundle, this can be a directive like "use client" for react or a comment block such as a license for the code.
+
+{% codetabs %}
+
+```ts#JavaScript
+await Bun.build({
+  entrypoints: ['./index.tsx'],
+  outdir: './out',
+  banner: '"use client";'
+})
+```
+
+```bash#CLI
+$ bun build ./index.tsx --outdir ./out --banner "\"use client\";"
+```
+
+{% /codetabs %}
+
+### `footer`
+
+A footer to be added to the final bundle, this can be something like a comment block for a license or just a fun easter egg.
+
+{% codetabs %}
+
+```ts#JavaScript
+await Bun.build({
+  entrypoints: ['./index.tsx'],
+  outdir: './out',
+  footer: '// built with love in SF'
+})
+```
+
+```bash#CLI
+$ bun build ./index.tsx --outdir ./out --footer="// built with love in SF"
+```
+
+{% /codetabs %}
+
+### `drop`
+
+Remove function calls from a bundle. For example, `--drop=console` will remove all calls to `console.log`. Arguments to calls will also be removed, regardless of if those arguments may have side effects. Dropping `debugger` will remove all `debugger` statements.
+
+{% codetabs %}
+
+```ts#JavaScript
+await Bun.build({
+  entrypoints: ['./index.tsx'],
+  outdir: './out',
+  drop: ["console", "debugger", "anyIdentifier.or.propertyAccess"],
+})
+```
+
+```bash#CLI
+$ bun build ./index.tsx --outdir ./out --drop=console --drop=debugger --drop=anyIdentifier.or.propertyAccess
+```
+
+{% /codetabs %}
+
+### `experimentalCss`
+
+Whether to enable _experimental_ support for bundling CSS files. Defaults to `false`.
+
+This supports bundling CSS files imported from JS, as well as CSS entrypoints.
+
+{% codetabs group="a" %}
+
+```ts#JavaScript
+const result = await Bun.build({
+  entrypoints: ["./index.ts"],
+  experimentalCss: true,
+});
+// => { success: boolean, outputs: BuildArtifact[], logs: BuildMessage[] }
+```
+
+{% /codetabs %}
+
 ## Outputs
 
 The `Bun.build` function returns a `Promise<BuildOutput>`, defined as:
@@ -1138,7 +1209,7 @@ Each artifact also contains the following properties:
 ---
 
 - `kind`
-- What kind of build output this file is. A build generates bundled entrypoints, code-split "chunks", sourcemaps, and copied assets (like images).
+- What kind of build output this file is. A build generates bundled entrypoints, code-split "chunks", sourcemaps, bytecode, and copied assets (like images).
 
 ---
 
@@ -1203,6 +1274,26 @@ BuildArtifact (entry-point) {
 
 {% /codetabs %}
 
+### Bytecode
+
+The `bytecode: boolean` option can be used to generate bytecode for any JavaScript/TypeScript entrypoints. This can greatly improve startup times for large applications. Only supported for `"cjs"` format, only supports `"target": "bun"` and dependent on a matching version of Bun. This adds a corresponding `.jsc` file for each entrypoint.
+
+{% codetabs %}
+
+```ts#JavaScript
+await Bun.build({
+  entrypoints: ["./index.tsx"],
+  outdir: "./out",
+  bytecode: true,
+})
+```
+
+```bash#CLI
+$ bun build ./index.tsx --outdir ./out --bytecode
+```
+
+{% /codetabs %}
+
 ### Executables
 
 Bun supports "compiling" a JavaScript/TypeScript entrypoint into a standalone executable. This executable contains a copy of the Bun binary.
@@ -1266,33 +1357,104 @@ interface Bun {
   build(options: BuildOptions): Promise<BuildOutput>;
 }
 
-interface BuildOptions {
-  entrypoints: string[]; // required
-  outdir?: string; // default: no write (in-memory only)
-  format?: "esm"; // later: "cjs" | "iife"
-  target?: "browser" | "bun" | "node"; // "browser"
-  splitting?: boolean; // true
-  plugins?: BunPlugin[]; // [] // See https://bun.sh/docs/bundler/plugins
-  loader?: { [k in string]: Loader }; // See https://bun.sh/docs/bundler/loaders
-  manifest?: boolean; // false
-  external?: string[]; // []
-  sourcemap?: "none" | "inline" | "linked" | "external" | "linked" | boolean; // "none"
-  root?: string; // computed from entrypoints
+interface BuildConfig {
+  entrypoints: string[]; // list of file path
+  outdir?: string; // output directory
+  target?: Target; // default: "browser"
+  /**
+   * Output module format. Top-level await is only supported for `"esm"`.
+   *
+   * Can be:
+   * - `"esm"`
+   * - `"cjs"` (**experimental**)
+   * - `"iife"` (**experimental**)
+   *
+   * @default "esm"
+   */
+  format?: /**
+
+     * ECMAScript Module format
+     */
+  | "esm"
+    /**
+     * CommonJS format
+     * **Experimental**
+     */
+    | "cjs"
+    /**
+     * IIFE format
+     * **Experimental**
+     */
+    | "iife";
   naming?:
     | string
     | {
-        entry?: string; // '[dir]/[name].[ext]'
-        chunk?: string; // '[name]-[hash].[ext]'
-        asset?: string; // '[name]-[hash].[ext]'
-      };
-  publicPath?: string; // e.g. http://mydomain.com/
+        chunk?: string;
+        entry?: string;
+        asset?: string;
+      }; // | string;
+  root?: string; // project root
+  splitting?: boolean; // default true, enable code splitting
+  plugins?: BunPlugin[];
+  // manifest?: boolean; // whether to return manifest
+  external?: string[];
+  packages?: "bundle" | "external";
+  publicPath?: string;
+  define?: Record<string, string>;
+  // origin?: string; // e.g. http://mydomain.com
+  loader?: { [k in string]: Loader };
+  sourcemap?: "none" | "linked" | "inline" | "external" | "linked"; // default: "none", true -> "inline"
+  /**
+   * package.json `exports` conditions used when resolving imports
+   *
+   * Equivalent to `--conditions` in `bun build` or `bun run`.
+   *
+   * https://nodejs.org/api/packages.html#exports
+   */
+  conditions?: Array<string> | string;
   minify?:
-    | boolean // false
+    | boolean
     | {
-        identifiers?: boolean;
         whitespace?: boolean;
         syntax?: boolean;
+        identifiers?: boolean;
       };
+  /**
+   * Ignore dead code elimination/tree-shaking annotations such as @__PURE__ and package.json
+   * "sideEffects" fields. This should only be used as a temporary workaround for incorrect
+   * annotations in libraries.
+   */
+  ignoreDCEAnnotations?: boolean;
+  /**
+   * Force emitting @__PURE__ annotations even if minify.whitespace is true.
+   */
+  emitDCEAnnotations?: boolean;
+  // treeshaking?: boolean;
+
+  // jsx?:
+  //   | "automatic"
+  //   | "classic"
+  //   | /* later: "preserve" */ {
+  //       runtime?: "automatic" | "classic"; // later: "preserve"
+  //       /** Only works when runtime=classic */
+  //       factory?: string; // default: "React.createElement"
+  //       /** Only works when runtime=classic */
+  //       fragment?: string; // default: "React.Fragment"
+  //       /** Only works when runtime=automatic */
+  //       importSource?: string; // default: "react"
+  //     };
+
+  /**
+   * Generate bytecode for the output. This can dramatically improve cold
+   * start times, but will make the final output larger and slightly increase
+   * memory usage.
+   *
+   * Bytecode is currently only supported for CommonJS (`format: "cjs"`).
+   *
+   * Must be `target: "bun"`
+   * @default false
+   */
+  bytecode?: boolean;
 }
 
 interface BuildOutput {
@@ -1304,9 +1466,9 @@ interface BuildOutput {
 interface BuildArtifact extends Blob {
   path: string;
   loader: Loader;
-  hash?: string;
-  kind: "entry-point" | "chunk" | "asset" | "sourcemap";
-  sourcemap?: BuildArtifact;
+  hash: string | null;
+  kind: "entry-point" | "chunk" | "asset" | "sourcemap" | "bytecode";
+  sourcemap: BuildArtifact | null;
 }
 
 type Loader =
diff --git a/docs/bundler/vs-esbuild.md b/docs/bundler/vs-esbuild.md
index c89df8bdde..1266914c05 100644
--- a/docs/bundler/vs-esbuild.md
+++ b/docs/bundler/vs-esbuild.md
@@ -59,7 +59,7 @@ In Bun's CLI, simple boolean flags like `--minify` do not accept an argument. Ot
 
 - `--format`
 - `--format`
-- Bun only supports `"esm"` currently but other module formats are planned. esbuild defaults to `"iife"`.
+- Bun supports `"esm"` and `"cjs"` currently, but more module formats are planned. esbuild defaults to `"iife"`.
 
 ---
 
@@ -154,8 +154,14 @@ In Bun's CLI, simple boolean flags like `--minify` do not accept an argument. Ot
 ---
 
 - `--banner`
-- n/a
-- Not supported
+- `--banner`
+- Only applies to js bundles
+
+---
+
+- `--footer`
+- `--footer`
+- Only applies to js bundles
 
 ---
 
@@ -184,8 +190,7 @@ In Bun's CLI, simple boolean flags like `--minify` do not accept an argument. Ot
 ---
 
 - `--drop`
-- n/a
-- Not supported
+- `--drop`
 
 ---
 
@@ -195,12 +200,6 @@ In Bun's CLI, simple boolean flags like `--minify` do not accept an argument. Ot
 
 ---
 
-- `--footer`
-- n/a
-- Not supported
-
----
-
 - `--global-name`
 - n/a
 - Not applicable, Bun does not support `iife` output at this time
diff --git a/docs/cli/pm.md b/docs/cli/pm.md
index 4a5e0febcc..12c31c8de0 100644
--- a/docs/cli/pm.md
+++ b/docs/cli/pm.md
@@ -1,5 +1,22 @@
 The `bun pm` command group provides a set of utilities for working with Bun's package manager.
 
+## pack
+
+To create a tarball of the current workspace:
+
+```bash
+$ bun pm pack
+```
+
+Options for the `pack` command:
+
+- `--dry-run`: Perform all tasks except writing the tarball to disk.
+- `--destination`: Specify the directory where the tarball will be saved.
+- `--ignore-scripts`: Skip running pre/postpack and prepare scripts.
+- `--gzip-level`: Set a custom compression level for gzip, ranging from 0 to 9 (default is 9).
+
+## bin
+
 To print the path to the `bin` directory for the local project:
 
 ```bash
@@ -14,6 +31,8 @@ $ bun pm bin -g
 <$HOME>/.bun/bin
 ```
 
+## ls
+
 To print a list of installed dependencies in the current project and their resolved versions, excluding their dependencies.
 
 ```bash
@@ -45,6 +64,36 @@ $ bun pm ls --all
 ├── ...
 ```
 
+## whoami
+
+Print your npm username. Requires you to be logged in (`bunx npm login`) with credentials in either `bunfig.toml` or `.npmrc`:
+
+```bash
+$ bun pm whoami
+```
+
+## hash
+
+To generate and print the hash of the current lockfile:
+
+```bash
+$ bun pm hash
+```
+
+To print the string used to hash the lockfile:
+
+```bash
+$ bun pm hash-string
+```
+
+To print the hash stored in the current lockfile:
+
+```bash
+$ bun pm hash-print
+```
+
+## cache
+
 To print the path to Bun's global module cache:
 
 ```bash
@@ -57,16 +106,45 @@ To clear Bun's global module cache:
 $ bun pm cache rm
 ```
 
-## List global installs
+## migrate
 
-To list all globally installed packages:
+To migrate another package manager's lockfile without installing anything:
 
 ```bash
-$ bun pm ls -g
+$ bun pm migrate
 ```
 
-To list all globally installed packages, including nth-order dependencies:
+## untrusted
+
+To print current untrusted dependencies with scripts:
 
 ```bash
-$ bun pm ls -g --all
+$ bun pm untrusted
+
+./node_modules/@biomejs/biome @1.8.3
+ » [postinstall]: node scripts/postinstall.js
+
+These dependencies had their lifecycle scripts blocked during install.
 ```
+
+## trust
+
+To run scripts for untrusted dependencies and add to `trustedDependencies`:
+
+```bash
+$ bun pm trust <names>
+```
+
+Options for the `trust` command:
+
+- `--all`: Trust all untrusted dependencies.
+
+## default-trusted
+
+To print the default trusted dependencies list:
+
+```bash
+$ bun pm default-trusted
+```
+
+see the current list on GitHub [here](https://github.com/oven-sh/bun/blob/main/src/install/default-trusted-dependencies.txt)
diff --git a/docs/cli/publish.md b/docs/cli/publish.md
new file mode 100644
index 0000000000..7dec426593
--- /dev/null
+++ b/docs/cli/publish.md
@@ -0,0 +1,107 @@
+Use `bun publish` to publish a package to the npm registry.
+
+`bun publish` will automatically pack your package into a tarball, strip workspace protocols from the `package.json` (resolving versions if necessary), and publish to the registry specified in your configuration files. Both `bunfig.toml` and `.npmrc` files are supported.
+
+```sh
+## Publishing the package from the current working directory
+$ bun publish
+
+## Output
+bun publish v1.1.30 (ca7428e9)
+
+packed 203B package.json
+packed 224B README.md
+packed 30B index.ts
+packed 0.64KB tsconfig.json
+
+Total files: 4
+Shasum: 79e2b4377b63f4de38dc7ea6e5e9dbee08311a69
+Integrity: sha512-6QSNlDdSwyG/+[...]X6wXHriDWr6fA==
+Unpacked size: 1.1KB
+Packed size: 0.76KB
+Tag: latest
+Access: default
+Registry: http://localhost:4873/
+
+ + publish-1@1.0.0
+```
+
+Alternatively, you can pack and publish your package separately by using `bun pm pack` followed by `bun publish` with the path to the output tarball.
+
+```sh
+$ bun pm pack
+...
+$ bun publish ./package.tgz
+```
+
+{% callout %}
+**Note** - `bun publish` will not run lifecycle scripts (`prepublishOnly/prepack/prepare/postpack/publish/postpublish`) if a tarball path is provided. Scripts will only be run if the package is packed by `bun publish`.
+{% /callout %}
+
+### `--access`
+
+The `--access` flag can be used to set the access level of the package being published. The access level can be one of `public` or `restricted`. Unscoped packages are always public, and attempting to publish an unscoped package with `--access restricted` will result in an error.
+
+```sh
+$ bun publish --access public
+```
+
+`--access` can also be set in the `publishConfig` field of your `package.json`.
+
+```json
+{
+  "publishConfig": {
+    "access": "restricted"
+  }
+}
+```
+
+### `--tag`
+
+Set the tag of the package version being published. By default, the tag is `latest`. The initial version of a package is always given the `latest` tag in addition to the specified tag.
+
+```sh
+$ bun publish --tag alpha
+```
+
+`--tag` can also be set in the `publishConfig` field of your `package.json`.
+
+```json
+{
+  "publishConfig": {
+    "tag": "next"
+  }
+}
+```
+
+### `--dry-run`
+
+The `--dry-run` flag can be used to simulate the publish process without actually publishing the package. This is useful for verifying the contents of the published package without actually publishing the package.
+
+```sh
+$ bun publish --dry-run
+```
+
+### `--auth-type`
+
+If you have 2FA enabled for your npm account, `bun publish` will prompt you for a one-time password. This can be done through a browser or the CLI. The `--auth-type` flag can be used to tell the npm registry which method you prefer. The possible values are `web` and `legacy`, with `web` being the default.
+
+```sh
+$ bun publish --auth-type legacy
+...
+This operation requires a one-time password.
+Enter OTP: 123456
+...
+```
+
+### `--otp`
+
+Provide a one-time password directly to the CLI. If the password is valid, this will skip the extra prompt for a one-time password before publishing. Example usage:
+
+```sh
+$ bun publish --otp 123456
+```
+
+### `--gzip-level`
+
+Specify the level of gzip compression to use when packing the package. Only applies to `bun publish` without a tarball path argument. Values range from `0` to `9` (default is `9`).
diff --git a/docs/cli/test.md b/docs/cli/test.md
index 3a9ec639a5..e1b37f229b 100644
--- a/docs/cli/test.md
+++ b/docs/cli/test.md
@@ -55,6 +55,51 @@ $ 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: Checkout
+        uses: actions/checkout@v4
+      - name: Install bun
+        uses: oven-sh/setup-bun@v2
+      - 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`.
@@ -81,7 +126,7 @@ Use the `--bail` flag to abort the test run early after a pre-determined number
 $ bun test --bail
 
 # bail after 10 failure
-$ bun test --bail 10
+$ bun test --bail=10
 ```
 
 ## Watch mode
diff --git a/docs/upgrading-webkit.md b/docs/contributing/upgrading-webkit.md
similarity index 100%
rename from docs/upgrading-webkit.md
rename to docs/contributing/upgrading-webkit.md
diff --git a/docs/dev/bundev.md b/docs/dev/bundev.md
deleted file mode 100644
index baccf7658a..0000000000
--- 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 8eb8687150..0000000000
--- 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 53ebc6c066..0000000000
--- 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 d3e9c5a2b7..0000000000
--- 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/ecosystem/neon-drizzle.md b/docs/guides/ecosystem/neon-drizzle.md
index ceef365435..d17ac150e6 100644
--- a/docs/guides/ecosystem/neon-drizzle.md
+++ b/docs/guides/ecosystem/neon-drizzle.md
@@ -19,7 +19,7 @@ $ bun add -D drizzle-kit
 Create a `.env.local` file and add your [Neon Postgres connection string](https://neon.tech/docs/connect/connect-from-any-app) to it.
 
 ```sh
-DATBASE_URL=postgresql://username:password@ep-adj-noun-guid.us-east-1.aws.neon.tech/neondb?sslmode=require
+DATABASE_URL=postgresql://username:password@ep-adj-noun-guid.us-east-1.aws.neon.tech/neondb?sslmode=require
 ```
 
 ---
@@ -217,4 +217,4 @@ $ bun run index.ts
 
 This example used the Neon serverless driver's SQL-over-HTTP functionality. Neon's serverless driver also exposes `Client` and `Pool` constructors to enable sessions, interactive transactions, and node-postgres compatibility. Refer to [Neon's documentation](https://neon.tech/docs/serverless/serverless-driver) for a complete overview. 
 
-Refer to the [Drizzle website](https://orm.drizzle.team/docs/overview) for more documentation on using the Drizzle ORM.
\ No newline at end of file
+Refer to the [Drizzle website](https://orm.drizzle.team/docs/overview) for more documentation on using the Drizzle ORM.
diff --git a/docs/guides/ecosystem/nextjs.md b/docs/guides/ecosystem/nextjs.md
index d8bf337c27..c3147d703b 100644
--- a/docs/guides/ecosystem/nextjs.md
+++ b/docs/guides/ecosystem/nextjs.md
@@ -2,13 +2,7 @@
 name: Build an app with Next.js and Bun
 ---
 
-{% callout %}
-The Next.js [App Router](https://nextjs.org/docs/app) currently relies on Node.js APIs that Bun does not yet implement. The guide below uses Bun to initialize a project and install dependencies, but it uses Node.js to run the dev server.
-{% /callout %}
-
----
-
-Initialize a Next.js app with `create-next-app`. This automatically installs dependencies using `npm`.
+Initialize a Next.js app with `create-next-app`. This will scaffold a new Next.js project and automatically install dependencies.
 
 ```sh
 $ bun create next-app
diff --git a/docs/guides/ecosystem/pm2.md b/docs/guides/ecosystem/pm2.md
index c775c8ca32..87ed5c57f7 100644
--- a/docs/guides/ecosystem/pm2.md
+++ b/docs/guides/ecosystem/pm2.md
@@ -37,7 +37,10 @@ Alternatively, you can create a PM2 configuration file. Create a file named `pm2
 module.exports = {
   name: "app", // Name of your application
   script: "index.ts", // Entry point of your application
-  interpreter: "~/.bun/bin/bun", // Path to the Bun interpreter
+  interpreter: "bun", // Bun interpreter
+  env: {
+    PATH: `${process.env.HOME}/.bun/bin:${process.env.PATH}`, // Add "~/.bun/bin/bun" to PATH
+  }
 };
 ```
 
diff --git a/docs/guides/ecosystem/sveltekit.md b/docs/guides/ecosystem/sveltekit.md
index 6386673bc8..38824a5775 100644
--- a/docs/guides/ecosystem/sveltekit.md
+++ b/docs/guides/ecosystem/sveltekit.md
@@ -2,56 +2,62 @@
 name: Build an app with SvelteKit and Bun
 ---
 
-Use `bun create` to scaffold your app with the `svelte` package. Answer the prompts to select a template and set up your development environment.
+Use `sv create my-app` to create a SvelteKit project with SvelteKit CLI. Answer the prompts to select a template and set up your development environment.
 
 ```sh
-$ bun create svelte@latest my-app
-┌  Welcome to SvelteKit!
+$ bunx sv create my-app
+┌  Welcome to the Svelte CLI! (v0.5.7)
 │
-◇  Which Svelte app template?
-│  SvelteKit demo app
+◇  Which template would you like?
+│  SvelteKit demo
 │
-◇  Add type checking with TypeScript?
-│  Yes, using TypeScript syntax
+◇  Add type checking with Typescript?
+│  Yes, using Typescript syntax
 │
-◇  Select additional options (use arrow keys/space bar)
-│  None
+◆  Project created
 │
-└  Your project is ready!
-
-✔ Typescript
-  Inside Svelte components, use <script lang="ts">
-
-Install community-maintained integrations:
-  https://github.com/svelte-add/svelte-add
+◇  What would you like to add to your project?
+│  none
+│
+◇  Which package manager do you want to install dependencies with?
+│  bun
+│
+◇  Successfully installed dependencies
+│
+◇  Project next steps ─────────────────────────────────────────────────────╮
+│                                                                          │
+│  1: cd my-app                                                            │
+│  2: git init && git add -A && git commit -m "Initial commit" (optional)  │
+│  3: bun run dev -- --open                                                │
+│                                                                          │
+│  To close the dev server, hit Ctrl-C                                     │
+│                                                                          │
+│  Stuck? Visit us at https://svelte.dev/chat                              │
+│                                                                          │
+├──────────────────────────────────────────────────────────────────────────╯
+│
+└  You're all set!
 ```
 
 ---
 
-Once the project is initialized, `cd` into the new project and install dependencies.
-
-```sh
-$ cd my-app
-$ bun install
-```
-
----
+Once the project is initialized, `cd` into the new project. You don't need to run 'bun install' since the dependencies are already installed.
 
 Then start the development server with `bun --bun run dev`.
 
 To run the dev server with Node.js instead of Bun, you can omit the `--bun` flag.
 
 ```sh
+$ cd my-app
 $ bun --bun run dev
   $ vite dev
-
   Forced re-optimization of dependencies
-
-    VITE v4.4.9  ready in 895 ms
-
+  
+    VITE v5.4.10  ready in 424 ms
+  
     ➜  Local:   http://localhost:5173/
     ➜  Network: use --host to expose
-    ➜  press h to show help
+    ➜  press h + enter to show help
 ```
 
 ---
@@ -75,16 +81,22 @@ Now, make the following changes to your `svelte.config.js`.
 ```ts-diff
 - import adapter from "@sveltejs/adapter-auto";
 + import adapter from "svelte-adapter-bun";
-  import { vitePreprocess } from "@sveltejs/kit/vite";
+  import { vitePreprocess } from '@sveltejs/vite-plugin-svelte';
 
   /** @type {import('@sveltejs/kit').Config} */
   const config = {
-    kit: {
-      adapter: adapter(),
-    },
-    preprocess: vitePreprocess(),
+  	// Consult https://svelte.dev/docs/kit/integrations#preprocessors
+  	// for more information about preprocessors
+  	preprocess: vitePreprocess(),
+  
+  	kit: {
+  		// adapter-auto only supports some environments, see https://svelte.dev/docs/kit/adapter-auto for a list.
+  		// If your environment is not supported, or you settled on a specific environment, switch out the adapter.
+  		// See https://svelte.dev/docs/kit/adapters for more information about adapters.
+  		adapter: adapter()
+  	}
   };
-
+  
   export default config;
 ```
 
@@ -93,28 +105,21 @@ Now, make the following changes to your `svelte.config.js`.
 To build a production bundle:
 
 ```sh
-$ bun run build
- $ vite build
-
-vite v4.4.9 building SSR bundle for production...
-transforming (60) node_modules/@sveltejs/kit/src/utils/escape.js
-
-✓ 98 modules transformed.
-Generated an empty chunk: "entries/endpoints/waitlist/_server.ts".
-
-vite v4.4.9 building for production...
-✓ 92 modules transformed.
-Generated an empty chunk: "7".
-.svelte-kit/output/client/_app/version.json      0.03 kB │ gzip:  0.05 kB
-
-...
-
-.svelte-kit/output/server/index.js               86.47 kB
-
-Run npm run preview to preview your production build locally.
-
-> Using svelte-adapter-bun
-  ✔ Start server with: bun ./build/index.js
-  ✔ done
-✓ built in 7.81s
+$ bun --bun run build
+  $ vite build
+  vite v5.4.10 building SSR bundle for production...
+  "confetti" is imported from external module "@neoconfetti/svelte" but never used in "src/routes/sverdle/+page.svelte".
+  ✓ 130 modules transformed.
+  vite v5.4.10 building for production...
+  ✓ 148 modules transformed.
+  ...
+  ✓ built in 231ms
+  ...
+  ✓ built in 899ms
+  
+  Run npm run preview to preview your production build locally.
+  
+  > Using svelte-adapter-bun
+    ✔ Start server with: bun ./build/index.js
+    ✔ done
 ```
diff --git a/docs/guides/http/cluster.md b/docs/guides/http/cluster.md
index 7d5e8b992d..c434337d79 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/install/trusted.md b/docs/guides/install/trusted.md
index acd27a47a6..75c6cfbd22 100644
--- a/docs/guides/install/trusted.md
+++ b/docs/guides/install/trusted.md
@@ -17,7 +17,7 @@ If you are seeing one of the following errors, you are probably trying to use a
 
 ---
 
-To tell Bun to allow lifecycle scripts for a particular package, add the package to `trustedDependencies` in your package.json.
+To allow Bun to execute lifecycle scripts for a specific package, add the package to `trustedDependencies` in your package.json file. You can do this automatically by running the command `bun pm trust <pkg>`.
 
 {% callout %}
 Note that this only allows lifecycle scripts for the specific package listed in `trustedDependencies`, _not_ the dependencies of that dependency!
diff --git a/docs/guides/runtime/import-json.md b/docs/guides/runtime/import-json.md
index 57e3a1b580..5791e32ae3 100644
--- a/docs/guides/runtime/import-json.md
+++ b/docs/guides/runtime/import-json.md
@@ -27,16 +27,6 @@ data.version; // => "1.0.0"
 data.author.name; // => "John Dough"
 ```
 
-Bun also supports [Import Attributes](https://github.com/tc39/proposal-import-attributes/) and [JSON modules](https://github.com/tc39/proposal-json-modules) syntax.
-
-```ts
-import data from "./package.json" with { type: "json" };
-
-data.name; // => "bun"
-data.version; // => "1.0.0"
-data.author.name; // => "John Dough"
-```
-
 ---
 
 Bun also supports [Import Attributes](https://github.com/tc39/proposal-import-attributes/) and [JSON modules](https://github.com/tc39/proposal-json-modules) syntax.
diff --git a/docs/guides/runtime/set-env.md b/docs/guides/runtime/set-env.md
index 92cd5e27ec..c336a2c7a5 100644
--- a/docs/guides/runtime/set-env.md
+++ b/docs/guides/runtime/set-env.md
@@ -16,7 +16,7 @@ Set these variables in a `.env` file.
 Bun reads the following files automatically (listed in order of increasing precedence).
 
 - `.env`
-- `.env.production` or `.env.development` (depending on value of `NODE_ENV`)
+- `.env.production`, `.env.development`, `.env.test` (depending on value of `NODE_ENV`)
 - `.env.local`
 
 ```txt#.env
diff --git a/docs/guides/test/bail.md b/docs/guides/test/bail.md
index de50745ac1..8b657c5739 100644
--- a/docs/guides/test/bail.md
+++ b/docs/guides/test/bail.md
@@ -14,7 +14,7 @@ To bail after a certain threshold of failures, optionally specify a number after
 
 ```sh
 # bail after 10 failures
-$ bun test --bail 10
+$ bun test --bail=10
 ```
 
 ---
diff --git a/docs/guides/test/migrate-from-jest.md b/docs/guides/test/migrate-from-jest.md
index 3ee6eccb4b..9cf250d603 100644
--- a/docs/guides/test/migrate-from-jest.md
+++ b/docs/guides/test/migrate-from-jest.md
@@ -30,7 +30,6 @@ Bun implements the vast majority of Jest's matchers, but compatibility isn't 100
 
 Some notable missing features:
 
-- `expect().toMatchInlineSnapshot()`
 - `expect().toHaveReturned()`
 
 ---
@@ -57,7 +56,7 @@ Replace `bail` in your Jest config with the `--bail` CLI flag.
 ``` -->
 
 ```sh
-$ bun test --bail 3
+$ bun test --bail=3
 ```
 
 ---
diff --git a/docs/guides/test/snapshot.md b/docs/guides/test/snapshot.md
index 7c4867709f..f30feb0492 100644
--- a/docs/guides/test/snapshot.md
+++ b/docs/guides/test/snapshot.md
@@ -4,10 +4,6 @@ name: Use snapshot testing in `bun test`
 
 Bun's test runner supports Jest-style snapshot testing via `.toMatchSnapshot()`.
 
-{% callout %}
-The `.toMatchInlineSnapshot()` method is not yet supported.
-{% /callout %}
-
 ```ts#snap.test.ts
 import { test, expect } from "bun:test";
 
@@ -96,4 +92,4 @@ Ran 1 tests across 1 files. [102.00ms]
 
 ---
 
-See [Docs > Test Runner > Snapshots](https://bun.sh/docs/test/mocks) for complete documentation on mocking with the Bun test runner.
+See [Docs > Test Runner > Snapshots](https://bun.sh/docs/test/snapshots) for complete documentation on snapshots with the Bun test runner.
diff --git a/docs/guides/test/todo-tests.md b/docs/guides/test/todo-tests.md
index 577843206c..da9bd9e70c 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/guides/test/update-snapshots.md b/docs/guides/test/update-snapshots.md
index 3d9ba078eb..24f76440a8 100644
--- a/docs/guides/test/update-snapshots.md
+++ b/docs/guides/test/update-snapshots.md
@@ -4,10 +4,6 @@ name: Update snapshots in `bun test`
 
 Bun's test runner supports Jest-style snapshot testing via `.toMatchSnapshot()`.
 
-{% callout %}
-The `.toMatchInlineSnapshot()` method is not yet supported.
-{% /callout %}
-
 ```ts#snap.test.ts
 import { test, expect } from "bun:test";
 
@@ -47,4 +43,4 @@ Ran 1 tests across 1 files. [102.00ms]
 
 ---
 
-See [Docs > Test Runner > Snapshots](https://bun.sh/docs/test/mocks) for complete documentation on mocking with the Bun test runner.
+See [Docs > Test Runner > Snapshots](https://bun.sh/docs/test/snapshots) for complete documentation on snapshots with the Bun test runner.
diff --git a/docs/install/lockfile.md b/docs/install/lockfile.md
index f8e3001ca6..66fb28e2b2 100644
--- a/docs/install/lockfile.md
+++ b/docs/install/lockfile.md
@@ -16,7 +16,7 @@ Add the following to your local or global `.gitattributes` file:
 *.lockb binary diff=lockb
 ```
 
-Then add the following to you local git config with:
+Then add the following to your local git config with:
 
 ```sh
 $ git config diff.lockb.textconv bun
diff --git a/docs/install/npmrc.md b/docs/install/npmrc.md
index 6bccdaf4ce..ae3c074892 100644
--- a/docs/install/npmrc.md
+++ b/docs/install/npmrc.md
@@ -39,7 +39,7 @@ The equivalent `bunfig.toml` option is to add a key in [`install.scopes`](https:
 myorg = "http://localhost:4873/"
 ```
 
-### `//<registry_url>/:<key>=<value>`: Confgure options for a specific registry
+### `//<registry_url>/:<key>=<value>`: Configure options for a specific registry
 
 Allows you to set options for a specific registry:
 
diff --git a/docs/install/workspaces.md b/docs/install/workspaces.md
index dc3219679c..64d2445132 100644
--- a/docs/install/workspaces.md
+++ b/docs/install/workspaces.md
@@ -41,7 +41,7 @@ In the root `package.json`, the `"workspaces"` key is used to indicate which sub
 **Glob support** — Bun supports full glob syntax in `"workspaces"` (see [here](https://bun.sh/docs/api/glob#supported-glob-patterns) for a comprehensive list of supported syntax), _except_ for exclusions (e.g. `!**/excluded/**`), which are not implemented yet.
 {% /callout %}
 
-Each workspace has it's own `package.json` When referencing other packages in the monorepo, use `"workspace:*"` as the version field in your `package.json`.
+Each workspace has it's own `package.json`. When referencing other packages in the monorepo, semver or workspace protocols (e.g. `workspace:*`) can be used as the version field in your `package.json`.
 
 ```json
 {
@@ -53,10 +53,6 @@ Each workspace has it's own `package.json` When referencing other packages in th
 }
 ```
 
-{% callout %}
-**Version support** — Bun supports simple `workspace:*` versions in `"dependencies"`. Full version syntax (e.g. `workspace:^*`) is not yet supported.
-{% /callout %}
-
 Workspaces have a couple major benefits.
 
 - **Code can be split into logical parts.** If one package relies on another, you can simply add it as a dependency in `package.json`. If package `b` depends on `a`, `bun install` will install your local `packages/a` directory into `node_modules` instead of downloading it from the npm registry.
diff --git a/docs/installation.md b/docs/installation.md
index ea1fa14b44..f98e3bbfa1 100644
--- a/docs/installation.md
+++ b/docs/installation.md
@@ -72,8 +72,8 @@ There are also image variants for different operating systems.
 ```bash
 $ docker pull oven/bun:debian
 $ docker pull oven/bun:slim
-$ docker pull oven/bun:alpine
 $ docker pull oven/bun:distroless
+$ docker pull oven/bun:alpine
 ```
 
 ## Checking installation
@@ -189,14 +189,19 @@ For convenience, here are download links for the latest version:
 
 - [`bun-linux-x64.zip`](https://github.com/oven-sh/bun/releases/latest/download/bun-linux-x64.zip)
 - [`bun-linux-x64-baseline.zip`](https://github.com/oven-sh/bun/releases/latest/download/bun-linux-x64-baseline.zip)
+- [`bun-linux-x64-musl.zip`](https://github.com/oven-sh/bun/releases/latest/download/bun-linux-x64-musl.zip)
+- [`bun-linux-x64-musl-baseline.zip`](https://github.com/oven-sh/bun/releases/latest/download/bun-linux-x64-musl-baseline.zip)
 - [`bun-windows-x64.zip`](https://github.com/oven-sh/bun/releases/latest/download/bun-windows-x64.zip)
 - [`bun-windows-x64-baseline.zip`](https://github.com/oven-sh/bun/releases/latest/download/bun-windows-x64-baseline.zip)
 - [`bun-darwin-aarch64.zip`](https://github.com/oven-sh/bun/releases/latest/download/bun-darwin-aarch64.zip)
 - [`bun-linux-aarch64.zip`](https://github.com/oven-sh/bun/releases/latest/download/bun-linux-aarch64.zip)
+- [`bun-linux-aarch64-musl.zip`](https://github.com/oven-sh/bun/releases/latest/download/bun-linux-aarch64-musl.zip)
 - [`bun-darwin-x64.zip`](https://github.com/oven-sh/bun/releases/latest/download/bun-darwin-x64.zip)
 - [`bun-darwin-x64-baseline.zip`](https://github.com/oven-sh/bun/releases/latest/download/bun-darwin-x64-baseline.zip)
 
-The `baseline` binaries are built for older CPUs which may not support AVX2 instructions. If you run into an "Illegal Instruction" error when running Bun, try using the `baseline` binaries instead. Bun's install scripts automatically choose the correct binary for your system which helps avoid this issue. Baseline builds are slower than regular builds, so use them only if necessary.
+The `musl` binaries are built for distributions that do not ship with the glibc libraries by default, instead relying on musl. The two most popular distros are Void Linux and Alpine Linux, with the latter is used heavily in Docker containers. If you encounter an error like the following: `bun: /lib/x86_64-linux-gnu/libm.so.6: version GLIBC_2.29' not found (required by bun)`, try using the musl binary. Bun's install script automatically chooses the correct binary for your system.
+
+The `baseline` binaries are built for older CPUs which may not support AVX2 instructions. If you run into an "Illegal Instruction" error when running Bun, try using the `baseline` binaries instead. Bun's install scripts automatically chooses the correct binary for your system which helps avoid this issue. Baseline builds are slower than regular builds, so use them only if necessary.
 
 <!--
 ## Native
diff --git a/docs/nav.ts b/docs/nav.ts
index 2b9202b556..c4f04ca7c2 100644
--- a/docs/nav.ts
+++ b/docs/nav.ts
@@ -164,6 +164,9 @@ export default {
     page("cli/update", "`bun update`", {
       description: "Update your project's dependencies.",
     }),
+    page("cli/publish", "`bun publish`", {
+      description: "Publish your package to an npm registry.",
+    }),
     page("cli/outdated", "`bun outdated`", {
       description: "Check for outdated dependencies.",
     }),
@@ -374,6 +377,10 @@ export default {
       description: `Bun's native Semver implementation is 20x faster than the popular \`node-semver\` package.`,
     }), // "`Semver`"),
 
+    page("api/color", "Color", {
+      description: `Bun's color function leverages Bun's CSS parser for parsing, normalizing, and converting colors from user input to a variety of output formats.`,
+    }), // "`Color`"),
+
     // divider("Dev Server"),
     // page("bun-dev", "Vanilla"),
     // page("dev/css", "CSS"),
diff --git a/docs/project/building-windows.md b/docs/project/building-windows.md
index 041207c9ff..8831bd5c44 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 %}
 
+{% 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 %}
+
 If you intend on building WebKit locally (optional), you should install these packages:
 
-{% codetabs group="a" %}
-
-```ps1#WinGet
-> winget install ezwinports.make Cygwin.Cygwin Python.Python.3.12
-```
-
 ```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 65ef33ead8..0000000000
--- a/docs/rfcs/README.md
+++ /dev/null
@@ -1,4 +0,0 @@
-# RFCs
-
-| Number | Name | Issue |
-| ------ | ---- | ----- |
diff --git a/docs/runtime/bunfig.md b/docs/runtime/bunfig.md
index 4af5187445..1bfcd540e5 100644
--- a/docs/runtime/bunfig.md
+++ b/docs/runtime/bunfig.md
@@ -370,6 +370,19 @@ myorg = { username = "myusername", password = "$npm_password", url = "https://re
 myorg = { token = "$npm_token", url = "https://registry.myorg.com/" }
 ```
 
+### `install.ca` and `install.cafile`
+
+To configure a CA certificate, use `install.ca` or `install.cafile` to specify a path to a CA certificate file.
+
+```toml
+[install]
+# The CA certificate as a string
+ca = "-----BEGIN CERTIFICATE-----\n...\n-----END CERTIFICATE-----"
+
+# A path to a CA certificate file. The file can contain multiple certificates.
+cafile = "path/to/cafile"
+```
+
 ### `install.cache`
 
 To configure the cache behavior:
diff --git a/docs/runtime/modules.md b/docs/runtime/modules.md
index 2d50ac6cdd..526446751e 100644
--- a/docs/runtime/modules.md
+++ b/docs/runtime/modules.md
@@ -238,6 +238,30 @@ If `exports` is not defined, Bun falls back to `"module"` (ESM imports only) the
 }
 ```
 
+### Custom conditions
+
+The `--conditions` flag allows you to specify a list of conditions to use when resolving packages from package.json `"exports"`.
+
+This flag is supported in both `bun build` and Bun's runtime.
+
+```sh
+# Use it with bun build:
+$ bun build --conditions="react-server" --target=bun ./app/foo/route.js
+
+# Use it with bun's runtime:
+$ bun --conditions="react-server" ./app/foo/route.js
+```
+
+You can also use `conditions` programmatically with `Bun.build`:
+
+```js
+await Bun.build({
+  conditions: ["react-server"],
+  target: "bun",
+  entryPoints: ["./app/foo/route.js"],
+});
+```
+
 ## Path re-mapping
 
 In the spirit of treating TypeScript as a first-class citizen, the Bun runtime will re-map import paths according to the [`compilerOptions.paths`](https://www.typescriptlang.org/tsconfig#paths) field in `tsconfig.json`. This is a major divergence from Node.js, which doesn't support any form of import path re-mapping.
diff --git a/docs/runtime/nodejs-apis.md b/docs/runtime/nodejs-apis.md
index 86e1bbf209..f51b4c4553 100644
--- a/docs/runtime/nodejs-apis.md
+++ b/docs/runtime/nodejs-apis.md
@@ -65,7 +65,7 @@ Some methods are not optimized yet.
 
 ### [`node:http2`](https://nodejs.org/api/http2.html)
 
-🟡 Client is supported, but server isn't yet.
+🟡 Client & server are implemented (95.25% of gRPC's test suite passes). Missing `options.allowHTTP1`, `options.enableConnectProtocol`, ALTSVC extension, and `http2stream.pushStream`.
 
 ### [`node:https`](https://nodejs.org/api/https.html)
 
diff --git a/docs/runtime/plugins.md b/docs/runtime/plugins.md
index 5fd38c3694..129d129936 100644
--- a/docs/runtime/plugins.md
+++ b/docs/runtime/plugins.md
@@ -302,7 +302,7 @@ require("my-object-virtual-module"); // { baz: "quix" }
 await import("my-object-virtual-module"); // { baz: "quix" }
 ```
 
-## Reading the config
+## Reading or modifying the config
 
 Plugins can read and write to the [build config](https://bun.sh/docs/bundler#api) with `build.config`.
 
@@ -327,7 +327,45 @@ Bun.build({
 });
 ```
 
-## Reference
+{% callout %}
+
+**NOTE**: Plugin lifcycle callbacks (`onStart()`, `onResolve()`, etc.) do not have the ability to modify the `build.config` object in the `setup()` function. If you want to mutate `build.config`, you must do so directly in the `setup()` function:
+
+```ts
+Bun.build({
+  entrypoints: ["./app.ts"],
+  outdir: "./dist",
+  sourcemap: "external",
+  plugins: [
+    {
+      name: "demo",
+      setup(build) {
+        // ✅ good! modifying it directly in the setup() function
+        build.config.minify = true;
+
+        build.onStart(() => {
+          // 🚫 uh-oh! this won't work!
+          build.config.minify = false;
+        });
+      },
+    },
+  ],
+});
+```
+
+{% /callout %}
+
+## Lifecycle hooks
+
+Plugins can register callbacks to be run at various points in the lifecycle of a bundle:
+
+- [`onStart()`](#onstart): Run once the bundler has started a bundle
+- [`onResolve()`](#onresolve): Run before a module is resolved
+- [`onLoad()`](#onload): Run before a module is loaded.
+
+### Reference
+
+A rough overview of the types (please refer to Bun's `bun.d.ts` for the full type definitions):
 
 ```ts
 namespace Bun {
@@ -338,6 +376,7 @@ namespace Bun {
 }
 
 type PluginBuilder = {
+  onStart(callback: () => void): void;
   onResolve: (
     args: { filter: RegExp; namespace?: string },
     callback: (args: { path: string; importer: string }) => {
@@ -356,7 +395,308 @@ type PluginBuilder = {
   config: BuildConfig;
 };
 
-type Loader = "js" | "jsx" | "ts" | "tsx" | "json" | "toml" | "object";
+type Loader = "js" | "jsx" | "ts" | "tsx" | "css" | "json" | "toml" | "object";
 ```
 
-The `onLoad` method optionally accepts a `namespace` in addition to the `filter` regex. This namespace will be be used to prefix the import in transpiled code; for instance, a loader with a `filter: /\.yaml$/` and `namespace: "yaml:"` will transform an import from `./myfile.yaml` into `yaml:./myfile.yaml`.
+### Namespaces
+
+`onLoad` and `onResolve` accept an optional `namespace` string. What is a namespaace?
+
+Every module has a namespace. Namespaces are used to prefix the import in transpiled code; for instance, a loader with a `filter: /\.yaml$/` and `namespace: "yaml:"` will transform an import from `./myfile.yaml` into `yaml:./myfile.yaml`.
+
+The default namespace is `"file"` and it is not necessary to specify it, for instance: `import myModule from "./my-module.ts"` is the same as `import myModule from "file:./my-module.ts"`.
+
+Other common namespaces are:
+
+- `"bun"`: for Bun-specific modules (e.g. `"bun:test"`, `"bun:sqlite"`)
+- `"node"`: for Node.js modules (e.g. `"node:fs"`, `"node:path"`)
+
+### `onStart`
+
+```ts
+onStart(callback: () => void): Promise<void> | void;
+```
+
+Registers a callback to be run when the bundler starts a new bundle.
+
+```ts
+import { plugin } from "bun";
+
+plugin({
+  name: "onStart example",
+
+  setup(build) {
+    build.onStart(() => {
+      console.log("Bundle started!");
+    });
+  },
+});
+```
+
+The callback can return a `Promise`. After the bundle process has initialized, the bundler waits until all `onStart()` callbacks have completed before continuing.
+
+For example:
+
+```ts
+const result = await Bun.build({
+  entrypoints: ["./app.ts"],
+  outdir: "./dist",
+  sourcemap: "external",
+  plugins: [
+    {
+      name: "Sleep for 10 seconds",
+      setup(build) {
+        build.onStart(async () => {
+          await Bunlog.sleep(10_000);
+        });
+      },
+    },
+    {
+      name: "Log bundle time to a file",
+      setup(build) {
+        build.onStart(async () => {
+          const now = Date.now();
+          await Bun.$`echo ${now} > bundle-time.txt`;
+        });
+      },
+    },
+  ],
+});
+```
+
+In the above example, Bun will wait until the first `onStart()` (sleeping for 10 seconds) has completed, _as well as_ the second `onStart()` (writing the bundle time to a file).
+
+Note that `onStart()` callbacks (like every other lifecycle callback) do not have the ability to modify the `build.config` object. If you want to mutate `build.config`, you must do so directly in the `setup()` function.
+
+### `onResolve`
+
+```ts
+onResolve(
+  args: { filter: RegExp; namespace?: string },
+  callback: (args: { path: string; importer: string }) => {
+    path: string;
+    namespace?: string;
+  } | void,
+): void;
+```
+
+To bundle your project, Bun walks down the dependency tree of all modules in your project. For each imported module, Bun actually has to find and read that module. The "finding" part is known as "resolving" a module.
+
+The `onResolve()` plugin lifecycle callback allows you to configure how a module is resolved.
+
+The first argument to `onResolve()` is an object with a `filter` and [`namespace`](#what-is-a-namespace) property. The filter is a regular expression which is run on the import string. Effectively, these allow you to filter which modules your custom resolution logic will apply to.
+
+The second argument to `onResolve()` is a callback which is run for each module import Bun finds that matches the `filter` and `namespace` defined in the first argument.
+
+The callback receives as input the _path_ to the matching module. The callback can return a _new path_ for the module. Bun will read the contents of the _new path_ and parse it as a module.
+
+For example, redirecting all imports to `images/` to `./public/images/`:
+
+```ts
+import { plugin } from "bun";
+
+plugin({
+  name: "onResolve example",
+  setup(build) {
+    build.onResolve({ filter: /.*/, namespace: "file" }, args => {
+      if (args.path.startsWith("images/")) {
+        return {
+          path: args.path.replace("images/", "./public/images/"),
+        };
+      }
+    });
+  },
+});
+```
+
+### `onLoad`
+
+```ts
+onLoad(
+  args: { filter: RegExp; namespace?: string },
+  callback: (args: { path: string, importer: string, namespace: string, kind: ImportKind  }) => {
+    loader?: Loader;
+    contents?: string;
+    exports?: Record<string, any>;
+  },
+): void;
+```
+
+After Bun's bundler has resolved a module, it needs to read the contents of the module and parse it.
+
+The `onLoad()` plugin lifecycle callback allows you to modify the _contents_ of a module before it is read and parsed by Bun.
+
+Like `onResolve()`, the first argument to `onLoad()` allows you to filter which modules this invocation of `onLoad()` will apply to.
+
+The second argument to `onLoad()` is a callback which is run for each matching module _before_ Bun loads the contents of the module into memory.
+
+This callback receives as input the _path_ to the matching module, the _importer_ of the module (the module that imported the module), the _namespace_ of the module, and the _kind_ of the module.
+
+The callback can return a new `contents` string for the module as well as a new `loader`.
+
+For example:
+
+```ts
+import { plugin } from "bun";
+
+plugin({
+  name: "env plugin",
+  setup(build) {
+    build.onLoad({ filter: /env/, namespace: "file" }, args => {
+      return {
+        contents: `export default ${JSON.stringify(process.env)}`,
+        loader: "js",
+      };
+    });
+  },
+});
+```
+
+This plugin will transform all imports of the form `import env from "env"` into a JavaScript module that exports the current environment variables.
+
+#### `.defer()`
+
+One of the arguments passed to the `onLoad` callback is a `defer` function. This function returns a `Promise` that is resolved when all _other_ modules have been loaded.
+
+This allows you to delay execution of the `onLoad` callback until all other modules have been loaded.
+
+This is useful for returning contens of a module that depends on other modules.
+
+##### Example: tracking and reporting unused exports
+
+```ts
+import { plugin } from "bun";
+
+plugin({
+  name: "track imports",
+  setup(build) {
+    const transpiler = new Bun.Transpiler();
+
+    let trackedImports: Record<string, number> = {};
+
+    // Each module that goes through this onLoad callback
+    // will record its imports in `trackedImports`
+    build.onLoad({ filter: /\.ts/ }, async ({ path }) => {
+      const contents = await Bun.file(path).arrayBuffer();
+
+      const imports = transpiler.scanImports(contents);
+
+      for (const i of imports) {
+        trackedImports[i.path] = (trackedImports[i.path] || 0) + 1;
+      }
+
+      return undefined;
+    });
+
+    build.onLoad({ filter: /stats\.json/ }, async ({ defer }) => {
+      // Wait for all files to be loaded, ensuring
+      // that every file goes through the above `onLoad()` function
+      // and their imports tracked
+      await defer();
+
+      // Emit JSON containing the stats of each import
+      return {
+        contents: `export default ${JSON.stringify(trackedImports)}`,
+        loader: "json",
+      };
+    });
+  },
+});
+```
+
+Note that the `.defer()` function currently has the limitation that it can only be called once per `onLoad` callback.
+
+## Native plugins
+
+{% callout %}
+**NOTE** — This is an advanced and experiemental API recommended for plugin developers who are familiar with systems programming and the C ABI. Use with caution.
+{% /callout %}
+
+One of the reasons why Bun's bundler is so fast is that it is written in native code and leverages multi-threading to load and parse modules in parallel.
+
+However, one limitation of plugins written in JavaScript is that JavaScript itself is single-threaded.
+
+Native plugins are written as [NAPI](/docs/node-api) modules and can be run on multiple threads. This allows native plugins to run much faster than JavaScript plugins.
+
+In addition, native plugins can skip unnecessary work such as the UTF-8 -> UTF-16 conversion needed to pass strings to JavaScript.
+
+These are the following lifecycle hooks which are available to native plugins:
+
+- [`onBeforeParse()`](#onbeforeparse): Called on any thread before a file is parsed by Bun's bundler.
+
+### Creating a native plugin
+
+Native plugins are NAPI modules which expose lifecycle hooks as C ABI functions.
+
+To create a native plugin, you must export a C ABI function which matches the signature of the native lifecycle hook you want to implement.
+
+#### Example: Rust with napi-rs
+
+First initialize a napi project (see [here](https://napi.rs/docs/introduction/getting-started) for a more comprehensive guide).
+
+Then install Bun's official safe plugin wrapper crate:
+
+```bash
+cargo add bun-native-plugin
+```
+
+Now you can export an `extern "C" fn` which is the implementation of your plugin:
+
+```rust
+#[no_mangle]
+extern "C" fn on_before_parse_impl(
+  args: *const bun_native_plugin::sys::OnBeforeParseArguments,
+  result: *mut bun_native_plugin::sys::OnBeforeParseResult,
+) {
+  let args = unsafe { &*args };
+  let result = unsafe { &mut *result };
+
+  let mut handle = match bun_native_plugin::OnBeforeParse::from_raw(args, result) {
+    Ok(handle) => handle,
+    Err(_) => {
+      return;
+    }
+  };
+
+  let source_code = match handle.input_source_code() {
+    Ok(source_code) => source_code,
+    Err(_) => {
+      handle.log_error("Fetching source code failed!");
+      return;
+    }
+  };
+
+  let loader = handle.output_loader();
+  handle.set_output_source_code(source_code.replace("foo", "bar"), loader);
+```
+
+Use napi-rs to compile the plugin to a `.node` file, then you can `require()` it from JS and use it:
+
+```js
+await Bun.build({
+  entrypoints: ["index.ts"],
+  setup(build) {
+    const myNativePlugin = require("./path/to/plugin.node");
+
+    build.onBeforeParse(
+      { filter: /\.ts/ },
+      { napiModule: myNativePlugin, symbol: "on_before_parse_impl" },
+    );
+  },
+});
+```
+
+### `onBeforeParse`
+
+```ts
+onBeforeParse(
+  args: { filter: RegExp; namespace?: string },
+  callback: { napiModule: NapiModule; symbol: string; external?: unknown },
+): void;
+```
+
+This lifecycle callback is run immediately before a file is parsed by Bun's bundler.
+
+As input, it receives the file's contents and can optionally return new source code.
+
+This callback can be called from any thread and so the napi module implementation must be thread-safe.
diff --git a/docs/test/writing.md b/docs/test/writing.md
index e37950cd47..e56c234b10 100644
--- a/docs/test/writing.md
+++ b/docs/test/writing.md
@@ -76,6 +76,12 @@ test("wat", async () => {
 }, 500); // test must run in <500ms
 ```
 
+In `bun:test`, test timeouts throw an uncatchable exception to force the test to stop running and fail. We also kill any child processes that were spawned in the test to avoid leaving behind zombie processes lurking in the background.
+
+### 🧟 Zombie process killer
+
+When a test times out and processes spawned in the test via `Bun.spawn`, `Bun.spawnSync`, or `node:child_process` are not killed, they will be automatically killed and a message will be logged to the console.
+
 ## `test.skip`
 
 Skip individual tests with `test.skip`. These tests will not be run.
@@ -91,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";
@@ -101,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.
@@ -324,6 +340,7 @@ Bun implements the following matchers. Full Jest compatibility is on the roadmap
 - [`.toContainAllValues()`](https://jest-extended.jestcommunity.dev/docs/matchers/Object#tocontainallvaluesvalues)
 
 ---
+
 - ✅
 - [`.toContainAnyValues()`](https://jest-extended.jestcommunity.dev/docs/matchers/Object#tocontainanyvaluesvalues)
 
@@ -514,7 +531,7 @@ Bun implements the following matchers. Full Jest compatibility is on the roadmap
 
 ---
 
-- ❌
+- ✅
 - [`.toMatchInlineSnapshot()`](https://jestjs.io/docs/expect#tomatchinlinesnapshotpropertymatchers-inlinesnapshot)
 
 ---
diff --git a/docs/troubleshooting.md b/docs/troubleshooting.md
deleted file mode 100644
index 07303bff33..0000000000
--- a/docs/troubleshooting.md
+++ /dev/null
@@ -1,67 +0,0 @@
-## Troubleshooting
-
-### Bun not running on an M1 (or Apple Silicon)
-
-If you see a message like this
-
-> [1] 28447 killed bun create next ./test
-
-It most likely means you’re running Bun’s x64 version on Apple Silicon. This happens if Bun is running via Rosetta. Rosetta is unable to emulate AVX2 instructions, which Bun indirectly uses.
-
-The fix is to ensure you installed a version of Bun built for Apple Silicon.
-
-### error: Unexpected
-
-If you see an error like this:
-
-![image](https://user-images.githubusercontent.com/709451/141210854-89434678-d21b-42f4-b65a-7df3b785f7b9.png)
-
-It usually means the max number of open file descriptors is being explicitly set to a low number. By default, Bun requests the max number of file descriptors available (which on macOS, is something like 32,000). But, if you previously ran into ulimit issues with, e.g., Chokidar, someone on The Internet may have advised you to run `ulimit -n 8192`.
-
-That advice unfortunately **lowers** the hard limit to `8192`. This can be a problem in large repositories or projects with lots of dependencies. Chokidar (and other watchers) don’t seem to call `setrlimit`, which means they’re reliant on the (much lower) soft limit.
-
-To fix this issue:
-
-1. Remove any scripts that call `ulimit -n` and restart your shell.
-2. Try again, and if the error still occurs, try setting `ulimit -n` to an absurdly high number, such as `ulimit -n 2147483646`
-3. Try again, and if that still doesn’t fix it, open an issue
-
-### Unzip is required
-
-Unzip is required to install Bun on Linux. You can use one of the following commands to install `unzip`:
-
-#### Debian / Ubuntu / Mint
-
-```sh
-$ sudo apt install unzip
-```
-
-#### RedHat / CentOS / Fedora
-
-```sh
-$ sudo dnf install unzip
-```
-
-#### Arch / Manjaro
-
-```sh
-$ sudo pacman -S unzip
-```
-
-#### OpenSUSE
-
-```sh
-$ sudo zypper install unzip
-```
-
-### bun install is stuck
-
-Please run `bun install --verbose 2> logs.txt` and send them to me in Bun's discord. If you're on Linux, it would also be helpful if you run `sudo perf trace bun install --silent` and attach the logs.
-
-### Uninstalling
-
-Bun's binary and install cache is located in `~/.bun` by default. To uninstall bun, delete this directory and edit your shell config (`.bashrc`, `.zshrc`, or similar) to remove `~/.bun/bin` from the `$PATH` variable.
-
-```sh
-$ rm -rf ~/.bun # make sure to remove ~/.bun/bin from $PATH
-```
diff --git a/package.json b/package.json
index 89d9f0f813..65969f7ba8 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "private": true,
   "name": "bun",
-  "version": "1.1.30",
+  "version": "1.1.39",
   "workspaces": [
     "./packages/bun-types"
   ],
@@ -21,14 +21,17 @@
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
     "source-map-js": "^1.2.0",
-    "typescript": "^5.4.5"
+    "typescript": "^5.4.5",
+    "caniuse-lite": "^1.0.30001620",
+    "autoprefixer": "^10.4.19",
+    "@mdn/browser-compat-data": "~5.5.28"
   },
   "resolutions": {
     "bun-types": "workspace:packages/bun-types"
   },
   "scripts": {
-    "build": "bun ./scripts/build.mjs -GNinja -DCMAKE_BUILD_TYPE=Debug -B build/debug",
-    "build:debug": "bun run build",
+    "build": "bun run build:debug",
+    "build:debug": "bun ./scripts/build.mjs -GNinja -DCMAKE_BUILD_TYPE=Debug -B build/debug",
     "build:valgrind": "bun ./scripts/build.mjs -GNinja -DCMAKE_BUILD_TYPE=Debug -DENABLE_BASELINE=ON -ENABLE_VALGRIND=ON -B build/debug-valgrind",
     "build:release": "bun ./scripts/build.mjs -GNinja -DCMAKE_BUILD_TYPE=Release -B build/release",
     "build:ci": "bun ./scripts/build.mjs -GNinja -DCMAKE_BUILD_TYPE=Release -DCMAKE_VERBOSE_MAKEFILE=ON -DCI=true -B build/release-ci --verbose --fresh",
@@ -36,10 +39,11 @@
     "build:logs": "bun ./scripts/build.mjs -GNinja -DCMAKE_BUILD_TYPE=Release -DENABLE_LOGS=ON -B build/release-logs",
     "build:safe": "bun ./scripts/build.mjs -GNinja -DCMAKE_BUILD_TYPE=Release -DZIG_OPTIMIZE=ReleaseSafe -B build/release-safe",
     "build:smol": "bun ./scripts/build.mjs -GNinja -DCMAKE_BUILD_TYPE=MinSizeRel -B build/release-smol",
-    "build:local": "bun ./scripts/build.mjs -GNinja -DCMAKE_BUILD_TYPE=Debug -DWEBKIT_LOCAL=ON -B build/debug",
-    "build:release:local": "bun ./scripts/build.mjs -GNinja -DCMAKE_BUILD_TYPE=Release -DWEBKIT_LOCAL=ON -B build/release",
+    "build:local": "bun ./scripts/build.mjs -GNinja -DCMAKE_BUILD_TYPE=Debug -DWEBKIT_LOCAL=ON -B build/debug-local",
+    "build:release:local": "bun ./scripts/build.mjs -GNinja -DCMAKE_BUILD_TYPE=Release -DWEBKIT_LOCAL=ON -B build/release-local",
     "build:release:with_logs": "cmake . -DCMAKE_BUILD_TYPE=Release -DENABLE_LOGS=true -GNinja -Bbuild-release && ninja -Cbuild-release",
     "build:debug-zig-release": "cmake . -DCMAKE_BUILD_TYPE=Release -DZIG_OPTIMIZE=Debug -GNinja -Bbuild-debug-zig-release && ninja -Cbuild-debug-zig-release",
+    "css-properties": "bun run src/css/properties/generate_properties.ts",
     "bump": "bun ./scripts/bump.ts",
     "typecheck": "tsc --noEmit && cd test && bun run typecheck",
     "fmt": "bun run prettier",
@@ -55,19 +59,20 @@
     "zig:check": "bun run zig build check --summary new",
     "zig:check-all": "bun run zig build check-all --summary new",
     "zig:check-windows": "bun run zig build check-windows --summary new",
-    "cmake": "bun ./scripts/build.mjs -DCMAKE_BUILD_TYPE=Debug -B build/debug",
-    "clang-format": "bun run cmake --target clang-format",
-    "clang-format:check": "bun run cmake --target clang-format-check",
-    "clang-format:diff": "bun run cmake --target clang-format-diff",
-    "clang-tidy": "bun run cmake --target clang-tidy",
-    "clang-tidy:check": "bun run cmake --target clang-tidy-check",
-    "clang-tidy:diff": "bun run cmake --target clang-tidy-diff",
-    "zig-format": "bun run cmake --target zig-format",
-    "zig-format:check": "bun run cmake --target zig-format-check",
-    "zig-format:diff": "bun run cmake --target zig-format-diff",
-    "prettier": "bun run cmake --target prettier",
-    "prettier:check": "bun run cmake --target prettier-check",
-    "prettier:extra": "bun run cmake --target prettier-extra",
-    "prettier:diff": "bun run cmake --target prettier-diff"
+    "analysis": "bun ./scripts/build.mjs -DCMAKE_BUILD_TYPE=Debug -DENABLE_ANALYSIS=ON -DENABLE_CCACHE=OFF -B build/analysis",
+    "analysis:no-llvm": "bun run analysis -DENABLE_LLVM=OFF",
+    "clang-format": "bun run analysis --target clang-format",
+    "clang-format:check": "bun run analysis --target clang-format-check",
+    "clang-format:diff": "bun run analysis --target clang-format-diff",
+    "clang-tidy": "bun run analysis --target clang-tidy",
+    "clang-tidy:check": "bun run analysis --target clang-tidy-check",
+    "clang-tidy:diff": "bun run analysis --target clang-tidy-diff",
+    "zig-format": "bun run analysis:no-llvm --target zig-format",
+    "zig-format:check": "bun run analysis:no-llvm --target zig-format-check",
+    "zig-format:diff": "bun run analysis:no-llvm --target zig-format-diff",
+    "prettier": "bun run analysis:no-llvm --target prettier",
+    "prettier:check": "bun run analysis:no-llvm --target prettier-check",
+    "prettier:extra": "bun run analysis:no-llvm --target prettier-extra",
+    "prettier:diff": "bun run analysis:no-llvm --target prettier-diff"
   }
 }
diff --git a/packages/bun-build-mdx-rs/.cargo/config.toml b/packages/bun-build-mdx-rs/.cargo/config.toml
new file mode 100644
index 0000000000..06516547bf
--- /dev/null
+++ b/packages/bun-build-mdx-rs/.cargo/config.toml
@@ -0,0 +1,5 @@
+[target.aarch64-unknown-linux-musl]
+linker = "aarch64-linux-musl-gcc"
+rustflags = ["-C", "target-feature=-crt-static"]
+[target.x86_64-pc-windows-msvc]
+rustflags = ["-C", "target-feature=+crt-static"]
\ No newline at end of file
diff --git a/packages/bun-build-mdx-rs/.gitignore b/packages/bun-build-mdx-rs/.gitignore
new file mode 100644
index 0000000000..3bcc3fe03c
--- /dev/null
+++ b/packages/bun-build-mdx-rs/.gitignore
@@ -0,0 +1,202 @@
+# Created by https://www.toptal.com/developers/gitignore/api/node
+# Edit at https://www.toptal.com/developers/gitignore?templates=node
+
+### Node ###
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+
+# Diagnostic reports (https://nodejs.org/api/report.html)
+report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+*.lcov
+
+# nyc test coverage
+.nyc_output
+
+# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# Bower dependency directory (https://bower.io/)
+bower_components
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (https://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# TypeScript v1 declaration files
+typings/
+
+# TypeScript cache
+*.tsbuildinfo
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Microbundle cache
+.rpt2_cache/
+.rts2_cache_cjs/
+.rts2_cache_es/
+.rts2_cache_umd/
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variables file
+.env
+.env.test
+
+# parcel-bundler cache (https://parceljs.org/)
+.cache
+
+# Next.js build output
+.next
+
+# Nuxt.js build / generate output
+.nuxt
+dist
+
+# Gatsby files
+.cache/
+# Comment in the public line in if your project uses Gatsby and not Next.js
+# https://nextjs.org/blog/next-9-1#public-directory-support
+# public
+
+# vuepress build output
+.vuepress/dist
+
+# Serverless directories
+.serverless/
+
+# FuseBox cache
+.fusebox/
+
+# DynamoDB Local files
+.dynamodb/
+
+# TernJS port file
+.tern-port
+
+# Stores VSCode versions used for testing VSCode extensions
+.vscode-test
+
+# End of https://www.toptal.com/developers/gitignore/api/node
+
+# Created by https://www.toptal.com/developers/gitignore/api/macos
+# Edit at https://www.toptal.com/developers/gitignore?templates=macos
+
+### macOS ###
+# General
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two 
+Icon
+
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+### macOS Patch ###
+# iCloud generated files
+*.icloud
+
+# End of https://www.toptal.com/developers/gitignore/api/macos
+
+# Created by https://www.toptal.com/developers/gitignore/api/windows
+# Edit at https://www.toptal.com/developers/gitignore?templates=windows
+
+### Windows ###
+# Windows thumbnail cache files
+Thumbs.db
+Thumbs.db:encryptable
+ehthumbs.db
+ehthumbs_vista.db
+
+# Dump file
+*.stackdump
+
+# Folder config file
+[Dd]esktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Windows Installer files
+*.cab
+*.msi
+*.msix
+*.msm
+*.msp
+
+# Windows shortcuts
+*.lnk
+
+# End of https://www.toptal.com/developers/gitignore/api/windows
+
+#Added by cargo
+
+/target
+Cargo.lock
+
+.pnp.*
+.yarn/*
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/sdks
+!.yarn/versions
+
+*.node
+
+dist/
+
+index.js
+index.d.ts
\ No newline at end of file
diff --git a/packages/bun-build-mdx-rs/.npmignore b/packages/bun-build-mdx-rs/.npmignore
new file mode 100644
index 0000000000..ec144db2a7
--- /dev/null
+++ b/packages/bun-build-mdx-rs/.npmignore
@@ -0,0 +1,13 @@
+target
+Cargo.lock
+.cargo
+.github
+npm
+.eslintrc
+.prettierignore
+rustfmt.toml
+yarn.lock
+*.node
+.yarn
+__test__
+renovate.json
diff --git a/packages/bun-build-mdx-rs/Cargo.toml b/packages/bun-build-mdx-rs/Cargo.toml
new file mode 100644
index 0000000000..90c4753237
--- /dev/null
+++ b/packages/bun-build-mdx-rs/Cargo.toml
@@ -0,0 +1,21 @@
+[package]
+edition = "2021"
+name = "bun-mdx-rs"
+version = "0.0.0"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+# Default enable napi4 feature, see https://nodejs.org/api/n-api.html#node-api-version-matrix
+napi = { version = "2.12.2", default-features = false, features = ["napi4"] }
+napi-derive = "2.12.2"
+mdxjs = "0.2.11"
+bun-native-plugin = { path = "../bun-native-plugin-rs" }
+
+[build-dependencies]
+napi-build = "2.0.1"
+
+[profile.release]
+lto = true
+strip = "symbols"
diff --git a/packages/bun-build-mdx-rs/README.md b/packages/bun-build-mdx-rs/README.md
new file mode 100644
index 0000000000..0c2f01a2ce
--- /dev/null
+++ b/packages/bun-build-mdx-rs/README.md
@@ -0,0 +1,34 @@
+# bun-build-mdx-rs
+
+This is a proof of concept for using a third-party native addon in `Bun.build()`.
+
+This uses `mdxjs-rs` to convert MDX to JSX.
+
+TODO: **This needs to be built & published to npm.**
+
+## Building locally:
+
+```sh
+cargo build --release
+```
+
+```js
+import { build } from "bun";
+import mdx from "./index.js";
+
+// TODO: This needs to be prebuilt for the current platform
+// Probably use a napi-rs template for this
+import addon from "./target/release/libmdx_bun.dylib" with { type: "file" };
+
+const results = await build({
+  entrypoints: ["./hello.jsx"],
+  plugins: [mdx({ addon })],
+  minify: true,
+  outdir: "./dist",
+  define: {
+    "process.env.NODE_ENV": JSON.stringify("production"),
+  },
+});
+
+console.log(results);
+```
diff --git a/packages/bun-build-mdx-rs/__test__/index.spec.mjs b/packages/bun-build-mdx-rs/__test__/index.spec.mjs
new file mode 100644
index 0000000000..1ade4cafe8
--- /dev/null
+++ b/packages/bun-build-mdx-rs/__test__/index.spec.mjs
@@ -0,0 +1,7 @@
+import test from 'ava'
+
+import { sum } from '../index.js'
+
+test('sum from native', (t) => {
+  t.is(sum(1, 2), 3)
+})
diff --git a/packages/bun-build-mdx-rs/build.rs b/packages/bun-build-mdx-rs/build.rs
new file mode 100644
index 0000000000..1f866b6a3c
--- /dev/null
+++ b/packages/bun-build-mdx-rs/build.rs
@@ -0,0 +1,5 @@
+extern crate napi_build;
+
+fn main() {
+  napi_build::setup();
+}
diff --git a/packages/bun-build-mdx-rs/input/index.ts b/packages/bun-build-mdx-rs/input/index.ts
new file mode 100644
index 0000000000..9531975088
--- /dev/null
+++ b/packages/bun-build-mdx-rs/input/index.ts
@@ -0,0 +1,6 @@
+import page1 from "./page1.mdx";
+import page2 from "./page2.mdx";
+import page3 from "./page3.mdx";
+import page4 from "./page4.mdx";
+
+console.log(page1, page2, page3, page4);
diff --git a/packages/bun-build-mdx-rs/input/page1.mdx b/packages/bun-build-mdx-rs/input/page1.mdx
new file mode 100644
index 0000000000..2199a0d985
--- /dev/null
+++ b/packages/bun-build-mdx-rs/input/page1.mdx
@@ -0,0 +1,11 @@
+# Hello World
+
+This is a sample MDX file that demonstrates various MDX features.
+
+## Components
+
+You can use JSX components directly in MDX:
+
+<Button onClick={() => alert("Hello!")}>Click me</Button>
+
+## Code Blocks
diff --git a/packages/bun-build-mdx-rs/input/page2.mdx b/packages/bun-build-mdx-rs/input/page2.mdx
new file mode 100644
index 0000000000..2199a0d985
--- /dev/null
+++ b/packages/bun-build-mdx-rs/input/page2.mdx
@@ -0,0 +1,11 @@
+# Hello World
+
+This is a sample MDX file that demonstrates various MDX features.
+
+## Components
+
+You can use JSX components directly in MDX:
+
+<Button onClick={() => alert("Hello!")}>Click me</Button>
+
+## Code Blocks
diff --git a/packages/bun-build-mdx-rs/input/page3.mdx b/packages/bun-build-mdx-rs/input/page3.mdx
new file mode 100644
index 0000000000..2199a0d985
--- /dev/null
+++ b/packages/bun-build-mdx-rs/input/page3.mdx
@@ -0,0 +1,11 @@
+# Hello World
+
+This is a sample MDX file that demonstrates various MDX features.
+
+## Components
+
+You can use JSX components directly in MDX:
+
+<Button onClick={() => alert("Hello!")}>Click me</Button>
+
+## Code Blocks
diff --git a/packages/bun-build-mdx-rs/input/page4.mdx b/packages/bun-build-mdx-rs/input/page4.mdx
new file mode 100644
index 0000000000..2199a0d985
--- /dev/null
+++ b/packages/bun-build-mdx-rs/input/page4.mdx
@@ -0,0 +1,11 @@
+# Hello World
+
+This is a sample MDX file that demonstrates various MDX features.
+
+## Components
+
+You can use JSX components directly in MDX:
+
+<Button onClick={() => alert("Hello!")}>Click me</Button>
+
+## Code Blocks
diff --git a/packages/bun-build-mdx-rs/npm/darwin-arm64/README.md b/packages/bun-build-mdx-rs/npm/darwin-arm64/README.md
new file mode 100644
index 0000000000..ad90799c6f
--- /dev/null
+++ b/packages/bun-build-mdx-rs/npm/darwin-arm64/README.md
@@ -0,0 +1,3 @@
+# `bun-mdx-rs-darwin-arm64`
+
+This is the **aarch64-apple-darwin** binary for `bun-mdx-rs`
diff --git a/packages/bun-build-mdx-rs/npm/darwin-arm64/package.json b/packages/bun-build-mdx-rs/npm/darwin-arm64/package.json
new file mode 100644
index 0000000000..a49f40f89e
--- /dev/null
+++ b/packages/bun-build-mdx-rs/npm/darwin-arm64/package.json
@@ -0,0 +1,18 @@
+{
+  "name": "bun-mdx-rs-darwin-arm64",
+  "version": "0.0.0",
+  "os": [
+    "darwin"
+  ],
+  "cpu": [
+    "arm64"
+  ],
+  "main": "bun-mdx-rs.darwin-arm64.node",
+  "files": [
+    "bun-mdx-rs.darwin-arm64.node"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">= 10"
+  }
+}
\ No newline at end of file
diff --git a/packages/bun-build-mdx-rs/npm/darwin-x64/README.md b/packages/bun-build-mdx-rs/npm/darwin-x64/README.md
new file mode 100644
index 0000000000..53098f4931
--- /dev/null
+++ b/packages/bun-build-mdx-rs/npm/darwin-x64/README.md
@@ -0,0 +1,3 @@
+# `bun-mdx-rs-darwin-x64`
+
+This is the **x86_64-apple-darwin** binary for `bun-mdx-rs`
diff --git a/packages/bun-build-mdx-rs/npm/darwin-x64/package.json b/packages/bun-build-mdx-rs/npm/darwin-x64/package.json
new file mode 100644
index 0000000000..41bd00cd3f
--- /dev/null
+++ b/packages/bun-build-mdx-rs/npm/darwin-x64/package.json
@@ -0,0 +1,18 @@
+{
+  "name": "bun-mdx-rs-darwin-x64",
+  "version": "0.0.0",
+  "os": [
+    "darwin"
+  ],
+  "cpu": [
+    "x64"
+  ],
+  "main": "bun-mdx-rs.darwin-x64.node",
+  "files": [
+    "bun-mdx-rs.darwin-x64.node"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">= 10"
+  }
+}
\ No newline at end of file
diff --git a/packages/bun-build-mdx-rs/npm/linux-arm64-gnu/README.md b/packages/bun-build-mdx-rs/npm/linux-arm64-gnu/README.md
new file mode 100644
index 0000000000..f2613108fe
--- /dev/null
+++ b/packages/bun-build-mdx-rs/npm/linux-arm64-gnu/README.md
@@ -0,0 +1,3 @@
+# `bun-mdx-rs-linux-arm64-gnu`
+
+This is the **aarch64-unknown-linux-gnu** binary for `bun-mdx-rs`
diff --git a/packages/bun-build-mdx-rs/npm/linux-arm64-gnu/package.json b/packages/bun-build-mdx-rs/npm/linux-arm64-gnu/package.json
new file mode 100644
index 0000000000..6d8fc3cd88
--- /dev/null
+++ b/packages/bun-build-mdx-rs/npm/linux-arm64-gnu/package.json
@@ -0,0 +1,21 @@
+{
+  "name": "bun-mdx-rs-linux-arm64-gnu",
+  "version": "0.0.0",
+  "os": [
+    "linux"
+  ],
+  "cpu": [
+    "arm64"
+  ],
+  "main": "bun-mdx-rs.linux-arm64-gnu.node",
+  "files": [
+    "bun-mdx-rs.linux-arm64-gnu.node"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">= 10"
+  },
+  "libc": [
+    "glibc"
+  ]
+}
\ No newline at end of file
diff --git a/packages/bun-build-mdx-rs/npm/linux-arm64-musl/README.md b/packages/bun-build-mdx-rs/npm/linux-arm64-musl/README.md
new file mode 100644
index 0000000000..6a07db8135
--- /dev/null
+++ b/packages/bun-build-mdx-rs/npm/linux-arm64-musl/README.md
@@ -0,0 +1,3 @@
+# `bun-mdx-rs-linux-arm64-musl`
+
+This is the **aarch64-unknown-linux-musl** binary for `bun-mdx-rs`
diff --git a/packages/bun-build-mdx-rs/npm/linux-arm64-musl/package.json b/packages/bun-build-mdx-rs/npm/linux-arm64-musl/package.json
new file mode 100644
index 0000000000..02344ef80a
--- /dev/null
+++ b/packages/bun-build-mdx-rs/npm/linux-arm64-musl/package.json
@@ -0,0 +1,21 @@
+{
+  "name": "bun-mdx-rs-linux-arm64-musl",
+  "version": "0.0.0",
+  "os": [
+    "linux"
+  ],
+  "cpu": [
+    "arm64"
+  ],
+  "main": "bun-mdx-rs.linux-arm64-musl.node",
+  "files": [
+    "bun-mdx-rs.linux-arm64-musl.node"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">= 10"
+  },
+  "libc": [
+    "musl"
+  ]
+}
\ No newline at end of file
diff --git a/packages/bun-build-mdx-rs/npm/linux-x64-gnu/README.md b/packages/bun-build-mdx-rs/npm/linux-x64-gnu/README.md
new file mode 100644
index 0000000000..339193a734
--- /dev/null
+++ b/packages/bun-build-mdx-rs/npm/linux-x64-gnu/README.md
@@ -0,0 +1,3 @@
+# `bun-mdx-rs-linux-x64-gnu`
+
+This is the **x86_64-unknown-linux-gnu** binary for `bun-mdx-rs`
diff --git a/packages/bun-build-mdx-rs/npm/linux-x64-gnu/package.json b/packages/bun-build-mdx-rs/npm/linux-x64-gnu/package.json
new file mode 100644
index 0000000000..b45a64b866
--- /dev/null
+++ b/packages/bun-build-mdx-rs/npm/linux-x64-gnu/package.json
@@ -0,0 +1,21 @@
+{
+  "name": "bun-mdx-rs-linux-x64-gnu",
+  "version": "0.0.0",
+  "os": [
+    "linux"
+  ],
+  "cpu": [
+    "x64"
+  ],
+  "main": "bun-mdx-rs.linux-x64-gnu.node",
+  "files": [
+    "bun-mdx-rs.linux-x64-gnu.node"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">= 10"
+  },
+  "libc": [
+    "glibc"
+  ]
+}
\ No newline at end of file
diff --git a/packages/bun-build-mdx-rs/npm/linux-x64-musl/README.md b/packages/bun-build-mdx-rs/npm/linux-x64-musl/README.md
new file mode 100644
index 0000000000..f37e0555ec
--- /dev/null
+++ b/packages/bun-build-mdx-rs/npm/linux-x64-musl/README.md
@@ -0,0 +1,3 @@
+# `bun-mdx-rs-linux-x64-musl`
+
+This is the **x86_64-unknown-linux-musl** binary for `bun-mdx-rs`
diff --git a/packages/bun-build-mdx-rs/npm/linux-x64-musl/package.json b/packages/bun-build-mdx-rs/npm/linux-x64-musl/package.json
new file mode 100644
index 0000000000..8a3f90cd98
--- /dev/null
+++ b/packages/bun-build-mdx-rs/npm/linux-x64-musl/package.json
@@ -0,0 +1,21 @@
+{
+  "name": "bun-mdx-rs-linux-x64-musl",
+  "version": "0.0.0",
+  "os": [
+    "linux"
+  ],
+  "cpu": [
+    "x64"
+  ],
+  "main": "bun-mdx-rs.linux-x64-musl.node",
+  "files": [
+    "bun-mdx-rs.linux-x64-musl.node"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">= 10"
+  },
+  "libc": [
+    "musl"
+  ]
+}
\ No newline at end of file
diff --git a/packages/bun-build-mdx-rs/npm/win32-x64-msvc/README.md b/packages/bun-build-mdx-rs/npm/win32-x64-msvc/README.md
new file mode 100644
index 0000000000..5e72822a4b
--- /dev/null
+++ b/packages/bun-build-mdx-rs/npm/win32-x64-msvc/README.md
@@ -0,0 +1,3 @@
+# `bun-mdx-rs-win32-x64-msvc`
+
+This is the **x86_64-pc-windows-msvc** binary for `bun-mdx-rs`
diff --git a/packages/bun-build-mdx-rs/npm/win32-x64-msvc/package.json b/packages/bun-build-mdx-rs/npm/win32-x64-msvc/package.json
new file mode 100644
index 0000000000..738081cb77
--- /dev/null
+++ b/packages/bun-build-mdx-rs/npm/win32-x64-msvc/package.json
@@ -0,0 +1,18 @@
+{
+  "name": "bun-mdx-rs-win32-x64-msvc",
+  "version": "0.0.0",
+  "os": [
+    "win32"
+  ],
+  "cpu": [
+    "x64"
+  ],
+  "main": "bun-mdx-rs.win32-x64-msvc.node",
+  "files": [
+    "bun-mdx-rs.win32-x64-msvc.node"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">= 10"
+  }
+}
\ No newline at end of file
diff --git a/packages/bun-build-mdx-rs/package.json b/packages/bun-build-mdx-rs/package.json
new file mode 100644
index 0000000000..280221f8c6
--- /dev/null
+++ b/packages/bun-build-mdx-rs/package.json
@@ -0,0 +1,37 @@
+{
+  "name": "bun-mdx-rs",
+  "version": "0.0.0",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "napi": {
+    "name": "bun-mdx-rs",
+    "triples": {
+      "additional": [
+        "aarch64-apple-darwin",
+        "aarch64-unknown-linux-gnu",
+        "aarch64-unknown-linux-musl",
+        "x86_64-unknown-linux-musl"
+      ]
+    }
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@napi-rs/cli": "^2.18.4",
+    "ava": "^6.0.1"
+  },
+  "ava": {
+    "timeout": "3m"
+  },
+  "engines": {
+    "node": ">= 10"
+  },
+  "scripts": {
+    "artifacts": "napi artifacts",
+    "build": "napi build --platform --release",
+    "build:debug": "napi build --platform",
+    "prepublishOnly": "napi prepublish -t npm",
+    "test": "ava",
+    "universal": "napi universal",
+    "version": "napi version"
+  }
+}
\ No newline at end of file
diff --git a/packages/bun-build-mdx-rs/rustfmt.toml b/packages/bun-build-mdx-rs/rustfmt.toml
new file mode 100644
index 0000000000..cab5731eda
--- /dev/null
+++ b/packages/bun-build-mdx-rs/rustfmt.toml
@@ -0,0 +1,2 @@
+tab_spaces = 2
+edition = "2021"
diff --git a/packages/bun-build-mdx-rs/src/lib.rs b/packages/bun-build-mdx-rs/src/lib.rs
new file mode 100644
index 0000000000..4b93e6037f
--- /dev/null
+++ b/packages/bun-build-mdx-rs/src/lib.rs
@@ -0,0 +1,55 @@
+use bun_native_plugin::{define_bun_plugin, BunLoader, OnBeforeParse};
+use mdxjs::{compile, Options as CompileOptions};
+use napi_derive::napi;
+
+#[macro_use]
+extern crate napi;
+
+define_bun_plugin!("bun-mdx-rs");
+
+#[no_mangle]
+pub extern "C" fn bun_mdx_rs(
+  args: *const bun_native_plugin::sys::OnBeforeParseArguments,
+  result: *mut bun_native_plugin::sys::OnBeforeParseResult,
+) {
+  let args = unsafe { &*args };
+
+  let mut handle = match OnBeforeParse::from_raw(args, result) {
+    Ok(handle) => handle,
+    Err(_) => {
+      return;
+    }
+  };
+
+  let source_str = match handle.input_source_code() {
+    Ok(source_str) => source_str,
+    Err(_) => {
+      handle.log_error("Failed to fetch source code");
+      return;
+    }
+  };
+
+  let mut options = CompileOptions::gfm();
+
+  // Leave it as JSX for Bun to handle
+  options.jsx = true;
+
+  let path = match handle.path() {
+    Ok(path) => path,
+    Err(e) => {
+      handle.log_error(&format!("Failed to get path: {:?}", e));
+      return;
+    }
+  };
+  options.filepath = Some(path.to_string());
+
+  match compile(&source_str, &options) {
+    Ok(compiled) => {
+      handle.set_output_source_code(compiled, BunLoader::BUN_LOADER_JSX);
+    }
+    Err(_) => {
+      handle.log_error("Failed to compile MDX");
+      return;
+    }
+  }
+}
diff --git a/packages/bun-darwin-aarch64/.npmignore b/packages/bun-darwin-aarch64/.npmignore
deleted file mode 100644
index 08d23cb2a7..0000000000
--- a/packages/bun-darwin-aarch64/.npmignore
+++ /dev/null
@@ -1,4 +0,0 @@
-bin/bun-profile
-bin/*.o
-*.o
-*.a
\ No newline at end of file
diff --git a/packages/bun-debug-adapter-protocol/package.json b/packages/bun-debug-adapter-protocol/package.json
index 5c23c6fffe..cf8bd70ce0 100644
--- a/packages/bun-debug-adapter-protocol/package.json
+++ b/packages/bun-debug-adapter-protocol/package.json
@@ -1,6 +1,7 @@
 {
   "name": "bun-debug-adapter-protocol",
   "version": "0.0.1",
+  "type": "module",
   "dependencies": {
     "semver": "^7.5.4",
     "source-map-js": "^1.0.2"
diff --git a/packages/bun-debug-adapter-protocol/src/debugger/adapter.ts b/packages/bun-debug-adapter-protocol/src/debugger/adapter.ts
index 677db5e41c..87bdedea0c 100644
--- a/packages/bun-debug-adapter-protocol/src/debugger/adapter.ts
+++ b/packages/bun-debug-adapter-protocol/src/debugger/adapter.ts
@@ -1,19 +1,19 @@
-import type { InspectorEventMap } from "../../../bun-inspector-protocol/src/inspector";
-import type { JSC } from "../../../bun-inspector-protocol/src/protocol";
-import type { DAP } from "../protocol";
-// @ts-ignore
 import { ChildProcess, spawn } from "node:child_process";
 import { EventEmitter } from "node:events";
-import { AddressInfo, createServer } from "node:net";
+import { AddressInfo, createServer, Socket } from "node:net";
 import * as path from "node:path";
-import { remoteObjectToString, WebSocketInspector } from "../../../bun-inspector-protocol/index";
-import { randomUnixPath, TCPSocketSignal, UnixSignal } from "./signal";
-import { Location, SourceMap } from "./sourcemap";
+import { remoteObjectToString, WebSocketInspector } from "../../../bun-inspector-protocol/index.ts";
+import type { Inspector, InspectorEventMap } from "../../../bun-inspector-protocol/src/inspector/index.d.ts";
+import { NodeSocketInspector } from "../../../bun-inspector-protocol/src/inspector/node-socket.ts";
+import type { JSC } from "../../../bun-inspector-protocol/src/protocol/index.d.ts";
+import type { DAP } from "../protocol/index.d.ts";
+import { randomUnixPath, TCPSocketSignal, UnixSignal } from "./signal.ts";
+import { Location, SourceMap } from "./sourcemap.ts";
 
 export async function getAvailablePort(): Promise<number> {
   const server = createServer();
   server.listen(0);
-  return new Promise((resolve, reject) => {
+  return new Promise(resolve => {
     server.on("listening", () => {
       const { port } = server.address() as AddressInfo;
       server.close(() => {
@@ -105,7 +105,18 @@ const capabilities: DAP.Capabilities = {
 
 type InitializeRequest = DAP.InitializeRequest & {
   supportsConfigurationDoneRequest?: boolean;
-};
+  enableControlFlowProfiler?: boolean;
+  enableDebugger?: boolean;
+} & (
+    | {
+        enableLifecycleAgentReporter?: false;
+        sendImmediatePreventExit?: false;
+      }
+    | {
+        enableLifecycleAgentReporter: true;
+        sendImmediatePreventExit?: boolean;
+      }
+  );
 
 type LaunchRequest = DAP.LaunchRequest & {
   runtime?: string;
@@ -118,6 +129,8 @@ type LaunchRequest = DAP.LaunchRequest & {
   stopOnEntry?: boolean;
   noDebug?: boolean;
   watchMode?: boolean | "hot";
+  __skipValidation?: boolean;
+  stdin?: string;
 };
 
 type AttachRequest = DAP.AttachRequest & {
@@ -211,10 +224,32 @@ const debugSilentEvents = new Set(["Adapter.event", "Inspector.event"]);
 
 let threadId = 1;
 
-export class DebugAdapter extends EventEmitter<DebugAdapterEventMap> implements IDebugAdapter {
+// Add these helper functions at the top level
+function normalizeSourcePath(sourcePath: string, untitledDocPath?: string, bunEvalPath?: string): string {
+  if (!sourcePath) return sourcePath;
+
+  // Handle eval source paths
+  if (sourcePath === bunEvalPath) {
+    return bunEvalPath!;
+  }
+
+  // Handle untitled documents
+  if (sourcePath === untitledDocPath) {
+    return bunEvalPath!;
+  }
+
+  // Handle normal file paths
+  return path.normalize(sourcePath);
+}
+
+export abstract class BaseDebugAdapter<T extends Inspector = Inspector>
+  extends EventEmitter<DebugAdapterEventMap>
+  implements IDebugAdapter
+{
+  protected readonly inspector: T;
+  protected options?: DebuggerOptions;
+
   #threadId: number;
-  #inspector: WebSocketInspector;
-  #process?: ChildProcess;
   #sourceId: number;
   #pendingSources: Map<string, ((source: Source) => void)[]>;
   #sources: Map<string | number, Source>;
@@ -227,18 +262,21 @@ export class DebugAdapter extends EventEmitter<DebugAdapterEventMap> implements
   #targets: Map<number, Target>;
   #variableId: number;
   #variables: Map<number, Variable>;
+  #untitledDocPath?: string;
+  #bunEvalPath?: string;
   #initialized?: InitializeRequest;
-  #options?: DebuggerOptions;
 
-  constructor(url?: string | URL) {
+  protected constructor(inspector: T, untitledDocPath?: string, bunEvalPath?: string) {
     super();
+    this.#untitledDocPath = untitledDocPath;
+    this.#bunEvalPath = bunEvalPath;
     this.#threadId = threadId++;
-    this.#inspector = new WebSocketInspector(url);
-    const emit = this.#inspector.emit.bind(this.#inspector);
-    this.#inspector.emit = (event, ...args) => {
+    this.inspector = inspector;
+    const emit = this.inspector.emit.bind(this.inspector);
+    this.inspector.emit = (event, ...args) => {
       let sent = false;
       sent ||= emit(event, ...args);
-      sent ||= this.emit(event, ...(args as any));
+      sent ||= this.emit(event as keyof JSC.EventMap, ...(args as any));
       return sent;
     };
     this.#sourceId = 1;
@@ -255,21 +293,24 @@ export class DebugAdapter extends EventEmitter<DebugAdapterEventMap> implements
   }
 
   /**
-   * Gets the inspector url.
+   * Gets the inspector url. This is deprecated and exists for compat.
+   * @deprecated You should get the inspector directly (with .getInspector()), and if it's a WebSocketInspector you can access `.url` direclty.
    */
   get url(): string {
-    return this.#inspector.url;
+    // This code has been migrated from a time when the inspector was always a WebSocketInspector.
+    if (this.inspector instanceof WebSocketInspector) {
+      return this.inspector.url;
+    }
+
+    throw new Error("Inspector does not offer a URL");
   }
 
-  /**
-   * Starts the inspector.
-   * @param url the inspector url
-   * @returns if the inspector was able to connect
-   */
-  start(url?: string): Promise<boolean> {
-    return this.#attach({ url });
+  public getInspector() {
+    return this.inspector;
   }
 
+  abstract start(...args: unknown[]): Promise<boolean>;
+
   /**
    * Sends a request to the JavaScript inspector.
    * @param method the method name
@@ -282,7 +323,7 @@ export class DebugAdapter extends EventEmitter<DebugAdapterEventMap> implements
    * console.log(result.value); // 2
    */
   async send<M extends keyof JSC.ResponseMap>(method: M, params?: JSC.RequestMap[M]): Promise<JSC.ResponseMap[M]> {
-    return this.#inspector.send(method, params);
+    return this.inspector.send(method, params);
   }
 
   /**
@@ -323,7 +364,7 @@ export class DebugAdapter extends EventEmitter<DebugAdapterEventMap> implements
     return sent;
   }
 
-  #emit<E extends keyof DAP.EventMap>(event: E, body?: DAP.EventMap[E]): void {
+  protected emitAdapterEvent<E extends keyof DAP.EventMap>(event: E, body?: DAP.EventMap[E]): void {
     this.emit("Adapter.event", {
       type: "event",
       seq: 0,
@@ -335,7 +376,7 @@ export class DebugAdapter extends EventEmitter<DebugAdapterEventMap> implements
   #emitAfterResponse<E extends keyof DAP.EventMap>(event: E, body?: DAP.EventMap[E]): void {
     this.once("Adapter.response", () => {
       process.nextTick(() => {
-        this.#emit(event, body);
+        this.emitAdapterEvent(event, body);
       });
     });
   }
@@ -413,19 +454,37 @@ export class DebugAdapter extends EventEmitter<DebugAdapterEventMap> implements
     this.emit(`Adapter.${name}` as keyof DebugAdapterEventMap, body);
   }
 
-  initialize(request: InitializeRequest): DAP.InitializeResponse {
+  public initialize(request: InitializeRequest): DAP.InitializeResponse {
     this.#initialized = request;
 
     this.send("Inspector.enable");
     this.send("Runtime.enable");
     this.send("Console.enable");
-    this.send("Debugger.enable").catch(error => {
-      const { message } = unknownToError(error);
-      if (message !== "Debugger domain already enabled") {
-        throw error;
+
+    if (request.enableControlFlowProfiler) {
+      this.send("Runtime.enableControlFlowProfiler");
+    }
+
+    if (request.enableLifecycleAgentReporter) {
+      this.send("LifecycleReporter.enable");
+
+      if (request.sendImmediatePreventExit) {
+        this.send("LifecycleReporter.preventExit");
       }
-    });
-    this.send("Debugger.setAsyncStackTraceDepth", { depth: 200 });
+    }
+
+    // use !== false because by default if unspecified we want to enable the debugger
+    // and this option didn't exist beforehand, so we can't make it non-optional
+    if (request.enableDebugger !== false) {
+      this.send("Debugger.enable").catch(error => {
+        const { message } = unknownToError(error);
+        if (message !== "Debugger domain already enabled") {
+          throw error;
+        }
+      });
+
+      this.send("Debugger.setAsyncStackTraceDepth", { depth: 200 });
+    }
 
     const { clientID, supportsConfigurationDoneRequest } = request;
     if (!supportsConfigurationDoneRequest && clientID !== "vscode") {
@@ -439,242 +498,20 @@ export class DebugAdapter extends EventEmitter<DebugAdapterEventMap> implements
   configurationDone(): void {
     // If the client requested that `noDebug` mode be enabled,
     // then we need to disable all breakpoints and pause on statements.
-    const active = !this.#options?.noDebug;
+    const active = !this.options?.noDebug;
     this.send("Debugger.setBreakpointsActive", { active });
 
     // Tell the debugger that its ready to start execution.
     this.send("Inspector.initialized");
   }
 
-  async launch(request: DAP.LaunchRequest): Promise<void> {
-    this.#options = { ...request, type: "launch" };
-
-    try {
-      await this.#launch(request);
-    } catch (error) {
-      // Some clients, like VSCode, will show a system-level popup when a `launch` request fails.
-      // Instead, we want to show the error as a sidebar notification.
-      const { message } = unknownToError(error);
-      this.#emit("output", {
-        category: "stderr",
-        output: `Failed to start debugger.\n${message}`,
-      });
-      this.terminate();
-    }
-  }
-
-  async #launch(request: LaunchRequest): Promise<void> {
-    const {
-      runtime = "bun",
-      runtimeArgs = [],
-      program,
-      args = [],
-      cwd,
-      env = {},
-      strictEnv = false,
-      watchMode = false,
-      stopOnEntry = false,
-    } = request;
-
-    if (!program) {
-      throw new Error("No program specified. Did you set the 'program' property in your launch.json?");
-    }
-
-    if (!isJavaScript(program)) {
-      throw new Error("Program must be a JavaScript or TypeScript file.");
-    }
-
-    const processArgs = [...runtimeArgs, program, ...args];
-
-    if (isTestJavaScript(program) && !runtimeArgs.includes("test")) {
-      processArgs.unshift("test");
-    }
-
-    if (watchMode && !runtimeArgs.includes("--watch") && !runtimeArgs.includes("--hot")) {
-      processArgs.unshift(watchMode === "hot" ? "--hot" : "--watch");
-    }
-
-    const processEnv = strictEnv
-      ? {
-          ...env,
-        }
-      : {
-          ...process.env,
-          ...env,
-        };
-
-    if (process.platform !== "win32") {
-      // we're on unix
-      const url = `ws+unix://${randomUnixPath()}`;
-      const signal = new UnixSignal();
-
-      signal.on("Signal.received", () => {
-        this.#attach({ url });
-      });
-
-      this.once("Adapter.terminated", () => {
-        signal.close();
-      });
-
-      const query = stopOnEntry ? "break=1" : "wait=1";
-      processEnv["BUN_INSPECT"] = `${url}?${query}`;
-      processEnv["BUN_INSPECT_NOTIFY"] = signal.url;
-
-      // This is probably not correct, but it's the best we can do for now.
-      processEnv["FORCE_COLOR"] = "1";
-      processEnv["BUN_QUIET_DEBUG_LOGS"] = "1";
-      processEnv["BUN_DEBUG_QUIET_LOGS"] = "1";
-
-      const started = await this.#spawn({
-        command: runtime,
-        args: processArgs,
-        env: processEnv,
-        cwd,
-        isDebugee: true,
-      });
-
-      if (!started) {
-        throw new Error("Program could not be started.");
-      }
-    } else {
-      // we're on windows
-      // Create TCPSocketSignal
-      const url = `ws://127.0.0.1:${await getAvailablePort()}/${getRandomId()}`; // 127.0.0.1 so it resolves correctly on windows
-      const signal = new TCPSocketSignal(await getAvailablePort());
-
-      signal.on("Signal.received", async () => {
-        this.#attach({ url });
-      });
-
-      this.once("Adapter.terminated", () => {
-        signal.close();
-      });
-
-      const query = stopOnEntry ? "break=1" : "wait=1";
-      processEnv["BUN_INSPECT"] = `${url}?${query}`;
-      processEnv["BUN_INSPECT_NOTIFY"] = signal.url; // 127.0.0.1 so it resolves correctly on windows
-
-      // This is probably not correct, but it's the best we can do for now.
-      processEnv["FORCE_COLOR"] = "1";
-      processEnv["BUN_QUIET_DEBUG_LOGS"] = "1";
-      processEnv["BUN_DEBUG_QUIET_LOGS"] = "1";
-
-      const started = await this.#spawn({
-        command: runtime,
-        args: processArgs,
-        env: processEnv,
-        cwd,
-        isDebugee: true,
-      });
-
-      if (!started) {
-        throw new Error("Program could not be started.");
-      }
-    }
-  }
-
-  async #spawn(options: {
-    command: string;
-    args?: string[];
-    cwd?: string;
-    env?: Record<string, string | undefined>;
-    isDebugee?: boolean;
-  }): Promise<boolean> {
-    const { command, args = [], cwd, env, isDebugee } = options;
-    const request = { command, args, cwd, env };
-    this.emit("Process.requested", request);
-
-    let subprocess: ChildProcess;
-    try {
-      subprocess = spawn(command, args, {
-        ...request,
-        stdio: ["ignore", "pipe", "pipe"],
-      });
-    } catch (cause) {
-      this.emit("Process.exited", new Error("Failed to spawn process", { cause }), null);
-      return false;
-    }
-
-    subprocess.on("spawn", () => {
-      this.emit("Process.spawned", subprocess);
-
-      if (isDebugee) {
-        this.#process = subprocess;
-        this.#emit("process", {
-          name: `${command} ${args.join(" ")}`,
-          systemProcessId: subprocess.pid,
-          isLocalProcess: true,
-          startMethod: "launch",
-        });
-      }
-    });
-
-    subprocess.on("exit", (code, signal) => {
-      this.emit("Process.exited", code, signal);
-
-      if (isDebugee) {
-        this.#process = undefined;
-        this.#emit("exited", {
-          exitCode: code ?? -1,
-        });
-        this.#emit("terminated");
-      }
-    });
-
-    subprocess.stdout?.on("data", data => {
-      this.emit("Process.stdout", data.toString());
-    });
-
-    subprocess.stderr?.on("data", data => {
-      this.emit("Process.stderr", data.toString());
-    });
-
-    return new Promise(resolve => {
-      subprocess.on("spawn", () => resolve(true));
-      subprocess.on("exit", () => resolve(false));
-      subprocess.on("error", () => resolve(false));
-    });
-  }
-
-  async attach(request: AttachRequest): Promise<void> {
-    this.#options = { ...request, type: "attach" };
-
-    try {
-      await this.#attach(request);
-    } catch (error) {
-      // Some clients, like VSCode, will show a system-level popup when a `launch` request fails.
-      // Instead, we want to show the error as a sidebar notification.
-      const { message } = unknownToError(error);
-      this.#emit("output", {
-        category: "stderr",
-        output: `Failed to start debugger.\n${message}`,
-      });
-      this.terminate();
-    }
-  }
-
-  async #attach(request: AttachRequest): Promise<boolean> {
-    const { url } = request;
-
-    for (let i = 0; i < 3; i++) {
-      const ok = await this.#inspector.start(url);
-      if (ok) {
-        return true;
-      }
-      await new Promise(resolve => setTimeout(resolve, 100 * i));
-    }
-
-    return false;
-  }
+  // Required so all implementations have a method that .terminate() always calls.
+  // This is useful because we don't want any implementors to forget
+  protected abstract exitJSProcess(): void;
 
   terminate(): void {
-    if (!this.#process?.kill()) {
-      this.#evaluate({
-        expression: "process.exit(0)",
-      });
-    }
-
-    this.#emit("terminated");
+    this.exitJSProcess();
+    this.emitAdapterEvent("terminated");
   }
 
   disconnect(request: DAP.DisconnectRequest): void {
@@ -1047,7 +884,7 @@ export class DebugAdapter extends EventEmitter<DebugAdapterEventMap> implements
     }
 
     for (const breakpoint of breakpoints) {
-      this.#emit("breakpoint", {
+      this.emitAdapterEvent("breakpoint", {
         reason: "removed",
         breakpoint,
       });
@@ -1073,15 +910,21 @@ export class DebugAdapter extends EventEmitter<DebugAdapterEventMap> implements
   }
 
   #getBreakpointByLocation(source: Source, location: DAP.SourceBreakpoint): Breakpoint | undefined {
-    console.log("getBreakpointByLocation", {
-      source: sourceToId(source),
-      location,
-      ids: this.#getBreakpoints(sourceToId(source)).map(({ id }) => id),
-      breakpointIds: this.#getBreakpoints(sourceToId(source)).map(({ breakpointId }) => breakpointId),
-      lines: this.#getBreakpoints(sourceToId(source)).map(({ line }) => line),
-      columns: this.#getBreakpoints(sourceToId(source)).map(({ column }) => column),
-    });
-    const sourceId = sourceToId(source);
+    if (isDebug) {
+      console.log("getBreakpointByLocation", {
+        source: sourceToId(source),
+        location,
+        ids: this.#getBreakpoints(sourceToId(source)).map(({ id }) => id),
+        breakpointIds: this.#getBreakpoints(sourceToId(source)).map(({ breakpointId }) => breakpointId),
+        lines: this.#getBreakpoints(sourceToId(source)).map(({ line }) => line),
+        columns: this.#getBreakpoints(sourceToId(source)).map(({ column }) => column),
+      });
+    }
+    let sourceId = sourceToId(source);
+    const untitledDocPath = this.#untitledDocPath;
+    if (sourceId === untitledDocPath && this.#bunEvalPath) {
+      sourceId = this.#bunEvalPath;
+    }
     const [breakpoint] = this.#getBreakpoints(sourceId).filter(
       ({ source, request }) => source && sourceToId(source) === sourceId && request?.line === location.line,
     );
@@ -1089,7 +932,18 @@ export class DebugAdapter extends EventEmitter<DebugAdapterEventMap> implements
   }
 
   #getBreakpoints(sourceId: string | number): Breakpoint[] {
-    return [...this.#breakpoints.values()].flat().filter(({ source }) => source && sourceToId(source) === sourceId);
+    let output = [];
+    let all = this.#breakpoints;
+    for (const breakpoints of all.values()) {
+      for (const breakpoint of breakpoints) {
+        const source = breakpoint.source;
+        if (source && sourceToId(source) === sourceId) {
+          output.push(breakpoint);
+        }
+      }
+    }
+
+    return output;
   }
 
   #getFutureBreakpoints(breakpointId: string): FutureBreakpoint[] {
@@ -1269,7 +1123,7 @@ export class DebugAdapter extends EventEmitter<DebugAdapterEventMap> implements
     const callFrameId = this.#getCallFrameId(frameId);
     const objectGroup = callFrameId ? "debugger" : context;
 
-    const { result, wasThrown } = await this.#evaluate({
+    const { result, wasThrown } = await this.evaluateInternal({
       expression,
       objectGroup,
       callFrameId,
@@ -1290,7 +1144,7 @@ export class DebugAdapter extends EventEmitter<DebugAdapterEventMap> implements
     };
   }
 
-  async #evaluate(options: {
+  protected async evaluateInternal(options: {
     expression: string;
     objectGroup?: string;
     callFrameId?: string;
@@ -1314,7 +1168,7 @@ export class DebugAdapter extends EventEmitter<DebugAdapterEventMap> implements
     const callFrameId = this.#getCallFrameId(frameId);
 
     const { expression, hint } = completionToExpression(text);
-    const { result, wasThrown } = await this.#evaluate({
+    const { result, wasThrown } = await this.evaluateInternal({
       expression: expression || "this",
       callFrameId,
       objectGroup: "repl",
@@ -1346,33 +1200,29 @@ export class DebugAdapter extends EventEmitter<DebugAdapterEventMap> implements
   }
 
   ["Inspector.connected"](): void {
-    this.#emit("output", {
+    this.emitAdapterEvent("output", {
       category: "debug console",
       output: "Debugger attached.\n",
     });
 
-    this.#emit("initialized");
+    this.emitAdapterEvent("initialized");
   }
 
   async ["Inspector.disconnected"](error?: Error): Promise<void> {
-    this.#emit("output", {
+    this.emitAdapterEvent("output", {
       category: "debug console",
       output: "Debugger detached.\n",
     });
 
     if (error) {
       const { message } = error;
-      this.#emit("output", {
+      this.emitAdapterEvent("output", {
         category: "stderr",
         output: `${message}\n`,
       });
     }
 
-    this.#reset();
-
-    if (this.#process?.exitCode !== null) {
-      this.#emit("terminated");
-    }
+    this.resetInternal();
   }
 
   async ["Debugger.scriptParsed"](event: JSC.Debugger.ScriptParsedEvent): Promise<void> {
@@ -1423,7 +1273,7 @@ export class DebugAdapter extends EventEmitter<DebugAdapterEventMap> implements
       return;
     }
 
-    this.#emit("output", {
+    this.emitAdapterEvent("output", {
       category: "stderr",
       output: errorMessage,
       line: this.#lineFrom0BasedLine(errorLine),
@@ -1451,7 +1301,7 @@ export class DebugAdapter extends EventEmitter<DebugAdapterEventMap> implements
         const breakpoint = breakpoints[i];
         const oldBreakpoint = oldBreakpoints[i];
 
-        this.#emit("breakpoint", {
+        this.emitAdapterEvent("breakpoint", {
           reason: "changed",
           breakpoint: {
             ...breakpoint,
@@ -1534,7 +1384,7 @@ export class DebugAdapter extends EventEmitter<DebugAdapterEventMap> implements
       }
     }
 
-    this.#emit("stopped", {
+    this.emitAdapterEvent("stopped", {
       threadId: this.#threadId,
       reason: this.#stopped,
       hitBreakpointIds,
@@ -1551,20 +1401,20 @@ export class DebugAdapter extends EventEmitter<DebugAdapterEventMap> implements
       }
     }
 
-    this.#emit("continued", {
+    this.emitAdapterEvent("continued", {
       threadId: this.#threadId,
     });
   }
 
   ["Process.stdout"](output: string): void {
-    this.#emit("output", {
+    this.emitAdapterEvent("output", {
       category: "debug console",
       output,
     });
   }
 
   ["Process.stderr"](output: string): void {
-    this.#emit("output", {
+    this.emitAdapterEvent("output", {
       category: "debug console",
       output,
     });
@@ -1632,7 +1482,12 @@ export class DebugAdapter extends EventEmitter<DebugAdapterEventMap> implements
   }
 
   #addSource(source: Source): Source {
-    const { sourceId, scriptId, path, sourceReference } = source;
+    let { sourceId, scriptId, path } = source;
+
+    // Normalize the source path
+    if (path) {
+      path = source.path = normalizeSourcePath(path, this.#untitledDocPath, this.#bunEvalPath);
+    }
 
     const oldSource = this.#getSourceIfPresent(sourceId);
     if (oldSource) {
@@ -1643,8 +1498,8 @@ export class DebugAdapter extends EventEmitter<DebugAdapterEventMap> implements
 
       // If the path changed or the source has a source reference,
       // the old source should be marked as removed.
-      if (path !== oldPath || sourceReference) {
-        this.#emit("loadedSource", {
+      if (path !== oldPath /*|| sourceReference*/) {
+        this.emitAdapterEvent("loadedSource", {
           reason: "removed",
           source: oldSource,
         });
@@ -1654,7 +1509,7 @@ export class DebugAdapter extends EventEmitter<DebugAdapterEventMap> implements
     this.#sources.set(sourceId, source);
     this.#sources.set(scriptId, source);
 
-    this.#emit("loadedSource", {
+    this.emitAdapterEvent("loadedSource", {
       // If the reason is "changed", the source will be retrieved using
       // the `source` command, which is why it cannot be set when `path` is present.
       reason: oldSource && !path ? "changed" : "new",
@@ -1704,16 +1559,15 @@ export class DebugAdapter extends EventEmitter<DebugAdapterEventMap> implements
       return source;
     }
 
-    // If the source does not have a path or is a builtin module,
-    // it cannot be retrieved from the file system.
-    if (typeof sourceId === "number" || !path.isAbsolute(sourceId)) {
-      throw new Error(`Source not found: ${sourceId}`);
+    // Normalize the source path before lookup
+    if (typeof sourceId === "string") {
+      sourceId = normalizeSourcePath(sourceId, this.#untitledDocPath, this.#bunEvalPath);
     }
 
     // If the source is not present, it may not have been loaded yet.
-    let resolves = this.#pendingSources.get(sourceId);
+    let resolves = this.#pendingSources.get(sourceId.toString());
     if (!resolves) {
-      this.#pendingSources.set(sourceId, (resolves = []));
+      this.#pendingSources.set(sourceId.toString(), (resolves = []));
     }
 
     return new Promise(resolve => {
@@ -1965,7 +1819,7 @@ export class DebugAdapter extends EventEmitter<DebugAdapterEventMap> implements
     const callFrameId = this.#getCallFrameId(frameId);
     const objectGroup = callFrameId ? "debugger" : "repl";
 
-    const { result, wasThrown } = await this.#evaluate({
+    const { result, wasThrown } = await this.evaluateInternal({
       expression: `${expression} = (${value});`,
       objectGroup: "repl",
       callFrameId,
@@ -2165,12 +2019,11 @@ export class DebugAdapter extends EventEmitter<DebugAdapterEventMap> implements
   }
 
   close(): void {
-    this.#process?.kill();
-    this.#inspector.close();
-    this.#reset();
+    this.inspector.close();
+    this.resetInternal();
   }
 
-  #reset(): void {
+  protected resetInternal(): void {
     this.#pendingSources.clear();
     this.#sources.clear();
     this.#stackFrames.length = 0;
@@ -2181,10 +2034,309 @@ export class DebugAdapter extends EventEmitter<DebugAdapterEventMap> implements
     this.#functionBreakpoints.clear();
     this.#targets.clear();
     this.#variables.clear();
-    this.#options = undefined;
+    this.options = undefined;
   }
 }
 
+/**
+ * Create a debug adapter that connects over a unix/tcp socket. Usually
+ * in the case of a reverse connection. This is used by the vscode extension.
+ *
+ * @warning This will gracefully handle socket closure, you don't need to add extra handling.
+ */
+export class NodeSocketDebugAdapter extends BaseDebugAdapter<NodeSocketInspector> {
+  public constructor(socket: Socket, untitledDocPath?: string, bunEvalPath?: string) {
+    super(new NodeSocketInspector(socket), untitledDocPath, bunEvalPath);
+
+    socket.once("close", () => {
+      this.resetInternal();
+    });
+  }
+
+  protected exitJSProcess(): void {
+    this.evaluateInternal({
+      expression: "process.exit(0)",
+    });
+  }
+
+  public async start() {
+    const ok = await this.inspector.start();
+    return ok;
+  }
+}
+
+/**
+ * The default debug adapter. Connects via WebSocket
+ */
+export class WebSocketDebugAdapter extends BaseDebugAdapter<WebSocketInspector> {
+  #process?: ChildProcess;
+
+  public constructor(url?: string | URL, untitledDocPath?: string, bunEvalPath?: string) {
+    super(new WebSocketInspector(url), untitledDocPath, bunEvalPath);
+  }
+
+  async ["Inspector.disconnected"](error?: Error): Promise<void> {
+    await super["Inspector.disconnected"](error);
+
+    if (this.#process?.exitCode !== null) {
+      this.emitAdapterEvent("terminated");
+    }
+  }
+
+  protected exitJSProcess() {
+    if (!this.#process?.kill()) {
+      this.evaluateInternal({
+        expression: "process.exit(0)",
+      });
+    }
+  }
+
+  /**
+   * Starts the inspector.
+   * @param url the inspector url, will default to the one provided in the constructor (if any). If none
+   * @returns if the inspector was able to connect
+   */
+  start(url?: string): Promise<boolean> {
+    return this.#attach({ url });
+  }
+
+  close() {
+    this.#process?.kill();
+    super.close();
+  }
+
+  async launch(request: DAP.LaunchRequest): Promise<void> {
+    this.options = { ...request, type: "launch" };
+
+    try {
+      await this.#launch(request);
+    } catch (error) {
+      // Some clients, like VSCode, will show a system-level popup when a `launch` request fails.
+      // Instead, we want to show the error as a sidebar notification.
+      const { message } = unknownToError(error);
+
+      this.emitAdapterEvent("output", {
+        category: "stderr",
+        output: `Failed to start debugger.\n${message}`,
+      });
+
+      this.terminate();
+    }
+  }
+
+  async #launch(request: LaunchRequest): Promise<void> {
+    const {
+      runtime = "bun",
+      runtimeArgs = [],
+      program,
+      args = [],
+      cwd,
+      env = {},
+      strictEnv = false,
+      watchMode = false,
+      stopOnEntry = false,
+      __skipValidation = false,
+      stdin,
+    } = request;
+
+    if (!__skipValidation && !program) {
+      throw new Error("No program specified");
+    }
+
+    const processArgs = [...runtimeArgs];
+
+    if (program === "-" && stdin) {
+      processArgs.push("--eval", stdin);
+    } else if (program) {
+      processArgs.push(program);
+    }
+
+    processArgs.push(...args);
+
+    if (program && isTestJavaScript(program) && !runtimeArgs.includes("test")) {
+      processArgs.unshift("test");
+    }
+
+    if (watchMode && !runtimeArgs.includes("--watch") && !runtimeArgs.includes("--hot")) {
+      processArgs.unshift(watchMode === "hot" ? "--hot" : "--watch");
+    }
+
+    const processEnv = strictEnv
+      ? {
+          ...env,
+        }
+      : {
+          ...process.env,
+          ...env,
+        };
+
+    if (process.platform !== "win32") {
+      // we're on unix
+      const url = `ws+unix://${randomUnixPath()}`;
+      const signal = new UnixSignal();
+
+      signal.on("Signal.received", () => {
+        this.#attach({ url });
+      });
+
+      this.once("Adapter.terminated", () => {
+        signal.close();
+      });
+
+      const query = stopOnEntry ? "break=1" : "wait=1";
+      processEnv["BUN_INSPECT"] = `${url}?${query}`;
+      processEnv["BUN_INSPECT_NOTIFY"] = signal.url;
+
+      // This is probably not correct, but it's the best we can do for now.
+      processEnv["FORCE_COLOR"] = "1";
+      processEnv["BUN_QUIET_DEBUG_LOGS"] = "1";
+      processEnv["BUN_DEBUG_QUIET_LOGS"] = "1";
+
+      const started = await this.#spawn({
+        command: runtime,
+        args: processArgs,
+        env: processEnv,
+        cwd,
+        isDebugee: true,
+      });
+
+      if (!started) {
+        throw new Error("Program could not be started.");
+      }
+    } else {
+      // we're on windows
+      // Create TCPSocketSignal
+      const url = `ws://127.0.0.1:${await getAvailablePort()}/${getRandomId()}`; // 127.0.0.1 so it resolves correctly on windows
+      const signal = new TCPSocketSignal(await getAvailablePort());
+
+      signal.on("Signal.received", async () => {
+        this.#attach({ url });
+      });
+
+      this.once("Adapter.terminated", () => {
+        signal.close();
+      });
+
+      const query = stopOnEntry ? "break=1" : "wait=1";
+      processEnv["BUN_INSPECT"] = `${url}?${query}`;
+      processEnv["BUN_INSPECT_NOTIFY"] = signal.url; // 127.0.0.1 so it resolves correctly on windows
+
+      // This is probably not correct, but it's the best we can do for now.
+      processEnv["FORCE_COLOR"] = "1";
+      processEnv["BUN_QUIET_DEBUG_LOGS"] = "1";
+      processEnv["BUN_DEBUG_QUIET_LOGS"] = "1";
+
+      const started = await this.#spawn({
+        command: runtime,
+        args: processArgs,
+        env: processEnv,
+        cwd,
+        isDebugee: true,
+      });
+
+      if (!started) {
+        throw new Error("Program could not be started.");
+      }
+    }
+  }
+
+  async #spawn(options: {
+    command: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+    isDebugee?: boolean;
+  }): Promise<boolean> {
+    const { command, args = [], cwd, env, isDebugee } = options;
+    const request = { command, args, cwd, env };
+    this.emit("Process.requested", request);
+
+    let subprocess: ChildProcess;
+    try {
+      subprocess = spawn(command, args, {
+        ...request,
+        stdio: ["ignore", "pipe", "pipe"],
+      });
+    } catch (cause) {
+      this.emit("Process.exited", new Error("Failed to spawn process", { cause }), null);
+      return false;
+    }
+
+    subprocess.on("spawn", () => {
+      this.emit("Process.spawned", subprocess);
+
+      if (isDebugee) {
+        this.#process = subprocess;
+        this.emitAdapterEvent("process", {
+          name: `${command} ${args.join(" ")}`,
+          systemProcessId: subprocess.pid,
+          isLocalProcess: true,
+          startMethod: "launch",
+        });
+      }
+    });
+
+    subprocess.on("exit", (code, signal) => {
+      this.emit("Process.exited", code, signal);
+
+      if (isDebugee) {
+        this.#process = undefined;
+        this.emitAdapterEvent("exited", {
+          exitCode: code ?? -1,
+        });
+        this.emitAdapterEvent("terminated");
+      }
+    });
+
+    subprocess.stdout?.on("data", data => {
+      this.emit("Process.stdout", data.toString());
+    });
+
+    subprocess.stderr?.on("data", data => {
+      this.emit("Process.stderr", data.toString());
+    });
+
+    return new Promise(resolve => {
+      subprocess.on("spawn", () => resolve(true));
+      subprocess.on("exit", () => resolve(false));
+      subprocess.on("error", () => resolve(false));
+    });
+  }
+
+  async attach(request: AttachRequest): Promise<void> {
+    this.options = { ...request, type: "attach" };
+
+    try {
+      await this.#attach(request);
+    } catch (error) {
+      // Some clients, like VSCode, will show a system-level popup when a `launch` request fails.
+      // Instead, we want to show the error as a sidebar notification.
+      const { message } = unknownToError(error);
+      this.emitAdapterEvent("output", {
+        category: "stderr",
+        output: `Failed to start debugger.\n${message}`,
+      });
+      this.terminate();
+    }
+  }
+
+  async #attach(request: AttachRequest): Promise<boolean> {
+    const { url } = request;
+
+    for (let i = 0; i < 3; i++) {
+      const ok = await this.inspector.start(url);
+      if (ok) {
+        return true;
+      }
+      await new Promise(resolve => setTimeout(resolve, 100 * i));
+    }
+
+    return false;
+  }
+}
+
+export const DebugAdapter = WebSocketDebugAdapter;
+
 function stoppedReason(reason: JSC.Debugger.PausedEvent["reason"]): DAP.StoppedEvent["reason"] {
   switch (reason) {
     case "Breakpoint":
diff --git a/packages/bun-debug-adapter-protocol/src/debugger/node-socket-framer.ts b/packages/bun-debug-adapter-protocol/src/debugger/node-socket-framer.ts
new file mode 100644
index 0000000000..3d0efa181b
--- /dev/null
+++ b/packages/bun-debug-adapter-protocol/src/debugger/node-socket-framer.ts
@@ -0,0 +1,117 @@
+import type { Socket } from "node:net";
+const enum FramerState {
+  WaitingForLength,
+  WaitingForMessage,
+}
+
+let socketFramerMessageLengthBuffer: Buffer;
+export class SocketFramer {
+  state: FramerState = FramerState.WaitingForLength;
+  pendingLength: number = 0;
+  sizeBuffer: Buffer = Buffer.alloc(4);
+  sizeBufferIndex: number = 0;
+  bufferedData: Buffer = Buffer.alloc(0);
+  socket: Socket;
+  private onMessage: (message: string | string[]) => void;
+
+  constructor(socket: Socket, onMessage: (message: string | string[]) => void) {
+    this.socket = socket;
+    this.onMessage = onMessage;
+
+    if (!socketFramerMessageLengthBuffer) {
+      socketFramerMessageLengthBuffer = Buffer.alloc(4);
+    }
+
+    this.reset();
+  }
+
+  reset(): void {
+    this.state = FramerState.WaitingForLength;
+    this.bufferedData = Buffer.alloc(0);
+    this.sizeBufferIndex = 0;
+    this.sizeBuffer = Buffer.alloc(4);
+  }
+
+  send(data: string): void {
+    socketFramerMessageLengthBuffer.writeUInt32BE(data.length, 0);
+    this.socket.write(socketFramerMessageLengthBuffer);
+    this.socket.write(data);
+  }
+
+  onData(data: Buffer): void {
+    this.bufferedData = this.bufferedData.length > 0 ? Buffer.concat([this.bufferedData, data]) : data;
+
+    let messagesToDeliver: string[] = [];
+    let position = 0;
+
+    while (position < this.bufferedData.length) {
+      // Need 4 bytes for the length
+      if (this.bufferedData.length - position < 4) {
+        break;
+      }
+
+      // Read the length prefix
+      const messageLength = this.bufferedData.readUInt32BE(position);
+
+      // Validate message length
+      if (messageLength <= 0 || messageLength > 1024 * 1024) {
+        // 1MB max
+        // Try to resync by looking for the next valid message
+        let newPosition = position + 1;
+        let found = false;
+
+        while (newPosition < this.bufferedData.length - 4) {
+          const testLength = this.bufferedData.readUInt32BE(newPosition);
+
+          if (testLength > 0 && testLength <= 1024 * 1024) {
+            // Verify we can read the full message
+            if (this.bufferedData.length - newPosition - 4 >= testLength) {
+              const testMessage = this.bufferedData.toString("utf-8", newPosition + 4, newPosition + 4 + testLength);
+
+              if (testMessage.startsWith('{"')) {
+                position = newPosition;
+                found = true;
+                break;
+              }
+            }
+          }
+
+          newPosition++;
+        }
+
+        if (!found) {
+          // Couldn't find a valid message, discard buffer up to this point
+          this.bufferedData = this.bufferedData.slice(position + 4);
+          return;
+        }
+
+        continue;
+      }
+
+      // Check if we have the complete message
+      if (this.bufferedData.length - position - 4 < messageLength) {
+        break;
+      }
+
+      const message = this.bufferedData.toString("utf-8", position + 4, position + 4 + messageLength);
+      if (message.startsWith('{"')) {
+        messagesToDeliver.push(message);
+      }
+
+      position += 4 + messageLength;
+    }
+
+    if (position > 0) {
+      this.bufferedData =
+        position < this.bufferedData.length ? this.bufferedData.slice(position) : SocketFramer.emptyBuffer;
+    }
+
+    if (messagesToDeliver.length === 1) {
+      this.onMessage(messagesToDeliver[0]);
+    } else if (messagesToDeliver.length > 1) {
+      this.onMessage(messagesToDeliver);
+    }
+  }
+
+  private static emptyBuffer = Buffer.from([]);
+}
diff --git a/packages/bun-debug-adapter-protocol/src/debugger/signal.ts b/packages/bun-debug-adapter-protocol/src/debugger/signal.ts
index db2b029a97..ef2dd6bc6b 100644
--- a/packages/bun-debug-adapter-protocol/src/debugger/signal.ts
+++ b/packages/bun-debug-adapter-protocol/src/debugger/signal.ts
@@ -11,6 +11,8 @@ export type UnixSignalEventMap = {
   "Signal.error": [Error];
   "Signal.received": [string];
   "Signal.closed": [];
+  "Signal.Socket.closed": [socket: Socket];
+  "Signal.Socket.connect": [socket: Socket];
 };
 
 /**
@@ -21,7 +23,7 @@ export class UnixSignal extends EventEmitter<UnixSignalEventMap> {
   #server: Server;
   #ready: Promise<void>;
 
-  constructor(path?: string | URL) {
+  constructor(path?: string | URL | undefined) {
     super();
     this.#path = path ? parseUnixPath(path) : randomUnixPath();
     this.#server = createServer();
@@ -29,9 +31,13 @@ export class UnixSignal extends EventEmitter<UnixSignalEventMap> {
     this.#server.on("error", error => this.emit("Signal.error", error));
     this.#server.on("close", () => this.emit("Signal.closed"));
     this.#server.on("connection", socket => {
+      this.emit("Signal.Socket.connect", socket);
       socket.on("data", data => {
         this.emit("Signal.received", data.toString());
       });
+      socket.on("close", () => {
+        this.emit("Signal.Socket.closed", socket);
+      });
     });
     this.#ready = new Promise((resolve, reject) => {
       this.#server.on("listening", resolve);
@@ -45,7 +51,7 @@ export class UnixSignal extends EventEmitter<UnixSignalEventMap> {
       console.log(event, ...args);
     }
 
-    return super.emit(event, ...args);
+    return super.emit(event, ...(args as never));
   }
 
   /**
@@ -91,6 +97,8 @@ export type TCPSocketSignalEventMap = {
   "Signal.error": [Error];
   "Signal.closed": [];
   "Signal.received": [string];
+  "Signal.Socket.closed": [socket: Socket];
+  "Signal.Socket.connect": [socket: Socket];
 };
 
 export class TCPSocketSignal extends EventEmitter {
@@ -103,6 +111,8 @@ export class TCPSocketSignal extends EventEmitter {
     this.#port = port;
 
     this.#server = createServer((socket: Socket) => {
+      this.emit("Signal.Socket.connect", socket);
+
       socket.on("data", data => {
         this.emit("Signal.received", data.toString());
       });
@@ -112,10 +122,14 @@ export class TCPSocketSignal extends EventEmitter {
       });
 
       socket.on("close", () => {
-        this.emit("Signal.closed");
+        this.emit("Signal.Socket.closed", socket);
       });
     });
 
+    this.#server.on("close", () => {
+      this.emit("Signal.closed");
+    });
+
     this.#ready = new Promise((resolve, reject) => {
       this.#server.listen(this.#port, () => {
         this.emit("Signal.listening");
diff --git a/packages/bun-debug-adapter-protocol/src/debugger/sourcemap.test.ts b/packages/bun-debug-adapter-protocol/src/debugger/sourcemap.test.ts
index fa3eba0eb4..b050fa4a68 100644
--- a/packages/bun-debug-adapter-protocol/src/debugger/sourcemap.test.ts
+++ b/packages/bun-debug-adapter-protocol/src/debugger/sourcemap.test.ts
@@ -1,6 +1,6 @@
 import { expect, test } from "bun:test";
 import { readFileSync } from "node:fs";
-import { SourceMap } from "./sourcemap";
+import { SourceMap } from "./sourcemap.js";
 
 test("works without source map", () => {
   const sourceMap = getSourceMap("without-sourcemap.js");
diff --git a/packages/bun-debug-adapter-protocol/src/debugger/sourcemap.ts b/packages/bun-debug-adapter-protocol/src/debugger/sourcemap.ts
index cae0eb5260..57fca12720 100644
--- a/packages/bun-debug-adapter-protocol/src/debugger/sourcemap.ts
+++ b/packages/bun-debug-adapter-protocol/src/debugger/sourcemap.ts
@@ -21,7 +21,15 @@ export type Location = {
 );
 
 export interface SourceMap {
+  /**
+   * Converts a location in the original source to a location in the generated source.
+   * @param request A request
+   */
   generatedLocation(request: LocationRequest): Location;
+  /**
+   * Converts a location in the generated source to a location in the original source.
+   * @param request A request
+   */
   originalLocation(request: LocationRequest): Location;
 }
 
diff --git a/packages/bun-debug-adapter-protocol/tsconfig.json b/packages/bun-debug-adapter-protocol/tsconfig.json
index 3b3c098f31..9f1006bc35 100644
--- a/packages/bun-debug-adapter-protocol/tsconfig.json
+++ b/packages/bun-debug-adapter-protocol/tsconfig.json
@@ -1,13 +1,13 @@
 {
   "compilerOptions": {
     "lib": ["ESNext"],
-    "module": "esnext",
+    "module": "NodeNext",
     "target": "esnext",
     "moduleResolution": "nodenext",
     "moduleDetection": "force",
     "allowImportingTsExtensions": true,
     "noEmit": true,
-    "composite": true,
+    // "composite": true,
     "strict": true,
     "downlevelIteration": true,
     "skipLibCheck": true,
@@ -15,7 +15,7 @@
     "forceConsistentCasingInFileNames": true,
     "inlineSourceMap": true,
     "allowJs": true,
-    "outDir": "dist",
+    "outDir": "dist"
   },
-  "include": ["src", "scripts", "../bun-types/index.d.ts", "../bun-inspector-protocol/src"]
+  "include": ["src", "scripts", "../bun-types/index.d.ts", "../bun-inspector-protocol/**/*.ts"]
 }
diff --git a/packages/bun-inspector-protocol/index.ts b/packages/bun-inspector-protocol/index.ts
index 21951bd4cb..117d224d65 100644
--- a/packages/bun-inspector-protocol/index.ts
+++ b/packages/bun-inspector-protocol/index.ts
@@ -1,4 +1,4 @@
-export type * from "./src/inspector";
-export * from "./src/inspector/websocket";
-export type * from "./src/protocol";
-export * from "./src/util/preview";
+export type * from "./src/inspector/index.js";
+export * from "./src/inspector/websocket.js";
+export type * from "./src/protocol/index.js";
+export * from "./src/util/preview.js";
diff --git a/packages/bun-inspector-protocol/scripts/generate-protocol.ts b/packages/bun-inspector-protocol/scripts/generate-protocol.ts
index 968796059c..65c2976715 100644
--- a/packages/bun-inspector-protocol/scripts/generate-protocol.ts
+++ b/packages/bun-inspector-protocol/scripts/generate-protocol.ts
@@ -1,26 +1,7 @@
 import { spawnSync } from "node:child_process";
-import { readFileSync, writeFileSync } from "node:fs";
+import { readFileSync, writeFileSync, realpathSync } from "node:fs";
 import type { Domain, Property, Protocol } from "../src/protocol/schema";
-
-run().catch(console.error);
-
-async function run() {
-  const cwd = new URL("../src/protocol/", import.meta.url);
-  const runner = "Bun" in globalThis ? "bunx" : "npx";
-  const write = (name: string, data: string) => {
-    const path = new URL(name, cwd);
-    writeFileSync(path, data);
-    spawnSync(runner, ["prettier", "--write", path.pathname], { cwd, stdio: "ignore" });
-  };
-  const base = readFileSync(new URL("protocol.d.ts", cwd), "utf-8");
-  const baseNoComments = base.replace(/\/\/.*/g, "");
-  const jsc = await downloadJsc();
-  write("jsc/protocol.json", JSON.stringify(jsc));
-  write("jsc/index.d.ts", "// GENERATED - DO NOT EDIT\n" + formatProtocol(jsc, baseNoComments));
-  const v8 = await downloadV8();
-  write("v8/protocol.json", JSON.stringify(v8));
-  write("v8/index.d.ts", "// GENERATED - DO NOT EDIT\n" + formatProtocol(v8, baseNoComments));
-}
+import path from "node:path";
 
 function formatProtocol(protocol: Protocol, extraTs?: string): string {
   const { name, domains } = protocol;
@@ -29,6 +10,7 @@ function formatProtocol(protocol: Protocol, extraTs?: string): string {
   let body = `export namespace ${name} {`;
   for (const { domain, types = [], events = [], commands = [] } of domains) {
     body += `export namespace ${domain} {`;
+
     for (const type of types) {
       body += formatProperty(type);
     }
@@ -153,32 +135,12 @@ async function downloadV8(): Promise<Protocol> {
   }));
 }
 
-/**
- * @link https://github.com/WebKit/WebKit/tree/main/Source/JavaScriptCore/inspector/protocol
- */
-async function downloadJsc(): Promise<Protocol> {
-  const baseUrl = "https://raw.githubusercontent.com/WebKit/WebKit/main/Source/JavaScriptCore/inspector/protocol";
-  const domains = [
-    "Runtime",
-    "Console",
-    "Debugger",
-    "Heap",
-    "ScriptProfiler",
-    "CPUProfiler",
-    "GenericTypes",
-    "Network",
-    "Inspector",
-  ];
-  return {
-    name: "JSC",
-    version: {
-      major: 1,
-      minor: 3,
-    },
-    domains: await Promise.all(domains.map(domain => download<Domain>(`${baseUrl}/${domain}.json`))).then(domains =>
-      domains.sort((a, b) => a.domain.localeCompare(b.domain)),
-    ),
-  };
+async function getJSC(): Promise<Protocol> {
+  let bunExecutable = Bun.which("bun-debug") || process.execPath;
+  if (!bunExecutable) {
+    throw new Error("bun-debug not found");
+  }
+  bunExecutable = realpathSync(bunExecutable);
 }
 
 async function download<V>(url: string): Promise<V> {
@@ -200,3 +162,39 @@ function toComment(description?: string): string {
   const lines = ["/**", ...description.split("\n").map(line => ` * ${line.trim()}`), "*/"];
   return lines.join("\n");
 }
+
+const cwd = new URL("../src/protocol/", import.meta.url);
+const runner = "Bun" in globalThis ? "bunx" : "npx";
+const write = (name: string, data: string) => {
+  const filePath = path.resolve(__dirname, "..", "src", "protocol", name);
+  writeFileSync(filePath, data);
+  spawnSync(runner, ["prettier", "--write", filePath], { cwd, stdio: "ignore" });
+};
+const base = readFileSync(new URL("protocol.d.ts", cwd), "utf-8");
+const baseNoComments = base.replace(/\/\/.*/g, "");
+
+const jscJsonFile = path.resolve(__dirname, process.argv.at(-1) ?? "");
+let jscJSONFile;
+try {
+  jscJSONFile = await Bun.file(jscJsonFile).json();
+} catch (error) {
+  console.warn("Failed to read CombinedDomains.json from WebKit build. Is this a WebKit build from Bun?");
+  console.error(error);
+  process.exit(1);
+}
+
+const jsc = {
+  name: "JSC",
+  version: {
+    major: 1,
+    minor: 4,
+  },
+  domains: jscJSONFile.domains
+    .filter(a => a.debuggableTypes?.includes?.("javascript"))
+    .sort((a, b) => a.domain.localeCompare(b.domain)),
+};
+write("jsc/protocol.json", JSON.stringify(jsc, null, 2));
+write("jsc/index.d.ts", "// GENERATED - DO NOT EDIT\n" + formatProtocol(jsc, baseNoComments));
+const v8 = await downloadV8();
+write("v8/protocol.json", JSON.stringify(v8));
+write("v8/index.d.ts", "// GENERATED - DO NOT EDIT\n" + formatProtocol(v8, baseNoComments));
diff --git a/packages/bun-inspector-protocol/src/inspector/node-socket.ts b/packages/bun-inspector-protocol/src/inspector/node-socket.ts
new file mode 100644
index 0000000000..06bac6ac3c
--- /dev/null
+++ b/packages/bun-inspector-protocol/src/inspector/node-socket.ts
@@ -0,0 +1,235 @@
+import { EventEmitter } from "node:events";
+import { Socket } from "node:net";
+import { SocketFramer } from "../../../bun-debug-adapter-protocol/src/debugger/node-socket-framer.js";
+import type { JSC } from "../protocol";
+import type { Inspector, InspectorEventMap } from "./index";
+
+/**
+ * An inspector that communicates with a debugger over a (unix) socket.
+ * This is used in the extension as follows:
+ *
+ * 1. Extension sets environment variable `BUN_INSPECT_NOTIFY` inside of all vscode terminals.
+ *    This is a path to a unix socket that the extension will listen on.
+ * 2. Bun reads it and connects to the socket, setting up a reverse connection for sending DAP
+ *    messages.
+ */
+export class NodeSocketInspector extends EventEmitter<InspectorEventMap> implements Inspector {
+  #ready: Promise<boolean> | undefined;
+  #socket: Socket;
+  #requestId: number;
+  #pendingRequests: JSC.Request[];
+  #pendingResponses: Map<
+    number,
+    {
+      request: JSC.Request;
+      done: (result: unknown) => void;
+    }
+  >;
+  #framer: SocketFramer;
+
+  constructor(socket: Socket) {
+    super();
+    this.#socket = socket;
+    this.#requestId = 1;
+    this.#pendingRequests = [];
+    this.#pendingResponses = new Map();
+
+    this.#framer = new SocketFramer(socket, message => {
+      if (Array.isArray(message)) {
+        for (const m of message) {
+          this.#accept(m);
+        }
+      } else {
+        this.#accept(message);
+      }
+    });
+  }
+
+  private onConnectOrImmediately(cb: () => void) {
+    const isAlreadyConnected = this.#socket.connecting === false;
+
+    if (isAlreadyConnected) {
+      cb();
+    } else {
+      this.#socket.once("connect", cb);
+    }
+  }
+
+  async start(): Promise<boolean> {
+    if (this.#ready) {
+      return this.#ready;
+    }
+
+    if (this.closed) {
+      this.close();
+      const addressWithPort = this.#socket.remoteAddress + ":" + this.#socket.remotePort;
+      this.emit("Inspector.connecting", addressWithPort);
+    }
+
+    const socket = this.#socket;
+
+    this.onConnectOrImmediately(() => {
+      this.emit("Inspector.connected");
+
+      for (let i = 0; i < this.#pendingRequests.length; i++) {
+        const request = this.#pendingRequests[i];
+
+        if (this.#send(request)) {
+          this.emit("Inspector.request", request);
+        } else {
+          this.#pendingRequests = this.#pendingRequests.slice(i);
+          break;
+        }
+      }
+    });
+
+    socket.on("data", data => this.#framer.onData(data));
+
+    socket.on("error", error => {
+      this.#close(unknownToError(error));
+    });
+
+    socket.on("close", hadError => {
+      if (hadError) {
+        this.#close(new Error("Socket closed due to a transmission error"));
+      } else {
+        this.#close();
+      }
+    });
+
+    const ready = new Promise<boolean>(resolve => {
+      if (socket.connecting) {
+        socket.on("connect", () => resolve(true));
+      } else {
+        resolve(true);
+      }
+      socket.on("close", () => resolve(false));
+      socket.on("error", () => resolve(false));
+    }).finally(() => {
+      this.#ready = undefined;
+    });
+
+    this.#ready = ready;
+
+    return ready;
+  }
+
+  send<M extends keyof JSC.RequestMap & keyof JSC.ResponseMap>(
+    method: M,
+    params?: JSC.RequestMap[M] | undefined,
+  ): Promise<JSC.ResponseMap[M]> {
+    const id = this.#requestId++;
+    const request = {
+      id,
+      method,
+      params: params ?? {},
+    };
+
+    return new Promise((resolve, reject) => {
+      let timerId: number | undefined;
+      const done = (result: any) => {
+        this.#pendingResponses.delete(id);
+        if (timerId) {
+          clearTimeout(timerId);
+        }
+        if (result instanceof Error) {
+          reject(result);
+        } else {
+          resolve(result);
+        }
+      };
+
+      this.#pendingResponses.set(id, {
+        request: request,
+        done: done,
+      });
+
+      if (this.#send(request)) {
+        timerId = +setTimeout(() => done(new Error(`Timed out: ${method}`)), 10_000);
+        this.emit("Inspector.request", request);
+      } else {
+        this.emit("Inspector.pendingRequest", request);
+      }
+    });
+  }
+
+  #send(request: JSC.Request): boolean {
+    this.#framer.send(JSON.stringify(request));
+
+    if (!this.#pendingRequests.includes(request)) {
+      this.#pendingRequests.push(request);
+    }
+
+    return false;
+  }
+
+  #accept(message: string): void {
+    let data: JSC.Event | JSC.Response;
+    try {
+      data = JSON.parse(message);
+    } catch (cause) {
+      this.emit("Inspector.error", new Error(`Failed to parse message: ${message}`, { cause }));
+      return;
+    }
+
+    if (!("id" in data)) {
+      this.emit("Inspector.event", data);
+      const { method, params } = data;
+      this.emit(method, params);
+      return;
+    }
+
+    this.emit("Inspector.response", data);
+
+    const { id } = data;
+    const handle = this.#pendingResponses.get(id);
+    if (!handle) {
+      this.emit("Inspector.error", new Error(`Failed to find matching request for ID: ${id}`));
+      return;
+    }
+
+    if ("error" in data) {
+      const { error } = data;
+      const { message } = error;
+      handle.done(new Error(message));
+    } else {
+      const { result } = data;
+      handle.done(result);
+    }
+  }
+
+  get closed(): boolean {
+    return !this.#socket.writable;
+  }
+
+  close(): void {
+    this.#socket?.end();
+  }
+
+  #close(error?: Error): void {
+    for (const handle of this.#pendingResponses.values()) {
+      handle.done(error ?? new Error("Socket closed while waiting for: " + handle.request.method));
+    }
+
+    this.#pendingResponses.clear();
+
+    if (error) {
+      this.emit("Inspector.error", error);
+    }
+
+    this.emit("Inspector.disconnected", error);
+  }
+}
+
+function unknownToError(input: unknown): Error {
+  if (input instanceof Error) {
+    return input;
+  }
+
+  if (typeof input === "object" && input !== null && "message" in input) {
+    const { message } = input;
+    return new Error(`${message}`);
+  }
+
+  return new Error(`${input}`);
+}
diff --git a/packages/bun-inspector-protocol/src/inspector/websocket.ts b/packages/bun-inspector-protocol/src/inspector/websocket.ts
index e20ebe2a1a..08be605378 100644
--- a/packages/bun-inspector-protocol/src/inspector/websocket.ts
+++ b/packages/bun-inspector-protocol/src/inspector/websocket.ts
@@ -1,7 +1,7 @@
 import { EventEmitter } from "node:events";
 import { WebSocket } from "ws";
-import type { Inspector, InspectorEventMap } from ".";
 import type { JSC } from "../protocol";
+import type { Inspector, InspectorEventMap } from "./index";
 
 /**
  * An inspector that communicates with a debugger over a WebSocket.
@@ -170,6 +170,7 @@ export class WebSocketInspector extends EventEmitter<InspectorEventMap> implemen
 
   #accept(message: string): void {
     let data: JSC.Event | JSC.Response;
+
     try {
       data = JSON.parse(message);
     } catch (cause) {
diff --git a/packages/bun-inspector-protocol/src/protocol/jsc/index.d.ts b/packages/bun-inspector-protocol/src/protocol/jsc/index.d.ts
index bf9f280e45..cc731f116a 100644
--- a/packages/bun-inspector-protocol/src/protocol/jsc/index.d.ts
+++ b/packages/bun-inspector-protocol/src/protocol/jsc/index.d.ts
@@ -1,5 +1,60 @@
 // GENERATED - DO NOT EDIT
 export namespace JSC {
+  export namespace Audit {
+    /**
+     * Creates the `WebInspectorAudit` object that is passed to run. Must call teardown before calling setup more than once.
+     * @request `Audit.setup`
+     */
+    export type SetupRequest = {
+      /**
+       * Specifies in which isolated context to run the test. Each content script lives in an isolated context and this parameter may be used to specify one of those contexts. If the parameter is omitted or 0 the evaluation will be performed in the context of the inspected page.
+       */
+      contextId?: Runtime.ExecutionContextId | undefined;
+    };
+    /**
+     * Creates the `WebInspectorAudit` object that is passed to run. Must call teardown before calling setup more than once.
+     * @response `Audit.setup`
+     */
+    export type SetupResponse = {};
+    /**
+     * Parses and evaluates the given test string and sends back the result. Returned values are saved to the "audit" object group. Call setup before and teardown after if the `WebInspectorAudit` object should be passed into the test.
+     * @request `Audit.run`
+     */
+    export type RunRequest = {
+      /**
+       * Test string to parse and evaluate.
+       */
+      test: string;
+      /**
+       * Specifies in which isolated context to run the test. Each content script lives in an isolated context and this parameter may be used to specify one of those contexts. If the parameter is omitted or 0 the evaluation will be performed in the context of the inspected page.
+       */
+      contextId?: Runtime.ExecutionContextId | undefined;
+    };
+    /**
+     * Parses and evaluates the given test string and sends back the result. Returned values are saved to the "audit" object group. Call setup before and teardown after if the `WebInspectorAudit` object should be passed into the test.
+     * @response `Audit.run`
+     */
+    export type RunResponse = {
+      /**
+       * Evaluation result.
+       */
+      result: Runtime.RemoteObject;
+      /**
+       * True if the result was thrown during the evaluation.
+       */
+      wasThrown?: boolean | undefined;
+    };
+    /**
+     * Destroys the `WebInspectorAudit` object that is passed to run. Must call setup before calling teardown.
+     * @request `Audit.teardown`
+     */
+    export type TeardownRequest = {};
+    /**
+     * Destroys the `WebInspectorAudit` object that is passed to run. Must call setup before calling teardown.
+     * @response `Audit.teardown`
+     */
+    export type TeardownResponse = {};
+  }
   export namespace Console {
     /**
      * Channels for different types of log messages.
@@ -29,7 +84,7 @@ export namespace JSC {
     /**
      * The reason the console is being cleared.
      */
-    export type ClearReason = "console-api" | "main-frame-navigation";
+    export type ClearReason = "console-api" | "frontend" | "main-frame-navigation";
     /**
      * Logging channel.
      */
@@ -224,6 +279,18 @@ export namespace JSC {
      * @response `Console.clearMessages`
      */
     export type ClearMessagesResponse = {};
+    /**
+     * Control whether calling <code>console.clear()</code> has an effect in Web Inspector. Defaults to true.
+     * @request `Console.setConsoleClearAPIEnabled`
+     */
+    export type SetConsoleClearAPIEnabledRequest = {
+      enable: boolean;
+    };
+    /**
+     * Control whether calling <code>console.clear()</code> has an effect in Web Inspector. Defaults to true.
+     * @response `Console.setConsoleClearAPIEnabled`
+     */
+    export type SetConsoleClearAPIEnabledResponse = {};
     /**
      * List of the different message sources that are non-default logging channels.
      * @request `Console.getLoggingChannels`
@@ -259,81 +326,6 @@ export namespace JSC {
      */
     export type SetLoggingChannelLevelResponse = {};
   }
-  export namespace CPUProfiler {
-    /**
-     * CPU usage for an individual thread.
-     */
-    export type ThreadInfo = {
-      /**
-       * Some thread identification information.
-       */
-      name: string;
-      /**
-       * CPU usage for this thread. This should not exceed 100% for an individual thread.
-       */
-      usage: number;
-      /**
-       * Type of thread. There should be a single main thread.
-       */
-      type?: "main" | "webkit" | undefined;
-      /**
-       * A thread may be associated with a target, such as a Worker, in the process.
-       */
-      targetId?: string | undefined;
-    };
-    export type Event = {
-      timestamp: number;
-      /**
-       * Percent of total cpu usage. If there are multiple cores the usage may be greater than 100%.
-       */
-      usage: number;
-      /**
-       * Per-thread CPU usage information. Does not include the main thread.
-       */
-      threads?: ThreadInfo[] | undefined;
-    };
-    /**
-     * Tracking started.
-     * @event `CPUProfiler.trackingStart`
-     */
-    export type TrackingStartEvent = {
-      timestamp: number;
-    };
-    /**
-     * Periodic tracking updates with event data.
-     * @event `CPUProfiler.trackingUpdate`
-     */
-    export type TrackingUpdateEvent = {
-      event: Event;
-    };
-    /**
-     * Tracking stopped.
-     * @event `CPUProfiler.trackingComplete`
-     */
-    export type TrackingCompleteEvent = {
-      timestamp: number;
-    };
-    /**
-     * Start tracking cpu usage.
-     * @request `CPUProfiler.startTracking`
-     */
-    export type StartTrackingRequest = {};
-    /**
-     * Start tracking cpu usage.
-     * @response `CPUProfiler.startTracking`
-     */
-    export type StartTrackingResponse = {};
-    /**
-     * Stop tracking cpu usage. This will produce a `trackingComplete` event.
-     * @request `CPUProfiler.stopTracking`
-     */
-    export type StopTrackingRequest = {};
-    /**
-     * Stop tracking cpu usage. This will produce a `trackingComplete` event.
-     * @response `CPUProfiler.stopTracking`
-     */
-    export type StopTrackingResponse = {};
-  }
   export namespace Debugger {
     /**
      * Breakpoint identifier.
@@ -1192,23 +1184,27 @@ export namespace JSC {
       savedResultIndex?: number | undefined;
     };
     /**
-     * Sets whether the given URL should be in the list of blackboxed scripts, which are ignored when pausing/stepping/debugging.
+     * Sets whether the given URL should be in the list of blackboxed scripts, which are ignored when pausing.
      * @request `Debugger.setShouldBlackboxURL`
      */
     export type SetShouldBlackboxURLRequest = {
       url: string;
       shouldBlackbox: boolean;
       /**
-       * If true, <code>url</code> is case sensitive.
+       * If <code>true</code>, <code>url</code> is case sensitive.
        */
       caseSensitive?: boolean | undefined;
       /**
-       * If true, treat <code>url</code> as regular expression.
+       * If <code>true</code>, treat <code>url</code> as regular expression.
        */
       isRegex?: boolean | undefined;
+      /**
+       * If provided, limits where in the script the debugger will skip pauses. Expected structure is a repeated <code>[startLine, startColumn, endLine, endColumn]</code>. Ignored if <code>shouldBlackbox</code> is <code>false</code>.
+       */
+      sourceRanges?: number[] | undefined;
     };
     /**
-     * Sets whether the given URL should be in the list of blackboxed scripts, which are ignored when pausing/stepping/debugging.
+     * Sets whether the given URL should be in the list of blackboxed scripts, which are ignored when pausing.
      * @response `Debugger.setShouldBlackboxURL`
      */
     export type SetShouldBlackboxURLResponse = {};
@@ -1225,21 +1221,6 @@ export namespace JSC {
      */
     export type SetBlackboxBreakpointEvaluationsResponse = {};
   }
-  export namespace GenericTypes {
-    /**
-     * Search match in a resource.
-     */
-    export type SearchMatch = {
-      /**
-       * Line number in resource content.
-       */
-      lineNumber: number;
-      /**
-       * Line with match content.
-       */
-      lineContent: string;
-    };
-  }
   export namespace Heap {
     /**
      * Information about a garbage collection.
@@ -1448,1006 +1429,78 @@ export namespace JSC {
      */
     export type InitializedResponse = {};
   }
-  export namespace Network {
+  export namespace LifecycleReporter {
     /**
-     * Unique loader identifier.
+     * undefined
+     * @event `LifecycleReporter.reload`
      */
-    export type LoaderId = string;
+    export type ReloadEvent = {};
     /**
-     * Unique frame identifier.
+     * undefined
+     * @event `LifecycleReporter.error`
      */
-    export type FrameId = string;
-    /**
-     * Unique request identifier.
-     */
-    export type RequestId = string;
-    /**
-     * Elapsed seconds since frontend connected.
-     */
-    export type Timestamp = number;
-    /**
-     * Number of seconds since epoch.
-     */
-    export type Walltime = number;
-    /**
-     * Controls how much referrer information is sent with the request
-     */
-    export type ReferrerPolicy =
-      | "empty-string"
-      | "no-referrer"
-      | "no-referrer-when-downgrade"
-      | "same-origin"
-      | "origin"
-      | "strict-origin"
-      | "origin-when-cross-origin"
-      | "strict-origin-when-cross-origin"
-      | "unsafe-url";
-    /**
-     * Request / response headers as keys / values of JSON object.
-     */
-    export type Headers = Record<string, unknown>;
-    /**
-     * Timing information for the request.
-     */
-    export type ResourceTiming = {
+    export type ErrorEvent = {
       /**
-       * Request is initiated
+       * string associated with the error
        */
-      startTime: Timestamp;
+      message: string;
       /**
-       * Started redirect resolution.
+       * If an Error instance, the error.name property
        */
-      redirectStart: Timestamp;
+      name: string;
       /**
-       * Finished redirect resolution.
+       * Array of URLs associated with the error
        */
-      redirectEnd: Timestamp;
+      urls: string[];
       /**
-       * Resource fetching started.
+       * Line, column pairs associated with the error. Already sourcemapped.
        */
-      fetchStart: Timestamp;
+      lineColumns: number[];
       /**
-       * Started DNS address resolve in milliseconds relative to fetchStart.
+       * Source code preview associated with the error for up to 5 lines before the error, relative to the first non-internal stack frame.
        */
-      domainLookupStart: number;
-      /**
-       * Finished DNS address resolve in milliseconds relative to fetchStart.
-       */
-      domainLookupEnd: number;
-      /**
-       * Started connecting to the remote host in milliseconds relative to fetchStart.
-       */
-      connectStart: number;
-      /**
-       * Connected to the remote host in milliseconds relative to fetchStart.
-       */
-      connectEnd: number;
-      /**
-       * Started SSL handshake in milliseconds relative to fetchStart.
-       */
-      secureConnectionStart: number;
-      /**
-       * Started sending request in milliseconds relative to fetchStart.
-       */
-      requestStart: number;
-      /**
-       * Started receiving response headers in milliseconds relative to fetchStart.
-       */
-      responseStart: number;
-      /**
-       * Finished receiving response headers in milliseconds relative to fetchStart.
-       */
-      responseEnd: number;
+      sourceLines: string[];
     };
     /**
-     * HTTP request data.
-     */
-    export type Request = {
-      /**
-       * Request URL.
-       */
-      url: string;
-      /**
-       * HTTP request method.
-       */
-      method: string;
-      /**
-       * HTTP request headers.
-       */
-      headers: Headers;
-      /**
-       * HTTP POST request data.
-       */
-      postData?: string | undefined;
-      /**
-       * The level of included referrer information.
-       */
-      referrerPolicy?: ReferrerPolicy | undefined;
-      /**
-       * The base64 cryptographic hash of the resource.
-       */
-      integrity?: string | undefined;
-    };
-    /**
-     * HTTP response data.
-     */
-    export type Response = {
-      /**
-       * Response URL. This URL can be different from CachedResource.url in case of redirect.
-       */
-      url: string;
-      /**
-       * HTTP response status code.
-       */
-      status: number;
-      /**
-       * HTTP response status text.
-       */
-      statusText: string;
-      /**
-       * HTTP response headers.
-       */
-      headers: Headers;
-      /**
-       * Resource mimeType as determined by the browser.
-       */
-      mimeType: string;
-      /**
-       * Specifies where the response came from.
-       */
-      source: "unknown" | "network" | "memory-cache" | "disk-cache" | "service-worker" | "inspector-override";
-      /**
-       * Refined HTTP request headers that were actually transmitted over the network.
-       */
-      requestHeaders?: Headers | undefined;
-      /**
-       * Timing information for the given request.
-       */
-      timing?: ResourceTiming | undefined;
-      /**
-       * The security information for the given request.
-       */
-      security?: Security.Security | undefined;
-    };
-    /**
-     * Network load metrics.
-     */
-    export type Metrics = {
-      /**
-       * Network protocol. ALPN Protocol ID Identification Sequence, as per RFC 7301 (for example, http/2, http/1.1, spdy/3.1)
-       */
-      protocol?: string | undefined;
-      /**
-       * Network priority.
-       */
-      priority?: "low" | "medium" | "high" | undefined;
-      /**
-       * Connection identifier.
-       */
-      connectionIdentifier?: string | undefined;
-      /**
-       * Remote IP address.
-       */
-      remoteAddress?: string | undefined;
-      /**
-       * Refined HTTP request headers that were actually transmitted over the network.
-       */
-      requestHeaders?: Headers | undefined;
-      /**
-       * Total HTTP request header bytes sent over the network.
-       */
-      requestHeaderBytesSent?: number | undefined;
-      /**
-       * Total HTTP request body bytes sent over the network.
-       */
-      requestBodyBytesSent?: number | undefined;
-      /**
-       * Total HTTP response header bytes received over the network.
-       */
-      responseHeaderBytesReceived?: number | undefined;
-      /**
-       * Total HTTP response body bytes received over the network.
-       */
-      responseBodyBytesReceived?: number | undefined;
-      /**
-       * Total decoded response body size in bytes.
-       */
-      responseBodyDecodedSize?: number | undefined;
-      /**
-       * Connection information for the completed request.
-       */
-      securityConnection?: Security.Connection | undefined;
-      /**
-       * Whether or not the connection was proxied through a server. If <code>true</code>, the <code>remoteAddress</code> will be for the proxy server, not the server that provided the resource to the proxy server.
-       */
-      isProxyConnection?: boolean | undefined;
-    };
-    /**
-     * WebSocket request data.
-     */
-    export type WebSocketRequest = {
-      /**
-       * HTTP response headers.
-       */
-      headers: Headers;
-    };
-    /**
-     * WebSocket response data.
-     */
-    export type WebSocketResponse = {
-      /**
-       * HTTP response status code.
-       */
-      status: number;
-      /**
-       * HTTP response status text.
-       */
-      statusText: string;
-      /**
-       * HTTP response headers.
-       */
-      headers: Headers;
-    };
-    /**
-     * WebSocket frame data.
-     */
-    export type WebSocketFrame = {
-      /**
-       * WebSocket frame opcode.
-       */
-      opcode: number;
-      /**
-       * WebSocket frame mask.
-       */
-      mask: boolean;
-      /**
-       * WebSocket frame payload data, binary frames (opcode = 2) are base64-encoded.
-       */
-      payloadData: string;
-      /**
-       * WebSocket frame payload length in bytes.
-       */
-      payloadLength: number;
-    };
-    /**
-     * Information about the cached resource.
-     */
-    export type CachedResource = {
-      /**
-       * Resource URL. This is the url of the original network request.
-       */
-      url: string;
-      /**
-       * Type of this resource.
-       */
-      type: Page.ResourceType;
-      /**
-       * Cached response data.
-       */
-      response?: Response | undefined;
-      /**
-       * Cached response body size.
-       */
-      bodySize: number;
-      /**
-       * URL of source map associated with this resource (if any).
-       */
-      sourceMapURL?: string | undefined;
-    };
-    /**
-     * Information about the request initiator.
-     */
-    export type Initiator = {
-      /**
-       * Type of this initiator.
-       */
-      type: "parser" | "script" | "other";
-      /**
-       * Initiator JavaScript stack trace, set for Script only.
-       */
-      stackTrace?: Console.StackTrace | undefined;
-      /**
-       * Initiator URL, set for Parser type only.
-       */
-      url?: string | undefined;
-      /**
-       * Initiator line number, set for Parser type only.
-       */
-      lineNumber?: number | undefined;
-      /**
-       * Set if the load was triggered by a DOM node, in addition to the other initiator information.
-       */
-      nodeId?: DOM.NodeId | undefined;
-    };
-    /**
-     * Different stages of a network request.
-     */
-    export type NetworkStage = "request" | "response";
-    /**
-     * Different stages of a network request.
-     */
-    export type ResourceErrorType = "General" | "AccessControl" | "Cancellation" | "Timeout";
-    /**
-     * Fired when page is about to send HTTP request.
-     * @event `Network.requestWillBeSent`
-     */
-    export type RequestWillBeSentEvent = {
-      /**
-       * Request identifier.
-       */
-      requestId: RequestId;
-      /**
-       * Frame identifier.
-       */
-      frameId: FrameId;
-      /**
-       * Loader identifier.
-       */
-      loaderId: LoaderId;
-      /**
-       * URL of the document this request is loaded for.
-       */
-      documentURL: string;
-      /**
-       * Request data.
-       */
-      request: Request;
-      timestamp: Timestamp;
-      walltime: Walltime;
-      /**
-       * Request initiator.
-       */
-      initiator: Initiator;
-      /**
-       * Redirect response data.
-       */
-      redirectResponse?: Response | undefined;
-      /**
-       * Resource type.
-       */
-      type?: Page.ResourceType | undefined;
-      /**
-       * Identifier for the context of where the load originated. In general this is the target identifier. For Workers this will be the workerId.
-       */
-      targetId?: string | undefined;
-    };
-    /**
-     * Fired when HTTP response is available.
-     * @event `Network.responseReceived`
-     */
-    export type ResponseReceivedEvent = {
-      /**
-       * Request identifier.
-       */
-      requestId: RequestId;
-      /**
-       * Frame identifier.
-       */
-      frameId: FrameId;
-      /**
-       * Loader identifier.
-       */
-      loaderId: LoaderId;
-      /**
-       * Timestamp.
-       */
-      timestamp: Timestamp;
-      /**
-       * Resource type.
-       */
-      type: Page.ResourceType;
-      /**
-       * Response data.
-       */
-      response: Response;
-    };
-    /**
-     * Fired when data chunk was received over the network.
-     * @event `Network.dataReceived`
-     */
-    export type DataReceivedEvent = {
-      /**
-       * Request identifier.
-       */
-      requestId: RequestId;
-      /**
-       * Timestamp.
-       */
-      timestamp: Timestamp;
-      /**
-       * Data chunk length.
-       */
-      dataLength: number;
-      /**
-       * Actual bytes received (might be less than dataLength for compressed encodings).
-       */
-      encodedDataLength: number;
-    };
-    /**
-     * Fired when HTTP request has finished loading.
-     * @event `Network.loadingFinished`
-     */
-    export type LoadingFinishedEvent = {
-      /**
-       * Request identifier.
-       */
-      requestId: RequestId;
-      /**
-       * Timestamp.
-       */
-      timestamp: Timestamp;
-      /**
-       * URL of source map associated with this resource (if any).
-       */
-      sourceMapURL?: string | undefined;
-      /**
-       * Network metrics.
-       */
-      metrics?: Metrics | undefined;
-    };
-    /**
-     * Fired when HTTP request has failed to load.
-     * @event `Network.loadingFailed`
-     */
-    export type LoadingFailedEvent = {
-      /**
-       * Request identifier.
-       */
-      requestId: RequestId;
-      /**
-       * Timestamp.
-       */
-      timestamp: Timestamp;
-      /**
-       * User friendly error message.
-       */
-      errorText: string;
-      /**
-       * True if loading was canceled.
-       */
-      canceled?: boolean | undefined;
-    };
-    /**
-     * Fired when HTTP request has been served from memory cache.
-     * @event `Network.requestServedFromMemoryCache`
-     */
-    export type RequestServedFromMemoryCacheEvent = {
-      /**
-       * Request identifier.
-       */
-      requestId: RequestId;
-      /**
-       * Frame identifier.
-       */
-      frameId: FrameId;
-      /**
-       * Loader identifier.
-       */
-      loaderId: LoaderId;
-      /**
-       * URL of the document this request is loaded for.
-       */
-      documentURL: string;
-      /**
-       * Timestamp.
-       */
-      timestamp: Timestamp;
-      /**
-       * Request initiator.
-       */
-      initiator: Initiator;
-      /**
-       * Cached resource data.
-       */
-      resource: CachedResource;
-    };
-    /**
-     * Fired when HTTP request has been intercepted. The frontend must respond with <code>Network.interceptContinue</code>, <code>Network.interceptWithRequest</code>` or <code>Network.interceptWithResponse</code>` to resolve this request.
-     * @event `Network.requestIntercepted`
-     */
-    export type RequestInterceptedEvent = {
-      /**
-       * Identifier for this intercepted network. Corresponds with an earlier <code>Network.requestWillBeSent</code>.
-       */
-      requestId: RequestId;
-      /**
-       * Original request content that would proceed if this is continued.
-       */
-      request: Request;
-    };
-    /**
-     * Fired when HTTP response has been intercepted. The frontend must response with <code>Network.interceptContinue</code> or <code>Network.interceptWithResponse</code>` to continue this response.
-     * @event `Network.responseIntercepted`
-     */
-    export type ResponseInterceptedEvent = {
-      /**
-       * Identifier for this intercepted network. Corresponds with an earlier <code>Network.requestWillBeSent</code>.
-       */
-      requestId: RequestId;
-      /**
-       * Original response content that would proceed if this is continued.
-       */
-      response: Response;
-    };
-    /**
-     * Fired when WebSocket is about to initiate handshake.
-     * @event `Network.webSocketWillSendHandshakeRequest`
-     */
-    export type WebSocketWillSendHandshakeRequestEvent = {
-      /**
-       * Request identifier.
-       */
-      requestId: RequestId;
-      timestamp: Timestamp;
-      walltime: Walltime;
-      /**
-       * WebSocket request data.
-       */
-      request: WebSocketRequest;
-    };
-    /**
-     * Fired when WebSocket handshake response becomes available.
-     * @event `Network.webSocketHandshakeResponseReceived`
-     */
-    export type WebSocketHandshakeResponseReceivedEvent = {
-      /**
-       * Request identifier.
-       */
-      requestId: RequestId;
-      timestamp: Timestamp;
-      /**
-       * WebSocket response data.
-       */
-      response: WebSocketResponse;
-    };
-    /**
-     * Fired upon WebSocket creation.
-     * @event `Network.webSocketCreated`
-     */
-    export type WebSocketCreatedEvent = {
-      /**
-       * Request identifier.
-       */
-      requestId: RequestId;
-      /**
-       * WebSocket request URL.
-       */
-      url: string;
-    };
-    /**
-     * Fired when WebSocket is closed.
-     * @event `Network.webSocketClosed`
-     */
-    export type WebSocketClosedEvent = {
-      /**
-       * Request identifier.
-       */
-      requestId: RequestId;
-      /**
-       * Timestamp.
-       */
-      timestamp: Timestamp;
-    };
-    /**
-     * Fired when WebSocket frame is received.
-     * @event `Network.webSocketFrameReceived`
-     */
-    export type WebSocketFrameReceivedEvent = {
-      /**
-       * Request identifier.
-       */
-      requestId: RequestId;
-      /**
-       * Timestamp.
-       */
-      timestamp: Timestamp;
-      /**
-       * WebSocket response data.
-       */
-      response: WebSocketFrame;
-    };
-    /**
-     * Fired when WebSocket frame error occurs.
-     * @event `Network.webSocketFrameError`
-     */
-    export type WebSocketFrameErrorEvent = {
-      /**
-       * Request identifier.
-       */
-      requestId: RequestId;
-      /**
-       * Timestamp.
-       */
-      timestamp: Timestamp;
-      /**
-       * WebSocket frame error message.
-       */
-      errorMessage: string;
-    };
-    /**
-     * Fired when WebSocket frame is sent.
-     * @event `Network.webSocketFrameSent`
-     */
-    export type WebSocketFrameSentEvent = {
-      /**
-       * Request identifier.
-       */
-      requestId: RequestId;
-      /**
-       * Timestamp.
-       */
-      timestamp: Timestamp;
-      /**
-       * WebSocket response data.
-       */
-      response: WebSocketFrame;
-    };
-    /**
-     * Enables network tracking, network events will now be delivered to the client.
-     * @request `Network.enable`
+     * Enables LifecycleReporter domain events.
+     * @request `LifecycleReporter.enable`
      */
     export type EnableRequest = {};
     /**
-     * Enables network tracking, network events will now be delivered to the client.
-     * @response `Network.enable`
+     * Enables LifecycleReporter domain events.
+     * @response `LifecycleReporter.enable`
      */
     export type EnableResponse = {};
     /**
-     * Disables network tracking, prevents network events from being sent to the client.
-     * @request `Network.disable`
+     * Disables LifecycleReporter domain events.
+     * @request `LifecycleReporter.disable`
      */
     export type DisableRequest = {};
     /**
-     * Disables network tracking, prevents network events from being sent to the client.
-     * @response `Network.disable`
+     * Disables LifecycleReporter domain events.
+     * @response `LifecycleReporter.disable`
      */
     export type DisableResponse = {};
     /**
-     * Specifies whether to always send extra HTTP headers with the requests from this page.
-     * @request `Network.setExtraHTTPHeaders`
+     * Prevents the process from exiting.
+     * @request `LifecycleReporter.preventExit`
      */
-    export type SetExtraHTTPHeadersRequest = {
-      /**
-       * Map with extra HTTP headers.
-       */
-      headers: Headers;
-    };
+    export type PreventExitRequest = {};
     /**
-     * Specifies whether to always send extra HTTP headers with the requests from this page.
-     * @response `Network.setExtraHTTPHeaders`
+     * Prevents the process from exiting.
+     * @response `LifecycleReporter.preventExit`
      */
-    export type SetExtraHTTPHeadersResponse = {};
+    export type PreventExitResponse = {};
     /**
-     * Returns content served for the given request.
-     * @request `Network.getResponseBody`
+     * Does not prevent the process from exiting.
+     * @request `LifecycleReporter.stopPreventingExit`
      */
-    export type GetResponseBodyRequest = {
-      /**
-       * Identifier of the network request to get content for.
-       */
-      requestId: RequestId;
-    };
+    export type StopPreventingExitRequest = {};
     /**
-     * Returns content served for the given request.
-     * @response `Network.getResponseBody`
+     * Does not prevent the process from exiting.
+     * @response `LifecycleReporter.stopPreventingExit`
      */
-    export type GetResponseBodyResponse = {
-      /**
-       * Response body.
-       */
-      body: string;
-      /**
-       * True, if content was sent as base64.
-       */
-      base64Encoded: boolean;
-    };
-    /**
-     * Toggles whether the resource cache may be used when loading resources in the inspected page. If <code>true</code>, the resource cache will not be used when loading resources.
-     * @request `Network.setResourceCachingDisabled`
-     */
-    export type SetResourceCachingDisabledRequest = {
-      /**
-       * Whether to prevent usage of the resource cache.
-       */
-      disabled: boolean;
-    };
-    /**
-     * Toggles whether the resource cache may be used when loading resources in the inspected page. If <code>true</code>, the resource cache will not be used when loading resources.
-     * @response `Network.setResourceCachingDisabled`
-     */
-    export type SetResourceCachingDisabledResponse = {};
-    /**
-     * Loads a resource in the context of a frame on the inspected page without cross origin checks.
-     * @request `Network.loadResource`
-     */
-    export type LoadResourceRequest = {
-      /**
-       * Frame to load the resource from.
-       */
-      frameId: FrameId;
-      /**
-       * URL of the resource to load.
-       */
-      url: string;
-    };
-    /**
-     * Loads a resource in the context of a frame on the inspected page without cross origin checks.
-     * @response `Network.loadResource`
-     */
-    export type LoadResourceResponse = {
-      /**
-       * Resource content.
-       */
-      content: string;
-      /**
-       * Resource mimeType.
-       */
-      mimeType: string;
-      /**
-       * HTTP response status code.
-       */
-      status: number;
-    };
-    /**
-     * Fetches a serialized secure certificate for the given requestId to be displayed via InspectorFrontendHost.showCertificate.
-     * @request `Network.getSerializedCertificate`
-     */
-    export type GetSerializedCertificateRequest = {
-      requestId: RequestId;
-    };
-    /**
-     * Fetches a serialized secure certificate for the given requestId to be displayed via InspectorFrontendHost.showCertificate.
-     * @response `Network.getSerializedCertificate`
-     */
-    export type GetSerializedCertificateResponse = {
-      /**
-       * Represents a base64 encoded WebCore::CertificateInfo object.
-       */
-      serializedCertificate: string;
-    };
-    /**
-     * Resolves JavaScript WebSocket object for given request id.
-     * @request `Network.resolveWebSocket`
-     */
-    export type ResolveWebSocketRequest = {
-      /**
-       * Identifier of the WebSocket resource to resolve.
-       */
-      requestId: RequestId;
-      /**
-       * Symbolic group name that can be used to release multiple objects.
-       */
-      objectGroup?: string | undefined;
-    };
-    /**
-     * Resolves JavaScript WebSocket object for given request id.
-     * @response `Network.resolveWebSocket`
-     */
-    export type ResolveWebSocketResponse = {
-      /**
-       * JavaScript object wrapper for given node.
-       */
-      object: Runtime.RemoteObject;
-    };
-    /**
-     * Enable interception of network requests.
-     * @request `Network.setInterceptionEnabled`
-     */
-    export type SetInterceptionEnabledRequest = {
-      enabled: boolean;
-    };
-    /**
-     * Enable interception of network requests.
-     * @response `Network.setInterceptionEnabled`
-     */
-    export type SetInterceptionEnabledResponse = {};
-    /**
-     * Add an interception.
-     * @request `Network.addInterception`
-     */
-    export type AddInterceptionRequest = {
-      /**
-       * URL pattern to intercept, intercept everything if not specified or empty
-       */
-      url: string;
-      /**
-       * Stage to intercept.
-       */
-      stage: NetworkStage;
-      /**
-       * If false, ignores letter casing of `url` parameter.
-       */
-      caseSensitive?: boolean | undefined;
-      /**
-       * If true, treats `url` parameter as a regular expression.
-       */
-      isRegex?: boolean | undefined;
-    };
-    /**
-     * Add an interception.
-     * @response `Network.addInterception`
-     */
-    export type AddInterceptionResponse = {};
-    /**
-     * Remove an interception.
-     * @request `Network.removeInterception`
-     */
-    export type RemoveInterceptionRequest = {
-      url: string;
-      /**
-       * Stage to intercept.
-       */
-      stage: NetworkStage;
-      /**
-       * If false, ignores letter casing of `url` parameter.
-       */
-      caseSensitive?: boolean | undefined;
-      /**
-       * If true, treats `url` parameter as a regular expression.
-       */
-      isRegex?: boolean | undefined;
-    };
-    /**
-     * Remove an interception.
-     * @response `Network.removeInterception`
-     */
-    export type RemoveInterceptionResponse = {};
-    /**
-     * Continue request or response without modifications.
-     * @request `Network.interceptContinue`
-     */
-    export type InterceptContinueRequest = {
-      /**
-       * Identifier for the intercepted Network request or response to continue.
-       */
-      requestId: RequestId;
-      /**
-       * Stage to continue.
-       */
-      stage: NetworkStage;
-    };
-    /**
-     * Continue request or response without modifications.
-     * @response `Network.interceptContinue`
-     */
-    export type InterceptContinueResponse = {};
-    /**
-     * Replace intercepted request with the provided one.
-     * @request `Network.interceptWithRequest`
-     */
-    export type InterceptWithRequestRequest = {
-      /**
-       * Identifier for the intercepted Network request or response to continue.
-       */
-      requestId: RequestId;
-      /**
-       * HTTP request url.
-       */
-      url?: string | undefined;
-      /**
-       * HTTP request method.
-       */
-      method?: string | undefined;
-      /**
-       * HTTP response headers. Pass through original values if unmodified.
-       */
-      headers?: Headers | undefined;
-      /**
-       * HTTP POST request data, base64-encoded.
-       */
-      postData?: string | undefined;
-    };
-    /**
-     * Replace intercepted request with the provided one.
-     * @response `Network.interceptWithRequest`
-     */
-    export type InterceptWithRequestResponse = {};
-    /**
-     * Provide response content for an intercepted response.
-     * @request `Network.interceptWithResponse`
-     */
-    export type InterceptWithResponseRequest = {
-      /**
-       * Identifier for the intercepted Network response to modify.
-       */
-      requestId: RequestId;
-      content: string;
-      /**
-       * True, if content was sent as base64.
-       */
-      base64Encoded: boolean;
-      /**
-       * MIME Type for the data.
-       */
-      mimeType?: string | undefined;
-      /**
-       * HTTP response status code. Pass through original values if unmodified.
-       */
-      status?: number | undefined;
-      /**
-       * HTTP response status text. Pass through original values if unmodified.
-       */
-      statusText?: string | undefined;
-      /**
-       * HTTP response headers. Pass through original values if unmodified.
-       */
-      headers?: Headers | undefined;
-    };
-    /**
-     * Provide response content for an intercepted response.
-     * @response `Network.interceptWithResponse`
-     */
-    export type InterceptWithResponseResponse = {};
-    /**
-     * Provide response for an intercepted request. Request completely bypasses the network in this case and is immediately fulfilled with the provided data.
-     * @request `Network.interceptRequestWithResponse`
-     */
-    export type InterceptRequestWithResponseRequest = {
-      /**
-       * Identifier for the intercepted Network response to modify.
-       */
-      requestId: RequestId;
-      content: string;
-      /**
-       * True, if content was sent as base64.
-       */
-      base64Encoded: boolean;
-      /**
-       * MIME Type for the data.
-       */
-      mimeType: string;
-      /**
-       * HTTP response status code.
-       */
-      status: number;
-      /**
-       * HTTP response status text.
-       */
-      statusText: string;
-      /**
-       * HTTP response headers.
-       */
-      headers: Headers;
-    };
-    /**
-     * Provide response for an intercepted request. Request completely bypasses the network in this case and is immediately fulfilled with the provided data.
-     * @response `Network.interceptRequestWithResponse`
-     */
-    export type InterceptRequestWithResponseResponse = {};
-    /**
-     * Fail request with given error type.
-     * @request `Network.interceptRequestWithError`
-     */
-    export type InterceptRequestWithErrorRequest = {
-      /**
-       * Identifier for the intercepted Network request to fail.
-       */
-      requestId: RequestId;
-      /**
-       * Deliver error reason for the request failure.
-       */
-      errorType: ResourceErrorType;
-    };
-    /**
-     * Fail request with given error type.
-     * @response `Network.interceptRequestWithError`
-     */
-    export type InterceptRequestWithErrorResponse = {};
-    /**
-     * Emulate various network conditions (e.g. bytes per second, latency, etc.).
-     * @request `Network.setEmulatedConditions`
-     */
-    export type SetEmulatedConditionsRequest = {
-      /**
-       * Limits the bytes per second of requests if positive. Removes any limits if zero or not provided.
-       */
-      bytesPerSecondLimit?: number | undefined;
-    };
-    /**
-     * Emulate various network conditions (e.g. bytes per second, latency, etc.).
-     * @response `Network.setEmulatedConditions`
-     */
-    export type SetEmulatedConditionsResponse = {};
+    export type StopPreventingExitResponse = {};
   }
   export namespace Runtime {
     /**
@@ -3453,14 +2506,88 @@ export namespace JSC {
      */
     export type StopTrackingResponse = {};
   }
+  export namespace TestReporter {
+    export type TestStatus = "pass" | "fail" | "timeout" | "skip" | "todo";
+    /**
+     * undefined
+     * @event `TestReporter.found`
+     */
+    export type FoundEvent = {
+      /**
+       * Unique identifier of the test that was found.
+       */
+      id: number;
+      /**
+       * Unique identifier of the script the test is in. Available when the debugger is attached.
+       */
+      scriptId?: Debugger.ScriptId | undefined;
+      /**
+       * url of the script the test is in. Available when the debugger is not attached.
+       */
+      url?: string | undefined;
+      /**
+       * Line number in the script that started the test.
+       */
+      line: number;
+      /**
+       * Name of the test that started.
+       */
+      name?: string | undefined;
+    };
+    /**
+     * undefined
+     * @event `TestReporter.start`
+     */
+    export type StartEvent = {
+      /**
+       * Unique identifier of the test that started.
+       */
+      id: number;
+    };
+    /**
+     * undefined
+     * @event `TestReporter.end`
+     */
+    export type EndEvent = {
+      /**
+       * Unique identifier of the test that ended.
+       */
+      id: number;
+      /**
+       * Status of the test that ended.
+       */
+      status: TestStatus;
+      /**
+       * Elapsed time in milliseconds since the test started.
+       */
+      elapsed: number;
+    };
+    /**
+     * Enables TestReporter domain events.
+     * @request `TestReporter.enable`
+     */
+    export type EnableRequest = {};
+    /**
+     * Enables TestReporter domain events.
+     * @response `TestReporter.enable`
+     */
+    export type EnableResponse = {};
+    /**
+     * Disables TestReporter domain events.
+     * @request `TestReporter.disable`
+     */
+    export type DisableRequest = {};
+    /**
+     * Disables TestReporter domain events.
+     * @response `TestReporter.disable`
+     */
+    export type DisableResponse = {};
+  }
   export type EventMap = {
     "Console.messageAdded": Console.MessageAddedEvent;
     "Console.messageRepeatCountUpdated": Console.MessageRepeatCountUpdatedEvent;
     "Console.messagesCleared": Console.MessagesClearedEvent;
     "Console.heapSnapshot": Console.HeapSnapshotEvent;
-    "CPUProfiler.trackingStart": CPUProfiler.TrackingStartEvent;
-    "CPUProfiler.trackingUpdate": CPUProfiler.TrackingUpdateEvent;
-    "CPUProfiler.trackingComplete": CPUProfiler.TrackingCompleteEvent;
     "Debugger.globalObjectCleared": Debugger.GlobalObjectClearedEvent;
     "Debugger.scriptParsed": Debugger.ScriptParsedEvent;
     "Debugger.scriptFailedToParse": Debugger.ScriptFailedToParseEvent;
@@ -3474,34 +2601,26 @@ export namespace JSC {
     "Heap.trackingComplete": Heap.TrackingCompleteEvent;
     "Inspector.evaluateForTestInFrontend": Inspector.EvaluateForTestInFrontendEvent;
     "Inspector.inspect": Inspector.InspectEvent;
-    "Network.requestWillBeSent": Network.RequestWillBeSentEvent;
-    "Network.responseReceived": Network.ResponseReceivedEvent;
-    "Network.dataReceived": Network.DataReceivedEvent;
-    "Network.loadingFinished": Network.LoadingFinishedEvent;
-    "Network.loadingFailed": Network.LoadingFailedEvent;
-    "Network.requestServedFromMemoryCache": Network.RequestServedFromMemoryCacheEvent;
-    "Network.requestIntercepted": Network.RequestInterceptedEvent;
-    "Network.responseIntercepted": Network.ResponseInterceptedEvent;
-    "Network.webSocketWillSendHandshakeRequest": Network.WebSocketWillSendHandshakeRequestEvent;
-    "Network.webSocketHandshakeResponseReceived": Network.WebSocketHandshakeResponseReceivedEvent;
-    "Network.webSocketCreated": Network.WebSocketCreatedEvent;
-    "Network.webSocketClosed": Network.WebSocketClosedEvent;
-    "Network.webSocketFrameReceived": Network.WebSocketFrameReceivedEvent;
-    "Network.webSocketFrameError": Network.WebSocketFrameErrorEvent;
-    "Network.webSocketFrameSent": Network.WebSocketFrameSentEvent;
+    "LifecycleReporter.reload": LifecycleReporter.ReloadEvent;
+    "LifecycleReporter.error": LifecycleReporter.ErrorEvent;
     "Runtime.executionContextCreated": Runtime.ExecutionContextCreatedEvent;
     "ScriptProfiler.trackingStart": ScriptProfiler.TrackingStartEvent;
     "ScriptProfiler.trackingUpdate": ScriptProfiler.TrackingUpdateEvent;
     "ScriptProfiler.trackingComplete": ScriptProfiler.TrackingCompleteEvent;
+    "TestReporter.found": TestReporter.FoundEvent;
+    "TestReporter.start": TestReporter.StartEvent;
+    "TestReporter.end": TestReporter.EndEvent;
   };
   export type RequestMap = {
+    "Audit.setup": Audit.SetupRequest;
+    "Audit.run": Audit.RunRequest;
+    "Audit.teardown": Audit.TeardownRequest;
     "Console.enable": Console.EnableRequest;
     "Console.disable": Console.DisableRequest;
     "Console.clearMessages": Console.ClearMessagesRequest;
+    "Console.setConsoleClearAPIEnabled": Console.SetConsoleClearAPIEnabledRequest;
     "Console.getLoggingChannels": Console.GetLoggingChannelsRequest;
     "Console.setLoggingChannelLevel": Console.SetLoggingChannelLevelRequest;
-    "CPUProfiler.startTracking": CPUProfiler.StartTrackingRequest;
-    "CPUProfiler.stopTracking": CPUProfiler.StopTrackingRequest;
     "Debugger.enable": Debugger.EnableRequest;
     "Debugger.disable": Debugger.DisableRequest;
     "Debugger.setAsyncStackTraceDepth": Debugger.SetAsyncStackTraceDepthRequest;
@@ -3542,23 +2661,10 @@ export namespace JSC {
     "Inspector.enable": Inspector.EnableRequest;
     "Inspector.disable": Inspector.DisableRequest;
     "Inspector.initialized": Inspector.InitializedRequest;
-    "Network.enable": Network.EnableRequest;
-    "Network.disable": Network.DisableRequest;
-    "Network.setExtraHTTPHeaders": Network.SetExtraHTTPHeadersRequest;
-    "Network.getResponseBody": Network.GetResponseBodyRequest;
-    "Network.setResourceCachingDisabled": Network.SetResourceCachingDisabledRequest;
-    "Network.loadResource": Network.LoadResourceRequest;
-    "Network.getSerializedCertificate": Network.GetSerializedCertificateRequest;
-    "Network.resolveWebSocket": Network.ResolveWebSocketRequest;
-    "Network.setInterceptionEnabled": Network.SetInterceptionEnabledRequest;
-    "Network.addInterception": Network.AddInterceptionRequest;
-    "Network.removeInterception": Network.RemoveInterceptionRequest;
-    "Network.interceptContinue": Network.InterceptContinueRequest;
-    "Network.interceptWithRequest": Network.InterceptWithRequestRequest;
-    "Network.interceptWithResponse": Network.InterceptWithResponseRequest;
-    "Network.interceptRequestWithResponse": Network.InterceptRequestWithResponseRequest;
-    "Network.interceptRequestWithError": Network.InterceptRequestWithErrorRequest;
-    "Network.setEmulatedConditions": Network.SetEmulatedConditionsRequest;
+    "LifecycleReporter.enable": LifecycleReporter.EnableRequest;
+    "LifecycleReporter.disable": LifecycleReporter.DisableRequest;
+    "LifecycleReporter.preventExit": LifecycleReporter.PreventExitRequest;
+    "LifecycleReporter.stopPreventingExit": LifecycleReporter.StopPreventingExitRequest;
     "Runtime.parse": Runtime.ParseRequest;
     "Runtime.evaluate": Runtime.EvaluateRequest;
     "Runtime.awaitPromise": Runtime.AwaitPromiseRequest;
@@ -3581,15 +2687,19 @@ export namespace JSC {
     "Runtime.getBasicBlocks": Runtime.GetBasicBlocksRequest;
     "ScriptProfiler.startTracking": ScriptProfiler.StartTrackingRequest;
     "ScriptProfiler.stopTracking": ScriptProfiler.StopTrackingRequest;
+    "TestReporter.enable": TestReporter.EnableRequest;
+    "TestReporter.disable": TestReporter.DisableRequest;
   };
   export type ResponseMap = {
+    "Audit.setup": Audit.SetupResponse;
+    "Audit.run": Audit.RunResponse;
+    "Audit.teardown": Audit.TeardownResponse;
     "Console.enable": Console.EnableResponse;
     "Console.disable": Console.DisableResponse;
     "Console.clearMessages": Console.ClearMessagesResponse;
+    "Console.setConsoleClearAPIEnabled": Console.SetConsoleClearAPIEnabledResponse;
     "Console.getLoggingChannels": Console.GetLoggingChannelsResponse;
     "Console.setLoggingChannelLevel": Console.SetLoggingChannelLevelResponse;
-    "CPUProfiler.startTracking": CPUProfiler.StartTrackingResponse;
-    "CPUProfiler.stopTracking": CPUProfiler.StopTrackingResponse;
     "Debugger.enable": Debugger.EnableResponse;
     "Debugger.disable": Debugger.DisableResponse;
     "Debugger.setAsyncStackTraceDepth": Debugger.SetAsyncStackTraceDepthResponse;
@@ -3630,23 +2740,10 @@ export namespace JSC {
     "Inspector.enable": Inspector.EnableResponse;
     "Inspector.disable": Inspector.DisableResponse;
     "Inspector.initialized": Inspector.InitializedResponse;
-    "Network.enable": Network.EnableResponse;
-    "Network.disable": Network.DisableResponse;
-    "Network.setExtraHTTPHeaders": Network.SetExtraHTTPHeadersResponse;
-    "Network.getResponseBody": Network.GetResponseBodyResponse;
-    "Network.setResourceCachingDisabled": Network.SetResourceCachingDisabledResponse;
-    "Network.loadResource": Network.LoadResourceResponse;
-    "Network.getSerializedCertificate": Network.GetSerializedCertificateResponse;
-    "Network.resolveWebSocket": Network.ResolveWebSocketResponse;
-    "Network.setInterceptionEnabled": Network.SetInterceptionEnabledResponse;
-    "Network.addInterception": Network.AddInterceptionResponse;
-    "Network.removeInterception": Network.RemoveInterceptionResponse;
-    "Network.interceptContinue": Network.InterceptContinueResponse;
-    "Network.interceptWithRequest": Network.InterceptWithRequestResponse;
-    "Network.interceptWithResponse": Network.InterceptWithResponseResponse;
-    "Network.interceptRequestWithResponse": Network.InterceptRequestWithResponseResponse;
-    "Network.interceptRequestWithError": Network.InterceptRequestWithErrorResponse;
-    "Network.setEmulatedConditions": Network.SetEmulatedConditionsResponse;
+    "LifecycleReporter.enable": LifecycleReporter.EnableResponse;
+    "LifecycleReporter.disable": LifecycleReporter.DisableResponse;
+    "LifecycleReporter.preventExit": LifecycleReporter.PreventExitResponse;
+    "LifecycleReporter.stopPreventingExit": LifecycleReporter.StopPreventingExitResponse;
     "Runtime.parse": Runtime.ParseResponse;
     "Runtime.evaluate": Runtime.EvaluateResponse;
     "Runtime.awaitPromise": Runtime.AwaitPromiseResponse;
@@ -3669,6 +2766,8 @@ export namespace JSC {
     "Runtime.getBasicBlocks": Runtime.GetBasicBlocksResponse;
     "ScriptProfiler.startTracking": ScriptProfiler.StartTrackingResponse;
     "ScriptProfiler.stopTracking": ScriptProfiler.StopTrackingResponse;
+    "TestReporter.enable": TestReporter.EnableResponse;
+    "TestReporter.disable": TestReporter.DisableResponse;
   };
 
   export type Event<T extends keyof EventMap = keyof EventMap> = {
diff --git a/packages/bun-inspector-protocol/src/protocol/jsc/protocol.json b/packages/bun-inspector-protocol/src/protocol/jsc/protocol.json
index 2e9e6b5682..8fb868df32 100644
--- a/packages/bun-inspector-protocol/src/protocol/jsc/protocol.json
+++ b/packages/bun-inspector-protocol/src/protocol/jsc/protocol.json
@@ -1,7 +1,65 @@
 {
   "name": "JSC",
-  "version": { "major": 1, "minor": 3 },
+  "version": {
+    "major": 1,
+    "minor": 4
+  },
   "domains": [
+    {
+      "domain": "Audit",
+      "description": "",
+      "version": 4,
+      "debuggableTypes": ["itml", "javascript", "page", "service-worker", "web-page"],
+      "targetTypes": ["itml", "javascript", "page", "service-worker", "worker"],
+      "commands": [
+        {
+          "name": "setup",
+          "description": "Creates the `WebInspectorAudit` object that is passed to run. Must call teardown before calling setup more than once.",
+          "parameters": [
+            {
+              "name": "contextId",
+              "$ref": "Runtime.ExecutionContextId",
+              "optional": true,
+              "description": "Specifies in which isolated context to run the test. Each content script lives in an isolated context and this parameter may be used to specify one of those contexts. If the parameter is omitted or 0 the evaluation will be performed in the context of the inspected page."
+            }
+          ]
+        },
+        {
+          "name": "run",
+          "description": "Parses and evaluates the given test string and sends back the result. Returned values are saved to the \"audit\" object group. Call setup before and teardown after if the `WebInspectorAudit` object should be passed into the test.",
+          "parameters": [
+            {
+              "name": "test",
+              "type": "string",
+              "description": "Test string to parse and evaluate."
+            },
+            {
+              "name": "contextId",
+              "$ref": "Runtime.ExecutionContextId",
+              "optional": true,
+              "description": "Specifies in which isolated context to run the test. Each content script lives in an isolated context and this parameter may be used to specify one of those contexts. If the parameter is omitted or 0 the evaluation will be performed in the context of the inspected page."
+            }
+          ],
+          "returns": [
+            {
+              "name": "result",
+              "$ref": "Runtime.RemoteObject",
+              "description": "Evaluation result."
+            },
+            {
+              "name": "wasThrown",
+              "type": "boolean",
+              "optional": true,
+              "description": "True if the result was thrown during the evaluation."
+            }
+          ]
+        },
+        {
+          "name": "teardown",
+          "description": "Destroys the `WebInspectorAudit` object that is passed to run. Must call setup before calling teardown."
+        }
+      ]
+    },
     {
       "domain": "Console",
       "description": "Console domain defines methods and events for interaction with the JavaScript console. Console collects messages created by means of the <a href='http://getfirebug.com/wiki/index.php/Console_API'>JavaScript Console API</a>. One needs to enable this domain using <code>enable</code> command in order to start receiving the console messages. Browser collects messages issued while console domain is not enabled as well and reports them using <code>messageAdded</code> notification upon enabling.",
@@ -41,28 +99,44 @@
         {
           "id": "ClearReason",
           "type": "string",
-          "enum": ["console-api", "main-frame-navigation"],
+          "enum": ["console-api", "frontend", "main-frame-navigation"],
           "description": "The reason the console is being cleared."
         },
         {
           "id": "Channel",
           "description": "Logging channel.",
           "type": "object",
-          "properties": [{ "name": "source", "$ref": "ChannelSource" }, { "name": "level", "$ref": "ChannelLevel" }]
+          "properties": [
+            {
+              "name": "source",
+              "$ref": "ChannelSource"
+            },
+            {
+              "name": "level",
+              "$ref": "ChannelLevel"
+            }
+          ]
         },
         {
           "id": "ConsoleMessage",
           "type": "object",
           "description": "Console message.",
           "properties": [
-            { "name": "source", "$ref": "ChannelSource" },
+            {
+              "name": "source",
+              "$ref": "ChannelSource"
+            },
             {
               "name": "level",
               "type": "string",
               "enum": ["log", "info", "warning", "error", "debug"],
               "description": "Message severity."
             },
-            { "name": "text", "type": "string", "description": "Message text." },
+            {
+              "name": "text",
+              "type": "string",
+              "description": "Message text."
+            },
             {
               "name": "type",
               "type": "string",
@@ -85,7 +159,12 @@
               ],
               "description": "Console message type."
             },
-            { "name": "url", "type": "string", "optional": true, "description": "URL of the message origin." },
+            {
+              "name": "url",
+              "type": "string",
+              "optional": true,
+              "description": "URL of the message origin."
+            },
             {
               "name": "line",
               "type": "integer",
@@ -107,7 +186,9 @@
             {
               "name": "parameters",
               "type": "array",
-              "items": { "$ref": "Runtime.RemoteObject" },
+              "items": {
+                "$ref": "Runtime.RemoteObject"
+              },
               "optional": true,
               "description": "Message parameters in case of the formatted message."
             },
@@ -136,11 +217,31 @@
           "type": "object",
           "description": "Stack entry for console errors and assertions.",
           "properties": [
-            { "name": "functionName", "type": "string", "description": "JavaScript function name." },
-            { "name": "url", "type": "string", "description": "JavaScript script name or url." },
-            { "name": "scriptId", "$ref": "Debugger.ScriptId", "description": "Script identifier." },
-            { "name": "lineNumber", "type": "integer", "description": "JavaScript script line number." },
-            { "name": "columnNumber", "type": "integer", "description": "JavaScript script column number." }
+            {
+              "name": "functionName",
+              "type": "string",
+              "description": "JavaScript function name."
+            },
+            {
+              "name": "url",
+              "type": "string",
+              "description": "JavaScript script name or url."
+            },
+            {
+              "name": "scriptId",
+              "$ref": "Debugger.ScriptId",
+              "description": "Script identifier."
+            },
+            {
+              "name": "lineNumber",
+              "type": "integer",
+              "description": "JavaScript script line number."
+            },
+            {
+              "name": "columnNumber",
+              "type": "integer",
+              "description": "JavaScript script column number."
+            }
           ]
         },
         {
@@ -148,7 +249,13 @@
           "description": "Call frames for async function calls, console assertions, and error messages.",
           "type": "object",
           "properties": [
-            { "name": "callFrames", "type": "array", "items": { "$ref": "CallFrame" } },
+            {
+              "name": "callFrames",
+              "type": "array",
+              "items": {
+                "$ref": "CallFrame"
+              }
+            },
             {
               "name": "topCallFrameIsBoundary",
               "type": "boolean",
@@ -161,7 +268,12 @@
               "optional": true,
               "description": "Whether one or more frames have been truncated from the bottom of the stack."
             },
-            { "name": "parentStackTrace", "$ref": "StackTrace", "optional": true, "description": "Parent StackTrace." }
+            {
+              "name": "parentStackTrace",
+              "$ref": "StackTrace",
+              "optional": true,
+              "description": "Parent StackTrace."
+            }
           ]
         }
       ],
@@ -174,20 +286,48 @@
           "name": "disable",
           "description": "Disables console domain, prevents further console messages from being reported to the client."
         },
-        { "name": "clearMessages", "description": "Clears console messages collected in the browser." },
+        {
+          "name": "clearMessages",
+          "description": "Clears console messages collected in the browser."
+        },
+        {
+          "name": "setConsoleClearAPIEnabled",
+          "description": "Control whether calling <code>console.clear()</code> has an effect in Web Inspector. Defaults to true.",
+          "parameters": [
+            {
+              "name": "enable",
+              "type": "boolean"
+            }
+          ]
+        },
         {
           "name": "getLoggingChannels",
           "description": "List of the different message sources that are non-default logging channels.",
           "returns": [
-            { "name": "channels", "type": "array", "items": { "$ref": "Channel" }, "description": "Logging channels." }
+            {
+              "name": "channels",
+              "type": "array",
+              "items": {
+                "$ref": "Channel"
+              },
+              "description": "Logging channels."
+            }
           ]
         },
         {
           "name": "setLoggingChannelLevel",
           "description": "Modify the level of a channel.",
           "parameters": [
-            { "name": "source", "$ref": "ChannelSource", "description": "Logging channel to modify." },
-            { "name": "level", "$ref": "ChannelLevel", "description": "New level." }
+            {
+              "name": "source",
+              "$ref": "ChannelSource",
+              "description": "Logging channel to modify."
+            },
+            {
+              "name": "level",
+              "$ref": "ChannelLevel",
+              "description": "New level."
+            }
           ]
         }
       ],
@@ -196,14 +336,22 @@
           "name": "messageAdded",
           "description": "Issued when new console message is added.",
           "parameters": [
-            { "name": "message", "$ref": "ConsoleMessage", "description": "Console message that has been added." }
+            {
+              "name": "message",
+              "$ref": "ConsoleMessage",
+              "description": "Console message that has been added."
+            }
           ]
         },
         {
           "name": "messageRepeatCountUpdated",
           "description": "Issued when subsequent message(s) are equal to the previous one(s).",
           "parameters": [
-            { "name": "count", "type": "integer", "description": "New repeat count value." },
+            {
+              "name": "count",
+              "type": "integer",
+              "description": "New repeat count value."
+            },
             {
               "name": "timestamp",
               "type": "number",
@@ -216,14 +364,21 @@
           "name": "messagesCleared",
           "description": "Issued when console is cleared. This happens either upon <code>clearMessages</code> command or after page navigation.",
           "parameters": [
-            { "name": "reason", "$ref": "ClearReason", "description": "The reason the console is being cleared." }
+            {
+              "name": "reason",
+              "$ref": "ClearReason",
+              "description": "The reason the console is being cleared."
+            }
           ]
         },
         {
           "name": "heapSnapshot",
           "description": "Issued from console.takeHeapSnapshot.",
           "parameters": [
-            { "name": "timestamp", "type": "number" },
+            {
+              "name": "timestamp",
+              "type": "number"
+            },
             {
               "name": "snapshotData",
               "$ref": "Heap.HeapSnapshotData",
@@ -239,94 +394,32 @@
         }
       ]
     },
-    {
-      "domain": "CPUProfiler",
-      "description": "CPUProfiler domain exposes cpu usage tracking.",
-      "condition": "defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE",
-      "debuggableTypes": ["page", "web-page"],
-      "targetTypes": ["page"],
-      "types": [
-        {
-          "id": "ThreadInfo",
-          "description": "CPU usage for an individual thread.",
-          "type": "object",
-          "properties": [
-            { "name": "name", "type": "string", "description": "Some thread identification information." },
-            {
-              "name": "usage",
-              "type": "number",
-              "description": "CPU usage for this thread. This should not exceed 100% for an individual thread."
-            },
-            {
-              "name": "type",
-              "type": "string",
-              "enum": ["main", "webkit"],
-              "optional": true,
-              "description": "Type of thread. There should be a single main thread."
-            },
-            {
-              "name": "targetId",
-              "type": "string",
-              "optional": true,
-              "description": "A thread may be associated with a target, such as a Worker, in the process."
-            }
-          ]
-        },
-        {
-          "id": "Event",
-          "type": "object",
-          "properties": [
-            { "name": "timestamp", "type": "number" },
-            {
-              "name": "usage",
-              "type": "number",
-              "description": "Percent of total cpu usage. If there are multiple cores the usage may be greater than 100%."
-            },
-            {
-              "name": "threads",
-              "type": "array",
-              "items": { "$ref": "ThreadInfo" },
-              "optional": true,
-              "description": "Per-thread CPU usage information. Does not include the main thread."
-            }
-          ]
-        }
-      ],
-      "commands": [
-        { "name": "startTracking", "description": "Start tracking cpu usage." },
-        {
-          "name": "stopTracking",
-          "description": "Stop tracking cpu usage. This will produce a `trackingComplete` event."
-        }
-      ],
-      "events": [
-        {
-          "name": "trackingStart",
-          "description": "Tracking started.",
-          "parameters": [{ "name": "timestamp", "type": "number" }]
-        },
-        {
-          "name": "trackingUpdate",
-          "description": "Periodic tracking updates with event data.",
-          "parameters": [{ "name": "event", "$ref": "Event" }]
-        },
-        {
-          "name": "trackingComplete",
-          "description": "Tracking stopped.",
-          "parameters": [{ "name": "timestamp", "type": "number" }]
-        }
-      ]
-    },
     {
       "domain": "Debugger",
       "description": "Debugger domain exposes JavaScript debugging capabilities. It allows setting and removing breakpoints, stepping through execution, exploring stack traces, etc.",
       "debuggableTypes": ["itml", "javascript", "page", "service-worker", "web-page"],
       "targetTypes": ["itml", "javascript", "page", "service-worker", "worker"],
       "types": [
-        { "id": "BreakpointId", "type": "string", "description": "Breakpoint identifier." },
-        { "id": "BreakpointActionIdentifier", "type": "integer", "description": "Breakpoint action identifier." },
-        { "id": "ScriptId", "type": "string", "description": "Unique script identifier." },
-        { "id": "CallFrameId", "type": "string", "description": "Call frame identifier." },
+        {
+          "id": "BreakpointId",
+          "type": "string",
+          "description": "Breakpoint identifier."
+        },
+        {
+          "id": "BreakpointActionIdentifier",
+          "type": "integer",
+          "description": "Breakpoint action identifier."
+        },
+        {
+          "id": "ScriptId",
+          "type": "string",
+          "description": "Unique script identifier."
+        },
+        {
+          "id": "CallFrameId",
+          "type": "string",
+          "description": "Call frame identifier."
+        },
         {
           "id": "Location",
           "type": "object",
@@ -337,7 +430,11 @@
               "$ref": "ScriptId",
               "description": "Script identifier as reported in the <code>Debugger.scriptParsed</code>."
             },
-            { "name": "lineNumber", "type": "integer", "description": "Line number in the script (0-based)." },
+            {
+              "name": "lineNumber",
+              "type": "integer",
+              "description": "Line number in the script (0-based)."
+            },
             {
               "name": "columnNumber",
               "type": "integer",
@@ -392,7 +489,9 @@
               "name": "actions",
               "type": "array",
               "optional": true,
-              "items": { "$ref": "BreakpointAction" },
+              "items": {
+                "$ref": "BreakpointAction"
+              },
               "description": "Actions to perform automatically when the breakpoint is triggered."
             },
             {
@@ -414,7 +513,11 @@
           "type": "object",
           "description": "Information about the function.",
           "properties": [
-            { "name": "location", "$ref": "Location", "description": "Location of the function." },
+            {
+              "name": "location",
+              "$ref": "Location",
+              "description": "Location of the function."
+            },
             {
               "name": "name",
               "type": "string",
@@ -431,7 +534,9 @@
               "name": "scopeChain",
               "type": "array",
               "optional": true,
-              "items": { "$ref": "Scope" },
+              "items": {
+                "$ref": "Scope"
+              },
               "description": "Scope chain for this closure."
             }
           ]
@@ -451,11 +556,17 @@
               "type": "string",
               "description": "Name of the JavaScript function called on this call frame."
             },
-            { "name": "location", "$ref": "Location", "description": "Location in the source code." },
+            {
+              "name": "location",
+              "$ref": "Location",
+              "description": "Location in the source code."
+            },
             {
               "name": "scopeChain",
               "type": "array",
-              "items": { "$ref": "Scope" },
+              "items": {
+                "$ref": "Scope"
+              },
               "description": "Scope chain for this call frame."
             },
             {
@@ -494,7 +605,12 @@
               ],
               "description": "Scope type."
             },
-            { "name": "name", "type": "string", "optional": true, "description": "Name associated with the scope." },
+            {
+              "name": "name",
+              "type": "string",
+              "optional": true,
+              "description": "Name associated with the scope."
+            },
             {
               "name": "location",
               "$ref": "Location",
@@ -519,14 +635,26 @@
               "$ref": "BreakpointActionIdentifier",
               "description": "Identifier of the probe breakpoint action that created the sample."
             },
-            { "name": "sampleId", "type": "integer", "description": "Unique identifier for this sample." },
+            {
+              "name": "sampleId",
+              "type": "integer",
+              "description": "Unique identifier for this sample."
+            },
             {
               "name": "batchId",
               "type": "integer",
               "description": "A batch identifier which is the same for all samples taken at the same breakpoint hit."
             },
-            { "name": "timestamp", "type": "number", "description": "Timestamp of when the sample was taken." },
-            { "name": "payload", "$ref": "Runtime.RemoteObject", "description": "Contents of the sample." }
+            {
+              "name": "timestamp",
+              "type": "number",
+              "description": "Timestamp of when the sample was taken."
+            },
+            {
+              "name": "payload",
+              "$ref": "Runtime.RemoteObject",
+              "description": "Contents of the sample."
+            }
           ]
         },
         {
@@ -559,7 +687,11 @@
           "type": "object",
           "description": "The pause reason auxiliary data when paused because of a Content Security Policy directive.",
           "properties": [
-            { "name": "directive", "type": "string", "description": "The CSP directive that blocked script execution." }
+            {
+              "name": "directive",
+              "type": "string",
+              "description": "The CSP directive that blocked script execution."
+            }
           ]
         }
       ],
@@ -568,24 +700,41 @@
           "name": "enable",
           "description": "Enables debugger for the given page. Clients should not assume that the debugging has been enabled until the result for this command is received."
         },
-        { "name": "disable", "description": "Disables debugger for given page." },
+        {
+          "name": "disable",
+          "description": "Disables debugger for given page."
+        },
         {
           "name": "setAsyncStackTraceDepth",
           "description": "Set the async stack trace depth for the page. A value of zero disables recording of async stack traces.",
-          "parameters": [{ "name": "depth", "type": "integer", "description": "Async stack trace depth." }]
+          "parameters": [
+            {
+              "name": "depth",
+              "type": "integer",
+              "description": "Async stack trace depth."
+            }
+          ]
         },
         {
           "name": "setBreakpointsActive",
           "description": "Activates / deactivates all breakpoints on the page.",
           "parameters": [
-            { "name": "active", "type": "boolean", "description": "New value for breakpoints active state." }
+            {
+              "name": "active",
+              "type": "boolean",
+              "description": "New value for breakpoints active state."
+            }
           ]
         },
         {
           "name": "setBreakpointByUrl",
           "description": "Sets JavaScript breakpoint at given location specified either by URL or URL regex. Once this command is issued, all existing parsed scripts will have breakpoints resolved and returned in <code>locations</code> property. Further matching script parsing will result in subsequent <code>breakpointResolved</code> events issued. This logical breakpoint will survive page reloads.",
           "parameters": [
-            { "name": "lineNumber", "type": "integer", "description": "Line number to set breakpoint at." },
+            {
+              "name": "lineNumber",
+              "type": "integer",
+              "description": "Line number to set breakpoint at."
+            },
             {
               "name": "url",
               "type": "string",
@@ -620,7 +769,9 @@
             {
               "name": "locations",
               "type": "array",
-              "items": { "$ref": "Location" },
+              "items": {
+                "$ref": "Location"
+              },
               "description": "List of the locations this breakpoint resolved into upon addition."
             }
           ]
@@ -629,7 +780,11 @@
           "name": "setBreakpoint",
           "description": "Sets JavaScript breakpoint at a given location.",
           "parameters": [
-            { "name": "location", "$ref": "Location", "description": "Location to set breakpoint in." },
+            {
+              "name": "location",
+              "$ref": "Location",
+              "description": "Location to set breakpoint in."
+            },
             {
               "name": "options",
               "$ref": "BreakpointOptions",
@@ -643,19 +798,32 @@
               "$ref": "BreakpointId",
               "description": "Id of the created breakpoint for further reference."
             },
-            { "name": "actualLocation", "$ref": "Location", "description": "Location this breakpoint resolved into." }
+            {
+              "name": "actualLocation",
+              "$ref": "Location",
+              "description": "Location this breakpoint resolved into."
+            }
           ]
         },
         {
           "name": "removeBreakpoint",
           "description": "Removes JavaScript breakpoint.",
-          "parameters": [{ "name": "breakpointId", "$ref": "BreakpointId" }]
+          "parameters": [
+            {
+              "name": "breakpointId",
+              "$ref": "BreakpointId"
+            }
+          ]
         },
         {
           "name": "addSymbolicBreakpoint",
           "description": "Adds a JavaScript breakpoint that pauses execution whenever a function with the given name is about to be called.",
           "parameters": [
-            { "name": "symbol", "type": "string", "description": "The name of the function to pause in when called." },
+            {
+              "name": "symbol",
+              "type": "string",
+              "description": "The name of the function to pause in when called."
+            },
             {
               "name": "caseSensitive",
               "type": "boolean",
@@ -680,7 +848,11 @@
           "name": "removeSymbolicBreakpoint",
           "description": "Removes a previously added symbolic breakpoint.",
           "parameters": [
-            { "name": "symbol", "type": "string", "description": "The name of the function to pause in when called." },
+            {
+              "name": "symbol",
+              "type": "string",
+              "description": "The name of the function to pause in when called."
+            },
             {
               "name": "caseSensitive",
               "type": "boolean",
@@ -702,7 +874,13 @@
         {
           "name": "continueToLocation",
           "description": "Continues execution until specific location is reached. This will trigger either a Debugger.paused or Debugger.resumed event.",
-          "parameters": [{ "name": "location", "$ref": "Location", "description": "Location to continue to." }]
+          "parameters": [
+            {
+              "name": "location",
+              "$ref": "Location",
+              "description": "Location to continue to."
+            }
+          ]
         },
         {
           "name": "stepNext",
@@ -720,7 +898,10 @@
           "name": "stepOut",
           "description": "Steps out of the function call. This will trigger either a Debugger.paused or Debugger.resumed event."
         },
-        { "name": "pause", "description": "Stops on the next JavaScript statement." },
+        {
+          "name": "pause",
+          "description": "Stops on the next JavaScript statement."
+        },
         {
           "name": "resume",
           "description": "Resumes JavaScript execution. This will trigger a Debugger.resumed event."
@@ -729,8 +910,16 @@
           "name": "searchInContent",
           "description": "Searches for given string in script content.",
           "parameters": [
-            { "name": "scriptId", "$ref": "ScriptId", "description": "Id of the script to search in." },
-            { "name": "query", "type": "string", "description": "String to search for." },
+            {
+              "name": "scriptId",
+              "$ref": "ScriptId",
+              "description": "Id of the script to search in."
+            },
+            {
+              "name": "query",
+              "type": "string",
+              "description": "String to search for."
+            },
             {
               "name": "caseSensitive",
               "type": "boolean",
@@ -748,7 +937,9 @@
             {
               "name": "result",
               "type": "array",
-              "items": { "$ref": "GenericTypes.SearchMatch" },
+              "items": {
+                "$ref": "GenericTypes.SearchMatch"
+              },
               "description": "List of search matches."
             }
           ]
@@ -757,9 +948,19 @@
           "name": "getScriptSource",
           "description": "Returns source for the script with given id.",
           "parameters": [
-            { "name": "scriptId", "$ref": "ScriptId", "description": "Id of the script to get source for." }
+            {
+              "name": "scriptId",
+              "$ref": "ScriptId",
+              "description": "Id of the script to get source for."
+            }
           ],
-          "returns": [{ "name": "scriptSource", "type": "string", "description": "Script source." }]
+          "returns": [
+            {
+              "name": "scriptSource",
+              "type": "string",
+              "description": "Script source."
+            }
+          ]
         },
         {
           "name": "getFunctionDetails",
@@ -772,7 +973,11 @@
             }
           ],
           "returns": [
-            { "name": "details", "$ref": "FunctionDetails", "description": "Information about the function." }
+            {
+              "name": "details",
+              "$ref": "FunctionDetails",
+              "description": "Information about the function."
+            }
           ]
         },
         {
@@ -794,7 +999,9 @@
             {
               "name": "locations",
               "type": "array",
-              "items": { "$ref": "Location" },
+              "items": {
+                "$ref": "Location"
+              },
               "description": "List of resolved breakpoint locations."
             }
           ]
@@ -803,7 +1010,10 @@
           "name": "setPauseOnDebuggerStatements",
           "description": "Control whether the debugger pauses execution before `debugger` statements.",
           "parameters": [
-            { "name": "enabled", "type": "boolean" },
+            {
+              "name": "enabled",
+              "type": "boolean"
+            },
             {
               "name": "options",
               "$ref": "BreakpointOptions",
@@ -834,7 +1044,10 @@
           "name": "setPauseOnAssertions",
           "description": "Set pause on assertions state. Assertions are console.assert assertions.",
           "parameters": [
-            { "name": "enabled", "type": "boolean" },
+            {
+              "name": "enabled",
+              "type": "boolean"
+            },
             {
               "name": "options",
               "$ref": "BreakpointOptions",
@@ -847,7 +1060,10 @@
           "name": "setPauseOnMicrotasks",
           "description": "Pause when running the next JavaScript microtask.",
           "parameters": [
-            { "name": "enabled", "type": "boolean" },
+            {
+              "name": "enabled",
+              "type": "boolean"
+            },
             {
               "name": "options",
               "$ref": "BreakpointOptions",
@@ -859,14 +1075,27 @@
         {
           "name": "setPauseForInternalScripts",
           "description": "Change whether to pause in the debugger for internal scripts. The default value is false.",
-          "parameters": [{ "name": "shouldPause", "type": "boolean" }]
+          "parameters": [
+            {
+              "name": "shouldPause",
+              "type": "boolean"
+            }
+          ]
         },
         {
           "name": "evaluateOnCallFrame",
           "description": "Evaluates expression on a given call frame.",
           "parameters": [
-            { "name": "callFrameId", "$ref": "CallFrameId", "description": "Call frame identifier to evaluate on." },
-            { "name": "expression", "type": "string", "description": "Expression to evaluate." },
+            {
+              "name": "callFrameId",
+              "$ref": "CallFrameId",
+              "description": "Call frame identifier to evaluate on."
+            },
+            {
+              "name": "expression",
+              "type": "string",
+              "description": "Expression to evaluate."
+            },
             {
               "name": "objectGroup",
               "type": "string",
@@ -932,28 +1161,48 @@
         },
         {
           "name": "setShouldBlackboxURL",
-          "description": "Sets whether the given URL should be in the list of blackboxed scripts, which are ignored when pausing/stepping/debugging.",
+          "description": "Sets whether the given URL should be in the list of blackboxed scripts, which are ignored when pausing.",
           "parameters": [
-            { "name": "url", "type": "string" },
-            { "name": "shouldBlackbox", "type": "boolean" },
+            {
+              "name": "url",
+              "type": "string"
+            },
+            {
+              "name": "shouldBlackbox",
+              "type": "boolean"
+            },
             {
               "name": "caseSensitive",
               "type": "boolean",
               "optional": true,
-              "description": "If true, <code>url</code> is case sensitive."
+              "description": "If <code>true</code>, <code>url</code> is case sensitive."
             },
             {
               "name": "isRegex",
               "type": "boolean",
               "optional": true,
-              "description": "If true, treat <code>url</code> as regular expression."
+              "description": "If <code>true</code>, treat <code>url</code> as regular expression."
+            },
+            {
+              "name": "sourceRanges",
+              "type": "array",
+              "items": {
+                "type": "integer"
+              },
+              "optional": true,
+              "description": "If provided, limits where in the script the debugger will skip pauses. Expected structure is a repeated <code>[startLine, startColumn, endLine, endColumn]</code>. Ignored if <code>shouldBlackbox</code> is <code>false</code>."
             }
           ]
         },
         {
           "name": "setBlackboxBreakpointEvaluations",
           "description": "Sets whether evaluation of breakpoint conditions, ignore counts, and actions happen at the location of the breakpoint or are deferred due to blackboxing.",
-          "parameters": [{ "name": "blackboxBreakpointEvaluations", "type": "boolean" }]
+          "parameters": [
+            {
+              "name": "blackboxBreakpointEvaluations",
+              "type": "boolean"
+            }
+          ]
         }
       ],
       "events": [
@@ -965,8 +1214,16 @@
           "name": "scriptParsed",
           "description": "Fired when virtual machine parses script. This event is also fired for all known and uncollected scripts upon enabling debugger.",
           "parameters": [
-            { "name": "scriptId", "$ref": "ScriptId", "description": "Identifier of the script parsed." },
-            { "name": "url", "type": "string", "description": "URL of the script parsed (if any)." },
+            {
+              "name": "scriptId",
+              "$ref": "ScriptId",
+              "description": "Identifier of the script parsed."
+            },
+            {
+              "name": "url",
+              "type": "string",
+              "description": "URL of the script parsed (if any)."
+            },
             {
               "name": "startLine",
               "type": "integer",
@@ -977,8 +1234,16 @@
               "type": "integer",
               "description": "Column offset of the script within the resource with given URL."
             },
-            { "name": "endLine", "type": "integer", "description": "Last line of the script." },
-            { "name": "endColumn", "type": "integer", "description": "Length of the last line of the script." },
+            {
+              "name": "endLine",
+              "type": "integer",
+              "description": "Last line of the script."
+            },
+            {
+              "name": "endColumn",
+              "type": "integer",
+              "description": "Length of the last line of the script."
+            },
             {
               "name": "isContentScript",
               "type": "boolean",
@@ -1009,23 +1274,47 @@
           "name": "scriptFailedToParse",
           "description": "Fired when virtual machine fails to parse the script.",
           "parameters": [
-            { "name": "url", "type": "string", "description": "URL of the script that failed to parse." },
+            {
+              "name": "url",
+              "type": "string",
+              "description": "URL of the script that failed to parse."
+            },
             {
               "name": "scriptSource",
               "type": "string",
               "description": "Source text of the script that failed to parse."
             },
-            { "name": "startLine", "type": "integer", "description": "Line offset of the script within the resource." },
-            { "name": "errorLine", "type": "integer", "description": "Line with error." },
-            { "name": "errorMessage", "type": "string", "description": "Parse error message." }
+            {
+              "name": "startLine",
+              "type": "integer",
+              "description": "Line offset of the script within the resource."
+            },
+            {
+              "name": "errorLine",
+              "type": "integer",
+              "description": "Line with error."
+            },
+            {
+              "name": "errorMessage",
+              "type": "string",
+              "description": "Parse error message."
+            }
           ]
         },
         {
           "name": "breakpointResolved",
           "description": "Fired when breakpoint is resolved to an actual script and location.",
           "parameters": [
-            { "name": "breakpointId", "$ref": "BreakpointId", "description": "Breakpoint unique identifier." },
-            { "name": "location", "$ref": "Location", "description": "Actual breakpoint location." }
+            {
+              "name": "breakpointId",
+              "$ref": "BreakpointId",
+              "description": "Breakpoint unique identifier."
+            },
+            {
+              "name": "location",
+              "$ref": "Location",
+              "description": "Actual breakpoint location."
+            }
           ]
         },
         {
@@ -1035,7 +1324,9 @@
             {
               "name": "callFrames",
               "type": "array",
-              "items": { "$ref": "CallFrame" },
+              "items": {
+                "$ref": "CallFrame"
+              },
               "description": "Call stack the virtual machine stopped on."
             },
             {
@@ -1075,11 +1366,20 @@
             }
           ]
         },
-        { "name": "resumed", "description": "Fired when the virtual machine resumed execution." },
+        {
+          "name": "resumed",
+          "description": "Fired when the virtual machine resumed execution."
+        },
         {
           "name": "didSampleProbe",
           "description": "Fires when a new probe sample is collected.",
-          "parameters": [{ "name": "sample", "$ref": "ProbeSample", "description": "A collected probe sample." }]
+          "parameters": [
+            {
+              "name": "sample",
+              "$ref": "ProbeSample",
+              "description": "A collected probe sample."
+            }
+          ]
         },
         {
           "name": "playBreakpointActionSound",
@@ -1094,21 +1394,6 @@
         }
       ]
     },
-    {
-      "domain": "GenericTypes",
-      "description": "Exposes generic types to be used by any domain.",
-      "types": [
-        {
-          "id": "SearchMatch",
-          "type": "object",
-          "description": "Search match in a resource.",
-          "properties": [
-            { "name": "lineNumber", "type": "number", "description": "Line number in resource content." },
-            { "name": "lineContent", "type": "string", "description": "Line with match content." }
-          ]
-        }
-      ]
-    },
     {
       "domain": "Heap",
       "description": "Heap domain exposes JavaScript heap attributes and capabilities.",
@@ -1126,20 +1411,48 @@
               "enum": ["full", "partial"],
               "description": "The type of garbage collection."
             },
-            { "name": "startTime", "type": "number" },
-            { "name": "endTime", "type": "number" }
+            {
+              "name": "startTime",
+              "type": "number"
+            },
+            {
+              "name": "endTime",
+              "type": "number"
+            }
           ]
         },
-        { "id": "HeapSnapshotData", "description": "JavaScriptCore HeapSnapshot JSON data.", "type": "string" }
+        {
+          "id": "HeapSnapshotData",
+          "description": "JavaScriptCore HeapSnapshot JSON data.",
+          "type": "string"
+        }
       ],
       "commands": [
-        { "name": "enable", "description": "Enables Heap domain events." },
-        { "name": "disable", "description": "Disables Heap domain events." },
-        { "name": "gc", "description": "Trigger a full garbage collection." },
+        {
+          "name": "enable",
+          "description": "Enables Heap domain events."
+        },
+        {
+          "name": "disable",
+          "description": "Disables Heap domain events."
+        },
+        {
+          "name": "gc",
+          "description": "Trigger a full garbage collection."
+        },
         {
           "name": "snapshot",
           "description": "Take a heap snapshot.",
-          "returns": [{ "name": "timestamp", "type": "number" }, { "name": "snapshotData", "$ref": "HeapSnapshotData" }]
+          "returns": [
+            {
+              "name": "timestamp",
+              "type": "number"
+            },
+            {
+              "name": "snapshotData",
+              "$ref": "HeapSnapshotData"
+            }
+          ]
         },
         {
           "name": "startTracking",
@@ -1160,14 +1473,24 @@
             }
           ],
           "returns": [
-            { "name": "string", "type": "string", "optional": true, "description": "String value." },
+            {
+              "name": "string",
+              "type": "string",
+              "optional": true,
+              "description": "String value."
+            },
             {
               "name": "functionDetails",
               "$ref": "Debugger.FunctionDetails",
               "optional": true,
               "description": "Function details."
             },
-            { "name": "preview", "$ref": "Runtime.ObjectPreview", "optional": true, "description": "Object preview." }
+            {
+              "name": "preview",
+              "$ref": "Runtime.ObjectPreview",
+              "optional": true,
+              "description": "Object preview."
+            }
           ]
         },
         {
@@ -1186,29 +1509,54 @@
               "description": "Symbolic group name that can be used to release multiple objects."
             }
           ],
-          "returns": [{ "name": "result", "$ref": "Runtime.RemoteObject", "description": "Resulting object." }]
+          "returns": [
+            {
+              "name": "result",
+              "$ref": "Runtime.RemoteObject",
+              "description": "Resulting object."
+            }
+          ]
         }
       ],
       "events": [
         {
           "name": "garbageCollected",
           "description": "Information about the garbage collection.",
-          "parameters": [{ "name": "collection", "$ref": "GarbageCollection" }]
+          "parameters": [
+            {
+              "name": "collection",
+              "$ref": "GarbageCollection"
+            }
+          ]
         },
         {
           "name": "trackingStart",
           "description": "Tracking started.",
           "parameters": [
-            { "name": "timestamp", "type": "number" },
-            { "name": "snapshotData", "$ref": "HeapSnapshotData", "description": "Snapshot at the start of tracking." }
+            {
+              "name": "timestamp",
+              "type": "number"
+            },
+            {
+              "name": "snapshotData",
+              "$ref": "HeapSnapshotData",
+              "description": "Snapshot at the start of tracking."
+            }
           ]
         },
         {
           "name": "trackingComplete",
           "description": "Tracking stopped.",
           "parameters": [
-            { "name": "timestamp", "type": "number" },
-            { "name": "snapshotData", "$ref": "HeapSnapshotData", "description": "Snapshot at the end of tracking." }
+            {
+              "name": "timestamp",
+              "type": "number"
+            },
+            {
+              "name": "snapshotData",
+              "$ref": "HeapSnapshotData",
+              "description": "Snapshot at the end of tracking."
+            }
           ]
         }
       ]
@@ -1218,810 +1566,111 @@
       "debuggableTypes": ["itml", "javascript", "page", "web-page"],
       "targetTypes": ["itml", "javascript", "page"],
       "commands": [
-        { "name": "enable", "description": "Enables inspector domain notifications." },
-        { "name": "disable", "description": "Disables inspector domain notifications." },
+        {
+          "name": "enable",
+          "description": "Enables inspector domain notifications."
+        },
+        {
+          "name": "disable",
+          "description": "Disables inspector domain notifications."
+        },
         {
           "name": "initialized",
           "description": "Sent by the frontend after all initialization messages have been sent."
         }
       ],
       "events": [
-        { "name": "evaluateForTestInFrontend", "parameters": [{ "name": "script", "type": "string" }] },
+        {
+          "name": "evaluateForTestInFrontend",
+          "parameters": [
+            {
+              "name": "script",
+              "type": "string"
+            }
+          ]
+        },
         {
           "name": "inspect",
-          "parameters": [{ "name": "object", "$ref": "Runtime.RemoteObject" }, { "name": "hints", "type": "object" }]
+          "parameters": [
+            {
+              "name": "object",
+              "$ref": "Runtime.RemoteObject"
+            },
+            {
+              "name": "hints",
+              "type": "object"
+            }
+          ]
         }
       ]
     },
     {
-      "domain": "Network",
-      "description": "Network domain allows tracking network activities of the page. It exposes information about http, file, data and other requests and responses, their headers, bodies, timing, etc.",
-      "debuggableTypes": ["itml", "page", "service-worker", "web-page"],
-      "targetTypes": ["itml", "page", "service-worker"],
-      "types": [
-        { "id": "LoaderId", "type": "string", "description": "Unique loader identifier." },
-        { "id": "FrameId", "type": "string", "description": "Unique frame identifier." },
-        { "id": "RequestId", "type": "string", "description": "Unique request identifier." },
-        { "id": "Timestamp", "type": "number", "description": "Elapsed seconds since frontend connected." },
-        { "id": "Walltime", "type": "number", "description": "Number of seconds since epoch." },
-        {
-          "id": "ReferrerPolicy",
-          "type": "string",
-          "description": "Controls how much referrer information is sent with the request",
-          "enum": [
-            "empty-string",
-            "no-referrer",
-            "no-referrer-when-downgrade",
-            "same-origin",
-            "origin",
-            "strict-origin",
-            "origin-when-cross-origin",
-            "strict-origin-when-cross-origin",
-            "unsafe-url"
-          ]
-        },
-        {
-          "id": "Headers",
-          "type": "object",
-          "description": "Request / response headers as keys / values of JSON object."
-        },
-        {
-          "id": "ResourceTiming",
-          "type": "object",
-          "description": "Timing information for the request.",
-          "properties": [
-            { "name": "startTime", "$ref": "Timestamp", "description": "Request is initiated" },
-            { "name": "redirectStart", "$ref": "Timestamp", "description": "Started redirect resolution." },
-            { "name": "redirectEnd", "$ref": "Timestamp", "description": "Finished redirect resolution." },
-            { "name": "fetchStart", "$ref": "Timestamp", "description": "Resource fetching started." },
-            {
-              "name": "domainLookupStart",
-              "type": "number",
-              "description": "Started DNS address resolve in milliseconds relative to fetchStart."
-            },
-            {
-              "name": "domainLookupEnd",
-              "type": "number",
-              "description": "Finished DNS address resolve in milliseconds relative to fetchStart."
-            },
-            {
-              "name": "connectStart",
-              "type": "number",
-              "description": "Started connecting to the remote host in milliseconds relative to fetchStart."
-            },
-            {
-              "name": "connectEnd",
-              "type": "number",
-              "description": "Connected to the remote host in milliseconds relative to fetchStart."
-            },
-            {
-              "name": "secureConnectionStart",
-              "type": "number",
-              "description": "Started SSL handshake in milliseconds relative to fetchStart."
-            },
-            {
-              "name": "requestStart",
-              "type": "number",
-              "description": "Started sending request in milliseconds relative to fetchStart."
-            },
-            {
-              "name": "responseStart",
-              "type": "number",
-              "description": "Started receiving response headers in milliseconds relative to fetchStart."
-            },
-            {
-              "name": "responseEnd",
-              "type": "number",
-              "description": "Finished receiving response headers in milliseconds relative to fetchStart."
-            }
-          ]
-        },
-        {
-          "id": "Request",
-          "type": "object",
-          "description": "HTTP request data.",
-          "properties": [
-            { "name": "url", "type": "string", "description": "Request URL." },
-            { "name": "method", "type": "string", "description": "HTTP request method." },
-            { "name": "headers", "$ref": "Headers", "description": "HTTP request headers." },
-            { "name": "postData", "type": "string", "optional": true, "description": "HTTP POST request data." },
-            {
-              "name": "referrerPolicy",
-              "$ref": "ReferrerPolicy",
-              "optional": true,
-              "description": "The level of included referrer information."
-            },
-            {
-              "name": "integrity",
-              "type": "string",
-              "optional": true,
-              "description": "The base64 cryptographic hash of the resource."
-            }
-          ]
-        },
-        {
-          "id": "Response",
-          "type": "object",
-          "description": "HTTP response data.",
-          "properties": [
-            {
-              "name": "url",
-              "type": "string",
-              "description": "Response URL. This URL can be different from CachedResource.url in case of redirect."
-            },
-            { "name": "status", "type": "integer", "description": "HTTP response status code." },
-            { "name": "statusText", "type": "string", "description": "HTTP response status text." },
-            { "name": "headers", "$ref": "Headers", "description": "HTTP response headers." },
-            { "name": "mimeType", "type": "string", "description": "Resource mimeType as determined by the browser." },
-            {
-              "name": "source",
-              "type": "string",
-              "enum": ["unknown", "network", "memory-cache", "disk-cache", "service-worker", "inspector-override"],
-              "description": "Specifies where the response came from."
-            },
-            {
-              "name": "requestHeaders",
-              "$ref": "Headers",
-              "optional": true,
-              "description": "Refined HTTP request headers that were actually transmitted over the network."
-            },
-            {
-              "name": "timing",
-              "$ref": "ResourceTiming",
-              "optional": true,
-              "description": "Timing information for the given request."
-            },
-            {
-              "name": "security",
-              "$ref": "Security.Security",
-              "optional": true,
-              "description": "The security information for the given request."
-            }
-          ]
-        },
-        {
-          "id": "Metrics",
-          "type": "object",
-          "description": "Network load metrics.",
-          "properties": [
-            {
-              "name": "protocol",
-              "type": "string",
-              "optional": true,
-              "description": "Network protocol. ALPN Protocol ID Identification Sequence, as per RFC 7301 (for example, http/2, http/1.1, spdy/3.1)"
-            },
-            {
-              "name": "priority",
-              "type": "string",
-              "enum": ["low", "medium", "high"],
-              "optional": true,
-              "description": "Network priority."
-            },
-            {
-              "name": "connectionIdentifier",
-              "type": "string",
-              "optional": true,
-              "description": "Connection identifier."
-            },
-            { "name": "remoteAddress", "type": "string", "optional": true, "description": "Remote IP address." },
-            {
-              "name": "requestHeaders",
-              "$ref": "Headers",
-              "optional": true,
-              "description": "Refined HTTP request headers that were actually transmitted over the network."
-            },
-            {
-              "name": "requestHeaderBytesSent",
-              "type": "number",
-              "optional": true,
-              "description": "Total HTTP request header bytes sent over the network."
-            },
-            {
-              "name": "requestBodyBytesSent",
-              "type": "number",
-              "optional": true,
-              "description": "Total HTTP request body bytes sent over the network."
-            },
-            {
-              "name": "responseHeaderBytesReceived",
-              "type": "number",
-              "optional": true,
-              "description": "Total HTTP response header bytes received over the network."
-            },
-            {
-              "name": "responseBodyBytesReceived",
-              "type": "number",
-              "optional": true,
-              "description": "Total HTTP response body bytes received over the network."
-            },
-            {
-              "name": "responseBodyDecodedSize",
-              "type": "number",
-              "optional": true,
-              "description": "Total decoded response body size in bytes."
-            },
-            {
-              "name": "securityConnection",
-              "$ref": "Security.Connection",
-              "optional": true,
-              "description": "Connection information for the completed request."
-            },
-            {
-              "name": "isProxyConnection",
-              "type": "boolean",
-              "optional": true,
-              "description": "Whether or not the connection was proxied through a server. If <code>true</code>, the <code>remoteAddress</code> will be for the proxy server, not the server that provided the resource to the proxy server."
-            }
-          ]
-        },
-        {
-          "id": "WebSocketRequest",
-          "type": "object",
-          "description": "WebSocket request data.",
-          "properties": [{ "name": "headers", "$ref": "Headers", "description": "HTTP response headers." }]
-        },
-        {
-          "id": "WebSocketResponse",
-          "type": "object",
-          "description": "WebSocket response data.",
-          "properties": [
-            { "name": "status", "type": "integer", "description": "HTTP response status code." },
-            { "name": "statusText", "type": "string", "description": "HTTP response status text." },
-            { "name": "headers", "$ref": "Headers", "description": "HTTP response headers." }
-          ]
-        },
-        {
-          "id": "WebSocketFrame",
-          "type": "object",
-          "description": "WebSocket frame data.",
-          "properties": [
-            { "name": "opcode", "type": "number", "description": "WebSocket frame opcode." },
-            { "name": "mask", "type": "boolean", "description": "WebSocket frame mask." },
-            {
-              "name": "payloadData",
-              "type": "string",
-              "description": "WebSocket frame payload data, binary frames (opcode = 2) are base64-encoded."
-            },
-            { "name": "payloadLength", "type": "number", "description": "WebSocket frame payload length in bytes." }
-          ]
-        },
-        {
-          "id": "CachedResource",
-          "type": "object",
-          "description": "Information about the cached resource.",
-          "properties": [
-            {
-              "name": "url",
-              "type": "string",
-              "description": "Resource URL. This is the url of the original network request."
-            },
-            { "name": "type", "$ref": "Page.ResourceType", "description": "Type of this resource." },
-            { "name": "response", "$ref": "Response", "optional": true, "description": "Cached response data." },
-            { "name": "bodySize", "type": "number", "description": "Cached response body size." },
-            {
-              "name": "sourceMapURL",
-              "type": "string",
-              "optional": true,
-              "description": "URL of source map associated with this resource (if any)."
-            }
-          ]
-        },
-        {
-          "id": "Initiator",
-          "type": "object",
-          "description": "Information about the request initiator.",
-          "properties": [
-            {
-              "name": "type",
-              "type": "string",
-              "enum": ["parser", "script", "other"],
-              "description": "Type of this initiator."
-            },
-            {
-              "name": "stackTrace",
-              "$ref": "Console.StackTrace",
-              "optional": true,
-              "description": "Initiator JavaScript stack trace, set for Script only."
-            },
-            {
-              "name": "url",
-              "type": "string",
-              "optional": true,
-              "description": "Initiator URL, set for Parser type only."
-            },
-            {
-              "name": "lineNumber",
-              "type": "number",
-              "optional": true,
-              "description": "Initiator line number, set for Parser type only."
-            },
-            {
-              "name": "nodeId",
-              "$ref": "DOM.NodeId",
-              "optional": true,
-              "description": "Set if the load was triggered by a DOM node, in addition to the other initiator information."
-            }
-          ]
-        },
-        {
-          "id": "NetworkStage",
-          "type": "string",
-          "description": "Different stages of a network request.",
-          "enum": ["request", "response"]
-        },
-        {
-          "id": "ResourceErrorType",
-          "type": "string",
-          "description": "Different stages of a network request.",
-          "enum": ["General", "AccessControl", "Cancellation", "Timeout"]
-        }
-      ],
+      "domain": "LifecycleReporter",
+      "description": "LifecycleReporter domain allows reporting of lifecycle events.",
+      "debuggableTypes": ["itml", "javascript"],
+      "targetTypes": ["itml", "javascript"],
+      "types": [],
       "commands": [
         {
           "name": "enable",
-          "description": "Enables network tracking, network events will now be delivered to the client."
+          "description": "Enables LifecycleReporter domain events."
         },
         {
           "name": "disable",
-          "description": "Disables network tracking, prevents network events from being sent to the client."
+          "description": "Disables LifecycleReporter domain events."
         },
         {
-          "name": "setExtraHTTPHeaders",
-          "description": "Specifies whether to always send extra HTTP headers with the requests from this page.",
-          "targetTypes": ["page"],
-          "parameters": [{ "name": "headers", "$ref": "Headers", "description": "Map with extra HTTP headers." }]
+          "name": "preventExit",
+          "description": "Prevents the process from exiting."
         },
         {
-          "name": "getResponseBody",
-          "description": "Returns content served for the given request.",
-          "parameters": [
-            {
-              "name": "requestId",
-              "$ref": "RequestId",
-              "description": "Identifier of the network request to get content for."
-            }
-          ],
-          "returns": [
-            { "name": "body", "type": "string", "description": "Response body." },
-            { "name": "base64Encoded", "type": "boolean", "description": "True, if content was sent as base64." }
-          ]
-        },
-        {
-          "name": "setResourceCachingDisabled",
-          "description": "Toggles whether the resource cache may be used when loading resources in the inspected page. If <code>true</code>, the resource cache will not be used when loading resources.",
-          "parameters": [
-            { "name": "disabled", "type": "boolean", "description": "Whether to prevent usage of the resource cache." }
-          ]
-        },
-        {
-          "name": "loadResource",
-          "description": "Loads a resource in the context of a frame on the inspected page without cross origin checks.",
-          "targetTypes": ["page"],
-          "async": true,
-          "parameters": [
-            { "name": "frameId", "$ref": "FrameId", "description": "Frame to load the resource from." },
-            { "name": "url", "type": "string", "description": "URL of the resource to load." }
-          ],
-          "returns": [
-            { "name": "content", "type": "string", "description": "Resource content." },
-            { "name": "mimeType", "type": "string", "description": "Resource mimeType." },
-            { "name": "status", "type": "integer", "description": "HTTP response status code." }
-          ]
-        },
-        {
-          "name": "getSerializedCertificate",
-          "description": "Fetches a serialized secure certificate for the given requestId to be displayed via InspectorFrontendHost.showCertificate.",
-          "targetTypes": ["page"],
-          "parameters": [{ "name": "requestId", "$ref": "RequestId" }],
-          "returns": [
-            {
-              "name": "serializedCertificate",
-              "type": "string",
-              "description": "Represents a base64 encoded WebCore::CertificateInfo object."
-            }
-          ]
-        },
-        {
-          "name": "resolveWebSocket",
-          "description": "Resolves JavaScript WebSocket object for given request id.",
-          "targetTypes": ["page"],
-          "parameters": [
-            {
-              "name": "requestId",
-              "$ref": "RequestId",
-              "description": "Identifier of the WebSocket resource to resolve."
-            },
-            {
-              "name": "objectGroup",
-              "type": "string",
-              "optional": true,
-              "description": "Symbolic group name that can be used to release multiple objects."
-            }
-          ],
-          "returns": [
-            {
-              "name": "object",
-              "$ref": "Runtime.RemoteObject",
-              "description": "JavaScript object wrapper for given node."
-            }
-          ]
-        },
-        {
-          "name": "setInterceptionEnabled",
-          "description": "Enable interception of network requests.",
-          "targetTypes": ["page"],
-          "parameters": [{ "name": "enabled", "type": "boolean" }]
-        },
-        {
-          "name": "addInterception",
-          "description": "Add an interception.",
-          "targetTypes": ["page"],
-          "parameters": [
-            {
-              "name": "url",
-              "type": "string",
-              "description": "URL pattern to intercept, intercept everything if not specified or empty"
-            },
-            { "name": "stage", "$ref": "NetworkStage", "description": "Stage to intercept." },
-            {
-              "name": "caseSensitive",
-              "type": "boolean",
-              "optional": true,
-              "description": "If false, ignores letter casing of `url` parameter."
-            },
-            {
-              "name": "isRegex",
-              "type": "boolean",
-              "optional": true,
-              "description": "If true, treats `url` parameter as a regular expression."
-            }
-          ]
-        },
-        {
-          "name": "removeInterception",
-          "description": "Remove an interception.",
-          "targetTypes": ["page"],
-          "parameters": [
-            { "name": "url", "type": "string" },
-            { "name": "stage", "$ref": "NetworkStage", "description": "Stage to intercept." },
-            {
-              "name": "caseSensitive",
-              "type": "boolean",
-              "optional": true,
-              "description": "If false, ignores letter casing of `url` parameter."
-            },
-            {
-              "name": "isRegex",
-              "type": "boolean",
-              "optional": true,
-              "description": "If true, treats `url` parameter as a regular expression."
-            }
-          ]
-        },
-        {
-          "name": "interceptContinue",
-          "description": "Continue request or response without modifications.",
-          "targetTypes": ["page"],
-          "parameters": [
-            {
-              "name": "requestId",
-              "$ref": "RequestId",
-              "description": "Identifier for the intercepted Network request or response to continue."
-            },
-            { "name": "stage", "$ref": "NetworkStage", "description": "Stage to continue." }
-          ]
-        },
-        {
-          "name": "interceptWithRequest",
-          "description": "Replace intercepted request with the provided one.",
-          "targetTypes": ["page"],
-          "parameters": [
-            {
-              "name": "requestId",
-              "$ref": "RequestId",
-              "description": "Identifier for the intercepted Network request or response to continue."
-            },
-            { "name": "url", "type": "string", "optional": true, "description": "HTTP request url." },
-            { "name": "method", "type": "string", "optional": true, "description": "HTTP request method." },
-            {
-              "name": "headers",
-              "$ref": "Headers",
-              "optional": true,
-              "description": "HTTP response headers. Pass through original values if unmodified."
-            },
-            {
-              "name": "postData",
-              "type": "string",
-              "optional": true,
-              "description": "HTTP POST request data, base64-encoded."
-            }
-          ]
-        },
-        {
-          "name": "interceptWithResponse",
-          "description": "Provide response content for an intercepted response.",
-          "targetTypes": ["page"],
-          "parameters": [
-            {
-              "name": "requestId",
-              "$ref": "RequestId",
-              "description": "Identifier for the intercepted Network response to modify."
-            },
-            { "name": "content", "type": "string" },
-            { "name": "base64Encoded", "type": "boolean", "description": "True, if content was sent as base64." },
-            { "name": "mimeType", "type": "string", "optional": true, "description": "MIME Type for the data." },
-            {
-              "name": "status",
-              "type": "integer",
-              "optional": true,
-              "description": "HTTP response status code. Pass through original values if unmodified."
-            },
-            {
-              "name": "statusText",
-              "type": "string",
-              "optional": true,
-              "description": "HTTP response status text. Pass through original values if unmodified."
-            },
-            {
-              "name": "headers",
-              "$ref": "Headers",
-              "optional": true,
-              "description": "HTTP response headers. Pass through original values if unmodified."
-            }
-          ]
-        },
-        {
-          "name": "interceptRequestWithResponse",
-          "description": "Provide response for an intercepted request. Request completely bypasses the network in this case and is immediately fulfilled with the provided data.",
-          "targetTypes": ["page"],
-          "parameters": [
-            {
-              "name": "requestId",
-              "$ref": "RequestId",
-              "description": "Identifier for the intercepted Network response to modify."
-            },
-            { "name": "content", "type": "string" },
-            { "name": "base64Encoded", "type": "boolean", "description": "True, if content was sent as base64." },
-            { "name": "mimeType", "type": "string", "description": "MIME Type for the data." },
-            { "name": "status", "type": "integer", "description": "HTTP response status code." },
-            { "name": "statusText", "type": "string", "description": "HTTP response status text." },
-            { "name": "headers", "$ref": "Headers", "description": "HTTP response headers." }
-          ]
-        },
-        {
-          "name": "interceptRequestWithError",
-          "description": "Fail request with given error type.",
-          "targetTypes": ["page"],
-          "parameters": [
-            {
-              "name": "requestId",
-              "$ref": "RequestId",
-              "description": "Identifier for the intercepted Network request to fail."
-            },
-            {
-              "name": "errorType",
-              "$ref": "ResourceErrorType",
-              "description": "Deliver error reason for the request failure."
-            }
-          ]
-        },
-        {
-          "name": "setEmulatedConditions",
-          "description": "Emulate various network conditions (e.g. bytes per second, latency, etc.).",
-          "targetTypes": ["page"],
-          "condition": "defined(ENABLE_INSPECTOR_NETWORK_THROTTLING) && ENABLE_INSPECTOR_NETWORK_THROTTLING",
-          "parameters": [
-            {
-              "name": "bytesPerSecondLimit",
-              "type": "integer",
-              "optional": true,
-              "description": "Limits the bytes per second of requests if positive. Removes any limits if zero or not provided."
-            }
-          ]
+          "name": "stopPreventingExit",
+          "description": "Does not prevent the process from exiting."
         }
       ],
       "events": [
         {
-          "name": "requestWillBeSent",
-          "description": "Fired when page is about to send HTTP request.",
+          "name": "reload",
+          "parameters": []
+        },
+        {
+          "name": "error",
           "parameters": [
-            { "name": "requestId", "$ref": "RequestId", "description": "Request identifier." },
-            { "name": "frameId", "$ref": "FrameId", "description": "Frame identifier." },
-            { "name": "loaderId", "$ref": "LoaderId", "description": "Loader identifier." },
             {
-              "name": "documentURL",
+              "name": "message",
               "type": "string",
-              "description": "URL of the document this request is loaded for."
+              "description": "string associated with the error"
             },
-            { "name": "request", "$ref": "Request", "description": "Request data." },
-            { "name": "timestamp", "$ref": "Timestamp" },
-            { "name": "walltime", "$ref": "Walltime" },
-            { "name": "initiator", "$ref": "Initiator", "description": "Request initiator." },
             {
-              "name": "redirectResponse",
-              "optional": true,
-              "$ref": "Response",
-              "description": "Redirect response data."
-            },
-            { "name": "type", "$ref": "Page.ResourceType", "optional": true, "description": "Resource type." },
-            {
-              "name": "targetId",
+              "name": "name",
               "type": "string",
-              "optional": true,
-              "description": "Identifier for the context of where the load originated. In general this is the target identifier. For Workers this will be the workerId."
-            }
-          ]
-        },
-        {
-          "name": "responseReceived",
-          "description": "Fired when HTTP response is available.",
-          "parameters": [
-            { "name": "requestId", "$ref": "RequestId", "description": "Request identifier." },
-            { "name": "frameId", "$ref": "FrameId", "description": "Frame identifier." },
-            { "name": "loaderId", "$ref": "LoaderId", "description": "Loader identifier." },
-            { "name": "timestamp", "$ref": "Timestamp", "description": "Timestamp." },
-            { "name": "type", "$ref": "Page.ResourceType", "description": "Resource type." },
-            { "name": "response", "$ref": "Response", "description": "Response data." }
-          ]
-        },
-        {
-          "name": "dataReceived",
-          "description": "Fired when data chunk was received over the network.",
-          "parameters": [
-            { "name": "requestId", "$ref": "RequestId", "description": "Request identifier." },
-            { "name": "timestamp", "$ref": "Timestamp", "description": "Timestamp." },
-            { "name": "dataLength", "type": "integer", "description": "Data chunk length." },
-            {
-              "name": "encodedDataLength",
-              "type": "integer",
-              "description": "Actual bytes received (might be less than dataLength for compressed encodings)."
-            }
-          ]
-        },
-        {
-          "name": "loadingFinished",
-          "description": "Fired when HTTP request has finished loading.",
-          "parameters": [
-            { "name": "requestId", "$ref": "RequestId", "description": "Request identifier." },
-            { "name": "timestamp", "$ref": "Timestamp", "description": "Timestamp." },
-            {
-              "name": "sourceMapURL",
-              "type": "string",
-              "optional": true,
-              "description": "URL of source map associated with this resource (if any)."
-            },
-            { "name": "metrics", "$ref": "Metrics", "optional": true, "description": "Network metrics." }
-          ]
-        },
-        {
-          "name": "loadingFailed",
-          "description": "Fired when HTTP request has failed to load.",
-          "parameters": [
-            { "name": "requestId", "$ref": "RequestId", "description": "Request identifier." },
-            { "name": "timestamp", "$ref": "Timestamp", "description": "Timestamp." },
-            { "name": "errorText", "type": "string", "description": "User friendly error message." },
-            { "name": "canceled", "type": "boolean", "optional": true, "description": "True if loading was canceled." }
-          ]
-        },
-        {
-          "name": "requestServedFromMemoryCache",
-          "description": "Fired when HTTP request has been served from memory cache.",
-          "parameters": [
-            { "name": "requestId", "$ref": "RequestId", "description": "Request identifier." },
-            { "name": "frameId", "$ref": "FrameId", "description": "Frame identifier." },
-            { "name": "loaderId", "$ref": "LoaderId", "description": "Loader identifier." },
-            {
-              "name": "documentURL",
-              "type": "string",
-              "description": "URL of the document this request is loaded for."
-            },
-            { "name": "timestamp", "$ref": "Timestamp", "description": "Timestamp." },
-            { "name": "initiator", "$ref": "Initiator", "description": "Request initiator." },
-            { "name": "resource", "$ref": "CachedResource", "description": "Cached resource data." }
-          ]
-        },
-        {
-          "name": "requestIntercepted",
-          "description": "Fired when HTTP request has been intercepted. The frontend must respond with <code>Network.interceptContinue</code>, <code>Network.interceptWithRequest</code>` or <code>Network.interceptWithResponse</code>` to resolve this request.",
-          "targetTypes": ["page"],
-          "parameters": [
-            {
-              "name": "requestId",
-              "$ref": "RequestId",
-              "description": "Identifier for this intercepted network. Corresponds with an earlier <code>Network.requestWillBeSent</code>."
+              "description": "If an Error instance, the error.name property"
             },
             {
-              "name": "request",
-              "$ref": "Request",
-              "description": "Original request content that would proceed if this is continued."
-            }
-          ]
-        },
-        {
-          "name": "responseIntercepted",
-          "description": "Fired when HTTP response has been intercepted. The frontend must response with <code>Network.interceptContinue</code> or <code>Network.interceptWithResponse</code>` to continue this response.",
-          "targetTypes": ["page"],
-          "parameters": [
-            {
-              "name": "requestId",
-              "$ref": "RequestId",
-              "description": "Identifier for this intercepted network. Corresponds with an earlier <code>Network.requestWillBeSent</code>."
+              "name": "urls",
+              "type": "array",
+              "description": "Array of URLs associated with the error",
+              "items": {
+                "type": "string"
+              }
             },
             {
-              "name": "response",
-              "$ref": "Response",
-              "description": "Original response content that would proceed if this is continued."
+              "name": "lineColumns",
+              "type": "array",
+              "description": "Line, column pairs associated with the error. Already sourcemapped.",
+              "items": {
+                "type": "integer"
+              }
+            },
+            {
+              "name": "sourceLines",
+              "type": "array",
+              "description": "Source code preview associated with the error for up to 5 lines before the error, relative to the first non-internal stack frame.",
+              "items": {
+                "type": "string"
+              }
             }
           ]
-        },
-        {
-          "name": "webSocketWillSendHandshakeRequest",
-          "description": "Fired when WebSocket is about to initiate handshake.",
-          "targetTypes": ["page"],
-          "parameters": [
-            { "name": "requestId", "$ref": "RequestId", "description": "Request identifier." },
-            { "name": "timestamp", "$ref": "Timestamp" },
-            { "name": "walltime", "$ref": "Walltime" },
-            { "name": "request", "$ref": "WebSocketRequest", "description": "WebSocket request data." }
-          ]
-        },
-        {
-          "name": "webSocketHandshakeResponseReceived",
-          "description": "Fired when WebSocket handshake response becomes available.",
-          "targetTypes": ["page"],
-          "parameters": [
-            { "name": "requestId", "$ref": "RequestId", "description": "Request identifier." },
-            { "name": "timestamp", "$ref": "Timestamp" },
-            { "name": "response", "$ref": "WebSocketResponse", "description": "WebSocket response data." }
-          ]
-        },
-        {
-          "name": "webSocketCreated",
-          "description": "Fired upon WebSocket creation.",
-          "targetTypes": ["page"],
-          "parameters": [
-            { "name": "requestId", "$ref": "RequestId", "description": "Request identifier." },
-            { "name": "url", "type": "string", "description": "WebSocket request URL." }
-          ]
-        },
-        {
-          "name": "webSocketClosed",
-          "description": "Fired when WebSocket is closed.",
-          "targetTypes": ["page"],
-          "parameters": [
-            { "name": "requestId", "$ref": "RequestId", "description": "Request identifier." },
-            { "name": "timestamp", "$ref": "Timestamp", "description": "Timestamp." }
-          ]
-        },
-        {
-          "name": "webSocketFrameReceived",
-          "description": "Fired when WebSocket frame is received.",
-          "targetTypes": ["page"],
-          "parameters": [
-            { "name": "requestId", "$ref": "RequestId", "description": "Request identifier." },
-            { "name": "timestamp", "$ref": "Timestamp", "description": "Timestamp." },
-            { "name": "response", "$ref": "WebSocketFrame", "description": "WebSocket response data." }
-          ]
-        },
-        {
-          "name": "webSocketFrameError",
-          "description": "Fired when WebSocket frame error occurs.",
-          "targetTypes": ["page"],
-          "parameters": [
-            { "name": "requestId", "$ref": "RequestId", "description": "Request identifier." },
-            { "name": "timestamp", "$ref": "Timestamp", "description": "Timestamp." },
-            { "name": "errorMessage", "type": "string", "description": "WebSocket frame error message." }
-          ]
-        },
-        {
-          "name": "webSocketFrameSent",
-          "description": "Fired when WebSocket frame is sent.",
-          "targetTypes": ["page"],
-          "parameters": [
-            { "name": "requestId", "$ref": "RequestId", "description": "Request identifier." },
-            { "name": "timestamp", "$ref": "Timestamp", "description": "Timestamp." },
-            { "name": "response", "$ref": "WebSocketFrame", "description": "WebSocket response data." }
-          ]
         }
       ]
     },
@@ -2031,7 +1680,11 @@
       "debuggableTypes": ["itml", "javascript", "page", "service-worker", "web-page"],
       "targetTypes": ["itml", "javascript", "page", "service-worker", "worker"],
       "types": [
-        { "id": "RemoteObjectId", "type": "string", "description": "Unique object identifier." },
+        {
+          "id": "RemoteObjectId",
+          "type": "string",
+          "description": "Unique object identifier."
+        },
         {
           "id": "RemoteObject",
           "type": "object",
@@ -2162,14 +1815,18 @@
             {
               "name": "properties",
               "type": "array",
-              "items": { "$ref": "PropertyPreview" },
+              "items": {
+                "$ref": "PropertyPreview"
+              },
               "optional": true,
               "description": "List of the properties."
             },
             {
               "name": "entries",
               "type": "array",
-              "items": { "$ref": "EntryPreview" },
+              "items": {
+                "$ref": "EntryPreview"
+              },
               "optional": true,
               "description": "List of the entries. Specified for <code>map</code> and <code>set</code> subtype values only."
             },
@@ -2185,7 +1842,11 @@
           "id": "PropertyPreview",
           "type": "object",
           "properties": [
-            { "name": "name", "type": "string", "description": "Property name." },
+            {
+              "name": "name",
+              "type": "string",
+              "description": "Property name."
+            },
             {
               "name": "type",
               "type": "string",
@@ -2260,7 +1921,11 @@
               "optional": true,
               "description": "Entry key. Specified for map-like collection entries."
             },
-            { "name": "value", "$ref": "ObjectPreview", "description": "Entry value." }
+            {
+              "name": "value",
+              "$ref": "ObjectPreview",
+              "description": "Entry value."
+            }
           ]
         },
         {
@@ -2273,7 +1938,11 @@
               "optional": true,
               "description": "Entry key of a map-like collection, otherwise not provided."
             },
-            { "name": "value", "$ref": "Runtime.RemoteObject", "description": "Entry value." }
+            {
+              "name": "value",
+              "$ref": "Runtime.RemoteObject",
+              "description": "Entry value."
+            }
           ]
         },
         {
@@ -2281,7 +1950,11 @@
           "type": "object",
           "description": "Object property descriptor.",
           "properties": [
-            { "name": "name", "type": "string", "description": "Property name or symbol description." },
+            {
+              "name": "name",
+              "type": "string",
+              "description": "Property name or symbol description."
+            },
             {
               "name": "value",
               "$ref": "RemoteObject",
@@ -2355,7 +2028,11 @@
           "type": "object",
           "description": "Object internal property descriptor. This property isn't normally visible in JavaScript code.",
           "properties": [
-            { "name": "name", "type": "string", "description": "Conventional property name." },
+            {
+              "name": "name",
+              "type": "string",
+              "description": "Conventional property name."
+            },
             {
               "name": "value",
               "$ref": "RemoteObject",
@@ -2369,11 +2046,25 @@
           "type": "object",
           "description": "Represents function call argument. Either remote object id <code>objectId</code> or primitive <code>value</code> or neither of (for undefined) them should be specified.",
           "properties": [
-            { "name": "value", "type": "any", "optional": true, "description": "Primitive value." },
-            { "name": "objectId", "$ref": "RemoteObjectId", "optional": true, "description": "Remote object handle." }
+            {
+              "name": "value",
+              "type": "any",
+              "optional": true,
+              "description": "Primitive value."
+            },
+            {
+              "name": "objectId",
+              "$ref": "RemoteObjectId",
+              "optional": true,
+              "description": "Remote object handle."
+            }
           ]
         },
-        { "id": "ExecutionContextId", "type": "integer", "description": "Id of an execution context." },
+        {
+          "id": "ExecutionContextId",
+          "type": "integer",
+          "description": "Id of an execution context."
+        },
         {
           "id": "ExecutionContextType",
           "type": "string",
@@ -2390,9 +2081,20 @@
               "$ref": "ExecutionContextId",
               "description": "Unique id of the execution context. It can be used to specify in which execution context script evaluation should be performed."
             },
-            { "name": "type", "$ref": "ExecutionContextType" },
-            { "name": "name", "type": "string", "description": "Human readable name describing given context." },
-            { "name": "frameId", "$ref": "Network.FrameId", "description": "Id of the owning frame." }
+            {
+              "name": "type",
+              "$ref": "ExecutionContextType"
+            },
+            {
+              "name": "name",
+              "type": "string",
+              "description": "Human readable name describing given context."
+            },
+            {
+              "name": "frameId",
+              "$ref": "Network.FrameId",
+              "description": "Id of the owning frame."
+            }
           ]
         },
         {
@@ -2406,8 +2108,16 @@
           "type": "object",
           "description": "Range of an error in source code.",
           "properties": [
-            { "name": "startOffset", "type": "integer", "description": "Start offset of range (inclusive)." },
-            { "name": "endOffset", "type": "integer", "description": "End offset of range (exclusive)." }
+            {
+              "name": "startOffset",
+              "type": "integer",
+              "description": "Start offset of range (inclusive)."
+            },
+            {
+              "name": "endOffset",
+              "type": "integer",
+              "description": "End offset of range (exclusive)."
+            }
           ]
         },
         {
@@ -2417,14 +2127,18 @@
             {
               "name": "fields",
               "type": "array",
-              "items": { "type": "string" },
+              "items": {
+                "type": "string"
+              },
               "optional": true,
               "description": "Array of strings, where the strings represent object properties."
             },
             {
               "name": "optionalFields",
               "type": "array",
-              "items": { "type": "string" },
+              "items": {
+                "type": "string"
+              },
               "optional": true,
               "description": "Array of strings, where the strings represent optional object properties."
             },
@@ -2529,7 +2243,9 @@
             {
               "name": "structures",
               "type": "array",
-              "items": { "$ref": "StructureDescription" },
+              "items": {
+                "$ref": "StructureDescription"
+              },
               "optional": true,
               "description": "Array of descriptions for all structures seen for this variable."
             },
@@ -2551,8 +2267,16 @@
               "type": "integer",
               "description": "What kind of type information do we want (normal, function return values, 'this' statement)."
             },
-            { "name": "sourceID", "type": "string", "description": "sourceID uniquely identifying a script" },
-            { "name": "divot", "type": "integer", "description": "character offset for assignment range" }
+            {
+              "name": "sourceID",
+              "type": "string",
+              "description": "sourceID uniquely identifying a script"
+            },
+            {
+              "name": "divot",
+              "type": "integer",
+              "description": "character offset for assignment range"
+            }
           ]
         },
         {
@@ -2560,8 +2284,16 @@
           "type": "object",
           "description": "From Wikipedia: a basic block is a portion of the code within a program with only one entry point and only one exit point. This type gives the location of a basic block and if that basic block has executed.",
           "properties": [
-            { "name": "startOffset", "type": "integer", "description": "Start offset of the basic block." },
-            { "name": "endOffset", "type": "integer", "description": "End offset of the basic block." },
+            {
+              "name": "startOffset",
+              "type": "integer",
+              "description": "Start offset of the basic block."
+            },
+            {
+              "name": "endOffset",
+              "type": "integer",
+              "description": "End offset of the basic block."
+            },
             {
               "name": "hasExecuted",
               "type": "boolean",
@@ -2579,10 +2311,25 @@
         {
           "name": "parse",
           "description": "Parses JavaScript source code for errors.",
-          "parameters": [{ "name": "source", "type": "string", "description": "Source code to parse." }],
+          "parameters": [
+            {
+              "name": "source",
+              "type": "string",
+              "description": "Source code to parse."
+            }
+          ],
           "returns": [
-            { "name": "result", "$ref": "SyntaxErrorType", "description": "Parse result." },
-            { "name": "message", "type": "string", "optional": true, "description": "Parse error message." },
+            {
+              "name": "result",
+              "$ref": "SyntaxErrorType",
+              "description": "Parse result."
+            },
+            {
+              "name": "message",
+              "type": "string",
+              "optional": true,
+              "description": "Parse error message."
+            },
             {
               "name": "range",
               "$ref": "ErrorRange",
@@ -2595,7 +2342,11 @@
           "name": "evaluate",
           "description": "Evaluates expression on global object.",
           "parameters": [
-            { "name": "expression", "type": "string", "description": "Expression to evaluate." },
+            {
+              "name": "expression",
+              "type": "string",
+              "description": "Expression to evaluate."
+            },
             {
               "name": "objectGroup",
               "type": "string",
@@ -2646,7 +2397,11 @@
             }
           ],
           "returns": [
-            { "name": "result", "$ref": "RemoteObject", "description": "Evaluation result." },
+            {
+              "name": "result",
+              "$ref": "RemoteObject",
+              "description": "Evaluation result."
+            },
             {
               "name": "wasThrown",
               "type": "boolean",
@@ -2665,7 +2420,11 @@
           "name": "awaitPromise",
           "description": "Calls the async callback when the promise with the given ID gets settled.",
           "parameters": [
-            { "name": "promiseObjectId", "$ref": "RemoteObjectId", "description": "Identifier of the promise." },
+            {
+              "name": "promiseObjectId",
+              "$ref": "RemoteObjectId",
+              "description": "Identifier of the promise."
+            },
             {
               "name": "returnByValue",
               "type": "boolean",
@@ -2686,7 +2445,11 @@
             }
           ],
           "returns": [
-            { "name": "result", "$ref": "RemoteObject", "description": "Evaluation result." },
+            {
+              "name": "result",
+              "$ref": "RemoteObject",
+              "description": "Evaluation result."
+            },
             {
               "name": "wasThrown",
               "type": "boolean",
@@ -2711,11 +2474,18 @@
               "$ref": "RemoteObjectId",
               "description": "Identifier of the object to call function on."
             },
-            { "name": "functionDeclaration", "type": "string", "description": "Declaration of the function to call." },
+            {
+              "name": "functionDeclaration",
+              "type": "string",
+              "description": "Declaration of the function to call."
+            },
             {
               "name": "arguments",
               "type": "array",
-              "items": { "$ref": "CallArgument", "description": "Call argument." },
+              "items": {
+                "$ref": "CallArgument",
+                "description": "Call argument."
+              },
               "optional": true,
               "description": "Call arguments. All call arguments must belong to the same JavaScript world as the target object."
             },
@@ -2751,7 +2521,11 @@
             }
           ],
           "returns": [
-            { "name": "result", "$ref": "RemoteObject", "description": "Call result." },
+            {
+              "name": "result",
+              "$ref": "RemoteObject",
+              "description": "Call result."
+            },
             {
               "name": "wasThrown",
               "type": "boolean",
@@ -2771,7 +2545,12 @@
               "description": "Identifier of the object to return a preview for."
             }
           ],
-          "returns": [{ "name": "preview", "$ref": "ObjectPreview" }]
+          "returns": [
+            {
+              "name": "preview",
+              "$ref": "ObjectPreview"
+            }
+          ]
         },
         {
           "name": "getProperties",
@@ -2811,14 +2590,18 @@
             {
               "name": "properties",
               "type": "array",
-              "items": { "$ref": "PropertyDescriptor" },
+              "items": {
+                "$ref": "PropertyDescriptor"
+              },
               "description": "Object properties."
             },
             {
               "name": "internalProperties",
               "optional": true,
               "type": "array",
-              "items": { "$ref": "InternalPropertyDescriptor" },
+              "items": {
+                "$ref": "InternalPropertyDescriptor"
+              },
               "description": "Internal object properties. Only included if `fetchStart` is 0."
             }
           ]
@@ -2855,14 +2638,18 @@
             {
               "name": "properties",
               "type": "array",
-              "items": { "$ref": "PropertyDescriptor" },
+              "items": {
+                "$ref": "PropertyDescriptor"
+              },
               "description": "Object properties."
             },
             {
               "name": "internalProperties",
               "optional": true,
               "type": "array",
-              "items": { "$ref": "InternalPropertyDescriptor" },
+              "items": {
+                "$ref": "InternalPropertyDescriptor"
+              },
               "description": "Internal object properties. Only included if `fetchStart` is 0."
             }
           ]
@@ -2899,7 +2686,9 @@
             {
               "name": "entries",
               "type": "array",
-              "items": { "$ref": "CollectionEntry" },
+              "items": {
+                "$ref": "CollectionEntry"
+              },
               "description": "Array of collection entries."
             }
           ]
@@ -2908,7 +2697,11 @@
           "name": "saveResult",
           "description": "Assign a saved result index to this value.",
           "parameters": [
-            { "name": "value", "$ref": "CallArgument", "description": "Id or value of the object to save." },
+            {
+              "name": "value",
+              "$ref": "CallArgument",
+              "description": "Id or value of the object to save."
+            },
             {
               "name": "contextId",
               "optional": true,
@@ -2941,19 +2734,32 @@
           "name": "releaseObject",
           "description": "Releases remote object with given id.",
           "parameters": [
-            { "name": "objectId", "$ref": "RemoteObjectId", "description": "Identifier of the object to release." }
+            {
+              "name": "objectId",
+              "$ref": "RemoteObjectId",
+              "description": "Identifier of the object to release."
+            }
           ]
         },
         {
           "name": "releaseObjectGroup",
           "description": "Releases all remote objects that belong to a given group.",
-          "parameters": [{ "name": "objectGroup", "type": "string", "description": "Symbolic object group name." }]
+          "parameters": [
+            {
+              "name": "objectGroup",
+              "type": "string",
+              "description": "Symbolic object group name."
+            }
+          ]
         },
         {
           "name": "enable",
           "description": "Enables reporting of execution contexts creation by means of <code>executionContextCreated</code> event. When the reporting gets enabled the event will be sent immediately for each existing execution context."
         },
-        { "name": "disable", "description": "Disables reporting of execution contexts creation." },
+        {
+          "name": "disable",
+          "description": "Disables reporting of execution contexts creation."
+        },
         {
           "name": "getRuntimeTypesForVariablesAtOffsets",
           "description": "Returns detailed information on the given function.",
@@ -2961,7 +2767,9 @@
             {
               "name": "locations",
               "type": "array",
-              "items": { "$ref": "TypeLocation" },
+              "items": {
+                "$ref": "TypeLocation"
+              },
               "description": "An array of type locations we're requesting information for. Results are expected in the same order they're sent in."
             }
           ],
@@ -2969,14 +2777,29 @@
             {
               "name": "types",
               "type": "array",
-              "items": { "$ref": "TypeDescription", "description": "Types for requested variable." }
+              "items": {
+                "$ref": "TypeDescription",
+                "description": "Types for requested variable."
+              }
             }
           ]
         },
-        { "name": "enableTypeProfiler", "description": "Enables type profiling on the VM." },
-        { "name": "disableTypeProfiler", "description": "Disables type profiling on the VM." },
-        { "name": "enableControlFlowProfiler", "description": "Enables control flow profiling on the VM." },
-        { "name": "disableControlFlowProfiler", "description": "Disables control flow profiling on the VM." },
+        {
+          "name": "enableTypeProfiler",
+          "description": "Enables type profiling on the VM."
+        },
+        {
+          "name": "disableTypeProfiler",
+          "description": "Disables type profiling on the VM."
+        },
+        {
+          "name": "enableControlFlowProfiler",
+          "description": "Enables control flow profiling on the VM."
+        },
+        {
+          "name": "disableControlFlowProfiler",
+          "description": "Disables control flow profiling on the VM."
+        },
         {
           "name": "getBasicBlocks",
           "description": "Returns a list of basic blocks for the given sourceID with information about their text ranges and whether or not they have executed.",
@@ -2991,7 +2814,10 @@
             {
               "name": "basicBlocks",
               "type": "array",
-              "items": { "$ref": "BasicBlock", "description": "Array of basic blocks." }
+              "items": {
+                "$ref": "BasicBlock",
+                "description": "Array of basic blocks."
+              }
             }
           ]
         }
@@ -3016,49 +2842,94 @@
       "debuggableTypes": ["itml", "javascript", "page", "web-page"],
       "targetTypes": ["itml", "javascript", "page"],
       "types": [
-        { "id": "EventType", "type": "string", "enum": ["API", "Microtask", "Other"] },
+        {
+          "id": "EventType",
+          "type": "string",
+          "enum": ["API", "Microtask", "Other"]
+        },
         {
           "id": "Event",
           "type": "object",
           "properties": [
-            { "name": "startTime", "type": "number" },
-            { "name": "endTime", "type": "number" },
-            { "name": "type", "$ref": "EventType" }
+            {
+              "name": "startTime",
+              "type": "number"
+            },
+            {
+              "name": "endTime",
+              "type": "number"
+            },
+            {
+              "name": "type",
+              "$ref": "EventType"
+            }
           ]
         },
         {
           "id": "ExpressionLocation",
           "type": "object",
           "properties": [
-            { "name": "line", "type": "integer", "description": "1-based." },
-            { "name": "column", "type": "integer", "description": "1-based." }
+            {
+              "name": "line",
+              "type": "integer",
+              "description": "1-based."
+            },
+            {
+              "name": "column",
+              "type": "integer",
+              "description": "1-based."
+            }
           ]
         },
         {
           "id": "StackFrame",
           "type": "object",
           "properties": [
-            { "name": "sourceID", "$ref": "Debugger.ScriptId", "description": "Unique script identifier." },
+            {
+              "name": "sourceID",
+              "$ref": "Debugger.ScriptId",
+              "description": "Unique script identifier."
+            },
             {
               "name": "name",
               "type": "string",
               "description": "A displayable name for the stack frame. i.e function name, (program), etc."
             },
-            { "name": "line", "type": "integer", "description": "-1 if unavailable. 1-based if available." },
-            { "name": "column", "type": "integer", "description": "-1 if unavailable. 1-based if available." },
-            { "name": "url", "type": "string" },
-            { "name": "expressionLocation", "$ref": "ExpressionLocation", "optional": true }
+            {
+              "name": "line",
+              "type": "integer",
+              "description": "-1 if unavailable. 1-based if available."
+            },
+            {
+              "name": "column",
+              "type": "integer",
+              "description": "-1 if unavailable. 1-based if available."
+            },
+            {
+              "name": "url",
+              "type": "string"
+            },
+            {
+              "name": "expressionLocation",
+              "$ref": "ExpressionLocation",
+              "optional": true
+            }
           ]
         },
         {
           "id": "StackTrace",
           "type": "object",
           "properties": [
-            { "name": "timestamp", "type": "number" },
+            {
+              "name": "timestamp",
+              "type": "number"
+            },
             {
               "name": "stackFrames",
               "type": "array",
-              "items": { "$ref": "StackFrame" },
+              "items": {
+                "$ref": "StackFrame"
+              },
               "description": "First array item is the bottom of the call stack and last array item is the top of the call stack."
             }
           ]
@@ -3066,7 +2937,15 @@
         {
           "id": "Samples",
           "type": "object",
-          "properties": [{ "name": "stackTraces", "type": "array", "items": { "$ref": "StackTrace" } }]
+          "properties": [
+            {
+              "name": "stackTraces",
+              "type": "array",
+              "items": {
+                "$ref": "StackTrace"
+              }
+            }
+          ]
         }
       ],
       "commands": [
@@ -3091,19 +2970,125 @@
         {
           "name": "trackingStart",
           "description": "Tracking started.",
-          "parameters": [{ "name": "timestamp", "type": "number" }]
+          "parameters": [
+            {
+              "name": "timestamp",
+              "type": "number"
+            }
+          ]
         },
         {
           "name": "trackingUpdate",
           "description": "Periodic tracking updates with event data.",
-          "parameters": [{ "name": "event", "$ref": "Event" }]
+          "parameters": [
+            {
+              "name": "event",
+              "$ref": "Event"
+            }
+          ]
         },
         {
           "name": "trackingComplete",
           "description": "Tracking stopped. Includes any buffered data during tracking, such as profiling information.",
           "parameters": [
-            { "name": "timestamp", "type": "number" },
-            { "name": "samples", "$ref": "Samples", "optional": true, "description": "Stack traces." }
+            {
+              "name": "timestamp",
+              "type": "number"
+            },
+            {
+              "name": "samples",
+              "$ref": "Samples",
+              "optional": true,
+              "description": "Stack traces."
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "domain": "TestReporter",
+      "description": "TestReporter domain allows reporting of test-related events.",
+      "debuggableTypes": ["itml", "javascript"],
+      "targetTypes": ["itml", "javascript"],
+      "types": [
+        {
+          "id": "TestStatus",
+          "type": "string",
+          "enum": ["pass", "fail", "timeout", "skip", "todo"]
+        }
+      ],
+      "commands": [
+        {
+          "name": "enable",
+          "description": "Enables TestReporter domain events."
+        },
+        {
+          "name": "disable",
+          "description": "Disables TestReporter domain events."
+        }
+      ],
+      "events": [
+        {
+          "name": "found",
+          "parameters": [
+            {
+              "name": "id",
+              "type": "integer",
+              "description": "Unique identifier of the test that was found."
+            },
+            {
+              "name": "scriptId",
+              "$ref": "Debugger.ScriptId",
+              "description": "Unique identifier of the script the test is in. Available when the debugger is attached.",
+              "optional": true
+            },
+            {
+              "name": "url",
+              "type": "string",
+              "description": "url of the script the test is in. Available when the debugger is not attached.",
+              "optional": true
+            },
+            {
+              "name": "line",
+              "type": "integer",
+              "description": "Line number in the script that started the test."
+            },
+            {
+              "name": "name",
+              "type": "string",
+              "description": "Name of the test that started.",
+              "optional": true
+            }
+          ]
+        },
+        {
+          "name": "start",
+          "parameters": [
+            {
+              "name": "id",
+              "type": "integer",
+              "description": "Unique identifier of the test that started."
+            }
+          ]
+        },
+        {
+          "name": "end",
+          "parameters": [
+            {
+              "name": "id",
+              "type": "integer",
+              "description": "Unique identifier of the test that ended."
+            },
+            {
+              "name": "status",
+              "$ref": "TestStatus",
+              "description": "Status of the test that ended."
+            },
+            {
+              "name": "elapsed",
+              "type": "integer",
+              "description": "Elapsed time in milliseconds since the test started."
+            }
           ]
         }
       ]
diff --git a/packages/bun-inspector-protocol/tsconfig.json b/packages/bun-inspector-protocol/tsconfig.json
index 4710b24d4f..ca927884c7 100644
--- a/packages/bun-inspector-protocol/tsconfig.json
+++ b/packages/bun-inspector-protocol/tsconfig.json
@@ -3,7 +3,7 @@
     "lib": ["ESNext"],
     "module": "ESNext",
     "target": "ESNext",
-    "moduleResolution": "NodeNext",
+    "moduleResolution": "Bundler",
     "moduleDetection": "force",
     "strict": true,
     "downlevelIteration": true,
@@ -12,7 +12,7 @@
     "forceConsistentCasingInFileNames": true,
     "inlineSourceMap": true,
     "allowJs": true,
-    "outDir": "dist",
+    "outDir": "dist"
   },
   "include": [".", "../bun-types/index.d.ts"]
 }
diff --git a/packages/bun-linux-x64/.npmignore b/packages/bun-linux-x64/.npmignore
deleted file mode 100644
index 08d23cb2a7..0000000000
--- a/packages/bun-linux-x64/.npmignore
+++ /dev/null
@@ -1,4 +0,0 @@
-bin/bun-profile
-bin/*.o
-*.o
-*.a
\ No newline at end of file
diff --git a/packages/bun-native-bundler-plugin-api/bundler_plugin.h b/packages/bun-native-bundler-plugin-api/bundler_plugin.h
new file mode 100644
index 0000000000..ff10c27ccd
--- /dev/null
+++ b/packages/bun-native-bundler-plugin-api/bundler_plugin.h
@@ -0,0 +1,73 @@
+#ifndef BUN_NATIVE_BUNDLER_PLUGIN_API_H
+#define BUN_NATIVE_BUNDLER_PLUGIN_API_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+typedef enum {
+  BUN_LOADER_JSX = 0,
+  BUN_LOADER_JS = 1,
+  BUN_LOADER_TS = 2,
+  BUN_LOADER_TSX = 3,
+  BUN_LOADER_CSS = 4,
+  BUN_LOADER_FILE = 5,
+  BUN_LOADER_JSON = 6,
+  BUN_LOADER_TOML = 7,
+  BUN_LOADER_WASM = 8,
+  BUN_LOADER_NAPI = 9,
+  BUN_LOADER_BASE64 = 10,
+  BUN_LOADER_DATAURL = 11,
+  BUN_LOADER_TEXT = 12,
+} BunLoader;
+
+const BunLoader BUN_LOADER_MAX = BUN_LOADER_TEXT;
+
+typedef struct BunLogOptions {
+  size_t __struct_size;
+  const uint8_t *message_ptr;
+  size_t message_len;
+  const uint8_t *path_ptr;
+  size_t path_len;
+  const uint8_t *source_line_text_ptr;
+  size_t source_line_text_len;
+  int8_t level;
+  int line;
+  int lineEnd;
+  int column;
+  int columnEnd;
+} BunLogOptions;
+
+typedef struct {
+  size_t __struct_size;
+  void *bun;
+  const uint8_t *path_ptr;
+  size_t path_len;
+  const uint8_t *namespace_ptr;
+  size_t namespace_len;
+  uint8_t default_loader;
+  void *external;
+} OnBeforeParseArguments;
+
+typedef struct OnBeforeParseResult {
+  size_t __struct_size;
+  uint8_t *source_ptr;
+  size_t source_len;
+  uint8_t loader;
+  int (*fetchSourceCode)(const OnBeforeParseArguments *args,
+                         struct OnBeforeParseResult *result);
+  void *plugin_source_code_context;
+  void (*free_plugin_source_code_context)(void *ctx);
+  void (*log)(const OnBeforeParseArguments *args, BunLogOptions *options);
+} OnBeforeParseResult;
+
+typedef enum {
+  BUN_LOG_LEVEL_VERBOSE = 0,
+  BUN_LOG_LEVEL_DEBUG = 1,
+  BUN_LOG_LEVEL_INFO = 2,
+  BUN_LOG_LEVEL_WARN = 3,
+  BUN_LOG_LEVEL_ERROR = 4,
+} BunLogLevel;
+
+const BunLogLevel BUN_LOG_MAX = BUN_LOG_LEVEL_ERROR;
+
+#endif // BUN_NATIVE_BUNDLER_PLUGIN_API_H
diff --git a/packages/bun-native-plugin-rs/.gitignore b/packages/bun-native-plugin-rs/.gitignore
new file mode 100644
index 0000000000..2f7896d1d1
--- /dev/null
+++ b/packages/bun-native-plugin-rs/.gitignore
@@ -0,0 +1 @@
+target/
diff --git a/packages/bun-native-plugin-rs/Cargo.lock b/packages/bun-native-plugin-rs/Cargo.lock
new file mode 100644
index 0000000000..202700fa3a
--- /dev/null
+++ b/packages/bun-native-plugin-rs/Cargo.lock
@@ -0,0 +1,286 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "bindgen"
+version = "0.70.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f49d8fed880d473ea71efb9bf597651e77201bdd4893efe54c9e5d65ae04ce6f"
+dependencies = [
+ "bitflags",
+ "cexpr",
+ "clang-sys",
+ "itertools",
+ "log",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "rustc-hash",
+ "shlex",
+ "syn",
+]
+
+[[package]]
+name = "bitflags"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
+
+[[package]]
+name = "bun-native-plugin"
+version = "0.1.0"
+dependencies = [
+ "bindgen",
+]
+
+[[package]]
+name = "cexpr"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
+dependencies = [
+ "nom",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "clang-sys"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b023947811758c97c59bf9d1c188fd619ad4718dcaa767947df1cadb14f39f4"
+dependencies = [
+ "glob",
+ "libc",
+ "libloading",
+]
+
+[[package]]
+name = "either"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0"
+
+[[package]]
+name = "glob"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
+
+[[package]]
+name = "itertools"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.166"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2ccc108bbc0b1331bd061864e7cd823c0cab660bbe6970e66e2c0614decde36"
+
+[[package]]
+name = "libloading"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4979f22fdb869068da03c9f7528f8297c6fd2606bc3a4affe42e6a823fdb8da4"
+dependencies = [
+ "cfg-if",
+ "windows-targets",
+]
+
+[[package]]
+name = "log"
+version = "0.4.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
+
+[[package]]
+name = "memchr"
+version = "2.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
+
+[[package]]
+name = "minimal-lexical"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+
+[[package]]
+name = "nom"
+version = "7.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
+dependencies = [
+ "memchr",
+ "minimal-lexical",
+]
+
+[[package]]
+name = "prettyplease"
+version = "0.2.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64d1ec885c64d0457d564db4ec299b2dae3f9c02808b8ad9c3a089c591b18033"
+dependencies = [
+ "proc-macro2",
+ "syn",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.92"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37d3544b3f2748c54e147655edb5025752e2303145b5aefb3c3ea2c78b973bb0"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "regex"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
+
+[[package]]
+name = "rustc-hash"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "syn"
+version = "2.0.89"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44d46482f1c1c87acd84dea20c1bf5ebff4c757009ed6bf19cfd36fb10e92c4e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adb9e6ca4f869e1180728b7950e35922a7fc6397f7b641499e8f3ef06e50dc83"
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
diff --git a/packages/bun-native-plugin-rs/Cargo.toml b/packages/bun-native-plugin-rs/Cargo.toml
new file mode 100644
index 0000000000..bf4d7b784b
--- /dev/null
+++ b/packages/bun-native-plugin-rs/Cargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "bun-native-plugin"
+version = "0.1.0"
+edition = "2021"
+
+[build-dependencies]
+bindgen = "0.70.1"
diff --git a/packages/bun-native-plugin-rs/README.md b/packages/bun-native-plugin-rs/README.md
new file mode 100644
index 0000000000..f235849872
--- /dev/null
+++ b/packages/bun-native-plugin-rs/README.md
@@ -0,0 +1,248 @@
+> ⚠️ Note: This is an advanced and experimental API recommended only for plugin developers who are familiar with systems proramming and the C ABI. Use with caution.
+
+# Bun Native Plugins
+
+This crate provides a Rustified wrapper over the Bun's native bundler plugin C API.
+
+Some advantages to _native_ bundler plugins as opposed to regular ones implemented in JS:
+
+- Native plugins take full advantage of Bun's parallelized bundler pipeline and run on multiple threads at the same time
+- Unlike JS, native plugins don't need to do the UTF-8 <-> UTF-16 source code string conversions
+
+What are native bundler plugins exactly? Precisely, they are NAPI modules which expose a C ABI function which implement a plugin lifecycle hook.
+
+The currently supported lifecycle hooks are:
+
+- `onBeforeParse` (called immediately before a file is parsed, allows you to modify the source code of the file)
+
+## Getting started
+
+Since native bundler plugins are NAPI modules, the easiest way to get started is to create a new [napi-rs](https://github.com/napi-rs/napi-rs) project:
+
+```bash
+bun add -g @napi-rs/cli
+napi new
+```
+
+Then install this crate:
+
+```bash
+cargo add bun-native-plugin
+```
+
+Now, inside the `lib.rs` file, expose a C ABI function which has the same function signature as the plugin lifecycle hook that you want to implement.
+
+For example, implementing `onBeforeParse`:
+
+```rs
+use bun_native_plugin::{define_bun_plugin, OnBeforeParse};
+use napi_derive::napi;
+
+/// Define with the name of the plugin
+define_bun_plugin!("replace-foo-with-bar");
+
+/// This is necessary for napi-rs to compile this into a proper NAPI module
+#[napi]
+pub fn register_bun_plugin() {}
+
+/// Use `no_mangle` so that we can reference this symbol by name later
+/// when registering this native plugin in JS.
+///
+/// Here we'll create a dummy plugin which replaces all occurences of
+/// `foo` with `bar`
+#[no_mangle]
+pub extern "C" fn on_before_parse_plugin_impl(
+  args: *const bun_native_plugin::sys::OnBeforeParseArguments,
+  result: *mut bun_native_plugin::sys::OnBeforeParseResult,
+) {
+  let args = unsafe { &*args };
+
+  // This returns a handle which is a safe wrapper over the raw
+  // C API.
+  let mut handle = OnBeforeParse::from_raw(args, result) {
+    Ok(handle) => handle,
+    Err(_) => {
+      // `OnBeforeParse::from_raw` handles error logging
+      // so it fine to return here.
+      return;
+    }
+  };
+
+  let input_source_code = match handle.input_source_code() {
+    Ok(source_str) => source_str,
+    Err(_) => {
+      // If we encounter an error, we must log it so that
+      // Bun knows this plugin failed.
+      handle.log_error("Failed to fetch source code!");
+      return;
+    }
+  };
+
+  let loader = handle.output_loader();
+  let output_source_code = source_str.replace("foo", "bar");
+  handle.set_output_source_code(output_source_code, loader);
+}
+```
+
+Then compile this NAPI module. If you using napi-rs, the `package.json` should have a `build` script you can run:
+
+```bash
+bun run build
+```
+
+This will produce a `.node` file in the project directory.
+
+With the compiled NAPI module, you can now register the plugin from JS:
+
+```js
+const result = await Bun.build({
+  entrypoints: ["index.ts"],
+  plugins: [
+    {
+      name: "replace-foo-with-bar",
+      setup(build) {
+        const napiModule = require("path/to/napi_module.node");
+
+        // Register the `onBeforeParse` hook to run on all `.ts` files.
+        // We tell it to use function we implemented inside of our `lib.rs` code.
+        build.onBeforeParse(
+          { filter: /\.ts/ },
+          { napiModule, symbol: "on_before_parse_plugin_impl" },
+        );
+      },
+    },
+  ],
+});
+```
+
+## Very important information
+
+### Error handling and panics
+
+It is highly recommended to avoid panicking as this will crash the runtime. Instead, you must handle errors and log them:
+
+```rs
+let input_source_code = match handle.input_source_code() {
+  Ok(source_str) => source_str,
+  Err(_) => {
+    // If we encounter an error, we must log it so that
+    // Bun knows this plugin failed.
+    handle.log_error("Failed to fetch source code!");
+    return;
+  }
+};
+```
+
+### Passing state to and from JS: `External`
+
+One way to communicate data from your plugin and JS and vice versa is through the NAPI's [External](https://napi.rs/docs/concepts/external) type.
+
+An External in NAPI is like an opaque pointer to data that can be passed to and from JS. Inside your NAPI module, you can retrieve
+the pointer and modify the data.
+
+As an example that extends our getting started example above, let's say you wanted to count the number of `foo`'s that the native plugin encounters.
+
+You would expose a NAPI module function which creates this state. Recall that state in native plugins must be threadsafe. This usually means
+that your state must be `Sync`:
+
+```rs
+struct PluginState {
+  foo_count: std::sync::atomic::AtomicU32,
+}
+
+#[napi]
+pub fn create_plugin_state() -> External<PluginState> {
+  let external = External::new(PluginState {
+    foo_count: 0,
+  });
+
+  external
+}
+
+
+#[napi]
+pub fn get_foo_count(plugin_state: External<PluginState>) -> u32 {
+  let plugin_state: &PluginState = &plugin_state;
+  plugin_state.foo_count.load(std::sync::atomic::Ordering::Relaxed)
+}
+```
+
+When you register your plugin from Javascript, you call the napi module function to create the external and then pass it:
+
+```js
+const napiModule = require("path/to/napi_module.node");
+const pluginState = napiModule.createPluginState();
+
+const result = await Bun.build({
+  entrypoints: ["index.ts"],
+  plugins: [
+    {
+      name: "replace-foo-with-bar",
+      setup(build) {
+        build.onBeforeParse(
+          { filter: /\.ts/ },
+          {
+            napiModule,
+            symbol: "on_before_parse_plugin_impl",
+            // pass our NAPI external which contains our plugin state here
+            external: pluginState,
+          },
+        );
+      },
+    },
+  ],
+});
+
+console.log("Total `foo`s encountered: ", pluginState.getFooCount());
+```
+
+Finally, from the native implementation of your plugin, you can extract the external:
+
+```rs
+pub extern "C" fn on_before_parse_plugin_impl(
+  args: *const bun_native_plugin::sys::OnBeforeParseArguments,
+  result: *mut bun_native_plugin::sys::OnBeforeParseResult,
+) {
+  let args = unsafe { &*args };
+
+  let mut handle = OnBeforeParse::from_raw(args, result) {
+    Ok(handle) => handle,
+    Err(_) => {
+      // `OnBeforeParse::from_raw` handles error logging
+      // so it fine to return here.
+      return;
+    }
+  };
+
+  let plugin_state: &PluginState =
+    // This operation is only safe if you pass in an external when registering the plugin.
+    // If you don't, this could lead to a segfault or access of undefined memory.
+    match unsafe { handle.external().and_then(|state| state.ok_or(Error::Unknown)) } {
+      Ok(state) => state,
+      Err(_) => {
+        handle.log_error("Failed to get external!");
+        return;
+      }
+    };
+
+
+  // Fetch our source code again
+  let input_source_code = match handle.input_source_code() {
+    Ok(source_str) => source_str,
+    Err(_) => {
+      handle.log_error("Failed to fetch source code!");
+      return;
+    }
+  };
+
+  // Count the number of `foo`s and add it to our state
+  let foo_count = source_code.matches("foo").count() as u32;
+  plugin_state.foo_count.fetch_add(foo_count, std::sync::atomic::Ordering::Relaxed);
+}
+```
+
+### Concurrency
+
+Your `extern "C"` plugin function can be called _on any thread_ at _any time_ and _multiple times at once_.
+
+Therefore, you must design any state management to be threadsafe
diff --git a/packages/bun-native-plugin-rs/build.rs b/packages/bun-native-plugin-rs/build.rs
new file mode 100644
index 0000000000..fb33bbbae1
--- /dev/null
+++ b/packages/bun-native-plugin-rs/build.rs
@@ -0,0 +1,20 @@
+use std::path::PathBuf;
+
+fn main() {
+    println!("cargo:rustc-link-search=./headers");
+
+    let bindings = bindgen::Builder::default()
+        .header("wrapper.h")
+        // Add absolute path to headers directory
+        .clang_arg("-I./headers")
+        .parse_callbacks(Box::new(bindgen::CargoCallbacks))
+        .rustified_enum("BunLogLevel")
+        .rustified_enum("BunLoader")
+        .generate()
+        .expect("Unable to generate bindings");
+
+    let out_path = PathBuf::from(std::env::var("OUT_DIR").unwrap());
+    bindings
+        .write_to_file(out_path.join("bindings.rs"))
+        .expect("Couldn't write bindings!");
+}
diff --git a/packages/bun-native-plugin-rs/copy_headers.ts b/packages/bun-native-plugin-rs/copy_headers.ts
new file mode 100644
index 0000000000..23cc166b8c
--- /dev/null
+++ b/packages/bun-native-plugin-rs/copy_headers.ts
@@ -0,0 +1,6 @@
+import { join } from "node:path";
+
+const dirname = join(import.meta.dir, "../", "bun-native-bundler-plugin-api");
+await Bun.$`rm -rf headers`;
+await Bun.$`mkdir -p headers`;
+await Bun.$`cp -R ${dirname} headers/bun-native-bundler-plugin-api`;
diff --git a/packages/bun-native-plugin-rs/headers/bun-native-bundler-plugin-api/bundler_plugin.h b/packages/bun-native-plugin-rs/headers/bun-native-bundler-plugin-api/bundler_plugin.h
new file mode 100644
index 0000000000..bd84c95a5f
--- /dev/null
+++ b/packages/bun-native-plugin-rs/headers/bun-native-bundler-plugin-api/bundler_plugin.h
@@ -0,0 +1,79 @@
+#ifndef BUN_NATIVE_BUNDLER_PLUGIN_API_H
+#define BUN_NATIVE_BUNDLER_PLUGIN_API_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+typedef enum {
+    BUN_LOADER_JSX = 0,
+    BUN_LOADER_JS = 1,
+    BUN_LOADER_TS = 2,
+    BUN_LOADER_TSX = 3,
+    BUN_LOADER_CSS = 4,
+    BUN_LOADER_FILE = 5,
+    BUN_LOADER_JSON = 6,
+    BUN_LOADER_TOML = 7,
+    BUN_LOADER_WASM = 8,
+    BUN_LOADER_NAPI = 9,
+    BUN_LOADER_BASE64 = 10,
+    BUN_LOADER_DATAURL = 11,
+    BUN_LOADER_TEXT = 12,
+    BUN_LOADER_BUNSH = 13,
+    BUN_LOADER_SQLITE = 14,
+    BUN_LOADER_SQLITE_EMBEDDED = 15
+} BunLoader;
+
+const BunLoader BUN_LOADER_MAX = BUN_LOADER_SQLITE_EMBEDDED;
+
+typedef struct BunLogOptions {
+    size_t __struct_size;
+    const uint8_t* message_ptr;
+    size_t message_len;
+    const uint8_t* path_ptr;
+    size_t path_len;
+    const uint8_t* source_line_text_ptr;
+    size_t source_line_text_len;
+    int8_t level;
+    int line;
+    int lineEnd;
+    int column;
+    int columnEnd;
+} BunLogOptions;
+
+typedef struct {
+    size_t __struct_size;
+    void* bun;
+    const uint8_t* path_ptr;
+    size_t path_len;
+    const uint8_t* namespace_ptr;
+    size_t namespace_len;
+    uint8_t default_loader;
+    void *external;
+} OnBeforeParseArguments;
+
+typedef struct OnBeforeParseResult {
+    size_t __struct_size;
+    uint8_t* source_ptr;
+    size_t source_len;
+    uint8_t loader;
+    int (*fetchSourceCode)(
+        const OnBeforeParseArguments* args,
+        struct OnBeforeParseResult* result
+    );
+    void* plugin_source_code_context;
+    void (*free_plugin_source_code_context)(void* ctx);
+    void (*log)(const OnBeforeParseArguments* args, BunLogOptions* options);
+}  OnBeforeParseResult;
+
+
+typedef enum {
+    BUN_LOG_LEVEL_VERBOSE = 0,
+    BUN_LOG_LEVEL_DEBUG = 1,
+    BUN_LOG_LEVEL_INFO = 2,
+    BUN_LOG_LEVEL_WARN = 3,
+    BUN_LOG_LEVEL_ERROR = 4,
+} BunLogLevel;
+
+const BunLogLevel BUN_LOG_MAX = BUN_LOG_LEVEL_ERROR;
+
+#endif // BUN_NATIVE_BUNDLER_PLUGIN_API_H
diff --git a/packages/bun-native-plugin-rs/src/lib.rs b/packages/bun-native-plugin-rs/src/lib.rs
new file mode 100644
index 0000000000..3e589e3bcd
--- /dev/null
+++ b/packages/bun-native-plugin-rs/src/lib.rs
@@ -0,0 +1,627 @@
+//! > ⚠️ Note: This is an advanced and experimental API recommended only for plugin developers who are familiar with systems proramming and the C ABI. Use with caution.
+//!
+//! # Bun Native Plugins
+//!
+//! This crate provides a Rustified wrapper over the Bun's native bundler plugin C API.
+//!
+//! Some advantages to _native_ bundler plugins as opposed to regular ones implemented in JS:
+//!
+//! - Native plugins take full advantage of Bun's parallelized bundler pipeline and run on multiple threads at the same time
+//! - Unlike JS, native plugins don't need to do the UTF-8 <-> UTF-16 source code string conversions
+//!
+//! What are native bundler plugins exactly? Precisely, they are NAPI modules which expose a C ABI function which implement a plugin lifecycle hook.
+//!
+//! The currently supported lifecycle hooks are:
+//!
+//! - `onBeforeParse` (called immediately before a file is parsed, allows you to modify the source code of the file)
+//!
+//! ## Getting started
+//!
+//! Since native bundler plugins are NAPI modules, the easiest way to get started is to create a new [napi-rs](https://github.com/napi-rs/napi-rs) project:
+//!
+//! ```bash
+//! bun add -g @napi-rs/cli
+//! napi new
+//! ```
+//!
+//! Then install this crate:
+//!
+//! ```bash
+//! cargo add bun-native-plugin
+//! ```
+//!
+//! Now, inside the `lib.rs` file, expose a C ABI function which has the same function signature as the plugin lifecycle hook that you want to implement.
+//!
+//! For example, implementing `onBeforeParse`:
+//!
+//! ```rust
+//! use bun_native_plugin::{OnBeforeParse};
+//!
+//! /// This is necessary for napi-rs to compile this into a proper NAPI module
+//! #[napi]
+//! pub fn register_bun_plugin() {}
+//!
+//! /// Use `no_mangle` so that we can reference this symbol by name later
+//! /// when registering this native plugin in JS.
+//! ///
+//! /// Here we'll create a dummy plugin which replaces all occurences of
+//! /// `foo` with `bar`
+//! #[no_mangle]
+//! pub extern "C" fn on_before_parse_plugin_impl(
+//!   args: *const bun_native_plugin::sys::OnBeforeParseArguments,
+//!   result: *mut bun_native_plugin::sys::OnBeforeParseResult,
+//! ) {
+//!   let args = unsafe { &*args };
+//!   let result = unsafe { &mut *result };
+//!
+//!   // This returns a handle which is a safe wrapper over the raw
+//!   // C API.
+//!   let mut handle = OnBeforeParse::from_raw(args, result) {
+//!     Ok(handle) => handle,
+//!     Err(_) => {
+//!       // `OnBeforeParse::from_raw` handles error logging
+//!       // so it fine to return here.
+//!       return;
+//!     }
+//!   };
+//!
+//!   let input_source_code = match handle.input_source_code() {
+//!     Ok(source_str) => source_str,
+//!     Err(_) => {
+//!       // If we encounter an error, we must log it so that
+//!       // Bun knows this plugin failed.
+//!       handle.log_error("Failed to fetch source code!");
+//!       return;
+//!     }
+//!   };
+//!
+//!   let loader = handle.output_loader();
+//!   let output_source_code = source_str.replace("foo", "bar");
+//!   handle.set_output_source_code(output_source_code, loader);
+//! }
+//! ```
+//!
+//! Then compile this NAPI module. If you using napi-rs, the `package.json` should have a `build` script you can run:
+//!
+//! ```bash
+//! bun run build
+//! ```
+//!
+//! This will produce a `.node` file in the project directory.
+//!
+//! With the compiled NAPI module, you can now register the plugin from JS:
+//!
+//! ```js
+//! const result = await Bun.build({
+//!   entrypoints: ["index.ts"],
+//!   plugins: [
+//!     {
+//!       name: "replace-foo-with-bar",
+//!       setup(build) {
+//!         const napiModule = require("path/to/napi_module.node");
+//!
+//!         // Register the `onBeforeParse` hook to run on all `.ts` files.
+//!         // We tell it to use function we implemented inside of our `lib.rs` code.
+//!         build.onBeforeParse(
+//!           { filter: /\.ts/ },
+//!           { napiModule, symbol: "on_before_parse_plugin_impl" },
+//!         );
+//!       },
+//!     },
+//!   ],
+//! });
+//! ```
+//!
+//! ## Very important information
+//!
+//! ### Error handling and panics
+//!
+//! It is highly recommended to avoid panicking as this will crash the runtime. Instead, you must handle errors and log them:
+//!
+//! ```rust
+//! let input_source_code = match handle.input_source_code() {
+//!   Ok(source_str) => source_str,
+//!   Err(_) => {
+//!     // If we encounter an error, we must log it so that
+//!     // Bun knows this plugin failed.
+//!     handle.log_error("Failed to fetch source code!");
+//!     return;
+//!   }
+//! };
+//! ```
+//!
+//! ### Passing state to and from JS: `External`
+//!
+//! One way to communicate data from your plugin and JS and vice versa is through the NAPI's [External](https://napi.rs/docs/concepts/external) type.
+//!
+//! An External in NAPI is like an opaque pointer to data that can be passed to and from JS. Inside your NAPI module, you can retrieve
+//! the pointer and modify the data.
+//!
+//! As an example that extends our getting started example above, let's say you wanted to count the number of `foo`'s that the native plugin encounters.
+//!
+//! You would expose a NAPI module function which creates this state. Recall that state in native plugins must be threadsafe. This usually means
+//! that your state must be `Sync`:
+//!
+//! ```rust
+//! struct PluginState {
+//!   foo_count: std::sync::atomic::AtomicU32,
+//! }
+//!
+//! #[napi]
+//! pub fn create_plugin_state() -> External<PluginState> {
+//!   let external = External::new(PluginState {
+//!     foo_count: 0,
+//!   });
+//!
+//!   external
+//! }
+//!
+//!
+//! #[napi]
+//! pub fn get_foo_count(plugin_state: External<PluginState>) -> u32 {
+//!   let plugin_state: &PluginState = &plugin_state;
+//!   plugin_state.foo_count.load(std::sync::atomic::Ordering::Relaxed)
+//! }
+//! ```
+//!
+//! When you register your plugin from Javascript, you call the napi module function to create the external and then pass it:
+//!
+//! ```js
+//! const napiModule = require("path/to/napi_module.node");
+//! const pluginState = napiModule.createPluginState();
+//!
+//! const result = await Bun.build({
+//!   entrypoints: ["index.ts"],
+//!   plugins: [
+//!     {
+//!       name: "replace-foo-with-bar",
+//!       setup(build) {
+//!         build.onBeforeParse(
+//!           { filter: /\.ts/ },
+//!           {
+//!             napiModule,
+//!             symbol: "on_before_parse_plugin_impl",
+//!             // pass our NAPI external which contains our plugin state here
+//!             external: pluginState,
+//!           },
+//!         );
+//!       },
+//!     },
+//!   ],
+//! });
+//!
+//! console.log("Total `foo`s encountered: ", pluginState.getFooCount());
+//! ```
+//!
+//! Finally, from the native implementation of your plugin, you can extract the external:
+//!
+//! ```rust
+//! pub extern "C" fn on_before_parse_plugin_impl(
+//!   args: *const bun_native_plugin::sys::OnBeforeParseArguments,
+//!   result: *mut bun_native_plugin::sys::OnBeforeParseResult,
+//! ) {
+//!   let args = unsafe { &*args };
+//!   let result = unsafe { &mut *result };
+//!
+//!   let mut handle = OnBeforeParse::from_raw(args, result) {
+//!     Ok(handle) => handle,
+//!     Err(_) => {
+//!       // `OnBeforeParse::from_raw` handles error logging
+//!       // so it fine to return here.
+//!       return;
+//!     }
+//!   };
+//!
+//!   let plugin_state: &PluginState =
+//!     // This operation is only safe if you pass in an external when registering the plugin.
+//!     // If you don't, this could lead to a segfault or access of undefined memory.
+//!     match unsafe { handle.external().and_then(|state| state.ok_or(Error::Unknown)) } {
+//!       Ok(state) => state,
+//!       Err(_) => {
+//!         handle.log_error("Failed to get external!");
+//!         return;
+//!       }
+//!     };
+//!
+//!
+//!   // Fetch our source code again
+//!   let input_source_code = match handle.input_source_code() {
+//!     Ok(source_str) => source_str,
+//!     Err(_) => {
+//!       handle.log_error("Failed to fetch source code!");
+//!       return;
+//!     }
+//!   };
+//!
+//!   // Count the number of `foo`s and add it to our state
+//!   let foo_count = source_code.matches("foo").count() as u32;
+//!   plugin_state.foo_count.fetch_add(foo_count, std::sync::atomic::Ordering::Relaxed);
+//! }
+//! ```
+//!
+//! ### Concurrency
+//!
+//! Your `extern "C"` plugin function can be called _on any thread_ at _any time_ and _multiple times at once_.
+//!
+//! Therefore, you must design any state management to be threadsafe
+
+#![allow(non_upper_case_globals)]
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+
+#[repr(transparent)]
+pub struct BunPluginName(*const c_char);
+
+impl BunPluginName {
+    pub const fn new(ptr: *const c_char) -> Self {
+        Self(ptr)
+    }
+}
+
+#[macro_export]
+macro_rules! define_bun_plugin {
+    ($name:expr) => {
+        pub static BUN_PLUGIN_NAME_STRING: &str = $name;
+
+        #[no_mangle]
+        pub static BUN_PLUGIN_NAME: bun_native_plugin::BunPluginName =
+            bun_native_plugin::BunPluginName::new(BUN_PLUGIN_NAME_STRING.as_ptr() as *const _);
+
+        #[napi]
+        fn bun_plugin_register() {}
+    };
+}
+
+unsafe impl Sync for BunPluginName {}
+
+use std::{
+    any::TypeId,
+    borrow::Cow,
+    cell::UnsafeCell,
+    ffi::{c_char, c_void},
+    str::Utf8Error,
+};
+
+pub mod sys {
+    include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
+}
+
+#[repr(C)]
+pub struct TaggedObject<T> {
+    type_id: TypeId,
+    pub(crate) object: Option<T>,
+}
+
+struct SourceCodeContext {
+    source_ptr: *mut u8,
+    source_len: usize,
+    source_cap: usize,
+}
+
+extern "C" fn free_plugin_source_code_context(ctx: *mut c_void) {
+    // SAFETY: The ctx pointer is a pointer to the `SourceCodeContext` struct we allocated.
+    unsafe {
+        drop(Box::from_raw(ctx as *mut SourceCodeContext));
+    }
+}
+
+impl Drop for SourceCodeContext {
+    fn drop(&mut self) {
+        if !self.source_ptr.is_null() {
+            // SAFETY: These fields come from a `String` that we allocated.
+            unsafe {
+                drop(String::from_raw_parts(
+                    self.source_ptr,
+                    self.source_len,
+                    self.source_cap,
+                ));
+            }
+        }
+    }
+}
+
+pub type BunLogLevel = sys::BunLogLevel;
+pub type BunLoader = sys::BunLoader;
+
+fn get_from_raw_str<'a>(ptr: *const u8, len: usize) -> Result<Cow<'a, str>> {
+    let slice: &'a [u8] = unsafe { std::slice::from_raw_parts(ptr, len) };
+
+    // Windows allows invalid UTF-16 strings in the filesystem. These get converted to WTF-8 in Zig.
+    // Meaning the string may contain invalid UTF-8, we'll have to use the safe checked version.
+    #[cfg(target_os = "windows")]
+    {
+        std::str::from_utf8(slice)
+            .map(Into::into)
+            .or_else(|_| Ok(String::from_utf8_lossy(slice)))
+    }
+
+    #[cfg(not(target_os = "windows"))]
+    {
+        // SAFETY: The source code comes from Zig, which uses UTF-8, so this should be safe.
+
+        std::str::from_utf8(slice)
+            .map(Into::into)
+            .or_else(|_| Ok(String::from_utf8_lossy(slice)))
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum Error {
+    Utf8(Utf8Error),
+    IncompatiblePluginVersion,
+    ExternalTypeMismatch,
+    Unknown,
+}
+
+pub type Result<T> = std::result::Result<T, Error>;
+
+impl From<Utf8Error> for Error {
+    fn from(value: Utf8Error) -> Self {
+        Self::Utf8(value)
+    }
+}
+
+/// A safe handle for the arguments + result struct for the
+/// `OnBeforeParse` bundler lifecycle hook.
+///
+/// This struct acts as a safe wrapper around the raw C API structs
+/// (`sys::OnBeforeParseArguments`/`sys::OnBeforeParseResult`) needed to
+/// implement the `OnBeforeParse` bundler lifecycle hook.
+///
+/// To initialize this struct, see the `from_raw` method.
+pub struct OnBeforeParse<'a> {
+    args_raw: &'a sys::OnBeforeParseArguments,
+    result_raw: *mut sys::OnBeforeParseResult,
+    compilation_context: *mut SourceCodeContext,
+}
+
+impl<'a> OnBeforeParse<'a> {
+    /// Initialize this struct from references to their raw counterparts.
+    ///
+    /// This function will do a versioning check to ensure that the plugin
+    /// is compatible with the current version of Bun. If the plugin is not
+    /// compatible, it will log an error and return an error result.
+    ///
+    /// # Example
+    /// ```rust
+    /// extern "C" fn on_before_parse_impl(args: *const sys::OnBeforeParseArguments, result: *mut sys::OnBeforeParseResult) {
+    ///   let args = unsafe { &*args };
+    ///   let result = unsafe { &mut *result };
+    ///   let handle = match OnBeforeParse::from_raw(args, result) {
+    ///     Ok(handle) => handle,
+    ///     Err(()) => return,
+    ///   };
+    /// }
+    /// ```
+    pub fn from_raw(
+        args: &'a sys::OnBeforeParseArguments,
+        result: *mut sys::OnBeforeParseResult,
+    ) -> Result<Self> {
+        if args.__struct_size < std::mem::size_of::<sys::OnBeforeParseArguments>()
+            || unsafe { (*result).__struct_size } < std::mem::size_of::<sys::OnBeforeParseResult>()
+        {
+            let message = "This plugin is not compatible with the current version of Bun.";
+            let mut log_options = sys::BunLogOptions {
+                __struct_size: std::mem::size_of::<sys::BunLogOptions>(),
+                message_ptr: message.as_ptr(),
+                message_len: message.len(),
+                path_ptr: args.path_ptr,
+                path_len: args.path_len,
+                source_line_text_ptr: std::ptr::null(),
+                source_line_text_len: 0,
+                level: BunLogLevel::BUN_LOG_LEVEL_ERROR as i8,
+                line: 0,
+                lineEnd: 0,
+                column: 0,
+                columnEnd: 0,
+            };
+            // SAFETY: The `log` function pointer is guaranteed to be valid by the Bun runtime.
+            unsafe {
+                ((*result).log.unwrap())(args, &mut log_options);
+            }
+            return Err(Error::IncompatiblePluginVersion);
+        }
+
+        Ok(Self {
+            args_raw: args,
+            result_raw: result,
+            compilation_context: std::ptr::null_mut() as *mut _,
+        })
+    }
+
+    pub fn path(&self) -> Result<Cow<'_, str>> {
+        get_from_raw_str(self.args_raw.path_ptr, self.args_raw.path_len)
+    }
+
+    pub fn namespace(&self) -> Result<Cow<'_, str>> {
+        get_from_raw_str(self.args_raw.namespace_ptr, self.args_raw.namespace_len)
+    }
+
+    /// Get the external object from the `OnBeforeParse` arguments.
+    ///
+    /// The external object is set by the plugin definition inside of JS:
+    /// ```js
+    /// await Bun.build({
+    ///   plugins: [
+    ///     {
+    ///       name: "my-plugin",
+    ///       setup(builder) {
+    ///         const native_plugin = require("./native_plugin.node");
+    ///         const external = native_plugin.createExternal();
+    ///         builder.external({ napiModule: native_plugin, symbol: 'onBeforeParse', external });
+    ///       },
+    ///     },
+    ///   ],
+    /// });
+    /// ```
+    ///
+    /// The external object must be created from NAPI for this function to be safe!
+    ///
+    /// This function will return an error if the external object is not a
+    /// valid tagged object for the given type.
+    ///
+    /// This function will return `Ok(None)` if there is no external object
+    /// set.
+    ///
+    /// # Example
+    /// The code to create the external from napi-rs:
+    /// ```rs
+    /// #[no_mangle]
+    /// #[napi]
+    /// pub fn create_my_external() -> External<MyStruct> {
+    ///   let external = External::new(MyStruct::new());
+    ///
+    ///   external
+    /// }
+    /// ```
+    ///
+    /// The code to extract the external:
+    /// ```rust
+    /// let external = match handle.external::<MyStruct>() {
+    ///     Ok(Some(external)) => external,
+    ///     _ => {
+    ///         handle.log_error("Could not get external object.");
+    ///         return;
+    ///     },
+    /// };
+    /// ```
+    pub unsafe fn external<T: 'static + Sync>(&self) -> Result<Option<&'static T>> {
+        if self.args_raw.external.is_null() {
+            return Ok(None);
+        }
+
+        let external: *mut TaggedObject<T> = self.args_raw.external as *mut TaggedObject<T>;
+
+        unsafe {
+            if (*external).type_id != TypeId::of::<T>() {
+                return Err(Error::ExternalTypeMismatch);
+            }
+
+            Ok((*external).object.as_ref())
+        }
+    }
+
+    /// The same as [`crate::bun_native_plugin::OnBeforeParse::external`], but returns a mutable reference.
+    ///
+    /// This is unsafe as you must ensure that no other invocation of the plugin
+    /// simultaneously holds a mutable reference to the external.
+    pub unsafe fn external_mut<T: 'static + Sync>(&mut self) -> Result<Option<&mut T>> {
+        if self.args_raw.external.is_null() {
+            return Ok(None);
+        }
+
+        let external: *mut TaggedObject<T> = self.args_raw.external as *mut TaggedObject<T>;
+
+        unsafe {
+            if (*external).type_id != TypeId::of::<T>() {
+                return Err(Error::ExternalTypeMismatch);
+            }
+
+            Ok((*external).object.as_mut())
+        }
+    }
+
+    /// Get the input source code for the current file.
+    ///
+    /// On Windows, this function may return an `Err(Error::Utf8(...))` if the
+    /// source code contains invalid UTF-8.
+    pub fn input_source_code(&self) -> Result<Cow<'_, str>> {
+        let fetch_result = unsafe {
+            ((*self.result_raw).fetchSourceCode.unwrap())(self.args_raw, self.result_raw)
+        };
+
+        if fetch_result != 0 {
+            Err(Error::Unknown)
+        } else {
+            // SAFETY: We don't hand out mutable references to `result_raw` so dereferencing here is safe.
+            unsafe {
+                get_from_raw_str((*self.result_raw).source_ptr, (*self.result_raw).source_len)
+            }
+        }
+    }
+
+    /// Set the output source code for the current file.
+    pub fn set_output_source_code(&mut self, source: String, loader: BunLoader) {
+        let source_cap = source.capacity();
+        let source = source.leak();
+        let source_ptr = source.as_mut_ptr();
+        let source_len = source.len();
+
+        if self.compilation_context.is_null() {
+            self.compilation_context = Box::into_raw(Box::new(SourceCodeContext {
+                source_ptr,
+                source_len,
+                source_cap,
+            }));
+
+            // SAFETY: We don't hand out mutable references to `result_raw` so dereferencing it is safe.
+            unsafe {
+                (*self.result_raw).plugin_source_code_context =
+                    self.compilation_context as *mut c_void;
+                (*self.result_raw).free_plugin_source_code_context =
+                    Some(free_plugin_source_code_context);
+            }
+        } else {
+            unsafe {
+                // SAFETY: If we're here we know that `compilation_context` is not null.
+                let context = &mut *self.compilation_context;
+
+                drop(String::from_raw_parts(
+                    context.source_ptr,
+                    context.source_len,
+                    context.source_cap,
+                ));
+
+                context.source_ptr = source_ptr;
+                context.source_len = source_len;
+                context.source_cap = source_cap;
+            }
+        }
+
+        // SAFETY: We don't hand out mutable references to `result_raw` so dereferencing it is safe.
+        unsafe {
+            (*self.result_raw).loader = loader as u8;
+            (*self.result_raw).source_ptr = source_ptr;
+            (*self.result_raw).source_len = source_len;
+        }
+    }
+
+    /// Set the output loader for the current file.
+    pub fn set_output_loader(&self, loader: BunLogLevel) {
+        // SAFETY: We don't hand out mutable references to `result_raw` so dereferencing it is safe.
+        unsafe {
+            (*self.result_raw).loader = loader as u8;
+        }
+    }
+
+    /// Get the output loader for the current file.
+    pub fn output_loader(&self) -> BunLoader {
+        unsafe { std::mem::transmute((*self.result_raw).loader as u32) }
+    }
+
+    /// Log an error message.
+    pub fn log_error(&self, message: &str) {
+        self.log(message, BunLogLevel::BUN_LOG_LEVEL_ERROR)
+    }
+
+    /// Log a message with the given level.
+    pub fn log(&self, message: &str, level: BunLogLevel) {
+        let mut log_options = sys::BunLogOptions {
+            __struct_size: std::mem::size_of::<sys::BunLogOptions>(),
+            message_ptr: message.as_ptr(),
+            message_len: message.len(),
+            path_ptr: self.args_raw.path_ptr,
+            path_len: self.args_raw.path_len,
+            source_line_text_ptr: std::ptr::null(),
+            source_line_text_len: 0,
+            level: level as i8,
+            line: 0,
+            lineEnd: 0,
+            column: 0,
+            columnEnd: 0,
+        };
+        unsafe {
+            ((*self.result_raw).log.unwrap())(self.args_raw, &mut log_options);
+        }
+    }
+}
diff --git a/packages/bun-native-plugin-rs/wrapper.h b/packages/bun-native-plugin-rs/wrapper.h
new file mode 100644
index 0000000000..8bea41f498
--- /dev/null
+++ b/packages/bun-native-plugin-rs/wrapper.h
@@ -0,0 +1 @@
+#include <bun-native-bundler-plugin-api/bundler_plugin.h>
\ No newline at end of file
diff --git a/packages/bun-plugin-css/README.md b/packages/bun-plugin-css/README.md
deleted file mode 100644
index 9abf5f6c0e..0000000000
--- a/packages/bun-plugin-css/README.md
+++ /dev/null
@@ -1,3 +0,0 @@
-# `bun-plugin-css`
-
-Not implemented.
diff --git a/packages/bun-plugin-css/index.ts b/packages/bun-plugin-css/index.ts
deleted file mode 100644
index bf67f6e7e0..0000000000
--- a/packages/bun-plugin-css/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-throw new Error("Not implemented.");
diff --git a/packages/bun-plugin-css/package.json b/packages/bun-plugin-css/package.json
deleted file mode 100644
index 68b4020d90..0000000000
--- a/packages/bun-plugin-css/package.json
+++ /dev/null
@@ -1,10 +0,0 @@
-{
-  "name": "bun-plugin-css",
-  "version": "0.0.1-alpha.0",
-  "module": "index.ts",
-  "type": "module",
-  "files": [
-    "index.ts",
-    "package.json"
-  ]
-}
diff --git a/packages/bun-plugin-lightningcss/README.md b/packages/bun-plugin-lightningcss/README.md
deleted file mode 100644
index 7cbe8c64b3..0000000000
--- a/packages/bun-plugin-lightningcss/README.md
+++ /dev/null
@@ -1,3 +0,0 @@
-# `bun-plugin-lightningcss`
-
-Not implemented.
diff --git a/packages/bun-plugin-lightningcss/index.ts b/packages/bun-plugin-lightningcss/index.ts
deleted file mode 100644
index bf67f6e7e0..0000000000
--- a/packages/bun-plugin-lightningcss/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-throw new Error("Not implemented.");
diff --git a/packages/bun-plugin-lightningcss/package.json b/packages/bun-plugin-lightningcss/package.json
deleted file mode 100644
index 6aafdedd1b..0000000000
--- a/packages/bun-plugin-lightningcss/package.json
+++ /dev/null
@@ -1,10 +0,0 @@
-{
-  "name": "bun-plugin-lightningcss",
-  "version": "0.0.1-alpha.0",
-  "module": "index.ts",
-  "type": "module",
-  "files": [
-    "index.ts",
-    "package.json"
-  ]
-}
diff --git a/packages/bun-plugin-mdx/README.md b/packages/bun-plugin-mdx/README.md
deleted file mode 100644
index 65890d7c24..0000000000
--- a/packages/bun-plugin-mdx/README.md
+++ /dev/null
@@ -1,3 +0,0 @@
-# `bun-plugin-mdx`
-
-Not implemented.
diff --git a/packages/bun-plugin-mdx/index.ts b/packages/bun-plugin-mdx/index.ts
deleted file mode 100644
index bf67f6e7e0..0000000000
--- a/packages/bun-plugin-mdx/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-throw new Error("Not implemented.");
diff --git a/packages/bun-plugin-mdx/package.json b/packages/bun-plugin-mdx/package.json
deleted file mode 100644
index 98047872f2..0000000000
--- a/packages/bun-plugin-mdx/package.json
+++ /dev/null
@@ -1,10 +0,0 @@
-{
-  "name": "bun-plugin-mdx",
-  "version": "0.0.1-alpha.0",
-  "module": "index.ts",
-  "type": "module",
-  "files": [
-    "index.ts",
-    "package.json"
-  ]
-}
diff --git a/packages/bun-plugin-server-components/.gitignore b/packages/bun-plugin-server-components/.gitignore
deleted file mode 100644
index f81d56eaa3..0000000000
--- a/packages/bun-plugin-server-components/.gitignore
+++ /dev/null
@@ -1,169 +0,0 @@
-# Based on https://raw.githubusercontent.com/github/gitignore/main/Node.gitignore
-
-# Logs
-
-logs
-_.log
-npm-debug.log_
-yarn-debug.log*
-yarn-error.log*
-lerna-debug.log*
-.pnpm-debug.log*
-
-# Diagnostic reports (https://nodejs.org/api/report.html)
-
-report.[0-9]_.[0-9]_.[0-9]_.[0-9]_.json
-
-# Runtime data
-
-pids
-_.pid
-_.seed
-\*.pid.lock
-
-# Directory for instrumented libs generated by jscoverage/JSCover
-
-lib-cov
-
-# Coverage directory used by tools like istanbul
-
-coverage
-\*.lcov
-
-# nyc test coverage
-
-.nyc_output
-
-# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
-
-.grunt
-
-# Bower dependency directory (https://bower.io/)
-
-bower_components
-
-# node-waf configuration
-
-.lock-wscript
-
-# Compiled binary addons (https://nodejs.org/api/addons.html)
-
-build/Release
-
-# Dependency directories
-
-node_modules/
-jspm_packages/
-
-# Snowpack dependency directory (https://snowpack.dev/)
-
-web_modules/
-
-# TypeScript cache
-
-\*.tsbuildinfo
-
-# Optional npm cache directory
-
-.npm
-
-# Optional eslint cache
-
-.eslintcache
-
-# Optional stylelint cache
-
-.stylelintcache
-
-# Microbundle cache
-
-.rpt2_cache/
-.rts2_cache_cjs/
-.rts2_cache_es/
-.rts2_cache_umd/
-
-# Optional REPL history
-
-.node_repl_history
-
-# Output of 'npm pack'
-
-\*.tgz
-
-# Yarn Integrity file
-
-.yarn-integrity
-
-# dotenv environment variable files
-
-.env
-.env.development.local
-.env.test.local
-.env.production.local
-.env.local
-
-# parcel-bundler cache (https://parceljs.org/)
-
-.cache
-.parcel-cache
-
-# Next.js build output
-
-.next
-out
-
-# Nuxt.js build / generate output
-
-.nuxt
-dist
-
-# Gatsby files
-
-.cache/
-
-# Comment in the public line in if your project uses Gatsby and not Next.js
-
-# https://nextjs.org/blog/next-9-1#public-directory-support
-
-# public
-
-# vuepress build output
-
-.vuepress/dist
-
-# vuepress v2.x temp and cache directory
-
-.temp
-.cache
-
-# Docusaurus cache and generated files
-
-.docusaurus
-
-# Serverless directories
-
-.serverless/
-
-# FuseBox cache
-
-.fusebox/
-
-# DynamoDB Local files
-
-.dynamodb/
-
-# TernJS port file
-
-.tern-port
-
-# Stores VSCode versions used for testing VSCode extensions
-
-.vscode-test
-
-# yarn v2
-
-.yarn/cache
-.yarn/unplugged
-.yarn/build-state.yml
-.yarn/install-state.gz
-.pnp.\*
diff --git a/packages/bun-plugin-server-components/README.md b/packages/bun-plugin-server-components/README.md
deleted file mode 100644
index 32ce31fede..0000000000
--- a/packages/bun-plugin-server-components/README.md
+++ /dev/null
@@ -1,149 +0,0 @@
-# `bun-plugin-server-components`
-
-The official Bun plugin for **server components**.
-
-## Installation
-
-```sh
-bun add bun-plugin-server-components -d
-```
-
-## Context
-
-Server components are a new abstraction for building web applications. They look similar to standard React/JSX components, but render exclusively on the server. They differ from classic "client components" in a few ways:
-
-1. They can be `async`.
-2. Their implementation can run privileged code like database queries. Normally this would be unsafe, because the source code of client components are typically bundled and sent to the client, where they can be inspected and reverse-engineered. Server components are never sent to the client, so they can run privileged code safely.
-3. They _cannot_ contain stateful hooks like `useState` or `useEffect`.
-
-Server components require a deep integration with the bundler to work. To understand why, we need a bit of background on how server components work.
-
-### How server components work
-
-Imagine you have a server component that looks like this:
-
-```tsx
-// index.tsx
-import { Component } from "./Component";
-export default async function HomePage() {
-  return (
-    <div>
-      <Component />
-    </div>
-  );
-}
-```
-
-This file imports a client component called `Component`.
-
-```ts
-// ./Component.tsx
-"use client";
-
-export function Component() {
-  return <div>Hello world</div>;
-}
-```
-
-To run this component we need to generate two builds.
-
-> Here the term "build" refers to a typical bundling step—the act of converting a set of entrypoints into a set of bundles.
-
-1. The first is our "server component build". It contains all the code we need to render `HomePage` to a component tree. When an incoming `Request` comes in, we can use React's built-in tools to convert this tree into a "virtual DOM stream" that we can return as a `Response`.
-2. The second is our "client build". It contains the bundled versions of all client components that were referenced by our server components.
-
-The browser hits the server and gets back the "virtual DOM stream". The virtual DOM stream will contain references to client components, which will be loaded from the client bundle. React provides a built-in utility (`createFromFetch`)that accepts the VDOM stream, dynamically loads the necessary client components, and returns a renderable component.
-
-```ts
-import { createRoot } from "react-dom/client";
-import { createFromFetch } from "react-server-dom-webpack/client.browser";
-
-const stream = fetch("/", { headers: { Accept: "text/x-component" } });
-const data = createFromFetch(stream);
-
-const root = createRoot(document);
-root.render(<App />);
-```
-
-### Server-side rendering
-
-One potentially confusing aspect of server components is that they "return" virtual DOM. From the perspective of a server component, client components are black boxes.
-
-If we want to do server-side rendering, we need to render our server component to VDOM, _then_ render the VDOM to plain HTML. These are two distinct steps. The second step requires a _third build_, we we'll call the "SSR build". Like the "client build", this build will bundle all the client components. Unlike the "client build", those bundles will be intended for consumption on the server; in bundler terms, the build's `"target"` will be`"bun"` (or perhaps `"node"`).
-
-### Bundling server components
-
-That's a high-level overview of how server components work. The important takeaway is that we need to generate totally separate bundles for server and client components.
-
-But it's not just a simple matter of running two separate bundling scripts. The true "entrypoints" of our application are the server components. Over the course of bundling our server components, we will discover some files containing the `"use client"` directive; these files then become the entrypoints for our "client build", which will require a totally separate build configuration from the server build.
-
-The goal of this plugin is to hide the complexty of this multi-stage build from the user.
-
-## Usage
-
-To use this plugin:
-
-```ts
-import ServerComponentsPlugin from "bun-plugin-server-components";
-
-await Bun.build({
-  entrypoints: ["./index.tsx"], // server component files
-  plugins: [
-    ServerComponentsPlugin({
-      // plugin configuration
-    }),
-  ],
-  // other configuration
-});
-```
-
-The `"entrypoints"` you pass into `Bun.build()` should be your _server components_. Bun's bundler will automatically detect any files containing the `"use client"` directive, and will use those files as entrypoints for the "client build" and "SSR build". The bundler configuration for these builds can be provided `client` and `ssr` keys respectively.
-
-```ts
-import ServerComponentsPlugin from "bun-plugin-server-components";
-
-await Bun.build({
-  entrypoints: ["./index.tsx"], // server component files
-  outdir: "./build",
-  manifest: true,
-  plugins: [ServerComponentsPlugin({
-    client: {
-      entrypoints: [], // optional - additional client entrypoints
-      outdir: "./build/client", // default: inherits from the main build
-      target: "browser",
-      plugins: [/* */],
-    }
-    ssr: {
-      entrypoints: [], // optional - additional SSR entrypoints
-      outdir: "./build/client", // default: inherits from the main build
-      target: "bun", // this is default
-      plugins: [/* */],
-    }
-  })],
-});
-```
-
-The result of `Bun.build()` will contain additional manifests for the SSR and client builds.
-
-```ts
-const result = await Bun.build({
-  // config
-  plugins: [
-    ServerComponentsPlugin({
-      /* config */
-    }),
-  ],
-});
-
-// standard manifest
-// for the top-level (server components) build
-result.manifest;
-
-// manifest for client build
-result.clientManifest;
-
-// manifest for client build
-result.ssrManifest;
-```
-
-Once the build is complete, use the manifests to implement your RSC server.
diff --git a/packages/bun-plugin-server-components/bun.lockb b/packages/bun-plugin-server-components/bun.lockb
deleted file mode 100755
index 460954c699..0000000000
Binary files a/packages/bun-plugin-server-components/bun.lockb and /dev/null differ
diff --git a/packages/bun-plugin-server-components/index.ts b/packages/bun-plugin-server-components/index.ts
deleted file mode 100644
index 67d98eb769..0000000000
--- a/packages/bun-plugin-server-components/index.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-import { BunPlugin, BuildConfig } from "bun";
-
-function Plugin(config: { client?: BuildConfig; ssr?: BuildConfig }): BunPlugin {
-  return {
-    name: "bun-plugin-server-components",
-    SECRET_SERVER_COMPONENTS_INTERNALS: config,
-  } as any;
-}
-
-export default Plugin;
diff --git a/packages/bun-plugin-server-components/package.json b/packages/bun-plugin-server-components/package.json
deleted file mode 100644
index 9d28f36fd7..0000000000
--- a/packages/bun-plugin-server-components/package.json
+++ /dev/null
@@ -1,28 +0,0 @@
-{
-  "name": "bun-plugin-server-components",
-  "version": "0.0.1-alpha.0",
-  "module": "index.ts",
-  "type": "module",
-  "types": "index.ts",
-  "exports": {
-    ".": {
-      "import": "./index.ts",
-      "require": "./index.ts",
-      "default": "./index.js"
-    },
-    "./package.json": "./package.json"
-  },
-  "files": [
-    "index.ts",
-    "tsconfig.json",
-    "package.json",
-    "modules.d.ts"
-  ],
-  "devDependencies": {
-    "@types/js-yaml": "^4.0.5"
-  },
-  "dependencies": {
-    "bun-types": "canary",
-    "js-yaml": "^4.1.0"
-  }
-}
diff --git a/packages/bun-plugin-server-components/tsconfig.json b/packages/bun-plugin-server-components/tsconfig.json
deleted file mode 100644
index a03219b2eb..0000000000
--- a/packages/bun-plugin-server-components/tsconfig.json
+++ /dev/null
@@ -1,23 +0,0 @@
-{
-  "compilerOptions": {
-    "lib": ["ESNext"],
-    "module": "esnext",
-    "target": "esnext",
-    "moduleResolution": "bundler",
-    "moduleDetection": "force",
-    "allowImportingTsExtensions": true,
-    "noEmit": true,
-    "composite": true,
-    "strict": true,
-    "downlevelIteration": true,
-    "skipLibCheck": true,
-    "jsx": "react-jsx",
-    "allowSyntheticDefaultImports": true,
-    "forceConsistentCasingInFileNames": true,
-    "allowJs": true,
-    "types": [
-      "bun-types" // add Bun global
-    ]
-  },
-  "include": ["**/*.ts", "modules.d.ts"]
-}
diff --git a/packages/bun-release/bun.lockb b/packages/bun-release/bun.lockb
index 5a23cb2ffb..3d275b5c17 100755
Binary files a/packages/bun-release/bun.lockb and b/packages/bun-release/bun.lockb differ
diff --git a/packages/bun-release/src/github.ts b/packages/bun-release/src/github.ts
index c0aa0239a2..e61e77070b 100644
--- a/packages/bun-release/src/github.ts
+++ b/packages/bun-release/src/github.ts
@@ -97,6 +97,8 @@ export async function getBuild(): Promise<number> {
 }
 
 export async function getSemver(tag?: string, build?: number): Promise<string> {
+  const { tag_name: latest_tag_name } = await getRelease();
+  const version = latest_tag_name.replace("bun-v", "");
   const { tag_name } = await getRelease(tag);
   if (tag_name !== "canary") {
     return tag_name.replace("bun-v", "");
@@ -106,7 +108,7 @@ export async function getSemver(tag?: string, build?: number): Promise<string> {
   }
   const sha = await getSha(tag_name, "short");
   const date = new Date().toISOString().split("T")[0].replace(/-/g, "");
-  return `${Bun.version}-canary.${date}.${build}+${sha}`;
+  return `${version}-canary.${date}.${build}+${sha}`;
 }
 
 export function formatTag(tag: string): string {
diff --git a/packages/bun-release/src/npm/install.ts b/packages/bun-release/src/npm/install.ts
index 37ed2c3165..f2f65d1a70 100644
--- a/packages/bun-release/src/npm/install.ts
+++ b/packages/bun-release/src/npm/install.ts
@@ -3,7 +3,7 @@ import { spawn } from "../spawn";
 import { chmod, join, rename, rm, tmp, write } from "../fs";
 import { unzipSync } from "zlib";
 import type { Platform } from "../platform";
-import { os, arch, supportedPlatforms } from "../platform";
+import { os, arch, abi, supportedPlatforms } from "../platform";
 import { debug, error } from "../console";
 
 declare const version: string;
@@ -12,7 +12,7 @@ declare const owner: string;
 
 export async function importBun(): Promise<string> {
   if (!supportedPlatforms.length) {
-    throw new Error(`Unsupported platform: ${os} ${arch}`);
+    throw new Error(`Unsupported platform: ${os} ${arch} ${abi || ""}`);
   }
   for (const platform of supportedPlatforms) {
     try {
@@ -121,7 +121,8 @@ async function downloadBun(platform: Platform, dst: string): Promise<void> {
 }
 
 export function optimizeBun(path: string): void {
-  const installScript = os === "win32" ? 'powershell -c "irm bun.sh/install.ps1 | iex"' : "curl -fsSL https://bun.sh/install | bash";
+  const installScript =
+    os === "win32" ? 'powershell -c "irm bun.sh/install.ps1 | iex"' : "curl -fsSL https://bun.sh/install | bash";
   try {
     rename(path, join(__dirname, "bin", "bun.exe"));
     return;
diff --git a/packages/bun-release/src/platform.ts b/packages/bun-release/src/platform.ts
index 8b87a8917f..39d581fbb0 100644
--- a/packages/bun-release/src/platform.ts
+++ b/packages/bun-release/src/platform.ts
@@ -1,5 +1,5 @@
 import { spawn } from "./spawn";
-import { read } from "./fs";
+import { exists, read } from "./fs";
 import { debug } from "./console";
 
 export const os = process.platform;
@@ -10,9 +10,12 @@ export const avx2 =
   arch === "x64" &&
   ((os === "linux" && isLinuxAVX2()) || (os === "darwin" && isDarwinAVX2()) || (os === "win32" && isWindowsAVX2()));
 
+export const abi = os === "linux" && isLinuxMusl() ? "musl" : undefined;
+
 export type Platform = {
   os: string;
   arch: string;
+  abi?: "musl";
   avx2?: boolean;
   bin: string;
   exe: string;
@@ -57,6 +60,28 @@ export const platforms: Platform[] = [
     bin: "bun-linux-x64-baseline",
     exe: "bin/bun",
   },
+  {
+    os: "linux",
+    arch: "aarch64",
+    abi: "musl",
+    bin: "bun-linux-aarch64-musl",
+    exe: "bin/bun",
+  },
+  {
+    os: "linux",
+    arch: "x64",
+    abi: "musl",
+    avx2: true,
+    bin: "bun-linux-x64-musl",
+    exe: "bin/bun",
+  },
+  {
+    os: "linux",
+    arch: "x64",
+    abi: "musl",
+    bin: "bun-linux-x64-musl-baseline",
+    exe: "bin/bun",
+  },
   {
     os: "win32",
     arch: "x64",
@@ -73,9 +98,24 @@ export const platforms: Platform[] = [
 ];
 
 export const supportedPlatforms: Platform[] = platforms
-  .filter(platform => platform.os === os && platform.arch === arch && (!platform.avx2 || avx2))
+  .filter(
+    platform =>
+      platform.os === os &&
+      platform.arch === arch &&
+      (!platform.avx2 || avx2) &&
+      (!platform.abi || abi === platform.abi),
+  )
   .sort((a, b) => (a.avx2 === b.avx2 ? 0 : a.avx2 ? -1 : 1));
 
+function isLinuxMusl(): boolean {
+  try {
+    return exists("/etc/alpine-release");
+  } catch (error) {
+    debug("isLinuxMusl failed", error);
+    return false;
+  }
+}
+
 function isLinuxAVX2(): boolean {
   try {
     return read("/proc/cpuinfo").includes("avx2");
diff --git a/packages/bun-types/.gitignore b/packages/bun-types/.gitignore
index 04c01ba7ba..324bb91768 100644
--- a/packages/bun-types/.gitignore
+++ b/packages/bun-types/.gitignore
@@ -1,2 +1,4 @@
 node_modules/
-dist/
\ No newline at end of file
+dist/
+docs/
+*.tgz
\ No newline at end of file
diff --git a/packages/bun-types/bun.d.ts b/packages/bun-types/bun.d.ts
index bed018c9a5..1843964b71 100644
--- a/packages/bun-types/bun.d.ts
+++ b/packages/bun-types/bun.d.ts
@@ -14,6 +14,7 @@
  * This module aliases `globalThis.Bun`.
  */
 declare module "bun" {
+  import type { FFIFunctionCallableSymbol } from "bun:ffi";
   import type { Encoding as CryptoEncoding } from "crypto";
   import type { CipherNameAndProtocol, EphemeralKeyInfo, PeerCertificate } from "tls";
   interface Env {
@@ -1497,13 +1498,35 @@ declare module "bun" {
     kind: ImportKind;
   }
 
-  type ModuleFormat = "esm"; // later: "cjs", "iife"
-
   interface BuildConfig {
     entrypoints: string[]; // list of file path
     outdir?: string; // output directory
     target?: Target; // default: "browser"
-    format?: ModuleFormat; // later: "cjs", "iife"
+    /**
+     * Output module format. Top-level await is only supported for `"esm"`.
+     *
+     * Can be:
+     * - `"esm"`
+     * - `"cjs"` (**experimental**)
+     * - `"iife"` (**experimental**)
+     *
+     * @default "esm"
+     */
+    format?: /**
+
+     * ECMAScript Module format
+     */
+    | "esm"
+      /**
+       * CommonJS format
+       * **Experimental**
+       */
+      | "cjs"
+      /**
+       * IIFE format
+       * **Experimental**
+       */
+      | "iife";
     naming?:
       | string
       | {
@@ -1561,6 +1584,40 @@ declare module "bun" {
     //       /** Only works when runtime=automatic */
     //       importSource?: string; // default: "react"
     //     };
+
+    /**
+     * Generate bytecode for the output. This can dramatically improve cold
+     * start times, but will make the final output larger and slightly increase
+     * memory usage.
+     *
+     * Bytecode is currently only supported for CommonJS (`format: "cjs"`).
+     *
+     * Must be `target: "bun"`
+     * @default false
+     */
+    bytecode?: boolean;
+    /**
+     * Add a banner to the bundled code such as "use client";
+     */
+    banner?: string;
+    /**
+     * Add a footer to the bundled code such as a comment block like
+     *
+     * `// made with bun!`
+     */
+    footer?: string;
+
+    /**
+     * **Experimental**
+     *
+     * Enable CSS support.
+     */
+    experimentalCss?: boolean;
+
+    /**
+     * Drop function calls to matching property accesses.
+     */
+    drop?: string[];
   }
 
   namespace Password {
@@ -1594,7 +1651,7 @@ declare module "bun" {
    * automatically run in a worker thread.
    *
    * The underlying implementation of these functions are provided by the Zig
-   * Standard Library. Thanks to @jedisct1 and other Zig constributors for their
+   * Standard Library. Thanks to @jedisct1 and other Zig contributors for their
    * work on this.
    *
    * ### Example with argon2
@@ -1697,7 +1754,7 @@ declare module "bun" {
      * instead which runs in a worker thread.
      *
      * The underlying implementation of these functions are provided by the Zig
-     * Standard Library. Thanks to @jedisct1 and other Zig constributors for their
+     * Standard Library. Thanks to @jedisct1 and other Zig contributors for their
      * work on this.
      *
      * ### Example with argon2
@@ -1736,7 +1793,7 @@ declare module "bun" {
      * instead which runs in a worker thread.
      *
      * The underlying implementation of these functions are provided by the Zig
-     * Standard Library. Thanks to @jedisct1 and other Zig constributors for their
+     * Standard Library. Thanks to @jedisct1 and other Zig contributors for their
      * work on this.
      *
      * ### Example with argon2
@@ -1781,7 +1838,7 @@ declare module "bun" {
     path: string;
     loader: Loader;
     hash: string | null;
-    kind: "entry-point" | "chunk" | "asset" | "sourcemap";
+    kind: "entry-point" | "chunk" | "asset" | "sourcemap" | "bytecode";
     sourcemap: BuildArtifact | null;
   }
 
@@ -2282,7 +2339,7 @@ declare module "bun" {
      */
     development?: boolean;
 
-    error?: (this: Server, request: ErrorLike) => Response | Promise<Response> | undefined | Promise<undefined>;
+    error?: (this: Server, error: ErrorLike) => Response | Promise<Response> | undefined | Promise<undefined>;
 
     /**
      * Uniquely identify a server instance with an ID
@@ -2967,6 +3024,7 @@ declare module "bun" {
     colors?: boolean;
     depth?: number;
     sorted?: boolean;
+    compact?: boolean;
   }
 
   /**
@@ -2982,6 +3040,14 @@ declare module "bun" {
      * That can be used to declare custom inspect functions.
      */
     const custom: typeof import("util").inspect.custom;
+
+    /**
+     * Pretty-print an object or array as a table
+     *
+     * Like {@link console.table}, except it returns a string
+     */
+    function table(tabularData: object | unknown[], properties?: string[], options?: { colors?: boolean }): string;
+    function table(tabularData: object | unknown[], options?: { colors?: boolean }): string;
   }
 
   interface MMapOptions {
@@ -3029,6 +3095,105 @@ declare module "bun" {
 
   type StringLike = string | { toString(): string };
 
+  type ColorInput =
+    | { r: number; g: number; b: number; a?: number }
+    | [number, number, number]
+    | [number, number, number, number]
+    | Uint8Array
+    | Uint8ClampedArray
+    | Float32Array
+    | Float64Array
+    | string
+    | number
+    | { toString(): string };
+
+  function color(
+    input: ColorInput,
+    outputFormat?: /**
+     * True color ANSI color string, for use in terminals
+     * @example \x1b[38;2;100;200;200m
+     */
+    | "ansi"
+      | "ansi-16"
+      | "ansi-16m"
+      /**
+       * 256 color ANSI color string, for use in terminals which don't support true color
+       *
+       * Tries to match closest 24-bit color to 256 color palette
+       */
+      | "ansi-256"
+      /**
+       * Picks the format that produces the shortest output
+       */
+      | "css"
+      /**
+       * Lowercase hex color string without alpha
+       * @example #ff9800
+       */
+      | "hex"
+      /**
+       * Uppercase hex color string without alpha
+       * @example #FF9800
+       */
+      | "HEX"
+      /**
+       * @example hsl(35.764706, 1, 0.5)
+       */
+      | "hsl"
+      /**
+       * @example lab(0.72732764, 33.938198, -25.311619)
+       */
+      | "lab"
+      /**
+       * @example 16750592
+       */
+      | "number"
+      /**
+       * RGB color string without alpha
+       * @example rgb(255, 152, 0)
+       */
+      | "rgb"
+      /**
+       * RGB color string with alpha
+       * @example rgba(255, 152, 0, 1)
+       */
+      | "rgba",
+  ): string | null;
+
+  function color(
+    input: ColorInput,
+    /**
+     * An array of numbers representing the RGB color
+     * @example [100, 200, 200]
+     */
+    outputFormat: "[rgb]",
+  ): [number, number, number] | null;
+  function color(
+    input: ColorInput,
+    /**
+     * An array of numbers representing the RGBA color
+     * @example [100, 200, 200, 255]
+     */
+    outputFormat: "[rgba]",
+  ): [number, number, number, number] | null;
+  function color(
+    input: ColorInput,
+    /**
+     * An object representing the RGB color
+     * @example { r: 100, g: 200, b: 200 }
+     */
+    outputFormat: "{rgb}",
+  ): { r: number; g: number; b: number } | null;
+  function color(
+    input: ColorInput,
+    /**
+     * An object representing the RGBA color
+     * @example { r: 100, g: 200, b: 200, a: 0.5 }
+     */
+    outputFormat: "{rgba}",
+  ): { r: number; g: number; b: number; a: number } | null;
+  function color(input: ColorInput, outputFormat: "number"): number | null;
+
   interface Semver {
     /**
      * Test if the version satisfies the range. Stringifies both arguments. Returns `true` or `false`.
@@ -3085,7 +3250,7 @@ declare module "bun" {
   }
   const unsafe: Unsafe;
 
-  type DigestEncoding = "hex" | "base64";
+  type DigestEncoding = "utf8" | "ucs2" | "utf16le" | "latin1" | "ascii" | "base64" | "base64url" | "hex";
 
   /**
    * Are ANSI colors enabled for stdin and stdout?
@@ -3264,8 +3429,9 @@ declare module "bun" {
      * Create a new hasher
      *
      * @param algorithm The algorithm to use. See {@link algorithms} for a list of supported algorithms
+     * @param hmacKey Optional key for HMAC. Must be a string or `TypedArray`. If not provided, the hasher will be a non-HMAC hasher.
      */
-    constructor(algorithm: SupportedCryptoAlgorithms);
+    constructor(algorithm: SupportedCryptoAlgorithms, hmacKey?: string | NodeJS.TypedArray);
 
     /**
      * Update the hash with data
@@ -3620,7 +3786,7 @@ declare module "bun" {
     | "browser";
 
   /** https://bun.sh/docs/bundler/loaders */
-  type Loader = "js" | "jsx" | "ts" | "tsx" | "json" | "toml" | "file" | "napi" | "wasm" | "text";
+  type Loader = "js" | "jsx" | "ts" | "tsx" | "json" | "toml" | "file" | "napi" | "wasm" | "text" | "css";
 
   interface PluginConstraints {
     /**
@@ -3708,10 +3874,17 @@ declare module "bun" {
      * The default loader for this file extension
      */
     loader: Loader;
+    /**
+     * Defer the execution of this callback until all other modules have been parsed.
+     *
+     * @returns Promise which will be resolved when all modules have been parsed
+     */
+    defer: () => Promise<void>;
   }
 
-  type OnLoadResult = OnLoadResultSourceCode | OnLoadResultObject | undefined;
+  type OnLoadResult = OnLoadResultSourceCode | OnLoadResultObject | undefined | void;
   type OnLoadCallback = (args: OnLoadArgs) => OnLoadResult | Promise<OnLoadResult>;
+  type OnStartCallback = () => void | Promise<void>;
 
   interface OnResolveArgs {
     /**
@@ -3726,6 +3899,10 @@ declare module "bun" {
      * The namespace of the importer.
      */
     namespace: string;
+    /** 
+     * The directory to perform file-based resolutions in.
+     */
+    resolveDir: string;
     /**
      * The kind of import this resolve is for.
      */
@@ -3755,7 +3932,30 @@ declare module "bun" {
     args: OnResolveArgs,
   ) => OnResolveResult | Promise<OnResolveResult | undefined | null> | undefined | null;
 
+  type FFIFunctionCallable = Function & {
+    // Making a nominally typed function so that the user must get it from dlopen
+    readonly __ffi_function_callable: typeof FFIFunctionCallableSymbol;
+  };
+
   interface PluginBuilder {
+    /**
+     * Register a callback which will be invoked when bundling starts.
+     * @example
+     * ```ts
+     * Bun.plugin({
+     *   setup(builder) {
+     *     builder.onStart(() => {
+     *       console.log("bundle just started!!")
+     *     });
+     *   },
+     * });
+     * ```
+     */
+    onStart(callback: OnStartCallback): void;
+    onBeforeParse(
+      constraints: PluginConstraints,
+      callback: { napiModule: unknown; symbol: string; external?: unknown | undefined },
+    ): void;
     /**
      * Register a callback to load imports with a specific import specifier
      * @param constraints The constraints to apply the plugin to
@@ -3828,7 +4028,7 @@ declare module "bun" {
      *
      * In a future version of Bun, this will be used in error messages.
      */
-    name?: string;
+    name: string;
 
     /**
      * The target JavaScript environment the plugin should be applied to.
@@ -4197,6 +4397,35 @@ declare module "bun" {
      * @param [size=16384] The maximum TLS fragment size. The maximum value is `16384`.
      */
     setMaxSendFragment(size: number): boolean;
+
+    /**
+     * Enable/disable the use of Nagle's algorithm.
+     * Only available for already connected sockets, will return false otherwise
+     * @param noDelay Default: `true`
+     * @returns true if is able to setNoDelay and false if it fails.
+     */
+    setNoDelay(noDelay?: boolean): boolean;
+
+    /**
+     * Enable/disable keep-alive functionality, and optionally set the initial delay before the first keepalive probe is sent on an idle socket.
+     * Set `initialDelay` (in milliseconds) to set the delay between the last data packet received and the first keepalive probe.
+     * Only available for already connected sockets, will return false otherwise.
+     *
+     * Enabling the keep-alive functionality will set the following socket options:
+     * SO_KEEPALIVE=1
+     * TCP_KEEPIDLE=initialDelay
+     * TCP_KEEPCNT=10
+     * TCP_KEEPINTVL=1
+     * @param enable Default: `false`
+     * @param initialDelay Default: `0`
+     * @returns true if is able to setNoDelay and false if it fails.
+     */
+    setKeepAlive(enable?: boolean, initialDelay?: number): boolean;
+
+    /**
+     * The number of bytes written to the socket.
+     */
+    readonly bytesWritten: number;
   }
 
   interface SocketListener<Data = undefined> extends Disposable {
@@ -4301,18 +4530,28 @@ declare module "bun" {
     hostname: string;
     port: number;
     tls?: TLSOptions;
+    exclusive?: boolean;
+    allowHalfOpen?: boolean;
   }
 
   interface TCPSocketConnectOptions<Data = undefined> extends SocketOptions<Data> {
     hostname: string;
     port: number;
     tls?: boolean;
+    exclusive?: boolean;
+    allowHalfOpen?: boolean;
   }
 
   interface UnixSocketOptions<Data = undefined> extends SocketOptions<Data> {
+    tls?: TLSOptions;
     unix: string;
   }
 
+  interface FdSocketOptions<Data = undefined> extends SocketOptions<Data> {
+    tls?: TLSOptions;
+    fd: number;
+  }
+
   /**
    * Create a TCP client that connects to a server
    *
@@ -4615,6 +4854,32 @@ declare module "bun" {
        * @default cmds[0]
        */
       argv0?: string;
+
+      /**
+       * An {@link AbortSignal} that can be used to abort the subprocess.
+       *
+       * This is useful for aborting a subprocess when some other part of the
+       * program is aborted, such as a `fetch` response.
+       *
+       * Internally, this works by calling `subprocess.kill(1)`.
+       *
+       * @example
+       * ```ts
+       * const controller = new AbortController();
+       * const { signal } = controller;
+       * const start = performance.now();
+       * const subprocess = Bun.spawn({
+       *  cmd: ["sleep", "100"],
+       *  signal,
+       * });
+       * await Bun.sleep(1);
+       * controller.abort();
+       * await subprocess.exited;
+       * const end = performance.now();
+       * console.log(end - start); // 1ms instead of 101ms
+       * ```
+       */
+      signal?: AbortSignal;
     }
 
     type OptionsToSubprocess<Opts extends OptionsObject> =
@@ -5118,6 +5383,12 @@ declare module "bun" {
    */
   const version: string;
 
+  /**
+   * The current version of Bun with the shortened commit sha of the build
+   * @example "v1.1.30 (d09df1af)"
+   */
+  const version_with_sha: string;
+
   /**
    * The git sha at the time the currently-running version of Bun was compiled
    * @example
@@ -5264,6 +5535,57 @@ declare module "bun" {
      */
     match(str: string): boolean;
   }
+
+  /**
+   * Generate a UUIDv7, which is a sequential ID based on the current timestamp with a random component.
+   *
+   * When the same timestamp is used multiple times, a monotonically increasing
+   * counter is appended to allow sorting. The final 8 bytes are
+   * cryptographically random. When the timestamp changes, the counter resets to
+   * a psuedo-random integer.
+   *
+   * @param encoding "hex" | "base64" | "base64url"
+   * @param timestamp Unix timestamp in milliseconds, defaults to `Date.now()`
+   *
+   * @example
+   * ```js
+   * import { randomUUIDv7 } from "bun";
+   * const array = [
+   *   randomUUIDv7(),
+   *   randomUUIDv7(),
+   *   randomUUIDv7(),
+   * ]
+   * [
+   *   "0192ce07-8c4f-7d66-afec-2482b5c9b03c",
+   *   "0192ce07-8c4f-7d67-805f-0f71581b5622",
+   *   "0192ce07-8c4f-7d68-8170-6816e4451a58"
+   * ]
+   * ```
+   */
+  function randomUUIDv7(
+    /**
+     * @default "hex"
+     */
+    encoding?: "hex" | "base64" | "base64url",
+    /**
+     * @default Date.now()
+     */
+    timestamp?: number | Date,
+  ): string;
+
+  /**
+   * Generate a UUIDv7 as a Buffer
+   *
+   * @param encoding "buffer"
+   * @param timestamp Unix timestamp in milliseconds, defaults to `Date.now()`
+   */
+  function randomUUIDv7(
+    encoding: "buffer",
+    /**
+     * @default Date.now()
+     */
+    timestamp?: number | Date,
+  ): Buffer;
 }
 
 // extends lib.dom.d.ts
diff --git a/packages/bun-types/ffi.d.ts b/packages/bun-types/ffi.d.ts
index fde1e47c98..1f0c1ffdfe 100644
--- a/packages/bun-types/ffi.d.ts
+++ b/packages/bun-types/ffi.d.ts
@@ -566,17 +566,21 @@ declare module "bun:ffi" {
 
   type ToFFIType<T extends FFITypeOrString> = T extends FFIType ? T : T extends string ? FFITypeStringToType[T] : never;
 
+  const FFIFunctionCallableSymbol: unique symbol;
   type ConvertFns<Fns extends Symbols> = {
-    [K in keyof Fns]: (
-      ...args: Fns[K]["args"] extends infer A extends readonly FFITypeOrString[]
-        ? { [L in keyof A]: FFITypeToArgsType[ToFFIType<A[L]>] }
-        : // eslint-disable-next-line @definitelytyped/no-single-element-tuple-type
-          [unknown] extends [Fns[K]["args"]]
-          ? []
-          : never
-    ) => [unknown] extends [Fns[K]["returns"]] // eslint-disable-next-line @definitelytyped/no-single-element-tuple-type
-      ? undefined
-      : FFITypeToReturnsType[ToFFIType<NonNullable<Fns[K]["returns"]>>];
+    [K in keyof Fns]: {
+      (
+        ...args: Fns[K]["args"] extends infer A extends readonly FFITypeOrString[]
+          ? { [L in keyof A]: FFITypeToArgsType[ToFFIType<A[L]>] }
+          : // eslint-disable-next-line @definitelytyped/no-single-element-tuple-type
+            [unknown] extends [Fns[K]["args"]]
+            ? []
+            : never
+      ): [unknown] extends [Fns[K]["returns"]] // eslint-disable-next-line @definitelytyped/no-single-element-tuple-type
+        ? undefined
+        : FFITypeToReturnsType[ToFFIType<NonNullable<Fns[K]["returns"]>>];
+      __ffi_function_callable: typeof FFIFunctionCallableSymbol;
+    };
   };
 
   /**
diff --git a/packages/bun-types/globals.d.ts b/packages/bun-types/globals.d.ts
index fb2727ca0d..a29bcc91cb 100644
--- a/packages/bun-types/globals.d.ts
+++ b/packages/bun-types/globals.d.ts
@@ -595,8 +595,16 @@ declare global {
        * @default true
        */
       // trackUnmanagedFds?: boolean;
-
       // resourceLimits?: import("worker_threads").ResourceLimits;
+
+      /**
+       * An array of module specifiers to preload in the worker.
+       *
+       * These modules load before the worker's entry point is executed.
+       *
+       * Equivalent to passing the `--preload` CLI argument, but only for this Worker.
+       */
+      preload?: string[] | string | undefined;
     }
 
     interface Worker extends EventTarget, AbstractWorker {
@@ -1673,7 +1681,36 @@ declare global {
     groupEnd(): void;
     info(...data: any[]): void;
     log(...data: any[]): void;
-    /** Does nothing currently */
+    /**
+     * Try to construct a table with the columns of the properties of `tabularData` (or use `properties`) and rows of `tabularData` and log it. Falls back to just
+     * logging the argument if it can't be parsed as tabular.
+     *
+     * ```js
+     * // These can't be parsed as tabular data
+     * console.table(Symbol());
+     * // Symbol()
+     *
+     * console.table(undefined);
+     * // undefined
+     *
+     * console.table([{ a: 1, b: 'Y' }, { a: 'Z', b: 2 }]);
+     * // ┌────┬─────┬─────┐
+     * // │    │  a  │  b  │
+     * // ├────┼─────┼─────┤
+     * // │  0 │  1  │ 'Y' │
+     * // │  1 │ 'Z' │  2  │
+     * // └────┴─────┴─────┘
+     *
+     * console.table([{ a: 1, b: 'Y' }, { a: 'Z', b: 2 }], ['a']);
+     * // ┌────┬─────┐
+     * // │    │  a  │
+     * // ├────┼─────┤
+     * // │ 0  │  1  │
+     * // │ 1  │ 'Z' │
+     * // └────┴─────┘
+     * ```
+     * @param properties Alternate properties for constructing the table.
+     */
     table(tabularData?: any, properties?: string[]): void;
     /**
      * Begin a timer to log with {@link console.timeEnd}
@@ -1838,14 +1875,6 @@ declare global {
     withCredentials?: boolean;
   }
 
-  interface EventSource extends Bun.EventSource {}
-  var EventSource: typeof globalThis extends {
-    onerror: any;
-    EventSource: infer T;
-  }
-    ? T
-    : EventSource;
-
   interface PromiseConstructor {
     /**
      * Create a deferred promise, with exposed `resolve` and `reject` methods which can be called
diff --git a/packages/bun-types/package.json b/packages/bun-types/package.json
index 3d406b2c92..5cf34ddc8e 100644
--- a/packages/bun-types/package.json
+++ b/packages/bun-types/package.json
@@ -3,14 +3,16 @@
   "license": "MIT",
   "main": "",
   "types": "index.d.ts",
-  "description": "Type definitions for Bun, an incredibly fast JavaScript runtime",
+  "description": "Type definitions and documentation for Bun, an incredibly fast JavaScript runtime",
   "repository": {
     "type": "git",
     "url": "https://github.com/oven-sh/bun",
     "directory": "packages/bun-types"
   },
   "files": [
-    "*.d.ts"
+    "*.d.ts",
+    "docs/**/*.md",
+    "docs/*.md"
   ],
   "homepage": "https://bun.sh",
   "dependencies": {
@@ -25,7 +27,8 @@
   },
   "scripts": {
     "prebuild": "echo $(pwd)",
-    "build": "bun scripts/build.ts && bun run fmt",
+    "copy-docs": "rm -rf docs && cp -r ../../docs/ ./docs",
+    "build": "bun run copy-docs && bun scripts/build.ts && bun run fmt",
     "test": "tsc",
     "fmt": "echo $(which biome) && biome format --write ."
   },
diff --git a/packages/bun-types/sqlite.d.ts b/packages/bun-types/sqlite.d.ts
index 3fe1301a41..97b2e83320 100644
--- a/packages/bun-types/sqlite.d.ts
+++ b/packages/bun-types/sqlite.d.ts
@@ -579,6 +579,15 @@ declare module "bun:sqlite" {
      */
     get(...params: ParamsType): ReturnType | null;
 
+    /**
+     * Execute the prepared statement and return an
+     *
+     * @param params optional values to bind to the statement. If omitted, the statement is run with the last bound values or no parameters if there are none.
+     *
+     */
+    iterate(...params: ParamsType): IterableIterator<ReturnType>;
+    [Symbol.iterator](): IterableIterator<ReturnType>;
+
     /**
      * Execute the prepared statement. This returns `undefined`.
      *
diff --git a/packages/bun-types/test.d.ts b/packages/bun-types/test.d.ts
index dd76ecc98a..da6fbd31f7 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
@@ -1295,6 +1295,29 @@ declare module "bun:test" {
      * @param hint Hint used to identify the snapshot in the snapshot file.
      */
     toMatchSnapshot(propertyMatchers?: object, hint?: string): void;
+    /**
+     * Asserts that a value matches the most recent inline snapshot.
+     *
+     * @example
+     * expect("Hello").toMatchInlineSnapshot(`"Hello"`);
+     * @param value The latest snapshot value.
+     */
+    toMatchInlineSnapshot(value?: string): void;
+    /**
+     * Asserts that a value matches the most recent inline snapshot.
+     *
+     * @example
+     * expect("Hello").toMatchInlineSnapshot(`"Hello"`);
+     * expect({ c: new Date() }).toMatchInlineSnapshot({ c: expect.any(Date) }, `
+     * {
+     *   "v": Any<Date>,
+     * }
+     * `);
+     *
+     * @param propertyMatchers Object containing properties to match against the value.
+     * @param hint Hint used to identify the snapshot in the snapshot file.
+     */
+    toMatchInlineSnapshot(propertyMatchers?: object, value?: string): void;
     /**
      * Asserts that an object matches a subset of properties.
      *
diff --git a/packages/bun-types/test/globals.test.ts b/packages/bun-types/test/globals.test.ts
index c324ad18f9..d2fb69e4c9 100644
--- a/packages/bun-types/test/globals.test.ts
+++ b/packages/bun-types/test/globals.test.ts
@@ -208,10 +208,6 @@ const writableStream = new WritableStream();
   const a = new ResolveError();
   a.level;
 }
-{
-  const a = new EventSource("asdf");
-  a.CLOSED;
-}
 {
   const a = new AbortController();
   a;
diff --git a/packages/bun-usockets/certdata.txt b/packages/bun-usockets/certdata.txt
index ea914d4090..110a814718 100644
--- a/packages/bun-usockets/certdata.txt
+++ b/packages/bun-usockets/certdata.txt
@@ -3645,7 +3645,7 @@ CKA_SERIAL_NUMBER MULTILINE_OCTAL
 \002\006\040\006\005\026\160\002
 END
 CKA_TRUST_SERVER_AUTH CK_TRUST CKT_NSS_TRUSTED_DELEGATOR
-CKA_TRUST_EMAIL_PROTECTION CK_TRUST CKT_NSS_TRUSTED_DELEGATOR
+CKA_TRUST_EMAIL_PROTECTION CK_TRUST CKT_NSS_MUST_VERIFY_TRUST
 CKA_TRUST_CODE_SIGNING CK_TRUST CKT_NSS_MUST_VERIFY_TRUST
 CKA_TRUST_STEP_UP_APPROVED CK_BBOOL CK_FALSE
 
@@ -7252,7 +7252,7 @@ CKA_SERIAL_NUMBER MULTILINE_OCTAL
 \002\010\136\303\267\246\103\177\244\340
 END
 CKA_TRUST_SERVER_AUTH CK_TRUST CKT_NSS_TRUSTED_DELEGATOR
-CKA_TRUST_EMAIL_PROTECTION CK_TRUST CKT_NSS_TRUSTED_DELEGATOR
+CKA_TRUST_EMAIL_PROTECTION CK_TRUST CKT_NSS_MUST_VERIFY_TRUST
 CKA_TRUST_CODE_SIGNING CK_TRUST CKT_NSS_MUST_VERIFY_TRUST
 CKA_TRUST_STEP_UP_APPROVED CK_BBOOL CK_FALSE
 
@@ -17020,8 +17020,14 @@ CKA_VALUE MULTILINE_OCTAL
 \155\015\277\173\327\222
 END
 CKA_NSS_MOZILLA_CA_POLICY CK_BBOOL CK_TRUE
-CKA_NSS_SERVER_DISTRUST_AFTER CK_BBOOL CK_FALSE
-CKA_NSS_EMAIL_DISTRUST_AFTER CK_BBOOL CK_FALSE
+# For Server Distrust After: Sun Jun 30 00:00:00 2024
+CKA_NSS_SERVER_DISTRUST_AFTER MULTILINE_OCTAL
+\062\064\060\066\063\060\060\060\060\060\060\060\132
+END
+# For Email Distrust After: Sun Jun 30 00:00:00 2024
+CKA_NSS_EMAIL_DISTRUST_AFTER MULTILINE_OCTAL
+\062\064\060\066\063\060\060\060\060\060\060\060\132
+END
 
 # Trust for "GLOBALTRUST 2020"
 # Issuer: CN=GLOBALTRUST 2020,O=e-commerce monitoring GmbH,C=AT
@@ -25483,3 +25489,761 @@ CKA_TRUST_EMAIL_PROTECTION CK_TRUST CKT_NSS_MUST_VERIFY_TRUST
 CKA_TRUST_CODE_SIGNING CK_TRUST CKT_NSS_MUST_VERIFY_TRUST
 CKA_TRUST_STEP_UP_APPROVED CK_BBOOL CK_FALSE
 
+#
+# Certificate "TWCA CYBER Root CA"
+#
+# Issuer: CN=TWCA CYBER Root CA,OU=Root CA,O=TAIWAN-CA,C=TW
+# Serial Number:40:01:34:8c:c2:00:00:00:00:00:00:00:01:3c:f2:c6
+# Subject: CN=TWCA CYBER Root CA,OU=Root CA,O=TAIWAN-CA,C=TW
+# Not Valid Before: Tue Nov 22 06:54:29 2022
+# Not Valid After : Fri Nov 22 15:59:59 2047
+# Fingerprint (SHA-256): 3F:63:BB:28:14:BE:17:4E:C8:B6:43:9C:F0:8D:6D:56:F0:B7:C4:05:88:3A:56:48:A3:34:42:4D:6B:3E:C5:58
+# Fingerprint (SHA1): F6:B1:1C:1A:83:38:E9:7B:DB:B3:A8:C8:33:24:E0:2D:9C:7F:26:66
+CKA_CLASS CK_OBJECT_CLASS CKO_CERTIFICATE
+CKA_TOKEN CK_BBOOL CK_TRUE
+CKA_PRIVATE CK_BBOOL CK_FALSE
+CKA_MODIFIABLE CK_BBOOL CK_FALSE
+CKA_LABEL UTF8 "TWCA CYBER Root CA"
+CKA_CERTIFICATE_TYPE CK_CERTIFICATE_TYPE CKC_X_509
+CKA_SUBJECT MULTILINE_OCTAL
+\060\120\061\013\060\011\006\003\125\004\006\023\002\124\127\061
+\022\060\020\006\003\125\004\012\023\011\124\101\111\127\101\116
+\055\103\101\061\020\060\016\006\003\125\004\013\023\007\122\157
+\157\164\040\103\101\061\033\060\031\006\003\125\004\003\023\022
+\124\127\103\101\040\103\131\102\105\122\040\122\157\157\164\040
+\103\101
+END
+CKA_ID UTF8 "0"
+CKA_ISSUER MULTILINE_OCTAL
+\060\120\061\013\060\011\006\003\125\004\006\023\002\124\127\061
+\022\060\020\006\003\125\004\012\023\011\124\101\111\127\101\116
+\055\103\101\061\020\060\016\006\003\125\004\013\023\007\122\157
+\157\164\040\103\101\061\033\060\031\006\003\125\004\003\023\022
+\124\127\103\101\040\103\131\102\105\122\040\122\157\157\164\040
+\103\101
+END
+CKA_SERIAL_NUMBER MULTILINE_OCTAL
+\002\020\100\001\064\214\302\000\000\000\000\000\000\000\001\074
+\362\306
+END
+CKA_VALUE MULTILINE_OCTAL
+\060\202\005\215\060\202\003\165\240\003\002\001\002\002\020\100
+\001\064\214\302\000\000\000\000\000\000\000\001\074\362\306\060
+\015\006\011\052\206\110\206\367\015\001\001\014\005\000\060\120
+\061\013\060\011\006\003\125\004\006\023\002\124\127\061\022\060
+\020\006\003\125\004\012\023\011\124\101\111\127\101\116\055\103
+\101\061\020\060\016\006\003\125\004\013\023\007\122\157\157\164
+\040\103\101\061\033\060\031\006\003\125\004\003\023\022\124\127
+\103\101\040\103\131\102\105\122\040\122\157\157\164\040\103\101
+\060\036\027\015\062\062\061\061\062\062\060\066\065\064\062\071
+\132\027\015\064\067\061\061\062\062\061\065\065\071\065\071\132
+\060\120\061\013\060\011\006\003\125\004\006\023\002\124\127\061
+\022\060\020\006\003\125\004\012\023\011\124\101\111\127\101\116
+\055\103\101\061\020\060\016\006\003\125\004\013\023\007\122\157
+\157\164\040\103\101\061\033\060\031\006\003\125\004\003\023\022
+\124\127\103\101\040\103\131\102\105\122\040\122\157\157\164\040
+\103\101\060\202\002\042\060\015\006\011\052\206\110\206\367\015
+\001\001\001\005\000\003\202\002\017\000\060\202\002\012\002\202
+\002\001\000\306\370\312\036\331\011\040\176\035\154\116\316\217
+\343\107\063\104\234\307\311\151\252\072\133\170\356\160\322\222
+\370\004\263\122\122\035\147\162\050\241\337\213\135\225\012\376
+\352\315\355\367\051\316\360\157\177\254\315\075\357\263\034\105
+\152\367\050\220\361\141\127\305\014\304\243\120\135\336\324\265
+\313\031\312\200\271\165\316\051\316\322\205\042\354\002\143\314
+\104\060\040\332\352\221\133\126\346\035\034\325\235\146\307\077
+\337\206\312\113\123\304\331\215\262\035\352\370\334\047\123\243
+\107\341\141\314\175\265\260\370\356\163\221\305\316\163\157\316
+\356\020\037\032\006\317\351\047\140\305\117\031\344\353\316\042
+\046\105\327\140\231\335\316\117\067\340\177\347\143\255\260\270
+\131\270\320\006\150\065\140\323\066\256\161\103\004\361\151\145
+\170\174\363\037\363\312\050\237\132\040\225\146\264\315\267\356
+\217\170\244\105\030\351\046\057\215\233\051\050\261\244\267\072
+\155\271\324\034\070\162\105\130\261\136\353\360\050\233\267\202
+\312\375\317\326\063\017\237\373\227\236\261\034\234\236\352\137
+\136\333\252\335\124\351\060\041\050\155\216\171\363\165\222\214
+\046\376\334\305\366\303\260\337\104\131\103\243\266\003\050\366
+\010\060\252\015\063\341\357\234\251\007\042\343\131\133\100\217
+\332\210\267\151\010\250\267\043\056\104\011\131\067\133\307\343
+\027\362\042\353\156\071\122\305\336\124\247\230\311\113\040\225
+\334\106\211\137\264\022\371\205\051\216\353\310\047\025\040\300
+\113\324\314\174\014\154\064\014\046\233\046\061\246\074\247\366
+\331\320\113\242\144\377\073\231\101\162\301\340\160\227\361\044
+\273\053\304\164\042\261\254\153\042\062\044\323\170\052\300\300
+\241\057\361\122\005\311\077\357\166\146\342\105\330\015\075\255
+\225\310\307\211\046\310\017\256\247\003\056\373\301\137\372\040
+\341\160\255\260\145\040\067\063\140\260\325\257\327\014\034\302
+\220\160\327\112\030\274\176\001\260\260\353\025\036\104\006\315
+\244\117\350\014\321\303\040\020\341\124\145\236\266\121\320\032
+\166\153\102\132\130\166\064\352\267\067\031\256\056\165\371\226
+\345\301\131\367\224\127\051\045\215\072\114\253\115\232\101\320
+\137\046\003\002\003\001\000\001\243\143\060\141\060\016\006\003
+\125\035\017\001\001\377\004\004\003\002\001\006\060\017\006\003
+\125\035\023\001\001\377\004\005\060\003\001\001\377\060\037\006
+\003\125\035\043\004\030\060\026\200\024\235\205\141\024\174\301
+\142\157\227\150\344\117\067\100\341\255\340\015\126\067\060\035
+\006\003\125\035\016\004\026\004\024\235\205\141\024\174\301\142
+\157\227\150\344\117\067\100\341\255\340\015\126\067\060\015\006
+\011\052\206\110\206\367\015\001\001\014\005\000\003\202\002\001
+\000\144\217\172\304\142\016\265\210\314\270\307\206\016\241\112
+\026\315\160\013\267\247\205\013\263\166\266\017\247\377\010\213
+\013\045\317\250\324\203\165\052\270\226\210\266\373\337\055\055
+\264\151\123\041\065\127\326\211\115\163\277\151\217\160\243\141
+\314\232\333\036\232\340\040\370\154\273\233\042\235\135\204\061
+\232\054\212\335\152\241\327\050\151\312\376\166\125\172\106\147
+\353\314\103\210\026\242\003\326\271\027\370\031\154\155\043\002
+\177\361\137\320\012\051\043\073\321\252\012\355\251\027\046\124
+\012\115\302\245\115\370\305\375\270\201\317\053\054\170\243\147
+\114\251\007\232\363\337\136\373\174\365\211\315\164\227\141\020
+\152\007\053\201\132\322\216\267\347\040\321\040\156\044\250\204
+\047\241\127\254\252\125\130\057\334\331\312\372\150\004\236\355
+\104\044\371\164\100\073\043\063\253\203\132\030\046\102\266\155
+\124\265\026\140\060\154\261\240\370\270\101\240\135\111\111\322
+\145\005\072\352\376\235\141\274\206\331\277\336\323\272\072\261
+\177\176\222\064\216\311\000\156\334\230\275\334\354\200\005\255
+\002\075\337\145\355\013\003\367\367\026\204\004\061\272\223\224
+\330\362\022\370\212\343\277\102\257\247\324\315\021\027\026\310
+\102\035\024\250\102\366\322\100\206\240\117\043\312\226\105\126
+\140\006\315\267\125\001\246\001\224\145\376\156\005\011\272\264
+\244\252\342\357\130\276\275\047\126\330\357\163\161\133\104\063
+\362\232\162\352\260\136\076\156\251\122\133\354\160\155\265\207
+\217\067\136\074\214\234\316\344\360\316\014\147\101\314\316\366
+\200\253\116\314\114\126\365\301\141\131\223\264\076\246\332\270
+\067\022\237\052\062\343\213\270\041\354\303\053\145\014\357\042
+\336\210\051\073\114\327\372\376\267\341\107\276\234\076\076\203
+\373\121\135\365\150\367\056\041\205\334\277\361\132\342\174\327
+\305\344\203\301\152\353\272\200\132\336\134\055\160\166\370\310
+\345\207\207\312\240\235\241\345\042\022\047\017\104\075\035\154
+\352\324\302\213\057\157\171\253\177\120\246\304\031\247\241\172
+\267\226\371\301\037\142\132\242\103\007\100\136\046\306\254\355
+\256\160\026\305\252\312\162\212\115\260\317\001\213\003\077\156
+\327
+END
+CKA_NSS_MOZILLA_CA_POLICY CK_BBOOL CK_TRUE
+CKA_NSS_SERVER_DISTRUST_AFTER CK_BBOOL CK_FALSE
+CKA_NSS_EMAIL_DISTRUST_AFTER CK_BBOOL CK_FALSE
+
+# Trust for "TWCA CYBER Root CA"
+# Issuer: CN=TWCA CYBER Root CA,OU=Root CA,O=TAIWAN-CA,C=TW
+# Serial Number:40:01:34:8c:c2:00:00:00:00:00:00:00:01:3c:f2:c6
+# Subject: CN=TWCA CYBER Root CA,OU=Root CA,O=TAIWAN-CA,C=TW
+# Not Valid Before: Tue Nov 22 06:54:29 2022
+# Not Valid After : Fri Nov 22 15:59:59 2047
+# Fingerprint (SHA-256): 3F:63:BB:28:14:BE:17:4E:C8:B6:43:9C:F0:8D:6D:56:F0:B7:C4:05:88:3A:56:48:A3:34:42:4D:6B:3E:C5:58
+# Fingerprint (SHA1): F6:B1:1C:1A:83:38:E9:7B:DB:B3:A8:C8:33:24:E0:2D:9C:7F:26:66
+CKA_CLASS CK_OBJECT_CLASS CKO_NSS_TRUST
+CKA_TOKEN CK_BBOOL CK_TRUE
+CKA_PRIVATE CK_BBOOL CK_FALSE
+CKA_MODIFIABLE CK_BBOOL CK_FALSE
+CKA_LABEL UTF8 "TWCA CYBER Root CA"
+CKA_CERT_SHA1_HASH MULTILINE_OCTAL
+\366\261\034\032\203\070\351\173\333\263\250\310\063\044\340\055
+\234\177\046\146
+END
+CKA_CERT_MD5_HASH MULTILINE_OCTAL
+\013\063\240\227\122\225\324\251\375\273\333\156\243\125\133\121
+END
+CKA_ISSUER MULTILINE_OCTAL
+\060\120\061\013\060\011\006\003\125\004\006\023\002\124\127\061
+\022\060\020\006\003\125\004\012\023\011\124\101\111\127\101\116
+\055\103\101\061\020\060\016\006\003\125\004\013\023\007\122\157
+\157\164\040\103\101\061\033\060\031\006\003\125\004\003\023\022
+\124\127\103\101\040\103\131\102\105\122\040\122\157\157\164\040
+\103\101
+END
+CKA_SERIAL_NUMBER MULTILINE_OCTAL
+\002\020\100\001\064\214\302\000\000\000\000\000\000\000\001\074
+\362\306
+END
+CKA_TRUST_SERVER_AUTH CK_TRUST CKT_NSS_TRUSTED_DELEGATOR
+CKA_TRUST_EMAIL_PROTECTION CK_TRUST CKT_NSS_MUST_VERIFY_TRUST
+CKA_TRUST_CODE_SIGNING CK_TRUST CKT_NSS_MUST_VERIFY_TRUST
+CKA_TRUST_STEP_UP_APPROVED CK_BBOOL CK_FALSE
+
+#
+# Certificate "TWCA Global Root CA G2"
+#
+# Issuer: CN=TWCA Global Root CA G2,OU=Root CA,O=TAIWAN-CA,C=TW
+# Serial Number:40:01:34:8c:c2:00:00:00:00:00:00:00:01:97:58:f4
+# Subject: CN=TWCA Global Root CA G2,OU=Root CA,O=TAIWAN-CA,C=TW
+# Not Valid Before: Tue Nov 22 06:42:21 2022
+# Not Valid After : Fri Nov 22 15:59:59 2047
+# Fingerprint (SHA-256): 3A:00:72:D4:9F:FC:04:E9:96:C5:9A:EB:75:99:1D:3C:34:0F:36:15:D6:FD:4D:CE:90:AC:0B:3D:88:EA:D4:F4
+# Fingerprint (SHA1): 73:FE:92:2F:83:63:91:FF:C8:C6:C4:DA:D6:20:2F:6B:07:2E:7F:1B
+CKA_CLASS CK_OBJECT_CLASS CKO_CERTIFICATE
+CKA_TOKEN CK_BBOOL CK_TRUE
+CKA_PRIVATE CK_BBOOL CK_FALSE
+CKA_MODIFIABLE CK_BBOOL CK_FALSE
+CKA_LABEL UTF8 "TWCA Global Root CA G2"
+CKA_CERTIFICATE_TYPE CK_CERTIFICATE_TYPE CKC_X_509
+CKA_SUBJECT MULTILINE_OCTAL
+\060\124\061\013\060\011\006\003\125\004\006\023\002\124\127\061
+\022\060\020\006\003\125\004\012\023\011\124\101\111\127\101\116
+\055\103\101\061\020\060\016\006\003\125\004\013\023\007\122\157
+\157\164\040\103\101\061\037\060\035\006\003\125\004\003\023\026
+\124\127\103\101\040\107\154\157\142\141\154\040\122\157\157\164
+\040\103\101\040\107\062
+END
+CKA_ID UTF8 "0"
+CKA_ISSUER MULTILINE_OCTAL
+\060\124\061\013\060\011\006\003\125\004\006\023\002\124\127\061
+\022\060\020\006\003\125\004\012\023\011\124\101\111\127\101\116
+\055\103\101\061\020\060\016\006\003\125\004\013\023\007\122\157
+\157\164\040\103\101\061\037\060\035\006\003\125\004\003\023\026
+\124\127\103\101\040\107\154\157\142\141\154\040\122\157\157\164
+\040\103\101\040\107\062
+END
+CKA_SERIAL_NUMBER MULTILINE_OCTAL
+\002\020\100\001\064\214\302\000\000\000\000\000\000\000\001\227
+\130\364
+END
+CKA_VALUE MULTILINE_OCTAL
+\060\202\005\225\060\202\003\175\240\003\002\001\002\002\020\100
+\001\064\214\302\000\000\000\000\000\000\000\001\227\130\364\060
+\015\006\011\052\206\110\206\367\015\001\001\014\005\000\060\124
+\061\013\060\011\006\003\125\004\006\023\002\124\127\061\022\060
+\020\006\003\125\004\012\023\011\124\101\111\127\101\116\055\103
+\101\061\020\060\016\006\003\125\004\013\023\007\122\157\157\164
+\040\103\101\061\037\060\035\006\003\125\004\003\023\026\124\127
+\103\101\040\107\154\157\142\141\154\040\122\157\157\164\040\103
+\101\040\107\062\060\036\027\015\062\062\061\061\062\062\060\066
+\064\062\062\061\132\027\015\064\067\061\061\062\062\061\065\065
+\071\065\071\132\060\124\061\013\060\011\006\003\125\004\006\023
+\002\124\127\061\022\060\020\006\003\125\004\012\023\011\124\101
+\111\127\101\116\055\103\101\061\020\060\016\006\003\125\004\013
+\023\007\122\157\157\164\040\103\101\061\037\060\035\006\003\125
+\004\003\023\026\124\127\103\101\040\107\154\157\142\141\154\040
+\122\157\157\164\040\103\101\040\107\062\060\202\002\042\060\015
+\006\011\052\206\110\206\367\015\001\001\001\005\000\003\202\002
+\017\000\060\202\002\012\002\202\002\001\000\252\016\325\040\222
+\001\255\202\371\014\010\221\064\153\212\026\320\106\026\377\003
+\270\330\215\352\223\064\373\377\053\275\375\156\252\334\233\362
+\206\201\125\365\211\034\304\215\165\152\130\170\221\023\036\002
+\023\160\075\357\276\012\347\000\217\270\061\345\164\305\060\276
+\377\175\326\231\345\302\102\243\317\041\326\263\010\177\221\325
+\141\346\242\225\020\015\357\136\227\013\111\070\325\042\260\327
+\213\131\157\237\065\233\177\322\221\314\172\177\273\240\237\336
+\125\063\366\113\215\012\352\175\011\300\171\334\275\104\342\376
+\034\347\144\041\050\317\004\112\342\264\277\206\171\052\273\016
+\223\311\217\136\254\060\071\122\220\007\271\352\234\046\102\024
+\304\147\106\376\321\032\150\241\076\120\031\243\046\012\047\051
+\220\302\366\264\353\163\232\170\036\341\230\364\145\014\065\041
+\006\370\013\336\142\345\115\301\263\135\331\271\372\141\227\052
+\343\352\307\104\125\044\222\376\022\247\077\304\167\340\055\002
+\201\007\325\373\175\346\020\236\072\264\250\357\354\373\120\352
+\065\317\314\176\273\102\271\104\154\122\351\277\052\162\037\077
+\336\233\160\351\334\132\305\073\273\277\360\131\205\257\057\301
+\260\024\171\005\254\165\237\045\365\021\047\006\140\041\307\155
+\145\276\250\211\234\345\254\106\337\370\135\104\003\215\140\275
+\367\261\015\314\057\357\101\124\057\356\153\225\271\116\174\064
+\337\073\371\167\235\175\315\007\075\034\006\063\022\200\354\162
+\234\362\055\202\332\325\073\304\307\371\004\303\144\002\174\365
+\065\140\247\264\106\051\056\033\357\245\130\200\056\172\211\121
+\070\066\074\375\241\167\270\200\060\320\212\336\215\247\064\046
+\354\043\273\030\125\030\066\105\356\355\001\006\252\115\277\144
+\014\312\230\227\032\061\002\146\370\170\150\133\210\337\011\250
+\347\233\372\064\155\160\034\041\255\010\213\362\241\266\254\166
+\152\277\361\200\045\000\276\074\036\115\256\271\074\266\225\143
+\275\153\176\107\022\220\125\105\021\215\354\027\037\301\276\047
+\201\223\127\143\151\000\046\167\213\303\131\345\173\321\015\104
+\362\250\360\367\205\232\005\367\302\056\160\232\223\205\330\225
+\220\061\220\124\246\354\013\237\067\105\017\002\003\001\000\001
+\243\143\060\141\060\016\006\003\125\035\017\001\001\377\004\004
+\003\002\001\006\060\017\006\003\125\035\023\001\001\377\004\005
+\060\003\001\001\377\060\037\006\003\125\035\043\004\030\060\026
+\200\024\222\214\324\066\321\133\107\123\304\161\015\204\335\144
+\052\365\066\144\100\347\060\035\006\003\125\035\016\004\026\004
+\024\222\214\324\066\321\133\107\123\304\161\015\204\335\144\052
+\365\066\144\100\347\060\015\006\011\052\206\110\206\367\015\001
+\001\014\005\000\003\202\002\001\000\045\374\113\332\220\264\332
+\165\347\101\072\201\321\246\376\240\152\363\030\161\142\152\044
+\010\213\251\172\115\311\125\316\317\020\050\056\004\031\226\005
+\317\135\002\040\052\073\263\125\077\001\315\102\315\262\167\355
+\377\165\363\174\167\333\226\245\317\214\147\006\364\244\233\162
+\366\041\111\011\230\243\062\136\167\132\143\011\357\142\103\227
+\002\070\265\352\074\030\120\150\374\131\133\331\171\324\361\344
+\126\110\023\126\330\323\161\013\136\170\224\070\021\105\372\005
+\027\365\016\165\036\142\122\141\106\272\056\031\255\206\264\210
+\017\261\120\346\100\000\064\032\225\235\223\340\121\371\324\125
+\106\351\225\074\045\206\056\227\327\001\061\030\104\354\034\140
+\351\175\151\257\062\370\227\100\045\044\266\215\032\125\074\305
+\267\367\274\006\122\073\161\060\160\076\161\027\176\361\146\004
+\136\135\274\212\061\103\246\222\035\173\124\322\245\066\213\157
+\215\326\136\332\324\303\056\035\337\071\125\140\202\060\236\047
+\377\216\200\335\143\114\246\125\065\330\320\063\251\200\155\076
+\136\235\314\250\147\200\146\372\231\127\014\122\312\031\165\260
+\070\065\125\052\201\305\214\036\126\327\137\220\362\040\330\332
+\340\146\161\351\262\170\253\147\271\044\156\153\066\162\374\157
+\215\375\177\162\071\050\147\122\221\005\037\127\145\322\243\247
+\015\141\372\241\347\325\065\106\225\311\006\207\366\060\354\062
+\121\251\254\126\300\041\116\243\024\164\005\072\274\343\277\155
+\075\116\077\136\245\244\155\051\277\204\121\165\123\216\206\032
+\365\121\160\052\015\034\116\100\341\375\243\343\245\053\147\220
+\222\307\154\256\205\277\072\233\027\025\312\234\052\223\324\115
+\071\015\274\040\010\243\215\210\154\011\015\214\256\104\041\115
+\311\161\354\330\046\327\027\236\055\021\030\074\243\042\175\270
+\047\124\277\150\310\073\102\314\217\136\116\347\334\302\305\372
+\152\104\017\215\126\210\172\337\211\204\154\240\263\076\075\361
+\145\000\011\210\352\052\353\100\316\263\135\254\062\027\256\301
+\233\351\320\301\365\111\224\335\247\316\174\132\007\353\256\040
+\234\027\060\222\151\223\162\363\232\133\161\233\376\152\337\172
+\060\151\216\263\056\333\017\054\335
+END
+CKA_NSS_MOZILLA_CA_POLICY CK_BBOOL CK_TRUE
+CKA_NSS_SERVER_DISTRUST_AFTER CK_BBOOL CK_FALSE
+CKA_NSS_EMAIL_DISTRUST_AFTER CK_BBOOL CK_FALSE
+
+# Trust for "TWCA Global Root CA G2"
+# Issuer: CN=TWCA Global Root CA G2,OU=Root CA,O=TAIWAN-CA,C=TW
+# Serial Number:40:01:34:8c:c2:00:00:00:00:00:00:00:01:97:58:f4
+# Subject: CN=TWCA Global Root CA G2,OU=Root CA,O=TAIWAN-CA,C=TW
+# Not Valid Before: Tue Nov 22 06:42:21 2022
+# Not Valid After : Fri Nov 22 15:59:59 2047
+# Fingerprint (SHA-256): 3A:00:72:D4:9F:FC:04:E9:96:C5:9A:EB:75:99:1D:3C:34:0F:36:15:D6:FD:4D:CE:90:AC:0B:3D:88:EA:D4:F4
+# Fingerprint (SHA1): 73:FE:92:2F:83:63:91:FF:C8:C6:C4:DA:D6:20:2F:6B:07:2E:7F:1B
+CKA_CLASS CK_OBJECT_CLASS CKO_NSS_TRUST
+CKA_TOKEN CK_BBOOL CK_TRUE
+CKA_PRIVATE CK_BBOOL CK_FALSE
+CKA_MODIFIABLE CK_BBOOL CK_FALSE
+CKA_LABEL UTF8 "TWCA Global Root CA G2"
+CKA_CERT_SHA1_HASH MULTILINE_OCTAL
+\163\376\222\057\203\143\221\377\310\306\304\332\326\040\057\153
+\007\056\177\033
+END
+CKA_CERT_MD5_HASH MULTILINE_OCTAL
+\023\215\135\372\031\265\346\253\144\173\020\164\160\032\043\056
+END
+CKA_ISSUER MULTILINE_OCTAL
+\060\124\061\013\060\011\006\003\125\004\006\023\002\124\127\061
+\022\060\020\006\003\125\004\012\023\011\124\101\111\127\101\116
+\055\103\101\061\020\060\016\006\003\125\004\013\023\007\122\157
+\157\164\040\103\101\061\037\060\035\006\003\125\004\003\023\026
+\124\127\103\101\040\107\154\157\142\141\154\040\122\157\157\164
+\040\103\101\040\107\062
+END
+CKA_SERIAL_NUMBER MULTILINE_OCTAL
+\002\020\100\001\064\214\302\000\000\000\000\000\000\000\001\227
+\130\364
+END
+CKA_TRUST_SERVER_AUTH CK_TRUST CKT_NSS_MUST_VERIFY_TRUST
+CKA_TRUST_EMAIL_PROTECTION CK_TRUST CKT_NSS_TRUSTED_DELEGATOR
+CKA_TRUST_CODE_SIGNING CK_TRUST CKT_NSS_MUST_VERIFY_TRUST
+CKA_TRUST_STEP_UP_APPROVED CK_BBOOL CK_FALSE
+
+#
+# Certificate "SecureSign Root CA12"
+#
+# Issuer: CN=SecureSign Root CA12,O="Cybertrust Japan Co., Ltd.",C=JP
+# Serial Number:66:f9:c7:c1:af:ec:c2:51:b4:ed:53:97:e6:e6:82:c3:2b:1c:90:16
+# Subject: CN=SecureSign Root CA12,O="Cybertrust Japan Co., Ltd.",C=JP
+# Not Valid Before: Wed Apr 08 05:36:46 2020
+# Not Valid After : Sun Apr 08 05:36:46 2040
+# Fingerprint (SHA-256): 3F:03:4B:B5:70:4D:44:B2:D0:85:45:A0:20:57:DE:93:EB:F3:90:5F:CE:72:1A:CB:C7:30:C0:6D:DA:EE:90:4E
+# Fingerprint (SHA1): 7A:22:1E:3D:DE:1B:06:AC:9E:C8:47:70:16:8E:3C:E5:F7:6B:06:F4
+CKA_CLASS CK_OBJECT_CLASS CKO_CERTIFICATE
+CKA_TOKEN CK_BBOOL CK_TRUE
+CKA_PRIVATE CK_BBOOL CK_FALSE
+CKA_MODIFIABLE CK_BBOOL CK_FALSE
+CKA_LABEL UTF8 "SecureSign Root CA12"
+CKA_CERTIFICATE_TYPE CK_CERTIFICATE_TYPE CKC_X_509
+CKA_SUBJECT MULTILINE_OCTAL
+\060\121\061\013\060\011\006\003\125\004\006\023\002\112\120\061
+\043\060\041\006\003\125\004\012\023\032\103\171\142\145\162\164
+\162\165\163\164\040\112\141\160\141\156\040\103\157\056\054\040
+\114\164\144\056\061\035\060\033\006\003\125\004\003\023\024\123
+\145\143\165\162\145\123\151\147\156\040\122\157\157\164\040\103
+\101\061\062
+END
+CKA_ID UTF8 "0"
+CKA_ISSUER MULTILINE_OCTAL
+\060\121\061\013\060\011\006\003\125\004\006\023\002\112\120\061
+\043\060\041\006\003\125\004\012\023\032\103\171\142\145\162\164
+\162\165\163\164\040\112\141\160\141\156\040\103\157\056\054\040
+\114\164\144\056\061\035\060\033\006\003\125\004\003\023\024\123
+\145\143\165\162\145\123\151\147\156\040\122\157\157\164\040\103
+\101\061\062
+END
+CKA_SERIAL_NUMBER MULTILINE_OCTAL
+\002\024\146\371\307\301\257\354\302\121\264\355\123\227\346\346
+\202\303\053\034\220\026
+END
+CKA_VALUE MULTILINE_OCTAL
+\060\202\003\162\060\202\002\132\240\003\002\001\002\002\024\146
+\371\307\301\257\354\302\121\264\355\123\227\346\346\202\303\053
+\034\220\026\060\015\006\011\052\206\110\206\367\015\001\001\013
+\005\000\060\121\061\013\060\011\006\003\125\004\006\023\002\112
+\120\061\043\060\041\006\003\125\004\012\023\032\103\171\142\145
+\162\164\162\165\163\164\040\112\141\160\141\156\040\103\157\056
+\054\040\114\164\144\056\061\035\060\033\006\003\125\004\003\023
+\024\123\145\143\165\162\145\123\151\147\156\040\122\157\157\164
+\040\103\101\061\062\060\036\027\015\062\060\060\064\060\070\060
+\065\063\066\064\066\132\027\015\064\060\060\064\060\070\060\065
+\063\066\064\066\132\060\121\061\013\060\011\006\003\125\004\006
+\023\002\112\120\061\043\060\041\006\003\125\004\012\023\032\103
+\171\142\145\162\164\162\165\163\164\040\112\141\160\141\156\040
+\103\157\056\054\040\114\164\144\056\061\035\060\033\006\003\125
+\004\003\023\024\123\145\143\165\162\145\123\151\147\156\040\122
+\157\157\164\040\103\101\061\062\060\202\001\042\060\015\006\011
+\052\206\110\206\367\015\001\001\001\005\000\003\202\001\017\000
+\060\202\001\012\002\202\001\001\000\272\071\301\067\172\150\105
+\053\024\264\353\344\023\353\127\165\043\115\217\044\055\026\350
+\256\216\311\175\244\127\073\052\166\045\063\203\154\352\062\212
+\224\233\116\074\226\344\375\121\277\231\311\223\176\277\371\255
+\247\262\110\053\007\034\047\365\114\274\160\022\167\244\205\124
+\265\375\220\172\344\243\344\121\130\003\315\020\171\171\356\153
+\223\037\144\216\153\144\253\243\023\343\161\376\175\253\234\335
+\047\123\067\263\252\030\302\131\046\354\133\037\322\346\145\174
+\357\223\275\330\130\134\013\300\343\145\157\074\307\312\131\343
+\376\156\137\254\203\276\375\135\045\116\052\051\073\326\013\253
+\027\062\170\244\341\076\224\106\276\142\156\233\336\106\250\261
+\026\347\205\156\364\010\100\105\021\240\236\124\104\204\367\330
+\066\316\365\120\107\334\054\060\233\356\300\365\226\322\376\011
+\206\307\006\131\256\117\256\216\021\230\173\363\013\122\252\142
+\046\252\041\337\216\045\063\171\227\026\111\215\365\076\325\107
+\237\067\061\111\063\162\005\115\014\266\125\214\361\127\217\212
+\207\321\255\305\021\022\071\240\255\002\003\001\000\001\243\102
+\060\100\060\017\006\003\125\035\023\001\001\377\004\005\060\003
+\001\001\377\060\016\006\003\125\035\017\001\001\377\004\004\003
+\002\001\006\060\035\006\003\125\035\016\004\026\004\024\127\064
+\363\164\317\004\113\325\045\346\361\100\266\054\114\331\055\351
+\240\255\060\015\006\011\052\206\110\206\367\015\001\001\013\005
+\000\003\202\001\001\000\076\273\333\027\026\322\362\024\001\040
+\054\070\203\113\255\276\312\205\172\232\266\233\153\246\341\374
+\245\072\254\255\264\050\072\257\327\001\203\111\053\143\242\335
+\232\144\016\230\134\157\335\216\273\212\124\042\055\112\023\363
+\256\100\103\333\117\221\267\206\032\354\000\264\101\201\244\117
+\372\152\213\210\263\166\010\162\052\111\100\303\323\303\205\211
+\230\020\245\235\157\031\267\273\317\172\145\125\333\067\353\074
+\212\162\062\227\036\232\051\076\255\215\346\243\033\155\365\165
+\032\346\260\150\271\133\242\356\151\107\047\065\241\206\231\200
+\363\063\113\341\153\244\046\303\357\164\131\154\172\242\144\266
+\036\104\303\120\340\017\071\075\251\063\361\245\363\322\275\142
+\204\254\216\034\251\315\132\275\067\073\156\012\042\264\364\025
+\347\221\130\305\072\104\323\225\050\331\300\145\351\162\312\320
+\017\275\037\263\025\331\251\343\244\107\011\236\340\313\067\373
+\375\275\227\325\276\030\032\151\242\071\201\331\032\365\253\177
+\310\343\342\147\013\235\364\014\352\124\337\322\262\257\261\042
+\361\040\337\274\104\034
+END
+CKA_NSS_MOZILLA_CA_POLICY CK_BBOOL CK_TRUE
+CKA_NSS_SERVER_DISTRUST_AFTER CK_BBOOL CK_FALSE
+CKA_NSS_EMAIL_DISTRUST_AFTER CK_BBOOL CK_FALSE
+
+# Trust for "SecureSign Root CA12"
+# Issuer: CN=SecureSign Root CA12,O="Cybertrust Japan Co., Ltd.",C=JP
+# Serial Number:66:f9:c7:c1:af:ec:c2:51:b4:ed:53:97:e6:e6:82:c3:2b:1c:90:16
+# Subject: CN=SecureSign Root CA12,O="Cybertrust Japan Co., Ltd.",C=JP
+# Not Valid Before: Wed Apr 08 05:36:46 2020
+# Not Valid After : Sun Apr 08 05:36:46 2040
+# Fingerprint (SHA-256): 3F:03:4B:B5:70:4D:44:B2:D0:85:45:A0:20:57:DE:93:EB:F3:90:5F:CE:72:1A:CB:C7:30:C0:6D:DA:EE:90:4E
+# Fingerprint (SHA1): 7A:22:1E:3D:DE:1B:06:AC:9E:C8:47:70:16:8E:3C:E5:F7:6B:06:F4
+CKA_CLASS CK_OBJECT_CLASS CKO_NSS_TRUST
+CKA_TOKEN CK_BBOOL CK_TRUE
+CKA_PRIVATE CK_BBOOL CK_FALSE
+CKA_MODIFIABLE CK_BBOOL CK_FALSE
+CKA_LABEL UTF8 "SecureSign Root CA12"
+CKA_CERT_SHA1_HASH MULTILINE_OCTAL
+\172\042\036\075\336\033\006\254\236\310\107\160\026\216\074\345
+\367\153\006\364
+END
+CKA_CERT_MD5_HASH MULTILINE_OCTAL
+\306\211\312\144\102\233\142\010\111\013\036\177\351\007\075\350
+END
+CKA_ISSUER MULTILINE_OCTAL
+\060\121\061\013\060\011\006\003\125\004\006\023\002\112\120\061
+\043\060\041\006\003\125\004\012\023\032\103\171\142\145\162\164
+\162\165\163\164\040\112\141\160\141\156\040\103\157\056\054\040
+\114\164\144\056\061\035\060\033\006\003\125\004\003\023\024\123
+\145\143\165\162\145\123\151\147\156\040\122\157\157\164\040\103
+\101\061\062
+END
+CKA_SERIAL_NUMBER MULTILINE_OCTAL
+\002\024\146\371\307\301\257\354\302\121\264\355\123\227\346\346
+\202\303\053\034\220\026
+END
+CKA_TRUST_SERVER_AUTH CK_TRUST CKT_NSS_TRUSTED_DELEGATOR
+CKA_TRUST_EMAIL_PROTECTION CK_TRUST CKT_NSS_MUST_VERIFY_TRUST
+CKA_TRUST_CODE_SIGNING CK_TRUST CKT_NSS_MUST_VERIFY_TRUST
+CKA_TRUST_STEP_UP_APPROVED CK_BBOOL CK_FALSE
+
+#
+# Certificate "SecureSign Root CA14"
+#
+# Issuer: CN=SecureSign Root CA14,O="Cybertrust Japan Co., Ltd.",C=JP
+# Serial Number:64:db:5a:0c:20:4e:e8:d7:29:77:c8:50:27:a2:5a:27:dd:2d:f2:cb
+# Subject: CN=SecureSign Root CA14,O="Cybertrust Japan Co., Ltd.",C=JP
+# Not Valid Before: Wed Apr 08 07:06:19 2020
+# Not Valid After : Sat Apr 08 07:06:19 2045
+# Fingerprint (SHA-256): 4B:00:9C:10:34:49:4F:9A:B5:6B:BA:3B:A1:D6:27:31:FC:4D:20:D8:95:5A:DC:EC:10:A9:25:60:72:61:E3:38
+# Fingerprint (SHA1): DD:50:C0:F7:79:B3:64:2E:74:A2:B8:9D:9F:D3:40:DD:BB:F0:F2:4F
+CKA_CLASS CK_OBJECT_CLASS CKO_CERTIFICATE
+CKA_TOKEN CK_BBOOL CK_TRUE
+CKA_PRIVATE CK_BBOOL CK_FALSE
+CKA_MODIFIABLE CK_BBOOL CK_FALSE
+CKA_LABEL UTF8 "SecureSign Root CA14"
+CKA_CERTIFICATE_TYPE CK_CERTIFICATE_TYPE CKC_X_509
+CKA_SUBJECT MULTILINE_OCTAL
+\060\121\061\013\060\011\006\003\125\004\006\023\002\112\120\061
+\043\060\041\006\003\125\004\012\023\032\103\171\142\145\162\164
+\162\165\163\164\040\112\141\160\141\156\040\103\157\056\054\040
+\114\164\144\056\061\035\060\033\006\003\125\004\003\023\024\123
+\145\143\165\162\145\123\151\147\156\040\122\157\157\164\040\103
+\101\061\064
+END
+CKA_ID UTF8 "0"
+CKA_ISSUER MULTILINE_OCTAL
+\060\121\061\013\060\011\006\003\125\004\006\023\002\112\120\061
+\043\060\041\006\003\125\004\012\023\032\103\171\142\145\162\164
+\162\165\163\164\040\112\141\160\141\156\040\103\157\056\054\040
+\114\164\144\056\061\035\060\033\006\003\125\004\003\023\024\123
+\145\143\165\162\145\123\151\147\156\040\122\157\157\164\040\103
+\101\061\064
+END
+CKA_SERIAL_NUMBER MULTILINE_OCTAL
+\002\024\144\333\132\014\040\116\350\327\051\167\310\120\047\242
+\132\047\335\055\362\313
+END
+CKA_VALUE MULTILINE_OCTAL
+\060\202\005\162\060\202\003\132\240\003\002\001\002\002\024\144
+\333\132\014\040\116\350\327\051\167\310\120\047\242\132\047\335
+\055\362\313\060\015\006\011\052\206\110\206\367\015\001\001\014
+\005\000\060\121\061\013\060\011\006\003\125\004\006\023\002\112
+\120\061\043\060\041\006\003\125\004\012\023\032\103\171\142\145
+\162\164\162\165\163\164\040\112\141\160\141\156\040\103\157\056
+\054\040\114\164\144\056\061\035\060\033\006\003\125\004\003\023
+\024\123\145\143\165\162\145\123\151\147\156\040\122\157\157\164
+\040\103\101\061\064\060\036\027\015\062\060\060\064\060\070\060
+\067\060\066\061\071\132\027\015\064\065\060\064\060\070\060\067
+\060\066\061\071\132\060\121\061\013\060\011\006\003\125\004\006
+\023\002\112\120\061\043\060\041\006\003\125\004\012\023\032\103
+\171\142\145\162\164\162\165\163\164\040\112\141\160\141\156\040
+\103\157\056\054\040\114\164\144\056\061\035\060\033\006\003\125
+\004\003\023\024\123\145\143\165\162\145\123\151\147\156\040\122
+\157\157\164\040\103\101\061\064\060\202\002\042\060\015\006\011
+\052\206\110\206\367\015\001\001\001\005\000\003\202\002\017\000
+\060\202\002\012\002\202\002\001\000\305\322\172\241\326\212\277
+\026\061\320\230\321\072\224\374\132\270\156\042\301\142\367\247
+\012\047\357\120\366\056\261\236\150\022\360\154\044\143\071\361
+\360\337\020\306\336\267\122\040\325\122\133\102\231\236\363\240
+\276\122\037\137\314\147\155\247\056\120\242\301\227\215\266\370
+\225\365\260\272\334\235\340\276\313\337\367\070\362\107\365\246
+\232\222\225\052\142\131\120\013\242\261\065\347\145\262\141\262
+\352\222\161\151\344\051\360\117\201\201\004\074\262\245\133\324
+\305\250\131\147\173\125\034\111\253\172\235\302\347\163\115\357
+\315\011\302\304\127\022\333\001\016\043\171\011\007\073\242\350
+\374\212\317\217\300\106\044\234\070\047\340\203\235\033\240\277
+\170\025\020\353\206\116\012\132\375\337\332\054\202\176\356\312
+\366\051\341\372\161\241\367\210\150\234\234\360\215\276\017\111
+\221\330\352\072\371\375\320\150\161\333\351\265\053\116\202\222
+\157\146\037\340\360\334\114\354\312\321\352\272\164\006\371\263
+\204\220\224\321\137\216\163\031\020\135\002\345\160\245\300\020
+\320\020\174\157\305\130\111\264\260\156\232\332\175\225\365\314
+\332\002\257\270\054\175\171\217\276\103\361\371\050\050\215\011
+\103\370\010\335\153\310\213\054\044\261\215\122\007\275\170\233
+\313\312\150\262\244\335\014\114\171\140\306\231\321\223\361\060
+\032\007\323\256\042\302\352\316\361\204\011\314\340\024\156\177
+\077\176\322\202\205\254\334\251\026\116\205\240\140\313\366\234
+\327\310\263\216\355\306\233\230\165\015\125\350\137\345\225\213
+\002\244\256\103\051\050\021\244\346\022\060\001\113\165\153\036
+\146\235\171\057\245\166\057\035\100\264\155\311\175\171\010\354
+\321\152\266\135\052\262\245\146\275\153\205\364\164\126\303\365
+\347\165\122\050\054\245\377\146\107\245\324\376\376\236\124\277
+\145\176\001\326\060\217\245\066\234\242\120\034\356\070\200\001
+\110\306\307\164\364\306\254\303\100\111\026\141\164\054\257\214
+\157\065\355\173\030\000\133\066\074\234\120\015\312\222\063\020
+\361\046\111\155\337\165\044\067\202\042\327\350\226\375\025\113
+\002\226\076\007\162\225\176\253\075\114\056\327\312\360\337\340
+\130\077\055\057\004\232\070\243\001\002\003\001\000\001\243\102
+\060\100\060\017\006\003\125\035\023\001\001\377\004\005\060\003
+\001\001\377\060\016\006\003\125\035\017\001\001\377\004\004\003
+\002\001\006\060\035\006\003\125\035\016\004\026\004\024\006\223
+\243\012\136\050\151\067\252\141\035\353\353\374\055\157\043\344
+\363\240\060\015\006\011\052\206\110\206\367\015\001\001\014\005
+\000\003\202\002\001\000\226\200\162\011\006\176\234\314\223\004
+\026\273\240\072\215\222\116\267\021\032\012\161\161\020\315\004
+\255\177\245\105\120\020\146\116\112\101\242\003\331\021\117\172
+\067\271\113\342\306\217\062\146\165\045\373\353\316\077\003\051
+\046\215\270\026\035\366\037\063\156\110\346\350\370\127\262\033
+\171\337\073\207\012\342\144\272\000\312\154\357\176\320\043\353
+\170\217\377\144\233\064\067\237\065\145\242\244\000\075\022\043
+\226\130\135\312\143\207\306\243\007\210\115\347\151\166\212\123
+\315\361\117\354\102\362\223\343\231\244\067\074\207\270\142\333
+\360\354\037\067\077\067\137\103\314\121\235\265\360\227\302\267
+\205\152\150\013\104\036\345\121\356\223\316\113\156\206\301\322
+\014\044\131\066\032\237\054\221\217\343\030\333\224\225\012\355
+\221\252\016\231\334\226\123\343\141\203\306\026\272\043\272\334
+\335\176\032\306\173\102\266\331\132\005\334\232\137\325\337\270
+\332\107\175\332\070\333\254\071\325\036\153\154\052\027\214\141
+\315\261\155\162\001\303\303\040\000\142\150\026\061\325\166\252
+\206\273\016\252\236\306\371\360\331\370\015\041\002\344\305\050
+\026\131\021\271\331\151\163\052\222\170\270\222\127\233\010\362
+\072\345\057\225\260\130\267\153\040\024\155\024\357\012\274\176
+\330\125\330\210\332\057\372\031\245\373\213\340\177\071\365\162
+\053\205\304\054\254\357\031\105\222\114\263\141\007\334\115\037
+\156\322\201\023\134\232\363\022\147\203\317\233\077\213\237\235
+\244\271\250\226\003\172\305\356\040\336\063\332\057\236\032\172
+\164\036\341\356\314\132\072\004\335\263\032\004\250\024\143\254
+\267\107\022\203\232\154\365\346\351\025\025\221\032\204\031\016
+\224\104\347\022\216\045\133\200\147\031\334\143\223\020\013\145
+\056\212\372\011\232\116\332\206\050\175\252\141\065\330\016\247
+\050\032\273\122\340\170\370\154\272\154\260\156\271\207\136\351
+\231\065\067\361\075\144\053\251\240\064\223\317\143\057\325\201
+\337\256\143\047\245\036\116\215\334\051\170\131\370\371\241\040
+\214\247\046\100\156\202\162\315\170\262\310\217\074\036\163\347
+\301\037\277\317\316\245\052\233\333\104\144\062\240\273\177\134
+\045\023\110\265\177\222
+END
+CKA_NSS_MOZILLA_CA_POLICY CK_BBOOL CK_TRUE
+CKA_NSS_SERVER_DISTRUST_AFTER CK_BBOOL CK_FALSE
+CKA_NSS_EMAIL_DISTRUST_AFTER CK_BBOOL CK_FALSE
+
+# Trust for "SecureSign Root CA14"
+# Issuer: CN=SecureSign Root CA14,O="Cybertrust Japan Co., Ltd.",C=JP
+# Serial Number:64:db:5a:0c:20:4e:e8:d7:29:77:c8:50:27:a2:5a:27:dd:2d:f2:cb
+# Subject: CN=SecureSign Root CA14,O="Cybertrust Japan Co., Ltd.",C=JP
+# Not Valid Before: Wed Apr 08 07:06:19 2020
+# Not Valid After : Sat Apr 08 07:06:19 2045
+# Fingerprint (SHA-256): 4B:00:9C:10:34:49:4F:9A:B5:6B:BA:3B:A1:D6:27:31:FC:4D:20:D8:95:5A:DC:EC:10:A9:25:60:72:61:E3:38
+# Fingerprint (SHA1): DD:50:C0:F7:79:B3:64:2E:74:A2:B8:9D:9F:D3:40:DD:BB:F0:F2:4F
+CKA_CLASS CK_OBJECT_CLASS CKO_NSS_TRUST
+CKA_TOKEN CK_BBOOL CK_TRUE
+CKA_PRIVATE CK_BBOOL CK_FALSE
+CKA_MODIFIABLE CK_BBOOL CK_FALSE
+CKA_LABEL UTF8 "SecureSign Root CA14"
+CKA_CERT_SHA1_HASH MULTILINE_OCTAL
+\335\120\300\367\171\263\144\056\164\242\270\235\237\323\100\335
+\273\360\362\117
+END
+CKA_CERT_MD5_HASH MULTILINE_OCTAL
+\161\015\162\372\222\031\145\136\211\004\254\026\063\360\274\325
+END
+CKA_ISSUER MULTILINE_OCTAL
+\060\121\061\013\060\011\006\003\125\004\006\023\002\112\120\061
+\043\060\041\006\003\125\004\012\023\032\103\171\142\145\162\164
+\162\165\163\164\040\112\141\160\141\156\040\103\157\056\054\040
+\114\164\144\056\061\035\060\033\006\003\125\004\003\023\024\123
+\145\143\165\162\145\123\151\147\156\040\122\157\157\164\040\103
+\101\061\064
+END
+CKA_SERIAL_NUMBER MULTILINE_OCTAL
+\002\024\144\333\132\014\040\116\350\327\051\167\310\120\047\242
+\132\047\335\055\362\313
+END
+CKA_TRUST_SERVER_AUTH CK_TRUST CKT_NSS_TRUSTED_DELEGATOR
+CKA_TRUST_EMAIL_PROTECTION CK_TRUST CKT_NSS_MUST_VERIFY_TRUST
+CKA_TRUST_CODE_SIGNING CK_TRUST CKT_NSS_MUST_VERIFY_TRUST
+CKA_TRUST_STEP_UP_APPROVED CK_BBOOL CK_FALSE
+
+#
+# Certificate "SecureSign Root CA15"
+#
+# Issuer: CN=SecureSign Root CA15,O="Cybertrust Japan Co., Ltd.",C=JP
+# Serial Number:16:15:c7:c3:d8:49:a7:be:69:0c:8a:88:ed:f0:70:f9:dd:b7:3e:87
+# Subject: CN=SecureSign Root CA15,O="Cybertrust Japan Co., Ltd.",C=JP
+# Not Valid Before: Wed Apr 08 08:32:56 2020
+# Not Valid After : Sat Apr 08 08:32:56 2045
+# Fingerprint (SHA-256): E7:78:F0:F0:95:FE:84:37:29:CD:1A:00:82:17:9E:53:14:A9:C2:91:44:28:05:E1:FB:1D:8F:B6:B8:88:6C:3A
+# Fingerprint (SHA1): CB:BA:83:C8:C1:5A:5D:F1:F9:73:6F:CA:D7:EF:28:13:06:4A:07:7D
+CKA_CLASS CK_OBJECT_CLASS CKO_CERTIFICATE
+CKA_TOKEN CK_BBOOL CK_TRUE
+CKA_PRIVATE CK_BBOOL CK_FALSE
+CKA_MODIFIABLE CK_BBOOL CK_FALSE
+CKA_LABEL UTF8 "SecureSign Root CA15"
+CKA_CERTIFICATE_TYPE CK_CERTIFICATE_TYPE CKC_X_509
+CKA_SUBJECT MULTILINE_OCTAL
+\060\121\061\013\060\011\006\003\125\004\006\023\002\112\120\061
+\043\060\041\006\003\125\004\012\023\032\103\171\142\145\162\164
+\162\165\163\164\040\112\141\160\141\156\040\103\157\056\054\040
+\114\164\144\056\061\035\060\033\006\003\125\004\003\023\024\123
+\145\143\165\162\145\123\151\147\156\040\122\157\157\164\040\103
+\101\061\065
+END
+CKA_ID UTF8 "0"
+CKA_ISSUER MULTILINE_OCTAL
+\060\121\061\013\060\011\006\003\125\004\006\023\002\112\120\061
+\043\060\041\006\003\125\004\012\023\032\103\171\142\145\162\164
+\162\165\163\164\040\112\141\160\141\156\040\103\157\056\054\040
+\114\164\144\056\061\035\060\033\006\003\125\004\003\023\024\123
+\145\143\165\162\145\123\151\147\156\040\122\157\157\164\040\103
+\101\061\065
+END
+CKA_SERIAL_NUMBER MULTILINE_OCTAL
+\002\024\026\025\307\303\330\111\247\276\151\014\212\210\355\360
+\160\371\335\267\076\207
+END
+CKA_VALUE MULTILINE_OCTAL
+\060\202\002\043\060\202\001\251\240\003\002\001\002\002\024\026
+\025\307\303\330\111\247\276\151\014\212\210\355\360\160\371\335
+\267\076\207\060\012\006\010\052\206\110\316\075\004\003\003\060
+\121\061\013\060\011\006\003\125\004\006\023\002\112\120\061\043
+\060\041\006\003\125\004\012\023\032\103\171\142\145\162\164\162
+\165\163\164\040\112\141\160\141\156\040\103\157\056\054\040\114
+\164\144\056\061\035\060\033\006\003\125\004\003\023\024\123\145
+\143\165\162\145\123\151\147\156\040\122\157\157\164\040\103\101
+\061\065\060\036\027\015\062\060\060\064\060\070\060\070\063\062
+\065\066\132\027\015\064\065\060\064\060\070\060\070\063\062\065
+\066\132\060\121\061\013\060\011\006\003\125\004\006\023\002\112
+\120\061\043\060\041\006\003\125\004\012\023\032\103\171\142\145
+\162\164\162\165\163\164\040\112\141\160\141\156\040\103\157\056
+\054\040\114\164\144\056\061\035\060\033\006\003\125\004\003\023
+\024\123\145\143\165\162\145\123\151\147\156\040\122\157\157\164
+\040\103\101\061\065\060\166\060\020\006\007\052\206\110\316\075
+\002\001\006\005\053\201\004\000\042\003\142\000\004\013\120\164
+\215\144\062\231\231\263\322\140\010\270\042\216\106\164\054\170
+\300\053\104\055\155\137\035\311\256\113\122\040\203\075\270\024
+\155\123\207\140\236\137\154\205\333\006\024\225\340\307\050\377
+\235\137\344\252\361\263\213\155\355\117\057\113\311\112\224\221
+\144\165\376\001\354\301\330\353\172\224\170\126\030\103\137\153
+\201\313\366\274\332\264\014\266\051\223\010\151\217\243\102\060
+\100\060\017\006\003\125\035\023\001\001\377\004\005\060\003\001
+\001\377\060\016\006\003\125\035\017\001\001\377\004\004\003\002
+\001\006\060\035\006\003\125\035\016\004\026\004\024\353\101\310
+\256\374\325\236\121\110\365\275\213\364\207\040\223\101\053\323
+\364\060\012\006\010\052\206\110\316\075\004\003\003\003\150\000
+\060\145\002\061\000\331\056\211\176\136\116\244\021\007\275\131
+\302\007\336\253\062\070\123\052\106\104\006\027\172\316\121\351
+\340\377\146\055\011\116\340\117\364\005\321\205\366\065\140\334
+\365\162\263\106\175\002\060\104\230\106\032\202\205\036\141\151
+\211\113\007\113\146\265\236\252\272\240\036\101\331\001\164\072
+\156\105\072\211\200\031\173\062\230\125\143\253\353\143\156\223
+\155\253\033\011\140\061\116
+END
+CKA_NSS_MOZILLA_CA_POLICY CK_BBOOL CK_TRUE
+CKA_NSS_SERVER_DISTRUST_AFTER CK_BBOOL CK_FALSE
+CKA_NSS_EMAIL_DISTRUST_AFTER CK_BBOOL CK_FALSE
+
+# Trust for "SecureSign Root CA15"
+# Issuer: CN=SecureSign Root CA15,O="Cybertrust Japan Co., Ltd.",C=JP
+# Serial Number:16:15:c7:c3:d8:49:a7:be:69:0c:8a:88:ed:f0:70:f9:dd:b7:3e:87
+# Subject: CN=SecureSign Root CA15,O="Cybertrust Japan Co., Ltd.",C=JP
+# Not Valid Before: Wed Apr 08 08:32:56 2020
+# Not Valid After : Sat Apr 08 08:32:56 2045
+# Fingerprint (SHA-256): E7:78:F0:F0:95:FE:84:37:29:CD:1A:00:82:17:9E:53:14:A9:C2:91:44:28:05:E1:FB:1D:8F:B6:B8:88:6C:3A
+# Fingerprint (SHA1): CB:BA:83:C8:C1:5A:5D:F1:F9:73:6F:CA:D7:EF:28:13:06:4A:07:7D
+CKA_CLASS CK_OBJECT_CLASS CKO_NSS_TRUST
+CKA_TOKEN CK_BBOOL CK_TRUE
+CKA_PRIVATE CK_BBOOL CK_FALSE
+CKA_MODIFIABLE CK_BBOOL CK_FALSE
+CKA_LABEL UTF8 "SecureSign Root CA15"
+CKA_CERT_SHA1_HASH MULTILINE_OCTAL
+\313\272\203\310\301\132\135\361\371\163\157\312\327\357\050\023
+\006\112\007\175
+END
+CKA_CERT_MD5_HASH MULTILINE_OCTAL
+\023\060\374\304\142\246\251\336\265\301\150\257\265\322\061\107
+END
+CKA_ISSUER MULTILINE_OCTAL
+\060\121\061\013\060\011\006\003\125\004\006\023\002\112\120\061
+\043\060\041\006\003\125\004\012\023\032\103\171\142\145\162\164
+\162\165\163\164\040\112\141\160\141\156\040\103\157\056\054\040
+\114\164\144\056\061\035\060\033\006\003\125\004\003\023\024\123
+\145\143\165\162\145\123\151\147\156\040\122\157\157\164\040\103
+\101\061\065
+END
+CKA_SERIAL_NUMBER MULTILINE_OCTAL
+\002\024\026\025\307\303\330\111\247\276\151\014\212\210\355\360
+\160\371\335\267\076\207
+END
+CKA_TRUST_SERVER_AUTH CK_TRUST CKT_NSS_TRUSTED_DELEGATOR
+CKA_TRUST_EMAIL_PROTECTION CK_TRUST CKT_NSS_MUST_VERIFY_TRUST
+CKA_TRUST_CODE_SIGNING CK_TRUST CKT_NSS_MUST_VERIFY_TRUST
+CKA_TRUST_STEP_UP_APPROVED CK_BBOOL CK_FALSE
diff --git a/packages/bun-usockets/generate-root-certs.mjs b/packages/bun-usockets/generate-root-certs.mjs
index ecb601d3fe..8c2af0df8b 100644
--- a/packages/bun-usockets/generate-root-certs.mjs
+++ b/packages/bun-usockets/generate-root-certs.mjs
@@ -18,8 +18,7 @@ const __filename = fileURLToPath(import.meta.url);
 const now = new Date();
 
 const formatDate = d => {
-  const iso = d.toISOString();
-  return iso.substring(0, iso.indexOf("T"));
+  return d;
 };
 
 const getCertdataURL = version => {
@@ -146,26 +145,35 @@ if (values.help) {
   process.exit(0);
 }
 
-const scheduleURL = "https://wiki.mozilla.org/NSS:Release_Versions";
-if (values.verbose) {
-  console.log(`Fetching NSS release schedule from ${scheduleURL}`);
-}
-const schedule = await fetch(scheduleURL);
-if (!schedule.ok) {
-  console.error(`Failed to fetch ${scheduleURL}: ${schedule.status}: ${schedule.statusText}`);
-  process.exit(-1);
-}
-const scheduleText = await schedule.text();
-const nssReleases = getReleases(scheduleText);
+const versions = await fetch("https://nucleus.mozilla.org/rna/all-releases.json").then(res => res.json());
 
-// Retrieve metadata for the NSS release being updated to.
-const version = positionals[0] ?? (await getLatestVersion(nssReleases));
-const release = nssReleases.find(r => {
-  return new RegExp(`^${version.replace(".", "\\.")}\\b`).test(r[kNSSVersion]);
-});
-if (!pastRelease(release)) {
-  console.warn(`Warning: NSS ${version} is not due to be released until ${formatDate(release[kNSSDate])}`);
+const today = new Date().toISOString().split("T")[0].trim();
+const releases = versions
+  .filter(
+    version =>
+      version.channel == "Release" &&
+      version.product === "Firefox" &&
+      version.is_public &&
+      version.release_date <= today,
+  )
+  .sort((a, b) => (a > b ? (a == b ? 0 : -1) : 1));
+const latest = releases[0];
+const release_tag = `FIREFOX_${latest.version.replaceAll(".", "_")}_RELEASE`;
+if (values.verbose) {
+  console.log(`Fetching NSS release from ${release_tag}`);
 }
+const version = await fetch(
+  `https://hg.mozilla.org/releases/mozilla-release/raw-file/${release_tag}/security/nss/TAG-INFO`,
+)
+  .then(res => res.text())
+  .then(txt => txt.trim().split("NSS_")[1].split("_RTM").join("").split("_").join(".").trim());
+
+const release = {
+  version: version,
+  firefoxVersion: latest.version,
+  firefoxDate: latest.release_date,
+  date: latest.release_date,
+};
 if (values.verbose) {
   console.log("Found NSS version:");
   console.log(release);
diff --git a/packages/bun-usockets/src/bsd.c b/packages/bun-usockets/src/bsd.c
index 351bc262e9..fbf36dd525 100644
--- a/packages/bun-usockets/src/bsd.c
+++ b/packages/bun-usockets/src/bsd.c
@@ -318,6 +318,74 @@ void bsd_socket_nodelay(LIBUS_SOCKET_DESCRIPTOR fd, int enabled) {
     setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (void *) &enabled, sizeof(enabled));
 }
 
+int bsd_socket_keepalive(LIBUS_SOCKET_DESCRIPTOR fd, int on, unsigned int delay) {
+
+#ifndef _WIN32
+    if(setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &on, sizeof(on))) {
+        return errno;
+    }
+
+    if (!on)
+        return 0;
+
+    if (delay == 0)
+        return -1;
+
+
+#ifdef TCP_KEEPIDLE
+  if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, &delay, sizeof(delay)))
+    return errno;
+#elif defined(TCP_KEEPALIVE)
+  /* Darwin/macOS uses TCP_KEEPALIVE in place of TCP_KEEPIDLE. */
+  if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPALIVE, &delay, sizeof(delay)))
+    return errno;
+#endif
+
+#ifdef TCP_KEEPINTVL
+  int intvl = 1;  /*  1 second; same as default on Win32 */
+  if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPINTVL, &intvl, sizeof(intvl)))
+    return errno;
+#endif
+
+#ifdef TCP_KEEPCNT
+  int cnt = 10;  /* 10 retries; same as hardcoded on Win32 */
+  if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPCNT, &cnt, sizeof(cnt)))
+    return errno;
+#endif
+
+    return 0;
+    #else
+    if (setsockopt(fd,
+                    SOL_SOCKET,
+                    SO_KEEPALIVE,
+                    (const char*)&on,
+                    sizeof on) == -1) {
+        return WSAGetLastError();
+    }
+
+    if (!on)
+        return 0;
+
+    if (delay < 1) {
+        #ifdef LIBUS_USE_LIBUV
+            return -4071; //UV_EINVAL;
+        #else
+            //TODO: revisit this when IOCP loop is implemented without libuv here
+            return 4071;
+        #endif
+    }
+    if (setsockopt(fd,
+                    IPPROTO_TCP,
+                    TCP_KEEPALIVE,
+                    (const char*)&delay,
+                    sizeof delay) == -1) {
+        return WSAGetLastError();
+    }
+
+    return 0;
+    #endif
+}
+
 void bsd_socket_flush(LIBUS_SOCKET_DESCRIPTOR fd) {
     // Linux TCP_CORK has the same underlying corking mechanism as with MSG_MORE
 #ifdef TCP_CORK
@@ -522,19 +590,21 @@ int bsd_would_block() {
 #endif
 }
 
-static int us_internal_bind_and_listen(LIBUS_SOCKET_DESCRIPTOR listenFd, struct sockaddr *listenAddr, socklen_t listenAddrLength, int backlog) {
+static int us_internal_bind_and_listen(LIBUS_SOCKET_DESCRIPTOR listenFd, struct sockaddr *listenAddr, socklen_t listenAddrLength, int backlog, int* error) {
     int result;
     do 
         result = bind(listenFd, listenAddr, listenAddrLength);
     while (IS_EINTR(result));
 
     if (result == -1) {
+        *error = LIBUS_ERR;
         return -1;
     }
 
     do 
         result = listen(listenFd, backlog);
     while (IS_EINTR(result));
+    *error = LIBUS_ERR;
 
     return result;
 }
@@ -543,7 +613,8 @@ inline __attribute__((always_inline)) LIBUS_SOCKET_DESCRIPTOR bsd_bind_listen_fd
     LIBUS_SOCKET_DESCRIPTOR listenFd,
     struct addrinfo *listenAddr,
     int port,
-    int options
+    int options,
+    int* error
 ) {
 
      if ((options & LIBUS_LISTEN_EXCLUSIVE_PORT)) {
@@ -552,23 +623,39 @@ inline __attribute__((always_inline)) LIBUS_SOCKET_DESCRIPTOR bsd_bind_listen_fd
         setsockopt(listenFd, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (void *) &optval2, sizeof(optval2));
 #endif
     } else {
-      #if defined(SO_REUSEPORT)
-        int optval2 = 1;
-        setsockopt(listenFd, SOL_SOCKET, SO_REUSEPORT, (void *) &optval2, sizeof(optval2));  
-        #endif
+#if defined(SO_REUSEPORT)
+        if((options & LIBUS_LISTEN_REUSE_PORT)) {
+            int optval2 = 1;
+            setsockopt(listenFd, SOL_SOCKET, SO_REUSEPORT, (void *) &optval2, sizeof(optval2));  
+        }
+#endif
     }
 
 #if defined(SO_REUSEADDR)
+    #ifndef _WIN32
+
+    //  Unlike on Unix, here we don't set SO_REUSEADDR, because it doesn't just
+    //  allow binding to addresses that are in use by sockets in TIME_WAIT, it
+    //  effectively allows 'stealing' a port which is in use by another application.
+    //  See libuv issue #1360.
+    
+    
     int optval3 = 1;
     setsockopt(listenFd, SOL_SOCKET, SO_REUSEADDR, (void *) &optval3, sizeof(optval3));
+    #endif
 #endif
 
 #ifdef IPV6_V6ONLY
+    // TODO: revise support to match node.js
+    // if (listenAddr->ai_family == AF_INET6) {
+    //     int disabled = (options & LIBUS_SOCKET_IPV6_ONLY) != 0;
+    //     setsockopt(listenFd, IPPROTO_IPV6, IPV6_V6ONLY, (void *) &disabled, sizeof(disabled));
+    // }
     int disabled = 0;
     setsockopt(listenFd, IPPROTO_IPV6, IPV6_V6ONLY, (void *) &disabled, sizeof(disabled));
 #endif
 
-    if (us_internal_bind_and_listen(listenFd, listenAddr->ai_addr, (socklen_t) listenAddr->ai_addrlen, 512)) {
+    if (us_internal_bind_and_listen(listenFd, listenAddr->ai_addr, (socklen_t) listenAddr->ai_addrlen, 512, error)) {
         return LIBUS_SOCKET_ERROR;
     }
 
@@ -577,7 +664,7 @@ inline __attribute__((always_inline)) LIBUS_SOCKET_DESCRIPTOR bsd_bind_listen_fd
 
 // return LIBUS_SOCKET_ERROR or the fd that represents listen socket
 // listen both on ipv6 and ipv4
-LIBUS_SOCKET_DESCRIPTOR bsd_create_listen_socket(const char *host, int port, int options) {
+LIBUS_SOCKET_DESCRIPTOR bsd_create_listen_socket(const char *host, int port, int options, int* error) {
     struct addrinfo hints, *result;
     memset(&hints, 0, sizeof(struct addrinfo));
 
@@ -602,7 +689,7 @@ LIBUS_SOCKET_DESCRIPTOR bsd_create_listen_socket(const char *host, int port, int
             }
 
             listenAddr = a;
-            if (bsd_bind_listen_fd(listenFd, listenAddr, port, options) != LIBUS_SOCKET_ERROR) {
+            if (bsd_bind_listen_fd(listenFd, listenAddr, port, options, error) != LIBUS_SOCKET_ERROR) {
                 freeaddrinfo(result);
                 return listenFd;
             }
@@ -619,7 +706,7 @@ LIBUS_SOCKET_DESCRIPTOR bsd_create_listen_socket(const char *host, int port, int
             }
 
             listenAddr = a;
-            if (bsd_bind_listen_fd(listenFd, listenAddr, port, options) != LIBUS_SOCKET_ERROR) {
+            if (bsd_bind_listen_fd(listenFd, listenAddr, port, options, error) != LIBUS_SOCKET_ERROR) {
                 freeaddrinfo(result);
                 return listenFd;
             }
@@ -724,7 +811,7 @@ static LIBUS_SOCKET_DESCRIPTOR bsd_create_unix_socket_address(const char *path,
     return 0;
 }
 
-static LIBUS_SOCKET_DESCRIPTOR internal_bsd_create_listen_socket_unix(const char* path, int options, struct sockaddr_un* server_address, size_t addrlen) {
+static LIBUS_SOCKET_DESCRIPTOR internal_bsd_create_listen_socket_unix(const char* path, int options, struct sockaddr_un* server_address, size_t addrlen, int* error) {
     LIBUS_SOCKET_DESCRIPTOR listenFd = LIBUS_SOCKET_ERROR;
 
     listenFd = bsd_create_socket(AF_UNIX, SOCK_STREAM, 0);
@@ -746,7 +833,7 @@ static LIBUS_SOCKET_DESCRIPTOR internal_bsd_create_listen_socket_unix(const char
     unlink(path);
 #endif
 
-    if (us_internal_bind_and_listen(listenFd, (struct sockaddr *) server_address, (socklen_t) addrlen, 512)) {
+    if (us_internal_bind_and_listen(listenFd, (struct sockaddr *) server_address, (socklen_t) addrlen, 512, error)) {
         #if defined(_WIN32)
           int shouldSimulateENOENT = WSAGetLastError() == WSAENETDOWN;
         #endif
@@ -762,7 +849,7 @@ static LIBUS_SOCKET_DESCRIPTOR internal_bsd_create_listen_socket_unix(const char
     return listenFd;
 }
 
-LIBUS_SOCKET_DESCRIPTOR bsd_create_listen_socket_unix(const char *path, size_t len, int options) {
+LIBUS_SOCKET_DESCRIPTOR bsd_create_listen_socket_unix(const char *path, size_t len, int options, int* error) {
     int dirfd_linux_workaround_for_unix_path_len = -1;
     struct sockaddr_un server_address;
     size_t addrlen = 0;
@@ -770,7 +857,7 @@ LIBUS_SOCKET_DESCRIPTOR bsd_create_listen_socket_unix(const char *path, size_t l
         return LIBUS_SOCKET_ERROR;
     }
 
-    LIBUS_SOCKET_DESCRIPTOR listenFd = internal_bsd_create_listen_socket_unix(path, options, &server_address, addrlen);
+    LIBUS_SOCKET_DESCRIPTOR listenFd = internal_bsd_create_listen_socket_unix(path, options, &server_address, addrlen, error);
 
 #if defined(__linux__)
     if (dirfd_linux_workaround_for_unix_path_len != -1) {
diff --git a/packages/bun-usockets/src/context.c b/packages/bun-usockets/src/context.c
index a59c80e83a..49e8bc3a16 100644
--- a/packages/bun-usockets/src/context.c
+++ b/packages/bun-usockets/src/context.c
@@ -212,12 +212,13 @@ void us_socket_context_add_server_name(int ssl, struct us_socket_context_t *cont
     }
 #endif
 }
-void us_bun_socket_context_add_server_name(int ssl, struct us_socket_context_t *context, const char *hostname_pattern, struct us_bun_socket_context_options_t options, void *user) {
+int us_bun_socket_context_add_server_name(int ssl, struct us_socket_context_t *context, const char *hostname_pattern, struct us_bun_socket_context_options_t options, void *user) {
 #ifndef LIBUS_NO_SSL
     if (ssl) {
-        us_bun_internal_ssl_socket_context_add_server_name((struct us_internal_ssl_socket_context_t *) context, hostname_pattern, options, user);
+        return us_bun_internal_ssl_socket_context_add_server_name((struct us_internal_ssl_socket_context_t *) context, hostname_pattern, options, user);
     }
 #endif
+    return 0;
 }
 
 /* Remove SNI context */
@@ -278,11 +279,11 @@ struct us_socket_context_t *us_create_socket_context(int ssl, struct us_loop_t *
     return context;
 }
 
-struct us_socket_context_t *us_create_bun_socket_context(int ssl, struct us_loop_t *loop, int context_ext_size, struct us_bun_socket_context_options_t options) {
+struct us_socket_context_t *us_create_bun_socket_context(int ssl, struct us_loop_t *loop, int context_ext_size, struct us_bun_socket_context_options_t options, enum create_bun_socket_error_t *err) {
 #ifndef LIBUS_NO_SSL
     if (ssl) {
         /* This function will call us, again, with SSL = false and a bigger ext_size */
-        return (struct us_socket_context_t *) us_internal_bun_create_ssl_socket_context(loop, context_ext_size, options);
+        return (struct us_socket_context_t *) us_internal_bun_create_ssl_socket_context(loop, context_ext_size, options, err);
     }
 #endif
 
@@ -346,14 +347,14 @@ void us_socket_context_free(int ssl, struct us_socket_context_t *context) {
     us_socket_context_unref(ssl, context);
 }
 
-struct us_listen_socket_t *us_socket_context_listen(int ssl, struct us_socket_context_t *context, const char *host, int port, int options, int socket_ext_size) {
+struct us_listen_socket_t *us_socket_context_listen(int ssl, struct us_socket_context_t *context, const char *host, int port, int options, int socket_ext_size, int* error) {
 #ifndef LIBUS_NO_SSL
     if (ssl) {
-        return us_internal_ssl_socket_context_listen((struct us_internal_ssl_socket_context_t *) context, host, port, options, socket_ext_size);
+        return us_internal_ssl_socket_context_listen((struct us_internal_ssl_socket_context_t *) context, host, port, options, socket_ext_size, error);
     }
 #endif
 
-    LIBUS_SOCKET_DESCRIPTOR listen_socket_fd = bsd_create_listen_socket(host, port, options);
+    LIBUS_SOCKET_DESCRIPTOR listen_socket_fd = bsd_create_listen_socket(host, port, options, error);
 
     if (listen_socket_fd == LIBUS_SOCKET_ERROR) {
         return 0;
@@ -370,6 +371,7 @@ struct us_listen_socket_t *us_socket_context_listen(int ssl, struct us_socket_co
     ls->s.long_timeout = 255;
     ls->s.low_prio_state = 0;
     ls->s.next = 0;
+    ls->s.allow_half_open = (options & LIBUS_SOCKET_ALLOW_HALF_OPEN);
     us_internal_socket_context_link_listen_socket(context, ls);
 
     ls->socket_ext_size = socket_ext_size;
@@ -377,14 +379,14 @@ struct us_listen_socket_t *us_socket_context_listen(int ssl, struct us_socket_co
     return ls;
 }
 
-struct us_listen_socket_t *us_socket_context_listen_unix(int ssl, struct us_socket_context_t *context, const char *path, size_t pathlen, int options, int socket_ext_size) {
+struct us_listen_socket_t *us_socket_context_listen_unix(int ssl, struct us_socket_context_t *context, const char *path, size_t pathlen, int options, int socket_ext_size, int* error) {
 #ifndef LIBUS_NO_SSL
     if (ssl) {
-        return us_internal_ssl_socket_context_listen_unix((struct us_internal_ssl_socket_context_t *) context, path, pathlen, options, socket_ext_size);
+        return us_internal_ssl_socket_context_listen_unix((struct us_internal_ssl_socket_context_t *) context, path, pathlen, options, socket_ext_size, error);
     }
 #endif
 
-    LIBUS_SOCKET_DESCRIPTOR listen_socket_fd = bsd_create_listen_socket_unix(path, pathlen, options);
+    LIBUS_SOCKET_DESCRIPTOR listen_socket_fd = bsd_create_listen_socket_unix(path, pathlen, options, error);
 
     if (listen_socket_fd == LIBUS_SOCKET_ERROR) {
         return 0;
@@ -401,6 +403,8 @@ struct us_listen_socket_t *us_socket_context_listen_unix(int ssl, struct us_sock
     ls->s.long_timeout = 255;
     ls->s.low_prio_state = 0;
     ls->s.next = 0;
+    ls->s.allow_half_open = (options & LIBUS_SOCKET_ALLOW_HALF_OPEN);
+
     us_internal_socket_context_link_listen_socket(context, ls);
 
     ls->socket_ext_size = socket_ext_size;
@@ -430,6 +434,8 @@ struct us_socket_t* us_socket_context_connect_resolved_dns(struct us_socket_cont
     socket->long_timeout = 255;
     socket->low_prio_state = 0;
     socket->connect_state = NULL;
+    socket->allow_half_open = (options & LIBUS_SOCKET_ALLOW_HALF_OPEN);
+
     us_internal_socket_context_link_socket(context, socket);
 
     return socket;
@@ -551,6 +557,7 @@ int start_connections(struct us_connecting_socket_t *c, int count) {
         s->timeout = c->timeout;
         s->long_timeout = c->long_timeout;
         s->low_prio_state = 0;
+        s->allow_half_open = (c->options & LIBUS_SOCKET_ALLOW_HALF_OPEN);
         /* Link it into context so that timeout fires properly */
         us_internal_socket_context_link_socket(s->context, s);
 
@@ -726,6 +733,7 @@ struct us_socket_t *us_socket_context_connect_unix(int ssl, struct us_socket_con
     connect_socket->long_timeout = 255;
     connect_socket->low_prio_state = 0;
     connect_socket->connect_state = NULL;
+    connect_socket->allow_half_open = (options & LIBUS_SOCKET_ALLOW_HALF_OPEN);
     us_internal_socket_context_link_socket(context, connect_socket);
 
     return connect_socket;
diff --git a/packages/bun-usockets/src/crypto/openssl.c b/packages/bun-usockets/src/crypto/openssl.c
index 232d5f8ff9..5b22659d34 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)
@@ -768,11 +772,20 @@ create_ssl_context_from_options(struct us_socket_context_options_t options) {
   }
 
   if (options.passphrase) {
+    #ifdef _WIN32
+    /* When freeing the CTX we need to check
+     * SSL_CTX_get_default_passwd_cb_userdata and free it if set */
+    SSL_CTX_set_default_passwd_cb_userdata(ssl_context,
+                                           (void *)_strdup(options.passphrase));
+    SSL_CTX_set_default_passwd_cb(ssl_context, passphrase_cb);
+
+    #else
     /* When freeing the CTX we need to check
      * SSL_CTX_get_default_passwd_cb_userdata and free it if set */
     SSL_CTX_set_default_passwd_cb_userdata(ssl_context,
                                            (void *)strdup(options.passphrase));
     SSL_CTX_set_default_passwd_cb(ssl_context, passphrase_cb);
+    #endif
   }
 
   /* This one most probably do not need the cert_file_name string to be kept
@@ -855,6 +868,11 @@ create_ssl_context_from_options(struct us_socket_context_options_t options) {
     }
   }
 
+  if (ERR_peek_error() != 0) {
+    free_ssl_context(ssl_context);
+    return NULL;
+  }
+
   /* This must be free'd with free_ssl_context, not SSL_CTX_free */
   return ssl_context;
 }
@@ -1104,7 +1122,10 @@ int us_verify_callback(int preverify_ok, X509_STORE_CTX *ctx) {
 }
 
 SSL_CTX *create_ssl_context_from_bun_options(
-    struct us_bun_socket_context_options_t options) {
+    struct us_bun_socket_context_options_t options, 
+    enum create_bun_socket_error_t *err) {
+  ERR_clear_error();
+
   /* Create the context */
   SSL_CTX *ssl_context = SSL_CTX_new(TLS_method());
 
@@ -1127,11 +1148,19 @@ SSL_CTX *create_ssl_context_from_bun_options(
   }
 
   if (options.passphrase) {
+    #ifdef _WIN32
+    /* When freeing the CTX we need to check
+     * SSL_CTX_get_default_passwd_cb_userdata and free it if set */
+    SSL_CTX_set_default_passwd_cb_userdata(ssl_context,
+                                           (void *)_strdup(options.passphrase));
+    SSL_CTX_set_default_passwd_cb(ssl_context, passphrase_cb);
+    #else
     /* When freeing the CTX we need to check
      * SSL_CTX_get_default_passwd_cb_userdata and free it if set */
     SSL_CTX_set_default_passwd_cb_userdata(ssl_context,
                                            (void *)strdup(options.passphrase));
     SSL_CTX_set_default_passwd_cb(ssl_context, passphrase_cb);
+    #endif
   }
 
   /* This one most probably do not need the cert_file_name string to be kept
@@ -1174,6 +1203,7 @@ SSL_CTX *create_ssl_context_from_bun_options(
     STACK_OF(X509_NAME) * ca_list;
     ca_list = SSL_load_client_CA_file(options.ca_file_name);
     if (ca_list == NULL) {
+      *err = CREATE_BUN_SOCKET_ERROR_LOAD_CA_FILE;
       free_ssl_context(ssl_context);
       return NULL;
     }
@@ -1181,6 +1211,7 @@ SSL_CTX *create_ssl_context_from_bun_options(
     SSL_CTX_set_client_CA_list(ssl_context, ca_list);
     if (SSL_CTX_load_verify_locations(ssl_context, options.ca_file_name,
                                       NULL) != 1) {
+      *err = CREATE_BUN_SOCKET_ERROR_INVALID_CA_FILE;
       free_ssl_context(ssl_context);
       return NULL;
     }
@@ -1203,10 +1234,14 @@ SSL_CTX *create_ssl_context_from_bun_options(
       }
 
       if (!add_ca_cert_to_ctx_store(ssl_context, options.ca[i], cert_store)) {
+        *err = CREATE_BUN_SOCKET_ERROR_INVALID_CA;
         free_ssl_context(ssl_context);
         return NULL;
       }
 
+     // It may return spurious errors here.
+    ERR_clear_error();
+
       if (options.reject_unauthorized) {
         SSL_CTX_set_verify(ssl_context,
                            SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
@@ -1332,13 +1367,17 @@ void us_internal_ssl_socket_context_add_server_name(
   }
 }
 
-void us_bun_internal_ssl_socket_context_add_server_name(
+int us_bun_internal_ssl_socket_context_add_server_name(
     struct us_internal_ssl_socket_context_t *context,
     const char *hostname_pattern,
     struct us_bun_socket_context_options_t options, void *user) {
 
   /* Try and construct an SSL_CTX from options */
-  SSL_CTX *ssl_context = create_ssl_context_from_bun_options(options);
+  enum create_bun_socket_error_t err = CREATE_BUN_SOCKET_ERROR_NONE;
+  SSL_CTX *ssl_context = create_ssl_context_from_bun_options(options, &err);
+  if (ssl_context == NULL) {
+    return -1;
+  }
 
   /* Attach the user data to this context */
   if (1 != SSL_CTX_set_ex_data(ssl_context, 0, user)) {
@@ -1346,15 +1385,15 @@ void us_bun_internal_ssl_socket_context_add_server_name(
     printf("CANNOT SET EX DATA!\n");
     abort();
 #endif
+    return -1;
   }
 
-  /* We do not want to hold any nullptr's in our SNI tree */
-  if (ssl_context) {
-    if (sni_add(context->sni, hostname_pattern, ssl_context)) {
-      /* If we already had that name, ignore */
-      free_ssl_context(ssl_context);
-    }
+  if (sni_add(context->sni, hostname_pattern, ssl_context)) {
+    /* If we already had that name, ignore */
+    free_ssl_context(ssl_context);
   }
+
+  return 0;
 }
 
 void us_internal_ssl_socket_context_on_server_name(
@@ -1468,14 +1507,15 @@ struct us_internal_ssl_socket_context_t *us_internal_create_ssl_socket_context(
 struct us_internal_ssl_socket_context_t *
 us_internal_bun_create_ssl_socket_context(
     struct us_loop_t *loop, int context_ext_size,
-    struct us_bun_socket_context_options_t options) {
+    struct us_bun_socket_context_options_t options,
+    enum create_bun_socket_error_t *err) {
   /* If we haven't initialized the loop data yet, do so .
    * This is needed because loop data holds shared OpenSSL data and
    * the function is also responsible for initializing OpenSSL */
   us_internal_init_loop_ssl_data(loop);
 
   /* First of all we try and create the SSL context from options */
-  SSL_CTX *ssl_context = create_ssl_context_from_bun_options(options);
+  SSL_CTX *ssl_context = create_ssl_context_from_bun_options(options, err);
   if (!ssl_context) {
     /* We simply fail early if we cannot even create the OpenSSL context */
     return NULL;
@@ -1487,7 +1527,7 @@ us_internal_bun_create_ssl_socket_context(
       (struct us_internal_ssl_socket_context_t *)us_create_bun_socket_context(
           0, loop,
           sizeof(struct us_internal_ssl_socket_context_t) + context_ext_size,
-          options);
+          options, err);
 
   /* I guess this is the only optional callback */
   context->on_server_name = NULL;
@@ -1533,20 +1573,20 @@ void us_internal_ssl_socket_context_free(
 
 struct us_listen_socket_t *us_internal_ssl_socket_context_listen(
     struct us_internal_ssl_socket_context_t *context, const char *host,
-    int port, int options, int socket_ext_size) {
+    int port, int options, int socket_ext_size, int* error) {
   return us_socket_context_listen(0, &context->sc, host, port, options,
                                   sizeof(struct us_internal_ssl_socket_t) -
                                       sizeof(struct us_socket_t) +
-                                      socket_ext_size);
+                                      socket_ext_size, error);
 }
 
 struct us_listen_socket_t *us_internal_ssl_socket_context_listen_unix(
     struct us_internal_ssl_socket_context_t *context, const char *path,
-    size_t pathlen, int options, int socket_ext_size) {
+    size_t pathlen, int options, int socket_ext_size, int* error) {
   return us_socket_context_listen_unix(0, &context->sc, path, pathlen, options,
                                        sizeof(struct us_internal_ssl_socket_t) -
                                            sizeof(struct us_socket_t) +
-                                           socket_ext_size);
+                                           socket_ext_size, error);
 }
 
 // TODO does this need more changes?
@@ -1567,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)(
@@ -1575,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;
 }
 
@@ -1814,9 +1858,6 @@ ssl_wrapped_context_on_close(struct us_internal_ssl_socket_t *s, int code,
       (struct us_wrapped_socket_context_t *)us_internal_ssl_socket_context_ext(
           context);
 
-  if (wrapped_context->events.on_close) {
-    wrapped_context->events.on_close((struct us_socket_t *)s, code, reason);
-  }
 
   // writting here can cause the context to not be writable anymore but its the
   // user responsability to check for that
@@ -1824,6 +1865,10 @@ ssl_wrapped_context_on_close(struct us_internal_ssl_socket_t *s, int code,
     wrapped_context->old_events.on_close((struct us_socket_t *)s, code, reason);
   }
 
+  if (wrapped_context->events.on_close) {
+    wrapped_context->events.on_close((struct us_socket_t *)s, code, reason);
+  }
+
   us_socket_context_unref(0, wrapped_context->tcp_context);
   return s;
 }
@@ -1836,9 +1881,6 @@ ssl_wrapped_context_on_writable(struct us_internal_ssl_socket_t *s) {
       (struct us_wrapped_socket_context_t *)us_internal_ssl_socket_context_ext(
           context);
 
-  if (wrapped_context->events.on_writable) {
-    wrapped_context->events.on_writable((struct us_socket_t *)s);
-  }
 
   // writting here can cause the context to not be writable anymore but its the
   // user responsability to check for that
@@ -1846,6 +1888,10 @@ ssl_wrapped_context_on_writable(struct us_internal_ssl_socket_t *s) {
     wrapped_context->old_events.on_writable((struct us_socket_t *)s);
   }
 
+  if (wrapped_context->events.on_writable) {
+    wrapped_context->events.on_writable((struct us_socket_t *)s);
+  }
+
   return s;
 }
 
@@ -1872,14 +1918,14 @@ ssl_wrapped_context_on_timeout(struct us_internal_ssl_socket_t *s) {
   struct us_wrapped_socket_context_t *wrapped_context =
       (struct us_wrapped_socket_context_t *)us_internal_ssl_socket_context_ext(
           context);
+  if (wrapped_context->old_events.on_timeout) {
+    wrapped_context->old_events.on_timeout((struct us_socket_t *)s);
+  }
 
   if (wrapped_context->events.on_timeout) {
     wrapped_context->events.on_timeout((struct us_socket_t *)s);
   }
 
-  if (wrapped_context->old_events.on_timeout) {
-    wrapped_context->old_events.on_timeout((struct us_socket_t *)s);
-  }
 
   return s;
 }
@@ -1891,15 +1937,14 @@ ssl_wrapped_context_on_long_timeout(struct us_internal_ssl_socket_t *s) {
   struct us_wrapped_socket_context_t *wrapped_context =
       (struct us_wrapped_socket_context_t *)us_internal_ssl_socket_context_ext(
           context);
+  if (wrapped_context->old_events.on_long_timeout) {
+    wrapped_context->old_events.on_long_timeout((struct us_socket_t *)s);
+  }
 
   if (wrapped_context->events.on_long_timeout) {
     wrapped_context->events.on_long_timeout((struct us_socket_t *)s);
   }
 
-  if (wrapped_context->old_events.on_long_timeout) {
-    wrapped_context->old_events.on_long_timeout((struct us_socket_t *)s);
-  }
-
   return s;
 }
 
@@ -1910,14 +1955,13 @@ ssl_wrapped_context_on_end(struct us_internal_ssl_socket_t *s) {
   struct us_wrapped_socket_context_t *wrapped_context =
       (struct us_wrapped_socket_context_t *)us_internal_ssl_socket_context_ext(
           context);
-
-  if (wrapped_context->events.on_end) {
-    wrapped_context->events.on_end((struct us_socket_t *)s);
-  }
-
   if (wrapped_context->old_events.on_end) {
     wrapped_context->old_events.on_end((struct us_socket_t *)s);
   }
+  if (wrapped_context->events.on_end) {
+    wrapped_context->events.on_end((struct us_socket_t *)s);
+  }
+  
   return s;
 }
 
@@ -1929,13 +1973,13 @@ ssl_wrapped_on_connect_error(struct us_internal_ssl_socket_t *s, int code) {
       (struct us_wrapped_socket_context_t *)us_internal_ssl_socket_context_ext(
           context);
 
+  if (wrapped_context->old_events.on_connect_error) {
+    wrapped_context->old_events.on_connect_error((struct us_connecting_socket_t *)s, code);
+  }
   if (wrapped_context->events.on_connect_error) {
     wrapped_context->events.on_connect_error((struct us_connecting_socket_t *)s, code);
   }
 
-  if (wrapped_context->old_events.on_connect_error) {
-    wrapped_context->old_events.on_connect_error((struct us_connecting_socket_t *)s, code);
-  }
   return s;
 }
 
@@ -1946,14 +1990,14 @@ ssl_wrapped_on_socket_connect_error(struct us_internal_ssl_socket_t *s, int code
   struct us_wrapped_socket_context_t *wrapped_context =
       (struct us_wrapped_socket_context_t *)us_internal_ssl_socket_context_ext(
           context);
-
+  if (wrapped_context->old_events.on_connecting_socket_error) {
+    wrapped_context->old_events.on_connecting_socket_error((struct us_socket_t *)s, code);
+  }
   if (wrapped_context->events.on_connecting_socket_error) {
     wrapped_context->events.on_connecting_socket_error((struct us_socket_t *)s, code);
   }
 
-  if (wrapped_context->old_events.on_connecting_socket_error) {
-    wrapped_context->old_events.on_connecting_socket_error((struct us_socket_t *)s, code);
-  }
+
   return s;
 }
 
@@ -1969,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(
@@ -1983,9 +2050,10 @@ struct us_internal_ssl_socket_t *us_internal_ssl_socket_wrap_with_tls(
   struct us_socket_context_t *old_context = us_socket_context(0, s);
   us_socket_context_ref(0,old_context);
 
+  enum create_bun_socket_error_t err = CREATE_BUN_SOCKET_ERROR_NONE;
   struct us_socket_context_t *context = us_create_bun_socket_context(
       1, old_context->loop, sizeof(struct us_wrapped_socket_context_t),
-      options);
+      options, &err);
   
   // Handle SSL context creation failure
   if (UNLIKELY(!context)) {
@@ -2085,6 +2153,8 @@ us_socket_context_on_socket_connect_error(
   socket->ssl_read_wants_write = 0;
   socket->fatal_error = 0;
   socket->handshake_state = HANDSHAKE_PENDING;
+  // always resume the socket
+  us_socket_resume(1, &socket->s);
   return socket;
 }
 
diff --git a/packages/bun-usockets/src/crypto/root_certs.cpp b/packages/bun-usockets/src/crypto/root_certs.cpp
index 003685714c..f675a0ab16 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 @@ end:
   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/crypto/root_certs.h b/packages/bun-usockets/src/crypto/root_certs.h
index 863fac1f42..f3b09fdaec 100644
--- a/packages/bun-usockets/src/crypto/root_certs.h
+++ b/packages/bun-usockets/src/crypto/root_certs.h
@@ -3614,4 +3614,101 @@ static struct us_cert_string_t root_certs[] = {
 "fKR7w4l1M+E7qUW/Runpod3JIha3RxEL2Jq68cgLcFBTApFwhVmpHqTm6iMxoAACMQD94viz\n"
 "rxa5HnPEluPBMBnYfubDl94cT7iJLzPrSA8Z94dGXSaQpYXFuXqUPoeovQA=\n"
 "-----END CERTIFICATE-----",.len=917},
+
+/* TWCA CYBER Root CA */
+{.str="-----BEGIN CERTIFICATE-----\n"
+"MIIFjTCCA3WgAwIBAgIQQAE0jMIAAAAAAAAAATzyxjANBgkqhkiG9w0BAQwFADBQMQswCQYD\n"
+"VQQGEwJUVzESMBAGA1UEChMJVEFJV0FOLUNBMRAwDgYDVQQLEwdSb290IENBMRswGQYDVQQD\n"
+"ExJUV0NBIENZQkVSIFJvb3QgQ0EwHhcNMjIxMTIyMDY1NDI5WhcNNDcxMTIyMTU1OTU5WjBQ\n"
+"MQswCQYDVQQGEwJUVzESMBAGA1UEChMJVEFJV0FOLUNBMRAwDgYDVQQLEwdSb290IENBMRsw\n"
+"GQYDVQQDExJUV0NBIENZQkVSIFJvb3QgQ0EwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIK\n"
+"AoICAQDG+Moe2Qkgfh1sTs6P40czRJzHyWmqOlt47nDSkvgEs1JSHWdyKKHfi12VCv7qze33\n"
+"Kc7wb3+szT3vsxxFavcokPFhV8UMxKNQXd7UtcsZyoC5dc4pztKFIuwCY8xEMCDa6pFbVuYd\n"
+"HNWdZsc/34bKS1PE2Y2yHer43CdTo0fhYcx9tbD47nORxc5zb87uEB8aBs/pJ2DFTxnk684i\n"
+"JkXXYJndzk834H/nY62wuFm40AZoNWDTNq5xQwTxaWV4fPMf88oon1oglWa0zbfuj3ikRRjp\n"
+"Ji+NmykosaS3Om251Bw4ckVYsV7r8Cibt4LK/c/WMw+f+5eesRycnupfXtuq3VTpMCEobY55\n"
+"83WSjCb+3MX2w7DfRFlDo7YDKPYIMKoNM+HvnKkHIuNZW0CP2oi3aQiotyMuRAlZN1vH4xfy\n"
+"IutuOVLF3lSnmMlLIJXcRolftBL5hSmO68gnFSDAS9TMfAxsNAwmmyYxpjyn9tnQS6Jk/zuZ\n"
+"QXLB4HCX8SS7K8R0IrGsayIyJNN4KsDAoS/xUgXJP+92ZuJF2A09rZXIx4kmyA+upwMu+8Ff\n"
+"+iDhcK2wZSA3M2Cw1a/XDBzCkHDXShi8fgGwsOsVHkQGzaRP6AzRwyAQ4VRlnrZR0Bp2a0Ja\n"
+"WHY06rc3Ga4udfmW5cFZ95RXKSWNOkyrTZpB0F8mAwIDAQABo2MwYTAOBgNVHQ8BAf8EBAMC\n"
+"AQYwDwYDVR0TAQH/BAUwAwEB/zAfBgNVHSMEGDAWgBSdhWEUfMFib5do5E83QOGt4A1WNzAd\n"
+"BgNVHQ4EFgQUnYVhFHzBYm+XaORPN0DhreANVjcwDQYJKoZIhvcNAQEMBQADggIBAGSPesRi\n"
+"DrWIzLjHhg6hShbNcAu3p4ULs3a2D6f/CIsLJc+o1IN1KriWiLb73y0ttGlTITVX1olNc79p\n"
+"j3CjYcya2x6a4CD4bLubIp1dhDGaLIrdaqHXKGnK/nZVekZn68xDiBaiA9a5F/gZbG0jAn/x\n"
+"X9AKKSM70aoK7akXJlQKTcKlTfjF/biBzysseKNnTKkHmvPfXvt89YnNdJdhEGoHK4Fa0o63\n"
+"5yDRIG4kqIQnoVesqlVYL9zZyvpoBJ7tRCT5dEA7IzOrg1oYJkK2bVS1FmAwbLGg+LhBoF1J\n"
+"SdJlBTrq/p1hvIbZv97Tujqxf36SNI7JAG7cmL3c7IAFrQI932XtCwP39xaEBDG6k5TY8hL4\n"
+"iuO/Qq+n1M0RFxbIQh0UqEL20kCGoE8jypZFVmAGzbdVAaYBlGX+bgUJurSkquLvWL69J1bY\n"
+"73NxW0Qz8ppy6rBePm6pUlvscG21h483XjyMnM7k8M4MZ0HMzvaAq07MTFb1wWFZk7Q+ptq4\n"
+"NxKfKjLji7gh7MMrZQzvIt6IKTtM1/r+t+FHvpw+PoP7UV31aPcuIYXcv/Fa4nzXxeSDwWrr\n"
+"uoBa3lwtcHb4yOWHh8qgnaHlIhInD0Q9HWzq1MKLL295q39QpsQZp6F6t5b5wR9iWqJDB0Be\n"
+"Jsas7a5wFsWqynKKTbDPAYsDP27X\n"
+"-----END CERTIFICATE-----",.len=1980},
+
+/* SecureSign Root CA12 */
+{.str="-----BEGIN CERTIFICATE-----\n"
+"MIIDcjCCAlqgAwIBAgIUZvnHwa/swlG07VOX5uaCwysckBYwDQYJKoZIhvcNAQELBQAwUTEL\n"
+"MAkGA1UEBhMCSlAxIzAhBgNVBAoTGkN5YmVydHJ1c3QgSmFwYW4gQ28uLCBMdGQuMR0wGwYD\n"
+"VQQDExRTZWN1cmVTaWduIFJvb3QgQ0ExMjAeFw0yMDA0MDgwNTM2NDZaFw00MDA0MDgwNTM2\n"
+"NDZaMFExCzAJBgNVBAYTAkpQMSMwIQYDVQQKExpDeWJlcnRydXN0IEphcGFuIENvLiwgTHRk\n"
+"LjEdMBsGA1UEAxMUU2VjdXJlU2lnbiBSb290IENBMTIwggEiMA0GCSqGSIb3DQEBAQUAA4IB\n"
+"DwAwggEKAoIBAQC6OcE3emhFKxS06+QT61d1I02PJC0W6K6OyX2kVzsqdiUzg2zqMoqUm048\n"
+"luT9Ub+ZyZN+v/mtp7JIKwccJ/VMvHASd6SFVLX9kHrko+RRWAPNEHl57muTH2SOa2SroxPj\n"
+"cf59q5zdJ1M3s6oYwlkm7Fsf0uZlfO+TvdhYXAvA42VvPMfKWeP+bl+sg779XSVOKik71gur\n"
+"FzJ4pOE+lEa+Ym6b3kaosRbnhW70CEBFEaCeVESE99g2zvVQR9wsMJvuwPWW0v4JhscGWa5P\n"
+"ro4RmHvzC1KqYiaqId+OJTN5lxZJjfU+1UefNzFJM3IFTQy2VYzxV4+Kh9GtxRESOaCtAgMB\n"
+"AAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBRXNPN0\n"
+"zwRL1SXm8UC2LEzZLemgrTANBgkqhkiG9w0BAQsFAAOCAQEAPrvbFxbS8hQBICw4g0utvsqF\n"
+"epq2m2um4fylOqyttCg6r9cBg0krY6LdmmQOmFxv3Y67ilQiLUoT865AQ9tPkbeGGuwAtEGB\n"
+"pE/6aouIs3YIcipJQMPTw4WJmBClnW8Zt7vPemVV2zfrPIpyMpcemik+rY3moxtt9XUa5rBo\n"
+"uVui7mlHJzWhhpmA8zNL4WukJsPvdFlseqJkth5Ew1DgDzk9qTPxpfPSvWKErI4cqc1avTc7\n"
+"bgoitPQV55FYxTpE05Uo2cBl6XLK0A+9H7MV2anjpEcJnuDLN/v9vZfVvhgaaaI5gdka9at/\n"
+"yOPiZwud9AzqVN/Ssq+xIvEg37xEHA==\n"
+"-----END CERTIFICATE-----",.len=1254},
+
+/* SecureSign Root CA14 */
+{.str="-----BEGIN CERTIFICATE-----\n"
+"MIIFcjCCA1qgAwIBAgIUZNtaDCBO6Ncpd8hQJ6JaJ90t8sswDQYJKoZIhvcNAQEMBQAwUTEL\n"
+"MAkGA1UEBhMCSlAxIzAhBgNVBAoTGkN5YmVydHJ1c3QgSmFwYW4gQ28uLCBMdGQuMR0wGwYD\n"
+"VQQDExRTZWN1cmVTaWduIFJvb3QgQ0ExNDAeFw0yMDA0MDgwNzA2MTlaFw00NTA0MDgwNzA2\n"
+"MTlaMFExCzAJBgNVBAYTAkpQMSMwIQYDVQQKExpDeWJlcnRydXN0IEphcGFuIENvLiwgTHRk\n"
+"LjEdMBsGA1UEAxMUU2VjdXJlU2lnbiBSb290IENBMTQwggIiMA0GCSqGSIb3DQEBAQUAA4IC\n"
+"DwAwggIKAoICAQDF0nqh1oq/FjHQmNE6lPxauG4iwWL3pwon71D2LrGeaBLwbCRjOfHw3xDG\n"
+"3rdSINVSW0KZnvOgvlIfX8xnbacuUKLBl422+JX1sLrcneC+y9/3OPJH9aaakpUqYllQC6Kx\n"
+"NedlsmGy6pJxaeQp8E+BgQQ8sqVb1MWoWWd7VRxJq3qdwudzTe/NCcLEVxLbAQ4jeQkHO6Lo\n"
+"/IrPj8BGJJw4J+CDnRugv3gVEOuGTgpa/d/aLIJ+7sr2KeH6caH3iGicnPCNvg9JkdjqOvn9\n"
+"0Ghx2+m1K06Ckm9mH+Dw3EzsytHqunQG+bOEkJTRX45zGRBdAuVwpcAQ0BB8b8VYSbSwbpra\n"
+"fZX1zNoCr7gsfXmPvkPx+SgojQlD+Ajda8iLLCSxjVIHvXiby8posqTdDEx5YMaZ0ZPxMBoH\n"
+"064iwurO8YQJzOAUbn8/ftKChazcqRZOhaBgy/ac18izju3Gm5h1DVXoX+WViwKkrkMpKBGk\n"
+"5hIwAUt1ax5mnXkvpXYvHUC0bcl9eQjs0Wq2XSqypWa9a4X0dFbD9ed1Uigspf9mR6XU/v6e\n"
+"VL9lfgHWMI+lNpyiUBzuOIABSMbHdPTGrMNASRZhdCyvjG817XsYAFs2PJxQDcqSMxDxJklt\n"
+"33UkN4Ii1+iW/RVLApY+B3KVfqs9TC7XyvDf4Fg/LS8EmjijAQIDAQABo0IwQDAPBgNVHRMB\n"
+"Af8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUBpOjCl4oaTeqYR3r6/wtbyPk\n"
+"86AwDQYJKoZIhvcNAQEMBQADggIBAJaAcgkGfpzMkwQWu6A6jZJOtxEaCnFxEM0ErX+lRVAQ\n"
+"Zk5KQaID2RFPeje5S+LGjzJmdSX7684/AykmjbgWHfYfM25I5uj4V7Ibed87hwriZLoAymzv\n"
+"ftAj63iP/2SbNDefNWWipAA9EiOWWF3KY4fGoweITedpdopTzfFP7ELyk+OZpDc8h7hi2/Ds\n"
+"Hzc/N19DzFGdtfCXwreFamgLRB7lUe6TzktuhsHSDCRZNhqfLJGP4xjblJUK7ZGqDpncllPj\n"
+"YYPGFrojutzdfhrGe0K22VoF3Jpf1d+42kd92jjbrDnVHmtsKheMYc2xbXIBw8MgAGJoFjHV\n"
+"dqqGuw6qnsb58Nn4DSEC5MUoFlkRudlpcyqSeLiSV5sI8jrlL5WwWLdrIBRtFO8KvH7YVdiI\n"
+"2i/6GaX7i+B/OfVyK4XELKzvGUWSTLNhB9xNH27SgRNcmvMSZ4PPmz+Ln52kuaiWA3rF7iDe\n"
+"M9ovnhp6dB7h7sxaOgTdsxoEqBRjrLdHEoOabPXm6RUVkRqEGQ6UROcSjiVbgGcZ3GOTEAtl\n"
+"Lor6CZpO2oYofaphNdgOpygau1LgePhsumywbrmHXumZNTfxPWQrqaA0k89jL9WB365jJ6Ue\n"
+"To3cKXhZ+PmhIIynJkBugnLNeLLIjzwec+fBH7/PzqUqm9tEZDKgu39cJRNItX+S\n"
+"-----END CERTIFICATE-----",.len=1943},
+
+/* SecureSign Root CA15 */
+{.str="-----BEGIN CERTIFICATE-----\n"
+"MIICIzCCAamgAwIBAgIUFhXHw9hJp75pDIqI7fBw+d23PocwCgYIKoZIzj0EAwMwUTELMAkG\n"
+"A1UEBhMCSlAxIzAhBgNVBAoTGkN5YmVydHJ1c3QgSmFwYW4gQ28uLCBMdGQuMR0wGwYDVQQD\n"
+"ExRTZWN1cmVTaWduIFJvb3QgQ0ExNTAeFw0yMDA0MDgwODMyNTZaFw00NTA0MDgwODMyNTZa\n"
+"MFExCzAJBgNVBAYTAkpQMSMwIQYDVQQKExpDeWJlcnRydXN0IEphcGFuIENvLiwgTHRkLjEd\n"
+"MBsGA1UEAxMUU2VjdXJlU2lnbiBSb290IENBMTUwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQL\n"
+"UHSNZDKZmbPSYAi4Io5GdCx4wCtELW1fHcmuS1Iggz24FG1Th2CeX2yF2wYUleDHKP+dX+Sq\n"
+"8bOLbe1PL0vJSpSRZHX+AezB2Ot6lHhWGENfa4HL9rzatAy2KZMIaY+jQjBAMA8GA1UdEwEB\n"
+"/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBTrQciu/NWeUUj1vYv0hyCTQSvT\n"
+"9DAKBggqhkjOPQQDAwNoADBlAjEA2S6Jfl5OpBEHvVnCB96rMjhTKkZEBhd6zlHp4P9mLQlO\n"
+"4E/0BdGF9jVg3PVys0Z9AjBEmEYagoUeYWmJSwdLZrWeqrqgHkHZAXQ6bkU6iYAZezKYVWOr\n"
+"62Nuk22rGwlgMU4=\n"
+"-----END CERTIFICATE-----",.len=800},
 };
diff --git a/packages/bun-usockets/src/eventing/epoll_kqueue.c b/packages/bun-usockets/src/eventing/epoll_kqueue.c
index 9395e190ea..612a3a8591 100644
--- a/packages/bun-usockets/src/eventing/epoll_kqueue.c
+++ b/packages/bun-usockets/src/eventing/epoll_kqueue.c
@@ -113,6 +113,9 @@ struct us_loop_t *us_timer_loop(struct us_timer_t *t) {
 #if defined(LIBUS_USE_EPOLL) 
 
 #include <sys/syscall.h>
+#include <signal.h>
+#include <errno.h>
+
 static int has_epoll_pwait2 = -1;
 
 #ifndef SYS_epoll_pwait2
@@ -122,18 +125,21 @@ static int has_epoll_pwait2 = -1;
 #define SYS_epoll_pwait2 441
 #endif
 
-static ssize_t sys_epoll_pwait2(int epfd, struct epoll_event *events, int maxevents, const struct timespec *timeout, const sigset_t *sigmask, size_t sigsetsize) {
-    return syscall(SYS_epoll_pwait2, epfd, events, maxevents, timeout, sigmask, sigsetsize);
-}
+extern ssize_t sys_epoll_pwait2(int epfd, struct epoll_event* events, int maxevents,
+                              const struct timespec* timeout, const sigset_t* sigmask);
+
 
 static int bun_epoll_pwait2(int epfd, struct epoll_event *events, int maxevents, const struct timespec *timeout) {
     int ret;
+    sigset_t mask;  
+    sigemptyset(&mask);
+  
     if (has_epoll_pwait2 != 0) {
         do {
-            ret = sys_epoll_pwait2(epfd, events, maxevents, timeout, NULL, 0);
-        } while (IS_EINTR(ret));
+            ret = sys_epoll_pwait2(epfd, events, maxevents, timeout, &mask);
+        } while (ret == -EINTR);
 
-        if (LIKELY(ret != -1 || errno != ENOSYS)) {
+        if (LIKELY(ret != -ENOSYS && ret != -EPERM && ret != -EOPNOTSUPP)) {
             return ret;
         }
 
@@ -146,12 +152,14 @@ static int bun_epoll_pwait2(int epfd, struct epoll_event *events, int maxevents,
     }
 
     do {
-        ret = epoll_wait(epfd, events, maxevents, timeoutMs);
+        ret = epoll_pwait(epfd, events, maxevents, timeoutMs, &mask);
     } while (IS_EINTR(ret));
 
     return ret;
 }
 
+extern int Bun__isEpollPwait2SupportedOnLinuxKernel();
+
 #endif
 
 /* Loop */
@@ -166,6 +174,13 @@ struct us_loop_t *us_create_loop(void *hint, void (*wakeup_cb)(struct us_loop_t
 
 #ifdef LIBUS_USE_EPOLL
     loop->fd = epoll_create1(EPOLL_CLOEXEC);
+
+    if (has_epoll_pwait2 == -1) {
+        if (Bun__isEpollPwait2SupportedOnLinuxKernel() == 0) {
+            has_epoll_pwait2 = 0;
+        } 
+    }
+
 #else
     loop->fd = kqueue();
 #endif
@@ -202,7 +217,8 @@ void us_loop_run(struct us_loop_t *loop) {
                 }
 #ifdef LIBUS_USE_EPOLL
                 int events = loop->ready_polls[loop->current_ready_poll].events;
-                const int error = events & (EPOLLERR | EPOLLHUP);
+                const int error = events & EPOLLERR;
+                const int eof = events & EPOLLHUP;
 #else
                 const struct kevent64_s* current_kevent = &loop->ready_polls[loop->current_ready_poll];
                 const int16_t filter = current_kevent->filter;
@@ -215,12 +231,13 @@ void us_loop_run(struct us_loop_t *loop) {
                 int events = 0
                     | ((filter & EVFILT_READ) ? LIBUS_SOCKET_READABLE : 0)
                     | ((filter & EVFILT_WRITE) ? LIBUS_SOCKET_WRITABLE : 0);
-                const int error = (flags & (EV_ERROR | EV_EOF)) ? ((int)fflags || 1) : 0;
+                const int error = (flags & (EV_ERROR)) ? ((int)fflags || 1) : 0;
+                const int eof = (flags & (EV_EOF));
 #endif
                 /* Always filter all polls by what they actually poll for (callback polls always poll for readable) */
                 events &= us_poll_events(poll);
-                if (events || error) {
-                    us_internal_dispatch_ready_poll(poll, error, events);
+                if (events || error || eof) {
+                    us_internal_dispatch_ready_poll(poll, error, eof, events);
                 }
             }
         }
@@ -230,6 +247,8 @@ void us_loop_run(struct us_loop_t *loop) {
     }
 }
 
+extern int Bun__JSC_onBeforeWait(void*);
+extern void Bun__JSC_onAfterWait(void*);
 
 void us_loop_run_bun_tick(struct us_loop_t *loop, const struct timespec* timeout) {
     if (loop->num_polls == 0)
@@ -246,6 +265,11 @@ void us_loop_run_bun_tick(struct us_loop_t *loop, const struct timespec* timeout
     /* Emit pre callback */
     us_internal_loop_pre(loop);
 
+    int needs_after_wait = 0;
+    if (loop->data.jsc_vm) {
+        needs_after_wait = Bun__JSC_onBeforeWait(loop->data.jsc_vm);
+    }
+
     /* Fetch ready polls */
 #ifdef LIBUS_USE_EPOLL
     
@@ -256,6 +280,10 @@ void us_loop_run_bun_tick(struct us_loop_t *loop, const struct timespec* timeout
     } while (IS_EINTR(loop->num_ready_polls));
 #endif
 
+    if (needs_after_wait) {
+        Bun__JSC_onAfterWait(loop->data.jsc_vm);
+    }
+
     /* Iterate ready polls, dispatching them by type */
     for (loop->current_ready_poll = 0; loop->current_ready_poll < loop->num_ready_polls; loop->current_ready_poll++) {
         struct us_poll_t *poll = GET_READY_POLL(loop, loop->current_ready_poll);
@@ -267,7 +295,8 @@ void us_loop_run_bun_tick(struct us_loop_t *loop, const struct timespec* timeout
             }
 #ifdef LIBUS_USE_EPOLL
             int events = loop->ready_polls[loop->current_ready_poll].events;
-            const int error = events & (EPOLLERR | EPOLLHUP);
+            const int error = events & EPOLLERR;
+            const int eof = events & EPOLLHUP;
 #else
             const struct kevent64_s* current_kevent = &loop->ready_polls[loop->current_ready_poll];
             const int16_t filter = current_kevent->filter;
@@ -281,12 +310,14 @@ void us_loop_run_bun_tick(struct us_loop_t *loop, const struct timespec* timeout
                 | ((filter & EVFILT_WRITE) ? LIBUS_SOCKET_WRITABLE : 0);
 
             // Note: EV_ERROR only sets the error in data as part of changelist. Not in this call!
-            const int error = (flags & (EV_ERROR | EV_EOF)) ? ((int)fflags || 1) : 0;
+            const int error = (flags & (EV_ERROR)) ? ((int)fflags || 1) : 0;
+            const int eof = (flags & (EV_EOF));
+
 #endif
             /* Always filter all polls by what they actually poll for (callback polls always poll for readable) */
             events &= us_poll_events(poll);
-            if (events || error) {
-                us_internal_dispatch_ready_poll(poll, error, events);
+            if (events || error || eof) {
+                us_internal_dispatch_ready_poll(poll, error, eof, events);
             }
         }
     }
diff --git a/packages/bun-usockets/src/eventing/libuv.c b/packages/bun-usockets/src/eventing/libuv.c
index b808795ef0..1fef73720e 100644
--- a/packages/bun-usockets/src/eventing/libuv.c
+++ b/packages/bun-usockets/src/eventing/libuv.c
@@ -24,7 +24,7 @@
 /* uv_poll_t->data always (except for most times after calling us_poll_stop)
  * points to the us_poll_t */
 static void poll_cb(uv_poll_t *p, int status, int events) {
-  us_internal_dispatch_ready_poll((struct us_poll_t *)p->data, status < 0,
+  us_internal_dispatch_ready_poll((struct us_poll_t *)p->data, status < 0 && status != UV_EOF, status == UV_EOF,
                                   events);
 }
 
diff --git a/packages/bun-usockets/src/internal/internal.h b/packages/bun-usockets/src/internal/internal.h
index 8c6c717504..f84e268621 100644
--- a/packages/bun-usockets/src/internal/internal.h
+++ b/packages/bun-usockets/src/internal/internal.h
@@ -64,10 +64,12 @@ void us_internal_loop_update_pending_ready_polls(struct us_loop_t *loop,
 
 #ifdef _WIN32
 #define IS_EINTR(rc) (rc == SOCKET_ERROR && WSAGetLastError() == WSAEINTR)
+#define LIBUS_ERR WSAGetLastError()
 #else
+#include <errno.h>
 #define IS_EINTR(rc) (rc == -1 && errno == EINTR)
+#define LIBUS_ERR errno
 #endif
-
 /* Poll type and what it polls for */
 enum {
   /* Three first bits */
@@ -111,8 +113,7 @@ extern struct addrinfo_result *Bun__addrinfo_getRequestResult(struct addrinfo_re
 
 
 /* Loop related */
-void us_internal_dispatch_ready_poll(struct us_poll_t *p, int error,
-                                     int events);
+void us_internal_dispatch_ready_poll(struct us_poll_t *p, int error, int eof, int events);
 void us_internal_timer_sweep(us_loop_r loop);
 void us_internal_free_closed_sockets(us_loop_r loop);
 void us_internal_loop_link(struct us_loop_t *loop,
@@ -164,9 +165,11 @@ struct us_socket_t {
   alignas(LIBUS_EXT_ALIGNMENT) struct us_poll_t p; // 4 bytes
   unsigned char timeout;                           // 1 byte
   unsigned char long_timeout;                      // 1 byte
-  unsigned short
+  unsigned char
       low_prio_state; /* 0 = not in low-prio queue, 1 = is in low-prio queue, 2
                          = was in low-prio queue in this iteration */
+  unsigned char allow_half_open; /* Allow to stay alive after FIN/EOF */
+
   struct us_socket_context_t *context;
   struct us_socket_t *prev, *next;
   struct us_socket_t *connect_next;
@@ -302,7 +305,7 @@ void us_internal_ssl_socket_context_add_server_name(
     us_internal_ssl_socket_context_r context,
     const char *hostname_pattern, struct us_socket_context_options_t options,
     void *user);
-void us_bun_internal_ssl_socket_context_add_server_name(
+int us_bun_internal_ssl_socket_context_add_server_name(
     us_internal_ssl_socket_context_r context,
     const char *hostname_pattern,
     struct us_bun_socket_context_options_t options, void *user);
@@ -330,7 +333,8 @@ struct us_internal_ssl_socket_context_t *us_internal_create_ssl_socket_context(
 struct us_internal_ssl_socket_context_t *
 us_internal_bun_create_ssl_socket_context(
     struct us_loop_t *loop, int context_ext_size,
-    struct us_bun_socket_context_options_t options);
+    struct us_bun_socket_context_options_t options,
+    enum create_bun_socket_error_t *err);
 
 void us_internal_ssl_socket_context_free(
     us_internal_ssl_socket_context_r context);
@@ -390,11 +394,11 @@ void us_internal_ssl_socket_context_on_socket_connect_error(
 
 struct us_listen_socket_t *us_internal_ssl_socket_context_listen(
     us_internal_ssl_socket_context_r context, const char *host,
-    int port, int options, int socket_ext_size);
+    int port, int options, int socket_ext_size, int* error);
 
 struct us_listen_socket_t *us_internal_ssl_socket_context_listen_unix(
     us_internal_ssl_socket_context_r context, const char *path,
-    size_t pathlen, int options, int socket_ext_size);
+    size_t pathlen, int options, int socket_ext_size, int* error);
 
 struct us_connecting_socket_t *us_internal_ssl_socket_context_connect(
     us_internal_ssl_socket_context_r context, const char *host,
diff --git a/packages/bun-usockets/src/internal/loop_data.h b/packages/bun-usockets/src/internal/loop_data.h
index 1f0a3adb76..ddbaee9ffc 100644
--- a/packages/bun-usockets/src/internal/loop_data.h
+++ b/packages/bun-usockets/src/internal/loop_data.h
@@ -44,6 +44,7 @@ struct us_internal_loop_data_t {
     char parent_tag;
     /* We do not care if this flips or not, it doesn't matter */
     size_t iteration_nr;
+    void* jsc_vm;
 };
 
 #endif // LOOP_DATA_H
diff --git a/packages/bun-usockets/src/internal/networking/bsd.h b/packages/bun-usockets/src/internal/networking/bsd.h
index 3d4ed5a390..e100e12bf6 100644
--- a/packages/bun-usockets/src/internal/networking/bsd.h
+++ b/packages/bun-usockets/src/internal/networking/bsd.h
@@ -178,6 +178,7 @@ int bsd_udp_packet_buffer_local_ip(struct udp_recvbuf *msgvec, int index, char *
 LIBUS_SOCKET_DESCRIPTOR apple_no_sigpipe(LIBUS_SOCKET_DESCRIPTOR fd);
 LIBUS_SOCKET_DESCRIPTOR bsd_set_nonblocking(LIBUS_SOCKET_DESCRIPTOR fd);
 void bsd_socket_nodelay(LIBUS_SOCKET_DESCRIPTOR fd, int enabled);
+int bsd_socket_keepalive(LIBUS_SOCKET_DESCRIPTOR fd, int on, unsigned int delay);
 void bsd_socket_flush(LIBUS_SOCKET_DESCRIPTOR fd);
 LIBUS_SOCKET_DESCRIPTOR bsd_create_socket(int domain, int type, int protocol);
 
@@ -205,9 +206,9 @@ int bsd_would_block();
 
 // return LIBUS_SOCKET_ERROR or the fd that represents listen socket
 // listen both on ipv6 and ipv4
-LIBUS_SOCKET_DESCRIPTOR bsd_create_listen_socket(const char *host, int port, int options);
+LIBUS_SOCKET_DESCRIPTOR bsd_create_listen_socket(const char *host, int port, int options, int* error);
 
-LIBUS_SOCKET_DESCRIPTOR bsd_create_listen_socket_unix(const char *path, size_t pathlen, int options);
+LIBUS_SOCKET_DESCRIPTOR bsd_create_listen_socket_unix(const char *path, size_t pathlen, int options, int* error);
 
 /* Creates an UDP socket bound to the hostname and port */
 LIBUS_SOCKET_DESCRIPTOR bsd_create_udp_socket(const char *host, int port);
diff --git a/packages/bun-usockets/src/libusockets.h b/packages/bun-usockets/src/libusockets.h
index b939af53ef..cf34618f85 100644
--- a/packages/bun-usockets/src/libusockets.h
+++ b/packages/bun-usockets/src/libusockets.h
@@ -36,9 +36,9 @@
 #define LIBUSOCKETS_H
 
 #ifdef BUN_DEBUG
-#define nonnull_arg _Nonnull
-#else
 #define nonnull_arg
+#else
+#define nonnull_arg _Nonnull
 #endif
 
 #ifdef BUN_DEBUG
@@ -91,9 +91,15 @@ extern "C" {
 
 enum {
     /* No meaning, default listen option */
-    LIBUS_LISTEN_DEFAULT,
+    LIBUS_LISTEN_DEFAULT = 0,
     /* We exclusively own this port, do not share it */
-    LIBUS_LISTEN_EXCLUSIVE_PORT
+    LIBUS_LISTEN_EXCLUSIVE_PORT = 1,
+    /* Allow socket to keep writing after readable side closes */
+    LIBUS_SOCKET_ALLOW_HALF_OPEN = 2,
+    /* Setting reusePort allows multiple sockets on the same host to bind to the same port. Incoming connections are distributed by the operating system to listening sockets. This option is available only on some platforms, such as Linux 3.9+, DragonFlyBSD 3.6+, FreeBSD 12.0+, Solaris 11.4, and AIX 7.2.5+*/
+    LIBUS_LISTEN_REUSE_PORT = 4,
+    /* etting ipv6Only will disable dual-stack support, i.e., binding to host :: won't make 0.0.0.0 be bound.*/
+    LIBUS_SOCKET_IPV6_ONLY = 8,
 };
 
 /* Library types publicly available */
@@ -188,7 +194,7 @@ struct us_socket_context_options_t {
 };
 
 struct us_bun_verify_error_t {
-    long error;
+    int error;
     const char* code;
     const char* reason;
 };
@@ -234,7 +240,7 @@ unsigned short us_socket_context_timestamp(int ssl, us_socket_context_r context)
 
 /* Adds SNI domain and cert in asn1 format */
 void us_socket_context_add_server_name(int ssl, us_socket_context_r context, const char *hostname_pattern, struct us_socket_context_options_t options, void *user);
-void us_bun_socket_context_add_server_name(int ssl, us_socket_context_r context, const char *hostname_pattern, struct us_bun_socket_context_options_t options, void *user);
+int us_bun_socket_context_add_server_name(int ssl, us_socket_context_r context, const char *hostname_pattern, struct us_bun_socket_context_options_t options, void *user);
 void us_socket_context_remove_server_name(int ssl, us_socket_context_r context, const char *hostname_pattern);
 void us_socket_context_on_server_name(int ssl, us_socket_context_r context, void (*cb)(us_socket_context_r context, const char *hostname));
 void *us_socket_server_name_userdata(int ssl, us_socket_r s);
@@ -246,8 +252,16 @@ void *us_socket_context_get_native_handle(int ssl, us_socket_context_r context);
 /* A socket context holds shared callbacks and user data extension for associated sockets */
 struct us_socket_context_t *us_create_socket_context(int ssl, us_loop_r loop,
     int ext_size, struct us_socket_context_options_t options) nonnull_fn_decl;
+
+enum create_bun_socket_error_t {
+  CREATE_BUN_SOCKET_ERROR_NONE = 0,
+  CREATE_BUN_SOCKET_ERROR_LOAD_CA_FILE,
+  CREATE_BUN_SOCKET_ERROR_INVALID_CA_FILE,
+  CREATE_BUN_SOCKET_ERROR_INVALID_CA,
+};
+
 struct us_socket_context_t *us_create_bun_socket_context(int ssl, struct us_loop_t *loop,
-    int ext_size, struct us_bun_socket_context_options_t options);
+    int ext_size, struct us_bun_socket_context_options_t options, enum create_bun_socket_error_t *err);
 
 /* Delete resources allocated at creation time (will call unref now and only free when ref count == 0). */
 void us_socket_context_free(int ssl, us_socket_context_r context) nonnull_fn_decl;
@@ -287,10 +301,10 @@ void us_socket_context_close(int ssl, us_socket_context_r context);
 
 /* Listen for connections. Acts as the main driving cog in a server. Will call set async callbacks. */
 struct us_listen_socket_t *us_socket_context_listen(int ssl, us_socket_context_r context,
-    const char *host, int port, int options, int socket_ext_size);
+    const char *host, int port, int options, int socket_ext_size, int* error);
 
 struct us_listen_socket_t *us_socket_context_listen_unix(int ssl, us_socket_context_r context,
-    const char *path, size_t pathlen, int options, int socket_ext_size);
+    const char *path, size_t pathlen, int options, int socket_ext_size, int* error);
 
 /* listen_socket.c/.h */
 void us_listen_socket_close(int ssl, struct us_listen_socket_t *ls) nonnull_fn_decl;
@@ -328,6 +342,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);
@@ -457,6 +473,11 @@ int us_socket_get_error(int ssl, us_socket_r s);
 void us_socket_ref(us_socket_r s);
 void us_socket_unref(us_socket_r s);
 
+void us_socket_nodelay(us_socket_r s, int enabled);
+int us_socket_keepalive(us_socket_r s, int enabled, unsigned int delay);
+void us_socket_resume(int ssl, us_socket_r s);
+void us_socket_pause(int ssl, us_socket_r s);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/packages/bun-usockets/src/loop.c b/packages/bun-usockets/src/loop.c
index 9bd315822b..19bb4fe9ea 100644
--- a/packages/bun-usockets/src/loop.c
+++ b/packages/bun-usockets/src/loop.c
@@ -22,6 +22,7 @@
 #include <sys/ioctl.h>
 #endif
 
+
 /* The loop has 2 fallthrough polls */
 void us_internal_loop_data_init(struct us_loop_t *loop, void (*wakeup_cb)(struct us_loop_t *loop),
     void (*pre_cb)(struct us_loop_t *loop), void (*post_cb)(struct us_loop_t *loop)) {
@@ -48,6 +49,7 @@ void us_internal_loop_data_init(struct us_loop_t *loop, void (*wakeup_cb)(struct
     loop->data.parent_tag = 0;
 
     loop->data.closed_context_head = 0;
+    loop->data.jsc_vm = 0;
 
     loop->data.wakeup_async = us_internal_create_async(loop, 1, 0);
     us_internal_async_set(loop->data.wakeup_async, (void (*)(struct us_internal_async *)) wakeup_cb);
@@ -274,7 +276,7 @@ void us_internal_loop_post(struct us_loop_t *loop) {
 #define us_ioctl ioctl
 #endif
 
-void us_internal_dispatch_ready_poll(struct us_poll_t *p, int error, int events) {
+void us_internal_dispatch_ready_poll(struct us_poll_t *p, int error, int eof, int events) {
     switch (us_internal_poll_type(p)) {
     case POLL_TYPE_CALLBACK: {
             struct us_internal_callback_t *cb = (struct us_internal_callback_t *) p;
@@ -292,7 +294,7 @@ void us_internal_dispatch_ready_poll(struct us_poll_t *p, int error, int events)
             /* Both connect and listen sockets are semi-sockets
              * but they poll for different events */
             if (us_poll_events(p) == LIBUS_SOCKET_WRITABLE) {
-                us_internal_socket_after_open((struct us_socket_t *) p, error);
+                us_internal_socket_after_open((struct us_socket_t *) p, error || eof);
             } else {
                 struct us_listen_socket_t *listen_socket = (struct us_listen_socket_t *) p;
                 struct bsd_addr_t addr;
@@ -317,6 +319,8 @@ void us_internal_dispatch_ready_poll(struct us_poll_t *p, int error, int events)
                         s->timeout = 255;
                         s->long_timeout = 255;
                         s->low_prio_state = 0;
+                        s->allow_half_open = listen_socket->s.allow_half_open;
+
 
                         /* We always use nodelay */
                         bsd_socket_nodelay(client_fd, 1);
@@ -421,19 +425,11 @@ void us_internal_dispatch_ready_poll(struct us_poll_t *p, int error, int events)
                         #undef LOOP_ISNT_VERY_BUSY_THRESHOLD
                         #endif
                     } else if (!length) {
-                        if (us_socket_is_shut_down(0, s)) {
-                            /* We got FIN back after sending it */
-                            /* Todo: We should give "CLEAN SHUTDOWN" as reason here */
-                            s = us_socket_close(0, s, LIBUS_SOCKET_CLOSE_CODE_CLEAN_SHUTDOWN, NULL);
-                            return;
-                        } else {
-                            /* We got FIN, so stop polling for readable */
-                            us_poll_change(&s->p, us_socket_context(0, s)->loop, us_poll_events(&s->p) & LIBUS_SOCKET_WRITABLE);
-                            s = s->context->on_end(s);
-                        }
+                        eof = 1; // lets handle EOF in the same place
+                        break;
                     } else if (length == LIBUS_SOCKET_ERROR && !bsd_would_block()) {
                         /* Todo: decide also here what kind of reason we should give */
-                        s = us_socket_close(0, s, LIBUS_SOCKET_CLOSE_CODE_CLEAN_SHUTDOWN, NULL);
+                        s = us_socket_close(0, s, LIBUS_ERR, NULL);
                         return;
                     }
 
@@ -441,7 +437,24 @@ void us_internal_dispatch_ready_poll(struct us_poll_t *p, int error, int events)
                 } while (s);
             }
 
-            /* Such as epollerr epollhup */
+            if(eof && s) {
+                if (us_socket_is_shut_down(0, s)) {
+                    /* We got FIN back after sending it */
+                    s = us_socket_close(0, s, LIBUS_SOCKET_CLOSE_CODE_CLEAN_SHUTDOWN, NULL);
+                    return;
+                }
+                if(s->allow_half_open) {
+                    /* We got a Error but is EOF and we allow half open so stop polling for readable and keep going*/
+                    us_poll_change(&s->p, us_socket_context(0, s)->loop, us_poll_events(&s->p) & LIBUS_SOCKET_WRITABLE);
+                    s = s->context->on_end(s);
+                } else {
+                    /* We dont allow half open just emit end and close the socket */
+                    s = s->context->on_end(s);
+                    s = us_socket_close(0, s, LIBUS_SOCKET_CLOSE_CODE_CLEAN_SHUTDOWN, NULL);
+                    return;
+                }
+            } 
+            /* Such as epollerr or EV_ERROR */
             if (error && s) {
                 /* Todo: decide what code we give here */
                 s = us_socket_close(0, s, error, NULL);
diff --git a/packages/bun-usockets/src/socket.c b/packages/bun-usockets/src/socket.c
index c497a520d1..031ed9c911 100644
--- a/packages/bun-usockets/src/socket.c
+++ b/packages/bun-usockets/src/socket.c
@@ -496,6 +496,19 @@ void us_socket_ref(struct us_socket_t *s) {
     // do nothing if not using libuv
 }
 
+void us_socket_nodelay(struct us_socket_t *s, int enabled) {
+    if (!us_socket_is_shut_down(0, s)) {
+        bsd_socket_nodelay(us_poll_fd((struct us_poll_t *) s), enabled);
+    }
+}
+
+int us_socket_keepalive(us_socket_r s, int enabled, unsigned int delay){
+    if (!us_socket_is_shut_down(0, s)) {
+        bsd_socket_keepalive(us_poll_fd((struct us_poll_t *) s), enabled, delay);
+    }
+    return 0;
+}
+
 void us_socket_unref(struct us_socket_t *s) {
 #ifdef LIBUS_USE_LIBUV
     uv_unref((uv_handle_t*)s->p.uv_p);
@@ -506,3 +519,28 @@ void us_socket_unref(struct us_socket_t *s) {
 struct us_loop_t *us_connecting_socket_get_loop(struct us_connecting_socket_t *c) {
     return c->context->loop;
 }
+
+void us_socket_pause(int ssl, struct us_socket_t *s) {
+    // closed cannot be paused because it is already closed
+    if(us_socket_is_closed(ssl, s)) return;
+    if(us_socket_is_shut_down(ssl, s)) {
+        // we already sent FIN so we pause all events because we are read-only
+        us_poll_change(&s->p, s->context->loop, 0);
+        return;
+    }
+    // we are readable and writable so we can just pause readable side
+    us_poll_change(&s->p, s->context->loop, LIBUS_SOCKET_WRITABLE);
+}
+
+void us_socket_resume(int ssl, struct us_socket_t *s) {
+    // closed cannot be resumed
+    if(us_socket_is_closed(ssl, s)) return;
+
+    if(us_socket_is_shut_down(ssl, s)) {
+      // we already sent FIN so we resume only readable side we are read-only
+      us_poll_change(&s->p, s->context->loop, LIBUS_SOCKET_READABLE);
+      return;
+    }
+    // we are readable and writable so we resume everything
+    us_poll_change(&s->p, s->context->loop, LIBUS_SOCKET_READABLE | LIBUS_SOCKET_WRITABLE);
+  }
\ No newline at end of file
diff --git a/packages/bun-uws/src/App.h b/packages/bun-uws/src/App.h
index be91e146d6..a13c888c1c 100644
--- a/packages/bun-uws/src/App.h
+++ b/packages/bun-uws/src/App.h
@@ -16,8 +16,7 @@
  * limitations under the License.
  */
 // clang-format off
-#ifndef UWS_APP_H
-#define UWS_APP_H
+
 
 #include <string>
 #include <charconv>
@@ -106,14 +105,17 @@ public:
 
 
     /* Server name */
-    TemplatedApp &&addServerName(std::string hostname_pattern, SocketContextOptions options = {}) {
+    TemplatedApp &&addServerName(std::string hostname_pattern, SocketContextOptions options = {}, bool *success = nullptr) {
 
         /* Do nothing if not even on SSL */
         if constexpr (SSL) {
             /* First we create a new router for this domain */
             auto *domainRouter = new HttpRouter<typename HttpContextData<SSL>::RouterData>();
 
-            us_bun_socket_context_add_server_name(SSL, (struct us_socket_context_t *) httpContext, hostname_pattern.c_str(), options, domainRouter);
+            int result = us_bun_socket_context_add_server_name(SSL, (struct us_socket_context_t *) httpContext, hostname_pattern.c_str(), options, domainRouter);
+            if (success) {
+                *success = result == 0;
+            }
         }
 
         return std::move(*this);
@@ -238,6 +240,18 @@ public:
         httpContext = HttpContext<SSL>::create(Loop::get(), options);
     }
 
+    TemplatedApp(HttpContext<SSL> &context) {
+        httpContext = &context;
+    }
+
+    static TemplatedApp<SSL>* create(SocketContextOptions options = {}) {
+        auto* httpContext = HttpContext<SSL>::create(Loop::get(), options);
+        if (!httpContext) {
+            return nullptr;
+        }
+        return new TemplatedApp<SSL>(*httpContext);
+    }
+
     bool constructorFailed() {
         return !httpContext;
     }
@@ -604,4 +618,3 @@ typedef TemplatedApp<true> SSLApp;
 
 }
 
-#endif // UWS_APP_H
\ No newline at end of file
diff --git a/packages/bun-uws/src/AsyncSocketData.h b/packages/bun-uws/src/AsyncSocketData.h
index d91592f287..d6f65e6387 100644
--- a/packages/bun-uws/src/AsyncSocketData.h
+++ b/packages/bun-uws/src/AsyncSocketData.h
@@ -48,6 +48,7 @@ struct BackPressure {
     void clear() {
         pendingRemoval = 0;
         buffer.clear();
+        buffer.shrink_to_fit();
     }
     void reserve(size_t length) {
         buffer.reserve(length + pendingRemoval);
diff --git a/packages/bun-uws/src/HttpContext.h b/packages/bun-uws/src/HttpContext.h
index 338683f816..73384a5af8 100644
--- a/packages/bun-uws/src/HttpContext.h
+++ b/packages/bun-uws/src/HttpContext.h
@@ -16,8 +16,7 @@
  * limitations under the License.
  */
 
-#ifndef UWS_HTTPCONTEXT_H
-#define UWS_HTTPCONTEXT_H
+#pragma once
 
 /* This class defines the main behavior of HTTP and emits various events */
 
@@ -27,6 +26,8 @@
 #include "AsyncSocket.h"
 #include "WebSocketData.h"
 
+#include <string>
+#include <map>
 #include <string_view>
 #include <iostream>
 #include "MoveOnlyFunction.h"
@@ -171,7 +172,7 @@ private:
 #endif
 
             /* The return value is entirely up to us to interpret. The HttpParser only care for whether the returned value is DIFFERENT or not from passed user */
-            void *returnedSocket = httpResponseData->consumePostPadded(data, (unsigned int) length, s, proxyParser, [httpContextData](void *s, HttpRequest *httpRequest) -> void * {
+            auto [err, returnedSocket] = httpResponseData->consumePostPadded(data, (unsigned int) length, s, proxyParser, [httpContextData](void *s, HttpRequest *httpRequest) -> void * {
                 /* For every request we reset the timeout and hang until user makes action */
                 /* Warning: if we are in shutdown state, resetting the timer is a security issue! */
                 us_socket_timeout(SSL, (us_socket_t *) s, 0);
@@ -180,7 +181,9 @@ private:
                 HttpResponseData<SSL> *httpResponseData = (HttpResponseData<SSL> *) us_socket_ext(SSL, (us_socket_t *) s);
                 httpResponseData->offset = 0;
 
-                /* Are we not ready for another request yet? Terminate the connection. */
+                /* Are we not ready for another request yet? Terminate the connection.
+                 * Important for denying async pipelining until, if ever, we want to suppot it.
+                 * Otherwise requests can get mixed up on the same connection. We still support sync pipelining. */
                 if (httpResponseData->state & HttpResponseData<SSL>::HTTP_RESPONSE_PENDING) {
                     us_socket_close(SSL, (us_socket_t *) s, 0, nullptr);
                     return nullptr;
@@ -280,10 +283,6 @@ private:
                     }
                 }
                 return user;
-            }, [](void *user) {
-                 /* Close any socket on HTTP errors */
-                us_socket_close(SSL, (us_socket_t *) user, 0, nullptr);
-                return nullptr;
             });
 
             /* Mark that we are no longer parsing Http */
@@ -291,6 +290,9 @@ private:
 
             /* If we got fullptr that means the parser wants us to close the socket from error (same as calling the errorHandler) */
             if (returnedSocket == FULLPTR) {
+                /* For errors, we only deliver them "at most once". We don't care if they get halfways delivered or not. */
+                us_socket_write(SSL, s, httpErrorResponses[err].data(), (int) httpErrorResponses[err].length(), false);
+                us_socket_shutdown(SSL, s);
                 /* Close any socket on HTTP errors */
                 us_socket_close(SSL, s, 0, nullptr);
                 /* This just makes the following code act as if the socket was closed from error inside the parser. */
@@ -299,9 +301,8 @@ private:
 
             /* We need to uncork in all cases, except for nullptr (closed socket, or upgraded socket) */
             if (returnedSocket != nullptr) {
-                us_socket_t* returnedSocketPtr = (us_socket_t*) returnedSocket; 
                 /* We don't want open sockets to keep the event loop alive between HTTP requests */
-                us_socket_unref(returnedSocketPtr);
+                us_socket_unref((us_socket_t *) returnedSocket);
 
                 /* Timeout on uncork failure */
                 auto [written, failed] = ((AsyncSocket<SSL> *) returnedSocket)->uncork();
@@ -321,7 +322,7 @@ private:
                         }
                     }
                 }
-                return returnedSocketPtr;
+                return (us_socket_t *) returnedSocket;
             }
 
             /* If we upgraded, check here (differ between nullptr close and nullptr upgrade) */
@@ -433,7 +434,8 @@ public:
     static HttpContext *create(Loop *loop, us_bun_socket_context_options_t options = {}) {
         HttpContext *httpContext;
 
-        httpContext = (HttpContext *) us_create_bun_socket_context(SSL, (us_loop_t *) loop, sizeof(HttpContextData<SSL>), options);
+        enum create_bun_socket_error_t err = CREATE_BUN_SOCKET_ERROR_NONE;
+        httpContext = (HttpContext *) us_create_bun_socket_context(SSL, (us_loop_t *) loop, sizeof(HttpContextData<SSL>), options, &err);
 
         if (!httpContext) {
             return nullptr;
@@ -482,10 +484,27 @@ public:
             return;
         }
 
-        httpContextData->currentRouter->add(methods, pattern, [handler = std::move(handler)](auto *r) mutable {
+        /* Record this route's parameter offsets */
+        std::map<std::string, unsigned short, std::less<>> parameterOffsets;
+        unsigned short offset = 0;
+        for (unsigned int i = 0; i < pattern.length(); i++) {
+            if (pattern[i] == ':') {
+                i++;
+                unsigned int start = i;
+                while (i < pattern.length() && pattern[i] != '/') {
+                    i++;
+                }
+                parameterOffsets[std::string(pattern.data() + start, i - start)] = offset;
+                //std::cout << "<" << std::string(pattern.data() + start, i - start) << "> is offset " << offset;
+                offset++;
+            }
+        }
+
+        httpContextData->currentRouter->add(methods, pattern, [handler = std::move(handler), parameterOffsets = std::move(parameterOffsets)](auto *r) mutable {
             auto user = r->getUserData();
             user.httpRequest->setYield(false);
             user.httpRequest->setParameters(r->getParameters());
+            user.httpRequest->setParameterOffsets(&parameterOffsets);
 
             /* Middleware? Automatically respond to expectations */
             std::string_view expect = user.httpRequest->getHeader("expect");
@@ -505,7 +524,8 @@ public:
 
     /* Listen to port using this HttpContext */
     us_listen_socket_t *listen(const char *host, int port, int options) {
-        auto socket = us_socket_context_listen(SSL, getSocketContext(), host, port, options, sizeof(HttpResponseData<SSL>));
+        int error = 0;
+        auto socket = us_socket_context_listen(SSL, getSocketContext(), host, port, options, sizeof(HttpResponseData<SSL>), &error);
         // we dont depend on libuv ref for keeping it alive
         if (socket) {
           us_socket_unref(&socket->s);
@@ -515,7 +535,8 @@ public:
 
     /* Listen to unix domain socket using this HttpContext */
     us_listen_socket_t *listen_unix(const char *path, size_t pathlen, int options) {
-        auto* socket =  us_socket_context_listen_unix(SSL, getSocketContext(), path, pathlen, options, sizeof(HttpResponseData<SSL>));
+        int error = 0;
+        auto* socket =  us_socket_context_listen_unix(SSL, getSocketContext(), path, pathlen, options, sizeof(HttpResponseData<SSL>), &error);
         // we dont depend on libuv ref for keeping it alive
         if (socket) {
             us_socket_unref(&socket->s);
@@ -527,4 +548,4 @@ public:
 
 }
 
-#endif // UWS_HTTPCONTEXT_H
+
diff --git a/packages/bun-uws/src/HttpError.h b/packages/bun-uws/src/HttpError.h
new file mode 100644
index 0000000000..a17a1c7377
--- /dev/null
+++ b/packages/bun-uws/src/HttpError.h
@@ -0,0 +1,53 @@
+/*
+ * Authored by Alex Hultman, 2018-2023.
+ * Intellectual property of third-party.
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ *     http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef UWS_HTTP_ERRORS
+#define UWS_HTTP_ERRORS
+
+#include <string_view>
+
+namespace uWS {
+/* Possible errors from http parsing */
+enum HttpError {
+    HTTP_ERROR_505_HTTP_VERSION_NOT_SUPPORTED = 1,
+    HTTP_ERROR_431_REQUEST_HEADER_FIELDS_TOO_LARGE = 2,
+    HTTP_ERROR_400_BAD_REQUEST = 3
+};
+
+#ifndef UWS_HTTPRESPONSE_NO_WRITEMARK
+
+/* Returned parser errors match this LUT. */
+static const std::string_view httpErrorResponses[] = {
+    "", /* Zeroth place is no error so don't use it */
+    "HTTP/1.1 505 HTTP Version Not Supported\r\nConnection: close\r\n\r\n<h1>HTTP Version Not Supported</h1><p>This server does not support HTTP/1.0.</p><hr><i>uWebSockets/20 Server</i>",
+    "HTTP/1.1 431 Request Header Fields Too Large\r\nConnection: close\r\n\r\n<h1>Request Header Fields Too Large</h1><hr><i>uWebSockets/20 Server</i>",
+    "HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n<h1>Bad Request</h1><hr><i>uWebSockets/20 Server</i>",
+};
+
+#else
+/* Anonymized pages */
+static const std::string_view httpErrorResponses[] = {
+    "", /* Zeroth place is no error so don't use it */
+    "HTTP/1.1 505 HTTP Version Not Supported\r\nConnection: close\r\n\r\n",
+    "HTTP/1.1 431 Request Header Fields Too Large\r\nConnection: close\r\n\r\n",
+    "HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n"
+};
+#endif
+
+}
+
+#endif
\ No newline at end of file
diff --git a/packages/bun-uws/src/HttpErrors.h b/packages/bun-uws/src/HttpErrors.h
new file mode 100644
index 0000000000..704ba0b43a
--- /dev/null
+++ b/packages/bun-uws/src/HttpErrors.h
@@ -0,0 +1,42 @@
+/*
+ * Authored by Alex Hultman, 2018-2023.
+ * Intellectual property of third-party.
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ *     http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string_view>
+
+namespace uWS {
+/* Possible errors from http parsing */
+enum HttpError {
+    HTTP_ERROR_505_HTTP_VERSION_NOT_SUPPORTED = 1,
+    HTTP_ERROR_431_REQUEST_HEADER_FIELDS_TOO_LARGE = 2,
+    HTTP_ERROR_400_BAD_REQUEST = 3
+};
+
+
+/* Anonymized pages */
+static const std::string_view httpErrorResponses[] = {
+    "", /* Zeroth place is no error so don't use it */
+    "HTTP/1.1 505 HTTP Version Not Supported\r\nConnection: close\r\n\r\n",
+    "HTTP/1.1 431 Request Header Fields Too Large\r\nConnection: close\r\n\r\n",
+    "HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n"
+};
+
+
+
+}
+
diff --git a/packages/bun-uws/src/HttpParser.h b/packages/bun-uws/src/HttpParser.h
index 59bfd0f769..3eb88e353e 100644
--- a/packages/bun-uws/src/HttpParser.h
+++ b/packages/bun-uws/src/HttpParser.h
@@ -15,8 +15,7 @@
  * limitations under the License.
  */
 
-#ifndef UWS_HTTPPARSER_H
-#define UWS_HTTPPARSER_H
+#pragma once
 
 #ifndef UWS_HTTP_MAX_HEADERS_COUNT
 #define UWS_HTTP_MAX_HEADERS_COUNT 100
@@ -38,6 +37,7 @@
 #include "BloomFilter.h"
 #include "ProxyParser.h"
 #include "QueryParser.h"
+#include "HttpErrors.h"
 
 extern "C" size_t BUN_DEFAULT_MAX_HTTP_HEADER_SIZE;
 
@@ -63,6 +63,7 @@ namespace uWS
         bool didYield;
         BloomFilter bf;
         std::pair<int, std::string_view *> currentParameters;
+        std::map<std::string, unsigned short, std::less<>> *currentParameterOffsets = nullptr;
 
     public:
         bool isAncient()
@@ -188,14 +189,26 @@ namespace uWS
             currentParameters = parameters;
         }
 
-        std::string_view getParameter(unsigned short index)
+        void setParameterOffsets(std::map<std::string, unsigned short, std::less<>> *offsets)
         {
-            if (currentParameters.first < (int)index)
-            {
-                return {};
+            currentParameterOffsets = offsets;
+        }
+
+        std::string_view getParameter(std::string_view name) {
+            if (!currentParameterOffsets) {
+                return {nullptr, 0};
             }
-            else
-            {
+            auto it = currentParameterOffsets->find(name);
+            if (it == currentParameterOffsets->end()) {
+                return {nullptr, 0};
+            }
+            return getParameter(it->second);
+        }
+
+        std::string_view getParameter(unsigned short index) {
+            if (currentParameters.first < (int)index) {
+                return {};
+            } else {
                 return currentParameters.second[index];
             }
         }
@@ -211,46 +224,42 @@ namespace uWS
 
         const size_t MAX_FALLBACK_SIZE = BUN_DEFAULT_MAX_HTTP_HEADER_SIZE;
 
-        /* Returns UINT_MAX on error. Maximum 999999999 is allowed. */
+        /* Returns UINT64_MAX on error. Maximum 999999999 is allowed. */
         static uint64_t toUnsignedInteger(std::string_view str) {
             /* We assume at least 64-bit integer giving us safely 999999999999999999 (18 number of 9s) */
             if (str.length() > 18) {
-                return UINT_MAX;
+                return UINT64_MAX;
             }
 
             uint64_t unsignedIntegerValue = 0;
             for (char c : str) {
                 /* As long as the letter is 0-9 we cannot overflow. */
                 if (c < '0' || c > '9') {
-                    return UINT_MAX;
+                    return UINT64_MAX;
                 }
                 unsignedIntegerValue = unsignedIntegerValue * 10ull + ((unsigned int) c - (unsigned int) '0');
             }
             return unsignedIntegerValue;
         }
-
-        static inline uint64_t hasLess(uint64_t x, uint64_t n)
-        {
-            return (((x) - ~0ULL / 255 * (n)) & ~(x) & ~0ULL / 255 * 128);
+        
+        static inline uint64_t hasLess(uint64_t x, uint64_t n) {
+            return (((x)-~0ULL/255*(n))&~(x)&~0ULL/255*128);
         }
 
-        static inline uint64_t hasMore(uint64_t x, uint64_t n)
-        {
-            return ((((x) + ~0ULL / 255 * (127 - (n))) | (x)) & ~0ULL / 255 * 128);
+        static inline uint64_t hasMore(uint64_t x, uint64_t n) {
+            return (( ((x)+~0ULL/255*(127-(n))) |(x))&~0ULL/255*128);
         }
 
-        static inline uint64_t hasBetween(uint64_t x, uint64_t m, uint64_t n)
-        {
-            return (((~0ULL / 255 * (127 + (n)) - ((x) & ~0ULL / 255 * 127)) & ~(x) & (((x) & ~0ULL / 255 * 127) + ~0ULL / 255 * (127 - (m)))) & ~0ULL / 255 * 128);
+        static inline uint64_t hasBetween(uint64_t x, uint64_t m, uint64_t n) {
+            return (( (~0ULL/255*(127+(n))-((x)&~0ULL/255*127)) &~(x)& (((x)&~0ULL/255*127)+~0ULL/255*(127-(m))) )&~0ULL/255*128);
         }
 
-        static inline bool notFieldNameWord(uint64_t x)
-        {
+        static inline bool notFieldNameWord(uint64_t x) {
             return hasLess(x, '-') |
-                   hasBetween(x, '-', '0') |
-                   hasBetween(x, '9', 'A') |
-                   hasBetween(x, 'Z', 'a') |
-                   hasMore(x, 'z');
+            hasBetween(x, '-', '0') |
+            hasBetween(x, '9', 'A') |
+            hasBetween(x, 'Z', 'a') |
+            hasMore(x, 'z');
         }
 
         /* RFC 9110 5.6.2. Tokens */
@@ -305,392 +314,486 @@ namespace uWS
             return (void *)p;
         }
 
+        static inline int isHTTPorHTTPSPrefixForProxies(char *data, char *end) {
+            // We can check 8 because:
+            // 1. If it's "http://" that's 7 bytes, and it's supposed to at least have a trailing slash.
+            // 2. If it's "https://" that's 8 bytes exactly.
+            if (data + 8 >= end) [[unlikely]] {
+                // if it's not at least 8 bytes, let's try again later
+                return -1;
+            }
+
+            uint64_t http;
+            __builtin_memcpy(&http, data, sizeof(uint64_t));
+            
+            uint32_t first_four_bytes = http & static_cast<uint32_t>(0xFFFFFFFF);
+            // check if any of the first four bytes are > non-ascii
+            if ((first_four_bytes & 0x80808080) != 0) [[unlikely]] {
+                return 0;
+            }
+            first_four_bytes |= 0x20202020; // Lowercase the first four bytes
+            
+            static constexpr char http_lowercase_bytes[4] = {'h', 't', 't', 'p'};
+            static constexpr uint32_t http_lowercase_bytes_int = __builtin_bit_cast(uint32_t, http_lowercase_bytes);
+            if (first_four_bytes == http_lowercase_bytes_int) [[likely]] {
+                if (__builtin_memcmp(reinterpret_cast<char *>(&http) + 4, "://", 3) == 0) [[likely]] {
+                    return 1;
+                }
+
+                static constexpr char s_colon_slash_slash[4] = {'s', ':', '/', '/'};
+                static constexpr uint32_t s_colon_slash_slash_int = __builtin_bit_cast(uint32_t, s_colon_slash_slash);
+
+                static constexpr char S_colon_slash_slash[4] = {'S', ':', '/', '/'};
+                static constexpr uint32_t S_colon_slash_slash_int = __builtin_bit_cast(uint32_t, S_colon_slash_slash);
+              
+                // Extract the last four bytes from the uint64_t
+                const uint32_t last_four_bytes = (http >> 32) & static_cast<uint32_t>(0xFFFFFFFF);
+                return (last_four_bytes == s_colon_slash_slash_int) || (last_four_bytes == S_colon_slash_slash_int);
+            }
+
+            return 0;
+        }
+
         /* Puts method as key, target as value and returns non-null (or nullptr on error). */
-        static inline char *consumeRequestLine(char *data, HttpRequest::Header &header, bool *isAncientHttp)
-        {
-            /* Scan until single SP, assume next is not SP (origin request) */
+        static inline char *consumeRequestLine(char *data, char *end, HttpRequest::Header &header, bool &isAncientHTTP) {
+            /* Scan until single SP, assume next is / (origin request) */
             char *start = data;
             /* This catches the post padded CR and fails */
-            while (data[0] > 32)
-                data++;
-            if (data[0] == 32 && data[1] != 32)
-            {
-                header.key = {start, (size_t)(data - start)};
+            while (data[0] > 32) data++;
+            if (&data[1] == end) [[unlikely]] {
+                return nullptr;
+            }
+            
+            if (data[0] == 32 && (__builtin_expect(data[1] == '/', 1) || isHTTPorHTTPSPrefixForProxies(data + 1, end) == 1)) [[likely]] {
+                header.key = {start, (size_t) (data - start)};
                 data++;
                 /* Scan for less than 33 (catches post padded CR and fails) */
                 start = data;
-                for (; true; data += 8)
-                {
+                for (; true; data += 8) {
                     uint64_t word;
                     memcpy(&word, data, sizeof(uint64_t));
-                    if (hasLess(word, 33))
-                    {
-                        while (*(unsigned char *)data > 32)
-                            data++;
+                    if (hasLess(word, 33)) {
+                        while (*(unsigned char *)data > 32) data++;
                         /* Now we stand on space */
-                        header.value = {start, (size_t)(data - start)};
+                        header.value = {start, (size_t) (data - start)};
                         /* Check that the following is http 1.1 */
-                        if (memcmp(" HTTP/1.1\r\n", data, 11) == 0)
-                        {
-                            *isAncientHttp = false;
+                        if (data + 11 >= end) {
+                            /* Whatever we have must be part of the version string */
+                            if (memcmp(" HTTP/1.1\r\n", data, std::min<unsigned int>(11, (unsigned int) (end - data))) == 0) {
+                                return nullptr;
+                            } else if (memcmp(" HTTP/1.0\r\n", data, std::min<unsigned int>(11, (unsigned int) (end - data))) == 0) {
+                                isAncientHTTP = true;
+                                return data + 11;
+                            }
+                            return (char *) 0x1;
+                        }
+                        if (memcmp(" HTTP/1.1\r\n", data, 11) == 0) {
+                            return data + 11;
+                        } else if (memcmp(" HTTP/1.0\r\n", data, 11) == 0) {
+                            isAncientHTTP = true;
                             return data + 11;
                         }
-                        /* Check that the following is ancient http 1.0 */
-                        if (memcmp(" HTTP/1.0\r\n", data, 11) == 0)
-                        {
-                            *isAncientHttp = true;
-                            return data + 11;
+                        /* If we stand at the post padded CR, we have fragmented input so try again later */
+                        if (data[0] == '\r') {
+                            return nullptr;
                         }
-                        return nullptr;
+                        /* This is an error */
+                        return (char *) 0x1;
                     }
                 }
             }
-            return nullptr;
+
+            /* If we stand at the post padded CR, we have fragmented input so try again later */
+            if (data[0] == '\r') {
+                return nullptr;
+            }
+
+            if (data[0] == 32) {
+                switch (isHTTPorHTTPSPrefixForProxies(data + 1, end)) {
+                    // If we haven't received enough data to check if it's http:// or https://, let's try again later
+                    case -1:
+                        return nullptr;
+                    // Otherwise, if it's not http:// or https://, return 400
+                    default:
+                        return (char *) 0x2;
+                }
+            }
+
+            return (char *) 0x1;
         }
 
         /* RFC 9110: 5.5 Field Values (TLDR; anything above 31 is allowed; htab (9) is also allowed)
-         * Field values are usually constrained to the range of US-ASCII characters [...]
-         * Field values containing CR, LF, or NUL characters are invalid and dangerous [...]
-         * Field values containing other CTL characters are also invalid. */
-        static inline void *tryConsumeFieldValue(char *p)
-        {
-            for (; true; p += 8)
-            {
+        * Field values are usually constrained to the range of US-ASCII characters [...]
+        * Field values containing CR, LF, or NUL characters are invalid and dangerous [...]
+        * Field values containing other CTL characters are also invalid. */
+        static inline void *tryConsumeFieldValue(char *p) {
+            for (; true; p += 8) {
                 uint64_t word;
                 memcpy(&word, p, sizeof(uint64_t));
-                if (hasLess(word, 32))
-                {
-                    while (*(unsigned char *)p > 31)
-                        p++;
+                if (hasLess(word, 32)) {
+                    while (*(unsigned char *)p > 31) p++;
                     return (void *)p;
                 }
             }
         }
 
+        /* End is only used for the proxy parser. The HTTP parser recognizes "\ra" as invalid "\r\n" scan and breaks. */
+        static unsigned int getHeaders(char *postPaddedBuffer, char *end, struct HttpRequest::Header *headers, void *reserved, unsigned int &err, bool &isAncientHTTP) {
+            char *preliminaryKey, *preliminaryValue, *start = postPaddedBuffer;
 
-    /* End is only used for the proxy parser. The HTTP parser recognizes "\ra" as invalid "\r\n" scan and breaks. */
-    static unsigned int getHeaders(char *postPaddedBuffer, char *end, struct HttpRequest::Header *headers, void *reserved, bool*isAncientHttp) {
-        char *preliminaryKey, *preliminaryValue, *start = postPaddedBuffer;
+            #ifdef UWS_WITH_PROXY
+                /* ProxyParser is passed as reserved parameter */
+                ProxyParser *pp = (ProxyParser *) reserved;
 
-#ifdef UWS_WITH_PROXY
-            /* ProxyParser is passed as reserved parameter */
-            ProxyParser *pp = (ProxyParser *)reserved;
-
-            /* Parse PROXY protocol */
-            auto [done, offset] = pp->parse({start, (size_t)(end - postPaddedBuffer)});
-            if (!done)
-            {
-                /* We do not reset the ProxyParser (on filure) since it is tied to this
-                 * connection, which is really only supposed to ever get one PROXY frame
-                 * anyways. We do however allow multiple PROXY frames to be sent (overwrites former). */
-                return 0;
-            }
-            else
-            {
-                /* We have consumed this data so skip it */
-                start += offset;
-            }
-#else
-            /* This one is unused */
-            (void)reserved;
-            (void)end;
-#endif
+                /* Parse PROXY protocol */
+                auto [done, offset] = pp->parse({postPaddedBuffer, (size_t) (end - postPaddedBuffer)});
+                if (!done) {
+                    /* We do not reset the ProxyParser (on filure) since it is tied to this
+                    * connection, which is really only supposed to ever get one PROXY frame
+                    * anyways. We do however allow multiple PROXY frames to be sent (overwrites former). */
+                    return 0;
+                } else {
+                    /* We have consumed this data so skip it */
+                    postPaddedBuffer += offset;
+                }
+            #else
+                /* This one is unused */
+                (void) reserved;
+                (void) end;
+            #endif
 
             /* It is critical for fallback buffering logic that we only return with success
-             * if we managed to parse a complete HTTP request (minus data). Returning success
-             * for PROXY means we can end up succeeding, yet leaving bytes in the fallback buffer
-             * which is then removed, and our counters to flip due to overflow and we end up with a crash */
+            * if we managed to parse a complete HTTP request (minus data). Returning success
+            * for PROXY means we can end up succeeding, yet leaving bytes in the fallback buffer
+            * which is then removed, and our counters to flip due to overflow and we end up with a crash */
 
             /* The request line is different from the field names / field values */
-            if (!(postPaddedBuffer = consumeRequestLine(postPaddedBuffer, headers[0], isAncientHttp)))
-            {
+            if ((char *) 3 > (postPaddedBuffer = consumeRequestLine(postPaddedBuffer, end, headers[0], isAncientHTTP))) {
                 /* Error - invalid request line */
-
+                /* Assuming it is 505 HTTP Version Not Supported */
+                switch (reinterpret_cast<uintptr_t>(postPaddedBuffer)) {
+                    case 0x1:
+                        err = HTTP_ERROR_505_HTTP_VERSION_NOT_SUPPORTED;;
+                        break;
+                    case 0x2:
+                        err = HTTP_ERROR_400_BAD_REQUEST;
+                        break;
+                    default: {
+                        err = 0;
+                        break;
+                    }
+                }
                 return 0;
             }
             headers++;
 
-            for (unsigned int i = 1; i < UWS_HTTP_MAX_HEADERS_COUNT - 1; i++)
-            {
+            for (unsigned int i = 1; i < UWS_HTTP_MAX_HEADERS_COUNT - 1; i++) {
                 /* Lower case and consume the field name */
                 preliminaryKey = postPaddedBuffer;
-                postPaddedBuffer = (char *)consumeFieldName(postPaddedBuffer);
-                headers->key = std::string_view(preliminaryKey, (size_t)(postPaddedBuffer - preliminaryKey));
+                postPaddedBuffer = (char *) consumeFieldName(postPaddedBuffer);
+                headers->key = std::string_view(preliminaryKey, (size_t) (postPaddedBuffer - preliminaryKey));
 
                 /* We should not accept whitespace between key and colon, so colon must foloow immediately */
-                if (postPaddedBuffer[0] != ':')
-                {
+                if (postPaddedBuffer[0] != ':') {
+                    /* If we stand at the end, we are fragmented */
+                    if (postPaddedBuffer == end) {
+                        return 0;
+                    }
                     /* Error: invalid chars in field name */
+                    err = HTTP_ERROR_400_BAD_REQUEST;
                     return 0;
                 }
                 postPaddedBuffer++;
 
                 preliminaryValue = postPaddedBuffer;
                 /* The goal of this call is to find next "\r\n", or any invalid field value chars, fast */
-                while (true)
-                {
-                    postPaddedBuffer = (char *)tryConsumeFieldValue(postPaddedBuffer);
+                while (true) {
+                    postPaddedBuffer = (char *) tryConsumeFieldValue(postPaddedBuffer);
                     /* If this is not CR then we caught some stinky invalid char on the way */
-                    if (postPaddedBuffer[0] != '\r')
-                    {
+                    if (postPaddedBuffer[0] != '\r') {
                         /* If TAB then keep searching */
-                        if (postPaddedBuffer[0] == '\t')
-                        {
+                        if (postPaddedBuffer[0] == '\t') {
                             postPaddedBuffer++;
                             continue;
                         }
                         /* Error - invalid chars in field value */
+                        err = HTTP_ERROR_400_BAD_REQUEST;
                         return 0;
                     }
                     break;
                 }
                 /* We fence end[0] with \r, followed by end[1] being something that is "not \n", to signify "not found".
-                 * This way we can have this one single check to see if we found \r\n WITHIN our allowed search space. */
-                if (postPaddedBuffer[1] == '\n')
-                {
+                    * This way we can have this one single check to see if we found \r\n WITHIN our allowed search space. */
+                if (postPaddedBuffer[1] == '\n') {
                     /* Store this header, it is valid */
-                    headers->value = std::string_view(preliminaryValue, (size_t)(postPaddedBuffer - preliminaryValue));
+                    headers->value = std::string_view(preliminaryValue, (size_t) (postPaddedBuffer - preliminaryValue));
                     postPaddedBuffer += 2;
 
                     /* Trim trailing whitespace (SP, HTAB) */
-                    while (headers->value.length() && headers->value.back() < 33)
-                    {
+                    while (headers->value.length() && headers->value.back() < 33) {
                         headers->value.remove_suffix(1);
                     }
 
                     /* Trim initial whitespace (SP, HTAB) */
-                    while (headers->value.length() && headers->value.front() < 33)
-                    {
+                    while (headers->value.length() && headers->value.front() < 33) {
                         headers->value.remove_prefix(1);
                     }
-
+                    
                     headers++;
 
                     /* We definitely have at least one header (or request line), so check if we are done */
-                    if (*postPaddedBuffer == '\r')
-                    {
-                        if (postPaddedBuffer[1] == '\n')
-                        {
+                    if (*postPaddedBuffer == '\r') {
+                        if (postPaddedBuffer[1] == '\n') {
                             /* This cann take the very last header space */
                             headers->key = std::string_view(nullptr, 0);
-                            return (unsigned int)((postPaddedBuffer + 2) - start);
-                        }
-                        else
-                        {
+                            return (unsigned int) ((postPaddedBuffer + 2) - start);
+                        } else {
                             /* \r\n\r plus non-\n letter is malformed request, or simply out of search space */
+                            if (postPaddedBuffer + 1 < end) {
+                                err = HTTP_ERROR_400_BAD_REQUEST;
+                            }
                             return 0;
                         }
                     }
-                }
-                else
-                {
+                } else {
                     /* We are either out of search space or this is a malformed request */
                     return 0;
                 }
             }
             /* We ran out of header space, too large request */
+            err = HTTP_ERROR_431_REQUEST_HEADER_FIELDS_TOO_LARGE;
             return 0;
         }
 
+    /* This is the only caller of getHeaders and is thus the deepest part of the parser.
+     * From here we return either [consumed, user] for "keep going",
+     * or [consumed, nullptr] for "break; I am closed or upgraded to websocket"
+     * or [whatever, fullptr] for "break and close me, I am a parser error!" */
+    template <int CONSUME_MINIMALLY>
+    std::pair<unsigned int, void *> fenceAndConsumePostPadded(char *data, unsigned int length, void *user, void *reserved, HttpRequest *req, MoveOnlyFunction<void *(void *, HttpRequest *)> &requestHandler, MoveOnlyFunction<void *(void *, std::string_view, bool)> &dataHandler) {
 
-        /* This is the only caller of getHeaders and is thus the deepest part of the parser.
-         * From here we return either [consumed, user] for "keep going",
-         * or [consumed, nullptr] for "break; I am closed or upgraded to websocket"
-         * or [whatever, fullptr] for "break and close me, I am a parser error!" */
-        template<int CONSUME_MINIMALLY>
-        std::pair<unsigned int, void *> fenceAndConsumePostPadded(char *data, unsigned int length, void *user, void *reserved, HttpRequest *req, MoveOnlyFunction<void *(void *, HttpRequest *)> &requestHandler, MoveOnlyFunction<void *(void *, std::string_view, bool)> &dataHandler)
-        {
+        /* How much data we CONSUMED (to throw away) */
+        unsigned int consumedTotal = 0;
+        unsigned int err = 0;
 
-            /* How much data we CONSUMED (to throw away) */
-            unsigned int consumedTotal = 0;
+        /* Fence two bytes past end of our buffer (buffer has post padded margins).
+         * This is to always catch scan for \r but not for \r\n. */
+        data[length] = '\r';
+        data[length + 1] = 'a'; /* Anything that is not \n, to trigger "invalid request" */
+        bool isAncientHTTP = false;
 
-            /* Fence two bytes past end of our buffer (buffer has post padded margins).
-             * This is to always catch scan for \r but not for \r\n. */
-            data[length] = '\r';
-            data[length + 1] = 'a'; /* Anything that is not \n, to trigger "invalid request" */
-            bool isAncientHttp = false;
-            for (unsigned int consumed; length && (consumed = getHeaders(data, data + length, req->headers, reserved, &isAncientHttp));)
-            {
-                data += consumed;
-                length -= consumed;
-                consumedTotal += consumed;
+        for (unsigned int consumed; length && (consumed = getHeaders(data, data + length, req->headers, reserved, err, isAncientHTTP)); ) {
+            data += consumed;
+            length -= consumed;
+            consumedTotal += consumed;
 
-                /* Even if we could parse it, check for length here as well */
-                if (consumed > MAX_FALLBACK_SIZE) {
-                    return {0, FULLPTR};
-                }
+            /* Even if we could parse it, check for length here as well */
+            if (consumed > MAX_FALLBACK_SIZE) {
+                return {HTTP_ERROR_431_REQUEST_HEADER_FIELDS_TOO_LARGE, FULLPTR};
+            }
 
-                /* Store HTTP version (ancient 1.0 or 1.1) */
-                req->ancientHttp = isAncientHttp;
+            /* Store HTTP version (ancient 1.0 or 1.1) */
+            req->ancientHttp = isAncientHTTP;
 
-                /* Add all headers to bloom filter */
-                req->bf.reset();
-                for (HttpRequest::Header *h = req->headers; (++h)->key.length();)
-                {
-                    req->bf.add(h->key);
-                }
+            /* Add all headers to bloom filter */
+            req->bf.reset();
+            for (HttpRequest::Header *h = req->headers; (++h)->key.length(); ) {
+                req->bf.add(h->key);
+            }
+            
+            /* Break if no host header (but we can have empty string which is different from nullptr) */
+            if (!req->getHeader("host").data()) {
+                return {HTTP_ERROR_400_BAD_REQUEST, FULLPTR};
+            }
 
-                /* Break if no host header (but we can have empty string which is different from nullptr) */
-                if (!req->getHeader("host").data())
-                {
-                    return {0, FULLPTR};
-                }
+            /* 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. Such a message might indicate an attempt
+            * to perform request smuggling (Section 11.2) or response splitting (Section 11.1) and
+            * ought to be handled as an error. */
+            std::string_view transferEncodingString = req->getHeader("transfer-encoding");
+            std::string_view contentLengthString = req->getHeader("content-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 */
+                return {HTTP_ERROR_400_BAD_REQUEST, FULLPTR};
+            }
 
-                /* 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. Such a message might indicate an attempt
-                 * to perform request smuggling (Section 11.2) or response splitting (Section 11.1) and
-                 * 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())
-                {
-                    /* 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 */
-                    return {0, FULLPTR};
-                }
-
-                /* 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());
-
-                /* If returned socket is not what we put in we need
-                 * to break here as we either have upgraded to
-                 * WebSockets or otherwise closed the socket. */
-                void *returnedUser = requestHandler(user, req);
-                if (returnedUser != user)
-                {
-                    /* We are upgraded to WebSocket or otherwise broken */
-                    return {consumedTotal, returnedUser};
-                }
-
-                /* The rules at play here according to RFC 9112 for requests are essentially:
-                 * If both content-length and transfer-encoding then invalid message; must break.
-                 * If has transfer-encoding then must be chunked regardless of value.
-                 * If content-length then fixed length even if 0.
-                 * If none of the above then fixed length is 0. */
-
-                /* 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 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
-                     * all forms of transfer-encoding obfuscation tricks. We just rely on the header. */
-
-                    /* RFC 9112 6.3
-                     * If a Transfer-Encoding header field is present in a request and the chunked transfer coding is not the
-                     * final encoding, the message body length cannot be determined reliably; the server MUST respond with the
-                     * 400 (Bad Request) status code and then close the connection. */
-
-                    /* In this case we fail later by having the wrong interpretation (assuming chunked).
-                     * This could be made stricter but makes no difference either way, unless forwarding the identical message as a proxy. */
-
-                    remainingStreamingBytes = STATE_IS_CHUNKED;
-                    /* If consume minimally, we do not want to consume anything but we want to mark this as being chunked */
-                    if (!CONSUME_MINIMALLY)
-                    {
-                        /* Go ahead and parse it (todo: better heuristics for emitting FIN to the app level) */
-                        std::string_view dataToConsume(data, length);
-                        for (auto chunk : uWS::ChunkIterator(&dataToConsume, &remainingStreamingBytes))
-                        {
-                            dataHandler(user, chunk, chunk.length() == 0);
-                        }
-                        if (isParsingInvalidChunkedEncoding(remainingStreamingBytes))
-                        {
-                            return {0, FULLPTR};
-                        }
-                        unsigned int consumed = (length - (unsigned int)dataToConsume.length());
-                        data = (char *)dataToConsume.data();
-                        length = (unsigned int)dataToConsume.length();
-                        consumedTotal += consumed;
-                    }
-                }
-                else if (contentLengthString.length())
-                {
-                    remainingStreamingBytes = toUnsignedInteger(contentLengthString);
-                    if (remainingStreamingBytes == UINT_MAX)
-                    {
-                        /* Parser error */
-                        return {0, FULLPTR};
-                    }
-
-                    if (!CONSUME_MINIMALLY)
-                    {
-                        unsigned int emittable = (unsigned int) std::min<uint64_t>(remainingStreamingBytes, length);
-                        dataHandler(user, std::string_view(data, emittable), emittable == remainingStreamingBytes);
-                        remainingStreamingBytes -= emittable;
-
-                        data += emittable;
-                        length -= emittable;
-                        consumedTotal += emittable;
-                    }
-                }
-                else
-                {
-                    /* If we came here without a body; emit an empty data chunk to signal no data */
-                    dataHandler(user, {}, true);
-                }
-
-                /* Consume minimally should break as easrly as possible */
-                if (CONSUME_MINIMALLY)
-                {
-                    break;
+            /* 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};
                 }
             }
-            return {consumedTotal, user};
-        }
 
-    public:
-        void *consumePostPadded(char *data, unsigned int length, void *user, void *reserved, MoveOnlyFunction<void *(void *, HttpRequest *)> &&requestHandler, MoveOnlyFunction<void *(void *, std::string_view, bool)> &&dataHandler, MoveOnlyFunction<void *(void *)> &&errorHandler)
-        {
-            /* This resets BloomFilter by construction, but later we also reset it again.
-             * Optimize this to skip resetting twice (req could be made global) */
-            HttpRequest req;
+            /* If returned socket is not what we put in we need
+             * to break here as we either have upgraded to
+             * WebSockets or otherwise closed the socket. */
+            void *returnedUser = requestHandler(user, req);
+            if (returnedUser != user) {
+                /* We are upgraded to WebSocket or otherwise broken */
+                return {consumedTotal, returnedUser};
+            }
 
-            if (remainingStreamingBytes)
-            {
+            /* The rules at play here according to RFC 9112 for requests are essentially:
+             * If both content-length and transfer-encoding then invalid message; must break.
+             * If has transfer-encoding then must be chunked regardless of value.
+             * If content-length then fixed length even if 0.
+             * If none of the above then fixed length is 0. */
 
-                /* It's either chunked or with a content-length */
-                if (isParsingChunkedEncoding(remainingStreamingBytes))
-                {
+            /* 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 (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 
+                 * all forms of transfer-encoding obfuscation tricks. We just rely on the header. */
+
+                /* RFC 9112 6.3
+                 * If a Transfer-Encoding header field is present in a request and the chunked transfer coding is not the
+                 * final encoding, the message body length cannot be determined reliably; the server MUST respond with the
+                 * 400 (Bad Request) status code and then close the connection. */
+
+                /* In this case we fail later by having the wrong interpretation (assuming chunked).
+                 * This could be made stricter but makes no difference either way, unless forwarding the identical message as a proxy. */
+
+                remainingStreamingBytes = STATE_IS_CHUNKED;
+                /* If consume minimally, we do not want to consume anything but we want to mark this as being chunked */
+                if (!CONSUME_MINIMALLY) {
+                    /* Go ahead and parse it (todo: better heuristics for emitting FIN to the app level) */
                     std::string_view dataToConsume(data, length);
-                    for (auto chunk : uWS::ChunkIterator(&dataToConsume, &remainingStreamingBytes))
-                    {
+                    for (auto chunk : uWS::ChunkIterator(&dataToConsume, &remainingStreamingBytes)) {
                         dataHandler(user, chunk, chunk.length() == 0);
                     }
-                    if (isParsingInvalidChunkedEncoding(remainingStreamingBytes))
-                    {
-                        return FULLPTR;
+                    if (isParsingInvalidChunkedEncoding(remainingStreamingBytes)) {
+                        // TODO: what happen if we already responded?
+                        return {HTTP_ERROR_400_BAD_REQUEST, FULLPTR};
                     }
-                    data = (char *)dataToConsume.data();
-                    length = (unsigned int)dataToConsume.length();
+                    unsigned int consumed = (length - (unsigned int) dataToConsume.length());
+                    data = (char *) dataToConsume.data();
+                    length = (unsigned int) dataToConsume.length();
+                    consumedTotal += consumed;
                 }
-                else
-                {
-                    // this is exactly the same as below!
-                    // todo: refactor this
-                    if (remainingStreamingBytes >= length)
-                    {
-                        void *returnedUser = dataHandler(user, std::string_view(data, length), remainingStreamingBytes == length);
-                        remainingStreamingBytes -= length;
-                        return returnedUser;
+            } 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);
+                    remainingStreamingBytes -= emittable;
+
+                    data += emittable;
+                    length -= emittable;
+                    consumedTotal += emittable;
+                }
+            } else {
+                /* If we came here without a body; emit an empty data chunk to signal no data */
+                dataHandler(user, {}, true);
+            }
+
+            /* Consume minimally should break as easrly as possible */
+            if (CONSUME_MINIMALLY) {
+                break;
+            }
+        }
+        /* Whenever we return FULLPTR, the interpretation of "consumed" should be the HttpError enum. */
+        if (err) {
+            return {err, FULLPTR};
+        }
+        return {consumedTotal, user};
+    }
+
+public:
+    std::pair<unsigned int, void *> consumePostPadded(char *data, unsigned int length, void *user, void *reserved, MoveOnlyFunction<void *(void *, HttpRequest *)> &&requestHandler, MoveOnlyFunction<void *(void *, std::string_view, bool)> &&dataHandler) {
+
+        /* This resets BloomFilter by construction, but later we also reset it again.
+        * Optimize this to skip resetting twice (req could be made global) */
+        HttpRequest req;
+        if (remainingStreamingBytes) {
+
+            /* It's either chunked or with a content-length */
+            if (isParsingChunkedEncoding(remainingStreamingBytes)) {
+                std::string_view dataToConsume(data, length);
+                for (auto chunk : uWS::ChunkIterator(&dataToConsume, &remainingStreamingBytes)) {
+                    dataHandler(user, chunk, chunk.length() == 0);
+                }
+                if (isParsingInvalidChunkedEncoding(remainingStreamingBytes)) {
+                    return {HTTP_ERROR_400_BAD_REQUEST, FULLPTR};
+                }
+                data = (char *) dataToConsume.data();
+                length = (unsigned int) dataToConsume.length();
+            } else {
+                // this is exactly the same as below!
+                // todo: refactor this
+                if (remainingStreamingBytes >= length) {
+                    void *returnedUser = dataHandler(user, std::string_view(data, length), remainingStreamingBytes == length);
+                    remainingStreamingBytes -= length;
+                    return {0, returnedUser};
+                } else {
+                    void *returnedUser = dataHandler(user, std::string_view(data, remainingStreamingBytes), true);
+
+                    data += (unsigned int) remainingStreamingBytes;
+                    length -= (unsigned int) remainingStreamingBytes;
+
+                    remainingStreamingBytes = 0;
+
+                    if (returnedUser != user) {
+                        return {0, returnedUser};
                     }
-                    else
-                    {
-                        void *returnedUser = dataHandler(user, std::string_view(data, remainingStreamingBytes), true);
+                }
+            }
 
-                        data += (unsigned int) remainingStreamingBytes;
-                        length -= (unsigned int) remainingStreamingBytes;
+        } else if (fallback.length()) {
+            unsigned int had = (unsigned int) fallback.length();
 
-                        remainingStreamingBytes = 0;
+            size_t maxCopyDistance = std::min<size_t>(MAX_FALLBACK_SIZE - fallback.length(), (size_t) length);
 
-                        if (returnedUser != user)
-                        {
-                            return returnedUser;
+            /* We don't want fallback to be short string optimized, since we want to move it */
+            fallback.reserve(fallback.length() + maxCopyDistance + std::max<unsigned int>(MINIMUM_HTTP_POST_PADDING, sizeof(std::string)));
+            fallback.append(data, maxCopyDistance);
+
+            // break here on break
+            std::pair<unsigned int, void *> consumed = fenceAndConsumePostPadded<true>(fallback.data(), (unsigned int) fallback.length(), user, reserved, &req, requestHandler, dataHandler);
+            if (consumed.second != user) {
+                return consumed;
+            }
+
+            if (consumed.first) {
+
+                /* This logic assumes that we consumed everything in fallback buffer.
+                * This is critically important, as we will get an integer overflow in case
+                * of "had" being larger than what we consumed, and that we would drop data */
+                fallback.clear();
+                data += consumed.first - had;
+                length -= consumed.first - had;
+
+                if (remainingStreamingBytes) {
+                    /* It's either chunked or with a content-length */
+                    if (isParsingChunkedEncoding(remainingStreamingBytes)) {
+                        std::string_view dataToConsume(data, length);
+                        for (auto chunk : uWS::ChunkIterator(&dataToConsume, &remainingStreamingBytes)) {
+                            dataHandler(user, chunk, chunk.length() == 0);
+                        }
+                        if (isParsingInvalidChunkedEncoding(remainingStreamingBytes)) {
+                            return {HTTP_ERROR_400_BAD_REQUEST, FULLPTR};
+                        }
+                        data = (char *) dataToConsume.data();
+                        length = (unsigned int) dataToConsume.length();
+                    } else {
+                        // this is exactly the same as above!
+                        if (remainingStreamingBytes >= (unsigned int) length) {
+                            void *returnedUser = dataHandler(user, std::string_view(data, length), remainingStreamingBytes == (unsigned int) length);
+                            remainingStreamingBytes -= length;
+                            return {0, returnedUser};
                         } else {
                             void *returnedUser = dataHandler(user, std::string_view(data, remainingStreamingBytes), true);
 
@@ -700,120 +803,40 @@ namespace uWS
                             remainingStreamingBytes = 0;
 
                             if (returnedUser != user) {
-                                return returnedUser;
+                                return {0, returnedUser};
                             }
                         }
                     }
                 }
+
+            } else {
+                if (fallback.length() == MAX_FALLBACK_SIZE) {
+                    return {HTTP_ERROR_431_REQUEST_HEADER_FIELDS_TOO_LARGE, FULLPTR};
+                }
+                return {0, user};
             }
-            else if (fallback.length())
-            {
-                unsigned int had = (unsigned int)fallback.length();
-
-                size_t maxCopyDistance = std::min<size_t>(MAX_FALLBACK_SIZE - fallback.length(), (size_t)length);
-
-                /* We don't want fallback to be short string optimized, since we want to move it */
-                fallback.reserve(fallback.length() + maxCopyDistance + std::max<unsigned int>(MINIMUM_HTTP_POST_PADDING, sizeof(std::string)));
-                fallback.append(data, maxCopyDistance);
-
-                // break here on break
-                std::pair<unsigned int, void *> consumed = fenceAndConsumePostPadded<true>(fallback.data(), (unsigned int)fallback.length(), user, reserved, &req, requestHandler, dataHandler);
-                if (consumed.second != user)
-                {
-                    return consumed.second;
-                }
-
-                if (consumed.first)
-                {
-
-                    /* This logic assumes that we consumed everything in fallback buffer.
-                     * This is critically important, as we will get an integer overflow in case
-                     * of "had" being larger than what we consumed, and that we would drop data */
-                    fallback.clear();
-                    data += consumed.first - had;
-                    length -= consumed.first - had;
-
-                    if (remainingStreamingBytes)
-                    {
-                        /* It's either chunked or with a content-length */
-                        if (isParsingChunkedEncoding(remainingStreamingBytes))
-                        {
-                            std::string_view dataToConsume(data, length);
-                            for (auto chunk : uWS::ChunkIterator(&dataToConsume, &remainingStreamingBytes))
-                            {
-                                dataHandler(user, chunk, chunk.length() == 0);
-                            }
-                            if (isParsingInvalidChunkedEncoding(remainingStreamingBytes))
-                            {
-                                return FULLPTR;
-                            }
-                            data = (char *)dataToConsume.data();
-                            length = (unsigned int)dataToConsume.length();
-                        }
-                        else
-                        {
-                            // this is exactly the same as above!
-                            if (remainingStreamingBytes >= (unsigned int)length)
-                            {
-                                void *returnedUser = dataHandler(user, std::string_view(data, length), remainingStreamingBytes == (unsigned int)length);
-                                remainingStreamingBytes -= length;
-                                return returnedUser;
-                            }
-                            else
-                            {
-                                void *returnedUser = dataHandler(user, std::string_view(data, remainingStreamingBytes), true);
-
-                                data += remainingStreamingBytes;
-                                length -= remainingStreamingBytes;
-
-                                remainingStreamingBytes = 0;
-
-                                if (returnedUser != user)
-                                {
-                                    return returnedUser;
-                                }
-                            }
-                        }
-                    }
-                }
-                else
-                {
-                    if (fallback.length() == MAX_FALLBACK_SIZE)
-                    {
-                        // note: you don't really need error handler, just return something strange!
-                        // we could have it return a constant pointer to denote error!
-                        return errorHandler(user);
-                    }
-                    return user;
-                }
-            }
-
-            std::pair<unsigned int, void *> consumed = fenceAndConsumePostPadded<false>(data, length, user, reserved, &req, requestHandler, dataHandler);
-            if (consumed.second != user)
-            {
-                return consumed.second;
-            }
-
-            data += consumed.first;
-            length -= consumed.first;
-
-            if (length)
-            {
-                if (length < MAX_FALLBACK_SIZE)
-                {
-                    fallback.append(data, length);
-                }
-                else
-                {
-                    return errorHandler(user);
-                }
-            }
-
-            // added for now
-            return user;
         }
-    };
+
+        std::pair<unsigned int, void *> consumed = fenceAndConsumePostPadded<false>(data, length, user, reserved, &req, requestHandler, dataHandler);
+        if (consumed.second != user) {
+            return consumed;
+        }
+
+        data += consumed.first;
+        length -= consumed.first;
+
+        if (length) {
+            if (length < MAX_FALLBACK_SIZE) {
+                fallback.append(data, length);
+            } else {
+                return {HTTP_ERROR_431_REQUEST_HEADER_FIELDS_TOO_LARGE, FULLPTR};
+            }
+        }
+
+        // added for now
+        return {0, user};
+    }
+};
 
 }
 
-#endif // UWS_HTTPPARSER_H
diff --git a/packages/bun-uws/src/HttpResponseData.h b/packages/bun-uws/src/HttpResponseData.h
index 9613e84fe4..b4c3195f26 100644
--- a/packages/bun-uws/src/HttpResponseData.h
+++ b/packages/bun-uws/src/HttpResponseData.h
@@ -15,8 +15,7 @@
  * limitations under the License.
  */
 // clang-format off
-#ifndef UWS_HTTPRESPONSEDATA_H
-#define UWS_HTTPRESPONSEDATA_H
+#pragma once
 
 /* This data belongs to the HttpResponse */
 
@@ -106,4 +105,4 @@ struct HttpResponseData : AsyncSocketData<SSL>, HttpParser {
 
 }
 
-#endif // UWS_HTTPRESPONSEDATA_H
+
diff --git a/packages/bun-uws/src/TopicTree.h b/packages/bun-uws/src/TopicTree.h
index 215afd28b2..69855cf9fc 100644
--- a/packages/bun-uws/src/TopicTree.h
+++ b/packages/bun-uws/src/TopicTree.h
@@ -15,9 +15,7 @@
  * limitations under the License.
  */
 
-#ifndef UWS_TOPICTREE_H
-#define UWS_TOPICTREE_H
-
+#pragma once
 #include <map>
 #include <list>
 #include <iostream>
@@ -366,4 +364,4 @@ public:
 
 }
 
-#endif
+
diff --git a/packages/bun-vscode/README.md b/packages/bun-vscode/README.md
index 6848f89771..bd8266b296 100644
--- a/packages/bun-vscode/README.md
+++ b/packages/bun-vscode/README.md
@@ -19,6 +19,26 @@ At its core is the _Bun runtime_, a fast JavaScript runtime designed as a drop-i
   <br/>
 </div>
 
+## Features:
+
+- Live in-editor error messages (gif below)
+- Test runner codelens
+- Debugger support
+- Run scripts from package.json
+- Visual lockfile viewer (`bun.lockb`)
+
+## In-editor error messages
+
+When running programs with Bun from a Visual Studio Code terminal, Bun will connect to the extension and report errors as they happen, at the exact location they happened. We recommend using this feature with `bun --watch` so you can see errors on every save.
+
+![Error messages example](./error-messages.gif)
+
+<div align="center">
+<sup>In the example above VSCode is saving on every keypress. Under normal configuration you'd only see errors on every save.</sup>
+</div>
+
+Errors are cleared whenever you start typing, or whenever the extension detects that Bun just started running (or reloading) a new program.
+
 ## Configuration
 
 ### `.vscode/launch.json`
@@ -75,8 +95,8 @@ You can use the following configurations to debug JavaScript and TypeScript file
       // The URL of the WebSocket inspector to attach to.
       // This value can be retrieved by using `bun --inspect`.
       "url": "ws://localhost:6499/",
-    }
-  ]
+    },
+  ],
 }
 ```
 
@@ -91,8 +111,11 @@ You can use the following configurations to customize the behavior of the Bun ex
 
   // If support for Bun should be added to the default "JavaScript Debug Terminal".
   "bun.debugTerminal.enabled": true,
-  
+
   // If the debugger should stop on the first line of the program.
   "bun.debugTerminal.stopOnEntry": false,
+
+  // Glob pattern to find test files. Defaults to the value shown below.
+  "bun.test.filePattern": "**/*{.test.,.spec.,_test_,_spec_}{js,ts,tsx,jsx,mts,cts}",
 }
-```
\ No newline at end of file
+```
diff --git a/packages/bun-vscode/error-messages.gif b/packages/bun-vscode/error-messages.gif
new file mode 100644
index 0000000000..d81b32cc64
Binary files /dev/null and b/packages/bun-vscode/error-messages.gif differ
diff --git a/packages/bun-vscode/example/.gitignore b/packages/bun-vscode/example/.gitignore
new file mode 100644
index 0000000000..3867a4f345
--- /dev/null
+++ b/packages/bun-vscode/example/.gitignore
@@ -0,0 +1,3 @@
+.bake-debug
+dist
+node_modules
\ No newline at end of file
diff --git a/packages/bun-vscode/example/bake-test/bun.app.ts b/packages/bun-vscode/example/bake-test/bun.app.ts
new file mode 100644
index 0000000000..2bc7296116
--- /dev/null
+++ b/packages/bun-vscode/example/bake-test/bun.app.ts
@@ -0,0 +1,6 @@
+export default {
+  port: 3000,
+  app: {
+    framework: "react",
+  },
+};
diff --git a/packages/bun-vscode/example/bake-test/pages/_layout.tsx b/packages/bun-vscode/example/bake-test/pages/_layout.tsx
new file mode 100644
index 0000000000..257ebfe123
--- /dev/null
+++ b/packages/bun-vscode/example/bake-test/pages/_layout.tsx
@@ -0,0 +1,10 @@
+import { PropsWithChildren } from "react";
+
+export default function Layout({ children }: PropsWithChildren) {
+  return (
+    <div>
+      {children}
+      <footer>some rights reserved - {new Date().toString()}</footer>
+    </div>
+  );
+}
diff --git a/packages/bun-vscode/example/bake-test/pages/index.tsx b/packages/bun-vscode/example/bake-test/pages/index.tsx
new file mode 100644
index 0000000000..2923ba7473
--- /dev/null
+++ b/packages/bun-vscode/example/bake-test/pages/index.tsx
@@ -0,0 +1,17 @@
+"use client";
+
+
+import { useState } from "react";
+
+function App() {
+	const [count, setCount] = useState(null);
+
+	return (
+		<>
+      {/* @ts-expect-error */}
+		  <button onClick={() => setCount(count => count.charAt(0))}>count is {count}</button>
+		</>
+	);
+}
+
+export default App;
\ No newline at end of file
diff --git a/packages/bun-vscode/example/bake-test/pages/two.tsx b/packages/bun-vscode/example/bake-test/pages/two.tsx
new file mode 100644
index 0000000000..4fabda4a0d
--- /dev/null
+++ b/packages/bun-vscode/example/bake-test/pages/two.tsx
@@ -0,0 +1,3 @@
+export default function Two() {
+  return <p>Wow a second page! Bake is groundbreaking</p>;
+}
diff --git a/packages/bun-vscode/example/bug-preload.js b/packages/bun-vscode/example/bug-preload.js
new file mode 100644
index 0000000000..80584c303b
--- /dev/null
+++ b/packages/bun-vscode/example/bug-preload.js
@@ -0,0 +1 @@
+Math.max = undefined;
diff --git a/packages/bun-vscode/example/bun.lockb b/packages/bun-vscode/example/bun.lockb
index 7153db03e2..a69ab58180 100755
Binary files a/packages/bun-vscode/example/bun.lockb and b/packages/bun-vscode/example/bun.lockb differ
diff --git a/packages/bun-vscode/example/example.test.ts b/packages/bun-vscode/example/example.test.ts
index 2d6dc8b100..089fc742e5 100644
--- a/packages/bun-vscode/example/example.test.ts
+++ b/packages/bun-vscode/example/example.test.ts
@@ -3,10 +3,13 @@ import { describe, expect, test } from "bun:test";
 describe("example", () => {
   test("it works", () => {
     expect(1).toBe(1);
-    expect(1).not.toBe(2);
+
+    expect(10).toBe(10);
+
     expect(() => {
       throw new TypeError("Oops! I did it again.");
     }).toThrow();
+
     expect(() => {
       throw new Error("Parent error.", {
         cause: new TypeError("Child error."),
diff --git a/packages/bun-vscode/example/hello.ts b/packages/bun-vscode/example/hello.ts
index ee960a9c69..a5820812c3 100644
--- a/packages/bun-vscode/example/hello.ts
+++ b/packages/bun-vscode/example/hello.ts
@@ -1,7 +1,7 @@
-type OS = "Windows";
+import * as os from "node:os";
 
 Bun.serve({
   fetch(req: Request) {
-    return new Response(`Hello, ${"Windows" as OS}!`);
+    return new Response(`Hello from ${os.arch()}!`);
   },
 });
diff --git a/packages/bun-vscode/example/package.json b/packages/bun-vscode/example/package.json
index f9a909752b..5ca95a9ca9 100644
--- a/packages/bun-vscode/example/package.json
+++ b/packages/bun-vscode/example/package.json
@@ -2,10 +2,16 @@
   "private": true,
   "name": "example",
   "dependencies": {
+    "axios": "^1.7.7",
     "elysia": "^0.6.3",
     "express": "^4.18.2",
     "mime": "^3.0.0",
-    "mime-db": "^1.52.0"
+    "mime-db": "^1.52.0",
+    "react": "^0.0.0-experimental-380f5d67-20241113",
+    "react-dom": "^0.0.0-experimental-380f5d67-20241113",
+    "react-refresh": "^0.0.0-experimental-380f5d67-20241113",
+    "react-server-dom-bun": "^0.0.0-experimental-603e6108-20241029",
+    "react-server-dom-webpack": "^0.0.0-experimental-380f5d67-20241113"
   },
   "scripts": {
     "run": "node hello.js",
diff --git a/packages/bun-vscode/example/print.ts b/packages/bun-vscode/example/print.ts
new file mode 100644
index 0000000000..1d7fd09a66
--- /dev/null
+++ b/packages/bun-vscode/example/print.ts
@@ -0,0 +1,7 @@
+function getOldestPersonInBooking(ages: number[]): number {
+  console.log("ok");
+  throw new Error("TODO! Perhaps we can use Math.max() for this?");
+}
+
+const ticketAges = [5, 25, 30];
+console.log(getOldestPersonInBooking(ticketAges));
diff --git a/packages/bun-vscode/example/test.ts b/packages/bun-vscode/example/test.ts
new file mode 100644
index 0000000000..615b0abbd7
--- /dev/null
+++ b/packages/bun-vscode/example/test.ts
@@ -0,0 +1,9 @@
+import axios from "axios";
+
+async function foo() {
+  const res = await axios.get("http://example.com");
+
+  throw new Error("potato");
+}
+
+console.log(await foo());
diff --git a/packages/bun-vscode/example/tsconfig.json b/packages/bun-vscode/example/tsconfig.json
index 1449bc3d93..7eff589c74 100644
--- a/packages/bun-vscode/example/tsconfig.json
+++ b/packages/bun-vscode/example/tsconfig.json
@@ -14,9 +14,6 @@
     "jsx": "preserve",
     "allowSyntheticDefaultImports": true,
     "forceConsistentCasingInFileNames": true,
-    "allowJs": true,
-    "types": [
-      "bun-types" // add Bun global
-    ]
+    "allowJs": true
   }
 }
diff --git a/packages/bun-vscode/example/user.ts b/packages/bun-vscode/example/user.ts
new file mode 100644
index 0000000000..34402e95fa
--- /dev/null
+++ b/packages/bun-vscode/example/user.ts
@@ -0,0 +1,13 @@
+// await Bun.sleep(100);
+
+interface User {
+  name: string;
+}
+
+const user = {
+  name: "Alistair",
+} as User;
+
+console.log(`First letter us '${user.name.charAt(0)}'`);
+
+await Bun.sleep(100);
diff --git a/packages/bun-vscode/package.json b/packages/bun-vscode/package.json
index 23ace8a229..7843c4c722 100644
--- a/packages/bun-vscode/package.json
+++ b/packages/bun-vscode/package.json
@@ -1,6 +1,6 @@
 {
   "name": "bun-vscode",
-  "version": "0.0.15",
+  "version": "0.0.22",
   "author": "oven",
   "repository": {
     "type": "git",
@@ -18,48 +18,9 @@
     "esbuild": "^0.19.2",
     "typescript": "^5.0.0"
   },
-  "description": "The Visual Studio Code extension for Bun.",
-  "displayName": "Bun for Visual Studio Code",
-  "engines": {
-    "vscode": "^1.60.0"
-  },
-  "extensionKind": [
-    "workspace"
-  ],
-  "galleryBanner": {
-    "color": "#3B3738",
-    "theme": "dark"
-  },
-  "homepage": "https://bun.sh/",
-  "icon": "assets/icon.png",
-  "keywords": [
-    "bun",
-    "node.js",
-    "javascript",
-    "typescript",
-    "vscode"
-  ],
-  "license": "MIT",
-  "publisher": "oven",
-  "scripts": {
-    "build": "node scripts/build.mjs",
-    "pretest": "bun run build",
-    "test": "node scripts/test.mjs",
-    "dev": "vscode-test --config scripts/dev.mjs",
-    "prepublish": "npm version patch && bun run build",
-    "publish": "cd extension && bunx vsce publish"
-  },
-  "workspaceTrust": {
-    "request": "never"
-  },
-  "workspaces": [
-    "../bun-debug-adapter-protocol",
-    "../bun-inspector-protocol"
-  ],
   "activationEvents": [
     "onStartupFinished"
   ],
-  "browser": "dist/web-extension.js",
   "bugs": {
     "url": "https://github.com/oven-sh/bun/issues"
   },
@@ -84,6 +45,18 @@
           "scope": "window",
           "default": null
         },
+        "bun.diagnosticsSocket.enabled": {
+          "type": "boolean",
+          "description": "If Bun extension should communicate with Bun over a socket to show errors in editor.",
+          "scope": "window",
+          "default": true
+        },
+        "bun.bunlockb.enabled": {
+          "type": "boolean",
+          "description": "If visual lockfile viewer (`bun.lockb`) should be enabled ",
+          "scope": "window",
+          "default": true
+        },
         "bun.debugTerminal.enabled": {
           "type": "boolean",
           "description": "If Bun should be added to the JavaScript Debug Terminal.",
@@ -95,6 +68,21 @@
           "description": "If the debugger should stop on the first line when used in the JavaScript Debug Terminal.",
           "scope": "window",
           "default": false
+        },
+        "bun.test.filePattern": {
+          "type": "string",
+          "default": "**/*{.test.,.spec.,_test_,_spec_}{js,ts,tsx,jsx,mts,cts}",
+          "description": "Glob pattern to find test files"
+        },
+        "bun.test.customFlag": {
+          "type": "string",
+          "default": "",
+          "description": "Custom flag added to the end of test command"
+        },
+        "bun.test.customScript": {
+          "type": "string",
+          "default": "",
+          "description": "Custom script to use instead of `bun test`, for example script from `package.json`"
         }
       }
     },
@@ -114,6 +102,28 @@
         "category": "Bun",
         "enablement": "!inDebugMode",
         "icon": "$(debug-alt)"
+      },
+      {
+        "command": "extension.bun.runUnsavedCode",
+        "title": "Run Unsaved Code with Bun",
+        "shortTitle": "Run with Bun",
+        "category": "Bun",
+        "enablement": "!inDebugMode && resourceLangId =~ /^(javascript|typescript|javascriptreact|typescriptreact)$/ && !isInDiffEditor && resourceScheme == 'untitled'",
+        "icon": "$(play-circle)"
+      },
+      {
+        "command": "extension.bun.runTest",
+        "title": "Run all tests",
+        "shortTitle": "Run Test",
+        "category": "Bun",
+        "icon": "$(play)"
+      },
+      {
+        "command": "extension.bun.watchTest",
+        "title": "Run all tests in watch mode",
+        "shortTitle": "Run Test Watch",
+        "category": "Bun",
+        "icon": "$(sync)"
       }
     ],
     "menus": {
@@ -138,6 +148,20 @@
           "command": "extension.bun.debugFile",
           "when": "resourceLangId == javascript || resourceLangId == javascriptreact || resourceLangId == typescript || resourceLangId == typescriptreact"
         }
+      ],
+      "editor/title": [
+        {
+          "command": "extension.bun.runUnsavedCode",
+          "when": "resourceLangId =~ /^(javascript|typescript|javascriptreact|typescriptreact)$/ && !isInDiffEditor && resourceScheme == 'untitled'",
+          "group": "navigation"
+        }
+      ],
+      "editor/context": [
+        {
+          "command": "extension.bun.runUnsavedCode",
+          "when": "resourceLangId =~ /^(javascript|typescript|javascriptreact|typescriptreact)$/ && !isInDiffEditor && resourceScheme == 'untitled'",
+          "group": "1_run"
+        }
       ]
     },
     "breakpoints": [
@@ -306,5 +330,43 @@
         }
       }
     ]
-  }
-}
+  },
+  "description": "The Visual Studio Code extension for Bun.",
+  "displayName": "Bun",
+  "engines": {
+    "vscode": "^1.60.0"
+  },
+  "extensionKind": [
+    "workspace"
+  ],
+  "galleryBanner": {
+    "color": "#3B3738",
+    "theme": "dark"
+  },
+  "homepage": "https://bun.sh/",
+  "icon": "assets/icon.png",
+  "keywords": [
+    "bun",
+    "node.js",
+    "javascript",
+    "typescript",
+    "vscode"
+  ],
+  "license": "MIT",
+  "publisher": "oven",
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "pretest": "bun run build",
+    "test": "node scripts/test.mjs",
+    "dev": "vscode-test --config scripts/dev.mjs",
+    "prepublish": "npm version patch && bun run build",
+    "publish": "cd extension && bunx vsce publish"
+  },
+  "workspaceTrust": {
+    "request": "never"
+  },
+  "workspaces": [
+    "../bun-debug-adapter-protocol",
+    "../bun-inspector-protocol"
+  ]
+}
\ No newline at end of file
diff --git a/packages/bun-vscode/src/extension.ts b/packages/bun-vscode/src/extension.ts
index fc1abe4240..8917a36f8d 100644
--- a/packages/bun-vscode/src/extension.ts
+++ b/packages/bun-vscode/src/extension.ts
@@ -1,14 +1,59 @@
 import * as vscode from "vscode";
 import { registerDebugger } from "./features/debug";
+import { registerDiagnosticsSocket } from "./features/diagnostics/diagnostics";
 import { registerBunlockEditor } from "./features/lockfile";
 import { registerPackageJsonProviders } from "./features/tasks/package.json";
 import { registerTaskProvider } from "./features/tasks/tasks";
+import { registerTestCodeLens, registerTestRunner } from "./features/tests";
+
+async function runUnsavedCode() {
+  const editor = vscode.window.activeTextEditor;
+  if (!editor || !editor.document.isUntitled) {
+    return;
+  }
+
+  const document = editor.document;
+  if (!["javascript", "typescript", "javascriptreact", "typescriptreact"].includes(document.languageId)) {
+    return;
+  }
+
+  const code = document.getText();
+  const cwd = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath || process.cwd();
+
+  // Get the actual untitled document name
+  const untitledName = `untitled:${document.uri.path}`;
+
+  // Create a temporary debug session without saving
+  await vscode.debug.startDebugging(
+    undefined,
+    {
+      type: "bun",
+      name: "Run Unsaved Code",
+      request: "launch",
+      program: "-", // Special flag to indicate stdin input
+      __code: code, // Pass the code through configuration
+      __untitledName: untitledName, // Pass the untitled document name
+      cwd, // Pass the current working directory
+    },
+    {
+      suppressSaveBeforeStart: true, // This prevents the save dialog
+    },
+  );
+}
 
 export function activate(context: vscode.ExtensionContext) {
   registerBunlockEditor(context);
   registerDebugger(context);
   registerTaskProvider(context);
   registerPackageJsonProviders(context);
+  registerDiagnosticsSocket(context);
+  registerTestRunner(context);
+  registerTestCodeLens(context);
+
+  // Only register for text editors
+  context.subscriptions.push(vscode.commands.registerTextEditorCommand("extension.bun.runUnsavedCode", runUnsavedCode));
 }
 
-export function deactivate() {}
+export function getConfig<T>(path: string, scope?: vscode.ConfigurationScope) {
+  return vscode.workspace.getConfiguration("bun", scope).get<T>(path);
+}
diff --git a/packages/bun-vscode/src/features/debug.ts b/packages/bun-vscode/src/features/debug.ts
index 2dd68c8695..a48284dea3 100644
--- a/packages/bun-vscode/src/features/debug.ts
+++ b/packages/bun-vscode/src/features/debug.ts
@@ -1,14 +1,16 @@
-import { DebugSession } from "@vscode/debugadapter";
+import { DebugSession, OutputEvent } from "@vscode/debugadapter";
 import { tmpdir } from "node:os";
+import { join } from "node:path";
 import * as vscode from "vscode";
 import {
-  DAP,
-  DebugAdapter,
+  type DAP,
   getAvailablePort,
   getRandomId,
   TCPSocketSignal,
   UnixSignal,
+  WebSocketDebugAdapter,
 } from "../../../bun-debug-adapter-protocol";
+import { getConfig } from "../extension";
 
 export const DEBUG_CONFIGURATION: vscode.DebugConfiguration = {
   type: "bun",
@@ -45,6 +47,10 @@ const adapters = new Map<string, FileDebugSession>();
 
 export function registerDebugger(context: vscode.ExtensionContext, factory?: vscode.DebugAdapterDescriptorFactory) {
   context.subscriptions.push(
+    vscode.languages.registerCodeLensProvider(
+      ["javascript", "typescript", "javascriptreact", "typescriptreact"],
+      new BunCodeLensProvider(),
+    ),
     vscode.commands.registerCommand("extension.bun.runFile", runFileCommand),
     vscode.commands.registerCommand("extension.bun.debugFile", debugFileCommand),
     vscode.debug.registerDebugConfigurationProvider(
@@ -96,16 +102,18 @@ async function injectDebugTerminal(terminal: vscode.Terminal): Promise<void> {
   }
 
   const { env } = creationOptions as vscode.TerminalOptions;
-  if (env["BUN_INSPECT"]) {
+  if (env && env["BUN_INSPECT"]) {
     return;
   }
 
+  const session = new TerminalDebugSession();
+  await session.initialize();
+
+  const { adapter, signal } = session;
+
   const stopOnEntry = getConfig("debugTerminal.stopOnEntry") === true;
   const query = stopOnEntry ? "break=1" : "wait=1";
 
-  const debugSession = new TerminalDebugSession();
-  await debugSession.initialize();
-  const { adapter, signal } = debugSession;
   const debug = vscode.window.createTerminal({
     ...creationOptions,
     name: "JavaScript Debug Terminal",
@@ -113,6 +121,7 @@ async function injectDebugTerminal(terminal: vscode.Terminal): Promise<void> {
       ...env,
       "BUN_INSPECT": `${adapter.url}?${query}`,
       "BUN_INSPECT_NOTIFY": signal.url,
+      BUN_INSPECT_CONNECT_TO: "",
     },
   });
 
@@ -144,7 +153,15 @@ class DebugConfigurationProvider implements vscode.DebugConfigurationProvider {
       target = DEBUG_CONFIGURATION;
     }
 
-    // If the configuration is missing a default property, copy it from the template.
+    if (config.program === "-" && config.__code) {
+      const code = config.__code;
+      delete config.__code;
+
+      config.stdin = code;
+      config.program = "-";
+      config.__skipValidation = true;
+    }
+
     for (const [key, value] of Object.entries(target)) {
       if (config[key] === undefined) {
         config[key] = value;
@@ -165,7 +182,7 @@ class InlineDebugAdapterFactory implements vscode.DebugAdapterDescriptorFactory
     session: vscode.DebugSession,
   ): Promise<vscode.ProviderResult<vscode.DebugAdapterDescriptor>> {
     const { configuration } = session;
-    const { request, url } = configuration;
+    const { request, url, __untitledName } = configuration;
 
     if (request === "attach") {
       for (const [adapterUrl, adapter] of adapters) {
@@ -175,32 +192,108 @@ class InlineDebugAdapterFactory implements vscode.DebugAdapterDescriptorFactory
       }
     }
 
-    const adapter = new FileDebugSession(session.id);
+    const adapter = new FileDebugSession(session.id, __untitledName);
     await adapter.initialize();
     return new vscode.DebugAdapterInlineImplementation(adapter);
   }
 }
 
-class FileDebugSession extends DebugSession {
-  adapter: DebugAdapter;
-  sessionId?: string;
+interface DebugProtocolResponse extends DAP.Response {
+  body?: {
+    source?: {
+      path?: string;
+    };
+    breakpoints?: Array<{
+      source?: {
+        path?: string;
+      };
+      verified?: boolean;
+    }>;
+  };
+}
 
-  constructor(sessionId?: string) {
+interface DebugProtocolEvent extends DAP.Event {
+  body?: {
+    source?: {
+      path?: string;
+    };
+  };
+}
+
+interface RuntimeConsoleAPICalledEvent {
+  type: string;
+  args: Array<{
+    type: string;
+    value: any;
+  }>;
+}
+
+interface RuntimeExceptionThrownEvent {
+  exceptionDetails: {
+    text: string;
+    exception?: {
+      description?: string;
+    };
+  };
+}
+
+class FileDebugSession extends DebugSession {
+  // If these classes are moved/published, we should make sure
+  // we remove these non-null assertions so consumers of
+  // this lib are not running into these hard
+  adapter!: WebSocketDebugAdapter;
+  sessionId?: string;
+  untitledDocPath?: string;
+  bunEvalPath?: string;
+
+  constructor(sessionId?: string, untitledDocPath?: string) {
     super();
     this.sessionId = sessionId;
+    this.untitledDocPath = untitledDocPath;
+
+    if (untitledDocPath) {
+      const cwd = vscode.workspace.workspaceFolders?.[0]?.uri?.fsPath ?? process.cwd();
+      this.bunEvalPath = join(cwd, "[eval]");
+    }
   }
 
   async initialize() {
     const uniqueId = this.sessionId ?? Math.random().toString(36).slice(2);
-    let url;
-    if (process.platform === "win32") {
-      url = `ws://127.0.0.1:${await getAvailablePort()}/${getRandomId()}`;
+    const url =
+      process.platform === "win32"
+        ? `ws://127.0.0.1:${await getAvailablePort()}/${getRandomId()}`
+        : `ws+unix://${tmpdir()}/${uniqueId}.sock`;
+
+    const { untitledDocPath, bunEvalPath } = this;
+    this.adapter = new WebSocketDebugAdapter(url, untitledDocPath, bunEvalPath);
+
+    if (untitledDocPath) {
+      this.adapter.on("Adapter.response", (response: DebugProtocolResponse) => {
+        if (response.body?.source?.path === bunEvalPath) {
+          response.body.source.path = untitledDocPath;
+        }
+        if (Array.isArray(response.body?.breakpoints)) {
+          for (const bp of response.body.breakpoints) {
+            if (bp.source?.path === bunEvalPath) {
+              bp.source.path = untitledDocPath;
+              bp.verified = true;
+            }
+          }
+        }
+        this.sendResponse(response);
+      });
+
+      this.adapter.on("Adapter.event", (event: DebugProtocolEvent) => {
+        if (event.body?.source?.path === bunEvalPath) {
+          event.body.source.path = untitledDocPath;
+        }
+        this.sendEvent(event);
+      });
     } else {
-      url = `ws+unix://${tmpdir()}/${uniqueId}.sock`;
+      this.adapter.on("Adapter.response", response => this.sendResponse(response));
+      this.adapter.on("Adapter.event", event => this.sendEvent(event));
     }
-    this.adapter = new DebugAdapter(url);
-    this.adapter.on("Adapter.response", response => this.sendResponse(response));
-    this.adapter.on("Adapter.event", event => this.sendEvent(event));
+
     this.adapter.on("Adapter.reverseRequest", ({ command, arguments: args }) =>
       this.sendRequest(command, args, 5000, () => {}),
     );
@@ -212,6 +305,15 @@ class FileDebugSession extends DebugSession {
     const { type } = message;
 
     if (type === "request") {
+      const { untitledDocPath, bunEvalPath } = this;
+      const { command } = message;
+      if (untitledDocPath && (command === "setBreakpoints" || command === "breakpointLocations")) {
+        const args = message.arguments as any;
+        if (args.source?.path === untitledDocPath) {
+          args.source.path = bunEvalPath;
+        }
+      }
+
       this.adapter.emit("Adapter.request", message);
     } else {
       throw new Error(`Not supported: ${type}`);
@@ -224,7 +326,7 @@ class FileDebugSession extends DebugSession {
 }
 
 class TerminalDebugSession extends FileDebugSession {
-  signal: TCPSocketSignal | UnixSignal;
+  signal!: TCPSocketSignal | UnixSignal;
 
   constructor() {
     super();
@@ -251,6 +353,7 @@ class TerminalDebugSession extends FileDebugSession {
       env: {
         "BUN_INSPECT": `${this.adapter.url}?wait=1`,
         "BUN_INSPECT_NOTIFY": this.signal.url,
+        BUN_INSPECT_CONNECT_TO: "",
       },
       isTransient: true,
       iconPath: new vscode.ThemeIcon("debug-console"),
@@ -270,6 +373,91 @@ function getRuntime(scope?: vscode.ConfigurationScope): string {
   return "bun";
 }
 
-function getConfig<T>(path: string, scope?: vscode.ConfigurationScope) {
-  return vscode.workspace.getConfiguration("bun", scope).get<T>(path);
+export async function runUnsavedCode() {
+  const editor = vscode.window.activeTextEditor;
+  if (!editor || !editor.document.isUntitled) return;
+
+  const code = editor.document.getText();
+  const startTime = performance.now();
+
+  try {
+    // Start debugging
+    await vscode.debug.startDebugging(undefined, {
+      ...DEBUG_CONFIGURATION,
+      program: "-",
+      __code: code,
+      __untitledName: editor.document.uri.toString(),
+      console: "debugConsole",
+      internalConsoleOptions: "openOnSessionStart",
+    });
+
+    // Find our debug session instance
+    const debugSession = Array.from(adapters.values()).find(
+      adapter => adapter.sessionId === vscode.debug.activeDebugSession?.id,
+    );
+
+    if (debugSession) {
+      // Wait for both the inspector to connect AND the adapter to be initialized
+      await new Promise<void>(resolve => {
+        let inspectorConnected = false;
+        let adapterInitialized = false;
+
+        const checkDone = () => {
+          if (inspectorConnected && adapterInitialized) {
+            resolve();
+          }
+        };
+
+        debugSession.adapter.once("Inspector.connected", () => {
+          inspectorConnected = true;
+          checkDone();
+        });
+
+        debugSession.adapter.once("Adapter.initialized", () => {
+          adapterInitialized = true;
+          checkDone();
+        });
+      });
+
+      // Now wait for debug session to complete
+      await new Promise<void>(resolve => {
+        const disposable = vscode.debug.onDidTerminateDebugSession(() => {
+          const duration = (performance.now() - startTime).toFixed(1);
+          debugSession.sendEvent(new OutputEvent(`✓ Code execution completed in ${duration}ms\n`));
+          disposable.dispose();
+          resolve();
+        });
+      });
+    }
+  } catch (err) {
+    if (vscode.debug.activeDebugSession) {
+      const duration = (performance.now() - startTime).toFixed(1);
+      const errorSession = adapters.get(vscode.debug.activeDebugSession.id);
+      errorSession?.sendEvent(
+        new OutputEvent(`✕ Error after ${duration}ms: ${err instanceof Error ? err.message : String(err)}\n`),
+      );
+    }
+  }
+}
+
+const languageIds = ["javascript", "typescript", "javascriptreact", "typescriptreact"];
+
+class BunCodeLensProvider implements vscode.CodeLensProvider {
+  async provideCodeLenses(document: vscode.TextDocument): Promise<vscode.CodeLens[]> {
+    if (!document.isUntitled || document.isClosed || document.lineCount === 0) return [];
+    if (!languageIds.includes(document.languageId)) {
+      return [];
+    }
+
+    // Create a range at position 0,0 with zero width
+    const range = new vscode.Range(new vscode.Position(0, 0), new vscode.Position(0, 0));
+
+    return [
+      new vscode.CodeLens(range, {
+        title: "eval with bun",
+        command: "extension.bun.runUnsavedCode",
+        tooltip: "Run this unsaved, scratch file with Bun",
+      }),
+    ];
+  }
 }
diff --git a/packages/bun-vscode/src/features/diagnostics/diagnostics.ts b/packages/bun-vscode/src/features/diagnostics/diagnostics.ts
new file mode 100644
index 0000000000..5427fffafe
--- /dev/null
+++ b/packages/bun-vscode/src/features/diagnostics/diagnostics.ts
@@ -0,0 +1,279 @@
+import * as fs from "node:fs/promises";
+import { Socket } from "node:net";
+import * as os from "node:os";
+import { inspect } from "node:util";
+import * as vscode from "vscode";
+import {
+  getAvailablePort,
+  NodeSocketDebugAdapter,
+  TCPSocketSignal,
+  UnixSignal,
+} from "../../../../bun-debug-adapter-protocol";
+import type { JSC } from "../../../../bun-inspector-protocol";
+import { typedGlobalState } from "../../global-state";
+import { getConfig } from "../../extension";
+
+const output = vscode.window.createOutputChannel("Bun - Diagnostics");
+
+const ansiRegex = (() => {
+  const ST = "(?:\\u0007|\\u001B\\u005C|\\u009C)";
+  const pattern = [
+    `[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?${ST})`,
+    "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))",
+  ].join("|");
+
+  return new RegExp(pattern, "g");
+})();
+
+function stripAnsi(str: string) {
+  return str.replace(ansiRegex, "");
+}
+
+class EditorStateManager {
+  private diagnosticCollection: vscode.DiagnosticCollection;
+  private disposables: vscode.Disposable[] = [];
+
+  public constructor() {
+    this.diagnosticCollection = vscode.languages.createDiagnosticCollection("BunDiagnostics");
+  }
+
+  getVisibleEditorsWithErrors() {
+    return vscode.window.visibleTextEditors.filter(editor => {
+      const diagnostics = this.diagnosticCollection.get(editor.document.uri);
+
+      return diagnostics && diagnostics.length > 0;
+    });
+  }
+
+  clearInFile(uri: vscode.Uri) {
+    if (this.diagnosticCollection.has(uri)) {
+      output.appendLine(`Clearing diagnostics for ${uri.toString()}`);
+      this.diagnosticCollection.delete(uri);
+    }
+  }
+
+  clearAll(reason: string) {
+    output.appendLine("Clearing all because: " + reason);
+    this.diagnosticCollection.clear();
+  }
+
+  set(uri: vscode.Uri, diagnostic: vscode.Diagnostic) {
+    this.diagnosticCollection.set(uri, [diagnostic]);
+  }
+
+  dispose() {
+    this.clearAll("Editor state was disposed");
+    this.disposables.forEach(d => d.dispose());
+  }
+}
+
+class BunDiagnosticsManager {
+  private readonly editorState: EditorStateManager;
+  private readonly signal: UnixSignal | TCPSocketSignal;
+  private readonly context: vscode.ExtensionContext;
+
+  public get signalUrl() {
+    return this.signal.url;
+  }
+
+  private static async getOrRecreateSignal(context: vscode.ExtensionContext) {
+    const globalState = typedGlobalState(context.globalState);
+    const existing = globalState.get("BUN_INSPECT_CONNECT_TO");
+
+    const isWin = os.platform() === "win32";
+
+    if (existing) {
+      if (existing.type === "unix") {
+        output.appendLine(`Reusing existing unix socket: ${existing.url}`);
+
+        if ("url" in existing) {
+          await fs.unlink(existing.url).catch(() => {
+            // ? lol
+          });
+        }
+
+        return new UnixSignal(existing.url);
+      } else {
+        output.appendLine(`Reusing existing tcp socket on: ${existing.port}`);
+        return new TCPSocketSignal(existing.port);
+      }
+    }
+
+    if (isWin) {
+      const port = await getAvailablePort();
+
+      await globalState.update("BUN_INSPECT_CONNECT_TO", {
+        type: "tcp",
+        port,
+      });
+
+      output.appendLine(`Created new tcp socket on: ${port}`);
+
+      return new TCPSocketSignal(port);
+    } else {
+      const signal = new UnixSignal();
+
+      await globalState.update("BUN_INSPECT_CONNECT_TO", {
+        type: "unix",
+        url: signal.url,
+      });
+
+      output.appendLine(`Created new unix socket: ${signal.url}`);
+
+      return signal;
+    }
+  }
+
+  // private static getOrCreateOldVersionInspectURL = createGlobalStateGenerationFn(
+  //   "DIAGNOSTICS_BUN_INSPECT",
+  //   async () => {
+  //     const url =
+  //       process.platform === "win32"
+  //         ? `ws://127.0.0.1:${await getAvailablePort()}/${getRandomId()}`
+  //         : `ws+unix://${os.tmpdir()}/${getRandomId()}.sock`;
+
+  //     return url;
+  //   },
+  // );
+
+  public static async initialize(context: vscode.ExtensionContext) {
+    const signal = await BunDiagnosticsManager.getOrRecreateSignal(context);
+
+    return new BunDiagnosticsManager(context, signal);
+  }
+
+  /**
+   * Called when Bun pings BUN_INSPECT_NOTIFY (indicating a program has started).
+   */
+  private async handleSocketConnection(socket: Socket) {
+    const debugAdapter = new NodeSocketDebugAdapter(socket);
+
+    this.editorState.clearAll("A new socket connected");
+
+    debugAdapter.on("LifecycleReporter.reload", async () => {
+      this.editorState.clearAll("LifecycleReporter reported a reload event");
+    });
+
+    debugAdapter.on("Inspector.event", e => {
+      output.appendLine(`Received inspector event: ${e.method}`);
+    });
+
+    debugAdapter.on("Inspector.error", e => {
+      output.appendLine(inspect(e, true, null));
+    });
+
+    debugAdapter.on("LifecycleReporter.error", event => this.handleLifecycleError(event));
+
+    const ok = await debugAdapter.start();
+
+    if (!ok) {
+      await vscode.window.showErrorMessage("Failed to start debug adapter");
+      debugAdapter.removeAllListeners();
+
+      return;
+    }
+
+    debugAdapter.initialize({
+      adapterID: "bun-vsc-terminal-debug-adapter",
+      enableControlFlowProfiler: false,
+      enableLifecycleAgentReporter: true,
+      sendImmediatePreventExit: false,
+      enableDebugger: false, // Performance overhead when debugger is enabled
+    });
+  }
+
+  private handleLifecycleError(event: JSC.LifecycleReporter.ErrorEvent) {
+    const message = stripAnsi(event.message).trim() || event.name || "Error";
+
+    output.appendLine(
+      `Received error event: '{name:${event.name}} ${message.split("\n")[0].trim().substring(0, 100)}'`,
+    );
+
+    const [url = null] = event.urls;
+    const [line = null, col = null] = event.lineColumns;
+
+    if (url === null || url.length === 0 || line === null || col === null) {
+      output.appendLine("No valid url or line/column found in error event");
+      output.appendLine(JSON.stringify(event));
+      return;
+    }
+
+    const uri = vscode.Uri.file(url);
+
+    // range is really just 1 character here..
+    const range = new vscode.Range(new vscode.Position(line - 1, col - 1), new vscode.Position(line - 1, col));
+
+    const document = vscode.workspace.textDocuments.find(doc => doc.uri.toString() === uri.toString());
+
+    // ...but we want to highlight the entire word after(inclusive) the character
+    const rangeOfWord = document?.getWordRangeAtPosition(range.start) ?? range; // Fallback to just the character if no editor or no word range is found
+
+    const diagnostic = new vscode.Diagnostic(rangeOfWord, message, vscode.DiagnosticSeverity.Error);
+
+    diagnostic.source = "Bun";
+
+    const relatedInformation = event.urls.flatMap((url, i) => {
+      if (i === 0 || url === "") {
+        return [];
+      }
+
+      const [line = null, col = null] = event.lineColumns.slice(i * 2, i * 2 + 2);
+
+      if (line === null || col === null) {
+        return [];
+      }
+
+      return [
+        new vscode.DiagnosticRelatedInformation(
+          new vscode.Location(vscode.Uri.file(url), new vscode.Position(line - 1, col - 1)),
+          message,
+        ),
+      ];
+    });
+
+    diagnostic.relatedInformation = relatedInformation;
+
+    this.editorState.set(uri, diagnostic);
+  }
+
+  public dispose() {
+    return vscode.Disposable.from(this.editorState, {
+      dispose: () => {
+        this.signal.close();
+        this.signal.removeAllListeners();
+      },
+    });
+  }
+
+  private constructor(context: vscode.ExtensionContext, signal: UnixSignal | TCPSocketSignal) {
+    this.editorState = new EditorStateManager();
+    this.signal = signal;
+    this.context = context;
+
+    this.context.subscriptions.push(
+      // on did type
+      vscode.workspace.onDidChangeTextDocument(e => {
+        this.editorState.clearInFile(e.document.uri);
+      }),
+    );
+
+    this.signal.on("Signal.Socket.connect", this.handleSocketConnection.bind(this));
+  }
+}
+
+const description = new vscode.MarkdownString(
+  "Bun's VSCode extension communicates with Bun over a socket. We set the url in your terminal with the `BUN_INSPECT_NOTIFY` environment variable",
+);
+
+export async function registerDiagnosticsSocket(context: vscode.ExtensionContext) {
+  context.environmentVariableCollection.clear();
+  context.environmentVariableCollection.description = description;
+
+  if (!getConfig("diagnosticsSocket.enabled")) return;
+
+  const manager = await BunDiagnosticsManager.initialize(context);
+
+  context.environmentVariableCollection.replace("BUN_INSPECT_CONNECT_TO", manager.signalUrl);
+
+  context.subscriptions.push(manager);
+}
diff --git a/packages/bun-vscode/src/features/lockfile/index.ts b/packages/bun-vscode/src/features/lockfile/index.ts
index 3e525434e0..7765a171d7 100644
--- a/packages/bun-vscode/src/features/lockfile/index.ts
+++ b/packages/bun-vscode/src/features/lockfile/index.ts
@@ -1,6 +1,7 @@
 import { spawn } from "node:child_process";
 import * as vscode from "vscode";
 import { styleLockfile } from "./lockfile.style";
+import { getConfig } from "../../extension";
 
 export type BunLockfile = vscode.CustomDocument & {
   readonly preview: string;
@@ -36,6 +37,11 @@ export class BunLockfileEditorProvider implements vscode.CustomReadonlyEditorPro
 }
 
 function renderLockfile({ webview }: vscode.WebviewPanel, preview: string, extensionUri: vscode.Uri): void {
+  if (!getConfig("bunlockb.enabled")) {
+    webview.html = "<code>bun.bunlockb</code> config option is disabled."
+    return 
+  }
+
   const styleVSCodeUri = webview.asWebviewUri(vscode.Uri.joinPath(extensionUri, "assets", "vscode.css"));
   const lockfileContent = styleLockfile(preview);
 
@@ -49,7 +55,7 @@ function renderLockfile({ webview }: vscode.WebviewPanel, preview: string, exten
 <html lang="en">
   <head>
     <meta charset="UTF-8">
-    <meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src ${webview.cspSource};">    
+    <meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src ${webview.cspSource};">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <link href="${styleVSCodeUri}" rel="stylesheet" />
   </head>
diff --git a/packages/bun-vscode/src/features/tasks/package.json.ts b/packages/bun-vscode/src/features/tasks/package.json.ts
index 0944382b91..a6b83c249f 100644
--- a/packages/bun-vscode/src/features/tasks/package.json.ts
+++ b/packages/bun-vscode/src/features/tasks/package.json.ts
@@ -4,6 +4,7 @@
 import * as vscode from "vscode";
 import { debugCommand } from "../debug";
 import { BunTask } from "./tasks";
+import { getConfig } from "../../extension";
 
 /**
  * Parses tasks defined in the package.json.
diff --git a/packages/bun-vscode/src/features/tests/index.ts b/packages/bun-vscode/src/features/tests/index.ts
new file mode 100644
index 0000000000..e286e131d2
--- /dev/null
+++ b/packages/bun-vscode/src/features/tests/index.ts
@@ -0,0 +1,204 @@
+import ts from "typescript";
+import * as vscode from "vscode";
+
+/**
+ * Find all matching test via ts AST
+ */
+function findTests(document: vscode.TextDocument): Array<{ name: string; range: vscode.Range }> {
+  const sourceFile = ts.createSourceFile(document.fileName, document.getText(), ts.ScriptTarget.Latest, true);
+  const tests: Array<{ name: string; range: vscode.Range }> = [];
+
+  // Visit all nodes in the AST
+  function visit(node: ts.Node) {
+    if (ts.isCallExpression(node)) {
+      const expressionText = node.expression.getText(sourceFile);
+
+      // Check if the expression is a test function
+      const isTest = expressionText === "test" || expressionText === "describe" || expressionText === "it";
+
+      if (!isTest) {
+        return;
+      }
+
+      // Get the test name from the first argument
+      const testName = node.arguments[0] && ts.isStringLiteral(node.arguments[0]) ? node.arguments[0].text : null;
+      if (!testName) {
+        return;
+      }
+
+      // Get the range of the test function for the CodeLens
+      const start = document.positionAt(node.getStart());
+      const end = document.positionAt(node.getEnd());
+      const range = new vscode.Range(start, end);
+      tests.push({ name: testName, range });
+    }
+    ts.forEachChild(node, visit);
+  }
+
+  visit(sourceFile);
+  return tests;
+}
+
+/**
+ * This class provides CodeLens for test functions in the editor - find all tests in current document and provide CodeLens for them.
+ * It finds all test functions in the current document and provides CodeLens for them (Run Test, Watch Test buttons).
+ */
+class TestCodeLensProvider implements vscode.CodeLensProvider {
+  public provideCodeLenses(document: vscode.TextDocument): vscode.CodeLens[] {
+    const codeLenses: vscode.CodeLens[] = [];
+    const tests = findTests(document);
+
+    for (const test of tests) {
+      const runTestCommand = {
+        title: "Run Test",
+        command: "extension.bun.runTest",
+        arguments: [document.fileName, test.name],
+      };
+
+      const watchTestCommand = {
+        title: "Watch Test",
+        command: "extension.bun.watchTest",
+        arguments: [document.fileName, test.name],
+      };
+
+      codeLenses.push(new vscode.CodeLens(test.range, runTestCommand));
+      codeLenses.push(new vscode.CodeLens(test.range, watchTestCommand));
+    }
+
+    return codeLenses;
+  }
+}
+
+// default file pattern to search for tests
+const DEFAULT_FILE_PATTERN = "**/*{.test.,.spec.,_test_,_spec_}{js,ts,tsx,jsx,mts,cts}";
+
+/**
+ * This function registers a CodeLens provider for test files. It is used to display the "Run" and "Watch" buttons.
+ */
+export function registerTestCodeLens(context: vscode.ExtensionContext) {
+  const codeLensProvider = new TestCodeLensProvider();
+
+  // Get the user-defined file pattern from the settings, or use the default
+  // Setting is:
+  // bun.test.filePattern
+  const pattern = vscode.workspace.getConfiguration("bun.test").get("filePattern", DEFAULT_FILE_PATTERN);
+  const options = { scheme: "file", pattern };
+
+  context.subscriptions.push(
+    vscode.languages.registerCodeLensProvider({ ...options, language: "javascript" }, codeLensProvider),
+  );
+
+  context.subscriptions.push(
+    vscode.languages.registerCodeLensProvider({ ...options, language: "typescript" }, codeLensProvider),
+  );
+
+  context.subscriptions.push(
+    vscode.languages.registerCodeLensProvider({ ...options, language: "javascriptreact" }, codeLensProvider),
+  );
+
+  context.subscriptions.push(
+    vscode.languages.registerCodeLensProvider({ ...options, language: "typescriptreact" }, codeLensProvider),
+  );
+}
+
+// Tracking only one active terminal, so there will be only one terminal running at a time.
+// Example: when user clicks "Run Test" button, the previous terminal will be disposed.
+let activeTerminal: vscode.Terminal | null = null;
+
+/**
+ * This function registers the test runner commands.
+ */
+export function registerTestRunner(context: vscode.ExtensionContext) {
+  // Register the "Run Test" command
+  const runTestCommand = vscode.commands.registerCommand(
+    "extension.bun.runTest",
+    async (filePath?: string, testName?: string, isWatchMode: boolean = false) => {
+      // Get custom flag
+      const customFlag = vscode.workspace.getConfiguration("bun.test").get("customFlag", "").trim();
+      const customScriptSetting = vscode.workspace.getConfiguration("bun.test").get("customScript", "bun test").trim();
+
+      const customScript = customScriptSetting.length ? customScriptSetting : "bun test";
+
+      // When this command is called from the command palette, the fileName and testName arguments are not passed (commands in package.json)
+      // so then fileName is taken from the active text editor and it run for the whole file.
+      if (!filePath) {
+        const editor = vscode.window.activeTextEditor;
+
+        if (!editor) {
+          await vscode.window.showErrorMessage("No active editor to run tests in");
+          return;
+        }
+
+        filePath = editor.document.fileName;
+      }
+
+      // Detect if along file path there is package.json, like in mono-repo, if so, then switch to that directory
+      const packageJsonPaths = await vscode.workspace.findFiles("**/package.json");
+
+      // Sort by length, so the longest path is first, so we can switch to the deepest directory
+      const packagesRootPaths = packageJsonPaths
+        .map(uri => uri.fsPath.replace("/package.json", ""))
+        .sort((a, b) => b.length - a.length);
+
+      const packageJsonPath: string | undefined = packagesRootPaths.find(path => filePath.includes(path));
+
+      if (activeTerminal) {
+        activeTerminal.dispose();
+        activeTerminal = null;
+      }
+
+      const cwd = packageJsonPath ?? vscode.workspace.workspaceFolders?.[0]?.uri.fsPath ?? process.cwd();
+
+      const message = isWatchMode
+        ? `Watching \x1b[1m\x1b[32m${testName ?? filePath}\x1b[0m test`
+        : `Running \x1b[1m\x1b[32m${testName ?? filePath}\x1b[0m test`;
+
+      const terminalOptions: vscode.TerminalOptions = {
+        cwd,
+        name: "Bun Test Runner",
+        location: vscode.TerminalLocation.Panel,
+        message,
+        hideFromUser: true,
+      };
+
+      activeTerminal = vscode.window.createTerminal(terminalOptions);
+      activeTerminal.show();
+
+      let command = customScript;
+
+      if (filePath.length !== 0) {
+        command += ` ${filePath}`;
+      }
+
+      if (testName && testName.length) {
+        if (customScriptSetting.length) {
+          // escape the quotes in the test name
+          command += ` -t "${testName}"`;
+        } else {
+          command += ` -t "${testName}"`;
+        }
+      }
+
+      if (isWatchMode) {
+        command += ` --watch`;
+      }
+
+      if (customFlag.length) {
+        command += ` ${customFlag}`;
+      }
+
+      activeTerminal.sendText(command);
+    },
+  );
+
+  // Register the "Watch Test" command, which just calls the "Run Test" command with the watch flag
+  const watchTestCommand = vscode.commands.registerCommand(
+    "extension.bun.watchTest",
+    async (fileName?: string, testName?: string) => {
+      vscode.commands.executeCommand("extension.bun.runTest", fileName, testName, true);
+    },
+  );
+
+  context.subscriptions.push(runTestCommand);
+  context.subscriptions.push(watchTestCommand);
+}
diff --git a/packages/bun-vscode/src/global-state.ts b/packages/bun-vscode/src/global-state.ts
new file mode 100644
index 0000000000..9ee8f170b5
--- /dev/null
+++ b/packages/bun-vscode/src/global-state.ts
@@ -0,0 +1,65 @@
+import { ExtensionContext } from "vscode";
+
+export const GLOBAL_STATE_VERSION = 1;
+
+export type GlobalStateTypes = {
+  BUN_INSPECT_CONNECT_TO:
+    | {
+        type: "tcp";
+        port: number;
+      }
+    | {
+        type: "unix";
+        url: string;
+      };
+
+  DIAGNOSTICS_BUN_INSPECT: string;
+};
+
+export async function clearGlobalState(gs: ExtensionContext["globalState"]) {
+  const tgs = typedGlobalState(gs);
+
+  await Promise.all(tgs.keys().map(key => tgs.update(key, undefined as never)));
+}
+
+export function typedGlobalState(state: ExtensionContext["globalState"]) {
+  return state as {
+    get<K extends keyof GlobalStateTypes>(key: K): GlobalStateTypes[K] | undefined;
+
+    keys(): readonly (keyof GlobalStateTypes)[];
+
+    update<K extends keyof GlobalStateTypes>(key: K, value: GlobalStateTypes[K]): Thenable<void>;
+
+    /**
+     * Set the keys whose values should be synchronized across devices when synchronizing user-data
+     * like configuration, extensions, and mementos.
+     *
+     * Note that this function defines the whole set of keys whose values are synchronized:
+     *  - calling it with an empty array stops synchronization for this memento
+     *  - calling it with a non-empty array replaces all keys whose values are synchronized
+     *
+     * For any given set of keys this function needs to be called only once but there is no harm in
+     * repeatedly calling it.
+     *
+     * @param keys The set of keys whose values are synced.
+     */
+    setKeysForSync(keys: readonly (keyof GlobalStateTypes)[]): void;
+  };
+}
+
+export function createGlobalStateGenerationFn<T extends keyof GlobalStateTypes>(
+  key: T,
+  resolve: () => Promise<GlobalStateTypes[T]>,
+) {
+  return async (gs: ExtensionContext["globalState"]) => {
+    const value = (gs as TypedGlobalState).get(key);
+    if (value) return value;
+
+    const next = await resolve();
+    await (gs as TypedGlobalState).update(key, next);
+
+    return next;
+  };
+}
+
+export type TypedGlobalState = ReturnType<typeof typedGlobalState>;
diff --git a/packages/bun-vscode/tsconfig.json b/packages/bun-vscode/tsconfig.json
index 2383c58330..50d41834fc 100644
--- a/packages/bun-vscode/tsconfig.json
+++ b/packages/bun-vscode/tsconfig.json
@@ -7,7 +7,7 @@
     "esModuleInterop": true,
     "isolatedModules": false,
     "skipLibCheck": true,
-    "types": ["bun-types"]
+    "strict": true
   },
   "include": ["src", "test", "types", "../../bun-devtools", "../../bun-debug-adapter-protocol"],
   "exclude": ["node_modules"]
diff --git a/patches/libarchive/archive_write_add_filter_gzip.c.patch b/patches/libarchive/archive_write_add_filter_gzip.c.patch
new file mode 100644
index 0000000000..bdbdf68f21
--- /dev/null
+++ b/patches/libarchive/archive_write_add_filter_gzip.c.patch
@@ -0,0 +1,58 @@
+--- a/libarchive/archive_write_add_filter_gzip.c
++++ b/libarchive/archive_write_add_filter_gzip.c
+@@ -58,6 +58,7 @@ archive_write_set_compression_gzip(struct archive *a)
+ struct private_data {
+ 	int		 compression_level;
+ 	int		 timestamp;
++	unsigned char 	os;
+ #ifdef HAVE_ZLIB_H
+ 	z_stream	 stream;
+ 	int64_t		 total_in;
+@@ -106,6 +107,7 @@ archive_write_add_filter_gzip(struct archive *_a)
+ 		archive_set_error(&a->archive, ENOMEM, "Out of memory");
+ 		return (ARCHIVE_FATAL);
+ 	}
++	data->os = 3; /* default Unix */
+ 	f->data = data;
+ 	f->open = &archive_compressor_gzip_open;
+ 	f->options = &archive_compressor_gzip_options;
+@@ -166,6 +168,30 @@ archive_compressor_gzip_options(struct archive_write_filter *f, const char *key,
+ 		return (ARCHIVE_OK);
+ 	}
+ 
++	if (strcmp(key, "os") == 0) {
++		if (value == NULL) 
++			return (ARCHIVE_WARN);
++
++		if (strcmp(value, "FAT") == 0) data->os = 0;
++		else if (strcmp(value, "Amiga") == 0) data->os = 1;
++		else if (strcmp(value, "VMS") == 0 || strcmp(value, "OpenVMS") == 0) data->os = 2;
++		else if (strcmp(value, "Unix") == 0) data->os = 3;
++		else if (strcmp(value, "VM") == 0 || strcmp(value, "VM/CMS") == 0) data->os = 4;
++		else if (strcmp(value, "Atari TOS") == 0) data->os = 5;
++		else if (strcmp(value, "HPFS") == 0) data->os = 6; 
++		else if (strcmp(value, "Macintosh") == 0) data->os = 7;
++		else if (strcmp(value, "Z-System") == 0) data->os = 8;
++		else if (strcmp(value, "CP/M") == 0) data->os = 9;
++		else if (strcmp(value, "TOPS-20") == 0) data->os = 10;
++		else if (strcmp(value, "NTFS") == 0) data->os = 11;
++		else if (strcmp(value, "QDOS") == 0) data->os = 12;
++		else if (strcmp(value, "Acorn RISCOS") == 0) data->os = 13;
++		else if (strcmp(value, "Unknown") == 0) data->os = 255;
++		else return (ARCHIVE_WARN);
++
++		return (ARCHIVE_OK);
++	}
++
+ 	/* Note: The "warn" return is just to inform the options
+ 	 * supervisor that we didn't handle it.  It will generate
+ 	 * a suitable error if no one used this option. */
+@@ -226,7 +252,7 @@ archive_compressor_gzip_open(struct archive_write_filter *f)
+ 	    data->compressed[8] = 4;
+     else
+ 	    data->compressed[8] = 0;
+-	data->compressed[9] = 3; /* OS=Unix */
++	data->compressed[9] = data->os;
+ 	data->stream.next_out += 10;
+ 	data->stream.avail_out -= 10;
+ 
diff --git a/root.zig b/root.zig
index 6255deec04..4778a56d1b 100644
--- a/root.zig
+++ b/root.zig
@@ -3,16 +3,6 @@ pub usingnamespace @import("./src/main.zig");
 /// These functions are used throughout Bun's codebase.
 pub const bun = @import("./src/bun.zig");
 
-pub const content = struct {
-    pub const error_js_path = "packages/bun-error/dist/index.js";
-    pub const error_js = @embedFile(error_js_path);
-
-    pub const error_css_path = "packages/bun-error/dist/bun-error.css";
-    pub const error_css_path_dev = "packages/bun-error/bun-error.css";
-
-    pub const error_css = @embedFile(error_css_path);
-};
-
 pub const completions = struct {
     pub const bash = @embedFile("./completions/bun.bash");
     pub const zsh = @embedFile("./completions/bun.zsh");
diff --git a/root_wasm.zig b/root_wasm.zig
index f04ceb015c..7865cc0471 100644
--- a/root_wasm.zig
+++ b/root_wasm.zig
@@ -2,16 +2,6 @@ pub usingnamespace @import("src/main_wasm.zig");
 
 pub const bun = @import("src/bun.zig");
 
-pub const content = struct {
-    pub const error_js_path = "packages/bun-error/dist/index.js";
-    pub const error_js = @embedFile(error_js_path);
-
-    pub const error_css_path = "packages/bun-error/dist/bun-error.css";
-    pub const error_css_path_dev = "packages/bun-error/bun-error.css";
-
-    pub const error_css = @embedFile(error_css_path);
-};
-
 pub const completions = struct {};
 pub const is_bindgen = true;
 pub const JavaScriptCore = struct {
diff --git a/scripts/agent.mjs b/scripts/agent.mjs
new file mode 100755
index 0000000000..e94f0658d0
--- /dev/null
+++ b/scripts/agent.mjs
@@ -0,0 +1,260 @@
+#!/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,
+  spawn,
+  mkdir,
+} 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) {
+      mkdir(logsPath);
+
+      const nssm = which("nssm", { required: true });
+      const nssmCommands = [
+        [nssm, "install", "buildkite-agent", command, ...args],
+        [nssm, "set", "buildkite-agent", "Start", "SERVICE_AUTO_START"],
+        [nssm, "set", "buildkite-agent", "AppDirectory", homePath],
+        [nssm, "set", "buildkite-agent", "AppStdout", agentLogPath],
+        [nssm, "set", "buildkite-agent", "AppStderr", agentLogPath],
+      ];
+      for (const command of nssmCommands) {
+        await spawnSafe(command, { 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 });
+      writeFile(`/etc/conf.d/buildkite-agent`, `rc_ulimit="-n 262144"`);
+      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");
+    }
+
+    if (!token) {
+      throw new Error(
+        "Buildkite token not found: either set BUILDKITE_AGENT_TOKEN or add a buildkite:token label to the instance",
+      );
+    }
+
+    let shell;
+    if (isWindows) {
+      // Command Prompt has a faster startup time than PowerShell.
+      // Also, it propogates the exit code of the command, which PowerShell does not.
+      const cmd = which("cmd", { required: true });
+      shell = `"${cmd}" /S /C`;
+    } else {
+      const sh = which("sh", { required: true });
+      shell = `${sh} -e -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/associate-issue-with-sentry.ts b/scripts/associate-issue-with-sentry.ts
new file mode 100644
index 0000000000..49ffe57ca8
--- /dev/null
+++ b/scripts/associate-issue-with-sentry.ts
@@ -0,0 +1,51 @@
+const body = process.env.GITHUB_ISSUE_BODY;
+const SENTRY_AUTH_TOKEN = process.env.SENTRY_AUTH_TOKEN;
+
+if (!body || !SENTRY_AUTH_TOKEN) {
+  throw new Error("Missing environment variables");
+}
+
+const id = body.indexOf("<!-- sentry_id: ");
+const endIdLine = body.indexOf(" -->", id + 1);
+if (!(id > -1 && endIdLine > -1)) {
+  throw new Error("Missing sentry_id");
+}
+const sentryId = body.slice(id + "<!-- sentry_id: ".length, endIdLine).trim();
+if (!sentryId) {
+  throw new Error("Missing sentry_id");
+}
+
+const response = await fetch(`https://sentry.io/api/0/organizations/4507155222364160/eventids/${sentryId}/`, {
+  headers: {
+    Authorization: `Bearer ${SENTRY_AUTH_TOKEN}`,
+  },
+});
+if (!response.ok) {
+  throw new Error(`Failed to fetch Sentry event: ${response.statusText}`);
+}
+const json = await response.json();
+const groupId = json?.groupId;
+if (!groupId) {
+  throw new Error("Missing groupId");
+}
+
+const issueResponse = await fetch(`https://sentry.io/api/0/issues/${groupId}/`, {
+  headers: {
+    Authorization: `Bearer ${SENTRY_AUTH_TOKEN}`,
+  },
+});
+if (!issueResponse.ok) {
+  throw new Error(`Failed to fetch Sentry issue: ${issueResponse.statusText}`);
+}
+const { shortId, permalink } = await issueResponse.json();
+if (!shortId || !permalink) {
+  throw new Error("Missing shortId or permalink");
+}
+
+console.log(`Sentry ID: ${shortId}`);
+console.log(`Sentry permalink: ${permalink}`);
+
+await Bun.write("sentry-id.txt", shortId);
+await Bun.write("sentry-link.txt", permalink);
+
+export {};
diff --git a/scripts/bootstrap.ps1 b/scripts/bootstrap.ps1
new file mode 100755
index 0000000000..e9a698c941
--- /dev/null
+++ b/scripts/bootstrap.ps1
@@ -0,0 +1,418 @@
+# Version: 7
+# A script that installs the dependencies needed to build and test Bun.
+# This should work on Windows 10 or newer with PowerShell.
+
+# 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
+)
+
+$ErrorActionPreference = "Stop"
+Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass -Force
+
+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 Execute-Script {
+  param (
+    [Parameter(Mandatory = $true, Position = 0)]
+    [string]$Path
+  )
+
+  $pwsh = Which pwsh powershell -Required
+  Execute-Command $pwsh $Path
+}
+
+function Download-File {
+  param (
+    [Parameter(Mandatory = $true, Position = 0)]
+    [string]$Url,
+    [Parameter(Mandatory = $false)]
+    [string]$Name,
+    [Parameter(Mandatory = $false)]
+    [string]$Path
+  )
+
+  if (-not $Name) {
+    $Name = [System.IO.Path]::ChangeExtension([System.IO.Path]::GetRandomFileName(), [System.IO.Path]::GetExtension($Url))
+  }
+
+  if (-not $Path) {
+    $Path = "$env:TEMP\$Name"
+  }
+
+  $client = New-Object System.Net.WebClient
+  for ($i = 0; $i -lt 10 -and -not (Test-Path $Path); $i++) {
+    try {
+      $client.DownloadFile($Url, $Path)
+    } catch {
+      Write-Warning "Failed to download $Url, retry $i..."
+      Start-Sleep -s $i
+    }
+  }
+
+  return $Path
+}
+
+function Install-Chocolatey {
+  if (Which choco) {
+    return
+  }
+
+  Write-Output "Installing Chocolatey..."
+  [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072
+  $installScript = Download-File "https://community.chocolatey.org/install.ps1"
+  Execute-Script $installScript
+  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 Set-Env {
+  param (
+    [Parameter(Mandatory = $true, Position = 0)]
+    [string]$Name,
+    [Parameter(Mandatory = $true, Position = 1)]
+    [string]$Value
+  )
+
+  Write-Output "Setting environment variable $Name=$Value..."
+  [System.Environment]::SetEnvironmentVariable("$Name", "$Value", "Machine")
+  [System.Environment]::SetEnvironmentVariable("$Name", "$Value", "Process")
+}
+
+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 $package
+  }
+}
+
+function Install-Common-Software {
+  Install-Chocolatey
+  Install-Pwsh
+  Install-Git
+  Install-Packages curl 7zip nssm
+  Install-NodeJs
+  Install-Bun
+  Install-Cygwin
+  if ($CI) {
+    # FIXME: Installing tailscale causes the AWS metadata server to become unreachable
+    # 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"
+  $installScript = Download-File "https://raw.githubusercontent.com/buildkite/agent/main/install.ps1"
+  Execute-Script $installScript
+  Refresh-Path
+}
+
+function Install-Build-Essentials {
+  Install-Visual-Studio
+  Install-Packages `
+    cmake `
+    make `
+    ninja `
+    ccache `
+    python `
+    golang `
+    nasm `
+    ruby `
+    strawberryperl `
+    mingw
+  Install-Rust
+  Install-Llvm
+}
+
+function Install-Visual-Studio {
+  param (
+    [Parameter(Mandatory = $false)]
+    [string]$Edition = "community"
+  )
+
+  Write-Output "Downloading Visual Studio installer..."
+  $vsInstaller = Download-File "https://aka.ms/vs/17/release/vs_$Edition.exe"
+
+  Write-Output "Installing Visual Studio..."
+  $vsInstallArgs = @(
+    "--passive",
+    "--norestart",
+    "--wait",
+    "--force",
+    "--locale en-US",
+    "--add Microsoft.VisualStudio.Workload.NativeDesktop",
+    "--includeRecommended"
+  )
+  $startInfo = New-Object System.Diagnostics.ProcessStartInfo
+  $startInfo.FileName = $vsInstaller
+  $startInfo.Arguments = $vsInstallArgs -join ' '
+  $startInfo.CreateNoWindow = $true
+  $process = New-Object System.Diagnostics.Process
+  $process.StartInfo = $startInfo
+  $process.Start()
+  $process.WaitForExit()
+  if ($process.ExitCode -ne 0) {
+    throw "Failed to install Visual Studio: code $($process.ExitCode)"
+  }
+}
+
+function Install-Rust {
+  if (Which rustc) {
+    return
+  }
+
+  Write-Output "Installing Rustup..."
+  $rustupInit = Download-File "https://win.rustup.rs/" -Name "rustup-init.exe"
+
+  Write-Output "Installing Rust..."
+  Execute-Command $rustupInit -y
+
+  Write-Output "Moving Rust to $env:ProgramFiles..."
+  $rustPath = Join-Path $env:ProgramFiles "Rust"
+  if (-not (Test-Path $rustPath)) {
+    New-Item -Path $rustPath -ItemType Directory
+  }
+  Move-Item "$env:UserProfile\.cargo" "$rustPath\cargo" -Force
+  Move-Item "$env:UserProfile\.rustup" "$rustPath\rustup" -Force
+
+  Write-Output "Setting environment variables for Rust..."
+  Set-Env "CARGO_HOME" "$rustPath\cargo"
+  Set-Env "RUSTUP_HOME" "$rustPath\rustup"
+  Add-To-Path "$rustPath\cargo\bin"
+}
+
+function Install-Llvm {
+  Install-Package llvm `
+    -Command clang-cl `
+    -Version "18.1.8"
+  Add-To-Path "$env:ProgramFiles\LLVM\bin"
+}
+
+function Optimize-System {
+  Disable-Windows-Defender
+  Disable-Windows-Threat-Protection
+  Disable-Windows-Services
+  Disable-Power-Management
+}
+
+function Optimize-System-Needs-Reboot {
+  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..."
+  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
+}
+
+if ($Optimize) {
+  Optimize-System
+}
+
+Install-Common-Software
+Install-Build-Essentials
+
+if ($Optimize) {
+  Optimize-System-Needs-Reboot
+}
diff --git a/scripts/bootstrap.sh b/scripts/bootstrap.sh
new file mode 100755
index 0000000000..18defcfe88
--- /dev/null
+++ b/scripts/bootstrap.sh
@@ -0,0 +1,1119 @@
+#!/bin/sh
+# Version: 7
+
+# A script that installs the dependencies needed to build and test Bun.
+# This should work on macOS and Linux with a POSIX shell.
+
+# 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.
+
+pid=$$
+
+print() {
+	echo "$@"
+}
+
+error() {
+	echo "error: $@" >&2
+	kill -s TERM "$pid"
+	exit 1
+}
+
+execute() {
+	print "$ $@" >&2
+	if ! "$@"; then
+		error "Command failed: $@"
+	fi
+}
+
+execute_sudo() {
+	if [ "$sudo" = "1" ] || [ -z "$can_sudo" ]; then
+		execute "$@"
+	else
+		execute sudo -n "$@"
+	fi
+}
+
+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 /bin/sh -c "$*"
+	fi
+}
+
+grant_to_user() {
+	path="$1"
+	execute_sudo chown -R "$user:$group" "$path"
+}
+
+which() {
+	command -v "$1"
+}
+
+require() {
+	path="$(which "$1")"
+	if ! [ -f "$path" ]; then
+		error "Command \"$1\" is required, but is not installed."
+	fi
+	echo "$path"
+}
+
+fetch() {
+	curl=$(which curl)
+	if [ -f "$curl" ]; then
+		execute "$curl" -fsSL "$1"
+	else
+		wget=$(which wget)
+		if [ -f "$wget" ]; then
+			execute "$wget" -qO- "$1"
+		else
+			error "Command \"curl\" or \"wget\" is required, but is not installed."
+		fi
+	fi
+}
+
+download_file() {
+	url="$1"
+	filename="${2:-$(basename "$url")}"
+	tmp="$(execute mktemp -d)"
+	execute chmod 755 "$tmp"
+
+	path="$tmp/$filename"
+	fetch "$url" >"$path"
+	execute chmod 644 "$path"
+
+	print "$path"
+}
+
+compare_version() {
+	if [ "$1" = "$2" ]; then
+		echo "0"
+	elif [ "$1" = "$(echo -e "$1\n$2" | sort -V | head -n1)" ]; then
+		echo "-1"
+	else
+		echo "1"
+	fi
+}
+
+append_to_file() {
+	file="$1"
+	content="$2"
+
+	file_needs_sudo="0"
+	if [ -f "$file" ]; then
+		if ! [ -r "$file" ] || ! [ -w "$file" ]; then
+			file_needs_sudo="1"
+		fi
+	else
+		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
+			if [ "$file_needs_sudo" = "1" ]; then
+				execute_sudo sh -c "echo '$line' >> '$file'"
+			else
+				echo "$line" >>"$file"
+			fi
+		fi
+	done
+}
+
+append_to_file_sudo() {
+	file="$1"
+	content="$2"
+
+	if ! [ -f "$file" ]; then
+		execute_sudo mkdir -p "$(dirname "$file")"
+		execute_sudo touch "$file"
+	fi
+
+	echo "$content" | while read -r line; do
+		if ! grep -q "$line" "$file"; then
+			echo "$line" | execute_sudo tee "$file" >/dev/null
+		fi
+	done
+}
+
+append_to_profile() {
+	content="$1"
+	profiles=".profile .zprofile .bash_profile .bashrc .zshrc"
+	for profile in $profiles; do
+		file="$home/$profile"
+		if [ "$ci" = "1" ] || [ -f "$file" ]; then
+			append_to_file "$file" "$content"
+		fi
+	done
+}
+
+append_to_path() {
+	path="$1"
+	if ! [ -d "$path" ]; then
+		error "Could not find directory: \"$path\""
+	fi
+
+	append_to_profile "export PATH=\"$path:\$PATH\""
+	export PATH="$path:$PATH"
+}
+
+move_to_bin() {
+	exe_path="$1"
+	if ! [ -f "$exe_path" ]; then
+		error "Could not find executable: \"$exe_path\""
+	fi
+
+	usr_paths="/usr/bin /usr/local/bin"
+	for usr_path in $usr_paths; do
+		if [ -d "$usr_path" ] && [ -w "$usr_path" ]; then
+			break
+		fi
+	done
+
+	grant_to_user "$exe_path"
+	execute_sudo mv -f "$exe_path" "$usr_path/$(basename "$exe_path")"
+}
+
+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)"
+	case "$os" in
+	Linux*) os="linux" ;;
+	Darwin*) os="darwin" ;;
+	*) error "Unsupported operating system: $os" ;;
+	esac
+	print "Operating System: $os"
+
+	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)"
+	print "Kernel: $kernel"
+
+	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)"
+		fi
+		case "$arch" in
+		x64)
+			sysctl="$(which sysctl)"
+			if [ -f "$sysctl" ] && [ "$("$sysctl" -n sysctl.proc_translated 2>/dev/null)" = "1" ]; then
+				arch="aarch64"
+				rosetta="1"
+				print "Rosetta: enabled"
+			fi
+			;;
+		esac
+		;;
+	esac
+
+	if [ -n "$distro" ]; then
+		print "Distribution: $distro $release"
+	fi
+
+	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 "$abi" ]; then
+			print "ABI: $abi $abi_version"
+		fi
+		;;
+	esac
+}
+
+check_inside_docker() {
+	if ! [ "$os" = "linux" ]; then
+		return
+	fi
+	print "Checking if inside Docker..."
+
+	if [ -f "/.dockerenv" ]; then
+		docker=1
+	else
+		if [ -f "/proc/1/cgroup" ]; then
+			case "$(cat /proc/1/cgroup)" in
+			*/docker/*)
+				docker=1
+				;;
+			esac
+		fi
+
+		if [ -f "/proc/self/mountinfo" ]; then
+			case "$(cat /proc/self/mountinfo)" in
+			*/docker/*)
+				docker=1
+				;;
+			esac
+		fi
+	fi
+
+	if [ "$docker" = "1" ]; then
+		print "Docker: enabled"
+	fi
+}
+
+check_package_manager() {
+	print "Checking package manager..."
+
+	case "$os" in
+	darwin)
+		if ! [ -f "$(which brew)" ]; then
+			install_brew
+		fi
+		pm="brew"
+		;;
+	linux)
+		if [ -f "$(which apt)" ]; 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
+		;;
+	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
+		id="$(require id)"
+		user="$("$id" -un)"
+		group="$("$id" -gn)"
+	fi
+	if [ -z "$user" ]; then
+		error "Could not determine user"
+	fi
+	print "User: $user"
+	print "Group: $group"
+
+	home="$(execute_as_user echo '~')"
+	if [ -z "$home" ] || [ "$home" = "~" ]; then
+		error "Could not determine home directory for user: $user"
+	fi
+	print "Home: $home"
+
+	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
+}
+
+check_ulimit() {
+	if ! [ "$ci" = "1" ]; then
+		return
+	fi
+
+	print "Checking ulimits..."
+	systemd_conf="/etc/systemd/system.conf"
+	if [ -f "$systemd_conf" ]; then
+		limits_conf="/etc/security/limits.d/99-unlimited.conf"
+		if ! [ -f "$limits_conf" ]; then
+			execute_sudo mkdir -p "$(dirname "$limits_conf")"
+			execute_sudo touch "$limits_conf"
+		fi
+	fi
+
+	limits="core data fsize memlock nofile rss stack cpu nproc as locks sigpending msgqueue"
+	for limit in $limits; do
+		limit_upper="$(echo "$limit" | tr '[:lower:]' '[:upper:]')"
+
+		limit_value="unlimited"
+		case "$limit" in
+		nofile | nproc)
+			limit_value="1048576"
+			;;
+		esac
+
+		if [ -f "$limits_conf" ]; then
+			limit_users="root *"
+			for limit_user in $limit_users; do
+				append_to_file "$limits_conf" "$limit_user soft $limit $limit_value"
+				append_to_file "$limits_conf" "$limit_user hard $limit $limit_value"
+			done
+		fi
+
+		if [ -f "$systemd_conf" ]; then
+			append_to_file "$systemd_conf" "DefaultLimit$limit_upper=$limit_value"
+		fi
+	done
+
+	rc_conf="/etc/rc.conf"
+	if [ -f "$rc_conf" ]; then
+		rc_ulimit=""
+		limit_flags="c d e f i l m n q r s t u v x"
+		for limit_flag in $limit_flags; do
+			limit_value="unlimited"
+			case "$limit_flag" in
+			n | u)
+				limit_value="1048576"
+				;;
+			esac
+			rc_ulimit="$rc_ulimit -$limit_flag $limit_value"
+		done
+		append_to_file "$rc_conf" "rc_ulimit=\"$rc_ulimit\""
+	fi
+
+	pam_confs="/etc/pam.d/common-session /etc/pam.d/common-session-noninteractive"
+	for pam_conf in $pam_confs; do
+		if [ -f "$pam_conf" ]; then
+			append_to_file "$pam_conf" "session optional pam_limits.so"
+		fi
+	done
+
+	systemctl="$(which systemctl)"
+	if [ -f "$systemctl" ]; then
+		execute_sudo "$systemctl" daemon-reload
+	fi
+}
+
+package_manager() {
+	case "$pm" in
+	apt)
+		execute_sudo apt "$@"
+		;;
+	dnf)
+		case "$distro" in
+		rhel)
+			execute_sudo dnf \
+				--disableplugin=subscription-manager \
+				"$@"
+			;;
+		*)
+			execute_sudo dnf "$@"
+			;;
+		esac
+		;;
+	yum)
+		execute_sudo yum "$@"
+		;;
+	apk)
+		execute_sudo apk "$@"
+		;;
+	brew)
+		execute_as_user brew "$@"
+		;;
+	*)
+		error "Unsupported package manager: $pm"
+		;;
+	esac
+}
+
+check_package() {
+	case "$pm" in
+	apt)
+		apt-cache policy "$1"
+		;;
+	dnf | yum | brew)
+		package_manager info "$1"
+		;;
+	*)
+		error "Unsupported package manager: $pm"
+		;;
+	esac
+}
+
+install_packages() {
+	case "$pm" in
+	apt)
+		package_manager install \
+			--yes \
+			--no-install-recommends \
+			"$@"
+		;;
+	dnf)
+		package_manager install \
+			--assumeyes \
+			--nodocs \
+			--noautoremove \
+			--allowerasing \
+			"$@"
+		;;
+	yum)
+		package_manager install -y "$@"
+		;;
+	brew)
+		package_manager install \
+			--force \
+			--formula \
+			"$@"
+		package_manager link \
+			--force \
+			--overwrite \
+			"$@"
+		;;
+	apk)
+		package_manager add \
+			--no-cache \
+			--no-interactive \
+			--no-progress \
+			"$@"
+		;;
+	*)
+		error "Unsupported package manager: $pm"
+		;;
+	esac
+}
+
+install_brew() {
+	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)
+		append_to_path "/usr/local/bin"
+		;;
+	aarch64)
+		append_to_path "/opt/homebrew/bin"
+		;;
+	esac
+
+	case "$ci" in
+	1)
+		append_to_profile "export HOMEBREW_NO_INSTALL_CLEANUP=1"
+		append_to_profile "export HOMEBREW_NO_AUTO_UPDATE=1"
+		append_to_profile "export HOMEBREW_NO_ANALYTICS=1"
+		;;
+	esac
+}
+
+install_common_software() {
+	case "$pm" in
+	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 \
+		htop \
+		gnupg \
+		git \
+		unzip \
+		wget
+
+	install_rosetta
+	install_nodejs
+	install_bun
+	install_tailscale
+	install_buildkite
+}
+
+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_$(nodejs_version).x")
+		execute_sudo "$bash" "$script"
+		;;
+	apt)
+		bash="$(require bash)"
+		script="$(download_file "https://deb.nodesource.com/setup_$(nodejs_version).x")"
+		execute_sudo "$bash" "$script"
+		;;
+	esac
+
+	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() {
+	case "$pm" in
+	apk)
+		install_packages \
+			libgcc \
+			libstdc++
+		;;
+	esac
+
+	bash="$(require bash)"
+	script=$(download_file "https://bun.sh/install")
+
+	version="${1:-"latest"}"
+	case "$version" in
+	latest)
+		execute_as_user "$bash" "$script"
+		;;
+	*)
+		execute_as_user "$bash" "$script" -s "$version"
+		;;
+	esac
+
+	move_to_bin "$home/.bun/bin/bun"
+	bun_path="$(which bun)"
+	bunx_path="$(dirname "$bun_path")/bunx"
+	execute_sudo ln -sf "$bun_path" "$bunx_path"
+}
+
+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)
+			cmake_url="https://github.com/Kitware/CMake/releases/download/v$cmake_version/cmake-$cmake_version-linux-x86_64.sh"
+			;;
+		aarch64)
+			cmake_url="https://github.com/Kitware/CMake/releases/download/v$cmake_version/cmake-$cmake_version-linux-aarch64.sh"
+			;;
+		esac
+		cmake_script=$(download_file "$cmake_url")
+		execute_sudo "$sh" "$cmake_script" \
+			--skip-license \
+			--prefix=/usr
+		;;
+	esac
+}
+
+install_rosetta() {
+	case "$os" in
+	darwin)
+		if ! [ "$(which arch)" ]; then
+			execute softwareupdate \
+				--install-rosetta \
+				--agree-to-license
+		fi
+		;;
+	esac
+}
+
+install_build_essentials() {
+	case "$pm" in
+	apt)
+		install_packages \
+			build-essential \
+			ninja-build \
+			xz-utils \
+			pkg-config \
+			golang
+		;;
+	dnf | yum)
+		install_packages \
+			gcc-c++ \
+			xz \
+			pkg-config \
+			golang
+		case "$distro" in
+		rhel) ;;
+		*)
+			install_packages ninja-build
+			;;
+		esac
+		;;
+	brew)
+		install_packages \
+			ninja \
+			pkg-config \
+			golang
+		;;
+	apk)
+		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 \
+		python3 \
+		libtool \
+		ruby \
+		perl
+
+	install_cmake
+	install_llvm
+	install_ccache
+	install_rust
+	install_docker
+}
+
+llvm_version_exact() {
+	case "$os-$abi" in
+	darwin-* | windows-* | linux-musl)
+		print "18.1.8"
+		;;
+	linux-*)
+		print "16.0.6"
+		;;
+	esac
+}
+
+llvm_version() {
+	echo "$(llvm_version_exact)" | cut -d. -f1
+}
+
+install_llvm() {
+	case "$pm" in
+	apt)
+		bash="$(require bash)"
+		llvm_script="$(download_file "https://apt.llvm.org/llvm.sh")"
+		case "$distro-$release" in
+		ubuntu-24*)
+			execute_sudo "$bash" "$llvm_script" "$(llvm_version)" all -njammy
+			;;
+		*)
+			execute_sudo "$bash" "$llvm_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"
+		;;
+	esac
+}
+
+install_ccache() {
+	case "$pm" in
+	apt | apk | brew)
+		install_packages ccache
+		;;
+	esac
+}
+
+install_rust() {
+	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
+}
+
+install_docker() {
+	case "$pm" in
+	brew)
+		if ! [ -d "/Applications/Docker.app" ]; then
+			package_manager install docker --cask
+		fi
+		;;
+	*)
+		case "$distro-$release" in
+		amzn-2 | amzn-1)
+			execute_sudo 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
+
+	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)"
+		tailscale_script=$(download_file "https://tailscale.com/install.sh")
+		execute "$sh" "$tailscale_script"
+		;;
+	darwin)
+		install_packages go
+		execute_as_user go install tailscale.com/cmd/tailscale{,d}@latest
+		append_to_path "$home/go/bin"
+		;;
+	esac
+}
+
+create_buildkite_user() {
+	if ! [ "$ci" = "1" ] || ! [ "$os" = "linux" ]; then
+		return
+	fi
+
+	print "Creating Buildkite user..."
+	user="buildkite-agent"
+	group="$user"
+	home="/var/lib/buildkite-agent"
+
+	case "$distro" in
+	amzn)
+		install_packages \
+			shadow-utils \
+			util-linux
+		;;
+	esac
+
+	if [ -z "$(getent passwd "$user")" ]; then
+		case "$distro" in
+		alpine)
+			execute_sudo addgroup \
+				--system "$group"
+			execute_sudo adduser "$user" \
+				--system \
+				--ingroup "$group" \
+				--shell "$(require sh)" \
+				--home "$home" \
+				--disabled-password
+			;;
+		*)
+			execute_sudo useradd "$user" \
+				--system \
+				--shell "$(require sh)" \
+				--no-create-home \
+				--home-dir "$home"
+			;;
+		esac
+	fi
+
+	if [ -n "$(getent group docker)" ]; then
+		execute_sudo usermod -aG docker "$user"
+	fi
+
+	buildkite_paths="$home /var/cache/buildkite-agent /var/log/buildkite-agent /var/run/buildkite-agent /var/run/buildkite-agent/buildkite-agent.sock"
+	for path in $buildkite_paths; do
+		execute_sudo mkdir -p "$path"
+		execute_sudo chown -R "$user:$group" "$path"
+	done
+
+	buildkite_files="/var/run/buildkite-agent/buildkite-agent.pid"
+	for file in $buildkite_files; do
+		execute_sudo touch "$file"
+		execute_sudo chown "$user:$group" "$file"
+	done
+}
+
+install_buildkite() {
+	if ! [ "$ci" = "1" ]; then
+		return
+	fi
+
+	buildkite_version="3.87.0"
+	case "$os-$arch" in
+	linux-aarch64)
+		buildkite_filename="buildkite-agent-linux-arm64-$buildkite_version.tar.gz"
+		;;
+	linux-x64)
+		buildkite_filename="buildkite-agent-linux-amd64-$buildkite_version.tar.gz"
+		;;
+	darwin-aarch64)
+		buildkite_filename="buildkite-agent-darwin-arm64-$buildkite_version.tar.gz"
+		;;
+	darwin-x64)
+		buildkite_filename="buildkite-agent-darwin-amd64-$buildkite_version.tar.gz"
+		;;
+	esac
+	buildkite_url="https://github.com/buildkite/agent/releases/download/v$buildkite_version/$buildkite_filename"
+	buildkite_filepath="$(download_file "$buildkite_url" "$buildkite_filename")"
+	buildkite_tmpdir="$(dirname "$buildkite_filepath")"
+
+	execute tar -xzf "$buildkite_filepath" -C "$buildkite_tmpdir"
+	move_to_bin "$buildkite_tmpdir/buildkite-agent"
+	execute rm -rf "$buildkite_tmpdir"
+}
+
+install_chromium() {
+	# https://github.com/puppeteer/puppeteer/blob/main/docs/troubleshooting.md#chrome-doesnt-launch-on-linux
+	# https://github.com/puppeteer/puppeteer/blob/main/docs/troubleshooting.md#running-puppeteer-in-the-cloud
+	case "$pm" in
+	apk)
+		install_packages \
+			chromium \
+      nss \
+      freetype \
+      harfbuzz \
+      ttf-freefont
+		;;
+	apt)
+		install_packages \
+			fonts-liberation \
+			libatk-bridge2.0-0 \
+			libatk1.0-0 \
+			libc6 \
+			libcairo2 \
+			libcups2 \
+			libdbus-1-3 \
+			libexpat1 \
+			libfontconfig1 \
+			libgbm1 \
+			libgcc1 \
+			libglib2.0-0 \
+			libgtk-3-0 \
+			libnspr4 \
+			libnss3 \
+			libpango-1.0-0 \
+			libpangocairo-1.0-0 \
+			libstdc++6 \
+			libx11-6 \
+			libx11-xcb1 \
+			libxcb1 \
+			libxcomposite1 \
+			libxcursor1 \
+			libxdamage1 \
+			libxext6 \
+			libxfixes3 \
+			libxi6 \
+			libxrandr2 \
+			libxrender1 \
+			libxss1 \
+			libxtst6 \
+			xdg-utils
+
+		# Fixes issue in newer version of Ubuntu:
+		# Package 'libasound2' has no installation candidate
+		if [ "$(check_package "libasound2t64")" ]; then
+			install_packages libasound2t64
+		else
+			install_packages libasound2
+		fi
+		;;
+	dnf | yum)
+		install_packages \
+			alsa-lib \
+			atk \
+			cups-libs \
+			gtk3 \
+			ipa-gothic-fonts \
+			libXcomposite \
+			libXcursor \
+			libXdamage \
+			libXext \
+			libXi \
+			libXrandr \
+			libXScrnSaver \
+			libXtst \
+			pango \
+			xorg-x11-fonts-100dpi \
+			xorg-x11-fonts-75dpi \
+			xorg-x11-fonts-cyrillic \
+			xorg-x11-fonts-misc \
+			xorg-x11-fonts-Type1 \
+			xorg-x11-utils
+		;;
+	esac
+
+	case "$distro" in
+	amzn)
+		install_packages \
+			mesa-libgbm
+		;;
+	esac
+}
+
+main() {
+	check_features "$@"
+	check_operating_system
+	check_inside_docker
+	check_user
+	check_ulimit
+	check_package_manager
+	create_buildkite_user
+	install_common_software
+	install_build_essentials
+	install_chromium
+}
+
+main "$@"
diff --git a/scripts/build.mjs b/scripts/build.mjs
old mode 100644
new mode 100755
index b620d7964f..2fab14a959
--- a/scripts/build.mjs
+++ b/scripts/build.mjs
@@ -3,6 +3,7 @@
 import { spawn as nodeSpawn } from "node:child_process";
 import { existsSync, readFileSync, mkdirSync, cpSync, chmodSync } from "node:fs";
 import { basename, join, resolve } from "node:path";
+import { isCI, printEnvironment, startGroup } from "./utils.mjs";
 
 // https://cmake.org/cmake/help/latest/manual/cmake.1.html#generate-a-project-buildsystem
 const generateFlags = [
@@ -37,6 +38,10 @@ async function build(args) {
     return spawn("pwsh", ["-NoProfile", "-NoLogo", "-File", shellPath, process.argv0, scriptPath, ...args]);
   }
 
+  if (isCI) {
+    printEnvironment();
+  }
+
   const env = {
     ...process.env,
     FORCE_COLOR: "1",
@@ -102,7 +107,8 @@ async function build(args) {
   const generateArgs = Object.entries(generateOptions).flatMap(([flag, value]) =>
     flag.startsWith("-D") ? [`${flag}=${value}`] : [flag, value],
   );
-  await spawn("cmake", generateArgs, { env }, "configuration");
+
+  await startGroup("CMake Configure", () => spawn("cmake", generateArgs, { env }));
 
   const envPath = resolve(buildPath, ".env");
   if (existsSync(envPath)) {
@@ -116,7 +122,8 @@ async function build(args) {
   const buildArgs = Object.entries(buildOptions)
     .sort(([a], [b]) => (a === "--build" ? -1 : a.localeCompare(b)))
     .flatMap(([flag, value]) => [flag, value]);
-  await spawn("cmake", buildArgs, { env }, "compilation");
+
+  await startGroup("CMake Build", () => spawn("cmake", buildArgs, { env }));
 
   printDuration("total", Date.now() - startTime);
 }
@@ -130,7 +137,10 @@ function getCachePath(branch) {
   const repository = process.env.BUILDKITE_REPO;
   const fork = process.env.BUILDKITE_PULL_REQUEST_REPO;
   const repositoryKey = (fork || repository).replace(/[^a-z0-9]/gi, "-");
-  const branchKey = (branch || process.env.BUILDKITE_BRANCH).replace(/[^a-z0-9]/gi, "-");
+  const branchName = (branch || process.env.BUILDKITE_BRANCH).replace(/[^a-z0-9]/gi, "-");
+  const branchKey = branchName.startsWith("gh-readonly-queue-")
+    ? branchName.slice(18, branchName.indexOf("-pr-"))
+    : branchName;
   const stepKey = process.env.BUILDKITE_STEP_KEY.replace(/[^a-z0-9]/gi, "-");
   return resolve(buildPath, "..", "cache", repositoryKey, branchKey, stepKey);
 }
diff --git a/scripts/check-node.sh b/scripts/check-node.sh
new file mode 100755
index 0000000000..e704b7c893
--- /dev/null
+++ b/scripts/check-node.sh
@@ -0,0 +1,20 @@
+#!/bin/bash
+
+i=0
+j=0
+
+for x in $(git ls-files test/js/node/test/parallel --exclude-standard --others | grep test-$1)
+do
+  i=$((i+1))
+  echo ./$x
+  if timeout 2 $PWD/build/debug/bun-debug ./$x
+  then
+    j=$((j+1))
+    git add ./$x
+  fi
+  echo
+  echo
+done
+
+echo $i tests tested
+echo $j tests passed
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 0000000000..479dbb4cfd
--- /dev/null
+++ b/scripts/machine.mjs
@@ -0,0 +1,2714 @@
+#!/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,
+  getGithubUrl,
+  getGithubApiUrl,
+  curlSafe,
+  mkdtemp,
+  writeFile,
+  copyFile,
+  isMacOS,
+  mkdir,
+  rm,
+  homedir,
+  isWindows,
+  sha256,
+  isPrivileged,
+} from "./utils.mjs";
+import { basename, extname, join, relative, resolve } from "node:path";
+import { existsSync, mkdtempSync, readdirSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+/**
+ * @link https://tart.run/
+ * @link https://github.com/cirruslabs/tart
+ */
+const tart = {
+  get name() {
+    return "tart";
+  },
+
+  /**
+   * @param {string[]} args
+   * @param {import("./utils.mjs").SpawnOptions} options
+   * @returns {Promise<unknown>}
+   */
+  async spawn(args, options) {
+    const tart = which("tart", { required: true });
+    const { json } = options || {};
+    const command = json ? [tart, ...args, "--format=json"] : [tart, ...args];
+
+    const { stdout } = await spawnSafe(command, options);
+    if (!json) {
+      return stdout;
+    }
+
+    try {
+      return JSON.parse(stdout);
+    } catch {
+      return;
+    }
+  },
+
+  /**
+   * @typedef {"sequoia" | "sonoma" | "ventura" | "monterey"} TartDistro
+   * @typedef {`ghcr.io/cirruslabs/macos-${TartDistro}-xcode`} TartImage
+   * @link https://github.com/orgs/cirruslabs/packages?repo_name=macos-image-templates
+   */
+
+  /**
+   * @param {Platform} platform
+   * @returns {TartImage}
+   */
+  getImage(platform) {
+    const { os, arch, release } = platform;
+    if (os !== "darwin" || arch !== "aarch64") {
+      throw new Error(`Unsupported platform: ${inspect(platform)}`);
+    }
+    const distros = {
+      "15": "sequoia",
+      "14": "sonoma",
+      "13": "ventura",
+      "12": "monterey",
+    };
+    const distro = distros[release];
+    if (!distro) {
+      throw new Error(`Unsupported macOS release: ${distro}`);
+    }
+    return `ghcr.io/cirruslabs/macos-${distro}-xcode`;
+  },
+
+  /**
+   * @typedef {Object} TartVm
+   * @property {string} Name
+   * @property {"running" | "stopped"} State
+   * @property {"local"} Source
+   * @property {number} Size
+   * @property {number} Disk
+   * @property {number} [CPU]
+   * @property {number} [Memory]
+   */
+
+  /**
+   * @returns {Promise<TartVm[]>}
+   */
+  async listVms() {
+    return this.spawn(["list"], { json: true });
+  },
+
+  /**
+   * @param {string} name
+   * @returns {Promise<TartVm | undefined>}
+   */
+  async getVm(name) {
+    const result = await this.spawn(["get", name], {
+      json: true,
+      throwOnError: error => !/does not exist/i.test(inspect(error)),
+    });
+    return {
+      Name: name,
+      ...result,
+    };
+  },
+
+  /**
+   * @param {string} name
+   * @returns {Promise<void>}
+   */
+  async stopVm(name) {
+    await this.spawn(["stop", name, "--timeout=0"], {
+      throwOnError: error => !/does not exist|is not running/i.test(inspect(error)),
+    });
+  },
+
+  /**
+   * @param {string} name
+   * @returns {Promise<void>}
+   */
+  async deleteVm(name) {
+    await this.stopVm(name);
+    await this.spawn(["delete", name], {
+      throwOnError: error => !/does not exist/i.test(inspect(error)),
+    });
+  },
+
+  /**
+   * @param {string} name
+   * @param {TartImage} image
+   * @returns {Promise<void>}
+   */
+  async cloneVm(name, image) {
+    const localName = image.split("/").pop();
+    const localVm = await this.getVm(localName);
+    if (localVm) {
+      const { Name } = localVm;
+      await this.spawn(["clone", Name, name]);
+      return;
+    }
+
+    console.log(`Cloning macOS image: ${image} (this will take a long time)`);
+    await this.spawn(["clone", image, localName]);
+    await this.spawn(["clone", localName, name]);
+  },
+
+  /**
+   * @typedef {Object} TartMount
+   * @property {boolean} [readOnly]
+   * @property {string} source
+   * @property {string} destination
+   */
+
+  /**
+   * @typedef {Object} TartVmOptions
+   * @property {number} [cpuCount]
+   * @property {number} [memoryGb]
+   * @property {number} [diskSizeGb]
+   * @property {boolean} [no-graphics]
+   * @property {boolean} [no-audio]
+   * @property {boolean} [no-clipboard]
+   * @property {boolean} [recovery]
+   * @property {boolean} [vnc]
+   * @property {boolean} [vnc-experimental]
+   * @property {boolean} [net-softnet]
+   * @property {TartMount[]} [dir]
+   */
+
+  /**
+   * @param {string} name
+   * @param {TartVmOptions} options
+   * @returns {Promise<void>}
+   */
+  async runVm(name, options = {}) {
+    const { cpuCount, memoryGb, diskSizeGb, dir, ...vmOptions } = options;
+
+    const setArgs = ["--random-mac", "--random-serial"];
+    if (cpuCount) {
+      setArgs.push(`--cpu=${cpuCount}`);
+    }
+    if (memoryGb) {
+      setArgs.push(`--memory=${memoryGb}`);
+    }
+    if (diskSizeGb) {
+      setArgs.push(`--disk-size=${diskSizeGb}`);
+    }
+    await this.spawn(["set", name, ...setArgs]);
+
+    const args = Object.entries(vmOptions)
+      .filter(([, value]) => value !== undefined)
+      .flatMap(([key, value]) => (typeof value === "boolean" ? (value ? [`--${key}`] : []) : [`--${key}=${value}`]));
+    if (dir?.length) {
+      args.push(
+        ...dir.map(({ source, destination, readOnly }) => `--dir=${source}:${destination}${readOnly ? ":ro" : ""}`),
+      );
+    }
+
+    // This command is blocking, so it needs to be detached and not awaited
+    this.spawn(["run", name, ...args], { detached: true });
+  },
+
+  /**
+   * @param {string} name
+   * @returns {Promise<string | undefined>}
+   */
+  async getVmIp(name) {
+    const stdout = await this.spawn(["ip", name], {
+      retryOnError: error => /no IP address found/i.test(inspect(error)),
+      throwOnError: error => !/does not exist/i.test(inspect(error)),
+    });
+    return stdout?.trim();
+  },
+
+  /**
+   * @param {MachineOptions} options
+   * @returns {Promise<Machine>}
+   */
+  async createMachine(options) {
+    const { name, imageName, cpuCount, memoryGb, diskSizeGb, rdp } = options;
+
+    const image = imageName || this.getImage(options);
+    const machineId = name || `i-${Math.random().toString(36).slice(2, 11)}`;
+    await this.cloneVm(machineId, image);
+
+    await this.runVm(machineId, {
+      cpuCount,
+      memoryGb,
+      diskSizeGb,
+      "net-softnet": isPrivileged(),
+      "no-audio": true,
+      "no-clipboard": true,
+      "no-graphics": true,
+      "vnc-experimental": rdp,
+    });
+
+    return this.toMachine(machineId);
+  },
+
+  /**
+   * @param {string} name
+   * @returns {Machine}
+   */
+  toMachine(name) {
+    const connect = async () => {
+      const hostname = await this.getVmIp(name);
+      return {
+        hostname,
+        // hardcoded by base images
+        username: "admin",
+        password: "admin",
+      };
+    };
+
+    const exec = async (command, options) => {
+      const connectOptions = await connect();
+      return spawnSsh({ ...connectOptions, command }, options);
+    };
+
+    const execSafe = 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 rdp = async () => {
+      const connectOptions = await connect();
+      await spawnRdp({ ...connectOptions });
+    };
+
+    const close = async () => {
+      await this.deleteVm(name);
+    };
+
+    return {
+      cloud: "tart",
+      id: name,
+      spawn: exec,
+      spawnSafe: execSafe,
+      attach,
+      upload,
+      close,
+      [Symbol.asyncDispose]: close,
+    };
+  },
+};
+
+/**
+ * @link https://docs.orbstack.dev/
+ */
+const orbstack = {
+  get name() {
+    return "orbstack";
+  },
+
+  /**
+   * @typedef {Object} OrbstackImage
+   * @property {string} distro
+   * @property {string} version
+   * @property {string} arch
+   */
+
+  /**
+   * @param {Platform} platform
+   * @returns {OrbstackImage}
+   */
+  getImage(platform) {
+    const { os, arch, distro, release } = platform;
+    if (os !== "linux" || !/^debian|ubuntu|alpine|fedora|centos$/.test(distro)) {
+      throw new Error(`Unsupported platform: ${inspect(platform)}`);
+    }
+
+    return {
+      distro,
+      version: release,
+      arch: arch === "aarch64" ? "arm64" : "amd64",
+    };
+  },
+
+  /**
+   * @typedef {Object} OrbstackVm
+   * @property {string} id
+   * @property {string} name
+   * @property {"running"} state
+   * @property {OrbstackImage} image
+   * @property {OrbstackConfig} config
+   */
+
+  /**
+   * @typedef {Object} OrbstackConfig
+   * @property {string} default_username
+   * @property {boolean} isolated
+   */
+
+  /**
+   * @typedef {Object} OrbstackVmOptions
+   * @property {string} [name]
+   * @property {OrbstackImage} image
+   * @property {string} [username]
+   * @property {string} [password]
+   * @property {string} [userData]
+   */
+
+  /**
+   * @param {OrbstackVmOptions} options
+   * @returns {Promise<OrbstackVm>}
+   */
+  async createVm(options) {
+    const { name, image, username, password, userData } = options;
+    const { distro, version, arch } = image;
+    const uniqueId = name || `linux-${distro}-${version}-${arch}-${Math.random().toString(36).slice(2, 11)}`;
+
+    const args = [`--arch=${arch}`, `${distro}:${version}`, uniqueId];
+    if (username) {
+      args.push(`--user=${username}`);
+    }
+    if (password) {
+      args.push(`--set-password=${password}`);
+    }
+
+    let userDataPath;
+    if (userData) {
+      userDataPath = mkdtemp("orbstack-user-data-", "user-data.txt");
+      writeFile(userDataPath, userData);
+      args.push(`--user-data=${userDataPath}`);
+    }
+
+    try {
+      await spawnSafe($`orbctl create ${args}`);
+    } finally {
+      if (userDataPath) {
+        rm(userDataPath);
+      }
+    }
+
+    return this.inspectVm(uniqueId);
+  },
+
+  /**
+   * @param {string} name
+   */
+  async deleteVm(name) {
+    await spawnSafe($`orbctl delete ${name}`, {
+      throwOnError: error => !/machine not found/i.test(inspect(error)),
+    });
+  },
+
+  /**
+   * @param {string} name
+   * @returns {Promise<OrbstackVm | undefined>}
+   */
+  async inspectVm(name) {
+    const { exitCode, stdout } = await spawnSafe($`orbctl info ${name} --format=json`, {
+      throwOnError: error => !/machine not found/i.test(inspect(error)),
+    });
+    if (exitCode === 0) {
+      return JSON.parse(stdout);
+    }
+  },
+
+  /**
+   * @returns {Promise<OrbstackVm[]>}
+   */
+  async listVms() {
+    const { stdout } = await spawnSafe($`orbctl list --format=json`);
+    return JSON.parse(stdout);
+  },
+
+  /**
+   * @param {MachineOptions} options
+   * @returns {Promise<Machine>}
+   */
+  async createMachine(options) {
+    const { distro } = options;
+    const username = getUsername(distro);
+    const userData = getUserData({ ...options, username });
+
+    const image = this.getImage(options);
+    const vm = await this.createVm({
+      image,
+      username,
+      userData,
+    });
+
+    return this.toMachine(vm, options);
+  },
+
+  /**
+   * @param {OrbstackVm} vm
+   * @returns {Machine}
+   */
+  toMachine(vm) {
+    const { id, name, config } = vm;
+
+    const { default_username: username } = config;
+    const connectOptions = {
+      username,
+      hostname: `${name}@orb`,
+    };
+
+    const exec = async (command, options) => {
+      return spawnSsh({ ...connectOptions, command }, options);
+    };
+
+    const execSafe = async (command, options) => {
+      return spawnSshSafe({ ...connectOptions, command }, options);
+    };
+
+    const attach = async () => {
+      await spawnSshSafe({ ...connectOptions });
+    };
+
+    const upload = async (source, destination) => {
+      await spawnSafe(["orbctl", "push", `--machine=${name}`, source, destination]);
+    };
+
+    const close = async () => {
+      await this.deleteVm(name);
+    };
+
+    return {
+      cloud: "orbstack",
+      id,
+      name,
+      spawn: exec,
+      spawnSafe: execSafe,
+      upload,
+      attach,
+      close,
+      [Symbol.asyncDispose]: close,
+    };
+  },
+};
+
+const docker = {
+  get name() {
+    return "docker";
+  },
+
+  /**
+   * @typedef {"linux" | "darwin" | "windows"} DockerOs
+   * @typedef {"amd64" | "arm64"} DockerArch
+   * @typedef {`${DockerOs}/${DockerArch}`} DockerPlatform
+   */
+
+  /**
+   * @param {Platform} platform
+   * @returns {DockerPlatform}
+   */
+  getPlatform(platform) {
+    const { os, arch } = platform;
+    if (arch === "aarch64") {
+      return `${os}/arm64`;
+    } else if (arch === "x64") {
+      return `${os}/amd64`;
+    }
+    throw new Error(`Unsupported platform: ${inspect(platform)}`);
+  },
+
+  /**
+   * @typedef DockerSpawnOptions
+   * @property {DockerPlatform} [platform]
+   * @property {boolean} [json]
+   */
+
+  /**
+   * @param {string[]} args
+   * @param {DockerSpawnOptions & import("./utils.mjs").SpawnOptions} [options]
+   * @returns {Promise<unknown>}
+   */
+  async spawn(args, options = {}) {
+    const docker = which("docker", { required: true });
+
+    let env = { ...process.env };
+    if (isCI) {
+      env["BUILDKIT_PROGRESS"] = "plain";
+    }
+
+    const { json, platform } = options;
+    if (json) {
+      args.push("--format=json");
+    }
+    if (platform) {
+      args.push(`--platform=${platform}`);
+    }
+
+    const { error, stdout } = await spawnSafe($`${docker} ${args}`, { env, ...options });
+    if (error) {
+      return;
+    }
+    if (!json) {
+      return stdout;
+    }
+
+    try {
+      return JSON.parse(stdout);
+    } catch {
+      return;
+    }
+  },
+
+  /**
+   * @typedef {Object} DockerImage
+   * @property {string} Id
+   * @property {string[]} RepoTags
+   * @property {string[]} RepoDigests
+   * @property {string} Created
+   * @property {DockerOs} Os
+   * @property {DockerArch} Architecture
+   * @property {number} Size
+   */
+
+  /**
+   * @param {string} url
+   * @param {DockerPlatform} [platform]
+   * @returns {Promise<boolean>}
+   */
+  async pullImage(url, platform) {
+    const done = await this.spawn($`pull ${url}`, {
+      platform,
+      throwOnError: error => !/No such image|manifest unknown/i.test(inspect(error)),
+    });
+    return !!done;
+  },
+
+  /**
+   * @param {string} url
+   * @param {DockerPlatform} [platform]
+   * @returns {Promise<DockerImage | undefined>}
+   */
+  async inspectImage(url, platform) {
+    /** @type {DockerImage[]} */
+    const images = await this.spawn($`image inspect ${url}`, {
+      json: true,
+      throwOnError: error => !/No such image/i.test(inspect(error)),
+    });
+
+    if (!images) {
+      const pulled = await this.pullImage(url, platform);
+      if (pulled) {
+        return this.inspectImage(url, platform);
+      }
+    }
+
+    const { os, arch } = platform || {};
+    return images
+      ?.filter(({ Os, Architecture }) => !os || !arch || (Os === os && Architecture === arch))
+      ?.find((a, b) => (a.Created < b.Created ? 1 : -1));
+  },
+
+  /**
+   * @typedef {Object} DockerContainer
+   * @property {string} Id
+   * @property {string} Name
+   * @property {string} Image
+   * @property {string} Created
+   * @property {DockerContainerState} State
+   * @property {DockerContainerNetworkSettings} NetworkSettings
+   */
+
+  /**
+   * @typedef {Object} DockerContainerState
+   * @property {"exited" | "running"} Status
+   * @property {number} [Pid]
+   * @property {number} ExitCode
+   * @property {string} [Error]
+   * @property {string} StartedAt
+   * @property {string} FinishedAt
+   */
+
+  /**
+   * @typedef {Object} DockerContainerNetworkSettings
+   * @property {string} [IPAddress]
+   */
+
+  /**
+   * @param {string} containerId
+   * @returns {Promise<DockerContainer | undefined>}
+   */
+  async inspectContainer(containerId) {
+    const containers = await this.spawn($`container inspect ${containerId}`, { json: true });
+    return containers?.find(a => a.Id === containerId);
+  },
+
+  /**
+   * @returns {Promise<DockerContainer[]>}
+   */
+  async listContainers() {
+    const containers = await this.spawn($`container ls --all`, { json: true });
+    return containers || [];
+  },
+
+  /**
+   * @typedef {Object} DockerRunOptions
+   * @property {string[]} [command]
+   * @property {DockerPlatform} [platform]
+   * @property {string} [name]
+   * @property {boolean} [detach]
+   * @property {"always" | "never"} [pull]
+   * @property {boolean} [rm]
+   * @property {"no" | "on-failure" | "always"} [restart]
+   */
+
+  /**
+   * @param {string} url
+   * @param {DockerRunOptions} [options]
+   * @returns {Promise<DockerContainer>}
+   */
+  async runContainer(url, options = {}) {
+    const { detach, command = [], ...containerOptions } = options;
+    const args = Object.entries(containerOptions)
+      .filter(([_, value]) => typeof value !== "undefined")
+      .map(([key, value]) => (typeof value === "boolean" ? `--${key}` : `--${key}=${value}`));
+    if (detach) {
+      args.push("--detach");
+    } else {
+      args.push("--tty", "--interactive");
+    }
+
+    const stdio = detach ? "pipe" : "inherit";
+    const result = await this.spawn($`run ${args} ${url} ${command}`, { stdio });
+    if (!detach) {
+      return;
+    }
+
+    const containerId = result.trim();
+    const container = await this.inspectContainer(containerId);
+    if (!container) {
+      throw new Error(`Failed to run container: ${inspect(result)}`);
+    }
+    return container;
+  },
+
+  /**
+   * @param {Platform} platform
+   * @returns {Promise<DockerImage>}
+   */
+  async getBaseImage(platform) {
+    const { os, distro, release } = platform;
+    const dockerPlatform = this.getPlatform(platform);
+
+    let url;
+    if (os === "linux") {
+      if (distro === "debian" || distro === "ubuntu" || distro === "alpine") {
+        url = `docker.io/library/${distro}:${release}`;
+      } else if (distro === "amazonlinux") {
+        url = `public.ecr.aws/amazonlinux/amazonlinux:${release}`;
+      }
+    }
+
+    if (url) {
+      const image = await this.inspectImage(url, dockerPlatform);
+      if (image) {
+        return image;
+      }
+    }
+
+    throw new Error(`Unsupported platform: ${inspect(platform)}`);
+  },
+
+  /**
+   * @param {DockerContainer} container
+   * @param {MachineOptions} [options]
+   * @returns {Machine}
+   */
+  toMachine(container, options = {}) {
+    const { Id: containerId } = container;
+
+    const exec = (command, options) => {
+      return spawn(["docker", "exec", containerId, ...command], options);
+    };
+
+    const execSafe = (command, options) => {
+      return spawnSafe(["docker", "exec", containerId, ...command], options);
+    };
+
+    const upload = async (source, destination) => {
+      await spawn(["docker", "cp", source, `${containerId}:${destination}`]);
+    };
+
+    const attach = async () => {
+      const { exitCode, error } = await spawn(["docker", "exec", "-it", containerId, "sh"], {
+        stdio: "inherit",
+      });
+
+      if (exitCode === 0 || exitCode === 130) {
+        return;
+      }
+
+      throw error;
+    };
+
+    const snapshot = async name => {
+      await spawn(["docker", "commit", containerId]);
+    };
+
+    const kill = async () => {
+      await spawn(["docker", "kill", containerId]);
+    };
+
+    return {
+      cloud: "docker",
+      id: containerId,
+      spawn: exec,
+      spawnSafe: execSafe,
+      upload,
+      attach,
+      close: kill,
+      [Symbol.asyncDispose]: kill,
+    };
+  },
+
+  /**
+   * @param {MachineOptions} options
+   * @returns {Promise<Machine>}
+   */
+  async createMachine(options) {
+    const { Id: imageId, Os, Architecture } = await docker.getBaseImage(options);
+
+    const container = await docker.runContainer(imageId, {
+      platform: `${Os}/${Architecture}`,
+      command: ["sleep", "1d"],
+      detach: true,
+      rm: true,
+      restart: "no",
+    });
+
+    return this.toMachine(container, options);
+  },
+};
+
+const aws = {
+  get name() {
+    return "aws";
+  },
+
+  /**
+   * @param {string[]} args
+   * @param {import("./utils.mjs").SpawnOptions} [options]
+   * @returns {Promise<unknown>}
+   */
+  async spawn(args, options = {}) {
+    const aws = which("aws", { required: true });
+
+    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 { stdout } = await spawnSafe($`${aws} ${args} --output json`, { env, ...options });
+    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) {
+    for (let i = 0; i < 3; i++) {
+      const flags = aws.getFlags(options);
+      const result = await aws.spawn($`ec2 run-instances ${flags}`, {
+        throwOnError: error => {
+          if (options["instance-market-options"] && /InsufficientInstanceCapacity/i.test(inspect(error))) {
+            delete options["instance-market-options"];
+            const instanceType = options["instance-type"] || "default";
+            console.warn(`There is not enough capacity for ${instanceType} spot instances, retrying with on-demand...`);
+            return false;
+          }
+          return true;
+        },
+      });
+      if (result) {
+        const { Instances } = result;
+        if (Instances.length) {
+          return Instances.sort((a, b) => (a.LaunchTime < b.LaunchTime ? 1 : -1));
+        }
+      }
+      await new Promise(resolve => setTimeout(resolve, i * Math.random() * 15_000));
+    }
+    throw new Error(`Failed to run instances: ${inspect(instanceOptions)}`);
+  },
+
+  /**
+   * @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}`, {
+      throwOnError: error => !/InvalidInstanceID\.NotFound/i.test(inspect(error)),
+    });
+  },
+
+  /**
+   * @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}`, {
+      retryOnError: error => /max attempts exceeded/i.test(inspect(error)),
+    });
+  },
+
+  /**
+   * @param {string} instanceId
+   * @param {string} privateKeyPath
+   * @param {object} [passwordOptions]
+   * @param {boolean} [passwordOptions.wait]
+   * @returns {Promise<string | undefined>}
+   * @link https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-password-data.html
+   */
+  async getPasswordData(instanceId, privateKeyPath, passwordOptions = {}) {
+    const attempts = passwordOptions.wait ? 15 : 1;
+    for (let i = 0; i < attempts; i++) {
+      const { PasswordData } = await aws.spawn($`ec2 get-password-data --instance-id ${instanceId}`);
+      if (PasswordData) {
+        return decryptPassword(PasswordData, privateKeyPath);
+      }
+      await new Promise(resolve => setTimeout(resolve, 60000 * i));
+    }
+    throw new Error(`Failed to get password data for instance: ${instanceId}`);
+  },
+
+  /**
+   * @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);
+
+    /** @type {string | undefined} */
+    let existingImageId;
+
+    /** @type {AwsImage | undefined} */
+    const image = await aws.spawn($`ec2 create-image ${flags}`, {
+      throwOnError: error => {
+        const match = /already in use by AMI (ami-[a-z0-9]+)/i.exec(inspect(error));
+        if (!match) {
+          return true;
+        }
+        const [, imageId] = match;
+        existingImageId = imageId;
+        return false;
+      },
+    });
+
+    if (!existingImageId) {
+      const { ImageId } = image;
+      return ImageId;
+    }
+
+    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}`, {
+      retryOnError: error => /max attempts exceeded/i.test(inspect(error)),
+    });
+  },
+
+  /**
+   * @typedef {Object} AwsKeyPair
+   * @property {string} KeyPairId
+   * @property {string} KeyName
+   * @property {string} KeyFingerprint
+   * @property {string} [PublicKeyMaterial]
+   */
+
+  /**
+   * @param {string[]} [names]
+   * @returns {Promise<AwsKeyPair[]>}
+   * @link https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-key-pairs.html
+   */
+  async describeKeyPairs(names) {
+    const command = names
+      ? $`ec2 describe-key-pairs --include-public-key --key-names ${names}`
+      : $`ec2 describe-key-pairs --include-public-key`;
+    const { KeyPairs } = await aws.spawn(command);
+    return KeyPairs;
+  },
+
+  /**
+   * @param {string | Buffer} publicKey
+   * @param {string} [name]
+   * @returns {Promise<AwsKeyPair>}
+   * @link https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/import-key-pair.html
+   */
+  async importKeyPair(publicKey, name) {
+    const keyName = name || `key-pair-${sha256(publicKey)}`;
+    const publicKeyBase64 = Buffer.from(publicKey).toString("base64");
+
+    /** @type {AwsKeyPair | undefined} */
+    const keyPair = await aws.spawn(
+      $`ec2 import-key-pair --key-name ${keyName} --public-key-material ${publicKeyBase64}`,
+      {
+        throwOnError: error => !/InvalidKeyPair\.Duplicate/i.test(inspect(error)),
+      },
+    );
+
+    if (keyPair) {
+      return keyPair;
+    }
+
+    const keyPairs = await aws.describeKeyPairs(keyName);
+    if (keyPairs.length) {
+      return keyPairs[0];
+    }
+
+    throw new Error(`Failed to import key pair: ${keyName}`);
+  },
+
+  /**
+   * @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, release } = options;
+
+    let name, owner;
+    if (os === "linux") {
+      if (!distro || distro === "debian") {
+        owner = "amazon";
+        name = `debian-${release || "*"}-${arch === "aarch64" ? "arm64" : "amd64"}-*`;
+      } else if (distro === "ubuntu") {
+        owner = "099720109477";
+        name = `ubuntu/images/hvm-ssd*/ubuntu-*-${release || "*"}-${arch === "aarch64" ? "arm64" : "amd64"}-server-*`;
+      } else if (distro === "amazonlinux") {
+        owner = "amazon";
+        if (release === "1" && arch === "x64") {
+          name = `amzn-ami-2018.03.*`;
+        } else if (release === "2") {
+          name = `amzn2-ami-hvm-*-${arch === "aarch64" ? "arm64" : "x86_64"}-gp2`;
+        } else {
+          name = `al${release || "*"}-ami-*-${arch === "aarch64" ? "arm64" : "x86_64"}`;
+        }
+      } else if (distro === "alpine") {
+        owner = "538276064493";
+        name = `alpine-${release || "*"}.*-${arch === "aarch64" ? "aarch64" : "x86_64"}-uefi-cloudinit-*`;
+      } else if (distro === "centos") {
+        owner = "aws-marketplace";
+        name = `CentOS-Stream-ec2-${release || "*"}-*.${arch === "aarch64" ? "aarch64" : "x86_64"}-*`;
+      }
+    } else if (os === "windows") {
+      if (!distro || distro === "server") {
+        owner = "amazon";
+        name = `Windows_Server-${release || "*"}-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, sshKeys, preemptible } = 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>true</persist>`;
+    }
+
+    let tagSpecification = [];
+    if (tags) {
+      tagSpecification = ["instance", "volume"].map(resourceType => {
+        return {
+          ResourceType: resourceType,
+          Tags: Object.entries(tags).map(([Key, Value]) => ({ Key, Value: String(Value) })),
+        };
+      });
+    }
+
+    /** @type {string | undefined} */
+    let keyName, keyPath;
+    if (os === "windows") {
+      const sshKey = sshKeys.find(({ privatePath }) => existsSync(privatePath));
+      if (sshKey) {
+        const { publicKey, privatePath } = sshKey;
+        const { KeyName } = await aws.importKeyPair(publicKey);
+        keyName = KeyName;
+        keyPath = privatePath;
+      }
+    }
+
+    let marketOptions;
+    if (preemptible) {
+      marketOptions = JSON.stringify({
+        MarketType: "spot",
+        SpotOptions: {
+          InstanceInterruptionBehavior: "terminate",
+          SpotInstanceType: "one-time",
+        },
+      });
+    }
+
+    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"]: keyName,
+      ["instance-market-options"]: marketOptions,
+    });
+
+    return aws.toMachine(instance, { ...options, username, keyPath });
+  },
+
+  /**
+   * @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 rdp = async () => {
+      const { keyPath } = options;
+      const { hostname, username } = await connect();
+      const password = await aws.getPasswordData(InstanceId, keyPath, { wait: true });
+      return { hostname, username, password };
+    };
+
+    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,
+      rdp,
+      snapshot,
+      close: terminate,
+      [Symbol.asyncDispose]: terminate,
+    };
+  },
+};
+
+const google = {
+  get cloud() {
+    return "google";
+  },
+
+  /**
+   * @param {string[]} args
+   * @param {import("./utils.mjs").SpawnOptions} [options]
+   * @returns {Promise<unknown>}
+   */
+  async spawn(args, options = {}) {
+    const gcloud = which("gcloud", { required: true });
+
+    let env = { ...process.env };
+    // if (isCI) {
+    //   env; // TODO: Add Google Cloud credentials
+    // } else {
+    //   env["TERM"] = "dumb";
+    // }
+
+    const { stdout } = await spawnSafe($`${gcloud} ${args} --format json`, {
+      env,
+      ...options,
+    });
+    try {
+      return JSON.parse(stdout);
+    } catch {
+      return;
+    }
+  },
+
+  /**
+   * @param {Record<string, string | undefined>} [options]
+   * @returns {string[]}
+   */
+  getFilters(options = {}) {
+    const filter = Object.entries(options)
+      .filter(([, value]) => value !== undefined)
+      .map(([key, value]) => [value.includes("*") ? `${key}~${value}` : `${key}=${value}`])
+      .join(" AND ");
+    return filter ? ["--filter", filter] : [];
+  },
+
+  /**
+   * @param {Record<string, string | boolean | undefined>} options
+   * @returns {string[]}
+   */
+  getFlags(options) {
+    return Object.entries(options)
+      .filter(([, value]) => value !== undefined)
+      .flatMap(([key, value]) => {
+        if (typeof value === "boolean") {
+          return value ? [`--${key}`] : [];
+        }
+        return [`--${key}=${value}`];
+      });
+  },
+
+  /**
+   * @param {Record<string, string | boolean | undefined>} options
+   * @returns {string}
+   * @link https://cloud.google.com/sdk/gcloud/reference/topic/escaping
+   */
+  getMetadata(options) {
+    const delimiter = Math.random().toString(36).substring(2, 15);
+    const entries = Object.entries(options)
+      .map(([key, value]) => `${key}=${value}`)
+      .join(delimiter);
+    return `^${delimiter}^${entries}`;
+  },
+
+  /**
+   * @param {string} name
+   * @returns {string}
+   */
+  getLabel(name) {
+    return name.replace(/[^a-z0-9_-]/g, "-").toLowerCase();
+  },
+
+  /**
+   * @typedef {Object} GoogleImage
+   * @property {string} id
+   * @property {string} name
+   * @property {string} family
+   * @property {"X86_64" | "ARM64"} architecture
+   * @property {string} diskSizeGb
+   * @property {string} selfLink
+   * @property {"READY"} status
+   * @property {string} creationTimestamp
+   */
+
+  /**
+   * @param {Partial<GoogleImage>} [options]
+   * @returns {Promise<GoogleImage[]>}
+   * @link https://cloud.google.com/sdk/gcloud/reference/compute/images/list
+   */
+  async listImages(options) {
+    const filters = google.getFilters(options);
+    const images = await google.spawn($`compute images list ${filters} --preview-images --show-deprecated`);
+    return images.sort((a, b) => (a.creationTimestamp < b.creationTimestamp ? 1 : -1));
+  },
+
+  /**
+   * @param {Record<string, string | boolean | undefined>} options
+   * @returns {Promise<GoogleImage>}
+   * @link https://cloud.google.com/sdk/gcloud/reference/compute/images/create
+   */
+  async createImage(options) {
+    const { name, ...otherOptions } = options;
+    const flags = this.getFlags(otherOptions);
+    const imageId = name || "i-" + Math.random().toString(36).substring(2, 15);
+    return this.spawn($`compute images create ${imageId} ${flags}`);
+  },
+
+  /**
+   * @typedef {Object} GoogleInstance
+   * @property {string} id
+   * @property {string} name
+   * @property {"RUNNING"} status
+   * @property {string} machineType
+   * @property {string} zone
+   * @property {GoogleDisk[]} disks
+   * @property {GoogleNetworkInterface[]} networkInterfaces
+   * @property {object} [scheduling]
+   * @property {"STANDARD" | "SPOT"} [scheduling.provisioningModel]
+   * @property {boolean} [scheduling.preemptible]
+   * @property {Record<string, string | undefined>} [labels]
+   * @property {string} selfLink
+   * @property {string} creationTimestamp
+   */
+
+  /**
+   * @typedef {Object} GoogleDisk
+   * @property {string} deviceName
+   * @property {boolean} boot
+   * @property {"X86_64" | "ARM64"} architecture
+   * @property {string[]} [licenses]
+   * @property {number} diskSizeGb
+   */
+
+  /**
+   * @typedef {Object} GoogleNetworkInterface
+   * @property {"IPV4_ONLY" | "IPV4_IPV6" | "IPV6_ONLY"} stackType
+   * @property {string} name
+   * @property {string} network
+   * @property {string} networkIP
+   * @property {string} subnetwork
+   * @property {GoogleAccessConfig[]} accessConfigs
+   */
+
+  /**
+   * @typedef {Object} GoogleAccessConfig
+   * @property {string} name
+   * @property {"ONE_TO_ONE_NAT" | "INTERNAL_NAT"} type
+   * @property {string} [natIP]
+   */
+
+  /**
+   * @param {Record<string, string | boolean | undefined>} options
+   * @returns {Promise<GoogleInstance>}
+   * @link https://cloud.google.com/sdk/gcloud/reference/compute/instances/create
+   */
+  async createInstance(options) {
+    const { name, ...otherOptions } = options || {};
+    const flags = this.getFlags(otherOptions);
+    const instanceId = name || "i-" + Math.random().toString(36).substring(2, 15);
+    const [instance] = await this.spawn($`compute instances create ${instanceId} ${flags}`);
+    return instance;
+  },
+
+  /**
+   * @param {string} instanceId
+   * @param {string} zoneId
+   * @returns {Promise<void>}
+   * @link https://cloud.google.com/sdk/gcloud/reference/compute/instances/stop
+   */
+  async stopInstance(instanceId, zoneId) {
+    await this.spawn($`compute instances stop ${instanceId} --zone=${zoneId}`);
+  },
+
+  /**
+   * @param {string} instanceId
+   * @param {string} zoneId
+   * @returns {Promise<void>}
+   * @link https://cloud.google.com/sdk/gcloud/reference/compute/instances/delete
+   */
+  async deleteInstance(instanceId, zoneId) {
+    await this.spawn($`compute instances delete ${instanceId} --delete-disks=all --zone=${zoneId}`, {
+      throwOnError: error => !/not found/i.test(inspect(error)),
+    });
+  },
+
+  /**
+   * @param {string} instanceId
+   * @param {string} username
+   * @param {string} zoneId
+   * @param {object} [options]
+   * @param {boolean} [options.wait]
+   * @returns {Promise<string | undefined>}
+   * @link https://cloud.google.com/sdk/gcloud/reference/compute/reset-windows-password
+   */
+  async resetWindowsPassword(instanceId, username, zoneId, options = {}) {
+    const attempts = options.wait ? 15 : 1;
+    for (let i = 0; i < attempts; i++) {
+      const result = await this.spawn(
+        $`compute reset-windows-password ${instanceId} --user=${username} --zone=${zoneId}`,
+        {
+          throwOnError: error => !/instance may not be ready for use/i.test(inspect(error)),
+        },
+      );
+      if (result) {
+        const { password } = result;
+        if (password) {
+          return password;
+        }
+      }
+      await new Promise(resolve => setTimeout(resolve, 60000 * i));
+    }
+  },
+
+  /**
+   * @param {Partial<GoogleInstance>} options
+   * @returns {Promise<GoogleInstance[]>}
+   */
+  async listInstances(options) {
+    const filters = this.getFilters(options);
+    const instances = await this.spawn($`compute instances list ${filters}`);
+    return instances.sort((a, b) => (a.creationTimestamp < b.creationTimestamp ? 1 : -1));
+  },
+
+  /**
+   * @param {MachineOptions} options
+   * @returns {Promise<GoogleImage>}
+   */
+  async getMachineImage(options) {
+    const { os, arch, distro, release } = options;
+    const architecture = arch === "aarch64" ? "ARM64" : "X86_64";
+
+    /** @type {string | undefined} */
+    let family;
+    if (os === "linux") {
+      if (!distro || distro === "debian") {
+        family = `debian-${release || "*"}`;
+      } else if (distro === "ubuntu") {
+        family = `ubuntu-${release?.replace(/\./g, "") || "*"}`;
+      } else if (distro === "fedora") {
+        family = `fedora-coreos-${release || "*"}`;
+      } else if (distro === "rhel") {
+        family = `rhel-${release || "*"}`;
+      }
+    } else if (os === "windows" && arch === "x64") {
+      if (!distro || distro === "server") {
+        family = `windows-${release || "*"}`;
+      }
+    }
+
+    if (family) {
+      const images = await this.listImages({ family, architecture });
+      if (images.length) {
+        const [image] = images;
+        return image;
+      }
+    }
+
+    throw new Error(`Unsupported platform: ${inspect(options)}`);
+  },
+
+  /**
+   * @param {MachineOptions} options
+   * @returns {Promise<Machine>}
+   */
+  async createMachine(options) {
+    const { name, os, arch, distro, instanceType, tags, preemptible, detached } = options;
+    const image = await google.getMachineImage(options);
+    const { selfLink: imageUrl } = image;
+
+    const username = getUsername(distro || os);
+    const userData = getUserData({ ...options, username });
+
+    /** @type {Record<string, string>} */
+    let metadata;
+    if (os === "windows") {
+      metadata = {
+        "enable-windows-ssh": "TRUE",
+        "sysprep-specialize-script-ps1": userData,
+      };
+    } else {
+      metadata = {
+        "user-data": userData,
+      };
+    }
+
+    const instance = await google.createInstance({
+      "name": name,
+      "zone": "us-central1-a",
+      "image": imageUrl,
+      "machine-type": instanceType || (arch === "aarch64" ? "t2a-standard-2" : "t2d-standard-2"),
+      "boot-disk-auto-delete": true,
+      "boot-disk-size": `${getDiskSize(options)}GB`,
+      "metadata": this.getMetadata(metadata),
+      "labels": Object.entries(tags || {})
+        .filter(([, value]) => value !== undefined)
+        .map(([key, value]) => `${this.getLabel(key)}=${value}`)
+        .join(","),
+      "provisioning-model": preemptible ? "SPOT" : "STANDARD",
+      "instance-termination-action": preemptible || !detached ? "DELETE" : undefined,
+      "no-restart-on-failure": true,
+      "threads-per-core": 1,
+      "max-run-duration": detached ? undefined : "6h",
+    });
+
+    return this.toMachine(instance, options);
+  },
+
+  /**
+   * @param {GoogleInstance} instance
+   * @param {MachineOptions} [options]
+   * @returns {Machine}
+   */
+  toMachine(instance, options = {}) {
+    const { id: instanceId, name, zone: zoneUrl, machineType: machineTypeUrl, labels } = instance;
+    const machineType = machineTypeUrl.split("/").pop();
+    const zoneId = zoneUrl.split("/").pop();
+
+    let os, arch, distro, release;
+    const { disks = [] } = instance;
+    for (const { boot, architecture, licenses = [] } of disks) {
+      if (!boot) {
+        continue;
+      }
+
+      if (architecture === "X86_64") {
+        arch = "x64";
+      } else if (architecture === "ARM64") {
+        arch = "aarch64";
+      }
+
+      for (const license of licenses) {
+        const linuxMatch = /(debian|ubuntu|fedora|rhel)-(\d+)/i.exec(license);
+        if (linuxMatch) {
+          os = "linux";
+          [, distro, release] = linuxMatch;
+        } else {
+          const windowsMatch = /windows-server-(\d+)-dc-core/i.exec(license);
+          if (windowsMatch) {
+            os = "windows";
+            distro = "windowsserver";
+            [, release] = windowsMatch;
+          }
+        }
+      }
+    }
+
+    let publicIp;
+    const { networkInterfaces = [] } = instance;
+    for (const { accessConfigs = [] } of networkInterfaces) {
+      for (const { type, natIP } of accessConfigs) {
+        if (type === "ONE_TO_ONE_NAT" && natIP) {
+          publicIp = natIP;
+        }
+      }
+    }
+
+    let preemptible;
+    const { scheduling } = instance;
+    if (scheduling) {
+      const { provisioningModel, preemptible: isPreemptible } = scheduling;
+      preemptible = provisioningModel === "SPOT" || isPreemptible;
+    }
+
+    /**
+     * @returns {SshOptions}
+     */
+    const connect = () => {
+      if (!publicIp) {
+        throw new Error(`Failed to find public IP for instance: ${name}`);
+      }
+
+      /** @type {string | undefined} */
+      let username;
+
+      const { os, distro } = options;
+      if (os || distro) {
+        username = getUsername(distro || os);
+      }
+
+      return { hostname: publicIp, username };
+    };
+
+    const spawn = async (command, options) => {
+      const connectOptions = connect();
+      return spawnSsh({ ...connectOptions, command }, options);
+    };
+
+    const spawnSafe = async (command, options) => {
+      const connectOptions = connect();
+      return spawnSshSafe({ ...connectOptions, command }, options);
+    };
+
+    const rdp = async () => {
+      const { hostname, username } = connect();
+      const rdpUsername = `${username}-rdp`;
+      const password = await google.resetWindowsPassword(instanceId, rdpUsername, zoneId, { wait: true });
+      return { hostname, username: rdpUsername, password };
+    };
+
+    const attach = async () => {
+      const connectOptions = connect();
+      await spawnSshSafe({ ...connectOptions });
+    };
+
+    const upload = async (source, destination) => {
+      const connectOptions = connect();
+      await spawnScp({ ...connectOptions, source, destination });
+    };
+
+    const snapshot = async name => {
+      const stopResult = await this.stopInstance(instanceId, zoneId);
+      console.log(stopResult);
+      const image = await this.createImage({
+        ["source-disk"]: instanceId,
+        ["zone"]: zoneId,
+        ["name"]: name || `${instanceId}-snapshot-${Date.now()}`,
+      });
+      console.log(image);
+      return;
+    };
+
+    const terminate = async () => {
+      await google.deleteInstance(instanceId, zoneId);
+    };
+
+    return {
+      cloud: "google",
+      os,
+      arch,
+      distro,
+      release,
+      id: instanceId,
+      imageId: undefined,
+      name,
+      instanceType: machineType,
+      region: zoneId,
+      publicIp,
+      preemptible,
+      labels,
+      spawn,
+      spawnSafe,
+      rdp,
+      attach,
+      upload,
+      snapshot,
+      close: terminate,
+      [Symbol.asyncDispose]: terminate,
+    };
+  },
+
+  /**
+   * @param {Record<string, string>} [labels]
+   * @returns {Promise<Machine[]>}
+   */
+  async getMachines(labels) {
+    const filters = labels ? this.getFilters({ labels }) : {};
+    const instances = await google.listInstances(filters);
+    return instances.map(instance => this.toMachine(instance));
+  },
+
+  /**
+   * @param {MachineOptions} options
+   * @returns {Promise<MachineImage>}
+   */
+  async getImage(options) {
+    const { os, arch, distro, release } = options;
+    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)}`);
+  },
+};
+
+/**
+ * @typedef CloudInit
+ * @property {string} [distro]
+ * @property {SshKey[]} [sshKeys]
+ * @property {string} [username]
+ * @property {string} [password]
+ */
+
+/**
+ * @param {CloudInit} cloudInit
+ * @returns {string}
+ */
+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;
+  }
+
+  let users;
+  if (username === "root") {
+    users = [`root:${password}`];
+  } else {
+    users = [`root:${password}`, `${username}:${password}`];
+  }
+
+  // https://cloudinit.readthedocs.io/en/stable/
+  return `#cloud-config
+    write_files:
+      - path: /etc/ssh/sshd_config
+        content: |
+          PermitRootLogin yes
+          PasswordAuthentication no
+          PubkeyAuthentication yes
+          UsePAM yes
+          UseLogin yes
+          Subsystem sftp ${sftpPath}
+    chpasswd:
+      expire: false
+      list: ${JSON.stringify(users)}
+    disable_root: false
+    ssh_pwauth: true
+    ssh_authorized_keys: ${authorizedKeys}
+  `;
+}
+
+/**
+ * @param {CloudInit} cloudInit
+ * @returns {string}
+ */
+function getWindowsStartupScript(cloudInit) {
+  const { sshKeys } = cloudInit;
+  const authorizedKeys = sshKeys.map(({ publicKey }) => publicKey);
+
+  return `
+    $ErrorActionPreference = "Stop"
+    Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass -Force
+
+    function Install-Ssh {
+      $sshdService = Get-Service -Name sshd -ErrorAction SilentlyContinue
+      if (-not $sshdService) {
+        $buildNumber = Get-WmiObject Win32_OperatingSystem | Select-Object -ExpandProperty BuildNumber
+        if ($buildNumber -lt 17763) {
+          Write-Output "Installing OpenSSH server through Github..."
+          [Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
+          Invoke-WebRequest -Uri "https://github.com/PowerShell/Win32-OpenSSH/releases/download/v9.8.0.0p1-Preview/OpenSSH-Win64.zip" -OutFile "$env:TEMP\\OpenSSH.zip"
+          Expand-Archive -Path "$env:TEMP\\OpenSSH.zip" -DestinationPath "$env:TEMP\\OpenSSH" -Force
+          Get-ChildItem -Path "$env:TEMP\\OpenSSH\\OpenSSH-Win64" -Recurse | Move-Item -Destination "$env:ProgramFiles\\OpenSSH" -Force
+          & "$env:ProgramFiles\\OpenSSH\\install-sshd.ps1"
+        } else {
+          Write-Output "Installing OpenSSH server through Windows Update..."
+          Add-WindowsCapability -Online -Name OpenSSH.Server~~~~0.0.1.0
+        }
+      }
+
+      Write-Output "Enabling OpenSSH server..."
+      Set-Service -Name sshd -StartupType Automatic
+      Start-Service sshd
+
+      $pwshPath = Get-Command pwsh -ErrorAction SilentlyContinue | Select-Object -ExpandProperty Path
+      if (-not $pwshPath) {
+        $pwshPath = Get-Command powershell -ErrorAction SilentlyContinue | Select-Object -ExpandProperty Path
+      }
+
+      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" -ErrorAction SilentlyContinue
+      if (-not $firewallRule) {
+        Write-Output "Configuring firewall..."
+        New-NetFirewallRule -Profile Any -Name 'OpenSSH-Server' -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;
+  }
+
+  // After Visual Studio and dependencies are installed,
+  // there is ~50GB of used disk space.
+  if (os === "windows") {
+    return 60;
+  }
+
+  return 30;
+}
+
+/**
+ * @typedef SshKey
+ * @property {string} [privatePath]
+ * @property {string} [publicPath]
+ * @property {string} publicKey
+ */
+
+/**
+ * @returns {SshKey}
+ */
+function createSshKey() {
+  const sshKeyGen = which("ssh-keygen", { required: true });
+  const sshAdd = which("ssh-add", { required: true });
+
+  const sshPath = join(homedir(), ".ssh");
+  mkdir(sshPath);
+
+  const filename = `id_rsa_${crypto.randomUUID()}`;
+  const privatePath = join(sshPath, filename);
+  const publicPath = join(sshPath, `${filename}.pub`);
+  spawnSyncSafe([sshKeyGen, "-t", "rsa", "-b", "4096", "-f", privatePath, "-N", ""], { stdio: "inherit" });
+  if (!existsSync(privatePath) || !existsSync(publicPath)) {
+    throw new Error(`Failed to generate SSH key: ${privatePath} / ${publicPath}`);
+  }
+
+  if (isWindows) {
+    spawnSyncSafe([sshAdd, privatePath], { stdio: "inherit" });
+  } else {
+    const sshAgent = which("ssh-agent");
+    if (sshAgent) {
+      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, encoding: "utf-8" });
+    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;
+}
+
+/**
+ * @param {string} username
+ * @returns {Promise<SshKey[]>}
+ */
+async function getGithubUserSshKeys(username) {
+  const url = new URL(`${username}.keys`, getGithubUrl());
+  const publicKeys = await curlSafe(url);
+  return publicKeys
+    .split("\n")
+    .filter(key => key.length)
+    .map(key => ({ publicKey: `${key} github@${username}` }));
+}
+
+/**
+ * @param {string} organization
+ * @returns {Promise<SshKey[]>}
+ */
+async function getGithubOrgSshKeys(organization) {
+  const url = new URL(`orgs/${encodeURIComponent(organization)}/members`, getGithubApiUrl());
+  const members = await curlSafe(url, { json: true });
+
+  /** @type {SshKey[][]} */
+  const sshKeys = await Promise.all(
+    members.filter(({ type, login }) => type === "User" && login).map(({ login }) => getGithubUserSshKeys(login)),
+  );
+
+  return sshKeys.flat();
+}
+
+/**
+ * @typedef SshOptions
+ * @property {string} hostname
+ * @property {number} [port]
+ * @property {string} [username]
+ * @property {string} [password]
+ * @property {string[]} [command]
+ * @property {string[]} [identityPaths]
+ * @property {number} [retries]
+ */
+
+/**
+ * @param {SshOptions} options
+ * @param {import("./utils.mjs").SpawnOptions} [spawnOptions]
+ * @returns {Promise<import("./utils.mjs").SpawnResult>}
+ */
+async function spawnSsh(options, spawnOptions = {}) {
+  const { hostname, port, username, identityPaths, password, retries = 10, command: spawnCommand } = options;
+
+  if (!hostname.includes("@")) {
+    await waitForPort({
+      hostname,
+      port: port || 22,
+    });
+  }
+
+  const logPath = mkdtemp("ssh-", "ssh.log");
+  const command = ["ssh", hostname, "-v", "-C", "-E", logPath, "-o", "StrictHostKeyChecking=no"];
+  if (!password) {
+    command.push("-o", "BatchMode=yes");
+  }
+  if (port) {
+    command.push("-p", port);
+  }
+  if (username) {
+    command.push("-l", username);
+  }
+  if (password) {
+    const sshPass = which("sshpass", { required: true });
+    command.unshift(sshPass, "-p", password);
+  } else if (identityPaths) {
+    command.push(...identityPaths.flatMap(path => ["-i", path]));
+  }
+  const stdio = spawnCommand ? "pipe" : "inherit";
+  if (spawnCommand) {
+    command.push(...spawnCommand);
+  }
+
+  /** @type {import("./utils.mjs").SpawnResult} */
+  let result;
+  for (let i = 0; i < retries; i++) {
+    result = await spawn(command, { stdio, ...spawnOptions, throwOnError: undefined });
+
+    const { exitCode } = result;
+    if (exitCode !== 255) {
+      break;
+    }
+
+    const sshLogs = readFile(logPath, { encoding: "utf-8" });
+    if (sshLogs.includes("Authenticated")) {
+      break;
+    }
+
+    await new Promise(resolve => setTimeout(resolve, (i + 1) * 15000));
+  }
+
+  if (spawnOptions?.throwOnError) {
+    const { error } = result;
+    if (error) {
+      throw error;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * @param {SshOptions} options
+ * @param {import("./utils.mjs").SpawnOptions} [spawnOptions]
+ * @returns {Promise<import("./utils.mjs").SpawnResult>}
+ */
+async function spawnSshSafe(options, spawnOptions = {}) {
+  return spawnSsh(options, { throwOnError: true, ...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, password, source, destination, retries = 10 } = options;
+  await waitForPort({ hostname, port: port || 22 });
+
+  const command = ["scp", "-o", "StrictHostKeyChecking=no"];
+  if (!password) {
+    command.push("-o", "BatchMode=yes");
+  }
+  if (port) {
+    command.push("-P", port);
+  }
+  if (password) {
+    const sshPass = which("sshpass", { required: true });
+    command.unshift(sshPass, "-p", password);
+  } else 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 });
+}
+
+/**
+ * @param {string} passwordData
+ * @param {string} privateKeyPath
+ * @returns {string}
+ */
+function decryptPassword(passwordData, privateKeyPath) {
+  const name = basename(privateKeyPath, extname(privateKeyPath));
+  const tmpPemPath = mkdtemp("pem-", `${name}.pem`);
+  try {
+    copyFile(privateKeyPath, tmpPemPath, { mode: 0o600 });
+    spawnSyncSafe(["ssh-keygen", "-p", "-m", "PEM", "-f", tmpPemPath, "-N", ""]);
+    const { stdout } = spawnSyncSafe(
+      ["openssl", "pkeyutl", "-decrypt", "-inkey", tmpPemPath, "-pkeyopt", "rsa_padding_mode:pkcs1"],
+      {
+        stdin: Buffer.from(passwordData, "base64"),
+      },
+    );
+    return stdout.trim();
+  } finally {
+    rm(tmpPemPath);
+  }
+}
+
+/**
+ * @typedef RdpCredentials
+ * @property {string} hostname
+ * @property {string} username
+ * @property {string} password
+ */
+
+/**
+ * @param {string} hostname
+ * @param {string} [username]
+ * @param {string} [password]
+ * @returns {string}
+ */
+function getRdpFile(hostname, username) {
+  const options = [
+    "auto connect:i:1", // start the connection automatically
+    `full address:s:${hostname}`,
+  ];
+  if (username) {
+    options.push(`username:s:${username}`);
+  }
+  return options.join("\n");
+}
+
+/**
+ * @typedef Cloud
+ * @property {string} name
+ * @property {(options: MachineOptions) => Promise<Machine>} createMachine
+ */
+
+/**
+ * @param {string} name
+ * @returns {Cloud}
+ */
+function getCloud(name) {
+  switch (name) {
+    case "docker":
+      return docker;
+    case "orbstack":
+      return orbstack;
+    case "tart":
+      return tart;
+    case "aws":
+      return aws;
+    case "google":
+      return google;
+  }
+  throw new Error(`Unsupported cloud: ${name}`);
+}
+
+/**
+ * @typedef {"linux" | "darwin" | "windows"} Os
+ * @typedef {"aarch64" | "x64"} Arch
+ * @typedef {"macos" | "windowsserver" | "debian" | "ubuntu" | "alpine" | "amazonlinux"} Distro
+ */
+
+/**
+ * @typedef {Object} Platform
+ * @property {Os} os
+ * @property {Arch} arch
+ * @property {Distro} distro
+ * @property {string} release
+ * @property {string} [eol]
+ */
+
+/**
+ * @typedef {Object} Machine
+ * @property {string} cloud
+ * @property {Os} [os]
+ * @property {Arch} [arch]
+ * @property {Distro} [distro]
+ * @property {string} [release]
+ * @property {string} [name]
+ * @property {string} id
+ * @property {string} imageId
+ * @property {string} instanceType
+ * @property {string} region
+ * @property {string} [publicIp]
+ * @property {boolean} [preemptible]
+ * @property {Record<string, string>} tags
+ * @property {(command: string[], options?: import("./utils.mjs").SpawnOptions) => Promise<import("./utils.mjs").SpawnResult>} spawn
+ * @property {(command: string[], options?: import("./utils.mjs").SpawnOptions) => Promise<import("./utils.mjs").SpawnResult>} spawnSafe
+ * @property {(source: string, destination: string) => Promise<void>} upload
+ * @property {() => Promise<RdpCredentials>} [rdp]
+ * @property {() => Promise<void>} attach
+ * @property {() => Promise<string>} snapshot
+ * @property {() => Promise<void>} close
+ */
+
+/**
+ * @typedef MachineOptions
+ * @property {Cloud} cloud
+ * @property {Os} os
+ * @property {Arch} arch
+ * @property {Distro} distro
+ * @property {string} [release]
+ * @property {string} [name]
+ * @property {string} [instanceType]
+ * @property {string} [imageId]
+ * @property {string} [imageName]
+ * @property {number} [cpuCount]
+ * @property {number} [memoryGb]
+ * @property {number} [diskSizeGb]
+ * @property {boolean} [preemptible]
+ * @property {boolean} [detached]
+ * @property {Record<string, unknown>} [tags]
+ * @property {boolean} [bootstrap]
+ * @property {boolean} [ci]
+ * @property {boolean} [rdp]
+ * @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" },
+      "release": { type: "string" },
+      "name": { 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" },
+      "preemptible": { type: "boolean" },
+      "spot": { type: "boolean" },
+      "detached": { type: "boolean" },
+      "tag": { type: "string", multiple: true },
+      "ci": { type: "boolean" },
+      "rdp": { type: "boolean" },
+      "vnc": { type: "boolean" },
+      "authorized-user": { type: "string", multiple: true },
+      "authorized-org": { type: "string", multiple: true },
+      "no-bootstrap": { type: "boolean" },
+      "buildkite-token": { type: "string" },
+      "tailscale-authkey": { type: "string" },
+    },
+  });
+
+  const sshKeys = getSshKeys();
+  if (args["authorized-user"]) {
+    const userSshKeys = await Promise.all(args["authorized-user"].map(getGithubUserSshKeys));
+    sshKeys.push(...userSshKeys.flat());
+  }
+  if (args["authorized-org"]) {
+    const orgSshKeys = await Promise.all(args["authorized-org"].map(getGithubOrgSshKeys));
+    sshKeys.push(...orgSshKeys.flat());
+  }
+
+  const tags = {
+    "robobun": "true",
+    "robobun2": "true",
+    "buildkite:token": args["buildkite-token"],
+    "tailscale:authkey": args["tailscale-authkey"],
+    ...Object.fromEntries(args["tag"]?.map(tag => tag.split("=")) ?? []),
+  };
+
+  const cloud = getCloud(args["cloud"]);
+
+  /** @type {MachineOptions} */
+  const options = {
+    cloud: args["cloud"],
+    os: parseOs(args["os"]),
+    arch: parseArch(args["arch"]),
+    distro: args["distro"],
+    release: args["release"],
+    name: args["name"],
+    instanceType: args["instance-type"],
+    imageId: args["image-id"],
+    imageName: args["image-name"],
+    tags,
+    cpuCount: parseInt(args["cpu-count"]) || undefined,
+    memoryGb: parseInt(args["memory-gb"]) || undefined,
+    diskSizeGb: parseInt(args["disk-size-gb"]) || undefined,
+    preemptible: !!args["preemptible"] || !!args["spot"],
+    detached: !!args["detached"],
+    bootstrap: args["no-bootstrap"] !== true,
+    ci: !!args["ci"],
+    rdp: !!args["rdp"] || !!args["vnc"],
+    sshKeys,
+  };
+
+  const { detached, bootstrap, ci, os, arch, distro, release } = options;
+  const name = distro ? `${os}-${arch}-${distro}-${release}` : `${os}-${arch}-${release}`;
+
+  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:");
+    console.table({
+      "Operating System": os,
+      "Architecture": arch,
+      "Distribution": distro ? `${distro} ${release}` : release,
+      "CI": ci ? "Yes" : "No",
+    });
+
+    const result = await cloud.createMachine(options);
+    const { id, name, imageId, instanceType, region, publicIp } = result;
+    console.log("Created machine:");
+    console.table({
+      "ID": id,
+      "Name": name || "N/A",
+      "Image ID": imageId,
+      "Instance Type": instanceType,
+      "Region": region,
+      "IP Address": publicIp || "TBD",
+    });
+
+    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 {
+    if (options.rdp) {
+      await startGroup("Connecting with RDP...", async () => {
+        const { hostname, username, password } = await machine.rdp();
+
+        console.log("You can now connect with RDP using these credentials:");
+        console.table({
+          Hostname: hostname,
+          Username: username,
+          Password: password,
+        });
+
+        const { cloud, id } = machine;
+        const rdpPath = mkdtemp("rdp-", `${cloud}-${id}.rdp`);
+
+        /** @type {string[]} */
+        let command;
+        if (isMacOS) {
+          command = [
+            "osascript",
+            "-e",
+            `'tell application "Microsoft Remote Desktop" to open POSIX file ${JSON.stringify(rdpPath)}'`,
+          ];
+        }
+
+        if (command) {
+          writeFile(rdpPath, getRdpFile(hostname, username));
+          await spawn(command, { detached: true });
+        }
+      });
+    }
+
+    await startGroup("Connecting with SSH...", 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") {
+        const remotePath = "C:\\buildkite-agent\\agent.mjs";
+        await startGroup("Installing agent...", async () => {
+          await machine.upload(agentPath, remotePath);
+          if (cloud.name === "docker") {
+            return;
+          }
+          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]);
+          if (cloud.name === "docker") {
+            return;
+          }
+          {
+            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(os)}`;
+      } 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 f91996381f..3fa3eaa66a 100755
--- a/scripts/runner.node.mjs
+++ b/scripts/runner.node.mjs
@@ -17,45 +17,38 @@ import {
   accessSync,
   appendFileSync,
   readdirSync,
-  rmSync,
 } from "node:fs";
 import { spawn, spawnSync } from "node:child_process";
-import { tmpdir, hostname, userInfo, homedir } from "node:os";
 import { join, basename, dirname, relative, sep } from "node:path";
-import { normalize as normalizeWindows } from "node:path/win32";
-import { isIP } from "node:net";
 import { parseArgs } from "node:util";
+import {
+  getBuildLabel,
+  getBuildUrl,
+  getEnv,
+  getFileUrl,
+  getLoggedInUserCount,
+  getShell,
+  getWindowsExitReason,
+  isArm64,
+  isBuildkite,
+  isCI,
+  isGithubAction,
+  isMacOS,
+  isWindows,
+  printEnvironment,
+  startGroup,
+  tmpdir,
+  unzip,
+} from "./utils.mjs";
+import { userInfo } from "node:os";
+
+const cwd = import.meta.dirname ? dirname(import.meta.dirname) : process.cwd();
+const testsPath = join(cwd, "test");
 
 const spawnTimeout = 5_000;
 const testTimeout = 3 * 60_000;
 const integrationTimeout = 5 * 60_000;
 
-const isLinux = process.platform === "linux";
-const isMacOS = process.platform === "darwin";
-const isWindows = process.platform === "win32";
-
-const isGitHubAction = !!process.env["GITHUB_ACTIONS"];
-const isBuildKite = !!process.env["BUILDKITE"];
-const isBuildKiteTestSuite = !!process.env["BUILDKITE_ANALYTICS_TOKEN"];
-const isCI = !!process.env["CI"] || isGitHubAction || isBuildKite;
-
-const isAWS =
-  /^ec2/i.test(process.env["USERNAME"]) ||
-  /^ec2/i.test(process.env["USER"]) ||
-  /^(?:ec2|ip)/i.test(process.env["HOSTNAME"]) ||
-  /^(?:ec2|ip)/i.test(getHostname());
-const isCloud = isAWS;
-
-const baseUrl = process.env["GITHUB_SERVER_URL"] || "https://github.com";
-const repository = process.env["GITHUB_REPOSITORY"] || "oven-sh/bun";
-const pullRequest = /^pull\/(\d+)$/.exec(process.env["GITHUB_REF"])?.[1];
-const gitSha = getGitSha();
-const gitRef = getGitRef();
-
-const cwd = dirname(import.meta.dirname);
-const testsPath = join(cwd, "test");
-const tmpPath = getTmpdir();
-
 const { values: options, positionals: filters } = parseArgs({
   allowPositionals: true,
   options: {
@@ -67,17 +60,21 @@ const { values: options, positionals: filters } = parseArgs({
       type: "string",
       default: undefined,
     },
+    ["build-id"]: {
+      type: "string",
+      default: undefined,
+    },
     ["bail"]: {
       type: "boolean",
       default: false,
     },
     ["shard"]: {
       type: "string",
-      default: process.env["BUILDKITE_PARALLEL_JOB"] || "0",
+      default: getEnv("BUILDKITE_PARALLEL_JOB", false) || "0",
     },
     ["max-shards"]: {
       type: "string",
-      default: process.env["BUILDKITE_PARALLEL_JOB_COUNT"] || "1",
+      default: getEnv("BUILDKITE_PARALLEL_JOB_COUNT", false) || "1",
     },
     ["include"]: {
       type: "string",
@@ -93,40 +90,13 @@ const { values: options, positionals: filters } = parseArgs({
       type: "string",
       default: undefined,
     },
+    ["vendor"]: {
+      type: "string",
+      default: undefined,
+    },
   },
 });
 
-async function printInfo() {
-  console.log("Timestamp:", new Date());
-  console.log("OS:", getOsPrettyText(), getOsEmoji());
-  console.log("Arch:", getArchText(), getArchEmoji());
-  if (isLinux) {
-    console.log("Glibc:", getGlibcVersion());
-  }
-  console.log("Hostname:", getHostname());
-  if (isCI) {
-    console.log("CI:", getCI());
-    console.log("Shard:", options["shard"], "/", options["max-shards"]);
-    console.log("Build URL:", getBuildUrl());
-    console.log("Environment:", process.env);
-    if (isCloud) {
-      console.log("Public IP:", await getPublicIp());
-      console.log("Cloud:", getCloud());
-    }
-    const tailscaleIp = await getTailscaleIp();
-    if (tailscaleIp) {
-      console.log("Tailscale IP:", tailscaleIp);
-    }
-  }
-  console.log("Cwd:", cwd);
-  console.log("Tmpdir:", tmpPath);
-  console.log("Commit:", gitSha);
-  console.log("Ref:", gitRef);
-  if (pullRequest) {
-    console.log("Pull Request:", pullRequest);
-  }
-}
-
 /**
  *
  * @returns {Promise<TestResult[]>}
@@ -134,32 +104,7 @@ async function printInfo() {
 async function runTests() {
   let execPath;
   if (options["step"]) {
-    downloadLoop: for (let i = 0; i < 10; i++) {
-      execPath = await getExecPathFromBuildKite(options["step"]);
-      for (let j = 0; j < 10; j++) {
-        const { error } = spawnSync(execPath, ["--version"], {
-          encoding: "utf-8",
-          timeout: spawnTimeout,
-          env: {
-            PATH: process.env.PATH,
-            BUN_DEBUG_QUIET_LOGS: 1,
-          },
-        });
-        if (!error) {
-          break downloadLoop;
-        }
-        const { code } = error;
-        if (code === "EBUSY") {
-          console.log("Bun appears to be busy, retrying...");
-          continue;
-        }
-        if (code === "UNKNOWN") {
-          console.log("Bun appears to be corrupted, downloading again...");
-          rmSync(execPath, { force: true });
-          continue downloadLoop;
-        }
-      }
-    }
+    execPath = await getExecPathFromBuildKite(options["step"], options["build-id"]);
   } else {
     execPath = getExecPath(options["exec-path"]);
   }
@@ -171,35 +116,54 @@ async function runTests() {
   const tests = getRelevantTests(testsPath);
   console.log("Running tests:", tests.length);
 
+  /** @type {VendorTest[] | undefined} */
+  let vendorTests;
+  let vendorTotal = 0;
+  if (/true|1|yes|on/i.test(options["vendor"]) || (isCI && typeof options["vendor"] === "undefined")) {
+    vendorTests = await getVendorTests(cwd);
+    if (vendorTests.length) {
+      vendorTotal = vendorTests.reduce((total, { testPaths }) => total + testPaths.length + 1, 0);
+      console.log("Running vendor tests:", vendorTotal);
+    }
+  }
+
   let i = 0;
-  let total = tests.length + 2;
+  let total = vendorTotal + tests.length + 2;
   const results = [];
 
   /**
    * @param {string} title
    * @param {function} fn
+   * @returns {Promise<TestResult>}
    */
   const runTest = async (title, fn) => {
     const label = `${getAnsi("gray")}[${++i}/${total}]${getAnsi("reset")} ${title}`;
-    const result = await runTask(label, fn);
+    const result = await startGroup(label, fn);
     results.push(result);
 
-    if (isBuildKite) {
+    if (isBuildkite) {
       const { ok, error, stdoutPreview } = result;
-      const markdown = formatTestToMarkdown(result);
-      if (markdown) {
-        reportAnnotationToBuildKite(title, markdown);
+      if (title.startsWith("vendor")) {
+        const markdown = formatTestToMarkdown({ ...result, testPath: title });
+        if (markdown) {
+          reportAnnotationToBuildKite({ label: title, content: markdown, style: "warning", priority: 5 });
+        }
+      } else {
+        const markdown = formatTestToMarkdown(result);
+        if (markdown) {
+          reportAnnotationToBuildKite({ label: title, content: markdown, style: "error" });
+        }
       }
 
       if (!ok) {
         const label = `${getAnsi("red")}[${i}/${total}] ${title} - ${error}${getAnsi("reset")}`;
-        await runTask(label, () => {
+        startGroup(label, () => {
           process.stderr.write(stdoutPreview);
         });
       }
     }
 
-    if (isGitHubAction) {
+    if (isGithubAction) {
       const summaryPath = process.env["GITHUB_STEP_SUMMARY"];
       if (summaryPath) {
         const longMarkdown = formatTestToMarkdown(result);
@@ -212,6 +176,8 @@ async function runTests() {
     if (options["bail"] && !result.ok) {
       process.exit(getExitCode("fail"));
     }
+
+    return result;
   };
 
   for (const path of [cwd, testsPath]) {
@@ -222,19 +188,86 @@ async function runTests() {
   if (results.every(({ ok }) => ok)) {
     for (const testPath of tests) {
       const title = relative(cwd, join(testsPath, testPath)).replace(/\\/g, "/");
+      if (title.startsWith("test/js/node/test/parallel/")) {
+        await runTest(title, async () => {
+          const { ok, error, stdout } = await spawnBun(execPath, {
+            cwd: cwd,
+            args: [title],
+            timeout: spawnTimeout,
+            env: {
+              FORCE_COLOR: "0",
+            },
+            stdout: chunk => pipeTestStdout(process.stdout, chunk),
+            stderr: chunk => pipeTestStdout(process.stderr, chunk),
+          });
+          return {
+            testPath: title,
+            ok,
+            status: ok ? "pass" : "fail",
+            error,
+            errors: [],
+            tests: [],
+            stdout,
+            stdoutPreview: "",
+          };
+        });
+        continue;
+      }
       await runTest(title, async () => spawnBunTest(execPath, join("test", testPath)));
     }
   }
 
+  if (vendorTests?.length) {
+    for (const { cwd: vendorPath, packageManager, testRunner, testPaths } of vendorTests) {
+      if (!testPaths.length) {
+        continue;
+      }
+
+      const packageJson = join(relative(cwd, vendorPath), "package.json").replace(/\\/g, "/");
+      if (packageManager === "bun") {
+        const { ok } = await runTest(packageJson, () => spawnBunInstall(execPath, { cwd: vendorPath }));
+        if (!ok) {
+          continue;
+        }
+      } else {
+        throw new Error(`Unsupported package manager: ${packageManager}`);
+      }
+
+      for (const testPath of testPaths) {
+        const title = join(relative(cwd, vendorPath), testPath).replace(/\\/g, "/");
+
+        if (testRunner === "bun") {
+          await runTest(title, () => spawnBunTest(execPath, testPath, { cwd: vendorPath }));
+        } else {
+          const testRunnerPath = join(cwd, "test", "runners", `${testRunner}.ts`);
+          if (!existsSync(testRunnerPath)) {
+            throw new Error(`Unsupported test runner: ${testRunner}`);
+          }
+          await runTest(title, () =>
+            spawnBunTest(execPath, testPath, {
+              cwd: vendorPath,
+              args: ["--preload", testRunnerPath],
+            }),
+          );
+        }
+      }
+    }
+  }
+
   const failedTests = results.filter(({ ok }) => !ok);
-  if (isGitHubAction) {
+  if (isGithubAction) {
     reportOutputToGitHubAction("failing_tests_count", failedTests.length);
     const markdown = formatTestToMarkdown(failedTests);
     reportOutputToGitHubAction("failing_tests", markdown);
   }
 
-  if (!isCI) console.log("-------");
-  if (!isCI) console.log("passing", results.length - failedTests.length, "/", results.length);
+  if (!isCI) {
+    console.log("-------");
+    console.log("passing", results.length - failedTests.length, "/", results.length);
+    for (const { testPath } of failedTests) {
+      console.log("-", testPath);
+    }
+  }
   return results;
 }
 
@@ -401,7 +434,7 @@ async function spawnSafe(options) {
     error = "timeout";
   } else if (exitCode !== 0) {
     if (isWindows) {
-      const winCode = getWindowsExitCode(exitCode);
+      const winCode = getWindowsExitReason(exitCode);
       if (winCode) {
         exitCode = winCode;
       }
@@ -427,14 +460,16 @@ async function spawnSafe(options) {
  */
 async function spawnBun(execPath, { args, cwd, timeout, env, stdout, stderr }) {
   const path = addPath(dirname(execPath), process.env.PATH);
-  const tmpdirPath = mkdtempSync(join(tmpPath, "buntmp-"));
-  const { username } = userInfo();
+  const tmpdirPath = mkdtempSync(join(tmpdir(), "buntmp-"));
+  const { username, homedir } = userInfo();
+  const shellPath = getShell();
   const bunEnv = {
     ...process.env,
     PATH: path,
     TMPDIR: tmpdirPath,
     USER: username,
-    HOME: homedir(),
+    HOME: homedir,
+    SHELL: shellPath,
     FORCE_COLOR: "1",
     BUN_FEATURE_FLAG_INTERNAL_FOR_TESTING: "1",
     BUN_DEBUG_QUIET_LOGS: "1",
@@ -450,23 +485,6 @@ async function spawnBun(execPath, { args, cwd, timeout, env, stdout, stderr }) {
   if (env) {
     Object.assign(bunEnv, env);
   }
-  // Use Linux namespaces to isolate the child process
-  // https://man7.org/linux/man-pages/man1/unshare.1.html
-  // if (isLinux) {
-  //   const { uid, gid } = userInfo();
-  //   args = [
-  //     `--wd=${cwd}`,
-  //     "--user",
-  //     `--map-user=${uid}`,
-  //     `--map-group=${gid}`,
-  //     "--fork",
-  //     "--kill-child",
-  //     "--pid",
-  //     execPath,
-  //     ...args,
-  //   ];
-  //   execPath = "unshare";
-  // }
   if (isWindows) {
     delete bunEnv["PATH"];
     bunEnv["Path"] = path;
@@ -486,11 +504,11 @@ async function spawnBun(execPath, { args, cwd, timeout, env, stdout, stderr }) {
       stderr,
     });
   } finally {
-    try {
-      rmSync(tmpdirPath, { recursive: true, force: true });
-    } catch (error) {
-      console.warn(error);
-    }
+    // try {
+    //   rmSync(tmpdirPath, { recursive: true, force: true });
+    // } catch (error) {
+    //   console.warn(error);
+    // }
   }
 }
 
@@ -529,15 +547,20 @@ async function spawnBun(execPath, { args, cwd, timeout, env, stdout, stderr }) {
  *
  * @param {string} execPath
  * @param {string} testPath
+ * @param {object} [options]
+ * @param {string} [options.cwd]
+ * @param {string[]} [options.args]
  * @returns {Promise<TestResult>}
  */
-async function spawnBunTest(execPath, testPath) {
+async function spawnBunTest(execPath, testPath, options = { cwd }) {
   const timeout = getTestTimeout(testPath);
   const perTestTimeout = Math.ceil(timeout / 2);
-  const isReallyTest = isTestStrict(testPath);
+  const absPath = join(options["cwd"], testPath);
+  const isReallyTest = isTestStrict(testPath) || absPath.includes("vendor");
+  const args = options["args"] ?? [];
   const { ok, error, stdout } = await spawnBun(execPath, {
-    args: isReallyTest ? ["test", `--timeout=${perTestTimeout}`, testPath] : [testPath],
-    cwd: cwd,
+    args: isReallyTest ? ["test", ...args, `--timeout=${perTestTimeout}`, absPath] : [...args, absPath],
+    cwd: options["cwd"],
     timeout: isReallyTest ? timeout : 30_000,
     env: {
       GITHUB_ACTIONS: "true", // always true so annotations are parsed
@@ -563,7 +586,7 @@ async function spawnBunTest(execPath, testPath) {
  * @returns {number}
  */
 function getTestTimeout(testPath) {
-  if (/integration|3rd_party|docker/i.test(testPath)) {
+  if (/integration|3rd_party|docker|bun-install-registry|v8/i.test(testPath)) {
     return integrationTimeout;
   }
   return testTimeout;
@@ -574,9 +597,9 @@ function getTestTimeout(testPath) {
  * @param {string} chunk
  */
 function pipeTestStdout(io, chunk) {
-  if (isGitHubAction) {
+  if (isGithubAction) {
     io.write(chunk.replace(/\:\:(?:end)?group\:\:.*(?:\r\n|\r|\n)/gim, ""));
-  } else if (isBuildKite) {
+  } else if (isBuildkite) {
     io.write(chunk.replace(/(?:---|\+\+\+|~~~|\^\^\^) /gim, " ").replace(/\:\:.*(?:\r\n|\r|\n)/gim, ""));
   } else {
     io.write(chunk.replace(/\:\:.*(?:\r\n|\r|\n)/gim, ""));
@@ -618,7 +641,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;
       }
@@ -735,75 +758,6 @@ async function spawnBunInstall(execPath, options) {
   };
 }
 
-/**
- * @returns {string | undefined}
- */
-function getGitSha() {
-  const sha = process.env["GITHUB_SHA"] || process.env["BUILDKITE_COMMIT"];
-  if (sha?.length === 40) {
-    return sha;
-  }
-  try {
-    const { stdout } = spawnSync("git", ["rev-parse", "HEAD"], {
-      encoding: "utf-8",
-      timeout: spawnTimeout,
-    });
-    return stdout.trim();
-  } catch (error) {
-    console.warn(error);
-  }
-}
-
-/**
- * @returns {string}
- */
-function getGitRef() {
-  const ref = process.env["GITHUB_REF_NAME"] || process.env["BUILDKITE_BRANCH"];
-  if (ref) {
-    return ref;
-  }
-  try {
-    const { stdout } = spawnSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
-      encoding: "utf-8",
-      timeout: spawnTimeout,
-    });
-    return stdout.trim();
-  } catch (error) {
-    console.warn(error);
-    return "<unknown>";
-  }
-}
-
-/**
- * @returns {string}
- */
-function getTmpdir() {
-  if (isWindows) {
-    for (const key of ["TMPDIR", "TEMP", "TEMPDIR", "TMP", "RUNNER_TEMP"]) {
-      const tmpdir = process.env[key] || "";
-      // HACK: There are too many bugs with cygwin directories.
-      // We should probably run Windows tests in both cygwin and powershell.
-      if (/cygwin|cygdrive/i.test(tmpdir) || !/^[a-z]/i.test(tmpdir)) {
-        continue;
-      }
-      return normalizeWindows(tmpdir);
-    }
-    const appData = process.env["LOCALAPPDATA"];
-    if (appData) {
-      const appDataTemp = join(appData, "Temp");
-      if (existsSync(appDataTemp)) {
-        return appDataTemp;
-      }
-    }
-  }
-  if (isMacOS) {
-    if (existsSync("/tmp")) {
-      return "/tmp";
-    }
-  }
-  return tmpdir();
-}
-
 /**
  * @param {string} path
  * @returns {boolean}
@@ -812,12 +766,20 @@ function isJavaScript(path) {
   return /\.(c|m)?(j|t)sx?$/.test(basename(path));
 }
 
+/**
+ * @param {string} path
+ * @returns {boolean}
+ */
+function isJavaScriptTest(path) {
+  return isJavaScript(path) && /\.test|spec\./.test(basename(path));
+}
+
 /**
  * @param {string} path
  * @returns {boolean}
  */
 function isTest(path) {
-  if (path.replaceAll(sep, "/").includes("/test-cluster-") && path.endsWith(".js")) return true;
+  if (path.startsWith("js/node/test/parallel/") && isMacOS && isArm64) return true;
   if (path.replaceAll(sep, "/").startsWith("js/node/cluster/test-") && path.endsWith(".ts")) return true;
   return isTestStrict(path);
 }
@@ -857,6 +819,131 @@ function getTests(cwd) {
   return [...getFiles(cwd, "")].sort();
 }
 
+/**
+ * @typedef {object} Vendor
+ * @property {string} package
+ * @property {string} repository
+ * @property {string} tag
+ * @property {string} [packageManager]
+ * @property {string} [testPath]
+ * @property {string} [testRunner]
+ * @property {string[]} [testExtensions]
+ * @property {boolean | Record<string, boolean | string>} [skipTests]
+ */
+
+/**
+ * @typedef {object} VendorTest
+ * @property {string} cwd
+ * @property {string} packageManager
+ * @property {string} testRunner
+ * @property {string[]} testPaths
+ */
+
+/**
+ * @param {string} cwd
+ * @returns {Promise<VendorTest[]>}
+ */
+async function getVendorTests(cwd) {
+  const vendorPath = join(cwd, "test", "vendor.json");
+  if (!existsSync(vendorPath)) {
+    throw new Error(`Did not find vendor.json: ${vendorPath}`);
+  }
+
+  /** @type {Vendor[]} */
+  const vendors = JSON.parse(readFileSync(vendorPath, "utf-8")).sort(
+    (a, b) => a.package.localeCompare(b.package) || a.tag.localeCompare(b.tag),
+  );
+
+  const shardId = parseInt(options["shard"]);
+  const maxShards = parseInt(options["max-shards"]);
+
+  /** @type {Vendor[]} */
+  let relevantVendors = [];
+  if (maxShards > 1) {
+    for (let i = 0; i < vendors.length; i++) {
+      if (i % maxShards === shardId) {
+        relevantVendors.push(vendors[i]);
+      }
+    }
+  } else {
+    relevantVendors = vendors.flat();
+  }
+
+  return Promise.all(
+    relevantVendors.map(
+      async ({ package: name, repository, tag, testPath, testExtensions, testRunner, packageManager, skipTests }) => {
+        const vendorPath = join(cwd, "vendor", name);
+
+        if (!existsSync(vendorPath)) {
+          await spawnSafe({
+            command: "git",
+            args: ["clone", "--depth", "1", "--single-branch", repository, vendorPath],
+            timeout: testTimeout,
+            cwd,
+          });
+        }
+
+        await spawnSafe({
+          command: "git",
+          args: ["fetch", "--depth", "1", "origin", "tag", tag],
+          timeout: testTimeout,
+          cwd: vendorPath,
+        });
+
+        const packageJsonPath = join(vendorPath, "package.json");
+        if (!existsSync(packageJsonPath)) {
+          throw new Error(`Vendor '${name}' does not have a package.json: ${packageJsonPath}`);
+        }
+
+        const testPathPrefix = testPath || "test";
+        const testParentPath = join(vendorPath, testPathPrefix);
+        if (!existsSync(testParentPath)) {
+          throw new Error(`Vendor '${name}' does not have a test directory: ${testParentPath}`);
+        }
+
+        const isTest = path => {
+          if (!isJavaScriptTest(path)) {
+            return false;
+          }
+
+          if (typeof skipTests === "boolean") {
+            return !skipTests;
+          }
+
+          if (typeof skipTests === "object") {
+            for (const [glob, reason] of Object.entries(skipTests)) {
+              const pattern = new RegExp(`^${glob.replace(/\*/g, ".*")}$`);
+              if (pattern.test(path) && reason) {
+                return false;
+              }
+            }
+          }
+
+          return true;
+        };
+
+        const testPaths = readdirSync(testParentPath, { encoding: "utf-8", recursive: true })
+          .filter(filename =>
+            testExtensions ? testExtensions.some(ext => filename.endsWith(`.${ext}`)) : isTest(filename),
+          )
+          .map(filename => join(testPathPrefix, filename))
+          .filter(
+            filename =>
+              !filters?.length ||
+              filters.some(filter => join(vendorPath, filename).replace(/\\/g, "/").includes(filter)),
+          );
+
+        return {
+          cwd: vendorPath,
+          packageManager: packageManager || "bun",
+          testRunner: testRunner || "bun",
+          testPaths,
+        };
+      },
+    ),
+  );
+}
+
 /**
  * @param {string} cwd
  * @returns {string[]}
@@ -939,27 +1026,6 @@ function getRelevantTests(cwd) {
   return filteredTests;
 }
 
-let ntStatus;
-
-/**
- * @param {number} exitCode
- * @returns {string}
- */
-function getWindowsExitCode(exitCode) {
-  if (ntStatus === undefined) {
-    const ntStatusPath = "C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.22621.0\\shared\\ntstatus.h";
-    try {
-      ntStatus = readFileSync(ntStatusPath, "utf-8");
-    } catch (error) {
-      console.warn(error);
-      ntStatus = "";
-    }
-  }
-
-  const match = ntStatus.match(new RegExp(`(STATUS_\\w+).*0x${exitCode?.toString(16)}`, "i"));
-  return match?.[1];
-}
-
 /**
  * @param {string} bunExe
  * @returns {string}
@@ -996,51 +1062,55 @@ function getExecPath(bunExe) {
 
 /**
  * @param {string} target
+ * @param {string} [buildId]
  * @returns {Promise<string>}
  */
-async function getExecPathFromBuildKite(target) {
+async function getExecPathFromBuildKite(target, buildId) {
   if (existsSync(target) || target.includes("/")) {
     return getExecPath(target);
   }
 
   const releasePath = join(cwd, "release");
   mkdirSync(releasePath, { recursive: true });
-  await spawnSafe({
-    command: "buildkite-agent",
-    args: ["artifact", "download", "**", releasePath, "--step", target],
-  });
 
   let zipPath;
-  for (const entry of readdirSync(releasePath, { recursive: true, encoding: "utf-8" })) {
-    if (/^bun.*\.zip$/i.test(entry) && !entry.includes("-profile.zip")) {
-      zipPath = join(releasePath, entry);
-      break;
+  downloadLoop: for (let i = 0; i < 10; i++) {
+    const args = ["artifact", "download", "**", releasePath, "--step", target];
+    if (buildId) {
+      args.push("--build", buildId);
     }
+
+    await spawnSafe({
+      command: "buildkite-agent",
+      args,
+    });
+
+    for (const entry of readdirSync(releasePath, { recursive: true, encoding: "utf-8" })) {
+      if (/^bun.*\.zip$/i.test(entry) && !entry.includes("-profile.zip")) {
+        zipPath = join(releasePath, entry);
+        break downloadLoop;
+      }
+    }
+
+    console.warn(`Waiting for ${target}.zip to be available...`);
+    await new Promise(resolve => setTimeout(resolve, i * 1000));
   }
 
   if (!zipPath) {
     throw new Error(`Could not find ${target}.zip from Buildkite: ${releasePath}`);
   }
 
-  if (isWindows) {
-    await spawnSafe({
-      command: "powershell",
-      args: ["-Command", `Expand-Archive -Path ${zipPath} -DestinationPath ${releasePath} -Force`],
-    });
-  } else {
-    await spawnSafe({
-      command: "unzip",
-      args: ["-o", zipPath, "-d", releasePath],
-    });
-  }
+  await unzip(zipPath, releasePath);
 
-  for (const entry of readdirSync(releasePath, { recursive: true, encoding: "utf-8" })) {
+  const releaseFiles = readdirSync(releasePath, { recursive: true, encoding: "utf-8" });
+  for (const entry of releaseFiles) {
     const execPath = join(releasePath, entry);
-    if (/bun(?:\.exe)?$/i.test(entry) && isExecutable(execPath)) {
+    if (/bun(?:\.exe)?$/i.test(entry) && statSync(execPath).isFile()) {
       return execPath;
     }
   }
 
+  console.warn(`Found ${releaseFiles.length} files in ${releasePath}:`);
   throw new Error(`Could not find executable from BuildKite: ${releasePath}`);
 }
 
@@ -1068,308 +1138,6 @@ function getRevision(execPath) {
   }
 }
 
-/**
- * @returns {string}
- */
-function getOsText() {
-  const { platform } = process;
-  switch (platform) {
-    case "darwin":
-      return "darwin";
-    case "linux":
-      return "linux";
-    case "win32":
-      return "windows";
-    default:
-      return platform;
-  }
-}
-
-/**
- * @returns {string}
- */
-function getOsPrettyText() {
-  const { platform } = process;
-  if (platform === "darwin") {
-    const properties = {};
-    for (const property of ["productName", "productVersion", "buildVersion"]) {
-      try {
-        const { error, stdout } = spawnSync("sw_vers", [`-${property}`], {
-          encoding: "utf-8",
-          timeout: spawnTimeout,
-          env: {
-            PATH: process.env.PATH,
-          },
-        });
-        if (error) {
-          throw error;
-        }
-        properties[property] = stdout.trim();
-      } catch (error) {
-        console.warn(error);
-      }
-    }
-    const { productName, productVersion, buildVersion } = properties;
-    if (!productName) {
-      return "macOS";
-    }
-    if (!productVersion) {
-      return productName;
-    }
-    if (!buildVersion) {
-      return `${productName} ${productVersion}`;
-    }
-    return `${productName} ${productVersion} (build: ${buildVersion})`;
-  }
-  if (platform === "linux") {
-    try {
-      const { error, stdout } = spawnSync("lsb_release", ["--description", "--short"], {
-        encoding: "utf-8",
-        timeout: spawnTimeout,
-        env: {
-          PATH: process.env.PATH,
-        },
-      });
-      if (error) {
-        throw error;
-      }
-      return stdout.trim();
-    } catch (error) {
-      console.warn(error);
-      return "Linux";
-    }
-  }
-  if (platform === "win32") {
-    try {
-      const { error, stdout } = spawnSync("cmd", ["/c", "ver"], {
-        encoding: "utf-8",
-        timeout: spawnTimeout,
-        env: {
-          PATH: process.env.PATH,
-        },
-      });
-      if (error) {
-        throw error;
-      }
-      return stdout.trim();
-    } catch (error) {
-      console.warn(error);
-      return "Windows";
-    }
-  }
-  return platform;
-}
-
-/**
- * @returns {string}
- */
-function getOsEmoji() {
-  const { platform } = process;
-  switch (platform) {
-    case "darwin":
-      return isBuildKite ? ":apple:" : "";
-    case "win32":
-      return isBuildKite ? ":windows:" : "🪟";
-    case "linux":
-      return isBuildKite ? ":linux:" : "🐧";
-    default:
-      return "🔮";
-  }
-}
-
-/**
- * @returns {string}
- */
-function getArchText() {
-  const { arch } = process;
-  switch (arch) {
-    case "x64":
-      return "x64";
-    case "arm64":
-      return "aarch64";
-    default:
-      return arch;
-  }
-}
-
-/**
- * @returns {string}
- */
-function getArchEmoji() {
-  const { arch } = process;
-  switch (arch) {
-    case "x64":
-      return "🖥";
-    case "arm64":
-      return "💪";
-    default:
-      return "🔮";
-  }
-}
-
-/**
- * @returns {string | undefined}
- */
-function getGlibcVersion() {
-  if (!isLinux) {
-    return;
-  }
-  try {
-    const { header } = process.report.getReport();
-    const { glibcVersionRuntime } = header;
-    if (typeof glibcVersionRuntime === "string") {
-      return glibcVersionRuntime;
-    }
-  } catch (error) {
-    console.warn(error);
-  }
-}
-
-/**
- * @returns {string | undefined}
- */
-function getBuildUrl() {
-  if (isBuildKite) {
-    const buildUrl = process.env["BUILDKITE_BUILD_URL"];
-    const jobId = process.env["BUILDKITE_JOB_ID"];
-    if (buildUrl) {
-      return jobId ? `${buildUrl}#${jobId}` : buildUrl;
-    }
-  }
-  if (isGitHubAction) {
-    const baseUrl = process.env["GITHUB_SERVER_URL"];
-    const repository = process.env["GITHUB_REPOSITORY"];
-    const runId = process.env["GITHUB_RUN_ID"];
-    if (baseUrl && repository && runId) {
-      return `${baseUrl}/${repository}/actions/runs/${runId}`;
-    }
-  }
-}
-
-/**
- * @returns {string}
- */
-function getBuildLabel() {
-  if (isBuildKite) {
-    const label = process.env["BUILDKITE_LABEL"] || process.env["BUILDKITE_GROUP_LABEL"];
-    if (label) {
-      return label.replace("- test-bun", "").replace("- bun-test", "").trim();
-    }
-  }
-  return `${getOsEmoji()} ${getArchText()}`;
-}
-
-/**
- * @param {string} file
- * @param {number} [line]
- * @returns {string | undefined}
- */
-function getFileUrl(file, line) {
-  const filePath = file.replace(/\\/g, "/");
-
-  let url;
-  if (pullRequest) {
-    const fileMd5 = crypto.createHash("md5").update(filePath).digest("hex");
-    url = `${baseUrl}/${repository}/pull/${pullRequest}/files#diff-${fileMd5}`;
-    if (line !== undefined) {
-      url += `L${line}`;
-    }
-  } else if (gitSha) {
-    url = `${baseUrl}/${repository}/blob/${gitSha}/${filePath}`;
-    if (line !== undefined) {
-      url += `#L${line}`;
-    }
-  }
-
-  return url;
-}
-
-/**
- * @returns {string | undefined}
- */
-function getCI() {
-  if (isBuildKite) {
-    return "BuildKite";
-  }
-  if (isGitHubAction) {
-    return "GitHub Actions";
-  }
-  if (isCI) {
-    return "CI";
-  }
-}
-
-/**
- * @returns {string | undefined}
- */
-function getCloud() {
-  if (isAWS) {
-    return "AWS";
-  }
-}
-
-/**
- * @returns {string | undefined}
- */
-function getHostname() {
-  if (isBuildKite) {
-    return process.env["BUILDKITE_AGENT_NAME"];
-  }
-  try {
-    return hostname();
-  } catch (error) {
-    console.warn(error);
-  }
-}
-
-/**
- * @returns {Promise<string | undefined>}
- */
-async function getPublicIp() {
-  const addressUrls = ["https://checkip.amazonaws.com", "https://ipinfo.io/ip"];
-  if (isAWS) {
-    addressUrls.unshift("http://169.254.169.254/latest/meta-data/public-ipv4");
-  }
-  for (const url of addressUrls) {
-    try {
-      const response = await fetch(url);
-      const { ok, status, statusText } = response;
-      if (!ok) {
-        throw new Error(`${status} ${statusText}: ${url}`);
-      }
-      const text = await response.text();
-      const address = text.trim();
-      if (isIP(address)) {
-        return address;
-      } else {
-        throw new Error(`Invalid IP address: ${address}`);
-      }
-    } catch (error) {
-      console.warn(error);
-    }
-  }
-}
-
-/**
- * @returns {string | undefined}
- */
-function getTailscaleIp() {
-  try {
-    const { status, stdout } = spawnSync("tailscale", ["ip", "--1"], {
-      encoding: "utf-8",
-      timeout: spawnTimeout,
-      env: {
-        PATH: process.env.PATH,
-      },
-    });
-    if (status === 0) {
-      return stdout.trim();
-    }
-  } catch {
-    // ...
-  }
-}
-
 /**
  * @param  {...string} paths
  * @returns {string}
@@ -1382,25 +1150,10 @@ function addPath(...paths) {
 }
 
 /**
- * @param {string} title
- * @param {function} fn
+ * @returns {string | undefined}
  */
-async function runTask(title, fn) {
-  if (isGitHubAction) {
-    console.log(`::group::${stripAnsi(title)}`);
-  } else if (isBuildKite) {
-    console.log(`--- ${title}`);
-  } else {
-    console.log(title);
-  }
-  try {
-    return await fn();
-  } finally {
-    if (isGitHubAction) {
-      console.log("::endgroup::");
-    }
-    console.log();
-  }
+function getTestLabel() {
+  return getBuildLabel()?.replace(" - test-bun", "");
 }
 
 /**
@@ -1410,7 +1163,7 @@ async function runTask(title, fn) {
  */
 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;
 
@@ -1455,7 +1208,7 @@ function formatTestToMarkdown(result, concise) {
       markdown += "</li>\n";
     } else {
       markdown += "</summary>\n\n";
-      if (isBuildKite) {
+      if (isBuildkite) {
         const preview = escapeCodeBlock(stdout);
         markdown += `\`\`\`terminal\n${preview}\n\`\`\`\n`;
       } else {
@@ -1513,14 +1266,21 @@ function listArtifactsFromBuildKite(glob, step) {
 }
 
 /**
- * @param {string} label
- * @param {string} content
- * @param {number | undefined} attempt
+ * @typedef {object} BuildkiteAnnotation
+ * @property {string} label
+ * @property {string} content
+ * @property {"error" | "warning" | "info"} [style]
+ * @property {number} [priority]
+ * @property {number} [attempt]
  */
-function reportAnnotationToBuildKite(label, content, attempt = 0) {
+
+/**
+ * @param {BuildkiteAnnotation} annotation
+ */
+function reportAnnotationToBuildKite({ label, content, style = "error", priority = 3, attempt = 0 }) {
   const { error, status, signal, stderr } = spawnSync(
     "buildkite-agent",
-    ["annotate", "--append", "--style", "error", "--context", `${label}`, "--priority", `${attempt}`],
+    ["annotate", "--append", "--style", `${style}`, "--context", `${label}`, "--priority", `${priority}`],
     {
       input: content,
       stdio: ["pipe", "ignore", "pipe"],
@@ -1536,14 +1296,14 @@ function reportAnnotationToBuildKite(label, content, attempt = 0) {
     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 message = `<details><summary><a><code>${label}</code></a> - annotation error on ${platform}</summary>`;
+  let errorMessage = `<details><summary><a><code>${label}</code></a> - annotation error on ${platform}</summary>`;
   if (stderr) {
-    message += `\n\n\`\`\`terminal\n${escapeCodeBlock(stderr)}\n\`\`\`\n\n</details>\n\n`;
+    errorMessage += `\n\n\`\`\`terminal\n${escapeCodeBlock(stderr)}\n\`\`\`\n\n</details>\n\n`;
   }
-  reportAnnotationToBuildKite(`${label}-error`, message, attempt + 1);
+  reportAnnotationToBuildKite({ label: `${label}-error`, content: errorMessage, attempt: attempt + 1 });
 }
 
 /**
@@ -1642,42 +1402,6 @@ function parseDuration(duration) {
   return parseFloat(value) * (unit === "ms" ? 1 : 1000);
 }
 
-/**
- * @param {string} status
- * @returns {string}
- */
-function getTestEmoji(status) {
-  switch (status) {
-    case "pass":
-      return "✅";
-    case "fail":
-      return "❌";
-    case "skip":
-      return "⏭";
-    case "todo":
-      return "✏️";
-    default:
-      return "🔮";
-  }
-}
-
-/**
- * @param {string} status
- * @returns {string}
- */
-function getTestColor(status) {
-  switch (status) {
-    case "pass":
-      return getAnsi("green");
-    case "fail":
-      return getAnsi("red");
-    case "skip":
-    case "todo":
-    default:
-      return getAnsi("gray");
-  }
-}
-
 /**
  * @param {string} execPath
  * @returns {boolean}
@@ -1701,7 +1425,7 @@ function getExitCode(outcome) {
   if (outcome === "pass") {
     return 0;
   }
-  if (!isBuildKite) {
+  if (!isBuildkite) {
     return 1;
   }
   // On Buildkite, you can define a `soft_fail` property to differentiate
@@ -1715,52 +1439,56 @@ function getExitCode(outcome) {
   return 1;
 }
 
-/**
- * @returns {Promise<Date | undefined>}
- */
-async function getDoomsdayDate() {
-  try {
-    const response = await fetch("http://169.254.169.254/latest/meta-data/spot/instance-action");
-    if (response.ok) {
-      const { time } = await response.json();
-      return new Date(time);
-    }
-  } catch {
-    // Ignore
-  }
-}
-
 /**
  * @param {string} signal
  */
-async function beforeExit(signal) {
-  const endOfWorld = await getDoomsdayDate();
-  if (endOfWorld) {
-    const timeMin = 10 * 1000;
-    const timeLeft = Math.max(0, date.getTime() - Date.now());
-    if (timeLeft > timeMin) {
-      setTimeout(() => onExit(signal), timeLeft - timeMin);
-      return;
-    }
-  }
-  onExit(signal);
-}
-
-/**
- * @param {string} signal
- */
-async function onExit(signal) {
+function onExit(signal) {
   const label = `${getAnsi("red")}Received ${signal}, exiting...${getAnsi("reset")}`;
-  await runTask(label, () => {
+  startGroup(label, () => {
     process.exit(getExitCode("cancel"));
   });
 }
 
-for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
-  process.on(signal, () => beforeExit(signal));
+export async function main() {
+  for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+    process.on(signal, () => onExit(signal));
+  }
+
+  printEnvironment();
+
+  // FIXME: Some DNS tests hang unless we set the DNS server to 8.8.8.8
+  // It also appears to hang on 1.1.1.1, which could explain this issue:
+  // https://github.com/oven-sh/bun/issues/11136
+  if (isWindows && isCI) {
+    await spawn("pwsh", [
+      "-Command",
+      "Set-DnsClientServerAddress -InterfaceAlias 'Ethernet 4' -ServerAddresses ('8.8.8.8','8.8.4.4')",
+    ]);
+  }
+
+  const results = await runTests();
+  const ok = results.every(({ ok }) => ok);
+
+  let waitForUser = false;
+  while (isCI) {
+    const userCount = getLoggedInUserCount();
+    if (!userCount) {
+      if (waitForUser) {
+        console.log("No users logged in, exiting runner...");
+      }
+      break;
+    }
+
+    if (!waitForUser) {
+      startGroup("Summary");
+      console.warn(`Found ${userCount} users logged in, keeping the runner alive until logout...`);
+      waitForUser = true;
+    }
+
+    await new Promise(resolve => setTimeout(resolve, 60_000));
+  }
+
+  process.exit(getExitCode(ok ? "pass" : "fail"));
 }
 
-await runTask("Environment", printInfo);
-const results = await runTests();
-const ok = results.every(({ ok }) => ok);
-process.exit(getExitCode(ok ? "pass" : "fail"));
+await main();
diff --git a/scripts/utils.mjs b/scripts/utils.mjs
new file mode 100755
index 0000000000..198712a34c
--- /dev/null
+++ b/scripts/utils.mjs
@@ -0,0 +1,2749 @@
+// Contains utility functions for various scripts, including:
+// CI, running tests, and code generation.
+
+import { spawn as nodeSpawn, spawnSync as nodeSpawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import {
+  appendFileSync,
+  chmodSync,
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  writeFileSync,
+} from "node:fs";
+import { connect } from "node:net";
+import { hostname, tmpdir as nodeTmpdir, homedir as nodeHomedir, userInfo, release } from "node:os";
+import { dirname, join, relative, resolve } from "node:path";
+import { normalize as normalizeWindows } from "node:path/win32";
+
+export const isWindows = process.platform === "win32";
+export const isMacOS = process.platform === "darwin";
+export const isLinux = process.platform === "linux";
+export const isPosix = isMacOS || isLinux;
+
+export const isArm64 = process.arch === "arm64";
+
+/**
+ * @param {string} name
+ * @param {boolean} [required]
+ * @returns {string}
+ */
+export function getEnv(name, required = true) {
+  const value = process.env[name];
+
+  if (required && !value) {
+    throw new Error(`Environment variable is missing: ${name}`);
+  }
+
+  return value;
+}
+
+export const isBuildkite = getEnv("BUILDKITE", false) === "true";
+export const isGithubAction = getEnv("GITHUB_ACTIONS", false) === "true";
+export const isCI = getEnv("CI", false) === "true" || isBuildkite || isGithubAction;
+export const isDebug = getEnv("DEBUG", false) === "1";
+
+/**
+ * @param {string} name
+ * @param {object} [options]
+ * @param {boolean} [options.required]
+ * @param {boolean} [options.redact]
+ * @returns {string}
+ */
+export function getSecret(name, options = { required: true, redact: true }) {
+  const value = getEnv(name, false);
+  if (value) {
+    return value;
+  }
+
+  if (isBuildkite) {
+    const command = ["buildkite-agent", "secret", "get", name];
+    if (options["redact"] === false) {
+      command.push("--skip-redaction");
+    }
+
+    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);
+
+      let hint;
+      if (orgId && clusterId) {
+        hint = `https://buildkite.com/organizations/${orgId}/clusters/${clusterId}/secrets`;
+      } else {
+        hint = "https://buildkite.com/docs/pipelines/buildkite-secrets";
+      }
+
+      throw new Error(`Secret not found: ${name} (hint: go to ${hint} and create a secret)`, { cause: error });
+    }
+
+    setEnv(name, secret);
+    return secret;
+  }
+
+  return getEnv(name, options["required"]);
+}
+
+/**
+ * @param  {...unknown} args
+ */
+export function debugLog(...args) {
+  if (isDebug) {
+    console.log(...args);
+  }
+}
+
+/**
+ * @param {string} name
+ * @param {string | undefined} value
+ */
+export function setEnv(name, value) {
+  process.env[name] = value;
+
+  if (isGithubAction && !/^GITHUB_/i.test(name)) {
+    const envFilePath = process.env["GITHUB_ENV"];
+    if (envFilePath) {
+      const delimeter = Math.random().toString(36).substring(2, 15);
+      const content = `${name}<<${delimeter}\n${value}\n${delimeter}\n`;
+      appendFileSync(outputPath, content);
+    }
+  }
+}
+
+/**
+ * @typedef {object} SpawnOptions
+ * @property {string} [cwd]
+ * @property {number} [timeout]
+ * @property {Record<string, string | undefined>} [env]
+ * @property {boolean | ((error: Error) => boolean)} [throwOnError]
+ * @property {(error: Error) => boolean} [retryOnError]
+ * @property {string} [stdin]
+ * @property {boolean} [privileged]
+ */
+
+/**
+ * @typedef {object} SpawnResult
+ * @property {number} exitCode
+ * @property {number} [signalCode]
+ * @property {string} stdout
+ * @property {string} stderr
+ * @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;
+}
+
+/**
+ * @param {string[]} command
+ * @param {SpawnOptions} options
+ */
+function parseCommand(command, options) {
+  if (options?.privileged) {
+    return [...getPrivilegedCommand(), ...command];
+  }
+  return command;
+}
+
+/** @type {string[] | undefined} */
+let priviledgedCommand;
+
+/**
+ * @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 = []);
+}
+
+/** @type {boolean | undefined} */
+let privileged;
+
+/**
+ * @returns {boolean}
+ */
+export function isPrivileged() {
+  if (typeof privileged !== "undefined") {
+    return privileged;
+  }
+
+  const command = getPrivilegedCommand();
+  if (command.length) {
+    const { error } = spawnSync(command);
+    privileged = !error;
+  } else {
+    privileged = false;
+  }
+
+  return privileged;
+}
+
+/**
+ * @param {string[]} command
+ * @param {SpawnOptions} options
+ * @returns {Promise<SpawnResult>}
+ */
+export async function spawn(command, options = {}) {
+  const [cmd, ...args] = parseCommand(command, options);
+  debugLog("$", cmd, ...args);
+
+  const stdin = options["stdin"];
+  const spawnOptions = {
+    cwd: options["cwd"] ?? process.cwd(),
+    timeout: options["timeout"] ?? undefined,
+    env: options["env"] ?? undefined,
+    stdio: [stdin ? "pipe" : "ignore", "pipe", "pipe"],
+    ...options,
+  };
+
+  let exitCode = 1;
+  let signalCode;
+  let stdout = "";
+  let stderr = "";
+  let error;
+
+  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;
+    });
+    subprocess.stderr?.on("data", chunk => {
+      stderr += chunk;
+    });
+
+    subprocess.on("error", error => reject(error));
+    subprocess.on("exit", (code, signal) => {
+      exitCode = code;
+      signalCode = signal;
+      resolve();
+    });
+  });
+
+  try {
+    await result;
+  } catch (cause) {
+    error = cause;
+  }
+
+  if (exitCode !== 0 && isWindows) {
+    const exitReason = getWindowsExitReason(exitCode);
+    if (exitReason) {
+      exitCode = exitReason;
+    }
+  }
+
+  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;
+
+    if (signalCode) {
+      error = new Error(`Command killed with ${signalCode}: ${description}`, { cause });
+    } else {
+      error = new Error(`Command exited with code ${exitCode}: ${description}`, { cause });
+    }
+  }
+
+  if (error) {
+    const retryOnError = options["retryOnError"];
+    if (typeof retryOnError === "function") {
+      if (retryOnError(error)) {
+        return spawn(command, options);
+      }
+    }
+
+    const throwOnError = options["throwOnError"];
+    if (typeof throwOnError === "function") {
+      if (throwOnError(error)) {
+        throw error;
+      }
+    } else if (throwOnError) {
+      throw error;
+    }
+  }
+
+  return {
+    exitCode,
+    signalCode,
+    stdout,
+    stderr,
+    error,
+  };
+}
+
+/**
+ * @param {string[]} command
+ * @param {SpawnOptions} options
+ * @returns {Promise<SpawnResult>}
+ */
+export async function spawnSafe(command, options = {}) {
+  return spawn(command, { throwOnError: true, ...options });
+}
+
+/**
+ * @param {string[]} command
+ * @param {SpawnOptions} options
+ * @returns {SpawnResult}
+ */
+export function spawnSync(command, options = {}) {
+  const [cmd, ...args] = parseCommand(command, options);
+  debugLog("$", cmd, ...args);
+
+  const stdin = options["stdin"];
+  const spawnOptions = {
+    cwd: options["cwd"] ?? process.cwd(),
+    timeout: options["timeout"] ?? undefined,
+    env: options["env"] ?? undefined,
+    stdio: [typeof stdin === "undefined" ? "ignore" : "pipe", "pipe", "pipe"],
+    input: stdin,
+    ...options,
+  };
+
+  let exitCode = 1;
+  let signalCode;
+  let stdout = "";
+  let stderr = "";
+  let error;
+
+  let result;
+  try {
+    result = nodeSpawnSync(cmd, args, spawnOptions);
+  } catch (error) {
+    result = { error };
+  }
+
+  const { error: spawnError, status, signal, stdout: stdoutBuffer, stderr: stderrBuffer } = result;
+  if (spawnError) {
+    error = spawnError;
+  } else {
+    exitCode = status ?? 1;
+    signalCode = signal || undefined;
+    stdout = stdoutBuffer?.toString();
+    stderr = stderrBuffer?.toString();
+  }
+
+  if (exitCode !== 0 && isWindows) {
+    const exitReason = getWindowsExitReason(exitCode);
+    if (exitReason) {
+      exitCode = exitReason;
+    }
+  }
+
+  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;
+
+    if (signalCode) {
+      error = new Error(`Command killed with ${signalCode}: ${description}`, { cause });
+    } else {
+      error = new Error(`Command exited with code ${exitCode}: ${description}`, { cause });
+    }
+  }
+
+  if (error) {
+    const retryOnError = options["retryOnError"];
+    if (typeof retryOnError === "function") {
+      if (retryOnError(error)) {
+        return spawn(command, options);
+      }
+    }
+
+    const throwOnError = options["throwOnError"];
+    if (typeof throwOnError === "function") {
+      if (throwOnError(error)) {
+        throw error;
+      }
+    } else if (throwOnError) {
+      throw error;
+    }
+  }
+
+  return {
+    exitCode,
+    signalCode,
+    stdout,
+    stderr,
+    error,
+  };
+}
+
+/**
+ * @param {string[]} command
+ * @param {SpawnOptions} options
+ * @returns {SpawnResult}
+ */
+export function spawnSyncSafe(command, options = {}) {
+  return spawnSync(command, { throwOnError: true, ...options });
+}
+
+/**
+ * @param {number} exitCode
+ * @returns {string | undefined}
+ */
+export function getWindowsExitReason(exitCode) {
+  const ntStatusPath = "C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.22621.0\\shared\\ntstatus.h";
+  const nthStatus = readFile(ntStatusPath, { cache: true });
+
+  const match = nthStatus.match(new RegExp(`(STATUS_\\w+).*0x${exitCode?.toString(16)}`, "i"));
+  if (match) {
+    const [, exitReason] = match;
+    return exitReason;
+  }
+}
+
+/**
+ * @param {string | URL} url
+ * @returns {URL | undefined}
+ */
+export function parseGitUrl(url) {
+  const string = typeof url === "string" ? url : url.toString();
+
+  const githubUrl = getEnv("GITHUB_SERVER_URL", false) || "https://github.com";
+  if (/^git@github\.com:/.test(string)) {
+    return new URL(string.slice(15).replace(/\.git$/, ""), githubUrl);
+  }
+  if (/^https:\/\/github\.com\//.test(string)) {
+    return new URL(string.slice(19).replace(/\.git$/, ""), githubUrl);
+  }
+}
+
+/**
+ * @param {string | URL} url
+ * @returns {string | undefined}
+ */
+export function parseGitRepository(url) {
+  const parsed = parseGitUrl(url);
+  if (parsed) {
+    const { hostname, pathname } = parsed;
+    if (hostname == "github.com") {
+      return pathname.slice(1);
+    }
+  }
+}
+
+/**
+ * @param {string} [cwd]
+ * @returns {URL | undefined}
+ */
+export function getRepositoryUrl(cwd) {
+  if (!cwd) {
+    if (isBuildkite) {
+      const repository = getEnv("BUILDKITE_REPO", false);
+      if (repository) {
+        return parseGitUrl(repository);
+      }
+    }
+
+    if (isGithubAction) {
+      const serverUrl = getEnv("GITHUB_SERVER_URL", false) || "https://github.com";
+      const repository = getEnv("GITHUB_REPOSITORY", false);
+      if (serverUrl && repository) {
+        return parseGitUrl(new URL(repository, serverUrl));
+      }
+    }
+  }
+
+  const { error, stdout } = spawnSync(["git", "remote", "get-url", "origin"], { cwd });
+  if (!error) {
+    return parseGitUrl(stdout.trim());
+  }
+}
+
+/**
+ * @param {string} [cwd]
+ * @returns {string | undefined}
+ */
+export function getRepository(cwd) {
+  if (!cwd) {
+    if (isGithubAction) {
+      const repository = getEnv("GITHUB_REPOSITORY", false);
+      if (repository) {
+        return repository;
+      }
+    }
+  }
+
+  const url = getRepositoryUrl(cwd);
+  if (url) {
+    return parseGitRepository(url);
+  }
+}
+
+/**
+ * @returns {string | undefined}
+ */
+export function getPullRequestRepository() {
+  if (isBuildkite) {
+    const repository = getEnv("BUILDKITE_PULL_REQUEST_REPO", false);
+    if (repository) {
+      return parseGitRepository(repository);
+    }
+  }
+}
+
+/**
+ * @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}
+ */
+export function getCommit(cwd) {
+  if (!cwd) {
+    if (isBuildkite) {
+      const commit = getEnv("BUILDKITE_COMMIT", false);
+      if (commit) {
+        return commit;
+      }
+    }
+
+    if (isGithubAction) {
+      const commit = getEnv("GITHUB_SHA", false);
+      if (commit) {
+        return commit;
+      }
+    }
+  }
+
+  const { error, stdout } = spawnSync(["git", "rev-parse", "HEAD"], { cwd });
+  if (!error) {
+    return stdout.trim();
+  }
+}
+
+/**
+ * @param {string} [cwd]
+ * @returns {string | undefined}
+ */
+export function getCommitMessage(cwd) {
+  if (!cwd) {
+    if (isBuildkite) {
+      const message = getEnv("BUILDKITE_MESSAGE", false);
+      if (message) {
+        return message;
+      }
+    }
+  }
+
+  const { error, stdout } = spawnSync(["git", "log", "-1", "--pretty=%B"], { cwd });
+  if (!error) {
+    return stdout.trim();
+  }
+}
+
+/**
+ * @param {string} [cwd]
+ * @returns {string | undefined}
+ */
+export function getBranch(cwd) {
+  if (!cwd) {
+    if (isBuildkite) {
+      const branch = getEnv("BUILDKITE_BRANCH", false);
+      if (branch) {
+        return branch;
+      }
+    }
+
+    if (isGithubAction) {
+      const ref = getEnv("GITHUB_REF_NAME", false);
+      if (ref) {
+        return ref;
+      }
+    }
+  }
+
+  const { error, stdout } = spawnSync(["git", "rev-parse", "--abbrev-ref", "HEAD"], { cwd });
+  if (!error) {
+    return stdout.trim();
+  }
+}
+
+/**
+ * @param {string} [cwd]
+ * @returns {string | undefined}
+ */
+export function getMainBranch(cwd) {
+  if (!cwd) {
+    if (isBuildkite) {
+      const branch = getEnv("BUILDKITE_PIPELINE_DEFAULT_BRANCH", false);
+      if (branch) {
+        return branch;
+      }
+    }
+
+    if (isGithubAction) {
+      const headRef = getEnv("GITHUB_HEAD_REF", false);
+      if (headRef) {
+        return headRef;
+      }
+    }
+  }
+
+  const { error, stdout } = spawnSync(["git", "symbolic-ref", "refs/remotes/origin/HEAD"], { cwd });
+  if (!error) {
+    return stdout.trim().replace("refs/remotes/origin/", "");
+  }
+}
+
+/**
+ * @param {string} [cwd]
+ * @returns {boolean}
+ */
+export function isMainBranch(cwd) {
+  return !isFork(cwd) && getBranch(cwd) === getMainBranch(cwd);
+}
+
+/**
+ * @returns {boolean}
+ */
+export function isPullRequest() {
+  if (isBuildkite) {
+    return !isNaN(parseInt(getEnv("BUILDKITE_PULL_REQUEST", false)));
+  }
+
+  if (isGithubAction) {
+    return /pull_request|merge_group/.test(getEnv("GITHUB_EVENT_NAME", false));
+  }
+
+  return false;
+}
+
+/**
+ * @returns {number | undefined}
+ */
+export function getPullRequest() {
+  if (isBuildkite) {
+    const pullRequest = getEnv("BUILDKITE_PULL_REQUEST", false);
+    if (pullRequest) {
+      return parseInt(pullRequest);
+    }
+  }
+
+  if (isGithubAction) {
+    const eventPath = getEnv("GITHUB_EVENT_PATH", false);
+    if (eventPath && existsSync(eventPath)) {
+      const event = JSON.parse(readFile(eventPath, { cache: true }));
+      const pullRequest = event["pull_request"];
+      if (pullRequest) {
+        return parseInt(pullRequest["number"]);
+      }
+    }
+  }
+}
+
+/**
+ * @returns {string | undefined}
+ */
+export function getTargetBranch() {
+  if (isPullRequest()) {
+    if (isBuildkite) {
+      return getEnv("BUILDKITE_PULL_REQUEST_BASE_BRANCH", false);
+    }
+
+    if (isGithubAction) {
+      return getEnv("GITHUB_BASE_REF", false);
+    }
+  }
+}
+
+/**
+ * @returns {boolean}
+ */
+export function isFork() {
+  if (isBuildkite) {
+    const repository = getEnv("BUILDKITE_PULL_REQUEST_REPO", false);
+    return !!repository && repository !== getEnv("BUILDKITE_REPO", false);
+  }
+
+  if (isGithubAction) {
+    const eventPath = getEnv("GITHUB_EVENT_PATH", false);
+    if (eventPath && existsSync(eventPath)) {
+      const event = JSON.parse(readFile(eventPath, { cache: true }));
+      const pullRequest = event["pull_request"];
+      if (pullRequest) {
+        return !!pullRequest["head"]["repo"]["fork"];
+      }
+    }
+  }
+
+  return false;
+}
+
+/**
+ * @param {string} [cwd]
+ * @returns {boolean}
+ */
+export function isMergeQueue(cwd) {
+  return /^gh-readonly-queue/.test(getBranch(cwd));
+}
+
+/**
+ * @returns {string | undefined}
+ */
+export function getGithubToken() {
+  const cachedToken = getSecret("GITHUB_TOKEN", { required: false });
+
+  if (typeof cachedToken === "string" || !which("gh")) {
+    return cachedToken || undefined;
+  }
+
+  const { error, stdout } = spawnSync(["gh", "auth", "token"]);
+  const token = error ? "" : stdout.trim();
+
+  setEnv("GITHUB_TOKEN", token);
+  return token || undefined;
+}
+
+/**
+ * @typedef {object} CurlOptions
+ * @property {string} [method]
+ * @property {string} [body]
+ * @property {Record<string, string | undefined>} [headers]
+ * @property {number} [timeout]
+ * @property {boolean} [cache]
+ * @property {number} [retries]
+ * @property {boolean} [json]
+ * @property {boolean} [arrayBuffer]
+ * @property {string} [filename]
+ */
+
+/**
+ * @typedef {object} CurlResult
+ * @property {number} status
+ * @property {string} statusText
+ * @property {Error | undefined} error
+ * @property {any} body
+ */
+
+/** @type {Record<string, CurlResult | undefined>} */
+let cachedResults;
+
+/**
+ * @param {string} url
+ * @param {CurlOptions} [options]
+ * @returns {Promise<CurlResult>}
+ */
+export async function curl(url, options = {}) {
+  let { hostname, href } = new URL(url);
+  let method = options["method"] || "GET";
+  let input = options["body"];
+  let headers = options["headers"] || {};
+  let retries = options["retries"] || 3;
+  let json = options["json"];
+  let arrayBuffer = options["arrayBuffer"];
+  let filename = options["filename"];
+
+  let cacheKey;
+  let cache = options["cache"];
+  if (cache) {
+    cacheKey = `${method} ${href}`;
+    if (cachedResults?.[cacheKey]) {
+      return cachedResults[cacheKey];
+    }
+  }
+
+  if (typeof headers["Authorization"] === "undefined") {
+    if (hostname === "api.github.com" || hostname === "uploads.github.com") {
+      const githubToken = getGithubToken();
+      if (githubToken) {
+        headers["Authorization"] = `Bearer ${githubToken}`;
+      }
+    }
+  }
+
+  let status;
+  let statusText;
+  let body;
+  let error;
+  for (let i = 0; i < retries; i++) {
+    if (i > 0) {
+      await new Promise(resolve => setTimeout(resolve, 1000 * (i + 1)));
+    }
+
+    let response;
+    try {
+      response = await fetch(href, { method, headers, body: input });
+    } catch (cause) {
+      debugLog("$", "curl", href, "-> error");
+      error = new Error(`Fetch failed: ${method} ${url}`, { cause });
+      continue;
+    }
+
+    status = response["status"];
+    statusText = response["statusText"];
+    debugLog("$", "curl", href, "->", status, statusText);
+
+    const ok = response["ok"];
+    try {
+      if (filename && ok) {
+        const buffer = await response.arrayBuffer();
+        writeFile(filename, new Uint8Array(buffer));
+      } else if (arrayBuffer && ok) {
+        body = await response.arrayBuffer();
+      } else if (json && ok) {
+        body = await response.json();
+      } else {
+        body = await response.text();
+      }
+    } catch (cause) {
+      error = new Error(`Fetch failed: ${method} ${url}`, { cause });
+      continue;
+    }
+
+    if (response["ok"]) {
+      break;
+    }
+
+    error = new Error(`Fetch failed: ${method} ${url}: ${status} ${statusText}`, { cause: body });
+
+    if (status === 400 || status === 404 || status === 422) {
+      break;
+    }
+  }
+
+  if (cacheKey) {
+    cachedResults ||= {};
+    cachedResults[cacheKey] = { status, statusText, error, body };
+  }
+
+  return {
+    status,
+    statusText,
+    error,
+    body,
+  };
+}
+
+/**
+ * @param {string} url
+ * @param {CurlOptions} options
+ * @returns {Promise<any>}
+ */
+export async function curlSafe(url, options) {
+  const result = await curl(url, options);
+
+  const { error, body } = result;
+  if (error) {
+    throw error;
+  }
+
+  return body;
+}
+
+/** @type {Record<string, string> | undefined} */
+let cachedFiles;
+
+/**
+ * @param {string} filename
+ * @param {object} [options]
+ * @param {boolean} [options.cache]
+ * @returns {string}
+ */
+export function readFile(filename, options = {}) {
+  const absolutePath = resolve(filename);
+  if (options["cache"]) {
+    if (cachedFiles?.[absolutePath]) {
+      return cachedFiles[absolutePath];
+    }
+  }
+
+  debugLog("$", "cat", absolutePath);
+
+  let content;
+  try {
+    content = readFileSync(absolutePath, "utf-8");
+  } catch (cause) {
+    throw new Error(`Read failed: ${absolutePath}`, { cause });
+  }
+
+  if (options["cache"]) {
+    cachedFiles ||= {};
+    cachedFiles[absolutePath] = content;
+  }
+
+  return content;
+}
+
+/**
+ * @param {string} path
+ * @param {number} mode
+ */
+export function chmod(path, mode) {
+  debugLog("$", "chmod", path, mode);
+  chmodSync(path, mode);
+}
+
+/**
+ * @param {string} filename
+ * @param {string | Buffer} content
+ * @param {object} [options]
+ * @param {number} [options.mode]
+ */
+export function writeFile(filename, content, options) {
+  mkdir(dirname(filename));
+
+  debugLog("$", "touch", filename);
+  writeFileSync(filename, content);
+
+  if (options?.mode) {
+    chmod(filename, options.mode);
+  }
+}
+
+/**
+ * @param {string} source
+ * @param {string} destination
+ * @param {object} [options]
+ * @param {number} [options.mode]
+ */
+export function copyFile(source, destination, options) {
+  mkdir(dirname(destination));
+
+  debugLog("$", "cp", source, destination);
+  copyFileSync(source, destination);
+
+  if (options?.mode) {
+    chmod(destination, options.mode);
+  }
+}
+
+/**
+ * @param {string} path
+ * @param {object} [options]
+ * @param {number} [options.mode]
+ */
+export function mkdir(path, options = {}) {
+  if (existsSync(path)) {
+    return;
+  }
+
+  debugLog("$", "mkdir", path);
+  mkdirSync(path, { ...options, recursive: true });
+}
+
+/**
+ * @param {string} path
+ */
+export function rm(path) {
+  let stats;
+  try {
+    stats = statSync(path);
+  } catch {
+    return;
+  }
+
+  if (stats?.isDirectory()) {
+    debugLog("$", "rm", "-rf", path);
+    rmSync(path, { recursive: true, force: true });
+  } else {
+    debugLog("$", "rm", "-f", path);
+    rmSync(path, { force: true });
+  }
+}
+
+/**
+ * @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}`);
+  }
+}
+
+/**
+ * @typedef {object} GitRef
+ * @property {string} [repository]
+ * @property {string} [commit]
+ */
+
+/**
+ * @param {string} [cwd]
+ * @param {string | GitRef} [base]
+ * @param {string | GitRef} [head]
+ * @returns {Promise<string[] | undefined>}
+ */
+export async function getChangedFiles(cwd, base, head) {
+  const repository = getRepository(cwd);
+  head ||= getCommit(cwd);
+  base ||= `${head}^1`;
+
+  const url = new URL(`repos/${repository}/compare/${base}...${head}`, getGithubApiUrl());
+  const { error, body } = await curl(url, { json: true });
+
+  if (error) {
+    console.warn("Failed to list changed files:", error);
+    return;
+  }
+
+  const { files } = body;
+  return files.filter(({ status }) => !/removed|unchanged/i.test(status)).map(({ filename }) => filename);
+}
+
+/**
+ * @param {string} filename
+ * @returns {boolean}
+ */
+export function isDocumentation(filename) {
+  if (/^(docs|bench|examples|misctools|\.vscode)/.test(filename)) {
+    return true;
+  }
+
+  if (!/^(src|test|vendor)/.test(filename) && /\.(md|txt)$/.test(filename)) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * @returns {string | undefined}
+ */
+export function getBuildId() {
+  if (isBuildkite) {
+    return getEnv("BUILDKITE_BUILD_ID");
+  }
+
+  if (isGithubAction) {
+    return getEnv("GITHUB_RUN_ID");
+  }
+}
+
+/**
+ * @returns {number | undefined}
+ */
+export function getBuildNumber() {
+  if (isBuildkite) {
+    return parseInt(getEnv("BUILDKITE_BUILD_NUMBER"));
+  }
+
+  if (isGithubAction) {
+    return parseInt(getEnv("GITHUB_RUN_ID"));
+  }
+}
+
+/**
+ * @returns {URL | undefined}
+ */
+export function getBuildUrl() {
+  if (isBuildkite) {
+    const buildUrl = getEnv("BUILDKITE_BUILD_URL");
+    const jobId = getEnv("BUILDKITE_JOB_ID");
+    return new URL(`#${jobId}`, buildUrl);
+  }
+
+  if (isGithubAction) {
+    const baseUrl = getEnv("GITHUB_SERVER_URL", false) || "https://github.com";
+    const repository = getEnv("GITHUB_REPOSITORY");
+    const runId = getEnv("GITHUB_RUN_ID");
+    return new URL(`${repository}/actions/runs/${runId}`, baseUrl);
+  }
+}
+
+/**
+ * @returns {string | undefined}
+ */
+export function getBuildLabel() {
+  if (isBuildkite) {
+    const label = getEnv("BUILDKITE_LABEL", false) || getEnv("BUILDKITE_GROUP_LABEL", false);
+    if (label) {
+      return label;
+    }
+  }
+
+  if (isGithubAction) {
+    const label = getEnv("GITHUB_WORKFLOW", false);
+    if (label) {
+      return label;
+    }
+  }
+}
+
+/**
+ * @returns {boolean | undefined}
+ */
+export function isBuildManual() {
+  if (isBuildkite) {
+    const buildSource = getEnv("BUILDKITE_SOURCE", false);
+    if (buildSource) {
+      const buildId = getEnv("BUILDKITE_REBUILT_FROM_BUILD_ID", false);
+      return buildSource === "ui" && !buildId;
+    }
+  }
+}
+
+/**
+ * @param {string} [os]
+ * @returns {number}
+ */
+export function getBootstrapVersion(os) {
+  const scriptPath = join(
+    import.meta.dirname,
+    os === "windows" || (!os && isWindows) ? "bootstrap.ps1" : "bootstrap.sh",
+  );
+  const scriptContent = readFile(scriptPath, { cache: true });
+  const match = /# Version: (\d+)/.exec(scriptContent);
+  if (match) {
+    const [, version] = match;
+    return parseInt(version);
+  }
+  return 0;
+}
+
+/**
+ * @typedef {object} BuildArtifact
+ * @property {string} [job]
+ * @property {string} filename
+ * @property {string} url
+ */
+
+/**
+ * @returns {Promise<BuildArtifact[] | undefined>}
+ */
+export async function getBuildArtifacts() {
+  const buildId = await getBuildkiteBuildNumber();
+  if (buildId) {
+    return getBuildkiteArtifacts(buildId);
+  }
+}
+
+/**
+ * @returns {Promise<number | undefined>}
+ */
+export async function getBuildkiteBuildNumber() {
+  if (isBuildkite) {
+    const number = parseInt(getEnv("BUILDKITE_BUILD_NUMBER", false));
+    if (!isNaN(number)) {
+      return number;
+    }
+  }
+
+  const repository = getRepository();
+  const commit = getCommit();
+  if (!repository || !commit) {
+    return;
+  }
+
+  const url = new URL(`repos/${repository}/commits/${commit}/statuses`, getGithubApiUrl());
+  const { status, error, body } = await curl(url, { json: true });
+  if (status === 404) {
+    return;
+  }
+  if (error) {
+    throw error;
+  }
+
+  for (const { target_url: url } of body) {
+    const { hostname, pathname } = new URL(url);
+    if (hostname === "buildkite.com") {
+      const buildId = parseInt(pathname.split("/").pop());
+      if (!isNaN(buildId)) {
+        return buildId;
+      }
+    }
+  }
+}
+
+/**
+ * @param {string} buildId
+ * @returns {Promise<BuildArtifact[]>}
+ */
+export async function getBuildkiteArtifacts(buildId) {
+  const orgId = getEnv("BUILDKITE_ORGANIZATION_SLUG", false) || "bun";
+  const pipelineId = getEnv("BUILDKITE_PIPELINE_SLUG", false) || "bun";
+  const { jobs } = await curlSafe(`https://buildkite.com/${orgId}/${pipelineId}/builds/${buildId}.json`, {
+    json: true,
+  });
+
+  const artifacts = await Promise.all(
+    jobs.map(async ({ id: jobId, step_key: jobKey }) => {
+      const artifacts = await curlSafe(
+        `https://buildkite.com/organizations/${orgId}/pipelines/${pipelineId}/builds/${buildId}/jobs/${jobId}/artifacts`,
+        { json: true },
+      );
+
+      return artifacts.map(({ path, url }) => {
+        return {
+          job: jobKey,
+          filename: path,
+          url: new URL(url, "https://buildkite.com/").toString(),
+        };
+      });
+    }),
+  );
+
+  return artifacts.flat();
+}
+
+/**
+ * @param {string} [filename]
+ * @param {number} [line]
+ * @returns {URL | undefined}
+ */
+export function getFileUrl(filename, line) {
+  let cwd;
+  if (filename?.startsWith("vendor")) {
+    const parentPath = resolve(dirname(filename));
+    const { error, stdout } = spawnSync(["git", "rev-parse", "--show-toplevel"], { cwd: parentPath });
+    if (error) {
+      return;
+    }
+    cwd = stdout.trim();
+  }
+
+  const baseUrl = getRepositoryUrl(cwd);
+  if (!filename) {
+    return baseUrl;
+  }
+
+  const filePath = (cwd ? relative(cwd, filename) : filename).replace(/\\/g, "/");
+  const commit = getCommit(cwd);
+  const url = new URL(`blob/${commit}/${filePath}`, `${baseUrl}/`).toString();
+  if (typeof line !== "undefined") {
+    return new URL(`#L${line}`, url);
+  }
+  return url;
+}
+
+/**
+ * @typedef {object} BuildkiteBuild
+ * @property {string} id
+ * @property {string} commit_id
+ * @property {string} branch_name
+ */
+
+/**
+ * @returns {Promise<BuildkiteBuild | undefined>}
+ */
+export async function getLastSuccessfulBuild() {
+  if (isBuildkite) {
+    let depth = 0;
+    let url = getBuildUrl();
+    if (url) {
+      url.hash = "";
+    }
+
+    while (url) {
+      const { error, body } = await curl(`${url}.json`, { json: true, cache: true });
+      if (error) {
+        return;
+      }
+
+      const { state, prev_branch_build: previousBuild, steps } = body;
+      if (depth++) {
+        if (state === "failed" || state === "passed" || state === "canceled") {
+          const buildSteps = steps.filter(({ label }) => label.endsWith("build-bun"));
+          if (buildSteps.length) {
+            if (buildSteps.every(({ outcome }) => outcome === "passed")) {
+              return body;
+            }
+            return;
+          }
+        }
+      }
+
+      if (!previousBuild) {
+        return;
+      }
+
+      url = new URL(previousBuild["url"], url);
+    }
+  }
+}
+
+/**
+ * @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}
+ */
+export function stripAnsi(string) {
+  return string.replace(/\u001b\[[0-9;]*[a-zA-Z]/g, "");
+}
+
+/**
+ * @param {string} string
+ * @returns {string}
+ */
+export function escapeYaml(string) {
+  if (/[:"{}[\],&*#?|\-<>=!%@`]/.test(string)) {
+    return `"${string.replace(/"/g, '\\"')}"`;
+  }
+  return string;
+}
+
+/**
+ * @param {string} string
+ * @returns {string}
+ */
+export function escapeGitHubAction(string) {
+  return string.replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A");
+}
+
+/**
+ * @param {string} string
+ * @returns {string}
+ */
+export function unescapeGitHubAction(string) {
+  return string.replace(/%25/g, "%").replace(/%0D/g, "\r").replace(/%0A/g, "\n");
+}
+
+/**
+ * @param {string} string
+ * @returns {string}
+ */
+export function escapeHtml(string) {
+  return string
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#039;")
+    .replace(/`/g, "&#96;");
+}
+
+/**
+ * @param {string} string
+ * @returns {string}
+ */
+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}
+ */
+export function homedir() {
+  return nodeHomedir();
+}
+
+/**
+ * @returns {string}
+ */
+export function tmpdir() {
+  if (isWindows) {
+    for (const key of ["TMPDIR", "TEMP", "TEMPDIR", "TMP", "RUNNER_TEMP"]) {
+      const tmpdir = getEnv(key, false);
+      if (!tmpdir || /cygwin|cygdrive/i.test(tmpdir) || !/^[a-z]/i.test(tmpdir)) {
+        continue;
+      }
+      return normalizeWindows(tmpdir);
+    }
+
+    const appData = process.env["LOCALAPPDATA"];
+    if (appData) {
+      const appDataTemp = join(appData, "Temp");
+      if (existsSync(appDataTemp)) {
+        return appDataTemp;
+      }
+    }
+  }
+
+  if (isMacOS || isLinux) {
+    if (existsSync("/tmp")) {
+      return "/tmp";
+    }
+  }
+
+  return nodeTmpdir();
+}
+
+/**
+ * @param {string} [prefix]
+ * @param {string} [filename]
+ * @returns {string}
+ */
+export function mkdtemp(prefix, filename) {
+  const tmpPath = mkdtempSync(join(tmpdir(), prefix || "bun-"));
+  return filename ? join(tmpPath, filename) : tmpPath;
+}
+
+/**
+ * @param {string} filename
+ * @param {string} [output]
+ * @returns {Promise<string>}
+ */
+export async function unzip(filename, output) {
+  const destination = output || mkdtempSync(join(tmpdir(), "unzip-"));
+  if (isWindows) {
+    const command = `Expand-Archive -Force -LiteralPath "${escapePowershell(filename)}" -DestinationPath "${escapePowershell(destination)}"`;
+    await spawnSafe(["powershell", "-Command", command]);
+  } else {
+    await spawnSafe(["unzip", "-o", filename, "-d", destination]);
+  }
+  return destination;
+}
+
+/**
+ * @param {string} value
+ * @returns {boolean | undefined}
+ */
+export function parseBoolean(value) {
+  if (/^(true|yes|1|on)$/i.test(value)) {
+    return true;
+  }
+  if (/^(false|no|0|off)$/i.test(value)) {
+    return false;
+  }
+}
+
+/**
+ * @param {string} value
+ * @returns {number | undefined}
+ */
+export function parseNumber(value) {
+  const number = Number(value);
+  if (!isNaN(number)) {
+    return number;
+  }
+}
+
+/**
+ * @param {string} string
+ * @returns {"darwin" | "linux" | "windows"}
+ */
+export function parseOs(string) {
+  if (/darwin|apple|mac/i.test(string)) {
+    return "darwin";
+  }
+  if (/linux/i.test(string)) {
+    return "linux";
+  }
+  if (/win/i.test(string)) {
+    return "windows";
+  }
+  throw new Error(`Unsupported operating system: ${string}`);
+}
+
+/**
+ * @returns {"darwin" | "linux" | "windows"}
+ */
+export function getOs() {
+  return parseOs(process.platform);
+}
+
+/**
+ * @param {string} string
+ * @returns {"x64" | "aarch64"}
+ */
+export function parseArch(string) {
+  if (/x64|amd64|x86_64/i.test(string)) {
+    return "x64";
+  }
+  if (/arm64|aarch64/i.test(string)) {
+    return "aarch64";
+  }
+  throw new Error(`Unsupported architecture: ${string}`);
+}
+
+/**
+ * @returns {"x64" | "aarch64"}
+ */
+export function getArch() {
+  return parseArch(process.arch);
+}
+
+/**
+ * @returns {string | undefined}
+ */
+export function getKernel() {
+  if (isWindows) {
+    return;
+  }
+
+  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) {
+    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";
+    }
+    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
+ * @property {"x64" | "aarch64"} arch
+ * @property {"musl"} [abi]
+ * @property {boolean} [baseline]
+ * @property {boolean} profile
+ * @property {string} label
+ */
+
+/**
+ * @param {string} string
+ * @returns {Target}
+ */
+export function parseTarget(string) {
+  const os = parseOs(string);
+  const arch = parseArch(string);
+  const abi = os === "linux" && string.includes("-musl") ? "musl" : undefined;
+  const baseline = arch === "x64" ? string.includes("-baseline") : undefined;
+  const profile = string.includes("-profile");
+
+  let label = `${os}-${arch}`;
+  if (abi) {
+    label += `-${abi}`;
+  }
+  if (baseline) {
+    label += "-baseline";
+  }
+  if (profile) {
+    label += "-profile";
+  }
+
+  return { label, os, arch, abi, baseline, profile };
+}
+
+/**
+ * @param {string} target
+ * @param {string} [release]
+ * @returns {Promise<URL>}
+ */
+export async function getTargetDownloadUrl(target, release) {
+  const { label, os, arch, abi, baseline } = parseTarget(target);
+  const baseUrl = "https://pub-5e11e972747a44bf9aaf9394f185a982.r2.dev/releases/";
+  const filename = `bun-${label}.zip`;
+
+  const exists = async url => {
+    const { status } = await curl(url, { method: "HEAD" });
+    return status !== 404;
+  };
+
+  if (!release || /^(stable|latest|canary)$/i.test(release)) {
+    const tag = release === "canary" ? "canary" : "latest";
+    const url = new URL(`${tag}/${filename}`, baseUrl);
+    if (await exists(url)) {
+      return url;
+    }
+  }
+
+  if (/^(bun-v|v)?(\d+\.\d+\.\d+)$/i.test(release)) {
+    const [, major, minor, patch] = /(\d+)\.(\d+)\.(\d+)/i.exec(release);
+    const url = new URL(`bun-v${major}.${minor}.${patch}/${filename}`, baseUrl);
+    if (await exists(url)) {
+      return url;
+    }
+  }
+
+  if (/^https?:\/\//i.test(release) && (await exists(release))) {
+    return new URL(release);
+  }
+
+  if (release.length === 40 && /^[0-9a-f]{40}$/i.test(release)) {
+    const releaseUrl = new URL(`${release}/${filename}`, baseUrl);
+    if (await exists(releaseUrl)) {
+      return releaseUrl;
+    }
+
+    const canaryUrl = new URL(`${release}-canary/${filename}`, baseUrl);
+    if (await exists(canaryUrl)) {
+      return canaryUrl;
+    }
+
+    const statusUrl = new URL(`repos/oven-sh/bun/commits/${release}/status`, getGithubApiUrl());
+    const { error, body } = await curl(statusUrl, { json: true });
+    if (error) {
+      throw new Error(`Failed to fetch commit status: ${release}`, { cause: error });
+    }
+
+    const { statuses } = body;
+    const buildUrls = new Set();
+    for (const { target_url: url } of statuses) {
+      const { hostname, origin, pathname } = new URL(url);
+      if (hostname === "buildkite.com") {
+        buildUrls.add(`${origin}${pathname}.json`);
+      }
+    }
+
+    const buildkiteUrl = new URL("https://buildkite.com/");
+    for (const url of buildUrls) {
+      const { status, error, body } = await curl(url, { json: true });
+      if (status === 404) {
+        continue;
+      }
+      if (error) {
+        throw new Error(`Failed to fetch build: ${url}`, { cause: error });
+      }
+
+      const { jobs } = body;
+      const job = jobs.find(
+        ({ step_key: key }) =>
+          key &&
+          key.includes("build-bun") &&
+          key.includes(os) &&
+          key.includes(arch) &&
+          (!baseline || key.includes("baseline")) &&
+          (!abi || key.includes(abi)),
+      );
+      if (!job) {
+        continue;
+      }
+
+      const { base_path: jobPath } = job;
+      const artifactsUrl = new URL(`${jobPath}/artifacts`, buildkiteUrl);
+      {
+        const { error, body } = await curl(artifactsUrl, { json: true });
+        if (error) {
+          continue;
+        }
+
+        for (const { url, file_name: name } of body) {
+          if (name === filename) {
+            return new URL(url, artifactsUrl);
+          }
+        }
+      }
+    }
+  }
+
+  throw new Error(`Failed to find release: ${release}`);
+}
+
+/**
+ * @param {string} target
+ * @param {string} [release]
+ * @returns {Promise<string>}
+ */
+export async function downloadTarget(target, release) {
+  const url = await getTargetDownloadUrl(target, release);
+  const { error, body } = await curl(url, { arrayBuffer: true });
+  if (error) {
+    throw new Error(`Failed to download target: ${target} at ${release}`, { cause: error });
+  }
+
+  const tmpPath = mkdtempSync(join(tmpdir(), "bun-download-"));
+  const zipPath = join(tmpPath, "bun.zip");
+
+  writeFileSync(zipPath, new Uint8Array(body));
+  const unzipPath = await unzip(zipPath, tmpPath);
+
+  for (const entry of readdirSync(unzipPath, { recursive: true, encoding: "utf-8" })) {
+    const exePath = join(unzipPath, entry);
+    if (/bun(?:\.exe)?$/i.test(entry)) {
+      return exePath;
+    }
+  }
+
+  throw new Error(`Failed to find bun executable: ${unzipPath}`);
+}
+
+/**
+ * @returns {string}
+ */
+export function getTailscale() {
+  if (isMacOS) {
+    const tailscaleApp = "/Applications/Tailscale.app/Contents/MacOS/tailscale";
+    if (existsSync(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();
+  }
+}
+
+/**
+ * @returns {string | undefined}
+ */
+export function getPublicIp() {
+  for (const url of ["https://checkip.amazonaws.com", "https://ipinfo.io/ip"]) {
+    const { error, stdout } = spawnSync(["curl", url]);
+    if (!error) {
+      return stdout.trim();
+    }
+  }
+}
+
+/**
+ * @returns {string}
+ */
+export function getHostname() {
+  if (isBuildkite) {
+    const agent = getEnv("BUILDKITE_AGENT_NAME", false);
+    if (agent) {
+      return agent;
+    }
+  }
+
+  if (isGithubAction) {
+    const runner = getEnv("RUNNER_NAME", false);
+    if (runner) {
+      return runner;
+    }
+  }
+
+  return hostname();
+}
+
+/**
+ * @returns {string}
+ */
+export function getUsername() {
+  const { username } = userInfo();
+  return username;
+}
+
+/**
+ * @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) {
+    return "macOS";
+  }
+
+  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=(.*)/m);
+      if (match) {
+        const [, id] = match;
+        return id.includes('"') ? JSON.parse(id) : id;
+      }
+    }
+
+    const { error, stdout } = spawnSync(["lsb_release", "-is"]);
+    if (!error) {
+      return stdout.trim().toLowerCase();
+    }
+  }
+
+  if (isWindows) {
+    const { error, stdout } = spawnSync(["cmd", "/c", "ver"]);
+    if (!error) {
+      return stdout.trim();
+    }
+  }
+}
+
+/**
+ * @returns {string | undefined}
+ */
+export function getDistroVersion() {
+  if (isMacOS) {
+    const { error, stdout } = spawnSync(["sw_vers", "-productVersion"]);
+    if (!error) {
+      return stdout.trim();
+    }
+  }
+
+  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=(.*)/m);
+      if (match) {
+        const [, release] = match;
+        return release.includes('"') ? JSON.parse(release) : release;
+      }
+    }
+
+    const { error, stdout } = spawnSync(["lsb_release", "-rs"]);
+    if (!error) {
+      return stdout.trim();
+    }
+  }
+
+  if (isWindows) {
+    const { error, stdout } = spawnSync(["cmd", "/c", "ver"]);
+    if (!error) {
+      return stdout.trim();
+    }
+  }
+}
+
+/**
+ * @returns {string | undefined}
+ */
+export function getShell() {
+  if (isWindows) {
+    const pwsh = which(["pwsh", "powershell"]);
+    if (pwsh) {
+      return pwsh;
+    }
+  }
+
+  const sh = which(["bash", "sh"]);
+  if (sh) {
+    return sh;
+  }
+
+  return getEnv("SHELL", false);
+}
+
+/**
+ * @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");
+      }
+    }
+  }
+
+  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;
+          }
+        }
+      }
+    }
+  }
+
+  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: 10 });
+  if (error) {
+    console.warn("Failed to get cloud metadata:", 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}`,
+    "google": `labels/${tag.replace(":", "-")}`,
+  };
+
+  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;
+  console.log("Connecting...", `${hostname}:${port}`);
+
+  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();
+        console.log("Connected:", `${hostname}:${port}`);
+        resolve();
+      });
+      socket.on("error", error => {
+        socket.destroy();
+        reject(error);
+      });
+    });
+
+    try {
+      return await connected;
+    } catch (error) {
+      cause = error;
+    }
+  }
+
+  console.error("Connection failed:", `${hostname}:${port}`);
+  return cause;
+}
+/**
+ * @returns {Promise<number | undefined>}
+ */
+export async function getCanaryRevision() {
+  if (isPullRequest() || isFork()) {
+    return 1;
+  }
+
+  const repository = getRepository() || "oven-sh/bun";
+  const { error: releaseError, body: release } = await curl(
+    new URL(`repos/${repository}/releases/latest`, getGithubApiUrl()),
+    { json: true },
+  );
+  if (releaseError) {
+    return 1;
+  }
+
+  const commit = getCommit();
+  const { tag_name: latest } = release;
+  const { error: compareError, body: compare } = await curl(
+    new URL(`repos/${repository}/compare/${latest}...${commit}`, getGithubApiUrl()),
+    { json: true },
+  );
+  if (compareError) {
+    return 1;
+  }
+
+  const { ahead_by: revision } = compare;
+  if (typeof revision === "number") {
+    return revision;
+  }
+
+  return 1;
+}
+
+/**
+ * @returns {URL}
+ */
+export function getGithubApiUrl() {
+  return new URL(getEnv("GITHUB_API_URL", false) || "https://api.github.com");
+}
+
+/**
+ * @returns {URL}
+ */
+export function getGithubUrl() {
+  return new URL(getEnv("GITHUB_SERVER_URL", false) || "https://github.com");
+}
+
+/**
+ * @param {string} string
+ * @returns {string}
+ */
+export function sha256(string) {
+  return createHash("sha256").update(Buffer.from(string)).digest("hex");
+}
+
+/**
+ * @param {string} [level]
+ * @returns {"info" | "warning" | "error"}
+ */
+function parseLevel(level) {
+  if (/error|fatal|fail/i.test(level)) {
+    return "error";
+  }
+  if (/warn|caution/i.test(level)) {
+    return "warning";
+  }
+  return "notice";
+}
+
+/**
+ * @typedef {Object} Annotation
+ * @property {string} title
+ * @property {string} [content]
+ * @property {string} [source]
+ * @property {"notice" | "warning" | "error"} [level]
+ * @property {string} [url]
+ * @property {string} [filename]
+ * @property {number} [line]
+ * @property {number} [column]
+ * @property {Record<string, string>} [metadata]
+ */
+
+/**
+ * @typedef {Object} AnnotationContext
+ * @property {string} [cwd]
+ * @property {string[]} [command]
+ */
+
+/**
+ * @param {Record<keyof Annotation, unknown>} options
+ * @param {AnnotationContext} [context]
+ * @returns {Annotation}
+ */
+export function parseAnnotation(options, context) {
+  const source = options["source"];
+  const level = parseLevel(options["level"]);
+  const title = options["title"] || (source ? `${source} ${level}` : level);
+  const filename = options["filename"];
+  const line = parseInt(options["line"]) || undefined;
+  const column = parseInt(options["column"]) || undefined;
+  const content = options["content"];
+  const lines = Array.isArray(content) ? content : content?.split(/(\r?\n)/) || [];
+  const metadata = Object.fromEntries(
+    Object.entries(options["metadata"] || {}).filter(([, value]) => value !== undefined),
+  );
+
+  const relevantLines = [];
+  let lastLine;
+  for (const line of lines) {
+    if (!lastLine && !line.trim()) {
+      continue;
+    }
+    lastLine = line.trim();
+    relevantLines.push(line);
+  }
+
+  return {
+    source,
+    title,
+    level,
+    filename,
+    line,
+    column,
+    content: relevantLines.join("\n"),
+    metadata,
+  };
+}
+
+/**
+ * @typedef {Object} AnnotationResult
+ * @property {Annotation[]} annotations
+ * @property {string} content
+ * @property {string} preview
+ */
+
+/**
+ * @param {string} content
+ * @param {AnnotationOptions} [options]
+ * @returns {AnnotationResult}
+ */
+export function parseAnnotations(content, options = {}) {
+  /** @type {Annotation[]} */
+  const annotations = [];
+
+  const originalLines = content.split(/(\r?\n)/);
+  const lines = [];
+
+  for (let i = 0; i < originalLines.length; i++) {
+    const originalLine = originalLines[i];
+    const line = stripAnsi(originalLine).trim();
+    const bufferedLines = [originalLine];
+
+    /**
+     * @param {RegExp} pattern
+     * @param {number} [maxLength]
+     * @returns {{lines: string[], match: string[] | undefined}}
+     */
+    const readUntil = (pattern, maxLength = 100) => {
+      let length = 0;
+      let match;
+
+      while (i + length <= originalLines.length && length < maxLength) {
+        const originalLine = originalLines[i + length++];
+        const line = stripAnsi(originalLine).trim();
+        const patternMatch = pattern.exec(line);
+        if (patternMatch) {
+          match = patternMatch;
+          break;
+        }
+      }
+
+      const lines = originalLines.slice(i + 1, (i += length));
+      bufferedLines.push(...lines);
+      return { lines, match };
+    };
+
+    // Github Actions
+    // https://docs.github.com/en/actions/writing-workflows/choosing-what-your-workflow-does/workflow-commands-for-github-actions
+    const githubAnnotation = line.match(/^::(error|warning|notice|debug)(?: (.*))?::(.*)$/);
+    if (githubAnnotation) {
+      const [, level, attributes, content] = githubAnnotation;
+      const { file, line, col, title } = Object.fromEntries(
+        attributes?.split(",")?.map(entry => entry.split("=")) || {},
+      );
+
+      const annotation = parseAnnotation({
+        level,
+        filename: file,
+        line,
+        column: col,
+        content: unescapeGitHubAction(title) + unescapeGitHubAction(content),
+      });
+      annotations.push(annotation);
+      continue;
+    }
+
+    const githubCommand = line.match(/^::(group|endgroup|add-mask|stop-commands)::$/);
+    if (githubCommand) {
+      continue;
+    }
+
+    // CMake error format
+    // e.g. CMake Error at /path/to/thing.cmake:123 (message): ...
+    const cmakeMessage = line.match(/CMake (Error|Warning|Deprecation Warning) at (.*):(\d+)/i);
+    if (cmakeMessage) {
+      let [, level, filename, line] = cmakeMessage;
+
+      const { match: callStackMatch } = readUntil(/Call Stack \(most recent call first\)/i);
+      if (callStackMatch) {
+        const { match: callFrameMatch } = readUntil(/(CMakeLists\.txt|[^\s]+\.cmake):(\d+)/i, 5);
+        if (callFrameMatch) {
+          const [, frame, location] = callFrameMatch;
+          filename = frame;
+          line = location;
+        }
+      }
+
+      const annotation = parseAnnotation({
+        source: "cmake",
+        level,
+        filename,
+        line,
+        content: bufferedLines,
+      });
+      annotations.push(annotation);
+    }
+
+    // Zig compiler error
+    // e.g. /path/to/build.zig:8:19: error: ...
+    const zigMessage = line.match(/^(.+\.zig):(\d+):(\d+): (error|warning): (.+)$/);
+    if (zigMessage) {
+      const [, filename, line, column, level] = zigMessage;
+
+      const { match: callStackMatch } = readUntil(/referenced by:/i);
+      if (callStackMatch) {
+        readUntil(/(.+\.zig):(\d+):(\d+)/i, 5);
+      }
+
+      const annotation = parseAnnotation({
+        source: "zig",
+        level,
+        filename,
+        line,
+        column,
+        content: bufferedLines,
+      });
+      annotations.push(annotation);
+    }
+
+    const nodeJsError = line.match(/^file:\/\/(.+\.(?:c|m)js):(\d+)/i);
+    if (nodeJsError) {
+      const [, filename, line] = nodeJsError;
+
+      let metadata;
+      const { match: nodeJsVersionMatch } = readUntil(/^Node\.js v(\d+\.\d+\.\d+)/i);
+      if (nodeJsVersionMatch) {
+        const [, version] = nodeJsVersionMatch;
+        metadata = {
+          "node-version": version,
+        };
+      }
+
+      const annotation = parseAnnotation({
+        source: "node",
+        level: "error",
+        filename,
+        line,
+        content: bufferedLines,
+        metadata,
+      });
+      annotations.push(annotation);
+    }
+
+    const clangError = line.match(/^(.+\.(?:cpp|c|m|h)):(\d+):(\d+): (error|warning): (.+)/i);
+    if (clangError) {
+      const [, filename, line, column, level] = clangError;
+      readUntil(/^\d+ (?:error|warning)s? generated/);
+      const annotation = parseAnnotation({
+        source: "clang",
+        level,
+        filename,
+        line,
+        column,
+        content: bufferedLines,
+      });
+      annotations.push(annotation);
+    }
+
+    const shellMessage = line.match(/(.+\.sh): line (\d+): (.+)/i);
+    if (shellMessage) {
+      const [, filename, line] = shellMessage;
+      const annotation = parseAnnotation({
+        source: "shell",
+        level: "error",
+        filename,
+        line,
+        content: bufferedLines,
+      });
+      annotations.push(annotation);
+    }
+
+    lines.push(originalLine);
+  }
+
+  return {
+    annotations,
+    content: lines.join("\n"),
+  };
+}
+
+/**
+ * @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") ||
+        value.includes("*"))
+    ) {
+      result += `${spaces}${key}: "${value.replace(/"/g, '\\"')}"\n`;
+      continue;
+    }
+    result += `${spaces}${key}: ${value}\n`;
+  }
+  return result;
+}
+
+/** @type {string | undefined} */
+let lastGroup;
+
+/**
+ * @param {string} title
+ * @param {function} [fn]
+ */
+export function startGroup(title, fn) {
+  if (lastGroup && lastGroup !== title) {
+    lastGroup = title;
+    endGroup();
+  }
+
+  if (isGithubAction) {
+    console.log(`::group::${stripAnsi(title)}`);
+  } else if (isBuildkite) {
+    console.log(`--- ${title}`);
+  } else {
+    console.group(title);
+  }
+
+  if (typeof fn === "function") {
+    let result;
+    try {
+      result = fn();
+    } finally {
+      if (result instanceof Promise) {
+        return result.finally(() => endGroup());
+      } else {
+        endGroup();
+      }
+    }
+  }
+}
+
+export function endGroup() {
+  if (lastGroup) {
+    lastGroup = undefined;
+  }
+
+  if (isGithubAction) {
+    console.log("::endgroup::");
+  } else {
+    console.groupEnd();
+  }
+}
+
+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("Distro Version:", getDistroVersion());
+    console.log("Hostname:", getHostname());
+    if (isCI) {
+      console.log("Tailscale IP:", getTailscaleIp());
+      console.log("Public IP:", getPublicIp());
+    }
+    console.log("Username:", getUsername());
+    console.log("Working Directory:", process.cwd());
+    console.log("Temporary Directory:", tmpdir());
+    if (process.isBun) {
+      console.log("Bun Version:", Bun.version, Bun.revision);
+    } else {
+      console.log("Node Version:", process.version);
+    }
+  });
+
+  if (isCI) {
+    startGroup("Environment", () => {
+      for (const [key, value] of Object.entries(process.env)) {
+        console.log(`${key}:`, value);
+      }
+    });
+
+    if (isPosix) {
+      startGroup("Limits", () => {
+        const shell = which(["sh", "bash"]);
+        if (shell) {
+          spawnSync([shell, "-c", "ulimit -a"], { stdio: "inherit" });
+        }
+      });
+    }
+  }
+
+  startGroup("Repository", () => {
+    console.log("Commit:", getCommit());
+    console.log("Message:", getCommitMessage());
+    console.log("Branch:", getBranch());
+    console.log("Main Branch:", getMainBranch());
+    console.log("Is Fork:", isFork());
+    console.log("Is Merge Queue:", isMergeQueue());
+    console.log("Is Main Branch:", isMainBranch());
+    console.log("Is Pull Request:", isPullRequest());
+    if (isPullRequest()) {
+      console.log("Pull Request:", getPullRequest());
+      console.log("Target Branch:", getTargetBranch());
+    }
+  });
+
+  if (isCI) {
+    startGroup("CI", () => {
+      console.log("Build ID:", getBuildId());
+      console.log("Build Label:", getBuildLabel());
+      console.log("Build URL:", getBuildUrl()?.toString());
+    });
+  }
+}
+
+/**
+ * @returns {number | undefined}
+ */
+export function getLoggedInUserCount() {
+  if (isWindows) {
+    const pwsh = which(["pwsh", "powershell"]);
+    if (pwsh) {
+      const { error, stdout } = spawnSync([
+        pwsh,
+        "-Command",
+        `Get-CimInstance -ClassName Win32_Process -Filter "Name = 'sshd.exe'" | Get-CimAssociatedInstance -Association Win32_SessionProcess | Get-CimAssociatedInstance -Association Win32_LoggedOnUser | Where-Object {$_.Name -ne 'SYSTEM'} | Measure-Object | Select-Object -ExpandProperty Count`,
+      ]);
+      if (!error) {
+        return parseInt(stdout) || undefined;
+      }
+    }
+  }
+
+  const { error, stdout } = spawnSync(["who"]);
+  if (!error) {
+    return stdout.split("\n").filter(line => /tty|pts/i.test(line)).length;
+  }
+}
+
+/** @typedef {keyof typeof emojiMap} Emoji */
+
+const emojiMap = {
+  darwin: ["🍎", "darwin"],
+  linux: ["🐧", "linux"],
+  debian: ["🐧", "debian"],
+  ubuntu: ["🐧", "ubuntu"],
+  alpine: ["🐧", "alpine"],
+  aws: ["☁️", "aws"],
+  amazonlinux: ["🐧", "aws"],
+  windows: ["🪟", "windows"],
+  true: ["✅", "white_check_mark"],
+  false: ["❌", "x"],
+  debug: ["🐞", "bug"],
+  assert: ["🔍", "mag"],
+  release: ["🏆", "trophy"],
+  gear: ["⚙️", "gear"],
+  clipboard: ["📋", "clipboard"],
+  rocket: ["🚀", "rocket"],
+};
+
+/**
+ * @param {Emoji} emoji
+ * @returns {string}
+ */
+export function getEmoji(emoji) {
+  const [unicode] = emojiMap[emoji] || [];
+  return unicode || "";
+}
+
+/**
+ * @param {Emoji} emoji
+ * @returns {string}
+ * @link https://github.com/buildkite/emojis#emoji-reference
+ */
+export function getBuildkiteEmoji(emoji) {
+  const [, name] = emojiMap[emoji] || [];
+  return name ? `:${name}:` : "";
+}
diff --git a/src/bun.js/bindings/.clang-format b/src/.clang-format
similarity index 97%
rename from src/bun.js/bindings/.clang-format
rename to src/.clang-format
index d8fb9d0b97..d3d5f2ecb3 100644
--- a/src/bun.js/bindings/.clang-format
+++ b/src/.clang-format
@@ -11,7 +11,7 @@ AllowAllParametersOfDeclarationOnNextLine: true
 AllowShortBlocksOnASingleLine: false
 AllowShortCaseLabelsOnASingleLine: false
 AllowShortFunctionsOnASingleLine: All
-AllowShortIfStatementsOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: true
 AllowShortLoopsOnASingleLine: false
 AlwaysBreakAfterDefinitionReturnType: None
 AlwaysBreakAfterReturnType: None
@@ -73,6 +73,7 @@ IncludeIsMainRegex: "(Test)?$"
 IndentCaseLabels: false
 IndentWidth: 4
 IndentWrappedFunctionNames: false
+InsertNewlineAtEOF: true
 JavaScriptQuotes: Leave
 JavaScriptWrapImports: true
 KeepEmptyLinesAtTheStartOfBlocks: true
diff --git a/src/ArenaAllocator.zig b/src/ArenaAllocator.zig
deleted file mode 100644
index 4c62038cab..0000000000
--- 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 d3becfed78..2945062f43 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)),
     }
 }
@@ -126,7 +130,20 @@ pub fn raiseIgnoringPanicHandler(sig: bun.SignalCode) noreturn {
     Output.flush();
     Output.Source.Stdio.restore();
 
+    // clear segfault handler
     bun.crash_handler.resetSegfaultHandler();
+
+    // clear signal handler
+    if (bun.Environment.os != .windows) {
+        var sa: std.c.Sigaction = .{
+            .handler = .{ .handler = std.posix.SIG.DFL },
+            .mask = std.posix.empty_sigset,
+            .flags = std.posix.SA.RESETHAND,
+        };
+        _ = std.c.sigaction(@intFromEnum(sig), &sa, null);
+    }
+
+    // kill self
     _ = std.c.raise(@intFromEnum(sig));
     std.c.abort();
 }
@@ -172,23 +189,16 @@ const string = bun.string;
 pub const BunInfo = struct {
     bun_version: string,
     platform: Analytics.GenerateHeader.GeneratePlatform.Platform,
-    framework: string = "",
-    framework_version: string = "",
 
     const Analytics = @import("./analytics/analytics_thread.zig");
     const JSON = bun.JSON;
     const JSAst = bun.JSAst;
-    pub fn generate(comptime Bundler: type, bundler: Bundler, allocator: std.mem.Allocator) !JSAst.Expr {
-        var info = BunInfo{
+    pub fn generate(comptime Bundler: type, _: Bundler, allocator: std.mem.Allocator) !JSAst.Expr {
+        const info = BunInfo{
             .bun_version = Global.package_json_version,
             .platform = Analytics.GenerateHeader.GeneratePlatform.forOS(),
         };
 
-        if (bundler.options.framework) |framework| {
-            info.framework = framework.package;
-            info.framework_version = framework.version;
-        }
-
         return try JSON.toAST(allocator, BunInfo, info);
     }
 };
diff --git a/src/StandaloneModuleGraph.zig b/src/StandaloneModuleGraph.zig
index 9e9827aa00..e3daa4da17 100644
--- a/src/StandaloneModuleGraph.zig
+++ b/src/StandaloneModuleGraph.zig
@@ -75,8 +75,10 @@ pub const StandaloneModuleGraph = struct {
         name: Schema.StringPointer = .{},
         contents: Schema.StringPointer = .{},
         sourcemap: Schema.StringPointer = .{},
+        bytecode: Schema.StringPointer = .{},
         encoding: Encoding = .latin1,
         loader: bun.options.Loader = .file,
+        module_format: ModuleFormat = .none,
     };
 
     pub const Encoding = enum(u8) {
@@ -88,6 +90,12 @@ pub const StandaloneModuleGraph = struct {
         utf8 = 2,
     };
 
+    pub const ModuleFormat = enum(u8) {
+        none = 0,
+        esm = 1,
+        cjs = 2,
+    };
+
     pub const File = struct {
         name: []const u8 = "",
         loader: bun.options.Loader,
@@ -96,6 +104,8 @@ pub const StandaloneModuleGraph = struct {
         cached_blob: ?*bun.JSC.WebCore.Blob = null,
         encoding: Encoding = .binary,
         wtf_string: bun.String = bun.String.empty,
+        bytecode: []u8 = "",
+        module_format: ModuleFormat = .none,
 
         pub fn lessThanByIndex(ctx: []const File, lhs_i: u32, rhs_i: u32) bool {
             const lhs = ctx[lhs_i];
@@ -225,7 +235,7 @@ pub const StandaloneModuleGraph = struct {
         };
 
         const modules_list_bytes = sliceTo(raw_bytes, offsets.modules_ptr);
-        const modules_list = std.mem.bytesAsSlice(CompiledModuleGraphFile, modules_list_bytes);
+        const modules_list: []align(1) const CompiledModuleGraphFile = std.mem.bytesAsSlice(CompiledModuleGraphFile, modules_list_bytes);
 
         if (offsets.entry_point_id > modules_list.len) {
             return error.@"Corrupted module graph: entry point ID is greater than module list count";
@@ -246,6 +256,8 @@ pub const StandaloneModuleGraph = struct {
                         } }
                     else
                         .none,
+                    .bytecode = if (module.bytecode.length > 0) @constCast(sliceTo(raw_bytes, module.bytecode)) else &.{},
+                    .module_format = module.module_format,
                 },
             );
         }
@@ -271,14 +283,14 @@ pub const StandaloneModuleGraph = struct {
         return bytes[ptr.offset..][0..ptr.length :0];
     }
 
-    pub fn toBytes(allocator: std.mem.Allocator, prefix: []const u8, output_files: []const bun.options.OutputFile) ![]u8 {
+    pub fn toBytes(allocator: std.mem.Allocator, prefix: []const u8, output_files: []const bun.options.OutputFile, output_format: bun.options.Format) ![]u8 {
         var serialize_trace = bun.tracy.traceNamed(@src(), "StandaloneModuleGraph.serialize");
         defer serialize_trace.end();
 
         var entry_point_id: ?usize = null;
         var string_builder = bun.StringBuilder{};
         var module_count: usize = 0;
-        for (output_files, 0..) |output_file, i| {
+        for (output_files) |output_file| {
             string_builder.countZ(output_file.dest_path);
             string_builder.countZ(prefix);
             if (output_file.value == .buffer) {
@@ -288,10 +300,13 @@ pub const StandaloneModuleGraph = struct {
                     // the exact amount is not possible without allocating as it
                     // involves a JSON parser.
                     string_builder.cap += output_file.value.buffer.bytes.len * 2;
+                } else if (output_file.output_kind == .bytecode) {
+                    // Allocate up to 256 byte alignment for bytecode
+                    string_builder.cap += (output_file.value.buffer.bytes.len + 255) / 256 * 256 + 256;
                 } else {
                     if (entry_point_id == null) {
                         if (output_file.output_kind == .@"entry-point") {
-                            entry_point_id = i;
+                            entry_point_id = module_count;
                         }
                     }
 
@@ -320,7 +335,7 @@ pub const StandaloneModuleGraph = struct {
         defer source_map_arena.deinit();
 
         for (output_files) |output_file| {
-            if (output_file.output_kind == .sourcemap) {
+            if (!output_file.output_kind.isFileInStandaloneMode()) {
                 continue;
             }
 
@@ -330,6 +345,23 @@ pub const StandaloneModuleGraph = struct {
 
             const dest_path = bun.strings.removeLeadingDotSlash(output_file.dest_path);
 
+            const bytecode: StringPointer = brk: {
+                if (output_file.bytecode_index != std.math.maxInt(u32)) {
+                    // Use up to 256 byte alignment for bytecode
+                    // Not aligning it correctly will cause a runtime assertion error, or a segfault.
+                    const bytecode = output_files[output_file.bytecode_index].value.buffer.bytes;
+                    const aligned = std.mem.alignInSlice(string_builder.writable(), 128).?;
+                    @memcpy(aligned[0..bytecode.len], bytecode[0..bytecode.len]);
+                    const unaligned_space = aligned[bytecode.len..];
+                    const offset = @intFromPtr(aligned.ptr) - @intFromPtr(string_builder.ptr.?);
+                    const len = bytecode.len + @min(unaligned_space.len, 128);
+                    string_builder.len += len;
+                    break :brk StringPointer{ .offset = @truncate(offset), .length = @truncate(len) };
+                } else {
+                    break :brk .{};
+                }
+            };
+
             var module = CompiledModuleGraphFile{
                 .name = string_builder.fmtAppendCountZ("{s}{s}", .{
                     prefix,
@@ -341,7 +373,14 @@ pub const StandaloneModuleGraph = struct {
                     .js, .jsx, .ts, .tsx => .latin1,
                     else => .binary,
                 },
+                .module_format = if (output_file.loader.isJavaScriptLike()) switch (output_format) {
+                    .cjs => .cjs,
+                    .esm => .esm,
+                    else => .none,
+                } else .none,
+                .bytecode = bytecode,
             };
+
             if (output_file.source_map_index != std.math.maxInt(u32)) {
                 defer source_map_header_list.clearRetainingCapacity();
                 defer source_map_string_list.clearRetainingCapacity();
@@ -619,8 +658,9 @@ pub const StandaloneModuleGraph = struct {
         module_prefix: []const u8,
         outfile: []const u8,
         env: *bun.DotEnv.Loader,
+        output_format: bun.options.Format,
     ) !void {
-        const bytes = try toBytes(allocator, module_prefix, output_files);
+        const bytes = try toBytes(allocator, module_prefix, output_files, output_format);
         if (bytes.len == 0) return;
 
         const fd = inject(
@@ -999,7 +1039,7 @@ pub const StandaloneModuleGraph = struct {
             bun.JSAst.Expr.Data.Store.reset();
             bun.JSAst.Stmt.Data.Store.reset();
         }
-        var json = bun.JSON.ParseJSON(&json_src, &log, arena) catch
+        var json = bun.JSON.parse(&json_src, &log, arena, false) catch
             return error.InvalidSourceMap;
 
         const mappings_str = json.get("mappings") orelse
@@ -1032,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);
@@ -1049,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 bd8217163e..e43c11ed07 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 {
@@ -490,7 +498,7 @@ pub fn BSSMap(comptime ValueType: type, comptime count: anytype, comptime store_
         }
 
         pub fn getOrPut(self: *Self, denormalized_key: []const u8) !Result {
-            const key = if (comptime remove_trailing_slashes) std.mem.trimRight(u8, denormalized_key, "/") else denormalized_key;
+            const key = if (comptime remove_trailing_slashes) std.mem.trimRight(u8, denormalized_key, std.fs.path.sep_str) else denormalized_key;
             const _key = bun.hash(key);
 
             self.mutex.lock();
@@ -518,7 +526,7 @@ pub fn BSSMap(comptime ValueType: type, comptime count: anytype, comptime store_
         }
 
         pub fn get(self: *Self, denormalized_key: []const u8) ?*ValueType {
-            const key = if (comptime remove_trailing_slashes) std.mem.trimRight(u8, denormalized_key, "/") else denormalized_key;
+            const key = if (comptime remove_trailing_slashes) std.mem.trimRight(u8, denormalized_key, std.fs.path.sep_str) else denormalized_key;
             const _key = bun.hash(key);
             self.mutex.lock();
             defer self.mutex.unlock();
@@ -580,7 +588,7 @@ pub fn BSSMap(comptime ValueType: type, comptime count: anytype, comptime store_
             defer self.mutex.unlock();
 
             const key = if (comptime remove_trailing_slashes)
-                std.mem.trimRight(u8, denormalized_key, "/")
+                std.mem.trimRight(u8, denormalized_key, std.fs.path.sep_str)
             else
                 denormalized_key;
 
@@ -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 {
@@ -676,7 +685,7 @@ pub fn BSSMap(comptime ValueType: type, comptime count: anytype, comptime store_
         }
 
         // There's two parts to this.
-        // 1. Storing the underyling string.
+        // 1. Storing the underlying string.
         // 2. Making the key accessible at the index.
         pub fn putKey(self: *Self, key: anytype, result: *Result) !void {
             self.map.mutex.lock();
diff --git a/src/analytics/analytics_thread.zig b/src/analytics/analytics_thread.zig
index 72bbadf6fa..3c2c9bbe4d 100644
--- a/src/analytics/analytics_thread.zig
+++ b/src/analytics/analytics_thread.zig
@@ -79,43 +79,53 @@ pub fn isCI() bool {
 
 /// This answers, "What parts of bun are people actually using?"
 pub const Features = struct {
-    /// Set right before JSC::initialize is called
-    pub var jsc: usize = 0;
+    pub var builtin_modules = std.enums.EnumSet(bun.JSC.HardcodedModule).initEmpty();
+
     pub var @"Bun.stderr": usize = 0;
     pub var @"Bun.stdin": usize = 0;
     pub var @"Bun.stdout": usize = 0;
+    pub var WebSocket: usize = 0;
     pub var abort_signal: usize = 0;
+    pub var binlinks: usize = 0;
     pub var bunfig: usize = 0;
     pub var define: usize = 0;
     pub var dotenv: usize = 0;
     pub var external: usize = 0;
     pub var extracted_packages: usize = 0;
-    /// Incremented for each call to `fetch`
     pub var fetch: usize = 0;
-    pub var filesystem_router: usize = 0;
     pub var git_dependencies: usize = 0;
     pub var html_rewriter: usize = 0;
     pub var http_server: usize = 0;
     pub var https_server: usize = 0;
+    /// Set right before JSC::initialize is called
+    pub var jsc: usize = 0;
+    /// Set when bake.DevServer is initialized
+    pub var dev_server: usize = 0;
     pub var lifecycle_scripts: usize = 0;
     pub var loaders: usize = 0;
     pub var lockfile_migration_from_package_lock: usize = 0;
     pub var macros: usize = 0;
+    pub var no_avx2: usize = 0;
+    pub var no_avx: usize = 0;
     pub var shell: usize = 0;
     pub var spawn: usize = 0;
-    pub var standalone_shell: usize = 0;
-    pub var transpiler_cache: usize = 0;
-    pub var tsconfig_paths: usize = 0;
-    pub var tsconfig: usize = 0;
-    pub var virtual_modules: usize = 0;
-    pub var WebSocket: usize = 0;
-    pub var no_avx: usize = 0;
-    pub var no_avx2: usize = 0;
-    pub var binlinks: usize = 0;
-    pub var builtin_modules = std.enums.EnumSet(bun.JSC.HardcodedModule).initEmpty();
     pub var standalone_executable: usize = 0;
+    pub var standalone_shell: usize = 0;
+    /// Set when invoking a todo panic
+    pub var todo_panic: usize = 0;
+    pub var transpiler_cache: usize = 0;
+    pub var tsconfig: usize = 0;
+    pub var tsconfig_paths: usize = 0;
+    pub var virtual_modules: usize = 0;
     pub var workers_spawned: usize = 0;
     pub var workers_terminated: usize = 0;
+    pub var napi_module_register: usize = 0;
+    pub var process_dlopen: usize = 0;
+
+    comptime {
+        @export(napi_module_register, .{ .name = "Bun__napi_module_register_count" });
+        @export(process_dlopen, .{ .name = "Bun__process_dlopen_count" });
+    }
 
     pub fn formatter() Formatter {
         return Formatter{};
@@ -333,6 +343,25 @@ pub const GenerateHeader = struct {
             return linux_kernel_version;
         }
 
+        export fn Bun__isEpollPwait2SupportedOnLinuxKernel() i32 {
+            if (comptime !Environment.isLinux) {
+                return 0;
+            }
+
+            // https://man.archlinux.org/man/epoll_pwait2.2.en#HISTORY
+            const min_epoll_pwait2 = Semver.Version{
+                .major = 5,
+                .minor = 11,
+                .patch = 0,
+            };
+
+            return switch (kernelVersion().order(min_epoll_pwait2, "", "")) {
+                .gt => 1,
+                .eq => 1,
+                .lt => 0,
+            };
+        }
+
         fn forLinux() Analytics.Platform {
             linux_os_name = std.mem.zeroes(@TypeOf(linux_os_name));
 
diff --git a/src/api/schema.zig b/src/api/schema.zig
index 10e25bb561..002f43223f 100644
--- a/src/api/schema.zig
+++ b/src/api/schema.zig
@@ -1,6 +1,7 @@
 const std = @import("std");
 const bun = @import("root").bun;
 const js_ast = bun.JSAst;
+const OOM = bun.OOM;
 
 pub const Reader = struct {
     const Self = @This();
@@ -1635,6 +1636,8 @@ pub const Api = struct {
         /// define
         define: ?StringMap = null,
 
+        drop: []const []const u8 = &.{},
+
         /// preserve_symlinks
         preserve_symlinks: ?bool = null,
 
@@ -1671,12 +1674,6 @@ pub const Api = struct {
         /// extension_order
         extension_order: []const []const u8,
 
-        /// framework
-        framework: ?FrameworkConfig = null,
-
-        /// router
-        router: ?RouteConfig = null,
-
         /// no_summary
         no_summary: ?bool = null,
 
@@ -1755,9 +1752,7 @@ pub const Api = struct {
                     15 => {
                         this.target = try reader.readValue(Target);
                     },
-                    16 => {
-                        this.serve = try reader.readValue(bool);
-                    },
+                    16 => {},
                     17 => {
                         this.env_files = try reader.readArray([]const u8);
                     },
@@ -2821,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),
@@ -2831,11 +2826,11 @@ pub const Api = struct {
                 }
             }
 
-            pub fn parseRegistryURLString(this: *Parser, str: *js_ast.E.String) !Api.NpmRegistry {
+            pub fn parseRegistryURLString(this: *Parser, str: *js_ast.E.String) OOM!Api.NpmRegistry {
                 return try this.parseRegistryURLStringImpl(str.data);
             }
 
-            pub fn parseRegistryURLStringImpl(this: *Parser, str: []const u8) !Api.NpmRegistry {
+            pub fn parseRegistryURLStringImpl(this: *Parser, str: []const u8) OOM!Api.NpmRegistry {
                 const url = bun.URL.parse(str);
                 var registry = std.mem.zeroes(Api.NpmRegistry);
 
@@ -2982,6 +2977,13 @@ pub const Api = struct {
         /// concurrent_scripts
         concurrent_scripts: ?u32 = null,
 
+        cafile: ?[]const u8 = null,
+
+        ca: ?union(enum) {
+            str: []const u8,
+            list: []const []const u8,
+        } = null,
+
         pub fn decode(reader: anytype) anyerror!BunInstall {
             var this = std.mem.zeroes(BunInstall);
 
diff --git a/src/ast/base.zig b/src/ast/base.zig
index 26f3815e24..ffd6240ad3 100644
--- a/src/ast/base.zig
+++ b/src/ast/base.zig
@@ -31,7 +31,6 @@ pub const RefCtx = struct {
 
 /// In some parts of Bun, we have many different IDs pointing to different things.
 /// It's easy for them to get mixed up, so we use this type to make sure we don't.
-///
 pub const Index = packed struct(u32) {
     value: Int,
 
@@ -48,6 +47,9 @@ pub const Index = packed struct(u32) {
     pub const invalid = Index{ .value = std.math.maxInt(Int) };
     pub const runtime = Index{ .value = 0 };
 
+    pub const bake_server_data = Index{ .value = 1 };
+    pub const bake_client_data = Index{ .value = 2 };
+
     pub const Int = u32;
 
     pub inline fn source(num: anytype) Index {
@@ -111,7 +113,7 @@ pub const Ref = packed struct(u64) {
         allocated_name,
         source_contents_slice,
         symbol,
-    } = .invalid,
+    },
 
     source_index: Int = 0,
 
@@ -229,6 +231,8 @@ pub const Ref = packed struct(u64) {
             *const std.ArrayList(js_ast.Symbol) => symbol_table.items,
             *std.ArrayList(js_ast.Symbol) => symbol_table.items,
             []js_ast.Symbol => symbol_table,
+            *js_ast.Symbol.Map => return symbol_table.get(ref) orelse
+                unreachable, // ref must exist within symbol table
             else => |T| @compileError("Unsupported type to Ref.getSymbol: " ++ @typeName(T)),
         };
         return &resolved_symbol_table[ref.innerIndex()];
diff --git a/src/async/posix_event_loop.zig b/src/async/posix_event_loop.zig
index 491e09ce7b..bb4c4286f1 100644
--- a/src/async/posix_event_loop.zig
+++ b/src/async/posix_event_loop.zig
@@ -55,11 +55,11 @@ pub const KeepAlive = struct {
         this.status = .inactive;
 
         if (comptime @TypeOf(event_loop_ctx_) == JSC.EventLoopHandle) {
-            event_loop_ctx_.loop().subActive(1);
+            event_loop_ctx_.loop().unref();
             return;
         }
         const event_loop_ctx = JSC.AbstractVM(event_loop_ctx_);
-        event_loop_ctx.platformEventLoop().subActive(1);
+        event_loop_ctx.platformEventLoop().unref();
     }
 
     /// From another thread, Prevent a poll from keeping the process alive.
diff --git a/src/baby_list.zig b/src/baby_list.zig
index d304f75496..adf41b1620 100644
--- a/src/baby_list.zig
+++ b/src/baby_list.zig
@@ -13,7 +13,28 @@ pub fn BabyList(comptime Type: type) type {
         cap: u32 = 0,
 
         pub const Elem = Type;
+        pub fn parse(input: *bun.css.Parser) bun.css.Result(ListType) {
+            return switch (input.parseCommaSeparated(Type, bun.css.generic.parseFor(Type))) {
+                .result => |v| return .{ .result = ListType{
+                    .ptr = v.items.ptr,
+                    .len = @intCast(v.items.len),
+                    .cap = @intCast(v.capacity),
+                } },
+                .err => |e| return .{ .err = e },
+            };
+        }
 
+        pub fn toCss(this: *const ListType, comptime W: type, dest: *bun.css.Printer(W)) bun.css.PrintErr!void {
+            return bun.css.to_css.fromBabyList(Type, this, W, dest);
+        }
+
+        pub fn eql(lhs: *const ListType, rhs: *const ListType) bool {
+            if (lhs.len != rhs.len) return false;
+            for (lhs.sliceConst(), rhs.sliceConst()) |*a, *b| {
+                if (!bun.css.generic.eql(Type, a, b)) return false;
+            }
+            return true;
+        }
         pub fn set(this: *@This(), slice_: []Type) void {
             this.ptr = slice_.ptr;
             this.len = @as(u32, @truncate(slice_.len));
@@ -29,6 +50,12 @@ pub fn BabyList(comptime Type: type) type {
             this.* = .{};
         }
 
+        pub fn shrinkAndFree(this: *@This(), allocator: std.mem.Allocator, size: usize) void {
+            var list_ = this.listManaged(allocator);
+            list_.shrinkAndFree(size);
+            this.update(list_);
+        }
+
         pub fn orderedRemove(this: *@This(), index: usize) Type {
             var l = this.list();
             defer this.update(l);
@@ -41,11 +68,17 @@ pub fn BabyList(comptime Type: type) type {
             return l.swapRemove(index);
         }
 
+        pub fn sortAsc(
+            this: *@This(),
+        ) void {
+            bun.strings.sortAsc(this.slice());
+        }
+
         pub fn contains(this: @This(), item: []const Type) bool {
             return this.len > 0 and @intFromPtr(item.ptr) >= @intFromPtr(this.ptr) and @intFromPtr(item.ptr) < @intFromPtr(this.ptr) + this.len;
         }
 
-        pub inline fn initConst(items: []const Type) ListType {
+        pub fn initConst(items: []const Type) callconv(bun.callconv_inline) ListType {
             @setRuntimeSafety(false);
             return ListType{
                 // Remove the const qualifier from the items
@@ -77,8 +110,17 @@ pub fn BabyList(comptime Type: type) type {
             };
         }
 
+        fn assertValidDeepClone(comptime T: type) void {
+            return switch (T) {
+                bun.JSAst.Expr, bun.JSAst.G.Property, bun.css.ImportConditions => {},
+                else => {
+                    @compileError("Unsupported type for BabyList.deepClone(): " ++ @typeName(Type));
+                },
+            };
+        }
+
         pub fn deepClone(this: @This(), allocator: std.mem.Allocator) !@This() {
-            if (comptime Type != bun.JSAst.Expr and Type != bun.JSAst.G.Property) @compileError("Unsupported type for BabyList.deepClone()");
+            assertValidDeepClone(Type);
             var list_ = try initCapacity(allocator, this.len);
             for (this.slice()) |item| {
                 list_.appendAssumeCapacity(try item.deepClone(allocator));
@@ -87,6 +129,17 @@ pub fn BabyList(comptime Type: type) type {
             return list_;
         }
 
+        /// Same as `deepClone` but doesn't return an error
+        pub fn deepClone2(this: @This(), allocator: std.mem.Allocator) @This() {
+            assertValidDeepClone(Type);
+            var list_ = initCapacity(allocator, this.len) catch bun.outOfMemory();
+            for (this.slice()) |item| {
+                list_.appendAssumeCapacity(item.deepClone(allocator));
+            }
+
+            return list_;
+        }
+
         pub fn clearRetainingCapacity(this: *@This()) void {
             this.len = 0;
         }
@@ -204,24 +257,24 @@ pub fn BabyList(comptime Type: type) type {
             };
         }
 
-        pub inline fn first(this: ListType) ?*Type {
+        pub fn first(this: ListType) callconv(bun.callconv_inline) ?*Type {
             return if (this.len > 0) this.ptr[0] else @as(?*Type, null);
         }
 
-        pub inline fn last(this: ListType) ?*Type {
+        pub fn last(this: ListType) callconv(bun.callconv_inline) ?*Type {
             return if (this.len > 0) &this.ptr[this.len - 1] else @as(?*Type, null);
         }
 
-        pub inline fn first_(this: ListType) Type {
+        pub fn first_(this: ListType) callconv(bun.callconv_inline) Type {
             return this.ptr[0];
         }
 
-        pub inline fn at(this: ListType, index: usize) *const Type {
+        pub fn at(this: ListType, index: usize) callconv(bun.callconv_inline) *const Type {
             bun.assert(index < this.len);
             return &this.ptr[index];
         }
 
-        pub inline fn mut(this: ListType, index: usize) *Type {
+        pub fn mut(this: ListType, index: usize) callconv(bun.callconv_inline) *Type {
             bun.assert(index < this.len);
             return &this.ptr[index];
         }
@@ -236,7 +289,7 @@ pub fn BabyList(comptime Type: type) type {
             };
         }
 
-        pub inline fn @"[0]"(this: ListType) Type {
+        pub fn @"[0]"(this: ListType) callconv(bun.callconv_inline) Type {
             return this.ptr[0];
         }
         const OOM = error{OutOfMemory};
@@ -259,7 +312,12 @@ pub fn BabyList(comptime Type: type) type {
             this.update(list__);
         }
 
-        pub inline fn slice(this: ListType) []Type {
+        pub fn slice(this: ListType) callconv(bun.callconv_inline) []Type {
+            @setRuntimeSafety(false);
+            return this.ptr[0..this.len];
+        }
+
+        pub fn sliceConst(this: *const ListType) callconv(bun.callconv_inline) []const Type {
             @setRuntimeSafety(false);
             return this.ptr[0..this.len];
         }
@@ -273,6 +331,7 @@ pub fn BabyList(comptime Type: type) type {
             this.update(list_);
             return this.len - initial;
         }
+
         pub fn writeLatin1(this: *@This(), allocator: std.mem.Allocator, str: []const u8) !u32 {
             if (comptime Type != u8)
                 @compileError("Unsupported for type " ++ @typeName(Type));
@@ -282,6 +341,7 @@ pub fn BabyList(comptime Type: type) type {
             this.update(new);
             return this.len - initial;
         }
+
         pub fn writeUTF16(this: *@This(), allocator: std.mem.Allocator, str: []const u16) !u32 {
             if (comptime Type != u8)
                 @compileError("Unsupported for type " ++ @typeName(Type));
diff --git a/src/bake/BakeGlobalObject.cpp b/src/bake/BakeGlobalObject.cpp
new file mode 100644
index 0000000000..4bd4a4647e
--- /dev/null
+++ b/src/bake/BakeGlobalObject.cpp
@@ -0,0 +1,217 @@
+#include "BakeGlobalObject.h"
+#include "BakeSourceProvider.h"
+#include "JSNextTickQueue.h"
+#include "JavaScriptCore/GlobalObjectMethodTable.h"
+#include "JavaScriptCore/JSInternalPromise.h"
+#include "headers-handwritten.h"
+#include "JavaScriptCore/JSModuleLoader.h"
+#include "JavaScriptCore/Completion.h"
+#include "JavaScriptCore/JSSourceCode.h"
+
+extern "C" BunString BakeProdResolve(JSC::JSGlobalObject*, BunString a, BunString b);
+
+namespace Bake {
+
+JSC::JSInternalPromise*
+bakeModuleLoaderImportModule(JSC::JSGlobalObject* global,
+    JSC::JSModuleLoader* moduleLoader, JSC::JSString* moduleNameValue,
+    JSC::JSValue parameters,
+    const JSC::SourceOrigin& sourceOrigin)
+{
+    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());
+    }
+
+    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,
+    JSC::JSValue referrer, JSC::JSValue origin)
+{
+    Bake::GlobalObject* global = jsCast<Bake::GlobalObject*>(jsGlobal);
+    JSC::VM& vm = global->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    ASSERT(referrer.isString());
+    WTF::String refererString = jsCast<JSC::JSString*>(referrer)->getString(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));
+    }
+
+    // Use Zig::GlobalObject's function
+    return Zig::GlobalObject::moduleLoaderResolve(jsGlobal, loader, key, referrer, origin);
+}
+
+static JSC::JSInternalPromise* rejectedInternalPromise(JSC::JSGlobalObject* globalObject, JSC::JSValue value)
+{
+    JSC::VM& vm = globalObject->vm();
+    JSC::JSInternalPromise* promise = JSC::JSInternalPromise::create(vm, globalObject->internalPromiseStructure());
+    promise->internalField(JSC::JSPromise::Field::ReactionsOrResult).set(vm, promise, value);
+    promise->internalField(JSC::JSPromise::Field::Flags).set(vm, promise, JSC::jsNumber(promise->internalField(JSC::JSPromise::Field::Flags).get().asUInt32AsAnyInt() | JSC::JSPromise::isFirstResolvingFunctionCalledFlag | static_cast<unsigned>(JSC::JSPromise::Status::Rejected)));
+    return promise;
+}
+
+static JSC::JSInternalPromise* resolvedInternalPromise(JSC::JSGlobalObject* globalObject, JSC::JSValue value)
+{
+    JSC::VM& vm = globalObject->vm();
+    JSC::JSInternalPromise* promise = JSC::JSInternalPromise::create(vm, globalObject->internalPromiseStructure());
+    promise->internalField(JSC::JSPromise::Field::ReactionsOrResult).set(vm, promise, value);
+    promise->internalField(JSC::JSPromise::Field::Flags).set(vm, promise, JSC::jsNumber(promise->internalField(JSC::JSPromise::Field::Flags).get().asUInt32AsAnyInt() | JSC::JSPromise::isFirstResolvingFunctionCalledFlag | static_cast<unsigned>(JSC::JSPromise::Status::Fulfilled)));
+    return promise;
+}
+
+extern "C" BunString BakeProdLoad(ProductionPerThread* perThreadData, BunString a);
+
+JSC::JSInternalPromise* bakeModuleLoaderFetch(JSC::JSGlobalObject* globalObject,
+    JSC::JSModuleLoader* loader, JSC::JSValue key,
+    JSC::JSValue parameters, JSC::JSValue script)
+{
+    Bake::GlobalObject* global = jsCast<Bake::GlobalObject*>(globalObject);
+    JSC::VM& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    auto moduleKey = key.toWTFString(globalObject);
+    if (UNLIKELY(scope.exception()))
+        return rejectedInternalPromise(globalObject, scope.exception()->value());
+
+    if (moduleKey.startsWith("bake:/"_s)) {
+        if (LIKELY(global->m_perThreadData)) {
+            BunString source = BakeProdLoad(global->m_perThreadData, Bun::toString(moduleKey));
+            if (source.tag != BunStringTag::Dead) {
+                JSC::SourceOrigin origin = JSC::SourceOrigin(WTF::URL(moduleKey));
+                JSC::SourceCode sourceCode = JSC::SourceCode(Bake::SourceProvider::create(
+                    source.toWTFString(),
+                    origin,
+                    WTFMove(moduleKey),
+                    WTF::TextPosition(),
+                    JSC::SourceProviderSourceType::Module));
+                return resolvedInternalPromise(globalObject, JSC::JSSourceCode::create(vm, WTFMove(sourceCode)));
+            }
+            return rejectedInternalPromise(globalObject, createTypeError(globalObject, makeString("Bundle does not have \""_s, moduleKey, "\". This is a bug in Bun's bundler."_s)));
+        }
+        return rejectedInternalPromise(globalObject, createTypeError(globalObject, "BakeGlobalObject does not have per-thread data configured"_s));
+    }
+
+    return Zig::GlobalObject::moduleLoaderFetch(globalObject, loader, key, parameters, script);
+}
+
+#define INHERIT_HOOK_METHOD(name) \
+    Zig::GlobalObject::s_globalObjectMethodTable.name
+
+const JSC::GlobalObjectMethodTable GlobalObject::s_globalObjectMethodTable = {
+    INHERIT_HOOK_METHOD(supportsRichSourceInfo),
+    INHERIT_HOOK_METHOD(shouldInterruptScript),
+    INHERIT_HOOK_METHOD(javaScriptRuntimeFlags),
+    INHERIT_HOOK_METHOD(queueMicrotaskToEventLoop),
+    INHERIT_HOOK_METHOD(shouldInterruptScriptBeforeTimeout),
+    bakeModuleLoaderImportModule,
+    bakeModuleLoaderResolve,
+    bakeModuleLoaderFetch,
+    INHERIT_HOOK_METHOD(moduleLoaderCreateImportMetaProperties),
+    INHERIT_HOOK_METHOD(moduleLoaderEvaluate),
+    INHERIT_HOOK_METHOD(promiseRejectionTracker),
+    INHERIT_HOOK_METHOD(reportUncaughtExceptionAtEventLoop),
+    INHERIT_HOOK_METHOD(currentScriptExecutionOwner),
+    INHERIT_HOOK_METHOD(scriptExecutionStatus),
+    INHERIT_HOOK_METHOD(reportViolationForUnsafeEval),
+    INHERIT_HOOK_METHOD(defaultLanguage),
+    INHERIT_HOOK_METHOD(compileStreaming),
+    INHERIT_HOOK_METHOD(instantiateStreaming),
+    INHERIT_HOOK_METHOD(deriveShadowRealmGlobalObject),
+    INHERIT_HOOK_METHOD(codeForEval),
+    INHERIT_HOOK_METHOD(canCompileStrings),
+};
+
+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;
+}
+
+void GlobalObject::finishCreation(JSC::VM& vm)
+{
+    Base::finishCreation(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* BakeCreateProdGlobal(void* console)
+{
+    JSC::VM& vm = JSC::VM::create(JSC::HeapType::Large).leakRef();
+    vm.heap.acquireAccess();
+    JSC::JSLockHolder locker(vm);
+    BunVirtualMachine* bunVM = Bun__getVM();
+    WebCore::JSVMClientData::create(&vm, bunVM);
+
+    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_bunVM = bunVM;
+
+    JSC::gcProtect(global);
+
+    global->setConsole(console);
+    global->setStackTraceLimit(10); // Node.js defaults to 10
+
+    // TODO: it segfaults! process.nextTick is scoped out for now i guess!
+    // vm.setOnComputeErrorInfo(computeErrorInfoWrapper);
+    // vm.setOnEachMicrotaskTick([global](JSC::VM &vm) -> void {
+    //   if (auto nextTickQueue = global->m_nextTickQueue.get()) {
+    //     global->resetOnEachMicrotaskTick();
+    //     // Bun::JSNextTickQueue *queue =
+    //     //     jsCast<Bun::JSNextTickQueue *>(nextTickQueue);
+    //     // queue->drain(vm, global);
+    //     return;
+    //   }
+    // });
+
+    return global;
+}
+
+extern "C" void BakeGlobalObject__attachPerThreadData(GlobalObject* global, ProductionPerThread* perThreadData)
+{
+    global->m_perThreadData = perThreadData;
+}
+
+}; // namespace Bake
diff --git a/src/bake/BakeGlobalObject.h b/src/bake/BakeGlobalObject.h
new file mode 100644
index 0000000000..0ac902422e
--- /dev/null
+++ b/src/bake/BakeGlobalObject.h
@@ -0,0 +1,37 @@
+#pragma once
+#include "root.h"
+#include "ZigGlobalObject.h"
+
+namespace Bake {
+
+struct ProductionPerThread;
+
+class GlobalObject : public Zig::GlobalObject {
+public:
+    using Base = Zig::GlobalObject;
+
+    ProductionPerThread* m_perThreadData;
+
+    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+    {
+        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+            return nullptr;
+        return WebCore::subspaceForImpl<GlobalObject, WebCore::UseCustomHeapCellType::Yes>(
+            vm,
+            [](auto& spaces) { return spaces.m_clientSubspaceForBakeGlobalScope.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForBakeGlobalScope = std::forward<decltype(space)>(space); },
+            [](auto& spaces) { return spaces.m_subspaceForBakeGlobalScope.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_subspaceForBakeGlobalScope = std::forward<decltype(space)>(space); },
+            [](auto& server) -> JSC::HeapCellType& { return server.m_heapCellTypeForJSWorkerGlobalScope; });
+    }
+
+    static const JSC::GlobalObjectMethodTable s_globalObjectMethodTable;
+    static GlobalObject* create(JSC::VM& vm, JSC::Structure* structure, const JSC::GlobalObjectMethodTable* methodTable);
+
+    void finishCreation(JSC::VM& vm);
+
+    GlobalObject(JSC::VM& vm, JSC::Structure* structure, const JSC::GlobalObjectMethodTable* methodTable) 
+        : Zig::GlobalObject(vm, structure, methodTable) { }
+};
+
+}; // namespace Kit
diff --git a/src/bake/BakeProduction.cpp b/src/bake/BakeProduction.cpp
new file mode 100644
index 0000000000..d7a1fb9842
--- /dev/null
+++ b/src/bake/BakeProduction.cpp
@@ -0,0 +1,49 @@
+#include "BakeProduction.h"
+#include "BunBuiltinNames.h"
+#include "WebCoreJSBuiltins.h"
+#include "JavaScriptCore/JSPromise.h"
+#include "JavaScriptCore/Exception.h"
+
+namespace Bake {
+
+extern "C" JSC::JSPromise* BakeRenderRoutesForProdStatic(
+    JSC::JSGlobalObject* global,
+    BunString outBase,
+    JSC::JSValue allServerFiles,
+    JSC::JSValue renderStatic,
+    JSC::JSValue getParams,
+    JSC::JSValue clientEntryUrl,
+    JSC::JSValue pattern,
+    JSC::JSValue files,
+    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::bakeRenderRoutesForProdStaticCodeGenerator(vm), global);
+    JSC::CallData callData = JSC::getCallData(cb);
+
+    JSC::MarkedArgumentBuffer args;
+    args.append(JSC::jsString(vm, outBase.toWTFString()));
+    args.append(allServerFiles);
+    args.append(renderStatic);
+    args.append(getParams);
+    args.append(clientEntryUrl);
+    args.append(pattern);
+    args.append(files);
+    args.append(typeAndFlags);
+    args.append(sourceRouteFiles);
+    args.append(paramInformation);
+    args.append(styles);
+
+    NakedPtr<JSC::Exception> returnedException = nullptr;
+    auto result = JSC::call(global, cb, callData, JSC::jsUndefined(), args, returnedException);
+    if (UNLIKELY(returnedException)) {
+        // This should be impossible because it returns a promise.
+        return JSC::JSPromise::rejectedPromise(global, returnedException->value());
+    }
+    return JSC::jsCast<JSC::JSPromise*>(result);
+}
+
+} // namespace Bake
diff --git a/src/bake/BakeProduction.h b/src/bake/BakeProduction.h
new file mode 100644
index 0000000000..342159fd3e
--- /dev/null
+++ b/src/bake/BakeProduction.h
@@ -0,0 +1,5 @@
+#include "root.h"
+#include "headers-handwritten.h"
+
+namespace Bake {
+} // namespace Bake
\ No newline at end of file
diff --git a/src/bake/BakeSourceProvider.cpp b/src/bake/BakeSourceProvider.cpp
new file mode 100644
index 0000000000..2a51ffa0aa
--- /dev/null
+++ b/src/bake/BakeSourceProvider.cpp
@@ -0,0 +1,134 @@
+// clang-format off
+#include "BakeSourceProvider.h"
+#include "BakeGlobalObject.h"
+#include "JavaScriptCore/Completion.h"
+#include "JavaScriptCore/Identifier.h"
+#include "JavaScriptCore/JSCJSValue.h"
+#include "JavaScriptCore/JSCast.h"
+#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" JSC::EncodedJSValue BakeLoadInitialServerCode(GlobalObject* global, BunString source, bool separateSSRGraph) {
+  JSC::VM& vm = global->vm();
+  auto scope = DECLARE_THROW_SCOPE(vm);
+
+  String string = "bake://server-runtime.js"_s;
+  JSC::SourceOrigin origin = JSC::SourceOrigin(WTF::URL(string));
+  JSC::SourceCode sourceCode = JSC::SourceCode(SourceProvider::create(
+    source.toWTFString(),
+    origin,
+    WTFMove(string),
+    WTF::TextPosition(),
+    JSC::SourceProviderSourceType::Program
+  ));
+
+  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 JSC::JSValue::encode(JSC::call(global, fn, callData, JSC::jsUndefined(), args));
+}
+
+extern "C" JSC::JSInternalPromise* BakeLoadModuleByKey(GlobalObject* global, JSC::JSString* key) {
+  return global->moduleLoader()->loadAndEvaluateModule(global, key, JSC::jsUndefined(), JSC::jsUndefined());
+}
+
+extern "C" JSC::EncodedJSValue BakeLoadServerHmrPatch(GlobalObject* global, BunString source) {
+  JSC::VM&vm = global->vm();
+  auto scope = DECLARE_THROW_SCOPE(vm);
+
+  String string = "bake://server.patch.js"_s;
+  JSC::SourceOrigin origin = JSC::SourceOrigin(WTF::URL(string));
+  JSC::SourceCode sourceCode = JSC::SourceCode(SourceProvider::create(
+    source.toWTFString(),
+    origin,
+    WTFMove(string),
+    WTF::TextPosition(),
+    JSC::SourceProviderSourceType::Program
+  ));
+  
+  JSC::JSValue result = vm.interpreter.executeProgram(sourceCode, global, global);
+  RETURN_IF_EXCEPTION(scope, JSC::JSValue::encode({}));
+
+  RELEASE_ASSERT(result);
+  return JSC::JSValue::encode(result);
+}
+
+extern "C" JSC::EncodedJSValue BakeGetModuleNamespace(
+  JSC::JSGlobalObject* global,
+  JSC::JSValue keyValue
+) {
+  JSC::JSString* key = JSC::jsCast<JSC::JSString*>(keyValue);
+  JSC::VM& vm = global->vm();
+  JSC::JSMap* map = JSC::jsCast<JSC::JSMap*>(
+    global->moduleLoader()->getDirect(
+      vm, JSC::Identifier::fromString(global->vm(), "registry"_s)
+    ));
+  JSC::JSValue entry = map->get(global, key);
+  ASSERT(entry.isObject()); // should have called BakeLoadServerCode and wait for that promise
+  JSC::JSValue module = entry.getObject()->get(global, JSC::Identifier::fromString(global->vm(), "module"_s));
+  ASSERT(module.isCell());
+  JSC::JSModuleNamespaceObject* namespaceObject = global->moduleLoader()->getModuleNamespaceObject(global, module);
+  ASSERT(namespaceObject);
+  return JSC::JSValue::encode(namespaceObject);
+}
+
+extern "C" JSC::EncodedJSValue BakeGetDefaultExportFromModule(
+  JSC::JSGlobalObject* global,
+  JSC::JSValue keyValue
+) {
+  JSC::VM& vm = global->vm();
+  return JSC::JSValue::encode(jsCast<JSC::JSModuleNamespaceObject*>(JSC::JSValue::decode(BakeGetModuleNamespace(global, keyValue)))->get(global, vm.propertyNames->defaultKeyword));
+}
+
+// There were issues when trying to use JSValue.get from zig
+extern "C" JSC::EncodedJSValue BakeGetOnModuleNamespace(
+  JSC::JSGlobalObject* global,
+  JSC::JSModuleNamespaceObject* moduleNamespace,
+  const unsigned char* key,
+  size_t keyLength
+) {
+  JSC::VM& vm = global->vm();
+  const auto propertyString = String(StringImpl::createWithoutCopying({ key, keyLength }));
+  const auto identifier = JSC::Identifier::fromString(vm, propertyString);
+  const auto property = JSC::PropertyName(identifier);
+  return JSC::JSValue::encode(moduleNamespace->get(global, property));
+}
+
+extern "C" JSC::EncodedJSValue BakeRegisterProductionChunk(JSC::JSGlobalObject* global, BunString virtualPathName, BunString source) {
+  JSC::VM& vm = global->vm();
+  auto scope = DECLARE_THROW_SCOPE(vm);
+
+  String string = virtualPathName.toWTFString();
+  JSC::JSString* key = JSC::jsString(vm, string);
+  JSC::SourceOrigin origin = JSC::SourceOrigin(WTF::URL(string));
+  JSC::SourceCode sourceCode = JSC::SourceCode(SourceProvider::create(
+    source.toWTFString(),
+    origin,
+    WTFMove(string),
+    WTF::TextPosition(),
+    JSC::SourceProviderSourceType::Module
+  ));
+  
+  global->moduleLoader()->provideFetch(global, key, sourceCode);
+  RETURN_IF_EXCEPTION(scope, JSC::JSValue::encode({}));
+
+  return JSC::JSValue::encode(key);
+}
+
+} // namespace Bake
diff --git a/src/bake/BakeSourceProvider.h b/src/bake/BakeSourceProvider.h
new file mode 100644
index 0000000000..3a3706af85
--- /dev/null
+++ b/src/bake/BakeSourceProvider.h
@@ -0,0 +1,38 @@
+#pragma once
+#include "root.h"
+#include "headers-handwritten.h"
+#include "BakeGlobalObject.h"
+#include "JavaScriptCore/SourceOrigin.h"
+
+namespace Bake {
+
+class SourceProvider final : public JSC::StringSourceProvider {
+public:
+    static Ref<SourceProvider> create(
+      const String& source,
+      const JSC::SourceOrigin& sourceOrigin,
+      String&& sourceURL,
+      const TextPosition& startPosition,
+      JSC::SourceProviderSourceType sourceType
+    ) {
+        return adoptRef(*new SourceProvider(source, sourceOrigin, WTFMove(sourceURL), startPosition, sourceType));
+    }
+
+private:
+  SourceProvider(
+    const String& source,
+    const JSC::SourceOrigin& sourceOrigin,
+    String&& sourceURL,
+    const TextPosition& startPosition,
+    JSC::SourceProviderSourceType sourceType
+  ) : StringSourceProvider(
+    source, 
+    sourceOrigin, 
+    JSC::SourceTaintedOrigin::Untainted,
+    WTFMove(sourceURL),
+    startPosition,
+    sourceType
+  ) {}
+};
+
+} // namespace Bake
diff --git a/src/bake/DevServer.zig b/src/bake/DevServer.zig
new file mode 100644
index 0000000000..cae853a63d
--- /dev/null
+++ b/src/bake/DevServer.zig
@@ -0,0 +1,4488 @@
+//! Instance of the development server. Attaches to an instance of `Bun.serve`,
+//! controlling bundler, routing, and hot module reloading.
+//!
+//! 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.
+pub const DevServer = @This();
+pub const debug = bun.Output.Scoped(.Bake, false);
+pub const igLog = bun.Output.scoped(.IncrementalGraph, false);
+
+pub const Options = struct {
+    /// Arena must live until DevServer.deinit()
+    arena: Allocator,
+    root: []const u8,
+    vm: *VirtualMachine,
+    framework: bake.Framework,
+    bundler_options: bake.SplitBundlerOptions,
+
+    // Debugging features
+    dump_sources: ?[]const u8 = if (Environment.isDebug) ".bake-debug" else null,
+    dump_state_on_crash: ?bool = null,
+    verbose_watcher: bool = false,
+};
+
+// The fields `client_graph`, `server_graph`, and `directory_watchers` all
+// use `@fieldParentPointer` to access DevServer's state. This pattern has
+// made it easier to group related fields together, but one must remember
+// those structures still depend on the DevServer pointer.
+
+/// Used for all server-wide allocations. In debug, this shows up in
+/// a separate named heap. Thread-safe.
+allocator: Allocator,
+/// 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,
+/// 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,
+/// Quickly retrieve a route's index from its entry point file. These are
+/// populated as the routes are discovered. The route may not be bundled OR
+/// navigatable, such as the case where a layout's index is looked up.
+route_lookup: AutoArrayHashMapUnmanaged(IncrementalGraph(.server).FileIndex, RouteIndexAndRecurseFlag),
+/// 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.Optional),
+// /// 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 `hmr-runtime-server.ts`.
+// For type definitions, see `./bake.private.d.ts`
+server_fetch_function_callback: JSC.Strong,
+server_register_update_callback: JSC.Strong,
+
+// Watching
+bun_watcher: *JSC.Watcher,
+directory_watchers: DirectoryWatchStore,
+watcher_atomics: WatcherAtomics,
+
+/// 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,
+
+framework: bake.Framework,
+bundler_options: bake.SplitBundlerOptions,
+// Each logical graph gets its own bundler configuration
+server_bundler: Bundler,
+client_bundler: Bundler,
+ssr_bundler: Bundler,
+/// The log used by all `server_bundler`, `client_bundler` and `ssr_bundler`.
+/// Note that it is rarely correct to write messages into it. Instead, associate
+/// messages with the IncrementalGraph file or Route using `SerializedFailure`
+log: Log,
+/// There is only ever one bundle executing at the same time, since all bundles
+/// inevitably share state. This bundle is asynchronous, storing its state here
+/// while in-flight. All allocations held by `.bv2.graph.heap`'s arena
+current_bundle: ?struct {
+    bv2: *BundleV2,
+    /// Information BundleV2 needs to finalize the bundle
+    start_data: bun.bundle_v2.BakeBundleStart,
+    /// Started when the bundle was queued
+    timer: std.time.Timer,
+    /// If any files in this bundle were due to hot-reloading, some extra work
+    /// must be done to inform clients to reload routes. When this is false,
+    /// all entry points do not have bundles yet.
+    had_reload_event: bool,
+},
+/// This is not stored in `current_bundle` so that its memory can be reused when
+/// there is no active bundle. After the bundle finishes, these requests will
+/// be continued, either calling their handler on success or sending the error
+/// page on failure.
+current_bundle_requests: ArrayListUnmanaged(DeferredRequest),
+/// When `current_bundle` is non-null and new requests to bundle come in,
+/// those are temporaried here. When the current bundle is finished, it
+/// will immediately enqueue this.
+next_bundle: struct {
+    /// A list of `RouteBundle`s which have active requests to bundle it.
+    route_queue: AutoArrayHashMapUnmanaged(RouteBundle.Index, void),
+    /// If a reload event exists and should be drained. The information
+    /// for this watch event is in one of the `watch_events`
+    reload_event: ?*HotReloadEvent,
+    /// The list of requests that are blocked on this bundle.
+    requests: ArrayListUnmanaged(DeferredRequest),
+},
+
+// Debugging
+
+dump_dir: if (bun.FeatureFlags.bake_debugging_features) ?std.fs.Dir else void,
+/// 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 RouteBundle = struct {
+    pub const Index = bun.GenericIndex(u30, RouteBundle);
+
+    route: Route.Index,
+
+    server_state: State,
+
+    /// Used to communicate over WebSocket the pattern. The HMR client contains code
+    /// to match this against the URL bar to determine if a reloaded route applies.
+    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,
+    /// 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,
+
+    // TODO: micro-opt: use a singular strong
+
+    /// 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,
+
+    /// Reference count of how many HmrSockets say they are on this route. This
+    /// allows hot-reloading events to reduce the amount of times it traces the
+    /// graph.
+    active_viewers: usize,
+
+    /// 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.
+    const State = enum {
+        /// 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. 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
+        /// exist.
+        possible_bundling_failures,
+        /// Loading the module at runtime had a failure. The error can be
+        /// cleared by editing any file in the same hot-reloading boundary.
+        evaluation_failure,
+        /// Calling the request function may error, but that error will not be
+        /// at fault of bundling, nor would re-bundling change anything.
+        loaded,
+    };
+};
+
+/// DevServer is stored on the heap, storing its allocator.
+pub fn init(options: Options) bun.JSOOM!*DevServer {
+    const allocator = bun.default_allocator;
+    bun.analytics.Features.dev_server +|= 1;
+
+    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,
+
+        .root = options.root,
+        .vm = options.vm,
+        .server = null,
+        .directory_watchers = DirectoryWatchStore.empty,
+        .server_fetch_function_callback = .{},
+        .server_register_update_callback = .{},
+        .generation = 0,
+        .graph_safety_lock = bun.DebugThreadLock.unlocked,
+        .dump_dir = dump_dir,
+        .framework = options.framework,
+        .bundler_options = options.bundler_options,
+        .emit_visualizer_events = 0,
+        .has_pre_crash_handler = bun.FeatureFlags.bake_debugging_features and
+            options.dump_state_on_crash orelse
+            bun.getRuntimeFeatureFlag("BUN_DUMP_STATE_ON_CRASH"),
+        .css_files = .{},
+        .route_js_payloads = .{},
+        // .assets = .{},
+
+        .client_graph = IncrementalGraph(.client).empty,
+        .server_graph = IncrementalGraph(.server).empty,
+        .incremental_result = IncrementalResult.empty,
+        .route_lookup = .{},
+        .route_bundles = .{},
+        .current_bundle = null,
+        .current_bundle_requests = .{},
+        .next_bundle = .{
+            .route_queue = .{},
+            .reload_event = null,
+            .requests = .{},
+        },
+
+        .log = bun.logger.Log.init(allocator),
+
+        .server_bundler = undefined,
+        .client_bundler = undefined,
+        .ssr_bundler = undefined,
+        .bun_watcher = undefined,
+        .configuration_hash_key = undefined,
+        .router = undefined,
+        .watcher_atomics = undefined,
+    });
+    const global = dev.vm.global;
+    errdefer allocator.destroy(dev);
+
+    assert(dev.server_graph.owner() == dev);
+    assert(dev.client_graph.owner() == dev);
+    assert(dev.directory_watchers.owner() == dev);
+
+    dev.graph_safety_lock.lock();
+    defer dev.graph_safety_lock.unlock();
+
+    const generic_action = "while initializing development server";
+    const fs = bun.fs.FileSystem.init(options.root) catch |err|
+        return global.throwError(err, generic_action);
+
+    dev.bun_watcher = Watcher.init(DevServer, dev, fs, bun.default_allocator) catch |err|
+        return global.throwError(err, "while initializing file watcher for development server");
+
+    errdefer dev.bun_watcher.deinit(false);
+    dev.bun_watcher.start() catch |err|
+        return global.throwError(err, "while initializing file watcher thread for development server");
+
+    dev.server_bundler.resolver.watcher = dev.bun_watcher.getResolveWatcher();
+    dev.client_bundler.resolver.watcher = dev.bun_watcher.getResolveWatcher();
+    dev.ssr_bundler.resolver.watcher = dev.bun_watcher.getResolveWatcher();
+
+    dev.watcher_atomics = WatcherAtomics.init(dev);
+
+    dev.framework.initBundler(allocator, &dev.log, .development, .server, &dev.server_bundler) catch |err|
+        return global.throwError(err, generic_action);
+    dev.client_bundler.options.dev_server = dev;
+    dev.framework.initBundler(allocator, &dev.log, .development, .client, &dev.client_bundler) catch |err|
+        return global.throwError(err, generic_action);
+    dev.server_bundler.options.dev_server = dev;
+    if (separate_ssr_graph) {
+        dev.framework.initBundler(allocator, &dev.log, .development, .ssr, &dev.ssr_bundler) catch |err|
+            return global.throwError(err, generic_action);
+        dev.ssr_bundler.options.dev_server = dev;
+    }
+
+    dev.framework = dev.framework.resolve(&dev.server_bundler.resolver, &dev.client_bundler.resolver, options.arena) catch {
+        if (dev.framework.is_built_in_react)
+            try bake.Framework.addReactInstallCommandNote(&dev.log);
+        return global.throwValue(dev.log.toJSAggregateError(global, "Framework is missing required files!"));
+    };
+
+    errdefer dev.route_lookup.clearAndFree(allocator);
+    // errdefer dev.client_graph.deinit(allocator);
+    // errdefer dev.server_graph.deinit(allocator);
+
+    dev.configuration_hash_key = hash_key: {
+        var hash = std.hash.Wyhash.init(128);
+
+        if (bun.Environment.isDebug) {
+            const stat = bun.sys.stat(bun.selfExePath() catch |e|
+                Output.panic("unhandled {}", .{e})).unwrap() catch |e|
+                Output.panic("unhandled {}", .{e});
+            bun.writeAnyToHasher(&hash, stat.mtime());
+            hash.update(bake.getHmrRuntime(.client));
+            hash.update(bake.getHmrRuntime(.server));
+        } else {
+            hash.update(bun.Environment.git_sha_short);
+        }
+
+        for (dev.framework.file_system_router_types) |fsr| {
+            bun.writeAnyToHasher(&hash, fsr.allow_layouts);
+            bun.writeAnyToHasher(&hash, fsr.ignore_underscores);
+            hash.update(fsr.entry_server);
+            hash.update(&.{0});
+            hash.update(fsr.entry_client orelse "");
+            hash.update(&.{0});
+            hash.update(fsr.prefix);
+            hash.update(&.{0});
+            hash.update(fsr.root);
+            hash.update(&.{0});
+            for (fsr.extensions) |ext| {
+                hash.update(ext);
+                hash.update(&.{0});
+            }
+            hash.update(&.{0});
+            for (fsr.ignore_dirs) |dir| {
+                hash.update(dir);
+                hash.update(&.{0});
+            }
+            hash.update(&.{0});
+        }
+
+        if (dev.framework.server_components) |sc| {
+            bun.writeAnyToHasher(&hash, true);
+            bun.writeAnyToHasher(&hash, sc.separate_ssr_graph);
+            hash.update(sc.client_register_server_reference);
+            hash.update(&.{0});
+            hash.update(sc.server_register_client_reference);
+            hash.update(&.{0});
+            hash.update(sc.server_register_server_reference);
+            hash.update(&.{0});
+            hash.update(sc.server_runtime_import);
+            hash.update(&.{0});
+        } else {
+            bun.writeAnyToHasher(&hash, false);
+        }
+
+        if (dev.framework.react_fast_refresh) |rfr| {
+            bun.writeAnyToHasher(&hash, true);
+            hash.update(rfr.import_source);
+        } else {
+            bun.writeAnyToHasher(&hash, false);
+        }
+
+        for (dev.framework.built_in_modules.keys(), dev.framework.built_in_modules.values()) |k, v| {
+            hash.update(k);
+            hash.update(&.{0});
+            bun.writeAnyToHasher(&hash, std.meta.activeTag(v));
+            hash.update(switch (v) {
+                inline else => |data| data,
+            });
+            hash.update(&.{0});
+        }
+        hash.update(&.{0});
+
+        break :hash_key std.fmt.bytesToHex(std.mem.asBytes(&hash.final()), .lower);
+    };
+
+    // 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);
+    }
+
+    dev.initServerRuntime();
+
+    // Initialize FrameworkRouter
+    dev.router = router: {
+        var types = try std.ArrayListUnmanaged(FrameworkRouter.Type).initCapacity(allocator, options.framework.file_system_router_types.len);
+        errdefer types.deinit(allocator);
+
+        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;
+
+            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,
+                .allow_layouts = fsr.allow_layouts,
+                .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 = .{},
+            });
+
+            try dev.route_lookup.put(allocator, server_file, .{
+                .route_index = FrameworkRouter.Route.Index.init(@intCast(i)),
+                .should_recurse_when_visiting = true,
+            });
+        }
+
+        break :router try FrameworkRouter.initEmpty(dev.root, types.items, allocator);
+    };
+
+    // TODO: move scanning to be one tick after server startup. this way the
+    // line saying the server is ready shows quicker, and route errors show up
+    // after that line.
+    try dev.scanInitialRoutes();
+
+    if (bun.FeatureFlags.bake_debugging_features and dev.has_pre_crash_handler)
+        try bun.crash_handler.appendPreCrashHandler(DevServer, dev, dumpStateDueToCrash);
+
+    return dev;
+}
+
+fn initServerRuntime(dev: *DevServer) void {
+    const runtime = bun.String.static(bun.bake.getHmrRuntime(.server));
+
+    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");
+    };
+
+    if (!interface.isObject()) @panic("Internal assertion failure: expected interface from HMR runtime to be an object");
+    const fetch_function = interface.get(dev.vm.global, "handleRequest") catch null 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") catch null 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();
+}
+
+/// 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 attachRoutes(dev: *DevServer, server: anytype) !void {
+    dev.server = bun.JSC.API.AnyServer.from(server);
+    const app = server.app.?;
+
+    // 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", .{});
+    }
+
+    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);
+
+    app.ws(
+        internal_prefix ++ "/hmr",
+        dev,
+        0,
+        uws.WebSocketBehavior.Wrap(DevServer, HmrSocket, false).apply(.{}),
+    );
+
+    if (bun.FeatureFlags.bake_debugging_features)
+        app.get(internal_prefix ++ "/incremental_visualizer", *DevServer, dev, onIncrementalVisualizer);
+
+    app.any("/*", *DevServer, dev, onRequest);
+}
+
+pub fn deinit(dev: *DevServer) void {
+    // TODO: Currently deinit is not implemented, as it was assumed to be alive for
+    // the remainder of this process' lifespan. This isn't always true.
+    const allocator = dev.allocator;
+    if (dev.has_pre_crash_handler)
+        bun.crash_handler.removePreCrashHandler(dev);
+    allocator.destroy(dev);
+    // if (bun.Environment.isDebug)
+    //     bun.todoPanic(@src(), "bake.DevServer.deinit()", .{});
+}
+
+fn onJsRequest(dev: *DevServer, req: *Request, resp: *Response) void {
+    const maybe_route = route: {
+        const route_id = req.parameter(0);
+        if (!bun.strings.hasSuffixComptime(route_id, ".js"))
+            return req.setYield(true);
+        if (!bun.strings.hasPrefixComptime(route_id, "route."))
+            return req.setYield(true);
+        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);
+    };
+
+    if (maybe_route.unwrap()) |route| {
+        dev.ensureRouteIsBundled(route, .js_payload, req, resp) catch bun.outOfMemory();
+    } else {
+        @panic("TODO: generate client bundle with no source files");
+    }
+}
+
+fn onAssetRequest(dev: *DevServer, req: *Request, resp: *Response) void {
+    _ = dev;
+    _ = req;
+    _ = resp;
+    bun.todoPanic(@src(), "serve asset file", .{});
+    // const route_id = req.parameter(0);
+    // const asset = dev.assets.get(route_id) orelse
+    //     return req.setYield(true);
+    // _ = asset; // autofix
+
+}
+
+fn onCssRequest(dev: *DevServer, req: *Request, resp: *Response) void {
+    const param = req.parameter(0);
+    if (!bun.strings.hasSuffixComptime(param, ".css"))
+        return req.setYield(true);
+    const hex = param[0 .. param.len - ".css".len];
+    if (hex.len != @sizeOf(u64) * 2)
+        return req.setYield(true);
+
+    var out: [@sizeOf(u64)]u8 = undefined;
+    assert((std.fmt.hexToBytes(&out, hex) catch
+        return req.setYield(true)).len == @sizeOf(u64));
+    const hash: u64 = @bitCast(out);
+
+    const css = dev.css_files.get(hash) orelse
+        return req.setYield(true);
+
+    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});
+}
+
+fn onIncrementalVisualizerCorked(resp: *Response) void {
+    const code = if (Environment.codegen_embed)
+        @embedFile("incremental_visualizer.html")
+    else
+        bun.runtimeEmbedFile(.src_eager, "bake/incremental_visualizer.html");
+    resp.writeHeaderInt("Content-Length", code.len);
+    resp.end(code, false);
+}
+
+fn ensureRouteIsBundled(
+    dev: *DevServer,
+    route_index: Route.Index,
+    kind: DeferredRequest.Data.Tag,
+    req: *Request,
+    resp: *Response,
+) bun.OOM!void {
+    const route_bundle_index = try dev.getOrPutRouteBundle(route_index);
+
+    // TODO: Zig 0.14 gets labelled continue:
+    // - Remove the `while`
+    // - Move the code after this switch into `.loaded =>`
+    // - Replace `break` with `continue :sw .loaded`
+    // - Replace `continue` with `continue :sw <state>`
+    while (true) {
+        switch (dev.routeBundlePtr(route_bundle_index).server_state) {
+            .unqueued => {
+                try dev.next_bundle.requests.ensureUnusedCapacity(dev.allocator, 1);
+                if (dev.current_bundle != null) {
+                    try dev.next_bundle.route_queue.ensureUnusedCapacity(dev.allocator, 1);
+                }
+
+                const deferred: DeferredRequest = .{
+                    .route_bundle_index = route_bundle_index,
+                    .data = switch (kind) {
+                        .js_payload => .{ .js_payload = resp },
+                        .server_handler => .{
+                            .server_handler = (dev.server.?.DebugHTTPServer.prepareJsRequestContext(req, resp, null) orelse return)
+                                .save(dev.vm.global, req, resp),
+                        },
+                    },
+                };
+                errdefer @compileError("cannot error since the request is already stored");
+
+                dev.next_bundle.requests.appendAssumeCapacity(deferred);
+                if (dev.current_bundle != null) {
+                    dev.next_bundle.route_queue.putAssumeCapacity(route_bundle_index, {});
+                } else {
+                    var sfa = std.heap.stackFallback(4096, dev.allocator);
+                    const temp_alloc = sfa.get();
+
+                    var entry_points: EntryPointList = EntryPointList.empty;
+                    defer entry_points.deinit(temp_alloc);
+
+                    dev.appendRouteEntryPointsIfNotStale(&entry_points, temp_alloc, route_index) catch bun.outOfMemory();
+
+                    if (entry_points.set.count() == 0) {
+                        if (dev.bundling_failures.count() > 0) {
+                            dev.routeBundlePtr(route_bundle_index).server_state = .possible_bundling_failures;
+                        } else {
+                            dev.routeBundlePtr(route_bundle_index).server_state = .loaded;
+                        }
+                        continue;
+                    }
+
+                    dev.startAsyncBundle(
+                        entry_points,
+                        false,
+                        std.time.Timer.start() catch @panic("timers unsupported"),
+                    ) catch |err| {
+                        if (dev.log.hasAny()) {
+                            dev.log.print(Output.errorWriterBuffered()) catch {};
+                            Output.flush();
+                        }
+                        Output.panic("Fatal error while initializing bundle job: {}", .{err});
+                    };
+
+                    dev.routeBundlePtr(route_bundle_index).server_state = .bundling;
+                }
+                return;
+            },
+            .bundling => {
+                bun.assert(dev.current_bundle != null);
+                try dev.current_bundle_requests.ensureUnusedCapacity(dev.allocator, 1);
+
+                const deferred: DeferredRequest = .{
+                    .route_bundle_index = route_bundle_index,
+                    .data = switch (kind) {
+                        .js_payload => .{ .js_payload = resp },
+                        .server_handler => .{
+                            .server_handler = (dev.server.?.DebugHTTPServer.prepareJsRequestContext(req, resp, null) orelse return)
+                                .save(dev.vm.global, req, resp),
+                        },
+                    },
+                };
+
+                dev.current_bundle_requests.appendAssumeCapacity(deferred);
+                return;
+            },
+            .possible_bundling_failures => {
+                // TODO: perform a graph trace to find just the errors that are needed
+                if (dev.bundling_failures.count() > 0) {
+                    resp.corked(sendSerializedFailures, .{
+                        dev,
+                        resp,
+                        dev.bundling_failures.keys(),
+                        .bundler,
+                    });
+                    return;
+                } else {
+                    dev.routeBundlePtr(route_bundle_index).server_state = .loaded;
+                    break;
+                }
+            },
+            .evaluation_failure => {
+                resp.corked(sendSerializedFailures, .{
+                    dev,
+                    resp,
+                    (&(dev.routeBundlePtr(route_bundle_index).evaluate_failure orelse @panic("missing error")))[0..1],
+                    .evaluation,
+                });
+                return;
+            },
+            .loaded => break,
+        }
+
+        // this error is here to make sure there are no accidental loop exits
+        @compileError("all branches above should `return`, `break` or `continue`");
+    }
+
+    switch (kind) {
+        .server_handler => dev.onRequestWithBundle(route_bundle_index, .{ .stack = req }, resp),
+        .js_payload => dev.onJsRequestWithBundle(route_bundle_index, resp),
+    }
+}
+
+fn appendRouteEntryPointsIfNotStale(dev: *DevServer, entry_points: *EntryPointList, alloc: Allocator, route_index: Route.Index) bun.OOM!void {
+    const server_file_names = dev.server_graph.bundled_files.keys();
+    const client_file_names = dev.client_graph.bundled_files.keys();
+
+    // 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, alloc, .server, router_type.server_file);
+    try dev.appendOpaqueEntryPoint(client_file_names, entry_points, alloc, .client, router_type.client_file);
+    try dev.appendOpaqueEntryPoint(server_file_names, entry_points, alloc, .server, route.file_page);
+    try dev.appendOpaqueEntryPoint(server_file_names, entry_points, alloc, .server, route.file_layout);
+    while (route.parent.unwrap()) |parent_index| {
+        route = dev.router.routePtr(parent_index);
+        try dev.appendOpaqueEntryPoint(server_file_names, entry_points, alloc, .server, route.file_layout);
+    }
+}
+
+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
+
+    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(dev.relativePath(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_bundle.cached_client_bundle_url.get() orelse str: {
+                const id, const route_index: Route.Index.Optional = if (router_type.client_file != .none)
+                    .{ std.crypto.random.int(u64), route_bundle.route.toOptional() }
+                else
+                    // When there is no framework-provided client code, generate
+                    // a JS file so that the hot-reloading code can reload the
+                    // page on server-side changes and show errors in-browser.
+                    .{ 0, .none };
+                dev.route_js_payloads.put(dev.allocator, id, route_index) 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_bundle.cached_css_file_array.get() orelse arr: {
+                const js = dev.generateCssJSArray(route_bundle) catch bun.outOfMemory();
+                route_bundle.cached_css_file_array = JSC.Strong.create(js, dev.vm.global);
+                break :arr js;
+            },
+        },
+    );
+}
+
+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 {
+    if (req.header("open-in-editor") == null) {
+        resp.writeStatus("501 Not Implemented");
+        resp.end("Viewing source without opening in editor is not implemented yet!", false);
+        return;
+    }
+
+    const ctx = &dev.vm.rareData().editor_context;
+    ctx.autoDetectEditor(JSC.VirtualMachine.get().bundler.env);
+    const line: ?[]const u8 = req.header("editor-line");
+    const column: ?[]const u8 = req.header("editor-column");
+
+    if (ctx.editor) |editor| {
+        var url = req.url()[internal_prefix.len + "/src/".len ..];
+        if (bun.strings.indexOfChar(url, ':')) |colon| {
+            url = url[0..colon];
+        }
+        editor.open(ctx.path, url, line, column, dev.allocator) catch {
+            resp.writeStatus("202 No Content");
+            resp.end("", false);
+            return;
+        };
+        resp.writeStatus("202 No Content");
+        resp.end("", false);
+    } else {
+        resp.writeStatus("500 Internal Server Error");
+        resp.end("Please set your editor in bunfig.toml", false);
+    }
+}
+
+const DeferredRequest = struct {
+    route_bundle_index: RouteBundle.Index,
+    data: Data,
+
+    const Data = union(enum) {
+        server_handler: bun.JSC.API.SavedRequest,
+        js_payload: *Response,
+
+        const Tag = @typeInfo(Data).Union.tag_type.?;
+    };
+};
+
+fn startAsyncBundle(
+    dev: *DevServer,
+    entry_points: EntryPointList,
+    had_reload_event: bool,
+    timer: std.time.Timer,
+) bun.OOM!void {
+    assert(dev.current_bundle == null);
+    assert(entry_points.set.count() > 0);
+    dev.log.clearAndFree();
+
+    dev.incremental_result.reset();
+
+    var heap = try ThreadlocalArena.init();
+    errdefer heap.deinit();
+    const allocator = heap.allocator();
+    const ast_memory_allocator = try allocator.create(bun.JSAst.ASTMemoryAllocator);
+    ast_memory_allocator.* = .{ .allocator = allocator };
+    ast_memory_allocator.reset();
+    ast_memory_allocator.push();
+
+    if (dev.framework.server_components == null) {
+        // The handling of the dependency graphs are SLIGHTLY different when
+        // server components are disabled. It's subtle, but enough that it
+        // would be incorrect to even try to run a build.
+        bun.todoPanic(@src(), "support non-server components build", .{});
+    }
+
+    const bv2 = try BundleV2.init(
+        &dev.server_bundler,
+        if (dev.framework.server_components != null) .{
+            .framework = dev.framework,
+            .client_bundler = &dev.client_bundler,
+            .ssr_bundler = &dev.ssr_bundler,
+            .plugins = dev.bundler_options.plugin,
+        } else @panic("TODO: support non-server components"),
+        allocator,
+        .{ .js = dev.vm.eventLoop() },
+        false, // reloading is handled separately
+        JSC.WorkPool.get(),
+        heap,
+    );
+    bv2.bun_watcher = dev.bun_watcher;
+    bv2.asynchronous = true;
+
+    {
+        dev.graph_safety_lock.lock();
+        defer dev.graph_safety_lock.unlock();
+
+        dev.client_graph.reset();
+        dev.server_graph.reset();
+    }
+
+    const start_data = try bv2.startFromBakeDevServer(entry_points);
+
+    dev.current_bundle = .{
+        .bv2 = bv2,
+        .timer = timer,
+        .start_data = start_data,
+        .had_reload_event = had_reload_event,
+    };
+    const old_current_requests = dev.current_bundle_requests;
+    bun.assert(old_current_requests.items.len == 0);
+    dev.current_bundle_requests = dev.next_bundle.requests;
+    dev.next_bundle.requests = old_current_requests;
+}
+
+fn indexFailures(dev: *DevServer) !void {
+    var sfa_state = std.heap.stackFallback(65536, dev.allocator);
+    const sfa = sfa_state.get();
+
+    if (dev.incremental_result.failures_added.items.len > 0) {
+        var total_len: usize = @sizeOf(MessageId) + @sizeOf(u32);
+
+        for (dev.incremental_result.failures_added.items) |fail| {
+            total_len += fail.data.len;
+        }
+
+        total_len += dev.incremental_result.failures_removed.items.len * @sizeOf(u32);
+
+        var gts = try dev.initGraphTraceState(sfa);
+        defer gts.deinit(sfa);
+
+        var payload = try std.ArrayList(u8).initCapacity(sfa, total_len);
+        defer payload.deinit();
+        payload.appendAssumeCapacity(MessageId.errors.char());
+        const w = payload.writer();
+
+        try w.writeInt(u32, @intCast(dev.incremental_result.failures_removed.items.len), .little);
+
+        for (dev.incremental_result.failures_removed.items) |removed| {
+            try w.writeInt(u32, @bitCast(removed.getOwner().encode()), .little);
+            removed.deinit();
+        }
+
+        for (dev.incremental_result.failures_added.items) |added| {
+            try w.writeAll(added.data);
+
+            switch (added.getOwner()) {
+                .none, .route => unreachable,
+                .server => |index| try dev.server_graph.traceDependencies(index, &gts, .no_stop),
+                .client => |index| try dev.client_graph.traceDependencies(index, &gts, .no_stop),
+            }
+        }
+
+        for (dev.incremental_result.routes_affected.items) |entry| {
+            if (dev.router.routePtr(entry.route_index).bundle.unwrap()) |index| {
+                dev.routeBundlePtr(index).server_state = .possible_bundling_failures;
+            }
+            if (entry.should_recurse_when_visiting)
+                dev.markAllRouteChildrenFailed(entry.route_index);
+        }
+
+        dev.publish(.errors, payload.items, .binary);
+    } else if (dev.incremental_result.failures_removed.items.len > 0) {
+        var payload = try std.ArrayList(u8).initCapacity(sfa, @sizeOf(MessageId) + @sizeOf(u32) + dev.incremental_result.failures_removed.items.len * @sizeOf(u32));
+        defer payload.deinit();
+        payload.appendAssumeCapacity(MessageId.errors.char());
+        const w = payload.writer();
+
+        try w.writeInt(u32, @intCast(dev.incremental_result.failures_removed.items.len), .little);
+
+        for (dev.incremental_result.failures_removed.items) |removed| {
+            try w.writeInt(u32, @bitCast(removed.getOwner().encode()), .little);
+            removed.deinit();
+        }
+
+        dev.publish(.errors, payload.items, .binary);
+    }
+
+    dev.incremental_result.failures_removed.clearRetainingCapacity();
+}
+
+/// Used to generate the entry point. Unlike incremental patches, this always
+/// contains all needed files for a route.
+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();
+
+    // Prepare bitsets
+    var sfa_state = std.heap.stackFallback(65536, dev.allocator);
+    const sfa = sfa_state.get();
+    var gts = try dev.initGraphTraceState(sfa);
+    defer gts.deinit(sfa);
+
+    // Run tracing
+    dev.client_graph.reset();
+    try dev.traceAllRouteImports(route_bundle, &gts, .{ .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");
+
+    return dev.client_graph.takeBundle(
+        .initial_response,
+        dev.relativePath(dev.client_graph.bundled_files.keys()[fromOpaqueFileId(.client, client_file).get()]),
+    );
+}
+
+fn generateCssJSArray(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();
+
+    // Prepare bitsets
+    var sfa_state = std.heap.stackFallback(65536, dev.allocator);
+
+    const sfa = sfa_state.get();
+    var gts = try dev.initGraphTraceState(sfa);
+    defer gts.deinit(sfa);
+
+    // Run tracing
+    dev.client_graph.reset();
+    try dev.traceAllRouteImports(route_bundle, &gts, .{ .find_css = true });
+
+    const names = dev.client_graph.current_css_files.items;
+    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.vm.global, @intCast(i), str.toJS(dev.vm.global));
+    }
+    return arr;
+}
+
+fn traceAllRouteImports(dev: *DevServer, route_bundle: *RouteBundle, gts: *GraphTraceState, 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), gts, .{ .find_css = true });
+    if (router_type.client_file.unwrap()) |id| {
+        try dev.client_graph.traceImports(fromOpaqueFileId(.client, id), gts, goal);
+    }
+
+    // The route file is considered
+    if (route.file_page.unwrap()) |id| {
+        try dev.server_graph.traceImports(fromOpaqueFileId(.server, id), gts, goal);
+    }
+
+    // For all parents, the layout is considered
+    while (true) {
+        if (route.file_layout.unwrap()) |id| {
+            try dev.server_graph.traceImports(fromOpaqueFileId(.server, id), gts, 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(dev.relativePath(names[item.get()]));
+        defer str.deref();
+        arr.putIndex(global, @intCast(i), str.toJS(global));
+    }
+    return arr;
+}
+
+pub const HotUpdateContext = struct {
+    /// bundle_v2.Graph.input_files.items(.source)
+    sources: []bun.logger.Source,
+    /// bundle_v2.Graph.ast.items(.import_records)
+    import_records: []bun.ImportRecord.List,
+    /// bundle_v2.Graph.server_component_boundaries.slice()
+    scbs: bun.JSAst.ServerComponentBoundary.List.Slice,
+    /// Which files have a server-component boundary.
+    server_to_client_bitset: DynamicBitSetUnmanaged,
+    /// Used to reduce calls to the IncrementalGraph hash table.
+    ///
+    /// Caller initializes a slice with `sources.len * 2` items
+    /// all initialized to `std.math.maxInt(u32)`
+    ///
+    /// The first half of this slice is for the client graph,
+    /// second half is for server. Interact with this via
+    /// `getCachedIndex`
+    resolved_index_cache: []u32,
+    /// Used to tell if the server should replace or append import records.
+    server_seen_bit_set: DynamicBitSetUnmanaged,
+    gts: *GraphTraceState,
+
+    pub fn getCachedIndex(
+        rc: *const HotUpdateContext,
+        comptime side: bake.Side,
+        i: bun.JSAst.Index,
+    ) *IncrementalGraph(side).FileIndex {
+        const start = switch (side) {
+            .client => 0,
+            .server => rc.sources.len,
+        };
+
+        const subslice = rc.resolved_index_cache[start..][0..rc.sources.len];
+
+        comptime assert(@alignOf(IncrementalGraph(side).FileIndex.Optional) == @alignOf(u32));
+        comptime assert(@sizeOf(IncrementalGraph(side).FileIndex.Optional) == @sizeOf(u32));
+        return @ptrCast(&subslice[i.get()]);
+    }
+};
+
+/// Called at the end of BundleV2 to index bundle contents into the `IncrementalGraph`s
+/// This function does not recover DevServer state if it fails (allocation failure)
+pub fn finalizeBundle(
+    dev: *DevServer,
+    bv2: *bun.bundle_v2.BundleV2,
+    result: bun.bundle_v2.BakeBundleOutput,
+) bun.OOM!void {
+    defer dev.startNextBundleIfPresent();
+    const current_bundle = &dev.current_bundle.?;
+
+    dev.graph_safety_lock.lock();
+    defer dev.graph_safety_lock.unlock();
+
+    const js_chunk = result.jsPseudoChunk();
+    const input_file_sources = bv2.graph.input_files.items(.source);
+    const import_records = bv2.graph.ast.items(.import_records);
+    const targets = bv2.graph.ast.items(.target);
+    const scbs = bv2.graph.server_component_boundaries.slice();
+
+    var sfa = std.heap.stackFallback(65536, bv2.graph.allocator);
+    const stack_alloc = sfa.get();
+    var scb_bitset = try bun.bit_set.DynamicBitSetUnmanaged.initEmpty(stack_alloc, input_file_sources.len);
+    for (
+        scbs.list.items(.source_index),
+        scbs.list.items(.ssr_source_index),
+        scbs.list.items(.reference_source_index),
+    ) |source_index, ssr_index, ref_index| {
+        scb_bitset.set(source_index);
+        scb_bitset.set(ref_index);
+        if (ssr_index < scb_bitset.bit_length)
+            scb_bitset.set(ssr_index);
+    }
+
+    const resolved_index_cache = try bv2.graph.allocator.alloc(u32, input_file_sources.len * 2);
+
+    var ctx: bun.bake.DevServer.HotUpdateContext = .{
+        .import_records = import_records,
+        .sources = input_file_sources,
+        .scbs = scbs,
+        .server_to_client_bitset = scb_bitset,
+        .resolved_index_cache = resolved_index_cache,
+        .server_seen_bit_set = undefined,
+        .gts = undefined,
+    };
+
+    // Pass 1, update the graph's nodes, resolving every bundler source
+    // index into its `IncrementalGraph(...).FileIndex`
+    for (
+        js_chunk.content.javascript.parts_in_chunk_in_order,
+        js_chunk.compile_results_for_chunk,
+    ) |part_range, compile_result| {
+        const index = part_range.source_index;
+        switch (targets[part_range.source_index.get()].bakeGraph()) {
+            .server => try dev.server_graph.receiveChunk(&ctx, index, compile_result.code(), .js, false),
+            .ssr => try dev.server_graph.receiveChunk(&ctx, index, compile_result.code(), .js, true),
+            .client => try dev.client_graph.receiveChunk(&ctx, index, compile_result.code(), .js, false),
+        }
+    }
+
+    for (result.cssChunks(), result.css_file_list.values()) |*chunk, metadata| {
+        const index = bun.JSAst.Index.init(chunk.entry_point.source_index);
+
+        const code = try chunk.intermediate_output.code(
+            dev.allocator,
+            &bv2.graph,
+            &bv2.linker.graph,
+            "/_bun/TODO-import-prefix-where-is-this-used?",
+            chunk,
+            result.chunks,
+            null,
+            false, // TODO: sourcemaps true
+        );
+
+        // Create an entry for this file.
+        const key = ctx.sources[index.get()].path.keyForIncrementalGraph();
+        // Later code needs to retrieve the CSS content
+        // The hack is to use `entry_point_id`, which is otherwise unused, to store an index.
+        chunk.entry_point.entry_point_id = try dev.insertOrUpdateCssAsset(key, code.buffer);
+
+        try dev.client_graph.receiveChunk(&ctx, index, "", .css, false);
+
+        // If imported on server, there needs to be a server-side file entry
+        // so that edges can be attached. When a file is only imported on
+        // the server, this file is used to trace the CSS to the route.
+        if (metadata.imported_on_server) {
+            try dev.server_graph.insertCssFileOnServer(
+                &ctx,
+                index,
+                key,
+            );
+        }
+    }
+
+    var gts = try dev.initGraphTraceState(bv2.graph.allocator);
+    defer gts.deinit(bv2.graph.allocator);
+    ctx.gts = &gts;
+    ctx.server_seen_bit_set = try bun.bit_set.DynamicBitSetUnmanaged.initEmpty(bv2.graph.allocator, dev.server_graph.bundled_files.count());
+
+    dev.incremental_result.had_adjusted_edges = false;
+
+    // Pass 2, update the graph's edges by performing import diffing on each
+    // changed file, removing dependencies. This pass also flags what routes
+    // have been modified.
+    for (js_chunk.content.javascript.parts_in_chunk_in_order) |part_range| {
+        switch (targets[part_range.source_index.get()].bakeGraph()) {
+            .server, .ssr => try dev.server_graph.processChunkDependencies(&ctx, part_range.source_index, bv2.graph.allocator),
+            .client => try dev.client_graph.processChunkDependencies(&ctx, part_range.source_index, bv2.graph.allocator),
+        }
+    }
+    for (result.cssChunks(), result.css_file_list.values()) |*chunk, metadata| {
+        const index = bun.JSAst.Index.init(chunk.entry_point.source_index);
+        // TODO: index css deps
+        _ = index;
+        _ = metadata;
+    }
+
+    // Index all failed files now that the incremental graph has been updated.
+    try dev.indexFailures();
+
+    try dev.client_graph.ensureStaleBitCapacity(false);
+    try dev.server_graph.ensureStaleBitCapacity(false);
+
+    dev.generation +%= 1;
+    if (Environment.enable_logs) {
+        debug.log("Bundle Round {d}: {d} server, {d} client, {d} ms", .{
+            dev.generation,
+            dev.server_graph.current_chunk_parts.items.len,
+            dev.client_graph.current_chunk_parts.items.len,
+            @divFloor(current_bundle.timer.read(), std.time.ns_per_ms),
+        });
+    }
+
+    // Load all new chunks into the server runtime.
+    if (dev.server_graph.current_chunk_len > 0) {
+        const server_bundle = try dev.server_graph.takeBundle(.hmr_chunk, "");
+        defer dev.allocator.free(server_bundle);
+
+        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:
+    }
+
+    var route_bits = try DynamicBitSetUnmanaged.initEmpty(stack_alloc, dev.route_bundles.items.len);
+    defer route_bits.deinit(stack_alloc);
+    var route_bits_client = try DynamicBitSetUnmanaged.initEmpty(stack_alloc, dev.route_bundles.items.len);
+    defer route_bits_client.deinit(stack_alloc);
+
+    var has_route_bits_set = false;
+
+    var hot_update_payload_sfa = std.heap.stackFallback(65536, bun.default_allocator);
+    var hot_update_payload = std.ArrayList(u8).initCapacity(hot_update_payload_sfa.get(), 65536) catch
+        unreachable; // enough space
+    defer hot_update_payload.deinit();
+    hot_update_payload.appendAssumeCapacity(MessageId.hot_update.char());
+
+    // The writer used for the hot_update payload
+    const w = hot_update_payload.writer();
+
+    // It was discovered that if a tree falls with nobody around it, it does not
+    // make any sound. Let's avoid writing into `w` if no sockets are open.
+    const will_hear_hot_update = dev.numSubscribers(.hot_update) > 0;
+
+    // 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 (will_hear_hot_update and
+        current_bundle.had_reload_event and
+        dev.incremental_result.routes_affected.items.len > 0 and
+        dev.bundling_failures.count() == 0)
+    {
+        has_route_bits_set = true;
+
+        // A bit-set is used to avoid duplicate entries. This is not a problem
+        // with `dev.incremental_result.routes_affected`
+        for (dev.incremental_result.routes_affected.items) |request| {
+            const route = dev.router.routePtr(request.route_index);
+            if (route.bundle.unwrap()) |id| route_bits.set(id.get());
+            if (request.should_recurse_when_visiting) {
+                markAllRouteChildren(&dev.router, 1, .{&route_bits}, request.route_index);
+            }
+        }
+
+        // List 1
+        var it = route_bits.iterator(.{ .kind = .set });
+        while (it.next()) |bundled_route_index| {
+            const bundle = &dev.route_bundles.items[bundled_route_index];
+            if (bundle.active_viewers == 0) continue;
+            try w.writeInt(i32, @intCast(bundled_route_index), .little);
+        }
+    }
+    try w.writeInt(i32, -1, .little);
+
+    // When client component roots get updated, the `client_components_affected`
+    // list contains the server side versions of these roots. These roots are
+    // traced to the routes so that the client-side bundles can be properly
+    // invalidated.
+    if (dev.incremental_result.client_components_affected.items.len > 0) {
+        has_route_bits_set = true;
+
+        dev.incremental_result.routes_affected.clearRetainingCapacity();
+        gts.clear();
+
+        for (dev.incremental_result.client_components_affected.items) |index| {
+            try dev.server_graph.traceDependencies(index, &gts, .no_stop);
+        }
+
+        // A bit-set is used to avoid duplicate entries. This is not a problem
+        // with `dev.incremental_result.routes_affected`
+        for (dev.incremental_result.routes_affected.items) |request| {
+            const route = dev.router.routePtr(request.route_index);
+            if (route.bundle.unwrap()) |id| {
+                route_bits.set(id.get());
+                route_bits_client.set(id.get());
+            }
+            if (request.should_recurse_when_visiting) {
+                markAllRouteChildren(&dev.router, 2, .{ &route_bits, &route_bits_client }, request.route_index);
+            }
+        }
+
+        // Free old bundles
+        var it = route_bits_client.iterator(.{ .kind = .set });
+        while (it.next()) |bundled_route_index| {
+            const bundle = &dev.route_bundles.items[bundled_route_index];
+            if (bundle.client_bundle) |old| {
+                dev.allocator.free(old);
+            }
+            bundle.client_bundle = null;
+        }
+    }
+
+    // `route_bits` will have all of the routes that were modified. If any of
+    // these have active viewers, DevServer should inform them of CSS attachments. These
+    // route bundles also need to be invalidated of their css attachments.
+    if (has_route_bits_set and
+        (will_hear_hot_update or dev.incremental_result.had_adjusted_edges))
+    {
+        var it = route_bits.iterator(.{ .kind = .set });
+        // List 2
+        while (it.next()) |i| {
+            const bundle = dev.routeBundlePtr(RouteBundle.Index.init(@intCast(i)));
+            if (dev.incremental_result.had_adjusted_edges) {
+                bundle.cached_css_file_array.clear();
+            }
+            if (bundle.active_viewers == 0 or !will_hear_hot_update) continue;
+            try w.writeInt(i32, @intCast(i), .little);
+            try w.writeInt(u32, @intCast(bundle.full_pattern.len), .little);
+            try w.writeAll(bundle.full_pattern);
+
+            // If no edges were changed, then it is impossible to
+            // change the list of CSS files.
+            if (dev.incremental_result.had_adjusted_edges) {
+                gts.clear();
+                try dev.traceAllRouteImports(bundle, &gts, .{ .find_css = true });
+                const names = dev.client_graph.current_css_files.items;
+
+                try w.writeInt(i32, @intCast(names.len), .little);
+                for (names) |name| {
+                    const css_prefix_slash = css_prefix ++ "/";
+                    // These slices are url pathnames. The ID can be extracted
+                    bun.assert(name.len == (css_prefix_slash ++ ".css").len + 16);
+                    bun.assert(bun.strings.hasPrefix(name, css_prefix_slash));
+                    try w.writeAll(name[css_prefix_slash.len..][0..16]);
+                }
+            } else {
+                try w.writeInt(i32, -1, .little);
+            }
+        }
+    }
+    try w.writeInt(i32, -1, .little);
+
+    // Send CSS mutations
+    const css_chunks = result.cssChunks();
+    if (will_hear_hot_update) {
+        if (dev.client_graph.current_chunk_len > 0 or css_chunks.len > 0) {
+            const css_values = dev.css_files.values();
+            try w.writeInt(u32, @intCast(css_chunks.len), .little);
+            const sources = bv2.graph.input_files.items(.source);
+            for (css_chunks) |chunk| {
+                const key = sources[chunk.entry_point.source_index].path.keyForIncrementalGraph();
+                try w.writeAll(&std.fmt.bytesToHex(std.mem.asBytes(&bun.hash(key)), .lower));
+                const css_data = css_values[chunk.entry_point.entry_point_id];
+                try w.writeInt(u32, @intCast(css_data.len), .little);
+                try w.writeAll(css_data);
+            }
+
+            if (dev.client_graph.current_chunk_len > 0)
+                try dev.client_graph.takeBundleToList(.hmr_chunk, &hot_update_payload, "");
+        } else {
+            try w.writeInt(i32, 0, .little);
+        }
+
+        dev.publish(.hot_update, hot_update_payload.items, .binary);
+    }
+
+    if (dev.incremental_result.failures_added.items.len > 0) {
+        dev.bundles_since_last_error = 0;
+
+        for (dev.current_bundle_requests.items) |*req| {
+            const rb = dev.routeBundlePtr(req.route_bundle_index);
+            rb.server_state = .possible_bundling_failures;
+
+            const resp: *Response = switch (req.data) {
+                .server_handler => |*saved| brk: {
+                    const resp = saved.response.TCP;
+                    saved.deinit();
+                    break :brk resp;
+                },
+                .js_payload => |resp| resp,
+            };
+
+            resp.corked(sendSerializedFailures, .{
+                dev,
+                resp,
+                dev.bundling_failures.keys(),
+                .bundler,
+            });
+        }
+        return;
+    }
+
+    // TODO: improve this visual feedback
+    if (dev.bundling_failures.count() == 0) {
+        if (current_bundle.had_reload_event) {
+            const clear_terminal = !debug.isVisible();
+            if (clear_terminal) {
+                Output.disableBuffering();
+                Output.resetTerminalAll();
+                Output.enableBuffering();
+            }
+
+            dev.bundles_since_last_error += 1;
+            if (dev.bundles_since_last_error > 1) {
+                Output.prettyError("<cyan>[x{d}]<r> ", .{dev.bundles_since_last_error});
+            }
+        } else {
+            dev.bundles_since_last_error = 0;
+        }
+
+        Output.prettyError("<green>{s} in {d}ms<r>", .{
+            if (current_bundle.had_reload_event) "Reloaded" else "Bundled route",
+            @divFloor(current_bundle.timer.read(), std.time.ns_per_ms),
+        });
+
+        // Compute a file name to display
+        const file_name: ?[]const u8, const total_count: usize = if (current_bundle.had_reload_event)
+            .{ null, 0 }
+        else first_route_file_name: {
+            const opaque_id = dev.router.routePtr(
+                dev.routeBundlePtr(dev.current_bundle_requests.items[0].route_bundle_index)
+                    .route,
+            ).file_page.unwrap() orelse
+                break :first_route_file_name .{ null, 0 };
+            const server_index = fromOpaqueFileId(.server, opaque_id);
+
+            break :first_route_file_name .{
+                dev.relativePath(dev.server_graph.bundled_files.keys()[server_index.get()]),
+                0,
+            };
+        };
+        if (file_name) |name| {
+            Output.prettyError("<d>:<r> {s}", .{name});
+            if (total_count > 1) {
+                Output.prettyError(" <d>+ {d} more<r>", .{total_count - 1});
+            }
+        }
+        Output.prettyError("\n", .{});
+        Output.flush();
+    }
+
+    // Release the lock because the underlying handler may acquire one.
+    dev.graph_safety_lock.unlock();
+    defer dev.graph_safety_lock.lock();
+
+    for (dev.current_bundle_requests.items) |req| {
+        const rb = dev.routeBundlePtr(req.route_bundle_index);
+        rb.server_state = .loaded;
+
+        switch (req.data) {
+            .server_handler => |saved| dev.onRequestWithBundle(req.route_bundle_index, .{ .saved = saved }, saved.response.TCP),
+            .js_payload => |resp| dev.onJsRequestWithBundle(req.route_bundle_index, resp),
+        }
+    }
+}
+
+fn startNextBundleIfPresent(dev: *DevServer) void {
+    // Clear the current bundle
+    dev.current_bundle = null;
+    dev.log.clearAndFree();
+    dev.current_bundle_requests.clearRetainingCapacity();
+    dev.emitVisualizerMessageIfNeeded() catch {};
+
+    // If there were pending requests, begin another bundle.
+    if (dev.next_bundle.reload_event != null or dev.next_bundle.requests.items.len > 0) {
+        var sfb = std.heap.stackFallback(4096, bun.default_allocator);
+        const temp_alloc = sfb.get();
+        var entry_points: EntryPointList = EntryPointList.empty;
+        defer entry_points.deinit(temp_alloc);
+
+        if (dev.next_bundle.reload_event) |event| {
+            event.processFileList(dev, &entry_points, temp_alloc);
+
+            if (dev.watcher_atomics.recycleEventFromDevServer(event)) |second| {
+                second.processFileList(dev, &entry_points, temp_alloc);
+                dev.watcher_atomics.recycleSecondEventFromDevServer(second);
+            }
+        }
+
+        for (dev.next_bundle.route_queue.keys()) |route_bundle_index| {
+            const rb = dev.routeBundlePtr(route_bundle_index);
+            rb.server_state = .bundling;
+            dev.appendRouteEntryPointsIfNotStale(&entry_points, temp_alloc, rb.route) catch bun.outOfMemory();
+        }
+
+        dev.startAsyncBundle(
+            entry_points,
+            dev.next_bundle.reload_event != null,
+            std.time.Timer.start() catch @panic("timers unsupported"),
+        ) catch bun.outOfMemory();
+
+        dev.next_bundle.route_queue.clearRetainingCapacity();
+        dev.next_bundle.reload_event = null;
+    }
+}
+
+fn insertOrUpdateCssAsset(dev: *DevServer, abs_path: []const u8, code: []const u8) !u31 {
+    const path_hash = bun.hash(abs_path);
+    const gop = try dev.css_files.getOrPut(dev.allocator, path_hash);
+    if (gop.found_existing) {
+        dev.allocator.free(gop.value_ptr.*);
+    }
+    gop.value_ptr.* = code;
+    return @intCast(gop.index);
+}
+
+/// Note: The log is not consumed here
+pub fn handleParseTaskFailure(
+    dev: *DevServer,
+    err: anyerror,
+    graph: bake.Graph,
+    key: []const u8,
+    log: *const Log,
+) bun.OOM!void {
+    dev.graph_safety_lock.lock();
+    defer dev.graph_safety_lock.unlock();
+
+    if (err == error.FileNotFound) {
+        // Special-case files being deleted. Note that if a
+        // file never existed, resolution would fail first.
+        //
+        // TODO: this should walk up the graph one level, and queue all of these
+        // files for re-bundling if they aren't already in the BundleV2 graph.
+        switch (graph) {
+            .server, .ssr => try dev.server_graph.onFileDeleted(key, log),
+            .client => try dev.client_graph.onFileDeleted(key, log),
+        }
+    } else {
+        Output.prettyErrorln("<red><b>Error{s} while bundling \"{s}\":<r>", .{
+            if (log.errors +| log.warnings != 1) "s" else "",
+            dev.relativePath(key),
+        });
+        log.print(Output.errorWriterBuffered()) catch {};
+        Output.flush();
+
+        // Do not index css errors
+        if (!bun.strings.hasSuffixComptime(key, ".css")) {
+            switch (graph) {
+                .server => try dev.server_graph.insertFailure(key, log, false),
+                .ssr => try dev.server_graph.insertFailure(key, log, true),
+                .client => try dev.client_graph.insertFailure(key, log, false),
+            }
+        }
+    }
+}
+
+const CacheEntry = struct {
+    kind: FileKind,
+};
+
+pub fn isFileCached(dev: *DevServer, path: []const u8, side: bake.Graph) ?CacheEntry {
+    dev.graph_safety_lock.lock();
+    defer dev.graph_safety_lock.unlock();
+
+    switch (side) {
+        inline else => |side_comptime| {
+            const g = switch (side_comptime) {
+                .client => &dev.client_graph,
+                .server => &dev.server_graph,
+                .ssr => &dev.server_graph,
+            };
+            const index = g.bundled_files.getIndex(path) orelse
+                return null; // non-existent files are considered stale
+            if (!g.stale_files.isSet(index)) {
+                return .{ .kind = g.bundled_files.values()[index].fileKind() };
+            }
+            return null;
+        },
+    }
+}
+
+fn appendOpaqueEntryPoint(
+    dev: *DevServer,
+    file_names: [][]const u8,
+    entry_points: *EntryPointList,
+    alloc: Allocator,
+    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.appendJs(alloc, file_names[file_index.get()], side.graph());
+    }
+}
+
+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;
+    }
+
+    switch (dev.server.?) {
+        inline .DebugHTTPServer, .HTTPServer => |s| if (s.config.onRequest != .zero) {
+            s.onRequest(req, resp);
+            return;
+        },
+        else => @panic("TODO: HTTPS"),
+    }
+
+    sendBuiltInNotFound(resp);
+}
+
+fn getOrPutRouteBundle(dev: *DevServer, route: Route.Index) !RouteBundle.Index {
+    if (dev.router.routePtr(route).bundle.unwrap()) |bundle_index|
+        return bundle_index;
+
+    const full_pattern = full_pattern: {
+        var buf = bake.PatternBuffer.empty;
+        var current: *Route = dev.router.routePtr(route);
+        // This loop is done to avoid prepending `/` at the root
+        // if there is more than one component.
+        buf.prependPart(current.part);
+        if (current.parent.unwrap()) |first| {
+            current = dev.router.routePtr(first);
+            while (current.parent.unwrap()) |next| {
+                buf.prependPart(current.part);
+                current = dev.router.routePtr(next);
+            }
+        }
+        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 = .{},
+        .active_viewers = 0,
+    });
+    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");
+        resp.writeHeaderInt("Content-Length", 0);
+        resp.end("", true);
+        return;
+    }
+
+    resp.writeStatus("200 OK");
+    resp.writeHeader("Content-Type", content_type);
+    resp.end(code, true); // TODO: You should never call res.end(huge buffer)
+}
+
+const ErrorPageKind = enum {
+    /// Modules failed to bundle
+    bundler,
+    /// Modules failed to evaluate
+    evaluation,
+    /// Request handler threw
+    runtime,
+};
+
+fn sendSerializedFailures(
+    dev: *DevServer,
+    resp: *Response,
+    failures: []const SerializedFailure,
+    kind: ErrorPageKind,
+) void {
+    resp.writeStatus("500 Internal Server Error");
+    resp.writeHeader("Content-Type", MimeType.html.value);
+
+    // TODO: what to do about return values here?
+    _ = resp.write(switch (kind) {
+        inline else => |k| std.fmt.comptimePrint(
+            \\<!doctype html>
+            \\<html lang="en">
+            \\<head>
+            \\<meta charset="UTF-8" />
+            \\<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+            \\<title>Bun - {[page_title]s}</title>
+            \\<style>:root{{color-scheme:light dark}}body{{background:light-dark(white,black)}}</style>
+            \\</head>
+            \\<body>
+            \\<noscript><p style="font:24px sans-serif;">Bun requires JavaScript enabled in the browser to receive hot reloading events.</p></noscript>
+            \\<script>let error=Uint8Array.from(atob("
+        ,
+            .{ .page_title = switch (k) {
+                .bundler => "Bundling Error",
+                .evaluation, .runtime => "Runtime Error",
+            } },
+        ),
+    });
+
+    var sfb = std.heap.stackFallback(65536, dev.allocator);
+    var arena_state = std.heap.ArenaAllocator.init(sfb.get());
+    defer arena_state.deinit();
+
+    for (failures) |fail| {
+        // TODO: make this entirely use stack memory.
+        const len = bun.base64.encodeLen(fail.data);
+        const buf = arena_state.allocator().alloc(u8, len) catch bun.outOfMemory();
+        const encoded = buf[0..bun.base64.encode(buf, fail.data)];
+        _ = resp.write(encoded);
+
+        _ = arena_state.reset(.retain_capacity);
+    }
+
+    const pre = "\"),c=>c.charCodeAt(0));";
+    const post = "</script></body></html>";
+
+    if (Environment.codegen_embed) {
+        _ = resp.end(pre ++ @embedFile("bake-codegen/bake.error.js") ++ post, false);
+    } else {
+        _ = resp.write(pre);
+        _ = resp.write(bun.runtimeEmbedFile(.codegen_eager, "bake.error.js"));
+        _ = resp.end(post, false);
+    }
+}
+
+fn sendBuiltInNotFound(resp: *Response) void {
+    const message = "404 Not Found";
+    resp.writeStatus("404 Not Found");
+    resp.end(message, true);
+}
+
+const FileKind = enum(u2) {
+    /// Files that failed to bundle or do not exist on disk will appear in the
+    /// graph as "unknown".
+    unknown,
+    js,
+    css,
+    asset,
+};
+
+/// The paradigm of Bake's incremental state is to store a separate list of files
+/// than the Graph in bundle_v2. When watch events happen, the bundler is run on
+/// the changed files, excluding non-stale files via `isFileStale`.
+///
+/// Upon bundle completion, both `client_graph` and `server_graph` have their
+/// `receiveChunk` methods called with all new chunks, counting the total length
+/// needed. A call to `takeBundle` joins all of the chunks, resulting in the
+/// code to send to client or evaluate on the server.
+///
+/// Then, `processChunkDependencies` is called on each chunk to update the
+/// list of imports. When a change in imports is detected, the dependencies
+/// are updated accordingly.
+///
+/// Since all routes share the two graphs, bundling a new route that shared
+/// a module from a previously bundled route will perform the same exclusion
+/// behavior that rebuilds use. This also ensures that two routes on the server
+/// do not emit duplicate dependencies. By tracing `imports` on each file in
+/// the module graph recursively, the full bundle for any given route can
+/// be re-materialized (required when pressing Cmd+R after any client update)
+pub fn IncrementalGraph(side: bake.Side) type {
+    return struct {
+        // Unless otherwise mentioned, all data structures use DevServer's allocator.
+
+        /// Keys are absolute paths for the "file" namespace, or the
+        /// pretty-formatted path value that appear in imports. Absolute paths
+        /// are stored so the watcher can quickly query and invalidate them.
+        /// Key slices are owned by `default_allocator`
+        bundled_files: bun.StringArrayHashMapUnmanaged(File),
+        /// Track bools for files which are "stale", meaning they should be
+        /// re-bundled before being used. Resizing this is usually deferred
+        /// until after a bundle, since resizing the bit-set requires an
+        /// exact size, instead of the log approach that dynamic arrays use.
+        stale_files: DynamicBitSetUnmanaged,
+
+        /// Start of the 'dependencies' linked list. These are the other files
+        /// that import used by this file. Walk this list to discover what
+        /// files are to be reloaded when something changes.
+        first_dep: ArrayListUnmanaged(EdgeIndex.Optional),
+        /// Start of the 'imports' linked list. These are the files that this
+        /// file imports.
+        first_import: ArrayListUnmanaged(EdgeIndex.Optional),
+        /// `File` objects act as nodes in a directional many-to-many graph,
+        /// where edges represent the imports between modules. An 'dependency'
+        /// is a file that must to be notified when it `imported` changes. This
+        /// is implemented using an array of `Edge` objects that act as linked
+        /// list nodes; each file stores the first imports and dependency.
+        edges: ArrayListUnmanaged(Edge),
+        /// HMR Dependencies are added and removed very frequently, but indexes
+        /// must remain stable. This free list allows re-use of freed indexes,
+        /// so garbage collection can run less often.
+        edges_free_list: ArrayListUnmanaged(EdgeIndex),
+
+        /// Byte length of every file queued for concatenation
+        current_chunk_len: usize = 0,
+        /// All part contents
+        current_chunk_parts: ArrayListUnmanaged(switch (side) {
+            .client => FileIndex,
+            // These slices do not outlive the bundler, and must
+            // be joined before its arena is deinitialized.
+            .server => []const u8,
+        }),
+
+        current_css_files: switch (side) {
+            .client => ArrayListUnmanaged([]const u8),
+            .server => void,
+        },
+
+        const empty: @This() = .{
+            .bundled_files = .{},
+            .stale_files = .{},
+
+            .first_dep = .{},
+            .first_import = .{},
+            .edges = .{},
+            .edges_free_list = .{},
+
+            .current_chunk_len = 0,
+            .current_chunk_parts = .{},
+
+            .current_css_files = switch (side) {
+                .client => .{},
+                .server => {},
+            },
+        };
+
+        pub const File = switch (side) {
+            // The server's incremental graph does not store previously bundled
+            // code because there is only one instance of the server. Instead,
+            // it stores which module graphs it is a part of. This makes sure
+            // that recompilation knows what bundler options to use.
+            .server => struct { // TODO: make this packed(u8), i had compiler crashes before
+                /// Is this file built for the Server graph.
+                is_rsc: bool,
+                /// Is this file built for the SSR graph.
+                is_ssr: bool,
+                /// If set, the client graph contains a matching file.
+                /// The server
+                is_client_component_boundary: bool,
+                /// If this file is a route root, the route can be looked up in
+                /// the route list. This also stops dependency propagation.
+                is_route: bool,
+                /// If the file has an error, the failure can be looked up
+                /// in the `.failures` map.
+                failed: bool,
+                /// CSS and Asset files get special handling
+                kind: FileKind,
+
+                fn stopsDependencyTrace(file: @This()) bool {
+                    return file.is_client_component_boundary;
+                }
+
+                fn fileKind(file: @This()) FileKind {
+                    return file.kind;
+                }
+            },
+            .client => struct {
+                /// Allocated by default_allocator. Access with `.code()`
+                code_ptr: [*]const u8,
+                /// Separated from the pointer to reduce struct size.
+                /// Parser does not support files >4gb anyways.
+                code_len: u32,
+                flags: Flags,
+
+                const Flags = struct {
+                    /// If the file has an error, the failure can be looked up
+                    /// in the `.failures` map.
+                    failed: bool,
+                    /// For JS files, this is a component root; the server contains a matching file.
+                    /// For CSS files, this is also marked on the stylesheet that is imported from JS.
+                    is_hmr_root: bool,
+                    /// This is a file is an entry point to the framework.
+                    /// Changing this will always cause a full page reload.
+                    is_special_framework_file: bool,
+                    /// CSS and Asset files get special handling
+                    kind: FileKind,
+                };
+
+                comptime {
+                    assert(@sizeOf(@This()) == @sizeOf(usize) * 2);
+                    assert(@alignOf(@This()) == @alignOf([*]u8));
+                }
+
+                fn init(code_slice: []const u8, flags: Flags) @This() {
+                    return .{
+                        .code_ptr = code_slice.ptr,
+                        .code_len = @intCast(code_slice.len),
+                        .flags = flags,
+                    };
+                }
+
+                fn code(file: @This()) []const u8 {
+                    return file.code_ptr[0..file.code_len];
+                }
+
+                inline fn stopsDependencyTrace(_: @This()) bool {
+                    return false;
+                }
+
+                fn fileKind(file: @This()) FileKind {
+                    return file.flags.kind;
+                }
+            },
+        };
+
+        // If this data structure is not clear, see `DirectoryWatchStore.Dep`
+        // for a simpler example. It is more complicated here because this
+        // structure is two-way.
+        pub const Edge = struct {
+            /// The file with the `import` statement
+            dependency: FileIndex,
+            /// The file that `dependency` is importing
+            imported: FileIndex,
+
+            next_import: EdgeIndex.Optional,
+            next_dependency: EdgeIndex.Optional,
+            prev_dependency: EdgeIndex.Optional,
+        };
+
+        /// An index into `bundled_files`, `stale_files`, `first_dep`, `first_import`
+        /// Top bits cannot be relied on due to `SerializedFailure.Owner.Packed`
+        pub const FileIndex = bun.GenericIndex(u30, File);
+        pub const react_refresh_index = if (side == .client) FileIndex.init(0);
+
+        /// An index into `edges`
+        const EdgeIndex = bun.GenericIndex(u32, Edge);
+
+        fn getFileIndex(g: *@This(), path: []const u8) ?FileIndex {
+            return if (g.bundled_files.getIndex(path)) |i| FileIndex.init(@intCast(i)) else null;
+        }
+
+        /// Tracks a bundled code chunk for cross-bundle chunks,
+        /// ensuring it has an entry in `bundled_files`.
+        ///
+        /// For client, takes ownership of the code slice (must be default allocated)
+        ///
+        /// For server, the code is temporarily kept in the
+        /// `current_chunk_parts` array, where it must live until
+        /// takeBundle is called. Then it can be freed.
+        pub fn receiveChunk(
+            g: *@This(),
+            ctx: *HotUpdateContext,
+            index: bun.JSAst.Index,
+            code: []const u8,
+            kind: FileKind,
+            is_ssr_graph: bool,
+        ) !void {
+            const dev = g.owner();
+            dev.graph_safety_lock.assertLocked();
+
+            const path = ctx.sources[index.get()].path;
+            const key = path.keyForIncrementalGraph();
+
+            if (Environment.allow_assert) {
+                switch (kind) {
+                    .css => bun.assert(code.len == 0),
+                    .js => if (bun.strings.isAllWhitespace(code)) {
+                        // Should at least contain the function wrapper
+                        bun.Output.panic("Empty chunk is impossible: {s} {s}", .{
+                            key,
+                            switch (side) {
+                                .client => "client",
+                                .server => if (is_ssr_graph) "ssr" else "server",
+                            },
+                        });
+                    },
+                    else => Output.panic("unexpected file kind: .{s}", .{@tagName(kind)}),
+                }
+            }
+
+            g.current_chunk_len += code.len;
+
+            // Dump to filesystem if enabled
+            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, key);
+                const size = std.mem.replacementSize(u8, rel_path, "../", "_.._/");
+                _ = std.mem.replace(u8, rel_path, "../", "_.._/", &b);
+                const rel_path_escaped = b[0..size];
+                dumpBundle(dump_dir, switch (side) {
+                    .client => .client,
+                    .server => if (is_ssr_graph) .ssr else .server,
+                }, rel_path_escaped, code, true) catch |err| {
+                    bun.handleErrorReturnTrace(err, @errorReturnTrace());
+                    Output.warn("Could not dump bundle: {}", .{err});
+                };
+            };
+
+            const gop = try g.bundled_files.getOrPut(dev.allocator, key);
+            const file_index = FileIndex.init(@intCast(gop.index));
+
+            if (!gop.found_existing) {
+                gop.key_ptr.* = try bun.default_allocator.dupe(u8, key);
+                try g.first_dep.append(dev.allocator, .none);
+                try g.first_import.append(dev.allocator, .none);
+            }
+
+            if (g.stale_files.bit_length > gop.index) {
+                g.stale_files.unset(gop.index);
+            }
+
+            ctx.getCachedIndex(side, index).* = FileIndex.init(@intCast(gop.index));
+
+            switch (side) {
+                .client => {
+                    if (gop.found_existing) {
+                        if (kind == .js)
+                            bun.default_allocator.free(gop.value_ptr.code());
+
+                        if (gop.value_ptr.flags.failed) {
+                            const kv = dev.bundling_failures.fetchSwapRemoveAdapted(
+                                SerializedFailure.Owner{ .client = file_index },
+                                SerializedFailure.ArrayHashAdapter{},
+                            ) orelse
+                                Output.panic("Missing SerializedFailure in IncrementalGraph", .{});
+                            try dev.incremental_result.failures_removed.append(
+                                dev.allocator,
+                                kv.key,
+                            );
+                        }
+                    }
+                    const flags: File.Flags = .{
+                        .failed = false,
+                        .is_hmr_root = ctx.server_to_client_bitset.isSet(index.get()),
+                        .is_special_framework_file = false,
+                        .kind = kind,
+                    };
+                    if (kind == .css) {
+                        if (!gop.found_existing or gop.value_ptr.code_len == 0) {
+                            gop.value_ptr.* = File.init(try std.fmt.allocPrint(
+                                dev.allocator,
+                                css_prefix ++ "/{}.css",
+                                .{std.fmt.fmtSliceHexLower(std.mem.asBytes(&bun.hash(key)))},
+                            ), flags);
+                        } else {
+                            // The key is just the file-path
+                            gop.value_ptr.flags = flags;
+                        }
+                    } else {
+                        gop.value_ptr.* = File.init(code, flags);
+                    }
+                    try g.current_chunk_parts.append(dev.allocator, file_index);
+                },
+                .server => {
+                    if (!gop.found_existing) {
+                        const client_component_boundary = ctx.server_to_client_bitset.isSet(index.get());
+
+                        gop.value_ptr.* = .{
+                            .is_rsc = !is_ssr_graph,
+                            .is_ssr = is_ssr_graph,
+                            .is_route = false,
+                            .is_client_component_boundary = client_component_boundary,
+                            .failed = false,
+                            .kind = kind,
+                        };
+
+                        if (client_component_boundary) {
+                            try dev.incremental_result.client_components_added.append(dev.allocator, file_index);
+                        }
+                    } else {
+                        gop.value_ptr.kind = kind;
+
+                        if (is_ssr_graph) {
+                            gop.value_ptr.is_ssr = true;
+                        } else {
+                            gop.value_ptr.is_rsc = true;
+                        }
+
+                        if (ctx.server_to_client_bitset.isSet(index.get())) {
+                            gop.value_ptr.is_client_component_boundary = true;
+                            try dev.incremental_result.client_components_added.append(dev.allocator, file_index);
+                        } else if (gop.value_ptr.is_client_component_boundary) {
+                            const client_graph = &g.owner().client_graph;
+                            const client_index = client_graph.getFileIndex(gop.key_ptr.*) orelse
+                                Output.panic("Client graph's SCB was already deleted", .{});
+                            client_graph.disconnectAndDeleteFile(client_index);
+                            gop.value_ptr.is_client_component_boundary = false;
+
+                            try dev.incremental_result.client_components_removed.append(dev.allocator, file_index);
+                        }
+
+                        if (gop.value_ptr.failed) {
+                            gop.value_ptr.failed = false;
+                            const kv = dev.bundling_failures.fetchSwapRemoveAdapted(
+                                SerializedFailure.Owner{ .server = file_index },
+                                SerializedFailure.ArrayHashAdapter{},
+                            ) orelse
+                                Output.panic("Missing failure in IncrementalGraph", .{});
+                            try dev.incremental_result.failures_removed.append(
+                                dev.allocator,
+                                kv.key,
+                            );
+                        }
+                    }
+                    try g.current_chunk_parts.append(dev.allocator, code);
+                },
+            }
+        }
+
+        const TempLookup = extern struct {
+            edge_index: EdgeIndex,
+            seen: bool,
+
+            const HashTable = AutoArrayHashMapUnmanaged(FileIndex, TempLookup);
+        };
+
+        /// Second pass of IncrementalGraph indexing
+        /// - Updates dependency information for each file
+        /// - Resolves what the HMR roots are
+        pub fn processChunkDependencies(
+            g: *@This(),
+            ctx: *HotUpdateContext,
+            bundle_graph_index: bun.JSAst.Index,
+            temp_alloc: Allocator,
+        ) bun.OOM!void {
+            const log = bun.Output.scoped(.processChunkDependencies, false);
+            const file_index: FileIndex = ctx.getCachedIndex(side, bundle_graph_index).*;
+            log("index id={d} {}:", .{
+                file_index.get(),
+                bun.fmt.quote(g.bundled_files.keys()[file_index.get()]),
+            });
+
+            var quick_lookup: TempLookup.HashTable = .{};
+            defer quick_lookup.deinit(temp_alloc);
+
+            {
+                var it: ?EdgeIndex = g.first_import.items[file_index.get()].unwrap();
+                while (it) |edge_index| {
+                    const dep = g.edges.items[edge_index.get()];
+                    it = dep.next_import.unwrap();
+                    assert(dep.dependency == file_index);
+                    try quick_lookup.putNoClobber(temp_alloc, dep.imported, .{
+                        .seen = false,
+                        .edge_index = edge_index,
+                    });
+                }
+            }
+
+            var new_imports: EdgeIndex.Optional = .none;
+            defer g.first_import.items[file_index.get()] = new_imports;
+
+            if (side == .server) {
+                if (ctx.server_seen_bit_set.isSet(file_index.get())) return;
+
+                const file = &g.bundled_files.values()[file_index.get()];
+
+                // Process both files in the server-components graph at the same
+                // time. If they were done separately, the second would detach
+                // the edges the first added.
+                if (file.is_rsc and file.is_ssr) {
+                    // The non-ssr file is always first.
+                    // const ssr_index = ctx.scbs.getSSRIndex(bundle_graph_index.get()) orelse {
+                    //     @panic("Unexpected missing server-component-boundary entry");
+                    // };
+                    // try g.processChunkImportRecords(ctx, &quick_lookup, &new_imports, file_index, bun.JSAst.Index.init(ssr_index));
+                }
+            }
+
+            try g.processChunkImportRecords(ctx, &quick_lookup, &new_imports, file_index, bundle_graph_index);
+
+            // '.seen = false' means an import was removed and should be freed
+            for (quick_lookup.values()) |val| {
+                if (!val.seen) {
+                    g.owner().incremental_result.had_adjusted_edges = true;
+
+                    // Unlink from dependency list. At this point the edge is
+                    // already detached from the import list.
+                    g.disconnectEdgeFromDependencyList(val.edge_index);
+
+                    // With no references to this edge, it can be freed
+                    g.freeEdge(val.edge_index);
+                }
+            }
+
+            if (side == .server) {
+                // Follow this file to the route to mark it as stale.
+                try g.traceDependencies(file_index, ctx.gts, .stop_at_boundary);
+            } else {
+                // TODO: Follow this file to the HMR root (info to determine is currently not stored)
+                // without this, changing a client-only file will not mark the route's client bundle as stale
+            }
+        }
+
+        fn disconnectEdgeFromDependencyList(g: *@This(), edge_index: EdgeIndex) void {
+            const edge = &g.edges.items[edge_index.get()];
+            igLog("detach edge={d} | id={d} {} -> id={d} {}", .{
+                edge_index.get(),
+                edge.dependency.get(),
+                bun.fmt.quote(g.bundled_files.keys()[edge.dependency.get()]),
+                edge.imported.get(),
+                bun.fmt.quote(g.bundled_files.keys()[edge.imported.get()]),
+            });
+            if (edge.prev_dependency.unwrap()) |prev| {
+                const prev_dependency = &g.edges.items[prev.get()];
+                prev_dependency.next_dependency = edge.next_dependency;
+            } else {
+                assert(g.first_dep.items[edge.imported.get()].unwrap() == edge_index);
+                g.first_dep.items[edge.imported.get()] = .none;
+            }
+            if (edge.next_dependency.unwrap()) |next| {
+                const next_dependency = &g.edges.items[next.get()];
+                next_dependency.prev_dependency = edge.prev_dependency;
+            }
+        }
+
+        fn processChunkImportRecords(
+            g: *@This(),
+            ctx: *HotUpdateContext,
+            quick_lookup: *TempLookup.HashTable,
+            new_imports: *EdgeIndex.Optional,
+            file_index: FileIndex,
+            index: bun.JSAst.Index,
+        ) !void {
+            const log = bun.Output.scoped(.processChunkDependencies, false);
+            for (ctx.import_records[index.get()].slice()) |import_record| {
+                if (!import_record.source_index.isRuntime()) try_index_record: {
+                    const key = import_record.path.keyForIncrementalGraph();
+                    const imported_file_index = if (import_record.source_index.isInvalid())
+                        FileIndex.init(@intCast(
+                            g.bundled_files.getIndex(key) orelse break :try_index_record,
+                        ))
+                    else
+                        ctx.getCachedIndex(side, import_record.source_index).*;
+
+                    if (Environment.isDebug) {
+                        if (imported_file_index.get() > g.bundled_files.count()) {
+                            Output.debugWarn("Invalid mapped source index {x}. {} was not inserted into IncrementalGraph", .{
+                                imported_file_index.get(),
+                                bun.fmt.quote(key),
+                            });
+                            Output.flush();
+                            continue;
+                        }
+                    }
+
+                    if (quick_lookup.getPtr(imported_file_index)) |lookup| {
+                        // If the edge has already been seen, it will be skipped
+                        // to ensure duplicate edges never exist.
+                        if (lookup.seen) continue;
+                        lookup.seen = true;
+
+                        const dep = &g.edges.items[lookup.edge_index.get()];
+                        dep.next_import = new_imports.*;
+                        new_imports.* = lookup.edge_index.toOptional();
+                    } else {
+                        // A new edge is needed to represent the dependency and import.
+                        const first_dep = &g.first_dep.items[imported_file_index.get()];
+                        const edge = try g.newEdge(.{
+                            .next_import = new_imports.*,
+                            .next_dependency = first_dep.*,
+                            .prev_dependency = .none,
+                            .imported = imported_file_index,
+                            .dependency = file_index,
+                        });
+                        if (first_dep.*.unwrap()) |dep| {
+                            g.edges.items[dep.get()].prev_dependency = edge.toOptional();
+                        }
+                        new_imports.* = edge.toOptional();
+                        first_dep.* = edge.toOptional();
+
+                        g.owner().incremental_result.had_adjusted_edges = true;
+
+                        log("attach edge={d} | id={d} {} -> id={d} {}", .{
+                            edge.get(),
+                            file_index.get(),
+                            bun.fmt.quote(g.bundled_files.keys()[file_index.get()]),
+                            imported_file_index.get(),
+                            bun.fmt.quote(g.bundled_files.keys()[imported_file_index.get()]),
+                        });
+                    }
+                }
+            }
+        }
+
+        const TraceDependencyKind = enum {
+            stop_at_boundary,
+            no_stop,
+            css_to_route,
+        };
+
+        fn traceDependencies(g: *@This(), file_index: FileIndex, gts: *GraphTraceState, trace_kind: TraceDependencyKind) !void {
+            g.owner().graph_safety_lock.assertLocked();
+
+            if (Environment.enable_logs) {
+                igLog("traceDependencies(.{s}, {}{s})", .{
+                    @tagName(side),
+                    bun.fmt.quote(g.bundled_files.keys()[file_index.get()]),
+                    if (gts.bits(side).isSet(file_index.get())) " [already visited]" else "",
+                });
+            }
+
+            if (gts.bits(side).isSet(file_index.get()))
+                return;
+            gts.bits(side).set(file_index.get());
+
+            const file = g.bundled_files.values()[file_index.get()];
+
+            switch (side) {
+                .server => {
+                    const dev = g.owner();
+                    if (file.is_route) {
+                        const route_index = dev.route_lookup.get(file_index) orelse
+                            Output.panic("Route not in lookup index: {d} {}", .{ file_index.get(), bun.fmt.quote(g.bundled_files.keys()[file_index.get()]) });
+                        igLog("\\<- Route", .{});
+
+                        try dev.incremental_result.routes_affected.append(dev.allocator, route_index);
+                    }
+                    if (file.is_client_component_boundary) {
+                        try dev.incremental_result.client_components_affected.append(dev.allocator, file_index);
+                    }
+                },
+                .client => {
+                    if (file.flags.is_hmr_root or (file.flags.kind == .css and trace_kind == .css_to_route)) {
+                        const dev = g.owner();
+                        const key = g.bundled_files.keys()[file_index.get()];
+                        const index = dev.server_graph.getFileIndex(key) orelse
+                            Output.panic("Server Incremental Graph is missing component for {}", .{bun.fmt.quote(key)});
+                        try dev.server_graph.traceDependencies(index, gts, trace_kind);
+                    }
+                },
+            }
+
+            // Certain files do not propagate updates to dependencies.
+            // This is how updating a client component doesn't cause
+            // a server-side reload.
+            if (trace_kind == .stop_at_boundary) {
+                if (file.stopsDependencyTrace()) {
+                    igLog("\\<- this file stops propagation", .{});
+                    return;
+                }
+            }
+
+            // Recurse
+            var it: ?EdgeIndex = g.first_dep.items[file_index.get()].unwrap();
+            while (it) |dep_index| {
+                const edge = g.edges.items[dep_index.get()];
+                it = edge.next_dependency.unwrap();
+                try g.traceDependencies(edge.dependency, gts, trace_kind);
+            }
+        }
+
+        fn traceImports(g: *@This(), file_index: FileIndex, gts: *GraphTraceState, goal: TraceImportGoal) !void {
+            g.owner().graph_safety_lock.assertLocked();
+
+            if (Environment.enable_logs) {
+                igLog("traceImports(.{s}, {}{s})", .{
+                    @tagName(side),
+                    bun.fmt.quote(g.bundled_files.keys()[file_index.get()]),
+                    if (gts.bits(side).isSet(file_index.get())) " [already visited]" else "",
+                });
+            }
+
+            if (gts.bits(side).isSet(file_index.get()))
+                return;
+            gts.bits(side).set(file_index.get());
+
+            const file = g.bundled_files.values()[file_index.get()];
+
+            switch (side) {
+                .server => {
+                    if (file.is_client_component_boundary or file.kind == .css) {
+                        const dev = g.owner();
+                        const key = g.bundled_files.keys()[file_index.get()];
+                        const index = dev.client_graph.getFileIndex(key) orelse
+                            Output.panic("Client Incremental Graph is missing component for {}", .{bun.fmt.quote(key)});
+                        try dev.client_graph.traceImports(index, gts, goal);
+                    }
+                },
+                .client => {
+                    assert(!g.stale_files.isSet(file_index.get())); // should not be left stale
+                    if (file.flags.kind == .css) {
+                        if (goal.find_css) {
+                            try g.current_css_files.append(g.owner().allocator, file.code());
+                        }
+
+                        // Do not count css files as a client module
+                        // and also do not trace its dependencies.
+                        //
+                        // The server version of this code does not need to
+                        // early return, since server css files never have
+                        // imports.
+                        return;
+                    }
+
+                    if (goal.find_client_modules) {
+                        try g.current_chunk_parts.append(g.owner().allocator, file_index);
+                        g.current_chunk_len += file.code_len;
+                    }
+                },
+            }
+
+            // Recurse
+            var it: ?EdgeIndex = g.first_import.items[file_index.get()].unwrap();
+            while (it) |dep_index| {
+                const edge = g.edges.items[dep_index.get()];
+                it = edge.next_import.unwrap();
+                try g.traceImports(edge.imported, gts, goal);
+            }
+        }
+
+        /// 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);
+        }
+
+        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});
+            const gop = try g.bundled_files.getOrPut(g.owner().allocator, abs_path);
+            const file_index = FileIndex.init(@intCast(gop.index));
+
+            if (!gop.found_existing) {
+                gop.key_ptr.* = try bun.default_allocator.dupe(u8, abs_path);
+                try g.first_dep.append(g.owner().allocator, .none);
+                try g.first_import.append(g.owner().allocator, .none);
+            } else {
+                if (side == .server) {
+                    if (is_route) gop.value_ptr.*.is_route = is_route;
+                }
+            }
+
+            if (g.stale_files.bit_length > gop.index) {
+                g.stale_files.set(gop.index);
+            }
+
+            switch (side) {
+                .client => {
+                    gop.value_ptr.* = File.init("", .{
+                        .failed = false,
+                        .is_hmr_root = false,
+                        .is_special_framework_file = false,
+                        .kind = .unknown,
+                    });
+                },
+                .server => {
+                    if (!gop.found_existing) {
+                        gop.value_ptr.* = .{
+                            .is_rsc = !is_ssr_graph,
+                            .is_ssr = is_ssr_graph,
+                            .is_route = is_route,
+                            .is_client_component_boundary = false,
+                            .failed = false,
+                            .kind = .unknown,
+                        };
+                    } else if (is_ssr_graph) {
+                        gop.value_ptr.is_ssr = true;
+                    } else {
+                        gop.value_ptr.is_rsc = true;
+                    }
+                },
+            }
+
+            return file_index;
+        }
+
+        /// Server CSS files are just used to be targets for graph traversal.
+        /// Its content lives only on the client.
+        pub fn insertCssFileOnServer(g: *@This(), ctx: *HotUpdateContext, index: bun.JSAst.Index, abs_path: []const u8) bun.OOM!void {
+            g.owner().graph_safety_lock.assertLocked();
+
+            debug.log("Insert stale: {s}", .{abs_path});
+            const gop = try g.bundled_files.getOrPut(g.owner().allocator, abs_path);
+            const file_index = FileIndex.init(@intCast(gop.index));
+
+            if (!gop.found_existing) {
+                gop.key_ptr.* = try bun.default_allocator.dupe(u8, abs_path);
+                try g.first_dep.append(g.owner().allocator, .none);
+                try g.first_import.append(g.owner().allocator, .none);
+            }
+
+            switch (side) {
+                .client => @compileError("not implemented: use receiveChunk"),
+                .server => {
+                    gop.value_ptr.* = .{
+                        .is_rsc = false,
+                        .is_ssr = false,
+                        .is_route = false,
+                        .is_client_component_boundary = false,
+                        .failed = false,
+                        .kind = .css,
+                    };
+                },
+            }
+
+            ctx.getCachedIndex(.server, index).* = file_index;
+        }
+
+        pub fn insertFailure(
+            g: *@This(),
+            abs_path: []const u8,
+            log: *const Log,
+            is_ssr_graph: bool,
+        ) bun.OOM!void {
+            g.owner().graph_safety_lock.assertLocked();
+
+            debug.log("Insert stale: {s}", .{abs_path});
+            const gop = try g.bundled_files.getOrPut(g.owner().allocator, abs_path);
+            const file_index = FileIndex.init(@intCast(gop.index));
+
+            if (!gop.found_existing) {
+                gop.key_ptr.* = try bun.default_allocator.dupe(u8, abs_path);
+                try g.first_dep.append(g.owner().allocator, .none);
+                try g.first_import.append(g.owner().allocator, .none);
+            }
+
+            try g.ensureStaleBitCapacity(true);
+            g.stale_files.set(gop.index);
+
+            switch (side) {
+                .client => {
+                    gop.value_ptr.* = File.init("", .{
+                        .failed = true,
+                        .is_hmr_root = false,
+                        .is_special_framework_file = false,
+                        .kind = .unknown,
+                    });
+                },
+                .server => {
+                    if (!gop.found_existing) {
+                        gop.value_ptr.* = .{
+                            .is_rsc = !is_ssr_graph,
+                            .is_ssr = is_ssr_graph,
+                            .is_route = false,
+                            .is_client_component_boundary = false,
+                            .failed = true,
+                            .kind = .unknown,
+                        };
+                    } else {
+                        if (is_ssr_graph) {
+                            gop.value_ptr.is_ssr = true;
+                        } else {
+                            gop.value_ptr.is_rsc = true;
+                        }
+                        gop.value_ptr.failed = true;
+                    }
+                },
+            }
+
+            const dev = g.owner();
+
+            const fail_owner: SerializedFailure.Owner = switch (side) {
+                .server => .{ .server = file_index },
+                .client => .{ .client = file_index },
+            };
+            const failure = try SerializedFailure.initFromLog(
+                fail_owner,
+                dev.relativePath(abs_path),
+                log.msgs.items,
+            );
+            const fail_gop = try dev.bundling_failures.getOrPut(dev.allocator, failure);
+            try dev.incremental_result.failures_added.append(dev.allocator, failure);
+            if (fail_gop.found_existing) {
+                try dev.incremental_result.failures_removed.append(dev.allocator, fail_gop.key_ptr.*);
+                fail_gop.key_ptr.* = failure;
+            }
+        }
+
+        pub fn onFileDeleted(g: *@This(), abs_path: []const u8, log: *const Log) !void {
+            const index = g.getFileIndex(abs_path) orelse return;
+
+            if (g.first_dep.items[index.get()] == .none) {
+                g.disconnectAndDeleteFile(index);
+            } else {
+                // Keep the file so others may refer to it, but mark as failed.
+                try g.insertFailure(abs_path, log, false);
+            }
+        }
+
+        pub fn ensureStaleBitCapacity(g: *@This(), are_new_files_stale: bool) !void {
+            try g.stale_files.resize(
+                g.owner().allocator,
+                std.mem.alignForward(
+                    usize,
+                    @max(g.bundled_files.count(), g.stale_files.bit_length),
+                    // allocate 8 in 8 usize chunks
+                    std.mem.byte_size_in_bits * @sizeOf(usize) * 8,
+                ),
+                are_new_files_stale,
+            );
+        }
+
+        pub fn invalidate(g: *@This(), paths: []const []const u8, entry_points: *EntryPointList, alloc: Allocator) !void {
+            g.owner().graph_safety_lock.assertLocked();
+            const values = g.bundled_files.values();
+            for (paths) |path| {
+                const index = g.bundled_files.getIndex(path) orelse {
+                    // Cannot enqueue because it's impossible to know what
+                    // targets to bundle for. Instead, a failing bundle must
+                    // retrieve the list of files and add them as stale.
+                    continue;
+                };
+                g.stale_files.set(index);
+                const data = &values[index];
+                switch (side) {
+                    .client => {
+                        // When re-bundling SCBs, only bundle the server. Otherwise
+                        // the bundler gets confused and bundles both sides without
+                        // knowledge of the boundary between them.
+                        if (data.flags.kind == .css)
+                            try entry_points.appendCss(alloc, path)
+                        else if (!data.flags.is_hmr_root)
+                            try entry_points.appendJs(alloc, path, .client);
+                    },
+                    .server => {
+                        if (data.is_rsc)
+                            try entry_points.appendJs(alloc, path, .server);
+                        if (data.is_ssr and !data.is_client_component_boundary)
+                            try entry_points.appendJs(alloc, path, .ssr);
+                    },
+                }
+            }
+        }
+
+        fn reset(g: *@This()) void {
+            g.owner().graph_safety_lock.assertLocked();
+            g.current_chunk_len = 0;
+            g.current_chunk_parts.clearRetainingCapacity();
+            if (side == .client) g.current_css_files.clearRetainingCapacity();
+        }
+
+        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, 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),
+            initial_response_entry_point: []const u8,
+        ) !void {
+            g.owner().graph_safety_lock.assertLocked();
+            // initial bundle needs at least the entry point
+            // hot updates shouldn't be emitted if there are no chunks
+            assert(g.current_chunk_len > 0);
+
+            const runtime = switch (kind) {
+                .initial_response => bun.bake.getHmrRuntime(side),
+                .hmr_chunk => "({\n",
+            };
+
+            // A small amount of metadata is present at the end of the chunk
+            // to inform the HMR runtime some crucial entry-point info. The
+            // exact upper bound of this can be calculated, but is not to
+            // avoid worrying about windows paths.
+            var end_sfa = std.heap.stackFallback(65536, g.owner().allocator);
+            var end_list = std.ArrayList(u8).initCapacity(end_sfa.get(), 65536) catch unreachable;
+            defer end_list.deinit();
+            const end = end: {
+                const w = end_list.writer();
+                switch (kind) {
+                    .initial_response => {
+                        const fw = g.owner().framework;
+                        try w.writeAll("}, {\n  main: ");
+                        try bun.js_printer.writeJSONString(
+                            g.owner().relativePath(initial_response_entry_point),
+                            @TypeOf(w),
+                            w,
+                            .utf8,
+                        );
+                        switch (side) {
+                            .client => {
+                                try w.writeAll(",\n  version: \"");
+                                try w.writeAll(&g.owner().configuration_hash_key);
+                                try w.writeAll("\"");
+                                if (fw.react_fast_refresh) |rfr| {
+                                    try w.writeAll(",\n  refresh: ");
+                                    try bun.js_printer.writeJSONString(
+                                        g.owner().relativePath(rfr.import_source),
+                                        @TypeOf(w),
+                                        w,
+                                        .utf8,
+                                    );
+                                }
+                            },
+                            .server => {
+                                if (fw.server_components) |sc| {
+                                    if (sc.separate_ssr_graph) {
+                                        try w.writeAll(",\n  separateSSRGraph: true");
+                                    }
+                                }
+                            },
+                        }
+                        try w.writeAll("\n})");
+                    },
+                    .hmr_chunk => {
+                        try w.writeAll("\n})");
+                    },
+                }
+                break :end end_list.items;
+            };
+
+            const files = g.bundled_files.values();
+
+            const start = list.items.len;
+            if (start == 0)
+                try list.ensureTotalCapacityPrecise(g.current_chunk_len + runtime.len + end.len)
+            else
+                try list.ensureUnusedCapacity(g.current_chunk_len + runtime.len + end.len);
+
+            list.appendSliceAssumeCapacity(runtime);
+            for (g.current_chunk_parts.items) |entry| {
+                list.appendSliceAssumeCapacity(switch (side) {
+                    // entry is an index into files
+                    .client => files[entry.get()].code(),
+                    // entry is the '[]const u8' itself
+                    .server => entry,
+                });
+            }
+            list.appendSliceAssumeCapacity(end);
+
+            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,
+                    .server => .server,
+                }, rel_path_escaped, list.items[start..], false) catch |err| {
+                    bun.handleErrorReturnTrace(err, @errorReturnTrace());
+                    Output.warn("Could not dump bundle: {}", .{err});
+                };
+            };
+        }
+
+        fn disconnectAndDeleteFile(g: *@This(), file_index: FileIndex) void {
+            bun.assert(g.bundled_files.count() > 1); // never remove all files
+            bun.assert(g.first_dep.items[file_index.get()] == .none); // must have no dependencies
+
+            // Disconnect all imports
+            {
+                var it: ?EdgeIndex = g.first_import.items[file_index.get()].unwrap();
+                while (it) |edge_index| {
+                    const dep = g.edges.items[edge_index.get()];
+                    it = dep.next_import.unwrap();
+                    assert(dep.dependency == file_index);
+
+                    g.disconnectEdgeFromDependencyList(edge_index);
+                    g.freeEdge(edge_index);
+
+                    // TODO: a flag to this function which is queues all
+                    // direct importers to rebuild themselves, which will
+                    // display the bundling errors.
+                }
+            }
+
+            const keys = g.bundled_files.keys();
+
+            g.owner().allocator.free(keys[file_index.get()]);
+            keys[file_index.get()] = ""; // cannot be `undefined` as it may be read by hashmap logic
+
+            // TODO: it is infeasible to swapRemove a file since FrameworkRouter
+            // contains file indices to the server graph. Instead, `file_index`
+            // should go in a free-list for use by new files.
+        }
+
+        fn newEdge(g: *@This(), edge: Edge) !EdgeIndex {
+            if (g.edges_free_list.popOrNull()) |index| {
+                g.edges.items[index.get()] = edge;
+                return index;
+            }
+
+            const index = EdgeIndex.init(@intCast(g.edges.items.len));
+            try g.edges.append(g.owner().allocator, edge);
+            return index;
+        }
+
+        /// Does nothing besides release the `Edge` for reallocation by `newEdge`
+        /// Caller must detach the dependency from the linked list it is in.
+        fn freeEdge(g: *@This(), edge_index: EdgeIndex) void {
+            if (Environment.isDebug) {
+                g.edges.items[edge_index.get()] = undefined;
+            }
+
+            if (edge_index.get() == (g.edges.items.len - 1)) {
+                g.edges.items.len -= 1;
+            } else {
+                g.edges_free_list.append(g.owner().allocator, edge_index) catch {
+                    // Leak an edge object; Ok since it may get cleaned up by
+                    // the next incremental graph garbage-collection cycle.
+                };
+            }
+        }
+
+        pub fn owner(g: *@This()) *DevServer {
+            return @alignCast(@fieldParentPtr(@tagName(side) ++ "_graph", g));
+        }
+    };
+}
+
+const IncrementalResult = struct {
+    /// When tracing a file's dependencies via `traceDependencies`, this is
+    /// 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),
+    /// Set to true if any IncrementalGraph edges were added or removed.
+    had_adjusted_edges: bool,
+
+    // Following three fields are populated during `receiveChunk`
+
+    /// Components to add to the client manifest
+    client_components_added: ArrayListUnmanaged(IncrementalGraph(.server).FileIndex),
+    /// Components to add to the client manifest
+    client_components_removed: ArrayListUnmanaged(IncrementalGraph(.server).FileIndex),
+    /// This list acts as a free list. The contents of these slices must remain
+    /// valid; they have to be so the affected routes can be cleared of the
+    /// failures and potentially be marked valid. At the end of an
+    /// incremental update, the slices are freed.
+    failures_removed: ArrayListUnmanaged(SerializedFailure),
+
+    /// Client boundaries that have been added or modified. At the end of a hot
+    /// update, these are traced to their route to mark the bundles as stale (to
+    /// be generated on Cmd+R)
+    ///
+    /// Populated during `traceDependencies`
+    client_components_affected: ArrayListUnmanaged(IncrementalGraph(.server).FileIndex),
+
+    /// The list of failures which will have to be traced to their route. Such
+    /// tracing is deferred until the second pass of finalizeBundle as the
+    /// dependency graph may not fully exist at the time the failure is indexed.
+    ///
+    /// Populated from within the bundler via `handleParseTaskFailure`
+    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 = .{
+        .routes_affected = .{},
+        .had_adjusted_edges = false,
+        .failures_removed = .{},
+        .failures_added = .{},
+        .client_components_added = .{},
+        .client_components_removed = .{},
+        .client_components_affected = .{},
+        .delete_client_files_later = .{},
+    };
+
+    fn reset(result: *IncrementalResult) void {
+        result.routes_affected.clearRetainingCapacity();
+        assert(result.failures_removed.items.len == 0);
+        result.failures_added.clearRetainingCapacity();
+        result.client_components_added.clearRetainingCapacity();
+        result.client_components_removed.clearRetainingCapacity();
+        result.client_components_affected.clearRetainingCapacity();
+    }
+};
+
+/// Used during an incremental update to determine what "HMR roots"
+/// are affected. Set for all `bundled_files` that have been visited
+/// by the dependency tracing logic.
+const GraphTraceState = struct {
+    client_bits: DynamicBitSetUnmanaged,
+    server_bits: DynamicBitSetUnmanaged,
+
+    fn bits(gts: *GraphTraceState, side: bake.Side) *DynamicBitSetUnmanaged {
+        return switch (side) {
+            .client => &gts.client_bits,
+            .server => &gts.server_bits,
+        };
+    }
+
+    fn deinit(gts: *GraphTraceState, alloc: Allocator) void {
+        gts.client_bits.deinit(alloc);
+        gts.server_bits.deinit(alloc);
+    }
+
+    fn clear(gts: *GraphTraceState) void {
+        gts.server_bits.setAll(false);
+        gts.client_bits.setAll(false);
+    }
+};
+
+const TraceImportGoal = struct {
+    // gts: *GraphTraceState,
+    find_css: bool = false,
+    find_client_modules: bool = false,
+};
+
+fn initGraphTraceState(dev: *const DevServer, sfa: Allocator) !GraphTraceState {
+    var server_bits = try DynamicBitSetUnmanaged.initEmpty(sfa, dev.server_graph.bundled_files.count());
+    errdefer server_bits.deinit(sfa);
+    const client_bits = try DynamicBitSetUnmanaged.initEmpty(sfa, dev.client_graph.bundled_files.count());
+    return .{ .server_bits = server_bits, .client_bits = client_bits };
+}
+
+/// When a file fails to import a relative path, directory watchers are added so
+/// that when a matching file is created, the dependencies can be rebuilt. This
+/// handles HMR cases where a user writes an import before creating the file,
+/// or moves files around.
+///
+/// This structure manages those watchers, including releasing them once
+/// import resolution failures are solved.
+const DirectoryWatchStore = struct {
+    /// This guards all store state
+    lock: Mutex,
+
+    /// List of active watchers. Can be re-ordered on removal
+    watches: bun.StringArrayHashMapUnmanaged(Entry),
+    dependencies: ArrayListUnmanaged(Dep),
+    /// Dependencies cannot be re-ordered. This list tracks what indexes are free.
+    dependencies_free_list: ArrayListUnmanaged(Dep.Index),
+
+    const empty: DirectoryWatchStore = .{
+        .lock = .{},
+        .watches = .{},
+        .dependencies = .{},
+        .dependencies_free_list = .{},
+    };
+
+    pub fn owner(store: *DirectoryWatchStore) *DevServer {
+        return @alignCast(@fieldParentPtr("directory_watchers", store));
+    }
+
+    pub fn trackResolutionFailure(
+        store: *DirectoryWatchStore,
+        import_source: []const u8,
+        specifier: []const u8,
+        renderer: bake.Graph,
+    ) bun.OOM!void {
+        store.lock.lock();
+        defer store.lock.unlock();
+
+        // When it does not resolve to a file path, there is
+        // nothing to track. Bake does not watch node_modules.
+        if (!(bun.strings.startsWith(specifier, "./") or
+            bun.strings.startsWith(specifier, "../"))) return;
+        if (!std.fs.path.isAbsolute(import_source)) return;
+
+        const joined = bun.path.joinAbs(bun.path.dirname(import_source, .auto), .auto, specifier);
+        const dir = bun.path.dirname(joined, .auto);
+
+        // `import_source` is not a stable string. let's share memory with the file graph.
+        // this requires that
+        const dev = store.owner();
+        dev.graph_safety_lock.lock();
+        defer dev.graph_safety_lock.unlock();
+        const owned_file_path = switch (renderer) {
+            .client => path: {
+                const index = try dev.client_graph.insertStale(import_source, false);
+                break :path dev.client_graph.bundled_files.keys()[index.get()];
+            },
+            .server, .ssr => path: {
+                const index = try dev.client_graph.insertStale(import_source, renderer == .ssr);
+                break :path dev.client_graph.bundled_files.keys()[index.get()];
+            },
+        };
+
+        store.insert(dir, owned_file_path, specifier) catch |err| switch (err) {
+            error.Ignore => {}, // ignoring watch errors.
+            error.OutOfMemory => |e| return e,
+        };
+    }
+
+    /// `dir_name_to_watch` is cloned
+    /// `file_path` must have lifetime that outlives the watch
+    /// `specifier` is cloned
+    fn insert(
+        store: *DirectoryWatchStore,
+        dir_name_to_watch: []const u8,
+        file_path: []const u8,
+        specifier: []const u8,
+    ) !void {
+        // TODO: watch the parent dir too.
+        const dev = store.owner();
+
+        debug.log("DirectoryWatchStore.insert({}, {}, {})", .{
+            bun.fmt.quote(dir_name_to_watch),
+            bun.fmt.quote(file_path),
+            bun.fmt.quote(specifier),
+        });
+
+        if (store.dependencies_free_list.items.len == 0)
+            try store.dependencies.ensureUnusedCapacity(dev.allocator, 1);
+
+        const gop = try store.watches.getOrPut(dev.allocator, dir_name_to_watch);
+        if (gop.found_existing) {
+            const specifier_cloned = try dev.allocator.dupe(u8, specifier);
+            errdefer dev.allocator.free(specifier_cloned);
+
+            // TODO: check for dependency
+
+            const dep = store.appendDepAssumeCapacity(.{
+                .next = gop.value_ptr.first_dep.toOptional(),
+                .source_file_path = file_path,
+                .specifier = specifier_cloned,
+            });
+            gop.value_ptr.first_dep = dep;
+
+            return;
+        }
+        errdefer store.watches.swapRemoveAt(gop.index);
+
+        // Try to use an existing open directory handle
+        const cache_fd = if (dev.server_bundler.resolver.readDirInfo(dir_name_to_watch) catch null) |cache| fd: {
+            const fd = cache.getFileDescriptor();
+            break :fd if (fd == .zero) null else fd;
+        } else null;
+
+        const fd, const owned_fd = if (cache_fd) |fd|
+            .{ fd, false }
+        else
+            .{
+                switch (bun.sys.open(
+                    &(std.posix.toPosixPath(dir_name_to_watch) catch |err| switch (err) {
+                        error.NameTooLong => return, // wouldn't be able to open, ignore
+                    }),
+                    bun.O.DIRECTORY,
+                    0,
+                )) {
+                    .result => |fd| fd,
+                    .err => |err| switch (err.getErrno()) {
+                        // If this directory doesn't exist, a watcher should be
+                        // placed on the parent directory. Then, if this
+                        // directory is later created, the watcher can be
+                        // properly initialized. This would happen if you write
+                        // an import path like `./dir/whatever/hello.tsx` and
+                        // `dir` does not exist, Bun must place a watcher on
+                        // `.`, see the creation of `dir`, and repeat until it
+                        // can open a watcher on `whatever` to see the creation
+                        // of `hello.tsx`
+                        .NOENT => {
+                            // TODO: implement that. for now it ignores
+                            return;
+                        },
+                        .NOTDIR => return error.Ignore, // ignore
+                        else => {
+                            bun.todoPanic(@src(), "log watcher error", .{});
+                        },
+                    },
+                },
+                true,
+            };
+        errdefer _ = if (owned_fd) bun.sys.close(fd);
+
+        debug.log("-> fd: {} ({s})", .{
+            fd,
+            if (owned_fd) "from dir cache" else "owned fd",
+        });
+
+        const dir_name = try dev.allocator.dupe(u8, dir_name_to_watch);
+        errdefer dev.allocator.free(dir_name);
+
+        gop.key_ptr.* = dir_name;
+
+        const specifier_cloned = try dev.allocator.dupe(u8, specifier);
+        errdefer dev.allocator.free(specifier_cloned);
+
+        const watch_index = switch (dev.bun_watcher.addDirectory(fd, dir_name, bun.JSC.GenericWatcher.getHash(dir_name), false)) {
+            .err => return error.Ignore,
+            .result => |id| id,
+        };
+        const dep = store.appendDepAssumeCapacity(.{
+            .next = .none,
+            .source_file_path = file_path,
+            .specifier = specifier_cloned,
+        });
+        store.watches.putAssumeCapacity(dir_name, .{
+            .dir = fd,
+            .dir_fd_owned = owned_fd,
+            .first_dep = dep,
+            .watch_index = watch_index,
+        });
+    }
+
+    /// Caller must detach the dependency from the linked list it is in.
+    fn freeDependencyIndex(store: *DirectoryWatchStore, alloc: Allocator, index: Dep.Index) !void {
+        alloc.free(store.dependencies.items[index.get()].specifier);
+
+        if (Environment.isDebug) {
+            store.dependencies.items[index.get()] = undefined;
+        }
+
+        if (index.get() == (store.dependencies.items.len - 1)) {
+            store.dependencies.items.len -= 1;
+        } else {
+            try store.dependencies_free_list.append(alloc, index);
+        }
+    }
+
+    /// Expects dependency list to be already freed
+    fn freeEntry(store: *DirectoryWatchStore, entry_index: usize) void {
+        const entry = store.watches.values()[entry_index];
+
+        debug.log("DirectoryWatchStore.freeEntry({d}, {})", .{
+            entry_index,
+            entry.dir,
+        });
+
+        store.owner().bun_watcher.removeAtIndex(entry.watch_index, 0, &.{}, .file);
+
+        defer _ = if (entry.dir_fd_owned) bun.sys.close(entry.dir);
+        store.watches.swapRemoveAt(entry_index);
+
+        if (store.watches.entries.len == 0) {
+            assert(store.dependencies.items.len == 0);
+            store.dependencies_free_list.clearRetainingCapacity();
+        }
+    }
+
+    fn appendDepAssumeCapacity(store: *DirectoryWatchStore, dep: Dep) Dep.Index {
+        if (store.dependencies_free_list.popOrNull()) |index| {
+            store.dependencies.items[index.get()] = dep;
+            return index;
+        }
+
+        const index = Dep.Index.init(@intCast(store.dependencies.items.len));
+        store.dependencies.appendAssumeCapacity(dep);
+        return index;
+    }
+
+    const Entry = struct {
+        /// The directory handle the watch is placed on
+        dir: bun.FileDescriptor,
+        dir_fd_owned: bool,
+        /// Files which request this import index
+        first_dep: Dep.Index,
+        /// To pass to Watcher.remove
+        watch_index: u16,
+    };
+
+    const Dep = struct {
+        next: Index.Optional,
+        /// The file used
+        source_file_path: []const u8,
+        /// The specifier that failed. Before running re-build, it is resolved for, as
+        /// creating an unrelated file should not re-emit another error. Default-allocator
+        specifier: []const u8,
+
+        const Index = bun.GenericIndex(u32, Dep);
+    };
+};
+
+const ChunkKind = enum {
+    initial_response,
+    hmr_chunk,
+};
+
+/// Errors sent to the HMR client in the browser are serialized. The same format
+/// is used for thrown JavaScript exceptions as well as bundler errors.
+/// Serialized failures contain a handle on what file or route they came from,
+/// which allows the bundler to dismiss or update stale failures via index as
+/// opposed to re-sending a new payload. This also means only changed files are
+/// rebuilt, instead of all of the failed files.
+///
+/// The HMR client in the browser is expected to sort the final list of errors
+/// for deterministic output; there is code in DevServer that uses `swapRemove`.
+pub const SerializedFailure = struct {
+    /// Serialized data is always owned by default_allocator
+    /// The first 32 bits of this slice contain the owner
+    data: []u8,
+
+    pub fn deinit(f: SerializedFailure) void {
+        bun.default_allocator.free(f.data);
+    }
+
+    /// The metaphorical owner of an incremental file error. The packed variant
+    /// is given to the HMR runtime as an opaque handle.
+    pub const Owner = union(enum) {
+        none,
+        route: RouteBundle.Index,
+        client: IncrementalGraph(.client).FileIndex,
+        server: IncrementalGraph(.server).FileIndex,
+
+        pub fn encode(owner: Owner) Packed {
+            return switch (owner) {
+                .none => .{ .kind = .none, .data = 0 },
+                .client => |data| .{ .kind = .client, .data = data.get() },
+                .server => |data| .{ .kind = .server, .data = data.get() },
+                .route => |data| .{ .kind = .route, .data = data.get() },
+            };
+        }
+
+        pub const Packed = packed struct(u32) {
+            kind: enum(u2) { none, route, client, server },
+            data: u30,
+
+            pub fn decode(owner: Packed) Owner {
+                return switch (owner.kind) {
+                    .none => .none,
+                    .client => .{ .client = IncrementalGraph(.client).FileIndex.init(owner.data) },
+                    .server => .{ .server = IncrementalGraph(.server).FileIndex.init(owner.data) },
+                    .route => .{ .route = RouteBundle.Index.init(owner.data) },
+                };
+            }
+        };
+    };
+
+    fn getOwner(failure: SerializedFailure) Owner {
+        return std.mem.bytesAsValue(Owner.Packed, failure.data[0..4]).decode();
+    }
+
+    /// This assumes the hash map contains only one SerializedFailure per owner.
+    /// This is okay since SerializedFailure can contain more than one error.
+    const ArrayHashContextViaOwner = struct {
+        pub fn hash(_: ArrayHashContextViaOwner, k: SerializedFailure) u32 {
+            return std.hash.uint32(@bitCast(k.getOwner().encode()));
+        }
+
+        pub fn eql(_: ArrayHashContextViaOwner, a: SerializedFailure, b: SerializedFailure, _: usize) bool {
+            return @as(u32, @bitCast(a.getOwner().encode())) == @as(u32, @bitCast(b.getOwner().encode()));
+        }
+    };
+
+    const ArrayHashAdapter = struct {
+        pub fn hash(_: ArrayHashAdapter, own: Owner) u32 {
+            return std.hash.uint32(@bitCast(own.encode()));
+        }
+
+        pub fn eql(_: ArrayHashAdapter, a: Owner, b: SerializedFailure, _: usize) bool {
+            return @as(u32, @bitCast(a.encode())) == @as(u32, @bitCast(b.getOwner().encode()));
+        }
+    };
+
+    const ErrorKind = enum(u8) {
+        // A log message. The `logger.Kind` is encoded here.
+        bundler_log_err = 0,
+        bundler_log_warn = 1,
+        bundler_log_note = 2,
+        bundler_log_debug = 3,
+        bundler_log_verbose = 4,
+
+        /// new Error(message)
+        js_error,
+        /// new TypeError(message)
+        js_error_type,
+        /// new RangeError(message)
+        js_error_range,
+        /// Other forms of `Error` objects, including when an error has a
+        /// `code`, and other fields.
+        js_error_extra,
+        /// Non-error with a stack trace
+        js_primitive_exception,
+        /// Non-error JS values
+        js_primitive,
+        /// new AggregateError(errors, message)
+        js_aggregate,
+    };
+
+    pub fn initFromJs(owner: Owner, value: JSValue) !SerializedFailure {
+        {
+            _ = value;
+            @panic("TODO");
+        }
+        // Avoid small re-allocations without requesting so much from the heap
+        var sfb = std.heap.stackFallback(65536, bun.default_allocator);
+        var payload = std.ArrayList(u8).initCapacity(sfb.get(), 65536) catch
+            unreachable; // enough space
+        const w = payload.writer();
+
+        try w.writeInt(u32, @bitCast(owner.encode()), .little);
+        // try writeJsValue(value);
+
+        // Avoid-recloning if it is was moved to the hap
+        const data = if (payload.items.ptr == &sfb.buffer)
+            try bun.default_allocator.dupe(u8, payload.items)
+        else
+            payload.items;
+
+        return .{ .data = data };
+    }
+
+    pub fn initFromLog(
+        owner: Owner,
+        owner_display_name: []const u8,
+        messages: []const bun.logger.Msg,
+    ) !SerializedFailure {
+        assert(messages.len > 0);
+
+        // Avoid small re-allocations without requesting so much from the heap
+        var sfb = std.heap.stackFallback(65536, bun.default_allocator);
+        var payload = std.ArrayList(u8).initCapacity(sfb.get(), 65536) catch
+            unreachable; // enough space
+        const w = payload.writer();
+
+        try w.writeInt(u32, @bitCast(owner.encode()), .little);
+
+        try writeString32(owner_display_name, w);
+
+        try w.writeInt(u32, @intCast(messages.len), .little);
+
+        for (messages) |*msg| {
+            try writeLogMsg(msg, w);
+        }
+
+        // Avoid-recloning if it is was moved to the hap
+        const data = if (payload.items.ptr == &sfb.buffer)
+            try bun.default_allocator.dupe(u8, payload.items)
+        else
+            payload.items;
+
+        return .{ .data = data };
+    }
+
+    // All "write" functions get a corresponding "read" function in ./client/error.ts
+
+    const Writer = std.ArrayList(u8).Writer;
+
+    fn writeLogMsg(msg: *const bun.logger.Msg, w: Writer) !void {
+        try w.writeByte(switch (msg.kind) {
+            inline else => |k| @intFromEnum(@field(ErrorKind, "bundler_log_" ++ @tagName(k))),
+        });
+        try writeLogData(msg.data, w);
+        const notes = msg.notes;
+        try w.writeInt(u32, @intCast(notes.len), .little);
+        for (notes) |note| {
+            try writeLogData(note, w);
+        }
+    }
+
+    fn writeLogData(data: bun.logger.Data, w: Writer) !void {
+        try writeString32(data.text, w);
+        if (data.location) |loc| {
+            if (loc.line < 0) {
+                try w.writeInt(u32, 0, .little);
+                return;
+            }
+            assert(loc.column >= 0); // zero based and not negative
+
+            try w.writeInt(i32, @intCast(loc.line), .little);
+            try w.writeInt(u32, @intCast(loc.column), .little);
+            try w.writeInt(u32, @intCast(loc.length), .little);
+
+            // TODO: syntax highlighted line text + give more context lines
+            try writeString32(loc.line_text orelse "", w);
+
+            // The file is not specified here. Since the bundler runs every file
+            // in isolation, it would be impossible to reference any other file
+            // in this Log. Thus, it is not serialized.
+        } else {
+            try w.writeInt(u32, 0, .little);
+        }
+    }
+
+    fn writeString32(data: []const u8, w: Writer) !void {
+        try w.writeInt(u32, @intCast(data.len), .little);
+        try w.writeAll(data);
+    }
+
+    // fn writeJsValue(value: JSValue, global: *JSC.JSGlobalObject, w: *Writer) !void {
+    //     if (value.isAggregateError(global)) {
+    //         //
+    //     }
+    //     if (value.jsType() == .DOMWrapper) {
+    //         if (value.as(JSC.BuildMessage)) |build_error| {
+    //             _ = build_error; // autofix
+    //             //
+    //         } else if (value.as(JSC.ResolveMessage)) |resolve_error| {
+    //             _ = resolve_error; // autofix
+    //             @panic("TODO");
+    //         }
+    //     }
+    //     _ = w; // autofix
+
+    //     @panic("TODO");
+    // }
+};
+
+// For debugging, it is helpful to be able to see bundles.
+fn dumpBundle(dump_dir: std.fs.Dir, side: bake.Graph, rel_path: []const u8, chunk: []const u8, wrap: bool) !void {
+    const name = bun.path.joinAbsString("/", &.{
+        @tagName(side),
+        rel_path,
+    }, .auto)[1..];
+    var inner_dir = try dump_dir.makeOpenPath(bun.Dirname.dirname(u8, name).?, .{});
+    defer inner_dir.close();
+
+    const file = try inner_dir.createFile(bun.path.basename(name), .{});
+    defer file.close();
+
+    var bufw = std.io.bufferedWriter(file.writer());
+
+    try bufw.writer().print("// {s} bundled for {s}\n", .{
+        bun.fmt.quote(rel_path),
+        @tagName(side),
+    });
+    try bufw.writer().print("// Bundled at {d}, Bun " ++ bun.Global.package_json_version_with_canary ++ "\n", .{
+        std.time.nanoTimestamp(),
+    });
+
+    // Wrap in an object to make it valid syntax. Regardless, these files
+    // are never executable on their own as they contain only a single module.
+
+    if (wrap)
+        try bufw.writer().writeAll("({\n");
+
+    try bufw.writer().writeAll(chunk);
+
+    if (wrap)
+        try bufw.writer().writeAll("});\n");
+
+    try bufw.flush();
+}
+
+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(.visualizer, payload.items, .binary);
+}
+
+fn writeVisualizerMessage(dev: *DevServer, payload: *std.ArrayList(u8)) !void {
+    payload.appendAssumeCapacity(MessageId.visualizer.char());
+    const w = payload.writer();
+
+    inline for (
+        [2]bake.Side{ .client, .server },
+        .{ &dev.client_graph, &dev.server_graph },
+    ) |side, g| {
+        try w.writeInt(u32, @intCast(g.bundled_files.count()), .little);
+        for (
+            g.bundled_files.keys(),
+            g.bundled_files.values(),
+            0..,
+        ) |k, v, i| {
+            const normalized_key = dev.relativePath(k);
+            try w.writeInt(u32, @intCast(normalized_key.len), .little);
+            if (k.len == 0) continue;
+            try w.writeAll(normalized_key);
+            try w.writeByte(@intFromBool(g.stale_files.isSet(i) or switch (side) {
+                .server => v.failed,
+                .client => v.flags.failed,
+            }));
+            try w.writeByte(@intFromBool(side == .server and v.is_rsc));
+            try w.writeByte(@intFromBool(side == .server and v.is_ssr));
+            try w.writeByte(@intFromBool(side == .server and v.is_route));
+            try w.writeByte(@intFromBool(side == .client and v.flags.is_special_framework_file));
+            try w.writeByte(@intFromBool(switch (side) {
+                .server => v.is_client_component_boundary,
+                .client => v.flags.is_hmr_root,
+            }));
+        }
+    }
+    inline for (.{ &dev.client_graph, &dev.server_graph }) |g| {
+        const G = @TypeOf(g.*);
+
+        try w.writeInt(u32, @intCast(g.edges.items.len - g.edges_free_list.items.len), .little);
+        for (g.edges.items, 0..) |edge, i| {
+            if (std.mem.indexOfScalar(G.EdgeIndex, g.edges_free_list.items, G.EdgeIndex.init(@intCast(i))) != null)
+                continue;
+
+            try w.writeInt(u32, @intCast(edge.dependency.get()), .little);
+            try w.writeInt(u32, @intCast(edge.imported.get()), .little);
+        }
+    }
+}
+
+pub fn onWebSocketUpgrade(
+    dev: *DevServer,
+    res: *Response,
+    req: *Request,
+    upgrade_ctx: *uws.uws_socket_context_t,
+    id: usize,
+) void {
+    assert(id == 0);
+
+    const dw = bun.create(dev.allocator, HmrSocket, .{
+        .dev = dev,
+        .is_from_localhost = if (res.getRemoteSocketInfo()) |addr|
+            if (addr.is_ipv6)
+                bun.strings.eqlComptime(addr.ip, "::1")
+            else
+                bun.strings.eqlComptime(addr.ip, "127.0.0.1")
+        else
+            false,
+        .subscriptions = .{},
+        .active_route = .none,
+    });
+    res.upgrade(
+        *HmrSocket,
+        dw,
+        req.header("sec-websocket-key") orelse "",
+        req.header("sec-websocket-protocol") orelse "",
+        req.header("sec-websocket-extension") orelse "",
+        upgrade_ctx,
+    );
+}
+
+/// Every message is to use `.binary`/`ArrayBuffer` transport mode. The first byte
+/// indicates a Message ID; see comments on each type for how to interpret the rest.
+///
+/// This format is only intended for communication via the browser and DevServer.
+/// Server-side HMR is implemented using a different interface. This API is not
+/// versioned alongside Bun; breaking changes may occur at any point.
+///
+/// All integers are sent in little-endian
+pub const MessageId = enum(u8) {
+    /// Version payload. Sent on connection startup. The client should issue a
+    /// hard-reload when it mismatches with its `config.version`.
+    version = 'V',
+    /// Sent on a successful bundle, containing client code, updates routes, and
+    /// changed CSS files. Emitted on the `.hot_update` topic.
+    ///
+    /// - For each server-side updated route:
+    ///   - `i32`: Route Bundle ID
+    /// - `i32`: -1 to indicate end of list
+    /// - For each route stylesheet lists affected:
+    ///   - `i32`: Route Bundle ID
+    ///   - `u32`: Length of route pattern
+    ///   - `[n]u8` UTF-8: Route pattern
+    ///   - `u32`: Number of CSS attachments: For Each
+    ///     - `[16]u8` ASCII: CSS identifier
+    /// - `i32`: -1 to indicate end of list
+    /// - `u32`: Number of CSS mutations. For Each:
+    ///   - `[16]u8` ASCII: CSS identifier
+    ///   - `u32`: Length of CSS code
+    ///   - `[n]u8` UTF-8: CSS payload
+    /// - `[n]u8` UTF-8: JS Payload. No length, rest of buffer is text.
+    ///           Can be empty if no client-side code changed.
+    ///
+    /// The first list contains route changes that require a page reload, but
+    /// frameworks can perform via `onServerSideReload`. Fallback behavior
+    /// is to call `location.reload();`
+    ///
+    /// The second list is sent to inform the current list of CSS files
+    /// reachable by a route, recalculated whenever an import is added or
+    /// removed as that can inadvertently affect the CSS list.
+    ///
+    /// The third list contains CSS mutations, which are when the underlying
+    /// CSS file itself changes.
+    ///
+    /// The JS payload is the remaining data. If defined, it can be passed to
+    /// `eval`, resulting in an object of new module callables.
+    hot_update = 'u',
+    /// Sent when the list of errors changes.
+    ///
+    /// - `u32`: Removed errors. For Each:
+    ///   - `u32`: Error owner
+    /// - Remainder are added errors. For Each:
+    ///   - `SerializedFailure`: Error Data
+    errors = 'e',
+    /// A message from the browser. This is used to communicate.
+    /// - `u32`: Unique ID for the browser tab. Each tab gets a different ID
+    /// - `[n]u8`: Opaque bytes, untouched from `IncomingMessageId.browser_error`
+    browser_message = 'b',
+    /// Sent to clear the messages from `browser_error`
+    /// - For each removed ID:
+    ///   - `u32`: Unique ID for the browser tab.
+    browser_message_clear = 'B',
+    /// Sent when a request handler error is emitted. Each route will own at
+    /// most 1 error, where sending a new request clears the original one.
+    ///
+    /// - `u32`: Removed errors. For Each:
+    ///   - `u32`: Error owner
+    /// - `u32`: Length of route pattern
+    /// - `[n]u8`: UTF-8 Route pattern
+    /// - `SerializedFailure`: The one error list for the request
+    request_handler_error = 'h',
+    /// Payload for `incremental_visualizer.html`. This can be accessed via
+    /// `/_bun/incremental_visualizer`. This contains both graphs.
+    ///
+    /// - `u32`: Number of files in `client_graph`. For Each:
+    ///   - `u32`: Length of name. If zero then no other fields are provided.
+    ///   - `[n]u8`: File path in UTF-8 encoded text
+    ///   - `u8`: If file is stale, set 1
+    ///   - `u8`: If file is in server graph, set 1
+    ///   - `u8`: If file is in ssr graph, set 1
+    ///   - `u8`: If file is a server-side route root, set 1
+    ///   - `u8`: If file is a server-side component boundary file, set 1
+    /// - `u32`: Number of files in the server graph. For Each:
+    ///   - Repeat the same parser for the client graph
+    /// - `u32`: Number of client edges. For Each:
+    ///   - `u32`: File index of the dependency file
+    ///   - `u32`: File index of the imported file
+    /// - `u32`: Number of server edges. For Each:
+    ///   - `u32`: File index of the dependency file
+    ///   - `u32`: File index of the imported file
+    visualizer = 'v',
+
+    pub inline fn char(id: MessageId) u8 {
+        return @intFromEnum(id);
+    }
+};
+
+pub const IncomingMessageId = enum(u8) {
+    /// Subscribe to an event channel. Payload is a sequence of chars available
+    /// in HmrTopic.
+    subscribe = 's',
+    // /// Subscribe to `.route_manifest` events. No payload.
+    // subscribe_route_manifest = 'r',
+    // /// Emit a hot update for a file without actually changing its on-disk
+    // /// content. This can be used by an editor extension to stream contents in
+    // /// IDE to reflect in the browser. This is gated to only work on localhost
+    // /// socket connections.
+    // virtual_file_change = 'w',
+    /// Emitted on client-side navigations.
+    /// Rest of payload is a UTF-8 string.
+    set_url = 'n',
+    /// Emit a message from the browser. Payload is opaque bytes that DevServer
+    /// does not care about. In practice, the payload is a JSON object.
+    browser_message = 'm',
+
+    /// Invalid data
+    _,
+};
+
+const HmrTopic = enum(u8) {
+    hot_update = 'h',
+    errors = 'e',
+    browser_error = 'E',
+    visualizer = 'v',
+    // route_manifest = 'r',
+
+    /// Invalid data
+    _,
+
+    pub const max_count = @typeInfo(HmrTopic).Enum.fields.len;
+    pub const Bits = @Type(.{ .Struct = .{
+        .backing_integer = @Type(.{ .Int = .{
+            .bits = max_count,
+            .signedness = .unsigned,
+        } }),
+        .fields = &brk: {
+            const enum_fields = @typeInfo(HmrTopic).Enum.fields;
+            var fields: [enum_fields.len]std.builtin.Type.StructField = undefined;
+            for (enum_fields, &fields) |e, *s| {
+                s.* = .{
+                    .name = e.name,
+                    .type = bool,
+                    .default_value = &false,
+                    .is_comptime = false,
+                    .alignment = 0,
+                };
+            }
+            break :brk fields;
+        },
+        .decls = &.{},
+        .is_tuple = false,
+        .layout = .@"packed",
+    } });
+};
+
+const HmrSocket = struct {
+    dev: *DevServer,
+    subscriptions: HmrTopic.Bits,
+    /// Allows actions which inspect or mutate sensitive DevServer state.
+    is_from_localhost: bool,
+    /// By telling DevServer the active route, this enables receiving detailed
+    /// `hot_update` events for when the route is updated.
+    active_route: RouteBundle.Index.Optional,
+    /// Files which the client definitely has and should not be re-sent
+    pub fn onOpen(s: *HmrSocket, ws: AnyWebSocket) void {
+        _ = ws.send(&(.{MessageId.version.char()} ++ s.dev.configuration_hash_key), .binary, false, true);
+    }
+
+    pub fn onMessage(s: *HmrSocket, ws: AnyWebSocket, msg: []const u8, opcode: uws.Opcode) void {
+        _ = opcode;
+
+        if (msg.len == 0) {
+            ws.close();
+            return;
+        }
+
+        switch (@as(IncomingMessageId, @enumFromInt(msg[0]))) {
+            .subscribe => {
+                var new_bits: HmrTopic.Bits = .{};
+                const topics = msg[1..];
+                if (topics.len > HmrTopic.max_count) return;
+                outer: for (topics) |char| {
+                    inline for (@typeInfo(HmrTopic).Enum.fields) |field| {
+                        if (char == field.value) {
+                            @field(new_bits, field.name) = true;
+                            continue :outer;
+                        }
+                    }
+                }
+                inline for (comptime std.enums.values(HmrTopic)) |field| {
+                    if (@field(new_bits, @tagName(field)) and !@field(s.subscriptions, @tagName(field))) {
+                        _ = ws.subscribe(&.{@intFromEnum(field)});
+
+                        // on-subscribe hooks
+                        switch (field) {
+                            .visualizer => {
+                                s.dev.emit_visualizer_events += 1;
+                                s.dev.emitVisualizerMessageIfNeeded() catch bun.outOfMemory();
+                            },
+                            else => {},
+                        }
+                    } else if (@field(new_bits, @tagName(field)) and !@field(s.subscriptions, @tagName(field))) {
+                        _ = ws.unsubscribe(&.{@intFromEnum(field)});
+
+                        // on-unsubscribe hooks
+                        switch (field) {
+                            .visualizer => {
+                                s.dev.emit_visualizer_events -= 1;
+                            },
+                            else => {},
+                        }
+                    }
+                }
+            },
+            .set_url => {
+                const pattern = msg[1..];
+                var params: FrameworkRouter.MatchedParams = undefined;
+                if (s.dev.router.matchSlow(pattern, &params)) |route| {
+                    const rbi = s.dev.getOrPutRouteBundle(route) catch bun.outOfMemory();
+                    if (s.active_route.unwrap()) |old| {
+                        if (old == rbi) return;
+                        s.dev.routeBundlePtr(old).active_viewers -= 1;
+                    }
+                    s.dev.routeBundlePtr(rbi).active_viewers += 1;
+                }
+            },
+            else => ws.close(),
+        }
+    }
+
+    pub fn onClose(s: *HmrSocket, ws: AnyWebSocket, exit_code: i32, message: []const u8) void {
+        _ = ws;
+        _ = exit_code;
+        _ = message;
+
+        if (s.subscriptions.visualizer) {
+            s.dev.emit_visualizer_events -= 1;
+        }
+
+        if (s.active_route.unwrap()) |old| {
+            s.dev.routeBundlePtr(old).active_viewers -= 1;
+        }
+
+        defer s.dev.allocator.destroy(s);
+    }
+};
+
+const c = struct {
+    // BakeSourceProvider.cpp
+    extern fn BakeGetDefaultExportFromModule(global: *JSC.JSGlobalObject, module: JSValue) JSValue;
+
+    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: *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",
+        });
+        return f(global, code, separate_ssr_graph).unwrap();
+    }
+};
+
+/// Called on DevServer thread via HotReloadTask
+pub fn startReloadBundle(dev: *DevServer, event: *HotReloadEvent) bun.OOM!void {
+    defer event.files.clearRetainingCapacity();
+
+    var sfb = std.heap.stackFallback(4096, bun.default_allocator);
+    const temp_alloc = sfb.get();
+    var entry_points: EntryPointList = EntryPointList.empty;
+    defer entry_points.deinit(temp_alloc);
+
+    event.processFileList(dev, &entry_points, temp_alloc);
+    if (entry_points.set.count() == 0) {
+        Output.debugWarn("nothing to bundle. watcher may potentially be watching too many files.", .{});
+        return;
+    }
+
+    dev.startAsyncBundle(
+        entry_points,
+        true,
+        event.timer,
+    ) catch |err| {
+        bun.handleErrorReturnTrace(err, @errorReturnTrace());
+        return;
+    };
+}
+
+fn markAllRouteChildren(router: *FrameworkRouter, comptime n: comptime_int, bits: [n]*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| {
+            inline for (bits) |b|
+                b.set(index.get());
+        }
+        markAllRouteChildren(router, n, bits, child_index);
+        next = route.next_sibling.unwrap();
+    }
+}
+
+fn markAllRouteChildrenFailed(dev: *DevServer, route_index: Route.Index) void {
+    var next = dev.router.routePtr(route_index).first_child.unwrap();
+    while (next) |child_index| {
+        const route = dev.router.routePtr(child_index);
+        if (route.bundle.unwrap()) |index| {
+            dev.routeBundlePtr(index).server_state = .possible_bundling_failures;
+        }
+        markAllRouteChildrenFailed(dev, child_index);
+        next = route.next_sibling.unwrap();
+    }
+}
+
+/// This task informs the DevServer's thread about new files to be bundled.
+pub const HotReloadEvent = struct {
+    /// Align to cache lines to eliminate contention.
+    const Aligned = struct { aligned: HotReloadEvent align(std.atomic.cache_line) };
+
+    owner: *DevServer,
+    /// Initialized in WatcherAtomics.watcherReleaseAndSubmitEvent
+    concurrent_task: JSC.ConcurrentTask,
+    /// The watcher is not able to peek into the incremental graph to know what
+    /// files to invalidate, so the watch events are de-duplicated and passed
+    /// along.
+    files: bun.StringArrayHashMapUnmanaged(Watcher.Event.Op),
+    /// Initialized by the WatcherAtomics.watcherAcquireEvent
+    timer: std.time.Timer,
+    /// This event may be referenced by either DevServer or Watcher thread.
+    /// 1 if referenced, 0 if unreferenced; see WatcherAtomics
+    contention_indicator: std.atomic.Value(u32),
+
+    pub fn initEmpty(owner: *DevServer) HotReloadEvent {
+        return .{
+            .owner = owner,
+            .concurrent_task = undefined,
+            .files = .{},
+            .timer = undefined,
+            .contention_indicator = std.atomic.Value(u32).init(0),
+        };
+    }
+
+    pub fn append(
+        event: *HotReloadEvent,
+        allocator: Allocator,
+        file_path: []const u8,
+        op: Watcher.Event.Op,
+    ) void {
+        const gop = event.files.getOrPut(allocator, file_path) catch bun.outOfMemory();
+        if (gop.found_existing) {
+            gop.value_ptr.* = gop.value_ptr.merge(op);
+        } else {
+            gop.value_ptr.* = op;
+        }
+    }
+
+    /// Invalidates items in IncrementalGraph, appending all new items to `entry_points`
+    pub fn processFileList(
+        event: *HotReloadEvent,
+        dev: *DevServer,
+        entry_points: *EntryPointList,
+        alloc: Allocator,
+    ) void {
+        const changed_file_paths = event.files.keys();
+        // TODO: check for .delete and remove items from graph. this has to be done
+        // with care because some editors save by deleting and recreating the file.
+        // delete events are not to be trusted at face value. also, merging of
+        // events can cause .write and .delete to be true at the same time.
+        const changed_file_attributes = event.files.values();
+        _ = changed_file_attributes;
+
+        {
+            dev.graph_safety_lock.lock();
+            defer dev.graph_safety_lock.unlock();
+
+            inline for (.{ &dev.server_graph, &dev.client_graph }) |g| {
+                g.invalidate(changed_file_paths, entry_points, alloc) catch bun.outOfMemory();
+            }
+        }
+    }
+
+    pub fn run(first: *HotReloadEvent) void {
+        debug.log("HMR Task start", .{});
+        defer debug.log("HMR Task end", .{});
+
+        const dev = first.owner;
+        if (Environment.allow_assert) {
+            assert(first.contention_indicator.load(.seq_cst) == 0);
+        }
+
+        if (dev.current_bundle != null) {
+            dev.next_bundle.reload_event = first;
+            return;
+        }
+
+        // defer event.files.clearRetainingCapacity();
+
+        var sfb = std.heap.stackFallback(4096, bun.default_allocator);
+        const temp_alloc = sfb.get();
+        var entry_points: EntryPointList = EntryPointList.empty;
+        defer entry_points.deinit(temp_alloc);
+
+        first.processFileList(dev, &entry_points, temp_alloc);
+        const timer = first.timer;
+
+        if (dev.watcher_atomics.recycleEventFromDevServer(first)) |second| {
+            second.processFileList(dev, &entry_points, temp_alloc);
+            dev.watcher_atomics.recycleSecondEventFromDevServer(second);
+        }
+
+        if (entry_points.set.count() == 0) {
+            Output.debugWarn("nothing to bundle. watcher may potentially be watching too many files.", .{});
+            return;
+        }
+
+        dev.startAsyncBundle(
+            entry_points,
+            true,
+            timer,
+        ) catch |err| {
+            bun.handleErrorReturnTrace(err, @errorReturnTrace());
+            return;
+        };
+    }
+};
+
+/// All code working with atomics to communicate watcher is in this struct. It
+/// attempts to recycle as much memory as possible since files are very
+/// frequently updated.
+const WatcherAtomics = struct {
+    const log = Output.scoped(.DevServerWatchAtomics, true);
+
+    /// Only two hot-reload tasks exist ever, since only one bundle may be active at
+    /// once. Memory is reused by swapping between these two. These items are
+    /// aligned to cache lines to reduce contention, since these structures are
+    /// carefully passed between two threads.
+    events: [2]HotReloadEvent.Aligned align(std.atomic.cache_line),
+    /// 0  - no watch
+    /// 1  - has fired additional watch
+    /// 2+ - new events available, watcher is waiting on bundler to finish
+    watcher_events_emitted: std.atomic.Value(u32),
+    /// Which event is the watcher holding on to.
+    /// This is not atomic because only the watcher thread uses this value.
+    current: u1 align(std.atomic.cache_line),
+
+    watcher_has_event: std.debug.SafetyLock,
+    dev_server_has_event: std.debug.SafetyLock,
+
+    pub fn init(dev: *DevServer) WatcherAtomics {
+        return .{
+            .events = .{
+                .{ .aligned = HotReloadEvent.initEmpty(dev) },
+                .{ .aligned = HotReloadEvent.initEmpty(dev) },
+            },
+            .current = 0,
+            .watcher_events_emitted = std.atomic.Value(u32).init(0),
+            .watcher_has_event = .{},
+            .dev_server_has_event = .{},
+        };
+    }
+
+    /// Atomically get a *HotReloadEvent that is not used by the DevServer thread
+    /// Call `watcherRelease` when it is filled with files.
+    fn watcherAcquireEvent(state: *WatcherAtomics) *HotReloadEvent {
+        state.watcher_has_event.lock();
+
+        var ev: *HotReloadEvent = &state.events[state.current].aligned;
+        switch (ev.contention_indicator.swap(1, .seq_cst)) {
+            0 => {
+                // New event, initialize the timer if it is empty.
+                if (ev.files.count() == 0)
+                    ev.timer = std.time.Timer.start() catch unreachable;
+            },
+            1 => {
+                // @branchHint(.unlikely);
+                // DevServer stole this event. Unlikely but possible when
+                // the user is saving very heavily (10-30 times per second)
+                state.current +%= 1;
+                ev = &state.events[state.current].aligned;
+                if (Environment.allow_assert) {
+                    bun.assert(ev.contention_indicator.swap(1, .seq_cst) == 0);
+                }
+            },
+            else => unreachable,
+        }
+
+        ev.owner.bun_watcher.thread_lock.assertLocked();
+
+        return ev;
+    }
+
+    /// Release the pointer from `watcherAcquireHotReloadEvent`, submitting
+    /// the event if it contains new files.
+    fn watcherReleaseAndSubmitEvent(state: *WatcherAtomics, ev: *HotReloadEvent) void {
+        state.watcher_has_event.unlock();
+        ev.owner.bun_watcher.thread_lock.assertLocked();
+
+        if (ev.files.count() > 0) {
+            // @branchHint(.likely);
+            // There are files to be processed, increment this count first.
+            const prev_count = state.watcher_events_emitted.fetchAdd(1, .seq_cst);
+
+            if (prev_count == 0) {
+                // @branchHint(.likely);
+                // Submit a task to the DevServer, notifying it that there is
+                // work to do. The watcher will move to the other event.
+                ev.concurrent_task = .{
+                    .auto_delete = false,
+                    .next = null,
+                    .task = JSC.Task.init(ev),
+                };
+                ev.contention_indicator.store(0, .seq_cst);
+                ev.owner.vm.event_loop.enqueueTaskConcurrent(&ev.concurrent_task);
+                state.current +%= 1;
+            } else {
+                // DevServer thread has already notified once. Sending
+                // a second task would give ownership of both events to
+                // them. Instead, DevServer will steal this item since
+                // it can observe `watcher_events_emitted >= 2`.
+                ev.contention_indicator.store(0, .seq_cst);
+            }
+        } else {
+            ev.contention_indicator.store(0, .seq_cst);
+        }
+
+        if (Environment.allow_assert) {
+            bun.assert(ev.contention_indicator.load(.monotonic) == 0); // always must be reset
+        }
+    }
+
+    /// Called by DevServer after it receives a task callback. If this returns
+    /// another event, that event must be recycled with `recycleSecondEventFromDevServer`
+    fn recycleEventFromDevServer(state: *WatcherAtomics, first_event: *HotReloadEvent) ?*HotReloadEvent {
+        first_event.files.clearRetainingCapacity();
+        first_event.timer = undefined;
+
+        // Reset the watch count to zero, while detecting if
+        // the other watch event was submitted.
+        if (state.watcher_events_emitted.swap(0, .seq_cst) >= 2) {
+            // Cannot use `state.current` because it will contend with the watcher.
+            // Since there are are two events, one pointer comparison suffices
+            const other_event = if (first_event == &state.events[0].aligned)
+                &state.events[1].aligned
+            else
+                &state.events[0].aligned;
+
+            switch (other_event.contention_indicator.swap(1, .seq_cst)) {
+                0 => {
+                    // DevServer holds the event now.
+                    state.dev_server_has_event.lock();
+                    return other_event;
+                },
+                1 => {
+                    // The watcher is currently using this event.
+                    // `watcher_events_emitted` is already zero, so it will
+                    // always submit.
+
+                    // Not 100% confident in this logic, but the only way
+                    // to hit this is by saving extremely frequently, and
+                    // a followup save will just trigger the reload.
+                    return null;
+                },
+                else => unreachable,
+            }
+        }
+
+        // If a watch callback had already acquired the event, that is fine as
+        // it will now read 0 when deciding if to submit the task.
+        return null;
+    }
+
+    fn recycleSecondEventFromDevServer(state: *WatcherAtomics, second_event: *HotReloadEvent) void {
+        second_event.files.clearRetainingCapacity();
+        second_event.timer = undefined;
+
+        state.dev_server_has_event.unlock();
+        if (Environment.allow_assert) {
+            const result = second_event.contention_indicator.swap(0, .seq_cst);
+            bun.assert(result == 1);
+        } else {
+            second_event.contention_indicator.store(0, .seq_cst);
+        }
+    }
+};
+
+/// Called on watcher's thread; Access to dev-server state restricted.
+pub fn onFileUpdate(dev: *DevServer, events: []Watcher.Event, changed_files: []?[:0]u8, watchlist: Watcher.ItemList) void {
+    _ = changed_files;
+
+    debug.log("onFileUpdate start", .{});
+    defer debug.log("onFileUpdate end", .{});
+
+    const slice = watchlist.slice();
+    const file_paths = slice.items(.file_path);
+    const counts = slice.items(.count);
+    const kinds = slice.items(.kind);
+
+    const ev = dev.watcher_atomics.watcherAcquireEvent();
+    defer dev.watcher_atomics.watcherReleaseAndSubmitEvent(ev);
+
+    defer dev.bun_watcher.flushEvictions();
+
+    // TODO: alot of code is missing
+    // TODO: story for busting resolution cache smartly?
+    for (events) |event| {
+        const file_path = file_paths[event.index];
+        const update_count = counts[event.index] + 1;
+        counts[event.index] = update_count;
+        const kind = kinds[event.index];
+
+        debug.log("{s} change: {s} {}", .{ @tagName(kind), file_path, event.op });
+
+        switch (kind) {
+            .file => {
+                if (event.op.delete or event.op.rename) {
+                    dev.bun_watcher.removeAtIndex(event.index, 0, &.{}, .file);
+                }
+
+                ev.append(dev.allocator, file_path, event.op);
+            },
+            .directory => {
+                // bust the directory cache since this directory has changed
+                _ = dev.server_bundler.resolver.bustDirCache(bun.strings.withoutTrailingSlashWindowsPath(file_path));
+
+                // if a directory watch exists for resolution
+                // failures, check those now.
+                dev.directory_watchers.lock.lock();
+                defer dev.directory_watchers.lock.unlock();
+                if (dev.directory_watchers.watches.getIndex(file_path)) |watcher_index| {
+                    const entry = &dev.directory_watchers.watches.values()[watcher_index];
+                    var new_chain: DirectoryWatchStore.Dep.Index.Optional = .none;
+                    var it: ?DirectoryWatchStore.Dep.Index = entry.first_dep;
+
+                    while (it) |index| {
+                        const dep = &dev.directory_watchers.dependencies.items[index.get()];
+                        it = dep.next.unwrap();
+                        if ((dev.server_bundler.resolver.resolve(
+                            bun.path.dirname(dep.source_file_path, .auto),
+                            dep.specifier,
+                            .stmt,
+                        ) catch null) != null) {
+                            // the resolution result is not preserved as safely
+                            // transferring it into BundleV2 is too complicated. the
+                            // resolution is cached, anyways.
+                            ev.append(dev.allocator, dep.source_file_path, .{ .write = true });
+                            dev.directory_watchers.freeDependencyIndex(dev.allocator, index) catch bun.outOfMemory();
+                        } else {
+                            // rebuild a new linked list for unaffected files
+                            dep.next = new_chain;
+                            new_chain = index.toOptional();
+                        }
+                    }
+
+                    if (new_chain.unwrap()) |new_first_dep| {
+                        entry.first_dep = new_first_dep;
+                    } else {
+                        // without any files to depend on this watcher is freed
+                        dev.directory_watchers.freeEntry(watcher_index);
+                    }
+                }
+            },
+        }
+    }
+}
+
+pub fn onWatchError(_: *DevServer, err: bun.sys.Error) void {
+    // TODO: how to recover? the watcher can't just ... crash????????
+    Output.err(@as(bun.C.E, @enumFromInt(err.errno)), "Watcher crashed", .{});
+    if (bun.Environment.isDebug) {
+        bun.todoPanic(@src(), "Watcher crash", .{});
+    }
+}
+
+pub fn publish(dev: *DevServer, topic: HmrTopic, message: []const u8, opcode: uws.Opcode) void {
+    if (dev.server) |s| _ = s.publish(&.{@intFromEnum(topic)}, message, opcode, false);
+}
+
+pub fn numSubscribers(dev: *DevServer, topic: HmrTopic) u32 {
+    return if (dev.server) |s| s.numSubscribers(&.{@intFromEnum(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);
+}
+
+pub fn onRouterSyntaxError(dev: *DevServer, rel_path: []const u8, log: FrameworkRouter.TinyLog) bun.OOM!void {
+    _ = dev; // TODO: maybe this should track the error, send over HmrSocket?
+    log.print(rel_path);
+}
+
+pub fn onRouterCollisionError(dev: *DevServer, rel_path: []const u8, other_id: OpaqueFileId, ty: Route.FileKind) bun.OOM!void {
+    // TODO: maybe this should track the error, send over HmrSocket?
+
+    Output.errGeneric("Multiple {s} matching the same route pattern is ambiguous", .{
+        switch (ty) {
+            .page => "pages",
+            .layout => "layout",
+        },
+    });
+    Output.prettyErrorln("  - <blue>{s}<r>", .{rel_path});
+    Output.prettyErrorln("  - <blue>{s}<r>", .{
+        dev.relativePath(dev.server_graph.bundled_files.keys()[fromOpaqueFileId(.server, other_id).get()]),
+    });
+    Output.flush();
+}
+
+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 ..];
+    }
+    const rel = bun.path.relative(dev.root, path);
+    // `rel` is owned by a mutable threadlocal buffer in the path code.
+    bun.path.platformToPosixInPlace(u8, @constCast(rel));
+    return rel;
+}
+
+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 file for dumping incremental graph: {}", .{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) {
+    route_index: Route.Index,
+    /// Set true for layout
+    should_recurse_when_visiting: bool,
+};
+
+/// Bake needs to specify which graph (client/server/ssr) each entry point is.
+/// File paths are always absolute paths. Files may be bundled for multiple
+/// targets.
+pub const EntryPointList = struct {
+    set: bun.StringArrayHashMapUnmanaged(Flags),
+
+    pub const empty: EntryPointList = .{ .set = .{} };
+
+    const Flags = packed struct(u8) {
+        client: bool = false,
+        server: bool = false,
+        ssr: bool = false,
+        /// When this is set, also set .client = true
+        css: bool = false,
+        // /// Indicates the file might have been deleted.
+        // potentially_deleted: bool = false,
+
+        unused: enum(u4) { unused = 0 } = .unused,
+    };
+
+    pub fn deinit(entry_points: *EntryPointList, allocator: std.mem.Allocator) void {
+        entry_points.set.deinit(allocator);
+    }
+
+    pub fn appendJs(
+        entry_points: *EntryPointList,
+        allocator: std.mem.Allocator,
+        abs_path: []const u8,
+        side: bake.Graph,
+    ) !void {
+        return entry_points.append(allocator, abs_path, switch (side) {
+            .server => .{ .server = true },
+            .client => .{ .client = true },
+            .ssr => .{ .ssr = true },
+        });
+    }
+
+    pub fn appendCss(entry_points: *EntryPointList, allocator: std.mem.Allocator, abs_path: []const u8) !void {
+        return entry_points.append(allocator, abs_path, .{
+            .client = true,
+            .css = true,
+        });
+    }
+
+    /// Deduplictes requests to bundle the same file twice.
+    pub fn append(entry_points: *EntryPointList, allocator: std.mem.Allocator, abs_path: []const u8, flags: Flags) !void {
+        const gop = try entry_points.set.getOrPut(allocator, abs_path);
+        if (gop.found_existing) {
+            const T = @typeInfo(Flags).Struct.backing_integer.?;
+            gop.value_ptr.* = @bitCast(@as(T, @bitCast(gop.value_ptr.*)) | @as(T, @bitCast(flags)));
+        } else {
+            gop.value_ptr.* = flags;
+        }
+    }
+};
+
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const Mutex = std.Thread.Mutex;
+const ArrayListUnmanaged = std.ArrayListUnmanaged;
+const AutoArrayHashMapUnmanaged = std.AutoArrayHashMapUnmanaged;
+
+const bun = @import("root").bun;
+const Environment = bun.Environment;
+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;
+
+const Bundler = bun.bundler.Bundler;
+const BundleV2 = bun.bundle_v2.BundleV2;
+
+const Define = bun.options.Define;
+const OutputFile = bun.options.OutputFile;
+
+const uws = bun.uws;
+const App = uws.NewApp(false);
+const AnyWebSocket = uws.AnyWebSocket;
+const Request = uws.Request;
+const Response = App.Response;
+
+const MimeType = bun.http.MimeType;
+
+const JSC = bun.JSC;
+const Watcher = bun.JSC.Watcher;
+const JSValue = JSC.JSValue;
+const VirtualMachine = JSC.VirtualMachine;
+const JSModuleLoader = JSC.JSModuleLoader;
+const EventLoopHandle = JSC.EventLoopHandle;
+const JSInternalPromise = JSC.JSInternalPromise;
+
+const ThreadlocalArena = @import("../mimalloc_arena.zig").Arena;
diff --git a/src/bake/FrameworkRouter.zig b/src/bake/FrameworkRouter.zig
new file mode 100644
index 0000000000..f9c7a24d90
--- /dev/null
+++ b/src/bake/FrameworkRouter.zig
@@ -0,0 +1,1322 @@
+//! Discovers routes from the filesystem, as instructed by the framework
+//! 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 {});
+
+/// Absolute path to root directory of the router.
+root: []const u8,
+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,
+    allow_layouts: bool,
+    /// `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(root: []const u8, types: []Type, allocator: Allocator) !FrameworkRouter {
+    bun.assert(std.fs.path.isAbsolute(root));
+
+    var routes = try std.ArrayListUnmanaged(Route).initCapacity(allocator, types.len);
+    errdefer routes.deinit(allocator);
+
+    for (types, 0..) |*ty, type_index| {
+        ty.abs_root = bun.strings.withoutTrailingSlashWindowsPath(ty.abs_root);
+        bun.assert(bun.strings.hasPrefix(ty.abs_root, root));
+
+        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 .{
+        .root = bun.strings.withoutTrailingSlashWindowsPath(root),
+        .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 = union(enum) {
+    nextjs_pages,
+    nextjs_app_ui,
+    nextjs_app_routes,
+    javascript_defined: JSC.Strong,
+
+    pub const map = bun.ComptimeStringMap(Style, .{
+        .{ "nextjs-pages", .nextjs_pages },
+        .{ "nextjs-app-ui", .nextjs_app_ui },
+        .{ "nextjs-app-routes", .nextjs_app_routes },
+    });
+    pub const error_message = "'style' must be either \"nextjs-pages\", \"nextjs-app-ui\", \"nextjs-app-routes\", or a function.";
+
+    pub fn fromJS(value: JSValue, global: *JSC.JSGlobalObject) !Style {
+        if (value.isString()) {
+            const bun_string = try value.toBunString2(global);
+            var sfa = std.heap.stackFallback(4096, bun.default_allocator);
+            const utf8 = bun_string.toUTF8(sfa.get());
+            defer utf8.deinit();
+            if (map.get(utf8.slice())) |style| {
+                return style;
+            }
+        } else if (value.isCallable(global.vm())) {
+            return .{ .javascript_defined = JSC.Strong.create(value, global) };
+        }
+
+        return global.throwInvalidArguments(error_message, .{});
+    }
+
+    pub fn deinit(style: *Style) void {
+        switch (style.*) {
+            .javascript_defined => |*strong| strong.deinit(),
+            else => {},
+        }
+    }
+
+    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, allow_layouts: bool, arena: Allocator) !?ParsedPattern {
+        bun.assert(file_path[0] == '/');
+
+        return switch (style) {
+            .nextjs_pages => parseNextJsPages(file_path, ext, log, allow_layouts, arena),
+            .nextjs_app_ui => parseNextJsApp(file_path, ext, log, allow_layouts, arena, .ui),
+            .nextjs_app_routes => parseNextJsApp(file_path, ext, log, allow_layouts, arena, .routes),
+
+            // The strategy for this should be to collect a list of candidates,
+            // then batch-call the javascript handler and collect all results.
+            // This will avoid most of the back-and-forth native<->js overhead.
+            .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, allow_layouts: bool, arena: Allocator) !?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 (allow_layouts 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,
+        allow_layouts: bool,
+        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;
+
+        if (kind == .layout and !allow_layouts) 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.
+/// DevServer uses this to special-case the printing of these messages to highlight the offending part of the filename
+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.write(fmt, args);
+        log.cursor_at = @intCast(cursor_at);
+        log.cursor_len = @intCast(cursor_len);
+        return PatternParseError.InvalidRoutePattern;
+    }
+
+    pub fn write(log: *TinyLog, comptime fmt: []const u8, args: anytype) void {
+        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;
+        });
+    }
+
+    pub fn print(log: *const TinyLog, rel_path: []const u8) void {
+        const after = rel_path[@max(0, log.cursor_at)..];
+        bun.Output.errGeneric("\"{s}<blue>{s}<r>{s}\" is not a valid route", .{
+            rel_path[0..@max(0, log.cursor_at)],
+            after[0..@min(log.cursor_len, after.len)],
+            after[@min(log.cursor_len, after.len)..],
+        });
+        const w = bun.Output.errorWriterBuffered();
+        w.writeByteNTimes(' ', "error: \"".len + log.cursor_at) catch return;
+        if (bun.Output.enable_ansi_colors_stderr) {
+            const symbols = bun.fmt.TableSymbols.unicode;
+            bun.Output.prettyError("<blue>" ++ symbols.topColumnSep(), .{});
+            if (log.cursor_len > 1) {
+                w.writeBytesNTimes(symbols.horizontalEdge(), log.cursor_len - 1) catch return;
+            }
+        } else {
+            if (log.cursor_len <= 1) {
+                w.writeAll("|") catch return;
+            } else {
+                w.writeByteNTimes('-', log.cursor_len - 1) catch return;
+            }
+        }
+        w.writeByte('\n') catch return;
+        w.writeByteNTimes(' ', "error: \"".len + log.cursor_at) catch return;
+        w.writeAll(log.msg.slice()) catch return;
+        bun.Output.prettyError("<r>\n", .{});
+        bun.Output.flush();
+    }
+};
+
+/// 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,
+        onRouterSyntaxError: *const fn (*anyopaque, rel_path: []const u8, fail: TinyLog) bun.OOM!void,
+        onRouterCollisionError: *const fn (*anyopaque, rel_path: []const u8, other_id: OpaqueFileId, file_kind: Route.FileKind) bun.OOM!void,
+    };
+    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);
+            }
+            fn onRouterSyntaxError(opaque_ctx: *anyopaque, rel_path: []const u8, log: TinyLog) bun.OOM!void {
+                const cast_ctx: *T = @alignCast(@ptrCast(opaque_ctx));
+                if (!@hasDecl(T, "onRouterSyntaxError")) @panic("TODO: onRouterSyntaxError for " ++ @typeName(T));
+                return try cast_ctx.onRouterSyntaxError(rel_path, log);
+            }
+            fn onRouterCollisionError(opaque_ctx: *anyopaque, rel_path: []const u8, other_id: OpaqueFileId, file_kind: Route.FileKind) bun.OOM!void {
+                const cast_ctx: *T = @alignCast(@ptrCast(opaque_ctx));
+                if (!@hasDecl(T, "onRouterCollisionError")) @panic("TODO: onRouterCollisionError for " ++ @typeName(T));
+                return try cast_ctx.onRouterCollisionError(rel_path, other_id, file_kind);
+            }
+        };
+        return .{
+            .opaque_ctx = ctx,
+            .vtable = comptime &.{
+                .getFileIdForRouter = &wrapper.getFileIdForRouter,
+                .onRouterSyntaxError = &wrapper.onRouterSyntaxError,
+                .onRouterCollisionError = &wrapper.onRouterCollisionError,
+            },
+        };
+    }
+};
+
+pub fn scan(
+    fw: *FrameworkRouter,
+    alloc: Allocator,
+    ty: Type.Index,
+    r: *Resolver,
+    ctx: InsertionContext,
+) bun.OOM!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 = r.readDirInfoIgnoreError(t.abs_root) orelse
+        return;
+    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,
+) bun.OOM!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 full_rel_path = bun.path.relativeNormalizedBuf(
+                        rel_path_buf[1..],
+                        fr.root,
+                        fs.abs(&.{ file.dir, file.base() }),
+                        .auto,
+                        true,
+                    );
+                    rel_path_buf[0] = '/';
+                    bun.path.platformToPosixInPlace(u8, rel_path_buf[0..full_rel_path.len]);
+                    const rel_path = if (t.abs_root.len == fr.root.len)
+                        rel_path_buf[0 .. full_rel_path.len + 1]
+                    else
+                        full_rel_path[t.abs_root.len - fr.root.len - 1 ..];
+                    var log = TinyLog.empty;
+                    defer _ = arena_state.reset(.retain_capacity);
+                    const parsed = (t.style.parse(rel_path, ext, &log, t.allow_layouts, arena_state.allocator()) catch {
+                        log.cursor_at += @intCast(t.abs_root.len - fr.root.len);
+                        try ctx.vtable.onRouterSyntaxError(ctx.opaque_ctx, full_rel_path, log);
+                        continue :outer;
+                    }) orelse continue :outer;
+
+                    if (parsed.kind == .page and t.ignore_underscores and bun.strings.hasPrefixComptime(base, "_"))
+                        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) {
+                        log.write("Pattern cannot have more than 64 param", .{});
+                        try ctx.vtable.onRouterSyntaxError(ctx.opaque_ctx, full_rel_path, log);
+                        continue :outer;
+                    }
+
+                    var out_colliding_file_id: OpaqueFileId = undefined;
+
+                    const file_kind: Route.FileKind = switch (parsed.kind) {
+                        .page => .page,
+                        .layout => .layout,
+                        .extra => @panic("TODO: associate extra files with route"),
+                    };
+
+                    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 };
+                            };
+
+                            break :result fr.insert(
+                                alloc,
+                                t_index,
+                                if (has_dynamic_comptime) .dynamic else .static,
+                                pattern,
+                                file_kind,
+                                fs.abs(&.{ file.dir, file.base() }),
+                                ctx,
+                                &out_colliding_file_id,
+                            );
+                        },
+                    };
+
+                    result catch |err| switch (err) {
+                        error.OutOfMemory => |e| return e,
+                        error.RouteCollision => {
+                            try ctx.vtable.onRouterCollisionError(
+                                ctx.opaque_ctx,
+                                full_rel_path,
+                                out_colliding_file_id,
+                                file_kind,
+                            );
+                        },
+                    };
+                },
+            }
+        }
+    }
+}
+
+/// 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,
+    stored_parse_errors: std.ArrayListUnmanaged(struct {
+        // Owned by bun.default_allocator
+        rel_path: []const u8,
+        log: TinyLog,
+    }),
+
+    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.throwInvalidArguments("FrameworkRouter needs an object as it's first argument", .{});
+
+        const root = try opts.getOptional(global, "root", bun.String.Slice) orelse
+            return global.throwInvalidArguments("Missing options.root", .{});
+        defer root.deinit();
+
+        var style = try Style.fromJS(try opts.getOptional(global, "style", JSValue) orelse .undefined, global);
+        errdefer style.deinit();
+
+        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,
+            .allow_layouts = true,
+            // 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(abs_root, types, bun.default_allocator),
+            .files = .{},
+            .stored_parse_errors = .{},
+        });
+
+        try jsfr.router.scan(
+            bun.default_allocator,
+            Type.Index.init(0),
+            &global.bunVM().bundler.resolver,
+            InsertionContext.wrap(JSFrameworkRouter, jsfr),
+        );
+        if (jsfr.stored_parse_errors.items.len > 0) {
+            const arr = JSValue.createEmptyArray(global, jsfr.stored_parse_errors.items.len);
+            for (jsfr.stored_parse_errors.items, 0..) |*item, i| {
+                arr.putIndex(
+                    global,
+                    @intCast(i),
+                    global.createErrorInstance("Invalid route {}: {s}", .{
+                        bun.fmt.quote(item.rel_path),
+                        item.log.msg.slice(),
+                    }),
+                );
+            }
+            return global.throwValue(global.createAggregateErrorWithArray(
+                bun.String.static("Errors scanning routes"),
+                arr,
+            ));
+        }
+
+        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);
+        for (this.stored_parse_errors.items) |i| bun.default_allocator.free(i.rel_path);
+        this.stored_parse_errors.deinit(bun.default_allocator);
+        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.throwInvalidArguments("parseRoutePattern takes two arguments", .{});
+
+        const style_js, const filepath_js = frame.argumentsAsArray(2);
+        const filepath = try filepath_js.toSlice2(global, alloc);
+        defer filepath.deinit();
+        var style = try Style.fromJS(style_js, global);
+        errdefer style.deinit();
+
+        var log = TinyLog.empty;
+        const parsed = style.parse(filepath.slice(), std.fs.path.extension(filepath.slice()), &log, true, alloc) catch |err| switch (err) {
+            error.InvalidRoutePattern => {
+                return global.throw("{s} ({d}:{d})", .{ log.msg.slice(), log.cursor_at, log.cursor_len });
+            },
+            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 onRouterSyntaxError(jsfr: *JSFrameworkRouter, rel_path: []const u8, log: TinyLog) !void {
+        const rel_path_dupe = try bun.default_allocator.dupe(u8, rel_path);
+        errdefer bun.default_allocator.free(rel_path_dupe);
+        try jsfr.stored_parse_errors.append(bun.default_allocator, .{
+            .rel_path = rel_path_dupe,
+            .log = log,
+        });
+    }
+
+    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
new file mode 100644
index 0000000000..3e5a6f9ad0
--- /dev/null
+++ b/src/bake/bake.d.ts
@@ -0,0 +1,611 @@
+// 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 {
+      /**
+       * Bun provides built-in support for using React as a framework by passing
+       * 'react' as the framework name. Otherwise, frameworks are config objects.
+       *
+       * External dependencies:
+       * ```
+       * bun i react@experimental react-dom@experimental react-server-dom-webpack@experimental react-refresh@experimental
+       * ```
+       */
+      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
+      /**
+       * A subset of the options from Bun.build can be configured. While the framework
+       * can also set these options, this property overrides and merges with them.
+       *
+       * @default {}
+       */
+      bundlerOptions?: BundlerOptions | undefined;
+      /**
+       * These plugins are applied after `framework.plugins`
+       */
+      plugins?: BunPlugin[] | undefined;
+    }
+
+    /** Bake only allows a subset of options from `Bun.build` */
+    type BuildConfigSubset = Pick<
+      BuildConfig,
+      "conditions" | "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 by the user (TODO: add options.publicPath)
+      // - 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.
+      // - plugins is specified in the framework object, and currently merge between client and server.
+
+      // 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.
+     */
+    interface Framework {
+      /**
+       * 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 []
+       */
+      fileSystemRouterTypes?: FrameworkFileSystemRouterType[];
+      /**
+       * A list of directories that should be served statically. If the directory
+       * does not exist in the user's project, it is ignored.
+       *
+       * Example: 'public' or 'static'
+       *
+       * Different frameworks have different opinions, some use 'static', some
+       * use 'public'.
+       * @default []
+       */
+      staticRouters?: Array<StaticRouter> | undefined;
+      /**
+       * 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?: 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?: boolean | ReactFastRefreshOptions | undefined;
+      /** Framework bundler plugins load before the user-provided ones. */
+      plugins?: BunPlugin[];
+
+      // /**
+      //  * 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;
+    }
+
+    /** Using `code` here will cause import resolution to happen from the root. */
+    type BuiltInModule = { import: string; code: string } | { import: string; path: string };
+
+    /**
+     * A high-level overview of what server components means exists
+     * in the React Docs: https://react.dev/reference/rsc/server-components
+     *
+     * When enabled, files with "use server" and "use client" directives will get
+     * special processing according to this object, in combination with the
+     * framework-specified entry points for server rendering and browser
+     * interactivity.
+     */
+    interface ServerComponentsOptions {
+      /**
+       * If you are unsure what to set this to for a custom server components
+       * framework, choose 'false'.
+       *
+       * When set `true`, bundling "use client" components for SSR will be
+       * placed in a separate bundling graph without the `react-server`
+       * condition. All imports that stem from here get re-bundled for
+       * this second graph, regardless if they actually differ via this
+       * condition.
+       *
+       * The built in framework config for React enables this flag so that server
+       * components and client components utilize their own versions of React,
+       * despite running in the same process. This facilitates different aspects
+       * of the server and client react runtimes, such as `async` components only
+       * being available on the server.
+       *
+       * 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 { bunBakeGraph: 'ssr' };
+       *
+       * Since these models are so subtley different, there is no default value
+       * provided for this.
+       */
+      separateSSRGraph: boolean;
+      /** Server components runtime for the server */
+      serverRuntimeImportSource: ImportSource;
+      /**
+       * When server code imports client code, a stub module is generated,
+       * where every export calls this export from `serverRuntimeImportSource`.
+       * This is used to implement client components on the server.
+       *
+       * When separateSSRGraph is enabled, the call looks like:
+       *
+       *     export const ClientComp = registerClientReference(
+       *         // A function which may be passed through, it throws an error
+       *         function () { throw new Error('Cannot call client-component on the server') },
+       *
+       *         // The file path. In production, these use hashed strings for
+       *         // compactness and code privacy.
+       *         "src/components/Client.tsx",
+       *
+       *         // The instance id. This is not guaranteed to match the export
+       *         // name the user has given.
+       *         "ClientComp",
+       *     );
+       * 
+       * When separateSSRGraph is disabled, the call looks like:
+       *
+       *     export const ClientComp = registerClientReference(
+       *         function () { ... original user implementation here ... },
+       * 
+       *         // The file path of the client-side file to import in the browser.
+       *         "/_bun/d41d8cd0.js",
+       * 
+       *         // The export within the client-side file to load. This is
+       *         // not guaranteed to match the export name the user has given.
+       *        "ClientComp",
+       *     );
+       * 
+       * While subtle, the parameters in `separateSSRGraph` mode are opaque
+       * strings that have to be looked up in the server manifest. While when
+       * there isn't a separate SSR graph, the two parameters are the actual
+       * URLs to load on the client; The manifest is not required for anything.
+       *
+       * Additionally, the bundler will assemble a component manifest to be used
+       * during rendering.
+       * @default "registerClientReference"
+       */
+      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.
+      //  */
+      // allowAnonymousClientComponents: boolean;
+    }
+
+    /** 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);
+
+    /** 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.
+       * @default false
+       */
+      ignoreUnderscores?: boolean;
+      /**
+       * @default ["node_modules", ".git"]
+       */
+      ignoreDirs?: string[];
+      /**
+       * Extensions to match on.
+       * '*' - any extension
+       * @default (set of all valid JavaScript/TypeScript extensions)
+       */
+      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 {
+      /**
+       * 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 };
+       *     }
+       */
+      getParams?: (paramsMetadata: ParamsMetadata) => Awaitable<GetParamIterator>;
+      /**
+       * When a dynamic build uses static assets, Bun can map content types in the
+       * user's `Accept` header to the different static files.
+       */
+      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 {
+      // No exports
+    }
+
+    interface DevServerHookEntryPoint {
+      default: (dev: DevServerHookAPI) => Awaitable<void>;
+    }
+
+    interface DevServerHookAPI {
+      // TODO:
+    }
+
+    /**
+     * This object and it's children may be re-used between invocations, so it
+     * 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 modules: ReadonlyArray<string>;
+      /**
+       * A list of js files that should be preloaded.
+       *
+       *   <link rel="modulepreload" href="..." />
+       */
+      readonly modulepreload: ReadonlyArray<string>;
+      /**
+       * A list of css files that the route will need to be styled.
+       */
+      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 interface GenericServeOptions {
+    /** Add a fullstack web app to this server using Bun Bake */
+    app?: Bake.Options | undefined;
+  }
+
+  declare interface PluginBuilder {
+    /**
+     * Inject a module into the development server's runtime, to be loaded
+     * before all other user code.
+     */
+    addPreload(...args: any): void;
+  }
+
+  declare interface OnLoadArgs {
+    /**
+     * When using server-components, the same bundle has both client and server
+     * files; A single plugin can operate on files from both module graphs.
+     * Outside of server-components, this will be "client" when the target is
+     * set to "browser" and "server" otherwise.
+     */
+    side: 'server' | 'client';
+  }
+}
+
+/** Available in server-side files only. */
+declare module "bun:bake/server" {
+  // NOTE: The format of these manifests will likely be customizable in the future.
+
+  /**
+   * This follows the requirements for React's Server Components manifest, which
+   * 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 `ssrManifest`
+   */
+  declare const serverManifest: ServerManifest;
+  /**
+   * 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 ssrManifest: SSRManifest;
+
+  /** (insert teaser trailer) */
+  declare const actionManifest: never;
+
+  declare interface ServerManifest {
+    /**
+     * 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]: ServerManifestEntry;
+  }
+
+  declare interface ServerManifestEntry {
+    /**
+     * 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 SSRManifest {
+    /** ServerManifest[...].id */
+    [id: string]: {
+      /** ServerManifest[...].name */
+      [name: string]: SSRManifestEntry;
+    };
+  }
+
+  declare interface SSRManifestEntry {
+    /** Valid specifier to import */
+    specifier: string;
+    /** Export name */
+    name: string;
+  }
+
+}
+
+/** Available in client-side files. */
+declare module "bun:bake/client" {
+  /**
+   * Callback is invoked 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. If
+   * not provided, the client will perform a hard reload.
+   *
+   * Only one callback can be set. This function overwrites the previous one.
+   */
+  export function onServerSideReload(cb: () => void | Promise<void>): Promise<void>;
+}
+
+/** Available during development */
+declare module "bun:bake/dev" {
+  
+};
diff --git a/src/bake/bake.private.d.ts b/src/bake/bake.private.d.ts
new file mode 100644
index 0000000000..204a68f151
--- /dev/null
+++ b/src/bake/bake.private.d.ts
@@ -0,0 +1,109 @@
+type Id = string;
+
+/** Index with same usage as `IncrementalGraph(.client).Index` */
+type FileIndex = number;
+
+interface Config {
+  // Server + Client
+  main: Id;
+
+  // Server
+  separateSSRGraph?: true;
+
+  // Client
+  /** Dev Server's `configuration_hash_key` */
+  version: string;
+  /** If available, this is the Id of `react-refresh/runtime` */
+  refresh?: Id;
+  /**
+   * A list of "roots" that the client is aware of. This includes
+   * the framework entry point, as well as every client component.
+   */
+  roots: FileIndex[];
+}
+
+/**
+ * All modules for the initial bundle.
+ */
+declare const input_graph: Record<string, ModuleLoadFunction>;
+
+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
+ * a window to visually display errors with.
+ */
+declare const side: "client" | "server";
+
+/*
+ * If you are running a debug build of Bun. These debug builds should provide
+ * 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;
+
+declare var __bun_f: any;
+
+// The following interfaces have been transcribed manually.
+
+declare module "react-server-dom-bun/client.browser" {
+  export function createFromReadableStream<T = any>(readable: ReadableStream<Uint8Array>): Promise<T>;
+}
+
+declare module "react-server-dom-bun/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-bun/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-bun/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
new file mode 100644
index 0000000000..134acce3d9
--- /dev/null
+++ b/src/bake/bake.zig
@@ -0,0 +1,808 @@
+//! Bake is Bun's toolkit for building client+server web applications. It
+//! combines `Bun.build` and `Bun.serve`, providing a hot-reloading development
+//! server, server components, and other integrations. Instead of taking the
+//! role as a framework, Bake is tool for frameworks to build on top of.
+
+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,
+    allocations: StringRefList,
+
+    root: []const u8,
+    framework: Framework,
+    bundler_options: SplitBundlerOptions,
+
+    pub fn deinit(options: *UserOptions) void {
+        options.arena.deinit();
+        options.allocations.free();
+        if (options.bundler_options.plugin) |p| p.deinit();
+    }
+
+    /// Currently, this function must run at the top of the event loop.
+    pub fn fromJS(config: JSValue, global: *JSC.JSGlobalObject) !UserOptions {
+        if (!config.isObject()) {
+            return global.throwInvalidArguments("'" ++ 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.empty;
+
+        const framework = try Framework.fromJS(
+            try config.get(global, "framework") orelse {
+                return global.throwInvalidArguments("'" ++ 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 => {
+                    return global.throwOutOfMemory();
+                },
+                else => {
+                    return global.throwError(err, "while querying current working directory");
+                },
+            };
+
+        if (try config.get(global, "plugins")) |plugin_array| {
+            try bundler_options.parsePluginArray(plugin_array, global);
+        }
+
+        return .{
+            .arena = arena,
+            .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 = .{} };
+};
+
+pub const SplitBundlerOptions = struct {
+    plugin: ?*Plugin = null,
+    all: BuildConfigSubset = .{},
+    client: BuildConfigSubset = .{},
+    server: BuildConfigSubset = .{},
+    ssr: BuildConfigSubset = .{},
+
+    pub const empty: SplitBundlerOptions = .{
+        .plugin = null,
+        .all = .{},
+        .client = .{},
+        .server = .{},
+        .ssr = .{},
+    };
+
+    pub fn parsePluginArray(opts: *SplitBundlerOptions, plugin_array: JSValue, global: *JSC.JSGlobalObject) !void {
+        const plugin = opts.plugin orelse Plugin.create(global, .bun);
+        opts.plugin = plugin;
+        const empty_object = JSValue.createEmptyObject(global, 0);
+
+        var iter = plugin_array.arrayIterator(global);
+        while (iter.next()) |plugin_config| {
+            if (!plugin_config.isObject()) {
+                return global.throwInvalidArguments("Expected plugin to be an object", .{});
+            }
+
+            if (try plugin_config.getOptional(global, "name", ZigString.Slice)) |slice| {
+                defer slice.deinit();
+                if (slice.len == 0) {
+                    return global.throwInvalidArguments("Expected plugin to have a non-empty name", .{});
+                }
+            } else {
+                return global.throwInvalidArguments("Expected plugin to have a name", .{});
+            }
+
+            const function = try plugin_config.getFunction(global, "setup") orelse {
+                return global.throwInvalidArguments("Expected plugin to have a setup() function", .{});
+            };
+            const plugin_result = try plugin.addPlugin(function, empty_object, .null, false, true);
+            if (plugin_result.asAnyPromise()) |promise| {
+                promise.setHandled(global.vm());
+                // TODO: remove this call, replace with a promise list that must
+                // be resolved before the first bundle task can begin.
+                global.bunVM().waitForPromise(promise);
+                switch (promise.unwrap(global.vm(), .mark_handled)) {
+                    .pending => unreachable,
+                    .fulfilled => |val| {
+                        _ = val;
+                    },
+                    .rejected => |err| {
+                        return global.throwValue(err);
+                    },
+                }
+            }
+        }
+    }
+};
+
+const BuildConfigSubset = struct {
+    loader: ?bun.Schema.Api.LoaderMap = null,
+    ignoreDCEAnnotations: ?bool = null,
+    conditions: bun.StringArrayHashMapUnmanaged(void) = .{},
+    drop: bun.StringArrayHashMapUnmanaged(void) = .{},
+    // TODO: plugins
+
+    pub fn loadFromJs(config: *BuildConfigSubset, value: JSValue, arena: Allocator) !void {
+        _ = config; // autofix
+        _ = value; // autofix
+        _ = arena; // autofix
+    }
+};
+
+/// 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 {
+    is_built_in_react: bool,
+    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-refresh@experimental react-server-dom-bun
+    pub fn react(arena: std.mem.Allocator) !Framework {
+        return .{
+            .is_built_in_react = true,
+            .server_components = .{
+                .separate_ssr_graph = true,
+                .server_runtime_import = "react-server-dom-bun/server",
+            },
+            .react_fast_refresh = .{},
+            .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,
+                    .allow_layouts = true,
+                },
+            }),
+            // .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-react/client.tsx") },
+                .{ .code = @embedFile("./bun-framework-react/server.tsx") },
+                .{ .code = @embedFile("./bun-framework-react/ssr.tsx") },
+            } else &.{
+                // 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(),
+        };
+    }
+
+    pub 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,
+        allow_layouts: bool,
+    };
+
+    pub const BuiltInModule = union(enum) {
+        import: []const u8,
+        code: []const u8,
+    };
+
+    pub const ServerComponents = struct {
+        separate_ssr_graph: bool = false,
+        server_runtime_import: []const u8,
+        // client_runtime_import: []const u8,
+        server_register_client_reference: []const u8 = "registerClientReference",
+        server_register_server_reference: []const u8 = "registerServerReference",
+        client_register_server_reference: []const u8 = "registerServerReference",
+    };
+
+    const ReactFastRefresh = struct {
+        import_source: []const u8 = "react-refresh/runtime",
+    };
+
+    pub const react_install_command = "bun i react@experimental react-dom@experimental react-refresh@experimental react-server-dom-bun";
+
+    pub fn addReactInstallCommandNote(log: *bun.logger.Log) !void {
+        try log.addMsg(.{
+            .kind = .note,
+            .data = try bun.logger.rangeData(null, bun.logger.Range.none, "Install the built in react integration with \"" ++ react_install_command ++ "\"")
+                .cloneLineText(log.clone_line_text, log.msgs.allocator),
+        });
+    }
+
+    /// Given a Framework configuration, this returns another one with all paths resolved.
+    /// New memory allocated into provided arena.
+    ///
+    /// All resolution errors will happen before returning error.ModuleNotFound
+    /// Errors written into `r.log`
+    pub fn resolve(f: Framework, server: *bun.resolver.Resolver, client: *bun.resolver.Resolver, arena: Allocator) !Framework {
+        var clone = f;
+        var had_errors: bool = false;
+
+        if (clone.react_fast_refresh) |*react_fast_refresh| {
+            f.resolveHelper(client, &react_fast_refresh.import_source, &had_errors, "react refresh runtime");
+        }
+
+        if (clone.server_components) |*sc| {
+            f.resolveHelper(server, &sc.server_runtime_import, &had_errors, "server components runtime");
+            // f.resolveHelper(client, &sc.client_runtime_import, &had_errors);
+        }
+
+        for (clone.file_system_router_types) |*fsr| {
+            fsr.root = try arena.dupe(u8, 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;
+    }
+
+    inline fn resolveHelper(f: *const Framework, r: *bun.resolver.Resolver, path: *[]const u8, had_errors: *bool, desc: []const u8) void {
+        if (f.built_in_modules.get(path.*)) |mod| {
+            switch (mod) {
+                .import => |p| path.* = p,
+                .code => {},
+            }
+            return;
+        }
+
+        var result = r.resolve(r.fs.top_level_dir, path.*, .stmt) catch |err| {
+            bun.Output.err(err, "Failed to resolve '{s}' for framework ({s})", .{ path.*, desc });
+            had_errors.* = true;
+            return;
+        };
+        path.* = result.path().?.text;
+    }
+
+    fn fromJS(
+        opts: JSValue,
+        global: *JSC.JSGlobalObject,
+        refs: *StringRefList,
+        bundler_options: *SplitBundlerOptions,
+        arena: Allocator,
+    ) !Framework {
+        if (opts.isString()) {
+            const str = try opts.toBunString2(global);
+            defer str.deref();
+
+            // Deprecated
+            if (str.eqlComptime("react-server-components")) {
+                bun.Output.warn("deprecation notice: 'react-server-components' will be renamed to 'react'", .{});
+                return Framework.react(arena);
+            }
+
+            if (str.eqlComptime("react")) {
+                return Framework.react(arena);
+            }
+        }
+
+        if (!opts.isObject()) {
+            return global.throwInvalidArguments("Framework must be an object", .{});
+        }
+
+        if (try opts.get(global, "serverEntryPoint") != null) {
+            bun.Output.warn("deprecation notice: 'framework.serverEntryPoint' has been replaced with 'fileSystemRouterTypes[n].serverEntryPoint'", .{});
+        }
+        if (try opts.get(global, "clientEntryPoint") != null) {
+            bun.Output.warn("deprecation notice: 'framework.clientEntryPoint' has been replaced with 'fileSystemRouterTypes[n].clientEntryPoint'", .{});
+        }
+
+        const react_fast_refresh: ?ReactFastRefresh = brk: {
+            const rfr: JSValue = try opts.get(global, "reactFastRefresh") orelse
+                break :brk null;
+
+            if (rfr == .true) break :brk .{};
+            if (rfr == .false or rfr == .null or rfr == .undefined) break :brk null;
+
+            if (!rfr.isObject()) {
+                return global.throwInvalidArguments("'framework.reactFastRefresh' must be an object or 'true'", .{});
+            }
+
+            const prop = try rfr.get(global, "importSource") orelse {
+                return global.throwInvalidArguments("'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.get(global, "serverComponents") orelse
+                break :sc null;
+            if (sc == .false or sc == .null or sc == .undefined) break :sc null;
+
+            if (!sc.isObject()) {
+                return global.throwInvalidArguments("'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.throwInvalidArguments("Missing 'framework.serverComponents.separateSSRGraph'", .{});
+                    };
+                    if (prop == .true) break :brk true;
+                    if (prop == .false) break :brk false;
+                    return global.throwInvalidArguments("'framework.serverComponents.separateSSRGraph' must be a boolean", .{});
+                },
+                .server_runtime_import = refs.track(
+                    try sc.getOptional(global, "serverRuntimeImportSource", ZigString.Slice) orelse {
+                        return global.throwInvalidArguments("Missing 'framework.serverComponents.serverRuntimeImportSource'", .{});
+                    },
+                ),
+                .server_register_client_reference = if (try sc.getOptional(
+                    global,
+                    "serverRegisterClientReferenceExport",
+                    ZigString.Slice,
+                )) |slice|
+                    refs.track(slice)
+                else
+                    "registerClientReference",
+            };
+        };
+        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.throwInvalidArguments("'builtInModules[{d}]' is not an object", .{i});
+                }
+
+                const path = try getOptionalString(file, global, "import", refs, arena) orelse {
+                    return global.throwInvalidArguments("'builtInModules[{d}]' is missing 'import'", .{i});
+                };
+
+                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.throwInvalidArguments("'builtInModules[{d}]' needs either 'path' or 'code'", .{i});
+
+                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.throwInvalidArguments("Missing 'framework.fileSystemRouterTypes'", .{});
+            };
+            const len = array.getLength(global);
+            if (len > 256) {
+                return global.throwInvalidArguments("Framework can only define up to 256 file-system router types", .{});
+            }
+            const file_system_router_types = try arena.alloc(FileSystemRouterType, len);
+
+            var it = array.arrayIterator(global);
+            var i: usize = 0;
+            errdefer for (file_system_router_types[0..i]) |*fsr| fsr.style.deinit();
+            while (it.next()) |fsr_opts| : (i += 1) {
+                const root = try getOptionalString(fsr_opts, global, "root", refs, arena) orelse {
+                    return global.throwInvalidArguments("'fileSystemRouterTypes[{d}]' is missing 'root'", .{i});
+                };
+                const server_entry_point = try getOptionalString(fsr_opts, global, "serverEntryPoint", refs, arena) orelse {
+                    return global.throwInvalidArguments("'fileSystemRouterTypes[{d}]' is missing 'serverEntryPoint'", .{i});
+                };
+                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 layouts = try fsr_opts.getBooleanStrict(global, "layouts") orelse false;
+
+                var style = try FrameworkRouter.Style.fromJS(try fsr_opts.get(global, "style") orelse {
+                    return global.throwInvalidArguments("'fileSystemRouterTypes[{d}]' is missing 'style'", .{i});
+                }, global);
+                errdefer style.deinit();
+
+                const extensions: []const []const u8 = if (try fsr_opts.get(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 = exts_js.arrayIterator(global);
+                        var i_2: usize = 0;
+                        const extensions = try arena.alloc([]const u8, exts_js.getLength(global));
+                        while (it_2.next()) |array_item| : (i_2 += 1) {
+                            const slice = refs.track(try array_item.toSlice2(global, arena));
+                            if (bun.strings.eqlComptime(slice, "*"))
+                                return global.throwInvalidArguments("'extensions' cannot include \"*\" as an extension. Pass \"*\" instead of the array.", .{});
+
+                            if (slice.len == 0) {
+                                return global.throwInvalidArguments("'extensions' cannot include \"\" as an extension.", .{});
+                            }
+
+                            extensions[i_2] = if (slice[0] == '.')
+                                slice
+                            else
+                                try std.mem.concat(arena, u8, &.{ ".", slice });
+                        }
+                        break :exts extensions;
+                    }
+
+                    return global.throwInvalidArguments("'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.get(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.throwInvalidArguments("'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,
+                    .allow_layouts = layouts,
+                };
+            }
+
+            break :brk file_system_router_types;
+        };
+        errdefer for (file_system_router_types) |*fsr| fsr.style.deinit();
+
+        const framework: Framework = .{
+            .is_built_in_react = false,
+            .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, "plugins", JSValue)) |plugin_array| {
+            try bundler_options.parsePluginArray(plugin_array, global);
+        }
+
+        if (try opts.getOptional(global, "bundlerOptions", JSValue)) |js_options| {
+            _ = js_options; // TODO:
+            // try bundler_options.parseInto(global, js_options, .root);
+        }
+
+        return framework;
+    }
+
+    pub fn initBundler(
+        framework: *Framework,
+        allocator: std.mem.Allocator,
+        log: *bun.logger.Log,
+        mode: Mode,
+        comptime renderer: Graph,
+        out: *bun.bundler.Bundler,
+    ) !void {
+        out.* = try bun.Bundler.init(
+            allocator, // TODO: this is likely a memory leak
+            log,
+            std.mem.zeroes(bun.Schema.Api.TransformOptions),
+            null,
+        );
+
+        out.options.target = switch (renderer) {
+            .client => .browser,
+            .server, .ssr => .bun,
+        };
+        out.options.public_path = switch (renderer) {
+            .client => DevServer.client_prefix,
+            .server, .ssr => "",
+        };
+        out.options.entry_points = &.{};
+        out.options.log = log;
+        out.options.output_format = switch (mode) {
+            .development => .internal_bake_dev,
+            .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 != .development;
+
+        // force disable filesystem output, even though bundle_v2
+        // is special cased to return before that code is reached.
+        out.options.output_dir = "";
+
+        // framework configuration
+        out.options.react_fast_refresh = mode == .development and renderer == .client and framework.react_fast_refresh != null;
+        out.options.server_components = framework.server_components != null;
+
+        out.options.conditions = try bun.options.ESMConditions.init(allocator, out.options.target.defaultConditions());
+        if (renderer == .server and framework.server_components != null) {
+            try out.options.conditions.appendSlice(&.{"react-server"});
+        }
+        if (mode == .development) {
+            // Support `esm-env` package using this condition.
+            try out.options.conditions.appendSlice(&.{"development"});
+        }
+
+        out.options.production = mode != .development;
+
+        out.options.tree_shaking = mode != .development;
+        out.options.minify_syntax = mode != .development;
+        out.options.minify_identifiers = mode != .development;
+        out.options.minify_whitespace = mode != .development;
+
+        out.options.experimental_css = true;
+        out.options.css_chunking = true;
+
+        out.options.framework = framework;
+
+        out.options.source_map = switch (mode) {
+            // Source maps must always be linked, as DevServer special cases the
+            // linking and part of the generation of these.
+            .development => .external,
+            // TODO: follow user configuration
+            else => .none,
+        };
+
+        out.configureLinker();
+        try out.configureDefines();
+
+        out.options.jsx.development = mode == .development;
+
+        try addImportMetaDefines(allocator, out.options.define, mode, switch (renderer) {
+            .client => .client,
+            .server, .ssr => .server,
+        });
+
+        if (mode != .development) {
+            // Hide information about the source repository, at the cost of debugging quality.
+            out.options.entry_naming = "_bun/[hash].[ext]";
+            out.options.chunk_naming = "_bun/[hash].[ext]";
+            out.options.asset_naming = "_bun/[hash].[ext]";
+        }
+
+        out.resolver.opts = out.options;
+    }
+};
+
+fn getOptionalString(
+    target: JSValue,
+    global: *JSC.JSGlobalObject,
+    property: []const u8,
+    allocations: *StringRefList,
+    arena: Allocator,
+) !?[]const u8 {
+    const value = try target.get(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));
+}
+
+pub inline fn getHmrRuntime(side: Side) [:0]const u8 {
+    return if (Environment.codegen_embed)
+        switch (side) {
+            .client => @embedFile("bake-codegen/bake.client.js"),
+            .server => @embedFile("bake-codegen/bake.server.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 {
+    development,
+    production_dynamic,
+    production_static,
+};
+pub const Side = enum(u1) {
+    client,
+    server,
+
+    pub fn graph(s: Side) Graph {
+        return switch (s) {
+            .client => .client,
+            .server => .server,
+        };
+    }
+};
+pub const Graph = enum(u2) {
+    client,
+    server,
+    /// Only used when Framework has .server_components.separate_ssr_graph set
+    ssr,
+};
+
+pub fn addImportMetaDefines(
+    allocator: std.mem.Allocator,
+    define: *bun.options.Define,
+    mode: Mode,
+    side: Side,
+) !void {
+    const Define = bun.options.Define;
+
+    // The following are from Vite: https://vitejs.dev/guide/env-and-mode
+    // 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",
+        Define.Data.initBoolean(mode == .development),
+    );
+    try define.insert(
+        allocator,
+        "import.meta.env.PROD",
+        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),
+    );
+
+    if (mode != .development) {
+        try define.insert(
+            allocator,
+            "import.meta.hot",
+            Define.Data.initBoolean(false),
+        );
+    }
+}
+
+pub const server_virtual_source: bun.logger.Source = .{
+    .path = bun.fs.Path.initForKitBuiltIn("bun", "bake/server"),
+    .contents = "", // Virtual
+    .index = bun.JSAst.Index.bake_server_data,
+};
+
+pub const client_virtual_source: bun.logger.Source = .{
+    .path = bun.fs.Path.initForKitBuiltIn("bun", "bake/client"),
+    .contents = "", // Virtual
+    .index = bun.JSAst.Index.bake_client_data,
+};
+
+/// 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| {
+                bun.assert(text.len == 0 or text[0] != '/');
+                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..];
+    }
+};
+
+pub fn printWarning() void {
+    // Silence this for the test suite
+    if (bun.getenvZ("BUN_DEV_SERVER_TEST_RUNNER") == null) {
+        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();
+    }
+}
+
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+
+const bun = @import("root").bun;
+const Environment = bun.Environment;
+
+const JSC = bun.JSC;
+const JSValue = JSC.JSValue;
+const validators = bun.JSC.Node.validators;
+const ZigString = JSC.ZigString;
+const Plugin = JSC.API.JSBundler.Plugin;
diff --git a/src/bake/bun-framework-react/client.tsx b/src/bake/bun-framework-react/client.tsx
new file mode 100644
index 0000000000..9353da0f8e
--- /dev/null
+++ b/src/bake/bun-framework-react/client.tsx
@@ -0,0 +1,479 @@
+// 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 { onServerSideReload } from 'bun:bake/client';
+import { flushSync } from 'react-dom';
+
+const te = new TextEncoder();
+const td = new TextDecoder();
+
+// It is the framework's responsibility to ensure that client-side navigation
+// loads CSS files. The implementation here loads all CSS files as <link> tags,
+// and uses the ".disabled" property to enable/disable them.
+const cssFiles = new Map<string, { promise: Promise<void> | null; link: HTMLLinkElement }>();
+let currentCssList: string[] | undefined = undefined;
+
+// The initial RSC payload is put into inline <script> tags that follow the pattern
+// `(self.__bun_f ??= []).push(chunk)`, which is converted into a ReadableStream
+// here for React hydration. Since inline scripts are executed immediately, and
+// this file is loaded asynchronously, the `__bun_f` becomes a clever way to
+// stream the arbitrary data while HTML is loading. In a static build, this is
+// setup as an array with one string.
+let rscPayload: any = createFromReadableStream(
+  new ReadableStream({
+    start(controller) {
+      let handleChunk = chunk =>
+        typeof chunk === "string" //
+          ? controller.enqueue(te.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. The `Root` component
+// also updates CSS files when navigating between routes.
+let setPage;
+let abortOnRender: AbortController | undefined;
+const Root = () => {
+  setPage = React.useState(rscPayload)[1];
+
+  // Layout effects are executed right before the browser paints,
+  // which is the perfect time to make CSS visible.
+  React.useLayoutEffect(() => {
+    if (abortOnRender) {
+      try {
+        abortOnRender.abort();
+        abortOnRender = undefined;
+      } catch {}
+    }
+    requestAnimationFrame(() => {
+      if (currentCssList) disableUnusedCssFiles();
+    });
+  });
+
+  // Unwrap the promise if it is one
+  return rscPayload.then ? React.use(rscPayload) : rscPayload;
+};
+const root = hydrateRoot(document, <Root />, {
+  onUncaughtError(e) {
+    console.error(e);
+  }
+});
+
+// Keep a cache of page objects to avoid re-fetching a page when pressing the
+// back button. The cache is indexed by the date it was created.
+const cachedPages = new Map<number, Page>();
+// const defaultPageExpiryTime = 1000 * 60 * 5; // 5 minutes
+interface Page {
+  css: string[];
+  element: unknown;
+}
+
+const firstPageId = Date.now();
+{
+  history.replaceState(firstPageId, "", location.href);
+  rscPayload.then(result => {
+    if (lastNavigationId > 0) return;
+
+    // Collect the list of CSS files that were added from SSR
+    const links = document.querySelectorAll<HTMLLinkElement>("link[data-bake-ssr]");
+    currentCssList = [];
+    for (let i = 0; i < links.length; i++) {
+      const link = links[i];
+      const href = new URL(link.href).pathname;
+      currentCssList.push(href);
+
+      // Hack: cannot add this to `cssFiles` because React owns the element, and
+      // it will be removed when any navigation is performed.
+    }
+
+    cachedPages.set(firstPageId, {
+      css: currentCssList!,
+      element: result,
+    });
+  });
+
+  if (document.startViewTransition as unknown) {
+    // View transitions are used by navigations to ensure that the page rerender
+    // all happens in one operation. Additionally, developers may animate
+    // different elements. The default fade animation is disabled so that the
+    // out-of-the-box experience feels like there are no view transitions.
+    // This is done client-side because a React error will unmount all elements.
+    const sheet = new CSSStyleSheet();
+    document.adoptedStyleSheets.push(sheet);
+    sheet.replaceSync(':where(*)::view-transition-group(root){animation:none}');
+  }
+}
+
+let lastNavigationId = 0;
+let lastNavigationController: AbortController;
+
+// Client side navigation is implemented by updating the app's `useState` with a
+// new RSC payload promise. Callers of `goto` are expected to manage history state.
+// A navigation id is used
+async function goto(href: string, cacheId?: number) {
+  const thisNavigationId = ++lastNavigationId;
+  const olderController = lastNavigationController;
+  lastNavigationController = new AbortController();
+  const signal = lastNavigationController.signal;
+  signal.addEventListener("abort", () => {
+    olderController?.abort();
+  });
+
+  // If the page is cached, use the cached promise instead of fetching it again.
+  const cached = cacheId && cachedPages.get(cacheId);
+  if (cached) {
+    currentCssList = cached.css;
+    await ensureCssIsReady(currentCssList);
+    setPage?.(rscPayload = cached.element);
+    console.log("cached", cached);
+    if (olderController?.signal.aborted === false) 
+      abortOnRender = olderController;
+    return;
+  }
+
+  let response: 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,
+      },
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to fetch ${href}: ${response.status} ${response.statusText}`);
+    }
+  } catch (err) {
+    if (thisNavigationId === lastNavigationId) {
+      // Bail out to browser navigation if this fetch fails.
+      console.error(err);
+      location.href = href;
+    }
+
+    return;
+  }
+
+  // If the navigation id has changed, this fetch is no longer relevant.
+  if (thisNavigationId !== lastNavigationId) return;
+  let stream = response.body!;
+
+  // Read the css metadata at the start before handing it to react.
+  stream = await readCssMetadata(stream);
+  if (thisNavigationId !== lastNavigationId) return;
+
+  const cssWaitPromise = ensureCssIsReady(currentCssList!);
+
+  const p = await createFromReadableStream(stream);
+  if (thisNavigationId !== lastNavigationId) return;
+
+  if (cssWaitPromise) {
+    await cssWaitPromise;
+    if (thisNavigationId !== lastNavigationId) return;
+  }
+
+  // Save this promise so that pressing the back button in the browser navigates
+  // to the same instance of the old page, instead of re-fetching it.
+  if (cacheId) {
+    cachedPages.set(cacheId, { css: currentCssList, element: p });
+  }
+
+  // Defer aborting a previous request until VERY late. If a previous stream is
+  // aborted while rendering, it will cancel the render, resulting in a flash of
+  // a blank page.
+  if (olderController?.signal.aborted === false) {
+    abortOnRender = olderController;
+  }
+
+  // Tell react about the new page promise
+  if (setPage) {
+    if (document.startViewTransition as unknown) {
+      document.startViewTransition(() => {
+        flushSync(() => {
+          if (thisNavigationId === lastNavigationId)
+            setPage(rscPayload = p);
+        });
+      });
+    } else {
+      setPage((rscPayload = p));
+    }
+  }
+}
+
+// This function blocks until all CSS files are loaded.
+function ensureCssIsReady(cssList: string[]) {
+  const wait: Promise<void>[] = [];
+  for (const href of cssList) {
+    console.log("check", href);
+    const existing = cssFiles.get(href);
+    console.log("get", existing);
+    if (existing) {
+      const { promise, link } = existing;
+      if (promise) {
+        wait.push(promise);
+      }
+      link.disabled = false;
+    } else {
+      const link = document.createElement("link");
+      let entry;
+      const promise = new Promise<void>((resolve, reject) => {
+        link.rel = "stylesheet";
+        link.onload = resolve as any;
+        link.onerror = reject;
+        link.href = href;
+        document.head.appendChild(link);
+      }).then(() => {
+        console.log("loaded", href);
+        entry.promise = null;
+      });
+      entry = { promise, link };
+      cssFiles.set(href, entry);
+      wait.push(promise);
+    }
+  }
+  if (wait.length === 0) return;
+  return Promise.all(wait);
+}
+
+function disableUnusedCssFiles() {
+  // TODO: create a list of files that should be updated instead of a full loop
+  for (const [href, { link }] of cssFiles) {
+    if (!currentCssList!.includes(href)) {
+      link.disabled = true;
+    }
+  }
+}
+
+// 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;
+      const newId = Date.now();
+      history.pushState(newId, "", href);
+      goto(href, newId);
+
+      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", event => {
+  console.log("popstate", event);
+  let state = event.state;
+  if (typeof state !== "number") {
+    state = undefined;
+  }
+  goto(location.href, state);
+});
+
+if (import.meta.env.DEV) {
+  // Frameworks can call `onServerSideReload` to hook into server-side hot
+  // module reloading. 
+  onServerSideReload(async() => {
+    const newId = Date.now();
+    history.replaceState(newId, "", location.href);
+    await goto(location.href, newId);
+  });
+
+  // Expose a global in Development mode
+  (window as any).$bake = {
+    goto,
+    onServerSideReload,
+    get currentCssList() {
+      return currentCssList;
+    }
+  };
+}
+
+async function readCssMetadata(stream: ReadableStream<Uint8Array>) {
+  let reader;
+  try {
+    // Using BYOB reader allows reading an exact amount of bytes, which allows
+    // passing the stream to react without creating a wrapped stream.
+    reader = stream.getReader({ mode: "byob" });
+  } catch (e) {
+    return readCssMetadataFallback(stream);
+  }
+
+  const header = (await reader.read(new Uint32Array(1))).value;
+  if (!header) {
+    if (import.meta.env.DEV) {
+      throw new Error("Did not read all bytes! This is a bug in bun-framework-react");
+    } else {
+      location.reload();
+    }
+  }
+  if (header[0] > 0) {
+    const cssRaw = (await reader.read(new Uint8Array(header[0]))).value;
+    if (!cssRaw) {
+      if (import.meta.env.DEV) {
+        throw new Error("Did not read all bytes! This is a bug in bun-framework-react");
+      } else {
+        location.reload();
+      }
+    }
+    currentCssList = td.decode(cssRaw).split("\n");
+  } else {
+    currentCssList = [];
+  }
+  reader.releaseLock();
+  return stream;
+}
+
+// Safari does not support BYOB reader. When this is resolved, this fallback
+// should be kept for a few years since Safari on iOS is versioned to the OS.
+// https://bugs.webkit.org/show_bug.cgi?id=283065
+async function readCssMetadataFallback(stream: ReadableStream<Uint8Array>) {
+  const reader = stream.getReader();
+  const chunks: Uint8Array[] = [];
+  let totalBytes = 0;
+  const readChunk = async size => {
+    while (totalBytes < size) {
+      const { value, done } = await reader.read();
+      if (!done) {
+        chunks.push(value);
+        totalBytes += value.byteLength;
+      } else if (totalBytes < size) {
+        if (import.meta.env.DEV) {
+          throw new Error("Not enough bytes, expected " + size + " but got " + totalBytes);
+        } else {
+          location.reload();
+        }
+      }
+    }
+    if (chunks.length === 1) {
+      const first = chunks[0];
+      if(first.byteLength >= size) {
+        chunks[0] = first.subarray(size);
+        totalBytes -= size;
+        return first.subarray(0, size);
+      } else {
+        chunks.length = 0;
+        totalBytes = 0;
+        return first;
+      }
+    } else {
+      const buffer = new Uint8Array(size);
+      let i = 0;
+      let chunk;
+      let len;
+      while (size > 0) {
+        chunk = chunks.shift();
+        const { byteLength } = chunk;
+        len = Math.min(byteLength, size);
+        buffer.set(len === byteLength ? chunk : chunk.subarray(0, len), i);
+        i += len;
+        size -= len;
+      }
+      if (chunk.byteLength > len) {
+        chunks.unshift(chunk.subarray(len));
+      }
+      totalBytes -= size;
+      return buffer;
+    }
+  };
+  const header = new Uint32Array(await readChunk(4))[0]; 
+  console.log('h', header);
+  if (header === 0) {
+    currentCssList = [];
+  } else {
+    currentCssList = td.decode(await readChunk(header)).split("\n");
+  }
+  console.log('cc', currentCssList);
+  if (chunks.length === 0) {
+    return stream;
+  }
+  // New readable stream that includes the remaining data
+  return new ReadableStream({
+    async start(controller) {
+      for (const chunk of chunks) {
+        controller.enqueue(chunk);
+      }
+      while (true) {
+        const { value, done } = await reader.read();
+        if (done) {
+          controller.close();
+          return;
+        }
+        controller.enqueue(value);
+      }
+    },
+    cancel() {
+      reader.cancel();
+    }
+  });
+}
diff --git a/src/bake/bun-framework-react/index.ts b/src/bake/bun-framework-react/index.ts
new file mode 100644
index 0000000000..cdbd2b5942
--- /dev/null
+++ b/src/bake/bun-framework-react/index.ts
@@ -0,0 +1,42 @@
+// 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",
+        layouts: true,
+        ignoreUnderscores: true,
+      },
+    ],
+    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 0000000000..ca7c039725
--- /dev/null
+++ b/src/bake/bun-framework-react/server.tsx
@@ -0,0 +1,190 @@
+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, styles: readonly string[]) {
+  let route = component(meta.pageModule, meta.params);
+  for (const layout of meta.layouts) {
+    const Layout = layout.default;
+    if (import.meta.env.DEV) assertReactComponent(Layout);
+    route = <Layout params={meta.params}>{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 => (
+          // `data-bake-ssr` is used on the client-side to construct the styles array.
+          <link key={url} rel="stylesheet" href={url} data-bake-ssr />
+        ))}
+      </head>
+      <body>{route}</body>
+    </html>
+  );
+}
+
+function component(mod: any, params: Record<string, string> | null) {
+  const Page = mod.default;
+  let props = {};
+  if (import.meta.env.DEV) assertReactComponent(Page);
+
+  let method;
+  if ((import.meta.env.DEV || import.meta.env.STATIC) && (method = mod.getStaticProps)) {
+    if (mod.getServerSideProps) {
+      throw new Error("Cannot have both getStaticProps and getServerSideProps");
+    }
+
+    props = method();
+  }
+
+  return <Page params={params} {...props} />;
+}
+
+// `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 calling `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");
+
+  // Do not render <link> tags if the request is skipping SSR.
+  const page = getPage(meta, skipSSR ? [] : meta.styles);
+
+  // TODO: write a lightweight version of PassThrough
+  const rscPayload = new PassThrough();
+
+  if (skipSSR) {
+    // "client.tsx" reads the start of the response to determine the
+    // CSS files to load. The styles are loaded before the new page
+    // is presented, to avoid a flash of unstyled content.
+    const int = Buffer.allocUnsafe(4);
+    const str = meta.styles.join("\n");
+    int.writeUInt32LE(str.length, 0);
+    rscPayload.write(int);
+    rscPayload.write(str);
+  }
+
+  // This renders Server Components to a ReadableStream "RSC Payload"
+  let pipe;
+  const signal: MiniAbortSignal = { aborted: false, abort: null! };
+  ({ pipe, abort: signal.abort } = renderToPipeableStream(page, serverManifest, {
+    onError: err => {
+      if (signal.aborted) return;
+      console.error(err);
+    },
+    filterStackFrame: () => false,
+  }));
+  pipe(rscPayload);
+
+  rscPayload.on("error", err => {
+    if (signal.aborted) return;
+    console.error(err);
+  });
+
+  if (skipSSR) {
+    return new Response(rscPayload as any, {
+      status: 200,
+      headers: { "Content-Type": "text/x-component" },
+    });
+  }
+
+  // The RSC payload is rendered into HTML
+  return new Response(await renderToHtml(rscPayload, meta.modules, signal), {
+    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, meta.styles);
+
+  const rscPayload = renderToPipeableStream(page, serverManifest)
+    // TODO: write a lightweight version of PassThrough
+    .pipe(new PassThrough());
+
+  const int = new Uint32Array(1);
+  int[0] = meta.styles.length;
+  let rscChunks: Array<BlobPart> = [int.buffer as ArrayBuffer, meta.styles.join("\n")];
+  rscPayload.on("data", chunk => rscChunks.push(chunk));
+
+  const html = await renderToStaticHtml(rscPayload, meta.modules);
+  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.
+  };
+}
+
+export async function getParams(meta: Bake.ParamsMetadata): Promise<Bake.GetParamIterator> {
+  const getStaticPaths = meta.pageModule.getStaticPaths;
+  if (getStaticPaths == null) {
+    if (import.meta.env.STATIC) {
+      throw new Error(
+        "In files with dynamic params, a `getStaticPaths` function must be exported to tell Bun what files to render.",
+      );
+    } else {
+      return { pages: [], exhaustive: false };
+    }
+  }
+  const result = await meta.pageModule.getStaticPaths();
+  // Remap the Next.js pagess paradigm to Bun's format
+  if (result.paths) {
+    return {
+      pages: result.paths.map(path => path.params),
+    };
+  }
+  // Allow returning the array directly
+  return result;
+}
+
+// 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",
+};
+
+/** Instead of using AbortController, this is used */
+export interface MiniAbortSignal {
+  aborted: boolean;
+  /** Caller must set `aborted` to true before calling. */
+  abort: () => void;
+}
diff --git a/src/bake/bun-framework-react/ssr.tsx b/src/bake/bun-framework-react/ssr.tsx
new file mode 100644
index 0000000000..d42c10a241
--- /dev/null
+++ b/src/bake/bun-framework-react/ssr.tsx
@@ -0,0 +1,395 @@
+// 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 { ssrManifest } 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";
+import { MiniAbortSignal } from "./server";
+
+// Verify that React 19 is being used.
+if (!React.use) {
+  throw new Error("Bun's React integration requires React 19");
+}
+
+const createFromNodeStreamOptions: Manifest = {
+  moduleMap: ssrManifest,
+  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[],
+  signal: MiniAbortSignal,
+): 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) {
+      // `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: ssrManifest,
+        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,
+        onError(error) {
+          if (!signal.aborted) {
+            console.error(error);
+          }
+        },
+      }));
+
+      stream = new RscInjectionStream(rscPayload, controller);
+      pipe(stream);
+
+      // Promise resolved after all data is combined.
+      return stream.finished;
+    },
+    cancel() {
+      signal.aborted = true;
+      signal.abort();
+      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 (import.meta.env.DEV && process.env.VERBOSE_SSR)
+      console.write(
+        "write" +
+          Bun.inspect(
+            {
+              data: new TextDecoder().decode(data),
+            },
+            { colors: true },
+          ) +
+          "\n",
+      );
+    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.flush();
+      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 (import.meta.env.DEV && process.env.VERBOSE_SSR)
+      console.write(
+        "writeRscData " +
+          Bun.inspect(
+            {
+              data: new TextDecoder().decode(chunk),
+            },
+            { colors: true },
+          ) +
+          "\n",
+      );
+
+    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() {}
+
+  end() {}
+}
+
+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/client/css-reloader.ts b/src/bake/client/css-reloader.ts
new file mode 100644
index 0000000000..d58f2bf4a3
--- /dev/null
+++ b/src/bake/client/css-reloader.ts
@@ -0,0 +1,186 @@
+// CSS hot reloading is implemented a bit weirdly. A lot of opinions on how CSS
+// is managed is put in the hands of the framework implementation, but it is
+// assumed that some basic things always hold true:
+//
+// - SSR injects <link> elements with the URLs that Bun provided
+// - CSR will remove or append new <link> elements
+// - These link elements are direct children of <head>
+// - The URL bar contains the current route reflected by the UI
+//
+// With this, production mode is fully implemented in the framework, and
+// DevServer can hot-reload these files with some clever observation.
+//
+// The approach is to attach CSSStyleSheet objects to the page, which
+// the runtime can update at will. Then, a MutationObserver is used to
+// allow the framework to change the <link> tags as a part of its own
+// client-side navigation.
+
+const cssStore = new Map<string, CSS>();
+const registeredLinkTags = new Map<HTMLLinkElement, string>();
+
+interface CSS {
+  sheet: CSSStyleSheet | null;
+  link: HTMLLinkElement | null;
+  active: boolean;
+}
+
+function validateCssId(id: string) {
+  if (!/^[a-f0-9]{16}$/.test(id)) {
+    throw new Error(`Invalid CSS id: ${id}`);
+  }
+}
+
+function deactivateCss(css: CSS) {
+  if (css.active) {
+    const { sheet, link } = css;
+    css.active = false;
+    if (sheet) {
+      sheet.disabled = true;
+    } else if (link) {
+      const linkSheet = link.sheet;
+      if (linkSheet) linkSheet.disabled = true;
+    }
+  }
+}
+
+function activateCss(css: CSS) {
+  if (!css.active) {
+    css.active = true;
+    if (css.sheet) {
+      css.sheet.disabled = false;
+    } else if (css.link) {
+      const linkSheet = css.link.sheet;
+      if (linkSheet) linkSheet.disabled = false;
+    }
+  }
+}
+
+// A mutation observer detects when the framework does client-side routing.
+const headObserver = new MutationObserver(list => {
+  for (const mutation of list) {
+    if (mutation.type === "childList") {
+      // This allows frameworks to add and remove link tags. Removing a link tag
+      // that Bun had reloaded needs to disable the wrapped sheet. The wrapper
+      // is kept around in case the framework re-adds the link tag.
+      let i = 0;
+      let len = mutation.removedNodes.length;
+      while (i < len) {
+        const node = mutation.removedNodes[i];
+        const id = registeredLinkTags.get(node as HTMLLinkElement);
+        if (id) {
+          const existingSheet = cssStore.get(id);
+          if (existingSheet) {
+            deactivateCss(existingSheet);
+          }
+          registeredLinkTags.delete(node as HTMLLinkElement);
+        }
+        i++;
+      }
+      i = 0;
+      len = mutation.addedNodes.length;
+      while (i < len) {
+        const node = mutation.addedNodes[i];
+        if (node instanceof HTMLLinkElement) {
+          maybeAddCssLink(node);
+        }
+        i++;
+      }
+    } else if (mutation.type === "attributes") {
+      // This allows frameworks to set the `disabled` attribute on the link tag
+      const target = mutation.target as HTMLLinkElement;
+      if (target.tagName === "LINK" && target.rel === "stylesheet") {
+        const id = registeredLinkTags.get(target);
+        if (id) {
+          const existing = cssStore.get(id);
+          if (existing) {
+            const disabled = target.disabled;
+            if (disabled) {
+              deactivateCss(existing);
+            } else {
+              activateCss(existing);
+            }
+          }
+        }
+      }
+    }
+  }
+});
+
+function maybeAddCssLink(link: HTMLLinkElement) {
+  const pathname = new URL(link.href).pathname;
+  if (pathname.startsWith("/_bun/css/")) {
+    const id = pathname.slice("/_bun/css/".length).slice(0, 16);
+    if ( !/^[a-f0-9]{16}$/.test(id)) {
+      return;
+    }
+    const existing = cssStore.get(id);
+    if (existing) {
+      const { sheet } = existing;
+      if (sheet) {
+        // The HMR runtime has a managed sheet already.
+        sheet.disabled = false;
+        const linkSheet = link.sheet;
+        if (linkSheet) linkSheet.disabled = true;
+      }
+      existing.link = link;
+    } else {
+      cssStore.set(id, {
+        sheet: null,
+        link,
+        active: true,
+      });
+    }
+    registeredLinkTags.set(link, id);
+  }
+}
+
+headObserver.observe(document.head, {
+  childList: true,
+  // TODO: consider using a separate observer for attributes, this can avoid subtree
+  subtree: true,
+  attributes: true,
+  attributeFilter: ["disabled"],
+});
+document.querySelectorAll<HTMLLinkElement>("head>link[rel=stylesheet]").forEach(maybeAddCssLink);
+
+export function editCssArray(array: string[]) {
+  const removedCssKeys = new Set(cssStore.keys());
+  for (const css of array) {
+    if (IS_BUN_DEVELOPMENT) validateCssId(css);
+    const existing = cssStore.get(css);
+    removedCssKeys.delete(css);
+    if (existing) {
+      activateCss(existing);
+    } else {
+      // This will be populated shortly by a call to `editCssContent`
+      cssStore.set(css, {
+        sheet: null,
+        link: null,
+        active: true,
+      });
+    }
+  }
+  for (const css of removedCssKeys) {
+    const entry = cssStore.get(css);
+    if (entry) {
+      deactivateCss(entry);
+    }
+  }
+}
+
+export function editCssContent(id: string, newContent: string) {
+  let entry = cssStore.get(id);
+  if (!entry) return;
+  let sheet = entry.sheet;
+  if (!entry.sheet) {
+    sheet = entry.sheet = new CSSStyleSheet();
+    sheet.replace(newContent);
+    document.adoptedStyleSheets.push(sheet);
+
+    // Disable the link tag if it exists
+    const linkSheet = entry.link?.sheet;
+    if (linkSheet) linkSheet.disabled = true;
+    return;
+  }
+  sheet!.replace(newContent);
+}
diff --git a/src/bake/client/error-serialization.ts b/src/bake/client/error-serialization.ts
new file mode 100644
index 0000000000..ea361a9b62
--- /dev/null
+++ b/src/bake/client/error-serialization.ts
@@ -0,0 +1,82 @@
+// This implements error deserialization from the WebSocket protocol
+import { BundlerMessageLevel } from "../enums";
+import { DataViewReader } from "./reader";
+
+export interface DeserializedFailure {
+  // If not specified, it is a client-side error.
+  file: string | null;
+  messages: BundlerMessage[];
+}
+
+export interface BundlerMessage {
+  kind: "bundler";
+  level: BundlerMessageLevel;
+  message: string;
+  location: BundlerMessageLocation | null;
+  notes: BundlerNote[];
+}
+
+export interface BundlerMessageLocation {
+  /** One-based */
+  line: number;
+  /** One-based */
+  column: number;
+  /** Byte length */
+  length: number;
+  lineText: string;
+}
+
+export interface BundlerNote {
+  message: string;
+  location: BundlerMessageLocation | null;
+}
+
+export function decodeSerializedError(reader: DataViewReader) {
+  const kind = reader.u8();
+  if (kind >= 0 && kind <= 4) {
+    return readLogMsg(reader, kind);
+  } else {
+    throw new Error("TODO: JS Errors");
+  }
+}
+
+/** First byte is already read in. */
+function readLogMsg(r: DataViewReader, level: BundlerMessageLevel) {
+  const message = r.string32();
+  const location = readBundlerMessageLocationOrNull(r);
+  const noteCount = r.u32();
+  const notes = new Array(noteCount);
+  for (let i = 0; i < noteCount; i++) {
+    notes[i] = readLogData(r);
+  }
+  return {
+    kind: "bundler",
+    level,
+    message,
+    location,
+    notes,
+  };
+}
+
+function readLogData(r: DataViewReader): BundlerNote | null {
+  return {
+    message: r.string32(),
+    location: readBundlerMessageLocationOrNull(r),
+  };
+}
+
+function readBundlerMessageLocationOrNull(r: DataViewReader): BundlerMessageLocation | null {
+  const line = r.u32();
+  if (line == 0) return null;
+
+  const column = r.u32();
+  const length = r.u32();
+  const lineText = r.string32();
+
+  return {
+    line,
+    column,
+    length,
+    lineText,
+  };
+}
diff --git a/src/bake/client/overlay.css b/src/bake/client/overlay.css
new file mode 100644
index 0000000000..171d057505
--- /dev/null
+++ b/src/bake/client/overlay.css
@@ -0,0 +1,176 @@
+/*
+ * This file is mounted within Shadow DOM so interference with
+ * the user's application causes no issue. This sheet is used to
+ * style error popups and other elements provided by DevServer.
+ */
+* {
+  box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+}
+
+.root {
+  color-scheme: light dark;
+
+  --modal-bg: light-dark(#efefef, #202020);
+  --modal-text: light-dark(#0a0a0a, #fafafa);
+  --modal-text-faded: light-dark(#0a0a0a88, #fafafa88);
+  --item-bg: light-dark(#d4d4d4, #0f0f0f);
+  --item-bg-hover: light-dark(#cccccc, #171717);
+  --red: #ff5858;
+  --log-error: light-dark(#dc0000, #ff5858);
+  --log-warn: light-dark(#eab308, #fbbf24);
+  --log-note: light-dark(#008ae6, #22d3ee);
+  --log-colon: light-dark(#888, #888);
+
+  font-family:
+    system-ui,
+    -apple-system,
+    BlinkMacSystemFont,
+    "Segoe UI",
+    Roboto,
+    Oxygen,
+    Ubuntu,
+    Cantarell,
+    "Open Sans",
+    "Helvetica Neue",
+    sans-serif;
+  position: fixed;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+}
+
+code,
+.file-name,
+.message {
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+}
+
+.modal {
+  color: var(--modal-text);
+  background-color: var(--modal-bg);
+  border-top: 8px solid var(--red);
+  border-radius: 8px;
+  margin: 4rem 2rem 2rem 2rem;
+  max-width: 940px;
+  width: 100%;
+  box-shadow:
+    0 2px 6px #0004,
+    0 2px 32px #0003;
+}
+
+header {
+  margin: 1rem 1rem;
+  color: var(--red);
+  font-size: 2rem;
+  font-weight: bold;
+}
+
+footer {
+  color: var(--modal-text-faded);
+  margin: 1rem;
+}
+
+pre {
+  font: unset;
+}
+
+.message-group {
+  display: flex;
+  flex-direction: column;
+  background-color: var(--item-bg);
+}
+
+/* this is a <button> */
+.file-name {
+  appearance: none;
+  background-color: transparent;
+  border: none;
+  font-size: unset;
+  font-weight: bold;
+  padding: 0.5rem 1rem;
+  text-align: left;
+  cursor: pointer;
+}
+
+.file-name:hover,
+.file-name:focus-visible {
+  background-color: var(--item-bg-hover);
+}
+
+.file-name::after {
+  color: var(--modal-text-faded);
+  font-size: 70%;
+}
+
+.file-name:hover::after,
+.file-name:focus-visible {
+  content: " (click to open in editor)";
+}
+
+.message {
+  margin: 1rem;
+  margin-bottom: 0;
+}
+
+button + .message {
+  margin-top: 0.5rem;
+}
+
+.message-text > span {
+  color: var(--color);
+}
+
+.log-error {
+  --color: var(--log-error);
+  font-weight: bold;
+}
+
+.log-warn {
+  --color: var(--log-warn);
+}
+
+.log-note {
+  --color: var(--log-note);
+}
+
+.log-colon {
+  --color: var(--log-colon);
+}
+
+.code-line {
+  display: flex;
+  margin: 0.5rem 0;
+}
+
+.line-num {
+  color: var(--modal-text-faded);
+  margin-right: 10px;
+}
+
+.highlight-wrap {
+  color: transparent;
+  user-select: none;
+  pointer-events: none;
+  transform: translateY(-20px);
+  margin-bottom: -5px;
+}
+
+.highlight-wrap .line {
+  margin-left: 10px;
+  text-decoration: underline;
+  text-decoration-style: wavy;
+  text-decoration-color: var(--color);
+}
+
+@media (prefers-color-scheme: light) {
+  .log-warn,
+  .log-note {
+    font-weight: bold;
+  }
+}
diff --git a/src/bake/client/overlay.ts b/src/bake/client/overlay.ts
new file mode 100644
index 0000000000..2dd1754cb1
--- /dev/null
+++ b/src/bake/client/overlay.ts
@@ -0,0 +1,277 @@
+// This file implements the UI for error modals. Since using a framework like
+// React could collide with the user's code (consider React DevTools), this
+// entire modal is written from scratch using the standard DOM APIs. All CSS is
+// scoped in `overlay.css`, and all elements exist under a shadow root. These
+// constraints make the overlay simple to understand and work on.
+//
+// This file has two consumers:
+// - The bundler error page which embeds a list of bundler errors to render.
+// - The client runtime, for when reloading errors happen.
+// Both use a WebSocket to coordinate followup updates, when new errors are
+// added or previous ones are solved.
+import { BundlerMessageLevel } from "../enums";
+import { css } from "../macros" with { type: "macro" };
+import {
+  BundlerMessage,
+  BundlerMessageLocation,
+  BundlerNote,
+  decodeSerializedError,
+  type DeserializedFailure,
+} from "./error-serialization";
+import { DataViewReader } from "./reader";
+
+if (side !== "client") throw new Error("Not client side!");
+
+export let hasFatalError = false;
+
+// I would have used JSX, but TypeScript types interfere in odd ways.
+function elem(tagName: string, props?: null | Record<string, string>, children?: (HTMLElement | Text)[]) {
+  const node = document.createElement(tagName);
+  if (props)
+    for (let key in props) {
+      node.setAttribute(key, props[key]);
+    }
+  if (children)
+    for (const child of children) {
+      node.appendChild(child);
+    }
+  return node;
+}
+
+function elemText(tagName: string, props: null | Record<string, string>, innerHTML: string) {
+  const node = document.createElement(tagName);
+  if (props)
+    for (let key in props) {
+      node.setAttribute(key, props[key]);
+    }
+  node.textContent = innerHTML;
+  return node;
+}
+
+const textNode = (str = "") => document.createTextNode(str);
+
+/**
+ * 32-bit integer corresponding to `SerializedFailure.Owner.Packed`
+ * It is never decoded client-side; treat this as an opaque identifier.
+ */
+type ErrorId = number;
+
+const errors = new Map<ErrorId, DeserializedFailure>();
+const errorDoms = new Map<ErrorId, ErrorDomNodes>();
+const updatedErrorOwners = new Set<ErrorId>();
+
+let domShadowRoot: HTMLElement;
+let domModalTitle: Text;
+let domErrorList: HTMLElement;
+
+interface ErrorDomNodes {
+  root: HTMLElement;
+  title: Text;
+  messages: HTMLElement[];
+}
+
+/**
+ * Initial mount is done lazily. The modal starts invisible, controlled
+ * by `setModalVisible`.
+ */
+function mountModal() {
+  if (domModalTitle) return;
+  domShadowRoot = elem("bun-hmr", {
+    style:
+      "position:absolute!important;" +
+      "display:none!important;" +
+      "top:0!important;" +
+      "left:0!important;" +
+      "width:100%!important;" +
+      "height:100%!important;" +
+      "background:#8883!important",
+  });
+  const shadow = domShadowRoot.attachShadow({ mode: "open" });
+  const sheet = new CSSStyleSheet();
+  sheet.replace(css("client/overlay.css", IS_BUN_DEVELOPMENT));
+  shadow.adoptedStyleSheets = [sheet];
+
+  const root = elem("div", { class: "root" }, [
+    elem("div", { class: "modal" }, [
+      elem("header", null, [(domModalTitle = textNode())]),
+      (domErrorList = elem("div", { class: "error-list" })),
+      elem("footer", null, [
+        // TODO: for HMR turn this into a clickable thing + say it can be dismissed
+        textNode("Errors during a build can only be dismissed fixing them."),
+      ]),
+    ]),
+  ]);
+  shadow.appendChild(root);
+  document.body.appendChild(domShadowRoot);
+}
+
+let isModalVisible = false;
+function setModalVisible(visible: boolean) {
+  if (isModalVisible === visible || !domShadowRoot) return;
+  isModalVisible = visible;
+  domShadowRoot.style.display = visible ? "block" : "none";
+}
+
+/** Handler for `MessageId.errors` websocket packet */
+export function onErrorMessage(view: DataView) {
+  const reader = new DataViewReader(view, 1);
+  const removedCount = reader.u32();
+
+  for (let i = 0; i < removedCount; i++) {
+    const removed = reader.u32();
+    updatedErrorOwners.add(removed);
+    errors.delete(removed);
+  }
+
+  while (reader.hasMoreData()) {
+    decodeAndAppendError(reader);
+  }
+
+  updateErrorOverlay();
+}
+
+export const enum RuntimeErrorType {
+  recoverable,
+  /** Requires that clearances perform a full page reload */
+  fatal,
+}
+
+export function onRuntimeError(err: any, type: RuntimeErrorType) {
+  if (type === RuntimeErrorType.fatal) {
+    hasFatalError = true;
+  }
+ 
+  console.error(err);
+}
+
+/**
+ * Call this for each error, then call `updateErrorOverlay` to commit the
+ * changes to the UI in one smooth motion.
+ */
+export function decodeAndAppendError(r: DataViewReader) {
+  const owner = r.u32();
+  const file = r.string32() || null;
+  const messageCount = r.u32();
+  const messages = new Array(messageCount);
+  for (let i = 0; i < messageCount; i++) {
+    messages[i] = decodeSerializedError(r);
+  }
+  errors.set(owner, { file, messages });
+  updatedErrorOwners.add(owner);
+}
+
+export function updateErrorOverlay() {
+  console.log(errors, updatedErrorOwners);
+
+  if (errors.size === 0) {
+    setModalVisible(false);
+    return;
+  }
+
+  mountModal();
+
+  let totalCount = 0;
+
+  for (const owner of updatedErrorOwners) {
+    const data = errors.get(owner);
+    let dom = errorDoms.get(owner);
+
+    // If this failure was removed, delete it.
+    if (!data) {
+      dom?.root.remove();
+      errorDoms.delete(owner);
+      continue;
+    }
+
+    totalCount += data.messages.length;
+
+    // Create the element for the root if it does not yet exist.
+    if (!dom) {
+      let title;
+      let btn;
+      const root = elem("div", { class: "message-group" }, [
+        (btn = elem("button", { class: "file-name" }, [(title = textNode())])),
+      ]);
+      btn.addEventListener("click", () => {
+        const firstLocation = errors.get(owner)?.messages[0]?.location;
+        if (!firstLocation) return;
+        let fileName = title.textContent.replace(/^\//, "");
+        fetch("/_bun/src/" + fileName, {
+          headers: {
+            "Open-In-Editor": "1",
+            "Editor-Line": firstLocation.line.toString(),
+            "Editor-Column": firstLocation.column.toString(),
+          },
+        });
+      });
+      dom = { root, title, messages: [] };
+      // TODO: sorted insert?
+      domErrorList.appendChild(root);
+      errorDoms.set(owner, dom);
+    } else {
+      // For simplicity, messages are not reused, even if left unchanged.
+      dom.messages.forEach(msg => msg.remove());
+    }
+
+    // Update the DOM with the new data.
+    dom.title.textContent = data.file;
+
+    for (const msg of data.messages) {
+      const domMessage = renderBundlerMessage(msg);
+      dom.root.appendChild(domMessage);
+      dom.messages.push(domMessage);
+    }
+  }
+
+  domModalTitle.textContent = `${errors.size} Build Error${errors.size !== 1 ? "s" : ""}`;
+
+  updatedErrorOwners.clear();
+
+  setModalVisible(true);
+}
+
+const bundleLogLevelToName = ["error", "warn", "note", "debug", "verbose"];
+
+function renderBundlerMessage(msg: BundlerMessage) {
+  return elem(
+    "div",
+    { class: "message" },
+    [
+      renderErrorMessageLine(msg.level, msg.message),
+      ...(msg.location ? renderCodeLine(msg.location, msg.level) : []),
+      ...msg.notes.map(renderNote),
+    ].flat(1),
+  );
+}
+
+function renderErrorMessageLine(level: BundlerMessageLevel, text: string) {
+  const levelName = bundleLogLevelToName[level];
+  if (IS_BUN_DEVELOPMENT && !levelName) {
+    throw new Error("Unknown log level: " + level);
+  }
+  return elem("div", { class: "message-text" }, [
+    elemText("span", { class: "log-" + levelName }, levelName),
+    elemText("span", { class: "log-colon" }, ": "),
+    elemText("span", { class: "log-text" }, text),
+  ]);
+}
+
+function renderCodeLine(location: BundlerMessageLocation, level: BundlerMessageLevel) {
+  return [
+    elem("div", { class: "code-line" }, [
+      elemText("code", { class: "line-num" }, `${location.line}`),
+      elemText("pre", { class: "code-view" }, location.lineText),
+    ]),
+    elem("div", { class: "highlight-wrap log-" + bundleLogLevelToName[level] }, [
+      elemText("span", { class: "space" }, "_".repeat(`${location.line}`.length + location.column - 1)),
+      elemText("span", { class: "line" }, "_".repeat(location.length)),
+    ]),
+  ];
+}
+
+function renderNote(note: BundlerNote) {
+  return [
+    renderErrorMessageLine(BundlerMessageLevel.note, note.message),
+    ...(note.location ? renderCodeLine(note.location, BundlerMessageLevel.note) : []),
+  ];
+}
diff --git a/src/bake/client/reader.ts b/src/bake/client/reader.ts
new file mode 100644
index 0000000000..6da8d2ba6c
--- /dev/null
+++ b/src/bake/client/reader.ts
@@ -0,0 +1,53 @@
+import { td } from "../shared";
+
+export class DataViewReader {
+  view: DataView;
+  cursor: number;
+
+  constructor(view: DataView, cursor: number = 0) {
+    this.view = view;
+    this.cursor = cursor;
+  }
+
+  u32() {
+    const value = this.view.getUint32(this.cursor, true);
+    this.cursor += 4;
+    return value;
+  }
+
+  i32() {
+    const value = this.view.getInt32(this.cursor, true);
+    this.cursor += 4;
+    return value;
+  }
+
+  u16() {
+    const value = this.view.getUint16(this.cursor, true);
+    this.cursor += 2;
+    return value;
+  }
+
+  u8() {
+    const value = this.view.getUint8(this.cursor);
+    this.cursor += 1;
+    return value;
+  }
+
+  stringWithLength(byteLength: number) {
+    const str = td.decode(this.view.buffer.slice(this.cursor, this.cursor + byteLength));
+    this.cursor += byteLength;
+    return str;
+  }
+
+  string32() {
+    return this.stringWithLength(this.u32());
+  }
+
+  hasMoreData() {
+    return this.cursor < this.view.byteLength;
+  }
+
+  rest() {
+    return this.view.buffer.slice(this.cursor);
+  }
+}
diff --git a/src/bake/client/route.ts b/src/bake/client/route.ts
new file mode 100644
index 0000000000..275555cb94
--- /dev/null
+++ b/src/bake/client/route.ts
@@ -0,0 +1,6 @@
+export function routeMatch(routeId: number, routePattern: string) {
+  console.log(`routeMatch(${routeId}, ${routePattern})`);
+  // TODO: pattern parsing
+  // TODO: use routeId to cache the current route to avoid reparsing text we dont care about
+  return routePattern === location.pathname;
+}
diff --git a/src/bake/client/websocket.ts b/src/bake/client/websocket.ts
new file mode 100644
index 0000000000..bdfc988a24
--- /dev/null
+++ b/src/bake/client/websocket.ts
@@ -0,0 +1,126 @@
+const isLocal = location.host === "localhost" || location.host === "127.0.0.1";
+
+let wait = typeof document !== 'undefined'
+  ? () => new Promise<void>(done => {
+    let timer: Timer | null = null;
+
+    const onBlur = () => {
+      if (timer !== null) {
+        clearTimeout(timer);
+        timer = null;
+      }
+    };
+
+    const onTimeout = () => {
+      if (timer !== null) clearTimeout(timer);
+      window.removeEventListener("focus", onTimeout);
+      window.removeEventListener("blur", onBlur);
+      done();
+    };
+
+    window.addEventListener("focus", onTimeout);
+
+    if (document.hasFocus()) {
+      timer = setTimeout(
+        () => {
+          timer = null;
+          onTimeout();
+        },
+        isLocal ? 2_500 : 2_500,
+      );
+
+      window.addEventListener("blur", onBlur);
+    }})
+  : () => new Promise<void>(done => setTimeout(done, 2_500));
+
+interface WebSocketWrapper {
+  /** When re-connected, this is re-assigned */
+  wrapped: WebSocket | null;
+  send(data: string | ArrayBuffer): void;
+  close(): void;
+  [Symbol.dispose](): void;
+}
+
+export function initWebSocket(handlers: Record<number, (dv: DataView, ws: WebSocket) => void>, url: string = "/_bun/hmr") :WebSocketWrapper {
+  let firstConnection = true;
+  let closed = false;
+
+  const wsProxy: WebSocketWrapper = {
+    wrapped: null,
+    send(data) {
+      const wrapped = this.wrapped;
+      if (wrapped && wrapped.readyState === 1) {
+        wrapped.send(data);
+      }
+    },
+    close() {
+      closed = true;
+      this.wrapped?.close();
+    },
+    [Symbol.dispose]() {
+      this.close();
+    },
+  };
+
+  function onOpen() {
+    if (firstConnection) {
+      firstConnection = false;
+      console.info("[Bun] Hot-module-reloading socket connected, waiting for changes...");
+    }
+  }
+
+  function onMessage(ev: MessageEvent<string | ArrayBuffer>) {
+    const { data } = ev;
+    if (typeof data === "object") {
+      const view = new DataView(data);
+      if (IS_BUN_DEVELOPMENT) {
+        console.info("[WS] " + String.fromCharCode(view.getUint8(0)));
+      }
+      handlers[view.getUint8(0)]?.(view, ws);
+    }
+  }
+
+  function onError(ev: Event) {
+    console.error(ev);
+  }
+
+  async function onClose() {
+    console.warn("[Bun] Hot-module-reloading socket disconnected, reconnecting...");
+
+    while (true) {
+      if (closed) return;
+      await wait();
+
+      // Note: Cannot use Promise.withResolvers due to lacking support on iOS
+      let done;
+      const promise = new Promise<boolean>(cb => (done = cb));
+
+      ws = wsProxy.wrapped = new WebSocket(url);
+      ws.binaryType = "arraybuffer";
+      ws.onopen = () => {
+        console.info("[Bun] Reconnected");
+        done(true);
+        onOpen();
+        ws.onerror = onError;
+      };
+      ws.onmessage = onMessage;
+      ws.onerror = ev => {
+        onError(ev);
+        done(false);
+      };
+
+      if (await promise) {
+        break;
+      }
+    }
+  }
+
+  let ws = wsProxy.wrapped = new WebSocket(url);
+  ws.binaryType = "arraybuffer";
+  ws.onopen = onOpen;
+  ws.onmessage = onMessage;
+  ws.onclose = onClose;
+  ws.onerror = onError;
+
+  return wsProxy;
+}
diff --git a/src/bake/enums.ts b/src/bake/enums.ts
new file mode 100644
index 0000000000..8bed725288
--- /dev/null
+++ b/src/bake/enums.ts
@@ -0,0 +1,7 @@
+export const enum BundlerMessageLevel {
+  err = 0,
+  warn = 1,
+  note = 2,
+  debug = 3,
+  verbose = 4,
+}
diff --git a/src/bake/hmr-module.ts b/src/bake/hmr-module.ts
new file mode 100644
index 0000000000..15801f5031
--- /dev/null
+++ b/src/bake/hmr-module.ts
@@ -0,0 +1,280 @@
+import * as runtimeHelpers from "../runtime.bun.js";
+
+let refreshRuntime: any;
+const registry = new Map<Id, HotModule>();
+
+export type ModuleLoadFunction = (module: HotModule) => void;
+export type ExportsCallbackFunction = (new_exports: any) => void;
+
+export const enum State {
+  Loading,
+  Ready,
+  Error,
+}
+
+export const enum LoadModuleType {
+  AssertPresent,
+  UserDynamic,
+}
+
+interface DepEntry {
+  _callback: ExportsCallbackFunction;
+  _expectedImports: string[] | undefined;
+}
+
+/**
+ * This object is passed as the CommonJS "module", but has a bunch of
+ * non-standard properties that are used for implementing hot-module reloading.
+ * It is unacceptable for users to depend on these properties, and it will not
+ * be considered a breaking change when these internals are altered.
+ */
+export class HotModule<E = any> {
+  id: Id;
+  exports: E = {} as E;
+
+  _state = State.Loading;
+  _ext_exports = undefined;
+  __esModule = false;
+  _import_meta: ImportMeta | undefined = undefined;
+  _cached_failure: any = undefined;
+  // modules that import THIS module
+  _deps: Map<HotModule, DepEntry | undefined> = new Map();
+  _onDispose: HotDisposeFunction[] | undefined = undefined;
+
+  constructor(id: Id) {
+    this.id = id;
+  }
+
+  require(id: Id, onReload?: ExportsCallbackFunction) {
+    const mod = loadModule(id, LoadModuleType.UserDynamic);
+    mod._deps.set(this, onReload ? { _callback: onReload, _expectedImports: undefined } : undefined);
+    return mod.exports;
+  }
+
+  importSync(id: Id, onReload?: ExportsCallbackFunction, expectedImports?: string[]) {
+    const mod = loadModule(id, LoadModuleType.AssertPresent);
+    mod._deps.set(this, onReload ? { _callback: onReload, _expectedImports: expectedImports } : undefined);
+    const { exports, __esModule } = mod;
+    const object = __esModule ? exports : (mod._ext_exports ??= { ...exports, default: exports });
+    
+    if (expectedImports && mod._state === State.Ready) {
+      for (const key of expectedImports) {
+        if (!(key in object)) {
+          throw new SyntaxError(`The requested module '${id}' does not provide an export named '${key}'`);
+        }
+      }
+    }
+    return object;
+  }
+
+  /// Equivalent to `import()` in ES modules
+  async dynamicImport(specifier: string, opts?: ImportCallOptions) {
+    const mod = loadModule(specifier, LoadModuleType.UserDynamic);
+    // insert into the map if not present
+    mod._deps.set(this, mod._deps.get(this));
+    const { exports, __esModule } = mod;
+    return __esModule ? exports : (mod._ext_exports ??= { ...exports, default: exports });
+  }
+
+  importMeta() {
+    return (this._import_meta ??= initImportMeta(this));
+  }
+
+  /** Server-only */
+  declare importBuiltin: (id: string) => any;
+}
+
+if (side === "server") {
+  HotModule.prototype.importBuiltin = function (id: string) {
+    return import.meta.require(id);
+  };
+}
+
+function initImportMeta(m: HotModule): ImportMeta {
+  return {
+    url: `bun://${m.id}`,
+    main: false,
+    // @ts-ignore
+    get hot() {
+      const hot = new Hot(m);
+      Object.defineProperty(this, "hot", { value: hot });
+      return hot;
+    },
+  };
+}
+
+type HotAcceptFunction = (esmExports: any | void) => void;
+type HotArrayAcceptFunction = (esmExports: (any | void)[]) => void;
+type HotDisposeFunction = (data: any) => void;
+type HotEventHandler = (data: any) => void;
+
+class Hot {
+  private _module: HotModule;
+
+  data = {};
+
+  constructor(module: HotModule) {
+    this._module = module;
+  }
+
+  accept(
+    arg1: string | readonly string[] | HotAcceptFunction,
+    arg2: HotAcceptFunction | HotArrayAcceptFunction | undefined,
+  ) {
+    console.warn("TODO: implement ImportMetaHot.accept (called from " + JSON.stringify(this._module.id) + ")");
+  }
+
+  decline() {} // Vite: "This is currently a noop and is there for backward compatibility"
+
+  dispose(cb: HotDisposeFunction) {
+    (this._module._onDispose ??= []).push(cb);
+  }
+
+  prune(cb: HotDisposeFunction) {
+    throw new Error("TODO: implement ImportMetaHot.prune");
+  }
+
+  invalidate() {
+    throw new Error("TODO: implement ImportMetaHot.invalidate");
+  }
+
+  on(event: string, cb: HotEventHandler) {
+    if (isUnsupportedViteEventName(event)) {
+      throw new Error(`Unsupported event name: ${event}`);
+    }
+
+    throw new Error("TODO: implement ImportMetaHot.on");
+  }
+
+  off(event: string, cb: HotEventHandler) {
+    throw new Error("TODO: implement ImportMetaHot.off");
+  }
+
+  send(event: string, cb: HotEventHandler) {
+    throw new Error("TODO: implement ImportMetaHot.send");
+  }
+}
+
+function isUnsupportedViteEventName(str: string) {
+  return str === 'vite:beforeUpdate'
+    || str === 'vite:afterUpdate'
+    || str === 'vite:beforeFullReload'
+    || str === 'vite:beforePrune'
+    || str === 'vite:invalidate'
+    || str === 'vite:error'
+    || str === 'vite:ws:disconnect'
+    || str === 'vite:ws:connect';
+}
+
+/**
+ * Load a module by ID. Use `type` to specify if the module is supposed to be
+ * present, or is something a user is able to dynamically specify.
+ */
+export function loadModule<T = any>(key: Id, type: LoadModuleType): HotModule<T> {
+  let mod = registry.get(key);
+  if (mod) {
+    // Preserve failures until they are re-saved.
+    if (mod._state == State.Error) throw mod._cached_failure;
+
+    return mod;
+  }
+  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's bundler.`,
+      );
+    } else {
+      throw new Error(
+        `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, mod);
+    load(mod);
+    mod._state = State.Ready;
+    mod._deps.forEach((entry, dep) => {
+        entry._callback?.(mod.exports);
+    });
+  } catch (err) {
+    console.error(err);
+    mod._cached_failure = err;
+    mod._state = State.Error;
+    throw err;
+  }
+  return mod;
+}
+
+export const getModule = registry.get.bind(registry);
+
+export function replaceModule(key: Id, load: ModuleLoadFunction) {
+  const module = registry.get(key);
+  if (module) {
+    module._onDispose?.forEach((cb) => cb(null));
+    module.exports = {};
+    load(module);
+    const { exports } = module;
+    for (const updater of module._deps.values()) {
+      updater?._callback?.(exports);
+    }
+  }
+}
+
+export function replaceModules(modules: any) {
+  for (const k in modules) {
+    input_graph[k] = modules[k];
+  }
+  for (const k in modules) {
+    try {
+      replaceModule(k, modules[k]);
+    } catch (err) {
+      // TODO: overlay for client
+      console.error(err);
+    }
+  }
+  if (side === "client" && refreshRuntime) {
+    refreshRuntime.performReactRefresh(window);
+  }
+}
+
+{
+  const runtime = new HotModule("bun:wrap");
+  runtime.exports = runtimeHelpers;
+  runtime.__esModule = true;
+  registry.set("bun:wrap", runtime);
+}
+
+export const serverManifest = {};
+export const ssrManifest = {};
+
+export let onServerSideReload: (() => Promise<void>) | null = null;
+
+if (side === "server") {
+  const server_module = new HotModule("bun:bake/server");
+  server_module.__esModule = true;
+  server_module.exports = { serverManifest, ssrManifest, actionManifest: null };
+  registry.set(server_module.id, server_module);
+}
+
+if (side === "client") {
+  const { refresh } = config;
+  if (refresh) {
+    refreshRuntime = loadModule(refresh, LoadModuleType.AssertPresent).exports;
+    refreshRuntime.injectIntoGlobalHook(window);
+  }
+
+  const server_module = new HotModule("bun:bake/client");
+  server_module.__esModule = true;
+  server_module.exports = {
+    onServerSideReload: async (cb) => {
+      onServerSideReload = cb;
+    },
+  };
+  registry.set(server_module.id, server_module);
+}
+
+runtimeHelpers.__name(HotModule.prototype.importSync, "<HMR runtime> importSync");
+runtimeHelpers.__name(HotModule.prototype.require, "<HMR runtime> require");
+runtimeHelpers.__name(loadModule, "<HMR runtime> loadModule");
diff --git a/src/bake/hmr-runtime-client.ts b/src/bake/hmr-runtime-client.ts
new file mode 100644
index 0000000000..2b5ee97f28
--- /dev/null
+++ b/src/bake/hmr-runtime-client.ts
@@ -0,0 +1,163 @@
+// This file is the entrypoint to the hot-module-reloading runtime
+// In the browser, this uses a WebSocket to communicate with the bundler.
+import { loadModule, LoadModuleType, onServerSideReload, replaceModules } from "./hmr-module";
+import { hasFatalError, onErrorMessage, onRuntimeError, RuntimeErrorType } from "./client/overlay";
+import { Bake } from "bun";
+import { DataViewReader } from "./client/reader";
+import { routeMatch } from "./client/route";
+import { initWebSocket } from "./client/websocket";
+import { MessageId } from "./generated";
+import { editCssContent, editCssArray } from "./client/css-reloader";
+import { td } from "./shared";
+
+if (typeof IS_BUN_DEVELOPMENT !== "boolean") {
+  throw new Error("DCE is configured incorrectly");
+}
+
+let isPerformingRouteReload = false;
+let shouldPerformAnotherRouteReload = false;
+
+async function performRouteReload() {
+  console.info("[Bun] Server-side code changed, reloading!");
+  if (isPerformingRouteReload) {
+    shouldPerformAnotherRouteReload = true;
+    return;
+  }
+
+  if (onServerSideReload) {
+    try {
+      isPerformingRouteReload = true;
+      do {
+        shouldPerformAnotherRouteReload = false;
+        await onServerSideReload();
+      } while (shouldPerformAnotherRouteReload);
+      isPerformingRouteReload = false;
+      return;
+    } catch (err) {
+      console.error("Failed to perform Server-side reload.");
+      console.error(err);
+      console.error("The page will hard-reload now.");
+      if (IS_BUN_DEVELOPMENT) {
+        // return showErrorOverlay(err);
+      }
+    }
+  }
+
+  // Fallback for when reloading fails or is not implemented by the framework is
+  // to hard-reload.
+  location.reload();
+}
+
+let isFirstRun = true;
+const ws = initWebSocket({
+  [MessageId.version](view) {
+    if (td.decode(view.buffer.slice(1)) !== config.version) {
+      console.error("Version mismatch, hard-reloading");
+      location.reload();
+      return;
+    }
+
+    if (isFirstRun) {
+      isFirstRun = false;
+    } else {
+      // It would be possible to use `performRouteReload` to do a hot-reload,
+      // but the issue lies in possibly outdated client files. For correctness,
+      // all client files have to be HMR reloaded or proven unchanged.
+      // Configuration changes are already handled by the `config.version` data.
+      location.reload();
+      return;
+    }
+
+    ws.send("she"); // IncomingMessageId.subscribe with hot_update and route_update
+    ws.send("n" + location.pathname); // IncomingMessageId.set_url
+  },
+  [MessageId.hot_update](view) {
+    console.log(view);
+    const reader = new DataViewReader(view, 1);
+
+    // The code genearting each list is annotated with equivalent "List n"
+    // comments in DevServer.zig's finalizeBundle function.
+
+    // List 1
+    const serverSideRoutesUpdated = new Set();
+    do {
+      const routeId = reader.i32();
+      if (routeId === -1 || routeId == undefined) break;
+      serverSideRoutesUpdated.add(routeId);
+    } while (true);
+    // List 2
+    let isServerSideRouteUpdate = false;
+    do {
+      const routeId = reader.i32();
+      if (routeId === -1 || routeId == undefined) break;
+      const routePattern = reader.string32();
+      if (routeMatch(routeId, routePattern)) {
+        isServerSideRouteUpdate = serverSideRoutesUpdated.has(routeId);
+        const cssCount = reader.i32();
+        if (cssCount !== -1) {
+          const cssArray = new Array<string>(cssCount);
+          for (let i = 0; i < cssCount; i++) {
+            cssArray[i] = reader.stringWithLength(16);
+          }
+          editCssArray(cssArray);
+          console.log("oh shit", { routePattern, cssArray });
+        }
+
+        // Skip to the last route
+        let nextRouteId = reader.i32();
+        while (nextRouteId != null && nextRouteId !== -1) {
+          reader.string32();
+          reader.cursor += 16 * reader.u32();
+          nextRouteId = reader.i32();
+        }
+        break;
+      } else {
+        // Skip to the next route
+        reader.cursor += 16 * reader.u32();
+      }
+    } while (true);
+    // List 3
+    {
+      let i = reader.u32();
+      while (i--) {
+        const identifier = reader.stringWithLength(16);
+        const code = reader.string32();
+        editCssContent(identifier, code);
+      }
+    }
+    if (hasFatalError && (isServerSideRouteUpdate || reader.hasMoreData())) {
+      location.reload();
+      return;
+    }
+    // JavaScript modules
+    if (reader.hasMoreData()) {
+      const code = td.decode(reader.rest());
+      const modules = (0, eval)(code);
+      replaceModules(modules);
+    }
+    if (isServerSideRouteUpdate) {
+      performRouteReload();
+    }
+  },
+  [MessageId.errors]: onErrorMessage,
+});
+
+// Before loading user code, instrument some globals.
+{
+  const truePushState = History.prototype.pushState;
+  History.prototype.pushState = function pushState(this: History, state: any, title: string, url?: string | null) {
+    truePushState.call(this, state, title, url);
+    ws.send("n" + location.pathname);
+  }
+  const trueReplaceState = History.prototype.replaceState;
+  History.prototype.replaceState = function replaceState(this: History, state: any, title: string, url?: string | null) {
+    trueReplaceState.call(this, state, title, url);
+    ws.send("n" + location.pathname);
+  }
+}
+
+try {
+  loadModule<Bake.ClientEntryPoint>(config.main, LoadModuleType.AssertPresent);
+} catch (e) {
+  onRuntimeError(e, RuntimeErrorType.fatal);
+}
\ No newline at end of file
diff --git a/src/bake/hmr-runtime-error.ts b/src/bake/hmr-runtime-error.ts
new file mode 100644
index 0000000000..e59e97efe4
--- /dev/null
+++ b/src/bake/hmr-runtime-error.ts
@@ -0,0 +1,60 @@
+// When a bundling error happens, we cannot load any of the users code, since
+// that code expects the SSR step to succeed. This version of client just opens
+// a websocket and listens only for error resolution events, and reloads the
+// page.
+//
+// This is embedded in `DevServer.sendSerializedFailures`. SSR is
+// left unused for simplicity; a flash of unstyled content is
+// stopped by the fact this script runs synchronously.
+import { decodeAndAppendError, onErrorMessage, updateErrorOverlay } from "./client/overlay";
+import { DataViewReader } from "./client/reader";
+import { routeMatch } from "./client/route";
+import { initWebSocket } from "./client/websocket";
+import { MessageId } from "./generated";
+
+/** Injected by DevServer */
+declare const error: Uint8Array;
+
+{
+  const reader = new DataViewReader(new DataView(error.buffer), 0);
+  while (reader.hasMoreData()) {
+    decodeAndAppendError(reader);
+  }
+  updateErrorOverlay();
+}
+
+let firstVersionPacket = true;
+
+initWebSocket({
+  [MessageId.version](dv) {
+    if (firstVersionPacket) {
+      firstVersionPacket = false;
+    } else {
+      // On re-connection, the server may have restarted. The route that was
+      // requested could be in unqueued state. A reload is the only way to
+      // ensure this bundle is enqueued.
+      location.reload();
+    }
+  },
+
+  [MessageId.errors]: onErrorMessage,
+
+  [MessageId.route_update](view) {
+    const reader = new DataViewReader(view, 1);
+    let routeCount = reader.u32();
+
+    while (routeCount > 0) {
+      routeCount -= 1;
+      const routeId = reader.u32();
+      const routePattern = reader.stringWithLength(reader.u16());
+      if (routeMatch(routeId, routePattern)) {
+        location.reload();
+        break;
+      }
+    }
+  },
+
+  [MessageId.errors_cleared]() {
+    location.reload();
+  },
+});
diff --git a/src/bake/hmr-runtime-server.ts b/src/bake/hmr-runtime-server.ts
new file mode 100644
index 0000000000..51f5dc5103
--- /dev/null
+++ b/src/bake/hmr-runtime-server.ts
@@ -0,0 +1,105 @@
+// This file is the entrypoint to the hot-module-reloading runtime.
+// On the server, communication is established with `server_exports`.
+import type { Bake } from "bun";
+import { loadModule, LoadModuleType, replaceModules, ssrManifest, 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, routerTypeMain, routeModules, clientEntryUrl, styles, params) {
+    if (IS_BUN_DEVELOPMENT && process.env.BUN_DEBUG_BAKE_JS) {
+      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 "render" export.');
+    }
+    if (typeof serverRenderer !== "function") {
+      throw new Error('Framework server entrypoint\'s "render" export is not a function.');
+    }
+
+    const [pageModule, ...layouts] = routeModules.map(id => loadModule(id, LoadModuleType.AssertPresent).exports);
+
+    const response = await serverRenderer(req, {
+      styles: styles,
+      modules: [clientEntryUrl],
+      layouts,
+      pageModule,
+      modulepreload: [],
+      params,
+    });
+
+    if (!(response instanceof Response)) {
+      throw new Error(`Server-side request handler was expected to return a Response object.`);
+    }
+
+    return response;
+  },
+  registerUpdate(modules, componentManifestAdd, componentManifestDelete) {
+    replaceModules(modules);
+
+    if (componentManifestAdd) {
+      for (const uid of componentManifestAdd) {
+        try {
+          const mod = loadModule(uid, LoadModuleType.AssertPresent);
+          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 + '#' + exportName] = {
+              id: uid,
+              name: exportName,
+              chunks: [],
+            };
+            client[exportName] = {
+              specifier: "ssr:" + uid,
+              name: exportName,
+            };
+          }
+          ssrManifest[uid] = client;
+        } catch (err) {
+          console.log("caught error");
+          console.log(err);
+        }
+      }
+    }
+
+    if (componentManifestDelete) {
+      for (const fileName of componentManifestDelete) {
+        const client = ssrManifest[fileName];
+        for (const exportName in client) {
+          delete serverManifest[`${fileName}#${exportName}`];
+        }
+        delete ssrManifest[fileName];
+      }
+    }
+  },
+} satisfies Exports;
diff --git a/src/bake/incremental_visualizer.html b/src/bake/incremental_visualizer.html
new file mode 100644
index 0000000000..4a762ea342
--- /dev/null
+++ b/src/bake/incremental_visualizer.html
@@ -0,0 +1,349 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>IncrementalGraph Visualization</title>
+    <script type="text/javascript" src="https://unpkg.com/vis-network/standalone/umd/vis-network.min.js"></script>
+    <style>
+      html,
+      body {
+        background-color: #1e1e2e;
+        color: #cdd6f4;
+        font-family: sans-serif;
+      }
+
+      #network {
+        position: fixed;
+        top: 0;
+        left: 0;
+        width: 100vw;
+        height: 100vh;
+      }
+
+      h1 {
+        position: fixed;
+        top: 1rem;
+        left: 1rem;
+        pointer-events: none;
+        font-size: 1rem;
+        margin: 0;
+        z-index: 100;
+      }
+
+      #stat {
+        font-weight: normal;
+      }
+    </style>
+  </head>
+
+  <body>
+    <h1>IncrementalGraph Visualization <span id="stat"></span></h1>
+    <div id="network"></div>
+
+    <script>
+      // Connect to HMR WebSocket and enable visualization packets. This
+      // serializes the both `IncrementalGraph`s in full and sends them
+      // over the wire. A visualization is provided by `vis.js`. Support
+      //
+      // Script written partially by ChatGPT
+
+      const c = {
+        // Derived from mocha theme on https://catppuccin.com/palette
+        red: "#f38ba8",
+        green: "#a6e3a1",
+        mauve: "#cba6f7",
+        gray: "#7f849c",
+        orange: "#fab387",
+        sky: "#89dceb",
+        blue: "#89b4fa",
+        yellow: "#f9e2af",
+      };
+
+      // Store nodes and edges
+      let clientFiles = [];
+      let serverFiles = [];
+      let clientEdges = [];
+      let serverEdges = [];
+      let currentEdgeIds = new Set();
+      let currentNodeIds = new Set();
+      let = true;
+
+      // 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);
+
+      // 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("sv"); // Subscribe to visualizer events
+        };
+        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;
+
+        let offset = 1; // Skip the 'v' byte
+
+        // Parse client files
+        const clientFileCount = readUint32(buffer, offset);
+        offset += 4;
+
+        clientFiles = parseFiles(buffer, clientFileCount, offset);
+        offset = clientFiles.offset;
+        clientFiles = clientFiles.files;
+
+        // Parse server files
+        const serverFileCount = readUint32(buffer, offset);
+        offset += 4;
+
+        serverFiles = parseFiles(buffer, serverFileCount, offset);
+        offset = serverFiles.offset;
+        serverFiles = serverFiles.files;
+
+        // Parse client edges
+        const clientEdgeCount = readUint32(buffer, offset);
+        offset += 4;
+        clientEdges = parseEdges(buffer, clientEdgeCount, offset);
+        offset = clientEdges.offset;
+        clientEdges = clientEdges.edges;
+
+        // Parse server edges
+        const serverEdgeCount = readUint32(buffer, offset);
+        offset += 4;
+        serverEdges = parseEdges(buffer, serverEdgeCount, offset);
+        offset = serverEdges.offset;
+        serverEdges = serverEdges.edges;
+
+        // Update the graph visualization
+        updateGraph();
+      }
+
+      // Helper to read 4-byte unsigned int
+      function readUint32(buffer, offset) {
+        return buffer[offset] | (buffer[offset + 1] << 8) | (buffer[offset + 2] << 16) | (buffer[offset + 3] << 24);
+      }
+
+      function basename(path) {
+        const match = /node_modules\/(.*?)\//.exec(path);
+        return match ? match[1] : path;
+      }
+
+      // Parse the files from the buffer
+      function parseFiles(buffer, count, offset) {
+        const files = [];
+
+        for (let i = 0; i < count; i++) {
+          const nameLength = readUint32(buffer, offset);
+          offset += 4;
+
+          // If the name length is 0, it's a deleted file
+          if (nameLength === 0) {
+            files.push({ id: i, deleted: true });
+            continue;
+          }
+
+          const nameBytes = buffer.slice(offset, offset + nameLength);
+          const name = new TextDecoder().decode(nameBytes);
+          offset += nameLength;
+
+          const isStale = buffer[offset++] === 1;
+          const isServer = buffer[offset++] === 1;
+          const isSSR = buffer[offset++] === 1;
+          const isRoute = buffer[offset++] === 1;
+          const isFramework = buffer[offset++] === 1;
+          const isBoundary = buffer[offset++] === 1;
+
+          files.push({
+            id: i,
+            name,
+            isStale,
+            isServer,
+            isSSR,
+            isRoute,
+            isFramework,
+            isBoundary,
+          });
+        }
+
+        return { files, offset };
+      }
+
+      // Parse the edges from the buffer
+      function parseEdges(buffer, count, offset) {
+        const edges = [];
+        for (let i = 0; i < count; i++) {
+          const from = readUint32(buffer, offset);
+          offset += 4;
+          const to = readUint32(buffer, offset);
+          offset += 4;
+          edges.push({ from, to });
+        }
+        return { edges, offset };
+      }
+
+      // Helper function to add or update nodes in the graph
+      function updateNode(id, file, group) {
+        const label = basename(file.name);
+        const color = file.isStale
+          ? c.red
+          : file.name.startsWith("node_modules/")
+            ? c.gray
+            : file.isBoundary
+              ? c.orange
+              : group === "client"
+                ? c.mauve
+                : file.isRoute
+                  ? c.blue
+                  : file.isSSR
+                    ? file.isServer
+                      ? c.yellow
+                      : c.green
+                    : c.sky;
+        const props = {
+          id,
+          label,
+          shape: "dot",
+          color: color,
+          borderWidth: file.isRoute ? 3 : 1,
+          group,
+          font: file.name.startsWith("node_modules/") ? "10px sans-serif #cdd6f488" : "20px sans-serif #cdd6f4",
+        };
+        if (nodes.get(id)) {
+          nodes.update(props);
+        } else {
+          nodes.add(props);
+        }
+      }
+
+      // Helper function to remove a node by ID
+      function removeNode(id) {
+        nodes.remove({ id });
+      }
+
+      // Helper function to add or update edges in the graph
+      const edgeProps = { arrows: "to" };
+      function updateEdge(id, from, to, variant) {
+        const prop =
+          variant === "normal"
+            ? { id, from, to, arrows: "to" }
+            : variant === "client"
+              ? { id, from, to, arrows: "to,from", color: "#ffffff99", width: 2, label: "[use client]" }
+              : { id, from, to };
+        if (edges.get(id)) {
+          edges.update(prop);
+        } else {
+          edges.add(prop);
+        }
+      }
+
+      // Helper to remove all edges of a node
+      function removeEdges(nodeId) {
+        const edgesToRemove = edges.get({
+          filter: edge => edge.from === nodeId || edge.to === nodeId,
+        });
+        edges.remove(edgesToRemove.map(e => e.id));
+      }
+
+      // Function to update the entire graph when new data is received
+      function updateGraph() {
+        const newEdgeIds = new Set(); // Track new edges
+        const newNodeIds = new Set(); // Track new nodes
+
+        const boundaries = new Map();
+
+        // Update server files
+        serverFiles.forEach((file, index) => {
+          const id = `S_${file.name}`;
+          if (file.deleted) {
+            removeNode(id);
+            removeEdges(id);
+          } else {
+            updateNode(id, file, "server");
+          }
+
+          if (file.isBoundary) {
+            boundaries.set(file.name, { server: index, client: -1 });
+          }
+          newNodeIds.add(id); // Track this node
+        });
+
+        // Update client files
+        clientFiles.forEach((file, index) => {
+          const id = `C_${file.name}`;
+          if (file.deleted) {
+            removeNode(id);
+            removeEdges(id);
+            return;
+          }
+          updateNode(id, file, "client");
+          const b = boundaries.get(file.name);
+          if (b) {
+            b.client = index;
+          }
+          newNodeIds.add(id); // Track this node
+        });
+
+        // Update client edges
+        clientEdges.forEach((edge, index) => {
+          const id = `C_edge_${index}`;
+          updateEdge(id, `C_${clientFiles[edge.from].name}`, `C_${clientFiles[edge.to].name}`, "normal");
+          newEdgeIds.add(id); // Track this edge
+        });
+
+        // Update server edges
+        serverEdges.forEach((edge, index) => {
+          const id = `S_edge_${index}`;
+          updateEdge(id, `S_${serverFiles[edge.from].name}`, `S_${serverFiles[edge.to].name}`, "normal");
+          newEdgeIds.add(id); // Track this edge
+        });
+
+        boundaries.forEach(({ server, client }) => {
+          if (client === -1) return;
+          const id = `S_edge_bound_${server}_${client}`;
+          updateEdge(id, `S_${serverFiles[server].name}`, `C_${clientFiles[client].name}`, "client");
+          newEdgeIds.add(id); // Track this edge
+        });
+
+        // Remove edges that are no longer present
+        currentEdgeIds.forEach(id => {
+          if (!newEdgeIds.has(id)) {
+            edges.remove(id);
+          }
+        });
+
+        // Remove nodes that are no longer present
+        currentNodeIds.forEach(id => {
+          if (!newNodeIds.has(id)) {
+            nodes.remove(id);
+          }
+        });
+
+        // Update the currentEdgeIds set to the new one
+        currentEdgeIds = newEdgeIds;
+        currentNodeIds = newNodeIds;
+
+        if (isFirst) {
+          network.stabilize();
+          isFirst = false;
+        }
+
+        document.getElementById("stat").innerText =
+          `(server: ${serverFiles.length} files, ${serverEdges.length} edges; client: ${clientFiles.length} files, ${clientEdges.length} edges; ${boundaries.size} boundaries)`;
+      }
+    </script>
+  </body>
+</html>
diff --git a/src/bake/macros.ts b/src/bake/macros.ts
new file mode 100644
index 0000000000..1486a475dc
--- /dev/null
+++ b/src/bake/macros.ts
@@ -0,0 +1,13 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+// @ts-ignore
+export async function css(file: string, is_development: boolean): string {
+  const { success, stdout, stderr } = await Bun.spawnSync({
+    cmd: [process.execPath, "build", file, "--experimental-css", ...(is_development ? [] : ["--minify"])],
+    cwd: import.meta.dir,
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  if (!success) throw new Error(stderr.toString("utf-8"));
+  return stdout.toString("utf-8");
+}
diff --git a/src/bake/package.json b/src/bake/package.json
new file mode 100644
index 0000000000..725a78688b
--- /dev/null
+++ b/src/bake/package.json
@@ -0,0 +1,4 @@
+{
+  "sideEffects": false,
+  "type": "module"
+}
diff --git a/src/bake/production.zig b/src/bake/production.zig
new file mode 100644
index 0000000000..edeedd1de1
--- /dev/null
+++ b/src/bake/production.zig
@@ -0,0 +1,871 @@
+//! Implements building a Bake application to production
+const log = bun.Output.scoped(.production, false);
+
+pub fn buildCommand(ctx: bun.CLI.Command.Context) !void {
+    bun.bake.printWarning();
+
+    if (ctx.args.entry_points.len > 1) {
+        Output.errGeneric("bun build --app only accepts one entrypoint", .{});
+        bun.Global.crash();
+    }
+
+    if (ctx.debug.hot_reload != .none) {
+        Output.errGeneric("Instead of using --watch, use 'bun run'", .{});
+        bun.Global.crash();
+    }
+
+    var cwd_buf: bun.PathBuffer = undefined;
+    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 vm = try VirtualMachine.initBake(.{
+        .allocator = arena.allocator(),
+        .log = ctx.log,
+        .args = ctx.args,
+        .smol = ctx.runtime_options.smol,
+    });
+    defer vm.deinit();
+    // A special global object is used to allow registering virtual modules
+    // that bypass Bun's normal module resolver and plugin system.
+    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;
+    vm.allocator = arena.allocator();
+    b.options.install = ctx.install;
+    b.resolver.opts.install = ctx.install;
+    b.resolver.opts.global_cache = ctx.debug.global_cache;
+    b.resolver.opts.prefer_offline_install = (ctx.debug.offline_mode_setting orelse .online) == .offline;
+    b.resolver.opts.prefer_latest_install = (ctx.debug.offline_mode_setting orelse .online) == .latest;
+    b.options.global_cache = b.resolver.opts.global_cache;
+    b.options.prefer_offline_install = b.resolver.opts.prefer_offline_install;
+    b.options.prefer_latest_install = b.resolver.opts.prefer_latest_install;
+    b.resolver.env_loader = b.env;
+    b.options.minify_identifiers = ctx.bundler_options.minify_identifiers;
+    b.options.minify_whitespace = ctx.bundler_options.minify_whitespace;
+    b.options.ignore_dce_annotations = ctx.bundler_options.ignore_dce_annotations;
+    b.resolver.opts.minify_identifiers = ctx.bundler_options.minify_identifiers;
+    b.resolver.opts.minify_whitespace = ctx.bundler_options.minify_whitespace;
+    b.options.env.behavior = .load_all_without_inlining;
+    vm.event_loop.ensureWaker();
+    switch (ctx.debug.macros) {
+        .disable => {
+            b.options.no_macros = true;
+        },
+        .map => |macros| {
+            b.options.macro_remap = macros;
+        },
+        .unspecified => {},
+    }
+    b.configureDefines() catch {
+        bun.bun_js.failWithBuildError(vm);
+    };
+    bun.http.AsyncHTTP.loadEnv(vm.allocator, vm.log, b.env);
+    vm.loadExtraEnvAndSourceCodePrinter();
+    vm.is_main_thread = true;
+    JSC.VirtualMachine.is_main_thread_vm = true;
+
+    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());
+            const err_value = vm.global.takeException(e);
+            vm.printErrorLikeObjectToConsole(err_value.toError() orelse err_value);
+            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();
+    var unresolved_config_entry_point = if (ctx.args.entry_points.len > 0) ctx.args.entry_points[0] else "./bun.app";
+    if (bun.resolver.isPackagePath(unresolved_config_entry_point)) {
+        unresolved_config_entry_point = try std.fmt.allocPrint(ctx.allocator, "./{s}", .{unresolved_config_entry_point});
+    }
+
+    const config_entry_point = b.resolver.resolve(cwd, unresolved_config_entry_point, .entry_point) catch |err| {
+        if (err == error.ModuleNotFound) {
+            if (ctx.args.entry_points.len == 0) {
+                // Onboarding message
+                Output.err(err,
+                    \\'bun build --app' cannot find your application's config file
+                    \\
+                    \\The default location for this is `bun.app.ts`
+                    \\
+                    \\TODO: insert a link to `bun.sh/docs`
+                , .{});
+                bun.Global.crash();
+            }
+        }
+
+        Output.err(err, "could not resolve application config file '{s}'", .{unresolved_config_entry_point});
+        bun.Global.crash();
+    };
+
+    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(global, &config_entry_point_string) orelse {
+        bun.assert(global.hasException());
+        return error.JSError;
+    };
+
+    config_promise.setHandled(vm.jsc);
+    vm.waitForPromise(.{ .internal = config_promise });
+    var options = switch (config_promise.unwrap(vm.jsc, .mark_handled)) {
+        .pending => unreachable,
+        .fulfilled => |resolved| config: {
+            bun.assert(resolved == .undefined);
+            const default = BakeGetDefaultExportFromModule(vm.global, config_entry_point_string.toJS(vm.global));
+
+            if (!default.isObject()) {
+                Output.panic("TODO: print this error better, default export is not an object", .{});
+            }
+
+            const app = try default.get(vm.global, "app") orelse {
+                Output.panic("TODO: print this error better, default export needs an 'app' object", .{});
+            };
+
+            break :config try bake.UserOptions.fromJS(app, vm.global);
+        },
+        .rejected => |err| {
+            return global.throwValue(err.toError() orelse err);
+        },
+    };
+
+    const framework = &options.framework;
+
+    const separate_ssr_graph = if (framework.server_components) |sc| sc.separate_ssr_graph else false;
+
+    // this is probably wrong
+    const map = try allocator.create(bun.DotEnv.Map);
+    map.* = bun.DotEnv.Map.init(allocator);
+    const loader = try allocator.create(bun.DotEnv.Loader);
+    loader.* = bun.DotEnv.Loader.init(map, allocator);
+    try loader.map.put("NODE_ENV", "production");
+    bun.DotEnv.instance = loader;
+
+    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_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_static, .ssr, &ssr_bundler);
+    }
+
+    if (ctx.bundler_options.bake_debug_disable_minify) {
+        for ([_]*bun.bundler.Bundler{ &client_bundler, &server_bundler, &ssr_bundler }) |bundler| {
+            bundler.options.minify_syntax = false;
+            bundler.options.minify_identifiers = false;
+            bundler.options.minify_whitespace = false;
+            bundler.resolver.opts.entry_naming = "_bun/[dir]/[name].[hash].[ext]";
+            bundler.resolver.opts.chunk_naming = "_bun/[dir]/[name].[hash].chunk.[ext]";
+            bundler.resolver.opts.asset_naming = "_bun/[dir]/[name].[hash].asset.[ext]";
+        }
+    }
+
+    // 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, allocator) catch {
+        if (framework.is_built_in_react)
+            try bake.Framework.addReactInstallCommandNote(server_bundler.log);
+        Output.errGeneric("Failed to resolve all imports required by the framework", .{});
+        Output.flush();
+        server_bundler.log.print(Output.errorWriter()) catch {};
+        bun.Global.crash();
+    };
+
+    Output.prettyErrorln("Bundling routes", .{});
+    Output.flush();
+
+    // trailing slash
+    const public_path = "/";
+
+    var root_dir_buf: bun.PathBuffer = undefined;
+    const root_dir_path = bun.path.joinAbsStringBuf(cwd, &root_dir_buf, &.{"dist"}, .auto);
+
+    var router_types = try std.ArrayListUnmanaged(FrameworkRouter.Type).initCapacity(allocator, options.framework.file_system_router_types.len);
+
+    var entry_points: EntryPointMap = .{
+        .root = cwd,
+        .allocator = allocator,
+        .files = .{},
+    };
+
+    for (options.framework.file_system_router_types) |fsr| {
+        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.withoutTrailingSlashWindowsPath(entry.abs_path),
+            .prefix = fsr.prefix,
+            .ignore_underscores = fsr.ignore_underscores,
+            .ignore_dirs = fsr.ignore_dirs,
+            .extensions = fsr.extensions,
+            .style = fsr.style,
+            .allow_layouts = fsr.allow_layouts,
+            .server_file = try entry_points.getOrPutEntryPoint(fsr.entry_server, .server),
+            .client_file = if (fsr.entry_client) |client|
+                (try entry_points.getOrPutEntryPoint(client, .client)).toOptional()
+            else
+                .none,
+            .server_file_string = .{},
+        });
+    }
+
+    var router = try FrameworkRouter.initEmpty(cwd, router_types.items, allocator);
+    try router.scanAll(
+        allocator,
+        &server_bundler.resolver,
+        FrameworkRouter.InsertionContext.wrap(EntryPointMap, &entry_points),
+    );
+
+    const bundled_outputs_list = try bun.BundleV2.generateFromBakeProductionCLI(
+        entry_points,
+        &server_bundler,
+        .{
+            .framework = framework.*,
+            .client_bundler = &client_bundler,
+            .ssr_bundler = if (separate_ssr_graph) &ssr_bundler else &server_bundler,
+            .plugins = options.bundler_options.plugin,
+        },
+        allocator,
+        .{ .js = vm.event_loop },
+    );
+    const bundled_outputs = bundled_outputs_list.items;
+
+    Output.prettyErrorln("Rendering routes", .{});
+    Output.flush();
+
+    var root_dir = try std.fs.cwd().makeOpenPath("dist", .{});
+    defer root_dir.close();
+
+    var css_chunks_count: usize = 0;
+    var css_chunks_first: usize = 0;
+
+    // Index all bundled outputs.
+    // Client files go to disk.
+    // Server files get loaded in memory.
+    // Populate indexes in `entry_points` to be looked up during prerendering
+    const module_keys = try vm.allocator.alloc(bun.String, entry_points.files.count());
+    const output_indexes = entry_points.files.values();
+    var output_module_map: bun.StringArrayHashMapUnmanaged(OutputFile.Index) = .{};
+    @memset(module_keys, bun.String.dead);
+    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 < output_indexes.len) {
+                output_indexes[entry_point] = OutputFile.Index.init(@intCast(i));
+            }
+        }
+
+        switch (file.side orelse continue) {
+            .client => {
+                // Client-side resources will be written to disk for usage in on the client side
+                _ = file.writeToDisk(root_dir, ".") catch |err| {
+                    bun.handleErrorReturnTrace(err, @errorReturnTrace());
+                    Output.err(err, "Failed to write {} to output directory", .{bun.fmt.quote(file.dest_path)});
+                };
+            },
+            .server => {
+                // For Debugging
+                if (ctx.bundler_options.bake_debug_dump_server) {
+                    _ = file.writeToDisk(root_dir, ".") catch |err| {
+                        bun.handleErrorReturnTrace(err, @errorReturnTrace());
+                        Output.err(err, "Failed to write {} to output directory", .{bun.fmt.quote(file.dest_path)});
+                    };
+                }
+
+                switch (file.output_kind) {
+                    .@"entry-point", .chunk => {
+                        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;
+
+                        if (file.entry_point_index) |entry_point_index| {
+                            if (entry_point_index < module_keys.len) {
+                                var str = try bun.String.createFormat("bake:/{s}", .{without_prefix});
+                                str.toThreadSafe();
+                                module_keys[entry_point_index] = str;
+                            }
+                        }
+
+                        try output_module_map.put(
+                            allocator,
+                            try std.fmt.allocPrint(allocator, "bake:/{s}", .{without_prefix}),
+                            OutputFile.Index.init(@intCast(i)),
+                        );
+                    },
+                    .asset => {},
+                    .bytecode => {},
+                    .sourcemap => @panic("TODO: register source map"),
+                }
+            },
+        }
+    }
+
+    const per_thread_options: PerThread.Options = .{
+        .input_files = entry_points.files.keys(),
+        .bundled_outputs = bundled_outputs,
+        .output_indexes = output_indexes,
+        .module_keys = module_keys,
+        .module_map = output_module_map,
+    };
+
+    var pt = try PerThread.init(vm, per_thread_options);
+    pt.attach();
+
+    // Static site generator
+    const server_render_funcs = JSValue.createEmptyArray(global, router.types.len);
+    const server_param_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,
+                pt.outputFile(client_file).dest_path,
+            })).toJS(global);
+            client_entry_urls.putIndex(global, @intCast(i), str);
+        } else {
+            client_entry_urls.putIndex(global, @intCast(i), .null);
+        }
+
+        const server_entry_point = try pt.loadBundledModule(router_type.server_file);
+        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(bun.path.relative(cwd, entry_points.files.keys()[router_type.server_file.get()].absPath())),
+            });
+            bun.Global.crash();
+        };
+
+        const server_param_func = if (router.dynamic_routes.count() > 0)
+            brk: {
+                const raw = BakeGetOnModuleNamespace(global, server_entry_point, "getParams") 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 \"getParams\" export, which defines how to generate static files.", .{
+                    bun.fmt.quote(bun.path.relative(cwd, entry_points.files.keys()[router_type.server_file.get()].absPath())),
+                });
+                bun.Global.crash();
+            }
+        else
+            JSValue.null;
+        server_render_funcs.putIndex(global, @intCast(i), server_render_func);
+        server_param_funcs.putIndex(global, @intCast(i), server_param_func);
+    }
+
+    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 css_chunk_js_strings = try allocator.alloc(JSValue, css_chunks_count);
+    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(global);
+    }
+
+    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 = pt.outputFile(main_file_route_index);
+
+        // Count how many JS+CSS files associated with this route and prepare `pattern`
+        pattern.prependPart(route.part);
+        switch (route.part) {
+            .param => {
+                params_buf.append(ctx.allocator, route.part.param) catch unreachable;
+            },
+            .catch_all, .catch_all_optional => {
+                return global.throw("catch-all routes are not supported in static site generation", .{});
+            },
+            else => {},
+        }
+        var file_count: u32 = 1;
+        var css_file_count: u32 = @intCast(main_file.referenced_css_files.len);
+        if (route.file_layout.unwrap()) |file| {
+            css_file_count += @intCast(pt.outputFile(file).referenced_css_files.len);
+            file_count += 1;
+        }
+        var next: ?FrameworkRouter.Route.Index = route.parent.unwrap();
+        while (next) |parent_index| {
+            const parent = router.routePtr(parent_index);
+            pattern.prependPart(parent.part);
+            switch (parent.part) {
+                .param => {
+                    params_buf.append(ctx.allocator, parent.part.param) catch unreachable;
+                },
+                .catch_all, .catch_all_optional => {
+                    return global.throw("catch-all routes are not supported in static site generation", .{});
+                },
+                else => {},
+            }
+            if (parent.file_layout.unwrap()) |file| {
+                css_file_count += @intCast(pt.outputFile(file).referenced_css_files.len);
+                file_count += 1;
+            }
+            next = parent.parent.unwrap();
+        }
+
+        // Fill styles and file_list
+        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, pt.preloadBundledModule(main_file_route_index));
+        for (main_file.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, pt.preloadBundledModule(file));
+            for (pt.outputFile(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, pt.preloadBundledModule(file));
+                for (pt.outputFile(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();
+        }
+
+        // Init the items
+        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, pt.inputFile(main_file_route_index).absPath()));
+        route_source_files.putIndex(global, @intCast(nav_index), src_path.transferToJS(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(),
+        })));
+
+        if (params_buf.items.len > 0) {
+            const param_info_array = JSValue.createEmptyArray(global, params_buf.items.len);
+            for (params_buf.items, 0..) |param, i| {
+                param_info_array.putIndex(global, @intCast(params_buf.items.len - i - 1), JSValue.toJSString(global, param));
+            }
+            route_param_info.putIndex(global, @intCast(nav_index), param_info_array);
+        } else {
+            route_param_info.putIndex(global, @intCast(nav_index), .null);
+        }
+        route_style_references.putIndex(global, @intCast(nav_index), styles);
+    }
+
+    const render_promise = BakeRenderRoutesForProdStatic(
+        global,
+        bun.String.init(root_dir_path),
+        pt.all_server_files,
+        server_render_funcs,
+        server_param_funcs,
+        client_entry_urls,
+
+        route_patterns,
+        route_nested_files,
+        route_type_and_flags,
+        route_source_files,
+        route_param_info,
+        route_style_references,
+    );
+    render_promise.setHandled(vm.jsc);
+    vm.waitForPromise(.{ .normal = render_promise });
+    switch (render_promise.unwrap(vm.jsc, .mark_handled)) {
+        .pending => unreachable,
+        .fulfilled => {
+            Output.prettyln("done", .{});
+            Output.flush();
+        },
+        .rejected => |err| {
+            return vm.global.throwValue(err);
+        },
+    }
+}
+
+/// 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 {
+    const promise = BakeLoadModuleByKey(global, key).asAnyPromise().?.internal;
+    promise.setHandled(vm.jsc);
+    vm.waitForPromise(.{ .internal = promise });
+    switch (promise.unwrap(vm.jsc, .mark_handled)) {
+        .pending => unreachable,
+        .fulfilled => |val| {
+            bun.assert(val == .undefined);
+            return BakeGetModuleNamespace(global, key);
+        },
+        .rejected => |err| {
+            return vm.global.throwValue(err);
+        },
+    }
+}
+
+// extern apis:
+
+// TODO: Dedupe
+extern fn BakeGetDefaultExportFromModule(global: *JSC.JSGlobalObject, key: JSValue) JSValue;
+extern fn BakeGetModuleNamespace(global: *JSC.JSGlobalObject, key: JSValue) JSValue;
+extern fn BakeLoadModuleByKey(global: *JSC.JSGlobalObject, key: JSValue) JSValue;
+
+fn BakeGetOnModuleNamespace(global: *JSC.JSGlobalObject, module: JSValue, property: []const u8) ?JSValue {
+    const f = @extern(*const fn (*JSC.JSGlobalObject, JSValue, [*]const u8, usize) callconv(.C) JSValue, .{
+        .name = "BakeGetOnModuleNamespace",
+    });
+    const result: JSValue = f(global, module, property.ptr, property.len);
+    bun.assert(result != .zero);
+    return result;
+}
+
+extern fn BakeRenderRoutesForProdStatic(
+    *JSC.JSGlobalObject,
+    out_base: bun.String,
+    all_server_files: JSValue,
+    render_static: JSValue,
+    get_params: 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(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.
+fn BakeRegisterProductionChunk(global: *JSC.JSGlobalObject, key: bun.String, source_code: bun.String) bun.JSError!JSValue {
+    const f = @extern(*const fn (*JSC.JSGlobalObject, bun.String, bun.String) callconv(.C) JSValue, .{
+        .name = "BakeRegisterProductionChunk",
+    });
+    const result: JSValue = f(global, key, source_code);
+    if (result == .zero) return error.JSError;
+    bun.assert(result.isString());
+    return result;
+}
+
+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();
+
+    const specifier = specifier_str.toUTF8(alloc);
+    defer specifier.deinit();
+
+    if (JSC.HardcodedModule.Aliases.get(specifier.slice(), .bun)) |alias| {
+        return bun.String.static(alias.path);
+    }
+
+    const referrer = a_str.toUTF8(alloc);
+    defer referrer.deinit();
+
+    if (bun.resolver.isPackagePath(specifier.slice())) {
+        return global.throw("Non-relative import {} from {} are not allowed in production assets. This is a bug in Bun's bundler", .{
+            bun.fmt.quote(specifier.slice()),
+            bun.fmt.quote(referrer.slice()),
+        }) catch bun.String.dead;
+    }
+
+    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;
+}
+
+/// After a production bundle is generated, prerendering needs to be able to
+/// look up the generated chunks associated with each route's `OpaqueFileId`
+/// This data structure contains that mapping, and is also used by bundle_v2
+/// to enqueue the entry points.
+pub const EntryPointMap = struct {
+    root: []const u8,
+
+    allocator: std.mem.Allocator,
+    /// OpaqueFileId refers to the index in this map.
+    /// Values are left uninitialized until after the bundle is done and indexed.
+    files: HashMap,
+
+    const HashMap = std.ArrayHashMapUnmanaged(InputFile, OutputFile.Index, InputFile.ArrayHashContext, true);
+
+    /// This approach is used instead of what DevServer does so that each
+    /// distinct file gets its own index.
+    const InputFile = struct {
+        abs_path_ptr: [*]const u8,
+        abs_path_len: u32,
+        side: bake.Side,
+
+        pub fn init(abs_path: []const u8, side: bake.Side) InputFile {
+            return .{
+                .abs_path_ptr = abs_path.ptr,
+                .abs_path_len = @intCast(abs_path.len),
+                .side = side,
+            };
+        }
+
+        pub fn absPath(key: InputFile) []const u8 {
+            return key.abs_path_ptr[0..key.abs_path_len];
+        }
+
+        const ArrayHashContext = struct {
+            pub fn hash(_: @This(), key: InputFile) u32 {
+                return bun.hash32(key.absPath()) +% @intFromEnum(key.side);
+            }
+
+            pub fn eql(_: @This(), a: InputFile, b: InputFile, _: usize) bool {
+                return a.side == b.side and bun.strings.eql(a.absPath(), b.absPath());
+            }
+        };
+    };
+
+    pub fn getOrPutEntryPoint(map: *EntryPointMap, abs_path: []const u8, side: bake.Side) !OpaqueFileId {
+        const k = InputFile.init(abs_path, side);
+        const gop = try map.files.getOrPut(map.allocator, k);
+        if (!gop.found_existing) {
+            errdefer map.files.swapRemoveAt(gop.index);
+            gop.key_ptr.* = InputFile.init(try map.allocator.dupe(u8, abs_path), side);
+        }
+        return OpaqueFileId.init(@intCast(gop.index));
+    }
+
+    pub fn getFileIdForRouter(map: *EntryPointMap, abs_path: []const u8, _: FrameworkRouter.Route.Index, _: FrameworkRouter.Route.FileKind) !FrameworkRouter.OpaqueFileId {
+        return map.getOrPutEntryPoint(abs_path, .server);
+    }
+
+    pub fn onRouterCollisionError(dev: *EntryPointMap, rel_path: []const u8, other_id: OpaqueFileId, ty: FrameworkRouter.Route.FileKind) bun.OOM!void {
+        Output.errGeneric("Multiple {s} matching the same route pattern is ambiguous", .{
+            switch (ty) {
+                .page => "pages",
+                .layout => "layout",
+            },
+        });
+        Output.prettyErrorln("  - <blue>{s}<r>", .{rel_path});
+        Output.prettyErrorln("  - <blue>{s}<r>", .{
+            bun.path.relative(dev.root, dev.files.keys()[other_id.get()].absPath()),
+        });
+        Output.flush();
+    }
+};
+
+/// Data used on each rendering thread. Contains all information in the bundle needed to render.
+/// This is referred to as `pt` in variable/field naming, and Bake::ProductionPerThread in C++
+pub const PerThread = struct {
+    // Shared Data
+    input_files: []const EntryPointMap.InputFile,
+    bundled_outputs: []const OutputFile,
+    /// Indexed by entry point index (OpaqueFileId)
+    output_indexes: []const OutputFile.Index,
+    /// Indexed by entry point index (OpaqueFileId)
+    module_keys: []const bun.String,
+    /// Unordered
+    module_map: bun.StringArrayHashMapUnmanaged(OutputFile.Index),
+
+    // Thread-local
+    vm: *JSC.VirtualMachine,
+    /// Indexed by entry point index (OpaqueFileId)
+    loaded_files: bun.bit_set.AutoBitSet,
+    /// JSArray of JSString, indexed by entry point index (OpaqueFileId)
+    all_server_files: JSC.JSValue,
+
+    /// Sent to other threads for rendering
+    pub const Options = struct {
+        input_files: []const EntryPointMap.InputFile,
+        bundled_outputs: []const OutputFile,
+        /// Indexed by entry point index (OpaqueFileId)
+        output_indexes: []const OutputFile.Index,
+        /// Indexed by entry point index (OpaqueFileId)
+        module_keys: []const bun.String,
+        /// Unordered
+        module_map: bun.StringArrayHashMapUnmanaged(OutputFile.Index),
+    };
+
+    extern fn BakeGlobalObject__attachPerThreadData(global: *JSC.JSGlobalObject, pt: ?*PerThread) void;
+
+    /// After initializing, call `attach`
+    pub fn init(vm: *VirtualMachine, opts: Options) !PerThread {
+        const loaded_files = try bun.bit_set.AutoBitSet.initEmpty(vm.allocator, opts.output_indexes.len);
+        errdefer loaded_files.deinit(vm.allocator);
+
+        const all_server_files = JSValue.createEmptyArray(vm.global, opts.output_indexes.len);
+        all_server_files.protect();
+
+        return .{
+            .input_files = opts.input_files,
+            .bundled_outputs = opts.bundled_outputs,
+            .output_indexes = opts.output_indexes,
+            .module_keys = opts.module_keys,
+            .module_map = opts.module_map,
+            .vm = vm,
+            .loaded_files = loaded_files,
+            .all_server_files = all_server_files,
+        };
+    }
+
+    pub fn attach(pt: *PerThread) void {
+        BakeGlobalObject__attachPerThreadData(pt.vm.global, pt);
+    }
+
+    pub fn deinit(pt: *PerThread) void {
+        BakeGlobalObject__attachPerThreadData(pt.vm.global, null);
+        pt.all_server_files.unprotect();
+    }
+
+    pub fn outputIndex(s: PerThread, id: OpaqueFileId) OutputFile.Index {
+        return s.output_indexes[id.get()];
+    }
+
+    pub fn inputFile(s: PerThread, id: OpaqueFileId) EntryPointMap.InputFile {
+        return s.input_files[id.get()];
+    }
+
+    pub fn outputFile(s: PerThread, id: OpaqueFileId) *const OutputFile {
+        return &s.bundled_outputs[s.outputIndex(id).get()];
+    }
+
+    // Must be run at the top of the event loop
+    pub fn loadBundledModule(pt: *PerThread, id: OpaqueFileId) bun.JSError!JSValue {
+        return try loadModule(
+            pt.vm,
+            pt.vm.global,
+            pt.module_keys[id.get()].toJS(pt.vm.global),
+        );
+    }
+
+    /// The JSString entries in `all_server_files` is generated lazily. When
+    /// multiple rendering threads are used, unreferenced files will contain
+    /// holes in the array used. Returns a JSValue of the "FileIndex" type
+    //
+    // What could be done here is generating a new index type, which is
+    // specifically for referenced files. This would remove the holes, but make
+    // it harder to pre-allocate. It's probably worth it.
+    pub fn preloadBundledModule(pt: *PerThread, id: OpaqueFileId) JSValue {
+        if (!pt.loaded_files.isSet(id.get())) {
+            pt.loaded_files.set(id.get());
+            pt.all_server_files.putIndex(
+                pt.vm.global,
+                @intCast(id.get()),
+                pt.module_keys[id.get()].toJS(pt.vm.global),
+            );
+        }
+
+        return JSValue.jsNumberFromInt32(@intCast(id.get()));
+    }
+};
+
+/// Given a key, returns the source code to load.
+export fn BakeProdLoad(pt: *PerThread, key: bun.String) bun.String {
+    var sfa = std.heap.stackFallback(4096, bun.default_allocator);
+    const allocator = sfa.get();
+    const utf8 = key.toUTF8(allocator);
+    defer utf8.deinit();
+    if (pt.module_map.get(utf8.slice())) |value| {
+        return pt.bundled_outputs[value.get()].value.toBunString();
+    }
+    for (pt.module_map.keys()) |keys| {
+        std.debug.print("key that does exist: {s}\n", .{keys});
+    }
+    return bun.String.dead;
+}
+
+const TypeAndFlags = packed struct(i32) {
+    type: u8,
+    unused: u24 = 0,
+};
+
+const std = @import("std");
+
+const bun = @import("root").bun;
+const Environment = bun.Environment;
+const Output = bun.Output;
+const OutputFile = bun.options.OutputFile;
+
+const bake = bun.bake;
+const FrameworkRouter = bake.FrameworkRouter;
+const OpaqueFileId = FrameworkRouter.OpaqueFileId;
+
+const JSC = bun.JSC;
+const JSValue = JSC.JSValue;
+const VirtualMachine = JSC.VirtualMachine;
diff --git a/src/bake/shared.ts b/src/bake/shared.ts
new file mode 100644
index 0000000000..cb3f789fa6
--- /dev/null
+++ b/src/bake/shared.ts
@@ -0,0 +1 @@
+export const td = /* #__PURE__ */ new TextDecoder();
diff --git a/src/bake/tsconfig.json b/src/bake/tsconfig.json
new file mode 100644
index 0000000000..81f1f16c3a
--- /dev/null
+++ b/src/bake/tsconfig.json
@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "lib": ["DOM", "ESNext"],
+    "module": "esnext",
+    "target": "esnext",
+    "moduleResolution": "Bundler",
+    "allowImportingTsExtensions": true,
+    "noEmit": true,
+    "strict": true,
+    "noImplicitAny": false,
+    "allowJs": true,
+    "downlevelIteration": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "paths": {
+      "bun-framework-react/*": ["./bun-framework-react/*"]
+    },
+    "jsx": "react-jsx",
+    "types": ["react/experimental"]
+  },
+  "include": ["**/*.ts", "**/*.tsx"]
+}
diff --git a/src/bitflags.zig b/src/bitflags.zig
new file mode 100644
index 0000000000..d70a018fa8
--- /dev/null
+++ b/src/bitflags.zig
@@ -0,0 +1,110 @@
+const std = @import("std");
+
+pub fn Bitflags(comptime T: type) type {
+    const tyinfo = @typeInfo(T);
+    const IntType = tyinfo.Struct.backing_integer.?;
+    const IntTypeInfo = @typeInfo(IntType);
+    const IntRepresentingNumOfBits = std.math.IntFittingRange(0, IntTypeInfo.Int.bits);
+
+    return struct {
+        pub inline fn empty() T {
+            return @bitCast(@as(IntType, 0));
+        }
+
+        pub inline fn intersects(lhs: T, rhs: T) bool {
+            return asBits(lhs) & asBits(rhs) != 0;
+        }
+
+        pub inline fn fromName(comptime name: []const u8) T {
+            var this: T = .{};
+            @field(this, name) = true;
+            return this;
+        }
+
+        pub inline fn fromNames(comptime names: []const []const u8) T {
+            var this: T = .{};
+            inline for (names) |name| {
+                @field(this, name) = true;
+            }
+            return this;
+        }
+
+        pub fn bitwiseOr(lhs: T, rhs: T) T {
+            return @bitCast(@as(IntType, @bitCast(lhs)) | @as(IntType, @bitCast(rhs)));
+        }
+
+        pub fn bitwiseAnd(lhs: T, rhs: T) T {
+            return @bitCast(@as(IntType, asBits(lhs) & asBits(rhs)));
+        }
+
+        pub inline fn insert(this: *T, other: T) void {
+            this.* = bitwiseOr(this.*, other);
+        }
+
+        pub inline fn remove(this: *T, other: T) void {
+            this.* = @bitCast(asBits(this.*) & ~asBits(other));
+        }
+
+        pub inline fn maskOut(this: T, other: T) T {
+            return @bitCast(asBits(this) & ~asBits(other));
+        }
+
+        pub fn contains(lhs: T, rhs: T) bool {
+            return @as(IntType, @bitCast(lhs)) & @as(IntType, @bitCast(rhs)) != 0;
+        }
+
+        pub inline fn leadingZeroes(this: T) IntRepresentingNumOfBits {
+            return @clz(asBits(this));
+        }
+
+        pub inline fn all() T {
+            var ret: T = @bitCast(@as(IntType, 0));
+            @setEvalBranchQuota(5000);
+            inline for (std.meta.fields(T)) |field| {
+                if (comptime !std.mem.eql(u8, field.name, "__unused")) {
+                    @field(ret, field.name) = true;
+                }
+            }
+            return ret;
+        }
+
+        pub inline fn not(this: T) T {
+            return fromBitsTruncate(~asBits(this));
+        }
+
+        pub inline fn difference(lhs: T, rhs: T) T {
+            // 1100     1100        1100
+            // 1010     0101        0100
+            return @bitCast(asBits(lhs) & asBits(not(rhs)));
+        }
+
+        /// Convert from a bits value, unsetting any unknown bits.
+        pub inline fn fromBitsTruncate(bits: IntType) T {
+            return bitwiseAnd(@bitCast(bits), all());
+        }
+
+        pub inline fn asBits(this: T) IntType {
+            return @as(IntType, @bitCast(this));
+        }
+
+        pub fn isEmpty(this: T) bool {
+            return asBits(this) == 0;
+        }
+
+        pub fn eq(lhs: T, rhs: T) bool {
+            return asBits(lhs) == asBits(rhs);
+        }
+
+        pub fn eql(lhs: T, rhs: T) bool {
+            return eq(lhs, rhs);
+        }
+
+        pub fn neq(lhs: T, rhs: T) bool {
+            return asBits(lhs) != asBits(rhs);
+        }
+
+        pub fn hash(this: *const T, hasher: *std.hash.Wyhash) void {
+            hasher.update(std.mem.asBytes(this));
+        }
+    };
+}
diff --git a/src/brotli.zig b/src/brotli.zig
index 0759261d46..464d4b55c8 100644
--- a/src/brotli.zig
+++ b/src/brotli.zig
@@ -9,7 +9,7 @@ const BrotliEncoder = c.BrotliEncoder;
 
 const mimalloc = bun.Mimalloc;
 
-const BrotliAllocator = struct {
+pub const BrotliAllocator = struct {
     pub fn alloc(_: ?*anyopaque, len: usize) callconv(.C) *anyopaque {
         if (bun.heap_breakdown.enabled) {
             const zone = bun.heap_breakdown.getZone("brotli");
diff --git a/src/bun.js/BuildMessage.zig b/src/bun.js/BuildMessage.zig
index 468dd29c42..f69a581cad 100644
--- a/src/bun.js/BuildMessage.zig
+++ b/src/bun.js/BuildMessage.zig
@@ -19,21 +19,16 @@ 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.throw("BuildMessage is not constructable", .{});
     }
 
     pub fn getNotes(this: *BuildMessage, globalThis: *JSC.JSGlobalObject) JSC.JSValue {
-        const notes: []const logger.Data = this.msg.notes orelse &[_]logger.Data{};
+        const notes = this.msg.notes;
         const array = JSC.JSValue.createEmptyArray(globalThis, notes.len);
         for (notes, 0..) |note, i| {
             const cloned = note.clone(bun.default_allocator) catch {
-                globalThis.throwOutOfMemory();
-                return .zero;
+                return globalThis.throwOutOfMemoryValue();
             };
             array.putIndex(
                 globalThis,
@@ -47,8 +42,7 @@ pub const BuildMessage = struct {
 
     pub fn toStringFn(this: *BuildMessage, globalThis: *JSC.JSGlobalObject) JSC.JSValue {
         const text = std.fmt.allocPrint(default_allocator, "BuildMessage: {s}", .{this.msg.data.text}) catch {
-            globalThis.throwOutOfMemory();
-            return .zero;
+            return globalThis.throwOutOfMemoryValue();
         };
         var str = ZigString.init(text);
         str.setOutputEncoding();
@@ -81,7 +75,7 @@ pub const BuildMessage = struct {
         this: *BuildMessage,
         globalThis: *JSC.JSGlobalObject,
         _: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         return this.toStringFn(globalThis);
     }
 
@@ -89,8 +83,8 @@ pub const BuildMessage = struct {
         this: *BuildMessage,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
-        const args_ = callframe.arguments(1);
+    ) bun.JSError!JSC.JSValue {
+        const args_ = callframe.arguments_old(1);
         const args = args_.ptr[0..args_.len];
         if (args.len > 0) {
             if (!args[0].isString()) {
@@ -110,9 +104,9 @@ 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"), ZigString.init("BuildMessage").toJS(globalThis));
+        object.put(globalThis, ZigString.static("name"), bun.String.static("BuildMessage").toJS(globalThis));
         object.put(globalThis, ZigString.static("position"), this.getPosition(globalThis));
         object.put(globalThis, ZigString.static("message"), this.getMessage(globalThis));
         object.put(globalThis, ZigString.static("level"), this.getLevel(globalThis));
diff --git a/src/bun.js/ConsoleObject.zig b/src/bun.js/ConsoleObject.zig
index 58141dec83..5f08103018 100644
--- a/src/bun.js/ConsoleObject.zig
+++ b/src/bun.js/ConsoleObject.zig
@@ -32,6 +32,7 @@ const Counter = std.AutoHashMapUnmanaged(u64, u32);
 const BufferedWriter = std.io.BufferedWriter(4096, Output.WriterType);
 error_writer: BufferedWriter,
 writer: BufferedWriter,
+default_indent: u16 = 0,
 
 counts: Counter = .{},
 
@@ -80,7 +81,7 @@ threadlocal var stdout_lock_count: u16 = 0;
 /// https://console.spec.whatwg.org/#formatter
 pub fn messageWithTypeAndLevel(
     //console_: ConsoleObject.Type,
-    _: ConsoleObject.Type,
+    ctype: ConsoleObject.Type,
     message_type: MessageType,
     //message_level: u32,
     level: MessageLevel,
@@ -88,11 +89,37 @@ pub fn messageWithTypeAndLevel(
     vals: [*]const JSValue,
     len: usize,
 ) callconv(JSC.conv) void {
+    messageWithTypeAndLevel_(ctype, message_type, level, global, vals, len) catch |err| switch (err) {
+        error.JSError => {},
+        error.OutOfMemory => global.throwOutOfMemory() catch {}, // TODO: properly propagate exception upwards
+    };
+}
+fn messageWithTypeAndLevel_(
+    //console_: ConsoleObject.Type,
+    _: ConsoleObject.Type,
+    message_type: MessageType,
+    //message_level: u32,
+    level: MessageLevel,
+    global: *JSGlobalObject,
+    vals: [*]const JSValue,
+    len: usize,
+) bun.JSError!void {
     if (comptime is_bindgen) {
         return;
     }
 
     var console = global.bunVM().console;
+    defer console.default_indent +|= @as(u16, @intFromBool(message_type == .StartGroup));
+
+    if (message_type == .StartGroup and len == 0) {
+        // undefined is printed if passed explicitly.
+        return;
+    }
+
+    if (message_type == .EndGroup) {
+        console.default_indent -|= 1;
+        return;
+    }
 
     // Lock/unlock a mutex incase two JS threads are console.log'ing at the same time
     // We do this the slightly annoying way to avoid assigning a pointer
@@ -157,6 +184,7 @@ pub fn messageWithTypeAndLevel(
         .enable_colors = enable_colors,
         .add_newline = true,
         .flush = true,
+        .default_indent = console.default_indent,
     };
 
     if (message_type == .Table and len >= 1) {
@@ -170,6 +198,7 @@ pub fn messageWithTypeAndLevel(
                 tabular_data,
                 properties,
             );
+            table_printer.value_formatter.indent += console.default_indent;
 
             switch (enable_colors) {
                 inline else => |colors| table_printer.printTable(Writer, writer, colors) catch return,
@@ -183,13 +212,13 @@ pub fn messageWithTypeAndLevel(
         print_length = 1;
         var opts = vals[1];
         if (opts.isObject()) {
-            if (opts.get(global, "depth")) |depth_prop| {
+            if (try opts.get(global, "depth")) |depth_prop| {
                 if (depth_prop.isInt32() or depth_prop.isNumber() or depth_prop.isBigInt())
                     print_options.max_depth = depth_prop.toU16()
                 else if (depth_prop.isNull())
                     print_options.max_depth = std.math.maxInt(u16);
             }
-            if (opts.get(global, "colors")) |colors_prop| {
+            if (try opts.get(global, "colors")) |colors_prop| {
                 if (colors_prop.isBoolean())
                     print_options.enable_colors = colors_prop.toBoolean();
             }
@@ -219,7 +248,7 @@ pub fn messageWithTypeAndLevel(
     }
 }
 
-const TablePrinter = struct {
+pub const TablePrinter = struct {
     const Column = struct {
         name: String,
         width: u32 = 1,
@@ -342,7 +371,7 @@ const TablePrinter = struct {
             //  - otherwise: iterate the object properties, and create the columns on-demand
             if (!this.properties.isUndefined()) {
                 for (columns.items[1..]) |*column| {
-                    if (row_value.getWithString(this.globalObject, column.name)) |value| {
+                    if (row_value.getOwn(this.globalObject, column.name)) |value| {
                         column.width = @max(column.width, this.getWidthForValue(value));
                     }
                 }
@@ -436,10 +465,10 @@ const TablePrinter = struct {
                     value = row_value;
                 }
             } else if (row_value.isObject()) {
-                value = row_value.getWithString(this.globalObject, col.name) orelse JSValue.zero;
+                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);
@@ -666,6 +695,66 @@ pub const FormatOptions = struct {
     ordered_properties: bool = false,
     quote_strings: bool = false,
     max_depth: u16 = 2,
+    single_line: bool = false,
+    default_indent: u16 = 0,
+
+    pub fn fromJS(formatOptions: *FormatOptions, globalThis: *JSC.JSGlobalObject, arguments: []const JSC.JSValue) bun.JSError!void {
+        const arg1 = arguments[0];
+
+        if (arg1.isObject()) {
+            if (try arg1.getTruthy(globalThis, "depth")) |opt| {
+                if (opt.isInt32()) {
+                    const arg = opt.toInt32();
+                    if (arg < 0) {
+                        return globalThis.throwInvalidArguments("expected depth to be greater than or equal to 0, got {d}", .{arg});
+                    }
+                    formatOptions.max_depth = @as(u16, @truncate(@as(u32, @intCast(@min(arg, std.math.maxInt(u16))))));
+                } else if (opt.isNumber()) {
+                    const v = opt.coerce(f64, globalThis);
+                    if (std.math.isInf(v)) {
+                        formatOptions.max_depth = std.math.maxInt(u16);
+                    } else {
+                        return globalThis.throwInvalidArguments("expected depth to be an integer, got {d}", .{v});
+                    }
+                }
+            }
+            if (try arg1.getBooleanLoose(globalThis, "colors")) |opt| {
+                formatOptions.enable_colors = opt;
+            }
+            if (try arg1.getBooleanLoose(globalThis, "sorted")) |opt| {
+                formatOptions.ordered_properties = opt;
+            }
+
+            if (try arg1.getBooleanLoose(globalThis, "compact")) |opt| {
+                formatOptions.single_line = opt;
+            }
+        } else {
+            // formatOptions.show_hidden = arg1.toBoolean();
+            if (arguments.len > 0) {
+                var depthArg = arg1;
+                if (depthArg.isInt32()) {
+                    const arg = depthArg.toInt32();
+                    if (arg < 0) {
+                        return globalThis.throwInvalidArguments("expected depth to be greater than or equal to 0, got {d}", .{arg});
+                    }
+                    formatOptions.max_depth = @as(u16, @truncate(@as(u32, @intCast(@min(arg, std.math.maxInt(u16))))));
+                } else if (depthArg.isNumber()) {
+                    const v = depthArg.coerce(f64, globalThis);
+                    if (std.math.isInf(v)) {
+                        formatOptions.max_depth = std.math.maxInt(u16);
+                    } else {
+                        return globalThis.throwInvalidArguments("expected depth to be an integer, got {d}", .{v});
+                    }
+                }
+                if (arguments.len > 1 and !arguments[1].isEmptyOrUndefinedOrNull()) {
+                    formatOptions.enable_colors = arguments[1].coerce(bool, globalThis);
+                    if (globalThis.hasException()) {
+                        return error.JSError;
+                    }
+                }
+            }
+        }
+    }
 };
 
 pub fn format2(
@@ -694,8 +783,11 @@ pub fn format2(
             .ordered_properties = options.ordered_properties,
             .quote_strings = options.quote_strings,
             .max_depth = options.max_depth,
+            .single_line = options.single_line,
+            .indent = options.default_indent,
         };
         const tag = ConsoleObject.Formatter.Tag.get(vals[0], global);
+        fmt.writeIndent(Writer, writer) catch return;
 
         if (tag.tag == .String) {
             if (options.enable_colors) {
@@ -771,9 +863,13 @@ pub fn format2(
         .globalThis = global,
         .ordered_properties = options.ordered_properties,
         .quote_strings = options.quote_strings,
+        .single_line = options.single_line,
+        .indent = options.default_indent,
     };
     var tag: ConsoleObject.Formatter.Tag.Result = undefined;
 
+    fmt.writeIndent(Writer, writer) catch return;
+
     var any = false;
     if (options.enable_colors) {
         if (level == .Error) {
@@ -887,7 +983,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 {
@@ -1058,7 +1154,7 @@ pub const Formatter = struct {
                 };
             }
 
-            if (js_type.canGet()) {
+            if (js_type.canGet() and js_type != .ProxyObject) {
                 // Attempt to get custom formatter
                 if (value.fastGet(globalThis, .inspectCustom)) |callback_value| {
                     if (callback_value.isCallable(globalThis.vm())) {
@@ -1117,7 +1213,7 @@ pub const Formatter = struct {
             }
 
             // Is this a react element?
-            if (js_type.isObject()) {
+            if (js_type.isObject() and js_type != .ProxyObject) {
                 if (value.getOwnTruthy(globalThis, "$$typeof")) |typeof_symbol| {
                     var reactElement = ZigString.init("react.element");
                     var react_fragment = ZigString.init("react.fragment");
@@ -1132,19 +1228,24 @@ pub const Formatter = struct {
                 .tag = switch (js_type) {
                     .ErrorInstance => .Error,
                     .NumberObject => .Double,
-                    .DerivedArray, JSValue.JSType.Array => .Array,
+                    .DerivedArray, JSValue.JSType.Array, .DirectArguments, .ScopedArguments, .ClonedArguments => .Array,
                     .DerivedStringObject, JSValue.JSType.String, JSValue.JSType.StringObject => .String,
                     .RegExpObject => .String,
                     .Symbol => .Symbol,
                     .BooleanObject => .Boolean,
                     .JSFunction => .Function,
-                    .JSWeakMap, JSValue.JSType.JSMap => .Map,
-                    .JSMapIterator => .MapIterator,
-                    .JSSetIterator => .SetIterator,
-                    .JSWeakSet, JSValue.JSType.JSSet => .Set,
+                    .WeakMap, JSValue.JSType.Map => .Map,
+                    .MapIterator => .MapIterator,
+                    .SetIterator => .SetIterator,
+                    .WeakSet, JSValue.JSType.Set => .Set,
                     .JSDate => .JSON,
                     .JSPromise => .Promise,
 
+                    .WrapForValidIterator,
+                    .RegExpStringIterator,
+                    .JSArrayIterator,
+                    .Iterator,
+                    .IteratorHelper,
                     .Object,
                     .FinalObject,
                     .ModuleNamespaceObject,
@@ -1572,8 +1673,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;
@@ -1778,7 +1879,7 @@ pub const Formatter = struct {
 
                         writer.print(
                             comptime Output.prettyFmt("<r><green>{s}<r><d>:<r> ", enable_ansi_colors),
-                            .{JSPrinter.formatJSONString(key.slice())},
+                            .{bun.fmt.formatJSONString(key.slice())},
                         );
                     }
                 } else if (Environment.isDebug and is_private_symbol) {
@@ -1820,6 +1921,8 @@ pub const Formatter = struct {
         value.getClassName(globalThis, &name_str);
         if (!name_str.eqlComptime("Object")) {
             return name_str;
+        } else if (value.getPrototype(globalThis).eqlValue(JSValue.null)) {
+            return ZigString.static("[Object: null prototype]").*;
         }
         return null;
     }
@@ -1859,7 +1962,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;
@@ -1868,7 +1971,7 @@ pub const Formatter = struct {
 
         defer {
             if (comptime Format.canHaveCircularReferences()) {
-                _ = this.map.remove(@intFromEnum(value));
+                _ = this.map.remove(value);
             }
         }
 
@@ -2064,10 +2167,23 @@ pub const Formatter = struct {
                 value.getClassName(this.globalThis, &printable);
                 this.addForNewLine(printable.len);
 
+                const proto = value.getPrototype(this.globalThis);
+                var printable_proto = ZigString.init(&name_buf);
+                proto.getClassName(this.globalThis, &printable_proto);
+                this.addForNewLine(printable_proto.len);
+
                 if (printable.len == 0) {
-                    writer.print(comptime Output.prettyFmt("<cyan>[class (anonymous)]<r>", enable_ansi_colors), .{});
+                    if (printable_proto.isEmpty()) {
+                        writer.print(comptime Output.prettyFmt("<cyan>[class (anonymous)]<r>", enable_ansi_colors), .{});
+                    } else {
+                        writer.print(comptime Output.prettyFmt("<cyan>[class (anonymous) extends {}]<r>", enable_ansi_colors), .{printable_proto});
+                    }
                 } else {
-                    writer.print(comptime Output.prettyFmt("<cyan>[class {}]<r>", enable_ansi_colors), .{printable});
+                    if (printable_proto.isEmpty()) {
+                        writer.print(comptime Output.prettyFmt("<cyan>[class {}]<r>", enable_ansi_colors), .{printable});
+                    } else {
+                        writer.print(comptime Output.prettyFmt("<cyan>[class {} extends {}]<r>", enable_ansi_colors), .{ printable, printable_proto });
+                    }
                 }
             },
             .Function => {
@@ -2078,7 +2194,7 @@ pub const Formatter = struct {
                 const func_name = proto.getName(this.globalThis); // "Function" | "AsyncFunction" | "GeneratorFunction" | "AsyncGeneratorFunction"
                 defer func_name.deref();
 
-                if (printable.isEmpty()) {
+                if (printable.isEmpty() or func_name.eql(printable)) {
                     if (func_name.isEmpty()) {
                         writer.print(comptime Output.prettyFmt("<cyan>[Function]<r>", enable_ansi_colors), .{});
                     } else {
@@ -2169,7 +2285,7 @@ pub const Formatter = struct {
                             this.addForNewLine(2);
                         }
 
-                        if (element.isEmpty()) {
+                        if (element == .zero) {
                             empty_start = 0;
                             break :first;
                         }
@@ -2188,7 +2304,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;
                             }
@@ -2268,16 +2384,18 @@ pub const Formatter = struct {
                         }
                     }
 
-                    const Iterator = PropertyIterator(Writer, enable_ansi_colors);
-                    var iter = Iterator{
-                        .formatter = this,
-                        .writer = writer_,
-                        .always_newline = !this.single_line and (this.always_newline_scope or this.goodTimeForANewLine()),
-                        .single_line = this.single_line,
-                        .parent = value,
-                        .i = i,
-                    };
-                    value.forEachPropertyNonIndexed(this.globalThis, &iter, Iterator.forEach);
+                    if (!jsType.isArguments()) {
+                        const Iterator = PropertyIterator(Writer, enable_ansi_colors);
+                        var iter = Iterator{
+                            .formatter = this,
+                            .writer = writer_,
+                            .always_newline = !this.single_line and (this.always_newline_scope or this.goodTimeForANewLine()),
+                            .single_line = this.single_line,
+                            .parent = value,
+                            .i = i,
+                        };
+                        value.forEachPropertyNonIndexed(this.globalThis, &iter, Iterator.forEach);
+                    }
                 }
 
                 if (!this.single_line and (this.ordered_properties or was_good_time or this.goodTimeForANewLine())) {
@@ -2306,7 +2424,7 @@ pub const Formatter = struct {
                     blob.writeFormat(ConsoleObject.Formatter, this, writer_, enable_ansi_colors) catch {};
                     return;
                 } else if (value.as(JSC.FetchHeaders) != null) {
-                    if (value.get(this.globalThis, "toJSON")) |toJSONFunction| {
+                    if (value.get_unsafe(this.globalThis, "toJSON")) |toJSONFunction| {
                         this.addForNewLine("Headers ".len);
                         writer.writeAll(comptime Output.prettyFmt("<r>Headers ", enable_ansi_colors));
                         const prev_quote_keys = this.quote_keys;
@@ -2324,7 +2442,7 @@ pub const Formatter = struct {
                         );
                     }
                 } else if (value.as(JSC.DOMFormData) != null) {
-                    if (value.get(this.globalThis, "toJSON")) |toJSONFunction| {
+                    if (value.get_unsafe(this.globalThis, "toJSON")) |toJSONFunction| {
                         const prev_quote_keys = this.quote_keys;
                         this.quote_keys = true;
                         defer this.quote_keys = prev_quote_keys;
@@ -2374,8 +2492,15 @@ pub const Formatter = struct {
                 return this.printAs(.Object, Writer, writer_, value, .Event, enable_ansi_colors);
             },
             .NativeCode => {
-                this.addForNewLine("[native code]".len);
-                writer.writeAll("[native code]");
+                if (value.getClassInfoName()) |class_name| {
+                    this.addForNewLine("[native code: ]".len + class_name.len);
+                    writer.writeAll("[native code: ");
+                    writer.writeAll(class_name);
+                    writer.writeAll("]");
+                } else {
+                    this.addForNewLine("[native code]".len);
+                    writer.writeAll("[native code]");
+                }
             },
             .Promise => {
                 if (!this.single_line and this.goodTimeForANewLine()) {
@@ -2426,14 +2551,14 @@ pub const Formatter = struct {
                 writer.writeAll(comptime Output.prettyFmt("<cyan>" ++ fmt ++ "<r>", enable_ansi_colors));
             },
             .Map => {
-                const length_value = value.get(this.globalThis, "size") orelse JSC.JSValue.jsNumberFromInt32(0);
+                const length_value = value.get_unsafe(this.globalThis, "size") orelse JSC.JSValue.jsNumberFromInt32(0);
                 const length = length_value.toInt32();
 
                 const prev_quote_strings = this.quote_strings;
                 this.quote_strings = true;
                 defer this.quote_strings = prev_quote_strings;
 
-                const map_name = if (value.jsType() == .JSWeakMap) "WeakMap" else "Map";
+                const map_name = if (value.jsType() == .WeakMap) "WeakMap" else "Map";
 
                 if (length == 0) {
                     return writer.print("{s} {{}}", .{map_name});
@@ -2530,7 +2655,7 @@ pub const Formatter = struct {
                 writer.writeAll("}");
             },
             .Set => {
-                const length_value = value.get(this.globalThis, "size") orelse JSC.JSValue.jsNumberFromInt32(0);
+                const length_value = value.get_unsafe(this.globalThis, "size") orelse JSC.JSValue.jsNumberFromInt32(0);
                 const length = length_value.toInt32();
 
                 const prev_quote_strings = this.quote_strings;
@@ -2541,7 +2666,7 @@ pub const Formatter = struct {
                     this.writeIndent(Writer, writer_) catch {};
                 }
 
-                const set_name = if (value.jsType() == .JSWeakSet) "WeakSet" else "Set";
+                const set_name = if (value.jsType() == .WeakSet) "WeakSet" else "Set";
 
                 if (length == 0) {
                     return writer.print("{s} {{}}", .{set_name});
@@ -2576,7 +2701,7 @@ pub const Formatter = struct {
                 writer.writeAll("}");
             },
             .toJSON => {
-                if (value.get(this.globalThis, "toJSON")) |func| brk: {
+                if (value.get_unsafe(this.globalThis, "toJSON")) |func| brk: {
                     const result = func.call(this.globalThis, value, &.{}) catch {
                         this.globalThis.clearException();
                         break :brk;
@@ -2616,7 +2741,7 @@ pub const Formatter = struct {
             },
             .Event => {
                 const event_type_value = brk: {
-                    const value_ = value.get(this.globalThis, "type") orelse break :brk JSValue.undefined;
+                    const value_ = value.get_unsafe(this.globalThis, "type") orelse break :brk JSValue.undefined;
                     if (value_.isString()) {
                         break :brk value_;
                     }
@@ -2737,7 +2862,7 @@ pub const Formatter = struct {
 
                 defer if (tag_name_slice.isAllocated()) tag_name_slice.deinit();
 
-                if (value.get(this.globalThis, "type")) |type_value| {
+                if (value.get_unsafe(this.globalThis, "type")) |type_value| {
                     const _tag = Tag.getAdvanced(type_value, this.globalThis, .{ .hide_global = true });
 
                     if (_tag.cell == .Symbol) {} else if (_tag.cell.isStringLike()) {
@@ -2767,7 +2892,7 @@ pub const Formatter = struct {
                 writer.writeAll(tag_name_slice.slice());
                 if (enable_ansi_colors) writer.writeAll(comptime Output.prettyFmt("<r>", enable_ansi_colors));
 
-                if (value.get(this.globalThis, "key")) |key_value| {
+                if (value.get_unsafe(this.globalThis, "key")) |key_value| {
                     if (!key_value.isUndefinedOrNull()) {
                         if (needs_space)
                             writer.writeAll(" key=")
@@ -2784,7 +2909,7 @@ pub const Formatter = struct {
                     }
                 }
 
-                if (value.get(this.globalThis, "props")) |props| {
+                if (value.get_unsafe(this.globalThis, "props")) |props| {
                     const prev_quote_strings = this.quote_strings;
                     this.quote_strings = true;
                     defer this.quote_strings = prev_quote_strings;
@@ -2796,7 +2921,7 @@ pub const Formatter = struct {
                     }).init(this.globalThis, props);
                     defer props_iter.deinit();
 
-                    const children_prop = props.get(this.globalThis, "children");
+                    const children_prop = props.get_unsafe(this.globalThis, "children");
                     if (props_iter.len > 0) {
                         {
                             this.indent += 1;
@@ -2911,7 +3036,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 1a2f5e7745..a46ed1af37 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.throw("ResolveMessage is not constructable", .{});
     }
 
     pub fn getCode(this: *ResolveMessage, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
@@ -69,22 +65,22 @@ pub const ResolveMessage = struct {
         switch (err) {
             error.ModuleNotFound => {
                 if (strings.eqlComptime(referrer, "bun:main")) {
-                    return try std.fmt.allocPrint(allocator, "Module not found \"{s}\"", .{specifier});
+                    return try std.fmt.allocPrint(allocator, "Module not found '{s}'", .{specifier});
                 }
                 if (Resolver.isPackagePath(specifier) and !strings.containsChar(specifier, '/')) {
-                    return try std.fmt.allocPrint(allocator, "Cannot find package \"{s}\" from \"{s}\"", .{ specifier, referrer });
+                    return try std.fmt.allocPrint(allocator, "Cannot find package '{s}' from '{s}'", .{ specifier, referrer });
                 } else {
-                    return try std.fmt.allocPrint(allocator, "Cannot find module \"{s}\" from \"{s}\"", .{ specifier, referrer });
+                    return try std.fmt.allocPrint(allocator, "Cannot find module '{s}' from '{s}'", .{ specifier, referrer });
                 }
             },
             error.InvalidDataURL => {
-                return try std.fmt.allocPrint(allocator, "Cannot resolve invalid data URL \"{s}\" from \"{s}\"", .{ specifier, referrer });
+                return try std.fmt.allocPrint(allocator, "Cannot resolve invalid data URL '{s}' from '{s}'", .{ specifier, referrer });
             },
             else => {
                 if (Resolver.isPackagePath(specifier)) {
-                    return try std.fmt.allocPrint(allocator, "{s} while resolving package \"{s}\" from \"{s}\"", .{ @errorName(err), specifier, referrer });
+                    return try std.fmt.allocPrint(allocator, "{s} while resolving package '{s}' from '{s}'", .{ @errorName(err), specifier, referrer });
                 } else {
-                    return try std.fmt.allocPrint(allocator, "{s} while resolving \"{s}\" from \"{s}\"", .{ @errorName(err), specifier, referrer });
+                    return try std.fmt.allocPrint(allocator, "{s} while resolving '{s}' from '{s}'", .{ @errorName(err), specifier, referrer });
                 }
             },
         }
@@ -92,8 +88,7 @@ pub const ResolveMessage = struct {
 
     pub fn toStringFn(this: *ResolveMessage, globalThis: *JSC.JSGlobalObject) JSC.JSValue {
         const text = std.fmt.allocPrint(default_allocator, "ResolveMessage: {s}", .{this.msg.data.text}) catch {
-            globalThis.throwOutOfMemory();
-            return .zero;
+            return globalThis.throwOutOfMemoryValue();
         };
         var str = ZigString.init(text);
         str.setOutputEncoding();
@@ -111,7 +106,7 @@ pub const ResolveMessage = struct {
         this: *ResolveMessage,
         globalThis: *JSC.JSGlobalObject,
         _: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         return this.toStringFn(globalThis);
     }
 
@@ -119,8 +114,8 @@ pub const ResolveMessage = struct {
         this: *ResolveMessage,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
-        const args_ = callframe.arguments(1);
+    ) bun.JSError!JSC.JSValue {
+        const args_ = callframe.arguments_old(1);
         const args = args_.ptr[0..args_.len];
         if (args.len > 0) {
             if (!args[0].isString()) {
@@ -140,9 +135,9 @@ 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"), ZigString.init("ResolveMessage").toJS(globalThis));
+        object.put(globalThis, ZigString.static("name"), bun.String.static("ResolveMessage").toJS(globalThis));
         object.put(globalThis, ZigString.static("position"), this.getPosition(globalThis));
         object.put(globalThis, ZigString.static("message"), this.getMessage(globalThis));
         object.put(globalThis, ZigString.static("level"), this.getLevel(globalThis));
diff --git a/src/bun.js/RuntimeTranspilerCache.zig b/src/bun.js/RuntimeTranspilerCache.zig
index f76ee34a4c..62e8f9a253 100644
--- a/src/bun.js/RuntimeTranspilerCache.zig
+++ b/src/bun.js/RuntimeTranspilerCache.zig
@@ -3,7 +3,12 @@
 /// Version 4: TypeScript enums are properly handled + more constant folding
 /// Version 5: `require.main === module` no longer marks a module as CJS
 /// Version 6: `use strict` is preserved in CommonJS modules when at the top of the file
-const expected_version = 6;
+/// Version 7: Several bundler changes that are likely to impact the runtime as well.
+/// Version 8: Fix for generated symbols
+/// Version 9: String printing changes
+/// Version 10: Constant folding for ''.charCodeAt(n)
+/// Version 11: Fix \uFFFF printing regression
+const expected_version = 11;
 
 const bun = @import("root").bun;
 const std = @import("std");
diff --git a/src/bun.js/Strong.zig b/src/bun.js/Strong.zig
index 503b69c280..2756ac0149 100644
--- a/src/bun.js/Strong.zig
+++ b/src/bun.js/Strong.zig
@@ -99,7 +99,7 @@ pub const Strong = struct {
     }
 
     pub fn set(this: *Strong, globalThis: *JSC.JSGlobalObject, value: JSC.JSValue) void {
-        var ref: *StrongImpl = this.ref orelse {
+        const ref: *StrongImpl = this.ref orelse {
             if (value == .zero) return;
             this.ref = StrongImpl.init(globalThis, value);
             this.globalThis = globalThis;
@@ -110,12 +110,12 @@ pub const Strong = struct {
     }
 
     pub fn clear(this: *Strong) void {
-        var ref: *StrongImpl = this.ref orelse return;
+        const ref: *StrongImpl = this.ref orelse return;
         ref.clear();
     }
 
     pub fn deinit(this: *Strong) void {
-        var ref: *StrongImpl = this.ref orelse return;
+        const ref: *StrongImpl = this.ref orelse return;
         this.ref = null;
         ref.deinit();
     }
diff --git a/src/bun.js/api/BunObject.zig b/src/bun.js/api/BunObject.zig
index 12aff1d40d..ec7cd1db4e 100644
--- a/src/bun.js/api/BunObject.zig
+++ b/src/bun.js/api/BunObject.zig
@@ -10,8 +10,12 @@ const conv = std.builtin.CallingConvention.Unspecified;
 pub const BunObject = struct {
     // --- Callbacks ---
     pub const allocUnsafe = toJSCallback(Bun.allocUnsafe);
+    pub const braces = toJSCallback(Bun.braces);
     pub const build = toJSCallback(Bun.JSBundler.buildFn);
+    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);
     pub const deflateSync = toJSCallback(JSZlib.deflateSync);
     pub const file = toJSCallback(WebCore.Blob.constructBunFile);
     pub const gc = toJSCallback(Bun.runGC);
@@ -22,7 +26,6 @@ pub const BunObject = struct {
     pub const inflateSync = toJSCallback(JSZlib.inflateSync);
     pub const jest = toJSCallback(@import("../test/jest.zig").Jest.call);
     pub const listen = toJSCallback(JSC.wrapStaticMethod(JSC.API.Listener, "listen", false));
-    pub const udpSocket = toJSCallback(JSC.wrapStaticMethod(JSC.API.UDPSocket, "udpSocket", false));
     pub const mmap = toJSCallback(Bun.mmapFile);
     pub const nanoseconds = toJSCallback(Bun.nanoseconds);
     pub const openInEditor = toJSCallback(Bun.openInEditor);
@@ -31,23 +34,22 @@ pub const BunObject = struct {
     pub const resolveSync = toJSCallback(Bun.resolveSync);
     pub const serve = toJSCallback(Bun.serve);
     pub const sha = toJSCallback(JSC.wrapStaticMethod(Crypto.SHA512_256, "hash_", true));
+    pub const shellEscape = toJSCallback(Bun.shellEscape);
     pub const shrink = toJSCallback(Bun.shrink);
     pub const sleepSync = toJSCallback(Bun.sleepSync);
     pub const spawn = toJSCallback(JSC.wrapStaticMethod(JSC.Subprocess, "spawn", false));
     pub const spawnSync = toJSCallback(JSC.wrapStaticMethod(JSC.Subprocess, "spawnSync", false));
+    pub const stringWidth = toJSCallback(Bun.stringWidth);
+    pub const udpSocket = toJSCallback(JSC.wrapStaticMethod(JSC.API.UDPSocket, "udpSocket", false));
     pub const which = toJSCallback(Bun.which);
     pub const write = toJSCallback(JSC.WebCore.Blob.writeFile);
-    pub const stringWidth = toJSCallback(Bun.stringWidth);
-    pub const braces = toJSCallback(Bun.braces);
-    pub const shellEscape = toJSCallback(Bun.shellEscape);
-    pub const createParsedShellScript = toJSCallback(bun.shell.ParsedShellScript.createParsedShellScript);
-    pub const createShellInterpreter = toJSCallback(bun.shell.Interpreter.createShellInterpreter);
     // --- Callbacks ---
 
     // --- Getters ---
     pub const CryptoHasher = toJSGetter(Crypto.CryptoHasher.getter);
     pub const FFI = toJSGetter(Bun.FFIObject.getter);
     pub const FileSystemRouter = toJSGetter(Bun.getFileSystemRouter);
+    pub const Glob = toJSGetter(Bun.getGlobConstructor);
     pub const MD4 = toJSGetter(Crypto.MD4.getter);
     pub const MD5 = toJSGetter(Crypto.MD5.getter);
     pub const SHA1 = toJSGetter(Crypto.SHA1.getter);
@@ -57,22 +59,20 @@ pub const BunObject = struct {
     pub const SHA512 = toJSGetter(Crypto.SHA512.getter);
     pub const SHA512_256 = toJSGetter(Crypto.SHA512_256.getter);
     pub const TOML = toJSGetter(Bun.getTOMLObject);
-    pub const Glob = toJSGetter(Bun.getGlobConstructor);
     pub const Transpiler = toJSGetter(Bun.getTranspilerConstructor);
     pub const argv = toJSGetter(Bun.getArgv);
-    pub const assetPrefix = toJSGetter(Bun.getAssetPrefix);
     pub const cwd = toJSGetter(Bun.getCWD);
+    pub const embeddedFiles = toJSGetter(Bun.getEmbeddedFiles);
     pub const enableANSIColors = toJSGetter(Bun.enableANSIColors);
     pub const hash = toJSGetter(Bun.getHashObject);
     pub const inspect = toJSGetter(Bun.getInspect);
     pub const main = toJSGetter(Bun.getMain);
     pub const origin = toJSGetter(Bun.getOrigin);
+    pub const semver = toJSGetter(Bun.getSemver);
     pub const stderr = toJSGetter(Bun.getStderr);
     pub const stdin = toJSGetter(Bun.getStdin);
     pub const stdout = toJSGetter(Bun.getStdout);
     pub const unsafe = toJSGetter(Bun.getUnsafe);
-    pub const semver = toJSGetter(Bun.getSemver);
-    pub const embeddedFiles = toJSGetter(Bun.getEmbeddedFiles);
     // --- Getters ---
 
     fn getterName(comptime baseName: anytype) [:0]const u8 {
@@ -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;
@@ -120,7 +120,6 @@ pub const BunObject = struct {
         @export(BunObject.Glob, .{ .name = getterName("Glob") });
         @export(BunObject.Transpiler, .{ .name = getterName("Transpiler") });
         @export(BunObject.argv, .{ .name = getterName("argv") });
-        @export(BunObject.assetPrefix, .{ .name = getterName("assetPrefix") });
         @export(BunObject.cwd, .{ .name = getterName("cwd") });
         @export(BunObject.enableANSIColors, .{ .name = getterName("enableANSIColors") });
         @export(BunObject.hash, .{ .name = getterName("hash") });
@@ -136,12 +135,13 @@ pub const BunObject = struct {
         // --- Getters --
 
         // -- Callbacks --
-        @export(BunObject.createParsedShellScript, .{ .name = callbackName("createParsedShellScript") });
-        @export(BunObject.createShellInterpreter, .{ .name = callbackName("createShellInterpreter") });
         @export(BunObject.allocUnsafe, .{ .name = callbackName("allocUnsafe") });
         @export(BunObject.braces, .{ .name = callbackName("braces") });
         @export(BunObject.build, .{ .name = callbackName("build") });
+        @export(BunObject.color, .{ .name = callbackName("color") });
         @export(BunObject.connect, .{ .name = callbackName("connect") });
+        @export(BunObject.createParsedShellScript, .{ .name = callbackName("createParsedShellScript") });
+        @export(BunObject.createShellInterpreter, .{ .name = callbackName("createShellInterpreter") });
         @export(BunObject.deflateSync, .{ .name = callbackName("deflateSync") });
         @export(BunObject.file, .{ .name = callbackName("file") });
         @export(BunObject.gc, .{ .name = callbackName("gc") });
@@ -152,7 +152,6 @@ pub const BunObject = struct {
         @export(BunObject.inflateSync, .{ .name = callbackName("inflateSync") });
         @export(BunObject.jest, .{ .name = callbackName("jest") });
         @export(BunObject.listen, .{ .name = callbackName("listen") });
-        @export(BunObject.udpSocket, .{ .name = callbackName("udpSocket") });
         @export(BunObject.mmap, .{ .name = callbackName("mmap") });
         @export(BunObject.nanoseconds, .{ .name = callbackName("nanoseconds") });
         @export(BunObject.openInEditor, .{ .name = callbackName("openInEditor") });
@@ -161,14 +160,15 @@ pub const BunObject = struct {
         @export(BunObject.resolveSync, .{ .name = callbackName("resolveSync") });
         @export(BunObject.serve, .{ .name = callbackName("serve") });
         @export(BunObject.sha, .{ .name = callbackName("sha") });
+        @export(BunObject.shellEscape, .{ .name = callbackName("shellEscape") });
         @export(BunObject.shrink, .{ .name = callbackName("shrink") });
         @export(BunObject.sleepSync, .{ .name = callbackName("sleepSync") });
         @export(BunObject.spawn, .{ .name = callbackName("spawn") });
         @export(BunObject.spawnSync, .{ .name = callbackName("spawnSync") });
+        @export(BunObject.stringWidth, .{ .name = callbackName("stringWidth") });
+        @export(BunObject.udpSocket, .{ .name = callbackName("udpSocket") });
         @export(BunObject.which, .{ .name = callbackName("which") });
         @export(BunObject.write, .{ .name = callbackName("write") });
-        @export(BunObject.stringWidth, .{ .name = callbackName("stringWidth") });
-        @export(BunObject.shellEscape, .{ .name = callbackName("shellEscape") });
         // -- Callbacks --
     }
 };
@@ -252,169 +252,17 @@ const zlib = @import("../../zlib.zig");
 const Which = @import("../../which.zig");
 const ErrorableString = JSC.ErrorableString;
 const is_bindgen = JSC.is_bindgen;
-const max_addressible_memory = std.math.maxInt(u56);
+const max_addressable_memory = std.math.maxInt(u56);
 const glob = @import("../../glob.zig");
 const Async = bun.Async;
 const SemverObject = @import("../../install/semver.zig").SemverObject;
 const Braces = @import("../../shell/braces.zig");
 const Shell = @import("../../shell/shell.zig");
 
-threadlocal var css_imports_list_strings: [512]ZigString = undefined;
-threadlocal var css_imports_list: [512]Api.StringPointer = undefined;
-threadlocal var css_imports_list_tail: u16 = 0;
-threadlocal var css_imports_buf: std.ArrayList(u8) = undefined;
-threadlocal var css_imports_buf_loaded: bool = false;
-
-threadlocal var routes_list_strings: [1024]ZigString = undefined;
-
-pub fn onImportCSS(
-    resolve_result: *const Resolver.Result,
-    import_record: *ImportRecord,
-    origin: URL,
-) void {
-    if (!css_imports_buf_loaded) {
-        css_imports_buf = std.ArrayList(u8).initCapacity(
-            VirtualMachine.get().allocator,
-            import_record.path.text.len,
-        ) catch unreachable;
-        css_imports_buf_loaded = true;
-    }
-
-    const writer = css_imports_buf.writer();
-    const offset = css_imports_buf.items.len;
-    css_imports_list[css_imports_list_tail] = .{
-        .offset = @as(u32, @truncate(offset)),
-        .length = 0,
-    };
-    getPublicPath(resolve_result.path_pair.primary.text, origin, @TypeOf(writer), writer);
-    const length = css_imports_buf.items.len - offset;
-    css_imports_list[css_imports_list_tail].length = @as(u32, @truncate(length));
-    css_imports_list_tail += 1;
-}
-
-pub fn flushCSSImports() void {
-    if (css_imports_buf_loaded) {
-        css_imports_buf.clearRetainingCapacity();
-        css_imports_list_tail = 0;
-    }
-}
-
-pub fn getCSSImports() []ZigString {
-    const tail = css_imports_list_tail;
-    for (0..tail) |i| {
-        ZigString.fromStringPointer(css_imports_list[i], css_imports_buf.items, &css_imports_list_strings[i]);
-    }
-    return css_imports_list_strings[0..tail];
-}
-
-const ShellTask = struct {
-    arena: std.heap.Arena,
-    script: std.ArrayList(u8),
-    interpreter: Shell.InterpreterSync,
-
-    pub const AsyncShellTask = JSC.ConcurrentPromiseTask(ShellTask);
-};
-
-pub fn shell(
-    globalThis: *JSC.JSGlobalObject,
-    callframe: *JSC.CallFrame,
-) JSC.JSValue {
-    const Interpreter = @import("../../shell/interpreter.zig").Interpreter;
-
-    // var allocator = globalThis.bunVM().allocator;
-    const allocator = getAllocator(globalThis);
-    var arena = bun.ArenaAllocator.init(allocator);
-
-    const arguments_ = callframe.arguments(8);
-    var arguments = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments_.slice());
-    const string_args = arguments.nextEat() orelse {
-        globalThis.throw("shell: expected 2 arguments, got 0", .{});
-        return .undefined;
-    };
-
-    const template_args_js = arguments.nextEat() orelse {
-        globalThis.throw("shell: expected 2 arguments, got 0", .{});
-        return .undefined;
-    };
-    var template_args = template_args_js.arrayIterator(globalThis);
-    var jsobjs = std.ArrayList(JSValue).init(arena.allocator());
-    var script = std.ArrayList(u8).init(arena.allocator());
-
-    if (!(bun.shell.shellCmdFromJS(globalThis, string_args, &template_args, &jsobjs, &script) catch {
-        if (!globalThis.hasException())
-            globalThis.throwOutOfMemory();
-        return JSValue.undefined;
-    })) {
-        return .undefined;
-    }
-
-    if (globalThis.hasException()) {
-        arena.deinit();
-        return .undefined;
-    }
-
-    const lex_result = brk: {
-        if (bun.strings.isAllASCII(script.items[0..])) {
-            var lexer = Shell.LexerAscii.new(arena.allocator(), script.items[0..]);
-            lexer.lex() catch |err| {
-                globalThis.throwError(err, "failed to lex shell");
-                return JSValue.undefined;
-            };
-            break :brk lexer.get_result();
-        }
-        var lexer = Shell.LexerUnicode.new(arena.allocator(), script.items[0..]);
-        lexer.lex() catch |err| {
-            globalThis.throwError(err, "failed to lex shell");
-            return JSValue.undefined;
-        };
-        break :brk lexer.get_result();
-    };
-
-    var parser = Shell.Parser.new(arena.allocator(), lex_result, jsobjs.items[0..]) catch |err| {
-        globalThis.throwError(err, "failed to create shell parser");
-        return JSValue.undefined;
-    };
-
-    const script_ast = parser.parse() catch |err| {
-        globalThis.throwError(err, "failed to parse shell");
-        return JSValue.undefined;
-    };
-
-    const script_heap = arena.allocator().create(Shell.AST.Script) catch {
-        globalThis.throwOutOfMemory();
-        return JSValue.undefined;
-    };
-
-    script_heap.* = script_ast;
-
-    const interpreter = Interpreter.init(
-        globalThis,
-        allocator,
-        &arena,
-        script_heap,
-        jsobjs.items[0..],
-    ) catch {
-        arena.deinit();
-        return .false;
-    };
-    _ = interpreter; // autofix
-
-    // return interpreter;
-    return .undefined;
-
-    // return interpreter.start(globalThis) catch {
-    //     return .false;
-    // };
-}
-
-pub fn shellEscape(
-    globalThis: *JSC.JSGlobalObject,
-    callframe: *JSC.CallFrame,
-) JSC.JSValue {
-    const arguments = callframe.arguments(1);
+pub fn shellEscape(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+    const arguments = callframe.arguments_old(1);
     if (arguments.len < 1) {
-        globalThis.throw("shell escape expected at least 1 argument", .{});
-        return .undefined;
+        return globalThis.throw("shell escape expected at least 1 argument", .{});
     }
 
     const jsval = arguments.ptr[0];
@@ -425,43 +273,25 @@ pub fn shellEscape(
     var outbuf = std.ArrayList(u8).init(bun.default_allocator);
     defer outbuf.deinit();
 
-    if (bunstr.isUTF16()) {
-        if (bun.shell.needsEscapeUTF16(bunstr.utf16())) {
-            const result = bun.shell.escapeUtf16(bunstr.utf16(), &outbuf, true) catch {
-                globalThis.throwOutOfMemory();
-                return .undefined;
-            };
-            if (result.is_invalid) {
-                globalThis.throw("String has invalid utf-16: {s}", .{bunstr.byteSlice()});
-                return .undefined;
-            }
-            return bun.String.createUTF8(outbuf.items[0..]).toJS(globalThis);
+    if (bun.shell.needsEscapeBunstr(bunstr)) {
+        const result = try bun.shell.escapeBunStr(bunstr, &outbuf, true);
+        if (!result) {
+            return globalThis.throw("String has invalid utf-16: {s}", .{bunstr.byteSlice()});
         }
-        return jsval;
-    }
-
-    if (bun.shell.needsEscapeUtf8AsciiLatin1(bunstr.latin1())) {
-        bun.shell.escape8Bit(bunstr.byteSlice(), &outbuf, true) catch {
-            globalThis.throwOutOfMemory();
-            return .undefined;
-        };
-        return bun.String.createUTF8(outbuf.items[0..]).toJS(globalThis);
+        var str = bun.String.createUTF8(outbuf.items[0..]);
+        return str.transferToJS(globalThis);
     }
 
     return jsval;
 }
 
-pub fn braces(
-    globalThis: *JSC.JSGlobalObject,
-    callframe: *JSC.CallFrame,
-) JSC.JSValue {
-    const arguments_ = callframe.arguments(2);
+pub fn braces(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+    const arguments_ = callframe.arguments_old(2);
     var arguments = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments_.slice());
     defer arguments.deinit();
 
     const brace_str_js = arguments.nextEat() orelse {
-        globalThis.throw("braces: expected at least 1 argument, got 0", .{});
-        return .undefined;
+        return globalThis.throw("braces: expected at least 1 argument, got 0", .{});
     };
     const brace_str = brace_str_js.toBunString(globalThis);
     defer brace_str.deref();
@@ -475,11 +305,11 @@ pub fn braces(
     if (arguments.nextEat()) |opts_val| {
         if (opts_val.isObject()) {
             if (comptime bun.Environment.allow_assert) {
-                if (opts_val.getOwnTruthy(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.getOwnTruthy(globalThis, "parse")) |tokenize_val| {
+                if (try opts_val.getTruthy(globalThis, "parse")) |tokenize_val| {
                     parse = if (tokenize_val.isBoolean()) tokenize_val.asBoolean() else false;
                 }
             }
@@ -491,20 +321,15 @@ pub fn braces(
     defer arena.deinit();
 
     var lexer_output = Braces.Lexer.tokenize(arena.allocator(), brace_slice.slice()) catch |err| {
-        globalThis.throwError(err, "failed to tokenize braces");
-        return .undefined;
+        return globalThis.throwError(err, "failed to tokenize braces");
     };
 
     const expansion_count = Braces.calculateExpandedAmount(lexer_output.tokens.items[0..]) catch |err| {
-        globalThis.throwError(err, "failed to calculate brace expansion amount");
-        return .undefined;
+        return globalThis.throwError(err, "failed to calculate brace expansion amount");
     };
 
     if (tokenize) {
-        const str = std.json.stringifyAlloc(globalThis.bunVM().allocator, lexer_output.tokens.items[0..], .{}) catch {
-            globalThis.throwOutOfMemory();
-            return JSValue.undefined;
-        };
+        const str = try std.json.stringifyAlloc(globalThis.bunVM().allocator, lexer_output.tokens.items[0..], .{});
         defer globalThis.bunVM().allocator.free(str);
         var bun_str = bun.String.fromBytes(str);
         return bun_str.toJS(globalThis);
@@ -512,13 +337,9 @@ pub fn braces(
     if (parse) {
         var parser = Braces.Parser.init(lexer_output.tokens.items[0..], arena.allocator());
         const ast_node = parser.parse() catch |err| {
-            globalThis.throwError(err, "failed to parse braces");
-            return .undefined;
-        };
-        const str = std.json.stringifyAlloc(globalThis.bunVM().allocator, ast_node, .{}) catch {
-            globalThis.throwOutOfMemory();
-            return JSValue.undefined;
+            return globalThis.throwError(err, "failed to parse braces");
         };
+        const str = try std.json.stringifyAlloc(globalThis.bunVM().allocator, ast_node, .{});
         defer globalThis.bunVM().allocator.free(str);
         var bun_str = bun.String.fromBytes(str);
         return bun_str.toJS(globalThis);
@@ -528,10 +349,7 @@ pub fn braces(
         return bun.String.toJSArray(globalThis, &.{brace_str});
     }
 
-    var expanded_strings = arena.allocator().alloc(std.ArrayList(u8), expansion_count) catch {
-        globalThis.throwOutOfMemory();
-        return .undefined;
-    };
+    var expanded_strings = try arena.allocator().alloc(std.ArrayList(u8), expansion_count);
 
     for (0..expansion_count) |i| {
         expanded_strings[i] = std.ArrayList(u8).init(arena.allocator());
@@ -543,14 +361,10 @@ pub fn braces(
         expanded_strings,
         lexer_output.contains_nested,
     ) catch {
-        globalThis.throwOutOfMemory();
-        return .undefined;
+        return globalThis.throwOutOfMemory();
     };
 
-    var out_strings = arena.allocator().alloc(bun.String, expansion_count) catch {
-        globalThis.throwOutOfMemory();
-        return .undefined;
-    };
+    var out_strings = try arena.allocator().alloc(bun.String, expansion_count);
     for (0..expansion_count) |i| {
         out_strings[i] = bun.String.fromBytes(expanded_strings[i].items[0..]);
     }
@@ -558,17 +372,13 @@ pub fn braces(
     return bun.String.toJSArray(globalThis, out_strings[0..]);
 }
 
-pub fn which(
-    globalThis: *JSC.JSGlobalObject,
-    callframe: *JSC.CallFrame,
-) JSC.JSValue {
-    const arguments_ = callframe.arguments(2);
+pub fn which(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+    const arguments_ = callframe.arguments_old(2);
     var path_buf: bun.PathBuffer = undefined;
     var arguments = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments_.slice());
     defer arguments.deinit();
     const path_arg = arguments.nextEat() orelse {
-        globalThis.throw("which: expected 1 argument, got 0", .{});
-        return .undefined;
+        return globalThis.throw("which: expected 1 argument, got 0", .{});
     };
 
     var path_str: ZigString.Slice = ZigString.Slice.empty;
@@ -590,8 +400,7 @@ pub fn which(
     }
 
     if (bin_str.len >= bun.MAX_PATH_BYTES) {
-        globalThis.throw("bin path is too long", .{});
-        return .undefined;
+        return globalThis.throw("bin path is too long", .{});
     }
 
     if (bin_str.len == 0) {
@@ -607,11 +416,11 @@ pub fn which(
 
     if (arguments.nextEat()) |arg| {
         if (!arg.isEmptyOrUndefinedOrNull() and arg.isObject()) {
-            if (arg.getOwn(globalThis, "PATH")) |str_| {
+            if (try arg.get(globalThis, "PATH")) |str_| {
                 path_str = str_.toSlice(globalThis, globalThis.bunVM().allocator);
             }
 
-            if (arg.getOwn(globalThis, "cwd")) |str_| {
+            if (try arg.get(globalThis, "cwd")) |str_| {
                 cwd_str = str_.toSlice(globalThis, globalThis.bunVM().allocator);
             }
         }
@@ -629,11 +438,77 @@ pub fn which(
     return JSC.JSValue.jsNull();
 }
 
-pub fn inspect(
-    globalThis: *JSC.JSGlobalObject,
-    callframe: *JSC.CallFrame,
-) JSC.JSValue {
-    const arguments = callframe.arguments(4).slice();
+pub fn inspectTable(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) 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())
+        return bun.String.empty.toJS(globalThis);
+
+    for (all_arguments) |arg| {
+        arg.protect();
+    }
+    defer {
+        for (all_arguments) |arg| {
+            arg.unprotect();
+        }
+    }
+
+    var arguments = all_arguments[0..];
+
+    if (!arguments[1].isArray()) {
+        arguments[2] = arguments[1];
+        arguments[1] = .undefined;
+    }
+
+    var formatOptions = ConsoleObject.FormatOptions{
+        .enable_colors = false,
+        .add_newline = false,
+        .flush = false,
+        .max_depth = 5,
+        .quote_strings = true,
+        .ordered_properties = false,
+        .single_line = true,
+    };
+    if (arguments[2].isObject()) {
+        try formatOptions.fromJS(globalThis, arguments[2..]);
+    }
+    const value = arguments[0];
+
+    // very stable memory address
+    var array = MutableString.init(getAllocator(globalThis), 0) catch bun.outOfMemory();
+    defer array.deinit();
+    var buffered_writer_ = MutableString.BufferedWriter{ .context = &array };
+    var buffered_writer = &buffered_writer_;
+
+    const writer = buffered_writer.writer();
+    const Writer = @TypeOf(writer);
+    const properties = if (arguments[1].jsType().isArray()) arguments[1] else JSValue.undefined;
+    var table_printer = ConsoleObject.TablePrinter.init(
+        globalThis,
+        .Log,
+        value,
+        properties,
+    );
+    table_printer.value_formatter.depth = formatOptions.max_depth;
+    table_printer.value_formatter.ordered_properties = formatOptions.ordered_properties;
+    table_printer.value_formatter.single_line = formatOptions.single_line;
+
+    switch (formatOptions.enable_colors) {
+        inline else => |colors| table_printer.printTable(Writer, writer, colors) catch {
+            if (!globalThis.hasException())
+                return globalThis.throwOutOfMemory();
+            return .zero;
+        },
+    }
+
+    try buffered_writer.flush();
+
+    var out = bun.String.createUTF8(array.slice());
+    return out.transferToJS(globalThis);
+}
+
+pub fn inspect(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+    const arguments = callframe.arguments_old(4).slice();
     if (arguments.len == 0)
         return bun.String.empty.toJS(globalThis);
 
@@ -654,62 +529,10 @@ pub fn inspect(
         .quote_strings = true,
         .ordered_properties = false,
     };
-    const value = arguments[0];
-
     if (arguments.len > 1) {
-        const arg1 = arguments[1];
-
-        if (arg1.isObject()) {
-            if (arg1.getOwnTruthy(globalThis, "depth")) |opt| {
-                if (opt.isInt32()) {
-                    const arg = opt.toInt32();
-                    if (arg < 0) {
-                        globalThis.throwInvalidArguments("expected depth to be greater than or equal to 0, got {d}", .{arg});
-                        return .zero;
-                    }
-                    formatOptions.max_depth = @as(u16, @truncate(@as(u32, @intCast(@min(arg, std.math.maxInt(u16))))));
-                } else if (opt.isNumber()) {
-                    const v = opt.coerce(f64, globalThis);
-                    if (std.math.isInf(v)) {
-                        formatOptions.max_depth = std.math.maxInt(u16);
-                    } else {
-                        globalThis.throwInvalidArguments("expected depth to be an integer, got {d}", .{v});
-                        return .zero;
-                    }
-                }
-            }
-            if (arg1.getOptional(globalThis, "colors", bool) catch return .zero) |opt| {
-                formatOptions.enable_colors = opt;
-            }
-            if (arg1.getOptional(globalThis, "sorted", bool) catch return .zero) |opt| {
-                formatOptions.ordered_properties = opt;
-            }
-        } else {
-            // formatOptions.show_hidden = arg1.toBoolean();
-            if (arguments.len > 2) {
-                var depthArg = arguments[1];
-                if (depthArg.isInt32()) {
-                    const arg = depthArg.toInt32();
-                    if (arg < 0) {
-                        globalThis.throwInvalidArguments("expected depth to be greater than or equal to 0, got {d}", .{arg});
-                        return .zero;
-                    }
-                    formatOptions.max_depth = @as(u16, @truncate(@as(u32, @intCast(@min(arg, std.math.maxInt(u16))))));
-                } else if (depthArg.isNumber()) {
-                    const v = depthArg.coerce(f64, globalThis);
-                    if (std.math.isInf(v)) {
-                        formatOptions.max_depth = std.math.maxInt(u16);
-                    } else {
-                        globalThis.throwInvalidArguments("expected depth to be an integer, got {d}", .{v});
-                        return .zero;
-                    }
-                }
-                if (arguments.len > 3) {
-                    formatOptions.enable_colors = arguments[2].toBoolean();
-                }
-            }
-        }
+        try formatOptions.fromJS(globalThis, arguments[1..]);
     }
+    const value = arguments[0];
 
     // very stable memory address
     var array = MutableString.init(getAllocator(globalThis), 0) catch unreachable;
@@ -736,7 +559,7 @@ pub fn inspect(
 
     // we are going to always clone to keep things simple for now
     // the common case here will be stack-allocated, so it should be fine
-    var out = ZigString.init(array.toOwnedSliceLeaky()).withEncoding();
+    var out = ZigString.init(array.slice()).withEncoding();
     const ret = out.toJS(globalThis);
     array.deinit();
     return ret;
@@ -746,29 +569,24 @@ pub fn getInspect(globalObject: *JSC.JSGlobalObject, _: *JSC.JSObject) JSC.JSVal
     const fun = JSC.createCallback(globalObject, ZigString.static("inspect"), 2, inspect);
     var str = ZigString.init("nodejs.util.inspect.custom");
     fun.put(globalObject, ZigString.static("custom"), JSC.JSValue.symbolFor(globalObject, &str));
+    fun.put(globalObject, ZigString.static("table"), JSC.createCallback(globalObject, ZigString.static("table"), 3, inspectTable));
     return fun;
 }
 
-pub fn registerMacro(
-    globalObject: *JSC.JSGlobalObject,
-    callframe: *JSC.CallFrame,
-) JSC.JSValue {
-    const arguments_ = callframe.arguments(2);
+pub fn registerMacro(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+    const arguments_ = callframe.arguments_old(2);
     const arguments = arguments_.slice();
     if (arguments.len != 2 or !arguments[0].isNumber()) {
-        globalObject.throwInvalidArguments("Internal error registering macros: invalid args", .{});
-        return .undefined;
+        return globalObject.throwInvalidArguments("Internal error registering macros: invalid args", .{});
     }
     const id = arguments[0].toInt32();
     if (id == -1 or id == 0) {
-        globalObject.throwInvalidArguments("Internal error registering macros: invalid id", .{});
-        return .undefined;
+        return globalObject.throwInvalidArguments("Internal error registering macros: invalid id", .{});
     }
 
     if (!arguments[1].isCell() or !arguments[1].isCallable(globalObject.vm())) {
         // TODO: add "toTypeOf" helper
-        globalObject.throw("Macro must be a function", .{});
-        return .undefined;
+        return globalObject.throw("Macro must be a function", .{});
     }
 
     const get_or_put_result = VirtualMachine.get().macros.getOrPut(id) catch unreachable;
@@ -782,24 +600,15 @@ pub fn registerMacro(
     return .undefined;
 }
 
-pub fn getCWD(
-    globalThis: *JSC.JSGlobalObject,
-    _: *JSC.JSObject,
-) JSC.JSValue {
+pub fn getCWD(globalThis: *JSC.JSGlobalObject, _: *JSC.JSObject) JSC.JSValue {
     return ZigString.init(VirtualMachine.get().bundler.fs.top_level_dir).toJS(globalThis);
 }
 
-pub fn getOrigin(
-    globalThis: *JSC.JSGlobalObject,
-    _: *JSC.JSObject,
-) JSC.JSValue {
+pub fn getOrigin(globalThis: *JSC.JSGlobalObject, _: *JSC.JSObject) JSC.JSValue {
     return ZigString.init(VirtualMachine.get().origin.origin).toJS(globalThis);
 }
 
-pub fn getStdin(
-    globalThis: *JSC.JSGlobalObject,
-    _: *JSC.JSObject,
-) JSC.JSValue {
+pub fn getStdin(globalThis: *JSC.JSGlobalObject, _: *JSC.JSObject) JSC.JSValue {
     var rare_data = globalThis.bunVM().rareData();
     var store = rare_data.stdin();
     store.ref();
@@ -810,10 +619,7 @@ pub fn getStdin(
     return blob.toJS(globalThis);
 }
 
-pub fn getStderr(
-    globalThis: *JSC.JSGlobalObject,
-    _: *JSC.JSObject,
-) JSC.JSValue {
+pub fn getStderr(globalThis: *JSC.JSGlobalObject, _: *JSC.JSObject) JSC.JSValue {
     var rare_data = globalThis.bunVM().rareData();
     var store = rare_data.stderr();
     store.ref();
@@ -824,10 +630,7 @@ pub fn getStderr(
     return blob.toJS(globalThis);
 }
 
-pub fn getStdout(
-    globalThis: *JSC.JSGlobalObject,
-    _: *JSC.JSObject,
-) JSC.JSValue {
+pub fn getStdout(globalThis: *JSC.JSGlobalObject, _: *JSC.JSObject) JSC.JSValue {
     var rare_data = globalThis.bunVM().rareData();
     var store = rare_data.stdout();
     store.ref();
@@ -838,17 +641,12 @@ pub fn getStdout(
     return blob.toJS(globalThis);
 }
 
-pub fn enableANSIColors(
-    globalThis: *JSC.JSGlobalObject,
-    _: *JSC.JSObject,
-) JSC.JSValue {
+pub fn enableANSIColors(globalThis: *JSC.JSGlobalObject, _: *JSC.JSObject) JSC.JSValue {
     _ = globalThis;
     return JSValue.jsBoolean(Output.enable_ansi_colors);
 }
-pub fn getMain(
-    globalThis: *JSC.JSGlobalObject,
-    _: *JSC.JSObject,
-) JSC.JSValue {
+
+pub fn getMain(globalThis: *JSC.JSGlobalObject, _: *JSC.JSObject) JSC.JSValue {
     const vm = globalThis.bunVM();
 
     // Attempt to use the resolved filesystem path
@@ -898,27 +696,15 @@ pub fn getMain(
     return ZigString.init(vm.main).toJS(globalThis);
 }
 
-pub fn getAssetPrefix(
-    globalThis: *JSC.JSGlobalObject,
-    _: *JSC.JSObject,
-) JSC.JSValue {
-    return ZigString.init(VirtualMachine.get().bundler.options.routes.asset_prefix_path).toJS(globalThis);
-}
-
-pub fn getArgv(
-    globalThis: *JSC.JSGlobalObject,
-    _: *JSC.JSObject,
-) JSC.JSValue {
+pub fn getArgv(globalThis: *JSC.JSGlobalObject, _: *JSC.JSObject) JSC.JSValue {
     return JSC.Node.Process.getArgv(globalThis);
 }
 
 const Editor = @import("../../open.zig").Editor;
-pub fn openInEditor(
-    globalThis: js.JSContextRef,
-    callframe: *JSC.CallFrame,
-) JSValue {
+
+pub fn openInEditor(globalThis: js.JSContextRef, callframe: *JSC.CallFrame) bun.JSError!JSValue {
     var edit = &VirtualMachine.get().rareData().editor_context;
-    const args = callframe.arguments(4);
+    const args = callframe.arguments_old(4);
     var arguments = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), args.slice());
     defer arguments.deinit();
     var path: string = "";
@@ -932,7 +718,7 @@ pub fn openInEditor(
 
     if (arguments.nextEat()) |opts| {
         if (!opts.isUndefinedOrNull()) {
-            if (opts.getOwnTruthy(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;
 
@@ -943,8 +729,7 @@ pub fn openInEditor(
                     editor_choice = edit.editor;
                     if (editor_choice == null) {
                         edit.* = prev;
-                        globalThis.throw("Could not find editor \"{s}\"", .{sliced.slice()});
-                        return .undefined;
+                        return globalThis.throw("Could not find editor \"{s}\"", .{sliced.slice()});
                     } else if (edit.name.ptr == edit.path.ptr) {
                         edit.name = arguments.arena.allocator().dupe(u8, edit.path) catch unreachable;
                         edit.path = edit.path;
@@ -952,11 +737,11 @@ pub fn openInEditor(
                 }
             }
 
-            if (opts.getOwnTruthy(globalThis, "line")) |line_| {
+            if (try opts.getTruthy(globalThis, "line")) |line_| {
                 line = line_.toSlice(globalThis, arguments.arena.allocator()).slice();
             }
 
-            if (opts.getOwnTruthy(globalThis, "column")) |column_| {
+            if (try opts.getTruthy(globalThis, "column")) |column_| {
                 column = column_.toSlice(globalThis, arguments.arena.allocator()).slice();
             }
         }
@@ -965,21 +750,18 @@ pub fn openInEditor(
     const editor = editor_choice orelse edit.editor orelse brk: {
         edit.autoDetectEditor(VirtualMachine.get().bundler.env);
         if (edit.editor == null) {
-            globalThis.throw("Failed to auto-detect editor", .{});
-            return .zero;
+            return globalThis.throw("Failed to auto-detect editor", .{});
         }
 
         break :brk edit.editor.?;
     };
 
     if (path.len == 0) {
-        globalThis.throw("No file path specified", .{});
-        return .zero;
+        return globalThis.throw("No file path specified", .{});
     }
 
     editor.open(edit.path, path, line, column, arguments.arena.allocator()) catch |err| {
-        globalThis.throw("Opening editor failed {s}", .{@errorName(err)});
-        return .zero;
+        return globalThis.throw("Opening editor failed {s}", .{@errorName(err)});
     };
 
     return .undefined;
@@ -990,7 +772,7 @@ pub fn getPublicPath(to: string, origin: URL, comptime Writer: type, writer: Wri
         to,
         VirtualMachine.get().bundler.fs.top_level_dir,
         origin,
-        VirtualMachine.get().bundler.options.routes.asset_prefix_path,
+        "",
         comptime Writer,
         writer,
         .loose,
@@ -1034,73 +816,63 @@ pub fn getPublicPathWithAssetPrefix(
     }
 }
 
-pub fn sleepSync(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
-    const arguments = callframe.arguments(1);
+pub fn sleepSync(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+    const arguments = callframe.arguments_old(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];
 
     // The argument must be a number
     if (!arg.isNumber()) {
-        globalObject.throwInvalidArgumentType("sleepSync", "milliseconds", "number");
-        return .undefined;
+        return globalObject.throwInvalidArgumentType("sleepSync", "milliseconds", "number");
     }
 
     //NOTE: if argument is > max(i32) then it will be truncated
     const milliseconds = arg.coerce(i32, globalObject);
     if (milliseconds < 0) {
-        globalObject.throwInvalidArguments("argument to sleepSync must not be negative, got {d}", .{milliseconds});
-        return .undefined;
+        return globalObject.throwInvalidArguments("argument to sleepSync must not be negative, got {d}", .{milliseconds});
     }
 
     std.time.sleep(@as(u64, @intCast(milliseconds)) * std.time.ns_per_ms);
     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 {
-    const arguments_ = callframe.arguments(1);
+pub fn runGC(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+    const arguments_ = callframe.arguments_old(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;
 }
 
-fn doResolve(
-    globalThis: *JSC.JSGlobalObject,
-    arguments: []const JSValue,
-    exception: js.ExceptionRef,
-) ?JSC.JSValue {
+fn doResolve(globalThis: *JSC.JSGlobalObject, arguments: []const 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;
+        return globalThis.throwInvalidArguments("Expected a specifier and a from path", .{});
     };
 
     if (specifier.isUndefinedOrNull()) {
-        JSC.throwInvalidArguments("specifier must be a string", .{}, globalThis, exception);
-        return null;
+        return globalThis.throwInvalidArguments("specifier must be a string", .{});
     }
 
     const from = args.protectEatNext() orelse {
-        JSC.throwInvalidArguments("Expected a from path", .{}, globalThis, exception);
-        return null;
+        return globalThis.throwInvalidArguments("Expected a from path", .{});
     };
 
     if (from.isUndefinedOrNull()) {
-        JSC.throwInvalidArguments("from must be a string", .{}, globalThis, exception);
-        return null;
+        return globalThis.throwInvalidArguments("from must be a string", .{});
     }
 
     var is_esm = true;
@@ -1108,8 +880,7 @@ fn doResolve(
         if (next.isBoolean()) {
             is_esm = next.toBoolean();
         } else {
-            JSC.throwInvalidArguments("esm must be a boolean", .{}, globalThis, exception);
-            return null;
+            return globalThis.throwInvalidArguments("esm must be a boolean", .{});
         }
     }
 
@@ -1121,20 +892,12 @@ fn doResolve(
         globalThis,
         specifier_str,
         from_str,
-        exception,
         is_esm,
         false,
     );
 }
 
-fn doResolveWithArgs(
-    ctx: js.JSContextRef,
-    specifier: bun.String,
-    from: bun.String,
-    exception: js.ExceptionRef,
-    is_esm: bool,
-    comptime is_file_path: bool,
-) ?JSC.JSValue {
+fn doResolveWithArgs(ctx: js.JSContextRef, specifier: bun.String, from: bun.String, is_esm: bool, comptime is_file_path: bool) bun.JSError!JSC.JSValue {
     var errorable: ErrorableString = undefined;
     var query_string = ZigString.Empty;
 
@@ -1147,7 +910,7 @@ fn doResolveWithArgs(
     if (comptime is_file_path) {
         VirtualMachine.resolveFilePathForAPI(
             &errorable,
-            ctx.ptr(),
+            ctx,
             specifier_decoded,
             from,
             &query_string,
@@ -1156,7 +919,7 @@ fn doResolveWithArgs(
     } else {
         VirtualMachine.resolveForAPI(
             &errorable,
-            ctx.ptr(),
+            ctx,
             specifier_decoded,
             from,
             &query_string,
@@ -1165,8 +928,7 @@ fn doResolveWithArgs(
     }
 
     if (!errorable.success) {
-        exception.* = bun.cast(JSC.JSValueRef, errorable.result.err.ptr.?);
-        return null;
+        return ctx.throwValue(bun.cast(JSC.JSValueRef, errorable.result.err.ptr.?).?.value());
     }
 
     if (query_string.len > 0) {
@@ -1174,14 +936,10 @@ fn doResolveWithArgs(
         const allocator = stack.get();
         var arraylist = std.ArrayList(u8).initCapacity(allocator, 1024) catch unreachable;
         defer arraylist.deinit();
-        arraylist.writer().print("{any}{any}", .{
+        try arraylist.writer().print("{any}{any}", .{
             errorable.result.value,
             query_string,
-        }) catch {
-            // TODO: binding for createOutOfMemoryError
-            exception.* = JSC.createError(ctx, "Out of memory", .{}).asObjectRef();
-            return null;
-        };
+        });
 
         return ZigString.initUTF8(arraylist.items).toJS(ctx);
     }
@@ -1189,118 +947,59 @@ 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_;
-    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;
+pub fn resolveSync(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+    const arguments = callframe.arguments_old(3);
+    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_;
-    const arguments = callframe.arguments(3);
-    const value = doResolve(globalObject, arguments.slice(), exception) orelse {
-        return JSC.JSPromise.rejectedPromiseValue(globalObject, exception_[0].?.value());
+pub fn resolve(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+    const arguments = callframe.arguments_old(3);
+    const value = doResolve(globalObject, arguments.slice()) catch {
+        const err = globalObject.tryTakeException().?;
+        return JSC.JSPromise.rejectedPromiseValue(globalObject, err);
     };
     return JSC.JSPromise.resolvedPromiseValue(globalObject, value);
 }
 
-export fn Bun__resolve(
-    global: *JSGlobalObject,
-    specifier: JSValue,
-    source: JSValue,
-    is_esm: bool,
-) JSC.JSValue {
-    var exception_ = [1]JSC.JSValueRef{null};
-    const exception = &exception_;
+export fn Bun__resolve(global: *JSGlobalObject, specifier: JSValue, source: JSValue, is_esm: bool) JSC.JSValue {
     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);
 }
 
-export fn Bun__resolveSync(
-    global: *JSGlobalObject,
-    specifier: JSValue,
-    source: JSValue,
-    is_esm: bool,
-) JSC.JSValue {
-    var exception_ = [1]JSC.JSValueRef{null};
-    const exception = &exception_;
-
+export fn Bun__resolveSync(global: *JSGlobalObject, specifier: JSValue, source: JSValue, is_esm: bool) JSC.JSValue {
     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(
-    global: *JSGlobalObject,
-    specifier: *bun.String,
-    source: *bun.String,
-    is_esm: bool,
-) JSC.JSValue {
+export fn Bun__resolveSyncWithStrings(global: *JSGlobalObject, specifier: *bun.String, source: *bun.String, 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(
-    global: *JSGlobalObject,
-    specifier: JSValue,
-    source: *bun.String,
-    is_esm: bool,
-) JSC.JSValue {
-    var exception_ = [1]JSC.JSValueRef{null};
+export fn Bun__resolveSyncWithSource(global: *JSGlobalObject, specifier: JSValue, source: *bun.String, is_esm: bool) JSC.JSValue {
     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]);
-    };
-}
-
-pub fn getPublicPathJS(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
-    const arguments = callframe.arguments(1).slice();
-    if (arguments.len < 1) {
-        return bun.String.empty.toJS(globalObject);
-    }
-    var public_path_temp_str: bun.PathBuffer = undefined;
-
-    const to = arguments[0].toSlice(globalObject, bun.default_allocator);
-    defer to.deinit();
-    var stream = std.io.fixedBufferStream(&public_path_temp_str);
-    var writer = stream.writer();
-    getPublicPath(to.slice(), VirtualMachine.get().origin, @TypeOf(&writer), &writer);
-
-    return ZigString.init(stream.buffer[0..stream.pos]).toJS(globalObject);
+    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();
@@ -1308,8 +1007,8 @@ fn dump_mimalloc(globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSC.JSVal
     return .undefined;
 }
 
-pub fn indexOfLine(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
-    const arguments_ = callframe.arguments(2);
+pub fn indexOfLine(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+    const arguments_ = callframe.arguments_old(2);
     const arguments = arguments_.slice();
     if (arguments.len == 0) {
         return JSC.JSValue.jsNumberFromInt32(-1);
@@ -1359,6 +1058,59 @@ pub const Crypto = struct {
     const Hashers = @import("../../sha.zig");
 
     const BoringSSL = bun.BoringSSL;
+    pub const HMAC = struct {
+        ctx: BoringSSL.HMAC_CTX,
+        algorithm: EVP.Algorithm,
+
+        pub usingnamespace bun.New(@This());
+
+        pub fn init(algorithm: EVP.Algorithm, key: []const u8) ?*HMAC {
+            const md = algorithm.md() orelse return null;
+            var ctx: BoringSSL.HMAC_CTX = undefined;
+            BoringSSL.HMAC_CTX_init(&ctx);
+            if (BoringSSL.HMAC_Init_ex(&ctx, key.ptr, @intCast(key.len), md, null) != 1) {
+                BoringSSL.HMAC_CTX_cleanup(&ctx);
+                return null;
+            }
+            return HMAC.new(.{
+                .ctx = ctx,
+                .algorithm = algorithm,
+            });
+        }
+
+        pub fn update(this: *HMAC, data: []const u8) void {
+            _ = BoringSSL.HMAC_Update(&this.ctx, data.ptr, data.len);
+        }
+
+        pub fn size(this: *const HMAC) usize {
+            return BoringSSL.HMAC_size(&this.ctx);
+        }
+
+        pub fn copy(this: *HMAC) !*HMAC {
+            var ctx: BoringSSL.HMAC_CTX = undefined;
+            BoringSSL.HMAC_CTX_init(&ctx);
+            if (BoringSSL.HMAC_CTX_copy(&ctx, &this.ctx) != 1) {
+                BoringSSL.HMAC_CTX_cleanup(&ctx);
+                return error.BoringSSLError;
+            }
+            return HMAC.new(.{
+                .ctx = ctx,
+                .algorithm = this.algorithm,
+            });
+        }
+
+        pub fn final(this: *HMAC, out: []u8) []u8 {
+            var outlen: c_uint = undefined;
+            _ = BoringSSL.HMAC_Final(&this.ctx, out.ptr, &outlen);
+            return out[0..outlen];
+        }
+
+        pub fn deinit(this: *HMAC) void {
+            BoringSSL.HMAC_CTX_cleanup(&this.ctx);
+            this.destroy();
+        }
+    };
+
     pub const EVP = struct {
         ctx: BoringSSL.EVP_MD_CTX = undefined,
         md: *const BoringSSL.EVP_MD = undefined,
@@ -1619,46 +1371,42 @@ 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 globalThis.throwInvalidArgumentTypeValue("keylen", "integer", arguments[3]);
                 }
 
                 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.throwInvalidArguments("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 globalThis.throwInvalidArgumentTypeValue("iteration count", "integer", arguments[2]);
                 }
 
                 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.throwInvalidArguments("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 globalThis.throwInvalidArgumentTypeValue("algorithm", "string", arguments[4]);
                     }
 
                     break :brk EVP.Algorithm.map.fromJSCaseInsensitive(globalThis, arguments[4]) orelse {
@@ -1666,9 +1414,9 @@ pub const Crypto = struct {
                             const slice = arguments[4].toSlice(globalThis, bun.default_allocator);
                             defer slice.deinit();
                             const name = slice.slice();
-                            globalThis.ERR_CRYPTO_INVALID_DIGEST("Unsupported algorithm \"{s}\"", .{name}).throw();
+                            return globalThis.ERR_CRYPTO_INVALID_DIGEST("Unsupported algorithm \"{s}\"", .{name}).throw();
                         }
-                        return null;
+                        return error.JSError;
                     };
                 };
 
@@ -1687,25 +1435,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 globalThis.throwInvalidArgumentTypeValue("salt", "string or buffer", arguments[1]);
                 };
 
                 if (out.salt.slice().len > std.math.maxInt(i32)) {
-                    globalThis.throwInvalidArguments("salt is too long", .{});
-                    return null;
+                    return globalThis.throwInvalidArguments("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 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.throwInvalidArguments("password is too long", .{});
                 }
 
                 return out;
@@ -1826,36 +1571,32 @@ 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.getOwnTruthy(globalObject, "algorithm")) |algorithm_value| {
+                        if (try value.getTruthy(globalObject, "algorithm")) |algorithm_value| {
                             if (!algorithm_value.isString()) {
-                                globalObject.throwInvalidArgumentType("hash", "algorithm", "string");
-                                return null;
+                                return globalObject.throwInvalidArgumentType("hash", "algorithm", "string");
                             }
 
                             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 globalObject.throwInvalidArgumentType("hash", "algorithm", unknown_password_algorithm_message);
                             }) {
                                 .bcrypt => {
                                     var algorithm = PasswordObject.Algorithm.Value{
                                         .bcrypt = PasswordObject.Algorithm.Value.bcrpyt_default,
                                     };
 
-                                    if (value.getOwnTruthy(globalObject, "cost")) |rounds_value| {
+                                    if (try value.getTruthy(globalObject, "cost")) |rounds_value| {
                                         if (!rounds_value.isNumber()) {
-                                            globalObject.throwInvalidArgumentType("hash", "cost", "number");
-                                            return null;
+                                            return globalObject.throwInvalidArgumentType("hash", "cost", "number");
                                         }
 
                                         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.throwInvalidArguments("Rounds must be between 4 and 31", .{});
                                         }
 
                                         algorithm.bcrypt = @as(u6, @intCast(rounds));
@@ -1866,33 +1607,29 @@ pub const Crypto = struct {
                                 inline .argon2id, .argon2d, .argon2i => |tag| {
                                     var argon = Algorithm.Argon2Params{};
 
-                                    if (value.getOwnTruthy(globalObject, "timeCost")) |time_value| {
+                                    if (try value.getTruthy(globalObject, "timeCost")) |time_value| {
                                         if (!time_value.isNumber()) {
-                                            globalObject.throwInvalidArgumentType("hash", "timeCost", "number");
-                                            return null;
+                                            return globalObject.throwInvalidArgumentType("hash", "timeCost", "number");
                                         }
 
                                         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.throwInvalidArguments("Time cost must be greater than 0", .{});
                                         }
 
                                         argon.time_cost = @as(u32, @intCast(time_cost));
                                     }
 
-                                    if (value.getOwnTruthy(globalObject, "memoryCost")) |memory_value| {
+                                    if (try value.getTruthy(globalObject, "memoryCost")) |memory_value| {
                                         if (!memory_value.isNumber()) {
-                                            globalObject.throwInvalidArgumentType("hash", "memoryCost", "number");
-                                            return null;
+                                            return globalObject.throwInvalidArgumentType("hash", "memoryCost", "number");
                                         }
 
                                         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.throwInvalidArguments("Memory cost must be greater than 0", .{});
                                         }
 
                                         argon.memory_cost = @as(u32, @intCast(memory_cost));
@@ -1904,15 +1641,13 @@ pub const Crypto = struct {
 
                             unreachable;
                         } else {
-                            globalObject.throwInvalidArgumentType("hash", "options.algorithm", "string");
-                            return null;
+                            return globalObject.throwInvalidArgumentType("hash", "options.algorithm", "string");
                         }
                     } 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 globalObject.throwInvalidArgumentType("hash", "algorithm", unknown_password_algorithm_message);
                         }) {
                             .bcrypt => {
                                 return PasswordObject.Algorithm.Value{
@@ -1936,8 +1671,7 @@ pub const Crypto = struct {
                             },
                         }
                     } else {
-                        globalObject.throwInvalidArgumentType("hash", "algorithm", "string");
-                        return null;
+                        return globalObject.throwInvalidArgumentType("hash", "algorithm", "string");
                     }
 
                     unreachable;
@@ -2244,12 +1978,8 @@ pub const Crypto = struct {
                 this.deinit();
             }
         };
-        pub fn hash(
-            globalObject: *JSC.JSGlobalObject,
-            password: []const u8,
-            algorithm: PasswordObject.Algorithm.Value,
-            comptime sync: bool,
-        ) JSC.JSValue {
+
+        pub fn hash(globalObject: *JSC.JSGlobalObject, password: []const u8, algorithm: PasswordObject.Algorithm.Value, comptime sync: bool) bun.JSError!JSC.JSValue {
             assert(password.len > 0); // caller must check
 
             if (comptime sync) {
@@ -2257,8 +1987,7 @@ pub const Crypto = struct {
                 switch (value) {
                     .err => {
                         const error_instance = value.toErrorInstance(globalObject);
-                        globalObject.throwValue(error_instance);
-                        return .zero;
+                        return globalObject.throwValue(error_instance);
                     },
                     .hash => |h| {
                         return JSC.ZigString.init(h).toJS(globalObject);
@@ -2283,13 +2012,7 @@ pub const Crypto = struct {
             return promise.value();
         }
 
-        pub fn verify(
-            globalObject: *JSC.JSGlobalObject,
-            password: []const u8,
-            prev_hash: []const u8,
-            algorithm: ?PasswordObject.Algorithm,
-            comptime sync: bool,
-        ) JSC.JSValue {
+        pub fn verify(globalObject: *JSC.JSGlobalObject, password: []const u8, prev_hash: []const u8, algorithm: ?PasswordObject.Algorithm, comptime sync: bool) bun.JSError!JSC.JSValue {
             assert(password.len > 0); // caller must check
 
             if (comptime sync) {
@@ -2297,8 +2020,7 @@ pub const Crypto = struct {
                 switch (value) {
                     .err => {
                         const error_instance = value.toErrorInstance(globalObject);
-                        globalObject.throwValue(error_instance);
-                        return JSC.JSValue.undefined;
+                        return globalObject.throwValue(error_instance);
                     },
                     .pass => |pass| {
                         return JSC.JSValue.jsBoolean(pass);
@@ -2325,76 +2047,62 @@ 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 {
-            const arguments_ = callframe.arguments(2);
+        pub fn JSPasswordObject__hash(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+            const arguments_ = callframe.arguments_old(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 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 globalObject.throwInvalidArguments("password must not be empty", .{});
             }
 
             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 {
-            const arguments_ = callframe.arguments(2);
+        pub fn JSPasswordObject__hashSync(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+            const arguments_ = callframe.arguments_old(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 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.throwInvalidArguments("password must not be empty", .{});
             }
 
-            defer string_or_buffer.deinit();
-
             return hash(globalObject, string_or_buffer.slice(), algorithm, true);
         }
 
@@ -2486,45 +2194,40 @@ 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 {
-            const arguments_ = callframe.arguments(3);
+        pub fn JSPasswordObject__verify(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+            const arguments_ = callframe.arguments_old(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;
 
             if (arguments.len > 2 and !arguments[2].isEmptyOrUndefinedOrNull()) {
                 if (!arguments[2].isString()) {
-                    globalObject.throwInvalidArgumentType("verify", "algorithm", "string");
-                    return JSC.JSValue.undefined;
+                    return globalObject.throwInvalidArgumentType("verify", "algorithm", "string");
                 }
 
                 const algorithm_string = arguments[2].getZigString(globalObject);
 
                 algorithm = PasswordObject.Algorithm.label.getWithEql(algorithm_string, JSC.ZigString.eqlComptime) orelse {
                     if (!globalObject.hasException()) {
-                        globalObject.throwInvalidArgumentType("verify", "algorithm", unknown_password_algorithm_message);
+                        return 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()) return 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()) return globalObject.throwInvalidArgumentType("verify", "hash", "string or TypedArray");
+                return error.JSError;
             };
 
             if (owned_hash.len == 0) {
@@ -2541,49 +2244,44 @@ 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 {
-            const arguments_ = callframe.arguments(3);
+        pub fn JSPasswordObject__verifySync(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+            const arguments_ = callframe.arguments_old(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;
 
             if (arguments.len > 2 and !arguments[2].isEmptyOrUndefinedOrNull()) {
                 if (!arguments[2].isString()) {
-                    globalObject.throwInvalidArgumentType("verify", "algorithm", "string");
-                    return JSC.JSValue.undefined;
+                    return globalObject.throwInvalidArgumentType("verify", "algorithm", "string");
                 }
 
                 const algorithm_string = arguments[2].getZigString(globalObject);
 
                 algorithm = PasswordObject.Algorithm.label.getWithEql(algorithm_string, JSC.ZigString.eqlComptime) orelse {
                     if (!globalObject.hasException()) {
-                        globalObject.throwInvalidArgumentType("verify", "algorithm", unknown_password_algorithm_message);
+                        return globalObject.throwInvalidArgumentType("verify", "algorithm", unknown_password_algorithm_message);
                     }
-                    return JSC.JSValue.undefined;
+                    return .zero;
                 };
             }
 
             var password = JSC.Node.StringOrBuffer.fromJS(globalObject, bun.default_allocator, arguments[0]) orelse {
                 if (!globalObject.hasException()) {
-                    globalObject.throwInvalidArgumentType("verify", "password", "string or TypedArray");
+                    return globalObject.throwInvalidArgumentType("verify", "password", "string or TypedArray");
                 }
-                return JSC.JSValue.undefined;
+                return .zero;
             };
 
             var hash_ = JSC.Node.StringOrBuffer.fromJS(globalObject, bun.default_allocator, arguments[1]) orelse {
                 password.deinit();
                 if (!globalObject.hasException()) {
-                    globalObject.throwInvalidArgumentType("verify", "hash", "string or TypedArray");
+                    return globalObject.throwInvalidArgumentType("verify", "hash", "string or TypedArray");
                 }
-                return JSC.JSValue.undefined;
+                return .zero;
             };
 
             defer password.deinit();
@@ -2602,6 +2300,9 @@ pub const Crypto = struct {
     };
 
     pub const CryptoHasher = union(enum) {
+        // HMAC_CTX contains 3 EVP_CTX, so let's store it as a pointer.
+        hmac: ?*HMAC,
+
         evp: EVP,
         zig: CryptoHasherZig,
 
@@ -2613,22 +2314,26 @@ pub const Crypto = struct {
         pub const digest = JSC.wrapInstanceMethod(CryptoHasher, "digest_", false);
         pub const hash = JSC.wrapStaticMethod(CryptoHasher, "hash_", false);
 
-        pub fn getByteLength(
-            this: *CryptoHasher,
-            _: *JSC.JSGlobalObject,
-        ) JSC.JSValue {
+        fn throwHmacConsumed(globalThis: *JSC.JSGlobalObject) bun.JSError {
+            return globalThis.throw("HMAC has been consumed and is no longer usable", .{});
+        }
+
+        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) 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 else => |*inner| ZigString.fromUTF8(bun.asByteSlice(@tagName(inner.algorithm))).toJS(globalObject),
+                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) catch return .zero;
+                },
             };
         }
 
@@ -2641,51 +2346,37 @@ pub const Crypto = struct {
             return JSC.JSValue.createStringArray(globalThis_, &values, values.len, true);
         }
 
-        fn hashToEncoding(
-            globalThis: *JSGlobalObject,
-            evp: *EVP,
-            input: JSC.Node.BlobOrStringOrBuffer,
-            encoding: JSC.Node.Encoding,
-        ) JSC.JSValue {
+        fn hashToEncoding(globalThis: *JSGlobalObject, evp: *EVP, input: JSC.Node.BlobOrStringOrBuffer, encoding: JSC.Node.Encoding) bun.JSError!JSC.JSValue {
             var output_digest_buf: Digest = undefined;
             defer input.deinit();
 
             if (input == .blob and input.blob.isBunFile()) {
-                globalThis.throw("Bun.file() is not supported here yet (it needs an async version)", .{});
-                return .zero;
+                return globalThis.throw("Bun.file() is not supported here yet (it needs an async version)", .{});
             }
 
             const len = evp.hash(globalThis.bunVM().rareData().boringEngine(), input.slice(), &output_digest_buf) orelse {
                 const err = BoringSSL.ERR_get_error();
                 const instance = createCryptoError(globalThis, err);
                 BoringSSL.ERR_clear_error();
-                globalThis.throwValue(instance);
-                return .zero;
+                return globalThis.throwValue(instance);
             };
             return encoding.encodeWithMaxSize(globalThis, BoringSSL.EVP_MAX_MD_SIZE, output_digest_buf[0..len]);
         }
 
-        fn hashToBytes(
-            globalThis: *JSGlobalObject,
-            evp: *EVP,
-            input: JSC.Node.BlobOrStringOrBuffer,
-            output: ?JSC.ArrayBuffer,
-        ) JSC.JSValue {
+        fn hashToBytes(globalThis: *JSGlobalObject, evp: *EVP, input: JSC.Node.BlobOrStringOrBuffer, output: ?JSC.ArrayBuffer) bun.JSError!JSC.JSValue {
             var output_digest_buf: Digest = undefined;
             var output_digest_slice: []u8 = &output_digest_buf;
             defer input.deinit();
 
             if (input == .blob and input.blob.isBunFile()) {
-                globalThis.throw("Bun.file() is not supported here yet (it needs an async version)", .{});
-                return .zero;
+                return globalThis.throw("Bun.file() is not supported here yet (it needs an async version)", .{});
             }
 
             if (output) |output_buf| {
                 const size = evp.size();
                 var bytes = output_buf.byteSlice();
                 if (bytes.len < size) {
-                    globalThis.throwInvalidArguments("TypedArray must be at least {d} bytes", .{size});
-                    return JSC.JSValue.zero;
+                    return globalThis.throwInvalidArguments("TypedArray must be at least {d} bytes", .{size});
                 }
                 output_digest_slice = bytes[0..size];
             }
@@ -2694,8 +2385,7 @@ pub const Crypto = struct {
                 const err = BoringSSL.ERR_get_error();
                 const instance = createCryptoError(globalThis, err);
                 BoringSSL.ERR_clear_error();
-                globalThis.throwValue(instance);
-                return .zero;
+                return globalThis.throwValue(instance);
             };
 
             if (output) |output_buf| {
@@ -2711,10 +2401,9 @@ pub const Crypto = struct {
             algorithm: ZigString,
             input: JSC.Node.BlobOrStringOrBuffer,
             output: ?JSC.Node.StringOrBuffer,
-        ) JSC.JSValue {
-            var evp = EVP.byName(algorithm, globalThis) orelse return CryptoHasherZig.hashByName(globalThis, algorithm, input, output) orelse {
-                globalThis.throwInvalidArguments("Unsupported algorithm \"{any}\"", .{algorithm});
-                return .zero;
+        ) bun.JSError!JSC.JSValue {
+            var evp = EVP.byName(algorithm, globalThis) orelse return try CryptoHasherZig.hashByName(globalThis, algorithm, input, output) orelse {
+                return globalThis.throwInvalidArguments("Unsupported algorithm \"{any}\"", .{algorithm});
             };
             defer evp.deinit();
 
@@ -2723,8 +2412,7 @@ pub const Crypto = struct {
                     inline else => |*str| {
                         defer str.deinit();
                         const encoding = JSC.Node.Encoding.from(str.slice()) orelse {
-                            globalThis.throwInvalidArguments("Unknown encoding: {s}", .{str.slice()});
-                            return JSC.JSValue.zero;
+                            return globalThis.ERR_INVALID_ARG_VALUE("Unknown encoding: {s}", .{str.slice()}).throw();
                         };
 
                         return hashToEncoding(globalThis, &evp, input, encoding);
@@ -2738,33 +2426,69 @@ pub const Crypto = struct {
             }
         }
 
-        pub fn constructor(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) ?*CryptoHasher {
-            const arguments = callframe.arguments(2);
+        // Bun.CryptoHasher(algorithm, hmacKey?: string | Buffer)
+        pub fn constructor(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!*CryptoHasher {
+            const arguments = callframe.arguments_old(2);
             if (arguments.len == 0) {
-                globalThis.throwInvalidArguments("Expected an algorithm name as an argument", .{});
-                return null;
+                return globalThis.throwInvalidArguments("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.throwInvalidArguments("algorithm must be a string", .{});
             }
 
             const algorithm = algorithm_name.getZigString(globalThis);
 
             if (algorithm.len == 0) {
-                globalThis.throwInvalidArguments("Invalid algorithm name", .{});
-                return null;
+                return globalThis.throwInvalidArguments("Invalid algorithm name", .{});
             }
 
-            var this: CryptoHasher = undefined;
-            const evp = EVP.byName(algorithm, globalThis) orelse return CryptoHasherZig.constructor(algorithm) orelse {
-                globalThis.throwInvalidArguments("Unsupported algorithm {any}", .{algorithm});
-                return null;
-            };
-            this = .{ .evp = evp };
-            return CryptoHasher.new(this);
+            const hmac_value = arguments.ptr[1];
+            var hmac_key: ?JSC.Node.StringOrBuffer = null;
+            defer {
+                if (hmac_key) |*key| {
+                    key.deinit();
+                }
+            }
+
+            if (!hmac_value.isEmptyOrUndefinedOrNull()) {
+                hmac_key = JSC.Node.StringOrBuffer.fromJS(globalThis, bun.default_allocator, hmac_value) orelse {
+                    return globalThis.throwInvalidArguments("key must be a string or buffer", .{});
+                };
+            }
+
+            return CryptoHasher.new(brk: {
+                if (hmac_key) |*key| {
+                    const chosen_algorithm = try algorithm_name.toEnumFromMap(globalThis, "algorithm", EVP.Algorithm, EVP.Algorithm.map);
+                    if (chosen_algorithm == .ripemd160) {
+                        // crashes at runtime.
+                        return globalThis.throw("ripemd160 is not supported", .{});
+                    }
+
+                    break :brk .{
+                        .hmac = HMAC.init(chosen_algorithm, key.slice()) orelse {
+                            if (!globalThis.hasException()) {
+                                const err = BoringSSL.ERR_get_error();
+                                if (err != 0) {
+                                    const instance = createCryptoError(globalThis, err);
+                                    BoringSSL.ERR_clear_error();
+                                    return globalThis.throwValue(instance);
+                                } else {
+                                    return globalThis.throwTODO("HMAC is not supported for this algorithm yet");
+                                }
+                            }
+                            return error.JSError;
+                        },
+                    };
+                }
+
+                break :brk .{
+                    .evp = EVP.byName(algorithm, globalThis) orelse return CryptoHasherZig.constructor(algorithm) orelse {
+                        return globalThis.throwInvalidArguments("Unsupported algorithm {any}", .{algorithm});
+                    },
+                };
+            });
         }
 
         pub fn getter(
@@ -2774,23 +2498,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 arguments = callframe.arguments_old(2);
             const input = arguments.ptr[0];
             if (input.isEmptyOrUndefinedOrNull()) {
-                globalThis.throwInvalidArguments("expected blob, string or buffer", .{});
-                return JSC.JSValue.zero;
+                return globalThis.throwInvalidArguments("expected blob, string or buffer", .{});
             }
             const encoding = arguments.ptr[1];
-            const buffer = 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;
+            const buffer = try JSC.Node.BlobOrStringOrBuffer.fromJSWithEncodingValue(globalThis, globalThis.bunVM().allocator, input, encoding) orelse {
+                if (!globalThis.hasException()) return globalThis.throwInvalidArguments("expected blob, string or buffer", .{});
+                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.throw("Bun.file() is not supported here yet (it needs an async version)", .{});
             }
 
             switch (this.*) {
@@ -2800,8 +2522,20 @@ pub const Crypto = struct {
                     if (err != 0) {
                         const instance = createCryptoError(globalThis, err);
                         BoringSSL.ERR_clear_error();
-                        globalThis.throwValue(instance);
-                        return .zero;
+                        return globalThis.throwValue(instance);
+                    }
+                },
+                .hmac => |inner| {
+                    const hmac = inner orelse {
+                        return throwHmacConsumed(globalThis);
+                    };
+
+                    hmac.update(buffer.slice());
+                    const err = BoringSSL.ERR_get_error();
+                    if (err != 0) {
+                        const instance = createCryptoError(globalThis, err);
+                        BoringSSL.ERR_clear_error();
+                        return globalThis.throwValue(instance);
                     }
                 },
                 .zig => |*inner| {
@@ -2817,12 +2551,24 @@ 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| {
                     new = .{ .evp = inner.copy(globalObject.bunVM().rareData().boringEngine()) catch bun.outOfMemory() };
                 },
+                .hmac => |inner| {
+                    const hmac = inner orelse {
+                        return throwHmacConsumed(globalObject);
+                    };
+                    new = .{
+                        .hmac = hmac.copy() catch {
+                            const err = createCryptoError(globalObject, BoringSSL.ERR_get_error());
+                            BoringSSL.ERR_clear_error();
+                            return globalObject.throwValue(err);
+                        },
+                    };
+                },
                 .zig => |*inner| {
                     new = .{ .zig = inner.copy() };
                 },
@@ -2830,18 +2576,13 @@ pub const Crypto = struct {
             return CryptoHasher.new(new).toJS(globalObject);
         }
 
-        pub fn digest_(
-            this: *CryptoHasher,
-            globalThis: *JSGlobalObject,
-            output: ?JSC.Node.StringOrBuffer,
-        ) JSC.JSValue {
+        pub fn digest_(this: *CryptoHasher, globalThis: *JSGlobalObject, output: ?JSC.Node.StringOrBuffer) bun.JSError!JSC.JSValue {
             if (output) |string_or_buffer| {
                 switch (string_or_buffer) {
                     inline else => |*str| {
                         defer str.deinit();
                         const encoding = JSC.Node.Encoding.from(str.slice()) orelse {
-                            globalThis.throwInvalidArguments("Unknown encoding: {}", .{str.*});
-                            return JSC.JSValue.zero;
+                            return globalThis.ERR_INVALID_ARG_VALUE("Unknown encoding: {s}", .{str.slice()}).throw();
                         };
 
                         return this.digestToEncoding(globalThis, encoding);
@@ -2858,21 +2599,23 @@ pub const Crypto = struct {
             }
         }
 
-        fn digestToBytes(this: *CryptoHasher, globalThis: *JSGlobalObject, output: ?JSC.ArrayBuffer) JSC.JSValue {
+        fn digestToBytes(this: *CryptoHasher, globalThis: *JSGlobalObject, output: ?JSC.ArrayBuffer) bun.JSError!JSC.JSValue {
             var output_digest_buf: EVP.Digest = undefined;
             var output_digest_slice: []u8 = &output_digest_buf;
             if (output) |output_buf| {
                 var bytes = output_buf.byteSlice();
                 if (bytes.len < output_digest_buf.len) {
-                    globalThis.throwInvalidArguments(comptime std.fmt.comptimePrint("TypedArray must be at least {d} bytes", .{output_digest_buf.len}), .{});
-                    return JSC.JSValue.zero;
+                    return globalThis.throwInvalidArguments(comptime std.fmt.comptimePrint("TypedArray must be at least {d} bytes", .{output_digest_buf.len}), .{});
                 }
                 output_digest_slice = bytes[0..bytes.len];
             } else {
                 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 error.JSError;
+            }
 
             if (output) |output_buf| {
                 return output_buf.value;
@@ -2882,15 +2625,26 @@ pub const Crypto = struct {
             }
         }
 
-        fn digestToEncoding(this: *CryptoHasher, globalThis: *JSGlobalObject, encoding: JSC.Node.Encoding) JSC.JSValue {
+        fn digestToEncoding(this: *CryptoHasher, globalThis: *JSGlobalObject, encoding: JSC.Node.Encoding) bun.JSError!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 error.JSError;
+            }
             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 {
+                        return throwHmacConsumed(globalThis);
+                    };
+                    this.hmac = null;
+                    defer hmac.deinit();
+                    break :brk hmac.final(output_digest_slice);
+                },
                 .evp => |*inner| inner.final(globalThis.bunVM().rareData().boringEngine(), output_digest_slice),
                 .zig => |*inner| inner.final(output_digest_slice),
             };
@@ -2905,6 +2659,11 @@ pub const Crypto = struct {
                 .zig => |*inner| {
                     inner.deinit();
                 },
+                .hmac => |inner| {
+                    if (inner) |hmac| {
+                        hmac.deinit();
+                    }
+                },
             }
             this.destroy();
         }
@@ -2932,27 +2691,29 @@ pub const Crypto = struct {
             };
         }
 
-        pub fn hashByName(
-            globalThis: *JSGlobalObject,
-            algorithm: ZigString,
-            input: JSC.Node.BlobOrStringOrBuffer,
-            output: ?JSC.Node.StringOrBuffer,
-        ) ?JSC.JSValue {
+        pub fn hashByName(globalThis: *JSGlobalObject, algorithm: ZigString, input: JSC.Node.BlobOrStringOrBuffer, output: ?JSC.Node.StringOrBuffer) bun.JSError!?JSC.JSValue {
             inline for (algo_map) |item| {
                 if (bun.strings.eqlComptime(algorithm.slice(), item[0])) {
-                    return hashByNameInner(globalThis, item[1], input, output);
+                    return try hashByNameInner(globalThis, item[1], input, output);
                 }
             }
             return null;
         }
 
-        fn hashByNameInner(globalThis: *JSGlobalObject, comptime Algorithm: type, input: JSC.Node.BlobOrStringOrBuffer, output: ?JSC.Node.StringOrBuffer) JSC.JSValue {
+        fn hashByNameInner(globalThis: *JSGlobalObject, comptime Algorithm: type, input: JSC.Node.BlobOrStringOrBuffer, output: ?JSC.Node.StringOrBuffer) bun.JSError!JSC.JSValue {
             if (output) |string_or_buffer| {
                 switch (string_or_buffer) {
                     inline else => |*str| {
                         defer str.deinit();
-                        globalThis.throwInvalidArguments("Unknown encoding: {s}", .{str.slice()});
-                        return JSC.JSValue.zero;
+                        const encoding = JSC.Node.Encoding.from(str.slice()) orelse {
+                            return globalThis.ERR_INVALID_ARG_VALUE("Unknown encoding: {s}", .{str.slice()}).throw();
+                        };
+
+                        if (encoding == .buffer) {
+                            return hashByNameInnerToBytes(globalThis, Algorithm, input, null);
+                        }
+
+                        return hashByNameInnerToString(globalThis, Algorithm, input, encoding);
                     },
                     .buffer => |buffer| {
                         return hashByNameInnerToBytes(globalThis, Algorithm, input, buffer.buffer);
@@ -2962,12 +2723,27 @@ pub const Crypto = struct {
             return hashByNameInnerToBytes(globalThis, Algorithm, input, null);
         }
 
-        fn hashByNameInnerToBytes(globalThis: *JSGlobalObject, comptime Algorithm: type, input: JSC.Node.BlobOrStringOrBuffer, output: ?JSC.ArrayBuffer) JSC.JSValue {
+        fn hashByNameInnerToString(globalThis: *JSGlobalObject, comptime Algorithm: type, input: JSC.Node.BlobOrStringOrBuffer, encoding: JSC.Node.Encoding) bun.JSError!JSC.JSValue {
             defer input.deinit();
 
             if (input == .blob and input.blob.isBunFile()) {
-                globalThis.throw("Bun.file() is not supported here yet (it needs an async version)", .{});
-                return .zero;
+                return globalThis.throw("Bun.file() is not supported here yet (it needs an async version)", .{});
+            }
+
+            var h = Algorithm.init(.{});
+            h.update(input.slice());
+
+            var out: [digestLength(Algorithm)]u8 = undefined;
+            h.final(&out);
+
+            return encoding.encodeWithSize(globalThis, digestLength(Algorithm), &out);
+        }
+
+        fn hashByNameInnerToBytes(globalThis: *JSGlobalObject, comptime Algorithm: type, input: JSC.Node.BlobOrStringOrBuffer, output: ?JSC.ArrayBuffer) bun.JSError!JSC.JSValue {
+            defer input.deinit();
+
+            if (input == .blob and input.blob.isBunFile()) {
+                return globalThis.throw("Bun.file() is not supported here yet (it needs an async version)", .{});
             }
 
             var h = Algorithm.init(.{});
@@ -2975,8 +2751,7 @@ pub const Crypto = struct {
 
             if (output) |output_buf| {
                 if (output_buf.byteSlice().len < digest_length_comptime) {
-                    globalThis.throwInvalidArguments("TypedArray must be at least {d} bytes", .{digest_length_comptime});
-                    return JSC.JSValue.zero;
+                    return globalThis.throwInvalidArguments("TypedArray must be at least {d} bytes", .{digest_length_comptime});
                 }
             }
 
@@ -3051,6 +2826,7 @@ pub const Crypto = struct {
     fn StaticCryptoHasher(comptime Hasher: type, comptime name: [:0]const u8) type {
         return struct {
             hashing: Hasher = Hasher{},
+            digested: bool = false,
 
             const ThisHasher = @This();
 
@@ -3074,16 +2850,11 @@ pub const Crypto = struct {
                 return JSC.JSValue.jsNumber(@as(u16, Hasher.digest));
             }
 
-            fn hashToEncoding(
-                globalThis: *JSGlobalObject,
-                input: JSC.Node.BlobOrStringOrBuffer,
-                encoding: JSC.Node.Encoding,
-            ) JSC.JSValue {
+            fn hashToEncoding(globalThis: *JSGlobalObject, input: JSC.Node.BlobOrStringOrBuffer, encoding: JSC.Node.Encoding) bun.JSError!JSC.JSValue {
                 var output_digest_buf: Hasher.Digest = undefined;
 
                 if (input == .blob and input.blob.isBunFile()) {
-                    globalThis.throw("Bun.file() is not supported here yet (it needs an async version)", .{});
-                    return .zero;
+                    return globalThis.throw("Bun.file() is not supported here yet (it needs an async version)", .{});
                 }
 
                 if (comptime @typeInfo(@TypeOf(Hasher.hash)).Fn.params.len == 3) {
@@ -3095,18 +2866,13 @@ pub const Crypto = struct {
                 return encoding.encodeWithSize(globalThis, Hasher.digest, &output_digest_buf);
             }
 
-            fn hashToBytes(
-                globalThis: *JSGlobalObject,
-                input: JSC.Node.BlobOrStringOrBuffer,
-                output: ?JSC.ArrayBuffer,
-            ) JSC.JSValue {
+            fn hashToBytes(globalThis: *JSGlobalObject, input: JSC.Node.BlobOrStringOrBuffer, output: ?JSC.ArrayBuffer) bun.JSError!JSC.JSValue {
                 var output_digest_buf: Hasher.Digest = undefined;
                 var output_digest_slice: *Hasher.Digest = &output_digest_buf;
                 if (output) |output_buf| {
                     var bytes = output_buf.byteSlice();
                     if (bytes.len < Hasher.digest) {
-                        globalThis.throwInvalidArguments(comptime std.fmt.comptimePrint("TypedArray must be at least {d} bytes", .{Hasher.digest}), .{});
-                        return JSC.JSValue.zero;
+                        return globalThis.throwInvalidArguments(comptime std.fmt.comptimePrint("TypedArray must be at least {d} bytes", .{Hasher.digest}), .{});
                     }
                     output_digest_slice = bytes[0..Hasher.digest];
                 }
@@ -3129,12 +2895,11 @@ pub const Crypto = struct {
                 globalThis: *JSGlobalObject,
                 input: JSC.Node.BlobOrStringOrBuffer,
                 output: ?JSC.Node.StringOrBuffer,
-            ) JSC.JSValue {
+            ) bun.JSError!JSC.JSValue {
                 defer input.deinit();
 
                 if (input == .blob and input.blob.isBunFile()) {
-                    globalThis.throw("Bun.file() is not supported here yet (it needs an async version)", .{});
-                    return .zero;
+                    return globalThis.throw("Bun.file() is not supported here yet (it needs an async version)", .{});
                 }
 
                 if (output) |string_or_buffer| {
@@ -3142,8 +2907,7 @@ pub const Crypto = struct {
                         inline else => |*str| {
                             defer str.deinit();
                             const encoding = JSC.Node.Encoding.from(str.slice()) orelse {
-                                globalThis.throwInvalidArguments("Unknown encoding: {s}", .{str.slice()});
-                                return JSC.JSValue.zero;
+                                return globalThis.ERR_INVALID_ARG_VALUE("Unknown encoding: {s}", .{str.slice()}).throw();
                             };
 
                             return hashToEncoding(globalThis, input, encoding);
@@ -3157,9 +2921,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;
             }
@@ -3171,18 +2934,19 @@ 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) {
+                    return globalThis.ERR_INVALID_STATE(name ++ " hasher already digested, create a new instance to update", .{}).throw();
+                }
                 const thisValue = callframe.this();
                 const input = callframe.argument(0);
                 const buffer = JSC.Node.BlobOrStringOrBuffer.fromJS(globalThis, globalThis.bunVM().allocator, input) orelse {
-                    globalThis.throwInvalidArguments("expected blob or string or buffer", .{});
-                    return JSC.JSValue.zero;
+                    return globalThis.throwInvalidArguments("expected blob or string or buffer", .{});
                 };
                 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.throw("Bun.file() is not supported here yet (it needs an async version)", .{});
                 }
                 this.hashing.update(buffer.slice());
                 return thisValue;
@@ -3192,14 +2956,16 @@ pub const Crypto = struct {
                 this: *@This(),
                 globalThis: *JSGlobalObject,
                 output: ?JSC.Node.StringOrBuffer,
-            ) JSC.JSValue {
+            ) bun.JSError!JSC.JSValue {
+                if (this.digested) {
+                    return globalThis.ERR_INVALID_STATE(name ++ " hasher already digested, create a new instance to digest again", .{}).throw();
+                }
                 if (output) |*string_or_buffer| {
                     switch (string_or_buffer.*) {
                         inline else => |*str| {
                             defer str.deinit();
                             const encoding = JSC.Node.Encoding.from(str.slice()) orelse {
-                                globalThis.throwInvalidArguments("Unknown encoding: \"{s}\"", .{str.slice()});
-                                return JSC.JSValue.zero;
+                                return globalThis.ERR_INVALID_ARG_VALUE("Unknown encoding: {s}", .{str.slice()}).throw();
                             };
 
                             return this.digestToEncoding(globalThis, encoding);
@@ -3216,14 +2982,13 @@ pub const Crypto = struct {
                 }
             }
 
-            fn digestToBytes(this: *@This(), globalThis: *JSGlobalObject, output: ?JSC.ArrayBuffer) JSC.JSValue {
+            fn digestToBytes(this: *@This(), globalThis: *JSGlobalObject, output: ?JSC.ArrayBuffer) bun.JSError!JSC.JSValue {
                 var output_digest_buf: Hasher.Digest = undefined;
                 var output_digest_slice: *Hasher.Digest = &output_digest_buf;
                 if (output) |output_buf| {
                     var bytes = output_buf.byteSlice();
                     if (bytes.len < Hasher.digest) {
-                        globalThis.throwInvalidArguments(comptime std.fmt.comptimePrint("TypedArray must be at least {d} bytes", .{Hasher.digest}), .{});
-                        return JSC.JSValue.zero;
+                        return globalThis.throwInvalidArguments(comptime std.fmt.comptimePrint("TypedArray must be at least {d} bytes", .{Hasher.digest}), .{});
                     }
                     output_digest_slice = bytes[0..Hasher.digest];
                 } else {
@@ -3231,6 +2996,7 @@ pub const Crypto = struct {
                 }
 
                 this.hashing.final(output_digest_slice);
+                this.digested = true;
 
                 if (output) |output_buf| {
                     return output_buf.value;
@@ -3254,6 +3020,7 @@ pub const Crypto = struct {
                 const output_digest_slice: *Hasher.Digest = &output_digest_buf;
 
                 this.hashing.final(output_digest_slice);
+                this.digested = true;
 
                 return encoding.encodeWithSize(globalThis, Hasher.digest, output_digest_slice);
             }
@@ -3274,43 +3041,32 @@ 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 {
-    const arguments = callframe.arguments(2).slice();
+pub fn serve(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+    const arguments = callframe.arguments_old(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.fromJS(globalObject.ptr(), &args, exception);
-        if (exception[0] != null) {
-            config_.deinit();
+        var config: JSC.API.ServerConfig = .{};
 
-            globalObject.throwValue(exception_[0].?.value());
-            return .undefined;
-        }
+        try JSC.API.ServerConfig.fromJS(
+            globalObject,
+            &config,
+            &args,
+            callframe.isFromBunMain(globalObject.vm()),
+        );
 
         if (globalObject.hasException()) {
-            config_.deinit();
-
+            config.deinit();
             return .zero;
         }
 
-        break :brk config_;
+        break :brk config;
     };
 
-    var exception_value: *JSC.JSValue = undefined;
-
     if (config.allow_hot) {
         if (globalObject.bunVM().hotMap()) |hot| {
             if (config.id.len == 0) {
@@ -3345,143 +3101,58 @@ pub fn serve(
         }
     }
 
-    // Listen happens on the next tick!
-    // This is so we can return a Server object
-    if (config.ssl_config != null) {
-        if (config.development) {
-            var server = JSC.API.DebugHTTPSServer.init(config, globalObject.ptr());
-            exception_value = &server.thisObject;
-            server.listen();
-            if (!server.thisObject.isEmpty()) {
-                exception_value.unprotect();
-                globalObject.throwValue(server.thisObject);
-                server.thisObject = JSC.JSValue.zero;
-                server.deinit();
-                return .zero;
-            }
-            const obj = server.toJS(globalObject);
-            obj.protect();
+    switch (config.ssl_config != null) {
+        inline else => |has_ssl_config| {
+            switch (config.development) {
+                inline else => |development| {
+                    const ServerType = comptime switch (development) {
+                        true => switch (has_ssl_config) {
+                            true => JSC.API.DebugHTTPSServer,
+                            false => JSC.API.DebugHTTPServer,
+                        },
+                        false => switch (has_ssl_config) {
+                            true => JSC.API.HTTPSServer,
+                            false => JSC.API.HTTPServer,
+                        },
+                    };
 
-            server.thisObject = obj;
+                    var server = try ServerType.init(&config, globalObject);
+                    if (globalObject.hasException()) {
+                        return .zero;
+                    }
+                    server.listen();
+                    if (globalObject.hasException()) {
+                        return .zero;
+                    }
+                    const obj = server.toJS(globalObject);
+                    obj.protect();
 
-            if (config.allow_hot) {
-                if (globalObject.bunVM().hotMap()) |hot| {
-                    hot.insert(config.id, server);
-                }
-            }
-            return obj;
-        } else {
-            var server = JSC.API.HTTPSServer.init(config, globalObject.ptr());
-            exception_value = &server.thisObject;
-            server.listen();
-            if (!exception_value.isEmpty()) {
-                exception_value.unprotect();
-                globalObject.throwValue(exception_value.*);
-                server.thisObject = JSC.JSValue.zero;
-                server.deinit();
-                return .zero;
-            }
-            const obj = server.toJS(globalObject);
-            obj.protect();
-            server.thisObject = obj;
+                    server.thisObject = obj;
 
-            if (config.allow_hot) {
-                if (globalObject.bunVM().hotMap()) |hot| {
-                    hot.insert(config.id, server);
-                }
+                    if (config.allow_hot) {
+                        if (globalObject.bunVM().hotMap()) |hot| {
+                            hot.insert(config.id, server);
+                        }
+                    }
+                    return obj;
+                },
             }
-            return obj;
-        }
-    } else {
-        if (config.development) {
-            var server = JSC.API.DebugHTTPServer.init(config, globalObject.ptr());
-            exception_value = &server.thisObject;
-            server.listen();
-            if (!exception_value.isEmpty()) {
-                exception_value.unprotect();
-                globalObject.throwValue(exception_value.*);
-                server.thisObject = JSC.JSValue.zero;
-                server.deinit();
-                return .zero;
-            }
-            const obj = server.toJS(globalObject);
-            obj.protect();
-            server.thisObject = obj;
-
-            if (config.allow_hot) {
-                if (globalObject.bunVM().hotMap()) |hot| {
-                    hot.insert(config.id, server);
-                }
-            }
-            return obj;
-        } else {
-            var server = JSC.API.HTTPServer.init(config, globalObject.ptr());
-            exception_value = &server.thisObject;
-            server.listen();
-            if (!exception_value.isEmpty()) {
-                exception_value.unprotect();
-                globalObject.throwValue(exception_value.*);
-                server.thisObject = JSC.JSValue.zero;
-                server.deinit();
-                return .zero;
-            }
-            const obj = server.toJS(globalObject);
-            obj.protect();
-
-            server.thisObject = obj;
-
-            if (config.allow_hot) {
-                if (globalObject.bunVM().hotMap()) |hot| {
-                    hot.insert(config.id, server);
-                }
-            }
-            return obj;
-        }
+        },
     }
-
-    unreachable;
 }
 
 pub export fn Bun__escapeHTML16(globalObject: *JSC.JSGlobalObject, input_value: JSValue, ptr: [*]const u16, len: usize) JSValue {
     assert(len > 0);
     const input_slice = ptr[0..len];
     const escaped = strings.escapeHTMLForUTF16Input(globalObject.bunVM().allocator, input_slice) catch {
-        globalObject.vm().throwError(globalObject, ZigString.init("Out of memory").toJS(globalObject));
-        return .undefined;
+        return globalObject.throwValue(bun.String.static("Out of memory").toJS(globalObject)) catch .zero;
     };
 
-    switch (escaped) {
-        .static => |val| {
-            return ZigString.init(val).toJS(globalObject);
-        },
-        .original => return input_value,
-        .allocated => |escaped_html| {
-            if (comptime Environment.allow_assert) {
-                // assert that re-encoding the string produces the same result
-                assert(
-                    std.mem.eql(
-                        u16,
-                        (strings.toUTF16Alloc(bun.default_allocator, strings.toUTF8Alloc(bun.default_allocator, escaped_html) catch unreachable, false, false) catch unreachable).?,
-                        escaped_html,
-                    ),
-                );
-
-                // assert we do not allocate a new string unnecessarily
-                assert(
-                    !std.mem.eql(
-                        u16,
-                        input_slice,
-                        escaped_html,
-                    ),
-                );
-
-                // the output should always be longer than the input
-                assert(escaped_html.len > input_slice.len);
-            }
-
-            return ZigString.from16(escaped_html.ptr, escaped_html.len).toExternalValue(globalObject);
-        },
-    }
+    return switch (escaped) {
+        .static => |val| ZigString.init(val).toJS(globalObject),
+        .original => input_value,
+        .allocated => |escaped_html| ZigString.from16(escaped_html.ptr, escaped_html.len).toExternalValue(globalObject),
+    };
 }
 
 pub export fn Bun__escapeHTML8(globalObject: *JSC.JSGlobalObject, input_value: JSValue, ptr: [*]const u8, len: usize) JSValue {
@@ -3492,8 +3163,7 @@ pub export fn Bun__escapeHTML8(globalObject: *JSC.JSGlobalObject, input_value: J
     const allocator = if (input_slice.len <= 32) stack_allocator.get() else stack_allocator.fallback_allocator;
 
     const escaped = strings.escapeHTMLForLatin1Input(allocator, input_slice) catch {
-        globalObject.vm().throwError(globalObject, ZigString.init("Out of memory").toJS(globalObject));
-        return .undefined;
+        return globalObject.throwValue(bun.String.static("Out of memory").toJS(globalObject)) catch .zero;
     };
 
     switch (escaped) {
@@ -3534,30 +3204,22 @@ comptime {
     }
 }
 
-pub fn allocUnsafe(
-    globalThis: *JSC.JSGlobalObject,
-    callframe: *JSC.CallFrame,
-) JSC.JSValue {
-    const arguments = callframe.arguments(1);
+pub fn allocUnsafe(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+    const arguments = callframe.arguments_old(1);
     const size = arguments.ptr[0];
     if (!size.isUInt32AsAnyInt()) {
-        globalThis.throwInvalidArguments("Expected a positive number", .{});
-        return JSC.JSValue.zero;
+        return globalThis.throwInvalidArguments("Expected a positive number", .{});
     }
 
     return JSC.JSValue.createUninitializedUint8Array(globalThis, size.toUInt64NoTruncate());
 }
 
-pub fn mmapFile(
-    globalThis: *JSC.JSGlobalObject,
-    callframe: *JSC.CallFrame,
-) JSC.JSValue {
+pub fn mmapFile(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     if (comptime Environment.isWindows) {
-        globalThis.throwTODO("mmapFile is not supported on Windows");
-        return JSC.JSValue.zero;
+        return globalThis.throwTODO("mmapFile is not supported on Windows");
     }
 
-    const arguments_ = callframe.arguments(2);
+    const arguments_ = callframe.arguments_old(2);
     var args = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments_.slice());
     defer args.deinit();
 
@@ -3567,15 +3229,13 @@ pub fn mmapFile(
             if (path.isString()) {
                 const path_str = path.toSlice(globalThis, args.arena.allocator());
                 if (path_str.len > bun.MAX_PATH_BYTES) {
-                    globalThis.throwInvalidArguments("Path too long", .{});
-                    return JSC.JSValue.zero;
+                    return globalThis.throwInvalidArguments("Path too long", .{});
                 }
                 const paths = &[_]string{path_str.slice()};
                 break :brk bun.path.joinAbsStringBuf(bun.fs.FileSystem.instance.top_level_dir, &buf, paths, .auto);
             }
         }
-        globalThis.throwInvalidArguments("Expected a path", .{});
-        return JSC.JSValue.zero;
+        return globalThis.throwInvalidArguments("Expected a path", .{});
     };
 
     buf[path.len] = 0;
@@ -3589,23 +3249,23 @@ pub fn mmapFile(
     var map_size: ?usize = null;
 
     if (args.nextEat()) |opts| {
-        flags.TYPE = if ((opts.get(globalThis, "shared") orelse JSValue.true).toBoolean())
+        flags.TYPE = if ((try opts.get(globalThis, "shared") orelse JSValue.true).toBoolean())
             .SHARED
         else
             .PRIVATE;
 
         if (@hasField(std.c.MAP, "SYNC")) {
-            if ((opts.get(globalThis, "sync") orelse JSValue.false).toBoolean()) {
+            if ((try opts.get(globalThis, "sync") orelse JSValue.false).toBoolean()) {
                 flags.TYPE = .SHARED_VALIDATE;
                 flags.SYNC = true;
             }
         }
 
-        if (opts.get(globalThis, "size")) |value| {
+        if (try opts.get(globalThis, "size")) |value| {
             map_size = @as(usize, @intCast(value.toInt64()));
         }
 
-        if (opts.get(globalThis, "offset")) |value| {
+        if (try opts.get(globalThis, "offset")) |value| {
             offset = @as(usize, @intCast(value.toInt64()));
             offset = std.mem.alignBackwardAnyAlign(offset, std.mem.page_size);
         }
@@ -3615,8 +3275,7 @@ pub fn mmapFile(
         .result => |map| map,
 
         .err => |err| {
-            globalThis.throwValue(err.toJSC(globalThis));
-            return .zero;
+            return globalThis.throwValue(err.toJSC(globalThis));
         },
     };
 
@@ -3627,24 +3286,15 @@ pub fn mmapFile(
     }.x, @as(?*anyopaque, @ptrFromInt(map.len)), null).?.value();
 }
 
-pub fn getTranspilerConstructor(
-    globalThis: *JSC.JSGlobalObject,
-    _: *JSC.JSObject,
-) JSC.JSValue {
+pub fn getTranspilerConstructor(globalThis: *JSC.JSGlobalObject, _: *JSC.JSObject) JSC.JSValue {
     return JSC.API.JSTranspiler.getConstructor(globalThis);
 }
 
-pub fn getFileSystemRouter(
-    globalThis: *JSC.JSGlobalObject,
-    _: *JSC.JSObject,
-) JSC.JSValue {
+pub fn getFileSystemRouter(globalThis: *JSC.JSGlobalObject, _: *JSC.JSObject) JSC.JSValue {
     return JSC.API.FileSystemRouter.getConstructor(globalThis);
 }
 
-pub fn getHashObject(
-    globalThis: *JSC.JSGlobalObject,
-    _: *JSC.JSObject,
-) JSC.JSValue {
+pub fn getHashObject(globalThis: *JSC.JSGlobalObject, _: *JSC.JSObject) JSC.JSValue {
     return HashObject.create(globalThis);
 }
 
@@ -3659,7 +3309,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",
@@ -3683,14 +3333,11 @@ 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 {
-                const arguments = callframe.arguments(2).slice();
+            pub fn hash(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+                const arguments = callframe.arguments_old(2).slice();
                 var args = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments);
                 defer args.deinit();
 
@@ -3719,8 +3366,7 @@ const HashObject = struct {
                             .DataView,
                             => {
                                 var array_buffer = arg.asArrayBuffer(globalThis) orelse {
-                                    globalThis.throwInvalidArguments("ArrayBuffer conversion error", .{});
-                                    return .zero;
+                                    return globalThis.throwInvalidArguments("ArrayBuffer conversion error", .{});
                                 };
                                 input = array_buffer.byteSlice();
                             },
@@ -3765,24 +3411,15 @@ const HashObject = struct {
     }
 };
 
-pub fn getTOMLObject(
-    globalThis: *JSC.JSGlobalObject,
-    _: *JSC.JSObject,
-) JSC.JSValue {
+pub fn getTOMLObject(globalThis: *JSC.JSGlobalObject, _: *JSC.JSObject) JSC.JSValue {
     return TOMLObject.create(globalThis);
 }
 
-pub fn getGlobConstructor(
-    globalThis: *JSC.JSGlobalObject,
-    _: *JSC.JSObject,
-) JSC.JSValue {
+pub fn getGlobConstructor(globalThis: *JSC.JSGlobalObject, _: *JSC.JSObject) JSC.JSValue {
     return JSC.API.Glob.getConstructor(globalThis);
 }
 
-pub fn getEmbeddedFiles(
-    globalThis: *JSC.JSGlobalObject,
-    _: *JSC.JSObject,
-) JSC.JSValue {
+pub fn getEmbeddedFiles(globalThis: *JSC.JSGlobalObject, _: *JSC.JSObject) JSC.JSValue {
     const vm = globalThis.bunVM();
     const graph = vm.standalone_module_graph orelse return JSC.JSValue.createEmptyArray(globalThis, 0);
 
@@ -3815,17 +3452,11 @@ pub fn getEmbeddedFiles(
     return array;
 }
 
-pub fn getSemver(
-    globalThis: *JSC.JSGlobalObject,
-    _: *JSC.JSObject,
-) JSC.JSValue {
+pub fn getSemver(globalThis: *JSC.JSGlobalObject, _: *JSC.JSObject) JSC.JSValue {
     return SemverObject.create(globalThis);
 }
 
-pub fn getUnsafe(
-    globalThis: *JSC.JSGlobalObject,
-    _: *JSC.JSObject,
-) JSC.JSValue {
+pub fn getUnsafe(globalThis: *JSC.JSGlobalObject, _: *JSC.JSObject) JSC.JSValue {
     return UnsafeObject.create(globalThis);
 }
 
@@ -3850,9 +3481,9 @@ 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];
+        const value = callframe.arguments_old(1).ptr[0];
 
         if (!value.isEmptyOrUndefinedOrNull()) {
             switch (value.coerce(i32, globalThis)) {
@@ -3868,11 +3499,10 @@ const UnsafeObject = struct {
     pub fn arrayBufferToString(
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
-        const args = callframe.arguments(2).slice();
+    ) bun.JSError!JSC.JSValue {
+        const args = callframe.arguments_old(2).slice();
         if (args.len < 1 or !args[0].isCell() or !args[0].jsType().isTypedArray()) {
-            globalThis.throwInvalidArguments("Expected an ArrayBuffer", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("Expected an ArrayBuffer", .{});
         }
 
         const array_buffer = JSC.ArrayBuffer.fromTypedArray(globalThis, args[0]);
@@ -3913,37 +3543,33 @@ 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();
         var log = logger.Log.init(default_allocator);
-        const arguments = callframe.arguments(1).slice();
+        const arguments = callframe.arguments_old(1).slice();
         if (arguments.len == 0 or arguments[0].isEmptyOrUndefinedOrNull()) {
-            globalThis.throwInvalidArguments("Expected a string to parse", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("Expected a string to parse", .{});
         }
 
         var input_slice = arguments[0].toSlice(globalThis, bun.default_allocator);
         defer input_slice.deinit();
         var source = logger.Source.initPathString("input.toml", input_slice.slice());
-        const parse_result = TOMLParser.parse(&source, &log, allocator) catch {
-            globalThis.throwValue(log.toJS(globalThis, default_allocator, "Failed to parse toml"));
-            return .zero;
+        const parse_result = TOMLParser.parse(&source, &log, allocator, false) catch {
+            return globalThis.throwValue(log.toJS(globalThis, default_allocator, "Failed to parse toml"));
         };
 
         // for now...
         const buffer_writer = js_printer.BufferWriter.init(allocator) catch {
-            globalThis.throwValue(log.toJS(globalThis, default_allocator, "Failed to print toml"));
-            return .zero;
+            return globalThis.throwValue(log.toJS(globalThis, default_allocator, "Failed to print toml"));
         };
         var writer = js_printer.BufferPrinter.init(buffer_writer);
         _ = js_printer.printJSON(*js_printer.BufferPrinter, &writer, parse_result, &source, .{}) catch {
-            globalThis.throwValue(log.toJS(globalThis, default_allocator, "Failed to print toml"));
-            return .zero;
+            return globalThis.throwValue(log.toJS(globalThis, default_allocator, "Failed to print toml"));
         };
 
-        const slice = writer.ctx.buffer.toOwnedSliceLeaky();
+        const slice = writer.ctx.buffer.slice();
         var out = bun.String.fromUTF8(slice);
         defer out.deref();
 
@@ -4030,10 +3656,9 @@ pub const FFIObject = struct {
             globalObject: *JSGlobalObject,
             _: JSValue,
             arguments: []const JSValue,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             if (arguments.len == 0 or !arguments[0].isNumber()) {
-                globalObject.throwInvalidArguments("Expected a pointer", .{});
-                return .zero;
+                return globalObject.throwInvalidArguments("Expected a pointer", .{});
             }
             const addr = arguments[0].asPtrAddress() + if (arguments.len > 1) @as(usize, @intCast(arguments[1].to(i32))) else @as(usize, 0);
             const value = @as(*align(1) u8, @ptrFromInt(addr)).*;
@@ -4043,10 +3668,9 @@ pub const FFIObject = struct {
             globalObject: *JSGlobalObject,
             _: JSValue,
             arguments: []const JSValue,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             if (arguments.len == 0 or !arguments[0].isNumber()) {
-                globalObject.throwInvalidArguments("Expected a pointer", .{});
-                return .zero;
+                return globalObject.throwInvalidArguments("Expected a pointer", .{});
             }
             const addr = arguments[0].asPtrAddress() + if (arguments.len > 1) @as(usize, @intCast(arguments[1].to(i32))) else @as(usize, 0);
             const value = @as(*align(1) u16, @ptrFromInt(addr)).*;
@@ -4056,10 +3680,9 @@ pub const FFIObject = struct {
             globalObject: *JSGlobalObject,
             _: JSValue,
             arguments: []const JSValue,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             if (arguments.len == 0 or !arguments[0].isNumber()) {
-                globalObject.throwInvalidArguments("Expected a pointer", .{});
-                return .zero;
+                return globalObject.throwInvalidArguments("Expected a pointer", .{});
             }
             const addr = arguments[0].asPtrAddress() + if (arguments.len > 1) @as(usize, @intCast(arguments[1].to(i32))) else @as(usize, 0);
             const value = @as(*align(1) u32, @ptrFromInt(addr)).*;
@@ -4069,10 +3692,9 @@ pub const FFIObject = struct {
             globalObject: *JSGlobalObject,
             _: JSValue,
             arguments: []const JSValue,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             if (arguments.len == 0 or !arguments[0].isNumber()) {
-                globalObject.throwInvalidArguments("Expected a pointer", .{});
-                return .zero;
+                return globalObject.throwInvalidArguments("Expected a pointer", .{});
             }
             const addr = arguments[0].asPtrAddress() + if (arguments.len > 1) @as(usize, @intCast(arguments[1].to(i32))) else @as(usize, 0);
             const value = @as(*align(1) u64, @ptrFromInt(addr)).*;
@@ -4082,10 +3704,9 @@ pub const FFIObject = struct {
             globalObject: *JSGlobalObject,
             _: JSValue,
             arguments: []const JSValue,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             if (arguments.len == 0 or !arguments[0].isNumber()) {
-                globalObject.throwInvalidArguments("Expected a pointer", .{});
-                return .zero;
+                return globalObject.throwInvalidArguments("Expected a pointer", .{});
             }
             const addr = arguments[0].asPtrAddress() + if (arguments.len > 1) @as(usize, @intCast(arguments[1].to(i32))) else @as(usize, 0);
             const value = @as(*align(1) i8, @ptrFromInt(addr)).*;
@@ -4095,10 +3716,9 @@ pub const FFIObject = struct {
             globalObject: *JSGlobalObject,
             _: JSValue,
             arguments: []const JSValue,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             if (arguments.len == 0 or !arguments[0].isNumber()) {
-                globalObject.throwInvalidArguments("Expected a pointer", .{});
-                return .zero;
+                return globalObject.throwInvalidArguments("Expected a pointer", .{});
             }
             const addr = arguments[0].asPtrAddress() + if (arguments.len > 1) @as(usize, @intCast(arguments[1].to(i32))) else @as(usize, 0);
             const value = @as(*align(1) i16, @ptrFromInt(addr)).*;
@@ -4108,10 +3728,9 @@ pub const FFIObject = struct {
             globalObject: *JSGlobalObject,
             _: JSValue,
             arguments: []const JSValue,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             if (arguments.len == 0 or !arguments[0].isNumber()) {
-                globalObject.throwInvalidArguments("Expected a pointer", .{});
-                return .zero;
+                return globalObject.throwInvalidArguments("Expected a pointer", .{});
             }
             const addr = arguments[0].asPtrAddress() + if (arguments.len > 1) @as(usize, @intCast(arguments[1].to(i32))) else @as(usize, 0);
             const value = @as(*align(1) i32, @ptrFromInt(addr)).*;
@@ -4121,10 +3740,9 @@ pub const FFIObject = struct {
             globalObject: *JSGlobalObject,
             _: JSValue,
             arguments: []const JSValue,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             if (arguments.len == 0 or !arguments[0].isNumber()) {
-                globalObject.throwInvalidArguments("Expected a pointer", .{});
-                return .zero;
+                return globalObject.throwInvalidArguments("Expected a pointer", .{});
             }
             const addr = arguments[0].asPtrAddress() + if (arguments.len > 1) @as(usize, @intCast(arguments[1].to(i32))) else @as(usize, 0);
             const value = @as(*align(1) i64, @ptrFromInt(addr)).*;
@@ -4135,10 +3753,9 @@ pub const FFIObject = struct {
             globalObject: *JSGlobalObject,
             _: JSValue,
             arguments: []const JSValue,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             if (arguments.len == 0 or !arguments[0].isNumber()) {
-                globalObject.throwInvalidArguments("Expected a pointer", .{});
-                return .zero;
+                return globalObject.throwInvalidArguments("Expected a pointer", .{});
             }
             const addr = arguments[0].asPtrAddress() + if (arguments.len > 1) @as(usize, @intCast(arguments[1].to(i32))) else @as(usize, 0);
             const value = @as(*align(1) f32, @ptrFromInt(addr)).*;
@@ -4149,10 +3766,9 @@ pub const FFIObject = struct {
             globalObject: *JSGlobalObject,
             _: JSValue,
             arguments: []const JSValue,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             if (arguments.len == 0 or !arguments[0].isNumber()) {
-                globalObject.throwInvalidArguments("Expected a pointer", .{});
-                return .zero;
+                return globalObject.throwInvalidArguments("Expected a pointer", .{});
             }
             const addr = arguments[0].asPtrAddress() + if (arguments.len > 1) @as(usize, @intCast(arguments[1].to(i32))) else @as(usize, 0);
             const value = @as(*align(1) f64, @ptrFromInt(addr)).*;
@@ -4163,10 +3779,9 @@ pub const FFIObject = struct {
             globalObject: *JSGlobalObject,
             _: JSValue,
             arguments: []const JSValue,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             if (arguments.len == 0 or !arguments[0].isNumber()) {
-                globalObject.throwInvalidArguments("Expected a pointer", .{});
-                return .zero;
+                return globalObject.throwInvalidArguments("Expected a pointer", .{});
             }
             const addr = arguments[0].asPtrAddress() + if (arguments.len > 1) @as(usize, @intCast(arguments[1].to(i32))) else @as(usize, 0);
             const value = @as(*align(1) i64, @ptrFromInt(addr)).*;
@@ -4177,10 +3792,9 @@ pub const FFIObject = struct {
             globalObject: *JSGlobalObject,
             _: JSValue,
             arguments: []const JSValue,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             if (arguments.len == 0 or !arguments[0].isNumber()) {
-                globalObject.throwInvalidArguments("Expected a pointer", .{});
-                return .zero;
+                return globalObject.throwInvalidArguments("Expected a pointer", .{});
             }
             const addr = arguments[0].asPtrAddress() + if (arguments.len > 1) @as(usize, @intCast(arguments[1].to(i32))) else @as(usize, 0);
             const value = @as(*align(1) u64, @ptrFromInt(addr)).*;
@@ -4338,7 +3952,7 @@ pub const FFIObject = struct {
         value: JSValue,
         byteOffset: ?JSValue,
     ) JSValue {
-        if (value.isEmpty()) {
+        if (value == .zero) {
             return JSC.JSValue.jsNull();
         }
 
@@ -4373,7 +3987,7 @@ pub const FFIObject = struct {
             }
         }
 
-        if (addr > max_addressible_memory) {
+        if (addr > max_addressable_memory) {
             return JSC.toInvalidArguments("Pointer is outside max addressible memory, which usually means a bug in your program.", .{}, globalThis);
         }
 
@@ -4455,7 +4069,7 @@ pub const FFIObject = struct {
                     return .{ .err = JSC.toInvalidArguments("length must be > 0. This usually means a bug in your code.", .{}, globalThis) };
                 }
 
-                if (length_i > max_addressible_memory) {
+                if (length_i > max_addressable_memory) {
                     return .{ .err = JSC.toInvalidArguments("length exceeds max addressable memory. This usually means a bug in your code.", .{}, globalThis) };
                 }
 
@@ -4594,8 +4208,8 @@ pub const FFIObject = struct {
     }
 };
 
-fn stringWidth(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
-    const arguments = callframe.arguments(2).slice();
+fn stringWidth(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+    const arguments = callframe.arguments_old(2).slice();
     const value = if (arguments.len > 0) arguments[0] else .undefined;
     const options_object = if (arguments.len > 1) arguments[1] else .undefined;
 
@@ -4610,11 +4224,11 @@ fn stringWidth(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC
     var ambiguous_as_wide = false;
 
     if (options_object.isObject()) {
-        if (options_object.getOwnTruthy(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.getOwnTruthy(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();
         }
@@ -4708,67 +4322,48 @@ pub const JSZlib = struct {
     };
 
     // This has to be `inline` due to the callframe.
-    inline fn getOptions(globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) ?struct { JSC.Node.StringOrBuffer, ?JSValue } {
-        const arguments = callframe.arguments(2).slice();
+    inline fn getOptions(globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!struct { JSC.Node.StringOrBuffer, ?JSValue } {
+        const arguments = callframe.arguments_old(2).slice();
         const buffer_value = if (arguments.len > 0) arguments[0] else .undefined;
         const options_val: ?JSValue =
             if (arguments.len > 1 and arguments[1].isObject())
             arguments[1]
         else if (arguments.len > 1 and !arguments[1].isUndefined()) {
-            globalThis.throwInvalidArguments("Expected options to be an object", .{});
-            return null;
+            return globalThis.throwInvalidArguments("Expected options to be an object", .{});
         } else null;
 
         if (JSC.Node.StringOrBuffer.fromJS(globalThis, bun.default_allocator, buffer_value)) |buffer| {
             return .{ buffer, options_val };
         }
 
-        globalThis.throwInvalidArguments("Expected buffer to be a string or buffer", .{});
-        return null;
+        return globalThis.throwInvalidArguments("Expected buffer to be a string or buffer", .{});
     }
 
-    pub fn gzipSync(
-        globalThis: *JSGlobalObject,
-        callframe: *JSC.CallFrame,
-    ) JSValue {
-        const buffer, const options_val = getOptions(globalThis, callframe) orelse return .zero;
+    pub fn gzipSync(globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
+        const buffer, const options_val = try getOptions(globalThis, callframe);
         defer buffer.deinit();
         return gzipOrDeflateSync(globalThis, buffer, options_val, true);
     }
 
-    pub fn inflateSync(
-        globalThis: *JSGlobalObject,
-        callframe: *JSC.CallFrame,
-    ) JSValue {
-        const buffer, const options_val = getOptions(globalThis, callframe) orelse return .zero;
+    pub fn inflateSync(globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
+        const buffer, const options_val = try getOptions(globalThis, callframe);
         defer buffer.deinit();
         return gunzipOrInflateSync(globalThis, buffer, options_val, false);
     }
 
-    pub fn deflateSync(
-        globalThis: *JSGlobalObject,
-        callframe: *JSC.CallFrame,
-    ) JSValue {
-        const buffer, const options_val = getOptions(globalThis, callframe) orelse return .zero;
+    pub fn deflateSync(globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
+        const buffer, const options_val = try getOptions(globalThis, callframe);
         defer buffer.deinit();
         return gzipOrDeflateSync(globalThis, buffer, options_val, false);
     }
 
-    pub fn gunzipSync(
-        globalThis: *JSGlobalObject,
-        callframe: *JSC.CallFrame,
-    ) JSValue {
-        const buffer, const options_val = getOptions(globalThis, callframe) orelse return .zero;
+    pub fn gunzipSync(globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
+        const buffer, const options_val = try getOptions(globalThis, callframe);
         defer buffer.deinit();
         return gunzipOrInflateSync(globalThis, buffer, options_val, true);
     }
 
-    pub fn gunzipOrInflateSync(
-        globalThis: *JSGlobalObject,
-        buffer: JSC.Node.StringOrBuffer,
-        options_val_: ?JSValue,
-        is_gzip: bool,
-    ) JSValue {
+    pub fn gunzipOrInflateSync(globalThis: *JSGlobalObject, buffer: JSC.Node.StringOrBuffer, options_val_: ?JSValue, is_gzip: bool) bun.JSError!JSValue {
         var opts = zlib.Options{
             .gzip = is_gzip,
             .windowBits = if (is_gzip) 31 else -15,
@@ -4776,34 +4371,32 @@ pub const JSZlib = struct {
 
         var library: Library = .zlib;
         if (options_val_) |options_val| {
-            if (options_val.get(globalThis, "windowBits")) |window| {
+            if (try options_val.get(globalThis, "windowBits")) |window| {
                 opts.windowBits = window.coerce(i32, globalThis);
                 library = .zlib;
             }
 
-            if (options_val.get(globalThis, "level")) |level| {
+            if (try options_val.get(globalThis, "level")) |level| {
                 opts.level = level.coerce(i32, globalThis);
             }
 
-            if (options_val.get(globalThis, "memLevel")) |memLevel| {
+            if (try options_val.get(globalThis, "memLevel")) |memLevel| {
                 opts.memLevel = memLevel.coerce(i32, globalThis);
                 library = .zlib;
             }
 
-            if (options_val.get(globalThis, "strategy")) |strategy| {
+            if (try options_val.get(globalThis, "strategy")) |strategy| {
                 opts.strategy = strategy.coerce(i32, globalThis);
                 library = .zlib;
             }
 
-            if (options_val.getOwnTruthy(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;
+                    return globalThis.throwInvalidArguments("Expected library to be a string", .{});
                 }
 
                 library = Library.map.fromJS(globalThis, library_value) orelse {
-                    globalThis.throwInvalidArguments("Expected library to be one of 'zlib' or 'libdeflate'", .{});
-                    return .zero;
+                    return globalThis.throwInvalidArguments("Expected library to be one of 'zlib' or 'libdeflate'", .{});
                 };
             }
         }
@@ -4822,17 +4415,11 @@ pub const JSZlib = struct {
                 const estimated_size: u32 = @bitCast(compressed[compressed.len - 4 ..][0..4].*);
                 // If it's > 256 MB, let's rely on dynamic allocation to minimize the risk of OOM.
                 if (estimated_size > 0 and estimated_size < 256 * 1024 * 1024) {
-                    break :brk std.ArrayListUnmanaged(u8).initCapacity(allocator, @max(estimated_size, 64)) catch {
-                        globalThis.throwOutOfMemory();
-                        return .zero;
-                    };
+                    break :brk try std.ArrayListUnmanaged(u8).initCapacity(allocator, @max(estimated_size, 64));
                 }
             }
 
-            break :brk std.ArrayListUnmanaged(u8).initCapacity(allocator, if (compressed.len > 512) compressed.len else 32) catch {
-                globalThis.throwOutOfMemory();
-                return .zero;
-            };
+            break :brk try std.ArrayListUnmanaged(u8).initCapacity(allocator, if (compressed.len > 512) compressed.len else 32);
         };
 
         switch (library) {
@@ -4843,18 +4430,15 @@ pub const JSZlib = struct {
                 }) catch |err| {
                     list.deinit(allocator);
                     if (err == error.InvalidArgument) {
-                        globalThis.throw("Zlib error: Invalid argument", .{});
-                        return .zero;
+                        return globalThis.throw("Zlib error: Invalid argument", .{});
                     }
 
-                    globalThis.throwError(err, "Zlib error");
-                    return .zero;
+                    return globalThis.throwError(err, "Zlib error") catch return .zero;
                 };
 
                 reader.readAll() catch {
                     defer reader.deinit();
-                    globalThis.throwValue(ZigString.init(reader.errorMessage() orelse "Zlib returned an error").toErrorInstance(globalThis));
-                    return .zero;
+                    return globalThis.throwValue(ZigString.init(reader.errorMessage() orelse "Zlib returned an error").toErrorInstance(globalThis));
                 };
                 reader.list = .{ .items = reader.list.items };
                 reader.list.capacity = reader.list.items.len;
@@ -4866,8 +4450,7 @@ pub const JSZlib = struct {
             .libdeflate => {
                 var decompressor: *bun.libdeflate.Decompressor = bun.libdeflate.Decompressor.alloc() orelse {
                     list.deinit(allocator);
-                    globalThis.throwOutOfMemory();
-                    return .zero;
+                    return globalThis.throwOutOfMemory();
                 };
                 defer decompressor.deinit();
                 while (true) {
@@ -4878,14 +4461,12 @@ pub const JSZlib = struct {
                     if (result.status == .insufficient_space) {
                         if (list.capacity > 1024 * 1024 * 1024) {
                             list.deinit(allocator);
-                            globalThis.throwOutOfMemory();
-                            return .zero;
+                            return globalThis.throwOutOfMemory();
                         }
 
                         list.ensureTotalCapacity(allocator, list.capacity * 2) catch {
                             list.deinit(allocator);
-                            globalThis.throwOutOfMemory();
-                            return .zero;
+                            return globalThis.throwOutOfMemory();
                         };
                         continue;
                     }
@@ -4896,8 +4477,7 @@ pub const JSZlib = struct {
                     }
 
                     list.deinit(allocator);
-                    globalThis.throw("libdeflate returned an error: {s}", .{@tagName(result.status)});
-                    return .zero;
+                    return globalThis.throw("libdeflate returned an error: {s}", .{@tagName(result.status)});
                 }
 
                 var array_buffer = JSC.ArrayBuffer.fromBytes(list.items, .Uint8Array);
@@ -4911,30 +4491,28 @@ 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;
 
         if (options_val_) |options_val| {
-            if (options_val.get(globalThis, "windowBits")) |window| {
+            if (try options_val.get(globalThis, "windowBits")) |window| {
                 windowBits = window.coerce(i32, globalThis);
                 library = .zlib;
             }
 
-            if (options_val.getOwnTruthy(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;
+                    return globalThis.throwInvalidArguments("Expected library to be a string", .{});
                 }
 
                 library = Library.map.fromJS(globalThis, library_value) orelse {
-                    globalThis.throwInvalidArguments("Expected library to be one of 'zlib' or 'libdeflate'", .{});
-                    return .zero;
+                    return globalThis.throwInvalidArguments("Expected library to be one of 'zlib' or 'libdeflate'", .{});
                 };
             }
 
-            if (options_val.get(globalThis, "level")) |level_value| {
+            if (try options_val.get(globalThis, "level")) |level_value| {
                 level = level_value.coerce(i32, globalThis);
                 if (globalThis.hasException()) return .zero;
             }
@@ -4947,13 +4525,10 @@ pub const JSZlib = struct {
 
         switch (library) {
             .zlib => {
-                var list = std.ArrayListUnmanaged(u8).initCapacity(
+                var list = try std.ArrayListUnmanaged(u8).initCapacity(
                     allocator,
                     if (compressed.len > 512) compressed.len else 32,
-                ) catch {
-                    globalThis.throwOutOfMemory();
-                    return .zero;
-                };
+                );
 
                 var reader = zlib.ZlibCompressorArrayList.init(compressed, &list, allocator, .{
                     .windowBits = 15,
@@ -4962,18 +4537,15 @@ pub const JSZlib = struct {
                 }) catch |err| {
                     defer list.deinit(allocator);
                     if (err == error.InvalidArgument) {
-                        globalThis.throw("Zlib error: Invalid argument", .{});
-                        return .zero;
+                        return globalThis.throw("Zlib error: Invalid argument", .{});
                     }
 
-                    globalThis.throwError(err, "Zlib error");
-                    return .zero;
+                    return globalThis.throwError(err, "Zlib error");
                 };
 
                 reader.readAll() catch {
                     defer reader.deinit();
-                    globalThis.throwValue(ZigString.init(reader.errorMessage() orelse "Zlib returned an error").toErrorInstance(globalThis));
-                    return .zero;
+                    return globalThis.throwValue(ZigString.init(reader.errorMessage() orelse "Zlib returned an error").toErrorInstance(globalThis));
                 };
                 reader.list = .{ .items = reader.list.toOwnedSlice(allocator) catch @panic("TODO") };
                 reader.list.capacity = reader.list.items.len;
@@ -4984,20 +4556,16 @@ pub const JSZlib = struct {
             },
             .libdeflate => {
                 var compressor: *bun.libdeflate.Compressor = bun.libdeflate.Compressor.alloc(level orelse 6) orelse {
-                    globalThis.throwOutOfMemory();
-                    return .zero;
+                    return globalThis.throwOutOfMemory();
                 };
                 const encoding: bun.libdeflate.Encoding = if (is_gzip) .gzip else .deflate;
                 defer compressor.deinit();
 
-                var list = std.ArrayListUnmanaged(u8).initCapacity(
+                var list = try std.ArrayListUnmanaged(u8).initCapacity(
                     allocator,
                     // This allocation size is unfortunate, but it's not clear how to avoid it with libdeflate.
                     compressor.maxBytesNeeded(compressed, encoding),
-                ) catch {
-                    globalThis.throwOutOfMemory();
-                    return .zero;
-                };
+                );
 
                 while (true) {
                     const result = compressor.compress(compressed, list.allocatedSlice(), encoding);
@@ -5010,8 +4578,7 @@ pub const JSZlib = struct {
                     }
 
                     list.deinit(allocator);
-                    globalThis.throw("libdeflate error: {s}", .{@tagName(result.status)});
-                    return .zero;
+                    return globalThis.throw("libdeflate error: {s}", .{@tagName(result.status)});
                 }
 
                 var array_buffer = JSC.ArrayBuffer.fromBytes(list.items, .Uint8Array);
@@ -5024,8 +4591,8 @@ pub const JSZlib = struct {
 pub usingnamespace @import("./bun/subprocess.zig");
 
 const InternalTestingAPIs = struct {
-    pub fn BunInternalFunction__syntaxHighlighter(globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
-        const args = callframe.arguments(1);
+    pub fn BunInternalFunction__syntaxHighlighter(globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
+        const args = callframe.arguments_old(1);
         if (args.len < 1) {
             globalThis.throwNotEnoughArguments("code", 1, 0);
         }
@@ -5035,16 +4602,16 @@ const InternalTestingAPIs = struct {
         var buffer = MutableString.initEmpty(bun.default_allocator);
         defer buffer.deinit();
         var writer = buffer.bufferedWriter();
-        var formatter = bun.fmt.fmtJavaScript(code.slice(), true);
-        formatter.limited = false;
+        const formatter = bun.fmt.fmtJavaScript(code.slice(), .{
+            .enable_colors = true,
+            .check_for_unhighlighted_write = false,
+        });
         std.fmt.format(writer.writer(), "{}", .{formatter}) catch |err| {
-            globalThis.throwError(err, "Error formatting code");
-            return .zero;
+            return globalThis.throwError(err, "Error formatting code");
         };
 
         writer.flush() catch |err| {
-            globalThis.throwError(err, "Error formatting code");
-            return .zero;
+            return globalThis.throwError(err, "Error formatting code");
         };
 
         var str = bun.String.createUTF8(buffer.list.items);
diff --git a/src/bun.js/api/FFI.h b/src/bun.js/api/FFI.h
index 6616e5de47..50a7d0bcd3 100644
--- a/src/bun.js/api/FFI.h
+++ b/src/bun.js/api/FFI.h
@@ -60,8 +60,9 @@ typedef enum {
   napi_detachable_arraybuffer_expected,
   napi_would_deadlock // unused
 } napi_status;
-void* NapiHandleScope__push(void* jsGlobalObject, bool detached);
-void NapiHandleScope__pop(void* jsGlobalObject, void* handleScope);
+void* NapiHandleScope__open(void* napi_env, bool detached);
+void NapiHandleScope__close(void* napi_env, void* handleScope);
+extern struct napi_env__ Bun__thisFFIModuleNapiEnv;
 #endif
 
 
diff --git a/src/bun.js/api/JSBundler.zig b/src/bun.js/api/JSBundler.zig
index 7008c23069..663af51664 100644
--- a/src/bun.js/api/JSBundler.zig
+++ b/src/bun.js/api/JSBundler.zig
@@ -44,6 +44,8 @@ const JSLexer = bun.js_lexer;
 const Expr = JSAst.Expr;
 const Index = @import("../../ast/base.zig").Index;
 
+const debug = bun.Output.scoped(.Bundler, false);
+
 pub const JSBundler = struct {
     const OwnedString = bun.MutableString;
 
@@ -60,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,
@@ -70,12 +71,18 @@ pub const JSBundler = struct {
         public_path: OwnedString = OwnedString.initEmpty(bun.default_allocator),
         conditions: bun.StringSet = bun.StringSet.init(bun.default_allocator),
         packages: options.PackagesOption = .bundle,
+        format: options.Format = .esm,
+        bytecode: bool = false,
+        banner: OwnedString = OwnedString.initEmpty(bun.default_allocator),
+        footer: OwnedString = OwnedString.initEmpty(bun.default_allocator),
+        experimental_css: bool = false,
+        css_chunking: bool = false,
+        drop: bun.StringSet = bun.StringSet.init(bun.default_allocator),
+        has_any_on_before_parse: bool = false,
 
         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),
@@ -92,82 +99,40 @@ pub const JSBundler = struct {
             errdefer this.deinit(allocator);
             errdefer if (plugins.*) |plugin| plugin.deinit();
 
+            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 (try enable_css.getTruthy(globalThis, "chunking")) |enable_chunking| {
+                        this.css_chunking = if (enable_chunking.isBoolean()) enable_css.toBoolean() else false;
+                    }
+
+                    break :true true;
+                } else false;
+            }
+
             // Plugins must be resolved first as they are allowed to mutate the config JSValue
             if (try config.getArray(globalThis, "plugins")) |array| {
+                const length = array.getLength(globalThis);
                 var iter = array.arrayIterator(globalThis);
-                while (iter.next()) |plugin| {
+                var onstart_promise_array: JSValue = JSValue.undefined;
+                var i: usize = 0;
+                while (iter.next()) |plugin| : (i += 1) {
                     if (!plugin.isObject()) {
-                        globalThis.throwInvalidArguments("Expected plugin to be an object", .{});
-                        return error.JSError;
-                    }
-                    if (try plugin.getOwnObject(globalThis, "SECRET_SERVER_COMPONENTS_INTERNALS")) |internals| {
-                        if (internals.getOwn(globalThis, "router")) |router_value| {
-                            if (router_value.as(JSC.API.FileSystemRouter) != null) {
-                                this.server_components.router.set(globalThis, router_value);
-                            } else {
-                                globalThis.throwInvalidArguments("Expected router to be a Bun.FileSystemRouter", .{});
-                                return error.JSError;
-                            }
-                        }
-
-                        const directive_object = (try internals.getOwnObject(globalThis, "directive")) orelse {
-                            globalThis.throwInvalidArguments("Expected directive to be an object", .{});
-                            return error.JSError;
-                        };
-
-                        if (try directive_object.getArray(globalThis, "client")) |client_names_array| {
-                            var array_iter = client_names_array.arrayIterator(globalThis);
-                            while (array_iter.next()) |client_name| {
-                                var slice = client_name.toSliceOrNull(globalThis) orelse {
-                                    globalThis.throwInvalidArguments("Expected directive.client to be an array of strings", .{});
-                                    return error.JSError;
-                                };
-                                defer slice.deinit();
-                                try this.server_components.client.append(allocator, try OwnedString.initCopy(allocator, slice.slice()));
-                            }
-                        } else {
-                            globalThis.throwInvalidArguments("Expected directive.client to be an array of strings", .{});
-                            return error.JSError;
-                        }
-
-                        if (try directive_object.getArray(globalThis, "server")) |server_names_array| {
-                            var array_iter = server_names_array.arrayIterator(globalThis);
-                            while (array_iter.next()) |server_name| {
-                                var slice = server_name.toSliceOrNull(globalThis) orelse {
-                                    globalThis.throwInvalidArguments("Expected directive.server to be an array of strings", .{});
-                                    return error.JSError;
-                                };
-                                defer slice.deinit();
-                                try this.server_components.server.append(allocator, try OwnedString.initCopy(allocator, slice.slice()));
-                            }
-                        } else {
-                            globalThis.throwInvalidArguments("Expected directive.server to be an array of strings", .{});
-                            return error.JSError;
-                        }
-
-                        continue;
+                        return globalThis.throwInvalidArguments("Expected plugin to be an object", .{});
                     }
 
-                    // var decl = PluginDeclaration{
-                    //     .name = OwnedString.initEmpty(allocator),
-                    //     .setup = .{},
-                    // };
-                    // defer decl.deinit();
-
-                    if (plugin.getOwnOptional(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.throwInvalidArguments("Expected plugin to have a non-empty name", .{});
                         }
                     } else {
-                        globalThis.throwInvalidArguments("Expected plugin to have a name", .{});
-                        return error.JSError;
+                        return globalThis.throwInvalidArguments("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.throwInvalidArguments("Expected plugin to have a setup() function", .{});
                     };
 
                     var bun_plugins: *Plugin = plugins.* orelse brk: {
@@ -182,40 +147,75 @@ pub const JSBundler = struct {
                         break :brk plugins.*.?;
                     };
 
-                    var plugin_result = bun_plugins.addPlugin(function, config);
+                    const is_last = i == length - 1;
+                    var plugin_result = try bun_plugins.addPlugin(function, config, onstart_promise_array, is_last, false);
 
                     if (!plugin_result.isEmptyOrUndefinedOrNull()) {
                         if (plugin_result.asAnyPromise()) |promise| {
+                            promise.setHandled(globalThis.vm());
                             globalThis.bunVM().waitForPromise(promise);
-                            plugin_result = promise.result(globalThis.vm());
+                            switch (promise.unwrap(globalThis.vm(), .mark_handled)) {
+                                .pending => unreachable,
+                                .fulfilled => |val| {
+                                    plugin_result = val;
+                                },
+                                .rejected => |err| {
+                                    return globalThis.throwValue(err);
+                                },
+                            }
                         }
                     }
 
                     if (plugin_result.toError()) |err| {
-                        globalThis.throwValue(err);
+                        return globalThis.throwValue(err);
+                    } else if (globalThis.hasException()) {
                         return error.JSError;
                     }
+
+                    onstart_promise_array = plugin_result;
                 }
             }
 
-            if (config.getOwnTruthy(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.getBooleanLoose(globalThis, "bytecode")) |bytecode| {
+                this.bytecode = bytecode;
+
+                if (bytecode) {
+                    // Default to CJS for bytecode, since esm doesn't really work yet.
+                    this.format = .cjs;
+                    this.target = .bun;
                 }
             }
 
-            if (try config.getOwnOptionalEnum(globalThis, "target", options.Target)) |target| {
+            if (try config.getOptionalEnum(globalThis, "target", options.Target)) |target| {
                 this.target = target;
+
+                if (target != .bun and this.bytecode) {
+                    return globalThis.throwInvalidArguments("target must be 'bun' when bytecode is true", .{});
+                }
             }
 
             var has_out_dir = false;
-            if (try config.getOwnOptional(globalThis, "outdir", ZigString.Slice)) |slice| {
+            if (try config.getOptional(globalThis, "outdir", ZigString.Slice)) |slice| {
                 defer slice.deinit();
                 try this.outdir.appendSliceExact(slice.slice());
                 has_out_dir = true;
             }
 
-            if (config.getOwnTruthy(globalThis, "sourcemap")) |source_map_js| {
+            if (try config.getOptional(globalThis, "banner", ZigString.Slice)) |slice| {
+                defer slice.deinit();
+                try this.banner.appendSliceExact(slice.slice());
+            }
+
+            if (try config.getOptional(globalThis, "footer", ZigString.Slice)) |slice| {
+                defer slice.deinit();
+                try this.footer.appendSliceExact(slice.slice());
+            }
+
+            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)
@@ -232,104 +232,82 @@ pub const JSBundler = struct {
                 }
             }
 
-            if (try config.getOwnOptionalEnum(globalThis, "packages", options.PackagesOption)) |packages| {
+            if (try config.getOptionalEnum(globalThis, "packages", options.PackagesOption)) |packages| {
                 this.packages = packages;
             }
 
-            if (try config.getOwnOptionalEnum(globalThis, "format", options.Format)) |format| {
-                switch (format) {
-                    .esm => {},
-                    else => {
-                        globalThis.throwInvalidArguments("Formats besides 'esm' are not implemented", .{});
-                        return error.JSError;
-                    },
+            if (try config.getOptionalEnum(globalThis, "format", options.Format)) |format| {
+                this.format = format;
+
+                if (this.bytecode and format != .cjs) {
+                    return globalThis.throwInvalidArguments("format must be 'cjs' when bytecode is true. Eventually we'll add esm support as well.", .{});
                 }
             }
 
-            // if (try config.getOwnOptional(globalThis, "hot", bool)) |hot| {
-            //     this.hot = hot;
-            // }
-
-            if (try config.getOwnOptional(globalThis, "splitting", bool)) |hot| {
+            if (try config.getBooleanLoose(globalThis, "splitting")) |hot| {
                 this.code_splitting = hot;
             }
 
-            if (config.getOwnTruthy(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.getOwnOptional(globalThis, "whitespace", bool)) |whitespace| {
+                } else if (minify.isObject()) {
+                    if (try minify.getBooleanLoose(globalThis, "whitespace")) |whitespace| {
                         this.minify.whitespace = whitespace;
                     }
-                    if (try hot.getOwnOptional(globalThis, "syntax", bool)) |syntax| {
+                    if (try minify.getBooleanLoose(globalThis, "syntax")) |syntax| {
                         this.minify.syntax = syntax;
                     }
-                    if (try hot.getOwnOptional(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.throwInvalidArguments("Expected minify to be a boolean or an object", .{});
                 }
             }
 
             if (try config.getArray(globalThis, "entrypoints") orelse try config.getArray(globalThis, "entryPoints")) |entry_points| {
                 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;
-                    };
+                    var slice = try entry_point.toSliceOrNull(globalThis);
                     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.throwInvalidArguments("Expected entrypoints to be an array of strings", .{});
             }
 
-            if (config.getOwnTruthy(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.getOwnTruthy(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.getOwnTruthy(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;
-                    };
+                    var slice = try conditions_value.toSliceOrNull(globalThis);
                     defer slice.deinit();
                     try this.conditions.insert(slice.slice());
                 } else if (conditions_value.jsType().isArray()) {
                     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;
-                        };
+                        var slice = try entry_point.toSliceOrNull(globalThis);
                         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.throwInvalidArguments("Expected conditions to be an array of strings", .{});
                 }
             }
 
             {
                 const path: ZigString.Slice = brk: {
-                    if (try config.getOwnOptional(globalThis, "root", ZigString.Slice)) |slice| {
+                    if (try config.getOptional(globalThis, "root", ZigString.Slice)) |slice| {
                         break :brk slice;
                     }
 
@@ -345,15 +323,13 @@ pub const JSBundler = struct {
                 defer path.deinit();
 
                 var dir = std.fs.cwd().openDir(path.slice(), .{}) catch |err| {
-                    globalThis.throwPretty("{s}: failed to open root directory: {s}", .{ @errorName(err), path.slice() });
-                    return error.JSError;
+                    return globalThis.throwPretty("{s}: failed to open root directory: {s}", .{ @errorName(err), path.slice() });
                 };
                 defer dir.close();
 
                 var rootdir_buf: bun.PathBuffer = undefined;
                 const rootdir = bun.getFdPath(bun.toFD(dir.fd), &rootdir_buf) catch |err| {
-                    globalThis.throwPretty("{s}: failed to get full root directory path: {s}", .{ @errorName(err), path.slice() });
-                    return error.JSError;
+                    return globalThis.throwPretty("{s}: failed to get full root directory path: {s}", .{ @errorName(err), path.slice() });
                 };
                 try this.rootdir.appendSliceExact(rootdir);
             }
@@ -361,30 +337,36 @@ pub const JSBundler = struct {
             if (try config.getOwnArray(globalThis, "external")) |externals| {
                 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;
-                    };
+                    var slice = try entry_point.toSliceOrNull(globalThis);
                     defer slice.deinit();
                     try this.external.insert(slice.slice());
                 }
             }
 
-            // if (try config.getOwnOptional(globalThis, "dir", ZigString.Slice)) |slice| {
+            if (try config.getOwnArray(globalThis, "drop")) |drops| {
+                var iter = drops.arrayIterator(globalThis);
+                while (iter.next()) |entry| {
+                    var slice = try entry.toSliceOrNull(globalThis);
+                    defer slice.deinit();
+                    try this.drop.insert(slice.slice());
+                }
+            }
+
+            // if (try config.getOptional(globalThis, "dir", ZigString.Slice)) |slice| {
             //     defer slice.deinit();
             //     this.appendSliceExact(slice.slice()) catch unreachable;
             // } else {
             //     this.appendSliceExact(globalThis.bunVM().bundler.fs.top_level_dir) catch unreachable;
             // }
 
-            if (try config.getOwnOptional(globalThis, "publicPath", ZigString.Slice)) |slice| {
+            if (try config.getOptional(globalThis, "publicPath", ZigString.Slice)) |slice| {
                 defer slice.deinit();
                 try this.public_path.appendSliceExact(slice.slice());
             }
 
-            if (config.getOwnTruthy(globalThis, "naming")) |naming| {
+            if (try config.getTruthy(globalThis, "naming")) |naming| {
                 if (naming.isString()) {
-                    if (try config.getOwnOptional(globalThis, "naming", ZigString.Slice)) |slice| {
+                    if (try config.getOptional(globalThis, "naming", ZigString.Slice)) |slice| {
                         defer slice.deinit();
                         if (!strings.hasPrefixComptime(slice.slice(), "./")) {
                             try this.names.owned_entry_point.appendSliceExact("./");
@@ -393,7 +375,7 @@ pub const JSBundler = struct {
                         this.names.entry_point.data = this.names.owned_entry_point.list.items;
                     }
                 } else if (naming.isObject()) {
-                    if (try naming.getOwnOptional(globalThis, "entry", ZigString.Slice)) |slice| {
+                    if (try naming.getOptional(globalThis, "entry", ZigString.Slice)) |slice| {
                         defer slice.deinit();
                         if (!strings.hasPrefixComptime(slice.slice(), "./")) {
                             try this.names.owned_entry_point.appendSliceExact("./");
@@ -402,7 +384,7 @@ pub const JSBundler = struct {
                         this.names.entry_point.data = this.names.owned_entry_point.list.items;
                     }
 
-                    if (try naming.getOwnOptional(globalThis, "chunk", ZigString.Slice)) |slice| {
+                    if (try naming.getOptional(globalThis, "chunk", ZigString.Slice)) |slice| {
                         defer slice.deinit();
                         if (!strings.hasPrefixComptime(slice.slice(), "./")) {
                             try this.names.owned_chunk.appendSliceExact("./");
@@ -411,7 +393,7 @@ pub const JSBundler = struct {
                         this.names.chunk.data = this.names.owned_chunk.list.items;
                     }
 
-                    if (try naming.getOwnOptional(globalThis, "asset", ZigString.Slice)) |slice| {
+                    if (try naming.getOptional(globalThis, "asset", ZigString.Slice)) |slice| {
                         defer slice.deinit();
                         if (!strings.hasPrefixComptime(slice.slice(), "./")) {
                             try this.names.owned_asset.appendSliceExact("./");
@@ -420,15 +402,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.throwInvalidArguments("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.throwInvalidArguments("define must be an object", .{});
                 }
 
                 var define_iter = JSC.JSPropertyIterator(.{
@@ -442,8 +422,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.throwInvalidArguments("define \"{s}\" must be a JSON string", .{prop});
                     }
 
                     var val = JSC.ZigString.init("");
@@ -477,8 +456,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.throwInvalidArguments("loader property names must be file extensions, such as '.txt'", .{});
                     }
 
                     loader_values[loader_iter.i] = try loader_iter.value.toEnumFromMap(
@@ -515,18 +493,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,
@@ -550,7 +516,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);
@@ -563,30 +528,22 @@ pub const JSBundler = struct {
             self.rootdir.deinit();
             self.public_path.deinit();
             self.conditions.deinit();
+            self.drop.deinit();
+            self.banner.deinit();
+            self.footer.deinit();
         }
     };
 
     fn build(
         globalThis: *JSC.JSGlobalObject,
         arguments: []const JSC.JSValue,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         if (arguments.len == 0 or !arguments[0].isObject()) {
-            globalThis.throwInvalidArguments("Expected a config object to be passed to Bun.build", .{});
-            return .undefined;
+            return globalThis.throwInvalidArguments("Expected a config object to be passed to Bun.build", .{});
         }
 
         var plugins: ?*Plugin = null;
-        const config = Config.fromJS(globalThis, arguments[0], &plugins, globalThis.allocator()) catch |err| {
-            switch (err) {
-                error.JSError => {
-                    return .zero;
-                },
-                error.OutOfMemory => {
-                    globalThis.throwOutOfMemory();
-                    return .zero;
-                },
-            }
-        };
+        const config = try Config.fromJS(globalThis, arguments[0], &plugins, globalThis.allocator());
 
         return bun.BundleV2.generateFromJavaScript(
             config,
@@ -594,34 +551,24 @@ pub const JSBundler = struct {
             globalThis,
             globalThis.bunVM().eventLoop(),
             bun.default_allocator,
-        ) catch |err| {
-            switch (err) {
-                error.OutOfMemory => {
-                    globalThis.throwOutOfMemory();
-                    return .zero;
-                },
-            }
-        };
+        );
     }
 
     pub fn buildFn(
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
-        const arguments = callframe.arguments(1);
+    ) bun.JSError!JSC.JSValue {
+        const arguments = callframe.arguments_old(1);
         return build(globalThis, arguments.slice());
     }
 
     pub const Resolve = struct {
+        bv2: *BundleV2,
         import_record: MiniImportRecord,
+        value: Value,
 
-        /// Null means the Resolve is aborted
-        completion: ?*bun.BundleV2.JSBundleCompletionTask = null,
-
-        value: Value = .{ .pending = {} },
-
-        js_task: JSC.AnyTask = undefined,
-        task: JSC.AnyEventLoop.Task = undefined,
+        js_task: JSC.AnyTask,
+        task: JSC.AnyEventLoop.Task,
 
         pub const MiniImportRecord = struct {
             kind: bun.ImportKind,
@@ -633,42 +580,19 @@ pub const JSBundler = struct {
             range: logger.Range = logger.Range.None,
             original_target: Target,
 
-            pub inline fn loader(_: *const MiniImportRecord) ?options.Loader {
-                return null;
-            }
+            // pub inline fn loader(_: *const MiniImportRecord) ?options.Loader {
+            //     return null;
+            // }
         };
 
-        pub fn create(
-            from: union(enum) {
-                MiniImportRecord: MiniImportRecord,
-                ImportRecord: struct {
-                    importer_source_index: u32,
-                    import_record_index: u32,
-                    source_file: []const u8 = "",
-                    original_target: Target,
-                    record: *const bun.ImportRecord,
-                },
-            },
-            completion: *bun.BundleV2.JSBundleCompletionTask,
-        ) Resolve {
-            completion.ref();
+        pub fn init(bv2: *bun.BundleV2, record: MiniImportRecord) Resolve {
+            return .{
+                .bv2 = bv2,
+                .import_record = record,
+                .value = .pending,
 
-            return Resolve{
-                .import_record = switch (from) {
-                    .MiniImportRecord => from.MiniImportRecord,
-                    .ImportRecord => |file| MiniImportRecord{
-                        .kind = file.record.kind,
-                        .source_file = file.source_file,
-                        .namespace = file.record.path.namespace,
-                        .specifier = file.record.path.text,
-                        .importer_source_index = file.importer_source_index,
-                        .import_record_index = file.import_record_index,
-                        .range = file.record.range,
-                        .original_target = file.original_target,
-                    },
-                },
-                .completion = completion,
-                .value = .{ .pending = {} },
+                .task = undefined,
+                .js_task = undefined,
             };
         }
 
@@ -684,9 +608,9 @@ pub const JSBundler = struct {
                     bun.default_allocator.free(this.namespace);
                 }
             },
-            no_match: void,
-            pending: void,
-            consumed: void,
+            no_match,
+            pending,
+            consumed,
 
             pub fn consume(this: *Value) Value {
                 const result = this.*;
@@ -710,32 +634,18 @@ pub const JSBundler = struct {
 
         pub fn deinit(this: *Resolve) void {
             this.value.deinit();
-            if (this.completion) |completion|
-                completion.deref();
             bun.default_allocator.destroy(this);
         }
 
         const AnyTask = JSC.AnyTask.New(@This(), runOnJSThread);
 
         pub fn dispatch(this: *Resolve) void {
-            var completion = this.completion orelse {
-                this.deinit();
-                return;
-            };
-            completion.ref();
-
             this.js_task = AnyTask.init(this);
-            completion.jsc_event_loop.enqueueTaskConcurrent(JSC.ConcurrentTask.create(this.js_task.task()));
+            this.bv2.jsLoopForPlugins().enqueueTaskConcurrent(JSC.ConcurrentTask.create(this.js_task.task()));
         }
 
         pub fn runOnJSThread(this: *Resolve) void {
-            var completion = this.completion orelse {
-                this.deinit();
-                return;
-            };
-
-            completion.plugins.?.matchOnResolve(
-                completion.globalThis,
+            this.bv2.plugins.?.matchOnResolve(
                 this.import_record.specifier,
                 this.import_record.namespace,
                 this.import_record.source_file,
@@ -745,22 +655,19 @@ pub const JSBundler = struct {
         }
 
         export fn JSBundlerPlugin__onResolveAsync(
-            this: *Resolve,
+            resolve: *Resolve,
             _: *anyopaque,
             path_value: JSValue,
             namespace_value: JSValue,
             external_value: JSValue,
         ) void {
-            var completion = this.completion orelse {
-                this.deinit();
-                return;
-            };
             if (path_value.isEmptyOrUndefinedOrNull() or namespace_value.isEmptyOrUndefinedOrNull()) {
-                this.value = .{ .no_match = {} };
+                resolve.value = .{ .no_match = {} };
             } else {
-                const path = path_value.toSliceCloneWithAllocator(completion.globalThis, bun.default_allocator) orelse @panic("Unexpected: path is not a string");
-                const namespace = namespace_value.toSliceCloneWithAllocator(completion.globalThis, bun.default_allocator) orelse @panic("Unexpected: namespace is not a string");
-                this.value = .{
+                const global = resolve.bv2.plugins.?.globalObject();
+                const path = path_value.toSliceCloneWithAllocator(global, bun.default_allocator) orelse @panic("Unexpected: path is not a string");
+                const namespace = namespace_value.toSliceCloneWithAllocator(global, bun.default_allocator) orelse @panic("Unexpected: namespace is not a string");
+                resolve.value = .{
                     .success = .{
                         .path = path.slice(),
                         .namespace = namespace.slice(),
@@ -769,7 +676,7 @@ pub const JSBundler = struct {
                 };
             }
 
-            completion.bundler.onResolveAsync(this);
+            resolve.bv2.onResolveAsync(resolve);
         }
 
         comptime {
@@ -777,49 +684,57 @@ pub const JSBundler = struct {
         }
     };
 
+    const DeferredTask = bun.bundle_v2.DeferredTask;
+
     pub const Load = struct {
+        bv2: *BundleV2,
+
         source_index: Index,
         default_loader: options.Loader,
-        path: []const u8 = "",
-        namespace: []const u8 = "",
-
-        /// Null means the task was aborted.
-        completion: ?*bun.BundleV2.JSBundleCompletionTask = null,
+        path: []const u8,
+        namespace: []const u8,
 
         value: Value,
-        js_task: JSC.AnyTask = undefined,
-        task: JSC.AnyEventLoop.Task = undefined,
-        parse_task: *bun.ParseTask = undefined,
-
+        js_task: JSC.AnyTask,
+        task: JSC.AnyEventLoop.Task,
+        parse_task: *bun.ParseTask,
         /// Faster path: skip the extra threadpool dispatch when the file is not found
-        was_file: bool = false,
+        was_file: bool,
+        /// Defer may only be called once
+        called_defer: bool,
 
-        pub fn create(
-            completion: *bun.BundleV2.JSBundleCompletionTask,
-            source_index: Index,
-            default_loader: options.Loader,
-            path: Fs.Path,
-        ) Load {
-            completion.ref();
-            return Load{
-                .source_index = source_index,
-                .default_loader = default_loader,
-                .completion = completion,
-                .value = .{ .pending = {} },
-                .path = path.text,
-                .namespace = path.namespace,
+        const debug_deferred = bun.Output.scoped(.BUNDLER_DEFERRED, true);
+
+        pub fn init(bv2: *bun.BundleV2, parse: *bun.bundle_v2.ParseTask) Load {
+            return .{
+                .bv2 = bv2,
+                .parse_task = parse,
+                .source_index = parse.source_index,
+                .default_loader = parse.path.loader(&bv2.bundler.options.loaders) orelse .js,
+                .value = .pending,
+                .path = parse.path.text,
+                .namespace = parse.path.namespace,
+                .was_file = false,
+                .called_defer = false,
+                .task = undefined,
+                .js_task = undefined,
             };
         }
 
+        pub fn bakeGraph(load: *const Load) bun.bake.Graph {
+            return load.parse_task.known_target.bakeGraph();
+        }
+
         pub const Value = union(enum) {
             err: logger.Msg,
             success: struct {
                 source_code: []const u8 = "",
-                loader: options.Loader = options.Loader.file,
+                loader: options.Loader = .file,
             },
-            pending: void,
-            no_match: void,
-            consumed: void,
+            pending,
+            no_match,
+            /// The value has been de-initialized or left over from `consume()`
+            consumed,
 
             pub fn deinit(this: *Value) void {
                 switch (this.*) {
@@ -834,6 +749,9 @@ pub const JSBundler = struct {
                 this.* = .{ .consumed = {} };
             }
 
+            /// Moves the value, replacing the original with `.consumed`. It is
+            /// safe to `deinit()` the consumed value, but the memory in `err`
+            /// and `success` must be freed by the caller.
             pub fn consume(this: *Value) Value {
                 const result = this.*;
                 this.* = .{ .consumed = {} };
@@ -842,38 +760,57 @@ pub const JSBundler = struct {
         };
 
         pub fn deinit(this: *Load) void {
+            debug("Deinit Load(0{x}, {s})", .{ @intFromPtr(this), this.path });
             this.value.deinit();
-            if (this.completion) |completion|
-                completion.deref();
         }
 
         const AnyTask = JSC.AnyTask.New(@This(), runOnJSThread);
 
-        pub fn runOnJSThread(this: *Load) void {
-            var completion = this.completion orelse {
-                this.deinit();
-                return;
-            };
-
-            completion.plugins.?.matchOnLoad(
-                completion.globalThis,
-                this.path,
-                this.namespace,
-                this,
-                this.default_loader,
+        pub fn runOnJSThread(load: *Load) void {
+            load.bv2.plugins.?.matchOnLoad(
+                load.path,
+                load.namespace,
+                load,
+                load.default_loader,
+                load.bakeGraph() != .client,
             );
         }
 
         pub fn dispatch(this: *Load) void {
-            var completion = this.completion orelse {
-                this.deinit();
-                return;
-            };
-            completion.ref();
-
             this.js_task = AnyTask.init(this);
             const concurrent_task = JSC.ConcurrentTask.createFrom(&this.js_task);
-            completion.jsc_event_loop.enqueueTaskConcurrent(concurrent_task);
+            this.bv2.jsLoopForPlugins().enqueueTaskConcurrent(concurrent_task);
+        }
+
+        export fn JSBundlerPlugin__onDefer(load: *Load, global: *JSC.JSGlobalObject) JSValue {
+            return JSC.toJSHostValue(global, load.onDefer(global));
+        }
+        fn onDefer(this: *Load, globalObject: *JSC.JSGlobalObject) bun.JSError!JSValue {
+            if (this.called_defer) {
+                return globalObject.throw("Can't call .defer() more than once within an onLoad plugin", .{});
+            }
+            this.called_defer = true;
+
+            debug_deferred("JSBundlerPlugin__onDefer(0x{x}, {s})", .{ @intFromPtr(this), this.path });
+
+            // Notify the bundler thread about the deferral. This will decrement
+            // the pending item counter and increment the deferred counter.
+            switch (this.parse_task.ctx.loop().*) {
+                .js => |jsc_event_loop| {
+                    jsc_event_loop.enqueueTaskConcurrent(JSC.ConcurrentTask.fromCallback(this.parse_task.ctx, BundleV2.onNotifyDefer));
+                },
+                .mini => |*mini| {
+                    mini.enqueueTaskConcurrentWithExtraCtx(
+                        Load,
+                        BundleV2,
+                        this,
+                        BundleV2.onNotifyDeferMini,
+                        .task,
+                    );
+                },
+            }
+
+            return this.bv2.plugins.?.appendDeferPromise();
         }
 
         export fn JSBundlerPlugin__onLoadAsync(
@@ -883,32 +820,29 @@ pub const JSBundler = struct {
             loader_as_int: JSValue,
         ) void {
             JSC.markBinding(@src());
-            var completion = this.completion orelse {
-                this.deinit();
-                return;
-            };
             if (source_code_value.isEmptyOrUndefinedOrNull() or loader_as_int.isEmptyOrUndefinedOrNull()) {
                 this.value = .{ .no_match = {} };
 
                 if (this.was_file) {
                     // Faster path: skip the extra threadpool dispatch
-                    completion.bundler.graph.pool.pool.schedule(bun.ThreadPool.Batch.from(&this.parse_task.task));
+                    this.bv2.graph.pool.pool.schedule(bun.ThreadPool.Batch.from(&this.parse_task.task));
                     this.deinit();
                     return;
                 }
             } else {
-                const source_code = JSC.Node.StringOrBuffer.fromJSToOwnedSlice(completion.globalThis, source_code_value, bun.default_allocator) catch
+                const loader: Api.Loader = @enumFromInt(loader_as_int.to(u8));
+                const source_code = JSC.Node.StringOrBuffer.fromJSToOwnedSlice(this.bv2.plugins.?.globalObject(), source_code_value, bun.default_allocator) catch
                 // TODO:
                     @panic("Unexpected: source_code is not a string");
                 this.value = .{
                     .success = .{
-                        .loader = @as(options.Loader, @enumFromInt(@as(u8, @intCast(loader_as_int.to(i32))))),
+                        .loader = options.Loader.fromAPI(loader),
                         .source_code = source_code,
                     },
                 };
             }
 
-            completion.bundler.onLoadAsync(this);
+            this.bv2.onLoadAsync(this);
         }
 
         comptime {
@@ -918,14 +852,41 @@ pub const JSBundler = struct {
 
     pub const Plugin = opaque {
         extern fn JSBundlerPlugin__create(*JSC.JSGlobalObject, JSC.JSGlobalObject.BunPluginTarget) *Plugin;
-        pub fn create(globalObject: *JSC.JSGlobalObject, target: JSC.JSGlobalObject.BunPluginTarget) *Plugin {
+        pub fn create(global: *JSC.JSGlobalObject, target: JSC.JSGlobalObject.BunPluginTarget) *Plugin {
             JSC.markBinding(@src());
-            const plugin = JSBundlerPlugin__create(globalObject, target);
+            const plugin = JSBundlerPlugin__create(global, target);
             JSC.JSValue.fromCell(plugin).protect();
             return plugin;
         }
 
-        extern fn JSBundlerPlugin__tombestone(*Plugin) void;
+        extern fn JSBundlerPlugin__callOnBeforeParsePlugins(
+            *Plugin,
+            bun_context: *anyopaque,
+            namespace: *const String,
+            path: *const String,
+            on_before_parse_args: ?*anyopaque,
+            on_before_parse_result: ?*anyopaque,
+            should_continue: *i32,
+        ) i32;
+
+        pub fn callOnBeforeParsePlugins(this: *Plugin, ctx: *anyopaque, namespace: *const String, path: *const String, on_before_parse_args: ?*anyopaque, on_before_parse_result: ?*anyopaque, should_continue: *i32) i32 {
+            return JSBundlerPlugin__callOnBeforeParsePlugins(this, ctx, namespace, path, on_before_parse_args, on_before_parse_result, should_continue);
+        }
+
+        extern fn JSBundlerPlugin__hasOnBeforeParsePlugins(*Plugin) i32;
+        pub fn hasOnBeforeParsePlugins(this: *Plugin) bool {
+            return JSBundlerPlugin__hasOnBeforeParsePlugins(this) != 0;
+        }
+
+        extern fn JSBundlerPlugin__tombstone(*Plugin) void;
+        pub fn deinit(this: *Plugin) void {
+            JSC.markBinding(@src());
+            JSBundlerPlugin__tombstone(this);
+            JSC.JSValue.fromCell(this).unprotect();
+        }
+
+        extern fn JSBundlerPlugin__globalObject(*Plugin) *JSC.JSGlobalObject;
+        pub const globalObject = JSBundlerPlugin__globalObject;
 
         extern fn JSBundlerPlugin__anyMatches(
             *Plugin,
@@ -935,16 +896,15 @@ pub const JSBundler = struct {
         ) bool;
 
         extern fn JSBundlerPlugin__matchOnLoad(
-            *JSC.JSGlobalObject,
             *Plugin,
             namespaceString: *const String,
             path: *const String,
             context: *anyopaque,
             u8,
+            bool,
         ) void;
 
         extern fn JSBundlerPlugin__matchOnResolve(
-            *JSC.JSGlobalObject,
             *Plugin,
             namespaceString: *const String,
             path: *const String,
@@ -953,6 +913,10 @@ pub const JSBundler = struct {
             u8,
         ) void;
 
+        extern fn JSBundlerPlugin__drainDeferred(*Plugin, rejected: bool) void;
+        extern fn JSBundlerPlugin__appendDeferPromise(*Plugin) JSValue;
+        pub const appendDeferPromise = JSBundlerPlugin__appendDeferPromise;
+
         pub fn hasAnyMatches(
             this: *Plugin,
             path: *const Fs.Path,
@@ -974,15 +938,16 @@ pub const JSBundler = struct {
 
         pub fn matchOnLoad(
             this: *Plugin,
-            globalThis: *JSC.JSGlobalObject,
             path: []const u8,
             namespace: []const u8,
             context: *anyopaque,
             default_loader: options.Loader,
+            is_server_side: bool,
         ) void {
             JSC.markBinding(@src());
             const tracer = bun.tracy.traceNamed(@src(), "JSBundler.matchOnLoad");
             defer tracer.end();
+            debug("JSBundler.matchOnLoad(0x{x}, {s}, {s})", .{ @intFromPtr(this), namespace, path });
             const namespace_string = if (namespace.len == 0)
                 bun.String.static("file")
             else
@@ -990,12 +955,11 @@ pub const JSBundler = struct {
             const path_string = bun.String.createUTF8(path);
             defer namespace_string.deref();
             defer path_string.deref();
-            JSBundlerPlugin__matchOnLoad(globalThis, this, &namespace_string, &path_string, context, @intFromEnum(default_loader));
+            JSBundlerPlugin__matchOnLoad(this, &namespace_string, &path_string, context, @intFromEnum(default_loader), is_server_side);
         }
 
         pub fn matchOnResolve(
             this: *Plugin,
-            globalThis: *JSC.JSGlobalObject,
             path: []const u8,
             namespace: []const u8,
             importer: []const u8,
@@ -1014,24 +978,32 @@ pub const JSBundler = struct {
             defer namespace_string.deref();
             defer path_string.deref();
             defer importer_string.deref();
-            JSBundlerPlugin__matchOnResolve(globalThis, this, &namespace_string, &path_string, &importer_string, context, @intFromEnum(import_record_kind));
+            JSBundlerPlugin__matchOnResolve(this, &namespace_string, &path_string, &importer_string, context, @intFromEnum(import_record_kind));
         }
 
         pub fn addPlugin(
             this: *Plugin,
             object: JSC.JSValue,
             config: JSC.JSValue,
-        ) JSValue {
+            onstart_promises_array: JSC.JSValue,
+            is_last: bool,
+            is_bake: bool,
+        ) !JSValue {
             JSC.markBinding(@src());
             const tracer = bun.tracy.traceNamed(@src(), "JSBundler.addPlugin");
             defer tracer.end();
-            return JSBundlerPlugin__runSetupFunction(this, object, config);
+            return JSBundlerPlugin__runSetupFunction(
+                this,
+                object,
+                config,
+                onstart_promises_array,
+                JSValue.jsBoolean(is_last),
+                JSValue.jsBoolean(is_bake),
+            ).unwrap();
         }
 
-        pub fn deinit(this: *Plugin) void {
-            JSC.markBinding(@src());
-            JSBundlerPlugin__tombestone(this);
-            JSC.JSValue.fromCell(this).unprotect();
+        pub fn drainDeferred(this: *Plugin, rejected: bool) void {
+            JSBundlerPlugin__drainDeferred(this, rejected);
         }
 
         pub fn setConfig(this: *Plugin, config: *anyopaque) void {
@@ -1045,30 +1017,41 @@ pub const JSBundler = struct {
             *Plugin,
             JSC.JSValue,
             JSC.JSValue,
-        ) JSValue;
+            JSC.JSValue,
+            JSC.JSValue,
+            JSC.JSValue,
+        ) JSValue.MaybeException;
 
         pub export fn JSBundlerPlugin__addError(
             ctx: *anyopaque,
-            _: *Plugin,
+            plugin: *Plugin,
             exception: JSValue,
             which: JSValue,
         ) void {
             switch (which.to(i32)) {
                 0 => {
-                    var this: *JSBundler.Resolve = bun.cast(*Resolve, ctx);
-                    var completion = this.completion orelse return;
-                    this.value = .{
-                        .err = logger.Msg.fromJS(bun.default_allocator, completion.globalThis, this.import_record.source_file, exception) catch @panic("Out of memory in addError callback"),
+                    const resolve: *JSBundler.Resolve = bun.cast(*Resolve, ctx);
+                    resolve.value = .{
+                        .err = logger.Msg.fromJS(
+                            bun.default_allocator,
+                            plugin.globalObject(),
+                            resolve.import_record.source_file,
+                            exception,
+                        ) catch bun.outOfMemory(),
                     };
-                    completion.bundler.onResolveAsync(this);
+                    resolve.bv2.onResolveAsync(resolve);
                 },
                 1 => {
-                    var this: *Load = bun.cast(*Load, ctx);
-                    var completion = this.completion orelse return;
-                    this.value = .{
-                        .err = logger.Msg.fromJS(bun.default_allocator, completion.globalThis, this.path, exception) catch @panic("Out of memory in addError callback"),
+                    const load: *Load = bun.cast(*Load, ctx);
+                    load.value = .{
+                        .err = logger.Msg.fromJS(
+                            bun.default_allocator,
+                            plugin.globalObject(),
+                            load.path,
+                            exception,
+                        ) catch bun.outOfMemory(),
                     };
-                    completion.bundler.onLoadAsync(this);
+                    load.bv2.onLoadAsync(load);
                 },
                 else => @panic("invalid error type"),
             }
@@ -1091,10 +1074,12 @@ pub const BuildArtifact = struct {
         chunk,
         asset,
         @"entry-point",
-        @"component-manifest",
-        @"use client",
-        @"use server",
         sourcemap,
+        bytecode,
+
+        pub fn isFileInStandaloneMode(this: OutputKind) bool {
+            return this != .sourcemap and this != .bytecode;
+        }
     };
 
     pub fn deinit(this: *BuildArtifact) void {
@@ -1108,7 +1093,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 });
     }
 
@@ -1116,21 +1101,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(
@@ -1144,7 +1129,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,
@@ -1171,7 +1156,7 @@ pub const BuildArtifact = struct {
         globalThis: *JSC.JSGlobalObject,
     ) JSValue {
         var buf: [512]u8 = undefined;
-        const out = std.fmt.bufPrint(&buf, "{any}", .{options.PathTemplate.hashFormatter(this.hash)}) catch @panic("Unexpected");
+        const out = std.fmt.bufPrint(&buf, "{any}", .{bun.fmt.truncatedHash32(this.hash)}) catch @panic("Unexpected");
         return ZigString.init(out).toJS(globalThis);
     }
 
@@ -1255,7 +1240,7 @@ pub const BuildArtifact = struct {
                         "<r>hash<r>: <green>\"{any}\"<r>",
                         enable_ansi_colors,
                     ),
-                    .{options.PathTemplate.hashFormatter(this.hash)},
+                    .{bun.fmt.truncatedHash32(this.hash)},
                 );
             }
 
@@ -1306,3 +1291,4 @@ pub const BuildArtifact = struct {
 };
 
 const Output = bun.Output;
+const BundleV2 = bun.bundle_v2.BundleV2;
diff --git a/src/bun.js/api/JSTranspiler.zig b/src/bun.js/api/JSTranspiler.zig
index 2182ed6ccc..e13490d497 100644
--- a/src/bun.js/api/JSTranspiler.zig
+++ b/src/bun.js/api/JSTranspiler.zig
@@ -55,7 +55,6 @@ const default_transform_options: Api.TransformOptions = brk: {
     var opts = std.mem.zeroes(Api.TransformOptions);
     opts.disable_hmr = true;
     opts.target = Api.Target.browser;
-    opts.serve = false;
     break :brk opts;
 };
 
@@ -311,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) };
@@ -326,19 +325,17 @@ fn transformOptionsFromJSC(globalObject: JSC.C.JSContextRef, temp_allocator: std
     };
 
     if (!object.isObject()) {
-        JSC.throwInvalidArguments("Expected an object", .{}, globalObject, exception);
-        return transpiler;
+        return globalObject.throwInvalidArguments("Expected an object", .{});
     }
 
-    if (object.getOwnTruthy(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;
+                return globalObject.throwInvalidArguments("define must be an object", .{});
             }
 
             var define_iter = JSC.JSPropertyIterator(.{
@@ -359,8 +356,7 @@ 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;
+                    return globalObject.throwInvalidArguments("define \"{s}\" must be a JSON string", .{prop});
                 }
 
                 names[define_iter.i] = prop.toOwnedSlice(allocator) catch unreachable;
@@ -379,7 +375,7 @@ fn transformOptionsFromJSC(globalObject: JSC.C.JSContextRef, temp_allocator: std
         }
     }
 
-    if (object.getOwn(globalThis, "external")) |external| {
+    if (try object.get(globalThis, "external")) |external| {
         external: {
             if (external.isUndefinedOrNull()) break :external;
 
@@ -400,8 +396,7 @@ 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;
+                        return globalObject.throwInvalidArguments("external must be a string or string[]", .{});
                     }
 
                     var zig_str = JSC.ZigString.init("");
@@ -413,38 +408,28 @@ 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;
+                return globalObject.throwInvalidArguments("external must be a string or string[]", .{});
             }
         }
     }
 
-    if (object.getOwn(globalThis, "loader")) |loader| {
-        if (Loader.fromJS(globalThis, loader, exception)) |resolved| {
+    if (try object.get(globalThis, "loader")) |loader| {
+        if (try Loader.fromJS(globalThis, loader)) |resolved| {
             if (!resolved.isJavaScriptLike()) {
-                JSC.throwInvalidArguments("only JavaScript-like loaders supported for now", .{}, globalObject, exception);
-                return transpiler;
+                return globalObject.throwInvalidArguments("only JavaScript-like loaders supported for now", .{});
             }
 
             transpiler.default_loader = resolved;
         }
-
-        if (exception.* != null) {
-            return transpiler;
-        }
     }
 
-    if (object.getOwn(globalThis, "target")) |target| {
-        if (Target.fromJS(globalThis, target, exception)) |resolved| {
+    if (try object.get(globalThis, "target")) |target| {
+        if (try Target.fromJS(globalThis, target)) |resolved| {
             transpiler.transform.target = resolved.toAPI();
         }
-
-        if (exception.* != null) {
-            return transpiler;
-        }
     }
 
-    if (object.getOwn(globalThis, "tsconfig")) |tsconfig| {
+    if (try object.get(globalThis, "tsconfig")) |tsconfig| {
         tsconfig: {
             if (tsconfig.isUndefinedOrNull()) break :tsconfig;
             const kind = tsconfig.jsType();
@@ -452,8 +437,7 @@ 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;
+                return globalObject.throwInvalidArguments("tsconfig must be a string or object", .{});
             }
 
             if (!kind.isStringLike()) {
@@ -483,7 +467,7 @@ fn transformOptionsFromJSC(globalObject: JSC.C.JSContextRef, temp_allocator: std
         else => false,
     };
 
-    if (object.getOwnTruthy(globalThis, "macro")) |macros| {
+    if (try object.getTruthy(globalThis, "macro")) |macros| {
         macros: {
             if (macros.isUndefinedOrNull()) break :macros;
             if (macros.isBoolean()) {
@@ -493,8 +477,7 @@ 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;
+                return globalObject.throwInvalidArguments("macro must be an object", .{});
             }
 
             var out = bun.String.empty;
@@ -518,48 +501,47 @@ fn transformOptionsFromJSC(globalObject: JSC.C.JSContextRef, temp_allocator: std
         }
     }
 
-    if (object.getOwnOptional(globalThis, "autoImportJSX", bool) catch return transpiler) |flag| {
+    if (try object.getBooleanLoose(globalThis, "autoImportJSX")) |flag| {
         transpiler.runtime.auto_import_jsx = flag;
     }
 
-    if (object.getOwnOptional(globalThis, "allowBunRuntime", bool) catch return transpiler) |flag| {
+    if (try object.getBooleanLoose(globalThis, "allowBunRuntime")) |flag| {
         transpiler.runtime.allow_runtime = flag;
     }
 
-    if (object.getOwnOptional(globalThis, "inline", bool) catch return transpiler) |flag| {
+    if (try object.getBooleanLoose(globalThis, "inline")) |flag| {
         transpiler.runtime.inlining = flag;
     }
 
-    if (object.getOwnOptional(globalThis, "minifyWhitespace", bool) catch return transpiler) |flag| {
+    if (try object.getBooleanLoose(globalThis, "minifyWhitespace")) |flag| {
         transpiler.minify_whitespace = flag;
     }
 
-    if (object.getOwnOptional(globalThis, "deadCodeElimination", bool) catch return transpiler) |flag| {
+    if (try object.getBooleanLoose(globalThis, "deadCodeElimination")) |flag| {
         transpiler.dead_code_elimination = flag;
     }
 
-    if (object.getOwnTruthy(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.getOwnOptional(globalThis, "whitespace", bool)) |whitespace| {
+        } else if (minify.isObject()) {
+            if (try minify.getBooleanLoose(globalThis, "whitespace")) |whitespace| {
                 transpiler.minify_whitespace = whitespace;
             }
-            if (try hot.getOwnOptional(globalThis, "syntax", bool)) |syntax| {
+            if (try minify.getBooleanLoose(globalThis, "syntax")) |syntax| {
                 transpiler.minify_syntax = syntax;
             }
-            if (try hot.getOwnOptional(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;
+            return globalObject.throwInvalidArguments("Expected minify to be a boolean or an object", .{});
         }
     }
 
-    if (object.getOwn(globalThis, "sourcemap")) |flag| {
+    if (try object.get(globalThis, "sourcemap")) |flag| {
         if (flag.isBoolean() or flag.isUndefinedOrNull()) {
             if (flag.toBoolean()) {
                 transpiler.transform.source_map = .@"inline";
@@ -570,39 +552,36 @@ 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;
+                return globalObject.throwInvalidArguments("sourcemap must be one of \"inline\", \"linked\", \"external\", or \"none\"", .{});
             }
         }
     }
 
-    if (try object.getOwnOptionalEnum(globalThis, "packages", options.PackagesOption)) |packages| {
+    if (try object.getOptionalEnum(globalThis, "packages", options.PackagesOption)) |packages| {
         transpiler.transform.packages = packages.toAPI();
     }
 
     var tree_shaking: ?bool = null;
-    if (object.getOwnOptional(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.getOwnOptional(globalThis, "trimUnusedImports", bool) catch return transpiler) |trimUnusedImports| {
+    if (try object.getBooleanLoose(globalThis, "trimUnusedImports")) |trimUnusedImports| {
         trim_unused_imports = trimUnusedImports;
     }
 
-    if (object.getOwnTruthy(globalThis, "exports")) |exports| {
+    if (try object.getTruthy(globalThis, "exports")) |exports| {
         if (!exports.isObject()) {
-            JSC.throwInvalidArguments("exports must be an object", .{}, globalObject, exception);
-            return transpiler;
+            return globalObject.throwInvalidArguments("exports must be an object", .{});
         }
 
         var replacements = Runtime.Features.ReplaceableExport.Map{};
         errdefer replacements.clearAndFree(bun.default_allocator);
 
-        if (exports.getOwnTruthy(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;
+                return globalObject.throwInvalidArguments("exports.eliminate must be an array", .{});
             }
 
             var total_name_buf_len: u32 = 0;
@@ -629,8 +608,7 @@ 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;
+                            return globalObject.throwInvalidArguments("Error reading exports.eliminate. TODO: utf-16", .{});
                         };
                         buf.items.len += name.len;
                         if (name.len > 0) {
@@ -641,10 +619,9 @@ fn transformOptionsFromJSC(globalObject: JSC.C.JSContextRef, temp_allocator: std
             }
         }
 
-        if (exports.getOwnTruthy(globalThis, "replace")) |replace| {
+        if (try exports.getTruthy(globalThis, "replace")) |replace| {
             if (!replace.isObject()) {
-                JSC.throwInvalidArguments("replace must be an object", .{}, globalObject, exception);
-                return transpiler;
+                return globalObject.throwInvalidArguments("replace must be an object", .{});
             }
 
             var iter = JSC.JSPropertyIterator(.{
@@ -658,7 +635,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));
@@ -668,14 +645,13 @@ 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);
                         bun.default_allocator.free(key);
-                        return transpiler;
+                        return globalObject.throwInvalidArguments("\"{s}\" is not a valid ECMAScript identifier", .{key});
                     }
 
                     const entry = replacements.getOrPutAssumeCapacity(key);
@@ -693,9 +669,8 @@ 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);
                                 slice.deinit();
-                                return transpiler;
+                                return globalObject.throwInvalidArguments("\"{s}\" is not a valid ECMAScript identifier", .{replacement_name});
                             }
 
                             entry.value_ptr.* = .{
@@ -708,8 +683,7 @@ 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;
+                    return globalObject.throwInvalidArguments("exports.replace values can only be string, null, undefined, number or boolean", .{});
                 }
             }
         }
@@ -718,12 +692,11 @@ fn transformOptionsFromJSC(globalObject: JSC.C.JSContextRef, temp_allocator: std
         transpiler.runtime.replace_exports = replacements;
     }
 
-    if (object.getOwnTruthy(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;
+            return globalObject.throwInvalidArguments("logLevel must be one of \"verbose\", \"debug\", \"info\", \"warn\", or \"error\"", .{});
         }
     }
 
@@ -733,44 +706,31 @@ 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);
+    const arguments = callframe.arguments_old(3);
     var args = JSC.Node.ArgumentsSlice.init(
         globalThis.bunVM(),
         arguments.slice(),
     );
 
     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.throwValue(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,
@@ -779,30 +739,19 @@ 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.throwValue(log.toJS(globalThis, allocator, "Failed to create transpiler"));
         }
 
-        globalThis.throwError(err, "Error creating transpiler");
-        return null;
+        return globalThis.throwError(err, "Error creating transpiler");
     };
     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.throwValue(log.toJS(globalThis, allocator, "Failed to load define"));
         }
-
-        globalThis.throwError(err, "Failed to load define");
-        return null;
+        return globalThis.throwError(err, "Failed to load define");
     };
 
     if (transpiler_options.macro_map.count() > 0) {
@@ -827,10 +776,9 @@ pub fn constructor(
     bundler.options.auto_import_jsx = transpiler_options.runtime.auto_import_jsx;
     bundler.options.inlining = transpiler_options.runtime.inlining;
     bundler.options.hot_module_reloading = transpiler_options.runtime.hot_module_reloading;
-    bundler.options.jsx.supports_fast_refresh = bundler.options.hot_module_reloading and
-        bundler.options.allow_runtime and transpiler_options.runtime.react_fast_refresh;
+    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,
@@ -841,11 +789,9 @@ pub fn constructor(
     return transpiler;
 }
 
-pub fn finalize(
-    this: *Transpiler,
-) callconv(.C) void {
+pub fn finalize(this: *Transpiler) callconv(.C) void {
     this.bundler.log.deinit();
-    this.scan_pass_result.named_imports.deinit();
+    this.scan_pass_result.named_imports.deinit(this.scan_pass_result.import_records.allocator);
     this.scan_pass_result.import_records.deinit();
     this.scan_pass_result.used_symbols.deinit();
     if (this.buffer_writer != null) {
@@ -881,56 +827,35 @@ fn getParseResult(this: *Transpiler, allocator: std.mem.Allocator, code: []const
         // .allocator = this.
     };
 
-    var parse_result = this.bundler.parse(parse_options, null);
-
-    // necessary because we don't run the linker
-    if (parse_result) |*res| {
-        for (res.ast.import_records.slice()) |*import| {
-            if (import.kind.isCommonJS()) {
-                import.do_commonjs_transform_in_printer = true;
-                import.module_id = @as(u32, @truncate(bun.hash(import.path.pretty)));
-            }
-        }
-    }
-
-    return parse_result;
+    return this.bundler.parse(parse_options, null);
 }
 
-pub fn scan(
-    this: *Transpiler,
-    globalThis: *JSC.JSGlobalObject,
-    callframe: *JSC.CallFrame,
-) JSC.JSValue {
+pub fn scan(this: *Transpiler, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     JSC.markBinding(@src());
-    const arguments = callframe.arguments(3);
+    const arguments = callframe.arguments_old(3);
     var args = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments.slice());
     defer args.deinit();
     const code_arg = args.next() orelse {
-        globalThis.throwInvalidArgumentType("scan", "code", "string or Uint8Array");
-        return .zero;
+        return globalThis.throwInvalidArgumentType("scan", "code", "string or Uint8Array");
     };
 
     const code_holder = JSC.Node.StringOrBuffer.fromJS(globalThis, args.arena.allocator(), code_arg) orelse {
-        globalThis.throwInvalidArgumentType("scan", "code", "string or Uint8Array");
-        return .zero;
+        return globalThis.throwInvalidArgumentType("scan", "code", "string or Uint8Array");
     };
     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;
     }
 
@@ -953,17 +878,14 @@ pub fn scan(
 
     var parse_result = getParseResult(this, arena.allocator(), code, loader, Bundler.MacroJSValueType.zero) orelse {
         if ((this.bundler.log.warnings + this.bundler.log.errors) > 0) {
-            globalThis.throwValue(this.bundler.log.toJS(globalThis, globalThis.allocator(), "Parse error"));
-            return .zero;
+            return globalThis.throwValue(this.bundler.log.toJS(globalThis, globalThis.allocator(), "Parse error"));
         }
 
-        globalThis.throw("Failed to parse", .{});
-        return .zero;
+        return globalThis.throw("Failed to parse", .{});
     };
 
     if ((this.bundler.log.warnings + this.bundler.log.errors) > 0) {
-        globalThis.throwValue(this.bundler.log.toJS(globalThis, globalThis.allocator(), "Parse error"));
-        return .zero;
+        return globalThis.throwValue(this.bundler.log.toJS(globalThis, globalThis.allocator(), "Parse error"));
     }
 
     const exports_label = JSC.ZigString.static("exports");
@@ -971,12 +893,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,
@@ -985,52 +902,30 @@ 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 {
+pub fn transform(this: *Transpiler, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) 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);
+    const arguments = callframe.arguments_old(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 globalThis.throwInvalidArgumentType("transform", "code", "string or Uint8Array");
     };
 
-    var code = JSC.Node.StringOrBuffer.fromJSWithEncodingMaybeAsync(globalThis, bun.default_allocator, code_arg, .utf8, true) orelse {
-        globalThis.throwInvalidArgumentType("transform", "code", "string or Uint8Array");
-        return .zero;
+    var code = try JSC.Node.StringOrBuffer.fromJSWithEncodingMaybeAsync(globalThis, bun.default_allocator, code_arg, .utf8, true) orelse {
+        return globalThis.throwInvalidArgumentType("transform", "code", "string or Uint8Array");
     };
+    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();
     }
@@ -1044,7 +939,7 @@ pub fn transform(
             code_arg.unprotect();
         }
         globalThis.throwOutOfMemory();
-        return .zero;
+        return error.JSError;
     };
     task.schedule();
     return task.promise.value();
@@ -1054,24 +949,20 @@ 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);
+    const arguments = callframe.arguments_old(3);
 
     var args = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments.slice());
     defer args.arena.deinit();
     const code_arg = args.next() orelse {
-        globalThis.throwInvalidArgumentType("transformSync", "code", "string or Uint8Array");
-        return .zero;
+        return globalThis.throwInvalidArgumentType("transformSync", "code", "string or Uint8Array");
     };
 
     var arena = Mimalloc.Arena.init() catch unreachable;
     defer arena.deinit();
     const code_holder = JSC.Node.StringOrBuffer.fromJS(globalThis, arena.allocator(), code_arg) orelse {
-        globalThis.throwInvalidArgumentType("transformSync", "code", "string or Uint8Array");
-        return .zero;
+        return globalThis.throwInvalidArgumentType("transformSync", "code", "string or Uint8Array");
     };
     defer code_holder.deinit();
     const code = code_holder.slice();
@@ -1084,7 +975,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()) {
@@ -1100,25 +991,19 @@ pub fn transformSync(
         if (arg.isObject()) {
             js_ctx_value = arg;
         } else {
-            globalThis.throwInvalidArgumentType("transformSync", "context", "object or loader");
-            return .zero;
+            return globalThis.throwInvalidArgumentType("transformSync", "context", "object or loader");
         }
     }
-    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 {
@@ -1144,23 +1029,19 @@ pub fn transformSync(
         if (comptime JSC.is_bindgen) Bundler.MacroJSValueType.zero else js_ctx_value,
     ) orelse {
         if ((this.bundler.log.warnings + this.bundler.log.errors) > 0) {
-            globalThis.throwValue(this.bundler.log.toJS(globalThis, globalThis.allocator(), "Parse error"));
-            return .zero;
+            return globalThis.throwValue(this.bundler.log.toJS(globalThis, globalThis.allocator(), "Parse error"));
         }
 
-        globalThis.throw("Failed to parse code", .{});
-        return .zero;
+        return globalThis.throw("Failed to parse code", .{});
     };
 
     if ((this.bundler.log.warnings + this.bundler.log.errors) > 0) {
-        globalThis.throwValue(this.bundler.log.toJS(globalThis, globalThis.allocator(), "Parse error"));
-        return .zero;
+        return globalThis.throwValue(this.bundler.log.toJS(globalThis, globalThis.allocator(), "Parse error"));
     }
 
     var buffer_writer = this.buffer_writer orelse brk: {
         var writer = JSPrinter.BufferWriter.init(arena.backingAllocator()) catch {
-            globalThis.throw("Failed to create BufferWriter", .{});
-            return .zero;
+            return globalThis.throw("Failed to create BufferWriter", .{});
         };
 
         writer.buffer.growIfNeeded(code.len) catch unreachable;
@@ -1175,8 +1056,7 @@ pub fn transformSync(
     buffer_writer.reset();
     var printer = JSPrinter.BufferPrinter.init(buffer_writer);
     _ = this.bundler.print(parse_result, @TypeOf(&printer), &printer, .esm_ascii) catch |err| {
-        globalThis.throwError(err, "Failed to print code");
-        return .zero;
+        return globalThis.throwError(err, "Failed to print code");
     };
 
     // TODO: benchmark if pooling this way is faster or moving is faster
@@ -1215,7 +1095,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");
@@ -1235,29 +1114,19 @@ fn namedImportsToJS(
     return array;
 }
 
-pub fn scanImports(
-    this: *Transpiler,
-    globalThis: *JSC.JSGlobalObject,
-    callframe: *JSC.CallFrame,
-) JSC.JSValue {
-    const arguments = callframe.arguments(2);
-    var exception_val = [_]JSC.C.JSValueRef{null};
-    const exception: JSC.C.ExceptionRef = &exception_val;
+pub fn scanImports(this: *Transpiler, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+    const arguments = callframe.arguments_old(2);
     var args = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments.slice());
     defer args.deinit();
 
     const code_arg = args.next() orelse {
-        globalThis.throwInvalidArgumentType("scanImports", "code", "string or Uint8Array");
-        return .zero;
+        return globalThis.throwInvalidArgumentType("scanImports", "code", "string or Uint8Array");
     };
 
     const code_holder = JSC.Node.StringOrBuffer.fromJS(globalThis, args.arena.allocator(), code_arg) orelse {
-        if (exception.* == null) {
-            globalThis.throwInvalidArgumentType("scanImports", "code", "string or Uint8Array");
-        } else {
-            globalThis.throwValue(JSC.JSValue.c(exception.*));
+        if (!globalThis.hasException()) {
+            return globalThis.throwInvalidArgumentType("scanImports", "code", "string or Uint8Array");
         }
-
         return .zero;
     };
     args.eat();
@@ -1266,20 +1135,14 @@ 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();
     }
 
     if (!loader.isJavaScriptLike()) {
-        globalThis.throwInvalidArguments("Only JavaScript-like files support this fast path", .{});
-        return .zero;
-    }
-
-    if (exception.* != null) {
-        globalThis.throwValue(JSC.JSValue.c(exception.*));
-        return .zero;
+        return globalThis.throwInvalidArguments("Only JavaScript-like files support this fast path", .{});
     }
 
     var arena = Mimalloc.Arena.init() catch unreachable;
@@ -1325,29 +1188,21 @@ pub fn scanImports(
     ) catch |err| {
         defer this.scan_pass_result.reset();
         if ((log.warnings + log.errors) > 0) {
-            globalThis.throwValue(log.toJS(globalThis, globalThis.allocator(), "Failed to scan imports"));
-            return .zero;
+            return globalThis.throwValue(log.toJS(globalThis, globalThis.allocator(), "Failed to scan imports"));
         }
 
-        globalThis.throwError(err, "Failed to scan imports");
-        return .zero;
+        return globalThis.throwError(err, "Failed to scan imports");
     };
 
     defer this.scan_pass_result.reset();
 
     if ((log.warnings + log.errors) > 0) {
-        globalThis.throwValue(log.toJS(globalThis, globalThis.allocator(), "Failed to scan imports"));
-        return .zero;
+        return globalThis.throwValue(log.toJS(globalThis, globalThis.allocator(), "Failed to scan imports"));
     }
 
     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 3849d729eb..6f9dcb62e3 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 16b4f8cb84..44a36a9e02 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 {
-        const arguments = callframe.arguments(2).slice();
+    pub fn prefetchFromJS(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+        const arguments = callframe.arguments_old(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];
@@ -1649,14 +1648,10 @@ pub const InternalDNS = struct {
         if (hostname_or_url.isString()) {
             hostname_slice = hostname_or_url.toSlice(globalThis, bun.default_allocator);
         } else {
-            globalThis.throwInvalidArguments("hostname must be a string", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("hostname must be a string", .{});
         }
 
-        const hostname_z = bun.default_allocator.dupeZ(u8, hostname_slice.slice()) catch {
-            globalThis.throwOutOfMemory();
-            return .zero;
-        };
+        const hostname_z = try bun.default_allocator.dupeZ(u8, hostname_slice.slice());
         defer bun.default_allocator.free(hostname_z);
 
         prefetch(JSC.VirtualMachine.get().uwsLoop(), hostname_z);
@@ -2252,11 +2247,10 @@ pub const DNSResolver = struct {
         });
     };
 
-    pub fn resolve(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
-        const arguments = callframe.arguments(3);
+    pub fn resolve(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+        const arguments = callframe.arguments_old(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)
@@ -2276,16 +2270,14 @@ pub const DNSResolver = struct {
             }
 
             break :brk RecordType.map.getWithEql(record_type_str.getZigString(globalThis), JSC.ZigString.eqlComptime) orelse {
-                globalThis.throwInvalidArgumentType("resolve", "record", "one of: A, AAAA, CNAME, MX, NS, PTR, SOA, SRV, TXT");
-                return .zero;
+                return globalThis.throwInvalidArgumentType("resolve", "record", "one of: A, AAAA, CNAME, MX, NS, PTR, SOA, SRV, TXT");
             };
         };
 
         const name_value = arguments.ptr[0];
 
         if (name_value.isEmptyOrUndefinedOrNull() or !name_value.isString()) {
-            globalThis.throwInvalidArgumentType("resolve", "name", "string");
-            return .zero;
+            return globalThis.throwInvalidArgumentType("resolve", "name", "string");
         }
 
         const name_str = name_value.toStringOrNull(globalThis) orelse {
@@ -2293,8 +2285,7 @@ pub const DNSResolver = struct {
         };
 
         if (name_str.length() == 0) {
-            globalThis.throwInvalidArgumentType("resolve", "name", "non-empty string");
-            return .zero;
+            return globalThis.throwInvalidArgumentType("resolve", "name", "non-empty string");
         }
 
         const name = name_str.toSliceClone(globalThis, bun.default_allocator);
@@ -2337,25 +2328,22 @@ pub const DNSResolver = struct {
         }
     }
 
-    pub fn reverse(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
-        const arguments = callframe.arguments(2);
+    pub fn reverse(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+        const arguments = callframe.arguments_old(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];
         if (ip_value.isEmptyOrUndefinedOrNull() or !ip_value.isString()) {
-            globalThis.throwInvalidArgumentType("reverse", "ip", "string");
-            return .zero;
+            return globalThis.throwInvalidArgumentType("reverse", "ip", "string");
         }
 
         const ip_str = ip_value.toStringOrNull(globalThis) orelse {
             return .zero;
         };
         if (ip_str.length() == 0) {
-            globalThis.throwInvalidArgumentType("reverse", "ip", "non-empty string");
-            return .zero;
+            return globalThis.throwInvalidArgumentType("reverse", "ip", "non-empty string");
         }
 
         const ip_slice = ip_str.toSliceClone(globalThis, bun.default_allocator);
@@ -2366,8 +2354,7 @@ pub const DNSResolver = struct {
             .result => |res| res,
             .err => |err| {
                 defer ip_slice.deinit();
-                globalThis.throwValue(err.toJS(globalThis));
-                return .zero;
+                return globalThis.throwValue(err.toJS(globalThis));
             },
         };
 
@@ -2402,18 +2389,16 @@ pub const DNSResolver = struct {
         return promise;
     }
 
-    pub fn lookup(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
-        const arguments = callframe.arguments(2);
+    pub fn lookup(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+        const arguments = callframe.arguments_old(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];
 
         if (name_value.isEmptyOrUndefinedOrNull() or !name_value.isString()) {
-            globalThis.throwInvalidArgumentType("lookup", "hostname", "string");
-            return .zero;
+            return globalThis.throwInvalidArgumentType("lookup", "hostname", "string");
         }
 
         const name_str = name_value.toStringOrNull(globalThis) orelse {
@@ -2421,23 +2406,21 @@ pub const DNSResolver = struct {
         };
 
         if (name_str.length() == 0) {
-            globalThis.throwInvalidArgumentType("lookup", "hostname", "non-empty string");
-            return .zero;
+            return globalThis.throwInvalidArgumentType("lookup", "hostname", "non-empty string");
         }
 
         var options = GetAddrInfo.Options{};
         var port: u16 = 0;
 
         if (arguments.len > 1 and arguments.ptr[1].isCell()) {
-            if (arguments.ptr[1].get(globalThis, "port")) |port_value| {
+            if (try arguments.ptr[1].get(globalThis, "port")) |port_value| {
                 if (port_value.isNumber()) {
                     port = port_value.to(u16);
                 }
             }
 
             options = GetAddrInfo.Options.fromJS(arguments.ptr[1], globalThis) catch |err| {
-                globalThis.throw("Invalid options passed to lookup(): {s}", .{@errorName(err)});
-                return .zero;
+                return globalThis.throw("Invalid options passed to lookup(): {s}", .{@errorName(err)});
             };
         }
 
@@ -2449,7 +2432,7 @@ pub const DNSResolver = struct {
         return resolver.doLookup(name.slice(), port, options, globalThis);
     }
 
-    pub fn doLookup(this: *DNSResolver, name: []const u8, port: u16, options: GetAddrInfo.Options, globalThis: *JSC.JSGlobalObject) JSC.JSValue {
+    pub fn doLookup(this: *DNSResolver, name: []const u8, port: u16, options: GetAddrInfo.Options, globalThis: *JSC.JSGlobalObject) bun.JSError!JSC.JSValue {
         var opts = options;
         var backend = opts.backend;
         const normalized = normalizeDNSName(name, &backend);
@@ -2472,18 +2455,16 @@ pub const DNSResolver = struct {
         };
     }
 
-    pub fn resolveSrv(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
-        const arguments = callframe.arguments(2);
+    pub fn resolveSrv(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+        const arguments = callframe.arguments_old(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];
 
         if (name_value.isEmptyOrUndefinedOrNull() or !name_value.isString()) {
-            globalThis.throwInvalidArgumentType("resolveSrv", "hostname", "string");
-            return .zero;
+            return globalThis.throwInvalidArgumentType("resolveSrv", "hostname", "string");
         }
 
         const name_str = name_value.toStringOrNull(globalThis) orelse {
@@ -2491,8 +2472,7 @@ pub const DNSResolver = struct {
         };
 
         if (name_str.length() == 0) {
-            globalThis.throwInvalidArgumentType("resolveSrv", "hostname", "non-empty string");
-            return .zero;
+            return globalThis.throwInvalidArgumentType("resolveSrv", "hostname", "non-empty string");
         }
 
         const name = name_str.toSliceClone(globalThis, bun.default_allocator);
@@ -2503,18 +2483,16 @@ 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 {
-        const arguments = callframe.arguments(2);
+    pub fn resolveSoa(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+        const arguments = callframe.arguments_old(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];
 
         if (name_value.isEmptyOrUndefinedOrNull() or !name_value.isString()) {
-            globalThis.throwInvalidArgumentType("resolveSoa", "hostname", "string");
-            return .zero;
+            return globalThis.throwInvalidArgumentType("resolveSoa", "hostname", "string");
         }
 
         const name_str = name_value.toStringOrNull(globalThis) orelse {
@@ -2529,18 +2507,16 @@ 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 {
-        const arguments = callframe.arguments(2);
+    pub fn resolveCaa(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+        const arguments = callframe.arguments_old(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];
 
         if (name_value.isEmptyOrUndefinedOrNull() or !name_value.isString()) {
-            globalThis.throwInvalidArgumentType("resolveCaa", "hostname", "string");
-            return .zero;
+            return globalThis.throwInvalidArgumentType("resolveCaa", "hostname", "string");
         }
 
         const name_str = name_value.toStringOrNull(globalThis) orelse {
@@ -2548,8 +2524,7 @@ pub const DNSResolver = struct {
         };
 
         if (name_str.length() == 0) {
-            globalThis.throwInvalidArgumentType("resolveCaa", "hostname", "non-empty string");
-            return .zero;
+            return globalThis.throwInvalidArgumentType("resolveCaa", "hostname", "non-empty string");
         }
 
         const name = name_str.toSliceClone(globalThis, bun.default_allocator);
@@ -2560,18 +2535,16 @@ 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 {
-        const arguments = callframe.arguments(2);
+    pub fn resolveNs(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+        const arguments = callframe.arguments_old(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];
 
         if (name_value.isEmptyOrUndefinedOrNull() or !name_value.isString()) {
-            globalThis.throwInvalidArgumentType("resolveNs", "hostname", "string");
-            return .zero;
+            return globalThis.throwInvalidArgumentType("resolveNs", "hostname", "string");
         }
 
         const name_str = name_value.toStringOrNull(globalThis) orelse {
@@ -2586,18 +2559,16 @@ 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 {
-        const arguments = callframe.arguments(2);
+    pub fn resolvePtr(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+        const arguments = callframe.arguments_old(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];
 
         if (name_value.isEmptyOrUndefinedOrNull() or !name_value.isString()) {
-            globalThis.throwInvalidArgumentType("resolvePtr", "hostname", "string");
-            return .zero;
+            return globalThis.throwInvalidArgumentType("resolvePtr", "hostname", "string");
         }
 
         const name_str = name_value.toStringOrNull(globalThis) orelse {
@@ -2605,8 +2576,7 @@ pub const DNSResolver = struct {
         };
 
         if (name_str.length() == 0) {
-            globalThis.throwInvalidArgumentType("resolvePtr", "hostname", "non-empty string");
-            return .zero;
+            return globalThis.throwInvalidArgumentType("resolvePtr", "hostname", "non-empty string");
         }
 
         const name = name_str.toSliceClone(globalThis, bun.default_allocator);
@@ -2617,18 +2587,16 @@ 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 {
-        const arguments = callframe.arguments(2);
+    pub fn resolveCname(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+        const arguments = callframe.arguments_old(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];
 
         if (name_value.isEmptyOrUndefinedOrNull() or !name_value.isString()) {
-            globalThis.throwInvalidArgumentType("resolveCname", "hostname", "string");
-            return .zero;
+            return globalThis.throwInvalidArgumentType("resolveCname", "hostname", "string");
         }
 
         const name_str = name_value.toStringOrNull(globalThis) orelse {
@@ -2636,8 +2604,7 @@ pub const DNSResolver = struct {
         };
 
         if (name_str.length() == 0) {
-            globalThis.throwInvalidArgumentType("resolveCname", "hostname", "non-empty string");
-            return .zero;
+            return globalThis.throwInvalidArgumentType("resolveCname", "hostname", "non-empty string");
         }
 
         const name = name_str.toSliceClone(globalThis, bun.default_allocator);
@@ -2648,18 +2615,16 @@ 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 {
-        const arguments = callframe.arguments(2);
+    pub fn resolveMx(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+        const arguments = callframe.arguments_old(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];
 
         if (name_value.isEmptyOrUndefinedOrNull() or !name_value.isString()) {
-            globalThis.throwInvalidArgumentType("resolveMx", "hostname", "string");
-            return .zero;
+            return globalThis.throwInvalidArgumentType("resolveMx", "hostname", "string");
         }
 
         const name_str = name_value.toStringOrNull(globalThis) orelse {
@@ -2667,8 +2632,7 @@ pub const DNSResolver = struct {
         };
 
         if (name_str.length() == 0) {
-            globalThis.throwInvalidArgumentType("resolveMx", "hostname", "non-empty string");
-            return .zero;
+            return globalThis.throwInvalidArgumentType("resolveMx", "hostname", "non-empty string");
         }
 
         const name = name_str.toSliceClone(globalThis, bun.default_allocator);
@@ -2679,18 +2643,16 @@ 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 {
-        const arguments = callframe.arguments(2);
+    pub fn resolveNaptr(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+        const arguments = callframe.arguments_old(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];
 
         if (name_value.isEmptyOrUndefinedOrNull() or !name_value.isString()) {
-            globalThis.throwInvalidArgumentType("resolveNaptr", "hostname", "string");
-            return .zero;
+            return globalThis.throwInvalidArgumentType("resolveNaptr", "hostname", "string");
         }
 
         const name_str = name_value.toStringOrNull(globalThis) orelse {
@@ -2698,8 +2660,7 @@ pub const DNSResolver = struct {
         };
 
         if (name_str.length() == 0) {
-            globalThis.throwInvalidArgumentType("resolveNaptr", "hostname", "non-empty string");
-            return .zero;
+            return globalThis.throwInvalidArgumentType("resolveNaptr", "hostname", "non-empty string");
         }
 
         const name = name_str.toSliceClone(globalThis, bun.default_allocator);
@@ -2710,18 +2671,16 @@ 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 {
-        const arguments = callframe.arguments(2);
+    pub fn resolveTxt(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+        const arguments = callframe.arguments_old(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];
 
         if (name_value.isEmptyOrUndefinedOrNull() or !name_value.isString()) {
-            globalThis.throwInvalidArgumentType("resolveTxt", "hostname", "string");
-            return .zero;
+            return globalThis.throwInvalidArgumentType("resolveTxt", "hostname", "string");
         }
 
         const name_str = name_value.toStringOrNull(globalThis) orelse {
@@ -2729,8 +2688,7 @@ pub const DNSResolver = struct {
         };
 
         if (name_str.length() == 0) {
-            globalThis.throwInvalidArgumentType("resolveTxt", "hostname", "non-empty string");
-            return .zero;
+            return globalThis.throwInvalidArgumentType("resolveTxt", "hostname", "non-empty string");
         }
 
         const name = name_str.toSliceClone(globalThis, bun.default_allocator);
@@ -2741,12 +2699,11 @@ pub const DNSResolver = struct {
         return resolver.doResolveCAres(c_ares.struct_ares_txt_reply, "txt", name.slice(), globalThis);
     }
 
-    pub fn doResolveCAres(this: *DNSResolver, comptime cares_type: type, comptime type_name: []const u8, name: []const u8, globalThis: *JSC.JSGlobalObject) JSC.JSValue {
+    pub fn doResolveCAres(this: *DNSResolver, comptime cares_type: type, comptime type_name: []const u8, name: []const u8, globalThis: *JSC.JSGlobalObject) bun.JSError!JSC.JSValue {
         var channel: *c_ares.Channel = switch (this.getChannel()) {
             .result => |res| res,
             .err => |err| {
-                globalThis.throwValue(err.toJS(globalThis));
-                return .zero;
+                return globalThis.throwValue(err.toJS(globalThis));
             },
         };
 
@@ -2782,7 +2739,7 @@ pub const DNSResolver = struct {
 
         return promise;
     }
-    pub fn c_aresLookupWithNormalizedName(this: *DNSResolver, query: GetAddrInfo, globalThis: *JSC.JSGlobalObject) JSC.JSValue {
+    pub fn c_aresLookupWithNormalizedName(this: *DNSResolver, query: GetAddrInfo, globalThis: *JSC.JSGlobalObject) bun.JSError!JSC.JSValue {
         var channel: *c_ares.Channel = switch (this.getChannel()) {
             .result => |res| res,
             .err => |err| {
@@ -2792,8 +2749,7 @@ pub const DNSResolver = struct {
                     .message = bun.String.static(err.label()),
                 };
 
-                globalThis.throwValue(system_error.toErrorInstance(globalThis));
-                return .zero;
+                return globalThis.throwValue(system_error.toErrorInstance(globalThis)) catch .zero;
             },
         };
 
@@ -2831,7 +2787,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();
@@ -2845,8 +2801,7 @@ pub const DNSResolver = struct {
                     .message = bun.String.static(err.label()),
                 };
 
-                globalThis.throwValue(system_error.toErrorInstance(globalThis));
-                return .zero;
+                return globalThis.throwValue(system_error.toErrorInstance(globalThis));
             },
         };
 
@@ -2854,8 +2809,7 @@ pub const DNSResolver = struct {
         const r = c_ares.ares_get_servers_ports(channel, &servers);
         if (r != c_ares.ARES_SUCCESS) {
             const err = c_ares.Error.get(r).?;
-            globalThis.throwValue(globalThis.createErrorInstance("ares_get_servers_ports error: {s}", .{err.label()}));
-            return .zero;
+            return globalThis.throwValue(globalThis.createErrorInstance("ares_get_servers_ports error: {s}", .{err.label()}));
         }
         defer c_ares.ares_free_data(servers);
 
@@ -2880,11 +2834,7 @@ pub const DNSResolver = struct {
                 break :blk c_ares.ares_inet_ntop(family, &current.addr.addr4, buf[1..], @sizeOf(@TypeOf(buf)) - 1);
             };
             if (ip == null) {
-                globalThis.throwValue(globalThis.createErrorInstance(
-                    "ares_inet_ntop error: no more space to convert a network format address",
-                    .{},
-                ));
-                return .zero;
+                return globalThis.throwValue(globalThis.createErrorInstance("ares_inet_ntop error: no more space to convert a network format address", .{}));
             }
 
             var port = current.tcp_port;
@@ -2917,39 +2867,34 @@ 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 {
-        const arguments = callframe.arguments(3);
+    pub fn lookupService(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+        const arguments = callframe.arguments_old(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];
         const port_value = arguments.ptr[1];
         if (addr_value.isEmptyOrUndefinedOrNull() or !addr_value.isString()) {
-            globalThis.throwInvalidArgumentType("lookupService", "address", "string");
-            return .zero;
+            return globalThis.throwInvalidArgumentType("lookupService", "address", "string");
         }
         const addr_str = addr_value.toStringOrNull(globalThis) orelse {
             return .zero;
         };
         if (addr_str.length() == 0) {
-            globalThis.throwInvalidArgumentType("lookupService", "address", "non-empty string");
-            return .zero;
+            return globalThis.throwInvalidArgumentType("lookupService", "address", "non-empty string");
         }
 
         const addr_s = addr_str.getZigString(globalThis).slice();
         const port: u16 = if (port_value.isNumber()) blk: {
             break :blk port_value.to(u16);
         } else {
-            globalThis.throwInvalidArgumentType("lookupService", "port", "invalid port");
-            return .zero;
+            return globalThis.throwInvalidArgumentType("lookupService", "port", "invalid port");
         };
 
         var sa: std.posix.sockaddr.storage = std.mem.zeroes(std.posix.sockaddr.storage);
         if (c_ares.getSockaddr(addr_s, port, @as(*std.posix.sockaddr, @ptrCast(&sa))) != 0) {
-            globalThis.throwInvalidArgumentType("lookupService", "address", "invalid address");
-            return .zero;
+            return globalThis.throwInvalidArgumentType("lookupService", "address", "invalid address");
         }
 
         var vm = globalThis.bunVM();
@@ -2963,8 +2908,7 @@ pub const DNSResolver = struct {
                     .message = bun.String.static(err.label()),
                 };
 
-                globalThis.throwValue(system_error.toErrorInstance(globalThis));
-                return .zero;
+                return globalThis.throwValue(system_error.toErrorInstance(globalThis));
             },
         };
 
@@ -3004,98 +2948,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 13c5d04d89..05d30aa613 100644
--- a/src/bun.js/api/bun/h2_frame_parser.zig
+++ b/src/bun.js/api/bun/h2_frame_parser.zig
@@ -6,7 +6,28 @@ const Allocator = std.mem.Allocator;
 const JSC = bun.JSC;
 const MutableString = bun.MutableString;
 const lshpack = @import("./lshpack.zig");
+const strings = bun.strings;
+pub const AutoFlusher = @import("../../webcore/streams.zig").AutoFlusher;
+const TLSSocket = @import("./socket.zig").TLSSocket;
+const TCPSocket = @import("./socket.zig").TCPSocket;
+const JSTLSSocket = JSC.Codegen.JSTLSSocket;
+const JSTCPSocket = JSC.Codegen.JSTCPSocket;
+const MAX_PAYLOAD_SIZE_WITHOUT_FRAME = 16384 - FrameHeader.byteSize - 1;
+const BunSocket = union(enum) {
+    none: void,
+    tls: *TLSSocket,
+    tls_writeonly: *TLSSocket,
+    tcp: *TCPSocket,
+    tcp_writeonly: *TCPSocket,
+};
+extern fn JSC__JSGlobalObject__getHTTP2CommonString(globalObject: *JSC.JSGlobalObject, hpack_index: u32) JSC.JSValue;
 
+pub fn getHTTP2CommonString(globalObject: *JSC.JSGlobalObject, hpack_index: u32) ?JSC.JSValue {
+    if (hpack_index == 255) return null;
+    const value = JSC__JSGlobalObject__getHTTP2CommonString(globalObject, hpack_index);
+    if (value.isEmptyOrUndefinedOrNull()) return null;
+    return value;
+}
 const JSValue = JSC.JSValue;
 
 const BinaryType = JSC.BinaryType;
@@ -17,6 +38,11 @@ const WINDOW_INCREMENT_SIZE = 65536;
 const MAX_HPACK_HEADER_SIZE = 65536;
 const MAX_FRAME_SIZE = 16777215;
 
+const PaddingStrategy = enum {
+    none,
+    aligned,
+    max,
+};
 const FrameType = enum(u8) {
     HTTP_FRAME_DATA = 0x00,
     HTTP_FRAME_HEADERS = 0x01,
@@ -43,6 +69,9 @@ const HeadersFrameFlags = enum(u8) {
     PADDED = 0x8,
     PRIORITY = 0x20,
 };
+const SettingsFlags = enum(u8) {
+    ACK = 0x1,
+};
 
 const ErrorCode = enum(u32) {
     NO_ERROR = 0x0,
@@ -95,11 +124,11 @@ const UInt31WithReserved = packed struct(u32) {
         return @bitCast(dst);
     }
 
-    pub inline fn write(this: UInt31WithReserved, comptime Writer: type, writer: Writer) void {
+    pub inline fn write(this: UInt31WithReserved, comptime Writer: type, writer: Writer) bool {
         var value: u32 = @bitCast(this);
         value = @byteSwap(value);
 
-        _ = writer.write(std.mem.asBytes(&value)) catch 0;
+        return (writer.write(std.mem.asBytes(&value)) catch 0) != 0;
     }
 };
 
@@ -108,11 +137,11 @@ const StreamPriority = packed struct(u40) {
     weight: u8 = 0,
 
     pub const byteSize: usize = 5;
-    pub inline fn write(this: *StreamPriority, comptime Writer: type, writer: Writer) void {
+    pub inline fn write(this: *StreamPriority, comptime Writer: type, writer: Writer) bool {
         var swap = this.*;
         std.mem.byteSwapAllFields(StreamPriority, &swap);
 
-        _ = writer.write(std.mem.asBytes(&swap)[0..StreamPriority.byteSize]) catch 0;
+        return (writer.write(std.mem.asBytes(&swap)[0..StreamPriority.byteSize]) catch 0) != 0;
     }
 
     pub inline fn from(dst: *StreamPriority, src: []const u8) void {
@@ -128,11 +157,11 @@ const FrameHeader = packed struct(u72) {
     streamIdentifier: u32 = 0,
 
     pub const byteSize: usize = 9;
-    pub inline fn write(this: *FrameHeader, comptime Writer: type, writer: Writer) void {
+    pub inline fn write(this: *FrameHeader, comptime Writer: type, writer: Writer) bool {
         var swap = this.*;
         std.mem.byteSwapAllFields(FrameHeader, &swap);
 
-        _ = writer.write(std.mem.asBytes(&swap)[0..FrameHeader.byteSize]) catch 0;
+        return (writer.write(std.mem.asBytes(&swap)[0..FrameHeader.byteSize]) catch 0) != 0;
     }
 
     pub inline fn from(dst: *FrameHeader, src: []const u8, offset: usize, comptime end: bool) void {
@@ -159,9 +188,9 @@ const FullSettingsPayload = packed struct(u288) {
     _headerTableSizeType: u16 = @intFromEnum(SettingsType.SETTINGS_HEADER_TABLE_SIZE),
     headerTableSize: u32 = 4096,
     _enablePushType: u16 = @intFromEnum(SettingsType.SETTINGS_ENABLE_PUSH),
-    enablePush: u32 = 1,
+    enablePush: u32 = 0,
     _maxConcurrentStreamsType: u16 = @intFromEnum(SettingsType.SETTINGS_MAX_CONCURRENT_STREAMS),
-    maxConcurrentStreams: u32 = 2147483647,
+    maxConcurrentStreams: u32 = 4294967295,
     _initialWindowSizeType: u16 = @intFromEnum(SettingsType.SETTINGS_INITIAL_WINDOW_SIZE),
     initialWindowSize: u32 = 65535,
     _maxFrameSizeType: u16 = @intFromEnum(SettingsType.SETTINGS_MAX_FRAME_SIZE),
@@ -195,11 +224,11 @@ const FullSettingsPayload = packed struct(u288) {
             else => {}, // we ignore unknown/unsupportd settings its not relevant if we dont apply them
         }
     }
-    pub fn write(this: *FullSettingsPayload, comptime Writer: type, writer: Writer) void {
+    pub fn write(this: *FullSettingsPayload, comptime Writer: type, writer: Writer) bool {
         var swap = this.*;
 
         std.mem.byteSwapAllFields(FullSettingsPayload, &swap);
-        _ = writer.write(std.mem.asBytes(&swap)[0..FullSettingsPayload.byteSize]) catch 0;
+        return (writer.write(std.mem.asBytes(&swap)[0..FullSettingsPayload.byteSize]) catch 0) != 0;
     }
 };
 const ValidPseudoHeaders = bun.ComptimeStringMap(void, .{
@@ -261,11 +290,11 @@ 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 = .{};
 
-    const args_list = callframe.arguments(1);
+    const args_list = callframe.arguments_old(1);
     if (args_list.len < 1) {
         return settings.toJS(globalObject);
     }
@@ -276,8 +305,7 @@ fn jsGetUnpackedSettings(globalObject: *JSC.JSGlobalObject, callframe: *JSC.Call
         var payload = array_buffer.byteSlice();
         const settingByteSize = SettingsPayloadUnit.byteSize;
         if (payload.len < settingByteSize or payload.len % settingByteSize != 0) {
-            globalObject.throw("Expected buf to be a Buffer of at least 6 bytes and a multiple of 6 bytes", .{});
-            return .zero;
+            return globalObject.throw("Expected buf to be a Buffer of at least 6 bytes and a multiple of 6 bytes", .{});
         }
 
         var i: usize = 0;
@@ -289,115 +317,187 @@ fn jsGetUnpackedSettings(globalObject: *JSC.JSGlobalObject, callframe: *JSC.Call
         }
         return settings.toJS(globalObject);
     } else if (!data_arg.isEmptyOrUndefinedOrNull()) {
-        globalObject.throw("Expected buf to be a Buffer", .{});
-        return .zero;
+        return globalObject.throw("Expected buf to be a Buffer", .{});
     } else {
         return settings.toJS(globalObject);
     }
 }
 
-fn jsGetPackedSettings(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_old(1);
+    if (args_list.len < 1) {
+        return globalObject.throw("Expected settings to be a object", .{});
+    }
+
+    if (args_list.len > 0 and !args_list.ptr[0].isEmptyOrUndefinedOrNull()) {
+        const options = args_list.ptr[0];
+        if (!options.isObject()) {
+            return globalObject.throw("Expected settings to be a object", .{});
+        }
+
+        if (try options.get(globalObject, "headerTableSize")) |headerTableSize| {
+            if (headerTableSize.isNumber()) {
+                const headerTableSizeValue = headerTableSize.toInt32();
+                if (headerTableSizeValue > MAX_HEADER_TABLE_SIZE or headerTableSizeValue < 0) {
+                    return globalObject.throw("Expected headerTableSize to be a number between 0 and 2^32-1", .{});
+                }
+            } else if (!headerTableSize.isEmptyOrUndefinedOrNull()) {
+                return globalObject.throw("Expected headerTableSize to be a number", .{});
+            }
+        }
+
+        if (try options.get(globalObject, "enablePush")) |enablePush| {
+            if (!enablePush.isBoolean() and !enablePush.isEmptyOrUndefinedOrNull()) {
+                return globalObject.throw("Expected enablePush to be a boolean", .{});
+            }
+        }
+
+        if (try options.get(globalObject, "initialWindowSize")) |initialWindowSize| {
+            if (initialWindowSize.isNumber()) {
+                const initialWindowSizeValue = initialWindowSize.toInt32();
+                if (initialWindowSizeValue > MAX_HEADER_TABLE_SIZE or initialWindowSizeValue < 0) {
+                    return globalObject.throw("Expected initialWindowSize to be a number between 0 and 2^32-1", .{});
+                }
+            } else if (!initialWindowSize.isEmptyOrUndefinedOrNull()) {
+                return globalObject.throw("Expected initialWindowSize to be a number", .{});
+            }
+        }
+
+        if (try options.get(globalObject, "maxFrameSize")) |maxFrameSize| {
+            if (maxFrameSize.isNumber()) {
+                const maxFrameSizeValue = maxFrameSize.toInt32();
+                if (maxFrameSizeValue > MAX_FRAME_SIZE or maxFrameSizeValue < 16384) {
+                    return globalObject.throw("Expected maxFrameSize to be a number between 16,384 and 2^24-1", .{});
+                }
+            } else if (!maxFrameSize.isEmptyOrUndefinedOrNull()) {
+                return globalObject.throw("Expected maxFrameSize to be a number", .{});
+            }
+        }
+
+        if (try options.get(globalObject, "maxConcurrentStreams")) |maxConcurrentStreams| {
+            if (maxConcurrentStreams.isNumber()) {
+                const maxConcurrentStreamsValue = maxConcurrentStreams.toInt32();
+                if (maxConcurrentStreamsValue > MAX_HEADER_TABLE_SIZE or maxConcurrentStreamsValue < 0) {
+                    return globalObject.throw("Expected maxConcurrentStreams to be a number between 0 and 2^32-1", .{});
+                }
+            } else if (!maxConcurrentStreams.isEmptyOrUndefinedOrNull()) {
+                return globalObject.throw("Expected maxConcurrentStreams to be a number", .{});
+            }
+        }
+
+        if (try options.get(globalObject, "maxHeaderListSize")) |maxHeaderListSize| {
+            if (maxHeaderListSize.isNumber()) {
+                const maxHeaderListSizeValue = maxHeaderListSize.toInt32();
+                if (maxHeaderListSizeValue > MAX_HEADER_TABLE_SIZE or maxHeaderListSizeValue < 0) {
+                    return globalObject.throw("Expected maxHeaderListSize to be a number between 0 and 2^32-1", .{});
+                }
+            } else if (!maxHeaderListSize.isEmptyOrUndefinedOrNull()) {
+                return globalObject.throw("Expected maxHeaderListSize to be a number", .{});
+            }
+        }
+
+        if (try options.get(globalObject, "maxHeaderSize")) |maxHeaderSize| {
+            if (maxHeaderSize.isNumber()) {
+                const maxHeaderSizeValue = maxHeaderSize.toInt32();
+                if (maxHeaderSizeValue > MAX_HEADER_TABLE_SIZE or maxHeaderSizeValue < 0) {
+                    return globalObject.throw("Expected maxHeaderSize to be a number between 0 and 2^32-1", .{});
+                }
+            } else if (!maxHeaderSize.isEmptyOrUndefinedOrNull()) {
+                return globalObject.throw("Expected maxHeaderSize to be a number", .{});
+            }
+        }
+    }
+    return .undefined;
+}
+
+fn jsGetPackedSettings(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     var settings: FullSettingsPayload = .{};
-    const args_list = callframe.arguments(1);
+    const args_list = callframe.arguments_old(1);
 
     if (args_list.len > 0 and !args_list.ptr[0].isEmptyOrUndefinedOrNull()) {
         const options = args_list.ptr[0];
 
         if (!options.isObject()) {
-            globalObject.throw("Expected settings to be a object", .{});
-            return .zero;
+            return globalObject.throw("Expected settings to be a object", .{});
         }
 
-        if (options.get(globalObject, "headerTableSize")) |headerTableSize| {
+        if (try 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 .zero;
+                    return globalObject.throw("Expected headerTableSize to be a number between 0 and 2^32-1", .{});
                 }
                 settings.headerTableSize = @intCast(headerTableSizeValue);
             } else if (!headerTableSize.isEmptyOrUndefinedOrNull()) {
-                globalObject.throw("Expected headerTableSize to be a number", .{});
-                return .zero;
+                return globalObject.throw("Expected headerTableSize to be a number", .{});
             }
         }
 
-        if (options.get(globalObject, "enablePush")) |enablePush| {
+        if (try options.get(globalObject, "enablePush")) |enablePush| {
             if (enablePush.isBoolean()) {
                 settings.enablePush = if (enablePush.asBoolean()) 1 else 0;
             } else if (!enablePush.isEmptyOrUndefinedOrNull()) {
-                globalObject.throw("Expected enablePush to be a boolean", .{});
-                return .zero;
+                return globalObject.throw("Expected enablePush to be a boolean", .{});
             }
         }
 
-        if (options.get(globalObject, "initialWindowSize")) |initialWindowSize| {
+        if (try options.get(globalObject, "initialWindowSize")) |initialWindowSize| {
             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 .zero;
+                    return globalObject.throw("Expected initialWindowSize to be a number between 0 and 2^32-1", .{});
                 }
                 settings.initialWindowSize = @intCast(initialWindowSizeValue);
             } else if (!initialWindowSize.isEmptyOrUndefinedOrNull()) {
-                globalObject.throw("Expected initialWindowSize to be a number", .{});
-                return .zero;
+                return globalObject.throw("Expected initialWindowSize to be a number", .{});
             }
         }
 
-        if (options.get(globalObject, "maxFrameSize")) |maxFrameSize| {
+        if (try options.get(globalObject, "maxFrameSize")) |maxFrameSize| {
             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 .zero;
+                    return globalObject.throw("Expected maxFrameSize to be a number between 16,384 and 2^24-1", .{});
                 }
                 settings.maxFrameSize = @intCast(maxFrameSizeValue);
             } else if (!maxFrameSize.isEmptyOrUndefinedOrNull()) {
-                globalObject.throw("Expected maxFrameSize to be a number", .{});
-                return .zero;
+                return globalObject.throw("Expected maxFrameSize to be a number", .{});
             }
         }
 
-        if (options.get(globalObject, "maxConcurrentStreams")) |maxConcurrentStreams| {
+        if (try options.get(globalObject, "maxConcurrentStreams")) |maxConcurrentStreams| {
             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 .zero;
+                    return globalObject.throw("Expected maxConcurrentStreams to be a number between 0 and 2^32-1", .{});
                 }
                 settings.maxConcurrentStreams = @intCast(maxConcurrentStreamsValue);
             } else if (!maxConcurrentStreams.isEmptyOrUndefinedOrNull()) {
-                globalObject.throw("Expected maxConcurrentStreams to be a number", .{});
-                return .zero;
+                return globalObject.throw("Expected maxConcurrentStreams to be a number", .{});
             }
         }
 
-        if (options.get(globalObject, "maxHeaderListSize")) |maxHeaderListSize| {
+        if (try options.get(globalObject, "maxHeaderListSize")) |maxHeaderListSize| {
             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 .zero;
+                    return globalObject.throw("Expected maxHeaderListSize to be a number between 0 and 2^32-1", .{});
                 }
                 settings.maxHeaderListSize = @intCast(maxHeaderListSizeValue);
             } else if (!maxHeaderListSize.isEmptyOrUndefinedOrNull()) {
-                globalObject.throw("Expected maxHeaderListSize to be a number", .{});
-                return .zero;
+                return globalObject.throw("Expected maxHeaderListSize to be a number", .{});
             }
         }
 
-        if (options.get(globalObject, "maxHeaderSize")) |maxHeaderSize| {
+        if (try options.get(globalObject, "maxHeaderSize")) |maxHeaderSize| {
             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 .zero;
+                    return globalObject.throw("Expected maxHeaderSize to be a number between 0 and 2^32-1", .{});
                 }
                 settings.maxHeaderListSize = @intCast(maxHeaderSizeValue);
             } else if (!maxHeaderSize.isEmptyOrUndefinedOrNull()) {
-                globalObject.throw("Expected maxHeaderSize to be a number", .{});
-                return .zero;
+                return globalObject.throw("Expected maxHeaderSize to be a number", .{});
             }
         }
     }
@@ -437,19 +537,32 @@ const Handlers = struct {
         }
 
         this.vm.eventLoop().runCallback(callback, this.globalObject, thisValue, data);
-
         return true;
     }
 
-    pub fn fromJS(globalObject: *JSC.JSGlobalObject, opts: JSC.JSValue, exception: JSC.C.ExceptionRef) ?Handlers {
+    pub fn callWriteCallback(this: *Handlers, callback: JSC.JSValue, data: []const JSValue) bool {
+        if (!callback.isCallable(this.globalObject.vm())) return false;
+        this.vm.eventLoop().runCallback(callback, this.globalObject, .undefined, data);
+        return true;
+    }
+
+    pub fn callEventHandlerWithResult(this: *Handlers, comptime event: @Type(.EnumLiteral), thisValue: JSValue, data: []const JSValue) JSValue {
+        const callback = @field(this, @tagName(event));
+        if (callback == .zero) {
+            return JSC.JSValue.zero;
+        }
+
+        return this.vm.eventLoop().runCallbackWithResult(callback, this.globalObject, thisValue, data);
+    }
+
+    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.throwInvalidArguments("Expected \"handlers\" to be an object", .{});
         }
 
         const pairs = .{
@@ -463,37 +576,42 @@ const Handlers = struct {
             .{ "onWantTrailers", "wantTrailers" },
             .{ "onPing", "ping" },
             .{ "onEnd", "end" },
-            .{ "onError", "error" },
+            // .{ "onError", "error" } using fastGet(.error) now
             .{ "onGoAway", "goaway" },
             .{ "onAborted", "aborted" },
             .{ "onWrite", "write" },
         };
 
         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.throwInvalidArguments("Expected \"{s}\" callback to be a function", .{pair[1]});
                 }
 
                 @field(handlers, pair.@"0") = callback_value;
             }
         }
 
-        if (handlers.onWrite == .zero) {
-            exception.* = JSC.toInvalidArguments("Expected at least \"write\" callback", .{}, globalObject).asObjectRef();
-            return null;
-        }
-
-        if (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;
+        if (opts.fastGet(globalObject, .@"error")) |callback_value| {
+            if (!callback_value.isCell() or !callback_value.isCallable(globalObject.vm())) {
+                return globalObject.throwInvalidArguments("Expected \"error\" callback to be a function", .{});
             }
 
-            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.onError = callback_value;
+        }
+
+        // onWrite is required for duplex support or if more than 1 parser is attached to the same socket (unliked)
+        if (handlers.onWrite == .zero) {
+            return globalObject.throwInvalidArguments("Expected at least \"write\" callback", .{});
+        }
+
+        if (try opts.getTruthy(globalObject, "binaryType")) |binary_type_value| {
+            if (!binary_type_value.isString()) {
+                return globalObject.throwInvalidArguments("Expected \"binaryType\" to be a string", .{});
+            }
+
+            handlers.binary_type = try BinaryType.fromJSValue(globalObject, binary_type_value) orelse {
+                return globalObject.throwInvalidArguments("Expected 'binaryType' to be 'ArrayBuffer', 'Uint8Array', or 'Buffer'", .{});
             };
         }
 
@@ -525,10 +643,24 @@ const Handlers = struct {
 pub const H2FrameParser = struct {
     pub const log = Output.scoped(.H2FrameParser, false);
     pub usingnamespace JSC.Codegen.JSH2FrameParser;
+    pub usingnamespace bun.NewRefCounted(@This(), @This().deinit);
+    pub const DEBUG_REFCOUNT_NAME = "H2";
+    const ENABLE_AUTO_CORK = true; // ENABLE CORK OPTIMIZATION
+    const ENABLE_ALLOCATOR_POOL = true; // ENABLE HIVE ALLOCATOR OPTIMIZATION
+
+    const MAX_BUFFER_SIZE = 32768;
+    threadlocal var CORK_BUFFER: [16386]u8 = undefined;
+    threadlocal var CORK_OFFSET: u16 = 0;
+    threadlocal var CORKED_H2: ?*H2FrameParser = null;
+
+    const H2FrameParserHiveAllocator = bun.HiveArray(H2FrameParser, 256).Fallback;
+    pub threadlocal var pool: if (ENABLE_ALLOCATOR_POOL) ?*H2FrameParserHiveAllocator else u0 = if (ENABLE_ALLOCATOR_POOL) null else 0;
 
     strong_ctx: JSC.Strong = .{},
+    globalThis: *JSC.JSGlobalObject,
     allocator: Allocator,
     handlers: Handlers,
+    native_socket: BunSocket = .{ .none = {} },
     localSettings: FullSettingsPayload = .{},
     // only available after receiving settings or ACK
     remoteSettings: ?FullSettingsPayload = null,
@@ -542,17 +674,56 @@ pub const H2FrameParser = struct {
     windowSize: u32 = 65535,
     // used window size for the connection
     usedWindowSize: u32 = 0,
+    maxHeaderListPairs: u32 = 128,
+    maxRejectedStreams: u32 = 100,
+    rejectedStreams: u32 = 0,
+    maxSessionMemory: u32 = 10, //this limit is in MB
+    queuedDataSize: u64 = 0, // this is in bytes
+    maxOutstandingPings: u64 = 10,
+    outStandingPings: u64 = 0,
     lastStreamID: u32 = 0,
-    firstSettingsACK: bool = false,
+    isServer: bool = false,
+    prefaceReceivedLen: u8 = 0,
     // we buffer requests until we get the first settings ACK
     writeBuffer: bun.ByteList = .{},
+    writeBufferOffset: usize = 0,
+    // TODO: this will be removed when I re-add header and data priorization
+    outboundQueueSize: usize = 0,
 
     streams: bun.U32HashMap(Stream),
 
     hpack: ?*lshpack.HPACK = null,
 
-    threadlocal var shared_request_buffer: [16384]u8 = undefined;
+    autouncork_registered: bool = false,
+    has_nonnative_backpressure: bool = false,
+    ref_count: u8 = 1,
 
+    threadlocal var shared_request_buffer: [16384]u8 = undefined;
+    /// The streams hashmap may mutate when growing we use this when we need to make sure its safe to iterate over it
+    pub const StreamResumableIterator = struct {
+        parser: *H2FrameParser,
+        index: u32 = 0,
+        pub fn init(parser: *H2FrameParser) StreamResumableIterator {
+            return .{ .index = 0, .parser = parser };
+        }
+        pub fn next(this: *StreamResumableIterator) ?*Stream {
+            var it = this.parser.streams.iterator();
+            if (it.index > it.hm.capacity()) return null;
+            // resume the iterator from the same index if possible
+            it.index = this.index;
+            while (it.next()) |item| {
+                this.index = it.index;
+                return item.value_ptr;
+            }
+            this.index = it.index;
+            return null;
+        }
+    };
+    pub const FlushState = enum {
+        no_action,
+        flushed,
+        backpressure,
+    };
     const Stream = struct {
         id: u32 = 0,
         state: enum(u8) {
@@ -564,10 +735,13 @@ pub const H2FrameParser = struct {
             HALF_CLOSED_REMOTE = 6,
             CLOSED = 7,
         } = .IDLE,
+        jsContext: JSC.Strong = .{},
         waitForTrailers: bool = false,
+        closeAfterDrain: bool = false,
         endAfterHeaders: bool = false,
         isWaitingMoreHeaders: bool = false,
         padding: ?u8 = 0,
+        paddingStrategy: PaddingStrategy = .none,
         rstCode: u32 = 0,
         streamDependency: u32 = 0,
         exclusive: bool = false,
@@ -576,18 +750,286 @@ pub const H2FrameParser = struct {
         windowSize: u32 = 65535,
         // used window size for the stream
         usedWindowSize: u32 = 0,
+        signal: ?*SignalRef = null,
 
-        signal: ?*JSC.WebCore.AbortSignal = null,
-        client: *H2FrameParser,
+        // when we have backpressure we queue the data e round robin the Streams
+        dataFrameQueue: PendingQueue,
+        const SignalRef = struct {
+            signal: *JSC.WebCore.AbortSignal,
+            parser: *H2FrameParser,
+            stream_id: u32,
 
-        pub fn init(streamIdentifier: u32, initialWindowSize: u32, client: *H2FrameParser) Stream {
+            usingnamespace bun.New(SignalRef);
+
+            pub fn isAborted(this: *SignalRef) bool {
+                return this.signal.aborted();
+            }
+
+            pub fn abortListener(this: *SignalRef, reason: JSValue) void {
+                log("abortListener", .{});
+                reason.ensureStillAlive();
+                const stream = this.parser.streams.getEntry(this.stream_id) orelse return;
+                const value = stream.value_ptr;
+                if (value.state != .CLOSED) {
+                    this.parser.abortStream(value, reason);
+                }
+            }
+
+            pub fn deinit(this: *SignalRef) void {
+                this.signal.detach(this);
+                this.parser.deref();
+                this.destroy();
+            }
+        };
+        const PendingQueue = struct {
+            data: std.ArrayListUnmanaged(PendingFrame) = .{},
+            front: usize = 0,
+            len: usize = 0,
+
+            pub fn deinit(self: *PendingQueue, allocator: Allocator) void {
+                self.front = 0;
+                self.len = 0;
+                var data = self.data;
+                if (data.capacity > 0) {
+                    self.data = .{};
+                    data.clearAndFree(allocator);
+                }
+            }
+
+            pub fn enqueue(self: *PendingQueue, value: PendingFrame, allocator: Allocator) void {
+                self.data.append(allocator, value) catch bun.outOfMemory();
+                self.len += 1;
+                log("PendingQueue.enqueue {}", .{self.len});
+            }
+
+            pub fn peek(self: *PendingQueue) ?*PendingFrame {
+                if (self.len == 0) {
+                    return null;
+                }
+                return &self.data.items[0];
+            }
+
+            pub fn peekLast(self: *PendingQueue) ?*PendingFrame {
+                if (self.len == 0) {
+                    return null;
+                }
+                return &self.data.items[self.data.items.len - 1];
+            }
+
+            pub fn slice(self: *PendingQueue) []PendingFrame {
+                if (self.len == 0) return &.{};
+                return self.data.items[self.front..][0..self.len];
+            }
+
+            pub fn dequeue(self: *PendingQueue) ?PendingFrame {
+                if (self.len == 0) {
+                    log("PendingQueue.dequeue null", .{});
+                    return null;
+                }
+                const value = self.data.items[self.front];
+                self.data.items[self.front] = .{};
+                self.len -= 1;
+                if (self.len == 0) {
+                    self.front = 0;
+                    self.data.clearRetainingCapacity();
+                } else {
+                    self.front += 1;
+                }
+                log("PendingQueue.dequeue {}", .{self.len});
+
+                return value;
+            }
+
+            pub fn isEmpty(self: *PendingQueue) bool {
+                return self.len == 0;
+            }
+        };
+        const PendingFrame = struct {
+            end_stream: bool = false, // end_stream flag
+            len: u32 = 0, // actually payload size
+            buffer: []u8 = "", // allocated buffer if len > 0
+            callback: JSC.Strong = .{}, // JSCallback for done
+
+            pub fn deinit(this: *PendingFrame, allocator: Allocator) void {
+                if (this.buffer.len > 0) {
+                    allocator.free(this.buffer);
+                    this.buffer = "";
+                }
+                this.len = 0;
+                var callback = this.callback;
+                this.callback = .{};
+                callback.deinit();
+            }
+        };
+
+        pub fn getPadding(
+            this: *Stream,
+            frameLen: usize,
+            maxLen: usize,
+        ) u8 {
+            switch (this.paddingStrategy) {
+                .none => return 0,
+                .aligned => {
+                    const diff = (frameLen + 9) % 8;
+                    // already multiple of 8
+                    if (diff == 0) return 0;
+
+                    var paddedLen = frameLen + (8 - diff);
+                    // limit to maxLen
+                    paddedLen = @min(maxLen, paddedLen);
+                    return @min(paddedLen - frameLen, 255);
+                },
+                .max => return @min(maxLen - frameLen, 255),
+            }
+        }
+        pub fn flushQueue(this: *Stream, client: *H2FrameParser, written: *usize) FlushState {
+            if (this.canSendData()) {
+                // flush one frame
+                if (this.dataFrameQueue.dequeue()) |frame| {
+                    defer {
+                        var _frame = frame;
+                        if (_frame.callback.get()) |callback_value| client.dispatchWriteCallback(callback_value);
+                        _frame.deinit(client.allocator);
+                    }
+                    const no_backpressure = brk: {
+                        const writer = client.toWriter();
+
+                        if (frame.len == 0) {
+                            // flush a zero payload frame
+                            var dataHeader: FrameHeader = .{
+                                .type = @intFromEnum(FrameType.HTTP_FRAME_DATA),
+                                .flags = if (frame.end_stream and !this.waitForTrailers) @intFromEnum(DataFrameFlags.END_STREAM) else 0,
+                                .streamIdentifier = @intCast(this.id),
+                                .length = 0,
+                            };
+                            break :brk dataHeader.write(@TypeOf(writer), writer);
+                        } else {
+                            // flush with some payload
+                            client.queuedDataSize -= frame.len;
+                            const padding = this.getPadding(frame.len, MAX_PAYLOAD_SIZE_WITHOUT_FRAME - 1);
+                            const payload_size = frame.len + (if (padding != 0) padding + 1 else 0);
+                            var flags: u8 = if (frame.end_stream and !this.waitForTrailers) @intFromEnum(DataFrameFlags.END_STREAM) else 0;
+                            if (padding != 0) {
+                                flags |= @intFromEnum(DataFrameFlags.PADDED);
+                            }
+                            var dataHeader: FrameHeader = .{
+                                .type = @intFromEnum(FrameType.HTTP_FRAME_DATA),
+                                .flags = flags,
+                                .streamIdentifier = @intCast(this.id),
+                                .length = @intCast(payload_size),
+                            };
+                            _ = dataHeader.write(@TypeOf(writer), writer);
+                            if (padding != 0) {
+                                var buffer = shared_request_buffer[0..];
+                                bun.memmove(buffer[1..frame.len], buffer[0..frame.len]);
+                                buffer[0] = padding;
+                                break :brk (writer.write(buffer[0 .. FrameHeader.byteSize + payload_size]) catch 0) != 0;
+                            } else {
+                                break :brk (writer.write(frame.buffer[0..frame.len]) catch 0) != 0;
+                            }
+                        }
+                    };
+                    written.* += frame.len;
+                    log("dataFrame flushed {} {}", .{ frame.len, frame.end_stream });
+                    client.outboundQueueSize -= 1;
+                    if (this.dataFrameQueue.isEmpty()) {
+                        if (frame.end_stream) {
+                            if (this.waitForTrailers) {
+                                client.dispatch(.onWantTrailers, this.getIdentifier());
+                            } else {
+                                const identifier = this.getIdentifier();
+                                identifier.ensureStillAlive();
+                                if (this.state == .HALF_CLOSED_REMOTE) {
+                                    this.state = .CLOSED;
+                                } else {
+                                    this.state = .HALF_CLOSED_LOCAL;
+                                }
+                                client.dispatchWithExtra(.onStreamEnd, identifier, JSC.JSValue.jsNumber(@intFromEnum(this.state)));
+                            }
+                        }
+                    }
+                    return if (no_backpressure) .flushed else .backpressure;
+                }
+            }
+            // empty or cannot send data
+            return .no_action;
+        }
+
+        pub fn queueFrame(this: *Stream, client: *H2FrameParser, bytes: []const u8, callback: JSC.JSValue, end_stream: bool) void {
+            const globalThis = client.globalThis;
+
+            if (this.dataFrameQueue.peekLast()) |last_frame| {
+                if (bytes.len == 0) {
+                    // just merge the end_stream
+                    last_frame.end_stream = end_stream;
+                    // we can only hold 1 callback at a time so we conclude the last one, and keep the last one as pending
+                    // this is fine is like a per-stream CORKING in a frame level
+                    if (last_frame.callback.get()) |old_callback| {
+                        client.dispatchWriteCallback(old_callback);
+                        last_frame.callback.deinit();
+                    }
+                    last_frame.callback = JSC.Strong.create(callback, globalThis);
+                    return;
+                }
+                if (last_frame.len == 0) {
+                    // we have an empty frame with means we can just use this frame with a new buffer
+                    last_frame.buffer = client.allocator.alloc(u8, MAX_PAYLOAD_SIZE_WITHOUT_FRAME) catch bun.outOfMemory();
+                }
+                const max_size = MAX_PAYLOAD_SIZE_WITHOUT_FRAME;
+                const remaining = max_size - last_frame.len;
+                if (remaining > 0) {
+                    // ok we can cork frames
+                    const consumed_len = @min(remaining, bytes.len);
+                    const merge = bytes[0..consumed_len];
+                    @memcpy(last_frame.buffer[last_frame.len .. last_frame.len + consumed_len], merge);
+                    last_frame.len += @intCast(consumed_len);
+                    log("dataFrame merged {}", .{consumed_len});
+
+                    client.queuedDataSize += consumed_len;
+                    //lets fallthrough if we still have some data
+                    const more_data = bytes[consumed_len..];
+                    if (more_data.len == 0) {
+                        last_frame.end_stream = end_stream;
+                        // we can only hold 1 callback at a time so we conclude the last one, and keep the last one as pending
+                        // this is fine is like a per-stream CORKING in a frame level
+                        if (last_frame.callback.get()) |old_callback| {
+                            client.dispatchWriteCallback(old_callback);
+                            last_frame.callback.deinit();
+                        }
+                        last_frame.callback = JSC.Strong.create(callback, globalThis);
+                        return;
+                    }
+                    // we keep the old callback because the new will be part of another frame
+                    return this.queueFrame(client, more_data, callback, end_stream);
+                }
+            }
+            log("{s} queued {} {}", .{ if (client.isServer) "server" else "client", bytes.len, end_stream });
+
+            const frame: PendingFrame = .{
+                .end_stream = end_stream,
+                .len = @intCast(bytes.len),
+                // we need to clone this data to send it later
+                .buffer = if (bytes.len == 0) "" else client.allocator.alloc(u8, MAX_PAYLOAD_SIZE_WITHOUT_FRAME) catch bun.outOfMemory(),
+                .callback = if (callback.isCallable(globalThis.vm())) JSC.Strong.create(callback, globalThis) else .{},
+            };
+            if (bytes.len > 0) {
+                @memcpy(frame.buffer[0..bytes.len], bytes);
+                client.globalThis.vm().reportExtraMemory(bytes.len);
+            }
+            log("dataFrame enqueued {}", .{frame.len});
+            this.dataFrameQueue.enqueue(frame, client.allocator);
+            client.outboundQueueSize += 1;
+            client.queuedDataSize += frame.len;
+        }
+
+        pub fn init(streamIdentifier: u32, initialWindowSize: u32) Stream {
             const stream = Stream{
                 .id = streamIdentifier,
                 .state = .OPEN,
                 .windowSize = initialWindowSize,
                 .usedWindowSize = 0,
                 .weight = 36,
-                .client = client,
+                .dataFrameQueue = .{},
             };
             return stream;
         }
@@ -601,30 +1043,68 @@ pub const H2FrameParser = struct {
 
         pub fn canSendData(this: *Stream) bool {
             return switch (this.state) {
-                .IDLE, .RESERVED_LOCAL, .RESERVED_REMOTE, .OPEN, .HALF_CLOSED_REMOTE => false,
-                .HALF_CLOSED_LOCAL, .CLOSED => true,
+                .IDLE, .RESERVED_LOCAL, .RESERVED_REMOTE, .OPEN, .HALF_CLOSED_REMOTE => true,
+                .HALF_CLOSED_LOCAL, .CLOSED => false,
             };
         }
 
-        pub fn attachSignal(this: *Stream, signal: *JSC.WebCore.AbortSignal) void {
-            this.signal = signal.ref().listen(Stream, this, Stream.abortListener);
+        pub fn setContext(this: *Stream, value: JSValue, globalObject: *JSC.JSGlobalObject) void {
+            var context = this.jsContext;
+            defer context.deinit();
+            this.jsContext = JSC.Strong.create(value, globalObject);
         }
 
-        pub fn abortListener(this: *Stream, reason: JSValue) void {
-            log("abortListener", .{});
-            reason.ensureStillAlive();
-            if (this.canReceiveData() or this.canSendData()) {
-                this.state = .CLOSED;
-                this.client.endStream(this, .CANCEL);
-                this.client.dispatchWithExtra(.onAborted, JSC.JSValue.jsNumber(this.id), reason);
+        pub fn getIdentifier(this: *const Stream) JSValue {
+            return this.jsContext.get() orelse return JSC.JSValue.jsNumber(this.id);
+        }
+
+        pub fn attachSignal(this: *Stream, parser: *H2FrameParser, signal: *JSC.WebCore.AbortSignal) void {
+            // we need a stable pointer to know what signal points to what stream_id + parser
+            var signal_ref = SignalRef.new(.{
+                .signal = signal,
+                .parser = parser,
+                .stream_id = this.id,
+            });
+            signal_ref.signal = signal.ref().listen(SignalRef, signal_ref, SignalRef.abortListener);
+            //TODO: We should not need this ref counting here, since Parser owns Stream
+            parser.ref();
+            this.signal = signal_ref;
+        }
+
+        pub fn detachContext(this: *Stream) void {
+            var context = this.jsContext;
+            defer context.deinit();
+            this.jsContext = .{};
+        }
+
+        fn cleanQueue(this: *Stream, client: *H2FrameParser, comptime finalizing: bool) void {
+            log("cleanQueue len: {} front: {} outboundQueueSize: {}", .{ this.dataFrameQueue.len, this.dataFrameQueue.front, client.outboundQueueSize });
+
+            var queue = this.dataFrameQueue;
+            this.dataFrameQueue = .{};
+            defer {
+                queue.deinit(client.allocator);
+            }
+            while (queue.dequeue()) |item| {
+                var frame = item;
+                log("dataFrame dropped {}", .{frame.len});
+                client.queuedDataSize -= frame.len;
+                if (!finalizing) {
+                    if (frame.callback.get()) |callback_value| client.dispatchWriteCallback(callback_value);
+                }
+                frame.deinit(client.allocator);
+                client.outboundQueueSize -= 1;
             }
         }
-
-        pub fn deinit(this: *Stream) void {
+        /// this can be called multiple times
+        pub fn freeResources(this: *Stream, client: *H2FrameParser, comptime finalizing: bool) void {
+            this.detachContext();
+            this.cleanQueue(client, finalizing);
             if (this.signal) |signal| {
                 this.signal = null;
-                signal.detach(this);
+                signal.deinit();
             }
+            JSC.VirtualMachine.get().eventLoop().processGCTimer();
         }
     };
 
@@ -646,7 +1126,7 @@ pub const H2FrameParser = struct {
 
     /// Calculate the new window size for the connection and the stream
     /// https://datatracker.ietf.org/doc/html/rfc7540#section-6.9.1
-    fn ajustWindowSize(this: *H2FrameParser, stream: ?*Stream, payloadSize: u32) void {
+    fn ajustWindowSize(this: *H2FrameParser, stream: ?*Stream, payloadSize: u32) bool {
         this.usedWindowSize += payloadSize;
         if (this.usedWindowSize >= this.windowSize) {
             var increment_size: u32 = WINDOW_INCREMENT_SIZE;
@@ -656,8 +1136,8 @@ pub const H2FrameParser = struct {
                 increment_size = this.windowSize -| MAX_WINDOW_SIZE;
             }
             if (new_size == this.windowSize) {
-                this.sendGoAway(0, .FLOW_CONTROL_ERROR, "Window size overflow", this.lastStreamID);
-                return;
+                this.sendGoAway(0, .FLOW_CONTROL_ERROR, "Window size overflow", this.lastStreamID, true);
+                return false;
             }
             this.windowSize = new_size;
             this.sendWindowUpdate(0, UInt31WithReserved.from(increment_size));
@@ -676,9 +1156,12 @@ pub const H2FrameParser = struct {
                 this.sendWindowUpdate(s.id, UInt31WithReserved.from(increment_size));
             }
         }
+        return true;
     }
 
     pub fn setSettings(this: *H2FrameParser, settings: FullSettingsPayload) void {
+        log("HTTP_FRAME_SETTINGS ack false", .{});
+
         var buffer: [FrameHeader.byteSize + FullSettingsPayload.byteSize]u8 = undefined;
         @memset(&buffer, 0);
         var stream = std.io.fixedBufferStream(&buffer);
@@ -689,14 +1172,17 @@ pub const H2FrameParser = struct {
             .streamIdentifier = 0,
             .length = 36,
         };
-        settingsHeader.write(@TypeOf(writer), writer);
+        _ = settingsHeader.write(@TypeOf(writer), writer);
         this.localSettings = settings;
-        this.localSettings.write(@TypeOf(writer), writer);
-        this.write(&buffer);
-        this.ajustWindowSize(null, @intCast(buffer.len));
+        _ = this.localSettings.write(@TypeOf(writer), writer);
+        _ = this.write(&buffer);
+        _ = this.ajustWindowSize(null, @intCast(buffer.len));
     }
 
-    pub fn endStream(this: *H2FrameParser, stream: *Stream, rstCode: ErrorCode) void {
+    pub fn abortStream(this: *H2FrameParser, stream: *Stream, abortReason: JSC.JSValue) void {
+        log("HTTP_FRAME_RST_STREAM id: {} code: CANCEL", .{stream.id});
+
+        abortReason.ensureStillAlive();
         var buffer: [FrameHeader.byteSize + 4]u8 = undefined;
         @memset(&buffer, 0);
         var writerStream = std.io.fixedBufferStream(&buffer);
@@ -708,23 +1194,54 @@ pub const H2FrameParser = struct {
             .streamIdentifier = stream.id,
             .length = 4,
         };
-        frame.write(@TypeOf(writer), writer);
+        _ = frame.write(@TypeOf(writer), writer);
+        var value: u32 = @intFromEnum(ErrorCode.CANCEL);
+        stream.rstCode = value;
+        value = @byteSwap(value);
+        _ = writer.write(std.mem.asBytes(&value)) catch 0;
+        const old_state = stream.state;
+        stream.state = .CLOSED;
+        const identifier = stream.getIdentifier();
+        identifier.ensureStillAlive();
+        stream.freeResources(this, false);
+        this.dispatchWith2Extra(.onAborted, identifier, abortReason, JSC.JSValue.jsNumber(@intFromEnum(old_state)));
+        _ = this.write(&buffer);
+    }
+
+    pub fn endStream(this: *H2FrameParser, stream: *Stream, rstCode: ErrorCode) void {
+        log("HTTP_FRAME_RST_STREAM id: {} code: {}", .{ stream.id, @intFromEnum(rstCode) });
+        var buffer: [FrameHeader.byteSize + 4]u8 = undefined;
+        @memset(&buffer, 0);
+        var writerStream = std.io.fixedBufferStream(&buffer);
+        const writer = writerStream.writer();
+
+        var frame: FrameHeader = .{
+            .type = @intFromEnum(FrameType.HTTP_FRAME_RST_STREAM),
+            .flags = 0,
+            .streamIdentifier = stream.id,
+            .length = 4,
+        };
+        _ = frame.write(@TypeOf(writer), writer);
         var value: u32 = @intFromEnum(rstCode);
         stream.rstCode = value;
         value = @byteSwap(value);
         _ = writer.write(std.mem.asBytes(&value)) catch 0;
 
         stream.state = .CLOSED;
+        const identifier = stream.getIdentifier();
+        identifier.ensureStillAlive();
+        stream.freeResources(this, false);
         if (rstCode == .NO_ERROR) {
-            this.dispatchWithExtra(.onStreamEnd, JSC.JSValue.jsNumber(stream.id), .undefined);
+            this.dispatchWithExtra(.onStreamEnd, identifier, JSC.JSValue.jsNumber(@intFromEnum(stream.state)));
         } else {
-            this.dispatchWithExtra(.onStreamError, JSC.JSValue.jsNumber(stream.id), JSC.JSValue.jsNumber(@intFromEnum(rstCode)));
+            this.dispatchWithExtra(.onStreamError, identifier, JSC.JSValue.jsNumber(@intFromEnum(rstCode)));
         }
 
-        this.write(&buffer);
+        _ = this.write(&buffer);
     }
 
-    pub fn sendGoAway(this: *H2FrameParser, streamIdentifier: u32, rstCode: ErrorCode, debug_data: []const u8, lastStreamID: u32) void {
+    pub fn sendGoAway(this: *H2FrameParser, streamIdentifier: u32, rstCode: ErrorCode, debug_data: []const u8, lastStreamID: u32, emitError: bool) void {
+        log("HTTP_FRAME_GOAWAY {} code {} debug_data {s} emitError {}", .{ streamIdentifier, rstCode, debug_data, emitError });
         var buffer: [FrameHeader.byteSize + 8]u8 = undefined;
         @memset(&buffer, 0);
         var stream = std.io.fixedBufferStream(&buffer);
@@ -736,41 +1253,49 @@ pub const H2FrameParser = struct {
             .streamIdentifier = streamIdentifier,
             .length = @intCast(8 + debug_data.len),
         };
-        frame.write(@TypeOf(writer), writer);
+        _ = frame.write(@TypeOf(writer), writer);
         var last_id = UInt31WithReserved.from(lastStreamID);
-        last_id.write(@TypeOf(writer), writer);
+        _ = last_id.write(@TypeOf(writer), writer);
         var value: u32 = @intFromEnum(rstCode);
         value = @byteSwap(value);
         _ = writer.write(std.mem.asBytes(&value)) catch 0;
 
-        this.write(&buffer);
+        _ = this.write(&buffer);
         if (debug_data.len > 0) {
-            this.write(debug_data);
+            _ = this.write(debug_data);
         }
-        const chunk = this.handlers.binary_type.toJS(debug_data, this.handlers.globalObject);
-        if (rstCode != .NO_ERROR) {
-            this.dispatchWith2Extra(.onError, JSC.JSValue.jsNumber(@intFromEnum(rstCode)), JSC.JSValue.jsNumber(this.lastStreamID), chunk);
+        if (emitError) {
+            const chunk = this.handlers.binary_type.toJS(debug_data, this.handlers.globalObject);
+            if (rstCode != .NO_ERROR) {
+                this.dispatchWith2Extra(.onError, JSC.JSValue.jsNumber(@intFromEnum(rstCode)), JSC.JSValue.jsNumber(this.lastStreamID), chunk);
+            }
+            this.dispatchWithExtra(.onEnd, JSC.JSValue.jsNumber(this.lastStreamID), chunk);
         }
-        this.dispatchWithExtra(.onEnd, JSC.JSValue.jsNumber(this.lastStreamID), chunk);
     }
 
     pub fn sendPing(this: *H2FrameParser, ack: bool, payload: []const u8) void {
+        log("HTTP_FRAME_PING ack {} payload {s}", .{ ack, payload });
+
         var buffer: [FrameHeader.byteSize + 8]u8 = undefined;
         @memset(&buffer, 0);
         var stream = std.io.fixedBufferStream(&buffer);
         const writer = stream.writer();
+        if (!ack) {
+            this.outStandingPings += 1;
+        }
         var frame = FrameHeader{
             .type = @intFromEnum(FrameType.HTTP_FRAME_PING),
             .flags = if (ack) @intFromEnum(PingFrameFlags.ACK) else 0,
             .streamIdentifier = 0,
             .length = 8,
         };
-        frame.write(@TypeOf(writer), writer);
+        _ = frame.write(@TypeOf(writer), writer);
         _ = writer.write(payload) catch 0;
-        this.write(&buffer);
+        _ = this.write(&buffer);
     }
 
     pub fn sendPrefaceAndSettings(this: *H2FrameParser) void {
+        log("sendPrefaceAndSettings", .{});
         // PREFACE + Settings Frame
         var preface_buffer: [24 + FrameHeader.byteSize + FullSettingsPayload.byteSize]u8 = undefined;
         @memset(&preface_buffer, 0);
@@ -783,14 +1308,31 @@ pub const H2FrameParser = struct {
             .streamIdentifier = 0,
             .length = 36,
         };
-        settingsHeader.write(@TypeOf(writer), writer);
-        this.localSettings.write(@TypeOf(writer), writer);
-        this.write(&preface_buffer);
-        this.ajustWindowSize(null, @intCast(preface_buffer.len));
+        _ = settingsHeader.write(@TypeOf(writer), writer);
+        _ = this.localSettings.write(@TypeOf(writer), writer);
+        _ = this.write(&preface_buffer);
+        _ = this.ajustWindowSize(null, @intCast(preface_buffer.len));
+    }
+
+    pub fn sendSettingsACK(this: *H2FrameParser) void {
+        log("HTTP_FRAME_SETTINGS ack true", .{});
+        var buffer: [FrameHeader.byteSize]u8 = undefined;
+        @memset(&buffer, 0);
+        var stream = std.io.fixedBufferStream(&buffer);
+        const writer = stream.writer();
+        var settingsHeader: FrameHeader = .{
+            .type = @intFromEnum(FrameType.HTTP_FRAME_SETTINGS),
+            .flags = @intFromEnum(SettingsFlags.ACK),
+            .streamIdentifier = 0,
+            .length = 0,
+        };
+        _ = settingsHeader.write(@TypeOf(writer), writer);
+        _ = this.write(&buffer);
+        _ = this.ajustWindowSize(null, @intCast(buffer.len));
     }
 
     pub fn sendWindowUpdate(this: *H2FrameParser, streamIdentifier: u32, windowSize: UInt31WithReserved) void {
-        log("sendWindowUpdate stream {} size {}", .{ streamIdentifier, windowSize.uint31 });
+        log("HTTP_FRAME_WINDOW_UPDATE stream {} size {}", .{ streamIdentifier, windowSize.uint31 });
         var buffer: [FrameHeader.byteSize + 4]u8 = undefined;
         @memset(&buffer, 0);
         var stream = std.io.fixedBufferStream(&buffer);
@@ -801,25 +1343,39 @@ pub const H2FrameParser = struct {
             .streamIdentifier = streamIdentifier,
             .length = 4,
         };
-        settingsHeader.write(@TypeOf(writer), writer);
+        _ = settingsHeader.write(@TypeOf(writer), writer);
         // always clear reserved bit
         const cleanWindowSize: UInt31WithReserved = .{
             .reserved = false,
             .uint31 = windowSize.uint31,
         };
-        cleanWindowSize.write(@TypeOf(writer), writer);
-        this.write(&buffer);
+        _ = cleanWindowSize.write(@TypeOf(writer), writer);
+        _ = this.write(&buffer);
     }
 
     pub fn dispatch(this: *H2FrameParser, comptime event: @Type(.EnumLiteral), value: JSC.JSValue) void {
         JSC.markBinding(@src());
+
         const ctx_value = this.strong_ctx.get() orelse return;
         value.ensureStillAlive();
         _ = this.handlers.callEventHandler(event, ctx_value, &[_]JSC.JSValue{ ctx_value, value });
     }
 
+    pub fn call(this: *H2FrameParser, comptime event: @Type(.EnumLiteral), value: JSC.JSValue) JSValue {
+        JSC.markBinding(@src());
+
+        const ctx_value = this.strong_ctx.get() orelse return .zero;
+        value.ensureStillAlive();
+        return this.handlers.callEventHandlerWithResult(event, ctx_value, &[_]JSC.JSValue{ ctx_value, value });
+    }
+    pub fn dispatchWriteCallback(this: *H2FrameParser, callback: JSC.JSValue) void {
+        JSC.markBinding(@src());
+
+        _ = this.handlers.callWriteCallback(callback, &[_]JSC.JSValue{});
+    }
     pub fn dispatchWithExtra(this: *H2FrameParser, comptime event: @Type(.EnumLiteral), value: JSC.JSValue, extra: JSC.JSValue) void {
         JSC.markBinding(@src());
+
         const ctx_value = this.strong_ctx.get() orelse return;
         value.ensureStillAlive();
         extra.ensureStillAlive();
@@ -828,23 +1384,273 @@ pub const H2FrameParser = struct {
 
     pub fn dispatchWith2Extra(this: *H2FrameParser, comptime event: @Type(.EnumLiteral), value: JSC.JSValue, extra: JSC.JSValue, extra2: JSC.JSValue) void {
         JSC.markBinding(@src());
+
         const ctx_value = this.strong_ctx.get() orelse return;
         value.ensureStillAlive();
         extra.ensureStillAlive();
         extra2.ensureStillAlive();
         _ = this.handlers.callEventHandler(event, ctx_value, &[_]JSC.JSValue{ ctx_value, value, extra, extra2 });
     }
+    pub fn dispatchWith3Extra(this: *H2FrameParser, comptime event: @Type(.EnumLiteral), value: JSC.JSValue, extra: JSC.JSValue, extra2: JSC.JSValue, extra3: JSC.JSValue) void {
+        JSC.markBinding(@src());
 
-    fn bufferWrite(this: *H2FrameParser, bytes: []const u8) void {
-        log("bufferWrite", .{});
-        _ = this.writeBuffer.write(this.allocator, bytes) catch 0;
+        const ctx_value = this.strong_ctx.get() orelse return;
+        value.ensureStillAlive();
+        extra.ensureStillAlive();
+        extra2.ensureStillAlive();
+        extra3.ensureStillAlive();
+        _ = this.handlers.callEventHandler(event, ctx_value, &[_]JSC.JSValue{ ctx_value, value, extra, extra2, extra3 });
+    }
+    fn cork(this: *H2FrameParser) void {
+        if (CORKED_H2) |corked| {
+            if (@intFromPtr(corked) == @intFromPtr(this)) {
+                // already corked
+                return;
+            }
+            // force uncork
+            corked.flushCorked();
+        }
+        // cork
+        CORKED_H2 = this;
+        log("cork {*}", .{this});
+        CORK_OFFSET = 0;
     }
 
-    pub fn write(this: *H2FrameParser, bytes: []const u8) void {
+    pub fn _genericFlush(this: *H2FrameParser, comptime T: type, socket: T) usize {
+        const buffer = this.writeBuffer.slice()[this.writeBufferOffset..];
+        if (buffer.len > 0) {
+            const result: i32 = socket.writeMaybeCorked(buffer, false);
+            const written: u32 = if (result < 0) 0 else @intCast(result);
+
+            if (written < buffer.len) {
+                this.writeBufferOffset += written;
+                log("_genericFlush {}", .{written});
+                return written;
+            }
+
+            // all the buffer was written! reset things
+            this.writeBufferOffset = 0;
+            this.writeBuffer.len = 0;
+            // lets keep size under control
+            if (this.writeBuffer.cap > MAX_BUFFER_SIZE) {
+                this.writeBuffer.len = MAX_BUFFER_SIZE;
+                this.writeBuffer.shrinkAndFree(this.allocator, MAX_BUFFER_SIZE);
+                this.writeBuffer.clearRetainingCapacity();
+            }
+            log("_genericFlush {}", .{buffer.len});
+        } else {
+            log("_genericFlush 0", .{});
+        }
+        return buffer.len;
+    }
+
+    pub fn _genericWrite(this: *H2FrameParser, comptime T: type, socket: T, bytes: []const u8) bool {
+        log("_genericWrite {}", .{bytes.len});
+
+        const buffer = this.writeBuffer.slice()[this.writeBufferOffset..];
+        if (buffer.len > 0) {
+            {
+                const result: i32 = socket.writeMaybeCorked(buffer, false);
+                const written: u32 = if (result < 0) 0 else @intCast(result);
+                if (written < buffer.len) {
+                    this.writeBufferOffset += written;
+
+                    // we still have more to buffer and even more now
+                    _ = this.writeBuffer.write(this.allocator, bytes) catch bun.outOfMemory();
+                    this.globalThis.vm().reportExtraMemory(bytes.len);
+
+                    log("_genericWrite flushed {} and buffered more {}", .{ written, bytes.len });
+                    return false;
+                }
+            }
+            // all the buffer was written!
+            this.writeBufferOffset = 0;
+            this.writeBuffer.len = 0;
+            {
+                const result: i32 = socket.writeMaybeCorked(bytes, false);
+                const written: u32 = if (result < 0) 0 else @intCast(result);
+                if (written < bytes.len) {
+                    const pending = bytes[written..];
+                    // ops not all data was sent, lets buffer again
+                    _ = this.writeBuffer.write(this.allocator, pending) catch bun.outOfMemory();
+                    this.globalThis.vm().reportExtraMemory(pending.len);
+
+                    log("_genericWrite buffered more {}", .{pending.len});
+                    return false;
+                }
+            }
+            // lets keep size under control
+            if (this.writeBuffer.cap > MAX_BUFFER_SIZE) {
+                this.writeBuffer.len = MAX_BUFFER_SIZE;
+                this.writeBuffer.shrinkAndFree(this.allocator, MAX_BUFFER_SIZE);
+                this.writeBuffer.clearRetainingCapacity();
+            }
+            return true;
+        }
+        const result: i32 = socket.writeMaybeCorked(bytes, false);
+        const written: u32 = if (result < 0) 0 else @intCast(result);
+        if (written < bytes.len) {
+            const pending = bytes[written..];
+            // ops not all data was sent, lets buffer again
+            _ = this.writeBuffer.write(this.allocator, pending) catch bun.outOfMemory();
+            this.globalThis.vm().reportExtraMemory(pending.len);
+
+            return false;
+        }
+        return true;
+    }
+    /// be sure that we dont have any backpressure/data queued on writerBuffer before calling this
+    fn flushStreamQueue(this: *H2FrameParser) usize {
+        log("flushStreamQueue {}", .{this.outboundQueueSize});
+        var written: usize = 0;
+        // try to send as much as we can until we reach backpressure
+        while (this.outboundQueueSize > 0) {
+            var it = StreamResumableIterator.init(this);
+            while (it.next()) |stream| {
+                // reach backpressure
+                const result = stream.flushQueue(this, &written);
+                switch (result) {
+                    .flushed, .no_action => continue, // we can continue
+                    .backpressure => return written, // backpressure we need to return
+                }
+            }
+        }
+        return written;
+    }
+
+    pub fn flush(this: *H2FrameParser) usize {
+        this.ref();
+        defer this.deref();
+        var written = switch (this.native_socket) {
+            .tls_writeonly, .tls => |socket| this._genericFlush(*TLSSocket, socket),
+            .tcp_writeonly, .tcp => |socket| this._genericFlush(*TCPSocket, socket),
+            else => {
+                // consider that backpressure is gone and flush data queue
+                this.has_nonnative_backpressure = false;
+                const bytes = this.writeBuffer.slice();
+                if (bytes.len > 0) {
+                    defer {
+                        // all the buffer was written/queued! reset things
+                        this.writeBufferOffset = 0;
+                        this.writeBuffer.len = 0;
+                        // lets keep size under control
+                        if (this.writeBuffer.cap > MAX_BUFFER_SIZE) {
+                            this.writeBuffer.len = MAX_BUFFER_SIZE;
+                            this.writeBuffer.shrinkAndFree(this.allocator, MAX_BUFFER_SIZE);
+                            this.writeBuffer.clearRetainingCapacity();
+                        }
+                    }
+                    const output_value = this.handlers.binary_type.toJS(bytes, this.handlers.globalObject);
+                    const result = this.call(.onWrite, output_value);
+                    if (result.isBoolean() and !result.toBoolean()) {
+                        this.has_nonnative_backpressure = true;
+                        return bytes.len;
+                    }
+                }
+
+                return this.flushStreamQueue();
+            },
+        };
+        // if no backpressure flush data queue
+        if (!this.hasBackpressure()) {
+            written += this.flushStreamQueue();
+        }
+        return written;
+    }
+
+    pub fn _write(this: *H2FrameParser, bytes: []const u8) bool {
+        this.ref();
+        defer this.deref();
+        return switch (this.native_socket) {
+            .tls_writeonly, .tls => |socket| this._genericWrite(*TLSSocket, socket, bytes),
+            .tcp_writeonly, .tcp => |socket| this._genericWrite(*TCPSocket, socket, bytes),
+            else => {
+                if (this.has_nonnative_backpressure) {
+                    // we should not invoke JS when we have backpressure is cheaper to keep it queued here
+                    _ = this.writeBuffer.write(this.allocator, bytes) catch bun.outOfMemory();
+                    this.globalThis.vm().reportExtraMemory(bytes.len);
+
+                    return false;
+                }
+                // fallback to onWrite non-native callback
+                const output_value = this.handlers.binary_type.toJS(bytes, this.handlers.globalObject);
+                const result = this.call(.onWrite, output_value);
+                const code = if (result.isNumber()) result.to(i32) else -1;
+                switch (code) {
+                    -1 => {
+                        // dropped
+                        _ = this.writeBuffer.write(this.allocator, bytes) catch bun.outOfMemory();
+                        this.globalThis.vm().reportExtraMemory(bytes.len);
+                        this.has_nonnative_backpressure = true;
+                    },
+                    0 => {
+                        // queued
+                        this.has_nonnative_backpressure = true;
+                    },
+                    else => {
+                        // sended!
+                        return true;
+                    },
+                }
+                return false;
+            },
+        };
+    }
+
+    fn hasBackpressure(this: *H2FrameParser) bool {
+        return this.writeBuffer.len > 0 or this.has_nonnative_backpressure;
+    }
+
+    fn flushCorked(this: *H2FrameParser) void {
+        if (CORKED_H2) |corked| {
+            if (@intFromPtr(corked) == @intFromPtr(this)) {
+                log("uncork {*}", .{this});
+
+                const bytes = CORK_BUFFER[0..CORK_OFFSET];
+                CORK_OFFSET = 0;
+                if (bytes.len > 0) {
+                    _ = this._write(bytes);
+                }
+            }
+        }
+    }
+
+    fn onAutoUncork(this: *H2FrameParser) void {
+        this.autouncork_registered = false;
+        this.flushCorked();
+        this.deref();
+    }
+
+    pub fn write(this: *H2FrameParser, bytes: []const u8) bool {
         JSC.markBinding(@src());
-        log("write", .{});
-        const output_value = this.handlers.binary_type.toJS(bytes, this.handlers.globalObject);
-        this.dispatch(.onWrite, output_value);
+        log("write {}", .{bytes.len});
+        if (comptime ENABLE_AUTO_CORK) {
+            this.cork();
+            const available = CORK_BUFFER[CORK_OFFSET..];
+            if (bytes.len > available.len) {
+                // not worth corking
+                if (CORK_OFFSET != 0) {
+                    // clean already corked data
+                    this.flushCorked();
+                }
+                return this._write(bytes);
+            } else {
+                // write at the cork buffer
+                CORK_OFFSET += @truncate(bytes.len);
+                @memcpy(available[0..bytes.len], bytes);
+
+                // register auto uncork
+                if (!this.autouncork_registered) {
+                    this.autouncork_registered = true;
+                    this.ref();
+                    bun.uws.Loop.get().nextTick(*H2FrameParser, this, H2FrameParser.onAutoUncork);
+                }
+                // corked
+                return true;
+            }
+        } else {
+            return this._write(bytes);
+        }
     }
 
     const Payload = struct {
@@ -861,9 +1667,11 @@ pub const H2FrameParser = struct {
         if (this.remainingLength > 0) {
             // buffer more data
             _ = this.readBuffer.appendSlice(payload) catch bun.outOfMemory();
+            this.globalThis.vm().reportExtraMemory(payload.len);
+
             return null;
         } else if (this.remainingLength < 0) {
-            this.sendGoAway(streamIdentifier, ErrorCode.FRAME_SIZE_ERROR, "Invalid frame size", this.lastStreamID);
+            this.sendGoAway(streamIdentifier, ErrorCode.FRAME_SIZE_ERROR, "Invalid frame size", this.lastStreamID, true);
             return null;
         }
 
@@ -872,6 +1680,8 @@ pub const H2FrameParser = struct {
         if (this.readBuffer.list.items.len > 0) {
             // return buffered data
             _ = this.readBuffer.appendSlice(payload) catch bun.outOfMemory();
+            this.globalThis.vm().reportExtraMemory(payload.len);
+
             return .{
                 .data = this.readBuffer.list.items,
                 .end = end,
@@ -887,7 +1697,7 @@ pub const H2FrameParser = struct {
     pub fn handleWindowUpdateFrame(this: *H2FrameParser, frame: FrameHeader, data: []const u8, stream: ?*Stream) usize {
         // must be always 4 bytes (https://datatracker.ietf.org/doc/html/rfc7540#section-6.9)
         if (frame.length != 4) {
-            this.sendGoAway(frame.streamIdentifier, ErrorCode.FRAME_SIZE_ERROR, "Invalid dataframe frame size", this.lastStreamID);
+            this.sendGoAway(frame.streamIdentifier, ErrorCode.FRAME_SIZE_ERROR, "Invalid dataframe frame size", this.lastStreamID, true);
             return data.len;
         }
 
@@ -895,8 +1705,10 @@ pub const H2FrameParser = struct {
             const payload = content.data;
             const windowSizeIncrement = UInt31WithReserved.fromBytes(payload);
             this.readBuffer.reset();
-            // we automatically send a window update when receiving one
-            this.sendWindowUpdate(frame.streamIdentifier, windowSizeIncrement);
+            // we automatically send a window update when receiving one if we are a client
+            if (!this.isServer) {
+                this.sendWindowUpdate(frame.streamIdentifier, windowSizeIncrement);
+            }
             if (stream) |s| {
                 s.windowSize += windowSizeIncrement.uint31;
             } else {
@@ -909,42 +1721,60 @@ pub const H2FrameParser = struct {
         return data.len;
     }
 
-    pub fn decodeHeaderBlock(this: *H2FrameParser, payload: []const u8, stream_id: u32, flags: u8) void {
-        log("decodeHeaderBlock", .{});
+    pub fn decodeHeaderBlock(this: *H2FrameParser, payload: []const u8, stream: *Stream, flags: u8) ?*Stream {
+        log("decodeHeaderBlock isSever: {}", .{this.isServer});
 
         var offset: usize = 0;
-
         const globalObject = this.handlers.globalObject;
 
-        const headers = JSC.JSValue.createEmptyObject(globalObject, 0);
+        const stream_id = stream.id;
+        const headers = JSC.JSValue.createEmptyArray(globalObject, 0);
+        headers.ensureStillAlive();
+
+        var sensitiveHeaders = JSC.JSValue.jsUndefined();
+        var count: usize = 0;
+
         while (true) {
             const header = this.decode(payload[offset..]) catch break;
             offset += header.next;
             log("header {s} {s}", .{ header.name, header.value });
+            if (this.isServer and strings.eqlComptime(header.name, ":status")) {
+                this.sendGoAway(stream_id, ErrorCode.PROTOCOL_ERROR, "Server received :status header", this.lastStreamID, true);
 
-            if (headers.getTruthy(globalObject, header.name)) |current_value| {
-                // Duplicated of single value headers are discarded
-                if (SingleValueHeaders.has(header.name)) {
-                    continue;
-                }
-
-                const value = JSC.ZigString.fromUTF8(header.value).toJS(globalObject);
-
-                if (current_value.jsType().isArray()) {
-                    current_value.push(globalObject, value);
+                if (this.streams.getEntry(stream_id)) |entry| return entry.value_ptr;
+                return null;
+            }
+            count += 1;
+            if (this.maxHeaderListPairs < count) {
+                this.rejectedStreams += 1;
+                if (this.maxRejectedStreams <= this.rejectedStreams) {
+                    this.sendGoAway(stream_id, ErrorCode.ENHANCE_YOUR_CALM, "ENHANCE_YOUR_CALM", this.lastStreamID, true);
                 } else {
-                    const array = JSC.JSValue.createEmptyArray(globalObject, 2);
-                    array.putIndex(globalObject, 0, current_value);
-                    array.putIndex(globalObject, 1, value);
-                    // TODO: check for well-known headers and use pre-allocated static strings (see lshpack.c)
-                    const name = JSC.ZigString.fromUTF8(header.name);
-                    headers.put(globalObject, &name, array);
+                    this.endStream(stream, ErrorCode.ENHANCE_YOUR_CALM);
                 }
+                if (this.streams.getEntry(stream_id)) |entry| return entry.value_ptr;
+                return null;
+            }
+
+            const output = brk: {
+                if (header.never_index) {
+                    if (sensitiveHeaders.isUndefined()) {
+                        sensitiveHeaders = JSC.JSValue.createEmptyArray(globalObject, 0);
+                        sensitiveHeaders.ensureStillAlive();
+                    }
+                    break :brk sensitiveHeaders;
+                } else break :brk headers;
+            };
+
+            if (getHTTP2CommonString(globalObject, header.well_know)) |header_info| {
+                output.push(globalObject, header_info);
+                var header_value = bun.String.fromUTF8(header.value);
+                output.push(globalObject, header_value.transferToJS(globalObject));
             } else {
-                // TODO: check for well-known headers and use pre-allocated static strings (see lshpack.c)
-                const name = JSC.ZigString.fromUTF8(header.name);
-                const value = JSC.ZigString.fromUTF8(header.value).toJS(globalObject);
-                headers.put(globalObject, &name, value);
+                var header_name = bun.String.fromUTF8(header.name);
+                output.push(globalObject, header_name.transferToJS(globalObject));
+                var header_value = bun.String.fromUTF8(header.value);
+                output.push(globalObject, header_value.transferToJS(globalObject));
             }
 
             if (offset >= payload.len) {
@@ -952,19 +1782,24 @@ pub const H2FrameParser = struct {
             }
         }
 
-        this.dispatchWith2Extra(.onStreamHeaders, JSC.JSValue.jsNumber(stream_id), headers, JSC.JSValue.jsNumber(flags));
+        this.dispatchWith3Extra(.onStreamHeaders, stream.getIdentifier(), headers, sensitiveHeaders, JSC.JSValue.jsNumber(flags));
+        // callbacks can change the Stream ptr in this case we always return the new one
+        if (this.streams.getEntry(stream_id)) |entry| return entry.value_ptr;
+        return null;
     }
 
     pub fn handleDataFrame(this: *H2FrameParser, frame: FrameHeader, data: []const u8, stream_: ?*Stream) usize {
+        log("handleDataFrame {s}", .{if (this.isServer) "server" else "client"});
+
         var stream = stream_ orelse {
-            this.sendGoAway(frame.streamIdentifier, ErrorCode.PROTOCOL_ERROR, "Data frame on connection stream", this.lastStreamID);
+            this.sendGoAway(frame.streamIdentifier, ErrorCode.PROTOCOL_ERROR, "Data frame on connection stream", this.lastStreamID, true);
             return data.len;
         };
 
         const settings = this.remoteSettings orelse this.localSettings;
 
         if (frame.length > settings.maxFrameSize) {
-            this.sendGoAway(frame.streamIdentifier, ErrorCode.FRAME_SIZE_ERROR, "Invalid dataframe frame size", this.lastStreamID);
+            this.sendGoAway(frame.streamIdentifier, ErrorCode.FRAME_SIZE_ERROR, "Invalid dataframe frame size", this.lastStreamID, true);
             return data.len;
         }
 
@@ -996,70 +1831,81 @@ pub const H2FrameParser = struct {
         }
 
         if (this.remainingLength < 0) {
-            this.sendGoAway(frame.streamIdentifier, ErrorCode.FRAME_SIZE_ERROR, "Invalid data frame size", this.lastStreamID);
+            this.sendGoAway(frame.streamIdentifier, ErrorCode.FRAME_SIZE_ERROR, "Invalid data frame size", this.lastStreamID, true);
             return data.len;
         }
-
+        var emitted = false;
         // ignore padding
         if (data_needed > padding) {
             data_needed -= padding;
             payload = payload[0..@min(@as(usize, @intCast(data_needed)), payload.len)];
             const chunk = this.handlers.binary_type.toJS(payload, this.handlers.globalObject);
-            this.dispatchWithExtra(.onStreamData, JSC.JSValue.jsNumber(frame.streamIdentifier), chunk);
+            this.dispatchWithExtra(.onStreamData, stream.getIdentifier(), chunk);
+            emitted = true;
         } else {
             data_needed = 0;
         }
 
         if (this.remainingLength == 0) {
             this.currentFrame = null;
+            if (emitted) {
+                // we need to revalidate the stream ptr after emitting onStreamData
+                const entry = this.streams.getEntry(frame.streamIdentifier) orelse return end;
+                stream = entry.value_ptr;
+            }
             if (frame.flags & @intFromEnum(DataFrameFlags.END_STREAM) != 0) {
-                stream.state = .HALF_CLOSED_REMOTE;
-                this.dispatch(.onStreamEnd, JSC.JSValue.jsNumber(frame.streamIdentifier));
+                const identifier = stream.getIdentifier();
+                identifier.ensureStillAlive();
+
+                if (stream.state == .HALF_CLOSED_LOCAL) {
+                    stream.state = .CLOSED;
+                    stream.freeResources(this, false);
+                } else {
+                    stream.state = .HALF_CLOSED_REMOTE;
+                }
+                this.dispatchWithExtra(.onStreamEnd, identifier, JSC.JSValue.jsNumber(@intFromEnum(stream.state)));
             }
         }
 
         return end;
     }
     pub fn handleGoAwayFrame(this: *H2FrameParser, frame: FrameHeader, data: []const u8, stream_: ?*Stream) usize {
+        log("handleGoAwayFrame {} {s}", .{ frame.streamIdentifier, data });
         if (stream_ != null) {
-            this.sendGoAway(frame.streamIdentifier, ErrorCode.PROTOCOL_ERROR, "GoAway frame on stream", this.lastStreamID);
+            this.sendGoAway(frame.streamIdentifier, ErrorCode.PROTOCOL_ERROR, "GoAway frame on stream", this.lastStreamID, true);
             return data.len;
         }
         const settings = this.remoteSettings orelse this.localSettings;
 
         if (frame.length < 8 or frame.length > settings.maxFrameSize) {
-            this.sendGoAway(frame.streamIdentifier, ErrorCode.FRAME_SIZE_ERROR, "invalid GoAway frame size", this.lastStreamID);
+            this.sendGoAway(frame.streamIdentifier, ErrorCode.FRAME_SIZE_ERROR, "invalid GoAway frame size", this.lastStreamID, true);
             return data.len;
         }
 
         if (handleIncommingPayload(this, data, frame.streamIdentifier)) |content| {
             const payload = content.data;
-            const last_stream_id: u32 = @intCast(UInt31WithReserved.fromBytes(payload[0..4]).uint31);
             const error_code = UInt31WithReserved.fromBytes(payload[4..8]).toUInt32();
             const chunk = this.handlers.binary_type.toJS(payload[8..], this.handlers.globalObject);
             this.readBuffer.reset();
-            if (error_code != @intFromEnum(ErrorCode.NO_ERROR)) {
-                this.dispatchWith2Extra(.onGoAway, JSC.JSValue.jsNumber(error_code), JSC.JSValue.jsNumber(last_stream_id), chunk);
-            } else {
-                this.dispatchWithExtra(.onGoAway, JSC.JSValue.jsNumber(last_stream_id), chunk);
-            }
+            this.dispatchWith2Extra(.onGoAway, JSC.JSValue.jsNumber(error_code), JSC.JSValue.jsNumber(this.lastStreamID), chunk);
             return content.end;
         }
         return data.len;
     }
     pub fn handleRSTStreamFrame(this: *H2FrameParser, frame: FrameHeader, data: []const u8, stream_: ?*Stream) usize {
+        log("handleRSTStreamFrame {s}", .{data});
         var stream = stream_ orelse {
-            this.sendGoAway(frame.streamIdentifier, ErrorCode.PROTOCOL_ERROR, "RST_STREAM frame on connection stream", this.lastStreamID);
+            this.sendGoAway(frame.streamIdentifier, ErrorCode.PROTOCOL_ERROR, "RST_STREAM frame on connection stream", this.lastStreamID, true);
             return data.len;
         };
 
         if (frame.length != 4) {
-            this.sendGoAway(frame.streamIdentifier, ErrorCode.FRAME_SIZE_ERROR, "invalid RST_STREAM frame size", this.lastStreamID);
+            this.sendGoAway(frame.streamIdentifier, ErrorCode.FRAME_SIZE_ERROR, "invalid RST_STREAM frame size", this.lastStreamID, true);
             return data.len;
         }
 
         if (stream.isWaitingMoreHeaders) {
-            this.sendGoAway(frame.streamIdentifier, ErrorCode.PROTOCOL_ERROR, "Headers frame without continuation", this.lastStreamID);
+            this.sendGoAway(frame.streamIdentifier, ErrorCode.PROTOCOL_ERROR, "Headers frame without continuation", this.lastStreamID, true);
             return data.len;
         }
 
@@ -1068,23 +1914,27 @@ pub const H2FrameParser = struct {
             const rst_code = UInt31WithReserved.fromBytes(payload).toUInt32();
             stream.rstCode = rst_code;
             this.readBuffer.reset();
-            if (rst_code != @intFromEnum(ErrorCode.NO_ERROR)) {
-                this.dispatchWithExtra(.onStreamError, JSC.JSValue.jsNumber(stream.id), JSC.JSValue.jsNumber(rst_code));
+            stream.state = .CLOSED;
+            const identifier = stream.getIdentifier();
+            identifier.ensureStillAlive();
+            stream.freeResources(this, false);
+            if (rst_code == @intFromEnum(ErrorCode.NO_ERROR)) {
+                this.dispatchWithExtra(.onStreamEnd, identifier, JSC.JSValue.jsNumber(@intFromEnum(stream.state)));
+            } else {
+                this.dispatchWithExtra(.onStreamError, identifier, JSC.JSValue.jsNumber(rst_code));
             }
-            this.endStream(stream, ErrorCode.NO_ERROR);
-
             return content.end;
         }
         return data.len;
     }
     pub fn handlePingFrame(this: *H2FrameParser, frame: FrameHeader, data: []const u8, stream_: ?*Stream) usize {
         if (stream_ != null) {
-            this.sendGoAway(frame.streamIdentifier, ErrorCode.PROTOCOL_ERROR, "Ping frame on stream", this.lastStreamID);
+            this.sendGoAway(frame.streamIdentifier, ErrorCode.PROTOCOL_ERROR, "Ping frame on stream", this.lastStreamID, true);
             return data.len;
         }
 
         if (frame.length != 8) {
-            this.sendGoAway(frame.streamIdentifier, ErrorCode.FRAME_SIZE_ERROR, "Invalid ping frame size", this.lastStreamID);
+            this.sendGoAway(frame.streamIdentifier, ErrorCode.FRAME_SIZE_ERROR, "Invalid ping frame size", this.lastStreamID, true);
             return data.len;
         }
 
@@ -1094,6 +1944,8 @@ pub const H2FrameParser = struct {
             // if is not ACK send response
             if (isNotACK) {
                 this.sendPing(true, payload);
+            } else {
+                this.outStandingPings -|= 1;
             }
             const buffer = this.handlers.binary_type.toJS(payload, this.handlers.globalObject);
             this.readBuffer.reset();
@@ -1104,12 +1956,12 @@ pub const H2FrameParser = struct {
     }
     pub fn handlePriorityFrame(this: *H2FrameParser, frame: FrameHeader, data: []const u8, stream_: ?*Stream) usize {
         var stream = stream_ orelse {
-            this.sendGoAway(frame.streamIdentifier, ErrorCode.PROTOCOL_ERROR, "Priority frame on connection stream", this.lastStreamID);
+            this.sendGoAway(frame.streamIdentifier, ErrorCode.PROTOCOL_ERROR, "Priority frame on connection stream", this.lastStreamID, true);
             return data.len;
         };
 
         if (frame.length != StreamPriority.byteSize) {
-            this.sendGoAway(frame.streamIdentifier, ErrorCode.FRAME_SIZE_ERROR, "invalid Priority frame size", this.lastStreamID);
+            this.sendGoAway(frame.streamIdentifier, ErrorCode.FRAME_SIZE_ERROR, "invalid Priority frame size", this.lastStreamID, true);
             return data.len;
         }
 
@@ -1120,6 +1972,10 @@ pub const H2FrameParser = struct {
             priority.from(payload);
 
             const stream_identifier = UInt31WithReserved.from(priority.streamIdentifier);
+            if (stream_identifier.uint31 == stream.id) {
+                this.sendGoAway(stream.id, ErrorCode.PROTOCOL_ERROR, "Priority frame with self dependency", this.lastStreamID, true);
+                return data.len;
+            }
             stream.streamDependency = stream_identifier.uint31;
             stream.exclusive = stream_identifier.reserved;
             stream.weight = priority.weight;
@@ -1130,26 +1986,38 @@ pub const H2FrameParser = struct {
         return data.len;
     }
     pub fn handleContinuationFrame(this: *H2FrameParser, frame: FrameHeader, data: []const u8, stream_: ?*Stream) usize {
+        log("handleContinuationFrame", .{});
         var stream = stream_ orelse {
-            this.sendGoAway(frame.streamIdentifier, ErrorCode.PROTOCOL_ERROR, "Continuation on connection stream", this.lastStreamID);
+            this.sendGoAway(frame.streamIdentifier, ErrorCode.PROTOCOL_ERROR, "Continuation on connection stream", this.lastStreamID, true);
             return data.len;
         };
 
         if (!stream.isWaitingMoreHeaders) {
-            this.sendGoAway(frame.streamIdentifier, ErrorCode.PROTOCOL_ERROR, "Continuation without headers", this.lastStreamID);
+            this.sendGoAway(frame.streamIdentifier, ErrorCode.PROTOCOL_ERROR, "Continuation without headers", this.lastStreamID, true);
             return data.len;
         }
         if (handleIncommingPayload(this, data, frame.streamIdentifier)) |content| {
             const payload = content.data;
-            this.decodeHeaderBlock(payload[0..payload.len], stream.id, frame.flags);
+            stream = this.decodeHeaderBlock(payload[0..payload.len], stream, frame.flags) orelse {
+                this.readBuffer.reset();
+                return content.end;
+            };
             this.readBuffer.reset();
             if (frame.flags & @intFromEnum(HeadersFrameFlags.END_HEADERS) != 0) {
-                if (stream.state == .HALF_CLOSED_REMOTE) {
-                    // no more continuation headers we can call it closed
-                    stream.state = .CLOSED;
-                    this.dispatch(.onStreamEnd, JSC.JSValue.jsNumber(frame.streamIdentifier));
-                }
                 stream.isWaitingMoreHeaders = false;
+                if (frame.flags & @intFromEnum(HeadersFrameFlags.END_STREAM) != 0) {
+                    stream.endAfterHeaders = true;
+                    const identifier = stream.getIdentifier();
+                    identifier.ensureStillAlive();
+                    if (stream.state == .HALF_CLOSED_REMOTE) {
+                        // no more continuation headers we can call it closed
+                        stream.state = .CLOSED;
+                        stream.freeResources(this, false);
+                    } else {
+                        stream.state = .HALF_CLOSED_LOCAL;
+                    }
+                    this.dispatchWithExtra(.onStreamEnd, identifier, JSC.JSValue.jsNumber(@intFromEnum(stream.state)));
+                }
             }
 
             return content.end;
@@ -1160,19 +2028,20 @@ pub const H2FrameParser = struct {
     }
 
     pub fn handleHeadersFrame(this: *H2FrameParser, frame: FrameHeader, data: []const u8, stream_: ?*Stream) usize {
+        log("handleHeadersFrame {s}", .{if (this.isServer) "server" else "client"});
         var stream = stream_ orelse {
-            this.sendGoAway(frame.streamIdentifier, ErrorCode.PROTOCOL_ERROR, "Headers frame on connection stream", this.lastStreamID);
+            this.sendGoAway(frame.streamIdentifier, ErrorCode.PROTOCOL_ERROR, "Headers frame on connection stream", this.lastStreamID, true);
             return data.len;
         };
 
         const settings = this.remoteSettings orelse this.localSettings;
         if (frame.length > settings.maxFrameSize) {
-            this.sendGoAway(frame.streamIdentifier, ErrorCode.FRAME_SIZE_ERROR, "invalid Headers frame size", this.lastStreamID);
+            this.sendGoAway(frame.streamIdentifier, ErrorCode.FRAME_SIZE_ERROR, "invalid Headers frame size", this.lastStreamID, true);
             return data.len;
         }
 
         if (stream.isWaitingMoreHeaders) {
-            this.sendGoAway(frame.streamIdentifier, ErrorCode.PROTOCOL_ERROR, "Headers frame without continuation", this.lastStreamID);
+            this.sendGoAway(frame.streamIdentifier, ErrorCode.PROTOCOL_ERROR, "Headers frame without continuation", this.lastStreamID, true);
             return data.len;
         }
 
@@ -1192,24 +2061,30 @@ pub const H2FrameParser = struct {
             const end = payload.len - padding;
             if (offset > end) {
                 this.readBuffer.reset();
-                this.sendGoAway(frame.streamIdentifier, ErrorCode.FRAME_SIZE_ERROR, "invalid Headers frame size", this.lastStreamID);
+                this.sendGoAway(frame.streamIdentifier, ErrorCode.FRAME_SIZE_ERROR, "invalid Headers frame size", this.lastStreamID, true);
                 return data.len;
             }
-            this.decodeHeaderBlock(payload[offset..end], stream.id, frame.flags);
+            stream = this.decodeHeaderBlock(payload[offset..end], stream, frame.flags) orelse {
+                this.readBuffer.reset();
+                return content.end;
+            };
             this.readBuffer.reset();
             stream.isWaitingMoreHeaders = frame.flags & @intFromEnum(HeadersFrameFlags.END_HEADERS) == 0;
             if (frame.flags & @intFromEnum(HeadersFrameFlags.END_STREAM) != 0) {
+                const identifier = stream.getIdentifier();
+                identifier.ensureStillAlive();
                 if (stream.isWaitingMoreHeaders) {
                     stream.state = .HALF_CLOSED_REMOTE;
                 } else {
                     // no more continuation headers we can call it closed
-                    stream.state = .CLOSED;
-                    this.dispatch(.onStreamEnd, JSC.JSValue.jsNumber(frame.streamIdentifier));
+                    if (stream.state == .HALF_CLOSED_LOCAL) {
+                        stream.state = .CLOSED;
+                        stream.freeResources(this, false);
+                    } else {
+                        stream.state = .HALF_CLOSED_REMOTE;
+                    }
                 }
-            }
-
-            if (stream.endAfterHeaders) {
-                this.endStream(stream, ErrorCode.NO_ERROR);
+                this.dispatchWithExtra(.onStreamEnd, identifier, JSC.JSValue.jsNumber(@intFromEnum(stream.state)));
             }
             return content.end;
         }
@@ -1218,32 +2093,35 @@ pub const H2FrameParser = struct {
         return data.len;
     }
     pub fn handleSettingsFrame(this: *H2FrameParser, frame: FrameHeader, data: []const u8) usize {
+        const isACK = frame.flags & @intFromEnum(SettingsFlags.ACK) != 0;
+
+        log("handleSettingsFrame {s} isACK {}", .{ if (this.isServer) "server" else "client", isACK });
         if (frame.streamIdentifier != 0) {
-            this.sendGoAway(frame.streamIdentifier, ErrorCode.PROTOCOL_ERROR, "Settings frame on connection stream", this.lastStreamID);
+            this.sendGoAway(frame.streamIdentifier, ErrorCode.PROTOCOL_ERROR, "Settings frame on connection stream", this.lastStreamID, true);
             return data.len;
         }
+        defer if (!isACK) this.sendSettingsACK();
 
         const settingByteSize = SettingsPayloadUnit.byteSize;
         if (frame.length > 0) {
-            if (frame.flags & 0x1 != 0 or frame.length % settingByteSize != 0) {
+            if (isACK or frame.length % settingByteSize != 0) {
                 log("invalid settings frame size", .{});
-                this.sendGoAway(frame.streamIdentifier, ErrorCode.FRAME_SIZE_ERROR, "Invalid settings frame size", this.lastStreamID);
+                this.sendGoAway(frame.streamIdentifier, ErrorCode.FRAME_SIZE_ERROR, "Invalid settings frame size", this.lastStreamID, true);
                 return data.len;
             }
         } else {
-            if (frame.flags & 0x1 != 0) {
+            if (isACK) {
                 // we received an ACK
                 log("settings frame ACK", .{});
+
                 // we can now write any request
-                this.firstSettingsACK = true;
-                this.flush();
                 this.remoteSettings = this.localSettings;
                 this.dispatch(.onLocalSettings, this.localSettings.toJS(this.handlers.globalObject));
             }
+
             this.currentFrame = null;
             return 0;
         }
-
         if (handleIncommingPayload(this, data, frame.streamIdentifier)) |content| {
             var remoteSettings = this.remoteSettings orelse this.localSettings;
             var i: usize = 0;
@@ -1263,6 +2141,7 @@ pub const H2FrameParser = struct {
         return data.len;
     }
 
+    /// We need to be very carefull because this is not a stable ptr
     fn handleReceivedStreamID(this: *H2FrameParser, streamIdentifier: u32) ?*Stream {
         // connection stream
         if (streamIdentifier == 0) {
@@ -1281,16 +2160,34 @@ pub const H2FrameParser = struct {
         // new stream open
         const settings = this.remoteSettings orelse this.localSettings;
         const entry = this.streams.getOrPut(streamIdentifier) catch bun.outOfMemory();
-        entry.value_ptr.* = Stream.init(streamIdentifier, settings.initialWindowSize, this);
-
-        this.dispatch(.onStreamStart, JSC.JSValue.jsNumber(streamIdentifier));
+        entry.value_ptr.* = Stream.init(streamIdentifier, settings.initialWindowSize);
+        const ctx_value = this.strong_ctx.get() orelse return entry.value_ptr;
+        const callback = this.handlers.onStreamStart;
+        if (callback != .zero) {
+            // we assume that onStreamStart will never mutate the stream hash map
+            _ = callback.call(this.handlers.globalObject, ctx_value, &[_]JSC.JSValue{ ctx_value, JSC.JSValue.jsNumber(streamIdentifier) }) catch |err|
+                this.handlers.globalObject.reportActiveExceptionAsUnhandled(err);
+        }
         return entry.value_ptr;
     }
 
-    pub fn readBytes(this: *H2FrameParser, bytes: []u8) usize {
-        log("read", .{});
+    fn readBytes(this: *H2FrameParser, bytes: []const u8) usize {
+        log("read {}", .{bytes.len});
+        if (this.isServer and this.prefaceReceivedLen < 24) {
+            // Handle Server Preface
+            const preface_missing: usize = 24 - this.prefaceReceivedLen;
+            const preface_available = @min(preface_missing, bytes.len);
+            if (!strings.eql(bytes[0..preface_available], "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"[this.prefaceReceivedLen .. preface_available + this.prefaceReceivedLen])) {
+                // invalid preface
+                log("invalid preface", .{});
+                this.sendGoAway(0, ErrorCode.PROTOCOL_ERROR, "Invalid preface", this.lastStreamID, true);
+                return preface_available;
+            }
+            this.prefaceReceivedLen += @intCast(preface_available);
+            return preface_available;
+        }
         if (this.currentFrame) |header| {
-            log("current frame {} {} {} {}", .{ header.type, header.length, header.flags, header.streamIdentifier });
+            log("current frame {s} {} {} {} {}", .{ if (this.isServer) "server" else "client", header.type, header.length, header.flags, header.streamIdentifier });
 
             const stream = this.handleReceivedStreamID(header.streamIdentifier);
             return switch (header.type) {
@@ -1304,7 +2201,7 @@ pub const H2FrameParser = struct {
                 @intFromEnum(FrameType.HTTP_FRAME_GOAWAY) => this.handleGoAwayFrame(header, bytes, stream),
                 @intFromEnum(FrameType.HTTP_FRAME_RST_STREAM) => this.handleRSTStreamFrame(header, bytes, stream),
                 else => {
-                    this.sendGoAway(header.streamIdentifier, ErrorCode.PROTOCOL_ERROR, "Unknown frame type", this.lastStreamID);
+                    this.sendGoAway(header.streamIdentifier, ErrorCode.PROTOCOL_ERROR, "Unknown frame type", this.lastStreamID, true);
                     return bytes.len;
                 },
             };
@@ -1315,13 +2212,15 @@ pub const H2FrameParser = struct {
 
         const buffered_data = this.readBuffer.list.items.len;
 
-        var header: FrameHeader = .{};
+        var header: FrameHeader = .{ .flags = 0 };
         // we can have less than 9 bytes buffered
         if (buffered_data > 0) {
             const total = buffered_data + bytes.len;
             if (total < FrameHeader.byteSize) {
                 // buffer more data
                 _ = this.readBuffer.appendSlice(bytes) catch bun.outOfMemory();
+                this.globalThis.vm().reportExtraMemory(bytes.len);
+
                 return bytes.len;
             }
             FrameHeader.from(&header, this.readBuffer.list.items[0..buffered_data], 0, false);
@@ -1337,7 +2236,9 @@ pub const H2FrameParser = struct {
             this.remainingLength = header.length;
             log("new frame {} {} {} {}", .{ header.type, header.length, header.flags, header.streamIdentifier });
             const stream = this.handleReceivedStreamID(header.streamIdentifier);
-            this.ajustWindowSize(stream, header.length);
+            if (!this.ajustWindowSize(stream, header.length)) {
+                return bytes.len;
+            }
             return switch (header.type) {
                 @intFromEnum(FrameType.HTTP_FRAME_SETTINGS) => this.handleSettingsFrame(header, bytes[needed..]) + needed,
                 @intFromEnum(FrameType.HTTP_FRAME_WINDOW_UPDATE) => this.handleWindowUpdateFrame(header, bytes[needed..], stream) + needed,
@@ -1349,7 +2250,7 @@ pub const H2FrameParser = struct {
                 @intFromEnum(FrameType.HTTP_FRAME_GOAWAY) => this.handleGoAwayFrame(header, bytes[needed..], stream) + needed,
                 @intFromEnum(FrameType.HTTP_FRAME_RST_STREAM) => this.handleRSTStreamFrame(header, bytes[needed..], stream) + needed,
                 else => {
-                    this.sendGoAway(header.streamIdentifier, ErrorCode.PROTOCOL_ERROR, "Unknown frame type", this.lastStreamID);
+                    this.sendGoAway(header.streamIdentifier, ErrorCode.PROTOCOL_ERROR, "Unknown frame type", this.lastStreamID, true);
                     return bytes.len;
                 },
             };
@@ -1358,16 +2259,20 @@ pub const H2FrameParser = struct {
         if (bytes.len < FrameHeader.byteSize) {
             // buffer more dheaderata
             this.readBuffer.appendSlice(bytes) catch bun.outOfMemory();
+            this.globalThis.vm().reportExtraMemory(bytes.len);
+
             return bytes.len;
         }
 
         FrameHeader.from(&header, bytes[0..FrameHeader.byteSize], 0, true);
 
-        log("new frame {} {} {} {}", .{ header.type, header.length, header.flags, header.streamIdentifier });
+        log("new frame {s} {} {} {} {}", .{ if (this.isServer) "server" else "client", header.type, header.length, header.flags, header.streamIdentifier });
         this.currentFrame = header;
         this.remainingLength = header.length;
         const stream = this.handleReceivedStreamID(header.streamIdentifier);
-        this.ajustWindowSize(stream, header.length);
+        if (!this.ajustWindowSize(stream, header.length)) {
+            return bytes.len;
+        }
         return switch (header.type) {
             @intFromEnum(FrameType.HTTP_FRAME_SETTINGS) => this.handleSettingsFrame(header, bytes[FrameHeader.byteSize..]) + FrameHeader.byteSize,
             @intFromEnum(FrameType.HTTP_FRAME_WINDOW_UPDATE) => this.handleWindowUpdateFrame(header, bytes[FrameHeader.byteSize..], stream) + FrameHeader.byteSize,
@@ -1379,7 +2284,7 @@ pub const H2FrameParser = struct {
             @intFromEnum(FrameType.HTTP_FRAME_GOAWAY) => this.handleGoAwayFrame(header, bytes[FrameHeader.byteSize..], stream) + FrameHeader.byteSize,
             @intFromEnum(FrameType.HTTP_FRAME_RST_STREAM) => this.handleRSTStreamFrame(header, bytes[FrameHeader.byteSize..], stream) + FrameHeader.byteSize,
             else => {
-                this.sendGoAway(header.streamIdentifier, ErrorCode.PROTOCOL_ERROR, "Unknown frame type", this.lastStreamID);
+                this.sendGoAway(header.streamIdentifier, ErrorCode.PROTOCOL_ERROR, "Unknown frame type", this.lastStreamID, true);
                 return bytes.len;
             },
         };
@@ -1387,170 +2292,131 @@ pub const H2FrameParser = struct {
 
     const DirectWriterStruct = struct {
         writer: *H2FrameParser,
-        shouldBuffer: bool = true,
-        pub fn write(this: *const DirectWriterStruct, data: []const u8) !bool {
-            if (this.shouldBuffer) {
-                _ = this.writer.writeBuffer.write(this.writer.allocator, data) catch return false;
-                return true;
-            }
-            this.writer.write(data);
-            return true;
+        pub fn write(this: *const DirectWriterStruct, data: []const u8) !usize {
+            return if (this.writer.write(data)) data.len else 0;
         }
     };
 
     fn toWriter(this: *H2FrameParser) DirectWriterStruct {
-        return DirectWriterStruct{ .writer = this, .shouldBuffer = false };
+        return DirectWriterStruct{ .writer = this };
     }
 
-    fn getBufferWriter(this: *H2FrameParser) DirectWriterStruct {
-        return DirectWriterStruct{ .writer = this, .shouldBuffer = true };
-    }
-
-    fn flush(this: *H2FrameParser) void {
-        if (this.writeBuffer.len > 0) {
-            const slice = this.writeBuffer.slice();
-            this.write(slice);
-            // we will only flush one time
-            this.writeBuffer.deinitWithAllocator(this.allocator);
-        }
-    }
-
-    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);
+        const args_list = callframe.arguments_old(1);
         if (args_list.len < 1) {
-            globalObject.throw("Expected encoding argument", .{});
-            return .zero;
+            return globalObject.throw("Expected encoding argument", .{});
         }
         this.handlers.binary_type = BinaryType.fromJSValue(globalObject, args_list.ptr[0]) orelse {
             const err = JSC.toInvalidArguments("Expected 'binaryType' to be 'arraybuffer', 'uint8array', 'buffer'", .{}, globalObject).asObjectRef();
-            globalObject.throwValue(err);
-            return .zero;
+            return globalObject.throwValue(err);
         };
 
         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.throw("Expected settings to be a object", .{});
         }
 
-        if (options.get(globalObject, "headerTableSize")) |headerTableSize| {
+        if (try 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.throw("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.throw("Expected headerTableSize to be a number", .{});
             }
         }
 
-        if (options.get(globalObject, "enablePush")) |enablePush| {
+        if (try options.get(globalObject, "enablePush")) |enablePush| {
             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.throw("Expected enablePush to be a boolean", .{});
             }
         }
 
-        if (options.get(globalObject, "initialWindowSize")) |initialWindowSize| {
+        if (try options.get(globalObject, "initialWindowSize")) |initialWindowSize| {
             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.throw("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.throw("Expected initialWindowSize to be a number", .{});
             }
         }
 
-        if (options.get(globalObject, "maxFrameSize")) |maxFrameSize| {
+        if (try options.get(globalObject, "maxFrameSize")) |maxFrameSize| {
             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.throw("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.throw("Expected maxFrameSize to be a number", .{});
             }
         }
 
-        if (options.get(globalObject, "maxConcurrentStreams")) |maxConcurrentStreams| {
+        if (try options.get(globalObject, "maxConcurrentStreams")) |maxConcurrentStreams| {
             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.throw("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.throw("Expected maxConcurrentStreams to be a number", .{});
             }
         }
 
-        if (options.get(globalObject, "maxHeaderListSize")) |maxHeaderListSize| {
+        if (try options.get(globalObject, "maxHeaderListSize")) |maxHeaderListSize| {
             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.throw("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.throw("Expected maxHeaderListSize to be a number", .{});
             }
         }
 
-        if (options.get(globalObject, "maxHeaderSize")) |maxHeaderSize| {
+        if (try options.get(globalObject, "maxHeaderSize")) |maxHeaderSize| {
             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.throw("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.throw("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);
+        const args_list = callframe.arguments_old(1);
         if (args_list.len < 1) {
-            globalObject.throw("Expected settings argument", .{});
-            return .zero;
+            return globalObject.throw("Expected settings argument", .{});
         }
 
         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));
@@ -1563,28 +2429,24 @@ pub const H2FrameParser = struct {
         result.put(globalObject, JSC.ZigString.static("localWindowSize"), JSC.JSValue.jsNumber(this.localSettings.initialWindowSize));
         result.put(globalObject, JSC.ZigString.static("deflateDynamicTableSize"), JSC.JSValue.jsNumber(settings.headerTableSize));
         result.put(globalObject, JSC.ZigString.static("inflateDynamicTableSize"), JSC.JSValue.jsNumber(settings.headerTableSize));
-
-        // TODO: make this  real?
-        result.put(globalObject, JSC.ZigString.static("outboundQueueSize"), JSC.JSValue.jsNumber(0));
+        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);
+        const args_list = callframe.arguments_old(3);
         if (args_list.len < 1) {
-            globalObject.throw("Expected errorCode argument", .{});
-            return .zero;
+            return globalObject.throw("Expected errorCode argument", .{});
         }
 
         const error_code_arg = args_list.ptr[0];
 
         if (!error_code_arg.isNumber()) {
-            globalObject.throw("Expected errorCode to be a number", .{});
-            return .zero;
+            return globalObject.throw("Expected errorCode to be a number", .{});
         }
         const errorCode = error_code_arg.toInt32();
         if (errorCode < 1 and errorCode > 13) {
-            globalObject.throw("invalid errorCode", .{});
+            return globalObject.throw("invalid errorCode", .{});
         }
 
         var lastStreamID = this.lastStreamID;
@@ -1592,13 +2454,11 @@ pub const H2FrameParser = struct {
             const last_stream_arg = args_list.ptr[1];
             if (!last_stream_arg.isEmptyOrUndefinedOrNull()) {
                 if (!last_stream_arg.isNumber()) {
-                    globalObject.throw("Expected lastStreamId to be a number", .{});
-                    return .zero;
+                    return globalObject.throw("Expected lastStreamId to be a number", .{});
                 }
                 const id = last_stream_arg.toInt32();
                 if (id < 0 and id > MAX_STREAM_ID) {
-                    globalObject.throw("Expected lastStreamId to be a number between 1 and 2147483647", .{});
-                    return .zero;
+                    return globalObject.throw("Expected lastStreamId to be a number between 1 and 2147483647", .{});
                 }
                 lastStreamID = @intCast(id);
             }
@@ -1607,23 +2467,27 @@ pub const H2FrameParser = struct {
                 if (!opaque_data_arg.isEmptyOrUndefinedOrNull()) {
                     if (opaque_data_arg.asArrayBuffer(globalObject)) |array_buffer| {
                         const slice = array_buffer.byteSlice();
-                        this.sendGoAway(0, @enumFromInt(errorCode), slice, lastStreamID);
+                        this.sendGoAway(0, @enumFromInt(errorCode), slice, lastStreamID, false);
                         return .undefined;
                     }
                 }
             }
         }
 
-        this.sendGoAway(0, @enumFromInt(errorCode), "", lastStreamID);
+        this.sendGoAway(0, @enumFromInt(errorCode), "", lastStreamID, false);
         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);
+        const args_list = callframe.arguments_old(1);
         if (args_list.len < 1) {
-            globalObject.throw("Expected payload argument", .{});
-            return .zero;
+            return globalObject.throw("Expected payload argument", .{});
+        }
+
+        if (this.outStandingPings >= this.maxOutstandingPings) {
+            const exception = JSC.toTypeError(.ERR_HTTP2_PING_CANCEL, "HTTP2 ping cancelled", .{}, globalObject);
+            return globalObject.throwValue(exception);
         }
 
         if (args_list.ptr[0].asArrayBuffer(globalObject)) |array_buffer| {
@@ -1632,132 +2496,86 @@ pub const H2FrameParser = struct {
             return .undefined;
         }
 
-        globalObject.throw("Expected payload to be a Buffer", .{});
-        return .zero;
+        return globalObject.throw("Expected payload to be a Buffer", .{});
     }
 
-    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);
+        const args_list = callframe.arguments_old(1);
         if (args_list.len < 1) {
-            globalObject.throw("Expected stream argument", .{});
-            return .zero;
+            return globalObject.throw("Expected stream argument", .{});
         }
         const stream_arg = args_list.ptr[0];
 
         if (!stream_arg.isNumber()) {
-            globalObject.throw("Invalid stream id", .{});
-            return .zero;
+            return globalObject.throw("Invalid stream id", .{});
         }
 
         const stream_id = stream_arg.toU32();
         if (stream_id == 0) {
-            globalObject.throw("Invalid stream id", .{});
-            return .zero;
+            return globalObject.throw("Invalid stream id", .{});
         }
 
         const stream = this.streams.getPtr(stream_id) orelse {
-            globalObject.throw("Invalid stream id", .{});
-            return .zero;
+            return globalObject.throw("Invalid stream id", .{});
         };
 
         return JSC.JSValue.jsBoolean(stream.endAfterHeaders);
     }
 
-    pub fn setEndAfterHeaders(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(2);
-        if (args_list.len < 2) {
-            globalObject.throw("Expected stream and endAfterHeaders arguments", .{});
-            return .zero;
-        }
-        const stream_arg = args_list.ptr[0];
-        const end_arg = args_list.ptr[1];
-
-        if (!stream_arg.isNumber()) {
-            globalObject.throw("Invalid stream id", .{});
-            return .zero;
-        }
-
-        const stream_id = stream_arg.toU32();
-        if (stream_id == 0 or stream_id > MAX_STREAM_ID) {
-            globalObject.throw("Invalid stream id", .{});
-            return .zero;
-        }
-
-        var stream = this.streams.getPtr(stream_id) orelse {
-            globalObject.throw("Invalid stream id", .{});
-            return .zero;
-        };
-
-        if (!stream.canSendData() and !stream.canReceiveData()) {
-            return JSC.JSValue.jsBoolean(false);
-        }
-
-        stream.endAfterHeaders = end_arg.toBoolean();
-        return JSC.JSValue.jsBoolean(true);
-    }
-
-    pub fn isStreamAborted(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
-        JSC.markBinding(@src());
-        const args_list = callframe.arguments(1);
+        const args_list = callframe.arguments_old(1);
         if (args_list.len < 1) {
-            globalObject.throw("Expected stream argument", .{});
-            return .zero;
+            return globalObject.throw("Expected stream argument", .{});
         }
         const stream_arg = args_list.ptr[0];
 
         if (!stream_arg.isNumber()) {
-            globalObject.throw("Invalid stream id", .{});
-            return .zero;
+            return globalObject.throw("Invalid stream id", .{});
         }
 
         const stream_id = stream_arg.toU32();
         if (stream_id == 0) {
-            globalObject.throw("Invalid stream id", .{});
-            return .zero;
+            return globalObject.throw("Invalid stream id", .{});
         }
 
         const stream = this.streams.getPtr(stream_id) orelse {
-            globalObject.throw("Invalid stream id", .{});
-            return .zero;
+            return globalObject.throw("Invalid stream id", .{});
         };
 
-        if (stream.signal) |_signal| {
-            return JSC.JSValue.jsBoolean(_signal.aborted());
+        if (stream.signal) |signal_ref| {
+            return JSC.JSValue.jsBoolean(signal_ref.isAborted());
         }
-        return JSC.JSValue.jsBoolean(true);
+        // 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);
+        const args_list = callframe.arguments_old(1);
         if (args_list.len < 1) {
-            globalObject.throw("Expected stream argument", .{});
-            return .zero;
+            return globalObject.throw("Expected stream argument", .{});
         }
         const stream_arg = args_list.ptr[0];
 
         if (!stream_arg.isNumber()) {
-            globalObject.throw("Invalid stream id", .{});
-            return .zero;
+            return globalObject.throw("Invalid stream id", .{});
         }
 
         const stream_id = stream_arg.toU32();
         if (stream_id == 0) {
-            globalObject.throw("Invalid stream id", .{});
-            return .zero;
+            return globalObject.throw("Invalid stream id", .{});
         }
 
         var stream = this.streams.getPtr(stream_id) orelse {
-            globalObject.throw("Invalid stream id", .{});
-            return .zero;
+            return globalObject.throw("Invalid stream id", .{});
         };
         var state = JSC.JSValue.createEmptyObject(globalObject, 7);
 
         state.put(globalObject, JSC.ZigString.static("localWindowSize"), JSC.JSValue.jsNumber(stream.windowSize));
         state.put(globalObject, JSC.ZigString.static("state"), JSC.JSValue.jsNumber(@intFromEnum(stream.state)));
-        state.put(globalObject, JSC.ZigString.static("localClose"), JSC.JSValue.jsNumber(@as(i32, if (stream.canSendData()) 1 else 0)));
-        state.put(globalObject, JSC.ZigString.static("remoteClose"), JSC.JSValue.jsNumber(@as(i32, if (stream.canReceiveData()) 1 else 0)));
+        state.put(globalObject, JSC.ZigString.static("localClose"), JSC.JSValue.jsNumber(@as(i32, if (stream.canSendData()) 0 else 1)));
+        state.put(globalObject, JSC.ZigString.static("remoteClose"), JSC.JSValue.jsNumber(@as(i32, if (stream.canReceiveData()) 0 else 1)));
         // TODO: sumDependencyWeight
         state.put(globalObject, JSC.ZigString.static("sumDependencyWeight"), JSC.JSValue.jsNumber(0));
         state.put(globalObject, JSC.ZigString.static("weight"), JSC.JSValue.jsNumber(stream.weight));
@@ -1765,30 +2583,26 @@ 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);
+        const args_list = callframe.arguments_old(2);
         if (args_list.len < 2) {
-            globalObject.throw("Expected stream and options arguments", .{});
-            return .zero;
+            return globalObject.throw("Expected stream and options arguments", .{});
         }
         const stream_arg = args_list.ptr[0];
         const options = args_list.ptr[1];
 
         if (!stream_arg.isNumber()) {
-            globalObject.throw("Invalid stream id", .{});
-            return .zero;
+            return globalObject.throw("Invalid stream id", .{});
         }
 
         const stream_id = stream_arg.toU32();
         if (stream_id == 0) {
-            globalObject.throw("Invalid stream id", .{});
-            return .zero;
+            return globalObject.throw("Invalid stream id", .{});
         }
 
         var stream = this.streams.getPtr(stream_id) orelse {
-            globalObject.throw("Invalid stream id", .{});
-            return .zero;
+            return globalObject.throw("Invalid stream id", .{});
         };
 
         if (!stream.canSendData() and !stream.canReceiveData()) {
@@ -1796,41 +2610,43 @@ pub const H2FrameParser = struct {
         }
 
         if (!options.isObject()) {
-            globalObject.throw("Invalid priority", .{});
-            return .zero;
+            return globalObject.throw("Invalid priority", .{});
         }
+
         var weight = stream.weight;
         var exclusive = stream.exclusive;
         var parent_id = stream.streamDependency;
         var silent = false;
-        if (options.get(globalObject, "weight")) |js_weight| {
+        if (try options.get(globalObject, "weight")) |js_weight| {
             if (js_weight.isNumber()) {
                 const weight_u32 = js_weight.toU32();
                 if (weight_u32 > 255) {
-                    globalObject.throw("Invalid weight", .{});
-                    return .zero;
+                    return globalObject.throw("Invalid weight", .{});
                 }
                 weight = @intCast(weight_u32);
             }
         }
 
-        if (options.get(globalObject, "parent")) |js_parent| {
+        if (try options.get(globalObject, "parent")) |js_parent| {
             if (js_parent.isNumber()) {
                 parent_id = js_parent.toU32();
                 if (parent_id == 0 or parent_id > MAX_STREAM_ID) {
-                    globalObject.throw("Invalid stream id", .{});
-                    return .zero;
+                    return globalObject.throw("Invalid stream id", .{});
                 }
             }
         }
 
-        if (options.get(globalObject, "exclusive")) |js_exclusive| {
+        if (try options.get(globalObject, "exclusive")) |js_exclusive| {
             exclusive = js_exclusive.toBoolean();
         }
 
-        if (options.get(globalObject, "silent")) |js_silent| {
+        if (try options.get(globalObject, "silent")) |js_silent| {
             silent = js_silent.toBoolean();
         }
+        if (parent_id == stream.id) {
+            this.sendGoAway(stream.id, ErrorCode.PROTOCOL_ERROR, "Stream with self dependency", this.lastStreamID, true);
+            return JSC.JSValue.jsBoolean(false);
+        }
 
         stream.streamDependency = parent_id;
         stream.exclusive = exclusive;
@@ -1854,35 +2670,31 @@ pub const H2FrameParser = struct {
             };
 
             const writer = this.toWriter();
-            frame.write(@TypeOf(writer), writer);
-            priority.write(@TypeOf(writer), writer);
+            _ = frame.write(@TypeOf(writer), writer);
+            _ = priority.write(@TypeOf(writer), writer);
         }
         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);
+        const args_list = callframe.arguments_old(2);
         if (args_list.len < 2) {
-            globalObject.throw("Expected stream and code arguments", .{});
-            return .zero;
+            return globalObject.throw("Expected stream and code arguments", .{});
         }
         const stream_arg = args_list.ptr[0];
         const error_arg = args_list.ptr[1];
 
         if (!stream_arg.isNumber()) {
-            globalObject.throw("Invalid stream id", .{});
-            return .zero;
+            return globalObject.throw("Invalid stream id", .{});
         }
 
         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.throw("Invalid stream id", .{});
         }
 
         var stream = this.streams.getPtr(stream_id) orelse {
-            globalObject.throw("Invalid stream id", .{});
-            return .zero;
+            return globalObject.throw("Invalid stream id", .{});
         };
 
         if (!stream.canSendData() and !stream.canReceiveData()) {
@@ -1890,35 +2702,90 @@ pub const H2FrameParser = struct {
         }
 
         if (!error_arg.isNumber()) {
-            globalObject.throw("Invalid ErrorCode", .{});
-            return .zero;
+            return globalObject.throw("Invalid ErrorCode", .{});
         }
+
         const error_code = error_arg.toU32();
         if (error_code > 13) {
-            globalObject.throw("Invalid ErrorCode", .{});
-            return .zero;
+            return globalObject.throw("Invalid ErrorCode", .{});
         }
 
         this.endStream(stream, @enumFromInt(error_code));
 
         return JSC.JSValue.jsBoolean(true);
     }
-    fn sendData(this: *H2FrameParser, stream_id: u32, payload: []const u8, close: bool) void {
-        log("sendData({}, {}, {})", .{ stream_id, payload.len, close });
 
-        const writer = if (this.firstSettingsACK) this.toWriter() else this.getBufferWriter();
+    const MemoryWriter = struct {
+        buffer: []u8,
+        offset: usize = 0,
+        pub fn slice(this: *MemoryWriter) []const u8 {
+            return this.buffer[0..this.offset];
+        }
+        pub fn write(this: *MemoryWriter, data: []const u8) !usize {
+            const pending = this.buffer[this.offset..];
+            bun.debugAssert(pending.len >= data.len);
+            @memcpy(pending[0..data.len], data);
+            this.offset += data.len;
+            return data.len;
+        }
+    };
+    // get memory usage in MB
+    fn getSessionMemoryUsage(this: *H2FrameParser) usize {
+        return (this.writeBuffer.len + this.queuedDataSize) / 1024 / 1024;
+    }
+    // get memory in bytes
+    pub fn getBufferSize(this: *H2FrameParser, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSValue {
+        JSC.markBinding(@src());
+        return JSC.JSValue.jsNumber(this.writeBuffer.len + this.queuedDataSize);
+    }
+
+    fn sendData(this: *H2FrameParser, stream: *Stream, payload: []const u8, close: bool, callback: JSC.JSValue) void {
+        log("HTTP_FRAME_DATA {s} sendData({}, {}, {})", .{ if (this.isServer) "server" else "client", stream.id, payload.len, close });
+
+        const writer = this.toWriter();
+        const stream_id = stream.id;
+        var enqueued = false;
+        this.ref();
+
+        defer {
+            if (!enqueued) {
+                this.dispatchWriteCallback(callback);
+                if (close) {
+                    if (stream.waitForTrailers) {
+                        this.dispatch(.onWantTrailers, stream.getIdentifier());
+                    } else {
+                        const identifier = stream.getIdentifier();
+                        identifier.ensureStillAlive();
+                        if (stream.state == .HALF_CLOSED_REMOTE) {
+                            stream.state = .CLOSED;
+                            stream.freeResources(this, false);
+                        } else {
+                            stream.state = .HALF_CLOSED_LOCAL;
+                        }
+                        this.dispatchWithExtra(.onStreamEnd, identifier, JSC.JSValue.jsNumber(@intFromEnum(stream.state)));
+                    }
+                }
+            }
+            this.deref();
+        }
+        const can_close = close and !stream.waitForTrailers;
         if (payload.len == 0) {
             // empty payload we still need to send a frame
             var dataHeader: FrameHeader = .{
                 .type = @intFromEnum(FrameType.HTTP_FRAME_DATA),
-                .flags = if (close) @intFromEnum(DataFrameFlags.END_STREAM) else 0,
+                .flags = if (can_close) @intFromEnum(DataFrameFlags.END_STREAM) else 0,
                 .streamIdentifier = @intCast(stream_id),
                 .length = 0,
             };
-            dataHeader.write(@TypeOf(writer), writer);
+            if (this.hasBackpressure() or this.outboundQueueSize > 0) {
+                enqueued = true;
+                stream.queueFrame(this, "", callback, close);
+            } else {
+                _ = dataHeader.write(@TypeOf(writer), writer);
+            }
         } else {
             // max frame size will always be at least 16384
-            const max_size = 16384 - FrameHeader.byteSize - 1;
+            const max_size = MAX_PAYLOAD_SIZE_WITHOUT_FRAME;
 
             var offset: usize = 0;
 
@@ -1926,24 +2793,81 @@ pub const H2FrameParser = struct {
                 const size = @min(payload.len - offset, max_size);
                 const slice = payload[offset..(size + offset)];
                 offset += size;
-                var dataHeader: FrameHeader = .{
-                    .type = @intFromEnum(FrameType.HTTP_FRAME_DATA),
-                    .flags = if (offset >= payload.len and close) @intFromEnum(DataFrameFlags.END_STREAM) else 0,
-                    .streamIdentifier = @intCast(stream_id),
-                    .length = size,
-                };
-                dataHeader.write(@TypeOf(writer), writer);
-                _ = writer.write(slice) catch 0;
+                const end_stream = offset >= payload.len and can_close;
+
+                if (this.hasBackpressure() or this.outboundQueueSize > 0) {
+                    enqueued = true;
+                    // write the full frame in memory and queue the frame
+                    // the callback will only be called after the last frame is sended
+                    stream.queueFrame(this, slice, if (offset >= payload.len) callback else JSC.JSValue.jsUndefined(), offset >= payload.len and close);
+                } else {
+                    const padding = stream.getPadding(size, max_size - 1);
+                    const payload_size = size + (if (padding != 0) padding + 1 else 0);
+                    var flags: u8 = if (end_stream) @intFromEnum(DataFrameFlags.END_STREAM) else 0;
+                    if (padding != 0) {
+                        flags |= @intFromEnum(DataFrameFlags.PADDED);
+                    }
+                    var dataHeader: FrameHeader = .{
+                        .type = @intFromEnum(FrameType.HTTP_FRAME_DATA),
+                        .flags = flags,
+                        .streamIdentifier = @intCast(stream_id),
+                        .length = payload_size,
+                    };
+                    _ = dataHeader.write(@TypeOf(writer), writer);
+                    if (padding != 0) {
+                        var buffer = shared_request_buffer[0..];
+                        bun.memmove(buffer[1..size], buffer[0..size]);
+                        buffer[0] = padding;
+                        _ = writer.write(buffer[0 .. FrameHeader.byteSize + payload_size]) catch 0;
+                    } else {
+                        _ = writer.write(slice) catch 0;
+                    }
+                }
             }
         }
     }
-
-    pub fn sendTrailers(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(3);
+        const args_list = callframe.arguments_old(1);
+        if (args_list.len < 1) {
+            return globalObject.throw("Expected stream, headers and sensitiveHeaders arguments", .{});
+        }
+
+        const stream_arg = args_list.ptr[0];
+
+        if (!stream_arg.isNumber()) {
+            return globalObject.throw("Expected stream to be a number", .{});
+        }
+
+        const stream_id = stream_arg.toU32();
+        if (stream_id == 0 or stream_id > MAX_STREAM_ID) {
+            return globalObject.throw("Invalid stream id", .{});
+        }
+
+        var stream = this.streams.getPtr(@intCast(stream_id)) orelse {
+            return globalObject.throw("Invalid stream id", .{});
+        };
+
+        stream.waitForTrailers = false;
+        this.sendData(stream, "", true, JSC.JSValue.jsUndefined());
+
+        const identifier = stream.getIdentifier();
+        identifier.ensureStillAlive();
+        if (stream.state == .HALF_CLOSED_REMOTE) {
+            stream.state = .CLOSED;
+            stream.freeResources(this, false);
+        } else {
+            stream.state = .HALF_CLOSED_LOCAL;
+        }
+        this.dispatchWithExtra(.onStreamEnd, identifier, JSC.JSValue.jsNumber(@intFromEnum(stream.state)));
+        return .undefined;
+    }
+
+    pub fn sendTrailers(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
+        JSC.markBinding(@src());
+        const args_list = callframe.arguments_old(3);
         if (args_list.len < 3) {
-            globalObject.throw("Expected stream, headers and sensitiveHeaders arguments", .{});
-            return .zero;
+            return globalObject.throw("Expected stream, headers and sensitiveHeaders arguments", .{});
         }
 
         const stream_arg = args_list.ptr[0];
@@ -1951,34 +2875,28 @@ 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.throw("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.throw("Invalid stream id", .{});
         }
 
         var stream = this.streams.getPtr(@intCast(stream_id)) orelse {
-            globalObject.throw("Invalid stream id", .{});
-            return .zero;
+            return globalObject.throw("Invalid stream id", .{});
         };
 
         if (!headers_arg.isObject()) {
-            globalObject.throw("Expected headers to be an object", .{});
-            return .zero;
+            return globalObject.throw("Expected headers to be an object", .{});
         }
 
         if (!sensitive_arg.isObject()) {
-            globalObject.throw("Expected sensitiveHeaders to be an object", .{});
-            return .zero;
+            return globalObject.throw("Expected sensitiveHeaders to be an object", .{});
         }
 
         // max frame size will be always at least 16384
         var buffer = shared_request_buffer[0 .. shared_request_buffer.len - FrameHeader.byteSize];
-
         var encoded_size: usize = 0;
 
         var iter = JSC.JSPropertyIterator(.{
@@ -1989,20 +2907,20 @@ pub const H2FrameParser = struct {
 
         // TODO: support CONTINUE for more headers if headers are too big
         while (iter.next()) |header_name| {
+            if (header_name.length() == 0) continue;
+
             const name_slice = header_name.toUTF8(bun.default_allocator);
             defer name_slice.deinit();
             const name = name_slice.slice();
 
             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.throwValue(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.throwValue(exception);
             };
 
             if (js_value.jsType().isArray()) {
@@ -2011,24 +2929,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.throwValue(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.throwValue(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.throwValue(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();
@@ -2036,19 +2951,21 @@ pub const H2FrameParser = struct {
                     log("encode header {s} {s}", .{ name, value });
                     encoded_size += this.encode(buffer, encoded_size, name, value, never_index) catch {
                         stream.state = .CLOSED;
+                        const identifier = stream.getIdentifier();
+                        identifier.ensureStillAlive();
+                        stream.freeResources(this, false);
                         stream.rstCode = @intFromEnum(ErrorCode.COMPRESSION_ERROR);
-                        this.dispatchWithExtra(.onStreamError, JSC.JSValue.jsNumber(stream_id), JSC.JSValue.jsNumber(stream.rstCode));
+                        this.dispatchWithExtra(.onStreamError, identifier, JSC.JSValue.jsNumber(stream.rstCode));
                         return .undefined;
                     };
                 }
             } 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.throwValue(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();
@@ -2056,8 +2973,11 @@ pub const H2FrameParser = struct {
                 log("encode header {s} {s}", .{ name, value });
                 encoded_size += this.encode(buffer, encoded_size, name, value, never_index) catch {
                     stream.state = .CLOSED;
+                    const identifier = stream.getIdentifier();
+                    identifier.ensureStillAlive();
+                    stream.freeResources(this, false);
                     stream.rstCode = @intFromEnum(ErrorCode.COMPRESSION_ERROR);
-                    this.dispatchWithExtra(.onStreamError, JSC.JSValue.jsNumber(stream_id), JSC.JSValue.jsNumber(stream.rstCode));
+                    this.dispatchWithExtra(.onStreamError, identifier, JSC.JSValue.jsNumber(stream.rstCode));
                     return .undefined;
                 };
             }
@@ -2071,113 +2991,241 @@ pub const H2FrameParser = struct {
             .streamIdentifier = stream.id,
             .length = @intCast(encoded_size),
         };
-        const writer = if (this.firstSettingsACK) this.toWriter() else this.getBufferWriter();
-        frame.write(@TypeOf(writer), writer);
+        const writer = this.toWriter();
+        _ = frame.write(@TypeOf(writer), writer);
         _ = writer.write(buffer[0..encoded_size]) catch 0;
-
+        const identifier = stream.getIdentifier();
+        identifier.ensureStillAlive();
+        if (stream.state == .HALF_CLOSED_REMOTE) {
+            stream.state = .CLOSED;
+            stream.freeResources(this, false);
+        } else {
+            stream.state = .HALF_CLOSED_LOCAL;
+        }
+        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_list = callframe.arguments(3);
-        if (args_list.len < 3) {
-            globalObject.throw("Expected stream, data and endStream arguments", .{});
-            return .zero;
-        }
-
-        const stream_arg = args_list.ptr[0];
-        const data_arg = args_list.ptr[1];
-        const close_arg = args_list.ptr[2];
+        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.throw("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.throw("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.throw("Invalid stream id", .{});
         };
-        if (stream.canSendData()) {
+        if (!stream.canSendData()) {
+            this.dispatchWriteCallback(callback_arg);
             return JSC.JSValue.jsBoolean(false);
         }
 
-        // TODO: check padding strategy here
-
-        if (data_arg.asArrayBuffer(globalObject)) |array_buffer| {
-            const payload = array_buffer.slice();
-            this.sendData(stream_id, payload, close and !stream.waitForTrailers);
-        } else if (bun.String.tryFromJS(data_arg, globalObject)) |bun_str| {
-            defer bun_str.deref();
-            var zig_str = bun_str.toUTF8WithoutRef(bun.default_allocator);
-            defer zig_str.deinit();
-            const payload = zig_str.slice();
-            this.sendData(stream_id, payload, close and !stream.waitForTrailers);
-        } else {
-            if (!globalObject.hasException())
-                globalObject.throw("Expected data to be an ArrayBuffer or a string", .{});
-            return .zero;
-        }
-
-        if (close) {
-            if (stream.waitForTrailers) {
-                this.dispatch(.onWantTrailers, JSC.JSValue.jsNumber(stream.id));
+        const encoding: JSC.Node.Encoding = brk: {
+            if (encoding_arg == .undefined) {
+                break :brk .utf8;
             }
-        }
+
+            if (!encoding_arg.isString()) {
+                return globalObject.throwInvalidArgumentTypeValue("write", "encoding", encoding_arg);
+            }
+
+            break :brk JSC.Node.Encoding.fromJS(encoding_arg, globalObject) orelse {
+                if (!globalObject.hasException()) return globalObject.throwInvalidArgumentTypeValue("write", "encoding", encoding_arg);
+                return error.JSError;
+            };
+        };
+
+        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 error.JSError;
+        };
+        defer buffer.deinit();
+
+        this.sendData(stream, buffer.slice(), close, callback_arg);
 
         return JSC.JSValue.jsBoolean(true);
     }
 
     fn getNextStreamID(this: *H2FrameParser) u32 {
         var stream_id: u32 = this.lastStreamID;
-        if (stream_id % 2 == 0) {
-            stream_id += 1;
-        } else if (stream_id == 0) {
-            stream_id = 1;
+        if (this.isServer) {
+            if (stream_id % 2 == 0) {
+                stream_id += 2;
+            } else {
+                stream_id += 1;
+            }
         } else {
-            stream_id += 2;
+            if (stream_id % 2 == 0) {
+                stream_id += 1;
+            } else if (stream_id == 0) {
+                stream_id = 1;
+            } else {
+                stream_id += 2;
+            }
         }
-
         return stream_id;
     }
 
-    pub fn request(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
-        JSC.markBinding(@src());
-        // we use PADDING_STRATEGY_NONE with is default
-        // TODO: PADDING_STRATEGY_MAX AND PADDING_STRATEGY_ALIGNED
+    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);
+    }
 
-        const args_list = callframe.arguments(3);
-        if (args_list.len < 2) {
-            globalObject.throw("Expected headers and sensitiveHeaders arguments", .{});
-            return .zero;
+    pub fn getNextStream(this: *H2FrameParser, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSValue {
+        JSC.markBinding(@src());
+
+        const id = this.getNextStreamID();
+        _ = this.handleReceivedStreamID(id) orelse {
+            return JSC.JSValue.jsNumber(-1);
+        };
+
+        return JSC.JSValue.jsNumber(id);
+    }
+
+    pub fn getStreamContext(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
+        JSC.markBinding(@src());
+        const args_list = callframe.arguments_old(1);
+        if (args_list.len < 1) {
+            return globalObject.throw("Expected stream_id argument", .{});
         }
 
-        const headers_arg = args_list.ptr[0];
-        const sensitive_arg = args_list.ptr[1];
+        const stream_id_arg = args_list.ptr[0];
+        if (!stream_id_arg.isNumber()) {
+            return globalObject.throw("Expected stream_id to be a number", .{});
+        }
+
+        var stream = this.streams.getPtr(stream_id_arg.to(u32)) orelse {
+            return globalObject.throw("Invalid stream id", .{});
+        };
+
+        return stream.jsContext.get() orelse .undefined;
+    }
+
+    pub fn setStreamContext(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+        JSC.markBinding(@src());
+        const args_list = callframe.arguments_old(2);
+        if (args_list.len < 2) {
+            return globalObject.throw("Expected stream_id and context arguments", .{});
+        }
+
+        const stream_id_arg = args_list.ptr[0];
+        if (!stream_id_arg.isNumber()) {
+            return globalObject.throw("Expected stream_id to be a number", .{});
+        }
+        var stream = this.streams.getPtr(stream_id_arg.to(u32)) orelse {
+            return globalObject.throw("Invalid stream id", .{});
+        };
+        const context_arg = args_list.ptr[1];
+        if (!context_arg.isObject()) {
+            return globalObject.throw("Expected context to be an object", .{});
+        }
+
+        stream.setContext(context_arg, globalObject);
+        return .undefined;
+    }
+
+    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());
+        var count: u32 = 0;
+        var it = this.streams.valueIterator();
+        while (it.next()) |stream| {
+            const value = stream.jsContext.get() orelse continue;
+            array.putIndex(globalObject, count, value);
+            count += 1;
+        }
+        return array;
+    }
+    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| {
+            // this is the oposite logic of emitErrorToallStreams, in this case we wanna to cancel this streams
+            if (this.isServer) {
+                if (stream.id % 2 == 0) continue;
+            } else if (stream.id % 2 != 0) continue;
+            if (stream.state != .CLOSED) {
+                const old_state = stream.state;
+                stream.state = .CLOSED;
+                stream.rstCode = @intFromEnum(ErrorCode.CANCEL);
+                const identifier = stream.getIdentifier();
+                identifier.ensureStillAlive();
+                stream.freeResources(this, false);
+                this.dispatchWith2Extra(.onAborted, identifier, .undefined, JSC.JSValue.jsNumber(@intFromEnum(old_state)));
+            }
+        }
+        return .undefined;
+    }
+    pub fn emitErrorToAllStreams(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+        JSC.markBinding(@src());
+
+        const args_list = callframe.arguments_old(1);
+        if (args_list.len < 1) {
+            return globalObject.throw("Expected error argument", .{});
+        }
+
+        var it = StreamResumableIterator.init(this);
+        while (it.next()) |stream| {
+            if (this.isServer) {
+                if (stream.id % 2 != 0) continue;
+            } else if (stream.id % 2 == 0) continue;
+            if (stream.state != .CLOSED) {
+                stream.state = .CLOSED;
+                stream.rstCode = args_list.ptr[0].to(u32);
+                const identifier = stream.getIdentifier();
+                identifier.ensureStillAlive();
+                stream.freeResources(this, false);
+                this.dispatchWithExtra(.onStreamError, identifier, args_list.ptr[0]);
+            }
+        }
+        return .undefined;
+    }
+
+    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) bun.JSError!JSValue {
+        JSC.markBinding(@src());
+
+        const args_list = callframe.arguments_old(5);
+        if (args_list.len < 4) {
+            return globalObject.throw("Expected stream_id, stream_ctx, headers and sensitiveHeaders arguments", .{});
+        }
+
+        const stream_id_arg = args_list.ptr[0];
+        const stream_ctx_arg = args_list.ptr[1];
+
+        const headers_arg = args_list.ptr[2];
+        const sensitive_arg = args_list.ptr[3];
 
         if (!headers_arg.isObject()) {
-            globalObject.throw("Expected headers to be an object", .{});
-            return .zero;
+            return globalObject.throw("Expected headers to be an object", .{});
         }
 
         if (!sensitive_arg.isObject()) {
-            globalObject.throw("Expected sensitiveHeaders to be an object", .{});
-            return .zero;
+            return globalObject.throw("Expected sensitiveHeaders to be an object", .{});
         }
-
         // max frame size will be always at least 16384
         var buffer = shared_request_buffer[0 .. shared_request_buffer.len - FrameHeader.byteSize - 5];
-
         var encoded_size: usize = 0;
 
-        const stream_id: u32 = this.getNextStreamID();
+        const stream_id: u32 = if (!stream_id_arg.isEmptyOrUndefinedOrNull() and stream_id_arg.isNumber()) stream_id_arg.to(u32) else this.getNextStreamID();
         if (stream_id > MAX_STREAM_ID) {
             return JSC.JSValue.jsNumber(-1);
         }
@@ -2188,29 +3236,61 @@ pub const H2FrameParser = struct {
             .include_value = true,
         }).init(globalObject, headers_arg);
         defer iter.deinit();
+        var header_count: u32 = 0;
         for (0..2) |ignore_pseudo_headers| {
             iter.reset();
 
             while (iter.next()) |header_name| {
+                if (header_name.length() == 0) continue;
+
                 const name_slice = header_name.toUTF8(bun.default_allocator);
                 defer name_slice.deinit();
                 const name = name_slice.slice();
 
+                defer header_count += 1;
+                if (this.maxHeaderListPairs < header_count) {
+                    this.rejectedStreams += 1;
+                    const stream = this.handleReceivedStreamID(stream_id) orelse {
+                        return JSC.JSValue.jsNumber(-1);
+                    };
+                    if (!stream_ctx_arg.isEmptyOrUndefinedOrNull() and stream_ctx_arg.isObject()) {
+                        stream.setContext(stream_ctx_arg, globalObject);
+                    }
+                    stream.state = .CLOSED;
+                    stream.rstCode = @intFromEnum(ErrorCode.ENHANCE_YOUR_CALM);
+                    const identifier = stream.getIdentifier();
+                    identifier.ensureStillAlive();
+                    stream.freeResources(this, false);
+                    this.dispatchWithExtra(.onStreamError, identifier, JSC.JSValue.jsNumber(stream.rstCode));
+                    return JSC.JSValue.jsNumber(stream_id);
+                }
+
                 if (header_name.charAt(0) == ':') {
                     if (ignore_pseudo_headers == 1) continue;
 
-                    if (!ValidRequestPseudoHeaders.has(name)) {
-                        const exception = JSC.toTypeError(.ERR_HTTP2_INVALID_PSEUDOHEADER, "\"{s}\" is an invalid pseudoheader or is used incorrectly", .{name}, globalObject);
-                        globalObject.throwValue(exception);
-                        return .zero;
+                    if (this.isServer) {
+                        if (!ValidPseudoHeaders.has(name)) {
+                            if (!globalObject.hasException()) {
+                                return globalObject.ERR_HTTP2_INVALID_PSEUDOHEADER("\"{s}\" is an invalid pseudoheader or is used incorrectly", .{name}).throw();
+                            }
+                            return .zero;
+                        }
+                    } else {
+                        if (!ValidRequestPseudoHeaders.has(name)) {
+                            if (!globalObject.hasException()) {
+                                return globalObject.ERR_HTTP2_INVALID_PSEUDOHEADER("\"{s}\" is an invalid pseudoheader or is used incorrectly", .{name}).throw();
+                            }
+                            return .zero;
+                        }
                     }
                 } else if (ignore_pseudo_headers == 0) {
                     continue;
                 }
 
-                var js_value = 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);
+                const js_value: JSC.JSValue = try headers_arg.get(globalObject, name) orelse {
+                    if (!globalObject.hasException()) {
+                        return globalObject.ERR_HTTP2_INVALID_HEADER_VALUE("Invalid value for header \"{s}\"", .{name}).throw();
+                    }
                     return .zero;
                 };
 
@@ -2220,25 +3300,28 @@ pub const H2FrameParser = struct {
                     var value_iter = js_value.arrayIterator(globalObject);
 
                     if (SingleValueHeaders.has(name) and value_iter.len > 1) {
-                        const exception = JSC.toTypeError(.ERR_HTTP2_INVALID_HEADER_VALUE, "Header field \"{s}\" must only have a single value", .{name}, globalObject);
-                        globalObject.throwValue(exception);
+                        if (!globalObject.hasException()) {
+                            return globalObject.ERR_HTTP2_INVALID_HEADER_VALUE("Header field \"{s}\" must only have a single value", .{name}).throw();
+                        }
                         return .zero;
                     }
 
                     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);
+                            if (!globalObject.hasException()) {
+                                return globalObject.ERR_HTTP2_INVALID_HEADER_VALUE("Invalid value for header \"{s}\"", .{name}).throw();
+                            }
                             return .zero;
                         }
 
                         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);
+                            if (!globalObject.hasException()) {
+                                return globalObject.ERR_HTTP2_INVALID_HEADER_VALUE("Invalid value for header \"{s}\"", .{name}).throw();
+                            }
                             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();
@@ -2248,21 +3331,25 @@ pub const H2FrameParser = struct {
                             const stream = this.handleReceivedStreamID(stream_id) orelse {
                                 return JSC.JSValue.jsNumber(-1);
                             };
+                            if (!stream_ctx_arg.isEmptyOrUndefinedOrNull() and stream_ctx_arg.isObject()) {
+                                stream.setContext(stream_ctx_arg, globalObject);
+                            }
                             stream.state = .CLOSED;
                             stream.rstCode = @intFromEnum(ErrorCode.COMPRESSION_ERROR);
-                            this.dispatchWithExtra(.onStreamError, JSC.JSValue.jsNumber(stream_id), JSC.JSValue.jsNumber(stream.rstCode));
+                            this.dispatchWithExtra(.onStreamError, stream.getIdentifier(), JSC.JSValue.jsNumber(stream.rstCode));
                             return .undefined;
                         };
                     }
-                } else {
+                } else if (!js_value.isEmptyOrUndefinedOrNull()) {
                     log("single header {s}", .{name});
                     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);
+                        if (!globalObject.hasException()) {
+                            return globalObject.ERR_HTTP2_INVALID_HEADER_VALUE("Invalid value for header \"{s}\"", .{name}).throw();
+                        }
                         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();
@@ -2273,9 +3360,12 @@ pub const H2FrameParser = struct {
                             return JSC.JSValue.jsNumber(-1);
                         };
                         stream.state = .CLOSED;
+                        if (!stream_ctx_arg.isEmptyOrUndefinedOrNull() and stream_ctx_arg.isObject()) {
+                            stream.setContext(stream_ctx_arg, globalObject);
+                        }
                         stream.rstCode = @intFromEnum(ErrorCode.COMPRESSION_ERROR);
-                        this.dispatchWithExtra(.onStreamError, JSC.JSValue.jsNumber(stream_id), JSC.JSValue.jsNumber(stream.rstCode));
-                        return JSC.JSValue.jsNumber(stream.id);
+                        this.dispatchWithExtra(.onStreamError, stream.getIdentifier(), JSC.JSValue.jsNumber(stream.rstCode));
+                        return JSC.JSValue.jsNumber(stream_id);
                     };
                 }
             }
@@ -2283,7 +3373,9 @@ pub const H2FrameParser = struct {
         const stream = this.handleReceivedStreamID(stream_id) orelse {
             return JSC.JSValue.jsNumber(-1);
         };
-
+        if (!stream_ctx_arg.isEmptyOrUndefinedOrNull() and stream_ctx_arg.isObject()) {
+            stream.setContext(stream_ctx_arg, globalObject);
+        }
         var flags: u8 = @intFromEnum(HeadersFrameFlags.END_HEADERS);
         var exclusive: bool = false;
         var has_priority: bool = false;
@@ -2291,23 +3383,33 @@ pub const H2FrameParser = struct {
         var parent: i32 = 0;
         var waitForTrailers: bool = false;
         var end_stream: bool = false;
-        if (args_list.len > 2 and !args_list.ptr[2].isEmptyOrUndefinedOrNull()) {
-            const options = args_list.ptr[2];
+        if (args_list.len > 4 and !args_list.ptr[4].isEmptyOrUndefinedOrNull()) {
+            const options = args_list.ptr[4];
             if (!options.isObject()) {
                 stream.state = .CLOSED;
                 stream.rstCode = @intFromEnum(ErrorCode.INTERNAL_ERROR);
-                this.dispatchWithExtra(.onStreamError, JSC.JSValue.jsNumber(stream_id), JSC.JSValue.jsNumber(stream.rstCode));
-                return JSC.JSValue.jsNumber(stream.id);
+                this.dispatchWithExtra(.onStreamError, stream.getIdentifier(), JSC.JSValue.jsNumber(stream.rstCode));
+                return JSC.JSValue.jsNumber(stream_id);
             }
 
-            if (options.get(globalObject, "waitForTrailers")) |trailes_js| {
+            if (try options.get(globalObject, "paddingStrategy")) |padding_js| {
+                if (padding_js.isNumber()) {
+                    stream.paddingStrategy = switch (padding_js.to(u32)) {
+                        1 => .aligned,
+                        2 => .max,
+                        else => .none,
+                    };
+                }
+            }
+
+            if (try options.get(globalObject, "waitForTrailers")) |trailes_js| {
                 if (trailes_js.isBoolean()) {
                     waitForTrailers = trailes_js.asBoolean();
                     stream.waitForTrailers = waitForTrailers;
                 }
             }
 
-            if (options.get(globalObject, "endStream")) |end_stream_js| {
+            if (try options.get(globalObject, "endStream")) |end_stream_js| {
                 if (end_stream_js.isBoolean()) {
                     if (end_stream_js.asBoolean()) {
                         end_stream = true;
@@ -2319,7 +3421,7 @@ pub const H2FrameParser = struct {
                 }
             }
 
-            if (options.get(globalObject, "exclusive")) |exclusive_js| {
+            if (try options.get(globalObject, "exclusive")) |exclusive_js| {
                 if (exclusive_js.isBoolean()) {
                     if (exclusive_js.asBoolean()) {
                         exclusive = true;
@@ -2329,29 +3431,29 @@ pub const H2FrameParser = struct {
                 }
             }
 
-            if (options.get(globalObject, "parent")) |parent_js| {
+            if (try options.get(globalObject, "parent")) |parent_js| {
                 if (parent_js.isNumber() or parent_js.isInt32()) {
                     has_priority = true;
                     parent = parent_js.toInt32();
                     if (parent <= 0 or parent > MAX_STREAM_ID) {
                         stream.state = .CLOSED;
                         stream.rstCode = @intFromEnum(ErrorCode.INTERNAL_ERROR);
-                        this.dispatchWithExtra(.onStreamError, JSC.JSValue.jsNumber(stream_id), JSC.JSValue.jsNumber(stream.rstCode));
+                        this.dispatchWithExtra(.onStreamError, stream.getIdentifier(), JSC.JSValue.jsNumber(stream.rstCode));
                         return JSC.JSValue.jsNumber(stream.id);
                     }
                     stream.streamDependency = @intCast(parent);
                 }
             }
 
-            if (options.get(globalObject, "weight")) |weight_js| {
+            if (try options.get(globalObject, "weight")) |weight_js| {
                 if (weight_js.isNumber() or weight_js.isInt32()) {
                     has_priority = true;
                     weight = weight_js.toInt32();
                     if (weight < 1 or weight > 256) {
                         stream.state = .CLOSED;
                         stream.rstCode = @intFromEnum(ErrorCode.INTERNAL_ERROR);
-                        this.dispatchWithExtra(.onStreamError, JSC.JSValue.jsNumber(stream_id), JSC.JSValue.jsNumber(stream.rstCode));
-                        return JSC.JSValue.jsNumber(stream.id);
+                        this.dispatchWithExtra(.onStreamError, stream.getIdentifier(), JSC.JSValue.jsNumber(stream.rstCode));
+                        return JSC.JSValue.jsNumber(stream_id);
                     }
                     stream.weight = @intCast(weight);
                 }
@@ -2359,25 +3461,35 @@ pub const H2FrameParser = struct {
                 if (weight < 1 or weight > 256) {
                     stream.state = .CLOSED;
                     stream.rstCode = @intFromEnum(ErrorCode.INTERNAL_ERROR);
-                    this.dispatchWithExtra(.onStreamError, JSC.JSValue.jsNumber(stream_id), JSC.JSValue.jsNumber(stream.rstCode));
-                    return JSC.JSValue.jsNumber(stream.id);
+                    this.dispatchWithExtra(.onStreamError, stream.getIdentifier(), JSC.JSValue.jsNumber(stream.rstCode));
+                    return JSC.JSValue.jsNumber(stream_id);
                 }
                 stream.weight = @intCast(weight);
             }
 
-            if (options.get(globalObject, "signal")) |signal_arg| {
+            if (try options.get(globalObject, "signal")) |signal_arg| {
                 if (signal_arg.as(JSC.WebCore.AbortSignal)) |signal_| {
                     if (signal_.aborted()) {
-                        stream.state = .CLOSED;
-                        stream.rstCode = @intFromEnum(ErrorCode.CANCEL);
-                        this.dispatchWithExtra(.onAborted, JSC.JSValue.jsNumber(stream.id), signal_.abortReason());
-                        return JSC.JSValue.jsNumber(stream.id);
+                        stream.state = .IDLE;
+                        this.abortStream(stream, signal_.abortReason());
+                        return JSC.JSValue.jsNumber(stream_id);
                     }
-                    stream.attachSignal(signal_);
+                    stream.attachSignal(this, signal_);
                 }
             }
         }
-
+        // too much memory being use
+        if (this.getSessionMemoryUsage() > this.maxSessionMemory) {
+            stream.state = .CLOSED;
+            stream.rstCode = @intFromEnum(ErrorCode.ENHANCE_YOUR_CALM);
+            this.rejectedStreams += 1;
+            this.dispatchWithExtra(.onStreamError, stream.getIdentifier(), JSC.JSValue.jsNumber(stream.rstCode));
+            if (this.rejectedStreams >= this.maxRejectedStreams) {
+                const chunk = this.handlers.binary_type.toJS("ENHANCE_YOUR_CALM", this.handlers.globalObject);
+                this.dispatchWith2Extra(.onError, JSC.JSValue.jsNumber(@intFromEnum(ErrorCode.ENHANCE_YOUR_CALM)), JSC.JSValue.jsNumber(this.lastStreamID), chunk);
+            }
+            return JSC.JSValue.jsNumber(stream_id);
+        }
         var length: usize = encoded_size;
         if (has_priority) {
             length += 5;
@@ -2385,15 +3497,20 @@ pub const H2FrameParser = struct {
         }
 
         log("request encoded_size {}", .{encoded_size});
+        const padding = stream.getPadding(encoded_size, buffer.len - 1);
+        const payload_size = encoded_size + (if (padding != 0) padding + 1 else 0);
+        if (padding != 0) {
+            flags |= @intFromEnum(HeadersFrameFlags.PADDED);
+        }
         var frame: FrameHeader = .{
             .type = @intFromEnum(FrameType.HTTP_FRAME_HEADERS),
             .flags = flags,
             .streamIdentifier = stream.id,
-            .length = @intCast(encoded_size),
+            .length = @intCast(payload_size),
         };
 
-        const writer = if (this.firstSettingsACK) this.toWriter() else this.getBufferWriter();
-        frame.write(@TypeOf(writer), writer);
+        const writer = this.toWriter();
+        _ = frame.write(@TypeOf(writer), writer);
         //https://datatracker.ietf.org/doc/html/rfc7540#section-6.2
         if (has_priority) {
             var stream_identifier: UInt31WithReserved = .{
@@ -2406,30 +3523,33 @@ pub const H2FrameParser = struct {
                 .weight = @intCast(weight),
             };
 
-            priority.write(@TypeOf(writer), writer);
+            _ = priority.write(@TypeOf(writer), writer);
         }
-
-        _ = writer.write(buffer[0..encoded_size]) catch 0;
+        if (padding != 0) {
+            bun.memmove(buffer[1..encoded_size], buffer[0..encoded_size]);
+            buffer[0] = padding;
+        }
+        _ = writer.write(buffer[0..payload_size]) catch 0;
 
         if (end_stream) {
             stream.state = .HALF_CLOSED_LOCAL;
 
             if (waitForTrailers) {
-                this.dispatch(.onWantTrailers, JSC.JSValue.jsNumber(stream.id));
+                this.dispatch(.onWantTrailers, stream.getIdentifier());
+                return JSC.JSValue.jsNumber(stream_id);
             }
         } else {
             stream.waitForTrailers = waitForTrailers;
         }
 
-        return JSC.JSValue.jsNumber(stream.id);
+        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);
+        const args_list = callframe.arguments_old(1);
         if (args_list.len < 1) {
-            globalObject.throw("Expected 1 argument", .{});
-            return .zero;
+            return globalObject.throw("Expected 1 argument", .{});
         }
         const buffer = args_list.ptr[0];
         buffer.ensureStillAlive();
@@ -2442,103 +3562,272 @@ pub const H2FrameParser = struct {
             }
             return .undefined;
         }
-        globalObject.throw("Expected data to be a Buffer or ArrayBuffer", .{});
-        return .zero;
+        return globalObject.throw("Expected data to be a Buffer or ArrayBuffer", .{});
     }
 
-    pub fn constructor(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) ?*H2FrameParser {
-        const args_list = callframe.arguments(1);
+    pub fn onNativeRead(this: *H2FrameParser, data: []const u8) void {
+        log("onNativeRead", .{});
+        this.ref();
+        defer this.deref();
+        var bytes = data;
+        while (bytes.len > 0) {
+            const result = this.readBytes(bytes);
+            bytes = bytes[result..];
+        }
+    }
+
+    pub fn onNativeWritable(this: *H2FrameParser) void {
+        _ = this.flush();
+    }
+
+    pub fn onNativeClose(this: *H2FrameParser) void {
+        log("onNativeClose", .{});
+        this.detachNativeSocket();
+    }
+
+    pub fn setNativeSocketFromJS(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+        JSC.markBinding(@src());
+        const args_list = callframe.arguments_old(1);
         if (args_list.len < 1) {
-            globalObject.throw("Expected 1 argument", .{});
-            return null;
+            return globalObject.throw("Expected socket argument", .{});
+        }
+
+        const socket_js = args_list.ptr[0];
+        this.detachNativeSocket();
+        if (JSTLSSocket.fromJS(socket_js)) |socket| {
+            log("TLSSocket attached", .{});
+            if (socket.attachNativeCallback(.{ .h2 = this })) {
+                this.native_socket = .{ .tls = socket };
+            } else {
+                socket.ref();
+
+                this.native_socket = .{ .tls_writeonly = socket };
+            }
+            // if we started with non native and go to native we now control the backpressure internally
+            this.has_nonnative_backpressure = false;
+        } else if (JSTCPSocket.fromJS(socket_js)) |socket| {
+            log("TCPSocket attached", .{});
+
+            if (socket.attachNativeCallback(.{ .h2 = this })) {
+                this.native_socket = .{ .tcp = socket };
+            } else {
+                socket.ref();
+
+                this.native_socket = .{ .tcp_writeonly = socket };
+            }
+            // if we started with non native and go to native we now control the backpressure internally
+            this.has_nonnative_backpressure = false;
+        }
+        return .undefined;
+    }
+
+    pub fn detachNativeSocket(this: *H2FrameParser) void {
+        this.native_socket = .{ .none = {} };
+        const native_socket = this.native_socket;
+
+        switch (native_socket) {
+            inline .tcp, .tls => |socket| {
+                socket.detachNativeCallback();
+            },
+            inline .tcp_writeonly, .tls_writeonly => |socket| {
+                socket.deref();
+            },
+            .none => {},
+        }
+    }
+
+    pub fn constructor(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!*H2FrameParser {
+        const args_list = callframe.arguments_old(1);
+        if (args_list.len < 1) {
+            return globalObject.throw("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.throwInvalidArguments("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;
+        const context_obj = try options.get(globalObject, "context") orelse {
+            return globalObject.throw("Expected \"context\" option", .{});
         };
         var handler_js = JSC.JSValue.zero;
-        if (options.get(globalObject, "handlers")) |handlers_| {
+        if (try 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();
 
-        const allocator = getAllocator(globalObject);
-        var this = allocator.create(H2FrameParser) catch unreachable;
+        var this = brk: {
+            if (ENABLE_ALLOCATOR_POOL) {
+                if (H2FrameParser.pool == null) {
+                    H2FrameParser.pool = bun.default_allocator.create(H2FrameParser.H2FrameParserHiveAllocator) catch bun.outOfMemory();
+                    H2FrameParser.pool.?.* = H2FrameParser.H2FrameParserHiveAllocator.init(bun.default_allocator);
+                }
+                const self = H2FrameParser.pool.?.tryGet() catch bun.outOfMemory();
 
-        this.* = H2FrameParser{
-            .handlers = handlers,
-            .allocator = allocator,
-            .readBuffer = .{
-                .allocator = bun.default_allocator,
-                .list = .{
-                    .items = &.{},
-                    .capacity = 0,
-                },
-            },
-            .streams = bun.U32HashMap(Stream).init(bun.default_allocator),
+                self.* = H2FrameParser{
+                    .handlers = handlers,
+                    .globalThis = globalObject,
+                    .allocator = bun.default_allocator,
+                    .readBuffer = .{
+                        .allocator = bun.default_allocator,
+                        .list = .{
+                            .items = &.{},
+                            .capacity = 0,
+                        },
+                    },
+                    .streams = bun.U32HashMap(Stream).init(bun.default_allocator),
+                };
+                break :brk self;
+            } else {
+                break :brk H2FrameParser.new(.{
+                    .handlers = handlers,
+                    .globalThis = globalObject,
+                    .allocator = bun.default_allocator,
+                    .readBuffer = .{
+                        .allocator = bun.default_allocator,
+                        .list = .{
+                            .items = &.{},
+                            .capacity = 0,
+                        },
+                    },
+                    .streams = bun.U32HashMap(Stream).init(bun.default_allocator),
+                });
+            }
         };
-        if (options.get(globalObject, "settings")) |settings_js| {
-            if (!settings_js.isEmptyOrUndefinedOrNull()) {
-                if (!this.loadSettingsFromJSValue(globalObject, settings_js)) {
-                    this.deinit();
-                    handlers.deinit();
-                    return null;
+        errdefer this.deinit();
+
+        // check if socket is provided, and if it is a valid native socket
+        if (try options.get(globalObject, "native")) |socket_js| {
+            if (JSTLSSocket.fromJS(socket_js)) |socket| {
+                log("TLSSocket attached", .{});
+                if (socket.attachNativeCallback(.{ .h2 = this })) {
+                    this.native_socket = .{ .tls = socket };
+                } else {
+                    socket.ref();
+
+                    this.native_socket = .{ .tls_writeonly = socket };
+                }
+            } else if (JSTCPSocket.fromJS(socket_js)) |socket| {
+                log("TCPSocket attached", .{});
+                if (socket.attachNativeCallback(.{ .h2 = this })) {
+                    this.native_socket = .{ .tcp = socket };
+                } else {
+                    socket.ref();
+
+                    this.native_socket = .{ .tcp_writeonly = socket };
                 }
             }
         }
+        if (try options.get(globalObject, "settings")) |settings_js| {
+            if (!settings_js.isEmptyOrUndefinedOrNull()) {
+                try this.loadSettingsFromJSValue(globalObject, settings_js);
 
+                if (try settings_js.get(globalObject, "maxOutstandingPings")) |max_pings| {
+                    if (max_pings.isNumber()) {
+                        this.maxOutstandingPings = max_pings.to(u64);
+                    }
+                }
+                if (try settings_js.get(globalObject, "maxSessionMemory")) |max_memory| {
+                    if (max_memory.isNumber()) {
+                        this.maxSessionMemory = @truncate(max_memory.to(u64));
+                        if (this.maxSessionMemory < 1) {
+                            this.maxSessionMemory = 1;
+                        }
+                    }
+                }
+                if (try settings_js.get(globalObject, "maxHeaderListPairs")) |max_header_list_pairs| {
+                    if (max_header_list_pairs.isNumber()) {
+                        this.maxHeaderListPairs = @truncate(max_header_list_pairs.to(u64));
+                        if (this.maxHeaderListPairs < 4) {
+                            this.maxHeaderListPairs = 4;
+                        }
+                    }
+                }
+                if (try settings_js.get(globalObject, "maxSessionRejectedStreams")) |max_rejected_streams| {
+                    if (max_rejected_streams.isNumber()) {
+                        this.maxRejectedStreams = @truncate(max_rejected_streams.to(u64));
+                    }
+                }
+            }
+        }
+        var is_server = false;
+        if (try options.get(globalObject, "type")) |type_js| {
+            is_server = type_js.isNumber() and type_js.to(u32) == 0;
+        }
+
+        this.isServer = is_server;
         this.strong_ctx.set(globalObject, context_obj);
 
         this.hpack = lshpack.HPACK.init(this.localSettings.headerTableSize);
-        this.sendPrefaceAndSettings();
+
+        if (is_server) {
+            this.setSettings(this.localSettings);
+        } else {
+            // consider that we need to queue until the first flush
+            this.has_nonnative_backpressure = true;
+            this.sendPrefaceAndSettings();
+        }
         return this;
     }
-
-    pub fn deinit(this: *H2FrameParser) void {
-        var allocator = this.allocator;
-        defer allocator.destroy(this);
+    pub fn detachFromJS(this: *H2FrameParser, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSValue {
+        JSC.markBinding(@src());
+        this.detach(false);
+        return .undefined;
+    }
+    /// be careful when calling detach be sure that the socket is closed and the parser not accesible anymore
+    /// this function can be called multiple times, it will erase stream info
+    pub fn detach(this: *H2FrameParser, comptime finalizing: bool) void {
+        this.flushCorked();
+        this.detachNativeSocket();
         this.strong_ctx.deinit();
         this.handlers.deinit();
         this.readBuffer.deinit();
-        this.writeBuffer.deinitWithAllocator(allocator);
-
+        {
+            var writeBuffer = this.writeBuffer;
+            this.writeBuffer = .{};
+            writeBuffer.deinitWithAllocator(this.allocator);
+        }
+        this.writeBufferOffset = 0;
         if (this.hpack) |hpack| {
             hpack.deinit();
             this.hpack = null;
         }
-
-        var it = this.streams.iterator();
-        while (it.next()) |*entry| {
-            var stream = entry.value_ptr.*;
-            stream.deinit();
+        var it = this.streams.valueIterator();
+        while (it.next()) |stream| {
+            stream.freeResources(this, finalizing);
         }
+        var streams = this.streams;
+        defer streams.deinit();
+        this.streams = bun.U32HashMap(Stream).init(bun.default_allocator);
+    }
 
-        this.streams.deinit();
+    pub fn deinit(this: *H2FrameParser) void {
+        log("deinit", .{});
+
+        defer {
+            if (ENABLE_ALLOCATOR_POOL) {
+                H2FrameParser.pool.?.put(this);
+            } else {
+                this.destroy();
+            }
+        }
+        this.detach(true);
     }
 
     pub fn finalize(
         this: *H2FrameParser,
     ) void {
         log("finalize", .{});
-        this.deinit();
+        this.deref();
     }
 };
 
 pub fn createNodeHttp2Binding(global: *JSC.JSGlobalObject) JSC.JSValue {
     return JSC.JSArray.create(global, &.{
         H2FrameParser.getConstructor(global),
-        JSC.JSFunction.create(global, "getPackedSettings", jsGetPackedSettings, 0, .{}),
-        JSC.JSFunction.create(global, "getUnpackedSettings", jsGetUnpackedSettings, 0, .{}),
+        JSC.JSFunction.create(global, "assertSettings", jsAssertSettings, 1, .{}),
+        JSC.JSFunction.create(global, "getPackedSettings", jsGetPackedSettings, 1, .{}),
+        JSC.JSFunction.create(global, "getUnpackedSettings", jsGetUnpackedSettings, 1, .{}),
     });
 }
diff --git a/src/bun.js/api/bun/lshpack.zig b/src/bun.js/api/bun/lshpack.zig
index d9215f1542..9fdb1cab53 100644
--- a/src/bun.js/api/bun/lshpack.zig
+++ b/src/bun.js/api/bun/lshpack.zig
@@ -5,6 +5,8 @@ const lshpack_header = extern struct {
     name_len: usize = 0,
     value: [*]const u8 = undefined,
     value_len: usize = 0,
+    never_index: bool = false,
+    hpack_index: u16 = 255,
 };
 
 /// wrapper implemented at src/bun.js/bindings/c-bindings.cpp
@@ -16,6 +18,8 @@ pub const HPACK = extern struct {
     pub const DecodeResult = struct {
         name: []const u8,
         value: []const u8,
+        never_index: bool,
+        well_know: u16,
         // offset of the next header position in src
         next: usize,
     };
@@ -37,6 +41,8 @@ pub const HPACK = extern struct {
             .name = header.name[0..header.name_len],
             .value = header.value[0..header.value_len],
             .next = offset,
+            .never_index = header.never_index,
+            .well_know = header.hpack_index,
         };
     }
 
diff --git a/src/bun.js/api/bun/socket.zig b/src/bun.js/api/bun/socket.zig
index f2b4d59d4b..7170ba9e23 100644
--- a/src/bun.js/api/bun/socket.zig
+++ b/src/bun.js/api/bun/socket.zig
@@ -19,6 +19,8 @@ const BoringSSL = bun.BoringSSL;
 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;
@@ -216,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.throwInvalidArguments("Expected \"socket\" to be an object", .{});
         }
 
         const pairs = .{
@@ -239,10 +240,9 @@ const Handlers = struct {
             .{ "onHandshake", "handshake" },
         };
         inline for (pairs) |pair| {
-            if (opts.getOwnTruthyComptime(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.throwInvalidArguments("Expected \"{s}\" callback to be a function", .{pair[1]});
                 }
 
                 @field(handlers, pair.@"0") = callback_value;
@@ -250,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.throwInvalidArguments("Expected at least \"data\" or \"drain\" callback", .{});
         }
 
-        if (opts.getOwnTruthy(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.throwInvalidArguments("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.throwInvalidArguments("Expected 'binaryType' to be 'ArrayBuffer', 'Uint8Array', or 'Buffer'", .{});
             };
         }
 
@@ -312,52 +309,59 @@ pub const SocketConfig = struct {
     handlers: Handlers,
     default_data: JSC.JSValue = .zero,
     exclusive: bool = false,
+    allowHalfOpen: bool = false,
+    reusePort: bool = false,
+    ipv6Only: 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;
+        errdefer hostname_or_unix.deinit();
         var port: ?u16 = null;
         var exclusive = false;
+        var allowHalfOpen = false;
+        var reusePort = false;
+        var ipv6Only = false;
 
         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;
                 }
             }
         }
 
+        errdefer {
+            if (ssl != null) {
+                ssl.?.deinit();
+            }
+        }
+
         hostname_or_unix: {
-            if (opts.getOwnTruthy(globalObject, "fd")) |fd_| {
+            if (try opts.getTruthy(globalObject, "fd")) |fd_| {
                 if (fd_.isNumber()) {
                     break :hostname_or_unix;
                 }
             }
 
-            if (opts.getOwnTruthy(globalObject, "unix")) |unix_socket| {
-                if (!unix_socket.isString()) {
-                    exception.* = JSC.toInvalidArguments("Expected \"unix\" to be a string", .{}, globalObject).asObjectRef();
-                    return null;
-                }
+            if (try opts.getStringish(globalObject, "unix")) |unix_socket| {
+                defer unix_socket.deref();
 
-                hostname_or_unix = unix_socket.getZigString(globalObject).toSlice(bun.default_allocator);
+                hostname_or_unix = try unix_socket.toUTF8WithoutRef(bun.default_allocator).cloneIfNeeded(bun.default_allocator);
 
                 if (strings.hasPrefixComptime(hostname_or_unix.slice(), "file://") or strings.hasPrefixComptime(hostname_or_unix.slice(), "unix://") or strings.hasPrefixComptime(hostname_or_unix.slice(), "sock://")) {
-                    hostname_or_unix.ptr += 7;
-                    hostname_or_unix.len -|= 7;
+                    // The memory allocator relies on the pointer address to
+                    // free it, so if we simply moved the pointer up it would
+                    // cause an issue when freeing it later.
+                    const moved_bytes = try bun.default_allocator.dupeZ(u8, hostname_or_unix.slice()[7..]);
+                    hostname_or_unix.deinit();
+                    hostname_or_unix = ZigString.Slice.init(bun.default_allocator, moved_bytes);
                 }
 
                 if (hostname_or_unix.len > 0) {
@@ -365,48 +369,56 @@ pub const SocketConfig = struct {
                 }
             }
 
-            if (opts.getOwnTruthy(globalObject, "exclusive")) |_| {
-                exclusive = true;
+            if (try opts.getBooleanLoose(globalObject, "exclusive")) |exclusive_| {
+                exclusive = exclusive_;
+            }
+            if (try opts.getBooleanLoose(globalObject, "allowHalfOpen")) |allow_half_open| {
+                allowHalfOpen = allow_half_open;
             }
 
-            if (opts.getOwnTruthy(globalObject, "hostname") orelse opts.getOwnTruthy(globalObject, "host")) |hostname| {
-                if (!hostname.isString()) {
-                    exception.* = JSC.toInvalidArguments("Expected \"hostname\" to be a string", .{}, globalObject).asObjectRef();
-                    return null;
-                }
+            if (try opts.getBooleanLoose(globalObject, "reusePort")) |reuse_port| {
+                reusePort = reuse_port;
+            }
 
-                var port_value = opts.getOwn(globalObject, "port") orelse JSValue.zero;
-                hostname_or_unix = hostname.getZigString(globalObject).toSlice(bun.default_allocator);
+            if (try opts.getBooleanLoose(globalObject, "ipv6Only")) |ipv6_only| {
+                ipv6Only = ipv6_only;
+            }
+
+            if (try opts.getStringish(globalObject, "hostname") orelse try opts.getStringish(globalObject, "host")) |hostname| {
+                defer hostname.deref();
+
+                var port_value = try opts.get(globalObject, "port") orelse JSValue.zero;
+                hostname_or_unix = try hostname.toUTF8WithoutRef(bun.default_allocator).cloneIfNeeded(bun.default_allocator);
 
                 if (port_value.isEmptyOrUndefinedOrNull() and hostname_or_unix.len > 0) {
                     const parsed_url = bun.URL.parse(hostname_or_unix.slice());
                     if (parsed_url.getPort()) |port_num| {
                         port_value = JSValue.jsNumber(port_num);
-                        hostname_or_unix.ptr = parsed_url.hostname.ptr;
-                        hostname_or_unix.len = @as(u32, @truncate(parsed_url.hostname.len));
+                        if (parsed_url.hostname.len > 0) {
+                            const moved_bytes = try bun.default_allocator.dupeZ(u8, parsed_url.hostname);
+                            hostname_or_unix.deinit();
+                            hostname_or_unix = ZigString.Slice.init(bun.default_allocator, moved_bytes);
+                        }
                     }
                 }
 
                 if (port_value.isEmptyOrUndefinedOrNull()) {
-                    exception.* = JSC.toInvalidArguments("Expected \"port\" to be a number between 0 and 65535", .{}, globalObject).asObjectRef();
-                    return null;
+                    return globalObject.throwInvalidArguments("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.throwInvalidArguments("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.throwInvalidArguments("Expected \"hostname\" to be a non-empty string", .{});
                 }
 
                 if (hostname_or_unix.len > 0) {
@@ -415,18 +427,13 @@ 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.throwInvalidArguments("Expected \"unix\" or \"hostname\" to be a non-empty string", .{});
             }
 
-            exception.* = JSC.toInvalidArguments("Expected either \"hostname\" or \"unix\"", .{}, globalObject).asObjectRef();
-            return null;
+            return globalObject.throwInvalidArguments("Expected either \"hostname\" or \"unix\"", .{});
         }
 
-        var handlers = Handlers.fromJS(globalObject, opts.getOwn(globalObject, "socket") orelse JSValue.zero, exception) orelse {
-            hostname_or_unix.deinit();
-            return null;
-        };
+        var handlers = try Handlers.fromJS(globalObject, try opts.get(globalObject, "socket") orelse JSValue.zero);
 
         if (opts.fastGet(globalObject, .data)) |default_data_value| {
             default_data = default_data_value;
@@ -441,10 +448,45 @@ pub const SocketConfig = struct {
             .handlers = handlers,
             .default_data = default_data,
             .exclusive = exclusive,
+            .allowHalfOpen = allowHalfOpen,
+            .reusePort = reusePort,
+            .ipv6Only = ipv6Only,
         };
     }
 };
 
+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);
 
@@ -526,31 +568,23 @@ pub const Listener = struct {
         }
     };
 
-    pub fn reload(this: *Listener, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
-        const args = callframe.arguments(1);
+    pub fn reload(this: *Listener, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
+        const args = callframe.arguments_old(1);
 
         if (args.len < 1 or (this.listener == .none and this.handlers.active_connections == 0)) {
-            globalObject.throw("Expected 1 argument", .{});
-            return .zero;
+            return globalObject.throw("Expected 1 argument", .{});
         }
 
         const opts = args.ptr[0];
         if (opts.isEmptyOrUndefinedOrNull() or opts.isBoolean() or !opts.isObject()) {
-            globalObject.throwValue(JSC.toInvalidArguments("Expected options object", .{}, globalObject));
-            return .zero;
+            return globalObject.throwValue(JSC.toInvalidArguments("Expected options object", .{}, globalObject));
         }
 
-        var exception: JSC.C.JSValueRef = null;
-
-        const socket_obj = opts.getOwn(globalObject, "socket") orelse {
-            globalObject.throw("Expected \"socket\" object", .{});
-            return .zero;
+        const socket_obj = try opts.get(globalObject, "socket") orelse {
+            return globalObject.throw("Expected \"socket\" object", .{});
         };
 
-        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();
@@ -560,25 +594,15 @@ 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();
-            return .zero;
+            return globalObject.throwInvalidArguments("Expected object", .{});
         }
 
         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;
@@ -590,14 +614,21 @@ pub const Listener = struct {
 
         const ssl_enabled = ssl != null;
 
-        const socket_flags: i32 = if (exclusive) 1 else 0;
+        var socket_flags: i32 = if (exclusive) uws.LIBUS_LISTEN_EXCLUSIVE_PORT else (if (socket_config.reusePort) uws.LIBUS_SOCKET_REUSE_PORT else uws.LIBUS_LISTEN_DEFAULT);
+        if (socket_config.allowHalfOpen) {
+            socket_flags |= uws.LIBUS_SOCKET_ALLOW_HALF_OPEN;
+        }
+        if (socket_config.ipv6Only) {
+            socket_flags |= uws.LIBUS_SOCKET_IPV6_ONLY;
+        }
         defer if (ssl != null) ssl.?.deinit();
 
         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| {
@@ -628,9 +659,8 @@ 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();
                             this.deinit();
-                            return .zero;
+                            return globalObject.throwInvalidArguments("Failed to listen at {s}", .{pipe_name});
                         },
                     };
 
@@ -642,15 +672,20 @@ pub const Listener = struct {
                 }
             }
         }
-        const ctx_opts: uws.us_bun_socket_context_options_t = JSC.API.ServerConfig.SSLConfig.asUSockets(ssl);
+        const ctx_opts: uws.us_bun_socket_context_options_t = if (ssl != null)
+            JSC.API.ServerConfig.SSLConfig.asUSockets(ssl.?)
+        else
+            .{};
 
         vm.eventLoop().ensureWaker();
 
+        var create_err: uws.create_bun_socket_error_t = .none;
         const socket_context = uws.us_create_bun_socket_context(
             @intFromBool(ssl_enabled),
             uws.Loop.get(),
             @sizeOf(usize),
             ctx_opts,
+            &create_err,
         ) orelse {
             var err = globalObject.createErrorInstance("Failed to listen on {s}:{d}", .{ hostname_or_unix.slice(), port orelse 0 });
             defer {
@@ -666,8 +701,7 @@ pub const Listener = struct {
                 }
             }
 
-            exception.* = err.asObjectRef();
-            return .zero;
+            return globalObject.throwValue(err);
         };
 
         if (ssl_enabled) {
@@ -715,7 +749,7 @@ pub const Listener = struct {
         } else .{
             .unix = (hostname_or_unix.cloneIfNeeded(bun.default_allocator) catch bun.outOfMemory()).slice(),
         };
-
+        var errno: c_int = 0;
         const listen_socket: *uws.ListenSocket = brk: {
             switch (connection) {
                 .host => |c| {
@@ -729,6 +763,7 @@ pub const Listener = struct {
                         c.port,
                         socket_flags,
                         8,
+                        &errno,
                     );
                     // should return the assigned port
                     if (socket) |s| {
@@ -739,12 +774,9 @@ pub const Listener = struct {
                 .unix => |u| {
                     const host = bun.default_allocator.dupeZ(u8, u) catch bun.outOfMemory();
                     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);
-                },
-                .fd => {
-                    // don't call listen() on an fd
-                    return .zero;
+                    break :brk uws.us_socket_context_listen_unix(@intFromBool(ssl_enabled), socket_context, host, host.len, socket_flags, 8, &errno);
                 },
+                .fd => unreachable,
             }
         } orelse {
             defer {
@@ -758,16 +790,14 @@ pub const Listener = struct {
                     bun.span(hostname_or_unix.slice()),
                 },
             );
-            const errno = @intFromEnum(bun.C.getErrno(@as(c_int, -1)));
+            log("Failed to listen {d}", .{errno});
             if (errno != 0) {
                 err.put(globalObject, ZigString.static("errno"), JSValue.jsNumber(errno));
                 if (bun.C.SystemErrno.init(errno)) |str| {
                     err.put(globalObject, ZigString.static("code"), ZigString.init(@tagName(str)).toJS(globalObject));
                 }
             }
-            exception.* = err.asObjectRef();
-
-            return .zero;
+            return globalObject.throwValue(err);
         };
 
         var socket = Listener{
@@ -816,9 +846,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.throw("Cannot construct Listener", .{});
     }
 
     pub fn onNamePipeCreated(comptime ssl: bool, listener: *Listener) *NewSocket(ssl) {
@@ -870,14 +899,12 @@ 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;
+            return global.throwInvalidArguments("addServerName requires SSL support", .{});
         }
         if (!hostname.isString()) {
-            global.throwInvalidArguments("hostname pattern expects a string", .{});
-            return .zero;
+            return global.throwInvalidArguments("hostname pattern expects a string", .{});
         }
         const host_str = hostname.toSlice(
             global,
@@ -887,32 +914,25 @@ pub const Listener = struct {
         const server_name = bun.default_allocator.dupeZ(u8, host_str.slice()) catch bun.outOfMemory();
         defer bun.default_allocator.free(server_name);
         if (server_name.len == 0) {
-            global.throwInvalidArguments("hostname pattern cannot be empty", .{});
-            return .zero;
+            return global.throwInvalidArguments("hostname pattern cannot be empty", .{});
         }
-        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 {
-        const arguments = callframe.arguments(1);
+    pub fn stop(this: *Listener, _: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
+        const arguments = callframe.arguments_old(1);
         log("close", .{});
 
         this.doStop(if (arguments.len > 0 and arguments.ptr[0].isBoolean()) arguments.ptr[0].toBoolean() else false);
@@ -1018,7 +1038,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());
@@ -1026,7 +1046,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();
@@ -1034,26 +1054,13 @@ 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();
-            return .zero;
+            return globalObject.throwInvalidArguments("Expected options object", .{});
         }
         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;
@@ -1069,7 +1076,7 @@ pub const Listener = struct {
         vm.eventLoop().ensureWaker();
 
         var connection: Listener.UnixOrHost = blk: {
-            if (opts.getOwnTruthy(globalObject, "fd")) |fd_| {
+            if (try opts.getTruthy(globalObject, "fd")) |fd_| {
                 if (fd_.isNumber()) {
                     const fd = fd_.asFileDescriptor();
                     break :blk .{ .fd = fd };
@@ -1083,9 +1090,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);
@@ -1130,7 +1142,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);
@@ -1156,7 +1168,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);
@@ -1172,18 +1184,21 @@ pub const Listener = struct {
             }
         }
 
-        const ctx_opts: uws.us_bun_socket_context_options_t = JSC.API.ServerConfig.SSLConfig.asUSockets(socket_config.ssl);
+        const ctx_opts: uws.us_bun_socket_context_options_t = if (ssl != null)
+            JSC.API.ServerConfig.SSLConfig.asUSockets(ssl.?)
+        else
+            .{};
 
-        const socket_context = uws.us_create_bun_socket_context(@intFromBool(ssl_enabled), uws.Loop.get(), @sizeOf(usize), ctx_opts) orelse {
+        var create_err: uws.create_bun_socket_error_t = .none;
+        const socket_context = uws.us_create_bun_socket_context(@intFromBool(ssl_enabled), uws.Loop.get(), @sizeOf(usize), ctx_opts, &create_err) orelse {
             const err = JSC.SystemError{
                 .message = bun.String.static("Failed to connect"),
                 .syscall = bun.String.static("connect"),
                 .code = if (port == null) bun.String.static("ENOENT") else bun.String.static("ECONNREFUSED"),
             };
-            exception.* = err.toErrorInstance(globalObject).asObjectRef();
             handlers.unprotect();
             connection.deinit();
-            return .zero;
+            return globalObject.throwValue(err.toErrorInstance(globalObject));
         };
 
         if (ssl_enabled) {
@@ -1250,7 +1265,7 @@ pub const Listener = struct {
                 });
 
                 SocketType.dataSetCached(socket.getThisValue(globalObject), globalObject, default_data);
-
+                socket.flags.allow_half_open = socket_config.allowHalfOpen;
                 socket.doConnect(connection) catch {
                     socket.handleConnectError(@intFromEnum(if (port == null) bun.C.SystemErrno.ENOENT else bun.C.SystemErrno.ECONNREFUSED));
                     return promise_value;
@@ -1285,17 +1300,13 @@ fn selectALPNCallback(
         if (protos.len == 0) {
             return BoringSSL.SSL_TLSEXT_ERR_NOACK;
         }
-
         const status = BoringSSL.SSL_select_next_proto(bun.cast([*c][*c]u8, out), outlen, protos.ptr, @as(c_uint, @intCast(protos.len)), in, inlen);
-
         // Previous versions of Node.js returned SSL_TLSEXT_ERR_NOACK if no protocol
         // match was found. This would neither cause a fatal alert nor would it result
         // in a useful ALPN response as part of the Server Hello message.
         // We now return SSL_TLSEXT_ERR_ALERT_FATAL in that case as per Section 3.2
         // of RFC 7301, which causes a fatal no_application_protocol alert.
-        const expected = if (comptime BoringSSL.OPENSSL_NPN_NEGOTIATED == 1) BoringSSL.SSL_TLSEXT_ERR_OK else BoringSSL.SSL_TLSEXT_ERR_ALERT_FATAL;
-
-        return if (status == expected) 1 else 0;
+        return if (status == BoringSSL.OPENSSL_NPN_NEGOTIATED) BoringSSL.SSL_TLSEXT_ERR_OK else BoringSSL.SSL_TLSEXT_ERR_ALERT_FATAL;
     } else {
         return BoringSSL.SSL_TLSEXT_ERR_NOACK;
     }
@@ -1310,22 +1321,50 @@ fn NewSocket(comptime ssl: bool) type {
 
         flags: Flags = .{},
         ref_count: u32 = 1,
-
         wrapped: WrappedType = .none,
         handlers: *Handlers,
         this_value: JSC.JSValue = .zero,
         poll_ref: Async.KeepAlive = Async.KeepAlive.init(),
-        last_4: [4]u8 = .{ 0, 0, 0, 0 },
         connection: ?Listener.UnixOrHost = null,
         protos: ?[]const u8,
         server_name: ?[]const u8 = null,
+        buffered_data_for_node_net: bun.ByteList = .{},
+        bytes_written: u64 = 0,
 
         // TODO: switch to something that uses `visitAggregate` and have the
         // `Listener` keep a list of all the sockets JSValue in there
         // This is wasteful because it means we are keeping a JSC::Weak for every single open socket
         has_pending_activity: std.atomic.Value(bool) = std.atomic.Value(bool).init(true),
+        native_callback: NativeCallbacks = .none,
         pub usingnamespace bun.NewRefCounted(@This(), @This().deinit);
 
+        pub const DEBUG_REFCOUNT_NAME = "Socket";
+
+        // We use this direct callbacks on HTTP2 when available
+        pub const NativeCallbacks = union(enum) {
+            h2: *H2FrameParser,
+            none,
+
+            pub fn onData(this: NativeCallbacks, data: []const u8) bool {
+                switch (this) {
+                    .h2 => |h2| {
+                        h2.onNativeRead(data);
+                        return true;
+                    },
+                    .none => return false,
+                }
+            }
+            pub fn onWritable(this: NativeCallbacks) bool {
+                switch (this) {
+                    .h2 => |h2| {
+                        h2.onNativeWritable();
+                        return true;
+                    },
+                    .none => return false,
+                }
+            }
+        };
+
         const This = @This();
         const log = Output.scoped(.Socket, false);
         const WriteResult = union(enum) {
@@ -1341,6 +1380,8 @@ fn NewSocket(comptime ssl: bool) type {
             finalizing: bool = false,
             authorized: bool = false,
             owned_protos: bool = true,
+            is_paused: bool = false,
+            allow_half_open: bool = false,
         };
         pub usingnamespace if (!ssl)
             JSC.Codegen.JSTCPSocket
@@ -1353,6 +1394,29 @@ fn NewSocket(comptime ssl: bool) type {
             return this.has_pending_activity.load(.acquire);
         }
 
+        pub fn attachNativeCallback(this: *This, callback: NativeCallbacks) bool {
+            if (this.native_callback != .none) return false;
+            this.native_callback = callback;
+
+            switch (callback) {
+                .h2 => |h2| h2.ref(),
+                .none => {},
+            }
+            return true;
+        }
+        pub fn detachNativeCallback(this: *This) void {
+            const native_callback = this.native_callback;
+            this.native_callback = .none;
+
+            switch (native_callback) {
+                .h2 => |h2| {
+                    h2.onNativeClose();
+                    h2.deref();
+                },
+                .none => {},
+            }
+        }
+
         pub fn doConnect(this: *This, connection: Listener.UnixOrHost) !void {
             bun.assert(this.socket_context != null);
             this.ref();
@@ -1367,6 +1431,7 @@ fn NewSocket(comptime ssl: bool) type {
                         c.port,
                         this.socket_context.?,
                         this,
+                        this.flags.allow_half_open,
                     );
                 },
                 .unix => |u| {
@@ -1374,6 +1439,7 @@ fn NewSocket(comptime ssl: bool) type {
                         u,
                         this.socket_context.?,
                         this,
+                        this.flags.allow_half_open,
                     );
                 },
                 .fd => |f| {
@@ -1383,9 +1449,67 @@ 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.throw("Cannot construct Socket", .{});
+        }
+
+        pub fn resumeFromJS(this: *This, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSValue {
+            JSC.markBinding(@src());
+
+            log("resume", .{});
+            // we should not allow pausing/resuming a wrapped socket because a wrapped socket is 2 sockets and this can cause issues
+            if (this.wrapped == .none and this.flags.is_paused) {
+                this.flags.is_paused = !this.socket.resumeStream();
+            }
+            return .undefined;
+        }
+        pub fn pauseFromJS(this: *This, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSValue {
+            JSC.markBinding(@src());
+
+            log("pause", .{});
+            // we should not allow pausing/resuming a wrapped socket because a wrapped socket is 2 sockets and this can cause issues
+            if (this.wrapped == .none and !this.flags.is_paused) {
+                this.flags.is_paused = this.socket.pauseStream();
+            }
+
+            return .undefined;
+        }
+
+        pub fn setKeepAlive(this: *This, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
+            JSC.markBinding(@src());
+            const args = callframe.arguments_old(2);
+
+            const enabled: bool = brk: {
+                if (args.len >= 1) {
+                    break :brk args.ptr[0].coerce(bool, globalThis);
+                }
+                break :brk false;
+            };
+
+            const initialDelay: u32 = brk: {
+                if (args.len > 1) {
+                    break :brk @intCast(try globalThis.validateIntegerRange(args.ptr[1], i32, 0, .{ .min = 0, .field_name = "initialDelay" }));
+                }
+                break :brk 0;
+            };
+            log("setKeepAlive({}, {})", .{ enabled, initialDelay });
+
+            return JSValue.jsBoolean(this.socket.setKeepAlive(enabled, initialDelay));
+        }
+
+        pub fn setNoDelay(this: *This, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
+            JSC.markBinding(@src());
+
+            const args = callframe.arguments_old(1);
+            const enabled: bool = brk: {
+                if (args.len >= 1) {
+                    break :brk args.ptr[0].coerce(bool, globalThis);
+                }
+                break :brk true;
+            };
+            log("setNoDelay({})", .{enabled});
+
+            return JSValue.jsBoolean(this.socket.setNoDelay(enabled));
         }
 
         pub fn handleError(this: *This, err_value: JSC.JSValue) void {
@@ -1409,6 +1533,7 @@ fn NewSocket(comptime ssl: bool) type {
             JSC.markBinding(@src());
             log("onWritable", .{});
             if (this.socket.isDetached()) return;
+            if (this.native_callback.onWritable()) return;
             const handlers = this.handlers;
             const callback = handlers.onWritable;
             if (callback == .zero) return;
@@ -1417,6 +1542,12 @@ fn NewSocket(comptime ssl: bool) type {
             if (vm.isShuttingDown()) {
                 return;
             }
+            this.ref();
+            defer this.deref();
+            this.internalFlush();
+            // is not writable if we have buffered data or if we are already detached
+            if (this.buffered_data_for_node_net.len > 0 or this.socket.isDetached()) return;
+
             vm.eventLoop().enter();
             defer vm.eventLoop().exit();
 
@@ -1458,6 +1589,7 @@ fn NewSocket(comptime ssl: bool) type {
             // Ensure the socket is still alive for any defer's we have
             this.ref();
             defer this.deref();
+            this.buffered_data_for_node_net.deinitWithAllocator(bun.default_allocator);
 
             const needs_deref = !this.socket.isDetached();
             this.socket = Socket.detached;
@@ -1539,7 +1671,11 @@ fn NewSocket(comptime ssl: bool) type {
 
         pub fn closeAndDetach(this: *This, code: uws.CloseCode) void {
             const socket = this.socket;
+            this.buffered_data_for_node_net.deinitWithAllocator(bun.default_allocator);
+
             this.socket.detach();
+            this.detachNativeCallback();
+
             socket.close(code);
         }
 
@@ -1741,21 +1877,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 authorization_error: JSValue = if (ssl_error.error_no == 0)
+                    JSValue.jsNull()
+                else
+                    ssl_error.toJS(globalObject);
 
-                    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),
-                    };
-
-                    authorization_error = fallback.toErrorInstance(globalObject);
-                }
                 result = callback.call(globalObject, this_value, &[_]JSValue{
                     this_value,
                     JSValue.jsBoolean(authorized),
@@ -1771,6 +1897,7 @@ fn NewSocket(comptime ssl: bool) type {
         pub fn onClose(this: *This, _: Socket, err: c_int, _: ?*anyopaque) void {
             JSC.markBinding(@src());
             log("onClose", .{});
+            this.detachNativeCallback();
             this.socket.detach();
             defer this.deref();
             defer this.markInactive();
@@ -1799,9 +1926,15 @@ fn NewSocket(comptime ssl: bool) type {
 
             const globalObject = handlers.globalObject;
             const this_value = this.getThisValue(globalObject);
+            var js_error: JSValue = .undefined;
+            if (err != 0) {
+                // errors here are always a read error
+                js_error = bun.sys.Error.fromCodeInt(err, .read).toJSC(globalObject);
+            }
+
             _ = callback.call(globalObject, this_value, &[_]JSValue{
                 this_value,
-                JSValue.jsNumber(@as(i32, err)),
+                js_error,
             }) catch |e| {
                 _ = handlers.callErrorHandler(this_value, &.{ this_value, globalObject.takeException(e) });
             };
@@ -1812,6 +1945,8 @@ fn NewSocket(comptime ssl: bool) type {
             log("onData({d})", .{data.len});
             if (this.socket.isDetached()) return;
 
+            if (this.native_callback.onData(data)) return;
+
             const handlers = this.handlers;
             const callback = handlers.onData;
             if (callback == .zero or this.flags.finalizing) return;
@@ -1897,18 +2032,16 @@ 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);
+            const args = callframe.arguments_old(1);
             if (this.socket.isDetached()) return JSValue.jsUndefined();
             if (args.len == 0) {
-                globalObject.throw("Expected 1 argument, got 0", .{});
-                return .zero;
+                return globalObject.throw("Expected 1 argument, got 0", .{});
             }
             const t = args.ptr[0].coerce(i32, globalObject);
             if (t < 0) {
-                globalObject.throw("Timeout must be a positive integer", .{});
-                return .zero;
+                return globalObject.throw("Timeout must be a positive integer", .{});
             }
             log("timeout({d})", .{t});
 
@@ -1921,7 +2054,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()) {
@@ -1951,21 +2084,16 @@ 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()) {
                 return JSValue.jsNumber(@as(i32, -1));
             }
 
-            const args = callframe.arguments(4);
+            var args = callframe.argumentsUndef(5);
 
-            if (args.len == 0) {
-                globalObject.throw("Expected 1 - 4 arguments, got 0", .{});
-                return .zero;
-            }
-
-            return switch (this.writeOrEnd(globalObject, args.ptr[0..args.len], false)) {
+            return switch (this.writeOrEnd(globalObject, args.mut(), false, false)) {
                 .fail => .zero,
                 .success => |result| JSValue.jsNumber(result.wrote),
             };
@@ -2006,180 +2134,310 @@ fn NewSocket(comptime ssl: bool) type {
             return ZigString.init(text).toJS(globalThis);
         }
 
-        fn writeMaybeCorked(this: *This, buffer: []const u8, is_end: bool) i32 {
+        pub fn writeMaybeCorked(this: *This, buffer: []const u8, is_end: bool) i32 {
             if (this.socket.isShutdown() or this.socket.isClosed()) {
                 return -1;
             }
             // we don't cork yet but we might later
-
             if (comptime ssl) {
                 // TLS wrapped but in TCP mode
                 if (this.wrapped == .tcp) {
                     const res = this.socket.rawWrite(buffer, is_end);
+                    const uwrote: usize = @intCast(@max(res, 0));
+                    this.bytes_written += uwrote;
                     log("write({d}, {any}) = {d}", .{ buffer.len, is_end, res });
                     return res;
                 }
             }
 
             const res = this.socket.write(buffer, is_end);
+            const uwrote: usize = @intCast(@max(res, 0));
+            this.bytes_written += uwrote;
             log("write({d}, {any}) = {d}", .{ buffer.len, is_end, res });
             return res;
         }
 
-        fn writeOrEnd(this: *This, globalObject: *JSC.JSGlobalObject, args: []const JSC.JSValue, is_end: bool) WriteResult {
-            if (args.len == 0) return .{ .success = .{} };
-            if (args.ptr[0].asArrayBuffer(globalObject)) |array_buffer| {
-                var slice = array_buffer.slice();
-
-                if (args.len > 1) {
-                    if (!args.ptr[1].isAnyInt()) {
-                        globalObject.throw("Expected offset integer, got {any}", .{args.ptr[1].getZigString(globalObject)});
-                        return .{ .fail = {} };
-                    }
-
-                    const offset = @min(args.ptr[1].toUInt64NoTruncate(), slice.len);
-                    slice = slice[offset..];
-
-                    if (args.len > 2) {
-                        if (!args.ptr[2].isAnyInt()) {
-                            globalObject.throw("Expected length integer, got {any}", .{args.ptr[2].getZigString(globalObject)});
-                            return .{ .fail = {} };
-                        }
-
-                        const length = @min(args.ptr[2].toUInt64NoTruncate(), slice.len);
-                        slice = slice[0..length];
-                    }
-                }
-
-                // sending empty can be used to ensure that we'll cycle through internal openssl's state
-                if (comptime ssl == false) {
-                    if (slice.len == 0) return .{ .success = .{} };
-                }
-
-                return .{
-                    .success = .{
-                        .wrote = this.writeMaybeCorked(slice, is_end),
-                        .total = slice.len,
-                    },
-                };
-            } else if (args.ptr[0].jsType() == .DOMWrapper) {
-                const blob: JSC.WebCore.AnyBlob = getter: {
-                    if (args.ptr[0].as(JSC.WebCore.Blob)) |blob| {
-                        break :getter JSC.WebCore.AnyBlob{ .Blob = blob.* };
-                    } else if (args.ptr[0].as(JSC.WebCore.Response)) |response| {
-                        response.body.value.toBlobIfPossible();
-
-                        if (response.body.value.tryUseAsAnyBlob()) |blob| {
-                            break :getter blob;
-                        }
-
-                        globalObject.throw("Only Blob/buffered bodies are supported for now", .{});
-                        return .{ .fail = {} };
-                    } else if (args.ptr[0].as(JSC.WebCore.Request)) |request| {
-                        request.body.value.toBlobIfPossible();
-                        if (request.body.value.tryUseAsAnyBlob()) |blob| {
-                            break :getter blob;
-                        }
-
-                        globalObject.throw("Only Blob/buffered bodies are supported for now", .{});
-                        return .{ .fail = {} };
-                    }
-
-                    globalObject.throw("Expected Blob, Request or Response", .{});
-                    return .{ .fail = {} };
-                };
-
-                if (!blob.needsToReadFile()) {
-                    var slice = blob.slice();
-
-                    if (args.len > 1) {
-                        if (!args.ptr[1].isAnyInt()) {
-                            globalObject.throw("Expected offset integer, got {any}", .{args.ptr[1].getZigString(globalObject)});
-                            return .{ .fail = {} };
-                        }
-
-                        const offset = @min(args.ptr[1].toUInt64NoTruncate(), slice.len);
-                        slice = slice[offset..];
-
-                        if (args.len > 2) {
-                            if (!args.ptr[2].isAnyInt()) {
-                                globalObject.throw("Expected length integer, got {any}", .{args.ptr[2].getZigString(globalObject)});
-                                return .{ .fail = {} };
-                            }
-
-                            const length = @min(args.ptr[2].toUInt64NoTruncate(), slice.len);
-                            slice = slice[0..length];
-                        }
-                    }
-
-                    // sending empty can be used to ensure that we'll cycle through internal openssl's state
-                    if (comptime ssl == false) {
-                        if (slice.len == 0) return .{ .success = .{} };
-                    }
-
-                    return .{
-                        .success = .{
-                            .wrote = this.writeMaybeCorked(slice, is_end),
-                            .total = slice.len,
-                        },
-                    };
-                }
-
-                globalObject.throw("sendfile() not implemented yet", .{});
-                return .{ .fail = {} };
-            } else if (bun.String.tryFromJS(args.ptr[0], globalObject)) |bun_str| {
-                defer bun_str.deref();
-                var zig_str = bun_str.toUTF8WithoutRef(bun.default_allocator);
-                defer zig_str.deinit();
-
-                var slice = zig_str.slice();
-
-                if (args.len > 1) {
-                    if (!args.ptr[1].isAnyInt()) {
-                        globalObject.throw("Expected offset integer, got {any}", .{args.ptr[1].getZigString(globalObject)});
-                        return .{ .fail = {} };
-                    }
-
-                    const offset = @min(args.ptr[1].toUInt64NoTruncate(), slice.len);
-                    slice = slice[offset..];
-
-                    if (args.len > 2) {
-                        if (!args.ptr[2].isAnyInt()) {
-                            globalObject.throw("Expected length integer, got {any}", .{args.ptr[2].getZigString(globalObject)});
-                            return .{ .fail = {} };
-                        }
-
-                        const length = @min(args.ptr[2].toUInt64NoTruncate(), slice.len);
-                        slice = slice[0..length];
-                    }
-                }
-
-                // sending empty can be used to ensure that we'll cycle through internal openssl's state
-                if (comptime ssl == false) {
-                    if (slice.len == 0) return .{ .success = .{} };
-                }
-
-                return .{
-                    .success = .{
-                        .wrote = this.writeMaybeCorked(slice, is_end),
-                        .total = slice.len,
-                    },
-                };
-            } else {
-                if (!globalObject.hasException())
-                    globalObject.throw("Expected ArrayBufferView, a string, or a Blob", .{});
-                return .{ .fail = {} };
+        pub fn writeBuffered(
+            this: *This,
+            globalObject: *JSC.JSGlobalObject,
+            callframe: *JSC.CallFrame,
+        ) bun.JSError!JSValue {
+            if (this.socket.isDetached()) {
+                this.buffered_data_for_node_net.deinitWithAllocator(bun.default_allocator);
+                return JSValue.jsBoolean(false);
             }
+
+            const args = callframe.argumentsUndef(2);
+
+            return switch (this.writeOrEndBuffered(globalObject, args.ptr[0], args.ptr[1], false)) {
+                .fail => .zero,
+                .success => |result| if (@max(result.wrote, 0) == result.total) .true else .false,
+            };
         }
 
+        pub fn endBuffered(
+            this: *This,
+            globalObject: *JSC.JSGlobalObject,
+            callframe: *JSC.CallFrame,
+        ) bun.JSError!JSValue {
+            if (this.socket.isDetached()) {
+                this.buffered_data_for_node_net.deinitWithAllocator(bun.default_allocator);
+                return JSValue.jsBoolean(false);
+            }
+
+            const args = callframe.argumentsUndef(2);
+            this.ref();
+            defer this.deref();
+
+            return switch (this.writeOrEndBuffered(globalObject, args.ptr[0], args.ptr[1], false)) {
+                .fail => .zero,
+                .success => |result| brk: {
+                    if (result.wrote == result.total) {
+                        this.socket.flush();
+                        // markInactive does .detached = true
+                        this.markInactive();
+                    }
+
+                    break :brk JSValue.jsBoolean(@as(usize, @max(result.wrote, 0)) == result.total);
+                },
+            };
+        }
+
+        fn writeOrEndBuffered(this: *This, globalObject: *JSC.JSGlobalObject, data_value: JSC.JSValue, encoding_value: JSC.JSValue, comptime is_end: bool) WriteResult {
+            if (this.buffered_data_for_node_net.len == 0) {
+                var values = [4]JSC.JSValue{ data_value, .undefined, .undefined, encoding_value };
+                return this.writeOrEnd(globalObject, &values, true, is_end);
+            }
+
+            var stack_fallback = std.heap.stackFallback(16 * 1024, bun.default_allocator);
+            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) catch {
+                    return .fail;
+                } orelse {
+                    if (!globalObject.hasException()) {
+                        globalObject.throwInvalidArgumentTypeValue("data", "string, buffer, or blob", data_value) catch {};
+                        return .fail;
+                    }
+                    return .fail;
+                };
+            defer buffer.deinit();
+            if (this.socket.isShutdown() or this.socket.isClosed()) {
+                return .{
+                    .success = .{
+                        .wrote = -1,
+                        .total = buffer.slice().len + this.buffered_data_for_node_net.len,
+                    },
+                };
+            }
+
+            const total_to_write: usize = buffer.slice().len + @as(usize, this.buffered_data_for_node_net.len);
+            if (total_to_write == 0) {
+                return .{ .success = .{} };
+            }
+
+            const wrote: i32 = brk: {
+                if (comptime !ssl and Environment.isPosix) {
+                    // fast-ish path: use writev() to avoid cloning to another buffer.
+                    if (this.socket.socket == .connected and buffer.slice().len > 0) {
+                        const rc = this.socket.socket.connected.write2(this.buffered_data_for_node_net.slice(), buffer.slice());
+                        const written: usize = @intCast(@max(rc, 0));
+                        const leftover = total_to_write -| written;
+                        if (leftover == 0) {
+                            this.buffered_data_for_node_net.deinitWithAllocator(bun.default_allocator);
+                            this.buffered_data_for_node_net = .{};
+                            break :brk rc;
+                        }
+
+                        const remaining_in_buffered_data = this.buffered_data_for_node_net.slice()[@min(written, this.buffered_data_for_node_net.len)..];
+                        const remaining_in_input_data = buffer.slice()[@min(this.buffered_data_for_node_net.len -| written, buffer.slice().len)..];
+
+                        if (written > 0) {
+                            if (remaining_in_buffered_data.len > 0) {
+                                var input_buffer = this.buffered_data_for_node_net.slice();
+                                bun.C.memmove(input_buffer.ptr, input_buffer.ptr[written..], remaining_in_buffered_data.len);
+                                this.buffered_data_for_node_net.len = @truncate(remaining_in_buffered_data.len);
+                            }
+                        }
+
+                        if (remaining_in_input_data.len > 0) {
+                            this.buffered_data_for_node_net.append(bun.default_allocator, remaining_in_input_data) catch bun.outOfMemory();
+                        }
+
+                        break :brk rc;
+                    }
+                }
+
+                // slower-path: clone the data, do one write.
+                this.buffered_data_for_node_net.append(bun.default_allocator, buffer.slice()) catch bun.outOfMemory();
+                const rc = this.writeMaybeCorked(this.buffered_data_for_node_net.slice(), is_end);
+                if (rc > 0) {
+                    const wrote: usize = @intCast(@max(rc, 0));
+                    // did we write everything?
+                    // we can free this temporary buffer.
+                    if (wrote == this.buffered_data_for_node_net.len) {
+                        this.buffered_data_for_node_net.deinitWithAllocator(bun.default_allocator);
+                        this.buffered_data_for_node_net = .{};
+                    } else {
+                        // Otherwise, let's move the temporary buffer back.
+                        const len = @as(usize, @intCast(this.buffered_data_for_node_net.len)) - wrote;
+                        bun.debugAssert(len <= this.buffered_data_for_node_net.len);
+                        bun.debugAssert(len <= this.buffered_data_for_node_net.cap);
+                        bun.C.memmove(this.buffered_data_for_node_net.ptr, this.buffered_data_for_node_net.ptr[wrote..], len);
+                        this.buffered_data_for_node_net.len = @truncate(len);
+                    }
+                }
+
+                break :brk rc;
+            };
+
+            return .{
+                .success = .{
+                    .wrote = wrote,
+                    .total = total_to_write,
+                },
+            };
+        }
+
+        fn writeOrEnd(this: *This, globalObject: *JSC.JSGlobalObject, args: []JSC.JSValue, buffer_unwritten_data: bool, comptime is_end: bool) WriteResult {
+            if (args[0].isUndefined()) return .{ .success = .{} };
+
+            bun.debugAssert(this.buffered_data_for_node_net.len == 0);
+            var encoding_value: JSC.JSValue = args[3];
+            if (args[2].isString()) {
+                encoding_value = args[2];
+                args[2] = .undefined;
+            } else if (args[1].isString()) {
+                encoding_value = args[1];
+                args[1] = .undefined;
+            }
+
+            const offset_value = args[1];
+            const length_value = args[2];
+
+            if (encoding_value != .undefined and (offset_value != .undefined or length_value != .undefined)) {
+                return globalObject.throwTODO("Support encoding with offset and length altogether. Only either encoding or offset, length is supported, but not both combinations yet.") catch .fail;
+            }
+
+            var stack_fallback = std.heap.stackFallback(16 * 1024, bun.default_allocator);
+            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) catch {
+                    return .fail;
+                } orelse {
+                    if (!globalObject.hasException()) {
+                        return globalObject.throwInvalidArgumentTypeValue("data", "string, buffer, or blob", args[0]) catch .fail;
+                    }
+                    return .fail;
+                };
+
+            defer buffer.deinit();
+            if (buffer == .blob and buffer.blob.needsToReadFile()) {
+                return globalObject.throw("File blob not supported yet in this function.", .{}) catch .fail;
+            }
+
+            const label = if (comptime is_end) "end" else "write";
+
+            const byte_offset: usize = brk: {
+                if (offset_value.isUndefined()) break :brk 0;
+                if (!offset_value.isAnyInt()) {
+                    return globalObject.throwInvalidArgumentType(comptime "Socket." ++ label, "byteOffset", "integer") catch .fail;
+                }
+                const i = offset_value.toInt64();
+                if (i < 0) {
+                    return globalObject.throwRangeError(i, .{ .field_name = "byteOffset", .min = 0, .max = JSC.MAX_SAFE_INTEGER }) catch .fail;
+                }
+                break :brk @intCast(i);
+            };
+
+            const byte_length: usize = brk: {
+                if (length_value.isUndefined()) break :brk buffer.slice().len;
+                if (!length_value.isAnyInt()) {
+                    return globalObject.throwInvalidArgumentType(comptime "Socket." ++ label, "byteLength", "integer") catch .fail;
+                }
+
+                const l = length_value.toInt64();
+
+                if (l < 0) {
+                    return globalObject.throwRangeError(l, .{ .field_name = "byteLength", .min = 0, .max = JSC.MAX_SAFE_INTEGER }) catch .fail;
+                }
+                break :brk @intCast(l);
+            };
+
+            var bytes = buffer.slice();
+
+            if (byte_offset > bytes.len) {
+                return globalObject.throwRangeError(@as(i64, @intCast(byte_offset)), .{ .field_name = "byteOffset", .min = 0, .max = @intCast(bytes.len) }) catch .fail;
+            }
+
+            bytes = bytes[byte_offset..];
+
+            if (byte_length > bytes.len) {
+                return globalObject.throwRangeError(@as(i64, @intCast(byte_length)), .{ .field_name = "byteLength", .min = 0, .max = @intCast(bytes.len) }) catch .fail;
+            }
+
+            bytes = bytes[0..byte_length];
+
+            if (bytes.len == 0) {
+                return .{ .success = .{} };
+            }
+
+            if (globalObject.hasException()) {
+                return .fail;
+            }
+
+            if (this.socket.isShutdown() or this.socket.isClosed()) {
+                return .{
+                    .success = .{
+                        .wrote = -1,
+                        .total = bytes.len,
+                    },
+                };
+            }
+
+            const wrote = this.writeMaybeCorked(bytes, is_end);
+            const uwrote: usize = @intCast(@max(wrote, 0));
+            if (buffer_unwritten_data) {
+                const remaining = bytes[uwrote..];
+                if (remaining.len > 0) {
+                    this.buffered_data_for_node_net.append(bun.default_allocator, remaining) catch bun.outOfMemory();
+                }
+            }
+
+            return .{
+                .success = .{
+                    .wrote = wrote,
+                    .total = bytes.len,
+                },
+            };
+        }
+        fn internalFlush(this: *This) void {
+            if (this.buffered_data_for_node_net.len > 0) {
+                const written: usize = @intCast(@max(this.socket.write(this.buffered_data_for_node_net.slice(), false), 0));
+                this.bytes_written += written;
+                if (written > 0) {
+                    if (this.buffered_data_for_node_net.len > written) {
+                        const remaining = this.buffered_data_for_node_net.slice()[written..];
+                        bun.C.memmove(this.buffered_data_for_node_net.ptr, remaining.ptr, remaining.len);
+                        this.buffered_data_for_node_net.len = @truncate(remaining.len);
+                    } else {
+                        this.buffered_data_for_node_net.deinitWithAllocator(bun.default_allocator);
+                        this.buffered_data_for_node_net = .{};
+                    }
+                }
+            }
+
+            this.socket.flush();
+        }
         pub fn flush(
             this: *This,
             _: *JSC.JSGlobalObject,
             _: *JSC.CallFrame,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             JSC.markBinding(@src());
-            this.socket.flush();
-
+            this.internalFlush();
             return JSValue.jsUndefined();
         }
 
@@ -2187,7 +2445,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();
@@ -2197,9 +2455,9 @@ 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);
+            const args = callframe.arguments_old(1);
             if (args.len > 0 and args.ptr[0].toBoolean()) {
                 this.socket.shutdownRead();
             } else {
@@ -2213,10 +2471,10 @@ 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(4);
+            var args = callframe.argumentsUndef(5);
 
             log("end({d} args)", .{args.len});
 
@@ -2224,7 +2482,10 @@ fn NewSocket(comptime ssl: bool) type {
                 return JSValue.jsNumber(@as(i32, -1));
             }
 
-            return switch (this.writeOrEnd(globalObject, args.ptr[0..args.len], true)) {
+            this.ref();
+            defer this.deref();
+
+            return switch (this.writeOrEnd(globalObject, args.mut(), false, true)) {
                 .fail => .zero,
                 .success => |result| brk: {
                     if (result.wrote == result.total) {
@@ -2237,14 +2498,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();
@@ -2252,6 +2513,9 @@ fn NewSocket(comptime ssl: bool) type {
 
         pub fn deinit(this: *This) void {
             this.markInactive();
+            this.detachNativeCallback();
+
+            this.buffered_data_for_node_net.deinitWithAllocator(bun.default_allocator);
 
             this.poll_ref.unref(JSC.VirtualMachine.get());
             // need to deinit event without being attached
@@ -2288,12 +2552,11 @@ fn NewSocket(comptime ssl: bool) type {
             this.deref();
         }
 
-        pub fn reload(this: *This, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
-            const args = callframe.arguments(1);
+        pub fn reload(this: *This, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
+            const args = callframe.arguments_old(1);
 
             if (args.len < 1) {
-                globalObject.throw("Expected 1 argument", .{});
-                return .zero;
+                return globalObject.throw("Expected 1 argument", .{});
             }
 
             if (this.socket.isDetached()) {
@@ -2302,21 +2565,14 @@ fn NewSocket(comptime ssl: bool) type {
 
             const opts = args.ptr[0];
             if (opts.isEmptyOrUndefinedOrNull() or opts.isBoolean() or !opts.isObject()) {
-                globalObject.throw("Expected options object", .{});
-                return .zero;
+                return globalObject.throw("Expected options object", .{});
             }
 
-            var exception: JSC.C.JSValueRef = null;
-
-            const socket_obj = opts.getOwn(globalObject, "socket") orelse {
-                globalObject.throw("Expected \"socket\" option", .{});
-                return .zero;
+            const socket_obj = try opts.get(globalObject, "socket") orelse {
+                return globalObject.throw("Expected \"socket\" option", .{});
             };
 
-            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();
@@ -2330,7 +2586,7 @@ fn NewSocket(comptime ssl: bool) type {
             this: *This,
             _: *JSC.JSGlobalObject,
             _: *JSC.CallFrame,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             if (comptime ssl == false) {
                 return JSValue.jsUndefined();
             }
@@ -2343,7 +2599,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();
             }
@@ -2351,17 +2607,15 @@ fn NewSocket(comptime ssl: bool) type {
                 return JSValue.jsUndefined();
             }
 
-            const args = callframe.arguments(2);
+            const args = callframe.arguments_old(2);
 
             if (args.len < 2) {
-                globalObject.throw("Expected requestCert and rejectUnauthorized arguments", .{});
-                return .zero;
+                return globalObject.throw("Expected requestCert and rejectUnauthorized arguments", .{});
             }
             const request_cert_js = args.ptr[0];
             const reject_unauthorized_js = args.ptr[1];
             if (!request_cert_js.isBoolean() or !reject_unauthorized_js.isBoolean()) {
-                globalObject.throw("Expected requestCert and rejectUnauthorized arguments to be boolean", .{});
-                return .zero;
+                return globalObject.throw("Expected requestCert and rejectUnauthorized arguments to be boolean", .{});
             }
 
             const request_cert = request_cert_js.toBoolean();
@@ -2384,7 +2638,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();
             }
@@ -2392,8 +2646,7 @@ fn NewSocket(comptime ssl: bool) type {
             const ssl_ptr = this.socket.ssl() orelse return JSValue.jsUndefined();
             BoringSSL.ERR_clear_error();
             if (BoringSSL.SSL_renegotiate(ssl_ptr) != 1) {
-                globalObject.throwValue(getSSLException(globalObject, "SSL_renegotiate error"));
-                return .zero;
+                return globalObject.throwValue(getSSLException(globalObject, "SSL_renegotiate error"));
             }
             return JSValue.jsUndefined();
         }
@@ -2401,7 +2654,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();
             }
@@ -2424,7 +2677,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();
             }
@@ -2433,19 +2686,16 @@ fn NewSocket(comptime ssl: bool) type {
                 return JSValue.jsUndefined();
             }
 
-            const args = callframe.arguments(1);
+            const args = callframe.arguments_old(1);
 
             if (args.len < 1) {
-                globalObject.throw("Expected session to be a string, Buffer or TypedArray", .{});
-                return .zero;
+                return globalObject.throw("Expected session to be a string, Buffer or TypedArray", .{});
             }
 
             const session_arg = args.ptr[0];
             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();
@@ -2453,16 +2703,11 @@ fn NewSocket(comptime ssl: bool) type {
                 var tmp = @as([*c]const u8, @ptrCast(session_slice.ptr));
                 const session = BoringSSL.d2i_SSL_SESSION(null, &tmp, @as(c_long, @intCast(session_slice.len))) orelse return JSValue.jsUndefined();
                 if (BoringSSL.SSL_set_session(ssl_ptr, session) != 1) {
-                    globalObject.throwValue(getSSLException(globalObject, "SSL_set_session error"));
-                    return .zero;
+                    return globalObject.throwValue(getSSLException(globalObject, "SSL_set_session error"));
                 }
                 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;
+                return globalObject.throw("Expected session to be a string, Buffer or TypedArray", .{});
             }
         }
 
@@ -2470,7 +2715,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();
             }
@@ -2490,6 +2735,12 @@ fn NewSocket(comptime ssl: bool) type {
             bun.assert(result_size == size);
             return buffer;
         }
+        pub fn getBytesWritten(
+            this: *This,
+            _: *JSC.JSGlobalObject,
+        ) JSValue {
+            return JSC.JSValue.jsNumber(this.bytes_written + this.buffered_data_for_node_net.len);
+        }
 
         pub fn getALPNProtocol(
             this: *This,
@@ -2511,10 +2762,10 @@ fn NewSocket(comptime ssl: bool) type {
 
             const slice = alpn_proto[0..alpn_proto_len];
             if (strings.eql(slice, "h2")) {
-                return ZigString.static("h2").toJS(globalObject);
+                return bun.String.static("h2").toJS(globalObject);
             }
             if (strings.eql(slice, "http/1.1")) {
-                return ZigString.static("http/1.1").toJS(globalObject);
+                return bun.String.static("http/1.1").toJS(globalObject);
             }
             return ZigString.fromUTF8(slice).toJS(globalObject);
         }
@@ -2522,7 +2773,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();
             }
@@ -2531,33 +2782,26 @@ fn NewSocket(comptime ssl: bool) type {
                 return JSValue.jsUndefined();
             }
 
-            const args = callframe.arguments(3);
+            const args = callframe.arguments_old(3);
             if (args.len < 2) {
-                globalObject.throw("Expected length and label to be provided", .{});
-                return .zero;
+                return globalObject.throw("Expected length and label to be provided", .{});
             }
             const length_arg = args.ptr[0];
             if (!length_arg.isNumber()) {
-                globalObject.throw("Expected length to be a number", .{});
-                return .zero;
+                return globalObject.throw("Expected length to be a number", .{});
             }
 
             const length = length_arg.coerceToInt64(globalObject);
             if (length < 0) {
-                globalObject.throw("Expected length to be a positive number", .{});
-                return .zero;
+                return globalObject.throw("Expected length to be a positive number", .{});
             }
 
             const label_arg = args.ptr[1];
             if (!label_arg.isString()) {
-                globalObject.throw("Expected label to be a string", .{});
-                return .zero;
+                return globalObject.throw("Expected label to be a string", .{});
             }
 
-            var label = label_arg.toSliceOrNull(globalObject) orelse {
-                globalObject.throw("Expected label to be a string", .{});
-                return .zero;
-            };
+            var label = try label_arg.toSliceOrNull(globalObject);
 
             defer label.deinit();
             const label_slice = label.slice();
@@ -2569,8 +2813,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();
@@ -2581,16 +2823,11 @@ fn NewSocket(comptime ssl: bool) type {
 
                     const result = BoringSSL.SSL_export_keying_material(ssl_ptr, buffer_ptr, buffer_size, @as([*c]const u8, @ptrCast(label_slice.ptr)), label_slice.len, @as([*c]const u8, @ptrCast(context_slice.ptr)), context_slice.len, 1);
                     if (result != 1) {
-                        globalObject.throwValue(getSSLException(globalObject, "Failed to export keying material"));
-                        return .zero;
+                        return globalObject.throwValue(getSSLException(globalObject, "Failed to export keying material"));
                     }
                     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;
+                    return globalObject.throw("Expected context to be a string, Buffer or TypedArray", .{});
                 }
             } else {
                 const buffer_size = @as(usize, @intCast(length));
@@ -2599,8 +2836,7 @@ fn NewSocket(comptime ssl: bool) type {
 
                 const result = BoringSSL.SSL_export_keying_material(ssl_ptr, buffer_ptr, buffer_size, @as([*c]const u8, @ptrCast(label_slice.ptr)), label_slice.len, null, 0, 0);
                 if (result != 1) {
-                    globalObject.throwValue(getSSLException(globalObject, "Failed to export keying material"));
-                    return .zero;
+                    return globalObject.throwValue(getSSLException(globalObject, "Failed to export keying material"));
                 }
                 return buffer;
             }
@@ -2610,7 +2846,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();
             }
@@ -2640,7 +2876,7 @@ fn NewSocket(comptime ssl: bool) type {
 
             switch (kid) {
                 BoringSSL.EVP_PKEY_DH => {
-                    result.put(globalObject, ZigString.static("type"), ZigString.static("DH").toJS(globalObject));
+                    result.put(globalObject, ZigString.static("type"), bun.String.static("DH").toJS(globalObject));
                     result.put(globalObject, ZigString.static("size"), JSValue.jsNumber(bits));
                 },
 
@@ -2663,7 +2899,7 @@ fn NewSocket(comptime ssl: bool) type {
                             curve_name = "";
                         }
                     }
-                    result.put(globalObject, ZigString.static("type"), ZigString.static("ECDH").toJS(globalObject));
+                    result.put(globalObject, ZigString.static("type"), bun.String.static("ECDH").toJS(globalObject));
                     result.put(globalObject, ZigString.static("name"), ZigString.fromUTF8(curve_name).toJS(globalObject));
                     result.put(globalObject, ZigString.static("size"), JSValue.jsNumber(bits));
                 },
@@ -2676,7 +2912,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();
             }
@@ -2720,7 +2956,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();
             }
@@ -2748,7 +2984,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();
             }
@@ -2776,7 +3012,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();
@@ -2864,7 +3100,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();
@@ -2883,32 +3119,28 @@ 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);
             }
 
-            const args = callframe.arguments(1);
+            const args = callframe.arguments_old(1);
 
             if (args.len < 1) {
-                globalObject.throw("Expected size to be a number", .{});
-                return .zero;
+                return globalObject.throw("Expected size to be a number", .{});
             }
 
             const arg = args.ptr[0];
             if (!arg.isNumber()) {
-                globalObject.throw("Expected size to be a number", .{});
-                return .zero;
+                return globalObject.throw("Expected size to be a number", .{});
             }
             const size = args.ptr[0].coerceToInt64(globalObject);
             if (size < 1) {
-                globalObject.throw("Expected size to be greater than 1", .{});
-                return .zero;
+                return globalObject.throw("Expected size to be greater than 1", .{});
             }
             if (size > 16384) {
-                globalObject.throw("Expected size to be less than 16385", .{});
-                return .zero;
+                return globalObject.throw("Expected size to be less than 16385", .{});
             }
 
             const ssl_ptr = this.socket.ssl() orelse return JSValue.jsBoolean(false);
@@ -2918,19 +3150,18 @@ 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();
             }
 
-            const args = callframe.arguments(1);
+            const args = callframe.arguments_old(1);
             var abbreviated: bool = true;
             if (args.len > 0) {
                 const arg = args.ptr[0];
                 if (!arg.isBoolean()) {
-                    globalObject.throw("Expected abbreviated to be a boolean", .{});
-                    return .zero;
+                    return globalObject.throw("Expected abbreviated to be a boolean", .{});
                 }
                 abbreviated = arg.toBoolean();
             }
@@ -2969,7 +3200,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();
             }
@@ -2986,7 +3217,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();
             }
@@ -3002,26 +3233,23 @@ 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();
             }
 
             if (this.handlers.is_server) {
-                globalObject.throw("Cannot issue SNI from a TLS server-side socket", .{});
-                return .zero;
+                return globalObject.throw("Cannot issue SNI from a TLS server-side socket", .{});
             }
 
-            const args = callframe.arguments(1);
+            const args = callframe.arguments_old(1);
             if (args.len < 1) {
-                globalObject.throw("Expected 1 argument", .{});
-                return .zero;
+                return globalObject.throw("Expected 1 argument", .{});
             }
 
             const server_name = args.ptr[0];
             if (!server_name.isString()) {
-                globalObject.throw("Expected \"serverName\" to be a string", .{});
-                return .zero;
+                return globalObject.throw("Expected \"serverName\" to be a string", .{});
             }
 
             const slice = server_name.getZigString(globalObject).toOwnedSlice(bun.default_allocator) catch bun.outOfMemory();
@@ -3038,8 +3266,7 @@ fn NewSocket(comptime ssl: bool) type {
 
                 if (ssl_ptr.isInitFinished()) {
                     // match node.js exceptions
-                    globalObject.throw("Already started.", .{});
-                    return .zero;
+                    return globalObject.throw("Already started.", .{});
                 }
                 const host__ = default_allocator.dupeZ(u8, host) catch bun.outOfMemory();
                 defer default_allocator.free(host__);
@@ -3056,7 +3283,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();
 
@@ -3071,41 +3298,27 @@ fn NewSocket(comptime ssl: bool) type {
                 return .zero;
             }
 
-            const args = callframe.arguments(1);
+            const args = callframe.arguments_old(1);
 
             if (args.len < 1) {
-                globalObject.throw("Expected 1 arguments", .{});
-                return .zero;
+                return globalObject.throw("Expected 1 arguments", .{});
             }
 
-            var exception: JSC.C.JSValueRef = null;
             var success = false;
 
             const opts = args.ptr[0];
             if (opts.isEmptyOrUndefinedOrNull() or opts.isBoolean() or !opts.isObject()) {
-                globalObject.throw("Expected options object", .{});
-                return .zero;
+                return globalObject.throw("Expected options object", .{});
             }
 
-            const socket_obj = opts.getOwn(globalObject, "socket") orelse {
-                globalObject.throw("Expected \"socket\" option", .{});
-                return .zero;
+            const socket_obj = try opts.get(globalObject, "socket") orelse {
+                return globalObject.throw("Expected \"socket\" option", .{});
             };
             if (globalObject.hasException()) {
                 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;
@@ -3120,31 +3333,24 @@ 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;
             }
 
             if (ssl_opts == null) {
-                globalObject.throw("Expected \"tls\" option", .{});
-                return .zero;
+                return globalObject.throw("Expected \"tls\" option", .{});
             }
 
             var default_data = JSValue.zero;
@@ -3230,12 +3436,12 @@ fn NewSocket(comptime ssl: bool) type {
 
                 // If BoringSSL gave us an error code, let's use it.
                 if (err != 0 and !globalObject.hasException()) {
-                    globalObject.throwValue(BoringSSL.ERR_toJS(globalObject, err));
+                    return globalObject.throwValue(BoringSSL.ERR_toJS(globalObject, err));
                 }
 
                 // If BoringSSL did not give us an error code, let's throw a generic error.
                 if (!globalObject.hasException()) {
-                    globalObject.throw("Failed to upgrade socket from TCP -> TLS. Is the TLS config correct?", .{});
+                    return globalObject.throw("Failed to upgrade socket from TCP -> TLS. Is the TLS config correct?", .{});
                 }
 
                 return JSValue.jsUndefined();
@@ -3247,7 +3453,8 @@ fn NewSocket(comptime ssl: bool) type {
             TLSSocket.dataSetCached(tls_js_value, globalObject, default_data);
 
             tls.socket = new_socket;
-            tls.socket_context = new_socket.context(); // owns the new tls context that have a ref from the old one
+            const new_context = new_socket.context().?;
+            tls.socket_context = new_context; // owns the new tls context that have a ref from the old one
             tls.ref();
             const vm = handlers.vm;
 
@@ -3277,7 +3484,7 @@ fn NewSocket(comptime ssl: bool) type {
                 .connection = if (this.connection) |c| c.clone() else null,
                 .wrapped = .tcp,
                 .protos = null,
-                .socket_context = null, // raw socket will dont own the context
+                .socket_context = new_context.ref(true),
             });
             raw.ref();
 
@@ -3318,6 +3525,7 @@ fn NewSocket(comptime ssl: bool) type {
             defer this.deref();
 
             // detach and invalidate the old instance
+            this.detachNativeCallback();
             this.socket.detach();
 
             // start TLS handshake after we set extension on the socket
@@ -3395,7 +3603,7 @@ pub fn NewWrappedHandler(comptime tls: bool) type {
             if (comptime tls) {
                 TLSSocket.onData(this.tls, socket, data);
             } else {
-                // tedius use this
+                // tedius use this (tedius is a pure-javascript implementation of TDS protocol used to interact with instances of Microsoft's SQL Server)
                 TLSSocket.onData(this.tcp, socket, data);
             }
         }
@@ -3973,72 +4181,58 @@ 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);
+    const arguments = callframe.arguments_old(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.throw("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);
+    const args = callframe.arguments_old(2);
     if (args.len < 2) {
-        globalObject.throw("Expected 2 arguments", .{});
-        return .zero;
+        return globalObject.throw("Expected 2 arguments", .{});
     }
     const duplex = args.ptr[0];
     // TODO: do better type checking
     if (duplex.isEmptyOrUndefinedOrNull()) {
-        globalObject.throw("Expected a Duplex instance", .{});
-        return .zero;
+        return globalObject.throw("Expected a Duplex instance", .{});
     }
 
-    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", .{});
-        return .zero;
+        return globalObject.throw("Expected options object", .{});
     }
 
-    const socket_obj = opts.getOwn(globalObject, "socket") orelse {
-        globalObject.throw("Expected \"socket\" option", .{});
-        return .zero;
+    const socket_obj = try opts.get(globalObject, "socket") orelse {
+        return globalObject.throw("Expected \"socket\" option", .{});
     };
 
-    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;
             }
         }
     }
     if (ssl_opts == null) {
-        globalObject.throw("Expected \"tls\" option", .{});
-        return .zero;
+        return globalObject.throw("Expected \"tls\" option", .{});
     }
 
     var default_data = JSValue.zero;
@@ -4107,13 +4301,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);
+    const arguments = callframe.arguments_old(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| {
@@ -4125,26 +4318,24 @@ 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) {
-        global.throw("Not implemented on Windows", .{});
-        return .zero;
+        return global.throw("Not implemented on Windows", .{});
     }
 
     var fds_: [2]std.c.fd_t = .{ 0, 0 };
     const rc = std.c.socketpair(std.posix.AF.UNIX, std.posix.SOCK.STREAM, 0, &fds_);
     if (rc != 0) {
         const err = bun.sys.Error.fromCode(bun.C.getErrno(rc), .socketpair);
-        global.throwValue(err.toJSC(global));
-        return .zero;
+        return global.throwValue(err.toJSC(global));
     }
 
     const array = JSC.JSValue.createEmptyArray(global, 2);
diff --git a/src/bun.js/api/bun/spawn/stdio.zig b/src/bun.js/api/bun/spawn/stdio.zig
index 1f4e332344..8a989d1ab0 100644
--- a/src/bun.js/api/bun/spawn/stdio.zig
+++ b/src/bun.js/api/bun/spawn/stdio.zig
@@ -58,9 +58,8 @@ pub const Stdio = union(enum) {
             };
         }
 
-        pub fn throwJS(this: *const @This(), globalThis: *JSC.JSGlobalObject) JSValue {
-            globalThis.throw("{s}", .{this.toStr()});
-            return .zero;
+        pub fn throwJS(this: *const @This(), globalThis: *JSC.JSGlobalObject) bun.JSError {
+            return globalThis.throw("{s}", .{this.toStr()});
         }
     };
 
@@ -290,19 +289,14 @@ pub const Stdio = union(enum) {
         };
     }
 
-    pub fn extract(
-        out_stdio: *Stdio,
-        globalThis: *JSC.JSGlobalObject,
-        i: u32,
-        value: JSValue,
-    ) bool {
+    pub fn extract(out_stdio: *Stdio, globalThis: *JSC.JSGlobalObject, i: u32, value: JSValue) bun.JSError!void {
         switch (value) {
             // undefined: default
-            .undefined, .zero => return true,
+            .undefined, .zero => return,
             // null: ignore
             .null => {
                 out_stdio.* = Stdio{ .ignore = {} };
-                return true;
+                return;
             },
             else => {},
         }
@@ -318,58 +312,47 @@ pub const Stdio = union(enum) {
             } else if (str.eqlComptime("ipc")) {
                 out_stdio.* = Stdio{ .ipc = {} };
             } else {
-                globalThis.throwInvalidArguments("stdio must be an array of 'inherit', 'pipe', 'ignore', Bun.file(pathOrFd), number, or null", .{});
-                return false;
+                return globalThis.throwInvalidArguments("stdio must be an array of 'inherit', 'pipe', 'ignore', Bun.file(pathOrFd), number, or null", .{});
             }
-
-            return true;
+            return;
         } else if (value.isNumber()) {
             const fd = value.asFileDescriptor();
             const file_fd = bun.uvfdcast(fd);
             if (file_fd < 0) {
-                globalThis.throwInvalidArguments("file descriptor must be a positive integer", .{});
-                return false;
+                return globalThis.throwInvalidArguments("file descriptor must be a positive integer", .{});
             }
 
             if (file_fd >= std.math.maxInt(i32)) {
                 var formatter = JSC.ConsoleObject.Formatter{ .globalThis = globalThis };
-                globalThis.throwInvalidArguments("file descriptor must be a valid integer, received: {}", .{
-                    value.toFmt(&formatter),
-                });
-                return false;
+                return globalThis.throwInvalidArguments("file descriptor must be a valid integer, received: {}", .{value.toFmt(&formatter)});
             }
 
             switch (bun.FDTag.get(fd)) {
                 .stdin => {
                     if (i == 1 or i == 2) {
-                        globalThis.throwInvalidArguments("stdin cannot be used for stdout or stderr", .{});
-                        return false;
+                        return globalThis.throwInvalidArguments("stdin cannot be used for stdout or stderr", .{});
                     }
 
                     out_stdio.* = Stdio{ .inherit = {} };
-                    return true;
+                    return;
                 },
-
                 .stdout, .stderr => |tag| {
                     if (i == 0) {
-                        globalThis.throwInvalidArguments("stdout and stderr cannot be used for stdin", .{});
-                        return false;
+                        return globalThis.throwInvalidArguments("stdout and stderr cannot be used for stdin", .{});
                     }
-
                     if (i == 1 and tag == .stdout) {
                         out_stdio.* = .{ .inherit = {} };
-                        return true;
+                        return;
                     } else if (i == 2 and tag == .stderr) {
                         out_stdio.* = .{ .inherit = {} };
-                        return true;
+                        return;
                     }
                 },
                 else => {},
             }
 
             out_stdio.* = Stdio{ .fd = fd };
-
-            return true;
+            return;
         } else if (value.as(JSC.WebCore.Blob)) |blob| {
             return out_stdio.extractBlob(globalThis, .{ .Blob = blob.dupe() }, i);
         } else if (value.as(JSC.WebCore.Request)) |req| {
@@ -387,17 +370,16 @@ pub const Stdio = union(enum) {
 
                 switch (req.ptr) {
                     .File, .Blob => {
-                        globalThis.throwTODO("Support fd/blob backed ReadableStream in spawn stdin. See https://github.com/oven-sh/bun/issues/8049");
-                        return false;
+                        globalThis.throwTODO("Support fd/blob backed ReadableStream in spawn stdin. See https://github.com/oven-sh/bun/issues/8049") catch {};
+                        return error.JSError;
                     },
                     .Direct, .JavaScript, .Bytes => {
                         // out_stdio.* = .{ .connect = req };
-                        globalThis.throwTODO("Re-enable ReadableStream support in spawn stdin. ");
-                        return false;
+                        globalThis.throwTODO("Re-enable ReadableStream support in spawn stdin. ") catch {};
+                        return error.JSError;
                     },
                     .Invalid => {
-                        globalThis.throwInvalidArguments("ReadableStream is in invalid state.", .{});
-                        return false;
+                        return globalThis.throwInvalidArguments("ReadableStream is in invalid state.", .{});
                     },
                 }
             }
@@ -405,7 +387,7 @@ pub const Stdio = union(enum) {
             // Change in Bun v1.0.34: don't throw for empty ArrayBuffer
             if (array_buffer.byteSlice().len == 0) {
                 out_stdio.* = .{ .ignore = {} };
-                return true;
+                return;
             }
 
             out_stdio.* = .{
@@ -414,20 +396,13 @@ pub const Stdio = union(enum) {
                     .held = JSC.Strong.create(array_buffer.value, globalThis),
                 },
             };
-
-            return true;
+            return;
         }
 
-        globalThis.throwInvalidArguments("stdio must be an array of 'inherit', 'ignore', or null", .{});
-        return false;
+        return globalThis.throwInvalidArguments("stdio must be an array of 'inherit', 'ignore', or null", .{});
     }
 
-    pub fn extractBlob(
-        stdio: *Stdio,
-        globalThis: *JSC.JSGlobalObject,
-        blob: JSC.WebCore.AnyBlob,
-        i: u32,
-    ) bool {
+    pub fn extractBlob(stdio: *Stdio, globalThis: *JSC.JSGlobalObject, blob: JSC.WebCore.AnyBlob, i: u32) bun.JSError!void {
         const fd = bun.stdio(i);
 
         if (blob.needsToReadFile()) {
@@ -439,15 +414,13 @@ pub const Stdio = union(enum) {
                         switch (bun.FDTag.get(i)) {
                             .stdin => {
                                 if (i == 1 or i == 2) {
-                                    globalThis.throwInvalidArguments("stdin cannot be used for stdout or stderr", .{});
-                                    return false;
+                                    return globalThis.throwInvalidArguments("stdin cannot be used for stdout or stderr", .{});
                                 }
                             },
 
                             .stdout, .stderr => {
                                 if (i == 0) {
-                                    globalThis.throwInvalidArguments("stdout and stderr cannot be used for stdin", .{});
-                                    return false;
+                                    return globalThis.throwInvalidArguments("stdout and stderr cannot be used for stdin", .{});
                                 }
                             },
                             else => {},
@@ -456,26 +429,25 @@ pub const Stdio = union(enum) {
                         stdio.* = Stdio{ .fd = store.data.file.pathlike.fd };
                     }
 
-                    return true;
+                    return;
                 }
 
                 stdio.* = .{ .path = store.data.file.pathlike.path };
-                return true;
+                return;
             }
         }
 
         if (i == 1 or i == 2) {
-            globalThis.throwInvalidArguments("Blobs are immutable, and cannot be used for stdout/stderr", .{});
-            return false;
+            return globalThis.throwInvalidArguments("Blobs are immutable, and cannot be used for stdout/stderr", .{});
         }
 
         // Instead of writing an empty blob, lets just make it /dev/null
         if (blob.fastSize() == 0) {
             stdio.* = .{ .ignore = {} };
-            return true;
+            return;
         }
 
         stdio.* = .{ .blob = blob };
-        return true;
+        return;
     }
 };
diff --git a/src/bun.js/api/bun/subprocess.zig b/src/bun.js/api/bun/subprocess.zig
index f51669b594..9dfceca67a 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,
@@ -203,6 +196,7 @@ pub const Subprocess = struct {
 
     weak_file_sink_stdin_ptr: ?*JSC.WebCore.FileSink = null,
     ref_count: u32 = 1,
+    abort_signal: ?*JSC.AbortSignal = null,
 
     usingnamespace bun.NewRefCounted(@This(), Subprocess.deinit);
 
@@ -226,18 +220,21 @@ pub const Subprocess = struct {
         poll_ref: Async.KeepAlive = .{},
     };
 
+    pub fn onAbortSignal(subprocess_ctx: ?*anyopaque, _: JSC.JSValue) callconv(.C) void {
+        var this: *Subprocess = @ptrCast(@alignCast(subprocess_ctx.?));
+        this.clearAbortSignal();
+        _ = this.tryKill(SignalCode.default);
+    }
+
     pub fn resourceUsage(
         this: *Subprocess,
         globalObject: *JSGlobalObject,
         _: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         return this.createResourceUsageObject(globalObject);
     }
 
-    pub fn createResourceUsageObject(
-        this: *Subprocess,
-        globalObject: *JSGlobalObject,
-    ) JSValue {
+    pub fn createResourceUsageObject(this: *Subprocess, globalObject: *JSGlobalObject) JSValue {
         const pid_rusage = this.pid_rusage orelse brk: {
             if (Environment.isWindows) {
                 if (this.process.poller == .uv) {
@@ -254,8 +251,7 @@ pub const Subprocess = struct {
         };
 
         var result = bun.default_allocator.create(ResourceUsage) catch {
-            globalObject.throwOutOfMemory();
-            return .zero;
+            return globalObject.throwOutOfMemoryValue();
         };
         result.* = resource_usage;
         return result.toJS(globalObject);
@@ -386,11 +382,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.throw("Cannot construct Subprocess", .{});
     }
 
     const Readable = union(enum) {
@@ -502,7 +495,7 @@ pub const Subprocess = struct {
             _ = exited; // autofix
             switch (this.*) {
                 // should only be reachable when the entire output is buffered.
-                .memfd => return this.toBufferedValue(globalThis),
+                .memfd => return this.toBufferedValue(globalThis) catch .zero,
 
                 .fd => |fd| {
                     return fd.toJS(globalThis);
@@ -528,7 +521,7 @@ pub const Subprocess = struct {
             }
         }
 
-        pub fn toBufferedValue(this: *Readable, globalThis: *JSC.JSGlobalObject) JSValue {
+        pub fn toBufferedValue(this: *Readable, globalThis: *JSC.JSGlobalObject) bun.JSError!JSValue {
             switch (this.*) {
                 .fd => |fd| {
                     return fd.toJS(globalThis);
@@ -585,7 +578,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;
@@ -601,8 +594,7 @@ pub const Subprocess = struct {
             .result => {},
             .err => |err| {
                 // Signal 9 should always be fine, but just in case that somehow fails.
-                global.throwValue(err.toJSC(global));
-                return .zero;
+                return global.throwValue(err.toJSC(global));
             },
         }
 
@@ -613,10 +605,10 @@ 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);
+        var arguments = callframe.arguments_old(1);
         // If signal is 0, then no actual signal is sent, but error checking
         // is still performed.
         const sig: i32 = brk: {
@@ -628,18 +620,15 @@ pub const Subprocess = struct {
 
                 // This matches node behavior, minus some details with the error messages: https://gist.github.com/Jarred-Sumner/23ba38682bf9d84dff2f67eb35c42ab6
                 if (std.math.isInf(sig64) or @trunc(sig64) != sig64) {
-                    globalThis.throwInvalidArguments("Unknown signal", .{});
-                    return .zero;
+                    return globalThis.throwInvalidArguments("Unknown signal", .{});
                 }
 
                 if (sig64 < 0) {
-                    globalThis.throwInvalidArguments("Invalid signal: must be >= 0", .{});
-                    return .zero;
+                    return globalThis.throwInvalidArguments("Invalid signal: must be >= 0", .{});
                 }
 
                 if (sig64 > 31) {
-                    globalThis.throwInvalidArguments("Invalid signal: must be < 32", .{});
-                    return .zero;
+                    return globalThis.throwInvalidArguments("Invalid signal: must be < 32", .{});
                 }
 
                 break :brk @intFromFloat(sig64);
@@ -647,11 +636,10 @@ 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", .{});
-                return .zero;
+                return globalThis.throwInvalidArguments("Invalid signal: must be a string or an integer", .{});
             }
 
             break :brk SignalCode.default;
@@ -663,8 +651,7 @@ pub const Subprocess = struct {
             .result => {},
             .err => |err| {
                 // EINVAL or ENOSYS means the signal is not supported in the current platform (most likely unsupported on windows)
-                globalThis.throwValue(err.toJSC(globalThis));
-                return .zero;
+                return globalThis.throwValue(err.toJSC(globalThis));
             },
         }
 
@@ -693,12 +680,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;
     }
@@ -717,20 +704,18 @@ 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()) {
-                global.throw("Subprocess.send() cannot be used after the process has exited.", .{});
+                return global.throw("Subprocess.send() cannot be used after the process has exited.", .{});
             } else {
-                global.throw("Subprocess.send() can only be used if an IPC channel is open.", .{});
+                return global.throw("Subprocess.send() can only be used if an IPC channel is open.", .{});
             }
-            return .zero;
         });
 
         if (callFrame.argumentsCount() == 0) {
-            global.throwInvalidArguments("Subprocess.send() requires one argument", .{});
-            return .zero;
+            return global.throwInvalidArguments("Subprocess.send() requires one argument", .{});
         }
 
         const value = callFrame.argument(0);
@@ -744,7 +729,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);
@@ -1430,16 +1415,20 @@ pub const Subprocess = struct {
         }
     };
 
-    pub fn onProcessExit(this: *Subprocess, _: *Process, status: bun.spawn.Status, rusage: *const Rusage) void {
+    pub fn onProcessExit(this: *Subprocess, process: *Process, status: bun.spawn.Status, rusage: *const Rusage) void {
         log("onProcessExit()", .{});
         const this_jsvalue = this.this_jsvalue;
         const globalThis = this.globalThis;
+        const jsc_vm = globalThis.bunVM();
         this_jsvalue.ensureStillAlive();
         this.pid_rusage = rusage.*;
         const is_sync = this.flags.is_sync;
+        this.clearAbortSignal();
         defer this.deref();
         defer this.disconnectIPC(true);
 
+        jsc_vm.onSubprocessExit(process);
+
         var stdin: ?*JSC.WebCore.FileSink = this.weak_file_sink_stdin_ptr;
         var existing_stdin_value = JSC.JSValue.zero;
         if (this_jsvalue != .zero) {
@@ -1472,7 +1461,7 @@ pub const Subprocess = struct {
         var did_update_has_pending_activity = false;
         defer if (!did_update_has_pending_activity) this.updateHasPendingActivity();
 
-        const loop = globalThis.bunVM().eventLoop();
+        const loop = jsc_vm.eventLoop();
 
         if (!is_sync) {
             if (this.exit_promise.trySwap()) |promise| {
@@ -1587,6 +1576,15 @@ pub const Subprocess = struct {
         this.destroy();
     }
 
+    fn clearAbortSignal(this: *Subprocess) void {
+        if (this.abort_signal) |signal| {
+            this.abort_signal = null;
+            signal.pendingActivityUnref();
+            signal.cleanNativeBindings(this);
+            signal.unref();
+        }
+    }
+
     pub fn finalize(this: *Subprocess) callconv(.C) void {
         log("finalize", .{});
         // Ensure any code which references the "this" value doesn't attempt to
@@ -1594,6 +1592,8 @@ pub const Subprocess = struct {
         // access GC'd values during the finalizer
         this.this_jsvalue = .zero;
 
+        this.clearAbortSignal();
+
         bun.assert(!this.hasPendingActivity() or JSC.VirtualMachine.get().isShuttingDown());
         this.finalizeStreams();
 
@@ -1652,11 +1652,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);
     }
 
@@ -1665,7 +1665,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();
@@ -1702,11 +1702,17 @@ pub const Subprocess = struct {
 
         var windows_hide: bool = false;
         var windows_verbatim_arguments: bool = false;
+        var abort_signal: ?*JSC.WebCore.AbortSignal = null;
+        defer {
+            // Ensure we clean it up on error.
+            if (abort_signal) |signal| {
+                signal.unref();
+            }
+        }
 
         {
             if (args.isEmptyOrUndefinedOrNull()) {
-                globalThis.throwInvalidArguments("cmd must be an array", .{});
-                return .zero;
+                return globalThis.throwInvalidArguments("cmd must be an array", .{});
             }
 
             const args_type = args.jsType();
@@ -1714,34 +1720,26 @@ pub const Subprocess = struct {
                 cmd_value = args;
                 args = secondaryArgsValue orelse JSValue.zero;
             } else if (!args.isObject()) {
-                globalThis.throwInvalidArguments("cmd must be an array", .{});
-                return .zero;
-            } else if (args.getOwnTruthy(globalThis, "cmd")) |cmd_value_| {
+                return globalThis.throwInvalidArguments("cmd must be an array", .{});
+            } else if (try args.getTruthy(globalThis, "cmd")) |cmd_value_| {
                 cmd_value = cmd_value_;
             } else {
-                globalThis.throwInvalidArguments("cmd must be an array", .{});
-                return .zero;
+                return globalThis.throwInvalidArguments("cmd must be an array", .{});
             }
 
             if (args.isObject()) {
-                if (args.getOwnTruthy(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 {
-                            globalThis.throwOutOfMemory();
-                            return .zero;
-                        };
+                        argv0 = try argv0_str.toOwnedSliceZ(allocator);
                     }
                 }
 
                 // need to update `cwd` before searching for executable with `Which.which`
-                if (args.getOwnTruthy(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 {
-                            globalThis.throwOutOfMemory();
-                            return .zero;
-                        };
+                        cwd = try cwd_str.toOwnedSliceZ(allocator);
                     }
                 }
             }
@@ -1750,52 +1748,36 @@ pub const Subprocess = struct {
                 var cmds_array = cmd_value.arrayIterator(globalThis);
                 // + 1 for argv0
                 // + 1 for null terminator
-                argv = @TypeOf(argv).initCapacity(allocator, cmds_array.len + 2) catch {
-                    globalThis.throwOutOfMemory();
-                    return .zero;
-                };
+                argv = try @TypeOf(argv).initCapacity(allocator, cmds_array.len + 2);
 
                 if (cmd_value.isEmptyOrUndefinedOrNull()) {
-                    globalThis.throwInvalidArguments("cmd must be an array of strings", .{});
-                    return .zero;
+                    return globalThis.throwInvalidArguments("cmd must be an array of strings", .{});
                 }
 
                 if (cmds_array.len == 0) {
-                    globalThis.throwInvalidArguments("cmd must not be empty", .{});
-                    return .zero;
+                    return globalThis.throwInvalidArguments("cmd must not be empty", .{});
                 }
 
                 {
                     var first_cmd = cmds_array.next().?;
-                    var arg0 = first_cmd.toSliceOrNullWithAllocator(globalThis, allocator) orelse return .zero;
+                    var arg0 = try first_cmd.toSliceOrNullWithAllocator(globalThis, allocator);
                     defer arg0.deinit();
 
                     if (argv0 == null) {
                         var path_buf: bun.PathBuffer = undefined;
                         const resolved = Which.which(&path_buf, PATH, cwd, arg0.slice()) orelse {
-                            globalThis.throwInvalidArguments("Executable not found in $PATH: \"{s}\"", .{arg0.slice()});
-                            return .zero;
-                        };
-                        argv0 = allocator.dupeZ(u8, resolved) catch {
-                            globalThis.throwOutOfMemory();
-                            return .zero;
+                            return throwCommandNotFound(globalThis, arg0.slice());
                         };
+                        argv0 = try allocator.dupeZ(u8, resolved);
                     } else {
                         var path_buf: bun.PathBuffer = undefined;
                         const resolved = Which.which(&path_buf, PATH, cwd, bun.sliceTo(argv0.?, 0)) orelse {
-                            globalThis.throwInvalidArguments("Executable not found in $PATH: \"{s}\"", .{arg0.slice()});
-                            return .zero;
-                        };
-                        argv0 = allocator.dupeZ(u8, resolved) catch {
-                            globalThis.throwOutOfMemory();
-                            return .zero;
+                            return throwCommandNotFound(globalThis, arg0.slice());
                         };
+                        argv0 = try allocator.dupeZ(u8, resolved);
                     }
 
-                    argv.appendAssumeCapacity(allocator.dupeZ(u8, arg0.slice()) catch {
-                        globalThis.throwOutOfMemory();
-                        return .zero;
-                    });
+                    argv.appendAssumeCapacity(try allocator.dupeZ(u8, arg0.slice()));
                 }
 
                 while (cmds_array.next()) |value| {
@@ -1805,35 +1787,31 @@ pub const Subprocess = struct {
                     if (arg.len == 0) {
                         continue;
                     }
-                    argv.appendAssumeCapacity(arg.toOwnedSliceZ(allocator) catch {
-                        globalThis.throwOutOfMemory();
-                        return .zero;
-                    });
+                    argv.appendAssumeCapacity(try arg.toOwnedSliceZ(allocator));
                 }
 
                 if (argv.items.len == 0) {
-                    globalThis.throwInvalidArguments("cmd must be an array of strings", .{});
-                    return .zero;
+                    return globalThis.throwInvalidArguments("cmd must be an array of strings", .{});
                 }
             }
 
             if (args != .zero and args.isObject()) {
                 // This must run before the stdio parsing happens
                 if (!is_sync) {
-                    if (args.getOwnTruthy(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.getOwnTruthy(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()) {
-                                                globalThis.throwInvalidArguments("serialization must be \"json\" or \"advanced\"", .{});
+                                                return globalThis.throwInvalidArguments("serialization must be \"json\" or \"advanced\"", .{});
                                             }
-                                            return .zero;
+                                            return error.JSError;
                                         };
                                     } else {
                                         if (!globalThis.hasException()) {
-                                            globalThis.throwInvalidArgumentType("spawn", "serialization", "string");
+                                            return globalThis.throwInvalidArgumentType("spawn", "serialization", "string");
                                         }
                                         return .zero;
                                     }
@@ -1846,10 +1824,17 @@ pub const Subprocess = struct {
                     }
                 }
 
-                if (args.getOwnTruthy(globalThis, "onDisconnect")) |onDisconnect_| {
+                if (try args.getTruthy(globalThis, "signal")) |signal_val| {
+                    if (signal_val.as(JSC.WebCore.AbortSignal)) |signal| {
+                        abort_signal = signal.ref();
+                    } else {
+                        return globalThis.throwInvalidArgumentTypeValue("signal", "AbortSignal", signal_val);
+                    }
+                }
+
+                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;
+                        return globalThis.throwInvalidArguments("onDisconnect must be a function or undefined", .{});
                     }
 
                     on_disconnect_callback = if (comptime is_sync)
@@ -1858,10 +1843,9 @@ pub const Subprocess = struct {
                         onDisconnect_.withAsyncContextIfNeeded(globalThis);
                 }
 
-                if (args.getOwnTruthy(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;
+                        return globalThis.throwInvalidArguments("onExit must be a function or undefined", .{});
                     }
 
                     on_exit_callback = if (comptime is_sync)
@@ -1870,30 +1854,25 @@ pub const Subprocess = struct {
                         onExit_.withAsyncContextIfNeeded(globalThis);
                 }
 
-                if (args.getOwnTruthy(globalThis, "env")) |object| {
+                if (try args.getTruthy(globalThis, "env")) |object| {
                     if (!object.isObject()) {
-                        globalThis.throwInvalidArguments("env must be an object", .{});
-                        return .zero;
+                        return globalThis.throwInvalidArguments("env must be an object", .{});
                     }
 
                     override_env = true;
                     // If the env object does not include a $PATH, it must disable path lookup for argv[0]
                     PATH = "";
                     var envp_managed = env_array.toManaged(allocator);
-                    appendEnvpFromJS(globalThis, object, &envp_managed, &PATH) catch {
-                        globalThis.throwOutOfMemory();
-                        return .zero;
-                    };
+                    try appendEnvpFromJS(globalThis, object, &envp_managed, &PATH);
                     env_array = envp_managed.moveToUnmanaged();
                 }
-                if (args.getOwn(globalThis, "stdio")) |stdio_val| {
+                if (try args.get(globalThis, "stdio")) |stdio_val| {
                     if (!stdio_val.isEmptyOrUndefinedOrNull()) {
                         if (stdio_val.jsType().isArray()) {
                             var stdio_iter = stdio_val.arrayIterator(globalThis);
                             var i: u32 = 0;
                             while (stdio_iter.next()) |value| : (i += 1) {
-                                if (!stdio[i].extract(globalThis, i, value))
-                                    return .undefined;
+                                try stdio[i].extract(globalThis, i, value);
                                 if (i == 2)
                                     break;
                             }
@@ -1901,9 +1880,7 @@ pub const Subprocess = struct {
 
                             while (stdio_iter.next()) |value| : (i += 1) {
                                 var new_item: Stdio = undefined;
-                                if (!new_item.extract(globalThis, i, value)) {
-                                    return .undefined;
-                                }
+                                try new_item.extract(globalThis, i, value);
 
                                 const opt = switch (new_item.asSpawnOption(i)) {
                                     .result => |opt| opt,
@@ -1914,55 +1891,48 @@ pub const Subprocess = struct {
                                 if (opt == .ipc) {
                                     ipc_channel = @intCast(extra_fds.items.len);
                                 }
-                                extra_fds.append(opt) catch {
-                                    globalThis.throwOutOfMemory();
-                                    return .zero;
-                                };
+                                try extra_fds.append(opt);
                             }
                         } else {
-                            globalThis.throwInvalidArguments("stdio must be an array", .{});
-                            return .zero;
+                            return globalThis.throwInvalidArguments("stdio must be an array", .{});
                         }
                     }
                 } else {
-                    if (args.getOwn(globalThis, "stdin")) |value| {
-                        if (!stdio[0].extract(globalThis, 0, value))
-                            return .zero;
+                    if (try args.get(globalThis, "stdin")) |value| {
+                        try stdio[0].extract(globalThis, 0, value);
                     }
 
-                    if (args.getOwn(globalThis, "stderr")) |value| {
-                        if (!stdio[2].extract(globalThis, 2, value))
-                            return .zero;
+                    if (try args.get(globalThis, "stderr")) |value| {
+                        try stdio[2].extract(globalThis, 2, value);
                     }
 
-                    if (args.getOwn(globalThis, "stdout")) |value| {
-                        if (!stdio[1].extract(globalThis, 1, value))
-                            return .zero;
+                    if (try args.get(globalThis, "stdout")) |value| {
+                        try stdio[1].extract(globalThis, 1, value);
                     }
                 }
 
                 if (comptime !is_sync) {
-                    if (args.getOwn(globalThis, "lazy")) |lazy_val| {
+                    if (try args.get(globalThis, "lazy")) |lazy_val| {
                         if (lazy_val.isBoolean()) {
                             lazy = lazy_val.toBoolean();
                         }
                     }
                 }
 
-                if (args.getOwn(globalThis, "detached")) |detached_val| {
+                if (try args.get(globalThis, "detached")) |detached_val| {
                     if (detached_val.isBoolean()) {
                         detached = detached_val.toBoolean();
                     }
                 }
 
                 if (Environment.isWindows) {
-                    if (args.getOwn(globalThis, "windowsHide")) |val| {
+                    if (try args.get(globalThis, "windowsHide")) |val| {
                         if (val.isBoolean()) {
                             windows_hide = val.asBoolean();
                         }
                     }
 
-                    if (args.getOwn(globalThis, "windowsVerbatimArguments")) |val| {
+                    if (try args.get(globalThis, "windowsVerbatimArguments")) |val| {
                         if (val.isBoolean()) {
                             windows_verbatim_arguments = val.asBoolean();
                         }
@@ -1972,8 +1942,7 @@ pub const Subprocess = struct {
         }
 
         if (!override_env and env_array.items.len == 0) {
-            env_array.items = jsc_vm.bundler.env.map.createNullDelimitedEnvMap(allocator) catch |err|
-                return globalThis.handleError(err, "in Bun.spawn");
+            env_array.items = jsc_vm.bundler.env.map.createNullDelimitedEnvMap(allocator) catch |err| return globalThis.throwError(err, "in Bun.spawn") catch return .zero;
             env_array.capacity = env_array.items.len;
         }
 
@@ -2007,7 +1976,7 @@ pub const Subprocess = struct {
             // And then one fd is assigned specifically and only for IPC. If the user dont specify it, we add one (default: 3).
             //
             // When Bun.spawn() is given an `.ipc` callback, it enables IPC as follows:
-            env_array.ensureUnusedCapacity(allocator, 3) catch |err| return globalThis.handleError(err, "in Bun.spawn");
+            env_array.ensureUnusedCapacity(allocator, 3) catch |err| return globalThis.throwError(err, "in Bun.spawn") catch return .zero;
             const ipc_fd: u32 = brk: {
                 if (ipc_channel == -1) {
                     // If the user didn't specify an IPC channel, we need to add one
@@ -2016,10 +1985,7 @@ pub const Subprocess = struct {
                     const fd: u32 = @intCast(ipc_channel + 3);
                     switch (ipc_extra_fd_default.asSpawnOption(fd)) {
                         .result => |opt| {
-                            extra_fds.append(opt) catch {
-                                globalThis.throwOutOfMemory();
-                                return .zero;
-                            };
+                            try extra_fds.append(opt);
                         },
                         .err => |e| {
                             return e.throwJS(globalThis);
@@ -2036,8 +2002,7 @@ pub const Subprocess = struct {
                 "NODE_CHANNEL_FD={d}",
                 .{ipc_fd},
             ) catch {
-                globalThis.throwOutOfMemory();
-                return .zero;
+                return globalThis.throwOutOfMemory();
             };
             env_array.appendAssumeCapacity(pipe_env);
 
@@ -2046,14 +2011,8 @@ pub const Subprocess = struct {
             });
         };
 
-        env_array.append(allocator, null) catch {
-            globalThis.throwOutOfMemory();
-            return .zero;
-        };
-        argv.append(null) catch {
-            globalThis.throwOutOfMemory();
-            return .zero;
-        };
+        try env_array.append(allocator, null);
+        try argv.append(null);
 
         if (comptime is_sync) {
             for (&stdio, 0..) |*io, i| {
@@ -2092,14 +2051,11 @@ pub const Subprocess = struct {
             @ptrCast(env_array.items.ptr),
         ) catch |err| {
             spawn_options.deinit();
-            globalThis.throwError(err, ": failed to spawn process");
-
-            return .zero;
+            return globalThis.throwError(err, ": failed to spawn process") catch return .zero;
         }) {
             .err => |err| {
                 spawn_options.deinit();
-                globalThis.throwValue(err.toJSC(globalThis));
-                return .zero;
+                return globalThis.throwValue(err.toJSC(globalThis));
             },
             .result => |result| result,
         };
@@ -2141,9 +2097,8 @@ pub const Subprocess = struct {
                 subprocess,
                 spawned.stdin,
             ) catch {
-                globalThis.throwOutOfMemory();
                 subprocess.deref();
-                return .zero;
+                return globalThis.throwOutOfMemory();
             },
             .stdout = Readable.init(
                 stdio[1],
@@ -2215,8 +2170,7 @@ pub const Subprocess = struct {
                     subprocess.stdio_pipes.items[@intCast(ipc_channel)].buffer,
                 ).asErr()) |err| {
                     subprocess.deref();
-                    globalThis.throwValue(err.toJSC(globalThis));
-                    return .zero;
+                    return globalThis.throwValue(err.toJSC(globalThis));
                 }
                 subprocess.stdio_pipes.items[@intCast(ipc_channel)] = .unavailable;
             }
@@ -2280,18 +2234,42 @@ pub const Subprocess = struct {
         should_close_memfd = false;
 
         if (comptime !is_sync) {
+            // Once everything is set up, we can add the abort listener
+            // Adding the abort listener may call the onAbortSignal callback immediately if it was already aborted
+            // Therefore, we must do this at the very end.
+            if (abort_signal) |signal| {
+                signal.pendingActivityRef();
+                subprocess.abort_signal = signal.addListener(subprocess, onAbortSignal);
+                abort_signal = null;
+            }
+            if (!subprocess.process.hasExited()) {
+                jsc_vm.onSubprocessSpawn(subprocess.process);
+            }
             return out;
         }
 
         if (comptime is_sync) {
             switch (subprocess.process.watchOrReap()) {
-                .result => {},
+                .result => {
+                    // Once everything is set up, we can add the abort listener
+                    // Adding the abort listener may call the onAbortSignal callback immediately if it was already aborted
+                    // Therefore, we must do this at the very end.
+                    if (abort_signal) |signal| {
+                        signal.pendingActivityRef();
+                        subprocess.abort_signal = signal.addListener(subprocess, onAbortSignal);
+                        abort_signal = null;
+                    }
+                },
                 .err => {
                     subprocess.process.wait(true);
                 },
             }
         }
 
+        if (!subprocess.process.hasExited()) {
+            jsc_vm.onSubprocessSpawn(subprocess.process);
+        }
+
         while (subprocess.hasPendingActivityNonThreadsafe()) {
             if (subprocess.stdin == .buffer) {
                 subprocess.stdin.buffer.watch();
@@ -2313,11 +2291,16 @@ pub const Subprocess = struct {
 
         const signalCode = subprocess.getSignalCode(globalThis);
         const exitCode = subprocess.getExitCode(globalThis);
-        const stdout = subprocess.stdout.toBufferedValue(globalThis);
-        const stderr = subprocess.stderr.toBufferedValue(globalThis);
-        const resource_usage = subprocess.createResourceUsageObject(globalThis);
+        const stdout = try subprocess.stdout.toBufferedValue(globalThis);
+        const stderr = try subprocess.stderr.toBufferedValue(globalThis);
+        const resource_usage: JSValue = if (!globalThis.hasException()) subprocess.createResourceUsageObject(globalThis) else .zero;
         subprocess.finalize();
 
+        if (globalThis.hasException()) {
+            // e.g. a termination exception.
+            return .zero;
+        }
+
         const sync_value = JSC.JSValue.createEmptyObject(globalThis, 5 + @as(usize, @intFromBool(!signalCode.isEmptyOrUndefinedOrNull())));
         sync_value.put(globalThis, JSC.ZigString.static("exitCode"), exitCode);
         if (!signalCode.isEmptyOrUndefinedOrNull()) {
@@ -2331,6 +2314,15 @@ pub const Subprocess = struct {
         return sync_value;
     }
 
+    fn throwCommandNotFound(globalThis: *JSC.JSGlobalObject, command: []const u8) bun.JSError {
+        const message = bun.String.createFormat("Executable not found in $PATH: \"{s}\"", .{command}) catch bun.outOfMemory();
+        defer message.deref();
+        const err = message.toZigString().toErrorInstance(globalThis);
+        err.putZigString(globalThis, JSC.ZigString.static("code"), JSC.ZigString.init("ENOENT").toJS(globalThis));
+        err.putZigString(globalThis, JSC.ZigString.static("path"), JSC.ZigString.init(command).toJS(globalThis));
+        return globalThis.throwValue(err);
+    }
+
     const node_cluster_binding = @import("./../../node/node_cluster_binding.zig");
 
     pub fn handleIPCMessage(
@@ -2357,7 +2349,7 @@ pub const Subprocess = struct {
             },
             .internal => |data| {
                 IPC.log("Received IPC internal message from child", .{});
-                node_cluster_binding.handleInternalMessagePrimary(this.globalThis, this, data);
+                node_cluster_binding.handleInternalMessagePrimary(this.globalThis, this, data) catch {};
             },
         }
     }
diff --git a/src/bun.js/api/bun/udp_socket.zig b/src/bun.js/api/bun/udp_socket.zig
index b26d327ecf..14297ce810 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.throwInvalidArguments("Expected an object", .{});
         }
 
         const hostname = brk: {
-            if (options.getOwnTruthy(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.throwInvalidArguments("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.getOwnTruthy(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.throwInvalidArguments("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.getOwnTruthy(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.throwInvalidArguments("Expected \"socket\" to be an object", .{});
             }
 
-            if (options.getOwnTruthy(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.throwInvalidArguments("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.throwInvalidArguments("Expected \"socket.binaryType\" to be 'arraybuffer', 'uint8array', or 'buffer'", .{});
                 };
             }
 
             inline for (handlers) |handler| {
-                if (socket.getOwnTruthyComptime(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.throwInvalidArguments("Expected \"socket.{s}\" to be a function", .{handler.@"0"});
                     }
                     @field(config, handler.@"1") = value;
                 }
@@ -198,25 +191,21 @@ pub const UDPSocketConfig = struct {
             }
         }
 
-        if (options.getOwnTruthy(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.throwInvalidArguments("Expected \"connect\" to be an object", .{});
             }
 
-            const connect_host_js = connect.getOwnTruthy(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.throwInvalidArguments("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.throwInvalidArguments("Expected \"connect.hostname\" to be a string", .{});
             }
 
-            const connect_port_js = connect.getOwnTruthy(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.throwInvalidArguments("Expected \"connect.port\" to be an integer", .{});
             };
             const connect_port = connect_port_js.coerceToInt32(globalThis);
 
@@ -281,23 +270,16 @@ pub const UDPSocket = struct {
 
     pub usingnamespace JSC.Codegen.JSUDPSocket;
 
-    pub fn constructor(globalThis: *JSGlobalObject, _: *CallFrame) ?*This {
-        globalThis.throw("Cannot construct UDPSocket", .{});
-        return null;
-    }
-
     pub fn hasPendingActivity(this: *This) callconv(.C) bool {
         return this.js_refcount.load(.monotonic) > 0;
     }
 
     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 +309,14 @@ pub const UDPSocket = struct {
         )) |socket| {
             this.socket = socket;
         } else {
-            globalThis.throw("Failed to bind socket", .{});
-            return .zero;
+            return globalThis.throw("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.throwValue(err.toJS(globalThis));
                 }
             }
             this.connect_info = .{ .port = connect.port };
@@ -370,27 +350,23 @@ 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;
+            return globalThis.throw("Socket is closed", .{});
         }
-        const arguments = callframe.arguments(1);
+        const arguments = callframe.arguments_old(1);
         if (arguments.len != 1) {
-            globalThis.throwInvalidArguments("Expected 1 argument, got {}", .{arguments.len});
-            return .zero;
+            return globalThis.throwInvalidArguments("Expected 1 argument, got {}", .{arguments.len});
         }
 
         const arg = arguments.ptr[0];
         if (!arg.jsType().isArray()) {
-            globalThis.throwInvalidArgumentType("sendMany", "first argument", "array");
-            return .zero;
+            return globalThis.throwInvalidArgumentType("sendMany", "first argument", "array");
         }
 
         const array_len = arg.getLength(globalThis);
         if (this.connect_info == null and array_len % 3 != 0) {
-            globalThis.throwInvalidArguments("Expected 3 arguments for each packet", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("Expected 3 arguments for each packet", .{});
         }
 
         const len = if (this.connect_info == null) array_len / 3 else array_len;
@@ -410,8 +386,7 @@ pub const UDPSocket = struct {
         var port: JSValue = .zero;
         while (iter.next()) |val| : (i += 1) {
             if (i >= array_len) {
-                globalThis.throwInvalidArguments("Mismatch between array length property and number of items", .{});
-                return .zero;
+                return globalThis.throwInvalidArguments("Mismatch between array length property and number of items", .{});
             }
             const slice_idx = if (this.connect_info == null) i / 3 else i;
             if (this.connect_info != null or i % 3 == 0) {
@@ -421,8 +396,7 @@ pub const UDPSocket = struct {
                     } else if (val.isString()) {
                         break :brk val.toString(globalThis).toSlice(globalThis, alloc).slice();
                     } else {
-                        globalThis.throwInvalidArguments("Expected ArrayBufferView or string as payload", .{});
-                        return .zero;
+                        return globalThis.throwInvalidArguments("Expected ArrayBufferView or string as payload", .{});
                     }
                 };
                 payloads[slice_idx] = slice.ptr;
@@ -438,49 +412,38 @@ pub const UDPSocket = struct {
             }
             if (i % 3 == 2) {
                 if (!this.parseAddr(globalThis, port, val, &addrs[slice_idx])) {
-                    globalThis.throwInvalidArguments("Invalid address", .{});
-                    return .zero;
+                    return globalThis.throwInvalidArguments("Invalid address", .{});
                 }
                 addr_ptrs[slice_idx] = &addrs[slice_idx];
             }
         }
         if (i != array_len) {
-            globalThis.throwInvalidArguments("Mismatch between array length property and number of items", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("Mismatch between array length property and number of items", .{});
         }
         const res = this.socket.send(payloads, lens, addr_ptrs);
         if (bun.JSC.Maybe(void).errnoSys(res, .send)) |err| {
-            globalThis.throwValue(err.toJS(globalThis));
-            return .zero;
+            return globalThis.throwValue(err.toJS(globalThis));
         }
         return JSValue.jsNumber(res);
     }
 
-    pub fn send(
-        this: *This,
-        globalThis: *JSGlobalObject,
-        callframe: *CallFrame,
-    ) JSValue {
+    pub fn send(this: *This, globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         if (this.closed) {
-            globalThis.throw("Socket is closed", .{});
-            return .zero;
+            return globalThis.throw("Socket is closed", .{});
         }
-        const arguments = callframe.arguments(3);
+        const arguments = callframe.arguments_old(3);
         const dst: ?Destination = brk: {
             if (this.connect_info != null) {
                 if (arguments.len == 1) {
                     break :brk null;
                 }
                 if (arguments.len == 3) {
-                    globalThis.throwInvalidArguments("Cannot specify destination on connected socket", .{});
-                    return .zero;
+                    return globalThis.throwInvalidArguments("Cannot specify destination on connected socket", .{});
                 }
-                globalThis.throwInvalidArguments("Expected 1 argument, got {}", .{arguments.len});
-                return .zero;
+                return globalThis.throwInvalidArguments("Expected 1 argument, got {}", .{arguments.len});
             } else {
                 if (arguments.len != 3) {
-                    globalThis.throwInvalidArguments("Expected 3 arguments, got {}", .{arguments.len});
-                    return .zero;
+                    return globalThis.throwInvalidArguments("Expected 3 arguments, got {}", .{arguments.len});
                 }
                 break :brk .{
                     .port = arguments.ptr[1],
@@ -499,8 +462,7 @@ pub const UDPSocket = struct {
                 payload_str = payload_arg.asString().toSlice(globalThis, bun.default_allocator);
                 break :brk payload_str.slice();
             } else {
-                globalThis.throwInvalidArguments("Expected ArrayBufferView or string as first argument", .{});
-                return .zero;
+                return globalThis.throwInvalidArguments("Expected ArrayBufferView or string as first argument", .{});
             }
         };
 
@@ -508,8 +470,7 @@ pub const UDPSocket = struct {
         const addr_ptr = brk: {
             if (dst) |dest| {
                 if (!this.parseAddr(globalThis, dest.port, dest.address, &addr)) {
-                    globalThis.throwInvalidArguments("Invalid address", .{});
-                    return .zero;
+                    return globalThis.throwInvalidArguments("Invalid address", .{});
                 }
                 break :brk &addr;
             } else {
@@ -519,8 +480,7 @@ pub const UDPSocket = struct {
 
         const res = this.socket.send(&.{payload.ptr}, &.{payload.len}, &.{addr_ptr});
         if (bun.JSC.Maybe(void).errnoSys(res, .send)) |err| {
-            globalThis.throwValue(err.toJS(globalThis));
-            return .zero;
+            return globalThis.throwValue(err.toJS(globalThis));
         }
         return JSValue.jsBoolean(res > 0);
     }
@@ -563,7 +523,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 +531,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 +541,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 {
-        const args = callframe.arguments(1);
+    pub fn reload(this: *This, globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
+        const args = callframe.arguments_old(1);
 
         if (args.len < 1) {
-            globalThis.throwInvalidArguments("Expected 1 argument", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("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;
@@ -631,7 +588,8 @@ pub const UDPSocket = struct {
         };
 
         const slice = bun.fmt.formatIp(address, &text_buf) catch unreachable;
-        return bun.String.createLatin1(slice).toJS(globalThis);
+        var str = bun.String.createLatin1(slice);
+        return str.transferToJS(globalThis);
     }
 
     pub fn getAddress(this: *This, globalThis: *JSGlobalObject) JSValue {
@@ -671,9 +629,9 @@ pub const UDPSocket = struct {
         globalThis: *JSGlobalObject,
     ) JSValue {
         return switch (this.config.binary_type) {
-            .Buffer => JSC.ZigString.init("buffer").toJS(globalThis),
-            .Uint8Array => JSC.ZigString.init("uint8array").toJS(globalThis),
-            .ArrayBuffer => JSC.ZigString.init("arraybuffer").toJS(globalThis),
+            .Buffer => bun.String.static("buffer").toJS(globalThis),
+            .Uint8Array => bun.String.static("uint8array").toJS(globalThis),
+            .ArrayBuffer => bun.String.static("arraybuffer").toJS(globalThis),
             else => @panic("Invalid binary type"),
         };
     }
@@ -692,27 +650,23 @@ pub const UDPSocket = struct {
         this.destroy();
     }
 
-    pub fn jsConnect(globalThis: *JSC.JSGlobalObject, callFrame: *JSC.CallFrame) JSC.JSValue {
-        const args = callFrame.arguments(2);
+    pub fn jsConnect(globalThis: *JSC.JSGlobalObject, callFrame: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+        const args = callFrame.arguments_old(2);
 
         const this = callFrame.this().as(UDPSocket) orelse {
-            globalThis.throwInvalidArguments("Expected UDPSocket as 'this'", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("Expected UDPSocket as 'this'", .{});
         };
 
         if (this.connect_info != null) {
-            globalThis.throw("Socket is already connected", .{});
-            return .zero;
+            return globalThis.throw("Socket is already connected", .{});
         }
 
         if (this.closed) {
-            globalThis.throw("Socket is closed", .{});
-            return .zero;
+            return globalThis.throw("Socket is closed", .{});
         }
 
         if (args.len < 2) {
-            globalThis.throwInvalidArguments("Expected 2 arguments", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("Expected 2 arguments", .{});
         }
 
         const str = args.ptr[0].toBunString(globalThis);
@@ -723,16 +677,14 @@ pub const UDPSocket = struct {
         const connect_port_js = args.ptr[1];
 
         if (!connect_port_js.isNumber()) {
-            globalThis.throwInvalidArguments("Expected \"port\" to be an integer", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("Expected \"port\" to be an integer", .{});
         }
 
         const connect_port = connect_port_js.asInt32();
         const port: u16 = if (connect_port < 1 or connect_port > 0xffff) 0 else @as(u16, @intCast(connect_port));
 
         if (this.socket.connect(connect_host, port) == -1) {
-            globalThis.throw("Failed to connect socket", .{});
-            return .zero;
+            return globalThis.throw("Failed to connect socket", .{});
         }
         this.connect_info = .{
             .port = port,
@@ -742,25 +694,21 @@ 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;
+            return globalObject.throwInvalidArguments("Expected UDPSocket as 'this'", .{});
         };
 
         if (this.connect_info == null) {
-            globalObject.throw("Socket is not connected", .{});
-            return .zero;
+            return globalObject.throw("Socket is not connected", .{});
         }
 
         if (this.closed) {
-            globalObject.throw("Socket is closed", .{});
-            return .zero;
+            return globalObject.throw("Socket is closed", .{});
         }
 
         if (this.socket.disconnect() == -1) {
-            globalObject.throw("Failed to disconnect socket", .{});
-            return .zero;
+            return globalObject.throw("Failed to disconnect socket", .{});
         }
         this.connect_info = null;
 
diff --git a/src/bun.js/api/bun/x509.zig b/src/bun.js/api/bun/x509.zig
index c5c63ddc9b..c3efe96669 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,19 +434,18 @@ 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;
+        return globalObject.throw("Failed to create BIO", .{});
     };
     defer _ = BoringSSL.BIO_free(bio);
     var result = JSValue.createEmptyObject(globalObject, 8);
     // 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));
@@ -485,8 +484,7 @@ pub fn toJS(cert: *BoringSSL.X509, globalObject: *JSGlobalObject) JSValue {
 
                 const size = BoringSSL.i2d_RSA_PUBKEY(rsa, null);
                 if (size <= 0) {
-                    globalObject.throw("Failed to get public key length", .{});
-                    return .zero;
+                    return globalObject.throw("Failed to get public key length", .{});
                 }
 
                 var buffer = JSValue.createBufferFromLength(globalObject, @as(usize, @intCast(size)));
@@ -515,8 +513,7 @@ pub fn toJS(cert: *BoringSSL.X509, globalObject: *JSGlobalObject) JSValue {
                     const form = BoringSSL.EC_KEY_get_conv_form(ec);
                     const size = BoringSSL.EC_POINT_point2oct(group, point, form, null, 0, null);
                     if (size <= 0) {
-                        globalObject.throw("Failed to get public key length", .{});
-                        return .zero;
+                        return globalObject.throw("Failed to get public key length", .{});
                     }
 
                     var buffer = JSValue.createBufferFromLength(globalObject, @as(usize, @intCast(size)));
diff --git a/src/bun.js/api/ffi.zig b/src/bun.js/api/ffi.zig
index 858595cac2..0fd9ff1644 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";
                     }
                 }
             }
@@ -322,8 +334,7 @@ pub const FFI = struct {
 
         pub fn compile(this: *CompileC, globalThis: *JSGlobalObject) !struct { *TCC.TCCState, []u8 } {
             const state = TCC.tcc_new() orelse {
-                globalThis.throw("TinyCC failed to initialize", .{});
-                return error.JSException;
+                return globalThis.throw("TinyCC failed to initialize", .{});
             };
             TCC.tcc_set_error_func(state, this, @ptrCast(&handleCompilationError));
             if (this.flags.len > 0) {
@@ -355,14 +366,12 @@ pub const FFI = struct {
                         if (sdkroot.len > 0) {
                             const include_dir = bun.path.joinAbsStringBufZ(sdkroot, &pathbuf, &.{ "usr", "include" }, .auto);
                             if (TCC.tcc_add_sysinclude_path(state, include_dir.ptr) == -1) {
-                                globalThis.throw("TinyCC failed to add sysinclude path", .{});
-                                return error.JSException;
+                                return globalThis.throw("TinyCC failed to add sysinclude path", .{});
                             }
 
                             const lib_dir = bun.path.joinAbsStringBufZ(sdkroot, &pathbuf, &.{ "usr", "lib" }, .auto);
                             if (TCC.tcc_add_library_path(state, lib_dir.ptr) == -1) {
-                                globalThis.throw("TinyCC failed to add library path", .{});
-                                return error.JSException;
+                                return globalThis.throw("TinyCC failed to add library path", .{});
                             }
                             break :add_system_include_dir;
                         }
@@ -432,6 +441,13 @@ pub const FFI = struct {
                 return error.DeferredErrors;
             }
 
+            for (this.symbols.map.values()) |*symbol| {
+                if (symbol.needsNapiEnv()) {
+                    _ = TCC.tcc_add_symbol(state, "Bun__thisFFIModuleNapiEnv", globalThis);
+                    break;
+                }
+            }
+
             for (this.define.items) |define| {
                 TCC.tcc_define_symbol(state, define[0], define[1]);
 
@@ -445,9 +461,9 @@ pub const FFI = struct {
                     return error.DeferredErrors;
                 } else {
                     if (!globalThis.hasException()) {
-                        globalThis.throw("TinyCC failed to compile", .{});
+                        return globalThis.throw("TinyCC failed to compile", .{});
                     }
-                    return error.JSException;
+                    return error.JSError;
                 }
             };
 
@@ -484,8 +500,7 @@ pub const FFI = struct {
             }
 
             if (relocation_size < 0) {
-                globalThis.throw("Unexpected: tcc_relocate returned a negative value", .{});
-                return error.JSException;
+                return globalThis.throw("Unexpected: tcc_relocate returned a negative value", .{});
             }
 
             const bytes: []u8 = try bun.default_allocator.alloc(u8, @as(usize, @intCast(relocation_size)));
@@ -509,8 +524,7 @@ pub const FFI = struct {
                 if (TCC.tcc_get_symbol(state, duped)) |function_ptr| {
                     function.symbol_from_dynamic_library = function_ptr;
                 } else {
-                    globalThis.throw("{} is missing from {s}. Was it included in the source code?", .{ bun.fmt.quote(symbol), this.source.first() });
-                    return error.JSException;
+                    return globalThis.throw("{} is missing from {s}. Was it included in the source code?", .{ bun.fmt.quote(symbol), this.source.first() });
                 }
             }
 
@@ -568,7 +582,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);
 
@@ -578,8 +592,7 @@ pub const FFI = struct {
                         bun.default_allocator.free(@constCast(item));
                     }
                     items.deinit();
-                    _ = globalThis.throwInvalidArgumentTypeValue(property, "array of strings", val);
-                    return .{};
+                    return globalThis.throwInvalidArgumentTypeValue(property, "array of strings", val);
                 }
                 const str = val.getZigString(globalThis);
                 if (str.isEmpty()) continue;
@@ -589,11 +602,10 @@ 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 globalThis.throwInvalidArgumentTypeValue(property, "array of strings", value);
             }
             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 {
-        const arguments = callframe.arguments(1).slice();
+    pub fn Bun__FFI__cc(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+        const arguments = callframe.arguments_old(1).slice();
         if (arguments.len == 0 or !arguments[0].isObject()) {
-            return JSC.toInvalidArguments("Expected object", .{}, globalThis);
+            return globalThis.throwInvalidArguments("Expected object", .{});
         }
 
         // Step 1. compile the user's code
@@ -629,33 +641,32 @@ 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 globalThis.throwInvalidArgumentTypeValue("symbols", "object", symbols_object);
         }
 
         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 globalThis.throwValue(val);
+            return error.JSError;
         }
 
         if (compile_c.symbols.map.count() == 0) {
-            globalThis.throw("Expected at least one exported symbol", .{});
-            return .zero;
+            return globalThis.throw("Expected at least one exported symbol", .{});
         }
 
         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.getOwnTruthy(globalThis, "flags")) |flags_value| {
+        if (try object.getTruthy(globalThis, "flags")) |flags_value| {
             if (flags_value.isArray()) {
                 var iter = flags_value.arrayIterator(globalThis);
 
@@ -689,10 +700,10 @@ pub const FFI = struct {
         }
 
         if (globalThis.hasException()) {
-            return .zero;
+            return error.JSError;
         }
 
-        if (object.getOwnTruthy(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 +721,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 +730,15 @@ pub const FFI = struct {
         }
 
         if (globalThis.hasException()) {
-            return .zero;
+            return error.JSError;
         }
 
-        if (object.getOwnTruthy(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 +760,7 @@ pub const FFI = struct {
         }
 
         if (globalThis.hasException()) {
-            return .zero;
+            return error.JSError;
         }
 
         // Now we compile the code with tinycc.
@@ -765,16 +776,10 @@ pub const FFI = struct {
                         writer.print("{s}\n", .{deferred_error}) catch bun.outOfMemory();
                     }
 
-                    globalThis.throw("{s}", .{combined.items});
-                    return .zero;
-                },
-                error.JSException => {
-                    return .zero;
-                },
-                error.OutOfMemory => {
-                    globalThis.throwOutOfMemory();
-                    return .zero;
+                    return globalThis.throw("{s}", .{combined.items});
                 },
+                error.JSError => |e| return e,
+                error.OutOfMemory => |e| return e,
             }
         };
         defer {
@@ -791,26 +796,23 @@ pub const FFI = struct {
             const function_name = function.base_name.?;
             const allocator = bun.default_allocator;
 
-            function.compile(allocator) catch |err| {
+            function.compile(allocator, globalThis) catch |err| {
                 if (!globalThis.hasException()) {
                     const ret = JSC.toInvalidArguments("{s} when translating symbol \"{s}\"", .{
                         @errorName(err),
                         function_name,
                     }, globalThis);
-                    globalThis.throwValue(ret);
+                    return 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 globalThis.throwValue(res);
                 },
                 .pending => {
-                    globalThis.throw("Failed to compile (nothing happend!)", .{});
-                    return .zero;
+                    return globalThis.throw("Failed to compile (nothing happend!)", .{});
                 },
                 .compiled => |*compiled| {
                     const str = ZigString.init(bun.asByteSlice(function_name));
@@ -821,6 +823,7 @@ pub const FFI = struct {
                         bun.cast(JSC.JSHostFunctionPtr, compiled.ptr),
                         false,
                         true,
+                        function.symbol_from_dynamic_library,
                     );
                     compiled.js_function = cb;
                     obj.put(globalThis, &str, cb);
@@ -903,7 +906,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;
@@ -1131,7 +1134,7 @@ pub const FFI = struct {
                 function.symbol_from_dynamic_library = resolved_symbol;
             }
 
-            function.compile(allocator) catch |err| {
+            function.compile(allocator, global) catch |err| {
                 const ret = JSC.toInvalidArguments("{s} when compiling symbol \"{s}\" in \"{s}\"", .{
                     bun.asByteSlice(@errorName(err)),
                     bun.asByteSlice(function_name),
@@ -1176,6 +1179,7 @@ pub const FFI = struct {
                         bun.cast(JSC.JSHostFunctionPtr, compiled.ptr),
                         false,
                         true,
+                        function.symbol_from_dynamic_library,
                     );
                     compiled.js_function = cb;
                     obj.put(global, &str, cb);
@@ -1236,7 +1240,7 @@ pub const FFI = struct {
                 return ret;
             }
 
-            function.compile(allocator) catch |err| {
+            function.compile(allocator, global) catch |err| {
                 const ret = JSC.toInvalidArguments("{s} when compiling symbol \"{s}\"", .{
                     bun.asByteSlice(@errorName(err)),
                     bun.asByteSlice(function_name),
@@ -1278,6 +1282,7 @@ pub const FFI = struct {
                         bun.cast(JSC.JSHostFunctionPtr, compiled.ptr),
                         false,
                         true,
+                        function.symbol_from_dynamic_library,
                     );
                     compiled.js_function = cb;
 
@@ -1296,7 +1301,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 +1352,11 @@ pub const FFI = struct {
 
         var threadsafe = false;
 
-        if (value.getOwnTruthy(global, "threadsafe")) |threadsafe_value| {
+        if (try value.getTruthy(global, "threadsafe")) |threadsafe_value| {
             threadsafe = threadsafe_value.toBoolean();
         }
 
-        if (value.getOwnTruthy(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) {
@@ -1396,7 +1401,7 @@ pub const FFI = struct {
             .threadsafe = threadsafe,
         };
 
-        if (value.get(global, "ptr")) |ptr| {
+        if (try value.get(global, "ptr")) |ptr| {
             if (ptr.isNumber()) {
                 const num = ptr.asPtrAddress();
                 if (num > 0)
@@ -1411,7 +1416,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;
 
@@ -1517,7 +1523,7 @@ pub const FFI = struct {
         };
 
         pub fn ffiHeader() string {
-            return if (Environment.embed_code)
+            return if (Environment.codegen_embed)
                 @embedFile("./FFI.h")
             else
                 bun.runtimeEmbedFile(.src, "bun.js/api/FFI.h");
@@ -1544,6 +1550,7 @@ pub const FFI = struct {
         pub fn compile(
             this: *Function,
             allocator: std.mem.Allocator,
+            globalObject: *JSC.JSGlobalObject,
         ) !void {
             var source_code = std.ArrayList(u8).init(allocator);
             var source_code_writer = source_code.writer();
@@ -1566,6 +1573,8 @@ pub const FFI = struct {
 
             _ = TCC.tcc_set_output_type(state, TCC.TCC_OUTPUT_MEMORY);
 
+            _ = TCC.tcc_add_symbol(state, "Bun__thisFFIModuleNapiEnv", globalObject);
+
             CompilerRT.define(state);
 
             // TCC.tcc_define_symbol(
@@ -1673,6 +1682,8 @@ pub const FFI = struct {
 
             _ = TCC.tcc_set_output_type(state, TCC.TCC_OUTPUT_MEMORY);
 
+            _ = TCC.tcc_add_symbol(state, "Bun__thisFFIModuleNapiEnv", js_context);
+
             CompilerRT.define(state);
 
             const compilation_result = TCC.tcc_compile_string(
@@ -1800,7 +1811,7 @@ pub const FFI = struct {
 
             if (this.needsHandleScope()) {
                 try writer.writeAll(
-                    \\  void* handleScope = NapiHandleScope__push(JS_GLOBAL_OBJECT, false);
+                    \\  void* handleScope = NapiHandleScope__open(&Bun__thisFFIModuleNapiEnv, false);
                     \\
                 );
             }
@@ -1813,7 +1824,7 @@ pub const FFI = struct {
                 for (this.arg_types.items, 0..) |arg, i| {
                     if (arg == .napi_env) {
                         try writer.print(
-                            \\  napi_env arg{d} = (napi_env)JS_GLOBAL_OBJECT;
+                            \\  napi_env arg{d} = (napi_env)&Bun__thisFFIModuleNapiEnv;
                             \\  argsPtr++;
                             \\
                         ,
@@ -1913,7 +1924,7 @@ pub const FFI = struct {
 
             if (this.needsHandleScope()) {
                 try writer.writeAll(
-                    \\  NapiHandleScope__pop(JS_GLOBAL_OBJECT, handleScope);
+                    \\  NapiHandleScope__close(&Bun__thisFFIModuleNapiEnv, handleScope);
                     \\
                 );
             }
@@ -2045,6 +2056,16 @@ pub const FFI = struct {
 
             try writer.writeAll(";\n}\n\n");
         }
+
+        fn needsNapiEnv(this: *const FFI.Function) bool {
+            for (this.arg_types.items) |arg| {
+                if (arg == .napi_env or arg == .napi_value) {
+                    return true;
+                }
+            }
+
+            return false;
+        }
     };
 
     // Must be kept in sync with JSFFIFunction.h version
@@ -2229,7 +2250,7 @@ pub const FFI = struct {
                         try writer.writeAll("JSVALUE_TO_FLOAT(");
                     },
                     .napi_env => {
-                        try writer.writeAll("(napi_env)JS_GLOBAL_OBJECT");
+                        try writer.writeAll("((napi_env)&Bun__thisFFIModuleNapiEnv)");
                         return;
                     },
                     .napi_value => {
@@ -2290,7 +2311,7 @@ pub const FFI = struct {
                         try writer.print("FLOAT_TO_JSVALUE({s})", .{self.symbol});
                     },
                     .napi_env => {
-                        try writer.writeAll("JS_GLOBAL_OBJECT");
+                        try writer.writeAll("((napi_env)&Bun__thisFFIModuleNapiEnv)");
                     },
                     .napi_value => {
                         try writer.print("((EncodedJSValue) {{.asNapiValue = {s} }} )", .{self.symbol});
@@ -2487,8 +2508,8 @@ const CompilerRT = struct {
     pub fn inject(state: *TCC.TCCState) void {
         _ = TCC.tcc_add_symbol(state, "memset", &memset);
         _ = TCC.tcc_add_symbol(state, "memcpy", &memcpy);
-        _ = TCC.tcc_add_symbol(state, "NapiHandleScope__push", &bun.JSC.napi.NapiHandleScope.NapiHandleScope__push);
-        _ = TCC.tcc_add_symbol(state, "NapiHandleScope__pop", &bun.JSC.napi.NapiHandleScope.NapiHandleScope__pop);
+        _ = TCC.tcc_add_symbol(state, "NapiHandleScope__open", &bun.JSC.napi.NapiHandleScope.NapiHandleScope__open);
+        _ = TCC.tcc_add_symbol(state, "NapiHandleScope__close", &bun.JSC.napi.NapiHandleScope.NapiHandleScope__close);
 
         _ = TCC.tcc_add_symbol(
             state,
diff --git a/src/bun.js/api/filesystem_router.classes.ts b/src/bun.js/api/filesystem_router.classes.ts
index 4c331f7de9..99ec5c56c4 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 40f28ca9f7..8738fbce70 100644
--- a/src/bun.js/api/filesystem_router.zig
+++ b/src/bun.js/api/filesystem_router.zig
@@ -20,10 +20,9 @@ const JSError = Base.JSError;
 const JSValue = JSC.JSValue;
 const JSGlobalObject = JSC.JSGlobalObject;
 const strings = bun.strings;
-
 const To = Base.To;
 const Request = WebCore.Request;
-
+const Environment = bun.Environment;
 const URLPath = @import("../../http/url_path.zig");
 const URL = @import("../../url.zig").URL;
 const Log = bun.logger;
@@ -49,17 +48,15 @@ pub const FileSystemRouter = struct {
 
     pub usingnamespace JSC.Codegen.JSFileSystemRouter;
 
-    pub fn constructor(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) ?*FileSystemRouter {
-        const argument_ = callframe.arguments(1);
+    pub fn constructor(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!*FileSystemRouter {
+        const argument_ = callframe.arguments_old(1);
         if (argument_.len == 0) {
-            globalThis.throwInvalidArguments("Expected object", .{});
-            return null;
+            return globalThis.throwInvalidArguments("Expected object", .{});
         }
 
         const argument = argument_.ptr[0];
         if (argument.isEmptyOrUndefinedOrNull() or !argument.isObject()) {
-            globalThis.throwInvalidArguments("Expected object", .{});
-            return null;
+            return globalThis.throwInvalidArguments("Expected object", .{});
         }
         var vm = globalThis.bunVM();
 
@@ -69,20 +66,17 @@ pub const FileSystemRouter = struct {
         var asset_prefix_slice: ZigString.Slice = .{};
 
         var out_buf: [bun.MAX_PATH_BYTES * 2]u8 = undefined;
-        if (argument.getOwn(globalThis, "style")) |style_val| {
+        if (try 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.throwInvalidArguments("Only 'nextjs' style is currently implemented", .{});
             }
         } else {
-            globalThis.throwInvalidArguments("Expected 'style' option (ex: \"style\": \"nextjs\")", .{});
-            return null;
+            return globalThis.throwInvalidArguments("Expected 'style' option (ex: \"style\": \"nextjs\")", .{});
         }
 
-        if (argument.getOwn(globalThis, "dir")) |dir| {
+        if (try argument.get(globalThis, "dir")) |dir| {
             if (!dir.isString()) {
-                globalThis.throwInvalidArguments("Expected dir to be a string", .{});
-                return null;
+                return globalThis.throwInvalidArguments("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,44 +91,40 @@ pub const FileSystemRouter = struct {
             }
         } else {
             // dir is not optional
-            globalThis.throwInvalidArguments("Expected dir to be a string", .{});
-            return null;
+            return globalThis.throwInvalidArguments("Expected dir to be a string", .{});
         }
         var arena = globalThis.allocator().create(bun.ArenaAllocator) catch unreachable;
         arena.* = bun.ArenaAllocator.init(globalThis.allocator());
         const allocator = arena.allocator();
         var extensions = std.ArrayList(string).init(allocator);
-        if (argument.getOwn(globalThis, "fileExtensions")) |file_extensions| {
+        if (try 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.throwInvalidArguments("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.throwInvalidArguments("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.getOwnTruthy(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.throwInvalidArguments("Expected assetPrefix to be a string", .{});
             }
 
             asset_prefix_slice = asset_prefix.toSlice(globalThis, allocator).clone(allocator) catch unreachable;
@@ -147,17 +137,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.throwValue(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.throw("Unable to find directory: {s}", .{root_dir_path.slice()});
         };
 
         var router = Router.init(vm.bundler.fs, allocator, .{
@@ -167,29 +155,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.throwValue(log.toJS(globalThis, globalThis.allocator(), "loading routes"));
         };
 
-        if (argument.getOwn(globalThis, "origin")) |origin| {
+        if (try 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.throwInvalidArguments("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.throwValue(log.toJS(globalThis, globalThis.allocator(), "loading routes"));
         }
 
         var fs_router = globalThis.allocator().create(FileSystemRouter) catch unreachable;
@@ -211,7 +196,51 @@ pub const FileSystemRouter = struct {
         return fs_router;
     }
 
-    pub fn reload(this: *FileSystemRouter, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+    threadlocal var win32_normalized_dir_info_cache_buf: if (Environment.isWindows) [bun.MAX_PATH_BYTES * 2]u8 else void = undefined;
+    pub fn bustDirCacheRecursive(this: *FileSystemRouter, globalThis: *JSC.JSGlobalObject, inputPath: []const u8) void {
+        var vm = globalThis.bunVM();
+        var path = inputPath;
+        if (comptime Environment.isWindows) {
+            path = vm.bundler.resolver.fs.normalizeBuf(&win32_normalized_dir_info_cache_buf, path);
+        }
+
+        const root_dir_info = vm.bundler.resolver.readDirInfo(path) catch {
+            return;
+        };
+
+        if (root_dir_info) |dir| {
+            if (dir.getEntriesConst()) |entries| {
+                var iter = entries.data.iterator();
+                outer: while (iter.next()) |entry_ptr| {
+                    const entry = entry_ptr.value_ptr.*;
+                    if (entry.base()[0] == '.') {
+                        continue :outer;
+                    }
+                    if (entry.kind(&vm.bundler.fs.fs, false) == .dir) {
+                        inline for (Router.banned_dirs) |banned_dir| {
+                            if (strings.eqlComptime(entry.base(), comptime banned_dir)) {
+                                continue :outer;
+                            }
+                        }
+
+                        var abs_parts_con = [_]string{ entry.dir, entry.base() };
+                        const full_path = vm.bundler.fs.abs(&abs_parts_con);
+
+                        _ = vm.bundler.resolver.bustDirCache(strings.withoutTrailingSlashWindowsPath(full_path));
+                        bustDirCacheRecursive(this, globalThis, full_path);
+                    }
+                }
+            }
+        }
+
+        _ = vm.bundler.resolver.bustDirCache(path);
+    }
+
+    pub fn bustDirCache(this: *FileSystemRouter, globalThis: *JSC.JSGlobalObject) void {
+        bustDirCacheRecursive(this, globalThis, strings.withoutTrailingSlashWindowsPath(this.router.config.dir));
+    }
+
+    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;
@@ -225,14 +254,14 @@ pub const FileSystemRouter = struct {
         vm.bundler.resolver.log = &log;
         defer vm.bundler.resolver.log = orig_log;
 
+        bustDirCache(this, globalThis);
+
         const root_dir_info = vm.bundler.resolver.readDirInfo(this.router.config.dir) catch {
-            globalThis.throwValue(log.toJS(globalThis, globalThis.allocator(), "reading root directory"));
-            return .zero;
+            return globalThis.throwValue(log.toJS(globalThis, globalThis.allocator(), "reading root directory"));
         } orelse {
-            globalThis.throw("Unable to find directory: {s}", .{this.router.config.dir});
             arena.deinit();
             globalThis.allocator().destroy(arena);
-            return .zero;
+            return globalThis.throw("Unable to find directory: {s}", .{this.router.config.dir});
         };
 
         var router = Router.init(vm.bundler.fs, allocator, .{
@@ -241,11 +270,9 @@ pub const FileSystemRouter = struct {
             .asset_prefix_path = this.router.config.asset_prefix_path,
         }) 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"));
-
             arena.deinit();
             globalThis.allocator().destroy(arena);
-            return .zero;
+            return globalThis.throwValue(log.toJS(globalThis, globalThis.allocator(), "loading routes"));
         };
 
         this.arena.deinit();
@@ -259,17 +286,15 @@ pub const FileSystemRouter = struct {
         return this_value;
     }
 
-    pub fn match(this: *FileSystemRouter, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
-        const argument_ = callframe.arguments(2);
+    pub fn match(this: *FileSystemRouter, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
+        const argument_ = callframe.arguments_old(2);
         if (argument_.len == 0) {
-            globalThis.throwInvalidArguments("Expected string, Request or Response", .{});
-            return JSValue.zero;
+            return globalThis.throwInvalidArguments("Expected string, Request or Response", .{});
         }
 
         const argument = argument_.ptr[0];
         if (argument.isEmptyOrUndefinedOrNull() or !argument.isCell()) {
-            globalThis.throwInvalidArguments("Expected string, Request or Response", .{});
-            return JSValue.zero;
+            return globalThis.throwInvalidArguments("Expected string, Request or Response", .{});
         }
 
         var path: ZigString.Slice = brk: {
@@ -288,8 +313,7 @@ pub const FileSystemRouter = struct {
                 }
             }
 
-            globalThis.throwInvalidArguments("Expected string, Request or Response", .{});
-            return JSValue.zero;
+            return globalThis.throwInvalidArguments("Expected string, Request or Response", .{});
         };
 
         if (path.len == 0 or (path.len == 1 and path.ptr[0] == '/')) {
@@ -303,8 +327,7 @@ pub const FileSystemRouter = struct {
         }
 
         const url_path = URLPath.parse(path.slice()) catch |err| {
-            globalThis.throw("{s} parsing path: {s}", .{ @errorName(err), path.slice() });
-            return JSValue.zero;
+            return globalThis.throw("{s} parsing path: {s}", .{ @errorName(err), path.slice() });
         };
         var params = Router.Param.List{};
         defer params.deinit(globalThis.allocator());
@@ -355,7 +378,7 @@ pub const FileSystemRouter = struct {
     }
 
     pub fn getStyle(_: *FileSystemRouter, globalThis: *JSC.JSGlobalObject) JSValue {
-        return ZigString.static("nextjs").toJS(globalThis);
+        return bun.String.static("nextjs").toJS(globalThis);
     }
 
     pub fn getAssetPrefix(this: *FileSystemRouter, globalThis: *JSC.JSGlobalObject) JSValue {
@@ -531,11 +554,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 5d48b71caa..85051929db 100644
--- a/src/bun.js/api/glob.zig
+++ b/src/bun.js/api/glob.zig
@@ -39,17 +39,14 @@ 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 "";
 
         const cwd_str = cwd_str: {
             // If its absolute return as is
             if (ResolvePath.Platform.auto.isAbsolute(cwd_str_raw.slice())) {
-                const cwd_str = cwd_str_raw.clone(allocator) catch {
-                    globalThis.throwOutOfMemory();
-                    return null;
-                };
+                const cwd_str = try cwd_str_raw.clone(allocator);
                 break :cwd_str cwd_str.ptr[0..cwd_str.len];
             }
 
@@ -57,10 +54,7 @@ const ScanOpts = struct {
 
             if (!absolute) {
                 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;
-                };
+                break :cwd_str try allocator.dupe(u8, cwd_str);
             }
 
             // Convert to an absolute path
@@ -69,8 +63,7 @@ const ScanOpts = struct {
                 .result => |cwd| cwd,
                 .err => |err| {
                     const errJs = err.toJSC(globalThis);
-                    globalThis.throwValue(errJs);
-                    return null;
+                    return globalThis.throwValue(errJs);
                 },
             };
 
@@ -79,21 +72,17 @@ const ScanOpts = struct {
                 cwd_str_raw.slice(),
             }, .auto);
 
-            break :cwd_str allocator.dupe(u8, cwd_str) catch {
-                globalThis.throwOutOfMemory();
-                return null;
-            };
+            break :cwd_str try allocator.dupe(u8, cwd_str);
         };
 
         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.throw("{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,53 +95,47 @@ 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;
             }
-            globalThis.throw("{s}: expected first argument to be an object", .{fnName});
-            return null;
+            return globalThis.throw("{s}: expected first argument to be an object", .{fnName});
         }
 
-        if (optsObj.getOwnTruthy(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.getOwnTruthy(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.getOwnTruthy(globalThis, "followSymlinks")) |followSymlinksVal| {
+        if (try optsObj.getTruthy(globalThis, "followSymlinks")) |followSymlinksVal| {
             out.follow_symlinks = if (followSymlinksVal.isBoolean()) followSymlinksVal.asBoolean() else false;
         }
 
-        if (optsObj.getOwnTruthy(globalThis, "absolute")) |absoluteVal| {
+        if (try optsObj.getTruthy(globalThis, "absolute")) |absoluteVal| {
             out.absolute = if (absoluteVal.isBoolean()) absoluteVal.asBoolean() else false;
         }
 
-        if (optsObj.getOwnTruthy(globalThis, "cwd")) |cwdVal| {
+        if (try optsObj.getTruthy(globalThis, "cwd")) |cwdVal| {
             if (!cwdVal.isString()) {
-                globalThis.throw("{s}: invalid `cwd`, not a string", .{fnName});
-                return null;
+                return globalThis.throw("{s}: invalid `cwd`, not a string", .{fnName});
             }
 
-            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.getOwnTruthy(globalThis, "dot")) |dot| {
+        if (try optsObj.getTruthy(globalThis, "dot")) |dot| {
             out.dot = if (dot.isBoolean()) dot.asBoolean() else false;
         }
 
@@ -248,8 +231,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;
@@ -257,15 +240,12 @@ fn makeGlobWalker(
     const error_on_broken_symlinks = matchOpts.error_on_broken_symlinks;
     const only_files = matchOpts.only_files;
 
+    var globWalker = try alloc.create(GlobWalker);
+    errdefer alloc.destroy(globWalker);
+    globWalker.* = .{};
+
     if (cwd != null) {
-        var globWalker = alloc.create(GlobWalker) catch {
-            globalThis.throwOutOfMemory();
-            return null;
-        };
-
-        globWalker.* = .{};
-
-        switch (globWalker.initWithCwd(
+        switch (try globWalker.initWithCwd(
             arena,
             this.pattern,
             cwd.?,
@@ -274,25 +254,16 @@ fn makeGlobWalker(
             follow_symlinks,
             error_on_broken_symlinks,
             only_files,
-        ) catch {
-            globalThis.throwOutOfMemory();
-            return null;
-        }) {
+        )) {
             .err => |err| {
-                globalThis.throwValue(err.toJSC(globalThis));
-                return null;
+                return globalThis.throwValue(err.toJSC(globalThis));
             },
             else => {},
         }
         return globWalker;
     }
-    var globWalker = alloc.create(GlobWalker) catch {
-        globalThis.throwOutOfMemory();
-        return null;
-    };
 
-    globWalker.* = .{};
-    switch (globWalker.init(
+    switch (try globWalker.init(
         arena,
         this.pattern,
         dot,
@@ -300,40 +271,30 @@ fn makeGlobWalker(
         follow_symlinks,
         error_on_broken_symlinks,
         only_files,
-    ) catch {
-        globalThis.throwOutOfMemory();
-        return null;
-    }) {
+    )) {
         .err => |err| {
-            globalThis.throwValue(err.toJSC(globalThis));
-            return null;
+            return globalThis.throwValue(err.toJSC(globalThis));
         },
         else => {},
     }
-
     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);
+    const arguments_ = callframe.arguments_old(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.throw("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.throw("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 +302,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,15 +339,15 @@ 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);
+    const arguments_ = callframe.arguments_old(1);
     var arguments = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments_.slice());
     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;
     };
@@ -400,35 +355,30 @@ pub fn __scan(this: *Glob, globalThis: *JSGlobalObject, callframe: *JSC.CallFram
     incrPendingActivityFlag(&this.has_pending_activity);
     var task = WalkTask.create(globalThis, alloc, globWalker, &this.has_pending_activity) catch {
         decrPendingActivityFlag(&this.has_pending_activity);
-        globalThis.throwOutOfMemory();
-        return .undefined;
+        return globalThis.throwOutOfMemory();
     };
     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);
+    const arguments_ = callframe.arguments_old(1);
     var arguments = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments_.slice());
     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;
     };
     defer globWalker.deinit(true);
 
-    switch (globWalker.walk() catch {
-        globalThis.throwOutOfMemory();
-        return .undefined;
-    }) {
+    switch (try globWalker.walk()) {
         .err => |err| {
-            globalThis.throwValue(err.toJSC(globalThis));
-            return JSValue.undefined;
+            return globalThis.throwValue(err.toJSC(globalThis));
         },
         .result => {},
     }
@@ -438,22 +388,20 @@ 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();
 
-    const arguments_ = callframe.arguments(1);
+    const arguments_ = callframe.arguments_old(1);
     var arguments = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments_.slice());
     defer arguments.deinit();
     const str_arg = arguments.nextEat() orelse {
-        globalThis.throw("Glob.matchString: expected 1 arguments, got 0", .{});
-        return .undefined;
+        return globalThis.throw("Glob.matchString: expected 1 arguments, got 0", .{});
     };
 
     if (!str_arg.isString()) {
-        globalThis.throw("Glob.matchString: first argument is not a string", .{});
-        return .undefined;
+        return globalThis.throw("Glob.matchString: first argument is not a string", .{});
     }
 
     var str = str_arg.toSlice(globalThis, arena.allocator());
@@ -464,16 +412,10 @@ pub fn match(this: *Glob, globalThis: *JSGlobalObject, callframe: *JSC.CallFrame
     const codepoints = codepoints: {
         if (this.pattern_codepoints) |cp| break :codepoints cp.items[0..];
 
-        var codepoints = std.ArrayList(u32).initCapacity(alloc, this.pattern.len * 2) catch {
-            globalThis.throwOutOfMemory();
-            return .undefined;
-        };
+        var codepoints = try std.ArrayList(u32).initCapacity(alloc, this.pattern.len * 2);
         errdefer codepoints.deinit();
 
-        convertUtf8(&codepoints, this.pattern) catch {
-            globalThis.throwOutOfMemory();
-            return .undefined;
-        };
+        try convertUtf8(&codepoints, this.pattern);
 
         this.pattern_codepoints = codepoints;
 
diff --git a/src/bun.js/api/h2.classes.ts b/src/bun.js/api/h2.classes.ts
index 223a6800d2..bcad57f64a 100644
--- a/src/bun.js/api/h2.classes.ts
+++ b/src/bun.js/api/h2.classes.ts
@@ -9,6 +9,10 @@ export default [
         fn: "request",
         length: 2,
       },
+      setNativeSocket: {
+        fn: "setNativeSocketFromJS",
+        length: 1,
+      },
       ping: {
         fn: "ping",
         length: 0,
@@ -29,6 +33,14 @@ export default [
         fn: "read",
         length: 1,
       },
+      flush: {
+        fn: "flushFromJS",
+        length: 0,
+      },
+      detach: {
+        fn: "detachFromJS",
+        length: 0,
+      },
       rstStream: {
         fn: "rstStream",
         length: 1,
@@ -41,12 +53,20 @@ export default [
         fn: "sendTrailers",
         length: 2,
       },
+      noTrailers: {
+        fn: "noTrailers",
+        length: 1,
+      },
       setStreamPriority: {
         fn: "setStreamPriority",
         length: 2,
       },
-      setEndAfterHeaders: {
-        fn: "setEndAfterHeaders",
+      getStreamContext: {
+        fn: "getStreamContext",
+        length: 1,
+      },
+      setStreamContext: {
+        fn: "setStreamContext",
         length: 2,
       },
       getEndAfterHeaders: {
@@ -61,6 +81,30 @@ export default [
         fn: "getStreamState",
         length: 1,
       },
+      bufferSize: {
+        fn: "getBufferSize",
+        length: 0,
+      },
+      hasNativeRead: {
+        fn: "hasNativeRead",
+        length: 1,
+      },
+      getAllStreams: {
+        fn: "getAllStreams",
+        length: 0,
+      },
+      emitErrorToAllStreams: {
+        fn: "emitErrorToAllStreams",
+        length: 1,
+      },
+      emitAbortToAllStreams: {
+        fn: "emitAbortToAllStreams",
+        length: 0,
+      },
+      getNextStream: {
+        fn: "getNextStream",
+        length: 0,
+      },
     },
     finalize: true,
     construct: true,
diff --git a/src/bun.js/api/html_rewriter.zig b/src/bun.js/api/html_rewriter.zig
index ef86b5083f..bab7ac3e5a 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_;
@@ -168,19 +168,17 @@ pub const HTMLRewriter = struct {
         return BufferOutputSink.init(new_context, global, response, this.builder);
     }
 
-    pub fn transform_(this: *HTMLRewriter, global: *JSGlobalObject, response_value: JSC.JSValue) JSValue {
+    pub fn transform_(this: *HTMLRewriter, global: *JSGlobalObject, response_value: JSC.JSValue) bun.JSError!JSValue {
         if (response_value.as(Response)) |response| {
             if (response.body.value == .Used) {
-                global.throwInvalidArguments("Response body already used", .{});
-                return .zero;
+                return global.throwInvalidArguments("Response body already used", .{});
             }
 
             const out = this.beginTransform(global, response);
 
             if (out != .zero) {
                 if (out.toError()) |err| {
-                    global.throwValue(err);
-                    return .zero;
+                    return global.throwValue(err);
                 }
             }
 
@@ -198,7 +196,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,
@@ -229,8 +228,7 @@ pub const HTMLRewriter = struct {
             }
         }
 
-        global.throwInvalidArguments("Expected Response or Body", .{});
-        return .zero;
+        return global.throwInvalidArguments("Expected Response or Body", .{});
     }
 
     pub const on = JSC.wrapInstanceMethod(HTMLRewriter, "on_", false);
@@ -710,7 +708,7 @@ pub const HTMLRewriter = struct {
 
     //     pub fn done(this: *StreamOutputSink) void {
     //         var prev_value = this.response.body.value;
-    //         var bytes = this.bytes.toOwnedSliceLeaky();
+    //         var bytes = this.bytes.slice();
     //         this.response.body.value = .{
     //             .Blob = JSC.WebCore.Blob.init(bytes, this.bytes.allocator, this.global),
     //         };
@@ -776,11 +774,7 @@ const DocumentHandler = struct {
         };
 
         if (!thisObject.isObject()) {
-            global.throwInvalidArguments(
-                "Expected object",
-                .{},
-            );
-            return error.InvalidArguments;
+            return global.throwInvalidArguments("Expected object", .{});
         }
 
         errdefer {
@@ -801,37 +795,33 @@ const DocumentHandler = struct {
             }
         }
 
-        if (thisObject.get(global, "doctype")) |val| {
+        if (try 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 global.throwInvalidArguments("doctype must be a function", .{});
             }
             val.protect();
             handler.onDocTypeCallback = val;
         }
 
-        if (thisObject.get(global, "comments")) |val| {
+        if (try 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 global.throwInvalidArguments("comments must be a function", .{});
             }
             val.protect();
             handler.onCommentCallback = val;
         }
 
-        if (thisObject.get(global, "text")) |val| {
+        if (try 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 global.throwInvalidArguments("text must be a function", .{});
             }
             val.protect();
             handler.onTextCallback = val;
         }
 
-        if (thisObject.get(global, "end")) |val| {
+        if (try 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 global.throwInvalidArguments("end must be a function", .{});
             }
             val.protect();
             handler.onEndCallback = val;
@@ -935,35 +925,28 @@ const ElementHandler = struct {
         }
 
         if (!thisObject.isObject()) {
-            global.throwInvalidArguments(
-                "Expected object",
-                .{},
-            );
-            return error.InvalidArguments;
+            return global.throwInvalidArguments("Expected object", .{});
         }
 
-        if (thisObject.get(global, "element")) |val| {
+        if (try 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 global.throwInvalidArguments("element must be a function", .{});
             }
             val.protect();
             handler.onElementCallback = val;
         }
 
-        if (thisObject.get(global, "comments")) |val| {
+        if (try 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 global.throwInvalidArguments("comments must be a function", .{});
             }
             val.protect();
             handler.onCommentCallback = val;
         }
 
-        if (thisObject.get(global, "text")) |val| {
+        if (try 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 global.throwInvalidArguments("text must be a function", .{});
             }
             val.protect();
             handler.onTextCallback = val;
@@ -1096,7 +1079,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 +1261,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();
@@ -1304,7 +1287,7 @@ pub const Comment = struct {
         var text = value.toSlice(global, bun.default_allocator);
         defer text.deinit();
         this.comment.?.setText(text.slice()) catch {
-            global.throwValue(throwLOLHTMLError(global));
+            global.throwValue(throwLOLHTMLError(global)) catch {};
             return false;
         };
 
@@ -1400,7 +1383,7 @@ pub const EndTag = struct {
         this: *EndTag,
         _: *JSGlobalObject,
         callFrame: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         if (this.end_tag == null)
             return JSValue.jsUndefined();
 
@@ -1428,7 +1411,7 @@ pub const EndTag = struct {
         var text = value.toSlice(global, bun.default_allocator);
         defer text.deinit();
         this.end_tag.?.setName(text.slice()) catch {
-            global.throwValue(throwLOLHTMLError(global));
+            global.throwValue(throwLOLHTMLError(global)) catch {};
             return false;
         };
 
@@ -1449,7 +1432,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 +1458,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 +1477,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 +1657,7 @@ pub const Element = struct {
         this: *Element,
         _: *JSGlobalObject,
         callFrame: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         if (this.element == null)
             return JSValue.jsUndefined();
 
@@ -1687,7 +1670,7 @@ pub const Element = struct {
         this: *Element,
         _: *JSGlobalObject,
         callFrame: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         if (this.element == null)
             return JSValue.jsUndefined();
 
@@ -1713,7 +1696,7 @@ pub const Element = struct {
         defer text.deinit();
 
         this.element.?.setTagName(text.slice()) catch {
-            global.throwValue(throwLOLHTMLError(global));
+            global.throwValue(throwLOLHTMLError(global)) catch {};
             return false;
         };
 
diff --git a/src/bun.js/api/js_brotli.zig b/src/bun.js/api/js_brotli.zig
deleted file mode 100644
index 07bee73bda..0000000000
--- a/src/bun.js/api/js_brotli.zig
+++ /dev/null
@@ -1,811 +0,0 @@
-const bun = @import("root").bun;
-const JSC = bun.JSC;
-const std = @import("std");
-const brotli = bun.brotli;
-
-const Queue = std.fifo.LinearFifo(JSC.Node.BlobOrStringOrBuffer, .Dynamic);
-
-// We cannot free outside the JavaScript thread.
-const FreeList = struct {
-    write_lock: bun.Lock = .{},
-    list: std.ArrayListUnmanaged(JSC.Node.BlobOrStringOrBuffer) = .{},
-
-    pub fn append(this: *FreeList, slice: []const JSC.Node.BlobOrStringOrBuffer) void {
-        this.write_lock.lock();
-        defer this.write_lock.unlock();
-        this.list.appendSlice(bun.default_allocator, slice) catch bun.outOfMemory();
-    }
-
-    pub fn drain(this: *FreeList) void {
-        this.write_lock.lock();
-        defer this.write_lock.unlock();
-        const out = this.list.items;
-        for (out) |*item| {
-            item.deinitAndUnprotect();
-        }
-        this.list.clearRetainingCapacity();
-    }
-
-    pub fn deinit(this: *FreeList) void {
-        this.drain();
-        this.list.deinit(bun.default_allocator);
-    }
-};
-
-pub const BrotliEncoder = struct {
-    pub usingnamespace bun.New(@This());
-    pub usingnamespace JSC.Codegen.JSBrotliEncoder;
-
-    stream: brotli.BrotliCompressionStream,
-    chunkSize: c_uint,
-    maxOutputLength: usize,
-
-    freelist: FreeList = .{},
-
-    globalThis: *JSC.JSGlobalObject,
-    mode: u8,
-
-    input: Queue = Queue.init(bun.default_allocator),
-    input_lock: bun.Lock = .{},
-
-    has_called_end: bool = false,
-    callback_value: JSC.Strong = .{},
-
-    output: std.ArrayListUnmanaged(u8) = .{},
-    output_lock: bun.Lock = .{},
-
-    has_pending_activity: std.atomic.Value(u32) = std.atomic.Value(u32).init(0),
-    pending_encode_job_count: std.atomic.Value(u32) = std.atomic.Value(u32).init(0),
-    ref_count: u32 = 1,
-    write_failure: ?JSC.DeferredError = null,
-    poll_ref: bun.Async.KeepAlive = .{},
-    closed: bool = false,
-
-    pub fn hasPendingActivity(this: *BrotliEncoder) bool {
-        return this.has_pending_activity.load(.monotonic) > 0;
-    }
-
-    pub fn constructor(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) ?*BrotliEncoder {
-        globalThis.throw("BrotliEncoder is not constructable", .{});
-        return null;
-    }
-
-    pub fn create(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
-        const arguments = callframe.arguments(4).slice();
-
-        if (arguments.len < 4) {
-            globalThis.throwNotEnoughArguments("BrotliEncoder", 4, arguments.len);
-            return .zero;
-        }
-
-        const opts = arguments[0];
-        const callback = arguments[2];
-        const mode = arguments[3].to(u8);
-
-        const chunkSize = globalThis.getInteger(opts, u32, 1024 * 48, .{ .min = 64, .field_name = "chunkSize" }) orelse return .zero;
-        const maxOutputLength = globalThis.getInteger(opts, usize, 0, .{ .max = std.math.maxInt(u52), .field_name = "maxOutputLength" }) orelse return .zero;
-        const flush = globalThis.getInteger(opts, u8, 0, .{ .max = 3, .field_name = "flush" }) orelse return .zero;
-        const finishFlush = globalThis.getInteger(opts, u8, 2, .{ .max = 3, .field_name = "finishFlush" }) orelse return .zero;
-        const fullFlush = globalThis.getInteger(opts, u8, 1, .{ .max = 3, .field_name = "fullFlush" }) orelse return .zero;
-
-        var this: *BrotliEncoder = BrotliEncoder.new(.{
-            .globalThis = globalThis,
-            .stream = brotli.BrotliCompressionStream.init(@enumFromInt(flush), @enumFromInt(finishFlush), @enumFromInt(fullFlush)) catch {
-                globalThis.throw("Failed to create BrotliEncoder", .{});
-                return .zero;
-            },
-            .chunkSize = chunkSize,
-            .maxOutputLength = maxOutputLength,
-            .mode = mode,
-        });
-
-        if (opts.get(globalThis, "params")) |params| {
-            inline for (std.meta.fields(bun.brotli.c.BrotliEncoderParameter)) |f| {
-                if (!params.isObject()) break;
-                if (params.hasOwnPropertyValue(globalThis, JSC.ZigString.static(std.fmt.comptimePrint("{d}", .{f.value})).toJS(globalThis))) {
-                    const idx = params.getIndex(globalThis, f.value);
-                    if (!idx.isNumber()) {
-                        globalThis.throwValue(globalThis.ERR_INVALID_ARG_TYPE_static(
-                            JSC.ZigString.static("options.params[key]"),
-                            JSC.ZigString.static("number"),
-                            idx,
-                        ));
-                        this.deinit();
-                        return .zero;
-                    }
-                    const was_set = this.stream.brotli.setParameter(@enumFromInt(f.value), idx.toU32());
-                    if (!was_set) {
-                        globalThis.ERR_ZLIB_INITIALIZATION_FAILED("Initialization failed", .{}).throw();
-                        this.deinit();
-                        return .zero;
-                    }
-                }
-            }
-        }
-        if (globalThis.hasException()) return .zero;
-
-        const out = this.toJS(globalThis);
-        this.callback_value.set(globalThis, callback);
-
-        return out;
-    }
-
-    pub fn finalize(this: *BrotliEncoder) void {
-        this.deinit();
-    }
-
-    pub fn deinit(this: *BrotliEncoder) void {
-        this.callback_value.deinit();
-        this.freelist.deinit();
-        this.output.deinit(bun.default_allocator);
-        this.stream.deinit();
-        this.input.deinit();
-        this.destroy();
-    }
-
-    fn drainFreelist(this: *BrotliEncoder) void {
-        this.freelist.drain();
-    }
-
-    fn collectOutputValue(this: *BrotliEncoder) JSC.JSValue {
-        this.output_lock.lock();
-        defer this.output_lock.unlock();
-
-        defer this.output.clearRetainingCapacity();
-        return JSC.ArrayBuffer.createBuffer(this.globalThis, this.output.items);
-    }
-
-    pub fn runFromJSThread(this: *BrotliEncoder) void {
-        this.poll_ref.unref(this.globalThis.bunVM());
-
-        defer _ = this.has_pending_activity.fetchSub(1, .monotonic);
-        this.drainFreelist();
-
-        _ = this.callback_value.get().?.call(
-            this.globalThis,
-            .undefined,
-            if (this.write_failure != null)
-                &.{this.write_failure.?.toError(this.globalThis)}
-            else
-                &.{ .null, this.collectOutputValue() },
-        ) catch |err| this.globalThis.reportActiveExceptionAsUnhandled(err);
-    }
-
-    // We can only run one encode job at a time
-    // But we don't have an idea of a serial dispatch queue
-    // So instead, we let you enqueue as many times as you want
-    // and if one is already running, we just don't do anything
-    const EncodeJob = struct {
-        task: JSC.WorkPoolTask = .{ .callback = &runTask },
-        encoder: *BrotliEncoder,
-        is_async: bool,
-        vm: *JSC.VirtualMachine,
-
-        pub usingnamespace bun.New(@This());
-
-        pub fn runTask(this: *JSC.WorkPoolTask) void {
-            var job: *EncodeJob = @fieldParentPtr("task", this);
-            job.run();
-            job.destroy();
-        }
-
-        pub fn run(this: *EncodeJob) void {
-            defer {
-                _ = this.encoder.has_pending_activity.fetchSub(1, .monotonic);
-            }
-
-            var any = false;
-
-            if (this.encoder.pending_encode_job_count.fetchAdd(1, .monotonic) >= 0) {
-                const is_last = this.encoder.has_called_end;
-                while (true) {
-                    this.encoder.input_lock.lock();
-                    defer this.encoder.input_lock.unlock();
-                    const readable = this.encoder.input.readableSlice(0);
-                    defer this.encoder.input.discard(readable.len);
-                    const pending = readable;
-
-                    const Writer = struct {
-                        encoder: *BrotliEncoder,
-
-                        pub const Error = error{OutOfMemory};
-                        pub fn writeAll(writer: @This(), chunk: []const u8) Error!void {
-                            writer.encoder.output_lock.lock();
-                            defer writer.encoder.output_lock.unlock();
-
-                            try writer.encoder.output.appendSlice(bun.default_allocator, chunk);
-                        }
-                    };
-
-                    defer {
-                        this.encoder.freelist.append(pending);
-                    }
-                    for (pending) |*input| {
-                        var writer = this.encoder.stream.writer(Writer{ .encoder = this.encoder });
-                        writer.writeAll(input.slice()) catch {
-                            _ = this.encoder.pending_encode_job_count.fetchSub(1, .monotonic);
-                            if (!this.is_async) {
-                                this.encoder.closed = true;
-                                this.encoder.globalThis.throw("BrotliError", .{});
-                                return;
-                            }
-                            this.encoder.write_failure = JSC.DeferredError.from(.plainerror, .ERR_OPERATION_FAILED, "BrotliError", .{}); // TODO propogate better error
-                            return;
-                        };
-                        if (this.encoder.output.items.len > this.encoder.maxOutputLength) {
-                            _ = this.encoder.pending_encode_job_count.fetchSub(1, .monotonic);
-                            this.encoder.write_failure = JSC.DeferredError.from(.rangeerror, .ERR_BUFFER_TOO_LARGE, "Cannot create a Buffer larger than {d} bytes", .{this.encoder.maxOutputLength});
-                            return;
-                        }
-                    }
-
-                    any = any or pending.len > 0;
-
-                    if (this.encoder.pending_encode_job_count.fetchSub(1, .monotonic) == 0)
-                        break;
-                }
-
-                if (is_last and any) {
-                    var output = &this.encoder.output;
-                    this.encoder.output_lock.lock();
-                    defer this.encoder.output_lock.unlock();
-
-                    output.appendSlice(bun.default_allocator, this.encoder.stream.end() catch {
-                        _ = this.encoder.pending_encode_job_count.fetchSub(1, .monotonic);
-                        this.encoder.write_failure = JSC.DeferredError.from(.plainerror, .ERR_OPERATION_FAILED, "BrotliError", .{}); // TODO propogate better error
-                        return;
-                    }) catch {
-                        _ = this.encoder.pending_encode_job_count.fetchSub(1, .monotonic);
-                        this.encoder.write_failure = JSC.DeferredError.from(.plainerror, .ERR_OPERATION_FAILED, "BrotliError", .{}); // TODO propogate better error
-                        return;
-                    };
-                    if (output.items.len > this.encoder.maxOutputLength) {
-                        _ = this.encoder.pending_encode_job_count.fetchSub(1, .monotonic);
-                        this.encoder.write_failure = JSC.DeferredError.from(.rangeerror, .ERR_BUFFER_TOO_LARGE, "Cannot create a Buffer larger than {d} bytes", .{this.encoder.maxOutputLength});
-                        return;
-                    }
-                }
-            }
-
-            if (this.is_async and any) {
-                _ = this.encoder.has_pending_activity.fetchAdd(1, .monotonic);
-                this.vm.enqueueTaskConcurrent(JSC.ConcurrentTask.create(JSC.Task.init(this.encoder)));
-            }
-        }
-    };
-
-    pub fn transform(this: *BrotliEncoder, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
-        const arguments = callframe.arguments(3);
-
-        if (arguments.len < 3) {
-            globalThis.throwNotEnoughArguments("BrotliEncoder.encode", 3, arguments.len);
-            return .zero;
-        }
-
-        if (this.has_called_end) {
-            globalThis.throw("BrotliEncoder.encode called after BrotliEncoder.end", .{});
-            return .zero;
-        }
-
-        const input = callframe.argument(0);
-        const optional_encoding = callframe.argument(1);
-        const is_last = callframe.argument(2).toBoolean();
-
-        const input_to_queue = JSC.Node.BlobOrStringOrBuffer.fromJSWithEncodingValueMaybeAsync(globalThis, bun.default_allocator, input, optional_encoding, true) orelse {
-            globalThis.throwInvalidArgumentType("BrotliEncoder.encode", "input", "Blob, String, or Buffer");
-            return .zero;
-        };
-
-        _ = this.has_pending_activity.fetchAdd(1, .monotonic);
-        if (is_last)
-            this.has_called_end = true;
-
-        var task = EncodeJob.new(.{
-            .encoder = this,
-            .is_async = true,
-            .vm = this.globalThis.bunVM(),
-        });
-
-        {
-            this.input_lock.lock();
-            defer this.input_lock.unlock();
-
-            // need to protect because no longer on the stack. unprotected in FreeList.deinit
-            input_to_queue.protect();
-            this.input.writeItem(input_to_queue) catch bun.outOfMemory();
-        }
-        this.poll_ref.ref(task.vm);
-        JSC.WorkPool.schedule(&task.task);
-
-        return .undefined;
-    }
-
-    pub fn transformSync(this: *BrotliEncoder, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
-        const arguments = callframe.arguments(4);
-
-        if (arguments.len < 3) {
-            globalThis.throwNotEnoughArguments("BrotliEncoder.encode", 3, arguments.len);
-            return .zero;
-        }
-
-        if (this.has_called_end) {
-            globalThis.throw("BrotliEncoder.encode called after BrotliEncoder.end", .{});
-            return .zero;
-        }
-
-        const input = callframe.argument(0);
-        const optional_encoding = callframe.argument(1);
-        const is_last = callframe.argument(2).toBoolean();
-        const optional_flushFlag = arguments.ptr[3];
-
-        const old_flushFlag = this.stream.flushOp;
-        defer this.stream.flushOp = old_flushFlag;
-        blk: {
-            if (!optional_flushFlag.isInt32()) break :blk;
-            const int = optional_flushFlag.asInt32();
-            if (int < 0) break :blk;
-            if (int > 3) break :blk;
-            this.stream.flushOp = @enumFromInt(int);
-        }
-
-        const input_to_queue = JSC.Node.BlobOrStringOrBuffer.fromJSWithEncodingValueMaybeAsync(globalThis, bun.default_allocator, input, optional_encoding, true) orelse {
-            globalThis.throwInvalidArgumentType("BrotliEncoder.encode", "input", "Blob, String, or Buffer");
-            return .zero;
-        };
-
-        _ = this.has_pending_activity.fetchAdd(1, .monotonic);
-        if (is_last)
-            this.has_called_end = true;
-
-        var task: EncodeJob = .{
-            .encoder = this,
-            .is_async = false,
-            .vm = this.globalThis.bunVM(),
-        };
-
-        {
-            this.input_lock.lock();
-            defer this.input_lock.unlock();
-
-            // need to protect because no longer on the stack. unprotected in FreeList.deinit
-            input_to_queue.protect();
-            this.input.writeItem(input_to_queue) catch bun.outOfMemory();
-        }
-        task.run();
-        if (!is_last and this.output.items.len == 0) {
-            return JSC.Buffer.fromBytes(&.{}, bun.default_allocator, .Uint8Array).toNodeBuffer(globalThis);
-        }
-        if (this.write_failure != null) {
-            globalThis.vm().throwError(globalThis, this.write_failure.?.toError(globalThis));
-            return .zero;
-        }
-        return this.collectOutputValue();
-    }
-
-    pub fn reset(this: *@This(), globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
-        _ = this;
-        _ = globalThis;
-        _ = callframe;
-        return .undefined;
-    }
-
-    pub fn getBytesWritten(this: *@This(), globalObject: *JSC.JSGlobalObject) JSC.JSValue {
-        _ = globalObject;
-        return JSC.JSValue.jsNumber(this.stream.total_in);
-    }
-
-    pub fn getClosed(this: *@This(), globalObject: *JSC.JSGlobalObject) JSC.JSValue {
-        _ = globalObject;
-        return JSC.JSValue.jsBoolean(this.closed);
-    }
-
-    pub fn close(this: *@This(), globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(.C) JSC.JSValue {
-        _ = this;
-        _ = globalThis;
-        _ = callframe;
-        return .undefined;
-    }
-
-    pub fn getChunkSize(this: *@This(), globalObject: *JSC.JSGlobalObject) JSC.JSValue {
-        _ = globalObject;
-        return JSC.JSValue.jsNumber(this.chunkSize);
-    }
-
-    pub fn getFlush(this: *@This(), globalObject: *JSC.JSGlobalObject) JSC.JSValue {
-        _ = globalObject;
-        return JSC.JSValue.jsNumber(this.stream.flushOp);
-    }
-
-    pub fn getFinishFlush(this: *@This(), globalObject: *JSC.JSGlobalObject) JSC.JSValue {
-        _ = globalObject;
-        return JSC.JSValue.jsNumber(this.stream.finishFlushOp);
-    }
-
-    pub fn getFullFlush(this: *@This(), globalObject: *JSC.JSGlobalObject) JSC.JSValue {
-        _ = globalObject;
-        return JSC.JSValue.jsNumber(this.stream.fullFlushOp);
-    }
-
-    pub fn getMaxOutputLength(this: *@This(), globalObject: *JSC.JSGlobalObject) JSC.JSValue {
-        _ = globalObject;
-        return JSC.JSValue.jsNumber(this.maxOutputLength);
-    }
-};
-
-pub const BrotliDecoder = struct {
-    pub usingnamespace bun.New(@This());
-    pub usingnamespace JSC.Codegen.JSBrotliDecoder;
-
-    globalThis: *JSC.JSGlobalObject,
-    stream: brotli.BrotliReaderArrayList,
-    chunkSize: c_uint,
-    maxOutputLength: usize,
-    mode: u8,
-
-    has_pending_activity: std.atomic.Value(u32) = std.atomic.Value(u32).init(0),
-    ref_count: u32 = 1,
-    poll_ref: bun.Async.KeepAlive = .{},
-    write_failure: ?JSC.DeferredError = null,
-    callback_value: JSC.Strong = .{},
-    has_called_end: bool = false,
-    pending_decode_job_count: std.atomic.Value(u32) = std.atomic.Value(u32).init(0),
-    closed: bool = false,
-
-    input: Queue = Queue.init(bun.default_allocator),
-    input_lock: bun.Lock = .{},
-
-    output: std.ArrayListUnmanaged(u8) = .{},
-    output_lock: bun.Lock = .{},
-
-    freelist: FreeList = .{},
-
-    pub fn hasPendingActivity(this: *BrotliDecoder) bool {
-        return this.has_pending_activity.load(.monotonic) > 0;
-    }
-
-    pub fn deinit(this: *BrotliDecoder) void {
-        this.callback_value.deinit();
-        this.freelist.deinit();
-        this.output.deinit(bun.default_allocator);
-        this.stream.brotli.destroyInstance();
-        this.input.deinit();
-        this.destroy();
-    }
-
-    pub fn constructor(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) ?*BrotliDecoder {
-        globalThis.throw("BrotliDecoder is not constructable", .{});
-        return null;
-    }
-
-    pub fn create(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
-        const arguments = callframe.arguments(4).slice();
-
-        if (arguments.len < 4) {
-            globalThis.throwNotEnoughArguments("BrotliDecoder", 4, arguments.len);
-            return .zero;
-        }
-
-        const opts = arguments[0];
-        const callback = arguments[2];
-        const mode = arguments[3].to(u8);
-
-        const chunkSize = globalThis.getInteger(opts, u32, 1024 * 48, .{ .min = 64, .field_name = "chunkSize" }) orelse return .zero;
-        const maxOutputLength = globalThis.getInteger(opts, usize, 0, .{ .max = std.math.maxInt(u52), .field_name = "maxOutputLength" }) orelse return .zero;
-        const flush = globalThis.getInteger(opts, u8, 0, .{ .max = 6, .field_name = "flush" }) orelse return .zero;
-        const finishFlush = globalThis.getInteger(opts, u8, 2, .{ .max = 6, .field_name = "finishFlush" }) orelse return .zero;
-        const fullFlush = globalThis.getInteger(opts, u8, 1, .{ .max = 6, .field_name = "fullFlush" }) orelse return .zero;
-
-        var this: *BrotliDecoder = BrotliDecoder.new(.{
-            .globalThis = globalThis,
-            .stream = undefined, // &this.output needs to be a stable pointer
-            .chunkSize = chunkSize,
-            .maxOutputLength = maxOutputLength,
-            .mode = mode,
-        });
-        this.stream = brotli.BrotliReaderArrayList.initWithOptions("", &this.output, bun.default_allocator, .{}, @enumFromInt(flush), @enumFromInt(finishFlush), @enumFromInt(fullFlush)) catch {
-            globalThis.throw("Failed to create BrotliDecoder", .{});
-            return .zero;
-        };
-
-        if (opts.get(globalThis, "params")) |params| {
-            inline for (std.meta.fields(bun.brotli.c.BrotliDecoderParameter)) |f| {
-                if (!params.isObject()) break;
-                const idx = params.getIndex(globalThis, f.value);
-                if (!idx.isNumber()) break;
-                const was_set = this.stream.brotli.setParameter(@enumFromInt(f.value), idx.toU32());
-                if (!was_set) {
-                    globalThis.ERR_ZLIB_INITIALIZATION_FAILED("Initialization failed", .{}).throw();
-                    this.deinit();
-                    return .zero;
-                }
-            }
-        }
-        if (globalThis.hasException()) return .zero;
-
-        const out = this.toJS(globalThis);
-        this.callback_value.set(globalThis, callback);
-
-        return out;
-    }
-
-    pub fn finalize(this: *BrotliDecoder) void {
-        this.deinit();
-    }
-
-    fn collectOutputValue(this: *BrotliDecoder) JSC.JSValue {
-        this.output_lock.lock();
-        defer this.output_lock.unlock();
-
-        defer this.output.clearRetainingCapacity();
-        return JSC.ArrayBuffer.createBuffer(this.globalThis, this.output.items);
-    }
-
-    pub fn runFromJSThread(this: *BrotliDecoder) void {
-        this.poll_ref.unref(this.globalThis.bunVM());
-
-        defer _ = this.has_pending_activity.fetchSub(1, .monotonic);
-        this.drainFreelist();
-
-        _ = this.callback_value.get().?.call(
-            this.globalThis,
-            .undefined,
-            if (this.write_failure != null)
-                &.{this.write_failure.?.toError(this.globalThis)}
-            else
-                &.{ .null, this.collectOutputValue() },
-        ) catch |err| this.globalThis.reportActiveExceptionAsUnhandled(err);
-    }
-
-    fn drainFreelist(this: *BrotliDecoder) void {
-        this.freelist.drain();
-    }
-
-    pub fn transform(this: *BrotliDecoder, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
-        const arguments = callframe.arguments(3);
-
-        if (arguments.len < 3) {
-            globalThis.throwNotEnoughArguments("BrotliEncoder.decode", 3, arguments.len);
-            return .zero;
-        }
-
-        if (this.has_called_end) {
-            globalThis.throw("BrotliEncoder.decode called after BrotliEncoder.end", .{});
-            return .zero;
-        }
-
-        const input = callframe.argument(0);
-        const optional_encoding = callframe.argument(1);
-        const is_last = callframe.argument(2).toBoolean();
-
-        const input_to_queue = JSC.Node.BlobOrStringOrBuffer.fromJSWithEncodingValueMaybeAsync(globalThis, bun.default_allocator, input, optional_encoding, true) orelse {
-            globalThis.throwInvalidArgumentType("BrotliEncoder.decode", "input", "Blob, String, or Buffer");
-            return .zero;
-        };
-
-        _ = this.has_pending_activity.fetchAdd(1, .monotonic);
-        if (is_last)
-            this.has_called_end = true;
-
-        var task = DecodeJob.new(.{
-            .decoder = this,
-            .is_async = true,
-            .vm = this.globalThis.bunVM(),
-        });
-
-        {
-            this.input_lock.lock();
-            defer this.input_lock.unlock();
-
-            // need to protect because no longer on the stack. unprotected in FreeList.deinit
-            input_to_queue.protect();
-            this.input.writeItem(input_to_queue) catch bun.outOfMemory();
-        }
-        this.poll_ref.ref(task.vm);
-        JSC.WorkPool.schedule(&task.task);
-
-        return .undefined;
-    }
-
-    pub fn transformSync(this: *BrotliDecoder, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
-        const arguments = callframe.arguments(4);
-
-        if (arguments.len < 3) {
-            globalThis.throwNotEnoughArguments("BrotliEncoder.decode", 3, arguments.len);
-            return .zero;
-        }
-
-        if (this.has_called_end) {
-            globalThis.throw("BrotliEncoder.decode called after BrotliEncoder.end", .{});
-            return .zero;
-        }
-
-        const input = callframe.argument(0);
-        const optional_encoding = callframe.argument(1);
-        const is_last = callframe.argument(2).toBoolean();
-        // const optional_flushFlag = arguments.ptr[3];
-
-        // const old_flushFlag = this.stream.flushOp;
-        // defer this.stream.flushOp = old_flushFlag;
-        // blk: {
-        //     if (!optional_flushFlag.isInt32()) break :blk;
-        //     const int = optional_flushFlag.asInt32();
-        //     if (int < 0) break :blk;
-        //     if (int > 3) break :blk;
-        //     this.stream.flushOp = @enumFromInt(int);
-        // }
-
-        const input_to_queue = JSC.Node.BlobOrStringOrBuffer.fromJSWithEncodingValueMaybeAsync(globalThis, bun.default_allocator, input, optional_encoding, true) orelse {
-            globalThis.throwInvalidArgumentType("BrotliEncoder.decode", "input", "Blob, String, or Buffer");
-            return .zero;
-        };
-
-        _ = this.has_pending_activity.fetchAdd(1, .monotonic);
-        if (is_last)
-            this.has_called_end = true;
-
-        var task: DecodeJob = .{
-            .decoder = this,
-            .is_async = false,
-            .vm = this.globalThis.bunVM(),
-        };
-
-        {
-            this.input_lock.lock();
-            defer this.input_lock.unlock();
-
-            // need to protect because no longer on the stack. unprotected in FreeList.deinit
-            input_to_queue.protect();
-            this.input.writeItem(input_to_queue) catch bun.outOfMemory();
-        }
-        task.run();
-        if (!is_last and this.output.items.len == 0) {
-            return JSC.Buffer.fromBytes(&.{}, bun.default_allocator, .Uint8Array).toNodeBuffer(globalThis);
-        }
-        if (this.write_failure != null) {
-            globalThis.throwValue(this.write_failure.?.toError(globalThis));
-            return .zero;
-        }
-        return this.collectOutputValue();
-    }
-
-    // We can only run one decode job at a time
-    // But we don't have an idea of a serial dispatch queue
-    // So instead, we let you enqueue as many times as you want
-    // and if one is already running, we just don't do anything
-    const DecodeJob = struct {
-        task: JSC.WorkPoolTask = .{ .callback = &runTask },
-        decoder: *BrotliDecoder,
-        is_async: bool,
-        vm: *JSC.VirtualMachine,
-
-        pub usingnamespace bun.New(@This());
-
-        pub fn runTask(this: *JSC.WorkPoolTask) void {
-            var job: *DecodeJob = @fieldParentPtr("task", this);
-            job.run();
-            job.destroy();
-        }
-
-        pub fn run(this: *DecodeJob) void {
-            defer {
-                _ = this.decoder.has_pending_activity.fetchSub(1, .monotonic);
-            }
-
-            var any = false;
-
-            if (this.decoder.pending_decode_job_count.fetchAdd(1, .monotonic) >= 0) {
-                const is_last = this.decoder.has_called_end;
-                while (true) {
-                    this.decoder.input_lock.lock();
-                    defer this.decoder.input_lock.unlock();
-                    if (!is_last) break;
-                    const pending = this.decoder.input.readableSlice(0);
-
-                    defer {
-                        this.decoder.freelist.append(pending);
-                    }
-
-                    var input_list = std.ArrayListUnmanaged(u8){};
-                    defer input_list.deinit(bun.default_allocator);
-
-                    if (pending.len > 1) {
-                        var count: usize = 0;
-                        for (pending) |input| {
-                            count += input.slice().len;
-                        }
-
-                        input_list.ensureTotalCapacityPrecise(bun.default_allocator, count) catch bun.outOfMemory();
-
-                        for (pending) |*input| {
-                            input_list.appendSliceAssumeCapacity(input.slice());
-                        }
-                    }
-
-                    {
-                        this.decoder.output_lock.lock();
-                        defer this.decoder.output_lock.unlock();
-
-                        const input = if (pending.len <= 1) pending[0].slice() else input_list.items;
-                        this.decoder.stream.input = input;
-                        this.decoder.stream.readAll(false) catch {
-                            any = true;
-                            _ = this.decoder.pending_decode_job_count.fetchSub(1, .monotonic);
-                            if (!this.is_async) {
-                                this.decoder.closed = true;
-                                this.decoder.globalThis.throw("BrotliError", .{});
-                                return;
-                            }
-                            this.decoder.write_failure = JSC.DeferredError.from(.plainerror, .ERR_OPERATION_FAILED, "BrotliError", .{}); // TODO propogate better error
-                            break;
-                        };
-                        if (this.decoder.output.items.len > this.decoder.maxOutputLength) {
-                            any = true;
-                            _ = this.decoder.pending_decode_job_count.fetchSub(1, .monotonic);
-                            this.decoder.write_failure = JSC.DeferredError.from(.rangeerror, .ERR_BUFFER_TOO_LARGE, "Cannot create a Buffer larger than {d} bytes", .{this.decoder.maxOutputLength});
-                            break;
-                        }
-                    }
-
-                    any = any or pending.len > 0;
-
-                    if (this.decoder.pending_decode_job_count.fetchSub(1, .monotonic) == 0)
-                        break;
-                }
-            }
-
-            if (this.is_async and any) {
-                _ = this.decoder.has_pending_activity.fetchAdd(1, .monotonic);
-                this.vm.enqueueTaskConcurrent(JSC.ConcurrentTask.create(JSC.Task.init(this.decoder)));
-            }
-        }
-    };
-
-    pub fn reset(this: *@This(), globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
-        _ = this;
-        _ = globalThis;
-        _ = callframe;
-        return .undefined;
-    }
-
-    pub fn getBytesWritten(this: *@This(), globalObject: *JSC.JSGlobalObject) JSC.JSValue {
-        _ = globalObject;
-        return JSC.JSValue.jsNumber(this.stream.total_in);
-    }
-
-    pub fn getClosed(this: *@This(), globalObject: *JSC.JSGlobalObject) JSC.JSValue {
-        _ = globalObject;
-        return JSC.JSValue.jsBoolean(this.closed);
-    }
-
-    pub fn close(this: *@This(), globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(.C) JSC.JSValue {
-        _ = this;
-        _ = globalThis;
-        _ = callframe;
-        return .undefined;
-    }
-
-    pub fn getChunkSize(this: *@This(), globalObject: *JSC.JSGlobalObject) JSC.JSValue {
-        _ = globalObject;
-        return JSC.JSValue.jsNumber(this.chunkSize);
-    }
-
-    pub fn getFlush(this: *@This(), globalObject: *JSC.JSGlobalObject) JSC.JSValue {
-        _ = globalObject;
-        return JSC.JSValue.jsNumber(this.stream.flushOp);
-    }
-
-    pub fn getFinishFlush(this: *@This(), globalObject: *JSC.JSGlobalObject) JSC.JSValue {
-        _ = globalObject;
-        return JSC.JSValue.jsNumber(this.stream.finishFlushOp);
-    }
-
-    pub fn getFullFlush(this: *@This(), globalObject: *JSC.JSGlobalObject) JSC.JSValue {
-        _ = globalObject;
-        return JSC.JSValue.jsNumber(this.stream.fullFlushOp);
-    }
-
-    pub fn getMaxOutputLength(this: *@This(), globalObject: *JSC.JSGlobalObject) JSC.JSValue {
-        _ = globalObject;
-        return JSC.JSValue.jsNumber(this.maxOutputLength);
-    }
-};
diff --git a/src/bun.js/api/js_zlib.zig b/src/bun.js/api/js_zlib.zig
deleted file mode 100644
index 7b2d812e63..0000000000
--- a/src/bun.js/api/js_zlib.zig
+++ /dev/null
@@ -1,1014 +0,0 @@
-const std = @import("std");
-const bun = @import("root").bun;
-const Environment = bun.Environment;
-const JSC = bun.JSC;
-const string = bun.string;
-const Output = bun.Output;
-const ZigString = JSC.ZigString;
-const Queue = std.fifo.LinearFifo(JSC.Node.BlobOrStringOrBuffer, .Dynamic);
-
-pub const ZlibEncoder = struct {
-    pub usingnamespace bun.New(@This());
-    pub usingnamespace JSC.Codegen.JSZlibEncoder;
-
-    globalThis: *JSC.JSGlobalObject,
-    stream: bun.zlib.ZlibCompressorStreaming,
-    maxOutputLength: usize,
-
-    freelist: Queue = Queue.init(bun.default_allocator),
-    freelist_write_lock: bun.Lock = .{},
-
-    input: Queue = Queue.init(bun.default_allocator),
-    input_lock: bun.Lock = .{},
-
-    has_called_end: bool = false,
-    callback_value: JSC.Strong = .{},
-
-    output: std.ArrayListUnmanaged(u8) = .{},
-    output_lock: bun.Lock = .{},
-
-    has_pending_activity: std.atomic.Value(u32) = std.atomic.Value(u32).init(0),
-    pending_encode_job_count: std.atomic.Value(u32) = std.atomic.Value(u32).init(0),
-    ref_count: u32 = 1,
-    write_failure: ?JSC.DeferredError = null,
-    poll_ref: bun.Async.KeepAlive = .{},
-    closed: bool = false,
-
-    pub fn constructor(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(.C) ?*@This() {
-        _ = callframe;
-        globalThis.throw("ZlibEncoder is not constructable", .{});
-        return null;
-    }
-
-    pub fn create(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(.C) JSC.JSValue {
-        const arguments = callframe.arguments(4).slice();
-
-        if (arguments.len < 4) {
-            globalThis.throwNotEnoughArguments("ZlibEncoder", 4, arguments.len);
-            return .zero;
-        }
-
-        const opts = arguments[0];
-        const callback = arguments[2];
-        const mode = arguments[3].to(bun.zlib.NodeMode);
-
-        var options = Options.fromJS(globalThis, mode, opts) orelse return .zero;
-
-        if (mode == .GZIP or mode == .GUNZIP) options.windowBits += 16;
-        if (mode == .UNZIP) options.windowBits += 32;
-        if (mode == .DEFLATERAW or mode == .INFLATERAW) options.windowBits *= -1;
-
-        // In zlib v1.2.9, 8 become an invalid value for this parameter, so we gracefully fix it.
-        // Ref: https://github.com/nodejs/node/commit/241eb6122ee6f36de16ee4ed4a6a291510b1807f
-        if (mode == .DEFLATERAW and options.windowBits == -8) options.windowBits = -9;
-
-        var this: *ZlibEncoder = ZlibEncoder.new(.{
-            .globalThis = globalThis,
-            .maxOutputLength = options.maxOutputLength,
-            .stream = .{
-                .mode = mode,
-                .chunkSize = options.chunkSize,
-                .flush = @enumFromInt(options.flush),
-                .finishFlush = @enumFromInt(options.finishFlush),
-                .fullFlush = @enumFromInt(options.fullFlush),
-                .level = options.level,
-                .windowBits = options.windowBits,
-                .memLevel = options.memLevel,
-                .strategy = options.strategy,
-                .dictionary = options.dictionary.slice(),
-            },
-        });
-        this.stream.init() catch {
-            globalThis.throw("Failed to create ZlibEncoder", .{});
-            return .zero;
-        };
-
-        const out = this.toJS(globalThis);
-        this.callback_value.set(globalThis, callback);
-
-        return out;
-    }
-
-    pub fn finalize(this: *@This()) callconv(.C) void {
-        this.deinit();
-    }
-
-    pub fn deinit(this: *@This()) void {
-        this.input.deinit();
-        this.output.deinit(bun.default_allocator);
-        this.callback_value.deinit();
-        this.destroy();
-    }
-
-    pub fn transformSync(this: *@This(), globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(.C) JSC.JSValue {
-        const arguments = callframe.arguments(4);
-
-        if (arguments.len < 3) {
-            globalThis.throwNotEnoughArguments("ZlibEncoder.encode", 3, arguments.len);
-            return .zero;
-        }
-
-        if (this.has_called_end) {
-            globalThis.throw("ZlibEncoder.encodeSync called after ZlibEncoder.end", .{});
-            return .zero;
-        }
-
-        const input = callframe.argument(0);
-        const optional_encoding = callframe.argument(1);
-        const is_last = callframe.argument(2).toBoolean();
-        const optional_flushFlag = arguments.ptr[3];
-
-        const old_flushFlag = this.stream.flush;
-        defer this.stream.flush = old_flushFlag;
-        blk: {
-            if (!optional_flushFlag.isInt32()) break :blk;
-            const int = optional_flushFlag.asInt32();
-            if (int < 0) break :blk;
-            if (int > 5) break :blk;
-            this.stream.flush = @enumFromInt(int);
-        }
-
-        const input_to_queue = JSC.Node.BlobOrStringOrBuffer.fromJSWithEncodingValueMaybeAsync(globalThis, bun.default_allocator, input, optional_encoding, false) orelse {
-            return globalThis.throwInvalidArgumentTypeValue("buffer", "string or an instance of Buffer, TypedArray, DataView, or ArrayBuffer", input);
-        };
-        defer input_to_queue.deinit();
-
-        if (is_last)
-            this.has_called_end = true;
-
-        {
-            this.stream.write(input_to_queue.slice(), &this.output, true) catch |err| return handleTransformSyncStreamError(err, globalThis, this.stream.err_msg, &this.closed);
-        }
-        if (this.output.items.len > this.maxOutputLength) {
-            globalThis.ERR_BUFFER_TOO_LARGE("Cannot create a Buffer larger than {d} bytes", .{this.maxOutputLength}).throw();
-            return .zero;
-        }
-        if (is_last) {
-            this.stream.end(&this.output) catch |err| return handleTransformSyncStreamError(err, globalThis, this.stream.err_msg, &this.closed);
-        }
-        if (this.output.items.len > this.maxOutputLength) {
-            globalThis.ERR_BUFFER_TOO_LARGE("Cannot create a Buffer larger than {d} bytes", .{this.maxOutputLength}).throw();
-            return .zero;
-        }
-
-        if (!is_last and this.output.items.len == 0) {
-            return JSC.Buffer.fromBytes(&.{}, bun.default_allocator, .Uint8Array).toNodeBuffer(globalThis);
-        }
-        if (this.write_failure != null) {
-            globalThis.vm().throwError(globalThis, this.write_failure.?.toError(globalThis));
-            return .zero;
-        }
-        return this.collectOutputValue();
-    }
-
-    pub fn transformWith(this: *@This(), globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(.C) JSC.JSValue {
-        const arguments = callframe.arguments(4);
-
-        if (arguments.len < 4) {
-            globalThis.throwNotEnoughArguments("ZlibEncoder.encode", 4, arguments.len);
-            return .zero;
-        }
-
-        if (this.has_called_end) {
-            globalThis.throw("ZlibEncoder.encodeSync called after ZlibEncoder.end", .{});
-            return .zero;
-        }
-
-        const input = callframe.argument(0);
-        const optional_encoding = callframe.argument(1);
-        const thisctx = arguments.ptr[2];
-        const is_last = callframe.argument(3).toBoolean();
-
-        const push_fn: JSC.JSValue = thisctx.get(globalThis, "push") orelse {
-            globalThis.throw("are you sure this is a stream.Transform?", .{});
-            return .zero;
-        };
-        if (globalThis.hasException()) return .zero;
-
-        const input_to_queue = JSC.Node.BlobOrStringOrBuffer.fromJSWithEncodingValueMaybeAsync(globalThis, bun.default_allocator, input, optional_encoding, false) orelse {
-            return globalThis.throwInvalidArgumentTypeValue("buffer", "string or an instance of Buffer, TypedArray, DataView, or ArrayBuffer", input);
-        };
-        defer input_to_queue.deinit();
-
-        if (is_last)
-            this.has_called_end = true;
-
-        const err_buffer_too_large = globalThis.ERR_BUFFER_TOO_LARGE("Cannot create a Buffer larger than {d} bytes", .{this.maxOutputLength});
-
-        {
-            this.stream.write(input_to_queue.slice(), &this.output, false) catch |err| return handleTransformSyncStreamError(err, globalThis, this.stream.err_msg, &this.closed);
-            if (this.output.items.len > this.maxOutputLength) {
-                err_buffer_too_large.throw();
-                return .zero;
-            }
-            while (true) {
-                const done = this.stream.doWork(&this.output, this.stream.flush) catch |err| return handleTransformSyncStreamError(err, globalThis, this.stream.err_msg, &this.closed);
-                if (this.output.items.len > this.maxOutputLength) {
-                    err_buffer_too_large.throw();
-                    return .zero;
-                }
-                if (this.output.items.len > 0) _ = push_fn.call(globalThis, thisctx, &.{this.collectOutputValue()}) catch return .zero;
-                if (done) break;
-            }
-        }
-        if (is_last) {
-            this.stream.end(&this.output) catch |err| return handleTransformSyncStreamError(err, globalThis, this.stream.err_msg, &this.closed);
-            if (this.output.items.len > this.maxOutputLength) {
-                globalThis.ERR_BUFFER_TOO_LARGE("Cannot create a Buffer larger than {d} bytes", .{this.maxOutputLength}).throw();
-                return .zero;
-            }
-            if (this.output.items.len > 0) _ = push_fn.call(globalThis, thisctx, &.{this.collectOutputValue()}) catch return .zero;
-        }
-        return .undefined;
-    }
-
-    pub fn transform(this: *@This(), globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(.C) JSC.JSValue {
-        const arguments = callframe.arguments(3);
-
-        if (arguments.len < 3) {
-            globalThis.throwNotEnoughArguments("ZlibEncoder.encode", 3, arguments.len);
-            return .zero;
-        }
-
-        if (this.has_called_end) {
-            globalThis.throw("ZlibEncoder.encode called after ZlibEncoder.end", .{});
-            return .zero;
-        }
-
-        const input = callframe.argument(0);
-        const optional_encoding = callframe.argument(1);
-        const is_last = callframe.argument(2).toBoolean();
-
-        const input_to_queue = JSC.Node.BlobOrStringOrBuffer.fromJSWithEncodingValueMaybeAsync(globalThis, bun.default_allocator, input, optional_encoding, true) orelse {
-            globalThis.throwInvalidArgumentType("ZlibEncoder.encode", "input", "Blob, String, or Buffer");
-            return .zero;
-        };
-
-        _ = this.has_pending_activity.fetchAdd(1, .monotonic);
-        if (is_last)
-            this.has_called_end = true;
-
-        var task = EncodeJob.new(.{
-            .encoder = this,
-        });
-
-        {
-            this.input_lock.lock();
-            defer this.input_lock.unlock();
-
-            this.input.writeItem(input_to_queue) catch unreachable;
-        }
-        this.poll_ref.ref(globalThis.bunVM());
-        JSC.WorkPool.schedule(&task.task);
-
-        return .undefined;
-    }
-
-    pub fn runFromJSThread(this: *@This()) void {
-        this.poll_ref.unref(this.globalThis.bunVM());
-
-        defer _ = this.has_pending_activity.fetchSub(1, .monotonic);
-        this.drainFreelist();
-
-        _ = this.callback_value.get().?.call(
-            this.globalThis,
-            .undefined,
-            if (this.write_failure != null)
-                &.{this.write_failure.?.toError(this.globalThis)}
-            else
-                &.{ .null, this.collectOutputValue() },
-        ) catch |err| this.globalThis.reportActiveExceptionAsUnhandled(err);
-    }
-
-    pub fn hasPendingActivity(this: *@This()) callconv(.C) bool {
-        return this.has_pending_activity.load(.monotonic) > 0;
-    }
-
-    fn drainFreelist(this: *ZlibEncoder) void {
-        this.freelist_write_lock.lock();
-        defer this.freelist_write_lock.unlock();
-        const to_free = this.freelist.readableSlice(0);
-        for (to_free) |*input| {
-            input.deinit();
-        }
-        this.freelist.discard(to_free.len);
-    }
-
-    fn collectOutputValue(this: *ZlibEncoder) JSC.JSValue {
-        this.output_lock.lock();
-        defer this.output_lock.unlock();
-
-        defer this.output.clearRetainingCapacity();
-        return JSC.ArrayBuffer.createBuffer(this.globalThis, this.output.items);
-    }
-
-    const EncodeJob = struct {
-        task: JSC.WorkPoolTask = .{ .callback = &runTask },
-        encoder: *ZlibEncoder,
-
-        pub usingnamespace bun.New(@This());
-
-        pub fn runTask(this: *JSC.WorkPoolTask) void {
-            var job: *EncodeJob = @fieldParentPtr("task", this);
-            job.run();
-            job.destroy();
-        }
-
-        pub fn run(this: *EncodeJob) void {
-            const vm = this.encoder.globalThis.bunVMConcurrently();
-            defer this.encoder.poll_ref.unrefConcurrently(vm);
-            defer {
-                _ = this.encoder.has_pending_activity.fetchSub(1, .monotonic);
-            }
-
-            var any = false;
-
-            if (this.encoder.pending_encode_job_count.fetchAdd(1, .monotonic) >= 0) {
-                const is_last = this.encoder.has_called_end;
-                outer: while (true) {
-                    this.encoder.input_lock.lock();
-                    defer this.encoder.input_lock.unlock();
-                    const readable = this.encoder.input.readableSlice(0);
-                    defer this.encoder.input.discard(readable.len);
-                    const pending = readable;
-
-                    defer {
-                        this.encoder.freelist_write_lock.lock();
-                        this.encoder.freelist.write(pending) catch unreachable;
-                        this.encoder.freelist_write_lock.unlock();
-                    }
-                    for (pending) |input| {
-                        const output = &this.encoder.output;
-                        this.encoder.stream.write(input.slice(), output, true) catch |e| {
-                            any = true;
-                            _ = this.encoder.pending_encode_job_count.fetchSub(1, .monotonic);
-                            this.encoder.write_failure = JSC.DeferredError.from(.plainerror, .ERR_OPERATION_FAILED, "ZlibError: {s}", .{@errorName(e)}); // TODO propagate better error
-                            break :outer;
-                        };
-                        if (this.encoder.output.items.len > this.encoder.maxOutputLength) {
-                            any = true;
-                            _ = this.encoder.pending_encode_job_count.fetchSub(1, .monotonic);
-                            this.encoder.write_failure = JSC.DeferredError.from(.rangeerror, .ERR_BUFFER_TOO_LARGE, "Cannot create a Buffer larger than {d} bytes", .{this.encoder.maxOutputLength});
-                            break :outer;
-                        }
-                    }
-
-                    any = any or pending.len > 0;
-
-                    if (this.encoder.pending_encode_job_count.fetchSub(1, .monotonic) == 0)
-                        break;
-                }
-
-                if (is_last and any) {
-                    const output = &this.encoder.output;
-                    this.encoder.output_lock.lock();
-                    defer this.encoder.output_lock.unlock();
-
-                    this.encoder.stream.end(output) catch |e| {
-                        _ = this.encoder.pending_encode_job_count.fetchSub(1, .monotonic);
-                        this.encoder.write_failure = JSC.DeferredError.from(.plainerror, .ERR_OPERATION_FAILED, "ZlibError: {s}", .{@errorName(e)}); // TODO propogate better error
-                        return;
-                    };
-                    if (this.encoder.output.items.len > this.encoder.maxOutputLength) {
-                        _ = this.encoder.pending_encode_job_count.fetchSub(1, .monotonic);
-                        this.encoder.write_failure = JSC.DeferredError.from(.rangeerror, .ERR_BUFFER_TOO_LARGE, "Cannot create a Buffer larger than {d} bytes", .{this.encoder.maxOutputLength});
-                        return;
-                    }
-                }
-            }
-
-            if (any) {
-                _ = this.encoder.has_pending_activity.fetchAdd(1, .monotonic);
-                this.encoder.poll_ref.refConcurrently(vm);
-                this.encoder.poll_ref.refConcurrently(vm);
-                vm.enqueueTaskConcurrent(JSC.ConcurrentTask.create(JSC.Task.init(this.encoder)));
-            }
-        }
-    };
-
-    pub fn reset(this: *@This(), globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(.C) JSC.JSValue {
-        _ = globalThis;
-        _ = callframe;
-        _ = bun.zlib.deflateReset(&this.stream.state);
-        return .undefined;
-    }
-
-    pub fn getBytesWritten(this: *@This(), globalObject: *JSC.JSGlobalObject) callconv(.C) JSC.JSValue {
-        _ = globalObject;
-        return JSC.JSValue.jsNumber(@as(u64, this.stream.state.total_in));
-    }
-
-    pub fn getLevel(this: *@This(), globalObject: *JSC.JSGlobalObject) JSC.JSValue {
-        _ = globalObject;
-        return JSC.JSValue.jsNumber(this.stream.level);
-    }
-
-    pub fn getStrategy(this: *@This(), globalObject: *JSC.JSGlobalObject) JSC.JSValue {
-        _ = globalObject;
-        return JSC.JSValue.jsNumber(this.stream.strategy);
-    }
-
-    pub fn getClosed(this: *@This(), globalObject: *JSC.JSGlobalObject) JSC.JSValue {
-        _ = globalObject;
-        return JSC.JSValue.jsBoolean(this.closed);
-    }
-
-    pub fn close(this: *@This(), globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(.C) JSC.JSValue {
-        _ = this;
-        _ = globalThis;
-        _ = callframe;
-        return .undefined;
-    }
-
-    pub fn params(this: *@This(), globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(.C) JSC.JSValue {
-        const arguments = callframe.arguments(3).ptr;
-        if (this.stream.mode != .DEFLATE) return .undefined;
-
-        const level = if (arguments[0] != .zero) (globalThis.validateIntegerRange(arguments[0], i16, -1, .{ .max = 9, .min = -1, .field_name = "level" }) orelse return .zero) else this.stream.level;
-        const strategy = if (arguments[1] != .zero) (globalThis.validateIntegerRange(arguments[1], u8, 0, .{ .max = 4, .min = 0, .field_name = "strategy" }) orelse return .zero) else this.stream.strategy;
-        this.stream.params(level, strategy);
-
-        if (arguments[2] != .zero) {
-            if (!arguments[2].isFunction()) {
-                return globalThis.throwInvalidArgumentTypeValue("callback", "function", arguments[2]);
-            }
-            this.callback_value.set(globalThis, arguments[2]);
-        }
-
-        return .undefined;
-    }
-
-    pub fn getChunkSize(this: *@This(), globalObject: *JSC.JSGlobalObject) JSC.JSValue {
-        _ = globalObject;
-        return JSC.JSValue.jsNumber(this.stream.chunkSize);
-    }
-
-    pub fn getFlush(this: *@This(), globalObject: *JSC.JSGlobalObject) JSC.JSValue {
-        _ = globalObject;
-        return JSC.JSValue.jsNumber(this.stream.flush);
-    }
-
-    pub fn getFinishFlush(this: *@This(), globalObject: *JSC.JSGlobalObject) JSC.JSValue {
-        _ = globalObject;
-        return JSC.JSValue.jsNumber(this.stream.finishFlush);
-    }
-
-    pub fn getFullFlush(this: *@This(), globalObject: *JSC.JSGlobalObject) JSC.JSValue {
-        _ = globalObject;
-        return JSC.JSValue.jsNumber(this.stream.fullFlush);
-    }
-
-    pub fn getMaxOutputLength(this: *@This(), globalObject: *JSC.JSGlobalObject) JSC.JSValue {
-        _ = globalObject;
-        return JSC.JSValue.jsNumber(this.maxOutputLength);
-    }
-};
-
-pub const ZlibDecoder = struct {
-    pub usingnamespace bun.New(@This());
-    pub usingnamespace JSC.Codegen.JSZlibDecoder;
-
-    globalThis: *JSC.JSGlobalObject,
-    stream: bun.zlib.ZlibDecompressorStreaming,
-    maxOutputLength: usize,
-
-    freelist: Queue = Queue.init(bun.default_allocator),
-    freelist_write_lock: bun.Lock = .{},
-
-    input: Queue = Queue.init(bun.default_allocator),
-    input_lock: bun.Lock = .{},
-
-    has_called_end: bool = false,
-    callback_value: JSC.Strong = .{},
-
-    output: std.ArrayListUnmanaged(u8) = .{},
-    output_lock: bun.Lock = .{},
-
-    has_pending_activity: std.atomic.Value(u32) = std.atomic.Value(u32).init(0),
-    pending_encode_job_count: std.atomic.Value(u32) = std.atomic.Value(u32).init(0),
-    ref_count: u32 = 1,
-    write_failure: ?JSC.DeferredError = null,
-    poll_ref: bun.Async.KeepAlive = .{},
-    closed: bool = false,
-
-    pub fn constructor(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(.C) ?*@This() {
-        _ = callframe;
-        globalThis.throw("ZlibDecoder is not constructable", .{});
-        return null;
-    }
-
-    pub fn create(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(.C) JSC.JSValue {
-        const arguments = callframe.arguments(4).slice();
-
-        if (arguments.len < 4) {
-            globalThis.throwNotEnoughArguments("ZlibDecoder", 4, arguments.len);
-            return .zero;
-        }
-
-        const opts = arguments[0];
-        const callback = arguments[2];
-        const mode = arguments[3].to(bun.zlib.NodeMode);
-
-        var options = Options.fromJS(globalThis, mode, opts) orelse return .zero;
-
-        if (mode == .GZIP or mode == .GUNZIP) options.windowBits += 16;
-        if (mode == .UNZIP) options.windowBits += 32;
-        if (mode == .DEFLATERAW or mode == .INFLATERAW) options.windowBits *= -1;
-
-        var this: *ZlibDecoder = ZlibDecoder.new(.{
-            .globalThis = globalThis,
-            .maxOutputLength = options.maxOutputLength,
-            .stream = .{
-                .mode = mode,
-                .chunkSize = options.chunkSize,
-                .flush = @enumFromInt(options.flush),
-                .finishFlush = @enumFromInt(options.finishFlush),
-                .fullFlush = @enumFromInt(options.fullFlush),
-                .windowBits = options.windowBits,
-                .dictionary = options.dictionary.slice(),
-            },
-        });
-        this.stream.init() catch {
-            globalThis.throw("Failed to create ZlibDecoder", .{});
-            return .zero;
-        };
-
-        const out = this.toJS(globalThis);
-        this.callback_value.set(globalThis, callback);
-
-        return out;
-    }
-
-    pub fn finalize(this: *@This()) callconv(.C) void {
-        this.deinit();
-    }
-
-    pub fn deinit(this: *@This()) void {
-        this.input.deinit();
-        this.output.deinit(bun.default_allocator);
-        this.callback_value.deinit();
-        this.destroy();
-    }
-
-    pub fn transformSync(this: *@This(), globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(.C) JSC.JSValue {
-        const arguments = callframe.arguments(4);
-
-        if (arguments.len < 3) {
-            globalThis.throwNotEnoughArguments("ZlibDecoder.encode", 3, arguments.len);
-            return .zero;
-        }
-
-        if (this.has_called_end) {
-            globalThis.throw("ZlibDecoder.encodeSync called after ZlibDecoder.end", .{});
-            return .zero;
-        }
-
-        const input = callframe.argument(0);
-        const optional_encoding = callframe.argument(1);
-        const is_last = callframe.argument(2).toBoolean();
-        const optional_flushFlag = arguments.ptr[3];
-
-        const old_flushFlag = this.stream.flush;
-        defer this.stream.flush = old_flushFlag;
-        blk: {
-            if (!optional_flushFlag.isInt32()) break :blk;
-            const int = optional_flushFlag.asInt32();
-            if (int < 0) break :blk;
-            if (int > 5) break :blk;
-            this.stream.flush = @enumFromInt(int);
-        }
-
-        const input_to_queue = JSC.Node.BlobOrStringOrBuffer.fromJSWithEncodingValueMaybeAsync(globalThis, bun.default_allocator, input, optional_encoding, true) orelse {
-            return globalThis.throwInvalidArgumentTypeValue("buffer", "string or an instance of Buffer, TypedArray, DataView, or ArrayBuffer", input);
-        };
-
-        if (is_last)
-            this.has_called_end = true;
-
-        {
-            this.stream.writeAll(input_to_queue.slice(), &this.output, true) catch |err| return handleTransformSyncStreamError(err, globalThis, this.stream.err_msg, &this.closed);
-        }
-        if (this.output.items.len > this.maxOutputLength) {
-            globalThis.ERR_BUFFER_TOO_LARGE("Cannot create a Buffer larger than {d} bytes", .{this.maxOutputLength}).throw();
-            return .zero;
-        }
-        if (is_last) {
-            this.stream.end(&this.output) catch |err| return handleTransformSyncStreamError(err, globalThis, this.stream.err_msg, &this.closed);
-        }
-        if (this.output.items.len > this.maxOutputLength) {
-            globalThis.ERR_BUFFER_TOO_LARGE("Cannot create a Buffer larger than {d} bytes", .{this.maxOutputLength}).throw();
-            return .zero;
-        }
-
-        if (!is_last and this.output.items.len == 0) {
-            return JSC.Buffer.fromBytes(&.{}, bun.default_allocator, .Uint8Array).toNodeBuffer(globalThis);
-        }
-        if (this.write_failure != null) {
-            globalThis.vm().throwError(globalThis, this.write_failure.?.toError(globalThis));
-            return .zero;
-        }
-        return this.collectOutputValue();
-    }
-
-    pub fn transformWith(this: *@This(), globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(.C) JSC.JSValue {
-        const arguments = callframe.arguments(4);
-
-        if (arguments.len < 4) {
-            globalThis.throwNotEnoughArguments("ZlibEncoder.encode", 4, arguments.len);
-            return .zero;
-        }
-
-        if (this.has_called_end) {
-            globalThis.throw("ZlibEncoder.encodeSync called after ZlibEncoder.end", .{});
-            return .zero;
-        }
-
-        const input = callframe.argument(0);
-        const optional_encoding = callframe.argument(1);
-        const thisctx = arguments.ptr[2];
-        const is_last = callframe.argument(3).toBoolean();
-
-        const push_fn: JSC.JSValue = thisctx.get(globalThis, "push") orelse {
-            globalThis.throw("are you sure this is a stream.Transform?", .{});
-            return .zero;
-        };
-        if (globalThis.hasException()) return .zero;
-
-        const input_to_queue = JSC.Node.BlobOrStringOrBuffer.fromJSWithEncodingValue(globalThis, bun.default_allocator, input, optional_encoding) orelse {
-            return globalThis.throwInvalidArgumentTypeValue("buffer", "string or an instance of Buffer, TypedArray, DataView, or ArrayBuffer", input);
-        };
-        defer input_to_queue.deinit();
-        if (is_last)
-            this.has_called_end = true;
-
-        const err_buffer_too_large = globalThis.ERR_BUFFER_TOO_LARGE("Cannot create a Buffer larger than {d} bytes", .{this.maxOutputLength});
-
-        {
-            const input_slice = input_to_queue.slice();
-            this.stream.writeAll(input_slice, &this.output, false) catch |err| return handleTransformSyncStreamError(err, globalThis, this.stream.err_msg, &this.closed);
-            if (this.output.items.len > this.maxOutputLength) {
-                err_buffer_too_large.throw();
-                return .zero;
-            }
-            while (this.stream.do_inflate_loop) {
-                const done = this.stream.doWork(&this.output, this.stream.flush) catch |err| return handleTransformSyncStreamError(err, globalThis, this.stream.err_msg, &this.closed);
-                if (this.output.items.len > this.maxOutputLength) {
-                    err_buffer_too_large.throw();
-                    return .zero;
-                }
-                if (this.output.items.len > 0) _ = push_fn.call(globalThis, thisctx, &.{this.collectOutputValue()}) catch return .zero;
-                if (done) break;
-            }
-        }
-        if (is_last) {
-            this.stream.end(&this.output) catch |err| return handleTransformSyncStreamError(err, globalThis, this.stream.err_msg, &this.closed);
-            if (this.output.items.len > this.maxOutputLength) {
-                globalThis.ERR_BUFFER_TOO_LARGE("Cannot create a Buffer larger than {d} bytes", .{this.maxOutputLength}).throw();
-                return .zero;
-            }
-            if (this.output.items.len > 0) _ = push_fn.call(globalThis, thisctx, &.{this.collectOutputValue()}) catch return .zero;
-        }
-        return .undefined;
-    }
-
-    pub fn transform(this: *@This(), globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(.C) JSC.JSValue {
-        const arguments = callframe.arguments(3);
-
-        if (arguments.len < 3) {
-            globalThis.throwNotEnoughArguments("ZlibDecoder.encode", 3, arguments.len);
-            return .zero;
-        }
-
-        if (this.has_called_end) {
-            globalThis.throw("ZlibDecoder.encode called after ZlibDecoder.end", .{});
-            return .zero;
-        }
-
-        const input = callframe.argument(0);
-        const optional_encoding = callframe.argument(1);
-        const is_last = callframe.argument(2).toBoolean();
-
-        const input_to_queue = JSC.Node.BlobOrStringOrBuffer.fromJSWithEncodingValueMaybeAsync(globalThis, bun.default_allocator, input, optional_encoding, true) orelse {
-            globalThis.throwInvalidArgumentType("ZlibDecoder.encode", "input", "Blob, String, or Buffer");
-            return .zero;
-        };
-
-        _ = this.has_pending_activity.fetchAdd(1, .monotonic);
-        if (is_last)
-            this.has_called_end = true;
-
-        var task = DecodeJob.new(.{
-            .decoder = this,
-        });
-
-        {
-            this.input_lock.lock();
-            defer this.input_lock.unlock();
-
-            this.input.writeItem(input_to_queue) catch unreachable;
-        }
-        this.poll_ref.ref(globalThis.bunVM());
-        JSC.WorkPool.schedule(&task.task);
-
-        return .undefined;
-    }
-
-    pub fn runFromJSThread(this: *@This()) void {
-        this.poll_ref.unref(this.globalThis.bunVM());
-
-        defer _ = this.has_pending_activity.fetchSub(1, .monotonic);
-        this.drainFreelist();
-
-        _ = this.callback_value.get().?.call(
-            this.globalThis,
-            .undefined,
-            if (this.write_failure != null)
-                &.{this.write_failure.?.toError(this.globalThis)}
-            else
-                &.{ .null, this.collectOutputValue() },
-        ) catch |err| this.globalThis.reportActiveExceptionAsUnhandled(err);
-    }
-
-    pub fn hasPendingActivity(this: *@This()) callconv(.C) bool {
-        return this.has_pending_activity.load(.monotonic) > 0;
-    }
-
-    fn drainFreelist(this: *ZlibDecoder) void {
-        this.freelist_write_lock.lock();
-        defer this.freelist_write_lock.unlock();
-        const to_free = this.freelist.readableSlice(0);
-        for (to_free) |*input| {
-            input.deinit();
-        }
-        this.freelist.discard(to_free.len);
-    }
-
-    fn collectOutputValue(this: *ZlibDecoder) JSC.JSValue {
-        this.output_lock.lock();
-        defer this.output_lock.unlock();
-
-        defer this.output.clearRetainingCapacity();
-        return JSC.ArrayBuffer.createBuffer(this.globalThis, this.output.items);
-    }
-
-    const DecodeJob = struct {
-        task: JSC.WorkPoolTask = .{ .callback = &runTask },
-        decoder: *ZlibDecoder,
-
-        pub usingnamespace bun.New(@This());
-
-        pub fn runTask(this: *JSC.WorkPoolTask) void {
-            var job: *DecodeJob = @fieldParentPtr("task", this);
-            job.run();
-            job.destroy();
-        }
-
-        pub fn run(this: *DecodeJob) void {
-            const vm = this.decoder.globalThis.bunVMConcurrently();
-            defer this.decoder.poll_ref.unrefConcurrently(vm);
-            defer {
-                _ = this.decoder.has_pending_activity.fetchSub(1, .monotonic);
-            }
-
-            var any = false;
-
-            if (this.decoder.pending_encode_job_count.fetchAdd(1, .monotonic) >= 0) outer: {
-                const is_last = this.decoder.has_called_end;
-                while (true) {
-                    this.decoder.input_lock.lock();
-                    defer this.decoder.input_lock.unlock();
-                    const readable = this.decoder.input.readableSlice(0);
-                    defer this.decoder.input.discard(readable.len);
-                    const pending = readable;
-
-                    defer {
-                        this.decoder.freelist_write_lock.lock();
-                        this.decoder.freelist.write(pending) catch unreachable;
-                        this.decoder.freelist_write_lock.unlock();
-                    }
-                    for (pending) |input| {
-                        const output = &this.decoder.output;
-                        this.decoder.stream.writeAll(input.slice(), output, true) catch |e| {
-                            any = true;
-                            _ = this.decoder.pending_encode_job_count.fetchSub(1, .monotonic);
-                            switch (e) {
-                                error.ZlibError => {
-                                    const message = std.mem.sliceTo(this.decoder.stream.err_msg.?, 0);
-                                    this.decoder.write_failure = JSC.DeferredError.from(.plainerror, .ERR_OPERATION_FAILED, "{s}", .{message});
-                                    break :outer;
-                                },
-                                else => {},
-                            }
-                            this.decoder.write_failure = JSC.DeferredError.from(.plainerror, .ERR_OPERATION_FAILED, "ZlibError: {s}", .{@errorName(e)}); // TODO propogate better error
-                            break :outer;
-                        };
-                    }
-
-                    any = any or pending.len > 0;
-
-                    if (this.decoder.pending_encode_job_count.fetchSub(1, .monotonic) == 0)
-                        break;
-                }
-
-                if (is_last and any) {
-                    const output = &this.decoder.output;
-                    this.decoder.output_lock.lock();
-                    defer this.decoder.output_lock.unlock();
-
-                    this.decoder.stream.end(output) catch |e| {
-                        any = true;
-                        _ = this.decoder.pending_encode_job_count.fetchSub(1, .monotonic);
-                        switch (e) {
-                            error.ZlibError => {
-                                const message = std.mem.sliceTo(this.decoder.stream.err_msg.?, 0);
-                                this.decoder.write_failure = JSC.DeferredError.from(.plainerror, .ERR_OPERATION_FAILED, "{s}", .{message});
-                                break :outer;
-                            },
-                            else => {
-                                this.decoder.write_failure = JSC.DeferredError.from(.plainerror, .ERR_OPERATION_FAILED, "ZlibError: {s}", .{@errorName(e)}); // TODO propogate better error
-                                break :outer;
-                            },
-                        }
-                    };
-                    if (output.items.len > this.decoder.maxOutputLength) {
-                        any = true;
-                        _ = this.decoder.pending_encode_job_count.fetchSub(1, .monotonic);
-                        this.decoder.write_failure = JSC.DeferredError.from(.rangeerror, .ERR_BUFFER_TOO_LARGE, "Cannot create a Buffer larger than {d} bytes", .{this.decoder.maxOutputLength});
-                        break :outer;
-                    }
-                }
-            }
-
-            if (any) {
-                _ = this.decoder.has_pending_activity.fetchAdd(1, .monotonic);
-                this.decoder.poll_ref.refConcurrently(vm);
-                this.decoder.poll_ref.refConcurrently(vm);
-                vm.enqueueTaskConcurrent(JSC.ConcurrentTask.create(JSC.Task.init(this.decoder)));
-            }
-        }
-    };
-
-    pub fn reset(this: *@This(), globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(.C) JSC.JSValue {
-        _ = globalThis;
-        _ = callframe;
-        _ = bun.zlib.inflateReset(&this.stream.state);
-        return .undefined;
-    }
-
-    pub fn getBytesWritten(this: *@This(), globalObject: *JSC.JSGlobalObject) callconv(.C) JSC.JSValue {
-        _ = globalObject;
-        return JSC.JSValue.jsNumber(@as(u64, this.stream.state.total_in));
-    }
-
-    pub fn getLevel(this: *@This(), globalObject: *JSC.JSGlobalObject) JSC.JSValue {
-        _ = this;
-        _ = globalObject;
-        return JSC.JSValue.jsUndefined();
-    }
-
-    pub fn getStrategy(this: *@This(), globalObject: *JSC.JSGlobalObject) JSC.JSValue {
-        _ = this;
-        _ = globalObject;
-        return JSC.JSValue.jsUndefined();
-    }
-
-    pub fn getClosed(this: *@This(), globalObject: *JSC.JSGlobalObject) JSC.JSValue {
-        _ = globalObject;
-        return JSC.JSValue.jsBoolean(this.closed);
-    }
-
-    pub fn close(this: *@This(), globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(.C) JSC.JSValue {
-        _ = this;
-        _ = globalThis;
-        _ = callframe;
-        return .undefined;
-    }
-
-    pub fn params(this: *@This(), globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(.C) JSC.JSValue {
-        _ = this;
-        _ = globalThis;
-        _ = callframe;
-        return .undefined;
-    }
-
-    pub fn getChunkSize(this: *@This(), globalObject: *JSC.JSGlobalObject) JSC.JSValue {
-        _ = globalObject;
-        return JSC.JSValue.jsNumber(this.stream.chunkSize);
-    }
-
-    pub fn getFlush(this: *@This(), globalObject: *JSC.JSGlobalObject) JSC.JSValue {
-        _ = globalObject;
-        return JSC.JSValue.jsNumber(this.stream.flush);
-    }
-
-    pub fn getFinishFlush(this: *@This(), globalObject: *JSC.JSGlobalObject) JSC.JSValue {
-        _ = globalObject;
-        return JSC.JSValue.jsNumber(this.stream.finishFlush);
-    }
-
-    pub fn getFullFlush(this: *@This(), globalObject: *JSC.JSGlobalObject) JSC.JSValue {
-        _ = globalObject;
-        return JSC.JSValue.jsNumber(this.stream.fullFlush);
-    }
-
-    pub fn getMaxOutputLength(this: *@This(), globalObject: *JSC.JSGlobalObject) JSC.JSValue {
-        _ = globalObject;
-        return JSC.JSValue.jsNumber(this.maxOutputLength);
-    }
-};
-
-const Options = struct {
-    chunkSize: c_uint,
-    level: c_int,
-    windowBits: c_int,
-    memLevel: c_int,
-    strategy: c_int,
-    dictionary: JSC.Buffer,
-    maxOutputLength: usize,
-    flush: u8,
-    finishFlush: u8,
-    fullFlush: u8,
-
-    pub fn fromJS(globalThis: *JSC.JSGlobalObject, mode: bun.zlib.NodeMode, opts: JSC.JSValue) ?Options {
-        const chunkSize = globalThis.getInteger(opts, c_uint, 48 * 1024, .{
-            .field_name = "chunkSize",
-            .min = 64,
-        }) orelse return null;
-        const level = globalThis.getInteger(opts, i16, -1, .{ .field_name = "level", .min = -1, .max = 9 }) orelse return null;
-        const memLevel = globalThis.getInteger(opts, u8, 8, .{ .field_name = "memLevel", .min = 8, .max = 255 }) orelse return null;
-        const strategy = globalThis.getInteger(opts, u8, 0, .{ .field_name = "strategy", .min = 0, .max = 4 }) orelse return null;
-        const maxOutputLength = globalThis.getInteger(opts, usize, std.math.maxInt(u52), .{ .field_name = "maxOutputLength", .min = 0, .max = std.math.maxInt(u52) }) orelse return null;
-        const flush = globalThis.getInteger(opts, u8, 0, .{ .field_name = "flush", .min = 0, .max = 5 }) orelse return null;
-        const finishFlush = globalThis.getInteger(opts, u8, 4, .{ .field_name = "finishFlush", .min = 0, .max = 5 }) orelse return null;
-        const fullFlush = globalThis.getInteger(opts, u8, 3, .{ .field_name = "fullFlush", .min = 0, .max = 5 }) orelse return null;
-
-        const windowBits = switch (mode) {
-            .NONE,
-            .BROTLI_DECODE,
-            .BROTLI_ENCODE,
-            => unreachable,
-            .DEFLATE, .DEFLATERAW => globalThis.getInteger(opts, u8, 15, .{ .min = 8, .max = 15, .field_name = "windowBits" }) orelse return null,
-            .INFLATE, .INFLATERAW => getWindowBits(globalThis, opts, "windowBits", u8, 8, 15, 15) orelse return null,
-            .GZIP => globalThis.getInteger(opts, i16, 15, .{ .min = 9, .max = 15, .field_name = "windowBits" }) orelse return null,
-            .GUNZIP, .UNZIP => getWindowBits(globalThis, opts, "windowBits", i16, 9, 15, 15) orelse return null,
-        };
-
-        const dictionary = blk: {
-            var exceptionref: JSC.C.JSValueRef = null;
-            const value: JSC.JSValue = opts.get(globalThis, "dictionary") orelse {
-                if (globalThis.hasException()) return null;
-                break :blk JSC.Buffer.fromBytes(&.{}, bun.default_allocator, .Uint8Array);
-            };
-            if (value.isUndefined()) {
-                break :blk JSC.Buffer.fromBytes(&.{}, bun.default_allocator, .Uint8Array);
-            }
-            const buffer = JSC.Buffer.fromJS(globalThis, value, &exceptionref) orelse {
-                const ty_str = value.jsTypeString(globalThis).toSlice(globalThis, bun.default_allocator);
-                defer ty_str.deinit();
-                globalThis.ERR_INVALID_ARG_TYPE("The \"options.dictionary\" property must be an instance of Buffer, TypedArray, DataView, or ArrayBuffer. Received {s}", .{ty_str.slice()}).throw();
-                return null;
-            };
-            if (exceptionref) |ptr| {
-                globalThis.throwValue(JSC.JSValue.c(ptr));
-                return null;
-            }
-            break :blk buffer;
-        };
-
-        return .{
-            .chunkSize = chunkSize,
-            .level = level,
-            .windowBits = windowBits,
-            .memLevel = memLevel,
-            .strategy = strategy,
-            .dictionary = dictionary,
-            .maxOutputLength = maxOutputLength,
-            .flush = flush,
-            .finishFlush = finishFlush,
-            .fullFlush = fullFlush,
-        };
-    }
-
-    // Specialization of globalThis.checkRangesOrGetDefault since windowBits also allows 0 when decompressing
-    fn getWindowBits(this: *JSC.JSGlobalObject, obj: JSC.JSValue, comptime field_name: []const u8, comptime T: type, comptime min: T, comptime max: T, comptime default: T) ?T {
-        return this.getInteger(obj, T, default, .{
-            .field_name = field_name,
-            .min = min,
-            .max = max,
-            .always_allow_zero = true,
-        });
-    }
-};
-
-fn handleTransformSyncStreamError(err: anyerror, globalThis: *JSC.JSGlobalObject, err_msg: ?[*:0]const u8, closed: *bool) JSC.JSValue {
-    switch (err) {
-        error.ZlibError => {
-            globalThis.throw("{s}", .{std.mem.sliceTo(err_msg.?, 0)});
-        },
-        else => {
-            globalThis.throw("ZlibError: {s}", .{@errorName(err)});
-        },
-    }
-    closed.* = true;
-    return .zero;
-}
diff --git a/src/bun.js/api/postgres.classes.ts b/src/bun.js/api/postgres.classes.ts
index ddb27007c7..04097296fc 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 a22ebf8c83..5a37980083 100644
--- a/src/bun.js/api/server.zig
+++ b/src/bun.js/api/server.zig
@@ -92,23 +92,23 @@ 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 global.throwValue(read.err.toJSC(global));
                     },
                     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 };
+                        return global.throwInvalidArguments(std.fmt.comptimePrint("Invalid {s} file", .{fieldname}), .{});
                     },
                 }
             }
@@ -198,7 +198,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 +208,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.throwInvalidArguments("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.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.", .{});
                     },
                     .Null, .Empty => {
                         break :brk AnyBlob{
@@ -226,8 +224,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 globalThis.throwTODO("TODO: support Bun.file(path) in static routes");
                         }
                         var blob = response.body.value.use();
                         blob.globalThis = globalThis;
@@ -253,7 +250,7 @@ const StaticRoute = struct {
                 }) catch {
                     blob.detach();
                     globalThis.throwOutOfMemory();
-                    return null;
+                    return error.JSError;
                 }
             else
                 .{
@@ -270,8 +267,7 @@ const StaticRoute = struct {
             });
         }
 
-        globalThis.throwInvalidArguments("Expected a Response object", .{});
-        return null;
+        return globalThis.throwInvalidArguments("Expected a Response object", .{});
     }
 
     // HEAD requests have no body.
@@ -443,6 +439,7 @@ pub const ServerConfig = struct {
         .tcp = .{},
     },
     idleTimeout: u8 = 10, //TODO: should we match websocket default idleTimeout of 120?
+    has_idleTimeout: bool = false,
     // TODO: use webkit URL parser instead of bun's
     base_url: URL = URL{},
     base_uri: string = "",
@@ -464,6 +461,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,
@@ -520,6 +519,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 {
@@ -583,41 +586,39 @@ pub const ServerConfig = struct {
 
         const log = Output.scoped(.SSLConfig, false);
 
-        pub fn asUSockets(this_: ?SSLConfig) uws.us_bun_socket_context_options_t {
+        pub fn asUSockets(this: SSLConfig) uws.us_bun_socket_context_options_t {
             var ctx_opts: uws.us_bun_socket_context_options_t = .{};
 
-            if (this_) |ssl_config| {
-                if (ssl_config.key_file_name != null)
-                    ctx_opts.key_file_name = ssl_config.key_file_name;
-                if (ssl_config.cert_file_name != null)
-                    ctx_opts.cert_file_name = ssl_config.cert_file_name;
-                if (ssl_config.ca_file_name != null)
-                    ctx_opts.ca_file_name = ssl_config.ca_file_name;
-                if (ssl_config.dh_params_file_name != null)
-                    ctx_opts.dh_params_file_name = ssl_config.dh_params_file_name;
-                if (ssl_config.passphrase != null)
-                    ctx_opts.passphrase = ssl_config.passphrase;
-                ctx_opts.ssl_prefer_low_memory_usage = @intFromBool(ssl_config.low_memory_mode);
+            if (this.key_file_name != null)
+                ctx_opts.key_file_name = this.key_file_name;
+            if (this.cert_file_name != null)
+                ctx_opts.cert_file_name = this.cert_file_name;
+            if (this.ca_file_name != null)
+                ctx_opts.ca_file_name = this.ca_file_name;
+            if (this.dh_params_file_name != null)
+                ctx_opts.dh_params_file_name = this.dh_params_file_name;
+            if (this.passphrase != null)
+                ctx_opts.passphrase = this.passphrase;
+            ctx_opts.ssl_prefer_low_memory_usage = @intFromBool(this.low_memory_mode);
 
-                if (ssl_config.key) |key| {
-                    ctx_opts.key = key.ptr;
-                    ctx_opts.key_count = ssl_config.key_count;
-                }
-                if (ssl_config.cert) |cert| {
-                    ctx_opts.cert = cert.ptr;
-                    ctx_opts.cert_count = ssl_config.cert_count;
-                }
-                if (ssl_config.ca) |ca| {
-                    ctx_opts.ca = ca.ptr;
-                    ctx_opts.ca_count = ssl_config.ca_count;
-                }
-
-                if (ssl_config.ssl_ciphers != null) {
-                    ctx_opts.ssl_ciphers = ssl_config.ssl_ciphers;
-                }
-                ctx_opts.request_cert = ssl_config.request_cert;
-                ctx_opts.reject_unauthorized = ssl_config.reject_unauthorized;
+            if (this.key) |key| {
+                ctx_opts.key = key.ptr;
+                ctx_opts.key_count = this.key_count;
             }
+            if (this.cert) |cert| {
+                ctx_opts.cert = cert.ptr;
+                ctx_opts.cert_count = this.cert_count;
+            }
+            if (this.ca) |ca| {
+                ctx_opts.ca = ca.ptr;
+                ctx_opts.ca_count = this.ca_count;
+            }
+
+            if (this.ssl_ciphers != null) {
+                ctx_opts.ssl_ciphers = this.ssl_ciphers;
+            }
+            ctx_opts.request_cert = this.request_cert;
+            ctx_opts.reject_unauthorized = this.reject_unauthorized;
 
             return ctx_opts;
         }
@@ -748,15 +749,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.throwInvalidArguments("tls option expects an object", .{});
             }
 
             var any = false;
@@ -764,23 +765,20 @@ pub const ServerConfig = struct {
             result.reject_unauthorized = @intFromBool(vm.getTLSRejectUnauthorized());
 
             // Required
-            if (obj.getOwnTruthy(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.throwInvalidArguments("Unable to access keyFile path", .{});
                     }
                     any = true;
                     result.requires_custom_request_ctx = true;
                 }
             }
 
-            if (obj.getOwnTruthy(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) {
@@ -798,7 +796,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;
@@ -811,11 +809,9 @@ pub const ServerConfig = struct {
                                     return null;
                                 }
                             } else {
-                                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 global.throwInvalidArguments("key argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile", .{});
                             }
                         }
 
@@ -827,7 +823,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;
@@ -854,31 +850,27 @@ pub const ServerConfig = struct {
                             bun.default_allocator.free(native_array);
                         }
                     } else {
-                        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 global.throwInvalidArguments("key argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile", .{});
                     }
                 }
             }
 
-            if (obj.getOwnTruthy(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.throwInvalidArguments("Unable to access certFile path", .{});
                     }
                     any = true;
                     result.requires_custom_request_ctx = true;
                 }
             }
 
-            if (obj.getOwnTruthy(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();
@@ -890,13 +882,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.throwInvalidArguments("ALPNProtocols argument must be an string, Buffer or TypedArray", .{});
                 }
             }
 
-            if (obj.getOwnTruthy(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) {
@@ -914,7 +904,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;
@@ -927,11 +917,9 @@ pub const ServerConfig = struct {
                                     return null;
                                 }
                             } else {
-                                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 global.throwInvalidArguments("cert argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile", .{});
                             }
                         }
 
@@ -943,7 +931,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;
@@ -970,38 +958,32 @@ pub const ServerConfig = struct {
                             bun.default_allocator.free(native_array);
                         }
                     } else {
-                        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 global.throwInvalidArguments("cert argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile", .{});
                     }
                 }
             }
 
-            if (obj.getOwnTruthy(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.throw("Expected requestCert to be a boolean", .{});
                 }
             }
 
-            if (obj.getOwnTruthy(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.throw("Expected rejectUnauthorized to be a boolean", .{});
                 }
             }
 
-            if (obj.getOwnTruthy(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) {
@@ -1011,7 +993,7 @@ pub const ServerConfig = struct {
                 }
             }
 
-            if (obj.getOwnTruthy(global, "serverName") orelse obj.getOwnTruthy(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) {
@@ -1021,7 +1003,7 @@ pub const ServerConfig = struct {
                 }
             }
 
-            if (obj.getOwnTruthy(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) {
@@ -1039,7 +1021,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;
@@ -1052,11 +1034,9 @@ pub const ServerConfig = struct {
                                     return null;
                                 }
                             } else {
-                                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 global.throwInvalidArguments("ca argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile", .{});
                             }
                         }
 
@@ -1068,7 +1048,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;
@@ -1095,61 +1075,55 @@ 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);
                         // mark and free all certs
                         result.ca = native_array;
-                        result.deinit();
-                        return null;
+                        return global.throwInvalidArguments("ca argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile", .{});
                     }
                 }
             }
 
-            if (obj.getOwnTruthy(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.throwInvalidArguments("Invalid caFile path", .{});
                     }
                 }
             }
             // Optional
             if (any) {
-                if (obj.getOwnTruthy(global, "secureOptions")) |secure_options| {
+                if (try obj.getTruthy(global, "secureOptions")) |secure_options| {
                     if (secure_options.isNumber()) {
                         result.secure_options = secure_options.toU32();
                     }
                 }
 
-                if (obj.getOwnTruthy(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.getOwnTruthy(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.getOwnTruthy(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.throwInvalidArguments("Invalid dhParamsFile path", .{});
                         }
                     }
                 }
 
-                if (obj.getOwnTruthy(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) {
@@ -1157,14 +1131,12 @@ pub const ServerConfig = struct {
                     }
                 }
 
-                if (obj.getOwn(global, "lowMemoryMode")) |low_memory_mode| {
+                if (try obj.get(global, "lowMemoryMode")) |low_memory_mode| {
                     if (low_memory_mode.isBoolean() or low_memory_mode.isUndefined()) {
                         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.throw("Expected lowMemoryMode to be a boolean", .{});
                     }
                 }
             }
@@ -1175,11 +1147,16 @@ pub const ServerConfig = struct {
         }
     };
 
-    pub fn fromJS(global: *JSC.JSGlobalObject, arguments: *JSC.Node.ArgumentsSlice, exception: JSC.C.ExceptionRef) ServerConfig {
+    pub fn fromJS(
+        global: *JSC.JSGlobalObject,
+        args: *ServerConfig,
+        arguments: *JSC.Node.ArgumentsSlice,
+        allow_bake_config: bool,
+    ) bun.JSError!void {
         const vm = arguments.vm;
         const env = vm.bundler.env;
 
-        var args = ServerConfig{
+        args.* = .{
             .address = .{
                 .tcp = .{
                     .port = 3000,
@@ -1226,7 +1203,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;
@@ -1236,14 +1213,12 @@ pub const ServerConfig = struct {
 
         if (arguments.next()) |arg| {
             if (!arg.isObject()) {
-                JSC.throwInvalidArguments("Bun.serve expects an object", .{}, global, exception);
-                return args;
+                return global.throwInvalidArguments("Bun.serve expects an object", .{});
             }
 
-            if (arg.getOwn(global, "static")) |static| {
+            if (try 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 args;
+                    return global.throwInvalidArguments("Bun.serve expects 'static' to be an object shaped like { [pathname: string]: Response }", .{});
                 }
 
                 var iter = JSC.JSPropertyIterator(.{
@@ -1259,71 +1234,54 @@ 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 args;
+                        return global.throwInvalidArguments("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 args;
+                        return global.throwInvalidArguments("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 args;
-                    } 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 args;
+            if (global.hasException()) return error.JSError;
 
-            if (arg.getOwn(global, "idleTimeout")) |value| {
+            if (try arg.get(global, "idleTimeout")) |value| {
                 if (!value.isUndefinedOrNull()) {
                     if (!value.isAnyInt()) {
-                        JSC.throwInvalidArguments("Bun.serve expects idleTimeout to be an integer", .{}, global, exception);
-
-                        return args;
+                        return global.throwInvalidArguments("Bun.serve expects idleTimeout to be an integer", .{});
                     }
+                    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 args;
+                        return global.throwInvalidArguments("Bun.serve expects idleTimeout to be 255 or less", .{});
                     }
 
                     args.idleTimeout = @truncate(idleTimeout);
                 }
             }
 
-            if (arg.getOwnTruthy(global, "webSocket") orelse arg.getOwnTruthy(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);
                     if (args.ssl_config) |*conf| {
                         conf.deinit();
                     }
-                    return args;
+                    return global.throwInvalidArguments("Expected websocket to be an object", .{});
                 }
 
-                if (WebSocketServer.onCreate(global, websocket_object)) |wss| {
-                    args.websocket = wss;
-                } else {
-                    if (args.ssl_config) |*conf| {
-                        conf.deinit();
-                    }
-                    return args;
-                }
+                errdefer if (args.ssl_config) |*conf| conf.deinit();
+                args.websocket = try WebSocketServer.onCreate(global, websocket_object);
             }
-            if (global.hasException()) return args;
+            if (global.hasException()) return error.JSError;
 
-            if (arg.getOwnTruthy(global, "port")) |port_| {
+            if (try arg.getTruthy(global, "port")) |port_| {
                 args.address.tcp.port = @as(
                     u16,
                     @intCast(@min(
@@ -1333,9 +1291,9 @@ pub const ServerConfig = struct {
                 );
                 port = args.address.tcp.port;
             }
-            if (global.hasException()) return args;
+            if (global.hasException()) return error.JSError;
 
-            if (arg.getOwnTruthy(global, "baseURI")) |baseURI| {
+            if (try arg.getTruthy(global, "baseURI")) |baseURI| {
                 var sliced = baseURI.toSlice(global, bun.default_allocator);
 
                 if (sliced.len > 0) {
@@ -1343,13 +1301,11 @@ pub const ServerConfig = struct {
                     args.base_uri = bun.default_allocator.dupe(u8, sliced.slice()) catch unreachable;
                 }
             }
-            if (global.hasException()) return args;
+            if (global.hasException()) return error.JSError;
 
-            if (arg.getOwnTruthy(global, "hostname") orelse arg.getOwnTruthy(global, "host")) |host| {
-                const host_str = host.toSlice(
-                    global,
-                    bun.default_allocator,
-                );
+            if (try arg.getStringish(global, "hostname") orelse try arg.getStringish(global, "host")) |host| {
+                defer host.deref();
+                const host_str = host.toUTF8(bun.default_allocator);
                 defer host_str.deinit();
 
                 if (host_str.len > 0) {
@@ -1357,26 +1313,23 @@ pub const ServerConfig = struct {
                     has_hostname = true;
                 }
             }
-            if (global.hasException()) return args;
+            if (global.hasException()) return error.JSError;
 
-            if (arg.getOwnTruthy(global, "unix")) |unix| {
-                const unix_str = unix.toSlice(
-                    global,
-                    bun.default_allocator,
-                );
+            if (try arg.getStringish(global, "unix")) |unix| {
+                defer unix.deref();
+                const unix_str = unix.toUTF8(bun.default_allocator);
                 defer unix_str.deinit();
                 if (unix_str.len > 0) {
                     if (has_hostname) {
-                        JSC.throwInvalidArguments("Cannot specify both hostname and unix", .{}, global, exception);
-                        return args;
+                        return global.throwInvalidArguments("Cannot specify both hostname and unix", .{});
                     }
 
                     args.address = .{ .unix = bun.default_allocator.dupeZ(u8, unix_str.slice()) catch unreachable };
                 }
             }
-            if (global.hasException()) return args;
+            if (global.hasException()) return error.JSError;
 
-            if (arg.getOwn(global, "id")) |id| {
+            if (try arg.get(global, "id")) |id| {
                 if (id.isUndefinedOrNull()) {
                     args.allow_hot = false;
                 } else {
@@ -1392,145 +1345,142 @@ pub const ServerConfig = struct {
                     }
                 }
             }
-            if (global.hasException()) return args;
+            if (global.hasException()) return error.JSError;
 
-            if (arg.getOwn(global, "development")) |dev| {
+            if (try arg.get(global, "development")) |dev| {
                 args.development = dev.coerce(bool, global);
                 args.reuse_port = !args.development;
             }
-            if (global.hasException()) return args;
+            if (global.hasException()) return error.JSError;
 
-            if (arg.getOwn(global, "reusePort")) |dev| {
+            if (try arg.getTruthy(global, "app")) |bake_args_js| {
+                if (!bun.FeatureFlags.bake()) {
+                    return global.throwInvalidArguments("To use the experimental \"app\" option, upgrade to the canary build of bun via \"bun upgrade --canary\"", .{});
+                }
+                if (!allow_bake_config) {
+                    return global.throwInvalidArguments("To use the \"app\" option, change from calling \"Bun.serve({ app })\" to \"export default { app: ... }\"", .{});
+                }
+                if (!args.development) {
+                    return global.throwInvalidArguments("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 (try arg.get(global, "reusePort")) |dev| {
                 args.reuse_port = dev.coerce(bool, global);
             }
-            if (global.hasException()) return args;
+            if (global.hasException()) return error.JSError;
 
-            if (arg.getOwn(global, "inspector")) |inspector| {
+            if (try 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 args;
+                    return global.throwInvalidArguments("Cannot enable inspector in production. Please set development: true in Bun.serve()", .{});
                 }
             }
-            if (global.hasException()) return args;
+            if (global.hasException()) return error.JSError;
 
-            if (arg.getOwnTruthy(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 args;
+            if (global.hasException()) return error.JSError;
 
-            if (arg.getOwnTruthyComptime(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 args;
+                    return global.throwInvalidArguments("Expected error to be a function", .{});
                 }
                 const onErrorSnapshot = onError.withAsyncContextIfNeeded(global);
                 args.onError = onErrorSnapshot;
                 onErrorSnapshot.protect();
             }
-            if (global.hasException()) return args;
+            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 args;
+                    return global.throwInvalidArguments("Expected fetch() to be a function", .{});
                 }
                 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;
+                return global.throwInvalidArguments("Expected fetch() to be a function", .{});
             } else {
-                if (global.hasException()) return args;
-                JSC.throwInvalidArguments("Expected fetch() to be a function", .{}, global, exception);
-                return args;
+                if (global.hasException()) return error.JSError;
             }
 
-            if (arg.getTruthy(global, "tls")) |tls| {
-                if (tls.jsType().isArray()) {
+            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 args;
+                        return global.throwInvalidArguments("tls option expects at least 1 tls object", .{});
                     }
                     while (value_iter.next()) |item| {
-                        if (SSLConfig.inJS(vm, global, item, exception)) |ssl_config| {
-                            if (args.ssl_config == null) {
-                                args.ssl_config = ssl_config;
-                            } else {
-                                if (ssl_config.server_name == null or std.mem.span(ssl_config.server_name).len == 0) {
-                                    var config = ssl_config;
-                                    defer config.deinit();
-                                    JSC.throwInvalidArguments("SNI tls object must have a serverName", .{}, global, exception);
-                                    return args;
-                                }
-                                if (args.sni == null) {
-                                    args.sni = bun.BabyList(SSLConfig).initCapacity(bun.default_allocator, value_iter.len - 1) catch bun.outOfMemory();
-                                }
-
-                                args.sni.?.push(bun.default_allocator, ssl_config) catch bun.outOfMemory();
+                        var ssl_config = try SSLConfig.fromJS(vm, global, item) orelse {
+                            if (global.hasException()) {
+                                return error.JSError;
                             }
-                        }
 
-                        if (exception.* != null) {
-                            return args;
-                        }
+                            // Backwards-compatibility; we ignored empty tls objects.
+                            continue;
+                        };
 
-                        if (global.hasException()) {
-                            return args;
+                        if (args.ssl_config == null) {
+                            args.ssl_config = ssl_config;
+                        } else {
+                            if (ssl_config.server_name == null or std.mem.span(ssl_config.server_name).len == 0) {
+                                defer ssl_config.deinit();
+                                return global.throwInvalidArguments("SNI tls object must have a serverName", .{});
+                            }
+                            if (args.sni == null) {
+                                args.sni = bun.BabyList(SSLConfig).initCapacity(bun.default_allocator, value_iter.len - 1) catch bun.outOfMemory();
+                            }
+
+                            args.sni.?.push(bun.default_allocator, ssl_config) catch bun.outOfMemory();
                         }
                     }
                 } 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 args;
-                    }
-
                     if (global.hasException()) {
-                        return args;
+                        return error.JSError;
                     }
                 }
             }
-            if (global.hasException()) return args;
+            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 args;
-                }
-
                 if (global.hasException()) {
-                    return args;
+                    return error.JSError;
                 }
             }
         } else {
-            JSC.throwInvalidArguments("Bun.serve expects an object", .{}, global, exception);
-            return args;
+            return global.throwInvalidArguments("Bun.serve expects an object", .{});
         }
 
         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);
                 bun.default_allocator.free(@constCast(args.base_uri));
                 args.base_uri = "";
-                return args;
+                return global.throwInvalidArguments("baseURI must have a hostname", .{});
             }
 
             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);
                 bun.default_allocator.free(@constCast(args.base_uri));
                 args.base_uri = "";
-                return args;
+                return global.throwInvalidArguments("Unicode baseURI must already be encoded for now.\nnew URL(baseuRI).toString() should do the trick.", .{});
             }
 
             if (args.base_url.protocol.len == 0) {
@@ -1595,10 +1545,9 @@ 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);
                 bun.default_allocator.free(@constCast(args.base_uri));
                 args.base_uri = "";
-                return args;
+                return global.throwInvalidArguments("Unicode hostnames must already be encoded for now.\nnew URL(input).hostname should do the trick.", .{});
             }
 
             args.base_url = URL.parse(args.base_uri);
@@ -1607,20 +1556,18 @@ 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);
             bun.default_allocator.free(@constCast(args.base_uri));
             args.base_uri = "";
-            return args;
+            return global.throwInvalidArguments("baseURI must have a hostname", .{});
         }
 
         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);
             bun.default_allocator.free(@constCast(args.base_uri));
             args.base_uri = "";
-            return args;
+            return global.throwInvalidArguments("baseURI can't have a username or password", .{});
         }
 
-        return args;
+        return;
     }
 };
 
@@ -1875,6 +1822,28 @@ pub const AnyRequestContext = struct {
             else => @panic("Unexpected AnyRequestContext tag"),
         }
     }
+
+    pub fn deref(self: AnyRequestContext) void {
+        if (self.tagged_pointer.isNull()) {
+            return;
+        }
+
+        switch (self.tagged_pointer.tag()) {
+            @field(Pointer.Tag, bun.meta.typeBaseName(@typeName(HTTPServer.RequestContext))) => {
+                self.tagged_pointer.as(HTTPServer.RequestContext).deref();
+            },
+            @field(Pointer.Tag, bun.meta.typeBaseName(@typeName(HTTPSServer.RequestContext))) => {
+                self.tagged_pointer.as(HTTPSServer.RequestContext).deref();
+            },
+            @field(Pointer.Tag, bun.meta.typeBaseName(@typeName(DebugHTTPServer.RequestContext))) => {
+                self.tagged_pointer.as(DebugHTTPServer.RequestContext).deref();
+            },
+            @field(Pointer.Tag, bun.meta.typeBaseName(@typeName(DebugHTTPSServer.RequestContext))) => {
+                self.tagged_pointer.as(DebugHTTPSServer.RequestContext).deref();
+            },
+            else => @panic("Unexpected AnyRequestContext tag"),
+        }
+    }
 };
 
 // This is defined separately partially to work-around an LLVM debugger bug.
@@ -1965,10 +1934,10 @@ 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);
+            const arguments = callframe.arguments_old(2);
             var ctx = arguments.ptr[1].asPromisePtr(@This());
             defer ctx.deref();
 
@@ -1980,8 +1949,7 @@ fn NewRequestContext(comptime ssl_enabled: bool, comptime debug_mode: bool, comp
         }
 
         fn renderMissingInvalidResponse(ctx: *RequestContext, value: JSC.JSValue) void {
-            var class_name = value.getClassInfoName() orelse bun.String.empty;
-            defer class_name.deref();
+            const class_name = value.getClassInfoName() orelse "";
 
             if (ctx.server) |server| {
                 const globalThis: *JSC.JSGlobalObject = server.globalThis;
@@ -1989,9 +1957,9 @@ fn NewRequestContext(comptime ssl_enabled: bool, comptime debug_mode: bool, comp
                 Output.enableBuffering();
                 var writer = Output.errorWriter();
 
-                if (class_name.eqlComptime("Response")) {
+                if (bun.strings.eqlComptime(class_name, "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,
@@ -2110,10 +2078,10 @@ 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);
+            const arguments = callframe.arguments_old(2);
             const ctx = arguments.ptr[1].asPromisePtr(@This());
             const err = arguments.ptr[0];
             defer ctx.deref();
@@ -2130,7 +2098,7 @@ fn NewRequestContext(comptime ssl_enabled: bool, comptime debug_mode: bool, comp
             const has_responded = resp.hasResponded();
             if (!has_responded) {
                 const original_state = ctx.defer_deinit_until_callback_completes;
-                var should_deinit_context = false;
+                var should_deinit_context = if (original_state) |defer_deinit| defer_deinit.* else false;
                 ctx.defer_deinit_until_callback_completes = &should_deinit_context;
                 ctx.runErrorHandler(
                     value,
@@ -2173,7 +2141,7 @@ fn NewRequestContext(comptime ssl_enabled: bool, comptime debug_mode: bool, comp
                     ctx.end("", ctx.shouldCloseConnection());
                     return;
                 }
-                // avoid writing the status again and missmatching the content-length
+                // avoid writing the status again and mismatching the content-length
                 if (ctx.flags.has_written_status) {
                     ctx.end("", ctx.shouldCloseConnection());
                     return;
@@ -2374,13 +2342,14 @@ fn NewRequestContext(comptime ssl_enabled: bool, comptime debug_mode: bool, comp
             return this.sendWritableBytesForCompleteResponseBuffer(this.response_buf_owned.items, write_offset, resp);
         }
 
-        pub fn create(this: *RequestContext, server: *ThisServer, req: *uws.Request, resp: *App.Response) void {
+        pub fn create(this: *RequestContext, server: *ThisServer, req: *uws.Request, resp: *App.Response, should_deinit_context: ?*bool) void {
             this.* = .{
                 .allocator = server.allocator,
                 .resp = resp,
                 .req = req,
                 .method = HTTP.Method.which(req.method()) orelse .GET,
                 .server = server,
+                .defer_deinit_until_callback_completes = should_deinit_context,
             };
 
             ctxLog("create<d> ({*})<r>", .{this});
@@ -2491,7 +2460,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();
@@ -3179,13 +3148,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();
@@ -3298,8 +3263,6 @@ fn NewRequestContext(comptime ssl_enabled: bool, comptime debug_mode: bool, comp
 
             var wrote_anything = false;
             if (req.sink) |wrapper| {
-                wrapper.sink.pending_flush = null;
-                wrapper.sink.done = true;
                 req.flags.aborted = req.flags.aborted or wrapper.sink.aborted;
                 wrote_anything = wrapper.sink.wrote > 0;
 
@@ -3332,17 +3295,17 @@ 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 args = callframe.arguments_old(2);
             var req: *@This() = args.ptr[args.len - 1].asPromisePtr(@This());
             defer req.deref();
             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);
+            const args = callframe.arguments_old(2);
             var req = args.ptr[args.len - 1].asPromisePtr(@This());
             const err = args.ptr[0];
             defer req.deref();
@@ -3689,7 +3652,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,
@@ -4123,18 +4086,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 });
         }
     };
 }
@@ -4185,16 +4144,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.getOwnTruthyComptime(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.throwInvalidArguments("websocket expects a function for the message option", .{});
                 }
                 const message = message_.withAsyncContextIfNeeded(globalObject);
                 handler.onMessage = message;
@@ -4202,10 +4160,9 @@ pub const WebSocketServer = struct {
                 valid = true;
             }
 
-            if (object.getOwnTruthy(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.throwInvalidArguments("websocket expects a function for the open option", .{});
                 }
                 const open = open_.withAsyncContextIfNeeded(globalObject);
                 handler.onOpen = open;
@@ -4213,10 +4170,9 @@ pub const WebSocketServer = struct {
                 valid = true;
             }
 
-            if (object.getOwnTruthy(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.throwInvalidArguments("websocket expects a function for the close option", .{});
                 }
                 const close = close_.withAsyncContextIfNeeded(globalObject);
                 handler.onClose = close;
@@ -4224,10 +4180,9 @@ pub const WebSocketServer = struct {
                 valid = true;
             }
 
-            if (object.getOwnTruthy(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.throwInvalidArguments("websocket expects a function for the drain option", .{});
                 }
                 const drain = drain_.withAsyncContextIfNeeded(globalObject);
                 handler.onDrain = drain;
@@ -4235,30 +4190,27 @@ pub const WebSocketServer = struct {
                 valid = true;
             }
 
-            if (object.getOwnTruthy(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.throwInvalidArguments("websocket expects a function for the onError option", .{});
                 }
                 const onError = onError_.withAsyncContextIfNeeded(globalObject);
                 handler.onError = onError;
                 onError.ensureStillAlive();
             }
 
-            if (object.getOwnTruthy(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.throwInvalidArguments("websocket expects a function for the ping option", .{});
                 }
                 handler.onPing = cb;
                 cb.ensureStillAlive();
                 valid = true;
             }
 
-            if (object.getOwnTruthy(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.throwInvalidArguments("websocket expects a function for the pong option", .{});
                 }
                 handler.onPong = cb;
                 cb.ensureStillAlive();
@@ -4268,7 +4220,7 @@ pub const WebSocketServer = struct {
             if (valid)
                 return handler;
 
-            return null;
+            return globalObject.throwInvalidArguments("WebSocketServer expects a message handler", .{});
         }
 
         pub fn protect(this: Handler) void {
@@ -4344,17 +4296,11 @@ 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{};
+        server.handler = try Handler.fromJS(globalObject, object);
 
-        if (Handler.fromJS(globalObject, object)) |handler| {
-            server.handler = handler;
-        } else {
-            globalObject.throwInvalidArguments("WebSocketServer expects a message handler", .{});
-            return null;
-        }
-
-        if (object.getOwn(globalObject, "perMessageDeflate")) |per_message_deflate| {
+        if (try object.get(globalObject, "perMessageDeflate")) |per_message_deflate| {
             getter: {
                 if (per_message_deflate.isUndefined()) {
                     break :getter;
@@ -4369,69 +4315,50 @@ pub const WebSocketServer = struct {
                     break :getter;
                 }
 
-                if (per_message_deflate.getOwnTruthy(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.throwInvalidArguments("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.throwInvalidArguments("websocket expects a valid compress option, either disable \"shared\" \"dedicated\" \"3KB\" \"4KB\" \"8KB\" \"16KB\" \"32KB\" \"64KB\" \"128KB\" or \"256KB\"", .{});
                     }
                 }
 
-                if (per_message_deflate.getOwnTruthy(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.throwInvalidArguments("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.throwInvalidArguments("websocket expects a valid decompress option, either \"disable\" \"shared\" \"dedicated\" \"3KB\" \"4KB\" \"8KB\" \"16KB\" \"32KB\" \"64KB\" \"128KB\" or \"256KB\"", .{});
                     }
                 }
             }
         }
 
-        if (object.getOwn(globalObject, "maxPayloadLength")) |value| {
+        if (try object.get(globalObject, "maxPayloadLength")) |value| {
             if (!value.isUndefinedOrNull()) {
                 if (!value.isAnyInt()) {
-                    globalObject.throwInvalidArguments("websocket expects maxPayloadLength to be an integer", .{});
-                    return null;
+                    return globalObject.throwInvalidArguments("websocket expects maxPayloadLength to be an integer", .{});
                 }
                 server.maxPayloadLength = @truncate(@max(value.toInt64(), 0));
             }
         }
 
-        if (object.getOwn(globalObject, "idleTimeout")) |value| {
+        if (try object.get(globalObject, "idleTimeout")) |value| {
             if (!value.isUndefinedOrNull()) {
                 if (!value.isAnyInt()) {
-                    globalObject.throwInvalidArguments("websocket expects idleTimeout to be an integer", .{});
-                    return null;
+                    return globalObject.throwInvalidArguments("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.throwInvalidArguments("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.
@@ -4441,44 +4368,40 @@ pub const WebSocketServer = struct {
                 server.idleTimeout = idleTimeout;
             }
         }
-        if (object.getOwn(globalObject, "backpressureLimit")) |value| {
+        if (try object.get(globalObject, "backpressureLimit")) |value| {
             if (!value.isUndefinedOrNull()) {
                 if (!value.isAnyInt()) {
-                    globalObject.throwInvalidArguments("websocket expects backpressureLimit to be an integer", .{});
-                    return null;
+                    return globalObject.throwInvalidArguments("websocket expects backpressureLimit to be an integer", .{});
                 }
 
                 server.backpressureLimit = @truncate(@max(value.toInt64(), 0));
             }
         }
 
-        if (object.getOwn(globalObject, "closeOnBackpressureLimit")) |value| {
+        if (try object.get(globalObject, "closeOnBackpressureLimit")) |value| {
             if (!value.isUndefinedOrNull()) {
                 if (!value.isBoolean()) {
-                    globalObject.throwInvalidArguments("websocket expects closeOnBackpressureLimit to be a boolean", .{});
-                    return null;
+                    return globalObject.throwInvalidArguments("websocket expects closeOnBackpressureLimit to be a boolean", .{});
                 }
 
                 server.closeOnBackpressureLimit = value.toBoolean();
             }
         }
 
-        if (object.getOwn(globalObject, "sendPings")) |value| {
+        if (try object.get(globalObject, "sendPings")) |value| {
             if (!value.isUndefinedOrNull()) {
                 if (!value.isBoolean()) {
-                    globalObject.throwInvalidArguments("websocket expects sendPings to be a boolean", .{});
-                    return null;
+                    return globalObject.throwInvalidArguments("websocket expects sendPings to be a boolean", .{});
                 }
 
                 server.sendPingsAutomatically = value.toBoolean();
             }
         }
 
-        if (object.getOwn(globalObject, "publishToSelf")) |value| {
+        if (try object.get(globalObject, "publishToSelf")) |value| {
             if (!value.isUndefinedOrNull()) {
                 if (!value.isBoolean()) {
-                    globalObject.throwInvalidArguments("websocket expects publishToSelf to be a boolean", .{});
-                    return null;
+                    return globalObject.throwInvalidArguments("websocket expects publishToSelf to be a boolean", .{});
                 }
 
                 server.handler.flags.publish_to_self = value.toBoolean();
@@ -4512,6 +4435,7 @@ pub const ServerWebSocket = struct {
     handler: *WebSocketServer.Handler,
     this_value: JSValue = .zero,
     flags: Flags = .{},
+    signal: ?*JSC.AbortSignal = null,
 
     // We pack the per-socket data into this struct below
     const Flags = packed struct(u64) {
@@ -4793,17 +4717,35 @@ pub const ServerWebSocket = struct {
                 handler.active_connections -|= 1;
             }
         }
+        const signal = this.signal;
+        this.signal = null;
+
+        defer {
+            if (signal) |sig| {
+                sig.pendingActivityUnref();
+                sig.unref();
+            }
+        }
 
         const vm = handler.vm;
-        if (vm.isShuttingDown()) return;
+        if (vm.isShuttingDown()) {
+            return;
+        }
 
         if (!handler.onClose.isEmptyOrUndefinedOrNull()) {
             var str = ZigString.init(message);
             const globalObject = handler.globalObject;
             const loop = vm.eventLoop();
+
             loop.enter();
             defer loop.exit();
             str.markUTF8();
+            if (signal) |sig| {
+                if (!sig.aborted()) {
+                    sig.signal(handler.globalObject, .ConnectionClosed);
+                }
+            }
+
             _ = handler.onClose.call(
                 globalObject,
                 .undefined,
@@ -4813,6 +4755,15 @@ pub const ServerWebSocket = struct {
                 log("onClose error", .{});
                 handler.runErrorCallback(vm, globalObject, err);
             };
+        } else if (signal) |sig| {
+            const loop = vm.eventLoop();
+
+            loop.enter();
+            defer loop.exit();
+
+            if (!sig.aborted()) {
+                sig.signal(handler.globalObject, .ConnectionClosed);
+            }
         }
 
         this.this_value.unprotect();
@@ -4822,9 +4773,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.throw("Cannot construct ServerWebSocket", .{});
     }
 
     pub fn finalize(this: *ServerWebSocket) void {
@@ -4836,12 +4786,11 @@ pub const ServerWebSocket = struct {
         this: *ServerWebSocket,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSValue {
-        const args = callframe.arguments(4);
+    ) bun.JSError!JSValue {
+        const args = callframe.arguments_old(4);
         if (args.len < 1) {
             log("publish()", .{});
-            globalThis.throw("publish requires at least 1 argument", .{});
-            return .zero;
+            return globalThis.throw("publish requires at least 1 argument", .{});
         }
 
         const app = this.handler.app orelse {
@@ -4858,27 +4807,23 @@ pub const ServerWebSocket = struct {
 
         if (topic_value.isEmptyOrUndefinedOrNull() or !topic_value.isString()) {
             log("publish() topic invalid", .{});
-            globalThis.throw("publish requires a topic string", .{});
-            return .zero;
+            return globalThis.throw("publish requires a topic string", .{});
         }
 
         var topic_slice = topic_value.toSlice(globalThis, bun.default_allocator);
         defer topic_slice.deinit();
         if (topic_slice.len == 0) {
-            globalThis.throw("publish requires a non-empty topic", .{});
-            return .zero;
+            return globalThis.throw("publish requires a non-empty topic", .{});
         }
 
-        if (!compress_value.isBoolean() and !compress_value.isUndefined() and !compress_value.isEmpty()) {
-            globalThis.throw("publish expects compress to be a boolean", .{});
-            return .zero;
+        if (!compress_value.isBoolean() and !compress_value.isUndefined() and compress_value != .zero) {
+            return globalThis.throw("publish expects compress to be a boolean", .{});
         }
 
         const compress = args.len > 1 and compress_value.toBoolean();
 
         if (message_value.isEmptyOrUndefinedOrNull()) {
-            globalThis.throw("publish requires a non-empty message", .{});
-            return .zero;
+            return globalThis.throw("publish requires a non-empty message", .{});
         }
 
         if (message_value.asArrayBuffer(globalThis)) |array_buffer| {
@@ -4921,13 +4866,12 @@ pub const ServerWebSocket = struct {
         this: *ServerWebSocket,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSValue {
-        const args = callframe.arguments(4);
+    ) bun.JSError!JSValue {
+        const args = callframe.arguments_old(4);
 
         if (args.len < 1) {
             log("publish()", .{});
-            globalThis.throw("publish requires at least 1 argument", .{});
-            return .zero;
+            return globalThis.throw("publish requires at least 1 argument", .{});
         }
 
         const app = this.handler.app orelse {
@@ -4944,23 +4888,20 @@ pub const ServerWebSocket = struct {
 
         if (topic_value.isEmptyOrUndefinedOrNull() or !topic_value.isString()) {
             log("publish() topic invalid", .{});
-            globalThis.throw("publishText requires a topic string", .{});
-            return .zero;
+            return globalThis.throw("publishText requires a topic string", .{});
         }
 
         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()) {
-            globalThis.throw("publishText expects compress to be a boolean", .{});
-            return .zero;
+        if (!compress_value.isBoolean() and !compress_value.isUndefined() and compress_value != .zero) {
+            return globalThis.throw("publishText expects compress to be a boolean", .{});
         }
 
         const compress = args.len > 1 and compress_value.toBoolean();
 
         if (message_value.isEmptyOrUndefinedOrNull() or !message_value.isString()) {
-            globalThis.throw("publishText requires a non-empty message", .{});
-            return .zero;
+            return globalThis.throw("publishText requires a non-empty message", .{});
         }
 
         var string_slice = message_value.toSlice(globalThis, bun.default_allocator);
@@ -4984,13 +4925,12 @@ pub const ServerWebSocket = struct {
         this: *ServerWebSocket,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSValue {
-        const args = callframe.arguments(4);
+    ) bun.JSError!JSValue {
+        const args = callframe.arguments_old(4);
 
         if (args.len < 1) {
             log("publishBinary()", .{});
-            globalThis.throw("publishBinary requires at least 1 argument", .{});
-            return .zero;
+            return globalThis.throw("publishBinary requires at least 1 argument", .{});
         }
 
         const app = this.handler.app orelse {
@@ -5006,32 +4946,27 @@ pub const ServerWebSocket = struct {
 
         if (topic_value.isEmptyOrUndefinedOrNull() or !topic_value.isString()) {
             log("publishBinary() topic invalid", .{});
-            globalThis.throw("publishBinary requires a topic string", .{});
-            return .zero;
+            return globalThis.throw("publishBinary requires a topic string", .{});
         }
 
         var topic_slice = topic_value.toSlice(globalThis, bun.default_allocator);
         defer topic_slice.deinit();
         if (topic_slice.len == 0) {
-            globalThis.throw("publishBinary requires a non-empty topic", .{});
-            return .zero;
+            return globalThis.throw("publishBinary requires a non-empty topic", .{});
         }
 
-        if (!compress_value.isBoolean() and !compress_value.isUndefined() and !compress_value.isEmpty()) {
-            globalThis.throw("publishBinary expects compress to be a boolean", .{});
-            return .zero;
+        if (!compress_value.isBoolean() and !compress_value.isUndefined() and compress_value != .zero) {
+            return globalThis.throw("publishBinary expects compress to be a boolean", .{});
         }
 
         const compress = args.len > 1 and compress_value.toBoolean();
 
         if (message_value.isEmptyOrUndefinedOrNull()) {
-            globalThis.throw("publishBinary requires a non-empty message", .{});
-            return .zero;
+            return globalThis.throw("publishBinary requires a non-empty message", .{});
         }
 
         const array_buffer = message_value.asArrayBuffer(globalThis) orelse {
-            globalThis.throw("publishBinary expects an ArrayBufferView", .{});
-            return .zero;
+            return globalThis.throw("publishBinary expects an ArrayBufferView", .{});
         };
         const buffer = array_buffer.slice();
 
@@ -5064,8 +4999,7 @@ pub const ServerWebSocket = struct {
         var topic_slice = topic_str.toSlice(globalThis, bun.default_allocator);
         defer topic_slice.deinit();
         if (topic_slice.len == 0) {
-            globalThis.throw("publishBinary requires a non-empty topic", .{});
-            return .zero;
+            return globalThis.throw("publishBinary requires a non-empty topic", .{});
         }
 
         const compress = true;
@@ -5104,8 +5038,7 @@ pub const ServerWebSocket = struct {
         var topic_slice = topic_str.toSlice(globalThis, bun.default_allocator);
         defer topic_slice.deinit();
         if (topic_slice.len == 0) {
-            globalThis.throw("publishBinary requires a non-empty topic", .{});
-            return .zero;
+            return globalThis.throw("publishBinary requires a non-empty topic", .{});
         }
 
         const compress = true;
@@ -5137,13 +5070,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 {
-        const args = callframe.arguments(1);
+    ) bun.JSError!JSValue {
+        const args = callframe.arguments_old(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];
@@ -5165,8 +5097,7 @@ pub const ServerWebSocket = struct {
         const result = corker.result;
 
         if (result.isAnyError()) {
-            globalThis.throwValue(result);
-            return JSValue.jsUndefined();
+            return globalThis.throwValue(result);
         }
 
         return result;
@@ -5176,13 +5107,12 @@ pub const ServerWebSocket = struct {
         this: *ServerWebSocket,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSValue {
-        const args = callframe.arguments(2);
+    ) bun.JSError!JSValue {
+        const args = callframe.arguments_old(2);
 
         if (args.len < 1) {
             log("send()", .{});
-            globalThis.throw("send requires at least 1 argument", .{});
-            return .zero;
+            return globalThis.throw("send requires at least 1 argument", .{});
         }
 
         if (this.isClosed()) {
@@ -5193,16 +5123,14 @@ 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()) {
-            globalThis.throw("send expects compress to be a boolean", .{});
-            return .zero;
+        if (!compress_value.isBoolean() and !compress_value.isUndefined() and compress_value != .zero) {
+            return globalThis.throw("send expects compress to be a boolean", .{});
         }
 
         const compress = args.len > 1 and compress_value.toBoolean();
 
         if (message_value.isEmptyOrUndefinedOrNull()) {
-            globalThis.throw("send requires a non-empty message", .{});
-            return .zero;
+            return globalThis.throw("send requires a non-empty message", .{});
         }
 
         if (message_value.asArrayBuffer(globalThis)) |buffer| {
@@ -5250,13 +5178,12 @@ pub const ServerWebSocket = struct {
         this: *ServerWebSocket,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSValue {
-        const args = callframe.arguments(2);
+    ) bun.JSError!JSValue {
+        const args = callframe.arguments_old(2);
 
         if (args.len < 1) {
             log("sendText()", .{});
-            globalThis.throw("sendText requires at least 1 argument", .{});
-            return .zero;
+            return globalThis.throw("sendText requires at least 1 argument", .{});
         }
 
         if (this.isClosed()) {
@@ -5267,16 +5194,14 @@ 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()) {
-            globalThis.throw("sendText expects compress to be a boolean", .{});
-            return .zero;
+        if (!compress_value.isBoolean() and !compress_value.isUndefined() and compress_value != .zero) {
+            return globalThis.throw("sendText expects compress to be a boolean", .{});
         }
 
         const compress = args.len > 1 and compress_value.toBoolean();
 
         if (message_value.isEmptyOrUndefinedOrNull() or !message_value.isString()) {
-            globalThis.throw("sendText expects a string", .{});
-            return .zero;
+            return globalThis.throw("sendText expects a string", .{});
         }
 
         var string_slice = message_value.toSlice(globalThis, bun.default_allocator);
@@ -5334,13 +5259,12 @@ pub const ServerWebSocket = struct {
         this: *ServerWebSocket,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSValue {
-        const args = callframe.arguments(2);
+    ) bun.JSError!JSValue {
+        const args = callframe.arguments_old(2);
 
         if (args.len < 1) {
             log("sendBinary()", .{});
-            globalThis.throw("sendBinary requires at least 1 argument", .{});
-            return .zero;
+            return globalThis.throw("sendBinary requires at least 1 argument", .{});
         }
 
         if (this.isClosed()) {
@@ -5351,16 +5275,14 @@ 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()) {
-            globalThis.throw("sendBinary expects compress to be a boolean", .{});
-            return .zero;
+        if (!compress_value.isBoolean() and !compress_value.isUndefined() and compress_value != .zero) {
+            return globalThis.throw("sendBinary expects compress to be a boolean", .{});
         }
 
         const compress = args.len > 1 and compress_value.toBoolean();
 
         const buffer = message_value.asArrayBuffer(globalThis) orelse {
-            globalThis.throw("sendBinary requires an ArrayBufferView", .{});
-            return .zero;
+            return globalThis.throw("sendBinary requires an ArrayBufferView", .{});
         };
 
         switch (this.websocket().send(buffer.slice(), .binary, compress, true)) {
@@ -5412,7 +5334,7 @@ pub const ServerWebSocket = struct {
         this: *ServerWebSocket,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         return sendPing(this, globalThis, callframe, "ping", .ping);
     }
 
@@ -5420,7 +5342,7 @@ pub const ServerWebSocket = struct {
         this: *ServerWebSocket,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         return sendPing(this, globalThis, callframe, "pong", .pong);
     }
 
@@ -5430,8 +5352,8 @@ pub const ServerWebSocket = struct {
         callframe: *JSC.CallFrame,
         comptime name: string,
         comptime opcode: uws.Opcode,
-    ) JSValue {
-        const args = callframe.arguments(2);
+    ) bun.JSError!JSValue {
+        const args = callframe.arguments_old(2);
 
         if (this.isClosed()) {
             return JSValue.jsNumber(0);
@@ -5439,45 +5361,46 @@ pub const ServerWebSocket = struct {
 
         if (args.len > 0) {
             var value = args.ptr[0];
-            if (value.asArrayBuffer(globalThis)) |data| {
-                const buffer = data.slice();
+            if (!value.isEmptyOrUndefinedOrNull()) {
+                if (value.asArrayBuffer(globalThis)) |data| {
+                    const buffer = data.slice();
 
-                switch (this.websocket().send(buffer, opcode, false, true)) {
-                    .backpressure => {
-                        log("{s}() backpressure ({d} bytes)", .{ name, buffer.len });
-                        return JSValue.jsNumber(-1);
-                    },
-                    .success => {
-                        log("{s}() success ({d} bytes)", .{ name, buffer.len });
-                        return JSValue.jsNumber(buffer.len);
-                    },
-                    .dropped => {
-                        log("{s}() dropped ({d} bytes)", .{ name, buffer.len });
-                        return JSValue.jsNumber(0);
-                    },
-                }
-            } else if (value.isString()) {
-                var string_value = value.toString(globalThis).toSlice(globalThis, bun.default_allocator);
-                defer string_value.deinit();
-                const buffer = string_value.slice();
+                    switch (this.websocket().send(buffer, opcode, false, true)) {
+                        .backpressure => {
+                            log("{s}() backpressure ({d} bytes)", .{ name, buffer.len });
+                            return JSValue.jsNumber(-1);
+                        },
+                        .success => {
+                            log("{s}() success ({d} bytes)", .{ name, buffer.len });
+                            return JSValue.jsNumber(buffer.len);
+                        },
+                        .dropped => {
+                            log("{s}() dropped ({d} bytes)", .{ name, buffer.len });
+                            return JSValue.jsNumber(0);
+                        },
+                    }
+                } else if (value.isString()) {
+                    var string_value = value.toString(globalThis).toSlice(globalThis, bun.default_allocator);
+                    defer string_value.deinit();
+                    const buffer = string_value.slice();
 
-                switch (this.websocket().send(buffer, opcode, false, true)) {
-                    .backpressure => {
-                        log("{s}() backpressure ({d} bytes)", .{ name, buffer.len });
-                        return JSValue.jsNumber(-1);
-                    },
-                    .success => {
-                        log("{s}() success ({d} bytes)", .{ name, buffer.len });
-                        return JSValue.jsNumber(buffer.len);
-                    },
-                    .dropped => {
-                        log("{s}() dropped ({d} bytes)", .{ name, buffer.len });
-                        return JSValue.jsNumber(0);
-                    },
+                    switch (this.websocket().send(buffer, opcode, false, true)) {
+                        .backpressure => {
+                            log("{s}() backpressure ({d} bytes)", .{ name, buffer.len });
+                            return JSValue.jsNumber(-1);
+                        },
+                        .success => {
+                            log("{s}() success ({d} bytes)", .{ name, buffer.len });
+                            return JSValue.jsNumber(buffer.len);
+                        },
+                        .dropped => {
+                            log("{s}() dropped ({d} bytes)", .{ name, buffer.len });
+                            return JSValue.jsNumber(0);
+                        },
+                    }
+                } else {
+                    return globalThis.throwPretty("{s} requires a string or BufferSource", .{name});
                 }
-            } else {
-                globalThis.throwPretty("{s} requires a string or BufferSource", .{name});
-                return .zero;
             }
         }
 
@@ -5534,8 +5457,8 @@ 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 {
-        const args = callframe.arguments(2);
+    ) bun.JSError!JSValue {
+        const args = callframe.arguments_old(2);
         log("close()", .{});
         this.this_value = this_value;
 
@@ -5544,28 +5467,21 @@ 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;
             }
 
             if (!args.ptr[0].isNumber()) {
-                globalThis.throwInvalidArguments("close requires a numeric code or undefined", .{});
-                return .zero;
+                return globalThis.throwInvalidArguments("close requires a numeric code or undefined", .{});
             }
 
             break :brk args.ptr[0].coerce(i32, globalThis);
         };
 
         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].toSliceOrNull(globalThis)) |slice| {
-                break :brk slice;
-            }
-
-            // toString() failed, that means an exception occurred.
-            return .zero;
+            if (args.ptr[1] == .zero or args.ptr[1].isUndefined()) break :brk ZigString.Slice.empty;
+            break :brk try args.ptr[1].toSliceOrNull(globalThis);
         };
 
         defer message_value.deinit();
@@ -5581,9 +5497,9 @@ 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);
+        const args = callframe.arguments_old(2);
         _ = args;
         log("terminate()", .{});
 
@@ -5607,21 +5523,18 @@ pub const ServerWebSocket = struct {
         log("getBinaryType()", .{});
 
         return switch (this.flags.binary_type) {
-            .Uint8Array => ZigString.static("uint8array").toJS(globalThis),
-            .Buffer => ZigString.static("nodebuffer").toJS(globalThis),
-            .ArrayBuffer => ZigString.static("arraybuffer").toJS(globalThis),
+            .Uint8Array => bun.String.static("uint8array").toJS(globalThis),
+            .Buffer => bun.String.static("nodebuffer").toJS(globalThis),
+            .ArrayBuffer => bun.String.static("arraybuffer").toJS(globalThis),
             else => @panic("Invalid binary type"),
         };
     }
 
-    pub fn setBinaryType(
-        this: *ServerWebSocket,
-        globalThis: *JSC.JSGlobalObject,
-        value: JSC.JSValue,
-    ) callconv(.C) bool {
+    pub fn setBinaryType(this: *ServerWebSocket, globalThis: *JSC.JSGlobalObject, value: JSC.JSValue) 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| {
@@ -5629,7 +5542,7 @@ pub const ServerWebSocket = struct {
                 return true;
             },
             else => {
-                globalThis.throw("binaryType must be either \"uint8array\" or \"arraybuffer\" or \"nodebuffer\"", .{});
+                globalThis.throw("binaryType must be either \"uint8array\" or \"arraybuffer\" or \"nodebuffer\"", .{}) catch {};
                 return false;
             },
         }
@@ -5639,7 +5552,7 @@ pub const ServerWebSocket = struct {
         this: *ServerWebSocket,
         _: *JSC.JSGlobalObject,
         _: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         log("getBufferedAmount()", .{});
 
         if (this.isClosed()) {
@@ -5652,11 +5565,10 @@ pub const ServerWebSocket = struct {
         this: *ServerWebSocket,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSValue {
-        const args = callframe.arguments(1);
+    ) bun.JSError!JSValue {
+        const args = callframe.arguments_old(1);
         if (args.len < 1) {
-            globalThis.throw("subscribe requires at least 1 argument", .{});
-            return .zero;
+            return globalThis.throw("subscribe requires at least 1 argument", .{});
         }
 
         if (this.isClosed()) {
@@ -5679,8 +5591,7 @@ pub const ServerWebSocket = struct {
         }
 
         if (topic.len == 0) {
-            globalThis.throw("subscribe requires a non-empty topic name", .{});
-            return .zero;
+            return globalThis.throw("subscribe requires a non-empty topic name", .{});
         }
 
         return JSValue.jsBoolean(this.websocket().subscribe(topic.slice()));
@@ -5689,11 +5600,10 @@ pub const ServerWebSocket = struct {
         this: *ServerWebSocket,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSValue {
-        const args = callframe.arguments(1);
+    ) bun.JSError!JSValue {
+        const args = callframe.arguments_old(1);
         if (args.len < 1) {
-            globalThis.throw("unsubscribe requires at least 1 argument", .{});
-            return .zero;
+            return globalThis.throw("unsubscribe requires at least 1 argument", .{});
         }
 
         if (this.isClosed()) {
@@ -5716,8 +5626,7 @@ pub const ServerWebSocket = struct {
         }
 
         if (topic.len == 0) {
-            globalThis.throw("unsubscribe requires a non-empty topic name", .{});
-            return .zero;
+            return globalThis.throw("unsubscribe requires a non-empty topic name", .{});
         }
 
         return JSValue.jsBoolean(this.websocket().unsubscribe(topic.slice()));
@@ -5726,11 +5635,10 @@ pub const ServerWebSocket = struct {
         this: *ServerWebSocket,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSValue {
-        const args = callframe.arguments(1);
+    ) bun.JSError!JSValue {
+        const args = callframe.arguments_old(1);
         if (args.len < 1) {
-            globalThis.throw("isSubscribed requires at least 1 argument", .{});
-            return .zero;
+            return globalThis.throw("isSubscribed requires at least 1 argument", .{});
         }
 
         if (this.isClosed()) {
@@ -5753,8 +5661,7 @@ pub const ServerWebSocket = struct {
         }
 
         if (topic.len == 0) {
-            globalThis.throw("isSubscribed requires a non-empty topic name", .{});
-            return .zero;
+            return globalThis.throw("isSubscribed requires a non-empty topic name", .{});
         }
 
         return JSValue.jsBoolean(this.websocket().isSubscribed(topic.slice()));
@@ -5795,8 +5702,9 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
 
         listener: ?*App.ListenSocket = null,
         thisObject: JSC.JSValue = JSC.JSValue.zero,
-        app: *App = undefined,
-        vm: *JSC.VirtualMachine = undefined,
+        /// Potentially null before listen() is called, and once .destroy() is called.
+        app: ?*App = null,
+        vm: *JSC.VirtualMachine,
         globalThis: *JSGlobalObject,
         base_url_string_for_joining: string = "",
         config: ServerConfig = ServerConfig{},
@@ -5807,10 +5715,8 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
         listen_callback: JSC.AnyTask = undefined,
         allocator: std.mem.Allocator,
         poll_ref: Async.KeepAlive = .{},
-        temporary_url_buffer: std.ArrayListUnmanaged(u8) = .{},
 
         cached_hostname: bun.String = bun.String.empty,
-        cached_protocol: bun.String = bun.String.empty,
 
         flags: packed struct(u4) {
             deinit_scheduled: bool = false,
@@ -5819,6 +5725,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);
@@ -5828,16 +5736,14 @@ 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 {
-            const arguments = callframe.arguments(1);
+        pub fn doSubscriberCount(this: *ThisServer, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+            const arguments = callframe.arguments_old(1);
             if (arguments.len < 1) {
-                globalThis.throwNotEnoughArguments("subscriberCount", 1, 0);
-                return .zero;
+                return globalThis.throwNotEnoughArguments("subscriberCount", 1, 0);
             }
 
             if (arguments.ptr[0].isEmptyOrUndefinedOrNull()) {
-                globalThis.throwInvalidArguments("subscriberCount requires a topic name as a string", .{});
-                return .zero;
+                return globalThis.throwInvalidArguments("subscriberCount requires a topic name as a string", .{});
             }
 
             var topic = arguments.ptr[0].toSlice(globalThis, bun.default_allocator);
@@ -5850,15 +5756,18 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
                 return JSValue.jsNumber(0);
             }
 
-            return JSValue.jsNumber((this.app.num_subscribers(topic.slice())));
+            if (this.config.websocket == null or this.app == null) {
+                return JSValue.jsNumber(0);
+            }
+
+            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;
@@ -5878,10 +5787,9 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
                 JSValue.jsNull();
         }
 
-        pub fn timeout(this: *ThisServer, request: *JSC.WebCore.Request, seconds: JSValue) JSC.JSValue {
+        pub fn timeout(this: *ThisServer, request: *JSC.WebCore.Request, seconds: JSValue) bun.JSError!JSC.JSValue {
             if (!seconds.isNumber()) {
-                this.globalThis.throw("timeout() requires a number", .{});
-                return .zero;
+                return this.globalThis.throw("timeout() requires a number", .{});
             }
             const value = seconds.to(c_uint);
             _ = request.request_context.setTimeout(value);
@@ -5892,23 +5800,21 @@ 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) bun.JSError!JSValue {
             if (this.config.websocket == null)
                 return JSValue.jsNumber(0);
 
-            const app = this.app;
+            const app = this.app.?;
 
             if (topic.len == 0) {
                 httplog("publish() topic invalid", .{});
-                exception.* = JSC.createError(globalThis, "publish requires a topic string", .{}).asObjectRef();
-                return .zero;
+                return globalThis.throw("publish requires a topic string", .{});
             }
 
             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();
-                return .zero;
+                return globalThis.throw("publish requires a non-empty topic", .{});
             }
 
             const compress = (compress_value orelse JSValue.jsBoolean(true)).toBoolean();
@@ -5941,20 +5847,17 @@ 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();
+                return globalThis.throwInvalidArguments("To enable websocket support, set the \"websocket\" object in Bun.serve({})", .{});
             }
 
             if (this.flags.terminated) {
                 return JSValue.jsBoolean(false);
             }
 
-            var request = object.as(Request) orelse {
-                JSC.throwInvalidArguments("upgrade requires a Request object", .{}, globalThis, exception);
-                return JSValue.jsUndefined();
+            var request: *Request = object.as(Request) orelse {
+                return globalThis.throwInvalidArguments("upgrade requires a Request object", .{});
             };
 
             var upgrader = request.request_context.get(RequestContext) orelse return JSC.jsBoolean(false);
@@ -6025,8 +5928,7 @@ 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();
+                        return globalThis.throwInvalidArguments("upgrade options must be an object", .{});
                     }
 
                     if (opts.fastGet(globalThis, .data)) |headers_value| {
@@ -6034,7 +5936,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| {
@@ -6052,13 +5954,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);
+                                return 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| {
@@ -6076,7 +5978,7 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
                     }
 
                     if (globalThis.hasException()) {
-                        return JSValue.jsUndefined();
+                        return error.JSError;
                     }
                 }
             }
@@ -6086,9 +5988,9 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
 
             // obviously invalid pointer marks it as used
             upgrader.upgrade_context = @as(*uws.uws_socket_context_s, @ptrFromInt(std.math.maxInt(usize)));
-            // set the abort handler so we can receive onAbort to deref the context
-            upgrader.setAbortHandler();
-            // after upgrading we should not use the response anymore
+            const signal = upgrader.signal;
+
+            upgrader.signal = null;
             upgrader.resp = null;
             request.request_context = AnyRequestContext.Null;
             upgrader.request_weakref.deinit();
@@ -6097,6 +5999,7 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
             const ws = ServerWebSocket.new(.{
                 .handler = &this.config.websocket.?.handler,
                 .this_value = data_value,
+                .signal = signal,
             });
             data_value.ensureStillAlive();
 
@@ -6105,6 +6008,13 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
             var sec_websocket_extensions_str = sec_websocket_extensions.toSlice(bun.default_allocator);
             defer sec_websocket_extensions_str.deinit();
 
+            resp.clearAborted();
+            resp.clearOnData();
+            resp.clearOnWritable();
+            resp.clearTimeout();
+
+            upgrader.deref();
+
             resp.upgrade(
                 *ServerWebSocket,
                 ws,
@@ -6120,7 +6030,7 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
         pub fn onReloadFromZig(this: *ThisServer, new_config: *ServerConfig, globalThis: *JSC.JSGlobalObject) void {
             httplog("onReload", .{});
 
-            this.app.clearRoutes();
+            this.app.?.clearRoutes();
 
             // only reload those two
             if (this.config.onRequest != new_config.onRequest) {
@@ -6153,30 +6063,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 {
-            const arguments = callframe.arguments(1).slice();
+        pub fn onReload(this: *ThisServer, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+            const arguments = callframe.arguments_old(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.fromJS(globalThis, &args_slice, exception);
-            if (exception.* != null) {
-                new_config.deinit();
-                globalThis.throwValue(exception_ref[0].?.value());
-                return .zero;
-            }
+
+            var new_config: ServerConfig = .{};
+            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);
@@ -6188,9 +6088,9 @@ 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();
+            const arguments = callframe.arguments_old(2).slice();
             if (arguments.len == 0) {
                 const fetch_error = WebCore.Fetch.fetch_error_no_args;
                 return JSPromise.rejectedPromiseValue(ctx, ZigString.init(fetch_error).toErrorInstance(ctx));
@@ -6230,22 +6130,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));
@@ -6469,11 +6369,8 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
         }
 
         pub fn getProtocol(this: *ThisServer, globalThis: *JSGlobalObject) JSC.JSValue {
-            if (this.cached_protocol.isEmpty()) {
-                this.cached_protocol = bun.String.createUTF8(if (ssl_enabled) "https" else "http");
-            }
-
-            return this.cached_protocol.toJS(globalThis);
+            _ = this;
+            return bun.String.static(if (ssl_enabled) "https" else "http").toJS(globalThis);
         }
 
         pub fn getDevelopment(
@@ -6569,7 +6466,7 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
                     ws.handler.app = null;
                 }
                 this.flags.terminated = true;
-                this.app.close();
+                this.app.?.close();
             }
         }
 
@@ -6592,7 +6489,7 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
 
             if (!this.flags.terminated) {
                 this.flags.terminated = true;
-                this.app.close();
+                this.app.?.close();
             }
 
             const task = bun.default_allocator.create(JSC.AnyTask) catch unreachable;
@@ -6603,30 +6500,52 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
         pub fn deinit(this: *ThisServer) void {
             httplog("deinit", .{});
             this.cached_hostname.deref();
-            this.cached_protocol.deref();
             this.all_closed_promise.deinit();
 
             this.config.deinit();
-            this.app.destroy();
+            if (this.app) |app| {
+                this.app = null;
+                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 (config.bake) |*bake_options| dev_server: {
+                bun.bake.printWarning();
+
+                break :dev_server try bun.bake.DevServer.init(.{
+                    .arena = bake_options.arena.allocator(),
+                    .root = bake_options.root,
+                    .framework = bake_options.framework,
+                    .bundler_options = bake_options.bundler_options,
+                    .vm = global.bunVM(),
+                });
+            } else null;
+            errdefer if (dev_server) |d| d.deinit();
+
             var server = ThisServer.new(.{
-                .globalThis = globalThis,
-                .config = config,
-                .base_url_string_for_joining = bun.default_allocator.dupe(u8, strings.trim(config.base_url.href, "/")) catch unreachable,
+                .globalThis = global,
+                .config = config.*,
+                .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.?.* = RequestContext.RequestContextStackAllocator.init(
-                    if (comptime bun.heap_breakdown.enabled)
-                        bun.typedAllocator(RequestContext)
-                    else
-                        bun.default_allocator,
+                RequestContext.pool = bun.create(
+                    server.allocator,
+                    RequestContext.RequestContextStackAllocator,
+                    RequestContext.RequestContextStackAllocator.init(bun.typedAllocator(RequestContext)),
                 );
             }
 
@@ -6643,7 +6562,8 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
 
         noinline fn onListenFailed(this: *ThisServer) void {
             httplog("onListenFailed", .{});
-            this.unref();
+
+            const globalThis = this.globalThis;
 
             var error_instance = JSC.JSValue.zero;
             var output_buf: [4096]u8 = undefined;
@@ -6696,7 +6616,7 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
 
                 if (written > 0) {
                     const message = output_buf[0..written];
-                    error_instance = this.globalThis.createErrorInstance("OpenSSL {s}", .{message});
+                    error_instance = globalThis.createErrorInstance("OpenSSL {s}", .{message});
                     BoringSSL.ERR_clear_error();
                 }
             }
@@ -6713,7 +6633,7 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
                                         .message = bun.String.init(std.fmt.bufPrint(&output_buf, "permission denied {s}:{d}", .{ tcp.hostname orelse "0.0.0.0", tcp.port }) catch "Failed to start server"),
                                         .code = bun.String.static("EACCES"),
                                         .syscall = bun.String.static("listen"),
-                                    }).toErrorInstance(this.globalThis);
+                                    }).toErrorInstance(globalThis);
                                     break :error_set;
                                 }
                             }
@@ -6721,7 +6641,7 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
                                 .message = bun.String.init(std.fmt.bufPrint(&output_buf, "Failed to start server. Is port {d} in use?", .{tcp.port}) catch "Failed to start server"),
                                 .code = bun.String.static("EADDRINUSE"),
                                 .syscall = bun.String.static("listen"),
-                            }).toErrorInstance(this.globalThis);
+                            }).toErrorInstance(globalThis);
                         }
                     },
                     .unix => |unix| {
@@ -6731,27 +6651,20 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
                                     .message = bun.String.init(std.fmt.bufPrint(&output_buf, "Failed to listen on unix socket {}", .{bun.fmt.QuotedFormatter{ .text = unix }}) catch "Failed to start server"),
                                     .code = bun.String.static("EADDRINUSE"),
                                     .syscall = bun.String.static("listen"),
-                                }).toErrorInstance(this.globalThis);
+                                }).toErrorInstance(globalThis);
                             },
                             else => |e| {
                                 var sys_err = bun.sys.Error.fromCode(e, .listen);
                                 sys_err.path = unix;
-                                error_instance = sys_err.toJSC(this.globalThis);
+                                error_instance = sys_err.toJSC(globalThis);
                             },
                         }
                     },
                 }
             }
 
-            // store the exception in here
-            // toErrorInstance clones the string
             error_instance.ensureStillAlive();
-            error_instance.protect();
-            this.thisObject = error_instance;
-
-            // reference it in stack memory
-            this.thisObject.ensureStillAlive();
-            return;
+            globalThis.throwValue(error_instance) catch {};
         }
 
         pub fn onListen(this: *ThisServer, socket: ?*App.ListenSocket) void {
@@ -6777,14 +6690,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();
 
@@ -6854,11 +6767,150 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
             this.pending_requests += 1;
         }
 
-        pub fn onRequest(
+        var did_send_idletimeout_warning_once = false;
+        fn onTimeoutForIdleWarn(_: *anyopaque, _: *App.Response) void {
+            if (debug_mode and !did_send_idletimeout_warning_once) {
+                if (!bun.CLI.Command.get().debug.silent) {
+                    did_send_idletimeout_warning_once = true;
+                    Output.prettyErrorln("<r><yellow>[Bun.serve]<r><d>:<r> request timed out after 10 seconds. Pass <d><cyan>`idleTimeout`<r> to configure.", .{});
+                    Output.flush();
+                }
+            }
+        }
+
+        fn shouldAddTimeoutHandlerForWarning(server: *ThisServer) bool {
+            if (comptime debug_mode) {
+                if (!did_send_idletimeout_warning_once and !bun.CLI.Command.get().debug.silent) {
+                    return !server.config.has_idleTimeout;
+                }
+            }
+
+            return false;
+        }
+
+        pub fn onRequest(this: *ThisServer, req: *uws.Request, resp: *App.Response) void {
+            // Track this before we enter JavaScript.
+            var should_deinit_context = false;
+            const prepared = this.prepareJsRequestContext(req, resp, &should_deinit_context) 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();
+            }
+
+            ctx.onResponse(this, prepared.js_request, response_value);
+
+            // Reference in the stack here in case it is not for whatever reason
+            prepared.js_request.ensureStillAlive();
+
+            ctx.defer_deinit_until_callback_completes = null;
+
+            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, null) 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 {
+                // 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.init(resp),
+                };
+            }
+        };
+
+        pub fn prepareJsRequestContext(this: *ThisServer, req: *uws.Request, resp: *App.Response, should_deinit_context: ?*bool) ?PreparedRequest {
             JSC.markBinding(@src());
             this.onPendingRequest();
             if (comptime Environment.isDebug) {
@@ -6872,10 +6924,17 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
             req.setYield(false);
             resp.timeout(this.config.idleTimeout);
 
-            var ctx = this.request_pool_allocator.tryGet() catch bun.outOfMemory();
-            ctx.create(this, req, resp);
+            // Since we do timeouts by default, we should tell the user when
+            // this happens - but limit it to only warn once.
+            if (shouldAddTimeoutHandlerForWarning(this)) {
+                // We need to pass it a pointer, any pointer should do.
+                resp.onTimeout(*anyopaque, onTimeoutForIdleWarn, &did_send_idletimeout_warning_once);
+            }
+
+            const ctx = this.request_pool_allocator.tryGet() catch bun.outOfMemory();
+            ctx.create(this, req, resp, should_deinit_context);
             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);
@@ -6919,7 +6978,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;
@@ -6942,47 +7001,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(
@@ -6996,7 +7020,8 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
             this.pending_requests += 1;
             req.setYield(false);
             var ctx = this.request_pool_allocator.tryGet() catch bun.outOfMemory();
-            ctx.create(this, req, resp);
+            var should_deinit_context = false;
+            ctx.create(this, req, resp, &should_deinit_context);
             var body = this.vm.initRequestBodyValue(.{ .Null = {} }) catch unreachable;
 
             ctx.request_body = body;
@@ -7019,24 +7044,20 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
             };
             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;
+
+            ctx.defer_deinit_until_callback_completes = null;
 
             if (should_deinit_context) {
                 ctx.deinit();
@@ -7052,19 +7073,20 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
         }
 
         fn setRoutes(this: *ThisServer) void {
+            const app = this.app.?;
             if (this.config.static_routes.items.len > 0) {
                 this.config.applyStaticRoutes(
                     ssl_enabled,
                     AnyServer.from(this),
-                    this.app,
+                    app,
                 );
             }
 
             if (this.config.websocket) |*websocket| {
                 websocket.globalObject = this.globalThis;
-                websocket.handler.app = this.app;
+                websocket.handler.app = app;
                 websocket.handler.flags.ssl = ssl_enabled;
-                this.app.ws(
+                app.ws(
                     "/*",
                     this,
                     0,
@@ -7072,63 +7094,121 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
                 );
             }
 
-            this.app.any("/*", *ThisServer, this, onRequest);
-
             if (comptime debug_mode) {
-                this.app.get("/bun:info", *ThisServer, this, onBunInfoRequest);
+                app.get("/bun:info", *ThisServer, this, onBunInfoRequest);
                 if (this.config.inspector) {
                     JSC.markBinding(@src());
-                    Bun__addInspector(ssl_enabled, this.app, this.globalThis);
+                    Bun__addInspector(ssl_enabled, app, this.globalThis);
                 }
 
-                this.app.get("/src:/*", *ThisServer, this, onSrcRequest);
+                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;
+            const globalThis = this.globalThis;
             if (ssl_enabled) {
                 BoringSSL.load();
                 const ssl_config = this.config.ssl_config orelse @panic("Assertion failure: ssl_config");
                 const ssl_options = ssl_config.asUSockets();
-                this.app = App.create(ssl_options);
+
+                app = App.create(ssl_options) orelse {
+                    if (!globalThis.hasException()) {
+                        if (!throwSSLErrorIfNecessary(globalThis)) {
+                            globalThis.throw("Failed to create HTTP server", .{}) catch {};
+                        }
+                    }
+
+                    this.app = null;
+                    this.deinit();
+                    return;
+                };
+
+                this.app = app;
 
                 this.setRoutes();
+
                 // add serverName to the SSL context using default ssl options
-                if (ssl_config.server_name != null) {
-                    const servername_len = std.mem.span(ssl_config.server_name).len;
-                    if (servername_len > 0) {
-                        this.app.addServerNameWithOptions(ssl_config.server_name, ssl_options);
-                        this.app.domain(ssl_config.server_name[0..servername_len :0]);
+                if (ssl_config.server_name) |server_name_ptr| {
+                    const server_name: [:0]const u8 = std.mem.span(server_name_ptr);
+                    if (server_name.len > 0) {
+                        app.addServerNameWithOptions(server_name, ssl_options) catch {
+                            if (!globalThis.hasException()) {
+                                if (!throwSSLErrorIfNecessary(globalThis)) {
+                                    globalThis.throw("Failed to add serverName: {s}", .{server_name}) catch {};
+                                }
+                            }
+
+                            this.deinit();
+                            return;
+                        };
+                        if (throwSSLErrorIfNecessary(globalThis)) {
+                            this.deinit();
+                            return;
+                        }
+
+                        app.domain(server_name);
+                        if (throwSSLErrorIfNecessary(globalThis)) {
+                            this.deinit();
+                            return;
+                        }
+
+                        // Ensure the routes are set for that domain name.
                         this.setRoutes();
                     }
                 }
 
                 // apply SNI routes if any
-                if (this.config.sni) |sni| {
-                    for (sni.slice()) |sni_ssl_config| {
-                        const sni_servername_len = std.mem.span(sni_ssl_config.server_name).len;
-                        if (sni_servername_len > 0) {
-                            this.app.addServerNameWithOptions(sni_ssl_config.server_name, sni_ssl_config.asUSockets());
-                            this.app.domain(sni_ssl_config.server_name[0..sni_servername_len :0]);
+                if (this.config.sni) |*sni| {
+                    for (sni.slice()) |*sni_ssl_config| {
+                        const sni_servername: [:0]const u8 = std.mem.span(sni_ssl_config.server_name);
+                        if (sni_servername.len > 0) {
+                            app.addServerNameWithOptions(sni_servername, sni_ssl_config.asUSockets()) catch {
+                                if (!globalThis.hasException()) {
+                                    if (!throwSSLErrorIfNecessary(globalThis)) {
+                                        globalThis.throw("Failed to add serverName: {s}", .{sni_servername}) catch {};
+                                    }
+                                }
+
+                                this.deinit();
+                                return;
+                            };
+
+                            app.domain(sni_servername);
+
+                            if (throwSSLErrorIfNecessary(globalThis)) {
+                                this.deinit();
+                                return;
+                            }
+
+                            // Ensure the routes are set for that domain name.
                             this.setRoutes();
                         }
                     }
                 }
             } else {
-                this.app = App.create(.{});
+                app = App.create(.{}) orelse {
+                    if (!globalThis.hasException()) {
+                        globalThis.throw("Failed to create HTTP server", .{}) catch {};
+                    }
+                    this.deinit();
+                    return;
+                };
+                this.app = app;
+
                 this.setRoutes();
             }
 
-            this.ref();
-
-            // Starting up an HTTP server is a good time to GC
-            if (this.vm.aggressive_garbage_collection == .aggressive) {
-                this.vm.autoGarbageCollect();
-            } else {
-                this.vm.eventLoop().performGC();
-            }
-
             switch (this.config.address) {
                 .tcp => |tcp| {
                     var host: ?[*:0]const u8 = null;
@@ -7145,27 +7225,60 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
                         }
                     }
 
-                    this.app.listenWithConfig(*ThisServer, this, onListen, .{
+                    app.listenWithConfig(*ThisServer, this, onListen, .{
                         .port = tcp.port,
                         .host = host,
-                        .options = if (this.config.reuse_port) 0 else 1,
+                        // IPV6_ONLY is the default for bun, different from node it also set exclusive port in case reuse port is not set
+                        .options = (if (this.config.reuse_port) uws.LIBUS_SOCKET_REUSE_PORT else uws.LIBUS_LISTEN_EXCLUSIVE_PORT) | uws.LIBUS_SOCKET_IPV6_ONLY,
                     });
                 },
 
                 .unix => |unix| {
-                    this.app.listenOnUnixSocket(
+                    app.listenOnUnixSocket(
                         *ThisServer,
                         this,
                         onListen,
                         unix,
-                        if (this.config.reuse_port) 0 else 1,
+                        // IPV6_ONLY is the default for bun, different from node it also set exclusive port in case reuse port is not set
+                        (if (this.config.reuse_port) uws.LIBUS_SOCKET_REUSE_PORT else uws.LIBUS_LISTEN_EXCLUSIVE_PORT) | uws.LIBUS_SOCKET_IPV6_ONLY,
                     );
                 },
             }
+
+            if (globalThis.hasException()) {
+                this.deinit();
+                return;
+            }
+
+            this.ref();
+
+            // Starting up an HTTP server is a good time to GC
+            if (this.vm.aggressive_garbage_collection == .aggressive) {
+                this.vm.autoGarbageCollect();
+            } else {
+                this.vm.eventLoop().performGC();
+            }
         }
     };
 }
 
+pub const SavedRequest = struct {
+    js_request: JSC.Strong,
+    request: *Request,
+    ctx: AnyRequestContext,
+    response: uws.AnyResponse,
+
+    pub fn deinit(sr: *SavedRequest) void {
+        sr.js_request.deinit();
+        sr.ctx.deref();
+    }
+
+    pub const Union = union(enum) {
+        stack: *uws.Request,
+        saved: bun.JSC.API.SavedRequest,
+    };
+};
+
 pub const ServerAllConnectionsClosedTask = struct {
     globalObject: *JSC.JSGlobalObject,
     promise: JSC.JSPromise.Strong,
@@ -7195,7 +7308,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,
@@ -7209,11 +7322,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)),
         };
     }
 
@@ -7234,6 +7347,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");
 
@@ -7241,19 +7382,16 @@ extern fn Bun__addInspector(bool, *anyopaque, *JSC.JSGlobalObject) void;
 
 const assert = bun.assert;
 
-pub export fn Server__setIdleTimeout(
-    server: JSC.JSValue,
-    seconds: JSC.JSValue,
-    globalThis: *JSC.JSGlobalObject,
-) void {
+pub export fn Server__setIdleTimeout(server: JSC.JSValue, seconds: JSC.JSValue, globalThis: *JSC.JSGlobalObject) void {
+    Server__setIdleTimeout_(server, seconds, globalThis) catch return;
+}
+pub fn Server__setIdleTimeout_(server: JSC.JSValue, seconds: JSC.JSValue, globalThis: *JSC.JSGlobalObject) bun.JSError!void {
     if (!server.isObject()) {
-        globalThis.throw("Failed to set timeout: The 'this' value is not a Server.", .{});
-        return;
+        return globalThis.throw("Failed to set timeout: The 'this' value is not a Server.", .{});
     }
 
     if (!seconds.isNumber()) {
-        globalThis.throw("Failed to set timeout: The provided value is not of type 'number'.", .{});
-        return;
+        return globalThis.throw("Failed to set timeout: The provided value is not of type 'number'.", .{});
     }
     const value = seconds.to(c_uint);
     if (server.as(HTTPServer)) |this| {
@@ -7265,7 +7403,7 @@ pub export fn Server__setIdleTimeout(
     } else if (server.as(DebugHTTPSServer)) |this| {
         this.setIdleTimeout(value);
     } else {
-        globalThis.throw("Failed to set timeout: The 'this' value is not a Server.", .{});
+        return globalThis.throw("Failed to set timeout: The 'this' value is not a Server.", .{});
     }
 }
 
@@ -7274,3 +7412,14 @@ comptime {
         _ = Server__setIdleTimeout;
     }
 }
+
+fn throwSSLErrorIfNecessary(globalThis: *JSC.JSGlobalObject) bool {
+    const err_code = BoringSSL.ERR_get_error();
+    if (err_code != 0) {
+        defer BoringSSL.ERR_clear_error();
+        globalThis.throwValue(JSC.API.Bun.Crypto.createCryptoError(globalThis, err_code)) catch {};
+        return true;
+    }
+
+    return false;
+}
diff --git a/src/bun.js/api/sockets.classes.ts b/src/bun.js/api/sockets.classes.ts
index dc2f4b39c8..75cdc6b733 100644
--- a/src/bun.js/api/sockets.classes.ts
+++ b/src/bun.js/api/sockets.classes.ts
@@ -12,7 +12,14 @@ function generate(ssl) {
         fn: "getAuthorizationError",
         length: 0,
       },
-
+      resume: {
+        fn: "resumeFromJS",
+        length: 0,
+      },
+      pause: {
+        fn: "pauseFromJS",
+        length: 0,
+      },
       getTLSFinishedMessage: {
         fn: "getTLSFinishedMessage",
         length: 0,
@@ -83,6 +90,17 @@ function generate(ssl) {
       alpnProtocol: {
         getter: "getALPNProtocol",
       },
+      bytesWritten: {
+        getter: "getBytesWritten",
+      },
+      setNoDelay: {
+        fn: "setNoDelay",
+        length: 1,
+      },
+      setKeepAlive: {
+        fn: "setKeepAlive",
+        length: 2,
+      },
       write: {
         fn: "write",
         length: 3,
@@ -163,7 +181,9 @@ function generate(ssl) {
         fn: "reload",
         length: 1,
       },
-
+      bytesWritten: {
+        getter: "getBytesWritten",
+      },
       setServername: {
         fn: "setServername",
         length: 1,
@@ -172,6 +192,16 @@ function generate(ssl) {
         fn: "getServername",
         length: 0,
       },
+      "writeBuffered": {
+        fn: "writeBuffered",
+        length: 2,
+        privateSymbol: "write",
+      },
+      "endBuffered": {
+        fn: "endBuffered",
+        length: 2,
+        privateSymbol: "end",
+      },
     },
     finalize: true,
     construct: true,
diff --git a/src/bun.js/api/zlib.classes.ts b/src/bun.js/api/zlib.classes.ts
index 6b55a9f7d1..a89af81e32 100644
--- a/src/bun.js/api/zlib.classes.ts
+++ b/src/bun.js/api/zlib.classes.ts
@@ -2,249 +2,48 @@ import { define } from "../../codegen/class-definitions";
 
 export default [
   define({
-    name: "BrotliEncoder",
+    name: "NativeZlib",
     construct: true,
-    noConstructor: true,
+    noConstructor: false,
+    wantsThis: true,
     finalize: true,
     configurable: false,
-    hasPendingActivity: true,
-    klass: {},
-    JSType: "0b11101110",
-    values: ["callback"],
-    proto: {
-      transform: {
-        fn: "transform",
-        length: 2,
-      },
-      transformSync: {
-        fn: "transformSync",
-        length: 2,
-      },
-      reset: {
-        fn: "reset",
-        length: 0,
-      },
-      bytesWritten: {
-        getter: "getBytesWritten",
-      },
-      bytesRead: {
-        // deprecated
-        value: "bytesWritten",
-      },
-      closed: {
-        getter: "getClosed",
-      },
-      close: {
-        fn: "close",
-        length: 0,
-      },
-      chunkSize: {
-        getter: "getChunkSize",
-      },
-      flush: {
-        getter: "getFlush",
-      },
-      finishFlush: {
-        getter: "getFinishFlush",
-      },
-      fullFlush: {
-        getter: "getFullFlush",
-      },
-      maxOutputLength: {
-        getter: "getMaxOutputLength",
-      },
-    },
-  }),
-  define({
-    name: "BrotliDecoder",
-    construct: true,
-    noConstructor: true,
-    finalize: true,
-    configurable: false,
-    hasPendingActivity: true,
+    // estimatedSize: true,
     klass: {},
     JSType: "0b11101110",
     values: ["callback"],
 
     proto: {
-      transform: {
-        fn: "transform",
-        length: 2,
-      },
-      transformSync: {
-        fn: "transformSync",
-        length: 2,
-      },
-      reset: {
-        fn: "reset",
-        length: 0,
-      },
-      bytesWritten: {
-        getter: "getBytesWritten",
-      },
-      bytesRead: {
-        // deprecated
-        value: "bytesWritten",
-      },
-      closed: {
-        getter: "getClosed",
-      },
-      close: {
-        fn: "close",
-        length: 0,
-      },
-      chunkSize: {
-        getter: "getChunkSize",
-      },
-      flush: {
-        getter: "getFlush",
-      },
-      finishFlush: {
-        getter: "getFinishFlush",
-      },
-      fullFlush: {
-        getter: "getFullFlush",
-      },
-      maxOutputLength: {
-        getter: "getMaxOutputLength",
-      },
+      init: { fn: "init" },
+      write: { fn: "write" },
+      writeSync: { fn: "writeSync" },
+      params: { fn: "params" },
+      reset: { fn: "reset" },
+      close: { fn: "close" },
+      onerror: { setter: "setOnError", getter: "getOnError" },
     },
   }),
+
   define({
-    name: "ZlibEncoder",
+    name: "NativeBrotli",
     construct: true,
-    noConstructor: true,
+    noConstructor: false,
+    wantsThis: true,
     finalize: true,
     configurable: false,
-    hasPendingActivity: true,
-    klass: {},
-    JSType: "0b11101110",
-    values: ["callback"],
-    proto: {
-      transform: {
-        fn: "transform",
-        length: 2,
-      },
-      transformSync: {
-        fn: "transformSync",
-        length: 2,
-      },
-      transformWith: {
-        fn: "transformWith",
-        length: 4,
-      },
-      reset: {
-        fn: "reset",
-        length: 0,
-      },
-      bytesWritten: {
-        getter: "getBytesWritten",
-      },
-      bytesRead: {
-        // deprecated
-        value: "bytesWritten",
-      },
-      level: {
-        getter: "getLevel",
-      },
-      strategy: {
-        getter: "getStrategy",
-      },
-      closed: {
-        getter: "getClosed",
-      },
-      close: {
-        fn: "close",
-        length: 0,
-      },
-      params: {
-        fn: "params",
-        length: 3,
-      },
-      chunkSize: {
-        getter: "getChunkSize",
-      },
-      flush: {
-        getter: "getFlush",
-      },
-      finishFlush: {
-        getter: "getFinishFlush",
-      },
-      fullFlush: {
-        getter: "getFullFlush",
-      },
-      maxOutputLength: {
-        getter: "getMaxOutputLength",
-      },
-    },
-  }),
-  define({
-    name: "ZlibDecoder",
-    construct: true,
-    noConstructor: true,
-    finalize: true,
-    configurable: false,
-    hasPendingActivity: true,
+    estimatedSize: true,
     klass: {},
     JSType: "0b11101110",
     values: ["callback"],
 
     proto: {
-      transform: {
-        fn: "transform",
-        length: 2,
-      },
-      transformSync: {
-        fn: "transformSync",
-        length: 2,
-      },
-      transformWith: {
-        fn: "transformWith",
-        length: 4,
-      },
-      reset: {
-        fn: "reset",
-        length: 0,
-      },
-      bytesWritten: {
-        getter: "getBytesWritten",
-      },
-      bytesRead: {
-        // deprecated
-        value: "bytesWritten",
-      },
-      level: {
-        getter: "getLevel",
-      },
-      strategy: {
-        getter: "getStrategy",
-      },
-      closed: {
-        getter: "getClosed",
-      },
-      close: {
-        fn: "close",
-        length: 0,
-      },
-      params: {
-        fn: "params",
-        length: 3,
-      },
-      chunkSize: {
-        getter: "getChunkSize",
-      },
-      flush: {
-        getter: "getFlush",
-      },
-      finishFlush: {
-        getter: "getFinishFlush",
-      },
-      fullFlush: {
-        getter: "getFullFlush",
-      },
-      maxOutputLength: {
-        getter: "getMaxOutputLength",
-      },
+      init: { fn: "init" },
+      write: { fn: "write" },
+      writeSync: { fn: "writeSync" },
+      params: { fn: "params" },
+      reset: { fn: "reset" },
+      close: { fn: "close" },
+      onerror: { setter: "setOnError", getter: "getOnError" },
     },
   }),
 ];
diff --git a/src/bun.js/base.zig b/src/bun.js/base.zig
index 94b2e07c14..3c010ea1b4 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(
@@ -279,8 +279,7 @@ pub const ArrayBuffer = extern struct {
                     }
                 },
                 .err => |err| {
-                    globalObject.throwValue(err.toJSC(globalObject));
-                    return .zero;
+                    return globalObject.throwValue(err.toJSC(globalObject)) catch .zero;
                 },
             }
         }
@@ -293,12 +292,11 @@ pub const ArrayBuffer = extern struct {
     extern fn ArrayBuffer__fromSharedMemfd(fd: i64, globalObject: *JSC.JSGlobalObject, byte_offset: usize, byte_length: usize, total_size: usize, JSC.JSValue.JSType) JSC.JSValue;
     pub const toArrayBufferFromSharedMemfd = ArrayBuffer__fromSharedMemfd;
 
-    pub fn toJSBufferFromMemfd(fd: bun.FileDescriptor, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
+    pub fn toJSBufferFromMemfd(fd: bun.FileDescriptor, globalObject: *JSC.JSGlobalObject) bun.JSError!JSC.JSValue {
         const stat = switch (bun.sys.fstat(fd)) {
             .err => |err| {
-                globalObject.throwValue(err.toJSC(globalObject));
                 _ = bun.sys.close(fd);
-                return .zero;
+                return globalObject.throwValue(err.toJSC(globalObject));
             },
             .result => |fstat| fstat,
         };
@@ -335,9 +333,7 @@ pub const ArrayBuffer = extern struct {
                 return JSBuffer__fromMmap(globalObject, buf.ptr, buf.len);
             },
             .err => |err| {
-                globalObject.throwValue(err.toJSC(globalObject));
-
-                return .zero;
+                return globalObject.throwValue(err.toJSC(globalObject));
             },
         }
     }
@@ -413,7 +409,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 +476,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 +516,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;
         }
 
@@ -553,7 +550,7 @@ pub const ArrayBuffer = extern struct {
     ///    new ArrayBuffer(view.buffer, view.byteOffset, view.byteLength)
     /// ```
     pub inline fn byteSlice(this: *const @This()) []u8 {
-        return this.ptr[this.offset .. this.offset + this.byte_len];
+        return this.ptr[this.offset..][0..this.byte_len];
     }
 
     /// The equivalent of
@@ -564,15 +561,15 @@ pub const ArrayBuffer = extern struct {
     pub const slice = byteSlice;
 
     pub inline fn asU16(this: *const @This()) []u16 {
-        return std.mem.bytesAsSlice(u16, @as([*]u16, @alignCast(this.ptr))[this.offset..this.byte_len]);
+        return std.mem.bytesAsSlice(u16, @as([*]u16, @ptrCast(@alignCast(this.ptr)))[this.offset..this.byte_len]);
     }
 
     pub inline fn asU16Unaligned(this: *const @This()) []align(1) u16 {
-        return std.mem.bytesAsSlice(u16, @as([*]align(1) u16, @alignCast(this.ptr))[this.offset..this.byte_len]);
+        return std.mem.bytesAsSlice(u16, @as([*]align(1) u16, @ptrCast(@alignCast(this.ptr)))[this.offset..this.byte_len]);
     }
 
     pub inline fn asU32(this: *const @This()) []u32 {
-        return std.mem.bytesAsSlice(u32, @as([*]u32, @alignCast(this.ptr))[this.offset..this.byte_len]);
+        return std.mem.bytesAsSlice(u32, @as([*]u32, @ptrCast(@alignCast(this.ptr)))[this.offset..this.byte_len]);
     }
 };
 
@@ -605,7 +602,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 };
     }
@@ -677,8 +674,7 @@ pub const MarkedArrayBuffer = struct {
         const obj = this.toJSObjectRef(globalObject, &exception);
 
         if (exception[0] != null) {
-            globalObject.throwValue(JSC.JSValue.c(exception[0]));
-            return .zero;
+            return globalObject.throwValue(JSC.JSValue.c(exception[0])) catch return .zero;
         }
 
         return JSC.JSValue.c(obj);
@@ -877,7 +873,7 @@ pub const DOMEffect = struct {
         JSMapFields,
         JSSetFields,
         JSWeakMapFields,
-        JSWeakSetFields,
+        WeakSetFields,
         JSInternalFields,
         InternalState,
         CatchLocals,
@@ -956,11 +952,7 @@ pub fn DOMCall(
             arguments_ptr: [*]const JSC.JSValue,
             arguments_len: usize,
         ) callconv(JSC.conv) JSValue {
-            return @field(Container, functionName)(
-                globalObject,
-                thisValue,
-                arguments_ptr[0..arguments_len],
-            );
+            return JSC.toJSHostValue(globalObject, @field(Container, functionName)(globalObject, thisValue, arguments_ptr[0..arguments_len]));
         }
 
         pub const fastpath = @field(Container, functionName ++ "WithoutTypeChecks");
@@ -979,16 +971,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,8 +995,8 @@ pub fn wrapInstanceMethod(
             this: *Container,
             globalThis: *JSC.JSGlobalObject,
             callframe: *JSC.CallFrame,
-        ) callconv(JSC.conv) JSC.JSValue {
-            const arguments = callframe.arguments(FunctionTypeInfo.params.len);
+        ) bun.JSError!JSC.JSValue {
+            const arguments = callframe.arguments_old(FunctionTypeInfo.params.len);
             var iter = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments.slice());
             var args: Args = undefined;
 
@@ -1030,30 +1019,27 @@ pub fn wrapInstanceMethod(
                         args[i] = this;
                     },
                     *JSC.JSGlobalObject => {
-                        args[i] = globalThis.ptr();
+                        args[i] = globalThis;
                     },
                     *JSC.CallFrame => {
                         args[i] = callframe;
                     },
                     JSC.Node.StringOrBuffer => {
                         const arg = iter.nextEat() orelse {
-                            globalThis.throwInvalidArguments("expected string or buffer", .{});
                             iter.deinit();
-                            return JSC.JSValue.zero;
+                            return globalThis.throwInvalidArguments("expected string or buffer", .{});
                         };
-                        args[i] = JSC.Node.StringOrBuffer.fromJS(globalThis.ptr(), iter.arena.allocator(), arg) orelse {
-                            globalThis.throwInvalidArguments("expected string or buffer", .{});
+                        args[i] = JSC.Node.StringOrBuffer.fromJS(globalThis, iter.arena.allocator(), arg) orelse {
                             iter.deinit();
-                            return JSC.JSValue.zero;
+                            return globalThis.throwInvalidArguments("expected string or buffer", .{});
                         };
                     },
                     ?JSC.Node.StringOrBuffer => {
                         if (iter.nextEat()) |arg| {
                             if (!arg.isEmptyOrUndefinedOrNull()) {
-                                args[i] = JSC.Node.StringOrBuffer.fromJS(globalThis.ptr(), iter.arena.allocator(), arg) orelse {
-                                    globalThis.throwInvalidArguments("expected string or buffer", .{});
+                                args[i] = JSC.Node.StringOrBuffer.fromJS(globalThis, iter.arena.allocator(), arg) orelse {
                                     iter.deinit();
-                                    return JSC.JSValue.zero;
+                                    return globalThis.throwInvalidArguments("expected string or buffer", .{});
                                 };
                             } else {
                                 args[i] = null;
@@ -1064,23 +1050,20 @@ pub fn wrapInstanceMethod(
                     },
                     JSC.ArrayBuffer => {
                         if (iter.nextEat()) |arg| {
-                            args[i] = arg.asArrayBuffer(globalThis.ptr()) orelse {
-                                globalThis.throwInvalidArguments("expected TypedArray", .{});
+                            args[i] = arg.asArrayBuffer(globalThis) orelse {
                                 iter.deinit();
-                                return JSC.JSValue.zero;
+                                return globalThis.throwInvalidArguments("expected TypedArray", .{});
                             };
                         } else {
-                            globalThis.throwInvalidArguments("expected TypedArray", .{});
                             iter.deinit();
-                            return JSC.JSValue.zero;
+                            return globalThis.throwInvalidArguments("expected TypedArray", .{});
                         }
                     },
                     ?JSC.ArrayBuffer => {
                         if (iter.nextEat()) |arg| {
-                            args[i] = arg.asArrayBuffer(globalThis.ptr()) orelse {
-                                globalThis.throwInvalidArguments("expected TypedArray", .{});
+                            args[i] = arg.asArrayBuffer(globalThis) orelse {
                                 iter.deinit();
-                                return JSC.JSValue.zero;
+                                return globalThis.throwInvalidArguments("expected TypedArray", .{});
                             };
                         } else {
                             args[i] = null;
@@ -1088,22 +1071,20 @@ pub fn wrapInstanceMethod(
                     },
                     ZigString => {
                         var string_value = eater(&iter) orelse {
-                            globalThis.throwInvalidArguments("Missing argument", .{});
                             iter.deinit();
-                            return JSC.JSValue.zero;
+                            return globalThis.throwInvalidArguments("Missing argument", .{});
                         };
 
                         if (string_value.isUndefinedOrNull()) {
-                            globalThis.throwInvalidArguments("Expected string", .{});
                             iter.deinit();
-                            return JSC.JSValue.zero;
+                            return globalThis.throwInvalidArguments("Expected string", .{});
                         }
 
-                        args[i] = string_value.getZigString(globalThis.ptr());
+                        args[i] = string_value.getZigString(globalThis);
                     },
                     ?JSC.Cloudflare.ContentOptions => {
                         if (iter.nextEat()) |content_arg| {
-                            if (content_arg.getOwn(globalThis.ptr(), "html")) |html_val| {
+                            if (try content_arg.get(globalThis, "html")) |html_val| {
                                 args[i] = .{ .html = html_val.toBoolean() };
                             }
                         } else {
@@ -1112,31 +1093,26 @@ pub fn wrapInstanceMethod(
                     },
                     *Response => {
                         args[i] = (eater(&iter) orelse {
-                            globalThis.throwInvalidArguments("Missing Response object", .{});
                             iter.deinit();
-                            return JSC.JSValue.zero;
+                            return globalThis.throwInvalidArguments("Missing Response object", .{});
                         }).as(Response) orelse {
-                            globalThis.throwInvalidArguments("Expected Response object", .{});
                             iter.deinit();
-                            return JSC.JSValue.zero;
+                            return globalThis.throwInvalidArguments("Expected Response object", .{});
                         };
                     },
                     *Request => {
                         args[i] = (eater(&iter) orelse {
-                            globalThis.throwInvalidArguments("Missing Request object", .{});
                             iter.deinit();
-                            return JSC.JSValue.zero;
+                            return globalThis.throwInvalidArguments("Missing Request object", .{});
                         }).as(Request) orelse {
-                            globalThis.throwInvalidArguments("Expected Request object", .{});
                             iter.deinit();
-                            return JSC.JSValue.zero;
+                            return globalThis.throwInvalidArguments("Expected Request object", .{});
                         };
                     },
                     JSValue => {
                         const val = eater(&iter) orelse {
-                            globalThis.throwInvalidArguments("Missing argument", .{});
                             iter.deinit();
-                            return JSC.JSValue.zero;
+                            return globalThis.throwInvalidArguments("Missing argument", .{});
                         };
                         args[i] = val;
                     },
@@ -1169,7 +1145,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,8 +1155,8 @@ pub fn wrapStaticMethod(
         pub fn method(
             globalThis: *JSC.JSGlobalObject,
             callframe: *JSC.CallFrame,
-        ) callconv(JSC.conv) JSC.JSValue {
-            const arguments = callframe.arguments(FunctionTypeInfo.params.len);
+        ) bun.JSError!JSC.JSValue {
+            const arguments = callframe.arguments_old(FunctionTypeInfo.params.len);
             var iter = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments.slice());
             var args: Args = undefined;
 
@@ -1188,26 +1164,27 @@ 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 {
-                            globalThis.throwInvalidArguments("expected string or buffer", .{});
                             iter.deinit();
-                            return JSC.JSValue.zero;
+                            return globalThis.throwInvalidArguments("expected string or buffer", .{});
                         };
-                        args[i] = JSC.Node.StringOrBuffer.fromJS(globalThis.ptr(), iter.arena.allocator(), arg) orelse {
-                            globalThis.throwInvalidArguments("expected string or buffer", .{});
+                        args[i] = JSC.Node.StringOrBuffer.fromJS(globalThis, iter.arena.allocator(), arg) orelse {
                             iter.deinit();
-                            return JSC.JSValue.zero;
+                            return globalThis.throwInvalidArguments("expected string or buffer", .{});
                         };
                     },
                     ?JSC.Node.StringOrBuffer => {
                         if (iter.nextEat()) |arg| {
-                            args[i] = JSC.Node.StringOrBuffer.fromJS(globalThis.ptr(), iter.arena.allocator(), arg) orelse {
-                                globalThis.throwInvalidArguments("expected string or buffer", .{});
+                            args[i] = JSC.Node.StringOrBuffer.fromJS(globalThis, iter.arena.allocator(), arg) orelse brk: {
+                                if (arg == .undefined) {
+                                    break :brk null;
+                                }
+
                                 iter.deinit();
-                                return JSC.JSValue.zero;
+                                return globalThis.throwInvalidArguments("expected string or buffer", .{});
                             };
                         } else {
                             args[i] = null;
@@ -1215,36 +1192,31 @@ pub fn wrapStaticMethod(
                     },
                     JSC.Node.BlobOrStringOrBuffer => {
                         if (iter.nextEat()) |arg| {
-                            args[i] = JSC.Node.BlobOrStringOrBuffer.fromJS(globalThis.ptr(), iter.arena.allocator(), arg) orelse {
-                                globalThis.throwInvalidArguments("expected blob, string or buffer", .{});
+                            args[i] = JSC.Node.BlobOrStringOrBuffer.fromJS(globalThis, iter.arena.allocator(), arg) orelse {
                                 iter.deinit();
-                                return JSC.JSValue.zero;
+                                return globalThis.throwInvalidArguments("expected blob, string or buffer", .{});
                             };
                         } else {
-                            globalThis.throwInvalidArguments("expected blob, string or buffer", .{});
                             iter.deinit();
-                            return JSC.JSValue.zero;
+                            return globalThis.throwInvalidArguments("expected blob, string or buffer", .{});
                         }
                     },
                     JSC.ArrayBuffer => {
                         if (iter.nextEat()) |arg| {
-                            args[i] = arg.asArrayBuffer(globalThis.ptr()) orelse {
-                                globalThis.throwInvalidArguments("expected TypedArray", .{});
+                            args[i] = arg.asArrayBuffer(globalThis) orelse {
                                 iter.deinit();
-                                return JSC.JSValue.zero;
+                                return globalThis.throwInvalidArguments("expected TypedArray", .{});
                             };
                         } else {
-                            globalThis.throwInvalidArguments("expected TypedArray", .{});
                             iter.deinit();
-                            return JSC.JSValue.zero;
+                            return globalThis.throwInvalidArguments("expected TypedArray", .{});
                         }
                     },
                     ?JSC.ArrayBuffer => {
                         if (iter.nextEat()) |arg| {
-                            args[i] = arg.asArrayBuffer(globalThis.ptr()) orelse {
-                                globalThis.throwInvalidArguments("expected TypedArray", .{});
+                            args[i] = arg.asArrayBuffer(globalThis) orelse {
                                 iter.deinit();
-                                return JSC.JSValue.zero;
+                                return globalThis.throwInvalidArguments("expected TypedArray", .{});
                             };
                         } else {
                             args[i] = null;
@@ -1252,22 +1224,20 @@ pub fn wrapStaticMethod(
                     },
                     ZigString => {
                         var string_value = eater(&iter) orelse {
-                            globalThis.throwInvalidArguments("Missing argument", .{});
                             iter.deinit();
-                            return JSC.JSValue.zero;
+                            return globalThis.throwInvalidArguments("Missing argument", .{});
                         };
 
                         if (string_value.isUndefinedOrNull()) {
-                            globalThis.throwInvalidArguments("Expected string", .{});
                             iter.deinit();
-                            return JSC.JSValue.zero;
+                            return globalThis.throwInvalidArguments("Expected string", .{});
                         }
 
-                        args[i] = string_value.getZigString(globalThis.ptr());
+                        args[i] = string_value.getZigString(globalThis);
                     },
                     ?JSC.Cloudflare.ContentOptions => {
                         if (iter.nextEat()) |content_arg| {
-                            if (content_arg.getOwn(globalThis.ptr(), "html")) |html_val| {
+                            if (try content_arg.get(globalThis, "html")) |html_val| {
                                 args[i] = .{ .html = html_val.toBoolean() };
                             }
                         } else {
@@ -1276,31 +1246,26 @@ pub fn wrapStaticMethod(
                     },
                     *Response => {
                         args[i] = (eater(&iter) orelse {
-                            globalThis.throwInvalidArguments("Missing Response object", .{});
                             iter.deinit();
-                            return JSC.JSValue.zero;
+                            return globalThis.throwInvalidArguments("Missing Response object", .{});
                         }).as(Response) orelse {
-                            globalThis.throwInvalidArguments("Expected Response object", .{});
                             iter.deinit();
-                            return JSC.JSValue.zero;
+                            return globalThis.throwInvalidArguments("Expected Response object", .{});
                         };
                     },
                     *Request => {
                         args[i] = (eater(&iter) orelse {
-                            globalThis.throwInvalidArguments("Missing Request object", .{});
                             iter.deinit();
-                            return JSC.JSValue.zero;
+                            return globalThis.throwInvalidArguments("Missing Request object", .{});
                         }).as(Request) orelse {
-                            globalThis.throwInvalidArguments("Expected Request object", .{});
                             iter.deinit();
-                            return JSC.JSValue.zero;
+                            return globalThis.throwInvalidArguments("Expected Request object", .{});
                         };
                     },
                     JSValue => {
                         const val = eater(&iter) orelse {
-                            globalThis.throwInvalidArguments("Missing argument", .{});
                             iter.deinit();
-                            return JSC.JSValue.zero;
+                            return globalThis.throwInvalidArguments("Missing argument", .{});
                         };
                         args[i] = val;
                     },
@@ -1415,9 +1380,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/Base64Helpers.cpp b/src/bun.js/bindings/Base64Helpers.cpp
index ac99cf78e8..1e13730f47 100644
--- a/src/bun.js/bindings/Base64Helpers.cpp
+++ b/src/bun.js/bindings/Base64Helpers.cpp
@@ -50,4 +50,4 @@ ExceptionOr<String> atob(const String& encodedString)
     return outString;
 }
 }
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/BufferEncodingType.h b/src/bun.js/bindings/BufferEncodingType.h
index 0d50587126..6d3e93274c 100644
--- a/src/bun.js/bindings/BufferEncodingType.h
+++ b/src/bun.js/bindings/BufferEncodingType.h
@@ -17,4 +17,4 @@ enum class BufferEncodingType {
 
 };
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/BunClientData.cpp b/src/bun.js/bindings/BunClientData.cpp
index ee48afd07f..f8734725e4 100644
--- a/src/bun.js/bindings/BunClientData.cpp
+++ b/src/bun.js/bindings/BunClientData.cpp
@@ -94,4 +94,4 @@ void JSVMClientData::create(VM* vm, void* bunVM)
     clientData->builtinFunctions().exportNames();
 }
 
-} // namespace WebCore
\ No newline at end of file
+} // namespace WebCore
diff --git a/src/bun.js/bindings/BunClientData.h b/src/bun.js/bindings/BunClientData.h
index 5b28bb5801..c4b7f5745a 100644
--- a/src/bun.js/bindings/BunClientData.h
+++ b/src/bun.js/bindings/BunClientData.h
@@ -199,4 +199,4 @@ namespace WebCore {
 using JSVMClientData = WebCore::JSVMClientData;
 using JSHeapData = WebCore::JSHeapData;
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/BunCommonStrings.cpp b/src/bun.js/bindings/BunCommonStrings.cpp
index 0d93179cf6..c0327ca6e7 100644
--- a/src/bun.js/bindings/BunCommonStrings.cpp
+++ b/src/bun.js/bindings/BunCommonStrings.cpp
@@ -36,4 +36,4 @@ void CommonStrings::visit(Visitor& visitor)
 template void CommonStrings::visit(JSC::AbstractSlotVisitor&);
 template void CommonStrings::visit(JSC::SlotVisitor&);
 
-} // namespace Bun
\ No newline at end of file
+} // namespace Bun
diff --git a/src/bun.js/bindings/BunDebugger.cpp b/src/bun.js/bindings/BunDebugger.cpp
index be9ff69b69..73ac12f028 100644
--- a/src/bun.js/bindings/BunDebugger.cpp
+++ b/src/bun.js/bindings/BunDebugger.cpp
@@ -12,6 +12,9 @@
 #include "BunInjectedScriptHost.h"
 #include <JavaScriptCore/JSGlobalObjectInspectorController.h>
 
+#include "InspectorLifecycleAgent.h"
+#include "InspectorTestReporterAgent.h"
+
 extern "C" void Bun__tickWhilePaused(bool*);
 extern "C" void Bun__eventLoop__incrementRefConcurrently(void* bunVM, int delta);
 
@@ -41,15 +44,16 @@ public:
     {
     }
 
+    static Ref<BunJSGlobalObjectDebuggable> create(JSGlobalObject& globalObject)
+    {
+        return adoptRef(*new BunJSGlobalObjectDebuggable(globalObject));
+    }
+
     void pauseWaitingForAutomaticInspection() override
     {
     }
     void unpauseForInitializedInspector() override
     {
-        if (waitingForConnection) {
-            waitingForConnection = false;
-            Debugger__didConnect();
-        }
     }
 };
 
@@ -95,6 +99,18 @@ public:
         globalObject->setInspectable(true);
         auto& inspector = globalObject->inspectorDebuggable();
         inspector.setInspectable(true);
+
+        static bool hasConnected = false;
+
+        if (!hasConnected) {
+            hasConnected = true;
+            globalObject->inspectorController().registerAlternateAgent(
+                WTF::makeUnique<Inspector::InspectorLifecycleAgent>(*globalObject));
+            globalObject->inspectorController().registerAlternateAgent(
+                WTF::makeUnique<Inspector::InspectorTestReporterAgent>(*globalObject));
+        }
+
+        this->hasEverConnected = true;
         globalObject->inspectorController().connectFrontend(*this, true, false); // waitingForConnection
 
         Inspector::JSGlobalObjectDebugger* debugger = reinterpret_cast<Inspector::JSGlobalObjectDebugger*>(globalObject->debugger());
@@ -104,6 +120,11 @@ public:
             };
         }
 
+        if (waitingForConnection) {
+            waitingForConnection = false;
+            Debugger__didConnect();
+        }
+
         this->receiveMessagesOnInspectorThread(context, reinterpret_cast<Zig::GlobalObject*>(globalObject), false);
     }
 
@@ -132,6 +153,11 @@ public:
                 break;
             }
             }
+
+            if (waitingForConnection) {
+                waitingForConnection = false;
+                Debugger__didConnect();
+            }
         });
     }
 
@@ -154,7 +180,12 @@ public:
                 return;
 
             connection->status = ConnectionStatus::Disconnected;
-            connection->inspector().disconnect(*connection);
+
+            // Do not call .disconnect() if we never actually connected.
+            if (connection->hasEverConnected) {
+                connection->inspector().disconnect(*connection);
+            }
+
             if (connection->unrefOnDisconnect) {
                 connection->unrefOnDisconnect = false;
                 Bun__eventLoop__incrementRefConcurrently(reinterpret_cast<Zig::GlobalObject*>(context.jsGlobalObject())->bunVM(), -1);
@@ -308,6 +339,22 @@ public:
         }
     }
 
+    void sendMessageToInspectorFromDebuggerThread(Vector<WTF::String, 12>&& inputMessages)
+    {
+        {
+            Locker<Lock> locker(jsThreadMessagesLock);
+            jsThreadMessages.appendVector(inputMessages);
+        }
+
+        if (this->jsWaitForMessageFromInspectorLock.isLocked()) {
+            this->jsWaitForMessageFromInspectorLock.unlock();
+        } else if (this->jsThreadMessageScheduledCount++ == 0) {
+            ScriptExecutionContext::postTaskTo(scriptExecutionContextIdentifier, [connection = this](ScriptExecutionContext& context) {
+                connection->receiveMessagesOnInspectorThread(context, reinterpret_cast<Zig::GlobalObject*>(context.jsGlobalObject()), true);
+            });
+        }
+    }
+
     void sendMessageToInspectorFromDebuggerThread(const WTF::String& inputMessage)
     {
         {
@@ -340,6 +387,8 @@ public:
     std::atomic<ConnectionStatus> status = ConnectionStatus::Pending;
 
     bool unrefOnDisconnect = false;
+
+    bool hasEverConnected = false;
 };
 
 JSC_DECLARE_HOST_FUNCTION(jsFunctionSend);
@@ -399,12 +448,22 @@ private:
 JSC_DEFINE_HOST_FUNCTION(jsFunctionSend, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
 {
     auto* jsConnection = jsDynamicCast<JSBunInspectorConnection*>(callFrame->thisValue());
-    auto message = callFrame->uncheckedArgument(0).toWTFString(globalObject).isolatedCopy();
+    auto message = callFrame->uncheckedArgument(0);
 
     if (!jsConnection)
         return JSValue::encode(jsUndefined());
 
-    jsConnection->connection()->sendMessageToInspectorFromDebuggerThread(message);
+    if (message.isString()) {
+        jsConnection->connection()->sendMessageToInspectorFromDebuggerThread(message.toWTFString(globalObject).isolatedCopy());
+    } else if (message.isCell()) {
+        auto* array = jsCast<JSArray*>(message.asCell());
+        Vector<WTF::String, 12> messages;
+        JSC::forEachInArrayLike(globalObject, array, [&](JSC::JSValue value) -> bool {
+            messages.append(value.toWTFString(globalObject).isolatedCopy());
+            return true;
+        });
+        jsConnection->connection()->sendMessageToInspectorFromDebuggerThread(WTFMove(messages));
+    }
 
     return JSValue::encode(jsUndefined());
 }
@@ -449,7 +508,8 @@ extern "C" void Bun__ensureDebugger(ScriptExecutionContextIdentifier scriptId, b
 
     auto* globalObject = ScriptExecutionContext::getScriptExecutionContext(scriptId)->jsGlobalObject();
     globalObject->m_inspectorController = makeUnique<Inspector::JSGlobalObjectInspectorController>(*globalObject, Bun::BunInjectedScriptHost::create());
-    globalObject->m_inspectorDebuggable = makeUnique<BunJSGlobalObjectDebuggable>(*globalObject);
+    globalObject->m_inspectorDebuggable = BunJSGlobalObjectDebuggable::create(*globalObject);
+    globalObject->m_inspectorDebuggable->init();
 
     globalObject->setInspectable(true);
 
@@ -513,12 +573,15 @@ JSC_DEFINE_HOST_FUNCTION(jsFunctionCreateConnection, (JSGlobalObject * globalObj
     return JSValue::encode(JSBunInspectorConnection::create(vm, JSBunInspectorConnection::createStructure(vm, globalObject, globalObject->objectPrototype()), connection));
 }
 
-extern "C" void Bun__startJSDebuggerThread(Zig::GlobalObject* debuggerGlobalObject, ScriptExecutionContextIdentifier scriptId, BunString* portOrPathString)
+extern "C" void Bun__startJSDebuggerThread(Zig::GlobalObject* debuggerGlobalObject, ScriptExecutionContextIdentifier scriptId, BunString* portOrPathString, int isAutomatic, bool isUrlServer)
 {
     if (!debuggerScriptExecutionContext)
         debuggerScriptExecutionContext = debuggerGlobalObject->scriptExecutionContext();
+
     JSC::VM& vm = debuggerGlobalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
     JSValue defaultValue = debuggerGlobalObject->internalModuleRegistry()->requireId(debuggerGlobalObject, vm, InternalModuleRegistry::Field::InternalDebugger);
+    scope.assertNoException();
     JSFunction* debuggerDefaultFn = jsCast<JSFunction*>(defaultValue.asCell());
 
     MarkedArgumentBuffer arguments;
@@ -528,8 +591,11 @@ extern "C" void Bun__startJSDebuggerThread(Zig::GlobalObject* debuggerGlobalObje
     arguments.append(JSFunction::create(vm, debuggerGlobalObject, 3, String(), jsFunctionCreateConnection, ImplementationVisibility::Public));
     arguments.append(JSFunction::create(vm, debuggerGlobalObject, 1, String("send"_s), jsFunctionSend, ImplementationVisibility::Public));
     arguments.append(JSFunction::create(vm, debuggerGlobalObject, 0, String("disconnect"_s), jsFunctionDisconnect, ImplementationVisibility::Public));
+    arguments.append(jsBoolean(isAutomatic));
+    arguments.append(jsBoolean(isUrlServer));
 
     JSC::call(debuggerGlobalObject, debuggerDefaultFn, arguments, "Bun__initJSDebuggerThread - debuggerDefaultFn"_s);
+    scope.assertNoException();
 }
 
 enum class AsyncCallTypeUint8 : uint8_t {
diff --git a/src/bun.js/bindings/BunHttp2CommonStrings.cpp b/src/bun.js/bindings/BunHttp2CommonStrings.cpp
new file mode 100644
index 0000000000..e1eba23d6a
--- /dev/null
+++ b/src/bun.js/bindings/BunHttp2CommonStrings.cpp
@@ -0,0 +1,37 @@
+#include "root.h"
+#include "BunHttp2CommonStrings.h"
+#include <JavaScriptCore/JSString.h>
+#include <JavaScriptCore/JSGlobalObject.h>
+#include <JavaScriptCore/LazyProperty.h>
+#include <JavaScriptCore/LazyPropertyInlines.h>
+#include "ZigGlobalObject.h"
+#include <JavaScriptCore/SlotVisitorInlines.h>
+#include <JavaScriptCore/VMTrapsInlines.h>
+
+namespace Bun {
+using namespace JSC;
+
+#define HTTP2_COMMON_STRINGS_LAZY_PROPERTY_DEFINITION(jsName, key, value, idx)     \
+    this->m_names[idx].initLater(                                                  \
+        [](const JSC::LazyProperty<JSGlobalObject, JSString>::Initializer& init) { \
+            init.set(jsOwnedString(init.vm, key));                                 \
+        });
+
+#define HTTP2_COMMON_STRINGS_LAZY_PROPERTY_VISITOR(name, key, value, idx) \
+    this->m_names[idx].visit(visitor);
+
+void Http2CommonStrings::initialize()
+{
+    HTTP2_COMMON_STRINGS_EACH_NAME(HTTP2_COMMON_STRINGS_LAZY_PROPERTY_DEFINITION)
+}
+
+template<typename Visitor>
+void Http2CommonStrings::visit(Visitor& visitor)
+{
+    HTTP2_COMMON_STRINGS_EACH_NAME(HTTP2_COMMON_STRINGS_LAZY_PROPERTY_VISITOR)
+}
+
+template void Http2CommonStrings::visit(JSC::AbstractSlotVisitor&);
+template void Http2CommonStrings::visit(JSC::SlotVisitor&);
+
+} // namespace Bun
diff --git a/src/bun.js/bindings/BunHttp2CommonStrings.h b/src/bun.js/bindings/BunHttp2CommonStrings.h
new file mode 100644
index 0000000000..209cc4ffdf
--- /dev/null
+++ b/src/bun.js/bindings/BunHttp2CommonStrings.h
@@ -0,0 +1,107 @@
+#pragma once
+
+// clang-format off
+
+#define HTTP2_COMMON_STRINGS_EACH_NAME(macro) \
+   macro(authority, ":authority"_s, ""_s, 0) \
+macro(methodGet, ":method"_s, "GET"_s, 1) \
+macro(methodPost, ":method"_s, "POST"_s, 2) \
+macro(pathRoot, ":path"_s, "/"_s, 3) \
+macro(pathIndex, ":path"_s, "/index.html"_s, 4) \
+macro(schemeHttp, ":scheme"_s, "http"_s, 5) \
+macro(schemeHttps, ":scheme"_s, "https"_s, 6) \
+macro(status200, ":status"_s, "200"_s, 7) \
+macro(status204, ":status"_s, "204"_s, 8) \
+macro(status206, ":status"_s, "206"_s, 9) \
+macro(status304, ":status"_s, "304"_s, 10) \
+macro(status400, ":status"_s, "400"_s, 11) \
+macro(status404, ":status"_s, "404"_s, 12) \
+macro(status500, ":status"_s, "500"_s, 13) \
+macro(acceptCharset, "accept-charset"_s, ""_s, 14) \
+macro(acceptEncoding, "accept-encoding"_s, "gzip, deflate"_s, 15) \
+macro(acceptLanguage, "accept-language"_s, ""_s, 16) \
+macro(acceptRanges, "accept-ranges"_s, ""_s, 17) \
+macro(accept, "accept"_s, ""_s, 18) \
+macro(accessControlAllowOrigin, "access-control-allow-origin"_s, ""_s, 19) \
+macro(age, "age"_s, ""_s, 20) \
+macro(allow, "allow"_s, ""_s, 21) \
+macro(authorization, "authorization"_s, ""_s, 22) \
+macro(cacheControl, "cache-control"_s, ""_s, 23) \
+macro(contentDisposition, "content-disposition"_s, ""_s, 24) \
+macro(contentEncoding, "content-encoding"_s, ""_s, 25) \
+macro(contentLanguage, "content-language"_s, ""_s, 26) \
+macro(contentLength, "content-length"_s, ""_s, 27) \
+macro(contentLocation, "content-location"_s, ""_s, 28) \
+macro(contentRange, "content-range"_s, ""_s, 29) \
+macro(contentType, "content-type"_s, ""_s, 30) \
+macro(cookie, "cookie"_s, ""_s, 31) \
+macro(date, "date"_s, ""_s, 32) \
+macro(etag, "etag"_s, ""_s, 33) \
+macro(expect, "expect"_s, ""_s, 34) \
+macro(expires, "expires"_s, ""_s, 35) \
+macro(from, "from"_s, ""_s, 36) \
+macro(host, "host"_s, ""_s, 37) \
+macro(ifMatch, "if-match"_s, ""_s, 38) \
+macro(ifModifiedSince, "if-modified-since"_s, ""_s, 39) \
+macro(ifNoneMatch, "if-none-match"_s, ""_s, 40) \
+macro(ifRange, "if-range"_s, ""_s, 41) \
+macro(ifUnmodifiedSince, "if-unmodified-since"_s, ""_s, 42) \
+macro(lastModified, "last-modified"_s, ""_s, 43) \
+macro(link, "link"_s, ""_s, 44) \
+macro(location, "location"_s, ""_s, 45) \
+macro(maxForwards, "max-forwards"_s, ""_s, 46) \
+macro(proxyAuthenticate, "proxy-authenticate"_s, ""_s, 47) \
+macro(proxyAuthorization, "proxy-authorization"_s, ""_s, 48) \
+macro(range, "range"_s, ""_s, 49) \
+macro(referer, "referer"_s, ""_s, 50) \
+macro(refresh, "refresh"_s, ""_s, 51) \
+macro(retryAfter, "retry-after"_s, ""_s, 52) \
+macro(server, "server"_s, ""_s, 53) \
+macro(setCookie, "set-cookie"_s, ""_s, 54) \
+macro(strictTransportSecurity, "strict-transport-security"_s, ""_s, 55) \
+macro(transferEncoding, "transfer-encoding"_s, ""_s, 56) \
+macro(userAgent, "user-agent"_s, ""_s, 57) \
+macro(vary, "vary"_s, ""_s, 58) \
+macro(via, "via"_s, ""_s, 59) \
+macro(wwwAuthenticate, "www-authenticate"_s, ""_s, 60)
+
+// clang-format on
+
+#define HTTP2_COMMON_STRINGS_ACCESSOR_DEFINITION(name, key, value, idx) \
+    JSC::JSString* name##String(JSC::JSGlobalObject* globalObject)      \
+    {                                                                   \
+        return m_names[idx].getInitializedOnMainThread(globalObject);   \
+    }
+
+namespace Bun {
+
+using namespace JSC;
+
+class Http2CommonStrings {
+
+public:
+    typedef JSC::JSString* (*commonStringInitializer)(Http2CommonStrings*, JSC::JSGlobalObject* globalObject);
+
+    HTTP2_COMMON_STRINGS_EACH_NAME(HTTP2_COMMON_STRINGS_ACCESSOR_DEFINITION)
+
+    void initialize();
+
+    template<typename Visitor>
+    void visit(Visitor& visitor);
+
+    JSC::JSString* getStringFromHPackIndex(uint16_t index, JSC::JSGlobalObject* globalObject)
+    {
+        if (index > 60) {
+            return nullptr;
+        }
+        return m_names[index].getInitializedOnMainThread(globalObject);
+    }
+
+private:
+    JSC::LazyProperty<JSC::JSGlobalObject, JSC::JSString> m_names[61];
+};
+
+} // namespace Bun
+
+#undef BUN_COMMON_STRINGS_ACCESSOR_DEFINITION
+#undef BUN_COMMON_STRINGS_LAZY_PROPERTY_DECLARATION
diff --git a/src/bun.js/bindings/BunInjectedScriptHost.cpp b/src/bun.js/bindings/BunInjectedScriptHost.cpp
index a31aefdc29..b044e9bce1 100644
--- a/src/bun.js/bindings/BunInjectedScriptHost.cpp
+++ b/src/bun.js/bindings/BunInjectedScriptHost.cpp
@@ -144,19 +144,19 @@ JSValue BunInjectedScriptHost::getInternalProperties(VM& vm, JSGlobalObject* exe
                 return array;
             }
 
-            if (auto* params = jsDynamicCast<JSURLSearchParams*>(value)) {
-                auto* array = constructEmptyArray(exec, nullptr);
-                constructDataProperties(vm, exec, array, WebCore::getInternalProperties(vm, exec, params));
-                RETURN_IF_EXCEPTION(scope, {});
-                return array;
-            }
-
             if (auto* formData = jsDynamicCast<JSDOMFormData*>(value)) {
                 auto* array = constructEmptyArray(exec, nullptr);
                 constructDataProperties(vm, exec, array, WebCore::getInternalProperties(vm, exec, formData));
                 RETURN_IF_EXCEPTION(scope, {});
                 return array;
             }
+        } else if (type == JSAsJSONType) {
+            if (auto* params = jsDynamicCast<JSURLSearchParams*>(value)) {
+                auto* array = constructEmptyArray(exec, nullptr);
+                constructDataProperties(vm, exec, array, WebCore::getInternalProperties(vm, exec, params));
+                RETURN_IF_EXCEPTION(scope, {});
+                return array;
+            }
         }
     }
 
@@ -174,4 +174,4 @@ JSValue BunInjectedScriptHost::getInternalProperties(VM& vm, JSGlobalObject* exe
     return {};
 }
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/BunInjectedScriptHost.h b/src/bun.js/bindings/BunInjectedScriptHost.h
index 09e7e13614..5da7446552 100644
--- a/src/bun.js/bindings/BunInjectedScriptHost.h
+++ b/src/bun.js/bindings/BunInjectedScriptHost.h
@@ -12,4 +12,4 @@ public:
     bool isHTMLAllCollection(JSC::VM&, JSC::JSValue) override { return false; }
 };
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/BunJSCEventLoop.cpp b/src/bun.js/bindings/BunJSCEventLoop.cpp
new file mode 100644
index 0000000000..30498f1be9
--- /dev/null
+++ b/src/bun.js/bindings/BunJSCEventLoop.cpp
@@ -0,0 +1,23 @@
+#include "root.h"
+
+#include <JavaScriptCore/VM.h>
+#include <JavaScriptCore/Heap.h>
+
+extern "C" int Bun__JSC_onBeforeWait(JSC::VM* vm)
+{
+    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)
+{
+    UNUSED_PARAM(vm);
+    // vm->heap.acquireAccess();
+}
diff --git a/src/bun.js/bindings/BunObject+exports.h b/src/bun.js/bindings/BunObject+exports.h
index 8d6bd26d59..374af28774 100644
--- a/src/bun.js/bindings/BunObject+exports.h
+++ b/src/bun.js/bindings/BunObject+exports.h
@@ -38,6 +38,7 @@
     macro(braces) \
     macro(build) \
     macro(connect) \
+    macro(color) \
     macro(deflateSync) \
     macro(file) \
     macro(fs) \
diff --git a/src/bun.js/bindings/BunObject.cpp b/src/bun.js/bindings/BunObject.cpp
index 9d0629aa23..1ae5f4e00a 100644
--- a/src/bun.js/bindings/BunObject.cpp
+++ b/src/bun.js/bindings/BunObject.cpp
@@ -31,6 +31,7 @@
 #include "PathInlines.h"
 #include "wtf/text/ASCIILiteral.h"
 #include "BunObject+exports.h"
+#include "ErrorCode.h"
 
 BUN_DECLARE_HOST_FUNCTION(Bun__DNSResolver__lookup);
 BUN_DECLARE_HOST_FUNCTION(Bun__DNSResolver__resolve);
@@ -50,7 +51,7 @@ BUN_DECLARE_HOST_FUNCTION(Bun__DNSResolver__prefetch);
 BUN_DECLARE_HOST_FUNCTION(Bun__DNSResolver__getCacheStats);
 BUN_DECLARE_HOST_FUNCTION(Bun__fetch);
 BUN_DECLARE_HOST_FUNCTION(Bun__fetchPreconnect);
-
+BUN_DECLARE_HOST_FUNCTION(Bun__randomUUIDv7);
 namespace Bun {
 
 using namespace JSC;
@@ -120,8 +121,7 @@ static inline JSC::EncodedJSValue flattenArrayOfBuffersIntoArrayBufferOrUint8Arr
 
         if (auto* typedArray = JSC::jsDynamicCast<JSC::JSArrayBufferView*>(element)) {
             if (UNLIKELY(typedArray->isDetached())) {
-                throwTypeError(lexicalGlobalObject, throwScope, "ArrayBufferView is detached"_s);
-                return {};
+                return Bun::ERR::INVALID_STATE(throwScope, lexicalGlobalObject, "Cannot validate on a detached buffer"_s);
             }
             size_t current = typedArray->byteLength();
             any_typed = true;
@@ -133,8 +133,7 @@ static inline JSC::EncodedJSValue flattenArrayOfBuffersIntoArrayBufferOrUint8Arr
         } else if (auto* arrayBuffer = JSC::jsDynamicCast<JSC::JSArrayBuffer*>(element)) {
             auto* impl = arrayBuffer->impl();
             if (UNLIKELY(!impl)) {
-                throwTypeError(lexicalGlobalObject, throwScope, "ArrayBuffer is detached"_s);
-                return {};
+                return Bun::ERR::INVALID_STATE(throwScope, lexicalGlobalObject, "Cannot validate on a detached buffer"_s);
             }
 
             size_t current = impl->byteLength();
@@ -259,6 +258,11 @@ static JSValue constructBunRevision(VM& vm, JSObject*)
     return JSC::jsString(vm, makeString(ASCIILiteral::fromLiteralUnsafe(Bun__version_sha)));
 }
 
+static JSValue constructBunVersionWithSha(VM& vm, JSObject*)
+{
+    return JSC::jsString(vm, makeString(ASCIILiteral::fromLiteralUnsafe(Bun__version_with_sha)));
+}
+
 static JSValue constructIsMainThread(VM&, JSObject* object)
 {
     return jsBoolean(jsCast<Zig::GlobalObject*>(object->globalObject())->scriptExecutionContext()->isMainThread());
@@ -274,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)
@@ -318,13 +331,6 @@ static JSValue constructBunShell(VM& vm, JSObject* bunObject)
     return bunShell;
 }
 
-// This value currently depends on a zig feature flag
-extern "C" JSC::EncodedJSValue Bun__getTemporaryDevServer(JSC::JSGlobalObject* bunObject);
-static JSValue constructBunKit(VM& vm, JSObject* bunObject)
-{
-    return JSC::JSValue::decode(Bun__getTemporaryDevServer(bunObject->globalObject()));
-}
-
 static JSValue constructDNSObject(VM& vm, JSObject* bunObject)
 {
     JSGlobalObject* globalObject = bunObject->globalObject();
@@ -580,6 +586,7 @@ JSC_DEFINE_HOST_FUNCTION(functionFileURLToPath, (JSC::JSGlobalObject * globalObj
     concatArrayBuffers                             functionConcatTypedArrays                                           DontDelete|Function 3
     connect                                        BunObject_callback_connect                                          DontDelete|Function 1
     cwd                                            BunObject_getter_wrap_cwd                                           DontEnum|DontDelete|PropertyCallback
+    color                                          BunObject_callback_color                                            DontDelete|Function 2
     deepEquals                                     functionBunDeepEquals                                               DontDelete|Function 2
     deepMatch                                      functionBunDeepMatch                                                DontDelete|Function 2
     deflateSync                                    BunObject_callback_deflateSync                                        DontDelete|Function 1
@@ -607,10 +614,12 @@ JSC_DEFINE_HOST_FUNCTION(functionFileURLToPath, (JSC::JSGlobalObject * globalObj
     nanoseconds                                    functionBunNanoseconds                                              DontDelete|Function 0
     openInEditor                                   BunObject_callback_openInEditor                                     DontDelete|Function 1
     origin                                         BunObject_getter_wrap_origin                                        DontDelete|PropertyCallback
+    version_with_sha                               constructBunVersionWithSha                                          ReadOnly|DontDelete|PropertyCallback
     password                                       constructPasswordObject                                             DontDelete|PropertyCallback
     pathToFileURL                                  functionPathToFileURL                                               DontDelete|Function 1
     peek                                           constructBunPeekObject                                              DontDelete|PropertyCallback
     plugin                                         constructPluginObject                                               ReadOnly|DontDelete|PropertyCallback
+    randomUUIDv7                                   Bun__randomUUIDv7                                                   DontDelete|Function 2
     readableStreamToArray                          JSBuiltin                                                           Builtin|Function 1
     readableStreamToArrayBuffer                    JSBuiltin                                                           Builtin|Function 1
     readableStreamToBytes                          JSBuiltin                                                           Builtin|Function 1
@@ -623,6 +632,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
@@ -638,7 +648,6 @@ JSC_DEFINE_HOST_FUNCTION(functionFileURLToPath, (JSC::JSGlobalObject * globalObj
     version                                        constructBunVersion                                                 ReadOnly|DontDelete|PropertyCallback
     which                                          BunObject_callback_which                                            DontDelete|Function 1
     write                                          BunObject_callback_write                                            DontDelete|Function 1
-    wipDevServerDoNotUseYet                        constructBunKit                                                     DontEnum|ReadOnly|DontDelete|PropertyCallback
 @end
 */
 
diff --git a/src/bun.js/bindings/BunPlugin.cpp b/src/bun.js/bindings/BunPlugin.cpp
index 3f7386e7ba..8f1bb8d06e 100644
--- a/src/bun.js/bindings/BunPlugin.cpp
+++ b/src/bun.js/bindings/BunPlugin.cpp
@@ -936,4 +936,4 @@ BUN_DEFINE_HOST_FUNCTION(jsFunctionBunPluginClear, (JSC::JSGlobalObject * global
 BUN_DEFINE_HOST_FUNCTION(jsFunctionBunPlugin, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callframe))
 {
     return Bun::setupBunPlugin(globalObject, callframe, BunPluginTargetBun);
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/BunPlugin.h b/src/bun.js/bindings/BunPlugin.h
index 44a606234e..a8edf0d3aa 100644
--- a/src/bun.js/bindings/BunPlugin.h
+++ b/src/bun.js/bindings/BunPlugin.h
@@ -106,4 +106,4 @@ class GlobalObject;
 namespace Bun {
 JSC::JSValue runVirtualModule(Zig::GlobalObject*, BunString* specifier, bool& wasModuleMock);
 JSC::Structure* createModuleMockStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype);
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/BunProcess.cpp b/src/bun.js/bindings/BunProcess.cpp
index 354036653d..628240b254 100644
--- a/src/bun.js/bindings/BunProcess.cpp
+++ b/src/bun.js/bindings/BunProcess.cpp
@@ -18,6 +18,11 @@
 #include "headers.h"
 #include "JSEnvironmentVariableMap.h"
 #include "ImportMetaObject.h"
+#include "JavaScriptCore/ScriptCallStackFactory.h"
+#include "JavaScriptCore/ConsoleMessage.h"
+#include "JavaScriptCore/InspectorConsoleAgent.h"
+#include "JavaScriptCore/JSGlobalObjectDebuggable.h"
+#include <JavaScriptCore/StackFrame.h>
 #include <sys/stat.h>
 #include "ConsoleObject.h"
 #include <JavaScriptCore/GetterSetter.h>
@@ -26,14 +31,16 @@
 #include <JavaScriptCore/LazyPropertyInlines.h>
 #include <JavaScriptCore/VMTrapsInlines.h>
 #include "wtf-bindings.h"
-
+#include <webcore/SerializedScriptValue.h>
 #include "ProcessBindingTTYWrap.h"
 #include "wtf/text/ASCIILiteral.h"
 #include "wtf/text/OrdinalNumber.h"
 
 #include "AsyncContextFrame.h"
+#include "ErrorCode.h"
 
 #include "napi_handle_scope.h"
+#include "napi_external.h"
 
 #ifndef WIN32
 #include <errno.h>
@@ -57,8 +64,11 @@ typedef int mode_t;
 #include "ProcessBindingNatives.h"
 
 #if OS(LINUX)
+#include <features.h>
+#ifdef __GNU_LIBRARY__
 #include <gnu/libc-version.h>
 #endif
+#endif
 
 #pragma mark - Node.js Process
 
@@ -110,7 +120,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);
@@ -231,7 +240,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;
@@ -270,6 +279,8 @@ extern "C" bool Bun__resolveEmbeddedNodeFile(void*, BunString*);
 extern "C" HMODULE Bun__LoadLibraryBunString(BunString*);
 #endif
 
+extern "C" size_t Bun__process_dlopen_count;
+
 JSC_DEFINE_HOST_FUNCTION(Process_functionDlopen,
     (JSC::JSGlobalObject * globalObject_, JSC::CallFrame* callFrame))
 {
@@ -349,6 +360,10 @@ JSC_DEFINE_HOST_FUNCTION(Process_functionDlopen,
     void* handle = dlopen(utf8.data(), RTLD_LAZY);
 #endif
 
+    globalObject->m_pendingNapiModuleDlopenHandle = handle;
+
+    Bun__process_dlopen_count++;
+
     if (!handle) {
 #if OS(WINDOWS)
         DWORD errorId = GetLastError();
@@ -382,7 +397,7 @@ JSC_DEFINE_HOST_FUNCTION(Process_functionDlopen,
         return JSValue::encode(jsUndefined());
     }
 
-    JSC::EncodedJSValue (*napi_register_module_v1)(JSC::JSGlobalObject * globalObject,
+    JSC::EncodedJSValue (*napi_register_module_v1)(JSC::JSGlobalObject* globalObject,
         JSC::EncodedJSValue exports);
 #if OS(WINDOWS)
 #define dlsym GetProcAddress
@@ -413,10 +428,18 @@ JSC_DEFINE_HOST_FUNCTION(Process_functionDlopen,
     EncodedJSValue exportsValue = JSC::JSValue::encode(exports);
     JSC::JSValue resultValue = JSValue::decode(napi_register_module_v1(globalObject, exportsValue));
 
+    // TODO: think about the finalizer here
+    // currently we do not dealloc napi modules so we don't have to worry about it right now
+    auto* meta = new Bun::NapiModuleMeta(globalObject->m_pendingNapiModuleDlopenHandle);
+    Bun::NapiExternal* napi_external = Bun::NapiExternal::create(vm, globalObject->NapiExternalStructure(), meta, nullptr, nullptr);
+    bool success = resultValue.getObject()->putDirect(vm, WebCore::builtinNames(vm).napiDlopenHandlePrivateName(), napi_external, JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly);
+    ASSERT(success);
+
     RETURN_IF_EXCEPTION(scope, {});
 
     globalObject->m_pendingNapiModuleAndExports[0].clear();
     globalObject->m_pendingNapiModuleAndExports[1].clear();
+    globalObject->m_pendingNapiModuleDlopenHandle = nullptr;
 
     // https://github.com/nodejs/node/blob/2eff28fb7a93d3f672f80b582f664a7c701569fb/src/node_api.cc#L734-L742
     // https://github.com/oven-sh/bun/issues/1288
@@ -442,24 +465,18 @@ JSC_DEFINE_HOST_FUNCTION(Process_functionUmask,
     JSValue numberValue = callFrame->argument(0);
 
     if (!numberValue.isNumber()) {
-        throwTypeError(globalObject, throwScope, "The \"mask\" argument must be a number"_s);
-        return {};
+        return Bun::ERR::INVALID_ARG_TYPE(throwScope, globalObject, "mask"_s, "number"_s, numberValue);
     }
 
     if (!numberValue.isAnyInt()) {
-        throwNodeRangeError(globalObject, throwScope, "The \"mask\" argument must be an integer"_s);
-        return {};
+        return Bun::ERR::OUT_OF_RANGE(throwScope, globalObject, "mask"_s, "an integer"_s, numberValue);
     }
 
     double number = numberValue.toNumber(globalObject);
     int64_t newUmask = isInt52(number) ? tryConvertToInt52(number) : numberValue.toInt32(globalObject);
     RETURN_IF_EXCEPTION(throwScope, JSC::JSValue::encode(JSC::JSValue {}));
     if (newUmask < 0 || newUmask > 4294967295) {
-        StringBuilder messageBuilder;
-        messageBuilder.append("The \"mask\" value must be in range [0, 4294967295]. Received value: "_s);
-        messageBuilder.append(int52ToString(vm, newUmask, 10)->getString(globalObject));
-        throwNodeRangeError(globalObject, throwScope, messageBuilder.toString());
-        return {};
+        return Bun::ERR::OUT_OF_RANGE(throwScope, globalObject, "mask"_s, 0, 4294967295, numberValue);
     }
 
     return JSC::JSValue::encode(JSC::jsNumber(umask(newUmask)));
@@ -654,45 +671,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)
@@ -702,87 +725,93 @@ static void loadSignalNumberMap()
         signalNameToNumberMap->add(signalNames[9], SIGKILL);
         signalNameToNumberMap->add(signalNames[15], SIGTERM);
 #else
-            signalNameToNumberMap->add(signalNames[0], SIGHUP);
-            signalNameToNumberMap->add(signalNames[1], SIGINT);
-            signalNameToNumberMap->add(signalNames[2], SIGQUIT);
-            signalNameToNumberMap->add(signalNames[3], SIGILL);
+        signalNameToNumberMap->add(signalNames[0], SIGHUP);
+        signalNameToNumberMap->add(signalNames[1], SIGINT);
+        signalNameToNumberMap->add(signalNames[2], SIGQUIT);
+        signalNameToNumberMap->add(signalNames[3], SIGILL);
 #ifdef SIGTRAP
-            signalNameToNumberMap->add(signalNames[4], SIGTRAP);
+        signalNameToNumberMap->add(signalNames[4], SIGTRAP);
 #endif
-            signalNameToNumberMap->add(signalNames[5], SIGABRT);
+        signalNameToNumberMap->add(signalNames[5], SIGABRT);
 #ifdef SIGIOT
-            signalNameToNumberMap->add(signalNames[6], SIGIOT);
+        signalNameToNumberMap->add(signalNames[6], SIGIOT);
 #endif
 #ifdef SIGBUS
-            signalNameToNumberMap->add(signalNames[7], SIGBUS);
+        signalNameToNumberMap->add(signalNames[7], SIGBUS);
 #endif
-            signalNameToNumberMap->add(signalNames[8], SIGFPE);
-            signalNameToNumberMap->add(signalNames[9], SIGKILL);
+        signalNameToNumberMap->add(signalNames[8], SIGFPE);
+        signalNameToNumberMap->add(signalNames[9], SIGKILL);
 #ifdef SIGUSR1
-            signalNameToNumberMap->add(signalNames[10], SIGUSR1);
+        signalNameToNumberMap->add(signalNames[10], SIGUSR1);
 #endif
-            signalNameToNumberMap->add(signalNames[11], SIGSEGV);
+        signalNameToNumberMap->add(signalNames[11], SIGSEGV);
 #ifdef SIGUSR2
-            signalNameToNumberMap->add(signalNames[12], SIGUSR2);
+        signalNameToNumberMap->add(signalNames[12], SIGUSR2);
 #endif
 #ifdef SIGPIPE
-            signalNameToNumberMap->add(signalNames[13], SIGPIPE);
+        signalNameToNumberMap->add(signalNames[13], SIGPIPE);
 #endif
 #ifdef SIGALRM
-            signalNameToNumberMap->add(signalNames[14], SIGALRM);
+        signalNameToNumberMap->add(signalNames[14], SIGALRM);
 #endif
-            signalNameToNumberMap->add(signalNames[15], SIGTERM);
+        signalNameToNumberMap->add(signalNames[15], SIGTERM);
 #ifdef SIGCHLD
-            signalNameToNumberMap->add(signalNames[16], SIGCHLD);
+        signalNameToNumberMap->add(signalNames[16], SIGCHLD);
 #endif
 #ifdef SIGCONT
-            signalNameToNumberMap->add(signalNames[17], SIGCONT);
+        signalNameToNumberMap->add(signalNames[17], SIGCONT);
 #endif
 #ifdef SIGSTOP
-            signalNameToNumberMap->add(signalNames[18], SIGSTOP);
+        signalNameToNumberMap->add(signalNames[18], SIGSTOP);
 #endif
 #ifdef SIGTSTP
-            signalNameToNumberMap->add(signalNames[19], SIGTSTP);
+        signalNameToNumberMap->add(signalNames[19], SIGTSTP);
 #endif
 #ifdef SIGTTIN
-            signalNameToNumberMap->add(signalNames[20], SIGTTIN);
+        signalNameToNumberMap->add(signalNames[20], SIGTTIN);
 #endif
 #ifdef SIGTTOU
-            signalNameToNumberMap->add(signalNames[21], SIGTTOU);
+        signalNameToNumberMap->add(signalNames[21], SIGTTOU);
 #endif
 #ifdef SIGURG
-            signalNameToNumberMap->add(signalNames[22], SIGURG);
+        signalNameToNumberMap->add(signalNames[22], SIGURG);
 #endif
 #ifdef SIGXCPU
-            signalNameToNumberMap->add(signalNames[23], SIGXCPU);
+        signalNameToNumberMap->add(signalNames[23], SIGXCPU);
 #endif
 #ifdef SIGXFSZ
-            signalNameToNumberMap->add(signalNames[24], SIGXFSZ);
+        signalNameToNumberMap->add(signalNames[24], SIGXFSZ);
 #endif
 #ifdef SIGVTALRM
-            signalNameToNumberMap->add(signalNames[25], SIGVTALRM);
+        signalNameToNumberMap->add(signalNames[25], SIGVTALRM);
 #endif
 #ifdef SIGPROF
-            signalNameToNumberMap->add(signalNames[26], SIGPROF);
+        signalNameToNumberMap->add(signalNames[26], SIGPROF);
 #endif
-            signalNameToNumberMap->add(signalNames[27], SIGWINCH);
+        signalNameToNumberMap->add(signalNames[27], SIGWINCH);
 #ifdef SIGIO
-            signalNameToNumberMap->add(signalNames[28], SIGIO);
+        signalNameToNumberMap->add(signalNames[28], SIGIO);
 #endif
 #ifdef SIGINFO
-            signalNameToNumberMap->add(signalNames[29], SIGINFO);
+        signalNameToNumberMap->add(signalNames[29], SIGINFO);
 #endif
 
 #ifndef SIGINFO
-            signalNameToNumberMap->add(signalNames[29], 255);
+        signalNameToNumberMap->add(signalNames[29], 255);
 #endif
 #ifdef SIGSYS
-            signalNameToNumberMap->add(signalNames[30], SIGSYS);
+        signalNameToNumberMap->add(signalNames[30], SIGSYS);
 #endif
 #endif
     });
 }
 
+bool isSignalName(WTF::String input)
+{
+    loadSignalNumberMap();
+    return signalNameToNumberMap->contains(input);
+}
+
 #if OS(WINDOWS)
 extern "C" uv_signal_t* Bun__UVSignalHandle__init(JSC::JSGlobalObject* lexicalGlobalObject, int signalNumber, void (*callback)(uv_signal_t*, int));
 extern "C" uv_signal_t* Bun__UVSignalHandle__close(uv_signal_t*);
@@ -813,12 +842,7 @@ void signalHandler(uv_signal_t* signal, int signalNumber)
         MarkedArgumentBuffer args;
         args.append(jsString(globalObject->vm(), signalNameIdentifier.string()));
         args.append(jsNumber(signalNumber));
-        // TODO(@paperdave): add an ASSERT(isMainThread());
-        // This should be true on posix if I understand sigaction right
-        // On Windows it should be true if the uv_signal is created on the main thread's loop
-        //
-        // I would like to assert this because if that assumption is not true,
-        // this call will probably cause very confusing bugs.
+
         process->wrapped().emitForBindings(signalNameIdentifier, args);
     });
 };
@@ -924,6 +948,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]);
@@ -1572,8 +1597,11 @@ static JSValue constructReportObjectComplete(VM& vm, Zig::GlobalObject* globalOb
         }
 
 #if OS(LINUX)
+#ifdef __GNU_LIBRARY__
         header->putDirect(vm, JSC::Identifier::fromString(vm, "glibcVersionCompiler"_s), JSC::jsString(vm, makeString(__GLIBC__, '.', __GLIBC_MINOR__)), 0);
         header->putDirect(vm, JSC::Identifier::fromString(vm, "glibcVersionRuntime"_s), JSC::jsString(vm, String::fromUTF8(gnu_get_libc_version()), 0));
+#else
+#endif
 #endif
 
         header->putDirect(vm, Identifier::fromString(vm, "cpus"_s), JSC::constructEmptyArray(globalObject, nullptr), 0);
@@ -2895,11 +2923,11 @@ JSC_DEFINE_HOST_FUNCTION(Process_functionKill,
     (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
 {
     auto scope = DECLARE_THROW_SCOPE(globalObject->vm());
-    int pid = callFrame->argument(0).toInt32(globalObject);
+    auto pid_value = callFrame->argument(0);
+    int pid = pid_value.toInt32(globalObject);
     RETURN_IF_EXCEPTION(scope, {});
     if (pid < 0) {
-        throwNodeRangeError(globalObject, scope, "pid must be a positive integer"_s);
-        return {};
+        return Bun::ERR::OUT_OF_RANGE(scope, globalObject, "pid"_s, "a positive integer"_s, pid_value);
     }
     JSC::JSValue signalValue = callFrame->argument(1);
     int signal = SIGTERM;
@@ -2912,13 +2940,11 @@ JSC_DEFINE_HOST_FUNCTION(Process_functionKill,
             signal = num;
             RETURN_IF_EXCEPTION(scope, {});
         } else {
-            throwNodeRangeError(globalObject, scope, "Unknown signal name"_s);
-            return {};
+            return Bun::ERR::UNKNOWN_SIGNAL(scope, globalObject, signalValue);
         }
         RETURN_IF_EXCEPTION(scope, {});
     } else if (!signalValue.isUndefinedOrNull()) {
-        throwTypeError(globalObject, scope, "signal must be a string or number"_s);
-        return {};
+        return Bun::ERR::INVALID_ARG_TYPE(scope, globalObject, "signal"_s, "string or number"_s, signalValue);
     }
 
     auto global = jsCast<Zig::GlobalObject*>(globalObject);
diff --git a/src/bun.js/bindings/BunProcess.h b/src/bun.js/bindings/BunProcess.h
index 7183698525..368d93ae8b 100644
--- a/src/bun.js/bindings/BunProcess.h
+++ b/src/bun.js/bindings/BunProcess.h
@@ -104,4 +104,6 @@ public:
     inline JSObject* bindingNatives() { return m_bindingNatives.getInitializedOnMainThread(this); }
 };
 
-} // namespace Bun
\ No newline at end of file
+bool isSignalName(WTF::String input);
+
+} // namespace Bun
diff --git a/src/bun.js/bindings/BunString.cpp b/src/bun.js/bindings/BunString.cpp
index 8afcbb1ff1..4d9ce102f3 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,13 +146,18 @@ 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 };
     }
 
-    str.impl()->ref();
+    StringImpl* impl = str.impl();
 
-    return { BunStringTag::WTFStringImpl, { .wtf = str.impl() } };
+    impl->ref();
+
+    return { BunStringTag::WTFStringImpl, { .wtf = impl } };
 }
 
 BunString toString(WTF::String& wtfString)
diff --git a/src/bun.js/bindings/BunWorkerGlobalScope.cpp b/src/bun.js/bindings/BunWorkerGlobalScope.cpp
index 3bac99269b..40b1fbfddb 100644
--- a/src/bun.js/bindings/BunWorkerGlobalScope.cpp
+++ b/src/bun.js/bindings/BunWorkerGlobalScope.cpp
@@ -41,4 +41,4 @@ void WorkerGlobalScope::onDidChangeListenerImpl(EventTarget& self, const AtomStr
     }
 };
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/BunWorkerGlobalScope.h b/src/bun.js/bindings/BunWorkerGlobalScope.h
index eb9a2bac8a..ad9114de84 100644
--- a/src/bun.js/bindings/BunWorkerGlobalScope.h
+++ b/src/bun.js/bindings/BunWorkerGlobalScope.h
@@ -53,4 +53,4 @@ public:
 private:
     MessagePortChannelProviderImpl* m_messagePortChannelProvider;
 };
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/CPUFeatures.cpp b/src/bun.js/bindings/CPUFeatures.cpp
index 861de32dc1..d6665cd6b7 100644
--- a/src/bun.js/bindings/CPUFeatures.cpp
+++ b/src/bun.js/bindings/CPUFeatures.cpp
@@ -107,4 +107,4 @@ extern "C" uint8_t bun_cpu_features()
 #else
     return 0;
 #endif
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/CachedScript.h b/src/bun.js/bindings/CachedScript.h
index 3f54613d86..43a7e4ae6b 100644
--- a/src/bun.js/bindings/CachedScript.h
+++ b/src/bun.js/bindings/CachedScript.h
@@ -6,4 +6,4 @@ namespace WebCore {
 
 class CachedScript {
 };
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/CallSitePrototype.cpp b/src/bun.js/bindings/CallSitePrototype.cpp
index 0e9eb93ffd..ba7c8bdf07 100644
--- a/src/bun.js/bindings/CallSitePrototype.cpp
+++ b/src/bun.js/bindings/CallSitePrototype.cpp
@@ -13,42 +13,39 @@
 #include <JavaScriptCore/CodeBlock.h>
 #include <JavaScriptCore/Operations.h>
 #include <JavaScriptCore/JSCInlines.h>
-
+#include <JavaScriptCore/ObjectConstructor.h>
+#include <JavaScriptCore/JSBoundFunction.h>
 using namespace JSC;
 
 namespace Zig {
 
-static JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncGetThis);
-static JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncGetTypeName);
-static JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncGetFunction);
-static JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncGetFunctionName);
-static JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncGetMethodName);
-static JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncGetFileName);
-static JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncGetLineNumber);
-static JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncGetColumnNumber);
-static JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncGetEvalOrigin);
-static JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncGetScriptNameOrSourceURL);
-static JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncIsToplevel);
-static JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncIsEval);
-static JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncIsNative);
-static JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncIsConstructor);
-static JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncIsAsync);
-static JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncIsPromiseAll);
-static JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncGetPromiseIndex);
-static JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncToString);
+JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncGetThis);
+JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncGetTypeName);
+JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncGetFunction);
+JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncGetFunctionName);
+JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncGetMethodName);
+JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncGetFileName);
+JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncGetLineNumber);
+JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncGetColumnNumber);
+JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncGetEvalOrigin);
+JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncGetScriptNameOrSourceURL);
+JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncIsToplevel);
+JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncIsEval);
+JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncIsNative);
+JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncIsConstructor);
+JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncIsAsync);
+JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncIsPromiseAll);
+JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncGetPromiseIndex);
+JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncToString);
+JSC_DECLARE_HOST_FUNCTION(callSiteProtoFuncToJSON);
 
 ALWAYS_INLINE static CallSite* getCallSite(JSGlobalObject* globalObject, JSC::JSValue thisValue)
 {
     JSC::VM& vm = globalObject->vm();
     auto scope = DECLARE_THROW_SCOPE(vm);
 
-    if (UNLIKELY(!thisValue.isCell())) {
-        JSC::throwVMError(globalObject, scope, createNotAnObjectError(globalObject, thisValue));
-        return nullptr;
-    }
-
-    if (LIKELY(thisValue.asCell()->inherits(CallSite::info()))) {
-        return JSC::jsCast<CallSite*>(thisValue);
+    if (auto* callSite = JSC::jsDynamicCast<CallSite*>(thisValue)) {
+        return callSite;
     }
 
     throwTypeError(globalObject, scope, "CallSite operation called on non-CallSite object"_s);
@@ -84,6 +81,7 @@ static const HashTableValue CallSitePrototypeTableValues[]
           { "isPromiseAll"_s, JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::Function, NoIntrinsic, { HashTableValue::NativeFunctionType, callSiteProtoFuncIsPromiseAll, 0 } },
           { "getPromiseIndex"_s, JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::Function, NoIntrinsic, { HashTableValue::NativeFunctionType, callSiteProtoFuncGetPromiseIndex, 0 } },
           { "toString"_s, JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::Function, NoIntrinsic, { HashTableValue::NativeFunctionType, callSiteProtoFuncToString, 0 } },
+          { "toJSON"_s, JSC::PropertyAttribute::Function | 0, NoIntrinsic, { HashTableValue::NativeFunctionType, callSiteProtoFuncToJSON, 0 } },
       };
 
 const JSC::ClassInfo CallSitePrototype::s_info = { "CallSite"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(CallSitePrototype) };
@@ -165,10 +163,29 @@ JSC_DEFINE_HOST_FUNCTION(callSiteProtoFuncIsToplevel, (JSGlobalObject * globalOb
 {
     ENTER_PROTO_FUNC();
 
+    if (JSValue functionValue = callSite->function()) {
+        if (JSObject* fn = functionValue.getObject()) {
+            if (JSFunction* function = jsDynamicCast<JSFunction*>(fn)) {
+                if (function->inherits<JSC::JSBoundFunction>()) {
+                    return JSC::JSValue::encode(JSC::jsBoolean(false));
+                }
+
+                if (function->isHostFunction()) {
+                    return JSC::JSValue::encode(JSC::jsBoolean(true));
+                }
+
+                if (auto* executable = function->jsExecutable()) {
+                    return JSValue::encode(jsBoolean(executable->isProgramExecutable() || executable->isModuleProgramExecutable()));
+                }
+            } else if (auto* function = jsDynamicCast<InternalFunction*>(functionValue)) {
+                return JSC::JSValue::encode(JSC::jsBoolean(true));
+            }
+        }
+    }
+
     JSC::JSValue thisValue = callSite->thisValue();
 
     // This is what v8 does (JSStackFrame::IsToplevel in messages.cc):
-
     if (thisValue.isUndefinedOrNull()) {
         return JSC::JSValue::encode(JSC::jsBoolean(true));
     }
@@ -237,4 +254,15 @@ JSC_DEFINE_HOST_FUNCTION(callSiteProtoFuncToString, (JSGlobalObject * globalObje
     return JSC::JSValue::encode(JSC::JSValue(jsString(vm, sb.toString())));
 }
 
+JSC_DEFINE_HOST_FUNCTION(callSiteProtoFuncToJSON, (JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    ENTER_PROTO_FUNC();
+    JSObject* obj = JSC::constructEmptyObject(globalObject, globalObject->objectPrototype(), 4);
+    obj->putDirect(vm, JSC::Identifier::fromString(vm, "sourceURL"_s), callSite->sourceURL());
+    obj->putDirect(vm, JSC::Identifier::fromString(vm, "lineNumber"_s), jsNumber(callSite->lineNumber().oneBasedInt()));
+    obj->putDirect(vm, JSC::Identifier::fromString(vm, "columnNumber"_s), jsNumber(callSite->columnNumber().zeroBasedInt()));
+    obj->putDirect(vm, JSC::Identifier::fromString(vm, "functionName"_s), callSite->functionName());
+    return JSC::JSValue::encode(obj);
+}
+
 }
diff --git a/src/bun.js/bindings/CallSitePrototype.h b/src/bun.js/bindings/CallSitePrototype.h
index 8aa543fd30..5030763990 100644
--- a/src/bun.js/bindings/CallSitePrototype.h
+++ b/src/bun.js/bindings/CallSitePrototype.h
@@ -44,4 +44,4 @@ private:
     void finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject);
 };
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/CommonJSModuleRecord.cpp b/src/bun.js/bindings/CommonJSModuleRecord.cpp
index de4a1320f6..ac0f28d6f3 100644
--- a/src/bun.js/bindings/CommonJSModuleRecord.cpp
+++ b/src/bun.js/bindings/CommonJSModuleRecord.cpp
@@ -763,7 +763,7 @@ void populateESMExports(
     bool ignoreESModuleAnnotation)
 {
     auto& vm = globalObject->vm();
-    Identifier esModuleMarker = builtinNames(vm).__esModulePublicName();
+    const Identifier& esModuleMarker = vm.propertyNames->__esModule;
 
     // Bun's intepretation of the "__esModule" annotation:
     //
@@ -795,9 +795,23 @@ void populateESMExports(
     //       unit tests of build tools. Happy to revisit this if users file an issue.
     bool needsToAssignDefault = true;
 
-    if (result.isObject()) {
-        auto* exports = result.getObject();
-        bool hasESModuleMarker = !ignoreESModuleAnnotation && exports->hasProperty(globalObject, esModuleMarker);
+    if (auto* exports = result.getObject()) {
+        bool hasESModuleMarker = false;
+        if (!ignoreESModuleAnnotation) {
+            auto catchScope = DECLARE_CATCH_SCOPE(vm);
+            PropertySlot slot(exports, PropertySlot::InternalMethodType::VMInquiry, &vm);
+            if (exports->getPropertySlot(globalObject, esModuleMarker, slot)) {
+                JSValue value = slot.getValue(globalObject, esModuleMarker);
+                if (!value.isUndefinedOrNull()) {
+                    if (value.pureToBoolean() == TriState::True) {
+                        hasESModuleMarker = true;
+                    }
+                }
+            }
+            if (catchScope.exception()) {
+                catchScope.clearException();
+            }
+        }
 
         auto* structure = exports->structure();
         uint32_t size = structure->inlineSize() + structure->outOfLineSize();
@@ -942,6 +956,11 @@ void JSCommonJSModule::toSyntheticSource(JSC::JSGlobalObject* globalObject,
     populateESMExports(globalObject, result, exportNames, exportValues, this->ignoreESModuleAnnotation);
 }
 
+void JSCommonJSModule::setExportsObject(JSC::JSValue exportsObject)
+{
+    this->putDirect(vm(), JSC::PropertyName(clientData(vm())->builtinNames().exportsPublicName()), exportsObject, 0);
+}
+
 JSValue JSCommonJSModule::exportsObject()
 {
     return this->get(globalObject(), JSC::PropertyName(clientData(vm())->builtinNames().exportsPublicName()));
@@ -1004,12 +1023,6 @@ JSC_DEFINE_HOST_FUNCTION(jsFunctionRequireCommonJS, (JSGlobalObject * lexicalGlo
     WTF::String specifier = specifierValue.toWTFString(globalObject);
     RETURN_IF_EXCEPTION(throwScope, {});
 
-    // Special-case for "process" to just return the process object directly.
-    if (UNLIKELY(specifier == "process"_s || specifier == "node:process"_s)) {
-        jsCast<JSCommonJSModule*>(callframe->argument(1))->putDirect(vm, builtinNames(vm).exportsPublicName(), globalObject->processObject(), 0);
-        return JSValue::encode(globalObject->processObject());
-    }
-
     WTF::String referrer = thisObject->id().toWTFString(globalObject);
     RETURN_IF_EXCEPTION(throwScope, {});
 
diff --git a/src/bun.js/bindings/CommonJSModuleRecord.h b/src/bun.js/bindings/CommonJSModuleRecord.h
index d3f0fde00a..70721f0842 100644
--- a/src/bun.js/bindings/CommonJSModuleRecord.h
+++ b/src/bun.js/bindings/CommonJSModuleRecord.h
@@ -5,6 +5,7 @@
 #include "JavaScriptCore/JSString.h"
 #include "headers-handwritten.h"
 #include "wtf/NakedPtr.h"
+#include "BunClientData.h"
 
 namespace Zig {
 class GlobalObject;
@@ -18,6 +19,8 @@ class AbstractModuleRecord;
 
 namespace Bun {
 
+using namespace JSC;
+
 JSC_DECLARE_HOST_FUNCTION(jsFunctionCreateCommonJSModule);
 JSC_DECLARE_HOST_FUNCTION(jsFunctionLoadModule);
 
@@ -102,6 +105,7 @@ public:
         JSC::MarkedArgumentBuffer& exportValues);
 
     JSValue exportsObject();
+    void setExportsObject(JSC::JSValue exportsObject);
     JSValue id();
 
     bool load(JSC::VM& vm, Zig::GlobalObject* globalObject, WTF::NakedPtr<JSC::Exception>&);
@@ -154,7 +158,7 @@ public:
     using Base = JSC::JSNonFinalObject;
 
     static RequireResolveFunctionPrototype* create(JSC::JSGlobalObject* globalObject);
-    static Structure* createStructure(VM& vm, JSC::JSGlobalObject* globalObject);
+    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject);
 
     DECLARE_INFO;
 
@@ -180,7 +184,7 @@ public:
     using Base = JSC::JSNonFinalObject;
 
     static RequireFunctionPrototype* create(JSC::JSGlobalObject* globalObject);
-    static Structure* createStructure(VM& vm, JSC::JSGlobalObject* globalObject);
+    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject);
 
     DECLARE_INFO;
 
diff --git a/src/bun.js/bindings/ConsoleObject.cpp b/src/bun.js/bindings/ConsoleObject.cpp
index 754cfe5c67..1645511c7f 100644
--- a/src/bun.js/bindings/ConsoleObject.cpp
+++ b/src/bun.js/bindings/ConsoleObject.cpp
@@ -132,4 +132,4 @@ void ConsoleObject::profileEnd(JSC::JSGlobalObject* globalObject, const String&
     }
 }
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/ConsoleObject.h b/src/bun.js/bindings/ConsoleObject.h
index 44c5bf8e92..60608f9b8c 100644
--- a/src/bun.js/bindings/ConsoleObject.h
+++ b/src/bun.js/bindings/ConsoleObject.h
@@ -6,6 +6,8 @@
 #include <wtf/Vector.h>
 #include <wtf/text/WTFString.h>
 
+#include <JavaScriptCore/InspectorConsoleAgent.h>
+
 namespace Inspector {
 class InspectorConsoleAgent;
 class InspectorDebuggerAgent;
@@ -31,6 +33,7 @@ public:
     static bool logToSystemConsole();
     static void setLogToSystemConsole(bool);
 
+    Inspector::InspectorConsoleAgent* consoleAgent() { return m_consoleAgent; }
     void setDebuggerAgent(InspectorDebuggerAgent* agent) { m_debuggerAgent = agent; }
     void setPersistentScriptProfilerAgent(InspectorScriptProfilerAgent* agent)
     {
diff --git a/src/bun.js/bindings/DeleteCallbackDataTask.h b/src/bun.js/bindings/DeleteCallbackDataTask.h
index 4c3a5b05d3..e80ddf6fc7 100644
--- a/src/bun.js/bindings/DeleteCallbackDataTask.h
+++ b/src/bun.js/bindings/DeleteCallbackDataTask.h
@@ -13,4 +13,4 @@ public:
     }
 };
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/DoubleFormatter.cpp b/src/bun.js/bindings/DoubleFormatter.cpp
index c1a94d55bf..82266076a2 100644
--- a/src/bun.js/bindings/DoubleFormatter.cpp
+++ b/src/bun.js/bindings/DoubleFormatter.cpp
@@ -4,12 +4,14 @@
 #include "JavaScriptCore/JSGlobalObjectFunctions.h"
 #include <cstring>
 
+using namespace WTF;
+
 /// Must be called with a buffer of exactly 124
 /// Find the length by scanning for the 0
 extern "C" size_t WTF__dtoa(char* buf_124_bytes, double number)
 {
     NumberToStringBuffer& buf = *reinterpret_cast<NumberToStringBuffer*>(buf_124_bytes);
-    return WTF::numberToStringAndSize(number, buf);
+    return WTF::numberToStringAndSize(number, buf).size();
 }
 
 /// This is the equivalent of the unary '+' operator on a JS string
diff --git a/src/bun.js/bindings/ErrorCode.cpp b/src/bun.js/bindings/ErrorCode.cpp
index a962c516df..2d9142401f 100644
--- a/src/bun.js/bindings/ErrorCode.cpp
+++ b/src/bun.js/bindings/ErrorCode.cpp
@@ -7,7 +7,6 @@
 #include "JavaScriptCore/ErrorType.h"
 #include "JavaScriptCore/ObjectConstructor.h"
 #include "JavaScriptCore/WriteBarrier.h"
-#include "root.h"
 #include "headers-handwritten.h"
 #include "BunClientData.h"
 #include "helpers.h"
@@ -61,12 +60,6 @@ static JSC::JSObject* createErrorPrototype(JSC::VM& vm, JSC::JSGlobalObject* glo
     return prototype;
 }
 
-extern "C" JSC::EncodedJSValue Bun__ERR_INVALID_ARG_TYPE(JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue val_arg_name, JSC::EncodedJSValue val_expected_type, JSC::EncodedJSValue val_actual_value);
-extern "C" JSC::EncodedJSValue Bun__ERR_INVALID_ARG_TYPE_static(JSC::JSGlobalObject* globalObject, const ZigString* val_arg_name, const ZigString* val_expected_type, JSC::EncodedJSValue val_actual_value);
-extern "C" JSC::EncodedJSValue Bun__ERR_MISSING_ARGS(JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue arg1, JSC::EncodedJSValue arg2, JSC::EncodedJSValue arg3);
-extern "C" JSC::EncodedJSValue Bun__ERR_MISSING_ARGS_static(JSC::JSGlobalObject* globalObject, const ZigString* arg1, const ZigString* arg2, const ZigString* arg3);
-extern "C" JSC::EncodedJSValue Bun__ERR_IPC_CHANNEL_CLOSED(JSC::JSGlobalObject* globalObject);
-
 // clang-format on
 
 #define EXPECT_ARG_COUNT(count__)                                                          \
@@ -228,7 +221,6 @@ namespace Message {
 
 WTF::String ERR_INVALID_ARG_TYPE(JSC::ThrowScope& scope, JSC::JSGlobalObject* globalObject, const StringView& arg_name, const StringView& expected_type, JSValue actual_value)
 {
-
     auto actual_value_string = JSValueToStringSafe(globalObject, actual_value);
     RETURN_IF_EXCEPTION(scope, {});
 
@@ -280,7 +272,6 @@ WTF::String ERR_INVALID_ARG_TYPE(JSC::ThrowScope& scope, JSC::JSGlobalObject* gl
 
 WTF::String ERR_INVALID_ARG_TYPE(JSC::ThrowScope& scope, JSC::JSGlobalObject* globalObject, JSValue val_arg_name, JSValue val_expected_type, JSValue val_actual_value)
 {
-
     auto arg_name = val_arg_name.toWTFString(globalObject);
     RETURN_IF_EXCEPTION(scope, {});
 
@@ -301,13 +292,205 @@ WTF::String ERR_OUT_OF_RANGE(JSC::ThrowScope& scope, JSC::JSGlobalObject* global
     auto input = JSValueToStringSafe(globalObject, val_input);
     RETURN_IF_EXCEPTION(scope, {});
 
-    return makeString("The value of \""_s, arg_name, "\" is out of range. It must be "_s, range, ". Received: \""_s, input, '"');
+    return makeString("The value of \""_s, arg_name, "\" is out of range. It must be "_s, range, ". Received: "_s, input);
 }
+
+}
+
+namespace ERR {
+
+JSC::EncodedJSValue INVALID_ARG_TYPE(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, const WTF::String& val_arg_name, const WTF::String& val_expected_type, JSC::JSValue val_actual_value)
+{
+    auto arg_name = val_arg_name.span8();
+    ASSERT(WTF::charactersAreAllASCII(arg_name));
+
+    auto arg_kind = String(arg_name).startsWith("options."_s) ? "property"_s : "argument"_s;
+
+    auto expected_type = val_expected_type.span8();
+    ASSERT(WTF::charactersAreAllASCII(expected_type));
+
+    auto ty_first_char = expected_type[0];
+    auto ty_kind = ty_first_char >= 'A' && ty_first_char <= 'Z' ? "an instance of"_s : "of type"_s;
+
+    auto actual_value = JSValueToStringSafe(globalObject, val_actual_value);
+    RETURN_IF_EXCEPTION(throwScope, {});
+
+    auto message = makeString("The \""_s, arg_name, "\" "_s, arg_kind, " must be "_s, ty_kind, " "_s, expected_type, ". Received "_s, actual_value);
+    throwScope.throwException(globalObject, createError(globalObject, ErrorCode::ERR_INVALID_ARG_TYPE, message));
+    return {};
+}
+JSC::EncodedJSValue INVALID_ARG_TYPE(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, JSC::JSValue val_arg_name, const WTF::String& val_expected_type, JSC::JSValue val_actual_value)
+{
+    auto arg_name = val_arg_name.toWTFString(globalObject);
+    RETURN_IF_EXCEPTION(throwScope, {});
+
+    auto arg_kind = String(arg_name).startsWith("options."_s) ? "property"_s : "argument"_s;
+
+    auto expected_type = val_expected_type.span8();
+    ASSERT(WTF::charactersAreAllASCII(expected_type));
+
+    auto ty_first_char = expected_type[0];
+    auto ty_kind = ty_first_char >= 'A' && ty_first_char <= 'Z' ? "an instance of"_s : "of type"_s;
+
+    auto actual_value = JSValueToStringSafe(globalObject, val_actual_value);
+    RETURN_IF_EXCEPTION(throwScope, {});
+
+    auto message = makeString("The \""_s, arg_name, "\" "_s, arg_kind, " must be "_s, ty_kind, " "_s, expected_type, ". Received "_s, actual_value);
+    throwScope.throwException(globalObject, createError(globalObject, ErrorCode::ERR_INVALID_ARG_TYPE, message));
+    return {};
+}
+
+JSC::EncodedJSValue OUT_OF_RANGE(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, const WTF::String& arg_name, size_t lower, size_t upper, JSC::JSValue actual)
+{
+    auto lowerStr = jsNumber(lower).toWTFString(globalObject);
+    auto upperStr = jsNumber(upper).toWTFString(globalObject);
+    auto actual_value = JSValueToStringSafe(globalObject, actual);
+    RETURN_IF_EXCEPTION(throwScope, {});
+
+    auto message = makeString("The value of \""_s, arg_name, "\" is out of range. It must be >= "_s, lowerStr, " and <= "_s, upperStr, ". Received "_s, actual_value);
+    throwScope.throwException(globalObject, createError(globalObject, ErrorCode::ERR_OUT_OF_RANGE, message));
+    return {};
+}
+JSC::EncodedJSValue OUT_OF_RANGE(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, JSC::JSValue arg_name_val, size_t lower, size_t upper, JSC::JSValue actual)
+{
+    auto arg_name = arg_name_val.toWTFString(globalObject);
+    RETURN_IF_EXCEPTION(throwScope, {});
+    auto lowerStr = jsNumber(lower).toWTFString(globalObject);
+    auto upperStr = jsNumber(upper).toWTFString(globalObject);
+    auto actual_value = JSValueToStringSafe(globalObject, actual);
+    RETURN_IF_EXCEPTION(throwScope, {});
+
+    auto message = makeString("The value of \""_s, arg_name, "\" is out of range. It must be >= "_s, lowerStr, " and <= "_s, upperStr, ". Received "_s, actual_value);
+    throwScope.throwException(globalObject, createError(globalObject, ErrorCode::ERR_OUT_OF_RANGE, message));
+    return {};
+}
+JSC::EncodedJSValue OUT_OF_RANGE(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, JSC::JSValue arg_name_val, size_t bound_num, Bound bound, JSC::JSValue actual)
+{
+    auto arg_name = arg_name_val.toWTFString(globalObject);
+    RETURN_IF_EXCEPTION(throwScope, {});
+    auto actual_value = JSValueToStringSafe(globalObject, actual);
+    RETURN_IF_EXCEPTION(throwScope, {});
+
+    switch (bound) {
+    case LOWER: {
+        auto message = makeString("The value of \""_s, arg_name, "\" is out of range. It must be >= "_s, bound_num, ". Received "_s, actual_value);
+        throwScope.throwException(globalObject, createError(globalObject, ErrorCode::ERR_OUT_OF_RANGE, message));
+        return {};
+    }
+    case UPPER: {
+        auto message = makeString("The value of \""_s, arg_name, "\" is out of range. It must be <= "_s, bound_num, ". Received "_s, actual_value);
+        throwScope.throwException(globalObject, createError(globalObject, ErrorCode::ERR_OUT_OF_RANGE, message));
+        return {};
+    }
+    }
+}
+JSC::EncodedJSValue OUT_OF_RANGE(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, JSC::JSValue arg_name_val, const WTF::String& msg, JSC::JSValue actual)
+{
+    auto arg_name = arg_name_val.toWTFString(globalObject);
+    RETURN_IF_EXCEPTION(throwScope, {});
+    auto actual_value = JSValueToStringSafe(globalObject, actual);
+    RETURN_IF_EXCEPTION(throwScope, {});
+
+    auto message = makeString("The value of \""_s, arg_name, "\" is out of range. It must be "_s, msg, ". Received "_s, actual_value);
+    throwScope.throwException(globalObject, createError(globalObject, ErrorCode::ERR_OUT_OF_RANGE, message));
+    return {};
+}
+JSC::EncodedJSValue OUT_OF_RANGE(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, const WTF::String& arg_name, const WTF::String& msg, JSC::JSValue actual)
+{
+    auto actual_value = JSValueToStringSafe(globalObject, actual);
+    RETURN_IF_EXCEPTION(throwScope, {});
+
+    auto message = makeString("The value of \""_s, arg_name, "\" is out of range. It must be "_s, msg, ". Received "_s, actual_value);
+    throwScope.throwException(globalObject, createError(globalObject, ErrorCode::ERR_OUT_OF_RANGE, message));
+    return {};
+}
+
+JSC::EncodedJSValue INVALID_ARG_VALUE(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, const WTF::String& name, JSC::JSValue value, const WTF::String& reason)
+{
+    ASCIILiteral type;
+    {
+        auto sp = name.span8();
+        auto str = std::string_view((const char*)(sp.data()), sp.size());
+        auto has = str.find('.') == std::string::npos;
+        type = has ? "property"_s : "argument"_s;
+    }
+
+    auto value_string = JSValueToStringSafe(globalObject, value);
+    RETURN_IF_EXCEPTION(throwScope, {});
+
+    auto message = makeString("The "_s, type, " '"_s, name, "' "_s, reason, ". Received "_s, value_string);
+    throwScope.throwException(globalObject, createError(globalObject, ErrorCode::ERR_INVALID_ARG_VALUE, message));
+    return {};
+}
+JSC::EncodedJSValue INVALID_ARG_VALUE(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, JSC::JSValue name, JSC::JSValue value, const WTF::String& reason)
+{
+    auto name_string = JSValueToStringSafe(globalObject, name);
+    RETURN_IF_EXCEPTION(throwScope, {});
+
+    auto value_string = JSValueToStringSafe(globalObject, value);
+    RETURN_IF_EXCEPTION(throwScope, {});
+
+    auto message = makeString("The argument '"_s, name_string, "' "_s, reason, ". Received "_s, value_string);
+    throwScope.throwException(globalObject, createError(globalObject, ErrorCode::ERR_INVALID_ARG_VALUE, message));
+    return {};
+}
+
+JSC::EncodedJSValue UNKNOWN_ENCODING(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, const WTF::String& encoding)
+{
+    auto message = makeString("Unknown encoding: "_s, encoding);
+    throwScope.throwException(globalObject, createError(globalObject, ErrorCode::ERR_UNKNOWN_ENCODING, message));
+    return {};
+}
+
+JSC::EncodedJSValue INVALID_STATE(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, const WTF::String& statemsg)
+{
+    auto message = makeString("Invalid state: "_s, statemsg);
+    throwScope.throwException(globalObject, createError(globalObject, ErrorCode::ERR_INVALID_STATE, message));
+    return {};
+}
+
+JSC::EncodedJSValue STRING_TOO_LONG(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject)
+{
+    auto message = makeString("Cannot create a string longer than "_s, WTF::String ::MaxLength, " characters"_s);
+    throwScope.throwException(globalObject, createError(globalObject, ErrorCode::ERR_STRING_TOO_LONG, message));
+    return {};
+}
+
+JSC::EncodedJSValue BUFFER_OUT_OF_BOUNDS(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject)
+{
+    throwScope.throwException(globalObject, createError(globalObject, ErrorCode::ERR_BUFFER_OUT_OF_BOUNDS, "Attempt to access memory outside buffer bounds"_s));
+    return {};
+}
+
+JSC::EncodedJSValue UNKNOWN_SIGNAL(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, JSC::JSValue signal, bool triedUppercase)
+{
+    auto signal_string = JSValueToStringSafe(globalObject, signal);
+    RETURN_IF_EXCEPTION(throwScope, {});
+
+    auto message_extra = triedUppercase ? " (signals must use all capital letters)"_s : ""_s;
+    auto message = makeString("Unknown signal: "_s, signal_string, message_extra);
+    throwScope.throwException(globalObject, createError(globalObject, ErrorCode::ERR_UNKNOWN_SIGNAL, message));
+    return {};
+}
+
+JSC::EncodedJSValue SOCKET_BAD_PORT(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, JSC::JSValue name, JSC::JSValue port, bool allowZero)
+{
+    ASCIILiteral op = allowZero ? ">="_s : ">"_s;
+
+    auto name_string = JSValueToStringSafe(globalObject, name);
+    RETURN_IF_EXCEPTION(throwScope, {});
+    auto port_string = JSValueToStringSafe(globalObject, port);
+    RETURN_IF_EXCEPTION(throwScope, {});
+
+    auto message = makeString(name_string, " should be "_s, op, " 0 and < 65536. Received "_s, port_string);
+    throwScope.throwException(globalObject, createError(globalObject, ErrorCode::ERR_SOCKET_BAD_PORT, message));
+    return {};
+}
+
 }
 
 static JSC::JSValue ERR_INVALID_ARG_TYPE(JSC::ThrowScope& scope, JSC::JSGlobalObject* globalObject, JSValue arg0, JSValue arg1, JSValue arg2)
 {
-
     if (auto* array = jsDynamicCast<JSC::JSArray*>(arg1)) {
         const WTF::String argName = arg0.toWTFString(globalObject);
         RETURN_IF_EXCEPTION(scope, {});
@@ -326,25 +509,6 @@ static JSC::JSValue ERR_INVALID_ARG_TYPE(JSC::ThrowScope& scope, JSC::JSGlobalOb
     return createError(globalObject, ErrorCode::ERR_INVALID_ARG_TYPE, msg);
 }
 
-extern "C" JSC::EncodedJSValue Bun__ERR_INVALID_ARG_TYPE(JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue val_arg_name, JSC::EncodedJSValue val_expected_type, JSC::EncodedJSValue val_actual_value)
-{
-    JSC::VM& vm = globalObject->vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-
-    auto message = Message::ERR_INVALID_ARG_TYPE(scope, globalObject, JSValue::decode(val_arg_name), JSValue::decode(val_expected_type), JSValue::decode(val_actual_value));
-    RETURN_IF_EXCEPTION(scope, {});
-    return JSC::JSValue::encode(createError(globalObject, ErrorCode::ERR_INVALID_ARG_TYPE, message));
-}
-extern "C" JSC::EncodedJSValue Bun__ERR_INVALID_ARG_TYPE_static(JSC::JSGlobalObject* globalObject, const ZigString* val_arg_name, const ZigString* val_expected_type, JSC::EncodedJSValue val_actual_value)
-{
-    JSC::VM& vm = globalObject->vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-
-    WTF::String message = Message::ERR_INVALID_ARG_TYPE(scope, globalObject, val_arg_name, val_expected_type, JSValue::decode(val_actual_value));
-    RETURN_IF_EXCEPTION(scope, {});
-    return JSC::JSValue::encode(createError(globalObject, ErrorCode::ERR_INVALID_ARG_TYPE, message));
-}
-
 JSC_DEFINE_HOST_FUNCTION(jsFunction_ERR_OUT_OF_RANGE, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
 {
     JSC::VM& vm = globalObject->vm();
@@ -372,82 +536,7 @@ extern "C" JSC::EncodedJSValue Bun__createErrorWithCode(JSC::JSGlobalObject* glo
     return JSValue::encode(createError(globalObject, code, message->toWTFString(BunString::ZeroCopy)));
 }
 
-extern "C" JSC::EncodedJSValue Bun__ERR_MISSING_ARGS(JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue arg1, JSC::EncodedJSValue arg2, JSC::EncodedJSValue arg3)
-{
-    JSC::VM& vm = globalObject->vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-
-    if (arg1 == 0) {
-        JSC::throwTypeError(globalObject, scope, "requires at least 1 argument"_s);
-        return {};
-    }
-
-    auto name1 = JSValue::decode(arg1).toWTFString(globalObject);
-    RETURN_IF_EXCEPTION(scope, {});
-
-    if (arg2 == 0) {
-        // 1 arg name passed
-        auto message = makeString("The \""_s, name1, "\" argument must be specified"_s);
-        return JSC::JSValue::encode(createError(globalObject, ErrorCode::ERR_MISSING_ARGS, message));
-    }
-
-    auto name2 = JSValue::decode(arg2).toWTFString(globalObject);
-    RETURN_IF_EXCEPTION(scope, {});
-
-    if (arg3 == 0) {
-        // 2 arg names passed
-        auto message = makeString("The \""_s, name1, "\" and \""_s, name2, "\" arguments must be specified"_s);
-        return JSC::JSValue::encode(createError(globalObject, ErrorCode::ERR_MISSING_ARGS, message));
-    }
-
-    auto name3 = JSValue::decode(arg3).toWTFString(globalObject);
-    RETURN_IF_EXCEPTION(scope, {});
-
-    // 3 arg names passed
-    auto message = makeString("The \""_s, name1, "\", \""_s, name2, "\", and \""_s, name3, "\" arguments must be specified"_s);
-    return JSC::JSValue::encode(createError(globalObject, ErrorCode::ERR_MISSING_ARGS, message));
-}
-extern "C" JSC::EncodedJSValue Bun__ERR_MISSING_ARGS_static(JSC::JSGlobalObject* globalObject, const ZigString* arg1, const ZigString* arg2, const ZigString* arg3)
-{
-    JSC::VM& vm = globalObject->vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-
-    if (arg1 == nullptr) {
-        JSC::throwTypeError(globalObject, scope, "requires at least 1 argument"_s);
-        return {};
-    }
-
-    auto name1 = std::span<const unsigned char>(arg1->ptr, arg1->len);
-    ASSERT(WTF::charactersAreAllASCII(name1));
-
-    if (arg2 == nullptr) {
-        // 1 arg name passed
-        auto message = makeString("The \""_s, name1, "\" argument must be specified"_s);
-        return JSC::JSValue::encode(createError(globalObject, ErrorCode::ERR_MISSING_ARGS, message));
-    }
-
-    auto name2 = std::span<const unsigned char>(arg2->ptr, arg2->len);
-    ASSERT(WTF::charactersAreAllASCII(name2));
-
-    if (arg3 == nullptr) {
-        // 2 arg names passed
-        auto message = makeString("The \""_s, name1, "\" and \""_s, name2, "\" arguments must be specified"_s);
-        return JSC::JSValue::encode(createError(globalObject, ErrorCode::ERR_MISSING_ARGS, message));
-    }
-
-    auto name3 = std::span<const unsigned char>(arg3->ptr, arg3->len);
-    ASSERT(WTF::charactersAreAllASCII(name3));
-
-    // 3 arg names passed
-    auto message = makeString("The \""_s, name1, "\", \""_s, name2, "\", and \""_s, name3, "\" arguments must be specified"_s);
-    return JSC::JSValue::encode(createError(globalObject, ErrorCode::ERR_MISSING_ARGS, message));
-}
-
 JSC_DEFINE_HOST_FUNCTION(jsFunction_ERR_IPC_CHANNEL_CLOSED, (JSC::JSGlobalObject * globalObject, JSC::CallFrame*))
-{
-    return Bun__ERR_IPC_CHANNEL_CLOSED(globalObject);
-}
-extern "C" JSC::EncodedJSValue Bun__ERR_IPC_CHANNEL_CLOSED(JSC::JSGlobalObject* globalObject)
 {
     return JSC::JSValue::encode(createError(globalObject, ErrorCode::ERR_IPC_CHANNEL_CLOSED, "Channel closed."_s));
 }
@@ -487,6 +576,44 @@ JSC_DEFINE_HOST_FUNCTION(jsFunction_ERR_INVALID_ARG_TYPE, (JSC::JSGlobalObject *
     return JSValue::encode(ERR_INVALID_ARG_TYPE(scope, globalObject, arg_name, expected_type, actual_value));
 }
 
+JSC_DEFINE_HOST_FUNCTION(jsFunction_ERR_BROTLI_INVALID_PARAM, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    JSC::VM& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    EXPECT_ARG_COUNT(1);
+
+    auto param = callFrame->argument(0).toWTFString(globalObject);
+    RETURN_IF_EXCEPTION(scope, {});
+
+    auto message = makeString(param, " is not a valid Brotli parameter"_s);
+    return JSC::JSValue::encode(createError(globalObject, ErrorCode::ERR_BROTLI_INVALID_PARAM, message));
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunction_ERR_BUFFER_TOO_LARGE, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    JSC::VM& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    EXPECT_ARG_COUNT(1);
+
+    auto param = callFrame->argument(0).toWTFString(globalObject);
+    RETURN_IF_EXCEPTION(scope, {});
+
+    auto message = makeString("Cannot create a Buffer larger than "_s, param, " bytes"_s);
+    return JSC::JSValue::encode(createError(globalObject, ErrorCode::ERR_BUFFER_TOO_LARGE, message));
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunction_ERR_ZLIB_INITIALIZATION_FAILED, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    return JSC::JSValue::encode(createError(globalObject, ErrorCode::ERR_ZLIB_INITIALIZATION_FAILED, "Initialization failed"_s));
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunction_ERR_BUFFER_OUT_OF_BOUNDS, (JSC::JSGlobalObject * globalObject, JSC::CallFrame*))
+{
+    return JSC::JSValue::encode(createError(globalObject, ErrorCode::ERR_BUFFER_OUT_OF_BOUNDS, "Attempt to access memory outside buffer bounds"_s));
+}
+
 } // namespace Bun
 
 JSC::JSValue WebCore::toJS(JSC::JSGlobalObject* globalObject, CommonAbortReason abortReason)
diff --git a/src/bun.js/bindings/ErrorCode.h b/src/bun.js/bindings/ErrorCode.h
index 4e2d1d6010..39c1d0f963 100644
--- a/src/bun.js/bindings/ErrorCode.h
+++ b/src/bun.js/bindings/ErrorCode.h
@@ -63,5 +63,34 @@ JSC_DECLARE_HOST_FUNCTION(jsFunction_ERR_IPC_CHANNEL_CLOSED);
 JSC_DECLARE_HOST_FUNCTION(jsFunction_ERR_SOCKET_BAD_TYPE);
 JSC_DECLARE_HOST_FUNCTION(jsFunction_ERR_INVALID_PROTOCOL);
 JSC_DECLARE_HOST_FUNCTION(jsFunctionMakeErrorWithCode);
+JSC_DECLARE_HOST_FUNCTION(jsFunction_ERR_BROTLI_INVALID_PARAM);
+JSC_DECLARE_HOST_FUNCTION(jsFunction_ERR_BUFFER_TOO_LARGE);
+JSC_DECLARE_HOST_FUNCTION(jsFunction_ERR_ZLIB_INITIALIZATION_FAILED);
+JSC_DECLARE_HOST_FUNCTION(jsFunction_ERR_BUFFER_OUT_OF_BOUNDS);
+
+enum Bound {
+    LOWER,
+    UPPER,
+};
+
+namespace ERR {
+
+JSC::EncodedJSValue INVALID_ARG_TYPE(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, const WTF::String& val_arg_name, const WTF::String& val_expected_type, JSC::JSValue val_actual_value);
+JSC::EncodedJSValue INVALID_ARG_TYPE(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, JSC::JSValue val_arg_name, const WTF::String& val_expected_type, JSC::JSValue val_actual_value);
+JSC::EncodedJSValue OUT_OF_RANGE(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, const WTF::String& arg_name, size_t lower, size_t upper, JSC::JSValue actual);
+JSC::EncodedJSValue OUT_OF_RANGE(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, JSC::JSValue arg_name, size_t lower, size_t upper, JSC::JSValue actual);
+JSC::EncodedJSValue OUT_OF_RANGE(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, JSC::JSValue arg_name_val, size_t bound_num, Bound bound, JSC::JSValue actual);
+JSC::EncodedJSValue OUT_OF_RANGE(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, JSC::JSValue arg_name_val, const WTF::String& msg, JSC::JSValue actual);
+JSC::EncodedJSValue OUT_OF_RANGE(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, const WTF::String& arg_name_val, const WTF::String& msg, JSC::JSValue actual);
+JSC::EncodedJSValue INVALID_ARG_VALUE(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, const WTF::String& name, JSC::JSValue value, const WTF::String& reason = "is invalid"_s);
+JSC::EncodedJSValue INVALID_ARG_VALUE(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, JSC::JSValue name, JSC::JSValue value, const WTF::String& reason = "is invalid"_s);
+JSC::EncodedJSValue UNKNOWN_ENCODING(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, const WTF::String& encoding);
+JSC::EncodedJSValue INVALID_STATE(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, const WTF::String& statemsg);
+JSC::EncodedJSValue STRING_TOO_LONG(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject);
+JSC::EncodedJSValue BUFFER_OUT_OF_BOUNDS(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject);
+JSC::EncodedJSValue UNKNOWN_SIGNAL(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, JSC::JSValue signal, bool triedUppercase = false);
+JSC::EncodedJSValue SOCKET_BAD_PORT(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, JSC::JSValue name, JSC::JSValue port, bool allowZero);
+
+}
 
 }
diff --git a/src/bun.js/bindings/ErrorCode.ts b/src/bun.js/bindings/ErrorCode.ts
index c8519af883..a2184f7215 100644
--- a/src/bun.js/bindings/ErrorCode.ts
+++ b/src/bun.js/bindings/ErrorCode.ts
@@ -13,9 +13,6 @@ export default [
   ["ABORT_ERR", Error, "AbortError"],
   ["ERR_CRYPTO_INVALID_DIGEST", TypeError, "TypeError"],
   ["ERR_ENCODING_INVALID_ENCODED_DATA", TypeError, "TypeError"],
-  ["ERR_HTTP2_INVALID_HEADER_VALUE", TypeError, "TypeError"],
-  ["ERR_HTTP2_INVALID_PSEUDOHEADER", TypeError, "TypeError"],
-  ["ERR_HTTP2_INVALID_SINGLE_VALUE_HEADER", TypeError, "TypeError"],
   ["ERR_INVALID_ARG_TYPE", TypeError, "TypeError"],
   ["ERR_INVALID_ARG_VALUE", TypeError, "TypeError"],
   ["ERR_INVALID_PROTOCOL", TypeError, "TypeError"],
@@ -42,10 +39,46 @@ export default [
   ["ERR_ILLEGAL_CONSTRUCTOR", TypeError, "TypeError"],
   ["ERR_INVALID_URL", TypeError, "TypeError"],
   ["ERR_BUFFER_TOO_LARGE", RangeError, "RangeError"],
+  ["ERR_BROTLI_INVALID_PARAM", RangeError, "RangeError"],
+  ["ERR_UNKNOWN_ENCODING", TypeError, "TypeError"],
+  ["ERR_INVALID_STATE", Error, "Error"],
+  ["ERR_BUFFER_OUT_OF_BOUNDS", RangeError, "RangeError"],
+  ["ERR_UNKNOWN_SIGNAL", TypeError, "TypeError"],
+  ["ERR_SOCKET_BAD_PORT", RangeError, "RangeError"],
+  ["ERR_STREAM_RELEASE_LOCK", Error, "AbortError"],
 
   // Bun-specific
   ["ERR_FORMDATA_PARSE_ERROR", TypeError, "TypeError"],
   ["ERR_BODY_ALREADY_USED", Error, "Error"],
   ["ERR_STREAM_WRAP", Error, "Error"],
   ["ERR_BORINGSSL", Error, "Error"],
+
+  //NET
+  ["ERR_SOCKET_CLOSED_BEFORE_CONNECTION", Error, "Error"],
+  ["ERR_SOCKET_CLOSED", Error, "Error"],
+  //HTTP2
+  ["ERR_INVALID_HTTP_TOKEN", TypeError, "TypeError"],
+  ["ERR_HTTP2_PSEUDOHEADER_NOT_ALLOWED", TypeError, "TypeError"],
+  ["ERR_HTTP2_SEND_FILE", Error, "Error"],
+  ["ERR_HTTP2_SEND_FILE_NOSEEK", Error, "Error"],
+  ["ERR_HTTP2_HEADERS_SENT", Error, "ERR_HTTP2_HEADERS_SENT"],
+  ["ERR_HTTP2_INFO_STATUS_NOT_ALLOWED", RangeError, "RangeError"],
+  ["ERR_HTTP2_STATUS_INVALID", RangeError, "RangeError"],
+  ["ERR_HTTP2_INVALID_PSEUDOHEADER", TypeError, "TypeError"],
+  ["ERR_HTTP2_INVALID_HEADER_VALUE", TypeError, "TypeError"],
+  ["ERR_HTTP2_PING_CANCEL", Error, "Error"],
+  ["ERR_HTTP2_STREAM_ERROR", Error, "Error"],
+  ["ERR_HTTP2_INVALID_SINGLE_VALUE_HEADER", TypeError, "TypeError"],
+  ["ERR_HTTP2_SESSION_ERROR", Error, "Error"],
+  ["ERR_HTTP2_INVALID_SESSION", Error, "Error"],
+  ["ERR_HTTP2_INVALID_HEADERS", Error, "Error"],
+  ["ERR_HTTP2_PING_LENGTH", RangeError, "RangeError"],
+  ["ERR_HTTP2_INVALID_STREAM", Error, "Error"],
+  ["ERR_HTTP2_TRAILERS_ALREADY_SENT", Error, "Error"],
+  ["ERR_HTTP2_TRAILERS_NOT_READY", Error, "Error"],
+  ["ERR_HTTP2_PAYLOAD_FORBIDDEN", Error, "Error"],
+  ["ERR_HTTP2_NO_SOCKET_MANIPULATION", Error, "Error"],
+  ["ERR_HTTP2_SOCKET_UNBOUND", Error, "Error"],
+  ["ERR_HTTP2_ERROR", Error, "Error"],
+  ["ERR_HTTP2_OUT_OF_STREAMS", Error, "Error"],
 ] as ErrorCodeMapping;
diff --git a/src/bun.js/bindings/ErrorStackFrame.cpp b/src/bun.js/bindings/ErrorStackFrame.cpp
index 98fe90acf6..806a340be2 100644
--- a/src/bun.js/bindings/ErrorStackFrame.cpp
+++ b/src/bun.js/bindings/ErrorStackFrame.cpp
@@ -22,7 +22,15 @@ void adjustPositionBackwards(ZigStackFramePosition& pos, int amount, CodeBlock*
 
     pos.column_zero_based = pos.column_zero_based - amount;
     if (pos.column_zero_based < 0) {
-        auto source = code->source().provider()->source();
+        auto* provider = code->source().provider();
+        if (!provider) {
+            pos.line_zero_based = 0;
+            pos.column_zero_based = 0;
+            pos.byte_position = 0;
+            return;
+        }
+
+        auto source = provider->source();
         if (!source.is8Bit()) {
             // Debug-only assertion
             // Bun does not yet use 16-bit sources anywhere. The transpiler ensures everything
@@ -75,6 +83,8 @@ ZigStackFramePosition getAdjustedPositionForBytecode(JSC::CodeBlock* code, JSC::
     switch (inst->opcodeID()) {
     case op_construct:
     case op_construct_varargs:
+    case op_super_construct:
+    case op_super_construct_varargs:
         // The divot by default is pointing at the `(` or the end of the class name.
         // We want to point at the `new` keyword, which is conveniently at the
         // expression start.
@@ -88,4 +98,4 @@ ZigStackFramePosition getAdjustedPositionForBytecode(JSC::CodeBlock* code, JSC::
     return pos;
 }
 
-} // namespace Bun
\ No newline at end of file
+} // namespace Bun
diff --git a/src/bun.js/bindings/ErrorStackTrace.cpp b/src/bun.js/bindings/ErrorStackTrace.cpp
index ae2e282c1d..c52da44fc7 100644
--- a/src/bun.js/bindings/ErrorStackTrace.cpp
+++ b/src/bun.js/bindings/ErrorStackTrace.cpp
@@ -16,6 +16,8 @@
 #include <JavaScriptCore/StackVisitor.h>
 #include <JavaScriptCore/NativeCallee.h>
 #include <wtf/IterationStatus.h>
+#include <JavaScriptCore/CodeBlock.h>
+#include <JavaScriptCore/FunctionCodeBlock.h>
 
 #include "ErrorStackFrame.h"
 
@@ -24,6 +26,69 @@ using namespace WebCore;
 
 namespace Zig {
 
+static ImplementationVisibility getImplementationVisibility(JSC::CodeBlock* codeBlock)
+{
+
+    if (auto* executable = codeBlock->ownerExecutable()) {
+        return executable->implementationVisibility();
+    }
+
+    return ImplementationVisibility::Public;
+}
+
+bool isImplementationVisibilityPrivate(JSC::StackVisitor& visitor)
+{
+    ImplementationVisibility implementationVisibility = [&]() -> ImplementationVisibility {
+        if (visitor->callee().isCell()) {
+            if (auto* callee = visitor->callee().asCell()) {
+                if (auto* jsFunction = jsDynamicCast<JSFunction*>(callee)) {
+                    if (auto* executable = jsFunction->executable())
+                        return executable->implementationVisibility();
+                }
+            }
+        }
+
+        if (auto* codeBlock = visitor->codeBlock()) {
+            return getImplementationVisibility(codeBlock);
+        }
+
+#if ENABLE(WEBASSEMBLY)
+        if (visitor->isNativeCalleeFrame())
+            return visitor->callee().asNativeCallee()->implementationVisibility();
+#endif
+
+        return ImplementationVisibility::Public;
+    }();
+
+    return implementationVisibility != ImplementationVisibility::Public;
+}
+
+bool isImplementationVisibilityPrivate(const JSC::StackFrame& frame)
+{
+    ImplementationVisibility implementationVisibility = [&]() -> ImplementationVisibility {
+
+#if ENABLE(WEBASSEMBLY)
+        if (frame.isWasmFrame())
+            return ImplementationVisibility::Public;
+#endif
+
+        if (auto* callee = frame.callee()) {
+            if (auto* jsFunction = jsDynamicCast<JSFunction*>(callee)) {
+                if (auto* executable = jsFunction->executable())
+                    return executable->implementationVisibility();
+            }
+        }
+
+        if (auto* codeBlock = frame.codeBlock()) {
+            return getImplementationVisibility(codeBlock);
+        }
+
+        return ImplementationVisibility::Public;
+    }();
+
+    return implementationVisibility != ImplementationVisibility::Public;
+}
+
 JSCStackTrace JSCStackTrace::fromExisting(JSC::VM& vm, const WTF::Vector<JSC::StackFrame>& existingFrames)
 {
     WTF::Vector<JSCStackFrame> newFrames;
@@ -35,41 +100,155 @@ JSCStackTrace JSCStackTrace::fromExisting(JSC::VM& vm, const WTF::Vector<JSC::St
 
     newFrames.reserveInitialCapacity(frameCount);
     for (size_t i = 0; i < frameCount; i++) {
-        newFrames.constructAndAppend(vm, existingFrames.at(i));
+        if (!isImplementationVisibilityPrivate(existingFrames.at(i))) {
+            newFrames.constructAndAppend(vm, existingFrames.at(i));
+        }
     }
 
     return JSCStackTrace(newFrames);
 }
 
-static bool isImplementationVisibilityPrivate(JSC::StackVisitor& visitor)
+void JSCStackTrace::getFramesForCaller(JSC::VM& vm, JSC::CallFrame* callFrame, JSC::JSCell* owner, JSC::JSValue caller, WTF::Vector<JSC::StackFrame>& stackTrace, size_t stackTraceLimit)
 {
-    ImplementationVisibility implementationVisibility = [&]() -> ImplementationVisibility {
-        if (auto* codeBlock = visitor->codeBlock()) {
-            if (auto* executable = codeBlock->ownerExecutable()) {
-                return executable->implementationVisibility();
-            }
-            return ImplementationVisibility::Public;
+    size_t framesCount = 0;
+
+    bool belowCaller = false;
+    int32_t skipFrames = 0;
+
+    WTF::String callerName {};
+    if (JSC::JSFunction* callerFunction = JSC::jsDynamicCast<JSC::JSFunction*>(caller)) {
+        callerName = callerFunction->name(vm);
+        if (callerName.isEmpty() && callerFunction->jsExecutable()) {
+            callerName = callerFunction->jsExecutable()->name().string();
         }
+    }
+    if (JSC::InternalFunction* callerFunctionInternal = JSC::jsDynamicCast<JSC::InternalFunction*>(caller)) {
+        callerName = callerFunctionInternal->name();
+    }
 
-#if ENABLE(WEBASSEMBLY)
-        if (visitor->isNativeCalleeFrame())
-            return visitor->callee().asNativeCallee()->implementationVisibility();
-#endif
+    size_t totalFrames = 0;
 
-        if (visitor->callee().isCell()) {
-            if (auto* callee = visitor->callee().asCell()) {
-                if (auto* jsFunction = jsDynamicCast<JSFunction*>(callee)) {
-                    if (auto* executable = jsFunction->executable())
-                        return executable->implementationVisibility();
-                    return ImplementationVisibility::Public;
+    if (!callerName.isEmpty()) {
+        JSC::StackVisitor::visit(callFrame, vm, [&](JSC::StackVisitor& visitor) -> WTF::IterationStatus {
+            if (isImplementationVisibilityPrivate(visitor)) {
+                return WTF::IterationStatus::Continue;
+            }
+
+            framesCount += 1;
+
+            // skip caller frame and all frames above it
+            if (!belowCaller) {
+                skipFrames += 1;
+
+                if (visitor->functionName() == callerName) {
+                    belowCaller = true;
+                    return WTF::IterationStatus::Continue;
                 }
             }
+
+            totalFrames += 1;
+
+            if (totalFrames > stackTraceLimit) {
+                return WTF::IterationStatus::Done;
+            }
+
+            return WTF::IterationStatus::Continue;
+        });
+    } else if (caller && caller.isCell()) {
+        JSC::StackVisitor::visit(callFrame, vm, [&](JSC::StackVisitor& visitor) -> WTF::IterationStatus {
+            if (isImplementationVisibilityPrivate(visitor)) {
+                return WTF::IterationStatus::Continue;
+            }
+
+            framesCount += 1;
+
+            // skip caller frame and all frames above it
+            if (!belowCaller) {
+                auto callee = visitor->callee();
+                skipFrames += 1;
+                if (callee.isCell() && callee.asCell() == caller) {
+                    belowCaller = true;
+                    return WTF::IterationStatus::Continue;
+                }
+            }
+
+            totalFrames += 1;
+
+            if (totalFrames > stackTraceLimit) {
+                return WTF::IterationStatus::Done;
+            }
+
+            return WTF::IterationStatus::Continue;
+        });
+    } else if (caller.isEmpty() || caller.isUndefined()) {
+        // Skip the first frame.
+        JSC::StackVisitor::visit(callFrame, vm, [&](JSC::StackVisitor& visitor) -> WTF::IterationStatus {
+            if (isImplementationVisibilityPrivate(visitor)) {
+                return WTF::IterationStatus::Continue;
+            }
+
+            framesCount += 1;
+
+            if (!belowCaller) {
+                skipFrames += 1;
+                belowCaller = true;
+            }
+
+            totalFrames += 1;
+
+            if (totalFrames > stackTraceLimit) {
+                return WTF::IterationStatus::Done;
+            }
+
+            return WTF::IterationStatus::Continue;
+        });
+    }
+    size_t i = 0;
+    totalFrames = 0;
+    stackTrace.reserveInitialCapacity(framesCount);
+    JSC::StackVisitor::visit(callFrame, vm, [&](JSC::StackVisitor& visitor) -> WTF::IterationStatus {
+        // Skip native frames
+        if (isImplementationVisibilityPrivate(visitor)) {
+            return WTF::IterationStatus::Continue;
         }
 
-        return ImplementationVisibility::Public;
-    }();
+        // Skip frames if needed
+        if (skipFrames > 0) {
+            skipFrames--;
+            return WTF::IterationStatus::Continue;
+        }
 
-    return implementationVisibility != ImplementationVisibility::Public;
+        totalFrames += 1;
+
+        if (totalFrames > stackTraceLimit) {
+            return WTF::IterationStatus::Done;
+        }
+
+        if (visitor->isNativeCalleeFrame()) {
+
+            auto* nativeCallee = visitor->callee().asNativeCallee();
+            switch (nativeCallee->category()) {
+            case NativeCallee::Category::Wasm: {
+                stackTrace.append(StackFrame(visitor->wasmFunctionIndexOrName()));
+                break;
+            }
+            case NativeCallee::Category::InlineCache: {
+                break;
+            }
+            }
+#if USE(ALLOW_LINE_AND_COLUMN_NUMBER_IN_BUILTINS)
+        } else if (!!visitor->codeBlock())
+#else
+            } else if (!!visitor->codeBlock() && !visitor->codeBlock()->unlinkedCodeBlock()->isBuiltinFunction())
+#endif
+            stackTrace.append(StackFrame(vm, owner, visitor->callee().asCell(), visitor->codeBlock(), visitor->bytecodeIndex()));
+        else
+            stackTrace.append(StackFrame(vm, owner, visitor->callee().asCell()));
+
+        i++;
+
+        return (i == framesCount) ? WTF::IterationStatus::Done : WTF::IterationStatus::Continue;
+    });
 }
 
 JSCStackTrace JSCStackTrace::captureCurrentJSStackTrace(Zig::GlobalObject* globalObject, JSC::CallFrame* callFrame, size_t frameLimit, JSC::JSValue caller)
@@ -203,6 +382,22 @@ JSCStackTrace JSCStackTrace::getStackTraceForThrownValue(JSC::VM& vm, JSC::JSVal
     return fromExisting(vm, *jscStackTrace);
 }
 
+static bool isVisibleBuiltinFunction(JSC::CodeBlock* codeBlock)
+{
+    if (!codeBlock->ownerExecutable()) {
+        return false;
+    }
+
+    const JSC::SourceCode& source = codeBlock->source();
+    if (auto* provider = source.provider()) {
+        const auto& url = provider->sourceURL();
+        if (!url.isEmpty()) {
+            return true;
+        }
+    }
+    return false;
+}
+
 JSCStackFrame::JSCStackFrame(JSC::VM& vm, JSC::StackVisitor& visitor)
     : m_vm(vm)
     , m_codeBlock(nullptr)
@@ -228,9 +423,18 @@ JSCStackFrame::JSCStackFrame(JSC::VM& vm, JSC::StackVisitor& visitor)
             break;
         }
         }
-    } else if (!!visitor->codeBlock() && !visitor->codeBlock()->unlinkedCodeBlock()->isBuiltinFunction()) {
-        m_codeBlock = visitor->codeBlock();
-        m_bytecodeIndex = visitor->bytecodeIndex();
+    } else if (auto* codeBlock = visitor->codeBlock()) {
+        auto* unlinkedCodeBlock = codeBlock->unlinkedCodeBlock();
+        if (!unlinkedCodeBlock->isBuiltinFunction() || isVisibleBuiltinFunction(codeBlock)) {
+            m_codeBlock = codeBlock;
+            m_bytecodeIndex = visitor->bytecodeIndex();
+        }
+    }
+
+    if (!m_bytecodeIndex && visitor->hasLineAndColumnInfo()) {
+        auto lineColumn = visitor->computeLineAndColumn();
+        m_sourcePositions = { OrdinalNumber::fromOneBasedInt(lineColumn.line), OrdinalNumber::fromOneBasedInt(lineColumn.column) };
+        m_sourcePositionsState = SourcePositionsState::Calculated;
     }
 }
 
@@ -250,12 +454,19 @@ JSCStackFrame::JSCStackFrame(JSC::VM& vm, const JSC::StackFrame& frame)
     if (frame.isWasmFrame()) {
         m_wasmFunctionIndexOrName = frame.wasmFunctionIndexOrName();
         m_isWasmFrame = true;
-    } else {
-        m_codeBlock = frame.codeBlock();
-        if (frame.hasBytecodeIndex()) {
+    } else if (auto* codeBlock = frame.codeBlock()) {
+        auto* unlinkedCodeBlock = codeBlock->unlinkedCodeBlock();
+        if (!unlinkedCodeBlock->isBuiltinFunction() || isVisibleBuiltinFunction(codeBlock)) {
+            m_codeBlock = codeBlock;
             m_bytecodeIndex = frame.bytecodeIndex();
         }
     }
+
+    if (!m_codeBlock && frame.hasLineAndColumnInfo()) {
+        auto lineColumn = frame.computeLineAndColumn();
+        m_sourcePositions = { OrdinalNumber::fromOneBasedInt(lineColumn.line), OrdinalNumber::fromOneBasedInt(lineColumn.column) };
+        m_sourcePositionsState = SourcePositionsState::Calculated;
+    }
 }
 
 intptr_t JSCStackFrame::sourceID() const
@@ -308,16 +519,36 @@ ALWAYS_INLINE String JSCStackFrame::retrieveSourceURL()
         return String(sourceURLWasmString);
     }
 
+    if (m_callee && m_callee->isObject()) {
+        if (auto* jsFunction = jsDynamicCast<JSFunction*>(m_callee)) {
+            if (auto* executable = jsFunction->executable()) {
+                if (!executable->isHostFunction()) {
+                    auto* jsExectuable = jsFunction->jsExecutable();
+                    if (jsExectuable) {
+                        const auto* sourceProvider = jsExectuable->source().provider();
+                        if (sourceProvider) {
+                            return sourceProvider->sourceURL();
+                        }
+                    }
+                }
+            }
+        }
+    }
+
     if (!m_codeBlock) {
         return String(sourceURLNativeString);
     }
 
-    return m_codeBlock->ownerExecutable()->sourceURL();
+    auto* provider = m_codeBlock->source().provider();
+    if (provider) {
+        return provider->sourceURL();
+    }
+
+    return String();
 }
 
 ALWAYS_INLINE String JSCStackFrame::retrieveFunctionName()
 {
-    static auto functionNameEvalCodeString = MAKE_STATIC_STRING_IMPL("eval code");
     static auto functionNameModuleCodeString = MAKE_STATIC_STRING_IMPL("module code");
     static auto functionNameGlobalCodeString = MAKE_STATIC_STRING_IMPL("global code");
 
@@ -328,7 +559,8 @@ ALWAYS_INLINE String JSCStackFrame::retrieveFunctionName()
     if (m_codeBlock) {
         switch (m_codeBlock->codeType()) {
         case JSC::EvalCode:
-            return String(functionNameEvalCodeString);
+            // Node returns null here.
+            return String();
         case JSC::ModuleCode:
             return String(functionNameModuleCodeString);
         case JSC::FunctionCode:
@@ -340,13 +572,26 @@ ALWAYS_INLINE String JSCStackFrame::retrieveFunctionName()
         }
     }
 
-    String name;
     if (m_callee) {
-        if (m_callee->isObject())
-            name = getCalculatedDisplayName(m_vm, jsCast<JSObject*>(m_callee)).impl();
+        if (auto* callee = m_callee->getObject()) {
+            // Does the code block have a user-defined name property?
+            JSC::JSValue name = callee->getDirect(m_vm, m_vm.propertyNames->name);
+            if (name && name.isString()) {
+                auto scope = DECLARE_CATCH_SCOPE(m_vm);
+                auto nameString = name.toWTFString(callee->globalObject());
+                if (scope.exception()) {
+                    scope.clearException();
+                }
+                if (!nameString.isEmpty()) {
+                    return nameString;
+                }
+            }
+
+            return JSC::getCalculatedDisplayName(m_vm, callee);
+        }
     }
 
-    return name.isNull() ? emptyString() : name;
+    return emptyString();
 }
 
 ALWAYS_INLINE String JSCStackFrame::retrieveTypeName()
diff --git a/src/bun.js/bindings/ErrorStackTrace.h b/src/bun.js/bindings/ErrorStackTrace.h
index e33cc18a6e..8939059c93 100644
--- a/src/bun.js/bindings/ErrorStackTrace.h
+++ b/src/bun.js/bindings/ErrorStackTrace.h
@@ -46,13 +46,13 @@ public:
 
 private:
     JSC::VM& m_vm;
-    JSC::JSCell* m_callee;
+    JSC::JSCell* m_callee { nullptr };
 
     // May be null
     JSC::CallFrame* m_callFrame;
 
     // May be null
-    JSC::CodeBlock* m_codeBlock;
+    JSC::CodeBlock* m_codeBlock { nullptr };
     JSC::BytecodeIndex m_bytecodeIndex;
 
     // Lazy-initialized
@@ -96,8 +96,40 @@ public:
     SourcePositions* getSourcePositions();
 
     bool isWasmFrame() const { return m_isWasmFrame; }
-    bool isEval() const { return m_codeBlock && (JSC::EvalCode == m_codeBlock->codeType()); }
-    bool isConstructor() const { return m_codeBlock && (JSC::CodeForConstruct == m_codeBlock->specializationKind()); }
+    bool isEval()
+    {
+        if (m_codeBlock) {
+            if (m_codeBlock->codeType() == JSC::EvalCode) {
+                return true;
+            }
+            auto* executable = m_codeBlock->ownerExecutable();
+            if (!executable) {
+                return false;
+            }
+
+            switch (executable->evalContextType()) {
+            case JSC::EvalContextType::None: {
+                return false;
+            }
+            case JSC::EvalContextType::FunctionEvalContext:
+            case JSC::EvalContextType::InstanceFieldEvalContext:
+                return true;
+            }
+        }
+
+        if (m_callee && m_callee->inherits<JSC::JSFunction>()) {
+            auto* function = jsCast<JSC::JSFunction*>(m_callee);
+            if (function->isHostFunction()) {
+                return false;
+            }
+        }
+
+        return false;
+    }
+    bool isConstructor() const
+    {
+        return m_codeBlock && (JSC::CodeForConstruct == m_codeBlock->specializationKind());
+    }
 
 private:
     ALWAYS_INLINE String retrieveSourceURL();
@@ -130,10 +162,17 @@ public:
     {
     }
 
+    JSCStackTrace(WTF::Vector<JSCStackFrame>&& frames)
+        : m_frames(WTFMove(frames))
+    {
+    }
+
     size_t size() const { return m_frames.size(); }
     bool isEmpty() const { return m_frames.isEmpty(); }
     JSCStackFrame& at(size_t i) { return m_frames.at(i); }
 
+    WTF::Vector<JSCStackFrame>&& frames() { return WTFMove(m_frames); }
+
     static JSCStackTrace fromExisting(JSC::VM& vm, const WTF::Vector<JSC::StackFrame>& existingFrames);
 
     /* This is based on JSC::Interpreter::getStackTrace, but skips native (non js and not wasm)
@@ -145,6 +184,7 @@ public:
      *
      * Return value must remain stack allocated. */
     static JSCStackTrace captureCurrentJSStackTrace(Zig::GlobalObject* globalObject, JSC::CallFrame* callFrame, size_t frameLimit, JSC::JSValue caller);
+    static void getFramesForCaller(JSC::VM& vm, JSC::CallFrame* callFrame, JSC::JSCell* owner, JSC::JSValue caller, WTF::Vector<JSC::StackFrame>& stackTrace, size_t stackTraceLimit);
 
     /* In JSC, JSC::Exception points to the actual value that was thrown, usually
      * a JSC::ErrorInstance (but could be any JSValue). In v8, on the other hand,
@@ -171,4 +211,6 @@ private:
     }
 };
 
+bool isImplementationVisibilityPrivate(JSC::StackVisitor& visitor);
+bool isImplementationVisibilityPrivate(const JSC::StackFrame& frame);
 }
diff --git a/src/bun.js/bindings/EventLoopTask.h b/src/bun.js/bindings/EventLoopTask.h
index 965a36adc0..8461ac17dd 100644
--- a/src/bun.js/bindings/EventLoopTask.h
+++ b/src/bun.js/bindings/EventLoopTask.h
@@ -41,4 +41,4 @@ protected:
     bool m_isCleanupTask;
 };
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/ExposeNodeModuleGlobals.cpp b/src/bun.js/bindings/ExposeNodeModuleGlobals.cpp
index d8723e2ba9..0497c1c6a6 100644
--- a/src/bun.js/bindings/ExposeNodeModuleGlobals.cpp
+++ b/src/bun.js/bindings/ExposeNodeModuleGlobals.cpp
@@ -48,38 +48,38 @@
     v(worker_threads,         Bun::InternalModuleRegistry::NodeWorkerThreads) \
     v(zlib,                   Bun::InternalModuleRegistry::NodeZlib) \
 
-#define FOREACH_EXPOSED_BUILTIN_NATIVE(v) \
-    v(constants,              SyntheticModuleType::NodeConstants) \
-    v(string_decoder,         SyntheticModuleType::NodeStringDecoder) \
-    v(buffer,                 SyntheticModuleType::NodeBuffer) \
-    v(jsc,                    SyntheticModuleType::BunJSC) \
+
 
 namespace ExposeNodeModuleGlobalGetters {
 
 #define DECL_GETTER(id, field) \
     JSC_DEFINE_CUSTOM_GETTER(id, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::EncodedJSValue thisValue, JSC::PropertyName)) \
     { \
-        Zig::GlobalObject* thisObject = JSC::jsCast<Zig::GlobalObject*>(lexicalGlobalObject); \
+        Zig::GlobalObject* thisObject = defaultGlobalObject(lexicalGlobalObject); \
         JSC::VM& vm = thisObject->vm(); \
         return JSC::JSValue::encode(thisObject->internalModuleRegistry()->requireId(thisObject, vm, field)); \
     }
 FOREACH_EXPOSED_BUILTIN_IMR(DECL_GETTER)
-#undef DECL_GETTER
+#undef DECL_GETTER    
 
-#define DECL_GETTER(id, field) \
-    JSC_DEFINE_CUSTOM_GETTER(id, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::EncodedJSValue thisValue, JSC::PropertyName)) \
-    { \
-        Zig::GlobalObject* globalObject = jsCast<Zig::GlobalObject*>(lexicalGlobalObject); \
-        JSC::VM& vm = globalObject->vm(); \
-        auto& builtinNames = WebCore::builtinNames(vm); \
-        JSC::JSFunction* function = jsCast<JSC::JSFunction*>(globalObject->getDirect(vm, builtinNames.requireNativeModulePrivateName())); \
-        JSC::MarkedArgumentBuffer arguments = JSC::MarkedArgumentBuffer(); \
-        arguments.append(JSC::jsString(vm, WTF::String(#id##_s))); \
-        auto callData = JSC::getCallData(function); \
-        return JSC::JSValue::encode(call(globalObject, function, callData, JSC::jsUndefined(), arguments)); \
-    }
-FOREACH_EXPOSED_BUILTIN_NATIVE(DECL_GETTER)
-#undef DECL_GETTER
+
+JSC_DEFINE_CUSTOM_GETTER(jsCustomGetterGetNativeModule, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::EncodedJSValue thisValue, JSC::PropertyName propertyName))
+{
+    Zig::GlobalObject* globalObject = defaultGlobalObject(lexicalGlobalObject); 
+    JSC::VM& vm = globalObject->vm(); 
+    
+    JSC::JSValue key = JSC::identifierToJSValue(vm, propertyName == "jsc"_s ? JSC::Identifier::fromString(vm, "bun:jsc"_s) : JSC::Identifier::fromUid(vm, propertyName.uid())); 
+    JSC::JSValue result = globalObject->requireMap()->get(globalObject, key); 
+    if (!result || result.isUndefinedOrNull()) { 
+        auto& builtinNames = WebCore::builtinNames(vm); 
+        JSC::JSFunction* function = jsCast<JSC::JSFunction*>(globalObject->getDirect(vm, builtinNames.requireNativeModulePrivateName())); 
+        JSC::MarkedArgumentBuffer arguments = JSC::MarkedArgumentBuffer(); 
+        arguments.append(key); 
+        auto callData = JSC::getCallData(function); 
+        return JSC::JSValue::encode(call(globalObject, function, callData, JSC::jsUndefined(), arguments)); 
+    } 
+    return JSC::JSValue::encode(result); 
+}
 
 } // namespace ExposeNodeModuleGlobalGetters
 
@@ -95,11 +95,32 @@ extern "C" void Bun__ExposeNodeModuleGlobals(Zig::GlobalObject* globalObject)
             vm, \
             ExposeNodeModuleGlobalGetters::id, \
             nullptr), \
-        0 | JSC::PropertyAttribute::CustomAccessorOrValue \
+        0 | JSC::PropertyAttribute::CustomValue \
     );
 
     FOREACH_EXPOSED_BUILTIN_IMR(PUT_CUSTOM_GETTER_SETTER)
-    // FOREACH_EXPOSED_BUILTIN_NATIVE(PUT_CUSTOM_GETTER_SETTER)
 #undef PUT_CUSTOM_GETTER_SETTER
 
+
+    JSC::CustomGetterSetter *nativeModuleGetter = JSC::CustomGetterSetter::create(
+        vm,
+        ExposeNodeModuleGlobalGetters::jsCustomGetterGetNativeModule,
+        nullptr
+    );
+
+    static constexpr ASCIILiteral nativeModuleNames[] = {
+        "constants"_s,
+        "string_decoder"_s,
+        "buffer"_s,
+        "jsc"_s,
+    };
+
+    for (auto name : nativeModuleNames) {
+        globalObject->putDirectCustomAccessor(
+            vm,
+            JSC::Identifier::fromString(vm, name),
+            nativeModuleGetter,
+            0 | JSC::PropertyAttribute::CustomValue
+        );
+    }
 }
diff --git a/src/bun.js/bindings/GCDefferalContext.h b/src/bun.js/bindings/GCDefferalContext.h
index 7bedfb3e0d..802f63033e 100644
--- a/src/bun.js/bindings/GCDefferalContext.h
+++ b/src/bun.js/bindings/GCDefferalContext.h
@@ -18,4 +18,4 @@ ALWAYS_INLINE GCDeferralContext::~GCDeferralContext()
         m_vm.heap.collectIfNecessaryOrDefer();
 }
 
-} // namespace JSC
\ No newline at end of file
+} // namespace JSC
diff --git a/src/bun.js/bindings/IDLTypes.h b/src/bun.js/bindings/IDLTypes.h
index 8eccb08f4e..3ebea7e596 100644
--- a/src/bun.js/bindings/IDLTypes.h
+++ b/src/bun.js/bindings/IDLTypes.h
@@ -414,4 +414,4 @@ template<typename T>
 struct IsIDLArrayBufferViewAllowShared : public std::integral_constant<bool, std::is_base_of<IDLAllowSharedAdaptor<IDLArrayBufferView>, T>::value> {
 };
 
-} // namespace WebCore
\ No newline at end of file
+} // namespace WebCore
diff --git a/src/bun.js/bindings/ImportMetaObject.cpp b/src/bun.js/bindings/ImportMetaObject.cpp
index 74473f7bf1..61b64f0229 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));
@@ -303,31 +305,34 @@ extern "C" JSC::EncodedJSValue functionImportMeta__resolveSyncPrivate(JSC::JSGlo
 
     if (!isESM) {
         if (LIKELY(globalObject)) {
-            auto overrideHandler = globalObject->m_nodeModuleOverriddenResolveFilename.get();
-            if (UNLIKELY(overrideHandler)) {
-                ASSERT(overrideHandler->isCallable());
-                JSValue parentModuleObject = globalObject->requireMap()->get(globalObject, from);
+            if (UNLIKELY(globalObject->hasOverridenModuleResolveFilenameFunction)) {
+                auto overrideHandler = jsCast<JSObject*>(globalObject->m_moduleResolveFilenameFunction.getInitializedOnMainThread(globalObject));
+                if (UNLIKELY(overrideHandler)) {
+                    ASSERT(overrideHandler->isCallable());
+                    JSValue parentModuleObject = globalObject->requireMap()->get(globalObject, from);
 
-                JSValue parentID = jsUndefined();
-                if (auto* parent = jsDynamicCast<Bun::JSCommonJSModule*>(parentModuleObject)) {
-                    parentID = parent->id();
-                } else {
-                    parentID = from;
+                    JSValue parentID = jsUndefined();
+                    if (auto* parent = jsDynamicCast<Bun::JSCommonJSModule*>(parentModuleObject)) {
+                        parentID = parent->id();
+                    } else {
+                        parentID = from;
+                    }
+
+                    MarkedArgumentBuffer args;
+                    args.append(moduleName);
+                    args.append(parentModuleObject);
+                    auto parentIdStr = parentID.toWTFString(globalObject);
+                    auto bunStr = Bun::toString(parentIdStr);
+                    args.append(jsBoolean(Bun__isBunMain(lexicalGlobalObject, &bunStr)));
+
+                    return JSValue::encode(JSC::call(lexicalGlobalObject, overrideHandler, JSC::getCallData(overrideHandler), parentModuleObject, args));
                 }
-
-                MarkedArgumentBuffer args;
-                args.append(moduleName);
-                args.append(parentModuleObject);
-                auto parentIdStr = parentID.toWTFString(globalObject);
-                auto bunStr = Bun::toString(parentIdStr);
-                args.append(jsBoolean(Bun__isBunMain(lexicalGlobalObject, &bunStr)));
-
-                return JSValue::encode(JSC::call(lexicalGlobalObject, overrideHandler, JSC::getCallData(overrideHandler), parentModuleObject, args));
             }
         }
     }
 
     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));
@@ -424,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 {};
@@ -482,6 +489,24 @@ JSC_DEFINE_CUSTOM_GETTER(jsImportMetaObjectGetter_require, (JSGlobalObject * glo
     return JSValue::encode(thisObject->requireProperty.getInitializedOnMainThread(thisObject));
 }
 
+// https://github.com/oven-sh/bun/issues/11754#issuecomment-2452626172
+// This setter exists mainly to support various libraries doing weird things wrapping the require function.
+JSC_DEFINE_CUSTOM_SETTER(jsImportMetaObjectSetter_require, (JSGlobalObject * jsGlobalObject, JSC::EncodedJSValue thisValue, JSC::EncodedJSValue encodedValue, PropertyName propertyName))
+{
+    ImportMetaObject* thisObject = jsDynamicCast<ImportMetaObject*>(JSValue::decode(thisValue));
+    if (UNLIKELY(!thisObject))
+        return false;
+
+    JSValue value = JSValue::decode(encodedValue);
+    if (!value.isCell()) {
+        // TODO:
+        return true;
+    }
+
+    thisObject->requireProperty.set(thisObject->vm(), thisObject, value.asCell());
+    return true;
+}
+
 JSC_DEFINE_CUSTOM_GETTER(jsImportMetaObjectGetter_env, (JSGlobalObject * jsGlobalObject, JSC::EncodedJSValue thisValue, PropertyName propertyName))
 {
     auto* globalObject = jsCast<Zig::GlobalObject*>(jsGlobalObject);
@@ -495,7 +520,7 @@ static const HashTableValue ImportMetaObjectPrototypeValues[] = {
     { "file"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, jsImportMetaObjectGetter_file, 0 } },
     { "filename"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, jsImportMetaObjectGetter_path, 0 } },
     { "path"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, jsImportMetaObjectGetter_path, 0 } },
-    { "require"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, jsImportMetaObjectGetter_require, 0 } },
+    { "require"_s, static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, jsImportMetaObjectGetter_require, jsImportMetaObjectSetter_require } },
     { "resolve"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, functionImportMeta__resolve, 0 } },
     { "resolveSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, functionImportMeta__resolveSync, 0 } },
     { "url"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, jsImportMetaObjectGetter_url, 0 } },
@@ -570,7 +595,7 @@ void ImportMetaObject::finishCreation(VM& vm)
     Base::finishCreation(vm);
     ASSERT(inherits(info()));
 
-    this->requireProperty.initLater([](const JSC::LazyProperty<JSC::JSObject, JSC::JSFunction>::Initializer& init) {
+    this->requireProperty.initLater([](const JSC::LazyProperty<JSC::JSObject, JSC::JSCell>::Initializer& init) {
         ImportMetaObject* meta = jsCast<ImportMetaObject*>(init.owner);
 
         WTF::URL url = isAbsolutePath(meta->url) ? WTF::URL::fileURLWithFileSystemPath(meta->url) : WTF::URL(meta->url);
diff --git a/src/bun.js/bindings/ImportMetaObject.h b/src/bun.js/bindings/ImportMetaObject.h
index 663df39682..078f8b6b8c 100644
--- a/src/bun.js/bindings/ImportMetaObject.h
+++ b/src/bun.js/bindings/ImportMetaObject.h
@@ -71,7 +71,7 @@ public:
     static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
 
     WTF::String url;
-    LazyProperty<JSObject, JSFunction> requireProperty;
+    LazyProperty<JSObject, JSCell> requireProperty;
     LazyProperty<JSObject, JSString> dirProperty;
     LazyProperty<JSObject, JSString> urlProperty;
     LazyProperty<JSObject, JSString> fileProperty;
diff --git a/src/bun.js/bindings/InspectorLifecycleAgent.cpp b/src/bun.js/bindings/InspectorLifecycleAgent.cpp
new file mode 100644
index 0000000000..f65b1ffcd4
--- /dev/null
+++ b/src/bun.js/bindings/InspectorLifecycleAgent.cpp
@@ -0,0 +1,131 @@
+#include "InspectorLifecycleAgent.h"
+
+#include <JavaScriptCore/InspectorFrontendRouter.h>
+#include <JavaScriptCore/InspectorBackendDispatcher.h>
+#include <JavaScriptCore/JSGlobalObject.h>
+#include <wtf/text/WTFString.h>
+#include <JavaScriptCore/ScriptCallStackFactory.h>
+#include <JavaScriptCore/ScriptArguments.h>
+#include <JavaScriptCore/ConsoleMessage.h>
+#include <JavaScriptCore/InspectorConsoleAgent.h>
+#include <JavaScriptCore/JSGlobalObjectDebuggable.h>
+#include <JavaScriptCore/JSGlobalObjectInspectorController.h>
+#include "ConsoleObject.h"
+
+namespace Inspector {
+
+// Zig bindings implementation
+extern "C" {
+
+void Bun__LifecycleAgentEnable(Inspector::InspectorLifecycleAgent* agent);
+void Bun__LifecycleAgentDisable(Inspector::InspectorLifecycleAgent* agent);
+
+void Bun__LifecycleAgentReportReload(Inspector::InspectorLifecycleAgent* agent)
+{
+    agent->reportReload();
+}
+
+void Bun__LifecycleAgentReportError(Inspector::InspectorLifecycleAgent* agent, ZigException* exception)
+{
+    ASSERT(exception);
+    ASSERT(agent);
+
+    agent->reportError(*exception);
+}
+
+void Bun__LifecycleAgentPreventExit(Inspector::InspectorLifecycleAgent* agent);
+void Bun__LifecycleAgentStopPreventingExit(Inspector::InspectorLifecycleAgent* agent);
+}
+
+InspectorLifecycleAgent::InspectorLifecycleAgent(JSC::JSGlobalObject& globalObject)
+    : InspectorAgentBase("LifecycleReporter"_s)
+    , m_globalObject(globalObject)
+    , m_backendDispatcher(LifecycleReporterBackendDispatcher::create(m_globalObject.inspectorController().backendDispatcher(), this))
+    , m_frontendDispatcher(makeUnique<LifecycleReporterFrontendDispatcher>(const_cast<FrontendRouter&>(m_globalObject.inspectorController().frontendRouter())))
+{
+}
+
+InspectorLifecycleAgent::~InspectorLifecycleAgent()
+{
+    if (m_enabled) {
+        Bun__LifecycleAgentDisable(this);
+    }
+}
+
+void InspectorLifecycleAgent::didCreateFrontendAndBackend(FrontendRouter*, BackendDispatcher*)
+{
+}
+
+void InspectorLifecycleAgent::willDestroyFrontendAndBackend(DisconnectReason)
+{
+    disable();
+}
+
+Protocol::ErrorStringOr<void> InspectorLifecycleAgent::enable()
+{
+    if (m_enabled)
+        return {};
+
+    m_enabled = true;
+    Bun__LifecycleAgentEnable(this);
+    return {};
+}
+
+Protocol::ErrorStringOr<void> InspectorLifecycleAgent::disable()
+{
+    if (!m_enabled)
+        return {};
+
+    m_enabled = false;
+    Bun__LifecycleAgentDisable(this);
+    return {};
+}
+
+void InspectorLifecycleAgent::reportReload()
+{
+    if (!m_enabled)
+        return;
+
+    m_frontendDispatcher->reload();
+}
+
+void InspectorLifecycleAgent::reportError(ZigException& exception)
+{
+    if (!m_enabled)
+        return;
+
+    String message = exception.message.toWTFString();
+    String name = exception.name.toWTFString();
+
+    Ref<JSON::ArrayOf<String>> urls = JSON::ArrayOf<String>::create();
+    Ref<JSON::ArrayOf<int>> lineColumns = JSON::ArrayOf<int>::create();
+    Ref<JSON::ArrayOf<String>> sourceLines = JSON::ArrayOf<String>::create();
+
+    for (size_t i = 0; i < exception.stack.source_lines_len; i++) {
+        sourceLines->addItem(exception.stack.source_lines_ptr[i].toWTFString());
+    }
+
+    for (size_t i = 0; i < exception.stack.frames_len; i++) {
+        ZigStackFrame* frame = &exception.stack.frames_ptr[i];
+        lineColumns->addItem(frame->position.line_zero_based + 1);
+        lineColumns->addItem(frame->position.column_zero_based + 1);
+        urls->addItem(frame->source_url.toWTFString());
+    }
+
+    // error(const String& message, const String& name, Ref<JSON::ArrayOf<String>>&& urls, Ref<JSON::ArrayOf<int>>&& lineColumns, Ref<JSON::ArrayOf<String>>&& sourceLines);
+    m_frontendDispatcher->error(WTFMove(message), WTFMove(name), WTFMove(urls), WTFMove(lineColumns), WTFMove(sourceLines));
+}
+
+Protocol::ErrorStringOr<void> InspectorLifecycleAgent::preventExit()
+{
+    m_preventingExit = true;
+    return {};
+}
+
+Protocol::ErrorStringOr<void> InspectorLifecycleAgent::stopPreventingExit()
+{
+    m_preventingExit = false;
+    return {};
+}
+
+} // namespace Inspector
diff --git a/src/bun.js/bindings/InspectorLifecycleAgent.h b/src/bun.js/bindings/InspectorLifecycleAgent.h
new file mode 100644
index 0000000000..5990b833f6
--- /dev/null
+++ b/src/bun.js/bindings/InspectorLifecycleAgent.h
@@ -0,0 +1,48 @@
+#pragma once
+
+#include "root.h"
+#include <JavaScriptCore/AlternateDispatchableAgent.h>
+#include <JavaScriptCore/InspectorAgentBase.h>
+#include <JavaScriptCore/InspectorBackendDispatchers.h>
+#include <JavaScriptCore/InspectorFrontendDispatchers.h>
+#include <JavaScriptCore/JSGlobalObject.h>
+#include <wtf/Forward.h>
+#include <wtf/Noncopyable.h>
+#include "headers-handwritten.h"
+namespace Inspector {
+
+class FrontendRouter;
+class BackendDispatcher;
+class LifecycleReporterFrontendDispatcher;
+enum class DisconnectReason;
+
+class InspectorLifecycleAgent final : public InspectorAgentBase, public Inspector::LifecycleReporterBackendDispatcherHandler {
+    WTF_MAKE_NONCOPYABLE(InspectorLifecycleAgent);
+
+public:
+    InspectorLifecycleAgent(JSC::JSGlobalObject&);
+    virtual ~InspectorLifecycleAgent();
+
+    // InspectorAgentBase
+    virtual void didCreateFrontendAndBackend(FrontendRouter*, BackendDispatcher*) final;
+    virtual void willDestroyFrontendAndBackend(DisconnectReason) final;
+
+    // LifecycleReporterBackendDispatcherHandler
+    virtual Protocol::ErrorStringOr<void> enable() final;
+    virtual Protocol::ErrorStringOr<void> disable() final;
+
+    // Public API
+    void reportReload();
+    void reportError(ZigException&);
+    Protocol::ErrorStringOr<void> preventExit();
+    Protocol::ErrorStringOr<void> stopPreventingExit();
+
+private:
+    JSC::JSGlobalObject& m_globalObject;
+    std::unique_ptr<LifecycleReporterFrontendDispatcher> m_frontendDispatcher;
+    Ref<LifecycleReporterBackendDispatcher> m_backendDispatcher;
+    bool m_enabled { false };
+    bool m_preventingExit { false };
+};
+
+} // namespace Inspector
diff --git a/src/bun.js/bindings/InspectorTestReporterAgent.cpp b/src/bun.js/bindings/InspectorTestReporterAgent.cpp
new file mode 100644
index 0000000000..dad53f2b54
--- /dev/null
+++ b/src/bun.js/bindings/InspectorTestReporterAgent.cpp
@@ -0,0 +1,210 @@
+#include "InspectorTestReporterAgent.h"
+
+#include <JavaScriptCore/InspectorFrontendRouter.h>
+#include <JavaScriptCore/InspectorBackendDispatcher.h>
+#include <JavaScriptCore/JSGlobalObject.h>
+#include <wtf/text/WTFString.h>
+#include <JavaScriptCore/ScriptCallStack.h>
+#include <JavaScriptCore/JSGlobalObjectDebuggable.h>
+#include <JavaScriptCore/JSGlobalObjectInspectorController.h>
+#include "ErrorStackTrace.h"
+#include "ZigGlobalObject.h"
+
+#include "ModuleLoader.h"
+
+namespace Inspector {
+
+// Zig bindings implementation
+extern "C" {
+
+void Bun__TestReporterAgentEnable(Inspector::InspectorTestReporterAgent* agent);
+void Bun__TestReporterAgentDisable(Inspector::InspectorTestReporterAgent* agent);
+
+void Bun__TestReporterAgentReportTestFound(Inspector::InspectorTestReporterAgent* agent, JSC::CallFrame* callFrame, int testId, BunString* name)
+{
+    auto str = name->toWTFString(BunString::ZeroCopy);
+    agent->reportTestFound(callFrame, testId, str);
+}
+
+void Bun__TestReporterAgentReportTestStart(Inspector::InspectorTestReporterAgent* agent, int testId)
+{
+    agent->reportTestStart(testId);
+}
+
+enum class BunTestStatus : uint8_t {
+    Pass,
+    Fail,
+    Timeout,
+    Skip,
+    Todo,
+};
+
+void Bun__TestReporterAgentReportTestEnd(Inspector::InspectorTestReporterAgent* agent, int testId, BunTestStatus bunTestStatus, double elapsed)
+{
+    Protocol::TestReporter::TestStatus status;
+    switch (bunTestStatus) {
+    case BunTestStatus::Pass:
+        status = Protocol::TestReporter::TestStatus::Pass;
+        break;
+    case BunTestStatus::Fail:
+        status = Protocol::TestReporter::TestStatus::Fail;
+        break;
+    case BunTestStatus::Timeout:
+        status = Protocol::TestReporter::TestStatus::Timeout;
+        break;
+    case BunTestStatus::Skip:
+        status = Protocol::TestReporter::TestStatus::Skip;
+        break;
+    case BunTestStatus::Todo:
+        status = Protocol::TestReporter::TestStatus::Todo;
+        break;
+    default:
+        ASSERT_NOT_REACHED();
+    }
+    agent->reportTestEnd(testId, status, elapsed);
+}
+}
+
+InspectorTestReporterAgent::InspectorTestReporterAgent(JSC::JSGlobalObject& globalObject)
+    : InspectorAgentBase("TestReporter"_s)
+    , m_globalObject(globalObject)
+    , m_backendDispatcher(TestReporterBackendDispatcher::create(m_globalObject.inspectorController().backendDispatcher(), this))
+    , m_frontendDispatcher(makeUnique<TestReporterFrontendDispatcher>(const_cast<FrontendRouter&>(m_globalObject.inspectorController().frontendRouter())))
+{
+}
+
+InspectorTestReporterAgent::~InspectorTestReporterAgent()
+{
+    if (m_enabled) {
+        Bun__TestReporterAgentDisable(this);
+    }
+}
+
+void InspectorTestReporterAgent::didCreateFrontendAndBackend(FrontendRouter* frontendRouter, BackendDispatcher* backendDispatcher)
+{
+    this->m_frontendDispatcher = makeUnique<TestReporterFrontendDispatcher>(const_cast<FrontendRouter&>(m_globalObject.inspectorController().frontendRouter()));
+}
+
+void InspectorTestReporterAgent::willDestroyFrontendAndBackend(DisconnectReason)
+{
+    disable();
+    m_frontendDispatcher = nullptr;
+}
+
+Protocol::ErrorStringOr<void> InspectorTestReporterAgent::enable()
+{
+    if (m_enabled)
+        return {};
+
+    m_enabled = true;
+    Bun__TestReporterAgentEnable(this);
+    return {};
+}
+
+Protocol::ErrorStringOr<void> InspectorTestReporterAgent::disable()
+{
+    if (!m_enabled)
+        return {};
+
+    m_enabled = false;
+    Bun__TestReporterAgentDisable(this);
+    return {};
+}
+
+void InspectorTestReporterAgent::reportTestFound(JSC::CallFrame* callFrame, int testId, const String& name)
+{
+    if (!m_enabled)
+        return;
+
+    JSC::LineColumn lineColumn;
+    JSC::SourceID sourceID = 0;
+    String sourceURL;
+
+    ZigStackFrame remappedFrame = {};
+
+    auto* globalObject = &m_globalObject;
+    auto& vm = globalObject->vm();
+
+    JSC::StackVisitor::visit(callFrame, vm, [&](JSC::StackVisitor& visitor) -> WTF::IterationStatus {
+        if (Zig::isImplementationVisibilityPrivate(visitor))
+            return WTF::IterationStatus::Continue;
+
+        if (visitor->hasLineAndColumnInfo()) {
+            lineColumn = visitor->computeLineAndColumn();
+
+            String sourceURLForFrame = visitor->sourceURL();
+
+            // Sometimes, the sourceURL is empty.
+            // For example, pages in Next.js.
+            if (sourceURLForFrame.isEmpty()) {
+
+                // hasLineAndColumnInfo() checks codeBlock(), so this is safe to access here.
+                const auto& source = visitor->codeBlock()->source();
+
+                // source.isNull() is true when the SourceProvider is a null pointer.
+                if (!source.isNull()) {
+                    auto* provider = source.provider();
+                    // I'm not 100% sure we should show sourceURLDirective here.
+                    if (!provider->sourceURLDirective().isEmpty()) {
+                        sourceURLForFrame = provider->sourceURLDirective();
+                    } else if (!provider->sourceURL().isEmpty()) {
+                        sourceURLForFrame = provider->sourceURL();
+                    } else {
+                        const auto& origin = provider->sourceOrigin();
+                        if (!origin.isNull()) {
+                            sourceURLForFrame = origin.string();
+                        }
+                    }
+
+                    sourceID = provider->asID();
+                }
+            }
+
+            sourceURL = sourceURLForFrame;
+
+            return WTF::IterationStatus::Done;
+        }
+
+        return WTF::IterationStatus::Continue;
+    });
+
+    if (!sourceURL.isEmpty() and lineColumn.line > 0) {
+        OrdinalNumber originalLine = OrdinalNumber::fromOneBasedInt(lineColumn.line);
+        OrdinalNumber originalColumn = OrdinalNumber::fromOneBasedInt(lineColumn.column);
+
+        remappedFrame.position.line_zero_based = originalLine.zeroBasedInt();
+        remappedFrame.position.column_zero_based = originalColumn.zeroBasedInt();
+        remappedFrame.source_url = Bun::toStringRef(sourceURL);
+
+        Bun__remapStackFramePositions(globalObject, &remappedFrame, 1);
+
+        sourceURL = remappedFrame.source_url.toWTFString();
+        lineColumn.line = OrdinalNumber::fromZeroBasedInt(remappedFrame.position.line_zero_based).oneBasedInt();
+        lineColumn.column = OrdinalNumber::fromZeroBasedInt(remappedFrame.position.column_zero_based).oneBasedInt();
+    }
+
+    m_frontendDispatcher->found(
+        testId,
+        sourceID > 0 ? String::number(sourceID) : String(),
+        sourceURL,
+        lineColumn.line,
+        name);
+}
+
+void InspectorTestReporterAgent::reportTestStart(int testId)
+{
+    if (!m_enabled || !m_frontendDispatcher)
+        return;
+
+    m_frontendDispatcher->start(testId);
+}
+
+void InspectorTestReporterAgent::reportTestEnd(int testId, Protocol::TestReporter::TestStatus status, double elapsed)
+{
+    if (!m_enabled || !m_frontendDispatcher)
+        return;
+
+    m_frontendDispatcher->end(testId, status, elapsed);
+}
+
+} // namespace Inspector
diff --git a/src/bun.js/bindings/InspectorTestReporterAgent.h b/src/bun.js/bindings/InspectorTestReporterAgent.h
new file mode 100644
index 0000000000..7c6afcf2e0
--- /dev/null
+++ b/src/bun.js/bindings/InspectorTestReporterAgent.h
@@ -0,0 +1,46 @@
+#pragma once
+
+#include "root.h"
+#include <JavaScriptCore/AlternateDispatchableAgent.h>
+#include <JavaScriptCore/InspectorAgentBase.h>
+#include <JavaScriptCore/InspectorBackendDispatchers.h>
+#include <JavaScriptCore/InspectorFrontendDispatchers.h>
+#include <JavaScriptCore/JSGlobalObject.h>
+#include <wtf/Forward.h>
+#include <wtf/Noncopyable.h>
+
+namespace Inspector {
+
+class FrontendRouter;
+class BackendDispatcher;
+class TestReporterFrontendDispatcher;
+enum class DisconnectReason;
+
+class InspectorTestReporterAgent final : public InspectorAgentBase, public Inspector::TestReporterBackendDispatcherHandler {
+    WTF_MAKE_NONCOPYABLE(InspectorTestReporterAgent);
+
+public:
+    InspectorTestReporterAgent(JSC::JSGlobalObject&);
+    virtual ~InspectorTestReporterAgent();
+
+    // InspectorAgentBase
+    virtual void didCreateFrontendAndBackend(FrontendRouter*, BackendDispatcher*) final;
+    virtual void willDestroyFrontendAndBackend(DisconnectReason) final;
+
+    // TestReporterBackendDispatcherHandler
+    virtual Protocol::ErrorStringOr<void> enable() final;
+    virtual Protocol::ErrorStringOr<void> disable() final;
+
+    // Public API for reporting test events
+    void reportTestFound(JSC::CallFrame*, int testId, const String& name);
+    void reportTestStart(int testId);
+    void reportTestEnd(int testId, Protocol::TestReporter::TestStatus status, double elapsed);
+
+private:
+    JSC::JSGlobalObject& m_globalObject;
+    std::unique_ptr<TestReporterFrontendDispatcher> m_frontendDispatcher;
+    Ref<TestReporterBackendDispatcher> m_backendDispatcher;
+    bool m_enabled { false };
+};
+
+} // namespace Inspector
diff --git a/src/bun.js/bindings/InternalModuleRegistry.cpp b/src/bun.js/bindings/InternalModuleRegistry.cpp
index 3043fd0e9d..2f5d95c92f 100644
--- a/src/bun.js/bindings/InternalModuleRegistry.cpp
+++ b/src/bun.js/bindings/InternalModuleRegistry.cpp
@@ -6,7 +6,7 @@
 #include <JavaScriptCore/LazyPropertyInlines.h>
 #include <JavaScriptCore/VMTrapsInlines.h>
 #include <JavaScriptCore/JSModuleLoader.h>
-
+#include <JavaScriptCore/Debugger.h>
 #include <utility>
 
 #include "InternalModuleRegistryConstants.h"
@@ -32,45 +32,49 @@ static void maybeAddCodeCoverage(JSC::VM& vm, const JSC::SourceCode& code)
 // JS builtin that acts as a module. In debug mode, we use a different implementation that reads
 // from the developer's filesystem. This allows reloading code without recompiling bindings.
 
-#define INTERNAL_MODULE_REGISTRY_GENERATE_(globalObject, vm, SOURCE, moduleName, urlString) \
-    auto throwScope = DECLARE_THROW_SCOPE(vm);                                              \
-    auto&& origin = SourceOrigin(WTF::URL(urlString));                                      \
-    SourceCode source = JSC::makeSource(SOURCE, origin,                                     \
-        JSC::SourceTaintedOrigin::Untainted,                                                \
-        moduleName);                                                                        \
-    maybeAddCodeCoverage(vm, source);                                                       \
-    JSFunction* func                                                                        \
-        = JSFunction::create(                                                               \
-            vm, globalObject,                                                               \
-            createBuiltinExecutable(                                                        \
-                vm, source,                                                                 \
-                Identifier(),                                                               \
-                ImplementationVisibility::Public,                                           \
-                ConstructorKind::None,                                                      \
-                ConstructAbility::CannotConstruct,                                          \
-                InlineAttribute::None)                                                      \
-                ->link(vm, nullptr, source),                                                \
-            static_cast<JSC::JSGlobalObject*>(globalObject));                               \
-                                                                                            \
-    RETURN_IF_EXCEPTION(throwScope, {});                                                    \
-                                                                                            \
-    JSC::MarkedArgumentBuffer argList;                                                      \
-    JSValue result = JSC::profiledCall(                                                     \
-        globalObject,                                                                       \
-        ProfilingReason::Other,                                                             \
-        func,                                                                               \
-        JSC::getCallData(func),                                                             \
-        globalObject, JSC::MarkedArgumentBuffer());                                         \
-                                                                                            \
-    RETURN_IF_EXCEPTION(throwScope, {});                                                    \
-    ASSERT_INTERNAL_MODULE(result, moduleName);                                             \
-    return result;
+JSC::JSValue generateModule(JSC::JSGlobalObject* globalObject, JSC::VM& vm, const String& SOURCE, const String& moduleName, const String& urlString)
+{
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto&& origin = SourceOrigin(WTF::URL(urlString));
+    SourceCode source = JSC::makeSource(SOURCE, origin,
+        JSC::SourceTaintedOrigin::Untainted,
+        moduleName);
+    maybeAddCodeCoverage(vm, source);
+    JSFunction* func
+        = JSFunction::create(
+            vm, globalObject,
+            createBuiltinExecutable(
+                vm, source,
+                Identifier::fromString(vm, moduleName),
+                ImplementationVisibility::Public,
+                ConstructorKind::None,
+                ConstructAbility::CannotConstruct,
+                InlineAttribute::None)
+                ->link(vm, nullptr, source),
+            static_cast<JSC::JSGlobalObject*>(globalObject));
 
-#if BUN_DEBUG
-#define ASSERT_INTERNAL_MODULE(result, moduleName)                                                        \
-    if (!result || !result.isCell() || !jsDynamicCast<JSObject*>(result)) {                               \
-        printf("Expected \"%s\" to export a JSObject. Bun is going to crash.", moduleName.utf8().data()); \
+    RETURN_IF_EXCEPTION(throwScope, {});
+    if (UNLIKELY(globalObject->hasDebugger() && globalObject->debugger()->isInteractivelyDebugging())) {
+        globalObject->debugger()->sourceParsed(globalObject, source.provider(), -1, ""_s);
     }
+
+    JSC::MarkedArgumentBuffer argList;
+    JSValue result = JSC::profiledCall(
+        globalObject,
+        ProfilingReason::Other,
+        func,
+        JSC::getCallData(func),
+        globalObject, JSC::MarkedArgumentBuffer());
+
+    RETURN_IF_EXCEPTION(throwScope, {});
+    ASSERT(
+        result && result.isCell() && jsDynamicCast<JSObject*>(result),
+        "Expected \"%s\" to export a JSObject. Bun is going to crash.",
+        moduleName.utf8().data());
+    return result;
+}
+
+#if BUN_DYNAMIC_JS_LOAD_PATH
 JSValue initializeInternalModuleFromDisk(
     JSGlobalObject* globalObject,
     VM& vm,
@@ -81,7 +85,7 @@ JSValue initializeInternalModuleFromDisk(
     WTF::String file = makeString(ASCIILiteral::fromLiteralUnsafe(BUN_DYNAMIC_JS_LOAD_PATH), "/"_s, WTFMove(fileBase));
     if (auto contents = WTF::FileSystemImpl::readEntireFile(file)) {
         auto string = WTF::String::fromUTF8(contents.value());
-        INTERNAL_MODULE_REGISTRY_GENERATE_(globalObject, vm, string, moduleName, urlString);
+        return generateModule(globalObject, vm, string, moduleName, urlString);
     } else {
         printf("\nFATAL: bun-debug failed to load bundled version of \"%s\" at \"%s\" (was it deleted?)\n"
                "Please re-compile Bun to continue.\n\n",
@@ -93,11 +97,8 @@ JSValue initializeInternalModuleFromDisk(
     return initializeInternalModuleFromDisk(globalObject, vm, moduleId, filename, urlString)
 #else
 
-#define ASSERT_INTERNAL_MODULE(result, moduleName) \
-    {                                              \
-    }
 #define INTERNAL_MODULE_REGISTRY_GENERATE(globalObject, vm, moduleId, filename, SOURCE, urlString) \
-    INTERNAL_MODULE_REGISTRY_GENERATE_(globalObject, vm, SOURCE, moduleId, urlString)
+    return generateModule(globalObject, vm, SOURCE, moduleId, urlString)
 #endif
 
 const ClassInfo InternalModuleRegistry::s_info = { "InternalModuleRegistry"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(InternalModuleRegistry) };
@@ -168,5 +169,4 @@ JSC_DEFINE_HOST_FUNCTION(InternalModuleRegistry::jsCreateInternalModuleById, (JS
 
 } // namespace Bun
 
-#undef INTERNAL_MODULE_REGISTRY_GENERATE_
-#undef INTERNAL_MODULE_REGISTRY_GENERATE
\ No newline at end of file
+#undef INTERNAL_MODULE_REGISTRY_GENERATE
diff --git a/src/bun.js/bindings/JS2Native.cpp b/src/bun.js/bindings/JS2Native.cpp
index 61b16fefb1..0d93d22aff 100644
--- a/src/bun.js/bindings/JS2Native.cpp
+++ b/src/bun.js/bindings/JS2Native.cpp
@@ -32,8 +32,8 @@ 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
-} // namespace Bun
\ No newline at end of file
+} // namespace Bun
diff --git a/src/bun.js/bindings/JS2Native.h b/src/bun.js/bindings/JS2Native.h
index 1dd14bfa2c..4fcc074548 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
\ No newline at end of file
+} // namespace Bun
diff --git a/src/bun.js/bindings/JSBuffer.cpp b/src/bun.js/bindings/JSBuffer.cpp
index 8a0aea2c36..d29fbbc095 100644
--- a/src/bun.js/bindings/JSBuffer.cpp
+++ b/src/bun.js/bindings/JSBuffer.cpp
@@ -52,6 +52,8 @@
 #include <JavaScriptCore/BuiltinNames.h>
 
 #include "JSBufferEncodingType.h"
+#include "ErrorCode.h"
+#include "NodeValidator.h"
 #include "wtf/Assertions.h"
 #include "wtf/Forward.h"
 #include <JavaScriptCore/JSBase.h>
@@ -89,6 +91,7 @@ static JSC_DECLARE_HOST_FUNCTION(jsBufferConstructorFunction_allocUnsafeSlow);
 static JSC_DECLARE_HOST_FUNCTION(jsBufferConstructorFunction_byteLength);
 static JSC_DECLARE_HOST_FUNCTION(jsBufferConstructorFunction_compare);
 static JSC_DECLARE_HOST_FUNCTION(jsBufferConstructorFunction_concat);
+static JSC_DECLARE_HOST_FUNCTION(jsBufferConstructorFunction_copyBytesFrom);
 static JSC_DECLARE_HOST_FUNCTION(jsBufferConstructorFunction_from);
 static JSC_DECLARE_HOST_FUNCTION(jsBufferConstructorFunction_isBuffer);
 static JSC_DECLARE_HOST_FUNCTION(jsBufferConstructorFunction_isEncoding);
@@ -245,29 +248,15 @@ static int normalizeCompareVal(int val, size_t a_length, size_t b_length)
     return val;
 }
 
-static inline uint32_t parseIndex(JSC::JSGlobalObject* lexicalGlobalObject, JSC::ThrowScope& scope, JSValue arg)
-{
-    if (auto num = arg.tryGetAsUint32Index())
-        return num.value();
-
-    if (arg.isNumber())
-        throwNodeRangeError(lexicalGlobalObject, scope, "Invalid array length"_s);
-    else
-        throwTypeError(lexicalGlobalObject, scope, "Expected number"_s);
-
-    return 0;
-}
-
 static inline WebCore::BufferEncodingType parseEncoding(JSC::JSGlobalObject* lexicalGlobalObject, JSC::ThrowScope& scope, JSValue arg)
 {
-    if (UNLIKELY(!arg.isString())) {
-        throwTypeError(lexicalGlobalObject, scope, "Expected string"_s);
-        return WebCore::BufferEncodingType::utf8;
-    }
+    auto arg_ = arg.toStringOrNull(lexicalGlobalObject);
+    RETURN_IF_EXCEPTION(scope, {});
+    auto arg_s = arg_->getString(lexicalGlobalObject);
 
-    std::optional<BufferEncodingType> encoded = parseEnumeration<BufferEncodingType>(*lexicalGlobalObject, arg);
+    std::optional<BufferEncodingType> encoded = parseEnumeration2(*lexicalGlobalObject, arg_s);
     if (UNLIKELY(!encoded)) {
-        throwTypeError(lexicalGlobalObject, scope, "Invalid encoding"_s);
+        Bun::ERR::UNKNOWN_ENCODING(scope, lexicalGlobalObject, arg_s);
         return WebCore::BufferEncodingType::utf8;
     }
 
@@ -414,6 +403,10 @@ static inline JSC::JSUint8Array* JSBuffer__bufferFromLengthAsArray(JSC::JSGlobal
         throwNodeRangeError(lexicalGlobalObject, throwScope, "Invalid array length"_s);
         return nullptr;
     }
+    if (length > MAX_ARRAY_BUFFER_SIZE) {
+        Bun::ERR::OUT_OF_RANGE(throwScope, lexicalGlobalObject, "size"_s, 0, MAX_ARRAY_BUFFER_SIZE, jsNumber(length));
+        return nullptr;
+    }
 
     auto* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto* subclassStructure = globalObject->JSBufferSubclassStructure();
@@ -427,32 +420,18 @@ extern "C" JSC::EncodedJSValue JSBuffer__bufferFromLength(JSC::JSGlobalObject* l
     return JSC::JSValue::encode(JSBuffer__bufferFromLengthAsArray(lexicalGlobalObject, length));
 }
 
+// https://github.com/nodejs/node/blob/v22.9.0/lib/buffer.js#L404
 static inline JSC::EncodedJSValue jsBufferConstructorFunction_allocUnsafeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame)
 {
-
     VM& vm = lexicalGlobalObject->vm();
-
     auto throwScope = DECLARE_THROW_SCOPE(vm);
-
-    if (callFrame->argumentCount() < 1)
-        return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
-
-    JSValue lengthValue = callFrame->uncheckedArgument(0);
-    if (UNLIKELY(!lengthValue.isNumber())) {
-        throwTypeError(lexicalGlobalObject, throwScope, "size argument must be a number"_s);
-        return {};
-    }
-
-    double lengthDouble = lengthValue.toIntegerWithTruncation(lexicalGlobalObject);
-
-    if (UNLIKELY(lengthDouble < 0 || lengthDouble > UINT_MAX)) {
-        throwNodeRangeError(lexicalGlobalObject, throwScope, "Buffer size must be 0...4294967295"_s);
-        return {};
-    }
-
-    size_t length = static_cast<size_t>(lengthDouble);
-
-    RELEASE_AND_RETURN(throwScope, JSValue::encode(allocBufferUnsafe(lexicalGlobalObject, length)));
+    JSValue lengthValue = callFrame->argument(0);
+    Bun::V::validateNumber(throwScope, lexicalGlobalObject, lengthValue, jsString(vm, String("size"_s)), jsNumber(0), jsNumber(Bun::Buffer::kMaxLength));
+    RETURN_IF_EXCEPTION(throwScope, {});
+    size_t length = lengthValue.toLength(lexicalGlobalObject);
+    auto result = allocBufferUnsafe(lexicalGlobalObject, length);
+    RETURN_IF_EXCEPTION(throwScope, {});
+    RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
 // new Buffer()
@@ -546,8 +525,7 @@ static inline JSC::EncodedJSValue constructBufferFromStringAndEncoding(JSC::JSGl
     if (arg1 && arg1.isString()) {
         std::optional<BufferEncodingType> encoded = parseEnumeration<BufferEncodingType>(*lexicalGlobalObject, arg1);
         if (!encoded) {
-            throwTypeError(lexicalGlobalObject, scope, "Invalid encoding"_s);
-            return {};
+            return Bun::ERR::UNKNOWN_ENCODING(scope, lexicalGlobalObject, arg1.getString(lexicalGlobalObject));
         }
 
         encoding = encoded.value();
@@ -561,24 +539,16 @@ static inline JSC::EncodedJSValue constructBufferFromStringAndEncoding(JSC::JSGl
     RELEASE_AND_RETURN(scope, result);
 }
 
+// https://github.com/nodejs/node/blob/v22.9.0/lib/buffer.js#L391
 static inline JSC::EncodedJSValue jsBufferConstructorFunction_allocBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame)
 {
     VM& vm = lexicalGlobalObject->vm();
     auto scope = DECLARE_THROW_SCOPE(vm);
-    JSValue lengthValue = callFrame->uncheckedArgument(0);
-    if (UNLIKELY(!lengthValue.isNumber())) {
-        throwTypeError(lexicalGlobalObject, scope, "size argument must be a number"_s);
-        return {};
-    }
 
-    double lengthDouble = lengthValue.toIntegerWithTruncation(lexicalGlobalObject);
-
-    if (UNLIKELY(lengthDouble < 0 || lengthDouble > UINT_MAX)) {
-        throwNodeRangeError(lexicalGlobalObject, scope, "Buffer size must be 0...4294967295"_s);
-        return {};
-    }
-
-    size_t length = static_cast<size_t>(lengthDouble);
+    JSValue lengthValue = callFrame->argument(0);
+    Bun::V::validateNumber(scope, lexicalGlobalObject, lengthValue, jsString(vm, String("size"_s)), jsNumber(0), jsNumber(Bun::Buffer::kMaxLength));
+    RETURN_IF_EXCEPTION(scope, {});
+    size_t length = lengthValue.toLength(lexicalGlobalObject);
 
     // fill argument
     if (UNLIKELY(callFrame->argumentCount() > 1)) {
@@ -601,6 +571,11 @@ static inline JSC::EncodedJSValue jsBufferConstructorFunction_allocBody(JSC::JSG
             }
             auto startPtr = uint8Array->typedVector() + start;
             auto str_ = value.toWTFString(lexicalGlobalObject);
+            if (str_.isEmpty()) {
+                memset(startPtr, 0, length);
+                RELEASE_AND_RETURN(scope, JSC::JSValue::encode(uint8Array));
+            }
+
             ZigString str = Zig::toZigString(str_);
 
             if (UNLIKELY(!Bun__Buffer_fill(&str, startPtr, end - start, encoding))) {
@@ -693,14 +668,10 @@ static inline JSC::EncodedJSValue jsBufferConstructorFunction_byteLengthBody(JSC
 
     auto scope = DECLARE_THROW_SCOPE(vm);
 
-    if (UNLIKELY(callFrame->argumentCount() == 0)) {
-        throwTypeError(lexicalGlobalObject, scope, "Not enough arguments"_s);
-        return {};
-    }
-
     EnsureStillAliveScope arg0 = callFrame->argument(0);
 
     EnsureStillAliveScope arg1 = callFrame->argument(1);
+
     if (callFrame->argumentCount() > 1) {
 
         if (arg1.value().isString()) {
@@ -724,35 +695,28 @@ static inline JSC::EncodedJSValue jsBufferConstructorFunction_byteLengthBody(JSC
         return JSValue::encode(jsNumber(arrayBuffer->impl()->byteLength()));
     }
 
-    throwTypeError(lexicalGlobalObject, scope, "Invalid input, must be a string, Buffer, or ArrayBuffer"_s);
-    return {};
+    return Bun::ERR::INVALID_ARG_TYPE(scope, lexicalGlobalObject, "string"_s, "string or an instance of Buffer or ArrayBuffer"_s, callFrame->argument(0));
 }
 
 static inline JSC::EncodedJSValue jsBufferConstructorFunction_compareBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame)
 {
     auto& vm = JSC::getVM(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
-    if (callFrame->argumentCount() < 2) {
-        throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
-        return {};
-    }
 
-    auto castedThisValue = callFrame->uncheckedArgument(0);
+    auto castedThisValue = callFrame->argument(0);
     JSC::JSArrayBufferView* castedThis = JSC::jsDynamicCast<JSC::JSArrayBufferView*>(castedThisValue);
     if (UNLIKELY(!castedThis)) {
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected Buffer (first argument)"_s);
-        return {};
+        return Bun::ERR::INVALID_ARG_TYPE(throwScope, lexicalGlobalObject, "buf1"_s, "Buffer or Uint8Array"_s, castedThisValue);
     }
     if (UNLIKELY(castedThis->isDetached())) {
         throwVMTypeError(lexicalGlobalObject, throwScope, "Uint8Array (first argument) is detached"_s);
         return {};
     }
 
-    auto buffer = callFrame->uncheckedArgument(1);
+    auto buffer = callFrame->argument(1);
     JSC::JSArrayBufferView* view = JSC::jsDynamicCast<JSC::JSArrayBufferView*>(buffer);
     if (UNLIKELY(!view)) {
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected Buffer (2nd argument)"_s);
-        return {};
+        return Bun::ERR::INVALID_ARG_TYPE(throwScope, lexicalGlobalObject, "buf2"_s, "Buffer or Uint8Array"_s, buffer);
     }
     if (UNLIKELY(view->isDetached())) {
         throwVMTypeError(lexicalGlobalObject, throwScope, "Uint8Array (second argument) is detached"_s);
@@ -767,29 +731,6 @@ static inline JSC::EncodedJSValue jsBufferConstructorFunction_compareBody(JSC::J
     size_t sourceEndInit = castedThis->byteLength();
     size_t sourceEnd = sourceEndInit;
 
-    switch (callFrame->argumentCount()) {
-    default:
-        sourceEnd = parseIndex(lexicalGlobalObject, throwScope, callFrame->uncheckedArgument(5));
-        RETURN_IF_EXCEPTION(throwScope, {});
-        FALLTHROUGH;
-    case 5:
-        sourceStart = parseIndex(lexicalGlobalObject, throwScope, callFrame->uncheckedArgument(4));
-        RETURN_IF_EXCEPTION(throwScope, {});
-        FALLTHROUGH;
-    case 4:
-        targetEnd = parseIndex(lexicalGlobalObject, throwScope, callFrame->uncheckedArgument(3));
-        RETURN_IF_EXCEPTION(throwScope, {});
-        FALLTHROUGH;
-    case 3:
-        targetStart = parseIndex(lexicalGlobalObject, throwScope, callFrame->uncheckedArgument(2));
-        RETURN_IF_EXCEPTION(throwScope, {});
-        break;
-    case 2:
-    case 1:
-    case 0:
-        break;
-    }
-
     targetStart = std::min(targetStart, std::min(targetEnd, targetEndInit));
     sourceStart = std::min(sourceStart, std::min(sourceEnd, sourceEndInit));
 
@@ -804,6 +745,7 @@ static inline JSC::EncodedJSValue jsBufferConstructorFunction_compareBody(JSC::J
 
     RELEASE_AND_RETURN(throwScope, JSC::JSValue::encode(JSC::jsNumber(normalizeCompareVal(result, sourceLength, targetLength))));
 }
+
 static inline JSC::EncodedJSValue jsBufferConstructorFunction_concatBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame)
 {
     auto& vm = JSC::getVM(lexicalGlobalObject);
@@ -911,13 +853,76 @@ static inline JSC::EncodedJSValue jsBufferConstructorFunction_concatBody(JSC::JS
     RELEASE_AND_RETURN(throwScope, JSC::JSValue::encode(JSC::JSValue(outBuffer)));
 }
 
+// https://github.com/nodejs/node/blob/v22.9.0/lib/buffer.js#L337
+static inline JSC::EncodedJSValue jsBufferConstructorFunction_copyBytesFromBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame)
+{
+    auto& vm = JSC::getVM(lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+
+    auto viewValue = callFrame->argument(0);
+    auto offsetValue = callFrame->argument(1);
+    auto lengthValue = callFrame->argument(2);
+
+    auto view = jsDynamicCast<JSArrayBufferView*>(viewValue);
+    if (!view) {
+        return Bun::ERR::INVALID_ARG_TYPE(throwScope, lexicalGlobalObject, "view"_s, "TypedArray"_s, viewValue);
+    }
+
+    auto ty = JSC::typedArrayType(view->type());
+
+    auto viewLength = view->length();
+    if (viewLength == 0) {
+        return JSValue::encode(createEmptyBuffer(lexicalGlobalObject));
+    }
+
+    double offset;
+    double length;
+
+    if (!offsetValue.isUndefined() || !lengthValue.isUndefined()) {
+        if (!offsetValue.isUndefined()) {
+            Bun::V::validateInteger(throwScope, lexicalGlobalObject, offsetValue, jsString(vm, String("offset"_s)), jsNumber(0), jsUndefined());
+            RETURN_IF_EXCEPTION(throwScope, {});
+            offset = offsetValue.asNumber();
+            if (offset >= viewLength) return JSValue::encode(createEmptyBuffer(lexicalGlobalObject));
+        } else {
+            offset = 0;
+        }
+
+        double end = 0;
+        if (!lengthValue.isUndefined()) {
+            Bun::V::validateInteger(throwScope, lexicalGlobalObject, lengthValue, jsString(vm, String("length"_s)), jsNumber(0), jsUndefined());
+            RETURN_IF_EXCEPTION(throwScope, {});
+            length = lengthValue.asNumber();
+            end = offset + length;
+        } else {
+            end = viewLength;
+        }
+        end = std::min(end, (double)viewLength);
+
+        auto elemSize = JSC::elementSize(ty);
+        auto offset_r = offset * elemSize;
+        auto end_r = end * elemSize;
+        auto span = view->span().subspan(offset_r, end_r - offset_r);
+        return JSValue::encode(createBuffer(lexicalGlobalObject, span.data(), span.size()));
+    }
+
+    auto boffset = view->byteOffset();
+    auto blength = view->byteLength();
+    auto span = view->span().subspan(boffset, blength - boffset);
+    return JSValue::encode(createBuffer(lexicalGlobalObject, span.data(), span.size()));
+}
+
 static inline JSC::EncodedJSValue jsBufferConstructorFunction_isEncodingBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame)
 {
-    auto* encoding_ = callFrame->argument(0).toStringOrNull(lexicalGlobalObject);
-    if (!encoding_)
+    auto& vm = lexicalGlobalObject->vm();
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto encodingValue = callFrame->argument(0);
+    if (!encodingValue.isString()) {
         return JSValue::encode(jsBoolean(false));
-
-    std::optional<BufferEncodingType> encoded = parseEnumeration<BufferEncodingType>(*lexicalGlobalObject, encoding_);
+    }
+    auto* encoding = encodingValue.toString(lexicalGlobalObject);
+    RETURN_IF_EXCEPTION(throwScope, {});
+    std::optional<BufferEncodingType> encoded = parseEnumeration<BufferEncodingType>(*lexicalGlobalObject, encoding);
     return JSValue::encode(jsBoolean(!!encoded));
 }
 
@@ -957,16 +962,12 @@ static inline JSC::EncodedJSValue jsBufferPrototypeFunction_compareBody(JSC::JSG
 {
     auto& vm = JSC::getVM(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
-    if (callFrame->argumentCount() < 1) {
-        throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
-        return {};
-    }
 
-    JSC::JSUint8Array* view = JSC::jsDynamicCast<JSC::JSUint8Array*>(callFrame->uncheckedArgument(0));
+    auto arg0 = callFrame->argument(0);
+    JSC::JSUint8Array* view = JSC::jsDynamicCast<JSC::JSUint8Array*>(arg0);
 
     if (UNLIKELY(!view)) {
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected Uint8Array"_s);
-        return {};
+        return Bun::ERR::INVALID_ARG_TYPE(throwScope, lexicalGlobalObject, "target"_s, "Buffer or Uint8Array"_s, arg0);
     }
 
     if (UNLIKELY(view->isDetached())) {
@@ -990,39 +991,56 @@ static inline JSC::EncodedJSValue jsBufferPrototypeFunction_compareBody(JSC::JSG
     switch (callFrame->argumentCount()) {
     default:
         sourceEndValue = callFrame->uncheckedArgument(4);
+        if (sourceEndValue != jsUndefined()) {
+            Bun::V::validateInteger(throwScope, lexicalGlobalObject, sourceEndValue, jsString(vm, String("sourceEnd"_s)), jsNumber(0), jsNumber(Bun::Buffer::kMaxLength));
+            RETURN_IF_EXCEPTION(throwScope, {});
+            sourceEnd = sourceEndValue.asNumber();
+        }
+        RETURN_IF_EXCEPTION(throwScope, {});
         FALLTHROUGH;
     case 4:
         sourceStartValue = callFrame->uncheckedArgument(3);
+        if (sourceStartValue != jsUndefined()) {
+            Bun::V::validateInteger(throwScope, lexicalGlobalObject, sourceStartValue, jsString(vm, String("sourceStart"_s)), jsNumber(0), jsNumber(Bun::Buffer::kMaxLength));
+            RETURN_IF_EXCEPTION(throwScope, {});
+            sourceStart = sourceStartValue.asNumber();
+        }
+        RETURN_IF_EXCEPTION(throwScope, {});
         FALLTHROUGH;
     case 3:
         targetEndValue = callFrame->uncheckedArgument(2);
+        if (targetEndValue != jsUndefined()) {
+            Bun::V::validateInteger(throwScope, lexicalGlobalObject, targetEndValue, jsString(vm, String("targetEnd"_s)), jsNumber(0), jsNumber(Bun::Buffer::kMaxLength));
+            RETURN_IF_EXCEPTION(throwScope, {});
+            targetEnd = targetEndValue.asNumber();
+        }
+        RETURN_IF_EXCEPTION(throwScope, {});
         FALLTHROUGH;
     case 2:
         targetStartValue = callFrame->uncheckedArgument(1);
+        if (targetStartValue != jsUndefined()) {
+            Bun::V::validateInteger(throwScope, lexicalGlobalObject, targetStartValue, jsString(vm, String("targetStart"_s)), jsNumber(0), jsNumber(Bun::Buffer::kMaxLength));
+            RETURN_IF_EXCEPTION(throwScope, {});
+            targetStart = targetStartValue.asNumber();
+        }
+        RETURN_IF_EXCEPTION(throwScope, {});
         break;
     case 1:
     case 0:
         break;
     }
 
-    if (!targetStartValue.isUndefined()) {
-        targetStart = parseIndex(lexicalGlobalObject, throwScope, callFrame->uncheckedArgument(1));
-        RETURN_IF_EXCEPTION(throwScope, {});
+    if (targetStart > targetEndInit && targetStart <= targetEnd) {
+        return Bun::ERR::OUT_OF_RANGE(throwScope, lexicalGlobalObject, "targetStart"_s, 0, targetEndInit, targetStartValue);
     }
-
-    if (!targetEndValue.isUndefined()) {
-        targetEnd = parseIndex(lexicalGlobalObject, throwScope, callFrame->uncheckedArgument(2));
-        RETURN_IF_EXCEPTION(throwScope, {});
+    if (targetEnd > targetEndInit && targetEnd >= targetStart) {
+        return Bun::ERR::OUT_OF_RANGE(throwScope, lexicalGlobalObject, "targetEnd"_s, 0, targetEndInit, targetEndValue);
     }
-
-    if (!sourceStartValue.isUndefined()) {
-        sourceStart = parseIndex(lexicalGlobalObject, throwScope, callFrame->uncheckedArgument(3));
-        RETURN_IF_EXCEPTION(throwScope, {});
+    if (sourceStart > sourceEndInit && sourceStart <= sourceEnd) {
+        return Bun::ERR::OUT_OF_RANGE(throwScope, lexicalGlobalObject, "sourceStart"_s, 0, sourceEndInit, sourceStartValue);
     }
-
-    if (!sourceEndValue.isUndefined()) {
-        sourceEnd = parseIndex(lexicalGlobalObject, throwScope, callFrame->uncheckedArgument(4));
-        RETURN_IF_EXCEPTION(throwScope, {});
+    if (sourceEnd > sourceEndInit && sourceEnd >= sourceStart) {
+        return Bun::ERR::OUT_OF_RANGE(throwScope, lexicalGlobalObject, "sourceEnd"_s, 0, sourceEndInit, sourceEndValue);
     }
 
     targetStart = std::min(targetStart, std::min(targetEnd, targetEndInit));
@@ -1039,85 +1057,83 @@ static inline JSC::EncodedJSValue jsBufferPrototypeFunction_compareBody(JSC::JSG
 
     RELEASE_AND_RETURN(throwScope, JSC::JSValue::encode(JSC::jsNumber(normalizeCompareVal(result, sourceLength, targetLength))));
 }
+
+static double toInteger(JSC::ThrowScope& scope, JSC::JSGlobalObject* globalObject, JSValue value, double defaultVal)
+{
+    auto n = value.toNumber(globalObject);
+    RETURN_IF_EXCEPTION(scope, {});
+    if (std::isnan(n)) return defaultVal;
+    if (n < JSC::minSafeInteger()) return defaultVal;
+    if (n > JSC::maxSafeInteger()) return defaultVal;
+    return std::trunc(n);
+}
+
+// https://github.com/nodejs/node/blob/v22.9.0/lib/buffer.js#L825
+// https://github.com/nodejs/node/blob/v22.9.0/lib/buffer.js#L205
 static inline JSC::EncodedJSValue jsBufferPrototypeFunction_copyBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSArrayBufferView>::ClassParameter castedThis)
 {
     auto& vm = JSC::getVM(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
 
-    if (callFrame->argumentCount() < 1) {
-        throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
-        return {};
+    auto targetValue = callFrame->argument(0);
+    auto targetStartValue = callFrame->argument(1);
+    auto sourceStartValue = callFrame->argument(2);
+    auto sourceEndValue = callFrame->argument(3);
+
+    auto source = castedThis;
+    auto target = jsDynamicCast<JSArrayBufferView*>(targetValue);
+    if (!target) {
+        return Bun::ERR::INVALID_ARG_TYPE(throwScope, lexicalGlobalObject, "target"_s, "Buffer or Uint8Array"_s, targetValue);
     }
 
-    auto buffer = callFrame->uncheckedArgument(0);
-
-    if (!buffer.isCell() || !JSC::isTypedView(buffer.asCell()->type())) {
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected Uint8Array"_s);
-        return {};
-    }
-
-    JSC::JSArrayBufferView* view = JSC::jsDynamicCast<JSC::JSArrayBufferView*>(buffer);
-    if (UNLIKELY(!view || view->isDetached())) {
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Uint8Array is detached"_s);
-        return {};
-    }
+    auto sourceLength = source->byteLength();
+    auto targetLength = target->byteLength();
 
     size_t targetStart = 0;
-    size_t targetEnd = view->byteLength();
+    if (targetStartValue.isUndefined()) {
+    } else {
+        double targetStartD = targetStartValue.isAnyInt() ? targetStartValue.asNumber() : toInteger(throwScope, lexicalGlobalObject, targetStartValue, 0);
+        RETURN_IF_EXCEPTION(throwScope, {});
+        if (targetStartD < 0) return Bun::ERR::OUT_OF_RANGE(throwScope, lexicalGlobalObject, "targetStart"_s, 0, targetLength, targetStartValue);
+        targetStart = static_cast<size_t>(targetStartD);
+    }
 
     size_t sourceStart = 0;
-    size_t sourceEndInit = castedThis->byteLength();
-    size_t sourceEnd = sourceEndInit;
-
-    JSValue targetStartValue = jsUndefined();
-    JSValue sourceStartValue = jsUndefined();
-    JSValue sourceEndValue = jsUndefined();
-
-    switch (callFrame->argumentCount()) {
-    default:
-        sourceEndValue = callFrame->uncheckedArgument(3);
-        FALLTHROUGH;
-    case 3:
-        sourceStartValue = callFrame->uncheckedArgument(2);
-        FALLTHROUGH;
-    case 2:
-        targetStartValue = callFrame->uncheckedArgument(1);
-        break;
-    case 1:
-    case 0:
-        break;
-    }
-
-    if (!targetStartValue.isUndefined()) {
-        targetStart = parseIndex(lexicalGlobalObject, throwScope, callFrame->uncheckedArgument(1));
+    if (sourceStartValue.isUndefined()) {
+    } else {
+        double sourceStartD = sourceStartValue.isAnyInt() ? sourceStartValue.asNumber() : toInteger(throwScope, lexicalGlobalObject, sourceStartValue, 0);
         RETURN_IF_EXCEPTION(throwScope, {});
+        if (sourceStartD < 0 || sourceStartD > sourceLength) return Bun::ERR::OUT_OF_RANGE(throwScope, lexicalGlobalObject, "sourceStart"_s, 0, sourceLength, sourceStartValue);
+        sourceStart = static_cast<size_t>(sourceStartD);
     }
 
-    if (!sourceStartValue.isUndefined()) {
-        sourceStart = parseIndex(lexicalGlobalObject, throwScope, callFrame->uncheckedArgument(2));
+    size_t sourceEnd = sourceLength;
+    if (sourceEndValue.isUndefined()) {
+    } else {
+        double sourceEndD = sourceEndValue.isAnyInt() ? sourceEndValue.asNumber() : toInteger(throwScope, lexicalGlobalObject, sourceEndValue, 0);
         RETURN_IF_EXCEPTION(throwScope, {});
+        if (sourceEndD < 0) return Bun::ERR::OUT_OF_RANGE(throwScope, lexicalGlobalObject, "sourceEnd"_s, 0, sourceLength, sourceEndValue);
+        sourceEnd = static_cast<size_t>(sourceEndD);
     }
 
-    if (!sourceEndValue.isUndefined()) {
-        sourceEnd = parseIndex(lexicalGlobalObject, throwScope, callFrame->uncheckedArgument(3));
-        RETURN_IF_EXCEPTION(throwScope, {});
+    if (targetStart >= targetLength || sourceStart >= sourceEnd) {
+        return JSValue::encode(jsNumber(0));
     }
 
-    targetStart = std::min(targetStart, targetEnd);
-    sourceEnd = std::min(sourceEnd, sourceEndInit);
-    sourceStart = std::min(sourceStart, sourceEnd);
+    if (sourceEnd - sourceStart > targetLength - targetStart)
+        sourceEnd = sourceStart + targetLength - targetStart;
 
-    auto sourceLength = sourceEnd - sourceStart;
-    auto targetLength = targetEnd - targetStart;
-    auto actualLength = std::min(sourceLength, targetLength);
+    ssize_t nb = sourceEnd - sourceStart;
+    auto sourceLen = sourceLength - sourceStart;
+    if (nb > sourceLen) nb = sourceLen;
 
-    auto sourceStartPtr = castedThis->typedVector() + sourceStart;
-    auto targetStartPtr = reinterpret_cast<unsigned char*>(view->vector()) + targetStart;
+    if (nb <= 0) return JSValue::encode(jsNumber(0));
 
-    if (actualLength > 0)
-        memmove(targetStartPtr, sourceStartPtr, actualLength);
+    auto sourceStartPtr = reinterpret_cast<unsigned char*>(source->vector()) + sourceStart;
+    auto targetStartPtr = reinterpret_cast<unsigned char*>(target->vector()) + targetStart;
+    memmove(targetStartPtr, sourceStartPtr, nb);
 
-    return JSValue::encode(jsNumber(actualLength));
+    return JSValue::encode(jsNumber(nb));
 }
 
 static inline JSC::EncodedJSValue jsBufferPrototypeFunction_equalsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSArrayBufferView>::ClassParameter castedThis)
@@ -1132,8 +1148,7 @@ static inline JSC::EncodedJSValue jsBufferPrototypeFunction_equalsBody(JSC::JSGl
     auto buffer = callFrame->uncheckedArgument(0);
     JSC::JSArrayBufferView* view = JSC::jsDynamicCast<JSC::JSArrayBufferView*>(buffer);
     if (UNLIKELY(!view)) {
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected Buffer"_s);
-        return {};
+        return Bun::ERR::INVALID_ARG_TYPE(throwScope, lexicalGlobalObject, "otherBuffer"_s, "Buffer or Uint8Array"_s, buffer);
     }
 
     if (UNLIKELY(view->isDetached())) {
@@ -1166,19 +1181,19 @@ static inline JSC::EncodedJSValue jsBufferPrototypeFunction_fillBody(JSC::JSGlob
 
     auto value = callFrame->uncheckedArgument(0);
     const size_t limit = castedThis->byteLength();
-    size_t start = 0;
+    size_t offset = 0;
     size_t end = limit;
     WebCore::BufferEncodingType encoding = WebCore::BufferEncodingType::utf8;
     JSValue encodingValue = jsUndefined();
     JSValue offsetValue = jsUndefined();
-    JSValue lengthValue = jsUndefined();
+    JSValue endValue = jsUndefined();
 
     switch (callFrame->argumentCount()) {
     case 4:
         encodingValue = callFrame->uncheckedArgument(3);
         FALLTHROUGH;
     case 3:
-        lengthValue = callFrame->uncheckedArgument(2);
+        endValue = callFrame->uncheckedArgument(2);
         FALLTHROUGH;
     case 2:
         offsetValue = callFrame->uncheckedArgument(1);
@@ -1190,50 +1205,48 @@ static inline JSC::EncodedJSValue jsBufferPrototypeFunction_fillBody(JSC::JSGlob
     if (offsetValue.isUndefined() || offsetValue.isString()) {
         encodingValue = offsetValue;
         offsetValue = jsUndefined();
-    } else if (lengthValue.isString()) {
-        encodingValue = lengthValue;
-        lengthValue = jsUndefined();
+    } else if (endValue.isString()) {
+        encodingValue = endValue;
+        endValue = jsUndefined();
     }
 
-    if (!encodingValue.isUndefined()) {
+    if (!encodingValue.isUndefined() && value.isString()) {
+        if (!encodingValue.isString()) return Bun::ERR::INVALID_ARG_TYPE(scope, lexicalGlobalObject, "encoding"_s, "string"_s, encodingValue);
         encoding = parseEncoding(lexicalGlobalObject, scope, encodingValue);
         RETURN_IF_EXCEPTION(scope, {});
     }
 
+    // https://github.com/nodejs/node/blob/v22.9.0/lib/buffer.js#L1066-L1079
+    // https://github.com/nodejs/node/blob/v22.9.0/lib/buffer.js#L122
     if (!offsetValue.isUndefined()) {
-        start = parseIndex(lexicalGlobalObject, scope, offsetValue);
+        Bun::V::validateNumber(scope, lexicalGlobalObject, offsetValue, jsString(vm, String("offset"_s)), jsNumber(0), jsNumber(Bun::Buffer::kMaxLength));
         RETURN_IF_EXCEPTION(scope, {});
+        offset = offsetValue.toLength(lexicalGlobalObject);
     }
-
-    if (!lengthValue.isUndefined()) {
-        end = parseIndex(lexicalGlobalObject, scope, lengthValue);
+    if (!endValue.isUndefined()) {
+        Bun::V::validateNumber(scope, lexicalGlobalObject, endValue, jsString(vm, String("end"_s)), jsNumber(0), jsNumber(limit));
         RETURN_IF_EXCEPTION(scope, {});
+        end = endValue.toLength(lexicalGlobalObject);
     }
-
-    if (start >= end) {
+    if (offset >= end) {
         RELEASE_AND_RETURN(scope, JSValue::encode(castedThis));
     }
 
-    if (UNLIKELY(end > limit)) {
-        throwNodeRangeError(lexicalGlobalObject, scope, "end out of range"_s);
-        return {};
-    }
-
     if (value.isString()) {
-        auto startPtr = castedThis->typedVector() + start;
+        auto startPtr = castedThis->typedVector() + offset;
         auto str_ = value.toWTFString(lexicalGlobalObject);
+        RETURN_IF_EXCEPTION(scope, {});
         ZigString str = Zig::toZigString(str_);
 
         if (str.len == 0) {
-            memset(startPtr, 0, end - start);
-        } else if (UNLIKELY(!Bun__Buffer_fill(&str, startPtr, end - start, encoding))) {
-            throwTypeError(lexicalGlobalObject, scope, "Failed to decode value"_s);
-            return {};
+            memset(startPtr, 0, end - offset);
+        } else if (UNLIKELY(!Bun__Buffer_fill(&str, startPtr, end - offset, encoding))) {
+            return Bun::ERR::INVALID_ARG_VALUE(scope, lexicalGlobalObject, "value"_s, value);
         }
     } else if (auto* view = JSC::jsDynamicCast<JSC::JSArrayBufferView*>(value)) {
-        auto* startPtr = castedThis->typedVector() + start;
+        auto* startPtr = castedThis->typedVector() + offset;
         auto* head = startPtr;
-        size_t remain = end - start;
+        size_t remain = end - offset;
 
         if (UNLIKELY(view->isDetached())) {
             throwVMTypeError(lexicalGlobalObject, scope, "Uint8Array is detached"_s);
@@ -1262,11 +1275,12 @@ static inline JSC::EncodedJSValue jsBufferPrototypeFunction_fillBody(JSC::JSGlob
         }
     } else {
         auto value_ = value.toInt32(lexicalGlobalObject) & 0xFF;
+        RETURN_IF_EXCEPTION(scope, {});
 
         auto value_uint8 = static_cast<uint8_t>(value_);
         RETURN_IF_EXCEPTION(scope, {});
 
-        auto startPtr = castedThis->typedVector() + start;
+        auto startPtr = castedThis->typedVector() + offset;
         auto endPtr = castedThis->typedVector() + end;
         memset(startPtr, value_uint8, endPtr - startPtr);
     }
@@ -1522,6 +1536,12 @@ static inline JSC::EncodedJSValue jsBufferToString(JSC::VM& vm, JSC::JSGlobalObj
     if (UNLIKELY(length == 0)) {
         RELEASE_AND_RETURN(scope, JSC::JSValue::encode(JSC::jsEmptyString(vm)));
     }
+    if (length > WTF::String::MaxLength) {
+        return Bun::ERR::STRING_TOO_LONG(scope, lexicalGlobalObject);
+    }
+    if (length > castedThis->byteLength()) {
+        length = castedThis->byteLength();
+    }
 
     JSC::EncodedJSValue ret = 0;
 
@@ -1599,6 +1619,8 @@ bool inline parseArrayIndex(JSC::ThrowScope& scope, JSC::JSGlobalObject* globalO
     return true;
 }
 
+// https://github.com/nodejs/node/blob/v22.9.0/lib/buffer.js#L834
+// using byteLength and byte offsets here is intentional
 static inline JSC::EncodedJSValue jsBufferPrototypeFunction_toStringBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSArrayBufferView>::ClassParameter castedThis)
 {
     auto& vm = JSC::getVM(lexicalGlobalObject);
@@ -1625,25 +1647,30 @@ static inline JSC::EncodedJSValue jsBufferPrototypeFunction_toStringBody(JSC::JS
         RETURN_IF_EXCEPTION(scope, {});
     }
 
-    if (!arg2.isUndefined()) {
-        int32_t istart = arg2.toInt32(lexicalGlobalObject);
-        RETURN_IF_EXCEPTION(scope, {});
-
-        if (istart < 0) {
-            throwTypeError(lexicalGlobalObject, scope, "Start must be a positive integer"_s);
-            return {};
-        }
-
-        start = static_cast<uint32_t>(istart);
+    auto fstart = arg2.toNumber(lexicalGlobalObject);
+    RETURN_IF_EXCEPTION(scope, {});
+    if (fstart < 0) {
+        fstart = 0;
+        goto lstart;
     }
+    if (fstart > byteLength) {
+        return JSC::JSValue::encode(JSC::jsEmptyString(vm));
+    }
+    start = static_cast<uint32_t>(fstart);
+lstart:
 
     if (!arg3.isUndefined()) {
-        // length is end
-        end = std::min(byteLength, static_cast<uint32_t>(arg3.toInt32(lexicalGlobalObject)));
+        auto lend = arg3.toLength(lexicalGlobalObject);
         RETURN_IF_EXCEPTION(scope, {});
+        if (lend < byteLength) end = lend;
     }
 
-    return jsBufferToString(vm, lexicalGlobalObject, castedThis, start, end > start ? end - start : 0, encoding);
+    if (end <= start)
+        return JSC::JSValue::encode(JSC::jsEmptyString(vm));
+
+    auto offset = start;
+    auto length = end > start ? end - start : 0;
+    return jsBufferToString(vm, lexicalGlobalObject, castedThis, offset, length, encoding);
 }
 
 // https://github.com/nodejs/node/blob/2eff28fb7a93d3f672f80b582f664a7c701569fb/src/node_buffer.cc#L544
@@ -1953,6 +1980,11 @@ JSC_DEFINE_HOST_FUNCTION(jsBufferConstructorFunction_concat, (JSGlobalObject * l
     return jsBufferConstructorFunction_concatBody(lexicalGlobalObject, callFrame);
 }
 
+JSC_DEFINE_HOST_FUNCTION(jsBufferConstructorFunction_copyBytesFrom, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+{
+    return jsBufferConstructorFunction_copyBytesFromBody(lexicalGlobalObject, callFrame);
+}
+
 extern "C" JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(jsBufferConstructorAllocWithoutTypeChecks, JSUint8Array*, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue, int size));
 extern "C" JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(jsBufferConstructorAllocUnsafeWithoutTypeChecks, JSUint8Array*, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue, int size));
 extern "C" JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(jsBufferConstructorAllocUnsafeSlowWithoutTypeChecks, JSUint8Array*, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue, int size));
@@ -2171,16 +2203,6 @@ static const HashTableValue JSBufferPrototypeTableValues[]
           { "readUInt8"_s, static_cast<unsigned>(JSC::PropertyAttribute::Builtin), NoIntrinsic, { HashTableValue::BuiltinGeneratorType, jsBufferPrototypeReadUInt8CodeGenerator, 1 } },
           { "readUIntBE"_s, static_cast<unsigned>(JSC::PropertyAttribute::Builtin), NoIntrinsic, { HashTableValue::BuiltinGeneratorType, jsBufferPrototypeReadUIntBECodeGenerator, 1 } },
           { "readUIntLE"_s, static_cast<unsigned>(JSC::PropertyAttribute::Builtin), NoIntrinsic, { HashTableValue::BuiltinGeneratorType, jsBufferPrototypeReadUIntLECodeGenerator, 1 } },
-          // name alias
-          { "readUintBE"_s, static_cast<unsigned>(JSC::PropertyAttribute::Builtin), NoIntrinsic, { HashTableValue::BuiltinGeneratorType, jsBufferPrototypeReadUIntBECodeGenerator, 1 } },
-          { "readUintLE"_s, static_cast<unsigned>(JSC::PropertyAttribute::Builtin), NoIntrinsic, { HashTableValue::BuiltinGeneratorType, jsBufferPrototypeReadUIntLECodeGenerator, 1 } },
-          { "readUint8"_s, static_cast<unsigned>(JSC::PropertyAttribute::Builtin), NoIntrinsic, { HashTableValue::BuiltinGeneratorType, jsBufferPrototypeReadUInt8CodeGenerator, 1 } },
-          { "readUint16BE"_s, static_cast<unsigned>(JSC::PropertyAttribute::Builtin), NoIntrinsic, { HashTableValue::BuiltinGeneratorType, jsBufferPrototypeReadUInt16BECodeGenerator, 1 } },
-          { "readUint16LE"_s, static_cast<unsigned>(JSC::PropertyAttribute::Builtin), NoIntrinsic, { HashTableValue::BuiltinGeneratorType, jsBufferPrototypeReadUInt16LECodeGenerator, 1 } },
-          { "readUint32BE"_s, static_cast<unsigned>(JSC::PropertyAttribute::Builtin), NoIntrinsic, { HashTableValue::BuiltinGeneratorType, jsBufferPrototypeReadUInt32BECodeGenerator, 1 } },
-          { "readUint32LE"_s, static_cast<unsigned>(JSC::PropertyAttribute::Builtin), NoIntrinsic, { HashTableValue::BuiltinGeneratorType, jsBufferPrototypeReadUInt32LECodeGenerator, 1 } },
-          { "readBigUint64BE"_s, static_cast<unsigned>(JSC::PropertyAttribute::Builtin), NoIntrinsic, { HashTableValue::BuiltinGeneratorType, jsBufferPrototypeReadBigUInt64BECodeGenerator, 1 } },
-          { "readBigUint64LE"_s, static_cast<unsigned>(JSC::PropertyAttribute::Builtin), NoIntrinsic, { HashTableValue::BuiltinGeneratorType, jsBufferPrototypeReadBigUInt64LECodeGenerator, 1 } },
 
           { "slice"_s, static_cast<unsigned>(JSC::PropertyAttribute::Builtin), NoIntrinsic, { HashTableValue::BuiltinGeneratorType, jsBufferPrototypeSliceCodeGenerator, 2 } },
           { "subarray"_s, static_cast<unsigned>(JSC::PropertyAttribute::Builtin), NoIntrinsic, { HashTableValue::BuiltinGeneratorType, jsBufferPrototypeSliceCodeGenerator, 2 } },
@@ -2223,25 +2245,44 @@ static const HashTableValue JSBufferPrototypeTableValues[]
           { "writeUInt8"_s, static_cast<unsigned>(JSC::PropertyAttribute::Builtin), NoIntrinsic, { HashTableValue::BuiltinGeneratorType, jsBufferPrototypeWriteUInt8CodeGenerator, 1 } },
           { "writeUIntBE"_s, static_cast<unsigned>(JSC::PropertyAttribute::Builtin), NoIntrinsic, { HashTableValue::BuiltinGeneratorType, jsBufferPrototypeWriteUIntBECodeGenerator, 1 } },
           { "writeUIntLE"_s, static_cast<unsigned>(JSC::PropertyAttribute::Builtin), NoIntrinsic, { HashTableValue::BuiltinGeneratorType, jsBufferPrototypeWriteUIntLECodeGenerator, 1 } },
-          // name alias
-          { "writeUintBE"_s, static_cast<unsigned>(JSC::PropertyAttribute::Builtin), NoIntrinsic, { HashTableValue::BuiltinGeneratorType, jsBufferPrototypeWriteUIntBECodeGenerator, 1 } },
-          { "writeUintLE"_s, static_cast<unsigned>(JSC::PropertyAttribute::Builtin), NoIntrinsic, { HashTableValue::BuiltinGeneratorType, jsBufferPrototypeWriteUIntLECodeGenerator, 1 } },
-          { "writeUint8"_s, static_cast<unsigned>(JSC::PropertyAttribute::Builtin), NoIntrinsic, { HashTableValue::BuiltinGeneratorType, jsBufferPrototypeWriteUInt8CodeGenerator, 1 } },
-          { "writeUint16"_s, static_cast<unsigned>(JSC::PropertyAttribute::Builtin), NoIntrinsic, { HashTableValue::BuiltinGeneratorType, jsBufferPrototypeWriteUInt16LECodeGenerator, 1 } },
-          { "writeUint16BE"_s, static_cast<unsigned>(JSC::PropertyAttribute::Builtin), NoIntrinsic, { HashTableValue::BuiltinGeneratorType, jsBufferPrototypeWriteUInt16BECodeGenerator, 1 } },
-          { "writeUint16LE"_s, static_cast<unsigned>(JSC::PropertyAttribute::Builtin), NoIntrinsic, { HashTableValue::BuiltinGeneratorType, jsBufferPrototypeWriteUInt16LECodeGenerator, 1 } },
-          { "writeUint32"_s, static_cast<unsigned>(JSC::PropertyAttribute::Builtin), NoIntrinsic, { HashTableValue::BuiltinGeneratorType, jsBufferPrototypeWriteUInt32LECodeGenerator, 1 } },
-          { "writeUint32BE"_s, static_cast<unsigned>(JSC::PropertyAttribute::Builtin), NoIntrinsic, { HashTableValue::BuiltinGeneratorType, jsBufferPrototypeWriteUInt32BECodeGenerator, 1 } },
-          { "writeUint32LE"_s, static_cast<unsigned>(JSC::PropertyAttribute::Builtin), NoIntrinsic, { HashTableValue::BuiltinGeneratorType, jsBufferPrototypeWriteUInt32LECodeGenerator, 1 } },
-          { "writeBigUint64BE"_s, static_cast<unsigned>(JSC::PropertyAttribute::Builtin), NoIntrinsic, { HashTableValue::BuiltinGeneratorType, jsBufferPrototypeWriteBigUInt64BECodeGenerator, 1 } },
-          { "writeBigUint64LE"_s, static_cast<unsigned>(JSC::PropertyAttribute::Builtin), NoIntrinsic, { HashTableValue::BuiltinGeneratorType, jsBufferPrototypeWriteBigUInt64LECodeGenerator, 1 } },
       };
 
+// TODO: add this as a feature to the hash table generator mechanism above so that we can avoid all the unnecessary extra calls to `Identifier::fromString` and `this->getDirect`.
+#define ALIAS(to, from)                                                                          \
+    do {                                                                                         \
+        auto original_ident = Identifier::fromString(vm, ASCIILiteral::fromLiteralUnsafe(from)); \
+        auto original = this->getDirect(vm, original_ident);                                     \
+        auto alias_ident = Identifier::fromString(vm, ASCIILiteral::fromLiteralUnsafe(to));      \
+        this->putDirect(vm, alias_ident, original, PropertyAttribute::Builtin | 0);              \
+    } while (false);
+
 void JSBufferPrototype::finishCreation(VM& vm, JSC::JSGlobalObject* globalThis)
 {
     Base::finishCreation(vm);
     JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
     reifyStaticProperties(vm, JSBuffer::info(), JSBufferPrototypeTableValues, *this);
+
+    ALIAS("readUintBE", "readUIntBE");
+    ALIAS("readUintLE", "readUIntLE");
+    ALIAS("readUint8", "readUInt8");
+    ALIAS("readUint16BE", "readUInt16BE");
+    ALIAS("readUint16LE", "readUInt16LE");
+    ALIAS("readUint32BE", "readUInt32BE");
+    ALIAS("readUint32LE", "readUInt32LE");
+    ALIAS("readBigUint64BE", "readBigUInt64BE");
+    ALIAS("readBigUint64LE", "readBigUInt64LE");
+
+    ALIAS("writeUintBE", "writeUIntBE");
+    ALIAS("writeUintLE", "writeUIntLE");
+    ALIAS("writeUint8", "writeUInt8");
+    ALIAS("writeUint16", "writeUInt16");
+    ALIAS("writeUint16BE", "writeUInt16BE");
+    ALIAS("writeUint16LE", "writeUInt16LE");
+    ALIAS("writeUint32", "writeUInt32");
+    ALIAS("writeUint32BE", "writeUInt32BE");
+    ALIAS("writeUint32LE", "writeUInt32LE");
+    ALIAS("writeBigUint64BE", "writeBigUInt64BE");
+    ALIAS("writeBigUint64LE", "writeBigUInt64LE");
 }
 
 const ClassInfo JSBufferPrototype::s_info = {
@@ -2260,6 +2301,7 @@ const ClassInfo JSBufferPrototype::s_info = {
     byteLength      jsBufferConstructorFunction_byteLength         Function 2
     compare         jsBufferConstructorFunction_compare            Function 2
     concat          jsBufferConstructorFunction_concat             Function 2
+    copyBytesFrom   jsBufferConstructorFunction_copyBytesFrom      Function 1
     from            JSBuiltin                                      Builtin|Function 1
     isBuffer        JSBuiltin                                      Builtin|Function 1
     isEncoding      jsBufferConstructorFunction_isEncoding         Function 1
@@ -2274,6 +2316,7 @@ void JSBufferConstructor::finishCreation(VM& vm, JSGlobalObject* globalObject, J
     Base::finishCreation(vm, 3, "Buffer"_s, PropertyAdditionMode::WithoutStructureTransition);
     putDirectWithoutTransition(vm, vm.propertyNames->prototype, prototype, PropertyAttribute::DontEnum | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
     prototype->putDirect(vm, vm.propertyNames->speciesSymbol, this, PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
+    putDirectWithoutTransition(vm, Identifier::fromString(vm, "poolSize"_s), jsNumber(8192));
 }
 
 JSC::Structure* createBufferStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
@@ -2310,7 +2353,21 @@ static inline JSC::EncodedJSValue createJSBufferFromJS(JSC::JSGlobalObject* lexi
 
     if (distinguishingArg.isAnyInt()) {
         throwScope.release();
+        if (args.at(1).isString()) {
+            return Bun::ERR::INVALID_ARG_TYPE(throwScope, lexicalGlobalObject, "string"_s, "string"_s, distinguishingArg);
+        }
         return JSBuffer__bufferFromLength(lexicalGlobalObject, distinguishingArg.asAnyInt());
+    } else if (distinguishingArg.isNumber()) {
+        JSValue lengthValue = distinguishingArg;
+        Bun::V::validateNumber(throwScope, lexicalGlobalObject, lengthValue, jsString(vm, String("size"_s)), jsNumber(0), jsNumber(Bun::Buffer::kMaxLength));
+        RETURN_IF_EXCEPTION(throwScope, {});
+        size_t length = lengthValue.toLength(lexicalGlobalObject);
+        return JSBuffer__bufferFromLength(lexicalGlobalObject, length);
+    } else if (distinguishingArg.isUndefinedOrNull() || distinguishingArg.isBoolean()) {
+        auto arg_string = distinguishingArg.toWTFString(globalObject);
+        auto message = makeString("The first argument must be of type string or an instance of Buffer, ArrayBuffer, Array or an Array-like object. Received "_s, arg_string);
+        throwTypeError(lexicalGlobalObject, throwScope, message);
+        return {};
     } else if (distinguishingArg.isCell()) {
         auto type = distinguishingArg.asCell()->type();
 
diff --git a/src/bun.js/bindings/JSBuffer.h b/src/bun.js/bindings/JSBuffer.h
index 6910043790..04795e6143 100644
--- a/src/bun.js/bindings/JSBuffer.h
+++ b/src/bun.js/bindings/JSBuffer.h
@@ -39,6 +39,15 @@ namespace Bun {
 
 std::optional<double> byteLength(JSC::JSString* str, WebCore::BufferEncodingType encoding);
 
+namespace Buffer {
+
+const size_t kMaxLength = MAX_ARRAY_BUFFER_SIZE;
+const size_t kStringMaxLength = WTF::String::MaxLength;
+const size_t MAX_LENGTH = MAX_ARRAY_BUFFER_SIZE;
+const size_t MAX_STRING_LENGTH = WTF::String::MaxLength;
+
+}
+
 }
 
 namespace WebCore {
@@ -55,4 +64,4 @@ JSC::JSObject* createBufferPrototype(JSC::VM&, JSC::JSGlobalObject*);
 JSC::Structure* createBufferStructure(JSC::VM&, JSC::JSGlobalObject*, JSC::JSValue prototype);
 JSC::JSObject* createBufferConstructor(JSC::VM&, JSC::JSGlobalObject*, JSC::JSObject* bufferPrototype);
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/JSBufferEncodingType.cpp b/src/bun.js/bindings/JSBufferEncodingType.cpp
index 336d7cfdda..e97504fb70 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)];
 }
@@ -53,14 +51,17 @@ template<> JSString* convertEnumerationToJS(JSGlobalObject& lexicalGlobalObject,
 }
 
 // this function is mostly copied from node
-template<> std::optional<BufferEncodingType> parseEnumeration<BufferEncodingType>(JSGlobalObject& lexicalGlobalObject, JSValue value)
+template<> std::optional<BufferEncodingType> parseEnumeration<BufferEncodingType>(JSGlobalObject& lexicalGlobalObject, JSValue arg)
+{
+    if (UNLIKELY(!arg.isString())) {
+        return std::nullopt;
+    }
+    return parseEnumeration2(lexicalGlobalObject, asString(arg)->getString(&lexicalGlobalObject));
+}
+
+std::optional<BufferEncodingType> parseEnumeration2(JSGlobalObject& lexicalGlobalObject, WTF::String encoding)
 {
     // caller must check if value is a string
-    JSC::JSString* str = asString(value);
-    if (UNLIKELY(!str))
-        return std::nullopt;
-
-    String encoding = str->value(&lexicalGlobalObject);
     switch (encoding.length()) {
     case 0: {
         return BufferEncodingType::utf8;
diff --git a/src/bun.js/bindings/JSBufferEncodingType.h b/src/bun.js/bindings/JSBufferEncodingType.h
index 76b3aea301..f6e26116fa 100644
--- a/src/bun.js/bindings/JSBufferEncodingType.h
+++ b/src/bun.js/bindings/JSBufferEncodingType.h
@@ -7,7 +7,8 @@ namespace WebCore {
 String convertEnumerationToString(BufferEncodingType);
 template<> JSC::JSString* convertEnumerationToJS(JSC::JSGlobalObject&, BufferEncodingType);
 
-template<> std::optional<BufferEncodingType> parseEnumeration<BufferEncodingType>(JSC::JSGlobalObject&, JSC::JSValue);
+template<> std::optional<BufferEncodingType> parseEnumeration<BufferEncodingType>(JSC::JSGlobalObject&, JSValue);
+std::optional<BufferEncodingType> parseEnumeration2(JSC::JSGlobalObject&, WTF::String);
 template<> WTF::ASCIILiteral expectedEnumerationValues<BufferEncodingType>();
 
-} // namespace WebCore
\ No newline at end of file
+} // namespace WebCore
diff --git a/src/bun.js/bindings/JSBundlerPlugin.cpp b/src/bun.js/bindings/JSBundlerPlugin.cpp
index 2d5f0e7fce..c1ec1fd4b8 100644
--- a/src/bun.js/bindings/JSBundlerPlugin.cpp
+++ b/src/bun.js/bindings/JSBundlerPlugin.cpp
@@ -1,5 +1,7 @@
 #include "JSBundlerPlugin.h"
 
+#include "BunProcess.h"
+#include "../../../packages/bun-native-bundler-plugin-api/bundler_plugin.h"
 #include "headers-handwritten.h"
 #include <JavaScriptCore/CatchScope.h>
 #include <JavaScriptCore/JSGlobalObject.h>
@@ -11,6 +13,7 @@
 #include <JavaScriptCore/JSObjectInlines.h>
 #include <wtf/text/WTFString.h>
 #include <JavaScriptCore/JSCInlines.h>
+#include "JSFFIFunction.h"
 
 #include <JavaScriptCore/ObjectConstructor.h>
 #include <JavaScriptCore/SubspaceInlines.h>
@@ -23,29 +26,44 @@
 #include <JavaScriptCore/LazyPropertyInlines.h>
 #include <JavaScriptCore/VMTrapsInlines.h>
 #include <JavaScriptCore/YarrMatchingContextHolder.h>
+#include "ErrorCode.h"
+#include "napi_external.h"
+#include <JavaScriptCore/Strong.h>
+#include <JavaScriptCore/JSPromise.h>
+
+#if OS(WINDOWS)
+#include <windows.h>
+#endif
+
 namespace Bun {
 
-#define WRAP_BUNDLER_PLUGIN(argName) jsNumber(bitwise_cast<double>(reinterpret_cast<uintptr_t>(argName)))
+extern "C" int OnBeforeParsePlugin__isDone(void* context);
+#define WRAP_BUNDLER_PLUGIN(argName) jsDoubleNumber(bitwise_cast<double>(reinterpret_cast<uintptr_t>(argName)))
 #define UNWRAP_BUNDLER_PLUGIN(callFrame) reinterpret_cast<void*>(bitwise_cast<uintptr_t>(callFrame->argument(0).asDouble()))
 
+/// These are callbacks defined in Zig and to be run after their associated JS version is run
 extern "C" void JSBundlerPlugin__addError(void*, void*, JSC::EncodedJSValue, JSC::EncodedJSValue);
 extern "C" void JSBundlerPlugin__onLoadAsync(void*, void*, JSC::EncodedJSValue, JSC::EncodedJSValue);
 extern "C" void JSBundlerPlugin__onResolveAsync(void*, void*, JSC::EncodedJSValue, JSC::EncodedJSValue, JSC::EncodedJSValue);
 extern "C" void JSBundlerPlugin__onVirtualModulePlugin(void*, void*, JSC::EncodedJSValue, JSC::EncodedJSValue, JSC::EncodedJSValue);
+extern "C" JSC::EncodedJSValue JSBundlerPlugin__onDefer(void*, JSC::JSGlobalObject*);
 
 JSC_DECLARE_HOST_FUNCTION(jsBundlerPluginFunction_addFilter);
 JSC_DECLARE_HOST_FUNCTION(jsBundlerPluginFunction_addError);
 JSC_DECLARE_HOST_FUNCTION(jsBundlerPluginFunction_onLoadAsync);
 JSC_DECLARE_HOST_FUNCTION(jsBundlerPluginFunction_onResolveAsync);
+JSC_DECLARE_HOST_FUNCTION(jsBundlerPluginFunction_onBeforeParse);
+JSC_DECLARE_HOST_FUNCTION(jsBundlerPluginFunction_generateDeferPromise);
 
-void BundlerPlugin::NamespaceList::append(JSC::VM& vm, JSC::RegExp* filter, String& namespaceString)
+void BundlerPlugin::NamespaceList::append(JSC::VM& vm, JSC::RegExp* filter, String& namespaceString, unsigned& index)
 {
-    auto* nsGroup = group(namespaceString);
+    auto* nsGroup = group(namespaceString, index);
 
     if (nsGroup == nullptr) {
         namespaces.append(namespaceString);
         groups.append(Vector<Yarr::RegularExpression> {});
         nsGroup = &groups.last();
+        index = namespaces.size() - 1;
     }
 
     Yarr::RegularExpression regex(
@@ -55,62 +73,49 @@ void BundlerPlugin::NamespaceList::append(JSC::VM& vm, JSC::RegExp* filter, Stri
     nsGroup->append(WTFMove(regex));
 }
 
-bool BundlerPlugin::anyMatchesCrossThread(JSC::VM& vm, const BunString* namespaceStr, const BunString* path, bool isOnLoad)
+static bool anyMatchesForNamespace(JSC::VM& vm, BundlerPlugin::NamespaceList& list, const BunString* namespaceStr, const BunString* path)
 {
     constexpr bool usesPatternContextBuffer = false;
-    if (isOnLoad) {
-        if (this->onLoad.fileNamespace.isEmpty() && this->onLoad.namespaces.isEmpty())
-            return false;
 
-        // Avoid unnecessary string copies
-        auto namespaceString = namespaceStr ? namespaceStr->toWTFString(BunString::ZeroCopy) : String();
+    if (list.fileNamespace.isEmpty() && list.namespaces.isEmpty())
+        return false;
 
-        auto* group = this->onLoad.group(namespaceString);
-        if (group == nullptr) {
-            return false;
-        }
+    // Avoid unnecessary string copies
+    auto namespaceString = namespaceStr ? namespaceStr->toWTFString(BunString::ZeroCopy) : String();
+    unsigned index = 0;
+    auto* group = list.group(namespaceString, index);
+    if (group == nullptr) {
+        return false;
+    }
 
-        auto& filters = *group;
-        auto pathString = path->toWTFString(BunString::ZeroCopy);
+    auto& filters = *group;
+    auto pathString = path->toWTFString(BunString::ZeroCopy);
 
-        for (auto& filter : filters) {
-            Yarr::MatchingContextHolder regExpContext(vm, usesPatternContextBuffer, nullptr, Yarr::MatchFrom::CompilerThread);
-            if (filter.match(pathString) > -1) {
-                return true;
-            }
-        }
-
-    } else {
-        if (this->onResolve.fileNamespace.isEmpty() && this->onResolve.namespaces.isEmpty())
-            return false;
-
-        // Avoid unnecessary string copies
-        auto namespaceString = namespaceStr ? namespaceStr->toWTFString(BunString::ZeroCopy) : String();
-
-        auto* group = this->onResolve.group(namespaceString);
-        if (group == nullptr) {
-            return false;
-        }
-
-        auto pathString = path->toWTFString(BunString::ZeroCopy);
-        auto& filters = *group;
-
-        for (auto& filter : filters) {
-            Yarr::MatchingContextHolder regExpContext(vm, usesPatternContextBuffer, nullptr, Yarr::MatchFrom::CompilerThread);
-            if (filter.match(pathString) > -1) {
-                return true;
-            }
+    for (auto& filter : filters) {
+        Yarr::MatchingContextHolder regExpContext(vm, usesPatternContextBuffer, nullptr, Yarr::MatchFrom::CompilerThread);
+        if (filter.match(pathString) > -1) {
+            return true;
         }
     }
 
     return false;
 }
+bool BundlerPlugin::anyMatchesCrossThread(JSC::VM& vm, const BunString* namespaceStr, const BunString* path, bool isOnLoad)
+{
+    if (isOnLoad) {
+        return anyMatchesForNamespace(vm, this->onLoad, namespaceStr, path);
+    } else {
+        return anyMatchesForNamespace(vm, this->onResolve, namespaceStr, path);
+    }
+}
 
 static const HashTableValue JSBundlerPluginHashTable[] = {
     { "addFilter"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, jsBundlerPluginFunction_addFilter, 3 } },
     { "addError"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, jsBundlerPluginFunction_addError, 3 } },
     { "onLoadAsync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, jsBundlerPluginFunction_onLoadAsync, 3 } },
     { "onResolveAsync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, jsBundlerPluginFunction_onResolveAsync, 4 } },
+    { "onBeforeParse"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, jsBundlerPluginFunction_onBeforeParse, 4 } },
+    { "generateDeferPromise"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, jsBundlerPluginFunction_generateDeferPromise, 0 } },
 };
 
 class JSBundlerPlugin final : public JSC::JSNonFinalObject {
@@ -145,6 +150,7 @@ public:
             [](auto& spaces) { return spaces.m_subspaceForBundlerPlugin.get(); },
             [](auto& spaces, auto&& space) { spaces.m_subspaceForBundlerPlugin = std::forward<decltype(space)>(space); });
     }
+
     static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
     {
         return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
@@ -153,16 +159,18 @@ public:
     DECLARE_VISIT_CHILDREN;
 
     Bun::BundlerPlugin plugin;
+    /// These are the user implementation of the plugin callbacks
     JSC::LazyProperty<JSBundlerPlugin, JSC::JSFunction> onLoadFunction;
     JSC::LazyProperty<JSBundlerPlugin, JSC::JSFunction> onResolveFunction;
-    JSC::LazyProperty<JSBundlerPlugin, JSC::JSFunction> moduleFunction;
     JSC::LazyProperty<JSBundlerPlugin, JSC::JSFunction> setupFunction;
+    JSC::JSGlobalObject* m_globalObject;
 
 private:
-    JSBundlerPlugin(JSC::VM& vm, JSC::JSGlobalObject*, JSC::Structure* structure, void* config, BunPluginTarget target,
+    JSBundlerPlugin(JSC::VM& vm, JSC::JSGlobalObject* global, JSC::Structure* structure, void* config, BunPluginTarget target,
         JSBundlerPluginAddErrorCallback addError, JSBundlerPluginOnLoadAsyncCallback onLoadAsync, JSBundlerPluginOnResolveAsyncCallback onResolveAsync)
         : JSC::JSNonFinalObject(vm, structure)
         , plugin(BundlerPlugin(config, target, addError, onLoadAsync, onResolveAsync))
+        , m_globalObject(global)
     {
     }
 
@@ -196,25 +204,203 @@ JSC_DEFINE_HOST_FUNCTION(jsBundlerPluginFunction_addFilter, (JSC::JSGlobalObject
         namespaceStr = String();
     }
 
-    bool isOnLoad = callFrame->argument(2).toNumber(globalObject) == 1;
+    uint32_t isOnLoad = callFrame->argument(2).toUInt32(globalObject);
     auto& vm = globalObject->vm();
 
+    unsigned index = 0;
     if (isOnLoad) {
-        thisObject->plugin.onLoad.append(vm, regExp->regExp(), namespaceStr);
+        thisObject->plugin.onLoad.append(vm, regExp->regExp(), namespaceStr, index);
     } else {
-        thisObject->plugin.onResolve.append(vm, regExp->regExp(), namespaceStr);
+        thisObject->plugin.onResolve.append(vm, regExp->regExp(), namespaceStr, index);
     }
 
     return JSC::JSValue::encode(JSC::jsUndefined());
 }
 
+static JSBundlerPluginNativeOnBeforeParseCallback nativeCallbackFromJS(JSC::JSGlobalObject* globalObject, JSC::JSValue value)
+{
+    if (auto* fn = jsDynamicCast<JSFFIFunction*>(value)) {
+        return reinterpret_cast<JSBundlerPluginNativeOnBeforeParseCallback>(fn->symbolFromDynamicLibrary);
+    }
+
+    if (auto* object = value.getObject()) {
+        if (auto callbackValue = object->getIfPropertyExists(globalObject, JSC::Identifier::fromString(globalObject->vm(), String("native"_s)))) {
+            if (auto* fn = jsDynamicCast<JSFFIFunction*>(callbackValue)) {
+                return reinterpret_cast<JSBundlerPluginNativeOnBeforeParseCallback>(fn->symbolFromDynamicLibrary);
+            }
+        }
+    }
+
+    return nullptr;
+}
+
+void BundlerPlugin::NativePluginList::append(JSC::VM& vm, JSC::RegExp* filter, String& namespaceString, JSBundlerPluginNativeOnBeforeParseCallback callback, const char* name, NapiExternal* external)
+{
+    unsigned index = 0;
+
+    {
+        auto* nsGroup = group(namespaceString, index);
+
+        if (nsGroup == nullptr) {
+            namespaces.append(namespaceString);
+            groups.append(Vector<NativeFilterRegexp> {});
+            nsGroup = &groups.last();
+            index = namespaces.size() - 1;
+        }
+
+        Yarr::RegularExpression regex(
+            StringView(filter->pattern()),
+            filter->flags());
+
+        NativeFilterRegexp nativeFilterRegexp = std::make_pair(regex, std::make_shared<std::mutex>());
+
+        nsGroup->append(nativeFilterRegexp);
+    }
+
+    if (index == std::numeric_limits<unsigned>::max()) {
+        this->fileCallbacks.append(NativePluginCallback {
+            callback,
+            external,
+            name,
+        });
+    } else {
+        if (this->namespaceCallbacks.size() <= index) {
+            this->namespaceCallbacks.grow(index + 1);
+        }
+        this->namespaceCallbacks[index].append(NativePluginCallback { callback, external, name });
+    }
+}
+
+extern "C" void CrashHandler__setInsideNativePlugin(const char* plugin_name);
+
+int BundlerPlugin::NativePluginList::call(JSC::VM& vm, BundlerPlugin* plugin, int* shouldContinue, void* bunContextPtr, const BunString* namespaceStr, const BunString* pathString, void* onBeforeParseArgs, void* onBeforeParseResult)
+{
+    unsigned index = 0;
+    const auto* group = this->group(namespaceStr->toWTFString(BunString::ZeroCopy), index);
+    if (group == nullptr) {
+        return -1;
+    }
+
+    const auto& callbacks = index == std::numeric_limits<unsigned>::max() ? this->fileCallbacks : this->namespaceCallbacks[index];
+    ASSERT_WITH_MESSAGE(callbacks.size() == group->size(), "Number of callbacks and filters must match");
+    if (callbacks.isEmpty()) {
+        return -1;
+    }
+
+    int count = 0;
+    constexpr bool usesPatternContextBuffer = false;
+    const WTF::String& path = pathString->toWTFString(BunString::ZeroCopy);
+    for (size_t i = 0, total = callbacks.size(); i < total && *shouldContinue; ++i) {
+        Yarr::MatchingContextHolder regExpContext(vm, usesPatternContextBuffer, nullptr, Yarr::MatchFrom::CompilerThread);
+
+        // Need to lock the mutex to access the regular expression
+        {
+            std::lock_guard<std::mutex> lock(*group->at(i).second);
+            if (group->at(i).first.match(path) > -1) {
+                Bun::NapiExternal* external = callbacks[i].external;
+                if (external) {
+                    ((OnBeforeParseArguments*)(onBeforeParseArgs))->external = external->value();
+                }
+
+                JSBundlerPluginNativeOnBeforeParseCallback callback = callbacks[i].callback;
+                const char* name = callbacks[i].name ? callbacks[i].name : "<unknown>";
+                CrashHandler__setInsideNativePlugin(name);
+                callback(onBeforeParseArgs, onBeforeParseResult);
+                CrashHandler__setInsideNativePlugin(nullptr);
+
+                count++;
+            }
+        }
+
+        if (OnBeforeParsePlugin__isDone(bunContextPtr)) {
+            return count;
+        }
+    }
+
+    return count;
+}
+JSC_DEFINE_HOST_FUNCTION(jsBundlerPluginFunction_onBeforeParse, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    auto& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    JSBundlerPlugin* thisObject = jsCast<JSBundlerPlugin*>(callFrame->thisValue());
+    if (thisObject->plugin.tombstoned) {
+        return JSC::JSValue::encode(JSC::jsUndefined());
+    }
+
+    // Clone the regexp so we don't have to worry about it being used concurrently with the JS thread.
+    // TODO: Should we have a regexp object for every thread in the thread pool? Then we could avoid using
+    // a mutex to synchronize access to the same regexp from multiple threads.
+    JSC::RegExpObject* jsRegexp = jsCast<JSC::RegExpObject*>(callFrame->argument(0));
+    RegExp* reggie = jsRegexp->regExp();
+    RegExp* newRegexp = RegExp::create(vm, reggie->pattern(), reggie->flags());
+
+    WTF::String namespaceStr = callFrame->argument(1).toWTFString(globalObject);
+    RETURN_IF_EXCEPTION(scope, {});
+    if (namespaceStr == "file"_s) {
+        namespaceStr = String();
+    }
+
+    JSC::JSValue node_addon = callFrame->argument(2);
+    if (!node_addon.isObject()) {
+        Bun::throwError(globalObject, scope, ErrorCode::ERR_INVALID_ARG_TYPE, "Expected node_addon (2nd argument) to be an object"_s);
+        return {};
+    }
+
+    JSC::JSValue on_before_parse_symbol_js = callFrame->argument(3);
+    if (!on_before_parse_symbol_js.isString()) {
+        Bun::throwError(globalObject, scope, ErrorCode::ERR_INVALID_ARG_TYPE, "Expected on_before_parse_symbol (3rd argument) to be a string"_s);
+        return {};
+    }
+    WTF::String on_before_parse_symbol = on_before_parse_symbol_js.toWTFString(globalObject);
+
+    // The dlopen *void handle is attached to the node_addon as a NapiExternal
+    Bun::NapiExternal* napi_external = jsDynamicCast<Bun::NapiExternal*>(node_addon.getObject()->get(globalObject, WebCore::builtinNames(vm).napiDlopenHandlePrivateName()));
+    if (UNLIKELY(!napi_external)) {
+        Bun::throwError(globalObject, scope, ErrorCode::ERR_INVALID_ARG_TYPE, "Expected node_addon (2nd argument) to have a napiDlopenHandle property"_s);
+        return {};
+    }
+    Bun::NapiModuleMeta* meta = (Bun::NapiModuleMeta*)napi_external->value();
+    void* dlopen_handle = meta->dlopenHandle;
+    CString utf8 = on_before_parse_symbol.utf8();
+
+#if OS(WINDOWS)
+    void* on_before_parse_symbol_ptr = GetProcAddress((HMODULE)dlopen_handle, utf8.data());
+    const char** native_plugin_name = (const char**)GetProcAddress((HMODULE)dlopen_handle, "BUN_PLUGIN_NAME");
+#else
+    void* on_before_parse_symbol_ptr = dlsym(dlopen_handle, utf8.data());
+    const char** native_plugin_name = (const char**)dlsym(dlopen_handle, "BUN_PLUGIN_NAME");
+#endif
+
+    if (!on_before_parse_symbol_ptr) {
+        Bun::throwError(globalObject, scope, ErrorCode::ERR_INVALID_ARG_TYPE, "Expected on_before_parse_symbol (3rd argument) to be a valid symbol"_s);
+        return {};
+    }
+
+    JSBundlerPluginNativeOnBeforeParseCallback callback = reinterpret_cast<JSBundlerPluginNativeOnBeforeParseCallback>(on_before_parse_symbol_ptr);
+
+    JSC::JSValue external = callFrame->argument(4);
+    NapiExternal* externalPtr = nullptr;
+    if (!external.isUndefinedOrNull()) {
+        externalPtr = jsDynamicCast<Bun::NapiExternal*>(external);
+        if (UNLIKELY(!externalPtr)) {
+            Bun::throwError(globalObject, scope, ErrorCode::ERR_INVALID_ARG_TYPE, "Expected external (3rd argument) to be a NAPI external"_s);
+            return {};
+        }
+    }
+
+    thisObject->plugin.onBeforeParse.append(vm, newRegexp, namespaceStr, callback, native_plugin_name ? *native_plugin_name : nullptr, externalPtr);
+
+    return JSC::JSValue::encode(JSC::jsUndefined());
+}
+
 JSC_DEFINE_HOST_FUNCTION(jsBundlerPluginFunction_addError, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
 {
     JSBundlerPlugin* thisObject = jsCast<JSBundlerPlugin*>(callFrame->thisValue());
     if (!thisObject->plugin.tombstoned) {
         thisObject->plugin.addError(
             UNWRAP_BUNDLER_PLUGIN(callFrame),
-            thisObject->plugin.config,
+            thisObject,
             JSValue::encode(callFrame->argument(1)),
             JSValue::encode(callFrame->argument(2)));
     }
@@ -249,6 +435,23 @@ JSC_DEFINE_HOST_FUNCTION(jsBundlerPluginFunction_onResolveAsync, (JSC::JSGlobalO
     return JSC::JSValue::encode(JSC::jsUndefined());
 }
 
+extern "C" JSC::EncodedJSValue JSBundlerPlugin__appendDeferPromise(Bun::JSBundlerPlugin* pluginObject)
+{
+    JSC::JSGlobalObject* globalObject = pluginObject->globalObject();
+    Strong<JSPromise> strong_promise = JSC::Strong<JSPromise>(globalObject->vm(), JSPromise::create(globalObject->vm(), globalObject->promiseStructure()));
+    JSPromise* ret = strong_promise.get();
+    pluginObject->plugin.deferredPromises.append(strong_promise);
+
+    return JSC::JSValue::encode(ret);
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsBundlerPluginFunction_generateDeferPromise, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    JSBundlerPlugin* plugin = (JSBundlerPlugin*)UNWRAP_BUNDLER_PLUGIN(callFrame);
+    JSC::EncodedJSValue encoded_defer_promise = JSBundlerPlugin__onDefer(plugin, globalObject);
+    return encoded_defer_promise;
+}
+
 void JSBundlerPlugin::finishCreation(JSC::VM& vm)
 {
     Base::finishCreation(vm);
@@ -290,8 +493,9 @@ extern "C" bool JSBundlerPlugin__anyMatches(Bun::JSBundlerPlugin* pluginObject,
     return pluginObject->plugin.anyMatchesCrossThread(pluginObject->vm(), namespaceString, path, isOnLoad);
 }
 
-extern "C" void JSBundlerPlugin__matchOnLoad(JSC::JSGlobalObject* globalObject, Bun::JSBundlerPlugin* plugin, const BunString* namespaceString, const BunString* path, void* context, uint8_t defaultLoaderId)
+extern "C" void JSBundlerPlugin__matchOnLoad(Bun::JSBundlerPlugin* plugin, const BunString* namespaceString, const BunString* path, void* context, uint8_t defaultLoaderId, bool isServerSide)
 {
+    JSC::JSGlobalObject* globalObject = plugin->globalObject();
     WTF::String namespaceStringStr = namespaceString ? namespaceString->toWTFString(BunString::ZeroCopy) : WTF::String();
     WTF::String pathStr = path ? path->toWTFString(BunString::ZeroCopy) : WTF::String();
 
@@ -310,6 +514,7 @@ extern "C" void JSBundlerPlugin__matchOnLoad(JSC::JSGlobalObject* globalObject,
     arguments.append(JSC::jsString(plugin->vm(), pathStr));
     arguments.append(JSC::jsString(plugin->vm(), namespaceStringStr));
     arguments.append(JSC::jsNumber(defaultLoaderId));
+    arguments.append(JSC::jsBoolean(isServerSide));
 
     call(globalObject, function, callData, plugin, arguments);
 
@@ -326,8 +531,9 @@ extern "C" void JSBundlerPlugin__matchOnLoad(JSC::JSGlobalObject* globalObject,
     }
 }
 
-extern "C" void JSBundlerPlugin__matchOnResolve(JSC::JSGlobalObject* globalObject, Bun::JSBundlerPlugin* plugin, const BunString* namespaceString, const BunString* path, const BunString* importer, void* context, uint8_t kindId)
+extern "C" void JSBundlerPlugin__matchOnResolve(Bun::JSBundlerPlugin* plugin, const BunString* namespaceString, const BunString* path, const BunString* importer, void* context, uint8_t kindId)
 {
+    JSC::JSGlobalObject* globalObject = plugin->globalObject();
     WTF::String namespaceStringStr = namespaceString ? namespaceString->toWTFString(BunString::ZeroCopy) : WTF::String("file"_s);
     if (namespaceStringStr.length() == 0) {
         namespaceStringStr = WTF::String("file"_s);
@@ -361,7 +567,7 @@ extern "C" void JSBundlerPlugin__matchOnResolve(JSC::JSGlobalObject* globalObjec
         if (!plugin->plugin.tombstoned) {
             JSBundlerPlugin__addError(
                 context,
-                plugin->plugin.config,
+                plugin,
                 JSC::JSValue::encode(exception),
                 JSValue::encode(jsNumber(1)));
         }
@@ -386,7 +592,10 @@ extern "C" Bun::JSBundlerPlugin* JSBundlerPlugin__create(Zig::GlobalObject* glob
 extern "C" JSC::EncodedJSValue JSBundlerPlugin__runSetupFunction(
     Bun::JSBundlerPlugin* plugin,
     JSC::EncodedJSValue encodedSetupFunction,
-    JSC::EncodedJSValue encodedConfig)
+    JSC::EncodedJSValue encodedConfig,
+    JSC::EncodedJSValue encodedOnstartPromisesArray,
+    JSC::EncodedJSValue encodedIsLast,
+    JSC::EncodedJSValue encodedIsBake)
 {
     auto& vm = plugin->vm();
     auto scope = DECLARE_CATCH_SCOPE(vm);
@@ -402,16 +611,12 @@ extern "C" JSC::EncodedJSValue JSBundlerPlugin__runSetupFunction(
     MarkedArgumentBuffer arguments;
     arguments.append(JSValue::decode(encodedSetupFunction));
     arguments.append(JSValue::decode(encodedConfig));
+    arguments.append(JSValue::decode(encodedOnstartPromisesArray));
+    arguments.append(JSValue::decode(encodedIsLast));
+    arguments.append(JSValue::decode(encodedIsBake));
     auto* lexicalGlobalObject = jsCast<JSFunction*>(JSValue::decode(encodedSetupFunction))->globalObject();
 
-    auto result = call(lexicalGlobalObject, setupFunction, callData, plugin, arguments);
-    if (UNLIKELY(scope.exception())) {
-        auto exception = scope.exception();
-        scope.clearException();
-        return JSValue::encode(exception);
-    }
-
-    return JSValue::encode(result);
+    return JSC::JSValue::encode(JSC::call(lexicalGlobalObject, setupFunction, callData, plugin, arguments));
 }
 
 extern "C" void JSBundlerPlugin__setConfig(Bun::JSBundlerPlugin* plugin, void* config)
@@ -419,9 +624,44 @@ extern "C" void JSBundlerPlugin__setConfig(Bun::JSBundlerPlugin* plugin, void* c
     plugin->plugin.config = config;
 }
 
-extern "C" void JSBundlerPlugin__tombestone(Bun::JSBundlerPlugin* plugin)
+extern "C" void JSBundlerPlugin__drainDeferred(Bun::JSBundlerPlugin* pluginObject, bool rejected)
+{
+    auto deferredPromises = std::exchange(pluginObject->plugin.deferredPromises, {});
+    for (auto& promise : deferredPromises) {
+        if (rejected) {
+            promise->reject(pluginObject->globalObject(), JSC::jsUndefined());
+        } else {
+            promise->resolve(pluginObject->globalObject(), JSC::jsUndefined());
+        }
+        promise.clear();
+    }
+}
+
+extern "C" void JSBundlerPlugin__tombstone(Bun::JSBundlerPlugin* plugin)
 {
     plugin->plugin.tombstone();
 }
 
+extern "C" int JSBundlerPlugin__callOnBeforeParsePlugins(
+    Bun::JSBundlerPlugin* plugin,
+    void* bunContextPtr,
+    const BunString* namespaceStr,
+    const BunString* pathString,
+    OnBeforeParseArguments* onBeforeParseArgs,
+    void* onBeforeParseResult,
+    int* shouldContinue)
+{
+    return plugin->plugin.onBeforeParse.call(plugin->vm(), &plugin->plugin, shouldContinue, bunContextPtr, namespaceStr, pathString, onBeforeParseArgs, onBeforeParseResult);
+}
+
+extern "C" int JSBundlerPlugin__hasOnBeforeParsePlugins(Bun::JSBundlerPlugin* plugin)
+{
+    return plugin->plugin.onBeforeParse.namespaceCallbacks.size() > 0 || plugin->plugin.onBeforeParse.fileCallbacks.size() > 0;
+}
+
+extern "C" JSC::JSGlobalObject* JSBundlerPlugin__globalObject(Bun::JSBundlerPlugin* plugin)
+{
+    return plugin->m_globalObject;
+}
+
 } // namespace Bun
diff --git a/src/bun.js/bindings/JSBundlerPlugin.h b/src/bun.js/bindings/JSBundlerPlugin.h
index 3a1f062243..da28a8e485 100644
--- a/src/bun.js/bindings/JSBundlerPlugin.h
+++ b/src/bun.js/bindings/JSBundlerPlugin.h
@@ -3,15 +3,14 @@
 #include "root.h"
 #include "headers-handwritten.h"
 #include <JavaScriptCore/JSGlobalObject.h>
-#include <JavaScriptCore/Strong.h>
 #include <JavaScriptCore/RegularExpression.h>
-#include "helpers.h"
+#include "napi_external.h"
 #include <JavaScriptCore/Yarr.h>
-#include <JavaScriptCore/Strong.h>
 
 typedef void (*JSBundlerPluginAddErrorCallback)(void*, void*, JSC::EncodedJSValue, JSC::EncodedJSValue);
 typedef void (*JSBundlerPluginOnLoadAsyncCallback)(void*, void*, JSC::EncodedJSValue, JSC::EncodedJSValue);
 typedef void (*JSBundlerPluginOnResolveAsyncCallback)(void*, void*, JSC::EncodedJSValue, JSC::EncodedJSValue, JSC::EncodedJSValue);
+typedef void (*JSBundlerPluginNativeOnBeforeParseCallback)(void*, void*);
 
 namespace Bun {
 
@@ -19,22 +18,24 @@ using namespace JSC;
 
 class BundlerPlugin final {
 public:
-    class NamespaceList final {
+    class NamespaceList {
     public:
         Vector<Yarr::RegularExpression> fileNamespace = {};
         Vector<String> namespaces = {};
         Vector<Vector<Yarr::RegularExpression>> groups = {};
         BunPluginTarget target { BunPluginTargetBun };
 
-        Vector<Yarr::RegularExpression>* group(const String& namespaceStr)
+        Vector<Yarr::RegularExpression>* group(const String& namespaceStr, unsigned& index)
         {
             if (namespaceStr.isEmpty()) {
+                index = std::numeric_limits<unsigned>::max();
                 return &fileNamespace;
             }
 
             size_t length = namespaces.size();
             for (size_t i = 0; i < length; i++) {
                 if (namespaces[i] == namespaceStr) {
+                    index = i;
                     return &groups[i];
                 }
             }
@@ -42,7 +43,56 @@ public:
             return nullptr;
         }
 
-        void append(JSC::VM& vm, JSC::RegExp* filter, String& namespaceString);
+        void append(JSC::VM& vm, JSC::RegExp* filter, String& namespaceString, unsigned& index);
+    };
+
+    /// In native plugins, the regular expression could be called concurrently on multiple threads.
+    /// Therefore, we need a mutex to synchronize access.
+    typedef std::pair<Yarr::RegularExpression, std::shared_ptr<std::mutex>> NativeFilterRegexp;
+
+    struct NativePluginCallback {
+        JSBundlerPluginNativeOnBeforeParseCallback callback;
+        Bun::NapiExternal* external;
+        /// This refers to the string exported in the native plugin under
+        /// the symbol BUN_PLUGIN_NAME
+        ///
+        /// Right now we do not close NAPI modules opened with dlopen and
+        /// so we do not worry about lifetimes right now.
+        const char* name;
+    };
+
+    class NativePluginList {
+    public:
+        using PerNamespaceCallbackList = Vector<NativePluginCallback>;
+
+        Vector<NativeFilterRegexp> fileNamespace = {};
+        Vector<String> namespaces = {};
+        Vector<Vector<NativeFilterRegexp>> groups = {};
+        BunPluginTarget target { BunPluginTargetBun };
+
+        PerNamespaceCallbackList fileCallbacks = {};
+        Vector<PerNamespaceCallbackList> namespaceCallbacks = {};
+
+        int call(JSC::VM& vm, BundlerPlugin* plugin, int* shouldContinue, void* bunContextPtr, const BunString* namespaceStr, const BunString* pathString, void* onBeforeParseArgs, void* onBeforeParseResult);
+        void append(JSC::VM& vm, JSC::RegExp* filter, String& namespaceString, JSBundlerPluginNativeOnBeforeParseCallback callback, const char* name, NapiExternal* external);
+
+        Vector<NativeFilterRegexp>* group(const String& namespaceStr, unsigned& index)
+        {
+            if (namespaceStr.isEmpty()) {
+                index = std::numeric_limits<unsigned>::max();
+                return &fileNamespace;
+            }
+
+            size_t length = namespaces.size();
+            for (size_t i = 0; i < length; i++) {
+                if (namespaces[i] == namespaceStr) {
+                    index = i;
+                    return &groups[i];
+                }
+            }
+
+            return nullptr;
+        }
     };
 
 public:
@@ -60,8 +110,11 @@ public:
 
     NamespaceList onLoad = {};
     NamespaceList onResolve = {};
+    NativePluginList onBeforeParse = {};
     BunPluginTarget target { BunPluginTargetBrowser };
 
+    Vector<Strong<JSPromise>> deferredPromises = {};
+
     JSBundlerPluginAddErrorCallback addError;
     JSBundlerPluginOnLoadAsyncCallback onLoadAsync;
     JSBundlerPluginOnResolveAsyncCallback onResolveAsync;
@@ -69,4 +122,4 @@ public:
     bool tombstoned { false };
 };
 
-} // namespace Zig
\ No newline at end of file
+} // namespace Zig
diff --git a/src/bun.js/bindings/JSCTaskScheduler.h b/src/bun.js/bindings/JSCTaskScheduler.h
index 45a6d3888d..29660c406d 100644
--- a/src/bun.js/bindings/JSCTaskScheduler.h
+++ b/src/bun.js/bindings/JSCTaskScheduler.h
@@ -26,4 +26,4 @@ public:
     HashSet<Ref<JSC::DeferredWorkTimer::TicketData>> m_pendingTicketsOther;
 };
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/JSCTestingHelpers.cpp b/src/bun.js/bindings/JSCTestingHelpers.cpp
index 5f64580d35..78092eec0c 100644
--- a/src/bun.js/bindings/JSCTestingHelpers.cpp
+++ b/src/bun.js/bindings/JSCTestingHelpers.cpp
@@ -68,4 +68,4 @@ JSC::JSValue createJSCTestingHelpers(Zig::GlobalObject* globalObject)
     return object;
 }
 
-} // namespace Bun
\ No newline at end of file
+} // namespace Bun
diff --git a/src/bun.js/bindings/JSCTestingHelpers.h b/src/bun.js/bindings/JSCTestingHelpers.h
index fad7dd0665..db46851b7a 100644
--- a/src/bun.js/bindings/JSCTestingHelpers.h
+++ b/src/bun.js/bindings/JSCTestingHelpers.h
@@ -2,4 +2,4 @@ namespace Bun {
 
 JSC::JSValue createJSCTestingHelpers(Zig::GlobalObject* global);
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/JSCUSocketsLoopIntegration.cpp b/src/bun.js/bindings/JSCUSocketsLoopIntegration.cpp
deleted file mode 100644
index 0e3fcf47dc..0000000000
--- a/src/bun.js/bindings/JSCUSocketsLoopIntegration.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-#include "root.h"
-#include "JavaScriptCore/VM.h"
-
-// On Linux, signals are used to suspend/resume threads in JavaScriptCore
-// When `.acquireAccess` is called, the signal might be raised.
-// This causes issues with LLDB which might catch the signal.
-// So we want to avoid that, we really only want this code to be executed when the debugger is attached
-// But it's pretty hard to tell if LLDB is attached or not, so we just disable this code on Linux when in debug mode
-#ifndef ACQUIRE_RELEASE_HEAP_ACCESS
-#if OS(DARWIN)
-#define ACQUIRE_RELEASE_HEAP_ACCESS 1
-#else
-#ifndef BUN_DEBUG
-#define ACQUIRE_RELEASE_HEAP_ACCESS 1
-#endif
-#endif
-#endif
-
-extern "C" void bun_on_tick_before(JSC::VM* vm)
-{
-#if ACQUIRE_RELEASE_HEAP_ACCESS
-    // vm->heap.releaseAccess();
-#endif
-}
-extern "C" void bun_on_tick_after(JSC::VM* vm)
-{
-#if ACQUIRE_RELEASE_HEAP_ACCESS
-    // vm->heap.acquireAccess();
-#endif
-}
\ No newline at end of file
diff --git a/src/bun.js/bindings/JSDOMConvertBufferSource+JSBuffer.h b/src/bun.js/bindings/JSDOMConvertBufferSource+JSBuffer.h
index 88664ff257..d7e2a80062 100644
--- a/src/bun.js/bindings/JSDOMConvertBufferSource+JSBuffer.h
+++ b/src/bun.js/bindings/JSDOMConvertBufferSource+JSBuffer.h
@@ -8,4 +8,4 @@
 
 namespace WebCore {
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/JSDOMFile.cpp b/src/bun.js/bindings/JSDOMFile.cpp
index 212cbeb0c0..6b6f980062 100644
--- a/src/bun.js/bindings/JSDOMFile.cpp
+++ b/src/bun.js/bindings/JSDOMFile.cpp
@@ -110,4 +110,4 @@ JSC::JSObject* createJSDOMFileConstructor(JSC::VM& vm, JSC::JSGlobalObject* glob
     return JSDOMFile::create(vm, globalObject);
 }
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/JSDOMGlobalObject.cpp b/src/bun.js/bindings/JSDOMGlobalObject.cpp
index f90268828d..c83a1a95cb 100644
--- a/src/bun.js/bindings/JSDOMGlobalObject.cpp
+++ b/src/bun.js/bindings/JSDOMGlobalObject.cpp
@@ -84,4 +84,4 @@ Zig::GlobalObject* toJSDOMGlobalObject(ScriptExecutionContext& ctx, DOMWrapperWo
 //     return callerGlobalObject(lexicalGlobalObject, callFrame, skipFirstFrame, lookUpFromVMEntryScope);
 // }
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/JSDOMGlobalObject.h b/src/bun.js/bindings/JSDOMGlobalObject.h
index 9e33508a93..49281d94ac 100644
--- a/src/bun.js/bindings/JSDOMGlobalObject.h
+++ b/src/bun.js/bindings/JSDOMGlobalObject.h
@@ -35,4 +35,4 @@ JSClass* toJSDOMGlobalObject(JSC::VM& vm, JSC::JSValue value)
     return nullptr;
 }
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/JSEnvironmentVariableMap.h b/src/bun.js/bindings/JSEnvironmentVariableMap.h
index 7cc605303e..0de7c81ba4 100644
--- a/src/bun.js/bindings/JSEnvironmentVariableMap.h
+++ b/src/bun.js/bindings/JSEnvironmentVariableMap.h
@@ -12,4 +12,4 @@ namespace Bun {
 
 JSC::JSValue createEnvironmentVariablesMap(Zig::GlobalObject* globalObject);
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/JSFFIFunction.cpp b/src/bun.js/bindings/JSFFIFunction.cpp
index 6f5d9dcf4c..9533ed444e 100644
--- a/src/bun.js/bindings/JSFFIFunction.cpp
+++ b/src/bun.js/bindings/JSFFIFunction.cpp
@@ -113,7 +113,7 @@ extern "C" void Bun__untrackFFIFunction(Zig::GlobalObject* globalObject, JSC::En
 {
     globalObject->untrackFFIFunction(JSC::jsCast<JSC::JSFunction*>(JSC::JSValue::decode(function)));
 }
-extern "C" JSC::EncodedJSValue Bun__CreateFFIFunctionValue(Zig::GlobalObject* globalObject, const ZigString* symbolName, unsigned argCount, Zig::FFIFunction functionPointer, bool strong, bool addPtrField)
+extern "C" JSC::EncodedJSValue Bun__CreateFFIFunctionValue(Zig::GlobalObject* globalObject, const ZigString* symbolName, unsigned argCount, Zig::FFIFunction functionPointer, bool strong, bool addPtrField, void* symbolFromDynamicLibrary)
 {
     if (addPtrField) {
         auto* function = Zig::JSFFIFunction::createForFFI(globalObject->vm(), globalObject, argCount, symbolName != nullptr ? Zig::toStringCopy(*symbolName) : String(), reinterpret_cast<Bun::CFFIFunction>(functionPointer));
@@ -121,8 +121,8 @@ extern "C" JSC::EncodedJSValue Bun__CreateFFIFunctionValue(Zig::GlobalObject* gl
         // We should only expose the "ptr" field when it's a JSCallback for bun:ffi.
         // Not for internal usages of this function type.
         // We should also consider a separate JSFunction type for our usage to not have this branch in the first place...
-        function->putDirect(vm, JSC::Identifier::fromString(vm, String(MAKE_STATIC_STRING_IMPL("ptr"))), JSC::jsNumber(bitwise_cast<double>(functionPointer)), JSC::PropertyAttribute::ReadOnly | 0);
-
+        function->putDirect(vm, JSC::Identifier::fromString(vm, String("ptr"_s)), JSC::jsNumber(bitwise_cast<double>(functionPointer)), JSC::PropertyAttribute::ReadOnly | 0);
+        function->symbolFromDynamicLibrary = symbolFromDynamicLibrary;
         return JSC::JSValue::encode(function);
     }
 
diff --git a/src/bun.js/bindings/JSFFIFunction.h b/src/bun.js/bindings/JSFFIFunction.h
index 078cb8073b..9bd99c34e5 100644
--- a/src/bun.js/bindings/JSFFIFunction.h
+++ b/src/bun.js/bindings/JSFFIFunction.h
@@ -87,6 +87,7 @@ public:
 #endif
 
     void* dataPtr;
+    void* symbolFromDynamicLibrary { nullptr };
 
 private:
     JSFFIFunction(VM&, NativeExecutable*, JSGlobalObject*, Structure*, CFFIFunction&&);
diff --git a/src/bun.js/bindings/JSMockFunction.cpp b/src/bun.js/bindings/JSMockFunction.cpp
index 699f695a45..5140505d04 100644
--- a/src/bun.js/bindings/JSMockFunction.cpp
+++ b/src/bun.js/bindings/JSMockFunction.cpp
@@ -1585,4 +1585,4 @@ BUN_DEFINE_HOST_FUNCTION(JSMock__jsMockFn, (JSC::JSGlobalObject * lexicalGlobalO
     return JSValue::encode(thisObject);
 }
 
-#undef CHECK_IS_MOCK_FUNCTION
\ No newline at end of file
+#undef CHECK_IS_MOCK_FUNCTION
diff --git a/src/bun.js/bindings/JSNextTickQueue.cpp b/src/bun.js/bindings/JSNextTickQueue.cpp
index 6c3557177b..7b9c1f98bb 100644
--- a/src/bun.js/bindings/JSNextTickQueue.cpp
+++ b/src/bun.js/bindings/JSNextTickQueue.cpp
@@ -93,4 +93,4 @@ void JSNextTickQueue::drain(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
     }
 }
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/JSNextTickQueue.h b/src/bun.js/bindings/JSNextTickQueue.h
index 3a499345d8..63c75f6453 100644
--- a/src/bun.js/bindings/JSNextTickQueue.h
+++ b/src/bun.js/bindings/JSNextTickQueue.h
@@ -37,4 +37,4 @@ public:
     bool isEmpty();
     void drain(JSC::VM& vm, JSC::JSGlobalObject* globalObject);
 };
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/JSPropertyIterator.zig b/src/bun.js/bindings/JSPropertyIterator.zig
index 53c1ee6af4..f5361cc3ae 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/JSWrappingFunction.h b/src/bun.js/bindings/JSWrappingFunction.h
index ed3a925583..ac9b9d1919 100644
--- a/src/bun.js/bindings/JSWrappingFunction.h
+++ b/src/bun.js/bindings/JSWrappingFunction.h
@@ -71,4 +71,4 @@ private:
     JSC::WriteBarrier<JSC::JSFunction> m_wrappedFn;
 };
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/KeyObject.cpp b/src/bun.js/bindings/KeyObject.cpp
index 7578448315..ba7733b036 100644
--- a/src/bun.js/bindings/KeyObject.cpp
+++ b/src/bun.js/bindings/KeyObject.cpp
@@ -2769,8 +2769,6 @@ JSC_DEFINE_HOST_FUNCTION(KeyObject__generateKeySync, (JSC::JSGlobalObject * lexi
             throwException(lexicalGlobalObject, scope, createTypeError(lexicalGlobalObject, "Invalid length"_s));
             return {};
         }
-        // TODO(@paperdave 2023-10-19): i removed WTFMove from result.releaseNonNull() as per MSVC compiler error.
-        // We need to evaluate if that is the proper fix here.
         return JSC::JSValue::encode(JSCryptoKey::create(structure, zigGlobalObject, result.releaseNonNull()));
     } else {
         throwException(lexicalGlobalObject, scope, createTypeError(lexicalGlobalObject, "algorithm should be 'aes' or 'hmac'"_s));
@@ -3113,7 +3111,7 @@ static EncodedJSValue doAsymmetricSign(JSGlobalObject* globalObject, CallFrame*
         // We may classify the key as RSA_OAEP, but it can still be used for signing. RSA_PSS relies
         // on an incompatible scheme, and must be used via the generic crypto.sign function.
         || (cryptoKey.algorithmIdentifier() != CryptoAlgorithmIdentifier::RSA_OAEP
-        && cryptoKey.algorithmIdentifier() != CryptoAlgorithmIdentifier::RSASSA_PKCS1_v1_5)) {
+            && cryptoKey.algorithmIdentifier() != CryptoAlgorithmIdentifier::RSASSA_PKCS1_v1_5)) {
         return Bun::throwError(globalObject, scope, Bun::ErrorCode::ERR_INVALID_ARG_VALUE,
             "unsupported key type for asymmetric signing"_s);
     }
@@ -3141,7 +3139,7 @@ static EncodedJSValue doAsymmetricSign(JSGlobalObject* globalObject, CallFrame*
 
     const auto& rsaKey = downcast<CryptoKeyRSA>(cryptoKey);
     auto operation = encrypt ? CryptoAlgorithmRSASSA_PKCS1_v1_5::platformSignNoAlgorithm
-        : CryptoAlgorithmRSASSA_PKCS1_v1_5::platformVerifyRecover;
+                             : CryptoAlgorithmRSASSA_PKCS1_v1_5::platformVerifyRecover;
     auto result = operation(rsaKey, padding, buffer);
     if (result.hasException()) {
         WebCore::propagateException(*globalObject, scope, result.releaseException());
@@ -3151,12 +3149,12 @@ static EncodedJSValue doAsymmetricSign(JSGlobalObject* globalObject, CallFrame*
     return JSValue::encode(WebCore::createBuffer(globalObject, outBuffer));
 }
 
-JSC_DEFINE_HOST_FUNCTION(KeyObject__privateEncrypt, (JSGlobalObject* globalObject, CallFrame* callFrame))
+JSC_DEFINE_HOST_FUNCTION(KeyObject__privateEncrypt, (JSGlobalObject * globalObject, CallFrame* callFrame))
 {
     return doAsymmetricSign(globalObject, callFrame, true);
 }
 
-JSC_DEFINE_HOST_FUNCTION(KeyObject__publicDecrypt, (JSGlobalObject* globalObject, CallFrame* callFrame))
+JSC_DEFINE_HOST_FUNCTION(KeyObject__publicDecrypt, (JSGlobalObject * globalObject, CallFrame* callFrame))
 {
     return doAsymmetricSign(globalObject, callFrame, false);
 }
diff --git a/src/bun.js/bindings/ModuleLoader.cpp b/src/bun.js/bindings/ModuleLoader.cpp
index c1cd391b9b..bb0653d1e8 100644
--- a/src/bun.js/bindings/ModuleLoader.cpp
+++ b/src/bun.js/bindings/ModuleLoader.cpp
@@ -455,8 +455,6 @@ extern "C" void Bun__onFulfillAsyncModule(
     }
 }
 
-extern "C" bool isBunTest;
-
 JSValue fetchCommonJSModule(
     Zig::GlobalObject* globalObject,
     JSCommonJSModule* target,
@@ -517,6 +515,16 @@ JSValue fetchCommonJSModule(
 
         auto tag = res->result.value.tag;
         switch (tag) {
+        case SyntheticModuleType::NodeModule: {
+            target->setExportsObject(globalObject->m_nodeModuleConstructor.getInitializedOnMainThread(globalObject));
+            target->hasEvaluated = true;
+            RELEASE_AND_RETURN(scope, target);
+        }
+        case SyntheticModuleType::NodeProcess: {
+            target->setExportsObject(globalObject->processObject());
+            target->hasEvaluated = true;
+            RELEASE_AND_RETURN(scope, target);
+        }
 // Generated native module cases
 #define CASE(str, name)                                                                                           \
     case SyntheticModuleType::name: {                                                                             \
@@ -524,7 +532,7 @@ JSValue fetchCommonJSModule(
         RETURN_IF_EXCEPTION(scope, {});                                                                           \
         RELEASE_AND_RETURN(scope, target);                                                                        \
     }
-            BUN_FOREACH_NATIVE_MODULE(CASE)
+            BUN_FOREACH_CJS_NATIVE_MODULE(CASE)
 #undef CASE
 
         case SyntheticModuleType::ESM: {
@@ -715,6 +723,23 @@ static JSValue fetchESMSourceCode(
             return reject(exception);
         }
 
+        // This can happen if it's a `bun build --compile`'d CommonJS file
+        if (res->result.value.isCommonJSModule) {
+            auto created = Bun::createCommonJSModule(globalObject, specifierJS, res->result.value);
+
+            if (created.has_value()) {
+                return rejectOrResolve(JSSourceCode::create(vm, WTFMove(created.value())));
+            }
+
+            if constexpr (allowPromise) {
+                auto* exception = scope.exception();
+                scope.clearException();
+                return rejectedInternalPromise(globalObject, exception);
+            } else {
+                return {};
+            }
+        }
+
         auto moduleKey = specifier->toWTFString(BunString::ZeroCopy);
 
         auto tag = res->result.value.tag;
@@ -729,7 +754,7 @@ static JSValue fetchESMSourceCode(
         auto source = JSC::SourceCode(JSC::SyntheticSourceProvider::create(generateNativeModule_##name, JSC::SourceOrigin(), WTFMove(moduleKey))); \
         return rejectOrResolve(JSSourceCode::create(vm, WTFMove(source)));                                                                         \
     }
-            BUN_FOREACH_NATIVE_MODULE(CASE)
+            BUN_FOREACH_ESM_NATIVE_MODULE(CASE)
 #undef CASE
 
         // CommonJS modules from src/js/*
diff --git a/src/bun.js/bindings/ModuleLoader.h b/src/bun.js/bindings/ModuleLoader.h
index 6816c0fd0b..d38ed441e1 100644
--- a/src/bun.js/bindings/ModuleLoader.h
+++ b/src/bun.js/bindings/ModuleLoader.h
@@ -47,6 +47,8 @@ struct OnLoadResult {
     bool wasMock;
 };
 
+extern "C" bool isBunTest;
+
 class PendingVirtualModuleResult : public JSC::JSInternalFieldObjectImpl<3> {
 public:
     using Base = JSC::JSInternalFieldObjectImpl<3>;
diff --git a/src/bun.js/bindings/NodeAsyncHooks.cpp b/src/bun.js/bindings/NodeAsyncHooks.cpp
index 8828d2d354..c36ed476f1 100644
--- a/src/bun.js/bindings/NodeAsyncHooks.cpp
+++ b/src/bun.js/bindings/NodeAsyncHooks.cpp
@@ -48,4 +48,4 @@ JSC::JSValue createAsyncHooksBinding(Zig::GlobalObject* globalObject)
     return binding;
 }
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/NodeAsyncHooks.h b/src/bun.js/bindings/NodeAsyncHooks.h
index 84e7c95b13..466dd70e2b 100644
--- a/src/bun.js/bindings/NodeAsyncHooks.h
+++ b/src/bun.js/bindings/NodeAsyncHooks.h
@@ -2,7 +2,7 @@
 #include "ZigGlobalObject.h"
 
 namespace Bun {
-  
+
 JSC::JSValue createAsyncHooksBinding(Zig::GlobalObject*);
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/NodeFetch.cpp b/src/bun.js/bindings/NodeFetch.cpp
index 1b25af677d..742a4fb0e7 100644
--- a/src/bun.js/bindings/NodeFetch.cpp
+++ b/src/bun.js/bindings/NodeFetch.cpp
@@ -47,4 +47,4 @@ JSC::JSValue createNodeFetchInternalBinding(Zig::GlobalObject* globalObject)
     return obj;
 }
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/NodeFetch.h b/src/bun.js/bindings/NodeFetch.h
index 2b20c2d0be..ee4ee9875d 100644
--- a/src/bun.js/bindings/NodeFetch.h
+++ b/src/bun.js/bindings/NodeFetch.h
@@ -4,4 +4,4 @@ namespace Bun {
 
 JSC::JSValue createNodeFetchInternalBinding(Zig::GlobalObject*);
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/NodeHTTP.h b/src/bun.js/bindings/NodeHTTP.h
index e79a2b21d1..d953e3b0f5 100644
--- a/src/bun.js/bindings/NodeHTTP.h
+++ b/src/bun.js/bindings/NodeHTTP.h
@@ -1,11 +1,11 @@
 #include "config.h"
 
 namespace Bun {
-  
+
 JSC_DECLARE_HOST_FUNCTION(jsHTTPAssignHeaders);
 JSC_DECLARE_HOST_FUNCTION(jsHTTPGetHeader);
 JSC_DECLARE_HOST_FUNCTION(jsHTTPSetHeader);
 
 JSC::JSValue createNodeHTTPInternalBinding(Zig::GlobalObject*);
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/NodeTLS.cpp b/src/bun.js/bindings/NodeTLS.cpp
index f1c5efa37d..71ba5fa7fd 100644
--- a/src/bun.js/bindings/NodeTLS.cpp
+++ b/src/bun.js/bindings/NodeTLS.cpp
@@ -37,4 +37,4 @@ JSC::JSValue createNodeTLSBinding(Zig::GlobalObject* globalObject)
     return obj;
 }
 
-} // namespace Bun
\ No newline at end of file
+} // namespace Bun
diff --git a/src/bun.js/bindings/NodeTLS.h b/src/bun.js/bindings/NodeTLS.h
index 1f1fdb7b3f..2650f0cfaf 100644
--- a/src/bun.js/bindings/NodeTLS.h
+++ b/src/bun.js/bindings/NodeTLS.h
@@ -2,7 +2,7 @@
 #include "ZigGlobalObject.h"
 
 namespace Bun {
-  
+
 JSC::JSValue createNodeTLSBinding(Zig::GlobalObject*);
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/NodeURL.h b/src/bun.js/bindings/NodeURL.h
index 69a13e2d25..3252194123 100644
--- a/src/bun.js/bindings/NodeURL.h
+++ b/src/bun.js/bindings/NodeURL.h
@@ -5,4 +5,4 @@ namespace Bun {
 
 JSC::JSValue createNodeURLBinding(Zig::GlobalObject*);
 
-} // namespace Bun
\ No newline at end of file
+} // namespace Bun
diff --git a/src/bun.js/bindings/NodeValidator.cpp b/src/bun.js/bindings/NodeValidator.cpp
new file mode 100644
index 0000000000..c259609ef6
--- /dev/null
+++ b/src/bun.js/bindings/NodeValidator.cpp
@@ -0,0 +1,466 @@
+#include "root.h"
+
+#include "ZigGlobalObject.h"
+#include "JavaScriptCore/JSGlobalObject.h"
+#include "JavaScriptCore/JSCJSValue.h"
+#include "JavaScriptCore/ExceptionScope.h"
+#include "JavaScriptCore/CallData.h"
+#include "JavaScriptCore/JSObjectInlines.h"
+#include "JavaScriptCore/JSType.h"
+#include "JavaScriptCore/TypedArrayType.h"
+#include "JavaScriptCore/ArrayConstructor.h"
+#include <cmath>
+#include <limits>
+
+#include "JSAbortSignal.h"
+#include "JSBufferEncodingType.h"
+#include "BunProcess.h"
+#include "ErrorCode.h"
+#include "NodeValidator.h"
+
+namespace Bun {
+
+using namespace JSC;
+
+JSC_DEFINE_HOST_FUNCTION(jsFunction_validateInteger, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    JSC::VM& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    auto value = callFrame->argument(0);
+    auto name = callFrame->argument(1);
+    auto min = callFrame->argument(2);
+    auto max = callFrame->argument(3);
+    return Bun::V::validateInteger(scope, globalObject, value, name, min, max);
+}
+JSC::EncodedJSValue V::validateInteger(JSC::ThrowScope& scope, JSC::JSGlobalObject* globalObject, JSC::JSValue value, JSC::JSValue name, JSC::JSValue min, JSC::JSValue max)
+{
+    if (!value.isNumber()) return Bun::ERR::INVALID_ARG_TYPE(scope, globalObject, name, "number"_s, value);
+    if (min.isUndefined()) min = jsDoubleNumber(JSC::minSafeInteger());
+    if (max.isUndefined()) max = jsDoubleNumber(JSC::maxSafeInteger());
+
+    auto value_num = value.asNumber();
+    auto min_num = min.toNumber(globalObject);
+    RETURN_IF_EXCEPTION(scope, {});
+    auto max_num = max.toNumber(globalObject);
+    RETURN_IF_EXCEPTION(scope, {});
+    max_num = std::max(min_num, max_num);
+
+    if (std::fmod(value_num, 1.0) != 0) return Bun::ERR::OUT_OF_RANGE(scope, globalObject, name, "an integer"_s, value);
+    if (value_num < min_num || value_num > max_num) return Bun::ERR::OUT_OF_RANGE(scope, globalObject, name, min_num, max_num, value);
+
+    return JSValue::encode(jsUndefined());
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunction_validateNumber, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    JSC::VM& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    auto value = callFrame->argument(0);
+    auto name = callFrame->argument(1);
+    auto min = callFrame->argument(2);
+    auto max = callFrame->argument(3);
+    return Bun::V::validateNumber(scope, globalObject, value, name, min, max);
+}
+JSC::EncodedJSValue V::validateNumber(JSC::ThrowScope& scope, JSC::JSGlobalObject* globalObject, JSValue value, JSValue name, JSValue min, JSValue max)
+{
+    if (!value.isNumber()) return Bun::ERR::INVALID_ARG_TYPE(scope, globalObject, name, "number"_s, value);
+
+    auto value_num = value.asNumber();
+    auto min_num = min.toNumber(globalObject);
+    RETURN_IF_EXCEPTION(scope, {});
+    auto max_num = max.toNumber(globalObject);
+    RETURN_IF_EXCEPTION(scope, {});
+
+    auto min_isnonnull = !min.isUndefinedOrNull();
+    auto max_isnonnull = !max.isUndefinedOrNull();
+
+    if ((min_isnonnull && value_num < min_num) || (max_isnonnull && value_num > max_num) || ((min_isnonnull || max_isnonnull) && std::isnan(value_num))) {
+        if (min_isnonnull && max_isnonnull) return Bun::ERR::OUT_OF_RANGE(scope, globalObject, name, min_num, max_num, value);
+        if (min_isnonnull) return Bun::ERR::OUT_OF_RANGE(scope, globalObject, name, min_num, Bun::LOWER, value);
+        if (max_isnonnull) return Bun::ERR::OUT_OF_RANGE(scope, globalObject, name, max_num, Bun::UPPER, value);
+        return Bun::ERR::OUT_OF_RANGE(scope, globalObject, name, ""_s, value);
+    }
+
+    return JSValue::encode(jsUndefined());
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunction_validateString, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    JSC::VM& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    auto value = callFrame->argument(0);
+    auto name = callFrame->argument(1);
+    return V::validateString(scope, globalObject, value, name);
+}
+
+JSC::EncodedJSValue V::validateString(JSC::ThrowScope& scope, JSC::JSGlobalObject* globalObject, JSValue value, ASCIILiteral name)
+{
+    if (!value.isString()) {
+        return Bun::ERR::INVALID_ARG_TYPE(scope, globalObject, name, "string"_s, value);
+    }
+    return JSValue::encode(jsUndefined());
+}
+
+JSC::EncodedJSValue V::validateString(JSC::ThrowScope& scope, JSC::JSGlobalObject* globalObject, JSValue value, JSValue name)
+{
+    if (!value.isString()) {
+        return Bun::ERR::INVALID_ARG_TYPE(scope, globalObject, name, "string"_s, value);
+    }
+    return JSValue::encode(jsUndefined());
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunction_validateFiniteNumber, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    JSC::VM& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    auto number = callFrame->argument(0);
+    auto name = callFrame->argument(1);
+    return Bun::V::validateFiniteNumber(scope, globalObject, number, name);
+}
+JSC::EncodedJSValue V::validateFiniteNumber(JSC::ThrowScope& scope, JSC::JSGlobalObject* globalObject, JSValue number, JSValue name)
+{
+    if (number.isUndefined()) {
+        return JSValue::encode(jsBoolean(false));
+    }
+    if (number.isNumber() && (!std::isnan(number.asNumber())) && (!std::isinf(number.asNumber()))) {
+        return JSValue::encode(jsBoolean(true));
+    }
+    if (number.isNumber() && std::isnan(number.asNumber())) {
+        return JSValue::encode(jsBoolean(false));
+    }
+
+    Bun::V::validateNumber(scope, globalObject, number, name, jsUndefined(), jsUndefined());
+    RETURN_IF_EXCEPTION(scope, {});
+
+    return Bun::ERR::OUT_OF_RANGE(scope, globalObject, name, "a finite number"_s, number);
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunction_checkRangesOrGetDefault, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    JSC::VM& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    auto number = callFrame->argument(0);
+    auto name = callFrame->argument(1);
+    auto lower = callFrame->argument(2);
+    auto upper = callFrame->argument(3);
+
+    auto finite = Bun::V::validateFiniteNumber(scope, globalObject, number, name);
+    RETURN_IF_EXCEPTION(scope, {});
+    auto finite_real = JSValue::decode(finite).asBoolean();
+    if (!finite_real) {
+        auto def = callFrame->argument(4);
+        return JSValue::encode(def);
+    }
+
+    auto number_num = number.toNumber(globalObject);
+    RETURN_IF_EXCEPTION(scope, {});
+    auto lower_num = lower.toNumber(globalObject);
+    RETURN_IF_EXCEPTION(scope, {});
+    auto upper_num = upper.toNumber(globalObject);
+    RETURN_IF_EXCEPTION(scope, {});
+
+    if (number_num < lower_num || number_num > upper_num) {
+        return Bun::ERR::OUT_OF_RANGE(scope, globalObject, name, lower_num, upper_num, number);
+    }
+    return JSValue::encode(number);
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunction_validateFunction, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    JSC::VM& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    auto value = callFrame->argument(0);
+    auto name = callFrame->argument(1);
+
+    if (JSC::getCallData(value).type == JSC::CallData::Type::None) {
+        return Bun::ERR::INVALID_ARG_TYPE(scope, globalObject, name, "function"_s, value);
+    }
+    return JSValue::encode(jsUndefined());
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunction_validateBoolean, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    JSC::VM& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    auto value = callFrame->argument(0);
+    auto name = callFrame->argument(1);
+
+    if (!value.isBoolean()) {
+        return Bun::ERR::INVALID_ARG_TYPE(scope, globalObject, name, "boolean"_s, value);
+    }
+    return JSValue::encode(jsUndefined());
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunction_validatePort, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    JSC::VM& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    auto port = callFrame->argument(0);
+    auto name = callFrame->argument(1);
+    auto allowZero = callFrame->argument(2);
+
+    if (name.isUndefined()) name = jsString(vm, String("Port"_s));
+    if (allowZero.isUndefined()) allowZero = jsBoolean(true);
+
+    auto allowZero_b = allowZero.toBoolean(globalObject);
+    RETURN_IF_EXCEPTION(scope, {});
+
+    if (!port.isNumber() && !port.isString()) return Bun::ERR::SOCKET_BAD_PORT(scope, globalObject, name, port, allowZero_b);
+
+    if (port.isString()) {
+        auto port_str = port.getString(globalObject);
+        auto trimmed = port_str.trim([](auto c) {
+            // https://tc39.es/ecma262/multipage/text-processing.html#sec-string.prototype.trim
+            // The definition of white space is the union of *WhiteSpace* and *LineTerminator*.
+
+            // WhiteSpace ::
+            if (c == 0x0009) return true; //     <TAB>
+            if (c == 0x000B) return true; //     <VT>
+            if (c == 0x000C) return true; //     <FF>
+            if (c == 0xFEFF) return true; //     <ZWNBSP>
+            //     <USP>
+            // any code point in general category “Space_Separator”
+            // ranges accurate as of unicode 16.0.0
+            if (c >= 0x0009 && c <= 0x000D) return true;
+            if (c >= 0x0020 && c <= 0x0020) return true;
+            if (c >= 0x0085 && c <= 0x0085) return true;
+            if (c >= 0x00A0 && c <= 0x00A0) return true;
+            if (c >= 0x1680 && c <= 0x1680) return true;
+            if (c >= 0x2000 && c <= 0x200A) return true;
+            if (c >= 0x2028 && c <= 0x2028) return true;
+            if (c >= 0x2029 && c <= 0x2029) return true;
+            if (c >= 0x202F && c <= 0x202F) return true;
+            if (c >= 0x205F && c <= 0x205F) return true;
+
+            // LineTerminator ::
+            if (c == 0x000A) return true; // <LF>
+            if (c == 0x000D) return true; // <CR>
+            if (c == 0x2028) return true; // <LS>
+            if (c == 0x2029) return true; // <PS>
+
+            return false;
+        });
+        if (trimmed.length() == 0) {
+            return Bun::ERR::SOCKET_BAD_PORT(scope, globalObject, name, port, allowZero_b);
+        }
+    }
+
+    auto port_num = port.toNumber(globalObject);
+    RETURN_IF_EXCEPTION(scope, {});
+
+    if (std::isnan(port_num)) return Bun::ERR::SOCKET_BAD_PORT(scope, globalObject, name, port, allowZero_b);
+    if (std::isinf(port_num)) return Bun::ERR::SOCKET_BAD_PORT(scope, globalObject, name, port, allowZero_b);
+    if (std::fmod(port_num, 1.0) != 0) return Bun::ERR::SOCKET_BAD_PORT(scope, globalObject, name, port, allowZero_b);
+    if (port_num < 0) return Bun::ERR::SOCKET_BAD_PORT(scope, globalObject, name, port, allowZero_b);
+    if (port_num > 0xffff) return Bun::ERR::SOCKET_BAD_PORT(scope, globalObject, name, port, allowZero_b);
+    if (port_num == 0 && !allowZero_b) return Bun::ERR::SOCKET_BAD_PORT(scope, globalObject, name, port, allowZero_b);
+
+    return JSValue::encode(port);
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunction_validateAbortSignal, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    JSC::VM& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    auto signal = callFrame->argument(0);
+    auto name = callFrame->argument(1);
+
+    if (!signal.isUndefined()) {
+        auto* object = signal.getObject();
+        if (!object) return Bun::ERR::INVALID_ARG_TYPE(scope, globalObject, name, "AbortSignal"_s, signal);
+        if (object->inherits<WebCore::JSAbortSignal>()) {
+            return JSValue::encode(jsUndefined());
+        }
+
+        auto propin = object->hasProperty(globalObject, Identifier::fromString(vm, "aborted"_s));
+        RETURN_IF_EXCEPTION(scope, {});
+        if (!propin) return Bun::ERR::INVALID_ARG_TYPE(scope, globalObject, name, "AbortSignal"_s, signal);
+    }
+
+    return JSValue::encode(jsUndefined());
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunction_validateArray, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    JSC::VM& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    auto value = callFrame->argument(0);
+    auto name = callFrame->argument(1);
+    auto minLength = callFrame->argument(2);
+
+    if (minLength.isUndefined()) minLength = jsNumber(0);
+
+    if (!JSC::isArray(globalObject, value)) return Bun::ERR::INVALID_ARG_TYPE(scope, globalObject, name, "Array"_s, value);
+
+    auto length = value.get(globalObject, Identifier::fromString(vm, "length"_s));
+    RETURN_IF_EXCEPTION(scope, {});
+    auto length_num = length.toNumber(globalObject);
+    RETURN_IF_EXCEPTION(scope, {});
+    auto minLength_num = minLength.toNumber(globalObject);
+    RETURN_IF_EXCEPTION(scope, {});
+    if (length_num < minLength_num) {
+        return Bun::ERR::INVALID_ARG_VALUE(scope, globalObject, name, value, makeString("must be longer than "_s, minLength_num));
+    }
+    return JSValue::encode(jsUndefined());
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunction_validateInt32, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    JSC::VM& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    auto value = callFrame->argument(0);
+    auto name = callFrame->argument(1);
+    auto min = callFrame->argument(2);
+    auto max = callFrame->argument(3);
+
+    if (!value.isNumber()) return Bun::ERR::INVALID_ARG_TYPE(scope, globalObject, name, "number"_s, value);
+    if (min.isUndefined()) min = jsNumber(std::numeric_limits<int32_t>().min());
+    if (max.isUndefined()) max = jsNumber(std::numeric_limits<int32_t>().max());
+
+    auto value_num = value.asNumber();
+    auto min_num = min.toNumber(globalObject);
+    RETURN_IF_EXCEPTION(scope, {});
+    auto max_num = max.toNumber(globalObject);
+    RETURN_IF_EXCEPTION(scope, {});
+
+    if (std::fmod(value_num, 1.0) != 0) return Bun::ERR::OUT_OF_RANGE(scope, globalObject, name, "an integer"_s, value);
+    if (value_num < min_num || value_num > max_num) return Bun::ERR::OUT_OF_RANGE(scope, globalObject, name, min_num, max_num, value);
+
+    return JSValue::encode(jsUndefined());
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunction_validateUint32, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    JSC::VM& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    auto value = callFrame->argument(0);
+    auto name = callFrame->argument(1);
+    auto positive = callFrame->argument(2);
+
+    if (!value.isNumber()) return Bun::ERR::INVALID_ARG_TYPE(scope, globalObject, name, "number"_s, value);
+    if (positive.isUndefined()) positive = jsBoolean(false);
+
+    auto value_num = value.asNumber();
+    if (std::fmod(value_num, 1.0) != 0) return Bun::ERR::OUT_OF_RANGE(scope, globalObject, name, "an integer"_s, value);
+
+    auto positive_b = positive.toBoolean(globalObject);
+    RETURN_IF_EXCEPTION(scope, {});
+    auto min = positive_b ? 1 : 0;
+    auto max = std::numeric_limits<uint32_t>().max();
+    if (value_num < min || value_num > max) return Bun::ERR::OUT_OF_RANGE(scope, globalObject, name, min, max, value);
+
+    return JSValue::encode(jsUndefined());
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunction_validateSignalName, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    JSC::VM& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    auto signal = callFrame->argument(0);
+    auto name = callFrame->argument(1);
+
+    if (name.isUndefined()) name = jsString(vm, String("signal"_s));
+
+    V::validateString(scope, globalObject, signal, name);
+    RETURN_IF_EXCEPTION(scope, {});
+
+    auto signal_str = signal.getString(globalObject);
+    if (isSignalName(signal_str)) return JSValue::encode(jsUndefined());
+
+    auto signal_upper = signal_str.convertToUppercaseWithoutLocale();
+    RETURN_IF_EXCEPTION(scope, {});
+    if (isSignalName(signal_str)) return Bun::ERR::UNKNOWN_SIGNAL(scope, globalObject, signal, true);
+    return Bun::ERR::UNKNOWN_SIGNAL(scope, globalObject, signal);
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunction_validateEncoding, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    JSC::VM& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    auto encoding = callFrame->argument(1);
+
+    auto normalized = WebCore::parseEnumeration<BufferEncodingType>(*globalObject, encoding);
+    if (normalized == BufferEncodingType::hex) {
+        auto data = callFrame->argument(0);
+
+        size_t length = 0;
+        if (data.isString()) {
+            length = data.toString(globalObject)->length();
+        } else if (auto* view = JSC::jsDynamicCast<JSC::JSArrayBufferView*>(data)) {
+            length = view->length();
+        } else if (auto* buffer = JSC::jsDynamicCast<JSC::JSArrayBuffer*>(data)) {
+            if (auto* impl = buffer->impl()) {
+                length = impl->byteLength();
+            }
+        } else if (auto* object = data.getObject()) {
+            JSValue lengthValue = object->getIfPropertyExists(globalObject, vm.propertyNames->length);
+            RETURN_IF_EXCEPTION(scope, {});
+            length = lengthValue.toLength(globalObject);
+            RETURN_IF_EXCEPTION(scope, {});
+        }
+        if (length % 2 != 0) {
+            return Bun::ERR::INVALID_ARG_VALUE(scope, globalObject, "encoding"_s, encoding, makeString("is invalid for data of length "_s, length));
+        }
+    }
+
+    return JSValue::encode(jsUndefined());
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunction_validatePlainFunction, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    JSC::VM& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    auto value = callFrame->argument(0);
+
+    if (!value.isCallable()) {
+        auto name = callFrame->argument(1);
+        return Bun::ERR::INVALID_ARG_TYPE(scope, globalObject, name, "function"_s, value);
+    }
+    return JSValue::encode(jsUndefined());
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunction_validateUndefined, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    JSC::VM& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    auto value = callFrame->argument(0);
+    auto name = callFrame->argument(1);
+
+    if (!value.isUndefined()) return Bun::ERR::INVALID_ARG_TYPE(scope, globalObject, name, "undefined"_s, value);
+
+    return JSValue::encode(jsUndefined());
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunction_validateBuffer, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    JSC::VM& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    auto buffer = callFrame->argument(0);
+    auto name = callFrame->argument(1);
+
+    if (!buffer.isCell()) return JSValue::encode(jsUndefined());
+    auto ty = buffer.asCell()->type();
+
+    if (JSC::typedArrayType(ty) == NotTypedArray) {
+        return Bun::ERR::INVALID_ARG_TYPE(scope, globalObject, name, "Buffer, TypedArray, or DataView"_s, buffer);
+    }
+    return JSValue::encode(jsUndefined());
+}
+}
diff --git a/src/bun.js/bindings/NodeValidator.h b/src/bun.js/bindings/NodeValidator.h
new file mode 100644
index 0000000000..b691c7f5e0
--- /dev/null
+++ b/src/bun.js/bindings/NodeValidator.h
@@ -0,0 +1,37 @@
+#include "root.h"
+
+#include "ZigGlobalObject.h"
+#include "ErrorCode.h"
+#include "JavaScriptCore/JSCJSValue.h"
+
+namespace Bun {
+
+JSC_DEFINE_HOST_FUNCTION(jsFunction_validateInteger, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame));
+JSC_DEFINE_HOST_FUNCTION(jsFunction_validateNumber, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame));
+JSC_DEFINE_HOST_FUNCTION(jsFunction_validateString, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame));
+JSC_DEFINE_HOST_FUNCTION(jsFunction_validateFiniteNumber, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame));
+JSC_DEFINE_HOST_FUNCTION(jsFunction_checkRangesOrGetDefault, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame));
+JSC_DEFINE_HOST_FUNCTION(jsFunction_validateFunction, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame));
+JSC_DEFINE_HOST_FUNCTION(jsFunction_validateBoolean, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame));
+JSC_DEFINE_HOST_FUNCTION(jsFunction_validatePort, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame));
+JSC_DEFINE_HOST_FUNCTION(jsFunction_validateAbortSignal, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame));
+JSC_DEFINE_HOST_FUNCTION(jsFunction_validateArray, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame));
+JSC_DEFINE_HOST_FUNCTION(jsFunction_validateInt32, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame));
+JSC_DEFINE_HOST_FUNCTION(jsFunction_validateUint32, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame));
+JSC_DEFINE_HOST_FUNCTION(jsFunction_validateSignalName, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame));
+JSC_DEFINE_HOST_FUNCTION(jsFunction_validateEncoding, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame));
+JSC_DEFINE_HOST_FUNCTION(jsFunction_validatePlainFunction, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame));
+JSC_DEFINE_HOST_FUNCTION(jsFunction_validateUndefined, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame));
+JSC_DEFINE_HOST_FUNCTION(jsFunction_validateBuffer, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame));
+
+namespace V {
+
+JSC::EncodedJSValue validateInteger(JSC::ThrowScope& scope, JSC::JSGlobalObject* globalObject, JSC::JSValue value, JSC::JSValue name, JSC::JSValue min, JSC::JSValue max);
+JSC::EncodedJSValue validateNumber(JSC::ThrowScope& scope, JSC::JSGlobalObject* globalObject, JSC::JSValue value, JSC::JSValue name, JSC::JSValue min, JSC::JSValue max);
+JSC::EncodedJSValue validateFiniteNumber(JSC::ThrowScope& scope, JSC::JSGlobalObject* globalObject, JSC::JSValue number, JSC::JSValue name);
+JSC::EncodedJSValue validateString(JSC::ThrowScope& scope, JSC::JSGlobalObject* globalObject, JSValue value, JSValue name);
+JSC::EncodedJSValue validateString(JSC::ThrowScope& scope, JSC::JSGlobalObject* globalObject, JSValue value, ASCIILiteral name);
+
+}
+
+}
diff --git a/src/bun.js/bindings/ObjectBindings.cpp b/src/bun.js/bindings/ObjectBindings.cpp
new file mode 100644
index 0000000000..b5e633dcfc
--- /dev/null
+++ b/src/bun.js/bindings/ObjectBindings.cpp
@@ -0,0 +1,78 @@
+#include "root.h"
+#include <JavaScriptCore/JSObject.h>
+#include <JavaScriptCore/JSObjectInlines.h>
+#include <JavaScriptCore/PropertySlot.h>
+#include <JavaScriptCore/JSGlobalObject.h>
+
+namespace Bun {
+
+using namespace JSC;
+
+static bool getNonIndexPropertySlotPrototypePollutionMitigation(JSC::VM& vm, JSObject* object, JSGlobalObject* globalObject, PropertyName propertyName, PropertySlot& slot)
+{
+    // This method only supports non-index PropertyNames.
+    ASSERT(!parseIndex(propertyName));
+
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    JSObject* objectPrototype = nullptr;
+    while (true) {
+        Structure* structure = object->structureID().decode();
+        if (LIKELY(!TypeInfo::overridesGetOwnPropertySlot(object->inlineTypeFlags()))) {
+            if (object->getOwnNonIndexPropertySlot(vm, structure, propertyName, slot))
+                return true;
+        } else {
+            bool hasSlot = structure->classInfoForCells()->methodTable.getOwnPropertySlot(object, globalObject, propertyName, slot);
+            RETURN_IF_EXCEPTION(scope, false);
+            if (hasSlot)
+                return true;
+            if (UNLIKELY(slot.isVMInquiry() && slot.isTaintedByOpaqueObject()))
+                return false;
+            if (object->type() == ProxyObjectType && slot.internalMethodType() == PropertySlot::InternalMethodType::HasProperty)
+                return false;
+        }
+        JSValue prototype;
+        if (LIKELY(!structure->typeInfo().overridesGetPrototype() || slot.internalMethodType() == PropertySlot::InternalMethodType::VMInquiry))
+            prototype = object->getPrototypeDirect();
+        else {
+            prototype = object->getPrototype(vm, globalObject);
+            RETURN_IF_EXCEPTION(scope, false);
+        }
+        if (!prototype.isObject())
+            return false;
+        object = asObject(prototype);
+        // -- If we reach the object prototype, we stop.
+        if (objectPrototype == nullptr) {
+            objectPrototype = globalObject->objectPrototype();
+        }
+        if (object == objectPrototype) {
+            return false;
+        }
+    }
+
+    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);
+    auto propertySlot = PropertySlot(object, PropertySlot::InternalMethodType::Get);
+    auto isDefined = getNonIndexPropertySlotPrototypePollutionMitigation(vm, object, globalObject, name, propertySlot);
+
+    if (!isDefined) {
+        return JSValue::decode(JSC::JSValue::ValueDeleted);
+    }
+
+    scope.assertNoException();
+    JSValue value = propertySlot.getValue(globalObject, name);
+    RETURN_IF_EXCEPTION(scope, {});
+    return value;
+}
+
+JSC::JSValue getIfPropertyExistsPrototypePollutionMitigation(JSC::JSGlobalObject* globalObject, JSC::JSObject* object, const JSC::PropertyName& name)
+{
+    return getIfPropertyExistsPrototypePollutionMitigation(JSC::getVM(globalObject), globalObject, object, name);
+}
+
+}
diff --git a/src/bun.js/bindings/ObjectBindings.h b/src/bun.js/bindings/ObjectBindings.h
new file mode 100644
index 0000000000..8c32283cbb
--- /dev/null
+++ b/src/bun.js/bindings/ObjectBindings.h
@@ -0,0 +1,16 @@
+#pragma once
+
+namespace Bun {
+
+JSC::JSValue getIfPropertyExistsPrototypePollutionMitigation(JSC::JSGlobalObject* globalObject, JSC::JSObject* object, const JSC::PropertyName& name);
+
+/**
+ * This is `JSObject::getIfPropertyExists`, except it stops when it reaches globalObject->objectPrototype().
+ *
+ * This means that for a prototype pollution attack to work, they would need to modify the specific prototype instead of the generic one shared by most objects.
+ *
+ * This method also does not support index properties.
+ */
+JSC::JSValue getIfPropertyExistsPrototypePollutionMitigation(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSObject* object, const JSC::PropertyName& name);
+
+}
diff --git a/src/bun.js/bindings/Path.h b/src/bun.js/bindings/Path.h
index 4cdf983b18..edc73912c2 100644
--- a/src/bun.js/bindings/Path.h
+++ b/src/bun.js/bindings/Path.h
@@ -2,7 +2,7 @@
 #include "ZigGlobalObject.h"
 
 namespace Bun {
-    
+
 JSC::JSValue createNodePathBinding(Zig::GlobalObject* globalObject);
 
 } // namespace Bun
diff --git a/src/bun.js/bindings/ProcessBindingConstants.cpp b/src/bun.js/bindings/ProcessBindingConstants.cpp
index 8db61a6e72..789ba863ff 100644
--- a/src/bun.js/bindings/ProcessBindingConstants.cpp
+++ b/src/bun.js/bindings/ProcessBindingConstants.cpp
@@ -8,6 +8,8 @@
 #include <openssl/ec.h>
 #include <openssl/ssl.h>
 #include <zlib.h>
+#include <brotli/encode.h>
+#include <brotli/decode.h>
 #include <fcntl.h>
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -15,10 +17,6 @@
 #include <csignal>
 #include <limits>
 
-#ifndef OPENSSL_NO_ENGINE
-#include <openssl/engine.h>
-#endif
-
 #if !defined(_MSC_VER)
 #include <unistd.h>
 #endif
@@ -45,11 +43,11 @@ using namespace JSC;
 static JSValue processBindingConstantsGetOs(VM& vm, JSObject* bindingObject)
 {
     auto globalObject = bindingObject->globalObject();
-    auto osObj = JSC::constructEmptyObject(globalObject, globalObject->objectPrototype(), 1);
-    auto dlopenObj = JSC::constructEmptyObject(globalObject, globalObject->objectPrototype(), 1);
-    auto errnoObj = JSC::constructEmptyObject(globalObject, globalObject->objectPrototype(), 1);
-    auto signalsObj = JSC::constructEmptyObject(globalObject, globalObject->objectPrototype(), 1);
-    auto priorityObj = JSC::constructEmptyObject(globalObject, globalObject->objectPrototype(), 1);
+    auto osObj = JSC::constructEmptyObject(vm, globalObject->nullPrototypeObjectStructure());
+    auto dlopenObj = JSC::constructEmptyObject(vm, globalObject->nullPrototypeObjectStructure());
+    auto errnoObj = JSC::constructEmptyObject(vm, globalObject->nullPrototypeObjectStructure());
+    auto signalsObj = JSC::constructEmptyObject(vm, globalObject->nullPrototypeObjectStructure());
+    auto priorityObj = JSC::constructEmptyObject(vm, globalObject->nullPrototypeObjectStructure());
     osObj->putDirect(vm, Identifier::fromString(vm, "UV_UDP_REUSEADDR"_s), jsNumber(4));
     osObj->putDirect(vm, Identifier::fromString(vm, "dlopen"_s), dlopenObj);
     osObj->putDirect(vm, Identifier::fromString(vm, "errno"_s), errnoObj);
@@ -604,7 +602,7 @@ static JSValue processBindingConstantsGetOs(VM& vm, JSObject* bindingObject)
 static JSValue processBindingConstantsGetTrace(VM& vm, JSObject* bindingObject)
 {
     auto globalObject = bindingObject->globalObject();
-    auto object = JSC::constructEmptyObject(globalObject, globalObject->objectPrototype(), 26);
+    auto object = JSC::constructEmptyObject(vm, globalObject->nullPrototypeObjectStructure());
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "TRACE_EVENT_PHASE_BEGIN"_s)), jsNumber(66));
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "TRACE_EVENT_PHASE_END"_s)), jsNumber(69));
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "TRACE_EVENT_PHASE_COMPLETE"_s)), jsNumber(88));
@@ -637,7 +635,7 @@ static JSValue processBindingConstantsGetTrace(VM& vm, JSObject* bindingObject)
 static JSValue processBindingConstantsGetFs(VM& vm, JSObject* bindingObject)
 {
     auto globalObject = bindingObject->globalObject();
-    auto object = JSC::constructEmptyObject(globalObject, globalObject->objectPrototype(), 26);
+    auto object = JSC::constructEmptyObject(vm, globalObject->nullPrototypeObjectStructure());
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "UV_FS_SYMLINK_DIR"_s)), jsNumber(1));
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "UV_FS_SYMLINK_JUNCTION"_s)), jsNumber(2));
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "O_RDONLY"_s)), jsNumber(O_RDONLY));
@@ -767,13 +765,17 @@ static JSValue processBindingConstantsGetFs(VM& vm, JSObject* bindingObject)
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "COPYFILE_FICLONE"_s)), jsNumber(2));
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "UV_FS_COPYFILE_FICLONE_FORCE"_s)), jsNumber(4));
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "COPYFILE_FICLONE_FORCE"_s)), jsNumber(4));
+
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "EXTENSIONLESS_FORMAT_JAVASCRIPT"_s)), jsNumber(0));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "EXTENSIONLESS_FORMAT_WASM"_s)), jsNumber(1));
+
     return object;
 }
 
 static JSValue processBindingConstantsGetCrypto(VM& vm, JSObject* bindingObject)
 {
     auto globalObject = bindingObject->globalObject();
-    auto object = JSC::constructEmptyObject(globalObject, globalObject->objectPrototype());
+    auto object = JSC::constructEmptyObject(vm, globalObject->nullPrototypeObjectStructure());
 #ifdef OPENSSL_VERSION_NUMBER
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "OPENSSL_VERSION_NUMBER"_s)), jsNumber(OPENSSL_VERSION_NUMBER));
 #endif
@@ -782,6 +784,8 @@ static JSValue processBindingConstantsGetCrypto(VM& vm, JSObject* bindingObject)
 #endif
 #ifdef SSL_OP_ALLOW_NO_DHE_KEX
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "SSL_OP_ALLOW_NO_DHE_KEX"_s)), jsNumber(SSL_OP_ALLOW_NO_DHE_KEX));
+#else
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "SSL_OP_ALLOW_NO_DHE_KEX"_s)), jsNumber(0));
 #endif
 #ifdef SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION"_s)), jsNumber(SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION));
@@ -791,12 +795,18 @@ static JSValue processBindingConstantsGetCrypto(VM& vm, JSObject* bindingObject)
 #endif
 #ifdef SSL_OP_CISCO_ANYCONNECT
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "SSL_OP_CISCO_ANYCONNECT"_s)), jsNumber(SSL_OP_CISCO_ANYCONNECT));
+#else
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "SSL_OP_CISCO_ANYCONNECT"_s)), jsNumber(0));
 #endif
 #ifdef SSL_OP_COOKIE_EXCHANGE
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "SSL_OP_COOKIE_EXCHANGE"_s)), jsNumber(SSL_OP_COOKIE_EXCHANGE));
+#else
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "SSL_OP_COOKIE_EXCHANGE"_s)), jsNumber(0));
 #endif
 #ifdef SSL_OP_CRYPTOPRO_TLSEXT_BUG
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "SSL_OP_CRYPTOPRO_TLSEXT_BUG"_s)), jsNumber(SSL_OP_CRYPTOPRO_TLSEXT_BUG));
+#else
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "SSL_OP_CRYPTOPRO_TLSEXT_BUG"_s)), jsNumber(0));
 #endif
 #ifdef SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS"_s)), jsNumber(SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS));
@@ -809,6 +819,8 @@ static JSValue processBindingConstantsGetCrypto(VM& vm, JSObject* bindingObject)
 #endif
 #ifdef SSL_OP_NO_ENCRYPT_THEN_MAC
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "SSL_OP_NO_ENCRYPT_THEN_MAC"_s)), jsNumber(SSL_OP_NO_ENCRYPT_THEN_MAC));
+#else
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "SSL_OP_NO_ENCRYPT_THEN_MAC"_s)), jsNumber(0));
 #endif
 #ifdef SSL_OP_NO_QUERY_MTU
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "SSL_OP_NO_QUERY_MTU"_s)), jsNumber(SSL_OP_NO_QUERY_MTU));
@@ -842,45 +854,42 @@ static JSValue processBindingConstantsGetCrypto(VM& vm, JSObject* bindingObject)
 #endif
 #ifdef SSL_OP_PRIORITIZE_CHACHA
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "SSL_OP_PRIORITIZE_CHACHA"_s)), jsNumber(SSL_OP_PRIORITIZE_CHACHA));
+#else
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "SSL_OP_PRIORITIZE_CHACHA"_s)), jsNumber(0));
 #endif
 #ifdef SSL_OP_TLS_ROLLBACK_BUG
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "SSL_OP_TLS_ROLLBACK_BUG"_s)), jsNumber(SSL_OP_TLS_ROLLBACK_BUG));
 #endif
-#ifndef OPENSSL_NO_ENGINE
-#ifdef ENGINE_METHOD_RSA
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "ENGINE_METHOD_RSA"_s)), jsNumber(ENGINE_METHOD_RSA));
-#endif
-#ifdef ENGINE_METHOD_DSA
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "ENGINE_METHOD_DSA"_s)), jsNumber(ENGINE_METHOD_DSA));
-#endif
-#ifdef ENGINE_METHOD_DH
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "ENGINE_METHOD_DH"_s)), jsNumber(ENGINE_METHOD_DH));
-#endif
-#ifdef ENGINE_METHOD_RAND
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "ENGINE_METHOD_RAND"_s)), jsNumber(ENGINE_METHOD_RAND));
-#endif
-#ifdef ENGINE_METHOD_EC
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "ENGINE_METHOD_EC"_s)), jsNumber(ENGINE_METHOD_EC));
-#endif
-#ifdef ENGINE_METHOD_CIPHERS
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "ENGINE_METHOD_CIPHERS"_s)), jsNumber(ENGINE_METHOD_CIPHERS));
-#endif
-#ifdef ENGINE_METHOD_DIGESTS
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "ENGINE_METHOD_DIGESTS"_s)), jsNumber(ENGINE_METHOD_DIGESTS));
-#endif
-#ifdef ENGINE_METHOD_PKEY_METHS
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "ENGINE_METHOD_PKEY_METHS"_s)), jsNumber(ENGINE_METHOD_PKEY_METHS));
-#endif
-#ifdef ENGINE_METHOD_PKEY_ASN1_METHS
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "ENGINE_METHOD_PKEY_ASN1_METHS"_s)), jsNumber(ENGINE_METHOD_PKEY_ASN1_METHS));
-#endif
-#ifdef ENGINE_METHOD_ALL
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "ENGINE_METHOD_ALL"_s)), jsNumber(ENGINE_METHOD_ALL));
-#endif
-#ifdef ENGINE_METHOD_NONE
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "ENGINE_METHOD_NONE"_s)), jsNumber(ENGINE_METHOD_NONE));
-#endif
-#endif // !OPENSSL_NO_ENGINE
+    // OBSOLETE OPTIONS retained for compatibility
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "SSL_OP_MICROSOFT_SESS_ID_BUG"_s)), jsNumber(0));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "SSL_OP_NETSCAPE_CHALLENGE_BUG"_s)), jsNumber(0));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG"_s)), jsNumber(0));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG"_s)), jsNumber(0));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER"_s)), jsNumber(0));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "SSL_OP_MSIE_SSLV2_RSA_PADDING"_s)), jsNumber(0));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "SSL_OP_SSLEAY_080_CLIENT_DH_BUG"_s)), jsNumber(0));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "SSL_OP_TLS_D5_BUG"_s)), jsNumber(0));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "SSL_OP_TLS_BLOCK_PADDING_BUG"_s)), jsNumber(0));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "SSL_OP_SINGLE_ECDH_USE"_s)), jsNumber(0));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "SSL_OP_SINGLE_DH_USE"_s)), jsNumber(0));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "SSL_OP_EPHEMERAL_RSA"_s)), jsNumber(0));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "SSL_OP_NO_SSLv2"_s)), jsNumber(0));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "SSL_OP_PKCS1_CHECK_1"_s)), jsNumber(0));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "SSL_OP_PKCS1_CHECK_2"_s)), jsNumber(0));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "SSL_OP_NETSCAPE_CA_DN_BUG"_s)), jsNumber(0));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG"_s)), jsNumber(0));
+    // BoringSSL does not define engine constants in openssl/engine.h
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "ENGINE_METHOD_RSA"_s)), jsNumber(0x0001));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "ENGINE_METHOD_DSA"_s)), jsNumber(0x0002));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "ENGINE_METHOD_DH"_s)), jsNumber(0x0004));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "ENGINE_METHOD_RAND"_s)), jsNumber(0x0008));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "ENGINE_METHOD_CIPHERS"_s)), jsNumber(0x0040));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "ENGINE_METHOD_DIGESTS"_s)), jsNumber(0x0080));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "ENGINE_METHOD_PKEY_METHS"_s)), jsNumber(0x0200));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "ENGINE_METHOD_PKEY_ASN1_METHS"_s)), jsNumber(0x0400));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "ENGINE_METHOD_EC"_s)), jsNumber(0x0800));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "ENGINE_METHOD_ALL"_s)), jsNumber(0xFFFF));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "ENGINE_METHOD_NONE"_s)), jsNumber(0x0000));
 #ifdef DH_CHECK_P_NOT_SAFE_PRIME
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "DH_CHECK_P_NOT_SAFE_PRIME"_s)), jsNumber(DH_CHECK_P_NOT_SAFE_PRIME));
 #endif
@@ -956,18 +965,10 @@ static JSValue processBindingConstantsGetCrypto(VM& vm, JSObject* bindingObject)
         jsString(vm, cipherList));
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "defaultCipherList"_s)),
         jsString(vm, cipherList));
-#ifdef TLS1_VERSION
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "TLS1_VERSION"_s)), jsNumber(TLS1_VERSION));
-#endif
-#ifdef TLS1_1_VERSION
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "TLS1_1_VERSION"_s)), jsNumber(TLS1_1_VERSION));
-#endif
-#ifdef TLS1_2_VERSION
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "TLS1_2_VERSION"_s)), jsNumber(TLS1_2_VERSION));
-#endif
-#ifdef TLS1_3_VERSION
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "TLS1_3_VERSION"_s)), jsNumber(TLS1_3_VERSION));
-#endif
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "POINT_CONVERSION_COMPRESSED"_s)), jsNumber(POINT_CONVERSION_COMPRESSED));
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "POINT_CONVERSION_UNCOMPRESSED"_s)), jsNumber(POINT_CONVERSION_UNCOMPRESSED));
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "POINT_CONVERSION_HYBRID"_s)), jsNumber(POINT_CONVERSION_HYBRID));
@@ -977,7 +978,7 @@ static JSValue processBindingConstantsGetCrypto(VM& vm, JSObject* bindingObject)
 static JSValue processBindingConstantsGetZlib(VM& vm, JSObject* bindingObject)
 {
     auto globalObject = bindingObject->globalObject();
-    auto object = JSC::constructEmptyObject(globalObject, globalObject->objectPrototype());
+    auto object = JSC::constructEmptyObject(vm, globalObject->nullPrototypeObjectStructure());
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "Z_NO_FLUSH"_s)), jsNumber(Z_NO_FLUSH));
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "Z_PARTIAL_FLUSH"_s)), jsNumber(Z_PARTIAL_FLUSH));
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "Z_SYNC_FLUSH"_s)), jsNumber(Z_SYNC_FLUSH));
@@ -1020,76 +1021,76 @@ static JSValue processBindingConstantsGetZlib(VM& vm, JSObject* bindingObject)
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "Z_MAX_WINDOWBITS"_s)), jsNumber(15));
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "Z_DEFAULT_WINDOWBITS"_s)), jsNumber(15));
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "Z_MIN_CHUNK"_s)), jsNumber(64));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "Z_MAX_CHUNK"_s)), jsNumber(INFINITY));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "Z_DEFAULT_CHUNK"_s)), jsNumber(16384));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "Z_MAX_CHUNK"_s)), jsNumber(std::numeric_limits<double>::infinity()));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "Z_DEFAULT_CHUNK"_s)), jsNumber(16 * 1024));
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "Z_MIN_MEMLEVEL"_s)), jsNumber(1));
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "Z_MAX_MEMLEVEL"_s)), jsNumber(9));
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "Z_DEFAULT_MEMLEVEL"_s)), jsNumber(8));
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "Z_MIN_LEVEL"_s)), jsNumber(-1));
     object->putDirect(vm, PropertyName(Identifier::fromString(vm, "Z_MAX_LEVEL"_s)), jsNumber(9));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "Z_DEFAULT_LEVEL"_s)), jsNumber(-1));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "Z_DEFAULT_LEVEL"_s)), jsNumber(Z_DEFAULT_COMPRESSION));
 
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_OPERATION_PROCESS"_s)), jsNumber(0));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_OPERATION_FLUSH"_s)), jsNumber(1));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_OPERATION_FINISH"_s)), jsNumber(2));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_OPERATION_EMIT_METADATA"_s)), jsNumber(3));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_PARAM_MODE"_s)), jsNumber(0));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_MODE_GENERIC"_s)), jsNumber(0));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_MODE_TEXT"_s)), jsNumber(1));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_MODE_FONT"_s)), jsNumber(2));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DEFAULT_MODE"_s)), jsNumber(0));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_PARAM_QUALITY"_s)), jsNumber(1));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_MIN_QUALITY"_s)), jsNumber(0));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_MAX_QUALITY"_s)), jsNumber(11));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DEFAULT_QUALITY"_s)), jsNumber(11));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_PARAM_LGWIN"_s)), jsNumber(2));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_MIN_WINDOW_BITS"_s)), jsNumber(10));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_MAX_WINDOW_BITS"_s)), jsNumber(24));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_LARGE_MAX_WINDOW_BITS"_s)), jsNumber(30));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DEFAULT_WINDOW"_s)), jsNumber(22));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_PARAM_LGBLOCK"_s)), jsNumber(3));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_MIN_INPUT_BLOCK_BITS"_s)), jsNumber(16));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_MAX_INPUT_BLOCK_BITS"_s)), jsNumber(24));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING"_s)), jsNumber(4));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_PARAM_SIZE_HINT"_s)), jsNumber(5));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_PARAM_LARGE_WINDOW"_s)), jsNumber(6));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_PARAM_NPOSTFIX"_s)), jsNumber(7));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_PARAM_NDIRECT"_s)), jsNumber(8));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_RESULT_ERROR"_s)), jsNumber(0));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_RESULT_SUCCESS"_s)), jsNumber(1));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT"_s)), jsNumber(2));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT"_s)), jsNumber(3));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION"_s)), jsNumber(0));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_PARAM_LARGE_WINDOW"_s)), jsNumber(1));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_NO_ERROR"_s)), jsNumber(0));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_SUCCESS"_s)), jsNumber(1));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_NEEDS_MORE_INPUT"_s)), jsNumber(2));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_NEEDS_MORE_OUTPUT"_s)), jsNumber(3));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE"_s)), jsNumber(-1));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_FORMAT_RESERVED"_s)), jsNumber(-2));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE"_s)), jsNumber(-3));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET"_s)), jsNumber(-4));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME"_s)), jsNumber(-5));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_FORMAT_CL_SPACE"_s)), jsNumber(-6));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE"_s)), jsNumber(-7));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT"_s)), jsNumber(-8));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1"_s)), jsNumber(-9));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2"_s)), jsNumber(-10));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_FORMAT_TRANSFORM"_s)), jsNumber(-11));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_FORMAT_DICTIONARY"_s)), jsNumber(-12));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS"_s)), jsNumber(-13));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_FORMAT_PADDING_1"_s)), jsNumber(-14));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_FORMAT_PADDING_2"_s)), jsNumber(-15));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_FORMAT_DISTANCE"_s)), jsNumber(-16));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET"_s)), jsNumber(-19));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_INVALID_ARGUMENTS"_s)), jsNumber(-20));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES"_s)), jsNumber(-21));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS"_s)), jsNumber(-22));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP"_s)), jsNumber(-25));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1"_s)), jsNumber(-26));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2"_s)), jsNumber(-27));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES"_s)), jsNumber(-30));
-    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_UNREACHABLE"_s)), jsNumber(-31));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_OPERATION_PROCESS"_s)), jsNumber(BROTLI_OPERATION_PROCESS));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_OPERATION_FLUSH"_s)), jsNumber(BROTLI_OPERATION_FLUSH));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_OPERATION_FINISH"_s)), jsNumber(BROTLI_OPERATION_FINISH));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_OPERATION_EMIT_METADATA"_s)), jsNumber(BROTLI_OPERATION_EMIT_METADATA));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_PARAM_MODE"_s)), jsNumber(BROTLI_PARAM_MODE));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_MODE_GENERIC"_s)), jsNumber(BROTLI_MODE_GENERIC));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_MODE_TEXT"_s)), jsNumber(BROTLI_MODE_TEXT));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_MODE_FONT"_s)), jsNumber(BROTLI_MODE_FONT));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DEFAULT_MODE"_s)), jsNumber(BROTLI_DEFAULT_MODE));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_PARAM_QUALITY"_s)), jsNumber(BROTLI_PARAM_QUALITY));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_MIN_QUALITY"_s)), jsNumber(BROTLI_MIN_QUALITY));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_MAX_QUALITY"_s)), jsNumber(BROTLI_MAX_QUALITY));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DEFAULT_QUALITY"_s)), jsNumber(BROTLI_DEFAULT_QUALITY));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_PARAM_LGWIN"_s)), jsNumber(BROTLI_PARAM_LGWIN));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_MIN_WINDOW_BITS"_s)), jsNumber(BROTLI_MIN_WINDOW_BITS));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_MAX_WINDOW_BITS"_s)), jsNumber(BROTLI_MAX_WINDOW_BITS));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_LARGE_MAX_WINDOW_BITS"_s)), jsNumber(BROTLI_LARGE_MAX_WINDOW_BITS));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DEFAULT_WINDOW"_s)), jsNumber(BROTLI_DEFAULT_WINDOW));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_PARAM_LGBLOCK"_s)), jsNumber(BROTLI_PARAM_LGBLOCK));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_MIN_INPUT_BLOCK_BITS"_s)), jsNumber(BROTLI_MIN_INPUT_BLOCK_BITS));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_MAX_INPUT_BLOCK_BITS"_s)), jsNumber(BROTLI_MAX_INPUT_BLOCK_BITS));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING"_s)), jsNumber(BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_PARAM_SIZE_HINT"_s)), jsNumber(BROTLI_PARAM_SIZE_HINT));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_PARAM_LARGE_WINDOW"_s)), jsNumber(BROTLI_PARAM_LARGE_WINDOW));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_PARAM_NPOSTFIX"_s)), jsNumber(BROTLI_PARAM_NPOSTFIX));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_PARAM_NDIRECT"_s)), jsNumber(BROTLI_PARAM_NDIRECT));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_RESULT_ERROR"_s)), jsNumber(BROTLI_DECODER_RESULT_ERROR));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_RESULT_SUCCESS"_s)), jsNumber(BROTLI_DECODER_RESULT_SUCCESS));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT"_s)), jsNumber(BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT"_s)), jsNumber(BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION"_s)), jsNumber(BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_PARAM_LARGE_WINDOW"_s)), jsNumber(BROTLI_DECODER_PARAM_LARGE_WINDOW));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_NO_ERROR"_s)), jsNumber(BROTLI_DECODER_NO_ERROR));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_SUCCESS"_s)), jsNumber(BROTLI_DECODER_SUCCESS));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_NEEDS_MORE_INPUT"_s)), jsNumber(BROTLI_DECODER_NEEDS_MORE_INPUT));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_NEEDS_MORE_OUTPUT"_s)), jsNumber(BROTLI_DECODER_NEEDS_MORE_OUTPUT));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE"_s)), jsNumber(BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_FORMAT_RESERVED"_s)), jsNumber(BROTLI_DECODER_ERROR_FORMAT_RESERVED));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE"_s)), jsNumber(BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET"_s)), jsNumber(BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME"_s)), jsNumber(BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_FORMAT_CL_SPACE"_s)), jsNumber(BROTLI_DECODER_ERROR_FORMAT_CL_SPACE));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE"_s)), jsNumber(BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT"_s)), jsNumber(BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1"_s)), jsNumber(BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2"_s)), jsNumber(BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_FORMAT_TRANSFORM"_s)), jsNumber(BROTLI_DECODER_ERROR_FORMAT_TRANSFORM));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_FORMAT_DICTIONARY"_s)), jsNumber(BROTLI_DECODER_ERROR_FORMAT_DICTIONARY));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS"_s)), jsNumber(BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_FORMAT_PADDING_1"_s)), jsNumber(BROTLI_DECODER_ERROR_FORMAT_PADDING_1));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_FORMAT_PADDING_2"_s)), jsNumber(BROTLI_DECODER_ERROR_FORMAT_PADDING_2));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_FORMAT_DISTANCE"_s)), jsNumber(BROTLI_DECODER_ERROR_FORMAT_DISTANCE));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET"_s)), jsNumber(BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_INVALID_ARGUMENTS"_s)), jsNumber(BROTLI_DECODER_ERROR_INVALID_ARGUMENTS));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES"_s)), jsNumber(BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS"_s)), jsNumber(BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP"_s)), jsNumber(BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1"_s)), jsNumber(BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2"_s)), jsNumber(BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES"_s)), jsNumber(BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES));
+    object->putDirect(vm, PropertyName(Identifier::fromString(vm, "BROTLI_DECODER_ERROR_UNREACHABLE"_s)), jsNumber(BROTLI_DECODER_ERROR_UNREACHABLE));
 
     return object;
 }
diff --git a/src/bun.js/bindings/ProcessBindingTTYWrap.cpp b/src/bun.js/bindings/ProcessBindingTTYWrap.cpp
index 052863c900..c86eec8658 100644
--- a/src/bun.js/bindings/ProcessBindingTTYWrap.cpp
+++ b/src/bun.js/bindings/ProcessBindingTTYWrap.cpp
@@ -199,7 +199,7 @@ JSC_DEFINE_HOST_FUNCTION(jsTTYSetMode, (JSC::JSGlobalObject * globalObject, Call
 
     Zig::GlobalObject* global = jsCast<Zig::GlobalObject*>(globalObject);
 
-    return Source__setRawModeStdin(raw);
+    return JSValue::encode(jsNumber(Source__setRawModeStdin(raw)));
 #else
     auto& vm = globalObject->vm();
     auto scope = DECLARE_THROW_SCOPE(vm);
@@ -517,4 +517,4 @@ JSValue createNodeTTYWrapObject(JSC::JSGlobalObject* globalObject)
 
     return obj;
 }
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/ProcessBindingTTYWrap.h b/src/bun.js/bindings/ProcessBindingTTYWrap.h
index dfcd56966f..53f82092da 100644
--- a/src/bun.js/bindings/ProcessBindingTTYWrap.h
+++ b/src/bun.js/bindings/ProcessBindingTTYWrap.h
@@ -15,4 +15,4 @@ JSC::JSValue createNodeTTYWrapObject(JSC::JSGlobalObject* globalObject);
 
 JSC_DECLARE_HOST_FUNCTION(Process_functionInternalGetWindowSize);
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/ProcessBindingUV.cpp b/src/bun.js/bindings/ProcessBindingUV.cpp
index c6151ffefe..b3a9aa5e0c 100644
--- a/src/bun.js/bindings/ProcessBindingUV.cpp
+++ b/src/bun.js/bindings/ProcessBindingUV.cpp
@@ -171,4 +171,4 @@ JSObject* create(VM& vm, JSGlobalObject* globalObject)
 }
 
 } // namespace ProcessBindingUV
-} // namespace Bun
\ No newline at end of file
+} // namespace Bun
diff --git a/src/bun.js/bindings/ProcessBindingUV.h b/src/bun.js/bindings/ProcessBindingUV.h
index 4306e21f82..92f1a50600 100644
--- a/src/bun.js/bindings/ProcessBindingUV.h
+++ b/src/bun.js/bindings/ProcessBindingUV.h
@@ -10,4 +10,4 @@ JSC_DECLARE_HOST_FUNCTION(jsGetErrorMap);
 JSC::JSObject* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject);
 
 } // namespace ProcessBindingUV
-} // namespace Bun
\ No newline at end of file
+} // namespace Bun
diff --git a/src/bun.js/bindings/ProcessIdentifier.h b/src/bun.js/bindings/ProcessIdentifier.h
index 1950d8cf0e..f96e26c5ae 100644
--- a/src/bun.js/bindings/ProcessIdentifier.h
+++ b/src/bun.js/bindings/ProcessIdentifier.h
@@ -30,7 +30,7 @@
 namespace WebCore {
 
 enum class ProcessIdentifierType {};
-using ProcessIdentifier = LegacyNullableObjectIdentifier<ProcessIdentifierType>;
+using ProcessIdentifier = ObjectIdentifier<ProcessIdentifierType>;
 
 namespace Process {
 
diff --git a/src/bun.js/bindings/RegularExpression.cpp b/src/bun.js/bindings/RegularExpression.cpp
index 6fbf1b7733..1a4b035689 100644
--- a/src/bun.js/bindings/RegularExpression.cpp
+++ b/src/bun.js/bindings/RegularExpression.cpp
@@ -38,4 +38,4 @@ extern "C" int Yarr__RegularExpression__searchRev(RegularExpression* re, BunStri
 extern "C" int Yarr__RegularExpression__matches(RegularExpression* re, BunString string)
 {
     return re->match(string.toWTFString(BunString::ZeroCopy), 0, 0);
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/SQLClient.cpp b/src/bun.js/bindings/SQLClient.cpp
index 807fffffa3..514af1b664 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/ScriptExecutionContext.cpp b/src/bun.js/bindings/ScriptExecutionContext.cpp
index 06e5b7ddba..34534d6369 100644
--- a/src/bun.js/bindings/ScriptExecutionContext.cpp
+++ b/src/bun.js/bindings/ScriptExecutionContext.cpp
@@ -60,7 +60,8 @@ us_socket_context_t* ScriptExecutionContext::webSocketContextSSL()
         opts.request_cert = true;
         // but do not reject unauthorized
         opts.reject_unauthorized = false;
-        this->m_ssl_client_websockets_ctx = us_create_bun_socket_context(1, loop, sizeof(size_t), opts);
+        enum create_bun_socket_error_t err = CREATE_BUN_SOCKET_ERROR_NONE;
+        this->m_ssl_client_websockets_ctx = us_create_bun_socket_context(1, loop, sizeof(size_t), opts, &err);
         void** ptr = reinterpret_cast<void**>(us_socket_context_ext(1, m_ssl_client_websockets_ctx));
         *ptr = this;
         registerHTTPContextForWebSocket<true, false>(this, m_ssl_client_websockets_ctx, loop);
diff --git a/src/bun.js/bindings/ScriptExecutionContext.h b/src/bun.js/bindings/ScriptExecutionContext.h
index e2cf419111..23bca74153 100644
--- a/src/bun.js/bindings/ScriptExecutionContext.h
+++ b/src/bun.js/bindings/ScriptExecutionContext.h
@@ -206,4 +206,4 @@ public:
 
 ScriptExecutionContext* executionContext(JSC::JSGlobalObject*);
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/Serialization.cpp b/src/bun.js/bindings/Serialization.cpp
index fafb08b373..93a1393d66 100644
--- a/src/bun.js/bindings/Serialization.cpp
+++ b/src/bun.js/bindings/Serialization.cpp
@@ -56,4 +56,4 @@ extern "C" EncodedJSValue Bun__JSValue__deserialize(JSGlobalObject* globalObject
     /// ?! did i just give ownership of these bytes to JSC?
     auto scriptValue = SerializedScriptValue::createFromWireBytes(WTFMove(vector));
     return JSValue::encode(scriptValue->deserialize(*globalObject, globalObject));
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/Sink.h b/src/bun.js/bindings/Sink.h
index 6f7168c004..0b07ad0f5c 100644
--- a/src/bun.js/bindings/Sink.h
+++ b/src/bun.js/bindings/Sink.h
@@ -9,9 +9,10 @@ enum SinkID : uint8_t {
     HTMLRewriterSink = 3,
     HTTPResponseSink = 4,
     HTTPSResponseSink = 5,
+    FetchTaskletChunkedRequestSink = 6,
 
 };
 static constexpr unsigned numberOfSinkIDs
-    = 7;
+    = 8;
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/Strong.h b/src/bun.js/bindings/Strong.h
index 8da881a282..f8b2bd7b01 100644
--- a/src/bun.js/bindings/Strong.h
+++ b/src/bun.js/bindings/Strong.h
@@ -31,4 +31,4 @@ public:
     JSC::Strong<JSC::Unknown> m_cell;
 };
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/Uint8Array.cpp b/src/bun.js/bindings/Uint8Array.cpp
index 697bf61a5a..62d43612dd 100644
--- a/src/bun.js/bindings/Uint8Array.cpp
+++ b/src/bun.js/bindings/Uint8Array.cpp
@@ -41,4 +41,4 @@ extern "C" JSC::EncodedJSValue JSArrayBuffer__fromDefaultAllocator(JSC::JSGlobal
     return JSC::JSValue::encode(arrayBuffer);
 }
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/Undici.cpp b/src/bun.js/bindings/Undici.cpp
index 879b9f4fe2..c3649d7a34 100644
--- a/src/bun.js/bindings/Undici.cpp
+++ b/src/bun.js/bindings/Undici.cpp
@@ -16,6 +16,10 @@
 #include "JavaScriptCore/AggregateError.h"
 #include "JavaScriptCore/JSFunction.h"
 #include "JSDOMFile.h"
+#include "JSWebSocket.h"
+#include "JSCloseEvent.h"
+#include "JSErrorEvent.h"
+#include "JSMessageEvent.h"
 
 namespace Bun {
 
@@ -27,7 +31,7 @@ JSC::JSValue createUndiciInternalBinding(Zig::GlobalObject* globalObject)
 {
     auto& vm = globalObject->vm();
 
-    auto* obj = constructEmptyObject(globalObject);
+    auto* obj = constructEmptyObject(globalObject, globalObject->objectPrototype(), 11);
     obj->putDirectIndex(
         globalObject, 0,
         globalObject->JSResponseConstructor());
@@ -52,8 +56,20 @@ JSC::JSValue createUndiciInternalBinding(Zig::GlobalObject* globalObject)
     obj->putDirectIndex(
         globalObject, 7,
         JSURLSearchParams::getConstructor(vm, globalObject));
+    obj->putDirectIndex(
+        globalObject, 8,
+        JSWebSocket::getConstructor(vm, globalObject));
+    obj->putDirectIndex(
+        globalObject, 9,
+        JSCloseEvent::getConstructor(vm, globalObject));
+    obj->putDirectIndex(
+        globalObject, 10,
+        JSErrorEvent::getConstructor(vm, globalObject));
+    obj->putDirectIndex(
+        globalObject, 11,
+        JSMessageEvent::getConstructor(vm, globalObject));
 
     return obj;
 }
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/Undici.h b/src/bun.js/bindings/Undici.h
index 5bc89e5a29..88828edc70 100644
--- a/src/bun.js/bindings/Undici.h
+++ b/src/bun.js/bindings/Undici.h
@@ -3,4 +3,4 @@ namespace Bun {
 
 JSC::JSValue createUndiciInternalBinding(Zig::GlobalObject* globalObject);
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/UtilInspect.cpp b/src/bun.js/bindings/UtilInspect.cpp
index f96bfbbe93..9df5b95ead 100644
--- a/src/bun.js/bindings/UtilInspect.cpp
+++ b/src/bun.js/bindings/UtilInspect.cpp
@@ -68,4 +68,4 @@ extern "C" JSC::EncodedJSValue JSC__JSValue__callCustomInspectFunction(
     RELEASE_AND_RETURN(scope, JSValue::encode(inspectRet));
 }
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/UtilInspect.h b/src/bun.js/bindings/UtilInspect.h
index 388865b301..3a8d708c97 100644
--- a/src/bun.js/bindings/UtilInspect.h
+++ b/src/bun.js/bindings/UtilInspect.h
@@ -4,4 +4,4 @@ namespace Bun {
 
 JSC::Structure* createUtilInspectOptionsStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject);
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/Weak.cpp b/src/bun.js/bindings/Weak.cpp
index 90d4e98391..2d1a8e5018 100644
--- a/src/bun.js/bindings/Weak.cpp
+++ b/src/bun.js/bindings/Weak.cpp
@@ -1,7 +1,6 @@
 #include "root.h"
 #include <JavaScriptCore/StrongInlines.h>
 #include "BunClientData.h"
-#include "root.h"
 #include <JavaScriptCore/Weak.h>
 #include <JavaScriptCore/Strong.h>
 
@@ -118,4 +117,4 @@ extern "C" JSC::EncodedJSValue Bun__WeakRef__get(Bun::WeakRef* weakRef)
         return JSC::JSValue::encode(cell);
     }
     return JSC::encodedJSValue();
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/ZigGlobalObject.cpp b/src/bun.js/bindings/ZigGlobalObject.cpp
index c1383d8c3c..daf8b8c194 100644
--- a/src/bun.js/bindings/ZigGlobalObject.cpp
+++ b/src/bun.js/bindings/ZigGlobalObject.cpp
@@ -128,6 +128,7 @@
 #include "ModuleLoader.h"
 #include "napi_external.h"
 #include "napi_handle_scope.h"
+#include "napi_type_tag.h"
 #include "napi.h"
 #include "NodeHTTP.h"
 #include "NodeVM.h"
@@ -147,8 +148,13 @@
 #include "Base64Helpers.h"
 #include "wtf/text/OrdinalNumber.h"
 #include "ErrorCode.h"
-#include "v8/V8GlobalInternals.h"
+#include "v8/shim/GlobalInternals.h"
 #include "EventLoopTask.h"
+#include "NodeModuleModule.h"
+#include <JavaScriptCore/JSCBytecodeCacheVersion.h>
+#include "JSPerformanceServerTiming.h"
+#include "JSPerformanceResourceTiming.h"
+#include "JSPerformanceTiming.h"
 
 #if ENABLE(REMOTE_INSPECTOR)
 #include "JavaScriptCore/RemoteInspectorServer.h"
@@ -170,6 +176,7 @@ using namespace Bun;
 BUN_DECLARE_HOST_FUNCTION(Bun__NodeUtil__jsParseArgs);
 BUN_DECLARE_HOST_FUNCTION(BUN__HTTP2__getUnpackedSettings);
 BUN_DECLARE_HOST_FUNCTION(BUN__HTTP2_getPackedSettings);
+BUN_DECLARE_HOST_FUNCTION(BUN__HTTP2_assertSettings);
 
 using JSGlobalObject = JSC::JSGlobalObject;
 using Exception = JSC::Exception;
@@ -186,13 +193,34 @@ 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);
 
 extern "C" WebCore::Worker* WebWorker__getParentWorker(void*);
+
+#ifndef BUN_WEBKIT_VERSION
+#ifndef ASSERT_ENABLED
+#warning "BUN_WEBKIT_VERSION is not defined. WebKit's cmakeconfig.h is supposed to define that. If you're building a release build locally, ignore this warning. If you're seeing this warning in CI, please file an issue."
+#endif
+
+#define WEBKIT_BYTECODE_CACHE_HASH_KEY __TIMESTAMP__
+#else
+#define WEBKIT_BYTECODE_CACHE_HASH_KEY BUN_WEBKIT_VERSION
+#endif
+static consteval unsigned getWebKitBytecodeCacheVersion()
+{
+    return WTF::SuperFastHash::computeHash(WEBKIT_BYTECODE_CACHE_HASH_KEY);
+}
+#undef WEBKIT_BYTECODE_CACHE_HASH_KEY
+
+extern "C" unsigned getJSCBytecodeCacheVersion()
+{
+    return getWebKitBytecodeCacheVersion();
+}
+
 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;
@@ -222,6 +250,8 @@ extern "C" void JSCInitialize(const char* envp[], size_t envc, void (*onCrash)(c
         JSC::Options::evalMode() = evalMode;
         JSC::Options::usePromiseTryMethod() = true;
         JSC::Options::useRegExpEscape() = true;
+        JSC::Options::useIteratorHelpers() = true;
+        JSC::dangerouslyOverrideJSCBytecodeCacheVersion(getWebKitBytecodeCacheVersion());
 
 #ifdef BUN_DEBUG
         JSC::Options::showPrivateScriptsInStackTraces() = true;
@@ -251,36 +281,24 @@ extern "C" void* Bun__getVM();
 
 extern "C" void Bun__setDefaultGlobalObject(Zig::GlobalObject* globalObject);
 
-// Error.captureStackTrace may cause computeErrorInfo to be called twice
-// Rather than figure out the plumbing in JSC, we just skip the next call
-// TODO: thread_local for workers
-static bool skipNextComputeErrorInfo = false;
-
-static JSValue formatStackTraceToJSValue(JSC::VM& vm, Zig::GlobalObject* globalObject, JSC::JSGlobalObject* lexicalGlobalObject, JSC::JSObject* errorObject, JSC::JSArray* callSites, JSValue prepareStackTrace)
+static JSValue formatStackTraceToJSValue(JSC::VM& vm, Zig::GlobalObject* globalObject, JSC::JSGlobalObject* lexicalGlobalObject, JSC::JSObject* errorObject, JSC::JSArray* callSites)
 {
     auto scope = DECLARE_THROW_SCOPE(vm);
 
-    auto* errorConstructor = lexicalGlobalObject->m_errorStructure.constructor(globalObject);
-
-    if (!prepareStackTrace) {
-        if (lexicalGlobalObject->inherits<Zig::GlobalObject>()) {
-            if (auto prepare = globalObject->m_errorConstructorPrepareStackTraceValue.get()) {
-                prepareStackTrace = prepare;
-            }
-        } else {
-            prepareStackTrace = errorConstructor->getIfPropertyExists(lexicalGlobalObject, JSC::Identifier::fromString(vm, "prepareStackTrace"_s));
-        }
-    }
-
     // default formatting
     size_t framesCount = callSites->length();
 
     WTF::StringBuilder sb;
+
     if (JSC::JSValue errorMessage = errorObject->getIfPropertyExists(lexicalGlobalObject, vm.propertyNames->message)) {
+        RETURN_IF_EXCEPTION(scope, {});
         auto* str = errorMessage.toString(lexicalGlobalObject);
+        RETURN_IF_EXCEPTION(scope, {});
         if (str->length() > 0) {
+            auto value = str->value(lexicalGlobalObject);
+            RETURN_IF_EXCEPTION(scope, {});
             sb.append("Error: "_s);
-            sb.append(str->value(lexicalGlobalObject).data);
+            sb.append(value.data);
         } else {
             sb.append("Error"_s);
         }
@@ -288,30 +306,34 @@ static JSValue formatStackTraceToJSValue(JSC::VM& vm, Zig::GlobalObject* globalO
         sb.append("Error"_s);
     }
 
-    if (framesCount > 0) {
-        sb.append("\n"_s);
-    }
-
     for (size_t i = 0; i < framesCount; i++) {
+        sb.append("\n    at "_s);
+
         JSC::JSValue callSiteValue = callSites->getIndex(lexicalGlobalObject, i);
-        CallSite* callSite = JSC::jsDynamicCast<CallSite*>(callSiteValue);
-        sb.append("    at "_s);
-        callSite->formatAsString(vm, lexicalGlobalObject, sb);
-        if (i != framesCount - 1) {
-            sb.append("\n"_s);
+        RETURN_IF_EXCEPTION(scope, {});
+
+        if (CallSite* callSite = JSC::jsDynamicCast<CallSite*>(callSiteValue)) {
+            callSite->formatAsString(vm, lexicalGlobalObject, sb);
+            RETURN_IF_EXCEPTION(scope, {});
+        } else {
+            // This matches Node.js / V8's behavior
+            // It can become "at [object Object]" if the object is not a CallSite
+            auto* str = callSiteValue.toString(lexicalGlobalObject);
+            RETURN_IF_EXCEPTION(scope, {});
+            auto value = str->value(lexicalGlobalObject);
+            RETURN_IF_EXCEPTION(scope, {});
+            sb.append(value.data);
         }
     }
 
-    bool originalSkipNextComputeErrorInfo = skipNextComputeErrorInfo;
-    skipNextComputeErrorInfo = true;
-    if (errorObject->hasProperty(lexicalGlobalObject, vm.propertyNames->stack)) {
-        skipNextComputeErrorInfo = true;
-        errorObject->deleteProperty(lexicalGlobalObject, vm.propertyNames->stack);
-    }
+    return jsString(vm, sb.toString());
+}
 
-    skipNextComputeErrorInfo = originalSkipNextComputeErrorInfo;
-
-    JSValue stackStringValue = jsString(vm, sb.toString());
+static JSValue formatStackTraceToJSValue(JSC::VM& vm, Zig::GlobalObject* globalObject, JSC::JSGlobalObject* lexicalGlobalObject, JSC::JSObject* errorObject, JSC::JSArray* callSites, JSValue prepareStackTrace)
+{
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    auto stackStringValue = formatStackTraceToJSValue(vm, globalObject, lexicalGlobalObject, errorObject, callSites);
+    RETURN_IF_EXCEPTION(scope, {});
 
     if (prepareStackTrace && prepareStackTrace.isObject()) {
         JSC::CallData prepareStackTraceCallData = JSC::getCallData(prepareStackTrace);
@@ -330,10 +352,10 @@ static JSValue formatStackTraceToJSValue(JSC::VM& vm, Zig::GlobalObject* globalO
                 JSC::ProfilingReason::Other,
                 prepareStackTrace,
                 prepareStackTraceCallData,
-                errorConstructor,
+                lexicalGlobalObject->m_errorStructure.constructor(globalObject),
                 arguments);
 
-            RETURN_IF_EXCEPTION(scope, {});
+            RETURN_IF_EXCEPTION(scope, stackStringValue);
 
             if (result.isUndefinedOrNull()) {
                 result = jsUndefined();
@@ -346,6 +368,26 @@ static JSValue formatStackTraceToJSValue(JSC::VM& vm, Zig::GlobalObject* globalO
     return stackStringValue;
 }
 
+static JSValue formatStackTraceToJSValueWithoutPrepareStackTrace(JSC::VM& vm, Zig::GlobalObject* globalObject, JSC::JSGlobalObject* lexicalGlobalObject, JSC::JSObject* errorObject, JSC::JSArray* callSites)
+{
+    JSValue prepareStackTrace = {};
+    if (lexicalGlobalObject->inherits<Zig::GlobalObject>()) {
+        if (auto prepare = globalObject->m_errorConstructorPrepareStackTraceValue.get()) {
+            prepareStackTrace = prepare;
+        }
+    } else {
+        auto scope = DECLARE_CATCH_SCOPE(vm);
+
+        auto* errorConstructor = lexicalGlobalObject->m_errorStructure.constructor(globalObject);
+        prepareStackTrace = errorConstructor->getIfPropertyExists(lexicalGlobalObject, JSC::Identifier::fromString(vm, "prepareStackTrace"_s));
+        if (scope.exception()) {
+            scope.clearException();
+        }
+    }
+
+    return formatStackTraceToJSValue(vm, globalObject, lexicalGlobalObject, errorObject, callSites, prepareStackTrace);
+}
+
 WTF::String Bun::formatStackTrace(
     JSC::VM& vm,
     Zig::GlobalObject* globalObject,
@@ -442,12 +484,13 @@ WTF::String Bun::formatStackTrace(
 
     for (size_t i = 0; i < framesCount; i++) {
         StackFrame& frame = stackTrace.at(i);
+        WTF::String functionName;
+        bool isBuiltinFunction = false;
 
         sb.append("    at "_s);
 
-        WTF::String functionName;
-
         if (auto codeblock = frame.codeBlock()) {
+
             if (codeblock->isConstructor()) {
                 sb.append("new "_s);
             }
@@ -459,11 +502,25 @@ WTF::String Bun::formatStackTrace(
                 case JSC::CodeType::FunctionCode:
                 case JSC::CodeType::EvalCode: {
                     if (auto* callee = frame.callee()) {
-                        if (callee->isObject()) {
-                            JSValue functionNameValue = callee->getObject()->getDirect(vm, vm.propertyNames->name);
+                        if (auto* object = callee->getObject()) {
+                            JSValue functionNameValue = object->getDirect(vm, vm.propertyNames->name);
                             if (functionNameValue && functionNameValue.isString()) {
                                 functionName = functionNameValue.toWTFString(lexicalGlobalObject);
                             }
+
+                            if (functionName.isEmpty()) {
+                                auto catchScope = DECLARE_CATCH_SCOPE(vm);
+                                functionName = JSC::getCalculatedDisplayName(vm, object);
+                                if (catchScope.exception()) {
+                                    catchScope.clearException();
+                                }
+                            }
+
+                            if (auto* unlinkedCodeBlock = codeblock->unlinkedCodeBlock()) {
+                                if (unlinkedCodeBlock->isBuiltinFunction()) {
+                                    isBuiltinFunction = true;
+                                }
+                            }
                         }
                     }
                     break;
@@ -519,8 +576,10 @@ WTF::String Bun::formatStackTrace(
                 }
             }
 
-            // If it's not a Zig::GlobalObject, don't bother source-mapping it.
-            if (globalObject == lexicalGlobalObject && globalObject) {
+            bool isDefinitelyNotRunninginNodeVMGlobalObject = (globalObject == lexicalGlobalObject && globalObject);
+
+            bool isDefaultGlobalObjectInAFinalizer = (globalObject && !lexicalGlobalObject && !errorInstance);
+            if (isDefinitelyNotRunninginNodeVMGlobalObject || isDefaultGlobalObjectInAFinalizer) {
                 // https://github.com/oven-sh/bun/issues/3595
                 if (!sourceURLForFrame.isEmpty()) {
                     remappedFrame.source_url = Bun::toStringRef(sourceURLForFrame);
@@ -547,7 +606,15 @@ WTF::String Bun::formatStackTrace(
             }
 
             sb.append(" ("_s);
-            sb.append(sourceURLForFrame);
+            if (sourceURLForFrame.isEmpty()) {
+                if (isBuiltinFunction) {
+                    sb.append("native"_s);
+                } else {
+                    sb.append("unknown"_s);
+                }
+            } else {
+                sb.append(sourceURLForFrame);
+            }
             sb.append(":"_s);
             sb.append(remappedFrame.position.line().oneBasedInt());
             sb.append(":"_s);
@@ -598,16 +665,14 @@ static String computeErrorInfoWithoutPrepareStackTrace(
     return Bun::formatStackTrace(vm, globalObject, lexicalGlobalObject, name, message, line, column, sourceURL, stackTrace, errorInstance);
 }
 
-static String computeErrorInfoWithPrepareStackTrace(JSC::VM& vm, Zig::GlobalObject* globalObject, JSC::JSGlobalObject* lexicalGlobalObject, Vector<StackFrame>& stackFrames, OrdinalNumber& line, OrdinalNumber& column, String& sourceURL, JSObject* errorObject, JSObject* prepareStackTrace)
+static JSValue computeErrorInfoWithPrepareStackTrace(JSC::VM& vm, Zig::GlobalObject* globalObject, JSC::JSGlobalObject* lexicalGlobalObject, Vector<StackFrame>& stackFrames, OrdinalNumber& line, OrdinalNumber& column, String& sourceURL, JSObject* errorObject, JSObject* prepareStackTrace)
 {
     auto scope = DECLARE_THROW_SCOPE(vm);
 
     JSCStackTrace stackTrace = JSCStackTrace::fromExisting(vm, stackFrames);
 
     // Note: we cannot use tryCreateUninitializedRestricted here because we cannot allocate memory inside initializeIndex()
-    JSC::JSArray* callSites = JSC::JSArray::create(vm,
-        globalObject->arrayStructureForIndexingTypeDuringAllocation(JSC::ArrayWithContiguous),
-        stackTrace.size());
+    MarkedArgumentBuffer callSites;
 
     // Create the call sites (one per frame)
     GlobalObject::createCallSitesFromFrames(globalObject, lexicalGlobalObject, stackTrace, callSites);
@@ -632,73 +697,93 @@ static String computeErrorInfoWithPrepareStackTrace(JSC::VM& vm, Zig::GlobalObje
         Bun__remapStackFramePositions(globalObject, remappedFrames, framesCount);
 
         for (size_t i = 0; i < framesCount; i++) {
-            JSC::JSValue callSiteValue = callSites->getIndex(lexicalGlobalObject, i);
-            CallSite* callSite = JSC::jsDynamicCast<CallSite*>(callSiteValue);
+            JSC::JSValue callSiteValue = callSites.at(i);
             if (remappedFrames[i].remapped) {
+                CallSite* callSite = JSC::jsCast<CallSite*>(callSiteValue);
                 callSite->setColumnNumber(remappedFrames[i].position.column());
                 callSite->setLineNumber(remappedFrames[i].position.line());
             }
         }
     }
 
-    JSValue value = formatStackTraceToJSValue(vm, jsDynamicCast<Zig::GlobalObject*>(lexicalGlobalObject), lexicalGlobalObject, errorObject, callSites, prepareStackTrace);
+    JSArray* callSitesArray = JSC::constructArray(globalObject, globalObject->arrayStructureForIndexingTypeDuringAllocation(JSC::ArrayWithContiguous), callSites);
 
-    RETURN_IF_EXCEPTION(scope, String());
-
-    if (errorObject && !value.isEmpty()) {
-        errorObject->putDirect(vm, vm.propertyNames->stack, value, 0);
-    }
-
-    if (value.isString()) {
-        return value.toWTFString(lexicalGlobalObject);
-    }
-
-    return String();
+    return formatStackTraceToJSValue(vm, globalObject, lexicalGlobalObject, errorObject, callSitesArray, prepareStackTrace);
 }
 
-static String computeErrorInfo(JSC::VM& vm, Vector<StackFrame>& stackTrace, OrdinalNumber& line, OrdinalNumber& column, String& sourceURL, JSObject* errorInstance)
+static String computeErrorInfoToString(JSC::VM& vm, Vector<StackFrame>& stackTrace, OrdinalNumber& line, OrdinalNumber& column, String& sourceURL)
 {
-    if (skipNextComputeErrorInfo) {
-        return String();
-    }
 
     Zig::GlobalObject* globalObject = nullptr;
     JSC::JSGlobalObject* lexicalGlobalObject = nullptr;
 
-    if (errorInstance) {
-        lexicalGlobalObject = errorInstance->globalObject();
-        globalObject = jsDynamicCast<Zig::GlobalObject*>(lexicalGlobalObject);
+    return computeErrorInfoWithoutPrepareStackTrace(vm, globalObject, lexicalGlobalObject, stackTrace, line, column, sourceURL, nullptr);
+}
 
-        // Error.prepareStackTrace - https://v8.dev/docs/stack-trace-api#customizing-stack-traces
-        if (!globalObject) {
-            // node:vm will use a different JSGlobalObject
-            globalObject = defaultGlobalObject();
+static JSValue computeErrorInfoToJSValueWithoutSkipping(JSC::VM& vm, Vector<StackFrame>& stackTrace, OrdinalNumber& line, OrdinalNumber& column, String& sourceURL, JSObject* errorInstance)
+{
+    Zig::GlobalObject* globalObject = nullptr;
+    JSC::JSGlobalObject* lexicalGlobalObject = nullptr;
 
+    lexicalGlobalObject = errorInstance->globalObject();
+    globalObject = jsDynamicCast<Zig::GlobalObject*>(lexicalGlobalObject);
+
+    // Error.prepareStackTrace - https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+    if (!globalObject) {
+        // node:vm will use a different JSGlobalObject
+        globalObject = defaultGlobalObject();
+        if (!globalObject->isInsideErrorPrepareStackTraceCallback) {
             auto* errorConstructor = lexicalGlobalObject->m_errorStructure.constructor(lexicalGlobalObject);
             if (JSValue prepareStackTrace = errorConstructor->getIfPropertyExists(lexicalGlobalObject, Identifier::fromString(vm, "prepareStackTrace"_s))) {
                 if (prepareStackTrace.isCell() && prepareStackTrace.isObject() && prepareStackTrace.isCallable()) {
-                    return computeErrorInfoWithPrepareStackTrace(vm, globalObject, lexicalGlobalObject, stackTrace, line, column, sourceURL, errorInstance, prepareStackTrace.getObject());
+                    globalObject->isInsideErrorPrepareStackTraceCallback = true;
+                    auto result = computeErrorInfoWithPrepareStackTrace(vm, globalObject, lexicalGlobalObject, stackTrace, line, column, sourceURL, errorInstance, prepareStackTrace.getObject());
+                    globalObject->isInsideErrorPrepareStackTraceCallback = false;
+                    return result;
                 }
             }
-        } else {
-            if (JSValue prepareStackTrace = globalObject->m_errorConstructorPrepareStackTraceValue.get()) {
-                if (prepareStackTrace.isCell() && prepareStackTrace.isObject() && prepareStackTrace.isCallable()) {
-                    return computeErrorInfoWithPrepareStackTrace(vm, globalObject, lexicalGlobalObject, stackTrace, line, column, sourceURL, errorInstance, prepareStackTrace.getObject());
+        }
+    } else if (!globalObject->isInsideErrorPrepareStackTraceCallback) {
+        if (JSValue prepareStackTrace = globalObject->m_errorConstructorPrepareStackTraceValue.get()) {
+            if (prepareStackTrace) {
+                if (prepareStackTrace.isCallable()) {
+                    globalObject->isInsideErrorPrepareStackTraceCallback = true;
+                    auto result = computeErrorInfoWithPrepareStackTrace(vm, globalObject, lexicalGlobalObject, stackTrace, line, column, sourceURL, errorInstance, prepareStackTrace.getObject());
+                    globalObject->isInsideErrorPrepareStackTraceCallback = false;
+                    return result;
                 }
             }
         }
     }
 
-    return computeErrorInfoWithoutPrepareStackTrace(vm, globalObject, lexicalGlobalObject, stackTrace, line, column, sourceURL, errorInstance);
+    String result = computeErrorInfoWithoutPrepareStackTrace(vm, globalObject, lexicalGlobalObject, stackTrace, line, column, sourceURL, errorInstance);
+    return jsString(vm, result);
 }
 
-// TODO: @paperdave: remove this wrapper and make the WTF::Function from JavaScriptCore expect OrdinalNumber instead of unsigned.
-static String computeErrorInfoWrapper(JSC::VM& vm, Vector<StackFrame>& stackTrace, unsigned int& line_in, unsigned int& column_in, String& sourceURL, JSObject* errorInstance)
+static JSValue computeErrorInfoToJSValue(JSC::VM& vm, Vector<StackFrame>& stackTrace, OrdinalNumber& line, OrdinalNumber& column, String& sourceURL, JSObject* errorInstance)
+{
+    return computeErrorInfoToJSValueWithoutSkipping(vm, stackTrace, line, column, sourceURL, errorInstance);
+}
+
+static String computeErrorInfoWrapperToString(JSC::VM& vm, Vector<StackFrame>& stackTrace, unsigned int& line_in, unsigned int& column_in, String& sourceURL)
 {
     OrdinalNumber line = OrdinalNumber::fromOneBasedInt(line_in);
     OrdinalNumber column = OrdinalNumber::fromOneBasedInt(column_in);
 
-    WTF::String result = computeErrorInfo(vm, stackTrace, line, column, sourceURL, errorInstance);
+    WTF::String result = computeErrorInfoToString(vm, stackTrace, line, column, sourceURL);
+
+    line_in = line.oneBasedInt();
+    column_in = column.oneBasedInt();
+
+    return result;
+}
+
+static JSValue computeErrorInfoWrapperToJSValue(JSC::VM& vm, Vector<StackFrame>& stackTrace, unsigned int& line_in, unsigned int& column_in, String& sourceURL, JSObject* errorInstance)
+{
+    OrdinalNumber line = OrdinalNumber::fromOneBasedInt(line_in);
+    OrdinalNumber column = OrdinalNumber::fromOneBasedInt(column_in);
+
+    JSValue result = computeErrorInfoToJSValue(vm, stackTrace, line, column, sourceURL, errorInstance);
 
     line_in = line.oneBasedInt();
     column_in = column.oneBasedInt();
@@ -729,6 +814,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();
@@ -795,7 +915,8 @@ extern "C" JSC__JSGlobalObject* Zig__GlobalObject__create(void* console_client,
     Bun__setDefaultGlobalObject(globalObject);
     JSC::gcProtect(globalObject);
 
-    vm.setOnComputeErrorInfo(computeErrorInfoWrapper);
+    vm.setOnComputeErrorInfo(computeErrorInfoWrapperToString);
+    vm.setOnComputeErrorInfoJSValue(computeErrorInfoWrapperToJSValue);
     vm.setOnEachMicrotaskTick([](JSC::VM& vm) -> void {
         auto* globalObject = defaultGlobalObject();
         if (auto nextTickQueue = globalObject->m_nextTickQueue.get()) {
@@ -1002,8 +1123,7 @@ const JSC::GlobalObjectMethodTable GlobalObject::s_globalObjectMethodTable = {
     &supportsRichSourceInfo,
     &shouldInterruptScript,
     &javaScriptRuntimeFlags,
-    // &queueMicrotaskToEventLoop, // queueTaskToEventLoop
-    nullptr,
+    nullptr, // &queueMicrotaskToEventLoop, // queueTaskToEventLoop
     nullptr, // &shouldInterruptScriptBeforeTimeout,
     &moduleLoaderImportModule, // moduleLoaderImportModule
     &moduleLoaderResolve, // moduleLoaderResolve
@@ -1259,7 +1379,10 @@ WEBCORE_GENERATED_CONSTRUCTOR_GETTER(PerformanceEntry);
 WEBCORE_GENERATED_CONSTRUCTOR_GETTER(PerformanceMark);
 WEBCORE_GENERATED_CONSTRUCTOR_GETTER(PerformanceMeasure);
 WEBCORE_GENERATED_CONSTRUCTOR_GETTER(PerformanceObserver);
-WEBCORE_GENERATED_CONSTRUCTOR_GETTER(PerformanceObserverEntryList);
+WEBCORE_GENERATED_CONSTRUCTOR_GETTER(PerformanceObserverEntryList)
+WEBCORE_GENERATED_CONSTRUCTOR_GETTER(PerformanceResourceTiming)
+WEBCORE_GENERATED_CONSTRUCTOR_GETTER(PerformanceServerTiming)
+WEBCORE_GENERATED_CONSTRUCTOR_GETTER(PerformanceTiming)
 WEBCORE_GENERATED_CONSTRUCTOR_GETTER(ReadableByteStreamController)
 WEBCORE_GENERATED_CONSTRUCTOR_GETTER(ReadableStream)
 WEBCORE_GENERATED_CONSTRUCTOR_GETTER(ReadableStreamBYOBReader)
@@ -2503,7 +2626,7 @@ JSC_DEFINE_HOST_FUNCTION(jsFunctionPerformMicrotaskVariadic, (JSGlobalObject * g
     return JSValue::encode(jsUndefined());
 }
 
-void GlobalObject::createCallSitesFromFrames(Zig::GlobalObject* globalObject, JSC::JSGlobalObject* lexicalGlobalObject, JSCStackTrace& stackTrace, JSC::JSArray* callSites)
+void GlobalObject::createCallSitesFromFrames(Zig::GlobalObject* globalObject, JSC::JSGlobalObject* lexicalGlobalObject, JSCStackTrace& stackTrace, MarkedArgumentBuffer& callSites)
 {
     /* From v8's "Stack Trace API" (https://github.com/v8/v8/wiki/Stack-Trace-API):
      * "To maintain restrictions imposed on strict mode functions, frames that have a
@@ -2518,20 +2641,12 @@ void GlobalObject::createCallSitesFromFrames(Zig::GlobalObject* globalObject, JS
 
     for (size_t i = 0; i < framesCount; i++) {
         CallSite* callSite = CallSite::create(lexicalGlobalObject, callSiteStructure, stackTrace.at(i), encounteredStrictFrame);
-        callSites->putDirectIndex(lexicalGlobalObject, i, callSite);
 
         if (!encounteredStrictFrame) {
             encounteredStrictFrame = callSite->isStrict();
         }
-    }
-}
 
-void GlobalObject::formatStackTrace(JSC::VM& vm, JSC::JSGlobalObject* lexicalGlobalObject, JSC::JSObject* errorObject, JSC::JSArray* callSites, JSValue prepareStackTrace)
-{
-    JSValue stackTraceValue = formatStackTraceToJSValue(vm, this, lexicalGlobalObject, errorObject, callSites, prepareStackTrace);
-
-    if (!stackTraceValue.isEmpty()) {
-        errorObject->putDirect(vm, vm.propertyNames->stack, stackTraceValue, 0);
+        callSites.append(callSite);
     }
 }
 
@@ -2581,6 +2696,44 @@ JSC_DEFINE_HOST_FUNCTION(jsFunctionDefaultErrorPrepareStackTrace, (JSGlobalObjec
     return JSC::JSValue::encode(result);
 }
 
+JSC_DEFINE_CUSTOM_GETTER(errorInstanceLazyStackCustomGetter, (JSGlobalObject * globalObject, JSC::EncodedJSValue thisValue, PropertyName))
+{
+    auto& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    auto* errorObject = jsDynamicCast<ErrorInstance*>(JSValue::decode(thisValue));
+
+    // This shouldn't be possible.
+    if (!errorObject) {
+        return JSValue::encode(jsUndefined());
+    }
+
+    OrdinalNumber line;
+    OrdinalNumber column;
+    String sourceURL;
+    auto stackTrace = errorObject->stackTrace();
+    if (stackTrace == nullptr) {
+        return JSValue::encode(jsUndefined());
+    }
+
+    JSValue result = computeErrorInfoToJSValue(vm, *stackTrace, line, column, sourceURL, errorObject);
+    stackTrace->clear();
+    errorObject->setStackFrames(vm, {});
+    RETURN_IF_EXCEPTION(scope, {});
+    errorObject->putDirect(vm, vm.propertyNames->stack, result, 0);
+    return JSValue::encode(result);
+}
+
+JSC_DEFINE_CUSTOM_SETTER(errorInstanceLazyStackCustomSetter, (JSGlobalObject * globalObject, JSC::EncodedJSValue thisValue, JSC::EncodedJSValue value, PropertyName))
+{
+    auto& vm = globalObject->vm();
+    JSValue decodedValue = JSValue::decode(thisValue);
+    if (auto* object = decodedValue.getObject()) {
+        object->putDirect(vm, vm.propertyNames->stack, JSValue::decode(value), 0);
+    }
+
+    return true;
+}
+
 JSC_DEFINE_HOST_FUNCTION(errorConstructorFuncCaptureStackTrace, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame* callFrame))
 {
     GlobalObject* globalObject = reinterpret_cast<GlobalObject*>(lexicalGlobalObject);
@@ -2600,60 +2753,60 @@ JSC_DEFINE_HOST_FUNCTION(errorConstructorFuncCaptureStackTrace, (JSC::JSGlobalOb
         stackTraceLimit = DEFAULT_ERROR_STACK_TRACE_LIMIT;
     }
 
-    JSCStackTrace stackTrace = JSCStackTrace::captureCurrentJSStackTrace(globalObject, callFrame, stackTraceLimit, caller);
+    WTF::Vector<JSC::StackFrame> stackTrace;
+    JSCStackTrace::getFramesForCaller(vm, callFrame, errorObject, caller, stackTrace, stackTraceLimit);
 
-    // Note: we cannot use tryCreateUninitializedRestricted here because we cannot allocate memory inside initializeIndex()
-    JSC::JSArray* callSites = JSC::JSArray::create(vm,
-        globalObject->arrayStructureForIndexingTypeDuringAllocation(JSC::ArrayWithContiguous),
-        stackTrace.size());
-
-    // Create the call sites (one per frame)
-    GlobalObject::createCallSitesFromFrames(globalObject, lexicalGlobalObject, stackTrace, callSites);
-
-    /* Format the stack trace.
-     * Note that v8 won't actually format the stack trace here, but will create a "stack" accessor
-     * on the error object, which will format the stack trace on the first access. For now, since
-     * we're not being used internally by JSC, we can assume callers of Error.captureStackTrace in
-     * node are interested in the (formatted) stack. */
-
-    size_t framesCount = stackTrace.size();
-    ZigStackFrame remappedFrames[64];
-    framesCount = framesCount > 64 ? 64 : framesCount;
-
-    for (int i = 0; i < framesCount; i++) {
-        memset(remappedFrames + i, 0, sizeof(ZigStackFrame));
-        remappedFrames[i].source_url = Bun::toStringRef(lexicalGlobalObject, stackTrace.at(i).sourceURL());
-        if (JSCStackFrame::SourcePositions* sourcePositions = stackTrace.at(i).getSourcePositions()) {
-            remappedFrames[i].position.line_zero_based = sourcePositions->line.zeroBasedInt();
-            remappedFrames[i].position.column_zero_based = sourcePositions->column.zeroBasedInt();
-        } else {
-            remappedFrames[i].position.line_zero_based = -1;
-            remappedFrames[i].position.column_zero_based = -1;
+    if (auto* instance = jsDynamicCast<JSC::ErrorInstance*>(errorObject)) {
+        instance->setStackFrames(vm, WTFMove(stackTrace));
+        if (instance->hasMaterializedErrorInfo()) {
+            const auto& propertyName = vm.propertyNames->stack;
+            VM::DeletePropertyModeScope scope(vm, VM::DeletePropertyMode::IgnoreConfigurable);
+            DeletePropertySlot slot;
+            JSObject::deleteProperty(instance, globalObject, propertyName, slot);
+            if (auto* zigGlobalObject = jsDynamicCast<Zig::GlobalObject*>(globalObject)) {
+                instance->putDirectCustomAccessor(vm, vm.propertyNames->stack, zigGlobalObject->m_lazyStackCustomGetterSetter.get(zigGlobalObject), JSC::PropertyAttribute::CustomAccessor | 0);
+            } else {
+                instance->putDirectCustomAccessor(vm, vm.propertyNames->stack, CustomGetterSetter::create(vm, errorInstanceLazyStackCustomGetter, errorInstanceLazyStackCustomSetter), JSC::PropertyAttribute::CustomAccessor | 0);
+            }
         }
+    } else {
+        OrdinalNumber line;
+        OrdinalNumber column;
+        String sourceURL;
+        JSValue result = computeErrorInfoToJSValue(vm, stackTrace, line, column, sourceURL, errorObject);
+        errorObject->putDirect(vm, vm.propertyNames->stack, result, 0);
     }
 
-    // remap line and column start to original source
-    // XXX: this function does not fully populate the fields of ZigStackFrame,
-    // be careful reading the fields below.
-    Bun__remapStackFramePositions(lexicalGlobalObject, remappedFrames, framesCount);
-
-    // write the remapped lines back to the CallSites
-    for (size_t i = 0; i < framesCount; i++) {
-        JSC::JSValue callSiteValue = callSites->getIndex(lexicalGlobalObject, i);
-        CallSite* callSite = JSC::jsDynamicCast<CallSite*>(callSiteValue);
-        if (remappedFrames[i].remapped) {
-            callSite->setColumnNumber(remappedFrames[i].position.column());
-            callSite->setLineNumber(remappedFrames[i].position.line());
-        }
-    }
-
-    globalObject->formatStackTrace(vm, lexicalGlobalObject, errorObject, callSites, JSC::JSValue());
-    RETURN_IF_EXCEPTION(scope, {});
-
     return JSC::JSValue::encode(JSC::jsUndefined());
 }
 
 extern "C" JSC::EncodedJSValue CryptoObject__create(JSGlobalObject*);
+JSC_DEFINE_CUSTOM_GETTER(moduleNamespacePrototypeGetESModuleMarker, (JSGlobalObject * globalObject, JSC::EncodedJSValue encodedThisValue, PropertyName))
+{
+    JSValue thisValue = JSValue::decode(encodedThisValue);
+    JSModuleNamespaceObject* moduleNamespaceObject = jsDynamicCast<JSModuleNamespaceObject*>(thisValue);
+    if (!moduleNamespaceObject || moduleNamespaceObject->m_hasESModuleMarker != WTF::TriState::True) {
+        return JSC::JSValue::encode(jsUndefined());
+    }
+
+    return JSC::JSValue::encode(jsBoolean(true));
+}
+
+JSC_DEFINE_CUSTOM_SETTER(moduleNamespacePrototypeSetESModuleMarker, (JSGlobalObject * globalObject, JSC::EncodedJSValue encodedThisValue, JSC::EncodedJSValue encodedValue, PropertyName))
+{
+    auto& vm = globalObject->vm();
+    JSValue thisValue = JSValue::decode(encodedThisValue);
+    JSModuleNamespaceObject* moduleNamespaceObject = jsDynamicCast<JSModuleNamespaceObject*>(thisValue);
+    if (!moduleNamespaceObject) {
+        return false;
+    }
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    JSValue value = JSValue::decode(encodedValue);
+    WTF::TriState triState = value.toBoolean(globalObject) ? WTF::TriState::True : WTF::TriState::False;
+    RETURN_IF_EXCEPTION(scope, false);
+    moduleNamespaceObject->m_hasESModuleMarker = triState;
+    return true;
+}
 
 void GlobalObject::finishCreation(VM& vm)
 {
@@ -2661,6 +2814,14 @@ void GlobalObject::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 
     m_commonStrings.initialize();
+    m_http2_commongStrings.initialize();
+
+    Bun::addNodeModuleConstructorProperties(vm, this);
+
+    m_lazyStackCustomGetterSetter.initLater(
+        [](const Initializer<CustomGetterSetter>& init) {
+            init.set(CustomGetterSetter::create(init.vm, errorInstanceLazyStackCustomGetter, errorInstanceLazyStackCustomSetter));
+        });
 
     m_JSDOMFileConstructor.initLater(
         [](const Initializer<JSObject>& init) {
@@ -2726,11 +2887,11 @@ void GlobalObject::finishCreation(VM& vm)
         });
 
     m_V8GlobalInternals.initLater(
-        [](const JSC::LazyProperty<JSC::JSGlobalObject, v8::GlobalInternals>::Initializer& init) {
+        [](const JSC::LazyProperty<JSC::JSGlobalObject, v8::shim::GlobalInternals>::Initializer& init) {
             init.set(
-                v8::GlobalInternals::create(
+                v8::shim::GlobalInternals::create(
                     init.vm,
-                    v8::GlobalInternals::createStructure(init.vm, init.owner),
+                    v8::shim::GlobalInternals::createStructure(init.vm, init.owner),
                     jsDynamicCast<Zig::GlobalObject*>(init.owner)));
         });
 
@@ -2754,7 +2915,9 @@ void GlobalObject::finishCreation(VM& vm)
     // Change prototype from null to object for synthetic modules.
     m_moduleNamespaceObjectStructure.initLater(
         [](const Initializer<Structure>& init) {
-            init.set(JSModuleNamespaceObject::createStructure(init.vm, init.owner, init.owner->objectPrototype()));
+            JSObject* moduleNamespacePrototype = JSC::constructEmptyObject(init.owner);
+            moduleNamespacePrototype->putDirectCustomAccessor(init.vm, init.vm.propertyNames->__esModule, CustomGetterSetter::create(init.vm, moduleNamespacePrototypeGetESModuleMarker, moduleNamespacePrototypeSetESModuleMarker), PropertyAttribute::DontEnum | PropertyAttribute::DontDelete | PropertyAttribute::CustomAccessor | 0);
+            init.set(JSModuleNamespaceObject::createStructure(init.vm, init.owner, moduleNamespacePrototype));
         });
 
     m_vmModuleContextMap.initLater(
@@ -2905,6 +3068,14 @@ void GlobalObject::finishCreation(VM& vm)
         init.set(Bun::NapiHandleScopeImpl::createStructure(init.vm, init.owner));
     });
 
+    m_NapiTypeTagStructure.initLater([](const JSC::LazyProperty<JSC::JSGlobalObject, Structure>::Initializer& init) {
+        init.set(Bun::NapiTypeTag::createStructure(init.vm, init.owner));
+    });
+
+    m_napiTypeTags.initLater([](const JSC::LazyProperty<JSC::JSGlobalObject, JSC::JSWeakMap>::Initializer& init) {
+        init.set(JSC::JSWeakMap::create(init.vm, init.owner->weakMapStructure()));
+    });
+
     m_cachedNodeVMGlobalObjectStructure.initLater(
         [](const JSC::LazyProperty<JSC::JSGlobalObject, Structure>::Initializer& init) {
             init.set(WebCore::createNodeVMGlobalObjectStructure(init.vm));
@@ -2956,6 +3127,12 @@ void GlobalObject::finishCreation(VM& vm)
             init.set(prototype);
         });
 
+    m_JSFetchTaskletChunkedRequestControllerPrototype.initLater(
+        [](const JSC::LazyProperty<JSC::JSGlobalObject, JSC::JSObject>::Initializer& init) {
+            auto* prototype = createJSSinkControllerPrototype(init.vm, init.owner, WebCore::SinkID::FetchTaskletChunkedRequestSink);
+            init.set(prototype);
+        });
+
     m_performanceObject.initLater(
         [](const JSC::LazyProperty<JSC::JSGlobalObject, JSC::JSObject>::Initializer& init) {
             auto* globalObject = reinterpret_cast<Zig::GlobalObject*>(init.owner);
@@ -3084,6 +3261,16 @@ void GlobalObject::finishCreation(VM& vm)
             init.setConstructor(constructor);
         });
 
+    m_JSFetchTaskletChunkedRequestSinkClassStructure.initLater(
+        [](LazyClassStructure::Initializer& init) {
+            auto* prototype = createJSSinkPrototype(init.vm, init.global, WebCore::SinkID::FetchTaskletChunkedRequestSink);
+            auto* structure = JSFetchTaskletChunkedRequestSink::createStructure(init.vm, init.global, prototype);
+            auto* constructor = JSFetchTaskletChunkedRequestSinkConstructor::create(init.vm, init.global, JSFetchTaskletChunkedRequestSinkConstructor::createStructure(init.vm, init.global, init.global->functionPrototype()), jsCast<JSObject*>(prototype));
+            init.setPrototype(prototype);
+            init.setStructure(structure);
+            init.setConstructor(constructor);
+        });
+
     m_JSBufferClassStructure.initLater(
         [](LazyClassStructure::Initializer& init) {
             auto prototype = WebCore::createBufferPrototype(init.vm, init.global);
@@ -3248,30 +3435,6 @@ JSC_DEFINE_HOST_FUNCTION(functionSetImmediate,
     return Bun__Timer__setImmediate(globalObject, JSC::JSValue::encode(job), JSValue::encode(arguments));
 }
 
-JSValue getEventSourceConstructor(VM& vm, JSObject* thisObject)
-{
-    auto globalObject = jsCast<Zig::GlobalObject*>(thisObject);
-    auto scope = DECLARE_THROW_SCOPE(vm);
-
-    JSC::JSFunction* getSourceEvent = JSC::JSFunction::create(vm, globalObject, eventSourceGetEventSourceCodeGenerator(vm), globalObject);
-    RETURN_IF_EXCEPTION(scope, {});
-
-    JSC::MarkedArgumentBuffer args;
-
-    JSC::CallData callData = JSC::getCallData(getSourceEvent);
-
-    NakedPtr<JSC::Exception> returnedException = nullptr;
-    auto result = JSC::call(globalObject, getSourceEvent, callData, globalObject->globalThis(), args, returnedException);
-    RETURN_IF_EXCEPTION(scope, {});
-
-    if (returnedException) {
-        throwException(globalObject, scope, returnedException.get());
-        return jsUndefined();
-    }
-
-    RELEASE_AND_RETURN(scope, result);
-}
-
 // `console.Console` or `import { Console } from 'console';`
 JSC_DEFINE_CUSTOM_GETTER(getConsoleConstructor, (JSGlobalObject * globalObject, EncodedJSValue thisValue, PropertyName property))
 {
@@ -3336,6 +3499,42 @@ JSC_DEFINE_CUSTOM_SETTER(EventSource_setter,
     return true;
 }
 
+JSC_DEFINE_HOST_FUNCTION(jsFunctionToClass, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    // Mimick the behavior of class Foo {} for a regular JSFunction.
+    auto& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    auto target = callFrame->argument(0).toObject(globalObject);
+    auto name = callFrame->argument(1);
+    JSObject* base = callFrame->argument(2).getObject();
+    JSObject* prototypeBase = nullptr;
+    RETURN_IF_EXCEPTION(scope, encodedJSValue());
+
+    if (!base) {
+        base = globalObject->functionPrototype();
+    } else if (auto proto = base->getIfPropertyExists(globalObject, vm.propertyNames->prototype)) {
+        if (auto protoObject = proto.getObject()) {
+            prototypeBase = protoObject;
+        }
+    } else {
+        RETURN_IF_EXCEPTION(scope, encodedJSValue());
+        JSC::throwTypeError(globalObject, scope, "Base class must have a prototype property"_s);
+        return encodedJSValue();
+    }
+
+    JSObject* prototype = prototypeBase ? JSC::constructEmptyObject(globalObject, prototypeBase) : JSC::constructEmptyObject(globalObject);
+    RETURN_IF_EXCEPTION(scope, encodedJSValue());
+
+    prototype->structure()->setMayBePrototype(true);
+    prototype->putDirect(vm, vm.propertyNames->constructor, target, PropertyAttribute::DontEnum | 0);
+
+    target->setPrototypeDirect(vm, base);
+    target->putDirect(vm, vm.propertyNames->prototype, prototype, PropertyAttribute::DontEnum | 0);
+    target->putDirect(vm, vm.propertyNames->name, name, PropertyAttribute::DontEnum | 0);
+
+    return JSValue::encode(jsUndefined());
+}
+
 EncodedJSValue GlobalObject::assignToStream(JSValue stream, JSValue controller)
 {
     JSC::VM& vm = this->vm();
@@ -3437,6 +3636,7 @@ void GlobalObject::addBuiltinGlobals(JSC::VM& vm)
         GlobalPropertyInfo(builtinNames.requireMapPrivateName(), this->requireMap(), PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly | 0),
         GlobalPropertyInfo(builtinNames.TextEncoderStreamEncoderPrivateName(), JSTextEncoderStreamEncoderConstructor(), PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly | 0),
         GlobalPropertyInfo(builtinNames.makeErrorWithCodePrivateName(), JSFunction::create(vm, this, 2, String(), jsFunctionMakeErrorWithCode, ImplementationVisibility::Public), PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly),
+        GlobalPropertyInfo(builtinNames.toClassPrivateName(), JSFunction::create(vm, this, 1, String(), jsFunctionToClass, ImplementationVisibility::Public), PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly),
     };
     addStaticGlobals(staticGlobals, std::size(staticGlobals));
 
@@ -3473,20 +3673,20 @@ void GlobalObject::addBuiltinGlobals(JSC::VM& vm)
         NoIntrinsic,
         PropertyAttribute::ReadOnly | PropertyAttribute::DontDelete | 0);
 
-    putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().BufferPrivateName(), JSC::CustomGetterSetter::create(vm, JSBuffer_getter, nullptr), PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly | PropertyAttribute::CustomAccessorOrValue);
-    putDirectCustomAccessor(vm, builtinNames.lazyStreamPrototypeMapPrivateName(), JSC::CustomGetterSetter::create(vm, functionLazyLoadStreamPrototypeMap_getter, nullptr), PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly | PropertyAttribute::CustomAccessorOrValue);
-    putDirectCustomAccessor(vm, builtinNames.TransformStreamPrivateName(), CustomGetterSetter::create(vm, TransformStream_getter, nullptr), attributesForStructure(static_cast<unsigned>(PropertyAttribute::DontEnum)) | PropertyAttribute::CustomAccessorOrValue);
-    putDirectCustomAccessor(vm, builtinNames.TransformStreamDefaultControllerPrivateName(), CustomGetterSetter::create(vm, TransformStreamDefaultController_getter, nullptr), attributesForStructure(static_cast<unsigned>(PropertyAttribute::DontEnum)) | PropertyAttribute::CustomAccessorOrValue);
-    putDirectCustomAccessor(vm, builtinNames.ReadableByteStreamControllerPrivateName(), CustomGetterSetter::create(vm, ReadableByteStreamController_getter, nullptr), attributesForStructure(PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly) | PropertyAttribute::CustomAccessorOrValue);
-    putDirectCustomAccessor(vm, builtinNames.ReadableStreamPrivateName(), CustomGetterSetter::create(vm, ReadableStream_getter, nullptr), attributesForStructure(PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly) | PropertyAttribute::CustomAccessorOrValue);
-    putDirectCustomAccessor(vm, builtinNames.ReadableStreamBYOBReaderPrivateName(), CustomGetterSetter::create(vm, ReadableStreamBYOBReader_getter, nullptr), attributesForStructure(PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly) | PropertyAttribute::CustomAccessorOrValue);
-    putDirectCustomAccessor(vm, builtinNames.ReadableStreamBYOBRequestPrivateName(), CustomGetterSetter::create(vm, ReadableStreamBYOBRequest_getter, nullptr), attributesForStructure(PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly) | PropertyAttribute::CustomAccessorOrValue);
-    putDirectCustomAccessor(vm, builtinNames.ReadableStreamDefaultControllerPrivateName(), CustomGetterSetter::create(vm, ReadableStreamDefaultController_getter, nullptr), attributesForStructure(PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly) | PropertyAttribute::CustomAccessorOrValue);
-    putDirectCustomAccessor(vm, builtinNames.ReadableStreamDefaultReaderPrivateName(), CustomGetterSetter::create(vm, ReadableStreamDefaultReader_getter, nullptr), attributesForStructure(PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly) | PropertyAttribute::CustomAccessorOrValue);
-    putDirectCustomAccessor(vm, builtinNames.WritableStreamPrivateName(), CustomGetterSetter::create(vm, WritableStream_getter, nullptr), attributesForStructure(PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly) | PropertyAttribute::CustomAccessorOrValue);
-    putDirectCustomAccessor(vm, builtinNames.WritableStreamDefaultControllerPrivateName(), CustomGetterSetter::create(vm, WritableStreamDefaultController_getter, nullptr), attributesForStructure(PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly) | PropertyAttribute::CustomAccessorOrValue);
-    putDirectCustomAccessor(vm, builtinNames.WritableStreamDefaultWriterPrivateName(), CustomGetterSetter::create(vm, WritableStreamDefaultWriter_getter, nullptr), attributesForStructure(PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly) | PropertyAttribute::CustomAccessorOrValue);
-    putDirectCustomAccessor(vm, builtinNames.AbortSignalPrivateName(), CustomGetterSetter::create(vm, AbortSignal_getter, nullptr), PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly | PropertyAttribute::CustomAccessorOrValue);
+    putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().BufferPrivateName(), JSC::CustomGetterSetter::create(vm, JSBuffer_getter, nullptr), PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly | PropertyAttribute::CustomValue);
+    putDirectCustomAccessor(vm, builtinNames.lazyStreamPrototypeMapPrivateName(), JSC::CustomGetterSetter::create(vm, functionLazyLoadStreamPrototypeMap_getter, nullptr), PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly | PropertyAttribute::CustomValue);
+    putDirectCustomAccessor(vm, builtinNames.TransformStreamPrivateName(), CustomGetterSetter::create(vm, TransformStream_getter, nullptr), attributesForStructure(static_cast<unsigned>(PropertyAttribute::DontEnum)) | PropertyAttribute::CustomValue);
+    putDirectCustomAccessor(vm, builtinNames.TransformStreamDefaultControllerPrivateName(), CustomGetterSetter::create(vm, TransformStreamDefaultController_getter, nullptr), attributesForStructure(static_cast<unsigned>(PropertyAttribute::DontEnum)) | PropertyAttribute::CustomValue);
+    putDirectCustomAccessor(vm, builtinNames.ReadableByteStreamControllerPrivateName(), CustomGetterSetter::create(vm, ReadableByteStreamController_getter, nullptr), attributesForStructure(PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly) | PropertyAttribute::CustomValue);
+    putDirectCustomAccessor(vm, builtinNames.ReadableStreamPrivateName(), CustomGetterSetter::create(vm, ReadableStream_getter, nullptr), attributesForStructure(PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly) | PropertyAttribute::CustomValue);
+    putDirectCustomAccessor(vm, builtinNames.ReadableStreamBYOBReaderPrivateName(), CustomGetterSetter::create(vm, ReadableStreamBYOBReader_getter, nullptr), attributesForStructure(PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly) | PropertyAttribute::CustomValue);
+    putDirectCustomAccessor(vm, builtinNames.ReadableStreamBYOBRequestPrivateName(), CustomGetterSetter::create(vm, ReadableStreamBYOBRequest_getter, nullptr), attributesForStructure(PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly) | PropertyAttribute::CustomValue);
+    putDirectCustomAccessor(vm, builtinNames.ReadableStreamDefaultControllerPrivateName(), CustomGetterSetter::create(vm, ReadableStreamDefaultController_getter, nullptr), attributesForStructure(PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly) | PropertyAttribute::CustomValue);
+    putDirectCustomAccessor(vm, builtinNames.ReadableStreamDefaultReaderPrivateName(), CustomGetterSetter::create(vm, ReadableStreamDefaultReader_getter, nullptr), attributesForStructure(PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly) | PropertyAttribute::CustomValue);
+    putDirectCustomAccessor(vm, builtinNames.WritableStreamPrivateName(), CustomGetterSetter::create(vm, WritableStream_getter, nullptr), attributesForStructure(PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly) | PropertyAttribute::CustomValue);
+    putDirectCustomAccessor(vm, builtinNames.WritableStreamDefaultControllerPrivateName(), CustomGetterSetter::create(vm, WritableStreamDefaultController_getter, nullptr), attributesForStructure(PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly) | PropertyAttribute::CustomValue);
+    putDirectCustomAccessor(vm, builtinNames.WritableStreamDefaultWriterPrivateName(), CustomGetterSetter::create(vm, WritableStreamDefaultWriter_getter, nullptr), attributesForStructure(PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly) | PropertyAttribute::CustomValue);
+    putDirectCustomAccessor(vm, builtinNames.AbortSignalPrivateName(), CustomGetterSetter::create(vm, AbortSignal_getter, nullptr), PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly | PropertyAttribute::CustomValue);
 
     // ----- Public Properties -----
 
@@ -3548,6 +3748,15 @@ extern "C" void JSC__JSGlobalObject__drainMicrotasks(Zig::GlobalObject* globalOb
     globalObject->drainMicrotasks();
 }
 
+extern "C" EncodedJSValue JSC__JSGlobalObject__getHTTP2CommonString(Zig::GlobalObject* globalObject, uint32_t hpack_index)
+{
+    auto value = globalObject->http2CommonStrings().getStringFromHPackIndex(hpack_index, globalObject);
+    if (value != nullptr) {
+        return JSValue::encode(value);
+    }
+    return JSValue::encode(JSValue::JSUndefined);
+}
+
 template<typename Visitor>
 void GlobalObject::visitChildrenImpl(JSCell* cell, Visitor& visitor)
 {
@@ -3571,6 +3780,7 @@ void GlobalObject::visitChildrenImpl(JSCell* cell, Visitor& visitor)
 
     thisObject->m_builtinInternalFunctions.visit(visitor);
     thisObject->m_commonStrings.visit<Visitor>(visitor);
+    thisObject->m_http2_commongStrings.visit<Visitor>(visitor);
     visitor.append(thisObject->m_assignToStream);
     visitor.append(thisObject->m_readableStreamToArrayBuffer);
     visitor.append(thisObject->m_readableStreamToArrayBufferResolve);
@@ -3579,7 +3789,6 @@ void GlobalObject::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     visitor.append(thisObject->m_readableStreamToJSON);
     visitor.append(thisObject->m_readableStreamToText);
     visitor.append(thisObject->m_readableStreamToFormData);
-    visitor.append(thisObject->m_nodeModuleOverriddenResolveFilename);
 
     visitor.append(thisObject->m_nextTickQueue);
     visitor.append(thisObject->m_errorConstructorPrepareStackTraceValue);
@@ -3589,6 +3798,8 @@ void GlobalObject::visitChildrenImpl(JSCell* cell, Visitor& visitor)
 
     visitor.append(thisObject->m_currentNapiHandleScopeImpl);
 
+    thisObject->m_moduleResolveFilenameFunction.visit(visitor);
+    thisObject->m_nodeModuleConstructor.visit(visitor);
     thisObject->m_asyncBoundFunctionStructure.visit(visitor);
     thisObject->m_bunObject.visit(visitor);
     thisObject->m_cachedNodeVMGlobalObjectStructure.visit(visitor);
@@ -3606,6 +3817,7 @@ void GlobalObject::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     thisObject->m_JSBufferListClassStructure.visit(visitor);
     thisObject->m_JSBufferSubclassStructure.visit(visitor);
     thisObject->m_JSCryptoKey.visit(visitor);
+    thisObject->m_lazyStackCustomGetterSetter.visit(visitor);
     thisObject->m_JSDOMFileConstructor.visit(visitor);
     thisObject->m_JSFFIFunctionStructure.visit(visitor);
     thisObject->m_JSFileSinkClassStructure.visit(visitor);
@@ -3614,6 +3826,8 @@ void GlobalObject::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     thisObject->m_JSHTTPResponseSinkClassStructure.visit(visitor);
     thisObject->m_JSHTTPSResponseControllerPrototype.visit(visitor);
     thisObject->m_JSHTTPSResponseSinkClassStructure.visit(visitor);
+    thisObject->m_JSFetchTaskletChunkedRequestSinkClassStructure.visit(visitor);
+    thisObject->m_JSFetchTaskletChunkedRequestControllerPrototype.visit(visitor);
     thisObject->m_JSSocketAddressStructure.visit(visitor);
     thisObject->m_JSSQLStatementStructure.visit(visitor);
     thisObject->m_V8GlobalInternals.visit(visitor);
@@ -3628,6 +3842,8 @@ void GlobalObject::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     thisObject->m_NAPIFunctionStructure.visit(visitor);
     thisObject->m_NapiPrototypeStructure.visit(visitor);
     thisObject->m_NapiHandleScopeImplStructure.visit(visitor);
+    thisObject->m_NapiTypeTagStructure.visit(visitor);
+    thisObject->m_napiTypeTags.visit(visitor);
     thisObject->m_nativeMicrotaskTrampoline.visit(visitor);
     thisObject->m_navigatorObject.visit(visitor);
     thisObject->m_NodeVMScriptClassStructure.visit(visitor);
@@ -3942,7 +4158,8 @@ JSC::JSInternalPromise* GlobalObject::moduleLoaderImportModule(JSGlobalObject* j
     ASSERT(startRefCount == moduleName.impl()->refCount());
     if (!resolved.success) {
         throwException(scope, resolved.result.err, globalObject);
-        return JSC::JSInternalPromise::rejectedPromiseWithCaughtException(globalObject, scope);
+        auto* promise = JSC::JSInternalPromise::create(vm, globalObject->internalPromiseStructure());
+        return promise->rejectWithCaughtException(globalObject, scope);
     }
 
     JSC::Identifier resolvedIdentifier;
@@ -4150,6 +4367,10 @@ GlobalObject::PromiseFunctions GlobalObject::promiseHandlerID(Zig::FFIFunction h
         return GlobalObject::PromiseFunctions::Bun__onResolveEntryPointResult;
     } else if (handler == Bun__onRejectEntryPointResult) {
         return GlobalObject::PromiseFunctions::Bun__onRejectEntryPointResult;
+    } else if (handler == Bun__FetchTasklet__onResolveRequestStream) {
+        return GlobalObject::PromiseFunctions::Bun__FetchTasklet__onResolveRequestStream;
+    } else if (handler == Bun__FetchTasklet__onRejectRequestStream) {
+        return GlobalObject::PromiseFunctions::Bun__FetchTasklet__onRejectRequestStream;
     } else {
         RELEASE_ASSERT_NOT_REACHED();
     }
diff --git a/src/bun.js/bindings/ZigGlobalObject.h b/src/bun.js/bindings/ZigGlobalObject.h
index aa94f5abde..c2dca678fc 100644
--- a/src/bun.js/bindings/ZigGlobalObject.h
+++ b/src/bun.js/bindings/ZigGlobalObject.h
@@ -33,7 +33,9 @@ class NapiHandleScopeImpl;
 } // namespace Bun
 
 namespace v8 {
+namespace shim {
 class GlobalInternals;
+} // namespace shim
 } // namespace v8
 
 #include "root.h"
@@ -49,6 +51,7 @@ class GlobalInternals;
 #include "WebCoreJSBuiltins.h"
 #include "headers-handwritten.h"
 #include "BunCommonStrings.h"
+#include "BunHttp2CommonStrings.h"
 #include "BunGlobalScope.h"
 
 namespace WebCore {
@@ -97,10 +100,7 @@ public:
 
     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; }
@@ -121,33 +121,10 @@ public:
         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
     {
@@ -189,8 +166,7 @@ public:
 
     void clearDOMGuardedObjects();
 
-    static void createCallSitesFromFrames(Zig::GlobalObject* globalObject, JSC::JSGlobalObject* lexicalGlobalObject, JSCStackTrace& stackTrace, JSC::JSArray* callSites);
-    void formatStackTrace(JSC::VM& vm, JSC::JSGlobalObject* lexicalGlobalObject, JSC::JSObject* errorObject, JSC::JSArray* callSites, JSValue prepareStack = JSC::jsUndefined());
+    static void createCallSitesFromFrames(Zig::GlobalObject* globalObject, JSC::JSGlobalObject* lexicalGlobalObject, JSCStackTrace& stackTrace, MarkedArgumentBuffer& callSites);
 
     static void reportUncaughtExceptionAtEventLoop(JSGlobalObject*, JSC::Exception*);
     static JSGlobalObject* deriveShadowRealmGlobalObject(JSGlobalObject* globalObject);
@@ -234,6 +210,11 @@ public:
     JSC::JSValue HTTPSResponseSinkPrototype() const { return m_JSHTTPSResponseSinkClassStructure.prototypeInitializedOnMainThread(this); }
     JSC::JSValue JSReadableHTTPSResponseSinkControllerPrototype() const { return m_JSHTTPSResponseControllerPrototype.getInitializedOnMainThread(this); }
 
+    JSC::Structure* FetchTaskletChunkedRequestSinkStructure() const { return m_JSFetchTaskletChunkedRequestSinkClassStructure.getInitializedOnMainThread(this); }
+    JSC::JSObject* FetchTaskletChunkedRequestSink() { return m_JSFetchTaskletChunkedRequestSinkClassStructure.constructorInitializedOnMainThread(this); }
+    JSC::JSValue FetchTaskletChunkedRequestSinkPrototype() const { return m_JSFetchTaskletChunkedRequestSinkClassStructure.prototypeInitializedOnMainThread(this); }
+    JSC::JSValue JSReadableFetchTaskletChunkedRequestSinkControllerPrototype() const { return m_JSFetchTaskletChunkedRequestControllerPrototype.getInitializedOnMainThread(this); }
+
     JSC::Structure* JSBufferListStructure() const { return m_JSBufferListClassStructure.getInitializedOnMainThread(this); }
     JSC::JSObject* JSBufferList() { return m_JSBufferListClassStructure.constructorInitializedOnMainThread(this); }
     JSC::JSValue JSBufferListPrototype() const { return m_JSBufferListClassStructure.prototypeInitializedOnMainThread(this); }
@@ -286,10 +267,11 @@ public:
     Structure* NapiPrototypeStructure() const { return m_NapiPrototypeStructure.getInitializedOnMainThread(this); }
     Structure* NAPIFunctionStructure() const { return m_NAPIFunctionStructure.getInitializedOnMainThread(this); }
     Structure* NapiHandleScopeImplStructure() const { return m_NapiHandleScopeImplStructure.getInitializedOnMainThread(this); }
+    Structure* NapiTypeTagStructure() const { return m_NapiTypeTagStructure.getInitializedOnMainThread(this); }
 
     Structure* JSSQLStatementStructure() const { return m_JSSQLStatementStructure.getInitializedOnMainThread(this); }
 
-    v8::GlobalInternals* V8GlobalInternals() const { return m_V8GlobalInternals.getInitializedOnMainThread(this); }
+    v8::shim::GlobalInternals* V8GlobalInternals() const { return m_V8GlobalInternals.getInitializedOnMainThread(this); }
 
     bool hasProcessObject() const { return m_processObject.isInitialized(); }
 
@@ -352,8 +334,10 @@ public:
         Bun__BodyValueBufferer__onResolveStream,
         Bun__onResolveEntryPointResult,
         Bun__onRejectEntryPointResult,
+        Bun__FetchTasklet__onRejectRequestStream,
+        Bun__FetchTasklet__onResolveRequestStream,
     };
-    static constexpr size_t promiseFunctionsSize = 24;
+    static constexpr size_t promiseFunctionsSize = 26;
 
     static PromiseFunctions promiseHandlerID(SYSV_ABI EncodedJSValue (*handler)(JSC__JSGlobalObject* arg0, JSC__CallFrame* arg1));
 
@@ -372,6 +356,8 @@ public:
     }
 
     bool asyncHooksNeedsCleanup = false;
+    double INSPECT_MAX_BYTES = 50;
+    bool isInsideErrorPrepareStackTraceCallback = false;
 
     /**
      * WARNING: You must update visitChildrenImpl() if you add a new field.
@@ -393,9 +379,8 @@ public:
     mutable WriteBarrier<JSFunction> m_readableStreamToText;
     mutable WriteBarrier<JSFunction> m_readableStreamToFormData;
 
-    // This is set when doing `require('module')._resolveFilename = ...`
-    // a hack used by Next.js to inject their versions of webpack and react
-    mutable WriteBarrier<JSFunction> m_nodeModuleOverriddenResolveFilename;
+    LazyProperty<JSGlobalObject, JSCell> m_moduleResolveFilenameFunction;
+    LazyProperty<JSGlobalObject, JSObject> m_nodeModuleConstructor;
 
     mutable WriteBarrier<Unknown> m_nextTickQueue;
 
@@ -408,6 +393,10 @@ public:
     // When a napi module initializes on dlopen, we need to know what the value is
     mutable JSC::WriteBarrier<Unknown> m_pendingNapiModuleAndExports[2];
 
+    // This is the result of dlopen()ing a napi module.
+    // We will add it to the resulting napi value.
+    void* m_pendingNapiModuleDlopenHandle = nullptr;
+
     // The handle scope where all new NAPI values will be created. You must not pass any napi_values
     // back to a NAPI function without putting them in the handle scope, as the NAPI function may
     // move them off the stack which will cause them to get collected if not in the handle scope.
@@ -475,6 +464,12 @@ public:
     void* napiInstanceDataFinalizer = nullptr;
     void* napiInstanceDataFinalizerHint = nullptr;
 
+    // Used by napi_type_tag_object to associate a 128-bit type ID with JS objects.
+    // Should only use JSCell* keys and NapiTypeTag values.
+    LazyProperty<JSGlobalObject, JSC::JSWeakMap> m_napiTypeTags;
+
+    JSC::JSWeakMap* napiTypeTags() const { return m_napiTypeTags.getInitializedOnMainThread(this); }
+
     Bun::JSMockModule mockModule;
 
     LazyProperty<JSGlobalObject, JSObject> m_processEnvObject;
@@ -482,7 +477,7 @@ public:
     JSObject* cryptoObject() const { return m_cryptoObject.getInitializedOnMainThread(this); }
     JSObject* JSDOMFileConstructor() const { return m_JSDOMFileConstructor.getInitializedOnMainThread(this); }
     Bun::CommonStrings& commonStrings() { return m_commonStrings; }
-
+    Bun::Http2CommonStrings& http2CommonStrings() { return m_http2_commongStrings; }
 #include "ZigGeneratedClasses+lazyStructureHeader.h"
 
     void finishCreation(JSC::VM&);
@@ -498,6 +493,7 @@ private:
     Lock m_gcLock;
     Ref<WebCore::DOMWrapperWorld> m_world;
     Bun::CommonStrings m_commonStrings;
+    Bun::Http2CommonStrings m_http2_commongStrings;
     RefPtr<WebCore::Performance> m_performance { nullptr };
 
     // JSC's hashtable code-generator tries to access these properties, so we make them public.
@@ -519,6 +515,8 @@ public:
     LazyClassStructure m_JSFileSinkClassStructure;
     LazyClassStructure m_JSHTTPResponseSinkClassStructure;
     LazyClassStructure m_JSHTTPSResponseSinkClassStructure;
+    LazyClassStructure m_JSFetchTaskletChunkedRequestSinkClassStructure;
+
     LazyClassStructure m_JSStringDecoderClassStructure;
     LazyClassStructure m_NapiClassStructure;
     LazyClassStructure m_callSiteStructure;
@@ -548,6 +546,7 @@ public:
     LazyProperty<JSGlobalObject, JSMap> m_esmRegistryMap;
     LazyProperty<JSGlobalObject, JSObject> m_JSArrayBufferControllerPrototype;
     LazyProperty<JSGlobalObject, JSObject> m_JSHTTPSResponseControllerPrototype;
+    LazyProperty<JSGlobalObject, JSObject> m_JSFetchTaskletChunkedRequestControllerPrototype;
     LazyProperty<JSGlobalObject, JSObject> m_JSFileSinkControllerPrototype;
     LazyProperty<JSGlobalObject, JSObject> m_subtleCryptoObject;
     LazyProperty<JSGlobalObject, Structure> m_JSHTTPResponseController;
@@ -574,15 +573,19 @@ public:
     LazyProperty<JSGlobalObject, Structure> m_NapiPrototypeStructure;
     LazyProperty<JSGlobalObject, Structure> m_NAPIFunctionStructure;
     LazyProperty<JSGlobalObject, Structure> m_NapiHandleScopeImplStructure;
+    LazyProperty<JSGlobalObject, Structure> m_NapiTypeTagStructure;
 
     LazyProperty<JSGlobalObject, Structure> m_JSSQLStatementStructure;
-    LazyProperty<JSGlobalObject, v8::GlobalInternals> m_V8GlobalInternals;
+    LazyProperty<JSGlobalObject, v8::shim::GlobalInternals> m_V8GlobalInternals;
 
     LazyProperty<JSGlobalObject, JSObject> m_bunObject;
     LazyProperty<JSGlobalObject, JSObject> m_cryptoObject;
     LazyProperty<JSGlobalObject, JSObject> m_navigatorObject;
     LazyProperty<JSGlobalObject, JSObject> m_performanceObject;
     LazyProperty<JSGlobalObject, JSObject> m_processObject;
+    LazyProperty<JSGlobalObject, CustomGetterSetter> m_lazyStackCustomGetterSetter;
+
+    bool hasOverridenModuleResolveFilenameFunction = false;
 
 private:
     DOMGuardedObjectSet m_guardedObjects WTF_GUARDED_BY_LOCK(m_gcLock);
diff --git a/src/bun.js/bindings/ZigGlobalObject.lut.txt b/src/bun.js/bindings/ZigGlobalObject.lut.txt
index 106143b94a..fa44a60673 100644
--- a/src/bun.js/bindings/ZigGlobalObject.lut.txt
+++ b/src/bun.js/bindings/ZigGlobalObject.lut.txt
@@ -23,7 +23,6 @@
   structuredClone                 functionStructuredClone                              Function 2
   
   global                          GlobalObject_getGlobalThis                           PropertyCallback
-  EventSource                     getEventSourceConstructor                            PropertyCallback
   
   Bun                             GlobalObject::m_bunObject                            CellProperty|DontDelete|ReadOnly
   File                            GlobalObject::m_JSDOMFileConstructor                 CellProperty
@@ -67,6 +66,9 @@
   PerformanceMeasure              PerformanceMeasureConstructorCallback                PropertyCallback
   PerformanceObserver             PerformanceObserverConstructorCallback               PropertyCallback
   PerformanceObserverEntryList    PerformanceObserverEntryListConstructorCallback      PropertyCallback
+  PerformanceResourceTiming       PerformanceResourceTimingConstructorCallback         PropertyCallback
+  PerformanceServerTiming         PerformanceServerTimingConstructorCallback           PropertyCallback
+  PerformanceTiming               PerformanceTimingConstructorCallback                 PropertyCallback
   ReadableByteStreamController    ReadableByteStreamControllerConstructorCallback      PropertyCallback
   ReadableStream                  ReadableStreamConstructorCallback                    PropertyCallback
   ReadableStreamBYOBReader        ReadableStreamBYOBReaderConstructorCallback          PropertyCallback
@@ -74,9 +76,9 @@
   ReadableStreamDefaultController ReadableStreamDefaultControllerConstructorCallback   PropertyCallback
   ReadableStreamDefaultReader     ReadableStreamDefaultReaderConstructorCallback       PropertyCallback
   SubtleCrypto                    SubtleCryptoConstructorCallback                      PropertyCallback
+  TextDecoderStream               TextDecoderStreamConstructorCallback                 PropertyCallback
   TextEncoder                     TextEncoderConstructorCallback                       PropertyCallback
   TextEncoderStream               TextEncoderStreamConstructorCallback                 PropertyCallback
-  TextDecoderStream               TextDecoderStreamConstructorCallback                 PropertyCallback
   TransformStream                 TransformStreamConstructorCallback                   PropertyCallback
   TransformStreamDefaultController TransformStreamDefaultControllerConstructorCallback PropertyCallback
   URL                             DOMURLConstructorCallback                            PropertyCallback
diff --git a/src/bun.js/bindings/ZigSourceProvider.cpp b/src/bun.js/bindings/ZigSourceProvider.cpp
index 3d1c137bbe..53c1236bb8 100644
--- a/src/bun.js/bindings/ZigSourceProvider.cpp
+++ b/src/bun.js/bindings/ZigSourceProvider.cpp
@@ -12,6 +12,9 @@
 #include <wtf/Scope.h>
 #include <wtf/text/StringHash.h>
 #include <sys/stat.h>
+#include <JavaScriptCore/SourceCodeKey.h>
+#include <mimalloc.h>
+#include <JavaScriptCore/CodeCache.h>
 
 extern "C" void RefString__free(void*, void*, unsigned);
 
@@ -91,14 +94,40 @@ Ref<SourceProvider> SourceProvider::create(
         // https://github.com/oven-sh/bun/issues/9521
     }
 
-    auto provider = adoptRef(*new SourceProvider(
-        globalObject->isThreadLocalDefaultGlobalObject ? globalObject : nullptr,
-        resolvedSource,
-        string.isNull() ? *StringImpl::empty() : *string.impl(),
-        JSC::SourceTaintedOrigin::Untainted,
-        toSourceOrigin(sourceURLString, isBuiltin),
-        sourceURLString.impl(), TextPosition(),
-        sourceType));
+    const auto getProvider = [&]() -> Ref<SourceProvider> {
+        if (resolvedSource.bytecode_cache != nullptr) {
+            const auto destructorPtr = [](const void* ptr) {
+                mi_free(const_cast<void*>(ptr));
+            };
+            const auto destructorNoOp = [](const void* ptr) {
+                // no-op, for bun build --compile.
+            };
+            const auto destructor = resolvedSource.needsDeref ? destructorPtr : destructorNoOp;
+
+            Ref<JSC::CachedBytecode> bytecode = JSC::CachedBytecode::create(std::span<uint8_t>(resolvedSource.bytecode_cache, resolvedSource.bytecode_cache_size), destructor, {});
+            auto provider = adoptRef(*new SourceProvider(
+                globalObject->isThreadLocalDefaultGlobalObject ? globalObject : nullptr,
+                resolvedSource,
+                string.isNull() ? *StringImpl::empty() : *string.impl(),
+                JSC::SourceTaintedOrigin::Untainted,
+                toSourceOrigin(sourceURLString, isBuiltin),
+                sourceURLString.impl(), TextPosition(),
+                sourceType));
+            provider->m_cachedBytecode = WTFMove(bytecode);
+            return provider;
+        }
+
+        return adoptRef(*new SourceProvider(
+            globalObject->isThreadLocalDefaultGlobalObject ? globalObject : nullptr,
+            resolvedSource,
+            string.isNull() ? *StringImpl::empty() : *string.impl(),
+            JSC::SourceTaintedOrigin::Untainted,
+            toSourceOrigin(sourceURLString, isBuiltin),
+            sourceURLString.impl(), TextPosition(),
+            sourceType));
+    };
+
+    auto provider = getProvider();
 
     if (shouldGenerateCodeCoverage) {
         ByteRangeMapping__generate(Bun::toString(provider->sourceURL()), Bun::toString(provider->source().toStringWithoutCopying()), provider->asID());
@@ -111,6 +140,11 @@ Ref<SourceProvider> SourceProvider::create(
     return provider;
 }
 
+StringView SourceProvider::source() const
+{
+    return StringView(m_source.get());
+}
+
 SourceProvider::~SourceProvider()
 {
     if (m_resolvedSource.already_bundled) {
@@ -119,6 +153,90 @@ SourceProvider::~SourceProvider()
     }
 }
 
+extern "C" void CachedBytecode__deref(JSC::CachedBytecode* cachedBytecode)
+{
+    cachedBytecode->deref();
+}
+
+static JSC::VM& getVMForBytecodeCache()
+{
+    static thread_local JSC::VM* vmForBytecodeCache = nullptr;
+    if (!vmForBytecodeCache) {
+        const auto heapSize = JSC::HeapType::Small;
+        auto& vm = JSC::VM::create(heapSize).leakRef();
+        vm.ref();
+        vmForBytecodeCache = &vm;
+        vm.heap.acquireAccess();
+    }
+    return *vmForBytecodeCache;
+}
+
+extern "C" bool generateCachedModuleByteCodeFromSourceCode(BunString* sourceProviderURL, const LChar* inputSourceCode, size_t inputSourceCodeSize, const uint8_t** outputByteCode, size_t* outputByteCodeSize, JSC::CachedBytecode** cachedBytecodePtr)
+{
+    std::span<const LChar> sourceCodeSpan(inputSourceCode, inputSourceCodeSize);
+    JSC::SourceCode sourceCode = JSC::makeSource(WTF::String(sourceCodeSpan), toSourceOrigin(sourceProviderURL->toWTFString(), false), JSC::SourceTaintedOrigin::Untainted);
+
+    JSC::VM& vm = getVMForBytecodeCache();
+
+    JSC::JSLockHolder locker(vm);
+    LexicallyScopedFeatures lexicallyScopedFeatures = StrictModeLexicallyScopedFeature;
+    JSParserScriptMode scriptMode = JSParserScriptMode::Module;
+    EvalContextType evalContextType = EvalContextType::None;
+
+    ParserError parserError;
+    UnlinkedModuleProgramCodeBlock* unlinkedCodeBlock = JSC::recursivelyGenerateUnlinkedCodeBlockForModuleProgram(vm, sourceCode, lexicallyScopedFeatures, scriptMode, {}, parserError, evalContextType);
+    if (parserError.isValid())
+        return false;
+    if (!unlinkedCodeBlock)
+        return false;
+
+    auto key = JSC::sourceCodeKeyForSerializedModule(vm, sourceCode);
+
+    RefPtr<JSC::CachedBytecode> cachedBytecode = JSC::encodeCodeBlock(vm, key, unlinkedCodeBlock);
+    if (!cachedBytecode)
+        return false;
+
+    cachedBytecode->ref();
+    *cachedBytecodePtr = cachedBytecode.get();
+    *outputByteCode = cachedBytecode->span().data();
+    *outputByteCodeSize = cachedBytecode->span().size();
+
+    return true;
+}
+
+extern "C" bool generateCachedCommonJSProgramByteCodeFromSourceCode(BunString* sourceProviderURL, const LChar* inputSourceCode, size_t inputSourceCodeSize, const uint8_t** outputByteCode, size_t* outputByteCodeSize, JSC::CachedBytecode** cachedBytecodePtr)
+{
+    std::span<const LChar> sourceCodeSpan(inputSourceCode, inputSourceCodeSize);
+
+    JSC::SourceCode sourceCode = JSC::makeSource(WTF::String(sourceCodeSpan), toSourceOrigin(sourceProviderURL->toWTFString(), false), JSC::SourceTaintedOrigin::Untainted);
+    JSC::VM& vm = getVMForBytecodeCache();
+
+    JSC::JSLockHolder locker(vm);
+    LexicallyScopedFeatures lexicallyScopedFeatures = NoLexicallyScopedFeatures;
+    JSParserScriptMode scriptMode = JSParserScriptMode::Classic;
+    EvalContextType evalContextType = EvalContextType::None;
+
+    ParserError parserError;
+    UnlinkedProgramCodeBlock* unlinkedCodeBlock = JSC::recursivelyGenerateUnlinkedCodeBlockForProgram(vm, sourceCode, lexicallyScopedFeatures, scriptMode, {}, parserError, evalContextType);
+    if (parserError.isValid())
+        return false;
+    if (!unlinkedCodeBlock)
+        return false;
+
+    auto key = JSC::sourceCodeKeyForSerializedProgram(vm, sourceCode);
+
+    RefPtr<JSC::CachedBytecode> cachedBytecode = JSC::encodeCodeBlock(vm, key, unlinkedCodeBlock);
+    if (!cachedBytecode)
+        return false;
+
+    cachedBytecode->ref();
+    *cachedBytecodePtr = cachedBytecode.get();
+    *outputByteCode = cachedBytecode->span().data();
+    *outputByteCodeSize = cachedBytecode->span().size();
+
+    return true;
+}
+
 unsigned SourceProvider::hash() const
 {
     if (m_hash) {
diff --git a/src/bun.js/bindings/ZigSourceProvider.h b/src/bun.js/bindings/ZigSourceProvider.h
index d8ccaa69ee..eddb638665 100644
--- a/src/bun.js/bindings/ZigSourceProvider.h
+++ b/src/bun.js/bindings/ZigSourceProvider.h
@@ -43,11 +43,11 @@ public:
         bool isBuiltIn = false);
     ~SourceProvider();
     unsigned hash() const override;
-    StringView source() const override { return StringView(m_source.get()); }
+    StringView source() const override;
 
-    RefPtr<JSC::CachedBytecode> cachedBytecode()
+    RefPtr<JSC::CachedBytecode> cachedBytecode() const final
     {
-        return nullptr;
+        return m_cachedBytecode.copyRef();
     };
 
     void updateCache(const UnlinkedFunctionExecutable* executable, const SourceCode&,
diff --git a/src/bun.js/bindings/bindings.cpp b/src/bun.js/bindings/bindings.cpp
index 2c69eb1a9f..38e244d118 100644
--- a/src/bun.js/bindings/bindings.cpp
+++ b/src/bun.js/bindings/bindings.cpp
@@ -123,6 +123,8 @@
 #include "JavaScriptCore/CustomGetterSetter.h"
 
 #include "ErrorStackFrame.h"
+#include "ErrorStackTrace.h"
+#include "ObjectBindings.h"
 
 #if OS(DARWIN)
 #if BUN_DEBUG
@@ -220,7 +222,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,
@@ -241,7 +244,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()) {
@@ -257,21 +260,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);
@@ -411,6 +414,7 @@ AsymmetricMatcherResult matchAsymmetricMatcherAndGetFlags(JSGlobalObject* global
         case AsymmetricMatcherConstructorType::InstanceOf: {
             break;
         }
+        case AsymmetricMatcherConstructorType::exception:
         case AsymmetricMatcherConstructorType::none: {
             ASSERT_NOT_REACHED_WITH_MESSAGE("Invalid constructor type");
             break;
@@ -736,7 +740,7 @@ bool Bun__deepEquals(JSC__JSGlobalObject* globalObject, JSValue v1, JSValue v2,
             return false;
         }
 
-        auto iter1 = JSSetIterator::create(globalObject, set1->structure(), set1, IterationKind::Keys);
+        auto iter1 = JSSetIterator::create(globalObject, globalObject->setIteratorStructure(), set1, IterationKind::Keys);
         JSValue key1;
         while (iter1->next(globalObject, key1)) {
             if (set2->has(globalObject, key1)) {
@@ -745,7 +749,7 @@ bool Bun__deepEquals(JSC__JSGlobalObject* globalObject, JSValue v1, JSValue v2,
 
             // We couldn't find the key in the second set. This may be a false positive due to how
             // JSValues are represented in JSC, so we need to fall back to a linear search to be sure.
-            auto iter2 = JSSetIterator::create(globalObject, set2->structure(), set2, IterationKind::Keys);
+            auto iter2 = JSSetIterator::create(globalObject, globalObject->setIteratorStructure(), set2, IterationKind::Keys);
             JSValue key2;
             bool foundMatchingKey = false;
             while (iter2->next(globalObject, key2)) {
@@ -775,7 +779,7 @@ bool Bun__deepEquals(JSC__JSGlobalObject* globalObject, JSValue v1, JSValue v2,
             return false;
         }
 
-        auto iter1 = JSMapIterator::create(globalObject, map1->structure(), map1, IterationKind::Entries);
+        auto iter1 = JSMapIterator::create(globalObject, globalObject->mapIteratorStructure(), map1, IterationKind::Entries);
         JSValue key1, value1;
         while (iter1->nextKeyValue(globalObject, key1, value1)) {
             JSValue value2 = map2->get(globalObject, key1);
@@ -783,7 +787,7 @@ bool Bun__deepEquals(JSC__JSGlobalObject* globalObject, JSValue v1, JSValue v2,
                 // We couldn't find the key in the second map. This may be a false positive due to
                 // how JSValues are represented in JSC, so we need to fall back to a linear search
                 // to be sure.
-                auto iter2 = JSMapIterator::create(globalObject, map2->structure(), map2, IterationKind::Entries);
+                auto iter2 = JSMapIterator::create(globalObject, globalObject->mapIteratorStructure(), map2, IterationKind::Entries);
                 JSValue key2;
                 bool foundMatchingKey = false;
                 while (iter2->nextKeyValue(globalObject, key2, value2)) {
@@ -941,8 +945,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);
@@ -953,6 +959,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) {
@@ -963,8 +973,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;
     }
 
@@ -2294,19 +2387,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());
@@ -2316,10 +2407,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());
 
@@ -2788,9 +2882,13 @@ JSC__JSValue JSC__JSGlobalObject__createAggregateError(JSC__JSGlobalObject* glob
 
     RELEASE_AND_RETURN(scope, JSC::JSValue::encode(JSC::createAggregateError(globalObject, vm, errorStructure, array, message, options, nullptr, JSC::TypeNothing, false)));
 }
-// static JSC::JSNativeStdFunction* resolverFunction;
-// static JSC::JSNativeStdFunction* rejecterFunction;
-// static bool resolverFunctionInitialized = false;
+JSC::EncodedJSValue JSC__JSGlobalObject__createAggregateErrorWithArray(JSC::JSGlobalObject* global, JSC::JSArray* array, BunString message, JSValue options)
+{
+    JSC::VM& vm = global->vm();
+    JSC::Structure* errorStructure = global->errorStructure(JSC::ErrorType::AggregateError);
+    WTF::String messageString = message.toWTFString();
+    return JSC::JSValue::encode(JSC::createAggregateError(global, vm, errorStructure, array, JSC::jsString(vm, messageString), options, nullptr, JSC::TypeNothing, false));
+}
 
 JSC__JSValue ZigString__toAtomicValue(const ZigString* arg0, JSC__JSGlobalObject* arg1)
 {
@@ -3700,31 +3798,16 @@ JSC__JSValue JSC__JSValue__getIfPropertyExistsImpl(JSC__JSValue JSValue0,
 
     JSC::VM& vm = globalObject->vm();
     JSC::JSObject* object = value.getObject();
-    if (UNLIKELY(!object))
-        return JSValue::encode({});
+    if (UNLIKELY(!object)) {
+        return JSValue::encode(JSValue::decode(JSC::JSValue::ValueDeleted));
+    }
 
-    // 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);
 
-    return JSC::JSValue::encode(object->getIfPropertyExists(globalObject, property));
-}
-
-extern "C" JSC__JSValue JSC__JSValue__getIfPropertyExistsImplString(JSC__JSValue JSValue0, JSC__JSGlobalObject* globalObject, BunString* propertyName)
-{
-    ASSERT_NO_PENDING_EXCEPTION(globalObject);
-    JSValue value = JSC::JSValue::decode(JSValue0);
-    if (UNLIKELY(!value.isObject()))
-        return JSValue::encode({});
-
-    JSC::VM& vm = globalObject->vm();
-    JSC::JSObject* object = value.getObject();
-    WTF::String propertyNameString = propertyName->tag == BunStringTag::Empty ? WTF::String(""_s) : propertyName->toWTFString(BunString::ZeroCopy);
-    auto identifier = JSC::Identifier::fromString(vm, propertyNameString);
-    auto property = JSC::PropertyName(identifier);
-
-    return JSC::JSValue::encode(object->getIfPropertyExists(globalObject, property));
+    return JSC::JSValue::encode(Bun::getIfPropertyExistsPrototypePollutionMitigation(vm, globalObject, object, property));
 }
 
 extern "C" JSC__JSValue JSC__JSValue__getOwn(JSC__JSValue JSValue0, JSC__JSGlobalObject* globalObject, BunString* propertyName)
@@ -3904,10 +3987,6 @@ bool JSC__JSValue__symbolKeyFor(JSC__JSValue symbolValue_, JSC__JSGlobalObject*
     return true;
 }
 
-bool JSC__JSValue__toBoolean(JSC__JSValue JSValue0)
-{
-    return JSC::JSValue::decode(JSValue0).asBoolean();
-}
 int32_t JSC__JSValue__toInt32(JSC__JSValue JSValue0)
 {
     return JSC::JSValue::decode(JSValue0).asInt32();
@@ -4212,7 +4291,7 @@ public:
             end = offset;
         }
 
-        if (end == start || start == WTF::notFound) {
+        if (start >= end || start == WTF::notFound) {
             return false;
         }
 
@@ -4394,9 +4473,7 @@ static void fromErrorInstance(ZigException* except, JSC::JSGlobalObject* global,
     if (except->code == SYNTAX_ERROR_CODE) {
         except->message = Bun::toStringRef(err->sanitizedMessageString(global));
     } else if (JSC::JSValue message = obj->getIfPropertyExists(global, vm.propertyNames->message)) {
-
         except->message = Bun::toStringRef(global, message);
-
     } else {
         except->message = Bun::toStringRef(err->sanitizedMessageString(global));
     }
@@ -4465,42 +4542,44 @@ static void fromErrorInstance(ZigException* except, JSC::JSGlobalObject* global,
         if (JSC::JSValue stackValue = obj->getIfPropertyExists(global, vm.propertyNames->stack)) {
             if (stackValue.isString()) {
                 WTF::String stack = stackValue.toWTFString(global);
+                if (!stack.isEmpty()) {
 
-                V8StackTraceIterator iterator(stack);
-                const uint8_t frame_count = except->stack.frames_len;
+                    V8StackTraceIterator iterator(stack);
+                    const uint8_t frame_count = except->stack.frames_len;
 
-                except->stack.frames_len = 0;
+                    except->stack.frames_len = 0;
 
-                iterator.forEachFrame([&](const V8StackTraceIterator::StackFrame& frame, bool& stop) -> void {
-                    ASSERT(except->stack.frames_len < frame_count);
-                    auto& current = except->stack.frames_ptr[except->stack.frames_len];
-                    current = {};
+                    iterator.forEachFrame([&](const V8StackTraceIterator::StackFrame& frame, bool& stop) -> void {
+                        ASSERT(except->stack.frames_len < frame_count);
+                        auto& current = except->stack.frames_ptr[except->stack.frames_len];
+                        current = {};
 
-                    String functionName = frame.functionName.toString();
-                    String sourceURL = frame.sourceURL.toString();
-                    current.function_name = Bun::toStringRef(functionName);
-                    current.source_url = Bun::toStringRef(sourceURL);
-                    current.position.line_zero_based = frame.lineNumber.zeroBasedInt();
-                    current.position.column_zero_based = frame.columnNumber.zeroBasedInt();
+                        String functionName = frame.functionName.toString();
+                        String sourceURL = frame.sourceURL.toString();
+                        current.function_name = Bun::toStringRef(functionName);
+                        current.source_url = Bun::toStringRef(sourceURL);
+                        current.position.line_zero_based = frame.lineNumber.zeroBasedInt();
+                        current.position.column_zero_based = frame.columnNumber.zeroBasedInt();
 
-                    current.remapped = true;
+                        current.remapped = true;
 
-                    if (frame.isConstructor) {
-                        current.code_type = ZigStackFrameCodeConstructor;
-                    } else if (frame.isGlobalCode) {
-                        current.code_type = ZigStackFrameCodeGlobal;
+                        if (frame.isConstructor) {
+                            current.code_type = ZigStackFrameCodeConstructor;
+                        } else if (frame.isGlobalCode) {
+                            current.code_type = ZigStackFrameCodeGlobal;
+                        }
+
+                        except->stack.frames_len += 1;
+
+                        stop = except->stack.frames_len >= frame_count;
+                    });
+
+                    if (except->stack.frames_len > 0) {
+                        getFromSourceURL = false;
+                        except->remapped = true;
+                    } else {
+                        except->stack.frames_len = frame_count;
                     }
-
-                    except->stack.frames_len += 1;
-
-                    stop = except->stack.frames_len >= frame_count;
-                });
-
-                if (except->stack.frames_len > 0) {
-                    getFromSourceURL = false;
-                    except->remapped = true;
-                } else {
-                    except->stack.frames_len = frame_count;
                 }
             }
         }
@@ -4643,7 +4722,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);
@@ -4657,7 +4735,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;
     }
@@ -4673,10 +4751,11 @@ void JSC__JSValue__getClassName(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1
     *arg2 = Zig::toZigString(view);
 }
 
-bool JSC__JSValue__getClassInfoName(JSValue value, BunString* out)
+bool JSC__JSValue__getClassInfoName(JSValue value, const uint8_t** outPtr, size_t* outLen)
 {
     if (auto info = value.classInfoOrNull()) {
-        *out = Bun::toString(info->className);
+        *outPtr = info->className.span8().data();
+        *outLen = info->className.span8().size();
         return true;
     }
     return false;
@@ -4787,7 +4866,7 @@ void JSC__JSValue__toZigException(JSC__JSValue jsException, JSC__JSGlobalObject*
 
     if (JSC::Exception* jscException = JSC::jsDynamicCast<JSC::Exception*>(value)) {
         if (JSC::ErrorInstance* error = JSC::jsDynamicCast<JSC::ErrorInstance*>(jscException->value())) {
-            fromErrorInstance(exception, global, error, &jscException->stack(), value);
+            fromErrorInstance(exception, global, error, &jscException->stack(), jscException->value());
             return;
         }
     }
@@ -5018,11 +5097,13 @@ enum class BuiltinNamesMap : uint8_t {
     name,
     message,
     error,
+    defaultKeyword,
+    encoding,
 };
 
-static const JSC::Identifier builtinNameMap(JSC::JSGlobalObject* globalObject, unsigned char name)
+static inline const JSC::Identifier builtinNameMap(JSC::VM& vm, unsigned char name)
 {
-    auto& vm = globalObject->vm();
+
     auto clientData = WebCore::clientData(vm);
     switch (static_cast<BuiltinNamesMap>(name)) {
     case BuiltinNamesMap::method: {
@@ -5076,6 +5157,12 @@ static const JSC::Identifier builtinNameMap(JSC::JSGlobalObject* globalObject, u
     case BuiltinNamesMap::error: {
         return vm.propertyNames->error;
     }
+    case BuiltinNamesMap::defaultKeyword: {
+        return vm.propertyNames->defaultKeyword;
+    }
+    case BuiltinNamesMap::encoding: {
+        return clientData->builtinNames().encodingPublicName();
+    }
     default: {
         ASSERT_NOT_REACHED();
         return Identifier();
@@ -5087,14 +5174,20 @@ JSC__JSValue JSC__JSValue__fastGetDirect_(JSC__JSValue JSValue0, JSC__JSGlobalOb
 {
     JSC::JSValue value = JSC::JSValue::decode(JSValue0);
     ASSERT(value.isCell());
-    return JSValue::encode(value.getObject()->getDirect(globalObject->vm(), PropertyName(builtinNameMap(globalObject, arg2))));
+    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());
-    return JSValue::encode(value.getObject()->getIfPropertyExists(globalObject, builtinNameMap(globalObject, arg2)));
+
+    JSC::JSObject* object = value.getObject();
+    ASSERT_WITH_MESSAGE(object, "fastGet() called on non-object. Check that the JSValue is an object before calling fastGet().");
+    auto& vm = globalObject->vm();
+    const auto property = JSC::PropertyName(builtinNameMap(vm, arg2));
+
+    return JSC::JSValue::encode(Bun::getIfPropertyExistsPrototypePollutionMitigation(vm, globalObject, object, property));
 }
 
 extern "C" JSC__JSValue JSC__JSValue__fastGetOwn(JSC__JSValue JSValue0, JSC__JSGlobalObject* globalObject, unsigned char arg2)
@@ -5102,7 +5195,7 @@ extern "C" JSC__JSValue JSC__JSValue__fastGetOwn(JSC__JSValue JSValue0, JSC__JSG
     JSC::JSValue value = JSC::JSValue::decode(JSValue0);
     ASSERT(value.isCell());
     PropertySlot slot = PropertySlot(value, PropertySlot::InternalMethodType::GetOwnProperty);
-    const Identifier name = builtinNameMap(globalObject, arg2);
+    const Identifier name = builtinNameMap(globalObject->vm(), arg2);
     auto* object = value.getObject();
     if (object->getOwnPropertySlot(object, globalObject, name, slot)) {
         return JSValue::encode(slot.getValue(globalObject, name));
@@ -5111,9 +5204,10 @@ extern "C" JSC__JSValue JSC__JSValue__fastGetOwn(JSC__JSValue JSValue0, JSC__JSG
     return JSValue::encode({});
 }
 
-bool JSC__JSValue__toBooleanSlow(JSC__JSValue JSValue0, JSC__JSGlobalObject* globalObject)
+bool JSC__JSValue__toBoolean(JSC__JSValue JSValue0)
 {
-    return JSValue::decode(JSValue0).toBoolean(globalObject);
+    // We count masquerades as undefined as true.
+    return JSValue::decode(JSValue0).pureToBoolean() != TriState::False;
 }
 
 template<bool nonIndexedOnly>
@@ -5162,7 +5256,7 @@ restart:
 
             if (prop == propertyNames->constructor
                 || prop == propertyNames->underscoreProto
-                || prop == propertyNames->toStringTagSymbol)
+                || prop == propertyNames->toStringTagSymbol || (objectToUse != object && prop == propertyNames->__esModule))
                 return true;
 
             if (builtinNames.bunNativePtrPrivateName() == prop)
@@ -5259,7 +5353,7 @@ restart:
 
                 if ((slot.attributes() & PropertyAttribute::DontEnum) != 0) {
                     if (property == propertyNames->underscoreProto
-                        || property == propertyNames->toStringTagSymbol)
+                        || property == propertyNames->toStringTagSymbol || property == propertyNames->__esModule)
                         continue;
                 }
 
@@ -5632,7 +5726,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)
@@ -5641,6 +5765,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))));
@@ -5891,3 +6022,84 @@ 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;
+}
+
+CPP_DECL void Bun__CallFrame__getCallerSrcLoc(JSC::CallFrame* callFrame, JSC::JSGlobalObject* globalObject, unsigned int* outSourceID, unsigned int* outLine, unsigned int* outColumn)
+{
+    JSC::VM& vm = globalObject->vm();
+    JSC::LineColumn lineColumn;
+    JSC::SourceID sourceID = 0;
+    String sourceURL;
+
+    ZigStackFrame remappedFrame = {};
+
+    JSC::StackVisitor::visit(callFrame, vm, [&](JSC::StackVisitor& visitor) -> WTF::IterationStatus {
+        if (Zig::isImplementationVisibilityPrivate(visitor))
+            return WTF::IterationStatus::Continue;
+
+        if (visitor->hasLineAndColumnInfo()) {
+            lineColumn = visitor->computeLineAndColumn();
+
+            String sourceURLForFrame = visitor->sourceURL();
+
+            // Sometimes, the sourceURL is empty.
+            // For example, pages in Next.js.
+            if (sourceURLForFrame.isEmpty()) {
+
+                // hasLineAndColumnInfo() checks codeBlock(), so this is safe to access here.
+                const auto& source = visitor->codeBlock()->source();
+
+                // source.isNull() is true when the SourceProvider is a null pointer.
+                if (!source.isNull()) {
+                    auto* provider = source.provider();
+                    // I'm not 100% sure we should show sourceURLDirective here.
+                    if (!provider->sourceURLDirective().isEmpty()) {
+                        sourceURLForFrame = provider->sourceURLDirective();
+                    } else if (!provider->sourceURL().isEmpty()) {
+                        sourceURLForFrame = provider->sourceURL();
+                    } else {
+                        const auto& origin = provider->sourceOrigin();
+                        if (!origin.isNull()) {
+                            sourceURLForFrame = origin.string();
+                        }
+                    }
+
+                    sourceID = provider->asID();
+                }
+            }
+
+            sourceURL = sourceURLForFrame;
+
+            return WTF::IterationStatus::Done;
+        }
+
+        return WTF::IterationStatus::Continue;
+    });
+
+    if (!sourceURL.isEmpty() and lineColumn.line > 0) {
+        OrdinalNumber originalLine = OrdinalNumber::fromOneBasedInt(lineColumn.line);
+        OrdinalNumber originalColumn = OrdinalNumber::fromOneBasedInt(lineColumn.column);
+
+        remappedFrame.position.line_zero_based = originalLine.zeroBasedInt();
+        remappedFrame.position.column_zero_based = originalColumn.zeroBasedInt();
+        remappedFrame.source_url = Bun::toStringRef(sourceURL);
+
+        Bun__remapStackFramePositions(globalObject, &remappedFrame, 1);
+
+        sourceURL = remappedFrame.source_url.toWTFString();
+        lineColumn.line = OrdinalNumber::fromZeroBasedInt(remappedFrame.position.line_zero_based).oneBasedInt();
+        lineColumn.column = OrdinalNumber::fromZeroBasedInt(remappedFrame.position.column_zero_based).oneBasedInt();
+    }
+
+    *outSourceID = sourceID;
+    *outLine = lineColumn.line;
+    *outColumn = lineColumn.column;
+}
diff --git a/src/bun.js/bindings/bindings.zig b/src/bun.js/bindings/bindings.zig
index 2e9d427843..5034ae9806 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,86 @@ 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 putRecord(this: *JSObject, global: *JSGlobalObject, key: *ZigString, values: []ZigString) void {
+        return cppFn("putRecord", .{ this, global, key, values.ptr, values.len });
+    }
+};
+
+pub const CachedBytecode = opaque {
+    extern fn generateCachedModuleByteCodeFromSourceCode(sourceProviderURL: *bun.String, input_code: [*]const u8, inputSourceCodeSize: usize, outputByteCode: *?[*]u8, outputByteCodeSize: *usize, cached_bytecode: *?*CachedBytecode) bool;
+    extern fn generateCachedCommonJSProgramByteCodeFromSourceCode(sourceProviderURL: *bun.String, input_code: [*]const u8, inputSourceCodeSize: usize, outputByteCode: *?[*]u8, outputByteCodeSize: *usize, cached_bytecode: *?*CachedBytecode) bool;
+
+    pub fn generateForESM(sourceProviderURL: *bun.String, input: []const u8) ?struct { []const u8, *CachedBytecode } {
+        var this: ?*CachedBytecode = null;
+
+        var input_code_size: usize = 0;
+        var input_code_ptr: ?[*]u8 = null;
+        if (generateCachedModuleByteCodeFromSourceCode(sourceProviderURL, input.ptr, input.len, &input_code_ptr, &input_code_size, &this)) {
+            return .{ input_code_ptr.?[0..input_code_size], this.? };
+        }
+
+        return null;
     }
 
-    pub fn getDirect(this: *JSObject, globalThis: *JSGlobalObject, str: *const ZigString) JSValue {
-        return cppFn("getDirect", .{
-            this,
-            globalThis,
-            str,
-        });
+    pub fn generateForCJS(sourceProviderURL: *bun.String, input: []const u8) ?struct { []const u8, *CachedBytecode } {
+        var this: ?*CachedBytecode = null;
+        var input_code_size: usize = 0;
+        var input_code_ptr: ?[*]u8 = null;
+        if (generateCachedCommonJSProgramByteCodeFromSourceCode(sourceProviderURL, input.ptr, input.len, &input_code_ptr, &input_code_size, &this)) {
+            return .{ input_code_ptr.?[0..input_code_size], this.? };
+        }
+
+        return null;
     }
 
-    pub const Extern = [_][]const u8{
-        "putRecord",
-        "getArrayLength",
-        "getIndex",
-        "putAtIndex",
-        "getDirect",
+    extern "C" fn CachedBytecode__deref(this: *CachedBytecode) void;
+    pub fn deref(this: *CachedBytecode) void {
+        return CachedBytecode__deref(this);
+    }
+
+    pub fn generate(format: bun.options.Format, input: []const u8, source_provider_url: *bun.String) ?struct { []const u8, *CachedBytecode } {
+        return switch (format) {
+            .esm => generateForESM(source_provider_url, input),
+            .cjs => generateForCJS(source_provider_url, input),
+            else => null,
+        };
+    }
+
+    pub const VTable = &std.mem.Allocator.VTable{
+        .alloc = struct {
+            pub fn alloc(ctx: *anyopaque, len: usize, ptr_align: u8, ret_addr: usize) ?[*]u8 {
+                _ = ctx; // autofix
+                _ = len; // autofix
+                _ = ptr_align; // autofix
+                _ = ret_addr; // autofix
+                @panic("Unexpectedly called CachedBytecode.alloc");
+            }
+        }.alloc,
+        .resize = struct {
+            pub fn resize(ctx: *anyopaque, buf: []u8, buf_align: u8, new_len: usize, ret_addr: usize) bool {
+                _ = ctx; // autofix
+                _ = buf; // autofix
+                _ = buf_align; // autofix
+                _ = new_len; // autofix
+                _ = ret_addr; // autofix
+                return false;
+            }
+        }.resize,
+        .free = struct {
+            pub fn free(ctx: *anyopaque, buf: []u8, buf_align: u8, _: usize) void {
+                _ = buf; // autofix
+                _ = buf_align; // autofix
+                CachedBytecode__deref(@ptrCast(ctx));
+            }
+        }.free,
     };
+
+    pub fn allocator(this: *CachedBytecode) std.mem.Allocator {
+        return .{
+            .ptr = this,
+            .vtable = VTable,
+        };
+    }
 };
 
 /// Prefer using bun.String instead of ZigString in new code.
@@ -131,9 +181,13 @@ pub const ZigString = extern struct {
     }
 
     pub fn encode(this: ZigString, encoding: JSC.Node.Encoding) []u8 {
+        return this.encodeWithAllocator(bun.default_allocator, encoding);
+    }
+
+    pub fn encodeWithAllocator(this: ZigString, allocator: std.mem.Allocator, encoding: JSC.Node.Encoding) []u8 {
         return switch (this.as()) {
             inline else => |repr| switch (encoding) {
-                inline else => |enc| JSC.WebCore.Encoder.constructFrom(std.meta.Child(@TypeOf(repr)), repr, enc),
+                inline else => |enc| JSC.WebCore.Encoder.constructFrom(std.meta.Child(@TypeOf(repr)), repr, allocator, enc),
             },
         };
     }
@@ -682,8 +736,8 @@ pub const ZigString = extern struct {
     pub fn toExternalU16(ptr: [*]const u16, len: usize, global: *JSGlobalObject) JSValue {
         if (len > String.max_length()) {
             bun.default_allocator.free(ptr[0..len]);
-            global.ERR_STRING_TOO_LONG("Cannot create a string longer than 2^32-1 characters", .{}).throw();
-            return JSValue.zero;
+            global.ERR_STRING_TOO_LONG("Cannot create a string longer than 2^32-1 characters", .{}).throw() catch {}; // TODO: propagate?
+            return .zero;
         }
         return shim.cppFn("toExternalU16", .{ ptr, len, global });
     }
@@ -868,7 +922,7 @@ pub const ZigString = extern struct {
         this.assertGlobal();
         if (this.len > String.max_length()) {
             bun.default_allocator.free(@constCast(this.byteSlice()));
-            global.ERR_STRING_TOO_LONG("Cannot create a string longer than 2^32-1 characters", .{}).throw();
+            global.ERR_STRING_TOO_LONG("Cannot create a string longer than 2^32-1 characters", .{}).throw() catch {}; // TODO: propagate?
             return .zero;
         }
         return shim.cppFn("toExternalValue", .{ this, global });
@@ -890,7 +944,7 @@ pub const ZigString = extern struct {
     ) JSValue {
         if (this.len > String.max_length()) {
             callback(ctx, @constCast(@ptrCast(this.byteSlice().ptr)), this.len);
-            global.ERR_STRING_TOO_LONG("Cannot create a string longer than 2^32-1 characters", .{}).throw();
+            global.ERR_STRING_TOO_LONG("Cannot create a string longer than 2^32-1 characters", .{}).throw() catch {}; // TODO: propagate?
             return .zero;
         }
 
@@ -1046,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,
         });
@@ -1253,7 +1305,7 @@ pub const FetchHeaders = opaque {
     pub fn createFromPicoHeaders(
         pico_headers: anytype,
     ) *FetchHeaders {
-        const out = PicoHeaders{ .ptr = pico_headers.ptr, .len = pico_headers.len };
+        const out = PicoHeaders{ .ptr = pico_headers.list.ptr, .len = pico_headers.list.len };
         const result = shim.cppFn("createFromPicoHeaders_", .{
             &out,
         });
@@ -1764,6 +1816,10 @@ pub const JSString = extern struct {
     pub const name = "JSC::JSString";
     pub const namespace = "JSC";
 
+    pub fn toJS(str: *JSString) JSValue {
+        return JSValue.fromCell(str);
+    }
+
     pub fn toObject(this: *JSString, global: *JSGlobalObject) ?*JSObject {
         return shim.cppFn("toObject", .{ this, global });
     }
@@ -2339,8 +2395,8 @@ pub const JSPromise = extern struct {
         const Wrapper = struct {
             args: Args,
 
-            pub fn call(this: *@This(), _: *JSC.JSGlobalObject) JSC.JSValue {
-                return @call(.auto, Fn, this.args);
+            pub fn call(this: *@This(), g: *JSC.JSGlobalObject) JSC.JSValue {
+                return toJSHostValue(g, @call(.auto, Fn, this.args));
             }
         };
 
@@ -2349,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);
@@ -2795,8 +2851,8 @@ pub const AnyPromise = union(enum) {
         const Wrapper = struct {
             args: Args,
 
-            pub fn call(wrap_: *@This(), _: *JSC.JSGlobalObject) JSC.JSValue {
-                return @call(.auto, Fn, wrap_.args);
+            pub fn call(wrap_: *@This(), global: *JSC.JSGlobalObject) JSC.JSValue {
+                return toJSHostValue(global, @call(.auto, Fn, wrap_.args));
             }
         };
 
@@ -2853,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 {
@@ -2863,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,
@@ -2897,14 +2953,20 @@ pub const JSGlobalObject = opaque {
     }
 
     extern fn JSGlobalObject__throwOutOfMemoryError(this: *JSGlobalObject) void;
-    pub fn throwOutOfMemory(this: *JSGlobalObject) void {
+    pub fn throwOutOfMemory(this: *JSGlobalObject) bun.JSError {
         JSGlobalObject__throwOutOfMemoryError(this);
+        return error.JSError;
     }
 
-    pub fn throwTODO(this: *JSGlobalObject, msg: []const u8) void {
+    pub fn throwOutOfMemoryValue(this: *JSGlobalObject) JSValue {
+        JSGlobalObject__throwOutOfMemoryError(this);
+        return .zero;
+    }
+
+    pub fn throwTODO(this: *JSGlobalObject, msg: []const u8) bun.JSError {
         const err = this.createErrorInstance("{s}", .{msg});
         err.put(this, ZigString.static("name"), bun.String.static("TODOError").toJS(this));
-        this.throwValue(err);
+        return this.throwValue(err);
     }
 
     pub const throwTerminationException = JSGlobalObject__throwTerminationException;
@@ -2915,16 +2977,22 @@ pub const JSGlobalObject = opaque {
     }
 
     pub inline fn toJSValue(globalThis: *JSGlobalObject) JSValue {
-        return @enumFromInt(@as(JSValue.Type, @bitCast(@intFromPtr(globalThis))));
+        return @enumFromInt(@intFromPtr(globalThis));
     }
 
-    pub fn throwInvalidArguments(
-        this: *JSGlobalObject,
-        comptime fmt: [:0]const u8,
-        args: anytype,
-    ) void {
+    pub fn throwInvalidArguments(this: *JSGlobalObject, comptime fmt: [:0]const u8, args: anytype) bun.JSError {
         const err = JSC.toInvalidArguments(fmt, args, this);
-        this.vm().throwError(this, err);
+        return this.throwValue(err);
+    }
+
+    pub inline fn throwMissingArgumentsValue(this: *JSGlobalObject, comptime arg_names: []const []const u8) bun.JSError {
+        return switch (arg_names.len) {
+            0 => @compileError("requires at least one argument"),
+            1 => this.ERR_MISSING_ARGS("The \"{s}\" argument must be specified", .{arg_names[0]}).throw(),
+            2 => this.ERR_MISSING_ARGS("The \"{s}\" and \"{s}\" arguments must be specified", .{ arg_names[0], arg_names[1] }).throw(),
+            3 => this.ERR_MISSING_ARGS("The \"{s}\", \"{s}\", and \"{s}\" arguments must be specified", .{ arg_names[0], arg_names[1], arg_names[2] }).throw(),
+            else => @compileError("implement this message"),
+        };
     }
 
     pub fn createInvalidArgumentType(
@@ -2945,8 +3013,8 @@ pub const JSGlobalObject = opaque {
         comptime name_: []const u8,
         comptime field: []const u8,
         comptime typename: []const u8,
-    ) void {
-        this.throwValue(this.createInvalidArgumentType(name_, field, typename));
+    ) bun.JSError {
+        return this.throwValue(this.createInvalidArgumentType(name_, field, typename));
     }
 
     pub fn throwInvalidArgumentTypeValue(
@@ -2954,20 +3022,18 @@ pub const JSGlobalObject = opaque {
         argname: []const u8,
         typename: []const u8,
         value: JSValue,
-    ) JSValue {
-        const ty_str = value.jsTypeString(this).toSlice(this, bun.default_allocator);
-        defer ty_str.deinit();
-        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;
+    ) bun.JSError {
+        var formatter = JSC.ConsoleObject.Formatter{ .globalThis = this };
+        return this.ERR_INVALID_ARG_TYPE("The \"{s}\" argument must be of type {s}. Received {}", .{ argname, typename, value.toFmt(&formatter) }).throw();
     }
+
     pub fn throwInvalidArgumentRangeValue(
         this: *JSGlobalObject,
         argname: []const u8,
         typename: []const u8,
         value: i64,
-    ) JSValue {
-        this.ERR_OUT_OF_RANGE("The \"{s}\" is out of range. {s}. Received {}", .{ argname, typename, value }).throw();
-        return .zero;
+    ) bun.JSError {
+        return this.ERR_OUT_OF_RANGE("The \"{s}\" is out of range. {s}. Received {}", .{ argname, typename, value }).throw();
     }
 
     pub fn throwInvalidPropertyTypeValue(
@@ -2975,11 +3041,10 @@ pub const JSGlobalObject = opaque {
         field: []const u8,
         typename: []const u8,
         value: JSValue,
-    ) JSValue {
+    ) bun.JSError {
         const ty_str = value.jsTypeString(this).toSlice(this, bun.default_allocator);
         defer ty_str.deinit();
-        this.ERR_INVALID_ARG_TYPE("The \"{s}\" property must be of type {s}. Received {s}", .{ field, typename, ty_str.slice() }).throw();
-        return .zero;
+        return this.ERR_INVALID_ARG_TYPE("The \"{s}\" property must be of type {s}. Received {s}", .{ field, typename, ty_str.slice() }).throw();
     }
 
     pub fn createNotEnoughArguments(
@@ -2996,8 +3061,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.throwValue(this.createNotEnoughArguments(name_, expected, got));
     }
 
     extern fn JSC__JSGlobalObject__reload(JSC__JSGlobalObject__ptr: *JSGlobalObject) void;
@@ -3048,7 +3113,7 @@ pub const JSGlobalObject = opaque {
                 return ZigString.static(fmt).toErrorInstance(this);
 
             // Ensure we clone it.
-            var str = ZigString.initUTF8(buf.toOwnedSliceLeaky());
+            var str = ZigString.initUTF8(buf.slice());
 
             return str.toErrorInstance(this);
         } else {
@@ -3067,7 +3132,7 @@ pub const JSGlobalObject = opaque {
             defer buf.deinit();
             var writer = buf.writer();
             writer.print(fmt, args) catch return ZigString.static(fmt).toErrorInstance(this);
-            var str = ZigString.fromUTF8(buf.toOwnedSliceLeaky());
+            var str = ZigString.fromUTF8(buf.slice());
             return str.toTypeErrorInstance(this);
         } else {
             return ZigString.static(fmt).toTypeErrorInstance(this);
@@ -3081,7 +3146,7 @@ pub const JSGlobalObject = opaque {
             defer buf.deinit();
             var writer = buf.writer();
             writer.print(fmt, args) catch return ZigString.static(fmt).toErrorInstance(this);
-            var str = ZigString.fromUTF8(buf.toOwnedSliceLeaky());
+            var str = ZigString.fromUTF8(buf.slice());
             return str.toSyntaxErrorInstance(this);
         } else {
             return ZigString.static(fmt).toSyntaxErrorInstance(this);
@@ -3095,7 +3160,7 @@ pub const JSGlobalObject = opaque {
             defer buf.deinit();
             var writer = buf.writer();
             writer.print(fmt, args) catch return ZigString.static(fmt).toErrorInstance(this);
-            var str = ZigString.fromUTF8(buf.toOwnedSliceLeaky());
+            var str = ZigString.fromUTF8(buf.slice());
             return str.toRangeErrorInstance(this);
         } else {
             return ZigString.static(fmt).toRangeErrorInstance(this);
@@ -3125,28 +3190,20 @@ pub const JSGlobalObject = opaque {
         return err;
     }
 
-    pub fn throw(
-        this: *JSGlobalObject,
-        comptime fmt: [:0]const u8,
-        args: anytype,
-    ) void {
+    pub fn throw(this: *JSGlobalObject, comptime fmt: [:0]const u8, args: anytype) JSError {
         const instance = this.createErrorInstance(fmt, args);
-        if (instance != .zero)
-            this.vm().throwError(this, instance);
+        bun.assert(instance != .zero);
+        return this.throwValue(instance);
     }
 
-    pub fn throwPretty(
-        this: *JSGlobalObject,
-        comptime fmt: [:0]const u8,
-        args: anytype,
-    ) void {
+    pub fn throwPretty(this: *JSGlobalObject, comptime fmt: [:0]const u8, args: anytype) bun.JSError {
         const instance = switch (Output.enable_ansi_colors) {
             inline else => |enabled| this.createErrorInstance(Output.prettyFmt(fmt, enabled), args),
         };
-
-        if (instance != .zero)
-            this.vm().throwError(this, instance);
+        bun.assert(instance != .zero);
+        return this.throwValue(instance);
     }
+
     extern fn JSC__JSGlobalObject__queueMicrotaskCallback(*JSGlobalObject, *anyopaque, Function: *const (fn (*anyopaque) callconv(.C) void)) void;
     pub fn queueMicrotaskCallback(
         this: *JSGlobalObject,
@@ -3165,11 +3222,7 @@ pub const JSGlobalObject = opaque {
         JSC__JSGlobalObject__queueMicrotaskCallback(this, ctx_val, &Wrapper.call);
     }
 
-    pub fn queueMicrotask(
-        this: *JSGlobalObject,
-        function: JSValue,
-        args: []const JSC.JSValue,
-    ) void {
+    pub fn queueMicrotask(this: *JSGlobalObject, function: JSValue, args: []const JSC.JSValue) void {
         this.queueMicrotaskJob(
             function,
             if (args.len > 0) args[0] else .zero,
@@ -3178,50 +3231,34 @@ pub const JSGlobalObject = opaque {
     }
 
     extern fn JSC__JSGlobalObject__queueMicrotaskJob(JSC__JSGlobalObject__ptr: *JSGlobalObject, JSValue, JSValue, JSValue) void;
-    pub fn queueMicrotaskJob(
-        this: *JSGlobalObject,
-        function: JSValue,
-        first: JSValue,
-        second: JSValue,
-    ) void {
+    pub fn queueMicrotaskJob(this: *JSGlobalObject, function: JSValue, first: JSValue, second: JSValue) void {
         JSC__JSGlobalObject__queueMicrotaskJob(this, function, first, second);
     }
 
-    pub fn throwValue(
-        this: *JSGlobalObject,
-        value: JSC.JSValue,
-    ) void {
+    pub fn throwValue(this: *JSGlobalObject, value: JSC.JSValue) JSError {
         this.vm().throwError(this, value);
+        return error.JSError;
     }
 
-    // eventually merge this with throwValue, but that's a big diff
-    pub fn throwValueRet(
-        this: *JSGlobalObject,
-        value: JSC.JSValue,
-    ) JSValue {
-        this.vm().throwError(this, value);
-        return .zero;
-    }
+    pub fn throwError(this: *JSGlobalObject, err: anyerror, comptime fmt: [:0]const u8) bun.JSError {
+        if (err == error.OutOfMemory) {
+            return this.throwOutOfMemory();
+        }
 
-    pub fn throwError(
-        this: *JSGlobalObject,
-        err: anyerror,
-        comptime fmt: [:0]const u8,
-    ) void {
-        var str = ZigString.init(std.fmt.allocPrint(this.bunVM().allocator, "{s} " ++ fmt, .{@errorName(err)}) catch return);
-        str.markUTF8();
+        // If we're throwing JSError, that means either:
+        // - We're throwing an exception while another exception is already active
+        // - We're incorrectly returning JSError from a function that did not throw.
+        bun.debugAssert(err != error.JSError);
+
+        // Avoid tiny extra allocation
+        var stack = std.heap.stackFallback(128, bun.default_allocator);
+        const allocator_ = stack.get();
+        const buffer = try std.fmt.allocPrint(allocator_, comptime "{s} " ++ fmt, .{@errorName(err)});
+        defer allocator_.free(buffer);
+        const str = ZigString.initUTF8(buffer);
         const err_value = str.toErrorInstance(this);
         this.vm().throwError(this, err_value);
-        this.bunVM().allocator.free(ZigString.untagged(str._unsafe_ptr_do_not_use)[0..str.len]);
-    }
-
-    pub fn handleError(
-        this: *JSGlobalObject,
-        err: anyerror,
-        comptime fmt: [:0]const u8,
-    ) JSValue {
-        this.throwError(err, fmt);
-        return JSValue.jsUndefined();
+        return error.JSError;
     }
 
     pub fn ref(this: *JSGlobalObject) C_API.JSContextRef {
@@ -3229,15 +3266,22 @@ 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);
     }
 
+    extern fn JSC__JSGlobalObject__createAggregateErrorWithArray(*JSGlobalObject, JSValue, bun.String, JSValue) JSValue;
+    pub fn createAggregateErrorWithArray(
+        globalObject: *JSGlobalObject,
+        message: bun.String,
+        error_array: JSValue,
+    ) JSValue {
+        if (bun.Environment.allow_assert)
+            bun.assert(error_array.isArray());
+        return JSC__JSGlobalObject__createAggregateErrorWithArray(globalObject, error_array, message, .undefined);
+    }
+
     extern fn JSC__JSGlobalObject__generateHeapSnapshot(*JSGlobalObject) JSValue;
     pub fn generateHeapSnapshot(this: *JSGlobalObject) JSValue {
         return JSC__JSGlobalObject__generateHeapSnapshot(this);
@@ -3256,14 +3300,11 @@ pub const JSGlobalObject = opaque {
     pub fn takeException(this: *JSGlobalObject, proof: bun.JSError) JSValue {
         switch (proof) {
             error.JSError => {},
+            error.OutOfMemory => this.throwOutOfMemory() catch {},
         }
 
-        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.");
         };
     }
 
@@ -3304,7 +3345,6 @@ pub const JSGlobalObject = opaque {
             //   make clean-jsc-bindings
             //   make bindings -j10
             const assertion = this.bunVMUnsafe() == @as(*anyopaque, @ptrCast(JSC.VirtualMachine.get()));
-            if (!assertion) @breakpoint();
             bun.assert(assertion);
         }
         return @as(*JSC.VirtualMachine, @ptrCast(@alignCast(this.bunVMUnsafe())));
@@ -3365,31 +3405,20 @@ pub const JSGlobalObject = opaque {
             allowFunction: bool = false,
             nullable: bool = false,
         },
-    ) bool {
+    ) bun.JSError!void {
         if ((!opts.nullable and value.isNull()) or
             (!opts.allowArray and value.isArray()) or
             (!value.isObject() and (!opts.allowFunction or !value.isFunction())))
         {
-            this.throwValue(this.ERR_INVALID_ARG_TYPE_static(
-                ZigString.static(arg_name),
-                ZigString.static("object"),
-                value,
-            ));
-            return false;
+            return this.throwInvalidArgumentTypeValue(arg_name, "object", value);
         }
-        return true;
     }
 
-    extern fn Bun__ERR_INVALID_ARG_TYPE_static(*JSGlobalObject, *const ZigString, *const ZigString, JSValue) JSValue;
-    /// Caller asserts 'arg_name' and 'etype' are utf-8 literals.
-    pub fn ERR_INVALID_ARG_TYPE_static(this: *JSGlobalObject, arg_name: *const ZigString, etype: *const ZigString, atype: JSValue) JSValue {
-        return Bun__ERR_INVALID_ARG_TYPE_static(this, arg_name, etype, atype);
-    }
-
-    pub fn throwRangeError(this: *JSGlobalObject, value: anytype, options: bun.fmt.OutOfRangeOptions) void {
+    pub fn throwRangeError(this: *JSGlobalObject, value: anytype, options: bun.fmt.OutOfRangeOptions) bun.JSError {
+        // TODO:
         // This works around a Zig compiler bug
         // when using this.ERR_OUT_OF_RANGE.
-        JSC.Error.ERR_OUT_OF_RANGE.throw(this, "{}", .{bun.fmt.outOfRange(value, options)});
+        return JSC.Error.ERR_OUT_OF_RANGE.throw(this, "{}", .{bun.fmt.outOfRange(value, options)});
     }
 
     pub const IntegerRange = struct {
@@ -3399,7 +3428,7 @@ pub const JSGlobalObject = opaque {
         always_allow_zero: bool = false,
     };
 
-    pub fn validateIntegerRange(this: *JSGlobalObject, value: JSValue, comptime T: type, default: T, comptime range: IntegerRange) ?T {
+    pub fn validateIntegerRange(this: *JSGlobalObject, value: JSValue, comptime T: type, default: T, comptime range: IntegerRange) bun.JSError!T {
         if (value == .undefined or value == .zero) {
             return default;
         }
@@ -3427,15 +3456,13 @@ pub const JSGlobalObject = opaque {
                 return 0;
             }
             if (int < min_t or int > max_t) {
-                this.throwRangeError(int, .{ .field_name = field_name, .min = min, .max = max });
-                return null;
+                return this.throwRangeError(int, .{ .field_name = field_name, .min = min, .max = max });
             }
             return @intCast(int);
         }
 
         if (!value.isNumber()) {
-            _ = this.throwInvalidPropertyTypeValue(field_name, "number", value);
-            return null;
+            return this.throwInvalidPropertyTypeValue(field_name, "number", value);
         }
         const f64_val = value.asNumber();
         if (always_allow_zero and f64_val == 0) {
@@ -3447,12 +3474,10 @@ pub const JSGlobalObject = opaque {
             return default;
         }
         if (@floor(f64_val) != f64_val) {
-            _ = this.throwInvalidPropertyTypeValue(field_name, "integer", value);
-            return null;
+            return this.throwInvalidPropertyTypeValue(field_name, "integer", value);
         }
         if (f64_val < min_t or f64_val > max_t) {
-            this.throwRangeError(f64_val, .{ .field_name = comptime field_name, .min = min, .max = max });
-            return null;
+            return this.throwRangeError(f64_val, .{ .field_name = comptime field_name, .min = min, .max = max });
         }
 
         return @intFromFloat(f64_val);
@@ -3466,9 +3491,25 @@ pub const JSGlobalObject = opaque {
         return default;
     }
 
-    extern fn Bun__ERR_MISSING_ARGS_static(*JSGlobalObject, *const ZigString, ?*const ZigString, ?*const ZigString) JSValue;
-    pub fn ERR_MISSING_ARGS_static(this: *JSGlobalObject, arg1: *const ZigString, arg2: ?*const ZigString, arg3: ?*const ZigString) JSValue {
-        return Bun__ERR_MISSING_ARGS_static(this, arg1, arg2, arg3);
+    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, null);
     }
 
     pub usingnamespace @import("ErrorCode").JSGlobalObjectExtensions;
@@ -3484,7 +3525,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,
@@ -3500,6 +3541,7 @@ pub const JSArrayIterator = struct {
         };
     }
 
+    // TODO: this can throw
     pub fn next(this: *JSArrayIterator) ?JSValue {
         if (!(this.i < this.len)) {
             return null;
@@ -3548,7 +3590,7 @@ pub const JSMap = opaque {
     }
 
     pub fn fromJS(value: JSValue) ?*JSMap {
-        if (value.jsTypeLoose() == .JSMap) {
+        if (value.jsTypeLoose() == .Map) {
             return bun.cast(*JSMap, value.asEncoded().asPtr.?);
         }
 
@@ -3564,17 +3606,43 @@ pub const JSMap = opaque {
     };
 };
 
+// TODO: this should not need to be `pub`
 pub const JSValueReprInt = i64;
 
-pub const JSValue = enum(JSValueReprInt) {
-    zero = 0,
+/// ABI-compatible with EncodedJSValue
+/// In the future, this type will exclude `zero`, encoding it as `error.JSError` instead.
+pub const JSValue = enum(i64) {
     undefined = 0xa,
     null = 0x2,
     true = FFI.TrueI64,
     false = 0x6,
+
+    /// Typically means an exception was thrown.
+    zero = 0,
+
+    /// JSValue::ValueDeleted
+    ///
+    /// 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.
+    property_does_not_exist_on_object = 0x4,
     _,
 
-    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;
@@ -3648,31 +3716,32 @@ pub const JSValue = enum(JSValueReprInt) {
         RegExpObject = 60,
         JSDate = 61,
         ProxyObject = 62,
-        JSGenerator = 63,
-        JSAsyncGenerator = 64,
+        Generator = 63,
+        AsyncGenerator = 64,
         JSArrayIterator = 65,
-        JSIterator = 66,
-        JSMapIterator = 67,
-        JSSetIterator = 68,
-        JSStringIterator = 69,
-        JSWrapForValidIterator = 70,
-        JSRegExpStringIterator = 71,
-        JSPromise = 72,
-        JSMap = 73,
-        JSSet = 74,
-        JSWeakMap = 75,
-        JSWeakSet = 76,
-        WebAssemblyModule = 77,
-        WebAssemblyInstance = 78,
-        WebAssemblyGCObject = 79,
-        StringObject = 80,
-        DerivedStringObject = 81,
-        InternalFieldTuple = 82,
+        Iterator = 66,
+        IteratorHelper = 67,
+        MapIterator = 68,
+        SetIterator = 69,
+        StringIterator = 70,
+        WrapForValidIterator = 71,
+        RegExpStringIterator = 72,
+        AsyncFromSyncIterator = 73,
+        JSPromise = 74,
+        Map = 75,
+        Set = 76,
+        WeakMap = 77,
+        WeakSet = 78,
+        WebAssemblyModule = 79,
+        WebAssemblyInstance = 80,
+        WebAssemblyGCObject = 81,
+        StringObject = 82,
+        DerivedStringObject = 83,
+        InternalFieldTuple = 84,
 
         MaxJS = 0b11111111,
         Event = 0b11101111,
         DOMWrapper = 0b11101110,
-        Blob = 0b11111100,
 
         /// This means that we don't have Zig bindings for the type yet, but it
         /// implements .toJSON()
@@ -3705,18 +3774,20 @@ pub const JSValue = enum(JSValueReprInt) {
                 .Int8Array,
                 .InternalFunction,
                 .JSArrayIterator,
-                .JSAsyncGenerator,
+                .AsyncGenerator,
                 .JSDate,
                 .JSFunction,
-                .JSGenerator,
-                .JSMap,
-                .JSMapIterator,
+                .Generator,
+                .Map,
+                .MapIterator,
                 .JSPromise,
-                .JSSet,
-                .JSSetIterator,
-                .JSStringIterator,
-                .JSWeakMap,
-                .JSWeakSet,
+                .Set,
+                .SetIterator,
+                .IteratorHelper,
+                .Iterator,
+                .StringIterator,
+                .WeakMap,
+                .WeakSet,
                 .ModuleNamespaceObject,
                 .NumberObject,
                 .Object,
@@ -3866,14 +3937,14 @@ pub const JSValue = enum(JSValueReprInt) {
 
         pub inline fn isSet(this: JSType) bool {
             return switch (this) {
-                .JSSet, .JSWeakSet => true,
+                .Set, .WeakSet => true,
                 else => false,
             };
         }
 
         pub inline fn isMap(this: JSType) bool {
             return switch (this) {
-                .JSMap, .JSWeakMap => true,
+                .Map, .WeakMap => true,
                 else => false,
             };
         }
@@ -3905,6 +3976,13 @@ pub const JSValue = enum(JSValueReprInt) {
                 else => false,
             };
         }
+
+        pub inline fn isArguments(this: JSType) bool {
+            return switch (this) {
+                .DirectArguments, .ClonedArguments, .ScopedArguments => true,
+                else => false,
+            };
+        }
     };
 
     pub inline fn cast(ptr: anytype) JSValue {
@@ -3928,6 +4006,12 @@ pub const JSValue = enum(JSValueReprInt) {
         return JSC__JSValue__getDirectIndex(this, globalThis, i);
     }
 
+    pub fn isFalsey(this: JSValue) bool {
+        return !this.toBoolean();
+    }
+
+    pub const isTruthy = toBoolean;
+
     const PropertyIteratorFn = *const fn (
         globalObject_: *JSGlobalObject,
         ctx_ptr: ?*anyopaque,
@@ -3978,7 +4062,7 @@ pub const JSValue = enum(JSValueReprInt) {
     pub fn coerce(this: JSValue, comptime T: type, globalThis: *JSC.JSGlobalObject) T {
         return switch (T) {
             ZigString => this.getZigString(globalThis),
-            bool => this.toBooleanSlow(globalThis),
+            bool => this.toBoolean(),
             f64 => {
                 if (this.isDouble()) {
                     return this.asDouble();
@@ -4047,7 +4131,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());
@@ -4058,26 +4142,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});
     }
 
@@ -4116,7 +4197,7 @@ pub const JSValue = enum(JSValueReprInt) {
         return cppFn("putRecord", .{ value, global, key, values_array, values_len });
     }
 
-    fn putZigString(value: JSValue, global: *JSGlobalObject, key: *const ZigString, result: JSC.JSValue) void {
+    pub fn putZigString(value: JSValue, global: *JSGlobalObject, key: *const ZigString, result: JSC.JSValue) void {
         @import("./headers.zig").JSC__JSValue__put(value, global, key, result);
     }
 
@@ -4225,8 +4306,6 @@ pub const JSValue = enum(JSValueReprInt) {
 
             return ZigType.fromJS(value);
         }
-
-        return JSC.GetJSPrivateData(ZigType, value.asObjectRef());
     }
 
     extern fn JSC__JSValue__dateInstanceFromNullTerminatedString(*JSGlobalObject, [*:0]const u8) JSValue;
@@ -4235,6 +4314,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());
@@ -4249,13 +4334,6 @@ pub const JSValue = enum(JSValueReprInt) {
         return this.jsType() == .JSDate;
     }
 
-    pub fn asCheckLoaded(value: JSValue, comptime ZigType: type) ?*ZigType {
-        if (!ZigType.Class.isLoaded() or value.isUndefinedOrNull())
-            return null;
-
-        return JSC.GetJSPrivateData(ZigType, value.asObjectRef());
-    }
-
     pub fn protect(this: JSValue) void {
         if (this.isEmptyOrUndefinedOrNull() or this.isNumber()) return;
         JSC.C.JSValueProtect(JSC.VirtualMachine.get().global, this.asObjectRef());
@@ -4321,40 +4399,6 @@ pub const JSValue = enum(JSValueReprInt) {
         );
 
         try buffered_writer.flush();
-
-        const count: usize = brk: {
-            var total: usize = 0;
-            var remain = out.list.items;
-            while (strings.indexOfChar(remain, '`')) |i| {
-                total += 1;
-                remain = remain[i + 1 ..];
-            }
-            break :brk total;
-        };
-
-        if (count > 0) {
-            var result = try out.allocator.alloc(u8, count + out.list.items.len);
-            var input = out.list.items;
-
-            var input_i: usize = 0;
-            var result_i: usize = 0;
-            while (strings.indexOfChar(input[input_i..], '`')) |i| {
-                bun.copy(u8, result[result_i..], input[input_i .. input_i + i]);
-                result_i += i;
-                result[result_i] = '\\';
-                result[result_i + 1] = '`';
-                result_i += 2;
-                input_i += i + 1;
-            }
-
-            if (result_i != result.len) {
-                bun.copy(u8, result[result_i..], input[input_i..]);
-            }
-
-            out.deinit();
-            out.list.items = result;
-            out.list.capacity = result.len;
-        }
     }
 
     pub fn jestPrettyFormat(this: JSValue, out: *MutableString, globalObject: *JSGlobalObject) !void {
@@ -4536,7 +4580,7 @@ pub const JSValue = enum(JSValueReprInt) {
 
         var writer = buf.writer();
         try writer.print(fmt, args);
-        return String.init(buf.toOwnedSliceLeaky()).toJS(globalThis);
+        return String.init(buf.slice()).toJS(globalThis);
     }
 
     /// Create a JSValue string from a zig format-print (fmt + args), with pretty format
@@ -4550,7 +4594,7 @@ pub const JSValue = enum(JSValueReprInt) {
         switch (Output.enable_ansi_colors) {
             inline else => |enabled| try writer.print(Output.prettyFmt(fmt, enabled), args),
         }
-        return String.init(buf.toOwnedSliceLeaky()).toJS(globalThis);
+        return String.init(buf.slice()).toJS(globalThis);
     }
 
     pub fn fromEntries(globalThis: *JSGlobalObject, keys_array: [*c]ZigString, values_array: [*c]ZigString, strings_count: usize, clone: bool) JSValue {
@@ -4702,13 +4746,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});
     }
@@ -4904,13 +4941,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 {
@@ -4963,6 +5004,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);
@@ -4987,6 +5029,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);
     }
@@ -5006,17 +5061,15 @@ pub const JSValue = enum(JSValueReprInt) {
     }
 
     /// Call `toString()` on the JSValue and clone the result.
-    /// On exception, this returns null.
-    pub fn toSliceOrNull(this: JSValue, globalThis: *JSGlobalObject) ?ZigString.Slice {
-        const str = bun.String.tryFromJS(this, globalThis) orelse return null;
+    pub fn toSliceOrNull(this: JSValue, globalThis: *JSGlobalObject) bun.JSError!ZigString.Slice {
+        const str = try bun.String.fromJS2(this, globalThis);
         defer str.deref();
         return str.toUTF8(bun.default_allocator);
     }
 
     /// Call `toString()` on the JSValue and clone the result.
-    /// On exception, this returns null.
-    pub fn toSliceOrNullWithAllocator(this: JSValue, globalThis: *JSGlobalObject, allocator: std.mem.Allocator) ?ZigString.Slice {
-        const str = bun.String.tryFromJS(this, globalThis) orelse return null;
+    pub fn toSliceOrNullWithAllocator(this: JSValue, globalThis: *JSGlobalObject, allocator: std.mem.Allocator) bun.JSError!ZigString.Slice {
+        const str = try bun.String.fromJS2(this, globalThis);
         defer str.deref();
         return str.toUTF8(allocator);
     }
@@ -5046,7 +5099,7 @@ pub const JSValue = enum(JSValueReprInt) {
     ) ?ZigString.Slice {
         var str = this.toStringOrNull(globalThis) orelse return null;
         return str.toSlice(globalThis, allocator).cloneIfNeeded(allocator) catch {
-            globalThis.throwOutOfMemory();
+            globalThis.throwOutOfMemory() catch {}; // TODO: properly propagate exception upwards
             return null;
         };
     }
@@ -5085,10 +5138,16 @@ pub const JSValue = enum(JSValueReprInt) {
         name,
         message,
         @"error",
+        default,
+        encoding,
 
         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 {
@@ -5102,17 +5161,25 @@ pub const JSValue = enum(JSValueReprInt) {
     // `this` must be known to be an object
     // intended to be more lightweight than ZigString.
     pub fn fastGet(this: JSValue, global: *JSGlobalObject, builtin_name: BuiltinName) ?JSValue {
-        if (bun.Environment.allow_assert)
+        if (bun.Environment.isDebug)
             bun.assert(this.isObject());
-        const result = fastGet_(this, global, @intFromEnum(builtin_name));
-        if (result == .zero or
-            // JS APIs treat {}.a as mostly the same as though it was not defined
-            result == .undefined)
-        {
-            return null;
-        }
 
-        return result;
+        return switch (JSC__JSValue__fastGet(this, global, @intFromEnum(builtin_name))) {
+            .zero, .undefined, .property_does_not_exist_on_object => null,
+            else => |val| val,
+        };
+    }
+
+    pub fn fastGetWithError(this: JSValue, global: *JSGlobalObject, builtin_name: BuiltinName) JSError!?JSValue {
+        if (bun.Environment.isDebug)
+            bun.assert(this.isObject());
+
+        return switch (JSC__JSValue__fastGet(this, global, @intFromEnum(builtin_name))) {
+            .zero => error.JSError,
+            .undefined => null,
+            .property_does_not_exist_on_object => null,
+            else => |val| val,
+        };
     }
 
     pub fn fastGetDirect(this: JSValue, global: *JSGlobalObject, builtin_name: BuiltinName) ?JSValue {
@@ -5124,10 +5191,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) JSValue;
     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);
@@ -5142,10 +5206,7 @@ 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 });
-    }
+    extern fn JSC__JSValue__getIfPropertyExistsImpl(target: JSValue, global: *JSGlobalObject, ptr: [*]const u8, len: u32) JSValue;
 
     pub fn getIfPropertyExistsFromPath(this: JSValue, global: *JSGlobalObject, path: JSValue) JSValue {
         return cppFn("getIfPropertyExistsFromPath", .{ this, global, path });
@@ -5164,6 +5225,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 });
     }
 
@@ -5181,26 +5246,48 @@ pub const JSValue = enum(JSValueReprInt) {
 
     /// Equivalent to `obj.property` in JavaScript.
     /// Reminder: `undefined` is a value!
-    pub fn get(this: JSValue, global: *JSGlobalObject, property: []const u8) ?JSValue {
+    ///
+    /// Prefer `get` in new code, as this function is incapable of returning an exception
+    pub fn get_unsafe(this: JSValue, global: *JSGlobalObject, property: []const u8) ?JSValue {
         if (comptime bun.Environment.isDebug) {
             if (BuiltinName.has(property)) {
                 Output.debugWarn("get(\"{s}\") called. Please use fastGet(.{s}) instead!", .{ property, property });
             }
         }
 
-        const value = getIfPropertyExistsImpl(this, global, property.ptr, @as(u32, @intCast(property.len)));
-        return if (value.isEmpty()) null else value;
+        return switch (JSC__JSValue__getIfPropertyExistsImpl(this, global, property.ptr, @intCast(property.len))) {
+            .undefined, .zero, .property_does_not_exist_on_object => null,
+            else => |val| val,
+        };
     }
 
-    extern fn JSC__JSValue__getIfPropertyExistsImplString(value: JSValue, globalObject: *JSGlobalObject, propertyName: [*c]const bun.String) JSValue;
+    /// 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.
+    pub inline fn get(target: JSValue, global: *JSGlobalObject, property: anytype) JSError!?JSValue {
+        if (bun.Environment.isDebug) bun.assert(target.isObject());
+        const property_slice: []const u8 = property; // must be a slice!
 
-    pub fn getWithString(this: JSValue, global: *JSGlobalObject, property_name: anytype) ?JSValue {
-        var property_name_str = bun.String.init(property_name);
-        const value = JSC__JSValue__getIfPropertyExistsImplString(this, global, &property_name_str);
-        return if (@intFromEnum(value) != 0) value else return null;
+        // This call requires `get` to be `inline`
+        if (bun.isComptimeKnown(property_slice)) {
+            if (comptime BuiltinName.get(property_slice)) |builtin_name| {
+                return target.fastGetWithError(global, builtin_name);
+            }
+        }
+
+        return switch (JSC__JSValue__getIfPropertyExistsImpl(target, global, property_slice.ptr, @intCast(property_slice.len))) {
+            .zero => error.JSError,
+            .undefined, .property_does_not_exist_on_object => null,
+            else => |val| val,
+        };
     }
 
-    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 {
@@ -5209,6 +5296,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;
@@ -5218,7 +5312,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;
@@ -5227,6 +5321,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));
@@ -5235,28 +5330,74 @@ pub const JSValue = enum(JSValueReprInt) {
         return getOwnTruthy(this, global, property);
     }
 
-    pub fn getTruthyComptime(this: JSValue, global: *JSGlobalObject, comptime property: []const u8) ?JSValue {
-        if (comptime bun.ComptimeEnumMap(BuiltinName).has(property)) {
-            if (fastGet(this, global, @field(BuiltinName, property))) |prop| {
-                if (prop.isEmptyOrUndefinedOrNull()) return null;
-                return prop;
-            }
+    pub fn truthyPropertyValue(prop: JSValue) ?JSValue {
+        return switch (prop) {
+            .null => null,
 
-            return null;
+            // Handled by get() and fastGet().
+            .zero, .undefined => unreachable,
+
+            // false, 0, are deliberately not included in this list.
+            // That would prevent you from passing `0` or `false` to various Bun APIs.
+
+            else => {
+                // Ignore empty string.
+                if (prop.isString()) {
+                    if (!prop.toBoolean()) {
+                        return null;
+                    }
+                }
+
+                return prop;
+            },
+        };
+    }
+
+    // TODO: replace calls to this function with `getOptional`
+    pub fn getTruthyComptime(this: JSValue, global: *JSGlobalObject, comptime property: []const u8) bun.JSError!?JSValue {
+        if (comptime BuiltinName.has(property)) {
+            return truthyPropertyValue(fastGet(this, global, @field(BuiltinName, property)) orelse return null);
         }
 
         return getTruthy(this, global, property);
     }
 
-    pub fn getTruthy(this: JSValue, global: *JSGlobalObject, property: []const u8) ?JSValue {
-        if (get(this, global, property)) |prop| {
-            if (prop.isEmptyOrUndefinedOrNull()) return null;
-            return prop;
+    // TODO: replace calls to this function with `getOptional`
+    pub fn getTruthy(this: JSValue, global: *JSGlobalObject, property: []const u8) bun.JSError!?JSValue {
+        if (try get(this, global, property)) |prop| {
+            return truthyPropertyValue(prop);
         }
 
         return null;
     }
 
+    /// Get a value that can be coerced to a string.
+    ///
+    /// Returns null when the value is:
+    /// - JSValue.null
+    /// - JSValue.false
+    /// - JSValue.undefined
+    /// - an empty string
+    pub fn getStringish(this: JSValue, global: *JSGlobalObject, property: []const u8) bun.JSError!?bun.String {
+        const prop = try get(this, global, property) orelse return null;
+        if (prop.isNull() or prop == .false) {
+            return null;
+        }
+        if (prop.isSymbol()) {
+            return global.throwInvalidPropertyTypeValue(property, "string", prop);
+        }
+
+        const str = prop.toBunString(global);
+        if (global.hasException()) {
+            str.deref();
+            return error.JSError;
+        }
+        if (str.isEmpty()) {
+            return null;
+        }
+        return str;
+    }
+
     pub fn toEnumFromMap(
         this: JSValue,
         globalThis: *JSGlobalObject,
@@ -5265,12 +5406,10 @@ pub const JSValue = enum(JSValueReprInt) {
         comptime StringMap: anytype,
     ) JSError!Enum {
         if (!this.isString()) {
-            globalThis.throwInvalidArguments(property_name ++ " must be a string", .{});
-            return error.JSError;
+            return globalThis.throwInvalidArguments(property_name ++ " must be a string", .{});
         }
 
-        const target_str = this.getZigString(globalThis);
-        return StringMap.getWithEql(target_str, ZigString.eqlComptime) orelse {
+        return StringMap.fromJS(globalThis, this) orelse {
             const one_of = struct {
                 pub const list = brk: {
                     var str: []const u8 = "'";
@@ -5288,7 +5427,8 @@ pub const JSValue = enum(JSValueReprInt) {
 
                 pub const label = property_name ++ " must be one of " ++ list;
             }.label;
-            globalThis.throwInvalidArguments(one_of, .{});
+            if (!globalThis.hasException())
+                return globalThis.throwInvalidArguments(one_of, .{});
             return error.JSError;
         };
     }
@@ -5314,7 +5454,7 @@ pub const JSValue = enum(JSValueReprInt) {
             return null;
         }
 
-        if (get(this, globalThis, property_name)) |prop| {
+        if (try get(this, globalThis, property_name)) |prop| {
             if (prop.isEmptyOrUndefinedOrNull())
                 return null;
             return try toEnum(prop, globalThis, property_name, Enum);
@@ -5342,8 +5482,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.throwInvalidArguments(property_name ++ " must be an array", .{});
         }
 
         if (prop.getLength(globalThis) == 0) {
@@ -5354,7 +5493,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);
         }
 
@@ -5370,10 +5509,9 @@ 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;
+                return globalThis.throwInvalidArguments(property_name ++ " must be an object", .{});
             }
 
             return prop;
@@ -5385,8 +5523,7 @@ pub const JSValue = enum(JSValueReprInt) {
     pub fn getOwnObject(this: JSValue, globalThis: *JSGlobalObject, comptime property_name: []const u8) JSError!?JSValue {
         if (getOwnTruthy(this, globalThis, property_name)) |prop| {
             if (!prop.jsTypeLoose().isObject()) {
-                globalThis.throwInvalidArguments(property_name ++ " must be an object", .{});
-                return error.JSError;
+                return globalThis.throwInvalidArguments(property_name ++ " must be an object", .{});
             }
 
             return prop;
@@ -5396,10 +5533,9 @@ 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;
+                return globalThis.throwInvalidArguments(property_name ++ " must be a function", .{});
             }
 
             return prop;
@@ -5411,8 +5547,7 @@ pub const JSValue = enum(JSValueReprInt) {
     pub fn getOwnFunction(this: JSValue, globalThis: *JSGlobalObject, comptime property_name: []const u8) JSError!?JSValue {
         if (getOwnTruthy(this, globalThis, property_name)) |prop| {
             if (!prop.isCell() or !prop.isCallable(globalThis.vm())) {
-                globalThis.throwInvalidArguments(property_name ++ " must be a function", .{});
-                return error.JSError;
+                return globalThis.throwInvalidArguments(property_name ++ " must be a function", .{});
             }
 
             return prop;
@@ -5420,42 +5555,48 @@ pub const JSValue = enum(JSValueReprInt) {
 
         return null;
     }
-    fn coerceOptional(prop: JSValue, globalThis: *JSGlobalObject, comptime property_name: []const u8, comptime T: type) JSError!?T {
+
+    fn coerceOptional(prop: JSValue, global: *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;
-            },
+            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| {
-                        return str;
-                    }
+                    return try prop.toSliceOrNull(global);
                 }
-
-                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.get(global, property_name) orelse return null;
+        return prop.toBoolean();
+    }
 
-        if (!prop.isEmptyOrUndefinedOrNull()) {
-            return coerceOptional(prop, globalThis, property_name, T);
+    /// 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.get(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.get(globalThis, property_name) orelse return null;
+        bun.assert(prop != .zero);
+
+        if (!prop.isUndefinedOrNull()) {
+            return try coerceOptional(prop, globalThis, property_name, T);
         }
 
         return null;
@@ -5497,8 +5638,10 @@ pub const JSValue = enum(JSValueReprInt) {
     }
 
     /// same as `JSValue.deepEquals`, but with jest asymmetric matchers enabled
-    pub fn jestDeepEquals(this: JSValue, other: JSValue, global: *JSGlobalObject) bool {
-        return cppFn("jestDeepEquals", .{ this, other, global });
+    pub fn jestDeepEquals(this: JSValue, other: JSValue, global: *JSGlobalObject) bun.JSError!bool {
+        const result = cppFn("jestDeepEquals", .{ this, other, global });
+        if (global.hasException()) return error.JSError;
+        return result;
     }
 
     pub fn strictDeepEquals(this: JSValue, other: JSValue, global: *JSGlobalObject) bool {
@@ -5548,6 +5691,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,
@@ -5641,16 +5790,9 @@ pub const JSValue = enum(JSValueReprInt) {
         return fromPtrAddress(@intFromPtr(addr));
     }
 
-    pub fn toBooleanSlow(this: JSValue, global: *JSGlobalObject) bool {
-        return cppFn("toBooleanSlow", .{ this, global });
-    }
-
+    /// Equivalent to the `!!` operator
     pub fn toBoolean(this: JSValue) bool {
-        if (isEmptyOrUndefinedOrNull(this)) {
-            return false;
-        }
-
-        return asBoolean(this);
+        return this != .zero and cppFn("toBoolean", .{this});
     }
 
     pub fn asBoolean(this: JSValue) bool {
@@ -5808,25 +5950,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);
@@ -5845,6 +5990,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_",
@@ -5940,7 +6095,6 @@ pub const JSValue = enum(JSValueReprInt) {
         "symbolFor",
         "symbolKeyFor",
         "toBoolean",
-        "toBooleanSlow",
         "toError_",
         "toInt32",
         "toInt64",
@@ -5962,13 +6116,13 @@ pub const JSValue = enum(JSValueReprInt) {
         "jestDeepMatch",
     };
 
-    // For any callback JSValue created in JS that you will not call *immediately*, you must wrap it
-    // in an AsyncContextFrame with this function. This allows AsyncLocalStorage to work by
-    // snapshotting it's state and restoring it when called.
-    // - If there is no current context, this returns the callback as-is.
-    // - It is safe to run .call() on the resulting JSValue. This includes automatic unwrapping.
-    // - Do not pass the callback as-is to JS; The wrapped object is NOT a function.
-    // - If passed to C++, call it with AsyncContextFrame::call() instead of JSC::call()
+    /// For any callback JSValue created in JS that you will not call *immediately*, you must wrap it
+    /// in an AsyncContextFrame with this function. This allows AsyncLocalStorage to work by
+    /// snapshotting it's state and restoring it when called.
+    /// - If there is no current context, this returns the callback as-is.
+    /// - It is safe to run .call() on the resulting JSValue. This includes automatic unwrapping.
+    /// - Do not pass the callback as-is to JS; The wrapped object is NOT a function.
+    /// - If passed to C++, call it with AsyncContextFrame::call() instead of JSC::call()
     pub inline fn withAsyncContextIfNeeded(this: JSValue, global: *JSGlobalObject) JSValue {
         JSC.markBinding(@src());
         return AsyncContextFrame__withAsyncContextIfNeeded(global, this);
@@ -6021,13 +6175,14 @@ pub const JSValue = enum(JSValueReprInt) {
         return Bun__ProxyObject__getInternalField(this, field);
     }
 
-    extern fn JSC__JSValue__getClassInfoName(value: JSValue, out: *bun.String) bool;
+    extern fn JSC__JSValue__getClassInfoName(value: JSValue, out: *[*:0]const u8, len: *usize) bool;
 
     /// For native C++ classes extending JSCell, this retrieves s_info's name
-    pub fn getClassInfoName(this: JSValue) ?bun.String {
-        if (!this.isObject()) return null;
-        var out: bun.String = bun.String.empty;
-        if (!JSC__JSValue__getClassInfoName(this, &out)) return null;
+    /// This is a readonly ASCII string.
+    pub fn getClassInfoName(this: JSValue) ?[:0]const u8 {
+        if (!this.isCell()) return null;
+        var out: [:0]const u8 = "";
+        if (!JSC__JSValue__getClassInfoName(this, &out.ptr, &out.len)) return null;
         return out;
     }
 };
@@ -6088,6 +6243,22 @@ pub const VM = extern struct {
         LargeHeap = 1,
     };
 
+    extern fn Bun__JSC_onBeforeWait(vm: *VM) i32;
+    extern fn Bun__JSC_onAfterWait(vm: *VM) void;
+    pub const ReleaseHeapAccess = struct {
+        vm: *VM,
+        needs_to_release: bool,
+        pub fn acquire(this: *const ReleaseHeapAccess) void {
+            if (this.needs_to_release) {
+                Bun__JSC_onAfterWait(this.vm);
+            }
+        }
+    };
+
+    pub fn releaseHeapAccess(vm: *VM) ReleaseHeapAccess {
+        return .{ .vm = vm, .needs_to_release = Bun__JSC_onBeforeWait(vm) != 0 };
+    }
+
     pub fn create(heap_type: HeapType) *VM {
         return cppFn("create", .{@intFromEnum(heap_type)});
     }
@@ -6219,12 +6390,11 @@ pub const VM = extern struct {
         });
     }
 
-    pub fn throwError(vm: *VM, global_object: *JSGlobalObject, value: JSValue) void {
-        return cppFn("throwError", .{
-            vm,
-            global_object,
-            value,
-        });
+    // manual extern to workaround shimmer limitation
+    // shimmer doesnt let you change the return type or make it non-pub
+    extern fn JSC__VM__throwError(*VM, *JSGlobalObject, JSValue) void;
+    fn throwError(vm: *VM, global_object: *JSGlobalObject, value: JSValue) void {
+        JSC__VM__throwError(vm, global_object, value);
     }
 
     pub fn releaseWeakRefs(vm: *VM) void {
@@ -6354,6 +6524,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.
@@ -6363,6 +6547,10 @@ pub const CallFrame = opaque {
 
     pub const name = "JSC::CallFrame";
 
+    inline fn asUnsafeJSValueArray(self: *const CallFrame) [*]const JSC.JSValue {
+        return @as([*]align(alignment) const JSC.JSValue, @ptrCast(@alignCast(self)));
+    }
+
     pub fn format(frame: *CallFrame, comptime _: []const u8, _: std.fmt.FormatOptions, writer: anytype) !void {
         const args = frame.argumentsPtr()[0..frame.argumentsCount()];
 
@@ -6392,17 +6580,18 @@ pub const CallFrame = opaque {
     }
 
     pub fn argumentsPtr(self: *const CallFrame) [*]const JSC.JSValue {
-        return @as([*]align(alignment) const JSC.JSValue, @ptrCast(@alignCast(self))) + Sizes.Bun_CallFrame__firstArgument;
+        return self.asUnsafeJSValueArray()[Sizes.Bun_CallFrame__firstArgument..];
     }
 
     pub fn callee(self: *const CallFrame) JSC.JSValue {
-        return (@as([*]align(alignment) const JSC.JSValue, @ptrCast(@alignCast(self))) + Sizes.Bun_CallFrame__callee)[0];
+        return self.asUnsafeJSValueArray()[Sizes.Bun_CallFrame__callee];
     }
 
     fn Arguments(comptime max: usize) type {
         return struct {
             ptr: [max]JSC.JSValue,
             len: usize,
+
             pub inline fn init(comptime i: usize, ptr: [*]const JSC.JSValue) @This() {
                 var args: [max]JSC.JSValue = std.mem.zeroes([max]JSC.JSValue);
                 args[0..i].* = ptr[0..i].*;
@@ -6413,61 +6602,89 @@ pub const CallFrame = opaque {
                 };
             }
 
+            pub inline fn initUndef(comptime i: usize, ptr: [*]const JSC.JSValue) @This() {
+                var args = [1]JSC.JSValue{.undefined} ** max;
+                args[0..i].* = ptr[0..i].*;
+                return @This(){ .ptr = args, .len = i };
+            }
+
             pub inline fn slice(self: *const @This()) []const JSValue {
                 return self.ptr[0..self.len];
             }
+
+            pub inline fn mut(self: *@This()) []JSValue {
+                return self.ptr[0..];
+            }
         };
     }
 
-    pub fn arguments(self: *const CallFrame, comptime max: usize) Arguments(max) {
+    pub fn arguments(self: *const CallFrame) []const JSValue {
+        // this presumably isn't allowed given that it doesn't exist
+        return self.argumentsPtr()[0..self.argumentsCount()];
+    }
+    pub fn arguments_old(self: *const CallFrame, comptime max: usize) Arguments(max) {
         const len = self.argumentsCount();
         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,
         };
     }
 
-    pub fn argument(self: *const CallFrame, comptime i: comptime_int) JSC.JSValue {
+    pub fn argumentsUndef(self: *const CallFrame, comptime max: usize) Arguments(max) {
+        const len = self.argumentsCount();
+        const ptr = self.argumentsPtr();
+        return switch (@as(u4, @min(len, max))) {
+            0 => .{ .ptr = .{.undefined} ** max, .len = 0 },
+            inline 1...9 => |count| Arguments(max).initUndef(@min(count, max), ptr),
+            else => unreachable,
+        };
+    }
+
+    pub inline fn argument(self: *const CallFrame, i: usize) JSC.JSValue {
         return self.argumentsPtr()[i];
     }
 
     pub fn this(self: *const CallFrame) JSC.JSValue {
-        return (@as([*]align(alignment) const JSC.JSValue, @ptrCast(@alignCast(self))) + Sizes.Bun_CallFrame__thisArgument)[0];
+        return self.asUnsafeJSValueArray()[Sizes.Bun_CallFrame__thisArgument];
     }
 
     pub fn argumentsCount(self: *const CallFrame) usize {
-        return @as(usize, @intCast((@as([*]align(alignment) const JSC.JSValue, @ptrCast(@alignCast(self))) + Sizes.Bun_CallFrame__argumentCountIncludingThis)[0].asInt32() - 1));
+        return @as(usize, @intCast(self.asUnsafeJSValueArray()[Sizes.Bun_CallFrame__argumentCountIncludingThis].asInt32() - 1));
+    }
+
+    extern fn Bun__CallFrame__isFromBunMain(*const CallFrame, *const VM) bool;
+    pub const isFromBunMain = Bun__CallFrame__isFromBunMain;
+
+    /// 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;
+    }
+
+    extern fn Bun__CallFrame__getCallerSrcLoc(*const CallFrame, *JSGlobalObject, *c_uint, *c_uint, *c_uint) void;
+    pub const CallerSrcLoc = struct {
+        source_file_id: c_uint,
+        line: c_uint,
+        column: c_uint,
+    };
+    pub fn getCallerSrcLoc(call_frame: *const CallFrame, globalThis: *JSGlobalObject) CallerSrcLoc {
+        var source_id: c_uint = undefined;
+        var line: c_uint = undefined;
+        var column: c_uint = undefined;
+        Bun__CallFrame__getCallerSrcLoc(call_frame, globalThis, &source_id, &line, &column);
+        return .{
+            .source_file_id = source_id,
+            .line = line,
+            .column = column,
+        };
     }
 };
 
-// pub const WellKnownSymbols = extern struct {
-//     pub const shim = Shimmer("JSC", "CommonIdentifiers", @This());
-
-//
-//
-
-//     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");
-
-// };
-
 pub const EncodedJSValue = extern union {
     asInt64: i64,
     ptr: ?*JSCell,
@@ -6478,41 +6695,63 @@ 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));
-                }
-
-                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.");
-                    }
-                }
+            if (bun.Environment.allow_assert and bun.Environment.is_canary) {
+                const value = Function(globalThis, callframe) catch |err| switch (err) {
+                    error.JSError => .zero,
+                    error.OutOfMemory => globalThis.throwOutOfMemoryValue(),
+                };
+                bun.assert((value == .zero) == globalThis.hasException());
+                return value;
             }
-
-            return @call(.always_inline, Function, .{ globalThis, callframe });
+            return @call(.always_inline, Function, .{ globalThis, callframe }) catch |err| switch (err) {
+                error.JSError => .zero,
+                error.OutOfMemory => globalThis.throwOutOfMemoryValue(),
+            };
         }
     }.function;
 }
 
+pub fn toJSHostValue(globalThis: *JSGlobalObject, value: error{ OutOfMemory, JSError }!JSValue) JSValue {
+    if (bun.Environment.allow_assert and bun.Environment.is_canary) {
+        const normal = value catch |err| switch (err) {
+            error.JSError => .zero,
+            error.OutOfMemory => globalThis.throwOutOfMemoryValue(),
+        };
+        bun.assert((normal == .zero) == globalThis.hasException());
+        return normal;
+    }
+    return value catch |err| switch (err) {
+        error.JSError => .zero,
+        error.OutOfMemory => globalThis.throwOutOfMemoryValue(),
+    };
+}
+
+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;
+        }
+        break :brk errs;
+    };
+}
+
 const DeinitFunction = *const fn (ctx: *anyopaque, buffer: [*]u8, len: usize) callconv(.C) void;
 
 pub const JSArray = opaque {
@@ -6558,6 +6797,7 @@ const private = struct {
         functionPointer: JSHostFunctionPtr,
         strong: bool,
         add_ptr_field: bool,
+        inputFunctionPtr: ?*anyopaque,
     ) JSValue;
 
     pub extern fn Bun__untrackFFIFunction(
@@ -6576,7 +6816,10 @@ pub fn NewFunction(
     comptime functionPointer: anytype,
     strong: bool,
 ) JSValue {
-    return NewRuntimeFunction(globalObject, symbolName, argCount, toJSHostFunction(functionPointer), strong, false);
+    if (@TypeOf(functionPointer) == JSC.JSHostFunctionType) {
+        return NewRuntimeFunction(globalObject, symbolName, argCount, functionPointer, strong, false, null);
+    }
+    return NewRuntimeFunction(globalObject, symbolName, argCount, toJSHostFunction(functionPointer), strong, false, null);
 }
 
 pub fn createCallback(
@@ -6585,7 +6828,10 @@ pub fn createCallback(
     argCount: u32,
     comptime functionPointer: anytype,
 ) JSValue {
-    return NewRuntimeFunction(globalObject, symbolName, argCount, toJSHostFunction(functionPointer), false, false);
+    if (@TypeOf(functionPointer) == JSC.JSHostFunctionType) {
+        return NewRuntimeFunction(globalObject, symbolName, argCount, functionPointer, false, false);
+    }
+    return NewRuntimeFunction(globalObject, symbolName, argCount, toJSHostFunction(functionPointer), false, false, null);
 }
 
 pub fn NewRuntimeFunction(
@@ -6595,9 +6841,10 @@ pub fn NewRuntimeFunction(
     functionPointer: JSHostFunctionPtr,
     strong: bool,
     add_ptr_property: bool,
+    inputFunctionPtr: ?*anyopaque,
 ) JSValue {
     JSC.markBinding(@src());
-    return private.Bun__CreateFFIFunctionValue(globalObject, symbolName, argCount, functionPointer, strong, add_ptr_property);
+    return private.Bun__CreateFFIFunctionValue(globalObject, symbolName, argCount, functionPointer, strong, add_ptr_property, inputFunctionPtr);
 }
 
 pub fn getFunctionData(function: JSValue) ?*anyopaque {
@@ -6614,7 +6861,7 @@ pub fn NewFunctionWithData(
     globalObject: *JSGlobalObject,
     symbolName: ?*const ZigString,
     argCount: u32,
-    comptime functionPointer: anytype,
+    comptime functionPointer: JSC.JSHostZigFunction,
     strong: bool,
     data: *anyopaque,
 ) JSValue {
@@ -6683,14 +6930,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/blob.cpp b/src/bun.js/bindings/blob.cpp
index bfbdc1fd49..85982f1b8b 100644
--- a/src/bun.js/bindings/blob.cpp
+++ b/src/bun.js/bindings/blob.cpp
@@ -26,4 +26,4 @@ JSC::JSValue toJSNewlyCreated(JSC::JSGlobalObject* lexicalGlobalObject, JSDOMGlo
     return JSC::JSValue::decode(encoded);
 }
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/bun-simdutf.cpp b/src/bun.js/bindings/bun-simdutf.cpp
index ea6ff06416..e6dd1c471d 100644
--- a/src/bun.js/bindings/bun-simdutf.cpp
+++ b/src/bun.js/bindings/bun-simdutf.cpp
@@ -362,4 +362,4 @@ SIMDUTFResult simdutf__base64_decode_from_binary16(const char16_t* input, size_t
 
     return { .error = res.error, .count = res.count };
 }
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/bun-spawn.cpp b/src/bun.js/bindings/bun-spawn.cpp
index 70d84833e1..4a81d79850 100644
--- a/src/bun.js/bindings/bun-spawn.cpp
+++ b/src/bun.js/bindings/bun-spawn.cpp
@@ -8,8 +8,8 @@
 #include <unistd.h>
 #include <sys/stat.h>
 #include <sys/wait.h>
-#include <sys/fcntl.h>
-#include <sys/signal.h>
+#include <fcntl.h>
+#include <signal.h>
 #include <sys/syscall.h>
 #include <sys/resource.h>
 
@@ -201,4 +201,4 @@ extern "C" ssize_t posix_spawn_bun(
     return res;
 }
 
-#endif
\ No newline at end of file
+#endif
diff --git a/src/bun.js/bindings/c-bindings.cpp b/src/bun.js/bindings/c-bindings.cpp
index 9357a1c84c..906fc01e81 100644
--- a/src/bun.js/bindings/c-bindings.cpp
+++ b/src/bun.js/bindings/c-bindings.cpp
@@ -4,15 +4,15 @@
 
 #if !OS(WINDOWS)
 #include <sys/resource.h>
-#include <sys/fcntl.h>
+#include <fcntl.h>
 #include <sys/stat.h>
-#include <sys/signal.h>
+#include <signal.h>
 #include <unistd.h>
 #include <cstring>
 #include <csignal>
 #include <cstdint>
 #include <cstdlib>
-#include <sys/termios.h>
+#include <termios.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
 #else
@@ -252,6 +252,8 @@ typedef struct {
     size_t name_len;
     const char* value;
     size_t value_len;
+    bool never_index;
+    uint16_t hpack_index;
 } lshpack_header;
 
 lshpack_wrapper* lshpack_wrapper_init(lshpack_wrapper_alloc alloc, lshpack_wrapper_free free, unsigned max_capacity)
@@ -310,6 +312,12 @@ size_t lshpack_wrapper_decode(lshpack_wrapper* self,
     output->name_len = hdr.name_len;
     output->value = lsxpack_header_get_value(&hdr);
     output->value_len = hdr.val_len;
+    output->never_index = (hdr.flags & LSXPACK_NEVER_INDEX) != 0;
+    if (hdr.hpack_index != LSHPACK_HDR_UNKNOWN && hdr.hpack_index <= LSHPACK_HDR_WWW_AUTHENTICATE) {
+        output->hpack_index = hdr.hpack_index - 1;
+    } else {
+        output->hpack_index = 255;
+    }
     return s - src;
 }
 
@@ -549,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/coroutine.cpp b/src/bun.js/bindings/coroutine.cpp
index bf3ebea3f9..883d3ed3c2 100644
--- a/src/bun.js/bindings/coroutine.cpp
+++ b/src/bun.js/bindings/coroutine.cpp
@@ -39,4 +39,4 @@ extern "C" void Bun__startMacro(BunMacroFunction ctx, JSC::JSGlobalObject* globa
     // mco_result res = mco_create(&co, &desc);
     // mco_resume(co);
     // mco_destroy(co);
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/debug-helpers.h b/src/bun.js/bindings/debug-helpers.h
index 01dc92df8f..c40316c4d1 100644
--- a/src/bun.js/bindings/debug-helpers.h
+++ b/src/bun.js/bindings/debug-helpers.h
@@ -15,4 +15,4 @@ Inspector::InspectorDebuggerAgent* debuggerAgent(JSC::JSGlobalObject* globalObje
 
     return nullptr;
 }
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/exports.zig b/src/bun.js/bindings/exports.zig
index 27d1e91655..586f325178 100644
--- a/src/bun.js/bindings/exports.zig
+++ b/src/bun.js/bindings/exports.zig
@@ -140,6 +140,7 @@ pub const JSArrayBufferSink = JSC.WebCore.ArrayBufferSink.JSSink;
 pub const JSHTTPSResponseSink = JSC.WebCore.HTTPSResponseSink.JSSink;
 pub const JSHTTPResponseSink = JSC.WebCore.HTTPResponseSink.JSSink;
 pub const JSFileSink = JSC.WebCore.FileSink.JSSink;
+pub const JSFetchTaskletChunkedRequestSink = JSC.WebCore.FetchTaskletChunkedRequestSink.JSSink;
 
 // WebSocket
 pub const WebSocketHTTPClient = @import("../../http/websocket_http_client.zig").WebSocketHTTPClient;
@@ -215,6 +216,8 @@ pub const ResolvedSource = extern struct {
     /// This is for source_code
     source_code_needs_deref: bool = true,
     already_bundled: bool = false,
+    bytecode_cache: ?[*]u8 = null,
+    bytecode_cache_size: usize = 0,
 
     pub const Tag = @import("ResolvedSourceTag").ResolvedSourceTag;
 };
@@ -960,6 +963,7 @@ comptime {
         JSArrayBufferSink.shim.ref();
         JSHTTPResponseSink.shim.ref();
         JSHTTPSResponseSink.shim.ref();
+        JSFetchTaskletChunkedRequestSink.shim.ref();
         JSFileSink.shim.ref();
         JSFileSink.shim.ref();
         _ = ZigString__free;
diff --git a/src/bun.js/bindings/generated_classes_list.zig b/src/bun.js/bindings/generated_classes_list.zig
index 7550e84910..72095df5a5 100644
--- a/src/bun.js/bindings/generated_classes_list.zig
+++ b/src/bun.js/bindings/generated_classes_list.zig
@@ -73,9 +73,8 @@ pub const Classes = struct {
     pub const BytesInternalReadableStreamSource = JSC.WebCore.ByteStream.Source;
     pub const PostgresSQLConnection = JSC.Postgres.PostgresSQLConnection;
     pub const PostgresSQLQuery = JSC.Postgres.PostgresSQLQuery;
-    pub const BrotliEncoder = JSC.API.BrotliEncoder;
-    pub const BrotliDecoder = JSC.API.BrotliDecoder;
     pub const TextEncoderStreamEncoder = JSC.WebCore.TextEncoderStreamEncoder;
-    pub const ZlibEncoder = JSC.API.ZlibEncoder;
-    pub const ZlibDecoder = JSC.API.ZlibDecoder;
+    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-handwritten.h b/src/bun.js/bindings/headers-handwritten.h
index 54efa66cfc..f21fc27bf9 100644
--- a/src/bun.js/bindings/headers-handwritten.h
+++ b/src/bun.js/bindings/headers-handwritten.h
@@ -101,6 +101,8 @@ typedef struct ResolvedSource {
     uint32_t tag;
     bool needsDeref;
     bool already_bundled;
+    uint8_t* bytecode_cache;
+    size_t bytecode_cache_size;
 } ResolvedSource;
 static const uint32_t ResolvedSourceTagPackageJSONTypeModule = 1;
 typedef union ErrorableResolvedSourceResult {
@@ -343,6 +345,7 @@ extern "C" bool Bun__fetchBuiltinModule(
 
 // Used in process.version
 extern "C" const char* Bun__version;
+extern "C" const char* Bun__version_with_sha;
 
 // Used in process.versions
 extern "C" const char* Bun__versions_boringssl;
diff --git a/src/bun.js/bindings/headers.h b/src/bun.js/bindings/headers.h
index 6d5efdb701..43a5dd50a5 100644
--- a/src/bun.js/bindings/headers.h
+++ b/src/bun.js/bindings/headers.h
@@ -1,11 +1,5 @@
 // clang-format off
-//-- GENERATED FILE. Do not edit --
-//
-//   To regenerate this file, run:
-//   
-//      make headers
-// 
-//-- GENERATED FILE. Do not edit --
+// This file used to be generated but now in hard coded.
 #pragma once
 
 #include <stddef.h>
@@ -323,7 +317,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));
@@ -394,7 +388,6 @@ CPP_DECL bool JSC__JSValue__stringIncludes(JSC__JSValue JSValue0, JSC__JSGlobalO
 CPP_DECL JSC__JSValue JSC__JSValue__symbolFor(JSC__JSGlobalObject* arg0, ZigString* arg1);
 CPP_DECL bool JSC__JSValue__symbolKeyFor(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, ZigString* arg2);
 CPP_DECL bool JSC__JSValue__toBoolean(JSC__JSValue JSValue0);
-CPP_DECL bool JSC__JSValue__toBooleanSlow(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1);
 CPP_DECL JSC__JSValue JSC__JSValue__toError_(JSC__JSValue JSValue0);
 CPP_DECL int32_t JSC__JSValue__toInt32(JSC__JSValue JSValue0);
 CPP_DECL int64_t JSC__JSValue__toInt64(JSC__JSValue JSValue0);
@@ -692,6 +685,25 @@ BUN_DECLARE_HOST_FUNCTION(FileSink__start);
 ZIG_DECL void FileSink__updateRef(void* arg0, bool arg1);
 BUN_DECLARE_HOST_FUNCTION(FileSink__write);
 
+#endif
+CPP_DECL JSC__JSValue FetchTaskletChunkedRequestSink__assignToStream(JSC__JSGlobalObject* arg0, JSC__JSValue JSValue1, void* arg2, void** arg3);
+CPP_DECL JSC__JSValue FetchTaskletChunkedRequestSink__createObject(JSC__JSGlobalObject* arg0, void* arg1, uintptr_t destructor);
+CPP_DECL void FetchTaskletChunkedRequestSink__detachPtr(JSC__JSValue JSValue0);
+CPP_DECL void* FetchTaskletChunkedRequestSink__fromJS(JSC__JSGlobalObject* arg0, JSC__JSValue JSValue1);
+CPP_DECL void FetchTaskletChunkedRequestSink__onClose(JSC__JSValue JSValue0, JSC__JSValue JSValue1);
+CPP_DECL void FetchTaskletChunkedRequestSink__onReady(JSC__JSValue JSValue0, JSC__JSValue JSValue1, JSC__JSValue JSValue2);
+
+#ifdef __cplusplus
+
+ZIG_DECL JSC__JSValue FetchTaskletChunkedRequestSink__close(JSC__JSGlobalObject* arg0, void* arg1);
+BUN_DECLARE_HOST_FUNCTION(FetchTaskletChunkedRequestSink__construct);
+BUN_DECLARE_HOST_FUNCTION(FetchTaskletChunkedRequestSink__end);
+ZIG_DECL JSC__JSValue SYSV_ABI SYSV_ABI FetchTaskletChunkedRequestSink__endWithSink(void* arg0, JSC__JSGlobalObject* arg1);
+ZIG_DECL void FetchTaskletChunkedRequestSink__finalize(void* arg0);
+BUN_DECLARE_HOST_FUNCTION(FetchTaskletChunkedRequestSink__flush);
+BUN_DECLARE_HOST_FUNCTION(FetchTaskletChunkedRequestSink__start);
+ZIG_DECL void FetchTaskletChunkedRequestSink__updateRef(void* arg0, bool arg1);
+BUN_DECLARE_HOST_FUNCTION(FetchTaskletChunkedRequestSink__write);
 #endif
 
 #ifdef __cplusplus
@@ -853,4 +865,7 @@ CPP_DECL bool JSC__CustomGetterSetter__isSetterNull(JSC__CustomGetterSetter *arg
 BUN_DECLARE_HOST_FUNCTION(Bun__onResolveEntryPointResult);
 BUN_DECLARE_HOST_FUNCTION(Bun__onRejectEntryPointResult);
 
+BUN_DECLARE_HOST_FUNCTION(Bun__FetchTasklet__onResolveRequestStream);
+BUN_DECLARE_HOST_FUNCTION(Bun__FetchTasklet__onRejectRequestStream);
+
 #endif
\ No newline at end of file
diff --git a/src/bun.js/bindings/headers.zig b/src/bun.js/bindings/headers.zig
index 3b64ff6905..0a3910de08 100644
--- a/src/bun.js/bindings/headers.zig
+++ b/src/bun.js/bindings/headers.zig
@@ -187,10 +187,10 @@ pub extern fn JSC__JSGlobalObject__reload(arg0: *bindings.JSGlobalObject) void;
 pub extern fn JSC__JSGlobalObject__startRemoteInspector(arg0: *bindings.JSGlobalObject, arg1: [*c]u8, arg2: u16) bool;
 pub extern fn JSC__JSGlobalObject__vm(arg0: *bindings.JSGlobalObject) *bindings.VM;
 pub extern fn JSC__JSMap__create(arg0: *bindings.JSGlobalObject) JSC__JSValue;
-pub extern fn JSC__JSMap__get_(arg0: ?*bindings.JSMap, arg1: *bindings.JSGlobalObject, JSValue2: JSC__JSValue) JSC__JSValue;
-pub extern fn JSC__JSMap__has(arg0: ?*bindings.JSMap, arg1: *bindings.JSGlobalObject, JSValue2: JSC__JSValue) bool;
-pub extern fn JSC__JSMap__remove(arg0: ?*bindings.JSMap, arg1: *bindings.JSGlobalObject, JSValue2: JSC__JSValue) bool;
-pub extern fn JSC__JSMap__set(arg0: ?*bindings.JSMap, arg1: *bindings.JSGlobalObject, JSValue2: JSC__JSValue, JSValue3: JSC__JSValue) void;
+pub extern fn JSC__JSMap__get_(arg0: ?*bindings.Map, arg1: *bindings.JSGlobalObject, JSValue2: JSC__JSValue) JSC__JSValue;
+pub extern fn JSC__JSMap__has(arg0: ?*bindings.Map, arg1: *bindings.JSGlobalObject, JSValue2: JSC__JSValue) bool;
+pub extern fn JSC__JSMap__remove(arg0: ?*bindings.Map, arg1: *bindings.JSGlobalObject, JSValue2: JSC__JSValue) bool;
+pub extern fn JSC__JSMap__set(arg0: ?*bindings.Map, arg1: *bindings.JSGlobalObject, JSValue2: JSC__JSValue, JSValue3: JSC__JSValue) void;
 pub extern fn JSC__JSValue___then(JSValue0: JSC__JSValue, arg1: *bindings.JSGlobalObject, JSValue2: JSC__JSValue, ArgFn3: ?bun.JSC.JSHostFunctionPtr, ArgFn4: ?bun.JSC.JSHostFunctionPtr) void;
 pub extern fn JSC__JSValue__asArrayBuffer_(JSValue0: JSC__JSValue, arg1: *bindings.JSGlobalObject, arg2: ?*Bun__ArrayBuffer) bool;
 pub extern fn JSC__JSValue__asBigIntCompare(JSValue0: JSC__JSValue, arg1: *bindings.JSGlobalObject, JSValue2: JSC__JSValue) u8;
@@ -289,7 +289,6 @@ pub extern fn JSC__JSValue__stringIncludes(JSValue0: JSC__JSValue, arg1: *bindin
 pub extern fn JSC__JSValue__symbolFor(arg0: *bindings.JSGlobalObject, arg1: [*c]ZigString) JSC__JSValue;
 pub extern fn JSC__JSValue__symbolKeyFor(JSValue0: JSC__JSValue, arg1: *bindings.JSGlobalObject, arg2: [*c]ZigString) bool;
 pub extern fn JSC__JSValue__toBoolean(JSValue0: JSC__JSValue) bool;
-pub extern fn JSC__JSValue__toBooleanSlow(JSValue0: JSC__JSValue, arg1: *bindings.JSGlobalObject) bool;
 pub extern fn JSC__JSValue__toError_(JSValue0: JSC__JSValue) JSC__JSValue;
 pub extern fn JSC__JSValue__toInt32(JSValue0: JSC__JSValue) i32;
 pub extern fn JSC__JSValue__toInt64(JSValue0: JSC__JSValue) i64;
@@ -380,6 +379,13 @@ pub extern fn FileSink__setDestroyCallback(JSValue0: JSC__JSValue, callback: usi
 pub extern fn FileSink__fromJS(arg0: *bindings.JSGlobalObject, JSValue1: JSC__JSValue) ?*anyopaque;
 pub extern fn FileSink__onClose(JSValue0: JSC__JSValue, JSValue1: JSC__JSValue) void;
 pub extern fn FileSink__onReady(JSValue0: JSC__JSValue, JSValue1: JSC__JSValue, JSValue2: JSC__JSValue) void;
+pub extern fn FetchTaskletChunkedRequestSink__assignToStream(arg0: *bindings.JSGlobalObject, JSValue1: JSC__JSValue, arg2: ?*anyopaque, arg3: [*c]*anyopaque) JSC__JSValue;
+pub extern fn FetchTaskletChunkedRequestSink__createObject(arg0: *bindings.JSGlobalObject, arg1: ?*anyopaque, onDestroyPtrTag: usize) JSC__JSValue;
+pub extern fn FetchTaskletChunkedRequestSink__detachPtr(JSValue0: JSC__JSValue) void;
+pub extern fn FetchTaskletChunkedRequestSink__setDestroyCallback(JSValue0: JSC__JSValue, callback: usize) void;
+pub extern fn FetchTaskletChunkedRequestSink__fromJS(arg0: *bindings.JSGlobalObject, JSValue1: JSC__JSValue) ?*anyopaque;
+pub extern fn FetchTaskletChunkedRequestSink__onClose(JSValue0: JSC__JSValue, JSValue1: JSC__JSValue) void;
+pub extern fn FetchTaskletChunkedRequestSink__onReady(JSValue0: JSC__JSValue, JSValue1: JSC__JSValue, JSValue2: JSC__JSValue) void;
 pub extern fn ZigException__fromException(arg0: [*c]bindings.Exception) ZigException;
 
 pub const JSC__GetterSetter = bindings.GetterSetter;
diff --git a/src/bun.js/bindings/helpers.cpp b/src/bun.js/bindings/helpers.cpp
index 88f2a5be2b..6aa6a6096a 100644
--- a/src/bun.js/bindings/helpers.cpp
+++ b/src/bun.js/bindings/helpers.cpp
@@ -22,4 +22,4 @@ JSC::JSValue createSystemError(JSC::JSGlobalObject* global, ASCIILiteral syscall
     instance->putDirect(vm, builtinNames.errnoPublicName(), JSC::jsNumber(err), 0);
     instance->putDirect(vm, vm.propertyNames->name, jsString(vm, String("SystemError"_s)), JSC::PropertyAttribute::DontEnum | 0);
     return instance;
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/helpers.h b/src/bun.js/bindings/helpers.h
index ee00db842f..5aeca38695 100644
--- a/src/bun.js/bindings/helpers.h
+++ b/src/bun.js/bindings/helpers.h
@@ -81,7 +81,7 @@ static const WTF::String toString(ZigString str)
         return WTF::String();
     }
     if (UNLIKELY(isTaggedUTF8Ptr(str.ptr))) {
-        return WTF::String::fromUTF8(std::span { untag(str.ptr), str.len });
+        return WTF::String::fromUTF8ReplacingInvalidSequences(std::span { untag(str.ptr), str.len });
     }
 
     if (UNLIKELY(isTaggedExternalPtr(str.ptr))) {
diff --git a/src/bun.js/bindings/isBuiltinModule.cpp b/src/bun.js/bindings/isBuiltinModule.cpp
index ee1bd77a76..1d8484618b 100644
--- a/src/bun.js/bindings/isBuiltinModule.cpp
+++ b/src/bun.js/bindings/isBuiltinModule.cpp
@@ -96,4 +96,4 @@ bool isBuiltinModule(const String& namePossiblyWithNodePrefix)
     return false;
 }
 
-} // namespace Bun
\ No newline at end of file
+} // namespace Bun
diff --git a/src/bun.js/bindings/isBuiltinModule.h b/src/bun.js/bindings/isBuiltinModule.h
index d66f025d11..296dbf402f 100644
--- a/src/bun.js/bindings/isBuiltinModule.h
+++ b/src/bun.js/bindings/isBuiltinModule.h
@@ -1,5 +1,5 @@
 #pragma once
 
 namespace Bun {
-bool isBuiltinModule(const String &namePossiblyWithNodePrefix);
-} // namespace Bun
\ No newline at end of file
+bool isBuiltinModule(const String& namePossiblyWithNodePrefix);
+} // namespace Bun
diff --git a/src/bun.js/bindings/napi.cpp b/src/bun.js/bindings/napi.cpp
index 58c1649092..0c8bdec56d 100644
--- a/src/bun.js/bindings/napi.cpp
+++ b/src/bun.js/bindings/napi.cpp
@@ -8,6 +8,7 @@
 #include "JavaScriptCore/SourceCode.h"
 #include "js_native_api_types.h"
 #include "napi_handle_scope.h"
+#include "napi_type_tag.h"
 
 #include "helpers.h"
 #include <JavaScriptCore/JSObjectInlines.h>
@@ -50,6 +51,7 @@
 #include <JavaScriptCore/JSSourceCode.h>
 #include <JavaScriptCore/JSNativeStdFunction.h>
 #include <JavaScriptCore/BigIntObject.h>
+#include <JavaScriptCore/JSWeakMapInlines.h>
 #include "ScriptExecutionContext.h"
 #include "Strong.h"
 
@@ -64,6 +66,7 @@
 #include "CommonJSModuleRecord.h"
 #include "wtf/text/ASCIIFastPath.h"
 #include "JavaScriptCore/WeakInlines.h"
+#include <JavaScriptCore/BuiltinNames.h>
 
 // #include <iostream>
 using namespace JSC;
@@ -596,15 +599,16 @@ extern "C" napi_status napi_set_property(napi_env env, napi_value target,
 
     auto globalObject = toJS(env);
     auto& vm = globalObject->vm();
-    auto* object = targetValue.getObject();
+    auto scope = DECLARE_CATCH_SCOPE(vm);
+    auto* object = targetValue.toObject(globalObject);
+    RETURN_IF_EXCEPTION(scope, napi_pending_exception);
 
     auto keyProp = toJS(key);
 
-    auto scope = DECLARE_CATCH_SCOPE(vm);
     PutPropertySlot slot(object, false);
 
     Identifier identifier = keyProp.toPropertyKey(globalObject);
-    RETURN_IF_EXCEPTION(scope, napi_generic_failure);
+    RETURN_IF_EXCEPTION(scope, napi_pending_exception);
 
     JSValue jsValue = toJS(value);
 
@@ -635,15 +639,13 @@ extern "C" napi_status napi_has_property(napi_env env, napi_value object,
 
     auto globalObject = toJS(env);
     auto& vm = globalObject->vm();
-    auto* target = toJS(object).getObject();
-    if (!target) {
-        return napi_object_expected;
-    }
+    auto scope = DECLARE_CATCH_SCOPE(vm);
+    auto* target = toJS(object).toObject(globalObject);
+    RETURN_IF_EXCEPTION(scope, napi_pending_exception);
 
     auto keyProp = toJS(key);
-    auto scope = DECLARE_CATCH_SCOPE(vm);
     *result = target->hasProperty(globalObject, keyProp.toPropertyKey(globalObject));
-    RETURN_IF_EXCEPTION(scope, napi_generic_failure);
+    RETURN_IF_EXCEPTION(scope, napi_pending_exception);
 
     scope.clearException();
     return napi_ok;
@@ -691,18 +693,16 @@ extern "C" napi_status napi_get_property(napi_env env, napi_value object,
 
     auto globalObject = toJS(env);
     auto& vm = globalObject->vm();
+    auto scope = DECLARE_CATCH_SCOPE(vm);
 
-    auto* target = toJS(object).getObject();
-    if (!target) {
-        return napi_object_expected;
-    }
+    auto* target = toJS(object).toObject(globalObject);
+    RETURN_IF_EXCEPTION(scope, napi_pending_exception);
     JSC::EnsureStillAliveScope ensureAlive(target);
 
     auto keyProp = toJS(key);
     JSC::EnsureStillAliveScope ensureAlive2(keyProp);
-    auto scope = DECLARE_CATCH_SCOPE(vm);
-    *result = toNapi(target->getIfPropertyExists(globalObject, keyProp.toPropertyKey(globalObject)), globalObject);
-    RETURN_IF_EXCEPTION(scope, napi_generic_failure);
+    *result = toNapi(target->get(globalObject, keyProp.toPropertyKey(globalObject)), globalObject);
+    RETURN_IF_EXCEPTION(scope, napi_pending_exception);
 
     scope.clearException();
     return napi_ok;
@@ -715,16 +715,14 @@ extern "C" napi_status napi_delete_property(napi_env env, napi_value object,
 
     auto globalObject = toJS(env);
     auto& vm = globalObject->vm();
+    auto scope = DECLARE_CATCH_SCOPE(vm);
 
-    auto* target = toJS(object).getObject();
-    if (!target) {
-        return napi_object_expected;
-    }
+    auto* target = toJS(object).toObject(globalObject);
+    RETURN_IF_EXCEPTION(scope, napi_pending_exception);
 
     auto keyProp = toJS(key);
-    auto scope = DECLARE_CATCH_SCOPE(vm);
     auto deleteResult = target->deleteProperty(globalObject, keyProp.toPropertyKey(globalObject));
-    RETURN_IF_EXCEPTION(scope, napi_generic_failure);
+    RETURN_IF_EXCEPTION(scope, napi_pending_exception);
 
     if (LIKELY(result)) {
         *result = deleteResult;
@@ -744,16 +742,14 @@ extern "C" napi_status napi_has_own_property(napi_env env, napi_value object,
 
     auto globalObject = toJS(env);
     auto& vm = globalObject->vm();
+    auto scope = DECLARE_CATCH_SCOPE(vm);
 
-    auto* target = toJS(object).getObject();
-    if (!target) {
-        return napi_object_expected;
-    }
+    auto* target = toJS(object).toObject(globalObject);
+    RETURN_IF_EXCEPTION(scope, napi_pending_exception);
 
     auto keyProp = toJS(key);
-    auto scope = DECLARE_CATCH_SCOPE(vm);
     *result = target->hasOwnProperty(globalObject, JSC::PropertyName(keyProp.toPropertyKey(globalObject)));
-    RETURN_IF_EXCEPTION(scope, napi_generic_failure);
+    RETURN_IF_EXCEPTION(scope, napi_pending_exception);
 
     scope.clearException();
     return napi_ok;
@@ -766,11 +762,10 @@ extern "C" napi_status napi_set_named_property(napi_env env, napi_value object,
     NAPI_PREMABLE
 
     auto globalObject = toJS(env);
-    auto target = toJS(object).getObject();
     auto& vm = globalObject->vm();
-    if (UNLIKELY(!target)) {
-        return napi_object_expected;
-    }
+    auto scope = DECLARE_CATCH_SCOPE(vm);
+    auto target = toJS(object).toObject(globalObject);
+    RETURN_IF_EXCEPTION(scope, napi_pending_exception);
 
     if (UNLIKELY(utf8name == nullptr || !*utf8name || !value)) {
         return napi_invalid_arg;
@@ -783,11 +778,10 @@ extern "C" napi_status napi_set_named_property(napi_env env, napi_value object,
     auto nameStr = WTF::String::fromUTF8({ utf8name, strlen(utf8name) });
     auto identifier = JSC::Identifier::fromString(vm, WTFMove(nameStr));
 
-    auto scope = DECLARE_CATCH_SCOPE(vm);
     PutPropertySlot slot(target, true);
 
     target->put(target, globalObject, identifier, jsValue, slot);
-    RETURN_IF_EXCEPTION(scope, napi_generic_failure);
+    RETURN_IF_EXCEPTION(scope, napi_pending_exception);
     scope.clearException();
     return napi_ok;
 }
@@ -849,18 +843,16 @@ extern "C" napi_status napi_has_named_property(napi_env env, napi_value object,
 
     auto globalObject = toJS(env);
     auto& vm = globalObject->vm();
+    auto scope = DECLARE_CATCH_SCOPE(vm);
 
-    JSObject* target = toJS(object).getObject();
-    if (UNLIKELY(!target)) {
-        return napi_object_expected;
-    }
+    JSObject* target = toJS(object).toObject(globalObject);
+    RETURN_IF_EXCEPTION(scope, napi_pending_exception);
 
     PROPERTY_NAME_FROM_UTF8(name);
 
-    auto scope = DECLARE_CATCH_SCOPE(vm);
     PropertySlot slot(target, PropertySlot::InternalMethodType::HasProperty);
     *result = target->getPropertySlot(globalObject, name, slot);
-    RETURN_IF_EXCEPTION(scope, napi_generic_failure);
+    RETURN_IF_EXCEPTION(scope, napi_pending_exception);
 
     scope.clearException();
     return napi_ok;
@@ -878,16 +870,14 @@ extern "C" napi_status napi_get_named_property(napi_env env, napi_value object,
     auto globalObject = toJS(env);
     auto& vm = globalObject->vm();
 
-    JSObject* target = toJS(object).getObject();
-    if (UNLIKELY(!target)) {
-        return napi_object_expected;
-    }
+    auto scope = DECLARE_CATCH_SCOPE(vm);
+    JSObject* target = toJS(object).toObject(globalObject);
+    RETURN_IF_EXCEPTION(scope, napi_pending_exception);
 
     PROPERTY_NAME_FROM_UTF8(name);
 
-    auto scope = DECLARE_CATCH_SCOPE(vm);
-    *result = toNapi(target->getIfPropertyExists(globalObject, name), globalObject);
-    RETURN_IF_EXCEPTION(scope, napi_generic_failure);
+    *result = toNapi(target->get(globalObject, name), globalObject);
+    RETURN_IF_EXCEPTION(scope, napi_pending_exception);
 
     scope.clearException();
     return napi_ok;
@@ -966,13 +956,14 @@ node_api_create_external_string_utf16(napi_env env,
 
     return napi_ok;
 }
-
+extern "C" size_t Bun__napi_module_register_count;
 extern "C" void napi_module_register(napi_module* mod)
 {
     auto* globalObject = defaultGlobalObject();
     JSC::VM& vm = globalObject->vm();
     auto keyStr = WTF::String::fromUTF8(mod->nm_modname);
     globalObject->napiModuleRegisterCallCount++;
+    Bun__napi_module_register_count++;
     JSValue pendingNapiModule = globalObject->m_pendingNapiModuleAndExports[0].get();
     JSObject* object = (pendingNapiModule && pendingNapiModule.isObject()) ? pendingNapiModule.getObject()
                                                                            : nullptr;
@@ -1014,6 +1005,16 @@ extern "C" void napi_module_register(napi_module* mod)
         return;
     }
 
+    auto* meta = new Bun::NapiModuleMeta(globalObject->m_pendingNapiModuleDlopenHandle);
+
+    // TODO: think about the finalizer here
+    Bun::NapiExternal* napi_external = Bun::NapiExternal::create(vm, globalObject->NapiExternalStructure(), meta, nullptr, nullptr);
+
+    bool success = resultValue.getObject()->putDirect(vm, WebCore::builtinNames(vm).napiDlopenHandlePrivateName(), napi_external, JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly);
+    ASSERT(success);
+
+    globalObject->m_pendingNapiModuleDlopenHandle = nullptr;
+
     // https://github.com/nodejs/node/blob/2eff28fb7a93d3f672f80b582f664a7c701569fb/src/node_api.cc#L734-L742
     // https://github.com/oven-sh/bun/issues/1288
     if (!scope.exception() && strongExportsObject && strongExportsObject.get() != resultValue) {
@@ -1300,52 +1301,65 @@ napi_define_properties(napi_env env, napi_value object, size_t property_count,
     return napi_ok;
 }
 
-static void throwErrorWithCode(JSC::JSGlobalObject* globalObject, const char* msg_utf8, const char* code_utf8, const WTF::Function<JSObject*(JSC::JSGlobalObject*, const WTF::String&)>& createError)
+static JSC::ErrorInstance* createErrorWithCode(JSC::JSGlobalObject* globalObject, const WTF::String& code, const WTF::String& message, JSC::ErrorType type)
 {
+    // no napi functions permit a null message, they must check before calling this function and
+    // return the right error code
+    ASSERT(!message.isNull());
+
     auto& vm = globalObject->vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
 
-    auto message = msg_utf8 ? WTF::String::fromUTF8(msg_utf8) : String();
-    auto code = msg_utf8 ? WTF::String::fromUTF8(code_utf8) : String();
-
-    auto* error = createError(globalObject, message);
-    if (!code.isEmpty()) {
+    // we don't call JSC::createError() as it asserts the message is not an empty string ""
+    auto* error = JSC::ErrorInstance::create(globalObject->vm(), globalObject->errorStructure(type), message, JSValue(), nullptr, RuntimeType::TypeNothing, type);
+    if (!code.isNull()) {
         error->putDirect(vm, WebCore::builtinNames(vm).codePublicName(), JSC::jsString(vm, code), 0);
     }
 
-    scope.throwException(globalObject, Exception::create(vm, error));
+    return error;
 }
 
-static JSValue createErrorForNapi(napi_env env, napi_value code, napi_value msg, const WTF::Function<JSObject*(JSC::JSGlobalObject*, const WTF::String&)>& constructor)
+// used to implement napi_throw_*_error
+static napi_status throwErrorWithCStrings(napi_env env, const char* code_utf8, const char* msg_utf8, JSC::ErrorType type)
 {
     auto* globalObject = toJS(env);
-    JSC::VM& vm = globalObject->vm();
-    auto catchScope = DECLARE_CATCH_SCOPE(vm);
+    auto& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
 
-    JSValue codeValue = toJS(code);
-    WTF::String message;
-
-    if (msg) {
-        JSValue messageValue = toJS(msg);
-        message = messageValue.toWTFString(globalObject);
-        if (catchScope.exception()) {
-            catchScope.clearException();
-            return {};
-        }
+    if (!msg_utf8) {
+        return napi_invalid_arg;
     }
 
-    auto* error = constructor(globalObject, message);
+    WTF::String code = code_utf8 ? WTF::String::fromUTF8(code_utf8) : WTF::String();
+    WTF::String message = WTF::String::fromUTF8(msg_utf8);
 
-    if (codeValue && error) {
-        error->putDirect(vm, WebCore::builtinNames(vm).codePublicName(), codeValue, 0);
+    auto* error = createErrorWithCode(globalObject, code, message, type);
+    scope.throwException(globalObject, error);
+    return napi_ok;
+}
+
+// code must be a string or nullptr (no code)
+// msg must be a string
+// never calls toString, never throws
+static napi_status createErrorWithNapiValues(napi_env env, napi_value code, napi_value message, JSC::ErrorType type, napi_value* result)
+{
+    if (!result || !message) {
+        return napi_invalid_arg;
+    }
+    JSValue js_code = toJS(code);
+    JSValue js_message = toJS(message);
+    if (!js_message.isString() || !(js_code.isEmpty() || js_code.isString())) {
+        return napi_string_expected;
     }
 
-    if (catchScope.exception()) {
-        catchScope.clearException();
-        return {};
-    }
+    auto* globalObject = toJS(env);
 
-    return error;
+    auto wtf_code = js_code.isEmpty() ? WTF::String() : js_code.getString(globalObject);
+    auto wtf_message = js_message.getString(globalObject);
+
+    *result = toNapi(
+        createErrorWithCode(globalObject, wtf_code, wtf_message, type),
+        globalObject);
+    return napi_ok;
 }
 
 extern "C" napi_status napi_throw_error(napi_env env,
@@ -1353,13 +1367,7 @@ extern "C" napi_status napi_throw_error(napi_env env,
     const char* msg)
 {
     NAPI_PREMABLE
-    Zig::GlobalObject* globalObject = toJS(env);
-
-    throwErrorWithCode(globalObject, msg, code, [](JSC::JSGlobalObject* globalObject, const WTF::String& message) {
-        return JSC::createError(globalObject, message);
-    });
-
-    return napi_ok;
+    return throwErrorWithCStrings(env, code, msg, JSC::ErrorType::Error);
 }
 
 extern "C" napi_status napi_create_reference(napi_env env, napi_value value,
@@ -1584,8 +1592,13 @@ extern "C" napi_status napi_get_and_clear_last_exception(napi_env env,
     }
 
     auto globalObject = toJS(env);
-    *result = toNapi(JSC::JSValue(globalObject->vm().lastException()), globalObject);
-    globalObject->vm().clearLastException();
+    auto scope = DECLARE_CATCH_SCOPE(globalObject->vm());
+    if (scope.exception()) {
+        *result = toNapi(JSC::JSValue(scope.exception()->value()), globalObject);
+    } else {
+        *result = toNapi(JSC::jsUndefined(), globalObject);
+    }
+    scope.clearException();
     return napi_ok;
 }
 
@@ -1645,20 +1658,7 @@ extern "C" napi_status node_api_create_syntax_error(napi_env env,
     napi_value* result)
 {
     NAPI_PREMABLE
-    if (UNLIKELY(!result)) {
-        return napi_invalid_arg;
-    }
-
-    auto err = createErrorForNapi(env, code, msg, [](JSC::JSGlobalObject* globalObject, const WTF::String& message) {
-        return JSC::createSyntaxError(globalObject, message);
-    });
-
-    if (UNLIKELY(!err)) {
-        return napi_generic_failure;
-    }
-
-    *result = toNapi(err, toJS(env));
-    return napi_ok;
+    return createErrorWithNapiValues(env, code, msg, JSC::ErrorType::SyntaxError, result);
 }
 
 extern "C" napi_status node_api_throw_syntax_error(napi_env env,
@@ -1666,51 +1666,22 @@ extern "C" napi_status node_api_throw_syntax_error(napi_env env,
     const char* msg)
 {
     NAPI_PREMABLE
-
-    auto globalObject = toJS(env);
-
-    throwErrorWithCode(globalObject, msg, code, [](JSC::JSGlobalObject* globalObject, const WTF::String& message) {
-        return JSC::createSyntaxError(globalObject, message);
-    });
-
-    return napi_ok;
+    return throwErrorWithCStrings(env, code, msg, JSC::ErrorType::SyntaxError);
 }
 
 extern "C" napi_status napi_throw_type_error(napi_env env, const char* code,
     const char* msg)
 {
     NAPI_PREMABLE
-    Zig::GlobalObject* globalObject = toJS(env);
-
-    throwErrorWithCode(globalObject, msg, code, [](JSC::JSGlobalObject* globalObject, const WTF::String& message) {
-        return JSC::createTypeError(globalObject, message);
-    });
-
-    return napi_ok;
+    return throwErrorWithCStrings(env, code, msg, JSC::ErrorType::TypeError);
 }
 
 extern "C" napi_status napi_create_type_error(napi_env env, napi_value code,
     napi_value msg,
     napi_value* result)
 {
-    if (UNLIKELY(!result || !env)) {
-        return napi_invalid_arg;
-    }
-
-    auto err = createErrorForNapi(env, code, msg, [](JSC::JSGlobalObject* globalObject, const WTF::String& message) {
-        if (message.isEmpty()) {
-            return JSC::createTypeError(globalObject);
-        }
-
-        return JSC::createTypeError(globalObject, message);
-    });
-
-    if (UNLIKELY(!err)) {
-        return napi_generic_failure;
-    }
-
-    *result = toNapi(err, toJS(env));
-    return napi_ok;
+    NAPI_PREMABLE
+    return createErrorWithNapiValues(env, code, msg, JSC::ErrorType::TypeError, result);
 }
 
 extern "C" napi_status napi_create_error(napi_env env, napi_value code,
@@ -1718,37 +1689,13 @@ extern "C" napi_status napi_create_error(napi_env env, napi_value code,
     napi_value* result)
 {
     NAPI_PREMABLE
-
-    if (UNLIKELY(!result)) {
-        return napi_invalid_arg;
-    }
-
-    auto err = createErrorForNapi(env, code, msg, [](JSC::JSGlobalObject* globalObject, const WTF::String& message) {
-        if (message.isEmpty()) {
-            return JSC::createError(globalObject, String("Error"_s));
-        }
-
-        return JSC::createError(globalObject, message);
-    });
-
-    if (UNLIKELY(!err)) {
-        return napi_generic_failure;
-    }
-
-    *result = toNapi(err, toJS(env));
-    return napi_ok;
+    return createErrorWithNapiValues(env, code, msg, JSC::ErrorType::Error, result);
 }
 extern "C" napi_status napi_throw_range_error(napi_env env, const char* code,
     const char* msg)
 {
     NAPI_PREMABLE
-    Zig::GlobalObject* globalObject = toJS(env);
-
-    throwErrorWithCode(globalObject, msg, code, [](JSC::JSGlobalObject* globalObject, const WTF::String& message) {
-        return JSC::createRangeError(globalObject, message);
-    });
-
-    return napi_ok;
+    return throwErrorWithCStrings(env, code, msg, JSC::ErrorType::RangeError);
 }
 
 extern "C" napi_status napi_object_freeze(napi_env env, napi_value object_value)
@@ -1813,24 +1760,7 @@ extern "C" napi_status napi_create_range_error(napi_env env, napi_value code,
     napi_value* result)
 {
     NAPI_PREMABLE
-
-    if (UNLIKELY(!result)) {
-        return napi_invalid_arg;
-    }
-
-    auto err = createErrorForNapi(env, code, msg, [](JSC::JSGlobalObject* globalObject, const WTF::String& message) {
-        if (message.isEmpty()) {
-            return JSC::createRangeError(globalObject, String("Range error"_s));
-        }
-
-        return JSC::createRangeError(globalObject, message);
-    });
-
-    if (UNLIKELY(!err)) {
-        return napi_generic_failure;
-    }
-    *result = toNapi(err, toJS(env));
-    return napi_ok;
+    return createErrorWithNapiValues(env, code, msg, JSC::ErrorType::RangeError, result);
 }
 
 extern "C" napi_status napi_get_new_target(napi_env env,
@@ -2243,11 +2173,90 @@ extern "C" napi_status napi_get_value_double(napi_env env, napi_value value,
 
     auto scope = DECLARE_CATCH_SCOPE(globalObject->vm());
 
+    // should never throw as we know it is a number
     *result = jsValue.toNumber(globalObject);
+    scope.assertNoException();
 
-    if (UNLIKELY(scope.exception())) {
-        scope.clearException();
-        return napi_generic_failure;
+    return napi_ok;
+}
+
+extern "C" napi_status napi_get_value_int32(napi_env env, napi_value value, int32_t* result)
+{
+    NAPI_PREMABLE
+
+    auto* globalObject = toJS(env);
+    JSC::JSValue jsValue = toJS(value);
+
+    if (UNLIKELY(result == nullptr || !globalObject)) {
+        return napi_invalid_arg;
+    }
+
+    if (UNLIKELY(!jsValue || !jsValue.isNumber())) {
+        return napi_number_expected;
+    }
+
+    auto scope = DECLARE_CATCH_SCOPE(globalObject->vm());
+
+    // should never throw as we know it is a number
+    *result = jsValue.toInt32(globalObject);
+    scope.assertNoException();
+
+    return napi_ok;
+}
+
+extern "C" napi_status napi_get_value_uint32(napi_env env, napi_value value, uint32_t* result)
+{
+    NAPI_PREMABLE
+
+    auto* globalObject = toJS(env);
+    JSC::JSValue jsValue = toJS(value);
+
+    if (UNLIKELY(result == nullptr || !globalObject)) {
+        return napi_invalid_arg;
+    }
+
+    if (UNLIKELY(!jsValue || !jsValue.isNumber())) {
+        return napi_number_expected;
+    }
+
+    auto scope = DECLARE_CATCH_SCOPE(globalObject->vm());
+
+    // should never throw as we know it is a number
+    *result = jsValue.toUInt32(globalObject);
+    scope.assertNoException();
+
+    return napi_ok;
+}
+
+extern "C" napi_status napi_get_value_int64(napi_env env, napi_value value, int64_t* result)
+{
+    NAPI_PREMABLE
+
+    auto* globalObject = toJS(env);
+    JSC::JSValue jsValue = toJS(value);
+
+    if (UNLIKELY(result == nullptr || !globalObject)) {
+        return napi_invalid_arg;
+    }
+
+    if (UNLIKELY(!jsValue || !jsValue.isNumber())) {
+        return napi_number_expected;
+    }
+
+    double js_number = jsValue.asNumber();
+    if (isfinite(js_number)) {
+        // upper is 2^63 exactly, not 2^63-1, as the latter can't be represented exactly
+        constexpr double lower = std::numeric_limits<int64_t>::min(), upper = 1ull << 63;
+        if (js_number >= upper) {
+            *result = std::numeric_limits<int64_t>::max();
+        } else if (js_number <= lower) {
+            *result = std::numeric_limits<int64_t>::min();
+        } else {
+            // safe
+            *result = static_cast<int64_t>(js_number);
+        }
+    } else {
+        *result = 0;
     }
 
     return napi_ok;
@@ -2543,7 +2552,8 @@ extern "C" napi_status napi_get_value_external(napi_env env, napi_value value,
         return napi_invalid_arg;
     }
 
-    auto* external = jsDynamicCast<Bun::NapiExternal*>(toJS(value));
+    JSValue jsval = toJS(value);
+    auto* external = jsDynamicCast<Bun::NapiExternal*>(jsval);
     if (UNLIKELY(!external)) {
         return napi_invalid_arg;
     }
@@ -2593,9 +2603,15 @@ extern "C" napi_status napi_run_script(napi_env env, napi_value script,
 
     JSC::SourceCode sourceCode = makeSource(code, SourceOrigin(), SourceTaintedOrigin::Untainted);
 
-    JSValue value = JSC::evaluate(globalObject, sourceCode, globalObject->globalThis());
+    NakedPtr<Exception> returnedException;
+    JSValue value = JSC::evaluate(globalObject, sourceCode, globalObject->globalThis(), returnedException);
 
-    if (throwScope.exception() || value.isEmpty()) {
+    if (returnedException) {
+        throwScope.throwException(globalObject, returnedException);
+        RELEASE_AND_RETURN(throwScope, napi_generic_failure);
+    }
+
+    if (value.isEmpty()) {
         return napi_generic_failure;
     }
 
@@ -2773,3 +2789,50 @@ extern "C" napi_status napi_call_function(napi_env env, napi_value recv_napi,
 
     RELEASE_AND_RETURN(scope, napi_ok);
 }
+
+extern "C" napi_status napi_type_tag_object(napi_env env, napi_value value, const napi_type_tag* type_tag)
+{
+    NAPI_PREMABLE
+    if (!env || !value || !type_tag) {
+        return napi_invalid_arg;
+    }
+    Zig::GlobalObject* globalObject = toJS(env);
+    JSObject* js_object = toJS(value).getObject();
+    if (!js_object) {
+        return napi_object_expected;
+    }
+
+    auto* existing_tag = jsDynamicCast<Bun::NapiTypeTag*>(globalObject->napiTypeTags()->get(js_object));
+    // cannot tag an object that is already tagged
+    if (existing_tag) {
+        return napi_invalid_arg;
+    }
+
+    auto& vm = globalObject->vm();
+    auto* new_tag = Bun::NapiTypeTag::create(vm, globalObject->NapiTypeTagStructure(), *type_tag);
+    globalObject->napiTypeTags()->set(vm, js_object, new_tag);
+    return napi_ok;
+}
+
+extern "C" napi_status napi_check_object_type_tag(napi_env env, napi_value value, const napi_type_tag* type_tag, bool* result)
+{
+    NAPI_PREMABLE
+    if (!env || !value || !type_tag) {
+        return napi_invalid_arg;
+    }
+    Zig::GlobalObject* globalObject = toJS(env);
+    JSObject* js_object = toJS(value).getObject();
+    if (!js_object) {
+        return napi_object_expected;
+    }
+
+    bool match = false;
+    auto* found_tag = jsDynamicCast<Bun::NapiTypeTag*>(globalObject->napiTypeTags()->get(js_object));
+    if (found_tag && found_tag->matches(*type_tag)) {
+        match = true;
+    }
+    if (LIKELY(result)) {
+        *result = match;
+    }
+    return napi_ok;
+}
diff --git a/src/bun.js/bindings/napi.h b/src/bun.js/bindings/napi.h
index e78badd495..a26022c1e8 100644
--- a/src/bun.js/bindings/napi.h
+++ b/src/bun.js/bindings/napi.h
@@ -7,7 +7,7 @@
 #include "headers-handwritten.h"
 #include "BunClientData.h"
 #include <JavaScriptCore/CallFrame.h>
-#include "js_native_api_types.h"
+#include "js_native_api.h"
 #include <JavaScriptCore/JSWeakValue.h>
 #include "JSFFIFunction.h"
 #include "ZigGlobalObject.h"
diff --git a/src/bun.js/bindings/napi_external.cpp b/src/bun.js/bindings/napi_external.cpp
index 3780ebc210..f6925d9992 100644
--- a/src/bun.js/bindings/napi_external.cpp
+++ b/src/bun.js/bindings/napi_external.cpp
@@ -19,4 +19,4 @@ void NapiExternal::destroy(JSC::JSCell* cell)
 
 const ClassInfo NapiExternal::s_info = { "External"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(NapiExternal) };
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/napi_external.h b/src/bun.js/bindings/napi_external.h
index a9e38676dc..e755dc94d0 100644
--- a/src/bun.js/bindings/napi_external.h
+++ b/src/bun.js/bindings/napi_external.h
@@ -12,6 +12,11 @@ namespace Bun {
 using namespace JSC;
 using namespace WebCore;
 
+typedef struct {
+    /// The result of call to dlopen to load the module
+    void* dlopenHandle;
+} NapiModuleMeta;
+
 class NapiExternal : public JSC::JSDestructibleObject {
     using Base = JSC::JSDestructibleObject;
 
@@ -100,4 +105,4 @@ public:
 #endif
 };
 
-} // namespace Zig
\ No newline at end of file
+} // namespace Zig
diff --git a/src/bun.js/bindings/napi_handle_scope.cpp b/src/bun.js/bindings/napi_handle_scope.cpp
index b23d8bdfde..ed3af6e618 100644
--- a/src/bun.js/bindings/napi_handle_scope.cpp
+++ b/src/bun.js/bindings/napi_handle_scope.cpp
@@ -78,7 +78,7 @@ NapiHandleScopeImpl::Slot* NapiHandleScopeImpl::reserveSlot()
     return &m_storage.last();
 }
 
-NapiHandleScopeImpl* NapiHandleScope::push(Zig::GlobalObject* globalObject, bool escapable)
+NapiHandleScopeImpl* NapiHandleScope::open(Zig::GlobalObject* globalObject, bool escapable)
 {
     auto& vm = globalObject->vm();
     // Do not create a new handle scope while a finalizer is in progress
@@ -101,8 +101,12 @@ NapiHandleScopeImpl* NapiHandleScope::push(Zig::GlobalObject* globalObject, bool
     return impl;
 }
 
-void NapiHandleScope::pop(Zig::GlobalObject* globalObject, NapiHandleScopeImpl* current)
+void NapiHandleScope::close(Zig::GlobalObject* globalObject, NapiHandleScopeImpl* current)
 {
+    // napi handle scopes may be null pointers if created inside a finalizer
+    if (!current) {
+        return;
+    }
     RELEASE_ASSERT_WITH_MESSAGE(current == globalObject->m_currentNapiHandleScopeImpl.get(),
         "Unbalanced napi_handle_scope opens and closes");
     if (auto* parent = current->parent()) {
@@ -114,23 +118,23 @@ void NapiHandleScope::pop(Zig::GlobalObject* globalObject, NapiHandleScopeImpl*
 
 NapiHandleScope::NapiHandleScope(Zig::GlobalObject* globalObject)
     : m_globalObject(globalObject)
-    , m_impl(NapiHandleScope::push(globalObject, false))
+    , m_impl(NapiHandleScope::open(globalObject, false))
 {
 }
 
 NapiHandleScope::~NapiHandleScope()
 {
-    NapiHandleScope::pop(m_globalObject, m_impl);
+    NapiHandleScope::close(m_globalObject, m_impl);
 }
 
-extern "C" NapiHandleScopeImpl* NapiHandleScope__push(Zig::GlobalObject* globalObject, bool escapable)
+extern "C" NapiHandleScopeImpl* NapiHandleScope__open(Zig::GlobalObject* globalObject, bool escapable)
 {
-    return NapiHandleScope::push(globalObject, escapable);
+    return NapiHandleScope::open(globalObject, escapable);
 }
 
-extern "C" void NapiHandleScope__pop(Zig::GlobalObject* globalObject, NapiHandleScopeImpl* current)
+extern "C" void NapiHandleScope__close(Zig::GlobalObject* globalObject, NapiHandleScopeImpl* current)
 {
-    return NapiHandleScope::pop(globalObject, current);
+    return NapiHandleScope::close(globalObject, current);
 }
 
 extern "C" void NapiHandleScope__append(Zig::GlobalObject* globalObject, JSC::EncodedJSValue value)
diff --git a/src/bun.js/bindings/napi_handle_scope.h b/src/bun.js/bindings/napi_handle_scope.h
index 891dbbb9de..851d5006a5 100644
--- a/src/bun.js/bindings/napi_handle_scope.h
+++ b/src/bun.js/bindings/napi_handle_scope.h
@@ -61,18 +61,18 @@ private:
     NapiHandleScopeImpl(JSC::VM& vm, JSC::Structure* structure, NapiHandleScopeImpl* parent, bool escapable);
 };
 
-// Wrapper class used to push a new handle scope and pop it when this instance goes out of scope
+// Wrapper class used to open a new handle scope and close it when this instance goes out of scope
 class NapiHandleScope {
 public:
     NapiHandleScope(Zig::GlobalObject* globalObject);
     ~NapiHandleScope();
 
     // Create a new handle scope in the given environment
-    static NapiHandleScopeImpl* push(Zig::GlobalObject* globalObject, bool escapable);
+    static NapiHandleScopeImpl* open(Zig::GlobalObject* globalObject, bool escapable);
 
-    // Pop the most recently created handle scope in the given environment and restore the old one.
+    // Closes the most recently created handle scope in the given environment and restores the old one.
     // Asserts that `current` is the active handle scope.
-    static void pop(Zig::GlobalObject* globalObject, NapiHandleScopeImpl* current);
+    static void close(Zig::GlobalObject* globalObject, NapiHandleScopeImpl* current);
 
 private:
     NapiHandleScopeImpl* m_impl;
@@ -80,11 +80,11 @@ private:
 };
 
 // Create a new handle scope in the given environment
-extern "C" NapiHandleScopeImpl* NapiHandleScope__push(Zig::GlobalObject* globalObject, bool escapable);
+extern "C" NapiHandleScopeImpl* NapiHandleScope__open(Zig::GlobalObject* globalObject, bool escapable);
 
 // Pop the most recently created handle scope in the given environment and restore the old one.
 // Asserts that `current` is the active handle scope.
-extern "C" void NapiHandleScope__pop(Zig::GlobalObject* globalObject, NapiHandleScopeImpl* current);
+extern "C" void NapiHandleScope__close(Zig::GlobalObject* globalObject, NapiHandleScopeImpl* current);
 
 // Store a value in the active handle scope in the given environment
 extern "C" void NapiHandleScope__append(Zig::GlobalObject* globalObject, JSC::EncodedJSValue value);
diff --git a/src/bun.js/bindings/napi_type_tag.cpp b/src/bun.js/bindings/napi_type_tag.cpp
new file mode 100644
index 0000000000..b05385b18c
--- /dev/null
+++ b/src/bun.js/bindings/napi_type_tag.cpp
@@ -0,0 +1,28 @@
+#include "napi_type_tag.h"
+
+#include "ZigGlobalObject.h"
+
+namespace Bun {
+
+// for CREATE_METHOD_TABLE
+namespace JSCastingHelpers = JSC::JSCastingHelpers;
+
+const JSC::ClassInfo NapiTypeTag::s_info = {
+    "NapiTypeTag"_s,
+    nullptr,
+    nullptr,
+    nullptr,
+    CREATE_METHOD_TABLE(NapiTypeTag)
+};
+
+NapiTypeTag* NapiTypeTag::create(JSC::VM& vm,
+    JSC::Structure* structure,
+    const napi_type_tag& c_tag)
+{
+    NapiTypeTag* tag = new (NotNull, JSC::allocateCell<NapiTypeTag>(vm))
+        NapiTypeTag(vm, structure, c_tag);
+    tag->finishCreation(vm);
+    return tag;
+}
+
+} // namespace Bun
diff --git a/src/bun.js/bindings/napi_type_tag.h b/src/bun.js/bindings/napi_type_tag.h
new file mode 100644
index 0000000000..4f5ff63b4d
--- /dev/null
+++ b/src/bun.js/bindings/napi_type_tag.h
@@ -0,0 +1,56 @@
+#pragma once
+
+#include "BunClientData.h"
+#include "root.h"
+#include "napi.h"
+
+namespace Bun {
+
+// An object used to store the 128-bit type UUID provided by a native module in napi_type_tag_object.
+// This is a JSCell because we store it in a weak map
+class NapiTypeTag : public JSC::JSCell {
+public:
+    using Base = JSC::JSCell;
+
+    static NapiTypeTag* create(
+        JSC::VM& vm,
+        JSC::Structure* structure,
+        const napi_type_tag& tag);
+
+    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
+    {
+        return JSC::Structure::create(vm, globalObject, JSC::jsNull(), JSC::TypeInfo(JSC::CellType, StructureFlags), info(), 0, 0);
+    }
+
+    template<typename, JSC::SubspaceAccess mode>
+    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+    {
+        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+            return nullptr;
+        return WebCore::subspaceForImpl<NapiTypeTag, WebCore::UseCustomHeapCellType::No>(
+            vm,
+            [](auto& spaces) { return spaces.m_clientSubspaceForNapiTypeTag.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForNapiTypeTag = std::forward<decltype(space)>(space); },
+            [](auto& spaces) { return spaces.m_subspaceForNapiTypeTag.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_subspaceForNapiTypeTag = std::forward<decltype(space)>(space); });
+    }
+
+    DECLARE_INFO;
+
+    // Returns true if this tag is the same as the other tag
+    bool matches(const napi_type_tag& other) const
+    {
+        return m_tag.lower == other.lower && m_tag.upper == other.upper;
+    }
+
+private:
+    NapiTypeTag(JSC::VM& vm, JSC::Structure* structure, const napi_type_tag& tag)
+        : Base(vm, structure)
+        , m_tag(tag)
+    {
+    }
+
+    napi_type_tag m_tag;
+};
+
+} // namespace Bun
diff --git a/src/bun.js/bindings/shimmer.zig b/src/bun.js/bindings/shimmer.zig
index 307294918e..79c3dec3d4 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 795159e49f..39170e8980 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/spawn.cpp b/src/bun.js/bindings/spawn.cpp
index 04570f4bab..daa0f782c3 100644
--- a/src/bun.js/bindings/spawn.cpp
+++ b/src/bun.js/bindings/spawn.cpp
@@ -19,4 +19,4 @@ extern "C" int posix_spawnattr_reset_signals(posix_spawnattr_t* attr)
     return 0;
 }
 
-#endif
\ No newline at end of file
+#endif
diff --git a/src/bun.js/bindings/sqlite/JSSQLStatement.cpp b/src/bun.js/bindings/sqlite/JSSQLStatement.cpp
index a88b82845e..be8ff4b90b 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)
 {
@@ -278,6 +278,7 @@ JSC_DECLARE_HOST_FUNCTION(jsSQLStatementExecuteStatementFunction);
 JSC_DECLARE_HOST_FUNCTION(jsSQLStatementExecuteStatementFunctionRun);
 JSC_DECLARE_HOST_FUNCTION(jsSQLStatementExecuteStatementFunctionGet);
 JSC_DECLARE_HOST_FUNCTION(jsSQLStatementExecuteStatementFunctionAll);
+JSC_DECLARE_HOST_FUNCTION(jsSQLStatementExecuteStatementFunctionIterate);
 JSC_DECLARE_HOST_FUNCTION(jsSQLStatementExecuteStatementFunctionRows);
 
 JSC_DECLARE_CUSTOM_GETTER(jsSqlStatementGetColumnNames);
@@ -537,6 +538,7 @@ static const HashTableValue JSSQLStatementPrototypeTableValues[] = {
     { "run"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsSQLStatementExecuteStatementFunctionRun, 1 } },
     { "get"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsSQLStatementExecuteStatementFunctionGet, 1 } },
     { "all"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsSQLStatementExecuteStatementFunctionAll, 1 } },
+    { "iterate"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsSQLStatementExecuteStatementFunctionIterate, 1 } },
     { "as"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsSQLStatementSetPrototypeFunction, 1 } },
     { "values"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsSQLStatementExecuteStatementFunctionRows, 1 } },
     { "finalize"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsSQLStatementFunctionFinalize, 0 } },
@@ -1950,6 +1952,57 @@ JSC_DEFINE_HOST_FUNCTION(jsSQLStatementSetPrototypeFunction, (JSGlobalObject * l
     return JSValue::encode(jsUndefined());
 }
 
+JSC_DEFINE_HOST_FUNCTION(jsSQLStatementExecuteStatementFunctionIterate, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame* callFrame))
+{
+    JSC::VM& vm = lexicalGlobalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    auto castedThis = jsDynamicCast<JSSQLStatement*>(callFrame->thisValue());
+
+    CHECK_THIS
+
+    auto* stmt = castedThis->stmt;
+    CHECK_PREPARED
+
+    int busy = sqlite3_stmt_busy(stmt);
+    if (!busy) {
+        int statusCode = sqlite3_reset(stmt);
+        if (UNLIKELY(statusCode != SQLITE_OK)) {
+            throwException(lexicalGlobalObject, scope, createSQLiteError(lexicalGlobalObject, castedThis->version_db->db));
+            return {};
+        }
+    }
+
+    if (callFrame->argumentCount() > 0) {
+        auto arg0 = callFrame->argument(0);
+        DO_REBIND(arg0);
+    }
+
+    int status = sqlite3_step(stmt);
+    if (!sqlite3_stmt_readonly(stmt)) {
+        castedThis->version_db->version++;
+    }
+
+    if (!castedThis->hasExecuted || castedThis->need_update()) {
+        initializeColumnNames(lexicalGlobalObject, castedThis);
+    }
+
+    JSValue result = jsNull();
+    if (status == SQLITE_ROW) {
+        bool useBigInt64 = castedThis->useBigInt64;
+
+        result = useBigInt64 ? constructResultObject<true>(lexicalGlobalObject, castedThis)
+                             : constructResultObject<false>(lexicalGlobalObject, castedThis);
+    }
+
+    if (status == SQLITE_DONE || status == SQLITE_OK || status == SQLITE_ROW) {
+        RELEASE_AND_RETURN(scope, JSValue::encode(result));
+    } else {
+        throwException(lexicalGlobalObject, scope, createSQLiteError(lexicalGlobalObject, castedThis->version_db->db));
+        sqlite3_reset(stmt);
+        return {};
+    }
+}
+
 JSC_DEFINE_HOST_FUNCTION(jsSQLStatementExecuteStatementFunctionAll, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame* callFrame))
 {
     JSC::VM& vm = lexicalGlobalObject->vm();
diff --git a/src/bun.js/bindings/sqlite/lazy_sqlite3.h b/src/bun.js/bindings/sqlite/lazy_sqlite3.h
index 5b2855776a..400adbfbc8 100644
--- a/src/bun.js/bindings/sqlite/lazy_sqlite3.h
+++ b/src/bun.js/bindings/sqlite/lazy_sqlite3.h
@@ -90,6 +90,7 @@ typedef int (*lazy_sqlite3_deserialize_type)(
 );
 
 typedef int (*lazy_sqlite3_stmt_readonly_type)(sqlite3_stmt* pStmt);
+typedef int (*lazy_sqlite3_stmt_busy_type)(sqlite3_stmt* pStmt);
 typedef int (*lazy_sqlite3_compileoption_used_type)(const char* zOptName);
 typedef int64_t (*lazy_sqlite3_last_insert_rowid_type)(sqlite3* db);
 
@@ -135,6 +136,7 @@ static lazy_sqlite3_malloc64_type lazy_sqlite3_malloc64;
 static lazy_sqlite3_serialize_type lazy_sqlite3_serialize;
 static lazy_sqlite3_deserialize_type lazy_sqlite3_deserialize;
 static lazy_sqlite3_stmt_readonly_type lazy_sqlite3_stmt_readonly;
+static lazy_sqlite3_stmt_busy_type lazy_sqlite3_stmt_busy;
 static lazy_sqlite3_compileoption_used_type lazy_sqlite3_compileoption_used;
 static lazy_sqlite3_config_type lazy_sqlite3_config;
 static lazy_sqlite3_extended_result_codes_type lazy_sqlite3_extended_result_codes;
@@ -185,6 +187,7 @@ static lazy_sqlite3_last_insert_rowid_type lazy_sqlite3_last_insert_rowid;
 #define sqlite3_serialize lazy_sqlite3_serialize
 #define sqlite3_deserialize lazy_sqlite3_deserialize
 #define sqlite3_stmt_readonly lazy_sqlite3_stmt_readonly
+#define sqlite3_stmt_busy lazy_sqlite3_stmt_busy
 #define sqlite3_column_int64 lazy_sqlite3_column_int64
 #define sqlite3_compileoption_used lazy_sqlite3_compileoption_used
 #define sqlite3_config lazy_sqlite3_config
@@ -270,6 +273,7 @@ static int lazyLoadSQLite()
     lazy_sqlite3_deserialize = (lazy_sqlite3_deserialize_type)dlsym(sqlite3_handle, "sqlite3_deserialize");
     lazy_sqlite3_malloc64 = (lazy_sqlite3_malloc64_type)dlsym(sqlite3_handle, "sqlite3_malloc64");
     lazy_sqlite3_stmt_readonly = (lazy_sqlite3_stmt_readonly_type)dlsym(sqlite3_handle, "sqlite3_stmt_readonly");
+    lazy_sqlite3_stmt_busy = (lazy_sqlite3_stmt_busy_type)dlsym(sqlite3_handle, "sqlite3_stmt_busy");
     lazy_sqlite3_compileoption_used = (lazy_sqlite3_compileoption_used_type)dlsym(sqlite3_handle, "sqlite3_compileoption_used");
     lazy_sqlite3_config = (lazy_sqlite3_config_type)dlsym(sqlite3_handle, "sqlite3_config");
     lazy_sqlite3_extended_result_codes = (lazy_sqlite3_extended_result_codes_type)dlsym(sqlite3_handle, "sqlite3_extended_result_codes");
diff --git a/src/bun.js/bindings/sqlite/sqlite3.c b/src/bun.js/bindings/sqlite/sqlite3.c
index 6e6dc8a6c8..13308b3c49 100644
--- a/src/bun.js/bindings/sqlite/sqlite3.c
+++ b/src/bun.js/bindings/sqlite/sqlite3.c
@@ -1,6 +1,7 @@
+// clang-format off
 /******************************************************************************
 ** This file is an amalgamation of many separate C source files from SQLite
-** version 3.45.0.  By combining all the individual C code files into this
+** version 3.47.1.  By combining all the individual C code files into this
 ** single large file, the entire code can be compiled as a single translation
 ** unit.  This allows many compilers to do optimizations that would not be
 ** possible if the files were compiled separately.  Performance improvements
@@ -18,7 +19,7 @@
 ** separate file. This file contains only code for the core SQLite library.
 **
 ** The content in this amalgamation comes from Fossil check-in
-** 1066602b2b1976fe58b5150777cced894af1.
+** b95d11e958643b969c47a8e5857f3793b9e6.
 */
 #define SQLITE_CORE 1
 #define SQLITE_AMALGAMATION 1
@@ -256,10 +257,13 @@
 /*
 ** Macro to disable warnings about missing "break" at the end of a "case".
 */
-#if GCC_VERSION>=7000000
-# define deliberate_fall_through __attribute__((fallthrough));
-#else
-# define deliberate_fall_through
+#if defined(__has_attribute)
+#  if __has_attribute(fallthrough)
+#    define deliberate_fall_through __attribute__((fallthrough));
+#  endif
+#endif
+#if !defined(deliberate_fall_through)
+#  define deliberate_fall_through
 #endif
 
 /*
@@ -459,9 +463,9 @@ extern "C" {
 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
 ** [sqlite_version()] and [sqlite_source_id()].
 */
-#define SQLITE_VERSION        "3.45.0"
-#define SQLITE_VERSION_NUMBER 3045000
-#define SQLITE_SOURCE_ID      "2024-01-15 17:01:13 1066602b2b1976fe58b5150777cced894af17c803e068f5918390d6915b46e1d"
+#define SQLITE_VERSION        "3.47.1"
+#define SQLITE_VERSION_NUMBER 3047001
+#define SQLITE_SOURCE_ID      "2024-11-25 12:07:48 b95d11e958643b969c47a8e5857f3793b9e69700b8f1469371386369a26e577e"
 
 /*
 ** CAPI3REF: Run-Time Library Version Numbers
@@ -733,6 +737,8 @@ typedef int (*sqlite3_callback)(void*,int,char**, char**);
 **      the 1st parameter to sqlite3_exec() while sqlite3_exec() is running.
 ** <li> The application must not modify the SQL statement text passed into
 **      the 2nd parameter of sqlite3_exec() while sqlite3_exec() is running.
+** <li> The application must not dereference the arrays or string pointers
+**       passed as the 3rd and 4th callback parameters after it returns.
 ** </ul>
 */
 SQLITE_API int sqlite3_exec(
@@ -963,6 +969,13 @@ SQLITE_API int sqlite3_exec(
 ** filesystem supports doing multiple write operations atomically when those
 ** write operations are bracketed by [SQLITE_FCNTL_BEGIN_ATOMIC_WRITE] and
 ** [SQLITE_FCNTL_COMMIT_ATOMIC_WRITE].
+**
+** The SQLITE_IOCAP_SUBPAGE_READ property means that it is ok to read
+** from the database file in amounts that are not a multiple of the
+** page size and that do not begin at a page boundary.  Without this
+** property, SQLite is careful to only do full-page reads and write
+** on aligned pages, with the one exception that it will do a sub-page
+** read of the first page to access the database header.
 */
 #define SQLITE_IOCAP_ATOMIC                 0x00000001
 #define SQLITE_IOCAP_ATOMIC512              0x00000002
@@ -979,6 +992,7 @@ SQLITE_API int sqlite3_exec(
 #define SQLITE_IOCAP_POWERSAFE_OVERWRITE    0x00001000
 #define SQLITE_IOCAP_IMMUTABLE              0x00002000
 #define SQLITE_IOCAP_BATCH_ATOMIC           0x00004000
+#define SQLITE_IOCAP_SUBPAGE_READ           0x00008000
 
 /*
 ** CAPI3REF: File Locking Levels
@@ -1075,16 +1089,16 @@ struct sqlite3_file {
 ** </ul>
 ** xLock() upgrades the database file lock.  In other words, xLock() moves the
 ** database file lock in the direction NONE toward EXCLUSIVE. The argument to
-** xLock() is always on of SHARED, RESERVED, PENDING, or EXCLUSIVE, never
+** xLock() is always one of SHARED, RESERVED, PENDING, or EXCLUSIVE, never
 ** SQLITE_LOCK_NONE.  If the database file lock is already at or above the
 ** requested lock, then the call to xLock() is a no-op.
 ** xUnlock() downgrades the database file lock to either SHARED or NONE.
-*  If the lock is already at or below the requested lock state, then the call
+** If the lock is already at or below the requested lock state, then the call
 ** to xUnlock() is a no-op.
 ** The xCheckReservedLock() method checks whether any database connection,
 ** either in this process or in some other process, is holding a RESERVED,
-** PENDING, or EXCLUSIVE lock on the file.  It returns true
-** if such a lock exists and false otherwise.
+** PENDING, or EXCLUSIVE lock on the file.  It returns, via its output
+** pointer parameter, true if such a lock exists and false otherwise.
 **
 ** The xFileControl() method is a generic interface that allows custom
 ** VFS implementations to directly control an open file using the
@@ -1125,6 +1139,7 @@ struct sqlite3_file {
 ** <li> [SQLITE_IOCAP_POWERSAFE_OVERWRITE]
 ** <li> [SQLITE_IOCAP_IMMUTABLE]
 ** <li> [SQLITE_IOCAP_BATCH_ATOMIC]
+** <li> [SQLITE_IOCAP_SUBPAGE_READ]
 ** </ul>
 **
 ** The SQLITE_IOCAP_ATOMIC property means that all writes of
@@ -2454,6 +2469,22 @@ struct sqlite3_mem_methods {
 ** configuration setting is never used, then the default maximum is determined
 ** by the [SQLITE_MEMDB_DEFAULT_MAXSIZE] compile-time option.  If that
 ** compile-time option is not set, then the default maximum is 1073741824.
+**
+** [[SQLITE_CONFIG_ROWID_IN_VIEW]]
+** <dt>SQLITE_CONFIG_ROWID_IN_VIEW
+** <dd>The SQLITE_CONFIG_ROWID_IN_VIEW option enables or disables the ability
+** for VIEWs to have a ROWID.  The capability can only be enabled if SQLite is
+** compiled with -DSQLITE_ALLOW_ROWID_IN_VIEW, in which case the capability
+** defaults to on.  This configuration option queries the current setting or
+** changes the setting to off or on.  The argument is a pointer to an integer.
+** If that integer initially holds a value of 1, then the ability for VIEWs to
+** have ROWIDs is activated.  If the integer initially holds zero, then the
+** ability is deactivated.  Any other initial value for the integer leaves the
+** setting unchanged.  After changes, if any, the integer is written with
+** a 1 or 0, if the ability for VIEWs to have ROWIDs is on or off.  If SQLite
+** is compiled without -DSQLITE_ALLOW_ROWID_IN_VIEW (which is the usual and
+** recommended case) then the integer is always filled with zero, regardless
+** if its initial value.
 ** </dl>
 */
 #define SQLITE_CONFIG_SINGLETHREAD         1  /* nil */
@@ -2485,6 +2516,7 @@ struct sqlite3_mem_methods {
 #define SQLITE_CONFIG_SMALL_MALLOC        27  /* boolean */
 #define SQLITE_CONFIG_SORTERREF_SIZE      28  /* int nByte */
 #define SQLITE_CONFIG_MEMDB_MAXSIZE       29  /* sqlite3_int64 */
+#define SQLITE_CONFIG_ROWID_IN_VIEW       30  /* int* */
 
 /*
 ** CAPI3REF: Database Connection Configuration Options
@@ -3599,8 +3631,8 @@ SQLITE_API int sqlite3_set_authorizer(
 #define SQLITE_RECURSIVE            33   /* NULL            NULL            */
 
 /*
-** CAPI3REF: Tracing And Profiling Functions
-** METHOD: sqlite3
+** CAPI3REF: Deprecated Tracing And Profiling Functions
+** DEPRECATED
 **
 ** These routines are deprecated. Use the [sqlite3_trace_v2()] interface
 ** instead of the routines described here.
@@ -3864,8 +3896,8 @@ SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
 **
 ** [[OPEN_EXRESCODE]] ^(<dt>[SQLITE_OPEN_EXRESCODE]</dt>
 ** <dd>The database connection comes up in "extended result code mode".
-** In other words, the database behaves has if
-** [sqlite3_extended_result_codes(db,1)] where called on the database
+** In other words, the database behaves as if
+** [sqlite3_extended_result_codes(db,1)] were called on the database
 ** connection as soon as the connection is created. In addition to setting
 ** the extended result code mode, this flag also causes [sqlite3_open_v2()]
 ** to return an extended result code.</dd>
@@ -4516,13 +4548,17 @@ SQLITE_API int sqlite3_limit(sqlite3*, int id, int newVal);
 ** and sqlite3_prepare16_v3() use UTF-16.
 **
 ** ^If the nByte argument is negative, then zSql is read up to the
-** first zero terminator. ^If nByte is positive, then it is the
-** number of bytes read from zSql.  ^If nByte is zero, then no prepared
+** first zero terminator. ^If nByte is positive, then it is the maximum
+** number of bytes read from zSql.  When nByte is positive, zSql is read
+** up to the first zero terminator or until the nByte bytes have been read,
+** whichever comes first.  ^If nByte is zero, then no prepared
 ** statement is generated.
 ** If the caller knows that the supplied string is nul-terminated, then
 ** there is a small performance advantage to passing an nByte parameter that
 ** is the number of bytes in the input string <i>including</i>
 ** the nul-terminator.
+** Note that nByte measure the length of the input in bytes, not
+** characters, even for the UTF-16 interfaces.
 **
 ** ^If pzTail is not NULL then *pzTail is made to point to the first byte
 ** past the end of the first SQL statement in zSql.  These routines only
@@ -5893,7 +5929,7 @@ SQLITE_API int sqlite3_create_window_function(
 ** This flag instructs SQLite to omit some corner-case optimizations that
 ** might disrupt the operation of the [sqlite3_value_subtype()] function,
 ** causing it to return zero rather than the correct subtype().
-** SQL functions that invokes [sqlite3_value_subtype()] should have this
+** All SQL functions that invoke [sqlite3_value_subtype()] should have this
 ** property.  If the SQLITE_SUBTYPE property is omitted, then the return
 ** value from [sqlite3_value_subtype()] might sometimes be zero even though
 ** a non-zero subtype was specified by the function argument expression.
@@ -5909,6 +5945,15 @@ SQLITE_API int sqlite3_create_window_function(
 ** [sqlite3_result_subtype()] should avoid setting this property, as the
 ** purpose of this property is to disable certain optimizations that are
 ** incompatible with subtypes.
+**
+** [[SQLITE_SELFORDER1]] <dt>SQLITE_SELFORDER1</dt><dd>
+** The SQLITE_SELFORDER1 flag indicates that the function is an aggregate
+** that internally orders the values provided to the first argument.  The
+** ordered-set aggregate SQL notation with a single ORDER BY term can be
+** used to invoke this function.  If the ordered-set aggregate notation is
+** used on a function that lacks this flag, then an error is raised. Note
+** that the ordered-set aggregate syntax is only available if SQLite is
+** built using the -DSQLITE_ENABLE_ORDERED_SET_AGGREGATES compile-time option.
 ** </dd>
 ** </dl>
 */
@@ -5917,6 +5962,7 @@ SQLITE_API int sqlite3_create_window_function(
 #define SQLITE_SUBTYPE          0x000100000
 #define SQLITE_INNOCUOUS        0x000200000
 #define SQLITE_RESULT_SUBTYPE   0x001000000
+#define SQLITE_SELFORDER1       0x002000000
 
 /*
 ** CAPI3REF: Deprecated Functions
@@ -6114,7 +6160,7 @@ SQLITE_API int sqlite3_value_encoding(sqlite3_value*);
 ** one SQL function to another.  Use the [sqlite3_result_subtype()]
 ** routine to set the subtype for the return value of an SQL function.
 **
-** Every [application-defined SQL function] that invoke this interface
+** Every [application-defined SQL function] that invokes this interface
 ** should include the [SQLITE_SUBTYPE] property in the text
 ** encoding argument when the function is [sqlite3_create_function|registered].
 ** If the [SQLITE_SUBTYPE] property is omitted, then sqlite3_value_subtype()
@@ -7181,6 +7227,12 @@ SQLITE_API int sqlite3_autovacuum_pages(
 ** The exceptions defined in this paragraph might change in a future
 ** release of SQLite.
 **
+** Whether the update hook is invoked before or after the
+** corresponding change is currently unspecified and may differ
+** depending on the type of change. Do not rely on the order of the
+** hook call with regards to the final result of the operation which
+** triggers the hook.
+**
 ** The update hook implementation must not do anything that will modify
 ** the database connection that invoked the update hook.  Any actions
 ** to modify the database connection must be deferred until after the
@@ -7715,9 +7767,11 @@ struct sqlite3_module {
 ** will be returned by the strategy.
 **
 ** The xBestIndex method may optionally populate the idxFlags field with a
-** mask of SQLITE_INDEX_SCAN_* flags. Currently there is only one such flag -
-** SQLITE_INDEX_SCAN_UNIQUE. If the xBestIndex method sets this flag, SQLite
-** assumes that the strategy may visit at most one row.
+** mask of SQLITE_INDEX_SCAN_* flags. One such flag is
+** [SQLITE_INDEX_SCAN_HEX], which if set causes the [EXPLAIN QUERY PLAN]
+** output to show the idxNum has hex instead of as decimal.  Another flag is
+** SQLITE_INDEX_SCAN_UNIQUE, which if set indicates that the query plan will
+** return at most one row.
 **
 ** Additionally, if xBestIndex sets the SQLITE_INDEX_SCAN_UNIQUE flag, then
 ** SQLite also assumes that if a call to the xUpdate() method is made as
@@ -7781,7 +7835,9 @@ struct sqlite3_index_info {
 ** [sqlite3_index_info].idxFlags field to some combination of
 ** these bits.
 */
-#define SQLITE_INDEX_SCAN_UNIQUE      1     /* Scan visits at most 1 row */
+#define SQLITE_INDEX_SCAN_UNIQUE 0x00000001 /* Scan visits at most 1 row */
+#define SQLITE_INDEX_SCAN_HEX    0x00000002 /* Display idxNum as hex */
+                                            /* in EXPLAIN QUERY PLAN */
 
 /*
 ** CAPI3REF: Virtual Table Constraint Operator Codes
@@ -8618,6 +8674,7 @@ SQLITE_API int sqlite3_test_control(int op, ...);
 #define SQLITE_TESTCTRL_JSON_SELFCHECK          14
 #define SQLITE_TESTCTRL_OPTIMIZATIONS           15
 #define SQLITE_TESTCTRL_ISKEYWORD               16  /* NOT USED */
+#define SQLITE_TESTCTRL_GETOPT                  16
 #define SQLITE_TESTCTRL_SCRATCHMALLOC           17  /* NOT USED */
 #define SQLITE_TESTCTRL_INTERNAL_FUNCTIONS      17
 #define SQLITE_TESTCTRL_LOCALTIME_FAULT         18
@@ -8637,7 +8694,7 @@ SQLITE_API int sqlite3_test_control(int op, ...);
 #define SQLITE_TESTCTRL_TRACEFLAGS              31
 #define SQLITE_TESTCTRL_TUNE                    32
 #define SQLITE_TESTCTRL_LOGEST                  33
-#define SQLITE_TESTCTRL_USELONGDOUBLE           34
+#define SQLITE_TESTCTRL_USELONGDOUBLE           34  /* NOT USED */
 #define SQLITE_TESTCTRL_LAST                    34  /* Largest TESTCTRL */
 
 /*
@@ -8651,7 +8708,7 @@ SQLITE_API int sqlite3_test_control(int op, ...);
 ** The sqlite3_keyword_count() interface returns the number of distinct
 ** keywords understood by SQLite.
 **
-** The sqlite3_keyword_name(N,Z,L) interface finds the N-th keyword and
+** The sqlite3_keyword_name(N,Z,L) interface finds the 0-based N-th keyword and
 ** makes *Z point to that keyword expressed as UTF8 and writes the number
 ** of bytes in the keyword into *L.  The string that *Z points to is not
 ** zero-terminated.  The sqlite3_keyword_name(N,Z,L) routine returns
@@ -9613,6 +9670,16 @@ typedef struct sqlite3_backup sqlite3_backup;
 ** APIs are not strictly speaking threadsafe. If they are invoked at the
 ** same time as another thread is invoking sqlite3_backup_step() it is
 ** possible that they return invalid values.
+**
+** <b>Alternatives To Using The Backup API</b>
+**
+** Other techniques for safely creating a consistent backup of an SQLite
+** database include:
+**
+** <ul>
+** <li> The [VACUUM INTO] command.
+** <li> The [sqlite3_rsync] utility program.
+** </ul>
 */
 SQLITE_API sqlite3_backup *sqlite3_backup_init(
   sqlite3 *pDest,                        /* Destination database handle */
@@ -10230,24 +10297,45 @@ SQLITE_API const char *sqlite3_vtab_collation(sqlite3_index_info*,int);
 ** <li value="2"><p>
 ** ^(If the sqlite3_vtab_distinct() interface returns 2, that means
 ** that the query planner does not need the rows returned in any particular
-** order, as long as rows with the same values in all "aOrderBy" columns
-** are adjacent.)^  ^(Furthermore, only a single row for each particular
-** combination of values in the columns identified by the "aOrderBy" field
-** needs to be returned.)^  ^It is always ok for two or more rows with the same
-** values in all "aOrderBy" columns to be returned, as long as all such rows
-** are adjacent.  ^The virtual table may, if it chooses, omit extra rows
-** that have the same value for all columns identified by "aOrderBy".
-** ^However omitting the extra rows is optional.
+** order, as long as rows with the same values in all columns identified
+** by "aOrderBy" are adjacent.)^  ^(Furthermore, when two or more rows
+** contain the same values for all columns identified by "colUsed", all but
+** one such row may optionally be omitted from the result.)^
+** The virtual table is not required to omit rows that are duplicates
+** over the "colUsed" columns, but if the virtual table can do that without
+** too much extra effort, it could potentially help the query to run faster.
 ** This mode is used for a DISTINCT query.
 ** <li value="3"><p>
-** ^(If the sqlite3_vtab_distinct() interface returns 3, that means
-** that the query planner needs only distinct rows but it does need the
-** rows to be sorted.)^ ^The virtual table implementation is free to omit
-** rows that are identical in all aOrderBy columns, if it wants to, but
-** it is not required to omit any rows.  This mode is used for queries
+** ^(If the sqlite3_vtab_distinct() interface returns 3, that means the
+** virtual table must return rows in the order defined by "aOrderBy" as
+** if the sqlite3_vtab_distinct() interface had returned 0.  However if
+** two or more rows in the result have the same values for all columns
+** identified by "colUsed", then all but one such row may optionally be
+** omitted.)^  Like when the return value is 2, the virtual table
+** is not required to omit rows that are duplicates over the "colUsed"
+** columns, but if the virtual table can do that without
+** too much extra effort, it could potentially help the query to run faster.
+** This mode is used for queries
 ** that have both DISTINCT and ORDER BY clauses.
 ** </ol>
 **
+** <p>The following table summarizes the conditions under which the
+** virtual table is allowed to set the "orderByConsumed" flag based on
+** the value returned by sqlite3_vtab_distinct().  This table is a
+** restatement of the previous four paragraphs:
+**
+** <table border=1 cellspacing=0 cellpadding=10 width="90%">
+** <tr>
+** <td valign="top">sqlite3_vtab_distinct() return value
+** <td valign="top">Rows are returned in aOrderBy order
+** <td valign="top">Rows with the same value in all aOrderBy columns are adjacent
+** <td valign="top">Duplicates over all colUsed columns may be omitted
+** <tr><td>0<td>yes<td>yes<td>no
+** <tr><td>1<td>no<td>yes<td>no
+** <tr><td>2<td>no<td>yes<td>yes
+** <tr><td>3<td>yes<td>yes<td>yes
+** </table>
+**
 ** ^For the purposes of comparing virtual table output values to see if the
 ** values are same value for sorting purposes, two NULL values are considered
 ** to be the same.  In other words, the comparison operator is "IS"
@@ -10791,6 +10879,14 @@ typedef struct sqlite3_snapshot {
 ** If there is not already a read-transaction open on schema S when
 ** this function is called, one is opened automatically.
 **
+** If a read-transaction is opened by this function, then it is guaranteed
+** that the returned snapshot object may not be invalidated by a database
+** writer or checkpointer until after the read-transaction is closed. This
+** is not guaranteed if a read-transaction is already open when this
+** function is called. In that case, any subsequent write or checkpoint
+** operation on the database may invalidate the returned snapshot handle,
+** even while the read-transaction remains open.
+**
 ** The following must be true for this function to succeed. If any of
 ** the following statements are false when sqlite3_snapshot_get() is
 ** called, SQLITE_ERROR is returned. The final value of *P is undefined
@@ -11099,8 +11195,6 @@ SQLITE_API int sqlite3_deserialize(
 #if defined(__wasi__)
 # undef SQLITE_WASI
 # define SQLITE_WASI 1
-# undef SQLITE_OMIT_WAL
-# define SQLITE_OMIT_WAL 1/* because it requires shared memory APIs */
 # ifndef SQLITE_OMIT_LOAD_EXTENSION
 #  define SQLITE_OMIT_LOAD_EXTENSION
 # endif
@@ -12292,6 +12386,30 @@ SQLITE_API int sqlite3changegroup_schema(sqlite3_changegroup*, sqlite3*, const c
 */
 SQLITE_API int sqlite3changegroup_add(sqlite3_changegroup*, int nData, void *pData);
 
+/*
+** CAPI3REF: Add A Single Change To A Changegroup
+** METHOD: sqlite3_changegroup
+**
+** This function adds the single change currently indicated by the iterator
+** passed as the second argument to the changegroup object. The rules for
+** adding the change are just as described for [sqlite3changegroup_add()].
+**
+** If the change is successfully added to the changegroup, SQLITE_OK is
+** returned. Otherwise, an SQLite error code is returned.
+**
+** The iterator must point to a valid entry when this function is called.
+** If it does not, SQLITE_ERROR is returned and no change is added to the
+** changegroup. Additionally, the iterator must not have been opened with
+** the SQLITE_CHANGESETAPPLY_INVERT flag. In this case SQLITE_ERROR is also
+** returned.
+*/
+SQLITE_API int sqlite3changegroup_add_change(
+  sqlite3_changegroup*,
+  sqlite3_changeset_iter*
+);
+
+
+
 /*
 ** CAPI3REF: Obtain A Composite Changeset From A Changegroup
 ** METHOD: sqlite3_changegroup
@@ -13096,8 +13214,8 @@ struct Fts5PhraseIter {
 ** EXTENSION API FUNCTIONS
 **
 ** xUserData(pFts):
-**   Return a copy of the context pointer the extension function was
-**   registered with.
+**   Return a copy of the pUserData pointer passed to the xCreateFunction()
+**   API when the extension function was registered.
 **
 ** xColumnTotalSize(pFts, iCol, pnToken):
 **   If parameter iCol is less than zero, set output variable *pnToken
@@ -13279,6 +13397,10 @@ struct Fts5PhraseIter {
 **   (i.e. if it is a contentless table), then this API always iterates
 **   through an empty set (all calls to xPhraseFirst() set iCol to -1).
 **
+**   In all cases, matches are visited in (column ASC, offset ASC) order.
+**   i.e. all those in column 0, sorted by offset, followed by those in
+**   column 1, etc.
+**
 ** xPhraseNext()
 **   See xPhraseFirst above.
 **
@@ -13345,9 +13467,32 @@ struct Fts5PhraseIter {
 **
 **   This API can be quite slow if used with an FTS5 table created with the
 **   "detail=none" or "detail=column" option.
+**
+** xColumnLocale(pFts5, iIdx, pzLocale, pnLocale)
+**   If parameter iCol is less than zero, or greater than or equal to the
+**   number of columns in the table, SQLITE_RANGE is returned.
+**
+**   Otherwise, this function attempts to retrieve the locale associated
+**   with column iCol of the current row. Usually, there is no associated
+**   locale, and output parameters (*pzLocale) and (*pnLocale) are set
+**   to NULL and 0, respectively. However, if the fts5_locale() function
+**   was used to associate a locale with the value when it was inserted
+**   into the fts5 table, then (*pzLocale) is set to point to a nul-terminated
+**   buffer containing the name of the locale in utf-8 encoding. (*pnLocale)
+**   is set to the size in bytes of the buffer, not including the
+**   nul-terminator.
+**
+**   If successful, SQLITE_OK is returned. Or, if an error occurs, an
+**   SQLite error code is returned. The final value of the output parameters
+**   is undefined in this case.
+**
+** xTokenize_v2:
+**   Tokenize text using the tokenizer belonging to the FTS5 table. This
+**   API is the same as the xTokenize() API, except that it allows a tokenizer
+**   locale to be specified.
 */
 struct Fts5ExtensionApi {
-  int iVersion;                   /* Currently always set to 3 */
+  int iVersion;                   /* Currently always set to 4 */
 
   void *(*xUserData)(Fts5Context*);
 
@@ -13389,6 +13534,15 @@ struct Fts5ExtensionApi {
       const char **ppToken, int *pnToken
   );
   int (*xInstToken)(Fts5Context*, int iIdx, int iToken, const char**, int*);
+
+  /* Below this point are iVersion>=4 only */
+  int (*xColumnLocale)(Fts5Context*, int iCol, const char **pz, int *pn);
+  int (*xTokenize_v2)(Fts5Context*,
+    const char *pText, int nText,      /* Text to tokenize */
+    const char *pLocale, int nLocale,  /* Locale to pass to tokenizer */
+    void *pCtx,                        /* Context passed to xToken() */
+    int (*xToken)(void*, int, const char*, int, int, int)       /* Callback */
+  );
 };
 
 /*
@@ -13409,7 +13563,7 @@ struct Fts5ExtensionApi {
 **   A tokenizer instance is required to actually tokenize text.
 **
 **   The first argument passed to this function is a copy of the (void*)
-**   pointer provided by the application when the fts5_tokenizer object
+**   pointer provided by the application when the fts5_tokenizer_v2 object
 **   was registered with FTS5 (the third argument to xCreateTokenizer()).
 **   The second and third arguments are an array of nul-terminated strings
 **   containing the tokenizer arguments, if any, specified following the
@@ -13433,7 +13587,7 @@ struct Fts5ExtensionApi {
 **   argument passed to this function is a pointer to an Fts5Tokenizer object
 **   returned by an earlier call to xCreate().
 **
-**   The second argument indicates the reason that FTS5 is requesting
+**   The third argument indicates the reason that FTS5 is requesting
 **   tokenization of the supplied text. This is always one of the following
 **   four values:
 **
@@ -13457,6 +13611,13 @@ struct Fts5ExtensionApi {
 **            on a columnsize=0 database.
 **   </ul>
 **
+**   The sixth and seventh arguments passed to xTokenize() - pLocale and
+**   nLocale - are a pointer to a buffer containing the locale to use for
+**   tokenization (e.g. "en_US") and its size in bytes, respectively. The
+**   pLocale buffer is not nul-terminated. pLocale may be passed NULL (in
+**   which case nLocale is always 0) to indicate that the tokenizer should
+**   use its default locale.
+**
 **   For each token in the input string, the supplied callback xToken() must
 **   be invoked. The first argument to it should be a copy of the pointer
 **   passed as the second argument to xTokenize(). The third and fourth
@@ -13480,6 +13641,30 @@ struct Fts5ExtensionApi {
 **   may abandon the tokenization and return any error code other than
 **   SQLITE_OK or SQLITE_DONE.
 **
+**   If the tokenizer is registered using an fts5_tokenizer_v2 object,
+**   then the xTokenize() method has two additional arguments - pLocale
+**   and nLocale. These specify the locale that the tokenizer should use
+**   for the current request. If pLocale and nLocale are both 0, then the
+**   tokenizer should use its default locale. Otherwise, pLocale points to
+**   an nLocale byte buffer containing the name of the locale to use as utf-8
+**   text. pLocale is not nul-terminated.
+**
+** FTS5_TOKENIZER
+**
+** There is also an fts5_tokenizer object. This is an older, deprecated,
+** version of fts5_tokenizer_v2. It is similar except that:
+**
+**  <ul>
+**    <li> There is no "iVersion" field, and
+**    <li> The xTokenize() method does not take a locale argument.
+**  </ul>
+**
+** Legacy fts5_tokenizer tokenizers must be registered using the
+** legacy xCreateTokenizer() function, instead of xCreateTokenizer_v2().
+**
+** Tokenizer implementations registered using either API may be retrieved
+** using both xFindTokenizer() and xFindTokenizer_v2().
+**
 ** SYNONYM SUPPORT
 **
 **   Custom tokenizers may also support synonyms. Consider a case in which a
@@ -13588,6 +13773,33 @@ struct Fts5ExtensionApi {
 **   inefficient.
 */
 typedef struct Fts5Tokenizer Fts5Tokenizer;
+typedef struct fts5_tokenizer_v2 fts5_tokenizer_v2;
+struct fts5_tokenizer_v2 {
+  int iVersion;             /* Currently always 2 */
+
+  int (*xCreate)(void*, const char **azArg, int nArg, Fts5Tokenizer **ppOut);
+  void (*xDelete)(Fts5Tokenizer*);
+  int (*xTokenize)(Fts5Tokenizer*,
+      void *pCtx,
+      int flags,            /* Mask of FTS5_TOKENIZE_* flags */
+      const char *pText, int nText,
+      const char *pLocale, int nLocale,
+      int (*xToken)(
+        void *pCtx,         /* Copy of 2nd argument to xTokenize() */
+        int tflags,         /* Mask of FTS5_TOKEN_* flags */
+        const char *pToken, /* Pointer to buffer containing token */
+        int nToken,         /* Size of token in bytes */
+        int iStart,         /* Byte offset of token within input text */
+        int iEnd            /* Byte offset of end of token within input text */
+      )
+  );
+};
+
+/*
+** New code should use the fts5_tokenizer_v2 type to define tokenizer
+** implementations. The following type is included for legacy applications
+** that still use it.
+*/
 typedef struct fts5_tokenizer fts5_tokenizer;
 struct fts5_tokenizer {
   int (*xCreate)(void*, const char **azArg, int nArg, Fts5Tokenizer **ppOut);
@@ -13607,6 +13819,7 @@ struct fts5_tokenizer {
   );
 };
 
+
 /* Flags that may be passed as the third argument to xTokenize() */
 #define FTS5_TOKENIZE_QUERY     0x0001
 #define FTS5_TOKENIZE_PREFIX    0x0002
@@ -13626,7 +13839,7 @@ struct fts5_tokenizer {
 */
 typedef struct fts5_api fts5_api;
 struct fts5_api {
-  int iVersion;                   /* Currently always set to 2 */
+  int iVersion;                   /* Currently always set to 3 */
 
   /* Create a new tokenizer */
   int (*xCreateTokenizer)(
@@ -13653,6 +13866,25 @@ struct fts5_api {
     fts5_extension_function xFunction,
     void (*xDestroy)(void*)
   );
+
+  /* APIs below this point are only available if iVersion>=3 */
+
+  /* Create a new tokenizer */
+  int (*xCreateTokenizer_v2)(
+    fts5_api *pApi,
+    const char *zName,
+    void *pUserData,
+    fts5_tokenizer_v2 *pTokenizer,
+    void (*xDestroy)(void*)
+  );
+
+  /* Find an existing tokenizer */
+  int (*xFindTokenizer_v2)(
+    fts5_api *pApi,
+    const char *zName,
+    void **ppUserData,
+    fts5_tokenizer_v2 **ppTokenizer
+  );
 };
 
 /*
@@ -14295,6 +14527,8 @@ struct fts5_api {
 # define SQLITE_OMIT_ALTERTABLE
 #endif
 
+#define SQLITE_DIGIT_SEPARATOR '_'
+
 /*
 ** Return true (non-zero) if the input is an integer that is too large
 ** to fit in 32-bits.  This macro is used inside of various testcase()
@@ -14460,135 +14694,135 @@ SQLITE_PRIVATE void sqlite3HashClear(Hash*);
 #define TK_OR                              43
 #define TK_AND                             44
 #define TK_IS                              45
-#define TK_MATCH                           46
-#define TK_LIKE_KW                         47
-#define TK_BETWEEN                         48
-#define TK_IN                              49
-#define TK_ISNULL                          50
-#define TK_NOTNULL                         51
-#define TK_NE                              52
-#define TK_EQ                              53
-#define TK_GT                              54
-#define TK_LE                              55
-#define TK_LT                              56
-#define TK_GE                              57
-#define TK_ESCAPE                          58
-#define TK_ID                              59
-#define TK_COLUMNKW                        60
-#define TK_DO                              61
-#define TK_FOR                             62
-#define TK_IGNORE                          63
-#define TK_INITIALLY                       64
-#define TK_INSTEAD                         65
-#define TK_NO                              66
-#define TK_KEY                             67
-#define TK_OF                              68
-#define TK_OFFSET                          69
-#define TK_PRAGMA                          70
-#define TK_RAISE                           71
-#define TK_RECURSIVE                       72
-#define TK_REPLACE                         73
-#define TK_RESTRICT                        74
-#define TK_ROW                             75
-#define TK_ROWS                            76
-#define TK_TRIGGER                         77
-#define TK_VACUUM                          78
-#define TK_VIEW                            79
-#define TK_VIRTUAL                         80
-#define TK_WITH                            81
-#define TK_NULLS                           82
-#define TK_FIRST                           83
-#define TK_LAST                            84
-#define TK_CURRENT                         85
-#define TK_FOLLOWING                       86
-#define TK_PARTITION                       87
-#define TK_PRECEDING                       88
-#define TK_RANGE                           89
-#define TK_UNBOUNDED                       90
-#define TK_EXCLUDE                         91
-#define TK_GROUPS                          92
-#define TK_OTHERS                          93
-#define TK_TIES                            94
-#define TK_GENERATED                       95
-#define TK_ALWAYS                          96
-#define TK_MATERIALIZED                    97
-#define TK_REINDEX                         98
-#define TK_RENAME                          99
-#define TK_CTIME_KW                       100
-#define TK_ANY                            101
-#define TK_BITAND                         102
-#define TK_BITOR                          103
-#define TK_LSHIFT                         104
-#define TK_RSHIFT                         105
-#define TK_PLUS                           106
-#define TK_MINUS                          107
-#define TK_STAR                           108
-#define TK_SLASH                          109
-#define TK_REM                            110
-#define TK_CONCAT                         111
-#define TK_PTR                            112
-#define TK_COLLATE                        113
-#define TK_BITNOT                         114
-#define TK_ON                             115
-#define TK_INDEXED                        116
-#define TK_STRING                         117
-#define TK_JOIN_KW                        118
-#define TK_CONSTRAINT                     119
-#define TK_DEFAULT                        120
-#define TK_NULL                           121
-#define TK_PRIMARY                        122
-#define TK_UNIQUE                         123
-#define TK_CHECK                          124
-#define TK_REFERENCES                     125
-#define TK_AUTOINCR                       126
-#define TK_INSERT                         127
-#define TK_DELETE                         128
-#define TK_UPDATE                         129
-#define TK_SET                            130
-#define TK_DEFERRABLE                     131
-#define TK_FOREIGN                        132
-#define TK_DROP                           133
-#define TK_UNION                          134
-#define TK_ALL                            135
-#define TK_EXCEPT                         136
-#define TK_INTERSECT                      137
-#define TK_SELECT                         138
-#define TK_VALUES                         139
-#define TK_DISTINCT                       140
-#define TK_DOT                            141
-#define TK_FROM                           142
-#define TK_JOIN                           143
-#define TK_USING                          144
-#define TK_ORDER                          145
-#define TK_GROUP                          146
-#define TK_HAVING                         147
-#define TK_LIMIT                          148
-#define TK_WHERE                          149
-#define TK_RETURNING                      150
-#define TK_INTO                           151
-#define TK_NOTHING                        152
-#define TK_FLOAT                          153
-#define TK_BLOB                           154
-#define TK_INTEGER                        155
-#define TK_VARIABLE                       156
-#define TK_CASE                           157
-#define TK_WHEN                           158
-#define TK_THEN                           159
-#define TK_ELSE                           160
-#define TK_INDEX                          161
-#define TK_ALTER                          162
-#define TK_ADD                            163
-#define TK_WINDOW                         164
-#define TK_OVER                           165
-#define TK_FILTER                         166
-#define TK_COLUMN                         167
-#define TK_AGG_FUNCTION                   168
-#define TK_AGG_COLUMN                     169
-#define TK_TRUEFALSE                      170
-#define TK_ISNOT                          171
+#define TK_ISNOT                           46
+#define TK_MATCH                           47
+#define TK_LIKE_KW                         48
+#define TK_BETWEEN                         49
+#define TK_IN                              50
+#define TK_ISNULL                          51
+#define TK_NOTNULL                         52
+#define TK_NE                              53
+#define TK_EQ                              54
+#define TK_GT                              55
+#define TK_LE                              56
+#define TK_LT                              57
+#define TK_GE                              58
+#define TK_ESCAPE                          59
+#define TK_ID                              60
+#define TK_COLUMNKW                        61
+#define TK_DO                              62
+#define TK_FOR                             63
+#define TK_IGNORE                          64
+#define TK_INITIALLY                       65
+#define TK_INSTEAD                         66
+#define TK_NO                              67
+#define TK_KEY                             68
+#define TK_OF                              69
+#define TK_OFFSET                          70
+#define TK_PRAGMA                          71
+#define TK_RAISE                           72
+#define TK_RECURSIVE                       73
+#define TK_REPLACE                         74
+#define TK_RESTRICT                        75
+#define TK_ROW                             76
+#define TK_ROWS                            77
+#define TK_TRIGGER                         78
+#define TK_VACUUM                          79
+#define TK_VIEW                            80
+#define TK_VIRTUAL                         81
+#define TK_WITH                            82
+#define TK_NULLS                           83
+#define TK_FIRST                           84
+#define TK_LAST                            85
+#define TK_CURRENT                         86
+#define TK_FOLLOWING                       87
+#define TK_PARTITION                       88
+#define TK_PRECEDING                       89
+#define TK_RANGE                           90
+#define TK_UNBOUNDED                       91
+#define TK_EXCLUDE                         92
+#define TK_GROUPS                          93
+#define TK_OTHERS                          94
+#define TK_TIES                            95
+#define TK_GENERATED                       96
+#define TK_ALWAYS                          97
+#define TK_MATERIALIZED                    98
+#define TK_REINDEX                         99
+#define TK_RENAME                         100
+#define TK_CTIME_KW                       101
+#define TK_ANY                            102
+#define TK_BITAND                         103
+#define TK_BITOR                          104
+#define TK_LSHIFT                         105
+#define TK_RSHIFT                         106
+#define TK_PLUS                           107
+#define TK_MINUS                          108
+#define TK_STAR                           109
+#define TK_SLASH                          110
+#define TK_REM                            111
+#define TK_CONCAT                         112
+#define TK_PTR                            113
+#define TK_COLLATE                        114
+#define TK_BITNOT                         115
+#define TK_ON                             116
+#define TK_INDEXED                        117
+#define TK_STRING                         118
+#define TK_JOIN_KW                        119
+#define TK_CONSTRAINT                     120
+#define TK_DEFAULT                        121
+#define TK_NULL                           122
+#define TK_PRIMARY                        123
+#define TK_UNIQUE                         124
+#define TK_CHECK                          125
+#define TK_REFERENCES                     126
+#define TK_AUTOINCR                       127
+#define TK_INSERT                         128
+#define TK_DELETE                         129
+#define TK_UPDATE                         130
+#define TK_SET                            131
+#define TK_DEFERRABLE                     132
+#define TK_FOREIGN                        133
+#define TK_DROP                           134
+#define TK_UNION                          135
+#define TK_ALL                            136
+#define TK_EXCEPT                         137
+#define TK_INTERSECT                      138
+#define TK_SELECT                         139
+#define TK_VALUES                         140
+#define TK_DISTINCT                       141
+#define TK_DOT                            142
+#define TK_FROM                           143
+#define TK_JOIN                           144
+#define TK_USING                          145
+#define TK_ORDER                          146
+#define TK_GROUP                          147
+#define TK_HAVING                         148
+#define TK_LIMIT                          149
+#define TK_WHERE                          150
+#define TK_RETURNING                      151
+#define TK_INTO                           152
+#define TK_NOTHING                        153
+#define TK_FLOAT                          154
+#define TK_BLOB                           155
+#define TK_INTEGER                        156
+#define TK_VARIABLE                       157
+#define TK_CASE                           158
+#define TK_WHEN                           159
+#define TK_THEN                           160
+#define TK_ELSE                           161
+#define TK_INDEX                          162
+#define TK_ALTER                          163
+#define TK_ADD                            164
+#define TK_WINDOW                         165
+#define TK_OVER                           166
+#define TK_FILTER                         167
+#define TK_COLUMN                         168
+#define TK_AGG_FUNCTION                   169
+#define TK_AGG_COLUMN                     170
+#define TK_TRUEFALSE                      171
 #define TK_FUNCTION                       172
-#define TK_UMINUS                         173
-#define TK_UPLUS                          174
+#define TK_UPLUS                          173
+#define TK_UMINUS                         174
 #define TK_TRUTH                          175
 #define TK_REGISTER                       176
 #define TK_VECTOR                         177
@@ -14597,8 +14831,9 @@ SQLITE_PRIVATE void sqlite3HashClear(Hash*);
 #define TK_ASTERISK                       180
 #define TK_SPAN                           181
 #define TK_ERROR                          182
-#define TK_SPACE                          183
-#define TK_ILLEGAL                        184
+#define TK_QNUMBER                        183
+#define TK_SPACE                          184
+#define TK_ILLEGAL                        185
 
 /************** End of parse.h ***********************************************/
 /************** Continuing where we left off in sqliteInt.h ******************/
@@ -14607,6 +14842,7 @@ SQLITE_PRIVATE void sqlite3HashClear(Hash*);
 #include <string.h>
 #include <assert.h>
 #include <stddef.h>
+#include <ctype.h>
 
 /*
 ** Use a macro to replace memcpy() if compiled with SQLITE_INLINE_MEMCPY.
@@ -14627,7 +14863,8 @@ SQLITE_PRIVATE void sqlite3HashClear(Hash*);
 #ifdef SQLITE_OMIT_FLOATING_POINT
 # define double sqlite_int64
 # define float sqlite_int64
-# define LONGDOUBLE_TYPE sqlite_int64
+# define fabs(X) ((X)<0?-(X):(X))
+# define sqlite3IsOverflow(X) 0
 # ifndef SQLITE_BIG_DBL
 #   define SQLITE_BIG_DBL (((sqlite3_int64)1)<<50)
 # endif
@@ -14802,9 +15039,6 @@ SQLITE_PRIVATE void sqlite3HashClear(Hash*);
 #  define INT8_TYPE signed char
 # endif
 #endif
-#ifndef LONGDOUBLE_TYPE
-# define LONGDOUBLE_TYPE long double
-#endif
 typedef sqlite_int64 i64;          /* 8-byte signed integer */
 typedef sqlite_uint64 u64;         /* 8-byte unsigned integer */
 typedef UINT32_TYPE u32;           /* 4-byte unsigned integer */
@@ -14860,7 +15094,7 @@ typedef INT16_TYPE LogEst;
 #   define SQLITE_PTRSIZE __SIZEOF_POINTER__
 # elif defined(i386)     || defined(__i386__)   || defined(_M_IX86) ||    \
        defined(_M_ARM)   || defined(__arm__)    || defined(__x86)   ||    \
-      (defined(__APPLE__) && defined(__POWERPC__)) ||                     \
+      (defined(__APPLE__) && defined(__ppc__)) ||                         \
       (defined(__TOS_AIX__) && !defined(__64BIT__))
 #   define SQLITE_PTRSIZE 4
 # else
@@ -15097,6 +15331,7 @@ SQLITE_PRIVATE u32 sqlite3TreeTrace;
 **   0x00010000     Beginning of DELETE/INSERT/UPDATE processing
 **   0x00020000     Transform DISTINCT into GROUP BY
 **   0x00040000     SELECT tree dump after all code has been generated
+**   0x00080000     NOT NULL strength reduction
 */
 
 /*
@@ -15127,7 +15362,7 @@ SQLITE_PRIVATE u32 sqlite3WhereTrace;
 ** 0x00000010   Display sqlite3_index_info xBestIndex calls
 ** 0x00000020   Range an equality scan metrics
 ** 0x00000040   IN operator decisions
-** 0x00000080   WhereLoop cost adjustements
+** 0x00000080   WhereLoop cost adjustments
 ** 0x00000100
 ** 0x00000200   Covering index decisions
 ** 0x00000400   OR optimization
@@ -15303,6 +15538,7 @@ typedef struct Savepoint Savepoint;
 typedef struct Select Select;
 typedef struct SQLiteThread SQLiteThread;
 typedef struct SelectDest SelectDest;
+typedef struct Subquery Subquery;
 typedef struct SrcItem SrcItem;
 typedef struct SrcList SrcList;
 typedef struct sqlite3_str StrAccum; /* Internal alias for sqlite3_str */
@@ -16185,6 +16421,9 @@ SQLITE_PRIVATE int sqlite3BtreeCursor(
 );
 SQLITE_PRIVATE BtCursor *sqlite3BtreeFakeValidCursor(void);
 SQLITE_PRIVATE int sqlite3BtreeCursorSize(void);
+#ifdef SQLITE_DEBUG
+SQLITE_PRIVATE int sqlite3BtreeClosesWithCursor(Btree*,BtCursor*);
+#endif
 SQLITE_PRIVATE void sqlite3BtreeCursorZero(BtCursor*);
 SQLITE_PRIVATE void sqlite3BtreeCursorHintFlags(BtCursor*, unsigned);
 #ifdef SQLITE_ENABLE_CURSOR_HINTS
@@ -16276,6 +16515,7 @@ SQLITE_PRIVATE int sqlite3BtreeIntegrityCheck(
   sqlite3 *db,  /* Database connection that is running the check */
   Btree *p,     /* The btree to be checked */
   Pgno *aRoot,  /* An array of root pages numbers for individual trees */
+  sqlite3_value *aCnt,  /* OUT: entry counts for each btree in aRoot[] */
   int nRoot,    /* Number of entries in aRoot[] */
   int mxErr,    /* Stop reporting errors after this many */
   int *pnErr,   /* OUT: Write number of errors seen to this variable */
@@ -16402,6 +16642,19 @@ typedef struct Vdbe Vdbe;
 */
 typedef struct sqlite3_value Mem;
 typedef struct SubProgram SubProgram;
+typedef struct SubrtnSig SubrtnSig;
+
+/*
+** A signature for a reusable subroutine that materializes the RHS of
+** an IN operator.
+*/
+struct SubrtnSig {
+  int selId;          /* SELECT-id for the SELECT statement on the RHS */
+  char *zAff;         /* Affinity of the overall IN expression */
+  int iTable;         /* Ephemeral table generated by the subroutine */
+  int iAddr;          /* Subroutine entry address */
+  int regReturn;      /* Register used to hold return address */
+};
 
 /*
 ** A single instruction of the virtual machine has an opcode
@@ -16430,6 +16683,7 @@ struct VdbeOp {
     u32 *ai;               /* Used when p4type is P4_INTARRAY */
     SubProgram *pProgram;  /* Used when p4type is P4_SUBPROGRAM */
     Table *pTab;           /* Used when p4type is P4_TABLE */
+    SubrtnSig *pSubrtnSig; /* Used when p4type is P4_SUBRTNSIG */
 #ifdef SQLITE_ENABLE_CURSOR_HINTS
     Expr *pExpr;           /* Used when p4type is P4_EXPR */
 #endif
@@ -16497,6 +16751,7 @@ typedef struct VdbeOpList VdbeOpList;
 #define P4_INTARRAY   (-14) /* P4 is a vector of 32-bit integers */
 #define P4_FUNCCTX    (-15) /* P4 is a pointer to an sqlite3_context object */
 #define P4_TABLEREF   (-16) /* Like P4_TABLE, but reference counted */
+#define P4_SUBRTNSIG  (-17) /* P4 is a SubrtnSig pointer */
 
 /* Error message codes for OP_Halt */
 #define P5_ConstraintNotNull 1
@@ -16546,12 +16801,12 @@ typedef struct VdbeOpList VdbeOpList;
 #define OP_Vacuum          5
 #define OP_VFilter         6 /* jump, synopsis: iplan=r[P3] zplan='P4'     */
 #define OP_VUpdate         7 /* synopsis: data=r[P3@P2]                    */
-#define OP_Init            8 /* jump, synopsis: Start at P2                */
+#define OP_Init            8 /* jump0, synopsis: Start at P2               */
 #define OP_Goto            9 /* jump                                       */
 #define OP_Gosub          10 /* jump                                       */
-#define OP_InitCoroutine  11 /* jump                                       */
-#define OP_Yield          12 /* jump                                       */
-#define OP_MustBeInt      13 /* jump                                       */
+#define OP_InitCoroutine  11 /* jump0                                      */
+#define OP_Yield          12 /* jump0                                      */
+#define OP_MustBeInt      13 /* jump0                                      */
 #define OP_Jump           14 /* jump                                       */
 #define OP_Once           15 /* jump                                       */
 #define OP_If             16 /* jump                                       */
@@ -16559,22 +16814,22 @@ typedef struct VdbeOpList VdbeOpList;
 #define OP_IsType         18 /* jump, synopsis: if typeof(P1.P3) in P5 goto P2 */
 #define OP_Not            19 /* same as TK_NOT, synopsis: r[P2]= !r[P1]    */
 #define OP_IfNullRow      20 /* jump, synopsis: if P1.nullRow then r[P3]=NULL, goto P2 */
-#define OP_SeekLT         21 /* jump, synopsis: key=r[P3@P4]               */
-#define OP_SeekLE         22 /* jump, synopsis: key=r[P3@P4]               */
-#define OP_SeekGE         23 /* jump, synopsis: key=r[P3@P4]               */
-#define OP_SeekGT         24 /* jump, synopsis: key=r[P3@P4]               */
+#define OP_SeekLT         21 /* jump0, synopsis: key=r[P3@P4]              */
+#define OP_SeekLE         22 /* jump0, synopsis: key=r[P3@P4]              */
+#define OP_SeekGE         23 /* jump0, synopsis: key=r[P3@P4]              */
+#define OP_SeekGT         24 /* jump0, synopsis: key=r[P3@P4]              */
 #define OP_IfNotOpen      25 /* jump, synopsis: if( !csr[P1] ) goto P2     */
 #define OP_IfNoHope       26 /* jump, synopsis: key=r[P3@P4]               */
 #define OP_NoConflict     27 /* jump, synopsis: key=r[P3@P4]               */
 #define OP_NotFound       28 /* jump, synopsis: key=r[P3@P4]               */
 #define OP_Found          29 /* jump, synopsis: key=r[P3@P4]               */
-#define OP_SeekRowid      30 /* jump, synopsis: intkey=r[P3]               */
+#define OP_SeekRowid      30 /* jump0, synopsis: intkey=r[P3]              */
 #define OP_NotExists      31 /* jump, synopsis: intkey=r[P3]               */
-#define OP_Last           32 /* jump                                       */
-#define OP_IfSmaller      33 /* jump                                       */
+#define OP_Last           32 /* jump0                                      */
+#define OP_IfSizeBetween  33 /* jump                                       */
 #define OP_SorterSort     34 /* jump                                       */
 #define OP_Sort           35 /* jump                                       */
-#define OP_Rewind         36 /* jump                                       */
+#define OP_Rewind         36 /* jump0                                      */
 #define OP_SorterNext     37 /* jump                                       */
 #define OP_Prev           38 /* jump                                       */
 #define OP_Next           39 /* jump                                       */
@@ -16586,18 +16841,18 @@ typedef struct VdbeOpList VdbeOpList;
 #define OP_IdxGE          45 /* jump, synopsis: key=r[P3@P4]               */
 #define OP_RowSetRead     46 /* jump, synopsis: r[P3]=rowset(P1)           */
 #define OP_RowSetTest     47 /* jump, synopsis: if r[P3] in rowset(P1) goto P2 */
-#define OP_Program        48 /* jump                                       */
+#define OP_Program        48 /* jump0                                      */
 #define OP_FkIfZero       49 /* jump, synopsis: if fkctr[P1]==0 goto P2    */
-#define OP_IsNull         50 /* jump, same as TK_ISNULL, synopsis: if r[P1]==NULL goto P2 */
-#define OP_NotNull        51 /* jump, same as TK_NOTNULL, synopsis: if r[P1]!=NULL goto P2 */
-#define OP_Ne             52 /* jump, same as TK_NE, synopsis: IF r[P3]!=r[P1] */
-#define OP_Eq             53 /* jump, same as TK_EQ, synopsis: IF r[P3]==r[P1] */
-#define OP_Gt             54 /* jump, same as TK_GT, synopsis: IF r[P3]>r[P1] */
-#define OP_Le             55 /* jump, same as TK_LE, synopsis: IF r[P3]<=r[P1] */
-#define OP_Lt             56 /* jump, same as TK_LT, synopsis: IF r[P3]<r[P1] */
-#define OP_Ge             57 /* jump, same as TK_GE, synopsis: IF r[P3]>=r[P1] */
-#define OP_ElseEq         58 /* jump, same as TK_ESCAPE                    */
-#define OP_IfPos          59 /* jump, synopsis: if r[P1]>0 then r[P1]-=P3, goto P2 */
+#define OP_IfPos          50 /* jump, synopsis: if r[P1]>0 then r[P1]-=P3, goto P2 */
+#define OP_IsNull         51 /* jump, same as TK_ISNULL, synopsis: if r[P1]==NULL goto P2 */
+#define OP_NotNull        52 /* jump, same as TK_NOTNULL, synopsis: if r[P1]!=NULL goto P2 */
+#define OP_Ne             53 /* jump, same as TK_NE, synopsis: IF r[P3]!=r[P1] */
+#define OP_Eq             54 /* jump, same as TK_EQ, synopsis: IF r[P3]==r[P1] */
+#define OP_Gt             55 /* jump, same as TK_GT, synopsis: IF r[P3]>r[P1] */
+#define OP_Le             56 /* jump, same as TK_LE, synopsis: IF r[P3]<=r[P1] */
+#define OP_Lt             57 /* jump, same as TK_LT, synopsis: IF r[P3]<r[P1] */
+#define OP_Ge             58 /* jump, same as TK_GE, synopsis: IF r[P3]>=r[P1] */
+#define OP_ElseEq         59 /* jump, same as TK_ESCAPE                    */
 #define OP_IfNotZero      60 /* jump, synopsis: if r[P1]!=0 then r[P1]--, goto P2 */
 #define OP_DecrJumpZero   61 /* jump, synopsis: if (--r[P1])==0 goto P2    */
 #define OP_IncrVacuum     62 /* jump                                       */
@@ -16616,7 +16871,7 @@ typedef struct VdbeOpList VdbeOpList;
 #define OP_Null           75 /* synopsis: r[P2..P3]=NULL                   */
 #define OP_SoftNull       76 /* synopsis: r[P1]=NULL                       */
 #define OP_Blob           77 /* synopsis: r[P2]=P4 (len=P1)                */
-#define OP_Variable       78 /* synopsis: r[P2]=parameter(P1,P4)           */
+#define OP_Variable       78 /* synopsis: r[P2]=parameter(P1)              */
 #define OP_Move           79 /* synopsis: r[P2@P3]=r[P1@P3]                */
 #define OP_Copy           80 /* synopsis: r[P2@P3+1]=r[P1@P3+1]            */
 #define OP_SCopy          81 /* synopsis: r[P2]=r[P1]                      */
@@ -16640,23 +16895,23 @@ typedef struct VdbeOpList VdbeOpList;
 #define OP_ReadCookie     99
 #define OP_SetCookie     100
 #define OP_ReopenIdx     101 /* synopsis: root=P2 iDb=P3                   */
-#define OP_BitAnd        102 /* same as TK_BITAND, synopsis: r[P3]=r[P1]&r[P2] */
-#define OP_BitOr         103 /* same as TK_BITOR, synopsis: r[P3]=r[P1]|r[P2] */
-#define OP_ShiftLeft     104 /* same as TK_LSHIFT, synopsis: r[P3]=r[P2]<<r[P1] */
-#define OP_ShiftRight    105 /* same as TK_RSHIFT, synopsis: r[P3]=r[P2]>>r[P1] */
-#define OP_Add           106 /* same as TK_PLUS, synopsis: r[P3]=r[P1]+r[P2] */
-#define OP_Subtract      107 /* same as TK_MINUS, synopsis: r[P3]=r[P2]-r[P1] */
-#define OP_Multiply      108 /* same as TK_STAR, synopsis: r[P3]=r[P1]*r[P2] */
-#define OP_Divide        109 /* same as TK_SLASH, synopsis: r[P3]=r[P2]/r[P1] */
-#define OP_Remainder     110 /* same as TK_REM, synopsis: r[P3]=r[P2]%r[P1] */
-#define OP_Concat        111 /* same as TK_CONCAT, synopsis: r[P3]=r[P2]+r[P1] */
-#define OP_OpenRead      112 /* synopsis: root=P2 iDb=P3                   */
+#define OP_OpenRead      102 /* synopsis: root=P2 iDb=P3                   */
+#define OP_BitAnd        103 /* same as TK_BITAND, synopsis: r[P3]=r[P1]&r[P2] */
+#define OP_BitOr         104 /* same as TK_BITOR, synopsis: r[P3]=r[P1]|r[P2] */
+#define OP_ShiftLeft     105 /* same as TK_LSHIFT, synopsis: r[P3]=r[P2]<<r[P1] */
+#define OP_ShiftRight    106 /* same as TK_RSHIFT, synopsis: r[P3]=r[P2]>>r[P1] */
+#define OP_Add           107 /* same as TK_PLUS, synopsis: r[P3]=r[P1]+r[P2] */
+#define OP_Subtract      108 /* same as TK_MINUS, synopsis: r[P3]=r[P2]-r[P1] */
+#define OP_Multiply      109 /* same as TK_STAR, synopsis: r[P3]=r[P1]*r[P2] */
+#define OP_Divide        110 /* same as TK_SLASH, synopsis: r[P3]=r[P2]/r[P1] */
+#define OP_Remainder     111 /* same as TK_REM, synopsis: r[P3]=r[P2]%r[P1] */
+#define OP_Concat        112 /* same as TK_CONCAT, synopsis: r[P3]=r[P2]+r[P1] */
 #define OP_OpenWrite     113 /* synopsis: root=P2 iDb=P3                   */
-#define OP_BitNot        114 /* same as TK_BITNOT, synopsis: r[P2]= ~r[P1] */
-#define OP_OpenDup       115
+#define OP_OpenDup       114
+#define OP_BitNot        115 /* same as TK_BITNOT, synopsis: r[P2]= ~r[P1] */
 #define OP_OpenAutoindex 116 /* synopsis: nColumn=P2                       */
-#define OP_String8       117 /* same as TK_STRING, synopsis: r[P2]='P4'    */
-#define OP_OpenEphemeral 118 /* synopsis: nColumn=P2                       */
+#define OP_OpenEphemeral 117 /* synopsis: nColumn=P2                       */
+#define OP_String8       118 /* same as TK_STRING, synopsis: r[P2]='P4'    */
 #define OP_SorterOpen    119
 #define OP_SequenceTest  120 /* synopsis: if( cursor[P1].ctr++ ) pc = P2   */
 #define OP_OpenPseudo    121 /* synopsis: P3 columns in r[P2]              */
@@ -16691,8 +16946,8 @@ typedef struct VdbeOpList VdbeOpList;
 #define OP_LoadAnalysis  150
 #define OP_DropTable     151
 #define OP_DropIndex     152
-#define OP_Real          153 /* same as TK_FLOAT, synopsis: r[P2]=P4       */
-#define OP_DropTrigger   154
+#define OP_DropTrigger   153
+#define OP_Real          154 /* same as TK_FLOAT, synopsis: r[P2]=P4       */
 #define OP_IntegrityCk   155
 #define OP_RowSetAdd     156 /* synopsis: rowset(P1)=r[P2]                 */
 #define OP_Param         157
@@ -16740,27 +16995,28 @@ typedef struct VdbeOpList VdbeOpList;
 #define OPFLG_OUT2        0x10  /* out2:  P2 is an output */
 #define OPFLG_OUT3        0x20  /* out3:  P3 is an output */
 #define OPFLG_NCYCLE      0x40  /* ncycle:Cycles count against P1 */
+#define OPFLG_JUMP0       0x80  /* jump0:  P2 might be zero */
 #define OPFLG_INITIALIZER {\
 /*   0 */ 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x41, 0x00,\
-/*   8 */ 0x01, 0x01, 0x01, 0x01, 0x03, 0x03, 0x01, 0x01,\
-/*  16 */ 0x03, 0x03, 0x01, 0x12, 0x01, 0x49, 0x49, 0x49,\
-/*  24 */ 0x49, 0x01, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49,\
-/*  32 */ 0x41, 0x01, 0x41, 0x41, 0x41, 0x01, 0x41, 0x41,\
+/*   8 */ 0x81, 0x01, 0x01, 0x81, 0x83, 0x83, 0x01, 0x01,\
+/*  16 */ 0x03, 0x03, 0x01, 0x12, 0x01, 0xc9, 0xc9, 0xc9,\
+/*  24 */ 0xc9, 0x01, 0x49, 0x49, 0x49, 0x49, 0xc9, 0x49,\
+/*  32 */ 0xc1, 0x01, 0x41, 0x41, 0xc1, 0x01, 0x41, 0x41,\
 /*  40 */ 0x41, 0x41, 0x41, 0x26, 0x26, 0x41, 0x23, 0x0b,\
-/*  48 */ 0x01, 0x01, 0x03, 0x03, 0x0b, 0x0b, 0x0b, 0x0b,\
-/*  56 */ 0x0b, 0x0b, 0x01, 0x03, 0x03, 0x03, 0x01, 0x41,\
+/*  48 */ 0x81, 0x01, 0x03, 0x03, 0x03, 0x0b, 0x0b, 0x0b,\
+/*  56 */ 0x0b, 0x0b, 0x0b, 0x01, 0x03, 0x03, 0x01, 0x41,\
 /*  64 */ 0x01, 0x00, 0x00, 0x02, 0x02, 0x08, 0x00, 0x10,\
 /*  72 */ 0x10, 0x10, 0x00, 0x10, 0x00, 0x10, 0x10, 0x00,\
 /*  80 */ 0x00, 0x10, 0x10, 0x00, 0x00, 0x00, 0x02, 0x02,\
 /*  88 */ 0x02, 0x00, 0x00, 0x12, 0x1e, 0x20, 0x40, 0x00,\
-/*  96 */ 0x00, 0x00, 0x10, 0x10, 0x00, 0x40, 0x26, 0x26,\
+/*  96 */ 0x00, 0x00, 0x10, 0x10, 0x00, 0x40, 0x40, 0x26,\
 /* 104 */ 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,\
-/* 112 */ 0x40, 0x00, 0x12, 0x40, 0x40, 0x10, 0x40, 0x00,\
+/* 112 */ 0x26, 0x00, 0x40, 0x12, 0x40, 0x40, 0x10, 0x00,\
 /* 120 */ 0x00, 0x00, 0x40, 0x00, 0x40, 0x40, 0x10, 0x10,\
 /* 128 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x50,\
 /* 136 */ 0x00, 0x40, 0x04, 0x04, 0x00, 0x40, 0x50, 0x40,\
 /* 144 */ 0x10, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00,\
-/* 152 */ 0x00, 0x10, 0x00, 0x00, 0x06, 0x10, 0x00, 0x04,\
+/* 152 */ 0x00, 0x00, 0x10, 0x00, 0x06, 0x10, 0x00, 0x04,\
 /* 160 */ 0x1a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\
 /* 168 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x10, 0x50,\
 /* 176 */ 0x40, 0x00, 0x10, 0x10, 0x02, 0x12, 0x12, 0x00,\
@@ -16907,6 +17163,8 @@ SQLITE_PRIVATE RecordCompare sqlite3VdbeFindCompare(UnpackedRecord*);
 SQLITE_PRIVATE void sqlite3VdbeLinkSubProgram(Vdbe *, SubProgram *);
 SQLITE_PRIVATE int sqlite3VdbeHasSubProgram(Vdbe*);
 
+SQLITE_PRIVATE void sqlite3MemSetArrayInt64(sqlite3_value *aMem, int iIdx, i64 val);
+
 SQLITE_PRIVATE int sqlite3NotPureFunc(sqlite3_context*);
 #ifdef SQLITE_ENABLE_BYTECODE_VTAB
 SQLITE_PRIVATE int sqlite3VdbeBytecodeVtabInit(sqlite3*);
@@ -17494,6 +17752,10 @@ struct FuncDefHash {
 };
 #define SQLITE_FUNC_HASH(C,L) (((C)+(L))%SQLITE_FUNC_HASH_SZ)
 
+#if defined(SQLITE_USER_AUTHENTICATION)
+# warning  "The SQLITE_USER_AUTHENTICATION extension is deprecated. \
+ See ext/userauth/user-auth.txt for details."
+#endif
 #ifdef SQLITE_USER_AUTHENTICATION
 /*
 ** Information held in the "sqlite3" database connection object and used
@@ -17797,7 +18059,7 @@ struct sqlite3 {
 #define SQLITE_CursorHints    0x00000400 /* Add OP_CursorHint opcodes */
 #define SQLITE_Stat4          0x00000800 /* Use STAT4 data */
    /* TH3 expects this value  ^^^^^^^^^^ to be 0x0000800. Don't change it */
-#define SQLITE_PushDown       0x00001000 /* The push-down optimization */
+#define SQLITE_PushDown       0x00001000 /* WHERE-clause push-down opt */
 #define SQLITE_SimplifyJoin   0x00002000 /* Convert LEFT JOIN to JOIN */
 #define SQLITE_SkipScan       0x00004000 /* Skip-scans */
 #define SQLITE_PropagateConst 0x00008000 /* The constant propagation opt */
@@ -17815,6 +18077,7 @@ struct sqlite3 {
 #define SQLITE_Coroutines     0x02000000 /* Co-routines for subqueries */
 #define SQLITE_NullUnusedCols 0x04000000 /* NULL unused columns in subqueries */
 #define SQLITE_OnePass        0x08000000 /* Single-pass DELETE and UPDATE */
+#define SQLITE_OrderBySubq    0x10000000 /* ORDER BY in subquery helps outer */
 #define SQLITE_AllOpts        0xffffffff /* All optimizations */
 
 /*
@@ -18370,8 +18633,7 @@ struct Table {
 #define TF_HasStored      0x00000040 /* Has one or more STORED columns */
 #define TF_HasGenerated   0x00000060 /* Combo: HasVirtual + HasStored */
 #define TF_WithoutRowid   0x00000080 /* No rowid.  PRIMARY KEY is the key */
-#define TF_StatsUsed      0x00000100 /* Query planner decisions affected by
-                                     ** Index.aiRowLogEst[] values */
+#define TF_MaybeReanalyze 0x00000100 /* Maybe run ANALYZE on this table */
 #define TF_NoVisibleRowid 0x00000200 /* No user-visible "rowid" column */
 #define TF_OOOHidden      0x00000400 /* Out-of-Order hidden columns */
 #define TF_HasNotNull     0x00000800 /* Contains NOT NULL constraints */
@@ -18427,6 +18689,15 @@ struct Table {
 #define HasRowid(X)     (((X)->tabFlags & TF_WithoutRowid)==0)
 #define VisibleRowid(X) (((X)->tabFlags & TF_NoVisibleRowid)==0)
 
+/* Macro is true if the SQLITE_ALLOW_ROWID_IN_VIEW (mis-)feature is
+** available.  By default, this macro is false
+*/
+#ifndef SQLITE_ALLOW_ROWID_IN_VIEW
+# define ViewCanHaveRowid     0
+#else
+# define ViewCanHaveRowid     (sqlite3Config.mNoVisibleRowid==0)
+#endif
+
 /*
 ** Each foreign key constraint is an instance of the following structure.
 **
@@ -18794,9 +19065,15 @@ struct AggInfo {
 ** assignAggregateRegisters() that computes the value of pAggInfo->iFirstReg.
 ** The assert()s that are part of this macro verify that constraint.
 */
+#ifndef NDEBUG
 #define AggInfoColumnReg(A,I)  (assert((A)->iFirstReg),(A)->iFirstReg+(I))
 #define AggInfoFuncReg(A,I)    \
                       (assert((A)->iFirstReg),(A)->iFirstReg+(A)->nColumn+(I))
+#else
+#define AggInfoColumnReg(A,I)  ((A)->iFirstReg+(I))
+#define AggInfoFuncReg(A,I)    \
+                      ((A)->iFirstReg+(A)->nColumn+(I))
+#endif
 
 /*
 ** The datatype ynVar is a signed integer, either 16-bit or 32-bit.
@@ -18977,7 +19254,7 @@ struct Expr {
 #define EP_IsTrue   0x10000000 /* Always has boolean value of TRUE */
 #define EP_IsFalse  0x20000000 /* Always has boolean value of FALSE */
 #define EP_FromDDL  0x40000000 /* Originates from sqlite_schema */
-               /*   0x80000000 // Available */
+#define EP_SubtArg  0x80000000 /* Is argument to SQLITE_SUBTYPE function */
 
 /* The EP_Propagate mask is a set of properties that automatically propagate
 ** upwards into parent nodes.
@@ -19148,6 +19425,16 @@ struct IdList {
 #define EU4_IDX    1   /* Uses IdList.a.u4.idx */
 #define EU4_EXPR   2   /* Uses IdList.a.u4.pExpr -- NOT CURRENTLY USED */
 
+/*
+** Details of the implementation of a subquery.
+*/
+struct Subquery {
+  Select *pSelect;  /* A SELECT statement used in place of a table name */
+  int addrFillSub;  /* Address of subroutine to initialize a subquery */
+  int regReturn;    /* Register holding return address of addrFillSub */
+  int regResult;    /* Registers holding results of a co-routine */
+};
+
 /*
 ** The SrcItem object represents a single term in the FROM clause of a query.
 ** The SrcList object is mostly an array of SrcItems.
@@ -19160,27 +19447,40 @@ struct IdList {
 ** In the colUsed field, the high-order bit (bit 63) is set if the table
 ** contains more than 63 columns and the 64-th or later column is used.
 **
-** Union member validity:
+** Aggressive use of "union" helps keep the size of the object small.  This
+** has been shown to boost performance, in addition to saving memory.
+** Access to union elements is gated by the following rules which should
+** always be checked, either by an if-statement or by an assert().
 **
-**    u1.zIndexedBy          fg.isIndexedBy && !fg.isTabFunc
-**    u1.pFuncArg            fg.isTabFunc   && !fg.isIndexedBy
-**    u2.pIBIndex            fg.isIndexedBy && !fg.isCte
-**    u2.pCteUse             fg.isCte       && !fg.isIndexedBy
+**    Field              Only access if this is true
+**    ---------------    -----------------------------------
+**    u1.zIndexedBy      fg.isIndexedBy
+**    u1.pFuncArg        fg.isTabFunc
+**    u1.nRow            !fg.isTabFunc  && !fg.isIndexedBy
+**
+**    u2.pIBIndex        fg.isIndexedBy
+**    u2.pCteUse         fg.isCte
+**
+**    u3.pOn             !fg.isUsing
+**    u3.pUsing          fg.isUsing
+**
+**    u4.zDatabase       !fg.fixedSchema && !fg.isSubquery
+**    u4.pSchema         fg.fixedSchema
+**    u4.pSubq           fg.isSubquery
+**
+** See also the sqlite3SrcListDelete() routine for assert() statements that
+** check invariants on the fields of this object, especially the flags
+** inside the fg struct.
 */
 struct SrcItem {
-  Schema *pSchema;  /* Schema to which this item is fixed */
-  char *zDatabase;  /* Name of database holding this table */
   char *zName;      /* Name of the table */
   char *zAlias;     /* The "B" part of a "A AS B" phrase.  zName is the "A" */
-  Table *pTab;      /* An SQL table corresponding to zName */
-  Select *pSelect;  /* A SELECT statement used in place of a table name */
-  int addrFillSub;  /* Address of subroutine to manifest a subquery */
-  int regReturn;    /* Register holding return address of addrFillSub */
-  int regResult;    /* Registers holding results of a co-routine */
+  Table *pSTab;     /* Table object for zName. Mnemonic: Srcitem-TABle */
   struct {
     u8 jointype;      /* Type of join between this table and the previous */
     unsigned notIndexed :1;    /* True if there is a NOT INDEXED clause */
     unsigned isIndexedBy :1;   /* True if there is an INDEXED BY clause */
+    unsigned isSubquery :1;    /* True if this term is a subquery */
     unsigned isTabFunc :1;     /* True if table-valued-function syntax */
     unsigned isCorrelated :1;  /* True if sub-query is correlated */
     unsigned isMaterialized:1; /* This is a materialized view */
@@ -19193,21 +19493,30 @@ struct SrcItem {
     unsigned isOn :1;          /* u3.pOn was once valid and non-NULL */
     unsigned isSynthUsing :1;  /* u3.pUsing is synthesized from NATURAL */
     unsigned isNestedFrom :1;  /* pSelect is a SF_NestedFrom subquery */
+    unsigned rowidUsed :1;     /* The ROWID of this table is referenced */
+    unsigned fixedSchema :1;   /* Uses u4.pSchema, not u4.zDatabase */
+    unsigned hadSchema :1;     /* Had u4.zDatabase before u4.pSchema */
   } fg;
   int iCursor;      /* The VDBE cursor number used to access this table */
-  union {
-    Expr *pOn;        /* fg.isUsing==0 =>  The ON clause of a join */
-    IdList *pUsing;   /* fg.isUsing==1 =>  The USING clause of a join */
-  } u3;
   Bitmask colUsed;  /* Bit N set if column N used. Details above for N>62 */
   union {
     char *zIndexedBy;    /* Identifier from "INDEXED BY <zIndex>" clause */
     ExprList *pFuncArg;  /* Arguments to table-valued-function */
+    u32 nRow;            /* Number of rows in a VALUES clause */
   } u1;
   union {
     Index *pIBIndex;  /* Index structure corresponding to u1.zIndexedBy */
     CteUse *pCteUse;  /* CTE Usage info when fg.isCte is true */
   } u2;
+  union {
+    Expr *pOn;        /* fg.isUsing==0 =>  The ON clause of a join */
+    IdList *pUsing;   /* fg.isUsing==1 =>  The USING clause of a join */
+  } u3;
+  union {
+    Schema *pSchema;  /* Schema to which this item is fixed */
+    char *zDatabase;  /* Name of database holding this table */
+    Subquery *pSubq;  /* Description of a subquery */
+  } u4;
 };
 
 /*
@@ -19267,7 +19576,7 @@ struct SrcList {
 #define WHERE_AGG_DISTINCT     0x0400 /* Query is "SELECT agg(DISTINCT ...)" */
 #define WHERE_ORDERBY_LIMIT    0x0800 /* ORDERBY+LIMIT on the inner loop */
 #define WHERE_RIGHT_JOIN       0x1000 /* Processing a RIGHT JOIN */
-                        /*     0x2000    not currently used */
+#define WHERE_KEEP_ALL_JOINS   0x2000 /* Do not do the omit-noop-join opt */
 #define WHERE_USE_LIMIT        0x4000 /* Use the LIMIT in cost estimates */
                         /*     0x8000    not currently used */
 
@@ -19339,13 +19648,14 @@ struct NameContext {
 #define NC_UUpsert   0x000200 /* True if uNC.pUpsert is used */
 #define NC_UBaseReg  0x000400 /* True if uNC.iBaseReg is used */
 #define NC_MinMaxAgg 0x001000 /* min/max aggregates seen.  See note above */
-#define NC_Complex   0x002000 /* True if a function or subquery seen */
+/*                   0x002000 // available for reuse */
 #define NC_AllowWin  0x004000 /* Window functions are allowed here */
 #define NC_HasWin    0x008000 /* One or more window functions seen */
 #define NC_IsDDL     0x010000 /* Resolving names in a CREATE statement */
 #define NC_InAggFunc 0x020000 /* True if analyzing arguments to an agg func */
 #define NC_FromDDL   0x040000 /* SQL text comes from sqlite_schema */
 #define NC_NoSelect  0x080000 /* Do not descend into sub-selects */
+#define NC_Where     0x100000 /* Processing WHERE clause of a SELECT */
 #define NC_OrderAgg 0x8000000 /* Has an aggregate other than count/min/max */
 
 /*
@@ -19369,6 +19679,7 @@ struct Upsert {
   Expr *pUpsertWhere;       /* WHERE clause for the ON CONFLICT UPDATE */
   Upsert *pNextUpsert;      /* Next ON CONFLICT clause in the list */
   u8 isDoUpdate;            /* True for DO UPDATE.  False for DO NOTHING */
+  u8 isDup;                 /* True if 2nd or later with same pUpsertIdx */
   /* Above this point is the parse tree for the ON CONFLICT clauses.
   ** The next group of fields stores intermediate data. */
   void *pToFree;            /* Free memory when deleting the Upsert object */
@@ -19458,14 +19769,17 @@ struct Select {
 #define SF_View          0x0200000 /* SELECT statement is a view */
 #define SF_NoopOrderBy   0x0400000 /* ORDER BY is ignored for this query */
 #define SF_UFSrcCheck    0x0800000 /* Check pSrc as required by UPDATE...FROM */
-#define SF_PushDown      0x1000000 /* SELECT has be modified by push-down opt */
+#define SF_PushDown      0x1000000 /* Modified by WHERE-clause push-down opt */
 #define SF_MultiPart     0x2000000 /* Has multiple incompatible PARTITIONs */
 #define SF_CopyCte       0x4000000 /* SELECT statement is a copy of a CTE */
 #define SF_OrderByReqd   0x8000000 /* The ORDER BY clause may not be omitted */
 #define SF_UpdateFrom   0x10000000 /* Query originates with UPDATE FROM */
+#define SF_Correlated   0x20000000 /* True if references the outer context */
 
-/* True if S exists and has SF_NestedFrom */
-#define IsNestedFrom(S) ((S)!=0 && ((S)->selFlags&SF_NestedFrom)!=0)
+/* True if SrcItem X is a subquery that has SF_NestedFrom */
+#define IsNestedFrom(X) \
+   ((X)->fg.isSubquery && \
+    ((X)->u4.pSubq->pSelect->selFlags&SF_NestedFrom)!=0)
 
 /*
 ** The results of a SELECT can be distributed in several ways, as defined
@@ -19495,7 +19809,11 @@ struct Select {
 **     SRT_Set         The result must be a single column.  Store each
 **                     row of result as the key in table pDest->iSDParm.
 **                     Apply the affinity pDest->affSdst before storing
-**                     results.  Used to implement "IN (SELECT ...)".
+**                     results.  if pDest->iSDParm2 is positive, then it is
+**                     a register holding a Bloom filter for the IN operator
+**                     that should be populated in addition to the
+**                     pDest->iSDParm table.  This SRT is used to
+**                     implement "IN (SELECT ...)".
 **
 **     SRT_EphemTab    Create an temporary table pDest->iSDParm and store
 **                     the result there. The cursor is left open after
@@ -19702,6 +20020,8 @@ struct Parse {
   u8 disableLookaside; /* Number of times lookaside has been disabled */
   u8 prepFlags;        /* SQLITE_PREPARE_* flags */
   u8 withinRJSubrtn;   /* Nesting level for RIGHT JOIN body subroutines */
+  u8 bHasWith;         /* True if statement contains WITH */
+  u8 mSubrtnSig;       /* mini Bloom filter on available SubrtnSig.selId */
 #if defined(SQLITE_DEBUG) || defined(SQLITE_COVERAGE_TEST)
   u8 earlyCleanup;     /* OOM inside sqlite3ParserAddCleanup() */
 #endif
@@ -19997,7 +20317,7 @@ struct Returning {
 };
 
 /*
-** An objected used to accumulate the text of a string where we
+** An object used to accumulate the text of a string where we
 ** do not necessarily know how big the string will be in the end.
 */
 struct sqlite3_str {
@@ -20011,7 +20331,7 @@ struct sqlite3_str {
 };
 #define SQLITE_PRINTF_INTERNAL 0x01  /* Internal-use-only converters allowed */
 #define SQLITE_PRINTF_SQLFUNC  0x02  /* SQL function arguments to VXPrintf */
-#define SQLITE_PRINTF_MALLOCED 0x04  /* True if xText is allocated space */
+#define SQLITE_PRINTF_MALLOCED 0x04  /* True if zText is allocated space */
 
 #define isMalloced(X)  (((X)->printfFlags & SQLITE_PRINTF_MALLOCED)!=0)
 
@@ -20089,7 +20409,6 @@ struct Sqlite3Config {
   u8 bUseCis;                       /* Use covering indices for full-scans */
   u8 bSmallMalloc;                  /* Avoid large memory allocations if true */
   u8 bExtraSchemaChecks;            /* Verify type,name,tbl_name in schema */
-  u8 bUseLongDouble;                /* Make use of long double */
 #ifdef SQLITE_DEBUG
   u8 bJsonSelfcheck;                /* Double-check JSON parsing */
 #endif
@@ -20139,6 +20458,11 @@ struct Sqlite3Config {
 #endif
 #ifndef SQLITE_UNTESTABLE
   int (*xTestCallback)(int);        /* Invoked by sqlite3FaultSim() */
+#endif
+#ifdef SQLITE_ALLOW_ROWID_IN_VIEW
+  u32 mNoVisibleRowid;              /* TF_NoVisibleRowid if the ROWID_IN_VIEW
+                                    ** feature is disabled.  0 if rowids can
+                                    ** occur in views. */
 #endif
   int bLocaltimeFault;              /* True to fail localtime() calls */
   int (*xAltLocaltime)(const void*,void*); /* Alternative localtime() routine */
@@ -20376,6 +20700,9 @@ struct Window {
                           ** due to the SQLITE_SUBTYPE flag */
 };
 
+SQLITE_PRIVATE Select *sqlite3MultiValues(Parse *pParse, Select *pLeft, ExprList *pRow);
+SQLITE_PRIVATE void sqlite3MultiValuesEnd(Parse *pParse, Select *pVal);
+
 #ifndef SQLITE_OMIT_WINDOWFUNC
 SQLITE_PRIVATE void sqlite3WindowDelete(sqlite3*, Window*);
 SQLITE_PRIVATE void sqlite3WindowUnlinkFromSelect(Window*);
@@ -20456,15 +20783,6 @@ SQLITE_PRIVATE   int sqlite3CorruptPgnoError(int,Pgno);
 # define SQLITE_ENABLE_FTS3 1
 #endif
 
-/*
-** The ctype.h header is needed for non-ASCII systems.  It is also
-** needed by FTS3 when FTS3 is included in the amalgamation.
-*/
-#if !defined(SQLITE_ASCII) || \
-    (defined(SQLITE_ENABLE_FTS3) && defined(SQLITE_AMALGAMATION))
-# include <ctype.h>
-#endif
-
 /*
 ** The following macros mimic the standard library functions toupper(),
 ** isspace(), isalnum(), isdigit() and isxdigit(), respectively. The
@@ -20595,10 +20913,13 @@ SQLITE_PRIVATE void sqlite3MutexWarnOnContention(sqlite3_mutex*);
 # define EXP754 (((u64)0x7ff)<<52)
 # define MAN754 ((((u64)1)<<52)-1)
 # define IsNaN(X) (((X)&EXP754)==EXP754 && ((X)&MAN754)!=0)
+# define IsOvfl(X) (((X)&EXP754)==EXP754)
 SQLITE_PRIVATE   int sqlite3IsNaN(double);
+SQLITE_PRIVATE   int sqlite3IsOverflow(double);
 #else
-# define IsNaN(X)         0
-# define sqlite3IsNaN(X)  0
+# define IsNaN(X)             0
+# define sqlite3IsNaN(X)      0
+# define sqlite3IsOVerflow(X) 0
 #endif
 
 /*
@@ -20690,6 +21011,7 @@ SQLITE_PRIVATE int sqlite3ErrorToParser(sqlite3*,int);
 SQLITE_PRIVATE void sqlite3Dequote(char*);
 SQLITE_PRIVATE void sqlite3DequoteExpr(Expr*);
 SQLITE_PRIVATE void sqlite3DequoteToken(Token*);
+SQLITE_PRIVATE void sqlite3DequoteNumber(Parse*, Expr*);
 SQLITE_PRIVATE void sqlite3TokenInit(Token*,char*);
 SQLITE_PRIVATE int sqlite3KeywordCode(const unsigned char*, int);
 SQLITE_PRIVATE int sqlite3RunParser(Parse*, const char*);
@@ -20720,7 +21042,7 @@ SQLITE_PRIVATE void sqlite3ExprFunctionUsable(Parse*,const Expr*,const FuncDef*)
 SQLITE_PRIVATE void sqlite3ExprAssignVarNumber(Parse*, Expr*, u32);
 SQLITE_PRIVATE void sqlite3ExprDelete(sqlite3*, Expr*);
 SQLITE_PRIVATE void sqlite3ExprDeleteGeneric(sqlite3*,void*);
-SQLITE_PRIVATE void sqlite3ExprDeferredDelete(Parse*, Expr*);
+SQLITE_PRIVATE int sqlite3ExprDeferredDelete(Parse*, Expr*);
 SQLITE_PRIVATE void sqlite3ExprUnmapAndDelete(Parse*, Expr*);
 SQLITE_PRIVATE ExprList *sqlite3ExprListAppend(Parse*,ExprList*,Expr*);
 SQLITE_PRIVATE ExprList *sqlite3ExprListAppendVector(Parse*,ExprList*,IdList*,Expr*);
@@ -20839,6 +21161,9 @@ SQLITE_PRIVATE int sqlite3IdListIndex(IdList*,const char*);
 SQLITE_PRIVATE SrcList *sqlite3SrcListEnlarge(Parse*, SrcList*, int, int);
 SQLITE_PRIVATE SrcList *sqlite3SrcListAppendList(Parse *pParse, SrcList *p1, SrcList *p2);
 SQLITE_PRIVATE SrcList *sqlite3SrcListAppend(Parse*, SrcList*, Token*, Token*);
+SQLITE_PRIVATE void sqlite3SubqueryDelete(sqlite3*,Subquery*);
+SQLITE_PRIVATE Select *sqlite3SubqueryDetach(sqlite3*,SrcItem*);
+SQLITE_PRIVATE int sqlite3SrcItemAttachSubquery(Parse*, SrcItem*, Select*, int);
 SQLITE_PRIVATE SrcList *sqlite3SrcListAppendFromTerm(Parse*, SrcList*, Token*, Token*,
                                       Token*, Select*, OnOrUsing*);
 SQLITE_PRIVATE void sqlite3SrcListIndexedBy(Parse *, SrcList *, Token *);
@@ -20888,6 +21213,7 @@ SQLITE_PRIVATE void sqlite3ExprCodeLoadIndexColumn(Parse*, Index*, int, int, int
 SQLITE_PRIVATE int sqlite3ExprCodeGetColumn(Parse*, Table*, int, int, int, u8);
 SQLITE_PRIVATE void sqlite3ExprCodeGetColumnOfTable(Vdbe*, Table*, int, int, int);
 SQLITE_PRIVATE void sqlite3ExprCodeMove(Parse*, int, int, int);
+SQLITE_PRIVATE void sqlite3ExprToRegister(Expr *pExpr, int iReg);
 SQLITE_PRIVATE void sqlite3ExprCode(Parse*, Expr*, int);
 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
 SQLITE_PRIVATE void sqlite3ExprCodeGeneratedColumn(Parse*, Table*, Column*, int);
@@ -20943,16 +21269,14 @@ SQLITE_PRIVATE void sqlite3LeaveMutexAndCloseZombie(sqlite3*);
 SQLITE_PRIVATE u32 sqlite3IsTrueOrFalse(const char*);
 SQLITE_PRIVATE int sqlite3ExprIdToTrueFalse(Expr*);
 SQLITE_PRIVATE int sqlite3ExprTruthValue(const Expr*);
-SQLITE_PRIVATE int sqlite3ExprIsConstant(Expr*);
-SQLITE_PRIVATE int sqlite3ExprIsConstantNotJoin(Expr*);
+SQLITE_PRIVATE int sqlite3ExprIsConstant(Parse*,Expr*);
 SQLITE_PRIVATE int sqlite3ExprIsConstantOrFunction(Expr*, u8);
 SQLITE_PRIVATE int sqlite3ExprIsConstantOrGroupBy(Parse*, Expr*, ExprList*);
-SQLITE_PRIVATE int sqlite3ExprIsTableConstant(Expr*,int);
-SQLITE_PRIVATE int sqlite3ExprIsSingleTableConstraint(Expr*,const SrcList*,int);
+SQLITE_PRIVATE int sqlite3ExprIsSingleTableConstraint(Expr*,const SrcList*,int,int);
 #ifdef SQLITE_ENABLE_CURSOR_HINTS
 SQLITE_PRIVATE int sqlite3ExprContainsSubquery(Expr*);
 #endif
-SQLITE_PRIVATE int sqlite3ExprIsInteger(const Expr*, int*);
+SQLITE_PRIVATE int sqlite3ExprIsInteger(const Expr*, int*, Parse*);
 SQLITE_PRIVATE int sqlite3ExprCanBeNull(const Expr*);
 SQLITE_PRIVATE int sqlite3ExprNeedsNoAffinityChange(const Expr*, char);
 SQLITE_PRIVATE int sqlite3IsRowid(const char*);
@@ -21080,7 +21404,7 @@ SQLITE_PRIVATE int sqlite3GetInt32(const char *, int*);
 SQLITE_PRIVATE int sqlite3GetUInt32(const char*, u32*);
 SQLITE_PRIVATE int sqlite3Atoi(const char*);
 #ifndef SQLITE_OMIT_UTF16
-SQLITE_PRIVATE int sqlite3Utf16ByteLen(const void *pData, int nChar);
+SQLITE_PRIVATE int sqlite3Utf16ByteLen(const void *pData, int nByte, int nChar);
 #endif
 SQLITE_PRIVATE int sqlite3Utf8CharLen(const char *pData, int nByte);
 SQLITE_PRIVATE u32 sqlite3Utf8Read(const u8**);
@@ -21133,7 +21457,9 @@ SQLITE_PRIVATE void sqlite3ErrorWithMsg(sqlite3*, int, const char*,...);
 SQLITE_PRIVATE void sqlite3Error(sqlite3*,int);
 SQLITE_PRIVATE void sqlite3ErrorClear(sqlite3*);
 SQLITE_PRIVATE void sqlite3SystemError(sqlite3*,int);
+#if !defined(SQLITE_OMIT_BLOB_LITERAL)
 SQLITE_PRIVATE void *sqlite3HexToBlob(sqlite3*, const char *z, int n);
+#endif
 SQLITE_PRIVATE u8 sqlite3HexToInt(int h);
 SQLITE_PRIVATE int sqlite3TwoPartName(Parse *, Token *, Token *, Token **);
 
@@ -21444,7 +21770,7 @@ SQLITE_PRIVATE   With *sqlite3WithPush(Parse*, With*, u8);
 SQLITE_PRIVATE   Upsert *sqlite3UpsertNew(sqlite3*,ExprList*,Expr*,ExprList*,Expr*,Upsert*);
 SQLITE_PRIVATE   void sqlite3UpsertDelete(sqlite3*,Upsert*);
 SQLITE_PRIVATE   Upsert *sqlite3UpsertDup(sqlite3*,Upsert*);
-SQLITE_PRIVATE   int sqlite3UpsertAnalyzeTarget(Parse*,SrcList*,Upsert*);
+SQLITE_PRIVATE   int sqlite3UpsertAnalyzeTarget(Parse*,SrcList*,Upsert*,Upsert*);
 SQLITE_PRIVATE   void sqlite3UpsertDoUpdate(Parse*,Upsert*,Table*,Index*,int);
 SQLITE_PRIVATE   Upsert *sqlite3UpsertOfIndex(Upsert*,Index*);
 SQLITE_PRIVATE   int sqlite3UpsertNextIsIPK(Upsert*);
@@ -21834,6 +22160,9 @@ static const char * const sqlite3azCompileOpt[] = {
   "ALLOW_COVERING_INDEX_SCAN=" CTIMEOPT_VAL(SQLITE_ALLOW_COVERING_INDEX_SCAN),
 # endif
 #endif
+#ifdef SQLITE_ALLOW_ROWID_IN_VIEW
+  "ALLOW_ROWID_IN_VIEW",
+#endif
 #ifdef SQLITE_ALLOW_URI_AUTHORITY
   "ALLOW_URI_AUTHORITY",
 #endif
@@ -22061,6 +22390,9 @@ static const char * const sqlite3azCompileOpt[] = {
 #ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC
   "ENABLE_OFFSET_SQL_FUNC",
 #endif
+#ifdef SQLITE_ENABLE_ORDERED_SET_AGGREGATES
+  "ENABLE_ORDERED_SET_AGGREGATES",
+#endif
 #ifdef SQLITE_ENABLE_OVERSIZE_CELL_CHECK
   "ENABLE_OVERSIZE_CELL_CHECK",
 #endif
@@ -22808,7 +23140,6 @@ SQLITE_PRIVATE SQLITE_WSD struct Sqlite3Config sqlite3Config = {
    SQLITE_ALLOW_COVERING_INDEX_SCAN,   /* bUseCis */
    0,                         /* bSmallMalloc */
    1,                         /* bExtraSchemaChecks */
-   sizeof(LONGDOUBLE_TYPE)>8, /* bUseLongDouble */
 #ifdef SQLITE_DEBUG
    0,                         /* bJsonSelfcheck */
 #endif
@@ -22853,6 +23184,9 @@ SQLITE_PRIVATE SQLITE_WSD struct Sqlite3Config sqlite3Config = {
 #endif
 #ifndef SQLITE_UNTESTABLE
    0,                         /* xTestCallback */
+#endif
+#ifdef SQLITE_ALLOW_ROWID_IN_VIEW
+   0,                         /* mNoVisibleRowid.  0 == allow rowid-in-view */
 #endif
    0,                         /* bLocaltimeFault */
    0,                         /* xAltLocaltime */
@@ -23528,6 +23862,7 @@ struct PreUpdate {
   Mem *aNew;                      /* Array of new.* values */
   Table *pTab;                    /* Schema object being updated */
   Index *pPk;                     /* PK index if pTab is WITHOUT ROWID */
+  sqlite3_value **apDflt;         /* Array of default values, if required */
 };
 
 /*
@@ -24174,13 +24509,14 @@ struct DateTime {
   int tz;             /* Timezone offset in minutes */
   double s;           /* Seconds */
   char validJD;       /* True (1) if iJD is valid */
-  char rawS;          /* Raw numeric value stored in s */
   char validYMD;      /* True (1) if Y,M,D are valid */
   char validHMS;      /* True (1) if h,m,s are valid */
-  char validTZ;       /* True (1) if tz is valid */
-  char tzSet;         /* Timezone was set explicitly */
-  char isError;       /* An overflow has occurred */
-  char useSubsec;     /* Display subsecond precision */
+  char nFloor;            /* Days to implement "floor" */
+  unsigned rawS      : 1; /* Raw numeric value stored in s */
+  unsigned isError   : 1; /* An overflow has occurred */
+  unsigned useSubsec : 1; /* Display subsecond precision */
+  unsigned isUtc     : 1; /* Time is known to be UTC */
+  unsigned isLocal   : 1; /* Time is known to be localtime */
 };
 
 
@@ -24278,6 +24614,8 @@ static int parseTimezone(const char *zDate, DateTime *p){
     sgn = +1;
   }else if( c=='Z' || c=='z' ){
     zDate++;
+    p->isLocal = 0;
+    p->isUtc = 1;
     goto zulu_time;
   }else{
     return c!=0;
@@ -24290,7 +24628,6 @@ static int parseTimezone(const char *zDate, DateTime *p){
   p->tz = sgn*(nMn + nHr*60);
 zulu_time:
   while( sqlite3Isspace(*zDate) ){ zDate++; }
-  p->tzSet = 1;
   return *zDate!=0;
 }
 
@@ -24334,7 +24671,6 @@ static int parseHhMmSs(const char *zDate, DateTime *p){
   p->m = m;
   p->s = s + ms;
   if( parseTimezone(zDate, p) ) return 1;
-  p->validTZ = (p->tz!=0)?1:0;
   return 0;
 }
 
@@ -24373,23 +24709,48 @@ static void computeJD(DateTime *p){
     Y--;
     M += 12;
   }
-  A = Y/100;
-  B = 2 - A + (A/4);
+  A = (Y+4800)/100;
+  B = 38 - A + (A/4);
   X1 = 36525*(Y+4716)/100;
   X2 = 306001*(M+1)/10000;
   p->iJD = (sqlite3_int64)((X1 + X2 + D + B - 1524.5 ) * 86400000);
   p->validJD = 1;
   if( p->validHMS ){
     p->iJD += p->h*3600000 + p->m*60000 + (sqlite3_int64)(p->s*1000 + 0.5);
-    if( p->validTZ ){
+    if( p->tz ){
       p->iJD -= p->tz*60000;
       p->validYMD = 0;
       p->validHMS = 0;
-      p->validTZ = 0;
+      p->tz = 0;
+      p->isUtc = 1;
+      p->isLocal = 0;
     }
   }
 }
 
+/*
+** Given the YYYY-MM-DD information current in p, determine if there
+** is day-of-month overflow and set nFloor to the number of days that
+** would need to be subtracted from the date in order to bring the
+** date back to the end of the month.
+*/
+static void computeFloor(DateTime *p){
+  assert( p->validYMD || p->isError );
+  assert( p->D>=0 && p->D<=31 );
+  assert( p->M>=0 && p->M<=12 );
+  if( p->D<=28 ){
+    p->nFloor = 0;
+  }else if( (1<<p->M) & 0x15aa ){
+    p->nFloor = 0;
+  }else if( p->M!=2 ){
+    p->nFloor = (p->D==31);
+  }else if( p->Y%4!=0 || (p->Y%100==0 && p->Y%400!=0) ){
+    p->nFloor = p->D - 28;
+  }else{
+    p->nFloor = p->D - 29;
+  }
+}
+
 /*
 ** Parse dates of the form
 **
@@ -24428,12 +24789,16 @@ static int parseYyyyMmDd(const char *zDate, DateTime *p){
   p->Y = neg ? -Y : Y;
   p->M = M;
   p->D = D;
-  if( p->validTZ ){
+  computeFloor(p);
+  if( p->tz ){
     computeJD(p);
   }
   return 0;
 }
 
+
+static void clearYMD_HMS_TZ(DateTime *p);  /* Forward declaration */
+
 /*
 ** Set the time to the current time reported by the VFS.
 **
@@ -24443,6 +24808,9 @@ static int setDateTimeToCurrent(sqlite3_context *context, DateTime *p){
   p->iJD = sqlite3StmtCurrentTime(context);
   if( p->iJD>0 ){
     p->validJD = 1;
+    p->isUtc = 1;
+    p->isLocal = 0;
+    clearYMD_HMS_TZ(p);
     return 0;
   }else{
     return 1;
@@ -24526,7 +24894,7 @@ static int validJulianDay(sqlite3_int64 iJD){
 ** Compute the Year, Month, and Day from the julian day number.
 */
 static void computeYMD(DateTime *p){
-  int Z, A, B, C, D, E, X1;
+  int Z, alpha, A, B, C, D, E, X1;
   if( p->validYMD ) return;
   if( !p->validJD ){
     p->Y = 2000;
@@ -24537,8 +24905,8 @@ static void computeYMD(DateTime *p){
     return;
   }else{
     Z = (int)((p->iJD + 43200000)/86400000);
-    A = (int)((Z - 1867216.25)/36524.25);
-    A = Z + 1 + A - (A/4);
+    alpha = (int)((Z + 32044.75)/36524.25) - 52;
+    A = Z + 1 + alpha - ((alpha+100)/4) + 25;
     B = A + 1524;
     C = (int)((B - 122.1)/365.25);
     D = (36525*(C&32767))/100;
@@ -24581,7 +24949,7 @@ static void computeYMD_HMS(DateTime *p){
 static void clearYMD_HMS_TZ(DateTime *p){
   p->validYMD = 0;
   p->validHMS = 0;
-  p->validTZ = 0;
+  p->tz = 0;
 }
 
 #ifndef SQLITE_OMIT_LOCALTIME
@@ -24713,7 +25081,7 @@ static int toLocaltime(
   p->validHMS = 1;
   p->validJD = 0;
   p->rawS = 0;
-  p->validTZ = 0;
+  p->tz = 0;
   p->isError = 0;
   return SQLITE_OK;
 }
@@ -24733,12 +25101,12 @@ static const struct {
   float rLimit;       /* Maximum NNN value for this transform */
   float rXform;       /* Constant used for this transform */
 } aXformType[] = {
-  { 6, "second", 4.6427e+14,       1.0  },
-  { 6, "minute", 7.7379e+12,      60.0  },
-  { 4, "hour",   1.2897e+11,    3600.0  },
-  { 3, "day",    5373485.0,    86400.0  },
-  { 5, "month",  176546.0,   2592000.0  },
-  { 4, "year",   14713.0,   31536000.0  },
+  /* 0 */ { 6, "second",   4.6427e+14,         1.0  },
+  /* 1 */ { 6, "minute",   7.7379e+12,        60.0  },
+  /* 2 */ { 4, "hour",     1.2897e+11,      3600.0  },
+  /* 3 */ { 3, "day",      5373485.0,      86400.0  },
+  /* 4 */ { 5, "month",    176546.0,     2592000.0  },
+  /* 5 */ { 4, "year",     14713.0,     31536000.0  },
 };
 
 /*
@@ -24770,14 +25138,20 @@ static void autoAdjustDate(DateTime *p){
 **     NNN.NNNN seconds
 **     NNN months
 **     NNN years
+**     +/-YYYY-MM-DD HH:MM:SS.SSS
+**     ceiling
+**     floor
 **     start of month
 **     start of year
 **     start of week
 **     start of day
 **     weekday N
 **     unixepoch
+**     auto
 **     localtime
 **     utc
+**     subsec
+**     subsecond
 **
 ** Return 0 on success and 1 if there is any kind of error. If the error
 ** is in a system call (i.e. localtime()), then an error message is written
@@ -24808,6 +25182,37 @@ static int parseModifier(
       }
       break;
     }
+    case 'c': {
+      /*
+      **    ceiling
+      **
+      ** Resolve day-of-month overflow by rolling forward into the next
+      ** month.  As this is the default action, this modifier is really
+      ** a no-op that is only included for symmetry.  See "floor".
+      */
+      if( sqlite3_stricmp(z, "ceiling")==0 ){
+        computeJD(p);
+        clearYMD_HMS_TZ(p);
+        rc = 0;
+        p->nFloor = 0;
+      }
+      break;
+    }
+    case 'f': {
+      /*
+      **    floor
+      **
+      ** Resolve day-of-month overflow by rolling back to the end of the
+      ** previous month.
+      */
+      if( sqlite3_stricmp(z, "floor")==0 ){
+        computeJD(p);
+        p->iJD -= p->nFloor*86400000;
+        clearYMD_HMS_TZ(p);
+        rc = 0;
+      }
+      break;
+    }
     case 'j': {
       /*
       **    julianday
@@ -24834,7 +25239,9 @@ static int parseModifier(
       ** show local time.
       */
       if( sqlite3_stricmp(z, "localtime")==0 && sqlite3NotPureFunc(pCtx) ){
-        rc = toLocaltime(p, pCtx);
+        rc = p->isLocal ? SQLITE_OK : toLocaltime(p, pCtx);
+        p->isUtc = 0;
+        p->isLocal = 1;
       }
       break;
     }
@@ -24859,7 +25266,7 @@ static int parseModifier(
       }
 #ifndef SQLITE_OMIT_LOCALTIME
       else if( sqlite3_stricmp(z, "utc")==0 && sqlite3NotPureFunc(pCtx) ){
-        if( p->tzSet==0 ){
+        if( p->isUtc==0 ){
           i64 iOrigJD;              /* Original localtime */
           i64 iGuess;               /* Guess at the corresponding utc time */
           int cnt = 0;              /* Safety to prevent infinite loop */
@@ -24882,7 +25289,8 @@ static int parseModifier(
           memset(p, 0, sizeof(*p));
           p->iJD = iGuess;
           p->validJD = 1;
-          p->tzSet = 1;
+          p->isUtc = 1;
+          p->isLocal = 0;
         }
         rc = SQLITE_OK;
       }
@@ -24902,7 +25310,7 @@ static int parseModifier(
                && r>=0.0 && r<7.0 && (n=(int)r)==r ){
         sqlite3_int64 Z;
         computeYMD_HMS(p);
-        p->validTZ = 0;
+        p->tz = 0;
         p->validJD = 0;
         computeJD(p);
         Z = ((p->iJD + 129600000)/86400000) % 7;
@@ -24942,7 +25350,7 @@ static int parseModifier(
       p->h = p->m = 0;
       p->s = 0.0;
       p->rawS = 0;
-      p->validTZ = 0;
+      p->tz = 0;
       p->validJD = 0;
       if( sqlite3_stricmp(z,"month")==0 ){
         p->D = 1;
@@ -25013,6 +25421,7 @@ static int parseModifier(
         x = p->M>0 ? (p->M-1)/12 : (p->M-12)/12;
         p->Y += x;
         p->M -= x*12;
+        computeFloor(p);
         computeJD(p);
         p->validHMS = 0;
         p->validYMD = 0;
@@ -25059,11 +25468,12 @@ static int parseModifier(
       z += n;
       while( sqlite3Isspace(*z) ) z++;
       n = sqlite3Strlen30(z);
-      if( n>10 || n<3 ) break;
+      if( n<3 || n>10 ) break;
       if( sqlite3UpperToLower[(u8)z[n-1]]=='s' ) n--;
       computeJD(p);
       assert( rc==1 );
       rRounder = r<0 ? -0.5 : +0.5;
+      p->nFloor = 0;
       for(i=0; i<ArraySize(aXformType); i++){
         if( aXformType[i].nName==n
          && sqlite3_strnicmp(aXformType[i].zName, z, n)==0
@@ -25071,21 +25481,24 @@ static int parseModifier(
         ){
           switch( i ){
             case 4: { /* Special processing to add months */
-              assert( strcmp(aXformType[i].zName,"month")==0 );
+              assert( strcmp(aXformType[4].zName,"month")==0 );
               computeYMD_HMS(p);
               p->M += (int)r;
               x = p->M>0 ? (p->M-1)/12 : (p->M-12)/12;
               p->Y += x;
               p->M -= x*12;
+              computeFloor(p);
               p->validJD = 0;
               r -= (int)r;
               break;
             }
             case 5: { /* Special processing to add years */
               int y = (int)r;
-              assert( strcmp(aXformType[i].zName,"year")==0 );
+              assert( strcmp(aXformType[5].zName,"year")==0 );
               computeYMD_HMS(p);
+              assert( p->M>=0 && p->M<=12 );
               p->Y += y;
+              computeFloor(p);
               p->validJD = 0;
               r -= (int)r;
               break;
@@ -25339,22 +25752,83 @@ static void dateFunc(
   }
 }
 
+/*
+** Compute the number of days after the most recent January 1.
+**
+** In other words, compute the zero-based day number for the
+** current year:
+**
+**   Jan01 = 0,  Jan02 = 1, ..., Jan31 = 30, Feb01 = 31, ...
+**   Dec31 = 364 or 365.
+*/
+static int daysAfterJan01(DateTime *pDate){
+  DateTime jan01 = *pDate;
+  assert( jan01.validYMD );
+  assert( jan01.validHMS );
+  assert( pDate->validJD );
+  jan01.validJD = 0;
+  jan01.M = 1;
+  jan01.D = 1;
+  computeJD(&jan01);
+  return (int)((pDate->iJD-jan01.iJD+43200000)/86400000);
+}
+
+/*
+** Return the number of days after the most recent Monday.
+**
+** In other words, return the day of the week according
+** to this code:
+**
+**   0=Monday, 1=Tuesday, 2=Wednesday, ..., 6=Sunday.
+*/
+static int daysAfterMonday(DateTime *pDate){
+  assert( pDate->validJD );
+  return (int)((pDate->iJD+43200000)/86400000) % 7;
+}
+
+/*
+** Return the number of days after the most recent Sunday.
+**
+** In other words, return the day of the week according
+** to this code:
+**
+**   0=Sunday, 1=Monday, 2=Tues, ..., 6=Saturday
+*/
+static int daysAfterSunday(DateTime *pDate){
+  assert( pDate->validJD );
+  return (int)((pDate->iJD+129600000)/86400000) % 7;
+}
+
 /*
 **    strftime( FORMAT, TIMESTRING, MOD, MOD, ...)
 **
 ** Return a string described by FORMAT.  Conversions as follows:
 **
-**   %d  day of month
+**   %d  day of month  01-31
+**   %e  day of month  1-31
 **   %f  ** fractional seconds  SS.SSS
+**   %F  ISO date.  YYYY-MM-DD
+**   %G  ISO year corresponding to %V 0000-9999.
+**   %g  2-digit ISO year corresponding to %V 00-99
 **   %H  hour 00-24
-**   %j  day of year 000-366
+**   %k  hour  0-24  (leading zero converted to space)
+**   %I  hour 01-12
+**   %j  day of year 001-366
 **   %J  ** julian day number
+**   %l  hour  1-12  (leading zero converted to space)
 **   %m  month 01-12
 **   %M  minute 00-59
+**   %p  "am" or "pm"
+**   %P  "AM" or "PM"
+**   %R  time as HH:MM
 **   %s  seconds since 1970-01-01
 **   %S  seconds 00-59
-**   %w  day of week 0-6  Sunday==0
-**   %W  week of year 00-53
+**   %T  time as HH:MM:SS
+**   %u  day of week 1-7  Monday==1, Sunday==7
+**   %w  day of week 0-6  Sunday==0, Monday==1
+**   %U  week of year 00-53  (First Sunday is start of week 01)
+**   %V  week of year 01-53  (First week containing Thursday is week 01)
+**   %W  week of year 00-53  (First Monday is start of week 01)
 **   %Y  year 0000-9999
 **   %%  %
 */
@@ -25391,7 +25865,7 @@ static void strftimeFunc(
         sqlite3_str_appendf(&sRes, cf=='d' ? "%02d" : "%2d", x.D);
         break;
       }
-      case 'f': {
+      case 'f': {  /* Fractional seconds.  (Non-standard) */
         double s = x.s;
         if( s>59.999 ) s = 59.999;
         sqlite3_str_appendf(&sRes, "%06.3f", s);
@@ -25401,6 +25875,21 @@ static void strftimeFunc(
         sqlite3_str_appendf(&sRes, "%04d-%02d-%02d", x.Y, x.M, x.D);
         break;
       }
+      case 'G': /* Fall thru */
+      case 'g': {
+        DateTime y = x;
+        assert( y.validJD );
+        /* Move y so that it is the Thursday in the same week as x */
+        y.iJD += (3 - daysAfterMonday(&x))*86400000;
+        y.validYMD = 0;
+        computeYMD(&y);
+        if( cf=='g' ){
+          sqlite3_str_appendf(&sRes, "%02d", y.Y%100);
+        }else{
+          sqlite3_str_appendf(&sRes, "%04d", y.Y);
+        }
+        break;
+      }
       case 'H':
       case 'k': {
         sqlite3_str_appendf(&sRes, cf=='H' ? "%02d" : "%2d", x.h);
@@ -25414,25 +25903,11 @@ static void strftimeFunc(
         sqlite3_str_appendf(&sRes, cf=='I' ? "%02d" : "%2d", h);
         break;
       }
-      case 'W': /* Fall thru */
-      case 'j': {
-        int nDay;             /* Number of days since 1st day of year */
-        DateTime y = x;
-        y.validJD = 0;
-        y.M = 1;
-        y.D = 1;
-        computeJD(&y);
-        nDay = (int)((x.iJD-y.iJD+43200000)/86400000);
-        if( cf=='W' ){
-          int wd;   /* 0=Monday, 1=Tuesday, ... 6=Sunday */
-          wd = (int)(((x.iJD+43200000)/86400000)%7);
-          sqlite3_str_appendf(&sRes,"%02d",(nDay+7-wd)/7);
-        }else{
-          sqlite3_str_appendf(&sRes,"%03d",nDay+1);
-        }
+      case 'j': {  /* Day of year.  Jan01==1, Jan02==2, and so forth */
+        sqlite3_str_appendf(&sRes,"%03d",daysAfterJan01(&x)+1);
         break;
       }
-      case 'J': {
+      case 'J': {  /* Julian day number.  (Non-standard) */
         sqlite3_str_appendf(&sRes,"%.16g",x.iJD/86400000.0);
         break;
       }
@@ -25475,13 +25950,33 @@ static void strftimeFunc(
         sqlite3_str_appendf(&sRes,"%02d:%02d:%02d", x.h, x.m, (int)x.s);
         break;
       }
-      case 'u': /* Fall thru */
-      case 'w': {
-        char c = (char)(((x.iJD+129600000)/86400000) % 7) + '0';
+      case 'u':    /* Day of week.  1 to 7.  Monday==1, Sunday==7 */
+      case 'w': {  /* Day of week.  0 to 6.  Sunday==0, Monday==1 */
+        char c = (char)daysAfterSunday(&x) + '0';
         if( c=='0' && cf=='u' ) c = '7';
         sqlite3_str_appendchar(&sRes, 1, c);
         break;
       }
+      case 'U': {  /* Week num. 00-53. First Sun of the year is week 01 */
+        sqlite3_str_appendf(&sRes,"%02d",
+              (daysAfterJan01(&x)-daysAfterSunday(&x)+7)/7);
+        break;
+      }
+      case 'V': {  /* Week num. 01-53. First week with a Thur is week 01 */
+        DateTime y = x;
+        /* Adjust y so that is the Thursday in the same week as x */
+        assert( y.validJD );
+        y.iJD += (3 - daysAfterMonday(&x))*86400000;
+        y.validYMD = 0;
+        computeYMD(&y);
+        sqlite3_str_appendf(&sRes,"%02d", daysAfterJan01(&y)/7+1);
+        break;
+      }
+      case 'W': {  /* Week num. 00-53. First Mon of the year is week 01 */
+        sqlite3_str_appendf(&sRes,"%02d",
+           (daysAfterJan01(&x)-daysAfterMonday(&x)+7)/7);
+        break;
+      }
       case 'Y': {
         sqlite3_str_appendf(&sRes,"%04d",x.Y);
         break;
@@ -25628,9 +26123,7 @@ static void timediffFunc(
     d1.iJD = d2.iJD - d1.iJD;
     d1.iJD += (u64)1486995408 * (u64)100000;
   }
-  d1.validYMD = 0;
-  d1.validHMS = 0;
-  d1.validTZ = 0;
+  clearYMD_HMS_TZ(&d1);
   computeYMD_HMS(&d1);
   sqlite3StrAccumInit(&sRes, 0, 0, 0, 100);
   sqlite3_str_appendf(&sRes, "%c%04d-%02d-%02d %02d:%02d:%06.3f",
@@ -25699,6 +26192,36 @@ static void currentTimeFunc(
 }
 #endif
 
+#if !defined(SQLITE_OMIT_DATETIME_FUNCS) && defined(SQLITE_DEBUG)
+/*
+**   datedebug(...)
+**
+** This routine returns JSON that describes the internal DateTime object.
+** Used for debugging and testing only.  Subject to change.
+*/
+static void datedebugFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  DateTime x;
+  if( isDate(context, argc, argv, &x)==0 ){
+    char *zJson;
+    zJson = sqlite3_mprintf(
+      "{iJD:%lld,Y:%d,M:%d,D:%d,h:%d,m:%d,tz:%d,"
+      "s:%.3f,validJD:%d,validYMS:%d,validHMS:%d,"
+      "nFloor:%d,rawS:%d,isError:%d,useSubsec:%d,"
+      "isUtc:%d,isLocal:%d}",
+      x.iJD, x.Y, x.M, x.D, x.h, x.m, x.tz,
+      x.s, x.validJD, x.validYMD, x.validHMS,
+      x.nFloor, x.rawS, x.isError, x.useSubsec,
+      x.isUtc, x.isLocal);
+    sqlite3_result_text(context, zJson, -1, sqlite3_free);
+  }
+}
+#endif /* !SQLITE_OMIT_DATETIME_FUNCS && SQLITE_DEBUG */
+
+
 /*
 ** This function registered all of the above C functions as SQL
 ** functions.  This should be the only routine in this file with
@@ -25714,6 +26237,9 @@ SQLITE_PRIVATE void sqlite3RegisterDateTimeFunctions(void){
     PURE_DATE(datetime,         -1, 0, 0, datetimeFunc  ),
     PURE_DATE(strftime,         -1, 0, 0, strftimeFunc  ),
     PURE_DATE(timediff,          2, 0, 0, timediffFunc  ),
+#ifdef SQLITE_DEBUG
+    PURE_DATE(datedebug,        -1, 0, 0, datedebugFunc ),
+#endif
     DFUNCTION(current_time,      0, 0, 0, ctimeFunc     ),
     DFUNCTION(current_timestamp, 0, 0, 0, ctimestampFunc),
     DFUNCTION(current_date,      0, 0, 0, cdateFunc     ),
@@ -28782,16 +29308,29 @@ SQLITE_API void sqlite3_mutex_leave(sqlite3_mutex *p){
 /*
 ** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are
 ** intended for use inside assert() statements.
+**
+** Because these routines raise false-positive alerts in TSAN, disable
+** them (make them always return 1) when compiling with TSAN.
 */
 SQLITE_API int sqlite3_mutex_held(sqlite3_mutex *p){
+# if defined(__has_feature)
+#   if __has_feature(thread_sanitizer)
+      p = 0;
+#   endif
+# endif
   assert( p==0 || sqlite3GlobalConfig.mutex.xMutexHeld );
   return p==0 || sqlite3GlobalConfig.mutex.xMutexHeld(p);
 }
 SQLITE_API int sqlite3_mutex_notheld(sqlite3_mutex *p){
+# if defined(__has_feature)
+#   if __has_feature(thread_sanitizer)
+      p = 0;
+#   endif
+# endif
   assert( p==0 || sqlite3GlobalConfig.mutex.xMutexNotheld );
   return p==0 || sqlite3GlobalConfig.mutex.xMutexNotheld(p);
 }
-#endif
+#endif /* NDEBUG */
 
 #endif /* !defined(SQLITE_MUTEX_OMIT) */
 
@@ -30129,6 +30668,24 @@ static void sqlite3MallocAlarm(int nByte){
   sqlite3_mutex_enter(mem0.mutex);
 }
 
+#ifdef SQLITE_DEBUG
+/*
+** This routine is called whenever an out-of-memory condition is seen,
+** It's only purpose to to serve as a breakpoint for gdb or similar
+** code debuggers when working on out-of-memory conditions, for example
+** caused by PRAGMA hard_heap_limit=N.
+*/
+static SQLITE_NOINLINE void test_oom_breakpoint(u64 n){
+  static u64 nOomFault = 0;
+  nOomFault += n;
+  /* The assert() is never reached in a human lifetime.  It  is here mostly
+  ** to prevent code optimizers from optimizing out this function. */
+  assert( (nOomFault>>32) < 0xffffffff );
+}
+#else
+# define test_oom_breakpoint(X)   /* No-op for production builds */
+#endif
+
 /*
 ** Do a memory allocation with statistics and alarms.  Assume the
 ** lock is already held.
@@ -30155,6 +30712,7 @@ static void mallocWithAlarm(int n, void **pp){
       if( mem0.hardLimit ){
         nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
         if( nUsed >= mem0.hardLimit - nFull ){
+          test_oom_breakpoint(1);
           *pp = 0;
           return;
         }
@@ -30443,6 +31001,7 @@ SQLITE_PRIVATE void *sqlite3Realloc(void *pOld, u64 nBytes){
       sqlite3MallocAlarm(nDiff);
       if( mem0.hardLimit>0 && nUsed >= mem0.hardLimit - nDiff ){
         sqlite3_mutex_leave(mem0.mutex);
+        test_oom_breakpoint(1);
         return 0;
       }
     }
@@ -31309,6 +31868,7 @@ SQLITE_API void sqlite3_str_vappendf(
         if( xtype==etFLOAT ){
           iRound = -precision;
         }else if( xtype==etGENERIC ){
+          if( precision==0 ) precision = 1;
           iRound = precision;
         }else{
           iRound = precision+1;
@@ -31344,13 +31904,14 @@ SQLITE_API void sqlite3_str_vappendf(
         }
 
         exp = s.iDP-1;
-        if( xtype==etGENERIC && precision>0 ) precision--;
 
         /*
         ** If the field type is etGENERIC, then convert to either etEXP
         ** or etFLOAT, as appropriate.
         */
         if( xtype==etGENERIC ){
+          assert( precision>0 );
+          precision--;
           flag_rtz = !flag_alternateform;
           if( exp<-4 || exp>precision ){
             xtype = etEXP;
@@ -31657,18 +32218,25 @@ SQLITE_API void sqlite3_str_vappendf(
         if( pItem->zAlias && !flag_altform2 ){
           sqlite3_str_appendall(pAccum, pItem->zAlias);
         }else if( pItem->zName ){
-          if( pItem->zDatabase ){
-            sqlite3_str_appendall(pAccum, pItem->zDatabase);
+          if( pItem->fg.fixedSchema==0
+           && pItem->fg.isSubquery==0
+           && pItem->u4.zDatabase!=0
+          ){
+            sqlite3_str_appendall(pAccum, pItem->u4.zDatabase);
             sqlite3_str_append(pAccum, ".", 1);
           }
           sqlite3_str_appendall(pAccum, pItem->zName);
         }else if( pItem->zAlias ){
           sqlite3_str_appendall(pAccum, pItem->zAlias);
-        }else{
-          Select *pSel = pItem->pSelect;
+        }else if( ALWAYS(pItem->fg.isSubquery) ){/* Because of tag-20240424-1 */
+          Select *pSel = pItem->u4.pSubq->pSelect;
           assert( pSel!=0 );
           if( pSel->selFlags & SF_NestedFrom ){
             sqlite3_str_appendf(pAccum, "(join-%u)", pSel->selId);
+          }else if( pSel->selFlags & SF_MultiValue ){
+            assert( !pItem->fg.isTabFunc && !pItem->fg.isIndexedBy );
+            sqlite3_str_appendf(pAccum, "%u-ROW VALUES CLAUSE",
+                                pItem->u1.nRow);
           }else{
             sqlite3_str_appendf(pAccum, "(subquery-%u)", pSel->selId);
           }
@@ -31740,6 +32308,7 @@ SQLITE_PRIVATE void sqlite3RecordErrorOffsetOfExpr(sqlite3 *db, const Expr *pExp
     pExpr = pExpr->pLeft;
   }
   if( pExpr==0 ) return;
+  if( ExprHasProperty(pExpr, EP_FromDDL) ) return;
   db->errByteOffset = pExpr->w.iOfst;
 }
 
@@ -32444,9 +33013,11 @@ SQLITE_PRIVATE void sqlite3TreeViewSrcList(TreeView *pView, const SrcList *pSrc)
     sqlite3StrAccumInit(&x, 0, zLine, sizeof(zLine), 0);
     x.printfFlags |= SQLITE_PRINTF_INTERNAL;
     sqlite3_str_appendf(&x, "{%d:*} %!S", pItem->iCursor, pItem);
-    if( pItem->pTab ){
-      sqlite3_str_appendf(&x, " tab=%Q nCol=%d ptr=%p used=%llx",
-           pItem->pTab->zName, pItem->pTab->nCol, pItem->pTab, pItem->colUsed);
+    if( pItem->pSTab ){
+      sqlite3_str_appendf(&x, " tab=%Q nCol=%d ptr=%p used=%llx%s",
+           pItem->pSTab->zName, pItem->pSTab->nCol, pItem->pSTab,
+           pItem->colUsed,
+           pItem->fg.rowidUsed ? "+rowid" : "");
     }
     if( (pItem->fg.jointype & (JT_LEFT|JT_RIGHT))==(JT_LEFT|JT_RIGHT) ){
       sqlite3_str_appendf(&x, " FULL-OUTER-JOIN");
@@ -32475,23 +33046,30 @@ SQLITE_PRIVATE void sqlite3TreeViewSrcList(TreeView *pView, const SrcList *pSrc)
     if( pItem->fg.viaCoroutine )   sqlite3_str_appendf(&x, " viaCoroutine");
     if( pItem->fg.notCte )         sqlite3_str_appendf(&x, " notCte");
     if( pItem->fg.isNestedFrom )   sqlite3_str_appendf(&x, " isNestedFrom");
+    if( pItem->fg.fixedSchema )    sqlite3_str_appendf(&x, " fixedSchema");
+    if( pItem->fg.hadSchema )      sqlite3_str_appendf(&x, " hadSchema");
+    if( pItem->fg.isSubquery )     sqlite3_str_appendf(&x, " isSubquery");
 
     sqlite3StrAccumFinish(&x);
     sqlite3TreeViewItem(pView, zLine, i<pSrc->nSrc-1);
     n = 0;
-    if( pItem->pSelect ) n++;
+    if( pItem->fg.isSubquery ) n++;
     if( pItem->fg.isTabFunc ) n++;
     if( pItem->fg.isUsing ) n++;
     if( pItem->fg.isUsing ){
       sqlite3TreeViewIdList(pView, pItem->u3.pUsing, (--n)>0, "USING");
     }
-    if( pItem->pSelect ){
-      if( pItem->pTab ){
-        Table *pTab = pItem->pTab;
+    if( pItem->fg.isSubquery ){
+      assert( n==1 );
+      if( pItem->pSTab ){
+        Table *pTab = pItem->pSTab;
         sqlite3TreeViewColumnList(pView, pTab->aCol, pTab->nCol, 1);
       }
-      assert( (int)pItem->fg.isNestedFrom == IsNestedFrom(pItem->pSelect) );
-      sqlite3TreeViewSelect(pView, pItem->pSelect, (--n)>0);
+      assert( (int)pItem->fg.isNestedFrom == IsNestedFrom(pItem) );
+      sqlite3TreeViewPush(&pView, 0);
+      sqlite3TreeViewLine(pView, "SUBQUERY");
+      sqlite3TreeViewPop(&pView);
+      sqlite3TreeViewSelect(pView, pItem->u4.pSubq->pSelect, 0);
     }
     if( pItem->fg.isTabFunc ){
       sqlite3TreeViewExprList(pView, pItem->u1.pFuncArg, 0, "func-args:");
@@ -32533,7 +33111,7 @@ SQLITE_PRIVATE void sqlite3TreeViewSelect(TreeView *pView, const Select *p, u8 m
       n = 1000;
     }else{
       n = 0;
-      if( p->pSrc && p->pSrc->nSrc ) n++;
+      if( p->pSrc && p->pSrc->nSrc && p->pSrc->nAlloc ) n++;
       if( p->pWhere ) n++;
       if( p->pGroupBy ) n++;
       if( p->pHaving ) n++;
@@ -32559,7 +33137,7 @@ SQLITE_PRIVATE void sqlite3TreeViewSelect(TreeView *pView, const Select *p, u8 m
       sqlite3TreeViewPop(&pView);
     }
 #endif
-    if( p->pSrc && p->pSrc->nSrc ){
+    if( p->pSrc && p->pSrc->nSrc && p->pSrc->nAlloc ){
       sqlite3TreeViewPush(&pView, (n--)>0);
       sqlite3TreeViewLine(pView, "FROM");
       sqlite3TreeViewSrcList(pView, p->pSrc);
@@ -32595,7 +33173,7 @@ SQLITE_PRIVATE void sqlite3TreeViewSelect(TreeView *pView, const Select *p, u8 m
       sqlite3TreeViewItem(pView, "LIMIT", (n--)>0);
       sqlite3TreeViewExpr(pView, p->pLimit->pLeft, p->pLimit->pRight!=0);
       if( p->pLimit->pRight ){
-        sqlite3TreeViewItem(pView, "OFFSET", (n--)>0);
+        sqlite3TreeViewItem(pView, "OFFSET", 0);
         sqlite3TreeViewExpr(pView, p->pLimit->pRight, 0);
         sqlite3TreeViewPop(&pView);
       }
@@ -33067,7 +33645,8 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m
         case OE_Ignore:     zType = "ignore";    break;
       }
       assert( !ExprHasProperty(pExpr, EP_IntValue) );
-      sqlite3TreeViewLine(pView, "RAISE %s(%Q)", zType, pExpr->u.zToken);
+      sqlite3TreeViewLine(pView, "RAISE %s", zType);
+      sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
       break;
     }
 #endif
@@ -33147,9 +33726,10 @@ SQLITE_PRIVATE void sqlite3TreeViewBareExprList(
     sqlite3TreeViewLine(pView, "%s", zLabel);
     for(i=0; i<pList->nExpr; i++){
       int j = pList->a[i].u.x.iOrderByCol;
+      u8 sortFlags = pList->a[i].fg.sortFlags;
       char *zName = pList->a[i].zEName;
       int moreToFollow = i<pList->nExpr - 1;
-      if( j || zName ){
+      if( j || zName || sortFlags ){
         sqlite3TreeViewPush(&pView, moreToFollow);
         moreToFollow = 0;
         sqlite3TreeViewLine(pView, 0);
@@ -33170,13 +33750,18 @@ SQLITE_PRIVATE void sqlite3TreeViewBareExprList(
           }
         }
         if( j ){
-          fprintf(stdout, "iOrderByCol=%d", j);
+          fprintf(stdout, "iOrderByCol=%d ", j);
+        }
+        if( sortFlags & KEYINFO_ORDER_DESC ){
+          fprintf(stdout, "DESC ");
+        }else if( sortFlags & KEYINFO_ORDER_BIGNULL ){
+          fprintf(stdout, "NULLS-LAST");
         }
         fprintf(stdout, "\n");
         fflush(stdout);
       }
       sqlite3TreeViewExpr(pView, pList->a[i].pExpr, moreToFollow);
-      if( j || zName ){
+      if( j || zName || sortFlags ){
         sqlite3TreeViewPop(&pView);
       }
     }
@@ -34139,7 +34724,7 @@ static const unsigned char sqlite3Utf8Trans1[] = {
   c = *(zIn++);                                            \
   if( c>=0xc0 ){                                           \
     c = sqlite3Utf8Trans1[c-0xc0];                         \
-    while( zIn!=zTerm && (*zIn & 0xc0)==0x80 ){            \
+    while( zIn<zTerm && (*zIn & 0xc0)==0x80 ){             \
       c = (c<<6) + (0x3f & *(zIn++));                      \
     }                                                      \
     if( c<0x80                                             \
@@ -34517,20 +35102,22 @@ SQLITE_PRIVATE char *sqlite3Utf16to8(sqlite3 *db, const void *z, int nByte, u8 e
 }
 
 /*
-** zIn is a UTF-16 encoded unicode string at least nChar characters long.
+** zIn is a UTF-16 encoded unicode string at least nByte bytes long.
 ** Return the number of bytes in the first nChar unicode characters
-** in pZ.  nChar must be non-negative.
+** in pZ.  nChar must be non-negative.  Surrogate pairs count as a single
+** character.
 */
-SQLITE_PRIVATE int sqlite3Utf16ByteLen(const void *zIn, int nChar){
+SQLITE_PRIVATE int sqlite3Utf16ByteLen(const void *zIn, int nByte, int nChar){
   int c;
   unsigned char const *z = zIn;
+  unsigned char const *zEnd = &z[nByte-1];
   int n = 0;
 
   if( SQLITE_UTF16NATIVE==SQLITE_UTF16LE ) z++;
-  while( n<nChar ){
+  while( n<nChar && ALWAYS(z<=zEnd) ){
     c = z[0];
     z += 2;
-    if( c>=0xd8 && c<0xdc && z[0]>=0xdc && z[0]<0xe0 ) z += 2;
+    if( c>=0xd8 && c<0xdc && z<=zEnd && z[0]>=0xdc && z[0]<0xe0 ) z += 2;
     n++;
   }
   return (int)(z-(unsigned char const *)zIn)
@@ -34640,6 +35227,19 @@ SQLITE_PRIVATE int sqlite3IsNaN(double x){
 }
 #endif /* SQLITE_OMIT_FLOATING_POINT */
 
+#ifndef SQLITE_OMIT_FLOATING_POINT
+/*
+** Return true if the floating point value is NaN or +Inf or -Inf.
+*/
+SQLITE_PRIVATE int sqlite3IsOverflow(double x){
+  int rc;   /* The value return */
+  u64 y;
+  memcpy(&y,&x,sizeof(y));
+  rc = IsOvfl(y);
+  return rc;
+}
+#endif /* SQLITE_OMIT_FLOATING_POINT */
+
 /*
 ** Compute a string length that is limited to what can be stored in
 ** lower 30 bits of a 32-bit signed integer.
@@ -34883,6 +35483,44 @@ SQLITE_PRIVATE void sqlite3DequoteExpr(Expr *p){
   sqlite3Dequote(p->u.zToken);
 }
 
+/*
+** Expression p is a QNUMBER (quoted number). Dequote the value in p->u.zToken
+** and set the type to INTEGER or FLOAT. "Quoted" integers or floats are those
+** that contain '_' characters that must be removed before further processing.
+*/
+SQLITE_PRIVATE void sqlite3DequoteNumber(Parse *pParse, Expr *p){
+  assert( p!=0 || pParse->db->mallocFailed );
+  if( p ){
+    const char *pIn = p->u.zToken;
+    char *pOut = p->u.zToken;
+    int bHex = (pIn[0]=='0' && (pIn[1]=='x' || pIn[1]=='X'));
+    int iValue;
+    assert( p->op==TK_QNUMBER );
+    p->op = TK_INTEGER;
+    do {
+      if( *pIn!=SQLITE_DIGIT_SEPARATOR ){
+        *pOut++ = *pIn;
+        if( *pIn=='e' || *pIn=='E' || *pIn=='.' ) p->op = TK_FLOAT;
+      }else{
+        if( (bHex==0 && (!sqlite3Isdigit(pIn[-1]) || !sqlite3Isdigit(pIn[1])))
+         || (bHex==1 && (!sqlite3Isxdigit(pIn[-1]) || !sqlite3Isxdigit(pIn[1])))
+        ){
+          sqlite3ErrorMsg(pParse, "unrecognized token: \"%s\"", p->u.zToken);
+        }
+      }
+    }while( *pIn++ );
+    if( bHex ) p->op = TK_INTEGER;
+
+    /* tag-20240227-a: If after dequoting, the number is an integer that
+    ** fits in 32 bits, then it must be converted into EP_IntValue.  Other
+    ** parts of the code expect this.  See also tag-20240227-b. */
+    if( p->op==TK_INTEGER && sqlite3GetInt32(p->u.zToken, &iValue) ){
+      p->u.iValue = iValue;
+      p->flags |= EP_IntValue;
+    }
+  }
+}
+
 /*
 ** If the input token p is quoted, try to adjust the token to remove
 ** the quotes.  This is not always possible:
@@ -35060,6 +35698,8 @@ SQLITE_PRIVATE int sqlite3AtoF(const char *z, double *pResult, int length, u8 en
   int eValid = 1;  /* True exponent is either not used or is well-formed */
   int nDigit = 0;  /* Number of digits processed */
   int eType = 1;   /* 1: pure integer,  2+: fractional  -1 or less: bad UTF16 */
+  double rr[2];
+  u64 s2;
 
   assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );
   *pResult = 0.0;   /* Default return value, in case of an error */
@@ -35171,65 +35811,41 @@ do_atof_calc:
     e++;
   }
 
-  if( e==0 ){
-    *pResult = s;
-  }else if( sqlite3Config.bUseLongDouble ){
-    LONGDOUBLE_TYPE r = (LONGDOUBLE_TYPE)s;
-    if( e>0 ){
-      while( e>=100  ){ e-=100; r *= 1.0e+100L; }
-      while( e>=10   ){ e-=10;  r *= 1.0e+10L;  }
-      while( e>=1    ){ e-=1;   r *= 1.0e+01L;  }
-    }else{
-      while( e<=-100 ){ e+=100; r *= 1.0e-100L; }
-      while( e<=-10  ){ e+=10;  r *= 1.0e-10L;  }
-      while( e<=-1   ){ e+=1;   r *= 1.0e-01L;  }
-    }
-    assert( r>=0.0 );
-    if( r>+1.7976931348623157081452742373e+308L ){
-#ifdef INFINITY
-      *pResult = +INFINITY;
-#else
-      *pResult = 1.0e308*10.0;
+  rr[0] = (double)s;
+  s2 = (u64)rr[0];
+#if defined(_MSC_VER) && _MSC_VER<1700
+  if( s2==0x8000000000000000LL ){ s2 = 2*(u64)(0.5*rr[0]); }
 #endif
-    }else{
-      *pResult = (double)r;
+  rr[1] = s>=s2 ? (double)(s - s2) : -(double)(s2 - s);
+  if( e>0 ){
+    while( e>=100  ){
+      e -= 100;
+      dekkerMul2(rr, 1.0e+100, -1.5902891109759918046e+83);
+    }
+    while( e>=10   ){
+      e -= 10;
+      dekkerMul2(rr, 1.0e+10, 0.0);
+    }
+    while( e>=1    ){
+      e -= 1;
+      dekkerMul2(rr, 1.0e+01, 0.0);
     }
   }else{
-    double rr[2];
-    u64 s2;
-    rr[0] = (double)s;
-    s2 = (u64)rr[0];
-    rr[1] = s>=s2 ? (double)(s - s2) : -(double)(s2 - s);
-    if( e>0 ){
-      while( e>=100  ){
-        e -= 100;
-        dekkerMul2(rr, 1.0e+100, -1.5902891109759918046e+83);
-      }
-      while( e>=10   ){
-        e -= 10;
-        dekkerMul2(rr, 1.0e+10, 0.0);
-      }
-      while( e>=1    ){
-        e -= 1;
-        dekkerMul2(rr, 1.0e+01, 0.0);
-      }
-    }else{
-      while( e<=-100 ){
-        e += 100;
-        dekkerMul2(rr, 1.0e-100, -1.99918998026028836196e-117);
-      }
-      while( e<=-10  ){
-        e += 10;
-        dekkerMul2(rr, 1.0e-10, -3.6432197315497741579e-27);
-      }
-      while( e<=-1   ){
-        e += 1;
-        dekkerMul2(rr, 1.0e-01, -5.5511151231257827021e-18);
-      }
+    while( e<=-100 ){
+      e += 100;
+      dekkerMul2(rr, 1.0e-100, -1.99918998026028836196e-117);
+    }
+    while( e<=-10  ){
+      e += 10;
+      dekkerMul2(rr, 1.0e-10, -3.6432197315497741579e-27);
+    }
+    while( e<=-1   ){
+      e += 1;
+      dekkerMul2(rr, 1.0e-01, -5.5511151231257827021e-18);
     }
-    *pResult = rr[0]+rr[1];
-    if( sqlite3IsNaN(*pResult) ) *pResult = 1e300*1e300;
   }
+  *pResult = rr[0]+rr[1];
+  if( sqlite3IsNaN(*pResult) ) *pResult = 1e300*1e300;
   if( sign<0 ) *pResult = -*pResult;
   assert( !sqlite3IsNaN(*pResult) );
 
@@ -35533,10 +36149,13 @@ SQLITE_PRIVATE int sqlite3Atoi(const char *z){
 ** Decode a floating-point value into an approximate decimal
 ** representation.
 **
-** Round the decimal representation to n significant digits if
-** n is positive.  Or round to -n signficant digits after the
-** decimal point if n is negative.  No rounding is performed if
-** n is zero.
+** If iRound<=0 then round to -iRound significant digits to the
+** the left of the decimal point, or to a maximum of mxRound total
+** significant digits.
+**
+** If iRound>0 round to min(iRound,mxRound) significant digits total.
+**
+** mxRound must be positive.
 **
 ** The significant digits of the decimal representation are
 ** stored in p->z[] which is a often (but not always) a pointer
@@ -35547,8 +36166,11 @@ SQLITE_PRIVATE void sqlite3FpDecode(FpDecode *p, double r, int iRound, int mxRou
   int i;
   u64 v;
   int e, exp = 0;
+  double rr[2];
+
   p->isSpecial = 0;
   p->z = p->zBuf;
+  assert( mxRound>0 );
 
   /* Convert negative numbers to positive.  Deal with Infinity, 0.0, and
   ** NaN. */
@@ -35575,62 +36197,45 @@ SQLITE_PRIVATE void sqlite3FpDecode(FpDecode *p, double r, int iRound, int mxRou
 
   /* Multiply r by powers of ten until it lands somewhere in between
   ** 1.0e+19 and 1.0e+17.
+  **
+  ** Use Dekker-style double-double computation to increase the
+  ** precision.
+  **
+  ** The error terms on constants like 1.0e+100 computed using the
+  ** decimal extension, for example as follows:
+  **
+  **   SELECT decimal_exp(decimal_sub('1.0e+100',decimal(1.0e+100)));
   */
-  if( sqlite3Config.bUseLongDouble ){
-    LONGDOUBLE_TYPE rr = r;
-    if( rr>=1.0e+19 ){
-      while( rr>=1.0e+119L ){ exp+=100; rr *= 1.0e-100L; }
-      while( rr>=1.0e+29L  ){ exp+=10;  rr *= 1.0e-10L;  }
-      while( rr>=1.0e+19L  ){ exp++;    rr *= 1.0e-1L;   }
-    }else{
-      while( rr<1.0e-97L   ){ exp-=100; rr *= 1.0e+100L; }
-      while( rr<1.0e+07L   ){ exp-=10;  rr *= 1.0e+10L;  }
-      while( rr<1.0e+17L   ){ exp--;    rr *= 1.0e+1L;   }
+  rr[0] = r;
+  rr[1] = 0.0;
+  if( rr[0]>9.223372036854774784e+18 ){
+    while( rr[0]>9.223372036854774784e+118 ){
+      exp += 100;
+      dekkerMul2(rr, 1.0e-100, -1.99918998026028836196e-117);
+    }
+    while( rr[0]>9.223372036854774784e+28 ){
+      exp += 10;
+      dekkerMul2(rr, 1.0e-10, -3.6432197315497741579e-27);
+    }
+    while( rr[0]>9.223372036854774784e+18 ){
+      exp += 1;
+      dekkerMul2(rr, 1.0e-01, -5.5511151231257827021e-18);
     }
-    v = (u64)rr;
   }else{
-    /* If high-precision floating point is not available using "long double",
-    ** then use Dekker-style double-double computation to increase the
-    ** precision.
-    **
-    ** The error terms on constants like 1.0e+100 computed using the
-    ** decimal extension, for example as follows:
-    **
-    **   SELECT decimal_exp(decimal_sub('1.0e+100',decimal(1.0e+100)));
-    */
-    double rr[2];
-    rr[0] = r;
-    rr[1] = 0.0;
-    if( rr[0]>9.223372036854774784e+18 ){
-      while( rr[0]>9.223372036854774784e+118 ){
-        exp += 100;
-        dekkerMul2(rr, 1.0e-100, -1.99918998026028836196e-117);
-      }
-      while( rr[0]>9.223372036854774784e+28 ){
-        exp += 10;
-        dekkerMul2(rr, 1.0e-10, -3.6432197315497741579e-27);
-      }
-      while( rr[0]>9.223372036854774784e+18 ){
-        exp += 1;
-        dekkerMul2(rr, 1.0e-01, -5.5511151231257827021e-18);
-      }
-    }else{
-      while( rr[0]<9.223372036854774784e-83  ){
-        exp -= 100;
-        dekkerMul2(rr, 1.0e+100, -1.5902891109759918046e+83);
-      }
-      while( rr[0]<9.223372036854774784e+07  ){
-        exp -= 10;
-        dekkerMul2(rr, 1.0e+10, 0.0);
-      }
-      while( rr[0]<9.22337203685477478e+17  ){
-        exp -= 1;
-        dekkerMul2(rr, 1.0e+01, 0.0);
-      }
+    while( rr[0]<9.223372036854774784e-83  ){
+      exp -= 100;
+      dekkerMul2(rr, 1.0e+100, -1.5902891109759918046e+83);
+    }
+    while( rr[0]<9.223372036854774784e+07  ){
+      exp -= 10;
+      dekkerMul2(rr, 1.0e+10, 0.0);
+    }
+    while( rr[0]<9.22337203685477478e+17  ){
+      exp -= 1;
+      dekkerMul2(rr, 1.0e+01, 0.0);
     }
-    v = rr[1]<0.0 ? (u64)rr[0]-(u64)(-rr[1]) : (u64)rr[0]+(u64)rr[1];
   }
-
+  v = rr[1]<0.0 ? (u64)rr[0]-(u64)(-rr[1]) : (u64)rr[0]+(u64)rr[1];
 
   /* Extract significant digits. */
   i = sizeof(p->zBuf)-1;
@@ -35641,7 +36246,7 @@ SQLITE_PRIVATE void sqlite3FpDecode(FpDecode *p, double r, int iRound, int mxRou
   assert( p->n>0 );
   assert( p->n<sizeof(p->zBuf) );
   p->iDP = p->n + exp;
-  if( iRound<0 ){
+  if( iRound<=0 ){
     iRound = p->iDP - iRound;
     if( iRound==0 && p->zBuf[i+1]>='5' ){
       iRound = 1;
@@ -36401,104 +37006,6 @@ SQLITE_PRIVATE int sqlite3VListNameToNum(VList *pIn, const char *zName, int nNam
   return 0;
 }
 
-/*
-** High-resolution hardware timer used for debugging and testing only.
-*/
-#if defined(VDBE_PROFILE)  \
- || defined(SQLITE_PERFORMANCE_TRACE) \
- || defined(SQLITE_ENABLE_STMT_SCANSTATUS)
-/************** Include hwtime.h in the middle of util.c *********************/
-/************** Begin file hwtime.h ******************************************/
-/*
-** 2008 May 27
-**
-** The author disclaims copyright to this source code.  In place of
-** a legal notice, here is a blessing:
-**
-**    May you do good and not evil.
-**    May you find forgiveness for yourself and forgive others.
-**    May you share freely, never taking more than you give.
-**
-******************************************************************************
-**
-** This file contains inline asm code for retrieving "high-performance"
-** counters for x86 and x86_64 class CPUs.
-*/
-#ifndef SQLITE_HWTIME_H
-#define SQLITE_HWTIME_H
-
-/*
-** The following routine only works on Pentium-class (or newer) processors.
-** It uses the RDTSC opcode to read the cycle count value out of the
-** processor and returns that value.  This can be used for high-res
-** profiling.
-*/
-#if !defined(__STRICT_ANSI__) && \
-    (defined(__GNUC__) || defined(_MSC_VER)) && \
-    (defined(i386) || defined(__i386__) || defined(_M_IX86))
-
-  #if defined(__GNUC__)
-
-  __inline__ sqlite_uint64 sqlite3Hwtime(void){
-     unsigned int lo, hi;
-     __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));
-     return (sqlite_uint64)hi << 32 | lo;
-  }
-
-  #elif defined(_MSC_VER)
-
-  __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){
-     __asm {
-        rdtsc
-        ret       ; return value at EDX:EAX
-     }
-  }
-
-  #endif
-
-#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__x86_64__))
-
-  __inline__ sqlite_uint64 sqlite3Hwtime(void){
-     unsigned int lo, hi;
-     __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));
-     return (sqlite_uint64)hi << 32 | lo;
-  }
-
-#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__ppc__))
-
-  __inline__ sqlite_uint64 sqlite3Hwtime(void){
-      unsigned long long retval;
-      unsigned long junk;
-      __asm__ __volatile__ ("\n\
-          1:      mftbu   %1\n\
-                  mftb    %L0\n\
-                  mftbu   %0\n\
-                  cmpw    %0,%1\n\
-                  bne     1b"
-                  : "=r" (retval), "=r" (junk));
-      return retval;
-  }
-
-#else
-
-  /*
-  ** asm() is needed for hardware timing support.  Without asm(),
-  ** disable the sqlite3Hwtime() routine.
-  **
-  ** sqlite3Hwtime() is only used for some obscure debugging
-  ** and analysis configurations, not in any deliverable, so this
-  ** should not be a great loss.
-  */
-SQLITE_PRIVATE   sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); }
-
-#endif
-
-#endif /* !defined(SQLITE_HWTIME_H) */
-
-/************** End of hwtime.h **********************************************/
-/************** Continuing where we left off in util.c ***********************/
-#endif
-
 /************** End of util.c ************************************************/
 /************** Begin file hash.c ********************************************/
 /*
@@ -36819,7 +37326,7 @@ SQLITE_PRIVATE const char *sqlite3OpcodeName(int i){
     /*  30 */ "SeekRowid"        OpHelp("intkey=r[P3]"),
     /*  31 */ "NotExists"        OpHelp("intkey=r[P3]"),
     /*  32 */ "Last"             OpHelp(""),
-    /*  33 */ "IfSmaller"        OpHelp(""),
+    /*  33 */ "IfSizeBetween"    OpHelp(""),
     /*  34 */ "SorterSort"       OpHelp(""),
     /*  35 */ "Sort"             OpHelp(""),
     /*  36 */ "Rewind"           OpHelp(""),
@@ -36836,16 +37343,16 @@ SQLITE_PRIVATE const char *sqlite3OpcodeName(int i){
     /*  47 */ "RowSetTest"       OpHelp("if r[P3] in rowset(P1) goto P2"),
     /*  48 */ "Program"          OpHelp(""),
     /*  49 */ "FkIfZero"         OpHelp("if fkctr[P1]==0 goto P2"),
-    /*  50 */ "IsNull"           OpHelp("if r[P1]==NULL goto P2"),
-    /*  51 */ "NotNull"          OpHelp("if r[P1]!=NULL goto P2"),
-    /*  52 */ "Ne"               OpHelp("IF r[P3]!=r[P1]"),
-    /*  53 */ "Eq"               OpHelp("IF r[P3]==r[P1]"),
-    /*  54 */ "Gt"               OpHelp("IF r[P3]>r[P1]"),
-    /*  55 */ "Le"               OpHelp("IF r[P3]<=r[P1]"),
-    /*  56 */ "Lt"               OpHelp("IF r[P3]<r[P1]"),
-    /*  57 */ "Ge"               OpHelp("IF r[P3]>=r[P1]"),
-    /*  58 */ "ElseEq"           OpHelp(""),
-    /*  59 */ "IfPos"            OpHelp("if r[P1]>0 then r[P1]-=P3, goto P2"),
+    /*  50 */ "IfPos"            OpHelp("if r[P1]>0 then r[P1]-=P3, goto P2"),
+    /*  51 */ "IsNull"           OpHelp("if r[P1]==NULL goto P2"),
+    /*  52 */ "NotNull"          OpHelp("if r[P1]!=NULL goto P2"),
+    /*  53 */ "Ne"               OpHelp("IF r[P3]!=r[P1]"),
+    /*  54 */ "Eq"               OpHelp("IF r[P3]==r[P1]"),
+    /*  55 */ "Gt"               OpHelp("IF r[P3]>r[P1]"),
+    /*  56 */ "Le"               OpHelp("IF r[P3]<=r[P1]"),
+    /*  57 */ "Lt"               OpHelp("IF r[P3]<r[P1]"),
+    /*  58 */ "Ge"               OpHelp("IF r[P3]>=r[P1]"),
+    /*  59 */ "ElseEq"           OpHelp(""),
     /*  60 */ "IfNotZero"        OpHelp("if r[P1]!=0 then r[P1]--, goto P2"),
     /*  61 */ "DecrJumpZero"     OpHelp("if (--r[P1])==0 goto P2"),
     /*  62 */ "IncrVacuum"       OpHelp(""),
@@ -36864,7 +37371,7 @@ SQLITE_PRIVATE const char *sqlite3OpcodeName(int i){
     /*  75 */ "Null"             OpHelp("r[P2..P3]=NULL"),
     /*  76 */ "SoftNull"         OpHelp("r[P1]=NULL"),
     /*  77 */ "Blob"             OpHelp("r[P2]=P4 (len=P1)"),
-    /*  78 */ "Variable"         OpHelp("r[P2]=parameter(P1,P4)"),
+    /*  78 */ "Variable"         OpHelp("r[P2]=parameter(P1)"),
     /*  79 */ "Move"             OpHelp("r[P2@P3]=r[P1@P3]"),
     /*  80 */ "Copy"             OpHelp("r[P2@P3+1]=r[P1@P3+1]"),
     /*  81 */ "SCopy"            OpHelp("r[P2]=r[P1]"),
@@ -36888,23 +37395,23 @@ SQLITE_PRIVATE const char *sqlite3OpcodeName(int i){
     /*  99 */ "ReadCookie"       OpHelp(""),
     /* 100 */ "SetCookie"        OpHelp(""),
     /* 101 */ "ReopenIdx"        OpHelp("root=P2 iDb=P3"),
-    /* 102 */ "BitAnd"           OpHelp("r[P3]=r[P1]&r[P2]"),
-    /* 103 */ "BitOr"            OpHelp("r[P3]=r[P1]|r[P2]"),
-    /* 104 */ "ShiftLeft"        OpHelp("r[P3]=r[P2]<<r[P1]"),
-    /* 105 */ "ShiftRight"       OpHelp("r[P3]=r[P2]>>r[P1]"),
-    /* 106 */ "Add"              OpHelp("r[P3]=r[P1]+r[P2]"),
-    /* 107 */ "Subtract"         OpHelp("r[P3]=r[P2]-r[P1]"),
-    /* 108 */ "Multiply"         OpHelp("r[P3]=r[P1]*r[P2]"),
-    /* 109 */ "Divide"           OpHelp("r[P3]=r[P2]/r[P1]"),
-    /* 110 */ "Remainder"        OpHelp("r[P3]=r[P2]%r[P1]"),
-    /* 111 */ "Concat"           OpHelp("r[P3]=r[P2]+r[P1]"),
-    /* 112 */ "OpenRead"         OpHelp("root=P2 iDb=P3"),
+    /* 102 */ "OpenRead"         OpHelp("root=P2 iDb=P3"),
+    /* 103 */ "BitAnd"           OpHelp("r[P3]=r[P1]&r[P2]"),
+    /* 104 */ "BitOr"            OpHelp("r[P3]=r[P1]|r[P2]"),
+    /* 105 */ "ShiftLeft"        OpHelp("r[P3]=r[P2]<<r[P1]"),
+    /* 106 */ "ShiftRight"       OpHelp("r[P3]=r[P2]>>r[P1]"),
+    /* 107 */ "Add"              OpHelp("r[P3]=r[P1]+r[P2]"),
+    /* 108 */ "Subtract"         OpHelp("r[P3]=r[P2]-r[P1]"),
+    /* 109 */ "Multiply"         OpHelp("r[P3]=r[P1]*r[P2]"),
+    /* 110 */ "Divide"           OpHelp("r[P3]=r[P2]/r[P1]"),
+    /* 111 */ "Remainder"        OpHelp("r[P3]=r[P2]%r[P1]"),
+    /* 112 */ "Concat"           OpHelp("r[P3]=r[P2]+r[P1]"),
     /* 113 */ "OpenWrite"        OpHelp("root=P2 iDb=P3"),
-    /* 114 */ "BitNot"           OpHelp("r[P2]= ~r[P1]"),
-    /* 115 */ "OpenDup"          OpHelp(""),
+    /* 114 */ "OpenDup"          OpHelp(""),
+    /* 115 */ "BitNot"           OpHelp("r[P2]= ~r[P1]"),
     /* 116 */ "OpenAutoindex"    OpHelp("nColumn=P2"),
-    /* 117 */ "String8"          OpHelp("r[P2]='P4'"),
-    /* 118 */ "OpenEphemeral"    OpHelp("nColumn=P2"),
+    /* 117 */ "OpenEphemeral"    OpHelp("nColumn=P2"),
+    /* 118 */ "String8"          OpHelp("r[P2]='P4'"),
     /* 119 */ "SorterOpen"       OpHelp(""),
     /* 120 */ "SequenceTest"     OpHelp("if( cursor[P1].ctr++ ) pc = P2"),
     /* 121 */ "OpenPseudo"       OpHelp("P3 columns in r[P2]"),
@@ -36939,8 +37446,8 @@ SQLITE_PRIVATE const char *sqlite3OpcodeName(int i){
     /* 150 */ "LoadAnalysis"     OpHelp(""),
     /* 151 */ "DropTable"        OpHelp(""),
     /* 152 */ "DropIndex"        OpHelp(""),
-    /* 153 */ "Real"             OpHelp("r[P2]=P4"),
-    /* 154 */ "DropTrigger"      OpHelp(""),
+    /* 153 */ "DropTrigger"      OpHelp(""),
+    /* 154 */ "Real"             OpHelp("r[P2]=P4"),
     /* 155 */ "IntegrityCk"      OpHelp(""),
     /* 156 */ "RowSetAdd"        OpHelp("rowset(P1)=r[P2]"),
     /* 157 */ "Param"            OpHelp(""),
@@ -38289,7 +38796,7 @@ static pid_t randomnessPid = 0;
 #define UNIXFILE_EXCL        0x01     /* Connections from one process only */
 #define UNIXFILE_RDONLY      0x02     /* Connection is read only */
 #define UNIXFILE_PERSIST_WAL 0x04     /* Persistent WAL mode */
-#ifndef SQLITE_DISABLE_DIRSYNC
+#if !defined(SQLITE_DISABLE_DIRSYNC) && !defined(_AIX)
 # define UNIXFILE_DIRSYNC    0x08     /* Directory sync needed */
 #else
 # define UNIXFILE_DIRSYNC    0x00
@@ -39262,8 +39769,12 @@ static int unixLogErrorAtLine(
   ** available, the error message will often be an empty string. Not a
   ** huge problem. Incorrectly concluding that the GNU version is available
   ** could lead to a segfault though.
+  **
+  ** Forum post 3f13857fa4062301 reports that the Android SDK may use
+  ** int-type return, depending on its version.
   */
-#if defined(STRERROR_R_CHAR_P) || defined(__USE_GNU)
+#if (defined(STRERROR_R_CHAR_P) || defined(__USE_GNU)) \
+  && !defined(ANDROID) && !defined(__ANDROID__)
   zErr =
 # endif
   strerror_r(iErrno, aErr, sizeof(aErr)-1);
@@ -40242,26 +40753,22 @@ static int nolockClose(sqlite3_file *id) {
 
 /*
 ** This routine checks if there is a RESERVED lock held on the specified
-** file by this or any other process. If such a lock is held, set *pResOut
-** to a non-zero value otherwise *pResOut is set to zero.  The return value
-** is set to SQLITE_OK unless an I/O error occurs during lock checking.
-**
-** In dotfile locking, either a lock exists or it does not.  So in this
-** variation of CheckReservedLock(), *pResOut is set to true if any lock
-** is held on the file and false if the file is unlocked.
+** file by this or any other process. If the caller holds a SHARED
+** or greater lock when it is called, then it is assumed that no other
+** client may hold RESERVED. Or, if the caller holds no lock, then it
+** is assumed another client holds RESERVED if the lock-file exists.
 */
 static int dotlockCheckReservedLock(sqlite3_file *id, int *pResOut) {
-  int rc = SQLITE_OK;
-  int reserved = 0;
   unixFile *pFile = (unixFile*)id;
-
   SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; );
 
-  assert( pFile );
-  reserved = osAccess((const char*)pFile->lockingContext, 0)==0;
-  OSTRACE(("TEST WR-LOCK %d %d %d (dotlock)\n", pFile->h, rc, reserved));
-  *pResOut = reserved;
-  return rc;
+  if( pFile->eFileLock>=SHARED_LOCK ){
+    *pResOut = 0;
+  }else{
+    *pResOut = osAccess((const char*)pFile->lockingContext, 0)==0;
+  }
+  OSTRACE(("TEST WR-LOCK %d %d %d (dotlock)\n", pFile->h, 0, *pResOut));
+  return SQLITE_OK;
 }
 
 /*
@@ -40431,54 +40938,33 @@ static int robust_flock(int fd, int op){
 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
 */
 static int flockCheckReservedLock(sqlite3_file *id, int *pResOut){
-  int rc = SQLITE_OK;
-  int reserved = 0;
+#ifdef SQLITE_DEBUG
   unixFile *pFile = (unixFile*)id;
+#else
+  UNUSED_PARAMETER(id);
+#endif
 
   SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; );
 
   assert( pFile );
+  assert( pFile->eFileLock<=SHARED_LOCK );
 
-  /* Check if a thread in this process holds such a lock */
-  if( pFile->eFileLock>SHARED_LOCK ){
-    reserved = 1;
-  }
+  /* The flock VFS only ever takes exclusive locks (see function flockLock).
+  ** Therefore, if this connection is holding any lock at all, no other
+  ** connection may be holding a RESERVED lock. So set *pResOut to 0
+  ** in this case.
+  **
+  ** Or, this connection may be holding no lock. In that case, set *pResOut to
+  ** 0 as well. The caller will then attempt to take an EXCLUSIVE lock on the
+  ** db in order to roll the hot journal back. If there is another connection
+  ** holding a lock, that attempt will fail and an SQLITE_BUSY returned to
+  ** the user. With other VFS, we try to avoid this, in order to allow a reader
+  ** to proceed while a writer is preparing its transaction. But that won't
+  ** work with the flock VFS - as it always takes EXCLUSIVE locks - so it is
+  ** not a problem in this case.  */
+  *pResOut = 0;
 
-  /* Otherwise see if some other process holds it. */
-  if( !reserved ){
-    /* attempt to get the lock */
-    int lrc = robust_flock(pFile->h, LOCK_EX | LOCK_NB);
-    if( !lrc ){
-      /* got the lock, unlock it */
-      lrc = robust_flock(pFile->h, LOCK_UN);
-      if ( lrc ) {
-        int tErrno = errno;
-        /* unlock failed with an error */
-        lrc = SQLITE_IOERR_UNLOCK;
-        storeLastErrno(pFile, tErrno);
-        rc = lrc;
-      }
-    } else {
-      int tErrno = errno;
-      reserved = 1;
-      /* someone else might have it reserved */
-      lrc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
-      if( IS_LOCK_ERROR(lrc) ){
-        storeLastErrno(pFile, tErrno);
-        rc = lrc;
-      }
-    }
-  }
-  OSTRACE(("TEST WR-LOCK %d %d %d (flock)\n", pFile->h, rc, reserved));
-
-#ifdef SQLITE_IGNORE_FLOCK_LOCK_ERRORS
-  if( (rc & 0xff) == SQLITE_IOERR ){
-    rc = SQLITE_OK;
-    reserved=1;
-  }
-#endif /* SQLITE_IGNORE_FLOCK_LOCK_ERRORS */
-  *pResOut = reserved;
-  return rc;
+  return SQLITE_OK;
 }
 
 /*
@@ -41950,7 +42436,7 @@ static void unixModeBit(unixFile *pFile, unsigned char mask, int *pArg){
 
 /* Forward declaration */
 static int unixGetTempname(int nBuf, char *zBuf);
-#ifndef SQLITE_OMIT_WAL
+#if !defined(SQLITE_WASI) && !defined(SQLITE_OMIT_WAL)
  static int unixFcntlExternalReader(unixFile*, int*);
 #endif
 
@@ -42077,7 +42563,7 @@ static int unixFileControl(sqlite3_file *id, int op, void *pArg){
 #endif /* SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__) */
 
     case SQLITE_FCNTL_EXTERNAL_READER: {
-#ifndef SQLITE_OMIT_WAL
+#if !defined(SQLITE_WASI) && !defined(SQLITE_OMIT_WAL)
       return unixFcntlExternalReader((unixFile*)id, (int*)pArg);
 #else
       *(int*)pArg = 0;
@@ -42116,6 +42602,7 @@ static void setDeviceCharacteristics(unixFile *pFd){
     if( pFd->ctrlFlags & UNIXFILE_PSOW ){
       pFd->deviceCharacteristics |= SQLITE_IOCAP_POWERSAFE_OVERWRITE;
     }
+    pFd->deviceCharacteristics |= SQLITE_IOCAP_SUBPAGE_READ;
 
     pFd->sectorSize = SQLITE_DEFAULT_SECTOR_SIZE;
   }
@@ -42166,7 +42653,7 @@ static void setDeviceCharacteristics(unixFile *pFile){
       pFile->sectorSize = fsInfo.f_bsize;
       pFile->deviceCharacteristics =
         /* full bitset of atomics from max sector size and smaller */
-        ((pFile->sectorSize / 512 * SQLITE_IOCAP_ATOMIC512) << 1) - 2 |
+        (((pFile->sectorSize / 512 * SQLITE_IOCAP_ATOMIC512) << 1) - 2) |
         SQLITE_IOCAP_SEQUENTIAL |     /* The ram filesystem has no write behind
                                       ** so it is ordered */
         0;
@@ -42174,7 +42661,7 @@ static void setDeviceCharacteristics(unixFile *pFile){
       pFile->sectorSize = fsInfo.f_bsize;
       pFile->deviceCharacteristics =
         /* full bitset of atomics from max sector size and smaller */
-        ((pFile->sectorSize / 512 * SQLITE_IOCAP_ATOMIC512) << 1) - 2 |
+        (((pFile->sectorSize / 512 * SQLITE_IOCAP_ATOMIC512) << 1) - 2) |
         SQLITE_IOCAP_SEQUENTIAL |     /* The ram filesystem has no write behind
                                       ** so it is ordered */
         0;
@@ -42250,7 +42737,7 @@ static int unixGetpagesize(void){
 
 #endif /* !defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0 */
 
-#ifndef SQLITE_OMIT_WAL
+#if !defined(SQLITE_WASI) && !defined(SQLITE_OMIT_WAL)
 
 /*
 ** Object used to represent an shared memory buffer.
@@ -43408,11 +43895,16 @@ static int unixFetch(sqlite3_file *fd, i64 iOff, int nAmt, void **pp){
 
 #if SQLITE_MAX_MMAP_SIZE>0
   if( pFd->mmapSizeMax>0 ){
+    /* Ensure that there is always at least a 256 byte buffer of addressable
+    ** memory following the returned page. If the database is corrupt,
+    ** SQLite may overread the page slightly (in practice only a few bytes,
+    ** but 256 is safe, round, number).  */
+    const int nEofBuffer = 256;
     if( pFd->pMapRegion==0 ){
       int rc = unixMapfile(pFd, -1);
       if( rc!=SQLITE_OK ) return rc;
     }
-    if( pFd->mmapSize >= iOff+nAmt ){
+    if( pFd->mmapSize >= (iOff+nAmt+nEofBuffer) ){
       *pp = &((u8 *)pFd->pMapRegion)[iOff];
       pFd->nFetchOut++;
     }
@@ -44356,12 +44848,19 @@ static int unixOpen(
         rc = SQLITE_READONLY_DIRECTORY;
       }else if( errno!=EISDIR && isReadWrite ){
         /* Failed to open the file for read/write access. Try read-only. */
+        UnixUnusedFd *pReadonly = 0;
         flags &= ~(SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE);
         openFlags &= ~(O_RDWR|O_CREAT);
         flags |= SQLITE_OPEN_READONLY;
         openFlags |= O_RDONLY;
         isReadonly = 1;
-        fd = robust_open(zName, openFlags, openMode);
+        pReadonly = findReusableFd(zName, flags);
+        if( pReadonly ){
+          fd = pReadonly->fd;
+          sqlite3_free(pReadonly);
+        }else{
+          fd = robust_open(zName, openFlags, openMode);
+        }
       }
     }
     if( fd<0 ){
@@ -49904,7 +50403,7 @@ static int winSectorSize(sqlite3_file *id){
 */
 static int winDeviceCharacteristics(sqlite3_file *id){
   winFile *p = (winFile*)id;
-  return SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN |
+  return SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN | SQLITE_IOCAP_SUBPAGE_READ |
          ((p->ctrlFlags & WINFILE_PSOW)?SQLITE_IOCAP_POWERSAFE_OVERWRITE:0);
 }
 
@@ -50765,6 +51264,11 @@ static int winFetch(sqlite3_file *fd, i64 iOff, int nAmt, void **pp){
 
 #if SQLITE_MAX_MMAP_SIZE>0
   if( pFd->mmapSizeMax>0 ){
+    /* Ensure that there is always at least a 256 byte buffer of addressable
+    ** memory following the returned page. If the database is corrupt,
+    ** SQLite may overread the page slightly (in practice only a few bytes,
+    ** but 256 is safe, round, number).  */
+    const int nEofBuffer = 256;
     if( pFd->pMapRegion==0 ){
       int rc = winMapfile(pFd, -1);
       if( rc!=SQLITE_OK ){
@@ -50773,7 +51277,7 @@ static int winFetch(sqlite3_file *fd, i64 iOff, int nAmt, void **pp){
         return rc;
       }
     }
-    if( pFd->mmapSize >= iOff+nAmt ){
+    if( pFd->mmapSize >= (iOff+nAmt+nEofBuffer) ){
       assert( pFd->pMapRegion!=0 );
       *pp = &((u8 *)pFd->pMapRegion)[iOff];
       pFd->nFetchOut++;
@@ -51287,7 +51791,7 @@ static int winOpen(
 
   int rc = SQLITE_OK;            /* Function Return Code */
 #if !defined(NDEBUG) || SQLITE_OS_WINCE
-  int eType = flags&0xFFFFFF00;  /* Type of file to open */
+  int eType = flags&0x0FFF00;  /* Type of file to open */
 #endif
 
   int isExclusive  = (flags & SQLITE_OPEN_EXCLUSIVE);
@@ -53252,6 +53756,14 @@ SQLITE_API unsigned char *sqlite3_serialize(
     pOut = 0;
   }else{
     sz = sqlite3_column_int64(pStmt, 0)*szPage;
+    if( sz==0 ){
+      sqlite3_reset(pStmt);
+      sqlite3_exec(db, "BEGIN IMMEDIATE; COMMIT;", 0, 0, 0);
+      rc = sqlite3_step(pStmt);
+      if( rc==SQLITE_ROW ){
+        sz = sqlite3_column_int64(pStmt, 0)*szPage;
+      }
+    }
     if( piSize ) *piSize = sz;
     if( mFlags & SQLITE_SERIALIZE_NOCOPY ){
       pOut = 0;
@@ -54310,6 +54822,7 @@ static SQLITE_NOINLINE PgHdr *pcacheFetchFinishWithInit(
   pPgHdr->pData = pPage->pBuf;
   pPgHdr->pExtra = (void *)&pPgHdr[1];
   memset(pPgHdr->pExtra, 0, 8);
+  assert( EIGHT_BYTE_ALIGNMENT( pPgHdr->pExtra ) );
   pPgHdr->pCache = pCache;
   pPgHdr->pgno = pgno;
   pPgHdr->flags = PGHDR_CLEAN;
@@ -55056,7 +55569,8 @@ static int pcache1InitBulk(PCache1 *pCache){
     do{
       PgHdr1 *pX = (PgHdr1*)&zBulk[pCache->szPage];
       pX->page.pBuf = zBulk;
-      pX->page.pExtra = &pX[1];
+      pX->page.pExtra = (u8*)pX + ROUND8(sizeof(*pX));
+      assert( EIGHT_BYTE_ALIGNMENT( pX->page.pExtra ) );
       pX->isBulkLocal = 1;
       pX->isAnchor = 0;
       pX->pNext = pCache->pFree;
@@ -55193,7 +55707,8 @@ static PgHdr1 *pcache1AllocPage(PCache1 *pCache, int benignMalloc){
     if( pPg==0 ) return 0;
     p = (PgHdr1 *)&((u8 *)pPg)[pCache->szPage];
     p->page.pBuf = pPg;
-    p->page.pExtra = &p[1];
+    p->page.pExtra = (u8*)p + ROUND8(sizeof(*p));
+    assert( EIGHT_BYTE_ALIGNMENT( p->page.pExtra ) );
     p->isBulkLocal = 0;
     p->isAnchor = 0;
     p->pLruPrev = 0;           /* Initializing this saves a valgrind error */
@@ -57496,18 +58011,26 @@ static const unsigned char aJournalMagic[] = {
 ** Return true if page pgno can be read directly from the database file
 ** by the b-tree layer. This is the case if:
 **
-**   * the database file is open,
-**   * there are no dirty pages in the cache, and
-**   * the desired page is not currently in the wal file.
+**   (1)  the database file is open
+**   (2)  the VFS for the database is able to do unaligned sub-page reads
+**   (3)  there are no dirty pages in the cache, and
+**   (4)  the desired page is not currently in the wal file.
 */
 SQLITE_PRIVATE int sqlite3PagerDirectReadOk(Pager *pPager, Pgno pgno){
-  if( pPager->fd->pMethods==0 ) return 0;
-  if( sqlite3PCacheIsDirty(pPager->pPCache) ) return 0;
+  assert( pPager!=0 );
+  assert( pPager->fd!=0 );
+  if( pPager->fd->pMethods==0 ) return 0;  /* Case (1) */
+  assert( pPager->fd->pMethods->xDeviceCharacteristics!=0 );
+  if( (pPager->fd->pMethods->xDeviceCharacteristics(pPager->fd)
+        & SQLITE_IOCAP_SUBPAGE_READ)==0 ){
+    return 0; /* Case (2) */
+  }
+  if( sqlite3PCacheIsDirty(pPager->pPCache) ) return 0; /* Failed (3) */
 #ifndef SQLITE_OMIT_WAL
   if( pPager->pWal ){
     u32 iRead = 0;
     (void)sqlite3WalFindFrame(pPager->pWal, pgno, &iRead);
-    return iRead==0;
+    return iRead==0; /* Condition (4) */
   }
 #endif
   return 1;
@@ -60752,6 +61275,7 @@ static int pagerAcquireMapPage(
       return SQLITE_NOMEM_BKPT;
     }
     p->pExtra = (void *)&p[1];
+    assert( EIGHT_BYTE_ALIGNMENT( p->pExtra ) );
     p->flags = PGHDR_MMAP;
     p->nRef = 1;
     p->pPager = pPager;
@@ -63775,7 +64299,7 @@ SQLITE_PRIVATE sqlite3_file *sqlite3PagerFile(Pager *pPager){
 ** This will be either the rollback journal or the WAL file.
 */
 SQLITE_PRIVATE sqlite3_file *sqlite3PagerJrnlFile(Pager *pPager){
-#if SQLITE_OMIT_WAL
+#ifdef SQLITE_OMIT_WAL
   return pPager->jfd;
 #else
   return pPager->pWal ? sqlite3WalFile(pPager->pWal) : pPager->jfd;
@@ -64535,7 +65059,7 @@ SQLITE_PRIVATE int sqlite3PagerWalSystemErrno(Pager *pPager){
 **    28: Checksum-2 (second part of checksum for first 24 bytes of header).
 **
 ** Immediately following the wal-header are zero or more frames. Each
-** frame consists of a 24-byte frame-header followed by a <page-size> bytes
+** frame consists of a 24-byte frame-header followed by <page-size> bytes
 ** of page data. The frame-header is six big-endian 32-bit unsigned
 ** integer values, as follows:
 **
@@ -65032,6 +65556,7 @@ struct Wal {
 #endif
 #ifdef SQLITE_ENABLE_SNAPSHOT
   WalIndexHdr *pSnapshot;    /* Start transaction here if not NULL */
+  int bGetSnapshot;          /* Transaction opened for sqlite3_get_snapshot() */
 #endif
 #ifdef SQLITE_ENABLE_SETLK_TIMEOUT
   sqlite3 *db;
@@ -66924,7 +67449,7 @@ static int walHandleException(Wal *pWal){
 
 /*
 ** Assert that the Wal.lockMask mask, which indicates the locks held
-** by the connenction, is consistent with the Wal.readLock, Wal.writeLock
+** by the connection, is consistent with the Wal.readLock, Wal.writeLock
 ** and Wal.ckptLock variables. To be used as:
 **
 **   assert( walAssertLockmask(pWal) );
@@ -67588,7 +68113,7 @@ static int walTryBeginRead(Wal *pWal, int *pChanged, int useWal, int *pCnt){
   SEH_INJECT_FAULT;
   if( !useWal && AtomicLoad(&pInfo->nBackfill)==pWal->hdr.mxFrame
 #ifdef SQLITE_ENABLE_SNAPSHOT
-   && (pWal->pSnapshot==0 || pWal->hdr.mxFrame==0)
+   && ((pWal->bGetSnapshot==0 && pWal->pSnapshot==0) || pWal->hdr.mxFrame==0)
 #endif
   ){
     /* The WAL has been completely backfilled (or it is empty).
@@ -68988,7 +69513,20 @@ SQLITE_PRIVATE void sqlite3WalSnapshotOpen(
   Wal *pWal,
   sqlite3_snapshot *pSnapshot
 ){
-  pWal->pSnapshot = (WalIndexHdr*)pSnapshot;
+  if( pSnapshot && ((WalIndexHdr*)pSnapshot)->iVersion==0 ){
+    /* iVersion==0 means that this is a call to sqlite3_snapshot_get().  In
+    ** this case set the bGetSnapshot flag so that if the call to
+    ** sqlite3_snapshot_get() is about to read transaction on this wal
+    ** file, it does not take read-lock 0 if the wal file has been completely
+    ** checkpointed. Taking read-lock 0 would work, but then it would be
+    ** possible for a subsequent writer to destroy the snapshot even while
+    ** this connection is holding its read-transaction open. This is contrary
+    ** to user expectations, so we avoid it by not taking read-lock 0. */
+    pWal->bGetSnapshot = 1;
+  }else{
+    pWal->pSnapshot = (WalIndexHdr*)pSnapshot;
+    pWal->bGetSnapshot = 0;
+  }
 }
 
 /*
@@ -69799,6 +70337,7 @@ struct IntegrityCk {
   StrAccum errMsg;  /* Accumulate the error message text here */
   u32 *heap;        /* Min-heap used for analyzing cell coverage */
   sqlite3 *db;      /* Database connection running the check */
+  i64 nRow;         /* Number of rows visited in current tree */
 };
 
 /*
@@ -70273,8 +70812,47 @@ int corruptPageError(int lineno, MemPage *p){
 # define SQLITE_CORRUPT_PAGE(pMemPage) SQLITE_CORRUPT_PGNO(pMemPage->pgno)
 #endif
 
+/* Default value for SHARED_LOCK_TRACE macro if shared-cache is disabled
+** or if the lock tracking is disabled.  This is always the value for
+** release builds.
+*/
+#define SHARED_LOCK_TRACE(X,MSG,TAB,TYPE)  /*no-op*/
+
 #ifndef SQLITE_OMIT_SHARED_CACHE
 
+#if 0
+/*  ^----  Change to 1 and recompile to enable shared-lock tracing
+**         for debugging purposes.
+**
+** Print all shared-cache locks on a BtShared.  Debugging use only.
+*/
+static void sharedLockTrace(
+  BtShared *pBt,
+  const char *zMsg,
+  int iRoot,
+  int eLockType
+){
+  BtLock *pLock;
+  if( iRoot>0 ){
+    printf("%s-%p %u%s:", zMsg, pBt, iRoot, eLockType==READ_LOCK?"R":"W");
+  }else{
+    printf("%s-%p:", zMsg, pBt);
+  }
+  for(pLock=pBt->pLock; pLock; pLock=pLock->pNext){
+    printf(" %p/%u%s", pLock->pBtree, pLock->iTable,
+           pLock->eLock==READ_LOCK ? "R" : "W");
+    while( pLock->pNext && pLock->pBtree==pLock->pNext->pBtree ){
+      pLock = pLock->pNext;
+      printf(",%u%s", pLock->iTable, pLock->eLock==READ_LOCK ? "R" : "W");
+    }
+  }
+  printf("\n");
+  fflush(stdout);
+}
+#undef SHARED_LOCK_TRACE
+#define SHARED_LOCK_TRACE(X,MSG,TAB,TYPE)  sharedLockTrace(X,MSG,TAB,TYPE)
+#endif /* Shared-lock tracing */
+
 #ifdef SQLITE_DEBUG
 /*
 **** This function is only used as part of an assert() statement. ***
@@ -70351,6 +70929,8 @@ static int hasSharedCacheTableLock(
     iTab = iRoot;
   }
 
+  SHARED_LOCK_TRACE(pBtree->pBt,"hasLock",iRoot,eLockType);
+
   /* Search for the required lock. Either a write-lock on root-page iTab, a
   ** write-lock on the schema table, or (if the client is reading) a
   ** read-lock on iTab will suffice. Return 1 if any of these are found.  */
@@ -70484,6 +71064,8 @@ static int setSharedCacheTableLock(Btree *p, Pgno iTable, u8 eLock){
   BtLock *pLock = 0;
   BtLock *pIter;
 
+  SHARED_LOCK_TRACE(pBt,"setLock", iTable, eLock);
+
   assert( sqlite3BtreeHoldsMutex(p) );
   assert( eLock==READ_LOCK || eLock==WRITE_LOCK );
   assert( p->db!=0 );
@@ -70551,6 +71133,8 @@ static void clearAllSharedCacheTableLocks(Btree *p){
   assert( p->sharable || 0==*ppIter );
   assert( p->inTrans>0 );
 
+  SHARED_LOCK_TRACE(pBt, "clearAllLocks", 0, 0);
+
   while( *ppIter ){
     BtLock *pLock = *ppIter;
     assert( (pBt->btsFlags & BTS_EXCLUSIVE)==0 || pBt->pWriter==pLock->pBtree );
@@ -70589,6 +71173,9 @@ static void clearAllSharedCacheTableLocks(Btree *p){
 */
 static void downgradeAllSharedCacheTableLocks(Btree *p){
   BtShared *pBt = p->pBt;
+
+  SHARED_LOCK_TRACE(pBt, "downgradeLocks", 0, 0);
+
   if( pBt->pWriter==p ){
     BtLock *pLock;
     pBt->pWriter = 0;
@@ -74820,6 +75407,25 @@ SQLITE_PRIVATE int sqlite3BtreeCursorSize(void){
   return ROUND8(sizeof(BtCursor));
 }
 
+#ifdef SQLITE_DEBUG
+/*
+** Return true if and only if the Btree object will be automatically
+** closed with the BtCursor closes.  This is used within assert() statements
+** only.
+*/
+SQLITE_PRIVATE int sqlite3BtreeClosesWithCursor(
+  Btree *pBtree,       /* the btree object */
+  BtCursor *pCur       /* Corresponding cursor */
+){
+  BtShared *pBt = pBtree->pBt;
+  if( (pBt->openFlags & BTREE_SINGLE)==0 ) return 0;
+  if( pBt->pCursor!=pCur ) return 0;
+  if( pCur->pNext!=0 ) return 0;
+  if( pCur->pBtree!=pBtree ) return 0;
+  return 1;
+}
+#endif
+
 /*
 ** Initialize memory that will be converted into a BtCursor object.
 **
@@ -75202,9 +75808,12 @@ static int accessPayload(
       if( pCur->aOverflow==0
        || nOvfl*(int)sizeof(Pgno) > sqlite3MallocSize(pCur->aOverflow)
       ){
-        Pgno *aNew = (Pgno*)sqlite3Realloc(
-            pCur->aOverflow, nOvfl*2*sizeof(Pgno)
-        );
+        Pgno *aNew;
+        if( sqlite3FaultSim(413) ){
+          aNew = 0;
+        }else{
+          aNew = (Pgno*)sqlite3Realloc(pCur->aOverflow, nOvfl*2*sizeof(Pgno));
+        }
         if( aNew==0 ){
           return SQLITE_NOMEM_BKPT;
         }else{
@@ -75214,6 +75823,12 @@ static int accessPayload(
       memset(pCur->aOverflow, 0, nOvfl*sizeof(Pgno));
       pCur->curFlags |= BTCF_ValidOvfl;
     }else{
+      /* Sanity check the validity of the overflow page cache */
+      assert( pCur->aOverflow[0]==nextPage
+           || pCur->aOverflow[0]==0
+           || CORRUPT_DB );
+      assert( pCur->aOverflow[0]!=0 || pCur->aOverflow[offset/ovflSize]==0 );
+
       /* If the overflow page-list cache has been allocated and the
       ** entry for the first required overflow page is valid, skip
       ** directly to it.
@@ -75695,6 +76310,23 @@ SQLITE_PRIVATE int sqlite3BtreeFirst(BtCursor *pCur, int *pRes){
   return rc;
 }
 
+#ifdef SQLITE_DEBUG
+/* The cursors is CURSOR_VALID and has BTCF_AtLast set.  Verify that
+** this flags are true for a consistent database.
+**
+** This routine is is called from within assert() statements only.
+** It is an internal verification routine and does not appear in production
+** builds.
+*/
+static int cursorIsAtLastEntry(BtCursor *pCur){
+  int ii;
+  for(ii=0; ii<pCur->iPage; ii++){
+    if( pCur->aiIdx[ii]!=pCur->apPage[ii]->nCell ) return 0;
+  }
+  return pCur->ix==pCur->pPage->nCell-1 && pCur->pPage->leaf!=0;
+}
+#endif
+
 /* Move the cursor to the last entry in the table.  Return SQLITE_OK
 ** on success.  Set *pRes to 0 if the cursor actually points to something
 ** or set *pRes to 1 if the table is empty.
@@ -75723,18 +76355,7 @@ SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor *pCur, int *pRes){
 
   /* If the cursor already points to the last entry, this is a no-op. */
   if( CURSOR_VALID==pCur->eState && (pCur->curFlags & BTCF_AtLast)!=0 ){
-#ifdef SQLITE_DEBUG
-    /* This block serves to assert() that the cursor really does point
-    ** to the last entry in the b-tree. */
-    int ii;
-    for(ii=0; ii<pCur->iPage; ii++){
-      assert( pCur->aiIdx[ii]==pCur->apPage[ii]->nCell );
-    }
-    assert( pCur->ix==pCur->pPage->nCell-1 || CORRUPT_DB );
-    testcase( pCur->ix!=pCur->pPage->nCell-1 );
-    /* ^-- dbsqlfuzz b92b72e4de80b5140c30ab71372ca719b8feb618 */
-    assert( pCur->pPage->leaf );
-#endif
+    assert( cursorIsAtLastEntry(pCur) || CORRUPT_DB );
     *pRes = 0;
     return SQLITE_OK;
   }
@@ -75787,6 +76408,7 @@ SQLITE_PRIVATE int sqlite3BtreeTableMoveto(
     }
     if( pCur->info.nKey<intKey ){
       if( (pCur->curFlags & BTCF_AtLast)!=0 ){
+        assert( cursorIsAtLastEntry(pCur) || CORRUPT_DB );
         *pRes = -1;
         return SQLITE_OK;
       }
@@ -76047,7 +76669,7 @@ SQLITE_PRIVATE int sqlite3BtreeIndexMoveto(
      && indexCellCompare(pCur, 0, pIdxKey, xRecordCompare)<=0
      && pIdxKey->errCode==SQLITE_OK
     ){
-      pCur->curFlags &= ~BTCF_ValidOvfl;
+      pCur->curFlags &= ~(BTCF_ValidOvfl|BTCF_AtLast);
       if( !pCur->pPage->isInit ){
         return SQLITE_CORRUPT_BKPT;
       }
@@ -76253,10 +76875,10 @@ SQLITE_PRIVATE i64 sqlite3BtreeRowCountEst(BtCursor *pCur){
   assert( cursorOwnsBtShared(pCur) );
   assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
 
-  /* Currently this interface is only called by the OP_IfSmaller
-  ** opcode, and it that case the cursor will always be valid and
-  ** will always point to a leaf node. */
-  if( NEVER(pCur->eState!=CURSOR_VALID) ) return -1;
+  /* Currently this interface is only called by the OP_IfSizeBetween
+  ** opcode and the OP_Count opcode with P3=1.  In either case,
+  ** the cursor will always be valid unless the btree is empty. */
+  if( pCur->eState!=CURSOR_VALID ) return 0;
   if( NEVER(pCur->pPage->leaf==0) ) return -1;
 
   n = pCur->pPage->nCell;
@@ -76402,7 +77024,10 @@ static SQLITE_NOINLINE int btreePrevious(BtCursor *pCur){
   }
 
   pPage = pCur->pPage;
-  assert( pPage->isInit );
+  if( sqlite3FaultSim(412) ) pPage->isInit = 0;
+  if( !pPage->isInit ){
+    return SQLITE_CORRUPT_BKPT;
+  }
   if( !pPage->leaf ){
     int idx = pCur->ix;
     rc = moveToChild(pCur, get4byte(findCell(pPage, idx)));
@@ -77075,7 +77700,10 @@ static int fillInCell(
     n = nHeader + nPayload;
     testcase( n==3 );
     testcase( n==4 );
-    if( n<4 ) n = 4;
+    if( n<4 ){
+      n = 4;
+      pPayload[nPayload] = 0;
+    }
     *pnSize = n;
     assert( nSrc<=nPayload );
     testcase( nSrc<nPayload );
@@ -77619,7 +78247,8 @@ static int rebuildPage(
   if( j>(u32)usableSize ){ j = 0; }
   memcpy(&pTmp[j], &aData[j], usableSize - j);
 
-  for(k=0; ALWAYS(k<NB*2) && pCArray->ixNx[k]<=i; k++){}
+  assert( pCArray->ixNx[NB*2-1]>i );
+  for(k=0; pCArray->ixNx[k]<=i; k++){}
   pSrcEnd = pCArray->apEnd[k];
 
   pData = pEnd;
@@ -77702,7 +78331,8 @@ static int pageInsertArray(
   u8 *pEnd;                       /* Maximum extent of cell data */
   assert( CORRUPT_DB || pPg->hdrOffset==0 );    /* Never called on page 1 */
   if( iEnd<=iFirst ) return 0;
-  for(k=0; ALWAYS(k<NB*2) && pCArray->ixNx[k]<=i ; k++){}
+  assert( pCArray->ixNx[NB*2-1]>i );
+  for(k=0; pCArray->ixNx[k]<=i ; k++){}
   pEnd = pCArray->apEnd[k];
   while( 1 /*Exit by break*/ ){
     int sz, rc;
@@ -77987,6 +78617,7 @@ static int balance_quick(MemPage *pParent, MemPage *pPage, u8 *pSpace){
     b.szCell = &szCell;
     b.apEnd[0] = pPage->aDataEnd;
     b.ixNx[0] = 2;
+    b.ixNx[NB*2-1] = 0x7fffffff;
     rc = rebuildPage(&b, 0, 1, pNew);
     if( NEVER(rc) ){
       releasePage(pNew);
@@ -78222,7 +78853,9 @@ static int balance_nonroot(
   CellArray b;                 /* Parsed information on cells being balanced */
 
   memset(abDone, 0, sizeof(abDone));
-  memset(&b, 0, sizeof(b));
+  assert( sizeof(b) - sizeof(b.ixNx) == offsetof(CellArray,ixNx) );
+  memset(&b, 0, sizeof(b)-sizeof(b.ixNx[0]));
+  b.ixNx[NB*2-1] = 0x7fffffff;
   pBt = pParent->pBt;
   assert( sqlite3_mutex_held(pBt->mutex) );
   assert( sqlite3PagerIswriteable(pParent->pDbPage) );
@@ -78381,7 +79014,7 @@ static int balance_nonroot(
     ** table-interior, index-leaf, or index-interior).
     */
     if( pOld->aData[0]!=apOld[0]->aData[0] ){
-      rc = SQLITE_CORRUPT_BKPT;
+      rc = SQLITE_CORRUPT_PAGE(pOld);
       goto balance_cleanup;
     }
 
@@ -78405,7 +79038,7 @@ static int balance_nonroot(
     memset(&b.szCell[b.nCell], 0, sizeof(b.szCell[0])*(limit+pOld->nOverflow));
     if( pOld->nOverflow>0 ){
       if( NEVER(limit<pOld->aiOvfl[0]) ){
-        rc = SQLITE_CORRUPT_BKPT;
+        rc = SQLITE_CORRUPT_PAGE(pOld);
         goto balance_cleanup;
       }
       limit = pOld->aiOvfl[0];
@@ -78813,7 +79446,8 @@ static int balance_nonroot(
     iOvflSpace += sz;
     assert( sz<=pBt->maxLocal+23 );
     assert( iOvflSpace <= (int)pBt->pageSize );
-    for(k=0; ALWAYS(k<NB*2) && b.ixNx[k]<=j; k++){}
+    assert( b.ixNx[NB*2-1]>j );
+    for(k=0; b.ixNx[k]<=j; k++){}
     pSrcEnd = b.apEnd[k];
     if( SQLITE_OVERFLOW(pSrcEnd, pCell, pCell+sz) ){
       rc = SQLITE_CORRUPT_BKPT;
@@ -79048,7 +79682,7 @@ static int anotherValidCursor(BtCursor *pCur){
      && pOther->eState==CURSOR_VALID
      && pOther->pPage==pCur->pPage
     ){
-      return SQLITE_CORRUPT_BKPT;
+      return SQLITE_CORRUPT_PAGE(pCur->pPage);
     }
   }
   return SQLITE_OK;
@@ -79108,7 +79742,7 @@ static int balance(BtCursor *pCur){
       /* The page being written is not a root page, and there is currently
       ** more than one reference to it. This only happens if the page is one
       ** of its own ancestor pages. Corruption. */
-      rc = SQLITE_CORRUPT_BKPT;
+      rc = SQLITE_CORRUPT_PAGE(pPage);
     }else{
       MemPage * const pParent = pCur->apPage[iPage-1];
       int const iIdx = pCur->aiIdx[iPage-1];
@@ -79272,7 +79906,7 @@ static SQLITE_NOINLINE int btreeOverwriteOverflowCell(
     rc = btreeGetPage(pBt, ovflPgno, &pPage, 0);
     if( rc ) return rc;
     if( sqlite3PagerPageRefcount(pPage->pDbPage)!=1 || pPage->isInit ){
-      rc = SQLITE_CORRUPT_BKPT;
+      rc = SQLITE_CORRUPT_PAGE(pPage);
     }else{
       if( iOffset+ovflPageSize<(u32)nTotal ){
         ovflPgno = get4byte(pPage->aData);
@@ -79300,7 +79934,7 @@ static int btreeOverwriteCell(BtCursor *pCur, const BtreePayload *pX){
   if( pCur->info.pPayload + pCur->info.nLocal > pPage->aDataEnd
    || pCur->info.pPayload < pPage->aData + pPage->cellOffset
   ){
-    return SQLITE_CORRUPT_BKPT;
+    return SQLITE_CORRUPT_PAGE(pPage);
   }
   if( pCur->info.nLocal==nTotal ){
     /* The entire cell is local */
@@ -79381,7 +80015,7 @@ SQLITE_PRIVATE int sqlite3BtreeInsert(
       ** Which can only happen if the SQLITE_NoSchemaError flag was set when
       ** the schema was loaded. This cannot be asserted though, as a user might
       ** set the flag, load the schema, and then unset the flag.  */
-      return SQLITE_CORRUPT_BKPT;
+      return SQLITE_CORRUPT_PGNO(pCur->pgnoRoot);
     }
   }
 
@@ -79504,7 +80138,7 @@ SQLITE_PRIVATE int sqlite3BtreeInsert(
   if( pPage->nFree<0 ){
     if( NEVER(pCur->eState>CURSOR_INVALID) ){
      /* ^^^^^--- due to the moveToRoot() call above */
-      rc = SQLITE_CORRUPT_BKPT;
+      rc = SQLITE_CORRUPT_PAGE(pPage);
     }else{
       rc = btreeComputeFreeSpace(pPage);
     }
@@ -79521,7 +80155,10 @@ SQLITE_PRIVATE int sqlite3BtreeInsert(
   if( flags & BTREE_PREFORMAT ){
     rc = SQLITE_OK;
     szNew = p->pBt->nPreformatSize;
-    if( szNew<4 ) szNew = 4;
+    if( szNew<4 ){
+      szNew = 4;
+      newCell[3] = 0;
+    }
     if( ISAUTOVACUUM(p->pBt) && szNew>pPage->maxLocal ){
       CellInfo info;
       pPage->xParseCell(pPage, newCell, &info);
@@ -79543,7 +80180,7 @@ SQLITE_PRIVATE int sqlite3BtreeInsert(
     CellInfo info;
     assert( idx>=0 );
     if( idx>=pPage->nCell ){
-      return SQLITE_CORRUPT_BKPT;
+      return SQLITE_CORRUPT_PAGE(pPage);
     }
     rc = sqlite3PagerWrite(pPage->pDbPage);
     if( rc ){
@@ -79570,10 +80207,10 @@ SQLITE_PRIVATE int sqlite3BtreeInsert(
       ** necessary to add the PTRMAP_OVERFLOW1 pointer-map entry.  */
       assert( rc==SQLITE_OK ); /* clearCell never fails when nLocal==nPayload */
       if( oldCell < pPage->aData+pPage->hdrOffset+10 ){
-        return SQLITE_CORRUPT_BKPT;
+        return SQLITE_CORRUPT_PAGE(pPage);
       }
       if( oldCell+szNew > pPage->aDataEnd ){
-        return SQLITE_CORRUPT_BKPT;
+        return SQLITE_CORRUPT_PAGE(pPage);
       }
       memcpy(oldCell, newCell, szNew);
       return SQLITE_OK;
@@ -79583,7 +80220,7 @@ SQLITE_PRIVATE int sqlite3BtreeInsert(
   }else if( loc<0 && pPage->nCell>0 ){
     assert( pPage->leaf );
     idx = ++pCur->ix;
-    pCur->curFlags &= ~BTCF_ValidNKey;
+    pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
   }else{
     assert( pPage->leaf );
   }
@@ -79613,7 +80250,7 @@ SQLITE_PRIVATE int sqlite3BtreeInsert(
   */
   if( pPage->nOverflow ){
     assert( rc==SQLITE_OK );
-    pCur->curFlags &= ~(BTCF_ValidNKey);
+    pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
     rc = balance(pCur);
 
     /* Must make sure nOverflow is reset to zero even if the balance()
@@ -79675,7 +80312,7 @@ SQLITE_PRIVATE int sqlite3BtreeTransferRow(BtCursor *pDest, BtCursor *pSrc, i64
   nIn = pSrc->info.nLocal;
   aIn = pSrc->info.pPayload;
   if( aIn+nIn>pSrc->pPage->aDataEnd ){
-    return SQLITE_CORRUPT_BKPT;
+    return SQLITE_CORRUPT_PAGE(pSrc->pPage);
   }
   nRem = pSrc->info.nPayload;
   if( nIn==nRem && nIn<pDest->pPage->maxLocal ){
@@ -79700,7 +80337,7 @@ SQLITE_PRIVATE int sqlite3BtreeTransferRow(BtCursor *pDest, BtCursor *pSrc, i64
 
     if( nRem>nIn ){
       if( aIn+nIn+4>pSrc->pPage->aDataEnd ){
-        return SQLITE_CORRUPT_BKPT;
+        return SQLITE_CORRUPT_PAGE(pSrc->pPage);
       }
       ovflIn = get4byte(&pSrc->info.pPayload[nIn]);
     }
@@ -79796,7 +80433,7 @@ SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur, u8 flags){
       assert( rc!=SQLITE_OK || CORRUPT_DB || pCur->eState==CURSOR_VALID );
       if( rc || pCur->eState!=CURSOR_VALID ) return rc;
     }else{
-      return SQLITE_CORRUPT_BKPT;
+      return SQLITE_CORRUPT_PGNO(pCur->pgnoRoot);
     }
   }
   assert( pCur->eState==CURSOR_VALID );
@@ -79805,14 +80442,14 @@ SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur, u8 flags){
   iCellIdx = pCur->ix;
   pPage = pCur->pPage;
   if( pPage->nCell<=iCellIdx ){
-    return SQLITE_CORRUPT_BKPT;
+    return SQLITE_CORRUPT_PAGE(pPage);
   }
   pCell = findCell(pPage, iCellIdx);
   if( pPage->nFree<0 && btreeComputeFreeSpace(pPage) ){
-    return SQLITE_CORRUPT_BKPT;
+    return SQLITE_CORRUPT_PAGE(pPage);
   }
   if( pCell<&pPage->aCellIdx[pPage->nCell] ){
-    return SQLITE_CORRUPT_BKPT;
+    return SQLITE_CORRUPT_PAGE(pPage);
   }
 
   /* If the BTREE_SAVEPOSITION bit is on, then the cursor position must
@@ -79903,7 +80540,7 @@ SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur, u8 flags){
       n = pCur->pPage->pgno;
     }
     pCell = findCell(pLeaf, pLeaf->nCell-1);
-    if( pCell<&pLeaf->aData[4] ) return SQLITE_CORRUPT_BKPT;
+    if( pCell<&pLeaf->aData[4] ) return SQLITE_CORRUPT_PAGE(pLeaf);
     nCell = pLeaf->xCellSize(pLeaf, pCell);
     assert( MX_CELL_SIZE(pBt) >= nCell );
     pTmp = pBt->pTmpSpace;
@@ -80019,7 +80656,7 @@ static int btreeCreateTable(Btree *p, Pgno *piTable, int createTabFlags){
     */
     sqlite3BtreeGetMeta(p, BTREE_LARGEST_ROOT_PAGE, &pgnoRoot);
     if( pgnoRoot>btreePagecount(pBt) ){
-      return SQLITE_CORRUPT_BKPT;
+      return SQLITE_CORRUPT_PGNO(pgnoRoot);
     }
     pgnoRoot++;
 
@@ -80067,7 +80704,7 @@ static int btreeCreateTable(Btree *p, Pgno *piTable, int createTabFlags){
       }
       rc = ptrmapGet(pBt, pgnoRoot, &eType, &iPtrPage);
       if( eType==PTRMAP_ROOTPAGE || eType==PTRMAP_FREEPAGE ){
-        rc = SQLITE_CORRUPT_BKPT;
+        rc = SQLITE_CORRUPT_PGNO(pgnoRoot);
       }
       if( rc!=SQLITE_OK ){
         releasePage(pRoot);
@@ -80157,14 +80794,14 @@ static int clearDatabasePage(
 
   assert( sqlite3_mutex_held(pBt->mutex) );
   if( pgno>btreePagecount(pBt) ){
-    return SQLITE_CORRUPT_BKPT;
+    return SQLITE_CORRUPT_PGNO(pgno);
   }
   rc = getAndInitPage(pBt, pgno, &pPage, 0);
   if( rc ) return rc;
   if( (pBt->openFlags & BTREE_SINGLE)==0
    && sqlite3PagerPageRefcount(pPage->pDbPage) != (1 + (pgno==1))
   ){
-    rc = SQLITE_CORRUPT_BKPT;
+    rc = SQLITE_CORRUPT_PAGE(pPage);
     goto cleardatabasepage_out;
   }
   hdr = pPage->hdrOffset;
@@ -80268,7 +80905,7 @@ static int btreeDropTable(Btree *p, Pgno iTable, int *piMoved){
   assert( p->inTrans==TRANS_WRITE );
   assert( iTable>=2 );
   if( iTable>btreePagecount(pBt) ){
-    return SQLITE_CORRUPT_BKPT;
+    return SQLITE_CORRUPT_PGNO(iTable);
   }
 
   rc = sqlite3BtreeClearTable(p, iTable, 0);
@@ -80862,6 +81499,9 @@ static int checkTreePage(
   ** number of cells on the page. */
   nCell = get2byte(&data[hdr+3]);
   assert( pPage->nCell==nCell );
+  if( pPage->leaf || pPage->intKey==0 ){
+    pCheck->nRow += nCell;
+  }
 
   /* EVIDENCE-OF: R-23882-45353 The cell pointer array of a b-tree page
   ** immediately follows the b-tree page header. */
@@ -80973,6 +81613,7 @@ static int checkTreePage(
         btreeHeapInsert(heap, (pc<<16)|(pc+size-1));
       }
     }
+    assert( heap!=0 );
     /* Add the freeblocks to the min-heap
     **
     ** EVIDENCE-OF: R-20690-50594 The second field of the b-tree page header
@@ -81072,6 +81713,7 @@ SQLITE_PRIVATE int sqlite3BtreeIntegrityCheck(
   sqlite3 *db,  /* Database connection that is running the check */
   Btree *p,     /* The btree to be checked */
   Pgno *aRoot,  /* An array of root pages numbers for individual trees */
+  Mem *aCnt,    /* Memory cells to write counts for each tree to */
   int nRoot,    /* Number of entries in aRoot[] */
   int mxErr,    /* Stop reporting errors after this many */
   int *pnErr,   /* OUT: Write number of errors seen to this variable */
@@ -81085,7 +81727,9 @@ SQLITE_PRIVATE int sqlite3BtreeIntegrityCheck(
   int bPartial = 0;            /* True if not checking all btrees */
   int bCkFreelist = 1;         /* True to scan the freelist */
   VVA_ONLY( int nRef );
+
   assert( nRoot>0 );
+  assert( aCnt!=0 );
 
   /* aRoot[0]==0 means this is a partial check */
   if( aRoot[0]==0 ){
@@ -81158,15 +81802,18 @@ SQLITE_PRIVATE int sqlite3BtreeIntegrityCheck(
   testcase( pBt->db->flags & SQLITE_CellSizeCk );
   pBt->db->flags &= ~(u64)SQLITE_CellSizeCk;
   for(i=0; (int)i<nRoot && sCheck.mxErr; i++){
-    i64 notUsed;
-    if( aRoot[i]==0 ) continue;
+    sCheck.nRow = 0;
+    if( aRoot[i] ){
+      i64 notUsed;
 #ifndef SQLITE_OMIT_AUTOVACUUM
-    if( pBt->autoVacuum && aRoot[i]>1 && !bPartial ){
-      checkPtrmap(&sCheck, aRoot[i], PTRMAP_ROOTPAGE, 0);
-    }
+      if( pBt->autoVacuum && aRoot[i]>1 && !bPartial ){
+        checkPtrmap(&sCheck, aRoot[i], PTRMAP_ROOTPAGE, 0);
+      }
 #endif
-    sCheck.v0 = aRoot[i];
-    checkTreePage(&sCheck, aRoot[i], &notUsed, LARGEST_INT64);
+      sCheck.v0 = aRoot[i];
+      checkTreePage(&sCheck, aRoot[i], &notUsed, LARGEST_INT64);
+    }
+    sqlite3MemSetArrayInt64(aCnt, i, sCheck.nRow);
   }
   pBt->db->flags = savedDbFlags;
 
@@ -83221,6 +83868,13 @@ SQLITE_PRIVATE void sqlite3VdbeMemSetInt64(Mem *pMem, i64 val){
   }
 }
 
+/*
+** Set the iIdx'th entry of array aMem[] to contain integer value val.
+*/
+SQLITE_PRIVATE void sqlite3MemSetArrayInt64(sqlite3_value *aMem, int iIdx, i64 val){
+  sqlite3VdbeMemSetInt64(&aMem[iIdx], val);
+}
+
 /* A no-op destructor */
 SQLITE_PRIVATE void sqlite3NoopDestructor(void *p){ UNUSED_PARAMETER(p); }
 
@@ -83805,7 +84459,8 @@ static int valueFromFunction(
       goto value_from_function_out;
     }
     for(i=0; i<nVal; i++){
-      rc = sqlite3ValueFromExpr(db, pList->a[i].pExpr, enc, aff, &apVal[i]);
+      rc = sqlite3Stat4ValueFromExpr(pCtx->pParse, pList->a[i].pExpr, aff,
+                                     &apVal[i]);
       if( apVal[i]==0 || rc!=SQLITE_OK ) goto value_from_function_out;
     }
   }
@@ -83909,14 +84564,20 @@ static int valueFromExpr(
   }
 
   /* Handle negative integers in a single step.  This is needed in the
-  ** case when the value is -9223372036854775808.
-  */
-  if( op==TK_UMINUS
-   && (pExpr->pLeft->op==TK_INTEGER || pExpr->pLeft->op==TK_FLOAT) ){
-    pExpr = pExpr->pLeft;
-    op = pExpr->op;
-    negInt = -1;
-    zNeg = "-";
+  ** case when the value is -9223372036854775808. Except - do not do this
+  ** for hexadecimal literals.  */
+  if( op==TK_UMINUS ){
+    Expr *pLeft = pExpr->pLeft;
+    if( (pLeft->op==TK_INTEGER || pLeft->op==TK_FLOAT) ){
+      if( ExprHasProperty(pLeft, EP_IntValue)
+       || pLeft->u.zToken[0]!='0' || (pLeft->u.zToken[1] & ~0x20)!='X'
+      ){
+        pExpr = pLeft;
+        op = pExpr->op;
+        negInt = -1;
+        zNeg = "-";
+      }
+    }
   }
 
   if( op==TK_STRING || op==TK_FLOAT || op==TK_INTEGER ){
@@ -83925,12 +84586,26 @@ static int valueFromExpr(
     if( ExprHasProperty(pExpr, EP_IntValue) ){
       sqlite3VdbeMemSetInt64(pVal, (i64)pExpr->u.iValue*negInt);
     }else{
-      zVal = sqlite3MPrintf(db, "%s%s", zNeg, pExpr->u.zToken);
-      if( zVal==0 ) goto no_mem;
-      sqlite3ValueSetStr(pVal, -1, zVal, SQLITE_UTF8, SQLITE_DYNAMIC);
+      i64 iVal;
+      if( op==TK_INTEGER && 0==sqlite3DecOrHexToI64(pExpr->u.zToken, &iVal) ){
+        sqlite3VdbeMemSetInt64(pVal, iVal*negInt);
+      }else{
+        zVal = sqlite3MPrintf(db, "%s%s", zNeg, pExpr->u.zToken);
+        if( zVal==0 ) goto no_mem;
+        sqlite3ValueSetStr(pVal, -1, zVal, SQLITE_UTF8, SQLITE_DYNAMIC);
+      }
     }
-    if( (op==TK_INTEGER || op==TK_FLOAT ) && affinity==SQLITE_AFF_BLOB ){
-      sqlite3ValueApplyAffinity(pVal, SQLITE_AFF_NUMERIC, SQLITE_UTF8);
+    if( affinity==SQLITE_AFF_BLOB ){
+      if( op==TK_FLOAT ){
+        assert( pVal && pVal->z && pVal->flags==(MEM_Str|MEM_Term) );
+        sqlite3AtoF(pVal->z, &pVal->u.r, pVal->n, SQLITE_UTF8);
+        pVal->flags = MEM_Real;
+      }else if( op==TK_INTEGER ){
+        /* This case is required by -9223372036854775808 and other strings
+        ** that look like integers but cannot be handled by the
+        ** sqlite3DecOrHexToI64() call above.  */
+        sqlite3ValueApplyAffinity(pVal, SQLITE_AFF_NUMERIC, SQLITE_UTF8);
+      }
     }else{
       sqlite3ValueApplyAffinity(pVal, affinity, SQLITE_UTF8);
     }
@@ -84200,17 +84875,17 @@ SQLITE_PRIVATE int sqlite3Stat4Column(
   sqlite3_value **ppVal           /* OUT: Extracted value */
 ){
   u32 t = 0;                      /* a column type code */
-  int nHdr;                       /* Size of the header in the record */
-  int iHdr;                       /* Next unread header byte */
-  int iField;                     /* Next unread data byte */
-  int szField = 0;                /* Size of the current data field */
+  u32 nHdr;                       /* Size of the header in the record */
+  u32 iHdr;                       /* Next unread header byte */
+  i64 iField;                     /* Next unread data byte */
+  u32 szField = 0;                /* Size of the current data field */
   int i;                          /* Column index */
   u8 *a = (u8*)pRec;              /* Typecast byte array */
   Mem *pMem = *ppVal;             /* Write result into this Mem object */
 
   assert( iCol>0 );
   iHdr = getVarint32(a, nHdr);
-  if( nHdr>nRec || iHdr>=nHdr ) return SQLITE_CORRUPT_BKPT;
+  if( nHdr>(u32)nRec || iHdr>=nHdr ) return SQLITE_CORRUPT_BKPT;
   iField = nHdr;
   for(i=0; i<=iCol; i++){
     iHdr += getVarint32(&a[iHdr], t);
@@ -85245,6 +85920,15 @@ static void resolveP2Values(Vdbe *p, int *pMaxFuncArgs){
             assert( aLabel!=0 );  /* True because of tag-20230419-1 */
             pOp->p2 = aLabel[ADDR(pOp->p2)];
           }
+
+          /* OPFLG_JUMP opcodes never have P2==0, though OPFLG_JUMP0 opcodes
+          ** might */
+          assert( pOp->p2>0
+                  || (sqlite3OpcodeProperty[pOp->opcode] & OPFLG_JUMP0)!=0 );
+
+          /* Jumps never go off the end of the bytecode array */
+          assert( pOp->p2<p->nOp
+                  || (sqlite3OpcodeProperty[pOp->opcode] & OPFLG_JUMP)==0 );
           break;
         }
       }
@@ -85710,6 +86394,12 @@ static void freeP4(sqlite3 *db, int p4type, void *p4){
       if( db->pnBytesFreed==0 ) sqlite3DeleteTable(db, (Table*)p4);
       break;
     }
+    case P4_SUBRTNSIG: {
+      SubrtnSig *pSig = (SubrtnSig*)p4;
+      sqlite3DbFree(db, pSig->zAff);
+      sqlite3DbFree(db, pSig);
+      break;
+    }
   }
 }
 
@@ -86289,6 +86979,11 @@ SQLITE_PRIVATE char *sqlite3VdbeDisplayP4(sqlite3 *db, Op *pOp){
       zP4 = pOp->p4.pTab->zName;
       break;
     }
+    case P4_SUBRTNSIG: {
+      SubrtnSig *pSig = pOp->p4.pSubrtnSig;
+      sqlite3_str_appendf(&x, "subrtnsig:%d,%s", pSig->selId, pSig->zAff);
+      break;
+    }
     default: {
       zP4 = pOp->p4.z;
     }
@@ -87652,7 +88347,7 @@ SQLITE_PRIVATE int sqlite3VdbeHalt(Vdbe *p){
 
     /* Check for immediate foreign key violations. */
     if( p->rc==SQLITE_OK || (p->errorAction==OE_Fail && !isSpecialError) ){
-      sqlite3VdbeCheckFk(p, 0);
+      (void)sqlite3VdbeCheckFk(p, 0);
     }
 
     /* If the auto-commit flag is set and this is the only active writer
@@ -88366,6 +89061,23 @@ static void serialGet(
     pMem->flags = IsNaN(x) ? MEM_Null : MEM_Real;
   }
 }
+static int serialGet7(
+  const unsigned char *buf,     /* Buffer to deserialize from */
+  Mem *pMem                     /* Memory cell to write value into */
+){
+  u64 x = FOUR_BYTE_UINT(buf);
+  u32 y = FOUR_BYTE_UINT(buf+4);
+  x = (x<<32) + y;
+  assert( sizeof(x)==8 && sizeof(pMem->u.r)==8 );
+  swapMixedEndianFloat(x);
+  memcpy(&pMem->u.r, &x, sizeof(x));
+  if( IsNaN(x) ){
+    pMem->flags = MEM_Null;
+    return 1;
+  }
+  pMem->flags = MEM_Real;
+  return 0;
+}
 SQLITE_PRIVATE void sqlite3VdbeSerialGet(
   const unsigned char *buf,     /* Buffer to deserialize from */
   u32 serial_type,              /* Serial type to deserialize */
@@ -88781,7 +89493,7 @@ SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3BlobCompare(const Mem *pB1, const Mem
 ** We must use separate SQLITE_NOINLINE functions here, since otherwise
 ** optimizer code movement causes gcov to become very confused.
 */
-#if  defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_DEBUG)
+#if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_DEBUG)
 static int SQLITE_NOINLINE doubleLt(double a, double b){ return a<b; }
 static int SQLITE_NOINLINE doubleEq(double a, double b){ return a==b; }
 #endif
@@ -88796,26 +89508,17 @@ SQLITE_PRIVATE int sqlite3IntFloatCompare(i64 i, double r){
     /* SQLite considers NaN to be a NULL. And all integer values are greater
     ** than NULL */
     return 1;
-  }
-  if( sqlite3Config.bUseLongDouble ){
-    LONGDOUBLE_TYPE x = (LONGDOUBLE_TYPE)i;
-    testcase( x<r );
-    testcase( x>r );
-    testcase( x==r );
-    return (x<r) ? -1 : (x>r);
   }else{
     i64 y;
-    double s;
     if( r<-9223372036854775808.0 ) return +1;
     if( r>=9223372036854775808.0 ) return -1;
     y = (i64)r;
     if( i<y ) return -1;
     if( i>y ) return +1;
-    s = (double)i;
-    testcase( doubleLt(s,r) );
-    testcase( doubleLt(r,s) );
-    testcase( doubleEq(r,s) );
-    return (s<r) ? -1 : (s>r);
+    testcase( doubleLt(((double)i),r) );
+    testcase( doubleLt(r,((double)i)) );
+    testcase( doubleEq(r,((double)i)) );
+    return (((double)i)<r) ? -1 : (((double)i)>r);
   }
 }
 
@@ -89045,7 +89748,7 @@ SQLITE_PRIVATE int sqlite3VdbeRecordCompareWithSkip(
       }else if( serial_type==0 ){
         rc = -1;
       }else if( serial_type==7 ){
-        sqlite3VdbeSerialGet(&aKey1[d1], serial_type, &mem1);
+        serialGet7(&aKey1[d1], &mem1);
         rc = -sqlite3IntFloatCompare(pRhs->u.i, mem1.u.r);
       }else{
         i64 lhs = vdbeRecordDecodeInt(serial_type, &aKey1[d1]);
@@ -89070,14 +89773,18 @@ SQLITE_PRIVATE int sqlite3VdbeRecordCompareWithSkip(
       }else if( serial_type==0 ){
         rc = -1;
       }else{
-        sqlite3VdbeSerialGet(&aKey1[d1], serial_type, &mem1);
         if( serial_type==7 ){
-          if( mem1.u.r<pRhs->u.r ){
+          if( serialGet7(&aKey1[d1], &mem1) ){
+            rc = -1;  /* mem1 is a NaN */
+          }else if( mem1.u.r<pRhs->u.r ){
             rc = -1;
           }else if( mem1.u.r>pRhs->u.r ){
             rc = +1;
+          }else{
+            assert( rc==0 );
           }
         }else{
+          sqlite3VdbeSerialGet(&aKey1[d1], serial_type, &mem1);
           rc = sqlite3IntFloatCompare(mem1.u.i, pRhs->u.r);
         }
       }
@@ -89147,7 +89854,14 @@ SQLITE_PRIVATE int sqlite3VdbeRecordCompareWithSkip(
     /* RHS is null */
     else{
       serial_type = aKey1[idx1];
-      rc = (serial_type!=0 && serial_type!=10);
+      if( serial_type==0
+       || serial_type==10
+       || (serial_type==7 && serialGet7(&aKey1[d1], &mem1)!=0)
+      ){
+        assert( rc==0 );
+      }else{
+        rc = 1;
+      }
     }
 
     if( rc!=0 ){
@@ -89607,7 +90321,8 @@ SQLITE_PRIVATE sqlite3_value *sqlite3VdbeGetBoundValue(Vdbe *v, int iVar, u8 aff
   assert( iVar>0 );
   if( v ){
     Mem *pMem = &v->aVar[iVar-1];
-    assert( (v->db->flags & SQLITE_EnableQPSG)==0 );
+    assert( (v->db->flags & SQLITE_EnableQPSG)==0
+         || (v->db->mDbFlags & DBFLAG_InternalFunc)!=0 );
     if( 0==(pMem->flags & MEM_Null) ){
       sqlite3_value *pRet = sqlite3ValueNew(v->db);
       if( pRet ){
@@ -89627,7 +90342,8 @@ SQLITE_PRIVATE sqlite3_value *sqlite3VdbeGetBoundValue(Vdbe *v, int iVar, u8 aff
 */
 SQLITE_PRIVATE void sqlite3VdbeSetVarmask(Vdbe *v, int iVar){
   assert( iVar>0 );
-  assert( (v->db->flags & SQLITE_EnableQPSG)==0 );
+  assert( (v->db->flags & SQLITE_EnableQPSG)==0
+       || (v->db->mDbFlags & DBFLAG_InternalFunc)!=0 );
   if( iVar>=32 ){
     v->expmask |= 0x80000000;
   }else{
@@ -89801,6 +90517,13 @@ SQLITE_PRIVATE void sqlite3VdbePreUpdateHook(
     }
     sqlite3DbNNFreeNN(db, preupdate.aNew);
   }
+  if( preupdate.apDflt ){
+    int i;
+    for(i=0; i<pTab->nCol; i++){
+      sqlite3ValueFree(preupdate.apDflt[i]);
+    }
+    sqlite3DbFree(db, preupdate.apDflt);
+  }
 }
 #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
 
@@ -91429,6 +92152,17 @@ SQLITE_API const void *sqlite3_column_origin_name16(sqlite3_stmt *pStmt, int N){
 **
 ** The error code stored in database p->db is overwritten with the return
 ** value in any case.
+**
+** (tag-20240917-01) If  vdbeUnbind(p,(u32)(i-1))  returns SQLITE_OK,
+** that means all of the the following will be true:
+**
+**     p!=0
+**     p->pVar!=0
+**     i>0
+**     i<=p->nVar
+**
+** An assert() is normally added after vdbeUnbind() to help static analyzers
+** realize this.
 */
 static int vdbeUnbind(Vdbe *p, unsigned int i){
   Mem *pVar;
@@ -91486,6 +92220,7 @@ static int bindText(
 
   rc = vdbeUnbind(p, (u32)(i-1));
   if( rc==SQLITE_OK ){
+    assert( p!=0 && p->aVar!=0 && i>0 && i<=p->nVar ); /* tag-20240917-01 */
     if( zData!=0 ){
       pVar = &p->aVar[i-1];
       rc = sqlite3VdbeMemSetStr(pVar, zData, nData, encoding, xDel);
@@ -91535,6 +92270,7 @@ SQLITE_API int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){
   Vdbe *p = (Vdbe *)pStmt;
   rc = vdbeUnbind(p, (u32)(i-1));
   if( rc==SQLITE_OK ){
+    assert( p!=0 && p->aVar!=0 && i>0 && i<=p->nVar ); /* tag-20240917-01 */
     sqlite3VdbeMemSetDouble(&p->aVar[i-1], rValue);
     sqlite3_mutex_leave(p->db->mutex);
   }
@@ -91548,6 +92284,7 @@ SQLITE_API int sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValu
   Vdbe *p = (Vdbe *)pStmt;
   rc = vdbeUnbind(p, (u32)(i-1));
   if( rc==SQLITE_OK ){
+    assert( p!=0 && p->aVar!=0 && i>0 && i<=p->nVar ); /* tag-20240917-01 */
     sqlite3VdbeMemSetInt64(&p->aVar[i-1], iValue);
     sqlite3_mutex_leave(p->db->mutex);
   }
@@ -91558,6 +92295,7 @@ SQLITE_API int sqlite3_bind_null(sqlite3_stmt *pStmt, int i){
   Vdbe *p = (Vdbe*)pStmt;
   rc = vdbeUnbind(p, (u32)(i-1));
   if( rc==SQLITE_OK ){
+    assert( p!=0 && p->aVar!=0 && i>0 && i<=p->nVar ); /* tag-20240917-01 */
     sqlite3_mutex_leave(p->db->mutex);
   }
   return rc;
@@ -91573,6 +92311,7 @@ SQLITE_API int sqlite3_bind_pointer(
   Vdbe *p = (Vdbe*)pStmt;
   rc = vdbeUnbind(p, (u32)(i-1));
   if( rc==SQLITE_OK ){
+    assert( p!=0 && p->aVar!=0 && i>0 && i<=p->nVar ); /* tag-20240917-01 */
     sqlite3VdbeMemSetPointer(&p->aVar[i-1], pPtr, zPTtype, xDestructor);
     sqlite3_mutex_leave(p->db->mutex);
   }else if( xDestructor ){
@@ -91654,6 +92393,7 @@ SQLITE_API int sqlite3_bind_zeroblob(sqlite3_stmt *pStmt, int i, int n){
   Vdbe *p = (Vdbe *)pStmt;
   rc = vdbeUnbind(p, (u32)(i-1));
   if( rc==SQLITE_OK ){
+    assert( p!=0 && p->aVar!=0 && i>0 && i<=p->nVar ); /* tag-20240917-01 */
 #ifndef SQLITE_OMIT_INCRBLOB
     sqlite3VdbeMemSetZeroBlob(&p->aVar[i-1], n);
 #else
@@ -92013,7 +92753,30 @@ SQLITE_API int sqlite3_preupdate_old(sqlite3 *db, int iIdx, sqlite3_value **ppVa
   if( iIdx==p->pTab->iPKey ){
     sqlite3VdbeMemSetInt64(pMem, p->iKey1);
   }else if( iIdx>=p->pUnpacked->nField ){
-    *ppValue = (sqlite3_value *)columnNullValue();
+    /* This occurs when the table has been extended using ALTER TABLE
+    ** ADD COLUMN. The value to return is the default value of the column. */
+    Column *pCol = &p->pTab->aCol[iIdx];
+    if( pCol->iDflt>0 ){
+      if( p->apDflt==0 ){
+        int nByte = sizeof(sqlite3_value*)*p->pTab->nCol;
+        p->apDflt = (sqlite3_value**)sqlite3DbMallocZero(db, nByte);
+        if( p->apDflt==0 ) goto preupdate_old_out;
+      }
+      if( p->apDflt[iIdx]==0 ){
+        sqlite3_value *pVal = 0;
+        Expr *pDflt;
+        assert( p->pTab!=0 && IsOrdinaryTable(p->pTab) );
+        pDflt = p->pTab->u.tab.pDfltList->a[pCol->iDflt-1].pExpr;
+        rc = sqlite3ValueFromExpr(db, pDflt, ENC(db), pCol->affinity, &pVal);
+        if( rc==SQLITE_OK && pVal==0 ){
+          rc = SQLITE_CORRUPT_BKPT;
+        }
+        p->apDflt[iIdx] = pVal;
+      }
+      *ppValue = p->apDflt[iIdx];
+    }else{
+      *ppValue = (sqlite3_value *)columnNullValue();
+    }
   }else if( p->pTab->aCol[iIdx].affinity==SQLITE_AFF_REAL ){
     if( pMem->flags & (MEM_Int|MEM_IntReal) ){
       testcase( pMem->flags & MEM_Int );
@@ -92212,7 +92975,6 @@ SQLITE_API int sqlite3_stmt_scanstatus_v2(
   }
   if( flags & SQLITE_SCANSTAT_COMPLEX ){
     idx = iScan;
-    pScan = &p->aScan[idx];
   }else{
     /* If the COMPLEX flag is clear, then this function must ignore any
     ** ScanStatus structures with ScanStatus.addrLoop set to 0. */
@@ -92225,6 +92987,8 @@ SQLITE_API int sqlite3_stmt_scanstatus_v2(
     }
   }
   if( idx>=p->nScan ) return 1;
+  assert( pScan==0 || pScan==&p->aScan[idx] );
+  pScan = &p->aScan[idx];
 
   switch( iScanStatusOp ){
     case SQLITE_SCANSTAT_NLOOP: {
@@ -92565,6 +93329,104 @@ SQLITE_PRIVATE char *sqlite3VdbeExpandSql(
 /* #include "sqliteInt.h" */
 /* #include "vdbeInt.h" */
 
+/*
+** High-resolution hardware timer used for debugging and testing only.
+*/
+#if defined(VDBE_PROFILE)  \
+ || defined(SQLITE_PERFORMANCE_TRACE) \
+ || defined(SQLITE_ENABLE_STMT_SCANSTATUS)
+/************** Include hwtime.h in the middle of vdbe.c *********************/
+/************** Begin file hwtime.h ******************************************/
+/*
+** 2008 May 27
+**
+** The author disclaims copyright to this source code.  In place of
+** a legal notice, here is a blessing:
+**
+**    May you do good and not evil.
+**    May you find forgiveness for yourself and forgive others.
+**    May you share freely, never taking more than you give.
+**
+******************************************************************************
+**
+** This file contains inline asm code for retrieving "high-performance"
+** counters for x86 and x86_64 class CPUs.
+*/
+#ifndef SQLITE_HWTIME_H
+#define SQLITE_HWTIME_H
+
+/*
+** The following routine only works on Pentium-class (or newer) processors.
+** It uses the RDTSC opcode to read the cycle count value out of the
+** processor and returns that value.  This can be used for high-res
+** profiling.
+*/
+#if !defined(__STRICT_ANSI__) && \
+    (defined(__GNUC__) || defined(_MSC_VER)) && \
+    (defined(i386) || defined(__i386__) || defined(_M_IX86))
+
+  #if defined(__GNUC__)
+
+  __inline__ sqlite_uint64 sqlite3Hwtime(void){
+     unsigned int lo, hi;
+     __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));
+     return (sqlite_uint64)hi << 32 | lo;
+  }
+
+  #elif defined(_MSC_VER)
+
+  __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){
+     __asm {
+        rdtsc
+        ret       ; return value at EDX:EAX
+     }
+  }
+
+  #endif
+
+#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__x86_64__))
+
+  __inline__ sqlite_uint64 sqlite3Hwtime(void){
+     unsigned int lo, hi;
+     __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));
+     return (sqlite_uint64)hi << 32 | lo;
+  }
+
+#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__ppc__))
+
+  __inline__ sqlite_uint64 sqlite3Hwtime(void){
+      unsigned long long retval;
+      unsigned long junk;
+      __asm__ __volatile__ ("\n\
+          1:      mftbu   %1\n\
+                  mftb    %L0\n\
+                  mftbu   %0\n\
+                  cmpw    %0,%1\n\
+                  bne     1b"
+                  : "=r" (retval), "=r" (junk));
+      return retval;
+  }
+
+#else
+
+  /*
+  ** asm() is needed for hardware timing support.  Without asm(),
+  ** disable the sqlite3Hwtime() routine.
+  **
+  ** sqlite3Hwtime() is only used for some obscure debugging
+  ** and analysis configurations, not in any deliverable, so this
+  ** should not be a great loss.
+  */
+SQLITE_PRIVATE   sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); }
+
+#endif
+
+#endif /* !defined(SQLITE_HWTIME_H) */
+
+/************** End of hwtime.h **********************************************/
+/************** Continuing where we left off in vdbe.c ***********************/
+#endif
+
 /*
 ** Invoke this macro on memory cells just prior to changing the
 ** value of the cell.  This macro verifies that shallow copies are
@@ -93673,7 +94535,7 @@ case OP_Return: {           /* in1 */
 **
 ** See also: EndCoroutine
 */
-case OP_InitCoroutine: {     /* jump */
+case OP_InitCoroutine: {     /* jump0 */
   assert( pOp->p1>0 &&  pOp->p1<=(p->nMem+1 - p->nCursor) );
   assert( pOp->p2>=0 && pOp->p2<p->nOp );
   assert( pOp->p3>=0 && pOp->p3<p->nOp );
@@ -93696,7 +94558,9 @@ jump_to_p2:
 **
 ** The instruction at the address in register P1 is a Yield.
 ** Jump to the P2 parameter of that Yield.
-** After the jump, register P1 becomes undefined.
+** After the jump, the value register P1 is left with a value
+** such that subsequent OP_Yields go back to the this same
+** OP_EndCoroutine instruction.
 **
 ** See also: InitCoroutine
 */
@@ -93708,8 +94572,8 @@ case OP_EndCoroutine: {           /* in1 */
   pCaller = &aOp[pIn1->u.i];
   assert( pCaller->opcode==OP_Yield );
   assert( pCaller->p2>=0 && pCaller->p2<p->nOp );
+  pIn1->u.i = (int)(pOp - p->aOp) - 1;
   pOp = &aOp[pCaller->p2 - 1];
-  pIn1->flags = MEM_Undefined;
   break;
 }
 
@@ -93726,7 +94590,7 @@ case OP_EndCoroutine: {           /* in1 */
 **
 ** See also: InitCoroutine
 */
-case OP_Yield: {            /* in1, jump */
+case OP_Yield: {            /* in1, jump0 */
   int pcDest;
   pIn1 = &aMem[pOp->p1];
   assert( VdbeMemDynamic(pIn1)==0 );
@@ -93756,7 +94620,7 @@ case OP_HaltIfNull: {      /* in3 */
   /* no break */ deliberate_fall_through
 }
 
-/* Opcode:  Halt P1 P2 * P4 P5
+/* Opcode:  Halt P1 P2 P3 P4 P5
 **
 ** Exit immediately.  All open cursors, etc are closed
 ** automatically.
@@ -93769,18 +94633,22 @@ case OP_HaltIfNull: {      /* in3 */
 ** then back out all changes that have occurred during this execution of the
 ** VDBE, but do not rollback the transaction.
 **
-** If P4 is not null then it is an error message string.
+** If P3 is not zero and P4 is NULL, then P3 is a register that holds the
+** text of an error message.
 **
-** P5 is a value between 0 and 4, inclusive, that modifies the P4 string.
+** If P3 is zero and P4 is not null then the error message string is held
+** in P4.
+**
+** P5 is a value between 1 and 4, inclusive, then the P4 error message
+** string is modified as follows:
 **
-**    0:  (no change)
 **    1:  NOT NULL constraint failed: P4
 **    2:  UNIQUE constraint failed: P4
 **    3:  CHECK constraint failed: P4
 **    4:  FOREIGN KEY constraint failed: P4
 **
-** If P5 is not zero and P4 is NULL, then everything after the ":" is
-** omitted.
+** If P3 is zero and P5 is not zero and P4 is NULL, then everything after
+** the ":" is omitted.
 **
 ** There is an implied "Halt 0 0 0" instruction inserted at the very end of
 ** every program.  So a jump past the last instruction of the program
@@ -93793,6 +94661,9 @@ case OP_Halt: {
 #ifdef SQLITE_DEBUG
   if( pOp->p2==OE_Abort ){ sqlite3VdbeAssertAbortable(p); }
 #endif
+  assert( pOp->p4type==P4_NOTUSED
+       || pOp->p4type==P4_STATIC
+       || pOp->p4type==P4_DYNAMIC );
 
   /* A deliberately coded "OP_Halt SQLITE_INTERNAL * * * *" opcode indicates
   ** something is wrong with the code generator.  Raise an assertion in order
@@ -93823,7 +94694,12 @@ case OP_Halt: {
   p->errorAction = (u8)pOp->p2;
   assert( pOp->p5<=4 );
   if( p->rc ){
-    if( pOp->p5 ){
+    if( pOp->p3>0 && pOp->p4type==P4_NOTUSED ){
+      const char *zErr;
+      assert( pOp->p3<=(p->nMem + 1 - p->nCursor) );
+      zErr = sqlite3ValueText(&aMem[pOp->p3], SQLITE_UTF8);
+      sqlite3VdbeError(p, "%s", zErr);
+    }else if( pOp->p5 ){
       static const char * const azType[] = { "NOT NULL", "UNIQUE", "CHECK",
                                              "FOREIGN KEY" };
       testcase( pOp->p5==1 );
@@ -94056,19 +94932,15 @@ case OP_Blob: {                /* out2 */
   break;
 }
 
-/* Opcode: Variable P1 P2 * P4 *
-** Synopsis: r[P2]=parameter(P1,P4)
+/* Opcode: Variable P1 P2 * * *
+** Synopsis: r[P2]=parameter(P1)
 **
 ** Transfer the values of bound parameter P1 into register P2
-**
-** If the parameter is named, then its name appears in P4.
-** The P4 value is used by sqlite3_bind_parameter_name().
 */
 case OP_Variable: {            /* out2 */
   Mem *pVar;       /* Value being transferred */
 
   assert( pOp->p1>0 && pOp->p1<=p->nVar );
-  assert( pOp->p4.z==0 || pOp->p4.z==sqlite3VListNumToName(p->pVList,pOp->p1) );
   pVar = &p->aVar[pOp->p1 - 1];
   if( sqlite3VdbeMemTooBig(pVar) ){
     goto too_big;
@@ -94589,7 +95461,7 @@ case OP_AddImm: {            /* in1 */
 ** without data loss, then jump immediately to P2, or if P2==0
 ** raise an SQLITE_MISMATCH exception.
 */
-case OP_MustBeInt: {            /* jump, in1 */
+case OP_MustBeInt: {            /* jump0, in1 */
   pIn1 = &aMem[pOp->p1];
   if( (pIn1->flags & MEM_Int)==0 ){
     applyAffinity(pIn1, SQLITE_AFF_NUMERIC, encoding);
@@ -94630,7 +95502,7 @@ case OP_RealAffinity: {                  /* in1 */
 }
 #endif
 
-#ifndef SQLITE_OMIT_CAST
+#if !defined(SQLITE_OMIT_CAST) || !defined(SQLITE_OMIT_ANALYZE)
 /* Opcode: Cast P1 P2 * * *
 ** Synopsis: affinity(r[P1])
 **
@@ -94845,7 +95717,9 @@ case OP_Ge: {             /* same as TK_GE, jump, in1, in3 */
         }
       }
     }else if( affinity==SQLITE_AFF_TEXT && ((flags1 | flags3) & MEM_Str)!=0 ){
-      if( (flags1 & MEM_Str)==0 && (flags1&(MEM_Int|MEM_Real|MEM_IntReal))!=0 ){
+      if( (flags1 & MEM_Str)!=0 ){
+        pIn1->flags &= ~(MEM_Int|MEM_Real|MEM_IntReal);
+      }else if( (flags1&(MEM_Int|MEM_Real|MEM_IntReal))!=0 ){
         testcase( pIn1->flags & MEM_Int );
         testcase( pIn1->flags & MEM_Real );
         testcase( pIn1->flags & MEM_IntReal );
@@ -94854,7 +95728,9 @@ case OP_Ge: {             /* same as TK_GE, jump, in1, in3 */
         flags1 = (pIn1->flags & ~MEM_TypeMask) | (flags1 & MEM_TypeMask);
         if( NEVER(pIn1==pIn3) ) flags3 = flags1 | MEM_Str;
       }
-      if( (flags3 & MEM_Str)==0 && (flags3&(MEM_Int|MEM_Real|MEM_IntReal))!=0 ){
+      if( (flags3 & MEM_Str)!=0 ){
+        pIn3->flags &= ~(MEM_Int|MEM_Real|MEM_IntReal);
+      }else if( (flags3&(MEM_Int|MEM_Real|MEM_IntReal))!=0 ){
         testcase( pIn3->flags & MEM_Int );
         testcase( pIn3->flags & MEM_Real );
         testcase( pIn3->flags & MEM_IntReal );
@@ -96198,11 +97074,16 @@ case OP_MakeRecord: {
         switch( len ){
           default: zPayload[7] = (u8)(v&0xff); v >>= 8;
                    zPayload[6] = (u8)(v&0xff); v >>= 8;
+                   /* no break */ deliberate_fall_through
           case 6:  zPayload[5] = (u8)(v&0xff); v >>= 8;
                    zPayload[4] = (u8)(v&0xff); v >>= 8;
+                   /* no break */ deliberate_fall_through
           case 4:  zPayload[3] = (u8)(v&0xff); v >>= 8;
+                   /* no break */ deliberate_fall_through
           case 3:  zPayload[2] = (u8)(v&0xff); v >>= 8;
+                   /* no break */ deliberate_fall_through
           case 2:  zPayload[1] = (u8)(v&0xff); v >>= 8;
+                   /* no break */ deliberate_fall_through
           case 1:  zPayload[0] = (u8)(v&0xff);
         }
         zPayload += len;
@@ -96861,23 +97742,23 @@ case OP_OpenWrite:
     if( pDb->pSchema->file_format < p->minWriteFileFormat ){
       p->minWriteFileFormat = pDb->pSchema->file_format;
     }
+    if( pOp->p5 & OPFLAG_P2ISREG ){
+      assert( p2>0 );
+      assert( p2<=(u32)(p->nMem+1 - p->nCursor) );
+      pIn2 = &aMem[p2];
+      assert( memIsValid(pIn2) );
+      assert( (pIn2->flags & MEM_Int)!=0 );
+      sqlite3VdbeMemIntegerify(pIn2);
+      p2 = (int)pIn2->u.i;
+      /* The p2 value always comes from a prior OP_CreateBtree opcode and
+      ** that opcode will always set the p2 value to 2 or more or else fail.
+      ** If there were a failure, the prepared statement would have halted
+      ** before reaching this instruction. */
+      assert( p2>=2 );
+    }
   }else{
     wrFlag = 0;
-  }
-  if( pOp->p5 & OPFLAG_P2ISREG ){
-    assert( p2>0 );
-    assert( p2<=(u32)(p->nMem+1 - p->nCursor) );
-    assert( pOp->opcode==OP_OpenWrite );
-    pIn2 = &aMem[p2];
-    assert( memIsValid(pIn2) );
-    assert( (pIn2->flags & MEM_Int)!=0 );
-    sqlite3VdbeMemIntegerify(pIn2);
-    p2 = (int)pIn2->u.i;
-    /* The p2 value always comes from a prior OP_CreateBtree opcode and
-    ** that opcode will always set the p2 value to 2 or more or else fail.
-    ** If there were a failure, the prepared statement would have halted
-    ** before reaching this instruction. */
-    assert( p2>=2 );
+    assert( (pOp->p5 & OPFLAG_P2ISREG)==0 );
   }
   if( pOp->p4type==P4_KEYINFO ){
     pKeyInfo = pOp->p4.pKeyInfo;
@@ -97055,7 +97936,10 @@ case OP_OpenEphemeral: {     /* ncycle */
       }
       pCx->isOrdered = (pOp->p5!=BTREE_UNORDERED);
       if( rc ){
+        assert( !sqlite3BtreeClosesWithCursor(pCx->ub.pBtx, pCx->uc.pCursor) );
         sqlite3BtreeClose(pCx->ub.pBtx);
+      }else{
+        assert( sqlite3BtreeClosesWithCursor(pCx->ub.pBtx, pCx->uc.pCursor) );
       }
     }
   }
@@ -97121,7 +98005,8 @@ case OP_SequenceTest: {
 ** is the only cursor opcode that works with a pseudo-table.
 **
 ** P3 is the number of fields in the records that will be stored by
-** the pseudo-table.
+** the pseudo-table.  If P2 is 0 or negative then the pseudo-cursor
+** will return NULL for every column.
 */
 case OP_OpenPseudo: {
   VdbeCursor *pCx;
@@ -97264,10 +98149,10 @@ case OP_ColumnsUsed: {
 **
 ** See also: Found, NotFound, SeekGt, SeekGe, SeekLt
 */
-case OP_SeekLT:         /* jump, in3, group, ncycle */
-case OP_SeekLE:         /* jump, in3, group, ncycle */
-case OP_SeekGE:         /* jump, in3, group, ncycle */
-case OP_SeekGT: {       /* jump, in3, group, ncycle */
+case OP_SeekLT:         /* jump0, in3, group, ncycle */
+case OP_SeekLE:         /* jump0, in3, group, ncycle */
+case OP_SeekGE:         /* jump0, in3, group, ncycle */
+case OP_SeekGT: {       /* jump0, in3, group, ncycle */
   int res;           /* Comparison result */
   int oc;            /* Opcode */
   VdbeCursor *pC;    /* The cursor to seek */
@@ -97832,6 +98717,7 @@ case OP_Found: {        /* jump, in3, ncycle */
     r.pKeyInfo = pC->pKeyInfo;
     r.default_rc = 0;
 #ifdef SQLITE_DEBUG
+    (void)sqlite3FaultSim(50);  /* For use by --counter in TH3 */
     for(ii=0; ii<r.nField; ii++){
       assert( memIsValid(&r.aMem[ii]) );
       assert( (r.aMem[ii].flags & MEM_Zero)==0 || r.aMem[ii].n==0 );
@@ -97934,7 +98820,7 @@ case OP_Found: {        /* jump, in3, ncycle */
 **
 ** See also: Found, NotFound, NoConflict, SeekRowid
 */
-case OP_SeekRowid: {        /* jump, in3, ncycle */
+case OP_SeekRowid: {        /* jump0, in3, ncycle */
   VdbeCursor *pC;
   BtCursor *pCrsr;
   int res;
@@ -98693,7 +99579,7 @@ case OP_NullRow: {
 ** configured to use Prev, not Next.
 */
 case OP_SeekEnd:             /* ncycle */
-case OP_Last: {              /* jump, ncycle */
+case OP_Last: {              /* jump0, ncycle */
   VdbeCursor *pC;
   BtCursor *pCrsr;
   int res;
@@ -98727,28 +99613,38 @@ case OP_Last: {              /* jump, ncycle */
   break;
 }
 
-/* Opcode: IfSmaller P1 P2 P3 * *
+/* Opcode: IfSizeBetween P1 P2 P3 P4 *
 **
-** Estimate the number of rows in the table P1.  Jump to P2 if that
-** estimate is less than approximately 2**(0.1*P3).
+** Let N be the approximate number of rows in the table or index
+** with cursor P1 and let X be 10*log2(N) if N is positive or -1
+** if N is zero.
+**
+** Jump to P2 if X is in between P3 and P4, inclusive.
 */
-case OP_IfSmaller: {        /* jump */
+case OP_IfSizeBetween: {        /* jump */
   VdbeCursor *pC;
   BtCursor *pCrsr;
   int res;
   i64 sz;
 
   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
+  assert( pOp->p4type==P4_INT32 );
+  assert( pOp->p3>=-1 && pOp->p3<=640*2 );
+  assert( pOp->p4.i>=-1 && pOp->p4.i<=640*2 );
   pC = p->apCsr[pOp->p1];
   assert( pC!=0 );
   pCrsr = pC->uc.pCursor;
   assert( pCrsr );
   rc = sqlite3BtreeFirst(pCrsr, &res);
   if( rc ) goto abort_due_to_error;
-  if( res==0 ){
+  if( res!=0 ){
+    sz = -1;  /* -Infinity encoding */
+  }else{
     sz = sqlite3BtreeRowCountEst(pCrsr);
-    if( ALWAYS(sz>=0) && sqlite3LogEst((u64)sz)<pOp->p3 ) res = 1;
+    assert( sz>0 );
+    sz = sqlite3LogEst((u64)sz);
   }
+  res = sz>=pOp->p3 && sz<=pOp->p4.i;
   VdbeBranchTaken(res!=0,2);
   if( res ) goto jump_to_p2;
   break;
@@ -98801,7 +99697,7 @@ case OP_Sort: {        /* jump ncycle */
 ** from the beginning toward the end.  In other words, the cursor is
 ** configured to use Next, not Prev.
 */
-case OP_Rewind: {        /* jump, ncycle */
+case OP_Rewind: {        /* jump0, ncycle */
   VdbeCursor *pC;
   BtCursor *pCrsr;
   int res;
@@ -99448,11 +100344,18 @@ case OP_CreateBtree: {          /* out2 */
   break;
 }
 
-/* Opcode: SqlExec * * * P4 *
+/* Opcode: SqlExec P1 P2 * P4 *
 **
 ** Run the SQL statement or statements specified in the P4 string.
-** Disable Auth and Trace callbacks while those statements are running if
-** P1 is true.
+**
+** The P1 parameter is a bitmask of options:
+**
+**    0x0001     Disable Auth and Trace callbacks while the statements
+**               in P4 are running.
+**
+**    0x0002     Set db->nAnalysisLimit to P2 while the statements in
+**               P4 are running.
+**
 */
 case OP_SqlExec: {
   char *zErr;
@@ -99460,6 +100363,7 @@ case OP_SqlExec: {
   sqlite3_xauth xAuth;
 #endif
   u8 mTrace;
+  int savedAnalysisLimit;
 
   sqlite3VdbeIncrWriteCounter(p, 0);
   db->nSqlExec++;
@@ -99468,18 +100372,23 @@ case OP_SqlExec: {
   xAuth = db->xAuth;
 #endif
   mTrace = db->mTrace;
-  if( pOp->p1 ){
+  savedAnalysisLimit = db->nAnalysisLimit;
+  if( pOp->p1 & 0x0001 ){
 #ifndef SQLITE_OMIT_AUTHORIZATION
     db->xAuth = 0;
 #endif
     db->mTrace = 0;
   }
+  if( pOp->p1 & 0x0002 ){
+    db->nAnalysisLimit = pOp->p2;
+  }
   rc = sqlite3_exec(db, pOp->p4.z, 0, 0, &zErr);
   db->nSqlExec--;
 #ifndef SQLITE_OMIT_AUTHORIZATION
   db->xAuth = xAuth;
 #endif
   db->mTrace = mTrace;
+  db->nAnalysisLimit = savedAnalysisLimit;
   if( zErr || rc ){
     sqlite3VdbeError(p, "%s", zErr);
     sqlite3_free(zErr);
@@ -99631,11 +100540,11 @@ case OP_DropTrigger: {
 /* Opcode: IntegrityCk P1 P2 P3 P4 P5
 **
 ** Do an analysis of the currently open database.  Store in
-** register P1 the text of an error message describing any problems.
-** If no problems are found, store a NULL in register P1.
+** register (P1+1) the text of an error message describing any problems.
+** If no problems are found, store a NULL in register (P1+1).
 **
-** The register P3 contains one less than the maximum number of allowed errors.
-** At most reg(P3) errors will be reported.
+** The register (P1) contains one less than the maximum number of allowed
+** errors.  At most reg(P1) errors will be reported.
 ** In other words, the analysis stops as soon as reg(P1) errors are
 ** seen.  Reg(P1) is updated with the number of errors remaining.
 **
@@ -99655,19 +100564,21 @@ case OP_IntegrityCk: {
   Mem *pnErr;     /* Register keeping track of errors remaining */
 
   assert( p->bIsReader );
+  assert( pOp->p4type==P4_INTARRAY );
   nRoot = pOp->p2;
   aRoot = pOp->p4.ai;
   assert( nRoot>0 );
+  assert( aRoot!=0 );
   assert( aRoot[0]==(Pgno)nRoot );
-  assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
-  pnErr = &aMem[pOp->p3];
+  assert( pOp->p1>0 && (pOp->p1+1)<=(p->nMem+1 - p->nCursor) );
+  pnErr = &aMem[pOp->p1];
   assert( (pnErr->flags & MEM_Int)!=0 );
   assert( (pnErr->flags & (MEM_Str|MEM_Blob))==0 );
-  pIn1 = &aMem[pOp->p1];
+  pIn1 = &aMem[pOp->p1+1];
   assert( pOp->p5<db->nDb );
   assert( DbMaskTest(p->btreeMask, pOp->p5) );
-  rc = sqlite3BtreeIntegrityCheck(db, db->aDb[pOp->p5].pBt, &aRoot[1], nRoot,
-                                 (int)pnErr->u.i+1, &nErr, &z);
+  rc = sqlite3BtreeIntegrityCheck(db, db->aDb[pOp->p5].pBt, &aRoot[1],
+      &aMem[pOp->p3], nRoot, (int)pnErr->u.i+1, &nErr, &z);
   sqlite3VdbeMemSetNull(pIn1);
   if( nErr==0 ){
     assert( z==0 );
@@ -99794,7 +100705,9 @@ case OP_RowSetTest: {                     /* jump, in1, in3 */
 ** P1 contains the address of the memory cell that contains the first memory
 ** cell in an array of values used as arguments to the sub-program. P2
 ** contains the address to jump to if the sub-program throws an IGNORE
-** exception using the RAISE() function. Register P3 contains the address
+** exception using the RAISE() function. P2 might be zero, if there is
+** no possibility that an IGNORE exception will be raised.
+** Register P3 contains the address
 ** of a memory cell in this (the parent) VM that is used to allocate the
 ** memory required by the sub-vdbe at runtime.
 **
@@ -99802,7 +100715,7 @@ case OP_RowSetTest: {                     /* jump, in1, in3 */
 **
 ** If P5 is non-zero, then recursive program invocation is enabled.
 */
-case OP_Program: {        /* jump */
+case OP_Program: {        /* jump0 */
   int nMem;               /* Number of memory registers for sub-program */
   int nByte;              /* Bytes of runtime space required for sub-program */
   Mem *pRt;               /* Register to allocate runtime space */
@@ -100167,18 +101080,29 @@ case OP_AggInverse:
 case OP_AggStep: {
   int n;
   sqlite3_context *pCtx;
+  u64 nAlloc;
 
   assert( pOp->p4type==P4_FUNCDEF );
   n = pOp->p5;
   assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
   assert( n==0 || (pOp->p2>0 && pOp->p2+n<=(p->nMem+1 - p->nCursor)+1) );
   assert( pOp->p3<pOp->p2 || pOp->p3>=pOp->p2+n );
-  pCtx = sqlite3DbMallocRawNN(db, n*sizeof(sqlite3_value*) +
-               (sizeof(pCtx[0]) + sizeof(Mem) - sizeof(sqlite3_value*)));
+
+  /* Allocate space for (a) the context object and (n-1) extra pointers
+  ** to append to the sqlite3_context.argv[1] array, and (b) a memory
+  ** cell in which to store the accumulation. Be careful that the memory
+  ** cell is 8-byte aligned, even on platforms where a pointer is 32-bits.
+  **
+  ** Note: We could avoid this by using a regular memory cell from aMem[] for
+  ** the accumulator, instead of allocating one here. */
+  nAlloc = ROUND8P( sizeof(pCtx[0]) + (n-1)*sizeof(sqlite3_value*) );
+  pCtx = sqlite3DbMallocRawNN(db, nAlloc + sizeof(Mem));
   if( pCtx==0 ) goto no_mem;
-  pCtx->pMem = 0;
-  pCtx->pOut = (Mem*)&(pCtx->argv[n]);
+  pCtx->pOut = (Mem*)((u8*)pCtx + nAlloc);
+  assert( EIGHT_BYTE_ALIGNMENT(pCtx->pOut) );
+
   sqlite3VdbeMemInit(pCtx->pOut, db, MEM_Null);
+  pCtx->pMem = 0;
   pCtx->pFunc = pOp->p4.pFunc;
   pCtx->iOp = (int)(pOp - aOp);
   pCtx->pVdbe = p;
@@ -101351,7 +102275,7 @@ case OP_Filter: {          /* jump */
 ** error is encountered.
 */
 case OP_Trace:
-case OP_Init: {          /* jump */
+case OP_Init: {          /* jump0 */
   int i;
 #ifndef SQLITE_OMIT_TRACE
   char *zTrace;
@@ -101512,14 +102436,29 @@ case OP_ReleaseReg: {
 
 /* Opcode: Noop * * * * *
 **
-** Do nothing.  This instruction is often useful as a jump
-** destination.
+** Do nothing.  Continue downward to the next opcode.
 */
-/*
-** The magic Explain opcode are only inserted when explain==2 (which
-** is to say when the EXPLAIN QUERY PLAN syntax is used.)
-** This opcode records information from the optimizer.  It is the
-** the same as a no-op.  This opcodesnever appears in a real VM program.
+/* Opcode: Explain P1 P2 P3 P4 *
+**
+** This is the same as OP_Noop during normal query execution.  The
+** purpose of this opcode is to hold information about the query
+** plan for the purpose of EXPLAIN QUERY PLAN output.
+**
+** The P4 value is human-readable text that describes the query plan
+** element.  Something like "SCAN t1" or "SEARCH t2 USING INDEX t2x1".
+**
+** The P1 value is the ID of the current element and P2 is the parent
+** element for the case of nested query plan elements.  If P2 is zero
+** then this element is a top-level element.
+**
+** For loop elements, P3 is the estimated code of each invocation of this
+** element.
+**
+** As with all opcodes, the meanings of the parameters for OP_Explain
+** are subject to change from one release to the next.  Applications
+** should not attempt to interpret or use any of the information
+** contained in the OP_Explain opcode.  The information provided by this
+** opcode is intended for testing and debugging use only.
 */
 default: {          /* This is really OP_Noop, OP_Explain */
   assert( pOp->opcode==OP_Noop || pOp->opcode==OP_Explain );
@@ -101846,6 +102785,11 @@ SQLITE_API int sqlite3_blob_open(
       pTab = 0;
       sqlite3ErrorMsg(&sParse, "cannot open table without rowid: %s", zTable);
     }
+    if( pTab && (pTab->tabFlags&TF_HasGenerated)!=0 ){
+      pTab = 0;
+      sqlite3ErrorMsg(&sParse, "cannot open table with generated columns: %s",
+                      zTable);
+    }
 #ifndef SQLITE_OMIT_VIEW
     if( pTab && IsView(pTab) ){
       pTab = 0;
@@ -102753,13 +103697,14 @@ static int vdbePmaReadBlob(
     while( nRem>0 ){
       int rc;                     /* vdbePmaReadBlob() return code */
       int nCopy;                  /* Number of bytes to copy */
-      u8 *aNext;                  /* Pointer to buffer to copy data from */
+      u8 *aNext = 0;              /* Pointer to buffer to copy data from */
 
       nCopy = nRem;
       if( nRem>p->nBuffer ) nCopy = p->nBuffer;
       rc = vdbePmaReadBlob(p, nCopy, &aNext);
       if( rc!=SQLITE_OK ) return rc;
       assert( aNext!=p->aAlloc );
+      assert( aNext!=0 );
       memcpy(&p->aAlloc[nByte - nRem], aNext, nCopy);
       nRem -= nCopy;
     }
@@ -105252,10 +106197,10 @@ static int bytecodevtabColumn(
 
 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
     case 9:     /* nexec */
-      sqlite3_result_int(ctx, pOp->nExec);
+      sqlite3_result_int64(ctx, pOp->nExec);
       break;
     case 10:    /* ncycle */
-      sqlite3_result_int(ctx, pOp->nCycle);
+      sqlite3_result_int64(ctx, pOp->nCycle);
       break;
 #else
     case 9:     /* nexec */
@@ -106029,7 +106974,9 @@ SQLITE_PRIVATE int sqlite3WalkSelectFrom(Walker *pWalker, Select *p){
   pSrc = p->pSrc;
   if( ALWAYS(pSrc) ){
     for(i=pSrc->nSrc, pItem=pSrc->a; i>0; i--, pItem++){
-      if( pItem->pSelect && sqlite3WalkSelect(pWalker, pItem->pSelect) ){
+      if( pItem->fg.isSubquery
+       && sqlite3WalkSelect(pWalker, pItem->u4.pSubq->pSelect)
+      ){
         return WRC_Abort;
       }
       if( pItem->fg.isTabFunc
@@ -106199,6 +107146,8 @@ static void resolveAlias(
   assert( iCol>=0 && iCol<pEList->nExpr );
   pOrig = pEList->a[iCol].pExpr;
   assert( pOrig!=0 );
+  assert( !ExprHasProperty(pExpr, EP_Reduced|EP_TokenOnly) );
+  if( pExpr->pAggInfo ) return;
   db = pParse->db;
   pDup = sqlite3ExprDup(db, pOrig, 0);
   if( db->mallocFailed ){
@@ -106333,7 +107282,7 @@ static void extendFJMatch(
   if( pNew ){
     pNew->iTable = pMatch->iCursor;
     pNew->iColumn = iColumn;
-    pNew->y.pTab = pMatch->pTab;
+    pNew->y.pTab = pMatch->pSTab;
     assert( (pMatch->fg.jointype & (JT_LEFT|JT_LTORJ))!=0 );
     ExprSetProperty(pNew, EP_CanBeNull);
     *ppList = sqlite3ExprListAppend(pParse, *ppList, pNew);
@@ -106346,7 +107295,7 @@ static void extendFJMatch(
 static SQLITE_NOINLINE int isValidSchemaTableName(
   const char *zTab,         /* Name as it appears in the SQL */
   Table *pTab,              /* The schema table we are trying to match */
-  Schema *pSchema           /* non-NULL if a database qualifier is present */
+  const char *zDb           /* non-NULL if a database qualifier is present */
 ){
   const char *zLegacy;
   assert( pTab!=0 );
@@ -106357,7 +107306,7 @@ static SQLITE_NOINLINE int isValidSchemaTableName(
     if( sqlite3StrICmp(zTab+7, &PREFERRED_TEMP_SCHEMA_TABLE[7])==0 ){
       return 1;
     }
-    if( pSchema==0 ) return 0;
+    if( zDb==0 ) return 0;
     if( sqlite3StrICmp(zTab+7, &LEGACY_SCHEMA_TABLE[7])==0 ) return 1;
     if( sqlite3StrICmp(zTab+7, &PREFERRED_SCHEMA_TABLE[7])==0 ) return 1;
   }else{
@@ -106397,7 +107346,7 @@ static int lookupName(
   Parse *pParse,       /* The parsing context */
   const char *zDb,     /* Name of the database containing table, or NULL */
   const char *zTab,    /* Name of table containing column, or NULL */
-  const char *zCol,    /* Name of the column. */
+  const Expr *pRight,  /* Name of the column. */
   NameContext *pNC,    /* The name context used to resolve the name */
   Expr *pExpr          /* Make this EXPR node point to the selected column */
 ){
@@ -106414,6 +107363,7 @@ static int lookupName(
   Table *pTab = 0;                  /* Table holding the row */
   Column *pCol;                     /* A column of pTab */
   ExprList *pFJMatch = 0;           /* Matches for FULL JOIN .. USING */
+  const char *zCol = pRight->u.zToken;
 
   assert( pNC );     /* the name context cannot be NULL. */
   assert( zCol );    /* The Z in X.Y.Z cannot be NULL */
@@ -106463,10 +107413,10 @@ static int lookupName(
     if( pSrcList ){
       for(i=0, pItem=pSrcList->a; i<pSrcList->nSrc; i++, pItem++){
         u8 hCol;
-        pTab = pItem->pTab;
+        pTab = pItem->pSTab;
         assert( pTab!=0 && pTab->zName!=0 );
         assert( pTab->nCol>0 || pParse->nErr );
-        assert( (int)pItem->fg.isNestedFrom == IsNestedFrom(pItem->pSelect) );
+        assert( (int)pItem->fg.isNestedFrom == IsNestedFrom(pItem));
         if( pItem->fg.isNestedFrom ){
           /* In this case, pItem is a subquery that has been formed from a
           ** parenthesized subset of the FROM clause terms.  Example:
@@ -106475,8 +107425,12 @@ static int lookupName(
           **             This pItem -------------^
           */
           int hit = 0;
-          assert( pItem->pSelect!=0 );
-          pEList = pItem->pSelect->pEList;
+          Select *pSel;
+          assert( pItem->fg.isSubquery );
+          assert( pItem->u4.pSubq!=0 );
+          pSel = pItem->u4.pSubq->pSelect;
+          assert( pSel!=0 );
+          pEList = pSel->pEList;
           assert( pEList!=0 );
           assert( pEList->nExpr==pTab->nCol );
           for(j=0; j<pEList->nExpr; j++){
@@ -106539,7 +107493,7 @@ static int lookupName(
             }
           }else if( sqlite3StrICmp(zTab, pTab->zName)!=0 ){
             if( pTab->tnum!=1 ) continue;
-            if( !isValidSchemaTableName(zTab, pTab, pSchema) ) continue;
+            if( !isValidSchemaTableName(zTab, pTab, zDb) ) continue;
           }
           assert( ExprUseYTab(pExpr) );
           if( IN_RENAME_OBJECT && pItem->zAlias ){
@@ -106586,14 +107540,43 @@ static int lookupName(
           }
         }
         if( 0==cnt && VisibleRowid(pTab) ){
+          /* pTab is a potential ROWID match.  Keep track of it and match
+          ** the ROWID later if that seems appropriate.  (Search for "cntTab"
+          ** to find related code.)  Only allow a ROWID match if there is
+          ** a single ROWID match candidate.
+          */
+#ifdef SQLITE_ALLOW_ROWID_IN_VIEW
+          /* In SQLITE_ALLOW_ROWID_IN_VIEW mode, allow a ROWID match
+          ** if there is a single VIEW candidate or if there is a single
+          ** non-VIEW candidate plus multiple VIEW candidates.  In other
+          ** words non-VIEW candidate terms take precedence over VIEWs.
+          */
+          if( cntTab==0
+           || (cntTab==1
+               && pMatch!=0
+               && ALWAYS(pMatch->pSTab!=0)
+               && (pMatch->pSTab->tabFlags & TF_Ephemeral)!=0
+               && (pTab->tabFlags & TF_Ephemeral)==0)
+          ){
+            cntTab = 1;
+            pMatch = pItem;
+          }else{
+            cntTab++;
+          }
+#else
+          /* The (much more common) non-SQLITE_ALLOW_ROWID_IN_VIEW case is
+          ** simpler since we require exactly one candidate, which will
+          ** always be a non-VIEW
+          */
           cntTab++;
           pMatch = pItem;
+#endif
         }
       }
       if( pMatch ){
         pExpr->iTable = pMatch->iCursor;
         assert( ExprUseYTab(pExpr) );
-        pExpr->y.pTab = pMatch->pTab;
+        pExpr->y.pTab = pMatch->pSTab;
         if( (pMatch->fg.jointype & (JT_LEFT|JT_LTORJ))!=0 ){
           ExprSetProperty(pExpr, EP_CanBeNull);
         }
@@ -106616,7 +107599,8 @@ static int lookupName(
         if( pParse->bReturning ){
           if( (pNC->ncFlags & NC_UBaseReg)!=0
            && ALWAYS(zTab==0
-                     || sqlite3StrICmp(zTab,pParse->pTriggerTab->zName)==0)
+                     || sqlite3StrICmp(zTab,pParse->pTriggerTab->zName)==0
+                     || isValidSchemaTableName(zTab, pParse->pTriggerTab, 0))
           ){
             pExpr->iTable = op!=TK_DELETE;
             pTab = pParse->pTriggerTab;
@@ -106634,7 +107618,7 @@ static int lookupName(
       if( (pNC->ncFlags & NC_UUpsert)!=0 && zTab!=0 ){
         Upsert *pUpsert = pNC->uNC.pUpsert;
         if( pUpsert && sqlite3StrICmp("excluded",zTab)==0 ){
-          pTab = pUpsert->pUpsertSrc->a[0].pTab;
+          pTab = pUpsert->pUpsertSrc->a[0].pSTab;
           pExpr->iTable = EXCLUDED_TABLE_NUMBER;
         }
       }
@@ -106713,13 +107697,18 @@ static int lookupName(
     ** Perhaps the name is a reference to the ROWID
     */
     if( cnt==0
-     && cntTab==1
+     && cntTab>=1
      && pMatch
      && (pNC->ncFlags & (NC_IdxExpr|NC_GenCol))==0
      && sqlite3IsRowid(zCol)
-     && ALWAYS(VisibleRowid(pMatch->pTab) || pMatch->fg.isNestedFrom)
+     && ALWAYS(VisibleRowid(pMatch->pSTab) || pMatch->fg.isNestedFrom)
     ){
-      cnt = 1;
+      cnt = cntTab;
+#if SQLITE_ALLOW_ROWID_IN_VIEW+0==2
+      if( pMatch->pSTab!=0 && IsView(pMatch->pSTab) ){
+        eNewExprOp = TK_NULL;
+      }
+#endif
       if( pMatch->fg.isNestedFrom==0 ) pExpr->iColumn = -1;
       pExpr->affExpr = SQLITE_AFF_INTEGER;
     }
@@ -106873,6 +107862,10 @@ static int lookupName(
       sqlite3ErrorMsg(pParse, "%s: %s.%s.%s", zErr, zDb, zTab, zCol);
     }else if( zTab ){
       sqlite3ErrorMsg(pParse, "%s: %s.%s", zErr, zTab, zCol);
+    }else if( cnt==0 && ExprHasProperty(pRight,EP_DblQuoted) ){
+      sqlite3ErrorMsg(pParse, "%s: \"%s\" - should this be a"
+                              " string literal in single-quotes?",
+                              zErr, zCol);
     }else{
       sqlite3ErrorMsg(pParse, "%s: %s", zErr, zCol);
     }
@@ -106906,8 +107899,12 @@ static int lookupName(
   ** If a generated column is referenced, set bits for every column
   ** of the table.
   */
-  if( pExpr->iColumn>=0 && cnt==1 && pMatch!=0 ){
-    pMatch->colUsed |= sqlite3ExprColUsed(pExpr);
+  if( pMatch ){
+    if( pExpr->iColumn>=0 ){
+      pMatch->colUsed |= sqlite3ExprColUsed(pExpr);
+    }else{
+      pMatch->fg.rowidUsed = 1;
+    }
   }
 
   pExpr->op = eNewExprOp;
@@ -106945,7 +107942,7 @@ SQLITE_PRIVATE Expr *sqlite3CreateColumnExpr(sqlite3 *db, SrcList *pSrc, int iSr
     SrcItem *pItem = &pSrc->a[iSrc];
     Table *pTab;
     assert( ExprUseYTab(p) );
-    pTab = p->y.pTab = pItem->pTab;
+    pTab = p->y.pTab = pItem->pSTab;
     p->iTable = pItem->iCursor;
     if( p->y.pTab->iPKey==iCol ){
       p->iColumn = -1;
@@ -107064,7 +108061,7 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
       pItem = pSrcList->a;
       pExpr->op = TK_COLUMN;
       assert( ExprUseYTab(pExpr) );
-      pExpr->y.pTab = pItem->pTab;
+      pExpr->y.pTab = pItem->pSTab;
       pExpr->iTable = pItem->iCursor;
       pExpr->iColumn--;
       pExpr->affExpr = SQLITE_AFF_INTEGER;
@@ -107084,6 +108081,19 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
     ** resolved.  This prevents "column" from being counted as having been
     ** referenced, which might prevent a SELECT from being erroneously
     ** marked as correlated.
+    **
+    ** 2024-03-28: Beware of aggregates.  A bare column of aggregated table
+    ** can still evaluate to NULL even though it is marked as NOT NULL.
+    ** Example:
+    **
+    **       CREATE TABLE t1(a INT NOT NULL);
+    **       SELECT a, a IS NULL, a IS NOT NULL, count(*) FROM t1;
+    **
+    ** The "a IS NULL" and "a IS NOT NULL" expressions cannot be optimized
+    ** here because at the time this case is hit, we do not yet know whether
+    ** or not t1 is being aggregated.  We have to assume the worst and omit
+    ** the optimization.  The only time it is safe to apply this optimization
+    ** is within the WHERE clause.
     */
     case TK_NOTNULL:
     case TK_ISNULL: {
@@ -107094,19 +108104,36 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
         anRef[i] = p->nRef;
       }
       sqlite3WalkExpr(pWalker, pExpr->pLeft);
-      if( 0==sqlite3ExprCanBeNull(pExpr->pLeft) && !IN_RENAME_OBJECT ){
-        testcase( ExprHasProperty(pExpr, EP_OuterON) );
-        assert( !ExprHasProperty(pExpr, EP_IntValue) );
-        pExpr->u.iValue = (pExpr->op==TK_NOTNULL);
-        pExpr->flags |= EP_IntValue;
-        pExpr->op = TK_INTEGER;
-
-        for(i=0, p=pNC; p && i<ArraySize(anRef); p=p->pNext, i++){
-          p->nRef = anRef[i];
-        }
-        sqlite3ExprDelete(pParse->db, pExpr->pLeft);
-        pExpr->pLeft = 0;
+      if( IN_RENAME_OBJECT ) return WRC_Prune;
+      if( sqlite3ExprCanBeNull(pExpr->pLeft) ){
+        /* The expression can be NULL.  So the optimization does not apply */
+        return WRC_Prune;
       }
+
+      for(i=0, p=pNC; p; p=p->pNext, i++){
+        if( (p->ncFlags & NC_Where)==0 ){
+          return WRC_Prune;  /* Not in a WHERE clause.  Unsafe to optimize. */
+        }
+      }
+      testcase( ExprHasProperty(pExpr, EP_OuterON) );
+      assert( !ExprHasProperty(pExpr, EP_IntValue) );
+#if TREETRACE_ENABLED
+      if( sqlite3TreeTrace & 0x80000 ){
+        sqlite3DebugPrintf(
+           "NOT NULL strength reduction converts the following to %d:\n",
+           pExpr->op==TK_NOTNULL
+        );
+        sqlite3ShowExpr(pExpr);
+      }
+#endif /* TREETRACE_ENABLED */
+      pExpr->u.iValue = (pExpr->op==TK_NOTNULL);
+      pExpr->flags |= EP_IntValue;
+      pExpr->op = TK_INTEGER;
+      for(i=0, p=pNC; p && i<ArraySize(anRef); p=p->pNext, i++){
+        p->nRef = anRef[i];
+      }
+      sqlite3ExprDelete(pParse->db, pExpr->pLeft);
+      pExpr->pLeft = 0;
       return WRC_Prune;
     }
 
@@ -107120,7 +108147,6 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
     */
     case TK_ID:
     case TK_DOT: {
-      const char *zColumn;
       const char *zTable;
       const char *zDb;
       Expr *pRight;
@@ -107129,7 +108155,7 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
         zDb = 0;
         zTable = 0;
         assert( !ExprHasProperty(pExpr, EP_IntValue) );
-        zColumn = pExpr->u.zToken;
+        pRight = pExpr;
       }else{
         Expr *pLeft = pExpr->pLeft;
         testcase( pNC->ncFlags & NC_IdxExpr );
@@ -107148,21 +108174,20 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
         }
         assert( ExprUseUToken(pLeft) && ExprUseUToken(pRight) );
         zTable = pLeft->u.zToken;
-        zColumn = pRight->u.zToken;
         assert( ExprUseYTab(pExpr) );
         if( IN_RENAME_OBJECT ){
           sqlite3RenameTokenRemap(pParse, (void*)pExpr, (void*)pRight);
           sqlite3RenameTokenRemap(pParse, (void*)&pExpr->y.pTab, (void*)pLeft);
         }
       }
-      return lookupName(pParse, zDb, zTable, zColumn, pNC, pExpr);
+      return lookupName(pParse, zDb, zTable, pRight, pNC, pExpr);
     }
 
     /* Resolve function names
     */
     case TK_FUNCTION: {
-      ExprList *pList = pExpr->x.pList;    /* The argument list */
-      int n = pList ? pList->nExpr : 0;    /* Number of arguments */
+      ExprList *pList;            /* The argument list */
+      int n;                      /* Number of arguments */
       int no_such_func = 0;       /* True if no such function exists */
       int wrong_num_args = 0;     /* True if wrong number of arguments */
       int is_agg = 0;             /* True if is an aggregate function */
@@ -107175,6 +108200,8 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
 #endif
       assert( !ExprHasProperty(pExpr, EP_xIsSelect|EP_IntValue) );
       assert( pExpr->pLeft==0 || pExpr->pLeft->op==TK_ORDER );
+      pList = pExpr->x.pList;
+      n = pList ? pList->nExpr : 0;
       zId = pExpr->u.zToken;
       pDef = sqlite3FindFunction(pParse->db, zId, n, enc, 0);
       if( pDef==0 ){
@@ -107223,6 +108250,24 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
           }
         }
 #endif
+
+        /* If the function may call sqlite3_value_subtype(), then set the
+        ** EP_SubtArg flag on all of its argument expressions. This prevents
+        ** where.c from replacing the expression with a value read from an
+        ** index on the same expression, which will not have the correct
+        ** subtype. Also set the flag if the function expression itself is
+        ** an EP_SubtArg expression. In this case subtypes are required as
+        ** the function may return a value with a subtype back to its
+        ** caller using sqlite3_result_value().  */
+        if( (pDef->funcFlags & SQLITE_SUBTYPE)
+         || ExprHasProperty(pExpr, EP_SubtArg)
+        ){
+          int ii;
+          for(ii=0; ii<n; ii++){
+            ExprSetProperty(pList->a[ii].pExpr, EP_SubtArg);
+          }
+        }
+
         if( pDef->funcFlags & (SQLITE_FUNC_CONSTANT|SQLITE_FUNC_SLOCHNG) ){
           /* For the purposes of the EP_ConstFunc flag, date and time
           ** functions and other functions that change slowly are considered
@@ -107331,11 +108376,9 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
 #endif
         }
       }
-#ifndef SQLITE_OMIT_WINDOWFUNC
-      else if( ExprHasProperty(pExpr, EP_WinFunc) ){
+      else if( ExprHasProperty(pExpr, EP_WinFunc) || pExpr->pLeft ){
         is_agg = 1;
       }
-#endif
       sqlite3WalkExprList(pWalker, pList);
       if( is_agg ){
         if( pExpr->pLeft ){
@@ -107344,9 +108387,9 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
           sqlite3WalkExprList(pWalker, pExpr->pLeft->x.pList);
         }
 #ifndef SQLITE_OMIT_WINDOWFUNC
-        if( pWin ){
+        if( pWin && pParse->nErr==0 ){
           Select *pSel = pNC->pWinSelect;
-          assert( pWin==0 || (ExprUseYWin(pExpr) && pWin==pExpr->y.pWin) );
+          assert( ExprUseYWin(pExpr) && pWin==pExpr->y.pWin );
           if( IN_RENAME_OBJECT==0 ){
             sqlite3WindowUpdate(pParse, pSel ? pSel->pWinDefn : 0, pWin, pDef);
             if( pParse->db->mallocFailed ) break;
@@ -107405,6 +108448,7 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
         testcase( pNC->ncFlags & NC_PartIdx );
         testcase( pNC->ncFlags & NC_IdxExpr );
         testcase( pNC->ncFlags & NC_GenCol );
+        assert( pExpr->x.pSelect );
         if( pNC->ncFlags & NC_SelfRef ){
           notValidImpl(pParse, pNC, "subqueries", pExpr, pExpr);
         }else{
@@ -107413,6 +108457,7 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
         assert( pNC->nRef>=nRef );
         if( nRef!=pNC->nRef ){
           ExprSetProperty(pExpr, EP_VarSelect);
+          pExpr->x.pSelect->selFlags |= SF_Correlated;
         }
         pNC->ncFlags |= NC_Subquery;
       }
@@ -107551,7 +108596,7 @@ static int resolveOrderByTermToExprList(
   int rc;            /* Return code from subprocedures */
   u8 savedSuppErr;   /* Saved value of db->suppressErr */
 
-  assert( sqlite3ExprIsInteger(pE, &i)==0 );
+  assert( sqlite3ExprIsInteger(pE, &i, 0)==0 );
   pEList = pSelect->pEList;
 
   /* Resolve all names in the ORDER BY term expression
@@ -107650,7 +108695,7 @@ static int resolveCompoundOrderBy(
       if( pItem->fg.done ) continue;
       pE = sqlite3ExprSkipCollateAndLikely(pItem->pExpr);
       if( NEVER(pE==0) ) continue;
-      if( sqlite3ExprIsInteger(pE, &iCol) ){
+      if( sqlite3ExprIsInteger(pE, &iCol, 0) ){
         if( iCol<=0 || iCol>pEList->nExpr ){
           resolveOutOfRangeError(pParse, "ORDER", i+1, pEList->nExpr, pE);
           return 1;
@@ -107835,7 +108880,7 @@ static int resolveOrderGroupBy(
         continue;
       }
     }
-    if( sqlite3ExprIsInteger(pE2, &iCol) ){
+    if( sqlite3ExprIsInteger(pE2, &iCol, 0) ){
       /* The ORDER BY term is an integer constant.  Again, set the column
       ** number so that sqlite3ResolveOrderGroupBy() will convert the
       ** order-by term to a copy of the result-set expression */
@@ -107926,7 +108971,11 @@ static int resolveSelectStep(Walker *pWalker, Select *p){
     ** moves the pOrderBy down to the sub-query. It will be moved back
     ** after the names have been resolved.  */
     if( p->selFlags & SF_Converted ){
-      Select *pSub = p->pSrc->a[0].pSelect;
+      Select *pSub;
+      assert( p->pSrc->a[0].fg.isSubquery );
+      assert( p->pSrc->a[0].u4.pSubq!=0 );
+      pSub = p->pSrc->a[0].u4.pSubq->pSelect;
+      assert( pSub!=0 );
       assert( p->pSrc->nSrc==1 && p->pOrderBy );
       assert( pSub->pPrior && pSub->pOrderBy==0 );
       pSub->pOrderBy = p->pOrderBy;
@@ -107938,12 +108987,16 @@ static int resolveSelectStep(Walker *pWalker, Select *p){
     if( pOuterNC ) pOuterNC->nNestedSelect++;
     for(i=0; i<p->pSrc->nSrc; i++){
       SrcItem *pItem = &p->pSrc->a[i];
-      if( pItem->pSelect && (pItem->pSelect->selFlags & SF_Resolved)==0 ){
+      assert( pItem->zName!=0
+              || pItem->fg.isSubquery );  /* Test of tag-20240424-1*/
+      if( pItem->fg.isSubquery
+       && (pItem->u4.pSubq->pSelect->selFlags & SF_Resolved)==0
+      ){
         int nRef = pOuterNC ? pOuterNC->nRef : 0;
         const char *zSavedContext = pParse->zAuthContext;
 
         if( pItem->zName ) pParse->zAuthContext = pItem->zName;
-        sqlite3ResolveSelectNames(pParse, pItem->pSelect, pOuterNC);
+        sqlite3ResolveSelectNames(pParse, pItem->u4.pSubq->pSelect, pOuterNC);
         pParse->zAuthContext = zSavedContext;
         if( pParse->nErr ) return WRC_Abort;
         assert( db->mallocFailed==0 );
@@ -108006,7 +109059,9 @@ static int resolveSelectStep(Walker *pWalker, Select *p){
       }
       if( sqlite3ResolveExprNames(&sNC, p->pHaving) ) return WRC_Abort;
     }
+    sNC.ncFlags |= NC_Where;
     if( sqlite3ResolveExprNames(&sNC, p->pWhere) ) return WRC_Abort;
+    sNC.ncFlags &= ~NC_Where;
 
     /* Resolve names in table-valued-function arguments */
     for(i=0; i<p->pSrc->nSrc; i++){
@@ -108043,7 +109098,10 @@ static int resolveSelectStep(Walker *pWalker, Select *p){
     ** These integers will be replaced by copies of the corresponding result
     ** set expressions by the call to resolveOrderGroupBy() below.  */
     if( p->selFlags & SF_Converted ){
-      Select *pSub = p->pSrc->a[0].pSelect;
+      Select *pSub;
+      assert( p->pSrc->a[0].fg.isSubquery );
+      pSub = p->pSrc->a[0].u4.pSubq->pSelect;
+      assert( pSub!=0 );
       p->pOrderBy = pSub->pOrderBy;
       pSub->pOrderBy = 0;
     }
@@ -108197,6 +109255,9 @@ SQLITE_PRIVATE int sqlite3ResolveExprNames(
 ** Resolve all names for all expression in an expression list.  This is
 ** just like sqlite3ResolveExprNames() except that it works for an expression
 ** list rather than a single expression.
+**
+** The return value is SQLITE_OK (0) for success or SQLITE_ERROR (1) for a
+** failure.
 */
 SQLITE_PRIVATE int sqlite3ResolveExprListNames(
   NameContext *pNC,       /* Namespace to resolve expressions in. */
@@ -108205,7 +109266,7 @@ SQLITE_PRIVATE int sqlite3ResolveExprListNames(
   int i;
   int savedHasAgg = 0;
   Walker w;
-  if( pList==0 ) return WRC_Continue;
+  if( pList==0 ) return SQLITE_OK;
   w.pParse = pNC->pParse;
   w.xExprCallback = resolveExprStep;
   w.xSelectCallback = resolveSelectStep;
@@ -108219,7 +109280,7 @@ SQLITE_PRIVATE int sqlite3ResolveExprListNames(
 #if SQLITE_MAX_EXPR_DEPTH>0
     w.pParse->nHeight += pExpr->nHeight;
     if( sqlite3ExprCheckHeight(w.pParse, w.pParse->nHeight) ){
-      return WRC_Abort;
+      return SQLITE_ERROR;
     }
 #endif
     sqlite3WalkExprNN(&w, pExpr);
@@ -108236,10 +109297,10 @@ SQLITE_PRIVATE int sqlite3ResolveExprListNames(
                           (NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg);
       pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg);
     }
-    if( w.pParse->nErr>0 ) return WRC_Abort;
+    if( w.pParse->nErr>0 ) return SQLITE_ERROR;
   }
   pNC->ncFlags |= savedHasAgg;
-  return WRC_Continue;
+  return SQLITE_OK;
 }
 
 /*
@@ -108307,7 +109368,7 @@ SQLITE_PRIVATE int sqlite3ResolveSelfReference(
   if( pTab ){
     sSrc.nSrc = 1;
     sSrc.a[0].zName = pTab->zName;
-    sSrc.a[0].pTab = pTab;
+    sSrc.a[0].pSTab = pTab;
     sSrc.a[0].iCursor = -1;
     if( pTab->pSchema!=pParse->db->aDb[1].pSchema ){
       /* Cause EP_FromDDL to be set on TK_FUNCTION nodes of non-TEMP
@@ -108412,7 +109473,9 @@ SQLITE_PRIVATE char sqlite3ExprAffinity(const Expr *pExpr){
       op = pExpr->op;
       continue;
     }
-    if( op!=TK_REGISTER || (op = pExpr->op2)==TK_REGISTER ) break;
+    if( op!=TK_REGISTER ) break;
+    op = pExpr->op2;
+    if( NEVER( op==TK_REGISTER ) ) break;
   }
   return pExpr->affExpr;
 }
@@ -108545,9 +109608,10 @@ SQLITE_PRIVATE Expr *sqlite3ExprSkipCollateAndLikely(Expr *pExpr){
       assert( pExpr->x.pList->nExpr>0 );
       assert( pExpr->op==TK_FUNCTION );
       pExpr = pExpr->x.pList->a[0].pExpr;
-    }else{
-      assert( pExpr->op==TK_COLLATE );
+    }else if( pExpr->op==TK_COLLATE ){
       pExpr = pExpr->pLeft;
+    }else{
+      break;
     }
   }
   return pExpr;
@@ -109241,11 +110305,12 @@ SQLITE_PRIVATE void sqlite3ExprSetErrorOffset(Expr *pExpr, int iOfst){
 ** appear to be quoted.  If the quotes were of the form "..." (double-quotes)
 ** then the EP_DblQuoted flag is set on the expression node.
 **
-** Special case:  If op==TK_INTEGER and pToken points to a string that
-** can be translated into a 32-bit integer, then the token is not
-** stored in u.zToken.  Instead, the integer values is written
-** into u.iValue and the EP_IntValue flag is set.  No extra storage
+** Special case (tag-20240227-a):  If op==TK_INTEGER and pToken points to
+** a string that can be translated into a 32-bit integer, then the token is
+** not stored in u.zToken.  Instead, the integer values is written
+** into u.iValue and the EP_IntValue flag is set. No extra storage
 ** is allocated to hold the integer text and the dequote flag is ignored.
+** See also tag-20240227-b.
 */
 SQLITE_PRIVATE Expr *sqlite3ExprAlloc(
   sqlite3 *db,            /* Handle for sqlite3DbMallocRawNN() */
@@ -109261,7 +110326,7 @@ SQLITE_PRIVATE Expr *sqlite3ExprAlloc(
   if( pToken ){
     if( op!=TK_INTEGER || pToken->z==0
           || sqlite3GetInt32(pToken->z, &iValue)==0 ){
-      nExtra = pToken->n+1;
+      nExtra = pToken->n+1;  /* tag-20240227-a */
       assert( iValue>=0 );
     }
   }
@@ -109693,6 +110758,7 @@ SQLITE_PRIVATE void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr, u32 n
 static SQLITE_NOINLINE void sqlite3ExprDeleteNN(sqlite3 *db, Expr *p){
   assert( p!=0 );
   assert( db!=0 );
+exprDeleteRestart:
   assert( !ExprUseUValue(p) || p->u.iValue>=0 );
   assert( !ExprUseYWin(p) || !ExprUseYSub(p) );
   assert( !ExprUseYWin(p) || p->y.pWin!=0 || db->mallocFailed );
@@ -109708,7 +110774,6 @@ static SQLITE_NOINLINE void sqlite3ExprDeleteNN(sqlite3 *db, Expr *p){
   if( !ExprHasProperty(p, (EP_TokenOnly|EP_Leaf)) ){
     /* The Expr.x union is never used at the same time as Expr.pRight */
     assert( (ExprUseXList(p) && p->x.pList==0) || p->pRight==0 );
-    if( p->pLeft && p->op!=TK_SELECT_COLUMN ) sqlite3ExprDeleteNN(db, p->pLeft);
     if( p->pRight ){
       assert( !ExprHasProperty(p, EP_WinFunc) );
       sqlite3ExprDeleteNN(db, p->pRight);
@@ -109723,6 +110788,19 @@ static SQLITE_NOINLINE void sqlite3ExprDeleteNN(sqlite3 *db, Expr *p){
       }
 #endif
     }
+    if( p->pLeft && p->op!=TK_SELECT_COLUMN ){
+      Expr *pLeft = p->pLeft;
+      if( !ExprHasProperty(p, EP_Static)
+       && !ExprHasProperty(pLeft, EP_Static)
+      ){
+        /* Avoid unnecessary recursion on unary operators */
+        sqlite3DbNNFreeNN(db, p);
+        p = pLeft;
+        goto exprDeleteRestart;
+      }else{
+        sqlite3ExprDeleteNN(db, pLeft);
+      }
+    }
   }
   if( !ExprHasProperty(p, EP_Static) ){
     sqlite3DbNNFreeNN(db, p);
@@ -109755,11 +110833,11 @@ SQLITE_PRIVATE void sqlite3ClearOnOrUsing(sqlite3 *db, OnOrUsing *p){
 **
 ** The pExpr might be deleted immediately on an OOM error.
 **
-** The deferred delete is (currently) implemented by adding the
-** pExpr to the pParse->pConstExpr list with a register number of 0.
+** Return 0 if the delete was successfully deferred.  Return non-zero
+** if the delete happened immediately because of an OOM.
 */
-SQLITE_PRIVATE void sqlite3ExprDeferredDelete(Parse *pParse, Expr *pExpr){
-  sqlite3ParserAddCleanup(pParse, sqlite3ExprDeleteGeneric, pExpr);
+SQLITE_PRIVATE int sqlite3ExprDeferredDelete(Parse *pParse, Expr *pExpr){
+  return 0==sqlite3ParserAddCleanup(pParse, sqlite3ExprDeleteGeneric, pExpr);
 }
 
 /* Invoke sqlite3RenameExprUnmap() and sqlite3ExprDelete() on the
@@ -110187,30 +111265,46 @@ SQLITE_PRIVATE SrcList *sqlite3SrcListDup(sqlite3 *db, const SrcList *p, int fla
     SrcItem *pNewItem = &pNew->a[i];
     const SrcItem *pOldItem = &p->a[i];
     Table *pTab;
-    pNewItem->pSchema = pOldItem->pSchema;
-    pNewItem->zDatabase = sqlite3DbStrDup(db, pOldItem->zDatabase);
+    pNewItem->fg = pOldItem->fg;
+    if( pOldItem->fg.isSubquery ){
+      Subquery *pNewSubq = sqlite3DbMallocRaw(db, sizeof(Subquery));
+      if( pNewSubq==0 ){
+        assert( db->mallocFailed );
+        pNewItem->fg.isSubquery = 0;
+      }else{
+        memcpy(pNewSubq, pOldItem->u4.pSubq, sizeof(*pNewSubq));
+        pNewSubq->pSelect = sqlite3SelectDup(db, pNewSubq->pSelect, flags);
+        if( pNewSubq->pSelect==0 ){
+          sqlite3DbFree(db, pNewSubq);
+          pNewSubq = 0;
+          pNewItem->fg.isSubquery = 0;
+        }
+      }
+      pNewItem->u4.pSubq = pNewSubq;
+    }else if( pOldItem->fg.fixedSchema ){
+      pNewItem->u4.pSchema = pOldItem->u4.pSchema;
+    }else{
+      pNewItem->u4.zDatabase = sqlite3DbStrDup(db, pOldItem->u4.zDatabase);
+    }
     pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
     pNewItem->zAlias = sqlite3DbStrDup(db, pOldItem->zAlias);
-    pNewItem->fg = pOldItem->fg;
     pNewItem->iCursor = pOldItem->iCursor;
-    pNewItem->addrFillSub = pOldItem->addrFillSub;
-    pNewItem->regReturn = pOldItem->regReturn;
     if( pNewItem->fg.isIndexedBy ){
       pNewItem->u1.zIndexedBy = sqlite3DbStrDup(db, pOldItem->u1.zIndexedBy);
+    }else if( pNewItem->fg.isTabFunc ){
+      pNewItem->u1.pFuncArg =
+          sqlite3ExprListDup(db, pOldItem->u1.pFuncArg, flags);
+    }else{
+      pNewItem->u1.nRow = pOldItem->u1.nRow;
     }
     pNewItem->u2 = pOldItem->u2;
     if( pNewItem->fg.isCte ){
       pNewItem->u2.pCteUse->nUse++;
     }
-    if( pNewItem->fg.isTabFunc ){
-      pNewItem->u1.pFuncArg =
-          sqlite3ExprListDup(db, pOldItem->u1.pFuncArg, flags);
-    }
-    pTab = pNewItem->pTab = pOldItem->pTab;
+    pTab = pNewItem->pSTab = pOldItem->pSTab;
     if( pTab ){
       pTab->nTabRef++;
     }
-    pNewItem->pSelect = sqlite3SelectDup(db, pOldItem->pSelect, flags);
     if( pOldItem->fg.isUsing ){
       assert( pNewItem->fg.isUsing );
       pNewItem->u3.pUsing = sqlite3IdListDup(db, pOldItem->u3.pUsing);
@@ -110284,7 +111378,6 @@ SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3 *db, const Select *pDup, int fla
     pp = &pNew->pPrior;
     pNext = pNew;
   }
-
   return pRet;
 }
 #else
@@ -110671,6 +111764,54 @@ SQLITE_PRIVATE Expr *sqlite3ExprSimplifiedAndOr(Expr *pExpr){
   return pExpr;
 }
 
+/*
+** pExpr is a TK_FUNCTION node.  Try to determine whether or not the
+** function is a constant function.  A function is constant if all of
+** the following are true:
+**
+**    (1)  It is a scalar function (not an aggregate or window function)
+**    (2)  It has either the SQLITE_FUNC_CONSTANT or SQLITE_FUNC_SLOCHNG
+**         property.
+**    (3)  All of its arguments are constants
+**
+** This routine sets pWalker->eCode to 0 if pExpr is not a constant.
+** It makes no changes to pWalker->eCode if pExpr is constant.  In
+** every case, it returns WRC_Abort.
+**
+** Called as a service subroutine from exprNodeIsConstant().
+*/
+static SQLITE_NOINLINE int exprNodeIsConstantFunction(
+  Walker *pWalker,
+  Expr *pExpr
+){
+  int n;             /* Number of arguments */
+  ExprList *pList;   /* List of arguments */
+  FuncDef *pDef;     /* The function */
+  sqlite3 *db;       /* The database */
+
+  assert( pExpr->op==TK_FUNCTION );
+  if( ExprHasProperty(pExpr, EP_TokenOnly)
+   || (pList = pExpr->x.pList)==0
+  ){;
+    n = 0;
+  }else{
+    n = pList->nExpr;
+    sqlite3WalkExprList(pWalker, pList);
+    if( pWalker->eCode==0 ) return WRC_Abort;
+  }
+  db = pWalker->pParse->db;
+  pDef = sqlite3FindFunction(db, pExpr->u.zToken, n, ENC(db), 0);
+  if( pDef==0
+   || pDef->xFinalize!=0
+   || (pDef->funcFlags & (SQLITE_FUNC_CONSTANT|SQLITE_FUNC_SLOCHNG))==0
+   || ExprHasProperty(pExpr, EP_WinFunc)
+  ){
+    pWalker->eCode = 0;
+    return WRC_Abort;
+  }
+  return WRC_Prune;
+}
+
 
 /*
 ** These routines are Walker callbacks used to check expressions to
@@ -110699,6 +111840,7 @@ SQLITE_PRIVATE Expr *sqlite3ExprSimplifiedAndOr(Expr *pExpr){
 ** malformed schema error.
 */
 static int exprNodeIsConstant(Walker *pWalker, Expr *pExpr){
+  assert( pWalker->eCode>0 );
 
   /* If pWalker->eCode is 2 then any term of the expression that comes from
   ** the ON or USING clauses of an outer join disqualifies the expression
@@ -110718,6 +111860,8 @@ static int exprNodeIsConstant(Walker *pWalker, Expr *pExpr){
       ){
         if( pWalker->eCode==5 ) ExprSetProperty(pExpr, EP_FromDDL);
         return WRC_Continue;
+      }else if( pWalker->pParse ){
+        return exprNodeIsConstantFunction(pWalker, pExpr);
       }else{
         pWalker->eCode = 0;
         return WRC_Abort;
@@ -110746,9 +111890,11 @@ static int exprNodeIsConstant(Walker *pWalker, Expr *pExpr){
     case TK_IF_NULL_ROW:
     case TK_REGISTER:
     case TK_DOT:
+    case TK_RAISE:
       testcase( pExpr->op==TK_REGISTER );
       testcase( pExpr->op==TK_IF_NULL_ROW );
       testcase( pExpr->op==TK_DOT );
+      testcase( pExpr->op==TK_RAISE );
       pWalker->eCode = 0;
       return WRC_Abort;
     case TK_VARIABLE:
@@ -110770,15 +111916,15 @@ static int exprNodeIsConstant(Walker *pWalker, Expr *pExpr){
       return WRC_Continue;
   }
 }
-static int exprIsConst(Expr *p, int initFlag, int iCur){
+static int exprIsConst(Parse *pParse, Expr *p, int initFlag){
   Walker w;
   w.eCode = initFlag;
+  w.pParse = pParse;
   w.xExprCallback = exprNodeIsConstant;
   w.xSelectCallback = sqlite3SelectWalkFail;
 #ifdef SQLITE_DEBUG
   w.xSelectCallback2 = sqlite3SelectWalkAssert2;
 #endif
-  w.u.iCur = iCur;
   sqlite3WalkExpr(&w, p);
   return w.eCode;
 }
@@ -110790,9 +111936,15 @@ static int exprIsConst(Expr *p, int initFlag, int iCur){
 ** For the purposes of this function, a double-quoted string (ex: "abc")
 ** is considered a variable but a single-quoted string (ex: 'abc') is
 ** a constant.
+**
+** The pParse parameter may be NULL.  But if it is NULL, there is no way
+** to determine if function calls are constant or not, and hence all
+** function calls will be considered to be non-constant.  If pParse is
+** not NULL, then a function call might be constant, depending on the
+** function and on its parameters.
 */
-SQLITE_PRIVATE int sqlite3ExprIsConstant(Expr *p){
-  return exprIsConst(p, 1, 0);
+SQLITE_PRIVATE int sqlite3ExprIsConstant(Parse *pParse, Expr *p){
+  return exprIsConst(pParse, p, 1);
 }
 
 /*
@@ -110808,8 +111960,24 @@ SQLITE_PRIVATE int sqlite3ExprIsConstant(Expr *p){
 ** can be added to the pParse->pConstExpr list and evaluated once when
 ** the prepared statement starts up.  See sqlite3ExprCodeRunJustOnce().
 */
-SQLITE_PRIVATE int sqlite3ExprIsConstantNotJoin(Expr *p){
-  return exprIsConst(p, 2, 0);
+static int sqlite3ExprIsConstantNotJoin(Parse *pParse, Expr *p){
+  return exprIsConst(pParse, p, 2);
+}
+
+/*
+** This routine examines sub-SELECT statements as an expression is being
+** walked as part of sqlite3ExprIsTableConstant().  Sub-SELECTs are considered
+** constant as long as they are uncorrelated - meaning that they do not
+** contain any terms from outer contexts.
+*/
+static int exprSelectWalkTableConstant(Walker *pWalker, Select *pSelect){
+  assert( pSelect!=0 );
+  assert( pWalker->eCode==3 || pWalker->eCode==0 );
+  if( (pSelect->selFlags & SF_Correlated)!=0 ){
+    pWalker->eCode = 0;
+    return WRC_Abort;
+  }
+  return WRC_Prune;
 }
 
 /*
@@ -110817,9 +111985,26 @@ SQLITE_PRIVATE int sqlite3ExprIsConstantNotJoin(Expr *p){
 ** for any single row of the table with cursor iCur.  In other words, the
 ** expression must not refer to any non-deterministic function nor any
 ** table other than iCur.
+**
+** Consider uncorrelated subqueries to be constants if the bAllowSubq
+** parameter is true.
 */
-SQLITE_PRIVATE int sqlite3ExprIsTableConstant(Expr *p, int iCur){
-  return exprIsConst(p, 3, iCur);
+static int sqlite3ExprIsTableConstant(Expr *p, int iCur, int bAllowSubq){
+  Walker w;
+  w.eCode = 3;
+  w.pParse = 0;
+  w.xExprCallback = exprNodeIsConstant;
+  if( bAllowSubq ){
+    w.xSelectCallback = exprSelectWalkTableConstant;
+  }else{
+    w.xSelectCallback = sqlite3SelectWalkFail;
+#ifdef SQLITE_DEBUG
+    w.xSelectCallback2 = sqlite3SelectWalkAssert2;
+#endif
+  }
+  w.u.iCur = iCur;
+  sqlite3WalkExpr(&w, p);
+  return w.eCode;
 }
 
 /*
@@ -110837,7 +112022,10 @@ SQLITE_PRIVATE int sqlite3ExprIsTableConstant(Expr *p, int iCur){
 **
 **   (1)  pExpr cannot refer to any table other than pSrc->iCursor.
 **
-**   (2)  pExpr cannot use subqueries or non-deterministic functions.
+**   (2a) pExpr cannot use subqueries unless the bAllowSubq parameter is
+**        true and the subquery is non-correlated
+**
+**   (2b) pExpr cannot use non-deterministic functions.
 **
 **   (3)  pSrc cannot be part of the left operand for a RIGHT JOIN.
 **        (Is there some way to relax this constraint?)
@@ -110866,7 +112054,8 @@ SQLITE_PRIVATE int sqlite3ExprIsTableConstant(Expr *p, int iCur){
 SQLITE_PRIVATE int sqlite3ExprIsSingleTableConstraint(
   Expr *pExpr,                 /* The constraint */
   const SrcList *pSrcList,     /* Complete FROM clause */
-  int iSrc                     /* Which element of pSrcList to use */
+  int iSrc,                    /* Which element of pSrcList to use */
+  int bAllowSubq               /* Allow non-correlated subqueries */
 ){
   const SrcItem *pSrc = &pSrcList->a[iSrc];
   if( pSrc->fg.jointype & JT_LTORJ ){
@@ -110891,7 +112080,8 @@ SQLITE_PRIVATE int sqlite3ExprIsSingleTableConstraint(
       }
     }
   }
-  return sqlite3ExprIsTableConstant(pExpr, pSrc->iCursor); /* rules (1), (2) */
+  /* Rules (1), (2a), and (2b) handled by the following: */
+  return sqlite3ExprIsTableConstant(pExpr, pSrc->iCursor, bAllowSubq);
 }
 
 
@@ -110976,7 +112166,7 @@ SQLITE_PRIVATE int sqlite3ExprIsConstantOrGroupBy(Parse *pParse, Expr *p, ExprLi
 */
 SQLITE_PRIVATE int sqlite3ExprIsConstantOrFunction(Expr *p, u8 isInit){
   assert( isInit==0 || isInit==1 );
-  return exprIsConst(p, 4+isInit, 0);
+  return exprIsConst(0, p, 4+isInit);
 }
 
 #ifdef SQLITE_ENABLE_CURSOR_HINTS
@@ -111002,8 +112192,12 @@ SQLITE_PRIVATE int sqlite3ExprContainsSubquery(Expr *p){
 ** to fit in a 32-bit integer, return 1 and put the value of the integer
 ** in *pValue.  If the expression is not an integer or if it is too big
 ** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged.
+**
+** If the pParse pointer is provided, then allow the expression p to be
+** a parameter (TK_VARIABLE) that is bound to an integer.
+** But if pParse is NULL, then p must be a pure integer literal.
 */
-SQLITE_PRIVATE int sqlite3ExprIsInteger(const Expr *p, int *pValue){
+SQLITE_PRIVATE int sqlite3ExprIsInteger(const Expr *p, int *pValue, Parse *pParse){
   int rc = 0;
   if( NEVER(p==0) ) return 0;  /* Used to only happen following on OOM */
 
@@ -111018,18 +112212,38 @@ SQLITE_PRIVATE int sqlite3ExprIsInteger(const Expr *p, int *pValue){
   }
   switch( p->op ){
     case TK_UPLUS: {
-      rc = sqlite3ExprIsInteger(p->pLeft, pValue);
+      rc = sqlite3ExprIsInteger(p->pLeft, pValue, 0);
       break;
     }
     case TK_UMINUS: {
       int v = 0;
-      if( sqlite3ExprIsInteger(p->pLeft, &v) ){
+      if( sqlite3ExprIsInteger(p->pLeft, &v, 0) ){
         assert( ((unsigned int)v)!=0x80000000 );
         *pValue = -v;
         rc = 1;
       }
       break;
     }
+    case TK_VARIABLE: {
+      sqlite3_value *pVal;
+      if( pParse==0 ) break;
+      if( NEVER(pParse->pVdbe==0) ) break;
+      if( (pParse->db->flags & SQLITE_EnableQPSG)!=0 ) break;
+      sqlite3VdbeSetVarmask(pParse->pVdbe, p->iColumn);
+      pVal = sqlite3VdbeGetBoundValue(pParse->pReprepare, p->iColumn,
+                                      SQLITE_AFF_BLOB);
+      if( pVal ){
+        if( sqlite3_value_type(pVal)==SQLITE_INTEGER ){
+          sqlite3_int64 vv = sqlite3_value_int64(pVal);
+          if( vv == (vv & 0x7fffffff) ){ /* non-negative numbers only */
+            *pValue = (int)vv;
+            rc = 1;
+          }
+        }
+        sqlite3ValueFree(pVal);
+      }
+      break;
+    }
     default: break;
   }
   return rc;
@@ -111066,9 +112280,12 @@ SQLITE_PRIVATE int sqlite3ExprCanBeNull(const Expr *p){
       return 0;
     case TK_COLUMN:
       assert( ExprUseYTab(p) );
-      return ExprHasProperty(p, EP_CanBeNull) ||
-             NEVER(p->y.pTab==0) ||  /* Reference to column of index on expr */
-             (p->iColumn>=0
+      return ExprHasProperty(p, EP_CanBeNull)
+          || NEVER(p->y.pTab==0) /* Reference to column of index on expr */
+#ifdef SQLITE_ALLOW_ROWID_IN_VIEW
+          || (p->iColumn==XN_ROWID && IsView(p->y.pTab))
+#endif
+          || (p->iColumn>=0
               && p->y.pTab->aCol!=0 /* Possible due to prior error */
               && ALWAYS(p->iColumn<p->y.pTab->nCol)
               && p->y.pTab->aCol[p->iColumn].notNull==0);
@@ -111180,8 +112397,8 @@ static Select *isCandidateForInOpt(const Expr *pX){
   pSrc = p->pSrc;
   assert( pSrc!=0 );
   if( pSrc->nSrc!=1 ) return 0;          /* Single term in FROM clause */
-  if( pSrc->a[0].pSelect ) return 0;     /* FROM is not a subquery or view */
-  pTab = pSrc->a[0].pTab;
+  if( pSrc->a[0].fg.isSubquery) return 0;/* FROM is not a subquery or view */
+  pTab = pSrc->a[0].pSTab;
   assert( pTab!=0 );
   assert( !IsView(pTab)  );              /* FROM clause is not a view */
   if( IsVirtual(pTab) ) return 0;        /* FROM clause not a virtual table */
@@ -111221,13 +112438,13 @@ static void sqlite3SetHasNullFlag(Vdbe *v, int iCur, int regHasNull){
 ** The argument is an IN operator with a list (not a subquery) on the
 ** right-hand side.  Return TRUE if that list is constant.
 */
-static int sqlite3InRhsIsConstant(Expr *pIn){
+static int sqlite3InRhsIsConstant(Parse *pParse, Expr *pIn){
   Expr *pLHS;
   int res;
   assert( !ExprHasProperty(pIn, EP_xIsSelect) );
   pLHS = pIn->pLeft;
   pIn->pLeft = 0;
-  res = sqlite3ExprIsConstant(pIn);
+  res = sqlite3ExprIsConstant(pParse, pIn);
   pIn->pLeft = pLHS;
   return res;
 }
@@ -111364,7 +112581,7 @@ SQLITE_PRIVATE int sqlite3FindInIndex(
     assert( p->pEList!=0 );             /* Because of isCandidateForInOpt(p) */
     assert( p->pEList->a[0].pExpr!=0 ); /* Because of isCandidateForInOpt(p) */
     assert( p->pSrc!=0 );               /* Because of isCandidateForInOpt(p) */
-    pTab = p->pSrc->a[0].pTab;
+    pTab = p->pSrc->a[0].pSTab;
 
     /* Code an OP_Transaction and OP_TableLock for <table>. */
     iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
@@ -111496,7 +112713,7 @@ SQLITE_PRIVATE int sqlite3FindInIndex(
   if( eType==0
    && (inFlags & IN_INDEX_NOOP_OK)
    && ExprUseXList(pX)
-   && (!sqlite3InRhsIsConstant(pX) || pX->x.pList->nExpr<=2)
+   && (!sqlite3InRhsIsConstant(pParse,pX) || pX->x.pList->nExpr<=2)
   ){
     pParse->nTab--;  /* Back out the allocation of the unused cursor */
     iTab = -1;       /* Cursor is not allocated */
@@ -111604,6 +112821,49 @@ SQLITE_PRIVATE void sqlite3VectorErrorMsg(Parse *pParse, Expr *pExpr){
   }
 }
 
+#ifndef SQLITE_OMIT_SUBQUERY
+/*
+** Scan all previously generated bytecode looking for an OP_BeginSubrtn
+** that is compatible with pExpr.  If found, add the y.sub values
+** to pExpr and return true.  If not found, return false.
+*/
+static int findCompatibleInRhsSubrtn(
+  Parse *pParse,          /* Parsing context */
+  Expr *pExpr,            /* IN operator with RHS that we want to reuse */
+  SubrtnSig *pNewSig      /* Signature for the IN operator */
+){
+  VdbeOp *pOp, *pEnd;
+  SubrtnSig *pSig;
+  Vdbe *v;
+
+  if( pNewSig==0 ) return 0;
+  if( (pParse->mSubrtnSig & (1<<(pNewSig->selId&7)))==0 ) return 0;
+  assert( pExpr->op==TK_IN );
+  assert( !ExprUseYSub(pExpr) );
+  assert( ExprUseXSelect(pExpr) );
+  assert( pExpr->x.pSelect!=0 );
+  assert( (pExpr->x.pSelect->selFlags & SF_All)==0 );
+  v = pParse->pVdbe;
+  assert( v!=0 );
+  pOp = sqlite3VdbeGetOp(v, 1);
+  pEnd = sqlite3VdbeGetLastOp(v);
+  for(; pOp<pEnd; pOp++){
+    if( pOp->p4type!=P4_SUBRTNSIG ) continue;
+    assert( pOp->opcode==OP_BeginSubrtn );
+    pSig = pOp->p4.pSubrtnSig;
+    assert( pSig!=0 );
+    if( pNewSig->selId!=pSig->selId ) continue;
+    if( strcmp(pNewSig->zAff,pSig->zAff)!=0 ) continue;
+    pExpr->y.sub.iAddr = pSig->iAddr;
+    pExpr->y.sub.regReturn = pSig->regReturn;
+    pExpr->iTable = pSig->iTable;
+    ExprSetProperty(pExpr, EP_Subrtn);
+    return 1;
+  }
+  return 0;
+}
+#endif /* SQLITE_OMIT_SUBQUERY */
+
 #ifndef SQLITE_OMIT_SUBQUERY
 /*
 ** Generate code that will construct an ephemeral table containing all terms
@@ -111653,11 +112913,28 @@ SQLITE_PRIVATE void sqlite3CodeRhsOfIN(
   ** and reuse it many names.
   */
   if( !ExprHasProperty(pExpr, EP_VarSelect) && pParse->iSelfTab==0 ){
-    /* Reuse of the RHS is allowed */
-    /* If this routine has already been coded, but the previous code
-    ** might not have been invoked yet, so invoke it now as a subroutine.
+    /* Reuse of the RHS is allowed
+    **
+    ** Compute a signature for the RHS of the IN operator to facility
+    ** finding and reusing prior instances of the same IN operator.
     */
-    if( ExprHasProperty(pExpr, EP_Subrtn) ){
+    SubrtnSig *pSig = 0;
+    assert( !ExprUseXSelect(pExpr) || pExpr->x.pSelect!=0 );
+    if( ExprUseXSelect(pExpr) && (pExpr->x.pSelect->selFlags & SF_All)==0 ){
+      pSig = sqlite3DbMallocRawNN(pParse->db, sizeof(pSig[0]));
+      if( pSig ){
+        pSig->selId = pExpr->x.pSelect->selId;
+        pSig->zAff = exprINAffinity(pParse, pExpr);
+      }
+    }
+
+    /* Check to see if there is a prior materialization of the RHS of
+    ** this IN operator.  If there is, then make use of that prior
+    ** materialization rather than recomputing it.
+    */
+    if( ExprHasProperty(pExpr, EP_Subrtn)
+     || findCompatibleInRhsSubrtn(pParse, pExpr, pSig)
+    ){
       addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
       if( ExprUseXSelect(pExpr) ){
         ExplainQueryPlan((pParse, 0, "REUSE LIST SUBQUERY %d",
@@ -111669,6 +112946,10 @@ SQLITE_PRIVATE void sqlite3CodeRhsOfIN(
       assert( iTab!=pExpr->iTable );
       sqlite3VdbeAddOp2(v, OP_OpenDup, iTab, pExpr->iTable);
       sqlite3VdbeJumpHere(v, addrOnce);
+      if( pSig ){
+        sqlite3DbFree(pParse->db, pSig->zAff);
+        sqlite3DbFree(pParse->db, pSig);
+      }
       return;
     }
 
@@ -111679,7 +112960,13 @@ SQLITE_PRIVATE void sqlite3CodeRhsOfIN(
     pExpr->y.sub.regReturn = ++pParse->nMem;
     pExpr->y.sub.iAddr =
       sqlite3VdbeAddOp2(v, OP_BeginSubrtn, 0, pExpr->y.sub.regReturn) + 1;
-
+    if( pSig ){
+      pSig->iAddr = pExpr->y.sub.iAddr;
+      pSig->regReturn = pExpr->y.sub.regReturn;
+      pSig->iTable = iTab;
+      pParse->mSubrtnSig = 1 << (pSig->selId&7);
+      sqlite3VdbeChangeP4(v, -1, (const char*)pSig, P4_SUBRTNSIG);
+    }
     addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
   }
 
@@ -111720,15 +113007,30 @@ SQLITE_PRIVATE void sqlite3CodeRhsOfIN(
       SelectDest dest;
       int i;
       int rc;
+      int addrBloom = 0;
       sqlite3SelectDestInit(&dest, SRT_Set, iTab);
       dest.zAffSdst = exprINAffinity(pParse, pExpr);
       pSelect->iLimit = 0;
+      if( addrOnce && OptimizationEnabled(pParse->db, SQLITE_BloomFilter) ){
+        int regBloom = ++pParse->nMem;
+        addrBloom = sqlite3VdbeAddOp2(v, OP_Blob, 10000, regBloom);
+        VdbeComment((v, "Bloom filter"));
+        dest.iSDParm2 = regBloom;
+      }
       testcase( pSelect->selFlags & SF_Distinct );
       testcase( pKeyInfo==0 ); /* Caused by OOM in sqlite3KeyInfoAlloc() */
       pCopy = sqlite3SelectDup(pParse->db, pSelect, 0);
       rc = pParse->db->mallocFailed ? 1 :sqlite3Select(pParse, pCopy, &dest);
       sqlite3SelectDelete(pParse->db, pCopy);
       sqlite3DbFree(pParse->db, dest.zAffSdst);
+      if( addrBloom ){
+        sqlite3VdbeGetOp(v, addrOnce)->p3 = dest.iSDParm2;
+        if( dest.iSDParm2==0 ){
+          sqlite3VdbeChangeToNoop(v, addrBloom);
+        }else{
+          sqlite3VdbeGetOp(v, addrOnce)->p3 = dest.iSDParm2;
+        }
+      }
       if( rc ){
         sqlite3KeyInfoUnref(pKeyInfo);
         return;
@@ -111779,7 +113081,7 @@ SQLITE_PRIVATE void sqlite3CodeRhsOfIN(
       ** this code only executes once.  Because for a non-constant
       ** expression we need to rerun this code each time.
       */
-      if( addrOnce && !sqlite3ExprIsConstant(pE2) ){
+      if( addrOnce && !sqlite3ExprIsConstant(pParse, pE2) ){
         sqlite3VdbeChangeToNoop(v, addrOnce-1);
         sqlite3VdbeChangeToNoop(v, addrOnce);
         ExprClearProperty(pExpr, EP_Subrtn);
@@ -112026,9 +113328,7 @@ static void sqlite3ExprCodeIN(
   if( sqlite3ExprCheckIN(pParse, pExpr) ) return;
   zAff = exprINAffinity(pParse, pExpr);
   nVector = sqlite3ExprVectorSize(pExpr->pLeft);
-  aiMap = (int*)sqlite3DbMallocZero(
-      pParse->db, nVector*(sizeof(int) + sizeof(char)) + 1
-  );
+  aiMap = (int*)sqlite3DbMallocZero(pParse->db, nVector*sizeof(int));
   if( pParse->db->mallocFailed ) goto sqlite3ExprCodeIN_oom_error;
 
   /* Attempt to compute the RHS. After this step, if anything other than
@@ -112171,6 +113471,15 @@ static void sqlite3ExprCodeIN(
     sqlite3VdbeAddOp4(v, OP_Affinity, rLhs, nVector, 0, zAff, nVector);
     if( destIfFalse==destIfNull ){
       /* Combine Step 3 and Step 5 into a single opcode */
+      if( ExprHasProperty(pExpr, EP_Subrtn) ){
+        const VdbeOp *pOp = sqlite3VdbeGetOp(v, pExpr->y.sub.iAddr);
+        assert( pOp->opcode==OP_Once || pParse->nErr );
+        if( pOp->opcode==OP_Once && pOp->p3>0 ){
+          assert( OptimizationEnabled(pParse->db, SQLITE_BloomFilter) );
+          sqlite3VdbeAddOp4Int(v, OP_Filter, pOp->p3, destIfFalse,
+                               rLhs, nVector); VdbeCoverage(v);
+        }
+      }
       sqlite3VdbeAddOp4Int(v, OP_NotFound, iTab, destIfFalse,
                            rLhs, nVector); VdbeCoverage(v);
       goto sqlite3ExprCodeIN_finished;
@@ -112453,13 +113762,17 @@ SQLITE_PRIVATE void sqlite3ExprCodeMove(Parse *pParse, int iFrom, int iTo, int n
 ** register iReg.  The caller must ensure that iReg already contains
 ** the correct value for the expression.
 */
-static void exprToRegister(Expr *pExpr, int iReg){
+SQLITE_PRIVATE void sqlite3ExprToRegister(Expr *pExpr, int iReg){
   Expr *p = sqlite3ExprSkipCollateAndLikely(pExpr);
   if( NEVER(p==0) ) return;
-  p->op2 = p->op;
-  p->op = TK_REGISTER;
-  p->iTable = iReg;
-  ExprClearProperty(p, EP_Skip);
+  if( p->op==TK_REGISTER ){
+    assert( p->iTable==iReg );
+  }else{
+    p->op2 = p->op;
+    p->op = TK_REGISTER;
+    p->iTable = iReg;
+    ExprClearProperty(p, EP_Skip);
+  }
 }
 
 /*
@@ -112629,6 +113942,59 @@ static int exprCodeInlineFunction(
   return target;
 }
 
+/*
+** Expression Node callback for sqlite3ExprCanReturnSubtype().
+**
+** Only a function call is able to return a subtype.  So if the node
+** is not a function call, return WRC_Prune immediately.
+**
+** A function call is able to return a subtype if it has the
+** SQLITE_RESULT_SUBTYPE property.
+**
+** Assume that every function is able to pass-through a subtype from
+** one of its argument (using sqlite3_result_value()).  Most functions
+** are not this way, but we don't have a mechanism to distinguish those
+** that are from those that are not, so assume they all work this way.
+** That means that if one of its arguments is another function and that
+** other function is able to return a subtype, then this function is
+** able to return a subtype.
+*/
+static int exprNodeCanReturnSubtype(Walker *pWalker, Expr *pExpr){
+  int n;
+  FuncDef *pDef;
+  sqlite3 *db;
+  if( pExpr->op!=TK_FUNCTION ){
+    return WRC_Prune;
+  }
+  assert( ExprUseXList(pExpr) );
+  db = pWalker->pParse->db;
+  n = ALWAYS(pExpr->x.pList) ? pExpr->x.pList->nExpr : 0;
+  pDef = sqlite3FindFunction(db, pExpr->u.zToken, n, ENC(db), 0);
+  if( NEVER(pDef==0) || (pDef->funcFlags & SQLITE_RESULT_SUBTYPE)!=0 ){
+    pWalker->eCode = 1;
+    return WRC_Prune;
+  }
+  return WRC_Continue;
+}
+
+/*
+** Return TRUE if expression pExpr is able to return a subtype.
+**
+** A TRUE return does not guarantee that a subtype will be returned.
+** It only indicates that a subtype return is possible.  False positives
+** are acceptable as they only disable an optimization.  False negatives,
+** on the other hand, can lead to incorrect answers.
+*/
+static int sqlite3ExprCanReturnSubtype(Parse *pParse, Expr *pExpr){
+  Walker w;
+  memset(&w, 0, sizeof(w));
+  w.pParse = pParse;
+  w.xExprCallback = exprNodeCanReturnSubtype;
+  sqlite3WalkExpr(&w, pExpr);
+  return w.eCode;
+}
+
+
 /*
 ** Check to see if pExpr is one of the indexed expressions on pParse->pIdxEpr.
 ** If it is, then resolve the expression by reading from the index and
@@ -112661,6 +114027,17 @@ static SQLITE_NOINLINE int sqlite3IndexedExprLookup(
       continue;
     }
 
+
+    /* Functions that might set a subtype should not be replaced by the
+    ** value taken from an expression index if they are themselves an
+    ** argument to another scalar function or aggregate.
+    ** https://sqlite.org/forum/forumpost/68d284c86b082c3e */
+    if( ExprHasProperty(pExpr, EP_SubtArg)
+     && sqlite3ExprCanReturnSubtype(pParse, pExpr)
+    ){
+      continue;
+    }
+
     v = pParse->pVdbe;
     assert( v!=0 );
     if( p->bMaybeNullRow ){
@@ -112943,12 +114320,6 @@ expr_code_doover:
       assert( pExpr->u.zToken!=0 );
       assert( pExpr->u.zToken[0]!=0 );
       sqlite3VdbeAddOp2(v, OP_Variable, pExpr->iColumn, target);
-      if( pExpr->u.zToken[1]!=0 ){
-        const char *z = sqlite3VListNumToName(pParse->pVList, pExpr->iColumn);
-        assert( pExpr->u.zToken[0]=='?' || (z && !strcmp(pExpr->u.zToken, z)) );
-        pParse->pVList[0] = 0; /* Indicate VList may no longer be enlarged */
-        sqlite3VdbeAppendP4(v, (char*)z, P4_STATIC);
-      }
       return target;
     }
     case TK_REGISTER: {
@@ -113122,7 +114493,9 @@ expr_code_doover:
       }
 #endif
 
-      if( ConstFactorOk(pParse) && sqlite3ExprIsConstantNotJoin(pExpr) ){
+      if( ConstFactorOk(pParse)
+       && sqlite3ExprIsConstantNotJoin(pParse,pExpr)
+      ){
         /* SQL functions can be expensive. So try to avoid running them
         ** multiple times if we know they always give the same result */
         return sqlite3ExprCodeRunJustOnce(pParse, pExpr, -1);
@@ -113153,7 +114526,7 @@ expr_code_doover:
       }
 
       for(i=0; i<nFarg; i++){
-        if( i<32 && sqlite3ExprIsConstant(pFarg->a[i].pExpr) ){
+        if( i<32 && sqlite3ExprIsConstant(pParse, pFarg->a[i].pExpr) ){
           testcase( i==31 );
           constMask |= MASKBIT32(i);
         }
@@ -113295,8 +114668,9 @@ expr_code_doover:
       if( !ExprHasProperty(pExpr, EP_Collate) ){
         /* A TK_COLLATE Expr node without the EP_Collate tag is a so-called
         ** "SOFT-COLLATE" that is added to constraints that are pushed down
-        ** from outer queries into sub-queries by the push-down optimization.
-        ** Clear subtypes as subtypes may not cross a subquery boundary.
+        ** from outer queries into sub-queries by the WHERE-clause push-down
+        ** optimization. Clear subtypes as subtypes may not cross a subquery
+        ** boundary.
         */
         assert( pExpr->pLeft );
         sqlite3ExprCode(pParse, pExpr->pLeft, target);
@@ -113465,7 +114839,7 @@ expr_code_doover:
           break;
         }
         testcase( pX->op==TK_COLUMN );
-        exprToRegister(pDel, exprCodeVector(pParse, pDel, &regFree1));
+        sqlite3ExprToRegister(pDel, exprCodeVector(pParse, pDel, &regFree1));
         testcase( regFree1==0 );
         memset(&opCompare, 0, sizeof(opCompare));
         opCompare.op = TK_EQ;
@@ -113519,15 +114893,14 @@ expr_code_doover:
       }
       assert( !ExprHasProperty(pExpr, EP_IntValue) );
       if( pExpr->affExpr==OE_Ignore ){
-        sqlite3VdbeAddOp4(
-            v, OP_Halt, SQLITE_OK, OE_Ignore, 0, pExpr->u.zToken,0);
+        sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_OK, OE_Ignore);
         VdbeCoverage(v);
       }else{
-        sqlite3HaltConstraint(pParse,
+        r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
+        sqlite3VdbeAddOp3(v, OP_Halt,
              pParse->pTriggerTab ? SQLITE_CONSTRAINT_TRIGGER : SQLITE_ERROR,
-             pExpr->affExpr, pExpr->u.zToken, 0, 0);
+             pExpr->affExpr, r1);
       }
-
       break;
     }
 #endif
@@ -113620,7 +114993,7 @@ SQLITE_PRIVATE int sqlite3ExprCodeTemp(Parse *pParse, Expr *pExpr, int *pReg){
   if( ConstFactorOk(pParse)
    && ALWAYS(pExpr!=0)
    && pExpr->op!=TK_REGISTER
-   && sqlite3ExprIsConstantNotJoin(pExpr)
+   && sqlite3ExprIsConstantNotJoin(pParse, pExpr)
   ){
     *pReg  = 0;
     r2 = sqlite3ExprCodeRunJustOnce(pParse, pExpr, -1);
@@ -113684,7 +115057,7 @@ SQLITE_PRIVATE void sqlite3ExprCodeCopy(Parse *pParse, Expr *pExpr, int target){
 ** might choose to code the expression at initialization time.
 */
 SQLITE_PRIVATE void sqlite3ExprCodeFactorable(Parse *pParse, Expr *pExpr, int target){
-  if( pParse->okConstFactor && sqlite3ExprIsConstantNotJoin(pExpr) ){
+  if( pParse->okConstFactor && sqlite3ExprIsConstantNotJoin(pParse,pExpr) ){
     sqlite3ExprCodeRunJustOnce(pParse, pExpr, target);
   }else{
     sqlite3ExprCodeCopy(pParse, pExpr, target);
@@ -113743,7 +115116,7 @@ SQLITE_PRIVATE int sqlite3ExprCodeExprList(
         sqlite3VdbeAddOp2(v, copyOp, j+srcReg-1, target+i);
       }
     }else if( (flags & SQLITE_ECEL_FACTOR)!=0
-           && sqlite3ExprIsConstantNotJoin(pExpr)
+           && sqlite3ExprIsConstantNotJoin(pParse,pExpr)
     ){
       sqlite3ExprCodeRunJustOnce(pParse, pExpr, target+i);
     }else{
@@ -113816,7 +115189,7 @@ static void exprCodeBetween(
     compRight.op = TK_LE;
     compRight.pLeft = pDel;
     compRight.pRight = pExpr->x.pList->a[1].pExpr;
-    exprToRegister(pDel, exprCodeVector(pParse, pDel, &regFree1));
+    sqlite3ExprToRegister(pDel, exprCodeVector(pParse, pDel, &regFree1));
     if( xJump ){
       xJump(pParse, &exprAnd, dest, jumpIfNull);
     }else{
@@ -114894,9 +116267,8 @@ static int agginfoPersistExprCb(Walker *pWalker, Expr *pExpr){
        && pAggInfo->aCol[iAgg].pCExpr==pExpr
       ){
         pExpr = sqlite3ExprDup(db, pExpr, 0);
-        if( pExpr ){
+        if( pExpr && !sqlite3ExprDeferredDelete(pParse, pExpr) ){
           pAggInfo->aCol[iAgg].pCExpr = pExpr;
-          sqlite3ExprDeferredDelete(pParse, pExpr);
         }
       }
     }else{
@@ -114905,9 +116277,8 @@ static int agginfoPersistExprCb(Walker *pWalker, Expr *pExpr){
        && pAggInfo->aFunc[iAgg].pFExpr==pExpr
       ){
         pExpr = sqlite3ExprDup(db, pExpr, 0);
-        if( pExpr ){
+        if( pExpr && !sqlite3ExprDeferredDelete(pParse, pExpr) ){
           pAggInfo->aFunc[iAgg].pFExpr = pExpr;
-          sqlite3ExprDeferredDelete(pParse, pExpr);
         }
       }
     }
@@ -116666,7 +118037,7 @@ static int renameResolveTrigger(Parse *pParse){
   /* ALWAYS() because if the table of the trigger does not exist, the
   ** error would have been hit before this point */
   if( ALWAYS(pParse->pTriggerTab) ){
-    rc = sqlite3ViewGetColumnNames(pParse, pParse->pTriggerTab);
+    rc = sqlite3ViewGetColumnNames(pParse, pParse->pTriggerTab)!=0;
   }
 
   /* Resolve symbols in WHEN clause */
@@ -116712,8 +118083,9 @@ static int renameResolveTrigger(Parse *pParse){
           int i;
           for(i=0; i<pStep->pFrom->nSrc && rc==SQLITE_OK; i++){
             SrcItem *p = &pStep->pFrom->a[i];
-            if( p->pSelect ){
-              sqlite3SelectPrep(pParse, p->pSelect, 0);
+            if( p->fg.isSubquery ){
+              assert( p->u4.pSubq!=0 );
+              sqlite3SelectPrep(pParse, p->u4.pSubq->pSelect, 0);
             }
           }
         }
@@ -116781,8 +118153,12 @@ static void renameWalkTrigger(Walker *pWalker, Trigger *pTrigger){
     }
     if( pStep->pFrom ){
       int i;
-      for(i=0; i<pStep->pFrom->nSrc; i++){
-        sqlite3WalkSelect(pWalker, pStep->pFrom->a[i].pSelect);
+      SrcList *pFrom = pStep->pFrom;
+      for(i=0; i<pFrom->nSrc; i++){
+        if( pFrom->a[i].fg.isSubquery ){
+          assert( pFrom->a[i].u4.pSubq!=0 );
+          sqlite3WalkSelect(pWalker, pFrom->a[i].u4.pSubq->pSelect);
+        }
       }
     }
   }
@@ -117029,7 +118405,7 @@ static int renameTableSelectCb(Walker *pWalker, Select *pSelect){
   }
   for(i=0; i<pSrc->nSrc; i++){
     SrcItem *pItem = &pSrc->a[i];
-    if( pItem->pTab==p->pTab ){
+    if( pItem->pSTab==p->pTab ){
       renameTokenFind(pWalker->pParse, p, pItem->zName);
     }
   }
@@ -117608,7 +118984,12 @@ SQLITE_PRIVATE void sqlite3AlterDropColumn(Parse *pParse, SrcList *pSrc, const T
         if( i==pTab->iPKey ){
           sqlite3VdbeAddOp2(v, OP_Null, 0, regOut);
         }else{
+          char aff = pTab->aCol[i].affinity;
+          if( aff==SQLITE_AFF_REAL ){
+            pTab->aCol[i].affinity = SQLITE_AFF_NUMERIC;
+          }
           sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, i, regOut);
+          pTab->aCol[i].affinity = aff;
         }
         nField++;
       }
@@ -118527,7 +119908,7 @@ static void statGet(
       if( iVal==2 && p->nRow*10 <= nDistinct*11 ) iVal = 1;
       sqlite3_str_appendf(&sStat, " %llu", iVal);
 #ifdef SQLITE_ENABLE_STAT4
-      assert( p->current.anEq[i] );
+      assert( p->current.anEq[i] || p->nRow==0 );
 #endif
     }
     sqlite3ResultStrAccum(context, &sStat);
@@ -118712,7 +120093,7 @@ static void analyzeOneTable(
 
   for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
     int nCol;                     /* Number of columns in pIdx. "N" */
-    int addrRewind;               /* Address of "OP_Rewind iIdxCur" */
+    int addrGotoEnd;               /* Address of "OP_Rewind iIdxCur" */
     int addrNextRow;              /* Address of "next_row:" */
     const char *zIdxName;         /* Name of the index */
     int nColTest;                 /* Number of columns to test for changes */
@@ -118736,9 +120117,14 @@ static void analyzeOneTable(
     /*
     ** Pseudo-code for loop that calls stat_push():
     **
-    **   Rewind csr
-    **   if eof(csr) goto end_of_scan;
     **   regChng = 0
+    **   Rewind csr
+    **   if eof(csr){
+    **      stat_init() with count = 0;
+    **      goto end_of_scan;
+    **   }
+    **   count()
+    **   stat_init()
     **   goto chng_addr_0;
     **
     **  next_row:
@@ -118777,41 +120163,36 @@ static void analyzeOneTable(
     sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
     VdbeComment((v, "%s", pIdx->zName));
 
-    /* Invoke the stat_init() function. The arguments are:
+    /* Implementation of the following:
     **
+    **   regChng = 0
+    **   Rewind csr
+    **   if eof(csr){
+    **      stat_init() with count = 0;
+    **      goto end_of_scan;
+    **   }
+    **   count()
+    **   stat_init()
+    **   goto chng_addr_0;
+    */
+    assert( regTemp2==regStat+4 );
+    sqlite3VdbeAddOp2(v, OP_Integer, db->nAnalysisLimit, regTemp2);
+
+    /* Arguments to stat_init():
     **    (1) the number of columns in the index including the rowid
     **        (or for a WITHOUT ROWID table, the number of PK columns),
     **    (2) the number of columns in the key without the rowid/pk
-    **    (3) estimated number of rows in the index,
-    */
+    **    (3) estimated number of rows in the index. */
     sqlite3VdbeAddOp2(v, OP_Integer, nCol, regStat+1);
     assert( regRowid==regStat+2 );
     sqlite3VdbeAddOp2(v, OP_Integer, pIdx->nKeyCol, regRowid);
-#ifdef SQLITE_ENABLE_STAT4
-    if( OptimizationEnabled(db, SQLITE_Stat4) ){
-      sqlite3VdbeAddOp2(v, OP_Count, iIdxCur, regTemp);
-      addrRewind = sqlite3VdbeAddOp1(v, OP_Rewind, iIdxCur);
-      VdbeCoverage(v);
-    }else
-#endif
-    {
-      addrRewind = sqlite3VdbeAddOp1(v, OP_Rewind, iIdxCur);
-      VdbeCoverage(v);
-      sqlite3VdbeAddOp3(v, OP_Count, iIdxCur, regTemp, 1);
-    }
-    assert( regTemp2==regStat+4 );
-    sqlite3VdbeAddOp2(v, OP_Integer, db->nAnalysisLimit, regTemp2);
+    sqlite3VdbeAddOp3(v, OP_Count, iIdxCur, regTemp,
+                      OptimizationDisabled(db, SQLITE_Stat4));
     sqlite3VdbeAddFunctionCall(pParse, 0, regStat+1, regStat, 4,
                                &statInitFuncdef, 0);
+    addrGotoEnd = sqlite3VdbeAddOp1(v, OP_Rewind, iIdxCur);
+    VdbeCoverage(v);
 
-    /* Implementation of the following:
-    **
-    **   Rewind csr
-    **   if eof(csr) goto end_of_scan;
-    **   regChng = 0
-    **   goto next_push_0;
-    **
-    */
     sqlite3VdbeAddOp2(v, OP_Integer, 0, regChng);
     addrNextRow = sqlite3VdbeCurrentAddr(v);
 
@@ -118918,6 +120299,12 @@ static void analyzeOneTable(
     }
 
     /* Add the entry to the stat1 table. */
+    if( pIdx->pPartIdxWhere ){
+      /* Partial indexes might get a zero-entry in sqlite_stat1.  But
+      ** an empty table is omitted from sqlite_stat1. */
+      sqlite3VdbeJumpHere(v, addrGotoEnd);
+      addrGotoEnd = 0;
+    }
     callStatGet(pParse, regStat, STAT_GET_STAT1, regStat1);
     assert( "BBB"[0]==SQLITE_AFF_TEXT );
     sqlite3VdbeAddOp4(v, OP_MakeRecord, regTabname, 3, regTemp, "BBB", 0);
@@ -118941,6 +120328,13 @@ static void analyzeOneTable(
       int addrIsNull;
       u8 seekOp = HasRowid(pTab) ? OP_NotExists : OP_NotFound;
 
+      /* No STAT4 data is generated if the number of rows is zero */
+      if( addrGotoEnd==0 ){
+        sqlite3VdbeAddOp2(v, OP_Cast, regStat1, SQLITE_AFF_INTEGER);
+        addrGotoEnd = sqlite3VdbeAddOp1(v, OP_IfNot, regStat1);
+        VdbeCoverage(v);
+      }
+
       if( doOnce ){
         int mxCol = nCol;
         Index *pX;
@@ -118993,7 +120387,7 @@ static void analyzeOneTable(
 #endif /* SQLITE_ENABLE_STAT4 */
 
     /* End of analysis */
-    sqlite3VdbeJumpHere(v, addrRewind);
+    if( addrGotoEnd ) sqlite3VdbeJumpHere(v, addrGotoEnd);
   }
 
 
@@ -119439,12 +120833,13 @@ static int loadStatTbl(
   while( sqlite3_step(pStmt)==SQLITE_ROW ){
     int nIdxCol = 1;              /* Number of columns in stat4 records */
 
-    char *zIndex;   /* Index name */
-    Index *pIdx;    /* Pointer to the index object */
-    int nSample;    /* Number of samples */
-    int nByte;      /* Bytes of space required */
-    int i;          /* Bytes of space required */
-    tRowcnt *pSpace;
+    char *zIndex;    /* Index name */
+    Index *pIdx;     /* Pointer to the index object */
+    int nSample;     /* Number of samples */
+    i64 nByte;       /* Bytes of space required */
+    i64 i;           /* Bytes of space required */
+    tRowcnt *pSpace; /* Available allocated memory space */
+    u8 *pPtr;        /* Available memory as a u8 for easier manipulation */
 
     zIndex = (char *)sqlite3_column_text(pStmt, 0);
     if( zIndex==0 ) continue;
@@ -119464,7 +120859,7 @@ static int loadStatTbl(
     }
     pIdx->nSampleCol = nIdxCol;
     pIdx->mxSample = nSample;
-    nByte = sizeof(IndexSample) * nSample;
+    nByte = ROUND8(sizeof(IndexSample) * nSample);
     nByte += sizeof(tRowcnt) * nIdxCol * 3 * nSample;
     nByte += nIdxCol * sizeof(tRowcnt);     /* Space for Index.aAvgEq[] */
 
@@ -119473,7 +120868,10 @@ static int loadStatTbl(
       sqlite3_finalize(pStmt);
       return SQLITE_NOMEM_BKPT;
     }
-    pSpace = (tRowcnt*)&pIdx->aSample[nSample];
+    pPtr = (u8*)pIdx->aSample;
+    pPtr += ROUND8(nSample*sizeof(pIdx->aSample[0]));
+    pSpace = (tRowcnt*)pPtr;
+    assert( EIGHT_BYTE_ALIGNMENT( pSpace ) );
     pIdx->aAvgEq = pSpace; pSpace += nIdxCol;
     pIdx->pTable->tabFlags |= TF_HasStat4;
     for(i=0; i<nSample; i++){
@@ -120141,20 +121539,21 @@ static int fixSelectCb(Walker *p, Select *pSelect){
 
   if( NEVER(pList==0) ) return WRC_Continue;
   for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
-    if( pFix->bTemp==0 ){
-      if( pItem->zDatabase ){
-        if( iDb!=sqlite3FindDbName(db, pItem->zDatabase) ){
+    if( pFix->bTemp==0 && pItem->fg.isSubquery==0 ){
+      if( pItem->fg.fixedSchema==0 && pItem->u4.zDatabase!=0 ){
+        if( iDb!=sqlite3FindDbName(db, pItem->u4.zDatabase) ){
           sqlite3ErrorMsg(pFix->pParse,
               "%s %T cannot reference objects in database %s",
-              pFix->zType, pFix->pName, pItem->zDatabase);
+              pFix->zType, pFix->pName, pItem->u4.zDatabase);
           return WRC_Abort;
         }
-        sqlite3DbFree(db, pItem->zDatabase);
-        pItem->zDatabase = 0;
+        sqlite3DbFree(db, pItem->u4.zDatabase);
         pItem->fg.notCte = 1;
+        pItem->fg.hadSchema = 1;
       }
-      pItem->pSchema = pFix->pSchema;
+      pItem->u4.pSchema = pFix->pSchema;
       pItem->fg.fromDDL = 1;
+      pItem->fg.fixedSchema = 1;
     }
 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER)
     if( pList->a[i].fg.isUsing==0
@@ -120447,7 +121846,7 @@ SQLITE_PRIVATE void sqlite3AuthRead(
     assert( pTabList );
     for(iSrc=0; iSrc<pTabList->nSrc; iSrc++){
       if( pExpr->iTable==pTabList->a[iSrc].iCursor ){
-        pTab = pTabList->a[iSrc].pTab;
+        pTab = pTabList->a[iSrc].pSTab;
         break;
       }
     }
@@ -120742,7 +122141,7 @@ SQLITE_PRIVATE void sqlite3FinishCoding(Parse *pParse){
     }
     sqlite3VdbeAddOp0(v, OP_Halt);
 
-#if SQLITE_USER_AUTHENTICATION
+#if SQLITE_USER_AUTHENTICATION && !defined(SQLITE_OMIT_SHARED_CACHE)
     if( pParse->nTableLock>0 && db->init.busy==0 ){
       sqlite3UserAuthInit(db);
       if( db->auth.authLevel<UAUTH_User ){
@@ -121050,12 +122449,12 @@ SQLITE_PRIVATE Table *sqlite3LocateTableItem(
   SrcItem *p
 ){
   const char *zDb;
-  assert( p->pSchema==0 || p->zDatabase==0 );
-  if( p->pSchema ){
-    int iDb = sqlite3SchemaToIndex(pParse->db, p->pSchema);
+  if( p->fg.fixedSchema ){
+    int iDb = sqlite3SchemaToIndex(pParse->db, p->u4.pSchema);
     zDb = pParse->db->aDb[iDb].zDbSName;
   }else{
-    zDb = p->zDatabase;
+    assert( !p->fg.isSubquery );
+    zDb = p->u4.zDatabase;
   }
   return sqlite3LocateTable(pParse, flags, p->zName, zDb);
 }
@@ -123381,20 +124780,20 @@ SQLITE_PRIVATE void sqlite3EndTable(
       int regRowid;       /* Rowid of the next row to insert */
       int addrInsLoop;    /* Top of the loop for inserting rows */
       Table *pSelTab;     /* A table that describes the SELECT results */
+      int iCsr;           /* Write cursor on the new table */
 
       if( IN_SPECIAL_PARSE ){
         pParse->rc = SQLITE_ERROR;
         pParse->nErr++;
         return;
       }
+      iCsr = pParse->nTab++;
       regYield = ++pParse->nMem;
       regRec = ++pParse->nMem;
       regRowid = ++pParse->nMem;
-      assert(pParse->nTab==1);
       sqlite3MayAbort(pParse);
-      sqlite3VdbeAddOp3(v, OP_OpenWrite, 1, pParse->regRoot, iDb);
+      sqlite3VdbeAddOp3(v, OP_OpenWrite, iCsr, pParse->regRoot, iDb);
       sqlite3VdbeChangeP5(v, OPFLAG_P2ISREG);
-      pParse->nTab = 2;
       addrTop = sqlite3VdbeCurrentAddr(v) + 1;
       sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, addrTop);
       if( pParse->nErr ) return;
@@ -123415,11 +124814,11 @@ SQLITE_PRIVATE void sqlite3EndTable(
       VdbeCoverage(v);
       sqlite3VdbeAddOp3(v, OP_MakeRecord, dest.iSdst, dest.nSdst, regRec);
       sqlite3TableAffinity(v, p, 0);
-      sqlite3VdbeAddOp2(v, OP_NewRowid, 1, regRowid);
-      sqlite3VdbeAddOp3(v, OP_Insert, 1, regRec, regRowid);
+      sqlite3VdbeAddOp2(v, OP_NewRowid, iCsr, regRowid);
+      sqlite3VdbeAddOp3(v, OP_Insert, iCsr, regRec, regRowid);
       sqlite3VdbeGoto(v, addrInsLoop);
       sqlite3VdbeJumpHere(v, addrInsLoop);
-      sqlite3VdbeAddOp1(v, OP_Close, 1);
+      sqlite3VdbeAddOp1(v, OP_Close, iCsr);
     }
 
     /* Compute the complete text of the CREATE statement */
@@ -123476,13 +124875,10 @@ SQLITE_PRIVATE void sqlite3EndTable(
     /* Test for cycles in generated columns and illegal expressions
     ** in CHECK constraints and in DEFAULT clauses. */
     if( p->tabFlags & TF_HasGenerated ){
-      sqlite3VdbeAddOp4(v, OP_SqlExec, 1, 0, 0,
+      sqlite3VdbeAddOp4(v, OP_SqlExec, 0x0001, 0, 0,
              sqlite3MPrintf(db, "SELECT*FROM\"%w\".\"%w\"",
                    db->aDb[iDb].zDbSName, p->zName), P4_DYNAMIC);
     }
-    sqlite3VdbeAddOp4(v, OP_SqlExec, 1, 0, 0,
-           sqlite3MPrintf(db, "PRAGMA \"%w\".integrity_check(%Q)",
-                 db->aDb[iDb].zDbSName, p->zName), P4_DYNAMIC);
   }
 
   /* Add the table to the in-memory representation of the database.
@@ -123559,9 +124955,12 @@ SQLITE_PRIVATE void sqlite3CreateView(
   ** on a view, even though views do not have rowids.  The following flag
   ** setting fixes this problem.  But the fix can be disabled by compiling
   ** with -DSQLITE_ALLOW_ROWID_IN_VIEW in case there are legacy apps that
-  ** depend upon the old buggy behavior. */
-#ifndef SQLITE_ALLOW_ROWID_IN_VIEW
-  p->tabFlags |= TF_NoVisibleRowid;
+  ** depend upon the old buggy behavior.  The ability can also be toggled
+  ** using sqlite3_config(SQLITE_CONFIG_ROWID_IN_VIEW,...) */
+#ifdef SQLITE_ALLOW_ROWID_IN_VIEW
+  p->tabFlags |= sqlite3Config.mNoVisibleRowid; /* Optional. Allow by default */
+#else
+  p->tabFlags |= TF_NoVisibleRowid;             /* Never allow rowid in view */
 #endif
 
   sqlite3TwoPartName(pParse, pName1, pName2, &pName);
@@ -123617,8 +125016,9 @@ create_view_fail:
 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
 /*
 ** The Table structure pTable is really a VIEW.  Fill in the names of
-** the columns of the view in the pTable structure.  Return the number
-** of errors.  If an error is seen leave an error message in pParse->zErrMsg.
+** the columns of the view in the pTable structure.  Return non-zero if
+** there are errors.  If an error is seen an error message is left
+** in pParse->zErrMsg.
 */
 static SQLITE_NOINLINE int viewGetColumnNames(Parse *pParse, Table *pTable){
   Table *pSelTab;   /* A fake table from which we get the result set */
@@ -123741,7 +125141,7 @@ static SQLITE_NOINLINE int viewGetColumnNames(Parse *pParse, Table *pTable){
     sqlite3DeleteColumnNames(db, pTable);
   }
 #endif /* SQLITE_OMIT_VIEW */
-  return nErr;
+  return nErr + pParse->nErr;
 }
 SQLITE_PRIVATE int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){
   assert( pTable!=0 );
@@ -124039,6 +125439,8 @@ SQLITE_PRIVATE void sqlite3DropTable(Parse *pParse, SrcList *pName, int isView,
   }
   assert( pParse->nErr==0 );
   assert( pName->nSrc==1 );
+  assert( pName->a[0].fg.fixedSchema==0 );
+  assert( pName->a[0].fg.isSubquery==0 );
   if( sqlite3ReadSchema(pParse) ) goto exit_drop_table;
   if( noErr ) db->suppressErr++;
   assert( isView==0 || isView==LOCATE_VIEW );
@@ -124047,7 +125449,7 @@ SQLITE_PRIVATE void sqlite3DropTable(Parse *pParse, SrcList *pName, int isView,
 
   if( pTab==0 ){
     if( noErr ){
-      sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase);
+      sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].u4.zDatabase);
       sqlite3ForceNotReadOnly(pParse);
     }
     goto exit_drop_table;
@@ -125138,15 +126540,17 @@ SQLITE_PRIVATE void sqlite3DropIndex(Parse *pParse, SrcList *pName, int ifExists
   }
   assert( pParse->nErr==0 );   /* Never called with prior non-OOM errors */
   assert( pName->nSrc==1 );
+  assert( pName->a[0].fg.fixedSchema==0 );
+  assert( pName->a[0].fg.isSubquery==0 );
   if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
     goto exit_drop_index;
   }
-  pIndex = sqlite3FindIndex(db, pName->a[0].zName, pName->a[0].zDatabase);
+  pIndex = sqlite3FindIndex(db, pName->a[0].zName, pName->a[0].u4.zDatabase);
   if( pIndex==0 ){
     if( !ifExists ){
       sqlite3ErrorMsg(pParse, "no such index: %S", pName->a);
     }else{
-      sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase);
+      sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].u4.zDatabase);
       sqlite3ForceNotReadOnly(pParse);
     }
     pParse->checkSchema = 1;
@@ -125443,12 +126847,14 @@ SQLITE_PRIVATE SrcList *sqlite3SrcListAppend(
   if( pDatabase && pDatabase->z==0 ){
     pDatabase = 0;
   }
+  assert( pItem->fg.fixedSchema==0 );
+  assert( pItem->fg.isSubquery==0 );
   if( pDatabase ){
     pItem->zName = sqlite3NameFromToken(db, pDatabase);
-    pItem->zDatabase = sqlite3NameFromToken(db, pTable);
+    pItem->u4.zDatabase = sqlite3NameFromToken(db, pTable);
   }else{
     pItem->zName = sqlite3NameFromToken(db, pTable);
-    pItem->zDatabase = 0;
+    pItem->u4.zDatabase = 0;
   }
   return pList;
 }
@@ -125464,13 +126870,40 @@ SQLITE_PRIVATE void sqlite3SrcListAssignCursors(Parse *pParse, SrcList *pList){
     for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
       if( pItem->iCursor>=0 ) continue;
       pItem->iCursor = pParse->nTab++;
-      if( pItem->pSelect ){
-        sqlite3SrcListAssignCursors(pParse, pItem->pSelect->pSrc);
+      if( pItem->fg.isSubquery ){
+        assert( pItem->u4.pSubq!=0 );
+        assert( pItem->u4.pSubq->pSelect!=0 );
+        assert( pItem->u4.pSubq->pSelect->pSrc!=0 );
+        sqlite3SrcListAssignCursors(pParse, pItem->u4.pSubq->pSelect->pSrc);
       }
     }
   }
 }
 
+/*
+** Delete a Subquery object and its substructure.
+*/
+SQLITE_PRIVATE void sqlite3SubqueryDelete(sqlite3 *db, Subquery *pSubq){
+  assert( pSubq!=0 && pSubq->pSelect!=0 );
+  sqlite3SelectDelete(db, pSubq->pSelect);
+  sqlite3DbFree(db, pSubq);
+}
+
+/*
+** Remove a Subquery from a SrcItem.  Return the associated Select object.
+** The returned Select becomes the responsibility of the caller.
+*/
+SQLITE_PRIVATE Select *sqlite3SubqueryDetach(sqlite3 *db, SrcItem *pItem){
+  Select *pSel;
+  assert( pItem!=0 );
+  assert( pItem->fg.isSubquery );
+  pSel = pItem->u4.pSubq->pSelect;
+  sqlite3DbFree(db, pItem->u4.pSubq);
+  pItem->u4.pSubq = 0;
+  pItem->fg.isSubquery = 0;
+  return pSel;
+}
+
 /*
 ** Delete an entire SrcList including all its substructure.
 */
@@ -125480,13 +126913,24 @@ SQLITE_PRIVATE void sqlite3SrcListDelete(sqlite3 *db, SrcList *pList){
   assert( db!=0 );
   if( pList==0 ) return;
   for(pItem=pList->a, i=0; i<pList->nSrc; i++, pItem++){
-    if( pItem->zDatabase ) sqlite3DbNNFreeNN(db, pItem->zDatabase);
+
+    /* Check invariants on SrcItem */
+    assert( !pItem->fg.isIndexedBy || !pItem->fg.isTabFunc );
+    assert( !pItem->fg.isCte || !pItem->fg.isIndexedBy );
+    assert( !pItem->fg.fixedSchema || !pItem->fg.isSubquery );
+    assert( !pItem->fg.isSubquery || (pItem->u4.pSubq!=0 &&
+                                      pItem->u4.pSubq->pSelect!=0) );
+
     if( pItem->zName ) sqlite3DbNNFreeNN(db, pItem->zName);
     if( pItem->zAlias ) sqlite3DbNNFreeNN(db, pItem->zAlias);
+    if( pItem->fg.isSubquery ){
+      sqlite3SubqueryDelete(db, pItem->u4.pSubq);
+    }else if( pItem->fg.fixedSchema==0 && pItem->u4.zDatabase!=0 ){
+      sqlite3DbNNFreeNN(db, pItem->u4.zDatabase);
+    }
     if( pItem->fg.isIndexedBy ) sqlite3DbFree(db, pItem->u1.zIndexedBy);
     if( pItem->fg.isTabFunc ) sqlite3ExprListDelete(db, pItem->u1.pFuncArg);
-    sqlite3DeleteTable(db, pItem->pTab);
-    if( pItem->pSelect ) sqlite3SelectDelete(db, pItem->pSelect);
+    sqlite3DeleteTable(db, pItem->pSTab);
     if( pItem->fg.isUsing ){
       sqlite3IdListDelete(db, pItem->u3.pUsing);
     }else if( pItem->u3.pOn ){
@@ -125496,6 +126940,54 @@ SQLITE_PRIVATE void sqlite3SrcListDelete(sqlite3 *db, SrcList *pList){
   sqlite3DbNNFreeNN(db, pList);
 }
 
+/*
+** Attach a Subquery object to pItem->uv.pSubq.  Set the
+** pSelect value but leave all the other values initialized
+** to zero.
+**
+** A copy of the Select object is made if dupSelect is true, and the
+** SrcItem takes responsibility for deleting the copy.  If dupSelect is
+** false, ownership of the Select passes to the SrcItem.  Either way,
+** the SrcItem will take responsibility for deleting the Select.
+**
+** When dupSelect is zero, that means the Select might get deleted right
+** away if there is an OOM error.  Beware.
+**
+** Return non-zero on success.  Return zero on an OOM error.
+*/
+SQLITE_PRIVATE int sqlite3SrcItemAttachSubquery(
+  Parse *pParse,     /* Parsing context */
+  SrcItem *pItem,    /* Item to which the subquery is to be attached */
+  Select *pSelect,   /* The subquery SELECT.  Must be non-NULL */
+  int dupSelect      /* If true, attach a copy of pSelect, not pSelect itself.*/
+){
+  Subquery *p;
+  assert( pSelect!=0 );
+  assert( pItem->fg.isSubquery==0 );
+  if( pItem->fg.fixedSchema ){
+    pItem->u4.pSchema = 0;
+    pItem->fg.fixedSchema = 0;
+  }else if( pItem->u4.zDatabase!=0 ){
+    sqlite3DbFree(pParse->db, pItem->u4.zDatabase);
+    pItem->u4.zDatabase = 0;
+  }
+  if( dupSelect ){
+    pSelect = sqlite3SelectDup(pParse->db, pSelect, 0);
+    if( pSelect==0 ) return 0;
+  }
+  p = pItem->u4.pSubq = sqlite3DbMallocRawNN(pParse->db, sizeof(Subquery));
+  if( p==0 ){
+    sqlite3SelectDelete(pParse->db, pSelect);
+    return 0;
+  }
+  pItem->fg.isSubquery = 1;
+  p->pSelect = pSelect;
+  assert( offsetof(Subquery, pSelect)==0 );
+  memset(((char*)p)+sizeof(p->pSelect), 0, sizeof(*p)-sizeof(p->pSelect));
+  return 1;
+}
+
+
 /*
 ** This routine is called by the parser to add a new term to the
 ** end of a growing FROM clause.  The "p" parameter is the part of
@@ -125545,10 +127037,12 @@ SQLITE_PRIVATE SrcList *sqlite3SrcListAppendFromTerm(
   if( pAlias->n ){
     pItem->zAlias = sqlite3NameFromToken(db, pAlias);
   }
+  assert( pSubquery==0 || pDatabase==0 );
   if( pSubquery ){
-    pItem->pSelect = pSubquery;
-    if( pSubquery->selFlags & SF_NestedFrom ){
-      pItem->fg.isNestedFrom = 1;
+    if( sqlite3SrcItemAttachSubquery(pParse, pItem, pSubquery, 0) ){
+      if( pSubquery->selFlags & SF_NestedFrom ){
+        pItem->fg.isNestedFrom = 1;
+      }
     }
   }
   assert( pOnUsing==0 || pOnUsing->pOn==0 || pOnUsing->pUsing==0 );
@@ -126826,8 +128320,8 @@ SQLITE_PRIVATE Schema *sqlite3SchemaGet(sqlite3 *db, Btree *pBt){
 **
 ** The following fields are initialized appropriate in pSrc:
 **
-**    pSrc->a[0].pTab       Pointer to the Table object
-**    pSrc->a[0].pIndex     Pointer to the INDEXED BY index, if there is one
+**    pSrc->a[0].spTab        Pointer to the Table object
+**    pSrc->a[0].u2.pIBIndex  Pointer to the INDEXED BY index, if there is one
 **
 */
 SQLITE_PRIVATE Table *sqlite3SrcListLookup(Parse *pParse, SrcList *pSrc){
@@ -126835,8 +128329,8 @@ SQLITE_PRIVATE Table *sqlite3SrcListLookup(Parse *pParse, SrcList *pSrc){
   Table *pTab;
   assert( pItem && pSrc->nSrc>=1 );
   pTab = sqlite3LocateTableItem(pParse, 0, pItem);
-  if( pItem->pTab ) sqlite3DeleteTable(pParse->db, pItem->pTab);
-  pItem->pTab = pTab;
+  if( pItem->pSTab ) sqlite3DeleteTable(pParse->db, pItem->pSTab);
+  pItem->pSTab = pTab;
   pItem->fg.notCte = 1;
   if( pTab ){
     pTab->nTabRef++;
@@ -126877,6 +128371,7 @@ SQLITE_PRIVATE void sqlite3CodeChangeCount(Vdbe *v, int regCounter, const char *
 **      is for a top-level SQL statement.
 */
 static int vtabIsReadOnly(Parse *pParse, Table *pTab){
+  assert( IsVirtual(pTab) );
   if( sqlite3GetVTable(pParse->db, pTab)->pMod->pModule->xUpdate==0 ){
     return 1;
   }
@@ -126958,7 +128453,8 @@ SQLITE_PRIVATE void sqlite3MaterializeView(
   if( pFrom ){
     assert( pFrom->nSrc==1 );
     pFrom->a[0].zName = sqlite3DbStrDup(db, pView->zName);
-    pFrom->a[0].zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zDbSName);
+    assert( pFrom->a[0].fg.fixedSchema==0 && pFrom->a[0].fg.isSubquery==0 );
+    pFrom->a[0].u4.zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zDbSName);
     assert( pFrom->a[0].fg.isUsing==0 );
     assert( pFrom->a[0].u3.pOn==0 );
   }
@@ -127020,7 +128516,7 @@ SQLITE_PRIVATE Expr *sqlite3LimitWhere(
   **   );
   */
 
-  pTab = pSrc->a[0].pTab;
+  pTab = pSrc->a[0].pSTab;
   if( HasRowid(pTab) ){
     pLhs = sqlite3PExpr(pParse, TK_ROW, 0, 0);
     pEList = sqlite3ExprListAppend(
@@ -127053,9 +128549,9 @@ SQLITE_PRIVATE Expr *sqlite3LimitWhere(
 
   /* duplicate the FROM clause as it is needed by both the DELETE/UPDATE tree
   ** and the SELECT subtree. */
-  pSrc->a[0].pTab = 0;
+  pSrc->a[0].pSTab = 0;
   pSelectSrc = sqlite3SrcListDup(db, pSrc, 0);
-  pSrc->a[0].pTab = pTab;
+  pSrc->a[0].pSTab = pTab;
   if( pSrc->a[0].fg.isIndexedBy ){
     assert( pSrc->a[0].fg.isCte==0 );
     pSrc->a[0].u2.pIBIndex = 0;
@@ -128934,13 +130430,13 @@ SQLITE_PRIVATE void sqlite3QuoteValue(StrAccum *pStr, sqlite3_value *pValue){
       double r1, r2;
       const char *zVal;
       r1 = sqlite3_value_double(pValue);
-      sqlite3_str_appendf(pStr, "%!.15g", r1);
+      sqlite3_str_appendf(pStr, "%!0.15g", r1);
       zVal = sqlite3_str_value(pStr);
       if( zVal ){
         sqlite3AtoF(zVal, &r2, pStr->nChar, SQLITE_UTF8);
         if( r1!=r2 ){
           sqlite3_str_reset(pStr);
-          sqlite3_str_appendf(pStr, "%!.20e", r1);
+          sqlite3_str_appendf(pStr, "%!0.20e", r1);
         }
       }
       break;
@@ -129242,7 +130738,7 @@ static void replaceFunc(
   }
   if( zPattern[0]==0 ){
     assert( sqlite3_value_type(argv[1])!=SQLITE_NULL );
-    sqlite3_result_value(context, argv[0]);
+    sqlite3_result_text(context, (const char*)zStr, nStr, SQLITE_TRANSIENT);
     return;
   }
   nPattern = sqlite3_value_bytes(argv[1]);
@@ -129725,7 +131221,7 @@ static void sumFinalize(sqlite3_context *context){
     if( p->approx ){
       if( p->ovrfl ){
         sqlite3_result_error(context,"integer overflow",-1);
-      }else if( !sqlite3IsNaN(p->rErr) ){
+      }else if( !sqlite3IsOverflow(p->rErr) ){
         sqlite3_result_double(context, p->rSum+p->rErr);
       }else{
         sqlite3_result_double(context, p->rSum);
@@ -129742,7 +131238,7 @@ static void avgFinalize(sqlite3_context *context){
     double r;
     if( p->approx ){
       r = p->rSum;
-      if( !sqlite3IsNaN(p->rErr) ) r += p->rErr;
+      if( !sqlite3IsOverflow(p->rErr) ) r += p->rErr;
     }else{
       r = (double)(p->iSum);
     }
@@ -129756,7 +131252,7 @@ static void totalFinalize(sqlite3_context *context){
   if( p ){
     if( p->approx ){
       r = p->rSum;
-      if( !sqlite3IsNaN(p->rErr) ) r += p->rErr;
+      if( !sqlite3IsOverflow(p->rErr) ) r += p->rErr;
     }else{
       r = (double)(p->iSum);
     }
@@ -129882,7 +131378,11 @@ static void minMaxFinalize(sqlite3_context *context){
 ** group_concat(EXPR, ?SEPARATOR?)
 ** string_agg(EXPR, SEPARATOR)
 **
-** The SEPARATOR goes before the EXPR string.  This is tragic.  The
+** Content is accumulated in GroupConcatCtx.str with the SEPARATOR
+** coming before the EXPR value, except for the first entry which
+** omits the SEPARATOR.
+**
+** It is tragic that the SEPARATOR goes before the EXPR string.  The
 ** groupConcatInverse() implementation would have been easier if the
 ** SEPARATOR were appended after EXPR.  And the order is undocumented,
 ** so we could change it, in theory.  But the old behavior has been
@@ -129986,7 +131486,7 @@ static void groupConcatInverse(
   /* pGCC is always non-NULL since groupConcatStep() will have always
   ** run first to initialize it */
   if( ALWAYS(pGCC) ){
-    int nVS;
+    int nVS;  /* Number of characters to remove */
     /* Must call sqlite3_value_text() to convert the argument into text prior
     ** to invoking sqlite3_value_bytes(), in case the text encoding is UTF16 */
     (void)sqlite3_value_text(argv[0]);
@@ -130039,6 +131539,8 @@ static void groupConcatValue(sqlite3_context *context){
       sqlite3_result_error_toobig(context);
     }else if( pAccum->accError==SQLITE_NOMEM ){
       sqlite3_result_error_nomem(context);
+    }else if( pGCC->nAccum>0 && pAccum->nChar==0 ){
+      sqlite3_result_text(context, "", 1, SQLITE_STATIC);
     }else{
       const char *zText = sqlite3_str_value(pAccum);
       sqlite3_result_text(context, zText, pAccum->nChar, SQLITE_TRANSIENT);
@@ -130362,7 +131864,13 @@ static void signFunc(
 ** Implementation of fpdecode(x,y,z) function.
 **
 ** x is a real number that is to be decoded.  y is the precision.
-** z is the maximum real precision.
+** z is the maximum real precision.  Return a string that shows the
+** results of the sqlite3FpDecode() function.
+**
+** Used for testing and debugging only, specifically testing and debugging
+** of the sqlite3FpDecode() function.  This SQL function does not appear
+** in production builds.  This function is not an API and is subject to
+** modification or removal in future versions of SQLite.
 */
 static void fpdecodeFunc(
   sqlite3_context *context,
@@ -130378,6 +131886,7 @@ static void fpdecodeFunc(
   x = sqlite3_value_double(argv[0]);
   y = sqlite3_value_int(argv[1]);
   z = sqlite3_value_int(argv[2]);
+  if( z<=0 ) z = 1;
   sqlite3FpDecode(&s, x, y, z);
   if( s.isSpecial==2 ){
     sqlite3_snprintf(sizeof(zBuf), zBuf, "NaN");
@@ -130388,6 +131897,82 @@ static void fpdecodeFunc(
 }
 #endif /* SQLITE_DEBUG */
 
+#ifdef SQLITE_DEBUG
+/*
+** Implementation of parseuri(uri,flags) function.
+**
+** Required Arguments:
+**    "uri"        The URI to parse.
+**    "flags"      Bitmask of flags, as if to sqlite3_open_v2().
+**
+** Additional arguments beyond the first two make calls to
+** sqlite3_uri_key() for integers and sqlite3_uri_parameter for
+** anything else.
+**
+** The result is a string showing the results of calling sqlite3ParseUri().
+**
+** Used for testing and debugging only, specifically testing and debugging
+** of the sqlite3ParseUri() function.  This SQL function does not appear
+** in production builds.  This function is not an API and is subject to
+** modification or removal in future versions of SQLite.
+*/
+static void parseuriFunc(
+  sqlite3_context *ctx,
+  int argc,
+  sqlite3_value **argv
+){
+  sqlite3_str *pResult;
+  const char *zVfs;
+  const char *zUri;
+  unsigned int flgs;
+  int rc;
+  sqlite3_vfs *pVfs = 0;
+  char *zFile = 0;
+  char *zErr = 0;
+
+  if( argc<2 ) return;
+  pVfs = sqlite3_vfs_find(0);
+  assert( pVfs );
+  zVfs = pVfs->zName;
+  zUri = (const char*)sqlite3_value_text(argv[0]);
+  if( zUri==0 ) return;
+  flgs = (unsigned int)sqlite3_value_int(argv[1]);
+  rc = sqlite3ParseUri(zVfs, zUri, &flgs, &pVfs, &zFile, &zErr);
+  pResult = sqlite3_str_new(0);
+  if( pResult ){
+    int i;
+    sqlite3_str_appendf(pResult, "rc=%d", rc);
+    sqlite3_str_appendf(pResult, ", flags=0x%x", flgs);
+    sqlite3_str_appendf(pResult, ", vfs=%Q", pVfs ? pVfs->zName: 0);
+    sqlite3_str_appendf(pResult, ", err=%Q", zErr);
+    sqlite3_str_appendf(pResult, ", file=%Q", zFile);
+    if( zFile ){
+      const char *z = zFile;
+      z += sqlite3Strlen30(z)+1;
+      while( z[0] ){
+        sqlite3_str_appendf(pResult, ", %Q", z);
+        z += sqlite3Strlen30(z)+1;
+      }
+      for(i=2; i<argc; i++){
+        const char *zArg;
+        if( sqlite3_value_type(argv[i])==SQLITE_INTEGER ){
+          int k = sqlite3_value_int(argv[i]);
+          sqlite3_str_appendf(pResult, ", '%d:%q'",k,sqlite3_uri_key(zFile, k));
+        }else if( (zArg = (const char*)sqlite3_value_text(argv[i]))!=0 ){
+          sqlite3_str_appendf(pResult, ", '%q:%q'",
+                 zArg, sqlite3_uri_parameter(zFile,zArg));
+        }else{
+          sqlite3_str_appendf(pResult, ", NULL");
+        }
+      }
+    }
+    sqlite3_result_text(ctx, sqlite3_str_finish(pResult), -1, sqlite3_free);
+  }
+  sqlite3_free_filename(zFile);
+  sqlite3_free(zErr);
+}
+#endif /* SQLITE_DEBUG */
+
 /*
 ** All of the FuncDef structures in the aBuiltinFunc[] array above
 ** to the global function hash table.  This occurs at start-time (as
@@ -130450,7 +132035,8 @@ SQLITE_PRIVATE void sqlite3RegisterBuiltinFunctions(void){
     WAGGREGATE(max, 1, 1, 1, minmaxStep, minMaxFinalize, minMaxValue, 0,
                                  SQLITE_FUNC_MINMAX|SQLITE_FUNC_ANYORDER ),
     FUNCTION2(typeof,            1, 0, 0, typeofFunc,  SQLITE_FUNC_TYPEOF),
-    FUNCTION2(subtype,           1, 0, 0, subtypeFunc, SQLITE_FUNC_TYPEOF),
+    FUNCTION2(subtype,           1, 0, 0, subtypeFunc,
+                                           SQLITE_FUNC_TYPEOF|SQLITE_SUBTYPE),
     FUNCTION2(length,            1, 0, 0, lengthFunc,  SQLITE_FUNC_LENGTH),
     FUNCTION2(octet_length,      1, 0, 0, bytelengthFunc,SQLITE_FUNC_BYTELEN),
     FUNCTION(instr,              2, 0, 0, instrFunc        ),
@@ -130461,6 +132047,7 @@ SQLITE_PRIVATE void sqlite3RegisterBuiltinFunctions(void){
     FUNCTION(abs,                1, 0, 0, absFunc          ),
 #ifdef SQLITE_DEBUG
     FUNCTION(fpdecode,           3, 0, 0, fpdecodeFunc     ),
+    FUNCTION(parseuri,          -1, 0, 0, parseuriFunc     ),
 #endif
 #ifndef SQLITE_OMIT_FLOATING_POINT
     FUNCTION(round,              1, 0, 0, roundFunc        ),
@@ -130555,7 +132142,7 @@ SQLITE_PRIVATE void sqlite3RegisterBuiltinFunctions(void){
     MFUNCTION(sqrt,              1, sqrt,      math1Func   ),
     MFUNCTION(radians,           1, degToRad,  math1Func   ),
     MFUNCTION(degrees,           1, radToDeg,  math1Func   ),
-    FUNCTION(pi,                 0, 0, 0,      piFunc      ),
+    MFUNCTION(pi,                0, 0,         piFunc      ),
 #endif /* SQLITE_ENABLE_MATH_FUNCTIONS */
     FUNCTION(sign,               1, 0, 0,      signFunc    ),
     INLINE_FUNC(coalesce,       -1, INLINEFUNC_coalesce, 0 ),
@@ -131634,9 +133221,9 @@ SQLITE_PRIVATE void sqlite3FkCheck(
     pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0);
     if( pSrc ){
       SrcItem *pItem = pSrc->a;
-      pItem->pTab = pFKey->pFrom;
+      pItem->pSTab = pFKey->pFrom;
       pItem->zName = pFKey->pFrom->zName;
-      pItem->pTab->nTabRef++;
+      pItem->pSTab->nTabRef++;
       pItem->iCursor = pParse->nTab++;
 
       if( regNew!=0 ){
@@ -131919,7 +133506,8 @@ static Trigger *fkActionTrigger(
       SrcList *pSrc;
       Expr *pRaise;
 
-      pRaise = sqlite3Expr(db, TK_RAISE, "FOREIGN KEY constraint failed");
+      pRaise = sqlite3Expr(db, TK_STRING, "FOREIGN KEY constraint failed"),
+      pRaise = sqlite3PExpr(pParse, TK_RAISE, pRaise, 0);
       if( pRaise ){
         pRaise->affExpr = OE_Abort;
       }
@@ -131927,7 +133515,8 @@ static Trigger *fkActionTrigger(
       if( pSrc ){
         assert( pSrc->nSrc==1 );
         pSrc->a[0].zName = sqlite3DbStrDup(db, zFrom);
-        pSrc->a[0].zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zDbSName);
+        assert( pSrc->a[0].fg.fixedSchema==0 && pSrc->a[0].fg.isSubquery==0 );
+        pSrc->a[0].u4.zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zDbSName);
       }
       pSelect = sqlite3SelectNew(pParse,
           sqlite3ExprListAppend(pParse, 0, pRaise),
@@ -132653,6 +134242,210 @@ SQLITE_PRIVATE void sqlite3AutoincrementEnd(Parse *pParse){
 # define autoIncStep(A,B,C)
 #endif /* SQLITE_OMIT_AUTOINCREMENT */
 
+/*
+** If argument pVal is a Select object returned by an sqlite3MultiValues()
+** that was able to use the co-routine optimization, finish coding the
+** co-routine.
+*/
+SQLITE_PRIVATE void sqlite3MultiValuesEnd(Parse *pParse, Select *pVal){
+  if( ALWAYS(pVal) && pVal->pSrc->nSrc>0 ){
+    SrcItem *pItem = &pVal->pSrc->a[0];
+    assert( (pItem->fg.isSubquery && pItem->u4.pSubq!=0) || pParse->nErr );
+    if( pItem->fg.isSubquery ){
+      sqlite3VdbeEndCoroutine(pParse->pVdbe, pItem->u4.pSubq->regReturn);
+      sqlite3VdbeJumpHere(pParse->pVdbe, pItem->u4.pSubq->addrFillSub - 1);
+    }
+  }
+}
+
+/*
+** Return true if all expressions in the expression-list passed as the
+** only argument are constant.
+*/
+static int exprListIsConstant(Parse *pParse, ExprList *pRow){
+  int ii;
+  for(ii=0; ii<pRow->nExpr; ii++){
+    if( 0==sqlite3ExprIsConstant(pParse, pRow->a[ii].pExpr) ) return 0;
+  }
+  return 1;
+}
+
+/*
+** Return true if all expressions in the expression-list passed as the
+** only argument are both constant and have no affinity.
+*/
+static int exprListIsNoAffinity(Parse *pParse, ExprList *pRow){
+  int ii;
+  if( exprListIsConstant(pParse,pRow)==0 ) return 0;
+  for(ii=0; ii<pRow->nExpr; ii++){
+    Expr *pExpr = pRow->a[ii].pExpr;
+    assert( pExpr->op!=TK_RAISE );
+    assert( pExpr->affExpr==0 );
+    if( 0!=sqlite3ExprAffinity(pExpr) ) return 0;
+  }
+  return 1;
+
+}
+
+/*
+** This function is called by the parser for the second and subsequent
+** rows of a multi-row VALUES clause. Argument pLeft is the part of
+** the VALUES clause already parsed, argument pRow is the vector of values
+** for the new row. The Select object returned represents the complete
+** VALUES clause, including the new row.
+**
+** There are two ways in which this may be achieved - by incremental
+** coding of a co-routine (the "co-routine" method) or by returning a
+** Select object equivalent to the following (the "UNION ALL" method):
+**
+**        "pLeft UNION ALL SELECT pRow"
+**
+** If the VALUES clause contains a lot of rows, this compound Select
+** object may consume a lot of memory.
+**
+** When the co-routine method is used, each row that will be returned
+** by the VALUES clause is coded into part of a co-routine as it is
+** passed to this function. The returned Select object is equivalent to:
+**
+**     SELECT * FROM (
+**       Select object to read co-routine
+**     )
+**
+** The co-routine method is used in most cases. Exceptions are:
+**
+**    a) If the current statement has a WITH clause. This is to avoid
+**       statements like:
+**
+**            WITH cte AS ( VALUES('x'), ('y') ... )
+**            SELECT * FROM cte AS a, cte AS b;
+**
+**       This will not work, as the co-routine uses a hard-coded register
+**       for its OP_Yield instructions, and so it is not possible for two
+**       cursors to iterate through it concurrently.
+**
+**    b) The schema is currently being parsed (i.e. the VALUES clause is part
+**       of a schema item like a VIEW or TRIGGER). In this case there is no VM
+**       being generated when parsing is taking place, and so generating
+**       a co-routine is not possible.
+**
+**    c) There are non-constant expressions in the VALUES clause (e.g.
+**       the VALUES clause is part of a correlated sub-query).
+**
+**    d) One or more of the values in the first row of the VALUES clause
+**       has an affinity (i.e. is a CAST expression). This causes problems
+**       because the complex rules SQLite uses (see function
+**       sqlite3SubqueryColumnTypes() in select.c) to determine the effective
+**       affinity of such a column for all rows require access to all values in
+**       the column simultaneously.
+*/
+SQLITE_PRIVATE Select *sqlite3MultiValues(Parse *pParse, Select *pLeft, ExprList *pRow){
+
+  if( pParse->bHasWith                   /* condition (a) above */
+   || pParse->db->init.busy              /* condition (b) above */
+   || exprListIsConstant(pParse,pRow)==0 /* condition (c) above */
+   || (pLeft->pSrc->nSrc==0 &&
+       exprListIsNoAffinity(pParse,pLeft->pEList)==0) /* condition (d) above */
+   || IN_SPECIAL_PARSE
+  ){
+    /* The co-routine method cannot be used. Fall back to UNION ALL. */
+    Select *pSelect = 0;
+    int f = SF_Values | SF_MultiValue;
+    if( pLeft->pSrc->nSrc ){
+      sqlite3MultiValuesEnd(pParse, pLeft);
+      f = SF_Values;
+    }else if( pLeft->pPrior ){
+      /* In this case set the SF_MultiValue flag only if it was set on pLeft */
+      f = (f & pLeft->selFlags);
+    }
+    pSelect = sqlite3SelectNew(pParse, pRow, 0, 0, 0, 0, 0, f, 0);
+    pLeft->selFlags &= ~SF_MultiValue;
+    if( pSelect ){
+      pSelect->op = TK_ALL;
+      pSelect->pPrior = pLeft;
+      pLeft = pSelect;
+    }
+  }else{
+    SrcItem *p = 0;               /* SrcItem that reads from co-routine */
+
+    if( pLeft->pSrc->nSrc==0 ){
+      /* Co-routine has not yet been started and the special Select object
+      ** that accesses the co-routine has not yet been created. This block
+      ** does both those things. */
+      Vdbe *v = sqlite3GetVdbe(pParse);
+      Select *pRet = sqlite3SelectNew(pParse, 0, 0, 0, 0, 0, 0, 0, 0);
+
+      /* Ensure the database schema has been read. This is to ensure we have
+      ** the correct text encoding.  */
+      if( (pParse->db->mDbFlags & DBFLAG_SchemaKnownOk)==0 ){
+        sqlite3ReadSchema(pParse);
+      }
+
+      if( pRet ){
+        SelectDest dest;
+        Subquery *pSubq;
+        pRet->pSrc->nSrc = 1;
+        pRet->pPrior = pLeft->pPrior;
+        pRet->op = pLeft->op;
+        if( pRet->pPrior ) pRet->selFlags |= SF_Values;
+        pLeft->pPrior = 0;
+        pLeft->op = TK_SELECT;
+        assert( pLeft->pNext==0 );
+        assert( pRet->pNext==0 );
+        p = &pRet->pSrc->a[0];
+        p->fg.viaCoroutine = 1;
+        p->iCursor = -1;
+        assert( !p->fg.isIndexedBy && !p->fg.isTabFunc );
+        p->u1.nRow = 2;
+        if( sqlite3SrcItemAttachSubquery(pParse, p, pLeft, 0) ){
+          pSubq = p->u4.pSubq;
+          pSubq->addrFillSub = sqlite3VdbeCurrentAddr(v) + 1;
+          pSubq->regReturn = ++pParse->nMem;
+          sqlite3VdbeAddOp3(v, OP_InitCoroutine,
+                            pSubq->regReturn, 0, pSubq->addrFillSub);
+          sqlite3SelectDestInit(&dest, SRT_Coroutine, pSubq->regReturn);
+
+          /* Allocate registers for the output of the co-routine. Do so so
+          ** that there are two unused registers immediately before those
+          ** used by the co-routine. This allows the code in sqlite3Insert()
+          ** to use these registers directly, instead of copying the output
+          ** of the co-routine to a separate array for processing.  */
+          dest.iSdst = pParse->nMem + 3;
+          dest.nSdst = pLeft->pEList->nExpr;
+          pParse->nMem += 2 + dest.nSdst;
+
+          pLeft->selFlags |= SF_MultiValue;
+          sqlite3Select(pParse, pLeft, &dest);
+          pSubq->regResult = dest.iSdst;
+          assert( pParse->nErr || dest.iSdst>0 );
+        }
+        pLeft = pRet;
+      }
+    }else{
+      p = &pLeft->pSrc->a[0];
+      assert( !p->fg.isTabFunc && !p->fg.isIndexedBy );
+      p->u1.nRow++;
+    }
+
+    if( pParse->nErr==0 ){
+      Subquery *pSubq;
+      assert( p!=0 );
+      assert( p->fg.isSubquery );
+      pSubq = p->u4.pSubq;
+      assert( pSubq!=0 );
+      assert( pSubq->pSelect!=0 );
+      assert( pSubq->pSelect->pEList!=0 );
+      if( pSubq->pSelect->pEList->nExpr!=pRow->nExpr ){
+        sqlite3SelectWrongNumTermsError(pParse, pSubq->pSelect);
+      }else{
+        sqlite3ExprCodeExprList(pParse, pRow, pSubq->regResult, 0, 0);
+        sqlite3VdbeAddOp1(pParse->pVdbe, OP_Yield, pSubq->regReturn);
+      }
+    }
+    sqlite3ExprListDelete(pParse->db, pRow);
+  }
+
+  return pLeft;
+}
 
 /* Forward declaration */
 static int xferOptimization(
@@ -132989,25 +134782,45 @@ SQLITE_PRIVATE void sqlite3Insert(
   if( pSelect ){
     /* Data is coming from a SELECT or from a multi-row VALUES clause.
     ** Generate a co-routine to run the SELECT. */
-    int regYield;       /* Register holding co-routine entry-point */
-    int addrTop;        /* Top of the co-routine */
     int rc;             /* Result code */
 
-    regYield = ++pParse->nMem;
-    addrTop = sqlite3VdbeCurrentAddr(v) + 1;
-    sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, addrTop);
-    sqlite3SelectDestInit(&dest, SRT_Coroutine, regYield);
-    dest.iSdst = bIdListInOrder ? regData : 0;
-    dest.nSdst = pTab->nCol;
-    rc = sqlite3Select(pParse, pSelect, &dest);
-    regFromSelect = dest.iSdst;
-    assert( db->pParse==pParse );
-    if( rc || pParse->nErr ) goto insert_cleanup;
-    assert( db->mallocFailed==0 );
-    sqlite3VdbeEndCoroutine(v, regYield);
-    sqlite3VdbeJumpHere(v, addrTop - 1);                       /* label B: */
-    assert( pSelect->pEList );
-    nColumn = pSelect->pEList->nExpr;
+    if( pSelect->pSrc->nSrc==1
+     && pSelect->pSrc->a[0].fg.viaCoroutine
+     && pSelect->pPrior==0
+    ){
+      SrcItem *pItem = &pSelect->pSrc->a[0];
+      Subquery *pSubq;
+      assert( pItem->fg.isSubquery );
+      pSubq = pItem->u4.pSubq;
+      dest.iSDParm = pSubq->regReturn;
+      regFromSelect = pSubq->regResult;
+      assert( pSubq->pSelect!=0 );
+      assert( pSubq->pSelect->pEList!=0 );
+      nColumn = pSubq->pSelect->pEList->nExpr;
+      ExplainQueryPlan((pParse, 0, "SCAN %S", pItem));
+      if( bIdListInOrder && nColumn==pTab->nCol ){
+        regData = regFromSelect;
+        regRowid = regData - 1;
+        regIns = regRowid - (IsVirtual(pTab) ? 1 : 0);
+      }
+    }else{
+      int addrTop;        /* Top of the co-routine */
+      int regYield = ++pParse->nMem;
+      addrTop = sqlite3VdbeCurrentAddr(v) + 1;
+      sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, addrTop);
+      sqlite3SelectDestInit(&dest, SRT_Coroutine, regYield);
+      dest.iSdst = bIdListInOrder ? regData : 0;
+      dest.nSdst = pTab->nCol;
+      rc = sqlite3Select(pParse, pSelect, &dest);
+      regFromSelect = dest.iSdst;
+      assert( db->pParse==pParse );
+      if( rc || pParse->nErr ) goto insert_cleanup;
+      assert( db->mallocFailed==0 );
+      sqlite3VdbeEndCoroutine(v, regYield);
+      sqlite3VdbeJumpHere(v, addrTop - 1);                       /* label B: */
+      assert( pSelect->pEList );
+      nColumn = pSelect->pEList->nExpr;
+    }
 
     /* Set useTempTable to TRUE if the result of the SELECT statement
     ** should be written into a temporary table (template 4).  Set to
@@ -133162,7 +134975,7 @@ SQLITE_PRIVATE void sqlite3Insert(
       pNx->iDataCur = iDataCur;
       pNx->iIdxCur = iIdxCur;
       if( pNx->pUpsertTarget ){
-        if( sqlite3UpsertAnalyzeTarget(pParse, pTabList, pNx) ){
+        if( sqlite3UpsertAnalyzeTarget(pParse, pTabList, pNx, pUpsert) ){
           goto insert_cleanup;
         }
       }
@@ -134903,7 +136716,7 @@ static int xferOptimization(
   if( pSelect->pSrc->nSrc!=1 ){
     return 0;   /* FROM clause must have exactly one term */
   }
-  if( pSelect->pSrc->a[0].pSelect ){
+  if( pSelect->pSrc->a[0].fg.isSubquery ){
     return 0;   /* FROM clause cannot contain a subquery */
   }
   if( pSelect->pWhere ){
@@ -135054,7 +136867,10 @@ static int xferOptimization(
     }
   }
 #ifndef SQLITE_OMIT_CHECK
-  if( pDest->pCheck && sqlite3ExprListCompare(pSrc->pCheck,pDest->pCheck,-1) ){
+  if( pDest->pCheck
+   && (db->mDbFlags & DBFLAG_Vacuum)==0
+   && sqlite3ExprListCompare(pSrc->pCheck,pDest->pCheck,-1)
+  ){
     return 0;   /* Tables have different CHECK constraints.  Ticket #2252 */
   }
 #endif
@@ -137729,6 +139545,34 @@ static const PragmaName aPragmaName[] = {
 /************** End of pragma.h **********************************************/
 /************** Continuing where we left off in pragma.c *********************/
 
+/*
+** When the 0x10 bit of PRAGMA optimize is set, any ANALYZE commands
+** will be run with an analysis_limit set to the lessor of the value of
+** the following macro or to the actual analysis_limit if it is non-zero,
+** in order to prevent PRAGMA optimize from running for too long.
+**
+** The value of 2000 is chosen emperically so that the worst-case run-time
+** for PRAGMA optimize does not exceed 100 milliseconds against a variety
+** of test databases on a RaspberryPI-4 compiled using -Os and without
+** -DSQLITE_DEBUG.  Of course, your mileage may vary.  For the purpose of
+** this paragraph, "worst-case" means that ANALYZE ends up being
+** run on every table in the database.  The worst case typically only
+** happens if PRAGMA optimize is run on a database file for which ANALYZE
+** has not been previously run and the 0x10000 flag is included so that
+** all tables are analyzed.  The usual case for PRAGMA optimize is that
+** no ANALYZE commands will be run at all, or if any ANALYZE happens it
+** will be against a single table, so that expected timing for PRAGMA
+** optimize on a PI-4 is more like 1 millisecond or less with the 0x10000
+** flag or less than 100 microseconds without the 0x10000 flag.
+**
+** An analysis limit of 2000 is almost always sufficient for the query
+** planner to fully characterize an index.  The additional accuracy from
+** a larger analysis is not usually helpful.
+*/
+#ifndef SQLITE_DEFAULT_OPTIMIZE_LIMIT
+# define SQLITE_DEFAULT_OPTIMIZE_LIMIT 2000
+#endif
+
 /*
 ** Interpret the given string as a safety level.  Return 0 for OFF,
 ** 1 for ON or NORMAL, 2 for FULL, and 3 for EXTRA.  Return 1 for an empty or
@@ -139374,7 +141218,7 @@ SQLITE_PRIVATE void sqlite3Pragma(
     /* Set the maximum error count */
     mxErr = SQLITE_INTEGRITY_CHECK_ERROR_MAX;
     if( zRight ){
-      if( sqlite3GetInt32(zRight, &mxErr) ){
+      if( sqlite3GetInt32(pValue->z, &mxErr) ){
         if( mxErr<=0 ){
           mxErr = SQLITE_INTEGRITY_CHECK_ERROR_MAX;
         }
@@ -139391,7 +141235,6 @@ SQLITE_PRIVATE void sqlite3Pragma(
       Hash *pTbls;     /* Set of all tables in the schema */
       int *aRoot;      /* Array of root page numbers of all btrees */
       int cnt = 0;     /* Number of entries in aRoot[] */
-      int mxIdx = 0;   /* Maximum number of indexes for any table */
 
       if( OMIT_TEMPDB && i==1 ) continue;
       if( iDb>=0 && i!=iDb ) continue;
@@ -139413,7 +141256,6 @@ SQLITE_PRIVATE void sqlite3Pragma(
         if( pObjTab && pObjTab!=pTab ) continue;
         if( HasRowid(pTab) ) cnt++;
         for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){ cnt++; }
-        if( nIdx>mxIdx ) mxIdx = nIdx;
       }
       if( cnt==0 ) continue;
       if( pObjTab ) cnt++;
@@ -139433,11 +141275,12 @@ SQLITE_PRIVATE void sqlite3Pragma(
       aRoot[0] = cnt;
 
       /* Make sure sufficient number of registers have been allocated */
-      sqlite3TouchRegister(pParse, 8+mxIdx);
+      sqlite3TouchRegister(pParse, 8+cnt);
+      sqlite3VdbeAddOp3(v, OP_Null, 0, 8, 8+cnt);
       sqlite3ClearTempRegCache(pParse);
 
       /* Do the b-tree integrity checks */
-      sqlite3VdbeAddOp4(v, OP_IntegrityCk, 2, cnt, 1, (char*)aRoot,P4_INTARRAY);
+      sqlite3VdbeAddOp4(v, OP_IntegrityCk, 1, cnt, 8, (char*)aRoot,P4_INTARRAY);
       sqlite3VdbeChangeP5(v, (u8)i);
       addr = sqlite3VdbeAddOp1(v, OP_IsNull, 2); VdbeCoverage(v);
       sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0,
@@ -139447,6 +141290,36 @@ SQLITE_PRIVATE void sqlite3Pragma(
       integrityCheckResultRow(v);
       sqlite3VdbeJumpHere(v, addr);
 
+      /* Check that the indexes all have the right number of rows */
+      cnt = pObjTab ? 1 : 0;
+      sqlite3VdbeLoadString(v, 2, "wrong # of entries in index ");
+      for(x=sqliteHashFirst(pTbls); x; x=sqliteHashNext(x)){
+        int iTab = 0;
+        Table *pTab = sqliteHashData(x);
+        Index *pIdx;
+        if( pObjTab && pObjTab!=pTab ) continue;
+        if( HasRowid(pTab) ){
+          iTab = cnt++;
+        }else{
+          iTab = cnt;
+          for(pIdx=pTab->pIndex; ALWAYS(pIdx); pIdx=pIdx->pNext){
+            if( IsPrimaryKeyIndex(pIdx) ) break;
+            iTab++;
+          }
+        }
+        for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
+          if( pIdx->pPartIdxWhere==0 ){
+            addr = sqlite3VdbeAddOp3(v, OP_Eq, 8+cnt, 0, 8+iTab);
+            VdbeCoverageNeverNull(v);
+            sqlite3VdbeLoadString(v, 4, pIdx->zName);
+            sqlite3VdbeAddOp3(v, OP_Concat, 4, 2, 3);
+            integrityCheckResultRow(v);
+            sqlite3VdbeJumpHere(v, addr);
+          }
+          cnt++;
+        }
+      }
+
       /* Make sure all the indices are constructed correctly.
       */
       for(x=sqliteHashFirst(pTbls); x; x=sqliteHashNext(x)){
@@ -139461,31 +141334,7 @@ SQLITE_PRIVATE void sqlite3Pragma(
         int mxCol;              /* Maximum non-virtual column number */
 
         if( pObjTab && pObjTab!=pTab ) continue;
-        if( !IsOrdinaryTable(pTab) ){
-#ifndef SQLITE_OMIT_VIRTUALTABLE
-          sqlite3_vtab *pVTab;
-          int a1;
-          if( !IsVirtual(pTab) ) continue;
-          if( pTab->nCol<=0 ){
-            const char *zMod = pTab->u.vtab.azArg[0];
-            if( sqlite3HashFind(&db->aModule, zMod)==0 ) continue;
-          }
-          sqlite3ViewGetColumnNames(pParse, pTab);
-          if( pTab->u.vtab.p==0 ) continue;
-          pVTab = pTab->u.vtab.p->pVtab;
-          if( NEVER(pVTab==0) ) continue;
-          if( NEVER(pVTab->pModule==0) ) continue;
-          if( pVTab->pModule->iVersion<4 ) continue;
-          if( pVTab->pModule->xIntegrity==0 ) continue;
-          sqlite3VdbeAddOp3(v, OP_VCheck, i, 3, isQuick);
-          pTab->nTabRef++;
-          sqlite3VdbeAppendP4(v, pTab, P4_TABLEREF);
-          a1 = sqlite3VdbeAddOp1(v, OP_IsNull, 3); VdbeCoverage(v);
-          integrityCheckResultRow(v);
-          sqlite3VdbeJumpHere(v, a1);
-#endif
-          continue;
-        }
+        if( !IsOrdinaryTable(pTab) ) continue;
         if( isQuick || HasRowid(pTab) ){
           pPk = 0;
           r2 = 0;
@@ -139620,6 +141469,7 @@ SQLITE_PRIVATE void sqlite3Pragma(
               ** is REAL, we have to load the actual data using OP_Column
               ** to reliably determine if the value is a NULL. */
               sqlite3VdbeAddOp3(v, OP_Column, p1, p3, 3);
+              sqlite3ColumnDefault(v, pTab, j, 3);
               jmp3 = sqlite3VdbeAddOp2(v, OP_NotNull, 3, labelOk);
               VdbeCoverage(v);
             }
@@ -139793,23 +141643,43 @@ SQLITE_PRIVATE void sqlite3Pragma(
         }
         sqlite3VdbeAddOp2(v, OP_Next, iDataCur, loopTop); VdbeCoverage(v);
         sqlite3VdbeJumpHere(v, loopTop-1);
-        if( !isQuick ){
-          sqlite3VdbeLoadString(v, 2, "wrong # of entries in index ");
-          for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
-            if( pPk==pIdx ) continue;
-            sqlite3VdbeAddOp2(v, OP_Count, iIdxCur+j, 3);
-            addr = sqlite3VdbeAddOp3(v, OP_Eq, 8+j, 0, 3); VdbeCoverage(v);
-            sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
-            sqlite3VdbeLoadString(v, 4, pIdx->zName);
-            sqlite3VdbeAddOp3(v, OP_Concat, 4, 2, 3);
-            integrityCheckResultRow(v);
-            sqlite3VdbeJumpHere(v, addr);
-          }
-          if( pPk ){
-            sqlite3ReleaseTempRange(pParse, r2, pPk->nKeyCol);
-          }
+        if( pPk ){
+          assert( !isQuick );
+          sqlite3ReleaseTempRange(pParse, r2, pPk->nKeyCol);
         }
       }
+
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+      /* Second pass to invoke the xIntegrity method on all virtual
+      ** tables.
+      */
+      for(x=sqliteHashFirst(pTbls); x; x=sqliteHashNext(x)){
+        Table *pTab = sqliteHashData(x);
+        sqlite3_vtab *pVTab;
+        int a1;
+        if( pObjTab && pObjTab!=pTab ) continue;
+        if( IsOrdinaryTable(pTab) ) continue;
+        if( !IsVirtual(pTab) ) continue;
+        if( pTab->nCol<=0 ){
+          const char *zMod = pTab->u.vtab.azArg[0];
+          if( sqlite3HashFind(&db->aModule, zMod)==0 ) continue;
+        }
+        sqlite3ViewGetColumnNames(pParse, pTab);
+        if( pTab->u.vtab.p==0 ) continue;
+        pVTab = pTab->u.vtab.p->pVtab;
+        if( NEVER(pVTab==0) ) continue;
+        if( NEVER(pVTab->pModule==0) ) continue;
+        if( pVTab->pModule->iVersion<4 ) continue;
+        if( pVTab->pModule->xIntegrity==0 ) continue;
+        sqlite3VdbeAddOp3(v, OP_VCheck, i, 3, isQuick);
+        pTab->nTabRef++;
+        sqlite3VdbeAppendP4(v, pTab, P4_TABLEREF);
+        a1 = sqlite3VdbeAddOp1(v, OP_IsNull, 3); VdbeCoverage(v);
+        integrityCheckResultRow(v);
+        sqlite3VdbeJumpHere(v, a1);
+        continue;
+      }
+#endif
     }
     {
       static const int iLn = VDBE_OFFSET_LINENO(2);
@@ -140073,44 +141943,63 @@ SQLITE_PRIVATE void sqlite3Pragma(
   **
   ** The optional argument is a bitmask of optimizations to perform:
   **
-  **    0x0001    Debugging mode.  Do not actually perform any optimizations
-  **              but instead return one line of text for each optimization
-  **              that would have been done.  Off by default.
+  **    0x00001    Debugging mode.  Do not actually perform any optimizations
+  **               but instead return one line of text for each optimization
+  **               that would have been done.  Off by default.
   **
-  **    0x0002    Run ANALYZE on tables that might benefit.  On by default.
-  **              See below for additional information.
+  **    0x00002    Run ANALYZE on tables that might benefit.  On by default.
+  **               See below for additional information.
   **
-  **    0x0004    (Not yet implemented) Record usage and performance
-  **              information from the current session in the
-  **              database file so that it will be available to "optimize"
-  **              pragmas run by future database connections.
+  **    0x00010    Run all ANALYZE operations using an analysis_limit that
+  **               is the lessor of the current analysis_limit and the
+  **               SQLITE_DEFAULT_OPTIMIZE_LIMIT compile-time option.
+  **               The default value of SQLITE_DEFAULT_OPTIMIZE_LIMIT is
+  **               currently (2024-02-19) set to 2000, which is such that
+  **               the worst case run-time for PRAGMA optimize on a 100MB
+  **               database will usually be less than 100 milliseconds on
+  **               a RaspberryPI-4 class machine.  On by default.
   **
-  **    0x0008    (Not yet implemented) Create indexes that might have
-  **              been helpful to recent queries
+  **    0x10000    Look at tables to see if they need to be reanalyzed
+  **               due to growth or shrinkage even if they have not been
+  **               queried during the current connection.  Off by default.
   **
-  ** The default MASK is and always shall be 0xfffe.  0xfffe means perform all
-  ** of the optimizations listed above except Debug Mode, including new
-  ** optimizations that have not yet been invented.  If new optimizations are
-  ** ever added that should be off by default, those off-by-default
-  ** optimizations will have bitmasks of 0x10000 or larger.
+  ** The default MASK is and always shall be 0x0fffe.  In the current
+  ** implementation, the default mask only covers the 0x00002 optimization,
+  ** though additional optimizations that are covered by 0x0fffe might be
+  ** added in the future.  Optimizations that are off by default and must
+  ** be explicitly requested have masks of 0x10000 or greater.
   **
   ** DETERMINATION OF WHEN TO RUN ANALYZE
   **
   ** In the current implementation, a table is analyzed if only if all of
   ** the following are true:
   **
-  ** (1) MASK bit 0x02 is set.
+  ** (1) MASK bit 0x00002 is set.
   **
-  ** (2) The query planner used sqlite_stat1-style statistics for one or
-  **     more indexes of the table at some point during the lifetime of
-  **     the current connection.
+  ** (2) The table is an ordinary table, not a virtual table or view.
   **
-  ** (3) One or more indexes of the table are currently unanalyzed OR
-  **     the number of rows in the table has increased by 25 times or more
-  **     since the last time ANALYZE was run.
+  ** (3) The table name does not begin with "sqlite_".
+  **
+  ** (4) One or more of the following is true:
+  **      (4a) The 0x10000 MASK bit is set.
+  **      (4b) One or more indexes on the table lacks an entry
+  **           in the sqlite_stat1 table.
+  **      (4c) The query planner used sqlite_stat1-style statistics for one
+  **           or more indexes of the table at some point during the lifetime
+  **           of the current connection.
+  **
+  ** (5) One or more of the following is true:
+  **      (5a) One or more indexes on the table lacks an entry
+  **           in the sqlite_stat1 table.  (Same as 4a)
+  **      (5b) The number of rows in the table has increased or decreased by
+  **           10-fold.  In other words, the current size of the table is
+  **           10 times larger than the size in sqlite_stat1 or else the
+  **           current size is less than 1/10th the size in sqlite_stat1.
   **
   ** The rules for when tables are analyzed are likely to change in
-  ** future releases.
+  ** future releases.  Future versions of SQLite might accept a string
+  ** literal argument to this pragma that contains a mnemonic description
+  ** of the options rather than a bitmap.
   */
   case PragTyp_OPTIMIZE: {
     int iDbLast;           /* Loop termination point for the schema loop */
@@ -140122,6 +142011,10 @@ SQLITE_PRIVATE void sqlite3Pragma(
     LogEst szThreshold;    /* Size threshold above which reanalysis needed */
     char *zSubSql;         /* SQL statement for the OP_SqlExec opcode */
     u32 opMask;            /* Mask of operations to perform */
+    int nLimit;            /* Analysis limit to use */
+    int nCheck = 0;        /* Number of tables to be optimized */
+    int nBtree = 0;        /* Number of btrees to scan */
+    int nIndex;            /* Number of indexes on the current table */
 
     if( zRight ){
       opMask = (u32)sqlite3Atoi(zRight);
@@ -140129,6 +142022,14 @@ SQLITE_PRIVATE void sqlite3Pragma(
     }else{
       opMask = 0xfffe;
     }
+    if( (opMask & 0x10)==0 ){
+      nLimit = 0;
+    }else if( db->nAnalysisLimit>0
+           && db->nAnalysisLimit<SQLITE_DEFAULT_OPTIMIZE_LIMIT ){
+      nLimit = 0;
+    }else{
+      nLimit = SQLITE_DEFAULT_OPTIMIZE_LIMIT;
+    }
     iTabCur = pParse->nTab++;
     for(iDbLast = zDb?iDb:db->nDb-1; iDb<=iDbLast; iDb++){
       if( iDb==1 ) continue;
@@ -140137,23 +142038,61 @@ SQLITE_PRIVATE void sqlite3Pragma(
       for(k=sqliteHashFirst(&pSchema->tblHash); k; k=sqliteHashNext(k)){
         pTab = (Table*)sqliteHashData(k);
 
-        /* If table pTab has not been used in a way that would benefit from
-        ** having analysis statistics during the current session, then skip it.
-        ** This also has the effect of skipping virtual tables and views */
-        if( (pTab->tabFlags & TF_StatsUsed)==0 ) continue;
+        /* This only works for ordinary tables */
+        if( !IsOrdinaryTable(pTab) ) continue;
 
-        /* Reanalyze if the table is 25 times larger than the last analysis */
-        szThreshold = pTab->nRowLogEst + 46; assert( sqlite3LogEst(25)==46 );
+        /* Do not scan system tables */
+        if( 0==sqlite3StrNICmp(pTab->zName, "sqlite_", 7) ) continue;
+
+        /* Find the size of the table as last recorded in sqlite_stat1.
+        ** If any index is unanalyzed, then the threshold is -1 to
+        ** indicate a new, unanalyzed index
+        */
+        szThreshold = pTab->nRowLogEst;
+        nIndex = 0;
         for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
+          nIndex++;
           if( !pIdx->hasStat1 ){
-            szThreshold = 0; /* Always analyze if any index lacks statistics */
-            break;
+            szThreshold = -1; /* Always analyze if any index lacks statistics */
           }
         }
-        if( szThreshold ){
-          sqlite3OpenTable(pParse, iTabCur, iDb, pTab, OP_OpenRead);
-          sqlite3VdbeAddOp3(v, OP_IfSmaller, iTabCur,
-                         sqlite3VdbeCurrentAddr(v)+2+(opMask&1), szThreshold);
+
+        /* If table pTab has not been used in a way that would benefit from
+        ** having analysis statistics during the current session, then skip it,
+        ** unless the 0x10000 MASK bit is set. */
+        if( (pTab->tabFlags & TF_MaybeReanalyze)!=0 ){
+          /* Check for size change if stat1 has been used for a query */
+        }else if( opMask & 0x10000 ){
+          /* Check for size change if 0x10000 is set */
+        }else if( pTab->pIndex!=0 && szThreshold<0 ){
+          /* Do analysis if unanalyzed indexes exists */
+        }else{
+          /* Otherwise, we can skip this table */
+          continue;
+        }
+
+        nCheck++;
+        if( nCheck==2 ){
+          /* If ANALYZE might be invoked two or more times, hold a write
+          ** transaction for efficiency */
+          sqlite3BeginWriteOperation(pParse, 0, iDb);
+        }
+        nBtree += nIndex+1;
+
+        /* Reanalyze if the table is 10 times larger or smaller than
+        ** the last analysis.  Unconditional reanalysis if there are
+        ** unanalyzed indexes. */
+        sqlite3OpenTable(pParse, iTabCur, iDb, pTab, OP_OpenRead);
+        if( szThreshold>=0 ){
+          const LogEst iRange = 33;   /* 10x size change */
+          sqlite3VdbeAddOp4Int(v, OP_IfSizeBetween, iTabCur,
+                         sqlite3VdbeCurrentAddr(v)+2+(opMask&1),
+                         szThreshold>=iRange ? szThreshold-iRange : -1,
+                         szThreshold+iRange);
+          VdbeCoverage(v);
+        }else{
+          sqlite3VdbeAddOp2(v, OP_Rewind, iTabCur,
+                         sqlite3VdbeCurrentAddr(v)+2+(opMask&1));
           VdbeCoverage(v);
         }
         zSubSql = sqlite3MPrintf(db, "ANALYZE \"%w\".\"%w\"",
@@ -140163,11 +142102,27 @@ SQLITE_PRIVATE void sqlite3Pragma(
           sqlite3VdbeAddOp4(v, OP_String8, 0, r1, 0, zSubSql, P4_DYNAMIC);
           sqlite3VdbeAddOp2(v, OP_ResultRow, r1, 1);
         }else{
-          sqlite3VdbeAddOp4(v, OP_SqlExec, 0, 0, 0, zSubSql, P4_DYNAMIC);
+          sqlite3VdbeAddOp4(v, OP_SqlExec, nLimit ? 0x02 : 00, nLimit, 0,
+                            zSubSql, P4_DYNAMIC);
         }
       }
     }
     sqlite3VdbeAddOp0(v, OP_Expire);
+
+    /* In a schema with a large number of tables and indexes, scale back
+    ** the analysis_limit to avoid excess run-time in the worst case.
+    */
+    if( !db->mallocFailed && nLimit>0 && nBtree>100 ){
+      int iAddr, iEnd;
+      VdbeOp *aOp;
+      nLimit = 100*nLimit/nBtree;
+      if( nLimit<100 ) nLimit = 100;
+      aOp = sqlite3VdbeGetOp(v, 0);
+      iEnd = sqlite3VdbeCurrentAddr(v);
+      for(iAddr=0; iAddr<iEnd; iAddr++){
+        if( aOp[iAddr].opcode==OP_SqlExec ) aOp[iAddr].p2 = nLimit;
+      }
+    }
     break;
   }
 
@@ -140431,9 +142386,9 @@ static int pragmaVtabBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
   seen[0] = 0;
   seen[1] = 0;
   for(i=0; i<pIdxInfo->nConstraint; i++, pConstraint++){
-    if( pConstraint->usable==0 ) continue;
-    if( pConstraint->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue;
     if( pConstraint->iColumn < pTab->iHidden ) continue;
+    if( pConstraint->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue;
+    if( pConstraint->usable==0 ) return SQLITE_CONSTRAINT;
     j = pConstraint->iColumn - pTab->iHidden;
     assert( j < 2 );
     seen[j] = i+1;
@@ -140446,12 +142401,13 @@ static int pragmaVtabBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
   j = seen[0]-1;
   pIdxInfo->aConstraintUsage[j].argvIndex = 1;
   pIdxInfo->aConstraintUsage[j].omit = 1;
-  if( seen[1]==0 ) return SQLITE_OK;
   pIdxInfo->estimatedCost = (double)20;
   pIdxInfo->estimatedRows = 20;
-  j = seen[1]-1;
-  pIdxInfo->aConstraintUsage[j].argvIndex = 2;
-  pIdxInfo->aConstraintUsage[j].omit = 1;
+  if( seen[1] ){
+    j = seen[1]-1;
+    pIdxInfo->aConstraintUsage[j].argvIndex = 2;
+    pIdxInfo->aConstraintUsage[j].omit = 1;
+  }
   return SQLITE_OK;
 }
 
@@ -140471,6 +142427,7 @@ static void pragmaVtabCursorClear(PragmaVtabCursor *pCsr){
   int i;
   sqlite3_finalize(pCsr->pPragma);
   pCsr->pPragma = 0;
+  pCsr->iRowid = 0;
   for(i=0; i<ArraySize(pCsr->azArg); i++){
     sqlite3_free(pCsr->azArg[i]);
     pCsr->azArg[i] = 0;
@@ -141271,7 +143228,13 @@ SQLITE_PRIVATE void *sqlite3ParserAddCleanup(
   void (*xCleanup)(sqlite3*,void*),   /* The cleanup routine */
   void *pPtr                          /* Pointer to object to be cleaned up */
 ){
-  ParseCleanup *pCleanup = sqlite3DbMallocRaw(pParse->db, sizeof(*pCleanup));
+  ParseCleanup *pCleanup;
+  if( sqlite3FaultSim(300) ){
+    pCleanup = 0;
+    sqlite3OomFault(pParse->db);
+  }else{
+    pCleanup = sqlite3DbMallocRaw(pParse->db, sizeof(*pCleanup));
+  }
   if( pCleanup ){
     pCleanup->pNext = pParse->pCleanup;
     pParse->pCleanup = pCleanup;
@@ -141639,12 +143602,24 @@ static int sqlite3Prepare16(
   if( !sqlite3SafetyCheckOk(db)||zSql==0 ){
     return SQLITE_MISUSE_BKPT;
   }
+
+  /* Make sure nBytes is non-negative and correct.  It should be the
+  ** number of bytes until the end of the input buffer or until the first
+  ** U+0000 character.  If the input nBytes is odd, convert it into
+  ** an even number.  If the input nBytes is negative, then the input
+  ** must be terminated by at least one U+0000 character */
   if( nBytes>=0 ){
     int sz;
     const char *z = (const char*)zSql;
     for(sz=0; sz<nBytes && (z[sz]!=0 || z[sz+1]!=0); sz += 2){}
     nBytes = sz;
+  }else{
+    int sz;
+    const char *z = (const char*)zSql;
+    for(sz=0; z[sz]!=0 || z[sz+1]!=0; sz += 2){}
+    nBytes = sz;
   }
+
   sqlite3_mutex_enter(db->mutex);
   zSql8 = sqlite3Utf16to8(db, zSql, nBytes, SQLITE_UTF16NATIVE);
   if( zSql8 ){
@@ -141658,7 +143633,7 @@ static int sqlite3Prepare16(
     ** the same number of characters into the UTF-16 string.
     */
     int chars_parsed = sqlite3Utf8CharLen(zSql8, (int)(zTail8-zSql8));
-    *pzTail = (u8 *)zSql + sqlite3Utf16ByteLen(zSql, chars_parsed);
+    *pzTail = (u8 *)zSql + sqlite3Utf16ByteLen(zSql, nBytes, chars_parsed);
   }
   sqlite3DbFree(db, zSql8);
   rc = sqlite3ApiExit(db, rc);
@@ -142052,11 +144027,13 @@ SQLITE_PRIVATE int sqlite3ColumnIndex(Table *pTab, const char *zCol){
 */
 SQLITE_PRIVATE void sqlite3SrcItemColumnUsed(SrcItem *pItem, int iCol){
   assert( pItem!=0 );
-  assert( (int)pItem->fg.isNestedFrom == IsNestedFrom(pItem->pSelect) );
+  assert( (int)pItem->fg.isNestedFrom == IsNestedFrom(pItem) );
   if( pItem->fg.isNestedFrom ){
     ExprList *pResults;
-    assert( pItem->pSelect!=0 );
-    pResults = pItem->pSelect->pEList;
+    assert( pItem->fg.isSubquery );
+    assert( pItem->u4.pSubq!=0 );
+    assert( pItem->u4.pSubq->pSelect!=0 );
+    pResults = pItem->u4.pSubq->pSelect->pEList;
     assert( pResults!=0 );
     assert( iCol>=0 && iCol<pResults->nExpr );
     pResults->a[iCol].fg.bUsed = 1;
@@ -142090,9 +144067,9 @@ static int tableAndColumnIndex(
   assert( (piTab==0)==(piCol==0) );  /* Both or neither are NULL */
 
   for(i=iStart; i<=iEnd; i++){
-    iCol = sqlite3ColumnIndex(pSrc->a[i].pTab, zCol);
+    iCol = sqlite3ColumnIndex(pSrc->a[i].pSTab, zCol);
     if( iCol>=0
-     && (bIgnoreHidden==0 || IsHiddenColumn(&pSrc->a[i].pTab->aCol[iCol])==0)
+     && (bIgnoreHidden==0 || IsHiddenColumn(&pSrc->a[i].pSTab->aCol[iCol])==0)
     ){
       if( piTab ){
         sqlite3SrcItemColumnUsed(&pSrc->a[i], iCol);
@@ -142221,10 +144198,10 @@ static int sqlite3ProcessJoin(Parse *pParse, Select *p){
   pLeft = &pSrc->a[0];
   pRight = &pLeft[1];
   for(i=0; i<pSrc->nSrc-1; i++, pRight++, pLeft++){
-    Table *pRightTab = pRight->pTab;
+    Table *pRightTab = pRight->pSTab;
     u32 joinType;
 
-    if( NEVER(pLeft->pTab==0 || pRightTab==0) ) continue;
+    if( NEVER(pLeft->pSTab==0 || pRightTab==0) ) continue;
     joinType = (pRight->fg.jointype & JT_OUTER)!=0 ? EP_OuterON : EP_InnerON;
 
     /* If this is a NATURAL join, synthesize an appropriate USING clause
@@ -143097,12 +145074,18 @@ static void selectInnerLoop(
         ** case the order does matter */
         pushOntoSorter(
             pParse, pSort, p, regResult, regOrig, nResultCol, nPrefixReg);
+        pDest->iSDParm2 = 0; /* Signal that any Bloom filter is unpopulated */
       }else{
         int r1 = sqlite3GetTempReg(pParse);
         assert( sqlite3Strlen30(pDest->zAffSdst)==nResultCol );
         sqlite3VdbeAddOp4(v, OP_MakeRecord, regResult, nResultCol,
             r1, pDest->zAffSdst, nResultCol);
         sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, regResult, nResultCol);
+        if( pDest->iSDParm2 ){
+          sqlite3VdbeAddOp4Int(v, OP_FilterAdd, pDest->iSDParm2, 0,
+                               regResult, nResultCol);
+          ExplainQueryPlan((pParse, 0, "CREATE BLOOM FILTER"));
+        }
         sqlite3ReleaseTempReg(pParse, r1);
       }
       break;
@@ -143393,9 +145376,16 @@ static void generateSortTail(
   int addrExplain;                /* Address of OP_Explain instruction */
 #endif
 
-  ExplainQueryPlan2(addrExplain, (pParse, 0,
-        "USE TEMP B-TREE FOR %sORDER BY", pSort->nOBSat>0?"RIGHT PART OF ":"")
-  );
+  nKey = pOrderBy->nExpr - pSort->nOBSat;
+  if( pSort->nOBSat==0 || nKey==1 ){
+    ExplainQueryPlan2(addrExplain, (pParse, 0,
+      "USE TEMP B-TREE FOR %sORDER BY", pSort->nOBSat?"LAST TERM OF ":""
+    ));
+  }else{
+    ExplainQueryPlan2(addrExplain, (pParse, 0,
+      "USE TEMP B-TREE FOR LAST %d TERMS OF ORDER BY", nKey
+    ));
+  }
   sqlite3VdbeScanStatusRange(v, addrExplain,pSort->addrPush,pSort->addrPushEnd);
   sqlite3VdbeScanStatusCounters(v, addrExplain, addrExplain, pSort->addrPush);
 
@@ -143433,7 +145423,6 @@ static void generateSortTail(
       regRow = sqlite3GetTempRange(pParse, nColumn);
     }
   }
-  nKey = pOrderBy->nExpr - pSort->nOBSat;
   if( pSort->sortFlags & SORTFLAG_UseSorter ){
     int regSortOut = ++pParse->nMem;
     iSortTab = pParse->nTab++;
@@ -143638,8 +145627,12 @@ static const char *columnTypeImpl(
         SrcList *pTabList = pNC->pSrcList;
         for(j=0;j<pTabList->nSrc && pTabList->a[j].iCursor!=pExpr->iTable;j++);
         if( j<pTabList->nSrc ){
-          pTab = pTabList->a[j].pTab;
-          pS = pTabList->a[j].pSelect;
+          pTab = pTabList->a[j].pSTab;
+          if( pTabList->a[j].fg.isSubquery ){
+            pS = pTabList->a[j].u4.pSubq->pSelect;
+          }else{
+            pS = 0;
+          }
         }else{
           pNC = pNC->pNext;
         }
@@ -143673,11 +145666,7 @@ static const char *columnTypeImpl(
         ** data for the result-set column of the sub-select.
         */
         if( iCol<pS->pEList->nExpr
-#ifdef SQLITE_ALLOW_ROWID_IN_VIEW
-         && iCol>=0
-#else
-         && ALWAYS(iCol>=0)
-#endif
+         && (!ViewCanHaveRowid || iCol>=0)
         ){
           /* If iCol is less than zero, then the expression requests the
           ** rowid of the sub-select or view. This expression is legal (see
@@ -144042,8 +146031,7 @@ SQLITE_PRIVATE void sqlite3SubqueryColumnTypes(
   NameContext sNC;
 
   assert( pSelect!=0 );
-  testcase( (pSelect->selFlags & SF_Resolved)==0 );
-  assert( (pSelect->selFlags & SF_Resolved)!=0 || IN_RENAME_OBJECT );
+  assert( (pSelect->selFlags & SF_Resolved)!=0 );
   assert( pTab->nCol==pSelect->pEList->nExpr || pParse->nErr>0 );
   assert( aff==SQLITE_AFF_NONE || aff==SQLITE_AFF_BLOB );
   if( db->mallocFailed || IN_RENAME_OBJECT ) return;
@@ -144054,17 +146042,22 @@ SQLITE_PRIVATE void sqlite3SubqueryColumnTypes(
   for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
     const char *zType;
     i64 n;
+    int m = 0;
+    Select *pS2 = pSelect;
     pTab->tabFlags |= (pCol->colFlags & COLFLAG_NOINSERT);
     p = a[i].pExpr;
     /* pCol->szEst = ... // Column size est for SELECT tables never used */
     pCol->affinity = sqlite3ExprAffinity(p);
+    while( pCol->affinity<=SQLITE_AFF_NONE && pS2->pNext!=0 ){
+      m |= sqlite3ExprDataType(pS2->pEList->a[i].pExpr);
+      pS2 = pS2->pNext;
+      pCol->affinity = sqlite3ExprAffinity(pS2->pEList->a[i].pExpr);
+    }
     if( pCol->affinity<=SQLITE_AFF_NONE ){
       pCol->affinity = aff;
     }
-    if( pCol->affinity>=SQLITE_AFF_TEXT && pSelect->pNext ){
-      int m = 0;
-      Select *pS2;
-      for(m=0, pS2=pSelect->pNext; pS2; pS2=pS2->pNext){
+    if( pCol->affinity>=SQLITE_AFF_TEXT && (pS2->pNext || pS2!=pSelect) ){
+      for(pS2=pS2->pNext; pS2; pS2=pS2->pNext){
         m |= sqlite3ExprDataType(pS2->pEList->a[i].pExpr);
       }
       if( pCol->affinity==SQLITE_AFF_TEXT && (m&0x01)!=0 ){
@@ -144094,12 +146087,12 @@ SQLITE_PRIVATE void sqlite3SubqueryColumnTypes(
       }
     }
     if( zType ){
-      i64 m = sqlite3Strlen30(zType);
+      const i64 k = sqlite3Strlen30(zType);
       n = sqlite3Strlen30(pCol->zCnName);
-      pCol->zCnName = sqlite3DbReallocOrFree(db, pCol->zCnName, n+m+2);
+      pCol->zCnName = sqlite3DbReallocOrFree(db, pCol->zCnName, n+k+2);
       pCol->colFlags &= ~(COLFLAG_HASTYPE|COLFLAG_HASCOLL);
       if( pCol->zCnName ){
-        memcpy(&pCol->zCnName[n+1], zType, m+1);
+        memcpy(&pCol->zCnName[n+1], zType, k+1);
         pCol->colFlags |= COLFLAG_HASTYPE;
       }
     }
@@ -144206,7 +146199,7 @@ static void computeLimitRegisters(Parse *pParse, Select *p, int iBreak){
     p->iLimit = iLimit = ++pParse->nMem;
     v = sqlite3GetVdbe(pParse);
     assert( v!=0 );
-    if( sqlite3ExprIsInteger(pLimit->pLeft, &n) ){
+    if( sqlite3ExprIsInteger(pLimit->pLeft, &n, pParse) ){
       sqlite3VdbeAddOp2(v, OP_Integer, n, iLimit);
       VdbeComment((v, "LIMIT counter"));
       if( n==0 ){
@@ -144686,7 +146679,7 @@ static int multiSelect(
         p->pPrior = pPrior;
         p->nSelectRow = sqlite3LogEstAdd(p->nSelectRow, pPrior->nSelectRow);
         if( p->pLimit
-         && sqlite3ExprIsInteger(p->pLimit->pLeft, &nLimit)
+         && sqlite3ExprIsInteger(p->pLimit->pLeft, &nLimit, pParse)
          && nLimit>0 && p->nSelectRow > sqlite3LogEst((u64)nLimit)
         ){
           p->nSelectRow = sqlite3LogEst((u64)nLimit);
@@ -145030,6 +147023,11 @@ static int generateOutputSubroutine(
           r1, pDest->zAffSdst, pIn->nSdst);
       sqlite3VdbeAddOp4Int(v, OP_IdxInsert, pDest->iSDParm, r1,
                            pIn->iSdst, pIn->nSdst);
+      if( pDest->iSDParm2>0 ){
+        sqlite3VdbeAddOp4Int(v, OP_FilterAdd, pDest->iSDParm2, 0,
+                             pIn->iSdst, pIn->nSdst);
+        ExplainQueryPlan((pParse, 0, "CREATE BLOOM FILTER"));
+      }
       sqlite3ReleaseTempReg(pParse, r1);
       break;
     }
@@ -145686,7 +147684,9 @@ static void substSelect(
     pSrc = p->pSrc;
     assert( pSrc!=0 );
     for(i=pSrc->nSrc, pItem=pSrc->a; i>0; i--, pItem++){
-      substSelect(pSubst, pItem->pSelect, 1);
+      if( pItem->fg.isSubquery ){
+        substSelect(pSubst, pItem->u4.pSubq->pSelect, 1);
+      }
       if( pItem->fg.isTabFunc ){
         substExprList(pSubst, pItem->u1.pFuncArg);
       }
@@ -145717,7 +147717,7 @@ static void recomputeColumnsUsed(
   SrcItem *pSrcItem                /* Which FROM clause item to recompute */
 ){
   Walker w;
-  if( NEVER(pSrcItem->pTab==0) ) return;
+  if( NEVER(pSrcItem->pSTab==0) ) return;
   memset(&w, 0, sizeof(w));
   w.xExprCallback = recomputeColumnsUsedExpr;
   w.xSelectCallback = sqlite3SelectWalkNoop;
@@ -145757,8 +147757,10 @@ static void srclistRenumberCursors(
         aCsrMap[pItem->iCursor+1] = pParse->nTab++;
       }
       pItem->iCursor = aCsrMap[pItem->iCursor+1];
-      for(p=pItem->pSelect; p; p=p->pPrior){
-        srclistRenumberCursors(pParse, aCsrMap, p->pSrc, -1);
+      if( pItem->fg.isSubquery ){
+        for(p=pItem->u4.pSubq->pSelect; p; p=p->pPrior){
+          srclistRenumberCursors(pParse, aCsrMap, p->pSrc, -1);
+        }
       }
     }
   }
@@ -146069,7 +148071,8 @@ static int flattenSubquery(
   assert( pSrc && iFrom>=0 && iFrom<pSrc->nSrc );
   pSubitem = &pSrc->a[iFrom];
   iParent = pSubitem->iCursor;
-  pSub = pSubitem->pSelect;
+  assert( pSubitem->fg.isSubquery );
+  pSub = pSubitem->u4.pSubq->pSelect;
   assert( pSub!=0 );
 
 #ifndef SQLITE_OMIT_WINDOWFUNC
@@ -146122,7 +148125,7 @@ static int flattenSubquery(
   */
   if( (pSubitem->fg.jointype & (JT_OUTER|JT_LTORJ))!=0 ){
     if( pSubSrc->nSrc>1                        /* (3a) */
-     || IsVirtual(pSubSrc->a[0].pTab)          /* (3b) */
+     || IsVirtual(pSubSrc->a[0].pSTab)         /* (3b) */
      || (p->selFlags & SF_Distinct)!=0         /* (3d) */
      || (pSubitem->fg.jointype & JT_RIGHT)!=0  /* (26) */
     ){
@@ -146208,14 +148211,18 @@ static int flattenSubquery(
   pParse->zAuthContext = zSavedAuthContext;
 
   /* Delete the transient structures associated with the subquery */
-  pSub1 = pSubitem->pSelect;
-  sqlite3DbFree(db, pSubitem->zDatabase);
+
+  if( ALWAYS(pSubitem->fg.isSubquery) ){
+    pSub1 = sqlite3SubqueryDetach(db, pSubitem);
+  }else{
+    pSub1 = 0;
+  }
+  assert( pSubitem->fg.isSubquery==0 );
+  assert( pSubitem->fg.fixedSchema==0 );
   sqlite3DbFree(db, pSubitem->zName);
   sqlite3DbFree(db, pSubitem->zAlias);
-  pSubitem->zDatabase = 0;
   pSubitem->zName = 0;
   pSubitem->zAlias = 0;
-  pSubitem->pSelect = 0;
   assert( pSubitem->fg.isUsing!=0 || pSubitem->u3.pOn==0 );
 
   /* If the sub-query is a compound SELECT statement, then (by restrictions
@@ -146256,8 +148263,8 @@ static int flattenSubquery(
     ExprList *pOrderBy = p->pOrderBy;
     Expr *pLimit = p->pLimit;
     Select *pPrior = p->pPrior;
-    Table *pItemTab = pSubitem->pTab;
-    pSubitem->pTab = 0;
+    Table *pItemTab = pSubitem->pSTab;
+    pSubitem->pSTab = 0;
     p->pOrderBy = 0;
     p->pPrior = 0;
     p->pLimit = 0;
@@ -146265,7 +148272,7 @@ static int flattenSubquery(
     p->pLimit = pLimit;
     p->pOrderBy = pOrderBy;
     p->op = TK_ALL;
-    pSubitem->pTab = pItemTab;
+    pSubitem->pSTab = pItemTab;
     if( pNew==0 ){
       p->pPrior = pPrior;
     }else{
@@ -146280,11 +148287,14 @@ static int flattenSubquery(
       TREETRACE(0x4,pParse,p,("compound-subquery flattener"
                               " creates %u as peer\n",pNew->selId));
     }
-    assert( pSubitem->pSelect==0 );
+    assert( pSubitem->fg.isSubquery==0 );
   }
   sqlite3DbFree(db, aCsrMap);
   if( db->mallocFailed ){
-    pSubitem->pSelect = pSub1;
+    assert( pSubitem->fg.fixedSchema==0 );
+    assert( pSubitem->fg.isSubquery==0 );
+    assert( pSubitem->u4.zDatabase==0 );
+    sqlite3SrcItemAttachSubquery(pParse, pSubitem, pSub1, 0);
     return 1;
   }
 
@@ -146295,8 +148305,8 @@ static int flattenSubquery(
   **
   ** pSubitem->pTab is always non-NULL by test restrictions and tests above.
   */
-  if( ALWAYS(pSubitem->pTab!=0) ){
-    Table *pTabToDel = pSubitem->pTab;
+  if( ALWAYS(pSubitem->pSTab!=0) ){
+    Table *pTabToDel = pSubitem->pSTab;
     if( pTabToDel->nTabRef==1 ){
       Parse *pToplevel = sqlite3ParseToplevel(pParse);
       sqlite3ParserAddCleanup(pToplevel, sqlite3DeleteTableGeneric, pTabToDel);
@@ -146304,7 +148314,7 @@ static int flattenSubquery(
     }else{
       pTabToDel->nTabRef--;
     }
-    pSubitem->pTab = 0;
+    pSubitem->pSTab = 0;
   }
 
   /* The following loop runs once for each term in a compound-subquery
@@ -146360,8 +148370,11 @@ static int flattenSubquery(
     */
     for(i=0; i<nSubSrc; i++){
       SrcItem *pItem = &pSrc->a[i+iFrom];
-      if( pItem->fg.isUsing ) sqlite3IdListDelete(db, pItem->u3.pUsing);
       assert( pItem->fg.isTabFunc==0 );
+      assert( pItem->fg.isSubquery
+           || pItem->fg.fixedSchema
+           || pItem->u4.zDatabase==0 );
+      if( pItem->fg.isUsing ) sqlite3IdListDelete(db, pItem->u3.pUsing);
       *pItem = pSubSrc->a[i];
       pItem->fg.jointype |= ltorj;
       iNewParent = pSubSrc->a[i].iCursor;
@@ -146496,7 +148509,7 @@ static void constInsert(
 ){
   int i;
   assert( pColumn->op==TK_COLUMN );
-  assert( sqlite3ExprIsConstant(pValue) );
+  assert( sqlite3ExprIsConstant(pConst->pParse, pValue) );
 
   if( ExprHasProperty(pColumn, EP_FixedCol) ) return;
   if( sqlite3ExprAffinity(pValue)!=0 ) return;
@@ -146554,10 +148567,10 @@ static void findConstInWhere(WhereConst *pConst, Expr *pExpr){
   pLeft = pExpr->pLeft;
   assert( pRight!=0 );
   assert( pLeft!=0 );
-  if( pRight->op==TK_COLUMN && sqlite3ExprIsConstant(pLeft) ){
+  if( pRight->op==TK_COLUMN && sqlite3ExprIsConstant(pConst->pParse, pLeft) ){
     constInsert(pConst,pRight,pLeft,pExpr);
   }
-  if( pLeft->op==TK_COLUMN && sqlite3ExprIsConstant(pRight) ){
+  if( pLeft->op==TK_COLUMN && sqlite3ExprIsConstant(pConst->pParse, pRight) ){
     constInsert(pConst,pLeft,pRight,pExpr);
   }
 }
@@ -146778,6 +148791,19 @@ static int pushDownWindowCheck(Parse *pParse, Select *pSubq, Expr *pExpr){
 ** The hope is that the terms added to the inner query will make it more
 ** efficient.
 **
+** NAME AMBIGUITY
+**
+** This optimization is called the "WHERE-clause push-down optimization"
+** or sometimes the "predicate push-down optimization".
+**
+** Do not confuse this optimization with another unrelated optimization
+** with a similar name:  The "MySQL push-down optimization" causes WHERE
+** clause terms that can be evaluated using only the index and without
+** reference to the table are run first, so that if they are false,
+** unnecessary table seeks are avoided.
+**
+** RULES
+**
 ** Do not attempt this optimization if:
 **
 **   (1) (** This restriction was removed on 2017-09-29.  We used to
@@ -146843,15 +148869,19 @@ static int pushDownWindowCheck(Parse *pParse, Select *pSubq, Expr *pExpr){
 **       (9c) There is a RIGHT JOIN (or FULL JOIN) in between the ON/USING
 **            clause and the subquery.
 **
-**       Without this restriction, the push-down optimization might move
-**       the ON/USING filter expression from the left side of a RIGHT JOIN
-**       over to the right side, which leads to incorrect answers.  See
-**       also restriction (6) in sqlite3ExprIsSingleTableConstraint().
+**       Without this restriction, the WHERE-clause push-down optimization
+**       might move the ON/USING filter expression from the left side of a
+**       RIGHT JOIN over to the right side, which leads to incorrect answers.
+**       See also restriction (6) in sqlite3ExprIsSingleTableConstraint().
 **
 **  (10) The inner query is not the right-hand table of a RIGHT JOIN.
 **
 **  (11) The subquery is not a VALUES clause
 **
+**  (12) The WHERE clause is not "rowid ISNULL" or the equivalent.  This
+**       case only comes up if SQLite is compiled using
+**       SQLITE_ALLOW_ROWID_IN_VIEW.
+**
 ** Return 0 if no changes are made and non-zero if one or more WHERE clause
 ** terms are duplicated into the subquery.
 */
@@ -146962,7 +148992,19 @@ static int pushDownWhereTerms(
   }
 #endif
 
-  if( sqlite3ExprIsSingleTableConstraint(pWhere, pSrcList, iSrc) ){
+#ifdef SQLITE_ALLOW_ROWID_IN_VIEW
+  if( ViewCanHaveRowid && (pWhere->op==TK_ISNULL || pWhere->op==TK_NOTNULL) ){
+    Expr *pLeft = pWhere->pLeft;
+    if( ALWAYS(pLeft)
+     && pLeft->op==TK_COLUMN
+     && pLeft->iColumn < 0
+    ){
+      return 0;  /* Restriction (12) */
+    }
+  }
+#endif
+
+  if( sqlite3ExprIsSingleTableConstraint(pWhere, pSrcList, iSrc, 1) ){
     nChng++;
     pSubq->selFlags |= SF_PushDown;
     while( pSubq ){
@@ -147016,10 +149058,10 @@ static int disableUnusedSubqueryResultColumns(SrcItem *pItem){
   if( pItem->fg.isCorrelated || pItem->fg.isCte ){
     return 0;
   }
-  assert( pItem->pTab!=0 );
-  pTab = pItem->pTab;
-  assert( pItem->pSelect!=0 );
-  pSub = pItem->pSelect;
+  assert( pItem->pSTab!=0 );
+  pTab = pItem->pSTab;
+  assert( pItem->fg.isSubquery );
+  pSub = pItem->u4.pSubq->pSelect;
   assert( pSub->pEList->nExpr==pTab->nCol );
   for(pX=pSub; pX; pX=pX->pPrior){
     if( (pX->selFlags & (SF_Distinct|SF_Aggregate))!=0 ){
@@ -147148,13 +149190,13 @@ static Table *isSimpleCount(Select *p, AggInfo *pAggInfo){
   if( p->pWhere
    || p->pEList->nExpr!=1
    || p->pSrc->nSrc!=1
-   || p->pSrc->a[0].pSelect
+   || p->pSrc->a[0].fg.isSubquery
    || pAggInfo->nFunc!=1
    || p->pHaving
   ){
     return 0;
   }
-  pTab = p->pSrc->a[0].pTab;
+  pTab = p->pSrc->a[0].pSTab;
   assert( pTab!=0 );
   assert( !IsView(pTab) );
   if( !IsOrdinaryTable(pTab) ) return 0;
@@ -147179,7 +149221,7 @@ static Table *isSimpleCount(Select *p, AggInfo *pAggInfo){
 ** pFrom->pIndex and return SQLITE_OK.
 */
 SQLITE_PRIVATE int sqlite3IndexedByLookup(Parse *pParse, SrcItem *pFrom){
-  Table *pTab = pFrom->pTab;
+  Table *pTab = pFrom->pSTab;
   char *zIndexedBy = pFrom->u1.zIndexedBy;
   Index *pIdx;
   assert( pTab!=0 );
@@ -147256,7 +149298,11 @@ static int convertCompoundSelectToSubquery(Walker *pWalker, Select *p){
   if( pNew==0 ) return WRC_Abort;
   memset(&dummy, 0, sizeof(dummy));
   pNewSrc = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&dummy,pNew,0);
-  if( pNewSrc==0 ) return WRC_Abort;
+  assert( pNewSrc!=0 || pParse->nErr );
+  if( pParse->nErr ){
+    sqlite3SrcListDelete(db, pNewSrc);
+    return WRC_Abort;
+  }
   *pNew = *p;
   p->pSrc = pNewSrc;
   p->pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db, TK_ASTERISK, 0));
@@ -147311,7 +149357,7 @@ static struct Cte *searchWith(
 ){
   const char *zName = pItem->zName;
   With *p;
-  assert( pItem->zDatabase==0 );
+  assert( pItem->fg.fixedSchema || pItem->u4.zDatabase==0 );
   assert( zName!=0 );
   for(p=pWith; p; p=p->pOuter){
     int i;
@@ -147381,7 +149427,7 @@ static int resolveFromTermToCte(
   Cte *pCte;               /* Matched CTE (or NULL if no match) */
   With *pWith;             /* The matching WITH */
 
-  assert( pFrom->pTab==0 );
+  assert( pFrom->pSTab==0 );
   if( pParse->pWith==0 ){
     /* There are no WITH clauses in the stack.  No match is possible */
     return 0;
@@ -147391,7 +149437,8 @@ static int resolveFromTermToCte(
     ** go no further. */
     return 0;
   }
-  if( pFrom->zDatabase!=0 ){
+  assert( pFrom->fg.hadSchema==0 || pFrom->fg.notCte!=0 );
+  if( pFrom->fg.fixedSchema==0 && pFrom->u4.zDatabase!=0 ){
     /* The FROM term contains a schema qualifier (ex: main.t1) and so
     ** it cannot possibly be a CTE reference. */
     return 0;
@@ -147427,7 +149474,7 @@ static int resolveFromTermToCte(
     }
     if( cannotBeFunction(pParse, pFrom) ) return 2;
 
-    assert( pFrom->pTab==0 );
+    assert( pFrom->pSTab==0 );
     pTab = sqlite3DbMallocZero(db, sizeof(Table));
     if( pTab==0 ) return 2;
     pCteUse = pCte->pUse;
@@ -147441,26 +149488,29 @@ static int resolveFromTermToCte(
       }
       pCteUse->eM10d = pCte->eM10d;
     }
-    pFrom->pTab = pTab;
+    pFrom->pSTab = pTab;
     pTab->nTabRef = 1;
     pTab->zName = sqlite3DbStrDup(db, pCte->zName);
     pTab->iPKey = -1;
     pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
     pTab->tabFlags |= TF_Ephemeral | TF_NoVisibleRowid;
-    pFrom->pSelect = sqlite3SelectDup(db, pCte->pSelect, 0);
+    sqlite3SrcItemAttachSubquery(pParse, pFrom, pCte->pSelect, 1);
     if( db->mallocFailed ) return 2;
-    pFrom->pSelect->selFlags |= SF_CopyCte;
-    assert( pFrom->pSelect );
+    assert( pFrom->fg.isSubquery && pFrom->u4.pSubq );
+    pSel = pFrom->u4.pSubq->pSelect;
+    assert( pSel!=0 );
+    pSel->selFlags |= SF_CopyCte;
     if( pFrom->fg.isIndexedBy ){
       sqlite3ErrorMsg(pParse, "no such index: \"%s\"", pFrom->u1.zIndexedBy);
       return 2;
     }
+    assert( !pFrom->fg.isIndexedBy );
     pFrom->fg.isCte = 1;
     pFrom->u2.pCteUse = pCteUse;
     pCteUse->nUse++;
 
     /* Check if this is a recursive CTE. */
-    pRecTerm = pSel = pFrom->pSelect;
+    pRecTerm = pSel;
     bMayRecursive = ( pSel->op==TK_ALL || pSel->op==TK_UNION );
     while( bMayRecursive && pRecTerm->op==pSel->op ){
       int i;
@@ -147468,11 +149518,13 @@ static int resolveFromTermToCte(
       assert( pRecTerm->pPrior!=0 );
       for(i=0; i<pSrc->nSrc; i++){
         SrcItem *pItem = &pSrc->a[i];
-        if( pItem->zDatabase==0
-         && pItem->zName!=0
+        if( pItem->zName!=0
+         && !pItem->fg.hadSchema
+         && ALWAYS( !pItem->fg.isSubquery )
+         && (pItem->fg.fixedSchema || pItem->u4.zDatabase==0)
          && 0==sqlite3StrICmp(pItem->zName, pCte->zName)
         ){
-          pItem->pTab = pTab;
+          pItem->pSTab = pTab;
           pTab->nTabRef++;
           pItem->fg.isRecursive = 1;
           if( pRecTerm->selFlags & SF_Recursive ){
@@ -147574,11 +149626,14 @@ SQLITE_PRIVATE void sqlite3SelectPopWith(Walker *pWalker, Select *p){
 ** SQLITE_NOMEM.
 */
 SQLITE_PRIVATE int sqlite3ExpandSubquery(Parse *pParse, SrcItem *pFrom){
-  Select *pSel = pFrom->pSelect;
+  Select *pSel;
   Table *pTab;
 
+  assert( pFrom->fg.isSubquery );
+  assert( pFrom->u4.pSubq!=0 );
+  pSel = pFrom->u4.pSubq->pSelect;
   assert( pSel );
-  pFrom->pTab = pTab = sqlite3DbMallocZero(pParse->db, sizeof(Table));
+  pFrom->pSTab = pTab = sqlite3DbMallocZero(pParse->db, sizeof(Table));
   if( pTab==0 ) return SQLITE_NOMEM;
   pTab->nTabRef = 1;
   if( pFrom->zAlias ){
@@ -147589,12 +149644,14 @@ SQLITE_PRIVATE int sqlite3ExpandSubquery(Parse *pParse, SrcItem *pFrom){
   while( pSel->pPrior ){ pSel = pSel->pPrior; }
   sqlite3ColumnsFromExprList(pParse, pSel->pEList,&pTab->nCol,&pTab->aCol);
   pTab->iPKey = -1;
+  pTab->eTabType = TABTYP_VIEW;
   pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
 #ifndef SQLITE_ALLOW_ROWID_IN_VIEW
   /* The usual case - do not allow ROWID on a subquery */
   pTab->tabFlags |= TF_Ephemeral | TF_NoVisibleRowid;
 #else
-  pTab->tabFlags |= TF_Ephemeral;  /* Legacy compatibility mode */
+  /* Legacy compatibility mode */
+  pTab->tabFlags |= TF_Ephemeral | sqlite3Config.mNoVisibleRowid;
 #endif
   return pParse->nErr ? SQLITE_ERROR : SQLITE_OK;
 }
@@ -147696,33 +149753,35 @@ static int selectExpander(Walker *pWalker, Select *p){
   */
   for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
     Table *pTab;
-    assert( pFrom->fg.isRecursive==0 || pFrom->pTab!=0 );
-    if( pFrom->pTab ) continue;
+    assert( pFrom->fg.isRecursive==0 || pFrom->pSTab!=0 );
+    if( pFrom->pSTab ) continue;
     assert( pFrom->fg.isRecursive==0 );
     if( pFrom->zName==0 ){
 #ifndef SQLITE_OMIT_SUBQUERY
-      Select *pSel = pFrom->pSelect;
+      Select *pSel;
+      assert( pFrom->fg.isSubquery && pFrom->u4.pSubq!=0 );
+      pSel = pFrom->u4.pSubq->pSelect;
       /* A sub-query in the FROM clause of a SELECT */
       assert( pSel!=0 );
-      assert( pFrom->pTab==0 );
+      assert( pFrom->pSTab==0 );
       if( sqlite3WalkSelect(pWalker, pSel) ) return WRC_Abort;
       if( sqlite3ExpandSubquery(pParse, pFrom) ) return WRC_Abort;
 #endif
 #ifndef SQLITE_OMIT_CTE
     }else if( (rc = resolveFromTermToCte(pParse, pWalker, pFrom))!=0 ){
       if( rc>1 ) return WRC_Abort;
-      pTab = pFrom->pTab;
+      pTab = pFrom->pSTab;
       assert( pTab!=0 );
 #endif
     }else{
       /* An ordinary table or view name in the FROM clause */
-      assert( pFrom->pTab==0 );
-      pFrom->pTab = pTab = sqlite3LocateTableItem(pParse, 0, pFrom);
+      assert( pFrom->pSTab==0 );
+      pFrom->pSTab = pTab = sqlite3LocateTableItem(pParse, 0, pFrom);
       if( pTab==0 ) return WRC_Abort;
       if( pTab->nTabRef>=0xffff ){
         sqlite3ErrorMsg(pParse, "too many references to \"%s\": max 65535",
            pTab->zName);
-        pFrom->pTab = 0;
+        pFrom->pSTab = 0;
         return WRC_Abort;
       }
       pTab->nTabRef++;
@@ -147734,7 +149793,7 @@ static int selectExpander(Walker *pWalker, Select *p){
         i16 nCol;
         u8 eCodeOrig = pWalker->eCode;
         if( sqlite3ViewGetColumnNames(pParse, pTab) ) return WRC_Abort;
-        assert( pFrom->pSelect==0 );
+        assert( pFrom->fg.isSubquery==0 );
         if( IsView(pTab) ){
           if( (db->flags & SQLITE_EnableView)==0
            && pTab->pSchema!=db->aDb[1].pSchema
@@ -147742,7 +149801,7 @@ static int selectExpander(Walker *pWalker, Select *p){
             sqlite3ErrorMsg(pParse, "access to view \"%s\" prohibited",
               pTab->zName);
           }
-          pFrom->pSelect = sqlite3SelectDup(db, pTab->u.view.pSelect, 0);
+          sqlite3SrcItemAttachSubquery(pParse, pFrom, pTab->u.view.pSelect, 1);
         }
 #ifndef SQLITE_OMIT_VIRTUALTABLE
         else if( ALWAYS(IsVirtual(pTab))
@@ -147758,7 +149817,9 @@ static int selectExpander(Walker *pWalker, Select *p){
         nCol = pTab->nCol;
         pTab->nCol = -1;
         pWalker->eCode = 1;  /* Turn on Select.selId renumbering */
-        sqlite3WalkSelect(pWalker, pFrom->pSelect);
+        if( pFrom->fg.isSubquery ){
+          sqlite3WalkSelect(pWalker, pFrom->u4.pSubq->pSelect);
+        }
         pWalker->eCode = eCodeOrig;
         pTab->nCol = nCol;
       }
@@ -147845,7 +149906,7 @@ static int selectExpander(Walker *pWalker, Select *p){
         }
         for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
           int nAdd;                    /* Number of cols including rowid */
-          Table *pTab = pFrom->pTab;   /* Table for this data source */
+          Table *pTab = pFrom->pSTab;  /* Table for this data source */
           ExprList *pNestedFrom;       /* Result-set of a nested FROM clause */
           char *zTabName;              /* AS name for this data source */
           const char *zSchemaName = 0; /* Schema name for this data source */
@@ -147856,13 +149917,14 @@ static int selectExpander(Walker *pWalker, Select *p){
             zTabName = pTab->zName;
           }
           if( db->mallocFailed ) break;
-          assert( (int)pFrom->fg.isNestedFrom == IsNestedFrom(pFrom->pSelect) );
+          assert( (int)pFrom->fg.isNestedFrom == IsNestedFrom(pFrom) );
           if( pFrom->fg.isNestedFrom ){
-            assert( pFrom->pSelect!=0 );
-            pNestedFrom = pFrom->pSelect->pEList;
+            assert( pFrom->fg.isSubquery && pFrom->u4.pSubq );
+            assert( pFrom->u4.pSubq->pSelect!=0 );
+            pNestedFrom = pFrom->u4.pSubq->pSelect->pEList;
             assert( pNestedFrom!=0 );
             assert( pNestedFrom->nExpr==pTab->nCol );
-            assert( VisibleRowid(pTab)==0 );
+            assert( VisibleRowid(pTab)==0 || ViewCanHaveRowid );
           }else{
             if( zTName && sqlite3StrICmp(zTName, zTabName)!=0 ){
               continue;
@@ -147894,7 +149956,8 @@ static int selectExpander(Walker *pWalker, Select *p){
             pUsing = 0;
           }
 
-          nAdd = pTab->nCol + (VisibleRowid(pTab) && (selFlags&SF_NestedFrom));
+          nAdd = pTab->nCol;
+          if( VisibleRowid(pTab) && (selFlags & SF_NestedFrom)!=0 ) nAdd++;
           for(j=0; j<nAdd; j++){
             const char *zName;
             struct ExprList_item *pX; /* Newly added ExprList term */
@@ -147976,7 +150039,8 @@ static int selectExpander(Walker *pWalker, Select *p){
             pX = &pNew->a[pNew->nExpr-1];
             assert( pX->zEName==0 );
             if( (selFlags & SF_NestedFrom)!=0 && !IN_RENAME_OBJECT ){
-              if( pNestedFrom ){
+              if( pNestedFrom && (!ViewCanHaveRowid || j<pNestedFrom->nExpr) ){
+                assert( j<pNestedFrom->nExpr );
                 pX->zEName = sqlite3DbStrDup(db, pNestedFrom->a[j].zEName);
                 testcase( pX->zEName==0 );
               }else{
@@ -148093,18 +150157,15 @@ static void selectAddSubqueryTypeInfo(Walker *pWalker, Select *p){
   if( p->selFlags & SF_HasTypeInfo ) return;
   p->selFlags |= SF_HasTypeInfo;
   pParse = pWalker->pParse;
-  testcase( (p->selFlags & SF_Resolved)==0 );
-  assert( (p->selFlags & SF_Resolved) || IN_RENAME_OBJECT );
+  assert( (p->selFlags & SF_Resolved) );
   pTabList = p->pSrc;
   for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
-    Table *pTab = pFrom->pTab;
+    Table *pTab = pFrom->pSTab;
     assert( pTab!=0 );
-    if( (pTab->tabFlags & TF_Ephemeral)!=0 ){
+    if( (pTab->tabFlags & TF_Ephemeral)!=0 && pFrom->fg.isSubquery ){
       /* A sub-query in the FROM clause of a SELECT */
-      Select *pSel = pFrom->pSelect;
-      if( pSel ){
-        sqlite3SubqueryColumnTypes(pParse, pTab, pSel, SQLITE_AFF_NONE);
-      }
+      Select *pSel = pFrom->u4.pSubq->pSelect;
+      sqlite3SubqueryColumnTypes(pParse, pTab, pSel, SQLITE_AFF_NONE);
     }
   }
 }
@@ -148164,6 +150225,8 @@ SQLITE_PRIVATE void sqlite3SelectPrep(
 */
 static void printAggInfo(AggInfo *pAggInfo){
   int ii;
+  sqlite3DebugPrintf("AggInfo %d/%p:\n",
+     pAggInfo->selId, pAggInfo);
   for(ii=0; ii<pAggInfo->nColumn; ii++){
     struct AggInfo_col *pCol = &pAggInfo->aCol[ii];
     sqlite3DebugPrintf(
@@ -148416,6 +150479,7 @@ static void finalizeAggFunctions(Parse *pParse, AggInfo *pAggInfo){
   for(i=0, pF=pAggInfo->aFunc; i<pAggInfo->nFunc; i++, pF++){
     ExprList *pList;
     assert( ExprUseXList(pF->pFExpr) );
+    if( pParse->nErr ) return;
     pList = pF->pFExpr->x.pList;
     if( pF->iOBTab>=0 ){
       /* For an ORDER BY aggregate, calls to OP_AggStep were deferred.  Inputs
@@ -148625,6 +150689,7 @@ static void updateAccumulator(
     if( addrNext ){
       sqlite3VdbeResolveLabel(v, addrNext);
     }
+    if( pParse->nErr ) return;
   }
   if( regHit==0 && pAggInfo->nAccumulator ){
     regHit = regAcc;
@@ -148634,6 +150699,7 @@ static void updateAccumulator(
   }
   for(i=0, pC=pAggInfo->aCol; i<pAggInfo->nAccumulator; i++, pC++){
     sqlite3ExprCode(pParse, pC->pCExpr, AggInfoColumnReg(pAggInfo,i));
+    if( pParse->nErr ) return;
   }
 
   pAggInfo->directMode = 0;
@@ -148749,25 +150815,28 @@ static SrcItem *isSelfJoinView(
   int iFirst, int iEnd        /* Range of FROM-clause entries to search. */
 ){
   SrcItem *pItem;
-  assert( pThis->pSelect!=0 );
-  if( pThis->pSelect->selFlags & SF_PushDown ) return 0;
+  Select *pSel;
+  assert( pThis->fg.isSubquery );
+  pSel = pThis->u4.pSubq->pSelect;
+  assert( pSel!=0 );
+  if( pSel->selFlags & SF_PushDown ) return 0;
   while( iFirst<iEnd ){
     Select *pS1;
     pItem = &pTabList->a[iFirst++];
-    if( pItem->pSelect==0 ) continue;
+    if( !pItem->fg.isSubquery ) continue;
     if( pItem->fg.viaCoroutine ) continue;
     if( pItem->zName==0 ) continue;
-    assert( pItem->pTab!=0 );
-    assert( pThis->pTab!=0 );
-    if( pItem->pTab->pSchema!=pThis->pTab->pSchema ) continue;
+    assert( pItem->pSTab!=0 );
+    assert( pThis->pSTab!=0 );
+    if( pItem->pSTab->pSchema!=pThis->pSTab->pSchema ) continue;
     if( sqlite3_stricmp(pItem->zName, pThis->zName)!=0 ) continue;
-    pS1 = pItem->pSelect;
-    if( pItem->pTab->pSchema==0 && pThis->pSelect->selId!=pS1->selId ){
+    pS1 = pItem->u4.pSubq->pSelect;
+    if( pItem->pSTab->pSchema==0 && pSel->selId!=pS1->selId ){
       /* The query flattener left two different CTE tables with identical
       ** names in the same FROM clause. */
       continue;
     }
-    if( pItem->pSelect->selFlags & SF_PushDown ){
+    if( pS1->selFlags & SF_PushDown ){
       /* The view was modified by some other optimization such as
       ** pushDownWhereTerms() */
       continue;
@@ -148811,6 +150880,7 @@ static int countOfViewOptimization(Parse *pParse, Select *p){
   Expr *pExpr;
   Expr *pCount;
   sqlite3 *db;
+  SrcItem *pFrom;
   if( (p->selFlags & SF_Aggregate)==0 ) return 0;   /* This is an aggregate */
   if( p->pEList->nExpr!=1 ) return 0;               /* Single result column */
   if( p->pWhere ) return 0;
@@ -148825,8 +150895,9 @@ static int countOfViewOptimization(Parse *pParse, Select *p){
   if( pExpr->x.pList!=0 ) return 0;                 /* Must be count(*) */
   if( p->pSrc->nSrc!=1 ) return 0;                  /* One table in FROM  */
   if( ExprHasProperty(pExpr, EP_WinFunc) ) return 0;/* Not a window function */
-  pSub = p->pSrc->a[0].pSelect;
-  if( pSub==0 ) return 0;                           /* The FROM is a subquery */
+  pFrom = p->pSrc->a;
+  if( pFrom->fg.isSubquery==0 ) return 0;    /* FROM is a subquery */
+  pSub = pFrom->u4.pSubq->pSelect;
   if( pSub->pPrior==0 ) return 0;                   /* Must be a compound */
   if( pSub->selFlags & SF_CopyCte ) return 0;       /* Not a CTE */
   do{
@@ -148835,7 +150906,7 @@ static int countOfViewOptimization(Parse *pParse, Select *p){
     if( pSub->pLimit ) return 0;                      /* No LIMIT clause */
     if( pSub->selFlags & SF_Aggregate ) return 0;     /* Not an aggregate */
     assert( pSub->pHaving==0 );  /* Due to the previous */
-   pSub = pSub->pPrior;                              /* Repeat over compound */
+    pSub = pSub->pPrior;                              /* Repeat over compound */
   }while( pSub );
 
   /* If we reach this point then it is OK to perform the transformation */
@@ -148843,8 +150914,7 @@ static int countOfViewOptimization(Parse *pParse, Select *p){
   db = pParse->db;
   pCount = pExpr;
   pExpr = 0;
-  pSub = p->pSrc->a[0].pSelect;
-  p->pSrc->a[0].pSelect = 0;
+  pSub = sqlite3SubqueryDetach(db, pFrom);
   sqlite3SrcListDelete(db, p->pSrc);
   p->pSrc = sqlite3DbMallocZero(pParse->db, sizeof(*p->pSrc));
   while( pSub ){
@@ -148889,12 +150959,12 @@ static int sameSrcAlias(SrcItem *p0, SrcList *pSrc){
   for(i=0; i<pSrc->nSrc; i++){
     SrcItem *p1 = &pSrc->a[i];
     if( p1==p0 ) continue;
-    if( p0->pTab==p1->pTab && 0==sqlite3_stricmp(p0->zAlias, p1->zAlias) ){
+    if( p0->pSTab==p1->pSTab && 0==sqlite3_stricmp(p0->zAlias, p1->zAlias) ){
       return 1;
     }
-    if( p1->pSelect
-     && (p1->pSelect->selFlags & SF_NestedFrom)!=0
-     && sameSrcAlias(p0, p1->pSelect->pSrc)
+    if( p1->fg.isSubquery
+     && (p1->u4.pSubq->pSelect->selFlags & SF_NestedFrom)!=0
+     && sameSrcAlias(p0, p1->u4.pSubq->pSelect->pSrc)
     ){
       return 1;
     }
@@ -148959,13 +151029,13 @@ static int fromClauseTermCanBeCoroutine(
     if( i==0 ) break;
     i--;
     pItem--;
-    if( pItem->pSelect!=0 ) return 0;                             /* (1c-i) */
+    if( pItem->fg.isSubquery ) return 0;                          /* (1c-i) */
   }
   return 1;
 }
 
 /*
-** Generate code for the SELECT statement given in the p argument.
+** Generate byte-code for the SELECT statement given in the p argument.
 **
 ** The results are returned according to the SelectDest structure.
 ** See comments in sqliteInt.h for further information.
@@ -148976,6 +151046,40 @@ static int fromClauseTermCanBeCoroutine(
 **
 ** This routine does NOT free the Select structure passed in.  The
 ** calling function needs to do that.
+**
+** This is a long function.  The following is an outline of the processing
+** steps, with tags referencing various milestones:
+**
+**  *  Resolve names and similar preparation                tag-select-0100
+**  *  Scan of the FROM clause                              tag-select-0200
+**      +  OUTER JOIN strength reduction                      tag-select-0220
+**      +  Sub-query ORDER BY removal                         tag-select-0230
+**      +  Query flattening                                   tag-select-0240
+**  *  Separate subroutine for compound-SELECT              tag-select-0300
+**  *  WHERE-clause constant propagation                    tag-select-0330
+**  *  Count()-of-VIEW optimization                         tag-select-0350
+**  *  Scan of the FROM clause again                        tag-select-0400
+**      +  Authorize unreferenced tables                      tag-select-0410
+**      +  Predicate push-down optimization                   tag-select-0420
+**      +  Omit unused subquery columns optimization          tag-select-0440
+**      +  Generate code to implement subqueries              tag-select-0480
+**         -  Co-routines                                       tag-select-0482
+**         -  Reuse previously computed CTE                     tag-select-0484
+**         -  REuse previously computed VIEW                    tag-select-0486
+**         -  Materialize a VIEW or CTE                         tag-select-0488
+**  *  DISTINCT ORDER BY -> GROUP BY optimization           tag-select-0500
+**  *  Set up for ORDER BY                                  tag-select-0600
+**  *  Create output table                                  tag-select-0630
+**  *  Prepare registers for LIMIT                          tag-select-0650
+**  *  Setup for DISTINCT                                   tag-select-0680
+**  *  Generate code for non-aggregate and non-GROUP BY     tag-select-0700
+**  *  Generate code for aggregate and/or GROUP BY          tag-select-0800
+**      +  GROUP BY queries                                   tag-select-0810
+**      +  non-GROUP BY queries                               tag-select-0820
+**         -  Special case of count() w/o GROUP BY              tag-select-0821
+**         -  General case of non-GROUP BY aggregates           tag-select-0822
+**  *  Sort results, as needed                              tag-select-0900
+**  *  Internal self-checks                                 tag-select-1000
 */
 SQLITE_PRIVATE int sqlite3Select(
   Parse *pParse,         /* The parser context */
@@ -149019,6 +151123,7 @@ SQLITE_PRIVATE int sqlite3Select(
   }
 #endif
 
+  /* tag-select-0100 */
   assert( p->pOrderBy==0 || pDest->eDest!=SRT_DistFifo );
   assert( p->pOrderBy==0 || pDest->eDest!=SRT_Fifo );
   assert( p->pOrderBy==0 || pDest->eDest!=SRT_DistQueue );
@@ -149070,7 +151175,7 @@ SQLITE_PRIVATE int sqlite3Select(
     if( sameSrcAlias(p0, p->pSrc) ){
       sqlite3ErrorMsg(pParse,
           "target object/alias may not appear in FROM clause: %s",
-          p0->zAlias ? p0->zAlias : p0->pTab->zName
+          p0->zAlias ? p0->zAlias : p0->pSTab->zName
       );
       goto select_end;
     }
@@ -149105,12 +151210,13 @@ SQLITE_PRIVATE int sqlite3Select(
 
   /* Try to do various optimizations (flattening subqueries, and strength
   ** reduction of join operators) in the FROM clause up into the main query
+  ** tag-select-0200
   */
 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
   for(i=0; !p->pPrior && i<pTabList->nSrc; i++){
     SrcItem *pItem = &pTabList->a[i];
-    Select *pSub = pItem->pSelect;
-    Table *pTab = pItem->pTab;
+    Select *pSub = pItem->fg.isSubquery ? pItem->u4.pSubq->pSelect : 0;
+    Table *pTab = pItem->pSTab;
 
     /* The expander should have already created transient Table objects
     ** even for FROM clause elements such as subqueries that do not correspond
@@ -149127,6 +151233,7 @@ SQLITE_PRIVATE int sqlite3Select(
     ** way that the i-th table cannot be the NULL row of a join, then
     ** perform the appropriate simplification. This is called
     ** "OUTER JOIN strength reduction" in the SQLite documentation.
+    ** tag-select-0220
     */
     if( (pItem->fg.jointype & (JT_LEFT|JT_LTORJ))!=0
      && sqlite3ExprImpliesNonNullRow(p->pWhere, pItem->iCursor,
@@ -149197,7 +151304,8 @@ SQLITE_PRIVATE int sqlite3Select(
     if( (pSub->selFlags & SF_Aggregate)!=0 ) continue;
     assert( pSub->pGroupBy==0 );
 
-    /* If a FROM-clause subquery has an ORDER BY clause that is not
+    /* tag-select-0230:
+    ** If a FROM-clause subquery has an ORDER BY clause that is not
     ** really doing anything, then delete it now so that it does not
     ** interfere with query flattening.  See the discussion at
     ** https://sqlite.org/forum/forumpost/2d76f2bcf65d256a
@@ -149216,13 +151324,16 @@ SQLITE_PRIVATE int sqlite3Select(
     **            (a)  The outer query has a different ORDER BY clause
     **            (b)  The subquery is part of a join
     **          See forum post 062d576715d277c8
+    **    (6)   The subquery is not a recursive CTE.  ORDER BY has a different
+    **          meaning for recursive CTEs and this optimization does not
+    **          apply.
     **
     ** Also retain the ORDER BY if the OmitOrderBy optimization is disabled.
     */
     if( pSub->pOrderBy!=0
      && (p->pOrderBy!=0 || pTabList->nSrc>1)      /* Condition (5) */
      && pSub->pLimit==0                           /* Condition (1) */
-     && (pSub->selFlags & SF_OrderByReqd)==0      /* Condition (2) */
+     && (pSub->selFlags & (SF_OrderByReqd|SF_Recursive))==0  /* (2) and (6) */
      && (p->selFlags & SF_OrderByReqd)==0         /* Condition (3) and (4) */
      && OptimizationEnabled(db, SQLITE_OmitOrderBy)
     ){
@@ -149260,6 +151371,7 @@ SQLITE_PRIVATE int sqlite3Select(
       continue;
     }
 
+    /* tag-select-0240 */
     if( flattenSubquery(pParse, p, i, isAgg) ){
       if( pParse->nErr ) goto select_end;
       /* This subquery can be absorbed into its parent. */
@@ -149275,7 +151387,7 @@ SQLITE_PRIVATE int sqlite3Select(
 
 #ifndef SQLITE_OMIT_COMPOUND_SELECT
   /* Handle compound SELECT statements using the separate multiSelect()
-  ** procedure.
+  ** procedure.  tag-select-0300
   */
   if( p->pPrior ){
     rc = multiSelect(pParse, p, pDest);
@@ -149291,9 +151403,9 @@ SQLITE_PRIVATE int sqlite3Select(
 #endif
 
   /* Do the WHERE-clause constant propagation optimization if this is
-  ** a join.  No need to speed time on this operation for non-join queries
+  ** a join.  No need to spend time on this operation for non-join queries
   ** as the equivalent optimization will be handled by query planner in
-  ** sqlite3WhereBegin().
+  ** sqlite3WhereBegin().  tag-select-0330
   */
   if( p->pWhere!=0
    && p->pWhere->op==TK_AND
@@ -149310,6 +151422,7 @@ SQLITE_PRIVATE int sqlite3Select(
     TREETRACE(0x2000,pParse,p,("Constant propagation not helpful\n"));
   }
 
+  /* tag-select-0350 */
   if( OptimizationEnabled(db, SQLITE_QueryFlattener|SQLITE_CountOfView)
    && countOfViewOptimization(pParse, p)
   ){
@@ -149317,20 +151430,26 @@ SQLITE_PRIVATE int sqlite3Select(
     pTabList = p->pSrc;
   }
 
-  /* For each term in the FROM clause, do two things:
-  ** (1) Authorized unreferenced tables
-  ** (2) Generate code for all sub-queries
+  /* Loop over all terms in the FROM clause and do two things for each term:
+  **
+  **   (1) Authorize unreferenced tables
+  **   (2) Generate code for all sub-queries
+  **
+  ** tag-select-0400
   */
   for(i=0; i<pTabList->nSrc; i++){
     SrcItem *pItem = &pTabList->a[i];
     SrcItem *pPrior;
     SelectDest dest;
+    Subquery *pSubq;
     Select *pSub;
 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
     const char *zSavedAuthContext;
 #endif
 
-    /* Issue SQLITE_READ authorizations with a fake column name for any
+    /* Authorized unreferenced tables.  tag-select-0410
+    **
+    ** Issue SQLITE_READ authorizations with a fake column name for any
     ** tables that are referenced but from which no values are extracted.
     ** Examples of where these kinds of null SQLITE_READ authorizations
     ** would occur:
@@ -149347,17 +151466,28 @@ SQLITE_PRIVATE int sqlite3Select(
     ** string for the fake column name seems safer.
     */
     if( pItem->colUsed==0 && pItem->zName!=0 ){
-      sqlite3AuthCheck(pParse, SQLITE_READ, pItem->zName, "", pItem->zDatabase);
+      const char *zDb;
+      if( pItem->fg.fixedSchema ){
+        int iDb = sqlite3SchemaToIndex(pParse->db, pItem->u4.pSchema);
+        zDb = db->aDb[iDb].zDbSName;
+      }else if( pItem->fg.isSubquery ){
+        zDb = 0;
+      }else{
+        zDb = pItem->u4.zDatabase;
+      }
+      sqlite3AuthCheck(pParse, SQLITE_READ, pItem->zName, "", zDb);
     }
 
 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
     /* Generate code for all sub-queries in the FROM clause
     */
-    pSub = pItem->pSelect;
-    if( pSub==0 ) continue;
+    if( pItem->fg.isSubquery==0 ) continue;
+    pSubq = pItem->u4.pSubq;
+    assert( pSubq!=0 );
+    pSub = pSubq->pSelect;
 
     /* The code for a subquery should only be generated once. */
-    assert( pItem->addrFillSub==0 );
+    if( pSubq->addrFillSub!=0 ) continue;
 
     /* Increment Parse.nHeight by the height of the largest expression
     ** tree referred to by this, the parent select. The child select
@@ -149370,6 +151500,7 @@ SQLITE_PRIVATE int sqlite3Select(
 
     /* Make copies of constant WHERE-clause terms in the outer query down
     ** inside the subquery.  This can help the subquery to run more efficiently.
+    ** This is the "predicate push-down optimization".  tag-select-0420
     */
     if( OptimizationEnabled(db, SQLITE_PushDown)
      && (pItem->fg.isCte==0
@@ -149383,13 +151514,14 @@ SQLITE_PRIVATE int sqlite3Select(
         sqlite3TreeViewSelect(0, p, 0);
       }
 #endif
-      assert( pItem->pSelect && (pItem->pSelect->selFlags & SF_PushDown)!=0 );
+      assert( pSubq->pSelect && (pSub->selFlags & SF_PushDown)!=0 );
     }else{
-      TREETRACE(0x4000,pParse,p,("Push-down not possible\n"));
+      TREETRACE(0x4000,pParse,p,("WHERE-lcause push-down not possible\n"));
     }
 
     /* Convert unused result columns of the subquery into simple NULL
     ** expressions, to avoid unneeded searching and computation.
+    ** tag-select-0440
     */
     if( OptimizationEnabled(db, SQLITE_NullUnusedCols)
      && disableUnusedSubqueryResultColumns(pItem)
@@ -149407,32 +151539,33 @@ SQLITE_PRIVATE int sqlite3Select(
     zSavedAuthContext = pParse->zAuthContext;
     pParse->zAuthContext = pItem->zName;
 
-    /* Generate code to implement the subquery
+    /* Generate byte-code to implement the subquery  tag-select-0480
     */
     if( fromClauseTermCanBeCoroutine(pParse, pTabList, i, p->selFlags) ){
       /* Implement a co-routine that will return a single row of the result
-      ** set on each invocation.
+      ** set on each invocation.  tag-select-0482
       */
       int addrTop = sqlite3VdbeCurrentAddr(v)+1;
 
-      pItem->regReturn = ++pParse->nMem;
-      sqlite3VdbeAddOp3(v, OP_InitCoroutine, pItem->regReturn, 0, addrTop);
+      pSubq->regReturn = ++pParse->nMem;
+      sqlite3VdbeAddOp3(v, OP_InitCoroutine, pSubq->regReturn, 0, addrTop);
       VdbeComment((v, "%!S", pItem));
-      pItem->addrFillSub = addrTop;
-      sqlite3SelectDestInit(&dest, SRT_Coroutine, pItem->regReturn);
+      pSubq->addrFillSub = addrTop;
+      sqlite3SelectDestInit(&dest, SRT_Coroutine, pSubq->regReturn);
       ExplainQueryPlan((pParse, 1, "CO-ROUTINE %!S", pItem));
       sqlite3Select(pParse, pSub, &dest);
-      pItem->pTab->nRowLogEst = pSub->nSelectRow;
+      pItem->pSTab->nRowLogEst = pSub->nSelectRow;
       pItem->fg.viaCoroutine = 1;
-      pItem->regResult = dest.iSdst;
-      sqlite3VdbeEndCoroutine(v, pItem->regReturn);
+      pSubq->regResult = dest.iSdst;
+      sqlite3VdbeEndCoroutine(v, pSubq->regReturn);
+      VdbeComment((v, "end %!S", pItem));
       sqlite3VdbeJumpHere(v, addrTop-1);
       sqlite3ClearTempRegCache(pParse);
     }else if( pItem->fg.isCte && pItem->u2.pCteUse->addrM9e>0 ){
       /* This is a CTE for which materialization code has already been
       ** generated.  Invoke the subroutine to compute the materialization,
-      ** the make the pItem->iCursor be a copy of the ephemeral table that
-      ** holds the result of the materialization. */
+      ** then make the pItem->iCursor be a copy of the ephemeral table that
+      ** holds the result of the materialization. tag-select-0484 */
       CteUse *pCteUse = pItem->u2.pCteUse;
       sqlite3VdbeAddOp2(v, OP_Gosub, pCteUse->regRtn, pCteUse->addrM9e);
       if( pItem->iCursor!=pCteUse->iCur ){
@@ -149442,25 +151575,30 @@ SQLITE_PRIVATE int sqlite3Select(
       pSub->nSelectRow = pCteUse->nRowEst;
     }else if( (pPrior = isSelfJoinView(pTabList, pItem, 0, i))!=0 ){
       /* This view has already been materialized by a prior entry in
-      ** this same FROM clause.  Reuse it. */
-      if( pPrior->addrFillSub ){
-        sqlite3VdbeAddOp2(v, OP_Gosub, pPrior->regReturn, pPrior->addrFillSub);
+      ** this same FROM clause.  Reuse it.  tag-select-0486 */
+      Subquery *pPriorSubq;
+      assert( pPrior->fg.isSubquery );
+      pPriorSubq = pPrior->u4.pSubq;
+      assert( pPriorSubq!=0 );
+      if( pPriorSubq->addrFillSub ){
+        sqlite3VdbeAddOp2(v, OP_Gosub, pPriorSubq->regReturn,
+                                       pPriorSubq->addrFillSub);
       }
       sqlite3VdbeAddOp2(v, OP_OpenDup, pItem->iCursor, pPrior->iCursor);
-      pSub->nSelectRow = pPrior->pSelect->nSelectRow;
+      pSub->nSelectRow = pPriorSubq->pSelect->nSelectRow;
     }else{
       /* Materialize the view.  If the view is not correlated, generate a
       ** subroutine to do the materialization so that subsequent uses of
-      ** the same view can reuse the materialization. */
+      ** the same view can reuse the materialization.  tag-select-0488 */
       int topAddr;
       int onceAddr = 0;
 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
       int addrExplain;
 #endif
 
-      pItem->regReturn = ++pParse->nMem;
+      pSubq->regReturn = ++pParse->nMem;
       topAddr = sqlite3VdbeAddOp0(v, OP_Goto);
-      pItem->addrFillSub = topAddr+1;
+      pSubq->addrFillSub = topAddr+1;
       pItem->fg.isMaterialized = 1;
       if( pItem->fg.isCorrelated==0 ){
         /* If the subquery is not correlated and if we are not inside of
@@ -149475,17 +151613,17 @@ SQLITE_PRIVATE int sqlite3Select(
 
       ExplainQueryPlan2(addrExplain, (pParse, 1, "MATERIALIZE %!S", pItem));
       sqlite3Select(pParse, pSub, &dest);
-      pItem->pTab->nRowLogEst = pSub->nSelectRow;
+      pItem->pSTab->nRowLogEst = pSub->nSelectRow;
       if( onceAddr ) sqlite3VdbeJumpHere(v, onceAddr);
-      sqlite3VdbeAddOp2(v, OP_Return, pItem->regReturn, topAddr+1);
+      sqlite3VdbeAddOp2(v, OP_Return, pSubq->regReturn, topAddr+1);
       VdbeComment((v, "end %!S", pItem));
       sqlite3VdbeScanStatusRange(v, addrExplain, addrExplain, -1);
       sqlite3VdbeJumpHere(v, topAddr);
       sqlite3ClearTempRegCache(pParse);
       if( pItem->fg.isCte && pItem->fg.isCorrelated==0 ){
         CteUse *pCteUse = pItem->u2.pCteUse;
-        pCteUse->addrM9e = pItem->addrFillSub;
-        pCteUse->regRtn = pItem->regReturn;
+        pCteUse->addrM9e = pSubq->addrFillSub;
+        pCteUse->regRtn = pSubq->regReturn;
         pCteUse->iCur = pItem->iCursor;
         pCteUse->nRowEst = pSub->nSelectRow;
       }
@@ -149511,7 +151649,9 @@ SQLITE_PRIVATE int sqlite3Select(
   }
 #endif
 
-  /* If the query is DISTINCT with an ORDER BY but is not an aggregate, and
+  /* tag-select-0500
+  **
+  ** If the query is DISTINCT with an ORDER BY but is not an aggregate, and
   ** if the select-list is the same as the ORDER BY list, then this query
   ** can be rewritten as a GROUP BY. In other words, this:
   **
@@ -149528,12 +151668,18 @@ SQLITE_PRIVATE int sqlite3Select(
   */
   if( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct
    && sqlite3ExprListCompare(sSort.pOrderBy, pEList, -1)==0
+   && OptimizationEnabled(db, SQLITE_GroupByOrder)
 #ifndef SQLITE_OMIT_WINDOWFUNC
    && p->pWin==0
 #endif
   ){
     p->selFlags &= ~SF_Distinct;
     pGroupBy = p->pGroupBy = sqlite3ExprListDup(db, pEList, 0);
+    if( pGroupBy ){
+      for(i=0; i<pGroupBy->nExpr; i++){
+        pGroupBy->a[i].u.x.iOrderByCol = i+1;
+      }
+    }
     p->selFlags |= SF_Aggregate;
     /* Notice that even thought SF_Distinct has been cleared from p->selFlags,
     ** the sDistinct.isTnct is still set.  Hence, isTnct represents the
@@ -149555,7 +151701,7 @@ SQLITE_PRIVATE int sqlite3Select(
   ** If that is the case, then the OP_OpenEphemeral instruction will be
   ** changed to an OP_Noop once we figure out that the sorting index is
   ** not needed.  The sSort.addrSortIndex variable is used to facilitate
-  ** that change.
+  ** that change.  tag-select-0600
   */
   if( sSort.pOrderBy ){
     KeyInfo *pKeyInfo;
@@ -149572,6 +151718,7 @@ SQLITE_PRIVATE int sqlite3Select(
   }
 
   /* If the output is destined for a temporary table, open that table.
+  ** tag-select-0630
   */
   if( pDest->eDest==SRT_EphemTab ){
     sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pDest->iSDParm, pEList->nExpr);
@@ -149589,7 +151736,7 @@ SQLITE_PRIVATE int sqlite3Select(
     }
   }
 
-  /* Set the limiter.
+  /* Set the limiter.  tag-select-0650
   */
   iEnd = sqlite3VdbeMakeLabel(pParse);
   if( (p->selFlags & SF_FixedLimit)==0 ){
@@ -149601,7 +151748,7 @@ SQLITE_PRIVATE int sqlite3Select(
     sSort.sortFlags |= SORTFLAG_UseSorter;
   }
 
-  /* Open an ephemeral index to use for the distinct set.
+  /* Open an ephemeral index to use for the distinct set. tag-select-0680
   */
   if( p->selFlags & SF_Distinct ){
     sDistinct.tabTnct = pParse->nTab++;
@@ -149616,7 +151763,7 @@ SQLITE_PRIVATE int sqlite3Select(
   }
 
   if( !isAgg && pGroupBy==0 ){
-    /* No aggregate functions and no GROUP BY clause */
+    /* No aggregate functions and no GROUP BY clause.  tag-select-0700 */
     u16 wctrlFlags = (sDistinct.isTnct ? WHERE_WANT_DISTINCT : 0)
                    | (p->selFlags & SF_FixedLimit);
 #ifndef SQLITE_OMIT_WINDOWFUNC
@@ -149689,8 +151836,8 @@ SQLITE_PRIVATE int sqlite3Select(
       sqlite3WhereEnd(pWInfo);
     }
   }else{
-    /* This case when there exist aggregate functions or a GROUP BY clause
-    ** or both */
+    /* This case is for when there exist aggregate functions or a GROUP BY
+    ** clause or both.  tag-select-0800 */
     NameContext sNC;    /* Name context for processing aggregate information */
     int iAMem;          /* First Mem address for storing current GROUP BY */
     int iBMem;          /* First Mem address for previous GROUP BY */
@@ -149809,7 +151956,7 @@ SQLITE_PRIVATE int sqlite3Select(
 
 
     /* Processing for aggregates with GROUP BY is very different and
-    ** much more complex than aggregates without a GROUP BY.
+    ** much more complex than aggregates without a GROUP BY.  tag-select-0810
     */
     if( pGroupBy ){
       KeyInfo *pKeyInfo;  /* Keying information for the group by clause */
@@ -149996,12 +152143,25 @@ SQLITE_PRIVATE int sqlite3Select(
                           sortOut, sortPTab);
       }
       for(j=0; j<pGroupBy->nExpr; j++){
+        int iOrderByCol = pGroupBy->a[j].u.x.iOrderByCol;
+
         if( groupBySort ){
           sqlite3VdbeAddOp3(v, OP_Column, sortPTab, j, iBMem+j);
         }else{
           pAggInfo->directMode = 1;
           sqlite3ExprCode(pParse, pGroupBy->a[j].pExpr, iBMem+j);
         }
+
+        if( iOrderByCol ){
+          Expr *pX = p->pEList->a[iOrderByCol-1].pExpr;
+          Expr *pBase = sqlite3ExprSkipCollateAndLikely(pX);
+          if( ALWAYS(pBase!=0)
+           && pBase->op!=TK_AGG_COLUMN
+           && pBase->op!=TK_REGISTER
+          ){
+            sqlite3ExprToRegister(pX, iAMem+j);
+          }
+        }
       }
       sqlite3VdbeAddOp4(v, OP_Compare, iAMem, iBMem, pGroupBy->nExpr,
                           (char*)sqlite3KeyInfoRef(pKeyInfo), P4_KEYINFO);
@@ -150017,9 +152177,9 @@ SQLITE_PRIVATE int sqlite3Select(
       ** and resets the aggregate accumulator registers in preparation
       ** for the next GROUP BY batch.
       */
-      sqlite3ExprCodeMove(pParse, iBMem, iAMem, pGroupBy->nExpr);
       sqlite3VdbeAddOp2(v, OP_Gosub, regOutputRow, addrOutputRow);
       VdbeComment((v, "output one row"));
+      sqlite3ExprCodeMove(pParse, iBMem, iAMem, pGroupBy->nExpr);
       sqlite3VdbeAddOp2(v, OP_IfPos, iAbortFlag, addrEnd); VdbeCoverage(v);
       VdbeComment((v, "check abort flag"));
       sqlite3VdbeAddOp2(v, OP_Gosub, regReset, addrReset);
@@ -150093,9 +152253,12 @@ SQLITE_PRIVATE int sqlite3Select(
       }
     } /* endif pGroupBy.  Begin aggregate queries without GROUP BY: */
     else {
+      /* Aggregate functions without GROUP BY. tag-select-0820 */
       Table *pTab;
       if( (pTab = isSimpleCount(p, pAggInfo))!=0 ){
-        /* If isSimpleCount() returns a pointer to a Table structure, then
+        /* tag-select-0821
+        **
+        ** If isSimpleCount() returns a pointer to a Table structure, then
         ** the SQL statement is of the form:
         **
         **   SELECT count(*) FROM <tbl>
@@ -150154,6 +152317,8 @@ SQLITE_PRIVATE int sqlite3Select(
         sqlite3VdbeAddOp1(v, OP_Close, iCsr);
         explainSimpleCount(pParse, pTab, pBest);
       }else{
+        /* The general case of an aggregate query without GROUP BY
+        ** tag-select-0822 */
         int regAcc = 0;           /* "populate accumulators" flag */
         ExprList *pDistinct = 0;
         u16 distFlag = 0;
@@ -150242,7 +152407,7 @@ SQLITE_PRIVATE int sqlite3Select(
   }
 
   /* If there is an ORDER BY clause, then we need to sort the results
-  ** and send them to the callback one by one.
+  ** and send them to the callback one by one.  tag-select-0900
   */
   if( sSort.pOrderBy ){
     assert( p->pEList==pEList );
@@ -150265,7 +152430,14 @@ select_end:
   assert( db->mallocFailed==0 || pParse->nErr!=0 );
   sqlite3ExprListDelete(db, pMinMaxOrderBy);
 #ifdef SQLITE_DEBUG
+  /* Internal self-checks.  tag-select-1000 */
   if( pAggInfo && !db->mallocFailed ){
+#if TREETRACE_ENABLED
+    if( sqlite3TreeTrace & 0x20 ){
+      TREETRACE(0x20,pParse,p,("Finished with AggInfo\n"));
+      printAggInfo(pAggInfo);
+    }
+#endif
     for(i=0; i<pAggInfo->nColumn; i++){
       Expr *pExpr = pAggInfo->aCol[i].pCExpr;
       if( pExpr==0 ) continue;
@@ -150648,8 +152820,10 @@ SQLITE_PRIVATE void sqlite3BeginTrigger(
   ** name on pTableName if we are reparsing out of the schema table
   */
   if( db->init.busy && iDb!=1 ){
-    sqlite3DbFree(db, pTableName->a[0].zDatabase);
-    pTableName->a[0].zDatabase = 0;
+    assert( pTableName->a[0].fg.fixedSchema==0 );
+    assert( pTableName->a[0].fg.isSubquery==0 );
+    sqlite3DbFree(db, pTableName->a[0].u4.zDatabase);
+    pTableName->a[0].u4.zDatabase = 0;
   }
 
   /* If the trigger name was unqualified, and the table is a temp table,
@@ -151127,7 +153301,8 @@ SQLITE_PRIVATE void sqlite3DropTrigger(Parse *pParse, SrcList *pName, int noErr)
   }
 
   assert( pName->nSrc==1 );
-  zDb = pName->a[0].zDatabase;
+  assert( pName->a[0].fg.fixedSchema==0 && pName->a[0].fg.isSubquery==0 );
+  zDb = pName->a[0].u4.zDatabase;
   zName = pName->a[0].zName;
   assert( zDb!=0 || sqlite3BtreeHoldsAllMutexes(db) );
   for(i=OMIT_TEMPDB; i<db->nDb; i++){
@@ -151364,7 +153539,9 @@ SQLITE_PRIVATE SrcList *sqlite3TriggerStepSrc(
     Schema *pSchema = pStep->pTrig->pSchema;
     pSrc->a[0].zName = zName;
     if( pSchema!=db->aDb[1].pSchema ){
-      pSrc->a[0].pSchema = pSchema;
+      assert( pSrc->a[0].fg.fixedSchema || pSrc->a[0].u4.zDatabase==0 );
+      pSrc->a[0].u4.pSchema = pSchema;
+      pSrc->a[0].fg.fixedSchema = 1;
     }
     if( pStep->pFrom ){
       SrcList *pDup = sqlite3SrcListDup(db, pStep->pFrom, 0);
@@ -151447,6 +153624,72 @@ static ExprList *sqlite3ExpandReturning(
   return pNew;
 }
 
+/* If the Expr node is a subquery or an EXISTS operator or an IN operator that
+** uses a subquery, and if the subquery is SF_Correlated, then mark the
+** expression as EP_VarSelect.
+*/
+static int sqlite3ReturningSubqueryVarSelect(Walker *NotUsed, Expr *pExpr){
+  UNUSED_PARAMETER(NotUsed);
+  if( ExprUseXSelect(pExpr)
+   && (pExpr->x.pSelect->selFlags & SF_Correlated)!=0
+  ){
+    testcase( ExprHasProperty(pExpr, EP_VarSelect) );
+    ExprSetProperty(pExpr, EP_VarSelect);
+  }
+  return WRC_Continue;
+}
+
+
+/*
+** If the SELECT references the table pWalker->u.pTab, then do two things:
+**
+**    (1) Mark the SELECT as as SF_Correlated.
+**    (2) Set pWalker->eCode to non-zero so that the caller will know
+**        that (1) has happened.
+*/
+static int sqlite3ReturningSubqueryCorrelated(Walker *pWalker, Select *pSelect){
+  int i;
+  SrcList *pSrc;
+  assert( pSelect!=0 );
+  pSrc = pSelect->pSrc;
+  assert( pSrc!=0 );
+  for(i=0; i<pSrc->nSrc; i++){
+    if( pSrc->a[i].pSTab==pWalker->u.pTab ){
+      testcase( pSelect->selFlags & SF_Correlated );
+      pSelect->selFlags |= SF_Correlated;
+      pWalker->eCode = 1;
+      break;
+    }
+  }
+  return WRC_Continue;
+}
+
+/*
+** Scan the expression list that is the argument to RETURNING looking
+** for subqueries that depend on the table which is being modified in the
+** statement that is hosting the RETURNING clause (pTab).  Mark all such
+** subqueries as SF_Correlated.  If the subqueries are part of an
+** expression, mark the expression as EP_VarSelect.
+**
+** https://sqlite.org/forum/forumpost/2c83569ce8945d39
+*/
+static void sqlite3ProcessReturningSubqueries(
+  ExprList *pEList,
+  Table *pTab
+){
+  Walker w;
+  memset(&w, 0, sizeof(w));
+  w.xExprCallback = sqlite3ExprWalkNoop;
+  w.xSelectCallback = sqlite3ReturningSubqueryCorrelated;
+  w.u.pTab = pTab;
+  sqlite3WalkExprList(&w, pEList);
+  if( w.eCode ){
+    w.xExprCallback = sqlite3ReturningSubqueryVarSelect;
+    w.xSelectCallback = sqlite3SelectWalkNoop;
+    sqlite3WalkExprList(&w, pEList);
+  }
+}
+
 /*
 ** Generate code for the RETURNING trigger.  Unlike other triggers
 ** that invoke a subprogram in the bytecode, the code for RETURNING
@@ -151482,7 +153725,8 @@ static void codeReturningTrigger(
   sSelect.pEList = sqlite3ExprListDup(db, pReturning->pReturnEL, 0);
   sSelect.pSrc = &sFrom;
   sFrom.nSrc = 1;
-  sFrom.a[0].pTab = pTab;
+  sFrom.a[0].pSTab = pTab;
+  sFrom.a[0].zName = pTab->zName; /* tag-20240424-1 */
   sFrom.a[0].iCursor = -1;
   sqlite3SelectPrep(pParse, &sSelect, 0);
   if( pParse->nErr==0 ){
@@ -151509,6 +153753,7 @@ static void codeReturningTrigger(
       int i;
       int nCol = pNew->nExpr;
       int reg = pParse->nMem+1;
+      sqlite3ProcessReturningSubqueries(pNew, pTab);
       pParse->nMem += nCol+2;
       pReturning->iRetReg = reg;
       for(i=0; i<nCol; i++){
@@ -152191,7 +154436,7 @@ static void updateFromSelect(
   Expr *pLimit2 = 0;
   ExprList *pOrderBy2 = 0;
   sqlite3 *db = pParse->db;
-  Table *pTab = pTabList->a[0].pTab;
+  Table *pTab = pTabList->a[0].pSTab;
   SrcList *pSrc;
   Expr *pWhere2;
   int eDest;
@@ -152215,8 +154460,8 @@ static void updateFromSelect(
   if( pSrc ){
     assert( pSrc->a[0].fg.notCte );
     pSrc->a[0].iCursor = -1;
-    pSrc->a[0].pTab->nTabRef--;
-    pSrc->a[0].pTab = 0;
+    pSrc->a[0].pSTab->nTabRef--;
+    pSrc->a[0].pSTab = 0;
   }
   if( pPk ){
     for(i=0; i<pPk->nKeyCol; i++){
@@ -152910,6 +155155,9 @@ SQLITE_PRIVATE void sqlite3Update(
       }
     }
     if( chngRowid==0 && pPk==0 ){
+#ifdef SQLITE_ALLOW_ROWID_IN_VIEW
+      if( isView ) sqlite3VdbeAddOp2(v, OP_Null, 0, regOldRowid);
+#endif
       sqlite3VdbeAddOp2(v, OP_Copy, regOldRowid, regNewRowid);
     }
   }
@@ -153447,7 +155695,8 @@ SQLITE_PRIVATE Upsert *sqlite3UpsertNew(
 SQLITE_PRIVATE int sqlite3UpsertAnalyzeTarget(
   Parse *pParse,     /* The parsing context */
   SrcList *pTabList, /* Table into which we are inserting */
-  Upsert *pUpsert    /* The ON CONFLICT clauses */
+  Upsert *pUpsert,   /* The ON CONFLICT clauses */
+  Upsert *pAll       /* Complete list of all ON CONFLICT clauses */
 ){
   Table *pTab;            /* That table into which we are inserting */
   int rc;                 /* Result code */
@@ -153460,7 +155709,7 @@ SQLITE_PRIVATE int sqlite3UpsertAnalyzeTarget(
   int nClause = 0;        /* Counter of ON CONFLICT clauses */
 
   assert( pTabList->nSrc==1 );
-  assert( pTabList->a[0].pTab!=0 );
+  assert( pTabList->a[0].pSTab!=0 );
   assert( pUpsert!=0 );
   assert( pUpsert->pUpsertTarget!=0 );
 
@@ -153479,7 +155728,7 @@ SQLITE_PRIVATE int sqlite3UpsertAnalyzeTarget(
     if( rc ) return rc;
 
     /* Check to see if the conflict target matches the rowid. */
-    pTab = pTabList->a[0].pTab;
+    pTab = pTabList->a[0].pSTab;
     pTarget = pUpsert->pUpsertTarget;
     iCursor = pTabList->a[0].iCursor;
     if( HasRowid(pTab)
@@ -153550,6 +155799,14 @@ SQLITE_PRIVATE int sqlite3UpsertAnalyzeTarget(
         continue;
       }
       pUpsert->pUpsertIdx = pIdx;
+      if( sqlite3UpsertOfIndex(pAll,pIdx)!=pUpsert ){
+        /* Really this should be an error.  The isDup ON CONFLICT clause will
+        ** never fire.  But this problem was not discovered until three years
+        ** after multi-CONFLICT upsert was added, and so we silently ignore
+        ** the problem to prevent breaking applications that might actually
+        ** have redundant ON CONFLICT clauses. */
+        pUpsert->isDup = 1;
+      }
       break;
     }
     if( pUpsert->pUpsertIdx==0 ){
@@ -153576,9 +155833,13 @@ SQLITE_PRIVATE int sqlite3UpsertNextIsIPK(Upsert *pUpsert){
   Upsert *pNext;
   if( NEVER(pUpsert==0) ) return 0;
   pNext = pUpsert->pNextUpsert;
-  if( pNext==0 ) return 1;
-  if( pNext->pUpsertTarget==0 ) return 1;
-  if( pNext->pUpsertIdx==0 ) return 1;
+  while( 1 /*exit-by-return*/ ){
+    if( pNext==0 ) return 1;
+    if( pNext->pUpsertTarget==0 ) return 1;
+    if( pNext->pUpsertIdx==0 ) return 1;
+    if( !pNext->isDup ) return 0;
+    pNext = pNext->pNextUpsert;
+  }
   return 0;
 }
 
@@ -153838,6 +156099,9 @@ SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3RunVacuum(
   const char *zDbMain;    /* Schema name of database to vacuum */
   const char *zOut;       /* Name of output file */
   u32 pgflags = PAGER_SYNCHRONOUS_OFF; /* sync flags for output db */
+  u64 iRandom;            /* Random value used for zDbVacuum[] */
+  char zDbVacuum[42];     /* Name of the ATTACH-ed database used for vacuum */
+
 
   if( !db->autoCommit ){
     sqlite3SetString(pzErrMsg, db, "cannot VACUUM from within a transaction");
@@ -153878,27 +156142,29 @@ SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3RunVacuum(
   pMain = db->aDb[iDb].pBt;
   isMemDb = sqlite3PagerIsMemdb(sqlite3BtreePager(pMain));
 
-  /* Attach the temporary database as 'vacuum_db'. The synchronous pragma
+  /* Attach the temporary database as 'vacuum_XXXXXX'. The synchronous pragma
   ** can be set to 'off' for this file, as it is not recovered if a crash
   ** occurs anyway. The integrity of the database is maintained by a
   ** (possibly synchronous) transaction opened on the main database before
   ** sqlite3BtreeCopyFile() is called.
   **
   ** An optimization would be to use a non-journaled pager.
-  ** (Later:) I tried setting "PRAGMA vacuum_db.journal_mode=OFF" but
+  ** (Later:) I tried setting "PRAGMA vacuum_XXXXXX.journal_mode=OFF" but
   ** that actually made the VACUUM run slower.  Very little journalling
   ** actually occurs when doing a vacuum since the vacuum_db is initially
   ** empty.  Only the journal header is written.  Apparently it takes more
   ** time to parse and run the PRAGMA to turn journalling off than it does
   ** to write the journal header file.
   */
+  sqlite3_randomness(sizeof(iRandom),&iRandom);
+  sqlite3_snprintf(sizeof(zDbVacuum), zDbVacuum, "vacuum_%016llx", iRandom);
   nDb = db->nDb;
-  rc = execSqlF(db, pzErrMsg, "ATTACH %Q AS vacuum_db", zOut);
+  rc = execSqlF(db, pzErrMsg, "ATTACH %Q AS %s", zOut, zDbVacuum);
   db->openFlags = saved_openFlags;
   if( rc!=SQLITE_OK ) goto end_of_vacuum;
   assert( (db->nDb-1)==nDb );
   pDb = &db->aDb[nDb];
-  assert( strcmp(pDb->zDbSName,"vacuum_db")==0 );
+  assert( strcmp(pDb->zDbSName,zDbVacuum)==0 );
   pTemp = pDb->pBt;
   if( pOut ){
     sqlite3_file *id = sqlite3PagerFile(sqlite3BtreePager(pTemp));
@@ -153975,11 +156241,11 @@ SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3RunVacuum(
   ** the contents to the temporary database.
   */
   rc = execSqlF(db, pzErrMsg,
-      "SELECT'INSERT INTO vacuum_db.'||quote(name)"
+      "SELECT'INSERT INTO %s.'||quote(name)"
       "||' SELECT*FROM\"%w\".'||quote(name)"
-      "FROM vacuum_db.sqlite_schema "
+      "FROM %s.sqlite_schema "
       "WHERE type='table'AND coalesce(rootpage,1)>0",
-      zDbMain
+      zDbVacuum, zDbMain, zDbVacuum
   );
   assert( (db->mDbFlags & DBFLAG_Vacuum)!=0 );
   db->mDbFlags &= ~DBFLAG_Vacuum;
@@ -153991,11 +156257,11 @@ SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3RunVacuum(
   ** from the schema table.
   */
   rc = execSqlF(db, pzErrMsg,
-      "INSERT INTO vacuum_db.sqlite_schema"
+      "INSERT INTO %s.sqlite_schema"
       " SELECT*FROM \"%w\".sqlite_schema"
       " WHERE type IN('view','trigger')"
       " OR(type='table'AND rootpage=0)",
-      zDbMain
+      zDbVacuum, zDbMain
   );
   if( rc ) goto end_of_vacuum;
 
@@ -154703,6 +156969,8 @@ static int vtabCallConstructor(
   db->pVtabCtx = &sCtx;
   pTab->nTabRef++;
   rc = xConstruct(db, pMod->pAux, nArg, azArg, &pVTable->pVtab, &zErr);
+  assert( pTab!=0 );
+  assert( pTab->nTabRef>1 || rc!=SQLITE_OK );
   sqlite3DeleteTable(db, pTab);
   db->pVtabCtx = sCtx.pPrior;
   if( rc==SQLITE_NOMEM ) sqlite3OomFault(db);
@@ -154725,7 +156993,7 @@ static int vtabCallConstructor(
     pVTable->nRef = 1;
     if( sCtx.bDeclared==0 ){
       const char *zFormat = "vtable constructor did not declare schema: %s";
-      *pzErr = sqlite3MPrintf(db, zFormat, pTab->zName);
+      *pzErr = sqlite3MPrintf(db, zFormat, zModuleName);
       sqlite3VtabUnlock(pVTable);
       rc = SQLITE_ERROR;
     }else{
@@ -154903,12 +157171,30 @@ SQLITE_API int sqlite3_declare_vtab(sqlite3 *db, const char *zCreateTable){
   Table *pTab;
   Parse sParse;
   int initBusy;
+  int i;
+  const unsigned char *z;
+  static const u8 aKeyword[] = { TK_CREATE, TK_TABLE, 0 };
 
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) || zCreateTable==0 ){
     return SQLITE_MISUSE_BKPT;
   }
 #endif
+
+  /* Verify that the first two keywords in the CREATE TABLE statement
+  ** really are "CREATE" and "TABLE".  If this is not the case, then
+  ** sqlite3_declare_vtab() is being misused.
+  */
+  z = (const unsigned char*)zCreateTable;
+  for(i=0; aKeyword[i]; i++){
+    int tokenType = 0;
+    do{ z += sqlite3GetToken(z, &tokenType); }while( tokenType==TK_SPACE );
+    if( tokenType!=aKeyword[i] ){
+      sqlite3ErrorWithMsg(db, SQLITE_ERROR, "syntax error");
+      return SQLITE_ERROR;
+    }
+  }
+
   sqlite3_mutex_enter(db->mutex);
   pCtx = db->pVtabCtx;
   if( !pCtx || pCtx->bDeclared ){
@@ -154916,6 +157202,7 @@ SQLITE_API int sqlite3_declare_vtab(sqlite3 *db, const char *zCreateTable){
     sqlite3_mutex_leave(db->mutex);
     return SQLITE_MISUSE_BKPT;
   }
+
   pTab = pCtx->pTab;
   assert( IsVirtual(pTab) );
 
@@ -154929,16 +157216,16 @@ SQLITE_API int sqlite3_declare_vtab(sqlite3 *db, const char *zCreateTable){
   initBusy = db->init.busy;
   db->init.busy = 0;
   sParse.nQueryLoop = 1;
-  if( SQLITE_OK==sqlite3RunParser(&sParse, zCreateTable)
-   && ALWAYS(sParse.pNewTable!=0)
-   && ALWAYS(!db->mallocFailed)
-   && IsOrdinaryTable(sParse.pNewTable)
-  ){
+  if( SQLITE_OK==sqlite3RunParser(&sParse, zCreateTable) ){
+    assert( sParse.pNewTable!=0 );
+    assert( !db->mallocFailed );
+    assert( IsOrdinaryTable(sParse.pNewTable) );
     assert( sParse.zErrMsg==0 );
     if( !pTab->aCol ){
       Table *pNew = sParse.pNewTable;
       Index *pIdx;
       pTab->aCol = pNew->aCol;
+      assert( IsOrdinaryTable(pNew) );
       sqlite3ExprListDelete(db, pNew->u.tab.pDfltList);
       pTab->nNVCol = pTab->nCol = pNew->nCol;
       pTab->tabFlags |= pNew->tabFlags & (TF_WithoutRowid|TF_NoVisibleRowid);
@@ -155613,11 +157900,13 @@ struct WhereLoop {
       u16 nTop;              /* Size of TOP vector */
       u16 nDistinctCol;      /* Index columns used to sort for DISTINCT */
       Index *pIndex;         /* Index used, or NULL */
+      ExprList *pOrderBy;    /* ORDER BY clause if this is really a subquery */
     } btree;
     struct {               /* Information for virtual tables */
       int idxNum;            /* Index number */
       u32 needFree : 1;      /* True if sqlite3_free(idxStr) is needed */
       u32 bOmitOffset : 1;   /* True to let virtual table handle offset */
+      u32 bIdxNumHex : 1;    /* Show idxNum as hex in EXPLAIN QUERY PLAN */
       i8 isOrdered;          /* True if satisfies ORDER BY */
       u16 omitMask;          /* Terms that may be omitted */
       char *idxStr;          /* Index identifier string */
@@ -155630,6 +157919,8 @@ struct WhereLoop {
   /**** whereLoopXfer() copies fields above ***********************/
 # define WHERE_LOOP_XFER_SZ offsetof(WhereLoop,nLSlot)
   u16 nLSlot;           /* Number of slots allocated for aLTerm[] */
+  LogEst rStarDelta;    /* Cost delta due to star-schema heuristic.  Not
+                        ** initialized unless pWInfo->nOutStarDelta>0 */
   WhereTerm **aLTerm;   /* WhereTerms used */
   WhereLoop *pNextLoop; /* Next WhereLoop object in the WhereClause */
   WhereTerm *aLTermSpace[3];  /* Initial aLTerm[] space */
@@ -155952,6 +158243,7 @@ struct WhereInfo {
   unsigned untestedTerms :1;   /* Not all WHERE terms resolved by outer loop */
   unsigned bOrderedInnerLoop:1;/* True if only the inner-most loop is ordered */
   unsigned sorted :1;          /* True if really sorted (not just grouped) */
+  LogEst nOutStarDelta;     /* Artifical nOut reduction for star-query */
   LogEst nRowOut;           /* Estimated number of output rows */
   int iTop;                 /* The very beginning of the WHERE loop */
   int iEndWhere;            /* End of the WHERE clause itself */
@@ -156103,7 +158395,8 @@ SQLITE_PRIVATE void sqlite3WhereTabFuncArgs(Parse*, SrcItem*, WhereClause*);
 #define WHERE_BLOOMFILTER  0x00400000  /* Consider using a Bloom-filter */
 #define WHERE_SELFCULL     0x00800000  /* nOut reduced by extra WHERE terms */
 #define WHERE_OMIT_OFFSET  0x01000000  /* Set offset counter to zero */
-                      /*   0x02000000  -- available for reuse */
+#define WHERE_COROUTINE    0x02000000  /* Implemented by co-routine.
+                                       ** NB: False-negatives are possible */
 #define WHERE_EXPRIDX      0x04000000  /* Uses an index-on-expressions */
 
 #endif /* !defined(SQLITE_WHEREINT_H) */
@@ -156248,7 +158541,7 @@ SQLITE_PRIVATE int sqlite3WhereExplainOneScan(
       assert( pLoop->u.btree.pIndex!=0 );
       pIdx = pLoop->u.btree.pIndex;
       assert( !(flags&WHERE_AUTO_INDEX) || (flags&WHERE_IDX_ONLY) );
-      if( !HasRowid(pItem->pTab) && IsPrimaryKeyIndex(pIdx) ){
+      if( !HasRowid(pItem->pSTab) && IsPrimaryKeyIndex(pIdx) ){
         if( isSearch ){
           zFmt = "PRIMARY KEY";
         }
@@ -156291,7 +158584,9 @@ SQLITE_PRIVATE int sqlite3WhereExplainOneScan(
     }
 #ifndef SQLITE_OMIT_VIRTUALTABLE
     else if( (flags & WHERE_VIRTUALTABLE)!=0 ){
-      sqlite3_str_appendf(&str, " VIRTUAL TABLE INDEX %d:%s",
+      sqlite3_str_appendall(&str, " VIRTUAL TABLE INDEX ");
+      sqlite3_str_appendf(&str,
+                  pLoop->u.vtab.bIdxNumHex ? "0x%x:%s" : "%d:%s",
                   pLoop->u.vtab.idxNum, pLoop->u.vtab.idxStr);
     }
 #endif
@@ -156309,7 +158604,8 @@ SQLITE_PRIVATE int sqlite3WhereExplainOneScan(
     zMsg = sqlite3StrAccumFinish(&str);
     sqlite3ExplainBreakpoint("",zMsg);
     ret = sqlite3VdbeAddOp4(v, OP_Explain, sqlite3VdbeCurrentAddr(v),
-                            pParse->addrExplain, 0, zMsg,P4_DYNAMIC);
+                            pParse->addrExplain, pLoop->rRun,
+                            zMsg, P4_DYNAMIC);
   }
   return ret;
 }
@@ -156344,7 +158640,7 @@ SQLITE_PRIVATE int sqlite3WhereExplainBloomFilter(
   sqlite3_str_appendf(&str, "BLOOM FILTER ON %S (", pItem);
   pLoop = pLevel->pWLoop;
   if( pLoop->wsFlags & WHERE_IPK ){
-    const Table *pTab = pItem->pTab;
+    const Table *pTab = pItem->pSTab;
     if( pTab->iPKey>=0 ){
       sqlite3_str_appendf(&str, "%s=?", pTab->aCol[pTab->iPKey].zCnName);
     }else{
@@ -156407,7 +158703,9 @@ SQLITE_PRIVATE void sqlite3WhereAddScanStatus(
         sqlite3VdbeScanStatusRange(v, addrExplain, -1, pLvl->iIdxCur);
       }
     }else{
-      int addr = pSrclist->a[pLvl->iFrom].addrFillSub;
+      int addr;
+      assert( pSrclist->a[pLvl->iFrom].fg.isSubquery );
+      addr = pSrclist->a[pLvl->iFrom].u4.pSubq->addrFillSub;
       VdbeOp *pOp = sqlite3VdbeGetOp(v, addr-1);
       assert( sqlite3VdbeDb(v)->mallocFailed || pOp->opcode==OP_InitCoroutine );
       assert( sqlite3VdbeDb(v)->mallocFailed || pOp->p2>addr );
@@ -156551,6 +158849,39 @@ static void updateRangeAffinityStr(
   }
 }
 
+/*
+** The pOrderBy->a[].u.x.iOrderByCol values might be incorrect because
+** columns might have been rearranged in the result set.  This routine
+** fixes them up.
+**
+** pEList is the new result set.  The pEList->a[].u.x.iOrderByCol values
+** contain the *old* locations of each expression.  This is a temporary
+** use of u.x.iOrderByCol, not its intended use.  The caller must reset
+** u.x.iOrderByCol back to zero for all entries in pEList before the
+** caller returns.
+**
+** This routine changes pOrderBy->a[].u.x.iOrderByCol values from
+** pEList->a[N].u.x.iOrderByCol into N+1.  (The "+1" is because of the 1-based
+** indexing used by iOrderByCol.)  Or if no match, iOrderByCol is set to zero.
+*/
+static void adjustOrderByCol(ExprList *pOrderBy, ExprList *pEList){
+  int i, j;
+  if( pOrderBy==0 ) return;
+  for(i=0; i<pOrderBy->nExpr; i++){
+    int t = pOrderBy->a[i].u.x.iOrderByCol;
+    if( t==0 ) continue;
+    for(j=0; j<pEList->nExpr; j++){
+      if( pEList->a[j].u.x.iOrderByCol==t ){
+        pOrderBy->a[i].u.x.iOrderByCol = j+1;
+        break;
+      }
+    }
+    if( j>=pEList->nExpr ){
+      pOrderBy->a[i].u.x.iOrderByCol = 0;
+    }
+  }
+}
+
 
 /*
 ** pX is an expression of the form:  (vector) IN (SELECT ...)
@@ -156614,6 +158945,7 @@ static Expr *removeUnindexableInClauseTerms(
           if( pOrigRhs->a[iField].pExpr==0 ) continue; /* Duplicate PK column */
           pRhs = sqlite3ExprListAppend(pParse, pRhs, pOrigRhs->a[iField].pExpr);
           pOrigRhs->a[iField].pExpr = 0;
+          if( pRhs ) pRhs->a[pRhs->nExpr-1].u.x.iOrderByCol = iField+1;
           if( pOrigLhs ){
             assert( pOrigLhs->a[iField].pExpr!=0 );
             pLhs = sqlite3ExprListAppend(pParse,pLhs,pOrigLhs->a[iField].pExpr);
@@ -156627,6 +158959,7 @@ static Expr *removeUnindexableInClauseTerms(
         pNew->pLeft->x.pList = pLhs;
       }
       pSelect->pEList = pRhs;
+      pSelect->selId = ++pParse->nSelect; /* Req'd for SubrtnSig validity */
       if( pLhs && pLhs->nExpr==1 ){
         /* Take care here not to generate a TK_VECTOR containing only a
         ** single value. Since the parser never creates such a vector, some
@@ -156636,18 +158969,16 @@ static Expr *removeUnindexableInClauseTerms(
         sqlite3ExprDelete(db, pNew->pLeft);
         pNew->pLeft = p;
       }
-      if( pSelect->pOrderBy ){
-        /* If the SELECT statement has an ORDER BY clause, zero the
-        ** iOrderByCol variables. These are set to non-zero when an
-        ** ORDER BY term exactly matches one of the terms of the
-        ** result-set. Since the result-set of the SELECT statement may
-        ** have been modified or reordered, these variables are no longer
-        ** set correctly.  Since setting them is just an optimization,
-        ** it's easiest just to zero them here.  */
-        ExprList *pOrderBy = pSelect->pOrderBy;
-        for(i=0; i<pOrderBy->nExpr; i++){
-          pOrderBy->a[i].u.x.iOrderByCol = 0;
-        }
+
+      /* If either the ORDER BY clause or the GROUP BY clause contains
+      ** references to result-set columns, those references might now be
+      ** obsolete.  So fix them up.
+      */
+      assert( pRhs!=0 || db->mallocFailed );
+      if( pRhs ){
+        adjustOrderByCol(pSelect->pOrderBy, pRhs);
+        adjustOrderByCol(pSelect->pGroupBy, pRhs);
+        for(i=0; i<pRhs->nExpr; i++) pRhs->a[i].u.x.iOrderByCol = 0;
       }
 
 #if 0
@@ -156662,6 +158993,147 @@ static Expr *removeUnindexableInClauseTerms(
 }
 
 
+#ifndef SQLITE_OMIT_SUBQUERY
+/*
+** Generate code for a single X IN (....) term of the WHERE clause.
+**
+** This is a special-case of codeEqualityTerm() that works for IN operators
+** only.  It is broken out into a subroutine because this case is
+** uncommon and by splitting it off into a subroutine, the common case
+** runs faster.
+**
+** The current value for the constraint is left in  register iTarget.
+** This routine sets up a loop that will iterate over all values of X.
+*/
+static SQLITE_NOINLINE void codeINTerm(
+  Parse *pParse,      /* The parsing context */
+  WhereTerm *pTerm,   /* The term of the WHERE clause to be coded */
+  WhereLevel *pLevel, /* The level of the FROM clause we are working on */
+  int iEq,            /* Index of the equality term within this level */
+  int bRev,           /* True for reverse-order IN operations */
+  int iTarget         /* Attempt to leave results in this register */
+){
+  Expr *pX = pTerm->pExpr;
+  int eType = IN_INDEX_NOOP;
+  int iTab;
+  struct InLoop *pIn;
+  WhereLoop *pLoop = pLevel->pWLoop;
+  Vdbe *v = pParse->pVdbe;
+  int i;
+  int nEq = 0;
+  int *aiMap = 0;
+
+  if( (pLoop->wsFlags & WHERE_VIRTUALTABLE)==0
+    && pLoop->u.btree.pIndex!=0
+    && pLoop->u.btree.pIndex->aSortOrder[iEq]
+  ){
+    testcase( iEq==0 );
+    testcase( bRev );
+    bRev = !bRev;
+  }
+  assert( pX->op==TK_IN );
+
+  for(i=0; i<iEq; i++){
+    if( pLoop->aLTerm[i] && pLoop->aLTerm[i]->pExpr==pX ){
+      disableTerm(pLevel, pTerm);
+      return;
+    }
+  }
+  for(i=iEq;i<pLoop->nLTerm; i++){
+    assert( pLoop->aLTerm[i]!=0 );
+    if( pLoop->aLTerm[i]->pExpr==pX ) nEq++;
+  }
+
+  iTab = 0;
+  if( !ExprUseXSelect(pX) || pX->x.pSelect->pEList->nExpr==1 ){
+    eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, 0, &iTab);
+  }else{
+    Expr *pExpr = pTerm->pExpr;
+    if( pExpr->iTable==0 || !ExprHasProperty(pExpr, EP_Subrtn) ){
+      sqlite3 *db = pParse->db;
+      pX = removeUnindexableInClauseTerms(pParse, iEq, pLoop, pX);
+      if( !db->mallocFailed ){
+        aiMap = (int*)sqlite3DbMallocZero(pParse->db, sizeof(int)*nEq);
+        eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, aiMap,&iTab);
+        pExpr->iTable = iTab;
+      }
+      sqlite3ExprDelete(db, pX);
+    }else{
+      int n = sqlite3ExprVectorSize(pX->pLeft);
+      aiMap = (int*)sqlite3DbMallocZero(pParse->db, sizeof(int)*MAX(nEq,n));
+      eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, aiMap, &iTab);
+    }
+    pX = pExpr;
+  }
+
+  if( eType==IN_INDEX_INDEX_DESC ){
+    testcase( bRev );
+    bRev = !bRev;
+  }
+  sqlite3VdbeAddOp2(v, bRev ? OP_Last : OP_Rewind, iTab, 0);
+  VdbeCoverageIf(v, bRev);
+  VdbeCoverageIf(v, !bRev);
+
+  assert( (pLoop->wsFlags & WHERE_MULTI_OR)==0 );
+  pLoop->wsFlags |= WHERE_IN_ABLE;
+  if( pLevel->u.in.nIn==0 ){
+    pLevel->addrNxt = sqlite3VdbeMakeLabel(pParse);
+  }
+  if( iEq>0 && (pLoop->wsFlags & WHERE_IN_SEEKSCAN)==0 ){
+    pLoop->wsFlags |= WHERE_IN_EARLYOUT;
+  }
+
+  i = pLevel->u.in.nIn;
+  pLevel->u.in.nIn += nEq;
+  pLevel->u.in.aInLoop =
+     sqlite3WhereRealloc(pTerm->pWC->pWInfo,
+                         pLevel->u.in.aInLoop,
+                         sizeof(pLevel->u.in.aInLoop[0])*pLevel->u.in.nIn);
+  pIn = pLevel->u.in.aInLoop;
+  if( pIn ){
+    int iMap = 0;               /* Index in aiMap[] */
+    pIn += i;
+    for(i=iEq;i<pLoop->nLTerm; i++){
+      if( pLoop->aLTerm[i]->pExpr==pX ){
+        int iOut = iTarget + i - iEq;
+        if( eType==IN_INDEX_ROWID ){
+          pIn->addrInTop = sqlite3VdbeAddOp2(v, OP_Rowid, iTab, iOut);
+        }else{
+          int iCol = aiMap ? aiMap[iMap++] : 0;
+          pIn->addrInTop = sqlite3VdbeAddOp3(v,OP_Column,iTab, iCol, iOut);
+        }
+        sqlite3VdbeAddOp1(v, OP_IsNull, iOut); VdbeCoverage(v);
+        if( i==iEq ){
+          pIn->iCur = iTab;
+          pIn->eEndLoopOp = bRev ? OP_Prev : OP_Next;
+          if( iEq>0 ){
+            pIn->iBase = iTarget - i;
+            pIn->nPrefix = i;
+          }else{
+            pIn->nPrefix = 0;
+          }
+        }else{
+          pIn->eEndLoopOp = OP_Noop;
+        }
+        pIn++;
+      }
+    }
+    testcase( iEq>0
+              && (pLoop->wsFlags & WHERE_IN_SEEKSCAN)==0
+              && (pLoop->wsFlags & WHERE_VIRTUALTABLE)!=0 );
+    if( iEq>0
+     && (pLoop->wsFlags & (WHERE_IN_SEEKSCAN|WHERE_VIRTUALTABLE))==0
+    ){
+      sqlite3VdbeAddOp3(v, OP_SeekHit, pLevel->iIdxCur, 0, iEq);
+    }
+  }else{
+    pLevel->u.in.nIn = 0;
+  }
+  sqlite3DbFree(pParse->db, aiMap);
+}
+#endif
+
+
 /*
 ** Generate code for a single equality term of the WHERE clause.  An equality
 ** term can be either X=expr or X IN (...).   pTerm is the term to be
@@ -156686,7 +159158,6 @@ static int codeEqualityTerm(
   int iTarget         /* Attempt to leave results in this register */
 ){
   Expr *pX = pTerm->pExpr;
-  Vdbe *v = pParse->pVdbe;
   int iReg;                  /* Register holding results */
 
   assert( pLevel->pWLoop->aLTerm[iEq]==pTerm );
@@ -156695,125 +159166,12 @@ static int codeEqualityTerm(
     iReg = sqlite3ExprCodeTarget(pParse, pX->pRight, iTarget);
   }else if( pX->op==TK_ISNULL ){
     iReg = iTarget;
-    sqlite3VdbeAddOp2(v, OP_Null, 0, iReg);
+    sqlite3VdbeAddOp2(pParse->pVdbe, OP_Null, 0, iReg);
 #ifndef SQLITE_OMIT_SUBQUERY
   }else{
-    int eType = IN_INDEX_NOOP;
-    int iTab;
-    struct InLoop *pIn;
-    WhereLoop *pLoop = pLevel->pWLoop;
-    int i;
-    int nEq = 0;
-    int *aiMap = 0;
-
-    if( (pLoop->wsFlags & WHERE_VIRTUALTABLE)==0
-      && pLoop->u.btree.pIndex!=0
-      && pLoop->u.btree.pIndex->aSortOrder[iEq]
-    ){
-      testcase( iEq==0 );
-      testcase( bRev );
-      bRev = !bRev;
-    }
     assert( pX->op==TK_IN );
     iReg = iTarget;
-
-    for(i=0; i<iEq; i++){
-      if( pLoop->aLTerm[i] && pLoop->aLTerm[i]->pExpr==pX ){
-        disableTerm(pLevel, pTerm);
-        return iTarget;
-      }
-    }
-    for(i=iEq;i<pLoop->nLTerm; i++){
-      assert( pLoop->aLTerm[i]!=0 );
-      if( pLoop->aLTerm[i]->pExpr==pX ) nEq++;
-    }
-
-    iTab = 0;
-    if( !ExprUseXSelect(pX) || pX->x.pSelect->pEList->nExpr==1 ){
-      eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, 0, &iTab);
-    }else{
-      Expr *pExpr = pTerm->pExpr;
-      if( pExpr->iTable==0 || !ExprHasProperty(pExpr, EP_Subrtn) ){
-        sqlite3 *db = pParse->db;
-        pX = removeUnindexableInClauseTerms(pParse, iEq, pLoop, pX);
-        if( !db->mallocFailed ){
-          aiMap = (int*)sqlite3DbMallocZero(pParse->db, sizeof(int)*nEq);
-          eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, aiMap,&iTab);
-          pExpr->iTable = iTab;
-        }
-        sqlite3ExprDelete(db, pX);
-      }else{
-        int n = sqlite3ExprVectorSize(pX->pLeft);
-        aiMap = (int*)sqlite3DbMallocZero(pParse->db, sizeof(int)*MAX(nEq,n));
-        eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, aiMap, &iTab);
-      }
-      pX = pExpr;
-    }
-
-    if( eType==IN_INDEX_INDEX_DESC ){
-      testcase( bRev );
-      bRev = !bRev;
-    }
-    sqlite3VdbeAddOp2(v, bRev ? OP_Last : OP_Rewind, iTab, 0);
-    VdbeCoverageIf(v, bRev);
-    VdbeCoverageIf(v, !bRev);
-
-    assert( (pLoop->wsFlags & WHERE_MULTI_OR)==0 );
-    pLoop->wsFlags |= WHERE_IN_ABLE;
-    if( pLevel->u.in.nIn==0 ){
-      pLevel->addrNxt = sqlite3VdbeMakeLabel(pParse);
-    }
-    if( iEq>0 && (pLoop->wsFlags & WHERE_IN_SEEKSCAN)==0 ){
-      pLoop->wsFlags |= WHERE_IN_EARLYOUT;
-    }
-
-    i = pLevel->u.in.nIn;
-    pLevel->u.in.nIn += nEq;
-    pLevel->u.in.aInLoop =
-       sqlite3WhereRealloc(pTerm->pWC->pWInfo,
-                           pLevel->u.in.aInLoop,
-                           sizeof(pLevel->u.in.aInLoop[0])*pLevel->u.in.nIn);
-    pIn = pLevel->u.in.aInLoop;
-    if( pIn ){
-      int iMap = 0;               /* Index in aiMap[] */
-      pIn += i;
-      for(i=iEq;i<pLoop->nLTerm; i++){
-        if( pLoop->aLTerm[i]->pExpr==pX ){
-          int iOut = iReg + i - iEq;
-          if( eType==IN_INDEX_ROWID ){
-            pIn->addrInTop = sqlite3VdbeAddOp2(v, OP_Rowid, iTab, iOut);
-          }else{
-            int iCol = aiMap ? aiMap[iMap++] : 0;
-            pIn->addrInTop = sqlite3VdbeAddOp3(v,OP_Column,iTab, iCol, iOut);
-          }
-          sqlite3VdbeAddOp1(v, OP_IsNull, iOut); VdbeCoverage(v);
-          if( i==iEq ){
-            pIn->iCur = iTab;
-            pIn->eEndLoopOp = bRev ? OP_Prev : OP_Next;
-            if( iEq>0 ){
-              pIn->iBase = iReg - i;
-              pIn->nPrefix = i;
-            }else{
-              pIn->nPrefix = 0;
-            }
-          }else{
-            pIn->eEndLoopOp = OP_Noop;
-          }
-          pIn++;
-        }
-      }
-      testcase( iEq>0
-                && (pLoop->wsFlags & WHERE_IN_SEEKSCAN)==0
-                && (pLoop->wsFlags & WHERE_VIRTUALTABLE)!=0 );
-      if( iEq>0
-       && (pLoop->wsFlags & (WHERE_IN_SEEKSCAN|WHERE_VIRTUALTABLE))==0
-      ){
-        sqlite3VdbeAddOp3(v, OP_SeekHit, pLevel->iIdxCur, 0, iEq);
-      }
-    }else{
-      pLevel->u.in.nIn = 0;
-    }
-    sqlite3DbFree(pParse->db, aiMap);
+    codeINTerm(pParse, pTerm, pLevel, iEq, bRev, iTarget);
 #endif
   }
 
@@ -157428,6 +159786,27 @@ static SQLITE_NOINLINE void filterPullDown(
   }
 }
 
+/*
+** Loop pLoop is a WHERE_INDEXED level that uses at least one IN(...)
+** operator. Return true if level pLoop is guaranteed to visit only one
+** row for each key generated for the index.
+*/
+static int whereLoopIsOneRow(WhereLoop *pLoop){
+  if( pLoop->u.btree.pIndex->onError
+   && pLoop->nSkip==0
+   && pLoop->u.btree.nEq==pLoop->u.btree.pIndex->nKeyCol
+  ){
+    int ii;
+    for(ii=0; ii<pLoop->u.btree.nEq; ii++){
+      if( pLoop->aLTerm[ii]->eOperator & (WO_IS|WO_ISNULL) ){
+        return 0;
+      }
+    }
+    return 1;
+  }
+  return 0;
+}
+
 /*
 ** Generate code for the start of the iLevel-th loop in the WHERE clause
 ** implementation described by pWInfo.
@@ -157464,7 +159843,8 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
   iCur = pTabItem->iCursor;
   pLevel->notReady = notReady & ~sqlite3WhereGetMask(&pWInfo->sMaskSet, iCur);
   bRev = (pWInfo->revMask>>iLevel)&1;
-  VdbeModuleComment((v, "Begin WHERE-loop%d: %s",iLevel,pTabItem->pTab->zName));
+  VdbeModuleComment((v, "Begin WHERE-loop%d: %s",
+                     iLevel, pTabItem->pSTab->zName));
 #if WHERETRACE_ENABLED /* 0x4001 */
   if( sqlite3WhereTrace & 0x1 ){
     sqlite3DebugPrintf("Coding level %d of %d:  notReady=%llx  iFrom=%d\n",
@@ -157506,7 +159886,7 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
   if( pLevel->iFrom>0 && (pTabItem[0].fg.jointype & JT_LEFT)!=0 ){
     pLevel->iLeftJoin = ++pParse->nMem;
     sqlite3VdbeAddOp2(v, OP_Integer, 0, pLevel->iLeftJoin);
-    VdbeComment((v, "init LEFT JOIN no-match flag"));
+    VdbeComment((v, "init LEFT JOIN match flag"));
   }
 
   /* Compute a safe address to jump to if we discover that the table for
@@ -157519,11 +159899,15 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
 
   /* Special case of a FROM clause subquery implemented as a co-routine */
   if( pTabItem->fg.viaCoroutine ){
-    int regYield = pTabItem->regReturn;
-    sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, pTabItem->addrFillSub);
+    int regYield;
+    Subquery *pSubq;
+    assert( pTabItem->fg.isSubquery && pTabItem->u4.pSubq!=0 );
+    pSubq = pTabItem->u4.pSubq;
+    regYield = pSubq->regReturn;
+    sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, pSubq->addrFillSub);
     pLevel->p2 =  sqlite3VdbeAddOp2(v, OP_Yield, regYield, addrBrk);
     VdbeCoverage(v);
-    VdbeComment((v, "next row of %s", pTabItem->pTab->zName));
+    VdbeComment((v, "next row of %s", pTabItem->pSTab->zName));
     pLevel->op = OP_Goto;
   }else
 
@@ -158175,7 +160559,9 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
     }
 
     /* Record the instruction used to terminate the loop. */
-    if( pLoop->wsFlags & WHERE_ONEROW ){
+    if( (pLoop->wsFlags & WHERE_ONEROW)
+     || (pLevel->u.in.nIn && regBignull==0 && whereLoopIsOneRow(pLoop))
+    ){
       pLevel->op = OP_Noop;
     }else if( bRev ){
       pLevel->op = OP_Prev;
@@ -158250,7 +160636,7 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
     int untestedTerms = 0;             /* Some terms not completely tested */
     int ii;                            /* Loop counter */
     Expr *pAndExpr = 0;                /* An ".. AND (...)" expression */
-    Table *pTab = pTabItem->pTab;
+    Table *pTab = pTabItem->pSTab;
 
     pTerm = pLoop->aLTerm[0];
     assert( pTerm!=0 );
@@ -158565,6 +160951,12 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
   ** iLoop==3: Code all remaining expressions.
   **
   ** An effort is made to skip unnecessary iterations of the loop.
+  **
+  ** This optimization of causing simple query restrictions to occur before
+  ** more complex one is call the "push-down" optimization in MySQL.  Here
+  ** in SQLite, the name is "MySQL push-down", since there is also another
+  ** totally unrelated optimization called "WHERE-clause push-down".
+  ** Sometimes the qualifier is omitted, resulting in an ambiguity, so beware.
   */
   iLoop = (pIdx ? 1 : 2);
   do{
@@ -158703,7 +161095,7 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
     ** least once.  This is accomplished by storing the PK for the row in
     ** both the iMatch index and the regBloom Bloom filter.
     */
-    pTab = pWInfo->pTabList->a[pLevel->iFrom].pTab;
+    pTab = pWInfo->pTabList->a[pLevel->iFrom].pSTab;
     if( HasRowid(pTab) ){
       r = sqlite3GetTempRange(pParse, 2);
       sqlite3ExprCodeGetColumnOfTable(v, pTab, pLevel->iTabCur, -1, r+1);
@@ -158810,12 +161202,25 @@ SQLITE_PRIVATE SQLITE_NOINLINE void sqlite3WhereRightJoinLoop(
   Bitmask mAll = 0;
   int k;
 
-  ExplainQueryPlan((pParse, 1, "RIGHT-JOIN %s", pTabItem->pTab->zName));
+  ExplainQueryPlan((pParse, 1, "RIGHT-JOIN %s", pTabItem->pSTab->zName));
   sqlite3VdbeNoJumpsOutsideSubrtn(v, pRJ->addrSubrtn, pRJ->endSubrtn,
                                   pRJ->regReturn);
   for(k=0; k<iLevel; k++){
     int iIdxCur;
+    SrcItem *pRight;
+    assert( pWInfo->a[k].pWLoop->iTab == pWInfo->a[k].iFrom );
+    pRight = &pWInfo->pTabList->a[pWInfo->a[k].iFrom];
     mAll |= pWInfo->a[k].pWLoop->maskSelf;
+    if( pRight->fg.viaCoroutine ){
+      Subquery *pSubq;
+      assert( pRight->fg.isSubquery && pRight->u4.pSubq!=0 );
+      pSubq = pRight->u4.pSubq;
+      assert( pSubq->pSelect!=0 && pSubq->pSelect->pEList!=0 );
+      sqlite3VdbeAddOp3(
+          v, OP_Null, 0, pSubq->regResult,
+          pSubq->regResult + pSubq->pSelect->pEList->nExpr-1
+      );
+    }
     sqlite3VdbeAddOp1(v, OP_NullRow, pWInfo->a[k].iTabCur);
     iIdxCur = pWInfo->a[k].iIdxCur;
     if( iIdxCur ){
@@ -158851,7 +161256,7 @@ SQLITE_PRIVATE SQLITE_NOINLINE void sqlite3WhereRightJoinLoop(
     int nPk;
     int jmp;
     int addrCont = sqlite3WhereContinueLabel(pSubWInfo);
-    Table *pTab = pTabItem->pTab;
+    Table *pTab = pTabItem->pSTab;
     if( HasRowid(pTab) ){
       sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, -1, r);
       nPk = 1;
@@ -158984,7 +161389,12 @@ static int allowedOp(int op){
   assert( TK_LT>TK_EQ && TK_LT<TK_GE );
   assert( TK_LE>TK_EQ && TK_LE<TK_GE );
   assert( TK_GE==TK_EQ+4 );
-  return op==TK_IN || (op>=TK_EQ && op<=TK_GE) || op==TK_ISNULL || op==TK_IS;
+  assert( TK_IN<TK_EQ );
+  assert( TK_IS<TK_EQ );
+  assert( TK_ISNULL<TK_EQ );
+  if( op>TK_GE ) return 0;
+  if( op>=TK_EQ ) return 1;
+  return op==TK_IN || op==TK_ISNULL || op==TK_IS;
 }
 
 /*
@@ -159017,15 +161427,16 @@ static u16 exprCommute(Parse *pParse, Expr *pExpr){
 static u16 operatorMask(int op){
   u16 c;
   assert( allowedOp(op) );
-  if( op==TK_IN ){
+  if( op>=TK_EQ ){
+    assert( (WO_EQ<<(op-TK_EQ)) < 0x7fff );
+    c = (u16)(WO_EQ<<(op-TK_EQ));
+  }else if( op==TK_IN ){
     c = WO_IN;
   }else if( op==TK_ISNULL ){
     c = WO_ISNULL;
-  }else if( op==TK_IS ){
-    c = WO_IS;
   }else{
-    assert( (WO_EQ<<(op-TK_EQ)) < 0x7fff );
-    c = (u16)(WO_EQ<<(op-TK_EQ));
+    assert( op==TK_IS );
+    c = WO_IS;
   }
   assert( op!=TK_ISNULL || c==WO_ISNULL );
   assert( op!=TK_IN || c==WO_IN );
@@ -159096,12 +161507,26 @@ static int isLikeOrGlob(
      z = (u8*)pRight->u.zToken;
   }
   if( z ){
-
-    /* Count the number of prefix characters prior to the first wildcard */
+    /* Count the number of prefix bytes prior to the first wildcard.
+    ** or U+fffd character.  If the underlying database has a UTF16LE
+    ** encoding, then only consider ASCII characters.  Note that the
+    ** encoding of z[] is UTF8 - we are dealing with only UTF8 here in
+    ** this code, but the database engine itself might be processing
+    ** content using a different encoding. */
     cnt = 0;
     while( (c=z[cnt])!=0 && c!=wc[0] && c!=wc[1] && c!=wc[2] ){
       cnt++;
-      if( c==wc[3] && z[cnt]!=0 ) cnt++;
+      if( c==wc[3] && z[cnt]>0 && z[cnt]<0x80 ){
+        cnt++;
+      }else if( c>=0x80 ){
+        const u8 *z2 = z+cnt-1;
+        if( sqlite3Utf8Read(&z2)==0xfffd || ENC(db)==SQLITE_UTF16LE ){
+          cnt--;
+          break;
+        }else{
+          cnt = (int)(z2-z);
+        }
+      }
     }
 
     /* The optimization is possible only if (1) the pattern does not begin
@@ -159112,11 +161537,11 @@ static int isLikeOrGlob(
     ** range search. The third is because the caller assumes that the pattern
     ** consists of at least one character after all escapes have been
     ** removed.  */
-    if( (cnt>1 || (cnt>0 && z[0]!=wc[3])) && 255!=(u8)z[cnt-1] ){
+    if( (cnt>1 || (cnt>0 && z[0]!=wc[3])) && ALWAYS(255!=(u8)z[cnt-1]) ){
       Expr *pPrefix;
 
       /* A "complete" match if the pattern ends with "*" or "%" */
-      *pisComplete = c==wc[0] && z[cnt+1]==0;
+      *pisComplete = c==wc[0] && z[cnt+1]==0 && ENC(db)!=SQLITE_UTF16LE;
 
       /* Get the pattern prefix.  Remove all escapes from the prefix. */
       pPrefix = sqlite3Expr(db, TK_STRING, (char*)z);
@@ -159312,6 +161737,13 @@ static int isAuxiliaryVtabOperator(
         }
       }
     }
+  }else if( pExpr->op>=TK_EQ ){
+    /* Comparison operators are a common case.  Save a few comparisons for
+    ** that common case by terminating early. */
+    assert( TK_NE < TK_EQ );
+    assert( TK_ISNOT < TK_EQ );
+    assert( TK_NOTNULL < TK_EQ );
+    return 0;
   }else if( pExpr->op==TK_NE || pExpr->op==TK_ISNOT || pExpr->op==TK_NOTNULL ){
     int res = 0;
     Expr *pLeft = pExpr->pLeft;
@@ -159828,7 +162260,9 @@ static Bitmask exprSelectUsage(WhereMaskSet *pMaskSet, Select *pS){
     if( ALWAYS(pSrc!=0) ){
       int i;
       for(i=0; i<pSrc->nSrc; i++){
-        mask |= exprSelectUsage(pMaskSet, pSrc->a[i].pSelect);
+        if( pSrc->a[i].fg.isSubquery ){
+          mask |= exprSelectUsage(pMaskSet, pSrc->a[i].u4.pSubq->pSelect);
+        }
         if( pSrc->a[i].fg.isUsing==0 ){
           mask |= sqlite3WhereExprUsage(pMaskSet, pSrc->a[i].u3.pOn);
         }
@@ -159866,13 +162300,13 @@ static SQLITE_NOINLINE int exprMightBeIndexed2(
   int iCur;
   do{
     iCur = pFrom->a[j].iCursor;
-    for(pIdx=pFrom->a[j].pTab->pIndex; pIdx; pIdx=pIdx->pNext){
+    for(pIdx=pFrom->a[j].pSTab->pIndex; pIdx; pIdx=pIdx->pNext){
       if( pIdx->aColExpr==0 ) continue;
       for(i=0; i<pIdx->nKeyCol; i++){
         if( pIdx->aiColumn[i]!=XN_EXPR ) continue;
         assert( pIdx->bHasExpr );
         if( sqlite3ExprCompareSkip(pExpr,pIdx->aColExpr->a[i].pExpr,iCur)==0
-          && pExpr->op!=TK_STRING
+         && !sqlite3ExprIsConstant(0,pIdx->aColExpr->a[i].pExpr)
         ){
           aiCurCol[0] = iCur;
           aiCurCol[1] = XN_EXPR;
@@ -159910,7 +162344,7 @@ static int exprMightBeIndexed(
 
   for(i=0; i<pFrom->nSrc; i++){
     Index *pIdx;
-    for(pIdx=pFrom->a[i].pTab->pIndex; pIdx; pIdx=pIdx->pNext){
+    for(pIdx=pFrom->a[i].pSTab->pIndex; pIdx; pIdx=pIdx->pNext){
       if( pIdx->aColExpr ){
         return exprMightBeIndexed2(pFrom,aiCurCol,pExpr,i);
       }
@@ -160453,7 +162887,7 @@ static void whereAddLimitExpr(
   Expr *pNew;
   int iVal = 0;
 
-  if( sqlite3ExprIsInteger(pExpr, &iVal) && iVal>=0 ){
+  if( sqlite3ExprIsInteger(pExpr, &iVal, pParse) && iVal>=0 ){
     Expr *pVal = sqlite3Expr(db, TK_INTEGER, 0);
     if( pVal==0 ) return;
     ExprSetProperty(pVal, EP_IntValue);
@@ -160498,7 +162932,7 @@ SQLITE_PRIVATE void SQLITE_NOINLINE sqlite3WhereAddLimit(WhereClause *pWC, Selec
   assert( p!=0 && p->pLimit!=0 );                 /* 1 -- checked by caller */
   if( p->pGroupBy==0
    && (p->selFlags & (SF_Distinct|SF_Aggregate))==0             /* 2 */
-   && (p->pSrc->nSrc==1 && IsVirtual(p->pSrc->a[0].pTab))       /* 3 */
+   && (p->pSrc->nSrc==1 && IsVirtual(p->pSrc->a[0].pSTab))      /* 3 */
   ){
     ExprList *pOrderBy = p->pOrderBy;
     int iCsr = p->pSrc->a[0].iCursor;
@@ -160521,6 +162955,7 @@ SQLITE_PRIVATE void SQLITE_NOINLINE sqlite3WhereAddLimit(WhereClause *pWC, Selec
         continue;
       }
       if( pWC->a[ii].leftCursor!=iCsr ) return;
+      if( pWC->a[ii].prereqRight!=0 ) return;
     }
 
     /* Check condition (5). Return early if it is not met. */
@@ -160535,12 +162970,14 @@ SQLITE_PRIVATE void SQLITE_NOINLINE sqlite3WhereAddLimit(WhereClause *pWC, Selec
 
     /* All conditions are met. Add the terms to the where-clause object. */
     assert( p->pLimit->op==TK_LIMIT );
-    whereAddLimitExpr(pWC, p->iLimit, p->pLimit->pLeft,
-                      iCsr, SQLITE_INDEX_CONSTRAINT_LIMIT);
-    if( p->iOffset>0 ){
+    if( p->iOffset!=0 && (p->selFlags & SF_Compound)==0 ){
       whereAddLimitExpr(pWC, p->iOffset, p->pLimit->pRight,
                         iCsr, SQLITE_INDEX_CONSTRAINT_OFFSET);
     }
+    if( p->iOffset==0 || (p->selFlags & SF_Compound)==0 ){
+      whereAddLimitExpr(pWC, p->iLimit, p->pLimit->pLeft,
+                        iCsr, SQLITE_INDEX_CONSTRAINT_LIMIT);
+    }
   }
 }
 
@@ -160716,7 +163153,7 @@ SQLITE_PRIVATE void sqlite3WhereTabFuncArgs(
   Expr *pColRef;
   Expr *pTerm;
   if( pItem->fg.isTabFunc==0 ) return;
-  pTab = pItem->pTab;
+  pTab = pItem->pSTab;
   assert( pTab!=0 );
   pArgs = pItem->u1.pFuncArg;
   if( pArgs==0 ) return;
@@ -161058,6 +163495,42 @@ static Expr *whereRightSubexprIsColumn(Expr *p){
   return 0;
 }
 
+/*
+** Term pTerm is guaranteed to be a WO_IN term. It may be a component term
+** of a vector IN expression of the form "(x, y, ...) IN (SELECT ...)".
+** This function checks to see if the term is compatible with an index
+** column with affinity idxaff (one of the SQLITE_AFF_XYZ values). If so,
+** it returns a pointer to the name of the collation sequence (e.g. "BINARY"
+** or "NOCASE") used by the comparison in pTerm. If it is not compatible
+** with affinity idxaff, NULL is returned.
+*/
+static SQLITE_NOINLINE const char *indexInAffinityOk(
+  Parse *pParse,
+  WhereTerm *pTerm,
+  u8 idxaff
+){
+  Expr *pX = pTerm->pExpr;
+  Expr inexpr;
+
+  assert( pTerm->eOperator & WO_IN );
+
+  if( sqlite3ExprIsVector(pX->pLeft) ){
+    int iField = pTerm->u.x.iField - 1;
+    inexpr.flags = 0;
+    inexpr.op = TK_EQ;
+    inexpr.pLeft = pX->pLeft->x.pList->a[iField].pExpr;
+    assert( ExprUseXSelect(pX) );
+    inexpr.pRight = pX->x.pSelect->pEList->a[iField].pExpr;
+    pX = &inexpr;
+  }
+
+  if( sqlite3IndexAffinityOk(pX, idxaff) ){
+    CollSeq *pRet = sqlite3ExprCompareCollSeq(pParse, pX);
+    return pRet ? pRet->zName : sqlite3StrBINARY;
+  }
+  return 0;
+}
+
 /*
 ** Advance to the next WhereTerm that matches according to the criteria
 ** established when the pScan object was initialized by whereScanInit().
@@ -161108,16 +163581,24 @@ static WhereTerm *whereScanNext(WhereScan *pScan){
           if( (pTerm->eOperator & pScan->opMask)!=0 ){
             /* Verify the affinity and collating sequence match */
             if( pScan->zCollName && (pTerm->eOperator & WO_ISNULL)==0 ){
-              CollSeq *pColl;
+              const char *zCollName;
               Parse *pParse = pWC->pWInfo->pParse;
               pX = pTerm->pExpr;
-              if( !sqlite3IndexAffinityOk(pX, pScan->idxaff) ){
-                continue;
+
+              if( (pTerm->eOperator & WO_IN) ){
+                zCollName = indexInAffinityOk(pParse, pTerm, pScan->idxaff);
+                if( !zCollName ) continue;
+              }else{
+                CollSeq *pColl;
+                if( !sqlite3IndexAffinityOk(pX, pScan->idxaff) ){
+                  continue;
+                }
+                assert(pX->pLeft);
+                pColl = sqlite3ExprCompareCollSeq(pParse, pX);
+                zCollName = pColl ? pColl->zName : sqlite3StrBINARY;
               }
-              assert(pX->pLeft);
-              pColl = sqlite3ExprCompareCollSeq(pParse, pX);
-              if( pColl==0 ) pColl = pParse->db->pDfltColl;
-              if( sqlite3StrICmp(pColl->zName, pScan->zCollName) ){
+
+              if( sqlite3StrICmp(zCollName, pScan->zCollName) ){
                 continue;
               }
             }
@@ -161356,7 +163837,7 @@ static int isDistinctRedundant(
   ** clause is redundant. */
   if( pTabList->nSrc!=1 ) return 0;
   iBase = pTabList->a[0].iCursor;
-  pTab = pTabList->a[0].pTab;
+  pTab = pTabList->a[0].pSTab;
 
   /* If any of the expressions is an IPK column on table iBase, then return
   ** true. Note: The (p->iTable==iBase) part of this test may be false if the
@@ -161431,6 +163912,12 @@ static void translateColumnToCopy(
   VdbeOp *pOp = sqlite3VdbeGetOp(v, iStart);
   int iEnd = sqlite3VdbeCurrentAddr(v);
   if( pParse->db->mallocFailed ) return;
+#ifdef SQLITE_DEBUG
+  if( pParse->db->flags & SQLITE_VdbeAddopTrace ){
+    printf("CHECKING for column-to-copy on cursor %d for %d..%d\n",
+            iTabCur, iStart, iEnd);
+  }
+#endif
   for(; iStart<iEnd; iStart++, pOp++){
     if( pOp->p1!=iTabCur ) continue;
     if( pOp->opcode==OP_Column ){
@@ -161469,9 +163956,13 @@ static void translateColumnToCopy(
 ** are no-ops.
 */
 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(WHERETRACE_ENABLED)
-static void whereTraceIndexInfoInputs(sqlite3_index_info *p){
+static void whereTraceIndexInfoInputs(
+  sqlite3_index_info *p,   /* The IndexInfo object */
+  Table *pTab              /* The TABLE that is the virtual table */
+){
   int i;
   if( (sqlite3WhereTrace & 0x10)==0 ) return;
+  sqlite3DebugPrintf("sqlite3_index_info inputs for %s:\n", pTab->zName);
   for(i=0; i<p->nConstraint; i++){
     sqlite3DebugPrintf(
        "  constraint[%d]: col=%d termid=%d op=%d usabled=%d collseq=%s\n",
@@ -161489,9 +163980,13 @@ static void whereTraceIndexInfoInputs(sqlite3_index_info *p){
        p->aOrderBy[i].desc);
   }
 }
-static void whereTraceIndexInfoOutputs(sqlite3_index_info *p){
+static void whereTraceIndexInfoOutputs(
+  sqlite3_index_info *p,   /* The IndexInfo object */
+  Table *pTab              /* The TABLE that is the virtual table */
+){
   int i;
   if( (sqlite3WhereTrace & 0x10)==0 ) return;
+  sqlite3DebugPrintf("sqlite3_index_info outputs for %s:\n", pTab->zName);
   for(i=0; i<p->nConstraint; i++){
     sqlite3DebugPrintf("  usage[%d]: argvIdx=%d omit=%d\n",
        i,
@@ -161505,8 +164000,8 @@ static void whereTraceIndexInfoOutputs(sqlite3_index_info *p){
   sqlite3DebugPrintf("  estimatedRows=%lld\n", p->estimatedRows);
 }
 #else
-#define whereTraceIndexInfoInputs(A)
-#define whereTraceIndexInfoOutputs(A)
+#define whereTraceIndexInfoInputs(A,B)
+#define whereTraceIndexInfoOutputs(A,B)
 #endif
 
 /*
@@ -161544,6 +164039,40 @@ static int constraintCompatibleWithOuterJoin(
   return 1;
 }
 
+#ifndef SQLITE_OMIT_AUTOMATIC_INDEX
+/*
+** Return true if column iCol of table pTab seem like it might be a
+** good column to use as part of a query-time index.
+**
+** Current algorithm (subject to improvement!):
+**
+**   1.   If iCol is already the left-most column of some other index,
+**        then return false.
+**
+**   2.   If iCol is part of an existing index that has an aiRowLogEst of
+**        more than 20, then return false.
+**
+**   3.   If no disqualifying conditions above are found, return true.
+*/
+static SQLITE_NOINLINE int columnIsGoodIndexCandidate(
+  const Table *pTab,
+  int iCol
+){
+  const Index *pIdx;
+  for(pIdx = pTab->pIndex; pIdx!=0; pIdx=pIdx->pNext){
+    int j;
+    for(j=0; j<pIdx->nKeyCol; j++){
+       if( pIdx->aiColumn[j]==iCol ){
+         if( j==0 ) return 0;
+         if( pIdx->hasStat1 && pIdx->aiRowLogEst[j+1]>20 ) return 0;
+         break;
+       }
+    }
+  }
+  return 1;
+}
+#endif /* SQLITE_OMIT_AUTOMATIC_INDEX */
+
 
 
 #ifndef SQLITE_OMIT_AUTOMATIC_INDEX
@@ -161558,6 +164087,8 @@ static int termCanDriveIndex(
   const Bitmask notReady         /* Tables in outer loops of the join */
 ){
   char aff;
+  int leftCol;
+
   if( pTerm->leftCursor!=pSrc->iCursor ) return 0;
   if( (pTerm->eOperator & (WO_EQ|WO_IS))==0 ) return 0;
   assert( (pSrc->fg.jointype & JT_RIGHT)==0 );
@@ -161568,11 +164099,12 @@ static int termCanDriveIndex(
   }
   if( (pTerm->prereqRight & notReady)!=0 ) return 0;
   assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 );
-  if( pTerm->u.x.leftColumn<0 ) return 0;
-  aff = pSrc->pTab->aCol[pTerm->u.x.leftColumn].affinity;
+  leftCol = pTerm->u.x.leftColumn;
+  if( leftCol<0 ) return 0;
+  aff = pSrc->pSTab->aCol[leftCol].affinity;
   if( !sqlite3IndexAffinityOk(pTerm->pExpr, aff) ) return 0;
   testcase( pTerm->pExpr->op==TK_IS );
-  return 1;
+  return columnIsGoodIndexCandidate(pSrc->pSTab, leftCol);
 }
 #endif
 
@@ -161680,7 +164212,7 @@ static SQLITE_NOINLINE void constructAutomaticIndex(
   nKeyCol = 0;
   pTabList = pWC->pWInfo->pTabList;
   pSrc = &pTabList->a[pLevel->iFrom];
-  pTable = pSrc->pTab;
+  pTable = pSrc->pSTab;
   pWCEnd = &pWC->a[pWC->nTerm];
   pLoop = pLevel->pWLoop;
   idxCols = 0;
@@ -161690,7 +164222,7 @@ static SQLITE_NOINLINE void constructAutomaticIndex(
     ** WHERE clause (or the ON clause of a LEFT join) that constrain which
     ** rows of the target table (pSrc) that can be used. */
     if( (pTerm->wtFlags & TERM_VIRTUAL)==0
-     && sqlite3ExprIsSingleTableConstraint(pExpr, pTabList, pLevel->iFrom)
+     && sqlite3ExprIsSingleTableConstraint(pExpr, pTabList, pLevel->iFrom, 0)
     ){
       pPartial = sqlite3ExprAnd(pParse, pPartial,
                                 sqlite3ExprDup(pParse->db, pExpr, 0));
@@ -161732,7 +164264,7 @@ static SQLITE_NOINLINE void constructAutomaticIndex(
   ** if they go out of sync.
   */
   if( IsView(pTable) ){
-    extraCols = ALLBITS;
+    extraCols = ALLBITS & ~idxCols;
   }else{
     extraCols = pSrc->colUsed & (~idxCols | MASKBIT(BMS-1));
   }
@@ -161822,12 +164354,17 @@ static SQLITE_NOINLINE void constructAutomaticIndex(
   /* Fill the automatic index with content */
   assert( pSrc == &pWC->pWInfo->pTabList->a[pLevel->iFrom] );
   if( pSrc->fg.viaCoroutine ){
-    int regYield = pSrc->regReturn;
+    int regYield;
+    Subquery *pSubq;
+    assert( pSrc->fg.isSubquery );
+    pSubq = pSrc->u4.pSubq;
+    assert( pSubq!=0 );
+    regYield = pSubq->regReturn;
     addrCounter = sqlite3VdbeAddOp2(v, OP_Integer, 0, 0);
-    sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, pSrc->addrFillSub);
+    sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, pSubq->addrFillSub);
     addrTop =  sqlite3VdbeAddOp1(v, OP_Yield, regYield);
     VdbeCoverage(v);
-    VdbeComment((v, "next row of %s", pSrc->pTab->zName));
+    VdbeComment((v, "next row of %s", pSrc->pSTab->zName));
   }else{
     addrTop = sqlite3VdbeAddOp1(v, OP_Rewind, pLevel->iTabCur); VdbeCoverage(v);
   }
@@ -161849,11 +164386,12 @@ static SQLITE_NOINLINE void constructAutomaticIndex(
   sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
   if( pPartial ) sqlite3VdbeResolveLabel(v, iContinue);
   if( pSrc->fg.viaCoroutine ){
+    assert( pSrc->fg.isSubquery && pSrc->u4.pSubq!=0 );
     sqlite3VdbeChangeP2(v, addrCounter, regBase+n);
     testcase( pParse->db->mallocFailed );
     assert( pLevel->iIdxCur>0 );
     translateColumnToCopy(pParse, addrTop, pLevel->iTabCur,
-                          pSrc->regResult, pLevel->iIdxCur);
+                          pSrc->u4.pSubq->regResult, pLevel->iIdxCur);
     sqlite3VdbeGoto(v, addrTop);
     pSrc->fg.viaCoroutine = 0;
   }else{
@@ -161944,7 +164482,7 @@ static SQLITE_NOINLINE void sqlite3ConstructBloomFilter(
     iSrc = pLevel->iFrom;
     pItem = &pTabList->a[iSrc];
     assert( pItem!=0 );
-    pTab = pItem->pTab;
+    pTab = pItem->pSTab;
     assert( pTab!=0 );
     sz = sqlite3LogEstToInt(pTab->nRowLogEst);
     if( sz<10000 ){
@@ -161959,7 +164497,7 @@ static SQLITE_NOINLINE void sqlite3ConstructBloomFilter(
     for(pTerm=pWInfo->sWC.a; pTerm<pWCEnd; pTerm++){
       Expr *pExpr = pTerm->pExpr;
       if( (pTerm->wtFlags & TERM_VIRTUAL)==0
-       && sqlite3ExprIsSingleTableConstraint(pExpr, pTabList, iSrc)
+       && sqlite3ExprIsSingleTableConstraint(pExpr, pTabList, iSrc, 0)
       ){
         sqlite3ExprIfFalse(pParse, pTerm->pExpr, addrCont, SQLITE_JUMPIFNULL);
       }
@@ -161975,7 +164513,7 @@ static SQLITE_NOINLINE void sqlite3ConstructBloomFilter(
       int r1 = sqlite3GetTempRange(pParse, n);
       int jj;
       for(jj=0; jj<n; jj++){
-        assert( pIdx->pTable==pItem->pTab );
+        assert( pIdx->pTable==pItem->pSTab );
         sqlite3ExprCodeLoadIndexColumn(pParse, pIdx, iCur, jj, r1+jj);
       }
       sqlite3VdbeAddOp4Int(v, OP_FilterAdd, pLevel->regFilter, 0, r1, n);
@@ -162013,6 +164551,20 @@ static SQLITE_NOINLINE void sqlite3ConstructBloomFilter(
 
 
 #ifndef SQLITE_OMIT_VIRTUALTABLE
+/*
+** Return term iTerm of the WhereClause passed as the first argument. Terms
+** are numbered from 0 upwards, starting with the terms in pWC->a[], then
+** those in pWC->pOuter->a[] (if any), and so on.
+*/
+static WhereTerm *termFromWhereClause(WhereClause *pWC, int iTerm){
+  WhereClause *p;
+  for(p=pWC; p; p=p->pOuter){
+    if( iTerm<p->nTerm ) return &p->a[iTerm];
+    iTerm -= p->nTerm;
+  }
+  return 0;
+}
+
 /*
 ** Allocate and populate an sqlite3_index_info structure. It is the
 ** responsibility of the caller to eventually release the structure
@@ -162039,9 +164591,10 @@ static sqlite3_index_info *allocateIndexInfo(
   const Table *pTab;
   int eDistinct = 0;
   ExprList *pOrderBy = pWInfo->pOrderBy;
+  WhereClause *p;
 
   assert( pSrc!=0 );
-  pTab = pSrc->pTab;
+  pTab = pSrc->pSTab;
   assert( pTab!=0 );
   assert( IsVirtual(pTab) );
 
@@ -162049,28 +164602,30 @@ static sqlite3_index_info *allocateIndexInfo(
   ** Mark each term with the TERM_OK flag.  Set nTerm to the number of
   ** terms found.
   */
-  for(i=nTerm=0, pTerm=pWC->a; i<pWC->nTerm; i++, pTerm++){
-    pTerm->wtFlags &= ~TERM_OK;
-    if( pTerm->leftCursor != pSrc->iCursor ) continue;
-    if( pTerm->prereqRight & mUnusable ) continue;
-    assert( IsPowerOfTwo(pTerm->eOperator & ~WO_EQUIV) );
-    testcase( pTerm->eOperator & WO_IN );
-    testcase( pTerm->eOperator & WO_ISNULL );
-    testcase( pTerm->eOperator & WO_IS );
-    testcase( pTerm->eOperator & WO_ALL );
-    if( (pTerm->eOperator & ~(WO_EQUIV))==0 ) continue;
-    if( pTerm->wtFlags & TERM_VNULL ) continue;
+  for(p=pWC, nTerm=0; p; p=p->pOuter){
+    for(i=0, pTerm=p->a; i<p->nTerm; i++, pTerm++){
+      pTerm->wtFlags &= ~TERM_OK;
+      if( pTerm->leftCursor != pSrc->iCursor ) continue;
+      if( pTerm->prereqRight & mUnusable ) continue;
+      assert( IsPowerOfTwo(pTerm->eOperator & ~WO_EQUIV) );
+      testcase( pTerm->eOperator & WO_IN );
+      testcase( pTerm->eOperator & WO_ISNULL );
+      testcase( pTerm->eOperator & WO_IS );
+      testcase( pTerm->eOperator & WO_ALL );
+      if( (pTerm->eOperator & ~(WO_EQUIV))==0 ) continue;
+      if( pTerm->wtFlags & TERM_VNULL ) continue;
 
-    assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 );
-    assert( pTerm->u.x.leftColumn>=XN_ROWID );
-    assert( pTerm->u.x.leftColumn<pTab->nCol );
-    if( (pSrc->fg.jointype & (JT_LEFT|JT_LTORJ|JT_RIGHT))!=0
-     && !constraintCompatibleWithOuterJoin(pTerm,pSrc)
-    ){
-      continue;
+      assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 );
+      assert( pTerm->u.x.leftColumn>=XN_ROWID );
+      assert( pTerm->u.x.leftColumn<pTab->nCol );
+      if( (pSrc->fg.jointype & (JT_LEFT|JT_LTORJ|JT_RIGHT))!=0
+          && !constraintCompatibleWithOuterJoin(pTerm,pSrc)
+        ){
+        continue;
+      }
+      nTerm++;
+      pTerm->wtFlags |= TERM_OK;
     }
-    nTerm++;
-    pTerm->wtFlags |= TERM_OK;
   }
 
   /* If the ORDER BY clause contains only columns in the current
@@ -162085,7 +164640,7 @@ static sqlite3_index_info *allocateIndexInfo(
       Expr *pE2;
 
       /* Skip over constant terms in the ORDER BY clause */
-      if( sqlite3ExprIsConstant(pExpr) ){
+      if( sqlite3ExprIsConstant(0, pExpr) ){
         continue;
       }
 
@@ -162120,7 +164675,7 @@ static sqlite3_index_info *allocateIndexInfo(
     }
     if( i==n ){
       nOrderBy = n;
-      if( (pWInfo->wctrlFlags & WHERE_DISTINCTBY) ){
+      if( (pWInfo->wctrlFlags & WHERE_DISTINCTBY) && !pSrc->fg.rowidUsed ){
         eDistinct = 2 + ((pWInfo->wctrlFlags & WHERE_SORTBYGROUP)!=0);
       }else if( pWInfo->wctrlFlags & WHERE_GROUPBY ){
         eDistinct = 1;
@@ -162145,59 +164700,75 @@ static sqlite3_index_info *allocateIndexInfo(
   pIdxInfo->aConstraint = pIdxCons;
   pIdxInfo->aOrderBy = pIdxOrderBy;
   pIdxInfo->aConstraintUsage = pUsage;
+  pIdxInfo->colUsed = (sqlite3_int64)pSrc->colUsed;
+  if( HasRowid(pTab)==0 ){
+    /* Ensure that all bits associated with PK columns are set. This is to
+    ** ensure they are available for cases like RIGHT joins or OR loops. */
+    Index *pPk = sqlite3PrimaryKeyIndex((Table*)pTab);
+    assert( pPk!=0 );
+    for(i=0; i<pPk->nKeyCol; i++){
+      int iCol = pPk->aiColumn[i];
+      assert( iCol>=0 );
+      if( iCol>=BMS-1 ) iCol = BMS-1;
+      pIdxInfo->colUsed |= MASKBIT(iCol);
+    }
+  }
   pHidden->pWC = pWC;
   pHidden->pParse = pParse;
   pHidden->eDistinct = eDistinct;
   pHidden->mIn = 0;
-  for(i=j=0, pTerm=pWC->a; i<pWC->nTerm; i++, pTerm++){
-    u16 op;
-    if( (pTerm->wtFlags & TERM_OK)==0 ) continue;
-    pIdxCons[j].iColumn = pTerm->u.x.leftColumn;
-    pIdxCons[j].iTermOffset = i;
-    op = pTerm->eOperator & WO_ALL;
-    if( op==WO_IN ){
-      if( (pTerm->wtFlags & TERM_SLICE)==0 ){
-        pHidden->mIn |= SMASKBIT32(j);
+  for(p=pWC, i=j=0; p; p=p->pOuter){
+    int nLast = i+p->nTerm;;
+    for(pTerm=p->a; i<nLast; i++, pTerm++){
+      u16 op;
+      if( (pTerm->wtFlags & TERM_OK)==0 ) continue;
+      pIdxCons[j].iColumn = pTerm->u.x.leftColumn;
+      pIdxCons[j].iTermOffset = i;
+      op = pTerm->eOperator & WO_ALL;
+      if( op==WO_IN ){
+        if( (pTerm->wtFlags & TERM_SLICE)==0 ){
+          pHidden->mIn |= SMASKBIT32(j);
+        }
+        op = WO_EQ;
       }
-      op = WO_EQ;
-    }
-    if( op==WO_AUX ){
-      pIdxCons[j].op = pTerm->eMatchOp;
-    }else if( op & (WO_ISNULL|WO_IS) ){
-      if( op==WO_ISNULL ){
-        pIdxCons[j].op = SQLITE_INDEX_CONSTRAINT_ISNULL;
+      if( op==WO_AUX ){
+        pIdxCons[j].op = pTerm->eMatchOp;
+      }else if( op & (WO_ISNULL|WO_IS) ){
+        if( op==WO_ISNULL ){
+          pIdxCons[j].op = SQLITE_INDEX_CONSTRAINT_ISNULL;
+        }else{
+          pIdxCons[j].op = SQLITE_INDEX_CONSTRAINT_IS;
+        }
       }else{
-        pIdxCons[j].op = SQLITE_INDEX_CONSTRAINT_IS;
-      }
-    }else{
-      pIdxCons[j].op = (u8)op;
-      /* The direct assignment in the previous line is possible only because
-      ** the WO_ and SQLITE_INDEX_CONSTRAINT_ codes are identical.  The
-      ** following asserts verify this fact. */
-      assert( WO_EQ==SQLITE_INDEX_CONSTRAINT_EQ );
-      assert( WO_LT==SQLITE_INDEX_CONSTRAINT_LT );
-      assert( WO_LE==SQLITE_INDEX_CONSTRAINT_LE );
-      assert( WO_GT==SQLITE_INDEX_CONSTRAINT_GT );
-      assert( WO_GE==SQLITE_INDEX_CONSTRAINT_GE );
-      assert( pTerm->eOperator&(WO_IN|WO_EQ|WO_LT|WO_LE|WO_GT|WO_GE|WO_AUX) );
+        pIdxCons[j].op = (u8)op;
+        /* The direct assignment in the previous line is possible only because
+        ** the WO_ and SQLITE_INDEX_CONSTRAINT_ codes are identical.  The
+        ** following asserts verify this fact. */
+        assert( WO_EQ==SQLITE_INDEX_CONSTRAINT_EQ );
+        assert( WO_LT==SQLITE_INDEX_CONSTRAINT_LT );
+        assert( WO_LE==SQLITE_INDEX_CONSTRAINT_LE );
+        assert( WO_GT==SQLITE_INDEX_CONSTRAINT_GT );
+        assert( WO_GE==SQLITE_INDEX_CONSTRAINT_GE );
+        assert( pTerm->eOperator&(WO_IN|WO_EQ|WO_LT|WO_LE|WO_GT|WO_GE|WO_AUX) );
 
-      if( op & (WO_LT|WO_LE|WO_GT|WO_GE)
-       && sqlite3ExprIsVector(pTerm->pExpr->pRight)
-      ){
-        testcase( j!=i );
-        if( j<16 ) mNoOmit |= (1 << j);
-        if( op==WO_LT ) pIdxCons[j].op = WO_LE;
-        if( op==WO_GT ) pIdxCons[j].op = WO_GE;
+        if( op & (WO_LT|WO_LE|WO_GT|WO_GE)
+            && sqlite3ExprIsVector(pTerm->pExpr->pRight)
+          ){
+          testcase( j!=i );
+          if( j<16 ) mNoOmit |= (1 << j);
+          if( op==WO_LT ) pIdxCons[j].op = WO_LE;
+          if( op==WO_GT ) pIdxCons[j].op = WO_GE;
+        }
       }
+
+      j++;
     }
-
-    j++;
   }
   assert( j==nTerm );
   pIdxInfo->nConstraint = j;
   for(i=j=0; i<nOrderBy; i++){
     Expr *pExpr = pOrderBy->a[i].pExpr;
-    if( sqlite3ExprIsConstant(pExpr) ) continue;
+    if( sqlite3ExprIsConstant(0, pExpr) ) continue;
     assert( pExpr->op==TK_COLUMN
          || (pExpr->op==TK_COLLATE && pExpr->pLeft->op==TK_COLUMN
               && pExpr->iColumn==pExpr->pLeft->iColumn) );
@@ -162211,6 +164782,17 @@ static sqlite3_index_info *allocateIndexInfo(
   return pIdxInfo;
 }
 
+/*
+** Free and zero the sqlite3_index_info.idxStr value if needed.
+*/
+static void freeIdxStr(sqlite3_index_info *pIdxInfo){
+  if( pIdxInfo->needToFreeIdxStr ){
+    sqlite3_free(pIdxInfo->idxStr);
+    pIdxInfo->idxStr = 0;
+    pIdxInfo->needToFreeIdxStr = 0;
+  }
+}
+
 /*
 ** Free an sqlite3_index_info structure allocated by allocateIndexInfo()
 ** and possibly modified by xBestIndex methods.
@@ -162226,6 +164808,7 @@ static void freeIndexInfo(sqlite3 *db, sqlite3_index_info *pIdxInfo){
     sqlite3ValueFree(pHidden->aRhs[i]); /* IMP: R-14553-25174 */
     pHidden->aRhs[i] = 0;
   }
+  freeIdxStr(pIdxInfo);
   sqlite3DbFree(db, pIdxInfo);
 }
 
@@ -162246,14 +164829,16 @@ static void freeIndexInfo(sqlite3 *db, sqlite3_index_info *pIdxInfo){
 ** that this is required.
 */
 static int vtabBestIndex(Parse *pParse, Table *pTab, sqlite3_index_info *p){
-  sqlite3_vtab *pVtab = sqlite3GetVTable(pParse->db, pTab)->pVtab;
   int rc;
+  sqlite3_vtab *pVtab;
 
-  whereTraceIndexInfoInputs(p);
+  assert( IsVirtual(pTab) );
+  pVtab = sqlite3GetVTable(pParse->db, pTab)->pVtab;
+  whereTraceIndexInfoInputs(p, pTab);
   pParse->db->nSchemaLock++;
   rc = pVtab->pModule->xBestIndex(pVtab, p);
   pParse->db->nSchemaLock--;
-  whereTraceIndexInfoOutputs(p);
+  whereTraceIndexInfoOutputs(p, pTab);
 
   if( rc!=SQLITE_OK && rc!=SQLITE_CONSTRAINT ){
     if( rc==SQLITE_NOMEM ){
@@ -163019,7 +165604,7 @@ SQLITE_PRIVATE void sqlite3WhereLoopPrint(const WhereLoop *p, const WhereClause
     WhereInfo *pWInfo = pWC->pWInfo;
     int nb = 1+(pWInfo->pTabList->nSrc+3)/4;
     SrcItem *pItem = pWInfo->pTabList->a + p->iTab;
-    Table *pTab = pItem->pTab;
+    Table *pTab = pItem->pSTab;
     Bitmask mAll = (((Bitmask)1)<<(nb*4)) - 1;
     sqlite3DebugPrintf("%c%2d.%0*llx.%0*llx", p->cId,
                        p->iTab, nb, p->maskSelf, nb, p->prereq & mAll);
@@ -163191,7 +165776,7 @@ static void whereInfoFree(sqlite3 *db, WhereInfo *pWInfo){
 ** and Y has additional constraints that might speed the search that X lacks
 ** but the cost of running X is not more than the cost of running Y.
 **
-** In other words, return true if the cost relationwship between X and Y
+** In other words, return true if the cost relationship between X and Y
 ** is inverted and needs to be adjusted.
 **
 ** Case 1:
@@ -163577,7 +166162,7 @@ static void whereLoopOutputAdjust(
           Expr *pRight = pTerm->pExpr->pRight;
           int k = 0;
           testcase( pTerm->pExpr->op==TK_IS );
-          if( sqlite3ExprIsInteger(pRight, &k) && k>=(-1) && k<=1 ){
+          if( sqlite3ExprIsInteger(pRight, &k, 0) && k>=(-1) && k<=1 ){
             k = 10;
           }else{
             k = 20;
@@ -163731,7 +166316,9 @@ static int whereLoopAddBtreeIndex(
   }
   if( pProbe->bUnordered || pProbe->bLowQual ){
     if( pProbe->bUnordered ) opMask &= ~(WO_GT|WO_GE|WO_LT|WO_LE);
-    if( pProbe->bLowQual )   opMask &= ~(WO_EQ|WO_IN|WO_IS);
+    if( pProbe->bLowQual && pSrc->fg.isIndexedBy==0 ){
+      opMask &= ~(WO_EQ|WO_IN|WO_IS);
+    }
   }
 
   assert( pNew->u.btree.nEq<pProbe->nColumn );
@@ -163872,7 +166459,7 @@ static int whereLoopAddBtreeIndex(
        || (iCol>=0 && nInMul==0 && saved_nEq==pProbe->nKeyCol-1)
       ){
         if( iCol==XN_ROWID || pProbe->uniqNotNull
-         || (pProbe->nKeyCol==1 && pProbe->onError && eOp==WO_EQ)
+         || (pProbe->nKeyCol==1 && pProbe->onError && (eOp & WO_EQ))
         ){
           pNew->wsFlags |= WHERE_ONEROW;
         }else{
@@ -163998,11 +166585,14 @@ static int whereLoopAddBtreeIndex(
       }
     }
 
-    /* Set rCostIdx to the cost of visiting selected rows in index. Add
-    ** it to pNew->rRun, which is currently set to the cost of the index
-    ** seek only. Then, if this is a non-covering index, add the cost of
-    ** visiting the rows in the main table.  */
-    assert( pSrc->pTab->szTabRow>0 );
+    /* Set rCostIdx to the estimated cost of visiting selected rows in the
+    ** index.  The estimate is the sum of two values:
+    **   1.  The cost of doing one search-by-key to find the first matching
+    **       entry
+    **   2.  Stepping forward in the index pNew->nOut times to find all
+    **       additional matching entries.
+    */
+    assert( pSrc->pSTab->szTabRow>0 );
     if( pProbe->idxType==SQLITE_IDXTYPE_IPK ){
       /* The pProbe->szIdxRow is low for an IPK table since the interior
       ** pages are small.  Thus szIdxRow gives a good estimate of seek cost.
@@ -164010,9 +166600,17 @@ static int whereLoopAddBtreeIndex(
       ** under-estimate the scanning cost. */
       rCostIdx = pNew->nOut + 16;
     }else{
-      rCostIdx = pNew->nOut + 1 + (15*pProbe->szIdxRow)/pSrc->pTab->szTabRow;
+      rCostIdx = pNew->nOut + 1 + (15*pProbe->szIdxRow)/pSrc->pSTab->szTabRow;
     }
-    pNew->rRun = sqlite3LogEstAdd(rLogSize, rCostIdx);
+    rCostIdx = sqlite3LogEstAdd(rLogSize, rCostIdx);
+
+    /* Estimate the cost of running the loop.  If all data is coming
+    ** from the index, then this is just the cost of doing the index
+    ** lookup and scan.  But if some data is coming out of the main table,
+    ** we also have to add in the cost of doing pNew->nOut searches to
+    ** locate the row in the main table that corresponds to the index entry.
+    */
+    pNew->rRun = rCostIdx;
     if( (pNew->wsFlags & (WHERE_IDX_ONLY|WHERE_IPK|WHERE_EXPRIDX))==0 ){
       pNew->rRun = sqlite3LogEstAdd(pNew->rRun, pNew->nOut + 16);
     }
@@ -164118,7 +166716,9 @@ static int indexMightHelpWithOrderBy(
   for(ii=0; ii<pOB->nExpr; ii++){
     Expr *pExpr = sqlite3ExprSkipCollateAndLikely(pOB->a[ii].pExpr);
     if( NEVER(pExpr==0) ) continue;
-    if( pExpr->op==TK_COLUMN && pExpr->iTable==iCursor ){
+    if( (pExpr->op==TK_COLUMN || pExpr->op==TK_AGG_COLUMN)
+     && pExpr->iTable==iCursor
+    ){
       if( pExpr->iColumn<0 ) return 1;
       for(jj=0; jj<pIndex->nKeyCol; jj++){
         if( pExpr->iColumn==pIndex->aiColumn[jj] ) return 1;
@@ -164375,7 +166975,7 @@ static void wherePartIdxExpr(
     u8 aff;
 
     if( pLeft->op!=TK_COLUMN ) return;
-    if( !sqlite3ExprIsConstant(pRight) ) return;
+    if( !sqlite3ExprIsConstant(0, pRight) ) return;
     if( !sqlite3IsBinary(sqlite3ExprCompareCollSeq(pParse, pPart)) ) return;
     if( pLeft->iColumn<0 ) return;
     aff = pIdx->pTable->aCol[pLeft->iColumn].affinity;
@@ -164465,9 +167065,9 @@ static int whereLoopAddBtree(
   pWInfo = pBuilder->pWInfo;
   pTabList = pWInfo->pTabList;
   pSrc = pTabList->a + pNew->iTab;
-  pTab = pSrc->pTab;
+  pTab = pSrc->pSTab;
   pWC = pBuilder->pWC;
-  assert( !IsVirtual(pSrc->pTab) );
+  assert( !IsVirtual(pSrc->pSTab) );
 
   if( pSrc->fg.isIndexedBy ){
     assert( pSrc->fg.isCte==0 );
@@ -164492,7 +167092,7 @@ static int whereLoopAddBtree(
     sPk.idxType = SQLITE_IDXTYPE_IPK;
     aiRowEstPk[0] = pTab->nRowLogEst;
     aiRowEstPk[1] = 0;
-    pFirst = pSrc->pTab->pIndex;
+    pFirst = pSrc->pSTab->pIndex;
     if( pSrc->fg.notIndexed==0 ){
       /* The real indices of the table are only considered if the
       ** NOT INDEXED qualifier is omitted from the FROM clause */
@@ -164582,6 +167182,7 @@ static int whereLoopAddBtree(
     pNew->prereq = mPrereq;
     pNew->nOut = rSize;
     pNew->u.btree.pIndex = pProbe;
+    pNew->u.btree.pOrderBy = 0;
     b = indexMightHelpWithOrderBy(pBuilder, pProbe, pSrc->iCursor);
 
     /* The ONEPASS_DESIRED flags never occurs together with ORDER BY */
@@ -164611,6 +167212,10 @@ static int whereLoopAddBtree(
 #endif
       ApplyCostMultiplier(pNew->rRun, pTab->costMult);
       whereLoopOutputAdjust(pWC, pNew, rSize);
+      if( pSrc->fg.isSubquery ){
+        if( pSrc->fg.viaCoroutine ) pNew->wsFlags |= WHERE_COROUTINE;
+        pNew->u.btree.pOrderBy = pSrc->u4.pSubq->pSelect->pOrderBy;
+      }
       rc = whereLoopInsert(pBuilder, pNew);
       pNew->nOut = rSize;
       if( rc ) break;
@@ -164648,7 +167253,9 @@ static int whereLoopAddBtree(
                   " according to whereIsCoveringIndex()\n", pProbe->zName));
             }
           }
-        }else if( m==0 ){
+        }else if( m==0
+           && (HasRowid(pTab) || pWInfo->pSelect!=0 || sqlite3FaultSim(700))
+        ){
           WHERETRACE(0x200,
              ("-> %s a covering index according to bitmasks\n",
              pProbe->zName, m==0 ? "is" : "is not"));
@@ -164724,7 +167331,7 @@ static int whereLoopAddBtree(
       ** unique index is used (making the index functionally non-unique)
       ** then the sqlite_stat1 data becomes important for scoring the
       ** plan */
-      pTab->tabFlags |= TF_StatsUsed;
+      pTab->tabFlags |= TF_MaybeReanalyze;
     }
 #ifdef SQLITE_ENABLE_STAT4
     sqlite3Stat4ProbeFree(pBuilder->pRec);
@@ -164746,6 +167353,21 @@ static int isLimitTerm(WhereTerm *pTerm){
       && pTerm->eMatchOp<=SQLITE_INDEX_CONSTRAINT_OFFSET;
 }
 
+/*
+** Return true if the first nCons constraints in the pUsage array are
+** marked as in-use (have argvIndex>0). False otherwise.
+*/
+static int allConstraintsUsed(
+  struct sqlite3_index_constraint_usage *aUsage,
+  int nCons
+){
+  int ii;
+  for(ii=0; ii<nCons; ii++){
+    if( aUsage[ii].argvIndex<=0 ) return 0;
+  }
+  return 1;
+}
+
 /*
 ** Argument pIdxInfo is already populated with all constraints that may
 ** be used by the virtual table identified by pBuilder->pNew->iTab. This
@@ -164796,7 +167418,7 @@ static int whereLoopAddVirtualOne(
   ** arguments mUsable and mExclude. */
   pIdxCons = *(struct sqlite3_index_constraint**)&pIdxInfo->aConstraint;
   for(i=0; i<nConstraint; i++, pIdxCons++){
-    WhereTerm *pTerm = &pWC->a[pIdxCons->iTermOffset];
+    WhereTerm *pTerm = termFromWhereClause(pWC, pIdxCons->iTermOffset);
     pIdxCons->usable = 0;
     if( (pTerm->prereqRight & mUsable)==pTerm->prereqRight
      && (pTerm->eOperator & mExclude)==0
@@ -164815,11 +167437,10 @@ static int whereLoopAddVirtualOne(
   pIdxInfo->estimatedCost = SQLITE_BIG_DBL / (double)2;
   pIdxInfo->estimatedRows = 25;
   pIdxInfo->idxFlags = 0;
-  pIdxInfo->colUsed = (sqlite3_int64)pSrc->colUsed;
   pHidden->mHandleIn = 0;
 
   /* Invoke the virtual table xBestIndex() method */
-  rc = vtabBestIndex(pParse, pSrc->pTab, pIdxInfo);
+  rc = vtabBestIndex(pParse, pSrc->pSTab, pIdxInfo);
   if( rc ){
     if( rc==SQLITE_CONSTRAINT ){
       /* If the xBestIndex method returns SQLITE_CONSTRAINT, that means
@@ -164827,6 +167448,7 @@ static int whereLoopAddVirtualOne(
       ** Make no entries in the loop table.
       */
       WHERETRACE(0xffffffff, ("  ^^^^--- non-viable plan rejected!\n"));
+      freeIdxStr(pIdxInfo);
       return SQLITE_OK;
     }
     return rc;
@@ -164844,18 +167466,17 @@ static int whereLoopAddVirtualOne(
       int j = pIdxCons->iTermOffset;
       if( iTerm>=nConstraint
        || j<0
-       || j>=pWC->nTerm
+       || (pTerm = termFromWhereClause(pWC, j))==0
        || pNew->aLTerm[iTerm]!=0
        || pIdxCons->usable==0
       ){
-        sqlite3ErrorMsg(pParse,"%s.xBestIndex malfunction",pSrc->pTab->zName);
-        testcase( pIdxInfo->needToFreeIdxStr );
+        sqlite3ErrorMsg(pParse,"%s.xBestIndex malfunction",pSrc->pSTab->zName);
+        freeIdxStr(pIdxInfo);
         return SQLITE_ERROR;
       }
       testcase( iTerm==nConstraint-1 );
       testcase( j==0 );
       testcase( j==pWC->nTerm-1 );
-      pTerm = &pWC->a[j];
       pNew->prereq |= pTerm->prereqRight;
       assert( iTerm<pNew->nLSlot );
       pNew->aLTerm[iTerm] = pTerm;
@@ -164886,18 +167507,21 @@ static int whereLoopAddVirtualOne(
         *pbIn = 1; assert( (mExclude & WO_IN)==0 );
       }
 
+      /* Unless pbRetryLimit is non-NULL, there should be no LIMIT/OFFSET
+      ** terms. And if there are any, they should follow all other terms. */
       assert( pbRetryLimit || !isLimitTerm(pTerm) );
-      if( isLimitTerm(pTerm) && *pbIn ){
+      assert( !isLimitTerm(pTerm) || i>=nConstraint-2 );
+      assert( !isLimitTerm(pTerm) || i==nConstraint-1 || isLimitTerm(pTerm+1) );
+
+      if( isLimitTerm(pTerm) && (*pbIn || !allConstraintsUsed(pUsage, i)) ){
         /* If there is an IN(...) term handled as an == (separate call to
         ** xFilter for each value on the RHS of the IN) and a LIMIT or
-        ** OFFSET term handled as well, the plan is unusable. Set output
-        ** variable *pbRetryLimit to true to tell the caller to retry with
-        ** LIMIT and OFFSET disabled. */
-        if( pIdxInfo->needToFreeIdxStr ){
-          sqlite3_free(pIdxInfo->idxStr);
-          pIdxInfo->idxStr = 0;
-          pIdxInfo->needToFreeIdxStr = 0;
-        }
+        ** OFFSET term handled as well, the plan is unusable. Similarly,
+        ** if there is a LIMIT/OFFSET and there are other unused terms,
+        ** the plan cannot be used. In these cases set variable *pbRetryLimit
+        ** to true to tell the caller to retry with LIMIT and OFFSET
+        ** disabled. */
+        freeIdxStr(pIdxInfo);
         *pbRetryLimit = 1;
         return SQLITE_OK;
       }
@@ -164909,8 +167533,8 @@ static int whereLoopAddVirtualOne(
     if( pNew->aLTerm[i]==0 ){
       /* The non-zero argvIdx values must be contiguous.  Raise an
       ** error if they are not */
-      sqlite3ErrorMsg(pParse,"%s.xBestIndex malfunction",pSrc->pTab->zName);
-      testcase( pIdxInfo->needToFreeIdxStr );
+      sqlite3ErrorMsg(pParse,"%s.xBestIndex malfunction",pSrc->pSTab->zName);
+      freeIdxStr(pIdxInfo);
       return SQLITE_ERROR;
     }
   }
@@ -164921,6 +167545,7 @@ static int whereLoopAddVirtualOne(
   pNew->u.vtab.idxStr = pIdxInfo->idxStr;
   pNew->u.vtab.isOrdered = (i8)(pIdxInfo->orderByConsumed ?
       pIdxInfo->nOrderBy : 0);
+  pNew->u.vtab.bIdxNumHex = (pIdxInfo->idxFlags&SQLITE_INDEX_SCAN_HEX)!=0;
   pNew->rSetup = 0;
   pNew->rRun = sqlite3LogEstFromDouble(pIdxInfo->estimatedCost);
   pNew->nOut = sqlite3LogEst(pIdxInfo->estimatedRows);
@@ -164965,7 +167590,7 @@ SQLITE_API const char *sqlite3_vtab_collation(sqlite3_index_info *pIdxInfo, int
   if( iCons>=0 && iCons<pIdxInfo->nConstraint ){
     CollSeq *pC = 0;
     int iTerm = pIdxInfo->aConstraint[iCons].iTermOffset;
-    Expr *pX = pHidden->pWC->a[iTerm].pExpr;
+    Expr *pX = termFromWhereClause(pHidden->pWC, iTerm)->pExpr;
     if( pX->pLeft ){
       pC = sqlite3ExprCompareCollSeq(pHidden->pParse, pX);
     }
@@ -165011,7 +167636,9 @@ SQLITE_API int sqlite3_vtab_rhs_value(
     rc = SQLITE_MISUSE_BKPT; /* EV: R-30545-25046 */
   }else{
     if( pH->aRhs[iCons]==0 ){
-      WhereTerm *pTerm = &pH->pWC->a[pIdxInfo->aConstraint[iCons].iTermOffset];
+      WhereTerm *pTerm = termFromWhereClause(
+          pH->pWC, pIdxInfo->aConstraint[iCons].iTermOffset
+      );
       rc = sqlite3ValueFromExpr(
           pH->pParse->db, pTerm->pExpr->pRight, ENC(pH->pParse->db),
           SQLITE_AFF_BLOB, &pH->aRhs[iCons]
@@ -165109,7 +167736,7 @@ static int whereLoopAddVirtual(
   pWC = pBuilder->pWC;
   pNew = pBuilder->pNew;
   pSrc = &pWInfo->pTabList->a[pNew->iTab];
-  assert( IsVirtual(pSrc->pTab) );
+  assert( IsVirtual(pSrc->pSTab) );
   p = allocateIndexInfo(pWInfo, pWC, mUnusable, pSrc, &mNoOmit);
   if( p==0 ) return SQLITE_NOMEM_BKPT;
   pNew->rSetup = 0;
@@ -165123,7 +167750,7 @@ static int whereLoopAddVirtual(
   }
 
   /* First call xBestIndex() with all constraints usable. */
-  WHERETRACE(0x800, ("BEGIN %s.addVirtual()\n", pSrc->pTab->zName));
+  WHERETRACE(0x800, ("BEGIN %s.addVirtual()\n", pSrc->pSTab->zName));
   WHERETRACE(0x800, ("  VirtualOne: all usable\n"));
   rc = whereLoopAddVirtualOne(
       pBuilder, mPrereq, ALLBITS, 0, p, mNoOmit, &bIn, &bRetry
@@ -165167,9 +167794,8 @@ static int whereLoopAddVirtual(
       Bitmask mNext = ALLBITS;
       assert( mNext>0 );
       for(i=0; i<nConstraint; i++){
-        Bitmask mThis = (
-            pWC->a[p->aConstraint[i].iTermOffset].prereqRight & ~mPrereq
-        );
+        int iTerm = p->aConstraint[i].iTermOffset;
+        Bitmask mThis = termFromWhereClause(pWC, iTerm)->prereqRight & ~mPrereq;
         if( mThis>mPrev && mThis<mNext ) mNext = mThis;
       }
       mPrev = mNext;
@@ -165205,9 +167831,8 @@ static int whereLoopAddVirtual(
     }
   }
 
-  if( p->needToFreeIdxStr ) sqlite3_free(p->idxStr);
   freeIndexInfo(pParse->db, p);
-  WHERETRACE(0x800, ("END %s.addVirtual(), rc=%d\n", pSrc->pTab->zName, rc));
+  WHERETRACE(0x800, ("END %s.addVirtual(), rc=%d\n", pSrc->pSTab->zName, rc));
   return rc;
 }
 #endif /* SQLITE_OMIT_VIRTUALTABLE */
@@ -165279,7 +167904,7 @@ static int whereLoopAddOr(
         }
 #endif
 #ifndef SQLITE_OMIT_VIRTUALTABLE
-        if( IsVirtual(pItem->pTab) ){
+        if( IsVirtual(pItem->pSTab) ){
           rc = whereLoopAddVirtual(&sSubBuild, mPrereq, mUnusable);
         }else
 #endif
@@ -165393,7 +168018,7 @@ static int whereLoopAddAll(WhereLoopBuilder *pBuilder){
       mPrereq = 0;
     }
 #ifndef SQLITE_OMIT_VIRTUALTABLE
-    if( IsVirtual(pItem->pTab) ){
+    if( IsVirtual(pItem->pSTab) ){
       SrcItem *p;
       for(p=&pItem[1]; p<pEnd; p++){
         if( mUnusable || (p->fg.jointype & (JT_OUTER|JT_CROSS)) ){
@@ -165425,6 +168050,97 @@ static int whereLoopAddAll(WhereLoopBuilder *pBuilder){
   return rc;
 }
 
+/* Implementation of the order-by-subquery optimization:
+**
+** WhereLoop pLoop, which the iLoop-th term of the nested loop, is really
+** a subquery or CTE that has an ORDER BY clause.  See if any of the terms
+** in the subquery ORDER BY clause will satisfy pOrderBy from the outer
+** query.  Mark off all satisfied terms (by setting bits in *pOBSat) and
+** return TRUE if they do.  If not, return false.
+**
+** Example:
+**
+**    CREATE TABLE t1(a,b,c, PRIMARY KEY(a,b));
+**    CREATE TABLE t2(x,y);
+**    WITH t3(p,q) AS MATERIALIZED (SELECT x+y, x-y FROM t2 ORDER BY x+y)
+**       SELECT * FROM t3 JOIN t1 ON a=q ORDER BY p, b;
+**
+** The CTE named "t3" comes out in the natural order of "p", so the first
+** first them of "ORDER BY p,b" is satisfied by a sequential scan of "t3"
+** and sorting only needs to occur on the second term "b".
+**
+** Limitations:
+**
+** (1)  The optimization is not applied if the outer ORDER BY contains
+**      a COLLATE clause.  The optimization might be applied if the
+**      outer ORDER BY uses NULLS FIRST, NULLS LAST, ASC, and/or DESC as
+**      long as the subquery ORDER BY does the same.  But if the
+**      outer ORDER BY uses COLLATE, even a redundant COLLATE, the
+**      optimization is bypassed.
+**
+** (2)  The subquery ORDER BY terms must exactly match subquery result
+**      columns, including any COLLATE annotations.  This routine relies
+**      on iOrderByCol to do matching between order by terms and result
+**      columns, and iOrderByCol will not be set if the result column
+**      and ORDER BY collations differ.
+**
+** (3)  The subquery and outer ORDER BY can be in opposite directions as
+**      long as  the subquery is materialized.  If the subquery is
+**      implemented as a co-routine, the sort orders must be in the same
+**      direction because there is no way to run a co-routine backwards.
+*/
+static SQLITE_NOINLINE int wherePathMatchSubqueryOB(
+  WhereInfo *pWInfo,      /* The WHERE clause */
+  WhereLoop *pLoop,       /* The nested loop term that is a subquery */
+  int iLoop,              /* Which level of the nested loop.  0==outermost */
+  int iCur,               /* Cursor used by the this loop */
+  ExprList *pOrderBy,     /* The ORDER BY clause on the whole query */
+  Bitmask *pRevMask,      /* When loops need to go in reverse order */
+  Bitmask *pOBSat         /* Which terms of pOrderBy are satisfied so far */
+){
+  int iOB;                /* Index into pOrderBy->a[] */
+  int jSub;               /* Index into pSubOB->a[] */
+  u8 rev = 0;             /* True if iOB and jSub sort in opposite directions */
+  u8 revIdx = 0;          /* Sort direction for jSub */
+  Expr *pOBExpr;          /* Current term of outer ORDER BY */
+  ExprList *pSubOB;       /* Complete ORDER BY on the subquery */
+
+  pSubOB = pLoop->u.btree.pOrderBy;
+  assert( pSubOB!=0 );
+  for(iOB=0; (MASKBIT(iOB) & *pOBSat)!=0; iOB++){}
+  for(jSub=0; jSub<pSubOB->nExpr && iOB<pOrderBy->nExpr; jSub++, iOB++){
+    if( pSubOB->a[jSub].u.x.iOrderByCol==0 ) break;
+    pOBExpr = pOrderBy->a[iOB].pExpr;
+    if( pOBExpr->op!=TK_COLUMN && pOBExpr->op!=TK_AGG_COLUMN ) break;
+    if( pOBExpr->iTable!=iCur ) break;
+    if( pOBExpr->iColumn!=pSubOB->a[jSub].u.x.iOrderByCol-1 ) break;
+    if( (pWInfo->wctrlFlags & WHERE_GROUPBY)==0 ){
+      u8 sfOB = pOrderBy->a[iOB].fg.sortFlags;   /* sortFlags for iOB */
+      u8 sfSub = pSubOB->a[jSub].fg.sortFlags;   /* sortFlags for jSub */
+      if( (sfSub & KEYINFO_ORDER_BIGNULL) != (sfOB & KEYINFO_ORDER_BIGNULL) ){
+        break;
+      }
+      revIdx = sfSub & KEYINFO_ORDER_DESC;
+      if( jSub>0 ){
+        if( (rev^revIdx)!=(sfOB & KEYINFO_ORDER_DESC) ){
+          break;
+        }
+      }else{
+        rev = revIdx ^ (sfOB & KEYINFO_ORDER_DESC);
+        if( rev ){
+          if( (pLoop->wsFlags & WHERE_COROUTINE)!=0 ){
+            /* Cannot run a co-routine in reverse order */
+            break;
+          }
+          *pRevMask |= MASKBIT(iLoop);
+        }
+      }
+    }
+    *pOBSat |= MASKBIT(iOB);
+  }
+  return jSub>0;
+}
+
 /*
 ** Examine a WherePath (with the addition of the extra WhereLoop of the 6th
 ** parameters) to see if it outputs rows in the requested ORDER BY
@@ -165570,9 +168286,18 @@ static i8 wherePathSatisfiesOrderBy(
 
     if( (pLoop->wsFlags & WHERE_ONEROW)==0 ){
       if( pLoop->wsFlags & WHERE_IPK ){
+        if( pLoop->u.btree.pOrderBy
+         && OptimizationEnabled(db, SQLITE_OrderBySubq)
+         &&  wherePathMatchSubqueryOB(pWInfo,pLoop,iLoop,iCur,
+                                     pOrderBy,pRevMask, &obSat)
+        ){
+          nColumn = 0;
+          isOrderDistinct = 0;
+        }else{
+          nColumn = 1;
+        }
         pIndex = 0;
         nKeyCol = 0;
-        nColumn = 1;
       }else if( (pIndex = pLoop->u.btree.pIndex)==0 || pIndex->bUnordered ){
         return 0;
       }else{
@@ -165582,7 +168307,7 @@ static i8 wherePathSatisfiesOrderBy(
         assert( pIndex->aiColumn[nColumn-1]==XN_ROWID
                           || !HasRowid(pIndex->pTable));
         /* All relevant terms of the index must also be non-NULL in order
-        ** for isOrderDistinct to be true.  So the isOrderDistint value
+        ** for isOrderDistinct to be true.  So the isOrderDistinct value
         ** computed here might be a false positive.  Corrections will be
         ** made at tag-20210426-1 below */
         isOrderDistinct = IsUniqueIndex(pIndex)
@@ -165667,7 +168392,7 @@ static i8 wherePathSatisfiesOrderBy(
         }
 
         /* Find the ORDER BY term that corresponds to the j-th column
-        ** of the index and mark that ORDER BY term off
+        ** of the index and mark that ORDER BY term having been satisfied.
         */
         isMatch = 0;
         for(i=0; bOnce && i<nOrderBy; i++){
@@ -165749,7 +168474,7 @@ static i8 wherePathSatisfiesOrderBy(
         if( MASKBIT(i) & obSat ) continue;
         p = pOrderBy->a[i].pExpr;
         mTerm = sqlite3WhereExprUsage(&pWInfo->sMaskSet,p);
-        if( mTerm==0 && !sqlite3ExprIsConstant(p) ) continue;
+        if( mTerm==0 && !sqlite3ExprIsConstant(0,p) ) continue;
         if( (mTerm&~orderDistinctMask)==0 ){
           obSat |= MASKBIT(i);
         }
@@ -165874,6 +168599,83 @@ static LogEst whereSortingCost(
   return rSortCost;
 }
 
+/*
+** Compute the maximum number of paths in the solver algorithm, for
+** queries that have three or more terms in the FROM clause.  Queries with
+** two or fewer FROM clause terms are handled by the caller.
+**
+** Query planning is NP-hard.  We must limit the number of paths at
+** each step of the solver search algorithm to avoid exponential behavior.
+**
+** The value returned is a tuning parameter.  Currently the value is:
+**
+**     18    for star queries
+**     12    otherwise
+**
+** For the purposes of SQLite, a star-query is defined as a query
+** with a large central table that is joined against four or more
+** smaller tables.  The central table is called the "fact" table.
+** The smaller tables that get joined are "dimension tables".
+**
+** SIDE EFFECT:  (and really the whole point of this subroutine)
+**
+** If pWInfo describes a star-query, then the cost on WhereLoops for the
+** fact table is reduced.  This heuristic helps keep fact tables in
+** outer loops.  Without this heuristic, paths with fact tables in outer
+** loops tend to get pruned by the mxChoice limit on the number of paths,
+** resulting in poor query plans.  The total amount of heuristic cost
+** adjustment is stored in pWInfo->nOutStarDelta and the cost adjustment
+** for each WhereLoop is stored in its rStarDelta field.
+*/
+static int computeMxChoice(WhereInfo *pWInfo, LogEst nRowEst){
+  int nLoop = pWInfo->nLevel;    /* Number of terms in the join */
+  if( nRowEst==0 && nLoop>=5 ){
+    /* Check to see if we are dealing with a star schema and if so, reduce
+    ** the cost of fact tables relative to dimension tables, as a heuristic
+    ** to help keep the fact tables in outer loops.
+    */
+    int iLoop;                /* Counter over join terms */
+    Bitmask m;                /* Bitmask for current loop */
+    assert( pWInfo->nOutStarDelta==0 );
+    for(iLoop=0, m=1; iLoop<nLoop; iLoop++, m<<=1){
+      WhereLoop *pWLoop;        /* For looping over WhereLoops */
+      int nDep = 0;             /* Number of dimension tables */
+      LogEst rDelta;            /* Heuristic cost adjustment */
+      Bitmask mSeen = 0;        /* Mask of dimension tables */
+      for(pWLoop=pWInfo->pLoops; pWLoop; pWLoop=pWLoop->pNextLoop){
+        if( (pWLoop->prereq & m)!=0 && (pWLoop->maskSelf & mSeen)==0 ){
+          nDep++;
+          mSeen |= pWLoop->maskSelf;
+        }
+      }
+      if( nDep<=3 ) continue;
+      rDelta = 15*(nDep-3);
+#ifdef WHERETRACE_ENABLED /* 0x4 */
+      if( sqlite3WhereTrace&0x4 ){
+         SrcItem *pItem = pWInfo->pTabList->a + iLoop;
+         sqlite3DebugPrintf("Fact-table %s: %d dimensions, cost reduced %d\n",
+             pItem->zAlias ? pItem->zAlias : pItem->pSTab->zName,
+             nDep, rDelta);
+      }
+#endif
+      if( pWInfo->nOutStarDelta==0 ){
+        for(pWLoop=pWInfo->pLoops; pWLoop; pWLoop=pWLoop->pNextLoop){
+          pWLoop->rStarDelta = 0;
+        }
+      }
+      pWInfo->nOutStarDelta += rDelta;
+      for(pWLoop=pWInfo->pLoops; pWLoop; pWLoop=pWLoop->pNextLoop){
+        if( pWLoop->maskSelf==m ){
+          pWLoop->rRun -= rDelta;
+          pWLoop->nOut -= rDelta;
+          pWLoop->rStarDelta = rDelta;
+        }
+      }
+    }
+  }
+  return pWInfo->nOutStarDelta>0 ? 18 : 12;
+}
+
 /*
 ** Given the list of WhereLoop objects at pWInfo->pLoops, this routine
 ** attempts to find the lowest cost path that visits each WhereLoop
@@ -165909,13 +168711,25 @@ static int wherePathSolver(WhereInfo *pWInfo, LogEst nRowEst){
 
   pParse = pWInfo->pParse;
   nLoop = pWInfo->nLevel;
-  /* TUNING: For simple queries, only the best path is tracked.
-  ** For 2-way joins, the 5 best paths are followed.
-  ** For joins of 3 or more tables, track the 10 best paths */
-  mxChoice = (nLoop<=1) ? 1 : (nLoop==2 ? 5 : 10);
-  assert( nLoop<=pWInfo->pTabList->nSrc );
   WHERETRACE(0x002, ("---- begin solver.  (nRowEst=%d, nQueryLoop=%d)\n",
                      nRowEst, pParse->nQueryLoop));
+  /* TUNING: mxChoice is the maximum number of possible paths to preserve
+  ** at each step.  Based on the number of loops in the FROM clause:
+  **
+  **     nLoop      mxChoice
+  **     -----      --------
+  **       1            1            // the most common case
+  **       2            5
+  **       3+        12 or 18        // see computeMxChoice()
+  */
+  if( nLoop<=1 ){
+    mxChoice = 1;
+  }else if( nLoop==2 ){
+    mxChoice = 5;
+  }else{
+    mxChoice = computeMxChoice(pWInfo, nRowEst);
+  }
+  assert( nLoop<=pWInfo->pTabList->nSrc );
 
   /* If nRowEst is zero and there is an ORDER BY clause, ignore it. In this
   ** case the purpose of this call is to estimate the number of rows returned
@@ -165998,7 +168812,10 @@ static int wherePathSolver(WhereInfo *pWInfo, LogEst nRowEst){
 
         /* At this point, pWLoop is a candidate to be the next loop.
         ** Compute its cost */
-        rUnsorted = sqlite3LogEstAdd(pWLoop->rSetup,pWLoop->rRun + pFrom->nRow);
+        rUnsorted = pWLoop->rRun + pFrom->nRow;
+        if( pWLoop->rSetup ){
+          rUnsorted = sqlite3LogEstAdd(pWLoop->rSetup, rUnsorted);
+        }
         rUnsorted = sqlite3LogEstAdd(rUnsorted, pFrom->rUnsorted);
         nOut = pFrom->nRow + pWLoop->nOut;
         maskNew = pFrom->maskLoop | pWLoop->maskSelf;
@@ -166043,6 +168860,7 @@ static int wherePathSolver(WhereInfo *pWInfo, LogEst nRowEst){
         ** to (pTo->isOrdered==(-1))==(isOrdered==(-1))" for the range
         ** of legal values for isOrdered, -1..64.
         */
+        testcase( nTo==0 );
         for(jj=0, pTo=aTo; jj<nTo; jj++, pTo++){
           if( pTo->maskLoop==maskNew
            && ((pTo->isOrdered^isOrdered)&0x80)==0
@@ -166159,16 +168977,28 @@ static int wherePathSolver(WhereInfo *pWInfo, LogEst nRowEst){
 
 #ifdef WHERETRACE_ENABLED  /* >=2 */
     if( sqlite3WhereTrace & 0x02 ){
+      LogEst rMin, rFloor = 0;
+      int nDone = 0;
       sqlite3DebugPrintf("---- after round %d ----\n", iLoop);
-      for(ii=0, pTo=aTo; ii<nTo; ii++, pTo++){
-        sqlite3DebugPrintf(" %s cost=%-3d nrow=%-3d order=%c",
-           wherePathName(pTo, iLoop+1, 0), pTo->rCost, pTo->nRow,
-           pTo->isOrdered>=0 ? (pTo->isOrdered+'0') : '?');
-        if( pTo->isOrdered>0 ){
-          sqlite3DebugPrintf(" rev=0x%llx\n", pTo->revLoop);
-        }else{
-          sqlite3DebugPrintf("\n");
+      while( nDone<nTo ){
+        rMin = 0x7fff;
+        for(ii=0, pTo=aTo; ii<nTo; ii++, pTo++){
+          if( pTo->rCost>rFloor && pTo->rCost<rMin ) rMin = pTo->rCost;
         }
+        for(ii=0, pTo=aTo; ii<nTo; ii++, pTo++){
+          if( pTo->rCost==rMin ){
+            sqlite3DebugPrintf(" %s cost=%-3d nrow=%-3d order=%c",
+               wherePathName(pTo, iLoop+1, 0), pTo->rCost, pTo->nRow,
+               pTo->isOrdered>=0 ? (pTo->isOrdered+'0') : '?');
+            if( pTo->isOrdered>0 ){
+              sqlite3DebugPrintf(" rev=0x%llx\n", pTo->revLoop);
+            }else{
+              sqlite3DebugPrintf("\n");
+            }
+            nDone++;
+          }
+        }
+        rFloor = rMin;
       }
     }
 #endif
@@ -166218,10 +169048,9 @@ static int wherePathSolver(WhereInfo *pWInfo, LogEst nRowEst){
       if( pFrom->isOrdered==pWInfo->pOrderBy->nExpr ){
         pWInfo->eDistinct = WHERE_DISTINCT_ORDERED;
       }
-      if( pWInfo->pSelect->pOrderBy
-       && pWInfo->nOBSat > pWInfo->pSelect->pOrderBy->nExpr ){
-        pWInfo->nOBSat = pWInfo->pSelect->pOrderBy->nExpr;
-      }
+      /* vvv--- See check-in [12ad822d9b827777] on 2023-03-16 ---vvv */
+      assert( pWInfo->pSelect->pOrderBy==0
+           || pWInfo->nOBSat <= pWInfo->pSelect->pOrderBy->nExpr );
     }else{
       pWInfo->revMask = pFrom->revLoop;
       if( pWInfo->nOBSat<=0 ){
@@ -166264,14 +169093,90 @@ static int wherePathSolver(WhereInfo *pWInfo, LogEst nRowEst){
     }
   }
 
-
-  pWInfo->nRowOut = pFrom->nRow;
+  pWInfo->nRowOut = pFrom->nRow + pWInfo->nOutStarDelta;
 
   /* Free temporary memory and return success */
   sqlite3StackFreeNN(pParse->db, pSpace);
   return SQLITE_OK;
 }
 
+/*
+** This routine implements a heuristic designed to improve query planning.
+** This routine is called in between the first and second call to
+** wherePathSolver().  Hence the name "Interstage" "Heuristic".
+**
+** The first call to wherePathSolver() (hereafter just "solver()") computes
+** the best path without regard to the order of the outputs.  The second call
+** to the solver() builds upon the first call to try to find an alternative
+** path that satisfies the ORDER BY clause.
+**
+** This routine looks at the results of the first solver() run, and for
+** every FROM clause term in the resulting query plan that uses an equality
+** constraint against an index, disable other WhereLoops for that same
+** FROM clause term that would try to do a full-table scan.  This prevents
+** an index search from being converted into a full-table scan in order to
+** satisfy an ORDER BY clause, since even though we might get slightly better
+** performance using the full-scan without sorting if the output size
+** estimates are very precise, we might also get severe performance
+** degradation using the full-scan if the output size estimate is too large.
+** It is better to err on the side of caution.
+**
+** Except, if the first solver() call generated a full-table scan in an outer
+** loop then stop this analysis at the first full-scan, since the second
+** solver() run might try to swap that full-scan for another in order to
+** get the output into the correct order.  In other words, we allow a
+** rewrite like this:
+**
+**     First Solver()                      Second Solver()
+**       |-- SCAN t1                         |-- SCAN t2
+**       |-- SEARCH t2                       `-- SEARCH t1
+**       `-- SORT USING B-TREE
+**
+** The purpose of this routine is to disallow rewrites such as:
+**
+**     First Solver()                      Second Solver()
+**       |-- SEARCH t1                       |-- SCAN t2     <--- bad!
+**       |-- SEARCH t2                       `-- SEARCH t1
+**       `-- SORT USING B-TREE
+**
+** See test cases in test/whereN.test for the real-world query that
+** originally provoked this heuristic.
+*/
+static SQLITE_NOINLINE void whereInterstageHeuristic(WhereInfo *pWInfo){
+  int i;
+#ifdef WHERETRACE_ENABLED
+  int once = 0;
+#endif
+  for(i=0; i<pWInfo->nLevel; i++){
+    WhereLoop *p = pWInfo->a[i].pWLoop;
+    if( p==0 ) break;
+    if( (p->wsFlags & WHERE_VIRTUALTABLE)!=0 ) continue;
+    if( (p->wsFlags & (WHERE_COLUMN_EQ|WHERE_COLUMN_NULL|WHERE_COLUMN_IN))!=0 ){
+      u8 iTab = p->iTab;
+      WhereLoop *pLoop;
+      for(pLoop=pWInfo->pLoops; pLoop; pLoop=pLoop->pNextLoop){
+        if( pLoop->iTab!=iTab ) continue;
+        if( (pLoop->wsFlags & (WHERE_CONSTRAINT|WHERE_AUTO_INDEX))!=0 ){
+          /* Auto-index and index-constrained loops allowed to remain */
+          continue;
+        }
+#ifdef WHERETRACE_ENABLED
+        if( sqlite3WhereTrace & 0x80 ){
+          if( once==0 ){
+            sqlite3DebugPrintf("Loops disabled by interstage heuristic:\n");
+            once = 1;
+          }
+          sqlite3WhereLoopPrint(pLoop, &pWInfo->sWC);
+        }
+#endif /* WHERETRACE_ENABLED */
+        pLoop->prereq = ALLBITS;  /* Prevent 2nd solver() from using this one */
+      }
+    }else{
+      break;
+    }
+  }
+}
+
 /*
 ** Most queries use only a single table (they are not joins) and have
 ** simple == constraints against indexed fields.  This routine attempts
@@ -166299,7 +169204,7 @@ static int whereShortCut(WhereLoopBuilder *pBuilder){
   if( pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE ) return 0;
   assert( pWInfo->pTabList->nSrc>=1 );
   pItem = pWInfo->pTabList->a;
-  pTab = pItem->pTab;
+  pTab = pItem->pSTab;
   if( IsVirtual(pTab) ) return 0;
   if( pItem->fg.isIndexedBy || pItem->fg.notIndexed ){
     testcase( pItem->fg.isIndexedBy );
@@ -166440,6 +169345,10 @@ static void showAllWhereLoops(WhereInfo *pWInfo, WhereClause *pWC){
 **      the right-most table of a subquery that was flattened into the
 **      main query and that subquery was the right-hand operand of an
 **      inner join that held an ON or USING clause.
+**   6) The ORDER BY clause has 63 or fewer terms
+**   7) The omit-noop-join optimization is enabled.
+**
+** Items (1), (6), and (7) are checked by the caller.
 **
 ** For example, given:
 **
@@ -166485,6 +169394,7 @@ static SQLITE_NOINLINE Bitmask whereOmitNoopJoin(
     WhereTerm *pTerm, *pEnd;
     SrcItem *pItem;
     WhereLoop *pLoop;
+    Bitmask m1;
     pLoop = pWInfo->a[i].pWLoop;
     pItem = &pWInfo->pTabList->a[pLoop->iTab];
     if( (pItem->fg.jointype & (JT_LEFT|JT_RIGHT))!=JT_LEFT ) continue;
@@ -166511,7 +169421,10 @@ static SQLITE_NOINLINE Bitmask whereOmitNoopJoin(
       }
     }
     if( pTerm<pEnd ) continue;
-    WHERETRACE(0xffffffff, ("-> drop loop %c not used\n", pLoop->cId));
+    WHERETRACE(0xffffffff,("-> omit unused FROM-clause term %c\n",pLoop->cId));
+    m1 = MASKBIT(i)-1;
+    testcase( ((pWInfo->revMask>>1) & ~m1)!=0 );
+    pWInfo->revMask = (m1 & pWInfo->revMask) | ((pWInfo->revMask>>1) & ~m1);
     notReady &= ~pLoop->maskSelf;
     for(pTerm=pWInfo->sWC.a; pTerm<pEnd; pTerm++){
       if( (pTerm->prereqAll & pLoop->maskSelf)!=0 ){
@@ -166558,9 +169471,9 @@ static SQLITE_NOINLINE void whereCheckIfBloomFilterIsUseful(
     WhereLoop *pLoop = pWInfo->a[i].pWLoop;
     const unsigned int reqFlags = (WHERE_SELFCULL|WHERE_COLUMN_EQ);
     SrcItem *pItem = &pWInfo->pTabList->a[pLoop->iTab];
-    Table *pTab = pItem->pTab;
+    Table *pTab = pItem->pSTab;
     if( (pTab->tabFlags & TF_HasStat1)==0 ) break;
-    pTab->tabFlags |= TF_StatsUsed;
+    pTab->tabFlags |= TF_MaybeReanalyze;
     if( i>=1
      && (pLoop->wsFlags & reqFlags)==reqFlags
      /* vvvvvv--- Always the case if WHERE_COLUMN_EQ is defined */
@@ -166578,6 +169491,7 @@ static SQLITE_NOINLINE void whereCheckIfBloomFilterIsUseful(
       }
     }
     nSearch += pLoop->nOut;
+    if( pWInfo->nOutStarDelta ) nSearch += pLoop->rStarDelta;
   }
 }
 
@@ -166606,34 +169520,14 @@ static SQLITE_NOINLINE void whereAddIndexedExpr(
   for(i=0; i<pIdx->nColumn; i++){
     Expr *pExpr;
     int j = pIdx->aiColumn[i];
-    int bMaybeNullRow;
     if( j==XN_EXPR ){
       pExpr = pIdx->aColExpr->a[i].pExpr;
-      testcase( pTabItem->fg.jointype & JT_LEFT );
-      testcase( pTabItem->fg.jointype & JT_RIGHT );
-      testcase( pTabItem->fg.jointype & JT_LTORJ );
-      bMaybeNullRow = (pTabItem->fg.jointype & (JT_LEFT|JT_LTORJ|JT_RIGHT))!=0;
     }else if( j>=0 && (pTab->aCol[j].colFlags & COLFLAG_VIRTUAL)!=0 ){
       pExpr = sqlite3ColumnExpr(pTab, &pTab->aCol[j]);
-      bMaybeNullRow = 0;
     }else{
       continue;
     }
-    if( sqlite3ExprIsConstant(pExpr) ) continue;
-    if( pExpr->op==TK_FUNCTION ){
-      /* Functions that might set a subtype should not be replaced by the
-      ** value taken from an expression index since the index omits the
-      ** subtype.  https://sqlite.org/forum/forumpost/68d284c86b082c3e */
-      int n;
-      FuncDef *pDef;
-      sqlite3 *db = pParse->db;
-      assert( ExprUseXList(pExpr) );
-      n = pExpr->x.pList ? pExpr->x.pList->nExpr : 0;
-      pDef = sqlite3FindFunction(db, pExpr->u.zToken, n, ENC(db), 0);
-      if( pDef==0 || (pDef->funcFlags & SQLITE_RESULT_SUBTYPE)!=0 ){
-        continue;
-      }
-    }
+    if( sqlite3ExprIsConstant(0,pExpr) ) continue;
     p = sqlite3DbMallocRaw(pParse->db,  sizeof(IndexedExpr));
     if( p==0 ) break;
     p->pIENext = pParse->pIdxEpr;
@@ -166647,7 +169541,7 @@ static SQLITE_NOINLINE void whereAddIndexedExpr(
     p->iDataCur = pTabItem->iCursor;
     p->iIdxCur = iIdxCur;
     p->iIdxCol = i;
-    p->bMaybeNullRow = bMaybeNullRow;
+    p->bMaybeNullRow = (pTabItem->fg.jointype & (JT_LEFT|JT_LTORJ|JT_RIGHT))!=0;
     if( sqlite3IndexAffinityStr(pParse->db, pIdx) ){
       p->aff = pIdx->zColAff[i];
     }
@@ -166676,8 +169570,8 @@ static SQLITE_NOINLINE void whereReverseScanOrder(WhereInfo *pWInfo){
     SrcItem *pItem = &pWInfo->pTabList->a[ii];
     if( !pItem->fg.isCte
      || pItem->u2.pCteUse->eM10d!=M10d_Yes
-     || NEVER(pItem->pSelect==0)
-     || pItem->pSelect->pOrderBy==0
+     || NEVER(pItem->fg.isSubquery==0)
+     || pItem->u4.pSubq->pSelect->pOrderBy==0
     ){
       pWInfo->revMask |= MASKBIT(ii);
     }
@@ -166812,7 +169706,11 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(
 
   /* An ORDER/GROUP BY clause of more than 63 terms cannot be optimized */
   testcase( pOrderBy && pOrderBy->nExpr==BMS-1 );
-  if( pOrderBy && pOrderBy->nExpr>=BMS ) pOrderBy = 0;
+  if( pOrderBy && pOrderBy->nExpr>=BMS ){
+    pOrderBy = 0;
+    wctrlFlags &= ~WHERE_WANT_DISTINCT;
+    wctrlFlags |= WHERE_KEEP_ALL_JOINS; /* Disable omit-noop-join opt */
+  }
 
   /* The number of tables in the FROM clause is limited by the number of
   ** bits in a Bitmask
@@ -166894,7 +169792,11 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(
     ){
       pWInfo->eDistinct = WHERE_DISTINCT_UNIQUE;
     }
-    ExplainQueryPlan((pParse, 0, "SCAN CONSTANT ROW"));
+    if( ALWAYS(pWInfo->pSelect)
+     && (pWInfo->pSelect->selFlags & SF_MultiValue)==0
+    ){
+      ExplainQueryPlan((pParse, 0, "SCAN CONSTANT ROW"));
+    }
   }else{
     /* Assign a bit from the bitmask to every term in the FROM clause.
     **
@@ -167047,7 +169949,8 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(
     wherePathSolver(pWInfo, 0);
     if( db->mallocFailed ) goto whereBeginError;
     if( pWInfo->pOrderBy ){
-       wherePathSolver(pWInfo, pWInfo->nRowOut+1);
+       whereInterstageHeuristic(pWInfo);
+       wherePathSolver(pWInfo, pWInfo->nRowOut<0 ? 1 : pWInfo->nRowOut+1);
        if( db->mallocFailed ) goto whereBeginError;
     }
 
@@ -167107,10 +170010,10 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(
   ** in-line sqlite3WhereCodeOneLoopStart() for performance reasons.
   */
   notReady = ~(Bitmask)0;
-  if( pWInfo->nLevel>=2
-   && pResultSet!=0                         /* these two combine to guarantee */
-   && 0==(wctrlFlags & WHERE_AGG_DISTINCT)  /* condition (1) above */
-   && OptimizationEnabled(db, SQLITE_OmitNoopJoin)
+  if( pWInfo->nLevel>=2       /* Must be a join, or this opt8n is pointless */
+   && pResultSet!=0           /* Condition (1) */
+   && 0==(wctrlFlags & (WHERE_AGG_DISTINCT|WHERE_KEEP_ALL_JOINS)) /* (1),(6) */
+   && OptimizationEnabled(db, SQLITE_OmitNoopJoin)                /* (7) */
   ){
     notReady = whereOmitNoopJoin(pWInfo, notReady);
     nTabList = pWInfo->nLevel;
@@ -167158,15 +170061,15 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(
   if( (wctrlFlags & WHERE_ONEPASS_DESIRED)!=0 ){
     int wsFlags = pWInfo->a[0].pWLoop->wsFlags;
     int bOnerow = (wsFlags & WHERE_ONEROW)!=0;
-    assert( !(wsFlags & WHERE_VIRTUALTABLE) || IsVirtual(pTabList->a[0].pTab) );
+    assert( !(wsFlags&WHERE_VIRTUALTABLE) || IsVirtual(pTabList->a[0].pSTab) );
     if( bOnerow || (
         0!=(wctrlFlags & WHERE_ONEPASS_MULTIROW)
-     && !IsVirtual(pTabList->a[0].pTab)
+     && !IsVirtual(pTabList->a[0].pSTab)
      && (0==(wsFlags & WHERE_MULTI_OR) || (wctrlFlags & WHERE_DUPLICATES_OK))
      && OptimizationEnabled(db, SQLITE_OnePass)
     )){
       pWInfo->eOnePass = bOnerow ? ONEPASS_SINGLE : ONEPASS_MULTI;
-      if( HasRowid(pTabList->a[0].pTab) && (wsFlags & WHERE_IDX_ONLY) ){
+      if( HasRowid(pTabList->a[0].pSTab) && (wsFlags & WHERE_IDX_ONLY) ){
         if( wctrlFlags & WHERE_ONEPASS_MULTIROW ){
           bFordelete = OPFLAG_FORDELETE;
         }
@@ -167184,7 +170087,7 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(
     SrcItem *pTabItem;
 
     pTabItem = &pTabList->a[pLevel->iFrom];
-    pTab = pTabItem->pTab;
+    pTab = pTabItem->pSTab;
     iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
     pLoop = pLevel->pWLoop;
     if( (pTab->tabFlags & TF_Ephemeral)!=0 || IsView(pTab) ){
@@ -167255,7 +170158,7 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(
         iIndexCur = pLevel->iTabCur;
         op = 0;
       }else if( pWInfo->eOnePass!=ONEPASS_OFF ){
-        Index *pJ = pTabItem->pTab->pIndex;
+        Index *pJ = pTabItem->pSTab->pIndex;
         iIndexCur = iAuxArg;
         assert( wctrlFlags & WHERE_ONEPASS_DESIRED );
         while( ALWAYS(pJ) && pJ!=pIx ){
@@ -167322,7 +170225,7 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(
       sqlite3VdbeAddOp2(v, OP_Blob, 65536, pRJ->regBloom);
       pRJ->regReturn = ++pParse->nMem;
       sqlite3VdbeAddOp2(v, OP_Null, 0, pRJ->regReturn);
-      assert( pTab==pTabItem->pTab );
+      assert( pTab==pTabItem->pSTab );
       if( HasRowid(pTab) ){
         KeyInfo *pInfo;
         sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pRJ->iMatch, 1);
@@ -167361,13 +170264,18 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(
     wsFlags = pLevel->pWLoop->wsFlags;
     pSrc = &pTabList->a[pLevel->iFrom];
     if( pSrc->fg.isMaterialized ){
-      if( pSrc->fg.isCorrelated ){
-        sqlite3VdbeAddOp2(v, OP_Gosub, pSrc->regReturn, pSrc->addrFillSub);
+      Subquery *pSubq;
+      int iOnce = 0;
+      assert( pSrc->fg.isSubquery );
+      pSubq = pSrc->u4.pSubq;
+      if( pSrc->fg.isCorrelated==0 ){
+        iOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
       }else{
-        int iOnce = sqlite3VdbeAddOp0(v, OP_Once);  VdbeCoverage(v);
-        sqlite3VdbeAddOp2(v, OP_Gosub, pSrc->regReturn, pSrc->addrFillSub);
-        sqlite3VdbeJumpHere(v, iOnce);
+        iOnce = 0;
       }
+      sqlite3VdbeAddOp2(v, OP_Gosub, pSubq->regReturn, pSubq->addrFillSub);
+      VdbeComment((v, "materialize %!S", pSrc));
+      if( iOnce )  sqlite3VdbeJumpHere(v, iOnce);
     }
     assert( pTabList == pWInfo->pTabList );
     if( (wsFlags & (WHERE_AUTO_INDEX|WHERE_BLOOMFILTER))!=0 ){
@@ -167430,26 +170338,6 @@ whereBeginError:
   }
 #endif
 
-#ifdef SQLITE_DEBUG
-/*
-** Return true if cursor iCur is opened by instruction k of the
-** bytecode.  Used inside of assert() only.
-*/
-static int cursorIsOpen(Vdbe *v, int iCur, int k){
-  while( k>=0 ){
-    VdbeOp *pOp = sqlite3VdbeGetOp(v,k--);
-    if( pOp->p1!=iCur ) continue;
-    if( pOp->opcode==OP_Close ) return 0;
-    if( pOp->opcode==OP_OpenRead ) return 1;
-    if( pOp->opcode==OP_OpenWrite ) return 1;
-    if( pOp->opcode==OP_OpenDup ) return 1;
-    if( pOp->opcode==OP_OpenAutoindex ) return 1;
-    if( pOp->opcode==OP_OpenEphemeral ) return 1;
-  }
-  return 0;
-}
-#endif /* SQLITE_DEBUG */
-
 /*
 ** Generate the end of the WHERE loop.  See comments on
 ** sqlite3WhereBegin() for additional information.
@@ -167596,7 +170484,16 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){
       addr = sqlite3VdbeAddOp1(v, OP_IfPos, pLevel->iLeftJoin); VdbeCoverage(v);
       assert( (ws & WHERE_IDX_ONLY)==0 || (ws & WHERE_INDEXED)!=0 );
       if( (ws & WHERE_IDX_ONLY)==0 ){
-        assert( pLevel->iTabCur==pTabList->a[pLevel->iFrom].iCursor );
+        SrcItem *pSrc = &pTabList->a[pLevel->iFrom];
+        assert( pLevel->iTabCur==pSrc->iCursor );
+        if( pSrc->fg.viaCoroutine ){
+          int m, n;
+          assert( pSrc->fg.isSubquery );
+          n = pSrc->u4.pSubq->regResult;
+          assert( pSrc->pSTab!=0 );
+          m = pSrc->pSTab->nCol;
+          sqlite3VdbeAddOp3(v, OP_Null, 0, n, n+m-1);
+        }
         sqlite3VdbeAddOp1(v, OP_NullRow, pLevel->iTabCur);
       }
       if( (ws & WHERE_INDEXED)
@@ -167618,7 +170515,7 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){
       sqlite3VdbeJumpHere(v, addr);
     }
     VdbeModuleComment((v, "End WHERE-loop%d: %s", i,
-                     pWInfo->pTabList->a[pLevel->iFrom].pTab->zName));
+                     pWInfo->pTabList->a[pLevel->iFrom].pSTab->zName));
   }
 
   assert( pWInfo->nLevel<=pTabList->nSrc );
@@ -167627,7 +170524,7 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){
     VdbeOp *pOp, *pLastOp;
     Index *pIdx = 0;
     SrcItem *pTabItem = &pTabList->a[pLevel->iFrom];
-    Table *pTab = pTabItem->pTab;
+    Table *pTab = pTabItem->pSTab;
     assert( pTab!=0 );
     pLoop = pLevel->pWLoop;
 
@@ -167646,8 +170543,10 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){
     */
     if( pTabItem->fg.viaCoroutine ){
       testcase( pParse->db->mallocFailed );
+      assert( pTabItem->fg.isSubquery );
+      assert( pTabItem->u4.pSubq->regResult>=0 );
       translateColumnToCopy(pParse, pLevel->addrBody, pLevel->iTabCur,
-                            pTabItem->regResult, 0);
+                            pTabItem->u4.pSubq->regResult, 0);
       continue;
     }
 
@@ -167740,16 +170639,10 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){
             ** reference.  Verify that this is harmless - that the
             ** table being referenced really is open.
             */
-#ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC
-            assert( (pLoop->wsFlags & WHERE_IDX_ONLY)==0
-                 || cursorIsOpen(v,pOp->p1,k)
-                 || pOp->opcode==OP_Offset
-            );
-#else
-            assert( (pLoop->wsFlags & WHERE_IDX_ONLY)==0
-                 || cursorIsOpen(v,pOp->p1,k)
-            );
-#endif
+            if( pLoop->wsFlags & WHERE_IDX_ONLY ){
+              sqlite3ErrorMsg(pParse, "internal query planner error");
+              pParse->rc = SQLITE_INTERNAL;
+            }
           }
         }else if( pOp->opcode==OP_Rowid ){
           pOp->p1 = pLevel->iIdxCur;
@@ -168695,7 +171588,7 @@ static ExprList *exprListAppendList(
         int iDummy;
         Expr *pSub;
         pSub = sqlite3ExprSkipCollateAndLikely(pDup);
-        if( sqlite3ExprIsInteger(pSub, &iDummy) ){
+        if( sqlite3ExprIsInteger(pSub, &iDummy, 0) ){
           pSub->op = TK_NULL;
           pSub->flags &= ~(EP_IntValue|EP_IsTrue|EP_IsFalse);
           pSub->u.zToken = 0;
@@ -168863,9 +171756,10 @@ SQLITE_PRIVATE int sqlite3WindowRewrite(Parse *pParse, Select *p){
     assert( pSub!=0 || p->pSrc==0 ); /* Due to db->mallocFailed test inside
                                      ** of sqlite3DbMallocRawNN() called from
                                      ** sqlite3SrcListAppend() */
-    if( p->pSrc ){
+    if( p->pSrc==0 ){
+      sqlite3SelectDelete(db, pSub);
+    }else if( sqlite3SrcItemAttachSubquery(pParse, &p->pSrc->a[0], pSub, 0) ){
       Table *pTab2;
-      p->pSrc->a[0].pSelect = pSub;
       p->pSrc->a[0].fg.isCorrelated = 1;
       sqlite3SrcListAssignCursors(pParse, p->pSrc);
       pSub->selFlags |= SF_Expanded|SF_OrderByReqd;
@@ -168879,7 +171773,7 @@ SQLITE_PRIVATE int sqlite3WindowRewrite(Parse *pParse, Select *p){
       }else{
         memcpy(pTab, pTab2, sizeof(Table));
         pTab->tabFlags |= TF_Ephemeral;
-        p->pSrc->a[0].pTab = pTab;
+        p->pSrc->a[0].pSTab = pTab;
         pTab = pTab2;
         memset(&w, 0, sizeof(w));
         w.xExprCallback = sqlite3WindowExtraAggFuncDepth;
@@ -168887,8 +171781,6 @@ SQLITE_PRIVATE int sqlite3WindowRewrite(Parse *pParse, Select *p){
         w.xSelectCallback2 = sqlite3WalkerDepthDecrease;
         sqlite3WalkSelect(&w, pSub);
       }
-    }else{
-      sqlite3SelectDelete(db, pSub);
     }
     if( db->mallocFailed ) rc = SQLITE_NOMEM;
 
@@ -168950,7 +171842,7 @@ SQLITE_PRIVATE void sqlite3WindowListDelete(sqlite3 *db, Window *p){
 ** variable values in the expression tree.
 */
 static Expr *sqlite3WindowOffsetExpr(Parse *pParse, Expr *pExpr){
-  if( 0==sqlite3ExprIsConstant(pExpr) ){
+  if( 0==sqlite3ExprIsConstant(0,pExpr) ){
     if( IN_RENAME_OBJECT ) sqlite3RenameExprUnmap(pParse, pExpr);
     sqlite3ExprDelete(pParse->db, pExpr);
     pExpr = sqlite3ExprAlloc(pParse->db, TK_NULL, 0, 0);
@@ -169175,10 +172067,15 @@ SQLITE_PRIVATE int sqlite3WindowCompare(
 ** and initialize registers and cursors used by sqlite3WindowCodeStep().
 */
 SQLITE_PRIVATE void sqlite3WindowCodeInit(Parse *pParse, Select *pSelect){
-  int nEphExpr = pSelect->pSrc->a[0].pSelect->pEList->nExpr;
-  Window *pMWin = pSelect->pWin;
   Window *pWin;
-  Vdbe *v = sqlite3GetVdbe(pParse);
+  int nEphExpr;
+  Window *pMWin;
+  Vdbe *v;
+
+  assert( pSelect->pSrc->a[0].fg.isSubquery );
+  nEphExpr = pSelect->pSrc->a[0].u4.pSubq->pSelect->pEList->nExpr;
+  pMWin = pSelect->pWin;
+  v = sqlite3GetVdbe(pParse);
 
   sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pMWin->iEphCsr, nEphExpr);
   sqlite3VdbeAddOp2(v, OP_OpenDup, pMWin->iEphCsr+1, pMWin->iEphCsr);
@@ -170575,7 +173472,7 @@ SQLITE_PRIVATE void sqlite3WindowCodeStep(
   Vdbe *v = sqlite3GetVdbe(pParse);
   int csrWrite;                   /* Cursor used to write to eph. table */
   int csrInput = p->pSrc->a[0].iCursor;     /* Cursor of sub-select */
-  int nInput = p->pSrc->a[0].pTab->nCol;    /* Number of cols returned by sub */
+  int nInput = p->pSrc->a[0].pSTab->nCol;   /* Number of cols returned by sub */
   int iInput;                               /* To iterate through sub cols */
   int addrNe;                     /* Address of OP_Ne */
   int addrGosubFlush = 0;         /* Address of OP_Gosub to flush: */
@@ -171020,9 +173917,9 @@ static void updateDeleteLimitError(
           break;
         }
       }
-      if( (p->selFlags & SF_MultiValue)==0 &&
-        (mxSelect = pParse->db->aLimit[SQLITE_LIMIT_COMPOUND_SELECT])>0 &&
-        cnt>mxSelect
+      if( (p->selFlags & (SF_MultiValue|SF_Values))==0
+       && (mxSelect = pParse->db->aLimit[SQLITE_LIMIT_COMPOUND_SELECT])>0
+       && cnt>mxSelect
       ){
         sqlite3ErrorMsg(pParse, "too many terms in compound SELECT");
       }
@@ -171042,6 +173939,14 @@ static void updateDeleteLimitError(
     return pSelect;
   }
 
+  /* Memory allocator for parser stack resizing.  This is a thin wrapper around
+  ** sqlite3_realloc() that includes a call to sqlite3FaultSim() to facilitate
+  ** testing.
+  */
+  static void *parserStackRealloc(void *pOld, sqlite3_uint64 newSize){
+    return sqlite3FaultSim(700) ? 0 : sqlite3_realloc(pOld, newSize);
+  }
+
 
   /* Construct a new Expr object from a single token */
   static Expr *tokenExpr(Parse *pParse, int op, Token t){
@@ -171164,135 +174069,135 @@ static void updateDeleteLimitError(
 #define TK_OR                             43
 #define TK_AND                            44
 #define TK_IS                             45
-#define TK_MATCH                          46
-#define TK_LIKE_KW                        47
-#define TK_BETWEEN                        48
-#define TK_IN                             49
-#define TK_ISNULL                         50
-#define TK_NOTNULL                        51
-#define TK_NE                             52
-#define TK_EQ                             53
-#define TK_GT                             54
-#define TK_LE                             55
-#define TK_LT                             56
-#define TK_GE                             57
-#define TK_ESCAPE                         58
-#define TK_ID                             59
-#define TK_COLUMNKW                       60
-#define TK_DO                             61
-#define TK_FOR                            62
-#define TK_IGNORE                         63
-#define TK_INITIALLY                      64
-#define TK_INSTEAD                        65
-#define TK_NO                             66
-#define TK_KEY                            67
-#define TK_OF                             68
-#define TK_OFFSET                         69
-#define TK_PRAGMA                         70
-#define TK_RAISE                          71
-#define TK_RECURSIVE                      72
-#define TK_REPLACE                        73
-#define TK_RESTRICT                       74
-#define TK_ROW                            75
-#define TK_ROWS                           76
-#define TK_TRIGGER                        77
-#define TK_VACUUM                         78
-#define TK_VIEW                           79
-#define TK_VIRTUAL                        80
-#define TK_WITH                           81
-#define TK_NULLS                          82
-#define TK_FIRST                          83
-#define TK_LAST                           84
-#define TK_CURRENT                        85
-#define TK_FOLLOWING                      86
-#define TK_PARTITION                      87
-#define TK_PRECEDING                      88
-#define TK_RANGE                          89
-#define TK_UNBOUNDED                      90
-#define TK_EXCLUDE                        91
-#define TK_GROUPS                         92
-#define TK_OTHERS                         93
-#define TK_TIES                           94
-#define TK_GENERATED                      95
-#define TK_ALWAYS                         96
-#define TK_MATERIALIZED                   97
-#define TK_REINDEX                        98
-#define TK_RENAME                         99
-#define TK_CTIME_KW                       100
-#define TK_ANY                            101
-#define TK_BITAND                         102
-#define TK_BITOR                          103
-#define TK_LSHIFT                         104
-#define TK_RSHIFT                         105
-#define TK_PLUS                           106
-#define TK_MINUS                          107
-#define TK_STAR                           108
-#define TK_SLASH                          109
-#define TK_REM                            110
-#define TK_CONCAT                         111
-#define TK_PTR                            112
-#define TK_COLLATE                        113
-#define TK_BITNOT                         114
-#define TK_ON                             115
-#define TK_INDEXED                        116
-#define TK_STRING                         117
-#define TK_JOIN_KW                        118
-#define TK_CONSTRAINT                     119
-#define TK_DEFAULT                        120
-#define TK_NULL                           121
-#define TK_PRIMARY                        122
-#define TK_UNIQUE                         123
-#define TK_CHECK                          124
-#define TK_REFERENCES                     125
-#define TK_AUTOINCR                       126
-#define TK_INSERT                         127
-#define TK_DELETE                         128
-#define TK_UPDATE                         129
-#define TK_SET                            130
-#define TK_DEFERRABLE                     131
-#define TK_FOREIGN                        132
-#define TK_DROP                           133
-#define TK_UNION                          134
-#define TK_ALL                            135
-#define TK_EXCEPT                         136
-#define TK_INTERSECT                      137
-#define TK_SELECT                         138
-#define TK_VALUES                         139
-#define TK_DISTINCT                       140
-#define TK_DOT                            141
-#define TK_FROM                           142
-#define TK_JOIN                           143
-#define TK_USING                          144
-#define TK_ORDER                          145
-#define TK_GROUP                          146
-#define TK_HAVING                         147
-#define TK_LIMIT                          148
-#define TK_WHERE                          149
-#define TK_RETURNING                      150
-#define TK_INTO                           151
-#define TK_NOTHING                        152
-#define TK_FLOAT                          153
-#define TK_BLOB                           154
-#define TK_INTEGER                        155
-#define TK_VARIABLE                       156
-#define TK_CASE                           157
-#define TK_WHEN                           158
-#define TK_THEN                           159
-#define TK_ELSE                           160
-#define TK_INDEX                          161
-#define TK_ALTER                          162
-#define TK_ADD                            163
-#define TK_WINDOW                         164
-#define TK_OVER                           165
-#define TK_FILTER                         166
-#define TK_COLUMN                         167
-#define TK_AGG_FUNCTION                   168
-#define TK_AGG_COLUMN                     169
-#define TK_TRUEFALSE                      170
-#define TK_ISNOT                          171
+#define TK_ISNOT                          46
+#define TK_MATCH                          47
+#define TK_LIKE_KW                        48
+#define TK_BETWEEN                        49
+#define TK_IN                             50
+#define TK_ISNULL                         51
+#define TK_NOTNULL                        52
+#define TK_NE                             53
+#define TK_EQ                             54
+#define TK_GT                             55
+#define TK_LE                             56
+#define TK_LT                             57
+#define TK_GE                             58
+#define TK_ESCAPE                         59
+#define TK_ID                             60
+#define TK_COLUMNKW                       61
+#define TK_DO                             62
+#define TK_FOR                            63
+#define TK_IGNORE                         64
+#define TK_INITIALLY                      65
+#define TK_INSTEAD                        66
+#define TK_NO                             67
+#define TK_KEY                            68
+#define TK_OF                             69
+#define TK_OFFSET                         70
+#define TK_PRAGMA                         71
+#define TK_RAISE                          72
+#define TK_RECURSIVE                      73
+#define TK_REPLACE                        74
+#define TK_RESTRICT                       75
+#define TK_ROW                            76
+#define TK_ROWS                           77
+#define TK_TRIGGER                        78
+#define TK_VACUUM                         79
+#define TK_VIEW                           80
+#define TK_VIRTUAL                        81
+#define TK_WITH                           82
+#define TK_NULLS                          83
+#define TK_FIRST                          84
+#define TK_LAST                           85
+#define TK_CURRENT                        86
+#define TK_FOLLOWING                      87
+#define TK_PARTITION                      88
+#define TK_PRECEDING                      89
+#define TK_RANGE                          90
+#define TK_UNBOUNDED                      91
+#define TK_EXCLUDE                        92
+#define TK_GROUPS                         93
+#define TK_OTHERS                         94
+#define TK_TIES                           95
+#define TK_GENERATED                      96
+#define TK_ALWAYS                         97
+#define TK_MATERIALIZED                   98
+#define TK_REINDEX                        99
+#define TK_RENAME                         100
+#define TK_CTIME_KW                       101
+#define TK_ANY                            102
+#define TK_BITAND                         103
+#define TK_BITOR                          104
+#define TK_LSHIFT                         105
+#define TK_RSHIFT                         106
+#define TK_PLUS                           107
+#define TK_MINUS                          108
+#define TK_STAR                           109
+#define TK_SLASH                          110
+#define TK_REM                            111
+#define TK_CONCAT                         112
+#define TK_PTR                            113
+#define TK_COLLATE                        114
+#define TK_BITNOT                         115
+#define TK_ON                             116
+#define TK_INDEXED                        117
+#define TK_STRING                         118
+#define TK_JOIN_KW                        119
+#define TK_CONSTRAINT                     120
+#define TK_DEFAULT                        121
+#define TK_NULL                           122
+#define TK_PRIMARY                        123
+#define TK_UNIQUE                         124
+#define TK_CHECK                          125
+#define TK_REFERENCES                     126
+#define TK_AUTOINCR                       127
+#define TK_INSERT                         128
+#define TK_DELETE                         129
+#define TK_UPDATE                         130
+#define TK_SET                            131
+#define TK_DEFERRABLE                     132
+#define TK_FOREIGN                        133
+#define TK_DROP                           134
+#define TK_UNION                          135
+#define TK_ALL                            136
+#define TK_EXCEPT                         137
+#define TK_INTERSECT                      138
+#define TK_SELECT                         139
+#define TK_VALUES                         140
+#define TK_DISTINCT                       141
+#define TK_DOT                            142
+#define TK_FROM                           143
+#define TK_JOIN                           144
+#define TK_USING                          145
+#define TK_ORDER                          146
+#define TK_GROUP                          147
+#define TK_HAVING                         148
+#define TK_LIMIT                          149
+#define TK_WHERE                          150
+#define TK_RETURNING                      151
+#define TK_INTO                           152
+#define TK_NOTHING                        153
+#define TK_FLOAT                          154
+#define TK_BLOB                           155
+#define TK_INTEGER                        156
+#define TK_VARIABLE                       157
+#define TK_CASE                           158
+#define TK_WHEN                           159
+#define TK_THEN                           160
+#define TK_ELSE                           161
+#define TK_INDEX                          162
+#define TK_ALTER                          163
+#define TK_ADD                            164
+#define TK_WINDOW                         165
+#define TK_OVER                           166
+#define TK_FILTER                         167
+#define TK_COLUMN                         168
+#define TK_AGG_FUNCTION                   169
+#define TK_AGG_COLUMN                     170
+#define TK_TRUEFALSE                      171
 #define TK_FUNCTION                       172
-#define TK_UMINUS                         173
-#define TK_UPLUS                          174
+#define TK_UPLUS                          173
+#define TK_UMINUS                         174
 #define TK_TRUTH                          175
 #define TK_REGISTER                       176
 #define TK_VECTOR                         177
@@ -171301,8 +174206,9 @@ static void updateDeleteLimitError(
 #define TK_ASTERISK                       180
 #define TK_SPAN                           181
 #define TK_ERROR                          182
-#define TK_SPACE                          183
-#define TK_ILLEGAL                        184
+#define TK_QNUMBER                        183
+#define TK_SPACE                          184
+#define TK_ILLEGAL                        185
 #endif
 /**************** End token definitions ***************************************/
 
@@ -171343,6 +174249,9 @@ static void updateDeleteLimitError(
 **    sqlite3ParserARG_STORE     Code to store %extra_argument into yypParser
 **    sqlite3ParserARG_FETCH     Code to extract %extra_argument from yypParser
 **    sqlite3ParserCTX_*         As sqlite3ParserARG_ except for %extra_context
+**    YYREALLOC          Name of the realloc() function to use
+**    YYFREE             Name of the free() function to use
+**    YYDYNSTACK         True if stack space should be extended on heap
 **    YYERRORSYMBOL      is the code number of the error symbol.  If not
 **                       defined, then do no error processing.
 **    YYNSTATE           the combined number of states.
@@ -171356,37 +174265,39 @@ static void updateDeleteLimitError(
 **    YY_NO_ACTION       The yy_action[] code for no-op
 **    YY_MIN_REDUCE      Minimum value for reduce actions
 **    YY_MAX_REDUCE      Maximum value for reduce actions
+**    YY_MIN_DSTRCTR     Minimum symbol value that has a destructor
+**    YY_MAX_DSTRCTR     Maximum symbol value that has a destructor
 */
 #ifndef INTERFACE
 # define INTERFACE 1
 #endif
 /************* Begin control #defines *****************************************/
 #define YYCODETYPE unsigned short int
-#define YYNOCODE 319
+#define YYNOCODE 322
 #define YYACTIONTYPE unsigned short int
-#define YYWILDCARD 101
+#define YYWILDCARD 102
 #define sqlite3ParserTOKENTYPE Token
 typedef union {
   int yyinit;
   sqlite3ParserTOKENTYPE yy0;
-  TriggerStep* yy33;
-  Window* yy41;
-  Select* yy47;
-  SrcList* yy131;
-  struct TrigEvent yy180;
-  struct {int value; int mask;} yy231;
-  IdList* yy254;
-  u32 yy285;
-  ExprList* yy322;
-  Cte* yy385;
-  int yy394;
-  Upsert* yy444;
-  u8 yy516;
-  With* yy521;
-  const char* yy522;
-  Expr* yy528;
-  OnOrUsing yy561;
-  struct FrameBound yy595;
+  ExprList* yy14;
+  With* yy59;
+  Cte* yy67;
+  Upsert* yy122;
+  IdList* yy132;
+  int yy144;
+  const char* yy168;
+  SrcList* yy203;
+  Window* yy211;
+  OnOrUsing yy269;
+  struct TrigEvent yy286;
+  struct {int value; int mask;} yy383;
+  u32 yy391;
+  TriggerStep* yy427;
+  Expr* yy454;
+  u8 yy462;
+  struct FrameBound yy509;
+  Select* yy555;
 } YYMINORTYPE;
 #ifndef YYSTACKDEPTH
 #define YYSTACKDEPTH 100
@@ -171396,24 +174307,29 @@ typedef union {
 #define sqlite3ParserARG_PARAM
 #define sqlite3ParserARG_FETCH
 #define sqlite3ParserARG_STORE
+#define YYREALLOC parserStackRealloc
+#define YYFREE sqlite3_free
+#define YYDYNSTACK 1
 #define sqlite3ParserCTX_SDECL Parse *pParse;
 #define sqlite3ParserCTX_PDECL ,Parse *pParse
 #define sqlite3ParserCTX_PARAM ,pParse
 #define sqlite3ParserCTX_FETCH Parse *pParse=yypParser->pParse;
 #define sqlite3ParserCTX_STORE yypParser->pParse=pParse;
 #define YYFALLBACK 1
-#define YYNSTATE             579
-#define YYNRULE              405
-#define YYNRULE_WITH_ACTION  340
-#define YYNTOKEN             185
-#define YY_MAX_SHIFT         578
-#define YY_MIN_SHIFTREDUCE   838
-#define YY_MAX_SHIFTREDUCE   1242
-#define YY_ERROR_ACTION      1243
-#define YY_ACCEPT_ACTION     1244
-#define YY_NO_ACTION         1245
-#define YY_MIN_REDUCE        1246
-#define YY_MAX_REDUCE        1650
+#define YYNSTATE             583
+#define YYNRULE              409
+#define YYNRULE_WITH_ACTION  344
+#define YYNTOKEN             186
+#define YY_MAX_SHIFT         582
+#define YY_MIN_SHIFTREDUCE   845
+#define YY_MAX_SHIFTREDUCE   1253
+#define YY_ERROR_ACTION      1254
+#define YY_ACCEPT_ACTION     1255
+#define YY_NO_ACTION         1256
+#define YY_MIN_REDUCE        1257
+#define YY_MAX_REDUCE        1665
+#define YY_MIN_DSTRCTR       205
+#define YY_MAX_DSTRCTR       319
 /************* End control #defines *******************************************/
 #define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])))
 
@@ -171429,6 +174345,22 @@ typedef union {
 # define yytestcase(X)
 #endif
 
+/* Macro to determine if stack space has the ability to grow using
+** heap memory.
+*/
+#if YYSTACKDEPTH<=0 || YYDYNSTACK
+# define YYGROWABLESTACK 1
+#else
+# define YYGROWABLESTACK 0
+#endif
+
+/* Guarantee a minimum number of initial stack slots.
+*/
+#if YYSTACKDEPTH<=0
+# undef YYSTACKDEPTH
+# define YYSTACKDEPTH 2  /* Need a minimum stack size */
+#endif
+
 
 /* Next are the tables used to determine what action to take based on the
 ** current state and lookahead token.  These tables are used to implement
@@ -171480,619 +174412,643 @@ typedef union {
 **  yy_default[]       Default action for each state.
 **
 *********** Begin parsing tables **********************************************/
-#define YY_ACTTAB_COUNT (2100)
+#define YY_ACTTAB_COUNT (2207)
 static const YYACTIONTYPE yy_action[] = {
- /*     0 */   572,  210,  572,  119,  116,  231,  572,  119,  116,  231,
- /*    10 */   572, 1317,  379, 1296,  410,  566,  566,  566,  572,  411,
- /*    20 */   380, 1317, 1279,   42,   42,   42,   42,  210, 1529,   72,
- /*    30 */    72,  974,  421,   42,   42,  495,  305,  281,  305,  975,
- /*    40 */   399,   72,   72,  126,  127,   81, 1217, 1217, 1054, 1057,
- /*    50 */  1044, 1044,  124,  124,  125,  125,  125,  125,  480,  411,
- /*    60 */  1244,    1,    1,  578,    2, 1248,  554,  119,  116,  231,
- /*    70 */   319,  484,  147,  484,  528,  119,  116,  231,  533, 1330,
- /*    80 */   419,  527,  143,  126,  127,   81, 1217, 1217, 1054, 1057,
- /*    90 */  1044, 1044,  124,  124,  125,  125,  125,  125,  119,  116,
- /*   100 */   231,  329,  123,  123,  123,  123,  122,  122,  121,  121,
- /*   110 */   121,  120,  117,  448,  286,  286,  286,  286,  446,  446,
- /*   120 */   446, 1568,  378, 1570, 1193,  377, 1164,  569, 1164,  569,
- /*   130 */   411, 1568,  541,  261,  228,  448,  102,  146,  453,  318,
- /*   140 */   563,  242,  123,  123,  123,  123,  122,  122,  121,  121,
- /*   150 */   121,  120,  117,  448,  126,  127,   81, 1217, 1217, 1054,
- /*   160 */  1057, 1044, 1044,  124,  124,  125,  125,  125,  125,  143,
- /*   170 */   296, 1193,  341,  452,  121,  121,  121,  120,  117,  448,
- /*   180 */   128, 1193, 1194, 1193,  149,  445,  444,  572,  120,  117,
- /*   190 */   448,  125,  125,  125,  125,  118,  123,  123,  123,  123,
- /*   200 */   122,  122,  121,  121,  121,  120,  117,  448,  458,  114,
- /*   210 */    13,   13,  550,  123,  123,  123,  123,  122,  122,  121,
- /*   220 */   121,  121,  120,  117,  448,  424,  318,  563, 1193, 1194,
- /*   230 */  1193,  150, 1225,  411, 1225,  125,  125,  125,  125,  123,
- /*   240 */   123,  123,  123,  122,  122,  121,  121,  121,  120,  117,
- /*   250 */   448,  469,  344, 1041, 1041, 1055, 1058,  126,  127,   81,
- /*   260 */  1217, 1217, 1054, 1057, 1044, 1044,  124,  124,  125,  125,
- /*   270 */   125,  125, 1282,  526,  224, 1193,  572,  411,  226,  519,
- /*   280 */   177,   83,   84,  123,  123,  123,  123,  122,  122,  121,
- /*   290 */   121,  121,  120,  117,  448, 1010,   16,   16, 1193,  134,
- /*   300 */   134,  126,  127,   81, 1217, 1217, 1054, 1057, 1044, 1044,
- /*   310 */   124,  124,  125,  125,  125,  125,  123,  123,  123,  123,
- /*   320 */   122,  122,  121,  121,  121,  120,  117,  448, 1045,  550,
- /*   330 */  1193,  375, 1193, 1194, 1193,  254, 1438,  401,  508,  505,
- /*   340 */   504,  112,  564,  570,    4,  929,  929,  435,  503,  342,
- /*   350 */   464,  330,  362,  396, 1238, 1193, 1194, 1193,  567,  572,
- /*   360 */   123,  123,  123,  123,  122,  122,  121,  121,  121,  120,
- /*   370 */   117,  448,  286,  286,  371, 1581, 1607,  445,  444,  155,
- /*   380 */   411,  449,   72,   72, 1289,  569, 1222, 1193, 1194, 1193,
- /*   390 */    86, 1224,  273,  561,  547,  520,  520,  572,   99, 1223,
- /*   400 */     6, 1281,  476,  143,  126,  127,   81, 1217, 1217, 1054,
- /*   410 */  1057, 1044, 1044,  124,  124,  125,  125,  125,  125,  554,
- /*   420 */    13,   13, 1031,  511, 1225, 1193, 1225,  553,  110,  110,
- /*   430 */   224,  572, 1239,  177,  572,  429,  111,  199,  449,  573,
- /*   440 */   449,  432, 1555, 1019,  327,  555, 1193,  272,  289,  370,
- /*   450 */   514,  365,  513,  259,   72,   72,  547,   72,   72,  361,
- /*   460 */   318,  563, 1613,  123,  123,  123,  123,  122,  122,  121,
- /*   470 */   121,  121,  120,  117,  448, 1019, 1019, 1021, 1022,   28,
- /*   480 */   286,  286, 1193, 1194, 1193, 1159,  572, 1612,  411,  904,
- /*   490 */   192,  554,  358,  569,  554,  940,  537,  521, 1159,  437,
- /*   500 */   415, 1159,  556, 1193, 1194, 1193,  572,  548,  548,   52,
- /*   510 */    52,  216,  126,  127,   81, 1217, 1217, 1054, 1057, 1044,
- /*   520 */  1044,  124,  124,  125,  125,  125,  125, 1193,  478,  136,
- /*   530 */   136,  411,  286,  286, 1493,  509,  122,  122,  121,  121,
- /*   540 */   121,  120,  117,  448, 1010,  569,  522,  219,  545,  545,
- /*   550 */   318,  563,  143,    6,  536,  126,  127,   81, 1217, 1217,
- /*   560 */  1054, 1057, 1044, 1044,  124,  124,  125,  125,  125,  125,
- /*   570 */  1557,  123,  123,  123,  123,  122,  122,  121,  121,  121,
- /*   580 */   120,  117,  448,  489, 1193, 1194, 1193,  486,  283, 1270,
- /*   590 */   960,  254, 1193,  375,  508,  505,  504, 1193,  342,  574,
- /*   600 */  1193,  574,  411,  294,  503,  960,  879,  193,  484,  318,
- /*   610 */   563,  386,  292,  382,  123,  123,  123,  123,  122,  122,
- /*   620 */   121,  121,  121,  120,  117,  448,  126,  127,   81, 1217,
- /*   630 */  1217, 1054, 1057, 1044, 1044,  124,  124,  125,  125,  125,
- /*   640 */   125,  411,  396, 1139, 1193,  872,  101,  286,  286, 1193,
- /*   650 */  1194, 1193,  375, 1096, 1193, 1194, 1193, 1193, 1194, 1193,
- /*   660 */   569,  459,   33,  375,  235,  126,  127,   81, 1217, 1217,
- /*   670 */  1054, 1057, 1044, 1044,  124,  124,  125,  125,  125,  125,
- /*   680 */  1437,  962,  572,  230,  961,  123,  123,  123,  123,  122,
- /*   690 */   122,  121,  121,  121,  120,  117,  448, 1159,  230, 1193,
- /*   700 */   158, 1193, 1194, 1193, 1556,   13,   13,  303,  960, 1233,
- /*   710 */  1159,  154,  411, 1159,  375, 1584, 1177,    5,  371, 1581,
- /*   720 */   431, 1239,    3,  960,  123,  123,  123,  123,  122,  122,
- /*   730 */   121,  121,  121,  120,  117,  448,  126,  127,   81, 1217,
- /*   740 */  1217, 1054, 1057, 1044, 1044,  124,  124,  125,  125,  125,
- /*   750 */   125,  411,  210,  571, 1193, 1032, 1193, 1194, 1193, 1193,
- /*   760 */   390,  855,  156, 1555,  376,  404, 1101, 1101,  492,  572,
- /*   770 */   469,  344, 1322, 1322, 1555,  126,  127,   81, 1217, 1217,
- /*   780 */  1054, 1057, 1044, 1044,  124,  124,  125,  125,  125,  125,
- /*   790 */   130,  572,   13,   13,  532,  123,  123,  123,  123,  122,
- /*   800 */   122,  121,  121,  121,  120,  117,  448,  304,  572,  457,
- /*   810 */   229, 1193, 1194, 1193,   13,   13, 1193, 1194, 1193, 1300,
- /*   820 */   467, 1270,  411, 1320, 1320, 1555, 1015,  457,  456,  436,
- /*   830 */   301,   72,   72, 1268,  123,  123,  123,  123,  122,  122,
- /*   840 */   121,  121,  121,  120,  117,  448,  126,  127,   81, 1217,
- /*   850 */  1217, 1054, 1057, 1044, 1044,  124,  124,  125,  125,  125,
- /*   860 */   125,  411,  384, 1076, 1159,  286,  286,  421,  314,  280,
- /*   870 */   280,  287,  287,  461,  408,  407, 1539, 1159,  569,  572,
- /*   880 */  1159, 1196,  569,  409,  569,  126,  127,   81, 1217, 1217,
- /*   890 */  1054, 1057, 1044, 1044,  124,  124,  125,  125,  125,  125,
- /*   900 */   457, 1485,   13,   13, 1541,  123,  123,  123,  123,  122,
- /*   910 */   122,  121,  121,  121,  120,  117,  448,  202,  572,  462,
- /*   920 */  1587,  578,    2, 1248,  843,  844,  845, 1563,  319,  409,
- /*   930 */   147,    6,  411,  257,  256,  255,  208, 1330,    9, 1196,
- /*   940 */   264,   72,   72, 1436,  123,  123,  123,  123,  122,  122,
- /*   950 */   121,  121,  121,  120,  117,  448,  126,  127,   81, 1217,
- /*   960 */  1217, 1054, 1057, 1044, 1044,  124,  124,  125,  125,  125,
- /*   970 */   125,  572,  286,  286,  572, 1213,  411,  577,  315, 1248,
- /*   980 */   421,  371, 1581,  356,  319,  569,  147,  495,  529, 1644,
- /*   990 */   397,  935,  495, 1330,   71,   71,  934,   72,   72,  242,
- /*  1000 */  1328,  105,   81, 1217, 1217, 1054, 1057, 1044, 1044,  124,
- /*  1010 */   124,  125,  125,  125,  125,  123,  123,  123,  123,  122,
- /*  1020 */   122,  121,  121,  121,  120,  117,  448, 1117,  286,  286,
- /*  1030 */  1422,  452, 1528, 1213,  443,  286,  286, 1492, 1355,  313,
- /*  1040 */   478,  569, 1118,  454,  351,  495,  354, 1266,  569,  209,
- /*  1050 */   572,  418,  179,  572, 1031,  242,  385, 1119,  523,  123,
- /*  1060 */   123,  123,  123,  122,  122,  121,  121,  121,  120,  117,
- /*  1070 */   448, 1020,  108,   72,   72, 1019,   13,   13,  915,  572,
- /*  1080 */  1498,  572,  286,  286,   98,  530, 1537,  452,  916, 1334,
- /*  1090 */  1329,  203,  411,  286,  286,  569,  152,  211, 1498, 1500,
- /*  1100 */   426,  569,   56,   56,   57,   57,  569, 1019, 1019, 1021,
- /*  1110 */   447,  572,  411,  531,   12,  297,  126,  127,   81, 1217,
- /*  1120 */  1217, 1054, 1057, 1044, 1044,  124,  124,  125,  125,  125,
- /*  1130 */   125,  572,  411,  867,   15,   15,  126,  127,   81, 1217,
- /*  1140 */  1217, 1054, 1057, 1044, 1044,  124,  124,  125,  125,  125,
- /*  1150 */   125,  373,  529,  264,   44,   44,  126,  115,   81, 1217,
- /*  1160 */  1217, 1054, 1057, 1044, 1044,  124,  124,  125,  125,  125,
- /*  1170 */   125, 1498,  478, 1271,  417,  123,  123,  123,  123,  122,
- /*  1180 */   122,  121,  121,  121,  120,  117,  448,  205, 1213,  495,
- /*  1190 */   430,  867,  468,  322,  495,  123,  123,  123,  123,  122,
- /*  1200 */   122,  121,  121,  121,  120,  117,  448,  572,  557, 1140,
- /*  1210 */  1642, 1422, 1642,  543,  572,  123,  123,  123,  123,  122,
- /*  1220 */   122,  121,  121,  121,  120,  117,  448,  572, 1422,  572,
- /*  1230 */    13,   13,  542,  323, 1325,  411,  334,   58,   58,  349,
- /*  1240 */  1422, 1170,  326,  286,  286,  549, 1213,  300,  895,  530,
- /*  1250 */    45,   45,   59,   59, 1140, 1643,  569, 1643,  565,  417,
- /*  1260 */   127,   81, 1217, 1217, 1054, 1057, 1044, 1044,  124,  124,
- /*  1270 */   125,  125,  125,  125, 1367,  373,  500,  290, 1193,  512,
- /*  1280 */  1366,  427,  394,  394,  393,  275,  391,  896, 1138,  852,
- /*  1290 */   478,  258, 1422, 1170,  463, 1159,   12,  331,  428,  333,
- /*  1300 */  1117,  460,  236,  258,  325,  460,  544, 1544, 1159, 1098,
- /*  1310 */   491, 1159,  324, 1098,  440, 1118,  335,  516,  123,  123,
- /*  1320 */   123,  123,  122,  122,  121,  121,  121,  120,  117,  448,
- /*  1330 */  1119,  318,  563, 1138,  572, 1193, 1194, 1193,  112,  564,
- /*  1340 */   201,    4,  238,  433,  935,  490,  285,  228, 1517,  934,
- /*  1350 */   170,  560,  572,  142, 1516,  567,  572,   60,   60,  572,
- /*  1360 */   416,  572,  441,  572,  535,  302,  875,    8,  487,  572,
- /*  1370 */   237,  572,  416,  572,  485,   61,   61,  572,  449,   62,
- /*  1380 */    62,  332,   63,   63,   46,   46,   47,   47,  361,  572,
- /*  1390 */   561,  572,   48,   48,   50,   50,   51,   51,  572,  295,
- /*  1400 */    64,   64,  482,  295,  539,  412,  471, 1031,  572,  538,
- /*  1410 */   318,  563,   65,   65,   66,   66,  409,  475,  572, 1031,
- /*  1420 */   572,   14,   14,  875, 1020,  110,  110,  409, 1019,  572,
- /*  1430 */   474,   67,   67,  111,  455,  449,  573,  449,   98,  317,
- /*  1440 */  1019,  132,  132,  133,  133,  572, 1561,  572,  974,  409,
- /*  1450 */     6, 1562,   68,   68, 1560,    6,  975,  572,    6, 1559,
- /*  1460 */  1019, 1019, 1021,    6,  346,  218,  101,  531,   53,   53,
- /*  1470 */    69,   69, 1019, 1019, 1021, 1022,   28, 1586, 1181,  451,
- /*  1480 */    70,   70,  290,   87,  215,   31, 1363,  394,  394,  393,
- /*  1490 */   275,  391,  350,  109,  852,  107,  572,  112,  564,  483,
- /*  1500 */     4, 1212,  572,  239,  153,  572,   39,  236, 1299,  325,
- /*  1510 */   112,  564, 1298,    4,  567,  572,   32,  324,  572,   54,
- /*  1520 */    54,  572, 1135,  353,  398,  165,  165,  567,  166,  166,
- /*  1530 */   572,  291,  355,  572,   17,  357,  572,  449,   77,   77,
- /*  1540 */  1313,   55,   55, 1297,   73,   73,  572,  238,  470,  561,
- /*  1550 */   449,  472,  364,  135,  135,  170,   74,   74,  142,  163,
- /*  1560 */   163,  374,  561,  539,  572,  321,  572,  886,  540,  137,
- /*  1570 */   137,  339, 1353,  422,  298,  237,  539,  572, 1031,  572,
- /*  1580 */   340,  538,  101,  369,  110,  110,  162,  131,  131,  164,
- /*  1590 */   164, 1031,  111,  368,  449,  573,  449,  110,  110, 1019,
- /*  1600 */   157,  157,  141,  141,  572,  111,  572,  449,  573,  449,
- /*  1610 */   412,  288, 1019,  572,  882,  318,  563,  572,  219,  572,
- /*  1620 */   241, 1012,  477,  263,  263,  894,  893,  140,  140,  138,
- /*  1630 */   138, 1019, 1019, 1021, 1022,   28,  139,  139,  525,  455,
- /*  1640 */    76,   76,   78,   78, 1019, 1019, 1021, 1022,   28, 1181,
- /*  1650 */   451,  572, 1083,  290,  112,  564, 1575,    4,  394,  394,
- /*  1660 */   393,  275,  391,  572, 1023,  852,  572,  479,  345,  263,
- /*  1670 */   101,  567,  882, 1376,   75,   75, 1421,  501,  236,  260,
- /*  1680 */   325,  112,  564,  359,    4,  101,   43,   43,  324,   49,
- /*  1690 */    49,  901,  902,  161,  449,  101,  977,  978,  567, 1079,
- /*  1700 */  1349,  260,  965,  932,  263,  114,  561, 1095,  517, 1095,
- /*  1710 */  1083, 1094,  865, 1094,  151,  933, 1144,  114,  238, 1361,
- /*  1720 */   558,  449, 1023,  559, 1426, 1278,  170, 1269, 1257,  142,
- /*  1730 */  1601, 1256, 1258,  561, 1594, 1031,  496,  278,  213, 1346,
- /*  1740 */   310,  110,  110,  939,  311,  312,  237,   11,  234,  111,
- /*  1750 */   221,  449,  573,  449,  293,  395, 1019, 1408,  337, 1403,
- /*  1760 */  1396,  338, 1031,  299,  343, 1413, 1412,  481,  110,  110,
- /*  1770 */   506,  402,  225, 1296,  206,  367,  111, 1358,  449,  573,
- /*  1780 */   449,  412, 1359, 1019, 1489, 1488,  318,  563, 1019, 1019,
- /*  1790 */  1021, 1022,   28,  562,  207,  220,   80,  564,  389,    4,
- /*  1800 */  1597, 1357,  552, 1356, 1233,  181,  267,  232, 1536, 1534,
- /*  1810 */   455, 1230,  420,  567,   82, 1019, 1019, 1021, 1022,   28,
- /*  1820 */    86,  217,   85, 1494,  190,  175,  183,  465,  185,  466,
- /*  1830 */    36, 1409,  186,  187,  188,  499,  449,  244,   37,   99,
- /*  1840 */   400, 1415, 1414,  488, 1417,  194,  473,  403,  561, 1483,
- /*  1850 */   248,   92, 1505,  494,  198,  279,  112,  564,  250,    4,
- /*  1860 */   348,  497,  405,  352, 1259,  251,  252,  515, 1316,  434,
- /*  1870 */  1315, 1314,   94,  567, 1307,  886, 1306, 1031,  226,  406,
- /*  1880 */  1611, 1610,  438,  110,  110, 1580, 1286,  524,  439,  308,
- /*  1890 */   266,  111, 1285,  449,  573,  449,  449,  309, 1019,  366,
- /*  1900 */  1284, 1609,  265, 1566, 1565,  442,  372, 1381,  561,  129,
- /*  1910 */   550, 1380,   10, 1470,  383,  106,  316,  551,  100,   35,
- /*  1920 */   534,  575,  212, 1339,  381,  387, 1187, 1338,  274,  276,
- /*  1930 */  1019, 1019, 1021, 1022,   28,  277,  413, 1031,  576, 1254,
- /*  1940 */   388, 1521, 1249,  110,  110,  167, 1522,  168,  148, 1520,
- /*  1950 */  1519,  111,  306,  449,  573,  449,  222,  223, 1019,  839,
- /*  1960 */   169,   79,  450,  214,  414,  233,  320,  145, 1093, 1091,
- /*  1970 */   328,  182,  171, 1212,  918,  184,  240,  336,  243, 1107,
- /*  1980 */   189,  172,  173,  423,  425,   88,  180,  191,   89,   90,
- /*  1990 */  1019, 1019, 1021, 1022,   28,   91,  174, 1110,  245, 1106,
- /*  2000 */   246,  159,   18,  247,  347, 1099,  263,  195, 1227,  493,
- /*  2010 */   249,  196,   38,  854,  498,  368,  253,  360,  897,  197,
- /*  2020 */   502,   93,   19,   20,  507,  884,  363,  510,   95,  307,
- /*  2030 */   160,   96,  518,   97, 1175, 1060, 1146,   40,   21,  227,
- /*  2040 */   176, 1145,  282,  284,  969,  200,  963,  114,  262, 1165,
- /*  2050 */    22,   23,   24, 1161, 1169,   25, 1163, 1150,   34,   26,
- /*  2060 */  1168,  546,   27,  204,  101,  103,  104, 1074,    7, 1061,
- /*  2070 */  1059, 1063, 1116, 1064, 1115,  268,  269,   29,   41,  270,
- /*  2080 */  1024,  866,  113,   30,  568,  392, 1183,  144,  178, 1182,
- /*  2090 */   271,  928, 1245, 1245, 1245, 1245, 1245, 1245, 1245, 1602,
+ /*     0 */   130,  127,  234,  282,  282, 1328,  576, 1307,  460,  289,
+ /*    10 */   289,  576, 1622,  381,  576, 1328,  573,  576,  562,  413,
+ /*    20 */  1300, 1542,  573,  481,  562,  524,  460,  459,  558,   82,
+ /*    30 */    82,  983,  294,  375,   51,   51,  498,   61,   61,  984,
+ /*    40 */    82,   82, 1577,  137,  138,   91,    7, 1228, 1228, 1063,
+ /*    50 */  1066, 1053, 1053,  135,  135,  136,  136,  136,  136,  413,
+ /*    60 */   288,  288,  182,  288,  288,  481,  536,  288,  288,  130,
+ /*    70 */   127,  234,  432,  573,  525,  562,  573,  557,  562, 1290,
+ /*    80 */   573,  421,  562,  137,  138,   91,  559, 1228, 1228, 1063,
+ /*    90 */  1066, 1053, 1053,  135,  135,  136,  136,  136,  136,  296,
+ /*   100 */   460,  398, 1249,  134,  134,  134,  134,  133,  133,  132,
+ /*   110 */   132,  132,  131,  128,  451,   44, 1050, 1050, 1064, 1067,
+ /*   120 */  1255,    1,    1,  582,    2, 1259,  581, 1174, 1259, 1174,
+ /*   130 */   321,  413,  155,  321, 1584,  155,  379,  112,  498, 1341,
+ /*   140 */   456,  299, 1341,  134,  134,  134,  134,  133,  133,  132,
+ /*   150 */   132,  132,  131,  128,  451,  137,  138,   91, 1105, 1228,
+ /*   160 */  1228, 1063, 1066, 1053, 1053,  135,  135,  136,  136,  136,
+ /*   170 */   136, 1204,  320,  567,  288,  288,  283,  288,  288,  523,
+ /*   180 */   523, 1250,  139, 1541,    7,  214,  503,  573, 1169,  562,
+ /*   190 */   573, 1054,  562,  136,  136,  136,  136,  129,  401,  547,
+ /*   200 */   487, 1169,  245, 1568, 1169,  245,  133,  133,  132,  132,
+ /*   210 */   132,  131,  128,  451,  261,  134,  134,  134,  134,  133,
+ /*   220 */   133,  132,  132,  132,  131,  128,  451,  451, 1204, 1205,
+ /*   230 */  1204,  130,  127,  234,  455,  413,  182,  455,  130,  127,
+ /*   240 */   234,  134,  134,  134,  134,  133,  133,  132,  132,  132,
+ /*   250 */   131,  128,  451,  136,  136,  136,  136,  538,  576,  137,
+ /*   260 */   138,   91,  261, 1228, 1228, 1063, 1066, 1053, 1053,  135,
+ /*   270 */   135,  136,  136,  136,  136,   44,  472,  346, 1204,  472,
+ /*   280 */   346,   51,   51,  418,   93,  157,  134,  134,  134,  134,
+ /*   290 */   133,  133,  132,  132,  132,  131,  128,  451,  166,  363,
+ /*   300 */   298,  134,  134,  134,  134,  133,  133,  132,  132,  132,
+ /*   310 */   131,  128,  451, 1293,  461, 1570,  423,  377,  275,  134,
+ /*   320 */   134,  134,  134,  133,  133,  132,  132,  132,  131,  128,
+ /*   330 */   451,  418,  320,  567, 1292, 1204, 1205, 1204,  257,  413,
+ /*   340 */   483,  511,  508,  507,   94,  132,  132,  132,  131,  128,
+ /*   350 */   451,  506, 1204,  548,  548,  388,  576,  384,    7,  413,
+ /*   360 */   550,  229,  522,  137,  138,   91,  530, 1228, 1228, 1063,
+ /*   370 */  1066, 1053, 1053,  135,  135,  136,  136,  136,  136,   51,
+ /*   380 */    51, 1582,  380,  137,  138,   91,  331, 1228, 1228, 1063,
+ /*   390 */  1066, 1053, 1053,  135,  135,  136,  136,  136,  136,  320,
+ /*   400 */   567,  288,  288,  320,  567, 1602,  582,    2, 1259, 1204,
+ /*   410 */  1205, 1204, 1628,  321,  573,  155,  562,  576, 1511,  264,
+ /*   420 */   231,  520, 1341,  134,  134,  134,  134,  133,  133,  132,
+ /*   430 */   132,  132,  131,  128,  451,  519, 1511, 1513, 1333, 1333,
+ /*   440 */    82,   82,  498,  134,  134,  134,  134,  133,  133,  132,
+ /*   450 */   132,  132,  131,  128,  451, 1435,  257,  288,  288,  511,
+ /*   460 */   508,  507,  944, 1568,  413, 1019, 1204,  943,  360,  506,
+ /*   470 */   573, 1598,  562,   44,  575,  551,  551,  557, 1107, 1582,
+ /*   480 */   544,  576, 1107,   40,  417,  245,  531, 1505,  137,  138,
+ /*   490 */    91,  219, 1228, 1228, 1063, 1066, 1053, 1053,  135,  135,
+ /*   500 */   136,  136,  136,  136,   81,   81, 1281, 1204,  413,  553,
+ /*   510 */  1511,   48,  512,  448,  447,  493,  578,  455,  578,  344,
+ /*   520 */    45, 1204, 1233, 1204, 1205, 1204,  428, 1235,  158,  882,
+ /*   530 */   320,  567,  137,  138,   91, 1234, 1228, 1228, 1063, 1066,
+ /*   540 */  1053, 1053,  135,  135,  136,  136,  136,  136,  134,  134,
+ /*   550 */   134,  134,  133,  133,  132,  132,  132,  131,  128,  451,
+ /*   560 */  1236,  576, 1236,  329, 1204, 1205, 1204,  387,  492,  403,
+ /*   570 */  1040,  382,  489,  123,  568, 1569,    4,  377, 1204, 1205,
+ /*   580 */  1204,  570,  570,  570,   82,   82,  882, 1029, 1331, 1331,
+ /*   590 */   571, 1028,  134,  134,  134,  134,  133,  133,  132,  132,
+ /*   600 */   132,  131,  128,  451,  288,  288, 1281, 1204,  576,  423,
+ /*   610 */   576, 1568,  413,  423,  452,  378,  886,  573, 1279,  562,
+ /*   620 */    46,  557,  532, 1028, 1028, 1030,  565,  130,  127,  234,
+ /*   630 */   556,   82,   82,   82,   82,  479,  137,  138,   91,  462,
+ /*   640 */  1228, 1228, 1063, 1066, 1053, 1053,  135,  135,  136,  136,
+ /*   650 */   136,  136, 1188,  487, 1506, 1040,  413,    6, 1204,   50,
+ /*   660 */   879,  121,  121,  948, 1204, 1205, 1204,  358,  557,  122,
+ /*   670 */   316,  452,  577,  452,  535, 1204, 1028,  439,  303,  212,
+ /*   680 */   137,  138,   91,  213, 1228, 1228, 1063, 1066, 1053, 1053,
+ /*   690 */   135,  135,  136,  136,  136,  136,  134,  134,  134,  134,
+ /*   700 */   133,  133,  132,  132,  132,  131,  128,  451, 1028, 1028,
+ /*   710 */  1030, 1031,   35,  288,  288, 1204, 1205, 1204, 1040, 1339,
+ /*   720 */   533,  123,  568, 1569,    4,  377,  573, 1019,  562,  353,
+ /*   730 */  1277,  356, 1204, 1205, 1204, 1029,  488, 1188,  571, 1028,
+ /*   740 */   134,  134,  134,  134,  133,  133,  132,  132,  132,  131,
+ /*   750 */   128,  451,  576,  343,  288,  288,  449,  449,  449,  971,
+ /*   760 */   413, 1627,  452,  911, 1187,  288,  288,  573,  464,  562,
+ /*   770 */   238, 1028, 1028, 1030,  565,   82,   82,  498,  573,  411,
+ /*   780 */   562,  344,  467,  332,  137,  138,   91,  197, 1228, 1228,
+ /*   790 */  1063, 1066, 1053, 1053,  135,  135,  136,  136,  136,  136,
+ /*   800 */  1188,  528, 1169, 1040,  413, 1110, 1110,  495, 1041,  121,
+ /*   810 */   121, 1204,  317,  540,  862, 1169, 1244,  122, 1169,  452,
+ /*   820 */   577,  452, 1340,  198, 1028, 1204,  481,  526,  137,  138,
+ /*   830 */    91,  560, 1228, 1228, 1063, 1066, 1053, 1053,  135,  135,
+ /*   840 */   136,  136,  136,  136,  134,  134,  134,  134,  133,  133,
+ /*   850 */   132,  132,  132,  131,  128,  451, 1028, 1028, 1030, 1031,
+ /*   860 */    35, 1204,  288,  288, 1204,  477,  288,  288, 1204, 1205,
+ /*   870 */  1204,  539,  481,  437,  470,  573, 1451,  562,  364,  573,
+ /*   880 */  1153,  562, 1204, 1205, 1204, 1188,    5,  576,  134,  134,
+ /*   890 */   134,  134,  133,  133,  132,  132,  132,  131,  128,  451,
+ /*   900 */   221,  214,  302,   96, 1149, 1657,  232, 1657,  413,  392,
+ /*   910 */    19,   19, 1024,  949,  406,  373, 1595, 1085, 1204, 1205,
+ /*   920 */  1204, 1204, 1205, 1204, 1204,  426, 1149, 1658,  413, 1658,
+ /*   930 */  1659,  399,  137,  138,   91,    3, 1228, 1228, 1063, 1066,
+ /*   940 */  1053, 1053,  135,  135,  136,  136,  136,  136,  304, 1311,
+ /*   950 */   514, 1204,  137,  138,   91, 1498, 1228, 1228, 1063, 1066,
+ /*   960 */  1053, 1053,  135,  135,  136,  136,  136,  136,  434,  131,
+ /*   970 */   128,  451,  375, 1204,  274,  291,  372,  517,  367,  516,
+ /*   980 */   262, 1204, 1205, 1204, 1147,  227,  363,  448,  447, 1435,
+ /*   990 */  1568, 1310,  134,  134,  134,  134,  133,  133,  132,  132,
+ /*  1000 */   132,  131,  128,  451, 1568,  576, 1147,  487, 1204, 1205,
+ /*  1010 */  1204,  442,  134,  134,  134,  134,  133,  133,  132,  132,
+ /*  1020 */   132,  131,  128,  451,  386,  576,  485,  576,   19,   19,
+ /*  1030 */  1204, 1205, 1204, 1345, 1236,  970, 1236,  574,   47,  936,
+ /*  1040 */   936,  473,  413,  431, 1552,  573, 1125,  562,   19,   19,
+ /*  1050 */    19,   19,   49,  336,  850,  851,  852,  111, 1368,  315,
+ /*  1060 */   429,  576,  413,  433,  341,  306,  137,  138,   91,  115,
+ /*  1070 */  1228, 1228, 1063, 1066, 1053, 1053,  135,  135,  136,  136,
+ /*  1080 */   136,  136,  576, 1309,   82,   82,  137,  138,   91,  529,
+ /*  1090 */  1228, 1228, 1063, 1066, 1053, 1053,  135,  135,  136,  136,
+ /*  1100 */   136,  136, 1569,  222,  377,   19,   19,  305, 1126, 1169,
+ /*  1110 */   398, 1148,   22,   22,  498,  333, 1569,  335,  377,  576,
+ /*  1120 */   438,  445, 1169, 1127,  486, 1169,  134,  134,  134,  134,
+ /*  1130 */   133,  133,  132,  132,  132,  131,  128,  451, 1128,  576,
+ /*  1140 */   902,  576,  145,  145,    6,  576,  134,  134,  134,  134,
+ /*  1150 */   133,  133,  132,  132,  132,  131,  128,  451,  214, 1336,
+ /*  1160 */   922,  576,   19,   19,   19,   19, 1282,  419,   19,   19,
+ /*  1170 */   923,  412,  515,  141,  576, 1169,  413,  206,  465,  207,
+ /*  1180 */   903,  215, 1575,  552,  147,  147,    7,  227, 1169,  411,
+ /*  1190 */  1250, 1169,  120,  307,  117,  307,  413,   66,   66,  334,
+ /*  1200 */   137,  138,   91,  119, 1228, 1228, 1063, 1066, 1053, 1053,
+ /*  1210 */   135,  135,  136,  136,  136,  136,  413,  285,  209,  969,
+ /*  1220 */   137,  138,   91,  471, 1228, 1228, 1063, 1066, 1053, 1053,
+ /*  1230 */   135,  135,  136,  136,  136,  136,  435,   10, 1450,  267,
+ /*  1240 */   137,  126,   91, 1435, 1228, 1228, 1063, 1066, 1053, 1053,
+ /*  1250 */   135,  135,  136,  136,  136,  136, 1435, 1435,  410,  409,
+ /*  1260 */   134,  134,  134,  134,  133,  133,  132,  132,  132,  131,
+ /*  1270 */   128,  451,  576,  969,  576, 1224,  498,  373, 1595, 1554,
+ /*  1280 */   134,  134,  134,  134,  133,  133,  132,  132,  132,  131,
+ /*  1290 */   128,  451,  532,  457,  576,   82,   82,   82,   82,  111,
+ /*  1300 */   134,  134,  134,  134,  133,  133,  132,  132,  132,  131,
+ /*  1310 */   128,  451,  109,  233,  430, 1576,  546,   67,   67,    7,
+ /*  1320 */   413,  351,  550, 1550,  260,  259,  258,  494,  443,  569,
+ /*  1330 */   419,  983,  446, 1224,  450,  545, 1207,  576,  969,  984,
+ /*  1340 */   413,  475, 1449, 1574, 1180,  138,   91,    7, 1228, 1228,
+ /*  1350 */  1063, 1066, 1053, 1053,  135,  135,  136,  136,  136,  136,
+ /*  1360 */    21,   21,  267,  576,  300, 1126,   91,  233, 1228, 1228,
+ /*  1370 */  1063, 1066, 1053, 1053,  135,  135,  136,  136,  136,  136,
+ /*  1380 */  1127,  373, 1595,  161, 1573,   16,   53,   53,    7,  108,
+ /*  1390 */   533,   38,  969,  125, 1207, 1128, 1180,  576, 1224,  123,
+ /*  1400 */   568,  893,    4,  324,  134,  134,  134,  134,  133,  133,
+ /*  1410 */   132,  132,  132,  131,  128,  451,  571,  564,  534,  576,
+ /*  1420 */    68,   68,  576,   39,  134,  134,  134,  134,  133,  133,
+ /*  1430 */   132,  132,  132,  131,  128,  451,  576,  160, 1571, 1223,
+ /*  1440 */   452,  576,   54,   54,  576,   69,   69,  576, 1366,  576,
+ /*  1450 */   420,  184,  565,  463,  297,  576, 1224,  463,  297,   70,
+ /*  1460 */    70,  576,   44,  474,   71,   71,  576,   72,   72,  576,
+ /*  1470 */    73,   73,   55,   55,  411,  874,  242,  576,   56,   56,
+ /*  1480 */   576, 1040,  576,  478,   57,   57,  576,  121,  121,   59,
+ /*  1490 */    59,   23,   60,   60,  411,  122,  319,  452,  577,  452,
+ /*  1500 */    74,   74, 1028,   75,   75,   76,   76,  411,  290,   20,
+ /*  1510 */    20,  108,  287,  231,  553,  123,  568,  325,    4,  320,
+ /*  1520 */   567,   97,  218,  944, 1144,  328,  400,  576,  943,  576,
+ /*  1530 */  1380,  424,  571,  874, 1028, 1028, 1030, 1031,   35,  293,
+ /*  1540 */   534,  576, 1104,  576, 1104,    9,  576,  342,  576,  111,
+ /*  1550 */    77,   77,  143,  143,  576,  205,  452,  222, 1379,  889,
+ /*  1560 */   576,  901,  900, 1188,  144,  144,   78,   78,  565,   62,
+ /*  1570 */    62,   79,   79,  323, 1021,  576,  266,   63,   63,  908,
+ /*  1580 */   909, 1589,  542,   80,   80,  576,  371,  541,  123,  568,
+ /*  1590 */   480,    4,  266,  482,  244,  266,  370, 1040,   64,   64,
+ /*  1600 */   576,  466,  576,  121,  121,  571, 1557,  576,  170,  170,
+ /*  1610 */   576,  122,  576,  452,  577,  452,  576,  889, 1028,  576,
+ /*  1620 */   165,  576,  111,  171,  171,   87,   87,  337, 1616,  452,
+ /*  1630 */    65,   65, 1530,   83,   83,  146,  146,  986,  987,   84,
+ /*  1640 */    84,  565,  168,  168,  148,  148, 1092,  347, 1032,  111,
+ /*  1650 */  1028, 1028, 1030, 1031,   35,  542, 1103,  576, 1103,  576,
+ /*  1660 */   543,  123,  568,  504,    4,  263,  576,  361, 1529,  111,
+ /*  1670 */  1040, 1088,  576,  263,  576,  490,  121,  121,  571, 1188,
+ /*  1680 */   142,  142,  169,  169,  122,  576,  452,  577,  452,  162,
+ /*  1690 */   162, 1028,  576,  563,  576,  152,  152,  151,  151,  348,
+ /*  1700 */  1376,  974,  452,  266, 1092,  942, 1032,  125,  149,  149,
+ /*  1710 */   939,  576,  125,  576,  565,  150,  150,   86,   86,  872,
+ /*  1720 */   352,  159,  576, 1028, 1028, 1030, 1031,   35,  542,  941,
+ /*  1730 */   576,  125,  355,  541,   88,   88,   85,   85,  357,  359,
+ /*  1740 */  1324, 1308,  366, 1040,  376,   52,   52,  499, 1389,  121,
+ /*  1750 */   121, 1434, 1188,   58,   58, 1362, 1374,  122, 1439,  452,
+ /*  1760 */   577,  452, 1289,  167, 1028, 1280,  280, 1268, 1267, 1269,
+ /*  1770 */  1609, 1359,  312,  313,   12,  314,  397, 1421,  224, 1416,
+ /*  1780 */   295,  237, 1409,  339,  340, 1426,  301,  345,  484,  228,
+ /*  1790 */  1371, 1307, 1372, 1370, 1425,  404, 1028, 1028, 1030, 1031,
+ /*  1800 */    35, 1601, 1192,  454,  509,  369,  292, 1502,  210, 1501,
+ /*  1810 */  1369,  396,  396,  395,  277,  393,  211,  566,  859, 1612,
+ /*  1820 */  1244,  123,  568,  391,    4, 1188,  223,  270, 1549, 1547,
+ /*  1830 */  1241,  239,  186,  327,  422,   96,  195,  220,  571,  235,
+ /*  1840 */   180,  326,  188,  468,  190, 1507,  191,  192,   92,  193,
+ /*  1850 */   469,   95, 1422,   13,  502,  247, 1430,  109,  199,  402,
+ /*  1860 */   476,  405,  452, 1496, 1428, 1427,   14,  491,  251,  102,
+ /*  1870 */   497, 1518,  241,  281,  565,  253,  203,  354,  500,  254,
+ /*  1880 */   175, 1270,  407,   43,  350,  518, 1327,  436,  255, 1326,
+ /*  1890 */  1325, 1318,  104,  893, 1626,  229,  408,  440, 1625,  441,
+ /*  1900 */   240,  310, 1296, 1040,  311, 1317,  527, 1594, 1297,  121,
+ /*  1910 */   121,  368, 1295, 1624,  268,  269, 1580,  122, 1579,  452,
+ /*  1920 */   577,  452,  374,  444, 1028, 1394, 1393,  140,  553,   90,
+ /*  1930 */   568,   11,    4, 1483,  383,  414,  385,  110,  116,  216,
+ /*  1940 */   320,  567, 1350,  555,   42,  318,  571,  537, 1349,  389,
+ /*  1950 */   390,  579, 1198,  276,  279,  278, 1028, 1028, 1030, 1031,
+ /*  1960 */    35,  580,  415, 1265,  458, 1260,  416,  185, 1534,  172,
+ /*  1970 */   452, 1535,  173,  156,  308,  846, 1533, 1532,  453,  217,
+ /*  1980 */   225,   89,  565,  174,  322, 1188,  226,  236, 1102,  154,
+ /*  1990 */  1100,  330,  176,  187, 1223,  189,  925,  338,  243, 1116,
+ /*  2000 */   246,  194,  177,  178,  425,  427,   98,   99,  196,  100,
+ /*  2010 */   101, 1040,  179, 1119,  248, 1115,  249,  121,  121,   24,
+ /*  2020 */   163,  250,  349, 1108,  266,  122, 1238,  452,  577,  452,
+ /*  2030 */  1192,  454, 1028,  200,  292,  496,  252,  201,  861,  396,
+ /*  2040 */   396,  395,  277,  393,   15,  501,  859,  370,  292,  256,
+ /*  2050 */   202,  554,  505,  396,  396,  395,  277,  393,  103,  239,
+ /*  2060 */   859,  327,   25,   26, 1028, 1028, 1030, 1031,   35,  326,
+ /*  2070 */   362,  510,  891,  239,  365,  327,  513,  904,  105,  309,
+ /*  2080 */   164,  181,   27,  326,  106,  521,  107, 1185, 1069, 1155,
+ /*  2090 */    17, 1154,  284, 1188,  286,  978,  265,  204,  125, 1171,
+ /*  2100 */   241,  230,  972, 1175,   28, 1160,   29, 1179,  175, 1173,
+ /*  2110 */    30,   43,   31, 1178,  241,   32,   41,  549,    8,   33,
+ /*  2120 */   208,  111,  175, 1083, 1070,   43,  113, 1068,  240,  114,
+ /*  2130 */  1072,   34, 1073,  561, 1124,  118,  271,   36,   18, 1194,
+ /*  2140 */  1033,  873,  240,  935,  124,   37,  272,  273, 1617,  572,
+ /*  2150 */   183,  153,  394, 1193, 1256, 1256, 1256, 1256, 1256, 1256,
+ /*  2160 */  1256, 1256, 1256,  414, 1256, 1256, 1256, 1256,  320,  567,
+ /*  2170 */  1256, 1256, 1256, 1256, 1256, 1256, 1256,  414, 1256, 1256,
+ /*  2180 */  1256, 1256,  320,  567, 1256, 1256, 1256, 1256, 1256, 1256,
+ /*  2190 */  1256, 1256,  458, 1256, 1256, 1256, 1256, 1256, 1256, 1256,
+ /*  2200 */  1256, 1256, 1256, 1256, 1256, 1256,  458,
 };
 static const YYCODETYPE yy_lookahead[] = {
- /*     0 */   193,  193,  193,  274,  275,  276,  193,  274,  275,  276,
- /*    10 */   193,  223,  219,  225,  206,  210,  211,  212,  193,   19,
- /*    20 */   219,  233,  216,  216,  217,  216,  217,  193,  295,  216,
- /*    30 */   217,   31,  193,  216,  217,  193,  228,  213,  230,   39,
- /*    40 */   206,  216,  217,   43,   44,   45,   46,   47,   48,   49,
- /*    50 */    50,   51,   52,   53,   54,   55,   56,   57,  193,   19,
- /*    60 */   185,  186,  187,  188,  189,  190,  253,  274,  275,  276,
- /*    70 */   195,  193,  197,  193,  261,  274,  275,  276,  253,  204,
- /*    80 */   238,  204,   81,   43,   44,   45,   46,   47,   48,   49,
- /*    90 */    50,   51,   52,   53,   54,   55,   56,   57,  274,  275,
- /*   100 */   276,  262,  102,  103,  104,  105,  106,  107,  108,  109,
- /*   110 */   110,  111,  112,  113,  239,  240,  239,  240,  210,  211,
- /*   120 */   212,  314,  315,  314,   59,  316,   86,  252,   88,  252,
- /*   130 */    19,  314,  315,  256,  257,  113,   25,   72,  296,  138,
- /*   140 */   139,  266,  102,  103,  104,  105,  106,  107,  108,  109,
- /*   150 */   110,  111,  112,  113,   43,   44,   45,   46,   47,   48,
- /*   160 */    49,   50,   51,   52,   53,   54,   55,   56,   57,   81,
- /*   170 */   292,   59,  292,  298,  108,  109,  110,  111,  112,  113,
- /*   180 */    69,  116,  117,  118,   72,  106,  107,  193,  111,  112,
- /*   190 */   113,   54,   55,   56,   57,   58,  102,  103,  104,  105,
- /*   200 */   106,  107,  108,  109,  110,  111,  112,  113,  120,   25,
- /*   210 */   216,  217,  145,  102,  103,  104,  105,  106,  107,  108,
- /*   220 */   109,  110,  111,  112,  113,  231,  138,  139,  116,  117,
- /*   230 */   118,  164,  153,   19,  155,   54,   55,   56,   57,  102,
- /*   240 */   103,  104,  105,  106,  107,  108,  109,  110,  111,  112,
- /*   250 */   113,  128,  129,   46,   47,   48,   49,   43,   44,   45,
- /*   260 */    46,   47,   48,   49,   50,   51,   52,   53,   54,   55,
- /*   270 */    56,   57,  216,  193,   25,   59,  193,   19,  165,  166,
- /*   280 */   193,   67,   24,  102,  103,  104,  105,  106,  107,  108,
- /*   290 */   109,  110,  111,  112,  113,   73,  216,  217,   59,  216,
- /*   300 */   217,   43,   44,   45,   46,   47,   48,   49,   50,   51,
- /*   310 */    52,   53,   54,   55,   56,   57,  102,  103,  104,  105,
- /*   320 */   106,  107,  108,  109,  110,  111,  112,  113,  121,  145,
- /*   330 */    59,  193,  116,  117,  118,  119,  273,  204,  122,  123,
- /*   340 */   124,   19,   20,  134,   22,  136,  137,   19,  132,  127,
- /*   350 */   128,  129,   24,   22,   23,  116,  117,  118,   36,  193,
- /*   360 */   102,  103,  104,  105,  106,  107,  108,  109,  110,  111,
- /*   370 */   112,  113,  239,  240,  311,  312,  215,  106,  107,  241,
- /*   380 */    19,   59,  216,  217,  223,  252,  115,  116,  117,  118,
- /*   390 */   151,  120,   26,   71,  193,  308,  309,  193,  149,  128,
- /*   400 */   313,  216,  269,   81,   43,   44,   45,   46,   47,   48,
- /*   410 */    49,   50,   51,   52,   53,   54,   55,   56,   57,  253,
- /*   420 */   216,  217,  100,   95,  153,   59,  155,  261,  106,  107,
- /*   430 */    25,  193,  101,  193,  193,  231,  114,   25,  116,  117,
- /*   440 */   118,  113,  304,  121,  193,  204,   59,  119,  120,  121,
- /*   450 */   122,  123,  124,  125,  216,  217,  193,  216,  217,  131,
- /*   460 */   138,  139,  230,  102,  103,  104,  105,  106,  107,  108,
- /*   470 */   109,  110,  111,  112,  113,  153,  154,  155,  156,  157,
- /*   480 */   239,  240,  116,  117,  118,   76,  193,   23,   19,   25,
- /*   490 */    22,  253,   23,  252,  253,  108,   87,  204,   89,  261,
- /*   500 */   198,   92,  261,  116,  117,  118,  193,  306,  307,  216,
- /*   510 */   217,  150,   43,   44,   45,   46,   47,   48,   49,   50,
- /*   520 */    51,   52,   53,   54,   55,   56,   57,   59,  193,  216,
- /*   530 */   217,   19,  239,  240,  283,   23,  106,  107,  108,  109,
- /*   540 */   110,  111,  112,  113,   73,  252,  253,  142,  308,  309,
- /*   550 */   138,  139,   81,  313,  145,   43,   44,   45,   46,   47,
- /*   560 */    48,   49,   50,   51,   52,   53,   54,   55,   56,   57,
- /*   570 */   307,  102,  103,  104,  105,  106,  107,  108,  109,  110,
- /*   580 */   111,  112,  113,  281,  116,  117,  118,  285,   23,  193,
- /*   590 */    25,  119,   59,  193,  122,  123,  124,   59,  127,  203,
- /*   600 */    59,  205,   19,  268,  132,   25,   23,   22,  193,  138,
- /*   610 */   139,  249,  204,  251,  102,  103,  104,  105,  106,  107,
- /*   620 */   108,  109,  110,  111,  112,  113,   43,   44,   45,   46,
- /*   630 */    47,   48,   49,   50,   51,   52,   53,   54,   55,   56,
- /*   640 */    57,   19,   22,   23,   59,   23,   25,  239,  240,  116,
- /*   650 */   117,  118,  193,   11,  116,  117,  118,  116,  117,  118,
- /*   660 */   252,  269,   22,  193,   15,   43,   44,   45,   46,   47,
- /*   670 */    48,   49,   50,   51,   52,   53,   54,   55,   56,   57,
- /*   680 */   273,  143,  193,  118,  143,  102,  103,  104,  105,  106,
- /*   690 */   107,  108,  109,  110,  111,  112,  113,   76,  118,   59,
- /*   700 */   241,  116,  117,  118,  304,  216,  217,  292,  143,   60,
- /*   710 */    89,  241,   19,   92,  193,  193,   23,   22,  311,  312,
- /*   720 */   231,  101,   22,  143,  102,  103,  104,  105,  106,  107,
- /*   730 */   108,  109,  110,  111,  112,  113,   43,   44,   45,   46,
- /*   740 */    47,   48,   49,   50,   51,   52,   53,   54,   55,   56,
- /*   750 */    57,   19,  193,  193,   59,   23,  116,  117,  118,   59,
- /*   760 */   201,   21,  241,  304,  193,  206,  127,  128,  129,  193,
- /*   770 */   128,  129,  235,  236,  304,   43,   44,   45,   46,   47,
- /*   780 */    48,   49,   50,   51,   52,   53,   54,   55,   56,   57,
- /*   790 */    22,  193,  216,  217,  193,  102,  103,  104,  105,  106,
- /*   800 */   107,  108,  109,  110,  111,  112,  113,  231,  193,  193,
- /*   810 */   193,  116,  117,  118,  216,  217,  116,  117,  118,  226,
- /*   820 */    80,  193,   19,  235,  236,  304,   23,  211,  212,  231,
- /*   830 */   204,  216,  217,  205,  102,  103,  104,  105,  106,  107,
- /*   840 */   108,  109,  110,  111,  112,  113,   43,   44,   45,   46,
- /*   850 */    47,   48,   49,   50,   51,   52,   53,   54,   55,   56,
- /*   860 */    57,   19,  193,  123,   76,  239,  240,  193,  253,  239,
- /*   870 */   240,  239,  240,  244,  106,  107,  193,   89,  252,  193,
- /*   880 */    92,   59,  252,  254,  252,   43,   44,   45,   46,   47,
- /*   890 */    48,   49,   50,   51,   52,   53,   54,   55,   56,   57,
- /*   900 */   284,  161,  216,  217,  193,  102,  103,  104,  105,  106,
- /*   910 */   107,  108,  109,  110,  111,  112,  113,  231,  193,  244,
- /*   920 */   187,  188,  189,  190,    7,    8,    9,  309,  195,  254,
- /*   930 */   197,  313,   19,  127,  128,  129,  262,  204,   22,  117,
- /*   940 */    24,  216,  217,  273,  102,  103,  104,  105,  106,  107,
- /*   950 */   108,  109,  110,  111,  112,  113,   43,   44,   45,   46,
- /*   960 */    47,   48,   49,   50,   51,   52,   53,   54,   55,   56,
- /*   970 */    57,  193,  239,  240,  193,   59,   19,  188,  253,  190,
- /*   980 */   193,  311,  312,   16,  195,  252,  197,  193,   19,  301,
- /*   990 */   302,  135,  193,  204,  216,  217,  140,  216,  217,  266,
- /*  1000 */   204,  159,   45,   46,   47,   48,   49,   50,   51,   52,
- /*  1010 */    53,   54,   55,   56,   57,  102,  103,  104,  105,  106,
- /*  1020 */   107,  108,  109,  110,  111,  112,  113,   12,  239,  240,
- /*  1030 */   193,  298,  238,  117,  253,  239,  240,  238,  259,  260,
- /*  1040 */   193,  252,   27,  193,   77,  193,   79,  204,  252,  262,
- /*  1050 */   193,  299,  300,  193,  100,  266,  278,   42,  204,  102,
- /*  1060 */   103,  104,  105,  106,  107,  108,  109,  110,  111,  112,
- /*  1070 */   113,  117,  159,  216,  217,  121,  216,  217,   63,  193,
- /*  1080 */   193,  193,  239,  240,  115,  116,  193,  298,   73,  240,
- /*  1090 */   238,  231,   19,  239,  240,  252,   22,   24,  211,  212,
- /*  1100 */   263,  252,  216,  217,  216,  217,  252,  153,  154,  155,
- /*  1110 */   253,  193,   19,  144,  213,  268,   43,   44,   45,   46,
- /*  1120 */    47,   48,   49,   50,   51,   52,   53,   54,   55,   56,
- /*  1130 */    57,  193,   19,   59,  216,  217,   43,   44,   45,   46,
- /*  1140 */    47,   48,   49,   50,   51,   52,   53,   54,   55,   56,
- /*  1150 */    57,  193,   19,   24,  216,  217,   43,   44,   45,   46,
- /*  1160 */    47,   48,   49,   50,   51,   52,   53,   54,   55,   56,
- /*  1170 */    57,  284,  193,  208,  209,  102,  103,  104,  105,  106,
- /*  1180 */   107,  108,  109,  110,  111,  112,  113,  286,   59,  193,
- /*  1190 */   232,  117,  291,  193,  193,  102,  103,  104,  105,  106,
- /*  1200 */   107,  108,  109,  110,  111,  112,  113,  193,  204,   22,
- /*  1210 */    23,  193,   25,   66,  193,  102,  103,  104,  105,  106,
- /*  1220 */   107,  108,  109,  110,  111,  112,  113,  193,  193,  193,
- /*  1230 */   216,  217,   85,  193,  238,   19,   16,  216,  217,  238,
- /*  1240 */   193,   94,  193,  239,  240,  231,  117,  268,   35,  116,
- /*  1250 */   216,  217,  216,  217,   22,   23,  252,   25,  208,  209,
- /*  1260 */    44,   45,   46,   47,   48,   49,   50,   51,   52,   53,
- /*  1270 */    54,   55,   56,   57,  193,  193,   19,    5,   59,   66,
- /*  1280 */   193,  263,   10,   11,   12,   13,   14,   74,  101,   17,
- /*  1290 */   193,   46,  193,  146,  193,   76,  213,   77,  263,   79,
- /*  1300 */    12,  260,   30,   46,   32,  264,   87,  193,   89,   29,
- /*  1310 */   263,   92,   40,   33,  232,   27,  193,  108,  102,  103,
- /*  1320 */   104,  105,  106,  107,  108,  109,  110,  111,  112,  113,
- /*  1330 */    42,  138,  139,  101,  193,  116,  117,  118,   19,   20,
- /*  1340 */   255,   22,   70,  130,  135,   65,  256,  257,  193,  140,
- /*  1350 */    78,   63,  193,   81,  193,   36,  193,  216,  217,  193,
- /*  1360 */   115,  193,  263,  193,  145,  268,   59,   48,  193,  193,
- /*  1370 */    98,  193,  115,  193,  291,  216,  217,  193,   59,  216,
- /*  1380 */   217,  161,  216,  217,  216,  217,  216,  217,  131,  193,
- /*  1390 */    71,  193,  216,  217,  216,  217,  216,  217,  193,  260,
- /*  1400 */   216,  217,   19,  264,   85,  133,  244,  100,  193,   90,
- /*  1410 */   138,  139,  216,  217,  216,  217,  254,  244,  193,  100,
- /*  1420 */   193,  216,  217,  116,  117,  106,  107,  254,  121,  193,
- /*  1430 */   115,  216,  217,  114,  162,  116,  117,  118,  115,  244,
- /*  1440 */   121,  216,  217,  216,  217,  193,  309,  193,   31,  254,
- /*  1450 */   313,  309,  216,  217,  309,  313,   39,  193,  313,  309,
- /*  1460 */   153,  154,  155,  313,  193,  150,   25,  144,  216,  217,
- /*  1470 */   216,  217,  153,  154,  155,  156,  157,    0,    1,    2,
- /*  1480 */   216,  217,    5,  149,  150,   22,  193,   10,   11,   12,
- /*  1490 */    13,   14,  193,  158,   17,  160,  193,   19,   20,  116,
- /*  1500 */    22,   25,  193,   24,   22,  193,   24,   30,  226,   32,
- /*  1510 */    19,   20,  226,   22,   36,  193,   53,   40,  193,  216,
- /*  1520 */   217,  193,   23,  193,   25,  216,  217,   36,  216,  217,
- /*  1530 */   193,   99,  193,  193,   22,  193,  193,   59,  216,  217,
- /*  1540 */   193,  216,  217,  193,  216,  217,  193,   70,  129,   71,
- /*  1550 */    59,  129,  193,  216,  217,   78,  216,  217,   81,  216,
- /*  1560 */   217,  193,   71,   85,  193,  133,  193,  126,   90,  216,
- /*  1570 */   217,  152,  258,   61,  152,   98,   85,  193,  100,  193,
- /*  1580 */    23,   90,   25,  121,  106,  107,   23,  216,  217,  216,
- /*  1590 */   217,  100,  114,  131,  116,  117,  118,  106,  107,  121,
- /*  1600 */   216,  217,  216,  217,  193,  114,  193,  116,  117,  118,
- /*  1610 */   133,   22,  121,  193,   59,  138,  139,  193,  142,  193,
- /*  1620 */   141,   23,   23,   25,   25,  120,  121,  216,  217,  216,
- /*  1630 */   217,  153,  154,  155,  156,  157,  216,  217,   19,  162,
- /*  1640 */   216,  217,  216,  217,  153,  154,  155,  156,  157,    1,
- /*  1650 */     2,  193,   59,    5,   19,   20,  318,   22,   10,   11,
- /*  1660 */    12,   13,   14,  193,   59,   17,  193,   23,   23,   25,
- /*  1670 */    25,   36,  117,  193,  216,  217,  193,   23,   30,   25,
- /*  1680 */    32,   19,   20,   23,   22,   25,  216,  217,   40,  216,
- /*  1690 */   217,    7,    8,   23,   59,   25,   83,   84,   36,   23,
- /*  1700 */   193,   25,   23,   23,   25,   25,   71,  153,  145,  155,
- /*  1710 */   117,  153,   23,  155,   25,   23,   97,   25,   70,  193,
- /*  1720 */   193,   59,  117,  236,  193,  193,   78,  193,  193,   81,
- /*  1730 */   141,  193,  193,   71,  193,  100,  288,  287,  242,  255,
- /*  1740 */   255,  106,  107,  108,  255,  255,   98,  243,  297,  114,
- /*  1750 */   214,  116,  117,  118,  245,  191,  121,  271,  293,  267,
- /*  1760 */   267,  246,  100,  246,  245,  271,  271,  293,  106,  107,
- /*  1770 */   220,  271,  229,  225,  249,  219,  114,  259,  116,  117,
- /*  1780 */   118,  133,  259,  121,  219,  219,  138,  139,  153,  154,
- /*  1790 */   155,  156,  157,  280,  249,  243,   19,   20,  245,   22,
- /*  1800 */   196,  259,  140,  259,   60,  297,  141,  297,  200,  200,
- /*  1810 */   162,   38,  200,   36,  294,  153,  154,  155,  156,  157,
- /*  1820 */   151,  150,  294,  283,   22,   43,  234,   18,  237,  200,
- /*  1830 */   270,  272,  237,  237,  237,   18,   59,  199,  270,  149,
- /*  1840 */   246,  272,  272,  200,  234,  234,  246,  246,   71,  246,
- /*  1850 */   199,  158,  290,   62,   22,  200,   19,   20,  199,   22,
- /*  1860 */   289,  221,  221,  200,  200,  199,  199,  115,  218,   64,
- /*  1870 */   218,  218,   22,   36,  227,  126,  227,  100,  165,  221,
- /*  1880 */   224,  224,   24,  106,  107,  312,  218,  305,  113,  282,
- /*  1890 */    91,  114,  220,  116,  117,  118,   59,  282,  121,  218,
- /*  1900 */   218,  218,  200,  317,  317,   82,  221,  265,   71,  148,
- /*  1910 */   145,  265,   22,  277,  200,  158,  279,  140,  147,   25,
- /*  1920 */   146,  202,  248,  250,  249,  247,   13,  250,  194,  194,
- /*  1930 */   153,  154,  155,  156,  157,    6,  303,  100,  192,  192,
- /*  1940 */   246,  213,  192,  106,  107,  207,  213,  207,  222,  213,
- /*  1950 */   213,  114,  222,  116,  117,  118,  214,  214,  121,    4,
- /*  1960 */   207,  213,    3,   22,  303,   15,  163,   16,   23,   23,
- /*  1970 */   139,  151,  130,   25,   20,  142,   24,   16,  144,    1,
- /*  1980 */   142,  130,  130,   61,   37,   53,  300,  151,   53,   53,
- /*  1990 */   153,  154,  155,  156,  157,   53,  130,  116,   34,    1,
- /*  2000 */   141,    5,   22,  115,  161,   68,   25,   68,   75,   41,
- /*  2010 */   141,  115,   24,   20,   19,  131,  125,   23,   28,   22,
- /*  2020 */    67,   22,   22,   22,   67,   59,   24,   96,   22,   67,
- /*  2030 */    23,  149,   22,   25,   23,   23,   23,   22,   34,  141,
- /*  2040 */    37,   97,   23,   23,  116,   22,  143,   25,   34,   75,
- /*  2050 */    34,   34,   34,   88,   75,   34,   86,   23,   22,   34,
- /*  2060 */    93,   24,   34,   25,   25,  142,  142,   23,   44,   23,
- /*  2070 */    23,   23,   23,   11,   23,   25,   22,   22,   22,  141,
- /*  2080 */    23,   23,   22,   22,   25,   15,    1,   23,   25,    1,
- /*  2090 */   141,  135,  319,  319,  319,  319,  319,  319,  319,  141,
- /*  2100 */   319,  319,  319,  319,  319,  319,  319,  319,  319,  319,
- /*  2110 */   319,  319,  319,  319,  319,  319,  319,  319,  319,  319,
- /*  2120 */   319,  319,  319,  319,  319,  319,  319,  319,  319,  319,
- /*  2130 */   319,  319,  319,  319,  319,  319,  319,  319,  319,  319,
- /*  2140 */   319,  319,  319,  319,  319,  319,  319,  319,  319,  319,
- /*  2150 */   319,  319,  319,  319,  319,  319,  319,  319,  319,  319,
- /*  2160 */   319,  319,  319,  319,  319,  319,  319,  319,  319,  319,
- /*  2170 */   319,  319,  319,  319,  319,  319,  319,  319,  319,  319,
- /*  2180 */   319,  319,  319,  319,  319,  319,  319,  319,  319,  319,
- /*  2190 */   319,  319,  319,  319,  319,  319,  319,  319,  319,  319,
- /*  2200 */   319,  319,  319,  319,  319,  319,  319,  319,  319,  319,
- /*  2210 */   319,  319,  319,  319,  319,  319,  319,  319,  319,  319,
- /*  2220 */   319,  319,  319,  319,  319,  319,  319,  319,  319,  319,
- /*  2230 */   319,  319,  319,  319,  319,  319,  319,  319,  319,  319,
- /*  2240 */   319,  319,  319,  319,  319,  319,  319,  319,  319,  319,
- /*  2250 */   319,  319,  319,  319,  319,  319,  319,  319,  319,  319,
- /*  2260 */   319,  319,  319,  319,  319,  319,  319,  319,  319,  319,
- /*  2270 */   319,  319,  319,  319,  319,  319,  319,  319,  319,  319,
- /*  2280 */   319,  319,  319,  319,  319,
+ /*     0 */   276,  277,  278,  240,  241,  224,  194,  226,  194,  240,
+ /*    10 */   241,  194,  216,  220,  194,  234,  253,  194,  255,   19,
+ /*    20 */   224,  297,  253,  194,  255,  205,  212,  213,  205,  217,
+ /*    30 */   218,   31,  205,  194,  217,  218,  194,  217,  218,   39,
+ /*    40 */   217,  218,  312,   43,   44,   45,  316,   47,   48,   49,
+ /*    50 */    50,   51,   52,   53,   54,   55,   56,   57,   58,   19,
+ /*    60 */   240,  241,  194,  240,  241,  194,  254,  240,  241,  276,
+ /*    70 */   277,  278,  233,  253,  254,  255,  253,  254,  255,  217,
+ /*    80 */   253,  239,  255,   43,   44,   45,  263,   47,   48,   49,
+ /*    90 */    50,   51,   52,   53,   54,   55,   56,   57,   58,  270,
+ /*   100 */   286,   22,   23,  103,  104,  105,  106,  107,  108,  109,
+ /*   110 */   110,  111,  112,  113,  114,   82,   47,   48,   49,   50,
+ /*   120 */   186,  187,  188,  189,  190,  191,  189,   87,  191,   89,
+ /*   130 */   196,   19,  198,  196,  317,  198,  319,   25,  194,  205,
+ /*   140 */   298,  270,  205,  103,  104,  105,  106,  107,  108,  109,
+ /*   150 */   110,  111,  112,  113,  114,   43,   44,   45,   11,   47,
+ /*   160 */    48,   49,   50,   51,   52,   53,   54,   55,   56,   57,
+ /*   170 */    58,   60,  139,  140,  240,  241,  214,  240,  241,  311,
+ /*   180 */   312,  102,   70,  239,  316,  194,   19,  253,   77,  255,
+ /*   190 */   253,  122,  255,   55,   56,   57,   58,   59,  207,   88,
+ /*   200 */   194,   90,  268,  194,   93,  268,  107,  108,  109,  110,
+ /*   210 */   111,  112,  113,  114,   47,  103,  104,  105,  106,  107,
+ /*   220 */   108,  109,  110,  111,  112,  113,  114,  114,  117,  118,
+ /*   230 */   119,  276,  277,  278,  300,   19,  194,  300,  276,  277,
+ /*   240 */   278,  103,  104,  105,  106,  107,  108,  109,  110,  111,
+ /*   250 */   112,  113,  114,   55,   56,   57,   58,  146,  194,   43,
+ /*   260 */    44,   45,   47,   47,   48,   49,   50,   51,   52,   53,
+ /*   270 */    54,   55,   56,   57,   58,   82,  129,  130,   60,  129,
+ /*   280 */   130,  217,  218,  116,   68,   25,  103,  104,  105,  106,
+ /*   290 */   107,  108,  109,  110,  111,  112,  113,  114,   23,  132,
+ /*   300 */   294,  103,  104,  105,  106,  107,  108,  109,  110,  111,
+ /*   310 */   112,  113,  114,  217,  121,  306,  194,  308,   26,  103,
+ /*   320 */   104,  105,  106,  107,  108,  109,  110,  111,  112,  113,
+ /*   330 */   114,  116,  139,  140,  217,  117,  118,  119,  120,   19,
+ /*   340 */   194,  123,  124,  125,   24,  109,  110,  111,  112,  113,
+ /*   350 */   114,  133,   60,  311,  312,  250,  194,  252,  316,   19,
+ /*   360 */   194,  166,  167,   43,   44,   45,  205,   47,   48,   49,
+ /*   370 */    50,   51,   52,   53,   54,   55,   56,   57,   58,  217,
+ /*   380 */   218,  317,  318,   43,   44,   45,  264,   47,   48,   49,
+ /*   390 */    50,   51,   52,   53,   54,   55,   56,   57,   58,  139,
+ /*   400 */   140,  240,  241,  139,  140,  188,  189,  190,  191,  117,
+ /*   410 */   118,  119,  231,  196,  253,  198,  255,  194,  194,  258,
+ /*   420 */   259,  146,  205,  103,  104,  105,  106,  107,  108,  109,
+ /*   430 */   110,  111,  112,  113,  114,  109,  212,  213,  236,  237,
+ /*   440 */   217,  218,  194,  103,  104,  105,  106,  107,  108,  109,
+ /*   450 */   110,  111,  112,  113,  114,  194,  120,  240,  241,  123,
+ /*   460 */   124,  125,  136,  194,   19,   74,   60,  141,   23,  133,
+ /*   470 */   253,  194,  255,   82,  194,  309,  310,  254,   29,  317,
+ /*   480 */   318,  194,   33,   22,  199,  268,  263,  239,   43,   44,
+ /*   490 */    45,  151,   47,   48,   49,   50,   51,   52,   53,   54,
+ /*   500 */    55,   56,   57,   58,  217,  218,  194,   60,   19,  146,
+ /*   510 */   286,  242,   23,  107,  108,   66,  204,  300,  206,  128,
+ /*   520 */    73,   60,  116,  117,  118,  119,  265,  121,  165,   60,
+ /*   530 */   139,  140,   43,   44,   45,  129,   47,   48,   49,   50,
+ /*   540 */    51,   52,   53,   54,   55,   56,   57,   58,  103,  104,
+ /*   550 */   105,  106,  107,  108,  109,  110,  111,  112,  113,  114,
+ /*   560 */   154,  194,  156,  194,  117,  118,  119,  280,  283,  205,
+ /*   570 */   101,  220,  287,   19,   20,  306,   22,  308,  117,  118,
+ /*   580 */   119,  211,  212,  213,  217,  218,  117,  118,  236,  237,
+ /*   590 */    36,  122,  103,  104,  105,  106,  107,  108,  109,  110,
+ /*   600 */   111,  112,  113,  114,  240,  241,  194,   60,  194,  194,
+ /*   610 */   194,  194,   19,  194,   60,  194,   23,  253,  206,  255,
+ /*   620 */    73,  254,   19,  154,  155,  156,   72,  276,  277,  278,
+ /*   630 */   263,  217,  218,  217,  218,  271,   43,   44,   45,  271,
+ /*   640 */    47,   48,   49,   50,   51,   52,   53,   54,   55,   56,
+ /*   650 */    57,   58,  183,  194,  285,  101,   19,  214,   60,  242,
+ /*   660 */    23,  107,  108,  109,  117,  118,  119,   16,  254,  115,
+ /*   670 */   254,  117,  118,  119,  194,   60,  122,  263,  205,  264,
+ /*   680 */    43,   44,   45,  264,   47,   48,   49,   50,   51,   52,
+ /*   690 */    53,   54,   55,   56,   57,   58,  103,  104,  105,  106,
+ /*   700 */   107,  108,  109,  110,  111,  112,  113,  114,  154,  155,
+ /*   710 */   156,  157,  158,  240,  241,  117,  118,  119,  101,  205,
+ /*   720 */   117,   19,   20,  306,   22,  308,  253,   74,  255,   78,
+ /*   730 */   205,   80,  117,  118,  119,  118,  293,  183,   36,  122,
+ /*   740 */   103,  104,  105,  106,  107,  108,  109,  110,  111,  112,
+ /*   750 */   113,  114,  194,  294,  240,  241,  211,  212,  213,  144,
+ /*   760 */    19,   23,   60,   25,   23,  240,  241,  253,  245,  255,
+ /*   770 */    15,  154,  155,  156,   72,  217,  218,  194,  253,  256,
+ /*   780 */   255,  128,  129,  130,   43,   44,   45,   22,   47,   48,
+ /*   790 */    49,   50,   51,   52,   53,   54,   55,   56,   57,   58,
+ /*   800 */   183,   19,   77,  101,   19,  128,  129,  130,   23,  107,
+ /*   810 */   108,   60,  254,   88,   21,   90,   61,  115,   93,  117,
+ /*   820 */   118,  119,  239,   22,  122,   60,  194,  205,   43,   44,
+ /*   830 */    45,  205,   47,   48,   49,   50,   51,   52,   53,   54,
+ /*   840 */    55,   56,   57,   58,  103,  104,  105,  106,  107,  108,
+ /*   850 */   109,  110,  111,  112,  113,  114,  154,  155,  156,  157,
+ /*   860 */   158,   60,  240,  241,   60,  116,  240,  241,  117,  118,
+ /*   870 */   119,  146,  194,   19,   81,  253,  275,  255,   24,  253,
+ /*   880 */    98,  255,  117,  118,  119,  183,   22,  194,  103,  104,
+ /*   890 */   105,  106,  107,  108,  109,  110,  111,  112,  113,  114,
+ /*   900 */   151,  194,  270,  152,   22,   23,  194,   25,   19,  202,
+ /*   910 */   217,  218,   23,  109,  207,  314,  315,  124,  117,  118,
+ /*   920 */   119,  117,  118,  119,   60,  232,   22,   23,   19,   25,
+ /*   930 */   303,  304,   43,   44,   45,   22,   47,   48,   49,   50,
+ /*   940 */    51,   52,   53,   54,   55,   56,   57,   58,  270,  227,
+ /*   950 */    96,   60,   43,   44,   45,  162,   47,   48,   49,   50,
+ /*   960 */    51,   52,   53,   54,   55,   56,   57,   58,  114,  112,
+ /*   970 */   113,  114,  194,   60,  120,  121,  122,  123,  124,  125,
+ /*   980 */   126,  117,  118,  119,  102,   25,  132,  107,  108,  194,
+ /*   990 */   194,  227,  103,  104,  105,  106,  107,  108,  109,  110,
+ /*  1000 */   111,  112,  113,  114,  194,  194,  102,  194,  117,  118,
+ /*  1010 */   119,  233,  103,  104,  105,  106,  107,  108,  109,  110,
+ /*  1020 */   111,  112,  113,  114,  194,  194,   19,  194,  217,  218,
+ /*  1030 */   117,  118,  119,  241,  154,  144,  156,  135,  242,  137,
+ /*  1040 */   138,  130,   19,  232,  194,  253,   23,  255,  217,  218,
+ /*  1050 */   217,  218,  242,   16,    7,    8,    9,   25,  261,  262,
+ /*  1060 */   265,  194,   19,  232,  153,  232,   43,   44,   45,  160,
+ /*  1070 */    47,   48,   49,   50,   51,   52,   53,   54,   55,   56,
+ /*  1080 */    57,   58,  194,  227,  217,  218,   43,   44,   45,  194,
+ /*  1090 */    47,   48,   49,   50,   51,   52,   53,   54,   55,   56,
+ /*  1100 */    57,   58,  306,  143,  308,  217,  218,  294,   12,   77,
+ /*  1110 */    22,   23,  217,  218,  194,   78,  306,   80,  308,  194,
+ /*  1120 */   232,  254,   90,   27,  117,   93,  103,  104,  105,  106,
+ /*  1130 */   107,  108,  109,  110,  111,  112,  113,  114,   42,  194,
+ /*  1140 */    35,  194,  217,  218,  214,  194,  103,  104,  105,  106,
+ /*  1150 */   107,  108,  109,  110,  111,  112,  113,  114,  194,  239,
+ /*  1160 */    64,  194,  217,  218,  217,  218,  209,  210,  217,  218,
+ /*  1170 */    74,  207,   67,   22,  194,   77,   19,  232,  245,  232,
+ /*  1180 */    75,   24,  312,  232,  217,  218,  316,   25,   90,  256,
+ /*  1190 */   102,   93,  159,  229,  161,  231,   19,  217,  218,  162,
+ /*  1200 */    43,   44,   45,  160,   47,   48,   49,   50,   51,   52,
+ /*  1210 */    53,   54,   55,   56,   57,   58,   19,   23,  288,   25,
+ /*  1220 */    43,   44,   45,  293,   47,   48,   49,   50,   51,   52,
+ /*  1230 */    53,   54,   55,   56,   57,   58,  131,   22,  275,   24,
+ /*  1240 */    43,   44,   45,  194,   47,   48,   49,   50,   51,   52,
+ /*  1250 */    53,   54,   55,   56,   57,   58,  194,  194,  107,  108,
+ /*  1260 */   103,  104,  105,  106,  107,  108,  109,  110,  111,  112,
+ /*  1270 */   113,  114,  194,   25,  194,   60,  194,  314,  315,  194,
+ /*  1280 */   103,  104,  105,  106,  107,  108,  109,  110,  111,  112,
+ /*  1290 */   113,  114,   19,  194,  194,  217,  218,  217,  218,   25,
+ /*  1300 */   103,  104,  105,  106,  107,  108,  109,  110,  111,  112,
+ /*  1310 */   113,  114,  150,  119,  265,  312,   67,  217,  218,  316,
+ /*  1320 */    19,  239,  194,  194,  128,  129,  130,  265,  265,  209,
+ /*  1330 */   210,   31,  254,  118,  254,   86,   60,  194,  144,   39,
+ /*  1340 */    19,  130,  275,  312,   95,   44,   45,  316,   47,   48,
+ /*  1350 */    49,   50,   51,   52,   53,   54,   55,   56,   57,   58,
+ /*  1360 */   217,  218,   24,  194,  153,   12,   45,  119,   47,   48,
+ /*  1370 */    49,   50,   51,   52,   53,   54,   55,   56,   57,   58,
+ /*  1380 */    27,  314,  315,   22,  312,   24,  217,  218,  316,  116,
+ /*  1390 */   117,   22,  144,   25,  118,   42,  147,  194,   60,   19,
+ /*  1400 */    20,  127,   22,  194,  103,  104,  105,  106,  107,  108,
+ /*  1410 */   109,  110,  111,  112,  113,  114,   36,   64,  145,  194,
+ /*  1420 */   217,  218,  194,   54,  103,  104,  105,  106,  107,  108,
+ /*  1430 */   109,  110,  111,  112,  113,  114,  194,   22,  310,   25,
+ /*  1440 */    60,  194,  217,  218,  194,  217,  218,  194,  260,  194,
+ /*  1450 */   301,  302,   72,  262,  262,  194,  118,  266,  266,  217,
+ /*  1460 */   218,  194,   82,  245,  217,  218,  194,  217,  218,  194,
+ /*  1470 */   217,  218,  217,  218,  256,   60,   24,  194,  217,  218,
+ /*  1480 */   194,  101,  194,  245,  217,  218,  194,  107,  108,  217,
+ /*  1490 */   218,   22,  217,  218,  256,  115,  245,  117,  118,  119,
+ /*  1500 */   217,  218,  122,  217,  218,  217,  218,  256,   22,  217,
+ /*  1510 */   218,  116,  258,  259,  146,   19,   20,  194,   22,  139,
+ /*  1520 */   140,  150,  151,  136,   23,  194,   25,  194,  141,  194,
+ /*  1530 */   194,   62,   36,  118,  154,  155,  156,  157,  158,  100,
+ /*  1540 */   145,  194,  154,  194,  156,   49,  194,   23,  194,   25,
+ /*  1550 */   217,  218,  217,  218,  194,  257,   60,  143,  194,   60,
+ /*  1560 */   194,  121,  122,  183,  217,  218,  217,  218,   72,  217,
+ /*  1570 */   218,  217,  218,  134,   23,  194,   25,  217,  218,    7,
+ /*  1580 */     8,  321,   86,  217,  218,  194,  122,   91,   19,   20,
+ /*  1590 */    23,   22,   25,   23,  142,   25,  132,  101,  217,  218,
+ /*  1600 */   194,  194,  194,  107,  108,   36,  194,  194,  217,  218,
+ /*  1610 */   194,  115,  194,  117,  118,  119,  194,  118,  122,  194,
+ /*  1620 */    23,  194,   25,  217,  218,  217,  218,  194,  142,   60,
+ /*  1630 */   217,  218,  194,  217,  218,  217,  218,   84,   85,  217,
+ /*  1640 */   218,   72,  217,  218,  217,  218,   60,   23,   60,   25,
+ /*  1650 */   154,  155,  156,  157,  158,   86,  154,  194,  156,  194,
+ /*  1660 */    91,   19,   20,   23,   22,   25,  194,   23,  194,   25,
+ /*  1670 */   101,   23,  194,   25,  194,  194,  107,  108,   36,  183,
+ /*  1680 */   217,  218,  217,  218,  115,  194,  117,  118,  119,  217,
+ /*  1690 */   218,  122,  194,  237,  194,  217,  218,  217,  218,  194,
+ /*  1700 */   194,   23,   60,   25,  118,   23,  118,   25,  217,  218,
+ /*  1710 */    23,  194,   25,  194,   72,  217,  218,  217,  218,   23,
+ /*  1720 */   194,   25,  194,  154,  155,  156,  157,  158,   86,   23,
+ /*  1730 */   194,   25,  194,   91,  217,  218,  217,  218,  194,  194,
+ /*  1740 */   194,  194,  194,  101,  194,  217,  218,  290,  194,  107,
+ /*  1750 */   108,  194,  183,  217,  218,  194,  194,  115,  194,  117,
+ /*  1760 */   118,  119,  194,  243,  122,  194,  289,  194,  194,  194,
+ /*  1770 */   194,  257,  257,  257,  244,  257,  192,  273,  215,  269,
+ /*  1780 */   246,  299,  269,  295,  247,  273,  247,  246,  295,  230,
+ /*  1790 */   261,  226,  261,  261,  273,  273,  154,  155,  156,  157,
+ /*  1800 */   158,    0,    1,    2,  221,  220,    5,  220,  250,  220,
+ /*  1810 */   261,   10,   11,   12,   13,   14,  250,  282,   17,  197,
+ /*  1820 */    61,   19,   20,  246,   22,  183,  244,  142,  201,  201,
+ /*  1830 */    38,   30,  299,   32,  201,  152,   22,  151,   36,  299,
+ /*  1840 */    43,   40,  235,   18,  238,  285,  238,  238,  296,  238,
+ /*  1850 */   201,  296,  274,  272,   18,  200,  235,  150,  235,  247,
+ /*  1860 */   247,  247,   60,  247,  274,  274,  272,  201,  200,  159,
+ /*  1870 */    63,  292,   71,  201,   72,  200,   22,  201,  222,  200,
+ /*  1880 */    79,  201,  222,   82,  291,  116,  219,   65,  200,  219,
+ /*  1890 */   219,  228,   22,  127,  225,  166,  222,   24,  225,  114,
+ /*  1900 */    99,  284,  221,  101,  284,  228,  307,  315,  219,  107,
+ /*  1910 */   108,  219,  219,  219,  201,   92,  320,  115,  320,  117,
+ /*  1920 */   118,  119,  222,   83,  122,  267,  267,  149,  146,   19,
+ /*  1930 */    20,   22,   22,  279,  250,  134,  201,  148,  159,  249,
+ /*  1940 */   139,  140,  251,  141,   25,  281,   36,  147,  251,  248,
+ /*  1950 */   247,  203,   13,  195,    6,  195,  154,  155,  156,  157,
+ /*  1960 */   158,  193,  305,  193,  163,  193,  305,  302,  214,  208,
+ /*  1970 */    60,  214,  208,  223,  223,    4,  214,  214,    3,   22,
+ /*  1980 */   215,  214,   72,  208,  164,  183,  215,   15,   23,   16,
+ /*  1990 */    23,  140,  131,  152,   25,  143,   20,   16,   24,    1,
+ /*  2000 */   145,  143,  131,  131,   62,   37,   54,   54,  152,   54,
+ /*  2010 */    54,  101,  131,  117,   34,    1,  142,  107,  108,   22,
+ /*  2020 */     5,  116,  162,   69,   25,  115,   76,  117,  118,  119,
+ /*  2030 */     1,    2,  122,   69,    5,   41,  142,  116,   20,   10,
+ /*  2040 */    11,   12,   13,   14,   24,   19,   17,  132,    5,  126,
+ /*  2050 */    22,  141,   68,   10,   11,   12,   13,   14,   22,   30,
+ /*  2060 */    17,   32,   22,   22,  154,  155,  156,  157,  158,   40,
+ /*  2070 */    23,   68,   60,   30,   24,   32,   97,   28,   22,   68,
+ /*  2080 */    23,   37,   34,   40,  150,   22,   25,   23,   23,   23,
+ /*  2090 */    22,   98,   23,  183,   23,  117,   34,   22,   25,   89,
+ /*  2100 */    71,  142,  144,   76,   34,   23,   34,   76,   79,   87,
+ /*  2110 */    34,   82,   34,   94,   71,   34,   22,   24,   44,   34,
+ /*  2120 */    25,   25,   79,   23,   23,   82,  143,   23,   99,  143,
+ /*  2130 */    23,   22,   11,   25,   23,   25,   22,   22,   22,    1,
+ /*  2140 */    23,   23,   99,  136,   22,   22,  142,  142,  142,   25,
+ /*  2150 */    25,   23,   15,    1,  322,  322,  322,  322,  322,  322,
+ /*  2160 */   322,  322,  322,  134,  322,  322,  322,  322,  139,  140,
+ /*  2170 */   322,  322,  322,  322,  322,  322,  322,  134,  322,  322,
+ /*  2180 */   322,  322,  139,  140,  322,  322,  322,  322,  322,  322,
+ /*  2190 */   322,  322,  163,  322,  322,  322,  322,  322,  322,  322,
+ /*  2200 */   322,  322,  322,  322,  322,  322,  163,  322,  322,  322,
+ /*  2210 */   322,  322,  322,  322,  322,  322,  322,  322,  322,  322,
+ /*  2220 */   322,  322,  322,  322,  322,  322,  322,  322,  322,  322,
+ /*  2230 */   322,  322,  322,  322,  322,  322,  322,  322,  322,  322,
+ /*  2240 */   322,  322,  322,  322,  322,  322,  322,  322,  322,  322,
+ /*  2250 */   322,  322,  322,  322,  322,  322,  322,  322,  322,  322,
+ /*  2260 */   322,  322,  322,  322,  322,  322,  322,  322,  322,  322,
+ /*  2270 */   322,  322,  322,  322,  322,  322,  322,  322,  322,  322,
+ /*  2280 */   322,  322,  322,  322,  322,  322,  322,  322,  322,  322,
+ /*  2290 */   322,  322,  322,  322,  322,  322,  322,  322,  322,  322,
+ /*  2300 */   322,  322,  322,  322,  322,  322,  322,  322,  322,  322,
+ /*  2310 */   322,  322,  322,  322,  322,  322,  322,  322,  322,  322,
+ /*  2320 */   322,  322,  322,  322,  322,  322,  322,  322,  322,  322,
+ /*  2330 */   322,  322,  322,  322,  322,  322,  322,  322,  322,  322,
+ /*  2340 */   186,  186,  186,  186,  186,  186,  186,  186,  186,  186,
+ /*  2350 */   186,  186,  186,  186,  186,  186,  186,  186,  186,  186,
+ /*  2360 */   186,  186,  186,  186,  186,  186,  186,  186,  186,  186,
+ /*  2370 */   186,  186,  186,  186,  186,  186,  186,  186,  186,  186,
+ /*  2380 */   186,  186,  186,  186,  186,  186,  186,  186,  186,  186,
+ /*  2390 */   186,  186,  186,
 };
-#define YY_SHIFT_COUNT    (578)
+#define YY_SHIFT_COUNT    (582)
 #define YY_SHIFT_MIN      (0)
-#define YY_SHIFT_MAX      (2088)
+#define YY_SHIFT_MAX      (2152)
 static const unsigned short int yy_shift_ofst[] = {
- /*     0 */  1648, 1477, 1272,  322,  322,    1, 1319, 1478, 1491, 1837,
- /*    10 */  1837, 1837,  471,    0,    0,  214, 1093, 1837, 1837, 1837,
- /*    20 */  1837, 1837, 1837, 1837, 1837, 1837, 1837, 1837, 1837, 1837,
- /*    30 */  1837,  271,  271, 1219, 1219,  216,   88,    1,    1,    1,
- /*    40 */     1,    1,   40,  111,  258,  361,  469,  512,  583,  622,
- /*    50 */   693,  732,  803,  842,  913, 1073, 1093, 1093, 1093, 1093,
- /*    60 */  1093, 1093, 1093, 1093, 1093, 1093, 1093, 1093, 1093, 1093,
- /*    70 */  1093, 1093, 1093, 1093, 1113, 1093, 1216,  957,  957, 1635,
- /*    80 */  1662, 1777, 1837, 1837, 1837, 1837, 1837, 1837, 1837, 1837,
- /*    90 */  1837, 1837, 1837, 1837, 1837, 1837, 1837, 1837, 1837, 1837,
- /*   100 */  1837, 1837, 1837, 1837, 1837, 1837, 1837, 1837, 1837, 1837,
- /*   110 */  1837, 1837, 1837, 1837, 1837, 1837, 1837, 1837, 1837, 1837,
- /*   120 */  1837, 1837, 1837, 1837, 1837, 1837, 1837, 1837, 1837, 1837,
- /*   130 */  1837,  137,  181,  181,  181,  181,  181,  181,  181,   94,
- /*   140 */   430,   66,   65,  112,  366,  533,  533,  740, 1257,  533,
- /*   150 */   533,   79,   79,  533,  412,  412,  412,   77,  412,  123,
- /*   160 */   113,  113,  113,   22,   22, 2100, 2100,  328,  328,  328,
- /*   170 */   239,  468,  468,  468,  468, 1015, 1015,  409,  366, 1187,
- /*   180 */  1232,  533,  533,  533,  533,  533,  533,  533,  533,  533,
- /*   190 */   533,  533,  533,  533,  533,  533,  533,  533,  533,  533,
- /*   200 */   533,  969,  621,  621,  533,  642,  788,  788, 1133, 1133,
- /*   210 */   822,  822,   67, 1193, 2100, 2100, 2100, 2100, 2100, 2100,
- /*   220 */  2100, 1307,  954,  954,  585,  472,  640,  387,  695,  538,
- /*   230 */   541,  700,  533,  533,  533,  533,  533,  533,  533,  533,
- /*   240 */   533,  533,  222,  533,  533,  533,  533,  533,  533,  533,
- /*   250 */   533,  533,  533,  533,  533, 1213, 1213, 1213,  533,  533,
- /*   260 */   533,  565,  533,  533,  533,  916, 1147,  533,  533, 1288,
- /*   270 */   533,  533,  533,  533,  533,  533,  533,  533,  639, 1280,
- /*   280 */   209, 1129, 1129, 1129, 1129,  580,  209,  209, 1209,  768,
- /*   290 */   917,  649, 1315, 1334,  405, 1334, 1383,  249, 1315, 1315,
- /*   300 */   249, 1315,  405, 1383, 1441,  464, 1245, 1417, 1417, 1417,
- /*   310 */  1323, 1323, 1323, 1323,  184,  184, 1335, 1476,  856, 1482,
- /*   320 */  1744, 1744, 1665, 1665, 1773, 1773, 1665, 1669, 1671, 1802,
- /*   330 */  1782, 1809, 1809, 1809, 1809, 1665, 1817, 1690, 1671, 1671,
- /*   340 */  1690, 1802, 1782, 1690, 1782, 1690, 1665, 1817, 1693, 1791,
- /*   350 */  1665, 1817, 1832, 1665, 1817, 1665, 1817, 1832, 1752, 1752,
- /*   360 */  1752, 1805, 1850, 1850, 1832, 1752, 1749, 1752, 1805, 1752,
- /*   370 */  1752, 1713, 1858, 1775, 1775, 1832, 1665, 1799, 1799, 1823,
- /*   380 */  1823, 1761, 1765, 1890, 1665, 1757, 1761, 1771, 1774, 1690,
- /*   390 */  1894, 1913, 1913, 1929, 1929, 1929, 2100, 2100, 2100, 2100,
- /*   400 */  2100, 2100, 2100, 2100, 2100, 2100, 2100, 2100, 2100, 2100,
- /*   410 */  2100,  207, 1220,  331,  620,  967,  806, 1074, 1499, 1432,
- /*   420 */  1463, 1479, 1419, 1422, 1557, 1512, 1598, 1599, 1644, 1645,
- /*   430 */  1654, 1660, 1555, 1505, 1684, 1462, 1670, 1563, 1619, 1593,
- /*   440 */  1676, 1679, 1613, 1680, 1554, 1558, 1689, 1692, 1605, 1589,
- /*   450 */  1955, 1959, 1941, 1803, 1950, 1951, 1945, 1946, 1831, 1820,
- /*   460 */  1842, 1948, 1948, 1952, 1833, 1954, 1834, 1961, 1978, 1838,
- /*   470 */  1851, 1948, 1852, 1922, 1947, 1948, 1836, 1932, 1935, 1936,
- /*   480 */  1942, 1866, 1881, 1964, 1859, 1998, 1996, 1980, 1888, 1843,
- /*   490 */  1937, 1981, 1939, 1933, 1968, 1869, 1896, 1988, 1993, 1995,
- /*   500 */  1884, 1891, 1997, 1953, 1999, 2000, 1994, 2001, 1957, 1966,
- /*   510 */  2002, 1931, 1990, 2006, 1962, 2003, 2007, 2004, 1882, 2010,
- /*   520 */  2011, 2012, 2008, 2013, 2015, 1944, 1898, 2019, 2020, 1928,
- /*   530 */  2014, 2023, 1903, 2022, 2016, 2017, 2018, 2021, 1965, 1974,
- /*   540 */  1970, 2024, 1979, 1967, 2025, 2034, 2036, 2037, 2038, 2039,
- /*   550 */  2028, 1923, 1924, 2044, 2022, 2046, 2047, 2048, 2049, 2050,
- /*   560 */  2051, 2054, 2062, 2055, 2056, 2057, 2058, 2060, 2061, 2059,
- /*   570 */  1956, 1938, 1949, 1958, 2063, 2064, 2070, 2085, 2088,
+ /*     0 */  2029, 1801, 2043, 1380, 1380,   33,  391, 1496, 1569, 1642,
+ /*    10 */   702,  702,  702,  193,   33,   33,   33,   33,   33,    0,
+ /*    20 */     0,  216, 1177,  702,  702,  702,  702,  702,  702,  702,
+ /*    30 */   702,  702,  702,  702,  702,  702,  702,  702,  406,  406,
+ /*    40 */   111,  111,  218,  447,  547,  598,  598,  260,  260,  260,
+ /*    50 */   260,   40,  112,  320,  340,  445,  489,  593,  637,  741,
+ /*    60 */   785,  889,  909, 1023, 1043, 1157, 1177, 1177, 1177, 1177,
+ /*    70 */  1177, 1177, 1177, 1177, 1177, 1177, 1177, 1177, 1177, 1177,
+ /*    80 */  1177, 1177, 1177, 1177, 1197, 1177, 1301, 1321, 1321,  554,
+ /*    90 */  1802, 1910,  702,  702,  702,  702,  702,  702,  702,  702,
+ /*   100 */   702,  702,  702,  702,  702,  702,  702,  702,  702,  702,
+ /*   110 */   702,  702,  702,  702,  702,  702,  702,  702,  702,  702,
+ /*   120 */   702,  702,  702,  702,  702,  702,  702,  702,  702,  702,
+ /*   130 */   702,  702,  702,  702,  702,  702,  702,  702,  702,  702,
+ /*   140 */   702,  702,  138,  198,  198,  198,  198,  198,  198,  198,
+ /*   150 */   183,   99,  236,  292,  598,  793,  167,  598,  598,  880,
+ /*   160 */   880,  598,  857,  150,  195,  195,  195,  264,  113,  113,
+ /*   170 */  2207, 2207,  854,  854,  854,  751,  765,  765,  765,  765,
+ /*   180 */  1096, 1096,  725,  292,  882,  904,  598,  598,  598,  598,
+ /*   190 */   598,  598,  598,  598,  598,  598,  598,  598,  598,  598,
+ /*   200 */   598,  598,  598,  598,  598, 1273, 1032, 1032,  598,  147,
+ /*   210 */  1098, 1098,  603,  603, 1276, 1276,  363, 2207, 2207, 2207,
+ /*   220 */  2207, 2207, 2207, 2207,  469,  617,  617,  801,  336,  461,
+ /*   230 */   804,  864,  615,  891,  913,  598,  598,  598,  598,  598,
+ /*   240 */   598,  598,  598,  598,  598,  653,  598,  598,  598,  598,
+ /*   250 */   598,  598,  598,  598,  598,  598,  598,  598, 1105, 1105,
+ /*   260 */  1105,  598,  598,  598, 1194,  598,  598,  598, 1215, 1249,
+ /*   270 */   598, 1353,  598,  598,  598,  598,  598,  598,  598,  598,
+ /*   280 */   677,  449,  902, 1338, 1338, 1338, 1338, 1248,  902,  902,
+ /*   290 */   326, 1151, 1047,  755,  749, 1371,  960, 1371, 1007, 1162,
+ /*   300 */   749,  749, 1162,  749,  960, 1007, 1274,  738,  215, 1300,
+ /*   310 */  1300, 1300, 1395, 1395, 1395, 1395, 1368, 1368, 1033, 1414,
+ /*   320 */  1387, 1361, 1759, 1759, 1685, 1685, 1792, 1792, 1685, 1683,
+ /*   330 */  1686, 1814, 1797, 1825, 1825, 1825, 1825, 1685, 1836, 1707,
+ /*   340 */  1686, 1686, 1707, 1814, 1797, 1707, 1797, 1707, 1685, 1836,
+ /*   350 */  1710, 1807, 1685, 1836, 1854, 1685, 1836, 1685, 1836, 1854,
+ /*   360 */  1769, 1769, 1769, 1822, 1870, 1870, 1854, 1769, 1766, 1769,
+ /*   370 */  1822, 1769, 1769, 1729, 1873, 1785, 1785, 1854, 1685, 1823,
+ /*   380 */  1823, 1840, 1840, 1778, 1782, 1909, 1685, 1779, 1778, 1789,
+ /*   390 */  1800, 1707, 1919, 1939, 1939, 1948, 1948, 1948, 2207, 2207,
+ /*   400 */  2207, 2207, 2207, 2207, 2207, 2207, 2207, 2207, 2207, 2207,
+ /*   410 */  2207, 2207, 2207,   69, 1037,   79, 1088,  651, 1196, 1415,
+ /*   420 */  1501, 1439, 1369, 1452,  911, 1211, 1524, 1469, 1551, 1567,
+ /*   430 */  1570, 1624, 1640, 1644, 1499, 1440, 1572, 1464, 1597,  275,
+ /*   440 */   782, 1586, 1648, 1678, 1553, 1682, 1687, 1388, 1502, 1696,
+ /*   450 */  1706, 1588, 1486, 1971, 1975, 1957, 1820, 1972, 1973, 1965,
+ /*   460 */  1967, 1851, 1841, 1861, 1969, 1969, 1974, 1852, 1976, 1855,
+ /*   470 */  1981, 1998, 1858, 1871, 1969, 1872, 1942, 1968, 1969, 1856,
+ /*   480 */  1952, 1953, 1955, 1956, 1881, 1896, 1980, 1874, 2014, 2015,
+ /*   490 */  1997, 1905, 1860, 1954, 1999, 1964, 1950, 1994, 1894, 1921,
+ /*   500 */  2020, 2018, 2026, 1915, 1923, 2028, 1984, 2036, 2040, 2047,
+ /*   510 */  2041, 2003, 2012, 2050, 1979, 2049, 2056, 2011, 2044, 2057,
+ /*   520 */  2048, 1934, 2063, 2064, 2065, 2061, 2066, 2068, 1993, 1959,
+ /*   530 */  2069, 2071, 1978, 2062, 2075, 1958, 2073, 2070, 2072, 2076,
+ /*   540 */  2078, 2010, 2027, 2022, 2074, 2031, 2019, 2081, 2082, 2094,
+ /*   550 */  2093, 2095, 2096, 2085, 1983, 1986, 2100, 2073, 2101, 2104,
+ /*   560 */  2107, 2109, 2108, 2110, 2111, 2114, 2121, 2115, 2116, 2117,
+ /*   570 */  2118, 2122, 2123, 2124, 2007, 2004, 2005, 2006, 2125, 2128,
+ /*   580 */  2137, 2138, 2152,
 };
-#define YY_REDUCE_COUNT (410)
-#define YY_REDUCE_MIN   (-271)
-#define YY_REDUCE_MAX   (1753)
+#define YY_REDUCE_COUNT (412)
+#define YY_REDUCE_MIN   (-276)
+#define YY_REDUCE_MAX   (1775)
 static const short yy_reduce_ofst[] = {
- /*     0 */  -125,  733,  789,  241,  293, -123, -193, -191, -183, -187,
- /*    10 */   166,  238,  133, -207, -199, -267, -176,   -6,  204,  489,
- /*    20 */   576,  598, -175,  686,  860,  615,  725, 1014,  778,  781,
- /*    30 */   857,  616,  887,   87,  240, -192,  408,  626,  796,  843,
- /*    40 */   854, 1004, -271, -271, -271, -271, -271, -271, -271, -271,
- /*    50 */  -271, -271, -271, -271, -271, -271, -271, -271, -271, -271,
- /*    60 */  -271, -271, -271, -271, -271, -271, -271, -271, -271, -271,
- /*    70 */  -271, -271, -271, -271, -271, -271, -271, -271, -271,   80,
- /*    80 */    83,  313,  886,  888,  918,  938, 1021, 1034, 1036, 1141,
- /*    90 */  1159, 1163, 1166, 1168, 1170, 1176, 1178, 1180, 1184, 1196,
- /*   100 */  1198, 1205, 1215, 1225, 1227, 1236, 1252, 1254, 1264, 1303,
- /*   110 */  1309, 1312, 1322, 1325, 1328, 1337, 1340, 1343, 1353, 1371,
- /*   120 */  1373, 1384, 1386, 1411, 1413, 1420, 1424, 1426, 1458, 1470,
- /*   130 */  1473, -271, -271, -271, -271, -271, -271, -271, -271, -271,
- /*   140 */  -271, -271,  138,  459,  396, -158,  470,  302, -212,  521,
- /*   150 */   201, -195,  -92,  559,  630,  632,  630, -271,  632,  901,
- /*   160 */    63,  407,  670, -271, -271, -271, -271,  161,  161,  161,
- /*   170 */   251,  335,  847,  979, 1097,  537,  588,  618,  628,  688,
- /*   180 */   688, -166, -161,  674,  787,  794,  799,  852,  996, -122,
- /*   190 */   837, -120, 1018, 1035,  415, 1047, 1001,  958, 1082,  400,
- /*   200 */  1099,  779, 1137, 1142,  263, 1083, 1145, 1150, 1041, 1139,
- /*   210 */   965, 1050,  362,  849,  752,  629,  675, 1162, 1173, 1090,
- /*   220 */  1195, -194,   56,  185, -135,  232,  522,  560,  571,  601,
- /*   230 */   617,  669,  683,  711,  850,  893, 1000, 1040, 1049, 1081,
- /*   240 */  1087, 1101,  392, 1114, 1123, 1155, 1161, 1175, 1271, 1293,
- /*   250 */  1299, 1330, 1339, 1342, 1347,  593, 1282, 1286, 1350, 1359,
- /*   260 */  1368, 1314, 1480, 1483, 1507, 1085, 1338, 1526, 1527, 1487,
- /*   270 */  1531,  560, 1532, 1534, 1535, 1538, 1539, 1541, 1448, 1450,
- /*   280 */  1496, 1484, 1485, 1489, 1490, 1314, 1496, 1496, 1504, 1536,
- /*   290 */  1564, 1451, 1486, 1492, 1509, 1493, 1465, 1515, 1494, 1495,
- /*   300 */  1517, 1500, 1519, 1474, 1550, 1543, 1548, 1556, 1565, 1566,
- /*   310 */  1518, 1523, 1542, 1544, 1525, 1545, 1513, 1553, 1552, 1604,
- /*   320 */  1508, 1510, 1608, 1609, 1520, 1528, 1612, 1540, 1559, 1560,
- /*   330 */  1592, 1591, 1595, 1596, 1597, 1629, 1638, 1594, 1569, 1570,
- /*   340 */  1600, 1568, 1610, 1601, 1611, 1603, 1643, 1651, 1562, 1571,
- /*   350 */  1655, 1659, 1640, 1663, 1666, 1664, 1667, 1641, 1650, 1652,
- /*   360 */  1653, 1647, 1656, 1657, 1658, 1668, 1672, 1681, 1649, 1682,
- /*   370 */  1683, 1573, 1582, 1607, 1615, 1685, 1702, 1586, 1587, 1642,
- /*   380 */  1646, 1673, 1675, 1636, 1714, 1637, 1677, 1674, 1678, 1694,
- /*   390 */  1719, 1734, 1735, 1746, 1747, 1750, 1633, 1661, 1686, 1738,
- /*   400 */  1728, 1733, 1736, 1737, 1740, 1726, 1730, 1742, 1743, 1748,
- /*   410 */  1753,
+ /*     0 */   -66,  217,  -63, -177, -180,  161,  364,   64, -183,  162,
+ /*    10 */   223,  367,  414, -173,  473,  514,  525,  622,  626, -207,
+ /*    20 */   351, -276,  -38,  693,  811,  831,  833,  888, -188,  945,
+ /*    30 */   947,  416,  558,  951,  867,  287, 1078, 1080, -186,  224,
+ /*    40 */  -132,   42,  964,  269,  417,  796,  810, -237, -231, -237,
+ /*    50 */  -231,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,
+ /*    60 */   -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,
+ /*    70 */   -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,
+ /*    80 */   -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  895,
+ /*    90 */   925,  967,  980, 1100, 1143, 1169, 1203, 1225, 1228, 1242,
+ /*   100 */  1247, 1250, 1253, 1255, 1261, 1267, 1272, 1275, 1283, 1286,
+ /*   110 */  1288, 1292, 1333, 1335, 1347, 1349, 1352, 1354, 1360, 1366,
+ /*   120 */  1381, 1391, 1406, 1408, 1413, 1416, 1418, 1422, 1425, 1427,
+ /*   130 */  1463, 1465, 1472, 1478, 1480, 1491, 1498, 1500, 1517, 1519,
+ /*   140 */  1528, 1536,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,
+ /*   150 */   -45,  -45,  -45,  312, -158,  285, -219,    9,  166,  370,
+ /*   160 */   545,  707,  -45,  930,  601,  963, 1067,  792,  -45,  -45,
+ /*   170 */   -45,  -45, -204, -204, -204,  369, -171, -129,  632,  678,
+ /*   180 */   202,  352, -270,  412,  627,  627,   -9,  122,  415,  419,
+ /*   190 */   -56,  248,  583,  920,    6,  261,  459,  795, 1049,  813,
+ /*   200 */  1062, 1082, -161,  778, 1063,  797,  870, 1003, 1128,  443,
+ /*   210 */  1031, 1072, 1191, 1192,  957, 1120,  105, 1149,  523,  933,
+ /*   220 */  1218, 1238, 1254, 1251, -138,   96,  117,  146,  181,  277,
+ /*   230 */   280,  421,  480,  712,  830,  850, 1085, 1099, 1129, 1209,
+ /*   240 */  1323, 1331, 1336, 1364, 1407,  368, 1412, 1433, 1438, 1474,
+ /*   250 */  1481, 1505, 1506, 1526, 1538, 1544, 1545, 1546,  722,  764,
+ /*   260 */   856, 1547, 1548, 1550, 1188, 1554, 1557, 1561, 1298, 1260,
+ /*   270 */  1562, 1456, 1564,  280, 1568, 1571, 1573, 1574, 1575, 1576,
+ /*   280 */  1457, 1477, 1520, 1514, 1515, 1516, 1518, 1188, 1520, 1520,
+ /*   290 */  1530, 1563, 1584, 1482, 1504, 1510, 1534, 1513, 1488, 1537,
+ /*   300 */  1512, 1521, 1539, 1522, 1541, 1493, 1583, 1559, 1565, 1585,
+ /*   310 */  1587, 1589, 1529, 1531, 1532, 1549, 1558, 1566, 1535, 1577,
+ /*   320 */  1582, 1622, 1533, 1540, 1627, 1628, 1552, 1555, 1633, 1560,
+ /*   330 */  1578, 1581, 1607, 1606, 1608, 1609, 1611, 1649, 1655, 1612,
+ /*   340 */  1590, 1591, 1613, 1594, 1621, 1614, 1623, 1616, 1666, 1668,
+ /*   350 */  1579, 1593, 1672, 1675, 1656, 1676, 1679, 1680, 1688, 1660,
+ /*   360 */  1667, 1670, 1671, 1663, 1669, 1673, 1674, 1689, 1681, 1692,
+ /*   370 */  1677, 1693, 1694, 1592, 1599, 1617, 1620, 1700, 1713, 1596,
+ /*   380 */  1598, 1658, 1659, 1691, 1684, 1654, 1735, 1664, 1697, 1690,
+ /*   390 */  1701, 1703, 1748, 1758, 1760, 1768, 1770, 1772, 1657, 1661,
+ /*   400 */  1665, 1761, 1754, 1757, 1762, 1763, 1764, 1750, 1751, 1765,
+ /*   410 */  1771, 1767, 1775,
 };
 static const YYACTIONTYPE yy_default[] = {
- /*     0 */  1648, 1648, 1648, 1478, 1243, 1354, 1243, 1243, 1243, 1478,
- /*    10 */  1478, 1478, 1243, 1384, 1384, 1531, 1276, 1243, 1243, 1243,
- /*    20 */  1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243, 1477, 1243,
- /*    30 */  1243, 1243, 1243, 1564, 1564, 1243, 1243, 1243, 1243, 1243,
- /*    40 */  1243, 1243, 1243, 1393, 1243, 1400, 1243, 1243, 1243, 1243,
- /*    50 */  1243, 1479, 1480, 1243, 1243, 1243, 1530, 1532, 1495, 1407,
- /*    60 */  1406, 1405, 1404, 1513, 1372, 1398, 1391, 1395, 1474, 1475,
- /*    70 */  1473, 1626, 1480, 1479, 1243, 1394, 1442, 1458, 1441, 1243,
- /*    80 */  1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243,
- /*    90 */  1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243,
- /*   100 */  1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243,
- /*   110 */  1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243,
- /*   120 */  1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243,
- /*   130 */  1243, 1450, 1457, 1456, 1455, 1464, 1454, 1451, 1444, 1443,
- /*   140 */  1445, 1446, 1243, 1243, 1267, 1243, 1243, 1264, 1318, 1243,
- /*   150 */  1243, 1243, 1243, 1243, 1550, 1549, 1243, 1447, 1243, 1276,
- /*   160 */  1435, 1434, 1433, 1461, 1448, 1460, 1459, 1538, 1600, 1599,
- /*   170 */  1496, 1243, 1243, 1243, 1243, 1243, 1243, 1564, 1243, 1243,
- /*   180 */  1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243,
- /*   190 */  1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243,
- /*   200 */  1243, 1374, 1564, 1564, 1243, 1276, 1564, 1564, 1375, 1375,
- /*   210 */  1272, 1272, 1378, 1243, 1545, 1345, 1345, 1345, 1345, 1354,
- /*   220 */  1345, 1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243,
- /*   230 */  1243, 1243, 1243, 1243, 1243, 1243, 1535, 1533, 1243, 1243,
- /*   240 */  1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243,
- /*   250 */  1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243,
- /*   260 */  1243, 1243, 1243, 1243, 1243, 1350, 1243, 1243, 1243, 1243,
- /*   270 */  1243, 1243, 1243, 1243, 1243, 1243, 1243, 1593, 1243, 1508,
- /*   280 */  1332, 1350, 1350, 1350, 1350, 1352, 1333, 1331, 1344, 1277,
- /*   290 */  1250, 1640, 1410, 1399, 1351, 1399, 1637, 1397, 1410, 1410,
- /*   300 */  1397, 1410, 1351, 1637, 1293, 1615, 1288, 1384, 1384, 1384,
- /*   310 */  1374, 1374, 1374, 1374, 1378, 1378, 1476, 1351, 1344, 1243,
- /*   320 */  1640, 1640, 1360, 1360, 1639, 1639, 1360, 1496, 1623, 1419,
- /*   330 */  1321, 1327, 1327, 1327, 1327, 1360, 1261, 1397, 1623, 1623,
- /*   340 */  1397, 1419, 1321, 1397, 1321, 1397, 1360, 1261, 1512, 1634,
- /*   350 */  1360, 1261, 1486, 1360, 1261, 1360, 1261, 1486, 1319, 1319,
- /*   360 */  1319, 1308, 1243, 1243, 1486, 1319, 1293, 1319, 1308, 1319,
- /*   370 */  1319, 1582, 1243, 1490, 1490, 1486, 1360, 1574, 1574, 1387,
- /*   380 */  1387, 1392, 1378, 1481, 1360, 1243, 1392, 1390, 1388, 1397,
- /*   390 */  1311, 1596, 1596, 1592, 1592, 1592, 1645, 1645, 1545, 1608,
- /*   400 */  1276, 1276, 1276, 1276, 1608, 1295, 1295, 1277, 1277, 1276,
- /*   410 */  1608, 1243, 1243, 1243, 1243, 1243, 1243, 1603, 1243, 1540,
- /*   420 */  1497, 1364, 1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243,
- /*   430 */  1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243, 1551, 1243,
- /*   440 */  1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243, 1424,
- /*   450 */  1243, 1246, 1542, 1243, 1243, 1243, 1243, 1243, 1243, 1243,
- /*   460 */  1243, 1401, 1402, 1365, 1243, 1243, 1243, 1243, 1243, 1243,
- /*   470 */  1243, 1416, 1243, 1243, 1243, 1411, 1243, 1243, 1243, 1243,
- /*   480 */  1243, 1243, 1243, 1243, 1636, 1243, 1243, 1243, 1243, 1243,
- /*   490 */  1243, 1511, 1510, 1243, 1243, 1362, 1243, 1243, 1243, 1243,
- /*   500 */  1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243, 1291,
- /*   510 */  1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243,
- /*   520 */  1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243,
- /*   530 */  1243, 1243, 1243, 1389, 1243, 1243, 1243, 1243, 1243, 1243,
- /*   540 */  1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243, 1579, 1379,
- /*   550 */  1243, 1243, 1243, 1243, 1627, 1243, 1243, 1243, 1243, 1243,
- /*   560 */  1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243, 1243, 1619,
- /*   570 */  1335, 1425, 1243, 1428, 1265, 1243, 1255, 1243, 1243,
+ /*     0 */  1663, 1663, 1663, 1491, 1254, 1367, 1254, 1254, 1254, 1254,
+ /*    10 */  1491, 1491, 1491, 1254, 1254, 1254, 1254, 1254, 1254, 1397,
+ /*    20 */  1397, 1544, 1287, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
+ /*    30 */  1254, 1254, 1254, 1254, 1254, 1490, 1254, 1254, 1254, 1254,
+ /*    40 */  1578, 1578, 1254, 1254, 1254, 1254, 1254, 1563, 1562, 1254,
+ /*    50 */  1254, 1254, 1406, 1254, 1413, 1254, 1254, 1254, 1254, 1254,
+ /*    60 */  1492, 1493, 1254, 1254, 1254, 1254, 1543, 1545, 1508, 1420,
+ /*    70 */  1419, 1418, 1417, 1526, 1385, 1411, 1404, 1408, 1487, 1488,
+ /*    80 */  1486, 1641, 1493, 1492, 1254, 1407, 1455, 1471, 1454, 1254,
+ /*    90 */  1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
+ /*   100 */  1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
+ /*   110 */  1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
+ /*   120 */  1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
+ /*   130 */  1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
+ /*   140 */  1254, 1254, 1463, 1470, 1469, 1468, 1477, 1467, 1464, 1457,
+ /*   150 */  1456, 1458, 1459, 1278, 1254, 1275, 1329, 1254, 1254, 1254,
+ /*   160 */  1254, 1254, 1460, 1287, 1448, 1447, 1446, 1254, 1474, 1461,
+ /*   170 */  1473, 1472, 1551, 1615, 1614, 1509, 1254, 1254, 1254, 1254,
+ /*   180 */  1254, 1254, 1578, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
+ /*   190 */  1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
+ /*   200 */  1254, 1254, 1254, 1254, 1254, 1387, 1578, 1578, 1254, 1287,
+ /*   210 */  1578, 1578, 1388, 1388, 1283, 1283, 1391, 1558, 1358, 1358,
+ /*   220 */  1358, 1358, 1367, 1358, 1254, 1254, 1254, 1254, 1254, 1254,
+ /*   230 */  1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1548,
+ /*   240 */  1546, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
+ /*   250 */  1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
+ /*   260 */  1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1363, 1254,
+ /*   270 */  1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1608,
+ /*   280 */  1254, 1521, 1343, 1363, 1363, 1363, 1363, 1365, 1344, 1342,
+ /*   290 */  1357, 1288, 1261, 1655, 1423, 1412, 1364, 1412, 1652, 1410,
+ /*   300 */  1423, 1423, 1410, 1423, 1364, 1652, 1304, 1630, 1299, 1397,
+ /*   310 */  1397, 1397, 1387, 1387, 1387, 1387, 1391, 1391, 1489, 1364,
+ /*   320 */  1357, 1254, 1655, 1655, 1373, 1373, 1654, 1654, 1373, 1509,
+ /*   330 */  1638, 1432, 1332, 1338, 1338, 1338, 1338, 1373, 1272, 1410,
+ /*   340 */  1638, 1638, 1410, 1432, 1332, 1410, 1332, 1410, 1373, 1272,
+ /*   350 */  1525, 1649, 1373, 1272, 1499, 1373, 1272, 1373, 1272, 1499,
+ /*   360 */  1330, 1330, 1330, 1319, 1254, 1254, 1499, 1330, 1304, 1330,
+ /*   370 */  1319, 1330, 1330, 1596, 1254, 1503, 1503, 1499, 1373, 1588,
+ /*   380 */  1588, 1400, 1400, 1405, 1391, 1494, 1373, 1254, 1405, 1403,
+ /*   390 */  1401, 1410, 1322, 1611, 1611, 1607, 1607, 1607, 1660, 1660,
+ /*   400 */  1558, 1623, 1287, 1287, 1287, 1287, 1623, 1306, 1306, 1288,
+ /*   410 */  1288, 1287, 1623, 1254, 1254, 1254, 1254, 1254, 1254, 1618,
+ /*   420 */  1254, 1553, 1510, 1377, 1254, 1254, 1254, 1254, 1254, 1254,
+ /*   430 */  1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
+ /*   440 */  1564, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
+ /*   450 */  1254, 1254, 1437, 1254, 1257, 1555, 1254, 1254, 1254, 1254,
+ /*   460 */  1254, 1254, 1254, 1254, 1414, 1415, 1378, 1254, 1254, 1254,
+ /*   470 */  1254, 1254, 1254, 1254, 1429, 1254, 1254, 1254, 1424, 1254,
+ /*   480 */  1254, 1254, 1254, 1254, 1254, 1254, 1254, 1651, 1254, 1254,
+ /*   490 */  1254, 1254, 1254, 1254, 1524, 1523, 1254, 1254, 1375, 1254,
+ /*   500 */  1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
+ /*   510 */  1254, 1254, 1302, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
+ /*   520 */  1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
+ /*   530 */  1254, 1254, 1254, 1254, 1254, 1254, 1402, 1254, 1254, 1254,
+ /*   540 */  1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
+ /*   550 */  1254, 1593, 1392, 1254, 1254, 1254, 1254, 1642, 1254, 1254,
+ /*   560 */  1254, 1254, 1352, 1254, 1254, 1254, 1254, 1254, 1254, 1254,
+ /*   570 */  1254, 1254, 1254, 1634, 1346, 1438, 1254, 1441, 1276, 1254,
+ /*   580 */  1266, 1254, 1254,
 };
 /********** End of lemon-generated parsing tables *****************************/
 
@@ -172114,52 +175070,53 @@ static const YYACTIONTYPE yy_default[] = {
 static const YYCODETYPE yyFallback[] = {
     0,  /*          $ => nothing */
     0,  /*       SEMI => nothing */
-   59,  /*    EXPLAIN => ID */
-   59,  /*      QUERY => ID */
-   59,  /*       PLAN => ID */
-   59,  /*      BEGIN => ID */
+   60,  /*    EXPLAIN => ID */
+   60,  /*      QUERY => ID */
+   60,  /*       PLAN => ID */
+   60,  /*      BEGIN => ID */
     0,  /* TRANSACTION => nothing */
-   59,  /*   DEFERRED => ID */
-   59,  /*  IMMEDIATE => ID */
-   59,  /*  EXCLUSIVE => ID */
+   60,  /*   DEFERRED => ID */
+   60,  /*  IMMEDIATE => ID */
+   60,  /*  EXCLUSIVE => ID */
     0,  /*     COMMIT => nothing */
-   59,  /*        END => ID */
-   59,  /*   ROLLBACK => ID */
-   59,  /*  SAVEPOINT => ID */
-   59,  /*    RELEASE => ID */
+   60,  /*        END => ID */
+   60,  /*   ROLLBACK => ID */
+   60,  /*  SAVEPOINT => ID */
+   60,  /*    RELEASE => ID */
     0,  /*         TO => nothing */
     0,  /*      TABLE => nothing */
     0,  /*     CREATE => nothing */
-   59,  /*         IF => ID */
+   60,  /*         IF => ID */
     0,  /*        NOT => nothing */
     0,  /*     EXISTS => nothing */
-   59,  /*       TEMP => ID */
+   60,  /*       TEMP => ID */
     0,  /*         LP => nothing */
     0,  /*         RP => nothing */
     0,  /*         AS => nothing */
     0,  /*      COMMA => nothing */
-   59,  /*    WITHOUT => ID */
-   59,  /*      ABORT => ID */
-   59,  /*     ACTION => ID */
-   59,  /*      AFTER => ID */
-   59,  /*    ANALYZE => ID */
-   59,  /*        ASC => ID */
-   59,  /*     ATTACH => ID */
-   59,  /*     BEFORE => ID */
-   59,  /*         BY => ID */
-   59,  /*    CASCADE => ID */
-   59,  /*       CAST => ID */
-   59,  /*   CONFLICT => ID */
-   59,  /*   DATABASE => ID */
-   59,  /*       DESC => ID */
-   59,  /*     DETACH => ID */
-   59,  /*       EACH => ID */
-   59,  /*       FAIL => ID */
+   60,  /*    WITHOUT => ID */
+   60,  /*      ABORT => ID */
+   60,  /*     ACTION => ID */
+   60,  /*      AFTER => ID */
+   60,  /*    ANALYZE => ID */
+   60,  /*        ASC => ID */
+   60,  /*     ATTACH => ID */
+   60,  /*     BEFORE => ID */
+   60,  /*         BY => ID */
+   60,  /*    CASCADE => ID */
+   60,  /*       CAST => ID */
+   60,  /*   CONFLICT => ID */
+   60,  /*   DATABASE => ID */
+   60,  /*       DESC => ID */
+   60,  /*     DETACH => ID */
+   60,  /*       EACH => ID */
+   60,  /*       FAIL => ID */
     0,  /*         OR => nothing */
     0,  /*        AND => nothing */
     0,  /*         IS => nothing */
-   59,  /*      MATCH => ID */
-   59,  /*    LIKE_KW => ID */
+    0,  /*      ISNOT => nothing */
+   60,  /*      MATCH => ID */
+   60,  /*    LIKE_KW => ID */
     0,  /*    BETWEEN => nothing */
     0,  /*         IN => nothing */
     0,  /*     ISNULL => nothing */
@@ -172172,47 +175129,47 @@ static const YYCODETYPE yyFallback[] = {
     0,  /*         GE => nothing */
     0,  /*     ESCAPE => nothing */
     0,  /*         ID => nothing */
-   59,  /*   COLUMNKW => ID */
-   59,  /*         DO => ID */
-   59,  /*        FOR => ID */
-   59,  /*     IGNORE => ID */
-   59,  /*  INITIALLY => ID */
-   59,  /*    INSTEAD => ID */
-   59,  /*         NO => ID */
-   59,  /*        KEY => ID */
-   59,  /*         OF => ID */
-   59,  /*     OFFSET => ID */
-   59,  /*     PRAGMA => ID */
-   59,  /*      RAISE => ID */
-   59,  /*  RECURSIVE => ID */
-   59,  /*    REPLACE => ID */
-   59,  /*   RESTRICT => ID */
-   59,  /*        ROW => ID */
-   59,  /*       ROWS => ID */
-   59,  /*    TRIGGER => ID */
-   59,  /*     VACUUM => ID */
-   59,  /*       VIEW => ID */
-   59,  /*    VIRTUAL => ID */
-   59,  /*       WITH => ID */
-   59,  /*      NULLS => ID */
-   59,  /*      FIRST => ID */
-   59,  /*       LAST => ID */
-   59,  /*    CURRENT => ID */
-   59,  /*  FOLLOWING => ID */
-   59,  /*  PARTITION => ID */
-   59,  /*  PRECEDING => ID */
-   59,  /*      RANGE => ID */
-   59,  /*  UNBOUNDED => ID */
-   59,  /*    EXCLUDE => ID */
-   59,  /*     GROUPS => ID */
-   59,  /*     OTHERS => ID */
-   59,  /*       TIES => ID */
-   59,  /*  GENERATED => ID */
-   59,  /*     ALWAYS => ID */
-   59,  /* MATERIALIZED => ID */
-   59,  /*    REINDEX => ID */
-   59,  /*     RENAME => ID */
-   59,  /*   CTIME_KW => ID */
+   60,  /*   COLUMNKW => ID */
+   60,  /*         DO => ID */
+   60,  /*        FOR => ID */
+   60,  /*     IGNORE => ID */
+   60,  /*  INITIALLY => ID */
+   60,  /*    INSTEAD => ID */
+   60,  /*         NO => ID */
+   60,  /*        KEY => ID */
+   60,  /*         OF => ID */
+   60,  /*     OFFSET => ID */
+   60,  /*     PRAGMA => ID */
+   60,  /*      RAISE => ID */
+   60,  /*  RECURSIVE => ID */
+   60,  /*    REPLACE => ID */
+   60,  /*   RESTRICT => ID */
+   60,  /*        ROW => ID */
+   60,  /*       ROWS => ID */
+   60,  /*    TRIGGER => ID */
+   60,  /*     VACUUM => ID */
+   60,  /*       VIEW => ID */
+   60,  /*    VIRTUAL => ID */
+   60,  /*       WITH => ID */
+   60,  /*      NULLS => ID */
+   60,  /*      FIRST => ID */
+   60,  /*       LAST => ID */
+   60,  /*    CURRENT => ID */
+   60,  /*  FOLLOWING => ID */
+   60,  /*  PARTITION => ID */
+   60,  /*  PRECEDING => ID */
+   60,  /*      RANGE => ID */
+   60,  /*  UNBOUNDED => ID */
+   60,  /*    EXCLUDE => ID */
+   60,  /*     GROUPS => ID */
+   60,  /*     OTHERS => ID */
+   60,  /*       TIES => ID */
+   60,  /*  GENERATED => ID */
+   60,  /*     ALWAYS => ID */
+   60,  /* MATERIALIZED => ID */
+   60,  /*    REINDEX => ID */
+   60,  /*     RENAME => ID */
+   60,  /*   CTIME_KW => ID */
     0,  /*        ANY => nothing */
     0,  /*     BITAND => nothing */
     0,  /*      BITOR => nothing */
@@ -172283,10 +175240,9 @@ static const YYCODETYPE yyFallback[] = {
     0,  /* AGG_FUNCTION => nothing */
     0,  /* AGG_COLUMN => nothing */
     0,  /*  TRUEFALSE => nothing */
-    0,  /*      ISNOT => nothing */
     0,  /*   FUNCTION => nothing */
-    0,  /*     UMINUS => nothing */
     0,  /*      UPLUS => nothing */
+    0,  /*     UMINUS => nothing */
     0,  /*      TRUTH => nothing */
     0,  /*   REGISTER => nothing */
     0,  /*     VECTOR => nothing */
@@ -172295,6 +175251,7 @@ static const YYCODETYPE yyFallback[] = {
     0,  /*   ASTERISK => nothing */
     0,  /*       SPAN => nothing */
     0,  /*      ERROR => nothing */
+    0,  /*    QNUMBER => nothing */
     0,  /*      SPACE => nothing */
     0,  /*    ILLEGAL => nothing */
 };
@@ -172337,14 +175294,9 @@ struct yyParser {
 #endif
   sqlite3ParserARG_SDECL                /* A place to hold %extra_argument */
   sqlite3ParserCTX_SDECL                /* A place to hold %extra_context */
-#if YYSTACKDEPTH<=0
-  int yystksz;                  /* Current side of the stack */
-  yyStackEntry *yystack;        /* The parser's stack */
-  yyStackEntry yystk0;          /* First stack entry */
-#else
-  yyStackEntry yystack[YYSTACKDEPTH];  /* The parser's stack */
-  yyStackEntry *yystackEnd;            /* Last entry in the stack */
-#endif
+  yyStackEntry *yystackEnd;           /* Last entry in the stack */
+  yyStackEntry *yystack;              /* The parser stack */
+  yyStackEntry yystk0[YYSTACKDEPTH];  /* Initial stack space */
 };
 typedef struct yyParser yyParser;
 
@@ -172431,135 +175383,135 @@ static const char *const yyTokenName[] = {
   /*   43 */ "OR",
   /*   44 */ "AND",
   /*   45 */ "IS",
-  /*   46 */ "MATCH",
-  /*   47 */ "LIKE_KW",
-  /*   48 */ "BETWEEN",
-  /*   49 */ "IN",
-  /*   50 */ "ISNULL",
-  /*   51 */ "NOTNULL",
-  /*   52 */ "NE",
-  /*   53 */ "EQ",
-  /*   54 */ "GT",
-  /*   55 */ "LE",
-  /*   56 */ "LT",
-  /*   57 */ "GE",
-  /*   58 */ "ESCAPE",
-  /*   59 */ "ID",
-  /*   60 */ "COLUMNKW",
-  /*   61 */ "DO",
-  /*   62 */ "FOR",
-  /*   63 */ "IGNORE",
-  /*   64 */ "INITIALLY",
-  /*   65 */ "INSTEAD",
-  /*   66 */ "NO",
-  /*   67 */ "KEY",
-  /*   68 */ "OF",
-  /*   69 */ "OFFSET",
-  /*   70 */ "PRAGMA",
-  /*   71 */ "RAISE",
-  /*   72 */ "RECURSIVE",
-  /*   73 */ "REPLACE",
-  /*   74 */ "RESTRICT",
-  /*   75 */ "ROW",
-  /*   76 */ "ROWS",
-  /*   77 */ "TRIGGER",
-  /*   78 */ "VACUUM",
-  /*   79 */ "VIEW",
-  /*   80 */ "VIRTUAL",
-  /*   81 */ "WITH",
-  /*   82 */ "NULLS",
-  /*   83 */ "FIRST",
-  /*   84 */ "LAST",
-  /*   85 */ "CURRENT",
-  /*   86 */ "FOLLOWING",
-  /*   87 */ "PARTITION",
-  /*   88 */ "PRECEDING",
-  /*   89 */ "RANGE",
-  /*   90 */ "UNBOUNDED",
-  /*   91 */ "EXCLUDE",
-  /*   92 */ "GROUPS",
-  /*   93 */ "OTHERS",
-  /*   94 */ "TIES",
-  /*   95 */ "GENERATED",
-  /*   96 */ "ALWAYS",
-  /*   97 */ "MATERIALIZED",
-  /*   98 */ "REINDEX",
-  /*   99 */ "RENAME",
-  /*  100 */ "CTIME_KW",
-  /*  101 */ "ANY",
-  /*  102 */ "BITAND",
-  /*  103 */ "BITOR",
-  /*  104 */ "LSHIFT",
-  /*  105 */ "RSHIFT",
-  /*  106 */ "PLUS",
-  /*  107 */ "MINUS",
-  /*  108 */ "STAR",
-  /*  109 */ "SLASH",
-  /*  110 */ "REM",
-  /*  111 */ "CONCAT",
-  /*  112 */ "PTR",
-  /*  113 */ "COLLATE",
-  /*  114 */ "BITNOT",
-  /*  115 */ "ON",
-  /*  116 */ "INDEXED",
-  /*  117 */ "STRING",
-  /*  118 */ "JOIN_KW",
-  /*  119 */ "CONSTRAINT",
-  /*  120 */ "DEFAULT",
-  /*  121 */ "NULL",
-  /*  122 */ "PRIMARY",
-  /*  123 */ "UNIQUE",
-  /*  124 */ "CHECK",
-  /*  125 */ "REFERENCES",
-  /*  126 */ "AUTOINCR",
-  /*  127 */ "INSERT",
-  /*  128 */ "DELETE",
-  /*  129 */ "UPDATE",
-  /*  130 */ "SET",
-  /*  131 */ "DEFERRABLE",
-  /*  132 */ "FOREIGN",
-  /*  133 */ "DROP",
-  /*  134 */ "UNION",
-  /*  135 */ "ALL",
-  /*  136 */ "EXCEPT",
-  /*  137 */ "INTERSECT",
-  /*  138 */ "SELECT",
-  /*  139 */ "VALUES",
-  /*  140 */ "DISTINCT",
-  /*  141 */ "DOT",
-  /*  142 */ "FROM",
-  /*  143 */ "JOIN",
-  /*  144 */ "USING",
-  /*  145 */ "ORDER",
-  /*  146 */ "GROUP",
-  /*  147 */ "HAVING",
-  /*  148 */ "LIMIT",
-  /*  149 */ "WHERE",
-  /*  150 */ "RETURNING",
-  /*  151 */ "INTO",
-  /*  152 */ "NOTHING",
-  /*  153 */ "FLOAT",
-  /*  154 */ "BLOB",
-  /*  155 */ "INTEGER",
-  /*  156 */ "VARIABLE",
-  /*  157 */ "CASE",
-  /*  158 */ "WHEN",
-  /*  159 */ "THEN",
-  /*  160 */ "ELSE",
-  /*  161 */ "INDEX",
-  /*  162 */ "ALTER",
-  /*  163 */ "ADD",
-  /*  164 */ "WINDOW",
-  /*  165 */ "OVER",
-  /*  166 */ "FILTER",
-  /*  167 */ "COLUMN",
-  /*  168 */ "AGG_FUNCTION",
-  /*  169 */ "AGG_COLUMN",
-  /*  170 */ "TRUEFALSE",
-  /*  171 */ "ISNOT",
+  /*   46 */ "ISNOT",
+  /*   47 */ "MATCH",
+  /*   48 */ "LIKE_KW",
+  /*   49 */ "BETWEEN",
+  /*   50 */ "IN",
+  /*   51 */ "ISNULL",
+  /*   52 */ "NOTNULL",
+  /*   53 */ "NE",
+  /*   54 */ "EQ",
+  /*   55 */ "GT",
+  /*   56 */ "LE",
+  /*   57 */ "LT",
+  /*   58 */ "GE",
+  /*   59 */ "ESCAPE",
+  /*   60 */ "ID",
+  /*   61 */ "COLUMNKW",
+  /*   62 */ "DO",
+  /*   63 */ "FOR",
+  /*   64 */ "IGNORE",
+  /*   65 */ "INITIALLY",
+  /*   66 */ "INSTEAD",
+  /*   67 */ "NO",
+  /*   68 */ "KEY",
+  /*   69 */ "OF",
+  /*   70 */ "OFFSET",
+  /*   71 */ "PRAGMA",
+  /*   72 */ "RAISE",
+  /*   73 */ "RECURSIVE",
+  /*   74 */ "REPLACE",
+  /*   75 */ "RESTRICT",
+  /*   76 */ "ROW",
+  /*   77 */ "ROWS",
+  /*   78 */ "TRIGGER",
+  /*   79 */ "VACUUM",
+  /*   80 */ "VIEW",
+  /*   81 */ "VIRTUAL",
+  /*   82 */ "WITH",
+  /*   83 */ "NULLS",
+  /*   84 */ "FIRST",
+  /*   85 */ "LAST",
+  /*   86 */ "CURRENT",
+  /*   87 */ "FOLLOWING",
+  /*   88 */ "PARTITION",
+  /*   89 */ "PRECEDING",
+  /*   90 */ "RANGE",
+  /*   91 */ "UNBOUNDED",
+  /*   92 */ "EXCLUDE",
+  /*   93 */ "GROUPS",
+  /*   94 */ "OTHERS",
+  /*   95 */ "TIES",
+  /*   96 */ "GENERATED",
+  /*   97 */ "ALWAYS",
+  /*   98 */ "MATERIALIZED",
+  /*   99 */ "REINDEX",
+  /*  100 */ "RENAME",
+  /*  101 */ "CTIME_KW",
+  /*  102 */ "ANY",
+  /*  103 */ "BITAND",
+  /*  104 */ "BITOR",
+  /*  105 */ "LSHIFT",
+  /*  106 */ "RSHIFT",
+  /*  107 */ "PLUS",
+  /*  108 */ "MINUS",
+  /*  109 */ "STAR",
+  /*  110 */ "SLASH",
+  /*  111 */ "REM",
+  /*  112 */ "CONCAT",
+  /*  113 */ "PTR",
+  /*  114 */ "COLLATE",
+  /*  115 */ "BITNOT",
+  /*  116 */ "ON",
+  /*  117 */ "INDEXED",
+  /*  118 */ "STRING",
+  /*  119 */ "JOIN_KW",
+  /*  120 */ "CONSTRAINT",
+  /*  121 */ "DEFAULT",
+  /*  122 */ "NULL",
+  /*  123 */ "PRIMARY",
+  /*  124 */ "UNIQUE",
+  /*  125 */ "CHECK",
+  /*  126 */ "REFERENCES",
+  /*  127 */ "AUTOINCR",
+  /*  128 */ "INSERT",
+  /*  129 */ "DELETE",
+  /*  130 */ "UPDATE",
+  /*  131 */ "SET",
+  /*  132 */ "DEFERRABLE",
+  /*  133 */ "FOREIGN",
+  /*  134 */ "DROP",
+  /*  135 */ "UNION",
+  /*  136 */ "ALL",
+  /*  137 */ "EXCEPT",
+  /*  138 */ "INTERSECT",
+  /*  139 */ "SELECT",
+  /*  140 */ "VALUES",
+  /*  141 */ "DISTINCT",
+  /*  142 */ "DOT",
+  /*  143 */ "FROM",
+  /*  144 */ "JOIN",
+  /*  145 */ "USING",
+  /*  146 */ "ORDER",
+  /*  147 */ "GROUP",
+  /*  148 */ "HAVING",
+  /*  149 */ "LIMIT",
+  /*  150 */ "WHERE",
+  /*  151 */ "RETURNING",
+  /*  152 */ "INTO",
+  /*  153 */ "NOTHING",
+  /*  154 */ "FLOAT",
+  /*  155 */ "BLOB",
+  /*  156 */ "INTEGER",
+  /*  157 */ "VARIABLE",
+  /*  158 */ "CASE",
+  /*  159 */ "WHEN",
+  /*  160 */ "THEN",
+  /*  161 */ "ELSE",
+  /*  162 */ "INDEX",
+  /*  163 */ "ALTER",
+  /*  164 */ "ADD",
+  /*  165 */ "WINDOW",
+  /*  166 */ "OVER",
+  /*  167 */ "FILTER",
+  /*  168 */ "COLUMN",
+  /*  169 */ "AGG_FUNCTION",
+  /*  170 */ "AGG_COLUMN",
+  /*  171 */ "TRUEFALSE",
   /*  172 */ "FUNCTION",
-  /*  173 */ "UMINUS",
-  /*  174 */ "UPLUS",
+  /*  173 */ "UPLUS",
+  /*  174 */ "UMINUS",
   /*  175 */ "TRUTH",
   /*  176 */ "REGISTER",
   /*  177 */ "VECTOR",
@@ -172568,142 +175520,145 @@ static const char *const yyTokenName[] = {
   /*  180 */ "ASTERISK",
   /*  181 */ "SPAN",
   /*  182 */ "ERROR",
-  /*  183 */ "SPACE",
-  /*  184 */ "ILLEGAL",
-  /*  185 */ "input",
-  /*  186 */ "cmdlist",
-  /*  187 */ "ecmd",
-  /*  188 */ "cmdx",
-  /*  189 */ "explain",
-  /*  190 */ "cmd",
-  /*  191 */ "transtype",
-  /*  192 */ "trans_opt",
-  /*  193 */ "nm",
-  /*  194 */ "savepoint_opt",
-  /*  195 */ "create_table",
-  /*  196 */ "create_table_args",
-  /*  197 */ "createkw",
-  /*  198 */ "temp",
-  /*  199 */ "ifnotexists",
-  /*  200 */ "dbnm",
-  /*  201 */ "columnlist",
-  /*  202 */ "conslist_opt",
-  /*  203 */ "table_option_set",
-  /*  204 */ "select",
-  /*  205 */ "table_option",
-  /*  206 */ "columnname",
-  /*  207 */ "carglist",
-  /*  208 */ "typetoken",
-  /*  209 */ "typename",
-  /*  210 */ "signed",
-  /*  211 */ "plus_num",
-  /*  212 */ "minus_num",
-  /*  213 */ "scanpt",
-  /*  214 */ "scantok",
-  /*  215 */ "ccons",
-  /*  216 */ "term",
-  /*  217 */ "expr",
-  /*  218 */ "onconf",
-  /*  219 */ "sortorder",
-  /*  220 */ "autoinc",
-  /*  221 */ "eidlist_opt",
-  /*  222 */ "refargs",
-  /*  223 */ "defer_subclause",
-  /*  224 */ "generated",
-  /*  225 */ "refarg",
-  /*  226 */ "refact",
-  /*  227 */ "init_deferred_pred_opt",
-  /*  228 */ "conslist",
-  /*  229 */ "tconscomma",
-  /*  230 */ "tcons",
-  /*  231 */ "sortlist",
-  /*  232 */ "eidlist",
-  /*  233 */ "defer_subclause_opt",
-  /*  234 */ "orconf",
-  /*  235 */ "resolvetype",
-  /*  236 */ "raisetype",
-  /*  237 */ "ifexists",
-  /*  238 */ "fullname",
-  /*  239 */ "selectnowith",
-  /*  240 */ "oneselect",
-  /*  241 */ "wqlist",
-  /*  242 */ "multiselect_op",
-  /*  243 */ "distinct",
-  /*  244 */ "selcollist",
-  /*  245 */ "from",
-  /*  246 */ "where_opt",
-  /*  247 */ "groupby_opt",
-  /*  248 */ "having_opt",
-  /*  249 */ "orderby_opt",
-  /*  250 */ "limit_opt",
-  /*  251 */ "window_clause",
-  /*  252 */ "values",
-  /*  253 */ "nexprlist",
-  /*  254 */ "sclp",
-  /*  255 */ "as",
-  /*  256 */ "seltablist",
-  /*  257 */ "stl_prefix",
-  /*  258 */ "joinop",
-  /*  259 */ "on_using",
-  /*  260 */ "indexed_by",
-  /*  261 */ "exprlist",
-  /*  262 */ "xfullname",
-  /*  263 */ "idlist",
-  /*  264 */ "indexed_opt",
-  /*  265 */ "nulls",
-  /*  266 */ "with",
-  /*  267 */ "where_opt_ret",
-  /*  268 */ "setlist",
-  /*  269 */ "insert_cmd",
-  /*  270 */ "idlist_opt",
-  /*  271 */ "upsert",
-  /*  272 */ "returning",
-  /*  273 */ "filter_over",
-  /*  274 */ "likeop",
-  /*  275 */ "between_op",
-  /*  276 */ "in_op",
-  /*  277 */ "paren_exprlist",
-  /*  278 */ "case_operand",
-  /*  279 */ "case_exprlist",
-  /*  280 */ "case_else",
-  /*  281 */ "uniqueflag",
-  /*  282 */ "collate",
-  /*  283 */ "vinto",
-  /*  284 */ "nmnum",
-  /*  285 */ "trigger_decl",
-  /*  286 */ "trigger_cmd_list",
-  /*  287 */ "trigger_time",
-  /*  288 */ "trigger_event",
-  /*  289 */ "foreach_clause",
-  /*  290 */ "when_clause",
-  /*  291 */ "trigger_cmd",
-  /*  292 */ "trnm",
-  /*  293 */ "tridxby",
-  /*  294 */ "database_kw_opt",
-  /*  295 */ "key_opt",
-  /*  296 */ "add_column_fullname",
-  /*  297 */ "kwcolumn_opt",
-  /*  298 */ "create_vtab",
-  /*  299 */ "vtabarglist",
-  /*  300 */ "vtabarg",
-  /*  301 */ "vtabargtoken",
-  /*  302 */ "lp",
-  /*  303 */ "anylist",
-  /*  304 */ "wqitem",
-  /*  305 */ "wqas",
-  /*  306 */ "windowdefn_list",
-  /*  307 */ "windowdefn",
-  /*  308 */ "window",
-  /*  309 */ "frame_opt",
-  /*  310 */ "part_opt",
-  /*  311 */ "filter_clause",
-  /*  312 */ "over_clause",
-  /*  313 */ "range_or_rows",
-  /*  314 */ "frame_bound",
-  /*  315 */ "frame_bound_s",
-  /*  316 */ "frame_bound_e",
-  /*  317 */ "frame_exclude_opt",
-  /*  318 */ "frame_exclude",
+  /*  183 */ "QNUMBER",
+  /*  184 */ "SPACE",
+  /*  185 */ "ILLEGAL",
+  /*  186 */ "input",
+  /*  187 */ "cmdlist",
+  /*  188 */ "ecmd",
+  /*  189 */ "cmdx",
+  /*  190 */ "explain",
+  /*  191 */ "cmd",
+  /*  192 */ "transtype",
+  /*  193 */ "trans_opt",
+  /*  194 */ "nm",
+  /*  195 */ "savepoint_opt",
+  /*  196 */ "create_table",
+  /*  197 */ "create_table_args",
+  /*  198 */ "createkw",
+  /*  199 */ "temp",
+  /*  200 */ "ifnotexists",
+  /*  201 */ "dbnm",
+  /*  202 */ "columnlist",
+  /*  203 */ "conslist_opt",
+  /*  204 */ "table_option_set",
+  /*  205 */ "select",
+  /*  206 */ "table_option",
+  /*  207 */ "columnname",
+  /*  208 */ "carglist",
+  /*  209 */ "typetoken",
+  /*  210 */ "typename",
+  /*  211 */ "signed",
+  /*  212 */ "plus_num",
+  /*  213 */ "minus_num",
+  /*  214 */ "scanpt",
+  /*  215 */ "scantok",
+  /*  216 */ "ccons",
+  /*  217 */ "term",
+  /*  218 */ "expr",
+  /*  219 */ "onconf",
+  /*  220 */ "sortorder",
+  /*  221 */ "autoinc",
+  /*  222 */ "eidlist_opt",
+  /*  223 */ "refargs",
+  /*  224 */ "defer_subclause",
+  /*  225 */ "generated",
+  /*  226 */ "refarg",
+  /*  227 */ "refact",
+  /*  228 */ "init_deferred_pred_opt",
+  /*  229 */ "conslist",
+  /*  230 */ "tconscomma",
+  /*  231 */ "tcons",
+  /*  232 */ "sortlist",
+  /*  233 */ "eidlist",
+  /*  234 */ "defer_subclause_opt",
+  /*  235 */ "orconf",
+  /*  236 */ "resolvetype",
+  /*  237 */ "raisetype",
+  /*  238 */ "ifexists",
+  /*  239 */ "fullname",
+  /*  240 */ "selectnowith",
+  /*  241 */ "oneselect",
+  /*  242 */ "wqlist",
+  /*  243 */ "multiselect_op",
+  /*  244 */ "distinct",
+  /*  245 */ "selcollist",
+  /*  246 */ "from",
+  /*  247 */ "where_opt",
+  /*  248 */ "groupby_opt",
+  /*  249 */ "having_opt",
+  /*  250 */ "orderby_opt",
+  /*  251 */ "limit_opt",
+  /*  252 */ "window_clause",
+  /*  253 */ "values",
+  /*  254 */ "nexprlist",
+  /*  255 */ "mvalues",
+  /*  256 */ "sclp",
+  /*  257 */ "as",
+  /*  258 */ "seltablist",
+  /*  259 */ "stl_prefix",
+  /*  260 */ "joinop",
+  /*  261 */ "on_using",
+  /*  262 */ "indexed_by",
+  /*  263 */ "exprlist",
+  /*  264 */ "xfullname",
+  /*  265 */ "idlist",
+  /*  266 */ "indexed_opt",
+  /*  267 */ "nulls",
+  /*  268 */ "with",
+  /*  269 */ "where_opt_ret",
+  /*  270 */ "setlist",
+  /*  271 */ "insert_cmd",
+  /*  272 */ "idlist_opt",
+  /*  273 */ "upsert",
+  /*  274 */ "returning",
+  /*  275 */ "filter_over",
+  /*  276 */ "likeop",
+  /*  277 */ "between_op",
+  /*  278 */ "in_op",
+  /*  279 */ "paren_exprlist",
+  /*  280 */ "case_operand",
+  /*  281 */ "case_exprlist",
+  /*  282 */ "case_else",
+  /*  283 */ "uniqueflag",
+  /*  284 */ "collate",
+  /*  285 */ "vinto",
+  /*  286 */ "nmnum",
+  /*  287 */ "trigger_decl",
+  /*  288 */ "trigger_cmd_list",
+  /*  289 */ "trigger_time",
+  /*  290 */ "trigger_event",
+  /*  291 */ "foreach_clause",
+  /*  292 */ "when_clause",
+  /*  293 */ "trigger_cmd",
+  /*  294 */ "trnm",
+  /*  295 */ "tridxby",
+  /*  296 */ "database_kw_opt",
+  /*  297 */ "key_opt",
+  /*  298 */ "add_column_fullname",
+  /*  299 */ "kwcolumn_opt",
+  /*  300 */ "create_vtab",
+  /*  301 */ "vtabarglist",
+  /*  302 */ "vtabarg",
+  /*  303 */ "vtabargtoken",
+  /*  304 */ "lp",
+  /*  305 */ "anylist",
+  /*  306 */ "wqitem",
+  /*  307 */ "wqas",
+  /*  308 */ "withnm",
+  /*  309 */ "windowdefn_list",
+  /*  310 */ "windowdefn",
+  /*  311 */ "window",
+  /*  312 */ "frame_opt",
+  /*  313 */ "part_opt",
+  /*  314 */ "filter_clause",
+  /*  315 */ "over_clause",
+  /*  316 */ "range_or_rows",
+  /*  317 */ "frame_bound",
+  /*  318 */ "frame_bound_s",
+  /*  319 */ "frame_bound_e",
+  /*  320 */ "frame_exclude_opt",
+  /*  321 */ "frame_exclude",
 };
 #endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */
 
@@ -172806,351 +175761,363 @@ static const char *const yyRuleName[] = {
  /*  92 */ "oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt",
  /*  93 */ "oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt",
  /*  94 */ "values ::= VALUES LP nexprlist RP",
- /*  95 */ "values ::= values COMMA LP nexprlist RP",
- /*  96 */ "distinct ::= DISTINCT",
- /*  97 */ "distinct ::= ALL",
- /*  98 */ "distinct ::=",
- /*  99 */ "sclp ::=",
- /* 100 */ "selcollist ::= sclp scanpt expr scanpt as",
- /* 101 */ "selcollist ::= sclp scanpt STAR",
- /* 102 */ "selcollist ::= sclp scanpt nm DOT STAR",
- /* 103 */ "as ::= AS nm",
- /* 104 */ "as ::=",
- /* 105 */ "from ::=",
- /* 106 */ "from ::= FROM seltablist",
- /* 107 */ "stl_prefix ::= seltablist joinop",
- /* 108 */ "stl_prefix ::=",
- /* 109 */ "seltablist ::= stl_prefix nm dbnm as on_using",
- /* 110 */ "seltablist ::= stl_prefix nm dbnm as indexed_by on_using",
- /* 111 */ "seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using",
- /* 112 */ "seltablist ::= stl_prefix LP select RP as on_using",
- /* 113 */ "seltablist ::= stl_prefix LP seltablist RP as on_using",
- /* 114 */ "dbnm ::=",
- /* 115 */ "dbnm ::= DOT nm",
- /* 116 */ "fullname ::= nm",
- /* 117 */ "fullname ::= nm DOT nm",
- /* 118 */ "xfullname ::= nm",
- /* 119 */ "xfullname ::= nm DOT nm",
- /* 120 */ "xfullname ::= nm DOT nm AS nm",
- /* 121 */ "xfullname ::= nm AS nm",
- /* 122 */ "joinop ::= COMMA|JOIN",
- /* 123 */ "joinop ::= JOIN_KW JOIN",
- /* 124 */ "joinop ::= JOIN_KW nm JOIN",
- /* 125 */ "joinop ::= JOIN_KW nm nm JOIN",
- /* 126 */ "on_using ::= ON expr",
- /* 127 */ "on_using ::= USING LP idlist RP",
- /* 128 */ "on_using ::=",
- /* 129 */ "indexed_opt ::=",
- /* 130 */ "indexed_by ::= INDEXED BY nm",
- /* 131 */ "indexed_by ::= NOT INDEXED",
- /* 132 */ "orderby_opt ::=",
- /* 133 */ "orderby_opt ::= ORDER BY sortlist",
- /* 134 */ "sortlist ::= sortlist COMMA expr sortorder nulls",
- /* 135 */ "sortlist ::= expr sortorder nulls",
- /* 136 */ "sortorder ::= ASC",
- /* 137 */ "sortorder ::= DESC",
- /* 138 */ "sortorder ::=",
- /* 139 */ "nulls ::= NULLS FIRST",
- /* 140 */ "nulls ::= NULLS LAST",
- /* 141 */ "nulls ::=",
- /* 142 */ "groupby_opt ::=",
- /* 143 */ "groupby_opt ::= GROUP BY nexprlist",
- /* 144 */ "having_opt ::=",
- /* 145 */ "having_opt ::= HAVING expr",
- /* 146 */ "limit_opt ::=",
- /* 147 */ "limit_opt ::= LIMIT expr",
- /* 148 */ "limit_opt ::= LIMIT expr OFFSET expr",
- /* 149 */ "limit_opt ::= LIMIT expr COMMA expr",
- /* 150 */ "cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret",
- /* 151 */ "where_opt ::=",
- /* 152 */ "where_opt ::= WHERE expr",
- /* 153 */ "where_opt_ret ::=",
- /* 154 */ "where_opt_ret ::= WHERE expr",
- /* 155 */ "where_opt_ret ::= RETURNING selcollist",
- /* 156 */ "where_opt_ret ::= WHERE expr RETURNING selcollist",
- /* 157 */ "cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret",
- /* 158 */ "setlist ::= setlist COMMA nm EQ expr",
- /* 159 */ "setlist ::= setlist COMMA LP idlist RP EQ expr",
- /* 160 */ "setlist ::= nm EQ expr",
- /* 161 */ "setlist ::= LP idlist RP EQ expr",
- /* 162 */ "cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert",
- /* 163 */ "cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning",
- /* 164 */ "upsert ::=",
- /* 165 */ "upsert ::= RETURNING selcollist",
- /* 166 */ "upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert",
- /* 167 */ "upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert",
- /* 168 */ "upsert ::= ON CONFLICT DO NOTHING returning",
- /* 169 */ "upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning",
- /* 170 */ "returning ::= RETURNING selcollist",
- /* 171 */ "insert_cmd ::= INSERT orconf",
- /* 172 */ "insert_cmd ::= REPLACE",
- /* 173 */ "idlist_opt ::=",
- /* 174 */ "idlist_opt ::= LP idlist RP",
- /* 175 */ "idlist ::= idlist COMMA nm",
- /* 176 */ "idlist ::= nm",
- /* 177 */ "expr ::= LP expr RP",
- /* 178 */ "expr ::= ID|INDEXED|JOIN_KW",
- /* 179 */ "expr ::= nm DOT nm",
- /* 180 */ "expr ::= nm DOT nm DOT nm",
- /* 181 */ "term ::= NULL|FLOAT|BLOB",
- /* 182 */ "term ::= STRING",
- /* 183 */ "term ::= INTEGER",
- /* 184 */ "expr ::= VARIABLE",
- /* 185 */ "expr ::= expr COLLATE ID|STRING",
- /* 186 */ "expr ::= CAST LP expr AS typetoken RP",
- /* 187 */ "expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP",
- /* 188 */ "expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP",
- /* 189 */ "expr ::= ID|INDEXED|JOIN_KW LP STAR RP",
- /* 190 */ "expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over",
- /* 191 */ "expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP filter_over",
- /* 192 */ "expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over",
- /* 193 */ "term ::= CTIME_KW",
- /* 194 */ "expr ::= LP nexprlist COMMA expr RP",
- /* 195 */ "expr ::= expr AND expr",
- /* 196 */ "expr ::= expr OR expr",
- /* 197 */ "expr ::= expr LT|GT|GE|LE expr",
- /* 198 */ "expr ::= expr EQ|NE expr",
- /* 199 */ "expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr",
- /* 200 */ "expr ::= expr PLUS|MINUS expr",
- /* 201 */ "expr ::= expr STAR|SLASH|REM expr",
- /* 202 */ "expr ::= expr CONCAT expr",
- /* 203 */ "likeop ::= NOT LIKE_KW|MATCH",
- /* 204 */ "expr ::= expr likeop expr",
- /* 205 */ "expr ::= expr likeop expr ESCAPE expr",
- /* 206 */ "expr ::= expr ISNULL|NOTNULL",
- /* 207 */ "expr ::= expr NOT NULL",
- /* 208 */ "expr ::= expr IS expr",
- /* 209 */ "expr ::= expr IS NOT expr",
- /* 210 */ "expr ::= expr IS NOT DISTINCT FROM expr",
- /* 211 */ "expr ::= expr IS DISTINCT FROM expr",
- /* 212 */ "expr ::= NOT expr",
- /* 213 */ "expr ::= BITNOT expr",
- /* 214 */ "expr ::= PLUS|MINUS expr",
- /* 215 */ "expr ::= expr PTR expr",
- /* 216 */ "between_op ::= BETWEEN",
- /* 217 */ "between_op ::= NOT BETWEEN",
- /* 218 */ "expr ::= expr between_op expr AND expr",
- /* 219 */ "in_op ::= IN",
- /* 220 */ "in_op ::= NOT IN",
- /* 221 */ "expr ::= expr in_op LP exprlist RP",
- /* 222 */ "expr ::= LP select RP",
- /* 223 */ "expr ::= expr in_op LP select RP",
- /* 224 */ "expr ::= expr in_op nm dbnm paren_exprlist",
- /* 225 */ "expr ::= EXISTS LP select RP",
- /* 226 */ "expr ::= CASE case_operand case_exprlist case_else END",
- /* 227 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr",
- /* 228 */ "case_exprlist ::= WHEN expr THEN expr",
- /* 229 */ "case_else ::= ELSE expr",
- /* 230 */ "case_else ::=",
- /* 231 */ "case_operand ::=",
- /* 232 */ "exprlist ::=",
- /* 233 */ "nexprlist ::= nexprlist COMMA expr",
- /* 234 */ "nexprlist ::= expr",
- /* 235 */ "paren_exprlist ::=",
- /* 236 */ "paren_exprlist ::= LP exprlist RP",
- /* 237 */ "cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt",
- /* 238 */ "uniqueflag ::= UNIQUE",
- /* 239 */ "uniqueflag ::=",
- /* 240 */ "eidlist_opt ::=",
- /* 241 */ "eidlist_opt ::= LP eidlist RP",
- /* 242 */ "eidlist ::= eidlist COMMA nm collate sortorder",
- /* 243 */ "eidlist ::= nm collate sortorder",
- /* 244 */ "collate ::=",
- /* 245 */ "collate ::= COLLATE ID|STRING",
- /* 246 */ "cmd ::= DROP INDEX ifexists fullname",
- /* 247 */ "cmd ::= VACUUM vinto",
- /* 248 */ "cmd ::= VACUUM nm vinto",
- /* 249 */ "vinto ::= INTO expr",
- /* 250 */ "vinto ::=",
- /* 251 */ "cmd ::= PRAGMA nm dbnm",
- /* 252 */ "cmd ::= PRAGMA nm dbnm EQ nmnum",
- /* 253 */ "cmd ::= PRAGMA nm dbnm LP nmnum RP",
- /* 254 */ "cmd ::= PRAGMA nm dbnm EQ minus_num",
- /* 255 */ "cmd ::= PRAGMA nm dbnm LP minus_num RP",
- /* 256 */ "plus_num ::= PLUS INTEGER|FLOAT",
- /* 257 */ "minus_num ::= MINUS INTEGER|FLOAT",
- /* 258 */ "cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END",
- /* 259 */ "trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause",
- /* 260 */ "trigger_time ::= BEFORE|AFTER",
- /* 261 */ "trigger_time ::= INSTEAD OF",
- /* 262 */ "trigger_time ::=",
- /* 263 */ "trigger_event ::= DELETE|INSERT",
- /* 264 */ "trigger_event ::= UPDATE",
- /* 265 */ "trigger_event ::= UPDATE OF idlist",
- /* 266 */ "when_clause ::=",
- /* 267 */ "when_clause ::= WHEN expr",
- /* 268 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI",
- /* 269 */ "trigger_cmd_list ::= trigger_cmd SEMI",
- /* 270 */ "trnm ::= nm DOT nm",
- /* 271 */ "tridxby ::= INDEXED BY nm",
- /* 272 */ "tridxby ::= NOT INDEXED",
- /* 273 */ "trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt",
- /* 274 */ "trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt",
- /* 275 */ "trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt",
- /* 276 */ "trigger_cmd ::= scanpt select scanpt",
- /* 277 */ "expr ::= RAISE LP IGNORE RP",
- /* 278 */ "expr ::= RAISE LP raisetype COMMA nm RP",
- /* 279 */ "raisetype ::= ROLLBACK",
- /* 280 */ "raisetype ::= ABORT",
- /* 281 */ "raisetype ::= FAIL",
- /* 282 */ "cmd ::= DROP TRIGGER ifexists fullname",
- /* 283 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt",
- /* 284 */ "cmd ::= DETACH database_kw_opt expr",
- /* 285 */ "key_opt ::=",
- /* 286 */ "key_opt ::= KEY expr",
- /* 287 */ "cmd ::= REINDEX",
- /* 288 */ "cmd ::= REINDEX nm dbnm",
- /* 289 */ "cmd ::= ANALYZE",
- /* 290 */ "cmd ::= ANALYZE nm dbnm",
- /* 291 */ "cmd ::= ALTER TABLE fullname RENAME TO nm",
- /* 292 */ "cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist",
- /* 293 */ "cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm",
- /* 294 */ "add_column_fullname ::= fullname",
- /* 295 */ "cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm",
- /* 296 */ "cmd ::= create_vtab",
- /* 297 */ "cmd ::= create_vtab LP vtabarglist RP",
- /* 298 */ "create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm",
- /* 299 */ "vtabarg ::=",
- /* 300 */ "vtabargtoken ::= ANY",
- /* 301 */ "vtabargtoken ::= lp anylist RP",
- /* 302 */ "lp ::= LP",
- /* 303 */ "with ::= WITH wqlist",
- /* 304 */ "with ::= WITH RECURSIVE wqlist",
- /* 305 */ "wqas ::= AS",
- /* 306 */ "wqas ::= AS MATERIALIZED",
- /* 307 */ "wqas ::= AS NOT MATERIALIZED",
- /* 308 */ "wqitem ::= nm eidlist_opt wqas LP select RP",
- /* 309 */ "wqlist ::= wqitem",
- /* 310 */ "wqlist ::= wqlist COMMA wqitem",
- /* 311 */ "windowdefn_list ::= windowdefn_list COMMA windowdefn",
- /* 312 */ "windowdefn ::= nm AS LP window RP",
- /* 313 */ "window ::= PARTITION BY nexprlist orderby_opt frame_opt",
- /* 314 */ "window ::= nm PARTITION BY nexprlist orderby_opt frame_opt",
- /* 315 */ "window ::= ORDER BY sortlist frame_opt",
- /* 316 */ "window ::= nm ORDER BY sortlist frame_opt",
- /* 317 */ "window ::= nm frame_opt",
- /* 318 */ "frame_opt ::=",
- /* 319 */ "frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt",
- /* 320 */ "frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt",
- /* 321 */ "range_or_rows ::= RANGE|ROWS|GROUPS",
- /* 322 */ "frame_bound_s ::= frame_bound",
- /* 323 */ "frame_bound_s ::= UNBOUNDED PRECEDING",
- /* 324 */ "frame_bound_e ::= frame_bound",
- /* 325 */ "frame_bound_e ::= UNBOUNDED FOLLOWING",
- /* 326 */ "frame_bound ::= expr PRECEDING|FOLLOWING",
- /* 327 */ "frame_bound ::= CURRENT ROW",
- /* 328 */ "frame_exclude_opt ::=",
- /* 329 */ "frame_exclude_opt ::= EXCLUDE frame_exclude",
- /* 330 */ "frame_exclude ::= NO OTHERS",
- /* 331 */ "frame_exclude ::= CURRENT ROW",
- /* 332 */ "frame_exclude ::= GROUP|TIES",
- /* 333 */ "window_clause ::= WINDOW windowdefn_list",
- /* 334 */ "filter_over ::= filter_clause over_clause",
- /* 335 */ "filter_over ::= over_clause",
- /* 336 */ "filter_over ::= filter_clause",
- /* 337 */ "over_clause ::= OVER LP window RP",
- /* 338 */ "over_clause ::= OVER nm",
- /* 339 */ "filter_clause ::= FILTER LP WHERE expr RP",
- /* 340 */ "input ::= cmdlist",
- /* 341 */ "cmdlist ::= cmdlist ecmd",
- /* 342 */ "cmdlist ::= ecmd",
- /* 343 */ "ecmd ::= SEMI",
- /* 344 */ "ecmd ::= cmdx SEMI",
- /* 345 */ "ecmd ::= explain cmdx SEMI",
- /* 346 */ "trans_opt ::=",
- /* 347 */ "trans_opt ::= TRANSACTION",
- /* 348 */ "trans_opt ::= TRANSACTION nm",
- /* 349 */ "savepoint_opt ::= SAVEPOINT",
- /* 350 */ "savepoint_opt ::=",
- /* 351 */ "cmd ::= create_table create_table_args",
- /* 352 */ "table_option_set ::= table_option",
- /* 353 */ "columnlist ::= columnlist COMMA columnname carglist",
- /* 354 */ "columnlist ::= columnname carglist",
- /* 355 */ "nm ::= ID|INDEXED|JOIN_KW",
- /* 356 */ "nm ::= STRING",
- /* 357 */ "typetoken ::= typename",
- /* 358 */ "typename ::= ID|STRING",
- /* 359 */ "signed ::= plus_num",
- /* 360 */ "signed ::= minus_num",
- /* 361 */ "carglist ::= carglist ccons",
- /* 362 */ "carglist ::=",
- /* 363 */ "ccons ::= NULL onconf",
- /* 364 */ "ccons ::= GENERATED ALWAYS AS generated",
- /* 365 */ "ccons ::= AS generated",
- /* 366 */ "conslist_opt ::= COMMA conslist",
- /* 367 */ "conslist ::= conslist tconscomma tcons",
- /* 368 */ "conslist ::= tcons",
- /* 369 */ "tconscomma ::=",
- /* 370 */ "defer_subclause_opt ::= defer_subclause",
- /* 371 */ "resolvetype ::= raisetype",
- /* 372 */ "selectnowith ::= oneselect",
- /* 373 */ "oneselect ::= values",
- /* 374 */ "sclp ::= selcollist COMMA",
- /* 375 */ "as ::= ID|STRING",
- /* 376 */ "indexed_opt ::= indexed_by",
- /* 377 */ "returning ::=",
- /* 378 */ "expr ::= term",
- /* 379 */ "likeop ::= LIKE_KW|MATCH",
- /* 380 */ "case_operand ::= expr",
- /* 381 */ "exprlist ::= nexprlist",
- /* 382 */ "nmnum ::= plus_num",
- /* 383 */ "nmnum ::= nm",
- /* 384 */ "nmnum ::= ON",
- /* 385 */ "nmnum ::= DELETE",
- /* 386 */ "nmnum ::= DEFAULT",
- /* 387 */ "plus_num ::= INTEGER|FLOAT",
- /* 388 */ "foreach_clause ::=",
- /* 389 */ "foreach_clause ::= FOR EACH ROW",
- /* 390 */ "trnm ::= nm",
- /* 391 */ "tridxby ::=",
- /* 392 */ "database_kw_opt ::= DATABASE",
- /* 393 */ "database_kw_opt ::=",
- /* 394 */ "kwcolumn_opt ::=",
- /* 395 */ "kwcolumn_opt ::= COLUMNKW",
- /* 396 */ "vtabarglist ::= vtabarg",
- /* 397 */ "vtabarglist ::= vtabarglist COMMA vtabarg",
- /* 398 */ "vtabarg ::= vtabarg vtabargtoken",
- /* 399 */ "anylist ::=",
- /* 400 */ "anylist ::= anylist LP anylist RP",
- /* 401 */ "anylist ::= anylist ANY",
- /* 402 */ "with ::=",
- /* 403 */ "windowdefn_list ::= windowdefn",
- /* 404 */ "window ::= frame_opt",
+ /*  95 */ "oneselect ::= mvalues",
+ /*  96 */ "mvalues ::= values COMMA LP nexprlist RP",
+ /*  97 */ "mvalues ::= mvalues COMMA LP nexprlist RP",
+ /*  98 */ "distinct ::= DISTINCT",
+ /*  99 */ "distinct ::= ALL",
+ /* 100 */ "distinct ::=",
+ /* 101 */ "sclp ::=",
+ /* 102 */ "selcollist ::= sclp scanpt expr scanpt as",
+ /* 103 */ "selcollist ::= sclp scanpt STAR",
+ /* 104 */ "selcollist ::= sclp scanpt nm DOT STAR",
+ /* 105 */ "as ::= AS nm",
+ /* 106 */ "as ::=",
+ /* 107 */ "from ::=",
+ /* 108 */ "from ::= FROM seltablist",
+ /* 109 */ "stl_prefix ::= seltablist joinop",
+ /* 110 */ "stl_prefix ::=",
+ /* 111 */ "seltablist ::= stl_prefix nm dbnm as on_using",
+ /* 112 */ "seltablist ::= stl_prefix nm dbnm as indexed_by on_using",
+ /* 113 */ "seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using",
+ /* 114 */ "seltablist ::= stl_prefix LP select RP as on_using",
+ /* 115 */ "seltablist ::= stl_prefix LP seltablist RP as on_using",
+ /* 116 */ "dbnm ::=",
+ /* 117 */ "dbnm ::= DOT nm",
+ /* 118 */ "fullname ::= nm",
+ /* 119 */ "fullname ::= nm DOT nm",
+ /* 120 */ "xfullname ::= nm",
+ /* 121 */ "xfullname ::= nm DOT nm",
+ /* 122 */ "xfullname ::= nm DOT nm AS nm",
+ /* 123 */ "xfullname ::= nm AS nm",
+ /* 124 */ "joinop ::= COMMA|JOIN",
+ /* 125 */ "joinop ::= JOIN_KW JOIN",
+ /* 126 */ "joinop ::= JOIN_KW nm JOIN",
+ /* 127 */ "joinop ::= JOIN_KW nm nm JOIN",
+ /* 128 */ "on_using ::= ON expr",
+ /* 129 */ "on_using ::= USING LP idlist RP",
+ /* 130 */ "on_using ::=",
+ /* 131 */ "indexed_opt ::=",
+ /* 132 */ "indexed_by ::= INDEXED BY nm",
+ /* 133 */ "indexed_by ::= NOT INDEXED",
+ /* 134 */ "orderby_opt ::=",
+ /* 135 */ "orderby_opt ::= ORDER BY sortlist",
+ /* 136 */ "sortlist ::= sortlist COMMA expr sortorder nulls",
+ /* 137 */ "sortlist ::= expr sortorder nulls",
+ /* 138 */ "sortorder ::= ASC",
+ /* 139 */ "sortorder ::= DESC",
+ /* 140 */ "sortorder ::=",
+ /* 141 */ "nulls ::= NULLS FIRST",
+ /* 142 */ "nulls ::= NULLS LAST",
+ /* 143 */ "nulls ::=",
+ /* 144 */ "groupby_opt ::=",
+ /* 145 */ "groupby_opt ::= GROUP BY nexprlist",
+ /* 146 */ "having_opt ::=",
+ /* 147 */ "having_opt ::= HAVING expr",
+ /* 148 */ "limit_opt ::=",
+ /* 149 */ "limit_opt ::= LIMIT expr",
+ /* 150 */ "limit_opt ::= LIMIT expr OFFSET expr",
+ /* 151 */ "limit_opt ::= LIMIT expr COMMA expr",
+ /* 152 */ "cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret",
+ /* 153 */ "where_opt ::=",
+ /* 154 */ "where_opt ::= WHERE expr",
+ /* 155 */ "where_opt_ret ::=",
+ /* 156 */ "where_opt_ret ::= WHERE expr",
+ /* 157 */ "where_opt_ret ::= RETURNING selcollist",
+ /* 158 */ "where_opt_ret ::= WHERE expr RETURNING selcollist",
+ /* 159 */ "cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret",
+ /* 160 */ "setlist ::= setlist COMMA nm EQ expr",
+ /* 161 */ "setlist ::= setlist COMMA LP idlist RP EQ expr",
+ /* 162 */ "setlist ::= nm EQ expr",
+ /* 163 */ "setlist ::= LP idlist RP EQ expr",
+ /* 164 */ "cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert",
+ /* 165 */ "cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning",
+ /* 166 */ "upsert ::=",
+ /* 167 */ "upsert ::= RETURNING selcollist",
+ /* 168 */ "upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert",
+ /* 169 */ "upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert",
+ /* 170 */ "upsert ::= ON CONFLICT DO NOTHING returning",
+ /* 171 */ "upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning",
+ /* 172 */ "returning ::= RETURNING selcollist",
+ /* 173 */ "insert_cmd ::= INSERT orconf",
+ /* 174 */ "insert_cmd ::= REPLACE",
+ /* 175 */ "idlist_opt ::=",
+ /* 176 */ "idlist_opt ::= LP idlist RP",
+ /* 177 */ "idlist ::= idlist COMMA nm",
+ /* 178 */ "idlist ::= nm",
+ /* 179 */ "expr ::= LP expr RP",
+ /* 180 */ "expr ::= ID|INDEXED|JOIN_KW",
+ /* 181 */ "expr ::= nm DOT nm",
+ /* 182 */ "expr ::= nm DOT nm DOT nm",
+ /* 183 */ "term ::= NULL|FLOAT|BLOB",
+ /* 184 */ "term ::= STRING",
+ /* 185 */ "term ::= INTEGER",
+ /* 186 */ "expr ::= VARIABLE",
+ /* 187 */ "expr ::= expr COLLATE ID|STRING",
+ /* 188 */ "expr ::= CAST LP expr AS typetoken RP",
+ /* 189 */ "expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP",
+ /* 190 */ "expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP",
+ /* 191 */ "expr ::= ID|INDEXED|JOIN_KW LP STAR RP",
+ /* 192 */ "expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over",
+ /* 193 */ "expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP filter_over",
+ /* 194 */ "expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over",
+ /* 195 */ "term ::= CTIME_KW",
+ /* 196 */ "expr ::= LP nexprlist COMMA expr RP",
+ /* 197 */ "expr ::= expr AND expr",
+ /* 198 */ "expr ::= expr OR expr",
+ /* 199 */ "expr ::= expr LT|GT|GE|LE expr",
+ /* 200 */ "expr ::= expr EQ|NE expr",
+ /* 201 */ "expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr",
+ /* 202 */ "expr ::= expr PLUS|MINUS expr",
+ /* 203 */ "expr ::= expr STAR|SLASH|REM expr",
+ /* 204 */ "expr ::= expr CONCAT expr",
+ /* 205 */ "likeop ::= NOT LIKE_KW|MATCH",
+ /* 206 */ "expr ::= expr likeop expr",
+ /* 207 */ "expr ::= expr likeop expr ESCAPE expr",
+ /* 208 */ "expr ::= expr ISNULL|NOTNULL",
+ /* 209 */ "expr ::= expr NOT NULL",
+ /* 210 */ "expr ::= expr IS expr",
+ /* 211 */ "expr ::= expr IS NOT expr",
+ /* 212 */ "expr ::= expr IS NOT DISTINCT FROM expr",
+ /* 213 */ "expr ::= expr IS DISTINCT FROM expr",
+ /* 214 */ "expr ::= NOT expr",
+ /* 215 */ "expr ::= BITNOT expr",
+ /* 216 */ "expr ::= PLUS|MINUS expr",
+ /* 217 */ "expr ::= expr PTR expr",
+ /* 218 */ "between_op ::= BETWEEN",
+ /* 219 */ "between_op ::= NOT BETWEEN",
+ /* 220 */ "expr ::= expr between_op expr AND expr",
+ /* 221 */ "in_op ::= IN",
+ /* 222 */ "in_op ::= NOT IN",
+ /* 223 */ "expr ::= expr in_op LP exprlist RP",
+ /* 224 */ "expr ::= LP select RP",
+ /* 225 */ "expr ::= expr in_op LP select RP",
+ /* 226 */ "expr ::= expr in_op nm dbnm paren_exprlist",
+ /* 227 */ "expr ::= EXISTS LP select RP",
+ /* 228 */ "expr ::= CASE case_operand case_exprlist case_else END",
+ /* 229 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr",
+ /* 230 */ "case_exprlist ::= WHEN expr THEN expr",
+ /* 231 */ "case_else ::= ELSE expr",
+ /* 232 */ "case_else ::=",
+ /* 233 */ "case_operand ::=",
+ /* 234 */ "exprlist ::=",
+ /* 235 */ "nexprlist ::= nexprlist COMMA expr",
+ /* 236 */ "nexprlist ::= expr",
+ /* 237 */ "paren_exprlist ::=",
+ /* 238 */ "paren_exprlist ::= LP exprlist RP",
+ /* 239 */ "cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt",
+ /* 240 */ "uniqueflag ::= UNIQUE",
+ /* 241 */ "uniqueflag ::=",
+ /* 242 */ "eidlist_opt ::=",
+ /* 243 */ "eidlist_opt ::= LP eidlist RP",
+ /* 244 */ "eidlist ::= eidlist COMMA nm collate sortorder",
+ /* 245 */ "eidlist ::= nm collate sortorder",
+ /* 246 */ "collate ::=",
+ /* 247 */ "collate ::= COLLATE ID|STRING",
+ /* 248 */ "cmd ::= DROP INDEX ifexists fullname",
+ /* 249 */ "cmd ::= VACUUM vinto",
+ /* 250 */ "cmd ::= VACUUM nm vinto",
+ /* 251 */ "vinto ::= INTO expr",
+ /* 252 */ "vinto ::=",
+ /* 253 */ "cmd ::= PRAGMA nm dbnm",
+ /* 254 */ "cmd ::= PRAGMA nm dbnm EQ nmnum",
+ /* 255 */ "cmd ::= PRAGMA nm dbnm LP nmnum RP",
+ /* 256 */ "cmd ::= PRAGMA nm dbnm EQ minus_num",
+ /* 257 */ "cmd ::= PRAGMA nm dbnm LP minus_num RP",
+ /* 258 */ "plus_num ::= PLUS INTEGER|FLOAT",
+ /* 259 */ "minus_num ::= MINUS INTEGER|FLOAT",
+ /* 260 */ "cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END",
+ /* 261 */ "trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause",
+ /* 262 */ "trigger_time ::= BEFORE|AFTER",
+ /* 263 */ "trigger_time ::= INSTEAD OF",
+ /* 264 */ "trigger_time ::=",
+ /* 265 */ "trigger_event ::= DELETE|INSERT",
+ /* 266 */ "trigger_event ::= UPDATE",
+ /* 267 */ "trigger_event ::= UPDATE OF idlist",
+ /* 268 */ "when_clause ::=",
+ /* 269 */ "when_clause ::= WHEN expr",
+ /* 270 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI",
+ /* 271 */ "trigger_cmd_list ::= trigger_cmd SEMI",
+ /* 272 */ "trnm ::= nm DOT nm",
+ /* 273 */ "tridxby ::= INDEXED BY nm",
+ /* 274 */ "tridxby ::= NOT INDEXED",
+ /* 275 */ "trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt",
+ /* 276 */ "trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt",
+ /* 277 */ "trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt",
+ /* 278 */ "trigger_cmd ::= scanpt select scanpt",
+ /* 279 */ "expr ::= RAISE LP IGNORE RP",
+ /* 280 */ "expr ::= RAISE LP raisetype COMMA expr RP",
+ /* 281 */ "raisetype ::= ROLLBACK",
+ /* 282 */ "raisetype ::= ABORT",
+ /* 283 */ "raisetype ::= FAIL",
+ /* 284 */ "cmd ::= DROP TRIGGER ifexists fullname",
+ /* 285 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt",
+ /* 286 */ "cmd ::= DETACH database_kw_opt expr",
+ /* 287 */ "key_opt ::=",
+ /* 288 */ "key_opt ::= KEY expr",
+ /* 289 */ "cmd ::= REINDEX",
+ /* 290 */ "cmd ::= REINDEX nm dbnm",
+ /* 291 */ "cmd ::= ANALYZE",
+ /* 292 */ "cmd ::= ANALYZE nm dbnm",
+ /* 293 */ "cmd ::= ALTER TABLE fullname RENAME TO nm",
+ /* 294 */ "cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist",
+ /* 295 */ "cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm",
+ /* 296 */ "add_column_fullname ::= fullname",
+ /* 297 */ "cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm",
+ /* 298 */ "cmd ::= create_vtab",
+ /* 299 */ "cmd ::= create_vtab LP vtabarglist RP",
+ /* 300 */ "create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm",
+ /* 301 */ "vtabarg ::=",
+ /* 302 */ "vtabargtoken ::= ANY",
+ /* 303 */ "vtabargtoken ::= lp anylist RP",
+ /* 304 */ "lp ::= LP",
+ /* 305 */ "with ::= WITH wqlist",
+ /* 306 */ "with ::= WITH RECURSIVE wqlist",
+ /* 307 */ "wqas ::= AS",
+ /* 308 */ "wqas ::= AS MATERIALIZED",
+ /* 309 */ "wqas ::= AS NOT MATERIALIZED",
+ /* 310 */ "wqitem ::= withnm eidlist_opt wqas LP select RP",
+ /* 311 */ "withnm ::= nm",
+ /* 312 */ "wqlist ::= wqitem",
+ /* 313 */ "wqlist ::= wqlist COMMA wqitem",
+ /* 314 */ "windowdefn_list ::= windowdefn_list COMMA windowdefn",
+ /* 315 */ "windowdefn ::= nm AS LP window RP",
+ /* 316 */ "window ::= PARTITION BY nexprlist orderby_opt frame_opt",
+ /* 317 */ "window ::= nm PARTITION BY nexprlist orderby_opt frame_opt",
+ /* 318 */ "window ::= ORDER BY sortlist frame_opt",
+ /* 319 */ "window ::= nm ORDER BY sortlist frame_opt",
+ /* 320 */ "window ::= nm frame_opt",
+ /* 321 */ "frame_opt ::=",
+ /* 322 */ "frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt",
+ /* 323 */ "frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt",
+ /* 324 */ "range_or_rows ::= RANGE|ROWS|GROUPS",
+ /* 325 */ "frame_bound_s ::= frame_bound",
+ /* 326 */ "frame_bound_s ::= UNBOUNDED PRECEDING",
+ /* 327 */ "frame_bound_e ::= frame_bound",
+ /* 328 */ "frame_bound_e ::= UNBOUNDED FOLLOWING",
+ /* 329 */ "frame_bound ::= expr PRECEDING|FOLLOWING",
+ /* 330 */ "frame_bound ::= CURRENT ROW",
+ /* 331 */ "frame_exclude_opt ::=",
+ /* 332 */ "frame_exclude_opt ::= EXCLUDE frame_exclude",
+ /* 333 */ "frame_exclude ::= NO OTHERS",
+ /* 334 */ "frame_exclude ::= CURRENT ROW",
+ /* 335 */ "frame_exclude ::= GROUP|TIES",
+ /* 336 */ "window_clause ::= WINDOW windowdefn_list",
+ /* 337 */ "filter_over ::= filter_clause over_clause",
+ /* 338 */ "filter_over ::= over_clause",
+ /* 339 */ "filter_over ::= filter_clause",
+ /* 340 */ "over_clause ::= OVER LP window RP",
+ /* 341 */ "over_clause ::= OVER nm",
+ /* 342 */ "filter_clause ::= FILTER LP WHERE expr RP",
+ /* 343 */ "term ::= QNUMBER",
+ /* 344 */ "input ::= cmdlist",
+ /* 345 */ "cmdlist ::= cmdlist ecmd",
+ /* 346 */ "cmdlist ::= ecmd",
+ /* 347 */ "ecmd ::= SEMI",
+ /* 348 */ "ecmd ::= cmdx SEMI",
+ /* 349 */ "ecmd ::= explain cmdx SEMI",
+ /* 350 */ "trans_opt ::=",
+ /* 351 */ "trans_opt ::= TRANSACTION",
+ /* 352 */ "trans_opt ::= TRANSACTION nm",
+ /* 353 */ "savepoint_opt ::= SAVEPOINT",
+ /* 354 */ "savepoint_opt ::=",
+ /* 355 */ "cmd ::= create_table create_table_args",
+ /* 356 */ "table_option_set ::= table_option",
+ /* 357 */ "columnlist ::= columnlist COMMA columnname carglist",
+ /* 358 */ "columnlist ::= columnname carglist",
+ /* 359 */ "nm ::= ID|INDEXED|JOIN_KW",
+ /* 360 */ "nm ::= STRING",
+ /* 361 */ "typetoken ::= typename",
+ /* 362 */ "typename ::= ID|STRING",
+ /* 363 */ "signed ::= plus_num",
+ /* 364 */ "signed ::= minus_num",
+ /* 365 */ "carglist ::= carglist ccons",
+ /* 366 */ "carglist ::=",
+ /* 367 */ "ccons ::= NULL onconf",
+ /* 368 */ "ccons ::= GENERATED ALWAYS AS generated",
+ /* 369 */ "ccons ::= AS generated",
+ /* 370 */ "conslist_opt ::= COMMA conslist",
+ /* 371 */ "conslist ::= conslist tconscomma tcons",
+ /* 372 */ "conslist ::= tcons",
+ /* 373 */ "tconscomma ::=",
+ /* 374 */ "defer_subclause_opt ::= defer_subclause",
+ /* 375 */ "resolvetype ::= raisetype",
+ /* 376 */ "selectnowith ::= oneselect",
+ /* 377 */ "oneselect ::= values",
+ /* 378 */ "sclp ::= selcollist COMMA",
+ /* 379 */ "as ::= ID|STRING",
+ /* 380 */ "indexed_opt ::= indexed_by",
+ /* 381 */ "returning ::=",
+ /* 382 */ "expr ::= term",
+ /* 383 */ "likeop ::= LIKE_KW|MATCH",
+ /* 384 */ "case_operand ::= expr",
+ /* 385 */ "exprlist ::= nexprlist",
+ /* 386 */ "nmnum ::= plus_num",
+ /* 387 */ "nmnum ::= nm",
+ /* 388 */ "nmnum ::= ON",
+ /* 389 */ "nmnum ::= DELETE",
+ /* 390 */ "nmnum ::= DEFAULT",
+ /* 391 */ "plus_num ::= INTEGER|FLOAT",
+ /* 392 */ "foreach_clause ::=",
+ /* 393 */ "foreach_clause ::= FOR EACH ROW",
+ /* 394 */ "trnm ::= nm",
+ /* 395 */ "tridxby ::=",
+ /* 396 */ "database_kw_opt ::= DATABASE",
+ /* 397 */ "database_kw_opt ::=",
+ /* 398 */ "kwcolumn_opt ::=",
+ /* 399 */ "kwcolumn_opt ::= COLUMNKW",
+ /* 400 */ "vtabarglist ::= vtabarg",
+ /* 401 */ "vtabarglist ::= vtabarglist COMMA vtabarg",
+ /* 402 */ "vtabarg ::= vtabarg vtabargtoken",
+ /* 403 */ "anylist ::=",
+ /* 404 */ "anylist ::= anylist LP anylist RP",
+ /* 405 */ "anylist ::= anylist ANY",
+ /* 406 */ "with ::=",
+ /* 407 */ "windowdefn_list ::= windowdefn",
+ /* 408 */ "window ::= frame_opt",
 };
 #endif /* NDEBUG */
 
 
-#if YYSTACKDEPTH<=0
+#if YYGROWABLESTACK
 /*
 ** Try to increase the size of the parser stack.  Return the number
 ** of errors.  Return 0 on success.
 */
 static int yyGrowStack(yyParser *p){
+  int oldSize = 1 + (int)(p->yystackEnd - p->yystack);
   int newSize;
   int idx;
   yyStackEntry *pNew;
 
-  newSize = p->yystksz*2 + 100;
-  idx = p->yytos ? (int)(p->yytos - p->yystack) : 0;
-  if( p->yystack==&p->yystk0 ){
-    pNew = malloc(newSize*sizeof(pNew[0]));
-    if( pNew ) pNew[0] = p->yystk0;
+  newSize = oldSize*2 + 100;
+  idx = (int)(p->yytos - p->yystack);
+  if( p->yystack==p->yystk0 ){
+    pNew = YYREALLOC(0, newSize*sizeof(pNew[0]));
+    if( pNew==0 ) return 1;
+    memcpy(pNew, p->yystack, oldSize*sizeof(pNew[0]));
   }else{
-    pNew = realloc(p->yystack, newSize*sizeof(pNew[0]));
+    pNew = YYREALLOC(p->yystack, newSize*sizeof(pNew[0]));
+    if( pNew==0 ) return 1;
   }
-  if( pNew ){
-    p->yystack = pNew;
-    p->yytos = &p->yystack[idx];
+  p->yystack = pNew;
+  p->yytos = &p->yystack[idx];
 #ifndef NDEBUG
-    if( yyTraceFILE ){
-      fprintf(yyTraceFILE,"%sStack grows from %d to %d entries.\n",
-              yyTracePrompt, p->yystksz, newSize);
-    }
-#endif
-    p->yystksz = newSize;
+  if( yyTraceFILE ){
+    fprintf(yyTraceFILE,"%sStack grows from %d to %d entries.\n",
+            yyTracePrompt, oldSize, newSize);
   }
-  return pNew==0;
+#endif
+  p->yystackEnd = &p->yystack[newSize-1];
+  return 0;
 }
+#endif /* YYGROWABLESTACK */
+
+#if !YYGROWABLESTACK
+/* For builds that do no have a growable stack, yyGrowStack always
+** returns an error.
+*/
+# define yyGrowStack(X) 1
 #endif
 
 /* Datatype of the argument to the memory allocated passed as the
@@ -173170,24 +176137,14 @@ SQLITE_PRIVATE void sqlite3ParserInit(void *yypRawParser sqlite3ParserCTX_PDECL)
 #ifdef YYTRACKMAXSTACKDEPTH
   yypParser->yyhwm = 0;
 #endif
-#if YYSTACKDEPTH<=0
-  yypParser->yytos = NULL;
-  yypParser->yystack = NULL;
-  yypParser->yystksz = 0;
-  if( yyGrowStack(yypParser) ){
-    yypParser->yystack = &yypParser->yystk0;
-    yypParser->yystksz = 1;
-  }
-#endif
+  yypParser->yystack = yypParser->yystk0;
+  yypParser->yystackEnd = &yypParser->yystack[YYSTACKDEPTH-1];
 #ifndef YYNOERRORRECOVERY
   yypParser->yyerrcnt = -1;
 #endif
   yypParser->yytos = yypParser->yystack;
   yypParser->yystack[0].stateno = 0;
   yypParser->yystack[0].major = 0;
-#if YYSTACKDEPTH>0
-  yypParser->yystackEnd = &yypParser->yystack[YYSTACKDEPTH-1];
-#endif
 }
 
 #ifndef sqlite3Parser_ENGINEALWAYSONSTACK
@@ -173241,97 +176198,98 @@ static void yy_destructor(
     ** inside the C code.
     */
 /********* Begin destructor definitions ***************************************/
-    case 204: /* select */
-    case 239: /* selectnowith */
-    case 240: /* oneselect */
-    case 252: /* values */
+    case 205: /* select */
+    case 240: /* selectnowith */
+    case 241: /* oneselect */
+    case 253: /* values */
+    case 255: /* mvalues */
 {
-sqlite3SelectDelete(pParse->db, (yypminor->yy47));
+sqlite3SelectDelete(pParse->db, (yypminor->yy555));
 }
       break;
-    case 216: /* term */
-    case 217: /* expr */
-    case 246: /* where_opt */
-    case 248: /* having_opt */
-    case 267: /* where_opt_ret */
-    case 278: /* case_operand */
-    case 280: /* case_else */
-    case 283: /* vinto */
-    case 290: /* when_clause */
-    case 295: /* key_opt */
-    case 311: /* filter_clause */
+    case 217: /* term */
+    case 218: /* expr */
+    case 247: /* where_opt */
+    case 249: /* having_opt */
+    case 269: /* where_opt_ret */
+    case 280: /* case_operand */
+    case 282: /* case_else */
+    case 285: /* vinto */
+    case 292: /* when_clause */
+    case 297: /* key_opt */
+    case 314: /* filter_clause */
 {
-sqlite3ExprDelete(pParse->db, (yypminor->yy528));
+sqlite3ExprDelete(pParse->db, (yypminor->yy454));
 }
       break;
-    case 221: /* eidlist_opt */
-    case 231: /* sortlist */
-    case 232: /* eidlist */
-    case 244: /* selcollist */
-    case 247: /* groupby_opt */
-    case 249: /* orderby_opt */
-    case 253: /* nexprlist */
-    case 254: /* sclp */
-    case 261: /* exprlist */
-    case 268: /* setlist */
-    case 277: /* paren_exprlist */
-    case 279: /* case_exprlist */
-    case 310: /* part_opt */
+    case 222: /* eidlist_opt */
+    case 232: /* sortlist */
+    case 233: /* eidlist */
+    case 245: /* selcollist */
+    case 248: /* groupby_opt */
+    case 250: /* orderby_opt */
+    case 254: /* nexprlist */
+    case 256: /* sclp */
+    case 263: /* exprlist */
+    case 270: /* setlist */
+    case 279: /* paren_exprlist */
+    case 281: /* case_exprlist */
+    case 313: /* part_opt */
 {
-sqlite3ExprListDelete(pParse->db, (yypminor->yy322));
+sqlite3ExprListDelete(pParse->db, (yypminor->yy14));
 }
       break;
-    case 238: /* fullname */
-    case 245: /* from */
-    case 256: /* seltablist */
-    case 257: /* stl_prefix */
-    case 262: /* xfullname */
+    case 239: /* fullname */
+    case 246: /* from */
+    case 258: /* seltablist */
+    case 259: /* stl_prefix */
+    case 264: /* xfullname */
 {
-sqlite3SrcListDelete(pParse->db, (yypminor->yy131));
+sqlite3SrcListDelete(pParse->db, (yypminor->yy203));
 }
       break;
-    case 241: /* wqlist */
+    case 242: /* wqlist */
 {
-sqlite3WithDelete(pParse->db, (yypminor->yy521));
+sqlite3WithDelete(pParse->db, (yypminor->yy59));
 }
       break;
-    case 251: /* window_clause */
-    case 306: /* windowdefn_list */
+    case 252: /* window_clause */
+    case 309: /* windowdefn_list */
 {
-sqlite3WindowListDelete(pParse->db, (yypminor->yy41));
+sqlite3WindowListDelete(pParse->db, (yypminor->yy211));
 }
       break;
-    case 263: /* idlist */
-    case 270: /* idlist_opt */
+    case 265: /* idlist */
+    case 272: /* idlist_opt */
 {
-sqlite3IdListDelete(pParse->db, (yypminor->yy254));
+sqlite3IdListDelete(pParse->db, (yypminor->yy132));
 }
       break;
-    case 273: /* filter_over */
-    case 307: /* windowdefn */
-    case 308: /* window */
-    case 309: /* frame_opt */
-    case 312: /* over_clause */
+    case 275: /* filter_over */
+    case 310: /* windowdefn */
+    case 311: /* window */
+    case 312: /* frame_opt */
+    case 315: /* over_clause */
 {
-sqlite3WindowDelete(pParse->db, (yypminor->yy41));
+sqlite3WindowDelete(pParse->db, (yypminor->yy211));
 }
       break;
-    case 286: /* trigger_cmd_list */
-    case 291: /* trigger_cmd */
+    case 288: /* trigger_cmd_list */
+    case 293: /* trigger_cmd */
 {
-sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy33));
+sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy427));
 }
       break;
-    case 288: /* trigger_event */
+    case 290: /* trigger_event */
 {
-sqlite3IdListDelete(pParse->db, (yypminor->yy180).b);
+sqlite3IdListDelete(pParse->db, (yypminor->yy286).b);
 }
       break;
-    case 314: /* frame_bound */
-    case 315: /* frame_bound_s */
-    case 316: /* frame_bound_e */
+    case 317: /* frame_bound */
+    case 318: /* frame_bound_s */
+    case 319: /* frame_bound_e */
 {
-sqlite3ExprDelete(pParse->db, (yypminor->yy595).pExpr);
+sqlite3ExprDelete(pParse->db, (yypminor->yy509).pExpr);
 }
       break;
 /********* End destructor definitions *****************************************/
@@ -173365,9 +176323,26 @@ static void yy_pop_parser_stack(yyParser *pParser){
 */
 SQLITE_PRIVATE void sqlite3ParserFinalize(void *p){
   yyParser *pParser = (yyParser*)p;
-  while( pParser->yytos>pParser->yystack ) yy_pop_parser_stack(pParser);
-#if YYSTACKDEPTH<=0
-  if( pParser->yystack!=&pParser->yystk0 ) free(pParser->yystack);
+
+  /* In-lined version of calling yy_pop_parser_stack() for each
+  ** element left in the stack */
+  yyStackEntry *yytos = pParser->yytos;
+  while( yytos>pParser->yystack ){
+#ifndef NDEBUG
+    if( yyTraceFILE ){
+      fprintf(yyTraceFILE,"%sPopping %s\n",
+        yyTracePrompt,
+        yyTokenName[yytos->major]);
+    }
+#endif
+    if( yytos->major>=YY_MIN_DSTRCTR ){
+      yy_destructor(pParser, yytos->major, &yytos->minor);
+    }
+    yytos--;
+  }
+
+#if YYGROWABLESTACK
+  if( pParser->yystack!=pParser->yystk0 ) YYFREE(pParser->yystack);
 #endif
 }
 
@@ -173550,7 +176525,7 @@ static void yyStackOverflow(yyParser *yypParser){
    ** stack every overflows */
 /******** Begin %stack_overflow code ******************************************/
 
-  sqlite3ErrorMsg(pParse, "parser stack overflow");
+  sqlite3OomFault(pParse->db);
 /******** End %stack_overflow code ********************************************/
    sqlite3ParserARG_STORE /* Suppress warning about unused %extra_argument var */
    sqlite3ParserCTX_STORE
@@ -173594,25 +176569,19 @@ static void yy_shift(
     assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack) );
   }
 #endif
-#if YYSTACKDEPTH>0
-  if( yypParser->yytos>yypParser->yystackEnd ){
-    yypParser->yytos--;
-    yyStackOverflow(yypParser);
-    return;
-  }
-#else
-  if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz] ){
+  yytos = yypParser->yytos;
+  if( yytos>yypParser->yystackEnd ){
     if( yyGrowStack(yypParser) ){
       yypParser->yytos--;
       yyStackOverflow(yypParser);
       return;
     }
+    yytos = yypParser->yytos;
+    assert( yytos <= yypParser->yystackEnd );
   }
-#endif
   if( yyNewState > YY_MAX_SHIFT ){
     yyNewState += YY_MIN_REDUCE - YY_MIN_SHIFTREDUCE;
   }
-  yytos = yypParser->yytos;
   yytos->stateno = yyNewState;
   yytos->major = yyMajor;
   yytos->minor.yy0 = yyMinor;
@@ -173622,411 +176591,415 @@ static void yy_shift(
 /* For rule J, yyRuleInfoLhs[J] contains the symbol on the left-hand side
 ** of that rule */
 static const YYCODETYPE yyRuleInfoLhs[] = {
-   189,  /* (0) explain ::= EXPLAIN */
-   189,  /* (1) explain ::= EXPLAIN QUERY PLAN */
-   188,  /* (2) cmdx ::= cmd */
-   190,  /* (3) cmd ::= BEGIN transtype trans_opt */
-   191,  /* (4) transtype ::= */
-   191,  /* (5) transtype ::= DEFERRED */
-   191,  /* (6) transtype ::= IMMEDIATE */
-   191,  /* (7) transtype ::= EXCLUSIVE */
-   190,  /* (8) cmd ::= COMMIT|END trans_opt */
-   190,  /* (9) cmd ::= ROLLBACK trans_opt */
-   190,  /* (10) cmd ::= SAVEPOINT nm */
-   190,  /* (11) cmd ::= RELEASE savepoint_opt nm */
-   190,  /* (12) cmd ::= ROLLBACK trans_opt TO savepoint_opt nm */
-   195,  /* (13) create_table ::= createkw temp TABLE ifnotexists nm dbnm */
-   197,  /* (14) createkw ::= CREATE */
-   199,  /* (15) ifnotexists ::= */
-   199,  /* (16) ifnotexists ::= IF NOT EXISTS */
-   198,  /* (17) temp ::= TEMP */
-   198,  /* (18) temp ::= */
-   196,  /* (19) create_table_args ::= LP columnlist conslist_opt RP table_option_set */
-   196,  /* (20) create_table_args ::= AS select */
-   203,  /* (21) table_option_set ::= */
-   203,  /* (22) table_option_set ::= table_option_set COMMA table_option */
-   205,  /* (23) table_option ::= WITHOUT nm */
-   205,  /* (24) table_option ::= nm */
-   206,  /* (25) columnname ::= nm typetoken */
-   208,  /* (26) typetoken ::= */
-   208,  /* (27) typetoken ::= typename LP signed RP */
-   208,  /* (28) typetoken ::= typename LP signed COMMA signed RP */
-   209,  /* (29) typename ::= typename ID|STRING */
-   213,  /* (30) scanpt ::= */
-   214,  /* (31) scantok ::= */
-   215,  /* (32) ccons ::= CONSTRAINT nm */
-   215,  /* (33) ccons ::= DEFAULT scantok term */
-   215,  /* (34) ccons ::= DEFAULT LP expr RP */
-   215,  /* (35) ccons ::= DEFAULT PLUS scantok term */
-   215,  /* (36) ccons ::= DEFAULT MINUS scantok term */
-   215,  /* (37) ccons ::= DEFAULT scantok ID|INDEXED */
-   215,  /* (38) ccons ::= NOT NULL onconf */
-   215,  /* (39) ccons ::= PRIMARY KEY sortorder onconf autoinc */
-   215,  /* (40) ccons ::= UNIQUE onconf */
-   215,  /* (41) ccons ::= CHECK LP expr RP */
-   215,  /* (42) ccons ::= REFERENCES nm eidlist_opt refargs */
-   215,  /* (43) ccons ::= defer_subclause */
-   215,  /* (44) ccons ::= COLLATE ID|STRING */
-   224,  /* (45) generated ::= LP expr RP */
-   224,  /* (46) generated ::= LP expr RP ID */
-   220,  /* (47) autoinc ::= */
-   220,  /* (48) autoinc ::= AUTOINCR */
-   222,  /* (49) refargs ::= */
-   222,  /* (50) refargs ::= refargs refarg */
-   225,  /* (51) refarg ::= MATCH nm */
-   225,  /* (52) refarg ::= ON INSERT refact */
-   225,  /* (53) refarg ::= ON DELETE refact */
-   225,  /* (54) refarg ::= ON UPDATE refact */
-   226,  /* (55) refact ::= SET NULL */
-   226,  /* (56) refact ::= SET DEFAULT */
-   226,  /* (57) refact ::= CASCADE */
-   226,  /* (58) refact ::= RESTRICT */
-   226,  /* (59) refact ::= NO ACTION */
-   223,  /* (60) defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */
-   223,  /* (61) defer_subclause ::= DEFERRABLE init_deferred_pred_opt */
-   227,  /* (62) init_deferred_pred_opt ::= */
-   227,  /* (63) init_deferred_pred_opt ::= INITIALLY DEFERRED */
-   227,  /* (64) init_deferred_pred_opt ::= INITIALLY IMMEDIATE */
-   202,  /* (65) conslist_opt ::= */
-   229,  /* (66) tconscomma ::= COMMA */
-   230,  /* (67) tcons ::= CONSTRAINT nm */
-   230,  /* (68) tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */
-   230,  /* (69) tcons ::= UNIQUE LP sortlist RP onconf */
-   230,  /* (70) tcons ::= CHECK LP expr RP onconf */
-   230,  /* (71) tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */
-   233,  /* (72) defer_subclause_opt ::= */
-   218,  /* (73) onconf ::= */
-   218,  /* (74) onconf ::= ON CONFLICT resolvetype */
-   234,  /* (75) orconf ::= */
-   234,  /* (76) orconf ::= OR resolvetype */
-   235,  /* (77) resolvetype ::= IGNORE */
-   235,  /* (78) resolvetype ::= REPLACE */
-   190,  /* (79) cmd ::= DROP TABLE ifexists fullname */
-   237,  /* (80) ifexists ::= IF EXISTS */
-   237,  /* (81) ifexists ::= */
-   190,  /* (82) cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */
-   190,  /* (83) cmd ::= DROP VIEW ifexists fullname */
-   190,  /* (84) cmd ::= select */
-   204,  /* (85) select ::= WITH wqlist selectnowith */
-   204,  /* (86) select ::= WITH RECURSIVE wqlist selectnowith */
-   204,  /* (87) select ::= selectnowith */
-   239,  /* (88) selectnowith ::= selectnowith multiselect_op oneselect */
-   242,  /* (89) multiselect_op ::= UNION */
-   242,  /* (90) multiselect_op ::= UNION ALL */
-   242,  /* (91) multiselect_op ::= EXCEPT|INTERSECT */
-   240,  /* (92) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
-   240,  /* (93) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */
-   252,  /* (94) values ::= VALUES LP nexprlist RP */
-   252,  /* (95) values ::= values COMMA LP nexprlist RP */
-   243,  /* (96) distinct ::= DISTINCT */
-   243,  /* (97) distinct ::= ALL */
-   243,  /* (98) distinct ::= */
-   254,  /* (99) sclp ::= */
-   244,  /* (100) selcollist ::= sclp scanpt expr scanpt as */
-   244,  /* (101) selcollist ::= sclp scanpt STAR */
-   244,  /* (102) selcollist ::= sclp scanpt nm DOT STAR */
-   255,  /* (103) as ::= AS nm */
-   255,  /* (104) as ::= */
-   245,  /* (105) from ::= */
-   245,  /* (106) from ::= FROM seltablist */
-   257,  /* (107) stl_prefix ::= seltablist joinop */
-   257,  /* (108) stl_prefix ::= */
-   256,  /* (109) seltablist ::= stl_prefix nm dbnm as on_using */
-   256,  /* (110) seltablist ::= stl_prefix nm dbnm as indexed_by on_using */
-   256,  /* (111) seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using */
-   256,  /* (112) seltablist ::= stl_prefix LP select RP as on_using */
-   256,  /* (113) seltablist ::= stl_prefix LP seltablist RP as on_using */
-   200,  /* (114) dbnm ::= */
-   200,  /* (115) dbnm ::= DOT nm */
-   238,  /* (116) fullname ::= nm */
-   238,  /* (117) fullname ::= nm DOT nm */
-   262,  /* (118) xfullname ::= nm */
-   262,  /* (119) xfullname ::= nm DOT nm */
-   262,  /* (120) xfullname ::= nm DOT nm AS nm */
-   262,  /* (121) xfullname ::= nm AS nm */
-   258,  /* (122) joinop ::= COMMA|JOIN */
-   258,  /* (123) joinop ::= JOIN_KW JOIN */
-   258,  /* (124) joinop ::= JOIN_KW nm JOIN */
-   258,  /* (125) joinop ::= JOIN_KW nm nm JOIN */
-   259,  /* (126) on_using ::= ON expr */
-   259,  /* (127) on_using ::= USING LP idlist RP */
-   259,  /* (128) on_using ::= */
-   264,  /* (129) indexed_opt ::= */
-   260,  /* (130) indexed_by ::= INDEXED BY nm */
-   260,  /* (131) indexed_by ::= NOT INDEXED */
-   249,  /* (132) orderby_opt ::= */
-   249,  /* (133) orderby_opt ::= ORDER BY sortlist */
-   231,  /* (134) sortlist ::= sortlist COMMA expr sortorder nulls */
-   231,  /* (135) sortlist ::= expr sortorder nulls */
-   219,  /* (136) sortorder ::= ASC */
-   219,  /* (137) sortorder ::= DESC */
-   219,  /* (138) sortorder ::= */
-   265,  /* (139) nulls ::= NULLS FIRST */
-   265,  /* (140) nulls ::= NULLS LAST */
-   265,  /* (141) nulls ::= */
-   247,  /* (142) groupby_opt ::= */
-   247,  /* (143) groupby_opt ::= GROUP BY nexprlist */
-   248,  /* (144) having_opt ::= */
-   248,  /* (145) having_opt ::= HAVING expr */
-   250,  /* (146) limit_opt ::= */
-   250,  /* (147) limit_opt ::= LIMIT expr */
-   250,  /* (148) limit_opt ::= LIMIT expr OFFSET expr */
-   250,  /* (149) limit_opt ::= LIMIT expr COMMA expr */
-   190,  /* (150) cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */
-   246,  /* (151) where_opt ::= */
-   246,  /* (152) where_opt ::= WHERE expr */
-   267,  /* (153) where_opt_ret ::= */
-   267,  /* (154) where_opt_ret ::= WHERE expr */
-   267,  /* (155) where_opt_ret ::= RETURNING selcollist */
-   267,  /* (156) where_opt_ret ::= WHERE expr RETURNING selcollist */
-   190,  /* (157) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */
-   268,  /* (158) setlist ::= setlist COMMA nm EQ expr */
-   268,  /* (159) setlist ::= setlist COMMA LP idlist RP EQ expr */
-   268,  /* (160) setlist ::= nm EQ expr */
-   268,  /* (161) setlist ::= LP idlist RP EQ expr */
-   190,  /* (162) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
-   190,  /* (163) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */
-   271,  /* (164) upsert ::= */
-   271,  /* (165) upsert ::= RETURNING selcollist */
-   271,  /* (166) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */
-   271,  /* (167) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */
-   271,  /* (168) upsert ::= ON CONFLICT DO NOTHING returning */
-   271,  /* (169) upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */
-   272,  /* (170) returning ::= RETURNING selcollist */
-   269,  /* (171) insert_cmd ::= INSERT orconf */
-   269,  /* (172) insert_cmd ::= REPLACE */
-   270,  /* (173) idlist_opt ::= */
-   270,  /* (174) idlist_opt ::= LP idlist RP */
-   263,  /* (175) idlist ::= idlist COMMA nm */
-   263,  /* (176) idlist ::= nm */
-   217,  /* (177) expr ::= LP expr RP */
-   217,  /* (178) expr ::= ID|INDEXED|JOIN_KW */
-   217,  /* (179) expr ::= nm DOT nm */
-   217,  /* (180) expr ::= nm DOT nm DOT nm */
-   216,  /* (181) term ::= NULL|FLOAT|BLOB */
-   216,  /* (182) term ::= STRING */
-   216,  /* (183) term ::= INTEGER */
-   217,  /* (184) expr ::= VARIABLE */
-   217,  /* (185) expr ::= expr COLLATE ID|STRING */
-   217,  /* (186) expr ::= CAST LP expr AS typetoken RP */
-   217,  /* (187) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP */
-   217,  /* (188) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP */
-   217,  /* (189) expr ::= ID|INDEXED|JOIN_KW LP STAR RP */
-   217,  /* (190) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over */
-   217,  /* (191) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP filter_over */
-   217,  /* (192) expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over */
-   216,  /* (193) term ::= CTIME_KW */
-   217,  /* (194) expr ::= LP nexprlist COMMA expr RP */
-   217,  /* (195) expr ::= expr AND expr */
-   217,  /* (196) expr ::= expr OR expr */
-   217,  /* (197) expr ::= expr LT|GT|GE|LE expr */
-   217,  /* (198) expr ::= expr EQ|NE expr */
-   217,  /* (199) expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */
-   217,  /* (200) expr ::= expr PLUS|MINUS expr */
-   217,  /* (201) expr ::= expr STAR|SLASH|REM expr */
-   217,  /* (202) expr ::= expr CONCAT expr */
-   274,  /* (203) likeop ::= NOT LIKE_KW|MATCH */
-   217,  /* (204) expr ::= expr likeop expr */
-   217,  /* (205) expr ::= expr likeop expr ESCAPE expr */
-   217,  /* (206) expr ::= expr ISNULL|NOTNULL */
-   217,  /* (207) expr ::= expr NOT NULL */
-   217,  /* (208) expr ::= expr IS expr */
-   217,  /* (209) expr ::= expr IS NOT expr */
-   217,  /* (210) expr ::= expr IS NOT DISTINCT FROM expr */
-   217,  /* (211) expr ::= expr IS DISTINCT FROM expr */
-   217,  /* (212) expr ::= NOT expr */
-   217,  /* (213) expr ::= BITNOT expr */
-   217,  /* (214) expr ::= PLUS|MINUS expr */
-   217,  /* (215) expr ::= expr PTR expr */
-   275,  /* (216) between_op ::= BETWEEN */
-   275,  /* (217) between_op ::= NOT BETWEEN */
-   217,  /* (218) expr ::= expr between_op expr AND expr */
-   276,  /* (219) in_op ::= IN */
-   276,  /* (220) in_op ::= NOT IN */
-   217,  /* (221) expr ::= expr in_op LP exprlist RP */
-   217,  /* (222) expr ::= LP select RP */
-   217,  /* (223) expr ::= expr in_op LP select RP */
-   217,  /* (224) expr ::= expr in_op nm dbnm paren_exprlist */
-   217,  /* (225) expr ::= EXISTS LP select RP */
-   217,  /* (226) expr ::= CASE case_operand case_exprlist case_else END */
-   279,  /* (227) case_exprlist ::= case_exprlist WHEN expr THEN expr */
-   279,  /* (228) case_exprlist ::= WHEN expr THEN expr */
-   280,  /* (229) case_else ::= ELSE expr */
-   280,  /* (230) case_else ::= */
-   278,  /* (231) case_operand ::= */
-   261,  /* (232) exprlist ::= */
-   253,  /* (233) nexprlist ::= nexprlist COMMA expr */
-   253,  /* (234) nexprlist ::= expr */
-   277,  /* (235) paren_exprlist ::= */
-   277,  /* (236) paren_exprlist ::= LP exprlist RP */
-   190,  /* (237) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
-   281,  /* (238) uniqueflag ::= UNIQUE */
-   281,  /* (239) uniqueflag ::= */
-   221,  /* (240) eidlist_opt ::= */
-   221,  /* (241) eidlist_opt ::= LP eidlist RP */
-   232,  /* (242) eidlist ::= eidlist COMMA nm collate sortorder */
-   232,  /* (243) eidlist ::= nm collate sortorder */
-   282,  /* (244) collate ::= */
-   282,  /* (245) collate ::= COLLATE ID|STRING */
-   190,  /* (246) cmd ::= DROP INDEX ifexists fullname */
-   190,  /* (247) cmd ::= VACUUM vinto */
-   190,  /* (248) cmd ::= VACUUM nm vinto */
-   283,  /* (249) vinto ::= INTO expr */
-   283,  /* (250) vinto ::= */
-   190,  /* (251) cmd ::= PRAGMA nm dbnm */
-   190,  /* (252) cmd ::= PRAGMA nm dbnm EQ nmnum */
-   190,  /* (253) cmd ::= PRAGMA nm dbnm LP nmnum RP */
-   190,  /* (254) cmd ::= PRAGMA nm dbnm EQ minus_num */
-   190,  /* (255) cmd ::= PRAGMA nm dbnm LP minus_num RP */
-   211,  /* (256) plus_num ::= PLUS INTEGER|FLOAT */
-   212,  /* (257) minus_num ::= MINUS INTEGER|FLOAT */
-   190,  /* (258) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
-   285,  /* (259) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
-   287,  /* (260) trigger_time ::= BEFORE|AFTER */
-   287,  /* (261) trigger_time ::= INSTEAD OF */
-   287,  /* (262) trigger_time ::= */
-   288,  /* (263) trigger_event ::= DELETE|INSERT */
-   288,  /* (264) trigger_event ::= UPDATE */
-   288,  /* (265) trigger_event ::= UPDATE OF idlist */
-   290,  /* (266) when_clause ::= */
-   290,  /* (267) when_clause ::= WHEN expr */
-   286,  /* (268) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
-   286,  /* (269) trigger_cmd_list ::= trigger_cmd SEMI */
-   292,  /* (270) trnm ::= nm DOT nm */
-   293,  /* (271) tridxby ::= INDEXED BY nm */
-   293,  /* (272) tridxby ::= NOT INDEXED */
-   291,  /* (273) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */
-   291,  /* (274) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */
-   291,  /* (275) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */
-   291,  /* (276) trigger_cmd ::= scanpt select scanpt */
-   217,  /* (277) expr ::= RAISE LP IGNORE RP */
-   217,  /* (278) expr ::= RAISE LP raisetype COMMA nm RP */
-   236,  /* (279) raisetype ::= ROLLBACK */
-   236,  /* (280) raisetype ::= ABORT */
-   236,  /* (281) raisetype ::= FAIL */
-   190,  /* (282) cmd ::= DROP TRIGGER ifexists fullname */
-   190,  /* (283) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
-   190,  /* (284) cmd ::= DETACH database_kw_opt expr */
-   295,  /* (285) key_opt ::= */
-   295,  /* (286) key_opt ::= KEY expr */
-   190,  /* (287) cmd ::= REINDEX */
-   190,  /* (288) cmd ::= REINDEX nm dbnm */
-   190,  /* (289) cmd ::= ANALYZE */
-   190,  /* (290) cmd ::= ANALYZE nm dbnm */
-   190,  /* (291) cmd ::= ALTER TABLE fullname RENAME TO nm */
-   190,  /* (292) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
-   190,  /* (293) cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
-   296,  /* (294) add_column_fullname ::= fullname */
-   190,  /* (295) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
-   190,  /* (296) cmd ::= create_vtab */
-   190,  /* (297) cmd ::= create_vtab LP vtabarglist RP */
-   298,  /* (298) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
-   300,  /* (299) vtabarg ::= */
-   301,  /* (300) vtabargtoken ::= ANY */
-   301,  /* (301) vtabargtoken ::= lp anylist RP */
-   302,  /* (302) lp ::= LP */
-   266,  /* (303) with ::= WITH wqlist */
-   266,  /* (304) with ::= WITH RECURSIVE wqlist */
-   305,  /* (305) wqas ::= AS */
-   305,  /* (306) wqas ::= AS MATERIALIZED */
-   305,  /* (307) wqas ::= AS NOT MATERIALIZED */
-   304,  /* (308) wqitem ::= nm eidlist_opt wqas LP select RP */
-   241,  /* (309) wqlist ::= wqitem */
-   241,  /* (310) wqlist ::= wqlist COMMA wqitem */
-   306,  /* (311) windowdefn_list ::= windowdefn_list COMMA windowdefn */
-   307,  /* (312) windowdefn ::= nm AS LP window RP */
-   308,  /* (313) window ::= PARTITION BY nexprlist orderby_opt frame_opt */
-   308,  /* (314) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
-   308,  /* (315) window ::= ORDER BY sortlist frame_opt */
-   308,  /* (316) window ::= nm ORDER BY sortlist frame_opt */
-   308,  /* (317) window ::= nm frame_opt */
-   309,  /* (318) frame_opt ::= */
-   309,  /* (319) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
-   309,  /* (320) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
-   313,  /* (321) range_or_rows ::= RANGE|ROWS|GROUPS */
-   315,  /* (322) frame_bound_s ::= frame_bound */
-   315,  /* (323) frame_bound_s ::= UNBOUNDED PRECEDING */
-   316,  /* (324) frame_bound_e ::= frame_bound */
-   316,  /* (325) frame_bound_e ::= UNBOUNDED FOLLOWING */
-   314,  /* (326) frame_bound ::= expr PRECEDING|FOLLOWING */
-   314,  /* (327) frame_bound ::= CURRENT ROW */
-   317,  /* (328) frame_exclude_opt ::= */
-   317,  /* (329) frame_exclude_opt ::= EXCLUDE frame_exclude */
-   318,  /* (330) frame_exclude ::= NO OTHERS */
-   318,  /* (331) frame_exclude ::= CURRENT ROW */
-   318,  /* (332) frame_exclude ::= GROUP|TIES */
-   251,  /* (333) window_clause ::= WINDOW windowdefn_list */
-   273,  /* (334) filter_over ::= filter_clause over_clause */
-   273,  /* (335) filter_over ::= over_clause */
-   273,  /* (336) filter_over ::= filter_clause */
-   312,  /* (337) over_clause ::= OVER LP window RP */
-   312,  /* (338) over_clause ::= OVER nm */
-   311,  /* (339) filter_clause ::= FILTER LP WHERE expr RP */
-   185,  /* (340) input ::= cmdlist */
-   186,  /* (341) cmdlist ::= cmdlist ecmd */
-   186,  /* (342) cmdlist ::= ecmd */
-   187,  /* (343) ecmd ::= SEMI */
-   187,  /* (344) ecmd ::= cmdx SEMI */
-   187,  /* (345) ecmd ::= explain cmdx SEMI */
-   192,  /* (346) trans_opt ::= */
-   192,  /* (347) trans_opt ::= TRANSACTION */
-   192,  /* (348) trans_opt ::= TRANSACTION nm */
-   194,  /* (349) savepoint_opt ::= SAVEPOINT */
-   194,  /* (350) savepoint_opt ::= */
-   190,  /* (351) cmd ::= create_table create_table_args */
-   203,  /* (352) table_option_set ::= table_option */
-   201,  /* (353) columnlist ::= columnlist COMMA columnname carglist */
-   201,  /* (354) columnlist ::= columnname carglist */
-   193,  /* (355) nm ::= ID|INDEXED|JOIN_KW */
-   193,  /* (356) nm ::= STRING */
-   208,  /* (357) typetoken ::= typename */
-   209,  /* (358) typename ::= ID|STRING */
-   210,  /* (359) signed ::= plus_num */
-   210,  /* (360) signed ::= minus_num */
-   207,  /* (361) carglist ::= carglist ccons */
-   207,  /* (362) carglist ::= */
-   215,  /* (363) ccons ::= NULL onconf */
-   215,  /* (364) ccons ::= GENERATED ALWAYS AS generated */
-   215,  /* (365) ccons ::= AS generated */
-   202,  /* (366) conslist_opt ::= COMMA conslist */
-   228,  /* (367) conslist ::= conslist tconscomma tcons */
-   228,  /* (368) conslist ::= tcons */
-   229,  /* (369) tconscomma ::= */
-   233,  /* (370) defer_subclause_opt ::= defer_subclause */
-   235,  /* (371) resolvetype ::= raisetype */
-   239,  /* (372) selectnowith ::= oneselect */
-   240,  /* (373) oneselect ::= values */
-   254,  /* (374) sclp ::= selcollist COMMA */
-   255,  /* (375) as ::= ID|STRING */
-   264,  /* (376) indexed_opt ::= indexed_by */
-   272,  /* (377) returning ::= */
-   217,  /* (378) expr ::= term */
-   274,  /* (379) likeop ::= LIKE_KW|MATCH */
-   278,  /* (380) case_operand ::= expr */
-   261,  /* (381) exprlist ::= nexprlist */
-   284,  /* (382) nmnum ::= plus_num */
-   284,  /* (383) nmnum ::= nm */
-   284,  /* (384) nmnum ::= ON */
-   284,  /* (385) nmnum ::= DELETE */
-   284,  /* (386) nmnum ::= DEFAULT */
-   211,  /* (387) plus_num ::= INTEGER|FLOAT */
-   289,  /* (388) foreach_clause ::= */
-   289,  /* (389) foreach_clause ::= FOR EACH ROW */
-   292,  /* (390) trnm ::= nm */
-   293,  /* (391) tridxby ::= */
-   294,  /* (392) database_kw_opt ::= DATABASE */
-   294,  /* (393) database_kw_opt ::= */
-   297,  /* (394) kwcolumn_opt ::= */
-   297,  /* (395) kwcolumn_opt ::= COLUMNKW */
-   299,  /* (396) vtabarglist ::= vtabarg */
-   299,  /* (397) vtabarglist ::= vtabarglist COMMA vtabarg */
-   300,  /* (398) vtabarg ::= vtabarg vtabargtoken */
-   303,  /* (399) anylist ::= */
-   303,  /* (400) anylist ::= anylist LP anylist RP */
-   303,  /* (401) anylist ::= anylist ANY */
-   266,  /* (402) with ::= */
-   306,  /* (403) windowdefn_list ::= windowdefn */
-   308,  /* (404) window ::= frame_opt */
+   190,  /* (0) explain ::= EXPLAIN */
+   190,  /* (1) explain ::= EXPLAIN QUERY PLAN */
+   189,  /* (2) cmdx ::= cmd */
+   191,  /* (3) cmd ::= BEGIN transtype trans_opt */
+   192,  /* (4) transtype ::= */
+   192,  /* (5) transtype ::= DEFERRED */
+   192,  /* (6) transtype ::= IMMEDIATE */
+   192,  /* (7) transtype ::= EXCLUSIVE */
+   191,  /* (8) cmd ::= COMMIT|END trans_opt */
+   191,  /* (9) cmd ::= ROLLBACK trans_opt */
+   191,  /* (10) cmd ::= SAVEPOINT nm */
+   191,  /* (11) cmd ::= RELEASE savepoint_opt nm */
+   191,  /* (12) cmd ::= ROLLBACK trans_opt TO savepoint_opt nm */
+   196,  /* (13) create_table ::= createkw temp TABLE ifnotexists nm dbnm */
+   198,  /* (14) createkw ::= CREATE */
+   200,  /* (15) ifnotexists ::= */
+   200,  /* (16) ifnotexists ::= IF NOT EXISTS */
+   199,  /* (17) temp ::= TEMP */
+   199,  /* (18) temp ::= */
+   197,  /* (19) create_table_args ::= LP columnlist conslist_opt RP table_option_set */
+   197,  /* (20) create_table_args ::= AS select */
+   204,  /* (21) table_option_set ::= */
+   204,  /* (22) table_option_set ::= table_option_set COMMA table_option */
+   206,  /* (23) table_option ::= WITHOUT nm */
+   206,  /* (24) table_option ::= nm */
+   207,  /* (25) columnname ::= nm typetoken */
+   209,  /* (26) typetoken ::= */
+   209,  /* (27) typetoken ::= typename LP signed RP */
+   209,  /* (28) typetoken ::= typename LP signed COMMA signed RP */
+   210,  /* (29) typename ::= typename ID|STRING */
+   214,  /* (30) scanpt ::= */
+   215,  /* (31) scantok ::= */
+   216,  /* (32) ccons ::= CONSTRAINT nm */
+   216,  /* (33) ccons ::= DEFAULT scantok term */
+   216,  /* (34) ccons ::= DEFAULT LP expr RP */
+   216,  /* (35) ccons ::= DEFAULT PLUS scantok term */
+   216,  /* (36) ccons ::= DEFAULT MINUS scantok term */
+   216,  /* (37) ccons ::= DEFAULT scantok ID|INDEXED */
+   216,  /* (38) ccons ::= NOT NULL onconf */
+   216,  /* (39) ccons ::= PRIMARY KEY sortorder onconf autoinc */
+   216,  /* (40) ccons ::= UNIQUE onconf */
+   216,  /* (41) ccons ::= CHECK LP expr RP */
+   216,  /* (42) ccons ::= REFERENCES nm eidlist_opt refargs */
+   216,  /* (43) ccons ::= defer_subclause */
+   216,  /* (44) ccons ::= COLLATE ID|STRING */
+   225,  /* (45) generated ::= LP expr RP */
+   225,  /* (46) generated ::= LP expr RP ID */
+   221,  /* (47) autoinc ::= */
+   221,  /* (48) autoinc ::= AUTOINCR */
+   223,  /* (49) refargs ::= */
+   223,  /* (50) refargs ::= refargs refarg */
+   226,  /* (51) refarg ::= MATCH nm */
+   226,  /* (52) refarg ::= ON INSERT refact */
+   226,  /* (53) refarg ::= ON DELETE refact */
+   226,  /* (54) refarg ::= ON UPDATE refact */
+   227,  /* (55) refact ::= SET NULL */
+   227,  /* (56) refact ::= SET DEFAULT */
+   227,  /* (57) refact ::= CASCADE */
+   227,  /* (58) refact ::= RESTRICT */
+   227,  /* (59) refact ::= NO ACTION */
+   224,  /* (60) defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */
+   224,  /* (61) defer_subclause ::= DEFERRABLE init_deferred_pred_opt */
+   228,  /* (62) init_deferred_pred_opt ::= */
+   228,  /* (63) init_deferred_pred_opt ::= INITIALLY DEFERRED */
+   228,  /* (64) init_deferred_pred_opt ::= INITIALLY IMMEDIATE */
+   203,  /* (65) conslist_opt ::= */
+   230,  /* (66) tconscomma ::= COMMA */
+   231,  /* (67) tcons ::= CONSTRAINT nm */
+   231,  /* (68) tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */
+   231,  /* (69) tcons ::= UNIQUE LP sortlist RP onconf */
+   231,  /* (70) tcons ::= CHECK LP expr RP onconf */
+   231,  /* (71) tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */
+   234,  /* (72) defer_subclause_opt ::= */
+   219,  /* (73) onconf ::= */
+   219,  /* (74) onconf ::= ON CONFLICT resolvetype */
+   235,  /* (75) orconf ::= */
+   235,  /* (76) orconf ::= OR resolvetype */
+   236,  /* (77) resolvetype ::= IGNORE */
+   236,  /* (78) resolvetype ::= REPLACE */
+   191,  /* (79) cmd ::= DROP TABLE ifexists fullname */
+   238,  /* (80) ifexists ::= IF EXISTS */
+   238,  /* (81) ifexists ::= */
+   191,  /* (82) cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */
+   191,  /* (83) cmd ::= DROP VIEW ifexists fullname */
+   191,  /* (84) cmd ::= select */
+   205,  /* (85) select ::= WITH wqlist selectnowith */
+   205,  /* (86) select ::= WITH RECURSIVE wqlist selectnowith */
+   205,  /* (87) select ::= selectnowith */
+   240,  /* (88) selectnowith ::= selectnowith multiselect_op oneselect */
+   243,  /* (89) multiselect_op ::= UNION */
+   243,  /* (90) multiselect_op ::= UNION ALL */
+   243,  /* (91) multiselect_op ::= EXCEPT|INTERSECT */
+   241,  /* (92) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
+   241,  /* (93) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */
+   253,  /* (94) values ::= VALUES LP nexprlist RP */
+   241,  /* (95) oneselect ::= mvalues */
+   255,  /* (96) mvalues ::= values COMMA LP nexprlist RP */
+   255,  /* (97) mvalues ::= mvalues COMMA LP nexprlist RP */
+   244,  /* (98) distinct ::= DISTINCT */
+   244,  /* (99) distinct ::= ALL */
+   244,  /* (100) distinct ::= */
+   256,  /* (101) sclp ::= */
+   245,  /* (102) selcollist ::= sclp scanpt expr scanpt as */
+   245,  /* (103) selcollist ::= sclp scanpt STAR */
+   245,  /* (104) selcollist ::= sclp scanpt nm DOT STAR */
+   257,  /* (105) as ::= AS nm */
+   257,  /* (106) as ::= */
+   246,  /* (107) from ::= */
+   246,  /* (108) from ::= FROM seltablist */
+   259,  /* (109) stl_prefix ::= seltablist joinop */
+   259,  /* (110) stl_prefix ::= */
+   258,  /* (111) seltablist ::= stl_prefix nm dbnm as on_using */
+   258,  /* (112) seltablist ::= stl_prefix nm dbnm as indexed_by on_using */
+   258,  /* (113) seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using */
+   258,  /* (114) seltablist ::= stl_prefix LP select RP as on_using */
+   258,  /* (115) seltablist ::= stl_prefix LP seltablist RP as on_using */
+   201,  /* (116) dbnm ::= */
+   201,  /* (117) dbnm ::= DOT nm */
+   239,  /* (118) fullname ::= nm */
+   239,  /* (119) fullname ::= nm DOT nm */
+   264,  /* (120) xfullname ::= nm */
+   264,  /* (121) xfullname ::= nm DOT nm */
+   264,  /* (122) xfullname ::= nm DOT nm AS nm */
+   264,  /* (123) xfullname ::= nm AS nm */
+   260,  /* (124) joinop ::= COMMA|JOIN */
+   260,  /* (125) joinop ::= JOIN_KW JOIN */
+   260,  /* (126) joinop ::= JOIN_KW nm JOIN */
+   260,  /* (127) joinop ::= JOIN_KW nm nm JOIN */
+   261,  /* (128) on_using ::= ON expr */
+   261,  /* (129) on_using ::= USING LP idlist RP */
+   261,  /* (130) on_using ::= */
+   266,  /* (131) indexed_opt ::= */
+   262,  /* (132) indexed_by ::= INDEXED BY nm */
+   262,  /* (133) indexed_by ::= NOT INDEXED */
+   250,  /* (134) orderby_opt ::= */
+   250,  /* (135) orderby_opt ::= ORDER BY sortlist */
+   232,  /* (136) sortlist ::= sortlist COMMA expr sortorder nulls */
+   232,  /* (137) sortlist ::= expr sortorder nulls */
+   220,  /* (138) sortorder ::= ASC */
+   220,  /* (139) sortorder ::= DESC */
+   220,  /* (140) sortorder ::= */
+   267,  /* (141) nulls ::= NULLS FIRST */
+   267,  /* (142) nulls ::= NULLS LAST */
+   267,  /* (143) nulls ::= */
+   248,  /* (144) groupby_opt ::= */
+   248,  /* (145) groupby_opt ::= GROUP BY nexprlist */
+   249,  /* (146) having_opt ::= */
+   249,  /* (147) having_opt ::= HAVING expr */
+   251,  /* (148) limit_opt ::= */
+   251,  /* (149) limit_opt ::= LIMIT expr */
+   251,  /* (150) limit_opt ::= LIMIT expr OFFSET expr */
+   251,  /* (151) limit_opt ::= LIMIT expr COMMA expr */
+   191,  /* (152) cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */
+   247,  /* (153) where_opt ::= */
+   247,  /* (154) where_opt ::= WHERE expr */
+   269,  /* (155) where_opt_ret ::= */
+   269,  /* (156) where_opt_ret ::= WHERE expr */
+   269,  /* (157) where_opt_ret ::= RETURNING selcollist */
+   269,  /* (158) where_opt_ret ::= WHERE expr RETURNING selcollist */
+   191,  /* (159) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */
+   270,  /* (160) setlist ::= setlist COMMA nm EQ expr */
+   270,  /* (161) setlist ::= setlist COMMA LP idlist RP EQ expr */
+   270,  /* (162) setlist ::= nm EQ expr */
+   270,  /* (163) setlist ::= LP idlist RP EQ expr */
+   191,  /* (164) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
+   191,  /* (165) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */
+   273,  /* (166) upsert ::= */
+   273,  /* (167) upsert ::= RETURNING selcollist */
+   273,  /* (168) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */
+   273,  /* (169) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */
+   273,  /* (170) upsert ::= ON CONFLICT DO NOTHING returning */
+   273,  /* (171) upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */
+   274,  /* (172) returning ::= RETURNING selcollist */
+   271,  /* (173) insert_cmd ::= INSERT orconf */
+   271,  /* (174) insert_cmd ::= REPLACE */
+   272,  /* (175) idlist_opt ::= */
+   272,  /* (176) idlist_opt ::= LP idlist RP */
+   265,  /* (177) idlist ::= idlist COMMA nm */
+   265,  /* (178) idlist ::= nm */
+   218,  /* (179) expr ::= LP expr RP */
+   218,  /* (180) expr ::= ID|INDEXED|JOIN_KW */
+   218,  /* (181) expr ::= nm DOT nm */
+   218,  /* (182) expr ::= nm DOT nm DOT nm */
+   217,  /* (183) term ::= NULL|FLOAT|BLOB */
+   217,  /* (184) term ::= STRING */
+   217,  /* (185) term ::= INTEGER */
+   218,  /* (186) expr ::= VARIABLE */
+   218,  /* (187) expr ::= expr COLLATE ID|STRING */
+   218,  /* (188) expr ::= CAST LP expr AS typetoken RP */
+   218,  /* (189) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP */
+   218,  /* (190) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP */
+   218,  /* (191) expr ::= ID|INDEXED|JOIN_KW LP STAR RP */
+   218,  /* (192) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over */
+   218,  /* (193) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP filter_over */
+   218,  /* (194) expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over */
+   217,  /* (195) term ::= CTIME_KW */
+   218,  /* (196) expr ::= LP nexprlist COMMA expr RP */
+   218,  /* (197) expr ::= expr AND expr */
+   218,  /* (198) expr ::= expr OR expr */
+   218,  /* (199) expr ::= expr LT|GT|GE|LE expr */
+   218,  /* (200) expr ::= expr EQ|NE expr */
+   218,  /* (201) expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */
+   218,  /* (202) expr ::= expr PLUS|MINUS expr */
+   218,  /* (203) expr ::= expr STAR|SLASH|REM expr */
+   218,  /* (204) expr ::= expr CONCAT expr */
+   276,  /* (205) likeop ::= NOT LIKE_KW|MATCH */
+   218,  /* (206) expr ::= expr likeop expr */
+   218,  /* (207) expr ::= expr likeop expr ESCAPE expr */
+   218,  /* (208) expr ::= expr ISNULL|NOTNULL */
+   218,  /* (209) expr ::= expr NOT NULL */
+   218,  /* (210) expr ::= expr IS expr */
+   218,  /* (211) expr ::= expr IS NOT expr */
+   218,  /* (212) expr ::= expr IS NOT DISTINCT FROM expr */
+   218,  /* (213) expr ::= expr IS DISTINCT FROM expr */
+   218,  /* (214) expr ::= NOT expr */
+   218,  /* (215) expr ::= BITNOT expr */
+   218,  /* (216) expr ::= PLUS|MINUS expr */
+   218,  /* (217) expr ::= expr PTR expr */
+   277,  /* (218) between_op ::= BETWEEN */
+   277,  /* (219) between_op ::= NOT BETWEEN */
+   218,  /* (220) expr ::= expr between_op expr AND expr */
+   278,  /* (221) in_op ::= IN */
+   278,  /* (222) in_op ::= NOT IN */
+   218,  /* (223) expr ::= expr in_op LP exprlist RP */
+   218,  /* (224) expr ::= LP select RP */
+   218,  /* (225) expr ::= expr in_op LP select RP */
+   218,  /* (226) expr ::= expr in_op nm dbnm paren_exprlist */
+   218,  /* (227) expr ::= EXISTS LP select RP */
+   218,  /* (228) expr ::= CASE case_operand case_exprlist case_else END */
+   281,  /* (229) case_exprlist ::= case_exprlist WHEN expr THEN expr */
+   281,  /* (230) case_exprlist ::= WHEN expr THEN expr */
+   282,  /* (231) case_else ::= ELSE expr */
+   282,  /* (232) case_else ::= */
+   280,  /* (233) case_operand ::= */
+   263,  /* (234) exprlist ::= */
+   254,  /* (235) nexprlist ::= nexprlist COMMA expr */
+   254,  /* (236) nexprlist ::= expr */
+   279,  /* (237) paren_exprlist ::= */
+   279,  /* (238) paren_exprlist ::= LP exprlist RP */
+   191,  /* (239) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
+   283,  /* (240) uniqueflag ::= UNIQUE */
+   283,  /* (241) uniqueflag ::= */
+   222,  /* (242) eidlist_opt ::= */
+   222,  /* (243) eidlist_opt ::= LP eidlist RP */
+   233,  /* (244) eidlist ::= eidlist COMMA nm collate sortorder */
+   233,  /* (245) eidlist ::= nm collate sortorder */
+   284,  /* (246) collate ::= */
+   284,  /* (247) collate ::= COLLATE ID|STRING */
+   191,  /* (248) cmd ::= DROP INDEX ifexists fullname */
+   191,  /* (249) cmd ::= VACUUM vinto */
+   191,  /* (250) cmd ::= VACUUM nm vinto */
+   285,  /* (251) vinto ::= INTO expr */
+   285,  /* (252) vinto ::= */
+   191,  /* (253) cmd ::= PRAGMA nm dbnm */
+   191,  /* (254) cmd ::= PRAGMA nm dbnm EQ nmnum */
+   191,  /* (255) cmd ::= PRAGMA nm dbnm LP nmnum RP */
+   191,  /* (256) cmd ::= PRAGMA nm dbnm EQ minus_num */
+   191,  /* (257) cmd ::= PRAGMA nm dbnm LP minus_num RP */
+   212,  /* (258) plus_num ::= PLUS INTEGER|FLOAT */
+   213,  /* (259) minus_num ::= MINUS INTEGER|FLOAT */
+   191,  /* (260) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
+   287,  /* (261) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
+   289,  /* (262) trigger_time ::= BEFORE|AFTER */
+   289,  /* (263) trigger_time ::= INSTEAD OF */
+   289,  /* (264) trigger_time ::= */
+   290,  /* (265) trigger_event ::= DELETE|INSERT */
+   290,  /* (266) trigger_event ::= UPDATE */
+   290,  /* (267) trigger_event ::= UPDATE OF idlist */
+   292,  /* (268) when_clause ::= */
+   292,  /* (269) when_clause ::= WHEN expr */
+   288,  /* (270) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
+   288,  /* (271) trigger_cmd_list ::= trigger_cmd SEMI */
+   294,  /* (272) trnm ::= nm DOT nm */
+   295,  /* (273) tridxby ::= INDEXED BY nm */
+   295,  /* (274) tridxby ::= NOT INDEXED */
+   293,  /* (275) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */
+   293,  /* (276) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */
+   293,  /* (277) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */
+   293,  /* (278) trigger_cmd ::= scanpt select scanpt */
+   218,  /* (279) expr ::= RAISE LP IGNORE RP */
+   218,  /* (280) expr ::= RAISE LP raisetype COMMA expr RP */
+   237,  /* (281) raisetype ::= ROLLBACK */
+   237,  /* (282) raisetype ::= ABORT */
+   237,  /* (283) raisetype ::= FAIL */
+   191,  /* (284) cmd ::= DROP TRIGGER ifexists fullname */
+   191,  /* (285) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
+   191,  /* (286) cmd ::= DETACH database_kw_opt expr */
+   297,  /* (287) key_opt ::= */
+   297,  /* (288) key_opt ::= KEY expr */
+   191,  /* (289) cmd ::= REINDEX */
+   191,  /* (290) cmd ::= REINDEX nm dbnm */
+   191,  /* (291) cmd ::= ANALYZE */
+   191,  /* (292) cmd ::= ANALYZE nm dbnm */
+   191,  /* (293) cmd ::= ALTER TABLE fullname RENAME TO nm */
+   191,  /* (294) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
+   191,  /* (295) cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
+   298,  /* (296) add_column_fullname ::= fullname */
+   191,  /* (297) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
+   191,  /* (298) cmd ::= create_vtab */
+   191,  /* (299) cmd ::= create_vtab LP vtabarglist RP */
+   300,  /* (300) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
+   302,  /* (301) vtabarg ::= */
+   303,  /* (302) vtabargtoken ::= ANY */
+   303,  /* (303) vtabargtoken ::= lp anylist RP */
+   304,  /* (304) lp ::= LP */
+   268,  /* (305) with ::= WITH wqlist */
+   268,  /* (306) with ::= WITH RECURSIVE wqlist */
+   307,  /* (307) wqas ::= AS */
+   307,  /* (308) wqas ::= AS MATERIALIZED */
+   307,  /* (309) wqas ::= AS NOT MATERIALIZED */
+   306,  /* (310) wqitem ::= withnm eidlist_opt wqas LP select RP */
+   308,  /* (311) withnm ::= nm */
+   242,  /* (312) wqlist ::= wqitem */
+   242,  /* (313) wqlist ::= wqlist COMMA wqitem */
+   309,  /* (314) windowdefn_list ::= windowdefn_list COMMA windowdefn */
+   310,  /* (315) windowdefn ::= nm AS LP window RP */
+   311,  /* (316) window ::= PARTITION BY nexprlist orderby_opt frame_opt */
+   311,  /* (317) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
+   311,  /* (318) window ::= ORDER BY sortlist frame_opt */
+   311,  /* (319) window ::= nm ORDER BY sortlist frame_opt */
+   311,  /* (320) window ::= nm frame_opt */
+   312,  /* (321) frame_opt ::= */
+   312,  /* (322) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
+   312,  /* (323) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
+   316,  /* (324) range_or_rows ::= RANGE|ROWS|GROUPS */
+   318,  /* (325) frame_bound_s ::= frame_bound */
+   318,  /* (326) frame_bound_s ::= UNBOUNDED PRECEDING */
+   319,  /* (327) frame_bound_e ::= frame_bound */
+   319,  /* (328) frame_bound_e ::= UNBOUNDED FOLLOWING */
+   317,  /* (329) frame_bound ::= expr PRECEDING|FOLLOWING */
+   317,  /* (330) frame_bound ::= CURRENT ROW */
+   320,  /* (331) frame_exclude_opt ::= */
+   320,  /* (332) frame_exclude_opt ::= EXCLUDE frame_exclude */
+   321,  /* (333) frame_exclude ::= NO OTHERS */
+   321,  /* (334) frame_exclude ::= CURRENT ROW */
+   321,  /* (335) frame_exclude ::= GROUP|TIES */
+   252,  /* (336) window_clause ::= WINDOW windowdefn_list */
+   275,  /* (337) filter_over ::= filter_clause over_clause */
+   275,  /* (338) filter_over ::= over_clause */
+   275,  /* (339) filter_over ::= filter_clause */
+   315,  /* (340) over_clause ::= OVER LP window RP */
+   315,  /* (341) over_clause ::= OVER nm */
+   314,  /* (342) filter_clause ::= FILTER LP WHERE expr RP */
+   217,  /* (343) term ::= QNUMBER */
+   186,  /* (344) input ::= cmdlist */
+   187,  /* (345) cmdlist ::= cmdlist ecmd */
+   187,  /* (346) cmdlist ::= ecmd */
+   188,  /* (347) ecmd ::= SEMI */
+   188,  /* (348) ecmd ::= cmdx SEMI */
+   188,  /* (349) ecmd ::= explain cmdx SEMI */
+   193,  /* (350) trans_opt ::= */
+   193,  /* (351) trans_opt ::= TRANSACTION */
+   193,  /* (352) trans_opt ::= TRANSACTION nm */
+   195,  /* (353) savepoint_opt ::= SAVEPOINT */
+   195,  /* (354) savepoint_opt ::= */
+   191,  /* (355) cmd ::= create_table create_table_args */
+   204,  /* (356) table_option_set ::= table_option */
+   202,  /* (357) columnlist ::= columnlist COMMA columnname carglist */
+   202,  /* (358) columnlist ::= columnname carglist */
+   194,  /* (359) nm ::= ID|INDEXED|JOIN_KW */
+   194,  /* (360) nm ::= STRING */
+   209,  /* (361) typetoken ::= typename */
+   210,  /* (362) typename ::= ID|STRING */
+   211,  /* (363) signed ::= plus_num */
+   211,  /* (364) signed ::= minus_num */
+   208,  /* (365) carglist ::= carglist ccons */
+   208,  /* (366) carglist ::= */
+   216,  /* (367) ccons ::= NULL onconf */
+   216,  /* (368) ccons ::= GENERATED ALWAYS AS generated */
+   216,  /* (369) ccons ::= AS generated */
+   203,  /* (370) conslist_opt ::= COMMA conslist */
+   229,  /* (371) conslist ::= conslist tconscomma tcons */
+   229,  /* (372) conslist ::= tcons */
+   230,  /* (373) tconscomma ::= */
+   234,  /* (374) defer_subclause_opt ::= defer_subclause */
+   236,  /* (375) resolvetype ::= raisetype */
+   240,  /* (376) selectnowith ::= oneselect */
+   241,  /* (377) oneselect ::= values */
+   256,  /* (378) sclp ::= selcollist COMMA */
+   257,  /* (379) as ::= ID|STRING */
+   266,  /* (380) indexed_opt ::= indexed_by */
+   274,  /* (381) returning ::= */
+   218,  /* (382) expr ::= term */
+   276,  /* (383) likeop ::= LIKE_KW|MATCH */
+   280,  /* (384) case_operand ::= expr */
+   263,  /* (385) exprlist ::= nexprlist */
+   286,  /* (386) nmnum ::= plus_num */
+   286,  /* (387) nmnum ::= nm */
+   286,  /* (388) nmnum ::= ON */
+   286,  /* (389) nmnum ::= DELETE */
+   286,  /* (390) nmnum ::= DEFAULT */
+   212,  /* (391) plus_num ::= INTEGER|FLOAT */
+   291,  /* (392) foreach_clause ::= */
+   291,  /* (393) foreach_clause ::= FOR EACH ROW */
+   294,  /* (394) trnm ::= nm */
+   295,  /* (395) tridxby ::= */
+   296,  /* (396) database_kw_opt ::= DATABASE */
+   296,  /* (397) database_kw_opt ::= */
+   299,  /* (398) kwcolumn_opt ::= */
+   299,  /* (399) kwcolumn_opt ::= COLUMNKW */
+   301,  /* (400) vtabarglist ::= vtabarg */
+   301,  /* (401) vtabarglist ::= vtabarglist COMMA vtabarg */
+   302,  /* (402) vtabarg ::= vtabarg vtabargtoken */
+   305,  /* (403) anylist ::= */
+   305,  /* (404) anylist ::= anylist LP anylist RP */
+   305,  /* (405) anylist ::= anylist ANY */
+   268,  /* (406) with ::= */
+   309,  /* (407) windowdefn_list ::= windowdefn */
+   311,  /* (408) window ::= frame_opt */
 };
 
 /* For rule J, yyRuleInfoNRhs[J] contains the negative of the number
@@ -174127,316 +177100,320 @@ static const signed char yyRuleInfoNRhs[] = {
    -9,  /* (92) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
   -10,  /* (93) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */
    -4,  /* (94) values ::= VALUES LP nexprlist RP */
-   -5,  /* (95) values ::= values COMMA LP nexprlist RP */
-   -1,  /* (96) distinct ::= DISTINCT */
-   -1,  /* (97) distinct ::= ALL */
-    0,  /* (98) distinct ::= */
-    0,  /* (99) sclp ::= */
-   -5,  /* (100) selcollist ::= sclp scanpt expr scanpt as */
-   -3,  /* (101) selcollist ::= sclp scanpt STAR */
-   -5,  /* (102) selcollist ::= sclp scanpt nm DOT STAR */
-   -2,  /* (103) as ::= AS nm */
-    0,  /* (104) as ::= */
-    0,  /* (105) from ::= */
-   -2,  /* (106) from ::= FROM seltablist */
-   -2,  /* (107) stl_prefix ::= seltablist joinop */
-    0,  /* (108) stl_prefix ::= */
-   -5,  /* (109) seltablist ::= stl_prefix nm dbnm as on_using */
-   -6,  /* (110) seltablist ::= stl_prefix nm dbnm as indexed_by on_using */
-   -8,  /* (111) seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using */
-   -6,  /* (112) seltablist ::= stl_prefix LP select RP as on_using */
-   -6,  /* (113) seltablist ::= stl_prefix LP seltablist RP as on_using */
-    0,  /* (114) dbnm ::= */
-   -2,  /* (115) dbnm ::= DOT nm */
-   -1,  /* (116) fullname ::= nm */
-   -3,  /* (117) fullname ::= nm DOT nm */
-   -1,  /* (118) xfullname ::= nm */
-   -3,  /* (119) xfullname ::= nm DOT nm */
-   -5,  /* (120) xfullname ::= nm DOT nm AS nm */
-   -3,  /* (121) xfullname ::= nm AS nm */
-   -1,  /* (122) joinop ::= COMMA|JOIN */
-   -2,  /* (123) joinop ::= JOIN_KW JOIN */
-   -3,  /* (124) joinop ::= JOIN_KW nm JOIN */
-   -4,  /* (125) joinop ::= JOIN_KW nm nm JOIN */
-   -2,  /* (126) on_using ::= ON expr */
-   -4,  /* (127) on_using ::= USING LP idlist RP */
-    0,  /* (128) on_using ::= */
-    0,  /* (129) indexed_opt ::= */
-   -3,  /* (130) indexed_by ::= INDEXED BY nm */
-   -2,  /* (131) indexed_by ::= NOT INDEXED */
-    0,  /* (132) orderby_opt ::= */
-   -3,  /* (133) orderby_opt ::= ORDER BY sortlist */
-   -5,  /* (134) sortlist ::= sortlist COMMA expr sortorder nulls */
-   -3,  /* (135) sortlist ::= expr sortorder nulls */
-   -1,  /* (136) sortorder ::= ASC */
-   -1,  /* (137) sortorder ::= DESC */
-    0,  /* (138) sortorder ::= */
-   -2,  /* (139) nulls ::= NULLS FIRST */
-   -2,  /* (140) nulls ::= NULLS LAST */
-    0,  /* (141) nulls ::= */
-    0,  /* (142) groupby_opt ::= */
-   -3,  /* (143) groupby_opt ::= GROUP BY nexprlist */
-    0,  /* (144) having_opt ::= */
-   -2,  /* (145) having_opt ::= HAVING expr */
-    0,  /* (146) limit_opt ::= */
-   -2,  /* (147) limit_opt ::= LIMIT expr */
-   -4,  /* (148) limit_opt ::= LIMIT expr OFFSET expr */
-   -4,  /* (149) limit_opt ::= LIMIT expr COMMA expr */
-   -6,  /* (150) cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */
-    0,  /* (151) where_opt ::= */
-   -2,  /* (152) where_opt ::= WHERE expr */
-    0,  /* (153) where_opt_ret ::= */
-   -2,  /* (154) where_opt_ret ::= WHERE expr */
-   -2,  /* (155) where_opt_ret ::= RETURNING selcollist */
-   -4,  /* (156) where_opt_ret ::= WHERE expr RETURNING selcollist */
-   -9,  /* (157) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */
-   -5,  /* (158) setlist ::= setlist COMMA nm EQ expr */
-   -7,  /* (159) setlist ::= setlist COMMA LP idlist RP EQ expr */
-   -3,  /* (160) setlist ::= nm EQ expr */
-   -5,  /* (161) setlist ::= LP idlist RP EQ expr */
-   -7,  /* (162) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
-   -8,  /* (163) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */
-    0,  /* (164) upsert ::= */
-   -2,  /* (165) upsert ::= RETURNING selcollist */
-  -12,  /* (166) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */
-   -9,  /* (167) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */
-   -5,  /* (168) upsert ::= ON CONFLICT DO NOTHING returning */
-   -8,  /* (169) upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */
-   -2,  /* (170) returning ::= RETURNING selcollist */
-   -2,  /* (171) insert_cmd ::= INSERT orconf */
-   -1,  /* (172) insert_cmd ::= REPLACE */
-    0,  /* (173) idlist_opt ::= */
-   -3,  /* (174) idlist_opt ::= LP idlist RP */
-   -3,  /* (175) idlist ::= idlist COMMA nm */
-   -1,  /* (176) idlist ::= nm */
-   -3,  /* (177) expr ::= LP expr RP */
-   -1,  /* (178) expr ::= ID|INDEXED|JOIN_KW */
-   -3,  /* (179) expr ::= nm DOT nm */
-   -5,  /* (180) expr ::= nm DOT nm DOT nm */
-   -1,  /* (181) term ::= NULL|FLOAT|BLOB */
-   -1,  /* (182) term ::= STRING */
-   -1,  /* (183) term ::= INTEGER */
-   -1,  /* (184) expr ::= VARIABLE */
-   -3,  /* (185) expr ::= expr COLLATE ID|STRING */
-   -6,  /* (186) expr ::= CAST LP expr AS typetoken RP */
-   -5,  /* (187) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP */
-   -8,  /* (188) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP */
-   -4,  /* (189) expr ::= ID|INDEXED|JOIN_KW LP STAR RP */
-   -6,  /* (190) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over */
-   -9,  /* (191) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP filter_over */
-   -5,  /* (192) expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over */
-   -1,  /* (193) term ::= CTIME_KW */
-   -5,  /* (194) expr ::= LP nexprlist COMMA expr RP */
-   -3,  /* (195) expr ::= expr AND expr */
-   -3,  /* (196) expr ::= expr OR expr */
-   -3,  /* (197) expr ::= expr LT|GT|GE|LE expr */
-   -3,  /* (198) expr ::= expr EQ|NE expr */
-   -3,  /* (199) expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */
-   -3,  /* (200) expr ::= expr PLUS|MINUS expr */
-   -3,  /* (201) expr ::= expr STAR|SLASH|REM expr */
-   -3,  /* (202) expr ::= expr CONCAT expr */
-   -2,  /* (203) likeop ::= NOT LIKE_KW|MATCH */
-   -3,  /* (204) expr ::= expr likeop expr */
-   -5,  /* (205) expr ::= expr likeop expr ESCAPE expr */
-   -2,  /* (206) expr ::= expr ISNULL|NOTNULL */
-   -3,  /* (207) expr ::= expr NOT NULL */
-   -3,  /* (208) expr ::= expr IS expr */
-   -4,  /* (209) expr ::= expr IS NOT expr */
-   -6,  /* (210) expr ::= expr IS NOT DISTINCT FROM expr */
-   -5,  /* (211) expr ::= expr IS DISTINCT FROM expr */
-   -2,  /* (212) expr ::= NOT expr */
-   -2,  /* (213) expr ::= BITNOT expr */
-   -2,  /* (214) expr ::= PLUS|MINUS expr */
-   -3,  /* (215) expr ::= expr PTR expr */
-   -1,  /* (216) between_op ::= BETWEEN */
-   -2,  /* (217) between_op ::= NOT BETWEEN */
-   -5,  /* (218) expr ::= expr between_op expr AND expr */
-   -1,  /* (219) in_op ::= IN */
-   -2,  /* (220) in_op ::= NOT IN */
-   -5,  /* (221) expr ::= expr in_op LP exprlist RP */
-   -3,  /* (222) expr ::= LP select RP */
-   -5,  /* (223) expr ::= expr in_op LP select RP */
-   -5,  /* (224) expr ::= expr in_op nm dbnm paren_exprlist */
-   -4,  /* (225) expr ::= EXISTS LP select RP */
-   -5,  /* (226) expr ::= CASE case_operand case_exprlist case_else END */
-   -5,  /* (227) case_exprlist ::= case_exprlist WHEN expr THEN expr */
-   -4,  /* (228) case_exprlist ::= WHEN expr THEN expr */
-   -2,  /* (229) case_else ::= ELSE expr */
-    0,  /* (230) case_else ::= */
-    0,  /* (231) case_operand ::= */
-    0,  /* (232) exprlist ::= */
-   -3,  /* (233) nexprlist ::= nexprlist COMMA expr */
-   -1,  /* (234) nexprlist ::= expr */
-    0,  /* (235) paren_exprlist ::= */
-   -3,  /* (236) paren_exprlist ::= LP exprlist RP */
-  -12,  /* (237) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
-   -1,  /* (238) uniqueflag ::= UNIQUE */
-    0,  /* (239) uniqueflag ::= */
-    0,  /* (240) eidlist_opt ::= */
-   -3,  /* (241) eidlist_opt ::= LP eidlist RP */
-   -5,  /* (242) eidlist ::= eidlist COMMA nm collate sortorder */
-   -3,  /* (243) eidlist ::= nm collate sortorder */
-    0,  /* (244) collate ::= */
-   -2,  /* (245) collate ::= COLLATE ID|STRING */
-   -4,  /* (246) cmd ::= DROP INDEX ifexists fullname */
-   -2,  /* (247) cmd ::= VACUUM vinto */
-   -3,  /* (248) cmd ::= VACUUM nm vinto */
-   -2,  /* (249) vinto ::= INTO expr */
-    0,  /* (250) vinto ::= */
-   -3,  /* (251) cmd ::= PRAGMA nm dbnm */
-   -5,  /* (252) cmd ::= PRAGMA nm dbnm EQ nmnum */
-   -6,  /* (253) cmd ::= PRAGMA nm dbnm LP nmnum RP */
-   -5,  /* (254) cmd ::= PRAGMA nm dbnm EQ minus_num */
-   -6,  /* (255) cmd ::= PRAGMA nm dbnm LP minus_num RP */
-   -2,  /* (256) plus_num ::= PLUS INTEGER|FLOAT */
-   -2,  /* (257) minus_num ::= MINUS INTEGER|FLOAT */
-   -5,  /* (258) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
-  -11,  /* (259) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
-   -1,  /* (260) trigger_time ::= BEFORE|AFTER */
-   -2,  /* (261) trigger_time ::= INSTEAD OF */
-    0,  /* (262) trigger_time ::= */
-   -1,  /* (263) trigger_event ::= DELETE|INSERT */
-   -1,  /* (264) trigger_event ::= UPDATE */
-   -3,  /* (265) trigger_event ::= UPDATE OF idlist */
-    0,  /* (266) when_clause ::= */
-   -2,  /* (267) when_clause ::= WHEN expr */
-   -3,  /* (268) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
-   -2,  /* (269) trigger_cmd_list ::= trigger_cmd SEMI */
-   -3,  /* (270) trnm ::= nm DOT nm */
-   -3,  /* (271) tridxby ::= INDEXED BY nm */
-   -2,  /* (272) tridxby ::= NOT INDEXED */
-   -9,  /* (273) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */
-   -8,  /* (274) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */
-   -6,  /* (275) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */
-   -3,  /* (276) trigger_cmd ::= scanpt select scanpt */
-   -4,  /* (277) expr ::= RAISE LP IGNORE RP */
-   -6,  /* (278) expr ::= RAISE LP raisetype COMMA nm RP */
-   -1,  /* (279) raisetype ::= ROLLBACK */
-   -1,  /* (280) raisetype ::= ABORT */
-   -1,  /* (281) raisetype ::= FAIL */
-   -4,  /* (282) cmd ::= DROP TRIGGER ifexists fullname */
-   -6,  /* (283) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
-   -3,  /* (284) cmd ::= DETACH database_kw_opt expr */
-    0,  /* (285) key_opt ::= */
-   -2,  /* (286) key_opt ::= KEY expr */
-   -1,  /* (287) cmd ::= REINDEX */
-   -3,  /* (288) cmd ::= REINDEX nm dbnm */
-   -1,  /* (289) cmd ::= ANALYZE */
-   -3,  /* (290) cmd ::= ANALYZE nm dbnm */
-   -6,  /* (291) cmd ::= ALTER TABLE fullname RENAME TO nm */
-   -7,  /* (292) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
-   -6,  /* (293) cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
-   -1,  /* (294) add_column_fullname ::= fullname */
-   -8,  /* (295) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
-   -1,  /* (296) cmd ::= create_vtab */
-   -4,  /* (297) cmd ::= create_vtab LP vtabarglist RP */
-   -8,  /* (298) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
-    0,  /* (299) vtabarg ::= */
-   -1,  /* (300) vtabargtoken ::= ANY */
-   -3,  /* (301) vtabargtoken ::= lp anylist RP */
-   -1,  /* (302) lp ::= LP */
-   -2,  /* (303) with ::= WITH wqlist */
-   -3,  /* (304) with ::= WITH RECURSIVE wqlist */
-   -1,  /* (305) wqas ::= AS */
-   -2,  /* (306) wqas ::= AS MATERIALIZED */
-   -3,  /* (307) wqas ::= AS NOT MATERIALIZED */
-   -6,  /* (308) wqitem ::= nm eidlist_opt wqas LP select RP */
-   -1,  /* (309) wqlist ::= wqitem */
-   -3,  /* (310) wqlist ::= wqlist COMMA wqitem */
-   -3,  /* (311) windowdefn_list ::= windowdefn_list COMMA windowdefn */
-   -5,  /* (312) windowdefn ::= nm AS LP window RP */
-   -5,  /* (313) window ::= PARTITION BY nexprlist orderby_opt frame_opt */
-   -6,  /* (314) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
-   -4,  /* (315) window ::= ORDER BY sortlist frame_opt */
-   -5,  /* (316) window ::= nm ORDER BY sortlist frame_opt */
-   -2,  /* (317) window ::= nm frame_opt */
-    0,  /* (318) frame_opt ::= */
-   -3,  /* (319) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
-   -6,  /* (320) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
-   -1,  /* (321) range_or_rows ::= RANGE|ROWS|GROUPS */
-   -1,  /* (322) frame_bound_s ::= frame_bound */
-   -2,  /* (323) frame_bound_s ::= UNBOUNDED PRECEDING */
-   -1,  /* (324) frame_bound_e ::= frame_bound */
-   -2,  /* (325) frame_bound_e ::= UNBOUNDED FOLLOWING */
-   -2,  /* (326) frame_bound ::= expr PRECEDING|FOLLOWING */
-   -2,  /* (327) frame_bound ::= CURRENT ROW */
-    0,  /* (328) frame_exclude_opt ::= */
-   -2,  /* (329) frame_exclude_opt ::= EXCLUDE frame_exclude */
-   -2,  /* (330) frame_exclude ::= NO OTHERS */
-   -2,  /* (331) frame_exclude ::= CURRENT ROW */
-   -1,  /* (332) frame_exclude ::= GROUP|TIES */
-   -2,  /* (333) window_clause ::= WINDOW windowdefn_list */
-   -2,  /* (334) filter_over ::= filter_clause over_clause */
-   -1,  /* (335) filter_over ::= over_clause */
-   -1,  /* (336) filter_over ::= filter_clause */
-   -4,  /* (337) over_clause ::= OVER LP window RP */
-   -2,  /* (338) over_clause ::= OVER nm */
-   -5,  /* (339) filter_clause ::= FILTER LP WHERE expr RP */
-   -1,  /* (340) input ::= cmdlist */
-   -2,  /* (341) cmdlist ::= cmdlist ecmd */
-   -1,  /* (342) cmdlist ::= ecmd */
-   -1,  /* (343) ecmd ::= SEMI */
-   -2,  /* (344) ecmd ::= cmdx SEMI */
-   -3,  /* (345) ecmd ::= explain cmdx SEMI */
-    0,  /* (346) trans_opt ::= */
-   -1,  /* (347) trans_opt ::= TRANSACTION */
-   -2,  /* (348) trans_opt ::= TRANSACTION nm */
-   -1,  /* (349) savepoint_opt ::= SAVEPOINT */
-    0,  /* (350) savepoint_opt ::= */
-   -2,  /* (351) cmd ::= create_table create_table_args */
-   -1,  /* (352) table_option_set ::= table_option */
-   -4,  /* (353) columnlist ::= columnlist COMMA columnname carglist */
-   -2,  /* (354) columnlist ::= columnname carglist */
-   -1,  /* (355) nm ::= ID|INDEXED|JOIN_KW */
-   -1,  /* (356) nm ::= STRING */
-   -1,  /* (357) typetoken ::= typename */
-   -1,  /* (358) typename ::= ID|STRING */
-   -1,  /* (359) signed ::= plus_num */
-   -1,  /* (360) signed ::= minus_num */
-   -2,  /* (361) carglist ::= carglist ccons */
-    0,  /* (362) carglist ::= */
-   -2,  /* (363) ccons ::= NULL onconf */
-   -4,  /* (364) ccons ::= GENERATED ALWAYS AS generated */
-   -2,  /* (365) ccons ::= AS generated */
-   -2,  /* (366) conslist_opt ::= COMMA conslist */
-   -3,  /* (367) conslist ::= conslist tconscomma tcons */
-   -1,  /* (368) conslist ::= tcons */
-    0,  /* (369) tconscomma ::= */
-   -1,  /* (370) defer_subclause_opt ::= defer_subclause */
-   -1,  /* (371) resolvetype ::= raisetype */
-   -1,  /* (372) selectnowith ::= oneselect */
-   -1,  /* (373) oneselect ::= values */
-   -2,  /* (374) sclp ::= selcollist COMMA */
-   -1,  /* (375) as ::= ID|STRING */
-   -1,  /* (376) indexed_opt ::= indexed_by */
-    0,  /* (377) returning ::= */
-   -1,  /* (378) expr ::= term */
-   -1,  /* (379) likeop ::= LIKE_KW|MATCH */
-   -1,  /* (380) case_operand ::= expr */
-   -1,  /* (381) exprlist ::= nexprlist */
-   -1,  /* (382) nmnum ::= plus_num */
-   -1,  /* (383) nmnum ::= nm */
-   -1,  /* (384) nmnum ::= ON */
-   -1,  /* (385) nmnum ::= DELETE */
-   -1,  /* (386) nmnum ::= DEFAULT */
-   -1,  /* (387) plus_num ::= INTEGER|FLOAT */
-    0,  /* (388) foreach_clause ::= */
-   -3,  /* (389) foreach_clause ::= FOR EACH ROW */
-   -1,  /* (390) trnm ::= nm */
-    0,  /* (391) tridxby ::= */
-   -1,  /* (392) database_kw_opt ::= DATABASE */
-    0,  /* (393) database_kw_opt ::= */
-    0,  /* (394) kwcolumn_opt ::= */
-   -1,  /* (395) kwcolumn_opt ::= COLUMNKW */
-   -1,  /* (396) vtabarglist ::= vtabarg */
-   -3,  /* (397) vtabarglist ::= vtabarglist COMMA vtabarg */
-   -2,  /* (398) vtabarg ::= vtabarg vtabargtoken */
-    0,  /* (399) anylist ::= */
-   -4,  /* (400) anylist ::= anylist LP anylist RP */
-   -2,  /* (401) anylist ::= anylist ANY */
-    0,  /* (402) with ::= */
-   -1,  /* (403) windowdefn_list ::= windowdefn */
-   -1,  /* (404) window ::= frame_opt */
+   -1,  /* (95) oneselect ::= mvalues */
+   -5,  /* (96) mvalues ::= values COMMA LP nexprlist RP */
+   -5,  /* (97) mvalues ::= mvalues COMMA LP nexprlist RP */
+   -1,  /* (98) distinct ::= DISTINCT */
+   -1,  /* (99) distinct ::= ALL */
+    0,  /* (100) distinct ::= */
+    0,  /* (101) sclp ::= */
+   -5,  /* (102) selcollist ::= sclp scanpt expr scanpt as */
+   -3,  /* (103) selcollist ::= sclp scanpt STAR */
+   -5,  /* (104) selcollist ::= sclp scanpt nm DOT STAR */
+   -2,  /* (105) as ::= AS nm */
+    0,  /* (106) as ::= */
+    0,  /* (107) from ::= */
+   -2,  /* (108) from ::= FROM seltablist */
+   -2,  /* (109) stl_prefix ::= seltablist joinop */
+    0,  /* (110) stl_prefix ::= */
+   -5,  /* (111) seltablist ::= stl_prefix nm dbnm as on_using */
+   -6,  /* (112) seltablist ::= stl_prefix nm dbnm as indexed_by on_using */
+   -8,  /* (113) seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using */
+   -6,  /* (114) seltablist ::= stl_prefix LP select RP as on_using */
+   -6,  /* (115) seltablist ::= stl_prefix LP seltablist RP as on_using */
+    0,  /* (116) dbnm ::= */
+   -2,  /* (117) dbnm ::= DOT nm */
+   -1,  /* (118) fullname ::= nm */
+   -3,  /* (119) fullname ::= nm DOT nm */
+   -1,  /* (120) xfullname ::= nm */
+   -3,  /* (121) xfullname ::= nm DOT nm */
+   -5,  /* (122) xfullname ::= nm DOT nm AS nm */
+   -3,  /* (123) xfullname ::= nm AS nm */
+   -1,  /* (124) joinop ::= COMMA|JOIN */
+   -2,  /* (125) joinop ::= JOIN_KW JOIN */
+   -3,  /* (126) joinop ::= JOIN_KW nm JOIN */
+   -4,  /* (127) joinop ::= JOIN_KW nm nm JOIN */
+   -2,  /* (128) on_using ::= ON expr */
+   -4,  /* (129) on_using ::= USING LP idlist RP */
+    0,  /* (130) on_using ::= */
+    0,  /* (131) indexed_opt ::= */
+   -3,  /* (132) indexed_by ::= INDEXED BY nm */
+   -2,  /* (133) indexed_by ::= NOT INDEXED */
+    0,  /* (134) orderby_opt ::= */
+   -3,  /* (135) orderby_opt ::= ORDER BY sortlist */
+   -5,  /* (136) sortlist ::= sortlist COMMA expr sortorder nulls */
+   -3,  /* (137) sortlist ::= expr sortorder nulls */
+   -1,  /* (138) sortorder ::= ASC */
+   -1,  /* (139) sortorder ::= DESC */
+    0,  /* (140) sortorder ::= */
+   -2,  /* (141) nulls ::= NULLS FIRST */
+   -2,  /* (142) nulls ::= NULLS LAST */
+    0,  /* (143) nulls ::= */
+    0,  /* (144) groupby_opt ::= */
+   -3,  /* (145) groupby_opt ::= GROUP BY nexprlist */
+    0,  /* (146) having_opt ::= */
+   -2,  /* (147) having_opt ::= HAVING expr */
+    0,  /* (148) limit_opt ::= */
+   -2,  /* (149) limit_opt ::= LIMIT expr */
+   -4,  /* (150) limit_opt ::= LIMIT expr OFFSET expr */
+   -4,  /* (151) limit_opt ::= LIMIT expr COMMA expr */
+   -6,  /* (152) cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */
+    0,  /* (153) where_opt ::= */
+   -2,  /* (154) where_opt ::= WHERE expr */
+    0,  /* (155) where_opt_ret ::= */
+   -2,  /* (156) where_opt_ret ::= WHERE expr */
+   -2,  /* (157) where_opt_ret ::= RETURNING selcollist */
+   -4,  /* (158) where_opt_ret ::= WHERE expr RETURNING selcollist */
+   -9,  /* (159) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */
+   -5,  /* (160) setlist ::= setlist COMMA nm EQ expr */
+   -7,  /* (161) setlist ::= setlist COMMA LP idlist RP EQ expr */
+   -3,  /* (162) setlist ::= nm EQ expr */
+   -5,  /* (163) setlist ::= LP idlist RP EQ expr */
+   -7,  /* (164) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
+   -8,  /* (165) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */
+    0,  /* (166) upsert ::= */
+   -2,  /* (167) upsert ::= RETURNING selcollist */
+  -12,  /* (168) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */
+   -9,  /* (169) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */
+   -5,  /* (170) upsert ::= ON CONFLICT DO NOTHING returning */
+   -8,  /* (171) upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */
+   -2,  /* (172) returning ::= RETURNING selcollist */
+   -2,  /* (173) insert_cmd ::= INSERT orconf */
+   -1,  /* (174) insert_cmd ::= REPLACE */
+    0,  /* (175) idlist_opt ::= */
+   -3,  /* (176) idlist_opt ::= LP idlist RP */
+   -3,  /* (177) idlist ::= idlist COMMA nm */
+   -1,  /* (178) idlist ::= nm */
+   -3,  /* (179) expr ::= LP expr RP */
+   -1,  /* (180) expr ::= ID|INDEXED|JOIN_KW */
+   -3,  /* (181) expr ::= nm DOT nm */
+   -5,  /* (182) expr ::= nm DOT nm DOT nm */
+   -1,  /* (183) term ::= NULL|FLOAT|BLOB */
+   -1,  /* (184) term ::= STRING */
+   -1,  /* (185) term ::= INTEGER */
+   -1,  /* (186) expr ::= VARIABLE */
+   -3,  /* (187) expr ::= expr COLLATE ID|STRING */
+   -6,  /* (188) expr ::= CAST LP expr AS typetoken RP */
+   -5,  /* (189) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP */
+   -8,  /* (190) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP */
+   -4,  /* (191) expr ::= ID|INDEXED|JOIN_KW LP STAR RP */
+   -6,  /* (192) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over */
+   -9,  /* (193) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP filter_over */
+   -5,  /* (194) expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over */
+   -1,  /* (195) term ::= CTIME_KW */
+   -5,  /* (196) expr ::= LP nexprlist COMMA expr RP */
+   -3,  /* (197) expr ::= expr AND expr */
+   -3,  /* (198) expr ::= expr OR expr */
+   -3,  /* (199) expr ::= expr LT|GT|GE|LE expr */
+   -3,  /* (200) expr ::= expr EQ|NE expr */
+   -3,  /* (201) expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */
+   -3,  /* (202) expr ::= expr PLUS|MINUS expr */
+   -3,  /* (203) expr ::= expr STAR|SLASH|REM expr */
+   -3,  /* (204) expr ::= expr CONCAT expr */
+   -2,  /* (205) likeop ::= NOT LIKE_KW|MATCH */
+   -3,  /* (206) expr ::= expr likeop expr */
+   -5,  /* (207) expr ::= expr likeop expr ESCAPE expr */
+   -2,  /* (208) expr ::= expr ISNULL|NOTNULL */
+   -3,  /* (209) expr ::= expr NOT NULL */
+   -3,  /* (210) expr ::= expr IS expr */
+   -4,  /* (211) expr ::= expr IS NOT expr */
+   -6,  /* (212) expr ::= expr IS NOT DISTINCT FROM expr */
+   -5,  /* (213) expr ::= expr IS DISTINCT FROM expr */
+   -2,  /* (214) expr ::= NOT expr */
+   -2,  /* (215) expr ::= BITNOT expr */
+   -2,  /* (216) expr ::= PLUS|MINUS expr */
+   -3,  /* (217) expr ::= expr PTR expr */
+   -1,  /* (218) between_op ::= BETWEEN */
+   -2,  /* (219) between_op ::= NOT BETWEEN */
+   -5,  /* (220) expr ::= expr between_op expr AND expr */
+   -1,  /* (221) in_op ::= IN */
+   -2,  /* (222) in_op ::= NOT IN */
+   -5,  /* (223) expr ::= expr in_op LP exprlist RP */
+   -3,  /* (224) expr ::= LP select RP */
+   -5,  /* (225) expr ::= expr in_op LP select RP */
+   -5,  /* (226) expr ::= expr in_op nm dbnm paren_exprlist */
+   -4,  /* (227) expr ::= EXISTS LP select RP */
+   -5,  /* (228) expr ::= CASE case_operand case_exprlist case_else END */
+   -5,  /* (229) case_exprlist ::= case_exprlist WHEN expr THEN expr */
+   -4,  /* (230) case_exprlist ::= WHEN expr THEN expr */
+   -2,  /* (231) case_else ::= ELSE expr */
+    0,  /* (232) case_else ::= */
+    0,  /* (233) case_operand ::= */
+    0,  /* (234) exprlist ::= */
+   -3,  /* (235) nexprlist ::= nexprlist COMMA expr */
+   -1,  /* (236) nexprlist ::= expr */
+    0,  /* (237) paren_exprlist ::= */
+   -3,  /* (238) paren_exprlist ::= LP exprlist RP */
+  -12,  /* (239) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
+   -1,  /* (240) uniqueflag ::= UNIQUE */
+    0,  /* (241) uniqueflag ::= */
+    0,  /* (242) eidlist_opt ::= */
+   -3,  /* (243) eidlist_opt ::= LP eidlist RP */
+   -5,  /* (244) eidlist ::= eidlist COMMA nm collate sortorder */
+   -3,  /* (245) eidlist ::= nm collate sortorder */
+    0,  /* (246) collate ::= */
+   -2,  /* (247) collate ::= COLLATE ID|STRING */
+   -4,  /* (248) cmd ::= DROP INDEX ifexists fullname */
+   -2,  /* (249) cmd ::= VACUUM vinto */
+   -3,  /* (250) cmd ::= VACUUM nm vinto */
+   -2,  /* (251) vinto ::= INTO expr */
+    0,  /* (252) vinto ::= */
+   -3,  /* (253) cmd ::= PRAGMA nm dbnm */
+   -5,  /* (254) cmd ::= PRAGMA nm dbnm EQ nmnum */
+   -6,  /* (255) cmd ::= PRAGMA nm dbnm LP nmnum RP */
+   -5,  /* (256) cmd ::= PRAGMA nm dbnm EQ minus_num */
+   -6,  /* (257) cmd ::= PRAGMA nm dbnm LP minus_num RP */
+   -2,  /* (258) plus_num ::= PLUS INTEGER|FLOAT */
+   -2,  /* (259) minus_num ::= MINUS INTEGER|FLOAT */
+   -5,  /* (260) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
+  -11,  /* (261) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
+   -1,  /* (262) trigger_time ::= BEFORE|AFTER */
+   -2,  /* (263) trigger_time ::= INSTEAD OF */
+    0,  /* (264) trigger_time ::= */
+   -1,  /* (265) trigger_event ::= DELETE|INSERT */
+   -1,  /* (266) trigger_event ::= UPDATE */
+   -3,  /* (267) trigger_event ::= UPDATE OF idlist */
+    0,  /* (268) when_clause ::= */
+   -2,  /* (269) when_clause ::= WHEN expr */
+   -3,  /* (270) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
+   -2,  /* (271) trigger_cmd_list ::= trigger_cmd SEMI */
+   -3,  /* (272) trnm ::= nm DOT nm */
+   -3,  /* (273) tridxby ::= INDEXED BY nm */
+   -2,  /* (274) tridxby ::= NOT INDEXED */
+   -9,  /* (275) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */
+   -8,  /* (276) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */
+   -6,  /* (277) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */
+   -3,  /* (278) trigger_cmd ::= scanpt select scanpt */
+   -4,  /* (279) expr ::= RAISE LP IGNORE RP */
+   -6,  /* (280) expr ::= RAISE LP raisetype COMMA expr RP */
+   -1,  /* (281) raisetype ::= ROLLBACK */
+   -1,  /* (282) raisetype ::= ABORT */
+   -1,  /* (283) raisetype ::= FAIL */
+   -4,  /* (284) cmd ::= DROP TRIGGER ifexists fullname */
+   -6,  /* (285) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
+   -3,  /* (286) cmd ::= DETACH database_kw_opt expr */
+    0,  /* (287) key_opt ::= */
+   -2,  /* (288) key_opt ::= KEY expr */
+   -1,  /* (289) cmd ::= REINDEX */
+   -3,  /* (290) cmd ::= REINDEX nm dbnm */
+   -1,  /* (291) cmd ::= ANALYZE */
+   -3,  /* (292) cmd ::= ANALYZE nm dbnm */
+   -6,  /* (293) cmd ::= ALTER TABLE fullname RENAME TO nm */
+   -7,  /* (294) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
+   -6,  /* (295) cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
+   -1,  /* (296) add_column_fullname ::= fullname */
+   -8,  /* (297) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
+   -1,  /* (298) cmd ::= create_vtab */
+   -4,  /* (299) cmd ::= create_vtab LP vtabarglist RP */
+   -8,  /* (300) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
+    0,  /* (301) vtabarg ::= */
+   -1,  /* (302) vtabargtoken ::= ANY */
+   -3,  /* (303) vtabargtoken ::= lp anylist RP */
+   -1,  /* (304) lp ::= LP */
+   -2,  /* (305) with ::= WITH wqlist */
+   -3,  /* (306) with ::= WITH RECURSIVE wqlist */
+   -1,  /* (307) wqas ::= AS */
+   -2,  /* (308) wqas ::= AS MATERIALIZED */
+   -3,  /* (309) wqas ::= AS NOT MATERIALIZED */
+   -6,  /* (310) wqitem ::= withnm eidlist_opt wqas LP select RP */
+   -1,  /* (311) withnm ::= nm */
+   -1,  /* (312) wqlist ::= wqitem */
+   -3,  /* (313) wqlist ::= wqlist COMMA wqitem */
+   -3,  /* (314) windowdefn_list ::= windowdefn_list COMMA windowdefn */
+   -5,  /* (315) windowdefn ::= nm AS LP window RP */
+   -5,  /* (316) window ::= PARTITION BY nexprlist orderby_opt frame_opt */
+   -6,  /* (317) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
+   -4,  /* (318) window ::= ORDER BY sortlist frame_opt */
+   -5,  /* (319) window ::= nm ORDER BY sortlist frame_opt */
+   -2,  /* (320) window ::= nm frame_opt */
+    0,  /* (321) frame_opt ::= */
+   -3,  /* (322) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
+   -6,  /* (323) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
+   -1,  /* (324) range_or_rows ::= RANGE|ROWS|GROUPS */
+   -1,  /* (325) frame_bound_s ::= frame_bound */
+   -2,  /* (326) frame_bound_s ::= UNBOUNDED PRECEDING */
+   -1,  /* (327) frame_bound_e ::= frame_bound */
+   -2,  /* (328) frame_bound_e ::= UNBOUNDED FOLLOWING */
+   -2,  /* (329) frame_bound ::= expr PRECEDING|FOLLOWING */
+   -2,  /* (330) frame_bound ::= CURRENT ROW */
+    0,  /* (331) frame_exclude_opt ::= */
+   -2,  /* (332) frame_exclude_opt ::= EXCLUDE frame_exclude */
+   -2,  /* (333) frame_exclude ::= NO OTHERS */
+   -2,  /* (334) frame_exclude ::= CURRENT ROW */
+   -1,  /* (335) frame_exclude ::= GROUP|TIES */
+   -2,  /* (336) window_clause ::= WINDOW windowdefn_list */
+   -2,  /* (337) filter_over ::= filter_clause over_clause */
+   -1,  /* (338) filter_over ::= over_clause */
+   -1,  /* (339) filter_over ::= filter_clause */
+   -4,  /* (340) over_clause ::= OVER LP window RP */
+   -2,  /* (341) over_clause ::= OVER nm */
+   -5,  /* (342) filter_clause ::= FILTER LP WHERE expr RP */
+   -1,  /* (343) term ::= QNUMBER */
+   -1,  /* (344) input ::= cmdlist */
+   -2,  /* (345) cmdlist ::= cmdlist ecmd */
+   -1,  /* (346) cmdlist ::= ecmd */
+   -1,  /* (347) ecmd ::= SEMI */
+   -2,  /* (348) ecmd ::= cmdx SEMI */
+   -3,  /* (349) ecmd ::= explain cmdx SEMI */
+    0,  /* (350) trans_opt ::= */
+   -1,  /* (351) trans_opt ::= TRANSACTION */
+   -2,  /* (352) trans_opt ::= TRANSACTION nm */
+   -1,  /* (353) savepoint_opt ::= SAVEPOINT */
+    0,  /* (354) savepoint_opt ::= */
+   -2,  /* (355) cmd ::= create_table create_table_args */
+   -1,  /* (356) table_option_set ::= table_option */
+   -4,  /* (357) columnlist ::= columnlist COMMA columnname carglist */
+   -2,  /* (358) columnlist ::= columnname carglist */
+   -1,  /* (359) nm ::= ID|INDEXED|JOIN_KW */
+   -1,  /* (360) nm ::= STRING */
+   -1,  /* (361) typetoken ::= typename */
+   -1,  /* (362) typename ::= ID|STRING */
+   -1,  /* (363) signed ::= plus_num */
+   -1,  /* (364) signed ::= minus_num */
+   -2,  /* (365) carglist ::= carglist ccons */
+    0,  /* (366) carglist ::= */
+   -2,  /* (367) ccons ::= NULL onconf */
+   -4,  /* (368) ccons ::= GENERATED ALWAYS AS generated */
+   -2,  /* (369) ccons ::= AS generated */
+   -2,  /* (370) conslist_opt ::= COMMA conslist */
+   -3,  /* (371) conslist ::= conslist tconscomma tcons */
+   -1,  /* (372) conslist ::= tcons */
+    0,  /* (373) tconscomma ::= */
+   -1,  /* (374) defer_subclause_opt ::= defer_subclause */
+   -1,  /* (375) resolvetype ::= raisetype */
+   -1,  /* (376) selectnowith ::= oneselect */
+   -1,  /* (377) oneselect ::= values */
+   -2,  /* (378) sclp ::= selcollist COMMA */
+   -1,  /* (379) as ::= ID|STRING */
+   -1,  /* (380) indexed_opt ::= indexed_by */
+    0,  /* (381) returning ::= */
+   -1,  /* (382) expr ::= term */
+   -1,  /* (383) likeop ::= LIKE_KW|MATCH */
+   -1,  /* (384) case_operand ::= expr */
+   -1,  /* (385) exprlist ::= nexprlist */
+   -1,  /* (386) nmnum ::= plus_num */
+   -1,  /* (387) nmnum ::= nm */
+   -1,  /* (388) nmnum ::= ON */
+   -1,  /* (389) nmnum ::= DELETE */
+   -1,  /* (390) nmnum ::= DEFAULT */
+   -1,  /* (391) plus_num ::= INTEGER|FLOAT */
+    0,  /* (392) foreach_clause ::= */
+   -3,  /* (393) foreach_clause ::= FOR EACH ROW */
+   -1,  /* (394) trnm ::= nm */
+    0,  /* (395) tridxby ::= */
+   -1,  /* (396) database_kw_opt ::= DATABASE */
+    0,  /* (397) database_kw_opt ::= */
+    0,  /* (398) kwcolumn_opt ::= */
+   -1,  /* (399) kwcolumn_opt ::= COLUMNKW */
+   -1,  /* (400) vtabarglist ::= vtabarg */
+   -3,  /* (401) vtabarglist ::= vtabarglist COMMA vtabarg */
+   -2,  /* (402) vtabarg ::= vtabarg vtabargtoken */
+    0,  /* (403) anylist ::= */
+   -4,  /* (404) anylist ::= anylist LP anylist RP */
+   -2,  /* (405) anylist ::= anylist ANY */
+    0,  /* (406) with ::= */
+   -1,  /* (407) windowdefn_list ::= windowdefn */
+   -1,  /* (408) window ::= frame_opt */
 };
 
 static void yy_accept(yyParser*);  /* Forward Declaration */
@@ -174488,16 +177465,16 @@ static YYACTIONTYPE yy_reduce(
 { sqlite3FinishCoding(pParse); }
         break;
       case 3: /* cmd ::= BEGIN transtype trans_opt */
-{sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy394);}
+{sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy144);}
         break;
       case 4: /* transtype ::= */
-{yymsp[1].minor.yy394 = TK_DEFERRED;}
+{yymsp[1].minor.yy144 = TK_DEFERRED;}
         break;
       case 5: /* transtype ::= DEFERRED */
       case 6: /* transtype ::= IMMEDIATE */ yytestcase(yyruleno==6);
       case 7: /* transtype ::= EXCLUSIVE */ yytestcase(yyruleno==7);
-      case 321: /* range_or_rows ::= RANGE|ROWS|GROUPS */ yytestcase(yyruleno==321);
-{yymsp[0].minor.yy394 = yymsp[0].major; /*A-overwrites-X*/}
+      case 324: /* range_or_rows ::= RANGE|ROWS|GROUPS */ yytestcase(yyruleno==324);
+{yymsp[0].minor.yy144 = yymsp[0].major; /*A-overwrites-X*/}
         break;
       case 8: /* cmd ::= COMMIT|END trans_opt */
       case 9: /* cmd ::= ROLLBACK trans_opt */ yytestcase(yyruleno==9);
@@ -174520,7 +177497,7 @@ static YYACTIONTYPE yy_reduce(
         break;
       case 13: /* create_table ::= createkw temp TABLE ifnotexists nm dbnm */
 {
-   sqlite3StartTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,yymsp[-4].minor.yy394,0,0,yymsp[-2].minor.yy394);
+   sqlite3StartTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,yymsp[-4].minor.yy144,0,0,yymsp[-2].minor.yy144);
 }
         break;
       case 14: /* createkw ::= CREATE */
@@ -174532,40 +177509,40 @@ static YYACTIONTYPE yy_reduce(
       case 62: /* init_deferred_pred_opt ::= */ yytestcase(yyruleno==62);
       case 72: /* defer_subclause_opt ::= */ yytestcase(yyruleno==72);
       case 81: /* ifexists ::= */ yytestcase(yyruleno==81);
-      case 98: /* distinct ::= */ yytestcase(yyruleno==98);
-      case 244: /* collate ::= */ yytestcase(yyruleno==244);
-{yymsp[1].minor.yy394 = 0;}
+      case 100: /* distinct ::= */ yytestcase(yyruleno==100);
+      case 246: /* collate ::= */ yytestcase(yyruleno==246);
+{yymsp[1].minor.yy144 = 0;}
         break;
       case 16: /* ifnotexists ::= IF NOT EXISTS */
-{yymsp[-2].minor.yy394 = 1;}
+{yymsp[-2].minor.yy144 = 1;}
         break;
       case 17: /* temp ::= TEMP */
-{yymsp[0].minor.yy394 = pParse->db->init.busy==0;}
+{yymsp[0].minor.yy144 = pParse->db->init.busy==0;}
         break;
       case 19: /* create_table_args ::= LP columnlist conslist_opt RP table_option_set */
 {
-  sqlite3EndTable(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,yymsp[0].minor.yy285,0);
+  sqlite3EndTable(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,yymsp[0].minor.yy391,0);
 }
         break;
       case 20: /* create_table_args ::= AS select */
 {
-  sqlite3EndTable(pParse,0,0,0,yymsp[0].minor.yy47);
-  sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy47);
+  sqlite3EndTable(pParse,0,0,0,yymsp[0].minor.yy555);
+  sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy555);
 }
         break;
       case 21: /* table_option_set ::= */
-{yymsp[1].minor.yy285 = 0;}
+{yymsp[1].minor.yy391 = 0;}
         break;
       case 22: /* table_option_set ::= table_option_set COMMA table_option */
-{yylhsminor.yy285 = yymsp[-2].minor.yy285|yymsp[0].minor.yy285;}
-  yymsp[-2].minor.yy285 = yylhsminor.yy285;
+{yylhsminor.yy391 = yymsp[-2].minor.yy391|yymsp[0].minor.yy391;}
+  yymsp[-2].minor.yy391 = yylhsminor.yy391;
         break;
       case 23: /* table_option ::= WITHOUT nm */
 {
   if( yymsp[0].minor.yy0.n==5 && sqlite3_strnicmp(yymsp[0].minor.yy0.z,"rowid",5)==0 ){
-    yymsp[-1].minor.yy285 = TF_WithoutRowid | TF_NoVisibleRowid;
+    yymsp[-1].minor.yy391 = TF_WithoutRowid | TF_NoVisibleRowid;
   }else{
-    yymsp[-1].minor.yy285 = 0;
+    yymsp[-1].minor.yy391 = 0;
     sqlite3ErrorMsg(pParse, "unknown table option: %.*s", yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.z);
   }
 }
@@ -174573,20 +177550,20 @@ static YYACTIONTYPE yy_reduce(
       case 24: /* table_option ::= nm */
 {
   if( yymsp[0].minor.yy0.n==6 && sqlite3_strnicmp(yymsp[0].minor.yy0.z,"strict",6)==0 ){
-    yylhsminor.yy285 = TF_Strict;
+    yylhsminor.yy391 = TF_Strict;
   }else{
-    yylhsminor.yy285 = 0;
+    yylhsminor.yy391 = 0;
     sqlite3ErrorMsg(pParse, "unknown table option: %.*s", yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.z);
   }
 }
-  yymsp[0].minor.yy285 = yylhsminor.yy285;
+  yymsp[0].minor.yy391 = yylhsminor.yy391;
         break;
       case 25: /* columnname ::= nm typetoken */
 {sqlite3AddColumn(pParse,yymsp[-1].minor.yy0,yymsp[0].minor.yy0);}
         break;
       case 26: /* typetoken ::= */
       case 65: /* conslist_opt ::= */ yytestcase(yyruleno==65);
-      case 104: /* as ::= */ yytestcase(yyruleno==104);
+      case 106: /* as ::= */ yytestcase(yyruleno==106);
 {yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.z = 0;}
         break;
       case 27: /* typetoken ::= typename LP signed RP */
@@ -174605,7 +177582,7 @@ static YYACTIONTYPE yy_reduce(
       case 30: /* scanpt ::= */
 {
   assert( yyLookahead!=YYNOCODE );
-  yymsp[1].minor.yy522 = yyLookaheadToken.z;
+  yymsp[1].minor.yy168 = yyLookaheadToken.z;
 }
         break;
       case 31: /* scantok ::= */
@@ -174619,17 +177596,17 @@ static YYACTIONTYPE yy_reduce(
 {pParse->constraintName = yymsp[0].minor.yy0;}
         break;
       case 33: /* ccons ::= DEFAULT scantok term */
-{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy528,yymsp[-1].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);}
+{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy454,yymsp[-1].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);}
         break;
       case 34: /* ccons ::= DEFAULT LP expr RP */
-{sqlite3AddDefaultValue(pParse,yymsp[-1].minor.yy528,yymsp[-2].minor.yy0.z+1,yymsp[0].minor.yy0.z);}
+{sqlite3AddDefaultValue(pParse,yymsp[-1].minor.yy454,yymsp[-2].minor.yy0.z+1,yymsp[0].minor.yy0.z);}
         break;
       case 35: /* ccons ::= DEFAULT PLUS scantok term */
-{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy528,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);}
+{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy454,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);}
         break;
       case 36: /* ccons ::= DEFAULT MINUS scantok term */
 {
-  Expr *p = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy528, 0);
+  Expr *p = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy454, 0);
   sqlite3AddDefaultValue(pParse,p,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);
 }
         break;
@@ -174644,151 +177621,151 @@ static YYACTIONTYPE yy_reduce(
 }
         break;
       case 38: /* ccons ::= NOT NULL onconf */
-{sqlite3AddNotNull(pParse, yymsp[0].minor.yy394);}
+{sqlite3AddNotNull(pParse, yymsp[0].minor.yy144);}
         break;
       case 39: /* ccons ::= PRIMARY KEY sortorder onconf autoinc */
-{sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy394,yymsp[0].minor.yy394,yymsp[-2].minor.yy394);}
+{sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy144,yymsp[0].minor.yy144,yymsp[-2].minor.yy144);}
         break;
       case 40: /* ccons ::= UNIQUE onconf */
-{sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy394,0,0,0,0,
+{sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy144,0,0,0,0,
                                    SQLITE_IDXTYPE_UNIQUE);}
         break;
       case 41: /* ccons ::= CHECK LP expr RP */
-{sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy528,yymsp[-2].minor.yy0.z,yymsp[0].minor.yy0.z);}
+{sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy454,yymsp[-2].minor.yy0.z,yymsp[0].minor.yy0.z);}
         break;
       case 42: /* ccons ::= REFERENCES nm eidlist_opt refargs */
-{sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy322,yymsp[0].minor.yy394);}
+{sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy14,yymsp[0].minor.yy144);}
         break;
       case 43: /* ccons ::= defer_subclause */
-{sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy394);}
+{sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy144);}
         break;
       case 44: /* ccons ::= COLLATE ID|STRING */
 {sqlite3AddCollateType(pParse, &yymsp[0].minor.yy0);}
         break;
       case 45: /* generated ::= LP expr RP */
-{sqlite3AddGenerated(pParse,yymsp[-1].minor.yy528,0);}
+{sqlite3AddGenerated(pParse,yymsp[-1].minor.yy454,0);}
         break;
       case 46: /* generated ::= LP expr RP ID */
-{sqlite3AddGenerated(pParse,yymsp[-2].minor.yy528,&yymsp[0].minor.yy0);}
+{sqlite3AddGenerated(pParse,yymsp[-2].minor.yy454,&yymsp[0].minor.yy0);}
         break;
       case 48: /* autoinc ::= AUTOINCR */
-{yymsp[0].minor.yy394 = 1;}
+{yymsp[0].minor.yy144 = 1;}
         break;
       case 49: /* refargs ::= */
-{ yymsp[1].minor.yy394 = OE_None*0x0101; /* EV: R-19803-45884 */}
+{ yymsp[1].minor.yy144 = OE_None*0x0101; /* EV: R-19803-45884 */}
         break;
       case 50: /* refargs ::= refargs refarg */
-{ yymsp[-1].minor.yy394 = (yymsp[-1].minor.yy394 & ~yymsp[0].minor.yy231.mask) | yymsp[0].minor.yy231.value; }
+{ yymsp[-1].minor.yy144 = (yymsp[-1].minor.yy144 & ~yymsp[0].minor.yy383.mask) | yymsp[0].minor.yy383.value; }
         break;
       case 51: /* refarg ::= MATCH nm */
-{ yymsp[-1].minor.yy231.value = 0;     yymsp[-1].minor.yy231.mask = 0x000000; }
+{ yymsp[-1].minor.yy383.value = 0;     yymsp[-1].minor.yy383.mask = 0x000000; }
         break;
       case 52: /* refarg ::= ON INSERT refact */
-{ yymsp[-2].minor.yy231.value = 0;     yymsp[-2].minor.yy231.mask = 0x000000; }
+{ yymsp[-2].minor.yy383.value = 0;     yymsp[-2].minor.yy383.mask = 0x000000; }
         break;
       case 53: /* refarg ::= ON DELETE refact */
-{ yymsp[-2].minor.yy231.value = yymsp[0].minor.yy394;     yymsp[-2].minor.yy231.mask = 0x0000ff; }
+{ yymsp[-2].minor.yy383.value = yymsp[0].minor.yy144;     yymsp[-2].minor.yy383.mask = 0x0000ff; }
         break;
       case 54: /* refarg ::= ON UPDATE refact */
-{ yymsp[-2].minor.yy231.value = yymsp[0].minor.yy394<<8;  yymsp[-2].minor.yy231.mask = 0x00ff00; }
+{ yymsp[-2].minor.yy383.value = yymsp[0].minor.yy144<<8;  yymsp[-2].minor.yy383.mask = 0x00ff00; }
         break;
       case 55: /* refact ::= SET NULL */
-{ yymsp[-1].minor.yy394 = OE_SetNull;  /* EV: R-33326-45252 */}
+{ yymsp[-1].minor.yy144 = OE_SetNull;  /* EV: R-33326-45252 */}
         break;
       case 56: /* refact ::= SET DEFAULT */
-{ yymsp[-1].minor.yy394 = OE_SetDflt;  /* EV: R-33326-45252 */}
+{ yymsp[-1].minor.yy144 = OE_SetDflt;  /* EV: R-33326-45252 */}
         break;
       case 57: /* refact ::= CASCADE */
-{ yymsp[0].minor.yy394 = OE_Cascade;  /* EV: R-33326-45252 */}
+{ yymsp[0].minor.yy144 = OE_Cascade;  /* EV: R-33326-45252 */}
         break;
       case 58: /* refact ::= RESTRICT */
-{ yymsp[0].minor.yy394 = OE_Restrict; /* EV: R-33326-45252 */}
+{ yymsp[0].minor.yy144 = OE_Restrict; /* EV: R-33326-45252 */}
         break;
       case 59: /* refact ::= NO ACTION */
-{ yymsp[-1].minor.yy394 = OE_None;     /* EV: R-33326-45252 */}
+{ yymsp[-1].minor.yy144 = OE_None;     /* EV: R-33326-45252 */}
         break;
       case 60: /* defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */
-{yymsp[-2].minor.yy394 = 0;}
+{yymsp[-2].minor.yy144 = 0;}
         break;
       case 61: /* defer_subclause ::= DEFERRABLE init_deferred_pred_opt */
       case 76: /* orconf ::= OR resolvetype */ yytestcase(yyruleno==76);
-      case 171: /* insert_cmd ::= INSERT orconf */ yytestcase(yyruleno==171);
-{yymsp[-1].minor.yy394 = yymsp[0].minor.yy394;}
+      case 173: /* insert_cmd ::= INSERT orconf */ yytestcase(yyruleno==173);
+{yymsp[-1].minor.yy144 = yymsp[0].minor.yy144;}
         break;
       case 63: /* init_deferred_pred_opt ::= INITIALLY DEFERRED */
       case 80: /* ifexists ::= IF EXISTS */ yytestcase(yyruleno==80);
-      case 217: /* between_op ::= NOT BETWEEN */ yytestcase(yyruleno==217);
-      case 220: /* in_op ::= NOT IN */ yytestcase(yyruleno==220);
-      case 245: /* collate ::= COLLATE ID|STRING */ yytestcase(yyruleno==245);
-{yymsp[-1].minor.yy394 = 1;}
+      case 219: /* between_op ::= NOT BETWEEN */ yytestcase(yyruleno==219);
+      case 222: /* in_op ::= NOT IN */ yytestcase(yyruleno==222);
+      case 247: /* collate ::= COLLATE ID|STRING */ yytestcase(yyruleno==247);
+{yymsp[-1].minor.yy144 = 1;}
         break;
       case 64: /* init_deferred_pred_opt ::= INITIALLY IMMEDIATE */
-{yymsp[-1].minor.yy394 = 0;}
+{yymsp[-1].minor.yy144 = 0;}
         break;
       case 66: /* tconscomma ::= COMMA */
 {pParse->constraintName.n = 0;}
         break;
       case 68: /* tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */
-{sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy322,yymsp[0].minor.yy394,yymsp[-2].minor.yy394,0);}
+{sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy14,yymsp[0].minor.yy144,yymsp[-2].minor.yy144,0);}
         break;
       case 69: /* tcons ::= UNIQUE LP sortlist RP onconf */
-{sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy322,yymsp[0].minor.yy394,0,0,0,0,
+{sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy14,yymsp[0].minor.yy144,0,0,0,0,
                                        SQLITE_IDXTYPE_UNIQUE);}
         break;
       case 70: /* tcons ::= CHECK LP expr RP onconf */
-{sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy528,yymsp[-3].minor.yy0.z,yymsp[-1].minor.yy0.z);}
+{sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy454,yymsp[-3].minor.yy0.z,yymsp[-1].minor.yy0.z);}
         break;
       case 71: /* tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */
 {
-    sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy322, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy322, yymsp[-1].minor.yy394);
-    sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy394);
+    sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy14, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy14, yymsp[-1].minor.yy144);
+    sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy144);
 }
         break;
       case 73: /* onconf ::= */
       case 75: /* orconf ::= */ yytestcase(yyruleno==75);
-{yymsp[1].minor.yy394 = OE_Default;}
+{yymsp[1].minor.yy144 = OE_Default;}
         break;
       case 74: /* onconf ::= ON CONFLICT resolvetype */
-{yymsp[-2].minor.yy394 = yymsp[0].minor.yy394;}
+{yymsp[-2].minor.yy144 = yymsp[0].minor.yy144;}
         break;
       case 77: /* resolvetype ::= IGNORE */
-{yymsp[0].minor.yy394 = OE_Ignore;}
+{yymsp[0].minor.yy144 = OE_Ignore;}
         break;
       case 78: /* resolvetype ::= REPLACE */
-      case 172: /* insert_cmd ::= REPLACE */ yytestcase(yyruleno==172);
-{yymsp[0].minor.yy394 = OE_Replace;}
+      case 174: /* insert_cmd ::= REPLACE */ yytestcase(yyruleno==174);
+{yymsp[0].minor.yy144 = OE_Replace;}
         break;
       case 79: /* cmd ::= DROP TABLE ifexists fullname */
 {
-  sqlite3DropTable(pParse, yymsp[0].minor.yy131, 0, yymsp[-1].minor.yy394);
+  sqlite3DropTable(pParse, yymsp[0].minor.yy203, 0, yymsp[-1].minor.yy144);
 }
         break;
       case 82: /* cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */
 {
-  sqlite3CreateView(pParse, &yymsp[-8].minor.yy0, &yymsp[-4].minor.yy0, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy322, yymsp[0].minor.yy47, yymsp[-7].minor.yy394, yymsp[-5].minor.yy394);
+  sqlite3CreateView(pParse, &yymsp[-8].minor.yy0, &yymsp[-4].minor.yy0, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy14, yymsp[0].minor.yy555, yymsp[-7].minor.yy144, yymsp[-5].minor.yy144);
 }
         break;
       case 83: /* cmd ::= DROP VIEW ifexists fullname */
 {
-  sqlite3DropTable(pParse, yymsp[0].minor.yy131, 1, yymsp[-1].minor.yy394);
+  sqlite3DropTable(pParse, yymsp[0].minor.yy203, 1, yymsp[-1].minor.yy144);
 }
         break;
       case 84: /* cmd ::= select */
 {
   SelectDest dest = {SRT_Output, 0, 0, 0, 0, 0, 0};
-  sqlite3Select(pParse, yymsp[0].minor.yy47, &dest);
-  sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy47);
+  sqlite3Select(pParse, yymsp[0].minor.yy555, &dest);
+  sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy555);
 }
         break;
       case 85: /* select ::= WITH wqlist selectnowith */
-{yymsp[-2].minor.yy47 = attachWithToSelect(pParse,yymsp[0].minor.yy47,yymsp[-1].minor.yy521);}
+{yymsp[-2].minor.yy555 = attachWithToSelect(pParse,yymsp[0].minor.yy555,yymsp[-1].minor.yy59);}
         break;
       case 86: /* select ::= WITH RECURSIVE wqlist selectnowith */
-{yymsp[-3].minor.yy47 = attachWithToSelect(pParse,yymsp[0].minor.yy47,yymsp[-1].minor.yy521);}
+{yymsp[-3].minor.yy555 = attachWithToSelect(pParse,yymsp[0].minor.yy555,yymsp[-1].minor.yy59);}
         break;
       case 87: /* select ::= selectnowith */
 {
-  Select *p = yymsp[0].minor.yy47;
+  Select *p = yymsp[0].minor.yy555;
   if( p ){
     parserDoubleLinkSelect(pParse, p);
   }
@@ -174796,8 +177773,8 @@ static YYACTIONTYPE yy_reduce(
         break;
       case 88: /* selectnowith ::= selectnowith multiselect_op oneselect */
 {
-  Select *pRhs = yymsp[0].minor.yy47;
-  Select *pLhs = yymsp[-2].minor.yy47;
+  Select *pRhs = yymsp[0].minor.yy555;
+  Select *pLhs = yymsp[-2].minor.yy555;
   if( pRhs && pRhs->pPrior ){
     SrcList *pFrom;
     Token x;
@@ -174807,153 +177784,160 @@ static YYACTIONTYPE yy_reduce(
     pRhs = sqlite3SelectNew(pParse,0,pFrom,0,0,0,0,0,0);
   }
   if( pRhs ){
-    pRhs->op = (u8)yymsp[-1].minor.yy394;
+    pRhs->op = (u8)yymsp[-1].minor.yy144;
     pRhs->pPrior = pLhs;
     if( ALWAYS(pLhs) ) pLhs->selFlags &= ~SF_MultiValue;
     pRhs->selFlags &= ~SF_MultiValue;
-    if( yymsp[-1].minor.yy394!=TK_ALL ) pParse->hasCompound = 1;
+    if( yymsp[-1].minor.yy144!=TK_ALL ) pParse->hasCompound = 1;
   }else{
     sqlite3SelectDelete(pParse->db, pLhs);
   }
-  yymsp[-2].minor.yy47 = pRhs;
+  yymsp[-2].minor.yy555 = pRhs;
 }
         break;
       case 89: /* multiselect_op ::= UNION */
       case 91: /* multiselect_op ::= EXCEPT|INTERSECT */ yytestcase(yyruleno==91);
-{yymsp[0].minor.yy394 = yymsp[0].major; /*A-overwrites-OP*/}
+{yymsp[0].minor.yy144 = yymsp[0].major; /*A-overwrites-OP*/}
         break;
       case 90: /* multiselect_op ::= UNION ALL */
-{yymsp[-1].minor.yy394 = TK_ALL;}
+{yymsp[-1].minor.yy144 = TK_ALL;}
         break;
       case 92: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
 {
-  yymsp[-8].minor.yy47 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy322,yymsp[-5].minor.yy131,yymsp[-4].minor.yy528,yymsp[-3].minor.yy322,yymsp[-2].minor.yy528,yymsp[-1].minor.yy322,yymsp[-7].minor.yy394,yymsp[0].minor.yy528);
+  yymsp[-8].minor.yy555 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy14,yymsp[-5].minor.yy203,yymsp[-4].minor.yy454,yymsp[-3].minor.yy14,yymsp[-2].minor.yy454,yymsp[-1].minor.yy14,yymsp[-7].minor.yy144,yymsp[0].minor.yy454);
 }
         break;
       case 93: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */
 {
-  yymsp[-9].minor.yy47 = sqlite3SelectNew(pParse,yymsp[-7].minor.yy322,yymsp[-6].minor.yy131,yymsp[-5].minor.yy528,yymsp[-4].minor.yy322,yymsp[-3].minor.yy528,yymsp[-1].minor.yy322,yymsp[-8].minor.yy394,yymsp[0].minor.yy528);
-  if( yymsp[-9].minor.yy47 ){
-    yymsp[-9].minor.yy47->pWinDefn = yymsp[-2].minor.yy41;
+  yymsp[-9].minor.yy555 = sqlite3SelectNew(pParse,yymsp[-7].minor.yy14,yymsp[-6].minor.yy203,yymsp[-5].minor.yy454,yymsp[-4].minor.yy14,yymsp[-3].minor.yy454,yymsp[-1].minor.yy14,yymsp[-8].minor.yy144,yymsp[0].minor.yy454);
+  if( yymsp[-9].minor.yy555 ){
+    yymsp[-9].minor.yy555->pWinDefn = yymsp[-2].minor.yy211;
   }else{
-    sqlite3WindowListDelete(pParse->db, yymsp[-2].minor.yy41);
+    sqlite3WindowListDelete(pParse->db, yymsp[-2].minor.yy211);
   }
 }
         break;
       case 94: /* values ::= VALUES LP nexprlist RP */
 {
-  yymsp[-3].minor.yy47 = sqlite3SelectNew(pParse,yymsp[-1].minor.yy322,0,0,0,0,0,SF_Values,0);
+  yymsp[-3].minor.yy555 = sqlite3SelectNew(pParse,yymsp[-1].minor.yy14,0,0,0,0,0,SF_Values,0);
 }
         break;
-      case 95: /* values ::= values COMMA LP nexprlist RP */
+      case 95: /* oneselect ::= mvalues */
 {
-  Select *pRight, *pLeft = yymsp[-4].minor.yy47;
-  pRight = sqlite3SelectNew(pParse,yymsp[-1].minor.yy322,0,0,0,0,0,SF_Values|SF_MultiValue,0);
-  if( ALWAYS(pLeft) ) pLeft->selFlags &= ~SF_MultiValue;
-  if( pRight ){
-    pRight->op = TK_ALL;
-    pRight->pPrior = pLeft;
-    yymsp[-4].minor.yy47 = pRight;
-  }else{
-    yymsp[-4].minor.yy47 = pLeft;
-  }
+  sqlite3MultiValuesEnd(pParse, yymsp[0].minor.yy555);
 }
         break;
-      case 96: /* distinct ::= DISTINCT */
-{yymsp[0].minor.yy394 = SF_Distinct;}
-        break;
-      case 97: /* distinct ::= ALL */
-{yymsp[0].minor.yy394 = SF_All;}
-        break;
-      case 99: /* sclp ::= */
-      case 132: /* orderby_opt ::= */ yytestcase(yyruleno==132);
-      case 142: /* groupby_opt ::= */ yytestcase(yyruleno==142);
-      case 232: /* exprlist ::= */ yytestcase(yyruleno==232);
-      case 235: /* paren_exprlist ::= */ yytestcase(yyruleno==235);
-      case 240: /* eidlist_opt ::= */ yytestcase(yyruleno==240);
-{yymsp[1].minor.yy322 = 0;}
-        break;
-      case 100: /* selcollist ::= sclp scanpt expr scanpt as */
+      case 96: /* mvalues ::= values COMMA LP nexprlist RP */
+      case 97: /* mvalues ::= mvalues COMMA LP nexprlist RP */ yytestcase(yyruleno==97);
 {
-   yymsp[-4].minor.yy322 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy322, yymsp[-2].minor.yy528);
-   if( yymsp[0].minor.yy0.n>0 ) sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy322, &yymsp[0].minor.yy0, 1);
-   sqlite3ExprListSetSpan(pParse,yymsp[-4].minor.yy322,yymsp[-3].minor.yy522,yymsp[-1].minor.yy522);
+  yymsp[-4].minor.yy555 = sqlite3MultiValues(pParse, yymsp[-4].minor.yy555, yymsp[-1].minor.yy14);
 }
         break;
-      case 101: /* selcollist ::= sclp scanpt STAR */
+      case 98: /* distinct ::= DISTINCT */
+{yymsp[0].minor.yy144 = SF_Distinct;}
+        break;
+      case 99: /* distinct ::= ALL */
+{yymsp[0].minor.yy144 = SF_All;}
+        break;
+      case 101: /* sclp ::= */
+      case 134: /* orderby_opt ::= */ yytestcase(yyruleno==134);
+      case 144: /* groupby_opt ::= */ yytestcase(yyruleno==144);
+      case 234: /* exprlist ::= */ yytestcase(yyruleno==234);
+      case 237: /* paren_exprlist ::= */ yytestcase(yyruleno==237);
+      case 242: /* eidlist_opt ::= */ yytestcase(yyruleno==242);
+{yymsp[1].minor.yy14 = 0;}
+        break;
+      case 102: /* selcollist ::= sclp scanpt expr scanpt as */
+{
+   yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy14, yymsp[-2].minor.yy454);
+   if( yymsp[0].minor.yy0.n>0 ) sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy14, &yymsp[0].minor.yy0, 1);
+   sqlite3ExprListSetSpan(pParse,yymsp[-4].minor.yy14,yymsp[-3].minor.yy168,yymsp[-1].minor.yy168);
+}
+        break;
+      case 103: /* selcollist ::= sclp scanpt STAR */
 {
   Expr *p = sqlite3Expr(pParse->db, TK_ASTERISK, 0);
   sqlite3ExprSetErrorOffset(p, (int)(yymsp[0].minor.yy0.z - pParse->zTail));
-  yymsp[-2].minor.yy322 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy322, p);
+  yymsp[-2].minor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy14, p);
 }
         break;
-      case 102: /* selcollist ::= sclp scanpt nm DOT STAR */
+      case 104: /* selcollist ::= sclp scanpt nm DOT STAR */
 {
   Expr *pRight, *pLeft, *pDot;
   pRight = sqlite3PExpr(pParse, TK_ASTERISK, 0, 0);
   sqlite3ExprSetErrorOffset(pRight, (int)(yymsp[0].minor.yy0.z - pParse->zTail));
   pLeft = tokenExpr(pParse, TK_ID, yymsp[-2].minor.yy0);
   pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight);
-  yymsp[-4].minor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy322, pDot);
+  yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14, pDot);
 }
         break;
-      case 103: /* as ::= AS nm */
-      case 115: /* dbnm ::= DOT nm */ yytestcase(yyruleno==115);
-      case 256: /* plus_num ::= PLUS INTEGER|FLOAT */ yytestcase(yyruleno==256);
-      case 257: /* minus_num ::= MINUS INTEGER|FLOAT */ yytestcase(yyruleno==257);
+      case 105: /* as ::= AS nm */
+      case 117: /* dbnm ::= DOT nm */ yytestcase(yyruleno==117);
+      case 258: /* plus_num ::= PLUS INTEGER|FLOAT */ yytestcase(yyruleno==258);
+      case 259: /* minus_num ::= MINUS INTEGER|FLOAT */ yytestcase(yyruleno==259);
 {yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;}
         break;
-      case 105: /* from ::= */
-      case 108: /* stl_prefix ::= */ yytestcase(yyruleno==108);
-{yymsp[1].minor.yy131 = 0;}
+      case 107: /* from ::= */
+      case 110: /* stl_prefix ::= */ yytestcase(yyruleno==110);
+{yymsp[1].minor.yy203 = 0;}
         break;
-      case 106: /* from ::= FROM seltablist */
+      case 108: /* from ::= FROM seltablist */
 {
-  yymsp[-1].minor.yy131 = yymsp[0].minor.yy131;
-  sqlite3SrcListShiftJoinType(pParse,yymsp[-1].minor.yy131);
+  yymsp[-1].minor.yy203 = yymsp[0].minor.yy203;
+  sqlite3SrcListShiftJoinType(pParse,yymsp[-1].minor.yy203);
 }
         break;
-      case 107: /* stl_prefix ::= seltablist joinop */
+      case 109: /* stl_prefix ::= seltablist joinop */
 {
-   if( ALWAYS(yymsp[-1].minor.yy131 && yymsp[-1].minor.yy131->nSrc>0) ) yymsp[-1].minor.yy131->a[yymsp[-1].minor.yy131->nSrc-1].fg.jointype = (u8)yymsp[0].minor.yy394;
+   if( ALWAYS(yymsp[-1].minor.yy203 && yymsp[-1].minor.yy203->nSrc>0) ) yymsp[-1].minor.yy203->a[yymsp[-1].minor.yy203->nSrc-1].fg.jointype = (u8)yymsp[0].minor.yy144;
 }
         break;
-      case 109: /* seltablist ::= stl_prefix nm dbnm as on_using */
+      case 111: /* seltablist ::= stl_prefix nm dbnm as on_using */
 {
-  yymsp[-4].minor.yy131 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-4].minor.yy131,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0,&yymsp[0].minor.yy561);
+  yymsp[-4].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-4].minor.yy203,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0,&yymsp[0].minor.yy269);
 }
         break;
-      case 110: /* seltablist ::= stl_prefix nm dbnm as indexed_by on_using */
+      case 112: /* seltablist ::= stl_prefix nm dbnm as indexed_by on_using */
 {
-  yymsp[-5].minor.yy131 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy131,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,0,&yymsp[0].minor.yy561);
-  sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy131, &yymsp[-1].minor.yy0);
+  yymsp[-5].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy203,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,0,&yymsp[0].minor.yy269);
+  sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy203, &yymsp[-1].minor.yy0);
 }
         break;
-      case 111: /* seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using */
+      case 113: /* seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using */
 {
-  yymsp[-7].minor.yy131 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-7].minor.yy131,&yymsp[-6].minor.yy0,&yymsp[-5].minor.yy0,&yymsp[-1].minor.yy0,0,&yymsp[0].minor.yy561);
-  sqlite3SrcListFuncArgs(pParse, yymsp[-7].minor.yy131, yymsp[-3].minor.yy322);
+  yymsp[-7].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-7].minor.yy203,&yymsp[-6].minor.yy0,&yymsp[-5].minor.yy0,&yymsp[-1].minor.yy0,0,&yymsp[0].minor.yy269);
+  sqlite3SrcListFuncArgs(pParse, yymsp[-7].minor.yy203, yymsp[-3].minor.yy14);
 }
         break;
-      case 112: /* seltablist ::= stl_prefix LP select RP as on_using */
+      case 114: /* seltablist ::= stl_prefix LP select RP as on_using */
 {
-    yymsp[-5].minor.yy131 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy131,0,0,&yymsp[-1].minor.yy0,yymsp[-3].minor.yy47,&yymsp[0].minor.yy561);
+    yymsp[-5].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy203,0,0,&yymsp[-1].minor.yy0,yymsp[-3].minor.yy555,&yymsp[0].minor.yy269);
   }
         break;
-      case 113: /* seltablist ::= stl_prefix LP seltablist RP as on_using */
+      case 115: /* seltablist ::= stl_prefix LP seltablist RP as on_using */
 {
-    if( yymsp[-5].minor.yy131==0 && yymsp[-1].minor.yy0.n==0 && yymsp[0].minor.yy561.pOn==0 && yymsp[0].minor.yy561.pUsing==0 ){
-      yymsp[-5].minor.yy131 = yymsp[-3].minor.yy131;
-    }else if( ALWAYS(yymsp[-3].minor.yy131!=0) && yymsp[-3].minor.yy131->nSrc==1 ){
-      yymsp[-5].minor.yy131 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy131,0,0,&yymsp[-1].minor.yy0,0,&yymsp[0].minor.yy561);
-      if( yymsp[-5].minor.yy131 ){
-        SrcItem *pNew = &yymsp[-5].minor.yy131->a[yymsp[-5].minor.yy131->nSrc-1];
-        SrcItem *pOld = yymsp[-3].minor.yy131->a;
+    if( yymsp[-5].minor.yy203==0 && yymsp[-1].minor.yy0.n==0 && yymsp[0].minor.yy269.pOn==0 && yymsp[0].minor.yy269.pUsing==0 ){
+      yymsp[-5].minor.yy203 = yymsp[-3].minor.yy203;
+    }else if( ALWAYS(yymsp[-3].minor.yy203!=0) && yymsp[-3].minor.yy203->nSrc==1 ){
+      yymsp[-5].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy203,0,0,&yymsp[-1].minor.yy0,0,&yymsp[0].minor.yy269);
+      if( yymsp[-5].minor.yy203 ){
+        SrcItem *pNew = &yymsp[-5].minor.yy203->a[yymsp[-5].minor.yy203->nSrc-1];
+        SrcItem *pOld = yymsp[-3].minor.yy203->a;
+        assert( pOld->fg.fixedSchema==0 );
         pNew->zName = pOld->zName;
-        pNew->zDatabase = pOld->zDatabase;
-        pNew->pSelect = pOld->pSelect;
-        if( pNew->pSelect && (pNew->pSelect->selFlags & SF_NestedFrom)!=0 ){
-          pNew->fg.isNestedFrom = 1;
+        assert( pOld->fg.fixedSchema==0 );
+        if( pOld->fg.isSubquery ){
+          pNew->fg.isSubquery = 1;
+          pNew->u4.pSubq = pOld->u4.pSubq;
+          pOld->u4.pSubq = 0;
+          pOld->fg.isSubquery = 0;
+          assert( pNew->u4.pSubq!=0 && pNew->u4.pSubq->pSelect!=0 );
+          if( (pNew->u4.pSubq->pSelect->selFlags & SF_NestedFrom)!=0 ){
+            pNew->fg.isNestedFrom = 1;
+          }
+        }else{
+          pNew->u4.zDatabase = pOld->u4.zDatabase;
+          pOld->u4.zDatabase = 0;
         }
         if( pOld->fg.isTabFunc ){
           pNew->u1.pFuncArg = pOld->u1.pFuncArg;
@@ -174961,156 +177945,155 @@ static YYACTIONTYPE yy_reduce(
           pOld->fg.isTabFunc = 0;
           pNew->fg.isTabFunc = 1;
         }
-        pOld->zName = pOld->zDatabase = 0;
-        pOld->pSelect = 0;
+        pOld->zName = 0;
       }
-      sqlite3SrcListDelete(pParse->db, yymsp[-3].minor.yy131);
+      sqlite3SrcListDelete(pParse->db, yymsp[-3].minor.yy203);
     }else{
       Select *pSubquery;
-      sqlite3SrcListShiftJoinType(pParse,yymsp[-3].minor.yy131);
-      pSubquery = sqlite3SelectNew(pParse,0,yymsp[-3].minor.yy131,0,0,0,0,SF_NestedFrom,0);
-      yymsp[-5].minor.yy131 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy131,0,0,&yymsp[-1].minor.yy0,pSubquery,&yymsp[0].minor.yy561);
+      sqlite3SrcListShiftJoinType(pParse,yymsp[-3].minor.yy203);
+      pSubquery = sqlite3SelectNew(pParse,0,yymsp[-3].minor.yy203,0,0,0,0,SF_NestedFrom,0);
+      yymsp[-5].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy203,0,0,&yymsp[-1].minor.yy0,pSubquery,&yymsp[0].minor.yy269);
     }
   }
         break;
-      case 114: /* dbnm ::= */
-      case 129: /* indexed_opt ::= */ yytestcase(yyruleno==129);
+      case 116: /* dbnm ::= */
+      case 131: /* indexed_opt ::= */ yytestcase(yyruleno==131);
 {yymsp[1].minor.yy0.z=0; yymsp[1].minor.yy0.n=0;}
         break;
-      case 116: /* fullname ::= nm */
+      case 118: /* fullname ::= nm */
 {
-  yylhsminor.yy131 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0);
-  if( IN_RENAME_OBJECT && yylhsminor.yy131 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy131->a[0].zName, &yymsp[0].minor.yy0);
+  yylhsminor.yy203 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0);
+  if( IN_RENAME_OBJECT && yylhsminor.yy203 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy203->a[0].zName, &yymsp[0].minor.yy0);
 }
-  yymsp[0].minor.yy131 = yylhsminor.yy131;
+  yymsp[0].minor.yy203 = yylhsminor.yy203;
         break;
-      case 117: /* fullname ::= nm DOT nm */
+      case 119: /* fullname ::= nm DOT nm */
 {
-  yylhsminor.yy131 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);
-  if( IN_RENAME_OBJECT && yylhsminor.yy131 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy131->a[0].zName, &yymsp[0].minor.yy0);
+  yylhsminor.yy203 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);
+  if( IN_RENAME_OBJECT && yylhsminor.yy203 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy203->a[0].zName, &yymsp[0].minor.yy0);
 }
-  yymsp[-2].minor.yy131 = yylhsminor.yy131;
+  yymsp[-2].minor.yy203 = yylhsminor.yy203;
         break;
-      case 118: /* xfullname ::= nm */
-{yymsp[0].minor.yy131 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0); /*A-overwrites-X*/}
+      case 120: /* xfullname ::= nm */
+{yymsp[0].minor.yy203 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0); /*A-overwrites-X*/}
         break;
-      case 119: /* xfullname ::= nm DOT nm */
-{yymsp[-2].minor.yy131 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); /*A-overwrites-X*/}
+      case 121: /* xfullname ::= nm DOT nm */
+{yymsp[-2].minor.yy203 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); /*A-overwrites-X*/}
         break;
-      case 120: /* xfullname ::= nm DOT nm AS nm */
+      case 122: /* xfullname ::= nm DOT nm AS nm */
 {
-   yymsp[-4].minor.yy131 = sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,&yymsp[-2].minor.yy0); /*A-overwrites-X*/
-   if( yymsp[-4].minor.yy131 ) yymsp[-4].minor.yy131->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0);
+   yymsp[-4].minor.yy203 = sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,&yymsp[-2].minor.yy0); /*A-overwrites-X*/
+   if( yymsp[-4].minor.yy203 ) yymsp[-4].minor.yy203->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0);
 }
         break;
-      case 121: /* xfullname ::= nm AS nm */
+      case 123: /* xfullname ::= nm AS nm */
 {
-   yymsp[-2].minor.yy131 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,0); /*A-overwrites-X*/
-   if( yymsp[-2].minor.yy131 ) yymsp[-2].minor.yy131->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0);
+   yymsp[-2].minor.yy203 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,0); /*A-overwrites-X*/
+   if( yymsp[-2].minor.yy203 ) yymsp[-2].minor.yy203->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0);
 }
         break;
-      case 122: /* joinop ::= COMMA|JOIN */
-{ yymsp[0].minor.yy394 = JT_INNER; }
+      case 124: /* joinop ::= COMMA|JOIN */
+{ yymsp[0].minor.yy144 = JT_INNER; }
         break;
-      case 123: /* joinop ::= JOIN_KW JOIN */
-{yymsp[-1].minor.yy394 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0);  /*X-overwrites-A*/}
+      case 125: /* joinop ::= JOIN_KW JOIN */
+{yymsp[-1].minor.yy144 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0);  /*X-overwrites-A*/}
         break;
-      case 124: /* joinop ::= JOIN_KW nm JOIN */
-{yymsp[-2].minor.yy394 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); /*X-overwrites-A*/}
+      case 126: /* joinop ::= JOIN_KW nm JOIN */
+{yymsp[-2].minor.yy144 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); /*X-overwrites-A*/}
         break;
-      case 125: /* joinop ::= JOIN_KW nm nm JOIN */
-{yymsp[-3].minor.yy394 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);/*X-overwrites-A*/}
+      case 127: /* joinop ::= JOIN_KW nm nm JOIN */
+{yymsp[-3].minor.yy144 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);/*X-overwrites-A*/}
         break;
-      case 126: /* on_using ::= ON expr */
-{yymsp[-1].minor.yy561.pOn = yymsp[0].minor.yy528; yymsp[-1].minor.yy561.pUsing = 0;}
+      case 128: /* on_using ::= ON expr */
+{yymsp[-1].minor.yy269.pOn = yymsp[0].minor.yy454; yymsp[-1].minor.yy269.pUsing = 0;}
         break;
-      case 127: /* on_using ::= USING LP idlist RP */
-{yymsp[-3].minor.yy561.pOn = 0; yymsp[-3].minor.yy561.pUsing = yymsp[-1].minor.yy254;}
+      case 129: /* on_using ::= USING LP idlist RP */
+{yymsp[-3].minor.yy269.pOn = 0; yymsp[-3].minor.yy269.pUsing = yymsp[-1].minor.yy132;}
         break;
-      case 128: /* on_using ::= */
-{yymsp[1].minor.yy561.pOn = 0; yymsp[1].minor.yy561.pUsing = 0;}
+      case 130: /* on_using ::= */
+{yymsp[1].minor.yy269.pOn = 0; yymsp[1].minor.yy269.pUsing = 0;}
         break;
-      case 130: /* indexed_by ::= INDEXED BY nm */
+      case 132: /* indexed_by ::= INDEXED BY nm */
 {yymsp[-2].minor.yy0 = yymsp[0].minor.yy0;}
         break;
-      case 131: /* indexed_by ::= NOT INDEXED */
+      case 133: /* indexed_by ::= NOT INDEXED */
 {yymsp[-1].minor.yy0.z=0; yymsp[-1].minor.yy0.n=1;}
         break;
-      case 133: /* orderby_opt ::= ORDER BY sortlist */
-      case 143: /* groupby_opt ::= GROUP BY nexprlist */ yytestcase(yyruleno==143);
-{yymsp[-2].minor.yy322 = yymsp[0].minor.yy322;}
+      case 135: /* orderby_opt ::= ORDER BY sortlist */
+      case 145: /* groupby_opt ::= GROUP BY nexprlist */ yytestcase(yyruleno==145);
+{yymsp[-2].minor.yy14 = yymsp[0].minor.yy14;}
         break;
-      case 134: /* sortlist ::= sortlist COMMA expr sortorder nulls */
+      case 136: /* sortlist ::= sortlist COMMA expr sortorder nulls */
 {
-  yymsp[-4].minor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy322,yymsp[-2].minor.yy528);
-  sqlite3ExprListSetSortOrder(yymsp[-4].minor.yy322,yymsp[-1].minor.yy394,yymsp[0].minor.yy394);
+  yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14,yymsp[-2].minor.yy454);
+  sqlite3ExprListSetSortOrder(yymsp[-4].minor.yy14,yymsp[-1].minor.yy144,yymsp[0].minor.yy144);
 }
         break;
-      case 135: /* sortlist ::= expr sortorder nulls */
+      case 137: /* sortlist ::= expr sortorder nulls */
 {
-  yymsp[-2].minor.yy322 = sqlite3ExprListAppend(pParse,0,yymsp[-2].minor.yy528); /*A-overwrites-Y*/
-  sqlite3ExprListSetSortOrder(yymsp[-2].minor.yy322,yymsp[-1].minor.yy394,yymsp[0].minor.yy394);
+  yymsp[-2].minor.yy14 = sqlite3ExprListAppend(pParse,0,yymsp[-2].minor.yy454); /*A-overwrites-Y*/
+  sqlite3ExprListSetSortOrder(yymsp[-2].minor.yy14,yymsp[-1].minor.yy144,yymsp[0].minor.yy144);
 }
         break;
-      case 136: /* sortorder ::= ASC */
-{yymsp[0].minor.yy394 = SQLITE_SO_ASC;}
+      case 138: /* sortorder ::= ASC */
+{yymsp[0].minor.yy144 = SQLITE_SO_ASC;}
         break;
-      case 137: /* sortorder ::= DESC */
-{yymsp[0].minor.yy394 = SQLITE_SO_DESC;}
+      case 139: /* sortorder ::= DESC */
+{yymsp[0].minor.yy144 = SQLITE_SO_DESC;}
         break;
-      case 138: /* sortorder ::= */
-      case 141: /* nulls ::= */ yytestcase(yyruleno==141);
-{yymsp[1].minor.yy394 = SQLITE_SO_UNDEFINED;}
+      case 140: /* sortorder ::= */
+      case 143: /* nulls ::= */ yytestcase(yyruleno==143);
+{yymsp[1].minor.yy144 = SQLITE_SO_UNDEFINED;}
         break;
-      case 139: /* nulls ::= NULLS FIRST */
-{yymsp[-1].minor.yy394 = SQLITE_SO_ASC;}
+      case 141: /* nulls ::= NULLS FIRST */
+{yymsp[-1].minor.yy144 = SQLITE_SO_ASC;}
         break;
-      case 140: /* nulls ::= NULLS LAST */
-{yymsp[-1].minor.yy394 = SQLITE_SO_DESC;}
+      case 142: /* nulls ::= NULLS LAST */
+{yymsp[-1].minor.yy144 = SQLITE_SO_DESC;}
         break;
-      case 144: /* having_opt ::= */
-      case 146: /* limit_opt ::= */ yytestcase(yyruleno==146);
-      case 151: /* where_opt ::= */ yytestcase(yyruleno==151);
-      case 153: /* where_opt_ret ::= */ yytestcase(yyruleno==153);
-      case 230: /* case_else ::= */ yytestcase(yyruleno==230);
-      case 231: /* case_operand ::= */ yytestcase(yyruleno==231);
-      case 250: /* vinto ::= */ yytestcase(yyruleno==250);
-{yymsp[1].minor.yy528 = 0;}
+      case 146: /* having_opt ::= */
+      case 148: /* limit_opt ::= */ yytestcase(yyruleno==148);
+      case 153: /* where_opt ::= */ yytestcase(yyruleno==153);
+      case 155: /* where_opt_ret ::= */ yytestcase(yyruleno==155);
+      case 232: /* case_else ::= */ yytestcase(yyruleno==232);
+      case 233: /* case_operand ::= */ yytestcase(yyruleno==233);
+      case 252: /* vinto ::= */ yytestcase(yyruleno==252);
+{yymsp[1].minor.yy454 = 0;}
         break;
-      case 145: /* having_opt ::= HAVING expr */
-      case 152: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==152);
-      case 154: /* where_opt_ret ::= WHERE expr */ yytestcase(yyruleno==154);
-      case 229: /* case_else ::= ELSE expr */ yytestcase(yyruleno==229);
-      case 249: /* vinto ::= INTO expr */ yytestcase(yyruleno==249);
-{yymsp[-1].minor.yy528 = yymsp[0].minor.yy528;}
+      case 147: /* having_opt ::= HAVING expr */
+      case 154: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==154);
+      case 156: /* where_opt_ret ::= WHERE expr */ yytestcase(yyruleno==156);
+      case 231: /* case_else ::= ELSE expr */ yytestcase(yyruleno==231);
+      case 251: /* vinto ::= INTO expr */ yytestcase(yyruleno==251);
+{yymsp[-1].minor.yy454 = yymsp[0].minor.yy454;}
         break;
-      case 147: /* limit_opt ::= LIMIT expr */
-{yymsp[-1].minor.yy528 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy528,0);}
+      case 149: /* limit_opt ::= LIMIT expr */
+{yymsp[-1].minor.yy454 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy454,0);}
         break;
-      case 148: /* limit_opt ::= LIMIT expr OFFSET expr */
-{yymsp[-3].minor.yy528 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[-2].minor.yy528,yymsp[0].minor.yy528);}
+      case 150: /* limit_opt ::= LIMIT expr OFFSET expr */
+{yymsp[-3].minor.yy454 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[-2].minor.yy454,yymsp[0].minor.yy454);}
         break;
-      case 149: /* limit_opt ::= LIMIT expr COMMA expr */
-{yymsp[-3].minor.yy528 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy528,yymsp[-2].minor.yy528);}
+      case 151: /* limit_opt ::= LIMIT expr COMMA expr */
+{yymsp[-3].minor.yy454 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy454,yymsp[-2].minor.yy454);}
         break;
-      case 150: /* cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */
+      case 152: /* cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */
 {
-  sqlite3SrcListIndexedBy(pParse, yymsp[-2].minor.yy131, &yymsp[-1].minor.yy0);
-  sqlite3DeleteFrom(pParse,yymsp[-2].minor.yy131,yymsp[0].minor.yy528,0,0);
+  sqlite3SrcListIndexedBy(pParse, yymsp[-2].minor.yy203, &yymsp[-1].minor.yy0);
+  sqlite3DeleteFrom(pParse,yymsp[-2].minor.yy203,yymsp[0].minor.yy454,0,0);
 }
         break;
-      case 155: /* where_opt_ret ::= RETURNING selcollist */
-{sqlite3AddReturning(pParse,yymsp[0].minor.yy322); yymsp[-1].minor.yy528 = 0;}
+      case 157: /* where_opt_ret ::= RETURNING selcollist */
+{sqlite3AddReturning(pParse,yymsp[0].minor.yy14); yymsp[-1].minor.yy454 = 0;}
         break;
-      case 156: /* where_opt_ret ::= WHERE expr RETURNING selcollist */
-{sqlite3AddReturning(pParse,yymsp[0].minor.yy322); yymsp[-3].minor.yy528 = yymsp[-2].minor.yy528;}
+      case 158: /* where_opt_ret ::= WHERE expr RETURNING selcollist */
+{sqlite3AddReturning(pParse,yymsp[0].minor.yy14); yymsp[-3].minor.yy454 = yymsp[-2].minor.yy454;}
         break;
-      case 157: /* cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */
+      case 159: /* cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */
 {
-  sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy131, &yymsp[-4].minor.yy0);
-  sqlite3ExprListCheckLength(pParse,yymsp[-2].minor.yy322,"set list");
-  if( yymsp[-1].minor.yy131 ){
-    SrcList *pFromClause = yymsp[-1].minor.yy131;
+  sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy203, &yymsp[-4].minor.yy0);
+  sqlite3ExprListCheckLength(pParse,yymsp[-2].minor.yy14,"set list");
+  if( yymsp[-1].minor.yy203 ){
+    SrcList *pFromClause = yymsp[-1].minor.yy203;
     if( pFromClause->nSrc>1 ){
       Select *pSubquery;
       Token as;
@@ -175119,92 +178102,92 @@ static YYACTIONTYPE yy_reduce(
       as.z = 0;
       pFromClause = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&as,pSubquery,0);
     }
-    yymsp[-5].minor.yy131 = sqlite3SrcListAppendList(pParse, yymsp[-5].minor.yy131, pFromClause);
+    yymsp[-5].minor.yy203 = sqlite3SrcListAppendList(pParse, yymsp[-5].minor.yy203, pFromClause);
   }
-  sqlite3Update(pParse,yymsp[-5].minor.yy131,yymsp[-2].minor.yy322,yymsp[0].minor.yy528,yymsp[-6].minor.yy394,0,0,0);
+  sqlite3Update(pParse,yymsp[-5].minor.yy203,yymsp[-2].minor.yy14,yymsp[0].minor.yy454,yymsp[-6].minor.yy144,0,0,0);
 }
         break;
-      case 158: /* setlist ::= setlist COMMA nm EQ expr */
+      case 160: /* setlist ::= setlist COMMA nm EQ expr */
 {
-  yymsp[-4].minor.yy322 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy322, yymsp[0].minor.yy528);
-  sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy322, &yymsp[-2].minor.yy0, 1);
+  yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy14, yymsp[0].minor.yy454);
+  sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy14, &yymsp[-2].minor.yy0, 1);
 }
         break;
-      case 159: /* setlist ::= setlist COMMA LP idlist RP EQ expr */
+      case 161: /* setlist ::= setlist COMMA LP idlist RP EQ expr */
 {
-  yymsp[-6].minor.yy322 = sqlite3ExprListAppendVector(pParse, yymsp[-6].minor.yy322, yymsp[-3].minor.yy254, yymsp[0].minor.yy528);
+  yymsp[-6].minor.yy14 = sqlite3ExprListAppendVector(pParse, yymsp[-6].minor.yy14, yymsp[-3].minor.yy132, yymsp[0].minor.yy454);
 }
         break;
-      case 160: /* setlist ::= nm EQ expr */
+      case 162: /* setlist ::= nm EQ expr */
 {
-  yylhsminor.yy322 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy528);
-  sqlite3ExprListSetName(pParse, yylhsminor.yy322, &yymsp[-2].minor.yy0, 1);
+  yylhsminor.yy14 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy454);
+  sqlite3ExprListSetName(pParse, yylhsminor.yy14, &yymsp[-2].minor.yy0, 1);
 }
-  yymsp[-2].minor.yy322 = yylhsminor.yy322;
+  yymsp[-2].minor.yy14 = yylhsminor.yy14;
         break;
-      case 161: /* setlist ::= LP idlist RP EQ expr */
+      case 163: /* setlist ::= LP idlist RP EQ expr */
 {
-  yymsp[-4].minor.yy322 = sqlite3ExprListAppendVector(pParse, 0, yymsp[-3].minor.yy254, yymsp[0].minor.yy528);
+  yymsp[-4].minor.yy14 = sqlite3ExprListAppendVector(pParse, 0, yymsp[-3].minor.yy132, yymsp[0].minor.yy454);
 }
         break;
-      case 162: /* cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
+      case 164: /* cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
 {
-  sqlite3Insert(pParse, yymsp[-3].minor.yy131, yymsp[-1].minor.yy47, yymsp[-2].minor.yy254, yymsp[-5].minor.yy394, yymsp[0].minor.yy444);
+  sqlite3Insert(pParse, yymsp[-3].minor.yy203, yymsp[-1].minor.yy555, yymsp[-2].minor.yy132, yymsp[-5].minor.yy144, yymsp[0].minor.yy122);
 }
         break;
-      case 163: /* cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */
+      case 165: /* cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */
 {
-  sqlite3Insert(pParse, yymsp[-4].minor.yy131, 0, yymsp[-3].minor.yy254, yymsp[-6].minor.yy394, 0);
+  sqlite3Insert(pParse, yymsp[-4].minor.yy203, 0, yymsp[-3].minor.yy132, yymsp[-6].minor.yy144, 0);
 }
         break;
-      case 164: /* upsert ::= */
-{ yymsp[1].minor.yy444 = 0; }
+      case 166: /* upsert ::= */
+{ yymsp[1].minor.yy122 = 0; }
         break;
-      case 165: /* upsert ::= RETURNING selcollist */
-{ yymsp[-1].minor.yy444 = 0; sqlite3AddReturning(pParse,yymsp[0].minor.yy322); }
+      case 167: /* upsert ::= RETURNING selcollist */
+{ yymsp[-1].minor.yy122 = 0; sqlite3AddReturning(pParse,yymsp[0].minor.yy14); }
         break;
-      case 166: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */
-{ yymsp[-11].minor.yy444 = sqlite3UpsertNew(pParse->db,yymsp[-8].minor.yy322,yymsp[-6].minor.yy528,yymsp[-2].minor.yy322,yymsp[-1].minor.yy528,yymsp[0].minor.yy444);}
+      case 168: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */
+{ yymsp[-11].minor.yy122 = sqlite3UpsertNew(pParse->db,yymsp[-8].minor.yy14,yymsp[-6].minor.yy454,yymsp[-2].minor.yy14,yymsp[-1].minor.yy454,yymsp[0].minor.yy122);}
         break;
-      case 167: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */
-{ yymsp[-8].minor.yy444 = sqlite3UpsertNew(pParse->db,yymsp[-5].minor.yy322,yymsp[-3].minor.yy528,0,0,yymsp[0].minor.yy444); }
+      case 169: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */
+{ yymsp[-8].minor.yy122 = sqlite3UpsertNew(pParse->db,yymsp[-5].minor.yy14,yymsp[-3].minor.yy454,0,0,yymsp[0].minor.yy122); }
         break;
-      case 168: /* upsert ::= ON CONFLICT DO NOTHING returning */
-{ yymsp[-4].minor.yy444 = sqlite3UpsertNew(pParse->db,0,0,0,0,0); }
+      case 170: /* upsert ::= ON CONFLICT DO NOTHING returning */
+{ yymsp[-4].minor.yy122 = sqlite3UpsertNew(pParse->db,0,0,0,0,0); }
         break;
-      case 169: /* upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */
-{ yymsp[-7].minor.yy444 = sqlite3UpsertNew(pParse->db,0,0,yymsp[-2].minor.yy322,yymsp[-1].minor.yy528,0);}
+      case 171: /* upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */
+{ yymsp[-7].minor.yy122 = sqlite3UpsertNew(pParse->db,0,0,yymsp[-2].minor.yy14,yymsp[-1].minor.yy454,0);}
         break;
-      case 170: /* returning ::= RETURNING selcollist */
-{sqlite3AddReturning(pParse,yymsp[0].minor.yy322);}
+      case 172: /* returning ::= RETURNING selcollist */
+{sqlite3AddReturning(pParse,yymsp[0].minor.yy14);}
         break;
-      case 173: /* idlist_opt ::= */
-{yymsp[1].minor.yy254 = 0;}
+      case 175: /* idlist_opt ::= */
+{yymsp[1].minor.yy132 = 0;}
         break;
-      case 174: /* idlist_opt ::= LP idlist RP */
-{yymsp[-2].minor.yy254 = yymsp[-1].minor.yy254;}
+      case 176: /* idlist_opt ::= LP idlist RP */
+{yymsp[-2].minor.yy132 = yymsp[-1].minor.yy132;}
         break;
-      case 175: /* idlist ::= idlist COMMA nm */
-{yymsp[-2].minor.yy254 = sqlite3IdListAppend(pParse,yymsp[-2].minor.yy254,&yymsp[0].minor.yy0);}
+      case 177: /* idlist ::= idlist COMMA nm */
+{yymsp[-2].minor.yy132 = sqlite3IdListAppend(pParse,yymsp[-2].minor.yy132,&yymsp[0].minor.yy0);}
         break;
-      case 176: /* idlist ::= nm */
-{yymsp[0].minor.yy254 = sqlite3IdListAppend(pParse,0,&yymsp[0].minor.yy0); /*A-overwrites-Y*/}
+      case 178: /* idlist ::= nm */
+{yymsp[0].minor.yy132 = sqlite3IdListAppend(pParse,0,&yymsp[0].minor.yy0); /*A-overwrites-Y*/}
         break;
-      case 177: /* expr ::= LP expr RP */
-{yymsp[-2].minor.yy528 = yymsp[-1].minor.yy528;}
+      case 179: /* expr ::= LP expr RP */
+{yymsp[-2].minor.yy454 = yymsp[-1].minor.yy454;}
         break;
-      case 178: /* expr ::= ID|INDEXED|JOIN_KW */
-{yymsp[0].minor.yy528=tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0); /*A-overwrites-X*/}
+      case 180: /* expr ::= ID|INDEXED|JOIN_KW */
+{yymsp[0].minor.yy454=tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0); /*A-overwrites-X*/}
         break;
-      case 179: /* expr ::= nm DOT nm */
+      case 181: /* expr ::= nm DOT nm */
 {
   Expr *temp1 = tokenExpr(pParse,TK_ID,yymsp[-2].minor.yy0);
   Expr *temp2 = tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0);
-  yylhsminor.yy528 = sqlite3PExpr(pParse, TK_DOT, temp1, temp2);
+  yylhsminor.yy454 = sqlite3PExpr(pParse, TK_DOT, temp1, temp2);
 }
-  yymsp[-2].minor.yy528 = yylhsminor.yy528;
+  yymsp[-2].minor.yy454 = yylhsminor.yy454;
         break;
-      case 180: /* expr ::= nm DOT nm DOT nm */
+      case 182: /* expr ::= nm DOT nm DOT nm */
 {
   Expr *temp1 = tokenExpr(pParse,TK_ID,yymsp[-4].minor.yy0);
   Expr *temp2 = tokenExpr(pParse,TK_ID,yymsp[-2].minor.yy0);
@@ -175213,27 +178196,27 @@ static YYACTIONTYPE yy_reduce(
   if( IN_RENAME_OBJECT ){
     sqlite3RenameTokenRemap(pParse, 0, temp1);
   }
-  yylhsminor.yy528 = sqlite3PExpr(pParse, TK_DOT, temp1, temp4);
+  yylhsminor.yy454 = sqlite3PExpr(pParse, TK_DOT, temp1, temp4);
 }
-  yymsp[-4].minor.yy528 = yylhsminor.yy528;
+  yymsp[-4].minor.yy454 = yylhsminor.yy454;
         break;
-      case 181: /* term ::= NULL|FLOAT|BLOB */
-      case 182: /* term ::= STRING */ yytestcase(yyruleno==182);
-{yymsp[0].minor.yy528=tokenExpr(pParse,yymsp[0].major,yymsp[0].minor.yy0); /*A-overwrites-X*/}
+      case 183: /* term ::= NULL|FLOAT|BLOB */
+      case 184: /* term ::= STRING */ yytestcase(yyruleno==184);
+{yymsp[0].minor.yy454=tokenExpr(pParse,yymsp[0].major,yymsp[0].minor.yy0); /*A-overwrites-X*/}
         break;
-      case 183: /* term ::= INTEGER */
+      case 185: /* term ::= INTEGER */
 {
-  yylhsminor.yy528 = sqlite3ExprAlloc(pParse->db, TK_INTEGER, &yymsp[0].minor.yy0, 1);
-  if( yylhsminor.yy528 ) yylhsminor.yy528->w.iOfst = (int)(yymsp[0].minor.yy0.z - pParse->zTail);
+  yylhsminor.yy454 = sqlite3ExprAlloc(pParse->db, TK_INTEGER, &yymsp[0].minor.yy0, 1);
+  if( yylhsminor.yy454 ) yylhsminor.yy454->w.iOfst = (int)(yymsp[0].minor.yy0.z - pParse->zTail);
 }
-  yymsp[0].minor.yy528 = yylhsminor.yy528;
+  yymsp[0].minor.yy454 = yylhsminor.yy454;
         break;
-      case 184: /* expr ::= VARIABLE */
+      case 186: /* expr ::= VARIABLE */
 {
   if( !(yymsp[0].minor.yy0.z[0]=='#' && sqlite3Isdigit(yymsp[0].minor.yy0.z[1])) ){
     u32 n = yymsp[0].minor.yy0.n;
-    yymsp[0].minor.yy528 = tokenExpr(pParse, TK_VARIABLE, yymsp[0].minor.yy0);
-    sqlite3ExprAssignVarNumber(pParse, yymsp[0].minor.yy528, n);
+    yymsp[0].minor.yy454 = tokenExpr(pParse, TK_VARIABLE, yymsp[0].minor.yy0);
+    sqlite3ExprAssignVarNumber(pParse, yymsp[0].minor.yy454, n);
   }else{
     /* When doing a nested parse, one can include terms in an expression
     ** that look like this:   #1 #2 ...  These terms refer to registers
@@ -175242,194 +178225,203 @@ static YYACTIONTYPE yy_reduce(
     assert( t.n>=2 );
     if( pParse->nested==0 ){
       sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &t);
-      yymsp[0].minor.yy528 = 0;
+      yymsp[0].minor.yy454 = 0;
     }else{
-      yymsp[0].minor.yy528 = sqlite3PExpr(pParse, TK_REGISTER, 0, 0);
-      if( yymsp[0].minor.yy528 ) sqlite3GetInt32(&t.z[1], &yymsp[0].minor.yy528->iTable);
+      yymsp[0].minor.yy454 = sqlite3PExpr(pParse, TK_REGISTER, 0, 0);
+      if( yymsp[0].minor.yy454 ) sqlite3GetInt32(&t.z[1], &yymsp[0].minor.yy454->iTable);
     }
   }
 }
         break;
-      case 185: /* expr ::= expr COLLATE ID|STRING */
+      case 187: /* expr ::= expr COLLATE ID|STRING */
 {
-  yymsp[-2].minor.yy528 = sqlite3ExprAddCollateToken(pParse, yymsp[-2].minor.yy528, &yymsp[0].minor.yy0, 1);
+  yymsp[-2].minor.yy454 = sqlite3ExprAddCollateToken(pParse, yymsp[-2].minor.yy454, &yymsp[0].minor.yy0, 1);
 }
         break;
-      case 186: /* expr ::= CAST LP expr AS typetoken RP */
+      case 188: /* expr ::= CAST LP expr AS typetoken RP */
 {
-  yymsp[-5].minor.yy528 = sqlite3ExprAlloc(pParse->db, TK_CAST, &yymsp[-1].minor.yy0, 1);
-  sqlite3ExprAttachSubtrees(pParse->db, yymsp[-5].minor.yy528, yymsp[-3].minor.yy528, 0);
+  yymsp[-5].minor.yy454 = sqlite3ExprAlloc(pParse->db, TK_CAST, &yymsp[-1].minor.yy0, 1);
+  sqlite3ExprAttachSubtrees(pParse->db, yymsp[-5].minor.yy454, yymsp[-3].minor.yy454, 0);
 }
         break;
-      case 187: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP */
+      case 189: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP */
 {
-  yylhsminor.yy528 = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy322, &yymsp[-4].minor.yy0, yymsp[-2].minor.yy394);
+  yylhsminor.yy454 = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy14, &yymsp[-4].minor.yy0, yymsp[-2].minor.yy144);
 }
-  yymsp[-4].minor.yy528 = yylhsminor.yy528;
+  yymsp[-4].minor.yy454 = yylhsminor.yy454;
         break;
-      case 188: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP */
+      case 190: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP */
 {
-  yylhsminor.yy528 = sqlite3ExprFunction(pParse, yymsp[-4].minor.yy322, &yymsp[-7].minor.yy0, yymsp[-5].minor.yy394);
-  sqlite3ExprAddFunctionOrderBy(pParse, yylhsminor.yy528, yymsp[-1].minor.yy322);
+  yylhsminor.yy454 = sqlite3ExprFunction(pParse, yymsp[-4].minor.yy14, &yymsp[-7].minor.yy0, yymsp[-5].minor.yy144);
+  sqlite3ExprAddFunctionOrderBy(pParse, yylhsminor.yy454, yymsp[-1].minor.yy14);
 }
-  yymsp[-7].minor.yy528 = yylhsminor.yy528;
+  yymsp[-7].minor.yy454 = yylhsminor.yy454;
         break;
-      case 189: /* expr ::= ID|INDEXED|JOIN_KW LP STAR RP */
+      case 191: /* expr ::= ID|INDEXED|JOIN_KW LP STAR RP */
 {
-  yylhsminor.yy528 = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0, 0);
+  yylhsminor.yy454 = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0, 0);
 }
-  yymsp[-3].minor.yy528 = yylhsminor.yy528;
+  yymsp[-3].minor.yy454 = yylhsminor.yy454;
         break;
-      case 190: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over */
+      case 192: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over */
 {
-  yylhsminor.yy528 = sqlite3ExprFunction(pParse, yymsp[-2].minor.yy322, &yymsp[-5].minor.yy0, yymsp[-3].minor.yy394);
-  sqlite3WindowAttach(pParse, yylhsminor.yy528, yymsp[0].minor.yy41);
+  yylhsminor.yy454 = sqlite3ExprFunction(pParse, yymsp[-2].minor.yy14, &yymsp[-5].minor.yy0, yymsp[-3].minor.yy144);
+  sqlite3WindowAttach(pParse, yylhsminor.yy454, yymsp[0].minor.yy211);
 }
-  yymsp[-5].minor.yy528 = yylhsminor.yy528;
+  yymsp[-5].minor.yy454 = yylhsminor.yy454;
         break;
-      case 191: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP filter_over */
+      case 193: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP filter_over */
 {
-  yylhsminor.yy528 = sqlite3ExprFunction(pParse, yymsp[-5].minor.yy322, &yymsp[-8].minor.yy0, yymsp[-6].minor.yy394);
-  sqlite3WindowAttach(pParse, yylhsminor.yy528, yymsp[0].minor.yy41);
-  sqlite3ExprAddFunctionOrderBy(pParse, yylhsminor.yy528, yymsp[-2].minor.yy322);
+  yylhsminor.yy454 = sqlite3ExprFunction(pParse, yymsp[-5].minor.yy14, &yymsp[-8].minor.yy0, yymsp[-6].minor.yy144);
+  sqlite3WindowAttach(pParse, yylhsminor.yy454, yymsp[0].minor.yy211);
+  sqlite3ExprAddFunctionOrderBy(pParse, yylhsminor.yy454, yymsp[-2].minor.yy14);
 }
-  yymsp[-8].minor.yy528 = yylhsminor.yy528;
+  yymsp[-8].minor.yy454 = yylhsminor.yy454;
         break;
-      case 192: /* expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over */
+      case 194: /* expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over */
 {
-  yylhsminor.yy528 = sqlite3ExprFunction(pParse, 0, &yymsp[-4].minor.yy0, 0);
-  sqlite3WindowAttach(pParse, yylhsminor.yy528, yymsp[0].minor.yy41);
+  yylhsminor.yy454 = sqlite3ExprFunction(pParse, 0, &yymsp[-4].minor.yy0, 0);
+  sqlite3WindowAttach(pParse, yylhsminor.yy454, yymsp[0].minor.yy211);
 }
-  yymsp[-4].minor.yy528 = yylhsminor.yy528;
+  yymsp[-4].minor.yy454 = yylhsminor.yy454;
         break;
-      case 193: /* term ::= CTIME_KW */
+      case 195: /* term ::= CTIME_KW */
 {
-  yylhsminor.yy528 = sqlite3ExprFunction(pParse, 0, &yymsp[0].minor.yy0, 0);
+  yylhsminor.yy454 = sqlite3ExprFunction(pParse, 0, &yymsp[0].minor.yy0, 0);
 }
-  yymsp[0].minor.yy528 = yylhsminor.yy528;
+  yymsp[0].minor.yy454 = yylhsminor.yy454;
         break;
-      case 194: /* expr ::= LP nexprlist COMMA expr RP */
+      case 196: /* expr ::= LP nexprlist COMMA expr RP */
 {
-  ExprList *pList = sqlite3ExprListAppend(pParse, yymsp[-3].minor.yy322, yymsp[-1].minor.yy528);
-  yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_VECTOR, 0, 0);
-  if( yymsp[-4].minor.yy528 ){
-    yymsp[-4].minor.yy528->x.pList = pList;
+  ExprList *pList = sqlite3ExprListAppend(pParse, yymsp[-3].minor.yy14, yymsp[-1].minor.yy454);
+  yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_VECTOR, 0, 0);
+  if( yymsp[-4].minor.yy454 ){
+    yymsp[-4].minor.yy454->x.pList = pList;
     if( ALWAYS(pList->nExpr) ){
-      yymsp[-4].minor.yy528->flags |= pList->a[0].pExpr->flags & EP_Propagate;
+      yymsp[-4].minor.yy454->flags |= pList->a[0].pExpr->flags & EP_Propagate;
     }
   }else{
     sqlite3ExprListDelete(pParse->db, pList);
   }
 }
         break;
-      case 195: /* expr ::= expr AND expr */
-{yymsp[-2].minor.yy528=sqlite3ExprAnd(pParse,yymsp[-2].minor.yy528,yymsp[0].minor.yy528);}
+      case 197: /* expr ::= expr AND expr */
+{yymsp[-2].minor.yy454=sqlite3ExprAnd(pParse,yymsp[-2].minor.yy454,yymsp[0].minor.yy454);}
         break;
-      case 196: /* expr ::= expr OR expr */
-      case 197: /* expr ::= expr LT|GT|GE|LE expr */ yytestcase(yyruleno==197);
-      case 198: /* expr ::= expr EQ|NE expr */ yytestcase(yyruleno==198);
-      case 199: /* expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */ yytestcase(yyruleno==199);
-      case 200: /* expr ::= expr PLUS|MINUS expr */ yytestcase(yyruleno==200);
-      case 201: /* expr ::= expr STAR|SLASH|REM expr */ yytestcase(yyruleno==201);
-      case 202: /* expr ::= expr CONCAT expr */ yytestcase(yyruleno==202);
-{yymsp[-2].minor.yy528=sqlite3PExpr(pParse,yymsp[-1].major,yymsp[-2].minor.yy528,yymsp[0].minor.yy528);}
+      case 198: /* expr ::= expr OR expr */
+      case 199: /* expr ::= expr LT|GT|GE|LE expr */ yytestcase(yyruleno==199);
+      case 200: /* expr ::= expr EQ|NE expr */ yytestcase(yyruleno==200);
+      case 201: /* expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */ yytestcase(yyruleno==201);
+      case 202: /* expr ::= expr PLUS|MINUS expr */ yytestcase(yyruleno==202);
+      case 203: /* expr ::= expr STAR|SLASH|REM expr */ yytestcase(yyruleno==203);
+      case 204: /* expr ::= expr CONCAT expr */ yytestcase(yyruleno==204);
+{yymsp[-2].minor.yy454=sqlite3PExpr(pParse,yymsp[-1].major,yymsp[-2].minor.yy454,yymsp[0].minor.yy454);}
         break;
-      case 203: /* likeop ::= NOT LIKE_KW|MATCH */
+      case 205: /* likeop ::= NOT LIKE_KW|MATCH */
 {yymsp[-1].minor.yy0=yymsp[0].minor.yy0; yymsp[-1].minor.yy0.n|=0x80000000; /*yymsp[-1].minor.yy0-overwrite-yymsp[0].minor.yy0*/}
         break;
-      case 204: /* expr ::= expr likeop expr */
+      case 206: /* expr ::= expr likeop expr */
 {
   ExprList *pList;
   int bNot = yymsp[-1].minor.yy0.n & 0x80000000;
   yymsp[-1].minor.yy0.n &= 0x7fffffff;
-  pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy528);
-  pList = sqlite3ExprListAppend(pParse,pList, yymsp[-2].minor.yy528);
-  yymsp[-2].minor.yy528 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0);
-  if( bNot ) yymsp[-2].minor.yy528 = sqlite3PExpr(pParse, TK_NOT, yymsp[-2].minor.yy528, 0);
-  if( yymsp[-2].minor.yy528 ) yymsp[-2].minor.yy528->flags |= EP_InfixFunc;
+  pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy454);
+  pList = sqlite3ExprListAppend(pParse,pList, yymsp[-2].minor.yy454);
+  yymsp[-2].minor.yy454 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0);
+  if( bNot ) yymsp[-2].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-2].minor.yy454, 0);
+  if( yymsp[-2].minor.yy454 ) yymsp[-2].minor.yy454->flags |= EP_InfixFunc;
 }
         break;
-      case 205: /* expr ::= expr likeop expr ESCAPE expr */
+      case 207: /* expr ::= expr likeop expr ESCAPE expr */
 {
   ExprList *pList;
   int bNot = yymsp[-3].minor.yy0.n & 0x80000000;
   yymsp[-3].minor.yy0.n &= 0x7fffffff;
-  pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy528);
-  pList = sqlite3ExprListAppend(pParse,pList, yymsp[-4].minor.yy528);
-  pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy528);
-  yymsp[-4].minor.yy528 = sqlite3ExprFunction(pParse, pList, &yymsp[-3].minor.yy0, 0);
-  if( bNot ) yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy528, 0);
-  if( yymsp[-4].minor.yy528 ) yymsp[-4].minor.yy528->flags |= EP_InfixFunc;
+  pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy454);
+  pList = sqlite3ExprListAppend(pParse,pList, yymsp[-4].minor.yy454);
+  pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy454);
+  yymsp[-4].minor.yy454 = sqlite3ExprFunction(pParse, pList, &yymsp[-3].minor.yy0, 0);
+  if( bNot ) yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy454, 0);
+  if( yymsp[-4].minor.yy454 ) yymsp[-4].minor.yy454->flags |= EP_InfixFunc;
 }
         break;
-      case 206: /* expr ::= expr ISNULL|NOTNULL */
-{yymsp[-1].minor.yy528 = sqlite3PExpr(pParse,yymsp[0].major,yymsp[-1].minor.yy528,0);}
+      case 208: /* expr ::= expr ISNULL|NOTNULL */
+{yymsp[-1].minor.yy454 = sqlite3PExpr(pParse,yymsp[0].major,yymsp[-1].minor.yy454,0);}
         break;
-      case 207: /* expr ::= expr NOT NULL */
-{yymsp[-2].minor.yy528 = sqlite3PExpr(pParse,TK_NOTNULL,yymsp[-2].minor.yy528,0);}
+      case 209: /* expr ::= expr NOT NULL */
+{yymsp[-2].minor.yy454 = sqlite3PExpr(pParse,TK_NOTNULL,yymsp[-2].minor.yy454,0);}
         break;
-      case 208: /* expr ::= expr IS expr */
+      case 210: /* expr ::= expr IS expr */
 {
-  yymsp[-2].minor.yy528 = sqlite3PExpr(pParse,TK_IS,yymsp[-2].minor.yy528,yymsp[0].minor.yy528);
-  binaryToUnaryIfNull(pParse, yymsp[0].minor.yy528, yymsp[-2].minor.yy528, TK_ISNULL);
+  yymsp[-2].minor.yy454 = sqlite3PExpr(pParse,TK_IS,yymsp[-2].minor.yy454,yymsp[0].minor.yy454);
+  binaryToUnaryIfNull(pParse, yymsp[0].minor.yy454, yymsp[-2].minor.yy454, TK_ISNULL);
 }
         break;
-      case 209: /* expr ::= expr IS NOT expr */
+      case 211: /* expr ::= expr IS NOT expr */
 {
-  yymsp[-3].minor.yy528 = sqlite3PExpr(pParse,TK_ISNOT,yymsp[-3].minor.yy528,yymsp[0].minor.yy528);
-  binaryToUnaryIfNull(pParse, yymsp[0].minor.yy528, yymsp[-3].minor.yy528, TK_NOTNULL);
+  yymsp[-3].minor.yy454 = sqlite3PExpr(pParse,TK_ISNOT,yymsp[-3].minor.yy454,yymsp[0].minor.yy454);
+  binaryToUnaryIfNull(pParse, yymsp[0].minor.yy454, yymsp[-3].minor.yy454, TK_NOTNULL);
 }
         break;
-      case 210: /* expr ::= expr IS NOT DISTINCT FROM expr */
+      case 212: /* expr ::= expr IS NOT DISTINCT FROM expr */
 {
-  yymsp[-5].minor.yy528 = sqlite3PExpr(pParse,TK_IS,yymsp[-5].minor.yy528,yymsp[0].minor.yy528);
-  binaryToUnaryIfNull(pParse, yymsp[0].minor.yy528, yymsp[-5].minor.yy528, TK_ISNULL);
+  yymsp[-5].minor.yy454 = sqlite3PExpr(pParse,TK_IS,yymsp[-5].minor.yy454,yymsp[0].minor.yy454);
+  binaryToUnaryIfNull(pParse, yymsp[0].minor.yy454, yymsp[-5].minor.yy454, TK_ISNULL);
 }
         break;
-      case 211: /* expr ::= expr IS DISTINCT FROM expr */
+      case 213: /* expr ::= expr IS DISTINCT FROM expr */
 {
-  yymsp[-4].minor.yy528 = sqlite3PExpr(pParse,TK_ISNOT,yymsp[-4].minor.yy528,yymsp[0].minor.yy528);
-  binaryToUnaryIfNull(pParse, yymsp[0].minor.yy528, yymsp[-4].minor.yy528, TK_NOTNULL);
+  yymsp[-4].minor.yy454 = sqlite3PExpr(pParse,TK_ISNOT,yymsp[-4].minor.yy454,yymsp[0].minor.yy454);
+  binaryToUnaryIfNull(pParse, yymsp[0].minor.yy454, yymsp[-4].minor.yy454, TK_NOTNULL);
 }
         break;
-      case 212: /* expr ::= NOT expr */
-      case 213: /* expr ::= BITNOT expr */ yytestcase(yyruleno==213);
-{yymsp[-1].minor.yy528 = sqlite3PExpr(pParse, yymsp[-1].major, yymsp[0].minor.yy528, 0);/*A-overwrites-B*/}
+      case 214: /* expr ::= NOT expr */
+      case 215: /* expr ::= BITNOT expr */ yytestcase(yyruleno==215);
+{yymsp[-1].minor.yy454 = sqlite3PExpr(pParse, yymsp[-1].major, yymsp[0].minor.yy454, 0);/*A-overwrites-B*/}
         break;
-      case 214: /* expr ::= PLUS|MINUS expr */
+      case 216: /* expr ::= PLUS|MINUS expr */
 {
-  yymsp[-1].minor.yy528 = sqlite3PExpr(pParse, yymsp[-1].major==TK_PLUS ? TK_UPLUS : TK_UMINUS, yymsp[0].minor.yy528, 0);
-  /*A-overwrites-B*/
+  Expr *p = yymsp[0].minor.yy454;
+  u8 op = yymsp[-1].major + (TK_UPLUS-TK_PLUS);
+  assert( TK_UPLUS>TK_PLUS );
+  assert( TK_UMINUS == TK_MINUS + (TK_UPLUS - TK_PLUS) );
+  if( p && p->op==TK_UPLUS ){
+    p->op = op;
+    yymsp[-1].minor.yy454 = p;
+  }else{
+    yymsp[-1].minor.yy454 = sqlite3PExpr(pParse, op, p, 0);
+    /*A-overwrites-B*/
+  }
 }
         break;
-      case 215: /* expr ::= expr PTR expr */
+      case 217: /* expr ::= expr PTR expr */
 {
-  ExprList *pList = sqlite3ExprListAppend(pParse, 0, yymsp[-2].minor.yy528);
-  pList = sqlite3ExprListAppend(pParse, pList, yymsp[0].minor.yy528);
-  yylhsminor.yy528 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0);
+  ExprList *pList = sqlite3ExprListAppend(pParse, 0, yymsp[-2].minor.yy454);
+  pList = sqlite3ExprListAppend(pParse, pList, yymsp[0].minor.yy454);
+  yylhsminor.yy454 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0);
 }
-  yymsp[-2].minor.yy528 = yylhsminor.yy528;
+  yymsp[-2].minor.yy454 = yylhsminor.yy454;
         break;
-      case 216: /* between_op ::= BETWEEN */
-      case 219: /* in_op ::= IN */ yytestcase(yyruleno==219);
-{yymsp[0].minor.yy394 = 0;}
+      case 218: /* between_op ::= BETWEEN */
+      case 221: /* in_op ::= IN */ yytestcase(yyruleno==221);
+{yymsp[0].minor.yy144 = 0;}
         break;
-      case 218: /* expr ::= expr between_op expr AND expr */
+      case 220: /* expr ::= expr between_op expr AND expr */
 {
-  ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy528);
-  pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy528);
-  yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy528, 0);
-  if( yymsp[-4].minor.yy528 ){
-    yymsp[-4].minor.yy528->x.pList = pList;
+  ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy454);
+  pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy454);
+  yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy454, 0);
+  if( yymsp[-4].minor.yy454 ){
+    yymsp[-4].minor.yy454->x.pList = pList;
   }else{
     sqlite3ExprListDelete(pParse->db, pList);
   }
-  if( yymsp[-3].minor.yy394 ) yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy528, 0);
+  if( yymsp[-3].minor.yy144 ) yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy454, 0);
 }
         break;
-      case 221: /* expr ::= expr in_op LP exprlist RP */
+      case 223: /* expr ::= expr in_op LP exprlist RP */
 {
-    if( yymsp[-1].minor.yy322==0 ){
+    if( yymsp[-1].minor.yy14==0 ){
       /* Expressions of the form
       **
       **      expr1 IN ()
@@ -175438,208 +178430,208 @@ static YYACTIONTYPE yy_reduce(
       ** simplify to constants 0 (false) and 1 (true), respectively,
       ** regardless of the value of expr1.
       */
-      sqlite3ExprUnmapAndDelete(pParse, yymsp[-4].minor.yy528);
-      yymsp[-4].minor.yy528 = sqlite3Expr(pParse->db, TK_STRING, yymsp[-3].minor.yy394 ? "true" : "false");
-      if( yymsp[-4].minor.yy528 ) sqlite3ExprIdToTrueFalse(yymsp[-4].minor.yy528);
+      sqlite3ExprUnmapAndDelete(pParse, yymsp[-4].minor.yy454);
+      yymsp[-4].minor.yy454 = sqlite3Expr(pParse->db, TK_STRING, yymsp[-3].minor.yy144 ? "true" : "false");
+      if( yymsp[-4].minor.yy454 ) sqlite3ExprIdToTrueFalse(yymsp[-4].minor.yy454);
     }else{
-      Expr *pRHS = yymsp[-1].minor.yy322->a[0].pExpr;
-      if( yymsp[-1].minor.yy322->nExpr==1 && sqlite3ExprIsConstant(pRHS) && yymsp[-4].minor.yy528->op!=TK_VECTOR ){
-        yymsp[-1].minor.yy322->a[0].pExpr = 0;
-        sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy322);
+      Expr *pRHS = yymsp[-1].minor.yy14->a[0].pExpr;
+      if( yymsp[-1].minor.yy14->nExpr==1 && sqlite3ExprIsConstant(pParse,pRHS) && yymsp[-4].minor.yy454->op!=TK_VECTOR ){
+        yymsp[-1].minor.yy14->a[0].pExpr = 0;
+        sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy14);
         pRHS = sqlite3PExpr(pParse, TK_UPLUS, pRHS, 0);
-        yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_EQ, yymsp[-4].minor.yy528, pRHS);
-      }else if( yymsp[-1].minor.yy322->nExpr==1 && pRHS->op==TK_SELECT ){
-        yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy528, 0);
-        sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy528, pRHS->x.pSelect);
+        yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_EQ, yymsp[-4].minor.yy454, pRHS);
+      }else if( yymsp[-1].minor.yy14->nExpr==1 && pRHS->op==TK_SELECT ){
+        yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy454, 0);
+        sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy454, pRHS->x.pSelect);
         pRHS->x.pSelect = 0;
-        sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy322);
+        sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy14);
       }else{
-        yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy528, 0);
-        if( yymsp[-4].minor.yy528==0 ){
-          sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy322);
-        }else if( yymsp[-4].minor.yy528->pLeft->op==TK_VECTOR ){
-          int nExpr = yymsp[-4].minor.yy528->pLeft->x.pList->nExpr;
-          Select *pSelectRHS = sqlite3ExprListToValues(pParse, nExpr, yymsp[-1].minor.yy322);
+        yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy454, 0);
+        if( yymsp[-4].minor.yy454==0 ){
+          sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy14);
+        }else if( yymsp[-4].minor.yy454->pLeft->op==TK_VECTOR ){
+          int nExpr = yymsp[-4].minor.yy454->pLeft->x.pList->nExpr;
+          Select *pSelectRHS = sqlite3ExprListToValues(pParse, nExpr, yymsp[-1].minor.yy14);
           if( pSelectRHS ){
             parserDoubleLinkSelect(pParse, pSelectRHS);
-            sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy528, pSelectRHS);
+            sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy454, pSelectRHS);
           }
         }else{
-          yymsp[-4].minor.yy528->x.pList = yymsp[-1].minor.yy322;
-          sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy528);
+          yymsp[-4].minor.yy454->x.pList = yymsp[-1].minor.yy14;
+          sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy454);
         }
       }
-      if( yymsp[-3].minor.yy394 ) yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy528, 0);
+      if( yymsp[-3].minor.yy144 ) yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy454, 0);
     }
   }
         break;
-      case 222: /* expr ::= LP select RP */
+      case 224: /* expr ::= LP select RP */
 {
-    yymsp[-2].minor.yy528 = sqlite3PExpr(pParse, TK_SELECT, 0, 0);
-    sqlite3PExprAddSelect(pParse, yymsp[-2].minor.yy528, yymsp[-1].minor.yy47);
+    yymsp[-2].minor.yy454 = sqlite3PExpr(pParse, TK_SELECT, 0, 0);
+    sqlite3PExprAddSelect(pParse, yymsp[-2].minor.yy454, yymsp[-1].minor.yy555);
   }
         break;
-      case 223: /* expr ::= expr in_op LP select RP */
+      case 225: /* expr ::= expr in_op LP select RP */
 {
-    yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy528, 0);
-    sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy528, yymsp[-1].minor.yy47);
-    if( yymsp[-3].minor.yy394 ) yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy528, 0);
+    yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy454, 0);
+    sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy454, yymsp[-1].minor.yy555);
+    if( yymsp[-3].minor.yy144 ) yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy454, 0);
   }
         break;
-      case 224: /* expr ::= expr in_op nm dbnm paren_exprlist */
+      case 226: /* expr ::= expr in_op nm dbnm paren_exprlist */
 {
     SrcList *pSrc = sqlite3SrcListAppend(pParse, 0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);
     Select *pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0);
-    if( yymsp[0].minor.yy322 )  sqlite3SrcListFuncArgs(pParse, pSelect ? pSrc : 0, yymsp[0].minor.yy322);
-    yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy528, 0);
-    sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy528, pSelect);
-    if( yymsp[-3].minor.yy394 ) yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy528, 0);
+    if( yymsp[0].minor.yy14 )  sqlite3SrcListFuncArgs(pParse, pSelect ? pSrc : 0, yymsp[0].minor.yy14);
+    yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy454, 0);
+    sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy454, pSelect);
+    if( yymsp[-3].minor.yy144 ) yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy454, 0);
   }
         break;
-      case 225: /* expr ::= EXISTS LP select RP */
+      case 227: /* expr ::= EXISTS LP select RP */
 {
     Expr *p;
-    p = yymsp[-3].minor.yy528 = sqlite3PExpr(pParse, TK_EXISTS, 0, 0);
-    sqlite3PExprAddSelect(pParse, p, yymsp[-1].minor.yy47);
+    p = yymsp[-3].minor.yy454 = sqlite3PExpr(pParse, TK_EXISTS, 0, 0);
+    sqlite3PExprAddSelect(pParse, p, yymsp[-1].minor.yy555);
   }
         break;
-      case 226: /* expr ::= CASE case_operand case_exprlist case_else END */
+      case 228: /* expr ::= CASE case_operand case_exprlist case_else END */
 {
-  yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy528, 0);
-  if( yymsp[-4].minor.yy528 ){
-    yymsp[-4].minor.yy528->x.pList = yymsp[-1].minor.yy528 ? sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy322,yymsp[-1].minor.yy528) : yymsp[-2].minor.yy322;
-    sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy528);
+  yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy454, 0);
+  if( yymsp[-4].minor.yy454 ){
+    yymsp[-4].minor.yy454->x.pList = yymsp[-1].minor.yy454 ? sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy14,yymsp[-1].minor.yy454) : yymsp[-2].minor.yy14;
+    sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy454);
   }else{
-    sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy322);
-    sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy528);
+    sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy14);
+    sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy454);
   }
 }
         break;
-      case 227: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */
+      case 229: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */
 {
-  yymsp[-4].minor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy322, yymsp[-2].minor.yy528);
-  yymsp[-4].minor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy322, yymsp[0].minor.yy528);
+  yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14, yymsp[-2].minor.yy454);
+  yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14, yymsp[0].minor.yy454);
 }
         break;
-      case 228: /* case_exprlist ::= WHEN expr THEN expr */
+      case 230: /* case_exprlist ::= WHEN expr THEN expr */
 {
-  yymsp[-3].minor.yy322 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy528);
-  yymsp[-3].minor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy322, yymsp[0].minor.yy528);
+  yymsp[-3].minor.yy14 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy454);
+  yymsp[-3].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy14, yymsp[0].minor.yy454);
 }
         break;
-      case 233: /* nexprlist ::= nexprlist COMMA expr */
-{yymsp[-2].minor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy322,yymsp[0].minor.yy528);}
+      case 235: /* nexprlist ::= nexprlist COMMA expr */
+{yymsp[-2].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy14,yymsp[0].minor.yy454);}
         break;
-      case 234: /* nexprlist ::= expr */
-{yymsp[0].minor.yy322 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy528); /*A-overwrites-Y*/}
+      case 236: /* nexprlist ::= expr */
+{yymsp[0].minor.yy14 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy454); /*A-overwrites-Y*/}
         break;
-      case 236: /* paren_exprlist ::= LP exprlist RP */
-      case 241: /* eidlist_opt ::= LP eidlist RP */ yytestcase(yyruleno==241);
-{yymsp[-2].minor.yy322 = yymsp[-1].minor.yy322;}
+      case 238: /* paren_exprlist ::= LP exprlist RP */
+      case 243: /* eidlist_opt ::= LP eidlist RP */ yytestcase(yyruleno==243);
+{yymsp[-2].minor.yy14 = yymsp[-1].minor.yy14;}
         break;
-      case 237: /* cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
+      case 239: /* cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
 {
   sqlite3CreateIndex(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0,
-                     sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,0), yymsp[-2].minor.yy322, yymsp[-10].minor.yy394,
-                      &yymsp[-11].minor.yy0, yymsp[0].minor.yy528, SQLITE_SO_ASC, yymsp[-8].minor.yy394, SQLITE_IDXTYPE_APPDEF);
+                     sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,0), yymsp[-2].minor.yy14, yymsp[-10].minor.yy144,
+                      &yymsp[-11].minor.yy0, yymsp[0].minor.yy454, SQLITE_SO_ASC, yymsp[-8].minor.yy144, SQLITE_IDXTYPE_APPDEF);
   if( IN_RENAME_OBJECT && pParse->pNewIndex ){
     sqlite3RenameTokenMap(pParse, pParse->pNewIndex->zName, &yymsp[-4].minor.yy0);
   }
 }
         break;
-      case 238: /* uniqueflag ::= UNIQUE */
-      case 280: /* raisetype ::= ABORT */ yytestcase(yyruleno==280);
-{yymsp[0].minor.yy394 = OE_Abort;}
+      case 240: /* uniqueflag ::= UNIQUE */
+      case 282: /* raisetype ::= ABORT */ yytestcase(yyruleno==282);
+{yymsp[0].minor.yy144 = OE_Abort;}
         break;
-      case 239: /* uniqueflag ::= */
-{yymsp[1].minor.yy394 = OE_None;}
+      case 241: /* uniqueflag ::= */
+{yymsp[1].minor.yy144 = OE_None;}
         break;
-      case 242: /* eidlist ::= eidlist COMMA nm collate sortorder */
+      case 244: /* eidlist ::= eidlist COMMA nm collate sortorder */
 {
-  yymsp[-4].minor.yy322 = parserAddExprIdListTerm(pParse, yymsp[-4].minor.yy322, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy394, yymsp[0].minor.yy394);
+  yymsp[-4].minor.yy14 = parserAddExprIdListTerm(pParse, yymsp[-4].minor.yy14, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy144, yymsp[0].minor.yy144);
 }
         break;
-      case 243: /* eidlist ::= nm collate sortorder */
+      case 245: /* eidlist ::= nm collate sortorder */
 {
-  yymsp[-2].minor.yy322 = parserAddExprIdListTerm(pParse, 0, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy394, yymsp[0].minor.yy394); /*A-overwrites-Y*/
+  yymsp[-2].minor.yy14 = parserAddExprIdListTerm(pParse, 0, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy144, yymsp[0].minor.yy144); /*A-overwrites-Y*/
 }
         break;
-      case 246: /* cmd ::= DROP INDEX ifexists fullname */
-{sqlite3DropIndex(pParse, yymsp[0].minor.yy131, yymsp[-1].minor.yy394);}
+      case 248: /* cmd ::= DROP INDEX ifexists fullname */
+{sqlite3DropIndex(pParse, yymsp[0].minor.yy203, yymsp[-1].minor.yy144);}
         break;
-      case 247: /* cmd ::= VACUUM vinto */
-{sqlite3Vacuum(pParse,0,yymsp[0].minor.yy528);}
+      case 249: /* cmd ::= VACUUM vinto */
+{sqlite3Vacuum(pParse,0,yymsp[0].minor.yy454);}
         break;
-      case 248: /* cmd ::= VACUUM nm vinto */
-{sqlite3Vacuum(pParse,&yymsp[-1].minor.yy0,yymsp[0].minor.yy528);}
+      case 250: /* cmd ::= VACUUM nm vinto */
+{sqlite3Vacuum(pParse,&yymsp[-1].minor.yy0,yymsp[0].minor.yy454);}
         break;
-      case 251: /* cmd ::= PRAGMA nm dbnm */
+      case 253: /* cmd ::= PRAGMA nm dbnm */
 {sqlite3Pragma(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0,0);}
         break;
-      case 252: /* cmd ::= PRAGMA nm dbnm EQ nmnum */
+      case 254: /* cmd ::= PRAGMA nm dbnm EQ nmnum */
 {sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,0);}
         break;
-      case 253: /* cmd ::= PRAGMA nm dbnm LP nmnum RP */
+      case 255: /* cmd ::= PRAGMA nm dbnm LP nmnum RP */
 {sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,0);}
         break;
-      case 254: /* cmd ::= PRAGMA nm dbnm EQ minus_num */
+      case 256: /* cmd ::= PRAGMA nm dbnm EQ minus_num */
 {sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,1);}
         break;
-      case 255: /* cmd ::= PRAGMA nm dbnm LP minus_num RP */
+      case 257: /* cmd ::= PRAGMA nm dbnm LP minus_num RP */
 {sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,1);}
         break;
-      case 258: /* cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
+      case 260: /* cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
 {
   Token all;
   all.z = yymsp[-3].minor.yy0.z;
   all.n = (int)(yymsp[0].minor.yy0.z - yymsp[-3].minor.yy0.z) + yymsp[0].minor.yy0.n;
-  sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy33, &all);
+  sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy427, &all);
 }
         break;
-      case 259: /* trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
+      case 261: /* trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
 {
-  sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy394, yymsp[-4].minor.yy180.a, yymsp[-4].minor.yy180.b, yymsp[-2].minor.yy131, yymsp[0].minor.yy528, yymsp[-10].minor.yy394, yymsp[-8].minor.yy394);
+  sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy144, yymsp[-4].minor.yy286.a, yymsp[-4].minor.yy286.b, yymsp[-2].minor.yy203, yymsp[0].minor.yy454, yymsp[-10].minor.yy144, yymsp[-8].minor.yy144);
   yymsp[-10].minor.yy0 = (yymsp[-6].minor.yy0.n==0?yymsp[-7].minor.yy0:yymsp[-6].minor.yy0); /*A-overwrites-T*/
 }
         break;
-      case 260: /* trigger_time ::= BEFORE|AFTER */
-{ yymsp[0].minor.yy394 = yymsp[0].major; /*A-overwrites-X*/ }
+      case 262: /* trigger_time ::= BEFORE|AFTER */
+{ yymsp[0].minor.yy144 = yymsp[0].major; /*A-overwrites-X*/ }
         break;
-      case 261: /* trigger_time ::= INSTEAD OF */
-{ yymsp[-1].minor.yy394 = TK_INSTEAD;}
+      case 263: /* trigger_time ::= INSTEAD OF */
+{ yymsp[-1].minor.yy144 = TK_INSTEAD;}
         break;
-      case 262: /* trigger_time ::= */
-{ yymsp[1].minor.yy394 = TK_BEFORE; }
+      case 264: /* trigger_time ::= */
+{ yymsp[1].minor.yy144 = TK_BEFORE; }
         break;
-      case 263: /* trigger_event ::= DELETE|INSERT */
-      case 264: /* trigger_event ::= UPDATE */ yytestcase(yyruleno==264);
-{yymsp[0].minor.yy180.a = yymsp[0].major; /*A-overwrites-X*/ yymsp[0].minor.yy180.b = 0;}
+      case 265: /* trigger_event ::= DELETE|INSERT */
+      case 266: /* trigger_event ::= UPDATE */ yytestcase(yyruleno==266);
+{yymsp[0].minor.yy286.a = yymsp[0].major; /*A-overwrites-X*/ yymsp[0].minor.yy286.b = 0;}
         break;
-      case 265: /* trigger_event ::= UPDATE OF idlist */
-{yymsp[-2].minor.yy180.a = TK_UPDATE; yymsp[-2].minor.yy180.b = yymsp[0].minor.yy254;}
+      case 267: /* trigger_event ::= UPDATE OF idlist */
+{yymsp[-2].minor.yy286.a = TK_UPDATE; yymsp[-2].minor.yy286.b = yymsp[0].minor.yy132;}
         break;
-      case 266: /* when_clause ::= */
-      case 285: /* key_opt ::= */ yytestcase(yyruleno==285);
-{ yymsp[1].minor.yy528 = 0; }
+      case 268: /* when_clause ::= */
+      case 287: /* key_opt ::= */ yytestcase(yyruleno==287);
+{ yymsp[1].minor.yy454 = 0; }
         break;
-      case 267: /* when_clause ::= WHEN expr */
-      case 286: /* key_opt ::= KEY expr */ yytestcase(yyruleno==286);
-{ yymsp[-1].minor.yy528 = yymsp[0].minor.yy528; }
+      case 269: /* when_clause ::= WHEN expr */
+      case 288: /* key_opt ::= KEY expr */ yytestcase(yyruleno==288);
+{ yymsp[-1].minor.yy454 = yymsp[0].minor.yy454; }
         break;
-      case 268: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
+      case 270: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
 {
-  assert( yymsp[-2].minor.yy33!=0 );
-  yymsp[-2].minor.yy33->pLast->pNext = yymsp[-1].minor.yy33;
-  yymsp[-2].minor.yy33->pLast = yymsp[-1].minor.yy33;
+  assert( yymsp[-2].minor.yy427!=0 );
+  yymsp[-2].minor.yy427->pLast->pNext = yymsp[-1].minor.yy427;
+  yymsp[-2].minor.yy427->pLast = yymsp[-1].minor.yy427;
 }
         break;
-      case 269: /* trigger_cmd_list ::= trigger_cmd SEMI */
+      case 271: /* trigger_cmd_list ::= trigger_cmd SEMI */
 {
-  assert( yymsp[-1].minor.yy33!=0 );
-  yymsp[-1].minor.yy33->pLast = yymsp[-1].minor.yy33;
+  assert( yymsp[-1].minor.yy427!=0 );
+  yymsp[-1].minor.yy427->pLast = yymsp[-1].minor.yy427;
 }
         break;
-      case 270: /* trnm ::= nm DOT nm */
+      case 272: /* trnm ::= nm DOT nm */
 {
   yymsp[-2].minor.yy0 = yymsp[0].minor.yy0;
   sqlite3ErrorMsg(pParse,
@@ -175647,367 +178639,377 @@ static YYACTIONTYPE yy_reduce(
         "statements within triggers");
 }
         break;
-      case 271: /* tridxby ::= INDEXED BY nm */
+      case 273: /* tridxby ::= INDEXED BY nm */
 {
   sqlite3ErrorMsg(pParse,
         "the INDEXED BY clause is not allowed on UPDATE or DELETE statements "
         "within triggers");
 }
         break;
-      case 272: /* tridxby ::= NOT INDEXED */
+      case 274: /* tridxby ::= NOT INDEXED */
 {
   sqlite3ErrorMsg(pParse,
         "the NOT INDEXED clause is not allowed on UPDATE or DELETE statements "
         "within triggers");
 }
         break;
-      case 273: /* trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */
-{yylhsminor.yy33 = sqlite3TriggerUpdateStep(pParse, &yymsp[-6].minor.yy0, yymsp[-2].minor.yy131, yymsp[-3].minor.yy322, yymsp[-1].minor.yy528, yymsp[-7].minor.yy394, yymsp[-8].minor.yy0.z, yymsp[0].minor.yy522);}
-  yymsp[-8].minor.yy33 = yylhsminor.yy33;
+      case 275: /* trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */
+{yylhsminor.yy427 = sqlite3TriggerUpdateStep(pParse, &yymsp[-6].minor.yy0, yymsp[-2].minor.yy203, yymsp[-3].minor.yy14, yymsp[-1].minor.yy454, yymsp[-7].minor.yy144, yymsp[-8].minor.yy0.z, yymsp[0].minor.yy168);}
+  yymsp[-8].minor.yy427 = yylhsminor.yy427;
         break;
-      case 274: /* trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */
+      case 276: /* trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */
 {
-   yylhsminor.yy33 = sqlite3TriggerInsertStep(pParse,&yymsp[-4].minor.yy0,yymsp[-3].minor.yy254,yymsp[-2].minor.yy47,yymsp[-6].minor.yy394,yymsp[-1].minor.yy444,yymsp[-7].minor.yy522,yymsp[0].minor.yy522);/*yylhsminor.yy33-overwrites-yymsp[-6].minor.yy394*/
+   yylhsminor.yy427 = sqlite3TriggerInsertStep(pParse,&yymsp[-4].minor.yy0,yymsp[-3].minor.yy132,yymsp[-2].minor.yy555,yymsp[-6].minor.yy144,yymsp[-1].minor.yy122,yymsp[-7].minor.yy168,yymsp[0].minor.yy168);/*yylhsminor.yy427-overwrites-yymsp[-6].minor.yy144*/
 }
-  yymsp[-7].minor.yy33 = yylhsminor.yy33;
+  yymsp[-7].minor.yy427 = yylhsminor.yy427;
         break;
-      case 275: /* trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */
-{yylhsminor.yy33 = sqlite3TriggerDeleteStep(pParse, &yymsp[-3].minor.yy0, yymsp[-1].minor.yy528, yymsp[-5].minor.yy0.z, yymsp[0].minor.yy522);}
-  yymsp[-5].minor.yy33 = yylhsminor.yy33;
+      case 277: /* trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */
+{yylhsminor.yy427 = sqlite3TriggerDeleteStep(pParse, &yymsp[-3].minor.yy0, yymsp[-1].minor.yy454, yymsp[-5].minor.yy0.z, yymsp[0].minor.yy168);}
+  yymsp[-5].minor.yy427 = yylhsminor.yy427;
         break;
-      case 276: /* trigger_cmd ::= scanpt select scanpt */
-{yylhsminor.yy33 = sqlite3TriggerSelectStep(pParse->db, yymsp[-1].minor.yy47, yymsp[-2].minor.yy522, yymsp[0].minor.yy522); /*yylhsminor.yy33-overwrites-yymsp[-1].minor.yy47*/}
-  yymsp[-2].minor.yy33 = yylhsminor.yy33;
+      case 278: /* trigger_cmd ::= scanpt select scanpt */
+{yylhsminor.yy427 = sqlite3TriggerSelectStep(pParse->db, yymsp[-1].minor.yy555, yymsp[-2].minor.yy168, yymsp[0].minor.yy168); /*yylhsminor.yy427-overwrites-yymsp[-1].minor.yy555*/}
+  yymsp[-2].minor.yy427 = yylhsminor.yy427;
         break;
-      case 277: /* expr ::= RAISE LP IGNORE RP */
+      case 279: /* expr ::= RAISE LP IGNORE RP */
 {
-  yymsp[-3].minor.yy528 = sqlite3PExpr(pParse, TK_RAISE, 0, 0);
-  if( yymsp[-3].minor.yy528 ){
-    yymsp[-3].minor.yy528->affExpr = OE_Ignore;
+  yymsp[-3].minor.yy454 = sqlite3PExpr(pParse, TK_RAISE, 0, 0);
+  if( yymsp[-3].minor.yy454 ){
+    yymsp[-3].minor.yy454->affExpr = OE_Ignore;
   }
 }
         break;
-      case 278: /* expr ::= RAISE LP raisetype COMMA nm RP */
+      case 280: /* expr ::= RAISE LP raisetype COMMA expr RP */
 {
-  yymsp[-5].minor.yy528 = sqlite3ExprAlloc(pParse->db, TK_RAISE, &yymsp[-1].minor.yy0, 1);
-  if( yymsp[-5].minor.yy528 ) {
-    yymsp[-5].minor.yy528->affExpr = (char)yymsp[-3].minor.yy394;
+  yymsp[-5].minor.yy454 = sqlite3PExpr(pParse, TK_RAISE, yymsp[-1].minor.yy454, 0);
+  if( yymsp[-5].minor.yy454 ) {
+    yymsp[-5].minor.yy454->affExpr = (char)yymsp[-3].minor.yy144;
   }
 }
         break;
-      case 279: /* raisetype ::= ROLLBACK */
-{yymsp[0].minor.yy394 = OE_Rollback;}
+      case 281: /* raisetype ::= ROLLBACK */
+{yymsp[0].minor.yy144 = OE_Rollback;}
         break;
-      case 281: /* raisetype ::= FAIL */
-{yymsp[0].minor.yy394 = OE_Fail;}
+      case 283: /* raisetype ::= FAIL */
+{yymsp[0].minor.yy144 = OE_Fail;}
         break;
-      case 282: /* cmd ::= DROP TRIGGER ifexists fullname */
+      case 284: /* cmd ::= DROP TRIGGER ifexists fullname */
 {
-  sqlite3DropTrigger(pParse,yymsp[0].minor.yy131,yymsp[-1].minor.yy394);
+  sqlite3DropTrigger(pParse,yymsp[0].minor.yy203,yymsp[-1].minor.yy144);
 }
         break;
-      case 283: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
+      case 285: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
 {
-  sqlite3Attach(pParse, yymsp[-3].minor.yy528, yymsp[-1].minor.yy528, yymsp[0].minor.yy528);
+  sqlite3Attach(pParse, yymsp[-3].minor.yy454, yymsp[-1].minor.yy454, yymsp[0].minor.yy454);
 }
         break;
-      case 284: /* cmd ::= DETACH database_kw_opt expr */
+      case 286: /* cmd ::= DETACH database_kw_opt expr */
 {
-  sqlite3Detach(pParse, yymsp[0].minor.yy528);
+  sqlite3Detach(pParse, yymsp[0].minor.yy454);
 }
         break;
-      case 287: /* cmd ::= REINDEX */
+      case 289: /* cmd ::= REINDEX */
 {sqlite3Reindex(pParse, 0, 0);}
         break;
-      case 288: /* cmd ::= REINDEX nm dbnm */
+      case 290: /* cmd ::= REINDEX nm dbnm */
 {sqlite3Reindex(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
         break;
-      case 289: /* cmd ::= ANALYZE */
+      case 291: /* cmd ::= ANALYZE */
 {sqlite3Analyze(pParse, 0, 0);}
         break;
-      case 290: /* cmd ::= ANALYZE nm dbnm */
+      case 292: /* cmd ::= ANALYZE nm dbnm */
 {sqlite3Analyze(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
         break;
-      case 291: /* cmd ::= ALTER TABLE fullname RENAME TO nm */
+      case 293: /* cmd ::= ALTER TABLE fullname RENAME TO nm */
 {
-  sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy131,&yymsp[0].minor.yy0);
+  sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy203,&yymsp[0].minor.yy0);
 }
         break;
-      case 292: /* cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
+      case 294: /* cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
 {
   yymsp[-1].minor.yy0.n = (int)(pParse->sLastToken.z-yymsp[-1].minor.yy0.z) + pParse->sLastToken.n;
   sqlite3AlterFinishAddColumn(pParse, &yymsp[-1].minor.yy0);
 }
         break;
-      case 293: /* cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
+      case 295: /* cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
 {
-  sqlite3AlterDropColumn(pParse, yymsp[-3].minor.yy131, &yymsp[0].minor.yy0);
+  sqlite3AlterDropColumn(pParse, yymsp[-3].minor.yy203, &yymsp[0].minor.yy0);
 }
         break;
-      case 294: /* add_column_fullname ::= fullname */
+      case 296: /* add_column_fullname ::= fullname */
 {
   disableLookaside(pParse);
-  sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy131);
+  sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy203);
 }
         break;
-      case 295: /* cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
+      case 297: /* cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
 {
-  sqlite3AlterRenameColumn(pParse, yymsp[-5].minor.yy131, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
+  sqlite3AlterRenameColumn(pParse, yymsp[-5].minor.yy203, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
 }
         break;
-      case 296: /* cmd ::= create_vtab */
+      case 298: /* cmd ::= create_vtab */
 {sqlite3VtabFinishParse(pParse,0);}
         break;
-      case 297: /* cmd ::= create_vtab LP vtabarglist RP */
+      case 299: /* cmd ::= create_vtab LP vtabarglist RP */
 {sqlite3VtabFinishParse(pParse,&yymsp[0].minor.yy0);}
         break;
-      case 298: /* create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
+      case 300: /* create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
 {
-    sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-4].minor.yy394);
+    sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-4].minor.yy144);
 }
         break;
-      case 299: /* vtabarg ::= */
+      case 301: /* vtabarg ::= */
 {sqlite3VtabArgInit(pParse);}
         break;
-      case 300: /* vtabargtoken ::= ANY */
-      case 301: /* vtabargtoken ::= lp anylist RP */ yytestcase(yyruleno==301);
-      case 302: /* lp ::= LP */ yytestcase(yyruleno==302);
+      case 302: /* vtabargtoken ::= ANY */
+      case 303: /* vtabargtoken ::= lp anylist RP */ yytestcase(yyruleno==303);
+      case 304: /* lp ::= LP */ yytestcase(yyruleno==304);
 {sqlite3VtabArgExtend(pParse,&yymsp[0].minor.yy0);}
         break;
-      case 303: /* with ::= WITH wqlist */
-      case 304: /* with ::= WITH RECURSIVE wqlist */ yytestcase(yyruleno==304);
-{ sqlite3WithPush(pParse, yymsp[0].minor.yy521, 1); }
+      case 305: /* with ::= WITH wqlist */
+      case 306: /* with ::= WITH RECURSIVE wqlist */ yytestcase(yyruleno==306);
+{ sqlite3WithPush(pParse, yymsp[0].minor.yy59, 1); }
         break;
-      case 305: /* wqas ::= AS */
-{yymsp[0].minor.yy516 = M10d_Any;}
+      case 307: /* wqas ::= AS */
+{yymsp[0].minor.yy462 = M10d_Any;}
         break;
-      case 306: /* wqas ::= AS MATERIALIZED */
-{yymsp[-1].minor.yy516 = M10d_Yes;}
+      case 308: /* wqas ::= AS MATERIALIZED */
+{yymsp[-1].minor.yy462 = M10d_Yes;}
         break;
-      case 307: /* wqas ::= AS NOT MATERIALIZED */
-{yymsp[-2].minor.yy516 = M10d_No;}
+      case 309: /* wqas ::= AS NOT MATERIALIZED */
+{yymsp[-2].minor.yy462 = M10d_No;}
         break;
-      case 308: /* wqitem ::= nm eidlist_opt wqas LP select RP */
+      case 310: /* wqitem ::= withnm eidlist_opt wqas LP select RP */
 {
-  yymsp[-5].minor.yy385 = sqlite3CteNew(pParse, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy322, yymsp[-1].minor.yy47, yymsp[-3].minor.yy516); /*A-overwrites-X*/
+  yymsp[-5].minor.yy67 = sqlite3CteNew(pParse, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy14, yymsp[-1].minor.yy555, yymsp[-3].minor.yy462); /*A-overwrites-X*/
 }
         break;
-      case 309: /* wqlist ::= wqitem */
+      case 311: /* withnm ::= nm */
+{pParse->bHasWith = 1;}
+        break;
+      case 312: /* wqlist ::= wqitem */
 {
-  yymsp[0].minor.yy521 = sqlite3WithAdd(pParse, 0, yymsp[0].minor.yy385); /*A-overwrites-X*/
+  yymsp[0].minor.yy59 = sqlite3WithAdd(pParse, 0, yymsp[0].minor.yy67); /*A-overwrites-X*/
 }
         break;
-      case 310: /* wqlist ::= wqlist COMMA wqitem */
+      case 313: /* wqlist ::= wqlist COMMA wqitem */
 {
-  yymsp[-2].minor.yy521 = sqlite3WithAdd(pParse, yymsp[-2].minor.yy521, yymsp[0].minor.yy385);
+  yymsp[-2].minor.yy59 = sqlite3WithAdd(pParse, yymsp[-2].minor.yy59, yymsp[0].minor.yy67);
 }
         break;
-      case 311: /* windowdefn_list ::= windowdefn_list COMMA windowdefn */
+      case 314: /* windowdefn_list ::= windowdefn_list COMMA windowdefn */
 {
-  assert( yymsp[0].minor.yy41!=0 );
-  sqlite3WindowChain(pParse, yymsp[0].minor.yy41, yymsp[-2].minor.yy41);
-  yymsp[0].minor.yy41->pNextWin = yymsp[-2].minor.yy41;
-  yylhsminor.yy41 = yymsp[0].minor.yy41;
+  assert( yymsp[0].minor.yy211!=0 );
+  sqlite3WindowChain(pParse, yymsp[0].minor.yy211, yymsp[-2].minor.yy211);
+  yymsp[0].minor.yy211->pNextWin = yymsp[-2].minor.yy211;
+  yylhsminor.yy211 = yymsp[0].minor.yy211;
 }
-  yymsp[-2].minor.yy41 = yylhsminor.yy41;
+  yymsp[-2].minor.yy211 = yylhsminor.yy211;
         break;
-      case 312: /* windowdefn ::= nm AS LP window RP */
+      case 315: /* windowdefn ::= nm AS LP window RP */
 {
-  if( ALWAYS(yymsp[-1].minor.yy41) ){
-    yymsp[-1].minor.yy41->zName = sqlite3DbStrNDup(pParse->db, yymsp[-4].minor.yy0.z, yymsp[-4].minor.yy0.n);
+  if( ALWAYS(yymsp[-1].minor.yy211) ){
+    yymsp[-1].minor.yy211->zName = sqlite3DbStrNDup(pParse->db, yymsp[-4].minor.yy0.z, yymsp[-4].minor.yy0.n);
   }
-  yylhsminor.yy41 = yymsp[-1].minor.yy41;
+  yylhsminor.yy211 = yymsp[-1].minor.yy211;
 }
-  yymsp[-4].minor.yy41 = yylhsminor.yy41;
+  yymsp[-4].minor.yy211 = yylhsminor.yy211;
         break;
-      case 313: /* window ::= PARTITION BY nexprlist orderby_opt frame_opt */
+      case 316: /* window ::= PARTITION BY nexprlist orderby_opt frame_opt */
 {
-  yymsp[-4].minor.yy41 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy41, yymsp[-2].minor.yy322, yymsp[-1].minor.yy322, 0);
+  yymsp[-4].minor.yy211 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy211, yymsp[-2].minor.yy14, yymsp[-1].minor.yy14, 0);
 }
         break;
-      case 314: /* window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
+      case 317: /* window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
 {
-  yylhsminor.yy41 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy41, yymsp[-2].minor.yy322, yymsp[-1].minor.yy322, &yymsp[-5].minor.yy0);
+  yylhsminor.yy211 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy211, yymsp[-2].minor.yy14, yymsp[-1].minor.yy14, &yymsp[-5].minor.yy0);
 }
-  yymsp[-5].minor.yy41 = yylhsminor.yy41;
+  yymsp[-5].minor.yy211 = yylhsminor.yy211;
         break;
-      case 315: /* window ::= ORDER BY sortlist frame_opt */
+      case 318: /* window ::= ORDER BY sortlist frame_opt */
 {
-  yymsp[-3].minor.yy41 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy41, 0, yymsp[-1].minor.yy322, 0);
+  yymsp[-3].minor.yy211 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy211, 0, yymsp[-1].minor.yy14, 0);
 }
         break;
-      case 316: /* window ::= nm ORDER BY sortlist frame_opt */
+      case 319: /* window ::= nm ORDER BY sortlist frame_opt */
 {
-  yylhsminor.yy41 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy41, 0, yymsp[-1].minor.yy322, &yymsp[-4].minor.yy0);
+  yylhsminor.yy211 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy211, 0, yymsp[-1].minor.yy14, &yymsp[-4].minor.yy0);
 }
-  yymsp[-4].minor.yy41 = yylhsminor.yy41;
+  yymsp[-4].minor.yy211 = yylhsminor.yy211;
         break;
-      case 317: /* window ::= nm frame_opt */
+      case 320: /* window ::= nm frame_opt */
 {
-  yylhsminor.yy41 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy41, 0, 0, &yymsp[-1].minor.yy0);
+  yylhsminor.yy211 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy211, 0, 0, &yymsp[-1].minor.yy0);
 }
-  yymsp[-1].minor.yy41 = yylhsminor.yy41;
+  yymsp[-1].minor.yy211 = yylhsminor.yy211;
         break;
-      case 318: /* frame_opt ::= */
+      case 321: /* frame_opt ::= */
 {
-  yymsp[1].minor.yy41 = sqlite3WindowAlloc(pParse, 0, TK_UNBOUNDED, 0, TK_CURRENT, 0, 0);
+  yymsp[1].minor.yy211 = sqlite3WindowAlloc(pParse, 0, TK_UNBOUNDED, 0, TK_CURRENT, 0, 0);
 }
         break;
-      case 319: /* frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
+      case 322: /* frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
 {
-  yylhsminor.yy41 = sqlite3WindowAlloc(pParse, yymsp[-2].minor.yy394, yymsp[-1].minor.yy595.eType, yymsp[-1].minor.yy595.pExpr, TK_CURRENT, 0, yymsp[0].minor.yy516);
+  yylhsminor.yy211 = sqlite3WindowAlloc(pParse, yymsp[-2].minor.yy144, yymsp[-1].minor.yy509.eType, yymsp[-1].minor.yy509.pExpr, TK_CURRENT, 0, yymsp[0].minor.yy462);
 }
-  yymsp[-2].minor.yy41 = yylhsminor.yy41;
+  yymsp[-2].minor.yy211 = yylhsminor.yy211;
         break;
-      case 320: /* frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
+      case 323: /* frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
 {
-  yylhsminor.yy41 = sqlite3WindowAlloc(pParse, yymsp[-5].minor.yy394, yymsp[-3].minor.yy595.eType, yymsp[-3].minor.yy595.pExpr, yymsp[-1].minor.yy595.eType, yymsp[-1].minor.yy595.pExpr, yymsp[0].minor.yy516);
+  yylhsminor.yy211 = sqlite3WindowAlloc(pParse, yymsp[-5].minor.yy144, yymsp[-3].minor.yy509.eType, yymsp[-3].minor.yy509.pExpr, yymsp[-1].minor.yy509.eType, yymsp[-1].minor.yy509.pExpr, yymsp[0].minor.yy462);
 }
-  yymsp[-5].minor.yy41 = yylhsminor.yy41;
+  yymsp[-5].minor.yy211 = yylhsminor.yy211;
         break;
-      case 322: /* frame_bound_s ::= frame_bound */
-      case 324: /* frame_bound_e ::= frame_bound */ yytestcase(yyruleno==324);
-{yylhsminor.yy595 = yymsp[0].minor.yy595;}
-  yymsp[0].minor.yy595 = yylhsminor.yy595;
+      case 325: /* frame_bound_s ::= frame_bound */
+      case 327: /* frame_bound_e ::= frame_bound */ yytestcase(yyruleno==327);
+{yylhsminor.yy509 = yymsp[0].minor.yy509;}
+  yymsp[0].minor.yy509 = yylhsminor.yy509;
         break;
-      case 323: /* frame_bound_s ::= UNBOUNDED PRECEDING */
-      case 325: /* frame_bound_e ::= UNBOUNDED FOLLOWING */ yytestcase(yyruleno==325);
-      case 327: /* frame_bound ::= CURRENT ROW */ yytestcase(yyruleno==327);
-{yylhsminor.yy595.eType = yymsp[-1].major; yylhsminor.yy595.pExpr = 0;}
-  yymsp[-1].minor.yy595 = yylhsminor.yy595;
+      case 326: /* frame_bound_s ::= UNBOUNDED PRECEDING */
+      case 328: /* frame_bound_e ::= UNBOUNDED FOLLOWING */ yytestcase(yyruleno==328);
+      case 330: /* frame_bound ::= CURRENT ROW */ yytestcase(yyruleno==330);
+{yylhsminor.yy509.eType = yymsp[-1].major; yylhsminor.yy509.pExpr = 0;}
+  yymsp[-1].minor.yy509 = yylhsminor.yy509;
         break;
-      case 326: /* frame_bound ::= expr PRECEDING|FOLLOWING */
-{yylhsminor.yy595.eType = yymsp[0].major; yylhsminor.yy595.pExpr = yymsp[-1].minor.yy528;}
-  yymsp[-1].minor.yy595 = yylhsminor.yy595;
+      case 329: /* frame_bound ::= expr PRECEDING|FOLLOWING */
+{yylhsminor.yy509.eType = yymsp[0].major; yylhsminor.yy509.pExpr = yymsp[-1].minor.yy454;}
+  yymsp[-1].minor.yy509 = yylhsminor.yy509;
         break;
-      case 328: /* frame_exclude_opt ::= */
-{yymsp[1].minor.yy516 = 0;}
+      case 331: /* frame_exclude_opt ::= */
+{yymsp[1].minor.yy462 = 0;}
         break;
-      case 329: /* frame_exclude_opt ::= EXCLUDE frame_exclude */
-{yymsp[-1].minor.yy516 = yymsp[0].minor.yy516;}
+      case 332: /* frame_exclude_opt ::= EXCLUDE frame_exclude */
+{yymsp[-1].minor.yy462 = yymsp[0].minor.yy462;}
         break;
-      case 330: /* frame_exclude ::= NO OTHERS */
-      case 331: /* frame_exclude ::= CURRENT ROW */ yytestcase(yyruleno==331);
-{yymsp[-1].minor.yy516 = yymsp[-1].major; /*A-overwrites-X*/}
+      case 333: /* frame_exclude ::= NO OTHERS */
+      case 334: /* frame_exclude ::= CURRENT ROW */ yytestcase(yyruleno==334);
+{yymsp[-1].minor.yy462 = yymsp[-1].major; /*A-overwrites-X*/}
         break;
-      case 332: /* frame_exclude ::= GROUP|TIES */
-{yymsp[0].minor.yy516 = yymsp[0].major; /*A-overwrites-X*/}
+      case 335: /* frame_exclude ::= GROUP|TIES */
+{yymsp[0].minor.yy462 = yymsp[0].major; /*A-overwrites-X*/}
         break;
-      case 333: /* window_clause ::= WINDOW windowdefn_list */
-{ yymsp[-1].minor.yy41 = yymsp[0].minor.yy41; }
+      case 336: /* window_clause ::= WINDOW windowdefn_list */
+{ yymsp[-1].minor.yy211 = yymsp[0].minor.yy211; }
         break;
-      case 334: /* filter_over ::= filter_clause over_clause */
+      case 337: /* filter_over ::= filter_clause over_clause */
 {
-  if( yymsp[0].minor.yy41 ){
-    yymsp[0].minor.yy41->pFilter = yymsp[-1].minor.yy528;
+  if( yymsp[0].minor.yy211 ){
+    yymsp[0].minor.yy211->pFilter = yymsp[-1].minor.yy454;
   }else{
-    sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy528);
+    sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy454);
   }
-  yylhsminor.yy41 = yymsp[0].minor.yy41;
+  yylhsminor.yy211 = yymsp[0].minor.yy211;
 }
-  yymsp[-1].minor.yy41 = yylhsminor.yy41;
+  yymsp[-1].minor.yy211 = yylhsminor.yy211;
         break;
-      case 335: /* filter_over ::= over_clause */
+      case 338: /* filter_over ::= over_clause */
 {
-  yylhsminor.yy41 = yymsp[0].minor.yy41;
+  yylhsminor.yy211 = yymsp[0].minor.yy211;
 }
-  yymsp[0].minor.yy41 = yylhsminor.yy41;
+  yymsp[0].minor.yy211 = yylhsminor.yy211;
         break;
-      case 336: /* filter_over ::= filter_clause */
+      case 339: /* filter_over ::= filter_clause */
 {
-  yylhsminor.yy41 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
-  if( yylhsminor.yy41 ){
-    yylhsminor.yy41->eFrmType = TK_FILTER;
-    yylhsminor.yy41->pFilter = yymsp[0].minor.yy528;
+  yylhsminor.yy211 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
+  if( yylhsminor.yy211 ){
+    yylhsminor.yy211->eFrmType = TK_FILTER;
+    yylhsminor.yy211->pFilter = yymsp[0].minor.yy454;
   }else{
-    sqlite3ExprDelete(pParse->db, yymsp[0].minor.yy528);
+    sqlite3ExprDelete(pParse->db, yymsp[0].minor.yy454);
   }
 }
-  yymsp[0].minor.yy41 = yylhsminor.yy41;
+  yymsp[0].minor.yy211 = yylhsminor.yy211;
         break;
-      case 337: /* over_clause ::= OVER LP window RP */
+      case 340: /* over_clause ::= OVER LP window RP */
 {
-  yymsp[-3].minor.yy41 = yymsp[-1].minor.yy41;
-  assert( yymsp[-3].minor.yy41!=0 );
+  yymsp[-3].minor.yy211 = yymsp[-1].minor.yy211;
+  assert( yymsp[-3].minor.yy211!=0 );
 }
         break;
-      case 338: /* over_clause ::= OVER nm */
+      case 341: /* over_clause ::= OVER nm */
 {
-  yymsp[-1].minor.yy41 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
-  if( yymsp[-1].minor.yy41 ){
-    yymsp[-1].minor.yy41->zName = sqlite3DbStrNDup(pParse->db, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n);
+  yymsp[-1].minor.yy211 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
+  if( yymsp[-1].minor.yy211 ){
+    yymsp[-1].minor.yy211->zName = sqlite3DbStrNDup(pParse->db, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n);
   }
 }
         break;
-      case 339: /* filter_clause ::= FILTER LP WHERE expr RP */
-{ yymsp[-4].minor.yy528 = yymsp[-1].minor.yy528; }
+      case 342: /* filter_clause ::= FILTER LP WHERE expr RP */
+{ yymsp[-4].minor.yy454 = yymsp[-1].minor.yy454; }
+        break;
+      case 343: /* term ::= QNUMBER */
+{
+  yylhsminor.yy454=tokenExpr(pParse,yymsp[0].major,yymsp[0].minor.yy0);
+  sqlite3DequoteNumber(pParse, yylhsminor.yy454);
+}
+  yymsp[0].minor.yy454 = yylhsminor.yy454;
         break;
       default:
-      /* (340) input ::= cmdlist */ yytestcase(yyruleno==340);
-      /* (341) cmdlist ::= cmdlist ecmd */ yytestcase(yyruleno==341);
-      /* (342) cmdlist ::= ecmd (OPTIMIZED OUT) */ assert(yyruleno!=342);
-      /* (343) ecmd ::= SEMI */ yytestcase(yyruleno==343);
-      /* (344) ecmd ::= cmdx SEMI */ yytestcase(yyruleno==344);
-      /* (345) ecmd ::= explain cmdx SEMI (NEVER REDUCES) */ assert(yyruleno!=345);
-      /* (346) trans_opt ::= */ yytestcase(yyruleno==346);
-      /* (347) trans_opt ::= TRANSACTION */ yytestcase(yyruleno==347);
-      /* (348) trans_opt ::= TRANSACTION nm */ yytestcase(yyruleno==348);
-      /* (349) savepoint_opt ::= SAVEPOINT */ yytestcase(yyruleno==349);
-      /* (350) savepoint_opt ::= */ yytestcase(yyruleno==350);
-      /* (351) cmd ::= create_table create_table_args */ yytestcase(yyruleno==351);
-      /* (352) table_option_set ::= table_option (OPTIMIZED OUT) */ assert(yyruleno!=352);
-      /* (353) columnlist ::= columnlist COMMA columnname carglist */ yytestcase(yyruleno==353);
-      /* (354) columnlist ::= columnname carglist */ yytestcase(yyruleno==354);
-      /* (355) nm ::= ID|INDEXED|JOIN_KW */ yytestcase(yyruleno==355);
-      /* (356) nm ::= STRING */ yytestcase(yyruleno==356);
-      /* (357) typetoken ::= typename */ yytestcase(yyruleno==357);
-      /* (358) typename ::= ID|STRING */ yytestcase(yyruleno==358);
-      /* (359) signed ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=359);
-      /* (360) signed ::= minus_num (OPTIMIZED OUT) */ assert(yyruleno!=360);
-      /* (361) carglist ::= carglist ccons */ yytestcase(yyruleno==361);
-      /* (362) carglist ::= */ yytestcase(yyruleno==362);
-      /* (363) ccons ::= NULL onconf */ yytestcase(yyruleno==363);
-      /* (364) ccons ::= GENERATED ALWAYS AS generated */ yytestcase(yyruleno==364);
-      /* (365) ccons ::= AS generated */ yytestcase(yyruleno==365);
-      /* (366) conslist_opt ::= COMMA conslist */ yytestcase(yyruleno==366);
-      /* (367) conslist ::= conslist tconscomma tcons */ yytestcase(yyruleno==367);
-      /* (368) conslist ::= tcons (OPTIMIZED OUT) */ assert(yyruleno!=368);
-      /* (369) tconscomma ::= */ yytestcase(yyruleno==369);
-      /* (370) defer_subclause_opt ::= defer_subclause (OPTIMIZED OUT) */ assert(yyruleno!=370);
-      /* (371) resolvetype ::= raisetype (OPTIMIZED OUT) */ assert(yyruleno!=371);
-      /* (372) selectnowith ::= oneselect (OPTIMIZED OUT) */ assert(yyruleno!=372);
-      /* (373) oneselect ::= values */ yytestcase(yyruleno==373);
-      /* (374) sclp ::= selcollist COMMA */ yytestcase(yyruleno==374);
-      /* (375) as ::= ID|STRING */ yytestcase(yyruleno==375);
-      /* (376) indexed_opt ::= indexed_by (OPTIMIZED OUT) */ assert(yyruleno!=376);
-      /* (377) returning ::= */ yytestcase(yyruleno==377);
-      /* (378) expr ::= term (OPTIMIZED OUT) */ assert(yyruleno!=378);
-      /* (379) likeop ::= LIKE_KW|MATCH */ yytestcase(yyruleno==379);
-      /* (380) case_operand ::= expr */ yytestcase(yyruleno==380);
-      /* (381) exprlist ::= nexprlist */ yytestcase(yyruleno==381);
-      /* (382) nmnum ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=382);
-      /* (383) nmnum ::= nm (OPTIMIZED OUT) */ assert(yyruleno!=383);
-      /* (384) nmnum ::= ON */ yytestcase(yyruleno==384);
-      /* (385) nmnum ::= DELETE */ yytestcase(yyruleno==385);
-      /* (386) nmnum ::= DEFAULT */ yytestcase(yyruleno==386);
-      /* (387) plus_num ::= INTEGER|FLOAT */ yytestcase(yyruleno==387);
-      /* (388) foreach_clause ::= */ yytestcase(yyruleno==388);
-      /* (389) foreach_clause ::= FOR EACH ROW */ yytestcase(yyruleno==389);
-      /* (390) trnm ::= nm */ yytestcase(yyruleno==390);
-      /* (391) tridxby ::= */ yytestcase(yyruleno==391);
-      /* (392) database_kw_opt ::= DATABASE */ yytestcase(yyruleno==392);
-      /* (393) database_kw_opt ::= */ yytestcase(yyruleno==393);
-      /* (394) kwcolumn_opt ::= */ yytestcase(yyruleno==394);
-      /* (395) kwcolumn_opt ::= COLUMNKW */ yytestcase(yyruleno==395);
-      /* (396) vtabarglist ::= vtabarg */ yytestcase(yyruleno==396);
-      /* (397) vtabarglist ::= vtabarglist COMMA vtabarg */ yytestcase(yyruleno==397);
-      /* (398) vtabarg ::= vtabarg vtabargtoken */ yytestcase(yyruleno==398);
-      /* (399) anylist ::= */ yytestcase(yyruleno==399);
-      /* (400) anylist ::= anylist LP anylist RP */ yytestcase(yyruleno==400);
-      /* (401) anylist ::= anylist ANY */ yytestcase(yyruleno==401);
-      /* (402) with ::= */ yytestcase(yyruleno==402);
-      /* (403) windowdefn_list ::= windowdefn (OPTIMIZED OUT) */ assert(yyruleno!=403);
-      /* (404) window ::= frame_opt (OPTIMIZED OUT) */ assert(yyruleno!=404);
+      /* (344) input ::= cmdlist */ yytestcase(yyruleno==344);
+      /* (345) cmdlist ::= cmdlist ecmd */ yytestcase(yyruleno==345);
+      /* (346) cmdlist ::= ecmd (OPTIMIZED OUT) */ assert(yyruleno!=346);
+      /* (347) ecmd ::= SEMI */ yytestcase(yyruleno==347);
+      /* (348) ecmd ::= cmdx SEMI */ yytestcase(yyruleno==348);
+      /* (349) ecmd ::= explain cmdx SEMI (NEVER REDUCES) */ assert(yyruleno!=349);
+      /* (350) trans_opt ::= */ yytestcase(yyruleno==350);
+      /* (351) trans_opt ::= TRANSACTION */ yytestcase(yyruleno==351);
+      /* (352) trans_opt ::= TRANSACTION nm */ yytestcase(yyruleno==352);
+      /* (353) savepoint_opt ::= SAVEPOINT */ yytestcase(yyruleno==353);
+      /* (354) savepoint_opt ::= */ yytestcase(yyruleno==354);
+      /* (355) cmd ::= create_table create_table_args */ yytestcase(yyruleno==355);
+      /* (356) table_option_set ::= table_option (OPTIMIZED OUT) */ assert(yyruleno!=356);
+      /* (357) columnlist ::= columnlist COMMA columnname carglist */ yytestcase(yyruleno==357);
+      /* (358) columnlist ::= columnname carglist */ yytestcase(yyruleno==358);
+      /* (359) nm ::= ID|INDEXED|JOIN_KW */ yytestcase(yyruleno==359);
+      /* (360) nm ::= STRING */ yytestcase(yyruleno==360);
+      /* (361) typetoken ::= typename */ yytestcase(yyruleno==361);
+      /* (362) typename ::= ID|STRING */ yytestcase(yyruleno==362);
+      /* (363) signed ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=363);
+      /* (364) signed ::= minus_num (OPTIMIZED OUT) */ assert(yyruleno!=364);
+      /* (365) carglist ::= carglist ccons */ yytestcase(yyruleno==365);
+      /* (366) carglist ::= */ yytestcase(yyruleno==366);
+      /* (367) ccons ::= NULL onconf */ yytestcase(yyruleno==367);
+      /* (368) ccons ::= GENERATED ALWAYS AS generated */ yytestcase(yyruleno==368);
+      /* (369) ccons ::= AS generated */ yytestcase(yyruleno==369);
+      /* (370) conslist_opt ::= COMMA conslist */ yytestcase(yyruleno==370);
+      /* (371) conslist ::= conslist tconscomma tcons */ yytestcase(yyruleno==371);
+      /* (372) conslist ::= tcons (OPTIMIZED OUT) */ assert(yyruleno!=372);
+      /* (373) tconscomma ::= */ yytestcase(yyruleno==373);
+      /* (374) defer_subclause_opt ::= defer_subclause (OPTIMIZED OUT) */ assert(yyruleno!=374);
+      /* (375) resolvetype ::= raisetype (OPTIMIZED OUT) */ assert(yyruleno!=375);
+      /* (376) selectnowith ::= oneselect (OPTIMIZED OUT) */ assert(yyruleno!=376);
+      /* (377) oneselect ::= values */ yytestcase(yyruleno==377);
+      /* (378) sclp ::= selcollist COMMA */ yytestcase(yyruleno==378);
+      /* (379) as ::= ID|STRING */ yytestcase(yyruleno==379);
+      /* (380) indexed_opt ::= indexed_by (OPTIMIZED OUT) */ assert(yyruleno!=380);
+      /* (381) returning ::= */ yytestcase(yyruleno==381);
+      /* (382) expr ::= term (OPTIMIZED OUT) */ assert(yyruleno!=382);
+      /* (383) likeop ::= LIKE_KW|MATCH */ yytestcase(yyruleno==383);
+      /* (384) case_operand ::= expr */ yytestcase(yyruleno==384);
+      /* (385) exprlist ::= nexprlist */ yytestcase(yyruleno==385);
+      /* (386) nmnum ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=386);
+      /* (387) nmnum ::= nm (OPTIMIZED OUT) */ assert(yyruleno!=387);
+      /* (388) nmnum ::= ON */ yytestcase(yyruleno==388);
+      /* (389) nmnum ::= DELETE */ yytestcase(yyruleno==389);
+      /* (390) nmnum ::= DEFAULT */ yytestcase(yyruleno==390);
+      /* (391) plus_num ::= INTEGER|FLOAT */ yytestcase(yyruleno==391);
+      /* (392) foreach_clause ::= */ yytestcase(yyruleno==392);
+      /* (393) foreach_clause ::= FOR EACH ROW */ yytestcase(yyruleno==393);
+      /* (394) trnm ::= nm */ yytestcase(yyruleno==394);
+      /* (395) tridxby ::= */ yytestcase(yyruleno==395);
+      /* (396) database_kw_opt ::= DATABASE */ yytestcase(yyruleno==396);
+      /* (397) database_kw_opt ::= */ yytestcase(yyruleno==397);
+      /* (398) kwcolumn_opt ::= */ yytestcase(yyruleno==398);
+      /* (399) kwcolumn_opt ::= COLUMNKW */ yytestcase(yyruleno==399);
+      /* (400) vtabarglist ::= vtabarg */ yytestcase(yyruleno==400);
+      /* (401) vtabarglist ::= vtabarglist COMMA vtabarg */ yytestcase(yyruleno==401);
+      /* (402) vtabarg ::= vtabarg vtabargtoken */ yytestcase(yyruleno==402);
+      /* (403) anylist ::= */ yytestcase(yyruleno==403);
+      /* (404) anylist ::= anylist LP anylist RP */ yytestcase(yyruleno==404);
+      /* (405) anylist ::= anylist ANY */ yytestcase(yyruleno==405);
+      /* (406) with ::= */ yytestcase(yyruleno==406);
+      /* (407) windowdefn_list ::= windowdefn (OPTIMIZED OUT) */ assert(yyruleno!=407);
+      /* (408) window ::= frame_opt (OPTIMIZED OUT) */ assert(yyruleno!=408);
         break;
 /********** End reduce actions ************************************************/
   };
@@ -176194,19 +179196,12 @@ SQLITE_PRIVATE void sqlite3Parser(
                   (int)(yypParser->yytos - yypParser->yystack));
         }
 #endif
-#if YYSTACKDEPTH>0
         if( yypParser->yytos>=yypParser->yystackEnd ){
-          yyStackOverflow(yypParser);
-          break;
-        }
-#else
-        if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz-1] ){
           if( yyGrowStack(yypParser) ){
             yyStackOverflow(yypParser);
             break;
           }
         }
-#endif
       }
       yyact = yy_reduce(yypParser,yyruleno,yymajor,yyminor sqlite3ParserCTX_PARAM);
     }else if( yyact <= YY_MAX_SHIFTREDUCE ){
@@ -177277,27 +180272,58 @@ SQLITE_PRIVATE int sqlite3GetToken(const unsigned char *z, int *tokenType){
       *tokenType = TK_INTEGER;
 #ifndef SQLITE_OMIT_HEX_INTEGER
       if( z[0]=='0' && (z[1]=='x' || z[1]=='X') && sqlite3Isxdigit(z[2]) ){
-        for(i=3; sqlite3Isxdigit(z[i]); i++){}
-        return i;
-      }
+        for(i=3; 1; i++){
+          if( sqlite3Isxdigit(z[i])==0 ){
+            if( z[i]==SQLITE_DIGIT_SEPARATOR ){
+              *tokenType = TK_QNUMBER;
+            }else{
+              break;
+            }
+          }
+        }
+      }else
 #endif
-      for(i=0; sqlite3Isdigit(z[i]); i++){}
+        {
+        for(i=0; 1; i++){
+          if( sqlite3Isdigit(z[i])==0 ){
+            if( z[i]==SQLITE_DIGIT_SEPARATOR ){
+              *tokenType = TK_QNUMBER;
+            }else{
+              break;
+            }
+          }
+        }
 #ifndef SQLITE_OMIT_FLOATING_POINT
-      if( z[i]=='.' ){
-        i++;
-        while( sqlite3Isdigit(z[i]) ){ i++; }
-        *tokenType = TK_FLOAT;
-      }
-      if( (z[i]=='e' || z[i]=='E') &&
-           ( sqlite3Isdigit(z[i+1])
-            || ((z[i+1]=='+' || z[i+1]=='-') && sqlite3Isdigit(z[i+2]))
-           )
-      ){
-        i += 2;
-        while( sqlite3Isdigit(z[i]) ){ i++; }
-        *tokenType = TK_FLOAT;
-      }
+        if( z[i]=='.' ){
+          if( *tokenType==TK_INTEGER ) *tokenType = TK_FLOAT;
+          for(i++; 1; i++){
+            if( sqlite3Isdigit(z[i])==0 ){
+              if( z[i]==SQLITE_DIGIT_SEPARATOR ){
+                *tokenType = TK_QNUMBER;
+              }else{
+                break;
+              }
+            }
+          }
+        }
+        if( (z[i]=='e' || z[i]=='E') &&
+             ( sqlite3Isdigit(z[i+1])
+              || ((z[i+1]=='+' || z[i+1]=='-') && sqlite3Isdigit(z[i+2]))
+             )
+        ){
+          if( *tokenType==TK_INTEGER ) *tokenType = TK_FLOAT;
+          for(i+=2; 1; i++){
+            if( sqlite3Isdigit(z[i])==0 ){
+              if( z[i]==SQLITE_DIGIT_SEPARATOR ){
+                *tokenType = TK_QNUMBER;
+              }else{
+                break;
+              }
+            }
+          }
+        }
 #endif
+      }
       while( IdChar(z[i]) ){
         *tokenType = TK_ILLEGAL;
         i++;
@@ -177462,10 +180488,13 @@ SQLITE_PRIVATE int sqlite3RunParser(Parse *pParse, const char *zSql){
     if( tokenType>=TK_WINDOW ){
       assert( tokenType==TK_SPACE || tokenType==TK_OVER || tokenType==TK_FILTER
            || tokenType==TK_ILLEGAL || tokenType==TK_WINDOW
+           || tokenType==TK_QNUMBER
       );
 #else
     if( tokenType>=TK_SPACE ){
-      assert( tokenType==TK_SPACE || tokenType==TK_ILLEGAL );
+      assert( tokenType==TK_SPACE || tokenType==TK_ILLEGAL
+           || tokenType==TK_QNUMBER
+      );
 #endif /* SQLITE_OMIT_WINDOWFUNC */
       if( AtomicLoad(&db->u1.isInterrupted) ){
         pParse->rc = SQLITE_INTERRUPT;
@@ -177498,7 +180527,7 @@ SQLITE_PRIVATE int sqlite3RunParser(Parse *pParse, const char *zSql){
         assert( n==6 );
         tokenType = analyzeFilterKeyword((const u8*)&zSql[6], lastTokenParsed);
 #endif /* SQLITE_OMIT_WINDOWFUNC */
-      }else{
+      }else if( tokenType!=TK_QNUMBER ){
         Token x;
         x.z = zSql;
         x.n = n;
@@ -178243,32 +181272,6 @@ SQLITE_API char *sqlite3_temp_directory = 0;
 */
 SQLITE_API char *sqlite3_data_directory = 0;
 
-/*
-** Determine whether or not high-precision (long double) floating point
-** math works correctly on CPU currently running.
-*/
-static SQLITE_NOINLINE int hasHighPrecisionDouble(int rc){
-  if( sizeof(LONGDOUBLE_TYPE)<=8 ){
-    /* If the size of "long double" is not more than 8, then
-    ** high-precision math is not possible. */
-    return 0;
-  }else{
-    /* Just because sizeof(long double)>8 does not mean that the underlying
-    ** hardware actually supports high-precision floating point.  For example,
-    ** clearing the 0x100 bit in the floating-point control word on Intel
-    ** processors will make long double work like double, even though long
-    ** double takes up more space.  The only way to determine if long double
-    ** actually works is to run an experiment. */
-    LONGDOUBLE_TYPE a, b, c;
-    rc++;
-    a = 1.0+rc*0.1;
-    b = 1.0e+18+rc*25.0;
-    c = a+b;
-    return b!=c;
-  }
-}
-
-
 /*
 ** Initialize SQLite.
 **
@@ -178463,13 +181466,6 @@ SQLITE_API int sqlite3_initialize(void){
     rc = SQLITE_EXTRA_INIT(0);
   }
 #endif
-
-  /* Experimentally determine if high-precision floating point is
-  ** available. */
-#ifndef SQLITE_OMIT_WSD
-  sqlite3Config.bUseLongDouble = hasHighPrecisionDouble(rc);
-#endif
-
   return rc;
 }
 
@@ -178849,6 +181845,18 @@ SQLITE_API int sqlite3_config(int op, ...){
     }
 #endif /* SQLITE_OMIT_DESERIALIZE */
 
+    case SQLITE_CONFIG_ROWID_IN_VIEW: {
+      int *pVal = va_arg(ap,int*);
+#ifdef SQLITE_ALLOW_ROWID_IN_VIEW
+      if( 0==*pVal ) sqlite3GlobalConfig.mNoVisibleRowid = TF_NoVisibleRowid;
+      if( 1==*pVal ) sqlite3GlobalConfig.mNoVisibleRowid = 0;
+      *pVal = (sqlite3GlobalConfig.mNoVisibleRowid==0);
+#else
+      *pVal = 0;
+#endif
+      break;
+    }
+
     default: {
       rc = SQLITE_ERROR;
       break;
@@ -179998,7 +183006,8 @@ SQLITE_PRIVATE int sqlite3CreateFunc(
   assert( SQLITE_FUNC_CONSTANT==SQLITE_DETERMINISTIC );
   assert( SQLITE_FUNC_DIRECT==SQLITE_DIRECTONLY );
   extraFlags = enc &  (SQLITE_DETERMINISTIC|SQLITE_DIRECTONLY|
-                       SQLITE_SUBTYPE|SQLITE_INNOCUOUS|SQLITE_RESULT_SUBTYPE);
+                       SQLITE_SUBTYPE|SQLITE_INNOCUOUS|
+                       SQLITE_RESULT_SUBTYPE|SQLITE_SELFORDER1);
   enc &= (SQLITE_FUNC_ENCMASK|SQLITE_ANY);
 
   /* The SQLITE_INNOCUOUS flag is the same bit as SQLITE_FUNC_UNSAFE.  But
@@ -181553,6 +184562,7 @@ static int openDatabase(
   if( ((1<<(flags&7)) & 0x46)==0 ){
     rc = SQLITE_MISUSE_BKPT;  /* IMP: R-18321-05872 */
   }else{
+    if( zFilename==0 ) zFilename = ":memory:";
     rc = sqlite3ParseUri(zVfs, zFilename, &flags, &db->pVfs, &zOpen, &zErrMsg);
   }
   if( rc!=SQLITE_OK ){
@@ -182465,6 +185475,18 @@ SQLITE_API int sqlite3_test_control(int op, ...){
       break;
     }
 
+    /*  sqlite3_test_control(SQLITE_TESTCTRL_GETOPT, sqlite3 *db, int *N)
+    **
+    ** Write the current optimization settings into *N.  A zero bit means that
+    ** the optimization is on, and a 1 bit means that the optimization is off.
+    */
+    case SQLITE_TESTCTRL_GETOPT: {
+      sqlite3 *db = va_arg(ap, sqlite3*);
+      int *pN = va_arg(ap, int*);
+      *pN = db->dbOptFlags;
+      break;
+    }
+
     /*   sqlite3_test_control(SQLITE_TESTCTRL_LOCALTIME_FAULT, onoff, xAlt);
     **
     ** If parameter onoff is 1, subsequent calls to localtime() fail.
@@ -182696,24 +185718,6 @@ SQLITE_API int sqlite3_test_control(int op, ...){
       break;
     }
 
-#if !defined(SQLITE_OMIT_WSD)
-    /* sqlite3_test_control(SQLITE_TESTCTRL_USELONGDOUBLE, int X);
-    **
-    **   X<0     Make no changes to the bUseLongDouble.  Just report value.
-    **   X==0    Disable bUseLongDouble
-    **   X==1    Enable bUseLongDouble
-    **   X>=2    Set bUseLongDouble to its default value for this platform
-    */
-    case SQLITE_TESTCTRL_USELONGDOUBLE: {
-      int b = va_arg(ap, int);
-      if( b>=2 ) b = hasHighPrecisionDouble(b);
-      if( b>=0 ) sqlite3Config.bUseLongDouble = b>0;
-      rc = sqlite3Config.bUseLongDouble!=0;
-      break;
-    }
-#endif
-
-
 #if defined(SQLITE_DEBUG) && !defined(SQLITE_OMIT_WSD)
     /* sqlite3_test_control(SQLITE_TESTCTRL_TUNE, id, *piValue)
     **
@@ -183021,7 +186025,11 @@ SQLITE_API int sqlite3_snapshot_get(
     if( iDb==0 || iDb>1 ){
       Btree *pBt = db->aDb[iDb].pBt;
       if( SQLITE_TXN_WRITE!=sqlite3BtreeTxnState(pBt) ){
+        Pager *pPager = sqlite3BtreePager(pBt);
+        i64 dummy = 0;
+        sqlite3PagerSnapshotOpen(pPager, (sqlite3_snapshot*)&dummy);
         rc = sqlite3BtreeBeginTrans(pBt, 0, 0);
+        sqlite3PagerSnapshotOpen(pPager, 0);
         if( rc==SQLITE_OK ){
           rc = sqlite3PagerSnapshotGet(sqlite3BtreePager(pBt), ppSnapshot);
         }
@@ -184749,6 +187757,8 @@ SQLITE_PRIVATE int sqlite3FtsUnicodeIsdiacritic(int);
 
 SQLITE_PRIVATE int sqlite3Fts3ExprIterate(Fts3Expr*, int (*x)(Fts3Expr*,int,void*), void*);
 
+SQLITE_PRIVATE int sqlite3Fts3IntegrityCheck(Fts3Table *p, int *pbOk);
+
 #endif /* !SQLITE_CORE || SQLITE_ENABLE_FTS3 */
 #endif /* _FTSINT_H */
 
@@ -186809,10 +189819,15 @@ static int fts3PoslistPhraseMerge(
   if( *p1==POS_COLUMN ){
     p1++;
     p1 += fts3GetVarint32(p1, &iCol1);
+    /* iCol1==0 indicates corruption. Column 0 does not have a POS_COLUMN
+    ** entry, so this is actually end-of-doclist. */
+    if( iCol1==0 ) return 0;
   }
   if( *p2==POS_COLUMN ){
     p2++;
     p2 += fts3GetVarint32(p2, &iCol2);
+    /* As above, iCol2==0 indicates corruption. */
+    if( iCol2==0 ) return 0;
   }
 
   while( 1 ){
@@ -188471,7 +191486,7 @@ static int fts3ShadowName(const char *zName){
 ** Implementation of the xIntegrity() method on the FTS3/FTS4 virtual
 ** table.
 */
-static int fts3Integrity(
+static int fts3IntegrityMethod(
   sqlite3_vtab *pVtab,      /* The virtual table to be checked */
   const char *zSchema,      /* Name of schema in which pVtab lives */
   const char *zTabname,     /* Name of the pVTab table */
@@ -188479,31 +191494,24 @@ static int fts3Integrity(
   char **pzErr              /* Write error message here */
 ){
   Fts3Table *p = (Fts3Table*)pVtab;
-  char *zSql;
-  int rc;
-  char *zErr = 0;
+  int rc = SQLITE_OK;
+  int bOk = 0;
 
-  assert( pzErr!=0 );
-  assert( *pzErr==0 );
   UNUSED_PARAMETER(isQuick);
-  zSql = sqlite3_mprintf(
-            "INSERT INTO \"%w\".\"%w\"(\"%w\") VALUES('integrity-check');",
-            zSchema, zTabname, zTabname);
-  if( zSql==0 ){
-    return SQLITE_NOMEM;
-  }
-  rc = sqlite3_exec(p->db, zSql, 0, 0, &zErr);
-  sqlite3_free(zSql);
-  if( (rc&0xff)==SQLITE_CORRUPT ){
-    *pzErr = sqlite3_mprintf("malformed inverted index for FTS%d table %s.%s",
-                p->bFts4 ? 4 : 3, zSchema, zTabname);
-  }else if( rc!=SQLITE_OK ){
+  rc = sqlite3Fts3IntegrityCheck(p, &bOk);
+  assert( rc!=SQLITE_CORRUPT_VTAB );
+  if( rc==SQLITE_ERROR || (rc&0xFF)==SQLITE_CORRUPT ){
     *pzErr = sqlite3_mprintf("unable to validate the inverted index for"
                              " FTS%d table %s.%s: %s",
-                p->bFts4 ? 4 : 3, zSchema, zTabname, zErr);
+                p->bFts4 ? 4 : 3, zSchema, zTabname, sqlite3_errstr(rc));
+    if( *pzErr ) rc = SQLITE_OK;
+  }else if( rc==SQLITE_OK && bOk==0 ){
+    *pzErr = sqlite3_mprintf("malformed inverted index for FTS%d table %s.%s",
+                p->bFts4 ? 4 : 3, zSchema, zTabname);
+    if( *pzErr==0 ) rc = SQLITE_NOMEM;
   }
-  sqlite3_free(zErr);
-  return SQLITE_OK;
+  sqlite3Fts3SegmentsClose(p);
+  return rc;
 }
 
 
@@ -188533,7 +191541,7 @@ static const sqlite3_module fts3Module = {
   /* xRelease      */ fts3ReleaseMethod,
   /* xRollbackTo   */ fts3RollbackToMethod,
   /* xShadowName   */ fts3ShadowName,
-  /* xIntegrity    */ fts3Integrity,
+  /* xIntegrity    */ fts3IntegrityMethod,
 };
 
 /*
@@ -189990,7 +192998,7 @@ static int fts3EvalNearTest(Fts3Expr *pExpr, int *pRc){
       nTmp += p->pRight->pPhrase->doclist.nList;
     }
     nTmp += p->pPhrase->doclist.nList;
-    aTmp = sqlite3_malloc64(nTmp*2);
+    aTmp = sqlite3_malloc64(nTmp*2 + FTS3_VARINT_MAX);
     if( !aTmp ){
       *pRc = SQLITE_NOMEM;
       res = 0;
@@ -191543,10 +194551,11 @@ static int getNextString(
         Fts3PhraseToken *pToken;
 
         p = fts3ReallocOrFree(p, nSpace + ii*sizeof(Fts3PhraseToken));
-        if( !p ) goto no_mem;
-
         zTemp = fts3ReallocOrFree(zTemp, nTemp + nByte);
-        if( !zTemp ) goto no_mem;
+        if( !zTemp || !p ){
+          rc = SQLITE_NOMEM;
+          goto getnextstring_out;
+        }
 
         assert( nToken==ii );
         pToken = &((Fts3Phrase *)(&p[1]))->aToken[ii];
@@ -191561,9 +194570,6 @@ static int getNextString(
         nToken = ii+1;
       }
     }
-
-    pModule->xClose(pCursor);
-    pCursor = 0;
   }
 
   if( rc==SQLITE_DONE ){
@@ -191571,7 +194577,10 @@ static int getNextString(
     char *zBuf = 0;
 
     p = fts3ReallocOrFree(p, nSpace + nToken*sizeof(Fts3PhraseToken) + nTemp);
-    if( !p ) goto no_mem;
+    if( !p ){
+      rc = SQLITE_NOMEM;
+      goto getnextstring_out;
+    }
     memset(p, 0, (char *)&(((Fts3Phrase *)&p[1])->aToken[0])-(char *)p);
     p->eType = FTSQUERY_PHRASE;
     p->pPhrase = (Fts3Phrase *)&p[1];
@@ -191579,11 +194588,9 @@ static int getNextString(
     p->pPhrase->nToken = nToken;
 
     zBuf = (char *)&p->pPhrase->aToken[nToken];
+    assert( nTemp==0 || zTemp );
     if( zTemp ){
       memcpy(zBuf, zTemp, nTemp);
-      sqlite3_free(zTemp);
-    }else{
-      assert( nTemp==0 );
     }
 
     for(jj=0; jj<p->pPhrase->nToken; jj++){
@@ -191593,17 +194600,17 @@ static int getNextString(
     rc = SQLITE_OK;
   }
 
-  *ppExpr = p;
-  return rc;
-no_mem:
-
+ getnextstring_out:
   if( pCursor ){
     pModule->xClose(pCursor);
   }
   sqlite3_free(zTemp);
-  sqlite3_free(p);
-  *ppExpr = 0;
-  return SQLITE_NOMEM;
+  if( rc!=SQLITE_OK ){
+    sqlite3_free(p);
+    p = 0;
+  }
+  *ppExpr = p;
+  return rc;
 }
 
 /*
@@ -193797,11 +196804,7 @@ SQLITE_PRIVATE int sqlite3Fts3InitTokenizer(
 
 #ifdef SQLITE_TEST
 
-#if defined(INCLUDE_SQLITE_TCL_H)
-#  include "sqlite_tcl.h"
-#else
-#  include "tcl.h"
-#endif
+#include "tclsqlite.h"
 /* #include <string.h> */
 
 /*
@@ -200087,7 +203090,7 @@ static u64 fts3ChecksumIndex(
 ** If an error occurs (e.g. an OOM or IO error), return an SQLite error
 ** code. The final value of *pbOk is undefined in this case.
 */
-static int fts3IntegrityCheck(Fts3Table *p, int *pbOk){
+SQLITE_PRIVATE int sqlite3Fts3IntegrityCheck(Fts3Table *p, int *pbOk){
   int rc = SQLITE_OK;             /* Return code */
   u64 cksum1 = 0;                 /* Checksum based on FTS index contents */
   u64 cksum2 = 0;                 /* Checksum based on %_content contents */
@@ -200165,7 +203168,12 @@ static int fts3IntegrityCheck(Fts3Table *p, int *pbOk){
     sqlite3_finalize(pStmt);
   }
 
-  *pbOk = (cksum1==cksum2);
+  if( rc==SQLITE_CORRUPT_VTAB ){
+    rc = SQLITE_OK;
+    *pbOk = 0;
+  }else{
+    *pbOk = (rc==SQLITE_OK && cksum1==cksum2);
+  }
   return rc;
 }
 
@@ -200205,7 +203213,7 @@ static int fts3DoIntegrityCheck(
 ){
   int rc;
   int bOk = 0;
-  rc = fts3IntegrityCheck(p, &bOk);
+  rc = sqlite3Fts3IntegrityCheck(p, &bOk);
   if( rc==SQLITE_OK && bOk==0 ) rc = FTS_CORRUPT_VTAB;
   return rc;
 }
@@ -201023,6 +204031,7 @@ static int fts3SnippetNextCandidate(SnippetIter *pIter){
       return 1;
     }
 
+    assert( pIter->nSnippet>=0 );
     pIter->iCurrent = iStart = iEnd - pIter->nSnippet + 1;
     for(i=0; i<pIter->nPhrase; i++){
       SnippetPhrase *pPhrase = &pIter->aPhrase[i];
@@ -201071,7 +204080,7 @@ static void fts3SnippetDetails(
         }
         mCover |= mPhrase;
 
-        for(j=0; j<pPhrase->nToken; j++){
+        for(j=0; j<pPhrase->nToken && j<pIter->nSnippet; j++){
           mHighlight |= (mPos>>j);
         }
 
@@ -203732,7 +206741,6 @@ static void jsonAppendRawNZ(JsonString *p, const char *zIn, u32 N){
   }
 }
 
-
 /* Append formatted text (not to exceed N bytes) to the JsonString.
 */
 static void jsonPrintf(int N, JsonString *p, const char *zFormat, ...){
@@ -203758,6 +206766,16 @@ static void jsonAppendChar(JsonString *p, char c){
   }
 }
 
+/* Remove a single character from the end of the string
+*/
+static void jsonStringTrimOneChar(JsonString *p){
+  if( p->eErr==0 ){
+    assert( p->nUsed>0 );
+    p->nUsed--;
+  }
+}
+
+
 /* Make sure there is a zero terminator on p->zBuf[]
 **
 ** Return true on success.  Return false if an OOM prevents this
@@ -203765,7 +206783,7 @@ static void jsonAppendChar(JsonString *p, char c){
 */
 static int jsonStringTerminate(JsonString *p){
   jsonAppendChar(p, 0);
-  p->nUsed--;
+  jsonStringTrimOneChar(p);
   return p->eErr==0;
 }
 
@@ -203780,6 +206798,40 @@ static void jsonAppendSeparator(JsonString *p){
   jsonAppendChar(p, ',');
 }
 
+/* c is a control character.  Append the canonical JSON representation
+** of that control character to p.
+**
+** This routine assumes that the output buffer has already been enlarged
+** sufficiently to hold the worst-case encoding plus a nul terminator.
+*/
+static void jsonAppendControlChar(JsonString *p, u8 c){
+  static const char aSpecial[] = {
+     0, 0, 0, 0, 0, 0, 0, 0, 'b', 't', 'n', 0, 'f', 'r', 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0, 0,   0,   0, 0, 0
+  };
+  assert( sizeof(aSpecial)==32 );
+  assert( aSpecial['\b']=='b' );
+  assert( aSpecial['\f']=='f' );
+  assert( aSpecial['\n']=='n' );
+  assert( aSpecial['\r']=='r' );
+  assert( aSpecial['\t']=='t' );
+  assert( c>=0 && c<sizeof(aSpecial) );
+  assert( p->nUsed+7 <= p->nAlloc );
+  if( aSpecial[c] ){
+    p->zBuf[p->nUsed] = '\\';
+    p->zBuf[p->nUsed+1] = aSpecial[c];
+    p->nUsed += 2;
+  }else{
+    p->zBuf[p->nUsed] = '\\';
+    p->zBuf[p->nUsed+1] = 'u';
+    p->zBuf[p->nUsed+2] = '0';
+    p->zBuf[p->nUsed+3] = '0';
+    p->zBuf[p->nUsed+4] = "0123456789abcdef"[c>>4];
+    p->zBuf[p->nUsed+5] = "0123456789abcdef"[c&0xf];
+    p->nUsed += 6;
+  }
+}
+
 /* Append the N-byte string in zIn to the end of the JsonString string
 ** under construction.  Enclose the string in double-quotes ("...") and
 ** escape any double-quotes or backslash characters contained within the
@@ -203839,35 +206891,14 @@ static void jsonAppendString(JsonString *p, const char *zIn, u32 N){
     }
     c = z[0];
     if( c=='"' || c=='\\' ){
-      json_simple_escape:
       if( (p->nUsed+N+3 > p->nAlloc) && jsonStringGrow(p,N+3)!=0 ) return;
       p->zBuf[p->nUsed++] = '\\';
       p->zBuf[p->nUsed++] = c;
     }else if( c=='\'' ){
       p->zBuf[p->nUsed++] = c;
     }else{
-      static const char aSpecial[] = {
-         0, 0, 0, 0, 0, 0, 0, 0, 'b', 't', 'n', 0, 'f', 'r', 0, 0,
-         0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0, 0,   0,   0, 0, 0
-      };
-      assert( sizeof(aSpecial)==32 );
-      assert( aSpecial['\b']=='b' );
-      assert( aSpecial['\f']=='f' );
-      assert( aSpecial['\n']=='n' );
-      assert( aSpecial['\r']=='r' );
-      assert( aSpecial['\t']=='t' );
-      assert( c>=0 && c<sizeof(aSpecial) );
-      if( aSpecial[c] ){
-        c = aSpecial[c];
-        goto json_simple_escape;
-      }
       if( (p->nUsed+N+7 > p->nAlloc) && jsonStringGrow(p,N+7)!=0 ) return;
-      p->zBuf[p->nUsed++] = '\\';
-      p->zBuf[p->nUsed++] = 'u';
-      p->zBuf[p->nUsed++] = '0';
-      p->zBuf[p->nUsed++] = '0';
-      p->zBuf[p->nUsed++] = "0123456789abcdef"[c>>4];
-      p->zBuf[p->nUsed++] = "0123456789abcdef"[c&0xf];
+      jsonAppendControlChar(p, c);
     }
     z++;
     N--;
@@ -204568,7 +207599,10 @@ static u32 jsonbValidityCheck(
         if( !jsonIsOk[z[j]] && z[j]!='\'' ){
           if( z[j]=='"' ){
             if( x==JSONB_TEXTJ ) return j+1;
-          }else if( z[j]!='\\' || j+1>=k ){
+          }else if( z[j]<=0x1f ){
+            /* Control characters in JSON5 string literals are ok */
+            if( x==JSONB_TEXTJ ) return j+1;
+          }else if( NEVER(z[j]!='\\') || j+1>=k ){
             return j+1;
           }else if( strchr("\"\\/bfnrt",z[j+1])!=0 ){
             j++;
@@ -204766,6 +207800,7 @@ json_parse_restart:
   case '[': {
     /* Parse array */
     iThis = pParse->nBlob;
+    assert( i<=(u32)pParse->nJson );
     jsonBlobAppendNode(pParse, JSONB_ARRAY, pParse->nJson - i, 0);
     iStart = pParse->nBlob;
     if( pParse->oom ) return -1;
@@ -204862,9 +207897,14 @@ json_parse_restart:
           return -1;
         }
       }else if( c<=0x1f ){
-        /* Control characters are not allowed in strings */
-        pParse->iErr = j;
-        return -1;
+        if( c==0 ){
+          pParse->iErr = j;
+          return -1;
+        }
+        /* Control characters are not allowed in canonical JSON string
+        ** literals, but are allowed in JSON5 string literals. */
+        opcode = JSONB_TEXT5;
+        pParse->hasNonstd = 1;
       }else if( c=='"' ){
         opcode = JSONB_TEXT5;
       }
@@ -205080,6 +208120,7 @@ json_parse_restart:
       return i+4;
     }
     /* fall-through into the default case that checks for NaN */
+    /* no break */ deliberate_fall_through
   }
   default: {
     u32 k;
@@ -205164,6 +208205,10 @@ static void jsonReturnStringAsBlob(JsonString *pStr){
   JsonParse px;
   memset(&px, 0, sizeof(px));
   jsonStringTerminate(pStr);
+  if( pStr->eErr ){
+    sqlite3_result_error_nomem(pStr->pCtx);
+    return;
+  }
   px.zJson = pStr->zBuf;
   px.nJson = pStr->nUsed;
   px.db = sqlite3_context_db_handle(pStr->pCtx);
@@ -205231,8 +208276,8 @@ static u32 jsonbPayloadSize(const JsonParse *pParse, u32 i, u32 *pSz){
          (pParse->aBlob[i+7]<<8) + pParse->aBlob[i+8];
     n = 9;
   }
-  if( i+sz+n > pParse->nBlob
-   && i+sz+n > pParse->nBlob-pParse->delta
+  if( (i64)i+sz+n > pParse->nBlob
+   && (i64)i+sz+n > pParse->nBlob-pParse->delta
   ){
     sz = 0;
     n = 0;
@@ -205282,6 +208327,7 @@ static u32 jsonTranslateBlobToText(
     }
     case JSONB_INT:
     case JSONB_FLOAT: {
+      if( sz==0 ) goto malformed_jsonb;
       jsonAppendRaw(pOut, (const char*)&pParse->aBlob[i+n], sz);
       break;
     }
@@ -205290,6 +208336,7 @@ static u32 jsonTranslateBlobToText(
       sqlite3_uint64 u = 0;
       const char *zIn = (const char*)&pParse->aBlob[i+n];
       int bOverflow = 0;
+      if( sz==0 ) goto malformed_jsonb;
       if( zIn[0]=='-' ){
         jsonAppendChar(pOut, '-');
         k++;
@@ -205312,6 +208359,7 @@ static u32 jsonTranslateBlobToText(
     case JSONB_FLOAT5: { /* Float literal missing digits beside "." */
       u32 k = 0;
       const char *zIn = (const char*)&pParse->aBlob[i+n];
+      if( sz==0 ) goto malformed_jsonb;
       if( zIn[0]=='-' ){
         jsonAppendChar(pOut, '-');
         k++;
@@ -205341,7 +208389,7 @@ static u32 jsonTranslateBlobToText(
       zIn = (const char*)&pParse->aBlob[i+n];
       jsonAppendChar(pOut, '"');
       while( sz2>0 ){
-        for(k=0; k<sz2 && zIn[k]!='\\' && zIn[k]!='"'; k++){}
+        for(k=0; k<sz2 && (jsonIsOk[(u8)zIn[k]] || zIn[k]=='\''); k++){}
         if( k>0 ){
           jsonAppendRawNZ(pOut, zIn, k);
           if( k>=sz2 ){
@@ -205356,6 +208404,13 @@ static u32 jsonTranslateBlobToText(
           sz2--;
           continue;
         }
+        if( zIn[0]<=0x1f ){
+          if( pOut->nUsed+7>pOut->nAlloc && jsonStringGrow(pOut,7) ) break;
+          jsonAppendControlChar(pOut, zIn[0]);
+          zIn++;
+          sz2--;
+          continue;
+        }
         assert( zIn[0]=='\\' );
         assert( sz2>=1 );
         if( sz2<2 ){
@@ -205425,11 +208480,12 @@ static u32 jsonTranslateBlobToText(
       jsonAppendChar(pOut, '[');
       j = i+n;
       iEnd = j+sz;
-      while( j<iEnd ){
+      while( j<iEnd && pOut->eErr==0 ){
         j = jsonTranslateBlobToText(pParse, j, pOut);
         jsonAppendChar(pOut, ',');
       }
-      if( sz>0 ) pOut->nUsed--;
+      if( j>iEnd ) pOut->eErr |= JSTRING_MALFORMED;
+      if( sz>0 ) jsonStringTrimOneChar(pOut);
       jsonAppendChar(pOut, ']');
       break;
     }
@@ -205438,17 +208494,18 @@ static u32 jsonTranslateBlobToText(
       jsonAppendChar(pOut, '{');
       j = i+n;
       iEnd = j+sz;
-      while( j<iEnd ){
+      while( j<iEnd && pOut->eErr==0 ){
         j = jsonTranslateBlobToText(pParse, j, pOut);
         jsonAppendChar(pOut, (x++ & 1) ? ',' : ':');
       }
-      if( x & 1 ) pOut->eErr |= JSTRING_MALFORMED;
-      if( sz>0 ) pOut->nUsed--;
+      if( (x & 1)!=0 || j>iEnd ) pOut->eErr |= JSTRING_MALFORMED;
+      if( sz>0 ) jsonStringTrimOneChar(pOut);
       jsonAppendChar(pOut, '}');
       break;
     }
 
     default: {
+      malformed_jsonb:
       pOut->eErr |= JSTRING_MALFORMED;
       break;
     }
@@ -205456,6 +208513,112 @@ static u32 jsonTranslateBlobToText(
   return i+n+sz;
 }
 
+/* Context for recursion of json_pretty()
+*/
+typedef struct JsonPretty JsonPretty;
+struct JsonPretty {
+  JsonParse *pParse;        /* The BLOB being rendered */
+  JsonString *pOut;         /* Generate pretty output into this string */
+  const char *zIndent;      /* Use this text for indentation */
+  u32 szIndent;             /* Bytes in zIndent[] */
+  u32 nIndent;              /* Current level of indentation */
+};
+
+/* Append indentation to the pretty JSON under construction */
+static void jsonPrettyIndent(JsonPretty *pPretty){
+  u32 jj;
+  for(jj=0; jj<pPretty->nIndent; jj++){
+    jsonAppendRaw(pPretty->pOut, pPretty->zIndent, pPretty->szIndent);
+  }
+}
+
+/*
+** Translate the binary JSONB representation of JSON beginning at
+** pParse->aBlob[i] into a JSON text string.  Append the JSON
+** text onto the end of pOut.  Return the index in pParse->aBlob[]
+** of the first byte past the end of the element that is translated.
+**
+** This is a variant of jsonTranslateBlobToText() that "pretty-prints"
+** the output.  Extra whitespace is inserted to make the JSON easier
+** for humans to read.
+**
+** If an error is detected in the BLOB input, the pOut->eErr flag
+** might get set to JSTRING_MALFORMED.  But not all BLOB input errors
+** are detected.  So a malformed JSONB input might either result
+** in an error, or in incorrect JSON.
+**
+** The pOut->eErr JSTRING_OOM flag is set on a OOM.
+*/
+static u32 jsonTranslateBlobToPrettyText(
+  JsonPretty *pPretty,       /* Pretty-printing context */
+  u32 i                      /* Start rendering at this index */
+){
+  u32 sz, n, j, iEnd;
+  const JsonParse *pParse = pPretty->pParse;
+  JsonString *pOut = pPretty->pOut;
+  n = jsonbPayloadSize(pParse, i, &sz);
+  if( n==0 ){
+    pOut->eErr |= JSTRING_MALFORMED;
+    return pParse->nBlob+1;
+  }
+  switch( pParse->aBlob[i] & 0x0f ){
+    case JSONB_ARRAY: {
+      j = i+n;
+      iEnd = j+sz;
+      jsonAppendChar(pOut, '[');
+      if( j<iEnd ){
+        jsonAppendChar(pOut, '\n');
+        pPretty->nIndent++;
+        while( pOut->eErr==0 ){
+          jsonPrettyIndent(pPretty);
+          j = jsonTranslateBlobToPrettyText(pPretty, j);
+          if( j>=iEnd ) break;
+          jsonAppendRawNZ(pOut, ",\n", 2);
+        }
+        jsonAppendChar(pOut, '\n');
+        pPretty->nIndent--;
+        jsonPrettyIndent(pPretty);
+      }
+      jsonAppendChar(pOut, ']');
+      i = iEnd;
+      break;
+    }
+    case JSONB_OBJECT: {
+      j = i+n;
+      iEnd = j+sz;
+      jsonAppendChar(pOut, '{');
+      if( j<iEnd ){
+        jsonAppendChar(pOut, '\n');
+        pPretty->nIndent++;
+        while( pOut->eErr==0 ){
+          jsonPrettyIndent(pPretty);
+          j = jsonTranslateBlobToText(pParse, j, pOut);
+          if( j>iEnd ){
+            pOut->eErr |= JSTRING_MALFORMED;
+            break;
+          }
+          jsonAppendRawNZ(pOut, ": ", 2);
+          j = jsonTranslateBlobToPrettyText(pPretty, j);
+          if( j>=iEnd ) break;
+          jsonAppendRawNZ(pOut, ",\n", 2);
+        }
+        jsonAppendChar(pOut, '\n');
+        pPretty->nIndent--;
+        jsonPrettyIndent(pPretty);
+      }
+      jsonAppendChar(pOut, '}');
+      i = iEnd;
+      break;
+    }
+    default: {
+      i = jsonTranslateBlobToText(pParse, i, pOut);
+      break;
+    }
+  }
+  return i;
+}
+
+
 /* Return true if the input pJson
 **
 ** For performance reasons, this routine does not do a detailed check of the
@@ -205862,7 +209025,9 @@ static u32 jsonLookupStep(
     zPath++;
     if( zPath[0]=='"' ){
       zKey = zPath + 1;
-      for(i=1; zPath[i] && zPath[i]!='"'; i++){}
+      for(i=1; zPath[i] && zPath[i]!='"'; i++){
+        if( zPath[i]=='\\' && zPath[i+1]!=0 ) i++;
+      }
       nKey = i-1;
       if( zPath[i] ){
         i++;
@@ -206375,6 +209540,38 @@ jsonInsertIntoBlob_patherror:
   return;
 }
 
+/*
+** If pArg is a blob that seems like a JSONB blob, then initialize
+** p to point to that JSONB and return TRUE.  If pArg does not seem like
+** a JSONB blob, then return FALSE;
+**
+** This routine is only called if it is already known that pArg is a
+** blob.  The only open question is whether or not the blob appears
+** to be a JSONB blob.
+*/
+static int jsonArgIsJsonb(sqlite3_value *pArg, JsonParse *p){
+  u32 n, sz = 0;
+  p->aBlob = (u8*)sqlite3_value_blob(pArg);
+  p->nBlob = (u32)sqlite3_value_bytes(pArg);
+  if( p->nBlob==0 ){
+    p->aBlob = 0;
+    return 0;
+  }
+  if( NEVER(p->aBlob==0) ){
+    return 0;
+  }
+  if( (p->aBlob[0] & 0x0f)<=JSONB_OBJECT
+   && (n = jsonbPayloadSize(p, 0, &sz))>0
+   && sz+n==p->nBlob
+   && ((p->aBlob[0] & 0x0f)>JSONB_FALSE || sz==0)
+  ){
+    return 1;
+  }
+  p->aBlob = 0;
+  p->nBlob = 0;
+  return 0;
+}
+
 /*
 ** Generate a JsonParse object, containing valid JSONB in aBlob and nBlob,
 ** from the SQL function argument pArg.  Return a pointer to the new
@@ -206431,34 +209628,30 @@ rebuild_from_cache:
     return p;
   }
   if( eType==SQLITE_BLOB ){
-    u32 n, sz = 0;
-    p->aBlob = (u8*)sqlite3_value_blob(pArg);
-    p->nBlob = (u32)sqlite3_value_bytes(pArg);
-    if( p->nBlob==0 ){
-      goto json_pfa_malformed;
+    if( jsonArgIsJsonb(pArg,p) ){
+      if( (flgs & JSON_EDITABLE)!=0 && jsonBlobMakeEditable(p, 0)==0 ){
+        goto json_pfa_oom;
+      }
+      return p;
     }
-    if( NEVER(p->aBlob==0) ){
-      goto json_pfa_oom;
-    }
-    if( (p->aBlob[0] & 0x0f)>JSONB_OBJECT ){
-      goto json_pfa_malformed;
-    }
-    n = jsonbPayloadSize(p, 0, &sz);
-    if( n==0
-     || sz+n!=p->nBlob
-     || ((p->aBlob[0] & 0x0f)<=JSONB_FALSE && sz>0)
-    ){
-      goto json_pfa_malformed;
-    }
-    if( (flgs & JSON_EDITABLE)!=0 && jsonBlobMakeEditable(p, 0)==0 ){
-      goto json_pfa_oom;
-    }
-    return p;
+    /* If the blob is not valid JSONB, fall through into trying to cast
+    ** the blob into text which is then interpreted as JSON.  (tag-20240123-a)
+    **
+    ** This goes against all historical documentation about how the SQLite
+    ** JSON functions were suppose to work.  From the beginning, blob was
+    ** reserved for expansion and a blob value should have raised an error.
+    ** But it did not, due to a bug.  And many applications came to depend
+    ** upon this buggy behavior, espeically when using the CLI and reading
+    ** JSON text using readfile(), which returns a blob.  For this reason
+    ** we will continue to support the bug moving forward.
+    ** See for example https://sqlite.org/forum/forumpost/012136abd5292b8d
+    */
   }
   p->zJson = (char*)sqlite3_value_text(pArg);
   p->nJson = sqlite3_value_bytes(pArg);
+  if( db->mallocFailed ) goto json_pfa_oom;
   if( p->nJson==0 ) goto json_pfa_malformed;
-  if( NEVER(p->zJson==0) ) goto json_pfa_oom;
+  assert( p->zJson!=0 );
   if( jsonConvertTextToBlob(p, (flgs & JSON_KEEPERROR) ? 0 : ctx) ){
     if( flgs & JSON_KEEPERROR ){
       p->nErr = 1;
@@ -206624,10 +209817,10 @@ static void jsonDebugPrintBlob(
       if( sz==0 && x<=JSONB_FALSE ){
         sqlite3_str_append(pOut, "\n", 1);
       }else{
-        u32 i;
+        u32 j;
         sqlite3_str_appendall(pOut, ": \"");
-        for(i=iStart+n; i<iStart+n+sz; i++){
-          u8 c = pParse->aBlob[i];
+        for(j=iStart+n; j<iStart+n+sz; j++){
+          u8 c = pParse->aBlob[j];
           if( c<0x20 || c>=0x7f ) c = '.';
           sqlite3_str_append(pOut, (char*)&c, 1);
         }
@@ -206678,11 +209871,12 @@ static void jsonParseFunc(
   if( p==0 ) return;
   if( argc==1 ){
     jsonDebugPrintBlob(p, 0, p->nBlob, 0, &out);
-    sqlite3_result_text64(ctx, out.zText, out.nChar, SQLITE_DYNAMIC, SQLITE_UTF8);
+    sqlite3_result_text64(ctx,out.zText,out.nChar,SQLITE_TRANSIENT,SQLITE_UTF8);
   }else{
     jsonShowParse(p);
   }
   jsonParseFree(p);
+  sqlite3_str_reset(&out);
 }
 #endif /* SQLITE_DEBUG */
 
@@ -206781,13 +209975,6 @@ static void jsonArrayLengthFunc(
   jsonParseFree(p);
 }
 
-/* True if the string is all digits */
-static int jsonAllDigits(const char *z, int n){
-  int i;
-  for(i=0; i<n && sqlite3Isdigit(z[i]); i++){}
-  return i==n;
-}
-
 /* True if the string is all alphanumerics and underscores */
 static int jsonAllAlphanum(const char *z, int n){
   int i;
@@ -206850,10 +210037,16 @@ static void jsonExtractFunc(
       **     NUMBER   ==>  $[NUMBER]     // PG compatible
       **     LABEL    ==>  $.LABEL       // PG compatible
       **     [NUMBER] ==>  $[NUMBER]     // Not PG.  Purely for convenience
+      **
+      ** Updated 2024-05-27:  If the NUMBER is negative, then PG counts from
+      ** the right of the array.  Hence for negative NUMBER:
+      **
+      **     NUMBER   ==>  $[#NUMBER]    // PG compatible
       */
       jsonStringInit(&jx, ctx);
-      if( jsonAllDigits(zPath, nPath) ){
+      if( sqlite3_value_type(argv[i])==SQLITE_INTEGER ){
         jsonAppendRawNZ(&jx, "[", 1);
+        if( zPath[0]=='-' ) jsonAppendRawNZ(&jx,"#",1);
         jsonAppendRaw(&jx, zPath, nPath);
         jsonAppendRawNZ(&jx, "]", 2);
       }else if( jsonAllAlphanum(zPath, nPath) ){
@@ -207346,6 +210539,40 @@ json_type_done:
   jsonParseFree(p);
 }
 
+/*
+** json_pretty(JSON)
+** json_pretty(JSON, INDENT)
+**
+** Return text that is a pretty-printed rendering of the input JSON.
+** If the argument is not valid JSON, return NULL.
+**
+** The INDENT argument is text that is used for indentation.  If omitted,
+** it defaults to four spaces (the same as PostgreSQL).
+*/
+static void jsonPrettyFunc(
+  sqlite3_context *ctx,
+  int argc,
+  sqlite3_value **argv
+){
+  JsonString s;          /* The output string */
+  JsonPretty x;          /* Pretty printing context */
+
+  memset(&x, 0, sizeof(x));
+  x.pParse = jsonParseFuncArg(ctx, argv[0], 0);
+  if( x.pParse==0 ) return;
+  x.pOut = &s;
+  jsonStringInit(&s, ctx);
+  if( argc==1 || (x.zIndent = (const char*)sqlite3_value_text(argv[1]))==0 ){
+    x.zIndent = "    ";
+    x.szIndent = 4;
+  }else{
+    x.szIndent = (u32)strlen(x.zIndent);
+  }
+  jsonTranslateBlobToPrettyText(&x, 0);
+  jsonReturnString(&s, 0, 0);
+  jsonParseFree(x.pParse);
+}
+
 /*
 ** json_valid(JSON)
 ** json_valid(JSON, FLAGS)
@@ -207429,12 +210656,12 @@ static void jsonValidFunc(
       return;
     }
     case SQLITE_BLOB: {
-      if( (flags & 0x0c)!=0 && jsonFuncArgMightBeBinary(argv[0]) ){
+      if( jsonFuncArgMightBeBinary(argv[0]) ){
         if( flags & 0x04 ){
           /* Superficial checking only - accomplished by the
           ** jsonFuncArgMightBeBinary() call above. */
           res = 1;
-        }else{
+        }else if( flags & 0x08 ){
           /* Strict checking.  Check by translating BLOB->TEXT->BLOB.  If
           ** no errors occur, call that a "strict check". */
           JsonParse px;
@@ -207445,8 +210672,11 @@ static void jsonValidFunc(
           iErr = jsonbValidityCheck(&px, 0, px.nBlob, 1);
           res = iErr==0;
         }
+        break;
       }
-      break;
+      /* Fall through into interpreting the input as text.  See note
+      ** above at tag-20240123-a. */
+      /* no break */ deliberate_fall_through
     }
     default: {
       JsonParse px;
@@ -207571,7 +210801,7 @@ static void jsonArrayCompute(sqlite3_context *ctx, int isFinal){
       if( isFinal ){
         if( !pStr->bStatic ) sqlite3RCStrUnref(pStr->zBuf);
       }else{
-        pStr->nUsed--;
+        jsonStringTrimOneChar(pStr);
       }
       return;
     }else if( isFinal ){
@@ -207581,7 +210811,7 @@ static void jsonArrayCompute(sqlite3_context *ctx, int isFinal){
       pStr->bStatic = 1;
     }else{
       sqlite3_result_text(ctx, pStr->zBuf, (int)pStr->nUsed, SQLITE_TRANSIENT);
-      pStr->nUsed--;
+      jsonStringTrimOneChar(pStr);
     }
   }else{
     sqlite3_result_text(ctx, "[]", 2, SQLITE_STATIC);
@@ -207691,7 +210921,7 @@ static void jsonObjectCompute(sqlite3_context *ctx, int isFinal){
       if( isFinal ){
         if( !pStr->bStatic ) sqlite3RCStrUnref(pStr->zBuf);
       }else{
-        pStr->nUsed--;
+        jsonStringTrimOneChar(pStr);
       }
       return;
     }else if( isFinal ){
@@ -207701,7 +210931,7 @@ static void jsonObjectCompute(sqlite3_context *ctx, int isFinal){
       pStr->bStatic = 1;
     }else{
       sqlite3_result_text(ctx, pStr->zBuf, (int)pStr->nUsed, SQLITE_TRANSIENT);
-      pStr->nUsed--;
+      jsonStringTrimOneChar(pStr);
     }
   }else{
     sqlite3_result_text(ctx, "{}", 2, SQLITE_STATIC);
@@ -208032,6 +211262,9 @@ static int jsonEachColumn(
     case JEACH_VALUE: {
       u32 i = jsonSkipLabel(p);
       jsonReturnFromBlob(&p->sParse, i, ctx, 1);
+      if( (p->sParse.aBlob[i] & 0x0f)>=JSONB_ARRAY ){
+        sqlite3_result_subtype(ctx, JSON_SUBTYPE);
+      }
       break;
     }
     case JEACH_TYPE: {
@@ -208078,9 +211311,9 @@ static int jsonEachColumn(
     case JEACH_JSON: {
       if( p->sParse.zJson==0 ){
         sqlite3_result_blob(ctx, p->sParse.aBlob, p->sParse.nBlob,
-                            SQLITE_STATIC);
+                            SQLITE_TRANSIENT);
       }else{
-        sqlite3_result_text(ctx, p->sParse.zJson, -1, SQLITE_STATIC);
+        sqlite3_result_text(ctx, p->sParse.zJson, -1, SQLITE_TRANSIENT);
       }
       break;
     }
@@ -208182,13 +211415,9 @@ static int jsonEachFilter(
   memset(&p->sParse, 0, sizeof(p->sParse));
   p->sParse.nJPRef = 1;
   p->sParse.db = p->db;
-  if( sqlite3_value_type(argv[0])==SQLITE_BLOB ){
-    if( jsonFuncArgMightBeBinary(argv[0]) ){
-      p->sParse.nBlob = sqlite3_value_bytes(argv[0]);
-      p->sParse.aBlob = (u8*)sqlite3_value_blob(argv[0]);
-    }else{
-      goto json_each_malformed_input;
-    }
+  if( jsonFuncArgMightBeBinary(argv[0]) ){
+    p->sParse.nBlob = sqlite3_value_bytes(argv[0]);
+    p->sParse.aBlob = (u8*)sqlite3_value_blob(argv[0]);
   }else{
     p->sParse.zJson = (char*)sqlite3_value_text(argv[0]);
     p->sParse.nJson = sqlite3_value_bytes(argv[0]);
@@ -208358,6 +211587,8 @@ SQLITE_PRIVATE void sqlite3RegisterJsonFunctions(void){
     JFUNCTION(jsonb_object,      -1,0,1, 1,1,0,          jsonObjectFunc),
     JFUNCTION(json_patch,         2,1,1, 0,0,0,          jsonPatchFunc),
     JFUNCTION(jsonb_patch,        2,1,0, 0,1,0,          jsonPatchFunc),
+    JFUNCTION(json_pretty,        1,1,0, 0,0,0,          jsonPrettyFunc),
+    JFUNCTION(json_pretty,        2,1,0, 0,0,0,          jsonPrettyFunc),
     JFUNCTION(json_quote,         1,0,1, 1,0,0,          jsonQuoteFunc),
     JFUNCTION(json_remove,       -1,1,1, 0,0,0,          jsonRemoveFunc),
     JFUNCTION(jsonb_remove,      -1,1,0, 0,1,0,          jsonRemoveFunc),
@@ -209110,11 +212341,9 @@ static RtreeNode *nodeNew(Rtree *pRtree, RtreeNode *pParent){
 ** Clear the Rtree.pNodeBlob object
 */
 static void nodeBlobReset(Rtree *pRtree){
-  if( pRtree->pNodeBlob && pRtree->inWrTrans==0 && pRtree->nCursor==0 ){
-    sqlite3_blob *pBlob = pRtree->pNodeBlob;
-    pRtree->pNodeBlob = 0;
-    sqlite3_blob_close(pBlob);
-  }
+  sqlite3_blob *pBlob = pRtree->pNodeBlob;
+  pRtree->pNodeBlob = 0;
+  sqlite3_blob_close(pBlob);
 }
 
 /*
@@ -209158,7 +212387,6 @@ static int nodeAcquire(
                            &pRtree->pNodeBlob);
   }
   if( rc ){
-    nodeBlobReset(pRtree);
     *ppNode = 0;
     /* If unable to open an sqlite3_blob on the desired row, that can only
     ** be because the shadow tables hold erroneous data. */
@@ -209218,6 +212446,7 @@ static int nodeAcquire(
     }
     *ppNode = pNode;
   }else{
+    nodeBlobReset(pRtree);
     if( pNode ){
       pRtree->nNodeRef--;
       sqlite3_free(pNode);
@@ -209362,6 +212591,7 @@ static void nodeGetCoord(
   int iCoord,                  /* Which coordinate to extract */
   RtreeCoord *pCoord           /* OUT: Space to write result to */
 ){
+  assert( iCell<NCELL(pNode) );
   readCoord(&pNode->zData[12 + pRtree->nBytesPerCell*iCell + 4*iCoord], pCoord);
 }
 
@@ -209551,7 +212781,9 @@ static int rtreeClose(sqlite3_vtab_cursor *cur){
   sqlite3_finalize(pCsr->pReadAux);
   sqlite3_free(pCsr);
   pRtree->nCursor--;
-  nodeBlobReset(pRtree);
+  if( pRtree->nCursor==0 && pRtree->inWrTrans==0 ){
+    nodeBlobReset(pRtree);
+  }
   return SQLITE_OK;
 }
 
@@ -210136,7 +213368,11 @@ static int rtreeRowid(sqlite3_vtab_cursor *pVtabCursor, sqlite_int64 *pRowid){
   int rc = SQLITE_OK;
   RtreeNode *pNode = rtreeNodeOfFirstSearchPoint(pCsr, &rc);
   if( rc==SQLITE_OK && ALWAYS(p) ){
-    *pRowid = nodeGetRowid(RTREE_OF_CURSOR(pCsr), pNode, p->iCell);
+    if( p->iCell>=NCELL(pNode) ){
+      rc = SQLITE_ABORT;
+    }else{
+      *pRowid = nodeGetRowid(RTREE_OF_CURSOR(pCsr), pNode, p->iCell);
+    }
   }
   return rc;
 }
@@ -210154,6 +213390,7 @@ static int rtreeColumn(sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i){
 
   if( rc ) return rc;
   if( NEVER(p==0) ) return SQLITE_OK;
+  if( p->iCell>=NCELL(pNode) ) return SQLITE_ABORT;
   if( i==0 ){
     sqlite3_result_int64(ctx, nodeGetRowid(pRtree, pNode, p->iCell));
   }else if( i<=pRtree->nDim2 ){
@@ -210251,6 +213488,8 @@ static int deserializeGeometry(sqlite3_value *pValue, RtreeConstraint *pCons){
   return SQLITE_OK;
 }
 
+SQLITE_PRIVATE int sqlite3IntFloatCompare(i64,double);
+
 /*
 ** Rtree virtual table module xFilter method.
 */
@@ -210280,7 +213519,8 @@ static int rtreeFilter(
     i64 iNode = 0;
     int eType = sqlite3_value_numeric_type(argv[0]);
     if( eType==SQLITE_INTEGER
-     || (eType==SQLITE_FLOAT && sqlite3_value_double(argv[0])==iRowid)
+     || (eType==SQLITE_FLOAT
+         && 0==sqlite3IntFloatCompare(iRowid,sqlite3_value_double(argv[0])))
     ){
       rc = findLeafNode(pRtree, iRowid, &pLeaf, &iNode);
     }else{
@@ -211636,7 +214876,7 @@ constraint:
 static int rtreeBeginTransaction(sqlite3_vtab *pVtab){
   Rtree *pRtree = (Rtree *)pVtab;
   assert( pRtree->inWrTrans==0 );
-  pRtree->inWrTrans++;
+  pRtree->inWrTrans = 1;
   return SQLITE_OK;
 }
 
@@ -211650,6 +214890,9 @@ static int rtreeEndTransaction(sqlite3_vtab *pVtab){
   nodeBlobReset(pRtree);
   return SQLITE_OK;
 }
+static int rtreeRollback(sqlite3_vtab *pVtab){
+  return rtreeEndTransaction(pVtab);
+}
 
 /*
 ** The xRename method for rtree module virtual tables.
@@ -211768,7 +215011,7 @@ static sqlite3_module rtreeModule = {
   rtreeBeginTransaction,      /* xBegin - begin transaction */
   rtreeEndTransaction,        /* xSync - sync transaction */
   rtreeEndTransaction,        /* xCommit - commit transaction */
-  rtreeEndTransaction,        /* xRollback - rollback transaction */
+  rtreeRollback,              /* xRollback - rollback transaction */
   0,                          /* xFindFunction - function overloading */
   rtreeRename,                /* xRename - rename the table */
   rtreeSavepoint,             /* xSavepoint */
@@ -215187,7 +218430,7 @@ static void icuLoadCollation(
   UCollator *pUCollator;    /* ICU library collation object */
   int rc;                   /* Return code from sqlite3_create_collation_x() */
 
-  assert(nArg==2);
+  assert(nArg==2 || nArg==3);
   (void)nArg; /* Unused parameter */
   zLocale = (const char *)sqlite3_value_text(apArg[0]);
   zName = (const char *)sqlite3_value_text(apArg[1]);
@@ -215202,7 +218445,39 @@ static void icuLoadCollation(
     return;
   }
   assert(p);
-
+  if(nArg==3){
+    const char *zOption = (const char*)sqlite3_value_text(apArg[2]);
+    static const struct {
+       const char *zName;
+       UColAttributeValue val;
+    } aStrength[] = {
+      {  "PRIMARY",      UCOL_PRIMARY           },
+      {  "SECONDARY",    UCOL_SECONDARY         },
+      {  "TERTIARY",     UCOL_TERTIARY          },
+      {  "DEFAULT",      UCOL_DEFAULT_STRENGTH  },
+      {  "QUARTERNARY",  UCOL_QUATERNARY        },
+      {  "IDENTICAL",    UCOL_IDENTICAL         },
+    };
+    unsigned int i;
+    for(i=0; i<sizeof(aStrength)/sizeof(aStrength[0]); i++){
+      if( sqlite3_stricmp(zOption,aStrength[i].zName)==0 ){
+        ucol_setStrength(pUCollator, aStrength[i].val);
+        break;
+      }
+    }
+    if( i>=sizeof(aStrength)/sizeof(aStrength[0]) ){
+      sqlite3_str *pStr = sqlite3_str_new(sqlite3_context_db_handle(p));
+      sqlite3_str_appendf(pStr,
+         "unknown collation strength \"%s\" - should be one of:",
+         zOption);
+      for(i=0; i<sizeof(aStrength)/sizeof(aStrength[0]); i++){
+         sqlite3_str_appendf(pStr, " %s", aStrength[i].zName);
+      }
+      sqlite3_result_error(p, sqlite3_str_value(pStr), -1);
+      sqlite3_free(sqlite3_str_finish(pStr));
+      return;
+    }
+  }
   rc = sqlite3_create_collation_v2(db, zName, SQLITE_UTF16, (void *)pUCollator,
       icuCollationColl, icuCollationDel
   );
@@ -215225,6 +218500,7 @@ SQLITE_PRIVATE int sqlite3IcuInit(sqlite3 *db){
     void (*xFunc)(sqlite3_context*,int,sqlite3_value**);
   } scalars[] = {
     {"icu_load_collation",2,SQLITE_UTF8|SQLITE_DIRECTONLY,1, icuLoadCollation},
+    {"icu_load_collation",3,SQLITE_UTF8|SQLITE_DIRECTONLY,1, icuLoadCollation},
 #if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_ICU)
     {"regexp", 2, SQLITE_ANY|SQLITEICU_EXTRAFLAGS,         0, icuRegexpFunc},
     {"lower",  1, SQLITE_UTF16|SQLITEICU_EXTRAFLAGS,       0, icuCaseFunc16},
@@ -216375,6 +219651,7 @@ typedef unsigned int u32;
 typedef unsigned short u16;
 typedef unsigned char u8;
 typedef sqlite3_int64 i64;
+typedef sqlite3_uint64 u64;
 #endif
 
 /*
@@ -216511,6 +219788,27 @@ struct RbuFrame {
   u32 iWalFrame;
 };
 
+#ifndef UNUSED_PARAMETER
+/*
+** The following macros are used to suppress compiler warnings and to
+** make it clear to human readers when a function parameter is deliberately
+** left unused within the body of a function. This usually happens when
+** a function is called via a function pointer. For example the
+** implementation of an SQL aggregate step callback may not use the
+** parameter indicating the number of arguments passed to the aggregate,
+** if it knows that this is enforced elsewhere.
+**
+** When a function parameter is not used at all within the body of a function,
+** it is generally named "NotUsed" or "NotUsed2" to make things even clearer.
+** However, these macros may also be used to suppress warnings related to
+** parameters that may or may not be used depending on compilation options.
+** For example those parameters only used in assert() statements. In these
+** cases the parameters are named as per the usual conventions.
+*/
+#define UNUSED_PARAMETER(x) (void)(x)
+#define UNUSED_PARAMETER2(x,y) UNUSED_PARAMETER(x),UNUSED_PARAMETER(y)
+#endif
+
 /*
 ** RBU handle.
 **
@@ -216562,7 +219860,7 @@ struct sqlite3rbu {
   int rc;                         /* Value returned by last rbu_step() call */
   char *zErrmsg;                  /* Error message if rc!=SQLITE_OK */
   int nStep;                      /* Rows processed for current object */
-  int nProgress;                  /* Rows processed for all objects */
+  sqlite3_int64 nProgress;        /* Rows processed for all objects */
   RbuObjIter objiter;             /* Iterator for skipping through tbl/idx */
   const char *zVfsName;           /* Name of automatically created rbu vfs */
   rbu_file *pTargetFd;            /* File handle open on target db */
@@ -216679,7 +219977,7 @@ static unsigned int rbuDeltaGetInt(const char **pz, int *pLen){
      v = (v<<6) + c;
   }
   z--;
-  *pLen -= z - zStart;
+  *pLen -= (int)(z - zStart);
   *pz = (char*)z;
   return v;
 }
@@ -216864,6 +220162,7 @@ static void rbuFossilDeltaFunc(
   char *aOut;
 
   assert( argc==2 );
+  UNUSED_PARAMETER(argc);
 
   nOrig = sqlite3_value_bytes(argv[0]);
   aOrig = (const char*)sqlite3_value_blob(argv[0]);
@@ -217061,6 +220360,7 @@ static int rbuObjIterNext(sqlite3rbu *p, RbuObjIter *pIter){
         if( rc!=SQLITE_ROW ){
           rc = resetAndCollectError(pIter->pTblIter, &p->zErrmsg);
           pIter->zTbl = 0;
+          pIter->zDataTbl = 0;
         }else{
           pIter->zTbl = (const char*)sqlite3_column_text(pIter->pTblIter, 0);
           pIter->zDataTbl = (const char*)sqlite3_column_text(pIter->pTblIter,1);
@@ -218442,13 +221742,13 @@ static char *rbuObjIterGetIndexWhere(sqlite3rbu *p, RbuObjIter *pIter){
           else if( c==')' ){
             nParen--;
             if( nParen==0 ){
-              int nSpan = &zSql[i] - pIter->aIdxCol[iIdxCol].zSpan;
+              int nSpan = (int)(&zSql[i] - pIter->aIdxCol[iIdxCol].zSpan);
               pIter->aIdxCol[iIdxCol++].nSpan = nSpan;
               i++;
               break;
             }
           }else if( c==',' && nParen==1 ){
-            int nSpan = &zSql[i] - pIter->aIdxCol[iIdxCol].zSpan;
+            int nSpan = (int)(&zSql[i] - pIter->aIdxCol[iIdxCol].zSpan);
             pIter->aIdxCol[iIdxCol++].nSpan = nSpan;
             pIter->aIdxCol[iIdxCol].zSpan = &zSql[i+1];
           }else if( c=='"' || c=='\'' || c=='`' ){
@@ -219138,6 +222438,8 @@ static void rbuFileSuffix3(const char *zBase, char *z){
     for(i=sz-1; i>0 && z[i]!='/' && z[i]!='.'; i--){}
     if( z[i]=='.' && sz>i+4 ) memmove(&z[i+1], &z[sz-3], 4);
   }
+#else
+  UNUSED_PARAMETER2(zBase,z);
 #endif
 }
 
@@ -219155,7 +222457,7 @@ static i64 rbuShmChecksum(sqlite3rbu *p){
     u32 volatile *ptr;
     p->rc = pDb->pMethods->xShmMap(pDb, 0, 32*1024, 0, (void volatile**)&ptr);
     if( p->rc==SQLITE_OK ){
-      iRet = ((i64)ptr[10] << 32) + ptr[11];
+      iRet = (i64)(((u64)ptr[10] << 32) + ptr[11]);
     }
   }
   return iRet;
@@ -219722,7 +223024,7 @@ static void rbuSaveState(sqlite3rbu *p, int eStage){
           "(%d, %Q), "
           "(%d, %Q), "
           "(%d, %d), "
-          "(%d, %d), "
+          "(%d, %lld), "
           "(%d, %lld), "
           "(%d, %lld), "
           "(%d, %lld), "
@@ -220080,6 +223382,7 @@ static void rbuIndexCntFunc(
   sqlite3 *db = (rbuIsVacuum(p) ? p->dbRbu : p->dbMain);
 
   assert( nVal==1 );
+  UNUSED_PARAMETER(nVal);
 
   rc = prepareFreeAndCollectError(db, &pStmt, &zErrmsg,
       sqlite3_mprintf("SELECT count(*) FROM sqlite_schema "
@@ -220355,7 +223658,7 @@ SQLITE_API sqlite3rbu *sqlite3rbu_vacuum(
 ){
   if( zTarget==0 ){ return rbuMisuseError(); }
   if( zState ){
-    int n = strlen(zState);
+    size_t n = strlen(zState);
     if( n>=7 && 0==memcmp("-vactmp", &zState[n-7], 7) ){
       return rbuMisuseError();
     }
@@ -220572,6 +223875,7 @@ SQLITE_API int sqlite3rbu_savestate(sqlite3rbu *p){
 */
 static int xDefaultRename(void *pArg, const char *zOld, const char *zNew){
   int rc = SQLITE_OK;
+  UNUSED_PARAMETER(pArg);
 #if defined(_WIN32_WCE)
   {
     LPWSTR zWideOld;
@@ -221476,6 +224780,9 @@ static int rbuVfsCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){
 ** No-op.
 */
 static int rbuVfsGetLastError(sqlite3_vfs *pVfs, int a, char *b){
+  UNUSED_PARAMETER(pVfs);
+  UNUSED_PARAMETER(a);
+  UNUSED_PARAMETER(b);
   return 0;
 }
 
@@ -221874,6 +225181,7 @@ static int statBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
     pIdxInfo->orderByConsumed = 1;
     pIdxInfo->idxNum |= 0x08;
   }
+  pIdxInfo->idxFlags |= SQLITE_INDEX_SCAN_HEX;
 
   return SQLITE_OK;
 }
@@ -222531,7 +225839,13 @@ SQLITE_PRIVATE int sqlite3DbstatRegister(sqlite3 *db){ return SQLITE_OK; }
 **
 ** The data field of sqlite_dbpage table can be updated.  The new
 ** value must be a BLOB which is the correct page size, otherwise the
-** update fails.  Rows may not be deleted or inserted.
+** update fails.  INSERT operations also work, and operate as if they
+** where REPLACE.  The size of the database can be extended by INSERT-ing
+** new pages on the end.
+**
+** Rows may not be deleted.  However, doing an INSERT to page number N
+** with NULL page data causes the N-th page and all subsequent pages to be
+** deleted and the database to be truncated.
 */
 
 /* #include "sqliteInt.h"   ** Requires access to internal data structures ** */
@@ -222554,6 +225868,8 @@ struct DbpageCursor {
 struct DbpageTable {
   sqlite3_vtab base;              /* Base class.  Must be first */
   sqlite3 *db;                    /* The database */
+  int iDbTrunc;                   /* Database to truncate */
+  Pgno pgnoTrunc;                 /* Size to truncate to */
 };
 
 /* Columns */
@@ -222562,7 +225878,6 @@ struct DbpageTable {
 #define DBPAGE_COLUMN_SCHEMA  2
 
 
-
 /*
 ** Connect to or create a dbpagevfs virtual table.
 */
@@ -222824,11 +226139,11 @@ static int dbpageUpdate(
   DbPage *pDbPage = 0;
   int rc = SQLITE_OK;
   char *zErr = 0;
-  const char *zSchema;
   int iDb;
   Btree *pBt;
   Pager *pPager;
   int szPage;
+  int isInsert;
 
   (void)pRowid;
   if( pTab->db->flags & SQLITE_Defensive ){
@@ -222839,21 +226154,29 @@ static int dbpageUpdate(
     zErr = "cannot delete";
     goto update_fail;
   }
-  pgno = sqlite3_value_int(argv[0]);
-  if( sqlite3_value_type(argv[0])==SQLITE_NULL
-   || (Pgno)sqlite3_value_int(argv[1])!=pgno
-  ){
-    zErr = "cannot insert";
-    goto update_fail;
+  if( sqlite3_value_type(argv[0])==SQLITE_NULL ){
+    pgno = (Pgno)sqlite3_value_int(argv[2]);
+    isInsert = 1;
+  }else{
+    pgno = sqlite3_value_int(argv[0]);
+    if( (Pgno)sqlite3_value_int(argv[1])!=pgno ){
+      zErr = "cannot insert";
+      goto update_fail;
+    }
+    isInsert = 0;
   }
-  zSchema = (const char*)sqlite3_value_text(argv[4]);
-  iDb = ALWAYS(zSchema) ? sqlite3FindDbName(pTab->db, zSchema) : -1;
-  if( NEVER(iDb<0) ){
-    zErr = "no such schema";
-    goto update_fail;
+  if( sqlite3_value_type(argv[4])==SQLITE_NULL ){
+    iDb = 0;
+  }else{
+    const char *zSchema = (const char*)sqlite3_value_text(argv[4]);
+    iDb = sqlite3FindDbName(pTab->db, zSchema);
+    if( iDb<0 ){
+      zErr = "no such schema";
+      goto update_fail;
+    }
   }
   pBt = pTab->db->aDb[iDb].pBt;
-  if( NEVER(pgno<1) || NEVER(pBt==0) || NEVER(pgno>sqlite3BtreeLastPage(pBt)) ){
+  if( pgno<1 || NEVER(pBt==0) ){
     zErr = "bad page number";
     goto update_fail;
   }
@@ -222861,18 +226184,25 @@ static int dbpageUpdate(
   if( sqlite3_value_type(argv[3])!=SQLITE_BLOB
    || sqlite3_value_bytes(argv[3])!=szPage
   ){
-    zErr = "bad page value";
-    goto update_fail;
+    if( sqlite3_value_type(argv[3])==SQLITE_NULL && isInsert && pgno>1 ){
+      /* "INSERT INTO dbpage($PGNO,NULL)" causes page number $PGNO and
+      ** all subsequent pages to be deleted. */
+      pTab->iDbTrunc = iDb;
+      pgno--;
+      pTab->pgnoTrunc = pgno;
+    }else{
+      zErr = "bad page value";
+      goto update_fail;
+    }
   }
   pPager = sqlite3BtreePager(pBt);
   rc = sqlite3PagerGet(pPager, pgno, (DbPage**)&pDbPage, 0);
   if( rc==SQLITE_OK ){
     const void *pData = sqlite3_value_blob(argv[3]);
-    assert( pData!=0 || pTab->db->mallocFailed );
-    if( pData
-     && (rc = sqlite3PagerWrite(pDbPage))==SQLITE_OK
-    ){
-      memcpy(sqlite3PagerGetData(pDbPage), pData, szPage);
+    if( (rc = sqlite3PagerWrite(pDbPage))==SQLITE_OK && pData ){
+      unsigned char *aPage = sqlite3PagerGetData(pDbPage);
+      memcpy(aPage, pData, szPage);
+      pTab->pgnoTrunc = 0;
     }
   }
   sqlite3PagerUnref(pDbPage);
@@ -222896,9 +226226,31 @@ static int dbpageBegin(sqlite3_vtab *pVtab){
     Btree *pBt = db->aDb[i].pBt;
     if( pBt ) (void)sqlite3BtreeBeginTrans(pBt, 1, 0);
   }
+  pTab->pgnoTrunc = 0;
   return SQLITE_OK;
 }
 
+/* Invoke sqlite3PagerTruncate() as necessary, just prior to COMMIT
+*/
+static int dbpageSync(sqlite3_vtab *pVtab){
+  DbpageTable *pTab = (DbpageTable *)pVtab;
+  if( pTab->pgnoTrunc>0 ){
+    Btree *pBt = pTab->db->aDb[pTab->iDbTrunc].pBt;
+    Pager *pPager = sqlite3BtreePager(pBt);
+    sqlite3PagerTruncateImage(pPager, pTab->pgnoTrunc);
+  }
+  pTab->pgnoTrunc = 0;
+  return SQLITE_OK;
+}
+
+/* Cancel any pending truncate.
+*/
+static int dbpageRollbackTo(sqlite3_vtab *pVtab, int notUsed1){
+  DbpageTable *pTab = (DbpageTable *)pVtab;
+  pTab->pgnoTrunc = 0;
+  (void)notUsed1;
+  return SQLITE_OK;
+}
 
 /*
 ** Invoke this routine to register the "dbpage" virtual table module
@@ -222920,14 +226272,14 @@ SQLITE_PRIVATE int sqlite3DbpageRegister(sqlite3 *db){
     dbpageRowid,                  /* xRowid - read data */
     dbpageUpdate,                 /* xUpdate */
     dbpageBegin,                  /* xBegin */
-    0,                            /* xSync */
+    dbpageSync,                   /* xSync */
     0,                            /* xCommit */
     0,                            /* xRollback */
     0,                            /* xFindMethod */
     0,                            /* xRename */
     0,                            /* xSavepoint */
     0,                            /* xRelease */
-    0,                            /* xRollbackTo */
+    dbpageRollbackTo,             /* xRollbackTo */
     0,                            /* xShadowName */
     0                             /* xIntegrity */
   };
@@ -223015,6 +226367,10 @@ struct SessionBuffer {
 ** input data. Input data may be supplied either as a single large buffer
 ** (e.g. sqlite3changeset_start()) or using a stream function (e.g.
 **  sqlite3changeset_start_strm()).
+**
+** bNoDiscard:
+**   If true, then the only time data is discarded is as a result of explicit
+**   sessionDiscardData() calls. Not within every sessionInputBuffer() call.
 */
 struct SessionInput {
   int bNoDiscard;                 /* If true, do not discard in InputBuffer() */
@@ -224698,16 +228054,19 @@ static void sessionPreupdateOneChange(
       for(i=0; i<(pTab->nCol-pTab->bRowid); i++){
         sqlite3_value *p = 0;
         if( op!=SQLITE_INSERT ){
-          TESTONLY(int trc = ) pSession->hook.xOld(pSession->hook.pCtx, i, &p);
-          assert( trc==SQLITE_OK );
+          /* This may fail if the column has a non-NULL default and was added
+          ** using ALTER TABLE ADD COLUMN after this record was created. */
+          rc = pSession->hook.xOld(pSession->hook.pCtx, i, &p);
         }else if( pTab->abPK[i] ){
           TESTONLY(int trc = ) pSession->hook.xNew(pSession->hook.pCtx, i, &p);
           assert( trc==SQLITE_OK );
         }
 
-        /* This may fail if SQLite value p contains a utf-16 string that must
-        ** be converted to utf-8 and an OOM error occurs while doing so. */
-        rc = sessionSerializeValue(0, p, &nByte);
+        if( rc==SQLITE_OK ){
+          /* This may fail if SQLite value p contains a utf-16 string that must
+          ** be converted to utf-8 and an OOM error occurs while doing so. */
+          rc = sessionSerializeValue(0, p, &nByte);
+        }
         if( rc!=SQLITE_OK ) goto error_out;
       }
       if( pTab->bRowid ){
@@ -226626,14 +229985,14 @@ static int sessionChangesetNextOne(
   p->rc = sessionInputBuffer(&p->in, 2);
   if( p->rc!=SQLITE_OK ) return p->rc;
 
+  sessionDiscardData(&p->in);
+  p->in.iCurrent = p->in.iNext;
+
   /* If the iterator is already at the end of the changeset, return DONE. */
   if( p->in.iNext>=p->in.nData ){
     return SQLITE_DONE;
   }
 
-  sessionDiscardData(&p->in);
-  p->in.iCurrent = p->in.iNext;
-
   op = p->in.aData[p->in.iNext++];
   while( op=='T' || op=='P' ){
     if( pbNew ) *pbNew = 1;
@@ -228065,15 +231424,21 @@ static int sessionChangesetApply(
   int nTab = 0;                   /* Result of sqlite3Strlen30(zTab) */
   SessionApplyCtx sApply;         /* changeset_apply() context object */
   int bPatchset;
+  u64 savedFlag = db->flags & SQLITE_FkNoAction;
 
   assert( xConflict!=0 );
 
+  sqlite3_mutex_enter(sqlite3_db_mutex(db));
+  if( flags & SQLITE_CHANGESETAPPLY_FKNOACTION ){
+    db->flags |= ((u64)SQLITE_FkNoAction);
+    db->aDb[0].pSchema->schema_cookie -= 32;
+  }
+
   pIter->in.bNoDiscard = 1;
   memset(&sApply, 0, sizeof(sApply));
   sApply.bRebase = (ppRebase && pnRebase);
   sApply.bInvertConstraints = !!(flags & SQLITE_CHANGESETAPPLY_INVERT);
   sApply.bIgnoreNoop = !!(flags & SQLITE_CHANGESETAPPLY_IGNORENOOP);
-  sqlite3_mutex_enter(sqlite3_db_mutex(db));
   if( (flags & SQLITE_CHANGESETAPPLY_NOSAVEPOINT)==0 ){
     rc = sqlite3_exec(db, "SAVEPOINT changeset_apply", 0, 0, 0);
   }
@@ -228235,6 +231600,12 @@ static int sessionChangesetApply(
   sqlite3_free((char*)sApply.azCol);  /* cast works around VC++ bug */
   sqlite3_free((char*)sApply.constraints.aBuf);
   sqlite3_free((char*)sApply.rebase.aBuf);
+
+  if( (flags & SQLITE_CHANGESETAPPLY_FKNOACTION) && savedFlag==0 ){
+    assert( db->flags & SQLITE_FkNoAction );
+    db->flags &= ~((u64)SQLITE_FkNoAction);
+    db->aDb[0].pSchema->schema_cookie -= 32;
+  }
   sqlite3_mutex_leave(sqlite3_db_mutex(db));
   return rc;
 }
@@ -228263,12 +231634,6 @@ SQLITE_API int sqlite3changeset_apply_v2(
   sqlite3_changeset_iter *pIter;  /* Iterator to skip through changeset */
   int bInv = !!(flags & SQLITE_CHANGESETAPPLY_INVERT);
   int rc = sessionChangesetStart(&pIter, 0, 0, nChangeset, pChangeset, bInv, 1);
-  u64 savedFlag = db->flags & SQLITE_FkNoAction;
-
-  if( flags & SQLITE_CHANGESETAPPLY_FKNOACTION ){
-    db->flags |= ((u64)SQLITE_FkNoAction);
-    db->aDb[0].pSchema->schema_cookie -= 32;
-  }
 
   if( rc==SQLITE_OK ){
     rc = sessionChangesetApply(
@@ -228276,11 +231641,6 @@ SQLITE_API int sqlite3changeset_apply_v2(
     );
   }
 
-  if( (flags & SQLITE_CHANGESETAPPLY_FKNOACTION) && savedFlag==0 ){
-    assert( db->flags & SQLITE_FkNoAction );
-    db->flags &= ~((u64)SQLITE_FkNoAction);
-    db->aDb[0].pSchema->schema_cookie -= 32;
-  }
   return rc;
 }
 
@@ -228368,6 +231728,7 @@ struct sqlite3_changegroup {
   int rc;                         /* Error code */
   int bPatch;                     /* True to accumulate patchsets */
   SessionTable *pList;            /* List of tables in current patch */
+  SessionBuffer rec;
 
   sqlite3 *db;                    /* Configured by changegroup_schema() */
   char *zDb;                      /* Configured by changegroup_schema() */
@@ -228600,6 +231961,9 @@ static int sessionChangesetExtendRecord(
     sessionAppendBlob(pOut, aRec, nRec, &rc);
     if( rc==SQLITE_OK && pTab->pDfltStmt==0 ){
       rc = sessionPrepareDfltStmt(pGrp->db, pTab, &pTab->pDfltStmt);
+      if( rc==SQLITE_OK && SQLITE_ROW!=sqlite3_step(pTab->pDfltStmt) ){
+        rc = sqlite3_errcode(pGrp->db);
+      }
     }
     for(ii=nCol; rc==SQLITE_OK && ii<pTab->nCol; ii++){
       int eType = sqlite3_column_type(pTab->pDfltStmt, ii);
@@ -228616,6 +231980,7 @@ static int sessionChangesetExtendRecord(
           }
           if( SQLITE_OK==sessionBufferGrow(pOut, 8, &rc) ){
             sessionPutI64(&pOut->aBuf[pOut->nBuf], iVal);
+            pOut->nBuf += 8;
           }
           break;
         }
@@ -228666,108 +232031,130 @@ static int sessionChangesetExtendRecord(
 }
 
 /*
-** Add all changes in the changeset traversed by the iterator passed as
-** the first argument to the changegroup hash tables.
+** Locate or create a SessionTable object that may be used to add the
+** change currently pointed to by iterator pIter to changegroup pGrp.
+** If successful, set output variable (*ppTab) to point to the table
+** object and return SQLITE_OK. Otherwise, if some error occurs, return
+** an SQLite error code and leave (*ppTab) set to NULL.
 */
-static int sessionChangesetToHash(
-  sqlite3_changeset_iter *pIter,   /* Iterator to read from */
-  sqlite3_changegroup *pGrp,       /* Changegroup object to add changeset to */
-  int bRebase                      /* True if hash table is for rebasing */
+static int sessionChangesetFindTable(
+  sqlite3_changegroup *pGrp,
+  const char *zTab,
+  sqlite3_changeset_iter *pIter,
+  SessionTable **ppTab
 ){
-  u8 *aRec;
-  int nRec;
   int rc = SQLITE_OK;
   SessionTable *pTab = 0;
-  SessionBuffer rec = {0, 0, 0};
+  int nTab = (int)strlen(zTab);
+  u8 *abPK = 0;
+  int nCol = 0;
 
-  while( SQLITE_ROW==sessionChangesetNext(pIter, &aRec, &nRec, 0) ){
-    const char *zNew;
-    int nCol;
-    int op;
-    int iHash;
-    int bIndirect;
-    SessionChange *pChange;
-    SessionChange *pExist = 0;
-    SessionChange **pp;
+  *ppTab = 0;
+  sqlite3changeset_pk(pIter, &abPK, &nCol);
 
-    /* Ensure that only changesets, or only patchsets, but not a mixture
-    ** of both, are being combined. It is an error to try to combine a
-    ** changeset and a patchset.  */
-    if( pGrp->pList==0 ){
-      pGrp->bPatch = pIter->bPatchset;
-    }else if( pIter->bPatchset!=pGrp->bPatch ){
-      rc = SQLITE_ERROR;
-      break;
+  /* Search the list for an existing table */
+  for(pTab = pGrp->pList; pTab; pTab=pTab->pNext){
+    if( 0==sqlite3_strnicmp(pTab->zName, zTab, nTab+1) ) break;
+  }
+
+  /* If one was not found above, create a new table now */
+  if( !pTab ){
+    SessionTable **ppNew;
+
+    pTab = sqlite3_malloc64(sizeof(SessionTable) + nCol + nTab+1);
+    if( !pTab ){
+      return SQLITE_NOMEM;
     }
+    memset(pTab, 0, sizeof(SessionTable));
+    pTab->nCol = nCol;
+    pTab->abPK = (u8*)&pTab[1];
+    memcpy(pTab->abPK, abPK, nCol);
+    pTab->zName = (char*)&pTab->abPK[nCol];
+    memcpy(pTab->zName, zTab, nTab+1);
 
-    sqlite3changeset_op(pIter, &zNew, &nCol, &op, &bIndirect);
-    if( !pTab || sqlite3_stricmp(zNew, pTab->zName) ){
-      /* Search the list for a matching table */
-      int nNew = (int)strlen(zNew);
-      u8 *abPK;
-
-      sqlite3changeset_pk(pIter, &abPK, 0);
-      for(pTab = pGrp->pList; pTab; pTab=pTab->pNext){
-        if( 0==sqlite3_strnicmp(pTab->zName, zNew, nNew+1) ) break;
-      }
-      if( !pTab ){
-        SessionTable **ppTab;
-
-        pTab = sqlite3_malloc64(sizeof(SessionTable) + nCol + nNew+1);
-        if( !pTab ){
-          rc = SQLITE_NOMEM;
-          break;
-        }
-        memset(pTab, 0, sizeof(SessionTable));
-        pTab->nCol = nCol;
-        pTab->abPK = (u8*)&pTab[1];
-        memcpy(pTab->abPK, abPK, nCol);
-        pTab->zName = (char*)&pTab->abPK[nCol];
-        memcpy(pTab->zName, zNew, nNew+1);
-
-        if( pGrp->db ){
-          pTab->nCol = 0;
-          rc = sessionInitTable(0, pTab, pGrp->db, pGrp->zDb);
-          if( rc ){
-            assert( pTab->azCol==0 );
-            sqlite3_free(pTab);
-            break;
-          }
-        }
-
-        /* The new object must be linked on to the end of the list, not
-        ** simply added to the start of it. This is to ensure that the
-        ** tables within the output of sqlite3changegroup_output() are in
-        ** the right order.  */
-        for(ppTab=&pGrp->pList; *ppTab; ppTab=&(*ppTab)->pNext);
-        *ppTab = pTab;
-      }
-
-      if( !sessionChangesetCheckCompat(pTab, nCol, abPK) ){
-        rc = SQLITE_SCHEMA;
-        break;
+    if( pGrp->db ){
+      pTab->nCol = 0;
+      rc = sessionInitTable(0, pTab, pGrp->db, pGrp->zDb);
+      if( rc ){
+        assert( pTab->azCol==0 );
+        sqlite3_free(pTab);
+        return rc;
       }
     }
 
-    if( nCol<pTab->nCol ){
-      assert( pGrp->db );
-      rc = sessionChangesetExtendRecord(pGrp, pTab, nCol, op, aRec, nRec, &rec);
-      if( rc ) break;
-      aRec = rec.aBuf;
-      nRec = rec.nBuf;
-    }
+    /* The new object must be linked on to the end of the list, not
+    ** simply added to the start of it. This is to ensure that the
+    ** tables within the output of sqlite3changegroup_output() are in
+    ** the right order.  */
+    for(ppNew=&pGrp->pList; *ppNew; ppNew=&(*ppNew)->pNext);
+    *ppNew = pTab;
+  }
 
-    if( sessionGrowHash(0, pIter->bPatchset, pTab) ){
-      rc = SQLITE_NOMEM;
-      break;
-    }
+  /* Check that the table is compatible. */
+  if( !sessionChangesetCheckCompat(pTab, nCol, abPK) ){
+    rc = SQLITE_SCHEMA;
+  }
+
+  *ppTab = pTab;
+  return rc;
+}
+
+/*
+** Add the change currently indicated by iterator pIter to the hash table
+** belonging to changegroup pGrp.
+*/
+static int sessionOneChangeToHash(
+  sqlite3_changegroup *pGrp,
+  sqlite3_changeset_iter *pIter,
+  int bRebase
+){
+  int rc = SQLITE_OK;
+  int nCol = 0;
+  int op = 0;
+  int iHash = 0;
+  int bIndirect = 0;
+  SessionChange *pChange = 0;
+  SessionChange *pExist = 0;
+  SessionChange **pp = 0;
+  SessionTable *pTab = 0;
+  u8 *aRec = &pIter->in.aData[pIter->in.iCurrent + 2];
+  int nRec = (pIter->in.iNext - pIter->in.iCurrent) - 2;
+
+  assert( nRec>0 );
+
+  /* Ensure that only changesets, or only patchsets, but not a mixture
+  ** of both, are being combined. It is an error to try to combine a
+  ** changeset and a patchset.  */
+  if( pGrp->pList==0 ){
+    pGrp->bPatch = pIter->bPatchset;
+  }else if( pIter->bPatchset!=pGrp->bPatch ){
+    rc = SQLITE_ERROR;
+  }
+
+  if( rc==SQLITE_OK ){
+    const char *zTab = 0;
+    sqlite3changeset_op(pIter, &zTab, &nCol, &op, &bIndirect);
+    rc = sessionChangesetFindTable(pGrp, zTab, pIter, &pTab);
+  }
+
+  if( rc==SQLITE_OK && nCol<pTab->nCol ){
+    SessionBuffer *pBuf = &pGrp->rec;
+    rc = sessionChangesetExtendRecord(pGrp, pTab, nCol, op, aRec, nRec, pBuf);
+    aRec = pBuf->aBuf;
+    nRec = pBuf->nBuf;
+    assert( pGrp->db );
+  }
+
+  if( rc==SQLITE_OK && sessionGrowHash(0, pIter->bPatchset, pTab) ){
+    rc = SQLITE_NOMEM;
+  }
+
+  if( rc==SQLITE_OK ){
+    /* Search for existing entry. If found, remove it from the hash table.
+    ** Code below may link it back in.  */
     iHash = sessionChangeHash(
         pTab, (pIter->bPatchset && op==SQLITE_DELETE), aRec, pTab->nChange
     );
-
-    /* Search for existing entry. If found, remove it from the hash table.
-    ** Code below may link it back in.
-    */
     for(pp=&pTab->apChange[iHash]; *pp; pp=&(*pp)->pNext){
       int bPkOnly1 = 0;
       int bPkOnly2 = 0;
@@ -228782,19 +232169,42 @@ static int sessionChangesetToHash(
         break;
       }
     }
+  }
 
+  if( rc==SQLITE_OK ){
     rc = sessionChangeMerge(pTab, bRebase,
         pIter->bPatchset, pExist, op, bIndirect, aRec, nRec, &pChange
     );
-    if( rc ) break;
-    if( pChange ){
-      pChange->pNext = pTab->apChange[iHash];
-      pTab->apChange[iHash] = pChange;
-      pTab->nEntry++;
-    }
+  }
+  if( rc==SQLITE_OK && pChange ){
+    pChange->pNext = pTab->apChange[iHash];
+    pTab->apChange[iHash] = pChange;
+    pTab->nEntry++;
+  }
+
+  if( rc==SQLITE_OK ) rc = pIter->rc;
+  return rc;
+}
+
+/*
+** Add all changes in the changeset traversed by the iterator passed as
+** the first argument to the changegroup hash tables.
+*/
+static int sessionChangesetToHash(
+  sqlite3_changeset_iter *pIter,   /* Iterator to read from */
+  sqlite3_changegroup *pGrp,       /* Changegroup object to add changeset to */
+  int bRebase                      /* True if hash table is for rebasing */
+){
+  u8 *aRec;
+  int nRec;
+  int rc = SQLITE_OK;
+
+  pIter->in.bNoDiscard = 1;
+  while( SQLITE_ROW==(sessionChangesetNext(pIter, &aRec, &nRec, 0)) ){
+    rc = sessionOneChangeToHash(pGrp, pIter, bRebase);
+    if( rc!=SQLITE_OK ) break;
   }
 
-  sqlite3_free(rec.aBuf);
   if( rc==SQLITE_OK ) rc = pIter->rc;
   return rc;
 }
@@ -228922,6 +232332,23 @@ SQLITE_API int sqlite3changegroup_add(sqlite3_changegroup *pGrp, int nData, void
   return rc;
 }
 
+/*
+** Add a single change to a changeset-group.
+*/
+SQLITE_API int sqlite3changegroup_add_change(
+  sqlite3_changegroup *pGrp,
+  sqlite3_changeset_iter *pIter
+){
+  if( pIter->in.iCurrent==pIter->in.iNext
+   || pIter->rc!=SQLITE_OK
+   || pIter->bInvert
+  ){
+    /* Iterator does not point to any valid entry or is an INVERT iterator. */
+    return SQLITE_ERROR;
+  }
+  return sessionOneChangeToHash(pGrp, pIter, 0);
+}
+
 /*
 ** Obtain a buffer containing a changeset representing the concatenation
 ** of all changesets added to the group so far.
@@ -228971,6 +232398,7 @@ SQLITE_API void sqlite3changegroup_delete(sqlite3_changegroup *pGrp){
   if( pGrp ){
     sqlite3_free(pGrp->zDb);
     sessionDeleteTable(0, pGrp->pList);
+    sqlite3_free(pGrp->rec.aBuf);
     sqlite3_free(pGrp);
   }
 }
@@ -229372,6 +232800,7 @@ SQLITE_API int sqlite3rebaser_rebase_strm(
 SQLITE_API void sqlite3rebaser_delete(sqlite3_rebaser *p){
   if( p ){
     sessionDeleteTable(0, p->grp.pList);
+    sqlite3_free(p->grp.rec.aBuf);
     sqlite3_free(p);
   }
 }
@@ -229402,7 +232831,27 @@ SQLITE_API int sqlite3session_config(int op, void *pArg){
 /************** End of sqlite3session.c **************************************/
 /************** Begin file fts5.c ********************************************/
 
-
+/*
+** This, the "fts5.c" source file, is a composite file that is itself
+** assembled from the following files:
+**
+**    fts5.h
+**    fts5Int.h
+**    fts5parse.h          <--- Generated from fts5parse.y by Lemon
+**    fts5parse.c          <--- Generated from fts5parse.y by Lemon
+**    fts5_aux.c
+**    fts5_buffer.c
+**    fts5_config.c
+**    fts5_expr.c
+**    fts5_hash.c
+**    fts5_index.c
+**    fts5_main.c
+**    fts5_storage.c
+**    fts5_tokenize.c
+**    fts5_unicode2.c
+**    fts5_varint.c
+**    fts5_vocab.c
+*/
 #if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS5)
 
 #if !defined(NDEBUG) && !defined(SQLITE_DEBUG)
@@ -229412,6 +232861,12 @@ SQLITE_API int sqlite3session_config(int op, void *pArg){
 # undef NDEBUG
 #endif
 
+#ifdef HAVE_STDINT_H
+/* #include <stdint.h> */
+#endif
+#ifdef HAVE_INTTYPES_H
+/* #include <inttypes.h> */
+#endif
 /*
 ** 2014 May 31
 **
@@ -229469,8 +232924,8 @@ struct Fts5PhraseIter {
 ** EXTENSION API FUNCTIONS
 **
 ** xUserData(pFts):
-**   Return a copy of the context pointer the extension function was
-**   registered with.
+**   Return a copy of the pUserData pointer passed to the xCreateFunction()
+**   API when the extension function was registered.
 **
 ** xColumnTotalSize(pFts, iCol, pnToken):
 **   If parameter iCol is less than zero, set output variable *pnToken
@@ -229652,6 +233107,10 @@ struct Fts5PhraseIter {
 **   (i.e. if it is a contentless table), then this API always iterates
 **   through an empty set (all calls to xPhraseFirst() set iCol to -1).
 **
+**   In all cases, matches are visited in (column ASC, offset ASC) order.
+**   i.e. all those in column 0, sorted by offset, followed by those in
+**   column 1, etc.
+**
 ** xPhraseNext()
 **   See xPhraseFirst above.
 **
@@ -229718,9 +233177,32 @@ struct Fts5PhraseIter {
 **
 **   This API can be quite slow if used with an FTS5 table created with the
 **   "detail=none" or "detail=column" option.
+**
+** xColumnLocale(pFts5, iIdx, pzLocale, pnLocale)
+**   If parameter iCol is less than zero, or greater than or equal to the
+**   number of columns in the table, SQLITE_RANGE is returned.
+**
+**   Otherwise, this function attempts to retrieve the locale associated
+**   with column iCol of the current row. Usually, there is no associated
+**   locale, and output parameters (*pzLocale) and (*pnLocale) are set
+**   to NULL and 0, respectively. However, if the fts5_locale() function
+**   was used to associate a locale with the value when it was inserted
+**   into the fts5 table, then (*pzLocale) is set to point to a nul-terminated
+**   buffer containing the name of the locale in utf-8 encoding. (*pnLocale)
+**   is set to the size in bytes of the buffer, not including the
+**   nul-terminator.
+**
+**   If successful, SQLITE_OK is returned. Or, if an error occurs, an
+**   SQLite error code is returned. The final value of the output parameters
+**   is undefined in this case.
+**
+** xTokenize_v2:
+**   Tokenize text using the tokenizer belonging to the FTS5 table. This
+**   API is the same as the xTokenize() API, except that it allows a tokenizer
+**   locale to be specified.
 */
 struct Fts5ExtensionApi {
-  int iVersion;                   /* Currently always set to 3 */
+  int iVersion;                   /* Currently always set to 4 */
 
   void *(*xUserData)(Fts5Context*);
 
@@ -229762,6 +233244,15 @@ struct Fts5ExtensionApi {
       const char **ppToken, int *pnToken
   );
   int (*xInstToken)(Fts5Context*, int iIdx, int iToken, const char**, int*);
+
+  /* Below this point are iVersion>=4 only */
+  int (*xColumnLocale)(Fts5Context*, int iCol, const char **pz, int *pn);
+  int (*xTokenize_v2)(Fts5Context*,
+    const char *pText, int nText,      /* Text to tokenize */
+    const char *pLocale, int nLocale,  /* Locale to pass to tokenizer */
+    void *pCtx,                        /* Context passed to xToken() */
+    int (*xToken)(void*, int, const char*, int, int, int)       /* Callback */
+  );
 };
 
 /*
@@ -229782,7 +233273,7 @@ struct Fts5ExtensionApi {
 **   A tokenizer instance is required to actually tokenize text.
 **
 **   The first argument passed to this function is a copy of the (void*)
-**   pointer provided by the application when the fts5_tokenizer object
+**   pointer provided by the application when the fts5_tokenizer_v2 object
 **   was registered with FTS5 (the third argument to xCreateTokenizer()).
 **   The second and third arguments are an array of nul-terminated strings
 **   containing the tokenizer arguments, if any, specified following the
@@ -229806,7 +233297,7 @@ struct Fts5ExtensionApi {
 **   argument passed to this function is a pointer to an Fts5Tokenizer object
 **   returned by an earlier call to xCreate().
 **
-**   The second argument indicates the reason that FTS5 is requesting
+**   The third argument indicates the reason that FTS5 is requesting
 **   tokenization of the supplied text. This is always one of the following
 **   four values:
 **
@@ -229830,6 +233321,13 @@ struct Fts5ExtensionApi {
 **            on a columnsize=0 database.
 **   </ul>
 **
+**   The sixth and seventh arguments passed to xTokenize() - pLocale and
+**   nLocale - are a pointer to a buffer containing the locale to use for
+**   tokenization (e.g. "en_US") and its size in bytes, respectively. The
+**   pLocale buffer is not nul-terminated. pLocale may be passed NULL (in
+**   which case nLocale is always 0) to indicate that the tokenizer should
+**   use its default locale.
+**
 **   For each token in the input string, the supplied callback xToken() must
 **   be invoked. The first argument to it should be a copy of the pointer
 **   passed as the second argument to xTokenize(). The third and fourth
@@ -229853,6 +233351,30 @@ struct Fts5ExtensionApi {
 **   may abandon the tokenization and return any error code other than
 **   SQLITE_OK or SQLITE_DONE.
 **
+**   If the tokenizer is registered using an fts5_tokenizer_v2 object,
+**   then the xTokenize() method has two additional arguments - pLocale
+**   and nLocale. These specify the locale that the tokenizer should use
+**   for the current request. If pLocale and nLocale are both 0, then the
+**   tokenizer should use its default locale. Otherwise, pLocale points to
+**   an nLocale byte buffer containing the name of the locale to use as utf-8
+**   text. pLocale is not nul-terminated.
+**
+** FTS5_TOKENIZER
+**
+** There is also an fts5_tokenizer object. This is an older, deprecated,
+** version of fts5_tokenizer_v2. It is similar except that:
+**
+**  <ul>
+**    <li> There is no "iVersion" field, and
+**    <li> The xTokenize() method does not take a locale argument.
+**  </ul>
+**
+** Legacy fts5_tokenizer tokenizers must be registered using the
+** legacy xCreateTokenizer() function, instead of xCreateTokenizer_v2().
+**
+** Tokenizer implementations registered using either API may be retrieved
+** using both xFindTokenizer() and xFindTokenizer_v2().
+**
 ** SYNONYM SUPPORT
 **
 **   Custom tokenizers may also support synonyms. Consider a case in which a
@@ -229961,6 +233483,33 @@ struct Fts5ExtensionApi {
 **   inefficient.
 */
 typedef struct Fts5Tokenizer Fts5Tokenizer;
+typedef struct fts5_tokenizer_v2 fts5_tokenizer_v2;
+struct fts5_tokenizer_v2 {
+  int iVersion;             /* Currently always 2 */
+
+  int (*xCreate)(void*, const char **azArg, int nArg, Fts5Tokenizer **ppOut);
+  void (*xDelete)(Fts5Tokenizer*);
+  int (*xTokenize)(Fts5Tokenizer*,
+      void *pCtx,
+      int flags,            /* Mask of FTS5_TOKENIZE_* flags */
+      const char *pText, int nText,
+      const char *pLocale, int nLocale,
+      int (*xToken)(
+        void *pCtx,         /* Copy of 2nd argument to xTokenize() */
+        int tflags,         /* Mask of FTS5_TOKEN_* flags */
+        const char *pToken, /* Pointer to buffer containing token */
+        int nToken,         /* Size of token in bytes */
+        int iStart,         /* Byte offset of token within input text */
+        int iEnd            /* Byte offset of end of token within input text */
+      )
+  );
+};
+
+/*
+** New code should use the fts5_tokenizer_v2 type to define tokenizer
+** implementations. The following type is included for legacy applications
+** that still use it.
+*/
 typedef struct fts5_tokenizer fts5_tokenizer;
 struct fts5_tokenizer {
   int (*xCreate)(void*, const char **azArg, int nArg, Fts5Tokenizer **ppOut);
@@ -229980,6 +233529,7 @@ struct fts5_tokenizer {
   );
 };
 
+
 /* Flags that may be passed as the third argument to xTokenize() */
 #define FTS5_TOKENIZE_QUERY     0x0001
 #define FTS5_TOKENIZE_PREFIX    0x0002
@@ -229999,7 +233549,7 @@ struct fts5_tokenizer {
 */
 typedef struct fts5_api fts5_api;
 struct fts5_api {
-  int iVersion;                   /* Currently always set to 2 */
+  int iVersion;                   /* Currently always set to 3 */
 
   /* Create a new tokenizer */
   int (*xCreateTokenizer)(
@@ -230026,6 +233576,25 @@ struct fts5_api {
     fts5_extension_function xFunction,
     void (*xDestroy)(void*)
   );
+
+  /* APIs below this point are only available if iVersion>=3 */
+
+  /* Create a new tokenizer */
+  int (*xCreateTokenizer_v2)(
+    fts5_api *pApi,
+    const char *zName,
+    void *pUserData,
+    fts5_tokenizer_v2 *pTokenizer,
+    void (*xDestroy)(void*)
+  );
+
+  /* Find an existing tokenizer */
+  int (*xFindTokenizer_v2)(
+    fts5_api *pApi,
+    const char *zName,
+    void **ppUserData,
+    fts5_tokenizer_v2 **ppTokenizer
+  );
 };
 
 /*
@@ -230099,6 +233668,22 @@ typedef sqlite3_uint64 u64;
 # define LARGEST_INT64  (0xffffffff|(((i64)0x7fffffff)<<32))
 # define SMALLEST_INT64 (((i64)-1) - LARGEST_INT64)
 
+/* The uptr type is an unsigned integer large enough to hold a pointer
+*/
+#if defined(HAVE_STDINT_H)
+  typedef uintptr_t uptr;
+#elif SQLITE_PTRSIZE==4
+  typedef u32 uptr;
+#else
+  typedef u64 uptr;
+#endif
+
+#ifdef SQLITE_4_BYTE_ALIGNED_MALLOC
+# define EIGHT_BYTE_ALIGNMENT(X)   ((((uptr)(X) - (uptr)0)&3)==0)
+#else
+# define EIGHT_BYTE_ALIGNMENT(X)   ((((uptr)(X) - (uptr)0)&7)==0)
+#endif
+
 #endif
 
 /* Truncate very long tokens to this many bytes. Hard limit is
@@ -230182,6 +233767,18 @@ struct Fts5Colset {
 */
 
 typedef struct Fts5Config Fts5Config;
+typedef struct Fts5TokenizerConfig Fts5TokenizerConfig;
+
+struct Fts5TokenizerConfig {
+  Fts5Tokenizer *pTok;
+  fts5_tokenizer_v2 *pApi2;
+  fts5_tokenizer *pApi1;
+  const char **azArg;
+  int nArg;
+  int ePattern;                   /* FTS_PATTERN_XXX constant */
+  const char *pLocale;            /* Current locale to use */
+  int nLocale;                    /* Size of pLocale in bytes */
+};
 
 /*
 ** An instance of the following structure encodes all information that can
@@ -230221,9 +233818,12 @@ typedef struct Fts5Config Fts5Config;
 **
 **       INSERT INTO tbl(tbl, rank) VALUES('prefix-index', $bPrefixIndex);
 **
+** bLocale:
+**   Set to true if locale=1 was specified when the table was created.
 */
 struct Fts5Config {
   sqlite3 *db;                    /* Database handle */
+  Fts5Global *pGlobal;            /* Global fts5 object for handle db */
   char *zDb;                      /* Database holding FTS index (e.g. "main") */
   char *zName;                    /* Name of FTS index */
   int nCol;                       /* Number of columns */
@@ -230233,16 +233833,17 @@ struct Fts5Config {
   int *aPrefix;                   /* Sizes in bytes of nPrefix prefix indexes */
   int eContent;                   /* An FTS5_CONTENT value */
   int bContentlessDelete;         /* "contentless_delete=" option (dflt==0) */
+  int bContentlessUnindexed;      /* "contentless_unindexed=" option (dflt=0) */
   char *zContent;                 /* content table */
   char *zContentRowid;            /* "content_rowid=" option value */
   int bColumnsize;                /* "columnsize=" option value (dflt==1) */
   int bTokendata;                 /* "tokendata=" option value (dflt==0) */
+  int bLocale;                    /* "locale=" option value (dflt==0) */
   int eDetail;                    /* FTS5_DETAIL_XXX value */
   char *zContentExprlist;
-  Fts5Tokenizer *pTok;
-  fts5_tokenizer *pTokApi;
+  Fts5TokenizerConfig t;
   int bLock;                      /* True when table is preparing statement */
-  int ePattern;                   /* FTS_PATTERN_XXX constant */
+
 
   /* Values loaded from the %_config table */
   int iVersion;                   /* fts5 file format 'version' */
@@ -230271,9 +233872,10 @@ struct Fts5Config {
 #define FTS5_CURRENT_VERSION               4
 #define FTS5_CURRENT_VERSION_SECUREDELETE  5
 
-#define FTS5_CONTENT_NORMAL   0
-#define FTS5_CONTENT_NONE     1
-#define FTS5_CONTENT_EXTERNAL 2
+#define FTS5_CONTENT_NORMAL    0
+#define FTS5_CONTENT_NONE      1
+#define FTS5_CONTENT_EXTERNAL  2
+#define FTS5_CONTENT_UNINDEXED 3
 
 #define FTS5_DETAIL_FULL      0
 #define FTS5_DETAIL_NONE      1
@@ -230308,6 +233910,8 @@ static int sqlite3Fts5ConfigSetValue(Fts5Config*, const char*, sqlite3_value*, i
 
 static int sqlite3Fts5ConfigParseRank(const char*, char**, char**);
 
+static void sqlite3Fts5ConfigErrmsg(Fts5Config *pConfig, const char *zFmt, ...);
+
 /*
 ** End of interface to code in fts5_config.c.
 **************************************************************************/
@@ -230352,7 +233956,7 @@ static char *sqlite3Fts5Mprintf(int *pRc, const char *zFmt, ...);
 static void sqlite3Fts5Put32(u8*, int);
 static int sqlite3Fts5Get32(const u8*);
 
-#define FTS5_POS2COLUMN(iPos) (int)(iPos >> 32)
+#define FTS5_POS2COLUMN(iPos) (int)((iPos >> 32) & 0x7FFFFFFF)
 #define FTS5_POS2OFFSET(iPos) (int)(iPos & 0x7FFFFFFF)
 
 typedef struct Fts5PoslistReader Fts5PoslistReader;
@@ -230637,18 +234241,20 @@ struct Fts5Table {
   Fts5Index *pIndex;              /* Full-text index */
 };
 
-static int sqlite3Fts5GetTokenizer(
-  Fts5Global*,
-  const char **azArg,
-  int nArg,
-  Fts5Config*,
-  char **pzErr
-);
+static int sqlite3Fts5LoadTokenizer(Fts5Config *pConfig);
 
 static Fts5Table *sqlite3Fts5TableFromCsrid(Fts5Global*, i64);
 
 static int sqlite3Fts5FlushToDisk(Fts5Table*);
 
+static void sqlite3Fts5ClearLocale(Fts5Config *pConfig);
+static void sqlite3Fts5SetLocale(Fts5Config *pConfig, const char *pLoc, int nLoc);
+
+static int sqlite3Fts5IsLocaleValue(Fts5Config *pConfig, sqlite3_value *pVal);
+static int sqlite3Fts5DecodeLocaleValue(sqlite3_value *pVal,
+    const char **ppText, int *pnText, const char **ppLoc, int *pnLoc
+);
+
 /*
 ** End of interface to code in fts5.c.
 **************************************************************************/
@@ -230728,8 +234334,8 @@ static int sqlite3Fts5StorageRename(Fts5Storage*, const char *zName);
 static int sqlite3Fts5DropAll(Fts5Config*);
 static int sqlite3Fts5CreateTable(Fts5Config*, const char*, const char*, int, char **);
 
-static int sqlite3Fts5StorageDelete(Fts5Storage *p, i64, sqlite3_value**);
-static int sqlite3Fts5StorageContentInsert(Fts5Storage *p, sqlite3_value**, i64*);
+static int sqlite3Fts5StorageDelete(Fts5Storage *p, i64, sqlite3_value**, int);
+static int sqlite3Fts5StorageContentInsert(Fts5Storage *p, int, sqlite3_value**, i64*);
 static int sqlite3Fts5StorageIndexInsert(Fts5Storage *p, sqlite3_value**, i64);
 
 static int sqlite3Fts5StorageIntegrity(Fts5Storage *p, int iArg);
@@ -230754,6 +234360,9 @@ static int sqlite3Fts5StorageOptimize(Fts5Storage *p);
 static int sqlite3Fts5StorageMerge(Fts5Storage *p, int nMerge);
 static int sqlite3Fts5StorageReset(Fts5Storage *p);
 
+static void sqlite3Fts5StorageReleaseDeleteRow(Fts5Storage*);
+static int sqlite3Fts5StorageFindDeleteRow(Fts5Storage *p, i64 iDel);
+
 /*
 ** End of interface to code in fts5_storage.c.
 **************************************************************************/
@@ -230906,6 +234515,7 @@ static int sqlite3Fts5TokenizerPattern(
     int (*xCreate)(void*, const char**, int, Fts5Tokenizer**),
     Fts5Tokenizer *pTok
 );
+static int sqlite3Fts5TokenizerPreload(Fts5TokenizerConfig*);
 /*
 ** End of interface to code in fts5_tokenizer.c.
 **************************************************************************/
@@ -231066,6 +234676,9 @@ static void sqlite3Fts5UnicodeAscii(u8*, u8*);
 **    sqlite3Fts5ParserARG_STORE     Code to store %extra_argument into fts5yypParser
 **    sqlite3Fts5ParserARG_FETCH     Code to extract %extra_argument from fts5yypParser
 **    sqlite3Fts5ParserCTX_*         As sqlite3Fts5ParserARG_ except for %extra_context
+**    fts5YYREALLOC          Name of the realloc() function to use
+**    fts5YYFREE             Name of the free() function to use
+**    fts5YYDYNSTACK         True if stack space should be extended on heap
 **    fts5YYERRORSYMBOL      is the code number of the error symbol.  If not
 **                       defined, then do no error processing.
 **    fts5YYNSTATE           the combined number of states.
@@ -231079,6 +234692,8 @@ static void sqlite3Fts5UnicodeAscii(u8*, u8*);
 **    fts5YY_NO_ACTION       The fts5yy_action[] code for no-op
 **    fts5YY_MIN_REDUCE      Minimum value for reduce actions
 **    fts5YY_MAX_REDUCE      Maximum value for reduce actions
+**    fts5YY_MIN_DSTRCTR     Minimum symbol value that has a destructor
+**    fts5YY_MAX_DSTRCTR     Maximum symbol value that has a destructor
 */
 #ifndef INTERFACE
 # define INTERFACE 1
@@ -231105,6 +234720,9 @@ typedef union {
 #define sqlite3Fts5ParserARG_PARAM ,pParse
 #define sqlite3Fts5ParserARG_FETCH Fts5Parse *pParse=fts5yypParser->pParse;
 #define sqlite3Fts5ParserARG_STORE fts5yypParser->pParse=pParse;
+#define fts5YYREALLOC realloc
+#define fts5YYFREE free
+#define fts5YYDYNSTACK 0
 #define sqlite3Fts5ParserCTX_SDECL
 #define sqlite3Fts5ParserCTX_PDECL
 #define sqlite3Fts5ParserCTX_PARAM
@@ -231122,6 +234740,8 @@ typedef union {
 #define fts5YY_NO_ACTION         82
 #define fts5YY_MIN_REDUCE        83
 #define fts5YY_MAX_REDUCE        110
+#define fts5YY_MIN_DSTRCTR       16
+#define fts5YY_MAX_DSTRCTR       24
 /************* End control #defines *******************************************/
 #define fts5YY_NLOOKAHEAD ((int)(sizeof(fts5yy_lookahead)/sizeof(fts5yy_lookahead[0])))
 
@@ -231137,6 +234757,22 @@ typedef union {
 # define fts5yytestcase(X)
 #endif
 
+/* Macro to determine if stack space has the ability to grow using
+** heap memory.
+*/
+#if fts5YYSTACKDEPTH<=0 || fts5YYDYNSTACK
+# define fts5YYGROWABLESTACK 1
+#else
+# define fts5YYGROWABLESTACK 0
+#endif
+
+/* Guarantee a minimum number of initial stack slots.
+*/
+#if fts5YYSTACKDEPTH<=0
+# undef fts5YYSTACKDEPTH
+# define fts5YYSTACKDEPTH 2  /* Need a minimum stack size */
+#endif
+
 
 /* Next are the tables used to determine what action to take based on the
 ** current state and lookahead token.  These tables are used to implement
@@ -231297,14 +234933,9 @@ struct fts5yyParser {
 #endif
   sqlite3Fts5ParserARG_SDECL                /* A place to hold %extra_argument */
   sqlite3Fts5ParserCTX_SDECL                /* A place to hold %extra_context */
-#if fts5YYSTACKDEPTH<=0
-  int fts5yystksz;                  /* Current side of the stack */
-  fts5yyStackEntry *fts5yystack;        /* The parser's stack */
-  fts5yyStackEntry fts5yystk0;          /* First stack entry */
-#else
-  fts5yyStackEntry fts5yystack[fts5YYSTACKDEPTH];  /* The parser's stack */
-  fts5yyStackEntry *fts5yystackEnd;            /* Last entry in the stack */
-#endif
+  fts5yyStackEntry *fts5yystackEnd;           /* Last entry in the stack */
+  fts5yyStackEntry *fts5yystack;              /* The parser stack */
+  fts5yyStackEntry fts5yystk0[fts5YYSTACKDEPTH];  /* Initial stack space */
 };
 typedef struct fts5yyParser fts5yyParser;
 
@@ -231411,37 +235042,45 @@ static const char *const fts5yyRuleName[] = {
 #endif /* NDEBUG */
 
 
-#if fts5YYSTACKDEPTH<=0
+#if fts5YYGROWABLESTACK
 /*
 ** Try to increase the size of the parser stack.  Return the number
 ** of errors.  Return 0 on success.
 */
 static int fts5yyGrowStack(fts5yyParser *p){
+  int oldSize = 1 + (int)(p->fts5yystackEnd - p->fts5yystack);
   int newSize;
   int idx;
   fts5yyStackEntry *pNew;
 
-  newSize = p->fts5yystksz*2 + 100;
-  idx = p->fts5yytos ? (int)(p->fts5yytos - p->fts5yystack) : 0;
-  if( p->fts5yystack==&p->fts5yystk0 ){
-    pNew = malloc(newSize*sizeof(pNew[0]));
-    if( pNew ) pNew[0] = p->fts5yystk0;
+  newSize = oldSize*2 + 100;
+  idx = (int)(p->fts5yytos - p->fts5yystack);
+  if( p->fts5yystack==p->fts5yystk0 ){
+    pNew = fts5YYREALLOC(0, newSize*sizeof(pNew[0]));
+    if( pNew==0 ) return 1;
+    memcpy(pNew, p->fts5yystack, oldSize*sizeof(pNew[0]));
   }else{
-    pNew = realloc(p->fts5yystack, newSize*sizeof(pNew[0]));
+    pNew = fts5YYREALLOC(p->fts5yystack, newSize*sizeof(pNew[0]));
+    if( pNew==0 ) return 1;
   }
-  if( pNew ){
-    p->fts5yystack = pNew;
-    p->fts5yytos = &p->fts5yystack[idx];
+  p->fts5yystack = pNew;
+  p->fts5yytos = &p->fts5yystack[idx];
 #ifndef NDEBUG
-    if( fts5yyTraceFILE ){
-      fprintf(fts5yyTraceFILE,"%sStack grows from %d to %d entries.\n",
-              fts5yyTracePrompt, p->fts5yystksz, newSize);
-    }
-#endif
-    p->fts5yystksz = newSize;
+  if( fts5yyTraceFILE ){
+    fprintf(fts5yyTraceFILE,"%sStack grows from %d to %d entries.\n",
+            fts5yyTracePrompt, oldSize, newSize);
   }
-  return pNew==0;
+#endif
+  p->fts5yystackEnd = &p->fts5yystack[newSize-1];
+  return 0;
 }
+#endif /* fts5YYGROWABLESTACK */
+
+#if !fts5YYGROWABLESTACK
+/* For builds that do no have a growable stack, fts5yyGrowStack always
+** returns an error.
+*/
+# define fts5yyGrowStack(X) 1
 #endif
 
 /* Datatype of the argument to the memory allocated passed as the
@@ -231461,24 +235100,14 @@ static void sqlite3Fts5ParserInit(void *fts5yypRawParser sqlite3Fts5ParserCTX_PD
 #ifdef fts5YYTRACKMAXSTACKDEPTH
   fts5yypParser->fts5yyhwm = 0;
 #endif
-#if fts5YYSTACKDEPTH<=0
-  fts5yypParser->fts5yytos = NULL;
-  fts5yypParser->fts5yystack = NULL;
-  fts5yypParser->fts5yystksz = 0;
-  if( fts5yyGrowStack(fts5yypParser) ){
-    fts5yypParser->fts5yystack = &fts5yypParser->fts5yystk0;
-    fts5yypParser->fts5yystksz = 1;
-  }
-#endif
+  fts5yypParser->fts5yystack = fts5yypParser->fts5yystk0;
+  fts5yypParser->fts5yystackEnd = &fts5yypParser->fts5yystack[fts5YYSTACKDEPTH-1];
 #ifndef fts5YYNOERRORRECOVERY
   fts5yypParser->fts5yyerrcnt = -1;
 #endif
   fts5yypParser->fts5yytos = fts5yypParser->fts5yystack;
   fts5yypParser->fts5yystack[0].stateno = 0;
   fts5yypParser->fts5yystack[0].major = 0;
-#if fts5YYSTACKDEPTH>0
-  fts5yypParser->fts5yystackEnd = &fts5yypParser->fts5yystack[fts5YYSTACKDEPTH-1];
-#endif
 }
 
 #ifndef sqlite3Fts5Parser_ENGINEALWAYSONSTACK
@@ -231592,9 +235221,26 @@ static void fts5yy_pop_parser_stack(fts5yyParser *pParser){
 */
 static void sqlite3Fts5ParserFinalize(void *p){
   fts5yyParser *pParser = (fts5yyParser*)p;
-  while( pParser->fts5yytos>pParser->fts5yystack ) fts5yy_pop_parser_stack(pParser);
-#if fts5YYSTACKDEPTH<=0
-  if( pParser->fts5yystack!=&pParser->fts5yystk0 ) free(pParser->fts5yystack);
+
+  /* In-lined version of calling fts5yy_pop_parser_stack() for each
+  ** element left in the stack */
+  fts5yyStackEntry *fts5yytos = pParser->fts5yytos;
+  while( fts5yytos>pParser->fts5yystack ){
+#ifndef NDEBUG
+    if( fts5yyTraceFILE ){
+      fprintf(fts5yyTraceFILE,"%sPopping %s\n",
+        fts5yyTracePrompt,
+        fts5yyTokenName[fts5yytos->major]);
+    }
+#endif
+    if( fts5yytos->major>=fts5YY_MIN_DSTRCTR ){
+      fts5yy_destructor(pParser, fts5yytos->major, &fts5yytos->minor);
+    }
+    fts5yytos--;
+  }
+
+#if fts5YYGROWABLESTACK
+  if( pParser->fts5yystack!=pParser->fts5yystk0 ) fts5YYFREE(pParser->fts5yystack);
 #endif
 }
 
@@ -231821,25 +235467,19 @@ static void fts5yy_shift(
     assert( fts5yypParser->fts5yyhwm == (int)(fts5yypParser->fts5yytos - fts5yypParser->fts5yystack) );
   }
 #endif
-#if fts5YYSTACKDEPTH>0
-  if( fts5yypParser->fts5yytos>fts5yypParser->fts5yystackEnd ){
-    fts5yypParser->fts5yytos--;
-    fts5yyStackOverflow(fts5yypParser);
-    return;
-  }
-#else
-  if( fts5yypParser->fts5yytos>=&fts5yypParser->fts5yystack[fts5yypParser->fts5yystksz] ){
+  fts5yytos = fts5yypParser->fts5yytos;
+  if( fts5yytos>fts5yypParser->fts5yystackEnd ){
     if( fts5yyGrowStack(fts5yypParser) ){
       fts5yypParser->fts5yytos--;
       fts5yyStackOverflow(fts5yypParser);
       return;
     }
+    fts5yytos = fts5yypParser->fts5yytos;
+    assert( fts5yytos <= fts5yypParser->fts5yystackEnd );
   }
-#endif
   if( fts5yyNewState > fts5YY_MAX_SHIFT ){
     fts5yyNewState += fts5YY_MIN_REDUCE - fts5YY_MIN_SHIFTREDUCE;
   }
-  fts5yytos = fts5yypParser->fts5yytos;
   fts5yytos->stateno = fts5yyNewState;
   fts5yytos->major = fts5yyMajor;
   fts5yytos->minor.fts5yy0 = fts5yyMinor;
@@ -232276,19 +235916,12 @@ static void sqlite3Fts5Parser(
                   (int)(fts5yypParser->fts5yytos - fts5yypParser->fts5yystack));
         }
 #endif
-#if fts5YYSTACKDEPTH>0
         if( fts5yypParser->fts5yytos>=fts5yypParser->fts5yystackEnd ){
-          fts5yyStackOverflow(fts5yypParser);
-          break;
-        }
-#else
-        if( fts5yypParser->fts5yytos>=&fts5yypParser->fts5yystack[fts5yypParser->fts5yystksz-1] ){
           if( fts5yyGrowStack(fts5yypParser) ){
             fts5yyStackOverflow(fts5yypParser);
             break;
           }
         }
-#endif
       }
       fts5yyact = fts5yy_reduce(fts5yypParser,fts5yyruleno,fts5yymajor,fts5yyminor sqlite3Fts5ParserCTX_PARAM);
     }else if( fts5yyact <= fts5YY_MAX_SHIFTREDUCE ){
@@ -232660,6 +236293,7 @@ static int fts5HighlightCb(
   return rc;
 }
 
+
 /*
 ** Implementation of highlight() function.
 */
@@ -232690,12 +236324,19 @@ static void fts5HighlightFunction(
     sqlite3_result_text(pCtx, "", -1, SQLITE_STATIC);
     rc = SQLITE_OK;
   }else if( ctx.zIn ){
+    const char *pLoc = 0;         /* Locale of column iCol */
+    int nLoc = 0;                 /* Size of pLoc in bytes */
     if( rc==SQLITE_OK ){
       rc = fts5CInstIterInit(pApi, pFts, iCol, &ctx.iter);
     }
 
     if( rc==SQLITE_OK ){
-      rc = pApi->xTokenize(pFts, ctx.zIn, ctx.nIn, (void*)&ctx,fts5HighlightCb);
+      rc = pApi->xColumnLocale(pFts, iCol, &pLoc, &nLoc);
+    }
+    if( rc==SQLITE_OK ){
+      rc = pApi->xTokenize_v2(
+          pFts, ctx.zIn, ctx.nIn, pLoc, nLoc, (void*)&ctx, fts5HighlightCb
+      );
     }
     if( ctx.bOpen ){
       fts5HighlightAppend(&rc, &ctx, ctx.zClose, -1);
@@ -232892,6 +236533,8 @@ static void fts5SnippetFunction(
   memset(&sFinder, 0, sizeof(Fts5SFinder));
   for(i=0; i<nCol; i++){
     if( iCol<0 || iCol==i ){
+      const char *pLoc = 0;       /* Locale of column iCol */
+      int nLoc = 0;               /* Size of pLoc in bytes */
       int nDoc;
       int nDocsize;
       int ii;
@@ -232899,8 +236542,10 @@ static void fts5SnippetFunction(
       sFinder.nFirst = 0;
       rc = pApi->xColumnText(pFts, i, &sFinder.zDoc, &nDoc);
       if( rc!=SQLITE_OK ) break;
-      rc = pApi->xTokenize(pFts,
-          sFinder.zDoc, nDoc, (void*)&sFinder,fts5SentenceFinderCb
+      rc = pApi->xColumnLocale(pFts, i, &pLoc, &nLoc);
+      if( rc!=SQLITE_OK ) break;
+      rc = pApi->xTokenize_v2(pFts,
+          sFinder.zDoc, nDoc, pLoc, nLoc, (void*)&sFinder, fts5SentenceFinderCb
       );
       if( rc!=SQLITE_OK ) break;
       rc = pApi->xColumnSize(pFts, i, &nDocsize);
@@ -232958,6 +236603,9 @@ static void fts5SnippetFunction(
     rc = pApi->xColumnSize(pFts, iBestCol, &nColSize);
   }
   if( ctx.zIn ){
+    const char *pLoc = 0;         /* Locale of column iBestCol */
+    int nLoc = 0;                 /* Bytes in pLoc */
+
     if( rc==SQLITE_OK ){
       rc = fts5CInstIterInit(pApi, pFts, iBestCol, &ctx.iter);
     }
@@ -232976,7 +236624,12 @@ static void fts5SnippetFunction(
     }
 
     if( rc==SQLITE_OK ){
-      rc = pApi->xTokenize(pFts, ctx.zIn, ctx.nIn, (void*)&ctx,fts5HighlightCb);
+      rc = pApi->xColumnLocale(pFts, iBestCol, &pLoc, &nLoc);
+    }
+    if( rc==SQLITE_OK ){
+      rc = pApi->xTokenize_v2(
+          pFts, ctx.zIn, ctx.nIn, pLoc, nLoc, (void*)&ctx,fts5HighlightCb
+      );
     }
     if( ctx.bOpen ){
       fts5HighlightAppend(&rc, &ctx, ctx.zClose, -1);
@@ -233160,6 +236813,53 @@ static void fts5Bm25Function(
   }
 }
 
+/*
+** Implementation of fts5_get_locale() function.
+*/
+static void fts5GetLocaleFunction(
+  const Fts5ExtensionApi *pApi,   /* API offered by current FTS version */
+  Fts5Context *pFts,              /* First arg to pass to pApi functions */
+  sqlite3_context *pCtx,          /* Context for returning result/error */
+  int nVal,                       /* Number of values in apVal[] array */
+  sqlite3_value **apVal           /* Array of trailing arguments */
+){
+  int iCol = 0;
+  int eType = 0;
+  int rc = SQLITE_OK;
+  const char *zLocale = 0;
+  int nLocale = 0;
+
+  /* xColumnLocale() must be available */
+  assert( pApi->iVersion>=4 );
+
+  if( nVal!=1 ){
+    const char *z = "wrong number of arguments to function fts5_get_locale()";
+    sqlite3_result_error(pCtx, z, -1);
+    return;
+  }
+
+  eType = sqlite3_value_numeric_type(apVal[0]);
+  if( eType!=SQLITE_INTEGER ){
+    const char *z = "non-integer argument passed to function fts5_get_locale()";
+    sqlite3_result_error(pCtx, z, -1);
+    return;
+  }
+
+  iCol = sqlite3_value_int(apVal[0]);
+  if( iCol<0 || iCol>=pApi->xColumnCount(pFts) ){
+    sqlite3_result_error_code(pCtx, SQLITE_RANGE);
+    return;
+  }
+
+  rc = pApi->xColumnLocale(pFts, iCol, &zLocale, &nLocale);
+  if( rc!=SQLITE_OK ){
+    sqlite3_result_error_code(pCtx, rc);
+    return;
+  }
+
+  sqlite3_result_text(pCtx, zLocale, nLocale, SQLITE_TRANSIENT);
+}
+
 static int sqlite3Fts5AuxInit(fts5_api *pApi){
   struct Builtin {
     const char *zFunc;            /* Function name (nul-terminated) */
@@ -233167,9 +236867,10 @@ static int sqlite3Fts5AuxInit(fts5_api *pApi){
     fts5_extension_function xFunc;/* Callback function */
     void (*xDestroy)(void*);      /* Destructor function */
   } aBuiltin [] = {
-    { "snippet",   0, fts5SnippetFunction, 0 },
-    { "highlight", 0, fts5HighlightFunction, 0 },
-    { "bm25",      0, fts5Bm25Function,    0 },
+    { "snippet",         0, fts5SnippetFunction,   0 },
+    { "highlight",       0, fts5HighlightFunction, 0 },
+    { "bm25",            0, fts5Bm25Function,      0 },
+    { "fts5_get_locale", 0, fts5GetLocaleFunction, 0 },
   };
   int rc = SQLITE_OK;             /* Return code */
   int i;                          /* To iterate through builtin functions */
@@ -233834,7 +237535,6 @@ static int fts5ConfigSetEnum(
 ** eventually free any such error message using sqlite3_free().
 */
 static int fts5ConfigParseSpecial(
-  Fts5Global *pGlobal,
   Fts5Config *pConfig,            /* Configuration object to update */
   const char *zCmd,               /* Special command to parse */
   const char *zArg,               /* Argument to parse */
@@ -233842,6 +237542,7 @@ static int fts5ConfigParseSpecial(
 ){
   int rc = SQLITE_OK;
   int nCmd = (int)strlen(zCmd);
+
   if( sqlite3_strnicmp("prefix", zCmd, nCmd)==0 ){
     const int nByte = sizeof(int) * FTS5_MAX_PREFIX_INDEXES;
     const char *p;
@@ -233898,12 +237599,11 @@ static int fts5ConfigParseSpecial(
   if( sqlite3_strnicmp("tokenize", zCmd, nCmd)==0 ){
     const char *p = (const char*)zArg;
     sqlite3_int64 nArg = strlen(zArg) + 1;
-    char **azArg = sqlite3Fts5MallocZero(&rc, sizeof(char*) * nArg);
-    char *pDel = sqlite3Fts5MallocZero(&rc, nArg * 2);
-    char *pSpace = pDel;
+    char **azArg = sqlite3Fts5MallocZero(&rc, (sizeof(char*) + 2) * nArg);
 
-    if( azArg && pSpace ){
-      if( pConfig->pTok ){
+    if( azArg ){
+      char *pSpace = (char*)&azArg[nArg];
+      if( pConfig->t.azArg ){
         *pzErr = sqlite3_mprintf("multiple tokenize=... directives");
         rc = SQLITE_ERROR;
       }else{
@@ -233926,16 +237626,14 @@ static int fts5ConfigParseSpecial(
           *pzErr = sqlite3_mprintf("parse error in tokenize directive");
           rc = SQLITE_ERROR;
         }else{
-          rc = sqlite3Fts5GetTokenizer(pGlobal,
-              (const char**)azArg, (int)nArg, pConfig,
-              pzErr
-          );
+          pConfig->t.azArg = (const char**)azArg;
+          pConfig->t.nArg = nArg;
+          azArg = 0;
         }
       }
     }
-
     sqlite3_free(azArg);
-    sqlite3_free(pDel);
+
     return rc;
   }
 
@@ -233964,6 +237662,16 @@ static int fts5ConfigParseSpecial(
     return rc;
   }
 
+  if( sqlite3_strnicmp("contentless_unindexed", zCmd, nCmd)==0 ){
+    if( (zArg[0]!='0' && zArg[0]!='1') || zArg[1]!='\0' ){
+      *pzErr = sqlite3_mprintf("malformed contentless_delete=... directive");
+      rc = SQLITE_ERROR;
+    }else{
+      pConfig->bContentlessUnindexed = (zArg[0]=='1');
+    }
+    return rc;
+  }
+
   if( sqlite3_strnicmp("content_rowid", zCmd, nCmd)==0 ){
     if( pConfig->zContentRowid ){
       *pzErr = sqlite3_mprintf("multiple content_rowid=... directives");
@@ -233984,6 +237692,16 @@ static int fts5ConfigParseSpecial(
     return rc;
   }
 
+  if( sqlite3_strnicmp("locale", zCmd, nCmd)==0 ){
+    if( (zArg[0]!='0' && zArg[0]!='1') || zArg[1]!='\0' ){
+      *pzErr = sqlite3_mprintf("malformed locale=... directive");
+      rc = SQLITE_ERROR;
+    }else{
+      pConfig->bLocale = (zArg[0]=='1');
+    }
+    return rc;
+  }
+
   if( sqlite3_strnicmp("detail", zCmd, nCmd)==0 ){
     const Fts5Enum aDetail[] = {
       { "none", FTS5_DETAIL_NONE },
@@ -234012,16 +237730,6 @@ static int fts5ConfigParseSpecial(
   return SQLITE_ERROR;
 }
 
-/*
-** Allocate an instance of the default tokenizer ("simple") at
-** Fts5Config.pTokenizer. Return SQLITE_OK if successful, or an SQLite error
-** code if an error occurs.
-*/
-static int fts5ConfigDefaultTokenizer(Fts5Global *pGlobal, Fts5Config *pConfig){
-  assert( pConfig->pTok==0 && pConfig->pTokApi==0 );
-  return sqlite3Fts5GetTokenizer(pGlobal, 0, 0, pConfig, 0);
-}
-
 /*
 ** Gobble up the first bareword or quoted word from the input buffer zIn.
 ** Return a pointer to the character immediately following the last in
@@ -234081,7 +237789,8 @@ static int fts5ConfigParseColumn(
   Fts5Config *p,
   char *zCol,
   char *zArg,
-  char **pzErr
+  char **pzErr,
+  int *pbUnindexed
 ){
   int rc = SQLITE_OK;
   if( 0==sqlite3_stricmp(zCol, FTS5_RANK_NAME)
@@ -234092,6 +237801,7 @@ static int fts5ConfigParseColumn(
   }else if( zArg ){
     if( 0==sqlite3_stricmp(zArg, "unindexed") ){
       p->abUnindexed[p->nCol] = 1;
+      *pbUnindexed = 1;
     }else{
       *pzErr = sqlite3_mprintf("unrecognized column option: %s", zArg);
       rc = SQLITE_ERROR;
@@ -234112,11 +237822,26 @@ static int fts5ConfigMakeExprlist(Fts5Config *p){
 
   sqlite3Fts5BufferAppendPrintf(&rc, &buf, "T.%Q", p->zContentRowid);
   if( p->eContent!=FTS5_CONTENT_NONE ){
+    assert( p->eContent==FTS5_CONTENT_EXTERNAL
+         || p->eContent==FTS5_CONTENT_NORMAL
+         || p->eContent==FTS5_CONTENT_UNINDEXED
+    );
     for(i=0; i<p->nCol; i++){
       if( p->eContent==FTS5_CONTENT_EXTERNAL ){
         sqlite3Fts5BufferAppendPrintf(&rc, &buf, ", T.%Q", p->azCol[i]);
-      }else{
+      }else if( p->eContent==FTS5_CONTENT_NORMAL || p->abUnindexed[i] ){
         sqlite3Fts5BufferAppendPrintf(&rc, &buf, ", T.c%d", i);
+      }else{
+        sqlite3Fts5BufferAppendPrintf(&rc, &buf, ", NULL");
+      }
+    }
+  }
+  if( p->eContent==FTS5_CONTENT_NORMAL && p->bLocale ){
+    for(i=0; i<p->nCol; i++){
+      if( p->abUnindexed[i]==0 ){
+        sqlite3Fts5BufferAppendPrintf(&rc, &buf, ", T.l%d", i);
+      }else{
+        sqlite3Fts5BufferAppendPrintf(&rc, &buf, ", NULL");
       }
     }
   }
@@ -234150,10 +237875,12 @@ static int sqlite3Fts5ConfigParse(
   Fts5Config *pRet;               /* New object to return */
   int i;
   sqlite3_int64 nByte;
+  int bUnindexed = 0;             /* True if there are one or more UNINDEXED */
 
   *ppOut = pRet = (Fts5Config*)sqlite3_malloc(sizeof(Fts5Config));
   if( pRet==0 ) return SQLITE_NOMEM;
   memset(pRet, 0, sizeof(Fts5Config));
+  pRet->pGlobal = pGlobal;
   pRet->db = db;
   pRet->iCookie = -1;
 
@@ -234202,13 +237929,13 @@ static int sqlite3Fts5ConfigParse(
         rc = SQLITE_ERROR;
       }else{
         if( bOption ){
-          rc = fts5ConfigParseSpecial(pGlobal, pRet,
+          rc = fts5ConfigParseSpecial(pRet,
             ALWAYS(zOne)?zOne:"",
             zTwo?zTwo:"",
             pzErr
           );
         }else{
-          rc = fts5ConfigParseColumn(pRet, zOne, zTwo, pzErr);
+          rc = fts5ConfigParseColumn(pRet, zOne, zTwo, pzErr, &bUnindexed);
           zOne = 0;
         }
       }
@@ -234240,11 +237967,17 @@ static int sqlite3Fts5ConfigParse(
     rc = SQLITE_ERROR;
   }
 
-  /* If a tokenizer= option was successfully parsed, the tokenizer has
-  ** already been allocated. Otherwise, allocate an instance of the default
-  ** tokenizer (unicode61) now.  */
-  if( rc==SQLITE_OK && pRet->pTok==0 ){
-    rc = fts5ConfigDefaultTokenizer(pGlobal, pRet);
+  /* We only allow contentless_unindexed=1 if the table is actually a
+  ** contentless one.
+  */
+  if( rc==SQLITE_OK
+   && pRet->bContentlessUnindexed
+   && pRet->eContent!=FTS5_CONTENT_NONE
+  ){
+    *pzErr = sqlite3_mprintf(
+        "contentless_unindexed=1 requires a contentless table"
+    );
+    rc = SQLITE_ERROR;
   }
 
   /* If no zContent option was specified, fill in the default values. */
@@ -234255,6 +237988,9 @@ static int sqlite3Fts5ConfigParse(
     );
     if( pRet->eContent==FTS5_CONTENT_NORMAL ){
       zTail = "content";
+    }else if( bUnindexed && pRet->bContentlessUnindexed ){
+      pRet->eContent = FTS5_CONTENT_UNINDEXED;
+      zTail = "content";
     }else if( pRet->bColumnsize ){
       zTail = "docsize";
     }
@@ -234288,9 +238024,14 @@ static int sqlite3Fts5ConfigParse(
 static void sqlite3Fts5ConfigFree(Fts5Config *pConfig){
   if( pConfig ){
     int i;
-    if( pConfig->pTok ){
-      pConfig->pTokApi->xDelete(pConfig->pTok);
+    if( pConfig->t.pTok ){
+      if( pConfig->t.pApi1 ){
+        pConfig->t.pApi1->xDelete(pConfig->t.pTok);
+      }else{
+        pConfig->t.pApi2->xDelete(pConfig->t.pTok);
+      }
     }
+    sqlite3_free((char*)pConfig->t.azArg);
     sqlite3_free(pConfig->zDb);
     sqlite3_free(pConfig->zName);
     for(i=0; i<pConfig->nCol; i++){
@@ -234365,10 +238106,24 @@ static int sqlite3Fts5Tokenize(
   void *pCtx,                     /* Context passed to xToken() */
   int (*xToken)(void*, int, const char*, int, int, int)    /* Callback */
 ){
-  if( pText==0 ) return SQLITE_OK;
-  return pConfig->pTokApi->xTokenize(
-      pConfig->pTok, pCtx, flags, pText, nText, xToken
-  );
+  int rc = SQLITE_OK;
+  if( pText ){
+    if( pConfig->t.pTok==0 ){
+      rc = sqlite3Fts5LoadTokenizer(pConfig);
+    }
+    if( rc==SQLITE_OK ){
+      if( pConfig->t.pApi1 ){
+        rc = pConfig->t.pApi1->xTokenize(
+            pConfig->t.pTok, pCtx, flags, pText, nText, xToken
+        );
+      }else{
+        rc = pConfig->t.pApi2->xTokenize(pConfig->t.pTok, pCtx, flags,
+            pText, nText, pConfig->t.pLocale, pConfig->t.nLocale, xToken
+        );
+      }
+    }
+  }
+  return rc;
 }
 
 /*
@@ -234622,13 +238377,10 @@ static int sqlite3Fts5ConfigLoad(Fts5Config *pConfig, int iCookie){
    && iVersion!=FTS5_CURRENT_VERSION_SECUREDELETE
   ){
     rc = SQLITE_ERROR;
-    if( pConfig->pzErrmsg ){
-      assert( 0==*pConfig->pzErrmsg );
-      *pConfig->pzErrmsg = sqlite3_mprintf("invalid fts5 file format "
-          "(found %d, expected %d or %d) - run 'rebuild'",
-          iVersion, FTS5_CURRENT_VERSION, FTS5_CURRENT_VERSION_SECUREDELETE
-      );
-    }
+    sqlite3Fts5ConfigErrmsg(pConfig, "invalid fts5 file format "
+        "(found %d, expected %d or %d) - run 'rebuild'",
+        iVersion, FTS5_CURRENT_VERSION, FTS5_CURRENT_VERSION_SECUREDELETE
+    );
   }else{
     pConfig->iVersion = iVersion;
   }
@@ -234639,6 +238391,29 @@ static int sqlite3Fts5ConfigLoad(Fts5Config *pConfig, int iCookie){
   return rc;
 }
 
+/*
+** Set (*pConfig->pzErrmsg) to point to an sqlite3_malloc()ed buffer
+** containing the error message created using printf() style formatting
+** string zFmt and its trailing arguments.
+*/
+static void sqlite3Fts5ConfigErrmsg(Fts5Config *pConfig, const char *zFmt, ...){
+  va_list ap;                     /* ... printf arguments */
+  char *zMsg = 0;
+
+  va_start(ap, zFmt);
+  zMsg = sqlite3_vmprintf(zFmt, ap);
+  if( pConfig->pzErrmsg ){
+    assert( *pConfig->pzErrmsg==0 );
+    *pConfig->pzErrmsg = zMsg;
+  }else{
+    sqlite3_free(zMsg);
+  }
+
+  va_end(ap);
+}
+
+
+
 /*
 ** 2014 May 31
 **
@@ -234695,7 +238470,7 @@ struct Fts5Expr {
 
 /*
 ** eType:
-**   Expression node type. Always one of:
+**   Expression node type. Usually one of:
 **
 **       FTS5_AND                 (nChild, apChild valid)
 **       FTS5_OR                  (nChild, apChild valid)
@@ -234703,6 +238478,10 @@ struct Fts5Expr {
 **       FTS5_STRING              (pNear valid)
 **       FTS5_TERM                (pNear valid)
 **
+**   An expression node with eType==0 may also exist. It always matches zero
+**   rows. This is created when a phrase containing no tokens is parsed.
+**   e.g. "".
+**
 ** iHeight:
 **   Distance from this node to furthest leaf. This is always 0 for nodes
 **   of type FTS5_STRING and FTS5_TERM. For all other nodes it is one
@@ -234923,11 +238702,12 @@ static int sqlite3Fts5ExprNew(
   }while( sParse.rc==SQLITE_OK && t!=FTS5_EOF );
   sqlite3Fts5ParserFree(pEngine, fts5ParseFree);
 
+  assert( sParse.pExpr || sParse.rc!=SQLITE_OK );
   assert_expr_depth_ok(sParse.rc, sParse.pExpr);
 
   /* If the LHS of the MATCH expression was a user column, apply the
   ** implicit column-filter.  */
-  if( iCol<pConfig->nCol && sParse.pExpr && sParse.rc==SQLITE_OK ){
+  if( sParse.rc==SQLITE_OK && iCol<pConfig->nCol ){
     int n = sizeof(Fts5Colset);
     Fts5Colset *pColset = (Fts5Colset*)sqlite3Fts5MallocZero(&sParse.rc, n);
     if( pColset ){
@@ -234944,15 +238724,7 @@ static int sqlite3Fts5ExprNew(
       sParse.rc = SQLITE_NOMEM;
       sqlite3Fts5ParseNodeFree(sParse.pExpr);
     }else{
-      if( !sParse.pExpr ){
-        const int nByte = sizeof(Fts5ExprNode);
-        pNew->pRoot = (Fts5ExprNode*)sqlite3Fts5MallocZero(&sParse.rc, nByte);
-        if( pNew->pRoot ){
-          pNew->pRoot->bEof = 1;
-        }
-      }else{
-        pNew->pRoot = sParse.pExpr;
-      }
+      pNew->pRoot = sParse.pExpr;
       pNew->pIndex = 0;
       pNew->pConfig = pConfig;
       pNew->apExprPhrase = sParse.apPhrase;
@@ -234965,7 +238737,11 @@ static int sqlite3Fts5ExprNew(
   }
 
   sqlite3_free(sParse.apPhrase);
-  *pzErr = sParse.zErr;
+  if( 0==*pzErr ){
+    *pzErr = sParse.zErr;
+  }else{
+    sqlite3_free(sParse.zErr);
+  }
   return sParse.rc;
 }
 
@@ -235766,7 +239542,7 @@ static int fts5ExprNodeTest_STRING(
           }
         }else{
           Fts5IndexIter *pIter = pPhrase->aTerm[j].pIter;
-          if( pIter->iRowid==iLast || pIter->bEof ) continue;
+          if( pIter->iRowid==iLast ) continue;
           bMatch = 0;
           if( fts5ExprAdvanceto(pIter, bDesc, &iLast, &rc, &pNode->bEof) ){
             return rc;
@@ -236288,9 +240064,6 @@ static Fts5ExprNearset *sqlite3Fts5ParseNearset(
   Fts5ExprNearset *pRet = 0;
 
   if( pParse->rc==SQLITE_OK ){
-    if( pPhrase==0 ){
-      return pNear;
-    }
     if( pNear==0 ){
       sqlite3_int64 nByte;
       nByte = sizeof(Fts5ExprNearset) + SZALLOC * sizeof(Fts5ExprPhrase*);
@@ -236512,6 +240285,7 @@ static Fts5ExprPhrase *sqlite3Fts5ParseTerm(
     }else if( sCtx.pPhrase->nTerm ){
       sCtx.pPhrase->aTerm[sCtx.pPhrase->nTerm-1].bPrefix = (u8)bPrefix;
     }
+    assert( pParse->apPhrase!=0 );
     pParse->apPhrase[pParse->nPhrase-1] = sCtx.pPhrase;
   }
 
@@ -236531,7 +240305,7 @@ static int sqlite3Fts5ExprClonePhrase(
   Fts5ExprPhrase *pOrig = 0;      /* The phrase extracted from pExpr */
   Fts5Expr *pNew = 0;             /* Expression to return via *ppNew */
   TokenCtx sCtx = {0,0,0};        /* Context object for fts5ParseTokenize */
-  if( iPhrase<0 || iPhrase>=pExpr->nPhrase ){
+  if( !pExpr || iPhrase<0 || iPhrase>=pExpr->nPhrase ){
     rc = SQLITE_RANGE;
   }else{
     pOrig = pExpr->apExprPhrase[iPhrase];
@@ -236899,6 +240673,9 @@ static void fts5ExprAssignXNext(Fts5ExprNode *pNode){
   }
 }
 
+/*
+** Add pSub as a child of p.
+*/
 static void fts5ExprAddChildren(Fts5ExprNode *p, Fts5ExprNode *pSub){
   int ii = p->nChild;
   if( p->eType!=FTS5_NOT && pSub->eType==p->eType ){
@@ -237043,19 +240820,23 @@ static Fts5ExprNode *sqlite3Fts5ParseNode(
                   "fts5: %s queries are not supported (detail!=full)",
                   pNear->nPhrase==1 ? "phrase": "NEAR"
               );
-              sqlite3_free(pRet);
+              sqlite3Fts5ParseNodeFree(pRet);
               pRet = 0;
+              pNear = 0;
+              assert( pLeft==0 && pRight==0 );
             }
           }
         }else{
+          assert( pNear==0 );
           fts5ExprAddChildren(pRet, pLeft);
           fts5ExprAddChildren(pRet, pRight);
+          pLeft = pRight = 0;
           if( pRet->iHeight>SQLITE_FTS5_MAX_EXPR_DEPTH ){
             sqlite3Fts5ParseError(pParse,
                 "fts5 expression tree is too large (maximum depth %d)",
                 SQLITE_FTS5_MAX_EXPR_DEPTH
             );
-            sqlite3_free(pRet);
+            sqlite3Fts5ParseNodeFree(pRet);
             pRet = 0;
           }
         }
@@ -237093,6 +240874,7 @@ static Fts5ExprNode *sqlite3Fts5ParseImplicitAnd(
     assert( pRight->eType==FTS5_STRING
         || pRight->eType==FTS5_TERM
         || pRight->eType==FTS5_EOF
+        || (pRight->eType==FTS5_AND && pParse->bPhraseToAnd)
     );
 
     if( pLeft->eType==FTS5_AND ){
@@ -237106,6 +240888,8 @@ static Fts5ExprNode *sqlite3Fts5ParseImplicitAnd(
         );
 
     if( pRight->eType==FTS5_EOF ){
+      assert( pParse->apPhrase!=0 );
+      assert( pParse->nPhrase>0 );
       assert( pParse->apPhrase[pParse->nPhrase-1]==pRight->pNear->apPhrase[0] );
       sqlite3Fts5ParseNodeFree(pRight);
       pRet = pLeft;
@@ -237738,6 +241522,7 @@ static int fts5ExprCheckPoslists(Fts5ExprNode *pNode, i64 iRowid){
   pNode->iRowid = iRowid;
   pNode->bEof = 0;
   switch( pNode->eType ){
+    case 0:
     case FTS5_TERM:
     case FTS5_STRING:
       return (pNode->pNear->apPhrase[0]->poslist.n>0);
@@ -239321,11 +243106,12 @@ static Fts5Data *fts5DataRead(Fts5Index *p, i64 iRowid){
     if( rc==SQLITE_OK ){
       u8 *aOut = 0;               /* Read blob data into this buffer */
       int nByte = sqlite3_blob_bytes(p->pReader);
-      sqlite3_int64 nAlloc = sizeof(Fts5Data) + nByte + FTS5_DATA_PADDING;
+      int szData = (sizeof(Fts5Data) + 7) & ~7;
+      sqlite3_int64 nAlloc = szData + nByte + FTS5_DATA_PADDING;
       pRet = (Fts5Data*)sqlite3_malloc64(nAlloc);
       if( pRet ){
         pRet->nn = nByte;
-        aOut = pRet->p = (u8*)&pRet[1];
+        aOut = pRet->p = (u8*)pRet + szData;
       }else{
         rc = SQLITE_NOMEM;
       }
@@ -239348,6 +243134,7 @@ static Fts5Data *fts5DataRead(Fts5Index *p, i64 iRowid){
   }
 
   assert( (pRet==0)==(p->rc!=SQLITE_OK) );
+  assert( pRet==0 || EIGHT_BYTE_ALIGNMENT( pRet->p ) );
   return pRet;
 }
 
@@ -240673,7 +244460,7 @@ static void fts5SegIterNext_None(
 
   if( iOff<pIter->iEndofDoclist ){
     /* Next entry is on the current page */
-    i64 iDelta;
+    u64 iDelta;
     iOff += sqlite3Fts5GetVarint(&pIter->pLeaf->p[iOff], (u64*)&iDelta);
     pIter->iLeafOffset = iOff;
     pIter->iRowid += iDelta;
@@ -243377,6 +247164,11 @@ static int fts5IndexFindDeleteMerge(Fts5Index *p, Fts5Structure *pStruct){
           nBest = nPercent;
         }
       }
+
+      /* If pLvl is already the input level to an ongoing merge, look no
+      ** further for a merge candidate. The caller should be allowed to
+      ** continue merging from pLvl first.  */
+      if( pLvl->nMerge ) break;
     }
   }
   return iRet;
@@ -245327,23 +249119,26 @@ static void fts5IterSetOutputsTokendata(Fts5Iter *pIter){
 static void fts5TokendataIterNext(Fts5Iter *pIter, int bFrom, i64 iFrom){
   int ii;
   Fts5TokenDataIter *pT = pIter->pTokenDataIter;
+  Fts5Index *pIndex = pIter->pIndex;
 
   for(ii=0; ii<pT->nIter; ii++){
     Fts5Iter *p = pT->apIter[ii];
     if( p->base.bEof==0
      && (p->base.iRowid==pIter->base.iRowid || (bFrom && p->base.iRowid<iFrom))
     ){
-      fts5MultiIterNext(p->pIndex, p, bFrom, iFrom);
+      fts5MultiIterNext(pIndex, p, bFrom, iFrom);
       while( bFrom && p->base.bEof==0
           && p->base.iRowid<iFrom
-          && p->pIndex->rc==SQLITE_OK
+          && pIndex->rc==SQLITE_OK
       ){
-        fts5MultiIterNext(p->pIndex, p, 0, 0);
+        fts5MultiIterNext(pIndex, p, 0, 0);
       }
     }
   }
 
-  fts5IterSetOutputsTokendata(pIter);
+  if( pIndex->rc==SQLITE_OK ){
+    fts5IterSetOutputsTokendata(pIter);
+  }
 }
 
 /*
@@ -247298,7 +251093,7 @@ static int fts5structConnectMethod(
 
 /*
 ** We must have a single struct=? constraint that will be passed through
-** into the xFilter method.  If there is no valid stmt=? constraint,
+** into the xFilter method.  If there is no valid struct=? constraint,
 ** then return an SQLITE_CONSTRAINT error.
 */
 static int fts5structBestIndexMethod(
@@ -247640,8 +251435,17 @@ struct Fts5Global {
   Fts5TokenizerModule *pTok;      /* First in list of all tokenizer modules */
   Fts5TokenizerModule *pDfltTok;  /* Default tokenizer module */
   Fts5Cursor *pCsr;               /* First in list of all open cursors */
+  u32 aLocaleHdr[4];
 };
 
+/*
+** Size of header on fts5_locale() values. And macro to access a buffer
+** containing a copy of the header from an Fts5Config pointer.
+*/
+#define FTS5_LOCALE_HDR_SIZE ((int)sizeof( ((Fts5Global*)0)->aLocaleHdr ))
+#define FTS5_LOCALE_HDR(pConfig) ((const u8*)(pConfig->pGlobal->aLocaleHdr))
+
+
 /*
 ** Each auxiliary function registered with the FTS5 module is represented
 ** by an object of the following type. All such objects are stored as part
@@ -247660,11 +251464,28 @@ struct Fts5Auxiliary {
 ** Each tokenizer module registered with the FTS5 module is represented
 ** by an object of the following type. All such objects are stored as part
 ** of the Fts5Global.pTok list.
+**
+** bV2Native:
+**  True if the tokenizer was registered using xCreateTokenizer_v2(), false
+**  for xCreateTokenizer(). If this variable is true, then x2 is populated
+**  with the routines as supplied by the caller and x1 contains synthesized
+**  wrapper routines. In this case the user-data pointer passed to
+**  x1.xCreate should be a pointer to the Fts5TokenizerModule structure,
+**  not a copy of pUserData.
+**
+**  Of course, if bV2Native is false, then x1 contains the real routines and
+**  x2 the synthesized ones. In this case a pointer to the Fts5TokenizerModule
+**  object should be passed to x2.xCreate.
+**
+**  The synthesized wrapper routines are necessary for xFindTokenizer(_v2)
+**  calls.
 */
 struct Fts5TokenizerModule {
   char *zName;                    /* Name of tokenizer */
   void *pUserData;                /* User pointer passed to xCreate() */
-  fts5_tokenizer x;               /* Tokenizer functions */
+  int bV2Native;                  /* True if v2 native tokenizer */
+  fts5_tokenizer x1;              /* Tokenizer functions */
+  fts5_tokenizer_v2 x2;           /* V2 tokenizer functions */
   void (*xDestroy)(void*);        /* Destructor function */
   Fts5TokenizerModule *pNext;     /* Next registered tokenizer module */
 };
@@ -247752,7 +251573,7 @@ struct Fts5Cursor {
   Fts5Auxiliary *pAux;            /* Currently executing extension function */
   Fts5Auxdata *pAuxdata;          /* First in linked list of saved aux-data */
 
-  /* Cache used by auxiliary functions xInst() and xInstCount() */
+  /* Cache used by auxiliary API functions xInst() and xInstCount() */
   Fts5PoslistReader *aInstIter;   /* One for each phrase */
   int nInstAlloc;                 /* Size of aInst[] array (entries / 3) */
   int nInstCount;                 /* Number of phrase instances */
@@ -247863,10 +251684,16 @@ static void fts5CheckTransactionState(Fts5FullTable *p, int op, int iSavepoint){
 #endif
 
 /*
-** Return true if pTab is a contentless table.
+** Return true if pTab is a contentless table. If parameter bIncludeUnindexed
+** is true, this includes contentless tables that store UNINDEXED columns
+** only.
 */
-static int fts5IsContentless(Fts5FullTable *pTab){
-  return pTab->p.pConfig->eContent==FTS5_CONTENT_NONE;
+static int fts5IsContentless(Fts5FullTable *pTab, int bIncludeUnindexed){
+  int eContent = pTab->p.pConfig->eContent;
+  return (
+    eContent==FTS5_CONTENT_NONE
+    || (bIncludeUnindexed && eContent==FTS5_CONTENT_UNINDEXED)
+  );
 }
 
 /*
@@ -247934,8 +251761,12 @@ static int fts5InitVtab(
     assert( (rc==SQLITE_OK && *pzErr==0) || pConfig==0 );
   }
   if( rc==SQLITE_OK ){
+    pConfig->pzErrmsg = pzErr;
     pTab->p.pConfig = pConfig;
     pTab->pGlobal = pGlobal;
+    if( bCreate || sqlite3Fts5TokenizerPreload(&pConfig->t) ){
+      rc = sqlite3Fts5LoadTokenizer(pConfig);
+    }
   }
 
   /* Open the index sub-system */
@@ -247957,11 +251788,7 @@ static int fts5InitVtab(
 
   /* Load the initial configuration */
   if( rc==SQLITE_OK ){
-    assert( pConfig->pzErrmsg==0 );
-    pConfig->pzErrmsg = pzErr;
-    rc = sqlite3Fts5IndexLoadConfig(pTab->p.pIndex);
-    sqlite3Fts5IndexRollback(pTab->p.pIndex);
-    pConfig->pzErrmsg = 0;
+    rc = sqlite3Fts5ConfigLoad(pTab->p.pConfig, pTab->p.pConfig->iCookie-1);
   }
 
   if( rc==SQLITE_OK && pConfig->eContent==FTS5_CONTENT_NORMAL ){
@@ -247971,6 +251798,7 @@ static int fts5InitVtab(
     rc = sqlite3_vtab_config(db, SQLITE_VTAB_INNOCUOUS);
   }
 
+  if( pConfig ) pConfig->pzErrmsg = 0;
   if( rc!=SQLITE_OK ){
     fts5FreeVtab(pTab);
     pTab = 0;
@@ -248038,10 +251866,10 @@ static int fts5UsePatternMatch(
 ){
   assert( FTS5_PATTERN_GLOB==SQLITE_INDEX_CONSTRAINT_GLOB );
   assert( FTS5_PATTERN_LIKE==SQLITE_INDEX_CONSTRAINT_LIKE );
-  if( pConfig->ePattern==FTS5_PATTERN_GLOB && p->op==FTS5_PATTERN_GLOB ){
+  if( pConfig->t.ePattern==FTS5_PATTERN_GLOB && p->op==FTS5_PATTERN_GLOB ){
     return 1;
   }
-  if( pConfig->ePattern==FTS5_PATTERN_LIKE
+  if( pConfig->t.ePattern==FTS5_PATTERN_LIKE
    && (p->op==FTS5_PATTERN_LIKE || p->op==FTS5_PATTERN_GLOB)
   ){
     return 1;
@@ -248088,10 +251916,10 @@ static int fts5UsePatternMatch(
 ** This function ensures that there is at most one "r" or "=". And that if
 ** there exists an "=" then there is no "<" or ">".
 **
-** Costs are assigned as follows:
+** If an unusable MATCH operator is present in the WHERE clause, then
+** SQLITE_CONSTRAINT is returned.
 **
-**  a) If an unusable MATCH operator is present in the WHERE clause, the
-**     cost is unconditionally set to 1e50 (a really big number).
+** Costs are assigned as follows:
 **
 **  a) If a MATCH operator is present, the cost depends on the other
 **     constraints also present. As follows:
@@ -248124,7 +251952,7 @@ static int fts5BestIndexMethod(sqlite3_vtab *pVTab, sqlite3_index_info *pInfo){
   int bSeenEq = 0;
   int bSeenGt = 0;
   int bSeenLt = 0;
-  int bSeenMatch = 0;
+  int nSeenMatch = 0;
   int bSeenRank = 0;
 
 
@@ -248155,18 +251983,15 @@ static int fts5BestIndexMethod(sqlite3_vtab *pVTab, sqlite3_index_info *pInfo){
       /* A MATCH operator or equivalent */
       if( p->usable==0 || iCol<0 ){
         /* As there exists an unusable MATCH constraint this is an
-        ** unusable plan. Set a prohibitively high cost. */
-        pInfo->estimatedCost = 1e50;
-        assert( iIdxStr < pInfo->nConstraint*6 + 1 );
-        idxStr[iIdxStr] = 0;
-        return SQLITE_OK;
+        ** unusable plan. Return SQLITE_CONSTRAINT. */
+        return SQLITE_CONSTRAINT;
       }else{
         if( iCol==nCol+1 ){
           if( bSeenRank ) continue;
           idxStr[iIdxStr++] = 'r';
           bSeenRank = 1;
-        }else if( iCol>=0 ){
-          bSeenMatch = 1;
+        }else{
+          nSeenMatch++;
           idxStr[iIdxStr++] = 'M';
           sqlite3_snprintf(6, &idxStr[iIdxStr], "%d", iCol);
           idxStr += strlen(&idxStr[iIdxStr]);
@@ -248183,6 +252008,7 @@ static int fts5BestIndexMethod(sqlite3_vtab *pVTab, sqlite3_index_info *pInfo){
         idxStr += strlen(&idxStr[iIdxStr]);
         pInfo->aConstraintUsage[i].argvIndex = ++iCons;
         assert( idxStr[iIdxStr]=='\0' );
+        nSeenMatch++;
       }else if( bSeenEq==0 && p->op==SQLITE_INDEX_CONSTRAINT_EQ && iCol<0 ){
         idxStr[iIdxStr++] = '=';
         bSeenEq = 1;
@@ -248219,7 +252045,7 @@ static int fts5BestIndexMethod(sqlite3_vtab *pVTab, sqlite3_index_info *pInfo){
   */
   if( pInfo->nOrderBy==1 ){
     int iSort = pInfo->aOrderBy[0].iColumn;
-    if( iSort==(pConfig->nCol+1) && bSeenMatch ){
+    if( iSort==(pConfig->nCol+1) && nSeenMatch>0 ){
       idxFlags |= FTS5_BI_ORDER_RANK;
     }else if( iSort==-1 && (!pInfo->aOrderBy[0].desc || !pConfig->bTokendata) ){
       idxFlags |= FTS5_BI_ORDER_ROWID;
@@ -248234,14 +252060,17 @@ static int fts5BestIndexMethod(sqlite3_vtab *pVTab, sqlite3_index_info *pInfo){
 
   /* Calculate the estimated cost based on the flags set in idxFlags. */
   if( bSeenEq ){
-    pInfo->estimatedCost = bSeenMatch ? 100.0 : 10.0;
-    if( bSeenMatch==0 ) fts5SetUniqueFlag(pInfo);
+    pInfo->estimatedCost = nSeenMatch ? 1000.0 : 10.0;
+    if( nSeenMatch==0 ) fts5SetUniqueFlag(pInfo);
   }else if( bSeenLt && bSeenGt ){
-    pInfo->estimatedCost = bSeenMatch ? 500.0 : 250000.0;
+    pInfo->estimatedCost = nSeenMatch ? 5000.0 : 250000.0;
   }else if( bSeenLt || bSeenGt ){
-    pInfo->estimatedCost = bSeenMatch ? 750.0 : 750000.0;
+    pInfo->estimatedCost = nSeenMatch ? 7500.0 : 750000.0;
   }else{
-    pInfo->estimatedCost = bSeenMatch ? 1000.0 : 1000000.0;
+    pInfo->estimatedCost = nSeenMatch ? 10000.0 : 1000000.0;
+  }
+  for(i=1; i<nSeenMatch; i++){
+    pInfo->estimatedCost *= 0.4;
   }
 
   pInfo->idxNum = idxFlags;
@@ -248517,6 +252346,7 @@ static int fts5NextMethod(sqlite3_vtab_cursor *pCursor){
           }
         }else{
           rc = SQLITE_OK;
+          CsrFlagSet(pCsr, FTS5CSR_REQUIRE_DOCSIZE);
         }
         break;
       }
@@ -248546,7 +252376,7 @@ static int fts5PrepareStatement(
     rc = sqlite3_prepare_v3(pConfig->db, zSql, -1,
                             SQLITE_PREPARE_PERSISTENT, &pRet, 0);
     if( rc!=SQLITE_OK ){
-      *pConfig->pzErrmsg = sqlite3_mprintf("%s", sqlite3_errmsg(pConfig->db));
+      sqlite3Fts5ConfigErrmsg(pConfig, "%s", sqlite3_errmsg(pConfig->db));
     }
     sqlite3_free(zSql);
   }
@@ -248770,6 +252600,145 @@ static i64 fts5GetRowidLimit(sqlite3_value *pVal, i64 iDefault){
   return iDefault;
 }
 
+/*
+** Set the error message on the virtual table passed as the first argument.
+*/
+static void fts5SetVtabError(Fts5FullTable *p, const char *zFormat, ...){
+  va_list ap;                     /* ... printf arguments */
+  va_start(ap, zFormat);
+  sqlite3_free(p->p.base.zErrMsg);
+  p->p.base.zErrMsg = sqlite3_vmprintf(zFormat, ap);
+  va_end(ap);
+}
+
+/*
+** Arrange for subsequent calls to sqlite3Fts5Tokenize() to use the locale
+** specified by pLocale/nLocale. The buffer indicated by pLocale must remain
+** valid until after the final call to sqlite3Fts5Tokenize() that will use
+** the locale.
+*/
+static void sqlite3Fts5SetLocale(
+  Fts5Config *pConfig,
+  const char *zLocale,
+  int nLocale
+){
+  Fts5TokenizerConfig *pT = &pConfig->t;
+  pT->pLocale = zLocale;
+  pT->nLocale = nLocale;
+}
+
+/*
+** Clear any locale configured by an earlier call to sqlite3Fts5SetLocale().
+*/
+static void sqlite3Fts5ClearLocale(Fts5Config *pConfig){
+  sqlite3Fts5SetLocale(pConfig, 0, 0);
+}
+
+/*
+** Return true if the value passed as the only argument is an
+** fts5_locale() value.
+*/
+static int sqlite3Fts5IsLocaleValue(Fts5Config *pConfig, sqlite3_value *pVal){
+  int ret = 0;
+  if( sqlite3_value_type(pVal)==SQLITE_BLOB ){
+    /* Call sqlite3_value_bytes() after sqlite3_value_blob() in this case.
+    ** If the blob was created using zeroblob(), then sqlite3_value_blob()
+    ** may call malloc(). If this malloc() fails, then the values returned
+    ** by both value_blob() and value_bytes() will be 0. If value_bytes() were
+    ** called first, then the NULL pointer returned by value_blob() might
+    ** be dereferenced.  */
+    const u8 *pBlob = sqlite3_value_blob(pVal);
+    int nBlob = sqlite3_value_bytes(pVal);
+    if( nBlob>FTS5_LOCALE_HDR_SIZE
+     && 0==memcmp(pBlob, FTS5_LOCALE_HDR(pConfig), FTS5_LOCALE_HDR_SIZE)
+    ){
+      ret = 1;
+    }
+  }
+  return ret;
+}
+
+/*
+** Value pVal is guaranteed to be an fts5_locale() value, according to
+** sqlite3Fts5IsLocaleValue(). This function extracts the text and locale
+** from the value and returns them separately.
+**
+** If successful, SQLITE_OK is returned and (*ppText) and (*ppLoc) set
+** to point to buffers containing the text and locale, as utf-8,
+** respectively. In this case output parameters (*pnText) and (*pnLoc) are
+** set to the sizes in bytes of these two buffers.
+**
+** Or, if an error occurs, then an SQLite error code is returned. The final
+** value of the four output parameters is undefined in this case.
+*/
+static int sqlite3Fts5DecodeLocaleValue(
+  sqlite3_value *pVal,
+  const char **ppText,
+  int *pnText,
+  const char **ppLoc,
+  int *pnLoc
+){
+  const char *p = sqlite3_value_blob(pVal);
+  int n = sqlite3_value_bytes(pVal);
+  int nLoc = 0;
+
+  assert( sqlite3_value_type(pVal)==SQLITE_BLOB );
+  assert( n>FTS5_LOCALE_HDR_SIZE );
+
+  for(nLoc=FTS5_LOCALE_HDR_SIZE; p[nLoc]; nLoc++){
+    if( nLoc==(n-1) ){
+      return SQLITE_MISMATCH;
+    }
+  }
+  *ppLoc = &p[FTS5_LOCALE_HDR_SIZE];
+  *pnLoc = nLoc - FTS5_LOCALE_HDR_SIZE;
+
+  *ppText = &p[nLoc+1];
+  *pnText = n - nLoc - 1;
+  return SQLITE_OK;
+}
+
+/*
+** Argument pVal is the text of a full-text search expression. It may or
+** may not have been wrapped by fts5_locale(). This function extracts
+** the text of the expression, and sets output variable (*pzText) to
+** point to a nul-terminated buffer containing the expression.
+**
+** If pVal was an fts5_locale() value, then sqlite3Fts5SetLocale() is called
+** to set the tokenizer to use the specified locale.
+**
+** If output variable (*pbFreeAndReset) is set to true, then the caller
+** is required to (a) call sqlite3Fts5ClearLocale() to reset the tokenizer
+** locale, and (b) call sqlite3_free() to free (*pzText).
+*/
+static int fts5ExtractExprText(
+  Fts5Config *pConfig,            /* Fts5 configuration */
+  sqlite3_value *pVal,            /* Value to extract expression text from */
+  char **pzText,                  /* OUT: nul-terminated buffer of text */
+  int *pbFreeAndReset             /* OUT: Free (*pzText) and clear locale */
+){
+  int rc = SQLITE_OK;
+
+  if( sqlite3Fts5IsLocaleValue(pConfig, pVal) ){
+    const char *pText = 0;
+    int nText = 0;
+    const char *pLoc = 0;
+    int nLoc = 0;
+    rc = sqlite3Fts5DecodeLocaleValue(pVal, &pText, &nText, &pLoc, &nLoc);
+    *pzText = sqlite3Fts5Mprintf(&rc, "%.*s", nText, pText);
+    if( rc==SQLITE_OK ){
+      sqlite3Fts5SetLocale(pConfig, pLoc, nLoc);
+    }
+    *pbFreeAndReset = 1;
+  }else{
+    *pzText = (char*)sqlite3_value_text(pVal);
+    *pbFreeAndReset = 0;
+  }
+
+  return rc;
+}
+
+
 /*
 ** This is the xFilter interface for the virtual table.  See
 ** the virtual table xFilter method documentation for additional
@@ -248804,13 +252773,7 @@ static int fts5FilterMethod(
   int iIdxStr = 0;
   Fts5Expr *pExpr = 0;
 
-  if( pConfig->bLock ){
-    pTab->p.base.zErrMsg = sqlite3_mprintf(
-        "recursively defined fts5 content table"
-    );
-    return SQLITE_ERROR;
-  }
-
+  assert( pConfig->bLock==0 );
   if( pCsr->ePlan ){
     fts5FreeCursorComponents(pCsr);
     memset(&pCsr->ePlan, 0, sizeof(Fts5Cursor) - ((u8*)&pCsr->ePlan-(u8*)pCsr));
@@ -248834,8 +252797,14 @@ static int fts5FilterMethod(
         pRank = apVal[i];
         break;
       case 'M': {
-        const char *zText = (const char*)sqlite3_value_text(apVal[i]);
+        char *zText = 0;
+        int bFreeAndReset = 0;
+        int bInternal = 0;
+
+        rc = fts5ExtractExprText(pConfig, apVal[i], &zText, &bFreeAndReset);
+        if( rc!=SQLITE_OK ) goto filter_out;
         if( zText==0 ) zText = "";
+
         iCol = 0;
         do{
           iCol = iCol*10 + (idxStr[iIdxStr]-'0');
@@ -248847,7 +252816,7 @@ static int fts5FilterMethod(
           ** indicates that the MATCH expression is not a full text query,
           ** but a request for an internal parameter.  */
           rc = fts5SpecialMatch(pTab, pCsr, &zText[1]);
-          goto filter_out;
+          bInternal = 1;
         }else{
           char **pzErr = &pTab->p.base.zErrMsg;
           rc = sqlite3Fts5ExprNew(pConfig, 0, iCol, zText, &pExpr, pzErr);
@@ -248855,9 +252824,15 @@ static int fts5FilterMethod(
             rc = sqlite3Fts5ExprAnd(&pCsr->pExpr, pExpr);
             pExpr = 0;
           }
-          if( rc!=SQLITE_OK ) goto filter_out;
         }
 
+        if( bFreeAndReset ){
+          sqlite3_free(zText);
+          sqlite3Fts5ClearLocale(pConfig);
+        }
+
+        if( bInternal || rc!=SQLITE_OK ) goto filter_out;
+
         break;
       }
       case 'L':
@@ -248945,9 +252920,7 @@ static int fts5FilterMethod(
       }
     }
   }else if( pConfig->zContent==0 ){
-    *pConfig->pzErrmsg = sqlite3_mprintf(
-        "%s: table does not support scanning", pConfig->zName
-    );
+    fts5SetVtabError(pTab,"%s: table does not support scanning",pConfig->zName);
     rc = SQLITE_ERROR;
   }else{
     /* This is either a full-table scan (ePlan==FTS5_PLAN_SCAN) or a lookup
@@ -248990,9 +252963,13 @@ static i64 fts5CursorRowid(Fts5Cursor *pCsr){
   assert( pCsr->ePlan==FTS5_PLAN_MATCH
        || pCsr->ePlan==FTS5_PLAN_SORTED_MATCH
        || pCsr->ePlan==FTS5_PLAN_SOURCE
+       || pCsr->ePlan==FTS5_PLAN_SCAN
+       || pCsr->ePlan==FTS5_PLAN_ROWID
   );
   if( pCsr->pSorter ){
     return pCsr->pSorter->iRowid;
+  }else if( pCsr->ePlan>=FTS5_PLAN_SCAN ){
+    return sqlite3_column_int64(pCsr->pStmt, 0);
   }else{
     return sqlite3Fts5ExprRowid(pCsr->pExpr);
   }
@@ -249009,25 +252986,16 @@ static int fts5RowidMethod(sqlite3_vtab_cursor *pCursor, sqlite_int64 *pRowid){
   int ePlan = pCsr->ePlan;
 
   assert( CsrFlagTest(pCsr, FTS5CSR_EOF)==0 );
-  switch( ePlan ){
-    case FTS5_PLAN_SPECIAL:
-      *pRowid = 0;
-      break;
-
-    case FTS5_PLAN_SOURCE:
-    case FTS5_PLAN_MATCH:
-    case FTS5_PLAN_SORTED_MATCH:
-      *pRowid = fts5CursorRowid(pCsr);
-      break;
-
-    default:
-      *pRowid = sqlite3_column_int64(pCsr->pStmt, 0);
-      break;
+  if( ePlan==FTS5_PLAN_SPECIAL ){
+    *pRowid = 0;
+  }else{
+    *pRowid = fts5CursorRowid(pCsr);
   }
 
   return SQLITE_OK;
 }
 
+
 /*
 ** If the cursor requires seeking (bSeekRequired flag is set), seek it.
 ** Return SQLITE_OK if no error occurs, or an SQLite error code otherwise.
@@ -249064,8 +253032,13 @@ static int fts5SeekCursor(Fts5Cursor *pCsr, int bErrormsg){
       rc = sqlite3_reset(pCsr->pStmt);
       if( rc==SQLITE_OK ){
         rc = FTS5_CORRUPT;
+        fts5SetVtabError((Fts5FullTable*)pTab,
+            "fts5: missing row %lld from content table %s",
+            fts5CursorRowid(pCsr),
+            pTab->pConfig->zContent
+        );
       }else if( pTab->pConfig->pzErrmsg ){
-        *pTab->pConfig->pzErrmsg = sqlite3_mprintf(
+        fts5SetVtabError((Fts5FullTable*)pTab,
             "%s", sqlite3_errmsg(pTab->pConfig->db)
         );
       }
@@ -249074,14 +253047,6 @@ static int fts5SeekCursor(Fts5Cursor *pCsr, int bErrormsg){
   return rc;
 }
 
-static void fts5SetVtabError(Fts5FullTable *p, const char *zFormat, ...){
-  va_list ap;                     /* ... printf arguments */
-  va_start(ap, zFormat);
-  assert( p->p.base.zErrMsg==0 );
-  p->p.base.zErrMsg = sqlite3_vmprintf(zFormat, ap);
-  va_end(ap);
-}
-
 /*
 ** This function is called to handle an FTS INSERT command. In other words,
 ** an INSERT statement of the form:
@@ -249119,7 +253084,7 @@ static int fts5SpecialInsert(
     }
     bLoadConfig = 1;
   }else if( 0==sqlite3_stricmp("rebuild", zCmd) ){
-    if( pConfig->eContent==FTS5_CONTENT_NONE ){
+    if( fts5IsContentless(pTab, 1) ){
       fts5SetVtabError(pTab,
           "'rebuild' may not be used with a contentless fts5 table"
       );
@@ -249175,7 +253140,7 @@ static int fts5SpecialDelete(
   int eType1 = sqlite3_value_type(apVal[1]);
   if( eType1==SQLITE_INTEGER ){
     sqlite3_int64 iDel = sqlite3_value_int64(apVal[1]);
-    rc = sqlite3Fts5StorageDelete(pTab->pStorage, iDel, &apVal[2]);
+    rc = sqlite3Fts5StorageDelete(pTab->pStorage, iDel, &apVal[2], 0);
   }
   return rc;
 }
@@ -249188,7 +253153,7 @@ static void fts5StorageInsert(
 ){
   int rc = *pRc;
   if( rc==SQLITE_OK ){
-    rc = sqlite3Fts5StorageContentInsert(pTab->pStorage, apVal, piRowid);
+    rc = sqlite3Fts5StorageContentInsert(pTab->pStorage, 0, apVal, piRowid);
   }
   if( rc==SQLITE_OK ){
     rc = sqlite3Fts5StorageIndexInsert(pTab->pStorage, apVal, *piRowid);
@@ -249196,6 +253161,67 @@ static void fts5StorageInsert(
   *pRc = rc;
 }
 
+/*
+**
+** This function is called when the user attempts an UPDATE on a contentless
+** table. Parameter bRowidModified is true if the UPDATE statement modifies
+** the rowid value. Parameter apVal[] contains the new values for each user
+** defined column of the fts5 table. pConfig is the configuration object of the
+** table being updated (guaranteed to be contentless). The contentless_delete=1
+** and contentless_unindexed=1 options may or may not be set.
+**
+** This function returns SQLITE_OK if the UPDATE can go ahead, or an SQLite
+** error code if it cannot. In this case an error message is also loaded into
+** pConfig. Output parameter (*pbContent) is set to true if the caller should
+** update the %_content table only - not the FTS index or any other shadow
+** table. This occurs when an UPDATE modifies only UNINDEXED columns of the
+** table.
+**
+** An UPDATE may proceed if:
+**
+**   * The only columns modified are UNINDEXED columns, or
+**
+**   * The contentless_delete=1 option was specified and all of the indexed
+**     columns (not a subset) have been modified.
+*/
+static int fts5ContentlessUpdate(
+  Fts5Config *pConfig,
+  sqlite3_value **apVal,
+  int bRowidModified,
+  int *pbContent
+){
+  int ii;
+  int bSeenIndex = 0;             /* Have seen modified indexed column */
+  int bSeenIndexNC = 0;           /* Have seen unmodified indexed column */
+  int rc = SQLITE_OK;
+
+  for(ii=0; ii<pConfig->nCol; ii++){
+    if( pConfig->abUnindexed[ii]==0 ){
+      if( sqlite3_value_nochange(apVal[ii]) ){
+        bSeenIndexNC++;
+      }else{
+        bSeenIndex++;
+      }
+    }
+  }
+
+  if( bSeenIndex==0 && bRowidModified==0 ){
+    *pbContent = 1;
+  }else{
+    if( bSeenIndexNC || pConfig->bContentlessDelete==0 ){
+      rc = SQLITE_ERROR;
+      sqlite3Fts5ConfigErrmsg(pConfig,
+          (pConfig->bContentlessDelete ?
+          "%s a subset of columns on fts5 contentless-delete table: %s" :
+          "%s contentless fts5 table: %s")
+          , "cannot UPDATE", pConfig->zName
+      );
+    }
+  }
+
+  return rc;
+}
+
 /*
 ** This function is the implementation of the xUpdate callback used by
 ** FTS3 virtual tables. It is invoked by SQLite each time a row is to be
@@ -249257,6 +253283,7 @@ static int fts5UpdateMethod(
         rc = SQLITE_ERROR;
       }else{
         rc = fts5SpecialDelete(pTab, apVal);
+        bUpdateOrDelete = 1;
       }
     }else{
       rc = fts5SpecialInsert(pTab, z, apVal[2 + pConfig->nCol + 1]);
@@ -249281,41 +253308,46 @@ static int fts5UpdateMethod(
     assert( eType0==SQLITE_INTEGER || eType0==SQLITE_NULL );
     assert( nArg!=1 || eType0==SQLITE_INTEGER );
 
-    /* Filter out attempts to run UPDATE or DELETE on contentless tables.
-    ** This is not suported. Except - they are both supported if the CREATE
-    ** VIRTUAL TABLE statement contained "contentless_delete=1". */
-    if( eType0==SQLITE_INTEGER
-     && pConfig->eContent==FTS5_CONTENT_NONE
-     && pConfig->bContentlessDelete==0
-    ){
-      pTab->p.base.zErrMsg = sqlite3_mprintf(
-          "cannot %s contentless fts5 table: %s",
-          (nArg>1 ? "UPDATE" : "DELETE from"), pConfig->zName
-      );
-      rc = SQLITE_ERROR;
-    }
-
     /* DELETE */
-    else if( nArg==1 ){
-      i64 iDel = sqlite3_value_int64(apVal[0]);  /* Rowid to delete */
-      rc = sqlite3Fts5StorageDelete(pTab->pStorage, iDel, 0);
-      bUpdateOrDelete = 1;
+    if( nArg==1 ){
+      /* It is only possible to DELETE from a contentless table if the
+      ** contentless_delete=1 flag is set. */
+      if( fts5IsContentless(pTab, 1) && pConfig->bContentlessDelete==0 ){
+        fts5SetVtabError(pTab,
+            "cannot DELETE from contentless fts5 table: %s", pConfig->zName
+        );
+        rc = SQLITE_ERROR;
+      }else{
+        i64 iDel = sqlite3_value_int64(apVal[0]);  /* Rowid to delete */
+        rc = sqlite3Fts5StorageDelete(pTab->pStorage, iDel, 0, 0);
+        bUpdateOrDelete = 1;
+      }
     }
 
     /* INSERT or UPDATE */
     else{
       int eType1 = sqlite3_value_numeric_type(apVal[1]);
 
-      if( eType1!=SQLITE_INTEGER && eType1!=SQLITE_NULL ){
-        rc = SQLITE_MISMATCH;
+      /* It is an error to write an fts5_locale() value to a table without
+      ** the locale=1 option. */
+      if( pConfig->bLocale==0 ){
+        int ii;
+        for(ii=0; ii<pConfig->nCol; ii++){
+          sqlite3_value *pVal = apVal[ii+2];
+          if( sqlite3Fts5IsLocaleValue(pConfig, pVal) ){
+            fts5SetVtabError(pTab, "fts5_locale() requires locale=1");
+            rc = SQLITE_MISMATCH;
+            goto update_out;
+          }
+        }
       }
 
-      else if( eType0!=SQLITE_INTEGER ){
+      if( eType0!=SQLITE_INTEGER ){
         /* An INSERT statement. If the conflict-mode is REPLACE, first remove
         ** the current entry (if any). */
         if( eConflict==SQLITE_REPLACE && eType1==SQLITE_INTEGER ){
           i64 iNew = sqlite3_value_int64(apVal[1]);  /* Rowid to delete */
-          rc = sqlite3Fts5StorageDelete(pTab->pStorage, iNew, 0);
+          rc = sqlite3Fts5StorageDelete(pTab->pStorage, iNew, 0, 0);
           bUpdateOrDelete = 1;
         }
         fts5StorageInsert(&rc, pTab, apVal, pRowid);
@@ -249323,30 +253355,57 @@ static int fts5UpdateMethod(
 
       /* UPDATE */
       else{
+        Fts5Storage *pStorage = pTab->pStorage;
         i64 iOld = sqlite3_value_int64(apVal[0]);  /* Old rowid */
         i64 iNew = sqlite3_value_int64(apVal[1]);  /* New rowid */
-        if( eType1==SQLITE_INTEGER && iOld!=iNew ){
+        int bContent = 0;         /* Content only update */
+
+        /* If this is a contentless table (including contentless_unindexed=1
+        ** tables), check if the UPDATE may proceed.  */
+        if( fts5IsContentless(pTab, 1) ){
+          rc = fts5ContentlessUpdate(pConfig, &apVal[2], iOld!=iNew, &bContent);
+          if( rc!=SQLITE_OK ) goto update_out;
+        }
+
+        if( eType1!=SQLITE_INTEGER ){
+          rc = SQLITE_MISMATCH;
+        }else if( iOld!=iNew ){
+          assert( bContent==0 );
           if( eConflict==SQLITE_REPLACE ){
-            rc = sqlite3Fts5StorageDelete(pTab->pStorage, iOld, 0);
+            rc = sqlite3Fts5StorageDelete(pStorage, iOld, 0, 1);
             if( rc==SQLITE_OK ){
-              rc = sqlite3Fts5StorageDelete(pTab->pStorage, iNew, 0);
+              rc = sqlite3Fts5StorageDelete(pStorage, iNew, 0, 0);
             }
             fts5StorageInsert(&rc, pTab, apVal, pRowid);
           }else{
-            rc = sqlite3Fts5StorageContentInsert(pTab->pStorage, apVal, pRowid);
+            rc = sqlite3Fts5StorageFindDeleteRow(pStorage, iOld);
             if( rc==SQLITE_OK ){
-              rc = sqlite3Fts5StorageDelete(pTab->pStorage, iOld, 0);
+              rc = sqlite3Fts5StorageContentInsert(pStorage, 0, apVal, pRowid);
             }
             if( rc==SQLITE_OK ){
-              rc = sqlite3Fts5StorageIndexInsert(pTab->pStorage, apVal,*pRowid);
+              rc = sqlite3Fts5StorageDelete(pStorage, iOld, 0, 0);
+            }
+            if( rc==SQLITE_OK ){
+              rc = sqlite3Fts5StorageIndexInsert(pStorage, apVal, *pRowid);
             }
           }
+        }else if( bContent ){
+          /* This occurs when an UPDATE on a contentless table affects *only*
+          ** UNINDEXED columns. This is a no-op for contentless_unindexed=0
+          ** tables, or a write to the %_content table only for =1 tables.  */
+          assert( fts5IsContentless(pTab, 1) );
+          rc = sqlite3Fts5StorageFindDeleteRow(pStorage, iOld);
+          if( rc==SQLITE_OK ){
+            rc = sqlite3Fts5StorageContentInsert(pStorage, 1, apVal, pRowid);
+          }
         }else{
-          rc = sqlite3Fts5StorageDelete(pTab->pStorage, iOld, 0);
+          rc = sqlite3Fts5StorageDelete(pStorage, iOld, 0, 1);
           fts5StorageInsert(&rc, pTab, apVal, pRowid);
         }
         bUpdateOrDelete = 1;
+        sqlite3Fts5StorageReleaseDeleteRow(pStorage);
       }
+
     }
   }
 
@@ -249363,6 +253422,7 @@ static int fts5UpdateMethod(
     }
   }
 
+ update_out:
   pTab->p.pConfig->pzErrmsg = 0;
   return rc;
 }
@@ -249384,9 +253444,11 @@ static int fts5SyncMethod(sqlite3_vtab *pVtab){
 ** Implementation of xBegin() method.
 */
 static int fts5BeginMethod(sqlite3_vtab *pVtab){
-  fts5CheckTransactionState((Fts5FullTable*)pVtab, FTS5_BEGIN, 0);
-  fts5NewTransaction((Fts5FullTable*)pVtab);
-  return SQLITE_OK;
+  int rc = fts5NewTransaction((Fts5FullTable*)pVtab);
+  if( rc==SQLITE_OK ){
+    fts5CheckTransactionState((Fts5FullTable*)pVtab, FTS5_BEGIN, 0);
+  }
+  return rc;
 }
 
 /*
@@ -249440,17 +253502,40 @@ static int fts5ApiRowCount(Fts5Context *pCtx, i64 *pnRow){
   return sqlite3Fts5StorageRowCount(pTab->pStorage, pnRow);
 }
 
+/*
+** Implementation of xTokenize_v2() API.
+*/
+static int fts5ApiTokenize_v2(
+  Fts5Context *pCtx,
+  const char *pText, int nText,
+  const char *pLoc, int nLoc,
+  void *pUserData,
+  int (*xToken)(void*, int, const char*, int, int, int)
+){
+  Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
+  Fts5Table *pTab = (Fts5Table*)(pCsr->base.pVtab);
+  int rc = SQLITE_OK;
+
+  sqlite3Fts5SetLocale(pTab->pConfig, pLoc, nLoc);
+  rc = sqlite3Fts5Tokenize(pTab->pConfig,
+      FTS5_TOKENIZE_AUX, pText, nText, pUserData, xToken
+  );
+  sqlite3Fts5SetLocale(pTab->pConfig, 0, 0);
+
+  return rc;
+}
+
+/*
+** Implementation of xTokenize() API. This is just xTokenize_v2() with NULL/0
+** passed as the locale.
+*/
 static int fts5ApiTokenize(
   Fts5Context *pCtx,
   const char *pText, int nText,
   void *pUserData,
   int (*xToken)(void*, int, const char*, int, int, int)
 ){
-  Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
-  Fts5Table *pTab = (Fts5Table*)(pCsr->base.pVtab);
-  return sqlite3Fts5Tokenize(
-      pTab->pConfig, FTS5_TOKENIZE_AUX, pText, nText, pUserData, xToken
-  );
+  return fts5ApiTokenize_v2(pCtx, pText, nText, 0, 0, pUserData, xToken);
 }
 
 static int fts5ApiPhraseCount(Fts5Context *pCtx){
@@ -249463,6 +253548,49 @@ static int fts5ApiPhraseSize(Fts5Context *pCtx, int iPhrase){
   return sqlite3Fts5ExprPhraseSize(pCsr->pExpr, iPhrase);
 }
 
+/*
+** Argument pStmt is an SQL statement of the type used by Fts5Cursor. This
+** function extracts the text value of column iCol of the current row.
+** Additionally, if there is an associated locale, it invokes
+** sqlite3Fts5SetLocale() to configure the tokenizer. In all cases the caller
+** should invoke sqlite3Fts5ClearLocale() to clear the locale at some point
+** after this function returns.
+**
+** If successful, (*ppText) is set to point to a buffer containing the text
+** value as utf-8 and SQLITE_OK returned. (*pnText) is set to the size of that
+** buffer in bytes. It is not guaranteed to be nul-terminated. If an error
+** occurs, an SQLite error code is returned. The final values of the two
+** output parameters are undefined in this case.
+*/
+static int fts5TextFromStmt(
+  Fts5Config *pConfig,
+  sqlite3_stmt *pStmt,
+  int iCol,
+  const char **ppText,
+  int *pnText
+){
+  sqlite3_value *pVal = sqlite3_column_value(pStmt, iCol+1);
+  const char *pLoc = 0;
+  int nLoc = 0;
+  int rc = SQLITE_OK;
+
+  if( pConfig->bLocale
+   && pConfig->eContent==FTS5_CONTENT_EXTERNAL
+   && sqlite3Fts5IsLocaleValue(pConfig, pVal)
+  ){
+    rc = sqlite3Fts5DecodeLocaleValue(pVal, ppText, pnText, &pLoc, &nLoc);
+  }else{
+    *ppText = (const char*)sqlite3_value_text(pVal);
+    *pnText = sqlite3_value_bytes(pVal);
+    if( pConfig->bLocale && pConfig->eContent==FTS5_CONTENT_NORMAL ){
+      pLoc = (const char*)sqlite3_column_text(pStmt, iCol+1+pConfig->nCol);
+      nLoc = sqlite3_column_bytes(pStmt, iCol+1+pConfig->nCol);
+    }
+  }
+  sqlite3Fts5SetLocale(pConfig, pLoc, nLoc);
+  return rc;
+}
+
 static int fts5ApiColumnText(
   Fts5Context *pCtx,
   int iCol,
@@ -249472,28 +253600,35 @@ static int fts5ApiColumnText(
   int rc = SQLITE_OK;
   Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
   Fts5Table *pTab = (Fts5Table*)(pCsr->base.pVtab);
+
+  assert( pCsr->ePlan!=FTS5_PLAN_SPECIAL );
   if( iCol<0 || iCol>=pTab->pConfig->nCol ){
     rc = SQLITE_RANGE;
-  }else if( fts5IsContentless((Fts5FullTable*)(pCsr->base.pVtab))
-   || pCsr->ePlan==FTS5_PLAN_SPECIAL
-  ){
+  }else if( fts5IsContentless((Fts5FullTable*)(pCsr->base.pVtab), 0) ){
     *pz = 0;
     *pn = 0;
   }else{
     rc = fts5SeekCursor(pCsr, 0);
     if( rc==SQLITE_OK ){
-      *pz = (const char*)sqlite3_column_text(pCsr->pStmt, iCol+1);
-      *pn = sqlite3_column_bytes(pCsr->pStmt, iCol+1);
+      rc = fts5TextFromStmt(pTab->pConfig, pCsr->pStmt, iCol, pz, pn);
+      sqlite3Fts5ClearLocale(pTab->pConfig);
     }
   }
   return rc;
 }
 
+/*
+** This is called by various API functions - xInst, xPhraseFirst,
+** xPhraseFirstColumn etc. - to obtain the position list for phrase iPhrase
+** of the current row. This function works for both detail=full tables (in
+** which case the position-list was read from the fts index) or for other
+** detail= modes if the row content is available.
+*/
 static int fts5CsrPoslist(
-  Fts5Cursor *pCsr,
-  int iPhrase,
-  const u8 **pa,
-  int *pn
+  Fts5Cursor *pCsr,               /* Fts5 cursor object */
+  int iPhrase,                    /* Phrase to find position list for */
+  const u8 **pa,                  /* OUT: Pointer to position list buffer */
+  int *pn                         /* OUT: Size of (*pa) in bytes */
 ){
   Fts5Config *pConfig = ((Fts5Table*)(pCsr->base.pVtab))->pConfig;
   int rc = SQLITE_OK;
@@ -249501,20 +253636,32 @@ static int fts5CsrPoslist(
 
   if( iPhrase<0 || iPhrase>=sqlite3Fts5ExprPhraseCount(pCsr->pExpr) ){
     rc = SQLITE_RANGE;
+  }else if( pConfig->eDetail!=FTS5_DETAIL_FULL
+         && fts5IsContentless((Fts5FullTable*)pCsr->base.pVtab, 1)
+  ){
+    *pa = 0;
+    *pn = 0;
+    return SQLITE_OK;
   }else if( CsrFlagTest(pCsr, FTS5CSR_REQUIRE_POSLIST) ){
     if( pConfig->eDetail!=FTS5_DETAIL_FULL ){
       Fts5PoslistPopulator *aPopulator;
       int i;
+
       aPopulator = sqlite3Fts5ExprClearPoslists(pCsr->pExpr, bLive);
       if( aPopulator==0 ) rc = SQLITE_NOMEM;
+      if( rc==SQLITE_OK ){
+        rc = fts5SeekCursor(pCsr, 0);
+      }
       for(i=0; i<pConfig->nCol && rc==SQLITE_OK; i++){
-        int n; const char *z;
-        rc = fts5ApiColumnText((Fts5Context*)pCsr, i, &z, &n);
+        const char *z = 0;
+        int n = 0;
+        rc = fts5TextFromStmt(pConfig, pCsr->pStmt, i, &z, &n);
         if( rc==SQLITE_OK ){
           rc = sqlite3Fts5ExprPopulatePoslists(
               pConfig, pCsr->pExpr, aPopulator, i, z, n
           );
         }
+        sqlite3Fts5ClearLocale(pConfig);
       }
       sqlite3_free(aPopulator);
 
@@ -249539,7 +253686,6 @@ static int fts5CsrPoslist(
     *pn = 0;
   }
 
-
   return rc;
 }
 
@@ -249608,7 +253754,8 @@ static int fts5CacheInstArray(Fts5Cursor *pCsr){
         aInst[0] = iBest;
         aInst[1] = FTS5_POS2COLUMN(aIter[iBest].iPos);
         aInst[2] = FTS5_POS2OFFSET(aIter[iBest].iPos);
-        if( aInst[1]<0 || aInst[1]>=nCol ){
+        assert( aInst[1]>=0 );
+        if( aInst[1]>=nCol ){
           rc = FTS5_CORRUPT;
           break;
         }
@@ -249686,7 +253833,7 @@ static int fts5ApiColumnSize(Fts5Context *pCtx, int iCol, int *pnToken){
     if( pConfig->bColumnsize ){
       i64 iRowid = fts5CursorRowid(pCsr);
       rc = sqlite3Fts5StorageDocsize(pTab->pStorage, iRowid, pCsr->aColumnSize);
-    }else if( pConfig->zContent==0 ){
+    }else if( !pConfig->zContent || pConfig->eContent==FTS5_CONTENT_UNINDEXED ){
       int i;
       for(i=0; i<pConfig->nCol; i++){
         if( pConfig->abUnindexed[i]==0 ){
@@ -249695,17 +253842,19 @@ static int fts5ApiColumnSize(Fts5Context *pCtx, int iCol, int *pnToken){
       }
     }else{
       int i;
+      rc = fts5SeekCursor(pCsr, 0);
       for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){
         if( pConfig->abUnindexed[i]==0 ){
-          const char *z; int n;
-          void *p = (void*)(&pCsr->aColumnSize[i]);
+          const char *z = 0;
+          int n = 0;
           pCsr->aColumnSize[i] = 0;
-          rc = fts5ApiColumnText(pCtx, i, &z, &n);
+          rc = fts5TextFromStmt(pConfig, pCsr->pStmt, i, &z, &n);
           if( rc==SQLITE_OK ){
-            rc = sqlite3Fts5Tokenize(
-                pConfig, FTS5_TOKENIZE_AUX, z, n, p, fts5ColumnSizeCb
+            rc = sqlite3Fts5Tokenize(pConfig, FTS5_TOKENIZE_AUX,
+                z, n, (void*)&pCsr->aColumnSize[i], fts5ColumnSizeCb
             );
           }
+          sqlite3Fts5ClearLocale(pConfig);
         }
       }
     }
@@ -249785,11 +253934,10 @@ static void *fts5ApiGetAuxdata(Fts5Context *pCtx, int bClear){
 }
 
 static void fts5ApiPhraseNext(
-  Fts5Context *pUnused,
+  Fts5Context *pCtx,
   Fts5PhraseIter *pIter,
   int *piCol, int *piOff
 ){
-  UNUSED_PARAM(pUnused);
   if( pIter->a>=pIter->b ){
     *piCol = -1;
     *piOff = -1;
@@ -249797,8 +253945,12 @@ static void fts5ApiPhraseNext(
     int iVal;
     pIter->a += fts5GetVarint32(pIter->a, iVal);
     if( iVal==1 ){
+      /* Avoid returning a (*piCol) value that is too large for the table,
+      ** even if the position-list is corrupt. The caller might not be
+      ** expecting it.  */
+      int nCol = ((Fts5Table*)(((Fts5Cursor*)pCtx)->base.pVtab))->pConfig->nCol;
       pIter->a += fts5GetVarint32(pIter->a, iVal);
-      *piCol = iVal;
+      *piCol = (iVal>=nCol ? nCol-1 : iVal);
       *piOff = 0;
       pIter->a += fts5GetVarint32(pIter->a, iVal);
     }
@@ -249948,8 +254100,48 @@ static int fts5ApiQueryPhrase(Fts5Context*, int, void*,
     int(*)(const Fts5ExtensionApi*, Fts5Context*, void*)
 );
 
+/*
+** The xColumnLocale() API.
+*/
+static int fts5ApiColumnLocale(
+  Fts5Context *pCtx,
+  int iCol,
+  const char **pzLocale,
+  int *pnLocale
+){
+  int rc = SQLITE_OK;
+  Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
+  Fts5Config *pConfig = ((Fts5Table*)(pCsr->base.pVtab))->pConfig;
+
+  *pzLocale = 0;
+  *pnLocale = 0;
+
+  assert( pCsr->ePlan!=FTS5_PLAN_SPECIAL );
+  if( iCol<0 || iCol>=pConfig->nCol ){
+    rc = SQLITE_RANGE;
+  }else if(
+      pConfig->abUnindexed[iCol]==0
+   && 0==fts5IsContentless((Fts5FullTable*)pCsr->base.pVtab, 1)
+   && pConfig->bLocale
+  ){
+    rc = fts5SeekCursor(pCsr, 0);
+    if( rc==SQLITE_OK ){
+      const char *zDummy = 0;
+      int nDummy = 0;
+      rc = fts5TextFromStmt(pConfig, pCsr->pStmt, iCol, &zDummy, &nDummy);
+      if( rc==SQLITE_OK ){
+        *pzLocale = pConfig->t.pLocale;
+        *pnLocale = pConfig->t.nLocale;
+      }
+      sqlite3Fts5ClearLocale(pConfig);
+    }
+  }
+
+  return rc;
+}
+
 static const Fts5ExtensionApi sFts5Api = {
-  3,                            /* iVersion */
+  4,                            /* iVersion */
   fts5ApiUserData,
   fts5ApiColumnCount,
   fts5ApiRowCount,
@@ -249970,7 +254162,9 @@ static const Fts5ExtensionApi sFts5Api = {
   fts5ApiPhraseFirstColumn,
   fts5ApiPhraseNextColumn,
   fts5ApiQueryToken,
-  fts5ApiInstToken
+  fts5ApiInstToken,
+  fts5ApiColumnLocale,
+  fts5ApiTokenize_v2
 };
 
 /*
@@ -250021,6 +254215,7 @@ static void fts5ApiInvoke(
   sqlite3_value **argv
 ){
   assert( pCsr->pAux==0 );
+  assert( pCsr->ePlan!=FTS5_PLAN_SPECIAL );
   pCsr->pAux = pAux;
   pAux->xFunc(&sFts5Api, (Fts5Context*)pCsr, context, argc, argv);
   pCsr->pAux = 0;
@@ -250034,6 +254229,21 @@ static Fts5Cursor *fts5CursorFromCsrid(Fts5Global *pGlobal, i64 iCsrId){
   return pCsr;
 }
 
+/*
+** Parameter zFmt is a printf() style formatting string. This function
+** formats it using the trailing arguments and returns the result as
+** an error message to the context passed as the first argument.
+*/
+static void fts5ResultError(sqlite3_context *pCtx, const char *zFmt, ...){
+  char *zErr = 0;
+  va_list ap;
+  va_start(ap, zFmt);
+  zErr = sqlite3_vmprintf(zFmt, ap);
+  sqlite3_result_error(pCtx, zErr, -1);
+  sqlite3_free(zErr);
+  va_end(ap);
+}
+
 static void fts5ApiCallback(
   sqlite3_context *context,
   int argc,
@@ -250049,12 +254259,13 @@ static void fts5ApiCallback(
   iCsrId = sqlite3_value_int64(argv[0]);
 
   pCsr = fts5CursorFromCsrid(pAux->pGlobal, iCsrId);
-  if( pCsr==0 || pCsr->ePlan==0 ){
-    char *zErr = sqlite3_mprintf("no such cursor: %lld", iCsrId);
-    sqlite3_result_error(context, zErr, -1);
-    sqlite3_free(zErr);
+  if( pCsr==0 || (pCsr->ePlan==0 || pCsr->ePlan==FTS5_PLAN_SPECIAL) ){
+    fts5ResultError(context, "no such cursor: %lld", iCsrId);
   }else{
+    sqlite3_vtab *pTab = pCsr->base.pVtab;
     fts5ApiInvoke(pAux, pCsr, context, argc-1, &argv[1]);
+    sqlite3_free(pTab->zErrMsg);
+    pTab->zErrMsg = 0;
   }
 }
 
@@ -250172,8 +254383,8 @@ static int fts5ColumnMethod(
     ** auxiliary function.  */
     sqlite3_result_int64(pCtx, pCsr->iCsrId);
   }else if( iCol==pConfig->nCol+1 ){
-
     /* The value of the "rank" column. */
+
     if( pCsr->ePlan==FTS5_PLAN_SOURCE ){
       fts5PoslistBlob(pCtx, pCsr);
     }else if(
@@ -250184,20 +254395,32 @@ static int fts5ColumnMethod(
         fts5ApiInvoke(pCsr->pRank, pCsr, pCtx, pCsr->nRankArg, pCsr->apRankArg);
       }
     }
-  }else if( !fts5IsContentless(pTab) ){
-    pConfig->pzErrmsg = &pTab->p.base.zErrMsg;
-    rc = fts5SeekCursor(pCsr, 1);
-    if( rc==SQLITE_OK ){
-      sqlite3_result_value(pCtx, sqlite3_column_value(pCsr->pStmt, iCol+1));
+  }else{
+    if( !sqlite3_vtab_nochange(pCtx) && pConfig->eContent!=FTS5_CONTENT_NONE ){
+      pConfig->pzErrmsg = &pTab->p.base.zErrMsg;
+      rc = fts5SeekCursor(pCsr, 1);
+      if( rc==SQLITE_OK ){
+        sqlite3_value *pVal = sqlite3_column_value(pCsr->pStmt, iCol+1);
+        if( pConfig->bLocale
+         && pConfig->eContent==FTS5_CONTENT_EXTERNAL
+         && sqlite3Fts5IsLocaleValue(pConfig, pVal)
+        ){
+          const char *z = 0;
+          int n = 0;
+          rc = fts5TextFromStmt(pConfig, pCsr->pStmt, iCol, &z, &n);
+          if( rc==SQLITE_OK ){
+            sqlite3_result_text(pCtx, z, n, SQLITE_TRANSIENT);
+          }
+          sqlite3Fts5ClearLocale(pConfig);
+        }else{
+          sqlite3_result_value(pCtx, pVal);
+        }
+      }
+
+      pConfig->pzErrmsg = 0;
     }
-    pConfig->pzErrmsg = 0;
-  }else if( pConfig->bContentlessDelete && sqlite3_vtab_nochange(pCtx) ){
-    char *zErr = sqlite3_mprintf("cannot UPDATE a subset of "
-        "columns on fts5 contentless-delete table: %s", pConfig->zName
-    );
-    sqlite3_result_error(pCtx, zErr, -1);
-    sqlite3_free(zErr);
   }
+
   return rc;
 }
 
@@ -250336,9 +254559,180 @@ static int fts5CreateAux(
   return rc;
 }
 
+/*
+** This function is used by xCreateTokenizer_v2() and xCreateTokenizer().
+** It allocates and partially populates a new Fts5TokenizerModule object.
+** The new object is already linked into the Fts5Global context before
+** returning.
+**
+** If successful, SQLITE_OK is returned and a pointer to the new
+** Fts5TokenizerModule object returned via output parameter (*ppNew). All
+** that is required is for the caller to fill in the methods in
+** Fts5TokenizerModule.x1 and x2, and to set Fts5TokenizerModule.bV2Native
+** as appropriate.
+**
+** If an error occurs, an SQLite error code is returned and the final value
+** of (*ppNew) undefined.
+*/
+static int fts5NewTokenizerModule(
+  Fts5Global *pGlobal,            /* Global context (one per db handle) */
+  const char *zName,              /* Name of new function */
+  void *pUserData,                /* User data for aux. function */
+  void(*xDestroy)(void*),         /* Destructor for pUserData */
+  Fts5TokenizerModule **ppNew
+){
+  int rc = SQLITE_OK;
+  Fts5TokenizerModule *pNew;
+  sqlite3_int64 nName;          /* Size of zName and its \0 terminator */
+  sqlite3_int64 nByte;          /* Bytes of space to allocate */
+
+  nName = strlen(zName) + 1;
+  nByte = sizeof(Fts5TokenizerModule) + nName;
+  *ppNew = pNew = (Fts5TokenizerModule*)sqlite3Fts5MallocZero(&rc, nByte);
+  if( pNew ){
+    pNew->zName = (char*)&pNew[1];
+    memcpy(pNew->zName, zName, nName);
+    pNew->pUserData = pUserData;
+    pNew->xDestroy = xDestroy;
+    pNew->pNext = pGlobal->pTok;
+    pGlobal->pTok = pNew;
+    if( pNew->pNext==0 ){
+      pGlobal->pDfltTok = pNew;
+    }
+  }
+
+  return rc;
+}
+
+/*
+** An instance of this type is used as the Fts5Tokenizer object for
+** wrapper tokenizers - those that provide access to a v1 tokenizer via
+** the fts5_tokenizer_v2 API, and those that provide access to a v2 tokenizer
+** via the fts5_tokenizer API.
+*/
+typedef struct Fts5VtoVTokenizer Fts5VtoVTokenizer;
+struct Fts5VtoVTokenizer {
+  int bV2Native;                  /* True if v2 native tokenizer */
+  fts5_tokenizer x1;              /* Tokenizer functions */
+  fts5_tokenizer_v2 x2;           /* V2 tokenizer functions */
+  Fts5Tokenizer *pReal;
+};
+
+/*
+** Create a wrapper tokenizer. The context argument pCtx points to the
+** Fts5TokenizerModule object.
+*/
+static int fts5VtoVCreate(
+  void *pCtx,
+  const char **azArg,
+  int nArg,
+  Fts5Tokenizer **ppOut
+){
+  Fts5TokenizerModule *pMod = (Fts5TokenizerModule*)pCtx;
+  Fts5VtoVTokenizer *pNew = 0;
+  int rc = SQLITE_OK;
+
+  pNew = (Fts5VtoVTokenizer*)sqlite3Fts5MallocZero(&rc, sizeof(*pNew));
+  if( rc==SQLITE_OK ){
+    pNew->x1 = pMod->x1;
+    pNew->x2 = pMod->x2;
+    pNew->bV2Native = pMod->bV2Native;
+    if( pMod->bV2Native ){
+      rc = pMod->x2.xCreate(pMod->pUserData, azArg, nArg, &pNew->pReal);
+    }else{
+      rc = pMod->x1.xCreate(pMod->pUserData, azArg, nArg, &pNew->pReal);
+    }
+    if( rc!=SQLITE_OK ){
+      sqlite3_free(pNew);
+      pNew = 0;
+    }
+  }
+
+  *ppOut = (Fts5Tokenizer*)pNew;
+  return rc;
+}
+
+/*
+** Delete an Fts5VtoVTokenizer wrapper tokenizer.
+*/
+static void fts5VtoVDelete(Fts5Tokenizer *pTok){
+  Fts5VtoVTokenizer *p = (Fts5VtoVTokenizer*)pTok;
+  if( p ){
+    if( p->bV2Native ){
+      p->x2.xDelete(p->pReal);
+    }else{
+      p->x1.xDelete(p->pReal);
+    }
+    sqlite3_free(p);
+  }
+}
+
+
+/*
+** xTokenizer method for a wrapper tokenizer that offers the v1 interface
+** (no support for locales).
+*/
+static int fts5V1toV2Tokenize(
+  Fts5Tokenizer *pTok,
+  void *pCtx, int flags,
+  const char *pText, int nText,
+  int (*xToken)(void*, int, const char*, int, int, int)
+){
+  Fts5VtoVTokenizer *p = (Fts5VtoVTokenizer*)pTok;
+  assert( p->bV2Native );
+  return p->x2.xTokenize(p->pReal, pCtx, flags, pText, nText, 0, 0, xToken);
+}
+
+/*
+** xTokenizer method for a wrapper tokenizer that offers the v2 interface
+** (with locale support).
+*/
+static int fts5V2toV1Tokenize(
+  Fts5Tokenizer *pTok,
+  void *pCtx, int flags,
+  const char *pText, int nText,
+  const char *pLocale, int nLocale,
+  int (*xToken)(void*, int, const char*, int, int, int)
+){
+  Fts5VtoVTokenizer *p = (Fts5VtoVTokenizer*)pTok;
+  assert( p->bV2Native==0 );
+  UNUSED_PARAM2(pLocale,nLocale);
+  return p->x1.xTokenize(p->pReal, pCtx, flags, pText, nText, xToken);
+}
+
 /*
 ** Register a new tokenizer. This is the implementation of the
-** fts5_api.xCreateTokenizer() method.
+** fts5_api.xCreateTokenizer_v2() method.
+*/
+static int fts5CreateTokenizer_v2(
+  fts5_api *pApi,                 /* Global context (one per db handle) */
+  const char *zName,              /* Name of new function */
+  void *pUserData,                /* User data for aux. function */
+  fts5_tokenizer_v2 *pTokenizer,  /* Tokenizer implementation */
+  void(*xDestroy)(void*)          /* Destructor for pUserData */
+){
+  Fts5Global *pGlobal = (Fts5Global*)pApi;
+  int rc = SQLITE_OK;
+
+  if( pTokenizer->iVersion>2 ){
+    rc = SQLITE_ERROR;
+  }else{
+    Fts5TokenizerModule *pNew = 0;
+    rc = fts5NewTokenizerModule(pGlobal, zName, pUserData, xDestroy, &pNew);
+    if( pNew ){
+      pNew->x2 = *pTokenizer;
+      pNew->bV2Native = 1;
+      pNew->x1.xCreate = fts5VtoVCreate;
+      pNew->x1.xTokenize = fts5V1toV2Tokenize;
+      pNew->x1.xDelete = fts5VtoVDelete;
+    }
+  }
+
+  return rc;
+}
+
+/*
+** The fts5_api.xCreateTokenizer() method.
 */
 static int fts5CreateTokenizer(
   fts5_api *pApi,                 /* Global context (one per db handle) */
@@ -250347,37 +254741,29 @@ static int fts5CreateTokenizer(
   fts5_tokenizer *pTokenizer,     /* Tokenizer implementation */
   void(*xDestroy)(void*)          /* Destructor for pUserData */
 ){
-  Fts5Global *pGlobal = (Fts5Global*)pApi;
-  Fts5TokenizerModule *pNew;
-  sqlite3_int64 nName;            /* Size of zName and its \0 terminator */
-  sqlite3_int64 nByte;            /* Bytes of space to allocate */
+  Fts5TokenizerModule *pNew = 0;
   int rc = SQLITE_OK;
 
-  nName = strlen(zName) + 1;
-  nByte = sizeof(Fts5TokenizerModule) + nName;
-  pNew = (Fts5TokenizerModule*)sqlite3_malloc64(nByte);
+  rc = fts5NewTokenizerModule(
+      (Fts5Global*)pApi, zName, pUserData, xDestroy, &pNew
+  );
   if( pNew ){
-    memset(pNew, 0, (size_t)nByte);
-    pNew->zName = (char*)&pNew[1];
-    memcpy(pNew->zName, zName, nName);
-    pNew->pUserData = pUserData;
-    pNew->x = *pTokenizer;
-    pNew->xDestroy = xDestroy;
-    pNew->pNext = pGlobal->pTok;
-    pGlobal->pTok = pNew;
-    if( pNew->pNext==0 ){
-      pGlobal->pDfltTok = pNew;
-    }
-  }else{
-    rc = SQLITE_NOMEM;
+    pNew->x1 = *pTokenizer;
+    pNew->x2.xCreate = fts5VtoVCreate;
+    pNew->x2.xTokenize = fts5V2toV1Tokenize;
+    pNew->x2.xDelete = fts5VtoVDelete;
   }
-
   return rc;
 }
 
+/*
+** Search the global context passed as the first argument for a tokenizer
+** module named zName. If found, return a pointer to the Fts5TokenizerModule
+** object. Otherwise, return NULL.
+*/
 static Fts5TokenizerModule *fts5LocateTokenizer(
-  Fts5Global *pGlobal,
-  const char *zName
+  Fts5Global *pGlobal,            /* Global (one per db handle) object */
+  const char *zName               /* Name of tokenizer module to find */
 ){
   Fts5TokenizerModule *pMod = 0;
 
@@ -250392,6 +254778,36 @@ static Fts5TokenizerModule *fts5LocateTokenizer(
   return pMod;
 }
 
+/*
+** Find a tokenizer. This is the implementation of the
+** fts5_api.xFindTokenizer_v2() method.
+*/
+static int fts5FindTokenizer_v2(
+  fts5_api *pApi,                 /* Global context (one per db handle) */
+  const char *zName,              /* Name of tokenizer */
+  void **ppUserData,
+  fts5_tokenizer_v2 **ppTokenizer /* Populate this object */
+){
+  int rc = SQLITE_OK;
+  Fts5TokenizerModule *pMod;
+
+  pMod = fts5LocateTokenizer((Fts5Global*)pApi, zName);
+  if( pMod ){
+    if( pMod->bV2Native ){
+      *ppUserData = pMod->pUserData;
+    }else{
+      *ppUserData = (void*)pMod;
+    }
+    *ppTokenizer = &pMod->x2;
+  }else{
+    *ppTokenizer = 0;
+    *ppUserData = 0;
+    rc = SQLITE_ERROR;
+  }
+
+  return rc;
+}
+
 /*
 ** Find a tokenizer. This is the implementation of the
 ** fts5_api.xFindTokenizer() method.
@@ -250407,53 +254823,75 @@ static int fts5FindTokenizer(
 
   pMod = fts5LocateTokenizer((Fts5Global*)pApi, zName);
   if( pMod ){
-    *pTokenizer = pMod->x;
-    *ppUserData = pMod->pUserData;
+    if( pMod->bV2Native==0 ){
+      *ppUserData = pMod->pUserData;
+    }else{
+      *ppUserData = (void*)pMod;
+    }
+    *pTokenizer = pMod->x1;
   }else{
-    memset(pTokenizer, 0, sizeof(fts5_tokenizer));
+    memset(pTokenizer, 0, sizeof(*pTokenizer));
+    *ppUserData = 0;
     rc = SQLITE_ERROR;
   }
 
   return rc;
 }
 
-static int sqlite3Fts5GetTokenizer(
-  Fts5Global *pGlobal,
-  const char **azArg,
-  int nArg,
-  Fts5Config *pConfig,
-  char **pzErr
-){
-  Fts5TokenizerModule *pMod;
+/*
+** Attempt to instantiate the tokenizer.
+*/
+static int sqlite3Fts5LoadTokenizer(Fts5Config *pConfig){
+  const char **azArg = pConfig->t.azArg;
+  const int nArg = pConfig->t.nArg;
+  Fts5TokenizerModule *pMod = 0;
   int rc = SQLITE_OK;
 
-  pMod = fts5LocateTokenizer(pGlobal, nArg==0 ? 0 : azArg[0]);
+  pMod = fts5LocateTokenizer(pConfig->pGlobal, nArg==0 ? 0 : azArg[0]);
   if( pMod==0 ){
     assert( nArg>0 );
     rc = SQLITE_ERROR;
-    *pzErr = sqlite3_mprintf("no such tokenizer: %s", azArg[0]);
+    sqlite3Fts5ConfigErrmsg(pConfig, "no such tokenizer: %s", azArg[0]);
   }else{
-    rc = pMod->x.xCreate(
-        pMod->pUserData, (azArg?&azArg[1]:0), (nArg?nArg-1:0), &pConfig->pTok
-    );
-    pConfig->pTokApi = &pMod->x;
-    if( rc!=SQLITE_OK ){
-      if( pzErr ) *pzErr = sqlite3_mprintf("error in tokenizer constructor");
+    int (*xCreate)(void*, const char**, int, Fts5Tokenizer**) = 0;
+    if( pMod->bV2Native ){
+      xCreate = pMod->x2.xCreate;
+      pConfig->t.pApi2 = &pMod->x2;
     }else{
-      pConfig->ePattern = sqlite3Fts5TokenizerPattern(
-          pMod->x.xCreate, pConfig->pTok
+      pConfig->t.pApi1 = &pMod->x1;
+      xCreate = pMod->x1.xCreate;
+    }
+
+    rc = xCreate(pMod->pUserData,
+        (azArg?&azArg[1]:0), (nArg?nArg-1:0), &pConfig->t.pTok
+    );
+
+    if( rc!=SQLITE_OK ){
+      if( rc!=SQLITE_NOMEM ){
+        sqlite3Fts5ConfigErrmsg(pConfig, "error in tokenizer constructor");
+      }
+    }else if( pMod->bV2Native==0 ){
+      pConfig->t.ePattern = sqlite3Fts5TokenizerPattern(
+          pMod->x1.xCreate, pConfig->t.pTok
       );
     }
   }
 
   if( rc!=SQLITE_OK ){
-    pConfig->pTokApi = 0;
-    pConfig->pTok = 0;
+    pConfig->t.pApi1 = 0;
+    pConfig->t.pApi2 = 0;
+    pConfig->t.pTok = 0;
   }
 
   return rc;
 }
 
+
+/*
+** xDestroy callback passed to sqlite3_create_module(). This is invoked
+** when the db handle is being closed. Free memory associated with
+** tokenizers and aux functions registered with this db handle.
+*/
 static void fts5ModuleDestroy(void *pCtx){
   Fts5TokenizerModule *pTok, *pNextTok;
   Fts5Auxiliary *pAux, *pNextAux;
@@ -250474,6 +254912,10 @@ static void fts5ModuleDestroy(void *pCtx){
   sqlite3_free(pGlobal);
 }
 
+/*
+** Implementation of the fts5() function used by clients to obtain the
+** API pointer.
+*/
 static void fts5Fts5Func(
   sqlite3_context *pCtx,          /* Function call context */
   int nArg,                       /* Number of args */
@@ -250497,7 +254939,68 @@ static void fts5SourceIdFunc(
 ){
   assert( nArg==0 );
   UNUSED_PARAM2(nArg, apUnused);
-  sqlite3_result_text(pCtx, "fts5: 2024-01-15 17:01:13 1066602b2b1976fe58b5150777cced894af17c803e068f5918390d6915b46e1d", -1, SQLITE_TRANSIENT);
+  sqlite3_result_text(pCtx, "fts5: 2024-11-25 12:07:48 b95d11e958643b969c47a8e5857f3793b9e69700b8f1469371386369a26e577e", -1, SQLITE_TRANSIENT);
+}
+
+/*
+** Implementation of fts5_locale(LOCALE, TEXT) function.
+**
+** If parameter LOCALE is NULL, or a zero-length string, then a copy of
+** TEXT is returned. Otherwise, both LOCALE and TEXT are interpreted as
+** text, and the value returned is a blob consisting of:
+**
+**     * The 4 bytes 0x00, 0xE0, 0xB2, 0xEb (FTS5_LOCALE_HEADER).
+**     * The LOCALE, as utf-8 text, followed by
+**     * 0x00, followed by
+**     * The TEXT, as utf-8 text.
+**
+** There is no final nul-terminator following the TEXT value.
+*/
+static void fts5LocaleFunc(
+  sqlite3_context *pCtx,          /* Function call context */
+  int nArg,                       /* Number of args */
+  sqlite3_value **apArg           /* Function arguments */
+){
+  const char *zLocale = 0;
+  int nLocale = 0;
+  const char *zText = 0;
+  int nText = 0;
+
+  assert( nArg==2 );
+  UNUSED_PARAM(nArg);
+
+  zLocale = (const char*)sqlite3_value_text(apArg[0]);
+  nLocale = sqlite3_value_bytes(apArg[0]);
+
+  zText = (const char*)sqlite3_value_text(apArg[1]);
+  nText = sqlite3_value_bytes(apArg[1]);
+
+  if( zLocale==0 || zLocale[0]=='\0' ){
+    sqlite3_result_text(pCtx, zText, nText, SQLITE_TRANSIENT);
+  }else{
+    Fts5Global *p = (Fts5Global*)sqlite3_user_data(pCtx);
+    u8 *pBlob = 0;
+    u8 *pCsr = 0;
+    int nBlob = 0;
+
+    nBlob = FTS5_LOCALE_HDR_SIZE + nLocale + 1 + nText;
+    pBlob = (u8*)sqlite3_malloc(nBlob);
+    if( pBlob==0 ){
+      sqlite3_result_error_nomem(pCtx);
+      return;
+    }
+
+    pCsr = pBlob;
+    memcpy(pCsr, (const u8*)p->aLocaleHdr, FTS5_LOCALE_HDR_SIZE);
+    pCsr += FTS5_LOCALE_HDR_SIZE;
+    memcpy(pCsr, zLocale, nLocale);
+    pCsr += nLocale;
+    (*pCsr++) = 0x00;
+    if( zText ) memcpy(pCsr, zText, nText);
+    assert( &pCsr[nText]==&pBlob[nBlob] );
+
+    sqlite3_result_blob(pCtx, pBlob, nBlob, sqlite3_free);
+  }
 }
 
 /*
@@ -250528,28 +255031,29 @@ static int fts5IntegrityMethod(
   char **pzErr            /* Write error message here */
 ){
   Fts5FullTable *pTab = (Fts5FullTable*)pVtab;
-  Fts5Config *pConfig = pTab->p.pConfig;
-  char *zSql;
-  char *zErr = 0;
   int rc;
+
   assert( pzErr!=0 && *pzErr==0 );
   UNUSED_PARAM(isQuick);
-  zSql = sqlite3_mprintf(
-            "INSERT INTO \"%w\".\"%w\"(\"%w\") VALUES('integrity-check');",
-            zSchema, zTabname, pConfig->zName);
-  if( zSql==0 ) return SQLITE_NOMEM;
-  rc = sqlite3_exec(pConfig->db, zSql, 0, 0, &zErr);
-  sqlite3_free(zSql);
-  if( (rc&0xff)==SQLITE_CORRUPT ){
-    *pzErr = sqlite3_mprintf("malformed inverted index for FTS5 table %s.%s",
-                zSchema, zTabname);
-  }else if( rc!=SQLITE_OK ){
-    *pzErr = sqlite3_mprintf("unable to validate the inverted index for"
-                             " FTS5 table %s.%s: %s",
-                zSchema, zTabname, zErr);
+  assert( pTab->p.pConfig->pzErrmsg==0 );
+  pTab->p.pConfig->pzErrmsg = pzErr;
+  rc = sqlite3Fts5StorageIntegrity(pTab->pStorage, 0);
+  if( *pzErr==0 && rc!=SQLITE_OK ){
+    if( (rc&0xff)==SQLITE_CORRUPT ){
+      *pzErr = sqlite3_mprintf("malformed inverted index for FTS5 table %s.%s",
+          zSchema, zTabname);
+      rc = (*pzErr) ? SQLITE_OK : SQLITE_NOMEM;
+    }else{
+      *pzErr = sqlite3_mprintf("unable to validate the inverted index for"
+          " FTS5 table %s.%s: %s",
+          zSchema, zTabname, sqlite3_errstr(rc));
+    }
   }
-  sqlite3_free(zErr);
-  return SQLITE_OK;
+
+  sqlite3Fts5IndexCloseReader(pTab->p.pIndex);
+  pTab->p.pConfig->pzErrmsg = 0;
+
+  return rc;
 }
 
 static int fts5Init(sqlite3 *db){
@@ -250591,10 +255095,22 @@ static int fts5Init(sqlite3 *db){
     void *p = (void*)pGlobal;
     memset(pGlobal, 0, sizeof(Fts5Global));
     pGlobal->db = db;
-    pGlobal->api.iVersion = 2;
+    pGlobal->api.iVersion = 3;
     pGlobal->api.xCreateFunction = fts5CreateAux;
     pGlobal->api.xCreateTokenizer = fts5CreateTokenizer;
     pGlobal->api.xFindTokenizer = fts5FindTokenizer;
+    pGlobal->api.xCreateTokenizer_v2 = fts5CreateTokenizer_v2;
+    pGlobal->api.xFindTokenizer_v2 = fts5FindTokenizer_v2;
+
+    /* Initialize pGlobal->aLocaleHdr[] to a 128-bit pseudo-random vector.
+    ** The constants below were generated randomly.  */
+    sqlite3_randomness(sizeof(pGlobal->aLocaleHdr), pGlobal->aLocaleHdr);
+    pGlobal->aLocaleHdr[0] ^= 0xF924976D;
+    pGlobal->aLocaleHdr[1] ^= 0x16596E13;
+    pGlobal->aLocaleHdr[2] ^= 0x7C80BEAA;
+    pGlobal->aLocaleHdr[3] ^= 0x9B03A67F;
+    assert( sizeof(pGlobal->aLocaleHdr)==16 );
+
     rc = sqlite3_create_module_v2(db, "fts5", &fts5Mod, p, fts5ModuleDestroy);
     if( rc==SQLITE_OK ) rc = sqlite3Fts5IndexInit(db);
     if( rc==SQLITE_OK ) rc = sqlite3Fts5ExprInit(pGlobal, db);
@@ -250613,6 +255129,13 @@ static int fts5Init(sqlite3 *db){
           p, fts5SourceIdFunc, 0, 0
       );
     }
+    if( rc==SQLITE_OK ){
+      rc = sqlite3_create_function(
+          db, "fts5_locale", 2,
+          SQLITE_UTF8|SQLITE_INNOCUOUS|SQLITE_RESULT_SUBTYPE,
+          p, fts5LocaleFunc, 0, 0
+      );
+    }
   }
 
   /* If SQLITE_FTS5_ENABLE_TEST_MI is defined, assume that the file
@@ -250687,13 +255210,40 @@ SQLITE_PRIVATE int sqlite3Fts5Init(sqlite3 *db){
 
 /* #include "fts5Int.h" */
 
+/*
+** pSavedRow:
+**   SQL statement FTS5_STMT_LOOKUP2 is a copy of FTS5_STMT_LOOKUP, it
+**   does a by-rowid lookup to retrieve a single row from the %_content
+**   table or equivalent external-content table/view.
+**
+**   However, FTS5_STMT_LOOKUP2 is only used when retrieving the original
+**   values for a row being UPDATEd. In that case, the SQL statement is
+**   not reset and pSavedRow is set to point at it. This is so that the
+**   insert operation that follows the delete may access the original
+**   row values for any new values for which sqlite3_value_nochange() returns
+**   true. i.e. if the user executes:
+**
+**        CREATE VIRTUAL TABLE ft USING fts5(a, b, c, locale=1);
+**        ...
+**        UPDATE fts SET a=?, b=? WHERE rowid=?;
+**
+**   then the value passed to the xUpdate() method of this table as the
+**   new.c value is an sqlite3_value_nochange() value. So in this case it
+**   must be read from the saved row stored in Fts5Storage.pSavedRow.
+**
+**   This is necessary - using sqlite3_value_nochange() instead of just having
+**   SQLite pass the original value back via xUpdate() - so as not to discard
+**   any locale information associated with such values.
+**
+*/
 struct Fts5Storage {
   Fts5Config *pConfig;
   Fts5Index *pIndex;
   int bTotalsValid;               /* True if nTotalRow/aTotalSize[] are valid */
   i64 nTotalRow;                  /* Total number of rows in FTS table */
   i64 *aTotalSize;                /* Total sizes of each column */
-  sqlite3_stmt *aStmt[11];
+  sqlite3_stmt *pSavedRow;
+  sqlite3_stmt *aStmt[12];
 };
 
 
@@ -250707,14 +255257,15 @@ struct Fts5Storage {
 # error "FTS5_STMT_LOOKUP mismatch"
 #endif
 
-#define FTS5_STMT_INSERT_CONTENT  3
-#define FTS5_STMT_REPLACE_CONTENT 4
-#define FTS5_STMT_DELETE_CONTENT  5
-#define FTS5_STMT_REPLACE_DOCSIZE  6
-#define FTS5_STMT_DELETE_DOCSIZE  7
-#define FTS5_STMT_LOOKUP_DOCSIZE  8
-#define FTS5_STMT_REPLACE_CONFIG 9
-#define FTS5_STMT_SCAN 10
+#define FTS5_STMT_LOOKUP2         3
+#define FTS5_STMT_INSERT_CONTENT  4
+#define FTS5_STMT_REPLACE_CONTENT 5
+#define FTS5_STMT_DELETE_CONTENT  6
+#define FTS5_STMT_REPLACE_DOCSIZE 7
+#define FTS5_STMT_DELETE_DOCSIZE  8
+#define FTS5_STMT_LOOKUP_DOCSIZE  9
+#define FTS5_STMT_REPLACE_CONFIG 10
+#define FTS5_STMT_SCAN           11
 
 /*
 ** Prepare the two insert statements - Fts5Storage.pInsertContent and
@@ -250744,6 +255295,7 @@ static int fts5StorageGetStmt(
       "SELECT %s FROM %s T WHERE T.%Q >= ? AND T.%Q <= ? ORDER BY T.%Q ASC",
       "SELECT %s FROM %s T WHERE T.%Q <= ? AND T.%Q >= ? ORDER BY T.%Q DESC",
       "SELECT %s FROM %s T WHERE T.%Q=?",               /* LOOKUP  */
+      "SELECT %s FROM %s T WHERE T.%Q=?",               /* LOOKUP2  */
 
       "INSERT INTO %Q.'%q_content' VALUES(%s)",         /* INSERT_CONTENT  */
       "REPLACE INTO %Q.'%q_content' VALUES(%s)",        /* REPLACE_CONTENT */
@@ -250759,6 +255311,8 @@ static int fts5StorageGetStmt(
     Fts5Config *pC = p->pConfig;
     char *zSql = 0;
 
+    assert( ArraySize(azStmt)==ArraySize(p->aStmt) );
+
     switch( eStmt ){
       case FTS5_STMT_SCAN:
         zSql = sqlite3_mprintf(azStmt[eStmt],
@@ -250775,6 +255329,7 @@ static int fts5StorageGetStmt(
         break;
 
       case FTS5_STMT_LOOKUP:
+      case FTS5_STMT_LOOKUP2:
         zSql = sqlite3_mprintf(azStmt[eStmt],
             pC->zContentExprlist, pC->zContent, pC->zContentRowid
         );
@@ -250782,20 +255337,35 @@ static int fts5StorageGetStmt(
 
       case FTS5_STMT_INSERT_CONTENT:
       case FTS5_STMT_REPLACE_CONTENT: {
-        int nCol = pC->nCol + 1;
-        char *zBind;
+        char *zBind = 0;
         int i;
 
-        zBind = sqlite3_malloc64(1 + nCol*2);
-        if( zBind ){
-          for(i=0; i<nCol; i++){
-            zBind[i*2] = '?';
-            zBind[i*2 + 1] = ',';
+        assert( pC->eContent==FTS5_CONTENT_NORMAL
+             || pC->eContent==FTS5_CONTENT_UNINDEXED
+        );
+
+        /* Add bindings for the "c*" columns - those that store the actual
+        ** table content. If eContent==NORMAL, then there is one binding
+        ** for each column. Or, if eContent==UNINDEXED, then there are only
+        ** bindings for the UNINDEXED columns. */
+        for(i=0; rc==SQLITE_OK && i<(pC->nCol+1); i++){
+          if( !i || pC->eContent==FTS5_CONTENT_NORMAL || pC->abUnindexed[i-1] ){
+            zBind = sqlite3Fts5Mprintf(&rc, "%z%s?%d", zBind, zBind?",":"",i+1);
           }
-          zBind[i*2-1] = '\0';
-          zSql = sqlite3_mprintf(azStmt[eStmt], pC->zDb, pC->zName, zBind);
-          sqlite3_free(zBind);
         }
+
+        /* Add bindings for any "l*" columns. Only non-UNINDEXED columns
+        ** require these.  */
+        if( pC->bLocale && pC->eContent==FTS5_CONTENT_NORMAL ){
+          for(i=0; rc==SQLITE_OK && i<pC->nCol; i++){
+            if( pC->abUnindexed[i]==0 ){
+              zBind = sqlite3Fts5Mprintf(&rc, "%z,?%d", zBind, pC->nCol+i+2);
+            }
+          }
+        }
+
+        zSql = sqlite3Fts5Mprintf(&rc, azStmt[eStmt], pC->zDb, pC->zName,zBind);
+        sqlite3_free(zBind);
         break;
       }
 
@@ -250821,7 +255391,7 @@ static int fts5StorageGetStmt(
       rc = SQLITE_NOMEM;
     }else{
       int f = SQLITE_PREPARE_PERSISTENT;
-      if( eStmt>FTS5_STMT_LOOKUP ) f |= SQLITE_PREPARE_NO_VTAB;
+      if( eStmt>FTS5_STMT_LOOKUP2 ) f |= SQLITE_PREPARE_NO_VTAB;
       p->pConfig->bLock++;
       rc = sqlite3_prepare_v3(pC->db, zSql, -1, f, &p->aStmt[eStmt], 0);
       p->pConfig->bLock--;
@@ -250981,9 +255551,11 @@ static int sqlite3Fts5StorageOpen(
   p->pIndex = pIndex;
 
   if( bCreate ){
-    if( pConfig->eContent==FTS5_CONTENT_NORMAL ){
+    if( pConfig->eContent==FTS5_CONTENT_NORMAL
+     || pConfig->eContent==FTS5_CONTENT_UNINDEXED
+    ){
       int nDefn = 32 + pConfig->nCol*10;
-      char *zDefn = sqlite3_malloc64(32 + (sqlite3_int64)pConfig->nCol * 10);
+      char *zDefn = sqlite3_malloc64(32 + (sqlite3_int64)pConfig->nCol * 20);
       if( zDefn==0 ){
         rc = SQLITE_NOMEM;
       }else{
@@ -250992,8 +255564,20 @@ static int sqlite3Fts5StorageOpen(
         sqlite3_snprintf(nDefn, zDefn, "id INTEGER PRIMARY KEY");
         iOff = (int)strlen(zDefn);
         for(i=0; i<pConfig->nCol; i++){
-          sqlite3_snprintf(nDefn-iOff, &zDefn[iOff], ", c%d", i);
-          iOff += (int)strlen(&zDefn[iOff]);
+          if( pConfig->eContent==FTS5_CONTENT_NORMAL
+           || pConfig->abUnindexed[i]
+          ){
+            sqlite3_snprintf(nDefn-iOff, &zDefn[iOff], ", c%d", i);
+            iOff += (int)strlen(&zDefn[iOff]);
+          }
+        }
+        if( pConfig->bLocale ){
+          for(i=0; i<pConfig->nCol; i++){
+            if( pConfig->abUnindexed[i]==0 ){
+              sqlite3_snprintf(nDefn-iOff, &zDefn[iOff], ", l%d", i);
+              iOff += (int)strlen(&zDefn[iOff]);
+            }
+          }
         }
         rc = sqlite3Fts5CreateTable(pConfig, "content", zDefn, 0, pzErr);
       }
@@ -251070,15 +255654,49 @@ static int fts5StorageInsertCallback(
   return sqlite3Fts5IndexWrite(pIdx, pCtx->iCol, pCtx->szCol-1, pToken, nToken);
 }
 
+/*
+** This function is used as part of an UPDATE statement that modifies the
+** rowid of a row. In that case, this function is called first to set
+** Fts5Storage.pSavedRow to point to a statement that may be used to
+** access the original values of the row being deleted - iDel.
+**
+** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
+** It is not considered an error if row iDel does not exist. In this case
+** pSavedRow is not set and SQLITE_OK returned.
+*/
+static int sqlite3Fts5StorageFindDeleteRow(Fts5Storage *p, i64 iDel){
+  int rc = SQLITE_OK;
+  sqlite3_stmt *pSeek = 0;
+
+  assert( p->pSavedRow==0 );
+  rc = fts5StorageGetStmt(p, FTS5_STMT_LOOKUP+1, &pSeek, 0);
+  if( rc==SQLITE_OK ){
+    sqlite3_bind_int64(pSeek, 1, iDel);
+    if( sqlite3_step(pSeek)!=SQLITE_ROW ){
+      rc = sqlite3_reset(pSeek);
+    }else{
+      p->pSavedRow = pSeek;
+    }
+  }
+
+  return rc;
+}
+
 /*
 ** If a row with rowid iDel is present in the %_content table, add the
 ** delete-markers to the FTS index necessary to delete it. Do not actually
 ** remove the %_content row at this time though.
+**
+** If parameter bSaveRow is true, then Fts5Storage.pSavedRow is left
+** pointing to a statement (FTS5_STMT_LOOKUP2) that may be used to access
+** the original values of the row being deleted. This is used by UPDATE
+** statements.
 */
 static int fts5StorageDeleteFromIndex(
   Fts5Storage *p,
   i64 iDel,
-  sqlite3_value **apVal
+  sqlite3_value **apVal,
+  int bSaveRow                    /* True to set pSavedRow */
 ){
   Fts5Config *pConfig = p->pConfig;
   sqlite3_stmt *pSeek = 0;        /* SELECT to read row iDel from %_data */
@@ -251087,12 +255705,21 @@ static int fts5StorageDeleteFromIndex(
   int iCol;
   Fts5InsertCtx ctx;
 
+  assert( bSaveRow==0 || apVal==0 );
+  assert( bSaveRow==0 || bSaveRow==1 );
+  assert( FTS5_STMT_LOOKUP2==FTS5_STMT_LOOKUP+1 );
+
   if( apVal==0 ){
-    rc = fts5StorageGetStmt(p, FTS5_STMT_LOOKUP, &pSeek, 0);
-    if( rc!=SQLITE_OK ) return rc;
-    sqlite3_bind_int64(pSeek, 1, iDel);
-    if( sqlite3_step(pSeek)!=SQLITE_ROW ){
-      return sqlite3_reset(pSeek);
+    if( p->pSavedRow && bSaveRow ){
+      pSeek = p->pSavedRow;
+      p->pSavedRow = 0;
+    }else{
+      rc = fts5StorageGetStmt(p, FTS5_STMT_LOOKUP+bSaveRow, &pSeek, 0);
+      if( rc!=SQLITE_OK ) return rc;
+      sqlite3_bind_int64(pSeek, 1, iDel);
+      if( sqlite3_step(pSeek)!=SQLITE_ROW ){
+        return sqlite3_reset(pSeek);
+      }
     }
   }
 
@@ -251100,26 +255727,42 @@ static int fts5StorageDeleteFromIndex(
   ctx.iCol = -1;
   for(iCol=1; rc==SQLITE_OK && iCol<=pConfig->nCol; iCol++){
     if( pConfig->abUnindexed[iCol-1]==0 ){
-      const char *zText;
-      int nText;
+      sqlite3_value *pVal = 0;
+      const char *pText = 0;
+      int nText = 0;
+      const char *pLoc = 0;
+      int nLoc = 0;
+
       assert( pSeek==0 || apVal==0 );
       assert( pSeek!=0 || apVal!=0 );
       if( pSeek ){
-        zText = (const char*)sqlite3_column_text(pSeek, iCol);
-        nText = sqlite3_column_bytes(pSeek, iCol);
-      }else if( ALWAYS(apVal) ){
-        zText = (const char*)sqlite3_value_text(apVal[iCol-1]);
-        nText = sqlite3_value_bytes(apVal[iCol-1]);
+        pVal = sqlite3_column_value(pSeek, iCol);
       }else{
-        continue;
+        pVal = apVal[iCol-1];
       }
-      ctx.szCol = 0;
-      rc = sqlite3Fts5Tokenize(pConfig, FTS5_TOKENIZE_DOCUMENT,
-          zText, nText, (void*)&ctx, fts5StorageInsertCallback
-      );
-      p->aTotalSize[iCol-1] -= (i64)ctx.szCol;
-      if( p->aTotalSize[iCol-1]<0 ){
-        rc = FTS5_CORRUPT;
+
+      if( pConfig->bLocale && sqlite3Fts5IsLocaleValue(pConfig, pVal) ){
+        rc = sqlite3Fts5DecodeLocaleValue(pVal, &pText, &nText, &pLoc, &nLoc);
+      }else{
+        pText = (const char*)sqlite3_value_text(pVal);
+        nText = sqlite3_value_bytes(pVal);
+        if( pConfig->bLocale && pSeek ){
+          pLoc = (const char*)sqlite3_column_text(pSeek, iCol + pConfig->nCol);
+          nLoc = sqlite3_column_bytes(pSeek, iCol + pConfig->nCol);
+        }
+      }
+
+      if( rc==SQLITE_OK ){
+        sqlite3Fts5SetLocale(pConfig, pLoc, nLoc);
+        ctx.szCol = 0;
+        rc = sqlite3Fts5Tokenize(pConfig, FTS5_TOKENIZE_DOCUMENT,
+            pText, nText, (void*)&ctx, fts5StorageInsertCallback
+        );
+        p->aTotalSize[iCol-1] -= (i64)ctx.szCol;
+        if( rc==SQLITE_OK && p->aTotalSize[iCol-1]<0 ){
+          rc = FTS5_CORRUPT;
+        }
+        sqlite3Fts5ClearLocale(pConfig);
       }
     }
   }
@@ -251129,11 +255772,29 @@ static int fts5StorageDeleteFromIndex(
     p->nTotalRow--;
   }
 
-  rc2 = sqlite3_reset(pSeek);
-  if( rc==SQLITE_OK ) rc = rc2;
+  if( rc==SQLITE_OK && bSaveRow ){
+    assert( p->pSavedRow==0 );
+    p->pSavedRow = pSeek;
+  }else{
+    rc2 = sqlite3_reset(pSeek);
+    if( rc==SQLITE_OK ) rc = rc2;
+  }
   return rc;
 }
 
+/*
+** Reset any saved statement pSavedRow. Zero pSavedRow as well. This
+** should be called by the xUpdate() method of the fts5 table before
+** returning from any operation that may have set Fts5Storage.pSavedRow.
+*/
+static void sqlite3Fts5StorageReleaseDeleteRow(Fts5Storage *pStorage){
+  assert( pStorage->pSavedRow==0
+       || pStorage->pSavedRow==pStorage->aStmt[FTS5_STMT_LOOKUP2]
+  );
+  sqlite3_reset(pStorage->pSavedRow);
+  pStorage->pSavedRow = 0;
+}
+
 /*
 ** This function is called to process a DELETE on a contentless_delete=1
 ** table. It adds the tombstone required to delete the entry with rowid
@@ -251146,7 +255807,9 @@ static int fts5StorageContentlessDelete(Fts5Storage *p, i64 iDel){
   int rc = SQLITE_OK;
 
   assert( p->pConfig->bContentlessDelete );
-  assert( p->pConfig->eContent==FTS5_CONTENT_NONE );
+  assert( p->pConfig->eContent==FTS5_CONTENT_NONE
+       || p->pConfig->eContent==FTS5_CONTENT_UNINDEXED
+  );
 
   /* Look up the origin of the document in the %_docsize table. Store
   ** this in stack variable iOrigin.  */
@@ -251190,12 +255853,12 @@ static int fts5StorageInsertDocsize(
         rc = sqlite3Fts5IndexGetOrigin(p->pIndex, &iOrigin);
         sqlite3_bind_int64(pReplace, 3, iOrigin);
       }
-      if( rc==SQLITE_OK ){
-        sqlite3_bind_blob(pReplace, 2, pBuf->p, pBuf->n, SQLITE_STATIC);
-        sqlite3_step(pReplace);
-        rc = sqlite3_reset(pReplace);
-        sqlite3_bind_null(pReplace, 2);
-      }
+    }
+    if( rc==SQLITE_OK ){
+      sqlite3_bind_blob(pReplace, 2, pBuf->p, pBuf->n, SQLITE_STATIC);
+      sqlite3_step(pReplace);
+      rc = sqlite3_reset(pReplace);
+      sqlite3_bind_null(pReplace, 2);
     }
   }
   return rc;
@@ -251249,7 +255912,12 @@ static int fts5StorageSaveTotals(Fts5Storage *p){
 /*
 ** Remove a row from the FTS table.
 */
-static int sqlite3Fts5StorageDelete(Fts5Storage *p, i64 iDel, sqlite3_value **apVal){
+static int sqlite3Fts5StorageDelete(
+  Fts5Storage *p,                 /* Storage object */
+  i64 iDel,                       /* Rowid to delete from table */
+  sqlite3_value **apVal,          /* Optional - values to remove from index */
+  int bSaveRow                    /* If true, set pSavedRow for deleted row */
+){
   Fts5Config *pConfig = p->pConfig;
   int rc;
   sqlite3_stmt *pDel = 0;
@@ -251265,8 +255933,14 @@ static int sqlite3Fts5StorageDelete(Fts5Storage *p, i64 iDel, sqlite3_value **ap
   if( rc==SQLITE_OK ){
     if( p->pConfig->bContentlessDelete ){
       rc = fts5StorageContentlessDelete(p, iDel);
+      if( rc==SQLITE_OK
+       && bSaveRow
+       && p->pConfig->eContent==FTS5_CONTENT_UNINDEXED
+      ){
+        rc = sqlite3Fts5StorageFindDeleteRow(p, iDel);
+      }
     }else{
-      rc = fts5StorageDeleteFromIndex(p, iDel, apVal);
+      rc = fts5StorageDeleteFromIndex(p, iDel, apVal, bSaveRow);
     }
   }
 
@@ -251281,7 +255955,9 @@ static int sqlite3Fts5StorageDelete(Fts5Storage *p, i64 iDel, sqlite3_value **ap
   }
 
   /* Delete the %_content record */
-  if( pConfig->eContent==FTS5_CONTENT_NORMAL ){
+  if( pConfig->eContent==FTS5_CONTENT_NORMAL
+   || pConfig->eContent==FTS5_CONTENT_UNINDEXED
+  ){
     if( rc==SQLITE_OK ){
       rc = fts5StorageGetStmt(p, FTS5_STMT_DELETE_CONTENT, &pDel, 0);
     }
@@ -251313,8 +255989,13 @@ static int sqlite3Fts5StorageDeleteAll(Fts5Storage *p){
   );
   if( rc==SQLITE_OK && pConfig->bColumnsize ){
     rc = fts5ExecPrintf(pConfig->db, 0,
-        "DELETE FROM %Q.'%q_docsize';",
-        pConfig->zDb, pConfig->zName
+        "DELETE FROM %Q.'%q_docsize';", pConfig->zDb, pConfig->zName
+    );
+  }
+
+  if( rc==SQLITE_OK && pConfig->eContent==FTS5_CONTENT_UNINDEXED ){
+    rc = fts5ExecPrintf(pConfig->db, 0,
+        "DELETE FROM %Q.'%q_content';", pConfig->zDb, pConfig->zName
     );
   }
 
@@ -251355,14 +256036,36 @@ static int sqlite3Fts5StorageRebuild(Fts5Storage *p){
     for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
       ctx.szCol = 0;
       if( pConfig->abUnindexed[ctx.iCol]==0 ){
-        const char *zText = (const char*)sqlite3_column_text(pScan, ctx.iCol+1);
-        int nText = sqlite3_column_bytes(pScan, ctx.iCol+1);
-        rc = sqlite3Fts5Tokenize(pConfig,
-            FTS5_TOKENIZE_DOCUMENT,
-            zText, nText,
-            (void*)&ctx,
-            fts5StorageInsertCallback
-        );
+        int nText = 0;            /* Size of pText in bytes */
+        const char *pText = 0;    /* Pointer to buffer containing text value */
+        int nLoc = 0;             /* Size of pLoc in bytes */
+        const char *pLoc = 0;     /* Pointer to buffer containing text value */
+
+        sqlite3_value *pVal = sqlite3_column_value(pScan, ctx.iCol+1);
+        if( pConfig->eContent==FTS5_CONTENT_EXTERNAL
+         && sqlite3Fts5IsLocaleValue(pConfig, pVal)
+        ){
+          rc = sqlite3Fts5DecodeLocaleValue(pVal, &pText, &nText, &pLoc, &nLoc);
+        }else{
+          pText = (const char*)sqlite3_value_text(pVal);
+          nText = sqlite3_value_bytes(pVal);
+          if( pConfig->bLocale ){
+            int iCol = ctx.iCol + 1 + pConfig->nCol;
+            pLoc = (const char*)sqlite3_column_text(pScan, iCol);
+            nLoc = sqlite3_column_bytes(pScan, iCol);
+          }
+        }
+
+        if( rc==SQLITE_OK ){
+          sqlite3Fts5SetLocale(pConfig, pLoc, nLoc);
+          rc = sqlite3Fts5Tokenize(pConfig,
+              FTS5_TOKENIZE_DOCUMENT,
+              pText, nText,
+              (void*)&ctx,
+              fts5StorageInsertCallback
+          );
+          sqlite3Fts5ClearLocale(pConfig);
+        }
       }
       sqlite3Fts5BufferAppendVarint(&rc, &buf, ctx.szCol);
       p->aTotalSize[ctx.iCol] += (i64)ctx.szCol;
@@ -251428,6 +256131,7 @@ static int fts5StorageNewRowid(Fts5Storage *p, i64 *piRowid){
 */
 static int sqlite3Fts5StorageContentInsert(
   Fts5Storage *p,
+  int bReplace,                   /* True to use REPLACE instead of INSERT */
   sqlite3_value **apVal,
   i64 *piRowid
 ){
@@ -251435,7 +256139,9 @@ static int sqlite3Fts5StorageContentInsert(
   int rc = SQLITE_OK;
 
   /* Insert the new row into the %_content table. */
-  if( pConfig->eContent!=FTS5_CONTENT_NORMAL ){
+  if( pConfig->eContent!=FTS5_CONTENT_NORMAL
+   && pConfig->eContent!=FTS5_CONTENT_UNINDEXED
+  ){
     if( sqlite3_value_type(apVal[1])==SQLITE_INTEGER ){
       *piRowid = sqlite3_value_int64(apVal[1]);
     }else{
@@ -251444,9 +256150,52 @@ static int sqlite3Fts5StorageContentInsert(
   }else{
     sqlite3_stmt *pInsert = 0;    /* Statement to write %_content table */
     int i;                        /* Counter variable */
-    rc = fts5StorageGetStmt(p, FTS5_STMT_INSERT_CONTENT, &pInsert, 0);
-    for(i=1; rc==SQLITE_OK && i<=pConfig->nCol+1; i++){
-      rc = sqlite3_bind_value(pInsert, i, apVal[i]);
+
+    assert( FTS5_STMT_INSERT_CONTENT+1==FTS5_STMT_REPLACE_CONTENT );
+    assert( bReplace==0 || bReplace==1 );
+    rc = fts5StorageGetStmt(p, FTS5_STMT_INSERT_CONTENT+bReplace, &pInsert, 0);
+    if( pInsert ) sqlite3_clear_bindings(pInsert);
+
+    /* Bind the rowid value */
+    sqlite3_bind_value(pInsert, 1, apVal[1]);
+
+    /* Loop through values for user-defined columns. i=2 is the leftmost
+    ** user-defined column. As is column 1 of pSavedRow.  */
+    for(i=2; rc==SQLITE_OK && i<=pConfig->nCol+1; i++){
+      int bUnindexed = pConfig->abUnindexed[i-2];
+      if( pConfig->eContent==FTS5_CONTENT_NORMAL || bUnindexed ){
+        sqlite3_value *pVal = apVal[i];
+
+        if( sqlite3_value_nochange(pVal) && p->pSavedRow ){
+          /* This is an UPDATE statement, and user-defined column (i-2) was not
+          ** modified.  Retrieve the value from Fts5Storage.pSavedRow.  */
+          pVal = sqlite3_column_value(p->pSavedRow, i-1);
+          if( pConfig->bLocale && bUnindexed==0 ){
+            sqlite3_bind_value(pInsert, pConfig->nCol + i,
+                sqlite3_column_value(p->pSavedRow, pConfig->nCol + i - 1)
+            );
+          }
+        }else if( sqlite3Fts5IsLocaleValue(pConfig, pVal) ){
+          const char *pText = 0;
+          const char *pLoc = 0;
+          int nText = 0;
+          int nLoc = 0;
+          assert( pConfig->bLocale );
+
+          rc = sqlite3Fts5DecodeLocaleValue(pVal, &pText, &nText, &pLoc, &nLoc);
+          if( rc==SQLITE_OK ){
+            sqlite3_bind_text(pInsert, i, pText, nText, SQLITE_TRANSIENT);
+            if( bUnindexed==0 ){
+              int iLoc = pConfig->nCol + i;
+              sqlite3_bind_text(pInsert, iLoc, pLoc, nLoc, SQLITE_TRANSIENT);
+            }
+          }
+
+          continue;
+        }
+
+        rc = sqlite3_bind_value(pInsert, i, pVal);
+      }
     }
     if( rc==SQLITE_OK ){
       sqlite3_step(pInsert);
@@ -251481,14 +256230,38 @@ static int sqlite3Fts5StorageIndexInsert(
   for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
     ctx.szCol = 0;
     if( pConfig->abUnindexed[ctx.iCol]==0 ){
-      const char *zText = (const char*)sqlite3_value_text(apVal[ctx.iCol+2]);
-      int nText = sqlite3_value_bytes(apVal[ctx.iCol+2]);
-      rc = sqlite3Fts5Tokenize(pConfig,
-          FTS5_TOKENIZE_DOCUMENT,
-          zText, nText,
-          (void*)&ctx,
-          fts5StorageInsertCallback
-      );
+      int nText = 0;              /* Size of pText in bytes */
+      const char *pText = 0;      /* Pointer to buffer containing text value */
+      int nLoc = 0;               /* Size of pText in bytes */
+      const char *pLoc = 0;       /* Pointer to buffer containing text value */
+
+      sqlite3_value *pVal = apVal[ctx.iCol+2];
+      if( p->pSavedRow && sqlite3_value_nochange(pVal) ){
+        pVal = sqlite3_column_value(p->pSavedRow, ctx.iCol+1);
+        if( pConfig->eContent==FTS5_CONTENT_NORMAL && pConfig->bLocale ){
+          int iCol = ctx.iCol + 1 + pConfig->nCol;
+          pLoc = (const char*)sqlite3_column_text(p->pSavedRow, iCol);
+          nLoc = sqlite3_column_bytes(p->pSavedRow, iCol);
+        }
+      }else{
+        pVal = apVal[ctx.iCol+2];
+      }
+
+      if( pConfig->bLocale && sqlite3Fts5IsLocaleValue(pConfig, pVal) ){
+        rc = sqlite3Fts5DecodeLocaleValue(pVal, &pText, &nText, &pLoc, &nLoc);
+      }else{
+        pText = (const char*)sqlite3_value_text(pVal);
+        nText = sqlite3_value_bytes(pVal);
+      }
+
+      if( rc==SQLITE_OK ){
+        sqlite3Fts5SetLocale(pConfig, pLoc, nLoc);
+        rc = sqlite3Fts5Tokenize(pConfig,
+            FTS5_TOKENIZE_DOCUMENT, pText, nText, (void*)&ctx,
+            fts5StorageInsertCallback
+        );
+        sqlite3Fts5ClearLocale(pConfig);
+      }
     }
     sqlite3Fts5BufferAppendVarint(&rc, &buf, ctx.szCol);
     p->aTotalSize[ctx.iCol] += (i64)ctx.szCol;
@@ -251652,29 +256425,61 @@ static int sqlite3Fts5StorageIntegrity(Fts5Storage *p, int iArg){
           rc = sqlite3Fts5TermsetNew(&ctx.pTermset);
         }
         for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){
-          if( pConfig->abUnindexed[i] ) continue;
-          ctx.iCol = i;
-          ctx.szCol = 0;
-          if( pConfig->eDetail==FTS5_DETAIL_COLUMNS ){
-            rc = sqlite3Fts5TermsetNew(&ctx.pTermset);
-          }
-          if( rc==SQLITE_OK ){
-            const char *zText = (const char*)sqlite3_column_text(pScan, i+1);
-            int nText = sqlite3_column_bytes(pScan, i+1);
-            rc = sqlite3Fts5Tokenize(pConfig,
-                FTS5_TOKENIZE_DOCUMENT,
-                zText, nText,
-                (void*)&ctx,
-                fts5StorageIntegrityCallback
-            );
-          }
-          if( rc==SQLITE_OK && pConfig->bColumnsize && ctx.szCol!=aColSize[i] ){
-            rc = FTS5_CORRUPT;
-          }
-          aTotalSize[i] += ctx.szCol;
-          if( pConfig->eDetail==FTS5_DETAIL_COLUMNS ){
-            sqlite3Fts5TermsetFree(ctx.pTermset);
-            ctx.pTermset = 0;
+          if( pConfig->abUnindexed[i]==0 ){
+            const char *pText = 0;
+            int nText = 0;
+            const char *pLoc = 0;
+            int nLoc = 0;
+            sqlite3_value *pVal = sqlite3_column_value(pScan, i+1);
+
+            if( pConfig->eContent==FTS5_CONTENT_EXTERNAL
+             && sqlite3Fts5IsLocaleValue(pConfig, pVal)
+            ){
+              rc = sqlite3Fts5DecodeLocaleValue(
+                  pVal, &pText, &nText, &pLoc, &nLoc
+              );
+            }else{
+              if( pConfig->eContent==FTS5_CONTENT_NORMAL && pConfig->bLocale ){
+                int iCol = i + 1 + pConfig->nCol;
+                pLoc = (const char*)sqlite3_column_text(pScan, iCol);
+                nLoc = sqlite3_column_bytes(pScan, iCol);
+              }
+              pText = (const char*)sqlite3_value_text(pVal);
+              nText = sqlite3_value_bytes(pVal);
+            }
+
+            ctx.iCol = i;
+            ctx.szCol = 0;
+
+            if( rc==SQLITE_OK && pConfig->eDetail==FTS5_DETAIL_COLUMNS ){
+              rc = sqlite3Fts5TermsetNew(&ctx.pTermset);
+            }
+
+            if( rc==SQLITE_OK ){
+              sqlite3Fts5SetLocale(pConfig, pLoc, nLoc);
+              rc = sqlite3Fts5Tokenize(pConfig,
+                  FTS5_TOKENIZE_DOCUMENT,
+                  pText, nText,
+                  (void*)&ctx,
+                  fts5StorageIntegrityCallback
+              );
+              sqlite3Fts5ClearLocale(pConfig);
+            }
+
+            /* If this is not a columnsize=0 database, check that the number
+            ** of tokens in the value matches the aColSize[] value read from
+            ** the %_docsize table.  */
+            if( rc==SQLITE_OK
+             && pConfig->bColumnsize
+             && ctx.szCol!=aColSize[i]
+            ){
+              rc = FTS5_CORRUPT;
+            }
+            aTotalSize[i] += ctx.szCol;
+            if( pConfig->eDetail==FTS5_DETAIL_COLUMNS ){
+              sqlite3Fts5TermsetFree(ctx.pTermset);
+              ctx.pTermset = 0;
+            }
           }
         }
         sqlite3Fts5TermsetFree(ctx.pTermset);
@@ -252100,7 +256905,7 @@ static const unsigned char sqlite3Utf8Trans1[] = {
   c = *(zIn++);                                            \
   if( c>=0xc0 ){                                           \
     c = sqlite3Utf8Trans1[c-0xc0];                         \
-    while( zIn!=zTerm && (*zIn & 0xc0)==0x80 ){            \
+    while( zIn<zTerm && (*zIn & 0xc0)==0x80 ){             \
       c = (c<<6) + (0x3f & *(zIn++));                      \
     }                                                      \
     if( c<0x80                                             \
@@ -252288,7 +257093,6 @@ static int fts5UnicodeCreate(
           zCat = azArg[i+1];
         }
       }
-
       if( rc==SQLITE_OK ){
         rc = unicodeSetCategories(p, zCat);
       }
@@ -252318,7 +257122,6 @@ static int fts5UnicodeCreate(
           rc = SQLITE_ERROR;
         }
       }
-
     }else{
       rc = SQLITE_NOMEM;
     }
@@ -252457,7 +257260,7 @@ static int fts5UnicodeTokenize(
 
 typedef struct PorterTokenizer PorterTokenizer;
 struct PorterTokenizer {
-  fts5_tokenizer tokenizer;       /* Parent tokenizer module */
+  fts5_tokenizer_v2 tokenizer_v2; /* Parent tokenizer module */
   Fts5Tokenizer *pTokenizer;      /* Parent tokenizer instance */
   char aBuf[FTS5_PORTER_MAX_TOKEN + 64];
 };
@@ -252469,7 +257272,7 @@ static void fts5PorterDelete(Fts5Tokenizer *pTok){
   if( pTok ){
     PorterTokenizer *p = (PorterTokenizer*)pTok;
     if( p->pTokenizer ){
-      p->tokenizer.xDelete(p->pTokenizer);
+      p->tokenizer_v2.xDelete(p->pTokenizer);
     }
     sqlite3_free(p);
   }
@@ -252488,6 +257291,7 @@ static int fts5PorterCreate(
   PorterTokenizer *pRet;
   void *pUserdata = 0;
   const char *zBase = "unicode61";
+  fts5_tokenizer_v2 *pV2 = 0;
 
   if( nArg>0 ){
     zBase = azArg[0];
@@ -252496,14 +257300,15 @@ static int fts5PorterCreate(
   pRet = (PorterTokenizer*)sqlite3_malloc(sizeof(PorterTokenizer));
   if( pRet ){
     memset(pRet, 0, sizeof(PorterTokenizer));
-    rc = pApi->xFindTokenizer(pApi, zBase, &pUserdata, &pRet->tokenizer);
+    rc = pApi->xFindTokenizer_v2(pApi, zBase, &pUserdata, &pV2);
   }else{
     rc = SQLITE_NOMEM;
   }
   if( rc==SQLITE_OK ){
     int nArg2 = (nArg>0 ? nArg-1 : 0);
-    const char **azArg2 = (nArg2 ? &azArg[1] : 0);
-    rc = pRet->tokenizer.xCreate(pUserdata, azArg2, nArg2, &pRet->pTokenizer);
+    const char **az2 = (nArg2 ? &azArg[1] : 0);
+    memcpy(&pRet->tokenizer_v2, pV2, sizeof(fts5_tokenizer_v2));
+    rc = pRet->tokenizer_v2.xCreate(pUserdata, az2, nArg2, &pRet->pTokenizer);
   }
 
   if( rc!=SQLITE_OK ){
@@ -253154,6 +257959,7 @@ static int fts5PorterTokenize(
   void *pCtx,
   int flags,
   const char *pText, int nText,
+  const char *pLoc, int nLoc,
   int (*xToken)(void*, int, const char*, int nToken, int iStart, int iEnd)
 ){
   PorterTokenizer *p = (PorterTokenizer*)pTokenizer;
@@ -253161,8 +257967,8 @@ static int fts5PorterTokenize(
   sCtx.xToken = xToken;
   sCtx.pCtx = pCtx;
   sCtx.aBuf = p->aBuf;
-  return p->tokenizer.xTokenize(
-      p->pTokenizer, (void*)&sCtx, flags, pText, nText, fts5PorterCb
+  return p->tokenizer_v2.xTokenize(
+      p->pTokenizer, (void*)&sCtx, flags, pText, nText, pLoc, nLoc, fts5PorterCb
   );
 }
 
@@ -253192,40 +257998,46 @@ static int fts5TriCreate(
   Fts5Tokenizer **ppOut
 ){
   int rc = SQLITE_OK;
-  TrigramTokenizer *pNew = (TrigramTokenizer*)sqlite3_malloc(sizeof(*pNew));
+  TrigramTokenizer *pNew = 0;
   UNUSED_PARAM(pUnused);
-  if( pNew==0 ){
-    rc = SQLITE_NOMEM;
+  if( nArg%2 ){
+    rc = SQLITE_ERROR;
   }else{
     int i;
-    pNew->bFold = 1;
-    pNew->iFoldParam = 0;
-    for(i=0; rc==SQLITE_OK && i<nArg; i+=2){
-      const char *zArg = azArg[i+1];
-      if( 0==sqlite3_stricmp(azArg[i], "case_sensitive") ){
-        if( (zArg[0]!='0' && zArg[0]!='1') || zArg[1] ){
-          rc = SQLITE_ERROR;
+    pNew = (TrigramTokenizer*)sqlite3_malloc(sizeof(*pNew));
+    if( pNew==0 ){
+      rc = SQLITE_NOMEM;
+    }else{
+      pNew->bFold = 1;
+      pNew->iFoldParam = 0;
+
+      for(i=0; rc==SQLITE_OK && i<nArg; i+=2){
+        const char *zArg = azArg[i+1];
+        if( 0==sqlite3_stricmp(azArg[i], "case_sensitive") ){
+          if( (zArg[0]!='0' && zArg[0]!='1') || zArg[1] ){
+            rc = SQLITE_ERROR;
+          }else{
+            pNew->bFold = (zArg[0]=='0');
+          }
+        }else if( 0==sqlite3_stricmp(azArg[i], "remove_diacritics") ){
+          if( (zArg[0]!='0' && zArg[0]!='1' && zArg[0]!='2') || zArg[1] ){
+            rc = SQLITE_ERROR;
+          }else{
+            pNew->iFoldParam = (zArg[0]!='0') ? 2 : 0;
+          }
         }else{
-          pNew->bFold = (zArg[0]=='0');
-        }
-      }else if( 0==sqlite3_stricmp(azArg[i], "remove_diacritics") ){
-        if( (zArg[0]!='0' && zArg[0]!='1' && zArg[0]!='2') || zArg[1] ){
           rc = SQLITE_ERROR;
-        }else{
-          pNew->iFoldParam = (zArg[0]!='0') ? 2 : 0;
         }
-      }else{
+      }
+
+      if( pNew->iFoldParam!=0 && pNew->bFold==0 ){
         rc = SQLITE_ERROR;
       }
-    }
 
-    if( pNew->iFoldParam!=0 && pNew->bFold==0 ){
-      rc = SQLITE_ERROR;
-    }
-
-    if( rc!=SQLITE_OK ){
-      fts5TriDelete((Fts5Tokenizer*)pNew);
-      pNew = 0;
+      if( rc!=SQLITE_OK ){
+        fts5TriDelete((Fts5Tokenizer*)pNew);
+        pNew = 0;
+      }
     }
   }
   *ppOut = (Fts5Tokenizer*)pNew;
@@ -253330,6 +258142,16 @@ static int sqlite3Fts5TokenizerPattern(
   return FTS5_PATTERN_NONE;
 }
 
+/*
+** Return true if the tokenizer described by p->azArg[] is the trigram
+** tokenizer. This tokenizer needs to be loaded before xBestIndex is
+** called for the first time in order to correctly handle LIKE/GLOB.
+*/
+static int sqlite3Fts5TokenizerPreload(Fts5TokenizerConfig *p){
+  return (p->nArg>=1 && 0==sqlite3_stricmp(p->azArg[0], "trigram"));
+}
+
+
 /*
 ** Register all built-in tokenizers with FTS5.
 */
@@ -253340,7 +258162,6 @@ static int sqlite3Fts5TokenizerInit(fts5_api *pApi){
   } aBuiltin[] = {
     { "unicode61", {fts5UnicodeCreate, fts5UnicodeDelete, fts5UnicodeTokenize}},
     { "ascii",     {fts5AsciiCreate, fts5AsciiDelete, fts5AsciiTokenize }},
-    { "porter",    {fts5PorterCreate, fts5PorterDelete, fts5PorterTokenize }},
     { "trigram",   {fts5TriCreate, fts5TriDelete, fts5TriTokenize}},
   };
 
@@ -253355,7 +258176,20 @@ static int sqlite3Fts5TokenizerInit(fts5_api *pApi){
         0
     );
   }
-
+  if( rc==SQLITE_OK ){
+    fts5_tokenizer_v2 sPorter = {
+      2,
+      fts5PorterCreate,
+      fts5PorterDelete,
+      fts5PorterTokenize
+    };
+    rc = pApi->xCreateTokenizer_v2(pApi,
+        "porter",
+        (void*)pApi,
+        &sPorter,
+        0
+    );
+  }
   return rc;
 }
 
@@ -253725,6 +258559,9 @@ static int sqlite3Fts5UnicodeCatParse(const char *zCat, u8 *aArray){
             default: return 1;          }
           break;
 
+
+    default:
+      return 1;
   }
   return 0;
 }
@@ -254549,6 +259386,7 @@ struct Fts5VocabCursor {
 
   int nLeTerm;                    /* Size of zLeTerm in bytes */
   char *zLeTerm;                  /* (term <= $zLeTerm) paramater, or NULL */
+  int colUsed;                    /* Copy of sqlite3_index_info.colUsed */
 
   /* These are used by 'col' tables only */
   int iCol;
@@ -254575,9 +259413,11 @@ struct Fts5VocabCursor {
 /*
 ** Bits for the mask used as the idxNum value by xBestIndex/xFilter.
 */
-#define FTS5_VOCAB_TERM_EQ 0x01
-#define FTS5_VOCAB_TERM_GE 0x02
-#define FTS5_VOCAB_TERM_LE 0x04
+#define FTS5_VOCAB_TERM_EQ 0x0100
+#define FTS5_VOCAB_TERM_GE 0x0200
+#define FTS5_VOCAB_TERM_LE 0x0400
+
+#define FTS5_VOCAB_COLUSED_MASK 0xFF
 
 
 /*
@@ -254754,11 +259594,13 @@ static int fts5VocabBestIndexMethod(
   int iTermEq = -1;
   int iTermGe = -1;
   int iTermLe = -1;
-  int idxNum = 0;
+  int idxNum = (int)pInfo->colUsed;
   int nArg = 0;
 
   UNUSED_PARAM(pUnused);
 
+  assert( (pInfo->colUsed & FTS5_VOCAB_COLUSED_MASK)==pInfo->colUsed );
+
   for(i=0; i<pInfo->nConstraint; i++){
     struct sqlite3_index_constraint *p = &pInfo->aConstraint[i];
     if( p->usable==0 ) continue;
@@ -254850,7 +259692,7 @@ static int fts5VocabOpenMethod(
       if( rc==SQLITE_OK ){
         pVTab->zErrMsg = sqlite3_mprintf(
             "no such fts5 table: %s.%s", pTab->zFts5Db, pTab->zFts5Tbl
-            );
+        );
         rc = SQLITE_ERROR;
       }
     }else{
@@ -255010,9 +259852,19 @@ static int fts5VocabNextMethod(sqlite3_vtab_cursor *pCursor){
 
         switch( pTab->eType ){
           case FTS5_VOCAB_ROW:
-            if( eDetail==FTS5_DETAIL_FULL ){
-              while( 0==sqlite3Fts5PoslistNext64(pPos, nPos, &iOff, &iPos) ){
-                pCsr->aCnt[0]++;
+            /* Do not bother counting the number of instances if the "cnt"
+            ** column is not being read (according to colUsed).  */
+            if( eDetail==FTS5_DETAIL_FULL && (pCsr->colUsed & 0x04) ){
+              while( iPos<nPos ){
+                u32 ii;
+                fts5FastGetVarint32(pPos, iPos, ii);
+                if( ii==1 ){
+                  /* New column in the position list */
+                  fts5FastGetVarint32(pPos, iPos, ii);
+                }else{
+                  /* An instance - increment pCsr->aCnt[] */
+                  pCsr->aCnt[0]++;
+                }
               }
             }
             pCsr->aDoc[0]++;
@@ -255110,6 +259962,7 @@ static int fts5VocabFilterMethod(
   if( idxNum & FTS5_VOCAB_TERM_EQ ) pEq = apVal[iVal++];
   if( idxNum & FTS5_VOCAB_TERM_GE ) pGe = apVal[iVal++];
   if( idxNum & FTS5_VOCAB_TERM_LE ) pLe = apVal[iVal++];
+  pCsr->colUsed = (idxNum & FTS5_VOCAB_COLUSED_MASK);
 
   if( pEq ){
     zTerm = (const char *)sqlite3_value_text(pEq);
@@ -255277,7 +260130,7 @@ static int sqlite3Fts5VocabInit(Fts5Global *pGlobal, sqlite3 *db){
 }
 
 
-
+/* Here ends the fts5.c composite file. */
 #endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS5) */
 
 /************** End of fts5.c ************************************************/
diff --git a/src/bun.js/bindings/sqlite/sqlite3_local.h b/src/bun.js/bindings/sqlite/sqlite3_local.h
index 1d77374a2a..f9bea75fad 100644
--- a/src/bun.js/bindings/sqlite/sqlite3_local.h
+++ b/src/bun.js/bindings/sqlite/sqlite3_local.h
@@ -147,9 +147,9 @@ extern "C" {
 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
 ** [sqlite_version()] and [sqlite_source_id()].
 */
-#define SQLITE_VERSION        "3.45.0"
-#define SQLITE_VERSION_NUMBER 3045000
-#define SQLITE_SOURCE_ID      "2024-01-15 17:01:13 1066602b2b1976fe58b5150777cced894af17c803e068f5918390d6915b46e1d"
+#define SQLITE_VERSION        "3.47.1"
+#define SQLITE_VERSION_NUMBER 3047001
+#define SQLITE_SOURCE_ID      "2024-11-25 12:07:48 b95d11e958643b969c47a8e5857f3793b9e69700b8f1469371386369a26e577e"
 
 /*
 ** CAPI3REF: Run-Time Library Version Numbers
@@ -421,6 +421,8 @@ typedef int (*sqlite3_callback)(void*,int,char**, char**);
 **      the 1st parameter to sqlite3_exec() while sqlite3_exec() is running.
 ** <li> The application must not modify the SQL statement text passed into
 **      the 2nd parameter of sqlite3_exec() while sqlite3_exec() is running.
+** <li> The application must not dereference the arrays or string pointers
+**       passed as the 3rd and 4th callback parameters after it returns.
 ** </ul>
 */
 SQLITE_API int sqlite3_exec(
@@ -651,6 +653,13 @@ SQLITE_API int sqlite3_exec(
 ** filesystem supports doing multiple write operations atomically when those
 ** write operations are bracketed by [SQLITE_FCNTL_BEGIN_ATOMIC_WRITE] and
 ** [SQLITE_FCNTL_COMMIT_ATOMIC_WRITE].
+**
+** The SQLITE_IOCAP_SUBPAGE_READ property means that it is ok to read
+** from the database file in amounts that are not a multiple of the
+** page size and that do not begin at a page boundary.  Without this
+** property, SQLite is careful to only do full-page reads and write
+** on aligned pages, with the one exception that it will do a sub-page
+** read of the first page to access the database header.
 */
 #define SQLITE_IOCAP_ATOMIC                 0x00000001
 #define SQLITE_IOCAP_ATOMIC512              0x00000002
@@ -667,6 +676,7 @@ SQLITE_API int sqlite3_exec(
 #define SQLITE_IOCAP_POWERSAFE_OVERWRITE    0x00001000
 #define SQLITE_IOCAP_IMMUTABLE              0x00002000
 #define SQLITE_IOCAP_BATCH_ATOMIC           0x00004000
+#define SQLITE_IOCAP_SUBPAGE_READ           0x00008000
 
 /*
 ** CAPI3REF: File Locking Levels
@@ -763,16 +773,16 @@ struct sqlite3_file {
 ** </ul>
 ** xLock() upgrades the database file lock.  In other words, xLock() moves the
 ** database file lock in the direction NONE toward EXCLUSIVE. The argument to
-** xLock() is always on of SHARED, RESERVED, PENDING, or EXCLUSIVE, never
+** xLock() is always one of SHARED, RESERVED, PENDING, or EXCLUSIVE, never
 ** SQLITE_LOCK_NONE.  If the database file lock is already at or above the
 ** requested lock, then the call to xLock() is a no-op.
 ** xUnlock() downgrades the database file lock to either SHARED or NONE.
-*  If the lock is already at or below the requested lock state, then the call
+** If the lock is already at or below the requested lock state, then the call
 ** to xUnlock() is a no-op.
 ** The xCheckReservedLock() method checks whether any database connection,
 ** either in this process or in some other process, is holding a RESERVED,
-** PENDING, or EXCLUSIVE lock on the file.  It returns true
-** if such a lock exists and false otherwise.
+** PENDING, or EXCLUSIVE lock on the file.  It returns, via its output
+** pointer parameter, true if such a lock exists and false otherwise.
 **
 ** The xFileControl() method is a generic interface that allows custom
 ** VFS implementations to directly control an open file using the
@@ -813,6 +823,7 @@ struct sqlite3_file {
 ** <li> [SQLITE_IOCAP_POWERSAFE_OVERWRITE]
 ** <li> [SQLITE_IOCAP_IMMUTABLE]
 ** <li> [SQLITE_IOCAP_BATCH_ATOMIC]
+** <li> [SQLITE_IOCAP_SUBPAGE_READ]
 ** </ul>
 **
 ** The SQLITE_IOCAP_ATOMIC property means that all writes of
@@ -2142,6 +2153,22 @@ struct sqlite3_mem_methods {
 ** configuration setting is never used, then the default maximum is determined
 ** by the [SQLITE_MEMDB_DEFAULT_MAXSIZE] compile-time option.  If that
 ** compile-time option is not set, then the default maximum is 1073741824.
+**
+** [[SQLITE_CONFIG_ROWID_IN_VIEW]]
+** <dt>SQLITE_CONFIG_ROWID_IN_VIEW
+** <dd>The SQLITE_CONFIG_ROWID_IN_VIEW option enables or disables the ability
+** for VIEWs to have a ROWID.  The capability can only be enabled if SQLite is
+** compiled with -DSQLITE_ALLOW_ROWID_IN_VIEW, in which case the capability
+** defaults to on.  This configuration option queries the current setting or
+** changes the setting to off or on.  The argument is a pointer to an integer.
+** If that integer initially holds a value of 1, then the ability for VIEWs to
+** have ROWIDs is activated.  If the integer initially holds zero, then the
+** ability is deactivated.  Any other initial value for the integer leaves the
+** setting unchanged.  After changes, if any, the integer is written with
+** a 1 or 0, if the ability for VIEWs to have ROWIDs is on or off.  If SQLite
+** is compiled without -DSQLITE_ALLOW_ROWID_IN_VIEW (which is the usual and
+** recommended case) then the integer is always filled with zero, regardless
+** if its initial value.
 ** </dl>
 */
 #define SQLITE_CONFIG_SINGLETHREAD         1  /* nil */
@@ -2173,6 +2200,7 @@ struct sqlite3_mem_methods {
 #define SQLITE_CONFIG_SMALL_MALLOC        27  /* boolean */
 #define SQLITE_CONFIG_SORTERREF_SIZE      28  /* int nByte */
 #define SQLITE_CONFIG_MEMDB_MAXSIZE       29  /* sqlite3_int64 */
+#define SQLITE_CONFIG_ROWID_IN_VIEW       30  /* int* */
 
 /*
 ** CAPI3REF: Database Connection Configuration Options
@@ -3287,8 +3315,8 @@ SQLITE_API int sqlite3_set_authorizer(
 #define SQLITE_RECURSIVE            33   /* NULL            NULL            */
 
 /*
-** CAPI3REF: Tracing And Profiling Functions
-** METHOD: sqlite3
+** CAPI3REF: Deprecated Tracing And Profiling Functions
+** DEPRECATED
 **
 ** These routines are deprecated. Use the [sqlite3_trace_v2()] interface
 ** instead of the routines described here.
@@ -3552,8 +3580,8 @@ SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
 **
 ** [[OPEN_EXRESCODE]] ^(<dt>[SQLITE_OPEN_EXRESCODE]</dt>
 ** <dd>The database connection comes up in "extended result code mode".
-** In other words, the database behaves has if
-** [sqlite3_extended_result_codes(db,1)] where called on the database
+** In other words, the database behaves as if
+** [sqlite3_extended_result_codes(db,1)] were called on the database
 ** connection as soon as the connection is created. In addition to setting
 ** the extended result code mode, this flag also causes [sqlite3_open_v2()]
 ** to return an extended result code.</dd>
@@ -4204,13 +4232,17 @@ SQLITE_API int sqlite3_limit(sqlite3*, int id, int newVal);
 ** and sqlite3_prepare16_v3() use UTF-16.
 **
 ** ^If the nByte argument is negative, then zSql is read up to the
-** first zero terminator. ^If nByte is positive, then it is the
-** number of bytes read from zSql.  ^If nByte is zero, then no prepared
+** first zero terminator. ^If nByte is positive, then it is the maximum
+** number of bytes read from zSql.  When nByte is positive, zSql is read
+** up to the first zero terminator or until the nByte bytes have been read,
+** whichever comes first.  ^If nByte is zero, then no prepared
 ** statement is generated.
 ** If the caller knows that the supplied string is nul-terminated, then
 ** there is a small performance advantage to passing an nByte parameter that
 ** is the number of bytes in the input string <i>including</i>
 ** the nul-terminator.
+** Note that nByte measure the length of the input in bytes, not
+** characters, even for the UTF-16 interfaces.
 **
 ** ^If pzTail is not NULL then *pzTail is made to point to the first byte
 ** past the end of the first SQL statement in zSql.  These routines only
@@ -5581,7 +5613,7 @@ SQLITE_API int sqlite3_create_window_function(
 ** This flag instructs SQLite to omit some corner-case optimizations that
 ** might disrupt the operation of the [sqlite3_value_subtype()] function,
 ** causing it to return zero rather than the correct subtype().
-** SQL functions that invokes [sqlite3_value_subtype()] should have this
+** All SQL functions that invoke [sqlite3_value_subtype()] should have this
 ** property.  If the SQLITE_SUBTYPE property is omitted, then the return
 ** value from [sqlite3_value_subtype()] might sometimes be zero even though
 ** a non-zero subtype was specified by the function argument expression.
@@ -5597,6 +5629,15 @@ SQLITE_API int sqlite3_create_window_function(
 ** [sqlite3_result_subtype()] should avoid setting this property, as the
 ** purpose of this property is to disable certain optimizations that are
 ** incompatible with subtypes.
+**
+** [[SQLITE_SELFORDER1]] <dt>SQLITE_SELFORDER1</dt><dd>
+** The SQLITE_SELFORDER1 flag indicates that the function is an aggregate
+** that internally orders the values provided to the first argument.  The
+** ordered-set aggregate SQL notation with a single ORDER BY term can be
+** used to invoke this function.  If the ordered-set aggregate notation is
+** used on a function that lacks this flag, then an error is raised. Note
+** that the ordered-set aggregate syntax is only available if SQLite is
+** built using the -DSQLITE_ENABLE_ORDERED_SET_AGGREGATES compile-time option.
 ** </dd>
 ** </dl>
 */
@@ -5605,6 +5646,7 @@ SQLITE_API int sqlite3_create_window_function(
 #define SQLITE_SUBTYPE          0x000100000
 #define SQLITE_INNOCUOUS        0x000200000
 #define SQLITE_RESULT_SUBTYPE   0x001000000
+#define SQLITE_SELFORDER1       0x002000000
 
 /*
 ** CAPI3REF: Deprecated Functions
@@ -5802,7 +5844,7 @@ SQLITE_API int sqlite3_value_encoding(sqlite3_value*);
 ** one SQL function to another.  Use the [sqlite3_result_subtype()]
 ** routine to set the subtype for the return value of an SQL function.
 **
-** Every [application-defined SQL function] that invoke this interface
+** Every [application-defined SQL function] that invokes this interface
 ** should include the [SQLITE_SUBTYPE] property in the text
 ** encoding argument when the function is [sqlite3_create_function|registered].
 ** If the [SQLITE_SUBTYPE] property is omitted, then sqlite3_value_subtype()
@@ -6869,6 +6911,12 @@ SQLITE_API int sqlite3_autovacuum_pages(
 ** The exceptions defined in this paragraph might change in a future
 ** release of SQLite.
 **
+** Whether the update hook is invoked before or after the
+** corresponding change is currently unspecified and may differ
+** depending on the type of change. Do not rely on the order of the
+** hook call with regards to the final result of the operation which
+** triggers the hook.
+**
 ** The update hook implementation must not do anything that will modify
 ** the database connection that invoked the update hook.  Any actions
 ** to modify the database connection must be deferred until after the
@@ -7403,9 +7451,11 @@ struct sqlite3_module {
 ** will be returned by the strategy.
 **
 ** The xBestIndex method may optionally populate the idxFlags field with a
-** mask of SQLITE_INDEX_SCAN_* flags. Currently there is only one such flag -
-** SQLITE_INDEX_SCAN_UNIQUE. If the xBestIndex method sets this flag, SQLite
-** assumes that the strategy may visit at most one row.
+** mask of SQLITE_INDEX_SCAN_* flags. One such flag is
+** [SQLITE_INDEX_SCAN_HEX], which if set causes the [EXPLAIN QUERY PLAN]
+** output to show the idxNum has hex instead of as decimal.  Another flag is
+** SQLITE_INDEX_SCAN_UNIQUE, which if set indicates that the query plan will
+** return at most one row.
 **
 ** Additionally, if xBestIndex sets the SQLITE_INDEX_SCAN_UNIQUE flag, then
 ** SQLite also assumes that if a call to the xUpdate() method is made as
@@ -7469,7 +7519,9 @@ struct sqlite3_index_info {
 ** [sqlite3_index_info].idxFlags field to some combination of
 ** these bits.
 */
-#define SQLITE_INDEX_SCAN_UNIQUE      1     /* Scan visits at most 1 row */
+#define SQLITE_INDEX_SCAN_UNIQUE 0x00000001 /* Scan visits at most 1 row */
+#define SQLITE_INDEX_SCAN_HEX    0x00000002 /* Display idxNum as hex */
+                                            /* in EXPLAIN QUERY PLAN */
 
 /*
 ** CAPI3REF: Virtual Table Constraint Operator Codes
@@ -8306,6 +8358,7 @@ SQLITE_API int sqlite3_test_control(int op, ...);
 #define SQLITE_TESTCTRL_JSON_SELFCHECK          14
 #define SQLITE_TESTCTRL_OPTIMIZATIONS           15
 #define SQLITE_TESTCTRL_ISKEYWORD               16  /* NOT USED */
+#define SQLITE_TESTCTRL_GETOPT                  16
 #define SQLITE_TESTCTRL_SCRATCHMALLOC           17  /* NOT USED */
 #define SQLITE_TESTCTRL_INTERNAL_FUNCTIONS      17
 #define SQLITE_TESTCTRL_LOCALTIME_FAULT         18
@@ -8325,7 +8378,7 @@ SQLITE_API int sqlite3_test_control(int op, ...);
 #define SQLITE_TESTCTRL_TRACEFLAGS              31
 #define SQLITE_TESTCTRL_TUNE                    32
 #define SQLITE_TESTCTRL_LOGEST                  33
-#define SQLITE_TESTCTRL_USELONGDOUBLE           34
+#define SQLITE_TESTCTRL_USELONGDOUBLE           34  /* NOT USED */
 #define SQLITE_TESTCTRL_LAST                    34  /* Largest TESTCTRL */
 
 /*
@@ -8339,7 +8392,7 @@ SQLITE_API int sqlite3_test_control(int op, ...);
 ** The sqlite3_keyword_count() interface returns the number of distinct
 ** keywords understood by SQLite.
 **
-** The sqlite3_keyword_name(N,Z,L) interface finds the N-th keyword and
+** The sqlite3_keyword_name(N,Z,L) interface finds the 0-based N-th keyword and
 ** makes *Z point to that keyword expressed as UTF8 and writes the number
 ** of bytes in the keyword into *L.  The string that *Z points to is not
 ** zero-terminated.  The sqlite3_keyword_name(N,Z,L) routine returns
@@ -9301,6 +9354,16 @@ typedef struct sqlite3_backup sqlite3_backup;
 ** APIs are not strictly speaking threadsafe. If they are invoked at the
 ** same time as another thread is invoking sqlite3_backup_step() it is
 ** possible that they return invalid values.
+**
+** <b>Alternatives To Using The Backup API</b>
+**
+** Other techniques for safely creating a consistent backup of an SQLite
+** database include:
+**
+** <ul>
+** <li> The [VACUUM INTO] command.
+** <li> The [sqlite3_rsync] utility program.
+** </ul>
 */
 SQLITE_API sqlite3_backup *sqlite3_backup_init(
   sqlite3 *pDest,                        /* Destination database handle */
@@ -9918,24 +9981,45 @@ SQLITE_API const char *sqlite3_vtab_collation(sqlite3_index_info*,int);
 ** <li value="2"><p>
 ** ^(If the sqlite3_vtab_distinct() interface returns 2, that means
 ** that the query planner does not need the rows returned in any particular
-** order, as long as rows with the same values in all "aOrderBy" columns
-** are adjacent.)^  ^(Furthermore, only a single row for each particular
-** combination of values in the columns identified by the "aOrderBy" field
-** needs to be returned.)^  ^It is always ok for two or more rows with the same
-** values in all "aOrderBy" columns to be returned, as long as all such rows
-** are adjacent.  ^The virtual table may, if it chooses, omit extra rows
-** that have the same value for all columns identified by "aOrderBy".
-** ^However omitting the extra rows is optional.
+** order, as long as rows with the same values in all columns identified
+** by "aOrderBy" are adjacent.)^  ^(Furthermore, when two or more rows
+** contain the same values for all columns identified by "colUsed", all but
+** one such row may optionally be omitted from the result.)^
+** The virtual table is not required to omit rows that are duplicates
+** over the "colUsed" columns, but if the virtual table can do that without
+** too much extra effort, it could potentially help the query to run faster.
 ** This mode is used for a DISTINCT query.
 ** <li value="3"><p>
-** ^(If the sqlite3_vtab_distinct() interface returns 3, that means
-** that the query planner needs only distinct rows but it does need the
-** rows to be sorted.)^ ^The virtual table implementation is free to omit
-** rows that are identical in all aOrderBy columns, if it wants to, but
-** it is not required to omit any rows.  This mode is used for queries
+** ^(If the sqlite3_vtab_distinct() interface returns 3, that means the
+** virtual table must return rows in the order defined by "aOrderBy" as
+** if the sqlite3_vtab_distinct() interface had returned 0.  However if
+** two or more rows in the result have the same values for all columns
+** identified by "colUsed", then all but one such row may optionally be
+** omitted.)^  Like when the return value is 2, the virtual table
+** is not required to omit rows that are duplicates over the "colUsed"
+** columns, but if the virtual table can do that without
+** too much extra effort, it could potentially help the query to run faster.
+** This mode is used for queries
 ** that have both DISTINCT and ORDER BY clauses.
 ** </ol>
 **
+** <p>The following table summarizes the conditions under which the
+** virtual table is allowed to set the "orderByConsumed" flag based on
+** the value returned by sqlite3_vtab_distinct().  This table is a
+** restatement of the previous four paragraphs:
+**
+** <table border=1 cellspacing=0 cellpadding=10 width="90%">
+** <tr>
+** <td valign="top">sqlite3_vtab_distinct() return value
+** <td valign="top">Rows are returned in aOrderBy order
+** <td valign="top">Rows with the same value in all aOrderBy columns are adjacent
+** <td valign="top">Duplicates over all colUsed columns may be omitted
+** <tr><td>0<td>yes<td>yes<td>no
+** <tr><td>1<td>no<td>yes<td>no
+** <tr><td>2<td>no<td>yes<td>yes
+** <tr><td>3<td>yes<td>yes<td>yes
+** </table>
+**
 ** ^For the purposes of comparing virtual table output values to see if the
 ** values are same value for sorting purposes, two NULL values are considered
 ** to be the same.  In other words, the comparison operator is "IS"
@@ -10479,6 +10563,14 @@ typedef struct sqlite3_snapshot {
 ** If there is not already a read-transaction open on schema S when
 ** this function is called, one is opened automatically.
 **
+** If a read-transaction is opened by this function, then it is guaranteed
+** that the returned snapshot object may not be invalidated by a database
+** writer or checkpointer until after the read-transaction is closed. This
+** is not guaranteed if a read-transaction is already open when this
+** function is called. In that case, any subsequent write or checkpoint
+** operation on the database may invalidate the returned snapshot handle,
+** even while the read-transaction remains open.
+**
 ** The following must be true for this function to succeed. If any of
 ** the following statements are false when sqlite3_snapshot_get() is
 ** called, SQLITE_ERROR is returned. The final value of *P is undefined
@@ -10787,8 +10879,6 @@ SQLITE_API int sqlite3_deserialize(
 #if defined(__wasi__)
 # undef SQLITE_WASI
 # define SQLITE_WASI 1
-# undef SQLITE_OMIT_WAL
-# define SQLITE_OMIT_WAL 1/* because it requires shared memory APIs */
 # ifndef SQLITE_OMIT_LOAD_EXTENSION
 #  define SQLITE_OMIT_LOAD_EXTENSION
 # endif
@@ -11980,6 +12070,30 @@ SQLITE_API int sqlite3changegroup_schema(sqlite3_changegroup*, sqlite3*, const c
 */
 SQLITE_API int sqlite3changegroup_add(sqlite3_changegroup*, int nData, void *pData);
 
+/*
+** CAPI3REF: Add A Single Change To A Changegroup
+** METHOD: sqlite3_changegroup
+**
+** This function adds the single change currently indicated by the iterator
+** passed as the second argument to the changegroup object. The rules for
+** adding the change are just as described for [sqlite3changegroup_add()].
+**
+** If the change is successfully added to the changegroup, SQLITE_OK is
+** returned. Otherwise, an SQLite error code is returned.
+**
+** The iterator must point to a valid entry when this function is called.
+** If it does not, SQLITE_ERROR is returned and no change is added to the
+** changegroup. Additionally, the iterator must not have been opened with
+** the SQLITE_CHANGESETAPPLY_INVERT flag. In this case SQLITE_ERROR is also
+** returned.
+*/
+SQLITE_API int sqlite3changegroup_add_change(
+  sqlite3_changegroup*,
+  sqlite3_changeset_iter*
+);
+
+
+
 /*
 ** CAPI3REF: Obtain A Composite Changeset From A Changegroup
 ** METHOD: sqlite3_changegroup
@@ -12784,8 +12898,8 @@ struct Fts5PhraseIter {
 ** EXTENSION API FUNCTIONS
 **
 ** xUserData(pFts):
-**   Return a copy of the context pointer the extension function was
-**   registered with.
+**   Return a copy of the pUserData pointer passed to the xCreateFunction()
+**   API when the extension function was registered.
 **
 ** xColumnTotalSize(pFts, iCol, pnToken):
 **   If parameter iCol is less than zero, set output variable *pnToken
@@ -12967,6 +13081,10 @@ struct Fts5PhraseIter {
 **   (i.e. if it is a contentless table), then this API always iterates
 **   through an empty set (all calls to xPhraseFirst() set iCol to -1).
 **
+**   In all cases, matches are visited in (column ASC, offset ASC) order.
+**   i.e. all those in column 0, sorted by offset, followed by those in
+**   column 1, etc.
+**
 ** xPhraseNext()
 **   See xPhraseFirst above.
 **
@@ -13033,9 +13151,32 @@ struct Fts5PhraseIter {
 **
 **   This API can be quite slow if used with an FTS5 table created with the
 **   "detail=none" or "detail=column" option.
+**
+** xColumnLocale(pFts5, iIdx, pzLocale, pnLocale)
+**   If parameter iCol is less than zero, or greater than or equal to the
+**   number of columns in the table, SQLITE_RANGE is returned.
+**
+**   Otherwise, this function attempts to retrieve the locale associated
+**   with column iCol of the current row. Usually, there is no associated
+**   locale, and output parameters (*pzLocale) and (*pnLocale) are set
+**   to NULL and 0, respectively. However, if the fts5_locale() function
+**   was used to associate a locale with the value when it was inserted
+**   into the fts5 table, then (*pzLocale) is set to point to a nul-terminated
+**   buffer containing the name of the locale in utf-8 encoding. (*pnLocale)
+**   is set to the size in bytes of the buffer, not including the
+**   nul-terminator.
+**
+**   If successful, SQLITE_OK is returned. Or, if an error occurs, an
+**   SQLite error code is returned. The final value of the output parameters
+**   is undefined in this case.
+**
+** xTokenize_v2:
+**   Tokenize text using the tokenizer belonging to the FTS5 table. This
+**   API is the same as the xTokenize() API, except that it allows a tokenizer
+**   locale to be specified.
 */
 struct Fts5ExtensionApi {
-  int iVersion;                   /* Currently always set to 3 */
+  int iVersion;                   /* Currently always set to 4 */
 
   void *(*xUserData)(Fts5Context*);
 
@@ -13077,6 +13218,15 @@ struct Fts5ExtensionApi {
       const char **ppToken, int *pnToken
   );
   int (*xInstToken)(Fts5Context*, int iIdx, int iToken, const char**, int*);
+
+  /* Below this point are iVersion>=4 only */
+  int (*xColumnLocale)(Fts5Context*, int iCol, const char **pz, int *pn);
+  int (*xTokenize_v2)(Fts5Context*,
+    const char *pText, int nText,      /* Text to tokenize */
+    const char *pLocale, int nLocale,  /* Locale to pass to tokenizer */
+    void *pCtx,                        /* Context passed to xToken() */
+    int (*xToken)(void*, int, const char*, int, int, int)       /* Callback */
+  );
 };
 
 /*
@@ -13097,7 +13247,7 @@ struct Fts5ExtensionApi {
 **   A tokenizer instance is required to actually tokenize text.
 **
 **   The first argument passed to this function is a copy of the (void*)
-**   pointer provided by the application when the fts5_tokenizer object
+**   pointer provided by the application when the fts5_tokenizer_v2 object
 **   was registered with FTS5 (the third argument to xCreateTokenizer()).
 **   The second and third arguments are an array of nul-terminated strings
 **   containing the tokenizer arguments, if any, specified following the
@@ -13121,7 +13271,7 @@ struct Fts5ExtensionApi {
 **   argument passed to this function is a pointer to an Fts5Tokenizer object
 **   returned by an earlier call to xCreate().
 **
-**   The second argument indicates the reason that FTS5 is requesting
+**   The third argument indicates the reason that FTS5 is requesting
 **   tokenization of the supplied text. This is always one of the following
 **   four values:
 **
@@ -13145,6 +13295,13 @@ struct Fts5ExtensionApi {
 **            on a columnsize=0 database.
 **   </ul>
 **
+**   The sixth and seventh arguments passed to xTokenize() - pLocale and
+**   nLocale - are a pointer to a buffer containing the locale to use for
+**   tokenization (e.g. "en_US") and its size in bytes, respectively. The
+**   pLocale buffer is not nul-terminated. pLocale may be passed NULL (in
+**   which case nLocale is always 0) to indicate that the tokenizer should
+**   use its default locale.
+**
 **   For each token in the input string, the supplied callback xToken() must
 **   be invoked. The first argument to it should be a copy of the pointer
 **   passed as the second argument to xTokenize(). The third and fourth
@@ -13168,6 +13325,30 @@ struct Fts5ExtensionApi {
 **   may abandon the tokenization and return any error code other than
 **   SQLITE_OK or SQLITE_DONE.
 **
+**   If the tokenizer is registered using an fts5_tokenizer_v2 object,
+**   then the xTokenize() method has two additional arguments - pLocale
+**   and nLocale. These specify the locale that the tokenizer should use
+**   for the current request. If pLocale and nLocale are both 0, then the
+**   tokenizer should use its default locale. Otherwise, pLocale points to
+**   an nLocale byte buffer containing the name of the locale to use as utf-8
+**   text. pLocale is not nul-terminated.
+**
+** FTS5_TOKENIZER
+**
+** There is also an fts5_tokenizer object. This is an older, deprecated,
+** version of fts5_tokenizer_v2. It is similar except that:
+**
+**  <ul>
+**    <li> There is no "iVersion" field, and
+**    <li> The xTokenize() method does not take a locale argument.
+**  </ul>
+**
+** Legacy fts5_tokenizer tokenizers must be registered using the
+** legacy xCreateTokenizer() function, instead of xCreateTokenizer_v2().
+**
+** Tokenizer implementations registered using either API may be retrieved
+** using both xFindTokenizer() and xFindTokenizer_v2().
+**
 ** SYNONYM SUPPORT
 **
 **   Custom tokenizers may also support synonyms. Consider a case in which a
@@ -13276,6 +13457,33 @@ struct Fts5ExtensionApi {
 **   inefficient.
 */
 typedef struct Fts5Tokenizer Fts5Tokenizer;
+typedef struct fts5_tokenizer_v2 fts5_tokenizer_v2;
+struct fts5_tokenizer_v2 {
+  int iVersion;             /* Currently always 2 */
+
+  int (*xCreate)(void*, const char **azArg, int nArg, Fts5Tokenizer **ppOut);
+  void (*xDelete)(Fts5Tokenizer*);
+  int (*xTokenize)(Fts5Tokenizer*,
+      void *pCtx,
+      int flags,            /* Mask of FTS5_TOKENIZE_* flags */
+      const char *pText, int nText,
+      const char *pLocale, int nLocale,
+      int (*xToken)(
+        void *pCtx,         /* Copy of 2nd argument to xTokenize() */
+        int tflags,         /* Mask of FTS5_TOKEN_* flags */
+        const char *pToken, /* Pointer to buffer containing token */
+        int nToken,         /* Size of token in bytes */
+        int iStart,         /* Byte offset of token within input text */
+        int iEnd            /* Byte offset of end of token within input text */
+      )
+  );
+};
+
+/*
+** New code should use the fts5_tokenizer_v2 type to define tokenizer
+** implementations. The following type is included for legacy applications
+** that still use it.
+*/
 typedef struct fts5_tokenizer fts5_tokenizer;
 struct fts5_tokenizer {
   int (*xCreate)(void*, const char **azArg, int nArg, Fts5Tokenizer **ppOut);
@@ -13295,6 +13503,7 @@ struct fts5_tokenizer {
   );
 };
 
+
 /* Flags that may be passed as the third argument to xTokenize() */
 #define FTS5_TOKENIZE_QUERY     0x0001
 #define FTS5_TOKENIZE_PREFIX    0x0002
@@ -13314,7 +13523,7 @@ struct fts5_tokenizer {
 */
 typedef struct fts5_api fts5_api;
 struct fts5_api {
-  int iVersion;                   /* Currently always set to 2 */
+  int iVersion;                   /* Currently always set to 3 */
 
   /* Create a new tokenizer */
   int (*xCreateTokenizer)(
@@ -13341,6 +13550,25 @@ struct fts5_api {
     fts5_extension_function xFunction,
     void (*xDestroy)(void*)
   );
+
+  /* APIs below this point are only available if iVersion>=3 */
+
+  /* Create a new tokenizer */
+  int (*xCreateTokenizer_v2)(
+    fts5_api *pApi,
+    const char *zName,
+    void *pUserData,
+    fts5_tokenizer_v2 *pTokenizer,
+    void (*xDestroy)(void*)
+  );
+
+  /* Find an existing tokenizer */
+  int (*xFindTokenizer_v2)(
+    fts5_api *pApi,
+    const char *zName,
+    void **ppUserData,
+    fts5_tokenizer_v2 **ppTokenizer
+  );
 };
 
 /*
diff --git a/src/bun.js/bindings/v8-capture-stack-fixture.cjs b/src/bun.js/bindings/v8-capture-stack-fixture.cjs
new file mode 100644
index 0000000000..c8d21c775d
--- /dev/null
+++ b/src/bun.js/bindings/v8-capture-stack-fixture.cjs
@@ -0,0 +1,15 @@
+let e = new Error();
+
+const { noInline } = require("bun:jsc");
+
+function sloppyWrapperFn() {
+  sloppyFn();
+}
+noInline(sloppyWrapperFn);
+
+function sloppyFn() {
+  Error.captureStackTrace(e);
+  module.exports = e.stack;
+}
+noInline(sloppyFn);
+sloppyWrapperFn();
diff --git a/src/bun.js/bindings/v8/V8Array.cpp b/src/bun.js/bindings/v8/V8Array.cpp
index 97dd9cf319..27f4265ee0 100644
--- a/src/bun.js/bindings/v8/V8Array.cpp
+++ b/src/bun.js/bindings/v8/V8Array.cpp
@@ -1,6 +1,9 @@
 #include "V8Array.h"
 
 #include "V8HandleScope.h"
+#include "v8_compatibility_assertions.h"
+
+ASSERT_V8_TYPE_LAYOUT_MATCHES(v8::Array)
 
 using JSC::ArrayAllocationProfile;
 using JSC::JSArray;
@@ -20,4 +23,4 @@ Local<Array> Array::New(Isolate* isolate, Local<Value>* elements, size_t length)
     return isolate->currentHandleScope()->createLocal<Array>(isolate->vm(), array);
 }
 
-}
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8Array.h b/src/bun.js/bindings/v8/V8Array.h
index d88418894e..3e673b0308 100644
--- a/src/bun.js/bindings/v8/V8Array.h
+++ b/src/bun.js/bindings/v8/V8Array.h
@@ -13,4 +13,4 @@ public:
     BUN_EXPORT static Local<Array> New(Isolate* isolate, Local<Value>* elements, size_t length);
 };
 
-}
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8Boolean.cpp b/src/bun.js/bindings/v8/V8Boolean.cpp
index 3bc95e043c..5e5a5e6d4c 100644
--- a/src/bun.js/bindings/v8/V8Boolean.cpp
+++ b/src/bun.js/bindings/v8/V8Boolean.cpp
@@ -1,11 +1,21 @@
 #include "V8Boolean.h"
 #include "V8HandleScope.h"
+#include "v8_compatibility_assertions.h"
+
+ASSERT_V8_TYPE_LAYOUT_MATCHES(v8::Boolean)
 
 namespace v8 {
 
 bool Boolean::Value() const
 {
-    return localToJSValue(Isolate::GetCurrent()->globalInternals()).asBoolean();
+    JSC::JSValue jsv = localToOddball();
+    if (jsv.isTrue()) {
+        return true;
+    } else if (jsv.isFalse()) {
+        return false;
+    } else {
+        RELEASE_ASSERT_NOT_REACHED("non-Boolean passed to Boolean::Value");
+    }
 }
 
 Local<Boolean> Boolean::New(Isolate* isolate, bool value)
@@ -13,4 +23,4 @@ Local<Boolean> Boolean::New(Isolate* isolate, bool value)
     return isolate->currentHandleScope()->createLocal<Boolean>(isolate->vm(), JSC::jsBoolean(value));
 }
 
-}
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8Boolean.h b/src/bun.js/bindings/v8/V8Boolean.h
index 9dd76f124a..e90244d1b0 100644
--- a/src/bun.js/bindings/v8/V8Boolean.h
+++ b/src/bun.js/bindings/v8/V8Boolean.h
@@ -12,4 +12,4 @@ public:
     BUN_EXPORT static Local<Boolean> New(Isolate* isolate, bool value);
 };
 
-}
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8Context.cpp b/src/bun.js/bindings/v8/V8Context.cpp
index 1fe001f237..35a1ec0954 100644
--- a/src/bun.js/bindings/v8/V8Context.cpp
+++ b/src/bun.js/bindings/v8/V8Context.cpp
@@ -1,10 +1,13 @@
 #include "V8Context.h"
+#include "v8_compatibility_assertions.h"
+
+ASSERT_V8_TYPE_LAYOUT_MATCHES(v8::Context)
 
 namespace v8 {
 
 Isolate* Context::GetIsolate()
 {
-    return reinterpret_cast<Isolate*>(localToPointer());
+    return globalObject()->V8GlobalInternals()->isolate();
 }
 
-}
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8Context.h b/src/bun.js/bindings/v8/V8Context.h
index 2293a22516..164513277e 100644
--- a/src/bun.js/bindings/v8/V8Context.h
+++ b/src/bun.js/bindings/v8/V8Context.h
@@ -1,32 +1,33 @@
 #pragma once
 
 #include "ZigGlobalObject.h"
-#include "V8GlobalInternals.h"
 #include "V8Data.h"
 
 namespace v8 {
 
+namespace shim {
 class Isolate;
+}
 
-// Context is always a reinterpret pointer to V8::Roots, so that inlined V8 functions can find
-// values they expect to find at fixed offsets
+// Context is always a reinterpret pointer to Zig::GlobalObject, so that functions accepting a
+// Context can quickly access JSC data
 class Context : public Data {
 public:
     BUN_EXPORT Isolate* GetIsolate();
 
     JSC::VM& vm() const
     {
-        return globalObject()->vm();
+        return localToCell()->vm();
     }
 
     const Zig::GlobalObject* globalObject() const
     {
-        return reinterpret_cast<const Roots*>(localToCell())->parent->globalObject;
+        return JSC::jsDynamicCast<const Zig::GlobalObject*>(localToCell());
     }
 
     Zig::GlobalObject* globalObject()
     {
-        return reinterpret_cast<const Roots*>(localToCell())->parent->globalObject;
+        return JSC::jsDynamicCast<Zig::GlobalObject*>(localToCell());
     }
 
     HandleScope* currentHandleScope() const
@@ -35,4 +36,4 @@ public:
     };
 };
 
-}
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8Data.h b/src/bun.js/bindings/v8/V8Data.h
index aded85f5c9..f3ebc81aaf 100644
--- a/src/bun.js/bindings/v8/V8Data.h
+++ b/src/bun.js/bindings/v8/V8Data.h
@@ -1,30 +1,25 @@
 #pragma once
 
 #include "root.h"
-#include "V8TaggedPointer.h"
-#include "V8Handle.h"
-#include "V8GlobalInternals.h"
+#include "shim/TaggedPointer.h"
+#include "shim/Handle.h"
+#include "shim/GlobalInternals.h"
 
 namespace v8 {
 
 class Data {
+
 public:
     // Functions beginning with "localTo" must only be used when "this" comes from a v8::Local (i.e.
     // in public V8 functions), as they make assumptions about how V8 lays out local handles. They
     // will segfault or worse otherwise.
 
-    // Recover an opaque pointer out of a v8::Local which is not a number
-    void* localToPointer()
-    {
-        TaggedPointer tagged = localToTagged();
-        RELEASE_ASSERT(tagged.type() != TaggedPointer::Type::Smi);
-        return tagged.getPtr<void>();
-    }
-
     // Recover a JSCell pointer out of a v8::Local
     JSC::JSCell* localToCell()
     {
-        return reinterpret_cast<JSC::JSCell*>(localToPointer());
+        TaggedPointer root = localToTagged();
+        RELEASE_ASSERT(root.tag() != TaggedPointer::Tag::Smi);
+        return root.getPtr<shim::ObjectLayout>()->asCell();
     }
 
     // Recover a pointer to a JSCell subclass out of a v8::Local
@@ -35,47 +30,43 @@ public:
         return JSC::jsDynamicCast<T*>(localToCell());
     }
 
-    // Get this as a JSValue when this is a v8::Local
-    JSC::JSValue localToJSValue(GlobalInternals* globalInternals) const
+    // Get this as a JSValue when this is a v8::Local containing a boolean, null, or undefined
+    JSC::JSValue localToOddball() const
     {
-        TaggedPointer root = *reinterpret_cast<const TaggedPointer*>(this);
-        if (root.type() == TaggedPointer::Type::Smi) {
-            return JSC::jsNumber(root.getSmiUnchecked());
-        } else {
-            void* raw_ptr = root.getPtr<void>();
-            // check if this pointer is identical to the fixed locations where these primitive
-            // values are stored
-            if (raw_ptr == globalInternals->undefinedSlot()->getPtr<void>()) {
-                return JSC::jsUndefined();
-            } else if (raw_ptr == globalInternals->nullSlot()->getPtr<void>()) {
-                return JSC::jsNull();
-            } else if (raw_ptr == globalInternals->trueSlot()->getPtr<void>()) {
-                return JSC::jsBoolean(true);
-            } else if (raw_ptr == globalInternals->falseSlot()->getPtr<void>()) {
-                return JSC::jsBoolean(false);
-            }
-
-            ObjectLayout* v8_object = reinterpret_cast<ObjectLayout*>(raw_ptr);
-            if (v8_object->map()->instance_type == InstanceType::HeapNumber) {
-                return JSC::jsDoubleNumber(v8_object->asDouble());
-            } else {
-                return JSC::JSValue(v8_object->asCell());
-            }
-        }
+        TaggedPointer root = localToTagged();
+        shim::Oddball* oddball = root.getPtr<shim::Oddball>();
+        RELEASE_ASSERT(
+            oddball->m_map.getPtr<const shim::Map>()->m_instanceType == shim::InstanceType::Oddball);
+        return oddball->toJSValue();
     }
 
-    // Recover an opaque pointer out of a v8::Local which is not a number
-    const void* localToPointer() const
+    // Get this as a JSValue when this is a v8::Local
+    JSC::JSValue localToJSValue() const
     {
-        TaggedPointer tagged = localToTagged();
-        RELEASE_ASSERT(tagged.type() != TaggedPointer::Type::Smi);
-        return tagged.getPtr<const void>();
+        TaggedPointer root = localToTagged();
+        if (root.tag() == TaggedPointer::Tag::Smi) {
+            return JSC::jsNumber(root.getSmiUnchecked());
+        } else {
+            using shim::InstanceType;
+            auto* v8_object = root.getPtr<shim::ObjectLayout>();
+
+            switch (v8_object->map()->m_instanceType) {
+            case InstanceType::Oddball:
+                return reinterpret_cast<shim::Oddball*>(v8_object)->toJSValue();
+            case InstanceType::HeapNumber:
+                return JSC::jsDoubleNumber(v8_object->asDouble());
+            default:
+                return v8_object->asCell();
+            }
+        }
     }
 
     // Recover a JSCell pointer out of a v8::Local
     const JSC::JSCell* localToCell() const
     {
-        return reinterpret_cast<const JSC::JSCell*>(localToPointer());
+        TaggedPointer root = localToTagged();
+        RELEASE_ASSERT(root.tag() != TaggedPointer::Tag::Smi);
+        return root.getPtr<shim::ObjectLayout>()->asCell();
     }
 
     // Recover a pointer to a JSCell subclass out of a v8::Local
@@ -87,20 +78,11 @@ public:
     }
 
 private:
-    // Convert the local handle into either a smi or a pointer to some non-V8 type.
+    // Convert the local handle into either a smi or an ObjectLayout pointer.
     TaggedPointer localToTagged() const
     {
-        TaggedPointer root = *reinterpret_cast<const TaggedPointer*>(this);
-        if (root.type() == TaggedPointer::Type::Smi) {
-            return root;
-        } else {
-            // root points to the V8 object. The first field of the V8 object is the map, and the
-            // second is a pointer to some object we have stored. So we ignore the map and recover
-            // the object pointer.
-            ObjectLayout* v8_object = root.getPtr<ObjectLayout>();
-            return TaggedPointer(v8_object->asRaw());
-        }
+        return *reinterpret_cast<const TaggedPointer*>(this);
     }
 };
 
-}
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8EscapableHandleScope.cpp b/src/bun.js/bindings/v8/V8EscapableHandleScope.cpp
index c5e7bcb913..5135aeb8e8 100644
--- a/src/bun.js/bindings/v8/V8EscapableHandleScope.cpp
+++ b/src/bun.js/bindings/v8/V8EscapableHandleScope.cpp
@@ -1,4 +1,7 @@
 #include "V8EscapableHandleScope.h"
+#include "v8_compatibility_assertions.h"
+
+ASSERT_V8_TYPE_LAYOUT_MATCHES(v8::EscapableHandleScope)
 
 namespace v8 {
 
@@ -9,7 +12,6 @@ EscapableHandleScope::EscapableHandleScope(Isolate* isolate)
 
 EscapableHandleScope::~EscapableHandleScope()
 {
-    EscapableHandleScopeBase::~EscapableHandleScopeBase();
 }
 
-}
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8EscapableHandleScope.h b/src/bun.js/bindings/v8/V8EscapableHandleScope.h
index ad5f39ebd7..75f44470c1 100644
--- a/src/bun.js/bindings/v8/V8EscapableHandleScope.h
+++ b/src/bun.js/bindings/v8/V8EscapableHandleScope.h
@@ -10,4 +10,6 @@ public:
     BUN_EXPORT ~EscapableHandleScope();
 };
 
-}
+static_assert(sizeof(EscapableHandleScope) == 32, "EscapableHandleScope has wrong layout");
+
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8EscapableHandleScopeBase.cpp b/src/bun.js/bindings/v8/V8EscapableHandleScopeBase.cpp
index 9bc31b58b5..e9c3c01968 100644
--- a/src/bun.js/bindings/v8/V8EscapableHandleScopeBase.cpp
+++ b/src/bun.js/bindings/v8/V8EscapableHandleScopeBase.cpp
@@ -1,4 +1,7 @@
 #include "V8EscapableHandleScopeBase.h"
+#include "v8_compatibility_assertions.h"
+
+ASSERT_V8_TYPE_LAYOUT_MATCHES(v8::EscapableHandleScopeBase)
 
 namespace v8 {
 
@@ -7,16 +10,21 @@ EscapableHandleScopeBase::EscapableHandleScopeBase(Isolate* isolate)
 {
     // at this point isolate->currentHandleScope() would just be this, so instead we have to get the
     // previous one
-    auto& handle = prev->buffer->createEmptyHandle();
-    escape_slot = &handle;
+    auto& handle = m_previousHandleScope->m_buffer->createEmptyHandle();
+    m_escapeSlot = &handle;
 }
 
 // Store the handle escape_value in the escape slot that we have allocated from the parent
 // HandleScope, and return the escape slot
 uintptr_t* EscapableHandleScopeBase::EscapeSlot(uintptr_t* escape_value)
 {
-    *escape_slot = *reinterpret_cast<Handle*>(escape_value);
-    return &escape_slot->to_v8_object.value;
+    RELEASE_ASSERT(m_escapeSlot != nullptr, "EscapableHandleScope::Escape called multiple times");
+    TaggedPointer* newHandle = m_previousHandleScope->m_buffer->createHandleFromExistingObject(
+        TaggedPointer::fromRaw(*escape_value),
+        m_isolate,
+        m_escapeSlot);
+    m_escapeSlot = nullptr;
+    return newHandle->asRawPtrLocation();
 }
 
-}
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8EscapableHandleScopeBase.h b/src/bun.js/bindings/v8/V8EscapableHandleScopeBase.h
index 1b82748dc7..097f7aa0a5 100644
--- a/src/bun.js/bindings/v8/V8EscapableHandleScopeBase.h
+++ b/src/bun.js/bindings/v8/V8EscapableHandleScopeBase.h
@@ -1,8 +1,8 @@
 #pragma once
 
 #include "v8.h"
-#include "V8HandleScope.h"
 #include "V8Isolate.h"
+#include "V8HandleScope.h"
 
 namespace v8 {
 
@@ -14,7 +14,7 @@ protected:
     BUN_EXPORT uintptr_t* EscapeSlot(uintptr_t* escape_value);
 
 private:
-    Handle* escape_slot;
+    shim::Handle* m_escapeSlot;
 };
 
-}
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8External.cpp b/src/bun.js/bindings/v8/V8External.cpp
index 64a437490a..51023c9863 100644
--- a/src/bun.js/bindings/v8/V8External.cpp
+++ b/src/bun.js/bindings/v8/V8External.cpp
@@ -1,8 +1,10 @@
 #include "V8External.h"
 #include "V8HandleScope.h"
-
+#include "v8_compatibility_assertions.h"
 #include "napi_external.h"
 
+ASSERT_V8_TYPE_LAYOUT_MATCHES(v8::External)
+
 namespace v8 {
 
 Local<External> External::New(Isolate* isolate, void* value)
@@ -23,4 +25,4 @@ void* External::Value() const
     return external->value();
 }
 
-}
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8External.h b/src/bun.js/bindings/v8/V8External.h
index 8c01c3db66..3d9a0fccae 100644
--- a/src/bun.js/bindings/v8/V8External.h
+++ b/src/bun.js/bindings/v8/V8External.h
@@ -13,4 +13,4 @@ public:
     BUN_EXPORT void* Value() const;
 };
 
-}
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8Function.cpp b/src/bun.js/bindings/v8/V8Function.cpp
index 3ff1dc4ae1..ad2823e4ab 100644
--- a/src/bun.js/bindings/v8/V8Function.cpp
+++ b/src/bun.js/bindings/v8/V8Function.cpp
@@ -1,64 +1,38 @@
 #include "V8Function.h"
+#include "shim/Function.h"
+#include "V8HandleScope.h"
+#include "v8_compatibility_assertions.h"
 
-#include "V8FunctionTemplate.h"
-
-#include "JavaScriptCore/FunctionPrototype.h"
-
-using JSC::Structure;
-using JSC::VM;
+ASSERT_V8_TYPE_LAYOUT_MATCHES(v8::Function)
 
 namespace v8 {
 
-// for CREATE_METHOD_TABLE
-namespace JSCastingHelpers = JSC::JSCastingHelpers;
-
-const JSC::ClassInfo Function::s_info = {
-    "Function"_s,
-    &Base::s_info,
-    nullptr,
-    nullptr,
-    CREATE_METHOD_TABLE(Function)
-};
-
-Structure* Function::createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
-{
-    return Structure::create(
-        vm,
-        globalObject,
-        globalObject->functionPrototype(),
-        JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags),
-        info());
-}
-
-template<typename Visitor>
-void Function::visitChildrenImpl(JSCell* cell, Visitor& visitor)
-{
-    Function* fn = jsCast<Function*>(cell);
-    ASSERT_GC_OBJECT_INHERITS(fn, info());
-    Base::visitChildren(fn, visitor);
-
-    visitor.append(fn->__internals.functionTemplate);
-}
-
-DEFINE_VISIT_CHILDREN(Function);
-
-Function* Function::create(VM& vm, Structure* structure, FunctionTemplate* functionTemplate)
-{
-    auto* function = new (NotNull, JSC::allocateCell<Function>(vm)) Function(vm, structure);
-    function->finishCreation(vm, functionTemplate);
-    return function;
-}
-
-void Function::finishCreation(VM& vm, FunctionTemplate* functionTemplate)
-{
-    Base::finishCreation(vm, 0, "Function"_s);
-    __internals.functionTemplate.set(vm, this, functionTemplate);
-}
-
 void Function::SetName(Local<String> name)
 {
-    auto* thisObj = localToObjectPointer();
-    thisObj->m_originalName.set(Isolate::GetCurrent()->vm(), thisObj, name->localToJSString());
+    if (auto* jsFunction = localToObjectPointer<JSC::JSFunction>()) {
+        jsFunction->setFunctionName(jsFunction->globalObject(), name->localToJSString());
+    } else if (auto* v8Function = localToObjectPointer<shim::Function>()) {
+        v8Function->setName(name->localToJSString());
+    } else {
+        RELEASE_ASSERT_NOT_REACHED("v8::Function::SetName called on invalid type");
+    }
 }
 
+Local<Value> Function::GetName() const
+{
+    WTF::String wtfString;
+    if (auto* jsFunction = localToObjectPointer<JSC::JSFunction>()) {
+        wtfString = const_cast<JSC::JSFunction*>(jsFunction)->name(jsFunction->globalObject()->vm());
+    } else if (auto* internalFunction = localToObjectPointer<JSC::InternalFunction>()) {
+        wtfString = const_cast<JSC::InternalFunction*>(internalFunction)->name();
+    } else {
+        RELEASE_ASSERT_NOT_REACHED("v8::Function::GetName called on invalid type");
+    }
+
+    auto* globalObject = jsCast<Zig::GlobalObject*>(localToObjectPointer<JSC::JSNonFinalObject>()->globalObject());
+    auto* handleScope = globalObject->V8GlobalInternals()->currentHandleScope();
+    auto* jsString = JSC::jsString(globalObject->vm(), wtfString);
+    return handleScope->createLocal<Value>(globalObject->vm(), jsString);
 }
+
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8Function.h b/src/bun.js/bindings/v8/V8Function.h
index 9b2d1f552e..bf781e959d 100644
--- a/src/bun.js/bindings/v8/V8Function.h
+++ b/src/bun.js/bindings/v8/V8Function.h
@@ -4,73 +4,14 @@
 #include "V8FunctionTemplate.h"
 #include "V8Local.h"
 #include "V8String.h"
+#include "shim/Function.h"
 
 namespace v8 {
 
-// If this inherited Object like it does in V8, the layout would be wrong for JSC HeapCell.
-// Inheritance shouldn't matter for the ABI.
-class Function : public JSC::InternalFunction {
+class Function : public Object {
 public:
-    using Base = JSC::InternalFunction;
-
-    static Function* create(JSC::VM& vm, JSC::Structure* structure, FunctionTemplate* functionTemplate);
-
-    DECLARE_INFO;
-    DECLARE_VISIT_CHILDREN;
-
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject);
-
-    template<typename, JSC::SubspaceAccess mode>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<Function, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForV8Function.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForV8Function = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForV8Function.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForV8Function = std::forward<decltype(space)>(space); });
-    }
-
     BUN_EXPORT void SetName(Local<String> name);
-
-    FunctionTemplate* functionTemplate() const
-    {
-        return __internals.functionTemplate.get();
-    }
-
-private:
-    class Internals {
-    private:
-        JSC::WriteBarrier<FunctionTemplate> functionTemplate;
-        friend class Function;
-        friend class FunctionTemplate;
-    };
-
-    Internals __internals;
-
-    Function(JSC::VM& vm, JSC::Structure* structure)
-        : Base(vm, structure, FunctionTemplate::functionCall)
-    {
-    }
-
-    Function* localToObjectPointer()
-    {
-        return reinterpret_cast<Data*>(this)->localToObjectPointer<Function>();
-    }
-
-    const Function* localToObjectPointer() const
-    {
-        return reinterpret_cast<const Data*>(this)->localToObjectPointer<Function>();
-    }
-
-    Internals& internals()
-    {
-        return localToObjectPointer()->__internals;
-    }
-
-    void finishCreation(JSC::VM& vm, FunctionTemplate* functionTemplate);
+    BUN_EXPORT Local<Value> GetName() const;
 };
 
-}
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8FunctionCallbackInfo.cpp b/src/bun.js/bindings/v8/V8FunctionCallbackInfo.cpp
new file mode 100644
index 0000000000..f819282b5b
--- /dev/null
+++ b/src/bun.js/bindings/v8/V8FunctionCallbackInfo.cpp
@@ -0,0 +1,23 @@
+#include "V8FunctionCallbackInfo.h"
+#include "real_v8.h"
+#include "v8_compatibility_assertions.h"
+
+// Check that the offset of a field in our ImplicitArgs struct matches the array index
+// that V8 uses to access that field
+#define CHECK_IMPLICIT_ARG(BUN_NAME, V8_NAME)                                          \
+    static_assert(offsetof(v8::ImplicitArgs, BUN_NAME)                                 \
+            == sizeof(void*) * real_v8::FunctionCallbackInfo<real_v8::Value>::V8_NAME, \
+        "Position of `" #BUN_NAME "` in implicit arguments does not match V8");
+
+CHECK_IMPLICIT_ARG(holder, kHolderIndex)
+CHECK_IMPLICIT_ARG(isolate, kIsolateIndex)
+CHECK_IMPLICIT_ARG(unused, kUnusedIndex)
+CHECK_IMPLICIT_ARG(return_value, kReturnValueIndex)
+CHECK_IMPLICIT_ARG(data, kDataIndex)
+CHECK_IMPLICIT_ARG(new_target, kNewTargetIndex)
+
+ASSERT_V8_TYPE_LAYOUT_MATCHES(v8::FunctionCallbackInfo<v8::Value>)
+
+ASSERT_V8_TYPE_FIELD_OFFSET_MATCHES(v8::FunctionCallbackInfo<v8::Value>, implicit_args, implicit_args_)
+ASSERT_V8_TYPE_FIELD_OFFSET_MATCHES(v8::FunctionCallbackInfo<v8::Value>, values, values_)
+ASSERT_V8_TYPE_FIELD_OFFSET_MATCHES(v8::FunctionCallbackInfo<v8::Value>, length, length_)
diff --git a/src/bun.js/bindings/v8/V8FunctionCallbackInfo.h b/src/bun.js/bindings/v8/V8FunctionCallbackInfo.h
new file mode 100644
index 0000000000..7e9f6f9177
--- /dev/null
+++ b/src/bun.js/bindings/v8/V8FunctionCallbackInfo.h
@@ -0,0 +1,43 @@
+#pragma once
+
+#include "shim/TaggedPointer.h"
+
+namespace v8 {
+
+class Isolate;
+class Context;
+class Value;
+
+struct ImplicitArgs {
+    // v8-function-callback.h:168
+    void* holder;
+    Isolate* isolate;
+    void* unused;
+    // overwritten by the callback
+    TaggedPointer return_value;
+    // holds the value passed for data in FunctionTemplate::New
+    TaggedPointer data;
+    void* new_target;
+};
+
+// T = return value
+template<typename T>
+class FunctionCallbackInfo {
+public:
+    // V8 treats this as an array of pointers
+    ImplicitArgs* implicit_args;
+    // index -1 is this
+    TaggedPointer* values;
+    int length;
+
+    FunctionCallbackInfo(ImplicitArgs* implicit_args_, TaggedPointer* values_, int length_)
+        : implicit_args(implicit_args_)
+        , values(values_)
+        , length(length_)
+    {
+    }
+};
+
+using FunctionCallback = void (*)(const FunctionCallbackInfo<Value>&);
+
+}
diff --git a/src/bun.js/bindings/v8/V8FunctionTemplate.cpp b/src/bun.js/bindings/v8/V8FunctionTemplate.cpp
index b83d5c6fbf..36fdf022a1 100644
--- a/src/bun.js/bindings/v8/V8FunctionTemplate.cpp
+++ b/src/bun.js/bindings/v8/V8FunctionTemplate.cpp
@@ -1,8 +1,17 @@
 #include "V8FunctionTemplate.h"
 #include "V8Function.h"
 #include "V8HandleScope.h"
+#include "shim/FunctionTemplate.h"
+#include "v8_compatibility_assertions.h"
 
-#include "JavaScriptCore/FunctionPrototype.h"
+ASSERT_V8_TYPE_LAYOUT_MATCHES(v8::FunctionTemplate)
+
+ASSERT_V8_ENUM_MATCHES(ConstructorBehavior, kThrow)
+ASSERT_V8_ENUM_MATCHES(ConstructorBehavior, kAllow)
+
+ASSERT_V8_ENUM_MATCHES(SideEffectType, kHasSideEffect)
+ASSERT_V8_ENUM_MATCHES(SideEffectType, kHasNoSideEffect)
+ASSERT_V8_ENUM_MATCHES(SideEffectType, kHasSideEffectToReceiver)
 
 using JSC::JSCell;
 using JSC::JSValue;
@@ -10,17 +19,6 @@ using JSC::Structure;
 
 namespace v8 {
 
-// for CREATE_METHOD_TABLE
-namespace JSCastingHelpers = JSC::JSCastingHelpers;
-
-const JSC::ClassInfo FunctionTemplate::s_info = {
-    "FunctionTemplate"_s,
-    &Base::s_info,
-    nullptr,
-    nullptr,
-    CREATE_METHOD_TABLE(FunctionTemplate)
-};
-
 Local<FunctionTemplate> FunctionTemplate::New(
     Isolate* isolate,
     FunctionCallback callback,
@@ -36,24 +34,30 @@ Local<FunctionTemplate> FunctionTemplate::New(
 {
     // only handling simpler cases for now
     // (pass most of these into v8::Function / JSC::InternalFunction)
-    RELEASE_ASSERT(signature.IsEmpty());
-    RELEASE_ASSERT(length == 0);
-    RELEASE_ASSERT(behavior == ConstructorBehavior::kAllow);
-    RELEASE_ASSERT(side_effect_type == SideEffectType::kHasSideEffect);
-    RELEASE_ASSERT(c_function == nullptr);
-    RELEASE_ASSERT(instance_type == 0);
-    RELEASE_ASSERT(allowed_receiver_instance_type_range_start == 0);
-    RELEASE_ASSERT(allowed_receiver_instance_type_range_end == 0);
+    RELEASE_ASSERT_WITH_MESSAGE(signature.IsEmpty(),
+        "Passing signature to FunctionTemplate::New is not yet supported");
+    RELEASE_ASSERT_WITH_MESSAGE(length == 0,
+        "Passing length to FunctionTemplate::New is not yet supported");
+    RELEASE_ASSERT_WITH_MESSAGE(behavior == ConstructorBehavior::kAllow,
+        "Passing behavior to FunctionTemplate::New is not yet supported");
+    RELEASE_ASSERT_WITH_MESSAGE(side_effect_type == SideEffectType::kHasSideEffect,
+        "Passing side_effect_type to FunctionTemplate::New is not yet supported");
+    RELEASE_ASSERT_WITH_MESSAGE(c_function == nullptr,
+        "Passing c_function to FunctionTemplate::New is not yet supported");
+    RELEASE_ASSERT_WITH_MESSAGE(instance_type == 0,
+        "Passing instance_type to FunctionTemplate::New is not yet supported");
+    RELEASE_ASSERT_WITH_MESSAGE(allowed_receiver_instance_type_range_start == 0,
+        "Passing allowed_receiver_instance_type_range_start to FunctionTemplate::New is not yet supported");
+    RELEASE_ASSERT_WITH_MESSAGE(allowed_receiver_instance_type_range_end == 0,
+        "Passing allowed_receiver_instance_type_range_end to FunctionTemplate::New is not yet supported");
 
     auto globalObject = isolate->globalObject();
     auto& vm = globalObject->vm();
     auto* globalInternals = globalObject->V8GlobalInternals();
-    JSValue jsc_data = data.IsEmpty() ? JSC::jsUndefined() : data->localToJSValue(globalInternals);
+    JSValue jsc_data = data.IsEmpty() ? JSC::jsUndefined() : data->localToJSValue();
 
     Structure* structure = globalInternals->functionTemplateStructure(globalObject);
-    auto* functionTemplate = new (NotNull, JSC::allocateCell<FunctionTemplate>(vm)) FunctionTemplate(
-        vm, structure, callback, jsc_data);
-    functionTemplate->finishCreation(vm);
+    auto* functionTemplate = shim::FunctionTemplate::create(vm, structure, callback, jsc_data);
 
     return globalInternals->currentHandleScope()->createLocal<FunctionTemplate>(vm, functionTemplate);
 }
@@ -63,75 +67,9 @@ MaybeLocal<Function> FunctionTemplate::GetFunction(Local<Context> context)
     auto& vm = context->vm();
     auto* globalObject = context->globalObject();
     auto* globalInternals = globalObject->V8GlobalInternals();
-    auto* f = Function::create(vm, globalInternals->v8FunctionStructure(globalObject), localToObjectPointer());
+    auto* f = shim::Function::create(vm, globalInternals->v8FunctionStructure(globalObject), localToObjectPointer());
 
     return globalInternals->currentHandleScope()->createLocal<Function>(vm, f);
 }
 
-Structure* FunctionTemplate::createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
-{
-    return Structure::create(
-        vm,
-        globalObject,
-        globalObject->functionPrototype(),
-        JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags),
-        info());
-}
-
-template<typename Visitor>
-void FunctionTemplate::visitChildrenImpl(JSCell* cell, Visitor& visitor)
-{
-    FunctionTemplate* fn = jsCast<FunctionTemplate*>(cell);
-    ASSERT_GC_OBJECT_INHERITS(fn, info());
-    Base::visitChildren(fn, visitor);
-
-    visitor.append(fn->__internals.data);
-}
-
-DEFINE_VISIT_CHILDREN(FunctionTemplate);
-
-JSC::EncodedJSValue FunctionTemplate::functionCall(JSC::JSGlobalObject* globalObject, JSC::CallFrame* callFrame)
-{
-    auto* callee = JSC::jsDynamicCast<Function*>(callFrame->jsCallee());
-    auto* functionTemplate = callee->functionTemplate();
-    auto* isolate = Isolate::fromGlobalObject(JSC::jsDynamicCast<Zig::GlobalObject*>(globalObject));
-    auto& vm = globalObject->vm();
-
-    WTF::Vector<TaggedPointer, 8> args(callFrame->argumentCount() + 1);
-
-    HandleScope hs(isolate);
-    Local<Value> thisValue = hs.createLocal<Value>(vm, callFrame->thisValue());
-    args[0] = thisValue.tagged();
-
-    for (size_t i = 0; i < callFrame->argumentCount(); i++) {
-        Local<Value> argValue = hs.createLocal<Value>(vm, callFrame->argument(i));
-        args[i + 1] = argValue.tagged();
-    }
-
-    Local<Value> data = hs.createLocal<Value>(vm, functionTemplate->__internals.data.get());
-
-    ImplicitArgs implicit_args = {
-        .holder = nullptr,
-        .isolate = isolate,
-        .context = reinterpret_cast<Context*>(isolate),
-        .return_value = TaggedPointer(),
-        // data may be an object
-        // put it in the handle scope so that it has a map ptr
-        .target = data.tagged(),
-        .new_target = nullptr,
-    };
-
-    FunctionCallbackInfo<Value> info(&implicit_args, args.data() + 1, callFrame->argumentCount());
-
-    functionTemplate->__internals.callback(info);
-
-    if (implicit_args.return_value.type() != TaggedPointer::Type::Smi && implicit_args.return_value.getPtr() == nullptr) {
-        // callback forgot to set a return value, so return undefined
-        return JSValue::encode(JSC::jsUndefined());
-    } else {
-        Local<Data> local_ret(&implicit_args.return_value);
-        return JSValue::encode(local_ret->localToJSValue(isolate->globalInternals()));
-    }
-}
-
-}
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8FunctionTemplate.h b/src/bun.js/bindings/v8/V8FunctionTemplate.h
index 3d3fe261c1..873b45a0da 100644
--- a/src/bun.js/bindings/v8/V8FunctionTemplate.h
+++ b/src/bun.js/bindings/v8/V8FunctionTemplate.h
@@ -7,42 +7,17 @@
 #include "V8MaybeLocal.h"
 #include "V8Value.h"
 #include "V8Signature.h"
+#include "V8Template.h"
+#include "V8FunctionCallbackInfo.h"
+#include "shim/FunctionTemplate.h"
 
 namespace v8 {
 
 class Function;
 
-struct ImplicitArgs {
-    // v8-function-callback.h:168
-    void* holder;
-    Isolate* isolate;
-    Context* context;
-    // overwritten by the callback
-    TaggedPointer return_value;
-    // holds the value passed for data in FunctionTemplate::New
-    TaggedPointer target;
-    void* new_target;
-};
-
-// T = return value
-template<typename T>
-class FunctionCallbackInfo {
-    // V8 treats this as an array of pointers
-    ImplicitArgs* implicit_args;
-    // index -1 is this
-    TaggedPointer* values;
-    int length;
-
-public:
-    FunctionCallbackInfo(ImplicitArgs* implicit_args_, TaggedPointer* values_, int length_)
-        : implicit_args(implicit_args_)
-        , values(values_)
-        , length(length_)
-    {
-    }
-};
-
-using FunctionCallback = void (*)(const FunctionCallbackInfo<Value>&);
+namespace shim {
+class Function;
+}
 
 enum class ConstructorBehavior {
     kThrow,
@@ -55,18 +30,16 @@ enum class SideEffectType {
     kHasSideEffectToReceiver,
 };
 
+// Only used by v8 fast API calls, which Node.js doesn't seem to intend to support
+// (v8-fast-api-calls.h is not in the headers distribution)
 class CFunction {
 private:
     const void* address;
     const void* type_info;
 };
 
-// If this inherited Template like it does in V8, the layout would be wrong for JSC HeapCell.
-// Inheritance shouldn't matter for the ABI.
-class FunctionTemplate : public JSC::InternalFunction {
+class FunctionTemplate : public Template {
 public:
-    using Base = JSC::InternalFunction;
-
     BUN_EXPORT static Local<FunctionTemplate> New(
         Isolate* isolate,
         FunctionCallback callback = nullptr,
@@ -82,74 +55,16 @@ public:
 
     BUN_EXPORT MaybeLocal<Function> GetFunction(Local<Context> context);
 
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject);
-
-    template<typename, JSC::SubspaceAccess mode>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<FunctionTemplate, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForFunctionTemplate.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForFunctionTemplate = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForFunctionTemplate.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForFunctionTemplate = std::forward<decltype(space)>(space); });
-    }
-
-    DECLARE_INFO;
-    DECLARE_VISIT_CHILDREN;
-
-    friend class Function;
-
-    FunctionCallback callback() const
-    {
-        return __internals.callback;
-    }
-
 private:
-    class Internals {
-    private:
-        FunctionCallback callback;
-        JSC::WriteBarrier<JSC::Unknown> data;
-
-        Internals(FunctionCallback callback_, JSC::VM& vm, FunctionTemplate* owner, JSC::JSValue data_)
-            : callback(callback_)
-            , data(vm, owner, data_)
-        {
-        }
-
-        friend class FunctionTemplate;
-    };
-
-    // only use from functions called directly on FunctionTemplate
-    Internals __internals;
-
-    FunctionTemplate* localToObjectPointer()
+    shim::FunctionTemplate* localToObjectPointer()
     {
-        return reinterpret_cast<Data*>(this)->localToObjectPointer<FunctionTemplate>();
+        return Data::localToObjectPointer<shim::FunctionTemplate>();
     }
 
-    const FunctionTemplate* localToObjectPointer() const
+    const shim::FunctionTemplate* localToObjectPointer() const
     {
-        return reinterpret_cast<const Data*>(this)->localToObjectPointer<FunctionTemplate>();
+        return Data::localToObjectPointer<shim::FunctionTemplate>();
     }
-
-    // only use from functions called on Local<FunctionTemplate>
-    Internals& internals()
-    {
-        return localToObjectPointer()->__internals;
-    }
-
-    static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES functionCall(JSC::JSGlobalObject* globalObject, JSC::CallFrame* callFrame);
-
-    FunctionTemplate(JSC::VM& vm, JSC::Structure* structure, FunctionCallback callback, JSC::JSValue data)
-        : __internals(callback, vm, this, data)
-        , Base(vm, structure, functionCall, JSC::callHostFunctionAsConstructor)
-    {
-    }
-
-    // some kind of static trampoline
 };
 
-}
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8GlobalInternals.cpp b/src/bun.js/bindings/v8/V8GlobalInternals.cpp
deleted file mode 100644
index 6a5a36fa87..0000000000
--- a/src/bun.js/bindings/v8/V8GlobalInternals.cpp
+++ /dev/null
@@ -1,70 +0,0 @@
-#include "V8GlobalInternals.h"
-
-#include "V8ObjectTemplate.h"
-#include "V8InternalFieldObject.h"
-#include "V8HandleScopeBuffer.h"
-#include "V8FunctionTemplate.h"
-#include "V8Function.h"
-
-#include "JavaScriptCore/FunctionPrototype.h"
-#include "JavaScriptCore/LazyClassStructureInlines.h"
-#include "JavaScriptCore/VMTrapsInlines.h"
-
-using JSC::ClassInfo;
-using JSC::LazyClassStructure;
-using JSC::LazyProperty;
-using JSC::Structure;
-using JSC::VM;
-
-namespace v8 {
-
-// for CREATE_METHOD_TABLE
-namespace JSCastingHelpers = JSC::JSCastingHelpers;
-
-const ClassInfo GlobalInternals::s_info = { "GlobalInternals"_s, nullptr, nullptr, nullptr, CREATE_METHOD_TABLE(GlobalInternals) };
-
-GlobalInternals* GlobalInternals::create(VM& vm, Structure* structure, Zig::GlobalObject* globalObject)
-{
-    GlobalInternals* internals = new (NotNull, JSC::allocateCell<GlobalInternals>(vm)) GlobalInternals(vm, structure, globalObject);
-    internals->finishCreation(vm);
-    return internals;
-}
-
-void GlobalInternals::finishCreation(VM& vm)
-{
-    Base::finishCreation(vm);
-    m_ObjectTemplateStructure.initLater([](LazyClassStructure::Initializer& init) {
-        init.setStructure(ObjectTemplate::createStructure(init.vm, init.global, init.global->functionPrototype()));
-    });
-    m_HandleScopeBufferStructure.initLater([](LazyClassStructure::Initializer& init) {
-        init.setStructure(HandleScopeBuffer::createStructure(init.vm, init.global));
-    });
-    m_FunctionTemplateStructure.initLater([](LazyClassStructure::Initializer& init) {
-        init.setStructure(FunctionTemplate::createStructure(init.vm, init.global));
-    });
-    m_V8FunctionStructure.initLater([](LazyClassStructure::Initializer& init) {
-        init.setStructure(Function::createStructure(init.vm, init.global));
-    });
-    m_GlobalHandles.initLater([](const LazyProperty<GlobalInternals, HandleScopeBuffer>::Initializer& init) {
-        init.set(HandleScopeBuffer::create(init.vm,
-            init.owner->handleScopeBufferStructure(init.owner->globalObject)));
-    });
-}
-
-template<typename Visitor>
-void GlobalInternals::visitChildrenImpl(JSCell* cell, Visitor& visitor)
-{
-    GlobalInternals* thisObject = jsCast<GlobalInternals*>(cell);
-    ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-    Base::visitChildren(thisObject, visitor);
-
-    thisObject->m_ObjectTemplateStructure.visit(visitor);
-    thisObject->m_HandleScopeBufferStructure.visit(visitor);
-    thisObject->m_FunctionTemplateStructure.visit(visitor);
-    thisObject->m_V8FunctionStructure.visit(visitor);
-    thisObject->m_GlobalHandles.visit(visitor);
-}
-
-DEFINE_VISIT_CHILDREN_WITH_MODIFIER(JS_EXPORT_PRIVATE, GlobalInternals);
-
-}
diff --git a/src/bun.js/bindings/v8/V8GlobalInternals.h b/src/bun.js/bindings/v8/V8GlobalInternals.h
deleted file mode 100644
index bdb2bbc936..0000000000
--- a/src/bun.js/bindings/v8/V8GlobalInternals.h
+++ /dev/null
@@ -1,108 +0,0 @@
-#pragma once
-
-#include "BunClientData.h"
-
-#include "V8Roots.h"
-#include "V8Oddball.h"
-
-namespace v8 {
-
-class HandleScope;
-class HandleScopeBuffer;
-
-class GlobalInternals : public JSC::JSCell {
-public:
-    using Base = JSC::JSCell;
-
-    static GlobalInternals* create(JSC::VM& vm, JSC::Structure* structure, Zig::GlobalObject* globalObject);
-
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
-    {
-        return JSC::Structure::create(vm, globalObject, JSC::jsNull(), JSC::TypeInfo(JSC::ObjectType, StructureFlags), info(), 0, 0);
-    }
-
-    template<typename, JSC::SubspaceAccess mode>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<GlobalInternals, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForV8GlobalInternals.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForV8GlobalInternals = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForV8GlobalInternals.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForV8GlobalInternals = std::forward<decltype(space)>(space); });
-    }
-
-    JSC::Structure* objectTemplateStructure(JSC::JSGlobalObject* globalObject) const
-    {
-        return m_ObjectTemplateStructure.getInitializedOnMainThread(globalObject);
-    }
-
-    JSC::Structure* handleScopeBufferStructure(JSC::JSGlobalObject* globalObject) const
-    {
-        return m_HandleScopeBufferStructure.getInitializedOnMainThread(globalObject);
-    }
-
-    JSC::Structure* functionTemplateStructure(JSC::JSGlobalObject* globalObject) const
-    {
-        return m_FunctionTemplateStructure.getInitializedOnMainThread(globalObject);
-    }
-
-    JSC::Structure* v8FunctionStructure(JSC::JSGlobalObject* globalObject) const
-    {
-        return m_V8FunctionStructure.getInitializedOnMainThread(globalObject);
-    }
-
-    HandleScopeBuffer* globalHandles() const { return m_GlobalHandles.getInitializedOnMainThread(this); }
-
-    HandleScope* currentHandleScope() const { return m_CurrentHandleScope; }
-
-    void setCurrentHandleScope(HandleScope* handleScope) { m_CurrentHandleScope = handleScope; }
-
-    TaggedPointer* undefinedSlot() { return &roots.roots[Roots::kUndefinedValueRootIndex]; }
-
-    TaggedPointer* nullSlot() { return &roots.roots[Roots::kNullValueRootIndex]; }
-
-    TaggedPointer* trueSlot() { return &roots.roots[Roots::kTrueValueRootIndex]; }
-
-    TaggedPointer* falseSlot() { return &roots.roots[Roots::kFalseValueRootIndex]; }
-
-    DECLARE_INFO;
-    DECLARE_VISIT_CHILDREN_WITH_MODIFIER(JS_EXPORT_PRIVATE);
-
-    friend struct Roots;
-    friend class Isolate;
-    friend class Context;
-
-private:
-    Zig::GlobalObject* globalObject;
-    JSC::LazyClassStructure m_ObjectTemplateStructure;
-    JSC::LazyClassStructure m_HandleScopeBufferStructure;
-    JSC::LazyClassStructure m_FunctionTemplateStructure;
-    JSC::LazyClassStructure m_V8FunctionStructure;
-    HandleScope* m_CurrentHandleScope;
-    JSC::LazyProperty<GlobalInternals, HandleScopeBuffer> m_GlobalHandles;
-
-    Oddball undefinedValue;
-    Oddball nullValue;
-    Oddball trueValue;
-    Oddball falseValue;
-
-    Roots roots;
-
-    void finishCreation(JSC::VM& vm);
-    GlobalInternals(JSC::VM& vm, JSC::Structure* structure, Zig::GlobalObject* globalObject_)
-        : Base(vm, structure)
-        , m_CurrentHandleScope(nullptr)
-        , undefinedValue(Oddball::Kind::kUndefined)
-        , nullValue(Oddball::Kind::kNull)
-        , trueValue(Oddball::Kind::kTrue, &Map::boolean_map)
-        , falseValue(Oddball::Kind::kFalse, &Map::boolean_map)
-        , roots(this)
-        , globalObject(globalObject_)
-    {
-    }
-};
-
-}
diff --git a/src/bun.js/bindings/v8/V8Handle.h b/src/bun.js/bindings/v8/V8Handle.h
deleted file mode 100644
index 709481e95e..0000000000
--- a/src/bun.js/bindings/v8/V8Handle.h
+++ /dev/null
@@ -1,149 +0,0 @@
-#pragma once
-
-#include "V8Map.h"
-
-namespace v8 {
-
-class ObjectLayout {
-private:
-    // these two fields are laid out so that V8 can find the map
-    TaggedPointer tagged_map;
-    union {
-        JSC::WriteBarrier<JSC::JSCell> cell;
-        double number;
-        void* raw;
-    } contents;
-
-public:
-    ObjectLayout()
-        // using a smi value for map is most likely to catch bugs as almost every access will expect
-        // map to be a pointer (and even if the assertion is bypassed, it'll be a null pointer)
-        : tagged_map(0)
-        , contents({ .raw = nullptr })
-    {
-    }
-
-    ObjectLayout(const Map* map_ptr, JSC::JSCell* cell, JSC::VM& vm, const JSC::JSCell* owner)
-        : tagged_map(const_cast<Map*>(map_ptr))
-        , contents({ .cell = JSC::WriteBarrier<JSC::JSCell>(vm, owner, cell) })
-    {
-    }
-
-    ObjectLayout(double number)
-        : tagged_map(const_cast<Map*>(&Map::heap_number_map))
-        , contents({ .number = number })
-    {
-    }
-
-    ObjectLayout(void* raw)
-        : tagged_map(const_cast<Map*>(&Map::raw_ptr_map))
-        , contents({ .raw = raw })
-    {
-    }
-
-    const Map* map() const { return tagged_map.getPtr<Map>(); }
-
-    double asDouble() const { return contents.number; }
-
-    JSC::JSCell* asCell() const { return contents.cell.get(); }
-
-    void* asRaw() const { return contents.raw; }
-
-    friend class Handle;
-    friend class HandleScopeBuffer;
-};
-
-// A handle stored in a HandleScope with layout suitable for V8's inlined functions:
-// - The first field is a V8 tagged pointer. If it's a SMI (int32), it holds the numeric value
-//   directly and the other fields don't matter.
-// - Otherwise, if the first field is a pointer value, V8 treats that as a pointer to an object with
-//   V8 layout. V8 objects have a tagged pointer to their map (which describes their structure) as
-//   the first field. Therefore, in the object case, the first field is a pointer to the second
-//   field.
-// - V8 will inspect the instance type of the map to determine if it can take fast paths for some
-//   functions (notably, Value::IsUndefined()/IsNull() and Object::GetInternalField()). For objects,
-//   we use a map with an instance type that makes V8 think it must call SlowGetInternalField(),
-//   which we can control. That function (and all other functions that are called on Locals) uses
-//   the third field to get the actual object (either a JSCell* or a void*, depending on whether map
-//   points to Map::object_map or Map::raw_ptr_map).
-struct Handle {
-    static_assert(offsetof(ObjectLayout, tagged_map) == 0, "ObjectLayout is wrong");
-    static_assert(offsetof(ObjectLayout, contents) == 8, "ObjectLayout is wrong");
-    static_assert(sizeof(ObjectLayout) == 16, "ObjectLayout is wrong");
-
-    Handle(const Map* map, JSC::JSCell* cell, JSC::VM& vm, const JSC::JSCell* owner)
-        : to_v8_object(&this->object)
-        , object(map, cell, vm, owner)
-    {
-    }
-
-    Handle(double number)
-        : to_v8_object(&this->object)
-        , object(number)
-    {
-    }
-
-    Handle(void* raw)
-        : to_v8_object(&this->object)
-        , object(raw)
-    {
-    }
-
-    Handle(int32_t smi)
-        : to_v8_object(smi)
-        , object()
-    {
-    }
-
-    Handle(const Handle& that)
-    {
-        *this = that;
-    }
-
-    Handle(const ObjectLayout* that)
-        : to_v8_object(&this->object)
-    {
-        object = *that;
-    }
-
-    Handle& operator=(const Handle& that)
-    {
-        object = that.object;
-        if (that.to_v8_object.type() == TaggedPointer::Type::Smi) {
-            to_v8_object = that.to_v8_object;
-        } else {
-            to_v8_object = &this->object;
-        }
-        return *this;
-    }
-
-    Handle()
-        : to_v8_object(0)
-        , object()
-    {
-    }
-
-    bool isCell() const
-    {
-        if (to_v8_object.type() == TaggedPointer::Type::Smi) {
-            return false;
-        }
-        const Map* map_ptr = object.map();
-        // TODO(@190n) exhaustively switch on InstanceType
-        if (map_ptr == &Map::object_map || map_ptr == &Map::string_map) {
-            return true;
-        } else if (map_ptr == &Map::map_map || map_ptr == &Map::raw_ptr_map || map_ptr == &Map::oddball_map
-            || map_ptr == &Map::boolean_map || map_ptr == &Map::heap_number_map) {
-            return false;
-        } else {
-            RELEASE_ASSERT_NOT_REACHED("unknown Map at %p with instance type %" PRIx16,
-                map_ptr, map_ptr->instance_type);
-        }
-    }
-
-    // if not SMI, holds &this->map so that V8 can see what kind of object this is
-    TaggedPointer to_v8_object;
-    ObjectLayout object;
-};
-
-}
diff --git a/src/bun.js/bindings/v8/V8HandleScope.cpp b/src/bun.js/bindings/v8/V8HandleScope.cpp
index f7d20b76d2..9071d9621c 100644
--- a/src/bun.js/bindings/v8/V8HandleScope.cpp
+++ b/src/bun.js/bindings/v8/V8HandleScope.cpp
@@ -1,27 +1,38 @@
 #include "V8HandleScope.h"
+#include "shim/GlobalInternals.h"
+#include "v8_compatibility_assertions.h"
 
-#include "V8GlobalInternals.h"
+// I haven't found an inlined function which accesses HandleScope fields, so I'm assuming the field
+// offsets do *not* need to match (also, our fields have different types and meanings anyway).
+// But the size must match, because if our HandleScope is too big it'll clobber other stack variables.
+ASSERT_V8_TYPE_LAYOUT_MATCHES(v8::HandleScope)
 
 namespace v8 {
 
-HandleScope::HandleScope(Isolate* isolate_)
-    : isolate(isolate_)
-    , prev(isolate->globalInternals()->currentHandleScope())
-    , buffer(HandleScopeBuffer::create(isolate_->vm(), isolate_->globalInternals()->handleScopeBufferStructure(isolate_->globalObject())))
+HandleScope::HandleScope(Isolate* isolate)
+    : m_isolate(isolate)
+    , m_previousHandleScope(m_isolate->globalInternals()->currentHandleScope())
+    , m_buffer(shim::HandleScopeBuffer::create(
+          isolate->vm(),
+          isolate->globalInternals()->handleScopeBufferStructure(isolate->globalObject())))
 {
-    isolate->globalInternals()->setCurrentHandleScope(this);
+    m_isolate->globalInternals()->setCurrentHandleScope(this);
 }
 
 HandleScope::~HandleScope()
 {
-    isolate->globalInternals()->setCurrentHandleScope(prev);
-    buffer = nullptr;
+    m_isolate->globalInternals()->setCurrentHandleScope(m_previousHandleScope);
+    m_buffer->clear();
+    m_buffer = nullptr;
 }
 
-uintptr_t* HandleScope::CreateHandle(internal::Isolate* isolate, uintptr_t value)
+uintptr_t* HandleScope::CreateHandle(internal::Isolate* i_isolate, uintptr_t value)
 {
-    auto* handleScope = reinterpret_cast<Isolate*>(isolate)->globalInternals()->currentHandleScope();
-    return &handleScope->buffer->createHandleFromExistingHandle(TaggedPointer::fromRaw(value))->value;
+    auto* isolate = reinterpret_cast<Isolate*>(i_isolate);
+    auto* handleScope = isolate->globalInternals()->currentHandleScope();
+    TaggedPointer* newSlot = handleScope->m_buffer->createHandleFromExistingObject(TaggedPointer::fromRaw(value), isolate);
+    // basically a reinterpret
+    return newSlot->asRawPtrLocation();
 }
 
-}
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8HandleScope.h b/src/bun.js/bindings/v8/V8HandleScope.h
index 81f73e08ee..8813525e39 100644
--- a/src/bun.js/bindings/v8/V8HandleScope.h
+++ b/src/bun.js/bindings/v8/V8HandleScope.h
@@ -3,7 +3,9 @@
 #include "v8.h"
 #include "V8Isolate.h"
 #include "v8_internal.h"
-#include "V8HandleScopeBuffer.h"
+#include "shim/HandleScopeBuffer.h"
+#include "shim/GlobalInternals.h"
+#include "shim/Map.h"
 
 namespace v8 {
 
@@ -18,40 +20,34 @@ public:
     {
         // TODO(@190n) handle more types
         if (value.isString()) {
-            return Local<T>(buffer->createHandle(value.asCell(), &Map::string_map, vm));
+            return Local<T>(m_buffer->createHandle(value.asCell(), &shim::Map::string_map, vm));
         } else if (value.isCell()) {
-            return Local<T>(buffer->createHandle(value.asCell(), &Map::object_map, vm));
+            return Local<T>(m_buffer->createHandle(value.asCell(), &shim::Map::object_map, vm));
         } else if (value.isInt32()) {
-            return Local<T>(buffer->createSmiHandle(value.asInt32()));
+            return Local<T>(m_buffer->createSmiHandle(value.asInt32()));
         } else if (value.isNumber()) {
-            return Local<T>(buffer->createDoubleHandle(value.asNumber()));
+            return Local<T>(m_buffer->createDoubleHandle(value.asNumber()));
         } else if (value.isUndefined()) {
-            return Local<T>(isolate->globalInternals()->undefinedSlot());
+            return Local<T>(m_isolate->undefinedSlot());
         } else if (value.isNull()) {
-            return Local<T>(isolate->globalInternals()->nullSlot());
+            return Local<T>(m_isolate->nullSlot());
         } else if (value.isTrue()) {
-            return Local<T>(isolate->globalInternals()->trueSlot());
+            return Local<T>(m_isolate->trueSlot());
         } else if (value.isFalse()) {
-            return Local<T>(isolate->globalInternals()->falseSlot());
+            return Local<T>(m_isolate->falseSlot());
         } else {
             V8_UNIMPLEMENTED();
             return Local<T>();
         }
     }
 
-    template<typename T> Local<T> createRawLocal(void* ptr)
-    {
-        TaggedPointer* handle = buffer->createRawHandle(ptr);
-        return Local<T>(handle);
-    }
-
     friend class EscapableHandleScopeBase;
 
 protected:
     // must be 24 bytes to match V8 layout
-    Isolate* isolate;
-    HandleScope* prev;
-    HandleScopeBuffer* buffer;
+    Isolate* m_isolate;
+    HandleScope* m_previousHandleScope;
+    shim::HandleScopeBuffer* m_buffer;
 
     // is protected in v8, which matters on windows
     BUN_EXPORT static uintptr_t* CreateHandle(internal::Isolate* isolate, uintptr_t value);
@@ -59,4 +55,4 @@ protected:
 
 static_assert(sizeof(HandleScope) == 24, "HandleScope has wrong layout");
 
-}
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8HandleScopeBuffer.cpp b/src/bun.js/bindings/v8/V8HandleScopeBuffer.cpp
deleted file mode 100644
index 8468cc6467..0000000000
--- a/src/bun.js/bindings/v8/V8HandleScopeBuffer.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-#include "V8HandleScopeBuffer.h"
-
-namespace v8 {
-
-// for CREATE_METHOD_TABLE
-namespace JSCastingHelpers = JSC::JSCastingHelpers;
-
-const JSC::ClassInfo HandleScopeBuffer::s_info = {
-    "HandleScopeBuffer"_s,
-    nullptr,
-    nullptr,
-    nullptr,
-    CREATE_METHOD_TABLE(HandleScopeBuffer)
-};
-
-HandleScopeBuffer* HandleScopeBuffer::create(JSC::VM& vm, JSC::Structure* structure)
-{
-    HandleScopeBuffer* buffer = new (NotNull, JSC::allocateCell<HandleScopeBuffer>(vm)) HandleScopeBuffer(vm, structure);
-    buffer->finishCreation(vm);
-    return buffer;
-}
-
-template<typename Visitor>
-void HandleScopeBuffer::visitChildrenImpl(JSCell* cell, Visitor& visitor)
-{
-    HandleScopeBuffer* thisObject = jsCast<HandleScopeBuffer*>(cell);
-    ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-    Base::visitChildren(thisObject, visitor);
-
-    WTF::Locker locker { thisObject->gc_lock };
-
-    for (auto& handle : thisObject->storage) {
-        if (handle.isCell()) {
-            visitor.append(handle.object.contents.cell);
-        }
-    }
-}
-
-DEFINE_VISIT_CHILDREN(HandleScopeBuffer);
-
-Handle& HandleScopeBuffer::createEmptyHandle()
-{
-    WTF::Locker locker { gc_lock };
-    storage.append(Handle {});
-    return storage.last();
-}
-
-TaggedPointer* HandleScopeBuffer::createHandle(JSCell* ptr, const Map* map, JSC::VM& vm)
-{
-    auto& handle = createEmptyHandle();
-    handle = Handle(map, ptr, vm, this);
-    return &handle.to_v8_object;
-}
-
-TaggedPointer* HandleScopeBuffer::createRawHandle(void* ptr)
-{
-    auto& handle = createEmptyHandle();
-    handle = Handle(ptr);
-    return &handle.to_v8_object;
-}
-
-TaggedPointer* HandleScopeBuffer::createSmiHandle(int32_t smi)
-{
-    auto& handle = createEmptyHandle();
-    handle = Handle(smi);
-    return &handle.to_v8_object;
-}
-
-TaggedPointer* HandleScopeBuffer::createDoubleHandle(double value)
-{
-    auto& handle = createEmptyHandle();
-    handle = Handle(value);
-    return &handle.to_v8_object;
-}
-
-TaggedPointer* HandleScopeBuffer::createHandleFromExistingHandle(TaggedPointer address)
-{
-    auto& handle = createEmptyHandle();
-    int32_t smi;
-    if (address.getSmi(smi)) {
-        handle = Handle(smi);
-    } else {
-        auto* v8_object = address.getPtr<ObjectLayout>();
-        handle = Handle(v8_object);
-    }
-    return &handle.to_v8_object;
-}
-
-}
diff --git a/src/bun.js/bindings/v8/V8HandleScopeBuffer.h b/src/bun.js/bindings/v8/V8HandleScopeBuffer.h
deleted file mode 100644
index a045951436..0000000000
--- a/src/bun.js/bindings/v8/V8HandleScopeBuffer.h
+++ /dev/null
@@ -1,59 +0,0 @@
-#pragma once
-
-#include "v8.h"
-#include "V8TaggedPointer.h"
-#include "V8Map.h"
-#include "V8Handle.h"
-
-namespace v8 {
-
-// An array used by HandleScope to store the items. Must keep pointer stability when resized, since
-// v8::Locals point inside this array.
-class HandleScopeBuffer : public JSC::JSCell {
-public:
-    using Base = JSC::JSCell;
-
-    static HandleScopeBuffer* create(JSC::VM& vm, JSC::Structure* structure);
-
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
-    {
-        return JSC::Structure::create(vm, globalObject, JSC::jsNull(), JSC::TypeInfo(JSC::CellType, StructureFlags), info(), 0, 0);
-    }
-
-    template<typename, JSC::SubspaceAccess mode>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<HandleScopeBuffer, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForHandleScopeBuffer.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForHandleScopeBuffer = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForHandleScopeBuffer.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForHandleScopeBuffer = std::forward<decltype(space)>(space); });
-    }
-
-    TaggedPointer* createHandle(JSC::JSCell* object, const Map* map, JSC::VM& vm);
-    TaggedPointer* createRawHandle(void* ptr);
-    TaggedPointer* createSmiHandle(int32_t smi);
-    TaggedPointer* createDoubleHandle(double value);
-    TaggedPointer* createHandleFromExistingHandle(TaggedPointer address);
-
-    DECLARE_INFO;
-    DECLARE_VISIT_CHILDREN;
-
-    friend class EscapableHandleScopeBase;
-
-private:
-    WTF::Lock gc_lock;
-    WTF::SegmentedVector<Handle, 16> storage;
-
-    Handle& createEmptyHandle();
-
-    HandleScopeBuffer(JSC::VM& vm, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
-};
-
-}
diff --git a/src/bun.js/bindings/v8/V8InternalFieldObject.cpp b/src/bun.js/bindings/v8/V8InternalFieldObject.cpp
deleted file mode 100644
index 69dd3878da..0000000000
--- a/src/bun.js/bindings/v8/V8InternalFieldObject.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-#include "V8InternalFieldObject.h"
-
-namespace v8 {
-
-// for CREATE_METHOD_TABLE
-namespace JSCastingHelpers = JSC::JSCastingHelpers;
-
-const JSC::ClassInfo InternalFieldObject::s_info = {
-    "InternalFieldObject"_s,
-    &Base::s_info,
-    nullptr,
-    nullptr,
-    CREATE_METHOD_TABLE(InternalFieldObject)
-};
-
-InternalFieldObject* InternalFieldObject::create(JSC::VM& vm, JSC::Structure* structure, Local<ObjectTemplate> objectTemplate)
-{
-    // TODO figure out how this works with __internals
-    // maybe pass a Local<ObjectTemplate>
-    auto object = new (NotNull, JSC::allocateCell<InternalFieldObject>(vm)) InternalFieldObject(vm, structure, objectTemplate->InternalFieldCount());
-    object->finishCreation(vm);
-    return object;
-}
-
-template<typename Visitor>
-void InternalFieldObject::visitChildrenImpl(JSCell* cell, Visitor& visitor)
-{
-    InternalFieldObject* thisObject = jsCast<InternalFieldObject*>(cell);
-    ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-    Base::visitChildren(thisObject, visitor);
-
-    for (auto& value : thisObject->fields) {
-        visitor.append(value);
-    }
-}
-
-DEFINE_VISIT_CHILDREN(InternalFieldObject);
-
-}
diff --git a/src/bun.js/bindings/v8/V8InternalFieldObject.h b/src/bun.js/bindings/v8/V8InternalFieldObject.h
deleted file mode 100644
index 6a118786bf..0000000000
--- a/src/bun.js/bindings/v8/V8InternalFieldObject.h
+++ /dev/null
@@ -1,46 +0,0 @@
-#pragma once
-
-#include "V8ObjectTemplate.h"
-
-namespace v8 {
-
-class InternalFieldObject : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-
-    DECLARE_INFO;
-
-    template<typename, JSC::SubspaceAccess mode>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<InternalFieldObject, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForInternalFieldObject.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForInternalFieldObject = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForInternalFieldObject.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForInternalFieldObject = std::forward<decltype(space)>(space); });
-    }
-
-    // never changes size
-    using FieldContainer = WTF::FixedVector<JSC::WriteBarrier<JSC::Unknown>>;
-
-    FieldContainer* internalFields() { return &fields; }
-    static InternalFieldObject* create(JSC::VM& vm, JSC::Structure* structure, Local<ObjectTemplate> objectTemplate);
-
-    DECLARE_VISIT_CHILDREN;
-
-protected:
-    InternalFieldObject(JSC::VM& vm, JSC::Structure* structure, int internalFieldCount)
-        : Base(vm, structure)
-        , fields(internalFieldCount, JSC::WriteBarrier<JSC::Unknown>(vm, this, JSC::jsUndefined()))
-    {
-    }
-
-private:
-    // TODO(@190n) use template with fixed size array for small counts
-    FieldContainer fields;
-};
-
-}
diff --git a/src/bun.js/bindings/v8/V8Isolate.cpp b/src/bun.js/bindings/v8/V8Isolate.cpp
index 7ddca0beee..f6385c53b9 100644
--- a/src/bun.js/bindings/v8/V8Isolate.cpp
+++ b/src/bun.js/bindings/v8/V8Isolate.cpp
@@ -1,6 +1,24 @@
 #include "V8Isolate.h"
 #include "V8HandleScope.h"
+#include "shim/GlobalInternals.h"
 #include "ZigGlobalObject.h"
+#include "real_v8.h"
+#include "v8_compatibility_assertions.h"
+
+static_assert(offsetof(v8::Isolate, m_roots) == real_v8::internal::Internals::kIsolateRootsOffset,
+    "Isolate roots array is at wrong offset");
+
+#define CHECK_ROOT_INDEX(NAME)                                                           \
+    static_assert(v8::Isolate::NAME == real_v8::internal::Internals::NAME,               \
+        "Isolate root index " #NAME " does not match between Bun and V8");               \
+    static_assert(v8::Isolate::NAME < std::tuple_size_v<decltype(v8::Isolate::m_roots)>, \
+        "Bun v8::Isolate roots array is too small for index " #NAME);
+
+CHECK_ROOT_INDEX(kUndefinedValueRootIndex)
+CHECK_ROOT_INDEX(kTheHoleValueRootIndex)
+CHECK_ROOT_INDEX(kNullValueRootIndex)
+CHECK_ROOT_INDEX(kTrueValueRootIndex)
+CHECK_ROOT_INDEX(kFalseValueRootIndex)
 
 namespace v8 {
 
@@ -9,7 +27,7 @@ Isolate* Isolate::TryGetCurrent()
 {
     auto* global = defaultGlobalObject();
 
-    return global ? reinterpret_cast<v8::Isolate*>(&global->V8GlobalInternals()->roots) : nullptr;
+    return global ? &global->V8GlobalInternals()->m_isolate : nullptr;
 }
 
 // Returns the isolate inside which the current thread is running.
@@ -17,12 +35,27 @@ Isolate* Isolate::GetCurrent()
 {
     auto* global = defaultGlobalObject();
 
-    return global ? reinterpret_cast<v8::Isolate*>(&global->V8GlobalInternals()->roots) : nullptr;
+    return global ? &global->V8GlobalInternals()->m_isolate : nullptr;
 }
 
 Local<Context> Isolate::GetCurrentContext()
 {
-    return currentHandleScope()->createRawLocal<Context>(this);
+    return currentHandleScope()->createLocal<Context>(m_globalObject->vm(), m_globalObject);
 }
 
+Isolate::Isolate(shim::GlobalInternals* globalInternals)
+    : m_globalInternals(globalInternals)
+    , m_globalObject(globalInternals->m_globalObject)
+{
+    m_roots[kUndefinedValueRootIndex] = TaggedPointer(&globalInternals->m_undefinedValue);
+    m_roots[kNullValueRootIndex] = TaggedPointer(&globalInternals->m_nullValue);
+    m_roots[kTrueValueRootIndex] = TaggedPointer(&globalInternals->m_trueValue);
+    m_roots[kFalseValueRootIndex] = TaggedPointer(&globalInternals->m_falseValue);
 }
+
+HandleScope* Isolate::currentHandleScope()
+{
+    return m_globalInternals->currentHandleScope();
+}
+
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8Isolate.h b/src/bun.js/bindings/v8/V8Isolate.h
index 4616c22060..de603e0690 100644
--- a/src/bun.js/bindings/v8/V8Isolate.h
+++ b/src/bun.js/bindings/v8/V8Isolate.h
@@ -1,20 +1,30 @@
 #pragma once
 
 #include "v8.h"
-#include "V8Context.h"
 #include "V8Local.h"
-#include "V8GlobalInternals.h"
 
 namespace v8 {
 
 class HandleScope;
+class Context;
 
-// This currently is just a pointer to a v8::Roots
-// We do that so that we can recover the context and the VM from the "Isolate," and so that inlined
-// V8 functions can find values at certain fixed offsets from the Isolate
+namespace shim {
+class GlobalInternals;
+}
+
+// The only fields here are "roots," which are the global locations of V8's versions of nullish and
+// boolean values. These are computed as offsets from an Isolate pointer in many V8 functions so
+// they need to have the correct layout.
 class Isolate final {
 public:
-    Isolate() = default;
+    // v8-internal.h:775
+    static constexpr int kUndefinedValueRootIndex = 4;
+    static constexpr int kTheHoleValueRootIndex = 5;
+    static constexpr int kNullValueRootIndex = 6;
+    static constexpr int kTrueValueRootIndex = 7;
+    static constexpr int kFalseValueRootIndex = 8;
+
+    Isolate(shim::GlobalInternals* globalInternals);
 
     // Returns the isolate inside which the current thread is running or nullptr.
     BUN_EXPORT static Isolate* TryGetCurrent();
@@ -24,11 +34,25 @@ public:
 
     BUN_EXPORT Local<Context> GetCurrentContext();
 
-    static Isolate* fromGlobalObject(Zig::GlobalObject* globalObject) { return reinterpret_cast<Isolate*>(&globalObject->V8GlobalInternals()->roots); }
-    Zig::GlobalObject* globalObject() { return reinterpret_cast<Roots*>(this)->parent->globalObject; }
+    Zig::GlobalObject* globalObject() { return m_globalObject; }
     JSC::VM& vm() { return globalObject()->vm(); }
-    GlobalInternals* globalInternals() { return globalObject()->V8GlobalInternals(); }
-    HandleScope* currentHandleScope() { return globalInternals()->currentHandleScope(); }
+    shim::GlobalInternals* globalInternals() { return m_globalInternals; }
+    HandleScope* currentHandleScope();
+
+    TaggedPointer* undefinedSlot() { return &m_roots[Isolate::kUndefinedValueRootIndex]; }
+
+    TaggedPointer* nullSlot() { return &m_roots[Isolate::kNullValueRootIndex]; }
+
+    TaggedPointer* trueSlot() { return &m_roots[Isolate::kTrueValueRootIndex]; }
+
+    TaggedPointer* falseSlot() { return &m_roots[Isolate::kFalseValueRootIndex]; }
+
+    shim::GlobalInternals* m_globalInternals;
+    Zig::GlobalObject* m_globalObject;
+
+    uintptr_t m_padding[72];
+
+    std::array<TaggedPointer, 9> m_roots;
 };
 
-}
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8Local.cpp b/src/bun.js/bindings/v8/V8Local.cpp
new file mode 100644
index 0000000000..a2360b17e0
--- /dev/null
+++ b/src/bun.js/bindings/v8/V8Local.cpp
@@ -0,0 +1,5 @@
+#include "V8Local.h"
+#include "V8Data.h"
+#include "v8_compatibility_assertions.h"
+
+ASSERT_V8_TYPE_LAYOUT_MATCHES(v8::Local<v8::Data>)
diff --git a/src/bun.js/bindings/v8/V8Local.h b/src/bun.js/bindings/v8/V8Local.h
index a2f23ec1b4..24bdfaafa1 100644
--- a/src/bun.js/bindings/v8/V8Local.h
+++ b/src/bun.js/bindings/v8/V8Local.h
@@ -2,7 +2,7 @@
 
 #include "root.h"
 
-#include "V8TaggedPointer.h"
+#include "shim/TaggedPointer.h"
 
 namespace v8 {
 
@@ -10,33 +10,33 @@ template<class T>
 class Local final {
 public:
     Local()
-        : location(nullptr)
+        : m_location(nullptr)
     {
     }
 
     Local(TaggedPointer* slot)
-        : location(slot)
+        : m_location(slot)
     {
     }
 
-    bool IsEmpty() const { return location == nullptr; }
+    bool IsEmpty() const { return m_location == nullptr; }
 
-    T* operator*() const { return reinterpret_cast<T*>(location); }
-    T* operator->() const { return reinterpret_cast<T*>(location); }
+    T* operator*() const { return reinterpret_cast<T*>(m_location); }
+    T* operator->() const { return reinterpret_cast<T*>(m_location); }
 
     template<class U>
     Local<U> reinterpret() const
     {
-        return Local<U>(location);
+        return Local<U>(m_location);
     }
 
     TaggedPointer tagged() const
     {
-        return *location;
+        return *m_location;
     }
 
 private:
-    TaggedPointer* location;
+    TaggedPointer* m_location;
 };
 
-}
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8Map.cpp b/src/bun.js/bindings/v8/V8Map.cpp
deleted file mode 100644
index 300c242958..0000000000
--- a/src/bun.js/bindings/v8/V8Map.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "V8Map.h"
-
-namespace v8 {
-
-// TODO give these more appropriate instance types
-const Map Map::map_map(InstanceType::Object);
-const Map Map::object_map(InstanceType::Object);
-const Map Map::raw_ptr_map(InstanceType::Object);
-const Map Map::oddball_map(InstanceType::Oddball);
-const Map Map::boolean_map(InstanceType::Oddball);
-const Map Map::string_map(InstanceType::String);
-const Map Map::heap_number_map(InstanceType::HeapNumber);
-
-}
diff --git a/src/bun.js/bindings/v8/V8Map.h b/src/bun.js/bindings/v8/V8Map.h
deleted file mode 100644
index 4448c235aa..0000000000
--- a/src/bun.js/bindings/v8/V8Map.h
+++ /dev/null
@@ -1,60 +0,0 @@
-#pragma once
-
-#include "V8TaggedPointer.h"
-
-namespace v8 {
-
-enum class InstanceType : uint16_t {
-    // v8-internal.h:787, kFirstNonstringType is 0x80
-    String = 0x7f,
-    // "Oddball" in V8 means undefined or null
-    // v8-internal.h:788
-    Oddball = 0x83,
-    // v8-internal.h:1016 kFirstNonstringType
-    // this cannot be kJSObjectType (or anything in the range [kJSObjectType, kLastJSApiObjectType])
-    // because then V8 will try to access internal fields directly instead of calling
-    // SlowGetInternalField
-    Object = 0x80,
-    // a number that doesn't fit in int32_t and is stored on the heap (for us, in the
-    // HandleScopeBuffer)
-    HeapNumber = 0x82,
-};
-
-// V8's description of the structure of an object
-struct Map {
-    // the structure of the map itself (always points to map_map)
-    TaggedPointer meta_map;
-    // TBD whether we need to put anything here to please inlined V8 functions
-    uint32_t unused;
-    // describes which kind of object this is. we shouldn't actually need to create very many
-    // instance types -- only ones for primitives, and one to make sure V8 thinks it cannot take the
-    // fast path when accessing internal fields
-    // (v8::internal::Internals::CanHaveInternalField, in v8-internal.h)
-    InstanceType instance_type;
-
-    // the map used by maps
-    static const Map map_map;
-    // the map used by objects inheriting JSCell
-    static const Map object_map;
-    // the map used by pointers to non-JSCell objects stored in handles
-    static const Map raw_ptr_map;
-    // the map used by oddballs (null, undefined)
-    static const Map oddball_map;
-    // the map used by booleans
-    static const Map boolean_map;
-    // the map used by strings
-    static const Map string_map;
-    // the map used by heap numbers
-    static const Map heap_number_map;
-
-    Map(InstanceType instance_type_)
-        : meta_map(const_cast<Map*>(&map_map))
-        , unused(0xaaaaaaaa)
-        , instance_type(instance_type_)
-    {
-    }
-};
-
-static_assert(sizeof(Map) == 16, "Map has wrong layout");
-
-}
diff --git a/src/bun.js/bindings/v8/V8Maybe.cpp b/src/bun.js/bindings/v8/V8Maybe.cpp
new file mode 100644
index 0000000000..ff06921249
--- /dev/null
+++ b/src/bun.js/bindings/v8/V8Maybe.cpp
@@ -0,0 +1,6 @@
+#include "V8Maybe.h"
+#include "v8_compatibility_assertions.h"
+
+ASSERT_V8_TYPE_LAYOUT_MATCHES(v8::Maybe<int>)
+ASSERT_V8_TYPE_FIELD_OFFSET_MATCHES(v8::Maybe<int>, m_hasValue, has_value_)
+ASSERT_V8_TYPE_FIELD_OFFSET_MATCHES(v8::Maybe<int>, m_value, value_)
diff --git a/src/bun.js/bindings/v8/V8Maybe.h b/src/bun.js/bindings/v8/V8Maybe.h
index 6ad41688ad..5e71a25027 100644
--- a/src/bun.js/bindings/v8/V8Maybe.h
+++ b/src/bun.js/bindings/v8/V8Maybe.h
@@ -6,16 +6,16 @@ template<class T>
 class Maybe {
 public:
     Maybe()
-        : has_value(false)
+        : m_hasValue(false)
     {
     }
     explicit Maybe(const T& t)
-        : has_value(true)
-        , value(t)
+        : m_hasValue(true)
+        , m_value(t)
     {
     }
-    bool has_value;
-    T value;
+    bool m_hasValue;
+    T m_value;
 };
 
 template<class T>
@@ -30,4 +30,4 @@ inline Maybe<T> Just(const T& t)
     return Maybe<T>(t);
 }
 
-}
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8MaybeLocal.h b/src/bun.js/bindings/v8/V8MaybeLocal.h
index f53a6feedb..13b71acee2 100644
--- a/src/bun.js/bindings/v8/V8MaybeLocal.h
+++ b/src/bun.js/bindings/v8/V8MaybeLocal.h
@@ -8,17 +8,17 @@ template<class T>
 class MaybeLocal {
 public:
     MaybeLocal()
-        : local_(Local<T>()) {};
+        : m_local(Local<T>()) {};
 
     template<class S> MaybeLocal(Local<S> that)
-        : local_(that)
+        : m_local(that)
     {
     }
 
-    bool IsEmpty() const { return local_.IsEmpty(); }
+    bool IsEmpty() const { return m_local.IsEmpty(); }
 
 private:
-    Local<T> local_;
+    Local<T> m_local;
 };
 
-}
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8Number.cpp b/src/bun.js/bindings/v8/V8Number.cpp
index 31c6744f2f..c870d1ef38 100644
--- a/src/bun.js/bindings/v8/V8Number.cpp
+++ b/src/bun.js/bindings/v8/V8Number.cpp
@@ -1,5 +1,8 @@
 #include "V8Number.h"
 #include "V8HandleScope.h"
+#include "v8_compatibility_assertions.h"
+
+ASSERT_V8_TYPE_LAYOUT_MATCHES(v8::Number)
 
 namespace v8 {
 
@@ -10,7 +13,7 @@ Local<Number> Number::New(Isolate* isolate, double value)
 
 double Number::Value() const
 {
-    return localToJSValue(Isolate::GetCurrent()->globalInternals()).asNumber();
+    return localToJSValue().asNumber();
 }
 
-}
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8Number.h b/src/bun.js/bindings/v8/V8Number.h
index 7ec8e6d54c..e85c3ae5ec 100644
--- a/src/bun.js/bindings/v8/V8Number.h
+++ b/src/bun.js/bindings/v8/V8Number.h
@@ -14,4 +14,4 @@ public:
     BUN_EXPORT double Value() const;
 };
 
-}
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8Object.cpp b/src/bun.js/bindings/v8/V8Object.cpp
index cb6d5215ea..e69031ec2d 100644
--- a/src/bun.js/bindings/v8/V8Object.cpp
+++ b/src/bun.js/bindings/v8/V8Object.cpp
@@ -1,9 +1,11 @@
 #include "V8Object.h"
-#include "V8InternalFieldObject.h"
+#include "shim/InternalFieldObject.h"
 #include "V8HandleScope.h"
-
 #include "JavaScriptCore/ConstructData.h"
 #include "JavaScriptCore/ObjectConstructor.h"
+#include "v8_compatibility_assertions.h"
+
+ASSERT_V8_TYPE_LAYOUT_MATCHES(v8::Object)
 
 using JSC::Identifier;
 using JSC::JSFinalObject;
@@ -14,7 +16,7 @@ using JSC::PutPropertySlot;
 
 namespace v8 {
 
-using FieldContainer = InternalFieldObject::FieldContainer;
+using FieldContainer = shim::InternalFieldObject::FieldContainer;
 
 static FieldContainer* getInternalFieldsContainer(Object* object)
 {
@@ -22,7 +24,7 @@ static FieldContainer* getInternalFieldsContainer(Object* object)
 
     // TODO(@190n): do we need to unwrap proxies like node-jsc did?
 
-    if (auto ifo = JSC::jsDynamicCast<InternalFieldObject*>(js_object)) {
+    if (auto ifo = JSC::jsDynamicCast<shim::InternalFieldObject*>(js_object)) {
         return ifo->internalFields();
     }
 
@@ -39,8 +41,8 @@ Maybe<bool> Object::Set(Local<Context> context, Local<Value> key, Local<Value> v
 {
     Zig::GlobalObject* globalObject = context->globalObject();
     JSObject* object = localToObjectPointer<JSObject>();
-    JSValue k = key->localToJSValue(globalObject->V8GlobalInternals());
-    JSValue v = value->localToJSValue(globalObject->V8GlobalInternals());
+    JSValue k = key->localToJSValue();
+    JSValue v = value->localToJSValue();
     auto& vm = globalObject->vm();
 
     auto scope = DECLARE_CATCH_SCOPE(vm);
@@ -67,7 +69,7 @@ void Object::SetInternalField(int index, Local<Data> data)
     RELEASE_ASSERT(index >= 0 && index < fields->size(), "internal field index is out of bounds");
     JSObject* js_object = localToObjectPointer<JSObject>();
     auto* globalObject = JSC::jsDynamicCast<Zig::GlobalObject*>(js_object->globalObject());
-    fields->at(index).set(globalObject->vm(), localToCell(), data->localToJSValue(globalObject->V8GlobalInternals()));
+    fields->at(index).set(globalObject->vm(), localToCell(), data->localToJSValue());
 }
 
 Local<Data> Object::GetInternalField(int index)
@@ -80,7 +82,7 @@ Local<Data> Object::SlowGetInternalField(int index)
     auto* fields = getInternalFieldsContainer(this);
     JSObject* js_object = localToObjectPointer<JSObject>();
     auto* globalObject = JSC::jsDynamicCast<Zig::GlobalObject*>(js_object->globalObject());
-    HandleScope* handleScope = Isolate::fromGlobalObject(globalObject)->currentHandleScope();
+    HandleScope* handleScope = globalObject->V8GlobalInternals()->currentHandleScope();
     if (fields && index >= 0 && index < fields->size()) {
         auto& field = fields->at(index);
         return handleScope->createLocal<Data>(globalObject->vm(), field.get());
@@ -88,4 +90,4 @@ Local<Data> Object::SlowGetInternalField(int index)
     return handleScope->createLocal<Data>(globalObject->vm(), JSC::jsUndefined());
 }
 
-}
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8Object.h b/src/bun.js/bindings/v8/V8Object.h
index 6c74b0f035..9351f44220 100644
--- a/src/bun.js/bindings/v8/V8Object.h
+++ b/src/bun.js/bindings/v8/V8Object.h
@@ -22,4 +22,4 @@ private:
     BUN_EXPORT Local<Data> SlowGetInternalField(int index);
 };
 
-}
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8ObjectTemplate.cpp b/src/bun.js/bindings/v8/V8ObjectTemplate.cpp
index 07b32031f1..3eb5b5c7a5 100644
--- a/src/bun.js/bindings/v8/V8ObjectTemplate.cpp
+++ b/src/bun.js/bindings/v8/V8ObjectTemplate.cpp
@@ -1,53 +1,22 @@
 #include "V8ObjectTemplate.h"
-#include "V8InternalFieldObject.h"
-#include "V8GlobalInternals.h"
+#include "shim/InternalFieldObject.h"
+#include "shim/GlobalInternals.h"
 #include "V8HandleScope.h"
+#include "v8_compatibility_assertions.h"
 
-#include "JavaScriptCore/FunctionPrototype.h"
-#include "JavaScriptCore/LazyPropertyInlines.h"
-#include "JavaScriptCore/VMTrapsInlines.h"
-
-using JSC::JSGlobalObject;
-using JSC::JSValue;
-using JSC::LazyProperty;
-using JSC::Structure;
+ASSERT_V8_TYPE_LAYOUT_MATCHES(v8::Object)
 
 namespace v8 {
 
-void ObjectTemplate::finishCreation(JSC::VM& vm)
-{
-    Base::finishCreation(vm);
-    __internals.objectStructure.initLater([](const LazyProperty<ObjectTemplate, Structure>::Initializer& init) {
-        init.set(JSC::Structure::create(
-            init.vm,
-            init.owner->globalObject(),
-            init.owner->globalObject()->objectPrototype(),
-            JSC::TypeInfo(JSC::ObjectType, InternalFieldObject::StructureFlags),
-            InternalFieldObject::info()));
-    });
-}
-
-// for CREATE_METHOD_TABLE
-namespace JSCastingHelpers = JSC::JSCastingHelpers;
-
-const JSC::ClassInfo ObjectTemplate::s_info = {
-    "ObjectTemplate"_s,
-    &Base::s_info,
-    nullptr,
-    nullptr,
-    CREATE_METHOD_TABLE(ObjectTemplate)
-};
-
 Local<ObjectTemplate> ObjectTemplate::New(Isolate* isolate, Local<FunctionTemplate> constructor)
 {
     RELEASE_ASSERT(constructor.IsEmpty());
     auto* globalObject = isolate->globalObject();
     auto& vm = globalObject->vm();
     auto* globalInternals = globalObject->V8GlobalInternals();
-    Structure* structure = globalInternals->objectTemplateStructure(globalObject);
-    auto* objectTemplate = new (NotNull, JSC::allocateCell<ObjectTemplate>(vm)) ObjectTemplate(vm, structure);
+    auto* structure = globalInternals->objectTemplateStructure(globalObject);
     // TODO pass constructor
-    objectTemplate->finishCreation(vm);
+    auto* objectTemplate = shim::ObjectTemplate::create(vm, structure);
     return globalInternals->currentHandleScope()->createLocal<ObjectTemplate>(vm, objectTemplate);
 }
 
@@ -57,52 +26,19 @@ MaybeLocal<Object> ObjectTemplate::NewInstance(Local<Context> context)
     // TODO handle interceptors?
 
     auto& vm = context->vm();
-    auto thisObj = localToObjectPointer();
-
-    // get a structure
-    // must take thisObj because JSC needs the native pointer
-    auto structure = internals().objectStructure.get(thisObj);
-
-    // create object from it
-    // InternalFieldObject needs a Local<ObjectTemplate>, which we can create using the `this`
-    // pointer as we know this method itself was called through a Local
-    auto newInstance = InternalFieldObject::create(vm, structure, Local<ObjectTemplate>(reinterpret_cast<TaggedPointer*>(this)));
-
-    // todo: apply properties
-
+    auto* thisObj = localToObjectPointer();
+    auto* newInstance = thisObj->newInstance();
     return MaybeLocal<Object>(context->currentHandleScope()->createLocal<Object>(vm, newInstance));
 }
 
-template<typename Visitor>
-void ObjectTemplate::visitChildrenImpl(JSCell* cell, Visitor& visitor)
-{
-    ObjectTemplate* fn = jsCast<ObjectTemplate*>(cell);
-    ASSERT_GC_OBJECT_INHERITS(fn, info());
-    Base::visitChildren(fn, visitor);
-
-    fn->__internals.objectStructure.visit(visitor);
-}
-
-DEFINE_VISIT_CHILDREN(ObjectTemplate);
-
 void ObjectTemplate::SetInternalFieldCount(int value)
 {
-    internals().internalFieldCount = value;
+    localToObjectPointer()->setInternalFieldCount(value);
 }
 
 int ObjectTemplate::InternalFieldCount() const
 {
-    return internals().internalFieldCount;
+    return localToObjectPointer()->internalFieldCount();
 }
 
-Structure* ObjectTemplate::createStructure(JSC::VM& vm, JSGlobalObject* globalObject, JSValue prototype)
-{
-    return Structure::create(
-        vm,
-        globalObject,
-        prototype,
-        JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags),
-        info());
-}
-
-}
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8ObjectTemplate.h b/src/bun.js/bindings/v8/V8ObjectTemplate.h
index b8d92118f7..0775df72a9 100644
--- a/src/bun.js/bindings/v8/V8ObjectTemplate.h
+++ b/src/bun.js/bindings/v8/V8ObjectTemplate.h
@@ -1,6 +1,5 @@
 #pragma once
 
-#include "JavaScriptCore/SubspaceAccess.h"
 #include "v8.h"
 #include "V8Context.h"
 #include "V8Local.h"
@@ -9,75 +8,27 @@
 #include "V8MaybeLocal.h"
 #include "V8Object.h"
 #include "V8Template.h"
+#include "shim/ObjectTemplate.h"
 
 namespace v8 {
 
-// If this inherited Template like it does in V8, the layout would be wrong for JSC HeapCell.
-// Inheritance shouldn't matter for the ABI.
-class ObjectTemplate : public JSC::InternalFunction {
+class ObjectTemplate : public Template {
 public:
-    using Base = JSC::InternalFunction;
-
-    DECLARE_INFO;
-
     BUN_EXPORT static Local<ObjectTemplate> New(Isolate* isolate, Local<FunctionTemplate> constructor = Local<FunctionTemplate>());
     BUN_EXPORT MaybeLocal<Object> NewInstance(Local<Context> context);
     BUN_EXPORT void SetInternalFieldCount(int value);
     BUN_EXPORT int InternalFieldCount() const;
 
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype);
-
-    template<typename, JSC::SubspaceAccess mode>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<ObjectTemplate, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForObjectTemplate.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForObjectTemplate = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForObjectTemplate.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForObjectTemplate = std::forward<decltype(space)>(space); });
-    }
-
-    DECLARE_VISIT_CHILDREN;
-
 private:
-    class Internals {
-        int internalFieldCount = 0;
-        JSC::LazyProperty<ObjectTemplate, JSC::Structure> objectStructure;
-        friend class ObjectTemplate;
-    };
-
-    // do not use directly inside exported V8 functions, use internals()
-    Internals __internals;
-
-    ObjectTemplate* localToObjectPointer()
+    shim::ObjectTemplate* localToObjectPointer()
     {
-        return reinterpret_cast<Data*>(this)->localToObjectPointer<ObjectTemplate>();
+        return Data::localToObjectPointer<shim::ObjectTemplate>();
     }
 
-    const ObjectTemplate* localToObjectPointer() const
+    const shim::ObjectTemplate* localToObjectPointer() const
     {
-        return reinterpret_cast<const Data*>(this)->localToObjectPointer<ObjectTemplate>();
+        return Data::localToObjectPointer<shim::ObjectTemplate>();
     }
-
-    Internals& internals()
-    {
-        return localToObjectPointer()->__internals;
-    }
-
-    const Internals& internals() const
-    {
-        return localToObjectPointer()->__internals;
-    }
-
-    ObjectTemplate(JSC::VM& vm, JSC::Structure* structure)
-        : Base(vm, structure, Template::DummyCallback, Template::DummyCallback)
-    {
-    }
-
-    void finishCreation(JSC::VM& vm);
 };
 
-}
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8Oddball.h b/src/bun.js/bindings/v8/V8Oddball.h
deleted file mode 100644
index c58f40c149..0000000000
--- a/src/bun.js/bindings/v8/V8Oddball.h
+++ /dev/null
@@ -1,28 +0,0 @@
-#pragma once
-
-#include "V8TaggedPointer.h"
-#include "V8Map.h"
-
-namespace v8 {
-
-struct Oddball {
-    enum class Kind : int {
-        kUndefined = 4,
-        kNull = 3,
-        kInvalid = 255,
-        kTrue = 1,
-        kFalse = 0,
-    };
-
-    TaggedPointer map;
-    uintptr_t unused[4];
-    TaggedPointer kind;
-
-    Oddball(Kind kind_, const Map* map_ = &Map::oddball_map)
-        : map(const_cast<Map*>(map_))
-        , kind(TaggedPointer(static_cast<int>(kind_)))
-    {
-    }
-};
-
-}
diff --git a/src/bun.js/bindings/v8/V8Primitive.h b/src/bun.js/bindings/v8/V8Primitive.h
index afb9565fe6..57791bac71 100644
--- a/src/bun.js/bindings/v8/V8Primitive.h
+++ b/src/bun.js/bindings/v8/V8Primitive.h
@@ -6,4 +6,4 @@ namespace v8 {
 
 class Primitive : public Value {};
 
-}
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8Roots.cpp b/src/bun.js/bindings/v8/V8Roots.cpp
deleted file mode 100644
index 025f68a714..0000000000
--- a/src/bun.js/bindings/v8/V8Roots.cpp
+++ /dev/null
@@ -1,15 +0,0 @@
-#include "V8Roots.h"
-#include "V8GlobalInternals.h"
-
-namespace v8 {
-
-Roots::Roots(GlobalInternals* parent_)
-    : parent(parent_)
-{
-    roots[kUndefinedValueRootIndex] = TaggedPointer(&parent->undefinedValue);
-    roots[kNullValueRootIndex] = TaggedPointer(&parent->nullValue);
-    roots[kTrueValueRootIndex] = TaggedPointer(&parent->trueValue);
-    roots[kFalseValueRootIndex] = TaggedPointer(&parent->falseValue);
-}
-
-}
diff --git a/src/bun.js/bindings/v8/V8Roots.h b/src/bun.js/bindings/v8/V8Roots.h
deleted file mode 100644
index 1a538388e4..0000000000
--- a/src/bun.js/bindings/v8/V8Roots.h
+++ /dev/null
@@ -1,32 +0,0 @@
-#pragma once
-
-#include "V8TaggedPointer.h"
-
-namespace v8 {
-
-class GlobalInternals;
-
-// Container for some data that V8 expects to find at certain offsets. Isolate and Context pointers
-// actually point to this object. It is a separate struct so that we can use offsetof() to make sure
-// the layout is correct.
-struct Roots {
-    // v8-internal.h:775
-    static const int kUndefinedValueRootIndex = 4;
-    static const int kTheHoleValueRootIndex = 5;
-    static const int kNullValueRootIndex = 6;
-    static const int kTrueValueRootIndex = 7;
-    static const int kFalseValueRootIndex = 8;
-
-    GlobalInternals* parent;
-
-    uintptr_t padding[73];
-
-    TaggedPointer roots[9];
-
-    Roots(GlobalInternals* parent);
-};
-
-// kIsolateRootsOffset at v8-internal.h:744
-static_assert(offsetof(Roots, roots) == 592, "Roots does not match V8 layout");
-
-}
diff --git a/src/bun.js/bindings/v8/V8Signature.h b/src/bun.js/bindings/v8/V8Signature.h
index 9138775653..61775b1b11 100644
--- a/src/bun.js/bindings/v8/V8Signature.h
+++ b/src/bun.js/bindings/v8/V8Signature.h
@@ -6,4 +6,4 @@ namespace v8 {
 
 class Signature : public Data {};
 
-}
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8String.cpp b/src/bun.js/bindings/v8/V8String.cpp
index 7e6d9965d9..fc792cc7e4 100644
--- a/src/bun.js/bindings/v8/V8String.cpp
+++ b/src/bun.js/bindings/v8/V8String.cpp
@@ -1,7 +1,18 @@
 #include "V8String.h"
-
 #include "V8HandleScope.h"
 #include "wtf/SIMDUTF.h"
+#include "v8_compatibility_assertions.h"
+
+ASSERT_V8_TYPE_LAYOUT_MATCHES(v8::String)
+
+ASSERT_V8_ENUM_MATCHES(NewStringType, kNormal)
+ASSERT_V8_ENUM_MATCHES(NewStringType, kInternalized)
+
+ASSERT_V8_ENUM_MATCHES(String::WriteOptions, NO_OPTIONS)
+ASSERT_V8_ENUM_MATCHES(String::WriteOptions, HINT_MANY_WRITES_EXPECTED)
+ASSERT_V8_ENUM_MATCHES(String::WriteOptions, NO_NULL_TERMINATION)
+ASSERT_V8_ENUM_MATCHES(String::WriteOptions, PRESERVE_ONE_BYTE_NULL)
+ASSERT_V8_ENUM_MATCHES(String::WriteOptions, REPLACE_INVALID_UTF8)
 
 using JSC::JSString;
 
@@ -9,8 +20,6 @@ namespace v8 {
 
 MaybeLocal<String> String::NewFromUtf8(Isolate* isolate, char const* data, NewStringType type, int signed_length)
 {
-    // TODO(@190n) maybe use JSC::AtomString instead of ignoring type
-    (void)type;
     size_t length = 0;
     if (signed_length < 0) {
         length = strlen(data);
@@ -25,15 +34,26 @@ MaybeLocal<String> String::NewFromUtf8(Isolate* isolate, char const* data, NewSt
 
     auto& vm = isolate->vm();
     std::span<const unsigned char> span(reinterpret_cast<const unsigned char*>(data), length);
+    JSString* jsString = nullptr;
     // ReplacingInvalidSequences matches how v8 behaves here
     auto string = WTF::String::fromUTF8ReplacingInvalidSequences(span);
-    JSString* jsString = JSC::jsString(vm, string);
+    switch (type) {
+    case NewStringType::kNormal:
+        jsString = JSC::jsString(vm, string);
+        break;
+
+    case NewStringType::kInternalized:
+        // don't create AtomString directly from the characters, as that gives an empty string
+        // instead of replacing invalid UTF-8 sequences
+        WTF::AtomString atom_string(string);
+        jsString = JSC::jsString(vm, atom_string);
+        break;
+    }
     return MaybeLocal<String>(isolate->currentHandleScope()->createLocal<String>(vm, jsString));
 }
 
 MaybeLocal<String> String::NewFromOneByte(Isolate* isolate, const uint8_t* data, NewStringType type, int signed_length)
 {
-    (void)type;
     size_t length = 0;
     if (signed_length < 0) {
         length = strlen(reinterpret_cast<const char*>(data));
@@ -48,8 +68,19 @@ MaybeLocal<String> String::NewFromOneByte(Isolate* isolate, const uint8_t* data,
 
     auto& vm = isolate->vm();
     std::span<const unsigned char> span(data, length);
-    WTF::String string(span);
-    JSString* jsString = JSC::jsString(vm, string);
+    JSString* jsString = nullptr;
+    switch (type) {
+    case NewStringType::kNormal: {
+        WTF::String string(span);
+        jsString = JSC::jsString(vm, string);
+        break;
+    }
+    case NewStringType::kInternalized: {
+        WTF::AtomString atom_string(span);
+        jsString = JSC::jsString(vm, atom_string);
+        break;
+    }
+    }
     return MaybeLocal<String>(isolate->currentHandleScope()->createLocal<String>(vm, jsString));
 }
 
@@ -164,4 +195,4 @@ int String::Length() const
     return static_cast<int>(jsString->length());
 }
 
-}
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8String.h b/src/bun.js/bindings/v8/V8String.h
index 4ec76762c7..6c0ff9eed6 100644
--- a/src/bun.js/bindings/v8/V8String.h
+++ b/src/bun.js/bindings/v8/V8String.h
@@ -76,4 +76,4 @@ public:
     }
 };
 
-}
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8TaggedPointer.h b/src/bun.js/bindings/v8/V8TaggedPointer.h
deleted file mode 100644
index 910adb2845..0000000000
--- a/src/bun.js/bindings/v8/V8TaggedPointer.h
+++ /dev/null
@@ -1,92 +0,0 @@
-#pragma once
-
-#include "v8.h"
-
-namespace v8 {
-
-struct TaggedPointer {
-    uintptr_t value;
-
-    enum class Type : uint8_t {
-        Smi,
-        StrongPointer,
-        WeakPointer,
-    };
-
-    TaggedPointer()
-        : TaggedPointer(nullptr) {};
-    TaggedPointer(const TaggedPointer&) = default;
-    TaggedPointer& operator=(const TaggedPointer&) = default;
-    bool operator==(const TaggedPointer& other) const { return value == other.value; }
-
-    TaggedPointer(void* ptr, bool weak)
-        : value(reinterpret_cast<uintptr_t>(ptr) | (weak ? 3 : 1))
-    {
-        RELEASE_ASSERT((reinterpret_cast<uintptr_t>(ptr) & 3) == 0);
-    }
-
-    TaggedPointer(void* ptr)
-        : TaggedPointer(ptr, false)
-    {
-    }
-
-    TaggedPointer(int32_t smi)
-        : value(static_cast<uintptr_t>(smi) << 32)
-    {
-    }
-
-    static TaggedPointer fromRaw(uintptr_t raw)
-    {
-        TaggedPointer tagged;
-        tagged.value = raw;
-        return tagged;
-    }
-
-    Type type() const
-    {
-        switch (value & 3) {
-        case 0:
-            return Type::Smi;
-        case 1:
-            return Type::StrongPointer;
-        case 3:
-            return Type::WeakPointer;
-        default:
-            RELEASE_ASSERT_NOT_REACHED();
-        }
-    }
-
-    template<typename T = JSC::JSCell> T* getPtr() const
-    {
-        if (type() == Type::Smi) {
-            return nullptr;
-        }
-        return reinterpret_cast<T*>(value & ~3ull);
-    }
-
-    bool getSmi(int32_t& smi) const
-    {
-        if (type() != Type::Smi) {
-            return false;
-        }
-        smi = static_cast<int32_t>(value >> 32);
-        return true;
-    }
-
-    int32_t getSmiUnchecked() const
-    {
-        ASSERT(type() == Type::Smi);
-        return static_cast<int32_t>(value >> 32);
-    }
-
-    JSC::JSValue getJSValue() const
-    {
-        int32_t smi;
-        if (getSmi(smi)) {
-            return JSC::jsNumber(smi);
-        }
-        return getPtr();
-    }
-};
-
-}
diff --git a/src/bun.js/bindings/v8/V8Template.cpp b/src/bun.js/bindings/v8/V8Template.cpp
index 5993d74d41..3d269fdfa5 100644
--- a/src/bun.js/bindings/v8/V8Template.cpp
+++ b/src/bun.js/bindings/v8/V8Template.cpp
@@ -1,4 +1,7 @@
 #include "V8Template.h"
+#include "v8_compatibility_assertions.h"
+
+ASSERT_V8_TYPE_LAYOUT_MATCHES(v8::Template)
 
 namespace v8 {
 
@@ -8,4 +11,4 @@ JSC::EncodedJSValue Template::DummyCallback(JSC::JSGlobalObject* globalObject, J
     return JSC::JSValue::encode(JSC::jsUndefined());
 }
 
-}
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8Template.h b/src/bun.js/bindings/v8/V8Template.h
index d6cbdbc66f..d6aeb7d90f 100644
--- a/src/bun.js/bindings/v8/V8Template.h
+++ b/src/bun.js/bindings/v8/V8Template.h
@@ -10,4 +10,4 @@ public:
     static JSC_HOST_CALL_ATTRIBUTES JSC::EncodedJSValue DummyCallback(JSC::JSGlobalObject* globalObject, JSC::CallFrame* callFrame);
 };
 
-}
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8Value.cpp b/src/bun.js/bindings/v8/V8Value.cpp
index f0dcdf0d7c..68499be9b5 100644
--- a/src/bun.js/bindings/v8/V8Value.cpp
+++ b/src/bun.js/bindings/v8/V8Value.cpp
@@ -1,41 +1,44 @@
 #include "V8Value.h"
 #include "V8Isolate.h"
+#include "v8_compatibility_assertions.h"
+
+ASSERT_V8_TYPE_LAYOUT_MATCHES(v8::Value)
 
 namespace v8 {
 
 bool Value::IsBoolean() const
 {
-    return localToJSValue(Isolate::GetCurrent()->globalInternals()).isBoolean();
+    return localToJSValue().isBoolean();
 }
 
 bool Value::IsObject() const
 {
-    return localToJSValue(Isolate::GetCurrent()->globalInternals()).isObject();
+    return localToJSValue().isObject();
 }
 
 bool Value::IsNumber() const
 {
-    return localToJSValue(Isolate::GetCurrent()->globalInternals()).isNumber();
+    return localToJSValue().isNumber();
 }
 
 bool Value::IsUint32() const
 {
-    return localToJSValue(Isolate::GetCurrent()->globalInternals()).isUInt32();
+    return localToJSValue().isUInt32();
 }
 
 bool Value::IsUndefined() const
 {
-    return localToJSValue(Isolate::GetCurrent()->globalInternals()).isUndefined();
+    return localToJSValue().isUndefined();
 }
 
 bool Value::IsNull() const
 {
-    return localToJSValue(Isolate::GetCurrent()->globalInternals()).isNull();
+    return localToJSValue().isNull();
 }
 
 bool Value::IsNullOrUndefined() const
 {
-    return localToJSValue(Isolate::GetCurrent()->globalInternals()).isUndefinedOrNull();
+    return localToJSValue().isUndefinedOrNull();
 }
 
 bool Value::IsTrue() const
@@ -50,12 +53,17 @@ bool Value::IsFalse() const
 
 bool Value::IsString() const
 {
-    return localToJSValue(Isolate::GetCurrent()->globalInternals()).isString();
+    return localToJSValue().isString();
+}
+
+bool Value::IsFunction() const
+{
+    return JSC::jsTypeofIsFunction(defaultGlobalObject(), localToJSValue());
 }
 
 Maybe<uint32_t> Value::Uint32Value(Local<Context> context) const
 {
-    auto js_value = localToJSValue(context->globalObject()->V8GlobalInternals());
+    auto js_value = localToJSValue();
     uint32_t value;
     if (js_value.getUInt32(value)) {
         return Just(value);
@@ -65,12 +73,12 @@ Maybe<uint32_t> Value::Uint32Value(Local<Context> context) const
 
 bool Value::FullIsTrue() const
 {
-    return localToJSValue(Isolate::GetCurrent()->globalInternals()).isTrue();
+    return localToJSValue().isTrue();
 }
 
 bool Value::FullIsFalse() const
 {
-    return localToJSValue(Isolate::GetCurrent()->globalInternals()).isFalse();
+    return localToJSValue().isFalse();
 }
 
-}
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/V8Value.h b/src/bun.js/bindings/v8/V8Value.h
index fe3b7c9f7e..9cf7a1b86c 100644
--- a/src/bun.js/bindings/v8/V8Value.h
+++ b/src/bun.js/bindings/v8/V8Value.h
@@ -13,6 +13,7 @@ public:
     BUN_EXPORT bool IsObject() const;
     BUN_EXPORT bool IsNumber() const;
     BUN_EXPORT bool IsUint32() const;
+    BUN_EXPORT bool IsFunction() const;
     BUN_EXPORT Maybe<uint32_t> Uint32Value(Local<Context> context) const;
 
     // usually inlined:
@@ -29,4 +30,4 @@ private:
     BUN_EXPORT bool FullIsFalse() const;
 };
 
-}
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/node.cpp b/src/bun.js/bindings/v8/node.cpp
index f8a5d23ae4..f9e8f84f8d 100644
--- a/src/bun.js/bindings/v8/node.cpp
+++ b/src/bun.js/bindings/v8/node.cpp
@@ -3,7 +3,11 @@
 
 #include "JavaScriptCore/ObjectConstructor.h"
 #include "CommonJSModuleRecord.h"
-#include <charconv>
+
+#include "node/node_version.h"
+
+static_assert(REPORTED_NODEJS_ABI_VERSION == NODE_MODULE_VERSION,
+    "Bun's Node.js ABI version is not the same as in the reported version of Node.js");
 
 using v8::Context;
 using v8::HandleScope;
@@ -38,14 +42,6 @@ void node_module_register(void* opaque_mod)
     auto* globalObject = defaultGlobalObject();
     auto& vm = globalObject->vm();
     auto* mod = reinterpret_cast<struct node_module*>(opaque_mod);
-    // Error: The module '/Users/ben/code/bun/test/v8/v8-module/build/Release/v8tests.node'
-    // was compiled against a different Node.js version using
-    // NODE_MODULE_VERSION 127. This version of Node.js requires
-    // NODE_MODULE_VERSION 108. Please try re-compiling or re-installing
-    // the module (for instance, using `npm rebuild` or `npm install`).
-
-    if (mod->nm_version != REPORTED_NODEJS_ABI_VERSION) {
-    }
 
     auto keyStr = WTF::String::fromUTF8(mod->nm_modname);
     globalObject->napiModuleRegisterCallCount++;
@@ -86,12 +82,13 @@ void node_module_register(void* opaque_mod)
 
     JSC::Strong<JSC::JSObject> strongObject = { vm, object };
 
-    HandleScope hs(Isolate::fromGlobalObject(globalObject));
+    auto* isolate = globalObject->V8GlobalInternals()->isolate();
+    HandleScope hs(isolate);
 
     // exports, module
     Local<Object> exports = hs.createLocal<Object>(vm, *strongExportsObject);
     Local<Value> module = hs.createLocal<Value>(vm, object);
-    Local<Context> context = Isolate::fromGlobalObject(globalObject)->GetCurrentContext();
+    Local<Context> context = isolate->GetCurrentContext();
     if (mod->nm_context_register_func) {
         mod->nm_context_register_func(exports, module, context, mod->nm_priv);
     } else if (mod->nm_register_func) {
@@ -107,4 +104,4 @@ void node_module_register(void* opaque_mod)
     globalObject->m_pendingNapiModuleAndExports[1].set(vm, globalObject, object);
 }
 
-}
+} // namespace node
diff --git a/src/bun.js/bindings/v8/node.h b/src/bun.js/bindings/v8/node.h
index d1b791f7ea..dc467afbef 100644
--- a/src/bun.js/bindings/v8/node.h
+++ b/src/bun.js/bindings/v8/node.h
@@ -41,4 +41,4 @@ struct node_module {
 
 extern "C" BUN_EXPORT void node_module_register(void* mod);
 
-}
+} // namespace node
diff --git a/src/bun.js/bindings/v8/real_v8.h b/src/bun.js/bindings/v8/real_v8.h
new file mode 100644
index 0000000000..dec9fa2b1a
--- /dev/null
+++ b/src/bun.js/bindings/v8/real_v8.h
@@ -0,0 +1,38 @@
+#pragma once
+
+// This file includes the actual V8 headers, with the namespace renamed from v8 to real_v8. To
+// minimize potential conflicts between V8 and Bun's implementation, it should only be included by
+// files from Bun's V8 implementation, and it should only be included in source files (not
+// header files).
+
+// Microsoft's C++ headers cause a compiler error if `private` has been redefined, like we do below.
+// These are all the standard library headers included by V8. We include them here so that they
+// are included while `private` is not redefined yet, and then when V8 includes them they will get
+// skipped by include guards.
+
+#include <array>
+#include <atomic>
+#include <bit>
+#include <cassert>
+#include <climits>
+#include <cstddef>
+#include <cstdint>
+#include <fstream>
+#include <functional>
+#include <iosfwd>
+#include <iterator>
+#include <limits>
+#include <memory>
+#include <new>
+#include <optional>
+#include <ostream>
+#include <string>
+#include <tuple>
+#include <utility>
+#include <vector>
+
+#define v8 real_v8
+#define private public
+#include "node/v8.h"
+#undef private
+#undef v8
diff --git a/src/bun.js/bindings/v8/shim/Function.cpp b/src/bun.js/bindings/v8/shim/Function.cpp
new file mode 100644
index 0000000000..2ee99becbb
--- /dev/null
+++ b/src/bun.js/bindings/v8/shim/Function.cpp
@@ -0,0 +1,63 @@
+#include "Function.h"
+
+#include "JavaScriptCore/FunctionPrototype.h"
+
+using JSC::Structure;
+using JSC::VM;
+
+namespace v8 {
+namespace shim {
+
+// for CREATE_METHOD_TABLE
+namespace JSCastingHelpers = JSC::JSCastingHelpers;
+
+const JSC::ClassInfo Function::s_info = {
+    "Function"_s,
+    &Base::s_info,
+    nullptr,
+    nullptr,
+    CREATE_METHOD_TABLE(Function)
+};
+
+Structure* Function::createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
+{
+    return Structure::create(
+        vm,
+        globalObject,
+        globalObject->functionPrototype(),
+        JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags),
+        info());
+}
+
+template<typename Visitor>
+void Function::visitChildrenImpl(JSCell* cell, Visitor& visitor)
+{
+    Function* fn = jsCast<Function*>(cell);
+    ASSERT_GC_OBJECT_INHERITS(fn, info());
+    Base::visitChildren(fn, visitor);
+
+    visitor.append(fn->m_functionTemplate);
+}
+
+DEFINE_VISIT_CHILDREN(Function);
+
+Function* Function::create(VM& vm, Structure* structure, FunctionTemplate* functionTemplate)
+{
+    auto* function = new (NotNull, JSC::allocateCell<Function>(vm)) Function(vm, structure);
+    function->finishCreation(vm, functionTemplate);
+    return function;
+}
+
+void Function::finishCreation(VM& vm, FunctionTemplate* functionTemplate)
+{
+    Base::finishCreation(vm, 0, "Function"_s);
+    m_functionTemplate.set(vm, this, functionTemplate);
+}
+
+void Function::setName(JSC::JSString* name)
+{
+    m_originalName.set(globalObject()->vm(), this, name);
+}
+
+} // namespace shim
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/shim/Function.h b/src/bun.js/bindings/v8/shim/Function.h
new file mode 100644
index 0000000000..895dd2b2df
--- /dev/null
+++ b/src/bun.js/bindings/v8/shim/Function.h
@@ -0,0 +1,49 @@
+#pragma once
+
+#include "../v8.h"
+#include "FunctionTemplate.h"
+
+namespace v8 {
+namespace shim {
+
+class Function : public JSC::InternalFunction {
+public:
+    using Base = JSC::InternalFunction;
+
+    static Function* create(JSC::VM& vm, JSC::Structure* structure, FunctionTemplate* functionTemplate);
+
+    DECLARE_INFO;
+    DECLARE_VISIT_CHILDREN;
+
+    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject);
+
+    template<typename, JSC::SubspaceAccess mode>
+    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+    {
+        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+            return nullptr;
+        return WebCore::subspaceForImpl<Function, WebCore::UseCustomHeapCellType::No>(
+            vm,
+            [](auto& spaces) { return spaces.m_clientSubspaceForV8Function.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForV8Function = std::forward<decltype(space)>(space); },
+            [](auto& spaces) { return spaces.m_subspaceForV8Function.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_subspaceForV8Function = std::forward<decltype(space)>(space); });
+    }
+
+    FunctionTemplate* functionTemplate() const { return m_functionTemplate.get(); }
+
+    void setName(JSC::JSString* name);
+
+private:
+    JSC::WriteBarrier<FunctionTemplate> m_functionTemplate;
+
+    Function(JSC::VM& vm, JSC::Structure* structure)
+        : Base(vm, structure, FunctionTemplate::functionCall)
+    {
+    }
+
+    void finishCreation(JSC::VM& vm, FunctionTemplate* functionTemplate);
+};
+
+} // namespace shim
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/shim/FunctionTemplate.cpp b/src/bun.js/bindings/v8/shim/FunctionTemplate.cpp
new file mode 100644
index 0000000000..db04da9fc2
--- /dev/null
+++ b/src/bun.js/bindings/v8/shim/FunctionTemplate.cpp
@@ -0,0 +1,111 @@
+#include "FunctionTemplate.h"
+#include "Function.h"
+#include "../V8HandleScope.h"
+#include "../V8Data.h"
+
+#include "JavaScriptCore/FunctionPrototype.h"
+
+using JSC::JSValue;
+using JSC::Structure;
+
+namespace v8 {
+
+class Object;
+
+namespace shim {
+
+// for CREATE_METHOD_TABLE
+namespace JSCastingHelpers = JSC::JSCastingHelpers;
+
+const JSC::ClassInfo FunctionTemplate::s_info = {
+    "FunctionTemplate"_s,
+    &Base::s_info,
+    nullptr,
+    nullptr,
+    CREATE_METHOD_TABLE(FunctionTemplate)
+};
+
+FunctionTemplate* FunctionTemplate::create(JSC::VM& vm, JSC::Structure* structure, FunctionCallback callback, JSC::JSValue data)
+{
+    auto* functionTemplate = new (NotNull, JSC::allocateCell<FunctionTemplate>(vm)) FunctionTemplate(
+        vm, structure, callback, data);
+    functionTemplate->finishCreation(vm);
+    return functionTemplate;
+}
+
+Structure* FunctionTemplate::createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
+{
+    return Structure::create(
+        vm,
+        globalObject,
+        globalObject->functionPrototype(),
+        JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags),
+        info());
+}
+
+template<typename Visitor>
+void FunctionTemplate::visitChildrenImpl(JSCell* cell, Visitor& visitor)
+{
+    FunctionTemplate* fn = jsCast<FunctionTemplate*>(cell);
+    ASSERT_GC_OBJECT_INHERITS(fn, info());
+    Base::visitChildren(fn, visitor);
+
+    visitor.append(fn->m_data);
+}
+
+DEFINE_VISIT_CHILDREN(FunctionTemplate);
+
+JSC::EncodedJSValue FunctionTemplate::functionCall(JSC::JSGlobalObject* globalObject, JSC::CallFrame* callFrame)
+{
+    auto* callee = JSC::jsDynamicCast<Function*>(callFrame->jsCallee());
+    auto* functionTemplate = callee->functionTemplate();
+    auto* isolate = JSC::jsCast<Zig::GlobalObject*>(globalObject)->V8GlobalInternals()->isolate();
+    auto& vm = globalObject->vm();
+
+    WTF::Vector<TaggedPointer, 8> args(callFrame->argumentCount() + 1);
+
+    HandleScope hs(isolate);
+
+    // V8 function calls always run in "sloppy mode," even if the JS side is in strict mode. So if
+    // `this` is null or undefined, we use globalThis instead; otherwise, we convert `this` to an
+    // object.
+    JSC::JSObject* jscThis = globalObject->globalThis();
+    if (!callFrame->thisValue().isUndefinedOrNull()) {
+        jscThis = callFrame->thisValue().toObject(globalObject);
+    }
+    Local<Object> thisObject = hs.createLocal<Object>(vm, jscThis);
+    args[0] = thisObject.tagged();
+
+    for (size_t i = 0; i < callFrame->argumentCount(); i++) {
+        Local<Value> argValue = hs.createLocal<Value>(vm, callFrame->argument(i));
+        args[i + 1] = argValue.tagged();
+    }
+
+    Local<Value> data = hs.createLocal<Value>(vm, functionTemplate->m_data.get());
+
+    ImplicitArgs implicit_args = {
+        .holder = nullptr,
+        .isolate = isolate,
+        .unused = nullptr,
+        .return_value = TaggedPointer(),
+        // data may be an object
+        // put it in the handle scope so that it has a map ptr
+        .data = data.tagged(),
+        .new_target = nullptr,
+    };
+
+    FunctionCallbackInfo<Value> info(&implicit_args, args.data() + 1, callFrame->argumentCount());
+
+    functionTemplate->m_callback(info);
+
+    if (implicit_args.return_value.isEmpty()) {
+        // callback forgot to set a return value, so return undefined
+        return JSValue::encode(JSC::jsUndefined());
+    } else {
+        Local<Data> local_ret(&implicit_args.return_value);
+        return JSValue::encode(local_ret->localToJSValue());
+    }
+}
+
+} // namespace shim
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/shim/FunctionTemplate.h b/src/bun.js/bindings/v8/shim/FunctionTemplate.h
new file mode 100644
index 0000000000..29027bd3fc
--- /dev/null
+++ b/src/bun.js/bindings/v8/shim/FunctionTemplate.h
@@ -0,0 +1,51 @@
+#pragma once
+
+#include "../v8.h"
+#include "../V8FunctionCallbackInfo.h"
+
+namespace v8 {
+
+class FunctionTemplate;
+
+namespace shim {
+
+class FunctionTemplate : public JSC::InternalFunction {
+public:
+    using Base = JSC::InternalFunction;
+
+    static FunctionTemplate* create(JSC::VM& vm, JSC::Structure* structure, FunctionCallback callback, JSC::JSValue data);
+
+    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject);
+
+    template<typename, JSC::SubspaceAccess mode>
+    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+    {
+        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+            return nullptr;
+        return WebCore::subspaceForImpl<FunctionTemplate, WebCore::UseCustomHeapCellType::No>(
+            vm,
+            [](auto& spaces) { return spaces.m_clientSubspaceForFunctionTemplate.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForFunctionTemplate = std::forward<decltype(space)>(space); },
+            [](auto& spaces) { return spaces.m_subspaceForFunctionTemplate.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_subspaceForFunctionTemplate = std::forward<decltype(space)>(space); });
+    }
+
+    DECLARE_INFO;
+    DECLARE_VISIT_CHILDREN;
+
+    static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES functionCall(JSC::JSGlobalObject* globalObject, JSC::CallFrame* callFrame);
+
+private:
+    FunctionCallback m_callback;
+    JSC::WriteBarrier<JSC::Unknown> m_data;
+
+    FunctionTemplate(JSC::VM& vm, JSC::Structure* structure, FunctionCallback callback, JSC::JSValue data)
+        : Base(vm, structure, functionCall, JSC::callHostFunctionAsConstructor)
+        , m_callback(callback)
+        , m_data(vm, this, data)
+    {
+    }
+};
+
+} // namespace shim
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/shim/GlobalInternals.cpp b/src/bun.js/bindings/v8/shim/GlobalInternals.cpp
new file mode 100644
index 0000000000..452c90b21d
--- /dev/null
+++ b/src/bun.js/bindings/v8/shim/GlobalInternals.cpp
@@ -0,0 +1,72 @@
+#include "GlobalInternals.h"
+
+#include "../V8ObjectTemplate.h"
+#include "InternalFieldObject.h"
+#include "HandleScopeBuffer.h"
+#include "../V8FunctionTemplate.h"
+#include "../V8Function.h"
+
+#include "JavaScriptCore/FunctionPrototype.h"
+#include "JavaScriptCore/LazyClassStructureInlines.h"
+#include "JavaScriptCore/VMTrapsInlines.h"
+
+using JSC::ClassInfo;
+using JSC::LazyClassStructure;
+using JSC::LazyProperty;
+using JSC::Structure;
+using JSC::VM;
+
+namespace v8 {
+namespace shim {
+
+// for CREATE_METHOD_TABLE
+namespace JSCastingHelpers = JSC::JSCastingHelpers;
+
+const ClassInfo GlobalInternals::s_info = { "GlobalInternals"_s, nullptr, nullptr, nullptr, CREATE_METHOD_TABLE(GlobalInternals) };
+
+GlobalInternals* GlobalInternals::create(VM& vm, Structure* structure, Zig::GlobalObject* globalObject)
+{
+    GlobalInternals* internals = new (NotNull, JSC::allocateCell<GlobalInternals>(vm)) GlobalInternals(vm, structure, globalObject);
+    internals->finishCreation(vm);
+    return internals;
+}
+
+void GlobalInternals::finishCreation(VM& vm)
+{
+    Base::finishCreation(vm);
+    m_objectTemplateStructure.initLater([](LazyClassStructure::Initializer& init) {
+        init.setStructure(ObjectTemplate::createStructure(init.vm, init.global, init.global->functionPrototype()));
+    });
+    m_handleScopeBufferStructure.initLater([](LazyClassStructure::Initializer& init) {
+        init.setStructure(HandleScopeBuffer::createStructure(init.vm, init.global));
+    });
+    m_functionTemplateStructure.initLater([](LazyClassStructure::Initializer& init) {
+        init.setStructure(FunctionTemplate::createStructure(init.vm, init.global));
+    });
+    m_v8FunctionStructure.initLater([](LazyClassStructure::Initializer& init) {
+        init.setStructure(Function::createStructure(init.vm, init.global));
+    });
+    m_globalHandles.initLater([](const LazyProperty<GlobalInternals, HandleScopeBuffer>::Initializer& init) {
+        init.set(HandleScopeBuffer::create(init.vm,
+            init.owner->handleScopeBufferStructure(init.owner->m_globalObject)));
+    });
+}
+
+template<typename Visitor>
+void GlobalInternals::visitChildrenImpl(JSCell* cell, Visitor& visitor)
+{
+    GlobalInternals* thisObject = jsCast<GlobalInternals*>(cell);
+    ASSERT_GC_OBJECT_INHERITS(thisObject, info());
+    Base::visitChildren(thisObject, visitor);
+
+    thisObject->m_objectTemplateStructure.visit(visitor);
+    thisObject->m_handleScopeBufferStructure.visit(visitor);
+    thisObject->m_functionTemplateStructure.visit(visitor);
+    thisObject->m_v8FunctionStructure.visit(visitor);
+    thisObject->m_globalHandles.visit(visitor);
+}
+
+DEFINE_VISIT_CHILDREN_WITH_MODIFIER(JS_EXPORT_PRIVATE, GlobalInternals);
+
+} // namespace shim
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/shim/GlobalInternals.h b/src/bun.js/bindings/v8/shim/GlobalInternals.h
new file mode 100644
index 0000000000..e55ac4af20
--- /dev/null
+++ b/src/bun.js/bindings/v8/shim/GlobalInternals.h
@@ -0,0 +1,105 @@
+#pragma once
+
+#include "BunClientData.h"
+
+#include "../V8Isolate.h"
+#include "Oddball.h"
+
+namespace v8 {
+
+class HandleScope;
+
+namespace shim {
+
+class HandleScopeBuffer;
+
+class GlobalInternals : public JSC::JSCell {
+public:
+    using Base = JSC::JSCell;
+
+    static GlobalInternals* create(JSC::VM& vm, JSC::Structure* structure, Zig::GlobalObject* globalObject);
+
+    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
+    {
+        return JSC::Structure::create(vm, globalObject, JSC::jsNull(), JSC::TypeInfo(JSC::CellType, StructureFlags), info(), 0, 0);
+    }
+
+    template<typename, JSC::SubspaceAccess mode>
+    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+    {
+        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+            return nullptr;
+        return WebCore::subspaceForImpl<GlobalInternals, WebCore::UseCustomHeapCellType::No>(
+            vm,
+            [](auto& spaces) { return spaces.m_clientSubspaceForV8GlobalInternals.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForV8GlobalInternals = std::forward<decltype(space)>(space); },
+            [](auto& spaces) { return spaces.m_subspaceForV8GlobalInternals.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_subspaceForV8GlobalInternals = std::forward<decltype(space)>(space); });
+    }
+
+    JSC::Structure* objectTemplateStructure(JSC::JSGlobalObject* globalObject) const
+    {
+        return m_objectTemplateStructure.getInitializedOnMainThread(globalObject);
+    }
+
+    JSC::Structure* handleScopeBufferStructure(JSC::JSGlobalObject* globalObject) const
+    {
+        return m_handleScopeBufferStructure.getInitializedOnMainThread(globalObject);
+    }
+
+    JSC::Structure* functionTemplateStructure(JSC::JSGlobalObject* globalObject) const
+    {
+        return m_functionTemplateStructure.getInitializedOnMainThread(globalObject);
+    }
+
+    JSC::Structure* v8FunctionStructure(JSC::JSGlobalObject* globalObject) const
+    {
+        return m_v8FunctionStructure.getInitializedOnMainThread(globalObject);
+    }
+
+    HandleScopeBuffer* globalHandles() const { return m_globalHandles.getInitializedOnMainThread(this); }
+
+    HandleScope* currentHandleScope() const { return m_currentHandleScope; }
+
+    void setCurrentHandleScope(HandleScope* handleScope) { m_currentHandleScope = handleScope; }
+
+    Isolate* isolate() { return &m_isolate; }
+
+    DECLARE_INFO;
+    DECLARE_VISIT_CHILDREN_WITH_MODIFIER(JS_EXPORT_PRIVATE);
+
+    friend class ::v8::Isolate;
+    friend class ::v8::Context;
+
+private:
+    Zig::GlobalObject* m_globalObject;
+    JSC::LazyClassStructure m_objectTemplateStructure;
+    JSC::LazyClassStructure m_handleScopeBufferStructure;
+    JSC::LazyClassStructure m_functionTemplateStructure;
+    JSC::LazyClassStructure m_v8FunctionStructure;
+    HandleScope* m_currentHandleScope;
+    JSC::LazyProperty<GlobalInternals, HandleScopeBuffer> m_globalHandles;
+
+    Oddball m_undefinedValue;
+    Oddball m_nullValue;
+    Oddball m_trueValue;
+    Oddball m_falseValue;
+
+    Isolate m_isolate;
+
+    void finishCreation(JSC::VM& vm);
+    GlobalInternals(JSC::VM& vm, JSC::Structure* structure, Zig::GlobalObject* globalObject)
+        : Base(vm, structure)
+        , m_currentHandleScope(nullptr)
+        , m_undefinedValue(Oddball::Kind::kUndefined)
+        , m_nullValue(Oddball::Kind::kNull)
+        , m_trueValue(Oddball::Kind::kTrue)
+        , m_falseValue(Oddball::Kind::kFalse)
+        , m_isolate(this)
+        , m_globalObject(globalObject)
+    {
+    }
+};
+
+} // namespace shim
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/shim/Handle.cpp b/src/bun.js/bindings/v8/shim/Handle.cpp
new file mode 100644
index 0000000000..3aa33c7880
--- /dev/null
+++ b/src/bun.js/bindings/v8/shim/Handle.cpp
@@ -0,0 +1,53 @@
+#include "Handle.h"
+#include "real_v8.h"
+
+static_assert(offsetof(v8::shim::ObjectLayout, m_taggedMap) == real_v8::internal::Internals::kHeapObjectMapOffset,
+    "ObjectLayout map pointer is at the wrong offset");
+static_assert(offsetof(v8::shim::Handle, m_toV8Object) == 0,
+    "Handle object pointer is at wrong offset");
+
+namespace v8 {
+namespace shim {
+
+Handle::Handle(const Map* map, JSC::JSCell* cell, JSC::VM& vm, const JSC::JSCell* owner)
+    : m_toV8Object(&this->m_object)
+    , m_object(map, cell, vm, owner)
+{
+}
+
+Handle::Handle(double number)
+    : m_toV8Object(&this->m_object)
+    , m_object(number)
+{
+}
+
+Handle::Handle(int32_t smi)
+    : m_toV8Object(smi)
+    , m_object()
+{
+}
+
+Handle::Handle(const Handle& that)
+{
+    *this = that;
+}
+
+Handle::Handle(const ObjectLayout* that)
+    : m_toV8Object(&this->m_object)
+{
+    m_object = *that;
+}
+
+Handle& Handle::operator=(const Handle& that)
+{
+    m_object = that.m_object;
+    if (that.m_toV8Object.tag() == TaggedPointer::Tag::Smi) {
+        m_toV8Object = that.m_toV8Object;
+    } else {
+        m_toV8Object = &this->m_object;
+    }
+    return *this;
+}
+
+} // namespace shim
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/shim/Handle.h b/src/bun.js/bindings/v8/shim/Handle.h
new file mode 100644
index 0000000000..bd87f417f0
--- /dev/null
+++ b/src/bun.js/bindings/v8/shim/Handle.h
@@ -0,0 +1,110 @@
+#pragma once
+
+#include <root.h>
+#include "Map.h"
+
+namespace v8 {
+namespace shim {
+
+struct ObjectLayout {
+    // this field must be at the start so that V8 can find the map
+    TaggedPointer m_taggedMap;
+    union {
+        JSC::WriteBarrier<JSC::JSCell> cell;
+        double number;
+    } m_contents;
+
+    ObjectLayout()
+        // using a smi value for map is most likely to catch bugs as almost every access will expect
+        // map to be a pointer (and even if the assertion is bypassed, it'll be a null pointer)
+        : m_taggedMap(0)
+        , m_contents({ .cell = {} })
+    {
+    }
+
+    ObjectLayout(const Map* map_ptr, JSC::JSCell* cell, JSC::VM& vm, const JSC::JSCell* owner)
+        : m_taggedMap(const_cast<Map*>(map_ptr))
+        , m_contents({ .cell = JSC::WriteBarrier<JSC::JSCell>(vm, owner, cell) })
+    {
+    }
+
+    ObjectLayout(double number)
+        : m_taggedMap(const_cast<Map*>(&Map::heap_number_map))
+        , m_contents({ .number = number })
+    {
+    }
+
+    const Map* map() const { return m_taggedMap.getPtr<Map>(); }
+
+    double asDouble() const { return m_contents.number; }
+
+    JSC::JSCell* asCell() const { return m_contents.cell.get(); }
+};
+
+// A handle stored in a HandleScope with layout suitable for V8's inlined functions:
+// - The first field is a V8 tagged pointer. If it's a SMI (int32), it holds the numeric value
+//   directly and the other fields don't matter.
+// - Otherwise, if the first field is a pointer value, V8 treats that as a pointer to an object with
+//   V8 layout. V8 objects have a tagged pointer to their map (which describes their structure) as
+//   the first field. Therefore, in the object case, the first field is a pointer to the second
+//   field.
+// - V8 will inspect the instance type of the map to determine if it can take fast paths for some
+//   functions (notably, Value::IsUndefined()/IsNull() and Object::GetInternalField()). For objects,
+//   we use a map with an instance type that makes V8 think it must call SlowGetInternalField(),
+//   which we can control. That function (and all other functions that are called on Locals) uses
+//   the third field to get the actual object (either a JSCell* or a void*, depending on whether map
+//   points to Map::object_map or Map::raw_ptr_map).
+struct Handle {
+    Handle(const Map* map, JSC::JSCell* cell, JSC::VM& vm, const JSC::JSCell* owner);
+
+    Handle(double number);
+
+    Handle(int32_t smi);
+
+    Handle(const Handle& that);
+
+    Handle(const ObjectLayout* that);
+
+    Handle()
+        : m_toV8Object(0)
+        , m_object()
+    {
+    }
+
+    Handle& operator=(const Handle& that);
+
+    bool isCell() const
+    {
+        if (m_toV8Object.tag() == TaggedPointer::Tag::Smi) {
+            return false;
+        }
+        const Map* map_ptr = m_object.map();
+        // TODO(@190n) exhaustively switch on InstanceType
+        if (map_ptr == &Map::object_map || map_ptr == &Map::string_map) {
+            return true;
+        } else if (map_ptr == &Map::map_map || map_ptr == &Map::oddball_map
+            || map_ptr == &Map::heap_number_map) {
+            return false;
+        } else {
+            RELEASE_ASSERT_NOT_REACHED("unknown Map at %p with instance type %" PRIx16,
+                map_ptr, map_ptr->m_instanceType);
+        }
+    }
+
+    TaggedPointer* slot()
+    {
+        return &m_toV8Object;
+    }
+
+    JSC::WriteBarrier<JSC::JSCell> asCell() const
+    {
+        return m_object.m_contents.cell;
+    }
+
+    // if not SMI, holds &this->map so that V8 can see what kind of object this is
+    TaggedPointer m_toV8Object;
+    ObjectLayout m_object;
+};
+
+} // namespace shim
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/shim/HandleScopeBuffer.cpp b/src/bun.js/bindings/v8/shim/HandleScopeBuffer.cpp
new file mode 100644
index 0000000000..9f814d90a7
--- /dev/null
+++ b/src/bun.js/bindings/v8/shim/HandleScopeBuffer.cpp
@@ -0,0 +1,121 @@
+#include "HandleScopeBuffer.h"
+#include "GlobalInternals.h"
+#include "../V8Isolate.h"
+
+namespace v8 {
+namespace shim {
+
+// for CREATE_METHOD_TABLE
+namespace JSCastingHelpers = JSC::JSCastingHelpers;
+
+const JSC::ClassInfo HandleScopeBuffer::s_info = {
+    "HandleScopeBuffer"_s,
+    nullptr,
+    nullptr,
+    nullptr,
+    CREATE_METHOD_TABLE(HandleScopeBuffer)
+};
+
+HandleScopeBuffer* HandleScopeBuffer::create(JSC::VM& vm, JSC::Structure* structure)
+{
+    HandleScopeBuffer* buffer = new (NotNull, JSC::allocateCell<HandleScopeBuffer>(vm)) HandleScopeBuffer(vm, structure);
+    buffer->finishCreation(vm);
+    return buffer;
+}
+
+template<typename Visitor>
+void HandleScopeBuffer::visitChildrenImpl(JSCell* cell, Visitor& visitor)
+{
+    HandleScopeBuffer* thisObject = jsCast<HandleScopeBuffer*>(cell);
+    ASSERT_GC_OBJECT_INHERITS(thisObject, info());
+    Base::visitChildren(thisObject, visitor);
+
+    WTF::Locker locker { thisObject->m_gcLock };
+
+    for (auto& handle : thisObject->m_storage) {
+        if (handle.isCell()) {
+            visitor.append(handle.asCell());
+        }
+    }
+}
+
+DEFINE_VISIT_CHILDREN(HandleScopeBuffer);
+
+Handle& HandleScopeBuffer::createEmptyHandle()
+{
+    WTF::Locker locker { m_gcLock };
+    m_storage.append(Handle {});
+    return m_storage.last();
+}
+
+TaggedPointer* HandleScopeBuffer::createHandle(JSCell* ptr, const Map* map, JSC::VM& vm)
+{
+    auto& handle = createEmptyHandle();
+    handle = Handle(map, ptr, vm, this);
+    return handle.slot();
+}
+
+TaggedPointer* HandleScopeBuffer::createSmiHandle(int32_t smi)
+{
+    auto& handle = createEmptyHandle();
+    handle = Handle(smi);
+    return handle.slot();
+}
+
+TaggedPointer* HandleScopeBuffer::createDoubleHandle(double value)
+{
+    auto& handle = createEmptyHandle();
+    handle = Handle(value);
+    return handle.slot();
+}
+
+TaggedPointer* HandleScopeBuffer::createHandleFromExistingObject(TaggedPointer address, Isolate* isolate, Handle* reuseHandle)
+{
+    int32_t smi;
+    if (address.getSmi(smi)) {
+        if (reuseHandle) {
+            *reuseHandle = Handle(smi);
+            return reuseHandle->slot();
+        } else {
+            return createSmiHandle(smi);
+        }
+    } else {
+        auto* v8_object = address.getPtr<ObjectLayout>();
+        if (v8_object->map()->m_instanceType == InstanceType::Oddball) {
+            using Kind = Oddball::Kind;
+            // find which oddball this is
+            switch (reinterpret_cast<Oddball*>(v8_object)->kind()) {
+            case Kind::kNull:
+                return isolate->nullSlot();
+            case Kind::kUndefined:
+                return isolate->undefinedSlot();
+            case Kind::kTrue:
+                return isolate->trueSlot();
+            case Kind::kFalse:
+                return isolate->falseSlot();
+            default:
+                RELEASE_ASSERT_NOT_REACHED("HandleScopeBuffer::createHandleFromExistingObject passed an unknown Oddball kind: %d",
+                    reinterpret_cast<Oddball*>(v8_object)->kind());
+            }
+        }
+        if (reuseHandle) {
+            *reuseHandle = Handle(v8_object->map(), v8_object->asCell(), vm(), this);
+            return reuseHandle->slot();
+        } else {
+            return createHandle(v8_object->asCell(), v8_object->map(), vm());
+        }
+    }
+}
+
+void HandleScopeBuffer::clear()
+{
+    // detect use-after-free of handles
+    WTF::Locker locker { m_gcLock };
+    for (auto& handle : m_storage) {
+        handle = Handle();
+    }
+    m_storage.clear();
+}
+
+} // namespace shim
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/shim/HandleScopeBuffer.h b/src/bun.js/bindings/v8/shim/HandleScopeBuffer.h
new file mode 100644
index 0000000000..e51e59e9e8
--- /dev/null
+++ b/src/bun.js/bindings/v8/shim/HandleScopeBuffer.h
@@ -0,0 +1,75 @@
+#pragma once
+
+#include "../v8.h"
+#include "TaggedPointer.h"
+#include "Map.h"
+#include "Handle.h"
+#include <JavaScriptCore/JSCell.h>
+
+namespace v8 {
+
+class Isolate;
+class EscapableHandleScopeBase;
+
+namespace shim {
+
+// An array used by HandleScope to store the items. Must keep pointer stability when resized, since
+// v8::Locals point inside this array.
+class HandleScopeBuffer : public JSC::JSCell {
+public:
+    using Base = JSC::JSCell;
+
+    static HandleScopeBuffer* create(JSC::VM& vm, JSC::Structure* structure);
+
+    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
+    {
+        return JSC::Structure::create(vm, globalObject, JSC::jsNull(), JSC::TypeInfo(JSC::CellType, StructureFlags), info(), 0, 0);
+    }
+
+    template<typename, JSC::SubspaceAccess mode>
+    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+    {
+        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+            return nullptr;
+        return WebCore::subspaceForImpl<HandleScopeBuffer, WebCore::UseCustomHeapCellType::No>(
+            vm,
+            [](auto& spaces) { return spaces.m_clientSubspaceForHandleScopeBuffer.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForHandleScopeBuffer = std::forward<decltype(space)>(space); },
+            [](auto& spaces) { return spaces.m_subspaceForHandleScopeBuffer.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_subspaceForHandleScopeBuffer = std::forward<decltype(space)>(space); });
+    }
+
+    TaggedPointer* createHandle(JSC::JSCell* object, const Map* map, JSC::VM& vm);
+    TaggedPointer* createSmiHandle(int32_t smi);
+    TaggedPointer* createDoubleHandle(double value);
+
+    // Given a tagged pointer from V8, create a handle around the same object or the same
+    // numeric value
+    //
+    // address:     V8 object pointer or Smi
+    // isolate:     received in any V8 method
+    // reuseHandle: if nonnull, change this handle instead of creating a new one
+    // returns the location of the new handle's V8 object pointer or Smi
+    TaggedPointer* createHandleFromExistingObject(TaggedPointer address, Isolate* isolate, Handle* reuseHandle = nullptr);
+
+    void clear();
+
+    DECLARE_INFO;
+    DECLARE_VISIT_CHILDREN;
+
+    friend class ::v8::EscapableHandleScopeBase;
+
+private:
+    WTF::Lock m_gcLock;
+    WTF::SegmentedVector<Handle, 16> m_storage;
+
+    Handle& createEmptyHandle();
+
+    HandleScopeBuffer(JSC::VM& vm, JSC::Structure* structure)
+        : Base(vm, structure)
+    {
+    }
+};
+
+} // namespace shim
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/shim/InternalFieldObject.cpp b/src/bun.js/bindings/v8/shim/InternalFieldObject.cpp
new file mode 100644
index 0000000000..ca3f7bd2ee
--- /dev/null
+++ b/src/bun.js/bindings/v8/shim/InternalFieldObject.cpp
@@ -0,0 +1,41 @@
+#include "InternalFieldObject.h"
+#include "ObjectTemplate.h"
+
+namespace v8 {
+namespace shim {
+// for CREATE_METHOD_TABLE
+namespace JSCastingHelpers = JSC::JSCastingHelpers;
+
+const JSC::ClassInfo InternalFieldObject::s_info = {
+    "InternalFieldObject"_s,
+    &Base::s_info,
+    nullptr,
+    nullptr,
+    CREATE_METHOD_TABLE(InternalFieldObject)
+};
+
+InternalFieldObject* InternalFieldObject::create(JSC::VM& vm, JSC::Structure* structure, int internalFieldCount)
+{
+    // TODO figure out how this works with __internals
+    // maybe pass a Local<ObjectTemplate>
+    auto object = new (NotNull, JSC::allocateCell<InternalFieldObject>(vm)) InternalFieldObject(vm, structure, internalFieldCount);
+    object->finishCreation(vm);
+    return object;
+}
+
+template<typename Visitor>
+void InternalFieldObject::visitChildrenImpl(JSCell* cell, Visitor& visitor)
+{
+    InternalFieldObject* thisObject = jsCast<InternalFieldObject*>(cell);
+    ASSERT_GC_OBJECT_INHERITS(thisObject, info());
+    Base::visitChildren(thisObject, visitor);
+
+    for (auto& value : thisObject->m_fields) {
+        visitor.append(value);
+    }
+}
+
+DEFINE_VISIT_CHILDREN(InternalFieldObject);
+
+} // namespace shim
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/shim/InternalFieldObject.h b/src/bun.js/bindings/v8/shim/InternalFieldObject.h
new file mode 100644
index 0000000000..1453c9448e
--- /dev/null
+++ b/src/bun.js/bindings/v8/shim/InternalFieldObject.h
@@ -0,0 +1,50 @@
+#pragma once
+
+#include "BunClientData.h"
+
+namespace v8 {
+
+namespace shim {
+
+class ObjectTemplate;
+
+class InternalFieldObject : public JSC::JSDestructibleObject {
+public:
+    using Base = JSC::JSDestructibleObject;
+
+    DECLARE_INFO;
+
+    template<typename, JSC::SubspaceAccess mode>
+    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+    {
+        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+            return nullptr;
+        return WebCore::subspaceForImpl<InternalFieldObject, WebCore::UseCustomHeapCellType::No>(
+            vm,
+            [](auto& spaces) { return spaces.m_clientSubspaceForInternalFieldObject.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForInternalFieldObject = std::forward<decltype(space)>(space); },
+            [](auto& spaces) { return spaces.m_subspaceForInternalFieldObject.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_subspaceForInternalFieldObject = std::forward<decltype(space)>(space); });
+    }
+
+    // never changes size
+    using FieldContainer = WTF::FixedVector<JSC::WriteBarrier<JSC::Unknown>>;
+
+    FieldContainer* internalFields() { return &m_fields; }
+    static InternalFieldObject* create(JSC::VM& vm, JSC::Structure* structure, int internalFieldCount);
+
+    DECLARE_VISIT_CHILDREN;
+
+protected:
+    InternalFieldObject(JSC::VM& vm, JSC::Structure* structure, int internalFieldCount)
+        : Base(vm, structure)
+        , m_fields(internalFieldCount, JSC::WriteBarrier<JSC::Unknown>(vm, this, JSC::jsUndefined()))
+    {
+    }
+
+private:
+    FieldContainer m_fields;
+};
+
+} // namespace shim
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/shim/Map.cpp b/src/bun.js/bindings/v8/shim/Map.cpp
new file mode 100644
index 0000000000..0502ac6b71
--- /dev/null
+++ b/src/bun.js/bindings/v8/shim/Map.cpp
@@ -0,0 +1,33 @@
+#include "Map.h"
+#include "real_v8.h"
+
+static_assert(offsetof(v8::shim::Map, m_metaMap) == real_v8::internal::Internals::kHeapObjectMapOffset,
+    "v8::Map map pointer is at wrong offset");
+static_assert(offsetof(v8::shim::Map, m_instanceType) == real_v8::internal::Internals::kMapInstanceTypeOffset,
+    "v8::Map instance type is at wrong offset");
+
+static_assert((int)v8::shim::InstanceType::String < real_v8::internal::Internals::kFirstNonstringType,
+    "String instance type is not a string");
+static_assert((int)v8::shim::InstanceType::Oddball == real_v8::internal::Internals::kOddballType,
+    "Oddball instance type does not match V8");
+static_assert((int)v8::shim::InstanceType::Object >= real_v8::internal::Internals::kFirstNonstringType,
+    "Objects are strings");
+static_assert((int)v8::shim::InstanceType::HeapNumber >= real_v8::internal::Internals::kFirstNonstringType,
+    "HeapNumbers are strings");
+
+static_assert(real_v8::internal::Internals::CanHaveInternalField((int)v8::shim::InstanceType::Object) == false,
+    "Object instance type appears compatible with internal fields"
+    "(so V8 will use direct pointer offsets instead of calling the slow path)");
+
+namespace v8 {
+namespace shim {
+
+// TODO give these more appropriate instance types
+const Map Map::map_map(InstanceType::Object);
+const Map Map::object_map(InstanceType::Object);
+const Map Map::oddball_map(InstanceType::Oddball);
+const Map Map::string_map(InstanceType::String);
+const Map Map::heap_number_map(InstanceType::HeapNumber);
+
+} // namespace shim
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/shim/Map.h b/src/bun.js/bindings/v8/shim/Map.h
new file mode 100644
index 0000000000..95a9d14f6d
--- /dev/null
+++ b/src/bun.js/bindings/v8/shim/Map.h
@@ -0,0 +1,63 @@
+#pragma once
+
+#include "TaggedPointer.h"
+
+namespace v8 {
+namespace shim {
+
+enum class InstanceType : uint16_t {
+    // v8-internal.h:787, kFirstNonstringType is 0x80
+    String = 0x7f,
+    // "Oddball" in V8 means undefined or null
+    // v8-internal.h:788
+    Oddball = 0x83,
+    // v8-internal.h:1016 kFirstNonstringType
+    // this cannot be kJSObjectType (or anything in the range [kJSObjectType, kLastJSApiObjectType])
+    // because then V8 will try to access internal fields directly instead of calling
+    // SlowGetInternalField
+    Object = 0x80,
+    // a number that doesn't fit in int32_t and is stored on the heap (for us, in the
+    // HandleScopeBuffer)
+    HeapNumber = 0x82,
+};
+
+// V8's description of the structure of an object
+struct Map {
+    // the structure of the map itself (always points to map_map)
+    TaggedPointer m_metaMap;
+    // TBD whether we need to put anything here to please inlined V8 functions
+    uint32_t m_unused;
+    // describes which kind of object this is. we shouldn't actually need to create very many
+    // instance types -- only ones for primitives, and one to make sure V8 thinks it cannot take the
+    // fast path when accessing internal fields
+    // (v8::internal::Internals::CanHaveInternalField, in v8-internal.h)
+    InstanceType m_instanceType;
+
+    // Since maps are V8 objects, they each also have a map pointer at the start, which is this one
+    static const Map map_map;
+    // All V8 values not covered by a more specific map use this one
+    static const Map object_map;
+    // The map used by null, undefined, true, and false. Required since V8 checks these values'
+    // instance type in the inline QuickIs* functions
+    static const Map oddball_map;
+    // All strings use this map. Required since V8's inline QuickIsString() checks the instance
+    // type.
+    static const Map string_map;
+    // Handles containing a double instead of a JSCell pointer use this map so that we can tell they
+    // are numbers.
+    static const Map heap_number_map;
+
+    Map(InstanceType instance_type)
+        : m_metaMap(const_cast<Map*>(&map_map))
+        , m_unused(0xaaaaaaaa)
+        , m_instanceType(instance_type)
+    {
+    }
+};
+
+static_assert(sizeof(Map) == 16, "Map has wrong layout");
+static_assert(offsetof(Map, m_metaMap) == 0, "Map has wrong layout");
+static_assert(offsetof(Map, m_instanceType) == 12, "Map has wrong layout");
+
+} // namespace shim
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/shim/ObjectTemplate.cpp b/src/bun.js/bindings/v8/shim/ObjectTemplate.cpp
new file mode 100644
index 0000000000..6fb50513b8
--- /dev/null
+++ b/src/bun.js/bindings/v8/shim/ObjectTemplate.cpp
@@ -0,0 +1,76 @@
+#include "ObjectTemplate.h"
+
+#include "JavaScriptCore/FunctionPrototype.h"
+#include "JavaScriptCore/LazyPropertyInlines.h"
+#include "JavaScriptCore/VMTrapsInlines.h"
+
+using JSC::LazyProperty;
+using JSC::Structure;
+
+namespace v8 {
+namespace shim {
+
+// for CREATE_METHOD_TABLE
+namespace JSCastingHelpers = JSC::JSCastingHelpers;
+
+const JSC::ClassInfo ObjectTemplate::s_info = {
+    "ObjectTemplate"_s,
+    &Base::s_info,
+    nullptr,
+    nullptr,
+    CREATE_METHOD_TABLE(ObjectTemplate)
+};
+
+ObjectTemplate* ObjectTemplate::create(JSC::VM& vm, JSC::Structure* structure)
+{
+    // TODO take a constructor
+    auto* objectTemplate = new (NotNull, JSC::allocateCell<ObjectTemplate>(vm)) ObjectTemplate(vm, structure);
+    objectTemplate->finishCreation(vm);
+    return objectTemplate;
+}
+
+void ObjectTemplate::finishCreation(JSC::VM& vm)
+{
+    Base::finishCreation(vm);
+    m_objectStructure.initLater([](const LazyProperty<ObjectTemplate, Structure>::Initializer& init) {
+        init.set(JSC::Structure::create(
+            init.vm,
+            init.owner->globalObject(),
+            init.owner->globalObject()->objectPrototype(),
+            JSC::TypeInfo(JSC::ObjectType, InternalFieldObject::StructureFlags),
+            InternalFieldObject::info()));
+    });
+}
+
+template<typename Visitor>
+void ObjectTemplate::visitChildrenImpl(JSCell* cell, Visitor& visitor)
+{
+    ObjectTemplate* tmp = jsCast<ObjectTemplate*>(cell);
+    ASSERT_GC_OBJECT_INHERITS(tmp, info());
+    Base::visitChildren(tmp, visitor);
+
+    tmp->m_objectStructure.visit(visitor);
+}
+
+DEFINE_VISIT_CHILDREN(ObjectTemplate);
+
+Structure* ObjectTemplate::createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+{
+    return Structure::create(
+        vm,
+        globalObject,
+        prototype,
+        JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags),
+        info());
+}
+
+InternalFieldObject* ObjectTemplate::newInstance()
+{
+    auto* structure = m_objectStructure.get(this);
+    auto* newInstance = InternalFieldObject::create(globalObject()->vm(), structure, m_internalFieldCount);
+    // todo: apply properties
+    return newInstance;
+}
+
+} // namespace shim
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/shim/ObjectTemplate.h b/src/bun.js/bindings/v8/shim/ObjectTemplate.h
new file mode 100644
index 0000000000..85be1790e8
--- /dev/null
+++ b/src/bun.js/bindings/v8/shim/ObjectTemplate.h
@@ -0,0 +1,61 @@
+#pragma once
+
+#include "JavaScriptCore/SubspaceAccess.h"
+#include "../v8/V8Template.h"
+#include "InternalFieldObject.h"
+
+namespace v8 {
+
+class ObjectTemplate;
+
+namespace shim {
+
+class ObjectTemplate : public JSC::InternalFunction {
+public:
+    using Base = JSC::InternalFunction;
+
+    DECLARE_INFO;
+
+    static ObjectTemplate* create(JSC::VM& vm, JSC::Structure* structure);
+
+    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype);
+
+    template<typename, JSC::SubspaceAccess mode>
+    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+    {
+        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+            return nullptr;
+        return WebCore::subspaceForImpl<ObjectTemplate, WebCore::UseCustomHeapCellType::No>(
+            vm,
+            [](auto& spaces) { return spaces.m_clientSubspaceForObjectTemplate.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForObjectTemplate = std::forward<decltype(space)>(space); },
+            [](auto& spaces) { return spaces.m_subspaceForObjectTemplate.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_subspaceForObjectTemplate = std::forward<decltype(space)>(space); });
+    }
+
+    DECLARE_VISIT_CHILDREN;
+
+    InternalFieldObject* newInstance();
+
+    int internalFieldCount() const { return m_internalFieldCount; }
+
+    void setInternalFieldCount(int newInternalFieldCount) { m_internalFieldCount = newInternalFieldCount; }
+
+private:
+    // Number of internal fields to allocate space for on objects created by this template
+    int m_internalFieldCount = 0;
+    // Structure used to allocate objects with this template (different than
+    // GlobalInternals::m_objectTemplateStructure, which is the structure used to allocate object
+    // templates themselves)
+    JSC::LazyProperty<ObjectTemplate, JSC::Structure> m_objectStructure;
+
+    ObjectTemplate(JSC::VM& vm, JSC::Structure* structure)
+        : Base(vm, structure, Template::DummyCallback, Template::DummyCallback)
+    {
+    }
+
+    void finishCreation(JSC::VM& vm);
+};
+
+} // namespace shim
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/shim/Oddball.cpp b/src/bun.js/bindings/v8/shim/Oddball.cpp
new file mode 100644
index 0000000000..55e50512af
--- /dev/null
+++ b/src/bun.js/bindings/v8/shim/Oddball.cpp
@@ -0,0 +1,18 @@
+#include "Oddball.h"
+#include "real_v8.h"
+
+#define CHECK_ODDBALL_KIND(KIND)                                                                         \
+    static_assert((int)v8::shim::Oddball::Kind::KIND == real_v8::internal::Internals::KIND##OddballKind, \
+        "Oddball kind " #KIND " does not match V8");
+
+// true and false are unchecked, as those are only defined by class v8::internal::Oddball in
+// src/objects/oddball.h which is not included in the API headers. I haven't seen a case where an
+// inline function relies on those values. For now, we intentionally *don't* match V8's kind values
+// for true and false so that an error will be apparent if V8 ever does rely on them.
+CHECK_ODDBALL_KIND(kNull)
+CHECK_ODDBALL_KIND(kUndefined)
+
+static_assert(offsetof(v8::shim::Oddball, m_map) == real_v8::internal::Internals::kHeapObjectMapOffset,
+    "Oddball map field is at wrong offset");
+
+static_assert(offsetof(v8::shim::Oddball, m_kind) == real_v8::internal::Internals::kOddballKindOffset);
diff --git a/src/bun.js/bindings/v8/shim/Oddball.h b/src/bun.js/bindings/v8/shim/Oddball.h
new file mode 100644
index 0000000000..e445e5ead8
--- /dev/null
+++ b/src/bun.js/bindings/v8/shim/Oddball.h
@@ -0,0 +1,52 @@
+#pragma once
+
+#include "TaggedPointer.h"
+#include "Map.h"
+#include "JavaScriptCore/JSCJSValue.h"
+
+namespace v8 {
+namespace shim {
+
+struct Oddball {
+    enum class Kind : int {
+        kUndefined = 4,
+        kNull = 3,
+        kInvalid = 255,
+        kTrue = 99,
+        kFalse = 98,
+    };
+
+    TaggedPointer m_map;
+    uintptr_t m_unused[4];
+    TaggedPointer m_kind;
+
+    Oddball(Kind kind)
+        : m_map(const_cast<Map*>(&Map::oddball_map))
+        , m_kind(TaggedPointer(static_cast<int>(kind)))
+    {
+    }
+
+    Kind kind() const
+    {
+        return (Kind)m_kind.getSmiUnchecked();
+    }
+
+    JSC::JSValue toJSValue() const
+    {
+        switch (kind()) {
+        case Kind::kUndefined:
+            return JSC::jsUndefined();
+        case Kind::kNull:
+            return JSC::jsNull();
+        case Kind::kTrue:
+            return JSC::jsBoolean(true);
+        case Kind::kFalse:
+            return JSC::jsBoolean(false);
+        default:
+            RELEASE_ASSERT_NOT_REACHED();
+        }
+    }
+};
+
+} // namespace shim
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/shim/TaggedPointer.cpp b/src/bun.js/bindings/v8/shim/TaggedPointer.cpp
new file mode 100644
index 0000000000..eb0e786899
--- /dev/null
+++ b/src/bun.js/bindings/v8/shim/TaggedPointer.cpp
@@ -0,0 +1,8 @@
+#include "TaggedPointer.h"
+#include "../real_v8.h"
+
+static_assert(sizeof(v8::shim::TaggedPointer) == sizeof(real_v8::internal::Address),
+    "TaggedPointer has wrong size");
+
+static_assert(alignof(v8::shim::TaggedPointer) == alignof(real_v8::internal::Address),
+    "TaggedPointer has wrong alignment");
diff --git a/src/bun.js/bindings/v8/shim/TaggedPointer.h b/src/bun.js/bindings/v8/shim/TaggedPointer.h
new file mode 100644
index 0000000000..a11cac1bd7
--- /dev/null
+++ b/src/bun.js/bindings/v8/shim/TaggedPointer.h
@@ -0,0 +1,98 @@
+#pragma once
+
+#include "wtf/Assertions.h"
+#include <cstdint>
+
+namespace JSC {
+class JSCell;
+}
+
+namespace v8 {
+namespace shim {
+
+struct TaggedPointer {
+private:
+    uintptr_t m_value;
+
+public:
+    enum class Tag : uint8_t {
+        Smi = 0,
+        StrongPointer = 1,
+        WeakPointer = 3,
+    };
+
+    static constexpr uintptr_t TagMask = 0b11;
+
+    // empty
+    TaggedPointer()
+        : TaggedPointer(nullptr) {};
+    TaggedPointer(const TaggedPointer&) = default;
+    TaggedPointer& operator=(const TaggedPointer&) = default;
+    bool operator==(const TaggedPointer& other) const { return m_value == other.m_value; }
+
+    TaggedPointer(void* ptr, bool weak = false)
+        : m_value(reinterpret_cast<uintptr_t>(ptr) | static_cast<uintptr_t>(weak ? Tag::WeakPointer : Tag::StrongPointer))
+    {
+        // check original pointer was aligned
+        RELEASE_ASSERT((reinterpret_cast<uintptr_t>(ptr) & TagMask) == 0);
+    }
+
+    TaggedPointer(int32_t smi)
+        : m_value((static_cast<uintptr_t>(smi) << 32) | static_cast<uintptr_t>(Tag::Smi))
+    {
+    }
+
+    // Convert the raw integer representation of a tagged pointer into a TaggedPointer struct
+    static TaggedPointer fromRaw(uintptr_t raw)
+    {
+        TaggedPointer tagged;
+        tagged.m_value = raw;
+        return tagged;
+    }
+
+    bool isEmpty() const
+    {
+        return *this == TaggedPointer();
+    }
+
+    // Get a pointer to where this TaggedPointer is located (use ->asRawPtrLocation() to reinterpret
+    // TaggedPointer* as uintptr_t*)
+    uintptr_t* asRawPtrLocation()
+    {
+        return &m_value;
+    }
+
+    Tag tag() const
+    {
+        return static_cast<Tag>(m_value & TagMask);
+    }
+
+    template<typename T = JSC::JSCell> T* getPtr() const
+    {
+        if (tag() == Tag::Smi) {
+            return nullptr;
+        }
+        return reinterpret_cast<T*>(m_value & ~TagMask);
+    }
+
+    bool getSmi(int32_t& smi) const
+    {
+        if (tag() != Tag::Smi) {
+            return false;
+        }
+        smi = static_cast<int32_t>(m_value >> 32);
+        return true;
+    }
+
+    int32_t getSmiUnchecked() const
+    {
+        ASSERT(tag() == Tag::Smi);
+        return static_cast<int32_t>(m_value >> 32);
+    }
+};
+
+} // namespace shim
+
+using shim::TaggedPointer;
+
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/v8.h b/src/bun.js/bindings/v8/v8.h
index fd8d672e04..8ed2c62f8a 100644
--- a/src/bun.js/bindings/v8/v8.h
+++ b/src/bun.js/bindings/v8/v8.h
@@ -12,5 +12,11 @@
         Bun__panic(utf8.data(), utf8.length());                                                                     \
     } while (0)
 
+// Use only for types and functions that are exposed in the public V8 API
 namespace v8 {
+
+// Use for types added to Bun to support V8 APIs that aren't used in the actual V8 API
+namespace shim {
 }
+
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/v8_api_internal.cpp b/src/bun.js/bindings/v8/v8_api_internal.cpp
index f610051696..8f45b84073 100644
--- a/src/bun.js/bindings/v8/v8_api_internal.cpp
+++ b/src/bun.js/bindings/v8/v8_api_internal.cpp
@@ -1,8 +1,10 @@
 #include "v8_api_internal.h"
 #include "V8Isolate.h"
-#include "V8HandleScopeBuffer.h"
+#include "shim/HandleScopeBuffer.h"
+#include "shim/GlobalInternals.h"
 
 namespace v8 {
+
 namespace api_internal {
 
 void ToLocalEmpty()
@@ -10,10 +12,17 @@ void ToLocalEmpty()
     BUN_PANIC("Attempt to unwrap an empty v8::MaybeLocal");
 }
 
-uintptr_t* GlobalizeReference(v8::internal::Isolate* isolate, uintptr_t address)
+void FromJustIsNothing()
 {
-    auto* globalHandles = reinterpret_cast<Isolate*>(isolate)->globalInternals()->globalHandles();
-    return &globalHandles->createHandleFromExistingHandle(TaggedPointer::fromRaw(address))->value;
+    BUN_PANIC("Attempt to call FromJust on an empty v8::Maybe");
+}
+
+uintptr_t* GlobalizeReference(internal::Isolate* i_isolate, uintptr_t address)
+{
+    auto* isolate = reinterpret_cast<Isolate*>(i_isolate);
+    auto* globalHandles = isolate->globalInternals()->globalHandles();
+    TaggedPointer* newSlot = globalHandles->createHandleFromExistingObject(TaggedPointer::fromRaw(address), isolate);
+    return newSlot->asRawPtrLocation();
 }
 
 void DisposeGlobal(uintptr_t* location)
@@ -22,5 +31,5 @@ void DisposeGlobal(uintptr_t* location)
     (void)location;
 }
 
-}
-}
+} // namespace api_internal
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/v8_api_internal.h b/src/bun.js/bindings/v8/v8_api_internal.h
index ec3fa7347b..df54422290 100644
--- a/src/bun.js/bindings/v8/v8_api_internal.h
+++ b/src/bun.js/bindings/v8/v8_api_internal.h
@@ -7,8 +7,9 @@ namespace v8 {
 namespace api_internal {
 
 BUN_EXPORT void ToLocalEmpty();
+BUN_EXPORT void FromJustIsNothing();
 BUN_EXPORT uintptr_t* GlobalizeReference(v8::internal::Isolate* isolate, uintptr_t address);
 BUN_EXPORT void DisposeGlobal(uintptr_t* location);
 
-}
-}
+} // namespace api_internal
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/v8_compatibility_assertions.h b/src/bun.js/bindings/v8/v8_compatibility_assertions.h
new file mode 100644
index 0000000000..0abfff025d
--- /dev/null
+++ b/src/bun.js/bindings/v8/v8_compatibility_assertions.h
@@ -0,0 +1,54 @@
+#pragma once
+
+// This file defines macros to check compatibility between types from V8 and types from Bun's V8
+// implementation. The same warning as in real_v8.h applies: only include this in source files in
+// the v8 directory.
+
+#include "real_v8.h"
+
+#define V8_TYPE_ASSERTIONS_NAMESPACE_NAME_INDIRECT(LINE) V8TypeAssertions__##LINE
+
+#define V8_TYPE_ASSERTIONS_NAMESPACE_NAME(LINE) \
+    V8_TYPE_ASSERTIONS_NAMESPACE_NAME_INDIRECT(LINE)
+
+// usage: [*outside* namespace v8] ASSERT_V8_TYPE_LAYOUT_MATCHES(v8::SomeTemplate<v8::SomeParam>)
+#define ASSERT_V8_TYPE_LAYOUT_MATCHES(TYPENAME)                                       \
+    namespace V8_TYPE_ASSERTIONS_NAMESPACE_NAME(__LINE__) {                           \
+    namespace DeclareBunType {                                                        \
+    namespace v8 = ::v8;                                                              \
+    using BunType = TYPENAME;                                                         \
+    }                                                                                 \
+                                                                                      \
+    namespace DeclareV8Type {                                                         \
+    namespace v8 = ::real_v8;                                                         \
+    using V8Type = TYPENAME;                                                          \
+    }                                                                                 \
+                                                                                      \
+    static_assert(sizeof(DeclareBunType::BunType) == sizeof(DeclareV8Type::V8Type),   \
+        "size of " #TYPENAME " does not match between Bun and V8");                   \
+    static_assert(alignof(DeclareBunType::BunType) == alignof(DeclareV8Type::V8Type), \
+        "alignment of " #TYPENAME " does not match between Bun and V8");              \
+    }
+
+// usage: [*outside* namespace v8] ASSERT_V8_TYPE_FIELD_OFFSET_MATCHES(v8::Maybe<int>, m_hasValue, has_value_)
+#define ASSERT_V8_TYPE_FIELD_OFFSET_MATCHES(TYPENAME, BUN_FIELD_NAME, V8_FIELD_NAME)       \
+    namespace V8_TYPE_ASSERTIONS_NAMESPACE_NAME(__LINE__) {                                \
+    namespace DeclareBunType {                                                             \
+    namespace v8 = ::v8;                                                                   \
+    using BunType = TYPENAME;                                                              \
+    }                                                                                      \
+                                                                                           \
+    namespace DeclareV8Type {                                                              \
+    namespace v8 = ::real_v8;                                                              \
+    using V8Type = TYPENAME;                                                               \
+    }                                                                                      \
+                                                                                           \
+    static_assert(offsetof(DeclareBunType::BunType, BUN_FIELD_NAME)                        \
+            == offsetof(DeclareV8Type::V8Type, V8_FIELD_NAME),                             \
+        "offset of " #TYPENAME "::" #BUN_FIELD_NAME " does not match between Bun and V8"); \
+    }
+
+// usage: [*outside* namespace v8] ASSERT_V8_ENUM_MATCHES(ConstructorBehavior, kAllow)
+#define ASSERT_V8_ENUM_MATCHES(ENUM_NAME, ENUMERATOR_NAME)                                             \
+    static_assert((int)::v8::ENUM_NAME::ENUMERATOR_NAME == (int)::real_v8::ENUM_NAME::ENUMERATOR_NAME, \
+        "enumerator " #ENUM_NAME "::" #ENUMERATOR_NAME " does not match between Bun and V8");
diff --git a/src/bun.js/bindings/v8/v8_internal.cpp b/src/bun.js/bindings/v8/v8_internal.cpp
index 4f4ce03da4..784433c844 100644
--- a/src/bun.js/bindings/v8/v8_internal.cpp
+++ b/src/bun.js/bindings/v8/v8_internal.cpp
@@ -9,5 +9,5 @@ Isolate* IsolateFromNeverReadOnlySpaceObject(uintptr_t obj)
     return nullptr;
 }
 
-}
-}
+} // namespace internal
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/v8_internal.h b/src/bun.js/bindings/v8/v8_internal.h
index da9be2b59b..472ae4c17f 100644
--- a/src/bun.js/bindings/v8/v8_internal.h
+++ b/src/bun.js/bindings/v8/v8_internal.h
@@ -5,9 +5,10 @@
 namespace v8 {
 namespace internal {
 
+// identical to v8::Isolate
 class Isolate {};
 
 BUN_EXPORT Isolate* IsolateFromNeverReadOnlySpaceObject(uintptr_t obj);
 
-}
-}
+} // namespace internal
+} // namespace v8
diff --git a/src/bun.js/bindings/v8/v8config.h b/src/bun.js/bindings/v8/v8config.h
new file mode 100644
index 0000000000..f32a4d6635
--- /dev/null
+++ b/src/bun.js/bindings/v8/v8config.h
@@ -0,0 +1,3 @@
+// This only exists so that files from the real V8 implementation can include it, without us having
+// to add vendor/nodejs/include/node to the include path (as that would conflict with our V8 functions)
+#include "node/v8config.h"
diff --git a/src/bun.js/bindings/webcore/AbortSignal.cpp b/src/bun.js/bindings/webcore/AbortSignal.cpp
index d26816c01e..b279d8d451 100644
--- a/src/bun.js/bindings/webcore/AbortSignal.cpp
+++ b/src/bun.js/bindings/webcore/AbortSignal.cpp
@@ -65,15 +65,11 @@ Ref<AbortSignal> AbortSignal::timeout(ScriptExecutionContext& context, uint64_t
     auto signal = adoptRef(*new AbortSignal(&context));
     signal->setHasActiveTimeoutTimer(true);
     auto action = [signal](ScriptExecutionContext& context) mutable {
-        signal->setHasActiveTimeoutTimer(false);
-
-        auto* globalObject = JSC::jsCast<JSDOMGlobalObject*>(context.jsGlobalObject());
-        if (!globalObject)
-            return;
-
+        auto* globalObject = defaultGlobalObject(context.globalObject());
         auto& vm = globalObject->vm();
         Locker locker { vm.apiLock() };
         signal->signalAbort(toJS(globalObject, globalObject, DOMException::create(TimeoutError)));
+        signal->setHasActiveTimeoutTimer(false);
     };
 
     if (milliseconds == 0) {
diff --git a/src/bun.js/bindings/webcore/AbortSignal.h b/src/bun.js/bindings/webcore/AbortSignal.h
index 788d1c6c94..b603145ce3 100644
--- a/src/bun.js/bindings/webcore/AbortSignal.h
+++ b/src/bun.js/bindings/webcore/AbortSignal.h
@@ -106,6 +106,7 @@ public:
     void incrementPendingActivityCount() { ++pendingActivityCount; }
     void decrementPendingActivityCount() { --pendingActivityCount; }
     bool hasPendingActivity() const { return pendingActivityCount > 0; }
+    bool isDependent() const { return m_isDependent; }
 
 private:
     enum class Aborted : bool {
@@ -116,7 +117,6 @@ private:
 
     void setHasActiveTimeoutTimer(bool hasActiveTimeoutTimer) { m_hasActiveTimeoutTimer = hasActiveTimeoutTimer; }
 
-    bool isDependent() const { return m_isDependent; }
     void markAsDependent() { m_isDependent = true; }
     void addSourceSignal(AbortSignal&);
     void addDependentSignal(AbortSignal&);
diff --git a/src/bun.js/bindings/webcore/DOMClientIsoSubspaces.h b/src/bun.js/bindings/webcore/DOMClientIsoSubspaces.h
index 79da6f30f0..b1b5d8f6c6 100644
--- a/src/bun.js/bindings/webcore/DOMClientIsoSubspaces.h
+++ b/src/bun.js/bindings/webcore/DOMClientIsoSubspaces.h
@@ -50,6 +50,13 @@ public:
     std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForNAPIFunction;
     std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForTTYWrapObject;
     std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForNapiHandleScopeImpl;
+    std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForNapiTypeTag;
+    std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForObjectTemplate;
+    std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForInternalFieldObject;
+    std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForV8GlobalInternals;
+    std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForHandleScopeBuffer;
+    std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForFunctionTemplate;
+    std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForV8Function;
 #include "ZigGeneratedClasses+DOMClientIsoSubspaces.h"
     /* --- bun --- */
 
@@ -691,9 +698,9 @@ public:
     std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForPerformanceObserver;
     std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForPerformanceObserverEntryList;
     // std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForPerformancePaintTiming;
-    // std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForPerformanceResourceTiming;
-    // std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForPerformanceServerTiming;
     std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForPerformanceTiming;
+    std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForPerformanceResourceTiming;
+    std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForPerformanceServerTiming;
     // std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForRemoteDOMWindow;
     // std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForResizeObserver;
     // std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForResizeObserverEntry;
@@ -900,7 +907,7 @@ public:
     // std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForXPathResult;
     // std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForXSLTProcessor;
 
-    std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForKitGlobalScope;
+    std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForBakeGlobalScope;
 
     std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForAbortController;
     std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForAbortSignal;
@@ -909,12 +916,5 @@ public:
     std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForEventListener;
     std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForEventTarget;
     std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForEventEmitter;
-    // todo(@190n) move these up or move these elsewhere
-    std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForObjectTemplate;
-    std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForInternalFieldObject;
-    std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForV8GlobalInternals;
-    std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForHandleScopeBuffer;
-    std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForFunctionTemplate;
-    std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForV8Function;
 };
 } // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/DOMIsoSubspaces.h b/src/bun.js/bindings/webcore/DOMIsoSubspaces.h
index 27bd00eab7..6d8792cb6d 100644
--- a/src/bun.js/bindings/webcore/DOMIsoSubspaces.h
+++ b/src/bun.js/bindings/webcore/DOMIsoSubspaces.h
@@ -50,6 +50,13 @@ public:
     std::unique_ptr<IsoSubspace> m_subspaceForNAPIFunction;
     std::unique_ptr<IsoSubspace> m_subspaceForTTYWrapObject;
     std::unique_ptr<IsoSubspace> m_subspaceForNapiHandleScopeImpl;
+    std::unique_ptr<IsoSubspace> m_subspaceForNapiTypeTag;
+    std::unique_ptr<IsoSubspace> m_subspaceForObjectTemplate;
+    std::unique_ptr<IsoSubspace> m_subspaceForInternalFieldObject;
+    std::unique_ptr<IsoSubspace> m_subspaceForV8GlobalInternals;
+    std::unique_ptr<IsoSubspace> m_subspaceForHandleScopeBuffer;
+    std::unique_ptr<IsoSubspace> m_subspaceForFunctionTemplate;
+    std::unique_ptr<IsoSubspace> m_subspaceForV8Function;
 
 #include "ZigGeneratedClasses+DOMIsoSubspaces.h"
     /*-- BUN --*/
@@ -684,8 +691,8 @@ public:
     std::unique_ptr<IsoSubspace> m_subspaceForPerformanceObserver;
     std::unique_ptr<IsoSubspace> m_subspaceForPerformanceObserverEntryList;
     // std::unique_ptr<IsoSubspace> m_subspaceForPerformancePaintTiming;
-    // std::unique_ptr<IsoSubspace> m_subspaceForPerformanceResourceTiming;
-    // std::unique_ptr<IsoSubspace> m_subspaceForPerformanceServerTiming;
+    std::unique_ptr<IsoSubspace> m_subspaceForPerformanceResourceTiming;
+    std::unique_ptr<IsoSubspace> m_subspaceForPerformanceServerTiming;
     std::unique_ptr<IsoSubspace> m_subspaceForPerformanceTiming;
     // std::unique_ptr<IsoSubspace> m_subspaceForRemoteDOMWindow;
     // std::unique_ptr<IsoSubspace> m_subspaceForResizeObserver;
@@ -892,8 +899,8 @@ public:
     // std::unique_ptr<IsoSubspace> m_subspaceForXPathNSResolver;
     // std::unique_ptr<IsoSubspace> m_subspaceForXPathResult;
     // std::unique_ptr<IsoSubspace> m_subspaceForXSLTProcessor;
-    
-    std::unique_ptr<IsoSubspace> m_subspaceForKitGlobalScope;
+
+    std::unique_ptr<IsoSubspace> m_subspaceForBakeGlobalScope;
 
     std::unique_ptr<IsoSubspace> m_subspaceForAbortController;
     std::unique_ptr<IsoSubspace> m_subspaceForAbortSignal;
@@ -913,13 +920,6 @@ public:
     // std::unique_ptr<IsoSubspace> m_subspaceForDOMFormData;
     // std::unique_ptr<IsoSubspace> m_subspaceForDOMFormDataIterator;
     std::unique_ptr<IsoSubspace> m_subspaceForDOMURL;
-    // todo(@190n) move up
-    std::unique_ptr<IsoSubspace> m_subspaceForObjectTemplate;
-    std::unique_ptr<IsoSubspace> m_subspaceForInternalFieldObject;
-    std::unique_ptr<IsoSubspace> m_subspaceForV8GlobalInternals;
-    std::unique_ptr<IsoSubspace> m_subspaceForHandleScopeBuffer;
-    std::unique_ptr<IsoSubspace> m_subspaceForFunctionTemplate;
-    std::unique_ptr<IsoSubspace> m_subspaceForV8Function;
 };
 } // namespace WebCore
 
diff --git a/src/bun.js/bindings/webcore/EventNames.h b/src/bun.js/bindings/webcore/EventNames.h
index 5458cc6f14..bc6f291f38 100644
--- a/src/bun.js/bindings/webcore/EventNames.h
+++ b/src/bun.js/bindings/webcore/EventNames.h
@@ -29,15 +29,16 @@
 
 namespace WebCore {
 
-#define DOM_EVENT_NAMES_FOR_EACH(macro)   \
-    macro(error)                          \
-        macro(abort)                      \
-            macro(close)                  \
-                macro(open)               \
-                    macro(rename)         \
-                        macro(message)    \
-                            macro(change) \
-                                macro(messageerror)
+#define DOM_EVENT_NAMES_FOR_EACH(macro)             \
+    macro(error)                                    \
+        macro(abort)                                \
+            macro(close)                            \
+                macro(open)                         \
+                    macro(rename)                   \
+                        macro(message)              \
+                            macro(change)           \
+                                macro(messageerror) \
+                                    macro(resourcetimingbufferfull)
 
 struct EventNames {
     WTF_MAKE_NONCOPYABLE(EventNames);
diff --git a/src/bun.js/bindings/webcore/FetchHeaders.cpp b/src/bun.js/bindings/webcore/FetchHeaders.cpp
index 127f6d29a1..f50fdc8923 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 8e3713539b..e28db4f966 100644
--- a/src/bun.js/bindings/webcore/FetchHeaders.h
+++ b/src/bun.js/bindings/webcore/FetchHeaders.h
@@ -71,12 +71,12 @@ public:
 
     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 37b7ffb4e4..42db45a00f 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 0000000000..ffbd358965
--- /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/HeaderFieldTokenizer.cpp b/src/bun.js/bindings/webcore/HeaderFieldTokenizer.cpp
new file mode 100644
index 0000000000..29eae31ad3
--- /dev/null
+++ b/src/bun.js/bindings/webcore/HeaderFieldTokenizer.cpp
@@ -0,0 +1,123 @@
+/*
+ * Copyright 2017 The Chromium Authors. All rights reserved.
+ * Copyright (C) 2018 Akamai Technologies Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "HeaderFieldTokenizer.h"
+
+#include "RFC7230.h"
+#include <wtf/text/StringBuilder.h>
+
+namespace WebCore {
+
+HeaderFieldTokenizer::HeaderFieldTokenizer(const String& headerField)
+    : m_input(headerField)
+{
+    skipSpaces();
+}
+
+bool HeaderFieldTokenizer::consume(UChar c)
+{
+    ASSERT(!isTabOrSpace(c));
+
+    if (isConsumed() || m_input[m_index] != c)
+        return false;
+
+    ++m_index;
+    skipSpaces();
+    return true;
+}
+
+String HeaderFieldTokenizer::consumeQuotedString()
+{
+    StringBuilder builder;
+
+    ASSERT(m_input[m_index] == '"');
+    ++m_index;
+
+    while (!isConsumed()) {
+        if (m_input[m_index] == '"') {
+            String output = builder.toString();
+            ++m_index;
+            skipSpaces();
+            return output;
+        }
+        if (m_input[m_index] == '\\') {
+            ++m_index;
+            if (isConsumed())
+                return String();
+        }
+        builder.append(m_input[m_index]);
+        ++m_index;
+    }
+    return String();
+}
+
+String HeaderFieldTokenizer::consumeToken()
+{
+    auto start = m_index;
+    while (!isConsumed() && RFC7230::isTokenCharacter(m_input[m_index]))
+        ++m_index;
+
+    if (start == m_index)
+        return String();
+
+    String output = m_input.substring(start, m_index - start);
+    skipSpaces();
+    return output;
+}
+
+String HeaderFieldTokenizer::consumeTokenOrQuotedString()
+{
+    if (isConsumed())
+        return String();
+
+    if (m_input[m_index] == '"')
+        return consumeQuotedString();
+
+    return consumeToken();
+}
+
+void HeaderFieldTokenizer::skipSpaces()
+{
+    while (!isConsumed() && isTabOrSpace(m_input[m_index]))
+        ++m_index;
+}
+
+void HeaderFieldTokenizer::consumeBeforeAnyCharMatch(const Vector<UChar>& chars)
+{
+    ASSERT(chars.size() > 0U && chars.size() < 3U);
+
+    while (!isConsumed()) {
+        for (const auto& c : chars) {
+            if (c == m_input[m_index])
+                return;
+        }
+
+        ++m_index;
+    }
+}
+
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/HeaderFieldTokenizer.h b/src/bun.js/bindings/webcore/HeaderFieldTokenizer.h
new file mode 100644
index 0000000000..fe29f409ff
--- /dev/null
+++ b/src/bun.js/bindings/webcore/HeaderFieldTokenizer.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2017 The Chromium Authors. All rights reserved.
+ * Copyright (C) 2018 Akamai Technologies Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include <wtf/text/WTFString.h>
+
+namespace WebCore {
+
+// Parses header fields into tokens, quoted strings and separators.
+// Commonly used by ParsedContent* classes.
+class HeaderFieldTokenizer {
+
+public:
+    explicit HeaderFieldTokenizer(const String&);
+
+    // Try to parse a separator character, a token or either a token or a quoted
+    // string from the |header_field| input. Return |true| on success. Return
+    // |false| if the separator character, the token or the quoted string is
+    // missing or invalid.
+    bool consume(UChar);
+    String consumeToken();
+    String consumeTokenOrQuotedString();
+
+    // Consume all characters before (but excluding) any of the characters from
+    // the Vector parameter are found.
+    // Because we potentially have to iterate through the entire Vector for each
+    // character of the base string, the Vector should be small (< 3 members).
+    void consumeBeforeAnyCharMatch(const Vector<UChar>&);
+
+    bool isConsumed() const { return m_index >= m_input.length(); }
+
+private:
+    String consumeQuotedString();
+    void skipSpaces();
+
+    unsigned m_index = 0;
+    const String m_input;
+};
+
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/JSAbortSignalCustom.cpp b/src/bun.js/bindings/webcore/JSAbortSignalCustom.cpp
index 01cee8eecf..ddb54dab50 100644
--- a/src/bun.js/bindings/webcore/JSAbortSignalCustom.cpp
+++ b/src/bun.js/bindings/webcore/JSAbortSignalCustom.cpp
@@ -54,10 +54,12 @@ bool JSAbortSignalOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> ha
                 *reason = "Has Timeout And Abort Event Listener"_s;
             return true;
         }
-        if (!abortSignal.sourceSignals().isEmptyIgnoringNullReferences()) {
-            if (UNLIKELY(reason))
-                *reason = "Has Source Signals And Abort Event Listener"_s;
-            return true;
+        if (abortSignal.isDependent()) {
+            if (!abortSignal.sourceSignals().isEmptyIgnoringNullReferences()) {
+                if (UNLIKELY(reason))
+                    *reason = "Has Source Signals And Abort Event Listener"_s;
+                return true;
+            }
         }
 
         // https://github.com/oven-sh/bun/issues/4517
diff --git a/src/bun.js/bindings/webcore/JSDOMConvertStrings.cpp b/src/bun.js/bindings/webcore/JSDOMConvertStrings.cpp
index d5ae213042..53003fa258 100644
--- a/src/bun.js/bindings/webcore/JSDOMConvertStrings.cpp
+++ b/src/bun.js/bindings/webcore/JSDOMConvertStrings.cpp
@@ -117,4 +117,4 @@ AtomString valueToUSVAtomString(JSGlobalObject& lexicalGlobalObject, JSValue val
     return replaceUnpairedSurrogatesWithReplacementCharacter(WTFMove(string));
 }
 
-} // namespace WebCore
\ No newline at end of file
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/JSDOMGuardedObject.cpp b/src/bun.js/bindings/webcore/JSDOMGuardedObject.cpp
index 863fbb7385..13cc800b24 100644
--- a/src/bun.js/bindings/webcore/JSDOMGuardedObject.cpp
+++ b/src/bun.js/bindings/webcore/JSDOMGuardedObject.cpp
@@ -74,4 +74,4 @@ void DOMGuardedObject::contextDestroyed()
     clear();
 }
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/webcore/JSDOMIterator.cpp b/src/bun.js/bindings/webcore/JSDOMIterator.cpp
index 0bc957e177..4dc57d5e65 100644
--- a/src/bun.js/bindings/webcore/JSDOMIterator.cpp
+++ b/src/bun.js/bindings/webcore/JSDOMIterator.cpp
@@ -52,4 +52,4 @@ void addValueIterableMethods(JSC::JSGlobalObject& globalObject, JSC::JSObject& p
     copyProperty(vm.propertyNames->builtinNames().valuesPrivateName(), vm.propertyNames->builtinNames().valuesPublicName());
 }
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/webcore/JSDOMOperation.cpp b/src/bun.js/bindings/webcore/JSDOMOperation.cpp
index 1c1b40e951..4aa4a8b626 100644
--- a/src/bun.js/bindings/webcore/JSDOMOperation.cpp
+++ b/src/bun.js/bindings/webcore/JSDOMOperation.cpp
@@ -42,4 +42,4 @@ void throwNodeRangeError(JSGlobalObject* lexicalGlobalObject, ThrowScope& scope,
     }
 }
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/webcore/JSEventTarget.cpp b/src/bun.js/bindings/webcore/JSEventTarget.cpp
index c2d75bc90a..a4d9590ca1 100644
--- a/src/bun.js/bindings/webcore/JSEventTarget.cpp
+++ b/src/bun.js/bindings/webcore/JSEventTarget.cpp
@@ -345,3 +345,20 @@ void JSEventTargetOwner::finalize(JSC::Handle<JSC::Unknown> handle, void* contex
 }
 
 }
+
+JSC_DEFINE_HOST_FUNCTION(jsEventTargetGetEventListenersCount, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame* callFrame))
+{
+    JSC::VM& vm = JSC::getVM(lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto* thisValue = jsDynamicCast<WebCore::JSEventTarget*>(callFrame->argument(0));
+    if (!thisValue) {
+        return JSC::JSValue::encode(JSC::jsNumber(0));
+    }
+
+    JSC::JSString* eventName = callFrame->argument(1).toString(lexicalGlobalObject);
+    RETURN_IF_EXCEPTION(throwScope, {});
+    String str = eventName->value(lexicalGlobalObject);
+    RETURN_IF_EXCEPTION(throwScope, {});
+    auto size = thisValue->wrapped().eventListeners(makeAtomString(str)).size();
+    return JSC::JSValue::encode(JSC::jsNumber(size));
+}
diff --git a/src/bun.js/bindings/webcore/JSEventTarget.h b/src/bun.js/bindings/webcore/JSEventTarget.h
index 3d1badcefe..f8b2f99d14 100644
--- a/src/bun.js/bindings/webcore/JSEventTarget.h
+++ b/src/bun.js/bindings/webcore/JSEventTarget.h
@@ -101,4 +101,7 @@ template<> struct JSDOMWrapperConverterTraits<EventTarget> {
 };
 
 } // namespace WebCore
+
+JSC_DECLARE_HOST_FUNCTION(jsEventTargetGetEventListenersCount);
+
 #include "JSEventTargetCustom.h"
diff --git a/src/bun.js/bindings/webcore/JSEventTargetNode.cpp b/src/bun.js/bindings/webcore/JSEventTargetNode.cpp
index b278c74492..7fc9eec1d3 100644
--- a/src/bun.js/bindings/webcore/JSEventTargetNode.cpp
+++ b/src/bun.js/bindings/webcore/JSEventTargetNode.cpp
@@ -44,4 +44,4 @@ JSC_DEFINE_HOST_FUNCTION(jsFunctionNodeEventsGetEventListeners, (JSGlobalObject
     return JSValue::encode(constructArray(globalObject, static_cast<ArrayAllocationProfile*>(nullptr), values));
 }
 
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/bindings/webcore/JSPerformance.cpp b/src/bun.js/bindings/webcore/JSPerformance.cpp
index f9e252644d..c9ae3699f2 100644
--- a/src/bun.js/bindings/webcore/JSPerformance.cpp
+++ b/src/bun.js/bindings/webcore/JSPerformance.cpp
@@ -85,8 +85,8 @@ static JSC_DECLARE_HOST_FUNCTION(jsPerformancePrototypeFunction_getEntries);
 static JSC_DECLARE_HOST_FUNCTION(jsPerformancePrototypeFunction_getEntriesByType);
 static JSC_DECLARE_HOST_FUNCTION(jsPerformancePrototypeFunction_getEntriesByName);
 
-// static JSC_DECLARE_HOST_FUNCTION(jsPerformancePrototypeFunction_clearResourceTimings);
-// static JSC_DECLARE_HOST_FUNCTION(jsPerformancePrototypeFunction_setResourceTimingBufferSize);
+static JSC_DECLARE_HOST_FUNCTION(jsPerformancePrototypeFunction_clearResourceTimings);
+static JSC_DECLARE_HOST_FUNCTION(jsPerformancePrototypeFunction_setResourceTimingBufferSize);
 
 static JSC_DECLARE_HOST_FUNCTION(jsPerformancePrototypeFunction_mark);
 static JSC_DECLARE_HOST_FUNCTION(jsPerformancePrototypeFunction_clearMarks);
@@ -102,8 +102,8 @@ static JSC_DECLARE_CUSTOM_GETTER(jsPerformanceConstructor);
 
 // static JSC_DECLARE_CUSTOM_GETTER(jsPerformance_navigation);
 static JSC_DECLARE_CUSTOM_GETTER(jsPerformance_timing);
-// static JSC_DECLARE_CUSTOM_GETTER(jsPerformance_onresourcetimingbufferfull);
-// static JSC_DECLARE_CUSTOM_SETTER(setJSPerformance_onresourcetimingbufferfull);
+static JSC_DECLARE_CUSTOM_GETTER(jsPerformance_onresourcetimingbufferfull);
+static JSC_DECLARE_CUSTOM_SETTER(setJSPerformance_onresourcetimingbufferfull);
 
 // -- copied --
 
@@ -138,6 +138,12 @@ JSC_DEFINE_JIT_OPERATION(functionPerformanceNowWithoutTypeCheck, JSC::EncodedJSV
     return { functionPerformanceNowBody(vm) };
 }
 
+JSC_DEFINE_HOST_FUNCTION(jsPerformancePrototypeFunction_markResourceTiming, (JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    // TODO:
+    return JSValue::encode(jsUndefined());
+}
+
 // -- end copied --
 
 class JSPerformancePrototype final : public JSC::JSNonFinalObject {
@@ -197,18 +203,23 @@ static const HashTableValue JSPerformancePrototypeTableValues[] = {
     // { "timeOrigin"_s, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPerformance_timeOrigin, 0 } },
     // { "navigation"_s, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPerformance_navigation, 0 } },
     { "timing"_s, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPerformance_timing, 0 } },
-    // { "onresourcetimingbufferfull"_s, JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPerformance_onresourcetimingbufferfull, setJSPerformance_onresourcetimingbufferfull } },
+    { "onresourcetimingbufferfull"_s, JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPerformance_onresourcetimingbufferfull, setJSPerformance_onresourcetimingbufferfull } },
     // { "now"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPerformancePrototypeFunction_now, 0 } },
     { "toJSON"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPerformancePrototypeFunction_toJSON, 0 } },
     { "getEntries"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPerformancePrototypeFunction_getEntries, 0 } },
     { "getEntriesByType"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPerformancePrototypeFunction_getEntriesByType, 1 } },
     { "getEntriesByName"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPerformancePrototypeFunction_getEntriesByName, 1 } },
-    // { "clearResourceTimings"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPerformancePrototypeFunction_clearResourceTimings, 0 } },
-    // { "setResourceTimingBufferSize"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPerformancePrototypeFunction_setResourceTimingBufferSize, 1 } },
+    { "clearResourceTimings"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPerformancePrototypeFunction_clearResourceTimings, 0 } },
+    { "setResourceTimingBufferSize"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPerformancePrototypeFunction_setResourceTimingBufferSize, 1 } },
     { "mark"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPerformancePrototypeFunction_mark, 1 } },
     { "clearMarks"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPerformancePrototypeFunction_clearMarks, 0 } },
     { "measure"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPerformancePrototypeFunction_measure, 1 } },
     { "clearMeasures"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPerformancePrototypeFunction_clearMeasures, 0 } },
+
+    /**
+     * Node.js compatibility
+     */
+    { "markResourceTiming"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPerformancePrototypeFunction_markResourceTiming, 7 } },
 };
 
 const ClassInfo JSPerformancePrototype::s_info = { "Performance"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSPerformancePrototype) };
@@ -337,32 +348,32 @@ JSC_DEFINE_CUSTOM_GETTER(jsPerformance_timing, (JSGlobalObject * lexicalGlobalOb
     return IDLAttribute<JSPerformance>::get<jsPerformance_timingGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
 }
 
-// static inline JSValue jsPerformance_onresourcetimingbufferfullGetter(JSGlobalObject& lexicalGlobalObject, JSPerformance& thisObject)
-// {
-//     UNUSED_PARAM(lexicalGlobalObject);
-//     return eventHandlerAttribute(thisObject.wrapped(), eventNames().resourcetimingbufferfullEvent, worldForDOMObject(thisObject));
-// }
+static inline JSValue jsPerformance_onresourcetimingbufferfullGetter(JSGlobalObject& lexicalGlobalObject, JSPerformance& thisObject)
+{
+    UNUSED_PARAM(lexicalGlobalObject);
+    return eventHandlerAttribute(thisObject.wrapped(), eventNames().resourcetimingbufferfullEvent, worldForDOMObject(thisObject));
+}
 
-// JSC_DEFINE_CUSTOM_GETTER(jsPerformance_onresourcetimingbufferfull, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
-// {
-//     return IDLAttribute<JSPerformance>::get<jsPerformance_onresourcetimingbufferfullGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
-// }
+JSC_DEFINE_CUSTOM_GETTER(jsPerformance_onresourcetimingbufferfull, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    return IDLAttribute<JSPerformance>::get<jsPerformance_onresourcetimingbufferfullGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
+}
 
-// static inline bool setJSPerformance_onresourcetimingbufferfullSetter(JSGlobalObject& lexicalGlobalObject, JSPerformance& thisObject, JSValue value)
-// {
-//     auto& vm = JSC::getVM(&lexicalGlobalObject);
-//     UNUSED_PARAM(vm);
-//     setEventHandlerAttribute<JSEventListener>(thisObject.wrapped(), eventNames().resourcetimingbufferfullEvent, value, thisObject);
-//     vm.writeBarrier(&thisObject, value);
-//     ensureStillAliveHere(value);
+static inline bool setJSPerformance_onresourcetimingbufferfullSetter(JSGlobalObject& lexicalGlobalObject, JSPerformance& thisObject, JSValue value)
+{
+    auto& vm = JSC::getVM(&lexicalGlobalObject);
+    UNUSED_PARAM(vm);
+    setEventHandlerAttribute<JSEventListener>(thisObject.wrapped(), eventNames().resourcetimingbufferfullEvent, value, thisObject);
+    vm.writeBarrier(&thisObject, value);
+    ensureStillAliveHere(value);
 
-//     return true;
-// }
+    return true;
+}
 
-// JSC_DEFINE_CUSTOM_SETTER(setJSPerformance_onresourcetimingbufferfull, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
-// {
-//     return IDLAttribute<JSPerformance>::set<setJSPerformance_onresourcetimingbufferfullSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
-// }
+JSC_DEFINE_CUSTOM_SETTER(setJSPerformance_onresourcetimingbufferfull, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
+{
+    return IDLAttribute<JSPerformance>::set<setJSPerformance_onresourcetimingbufferfullSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
+}
 
 // static inline JSC::EncodedJSValue jsPerformancePrototypeFunction_nowBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPerformance>::ClassParameter castedThis)
 // {
@@ -395,9 +406,9 @@ static inline EncodedJSValue jsPerformancePrototypeFunction_toJSONBody(JSGlobalO
     //     result->putDirect(vm, Identifier::fromString(vm, "navigation"_s), navigationValue);
     // }
     // if ((castedThis->globalObject())->inherits<JSDOMWindowBase>()) {
-    //     auto timingValue = toJS<IDLInterface<PerformanceTiming>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.timing());
-    //     RETURN_IF_EXCEPTION(throwScope, { });
-    //     result->putDirect(vm, Identifier::fromString(vm, "timing"_s), timingValue);
+    auto timingValue = toJS<IDLInterface<PerformanceTiming>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.timing());
+    RETURN_IF_EXCEPTION(throwScope, {});
+    result->putDirect(vm, Identifier::fromString(vm, "timing"_s), timingValue);
     // }
     return JSValue::encode(result);
 }
@@ -465,40 +476,40 @@ JSC_DEFINE_HOST_FUNCTION(jsPerformancePrototypeFunction_getEntriesByName, (JSGlo
     return IDLOperation<JSPerformance>::call<jsPerformancePrototypeFunction_getEntriesByNameBody>(*lexicalGlobalObject, *callFrame, "getEntriesByName");
 }
 
-// static inline JSC::EncodedJSValue jsPerformancePrototypeFunction_clearResourceTimingsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPerformance>::ClassParameter castedThis)
-// {
-//     auto& vm = JSC::getVM(lexicalGlobalObject);
-//     auto throwScope = DECLARE_THROW_SCOPE(vm);
-//     UNUSED_PARAM(throwScope);
-//     UNUSED_PARAM(callFrame);
-//     auto& impl = castedThis->wrapped();
-//     RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.clearResourceTimings(); })));
-// }
+static inline JSC::EncodedJSValue jsPerformancePrototypeFunction_clearResourceTimingsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPerformance>::ClassParameter castedThis)
+{
+    auto& vm = JSC::getVM(lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    UNUSED_PARAM(throwScope);
+    UNUSED_PARAM(callFrame);
+    auto& impl = castedThis->wrapped();
+    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.clearResourceTimings(); })));
+}
 
-// JSC_DEFINE_HOST_FUNCTION(jsPerformancePrototypeFunction_clearResourceTimings, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
-// {
-//     return IDLOperation<JSPerformance>::call<jsPerformancePrototypeFunction_clearResourceTimingsBody>(*lexicalGlobalObject, *callFrame, "clearResourceTimings");
-// }
+JSC_DEFINE_HOST_FUNCTION(jsPerformancePrototypeFunction_clearResourceTimings, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+{
+    return IDLOperation<JSPerformance>::call<jsPerformancePrototypeFunction_clearResourceTimingsBody>(*lexicalGlobalObject, *callFrame, "clearResourceTimings");
+}
 
-// static inline JSC::EncodedJSValue jsPerformancePrototypeFunction_setResourceTimingBufferSizeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPerformance>::ClassParameter castedThis)
-// {
-//     auto& vm = JSC::getVM(lexicalGlobalObject);
-//     auto throwScope = DECLARE_THROW_SCOPE(vm);
-//     UNUSED_PARAM(throwScope);
-//     UNUSED_PARAM(callFrame);
-//     auto& impl = castedThis->wrapped();
-//     if (UNLIKELY(callFrame->argumentCount() < 1))
-//         return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
-//     EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
-//     auto maxSize = convert<IDLUnsignedLong>(*lexicalGlobalObject, argument0.value());
-//     RETURN_IF_EXCEPTION(throwScope, {});
-//     RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setResourceTimingBufferSize(WTFMove(maxSize)); })));
-// }
+static inline JSC::EncodedJSValue jsPerformancePrototypeFunction_setResourceTimingBufferSizeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPerformance>::ClassParameter castedThis)
+{
+    auto& vm = JSC::getVM(lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    UNUSED_PARAM(throwScope);
+    UNUSED_PARAM(callFrame);
+    auto& impl = castedThis->wrapped();
+    if (UNLIKELY(callFrame->argumentCount() < 1))
+        return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
+    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
+    auto maxSize = convert<IDLUnsignedLong>(*lexicalGlobalObject, argument0.value());
+    RETURN_IF_EXCEPTION(throwScope, {});
+    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setResourceTimingBufferSize(WTFMove(maxSize)); })));
+}
 
-// JSC_DEFINE_HOST_FUNCTION(jsPerformancePrototypeFunction_setResourceTimingBufferSize, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
-// {
-//     return IDLOperation<JSPerformance>::call<jsPerformancePrototypeFunction_setResourceTimingBufferSizeBody>(*lexicalGlobalObject, *callFrame, "setResourceTimingBufferSize");
-// }
+JSC_DEFINE_HOST_FUNCTION(jsPerformancePrototypeFunction_setResourceTimingBufferSize, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+{
+    return IDLOperation<JSPerformance>::call<jsPerformancePrototypeFunction_setResourceTimingBufferSizeBody>(*lexicalGlobalObject, *callFrame, "setResourceTimingBufferSize");
+}
 
 static inline JSC::EncodedJSValue jsPerformancePrototypeFunction_markBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPerformance>::ClassParameter castedThis)
 {
diff --git a/src/bun.js/bindings/webcore/JSPerformanceResourceTiming.cpp b/src/bun.js/bindings/webcore/JSPerformanceResourceTiming.cpp
new file mode 100644
index 0000000000..a77a899d7e
--- /dev/null
+++ b/src/bun.js/bindings/webcore/JSPerformanceResourceTiming.cpp
@@ -0,0 +1,536 @@
+/*
+    This file is part of the WebKit open source project.
+    This file has been generated by generate-bindings.pl. DO NOT MODIFY!
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+
+#include "config.h"
+#include "JSPerformanceResourceTiming.h"
+
+#include "ActiveDOMObject.h"
+#include "ExtendedDOMClientIsoSubspaces.h"
+#include "ExtendedDOMIsoSubspaces.h"
+#include "JSDOMAttribute.h"
+#include "JSDOMBinding.h"
+#include "JSDOMConstructorNotConstructable.h"
+#include "JSDOMConvertInterface.h"
+#include "JSDOMConvertNumbers.h"
+#include "JSDOMConvertSequences.h"
+#include "JSDOMConvertStrings.h"
+#include "JSDOMExceptionHandling.h"
+#include "JSDOMGlobalObject.h"
+#include "JSDOMGlobalObjectInlines.h"
+#include "JSDOMOperation.h"
+#include "JSDOMWrapperCache.h"
+#include "JSPerformanceServerTiming.h"
+#include "ScriptExecutionContext.h"
+#include "WebCoreJSClientData.h"
+#include <JavaScriptCore/HeapAnalyzer.h>
+#include <JavaScriptCore/JSArray.h>
+#include <JavaScriptCore/JSCInlines.h>
+#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>
+#include <JavaScriptCore/ObjectConstructor.h>
+#include <JavaScriptCore/SlotVisitorMacros.h>
+#include <JavaScriptCore/SubspaceInlines.h>
+#include <wtf/GetPtr.h>
+#include <wtf/PointerPreparations.h>
+#include <wtf/URL.h>
+
+namespace WebCore {
+using namespace JSC;
+
+// Functions
+
+static JSC_DECLARE_HOST_FUNCTION(jsPerformanceResourceTimingPrototypeFunction_toJSON);
+
+// Attributes
+
+static JSC_DECLARE_CUSTOM_GETTER(jsPerformanceResourceTimingConstructor);
+static JSC_DECLARE_CUSTOM_GETTER(jsPerformanceResourceTiming_initiatorType);
+static JSC_DECLARE_CUSTOM_GETTER(jsPerformanceResourceTiming_nextHopProtocol);
+static JSC_DECLARE_CUSTOM_GETTER(jsPerformanceResourceTiming_workerStart);
+static JSC_DECLARE_CUSTOM_GETTER(jsPerformanceResourceTiming_redirectStart);
+static JSC_DECLARE_CUSTOM_GETTER(jsPerformanceResourceTiming_redirectEnd);
+static JSC_DECLARE_CUSTOM_GETTER(jsPerformanceResourceTiming_fetchStart);
+static JSC_DECLARE_CUSTOM_GETTER(jsPerformanceResourceTiming_domainLookupStart);
+static JSC_DECLARE_CUSTOM_GETTER(jsPerformanceResourceTiming_domainLookupEnd);
+static JSC_DECLARE_CUSTOM_GETTER(jsPerformanceResourceTiming_connectStart);
+static JSC_DECLARE_CUSTOM_GETTER(jsPerformanceResourceTiming_connectEnd);
+static JSC_DECLARE_CUSTOM_GETTER(jsPerformanceResourceTiming_secureConnectionStart);
+static JSC_DECLARE_CUSTOM_GETTER(jsPerformanceResourceTiming_requestStart);
+static JSC_DECLARE_CUSTOM_GETTER(jsPerformanceResourceTiming_responseStart);
+static JSC_DECLARE_CUSTOM_GETTER(jsPerformanceResourceTiming_responseEnd);
+static JSC_DECLARE_CUSTOM_GETTER(jsPerformanceResourceTiming_transferSize);
+static JSC_DECLARE_CUSTOM_GETTER(jsPerformanceResourceTiming_encodedBodySize);
+static JSC_DECLARE_CUSTOM_GETTER(jsPerformanceResourceTiming_decodedBodySize);
+static JSC_DECLARE_CUSTOM_GETTER(jsPerformanceResourceTiming_serverTiming);
+
+class JSPerformanceResourceTimingPrototype final : public JSC::JSNonFinalObject {
+public:
+    using Base = JSC::JSNonFinalObject;
+    static JSPerformanceResourceTimingPrototype* create(JSC::VM& vm, JSDOMGlobalObject* globalObject, JSC::Structure* structure)
+    {
+        JSPerformanceResourceTimingPrototype* ptr = new (NotNull, JSC::allocateCell<JSPerformanceResourceTimingPrototype>(vm)) JSPerformanceResourceTimingPrototype(vm, globalObject, structure);
+        ptr->finishCreation(vm);
+        return ptr;
+    }
+
+    DECLARE_INFO;
+    template<typename CellType, JSC::SubspaceAccess>
+    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+    {
+        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSPerformanceResourceTimingPrototype, Base);
+        return &vm.plainObjectSpace();
+    }
+    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+    {
+        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+    }
+
+private:
+    JSPerformanceResourceTimingPrototype(JSC::VM& vm, JSC::JSGlobalObject*, JSC::Structure* structure)
+        : JSC::JSNonFinalObject(vm, structure)
+    {
+    }
+
+    void finishCreation(JSC::VM&);
+};
+STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSPerformanceResourceTimingPrototype, JSPerformanceResourceTimingPrototype::Base);
+
+using JSPerformanceResourceTimingDOMConstructor = JSDOMConstructorNotConstructable<JSPerformanceResourceTiming>;
+
+template<> const ClassInfo JSPerformanceResourceTimingDOMConstructor::s_info = { "PerformanceResourceTiming"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSPerformanceResourceTimingDOMConstructor) };
+
+template<> JSValue JSPerformanceResourceTimingDOMConstructor::prototypeForStructure(JSC::VM& vm, const JSDOMGlobalObject& globalObject)
+{
+    return JSPerformanceEntry::getConstructor(vm, &globalObject);
+}
+
+template<> void JSPerformanceResourceTimingDOMConstructor::initializeProperties(VM& vm, JSDOMGlobalObject& globalObject)
+{
+    putDirect(vm, vm.propertyNames->length, jsNumber(0), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
+    JSString* nameString = jsNontrivialString(vm, "PerformanceResourceTiming"_s);
+    m_originalName.set(vm, this, nameString);
+    putDirect(vm, vm.propertyNames->name, nameString, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
+    putDirect(vm, vm.propertyNames->prototype, JSPerformanceResourceTiming::prototype(vm, globalObject), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::DontDelete);
+}
+
+/* Hash table for prototype */
+
+static const HashTableValue JSPerformanceResourceTimingPrototypeTableValues[] = {
+    { "constructor"_s, static_cast<unsigned>(PropertyAttribute::DontEnum), NoIntrinsic, { HashTableValue::GetterSetterType, jsPerformanceResourceTimingConstructor, 0 } },
+    { "initiatorType"_s, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPerformanceResourceTiming_initiatorType, 0 } },
+    { "nextHopProtocol"_s, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPerformanceResourceTiming_nextHopProtocol, 0 } },
+    { "workerStart"_s, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPerformanceResourceTiming_workerStart, 0 } },
+    { "redirectStart"_s, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPerformanceResourceTiming_redirectStart, 0 } },
+    { "redirectEnd"_s, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPerformanceResourceTiming_redirectEnd, 0 } },
+    { "fetchStart"_s, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPerformanceResourceTiming_fetchStart, 0 } },
+    { "domainLookupStart"_s, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPerformanceResourceTiming_domainLookupStart, 0 } },
+    { "domainLookupEnd"_s, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPerformanceResourceTiming_domainLookupEnd, 0 } },
+    { "connectStart"_s, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPerformanceResourceTiming_connectStart, 0 } },
+    { "connectEnd"_s, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPerformanceResourceTiming_connectEnd, 0 } },
+    { "secureConnectionStart"_s, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPerformanceResourceTiming_secureConnectionStart, 0 } },
+    { "requestStart"_s, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPerformanceResourceTiming_requestStart, 0 } },
+    { "responseStart"_s, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPerformanceResourceTiming_responseStart, 0 } },
+    { "responseEnd"_s, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPerformanceResourceTiming_responseEnd, 0 } },
+    { "transferSize"_s, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPerformanceResourceTiming_transferSize, 0 } },
+    { "encodedBodySize"_s, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPerformanceResourceTiming_encodedBodySize, 0 } },
+    { "decodedBodySize"_s, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPerformanceResourceTiming_decodedBodySize, 0 } },
+    { "serverTiming"_s, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPerformanceResourceTiming_serverTiming, 0 } },
+    { "toJSON"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPerformanceResourceTimingPrototypeFunction_toJSON, 0 } },
+};
+
+const ClassInfo JSPerformanceResourceTimingPrototype::s_info = { "PerformanceResourceTiming"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSPerformanceResourceTimingPrototype) };
+
+void JSPerformanceResourceTimingPrototype::finishCreation(VM& vm)
+{
+    Base::finishCreation(vm);
+    reifyStaticProperties(vm, JSPerformanceResourceTiming::info(), JSPerformanceResourceTimingPrototypeTableValues, *this);
+    JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
+}
+
+const ClassInfo JSPerformanceResourceTiming::s_info = { "PerformanceResourceTiming"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSPerformanceResourceTiming) };
+
+JSPerformanceResourceTiming::JSPerformanceResourceTiming(Structure* structure, JSDOMGlobalObject& globalObject, Ref<PerformanceResourceTiming>&& impl)
+    : JSPerformanceEntry(structure, globalObject, WTFMove(impl))
+{
+}
+
+Ref<PerformanceResourceTiming> JSPerformanceResourceTiming::protectedWrapped() const
+{
+    return wrapped();
+}
+
+// static_assert(!std::is_base_of<ActiveDOMObject, PerformanceResourceTiming>::value, "Interface is not marked as [ActiveDOMObject] even though implementation class subclasses ActiveDOMObject.");
+
+JSObject* JSPerformanceResourceTiming::createPrototype(VM& vm, JSDOMGlobalObject& globalObject)
+{
+    auto* structure = JSPerformanceResourceTimingPrototype::createStructure(vm, &globalObject, JSPerformanceEntry::prototype(vm, globalObject));
+    structure->setMayBePrototype(true);
+    return JSPerformanceResourceTimingPrototype::create(vm, &globalObject, structure);
+}
+
+JSObject* JSPerformanceResourceTiming::prototype(VM& vm, JSDOMGlobalObject& globalObject)
+{
+    return getDOMPrototype<JSPerformanceResourceTiming>(vm, globalObject);
+}
+
+JSValue JSPerformanceResourceTiming::getConstructor(VM& vm, const JSGlobalObject* globalObject)
+{
+    return getDOMConstructor<JSPerformanceResourceTimingDOMConstructor, DOMConstructorID::PerformanceResourceTiming>(vm, *jsCast<const JSDOMGlobalObject*>(globalObject));
+}
+
+JSC_DEFINE_CUSTOM_GETTER(jsPerformanceResourceTimingConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
+{
+    auto& vm = JSC::getVM(lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto* prototype = jsDynamicCast<JSPerformanceResourceTimingPrototype*>(JSValue::decode(thisValue));
+    if (UNLIKELY(!prototype))
+        return throwVMTypeError(lexicalGlobalObject, throwScope);
+    return JSValue::encode(JSPerformanceResourceTiming::getConstructor(vm, prototype->globalObject()));
+}
+
+static inline JSValue jsPerformanceResourceTiming_initiatorTypeGetter(JSGlobalObject& lexicalGlobalObject, JSPerformanceResourceTiming& thisObject)
+{
+    auto& vm = JSC::getVM(&lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto& impl = thisObject.wrapped();
+    RELEASE_AND_RETURN(throwScope, (toJS<IDLDOMString>(lexicalGlobalObject, throwScope, impl.initiatorType())));
+}
+
+JSC_DEFINE_CUSTOM_GETTER(jsPerformanceResourceTiming_initiatorType, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    return IDLAttribute<JSPerformanceResourceTiming>::get<jsPerformanceResourceTiming_initiatorTypeGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
+}
+
+static inline JSValue jsPerformanceResourceTiming_nextHopProtocolGetter(JSGlobalObject& lexicalGlobalObject, JSPerformanceResourceTiming& thisObject)
+{
+    auto& vm = JSC::getVM(&lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto& impl = thisObject.wrapped();
+    RELEASE_AND_RETURN(throwScope, (toJS<IDLDOMString>(lexicalGlobalObject, throwScope, impl.nextHopProtocol())));
+}
+
+JSC_DEFINE_CUSTOM_GETTER(jsPerformanceResourceTiming_nextHopProtocol, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    return IDLAttribute<JSPerformanceResourceTiming>::get<jsPerformanceResourceTiming_nextHopProtocolGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
+}
+
+static inline JSValue jsPerformanceResourceTiming_workerStartGetter(JSGlobalObject& lexicalGlobalObject, JSPerformanceResourceTiming& thisObject)
+{
+    auto& vm = JSC::getVM(&lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto& impl = thisObject.wrapped();
+    RELEASE_AND_RETURN(throwScope, (toJS<IDLDouble>(lexicalGlobalObject, throwScope, impl.workerStart())));
+}
+
+JSC_DEFINE_CUSTOM_GETTER(jsPerformanceResourceTiming_workerStart, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    return IDLAttribute<JSPerformanceResourceTiming>::get<jsPerformanceResourceTiming_workerStartGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
+}
+
+static inline JSValue jsPerformanceResourceTiming_redirectStartGetter(JSGlobalObject& lexicalGlobalObject, JSPerformanceResourceTiming& thisObject)
+{
+    auto& vm = JSC::getVM(&lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto& impl = thisObject.wrapped();
+    RELEASE_AND_RETURN(throwScope, (toJS<IDLDouble>(lexicalGlobalObject, throwScope, impl.redirectStart())));
+}
+
+JSC_DEFINE_CUSTOM_GETTER(jsPerformanceResourceTiming_redirectStart, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    return IDLAttribute<JSPerformanceResourceTiming>::get<jsPerformanceResourceTiming_redirectStartGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
+}
+
+static inline JSValue jsPerformanceResourceTiming_redirectEndGetter(JSGlobalObject& lexicalGlobalObject, JSPerformanceResourceTiming& thisObject)
+{
+    auto& vm = JSC::getVM(&lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto& impl = thisObject.wrapped();
+    RELEASE_AND_RETURN(throwScope, (toJS<IDLDouble>(lexicalGlobalObject, throwScope, impl.redirectEnd())));
+}
+
+JSC_DEFINE_CUSTOM_GETTER(jsPerformanceResourceTiming_redirectEnd, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    return IDLAttribute<JSPerformanceResourceTiming>::get<jsPerformanceResourceTiming_redirectEndGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
+}
+
+static inline JSValue jsPerformanceResourceTiming_fetchStartGetter(JSGlobalObject& lexicalGlobalObject, JSPerformanceResourceTiming& thisObject)
+{
+    auto& vm = JSC::getVM(&lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto& impl = thisObject.wrapped();
+    RELEASE_AND_RETURN(throwScope, (toJS<IDLDouble>(lexicalGlobalObject, throwScope, impl.fetchStart())));
+}
+
+JSC_DEFINE_CUSTOM_GETTER(jsPerformanceResourceTiming_fetchStart, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    return IDLAttribute<JSPerformanceResourceTiming>::get<jsPerformanceResourceTiming_fetchStartGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
+}
+
+static inline JSValue jsPerformanceResourceTiming_domainLookupStartGetter(JSGlobalObject& lexicalGlobalObject, JSPerformanceResourceTiming& thisObject)
+{
+    auto& vm = JSC::getVM(&lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto& impl = thisObject.wrapped();
+    RELEASE_AND_RETURN(throwScope, (toJS<IDLDouble>(lexicalGlobalObject, throwScope, impl.domainLookupStart())));
+}
+
+JSC_DEFINE_CUSTOM_GETTER(jsPerformanceResourceTiming_domainLookupStart, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    return IDLAttribute<JSPerformanceResourceTiming>::get<jsPerformanceResourceTiming_domainLookupStartGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
+}
+
+static inline JSValue jsPerformanceResourceTiming_domainLookupEndGetter(JSGlobalObject& lexicalGlobalObject, JSPerformanceResourceTiming& thisObject)
+{
+    auto& vm = JSC::getVM(&lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto& impl = thisObject.wrapped();
+    RELEASE_AND_RETURN(throwScope, (toJS<IDLDouble>(lexicalGlobalObject, throwScope, impl.domainLookupEnd())));
+}
+
+JSC_DEFINE_CUSTOM_GETTER(jsPerformanceResourceTiming_domainLookupEnd, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    return IDLAttribute<JSPerformanceResourceTiming>::get<jsPerformanceResourceTiming_domainLookupEndGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
+}
+
+static inline JSValue jsPerformanceResourceTiming_connectStartGetter(JSGlobalObject& lexicalGlobalObject, JSPerformanceResourceTiming& thisObject)
+{
+    auto& vm = JSC::getVM(&lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto& impl = thisObject.wrapped();
+    RELEASE_AND_RETURN(throwScope, (toJS<IDLDouble>(lexicalGlobalObject, throwScope, impl.connectStart())));
+}
+
+JSC_DEFINE_CUSTOM_GETTER(jsPerformanceResourceTiming_connectStart, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    return IDLAttribute<JSPerformanceResourceTiming>::get<jsPerformanceResourceTiming_connectStartGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
+}
+
+static inline JSValue jsPerformanceResourceTiming_connectEndGetter(JSGlobalObject& lexicalGlobalObject, JSPerformanceResourceTiming& thisObject)
+{
+    auto& vm = JSC::getVM(&lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto& impl = thisObject.wrapped();
+    RELEASE_AND_RETURN(throwScope, (toJS<IDLDouble>(lexicalGlobalObject, throwScope, impl.connectEnd())));
+}
+
+JSC_DEFINE_CUSTOM_GETTER(jsPerformanceResourceTiming_connectEnd, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    return IDLAttribute<JSPerformanceResourceTiming>::get<jsPerformanceResourceTiming_connectEndGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
+}
+
+static inline JSValue jsPerformanceResourceTiming_secureConnectionStartGetter(JSGlobalObject& lexicalGlobalObject, JSPerformanceResourceTiming& thisObject)
+{
+    auto& vm = JSC::getVM(&lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto& impl = thisObject.wrapped();
+    RELEASE_AND_RETURN(throwScope, (toJS<IDLDouble>(lexicalGlobalObject, throwScope, impl.secureConnectionStart())));
+}
+
+JSC_DEFINE_CUSTOM_GETTER(jsPerformanceResourceTiming_secureConnectionStart, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    return IDLAttribute<JSPerformanceResourceTiming>::get<jsPerformanceResourceTiming_secureConnectionStartGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
+}
+
+static inline JSValue jsPerformanceResourceTiming_requestStartGetter(JSGlobalObject& lexicalGlobalObject, JSPerformanceResourceTiming& thisObject)
+{
+    auto& vm = JSC::getVM(&lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto& impl = thisObject.wrapped();
+    RELEASE_AND_RETURN(throwScope, (toJS<IDLDouble>(lexicalGlobalObject, throwScope, impl.requestStart())));
+}
+
+JSC_DEFINE_CUSTOM_GETTER(jsPerformanceResourceTiming_requestStart, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    return IDLAttribute<JSPerformanceResourceTiming>::get<jsPerformanceResourceTiming_requestStartGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
+}
+
+static inline JSValue jsPerformanceResourceTiming_responseStartGetter(JSGlobalObject& lexicalGlobalObject, JSPerformanceResourceTiming& thisObject)
+{
+    auto& vm = JSC::getVM(&lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto& impl = thisObject.wrapped();
+    RELEASE_AND_RETURN(throwScope, (toJS<IDLDouble>(lexicalGlobalObject, throwScope, impl.responseStart())));
+}
+
+JSC_DEFINE_CUSTOM_GETTER(jsPerformanceResourceTiming_responseStart, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    return IDLAttribute<JSPerformanceResourceTiming>::get<jsPerformanceResourceTiming_responseStartGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
+}
+
+static inline JSValue jsPerformanceResourceTiming_responseEndGetter(JSGlobalObject& lexicalGlobalObject, JSPerformanceResourceTiming& thisObject)
+{
+    auto& vm = JSC::getVM(&lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto& impl = thisObject.wrapped();
+    RELEASE_AND_RETURN(throwScope, (toJS<IDLDouble>(lexicalGlobalObject, throwScope, impl.responseEnd())));
+}
+
+JSC_DEFINE_CUSTOM_GETTER(jsPerformanceResourceTiming_responseEnd, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    return IDLAttribute<JSPerformanceResourceTiming>::get<jsPerformanceResourceTiming_responseEndGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
+}
+
+static inline JSValue jsPerformanceResourceTiming_transferSizeGetter(JSGlobalObject& lexicalGlobalObject, JSPerformanceResourceTiming& thisObject)
+{
+    auto& vm = JSC::getVM(&lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto& impl = thisObject.wrapped();
+    RELEASE_AND_RETURN(throwScope, (toJS<IDLUnsignedLongLong>(lexicalGlobalObject, throwScope, impl.transferSize())));
+}
+
+JSC_DEFINE_CUSTOM_GETTER(jsPerformanceResourceTiming_transferSize, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    return IDLAttribute<JSPerformanceResourceTiming>::get<jsPerformanceResourceTiming_transferSizeGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
+}
+
+static inline JSValue jsPerformanceResourceTiming_encodedBodySizeGetter(JSGlobalObject& lexicalGlobalObject, JSPerformanceResourceTiming& thisObject)
+{
+    auto& vm = JSC::getVM(&lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto& impl = thisObject.wrapped();
+    RELEASE_AND_RETURN(throwScope, (toJS<IDLUnsignedLongLong>(lexicalGlobalObject, throwScope, impl.encodedBodySize())));
+}
+
+JSC_DEFINE_CUSTOM_GETTER(jsPerformanceResourceTiming_encodedBodySize, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    return IDLAttribute<JSPerformanceResourceTiming>::get<jsPerformanceResourceTiming_encodedBodySizeGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
+}
+
+static inline JSValue jsPerformanceResourceTiming_decodedBodySizeGetter(JSGlobalObject& lexicalGlobalObject, JSPerformanceResourceTiming& thisObject)
+{
+    auto& vm = JSC::getVM(&lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto& impl = thisObject.wrapped();
+    RELEASE_AND_RETURN(throwScope, (toJS<IDLUnsignedLongLong>(lexicalGlobalObject, throwScope, impl.decodedBodySize())));
+}
+
+JSC_DEFINE_CUSTOM_GETTER(jsPerformanceResourceTiming_decodedBodySize, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    return IDLAttribute<JSPerformanceResourceTiming>::get<jsPerformanceResourceTiming_decodedBodySizeGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
+}
+
+static inline JSValue jsPerformanceResourceTiming_serverTimingGetter(JSGlobalObject& lexicalGlobalObject, JSPerformanceResourceTiming& thisObject)
+{
+    auto& vm = JSC::getVM(&lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto& impl = thisObject.wrapped();
+    RELEASE_AND_RETURN(throwScope, (toJS<IDLFrozenArray<IDLInterface<PerformanceServerTiming>>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.serverTiming())));
+}
+
+JSC_DEFINE_CUSTOM_GETTER(jsPerformanceResourceTiming_serverTiming, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    return IDLAttribute<JSPerformanceResourceTiming>::get<jsPerformanceResourceTiming_serverTimingGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
+}
+
+static inline EncodedJSValue jsPerformanceResourceTimingPrototypeFunction_toJSONBody(JSGlobalObject* lexicalGlobalObject, CallFrame*, JSPerformanceResourceTiming* castedThis)
+{
+    auto& vm = JSC::getVM(lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    UNUSED_PARAM(throwScope);
+    auto& impl = castedThis->wrapped();
+    auto* result = constructEmptyObject(lexicalGlobalObject);
+    auto nameValue = toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.name());
+    RETURN_IF_EXCEPTION(throwScope, {});
+    result->putDirect(vm, Identifier::fromString(vm, "name"_s), nameValue);
+    auto entryTypeValue = toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.entryType());
+    RETURN_IF_EXCEPTION(throwScope, {});
+    result->putDirect(vm, Identifier::fromString(vm, "entryType"_s), entryTypeValue);
+    auto startTimeValue = toJS<IDLDouble>(*lexicalGlobalObject, throwScope, impl.startTime());
+    RETURN_IF_EXCEPTION(throwScope, {});
+    result->putDirect(vm, Identifier::fromString(vm, "startTime"_s), startTimeValue);
+    auto durationValue = toJS<IDLDouble>(*lexicalGlobalObject, throwScope, impl.duration());
+    RETURN_IF_EXCEPTION(throwScope, {});
+    result->putDirect(vm, Identifier::fromString(vm, "duration"_s), durationValue);
+    auto initiatorTypeValue = toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.initiatorType());
+    RETURN_IF_EXCEPTION(throwScope, {});
+    result->putDirect(vm, Identifier::fromString(vm, "initiatorType"_s), initiatorTypeValue);
+    auto nextHopProtocolValue = toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.nextHopProtocol());
+    RETURN_IF_EXCEPTION(throwScope, {});
+    result->putDirect(vm, Identifier::fromString(vm, "nextHopProtocol"_s), nextHopProtocolValue);
+    auto workerStartValue = toJS<IDLDouble>(*lexicalGlobalObject, throwScope, impl.workerStart());
+    RETURN_IF_EXCEPTION(throwScope, {});
+    result->putDirect(vm, Identifier::fromString(vm, "workerStart"_s), workerStartValue);
+    auto redirectStartValue = toJS<IDLDouble>(*lexicalGlobalObject, throwScope, impl.redirectStart());
+    RETURN_IF_EXCEPTION(throwScope, {});
+    result->putDirect(vm, Identifier::fromString(vm, "redirectStart"_s), redirectStartValue);
+    auto redirectEndValue = toJS<IDLDouble>(*lexicalGlobalObject, throwScope, impl.redirectEnd());
+    RETURN_IF_EXCEPTION(throwScope, {});
+    result->putDirect(vm, Identifier::fromString(vm, "redirectEnd"_s), redirectEndValue);
+    auto fetchStartValue = toJS<IDLDouble>(*lexicalGlobalObject, throwScope, impl.fetchStart());
+    RETURN_IF_EXCEPTION(throwScope, {});
+    result->putDirect(vm, Identifier::fromString(vm, "fetchStart"_s), fetchStartValue);
+    auto domainLookupStartValue = toJS<IDLDouble>(*lexicalGlobalObject, throwScope, impl.domainLookupStart());
+    RETURN_IF_EXCEPTION(throwScope, {});
+    result->putDirect(vm, Identifier::fromString(vm, "domainLookupStart"_s), domainLookupStartValue);
+    auto domainLookupEndValue = toJS<IDLDouble>(*lexicalGlobalObject, throwScope, impl.domainLookupEnd());
+    RETURN_IF_EXCEPTION(throwScope, {});
+    result->putDirect(vm, Identifier::fromString(vm, "domainLookupEnd"_s), domainLookupEndValue);
+    auto connectStartValue = toJS<IDLDouble>(*lexicalGlobalObject, throwScope, impl.connectStart());
+    RETURN_IF_EXCEPTION(throwScope, {});
+    result->putDirect(vm, Identifier::fromString(vm, "connectStart"_s), connectStartValue);
+    auto connectEndValue = toJS<IDLDouble>(*lexicalGlobalObject, throwScope, impl.connectEnd());
+    RETURN_IF_EXCEPTION(throwScope, {});
+    result->putDirect(vm, Identifier::fromString(vm, "connectEnd"_s), connectEndValue);
+    auto secureConnectionStartValue = toJS<IDLDouble>(*lexicalGlobalObject, throwScope, impl.secureConnectionStart());
+    RETURN_IF_EXCEPTION(throwScope, {});
+    result->putDirect(vm, Identifier::fromString(vm, "secureConnectionStart"_s), secureConnectionStartValue);
+    auto requestStartValue = toJS<IDLDouble>(*lexicalGlobalObject, throwScope, impl.requestStart());
+    RETURN_IF_EXCEPTION(throwScope, {});
+    result->putDirect(vm, Identifier::fromString(vm, "requestStart"_s), requestStartValue);
+    auto responseStartValue = toJS<IDLDouble>(*lexicalGlobalObject, throwScope, impl.responseStart());
+    RETURN_IF_EXCEPTION(throwScope, {});
+    result->putDirect(vm, Identifier::fromString(vm, "responseStart"_s), responseStartValue);
+    auto responseEndValue = toJS<IDLDouble>(*lexicalGlobalObject, throwScope, impl.responseEnd());
+    RETURN_IF_EXCEPTION(throwScope, {});
+    result->putDirect(vm, Identifier::fromString(vm, "responseEnd"_s), responseEndValue);
+    auto transferSizeValue = toJS<IDLUnsignedLongLong>(*lexicalGlobalObject, throwScope, impl.transferSize());
+    RETURN_IF_EXCEPTION(throwScope, {});
+    result->putDirect(vm, Identifier::fromString(vm, "transferSize"_s), transferSizeValue);
+    auto encodedBodySizeValue = toJS<IDLUnsignedLongLong>(*lexicalGlobalObject, throwScope, impl.encodedBodySize());
+    RETURN_IF_EXCEPTION(throwScope, {});
+    result->putDirect(vm, Identifier::fromString(vm, "encodedBodySize"_s), encodedBodySizeValue);
+    auto decodedBodySizeValue = toJS<IDLUnsignedLongLong>(*lexicalGlobalObject, throwScope, impl.decodedBodySize());
+    RETURN_IF_EXCEPTION(throwScope, {});
+    result->putDirect(vm, Identifier::fromString(vm, "decodedBodySize"_s), decodedBodySizeValue);
+    auto serverTimingValue = toJS<IDLFrozenArray<IDLInterface<PerformanceServerTiming>>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.serverTiming());
+    RETURN_IF_EXCEPTION(throwScope, {});
+    result->putDirect(vm, Identifier::fromString(vm, "serverTiming"_s), serverTimingValue);
+    return JSValue::encode(result);
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsPerformanceResourceTimingPrototypeFunction_toJSON, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+{
+    return IDLOperation<JSPerformanceResourceTiming>::call<jsPerformanceResourceTimingPrototypeFunction_toJSONBody>(*lexicalGlobalObject, *callFrame, "toJSON");
+}
+
+JSC::GCClient::IsoSubspace* JSPerformanceResourceTiming::subspaceForImpl(JSC::VM& vm)
+{
+    return WebCore::subspaceForImpl<JSPerformanceResourceTiming, UseCustomHeapCellType::No>(vm, [](auto& spaces) { return spaces.m_clientSubspaceForPerformanceResourceTiming.get(); }, [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForPerformanceResourceTiming = std::forward<decltype(space)>(space); }, [](auto& spaces) { return spaces.m_subspaceForPerformanceResourceTiming.get(); }, [](auto& spaces, auto&& space) { spaces.m_subspaceForPerformanceResourceTiming = std::forward<decltype(space)>(space); });
+}
+
+void JSPerformanceResourceTiming::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
+{
+    auto* thisObject = jsCast<JSPerformanceResourceTiming*>(cell);
+    analyzer.setWrappedObjectForCell(cell, &thisObject->wrapped());
+    if (thisObject->scriptExecutionContext())
+        analyzer.setLabelForCell(cell, makeString("url "_s, thisObject->scriptExecutionContext()->url().string()));
+    Base::analyzeHeap(cell, analyzer);
+}
+
+}
diff --git a/src/bun.js/bindings/webcore/JSPerformanceResourceTiming.h b/src/bun.js/bindings/webcore/JSPerformanceResourceTiming.h
new file mode 100644
index 0000000000..fead6a3590
--- /dev/null
+++ b/src/bun.js/bindings/webcore/JSPerformanceResourceTiming.h
@@ -0,0 +1,78 @@
+/*
+    This file is part of the WebKit open source project.
+    This file has been generated by generate-bindings.pl. DO NOT MODIFY!
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+
+#pragma once
+
+#include "JSDOMWrapper.h"
+#include "JSPerformanceEntry.h"
+#include "PerformanceResourceTiming.h"
+
+namespace WebCore {
+
+class JSPerformanceResourceTiming : public JSPerformanceEntry {
+public:
+    using Base = JSPerformanceEntry;
+    using DOMWrapped = PerformanceResourceTiming;
+    static JSPerformanceResourceTiming* create(JSC::Structure* structure, JSDOMGlobalObject* globalObject, Ref<PerformanceResourceTiming>&& impl)
+    {
+        auto& vm = globalObject->vm();
+        JSPerformanceResourceTiming* ptr = new (NotNull, JSC::allocateCell<JSPerformanceResourceTiming>(vm)) JSPerformanceResourceTiming(structure, *globalObject, WTFMove(impl));
+        ptr->finishCreation(vm);
+        return ptr;
+    }
+
+    static JSC::JSObject* createPrototype(JSC::VM&, JSDOMGlobalObject&);
+    static JSC::JSObject* prototype(JSC::VM&, JSDOMGlobalObject&);
+
+    DECLARE_INFO;
+
+    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+    {
+        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info(), JSC::NonArray);
+    }
+
+    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);
+    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+    {
+        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+            return nullptr;
+        return subspaceForImpl(vm);
+    }
+    static JSC::GCClient::IsoSubspace* subspaceForImpl(JSC::VM& vm);
+    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+    PerformanceResourceTiming& wrapped() const
+    {
+        return static_cast<PerformanceResourceTiming&>(Base::wrapped());
+    }
+
+    Ref<PerformanceResourceTiming> protectedWrapped() const;
+
+protected:
+    JSPerformanceResourceTiming(JSC::Structure*, JSDOMGlobalObject&, Ref<PerformanceResourceTiming>&&);
+
+    DECLARE_DEFAULT_FINISH_CREATION;
+};
+
+template<> struct JSDOMWrapperConverterTraits<PerformanceResourceTiming> {
+    using WrapperClass = JSPerformanceResourceTiming;
+    using ToWrappedReturnType = PerformanceResourceTiming*;
+};
+
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/JSPerformanceServerTiming.cpp b/src/bun.js/bindings/webcore/JSPerformanceServerTiming.cpp
new file mode 100644
index 0000000000..65c10c2b4f
--- /dev/null
+++ b/src/bun.js/bindings/webcore/JSPerformanceServerTiming.cpp
@@ -0,0 +1,314 @@
+/*
+    This file is part of the WebKit open source project.
+    This file has been generated by generate-bindings.pl. DO NOT MODIFY!
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+
+#include "config.h"
+#include "JSPerformanceServerTiming.h"
+
+#include "ActiveDOMObject.h"
+#include "ExtendedDOMClientIsoSubspaces.h"
+#include "ExtendedDOMIsoSubspaces.h"
+#include "JSDOMAttribute.h"
+#include "JSDOMBinding.h"
+#include "JSDOMConstructorNotConstructable.h"
+#include "JSDOMConvertNumbers.h"
+#include "JSDOMConvertStrings.h"
+#include "JSDOMExceptionHandling.h"
+#include "JSDOMGlobalObjectInlines.h"
+#include "JSDOMOperation.h"
+#include "JSDOMWrapperCache.h"
+#include "ScriptExecutionContext.h"
+#include "WebCoreJSClientData.h"
+#include <JavaScriptCore/FunctionPrototype.h>
+#include <JavaScriptCore/HeapAnalyzer.h>
+#include <JavaScriptCore/JSCInlines.h>
+#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>
+#include <JavaScriptCore/ObjectConstructor.h>
+#include <JavaScriptCore/SlotVisitorMacros.h>
+#include <JavaScriptCore/SubspaceInlines.h>
+#include <wtf/GetPtr.h>
+#include <wtf/PointerPreparations.h>
+#include <wtf/URL.h>
+
+namespace WebCore {
+using namespace JSC;
+
+// Functions
+
+static JSC_DECLARE_HOST_FUNCTION(jsPerformanceServerTimingPrototypeFunction_toJSON);
+
+// Attributes
+
+static JSC_DECLARE_CUSTOM_GETTER(jsPerformanceServerTimingConstructor);
+static JSC_DECLARE_CUSTOM_GETTER(jsPerformanceServerTiming_name);
+static JSC_DECLARE_CUSTOM_GETTER(jsPerformanceServerTiming_duration);
+static JSC_DECLARE_CUSTOM_GETTER(jsPerformanceServerTiming_description);
+
+class JSPerformanceServerTimingPrototype final : public JSC::JSNonFinalObject {
+public:
+    using Base = JSC::JSNonFinalObject;
+    static JSPerformanceServerTimingPrototype* create(JSC::VM& vm, JSDOMGlobalObject* globalObject, JSC::Structure* structure)
+    {
+        JSPerformanceServerTimingPrototype* ptr = new (NotNull, JSC::allocateCell<JSPerformanceServerTimingPrototype>(vm)) JSPerformanceServerTimingPrototype(vm, globalObject, structure);
+        ptr->finishCreation(vm);
+        return ptr;
+    }
+
+    DECLARE_INFO;
+    template<typename CellType, JSC::SubspaceAccess>
+    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+    {
+        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSPerformanceServerTimingPrototype, Base);
+        return &vm.plainObjectSpace();
+    }
+    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+    {
+        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+    }
+
+private:
+    JSPerformanceServerTimingPrototype(JSC::VM& vm, JSC::JSGlobalObject*, JSC::Structure* structure)
+        : JSC::JSNonFinalObject(vm, structure)
+    {
+    }
+
+    void finishCreation(JSC::VM&);
+};
+STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSPerformanceServerTimingPrototype, JSPerformanceServerTimingPrototype::Base);
+
+using JSPerformanceServerTimingDOMConstructor = JSDOMConstructorNotConstructable<JSPerformanceServerTiming>;
+
+template<> const ClassInfo JSPerformanceServerTimingDOMConstructor::s_info = { "PerformanceServerTiming"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSPerformanceServerTimingDOMConstructor) };
+
+template<> JSValue JSPerformanceServerTimingDOMConstructor::prototypeForStructure(JSC::VM& vm, const JSDOMGlobalObject& globalObject)
+{
+    UNUSED_PARAM(vm);
+    return globalObject.functionPrototype();
+}
+
+template<> void JSPerformanceServerTimingDOMConstructor::initializeProperties(VM& vm, JSDOMGlobalObject& globalObject)
+{
+    putDirect(vm, vm.propertyNames->length, jsNumber(0), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
+    JSString* nameString = jsNontrivialString(vm, "PerformanceServerTiming"_s);
+    m_originalName.set(vm, this, nameString);
+    putDirect(vm, vm.propertyNames->name, nameString, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
+    putDirect(vm, vm.propertyNames->prototype, JSPerformanceServerTiming::prototype(vm, globalObject), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::DontDelete);
+}
+
+/* Hash table for prototype */
+
+static const HashTableValue JSPerformanceServerTimingPrototypeTableValues[] = {
+    { "constructor"_s, static_cast<unsigned>(PropertyAttribute::DontEnum), NoIntrinsic, { HashTableValue::GetterSetterType, jsPerformanceServerTimingConstructor, 0 } },
+    { "name"_s, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPerformanceServerTiming_name, 0 } },
+    { "duration"_s, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPerformanceServerTiming_duration, 0 } },
+    { "description"_s, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPerformanceServerTiming_description, 0 } },
+    { "toJSON"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPerformanceServerTimingPrototypeFunction_toJSON, 0 } },
+};
+
+const ClassInfo JSPerformanceServerTimingPrototype::s_info = { "PerformanceServerTiming"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSPerformanceServerTimingPrototype) };
+
+void JSPerformanceServerTimingPrototype::finishCreation(VM& vm)
+{
+    Base::finishCreation(vm);
+    reifyStaticProperties(vm, JSPerformanceServerTiming::info(), JSPerformanceServerTimingPrototypeTableValues, *this);
+    JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
+}
+
+const ClassInfo JSPerformanceServerTiming::s_info = { "PerformanceServerTiming"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSPerformanceServerTiming) };
+
+JSPerformanceServerTiming::JSPerformanceServerTiming(Structure* structure, JSDOMGlobalObject& globalObject, Ref<PerformanceServerTiming>&& impl)
+    : JSDOMWrapper<PerformanceServerTiming>(structure, globalObject, WTFMove(impl))
+{
+}
+
+// static_assert(!std::is_base_of<ActiveDOMObject, PerformanceServerTiming>::value, "Interface is not marked as [ActiveDOMObject] even though implementation class subclasses ActiveDOMObject.");
+
+JSObject* JSPerformanceServerTiming::createPrototype(VM& vm, JSDOMGlobalObject& globalObject)
+{
+    auto* structure = JSPerformanceServerTimingPrototype::createStructure(vm, &globalObject, globalObject.objectPrototype());
+    structure->setMayBePrototype(true);
+    return JSPerformanceServerTimingPrototype::create(vm, &globalObject, structure);
+}
+
+JSObject* JSPerformanceServerTiming::prototype(VM& vm, JSDOMGlobalObject& globalObject)
+{
+    return getDOMPrototype<JSPerformanceServerTiming>(vm, globalObject);
+}
+
+JSValue JSPerformanceServerTiming::getConstructor(VM& vm, const JSGlobalObject* globalObject)
+{
+    return getDOMConstructor<JSPerformanceServerTimingDOMConstructor, DOMConstructorID::PerformanceServerTiming>(vm, *jsCast<const JSDOMGlobalObject*>(globalObject));
+}
+
+void JSPerformanceServerTiming::destroy(JSC::JSCell* cell)
+{
+    JSPerformanceServerTiming* thisObject = static_cast<JSPerformanceServerTiming*>(cell);
+    thisObject->JSPerformanceServerTiming::~JSPerformanceServerTiming();
+}
+
+JSC_DEFINE_CUSTOM_GETTER(jsPerformanceServerTimingConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
+{
+    auto& vm = JSC::getVM(lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto* prototype = jsDynamicCast<JSPerformanceServerTimingPrototype*>(JSValue::decode(thisValue));
+    if (UNLIKELY(!prototype))
+        return throwVMTypeError(lexicalGlobalObject, throwScope);
+    return JSValue::encode(JSPerformanceServerTiming::getConstructor(vm, prototype->globalObject()));
+}
+
+static inline JSValue jsPerformanceServerTiming_nameGetter(JSGlobalObject& lexicalGlobalObject, JSPerformanceServerTiming& thisObject)
+{
+    auto& vm = JSC::getVM(&lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto& impl = thisObject.wrapped();
+    RELEASE_AND_RETURN(throwScope, (toJS<IDLDOMString>(lexicalGlobalObject, throwScope, impl.name())));
+}
+
+JSC_DEFINE_CUSTOM_GETTER(jsPerformanceServerTiming_name, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    return IDLAttribute<JSPerformanceServerTiming>::get<jsPerformanceServerTiming_nameGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
+}
+
+static inline JSValue jsPerformanceServerTiming_durationGetter(JSGlobalObject& lexicalGlobalObject, JSPerformanceServerTiming& thisObject)
+{
+    auto& vm = JSC::getVM(&lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto& impl = thisObject.wrapped();
+    RELEASE_AND_RETURN(throwScope, (toJS<IDLDouble>(lexicalGlobalObject, throwScope, impl.duration())));
+}
+
+JSC_DEFINE_CUSTOM_GETTER(jsPerformanceServerTiming_duration, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    return IDLAttribute<JSPerformanceServerTiming>::get<jsPerformanceServerTiming_durationGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
+}
+
+static inline JSValue jsPerformanceServerTiming_descriptionGetter(JSGlobalObject& lexicalGlobalObject, JSPerformanceServerTiming& thisObject)
+{
+    auto& vm = JSC::getVM(&lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto& impl = thisObject.wrapped();
+    RELEASE_AND_RETURN(throwScope, (toJS<IDLDOMString>(lexicalGlobalObject, throwScope, impl.description())));
+}
+
+JSC_DEFINE_CUSTOM_GETTER(jsPerformanceServerTiming_description, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    return IDLAttribute<JSPerformanceServerTiming>::get<jsPerformanceServerTiming_descriptionGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
+}
+
+static inline EncodedJSValue jsPerformanceServerTimingPrototypeFunction_toJSONBody(JSGlobalObject* lexicalGlobalObject, CallFrame*, JSPerformanceServerTiming* castedThis)
+{
+    auto& vm = JSC::getVM(lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    UNUSED_PARAM(throwScope);
+    auto& impl = castedThis->wrapped();
+    auto* result = constructEmptyObject(lexicalGlobalObject);
+    auto nameValue = toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.name());
+    RETURN_IF_EXCEPTION(throwScope, {});
+    result->putDirect(vm, Identifier::fromString(vm, "name"_s), nameValue);
+    auto durationValue = toJS<IDLDouble>(*lexicalGlobalObject, throwScope, impl.duration());
+    RETURN_IF_EXCEPTION(throwScope, {});
+    result->putDirect(vm, Identifier::fromString(vm, "duration"_s), durationValue);
+    auto descriptionValue = toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.description());
+    RETURN_IF_EXCEPTION(throwScope, {});
+    result->putDirect(vm, Identifier::fromString(vm, "description"_s), descriptionValue);
+    return JSValue::encode(result);
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsPerformanceServerTimingPrototypeFunction_toJSON, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+{
+    return IDLOperation<JSPerformanceServerTiming>::call<jsPerformanceServerTimingPrototypeFunction_toJSONBody>(*lexicalGlobalObject, *callFrame, "toJSON");
+}
+
+JSC::GCClient::IsoSubspace* JSPerformanceServerTiming::subspaceForImpl(JSC::VM& vm)
+{
+    return WebCore::subspaceForImpl<JSPerformanceServerTiming, UseCustomHeapCellType::No>(vm, [](auto& spaces) { return spaces.m_clientSubspaceForPerformanceServerTiming.get(); }, [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForPerformanceServerTiming = std::forward<decltype(space)>(space); }, [](auto& spaces) { return spaces.m_subspaceForPerformanceServerTiming.get(); }, [](auto& spaces, auto&& space) { spaces.m_subspaceForPerformanceServerTiming = std::forward<decltype(space)>(space); });
+}
+
+void JSPerformanceServerTiming::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
+{
+    auto* thisObject = jsCast<JSPerformanceServerTiming*>(cell);
+    analyzer.setWrappedObjectForCell(cell, &thisObject->wrapped());
+    if (thisObject->scriptExecutionContext())
+        analyzer.setLabelForCell(cell, makeString("url "_s, thisObject->scriptExecutionContext()->url().string()));
+    Base::analyzeHeap(cell, analyzer);
+}
+
+bool JSPerformanceServerTimingOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, AbstractSlotVisitor& visitor, ASCIILiteral* reason)
+{
+    UNUSED_PARAM(handle);
+    UNUSED_PARAM(visitor);
+    UNUSED_PARAM(reason);
+    return false;
+}
+
+void JSPerformanceServerTimingOwner::finalize(JSC::Handle<JSC::Unknown> handle, void* context)
+{
+    auto* jsPerformanceServerTiming = static_cast<JSPerformanceServerTiming*>(handle.slot()->asCell());
+    auto& world = *static_cast<DOMWrapperWorld*>(context);
+    uncacheWrapper(world, jsPerformanceServerTiming->protectedWrapped().ptr(), jsPerformanceServerTiming);
+}
+
+#if ENABLE(BINDING_INTEGRITY)
+#if PLATFORM(WIN)
+#pragma warning(disable : 4483)
+extern "C" {
+extern void (*const __identifier("??_7PerformanceServerTiming@WebCore@@6B@")[])();
+}
+#else
+extern "C" {
+extern void* _ZTVN7WebCore23PerformanceServerTimingE[];
+}
+#endif
+#endif
+
+JSC::JSValue toJSNewlyCreated(JSC::JSGlobalObject*, JSDOMGlobalObject* globalObject, Ref<PerformanceServerTiming>&& impl)
+{
+
+    //     if constexpr (std::is_polymorphic_v<PerformanceServerTiming>) {
+    // #if ENABLE(BINDING_INTEGRITY)
+    //         const void* actualVTablePointer = getVTablePointer(impl.ptr());
+    // #if PLATFORM(WIN)
+    //         void* expectedVTablePointer = __identifier("??_7PerformanceServerTiming@WebCore@@6B@");
+    // #else
+    //         void* expectedVTablePointer = &_ZTVN7WebCore23PerformanceServerTimingE[2];
+    // #endif
+
+    //         // If you hit this assertion you either have a use after free bug, or
+    //         // PerformanceServerTiming has subclasses. If PerformanceServerTiming has subclasses that get passed
+    //         // to toJS() we currently require PerformanceServerTiming you to opt out of binding hardening
+    //         // by adding the SkipVTableValidation attribute to the interface IDL definition
+    //         RELEASE_ASSERT(actualVTablePointer == expectedVTablePointer);
+    // #endif
+    // }
+    return createWrapper<PerformanceServerTiming>(globalObject, WTFMove(impl));
+}
+
+JSC::JSValue toJS(JSC::JSGlobalObject* lexicalGlobalObject, JSDOMGlobalObject* globalObject, PerformanceServerTiming& impl)
+{
+    return wrap(lexicalGlobalObject, globalObject, impl);
+}
+
+PerformanceServerTiming* JSPerformanceServerTiming::toWrapped(JSC::VM&, JSC::JSValue value)
+{
+    if (auto* wrapper = jsDynamicCast<JSPerformanceServerTiming*>(value))
+        return &wrapper->wrapped();
+    return nullptr;
+}
+
+}
diff --git a/src/bun.js/bindings/webcore/JSPerformanceServerTiming.h b/src/bun.js/bindings/webcore/JSPerformanceServerTiming.h
new file mode 100644
index 0000000000..0096a938c2
--- /dev/null
+++ b/src/bun.js/bindings/webcore/JSPerformanceServerTiming.h
@@ -0,0 +1,95 @@
+/*
+    This file is part of the WebKit open source project.
+    This file has been generated by generate-bindings.pl. DO NOT MODIFY!
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+
+#pragma once
+
+#include "JSDOMWrapper.h"
+#include "PerformanceServerTiming.h"
+#include <wtf/NeverDestroyed.h>
+
+namespace WebCore {
+
+class JSPerformanceServerTiming : public JSDOMWrapper<PerformanceServerTiming> {
+public:
+    using Base = JSDOMWrapper<PerformanceServerTiming>;
+    static JSPerformanceServerTiming* create(JSC::Structure* structure, JSDOMGlobalObject* globalObject, Ref<PerformanceServerTiming>&& impl)
+    {
+        auto& vm = globalObject->vm();
+        JSPerformanceServerTiming* ptr = new (NotNull, JSC::allocateCell<JSPerformanceServerTiming>(vm)) JSPerformanceServerTiming(structure, *globalObject, WTFMove(impl));
+        ptr->finishCreation(vm);
+        return ptr;
+    }
+
+    static JSC::JSObject* createPrototype(JSC::VM&, JSDOMGlobalObject&);
+    static JSC::JSObject* prototype(JSC::VM&, JSDOMGlobalObject&);
+    static PerformanceServerTiming* toWrapped(JSC::VM&, JSC::JSValue);
+    static void destroy(JSC::JSCell*);
+
+    DECLARE_INFO;
+
+    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+    {
+        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info(), JSC::NonArray);
+    }
+
+    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);
+    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+    {
+        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+            return nullptr;
+        return subspaceForImpl(vm);
+    }
+    static JSC::GCClient::IsoSubspace* subspaceForImpl(JSC::VM& vm);
+    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+
+protected:
+    JSPerformanceServerTiming(JSC::Structure*, JSDOMGlobalObject&, Ref<PerformanceServerTiming>&&);
+
+    DECLARE_DEFAULT_FINISH_CREATION;
+};
+
+class JSPerformanceServerTimingOwner final : public JSC::WeakHandleOwner {
+public:
+    bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown>, void* context, JSC::AbstractSlotVisitor&, ASCIILiteral*) final;
+    void finalize(JSC::Handle<JSC::Unknown>, void* context) final;
+};
+
+inline JSC::WeakHandleOwner* wrapperOwner(DOMWrapperWorld&, PerformanceServerTiming*)
+{
+    static NeverDestroyed<JSPerformanceServerTimingOwner> owner;
+    return &owner.get();
+}
+
+inline void* wrapperKey(PerformanceServerTiming* wrappableObject)
+{
+    return wrappableObject;
+}
+
+JSC::JSValue toJS(JSC::JSGlobalObject*, JSDOMGlobalObject*, PerformanceServerTiming&);
+inline JSC::JSValue toJS(JSC::JSGlobalObject* lexicalGlobalObject, JSDOMGlobalObject* globalObject, PerformanceServerTiming* impl) { return impl ? toJS(lexicalGlobalObject, globalObject, *impl) : JSC::jsNull(); }
+JSC::JSValue toJSNewlyCreated(JSC::JSGlobalObject*, JSDOMGlobalObject*, Ref<PerformanceServerTiming>&&);
+inline JSC::JSValue toJSNewlyCreated(JSC::JSGlobalObject* lexicalGlobalObject, JSDOMGlobalObject* globalObject, RefPtr<PerformanceServerTiming>&& impl) { return impl ? toJSNewlyCreated(lexicalGlobalObject, globalObject, impl.releaseNonNull()) : JSC::jsNull(); }
+
+template<> struct JSDOMWrapperConverterTraits<PerformanceServerTiming> {
+    using WrapperClass = JSPerformanceServerTiming;
+    using ToWrappedReturnType = PerformanceServerTiming*;
+};
+
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/JSTextEncoder.cpp b/src/bun.js/bindings/webcore/JSTextEncoder.cpp
index d886ce16e3..e8264a7319 100644
--- a/src/bun.js/bindings/webcore/JSTextEncoder.cpp
+++ b/src/bun.js/bindings/webcore/JSTextEncoder.cpp
@@ -378,6 +378,10 @@ static inline JSC::EncodedJSValue jsTextEncoderPrototypeFunction_encodeBody(JSC:
     UNUSED_PARAM(throwScope);
     UNUSED_PARAM(callFrame);
     EnsureStillAliveScope argument0 = callFrame->argument(0);
+    if (argument0.value().isUndefined()) {
+        auto res = JSC::JSUint8Array::create(lexicalGlobalObject, lexicalGlobalObject->m_typedArrayUint8.get(lexicalGlobalObject), 0);
+        RELEASE_AND_RETURN(throwScope, JSValue::encode(res));
+    }
     JSC::JSString* input = argument0.value().toStringOrNull(lexicalGlobalObject);
     JSC::EncodedJSValue res;
     String str;
diff --git a/src/bun.js/bindings/webcore/JSWebSocket.cpp b/src/bun.js/bindings/webcore/JSWebSocket.cpp
index f5b0aeaf32..c8a7fd5174 100644
--- a/src/bun.js/bindings/webcore/JSWebSocket.cpp
+++ b/src/bun.js/bindings/webcore/JSWebSocket.cpp
@@ -212,7 +212,8 @@ static inline JSC::EncodedJSValue constructJSWebSocket3(JSGlobalObject* lexicalG
     int rejectUnauthorized = -1;
     auto headersInit = std::optional<Converter<IDLUnion<IDLSequence<IDLSequence<IDLByteString>>, IDLRecord<IDLByteString, IDLByteString>>>::ReturnType>();
     if (JSC::JSObject* options = optionsObjectValue.getObject()) {
-        if (JSValue headersValue = options->getIfPropertyExists(globalObject, PropertyName(Identifier::fromString(vm, "headers"_s)))) {
+        const auto& builtinnames = WebCore::builtinNames(vm);
+        if (JSValue headersValue = options->getIfPropertyExists(globalObject, builtinnames.headersPublicName())) {
             if (!headersValue.isUndefinedOrNull()) {
                 headersInit = convert<IDLUnion<IDLSequence<IDLSequence<IDLByteString>>, IDLRecord<IDLByteString, IDLByteString>>>(*lexicalGlobalObject, headersValue);
                 RETURN_IF_EXCEPTION(throwScope, {});
diff --git a/src/bun.js/bindings/webcore/JSWorker.cpp b/src/bun.js/bindings/webcore/JSWorker.cpp
index 66ca015cd4..37f1674202 100644
--- a/src/bun.js/bindings/webcore/JSWorker.cpp
+++ b/src/bun.js/bindings/webcore/JSWorker.cpp
@@ -148,6 +148,30 @@ template<> JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSWorkerDOMConstructor::
             RETURN_IF_EXCEPTION(throwScope, {});
         }
 
+        if (auto preloadModulesValue = optionsObject->getIfPropertyExists(lexicalGlobalObject, Identifier::fromString(vm, "preload"_s))) {
+            if (!preloadModulesValue.isUndefinedOrNull()) {
+                if (preloadModulesValue.isString()) {
+                    auto str = preloadModulesValue.toWTFString(lexicalGlobalObject);
+                    RETURN_IF_EXCEPTION(throwScope, {});
+                    if (!str.isEmpty()) {
+                        options.bun.preloadModules.append(str);
+                    }
+                } else if (auto* array = jsDynamicCast<JSC::JSArray*>(preloadModulesValue)) {
+                    std::optional<Vector<String>> seq = convert<IDLSequence<IDLDOMString>>(*lexicalGlobalObject, array);
+                    RETURN_IF_EXCEPTION(throwScope, {});
+                    if (seq) {
+                        options.bun.preloadModules = WTFMove(*seq);
+                        options.bun.preloadModules.removeAllMatching([](const String& str) {
+                            return str.isEmpty();
+                        });
+                    }
+                } else {
+                    throwVMError(lexicalGlobalObject, throwScope, "preload must be an array or string"_s);
+                    return encodedJSValue();
+                }
+            }
+        }
+
         auto workerData = optionsObject->getIfPropertyExists(lexicalGlobalObject, Identifier::fromString(vm, "workerData"_s));
         if (!workerData) {
             workerData = optionsObject->getIfPropertyExists(lexicalGlobalObject, Identifier::fromString(vm, "data"_s));
diff --git a/src/bun.js/bindings/webcore/MessagePortChannel.cpp b/src/bun.js/bindings/webcore/MessagePortChannel.cpp
index a4b5cf1343..92f82c67c6 100644
--- a/src/bun.js/bindings/webcore/MessagePortChannel.cpp
+++ b/src/bun.js/bindings/webcore/MessagePortChannel.cpp
@@ -39,14 +39,13 @@ Ref<MessagePortChannel> MessagePortChannel::create(MessagePortChannelRegistry& r
 }
 
 MessagePortChannel::MessagePortChannel(MessagePortChannelRegistry& registry, const MessagePortIdentifier& port1, const MessagePortIdentifier& port2)
-    : m_registry(registry)
+    : m_ports { port1, port2 }
+    , m_registry(registry)
 {
     relaxAdoptionRequirement();
 
-    m_ports[0] = port1;
     m_processes[0] = port1.processIdentifier;
     m_entangledToProcessProtectors[0] = this;
-    m_ports[1] = port2;
     m_processes[1] = port2.processIdentifier;
     m_entangledToProcessProtectors[1] = this;
 
diff --git a/src/bun.js/bindings/webcore/MessagePortIdentifier.h b/src/bun.js/bindings/webcore/MessagePortIdentifier.h
index d7c70b627c..2615da8300 100644
--- a/src/bun.js/bindings/webcore/MessagePortIdentifier.h
+++ b/src/bun.js/bindings/webcore/MessagePortIdentifier.h
@@ -68,7 +68,7 @@ struct MessagePortIdentifierHash {
 };
 
 template<> struct HashTraits<WebCore::MessagePortIdentifier> : GenericHashTraits<WebCore::MessagePortIdentifier> {
-    static WebCore::MessagePortIdentifier emptyValue() { return {}; }
+    static WebCore::MessagePortIdentifier emptyValue() { return { HashTraits<WebCore::ProcessIdentifier>::emptyValue(), HashTraits<WebCore::PortIdentifier>::emptyValue() }; }
 
     static void constructDeletedValue(WebCore::MessagePortIdentifier& slot) { new (NotNull, &slot.processIdentifier) WebCore::ProcessIdentifier(WTF::HashTableDeletedValue); }
 
diff --git a/src/bun.js/bindings/webcore/NetworkLoadMetrics.cpp b/src/bun.js/bindings/webcore/NetworkLoadMetrics.cpp
new file mode 100644
index 0000000000..5eab2ae951
--- /dev/null
+++ b/src/bun.js/bindings/webcore/NetworkLoadMetrics.cpp
@@ -0,0 +1,189 @@
+/*
+ * Copyright (C) 2021 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "NetworkLoadMetrics.h"
+
+#include <wtf/NeverDestroyed.h>
+
+namespace WebCore {
+
+NetworkLoadMetrics::NetworkLoadMetrics() = default;
+
+NetworkLoadMetrics::NetworkLoadMetrics(MonotonicTime&& redirectStart, MonotonicTime&& fetchStart, MonotonicTime&& domainLookupStart, MonotonicTime&& domainLookupEnd, MonotonicTime&& connectStart, MonotonicTime&& secureConnectionStart, MonotonicTime&& connectEnd, MonotonicTime&& requestStart, MonotonicTime&& responseStart, MonotonicTime&& responseEnd, MonotonicTime&& workerStart, String&& protocol, uint16_t redirectCount, bool complete, bool cellular, bool expensive, bool constrained, bool multipath, bool isReusedConnection, bool failsTAOCheck, bool hasCrossOriginRedirect, PrivacyStance privacyStance, uint64_t responseBodyBytesReceived, uint64_t responseBodyDecodedSize, RefPtr<AdditionalNetworkLoadMetricsForWebInspector>&& additionalNetworkLoadMetricsForWebInspector)
+    : redirectStart(WTFMove(redirectStart))
+    , fetchStart(WTFMove(fetchStart))
+    , domainLookupStart(WTFMove(domainLookupStart))
+    , domainLookupEnd(WTFMove(domainLookupEnd))
+    , connectStart(WTFMove(connectStart))
+    , secureConnectionStart(WTFMove(secureConnectionStart))
+    , connectEnd(WTFMove(connectEnd))
+    , requestStart(WTFMove(requestStart))
+    , responseStart(WTFMove(responseStart))
+    , responseEnd(responseEnd)
+    , workerStart(workerStart)
+    , protocol(protocol)
+    , redirectCount(redirectCount)
+    , complete(complete)
+    , cellular(cellular)
+    , expensive(expensive)
+    , constrained(constrained)
+    , multipath(multipath)
+    , isReusedConnection(isReusedConnection)
+    , failsTAOCheck(failsTAOCheck)
+    , hasCrossOriginRedirect(hasCrossOriginRedirect)
+    , privacyStance(privacyStance)
+    , responseBodyBytesReceived(responseBodyBytesReceived)
+    , responseBodyDecodedSize(responseBodyDecodedSize)
+    , additionalNetworkLoadMetricsForWebInspector(WTFMove(additionalNetworkLoadMetricsForWebInspector))
+{
+}
+
+void NetworkLoadMetrics::updateFromFinalMetrics(const NetworkLoadMetrics& other)
+{
+    MonotonicTime originalRedirectStart = redirectStart;
+    MonotonicTime originalFetchStart = fetchStart;
+    MonotonicTime originalDomainLookupStart = domainLookupStart;
+    MonotonicTime originalDomainLookupEnd = domainLookupEnd;
+    MonotonicTime originalConnectStart = connectStart;
+    MonotonicTime originalSecureConnectionStart = secureConnectionStart;
+    MonotonicTime originalConnectEnd = connectEnd;
+    MonotonicTime originalRequestStart = requestStart;
+    MonotonicTime originalResponseStart = responseStart;
+    MonotonicTime originalResponseEnd = responseEnd;
+    MonotonicTime originalWorkerStart = workerStart;
+
+    *this = other;
+
+    if (!redirectStart)
+        redirectStart = originalRedirectStart;
+    if (!fetchStart)
+        fetchStart = originalFetchStart;
+    if (!domainLookupStart)
+        domainLookupStart = originalDomainLookupStart;
+    if (!domainLookupEnd)
+        domainLookupEnd = originalDomainLookupEnd;
+    if (!connectStart)
+        connectStart = originalConnectStart;
+    if (!secureConnectionStart)
+        secureConnectionStart = originalSecureConnectionStart;
+    if (!connectEnd)
+        connectEnd = originalConnectEnd;
+    if (!requestStart)
+        requestStart = originalRequestStart;
+    if (!responseStart)
+        responseStart = originalResponseStart;
+    if (!responseEnd)
+        responseEnd = originalResponseEnd;
+    if (!workerStart)
+        workerStart = originalWorkerStart;
+
+    if (!responseEnd)
+        responseEnd = MonotonicTime::now();
+    complete = true;
+}
+
+const NetworkLoadMetrics& NetworkLoadMetrics::emptyMetrics()
+{
+    static NeverDestroyed<NetworkLoadMetrics> metrics;
+    return metrics.get();
+}
+
+Ref<AdditionalNetworkLoadMetricsForWebInspector> AdditionalNetworkLoadMetricsForWebInspector::isolatedCopy()
+{
+    auto copy = AdditionalNetworkLoadMetricsForWebInspector::create();
+    copy->priority = priority;
+    copy->remoteAddress = remoteAddress.isolatedCopy();
+    copy->connectionIdentifier = connectionIdentifier.isolatedCopy();
+    copy->tlsProtocol = tlsProtocol.isolatedCopy();
+    copy->tlsCipher = tlsCipher.isolatedCopy();
+    copy->requestHeaders = requestHeaders.isolatedCopy();
+    copy->requestHeaderBytesSent = requestHeaderBytesSent;
+    copy->responseHeaderBytesReceived = responseHeaderBytesReceived;
+    copy->requestBodyBytesSent = requestBodyBytesSent;
+    copy->isProxyConnection = isProxyConnection;
+    return copy;
+}
+
+NetworkLoadMetrics NetworkLoadMetrics::isolatedCopy() const
+{
+    NetworkLoadMetrics copy;
+
+    copy.redirectStart = redirectStart.isolatedCopy();
+    copy.fetchStart = fetchStart.isolatedCopy();
+    copy.domainLookupStart = domainLookupStart.isolatedCopy();
+    copy.domainLookupEnd = domainLookupEnd.isolatedCopy();
+    copy.connectStart = connectStart.isolatedCopy();
+    copy.secureConnectionStart = secureConnectionStart.isolatedCopy();
+    copy.connectEnd = connectEnd.isolatedCopy();
+    copy.requestStart = requestStart.isolatedCopy();
+    copy.responseStart = responseStart.isolatedCopy();
+    copy.responseEnd = responseEnd.isolatedCopy();
+    copy.workerStart = workerStart.isolatedCopy();
+
+    copy.protocol = protocol.isolatedCopy();
+
+    copy.redirectCount = redirectCount;
+
+    copy.complete = complete;
+    copy.cellular = cellular;
+    copy.expensive = expensive;
+    copy.constrained = constrained;
+    copy.multipath = multipath;
+    copy.isReusedConnection = isReusedConnection;
+    copy.failsTAOCheck = failsTAOCheck;
+    copy.hasCrossOriginRedirect = hasCrossOriginRedirect;
+
+    copy.privacyStance = privacyStance;
+
+    copy.responseBodyBytesReceived = responseBodyBytesReceived;
+    copy.responseBodyDecodedSize = responseBodyDecodedSize;
+
+    if (additionalNetworkLoadMetricsForWebInspector)
+        copy.additionalNetworkLoadMetricsForWebInspector = additionalNetworkLoadMetricsForWebInspector->isolatedCopy();
+
+    return copy;
+}
+
+Ref<AdditionalNetworkLoadMetricsForWebInspector> AdditionalNetworkLoadMetricsForWebInspector::create(NetworkLoadPriority&& priority, String&& remoteAddress, String&& connectionIdentifier, String&& tlsProtocol, String&& tlsCipher, HTTPHeaderMap&& requestHeaders, uint64_t requestHeaderBytesSent, uint64_t responseHeaderBytesReceived, uint64_t requestBodyBytesSent, bool isProxyConnection)
+{
+    return adoptRef(*new AdditionalNetworkLoadMetricsForWebInspector(WTFMove(priority), WTFMove(remoteAddress), WTFMove(connectionIdentifier), WTFMove(tlsProtocol), WTFMove(tlsCipher), WTFMove(requestHeaders), requestHeaderBytesSent, responseHeaderBytesReceived, requestBodyBytesSent, isProxyConnection));
+}
+
+AdditionalNetworkLoadMetricsForWebInspector::AdditionalNetworkLoadMetricsForWebInspector(NetworkLoadPriority&& priority, String&& remoteAddress, String&& connectionIdentifier, String&& tlsProtocol, String&& tlsCipher, HTTPHeaderMap&& requestHeaders, uint64_t requestHeaderBytesSent, uint64_t responseHeaderBytesReceived, uint64_t requestBodyBytesSent, bool isProxyConnection)
+    : priority(WTFMove(priority))
+    , remoteAddress(WTFMove(remoteAddress))
+    , connectionIdentifier(WTFMove(connectionIdentifier))
+    , tlsProtocol(WTFMove(tlsProtocol))
+    , tlsCipher(WTFMove(tlsCipher))
+    , requestHeaders(WTFMove(requestHeaders))
+    , requestHeaderBytesSent(requestHeaderBytesSent)
+    , responseHeaderBytesReceived(responseHeaderBytesReceived)
+    , requestBodyBytesSent(requestBodyBytesSent)
+    , isProxyConnection(isProxyConnection)
+{
+}
+
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/NetworkLoadMetrics.h b/src/bun.js/bindings/webcore/NetworkLoadMetrics.h
new file mode 100644
index 0000000000..5e1951f84e
--- /dev/null
+++ b/src/bun.js/bindings/webcore/NetworkLoadMetrics.h
@@ -0,0 +1,154 @@
+/*
+ * Copyright (C) 2010 Google, Inc. All Rights Reserved.
+ * Copyright (C) 2014-2021 Apple, Inc. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include "HTTPHeaderMap.h"
+#include <wtf/Box.h>
+#include <wtf/MonotonicTime.h>
+#include <wtf/text/WTFString.h>
+
+#if PLATFORM(COCOA)
+OBJC_CLASS NSURLConnection;
+OBJC_CLASS NSURLSessionTaskMetrics;
+#endif
+
+namespace WebCore {
+
+class ResourceHandle;
+
+enum class NetworkLoadPriority : uint8_t {
+    Low,
+    Medium,
+    High,
+    Unknown,
+};
+
+enum class PrivacyStance : uint8_t {
+    Unknown,
+    NotEligible,
+    Proxied,
+    Failed,
+    Direct,
+    FailedUnreachable,
+};
+
+constexpr MonotonicTime reusedTLSConnectionSentinel { MonotonicTime::fromRawSeconds(-1) };
+
+struct AdditionalNetworkLoadMetricsForWebInspector;
+
+class NetworkLoadMetrics {
+    WTF_MAKE_FAST_ALLOCATED(NetworkLoadMetrics);
+
+public:
+    WEBCORE_EXPORT NetworkLoadMetrics();
+    WEBCORE_EXPORT NetworkLoadMetrics(MonotonicTime&& redirectStart, MonotonicTime&& fetchStart, MonotonicTime&& domainLookupStart, MonotonicTime&& domainLookupEnd, MonotonicTime&& connectStart, MonotonicTime&& secureConnectionStart, MonotonicTime&& connectEnd, MonotonicTime&& requestStart, MonotonicTime&& responseStart, MonotonicTime&& responseEnd, MonotonicTime&& workerStart, String&& protocol, uint16_t redirectCount, bool complete, bool cellular, bool expensive, bool constrained, bool multipath, bool isReusedConnection, bool failsTAOCheck, bool hasCrossOriginRedirect, PrivacyStance, uint64_t responseBodyBytesReceived, uint64_t responseBodyDecodedSize, RefPtr<AdditionalNetworkLoadMetricsForWebInspector>&&);
+
+    WEBCORE_EXPORT static const NetworkLoadMetrics& emptyMetrics();
+
+    WEBCORE_EXPORT NetworkLoadMetrics isolatedCopy() const;
+
+    bool isComplete() const { return complete; }
+    bool isCellular() const { return cellular; }
+    bool isExpensive() const { return expensive; }
+    bool isConstrained() const { return constrained; }
+    bool isMultipath() const { return multipath; }
+    bool reusedConnection() const { return isReusedConnection; }
+    bool doesFailTAOCheck() const { return failsTAOCheck; }
+    bool crossOriginRedirect() const { return hasCrossOriginRedirect; }
+    void markComplete() { complete = true; }
+
+    void updateFromFinalMetrics(const NetworkLoadMetrics&);
+
+    // https://www.w3.org/TR/resource-timing-2/#attribute-descriptions
+    MonotonicTime redirectStart;
+    MonotonicTime fetchStart;
+    MonotonicTime domainLookupStart;
+    MonotonicTime domainLookupEnd;
+    MonotonicTime connectStart;
+    MonotonicTime secureConnectionStart;
+    MonotonicTime connectEnd;
+    MonotonicTime requestStart;
+    MonotonicTime responseStart;
+    MonotonicTime responseEnd;
+    MonotonicTime workerStart;
+
+    // ALPN Protocol ID: https://w3c.github.io/resource-timing/#bib-RFC7301
+    String protocol;
+
+    uint16_t redirectCount { 0 };
+
+    bool complete : 1 { false };
+    bool cellular : 1 { false };
+    bool expensive : 1 { false };
+    bool constrained : 1 { false };
+    bool multipath : 1 { false };
+    bool isReusedConnection : 1 { false };
+    bool failsTAOCheck : 1 { false };
+    bool hasCrossOriginRedirect : 1 { false };
+
+    PrivacyStance privacyStance { PrivacyStance::Unknown };
+
+    uint64_t responseBodyBytesReceived { std::numeric_limits<uint64_t>::max() };
+    uint64_t responseBodyDecodedSize { std::numeric_limits<uint64_t>::max() };
+
+    RefPtr<AdditionalNetworkLoadMetricsForWebInspector> additionalNetworkLoadMetricsForWebInspector;
+};
+
+struct AdditionalNetworkLoadMetricsForWebInspector : public RefCounted<AdditionalNetworkLoadMetricsForWebInspector> {
+
+    static Ref<AdditionalNetworkLoadMetricsForWebInspector> create() { return adoptRef(*new AdditionalNetworkLoadMetricsForWebInspector()); }
+    WEBCORE_EXPORT static Ref<AdditionalNetworkLoadMetricsForWebInspector> create(NetworkLoadPriority&&, String&& remoteAddress, String&& connectionIdentifier, String&& tlsProtocol, String&& tlsCipher, HTTPHeaderMap&& requestHeaders, uint64_t requestHeaderBytesSent, uint64_t responseHeaderBytesReceived, uint64_t requestBodyBytesSent, bool isProxyConnection);
+    Ref<AdditionalNetworkLoadMetricsForWebInspector> isolatedCopy() const;
+    Ref<AdditionalNetworkLoadMetricsForWebInspector> isolatedCopy();
+
+    NetworkLoadPriority priority { NetworkLoadPriority::Unknown };
+
+    String remoteAddress;
+    String connectionIdentifier;
+
+    String tlsProtocol;
+    String tlsCipher;
+
+    HTTPHeaderMap requestHeaders;
+
+    uint64_t requestHeaderBytesSent { std::numeric_limits<uint64_t>::max() };
+    uint64_t responseHeaderBytesReceived { std::numeric_limits<uint64_t>::max() };
+    uint64_t requestBodyBytesSent { std::numeric_limits<uint64_t>::max() };
+
+    bool isProxyConnection { false };
+
+private:
+    AdditionalNetworkLoadMetricsForWebInspector() {}
+    AdditionalNetworkLoadMetricsForWebInspector(NetworkLoadPriority&&, String&& remoteAddress, String&& connectionIdentifier, String&& tlsProtocol, String&& tlsCipher, HTTPHeaderMap&& requestHeaders, uint64_t requestHeaderBytesSent, uint64_t responseHeaderBytesReceived, uint64_t requestBodyBytesSent, bool isProxyConnection);
+};
+
+#if PLATFORM(COCOA)
+Box<NetworkLoadMetrics> copyTimingData(NSURLConnection*, const ResourceHandle&);
+WEBCORE_EXPORT Box<NetworkLoadMetrics> copyTimingData(NSURLSessionTaskMetrics* incompleteMetrics, const NetworkLoadMetrics&);
+#endif
+
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/Performance.cpp b/src/bun.js/bindings/webcore/Performance.cpp
index b1866eb7b7..55abe5bbe4 100644
--- a/src/bun.js/bindings/webcore/Performance.cpp
+++ b/src/bun.js/bindings/webcore/Performance.cpp
@@ -46,7 +46,7 @@
 // #include "PerformanceNavigationTiming.h"
 #include "PerformanceObserver.h"
 // #include "PerformancePaintTiming.h"
-// #include "PerformanceResourceTiming.h"
+#include "PerformanceResourceTiming.h"
 #include "PerformanceTiming.h"
 #include "PerformanceUserTiming.h"
 // #include "ResourceResponse.h"
@@ -172,8 +172,8 @@ Vector<RefPtr<PerformanceEntry>> Performance::getEntriesByType(const String& ent
     // if (m_navigationTiming && entryType == "navigation"_s)
     //     entries.append(m_navigationTiming);
 
-    // if (entryType == "resource"_s)
-    //     entries.appendVector(m_resourceTimingBuffer);
+    if (entryType == "resource"_s)
+        entries.appendVector(m_resourceTimingBuffer);
 
     // if (m_firstContentfulPaint && entryType == "paint"_s)
     //     entries.append(m_firstContentfulPaint);
@@ -196,12 +196,12 @@ Vector<RefPtr<PerformanceEntry>> Performance::getEntriesByName(const String& nam
     // if (m_navigationTiming && (entryType.isNull() || entryType == "navigation"_s) && name == m_navigationTiming->name())
     //     entries.append(m_navigationTiming);
 
-    // if (entryType.isNull() || entryType == "resource"_s) {
-    //     for (auto& resource : m_resourceTimingBuffer) {
-    //         if (resource->name() == name)
-    //             entries.append(resource);
-    //     }
-    // }
+    if (entryType.isNull() || entryType == "resource"_s) {
+        for (auto& resource : m_resourceTimingBuffer) {
+            if (resource->name() == name)
+                entries.append(resource);
+        }
+    }
 
     // if (m_firstContentfulPaint && (entryType.isNull() || entryType == "paint"_s) && name == "first-contentful-paint"_s)
     //     entries.append(m_firstContentfulPaint);
@@ -226,8 +226,8 @@ void Performance::appendBufferedEntriesByType(const String& entryType, Vector<Re
     //     observer.addedNavigationTiming();
     // }
 
-    // if (entryType == "resource"_s)
-    //     entries.appendVector(m_resourceTimingBuffer);
+    if (entryType == "resource"_s)
+        entries.appendVector(m_resourceTimingBuffer);
 
     // if (entryType == "paint"_s && m_firstContentfulPaint)
     //     entries.append(m_firstContentfulPaint);
@@ -240,17 +240,17 @@ void Performance::appendBufferedEntriesByType(const String& entryType, Vector<Re
     }
 }
 
-// void Performance::clearResourceTimings()
-// {
-//     m_resourceTimingBuffer.clear();
-//     m_resourceTimingBufferFullFlag = false;
-// }
+void Performance::clearResourceTimings()
+{
+    m_resourceTimingBuffer.clear();
+    m_resourceTimingBufferFullFlag = false;
+}
 
-// void Performance::setResourceTimingBufferSize(unsigned size)
-// {
-//     m_resourceTimingBufferSize = size;
-//     m_resourceTimingBufferFullFlag = false;
-// }
+void Performance::setResourceTimingBufferSize(unsigned size)
+{
+    m_resourceTimingBufferSize = size;
+    m_resourceTimingBufferFullFlag = false;
+}
 
 // void Performance::reportFirstContentfulPaint()
 // {
@@ -274,40 +274,40 @@ void Performance::appendBufferedEntriesByType(const String& entryType, Vector<Re
 //     queueEntry(*m_navigationTiming);
 // }
 
-// void Performance::addResourceTiming(ResourceTiming&& resourceTiming)
-// {
-//     ASSERT(scriptExecutionContext());
+void Performance::addResourceTiming(ResourceTiming&& resourceTiming)
+{
+    ASSERT(scriptExecutionContext());
 
-//     auto entry = PerformanceResourceTiming::create(m_timeOrigin, WTFMove(resourceTiming));
+    auto entry = PerformanceResourceTiming::create(m_timeOrigin, WTFMove(resourceTiming));
 
-//     if (m_waitingForBackupBufferToBeProcessed) {
-//         m_backupResourceTimingBuffer.append(WTFMove(entry));
-//         return;
-//     }
+    if (m_waitingForBackupBufferToBeProcessed) {
+        m_backupResourceTimingBuffer.append(WTFMove(entry));
+        return;
+    }
 
-//     if (m_resourceTimingBufferFullFlag) {
-//         // We fired resourcetimingbufferfull event but the author script didn't clear the buffer.
-//         // Notify performance observers but don't add it to the buffer.
-//         queueEntry(entry.get());
-//         return;
-//     }
+    if (m_resourceTimingBufferFullFlag) {
+        // We fired resourcetimingbufferfull event but the author script didn't clear the buffer.
+        // Notify performance observers but don't add it to the buffer.
+        queueEntry(entry.get());
+        return;
+    }
 
-//     if (isResourceTimingBufferFull()) {
-//         ASSERT(!m_resourceTimingBufferFullTimer.isActive());
-//         m_backupResourceTimingBuffer.append(WTFMove(entry));
-//         m_waitingForBackupBufferToBeProcessed = true;
-//         m_resourceTimingBufferFullTimer.startOneShot(0_s);
-//         return;
-//     }
+    if (isResourceTimingBufferFull()) {
+        // ASSERT(!m_resourceTimingBufferFullTimer.isActive());
+        m_backupResourceTimingBuffer.append(WTFMove(entry));
+        m_waitingForBackupBufferToBeProcessed = true;
+        // m_resourceTimingBufferFullTimer.startOneShot(0_s);
+        return;
+    }
 
-//     queueEntry(entry.get());
-//     m_resourceTimingBuffer.append(WTFMove(entry));
-// }
+    queueEntry(entry.get());
+    m_resourceTimingBuffer.append(WTFMove(entry));
+}
 
-// bool Performance::isResourceTimingBufferFull() const
-// {
-//     return m_resourceTimingBuffer.size() >= m_resourceTimingBufferSize;
-// }
+bool Performance::isResourceTimingBufferFull() const
+{
+    return m_resourceTimingBuffer.size() >= m_resourceTimingBufferSize;
+}
 
 // void Performance::resourceTimingBufferFullTimerFired()
 // {
diff --git a/src/bun.js/bindings/webcore/Performance.h b/src/bun.js/bindings/webcore/Performance.h
index ce3549af1f..b6dc421c66 100644
--- a/src/bun.js/bindings/webcore/Performance.h
+++ b/src/bun.js/bindings/webcore/Performance.h
@@ -95,8 +95,8 @@ public:
     Vector<RefPtr<PerformanceEntry>> getEntriesByName(const String& name, const String& entryType) const;
     void appendBufferedEntriesByType(const String& entryType, Vector<RefPtr<PerformanceEntry>>&, PerformanceObserver&) const;
 
-    // void clearResourceTimings();
-    // void setResourceTimingBufferSize(unsigned);
+    void clearResourceTimings();
+    void setResourceTimingBufferSize(unsigned);
 
     ExceptionOr<Ref<PerformanceMark>> mark(JSC::JSGlobalObject&, const String& markName, std::optional<PerformanceMarkOptions>&&);
     void clearMarks(const String& markName);
@@ -107,7 +107,7 @@ public:
 
     // void addNavigationTiming(DocumentLoader&, Document&, CachedResource&, const DocumentLoadTiming&, const NetworkLoadMetrics&);
     // void navigationFinished(const NetworkLoadMetrics&);
-    // void addResourceTiming(ResourceTiming&&);
+    void addResourceTiming(ResourceTiming&&);
 
     // void reportFirstContentfulPaint();
 
@@ -145,7 +145,7 @@ private:
     void refEventTarget() final { ref(); }
     void derefEventTarget() final { deref(); }
 
-    // bool isResourceTimingBufferFull() const;
+    bool isResourceTimingBufferFull() const;
     // void resourceTimingBufferFullTimerFired();
 
     void queueEntry(PerformanceEntry&);
@@ -155,14 +155,14 @@ private:
     mutable RefPtr<PerformanceTiming> m_timing;
 
     // https://w3c.github.io/resource-timing/#extensions-performance-interface recommends size of 150.
-    // Vector<RefPtr<PerformanceEntry>> m_resourceTimingBuffer;
-    // unsigned m_resourceTimingBufferSize { 150 };
+    Vector<RefPtr<PerformanceEntry>> m_resourceTimingBuffer;
+    unsigned m_resourceTimingBufferSize { 150 };
 
     // Timer m_resourceTimingBufferFullTimer;
-    // Vector<RefPtr<PerformanceEntry>> m_backupResourceTimingBuffer;
+    Vector<RefPtr<PerformanceEntry>> m_backupResourceTimingBuffer;
 
     // https://w3c.github.io/resource-timing/#dfn-resource-timing-buffer-full-flag
-    // bool m_resourceTimingBufferFullFlag { false };
+    bool m_resourceTimingBufferFullFlag { false };
     bool m_waitingForBackupBufferToBeProcessed { false };
     bool m_hasScheduledTimingBufferDeliveryTask { false };
 
diff --git a/src/bun.js/bindings/webcore/PerformanceObserver.cpp b/src/bun.js/bindings/webcore/PerformanceObserver.cpp
index 75fa7d7b40..5efb33e00b 100644
--- a/src/bun.js/bindings/webcore/PerformanceObserver.cpp
+++ b/src/bun.js/bindings/webcore/PerformanceObserver.cpp
@@ -150,6 +150,7 @@ Vector<String> PerformanceObserver::supportedEntryTypes(ScriptExecutionContext&
     Vector<String> entryTypes = {
         "mark"_s,
         "measure"_s,
+        "resource"_s
     };
 
     // if (context.settingsValues().performanceNavigationTimingAPIEnabled)
@@ -158,8 +159,6 @@ Vector<String> PerformanceObserver::supportedEntryTypes(ScriptExecutionContext&
     // if (is<Document>(context) && downcast<Document>(context).supportsPaintTiming())
     //     entryTypes.append("paint"_s);
 
-    // entryTypes.append("resource"_s);
-
     return entryTypes;
 }
 
diff --git a/src/bun.js/bindings/webcore/PerformanceResourceTiming.cpp b/src/bun.js/bindings/webcore/PerformanceResourceTiming.cpp
new file mode 100644
index 0000000000..57b9e1a500
--- /dev/null
+++ b/src/bun.js/bindings/webcore/PerformanceResourceTiming.cpp
@@ -0,0 +1,316 @@
+/*
+ * Copyright (C) 2017 Apple Inc. All rights reserved.
+ * Copyright (C) 2012 Google Inc. All rights reserved.
+ * Copyright (C) 2012 Intel Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "PerformanceResourceTiming.h"
+
+// #include "Document.h"
+// #include "DocumentLoadTiming.h"
+// #include "DocumentLoader.h"
+#include "PerformanceServerTiming.h"
+// #include "ResourceResponse.h"
+#include "ResourceTiming.h"
+#include <wtf/URL.h>
+
+namespace WebCore {
+
+static double networkLoadTimeToDOMHighResTimeStamp(MonotonicTime timeOrigin, MonotonicTime timeStamp)
+{
+    if (!timeStamp)
+        return 0.0;
+    ASSERT(timeOrigin);
+    return Performance::reduceTimeResolution(timeStamp - timeOrigin).milliseconds();
+}
+
+static double fetchStart(MonotonicTime timeOrigin, const ResourceTiming& resourceTiming)
+{
+    if (auto fetchStart = resourceTiming.networkLoadMetrics().fetchStart; fetchStart && !resourceTiming.networkLoadMetrics().failsTAOCheck)
+        return networkLoadTimeToDOMHighResTimeStamp(timeOrigin, fetchStart);
+
+    // fetchStart is a required property.
+    auto startTime = resourceTiming.resourceLoadTiming().startTime();
+    ASSERT(startTime);
+    return networkLoadTimeToDOMHighResTimeStamp(timeOrigin, startTime);
+}
+
+static double entryStartTime(MonotonicTime timeOrigin, const ResourceTiming& resourceTiming)
+{
+    if (resourceTiming.networkLoadMetrics().failsTAOCheck
+        || !resourceTiming.networkLoadMetrics().redirectCount)
+        return fetchStart(timeOrigin, resourceTiming);
+
+    if (resourceTiming.networkLoadMetrics().redirectStart)
+        return networkLoadTimeToDOMHighResTimeStamp(timeOrigin, resourceTiming.networkLoadMetrics().redirectStart);
+
+    return networkLoadTimeToDOMHighResTimeStamp(timeOrigin, resourceTiming.resourceLoadTiming().startTime());
+}
+
+static double entryEndTime(MonotonicTime timeOrigin, const ResourceTiming& resourceTiming)
+{
+    if (resourceTiming.networkLoadMetrics().responseEnd)
+        return networkLoadTimeToDOMHighResTimeStamp(timeOrigin, resourceTiming.networkLoadMetrics().responseEnd);
+
+    return networkLoadTimeToDOMHighResTimeStamp(timeOrigin, resourceTiming.resourceLoadTiming().endTime());
+}
+
+Ref<PerformanceResourceTiming> PerformanceResourceTiming::create(MonotonicTime timeOrigin, ResourceTiming&& resourceTiming)
+{
+    return adoptRef(*new PerformanceResourceTiming(timeOrigin, WTFMove(resourceTiming)));
+}
+
+PerformanceResourceTiming::PerformanceResourceTiming(MonotonicTime timeOrigin, ResourceTiming&& resourceTiming)
+    : PerformanceEntry(resourceTiming.url().string(), entryStartTime(timeOrigin, resourceTiming), entryEndTime(timeOrigin, resourceTiming))
+    , m_timeOrigin(timeOrigin)
+    , m_resourceTiming(WTFMove(resourceTiming))
+    , m_serverTiming(m_resourceTiming.populateServerTiming())
+{
+}
+
+PerformanceResourceTiming::~PerformanceResourceTiming() = default;
+
+const String& PerformanceResourceTiming::nextHopProtocol() const
+{
+    if (m_resourceTiming.networkLoadMetrics().failsTAOCheck)
+        return emptyString();
+
+    return m_resourceTiming.networkLoadMetrics().protocol;
+}
+
+double PerformanceResourceTiming::workerStart() const
+{
+    if (m_resourceTiming.networkLoadMetrics().failsTAOCheck)
+        return 0.0;
+
+    return networkLoadTimeToDOMHighResTimeStamp(m_timeOrigin, m_resourceTiming.networkLoadMetrics().workerStart);
+}
+
+double PerformanceResourceTiming::redirectStart() const
+{
+    if (m_resourceTiming.networkLoadMetrics().failsTAOCheck)
+        return 0.0;
+
+    if (m_resourceTiming.isLoadedFromServiceWorker())
+        return 0.0;
+
+    if (!m_resourceTiming.networkLoadMetrics().redirectCount)
+        return 0.0;
+
+    return networkLoadTimeToDOMHighResTimeStamp(m_timeOrigin, m_resourceTiming.networkLoadMetrics().redirectStart);
+}
+
+double PerformanceResourceTiming::redirectEnd() const
+{
+    if (m_resourceTiming.networkLoadMetrics().failsTAOCheck)
+        return 0.0;
+
+    if (m_resourceTiming.isLoadedFromServiceWorker())
+        return 0.0;
+
+    if (!m_resourceTiming.networkLoadMetrics().redirectCount)
+        return 0.0;
+
+    // These two times are so close to each other that we don't record two timestamps.
+    // See https://www.w3.org/TR/resource-timing-2/#attribute-descriptions
+    return fetchStart();
+}
+
+double PerformanceResourceTiming::fetchStart() const
+{
+    return WebCore::fetchStart(m_timeOrigin, m_resourceTiming);
+}
+
+double PerformanceResourceTiming::domainLookupStart() const
+{
+    if (m_resourceTiming.networkLoadMetrics().failsTAOCheck)
+        return 0.0;
+
+    if (m_resourceTiming.isLoadedFromServiceWorker())
+        return fetchStart();
+
+    if (!m_resourceTiming.networkLoadMetrics().domainLookupStart)
+        return fetchStart();
+
+    return networkLoadTimeToDOMHighResTimeStamp(m_timeOrigin, m_resourceTiming.networkLoadMetrics().domainLookupStart);
+}
+
+double PerformanceResourceTiming::domainLookupEnd() const
+{
+    if (m_resourceTiming.networkLoadMetrics().failsTAOCheck)
+        return 0.0;
+
+    if (m_resourceTiming.isLoadedFromServiceWorker())
+        return fetchStart();
+
+    if (!m_resourceTiming.networkLoadMetrics().domainLookupEnd)
+        return domainLookupStart();
+
+    return networkLoadTimeToDOMHighResTimeStamp(m_timeOrigin, m_resourceTiming.networkLoadMetrics().domainLookupEnd);
+}
+
+double PerformanceResourceTiming::connectStart() const
+{
+    if (m_resourceTiming.networkLoadMetrics().failsTAOCheck)
+        return 0.0;
+
+    if (m_resourceTiming.isLoadedFromServiceWorker())
+        return fetchStart();
+
+    if (!m_resourceTiming.networkLoadMetrics().connectStart)
+        return domainLookupEnd();
+
+    return networkLoadTimeToDOMHighResTimeStamp(m_timeOrigin, m_resourceTiming.networkLoadMetrics().connectStart);
+}
+
+double PerformanceResourceTiming::connectEnd() const
+{
+    if (m_resourceTiming.networkLoadMetrics().failsTAOCheck)
+        return 0.0;
+
+    if (m_resourceTiming.isLoadedFromServiceWorker())
+        return fetchStart();
+
+    if (!m_resourceTiming.networkLoadMetrics().connectEnd)
+        return connectStart();
+
+    return networkLoadTimeToDOMHighResTimeStamp(m_timeOrigin, m_resourceTiming.networkLoadMetrics().connectEnd);
+}
+
+double PerformanceResourceTiming::secureConnectionStart() const
+{
+    if (m_resourceTiming.networkLoadMetrics().failsTAOCheck)
+        return 0.0;
+
+    if (m_resourceTiming.networkLoadMetrics().secureConnectionStart == reusedTLSConnectionSentinel)
+        return fetchStart();
+
+    if (!m_resourceTiming.networkLoadMetrics().secureConnectionStart)
+        return 0.0;
+
+    return networkLoadTimeToDOMHighResTimeStamp(m_timeOrigin, m_resourceTiming.networkLoadMetrics().secureConnectionStart);
+}
+
+double PerformanceResourceTiming::requestStart() const
+{
+    if (m_resourceTiming.networkLoadMetrics().failsTAOCheck)
+        return 0.0;
+
+    // requestStart is 0 when a network request is not made.
+    if (!m_resourceTiming.networkLoadMetrics().requestStart)
+        return connectEnd();
+
+    return networkLoadTimeToDOMHighResTimeStamp(m_timeOrigin, m_resourceTiming.networkLoadMetrics().requestStart);
+}
+
+double PerformanceResourceTiming::responseStart() const
+{
+    if (m_resourceTiming.networkLoadMetrics().failsTAOCheck)
+        return 0.0;
+
+    // responseStart is 0 when a network request is not made.
+    if (!m_resourceTiming.networkLoadMetrics().responseStart)
+        return requestStart();
+
+    return networkLoadTimeToDOMHighResTimeStamp(m_timeOrigin, m_resourceTiming.networkLoadMetrics().responseStart);
+}
+
+double PerformanceResourceTiming::responseEnd() const
+{
+    // responseEnd is a required property, but PerformanceNavigationTiming
+    // can be queried before the document load is complete
+    ASSERT(m_resourceTiming.networkLoadMetrics().isComplete()
+        || m_resourceTiming.resourceLoadTiming().endTime()
+        || performanceEntryType() == Type::Navigation);
+
+    if (m_resourceTiming.networkLoadMetrics().isComplete()) {
+        if (m_resourceTiming.networkLoadMetrics().responseEnd)
+            return networkLoadTimeToDOMHighResTimeStamp(m_timeOrigin, m_resourceTiming.networkLoadMetrics().responseEnd);
+
+        // responseEnd is 0 when a network request is not made.
+        // This should mean all other properties are empty.
+        ASSERT(!m_resourceTiming.networkLoadMetrics().responseStart);
+        ASSERT(!m_resourceTiming.networkLoadMetrics().requestStart);
+        ASSERT(!m_resourceTiming.networkLoadMetrics().requestStart);
+        ASSERT(!m_resourceTiming.networkLoadMetrics().secureConnectionStart);
+        ASSERT(!m_resourceTiming.networkLoadMetrics().connectEnd);
+        ASSERT(!m_resourceTiming.networkLoadMetrics().connectStart);
+        ASSERT(!m_resourceTiming.networkLoadMetrics().domainLookupEnd);
+        ASSERT(!m_resourceTiming.networkLoadMetrics().domainLookupStart);
+    }
+
+    return networkLoadTimeToDOMHighResTimeStamp(m_timeOrigin, m_resourceTiming.resourceLoadTiming().endTime());
+}
+
+uint64_t PerformanceResourceTiming::transferSize() const
+{
+    // This is intentionally stricter than a TAO check.
+    // See https://github.com/w3c/server-timing/issues/89
+    if (!m_resourceTiming.isSameOriginRequest())
+        return 0;
+
+    auto encodedBodySize = m_resourceTiming.networkLoadMetrics().responseBodyBytesReceived;
+    if (encodedBodySize == std::numeric_limits<uint64_t>::max())
+        return 0;
+
+    // https://w3c.github.io/resource-timing/#dom-performanceresourcetiming-transfersize
+    // Motivated by https://github.com/w3c/resource-timing/issues/238
+    return encodedBodySize + 300;
+}
+
+uint64_t PerformanceResourceTiming::encodedBodySize() const
+{
+    // This is intentionally stricter than a TAO check.
+    // See https://github.com/w3c/server-timing/issues/89
+    if (!m_resourceTiming.isSameOriginRequest())
+        return 0;
+
+    auto encodedBodySize = m_resourceTiming.networkLoadMetrics().responseBodyBytesReceived;
+    if (encodedBodySize == std::numeric_limits<uint64_t>::max())
+        return 0;
+
+    return encodedBodySize;
+}
+
+uint64_t PerformanceResourceTiming::decodedBodySize() const
+{
+    // This is intentionally stricter than a TAO check.
+    // See https://github.com/w3c/server-timing/issues/89
+    if (!m_resourceTiming.isSameOriginRequest())
+        return 0;
+
+    auto decodedBodySize = m_resourceTiming.networkLoadMetrics().responseBodyDecodedSize;
+    if (decodedBodySize == std::numeric_limits<uint64_t>::max())
+        return 0;
+
+    return decodedBodySize;
+}
+
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/PerformanceResourceTiming.h b/src/bun.js/bindings/webcore/PerformanceResourceTiming.h
new file mode 100644
index 0000000000..cb79a86633
--- /dev/null
+++ b/src/bun.js/bindings/webcore/PerformanceResourceTiming.h
@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2012 Google Inc. All rights reserved.
+ * Copyright (C) 2012 Intel Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include "NetworkLoadMetrics.h"
+#include "PerformanceEntry.h"
+#include "ResourceTiming.h"
+#include <wtf/Ref.h>
+#include <wtf/text/WTFString.h>
+
+namespace WebCore {
+
+class PerformanceServerTiming;
+class ResourceTiming;
+
+class PerformanceResourceTiming : public PerformanceEntry {
+public:
+    static Ref<PerformanceResourceTiming> create(MonotonicTime timeOrigin, ResourceTiming&&);
+
+    const String& initiatorType() const { return m_resourceTiming.initiatorType(); }
+    const String& nextHopProtocol() const;
+
+    double workerStart() const;
+    double redirectStart() const;
+    double redirectEnd() const;
+    double fetchStart() const;
+    double domainLookupStart() const;
+    double domainLookupEnd() const;
+    double connectStart() const;
+    double connectEnd() const;
+    double secureConnectionStart() const;
+    double requestStart() const;
+    double responseStart() const;
+    double responseEnd() const;
+    uint64_t transferSize() const;
+    uint64_t encodedBodySize() const;
+    uint64_t decodedBodySize() const;
+
+    const Vector<Ref<PerformanceServerTiming>>& serverTiming() const { return m_serverTiming; }
+
+    Type performanceEntryType() const override { return Type::Resource; }
+    ASCIILiteral entryType() const override { return "resource"_s; }
+
+protected:
+    PerformanceResourceTiming(MonotonicTime timeOrigin, ResourceTiming&&);
+    ~PerformanceResourceTiming();
+
+    bool isLoadedFromServiceWorker() const { return m_resourceTiming.isLoadedFromServiceWorker(); }
+
+    MonotonicTime m_timeOrigin;
+    ResourceTiming m_resourceTiming;
+    Vector<Ref<PerformanceServerTiming>> m_serverTiming;
+};
+
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/PerformanceResourceTiming.idl b/src/bun.js/bindings/webcore/PerformanceResourceTiming.idl
new file mode 100644
index 0000000000..141f39bf86
--- /dev/null
+++ b/src/bun.js/bindings/webcore/PerformanceResourceTiming.idl
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2012 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+// https://w3c.github.io/resource-timing/
+
+typedef double DOMHighResTimeStamp;
+
+[
+    Exposed=*,
+] interface PerformanceResourceTiming : PerformanceEntry {
+    readonly attribute DOMString initiatorType;
+    readonly attribute DOMString nextHopProtocol;
+
+    readonly attribute DOMHighResTimeStamp workerStart;
+    readonly attribute DOMHighResTimeStamp redirectStart;
+    readonly attribute DOMHighResTimeStamp redirectEnd;
+    readonly attribute DOMHighResTimeStamp fetchStart;
+    readonly attribute DOMHighResTimeStamp domainLookupStart;
+    readonly attribute DOMHighResTimeStamp domainLookupEnd;
+    readonly attribute DOMHighResTimeStamp connectStart;
+    readonly attribute DOMHighResTimeStamp connectEnd;
+    readonly attribute DOMHighResTimeStamp secureConnectionStart;
+    readonly attribute DOMHighResTimeStamp requestStart;
+    readonly attribute DOMHighResTimeStamp responseStart;
+    readonly attribute DOMHighResTimeStamp responseEnd;
+    readonly attribute unsigned long long transferSize;
+    readonly attribute unsigned long long encodedBodySize;
+    readonly attribute unsigned long long decodedBodySize;
+
+    // https://www.w3.org/TR/server-timing/#extension-to-the-performanceresourcetiming-interface
+    readonly attribute FrozenArray<PerformanceServerTiming> serverTiming;
+
+    [Default] object toJSON();
+};
diff --git a/src/bun.js/bindings/webcore/PerformanceServerTiming.cpp b/src/bun.js/bindings/webcore/PerformanceServerTiming.cpp
new file mode 100644
index 0000000000..484087699e
--- /dev/null
+++ b/src/bun.js/bindings/webcore/PerformanceServerTiming.cpp
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2017 The Chromium Authors. All rights reserved.
+ * Copyright (C) 2018 Akamai Technologies Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "PerformanceServerTiming.h"
+
+namespace WebCore {
+
+Ref<PerformanceServerTiming> PerformanceServerTiming::create(String&& name, double duration, String&& description)
+{
+    return adoptRef(*new PerformanceServerTiming(WTFMove(name), duration, WTFMove(description)));
+}
+
+PerformanceServerTiming::PerformanceServerTiming(String&& name, double duration, String&& description)
+    : m_name(WTFMove(name))
+    , m_duration(duration)
+    , m_description(WTFMove(description))
+{
+}
+
+PerformanceServerTiming::~PerformanceServerTiming() = default;
+
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/PerformanceServerTiming.h b/src/bun.js/bindings/webcore/PerformanceServerTiming.h
new file mode 100644
index 0000000000..fba992220c
--- /dev/null
+++ b/src/bun.js/bindings/webcore/PerformanceServerTiming.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2017 The Chromium Authors. All rights reserved.
+ * Copyright (C) 2018 Akamai Technologies Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include <wtf/RefCounted.h>
+#include <wtf/text/WTFString.h>
+
+namespace WebCore {
+
+class PerformanceServerTiming : public RefCounted<PerformanceServerTiming> {
+public:
+    static Ref<PerformanceServerTiming> create(String&& name, double duration, String&& description);
+    ~PerformanceServerTiming();
+
+    const String& name() const { return m_name; }
+    double duration() const { return m_duration; }
+    const String& description() const { return m_description; }
+
+private:
+    PerformanceServerTiming(String&& name, double duration, String&& description);
+    String m_name;
+    double m_duration;
+    String m_description;
+};
+
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/PerformanceServerTiming.idl b/src/bun.js/bindings/webcore/PerformanceServerTiming.idl
new file mode 100644
index 0000000000..263b8da422
--- /dev/null
+++ b/src/bun.js/bindings/webcore/PerformanceServerTiming.idl
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2017 The Chromium Authors. All rights reserved.
+ * Copyright (C) 2018 Akamai Technologies Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+// https://w3c.github.io/server-timing/#dom-performanceservertiming
+
+typedef double DOMHighResTimeStamp;
+
+[
+    Exposed=*,
+] interface PerformanceServerTiming {
+    readonly attribute DOMString name;
+    readonly attribute DOMHighResTimeStamp duration;
+    readonly attribute DOMString description;
+    [Default] object toJSON();
+};
diff --git a/src/bun.js/bindings/webcore/PortIdentifier.h b/src/bun.js/bindings/webcore/PortIdentifier.h
index 17e9516d02..b584438a99 100644
--- a/src/bun.js/bindings/webcore/PortIdentifier.h
+++ b/src/bun.js/bindings/webcore/PortIdentifier.h
@@ -30,6 +30,6 @@
 namespace WebCore {
 
 enum class PortIdentifierType {};
-using PortIdentifier = LegacyNullableAtomicObjectIdentifier<PortIdentifierType>;
+using PortIdentifier = AtomicObjectIdentifier<PortIdentifierType>;
 
 }
diff --git a/src/bun.js/bindings/webcore/RFC7230.cpp b/src/bun.js/bindings/webcore/RFC7230.cpp
new file mode 100644
index 0000000000..b447a2f180
--- /dev/null
+++ b/src/bun.js/bindings/webcore/RFC7230.cpp
@@ -0,0 +1,199 @@
+/*
+ * Copyright (C) 2017-2022 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "RFC7230.h"
+
+#include <wtf/ASCIICType.h>
+#include <wtf/text/StringView.h>
+
+namespace RFC7230 {
+
+bool isTokenCharacter(UChar c)
+{
+    return isASCIIAlpha(c) || isASCIIDigit(c)
+        || c == '!' || c == '#' || c == '$'
+        || c == '%' || c == '&' || c == '\''
+        || c == '*' || c == '+' || c == '-'
+        || c == '.' || c == '^' || c == '_'
+        || c == '`' || c == '|' || c == '~';
+}
+
+bool isDelimiter(UChar c)
+{
+    return c == '(' || c == ')' || c == ','
+        || c == '/' || c == ':' || c == ';'
+        || c == '<' || c == '=' || c == '>'
+        || c == '?' || c == '@' || c == '['
+        || c == '\\' || c == ']' || c == '{'
+        || c == '}' || c == '"';
+}
+
+static bool isVisibleCharacter(UChar c)
+{
+    return isTokenCharacter(c) || isDelimiter(c);
+}
+
+template<size_t min, size_t max>
+static bool isInRange(UChar c)
+{
+    return c >= min && c <= max;
+}
+
+static bool isOBSText(UChar c)
+{
+    return isInRange<0x80, 0xFF>(c);
+}
+
+static bool isQuotedTextCharacter(UChar c)
+{
+    return isTabOrSpace(c)
+        || c == 0x21
+        || isInRange<0x23, 0x5B>(c)
+        || isInRange<0x5D, 0x7E>(c)
+        || isOBSText(c);
+}
+
+bool isQuotedPairSecondOctet(UChar c)
+{
+    return isTabOrSpace(c)
+        || isVisibleCharacter(c)
+        || isOBSText(c);
+}
+
+bool isCommentText(UChar c)
+{
+    return isTabOrSpace(c)
+        || isInRange<0x21, 0x27>(c)
+        || isInRange<0x2A, 0x5B>(c)
+        || isInRange<0x5D, 0x7E>(c)
+        || isOBSText(c);
+}
+
+bool isValidName(StringView name)
+{
+    if (!name.length())
+        return false;
+    for (size_t i = 0; i < name.length(); ++i) {
+        if (!isTokenCharacter(name[i]))
+            return false;
+    }
+    return true;
+}
+
+bool isValidValue(StringView value)
+{
+    enum class State {
+        OptionalWhitespace,
+        Token,
+        QuotedString,
+        Comment,
+    };
+    State state = State::OptionalWhitespace;
+    size_t commentDepth = 0;
+    bool hadNonWhitespace = false;
+
+    for (size_t i = 0; i < value.length(); ++i) {
+        UChar c = value[i];
+        switch (state) {
+        case State::OptionalWhitespace:
+            if (isTabOrSpace(c))
+                continue;
+            hadNonWhitespace = true;
+            if (isTokenCharacter(c)) {
+                state = State::Token;
+                continue;
+            }
+            if (c == '"') {
+                state = State::QuotedString;
+                continue;
+            }
+            if (c == '(') {
+                ASSERT(!commentDepth);
+                ++commentDepth;
+                state = State::Comment;
+                continue;
+            }
+            return false;
+
+        case State::Token:
+            if (isTokenCharacter(c))
+                continue;
+            state = State::OptionalWhitespace;
+            continue;
+        case State::QuotedString:
+            if (c == '"') {
+                state = State::OptionalWhitespace;
+                continue;
+            }
+            if (c == '\\') {
+                ++i;
+                if (i == value.length())
+                    return false;
+                if (!isQuotedPairSecondOctet(value[i]))
+                    return false;
+                continue;
+            }
+            if (!isQuotedTextCharacter(c))
+                return false;
+            continue;
+        case State::Comment:
+            if (c == '(') {
+                ++commentDepth;
+                continue;
+            }
+            if (c == ')') {
+                --commentDepth;
+                if (!commentDepth)
+                    state = State::OptionalWhitespace;
+                continue;
+            }
+            if (c == '\\') {
+                ++i;
+                if (i == value.length())
+                    return false;
+                if (!isQuotedPairSecondOctet(value[i]))
+                    return false;
+                continue;
+            }
+            if (!isCommentText(c))
+                return false;
+            continue;
+        }
+    }
+
+    switch (state) {
+    case State::OptionalWhitespace:
+    case State::Token:
+        return hadNonWhitespace;
+    case State::QuotedString:
+    case State::Comment:
+        // Unclosed comments or quotes are invalid values.
+        break;
+    }
+    return false;
+}
+
+} // namespace RFC7230
diff --git a/src/bun.js/bindings/webcore/RFC7230.h b/src/bun.js/bindings/webcore/RFC7230.h
new file mode 100644
index 0000000000..47ecff033c
--- /dev/null
+++ b/src/bun.js/bindings/webcore/RFC7230.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2017-2022 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include <unicode/umachine.h>
+#include <wtf/Forward.h>
+
+namespace RFC7230 {
+
+bool isTokenCharacter(UChar);
+bool isCommentText(UChar);
+bool isQuotedPairSecondOctet(UChar);
+bool isDelimiter(UChar);
+bool isValidName(StringView);
+bool isValidValue(StringView);
+
+} // namespace RFC7230
diff --git a/src/bun.js/bindings/webcore/ResourceLoadTiming.h b/src/bun.js/bindings/webcore/ResourceLoadTiming.h
new file mode 100644
index 0000000000..80271d70aa
--- /dev/null
+++ b/src/bun.js/bindings/webcore/ResourceLoadTiming.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2021 Apple Inc.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include <wtf/MonotonicTime.h>
+
+namespace WebCore {
+
+class ResourceLoadTiming {
+public:
+    void markStartTime() { m_startTime = MonotonicTime::now(); }
+    void markEndTime() { m_endTime = MonotonicTime::now(); }
+
+    MonotonicTime startTime() const { return m_startTime; }
+    MonotonicTime endTime() const { return m_endTime; }
+
+    ResourceLoadTiming isolatedCopy() const
+    {
+        // All members are wrapping POD types.
+        return *this;
+    }
+
+private:
+    MonotonicTime m_startTime;
+    MonotonicTime m_endTime;
+};
+
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/ResourceTiming.cpp b/src/bun.js/bindings/webcore/ResourceTiming.cpp
new file mode 100644
index 0000000000..1c18ae6e85
--- /dev/null
+++ b/src/bun.js/bindings/webcore/ResourceTiming.cpp
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "ResourceTiming.h"
+
+// #include "CachedResource.h"
+// #include "DocumentLoadTiming.h"
+// #include "OriginAccessPatterns.h"
+#include "PerformanceServerTiming.h"
+// #include "SecurityOrigin.h"
+#include "ResourceLoadTiming.h"
+#include "ServerTimingParser.h"
+#include <wtf/CrossThreadCopier.h>
+
+#include "NetworkLoadMetrics.h"
+
+namespace WebCore {
+
+DEFINE_ALLOCATOR_WITH_HEAP_IDENTIFIER(ResourceTiming);
+
+// ResourceTiming ResourceTiming::fromMemoryCache(const URL& url, const String& initiator, const ResourceLoadTiming& loadTiming, const ResourceResponse& response, const NetworkLoadMetrics& networkLoadMetrics, const SecurityOrigin& securityOrigin)
+// {
+//     return ResourceTiming(url, initiator, loadTiming, networkLoadMetrics, response, securityOrigin);
+// }
+
+// ResourceTiming ResourceTiming::fromLoad(CachedResource& resource, const URL& url, const String& initiator, const ResourceLoadTiming& loadTiming, const NetworkLoadMetrics& networkLoadMetrics, const SecurityOrigin& securityOrigin)
+// {
+//     return ResourceTiming(url, initiator, loadTiming, networkLoadMetrics, resource.response(), securityOrigin);
+// }
+
+// ResourceTiming ResourceTiming::fromSynchronousLoad(const URL& url, const String& initiator, const ResourceLoadTiming& loadTiming, const NetworkLoadMetrics& networkLoadMetrics, const ResourceResponse& response, const SecurityOrigin& securityOrigin)
+// {
+//     return ResourceTiming(url, initiator, loadTiming, networkLoadMetrics, response, securityOrigin);
+// }
+
+ResourceTiming::ResourceTiming(const URL& url, const String& initiatorType, const NetworkLoadMetrics& networkLoadMetrics)
+    : m_url(url)
+    , m_initiatorType(initiatorType)
+    , m_resourceLoadTiming(ResourceLoadTiming())
+    , m_networkLoadMetrics(networkLoadMetrics)
+    , m_serverTiming()
+    , m_isLoadedFromServiceWorker(false)
+    , m_isSameOriginRequest(true)
+{
+}
+
+// void ResourceTiming::updateExposure(const SecurityOrigin& origin)
+// {
+//     m_isSameOriginRequest = m_isSameOriginRequest && origin.canRequest(m_url, OriginAccessPatternsForWebProcess::singleton());
+// }
+
+Vector<Ref<PerformanceServerTiming>> ResourceTiming::populateServerTiming() const
+{
+    // To increase privacy, this additional check was proposed at https://github.com/w3c/resource-timing/issues/342 .
+    if (!m_isSameOriginRequest)
+        return {};
+
+    return WTF::map(m_serverTiming, [](auto& entry) {
+        return PerformanceServerTiming::create(String(entry.name), entry.duration, String(entry.description));
+    });
+}
+
+ResourceTiming ResourceTiming::isolatedCopy() const&
+{
+    return ResourceTiming {
+        m_url.isolatedCopy(),
+        m_initiatorType.isolatedCopy(),
+        // m_resourceLoadTiming.isolatedCopy(),
+        m_networkLoadMetrics.isolatedCopy(),
+        crossThreadCopy(m_serverTiming)
+    };
+}
+
+ResourceTiming ResourceTiming::isolatedCopy() &&
+{
+    return ResourceTiming {
+        WTFMove(m_url).isolatedCopy(),
+        WTFMove(m_initiatorType).isolatedCopy(),
+        // WTFMove(m_resourceLoadTiming).isolatedCopy(),
+        WTFMove(m_networkLoadMetrics).isolatedCopy(),
+        crossThreadCopy(WTFMove(m_serverTiming))
+    };
+}
+
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/ResourceTiming.h b/src/bun.js/bindings/webcore/ResourceTiming.h
new file mode 100644
index 0000000000..b3a763971b
--- /dev/null
+++ b/src/bun.js/bindings/webcore/ResourceTiming.h
@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 2017 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+// #include "LoaderMalloc.h"
+#include "NetworkLoadMetrics.h"
+#include "ResourceLoadTiming.h"
+#include "ServerTiming.h"
+#include <wtf/URL.h>
+
+namespace WebCore {
+
+class CachedResource;
+class PerformanceServerTiming;
+class ResourceResponse;
+class ResourceLoadTiming;
+class SecurityOrigin;
+
+DECLARE_ALLOCATOR_WITH_HEAP_IDENTIFIER(ResourceTiming);
+
+class ResourceTiming {
+    WTF_MAKE_FAST_ALLOCATED_WITH_HEAP_IDENTIFIER(ResourceTiming);
+
+public:
+    // static ResourceTiming fromMemoryCache(const URL&, const String& initiator const ResourceResponse&, const NetworkLoadMetrics&, const SecurityOrigin&);
+    // static ResourceTiming fromLoad(CachedResource&, const URL&, const String& initiator const NetworkLoadMetrics&, const SecurityOrigin&);
+    // static ResourceTiming fromSynchronousLoad(const URL&, const String& initiator const NetworkLoadMetrics&, const ResourceResponse&, const SecurityOrigin&);
+
+    const URL& url() const { return m_url; }
+    const String& initiatorType() const { return m_initiatorType; }
+    const ResourceLoadTiming& resourceLoadTiming() const { return m_resourceLoadTiming; }
+    const NetworkLoadMetrics& networkLoadMetrics() const { return m_networkLoadMetrics; }
+    NetworkLoadMetrics& networkLoadMetrics() { return m_networkLoadMetrics; }
+    Vector<Ref<PerformanceServerTiming>> populateServerTiming() const;
+    bool isSameOriginRequest() const { return m_isSameOriginRequest; }
+    ResourceTiming isolatedCopy() const&;
+    ResourceTiming isolatedCopy() &&;
+
+    // void updateExposure(const SecurityOrigin&);
+    void overrideInitiatorType(const String& type) { m_initiatorType = type; }
+    bool isLoadedFromServiceWorker() const { return m_isLoadedFromServiceWorker; }
+
+private:
+    ResourceTiming(const URL& url, const String& initiatorType, const NetworkLoadMetrics& networkLoadMetrics);
+    ResourceTiming(URL&& url, String&& initiatorType, NetworkLoadMetrics&& networkLoadMetrics, Vector<ServerTiming>&& serverTiming)
+        : m_url(WTFMove(url))
+        , m_initiatorType(WTFMove(initiatorType))
+        , m_resourceLoadTiming(ResourceLoadTiming())
+        , m_networkLoadMetrics(WTFMove(networkLoadMetrics))
+        , m_serverTiming(WTFMove(serverTiming))
+    {
+    }
+
+    URL m_url;
+    String m_initiatorType;
+    ResourceLoadTiming m_resourceLoadTiming;
+    NetworkLoadMetrics m_networkLoadMetrics;
+    Vector<ServerTiming> m_serverTiming;
+    bool m_isLoadedFromServiceWorker { false };
+    bool m_isSameOriginRequest { false };
+};
+
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/SerializedScriptValue.cpp b/src/bun.js/bindings/webcore/SerializedScriptValue.cpp
index 823f2a46ed..c3b936459e 100644
--- a/src/bun.js/bindings/webcore/SerializedScriptValue.cpp
+++ b/src/bun.js/bindings/webcore/SerializedScriptValue.cpp
@@ -2574,7 +2574,7 @@ SerializationReturnCode CloneSerializer::serialize(JSValue in)
             indexStack.last()++;
             goto objectStartVisitMember;
         }
-        mapStartState : {
+        mapStartState: {
             ASSERT(inValue.isObject());
             if (inputObjectStack.size() > maximumFilterRecursion)
                 return SerializationReturnCode::StackOverflowError;
@@ -2622,7 +2622,7 @@ SerializationReturnCode CloneSerializer::serialize(JSValue in)
             goto mapDataStartVisitEntry;
         }
 
-        setStartState : {
+        setStartState: {
             ASSERT(inValue.isObject());
             if (inputObjectStack.size() > maximumFilterRecursion)
                 return SerializationReturnCode::StackOverflowError;
@@ -5084,7 +5084,7 @@ DeserializationResult CloneDeserializer::deserialize()
             propertyNameStack.removeLast();
             goto objectStartVisitMember;
         }
-        mapObjectStartState : {
+        mapObjectStartState: {
             if (outputObjectStack.size() > maximumFilterRecursion)
                 return std::make_pair(JSValue(), SerializationReturnCode::StackOverflowError);
             JSMap* map = JSMap::create(m_lexicalGlobalObject->vm(), m_globalObject->mapStructure());
@@ -5113,7 +5113,7 @@ DeserializationResult CloneDeserializer::deserialize()
             goto mapDataStartVisitEntry;
         }
 
-        setObjectStartState : {
+        setObjectStartState: {
             if (outputObjectStack.size() > maximumFilterRecursion)
                 return std::make_pair(JSValue(), SerializationReturnCode::StackOverflowError);
             JSSet* set = JSSet::create(m_lexicalGlobalObject->vm(), m_globalObject->setStructure());
diff --git a/src/bun.js/bindings/webcore/ServerTiming.cpp b/src/bun.js/bindings/webcore/ServerTiming.cpp
new file mode 100644
index 0000000000..eac63d8f2d
--- /dev/null
+++ b/src/bun.js/bindings/webcore/ServerTiming.cpp
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2018 Akamai Technologies Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "ServerTiming.h"
+
+namespace WebCore {
+
+void ServerTiming::setParameter(const String& name, const String& value)
+{
+    if (equalLettersIgnoringASCIICase(name, "dur"_s)) {
+        if (!durationSet) {
+            duration = value.toDouble();
+            durationSet = true;
+        }
+        return;
+    }
+    if (equalLettersIgnoringASCIICase(name, "desc"_s)) {
+        if (!descriptionSet) {
+            description = value;
+            descriptionSet = true;
+        }
+        return;
+    }
+}
+
+ServerTiming ServerTiming::isolatedCopy() const&
+{
+    return ServerTiming { name.isolatedCopy(), duration, description.isolatedCopy(), durationSet, descriptionSet };
+}
+
+ServerTiming ServerTiming::isolatedCopy() &&
+{
+    return ServerTiming { WTFMove(name).isolatedCopy(), duration, WTFMove(description).isolatedCopy(), durationSet, descriptionSet };
+}
+
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/ServerTiming.h b/src/bun.js/bindings/webcore/ServerTiming.h
new file mode 100644
index 0000000000..dc24c76ca5
--- /dev/null
+++ b/src/bun.js/bindings/webcore/ServerTiming.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2018 Akamai Technologies Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include <wtf/text/WTFString.h>
+
+namespace WebCore {
+
+struct ServerTiming {
+    String name;
+    double duration = 0;
+    String description;
+
+    bool durationSet = false;
+    bool descriptionSet = false;
+
+    ServerTiming(String&& name);
+    ServerTiming(String&& name, double duration, String&& description);
+    ServerTiming(String&& name, double duration, String&& description, bool durationSet, bool descriptionSet);
+
+    void setParameter(const String&, const String&);
+    ServerTiming isolatedCopy() const&;
+    ServerTiming isolatedCopy() &&;
+};
+
+inline ServerTiming::ServerTiming(String&& name)
+    : name(WTFMove(name))
+{
+}
+
+inline ServerTiming::ServerTiming(String&& name, double duration, String&& description)
+    : name(WTFMove(name))
+    , duration(duration)
+    , description(WTFMove(description))
+{
+}
+
+inline ServerTiming::ServerTiming(String&& name, double duration, String&& description, bool durationSet, bool descriptionSet)
+    : name(WTFMove(name))
+    , duration(duration)
+    , description(WTFMove(description))
+    , durationSet(durationSet)
+    , descriptionSet(descriptionSet)
+{
+}
+
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/ServerTimingParser.cpp b/src/bun.js/bindings/webcore/ServerTimingParser.cpp
new file mode 100644
index 0000000000..73a0b04b5e
--- /dev/null
+++ b/src/bun.js/bindings/webcore/ServerTimingParser.cpp
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2017 Akamai Technologies Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "ServerTimingParser.h"
+
+#include "HeaderFieldTokenizer.h"
+#include "ServerTiming.h"
+
+#include <wtf/text/CString.h>
+
+namespace WebCore {
+
+namespace ServerTimingParser {
+
+Vector<ServerTiming> parseServerTiming(const String& headerValue)
+{
+    auto entries = Vector<ServerTiming>();
+    if (headerValue.isNull())
+        return entries;
+
+    ASSERT(headerValue.is8Bit());
+
+    HeaderFieldTokenizer tokenizer(headerValue);
+    while (!tokenizer.isConsumed()) {
+        String name = tokenizer.consumeToken();
+        if (name.isNull())
+            break;
+
+        ServerTiming entry(WTFMove(name));
+
+        while (tokenizer.consume(';')) {
+            String parameterName = tokenizer.consumeToken();
+            if (parameterName.isNull())
+                break;
+
+            String value = emptyString();
+            if (tokenizer.consume('=')) {
+                value = tokenizer.consumeTokenOrQuotedString();
+                tokenizer.consumeBeforeAnyCharMatch({ ',', ';' });
+            }
+            entry.setParameter(parameterName, value);
+        }
+
+        entries.append(WTFMove(entry));
+
+        if (!tokenizer.consume(','))
+            break;
+    }
+    return entries;
+}
+
+} // namespace ServerTimingParser
+
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/ServerTimingParser.h b/src/bun.js/bindings/webcore/ServerTimingParser.h
new file mode 100644
index 0000000000..5ee451dc7d
--- /dev/null
+++ b/src/bun.js/bindings/webcore/ServerTimingParser.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2017 Akamai Technologies Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include <wtf/Vector.h>
+
+namespace WebCore {
+
+struct ServerTiming;
+
+namespace ServerTimingParser {
+
+Vector<ServerTiming> parseServerTiming(const String&);
+
+}
+
+}
diff --git a/src/bun.js/bindings/webcore/WebSocket.cpp b/src/bun.js/bindings/webcore/WebSocket.cpp
index 58b2d10494..e44742c079 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/webcore/Worker.cpp b/src/bun.js/bindings/webcore/Worker.cpp
index 07601d1d67..ad88e549ed 100644
--- a/src/bun.js/bindings/webcore/Worker.cpp
+++ b/src/bun.js/bindings/webcore/Worker.cpp
@@ -121,7 +121,9 @@ extern "C" void* WebWorker__create(
     StringImpl* argvPtr,
     uint32_t argvLen,
     StringImpl* execArgvPtr,
-    uint32_t execArgvLen);
+    uint32_t execArgvLen,
+    BunString* preloadModulesPtr,
+    uint32_t preloadModulesLen);
 extern "C" void WebWorker__setRef(
     void* worker,
     bool ref);
@@ -149,7 +151,12 @@ ExceptionOr<Ref<Worker>> Worker::create(ScriptExecutionContext& context, const S
 
     WTF::String url = urlInit;
     if (url.startsWith("file://"_s)) {
-        url = WTF::URL(url).fileSystemPath();
+        WTF::URL urlObject = WTF::URL(url);
+        if (urlObject.isValid()) {
+            url = urlObject.fileSystemPath();
+        } else {
+            return Exception { TypeError, makeString("Invalid file URL: \""_s, urlInit, '"') };
+        }
     }
     BunString urlStr = Bun::toString(url);
     BunString errorMessage = BunStringEmpty;
@@ -160,6 +167,20 @@ ExceptionOr<Ref<Worker>> Worker::create(ScriptExecutionContext& context, const S
 
     Vector<String>* argv = worker->m_options.bun.argv.get();
     Vector<String>* execArgv = worker->m_options.bun.execArgv.get();
+    Vector<String>* preloadModuleStrings = &worker->m_options.bun.preloadModules;
+    Vector<BunString> preloadModules;
+    preloadModules.reserveInitialCapacity(preloadModuleStrings->size());
+    for (auto& str : *preloadModuleStrings) {
+        if (str.startsWith("file://"_s)) {
+            WTF::URL urlObject = WTF::URL(str);
+            if (!urlObject.isValid()) {
+                return Exception { TypeError, makeString("Invalid file URL: \""_s, str, '"') };
+            }
+            str = urlObject.fileSystemPath();
+        }
+
+        preloadModules.append(Bun::toString(str));
+    }
 
     void* impl = WebWorker__create(
         worker.ptr(),
@@ -174,7 +195,11 @@ ExceptionOr<Ref<Worker>> Worker::create(ScriptExecutionContext& context, const S
         argv ? reinterpret_cast<StringImpl*>(argv->data()) : nullptr,
         argv ? static_cast<uint32_t>(argv->size()) : 0,
         execArgv ? reinterpret_cast<StringImpl*>(execArgv->data()) : nullptr,
-        execArgv ? static_cast<uint32_t>(execArgv->size()) : 0);
+        execArgv ? static_cast<uint32_t>(execArgv->size()) : 0,
+        preloadModules.size() ? preloadModules.data() : nullptr,
+        static_cast<uint32_t>(preloadModules.size()));
+
+    preloadModuleStrings->clear();
 
     if (!impl) {
         return Exception { TypeError, errorMessage.toWTFString(BunString::ZeroCopy) };
diff --git a/src/bun.js/bindings/webcore/WorkerOptions.h b/src/bun.js/bindings/webcore/WorkerOptions.h
index dc2f5e5c76..de6d9ba0fe 100644
--- a/src/bun.js/bindings/webcore/WorkerOptions.h
+++ b/src/bun.js/bindings/webcore/WorkerOptions.h
@@ -12,6 +12,7 @@ struct BunOptions {
     bool unref { false };
     RefPtr<SerializedScriptValue> data;
     Vector<TransferredMessagePort> dataMessagePorts;
+    Vector<String> preloadModules;
     std::unique_ptr<HashMap<String, String>> env { nullptr };
     std::unique_ptr<Vector<String>> argv { nullptr };
     std::unique_ptr<Vector<String>> execArgv { nullptr };
diff --git a/src/bun.js/bindings/workaround-missing-symbols.cpp b/src/bun.js/bindings/workaround-missing-symbols.cpp
index 21cb196439..b1fcc12a63 100644
--- a/src/bun.js/bindings/workaround-missing-symbols.cpp
+++ b/src/bun.js/bindings/workaround-missing-symbols.cpp
@@ -53,13 +53,19 @@ extern "C" int kill(int pid, int sig)
 
 // if linux
 #if defined(__linux__)
+#include <features.h>
+#ifdef __GNU_LIBRARY__
+
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
 
 #include <fcntl.h>
-// #include <sys/stat.h>
-#include <stdarg.h>
-#include <math.h>
-#include <errno.h>
 #include <dlfcn.h>
+#include <stdarg.h>
+#include <errno.h>
+#include <math.h>
+#include <mutex>
 
 #ifndef _STAT_VER
 #if defined(__aarch64__)
@@ -72,131 +78,171 @@ extern "C" int kill(int pid, int sig)
 #endif
 
 #if defined(__x86_64__)
-// Force older versions of symbols
-__asm__(".symver pow,pow@GLIBC_2.2.5");
+__asm__(".symver cosf,cosf@GLIBC_2.2.5");
+__asm__(".symver exp,exp@GLIBC_2.2.5");
+__asm__(".symver expf,expf@GLIBC_2.2.5");
+__asm__(".symver fcntl,fcntl@GLIBC_2.2.5");
+__asm__(".symver fmod,fmod@GLIBC_2.2.5");
+__asm__(".symver fmodf,fmodf@GLIBC_2.2.5");
 __asm__(".symver log,log@GLIBC_2.2.5");
+__asm__(".symver log10f,log10f@GLIBC_2.2.5");
+__asm__(".symver log2,log2@GLIBC_2.2.5");
+__asm__(".symver log2f,log2f@GLIBC_2.2.5");
+__asm__(".symver logf,logf@GLIBC_2.2.5");
+__asm__(".symver pow,pow@GLIBC_2.2.5");
+__asm__(".symver powf,powf@GLIBC_2.2.5");
+__asm__(".symver sincosf,sincosf@GLIBC_2.2.5");
+__asm__(".symver sinf,sinf@GLIBC_2.2.5");
+__asm__(".symver tanf,tanf@GLIBC_2.2.5");
+#elif defined(__aarch64__)
+__asm__(".symver cosf,cosf@GLIBC_2.17");
+__asm__(".symver exp,exp@GLIBC_2.17");
+__asm__(".symver expf,expf@GLIBC_2.17");
+__asm__(".symver fmod,fmod@GLIBC_2.17");
+__asm__(".symver fmodf,fmodf@GLIBC_2.17");
+__asm__(".symver log,log@GLIBC_2.17");
+__asm__(".symver log10f,log10f@GLIBC_2.17");
+__asm__(".symver log2,log2@GLIBC_2.17");
+__asm__(".symver log2f,log2f@GLIBC_2.17");
+__asm__(".symver logf,logf@GLIBC_2.17");
+__asm__(".symver pow,pow@GLIBC_2.17");
+__asm__(".symver powf,powf@GLIBC_2.17");
+__asm__(".symver sincosf,sincosf@GLIBC_2.17");
+__asm__(".symver sinf,sinf@GLIBC_2.17");
+__asm__(".symver tanf,tanf@GLIBC_2.17");
 #endif
 
-// ban statx, for now
-extern "C" int __wrap_statx(int fd, const char* path, int flags,
-    unsigned int mask, struct statx* buf)
-{
-    errno = ENOSYS;
-#ifdef BUN_DEBUG
-    abort();
+#if defined(__x86_64__) || defined(__aarch64__)
+#define BUN_WRAP_GLIBC_SYMBOL(symbol) __wrap_##symbol
+#else
+#define BUN_WRAP_GLIBC_SYMBOL(symbol) symbol
 #endif
-    return -1;
+
+extern "C" {
+double BUN_WRAP_GLIBC_SYMBOL(exp)(double);
+double BUN_WRAP_GLIBC_SYMBOL(fmod)(double, double);
+double BUN_WRAP_GLIBC_SYMBOL(log)(double);
+double BUN_WRAP_GLIBC_SYMBOL(log2)(double);
+double BUN_WRAP_GLIBC_SYMBOL(pow)(double, double);
+float BUN_WRAP_GLIBC_SYMBOL(cosf)(float);
+float BUN_WRAP_GLIBC_SYMBOL(expf)(float);
+float BUN_WRAP_GLIBC_SYMBOL(fmodf)(float, float);
+float BUN_WRAP_GLIBC_SYMBOL(log10f)(float);
+float BUN_WRAP_GLIBC_SYMBOL(log2f)(float);
+float BUN_WRAP_GLIBC_SYMBOL(logf)(float);
+float BUN_WRAP_GLIBC_SYMBOL(sinf)(float);
+float BUN_WRAP_GLIBC_SYMBOL(tanf)(float);
+int BUN_WRAP_GLIBC_SYMBOL(fcntl)(int, int, ...);
+int BUN_WRAP_GLIBC_SYMBOL(fcntl64)(int, int, ...);
+void BUN_WRAP_GLIBC_SYMBOL(sincosf)(float, float*, float*);
 }
 
-extern "C" int __real_fcntl(int fd, int cmd, ...);
-typedef double (*MathFunction)(double);
-typedef double (*MathFunction2)(double, double);
+extern "C" {
 
-static inline double __real_exp(double x)
+#if defined(__x86_64__) || defined(__aarch64__)
+
+int __wrap_fcntl(int fd, int cmd, ...)
 {
-    static MathFunction function = nullptr;
-    if (UNLIKELY(function == nullptr)) {
-        function = reinterpret_cast<MathFunction>(dlsym(nullptr, "exp"));
-        if (UNLIKELY(function == nullptr))
-            abort();
+    va_list args;
+    va_start(args, cmd);
+    void* arg = va_arg(args, void*);
+    va_end(args);
+    return fcntl(fd, cmd, arg);
+}
+
+typedef int (*fcntl64_func)(int fd, int cmd, ...);
+
+enum arg_type {
+    NO_ARG,
+    INT_ARG,
+    PTR_ARG
+};
+
+static enum arg_type get_arg_type(int cmd)
+{
+    switch (cmd) {
+    // Commands that take no argument
+    case F_GETFD:
+    case F_GETFL:
+    case F_GETOWN:
+    case F_GETSIG:
+    case F_GETLEASE:
+    case F_GETPIPE_SZ:
+#ifdef F_GET_SEALS
+    case F_GET_SEALS:
+#endif
+        return NO_ARG;
+
+    // Commands that take an integer argument
+    case F_DUPFD:
+    case F_DUPFD_CLOEXEC:
+    case F_SETFD:
+    case F_SETFL:
+    case F_SETOWN:
+    case F_SETSIG:
+    case F_SETLEASE:
+    case F_NOTIFY:
+    case F_SETPIPE_SZ:
+#ifdef F_ADD_SEALS
+    case F_ADD_SEALS:
+#endif
+        return INT_ARG;
+
+    // Commands that take a pointer argument
+    case F_GETLK:
+    case F_SETLK:
+    case F_SETLKW:
+    case F_GETOWN_EX:
+    case F_SETOWN_EX:
+        return PTR_ARG;
+
+    default:
+        return PTR_ARG; // Default to pointer for unknown commands
     }
-
-    return function(x);
-}
-static inline double __real_log(double x)
-{
-    static MathFunction function = nullptr;
-    if (UNLIKELY(function == nullptr)) {
-        function = reinterpret_cast<MathFunction>(dlsym(nullptr, "log"));
-        if (UNLIKELY(function == nullptr))
-            abort();
-    }
-
-    return function(x);
-}
-static inline double __real_log2(double x)
-{
-    static MathFunction function = nullptr;
-    if (UNLIKELY(function == nullptr)) {
-        function = reinterpret_cast<MathFunction>(dlsym(nullptr, "log2"));
-        if (UNLIKELY(function == nullptr))
-            abort();
-    }
-
-    return function(x);
-}
-static inline double __real_fmod(double x, double y)
-{
-    static MathFunction2 function = nullptr;
-    if (UNLIKELY(function == nullptr)) {
-        function = reinterpret_cast<MathFunction2>(dlsym(nullptr, "fmod"));
-        if (UNLIKELY(function == nullptr))
-            abort();
-    }
-
-    return function(x, y);
-}
-
-extern "C" int __wrap_fcntl(int fd, int cmd, ...)
-{
-    va_list va;
-    va_start(va, cmd);
-    return __real_fcntl(fd, cmd, va_arg(va, void*));
-    va_end(va);
 }
 
 extern "C" int __wrap_fcntl64(int fd, int cmd, ...)
 {
-    va_list va;
-    va_start(va, cmd);
-    return __real_fcntl(fd, cmd, va_arg(va, void*));
-    va_end(va);
-}
+    va_list ap;
+    enum arg_type type = get_arg_type(cmd);
 
-extern "C" double __wrap_pow(double x, double y)
-{
-    static void* pow_ptr = nullptr;
-    if (UNLIKELY(pow_ptr == nullptr)) {
-        pow_ptr = dlsym(RTLD_DEFAULT, "pow");
+    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:
+        return real_fcntl64(fd, cmd);
+
+    case INT_ARG: {
+        va_start(ap, cmd);
+        int arg = va_arg(ap, int);
+        va_end(ap);
+        return real_fcntl64(fd, cmd, arg);
     }
 
-    return ((double (*)(double, double))pow_ptr)(x, y);
-}
-
-extern "C" double __wrap_exp(double x)
-{
-    return __real_exp(x);
-}
-
-extern "C" double __wrap_log(double x)
-{
-    return __real_log(x);
-}
-
-extern "C" double __wrap_log2(double x)
-{
-    return __real_log2(x);
-}
-
-extern "C" double __wrap_fmod(double x, double y)
-{
-    return __real_fmod(x, y);
-}
-
-static inline float __real_expf(float arg)
-{
-    static void* ptr = nullptr;
-    if (UNLIKELY(ptr == nullptr)) {
-        ptr = dlsym(RTLD_DEFAULT, "expf");
+    case PTR_ARG: {
+        va_start(ap, cmd);
+        void* arg = va_arg(ap, void*);
+        va_end(ap);
+        return real_fcntl64(fd, cmd, arg);
     }
 
-    return ((float (*)(float))ptr)(arg);
+    default:
+        va_end(ap);
+        errno = EINVAL;
+        return -1;
+    }
 }
 
-extern "C" float __wrap_expf(float arg)
-{
-    return __real_expf(arg);
-}
+#endif
+
+#if defined(__x86_64__)
 
 #ifndef _MKNOD_VER
 #define _MKNOD_VER 1
@@ -250,20 +296,57 @@ extern "C" int __wrap_fstatat64(int dirfd, const char* path, struct stat64* stat
     return __fxstatat64(_STAT_VER, dirfd, path, stat, flags);
 }
 
-extern "C" int __xmknod(int ver, const char* path, __mode_t mode, __dev_t dev);
-extern "C" int __wrap_mknod(const char* path, __mode_t mode, __dev_t dev)
+extern "C" int __xmknod(int ver, const char* path, mode_t mode, dev_t dev);
+extern "C" int __wrap_mknod(const char* path, mode_t mode, dev_t dev)
 {
     return __xmknod(_MKNOD_VER, path, mode, dev);
 }
 
-extern "C" int __xmknodat(int ver, int dirfd, const char* path, __mode_t mode, __dev_t dev);
-extern "C" int __wrap_mknodat(int dirfd, const char* path, __mode_t mode, __dev_t dev)
+extern "C" int __xmknodat(int ver, int dirfd, const char* path, mode_t mode, dev_t dev);
+extern "C" int __wrap_mknodat(int dirfd, const char* path, mode_t mode, dev_t dev)
 {
     return __xmknodat(_MKNOD_VER, dirfd, path, mode, dev);
 }
 
 #endif
 
+double __wrap_exp(double x)
+{
+    return exp(x);
+}
+double __wrap_fmod(double x, double y) { return fmod(x, y); }
+double __wrap_log(double x) { return log(x); }
+double __wrap_log2(double x) { return log2(x); }
+double __wrap_pow(double x, double y) { return pow(x, y); }
+float __wrap_powf(float x, float y) { return powf(x, y); }
+float __wrap_cosf(float x) { return cosf(x); }
+float __wrap_expf(float x) { return expf(x); }
+float __wrap_fmodf(float x, float y) { return fmodf(x, y); }
+float __wrap_log10f(float x) { return log10f(x); }
+float __wrap_log2f(float x) { return log2f(x); }
+float __wrap_logf(float x) { return logf(x); }
+float __wrap_sinf(float x) { return sinf(x); }
+float __wrap_tanf(float x) { return tanf(x); }
+void __wrap_sincosf(float x, float* sin_x, float* cos_x) { sincosf(x, sin_x, cos_x); }
+}
+
+// ban statx, for now
+extern "C" int __wrap_statx(int fd, const char* path, int flags,
+    unsigned int mask, struct statx* buf)
+{
+    errno = ENOSYS;
+#ifdef BUN_DEBUG
+    abort();
+#endif
+    return -1;
+}
+
+#endif // glibc
+
+// musl
+
+#endif // linux
+
 // macOS
 #if defined(__APPLE__)
 
diff --git a/src/bun.js/bindings/wtf-bindings.h b/src/bun.js/bindings/wtf-bindings.h
index 6b96ac070d..d7298c77a5 100644
--- a/src/bun.js/bindings/wtf-bindings.h
+++ b/src/bun.js/bindings/wtf-bindings.h
@@ -12,4 +12,4 @@ class VM;
 namespace Bun {
 String base64URLEncodeToString(Vector<uint8_t> data);
 size_t toISOString(JSC::VM& vm, double date, char buffer[64]);
-}
\ No newline at end of file
+}
diff --git a/src/bun.js/config.zig b/src/bun.js/config.zig
index 1018a6226d..d82c3467d2 100644
--- a/src/bun.js/config.zig
+++ b/src/bun.js/config.zig
@@ -31,7 +31,6 @@ pub const DefaultBunDefines = struct {
 pub fn configureTransformOptionsForBunVM(allocator: std.mem.Allocator, _args: Api.TransformOptions) !Api.TransformOptions {
     var args = _args;
 
-    // args.serve = false;
     args.write = false;
     args.resolve = Api.ResolveMode.lazy;
     return try configureTransformOptionsForBun(allocator, args);
diff --git a/src/bun.js/event_loop.zig b/src/bun.js/event_loop.zig
index 7a0f7a793e..514e8489d0 100644
--- a/src/bun.js/event_loop.zig
+++ b/src/bun.js/event_loop.zig
@@ -380,10 +380,8 @@ const Futimes = JSC.Node.Async.futimes;
 const Lchmod = JSC.Node.Async.lchmod;
 const Lchown = JSC.Node.Async.lchown;
 const Unlink = JSC.Node.Async.unlink;
-const BrotliDecoder = JSC.API.BrotliDecoder;
-const BrotliEncoder = JSC.API.BrotliEncoder;
-const ZlibDecoder = JSC.API.ZlibDecoder;
-const ZlibEncoder = JSC.API.ZlibEncoder;
+const NativeZlib = JSC.API.NativeZlib;
+const NativeBrotli = JSC.API.NativeBrotli;
 
 const ShellGlobTask = bun.shell.interpret.Interpreter.Expansion.ShellGlobTask;
 const ShellRmTask = bun.shell.Interpreter.Builtin.Rm.ShellRmTask;
@@ -466,10 +464,8 @@ pub const Task = TaggedPointerUnion(.{
     Lchmod,
     Lchown,
     Unlink,
-    BrotliEncoder,
-    BrotliDecoder,
-    ZlibEncoder,
-    ZlibDecoder,
+    NativeZlib,
+    NativeBrotli,
     ShellGlobTask,
     ShellRmTask,
     ShellRmDirTask,
@@ -484,13 +480,11 @@ pub const Task = TaggedPointerUnion(.{
     ShellAsyncSubprocessDone,
     TimerObject,
     bun.shell.Interpreter.Builtin.Yes.YesTask,
-
-    bun.kit.DevServer.BundleTask,
-    bun.kit.DevServer.HotReloadTask,
-
     ProcessWaiterThreadTask,
     RuntimeTranspilerStore,
     ServerAllConnectionsClosedTask,
+    bun.bake.DevServer.HotReloadEvent,
+    bun.bundle_v2.DeferredBatchTask,
 });
 const UnboundedQueue = @import("./unbounded_queue.zig").UnboundedQueue;
 pub const ConcurrentTask = struct {
@@ -552,6 +546,7 @@ pub const GarbageCollectionController = struct {
         const actual = uws.Loop.get();
         this.gc_timer = uws.Timer.createFallthrough(actual, this);
         this.gc_repeating_timer = uws.Timer.createFallthrough(actual, this);
+        actual.internal_loop_data.jsc_vm = vm.jsc;
 
         if (comptime Environment.isDebug) {
             if (bun.getenvZ("BUN_TRACK_LAST_FN_NAME") != null) {
@@ -885,6 +880,17 @@ pub const EventLoop = struct {
             globalObject.reportActiveExceptionAsUnhandled(err);
     }
 
+    pub fn runCallbackWithResult(this: *EventLoop, callback: JSC.JSValue, globalObject: *JSC.JSGlobalObject, thisValue: JSC.JSValue, arguments: []const JSC.JSValue) JSC.JSValue {
+        this.enter();
+        defer this.exit();
+
+        const result = callback.call(globalObject, thisValue, arguments) catch |err| {
+            globalObject.reportActiveExceptionAsUnhandled(err);
+            return .zero;
+        };
+        return result;
+    }
+
     fn tickQueueWithCount(this: *EventLoop, virtual_machine: *VirtualMachine, comptime queue_name: []const u8) u32 {
         var global = this.global;
         const global_vm = global.vm();
@@ -1006,7 +1012,7 @@ pub const EventLoop = struct {
                 },
                 .ThreadSafeFunction => {
                     var transform_task: *ThreadSafeFunction = task.as(ThreadSafeFunction);
-                    transform_task.call();
+                    transform_task.onDispatch();
                 },
                 @field(Task.Tag, @typeName(ReadFileTask)) => {
                     var transform_task: *ReadFileTask = task.get(ReadFileTask).?;
@@ -1024,18 +1030,15 @@ pub const EventLoop = struct {
                     transform_task.deinit();
                 },
                 @field(Task.Tag, @typeName(HotReloadTask)) => {
-                    var transform_task: *HotReloadTask = task.get(HotReloadTask).?;
-                    transform_task.*.run();
+                    const transform_task: *HotReloadTask = task.get(HotReloadTask).?;
+                    transform_task.run();
                     transform_task.deinit();
                     // special case: we return
                     return 0;
                 },
-                @field(Task.Tag, @typeName(bun.kit.DevServer.HotReloadTask)) => {
-                    const transform_task = task.get(bun.kit.DevServer.HotReloadTask).?;
-                    transform_task.*.run();
-                    transform_task.deinit();
-                    // special case: we return
-                    return 0;
+                @field(Task.Tag, typeBaseName(@typeName(bun.bake.DevServer.HotReloadEvent))) => {
+                    const hmr_task: *bun.bake.DevServer.HotReloadEvent = task.get(bun.bake.DevServer.HotReloadEvent).?;
+                    hmr_task.run();
                 },
                 @field(Task.Tag, typeBaseName(@typeName(FSWatchTask))) => {
                     var transform_task: *FSWatchTask = task.get(FSWatchTask).?;
@@ -1224,20 +1227,12 @@ pub const EventLoop = struct {
                     var any: *Unlink = task.get(Unlink).?;
                     any.runFromJSThread();
                 },
-                @field(Task.Tag, typeBaseName(@typeName(BrotliEncoder))) => {
-                    var any: *BrotliEncoder = task.get(BrotliEncoder).?;
+                @field(Task.Tag, typeBaseName(@typeName(NativeZlib))) => {
+                    var any: *NativeZlib = task.get(NativeZlib).?;
                     any.runFromJSThread();
                 },
-                @field(Task.Tag, typeBaseName(@typeName(BrotliDecoder))) => {
-                    var any: *BrotliDecoder = task.get(BrotliDecoder).?;
-                    any.runFromJSThread();
-                },
-                @field(Task.Tag, typeBaseName(@typeName(ZlibEncoder))) => {
-                    var any: *ZlibEncoder = task.get(ZlibEncoder).?;
-                    any.runFromJSThread();
-                },
-                @field(Task.Tag, typeBaseName(@typeName(ZlibDecoder))) => {
-                    var any: *ZlibDecoder = task.get(ZlibDecoder).?;
+                @field(Task.Tag, typeBaseName(@typeName(NativeBrotli))) => {
+                    var any: *NativeBrotli = task.get(NativeBrotli).?;
                     any.runFromJSThread();
                 },
                 @field(Task.Tag, typeBaseName(@typeName(ProcessWaiterThreadTask))) => {
@@ -1257,15 +1252,13 @@ pub const EventLoop = struct {
                     var any: *ServerAllConnectionsClosedTask = task.get(ServerAllConnectionsClosedTask).?;
                     any.runFromJSThread(virtual_machine);
                 },
-                @field(Task.Tag, typeBaseName(@typeName(bun.kit.DevServer.BundleTask))) => {
-                    task.get(bun.kit.DevServer.BundleTask).?.completeOnMainThread();
+                @field(Task.Tag, typeBaseName(@typeName(bun.bundle_v2.DeferredBatchTask))) => {
+                    var any: *bun.bundle_v2.DeferredBatchTask = task.get(bun.bundle_v2.DeferredBatchTask).?;
+                    any.runOnJSThread();
                 },
 
-                else => if (Environment.allow_assert) {
-                    bun.Output.prettyln("\nUnexpected tag: {s}\n", .{@tagName(task.tag())});
-                } else {
-                    log("\nUnexpected tag: {s}\n", .{@tagName(task.tag())});
-                    unreachable;
+                else => {
+                    bun.Output.panic("Unexpected tag: {s}", .{@tagName(task.tag())});
                 },
             }
 
@@ -1445,6 +1438,7 @@ pub const EventLoop = struct {
             }
         }
 
+        this.processGCTimer();
         this.processGCTimer();
         loop.tick();
 
@@ -1494,38 +1488,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();
-
-            const global = ctx.global;
-            const global_vm = ctx.jsc;
-
-            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;
-            }
-
-            while (this.tickWithCount(ctx) > 0) {
-                this.tickConcurrent();
-            }
-
-            this.global.handleRejectedPromises();
+        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();
+
+        const global = ctx.global;
+        const global_vm = ctx.jsc;
+
+        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;
+        }
+
+        while (this.tickWithCount(ctx) > 0) {
+            this.tickConcurrent();
+        }
+
+        this.global.handleRejectedPromises();
     }
 
     pub fn waitForPromise(this: *EventLoop, promise: JSC.AnyPromise) void {
@@ -1714,8 +1706,7 @@ pub const MiniVM = struct {
     }
 
     pub inline fn incrementPendingUnrefCounter(this: @This()) void {
-        _ = this; // autofix
-
+        _ = this;
         @panic("FIXME TODO");
     }
 
@@ -2036,13 +2027,6 @@ pub const AnyEventLoop = union(enum) {
 
     pub const Task = AnyTaskWithExtraContext;
 
-    pub fn fromJSC(
-        this: *AnyEventLoop,
-        jsc: *EventLoop,
-    ) void {
-        this.* = .{ .js = jsc };
-    }
-
     pub fn wakeup(this: *AnyEventLoop) void {
         this.loop().wakeup();
     }
@@ -2124,7 +2108,7 @@ pub const AnyEventLoop = union(enum) {
     ) void {
         switch (this.*) {
             .js => {
-                unreachable; // TODO:
+                bun.todoPanic(@src(), "AnyEventLoop.enqueueTaskConcurrent", .{});
                 // const TaskType = AnyTask.New(Context, Callback);
                 // @field(ctx, field) = TaskType.init(ctx);
                 // var concurrent = bun.default_allocator.create(ConcurrentTask) catch unreachable;
diff --git a/src/bun.js/javascript.zig b/src/bun.js/javascript.zig
index fe9b945d4d..7fc7ce4903 100644
--- a/src/bun.js/javascript.zig
+++ b/src/bun.js/javascript.zig
@@ -178,13 +178,14 @@ pub const SavedSourceMap = struct {
                         try fail.toData(path).writeFormat(
                             Output.errorWriter(),
                             logger.Kind.warn,
+                            false,
                             true,
                         );
                     } else {
                         try fail.toData(path).writeFormat(
                             Output.errorWriter(),
                             logger.Kind.warn,
-
+                            false,
                             false,
                         );
                     }
@@ -428,17 +429,13 @@ 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(
-    globalObject: *JSGlobalObject,
-    callFrame: *JSC.CallFrame,
-) callconv(JSC.conv) JSValue {
+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) bun.JSError!JSC.JSValue {
     JSC.markBinding(@src());
-    var message, var handle, var options_, var callback = callFrame.arguments(4).ptr;
-
-    if (message == .zero) message = .undefined;
-    if (handle == .zero) handle = .undefined;
-    if (options_ == .zero) options_ = .undefined;
-    if (callback == .zero) callback = .undefined;
+    var message, var handle, var options_, var callback = callFrame.argumentsAsArray(4);
 
     if (handle.isFunction()) {
         callback = handle;
@@ -448,12 +445,12 @@ pub export fn Bun__Process__send(
         callback = options_;
         options_ = .undefined;
     } else if (!options_.isUndefined()) {
-        if (!globalObject.validateObject("options", options_, .{})) return .zero;
+        try globalObject.validateObject("options", options_, .{});
     }
 
     const S = struct {
-        fn impl(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
-            const arguments_ = callframe.arguments(1).slice();
+        fn impl(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+            const arguments_ = callframe.arguments_old(1).slice();
             const ex = arguments_[0];
             VirtualMachine.Process__emitErrorEvent(globalThis, ex);
             return .undefined;
@@ -474,14 +471,10 @@ pub export fn Bun__Process__send(
     };
 
     if (message.isUndefined()) {
-        return globalObject.throwValueRet(globalObject.ERR_MISSING_ARGS_static(ZigString.static("message"), null, null));
+        return globalObject.throwMissingArgumentsValue(&.{"message"});
     }
     if (!message.isString() and !message.isObject() and !message.isNumber() and !message.isBoolean()) {
-        return globalObject.throwValueRet(globalObject.ERR_INVALID_ARG_TYPE_static(
-            ZigString.static("message"),
-            ZigString.static("string, object, number, or boolean"),
-            message,
-        ));
+        return globalObject.throwInvalidArgumentTypeValue("message", "string, object, number, or boolean", message);
     }
 
     const good = ipc_instance.data.serializeAndSend(globalObject, message);
@@ -492,7 +485,7 @@ pub export fn Bun__Process__send(
         }
     } else {
         const ex = globalObject.createTypeErrorInstance("process.send() failed", .{});
-        ex.put(globalObject, ZigString.static("syscall"), ZigString.static("write").toJS(globalObject));
+        ex.put(globalObject, ZigString.static("syscall"), bun.String.static("write").toJS(globalObject));
         if (callback.isFunction()) {
             Bun__Process__queueNextTick1(zigGlobal, callback, ex);
         } else {
@@ -624,8 +617,8 @@ pub const WebWorker = @import("./web_worker.zig").WebWorker;
 
 pub const ImportWatcher = union(enum) {
     none: void,
-    hot: *HotReloader.Watcher,
-    watch: *WatchReloader.Watcher,
+    hot: *Watcher,
+    watch: *Watcher,
 
     pub fn start(this: ImportWatcher) !void {
         switch (this) {
@@ -700,6 +693,77 @@ const body_value_pool_size = if (bun.heap_breakdown.enabled) 0 else 256;
 pub const BodyValueRef = bun.HiveRef(JSC.WebCore.Body.Value, body_value_pool_size);
 const BodyValueHiveAllocator = bun.HiveArray(BodyValueRef, body_value_pool_size).Fallback;
 
+const AutoKiller = struct {
+    const log = Output.scoped(.AutoKiller, true);
+    processes: std.AutoArrayHashMapUnmanaged(*bun.spawn.Process, void) = .{},
+    enabled: bool = false,
+    ever_enabled: bool = false,
+
+    pub fn enable(this: *AutoKiller) void {
+        this.enabled = true;
+        this.ever_enabled = true;
+    }
+
+    pub fn disable(this: *AutoKiller) void {
+        this.enabled = false;
+    }
+
+    pub const Result = struct {
+        processes: u32 = 0,
+
+        pub fn format(self: @This(), comptime _: []const u8, _: anytype, writer: anytype) !void {
+            switch (self.processes) {
+                0 => {},
+                1 => {
+                    try writer.writeAll("killed 1 dangling process");
+                },
+                else => {
+                    try std.fmt.format(writer, "killed {d} dangling processes", .{self.processes});
+                },
+            }
+        }
+    };
+
+    pub fn kill(this: *AutoKiller) Result {
+        return .{
+            .processes = this.killProcesses(),
+        };
+    }
+
+    fn killProcesses(this: *AutoKiller) u32 {
+        var count: u32 = 0;
+        while (this.processes.popOrNull()) |process| {
+            if (!process.key.hasExited()) {
+                log("process.kill {d}", .{process.key.pid});
+                count += @as(u32, @intFromBool(process.key.kill(bun.SignalCode.default) == .result));
+            }
+        }
+        return count;
+    }
+
+    pub fn clear(this: *AutoKiller) void {
+        if (this.processes.capacity() > 256) {
+            this.processes.clearAndFree(bun.default_allocator);
+        }
+
+        this.processes.clearRetainingCapacity();
+    }
+
+    pub fn onSubprocessSpawn(this: *AutoKiller, process: *bun.spawn.Process) void {
+        if (this.enabled)
+            this.processes.put(bun.default_allocator, process, {}) catch {};
+    }
+
+    pub fn onSubprocessExit(this: *AutoKiller, process: *bun.spawn.Process) void {
+        if (this.ever_enabled)
+            _ = this.processes.swapRemove(process);
+    }
+
+    pub fn deinit(this: *AutoKiller) void {
+        this.processes.deinit(bun.default_allocator);
+    }
+};
+
 /// TODO: rename this to ScriptExecutionContext
 /// This is the shared global state for a single JS instance execution
 /// Today, Bun is one VM per thread, so the name "VirtualMachine" sort of makes sense
@@ -716,7 +780,6 @@ pub const VirtualMachine = struct {
     main_resolved_path: bun.String = bun.String.empty,
     main_hash: u32 = 0,
     process: js.JSObjectRef = null,
-    flush_list: std.ArrayList(string),
     entry_point: ServerEntryPoint = undefined,
     origin: URL = URL{},
     node_fs: ?*Node.NodeFS = null,
@@ -765,6 +828,9 @@ pub const VirtualMachine = struct {
     macro_entry_points: std.AutoArrayHashMap(i32, *MacroEntryPoint),
     macro_mode: bool = false,
     no_macros: bool = false,
+    auto_killer: AutoKiller = .{
+        .enabled = false,
+    },
 
     has_any_macro_remappings: bool = false,
     is_from_devserver: bool = false,
@@ -879,6 +945,14 @@ pub const VirtualMachine = struct {
         return this.default_tls_reject_unauthorized orelse this.bundler.env.getTLSRejectUnauthorized();
     }
 
+    pub fn onSubprocessSpawn(this: *VirtualMachine, process: *bun.spawn.Process) void {
+        this.auto_killer.onSubprocessSpawn(process);
+    }
+
+    pub fn onSubprocessExit(this: *VirtualMachine, process: *bun.spawn.Process) void {
+        this.auto_killer.onSubprocessExit(process);
+    }
+
     pub fn getVerboseFetch(this: *VirtualMachine) bun.http.HTTPVerboseLevel {
         return this.default_verbose_fetch orelse {
             if (this.bundler.env.get("BUN_CONFIG_VERBOSE_FETCH")) |verbose_fetch| {
@@ -1154,6 +1228,14 @@ pub const VirtualMachine = struct {
         return handled;
     }
 
+    pub fn handlePendingInternalPromiseRejection(this: *JSC.VirtualMachine) void {
+        var promise = this.pending_internal_promise;
+        if (promise.status(this.global.vm()) == .rejected and !promise.isHandled(this.global.vm())) {
+            _ = this.unhandledRejection(this.global, promise.result(this.global.vm()), promise.asValue());
+            promise.setHandled(this.global.vm());
+        }
+    }
+
     pub fn defaultOnUnhandledRejection(this: *JSC.VirtualMachine, _: *JSC.JSGlobalObject, value: JSC.JSValue) void {
         this.runErrorHandler(value, this.onUnhandledRejectionExceptionList);
     }
@@ -1178,7 +1260,7 @@ pub const VirtualMachine = struct {
         }
     }
 
-    pub fn reload(this: *VirtualMachine) void {
+    pub fn reload(this: *VirtualMachine, _: *HotReloader.HotReloadTask) void {
         Output.debug("Reloading...", .{});
         const should_clear_terminal = !this.bundler.env.hasSetNoClearTerminalOnReload(!Output.enable_ansi_colors);
         if (this.hot_reload == .watch) {
@@ -1336,63 +1418,278 @@ pub const VirtualMachine = struct {
 
     pub var has_created_debugger: bool = false;
 
+    pub const TestReporterAgent = struct {
+        handle: ?*Handle = null,
+        const debug = Output.scoped(.TestReporterAgent, false);
+        pub const TestStatus = enum(u8) {
+            pass,
+            fail,
+            timeout,
+            skip,
+            todo,
+        };
+        pub const Handle = opaque {
+            extern "c" fn Bun__TestReporterAgentReportTestFound(agent: *Handle, callFrame: *JSC.CallFrame, testId: c_int, name: *String) void;
+            extern "c" fn Bun__TestReporterAgentReportTestStart(agent: *Handle, testId: c_int) void;
+            extern "c" fn Bun__TestReporterAgentReportTestEnd(agent: *Handle, testId: c_int, bunTestStatus: TestStatus, elapsed: f64) void;
+
+            pub fn reportTestFound(this: *Handle, callFrame: *JSC.CallFrame, testId: i32, name: *String) void {
+                Bun__TestReporterAgentReportTestFound(this, callFrame, testId, name);
+            }
+
+            pub fn reportTestStart(this: *Handle, testId: c_int) void {
+                Bun__TestReporterAgentReportTestStart(this, testId);
+            }
+
+            pub fn reportTestEnd(this: *Handle, testId: c_int, bunTestStatus: TestStatus, elapsed: f64) void {
+                Bun__TestReporterAgentReportTestEnd(this, testId, bunTestStatus, elapsed);
+            }
+        };
+        pub export fn Bun__TestReporterAgentEnable(agent: *Handle) void {
+            if (JSC.VirtualMachine.get().debugger) |*debugger| {
+                debug("enable", .{});
+                debugger.test_reporter_agent.handle = agent;
+            }
+        }
+        pub export fn Bun__TestReporterAgentDisable(agent: *Handle) void {
+            _ = agent; // autofix
+            if (JSC.VirtualMachine.get().debugger) |*debugger| {
+                debug("disable", .{});
+                debugger.test_reporter_agent.handle = null;
+            }
+        }
+
+        /// Caller must ensure that it is enabled first.
+        ///
+        /// Since we may have to call .deinit on the name string.
+        pub fn reportTestFound(this: TestReporterAgent, callFrame: *JSC.CallFrame, test_id: i32, name: *bun.String) void {
+            debug("reportTestFound", .{});
+
+            this.handle.?.reportTestFound(callFrame, test_id, name);
+        }
+
+        /// Caller must ensure that it is enabled first.
+        pub fn reportTestStart(this: TestReporterAgent, test_id: i32) void {
+            debug("reportTestStart", .{});
+            this.handle.?.reportTestStart(test_id);
+        }
+
+        /// Caller must ensure that it is enabled first.
+        pub fn reportTestEnd(this: TestReporterAgent, test_id: i32, bunTestStatus: TestStatus, elapsed: f64) void {
+            debug("reportTestEnd", .{});
+            this.handle.?.reportTestEnd(test_id, bunTestStatus, elapsed);
+        }
+
+        pub fn isEnabled(this: TestReporterAgent) bool {
+            return this.handle != null;
+        }
+    };
+
+    pub const LifecycleAgent = struct {
+        handle: ?*Handle = null,
+        const debug = Output.scoped(.LifecycleAgent, false);
+
+        pub const Handle = opaque {
+            extern "c" fn Bun__LifecycleAgentReportReload(agent: *Handle) void;
+            extern "c" fn Bun__LifecycleAgentReportError(agent: *Handle, exception: *JSC.ZigException) void;
+            extern "c" fn Bun__LifecycleAgentPreventExit(agent: *Handle) void;
+            extern "c" fn Bun__LifecycleAgentStopPreventingExit(agent: *Handle) void;
+
+            pub fn preventExit(this: *Handle) void {
+                Bun__LifecycleAgentPreventExit(this);
+            }
+
+            pub fn stopPreventingExit(this: *Handle) void {
+                Bun__LifecycleAgentStopPreventingExit(this);
+            }
+
+            pub fn reportReload(this: *Handle) void {
+                debug("reportReload", .{});
+                Bun__LifecycleAgentReportReload(this);
+            }
+
+            pub fn reportError(this: *Handle, exception: *JSC.ZigException) void {
+                debug("reportError", .{});
+                Bun__LifecycleAgentReportError(this, exception);
+            }
+        };
+
+        pub export fn Bun__LifecycleAgentEnable(agent: *Handle) void {
+            if (JSC.VirtualMachine.get().debugger) |*debugger| {
+                debug("enable", .{});
+                debugger.lifecycle_reporter_agent.handle = agent;
+            }
+        }
+
+        pub export fn Bun__LifecycleAgentDisable(agent: *Handle) void {
+            _ = agent; // autofix
+            if (JSC.VirtualMachine.get().debugger) |*debugger| {
+                debug("disable", .{});
+                debugger.lifecycle_reporter_agent.handle = null;
+            }
+        }
+
+        pub fn reportReload(this: *LifecycleAgent) void {
+            if (this.handle) |handle| {
+                handle.reportReload();
+            }
+        }
+
+        pub fn reportError(this: *LifecycleAgent, exception: *JSC.ZigException) void {
+            if (this.handle) |handle| {
+                handle.reportError(exception);
+            }
+        }
+
+        pub fn isEnabled(this: *const LifecycleAgent) bool {
+            return this.handle != null;
+        }
+    };
+
     pub const Debugger = struct {
         path_or_port: ?[]const u8 = null,
-        unix: []const u8 = "",
+        from_environment_variable: []const u8 = "",
         script_execution_context_id: u32 = 0,
         next_debugger_id: u64 = 1,
         poll_ref: Async.KeepAlive = .{},
-        wait_for_connection: bool = false,
+        wait_for_connection: Wait = .off,
+        // wait_for_connection: bool = false,
         set_breakpoint_on_first_line: bool = false,
+        mode: enum {
+            /// Bun acts as the server. https://debug.bun.sh/ uses this
+            listen,
+            /// Bun connects to this path. The VSCode extension uses this.
+            connect,
+        } = .listen,
 
-        const debug = Output.scoped(.DEBUGGER, false);
+        test_reporter_agent: TestReporterAgent = .{},
+        lifecycle_reporter_agent: LifecycleAgent = .{},
+        must_block_until_connected: bool = false,
+
+        pub const Wait = enum { off, shortly, forever };
+
+        pub const log = Output.scoped(.debugger, false);
 
         extern "C" fn Bun__createJSDebugger(*JSC.JSGlobalObject) u32;
         extern "C" fn Bun__ensureDebugger(u32, bool) void;
-        extern "C" fn Bun__startJSDebuggerThread(*JSC.JSGlobalObject, u32, *bun.String) void;
+        extern "C" fn Bun__startJSDebuggerThread(*JSC.JSGlobalObject, u32, *bun.String, c_int, bool) void;
         var futex_atomic: std.atomic.Value(u32) = undefined;
 
-        pub fn create(this: *VirtualMachine, globalObject: *JSGlobalObject) !void {
-            debug("create", .{});
-            JSC.markBinding(@src());
-            if (has_created_debugger) return;
-            has_created_debugger = true;
-            var debugger = &this.debugger.?;
-            debugger.script_execution_context_id = Bun__createJSDebugger(globalObject);
-            if (!this.has_started_debugger) {
-                this.has_started_debugger = true;
-                futex_atomic = std.atomic.Value(u32).init(0);
-                var thread = try std.Thread.spawn(.{}, startJSDebuggerThread, .{this});
-                thread.detach();
+        pub fn waitForDebuggerIfNecessary(this: *VirtualMachine) void {
+            const debugger = &(this.debugger orelse return);
+            if (!debugger.must_block_until_connected) {
+                return;
             }
-            this.eventLoop().ensureWaker();
+            defer debugger.must_block_until_connected = false;
 
-            if (debugger.wait_for_connection) {
-                debugger.poll_ref.ref(this);
-            }
-
-            debug("spin", .{});
+            Debugger.log("spin", .{});
             while (futex_atomic.load(.monotonic) > 0) {
                 std.Thread.Futex.wait(&futex_atomic, 1);
             }
-            if (comptime Environment.allow_assert)
-                debug("waitForDebugger: {}", .{Output.ElapsedFormatter{
+            if (comptime Environment.enable_logs)
+                Debugger.log("waitForDebugger: {}", .{Output.ElapsedFormatter{
                     .colors = Output.enable_ansi_colors_stderr,
                     .duration_ns = @truncate(@as(u128, @intCast(std.time.nanoTimestamp() - bun.CLI.start_time))),
                 }});
 
-            Bun__ensureDebugger(debugger.script_execution_context_id, debugger.wait_for_connection);
-            while (debugger.wait_for_connection) {
+            Bun__ensureDebugger(debugger.script_execution_context_id, debugger.wait_for_connection != .off);
+
+            // Sleep up to 30ms for automatic inspection.
+            const wait_for_connection_delay_ms = 30;
+
+            var deadline: bun.timespec = if (debugger.wait_for_connection == .shortly) bun.timespec.now().addMs(wait_for_connection_delay_ms) else undefined;
+
+            if (comptime Environment.isWindows) {
+                // TODO: remove this when tickWithTimeout actually works properly on Windows.
+                if (debugger.wait_for_connection == .shortly) {
+                    uv.uv_update_time(this.uvLoop());
+                    var timer = bun.default_allocator.create(uv.Timer) catch bun.outOfMemory();
+                    timer.* = std.mem.zeroes(uv.Timer);
+                    timer.init(this.uvLoop());
+                    const onDebuggerTimer = struct {
+                        fn call(handle: *uv.Timer) callconv(.C) void {
+                            const vm = JSC.VirtualMachine.get();
+                            vm.debugger.?.poll_ref.unref(vm);
+                            uv.uv_close(@ptrCast(handle), deinitTimer);
+                        }
+
+                        fn deinitTimer(handle: *anyopaque) callconv(.C) void {
+                            bun.default_allocator.destroy(@as(*uv.Timer, @alignCast(@ptrCast(handle))));
+                        }
+                    }.call;
+                    timer.start(wait_for_connection_delay_ms, 0, &onDebuggerTimer);
+                    timer.ref();
+                }
+            }
+
+            while (debugger.wait_for_connection != .off) {
                 this.eventLoop().tick();
-                if (debugger.wait_for_connection)
-                    this.eventLoop().autoTickActive();
+                switch (debugger.wait_for_connection) {
+                    .forever => {
+                        this.eventLoop().autoTickActive();
+
+                        if (comptime Environment.enable_logs)
+                            log("waited: {}", .{bun.fmt.fmtDuration(@intCast(@as(i64, @truncate(std.time.nanoTimestamp() - bun.CLI.start_time))))});
+                    },
+                    .shortly => {
+                        // Handle .incrementRefConcurrently
+                        if (comptime Environment.isPosix) {
+                            const pending_unref = this.pending_unref_counter;
+                            if (pending_unref > 0) {
+                                this.pending_unref_counter = 0;
+                                this.uwsLoop().unrefCount(pending_unref);
+                            }
+                        }
+
+                        this.uwsLoop().tickWithTimeout(&deadline);
+
+                        if (comptime Environment.enable_logs)
+                            log("waited: {}", .{bun.fmt.fmtDuration(@intCast(@as(i64, @truncate(std.time.nanoTimestamp() - bun.CLI.start_time))))});
+
+                        const elapsed = bun.timespec.now();
+                        if (elapsed.order(&deadline) != .lt) {
+                            debugger.poll_ref.unref(this);
+                            log("Timed out waiting for the debugger", .{});
+                            break;
+                        }
+                    },
+                    .off => {
+                        break;
+                    },
+                }
+            }
+        }
+
+        pub fn create(this: *VirtualMachine, globalObject: *JSGlobalObject) !void {
+            log("create", .{});
+            JSC.markBinding(@src());
+            if (!has_created_debugger) {
+                has_created_debugger = true;
+                std.mem.doNotOptimizeAway(&TestReporterAgent.Bun__TestReporterAgentDisable);
+                std.mem.doNotOptimizeAway(&LifecycleAgent.Bun__LifecycleAgentDisable);
+                std.mem.doNotOptimizeAway(&TestReporterAgent.Bun__TestReporterAgentEnable);
+                std.mem.doNotOptimizeAway(&LifecycleAgent.Bun__LifecycleAgentEnable);
+                var debugger = &this.debugger.?;
+                debugger.script_execution_context_id = Bun__createJSDebugger(globalObject);
+                if (!this.has_started_debugger) {
+                    this.has_started_debugger = true;
+                    futex_atomic = std.atomic.Value(u32).init(0);
+                    var thread = try std.Thread.spawn(.{}, startJSDebuggerThread, .{this});
+                    thread.detach();
+                }
+                this.eventLoop().ensureWaker();
+
+                if (debugger.wait_for_connection != .off) {
+                    debugger.poll_ref.ref(this);
+                    debugger.must_block_until_connected = true;
+                }
             }
         }
 
         pub fn startJSDebuggerThread(other_vm: *VirtualMachine) void {
             var arena = bun.MimallocArena.init() catch unreachable;
             Output.Source.configureNamedThread("Debugger");
-            debug("startJSDebuggerThread", .{});
+            log("startJSDebuggerThread", .{});
             JSC.markBinding(@src());
 
             var vm = JSC.VirtualMachine.init(.{
@@ -1412,9 +1709,10 @@ pub const VirtualMachine = struct {
 
         pub export fn Debugger__didConnect() void {
             var this = VirtualMachine.get();
-            bun.assert(this.debugger.?.wait_for_connection);
-            this.debugger.?.wait_for_connection = false;
-            this.debugger.?.poll_ref.unref(this);
+            if (this.debugger.?.wait_for_connection != .off) {
+                this.debugger.?.wait_for_connection = .off;
+                this.debugger.?.poll_ref.unref(this);
+            }
         }
 
         fn start(other_vm: *VirtualMachine) void {
@@ -1422,35 +1720,42 @@ pub const VirtualMachine = struct {
 
             var this = VirtualMachine.get();
             const debugger = other_vm.debugger.?;
+            const loop = this.eventLoop();
 
-            if (debugger.unix.len > 0) {
-                var url = bun.String.createUTF8(debugger.unix);
-                Bun__startJSDebuggerThread(this.global, debugger.script_execution_context_id, &url);
+            if (debugger.from_environment_variable.len > 0) {
+                var url = bun.String.createUTF8(debugger.from_environment_variable);
+
+                loop.enter();
+                defer loop.exit();
+                Bun__startJSDebuggerThread(this.global, debugger.script_execution_context_id, &url, 1, debugger.mode == .connect);
             }
 
             if (debugger.path_or_port) |path_or_port| {
                 var url = bun.String.createUTF8(path_or_port);
-                Bun__startJSDebuggerThread(this.global, debugger.script_execution_context_id, &url);
+
+                loop.enter();
+                defer loop.exit();
+                Bun__startJSDebuggerThread(this.global, debugger.script_execution_context_id, &url, 0, debugger.mode == .connect);
             }
 
             this.global.handleRejectedPromises();
 
             if (this.log.msgs.items.len > 0) {
-                if (Output.enable_ansi_colors) {
-                    this.log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), true) catch {};
-                } else {
-                    this.log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), false) catch {};
-                }
+                this.log.print(Output.errorWriter()) catch {};
                 Output.prettyErrorln("\n", .{});
                 Output.flush();
             }
 
-            debug("wake", .{});
+            log("wake", .{});
             futex_atomic.store(0, .monotonic);
             std.Thread.Futex.wake(&futex_atomic, 1);
 
+            other_vm.eventLoop().wakeup();
+
             this.eventLoop().tick();
 
+            other_vm.eventLoop().wakeup();
+
             while (true) {
                 while (this.isEventLoopAlive()) {
                     this.tick();
@@ -1579,7 +1884,6 @@ pub const VirtualMachine = struct {
             .bundler = bundler,
             .console = console,
             .log = log,
-            .flush_list = std.ArrayList(string).init(allocator),
             .origin = bundler.options.origin,
             .saved_source_map_table = SavedSourceMap.HashTable.init(bun.default_allocator),
             .source_mappings = undefined,
@@ -1620,7 +1924,6 @@ pub const VirtualMachine = struct {
 
         // Avoid reading from tsconfig.json & package.json when we're in standalone mode
         vm.bundler.configureLinkerWithAutoJSX(false);
-        try vm.bundler.configureFramework(false);
 
         vm.bundler.macro_context = js_ast.Macro.MacroContext.init(&vm.bundler);
 
@@ -1688,7 +1991,6 @@ pub const VirtualMachine = struct {
             .bundler = bundler,
             .console = console,
             .log = log,
-            .flush_list = std.ArrayList(string).init(allocator),
             .origin = bundler.options.origin,
             .saved_source_map_table = SavedSourceMap.HashTable.init(bun.default_allocator),
             .source_mappings = undefined,
@@ -1725,14 +2027,9 @@ pub const VirtualMachine = struct {
         };
 
         vm.bundler.configureLinker();
-        try vm.bundler.configureFramework(false);
 
         vm.bundler.macro_context = js_ast.Macro.MacroContext.init(&vm.bundler);
 
-        if (opts.args.serve orelse false) {
-            vm.bundler.linker.onImportCSS = Bun.onImportCSS;
-        }
-
         vm.global = ZigGlobalObject.create(
             vm.console,
             -1,
@@ -1762,33 +2059,63 @@ pub const VirtualMachine = struct {
         }
     }
 
-    fn configureDebugger(this: *VirtualMachine, debugger: bun.CLI.Command.Debugger) void {
-        const unix = bun.getenvZ("BUN_INSPECT") orelse "";
-        const set_breakpoint_on_first_line = unix.len > 0 and strings.endsWith(unix, "?break=1");
-        const wait_for_connection = set_breakpoint_on_first_line or (unix.len > 0 and strings.endsWith(unix, "?wait=1"));
+    fn configureDebugger(this: *VirtualMachine, cli_flag: bun.CLI.Command.Debugger) void {
+        if (bun.getenvZ("HYPERFINE_RANDOMIZED_ENVIRONMENT_OFFSET") != null) {
+            return;
+        }
 
-        switch (debugger) {
+        const unix = bun.getenvZ("BUN_INSPECT") orelse "";
+        const notify = bun.getenvZ("BUN_INSPECT_NOTIFY") orelse "";
+        const connect_to = bun.getenvZ("BUN_INSPECT_CONNECT_TO") orelse "";
+
+        const set_breakpoint_on_first_line = unix.len > 0 and strings.endsWith(unix, "?break=1"); // If we should set a breakpoint on the first line
+        const wait_for_debugger = unix.len > 0 and strings.endsWith(unix, "?wait=1"); // If we should wait for the debugger to connect before starting the event loop
+
+        const wait_for_connection: Debugger.Wait = switch (set_breakpoint_on_first_line or wait_for_debugger) {
+            true => if (notify.len > 0 or connect_to.len > 0) .shortly else .forever,
+            false => .off,
+        };
+
+        switch (cli_flag) {
             .unspecified => {
                 if (unix.len > 0) {
                     this.debugger = Debugger{
                         .path_or_port = null,
-                        .unix = unix,
+                        .from_environment_variable = unix,
                         .wait_for_connection = wait_for_connection,
                         .set_breakpoint_on_first_line = set_breakpoint_on_first_line,
                     };
+                } else if (notify.len > 0) {
+                    this.debugger = Debugger{
+                        .path_or_port = null,
+                        .from_environment_variable = notify,
+                        .wait_for_connection = wait_for_connection,
+                        .set_breakpoint_on_first_line = set_breakpoint_on_first_line,
+                        .mode = .connect,
+                    };
+                } else if (connect_to.len > 0) {
+                    // This works in the vscode debug terminal because that relies on unix or notify being set, which they
+                    // are in the debug terminal. This branch doesn't reach
+                    this.debugger = Debugger{
+                        .path_or_port = null,
+                        .from_environment_variable = connect_to,
+                        .wait_for_connection = wait_for_connection,
+                        .set_breakpoint_on_first_line = set_breakpoint_on_first_line,
+                        .mode = .connect,
+                    };
                 }
             },
             .enable => {
                 this.debugger = Debugger{
-                    .path_or_port = debugger.enable.path_or_port,
-                    .unix = unix,
-                    .wait_for_connection = wait_for_connection or debugger.enable.wait_for_connection,
-                    .set_breakpoint_on_first_line = set_breakpoint_on_first_line or debugger.enable.set_breakpoint_on_first_line,
+                    .path_or_port = cli_flag.enable.path_or_port,
+                    .from_environment_variable = unix,
+                    .wait_for_connection = if (cli_flag.enable.wait_for_connection) .forever else wait_for_connection,
+                    .set_breakpoint_on_first_line = set_breakpoint_on_first_line or cli_flag.enable.set_breakpoint_on_first_line,
                 };
             },
         }
 
-        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;
@@ -1829,7 +2156,6 @@ pub const VirtualMachine = struct {
             .bundler = bundler,
             .console = console,
             .log = log,
-            .flush_list = std.ArrayList(string).init(allocator),
             .origin = bundler.options.origin,
             .saved_source_map_table = SavedSourceMap.HashTable.init(bun.default_allocator),
             .source_mappings = undefined,
@@ -1873,14 +2199,9 @@ pub const VirtualMachine = struct {
             vm.bundler.configureLinkerWithAutoJSX(false);
         }
 
-        try vm.bundler.configureFramework(false);
         vm.smol = opts.smol;
         vm.bundler.macro_context = js_ast.Macro.MacroContext.init(&vm.bundler);
 
-        if (opts.args.serve orelse false) {
-            vm.bundler.linker.onImportCSS = Bun.onImportCSS;
-        }
-
         vm.global = ZigGlobalObject.create(
             vm.console,
             @as(i32, @intCast(worker.execution_context_id)),
@@ -1897,7 +2218,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;
@@ -1927,7 +2248,6 @@ pub const VirtualMachine = struct {
             .bundler = bundler,
             .console = console,
             .log = log,
-            .flush_list = std.ArrayList(string).init(allocator),
             .origin = bundler.options.origin,
             .saved_source_map_table = SavedSourceMap.HashTable.init(bun.default_allocator),
             .source_mappings = undefined,
@@ -1964,14 +2284,9 @@ pub const VirtualMachine = struct {
         };
 
         vm.bundler.configureLinker();
-        try vm.bundler.configureFramework(false);
 
         vm.bundler.macro_context = js_ast.Macro.MacroContext.init(&vm.bundler);
 
-        if (opts.args.serve orelse false) {
-            vm.bundler.linker.onImportCSS = Bun.onImportCSS;
-        }
-
         vm.regular_event_loop.virtual_machine = vm;
         vm.smol = opts.smol;
 
@@ -2142,7 +2457,6 @@ pub const VirtualMachine = struct {
                     if (!blob.needsToReadFile()) {
                         virtual_source_to_use = logger.Source{
                             .path = path,
-                            .key_path = path,
                             .contents = blob.sharedView(),
                         };
                     }
@@ -2227,7 +2541,7 @@ pub const VirtualMachine = struct {
             ret.result = null;
             ret.path = specifier;
             return;
-        } else if (strings.hasPrefixComptime(specifier, "/bun-vfs/node_modules/")) {
+        } else if (strings.hasPrefixComptime(specifier, NodeFallbackModules.import_path)) {
             ret.result = null;
             ret.path = specifier;
             return;
@@ -2287,7 +2601,7 @@ pub const VirtualMachine = struct {
                         const buster_name = name: {
                             if (std.fs.path.isAbsolute(normalized_specifier)) {
                                 if (std.fs.path.dirname(normalized_specifier)) |dir| {
-                                    // Normalized with trailing slash
+                                    // Normalized without trailing slash
                                     break :name bun.strings.normalizeSlashesOnly(&specifier_cache_resolver_buf, dir, std.fs.path.sep);
                                 }
                             }
@@ -2307,7 +2621,7 @@ pub const VirtualMachine = struct {
                         };
 
                         // Only re-query if we previously had something cached.
-                        if (jsc_vm.bundler.resolver.bustDirCache(buster_name)) {
+                        if (jsc_vm.bundler.resolver.bustDirCache(bun.strings.withoutTrailingSlashWindowsPath(buster_name))) {
                             continue;
                         }
 
@@ -2336,7 +2650,8 @@ pub const VirtualMachine = struct {
         query_string: ?*ZigString,
         is_esm: bool,
     ) void {
-        resolveMaybeNeedsTrailingSlash(res, global, specifier, source, query_string, is_esm, false);
+        resolveMaybeNeedsTrailingSlash(res, global, specifier, source, query_string, is_esm, false) catch {};
+        // TODO: handle js exception
     }
 
     pub fn resolveFilePathForAPI(
@@ -2347,7 +2662,8 @@ pub const VirtualMachine = struct {
         query_string: ?*ZigString,
         is_esm: bool,
     ) void {
-        resolveMaybeNeedsTrailingSlash(res, global, specifier, source, query_string, is_esm, true);
+        resolveMaybeNeedsTrailingSlash(res, global, specifier, source, query_string, is_esm, true) catch {};
+        // TODO: handle js exception
     }
 
     pub fn resolve(
@@ -2358,7 +2674,8 @@ pub const VirtualMachine = struct {
         query_string: ?*ZigString,
         is_esm: bool,
     ) void {
-        resolveMaybeNeedsTrailingSlash(res, global, specifier, source, query_string, is_esm, true);
+        resolveMaybeNeedsTrailingSlash(res, global, specifier, source, query_string, is_esm, true) catch {};
+        // TODO: handle js exception
     }
 
     fn normalizeSource(source: []const u8) []const u8 {
@@ -2369,15 +2686,7 @@ pub const VirtualMachine = struct {
         return source;
     }
 
-    fn resolveMaybeNeedsTrailingSlash(
-        res: *ErrorableString,
-        global: *JSGlobalObject,
-        specifier: bun.String,
-        source: bun.String,
-        query_string: ?*ZigString,
-        is_esm: bool,
-        comptime is_a_file_path: bool,
-    ) void {
+    fn resolveMaybeNeedsTrailingSlash(res: *ErrorableString, global: *JSGlobalObject, specifier: bun.String, source: bun.String, query_string: ?*ZigString, is_esm: bool, comptime is_a_file_path: bool) bun.JSError!void {
         if (is_a_file_path and specifier.length() > comptime @as(u32, @intFromFloat(@trunc(@as(f64, @floatFromInt(bun.MAX_PATH_BYTES)) * 1.5)))) {
             const specifier_utf8 = specifier.toUTF8(bun.default_allocator);
             defer specifier_utf8.deinit();
@@ -2415,7 +2724,7 @@ pub const VirtualMachine = struct {
                 else
                     specifier_utf8.slice()[namespace.len + 1 .. specifier_utf8.len];
 
-                if (plugin_runner.onResolveJSC(bun.String.init(namespace), bun.String.fromUTF8(after_namespace), source, .bun)) |resolved_path| {
+                if (try plugin_runner.onResolveJSC(bun.String.init(namespace), bun.String.fromUTF8(after_namespace), source, .bun)) |resolved_path| {
                     res.* = resolved_path;
                     return;
                 }
@@ -2423,18 +2732,18 @@ pub const VirtualMachine = struct {
         }
 
         if (JSC.HardcodedModule.Aliases.getWithEql(specifier, bun.String.eqlComptime, jsc_vm.bundler.options.target)) |hardcoded| {
-            if (hardcoded.tag == .none) {
-                resolveMaybeNeedsTrailingSlash(
-                    res,
-                    global,
-                    bun.String.init(hardcoded.path),
-                    source,
-                    query_string,
-                    is_esm,
-                    is_a_file_path,
-                );
-                return;
-            }
+            // if (hardcoded.tag == .none) {
+            //     resolveMaybeNeedsTrailingSlash(
+            //         res,
+            //         global,
+            //         bun.String.init(hardcoded.path),
+            //         source,
+            //         query_string,
+            //         is_esm,
+            //         is_a_file_path,
+            //     );
+            //     return;
+            // }
 
             res.* = ErrorableString.ok(bun.String.init(hardcoded.path));
             return;
@@ -2577,6 +2886,8 @@ pub const VirtualMachine = struct {
 
     // TODO:
     pub fn deinit(this: *VirtualMachine) void {
+        this.auto_killer.deinit();
+
         if (source_code_printer) |print| {
             print.getMutableBuffer().deinit();
             print.ctx.written = &.{};
@@ -2681,7 +2992,7 @@ pub const VirtualMachine = struct {
                         "{s} resolving preload {}",
                         .{
                             @errorName(e),
-                            js_printer.formatJSONString(preload),
+                            bun.fmt.formatJSONString(preload),
                         },
                     ) catch unreachable;
                     return e;
@@ -2693,7 +3004,7 @@ pub const VirtualMachine = struct {
                         this.allocator,
                         "preload not found {}",
                         .{
-                            js_printer.formatJSONString(preload),
+                            bun.fmt.formatJSONString(preload),
                         },
                     ) catch unreachable;
                     return error.ModuleNotFound;
@@ -2737,11 +3048,23 @@ pub const VirtualMachine = struct {
         return null;
     }
 
+    pub fn ensureDebugger(this: *VirtualMachine, block_until_connected: bool) !void {
+        if (this.debugger != null) {
+            try Debugger.create(this, this.global);
+
+            if (block_until_connected) {
+                Debugger.waitForDebuggerIfNecessary(this);
+            }
+        }
+    }
+
     pub fn reloadEntryPoint(this: *VirtualMachine, entry_path: []const u8) !*JSInternalPromise {
         this.has_loaded = false;
         this.main = entry_path;
         this.main_hash = GenericWatcher.getHash(entry_path);
 
+        try this.ensureDebugger(true);
+
         try this.entry_point.generate(
             this.allocator,
             this.bun_watcher != .none,
@@ -2750,10 +3073,6 @@ pub const VirtualMachine = struct {
         );
         this.eventLoop().ensureWaker();
 
-        if (this.debugger != null) {
-            try Debugger.create(this, this.global);
-        }
-
         if (!this.bundler.options.disable_transpilation) {
             if (try this.loadPreloads()) |promise| {
                 JSC.JSValue.fromCell(promise).ensureStillAlive();
@@ -2767,7 +3086,7 @@ pub const VirtualMachine = struct {
             JSC.JSValue.fromCell(promise).ensureStillAlive();
             return promise;
         } else {
-            const promise = JSModuleLoader.loadAndEvaluateModule(this.global, &String.init(this.main)) orelse return error.JSError;
+            const promise = JSModuleLoader.loadAndEvaluateModule(this.global, &String.fromBytes(this.main)) orelse return error.JSError;
             this.pending_internal_promise = promise;
             JSC.JSValue.fromCell(promise).ensureStillAlive();
 
@@ -2782,9 +3101,7 @@ pub const VirtualMachine = struct {
 
         this.eventLoop().ensureWaker();
 
-        if (this.debugger != null) {
-            try Debugger.create(this, this.global);
-        }
+        try this.ensureDebugger(true);
 
         if (!this.bundler.options.disable_transpilation) {
             if (try this.loadPreloads()) |promise| {
@@ -3290,6 +3607,7 @@ pub const VirtualMachine = struct {
         if (frames.len == 0) return;
 
         var top = &frames[0];
+        var top_frame_is_builtin = false;
         if (this.hide_bun_stackframes) {
             for (frames) |*frame| {
                 if (frame.source_url.hasPrefixComptime("bun:") or
@@ -3297,10 +3615,12 @@ pub const VirtualMachine = struct {
                     frame.source_url.isEmpty() or
                     frame.source_url.eqlComptime("native"))
                 {
+                    top_frame_is_builtin = true;
                     continue;
                 }
 
                 top = frame;
+                top_frame_is_builtin = false;
                 break;
             }
         }
@@ -3349,8 +3669,14 @@ pub const VirtualMachine = struct {
                     }
                 }
 
+                if (top_frame_is_builtin) {
+                    // Avoid printing "export default 'native'"
+                    break :code ZigString.Slice.empty;
+                }
+
                 var log = logger.Log.init(bun.default_allocator);
                 defer log.deinit();
+
                 var original_source = fetchWithoutOnLoadPlugins(this, this.global, top.source_url, bun.String.empty, &log, .print_source) catch return;
                 must_reset_parser_arena_later.* = true;
                 break :code original_source.source_code.toUTF8(bun.default_allocator);
@@ -3436,10 +3762,15 @@ pub const VirtualMachine = struct {
         this.had_errors = true;
         defer this.had_errors = prev_had_errors;
 
-        if (allow_side_effects and Output.is_github_action) {
-            defer printGithubAnnotation(exception);
+        if (allow_side_effects) {
+            if (this.debugger) |*debugger| {
+                debugger.lifecycle_reporter_agent.reportError(exception);
+            }
         }
 
+        defer if (allow_side_effects and Output.is_github_action)
+            printGithubAnnotation(exception);
+
         // This is a longer number than necessary because we don't handle this case very well
         // At the very least, we shouldn't dump 100 KB of minified code into your terminal.
         const max_line_length_with_divot = 512;
@@ -3471,7 +3802,7 @@ pub const VirtualMachine = struct {
                         "<r><b>{d} |<r> {}" ++ fmt,
                         allow_ansi_color,
                     ),
-                    .{ display_line, bun.fmt.fmtJavaScript(clamped, allow_ansi_color) },
+                    .{ display_line, bun.fmt.fmtJavaScript(clamped, .{ .enable_colors = allow_ansi_color }) },
                 );
             } else {
                 try writer.print(
@@ -3479,7 +3810,7 @@ pub const VirtualMachine = struct {
                         "<r><b>{d} |<r> {}\n",
                         allow_ansi_color,
                     ),
-                    .{ display_line, bun.fmt.fmtJavaScript(clamped, allow_ansi_color) },
+                    .{ display_line, bun.fmt.fmtJavaScript(clamped, .{ .enable_colors = allow_ansi_color }) },
                 );
             }
         }
@@ -3516,7 +3847,7 @@ pub const VirtualMachine = struct {
                             "<r><b>- |<r> {}" ++ fmt,
                             allow_ansi_color,
                         ),
-                        .{bun.fmt.fmtJavaScript(text, allow_ansi_color)},
+                        .{bun.fmt.fmtJavaScript(text, .{ .enable_colors = allow_ansi_color })},
                     );
                 } else {
                     try writer.print(
@@ -3524,7 +3855,7 @@ pub const VirtualMachine = struct {
                             "<r><d>- |<r> {}\n",
                             allow_ansi_color,
                         ),
-                        .{bun.fmt.fmtJavaScript(text, allow_ansi_color)},
+                        .{bun.fmt.fmtJavaScript(text, .{ .enable_colors = allow_ansi_color })},
                     );
                 }
 
@@ -3549,7 +3880,7 @@ pub const VirtualMachine = struct {
                             "<r><b>{d} |<r> {}" ++ fmt,
                             allow_ansi_color,
                         ),
-                        .{ display_line, bun.fmt.fmtJavaScript(clamped, allow_ansi_color) },
+                        .{ display_line, bun.fmt.fmtJavaScript(clamped, .{ .enable_colors = allow_ansi_color }) },
                     );
                 } else {
                     try writer.print(
@@ -3557,7 +3888,7 @@ pub const VirtualMachine = struct {
                             "<r><b>{d} |<r> {}\n",
                             allow_ansi_color,
                         ),
-                        .{ display_line, bun.fmt.fmtJavaScript(clamped, allow_ansi_color) },
+                        .{ display_line, bun.fmt.fmtJavaScript(clamped, .{ .enable_colors = allow_ansi_color }) },
                     );
 
                     if (clamped.len < max_line_length_with_divot or top.position.column.zeroBased() > max_line_length_with_divot) {
@@ -3618,7 +3949,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| {
@@ -3924,7 +4255,7 @@ pub const VirtualMachine = struct {
                     IPC.log("Received IPC internal message from parent", .{});
                     event_loop.enter();
                     defer event_loop.exit();
-                    node_cluster_binding.handleInternalMessageChild(globalThis, data);
+                    node_cluster_binding.handleInternalMessageChild(globalThis, data) catch return;
                 },
             }
         }
@@ -4025,20 +4356,28 @@ pub const VirtualMachine = struct {
         return instance;
     }
 
+    /// To satisfy the interface from NewHotReloader()
+    pub fn getLoaders(vm: *VirtualMachine) *bun.options.Loader.HashTable {
+        return &vm.bundler.options.loaders;
+    }
+
+    /// To satisfy the interface from NewHotReloader()
+    pub fn bustDirCache(vm: *VirtualMachine, path: []const u8) bool {
+        return vm.bundler.resolver.bustDirCache(path);
+    }
+
     comptime {
-        if (!JSC.is_bindgen)
-            _ = Bun__remapStackFramePositions;
+        _ = Bun__remapStackFramePositions;
     }
 };
 
+pub const Watcher = GenericWatcher.NewWatcher;
 pub const HotReloader = NewHotReloader(VirtualMachine, JSC.EventLoop, false);
 pub const WatchReloader = NewHotReloader(VirtualMachine, JSC.EventLoop, true);
-pub const Watcher = HotReloader.Watcher;
 extern fn BunDebugger__willHotReload() void;
 
 pub fn NewHotReloader(comptime Ctx: type, comptime EventLoopType: type, comptime reload_immediately: bool) type {
     return struct {
-        pub const Watcher = GenericWatcher.NewWatcher(*@This());
         const Reloader = @This();
 
         ctx: *Ctx,
@@ -4047,7 +4386,7 @@ pub fn NewHotReloader(comptime Ctx: type, comptime EventLoopType: type, comptime
 
         tombstones: bun.StringHashMapUnmanaged(*bun.fs.FileSystem.RealFS.EntriesOption) = .{},
 
-        pub fn init(ctx: *Ctx, fs: *bun.fs.FileSystem, verbose: bool, clear_screen_flag: bool) *@This().Watcher {
+        pub fn init(ctx: *Ctx, fs: *bun.fs.FileSystem, verbose: bool, clear_screen_flag: bool) *Watcher {
             const reloader = bun.default_allocator.create(Reloader) catch bun.outOfMemory();
             reloader.* = .{
                 .ctx = ctx,
@@ -4055,7 +4394,7 @@ pub fn NewHotReloader(comptime Ctx: type, comptime EventLoopType: type, comptime
             };
 
             clear_screen = clear_screen_flag;
-            const watcher = @This().Watcher.init(reloader, fs, bun.default_allocator) catch |err| {
+            const watcher = Watcher.init(Reloader, reloader, fs, bun.default_allocator) catch |err| {
                 bun.handleErrorReturnTrace(err, @errorReturnTrace());
                 Output.panic("Failed to enable File Watcher: {s}", .{@errorName(err)});
             };
@@ -4088,19 +4427,28 @@ pub fn NewHotReloader(comptime Ctx: type, comptime EventLoopType: type, comptime
         pub var clear_screen = false;
 
         pub const HotReloadTask = struct {
-            reloader: *Reloader,
             count: u8 = 0,
-            hashes: [8]u32 = [_]u32{0} ** 8,
-            concurrent_task: JSC.ConcurrentTask = undefined,
+            hashes: [8]u32,
+            paths: if (Ctx == bun.bake.DevServer) [8][]const u8 else void,
+            /// Left uninitialized until .enqueue
+            concurrent_task: JSC.ConcurrentTask,
+            reloader: *Reloader,
+
+            pub fn initEmpty(reloader: *Reloader) HotReloadTask {
+                return .{
+                    .reloader = reloader,
+
+                    .hashes = [_]u32{0} ** 8,
+                    .paths = if (Ctx == bun.bake.DevServer) [_][]const u8{&.{}} ** 8,
+                    .count = 0,
+                    .concurrent_task = undefined,
+                };
+            }
 
             pub fn append(this: *HotReloadTask, id: u32) void {
                 if (this.count == 8) {
                     this.enqueue();
-                    const reloader = this.reloader;
-                    this.* = .{
-                        .reloader = reloader,
-                        .count = 0,
-                    };
+                    this.count = 0;
                 }
 
                 this.hashes[this.count] = id;
@@ -4118,7 +4466,7 @@ pub fn NewHotReloader(comptime Ctx: type, comptime EventLoopType: type, comptime
                 // get another hot reload request while we're reloading, we'll
                 // still enqueue it.
                 while (this.reloader.pending_count.swap(0, .monotonic) > 0) {
-                    this.reloader.ctx.reload();
+                    this.reloader.ctx.reload(this);
                 }
             }
 
@@ -4140,16 +4488,20 @@ pub fn NewHotReloader(comptime Ctx: type, comptime EventLoopType: type, comptime
                 _ = this.reloader.pending_count.fetchAdd(1, .monotonic);
 
                 BunDebugger__willHotReload();
-                var that = bun.default_allocator.create(HotReloadTask) catch unreachable;
-
-                that.* = this.*;
+                const that = bun.new(HotReloadTask, .{
+                    .reloader = this.reloader,
+                    .count = this.count,
+                    .paths = this.paths,
+                    .hashes = this.hashes,
+                    .concurrent_task = undefined,
+                });
+                that.concurrent_task = .{ .task = Task.init(that), .auto_delete = false };
+                that.reloader.enqueueTaskConcurrent(&that.concurrent_task);
                 this.count = 0;
-                that.concurrent_task.task = Task.init(that);
-                this.reloader.enqueueTaskConcurrent(&that.concurrent_task);
             }
 
             pub fn deinit(this: *HotReloadTask) void {
-                bun.default_allocator.destroy(this);
+                bun.destroy(this);
             }
         };
 
@@ -4170,7 +4522,8 @@ pub fn NewHotReloader(comptime Ctx: type, comptime EventLoopType: type, comptime
 
             if (comptime @TypeOf(this.bun_watcher) == ImportWatcher) {
                 this.bun_watcher = if (reload_immediately)
-                    .{ .watch = @This().Watcher.init(
+                    .{ .watch = Watcher.init(
+                        Reloader,
                         reloader,
                         this.bundler.fs,
                         bun.default_allocator,
@@ -4179,7 +4532,8 @@ pub fn NewHotReloader(comptime Ctx: type, comptime EventLoopType: type, comptime
                         Output.panic("Failed to enable File Watcher: {s}", .{@errorName(err)});
                     } }
                 else
-                    .{ .hot = @This().Watcher.init(
+                    .{ .hot = Watcher.init(
+                        Reloader,
                         reloader,
                         this.bundler.fs,
                         bun.default_allocator,
@@ -4189,12 +4543,13 @@ pub fn NewHotReloader(comptime Ctx: type, comptime EventLoopType: type, comptime
                     } };
 
                 if (reload_immediately) {
-                    this.bundler.resolver.watcher = Resolver.ResolveWatcher(*@This().Watcher, onMaybeWatchDirectory).init(this.bun_watcher.watch);
+                    this.bundler.resolver.watcher = Resolver.ResolveWatcher(*Watcher, Watcher.onMaybeWatchDirectory).init(this.bun_watcher.watch);
                 } else {
-                    this.bundler.resolver.watcher = Resolver.ResolveWatcher(*@This().Watcher, onMaybeWatchDirectory).init(this.bun_watcher.hot);
+                    this.bundler.resolver.watcher = Resolver.ResolveWatcher(*Watcher, Watcher.onMaybeWatchDirectory).init(this.bun_watcher.hot);
                 }
             } else {
-                this.bun_watcher = @This().Watcher.init(
+                this.bun_watcher = Watcher.init(
+                    Reloader,
                     reloader,
                     this.bundler.fs,
                     bun.default_allocator,
@@ -4202,7 +4557,7 @@ pub fn NewHotReloader(comptime Ctx: type, comptime EventLoopType: type, comptime
                     bun.handleErrorReturnTrace(err, @errorReturnTrace());
                     Output.panic("Failed to enable File Watcher: {s}", .{@errorName(err)});
                 };
-                this.bundler.resolver.watcher = Resolver.ResolveWatcher(*@This().Watcher, onMaybeWatchDirectory).init(this.bun_watcher.?);
+                this.bundler.resolver.watcher = Resolver.ResolveWatcher(*Watcher, Watcher.onMaybeWatchDirectory).init(this.bun_watcher.?);
             }
 
             clear_screen = !this.bundler.env.hasSetNoClearTerminalOnReload(!Output.enable_ansi_colors);
@@ -4210,15 +4565,6 @@ pub fn NewHotReloader(comptime Ctx: type, comptime EventLoopType: type, comptime
             reloader.getContext().start() catch @panic("Failed to start File Watcher");
         }
 
-        pub fn onMaybeWatchDirectory(watch: *@This().Watcher, file_path: string, dir_fd: StoredFileDescriptorType) void {
-            // We don't want to watch:
-            // - Directories outside the root directory
-            // - Directories inside node_modules
-            if (std.mem.indexOf(u8, file_path, "node_modules") == null and std.mem.indexOf(u8, file_path, watch.fs.top_level_dir) != null) {
-                _ = watch.addDirectory(dir_fd, file_path, GenericWatcher.getHash(file_path), false);
-            }
-        }
-
         fn putTombstone(this: *@This(), key: []const u8, value: *bun.fs.FileSystem.RealFS.EntriesOption) void {
             this.tombstones.put(bun.default_allocator, key, value) catch unreachable;
         }
@@ -4237,7 +4583,7 @@ pub fn NewHotReloader(comptime Ctx: type, comptime EventLoopType: type, comptime
             }
         }
 
-        pub fn getContext(this: *@This()) *@This().Watcher {
+        pub fn getContext(this: *@This()) *Watcher {
             if (comptime @TypeOf(this.ctx.bun_watcher) == ImportWatcher) {
                 if (reload_immediately) {
                     return this.ctx.bun_watcher.watch;
@@ -4251,7 +4597,7 @@ pub fn NewHotReloader(comptime Ctx: type, comptime EventLoopType: type, comptime
             }
         }
 
-        pub fn onFileUpdate(
+        pub noinline fn onFileUpdate(
             this: *@This(),
             events: []GenericWatcher.WatchEvent,
             changed_files: []?[:0]u8,
@@ -4268,19 +4614,10 @@ pub fn NewHotReloader(comptime Ctx: type, comptime EventLoopType: type, comptime
             defer ctx.flushEvictions();
             defer Output.flush();
 
-            const bundler = if (@TypeOf(this.ctx.bundler) == *bun.Bundler)
-                this.ctx.bundler
-            else
-                &this.ctx.bundler;
-
-            var fs: *Fs.FileSystem = bundler.fs;
-            var rfs: *Fs.FileSystem.RealFS = &fs.fs;
-            var resolver = &bundler.resolver;
+            const fs: *Fs.FileSystem = &Fs.FileSystem.instance;
+            const rfs: *Fs.FileSystem.RealFS = &fs.fs;
             var _on_file_update_path_buf: bun.PathBuffer = undefined;
-
-            var current_task: HotReloadTask = .{
-                .reloader = this,
-            };
+            var current_task = HotReloadTask.initEmpty(this);
             defer current_task.enqueue();
 
             for (events) |event| {
@@ -4292,10 +4629,7 @@ pub fn NewHotReloader(comptime Ctx: type, comptime EventLoopType: type, comptime
                 // so it's consistent with the rest
                 // if we use .extname we might run into an issue with whether or not the "." is included.
                 // const path = Fs.PathName.init(file_path);
-                const id = hashes[event.index];
-
-                if (this.verbose)
-                    debug("onFileUpdate {s} ({s}, {})", .{ file_path, @tagName(kind), event.op });
+                const current_hash = hashes[event.index];
 
                 switch (kind) {
                     .file => {
@@ -4312,15 +4646,17 @@ pub fn NewHotReloader(comptime Ctx: type, comptime EventLoopType: type, comptime
                             debug("File changed: {s}", .{fs.relativeTo(file_path)});
 
                         if (event.op.write or event.op.delete or event.op.rename) {
-                            current_task.append(id);
+                            current_task.append(current_hash);
                         }
+
+                        // TODO: delete events?
                     },
                     .directory => {
                         if (comptime Environment.isWindows) {
                             // on windows we receive file events for all items affected by a directory change
                             // so we only need to clear the directory cache. all other effects will be handled
                             // by the file events
-                            _ = resolver.bustDirCache(strings.pathWithoutTrailingSlashOne(file_path));
+                            _ = this.ctx.bustDirCache(strings.withoutTrailingSlashWindowsPath(file_path));
                             continue;
                         }
                         var affected_buf: [128][]const u8 = undefined;
@@ -4340,7 +4676,7 @@ pub fn NewHotReloader(comptime Ctx: type, comptime EventLoopType: type, comptime
                                 // if a file descriptor is stale, we need to close it
                                 if (event.op.delete and entries_option != null) {
                                     for (parents, 0..) |parent_hash, entry_id| {
-                                        if (parent_hash == id) {
+                                        if (parent_hash == current_hash) {
                                             const affected_path = file_paths[entry_id];
                                             const was_deleted = check: {
                                                 std.posix.access(affected_path, std.posix.F_OK) catch break :check true;
@@ -4370,7 +4706,7 @@ pub fn NewHotReloader(comptime Ctx: type, comptime EventLoopType: type, comptime
                             }
                         }
 
-                        _ = resolver.bustDirCache(strings.pathWithoutTrailingSlashOne(file_path));
+                        _ = this.ctx.bustDirCache(strings.withoutTrailingSlashWindowsPath(file_path));
 
                         if (entries_option) |dir_ent| {
                             var last_file_hash: GenericWatcher.HashType = std.math.maxInt(GenericWatcher.HashType);
@@ -4382,7 +4718,7 @@ pub fn NewHotReloader(comptime Ctx: type, comptime EventLoopType: type, comptime
                                     bun.asByteSlice(changed_name_.?);
                                 if (changed_name.len == 0 or changed_name[0] == '~' or changed_name[0] == '.') continue;
 
-                                const loader = (bundler.options.loaders.get(Fs.PathName.init(changed_name).ext) orelse .file);
+                                const loader = (this.ctx.getLoaders().get(Fs.PathName.init(changed_name).ext) orelse .file);
                                 var prev_entry_id: usize = std.math.maxInt(usize);
                                 if (loader != .file) {
                                     var path_string: bun.PathString = undefined;
@@ -4398,7 +4734,7 @@ pub fn NewHotReloader(comptime Ctx: type, comptime EventLoopType: type, comptime
                                                 if (hash == file_hash) {
                                                     if (file_descriptors[entry_id] != .zero) {
                                                         if (prev_entry_id != entry_id) {
-                                                            current_task.append(@as(u32, @truncate(entry_id)));
+                                                            current_task.append(hashes[entry_id]);
                                                             ctx.removeAtIndex(
                                                                 @as(u16, @truncate(entry_id)),
                                                                 0,
@@ -4471,16 +4807,14 @@ comptime {
     @export(string_allocation_limit, .{ .name = "Bun__stringSyntheticAllocationLimit" });
 }
 
-pub export fn Bun__setSyntheticAllocationLimitForTesting(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSValue {
-    const args = callframe.arguments(1).slice();
+pub fn Bun__setSyntheticAllocationLimitForTesting(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
+    const args = callframe.arguments_old(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.throwInvalidArguments("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 3bba44b331..18e3f199cd 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 d6a5e0daea..df80522e28 100644
--- a/src/bun.js/module_loader.zig
+++ b/src/bun.js/module_loader.zig
@@ -184,9 +184,9 @@ fn dumpSourceStringFailiable(vm: *VirtualMachine, specifier: string, written: []
                 \\  "mappings": "{}"
                 \\}}
             , .{
-                js_printer.formatJSONStringUTF8(std.fs.path.basename(specifier)),
-                js_printer.formatJSONStringUTF8(specifier),
-                js_printer.formatJSONStringUTF8(source_file),
+                bun.fmt.formatJSONStringUTF8(std.fs.path.basename(specifier)),
+                bun.fmt.formatJSONStringUTF8(specifier),
+                bun.fmt.formatJSONStringUTF8(source_file),
                 mappings.formatVLQs(),
             });
             try bufw.flush();
@@ -436,7 +436,7 @@ pub const RuntimeTranspilerStore = struct {
             }
 
             // this should be a cheap lookup because 24 bytes == 8 * 3 so it's read 3 machine words
-            const is_node_override = strings.hasPrefixComptime(specifier, "/bun-vfs/node_modules/");
+            const is_node_override = strings.hasPrefixComptime(specifier, NodeFallbackModules.import_path);
 
             const macro_remappings = if (vm.macro_mode or !vm.has_any_macro_remappings or is_node_override)
                 MacroRemap{}
@@ -479,6 +479,7 @@ pub const RuntimeTranspilerStore = struct {
                     setBreakPointOnFirstLine(),
                 .runtime_transpiler_cache = if (!JSC.RuntimeTranspilerCache.is_disabled) &cache else null,
                 .remove_cjs_module_wrapper = is_main and vm.module_loader.eval_source != null,
+                .allow_bytecode_cache = true,
             };
 
             defer {
@@ -491,7 +492,7 @@ pub const RuntimeTranspilerStore = struct {
             if (is_node_override) {
                 if (NodeFallbackModules.contentsFromPath(specifier)) |code| {
                     const fallback_path = Fs.Path.initWithNamespace(specifier, "node");
-                    fallback_source = logger.Source{ .path = fallback_path, .contents = code, .key_path = fallback_path };
+                    fallback_source = logger.Source{ .path = fallback_path, .contents = code };
                     parse_options.virtual_source = &fallback_source;
                 }
             }
@@ -573,8 +574,9 @@ pub const RuntimeTranspilerStore = struct {
                 return;
             }
 
-            if (parse_result.already_bundled) {
+            if (parse_result.already_bundled != .none) {
                 const duped = String.createUTF8(specifier);
+                const bytecode_slice = parse_result.already_bundled.bytecodeSlice();
                 this.resolved_source = ResolvedSource{
                     .allocator = null,
                     .source_code = bun.String.createLatin1(parse_result.source.contents),
@@ -582,6 +584,9 @@ pub const RuntimeTranspilerStore = struct {
                     .source_url = duped.createIfDifferent(path.text),
                     .already_bundled = true,
                     .hash = 0,
+                    .bytecode_cache = if (bytecode_slice.len > 0) bytecode_slice.ptr else null,
+                    .bytecode_cache_size = bytecode_slice.len,
+                    .is_commonjs_module = parse_result.already_bundled.isCommonJS(),
                 };
                 this.resolved_source.source_code.ensureHash();
                 return;
@@ -667,10 +672,10 @@ pub const RuntimeTranspilerStore = struct {
                 // In a benchmarking loading @babel/standalone 100 times:
                 //
                 // After ensureHash:
-                // 354.00 ms    4.2%	354.00 ms	 	  WTF::StringImpl::hashSlowCase() const
+                // 354.00 ms    4.2%    354.00 ms           WTF::StringImpl::hashSlowCase() const
                 //
                 // Before ensureHash:
-                // 506.00 ms    6.1%	506.00 ms	 	  WTF::StringImpl::hashSlowCase() const
+                // 506.00 ms    6.1%    506.00 ms           WTF::StringImpl::hashSlowCase() const
                 //
                 result.ensureHash();
 
@@ -1582,7 +1587,7 @@ pub const ModuleLoader = struct {
                 }
 
                 // this should be a cheap lookup because 24 bytes == 8 * 3 so it's read 3 machine words
-                const is_node_override = strings.hasPrefixComptime(specifier, "/bun-vfs/node_modules/");
+                const is_node_override = strings.hasPrefixComptime(specifier, NodeFallbackModules.import_path);
 
                 const macro_remappings = if (jsc_vm.macro_mode or !jsc_vm.has_any_macro_remappings or is_node_override)
                     MacroRemap{}
@@ -1615,6 +1620,7 @@ pub const ModuleLoader = struct {
                     .allow_commonjs = true,
                     .inject_jest_globals = jsc_vm.bundler.options.rewrite_jest_for_tests and is_main,
                     .keep_json_and_toml_as_one_statement = true,
+                    .allow_bytecode_cache = true,
                     .set_breakpoint_on_first_line = is_main and
                         jsc_vm.debugger != null and
                         jsc_vm.debugger.?.set_breakpoint_on_first_line and
@@ -1632,7 +1638,7 @@ pub const ModuleLoader = struct {
                 if (is_node_override) {
                     if (NodeFallbackModules.contentsFromPath(specifier)) |code| {
                         const fallback_path = Fs.Path.initWithNamespace(specifier, "node");
-                        fallback_source = logger.Source{ .path = fallback_path, .contents = code, .key_path = fallback_path };
+                        fallback_source = logger.Source{ .path = fallback_path, .contents = code };
                         parse_options.virtual_source = &fallback_source;
                     }
                 }
@@ -1640,6 +1646,12 @@ pub const ModuleLoader = struct {
                 var parse_result: ParseResult = switch (disable_transpilying or
                     (loader == .json and !path.isJSONCFile())) {
                     inline else => |return_file_only| brk: {
+                        const heap_access = if (!disable_transpilying)
+                            jsc_vm.jsc.releaseHeapAccess()
+                        else
+                            JSC.VM.ReleaseHeapAccess{ .vm = jsc_vm.jsc, .needs_to_release = false };
+                        defer heap_access.acquire();
+
                         break :brk jsc_vm.bundler.parseMaybeReturnFileOnly(
                             parse_options,
                             null,
@@ -1755,12 +1767,13 @@ 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,
                     };
                 }
 
-                if (parse_result.already_bundled) {
+                if (parse_result.already_bundled != .none) {
+                    const bytecode_slice = parse_result.already_bundled.bytecodeSlice();
                     return ResolvedSource{
                         .allocator = null,
                         .source_code = bun.String.createLatin1(parse_result.source.contents),
@@ -1768,6 +1781,9 @@ pub const ModuleLoader = struct {
                         .source_url = input_specifier.createIfDifferent(path.text),
                         .already_bundled = true,
                         .hash = 0,
+                        .bytecode_cache = if (bytecode_slice.len > 0) bytecode_slice.ptr else null,
+                        .bytecode_cache_size = if (bytecode_slice.len > 0) bytecode_slice.len else 0,
+                        .is_commonjs_module = parse_result.already_bundled.isCommonJS(),
                     };
                 }
 
@@ -2133,7 +2149,7 @@ pub const ModuleLoader = struct {
                     writer.writeAll(";\n") catch bun.outOfMemory();
                 }
 
-                const public_url = bun.String.createUTF8(buf.toOwnedSliceLeaky());
+                const public_url = bun.String.createUTF8(buf.slice());
                 return ResolvedSource{
                     .allocator = &jsc_vm.allocator,
                     .source_code = public_url,
@@ -2148,23 +2164,9 @@ pub const ModuleLoader = struct {
     pub fn normalizeSpecifier(jsc_vm: *VirtualMachine, slice_: string, string_to_use_for_source: *[]const u8) string {
         var slice = slice_;
         if (slice.len == 0) return slice;
-        var was_http = false;
-        if (jsc_vm.bundler.options.serve) {
-            if (strings.hasPrefixComptime(slice, "https://")) {
-                slice = slice["https://".len..];
-                was_http = true;
-            } else if (strings.hasPrefixComptime(slice, "http://")) {
-                slice = slice["http://".len..];
-                was_http = true;
-            }
-        }
 
         if (strings.hasPrefix(slice, jsc_vm.origin.host)) {
             slice = slice[jsc_vm.origin.host.len..];
-        } else if (was_http) {
-            if (strings.indexOfChar(slice, '/')) |i| {
-                slice = slice[i..];
-            }
         }
 
         if (jsc_vm.origin.path.len > 1) {
@@ -2173,12 +2175,6 @@ pub const ModuleLoader = struct {
             }
         }
 
-        if (jsc_vm.bundler.options.routes.asset_prefix_path.len > 0) {
-            if (strings.hasPrefix(slice, jsc_vm.bundler.options.routes.asset_prefix_path)) {
-                slice = slice[jsc_vm.bundler.options.routes.asset_prefix_path.len..];
-            }
-        }
-
         string_to_use_for_source.* = slice;
 
         if (strings.indexOfChar(slice, '?')) |i| {
@@ -2289,7 +2285,6 @@ pub const ModuleLoader = struct {
                     virtual_source_to_use = logger.Source{
                         .path = path,
                         .contents = blob.sharedView(),
-                        .key_path = path,
                     };
                     virtual_source = &virtual_source_to_use.?;
                 }
@@ -2417,7 +2412,8 @@ pub const ModuleLoader = struct {
         else
             specifier[@min(namespace.len + 1, specifier.len)..];
 
-        return globalObject.runOnLoadPlugins(bun.String.init(namespace), bun.String.init(after_namespace), .bun) orelse return JSValue.zero;
+        return globalObject.runOnLoadPlugins(bun.String.init(namespace), bun.String.init(after_namespace), .bun) orelse
+            return JSValue.zero;
     }
 
     pub fn fetchBuiltinModule(jsc_vm: *VirtualMachine, specifier: bun.String) !?ResolvedSource {
@@ -2477,7 +2473,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),
@@ -2574,6 +2570,9 @@ pub const ModuleLoader = struct {
                     .source_url = specifier.dupeRef(),
                     .hash = 0,
                     .source_code_needs_deref = false,
+                    .bytecode_cache = if (file.bytecode.len > 0) file.bytecode.ptr else null,
+                    .bytecode_cache_size = file.bytecode.len,
+                    .is_commonjs_module = file.module_format == .cjs,
                 };
             }
         }
@@ -2820,8 +2819,8 @@ pub const HardcodedModule = enum {
     );
 
     pub const Alias = struct {
-        path: string,
-        tag: ImportRecord.Tag = ImportRecord.Tag.hardcoded,
+        path: [:0]const u8,
+        tag: ImportRecord.Tag = .builtin,
     };
 
     pub const Aliases = struct {
diff --git a/src/bun.js/modules/AbortControllerModuleModule.h b/src/bun.js/modules/AbortControllerModuleModule.h
index 31cd3d23de..5a20e6b10c 100644
--- a/src/bun.js/modules/AbortControllerModuleModule.h
+++ b/src/bun.js/modules/AbortControllerModuleModule.h
@@ -9,46 +9,44 @@ using namespace WebCore;
 namespace Zig {
 
 inline void generateNativeModule_AbortControllerModule(
-    JSC::JSGlobalObject *lexicalGlobalObject, JSC::Identifier moduleKey,
-    Vector<JSC::Identifier, 4> &exportNames,
-    JSC::MarkedArgumentBuffer &exportValues) {
+    JSC::JSGlobalObject* lexicalGlobalObject, JSC::Identifier moduleKey,
+    Vector<JSC::Identifier, 4>& exportNames,
+    JSC::MarkedArgumentBuffer& exportValues)
+{
 
-  Zig::GlobalObject *globalObject =
-      reinterpret_cast<Zig::GlobalObject *>(lexicalGlobalObject);
-  JSC::VM &vm = globalObject->vm();
+    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    JSC::VM& vm = globalObject->vm();
 
-  auto *abortController =
-      WebCore::JSAbortController::getConstructor(vm, globalObject).getObject();
-  JSValue abortSignal =
-      WebCore::JSAbortSignal::getConstructor(vm, globalObject);
+    auto* abortController = WebCore::JSAbortController::getConstructor(vm, globalObject).getObject();
+    JSValue abortSignal = WebCore::JSAbortSignal::getConstructor(vm, globalObject);
 
-  const auto controllerIdent = Identifier::fromString(vm, "AbortController"_s);
-  const auto signalIdent = Identifier::fromString(vm, "AbortSignal"_s);
-  const Identifier esModuleMarker = builtinNames(vm).__esModulePublicName();
+    const auto controllerIdent = Identifier::fromString(vm, "AbortController"_s);
+    const auto signalIdent = Identifier::fromString(vm, "AbortSignal"_s);
+    const Identifier& esModuleMarker = vm.propertyNames->__esModule;
 
-  exportNames.append(vm.propertyNames->defaultKeyword);
-  exportValues.append(abortController);
+    exportNames.append(vm.propertyNames->defaultKeyword);
+    exportValues.append(abortController);
 
-  exportNames.append(signalIdent);
-  exportValues.append(abortSignal);
+    exportNames.append(signalIdent);
+    exportValues.append(abortSignal);
 
-  exportNames.append(controllerIdent);
-  exportValues.append(abortController);
+    exportNames.append(controllerIdent);
+    exportValues.append(abortController);
 
-  exportNames.append(esModuleMarker);
-  exportValues.append(jsBoolean(true));
+    exportNames.append(esModuleMarker);
+    exportValues.append(jsBoolean(true));
 
-  // https://github.com/mysticatea/abort-controller/blob/a935d38e09eb95d6b633a8c42fcceec9969e7b05/dist/abort-controller.js#L125
-  abortController->putDirect(
-      vm, signalIdent, abortSignal,
-      static_cast<unsigned>(PropertyAttribute::DontDelete));
+    // https://github.com/mysticatea/abort-controller/blob/a935d38e09eb95d6b633a8c42fcceec9969e7b05/dist/abort-controller.js#L125
+    abortController->putDirect(
+        vm, signalIdent, abortSignal,
+        static_cast<unsigned>(PropertyAttribute::DontDelete));
 
-  abortController->putDirect(
-      vm, controllerIdent, abortController,
-      static_cast<unsigned>(PropertyAttribute::DontDelete));
+    abortController->putDirect(
+        vm, controllerIdent, abortController,
+        static_cast<unsigned>(PropertyAttribute::DontDelete));
 
-  abortController->putDirect(
-      vm, vm.propertyNames->defaultKeyword, abortController,
-      static_cast<unsigned>(PropertyAttribute::DontDelete));
+    abortController->putDirect(
+        vm, vm.propertyNames->defaultKeyword, abortController,
+        static_cast<unsigned>(PropertyAttribute::DontDelete));
 }
 } // namespace Zig
diff --git a/src/bun.js/modules/BunJSCModule.h b/src/bun.js/modules/BunJSCModule.h
index 592cb33826..353e09fac9 100644
--- a/src/bun.js/modules/BunJSCModule.h
+++ b/src/bun.js/modules/BunJSCModule.h
@@ -60,827 +60,833 @@ using namespace WebCore;
 
 JSC_DECLARE_HOST_FUNCTION(functionStartRemoteDebugger);
 JSC_DEFINE_HOST_FUNCTION(functionStartRemoteDebugger,
-                         (JSGlobalObject * globalObject,
-                          CallFrame *callFrame)) {
+    (JSGlobalObject * globalObject,
+        CallFrame* callFrame))
+{
 #if ENABLE(REMOTE_INSPECTOR)
-  static const char *defaultHost = "127.0.0.1\0";
-  static uint16_t defaultPort = 9230; // node + 1
+    static const char* defaultHost = "127.0.0.1\0";
+    static uint16_t defaultPort = 9230; // node + 1
 
-  auto &vm = globalObject->vm();
-  auto scope = DECLARE_THROW_SCOPE(vm);
+    auto& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
 
-  JSC::JSValue hostValue = callFrame->argument(0);
-  JSC::JSValue portValue = callFrame->argument(1);
-  const char *host = defaultHost;
-  if (hostValue.isString()) {
+    JSC::JSValue hostValue = callFrame->argument(0);
+    JSC::JSValue portValue = callFrame->argument(1);
+    const char* host = defaultHost;
+    if (hostValue.isString()) {
 
-    auto str = hostValue.toWTFString(globalObject);
-    if (!str.isEmpty())
-      host = toCString(str).data();
-  } else if (!hostValue.isUndefined()) {
-    throwVMError(globalObject, scope,
-                 createTypeError(globalObject, "host must be a string"_s));
-    return JSC::JSValue::encode(JSC::jsUndefined());
-  }
-
-  uint16_t port = defaultPort;
-  if (portValue.isNumber()) {
-    auto port_int = portValue.toUInt32(globalObject);
-    if (!(port_int > 0 && port_int < 65536)) {
-      throwVMError(
-          globalObject, scope,
-          createRangeError(globalObject, "port must be between 0 and 65535"_s));
-      return JSC::JSValue::encode(JSC::jsUndefined());
+        auto str = hostValue.toWTFString(globalObject);
+        if (!str.isEmpty())
+            host = toCString(str).data();
+    } else if (!hostValue.isUndefined()) {
+        throwVMError(globalObject, scope,
+            createTypeError(globalObject, "host must be a string"_s));
+        return JSC::JSValue::encode(JSC::jsUndefined());
     }
-    port = port_int;
-  } else if (!portValue.isUndefined()) {
-    throwVMError(
-        globalObject, scope,
-        createTypeError(globalObject,
-                        "port must be a number between 0 and 65535"_s));
-    return JSC::JSValue::encode(JSC::jsUndefined());
-  }
 
-  globalObject->setInspectable(true);
-  auto &server = Inspector::RemoteInspectorServer::singleton();
-  if (!server.start(reinterpret_cast<const char *>(host), port)) {
-    throwVMError(
-        globalObject, scope,
-        createError(globalObject,
-                    makeString("Failed to start server \""_s,
-                               reinterpret_cast<const unsigned char *>(host),
-                               ":"_s, port, "\". Is port already in use?"_s)));
-    return JSC::JSValue::encode(JSC::jsUndefined());
-  }
+    uint16_t port = defaultPort;
+    if (portValue.isNumber()) {
+        auto port_int = portValue.toUInt32(globalObject);
+        if (!(port_int > 0 && port_int < 65536)) {
+            throwVMError(
+                globalObject, scope,
+                createRangeError(globalObject, "port must be between 0 and 65535"_s));
+            return JSC::JSValue::encode(JSC::jsUndefined());
+        }
+        port = port_int;
+    } else if (!portValue.isUndefined()) {
+        throwVMError(
+            globalObject, scope,
+            createTypeError(globalObject,
+                "port must be a number between 0 and 65535"_s));
+        return JSC::JSValue::encode(JSC::jsUndefined());
+    }
 
-  RELEASE_AND_RETURN(scope, JSC::JSValue::encode(JSC::jsUndefined()));
+    globalObject->setInspectable(true);
+    auto& server = Inspector::RemoteInspectorServer::singleton();
+    if (!server.start(reinterpret_cast<const char*>(host), port)) {
+        throwVMError(
+            globalObject, scope,
+            createError(globalObject,
+                makeString("Failed to start server \""_s,
+                    reinterpret_cast<const unsigned char*>(host),
+                    ":"_s, port, "\". Is port already in use?"_s)));
+        return JSC::JSValue::encode(JSC::jsUndefined());
+    }
+
+    RELEASE_AND_RETURN(scope, JSC::JSValue::encode(JSC::jsUndefined()));
 #else
-  auto &vm = globalObject->vm();
-  auto scope = DECLARE_THROW_SCOPE(vm);
-  throwVMError(globalObject, scope,
-               createTypeError(
-                   globalObject,
-                   "Remote inspector is not enabled in this build of Bun"_s));
-  return JSC::JSValue::encode(JSC::jsUndefined());
+    auto& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    throwVMError(globalObject, scope,
+        createTypeError(
+            globalObject,
+            "Remote inspector is not enabled in this build of Bun"_s));
+    return JSC::JSValue::encode(JSC::jsUndefined());
 #endif
 }
 
 JSC_DECLARE_HOST_FUNCTION(functionDescribe);
-JSC_DEFINE_HOST_FUNCTION(functionDescribe, (JSGlobalObject * globalObject,
-                                            CallFrame *callFrame)) {
-  VM &vm = globalObject->vm();
-  if (callFrame->argumentCount() < 1)
-    return JSValue::encode(jsUndefined());
-  return JSValue::encode(jsString(vm, toString(callFrame->argument(0))));
+JSC_DEFINE_HOST_FUNCTION(functionDescribe, (JSGlobalObject * globalObject, CallFrame* callFrame))
+{
+    VM& vm = globalObject->vm();
+    if (callFrame->argumentCount() < 1)
+        return JSValue::encode(jsUndefined());
+    return JSValue::encode(jsString(vm, toString(callFrame->argument(0))));
 }
 
 JSC_DECLARE_HOST_FUNCTION(functionDescribeArray);
-JSC_DEFINE_HOST_FUNCTION(functionDescribeArray, (JSGlobalObject * globalObject,
-                                                 CallFrame *callFrame)) {
-  if (callFrame->argumentCount() < 1)
-    return JSValue::encode(jsUndefined());
-  VM &vm = globalObject->vm();
-  JSObject *object = jsDynamicCast<JSObject *>(callFrame->argument(0));
-  if (!object)
-    return JSValue::encode(jsNontrivialString(vm, "<not object>"_s));
-  return JSValue::encode(jsNontrivialString(
-      vm, toString("<Butterfly: ", RawPointer(object->butterfly()),
-                   "; public length: ", object->getArrayLength(),
-                   "; vector length: ", object->getVectorLength(), ">")));
+JSC_DEFINE_HOST_FUNCTION(functionDescribeArray, (JSGlobalObject * globalObject, CallFrame* callFrame))
+{
+    if (callFrame->argumentCount() < 1)
+        return JSValue::encode(jsUndefined());
+    VM& vm = globalObject->vm();
+    JSObject* object = jsDynamicCast<JSObject*>(callFrame->argument(0));
+    if (!object)
+        return JSValue::encode(jsNontrivialString(vm, "<not object>"_s));
+    return JSValue::encode(jsNontrivialString(
+        vm, toString("<Butterfly: ", RawPointer(object->butterfly()), "; public length: ", object->getArrayLength(), "; vector length: ", object->getVectorLength(), ">")));
 }
 
 JSC_DECLARE_HOST_FUNCTION(functionGCAndSweep);
 JSC_DEFINE_HOST_FUNCTION(functionGCAndSweep,
-                         (JSGlobalObject * globalObject, CallFrame *)) {
-  VM &vm = globalObject->vm();
-  JSLockHolder lock(vm);
-  vm.heap.collectNow(Sync, CollectionScope::Full);
-  return JSValue::encode(jsNumber(vm.heap.sizeAfterLastFullCollection()));
+    (JSGlobalObject * globalObject, CallFrame*))
+{
+    VM& vm = globalObject->vm();
+    JSLockHolder lock(vm);
+    vm.heap.collectNow(Sync, CollectionScope::Full);
+    return JSValue::encode(jsNumber(vm.heap.sizeAfterLastFullCollection()));
 }
 
 JSC_DECLARE_HOST_FUNCTION(functionFullGC);
 JSC_DEFINE_HOST_FUNCTION(functionFullGC,
-                         (JSGlobalObject * globalObject, CallFrame *)) {
-  VM &vm = globalObject->vm();
-  JSLockHolder lock(vm);
-  vm.heap.collectSync(CollectionScope::Full);
-  return JSValue::encode(jsNumber(vm.heap.sizeAfterLastFullCollection()));
+    (JSGlobalObject * globalObject, CallFrame*))
+{
+    VM& vm = globalObject->vm();
+    JSLockHolder lock(vm);
+    vm.heap.collectSync(CollectionScope::Full);
+    return JSValue::encode(jsNumber(vm.heap.sizeAfterLastFullCollection()));
 }
 
 JSC_DECLARE_HOST_FUNCTION(functionEdenGC);
 JSC_DEFINE_HOST_FUNCTION(functionEdenGC,
-                         (JSGlobalObject * globalObject, CallFrame *)) {
-  VM &vm = globalObject->vm();
-  JSLockHolder lock(vm);
-  vm.heap.collectSync(CollectionScope::Eden);
-  return JSValue::encode(jsNumber(vm.heap.sizeAfterLastEdenCollection()));
+    (JSGlobalObject * globalObject, CallFrame*))
+{
+    VM& vm = globalObject->vm();
+    JSLockHolder lock(vm);
+    vm.heap.collectSync(CollectionScope::Eden);
+    return JSValue::encode(jsNumber(vm.heap.sizeAfterLastEdenCollection()));
 }
 
 JSC_DECLARE_HOST_FUNCTION(functionHeapSize);
 JSC_DEFINE_HOST_FUNCTION(functionHeapSize,
-                         (JSGlobalObject * globalObject, CallFrame *)) {
-  VM &vm = globalObject->vm();
-  JSLockHolder lock(vm);
-  return JSValue::encode(jsNumber(vm.heap.size()));
+    (JSGlobalObject * globalObject, CallFrame*))
+{
+    VM& vm = globalObject->vm();
+    JSLockHolder lock(vm);
+    return JSValue::encode(jsNumber(vm.heap.size()));
 }
 
-JSC::Structure *
-createMemoryFootprintStructure(JSC::VM &vm, JSC::JSGlobalObject *globalObject) {
+JSC::Structure*
+createMemoryFootprintStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
+{
 
-  JSC::Structure *structure =
-      globalObject->structureCache().emptyObjectStructureForPrototype(
-          globalObject, globalObject->objectPrototype(), 5);
-  JSC::PropertyOffset offset;
+    JSC::Structure* structure = globalObject->structureCache().emptyObjectStructureForPrototype(
+        globalObject, globalObject->objectPrototype(), 5);
+    JSC::PropertyOffset offset;
 
-  structure = structure->addPropertyTransition(
-      vm, structure, Identifier::fromString(vm, "current"_s), 0, offset);
-  structure = structure->addPropertyTransition(
-      vm, structure, Identifier::fromString(vm, "peak"_s), 0, offset);
-  structure = structure->addPropertyTransition(
-      vm, structure, Identifier::fromString(vm, "currentCommit"_s), 0, offset);
-  structure = structure->addPropertyTransition(
-      vm, structure, Identifier::fromString(vm, "peakCommit"_s), 0, offset);
-  structure = structure->addPropertyTransition(
-      vm, structure, Identifier::fromString(vm, "pageFaults"_s), 0, offset);
+    structure = structure->addPropertyTransition(
+        vm, structure, Identifier::fromString(vm, "current"_s), 0, offset);
+    structure = structure->addPropertyTransition(
+        vm, structure, Identifier::fromString(vm, "peak"_s), 0, offset);
+    structure = structure->addPropertyTransition(
+        vm, structure, Identifier::fromString(vm, "currentCommit"_s), 0, offset);
+    structure = structure->addPropertyTransition(
+        vm, structure, Identifier::fromString(vm, "peakCommit"_s), 0, offset);
+    structure = structure->addPropertyTransition(
+        vm, structure, Identifier::fromString(vm, "pageFaults"_s), 0, offset);
 
-  return structure;
+    return structure;
 }
 
 JSC_DECLARE_HOST_FUNCTION(functionMemoryUsageStatistics);
 JSC_DEFINE_HOST_FUNCTION(functionMemoryUsageStatistics,
-                         (JSGlobalObject * globalObject, CallFrame *)) {
+    (JSGlobalObject * globalObject, CallFrame*))
+{
 
-  auto &vm = globalObject->vm();
+    auto& vm = globalObject->vm();
 
-  if (vm.heap.size() == 0) {
-    vm.heap.collectNow(Sync, CollectionScope::Full);
-    JSC::DisallowGC disallowGC;
-  }
-
-  const auto createdSortedTypeCounts =
-      [&](JSC::TypeCountSet *typeCounts) -> JSC::JSValue {
-    WTF::Vector<std::pair<Identifier, unsigned>> counts;
-    counts.reserveInitialCapacity(typeCounts->size());
-    for (auto &it : *typeCounts) {
-      if (it.value > 0)
-        counts.append(
-            std::make_pair(Identifier::fromLatin1(vm, it.key), it.value));
+    if (vm.heap.size() == 0) {
+        vm.heap.collectNow(Sync, CollectionScope::Full);
+        JSC::DisallowGC disallowGC;
     }
 
-    // Sort by count first, then by name.
-    std::sort(counts.begin(), counts.end(),
-              [](const std::pair<Identifier, unsigned> &a,
-                 const std::pair<Identifier, unsigned> &b) {
-                if (a.second == b.second) {
-                  WTF::StringView left = a.first.string();
-                  WTF::StringView right = b.first.string();
-                  unsigned originalLeftLength = left.length();
-                  unsigned originalRightLength = right.length();
-                  unsigned size = std::min(left.length(), right.length());
-                  left = left.substring(0, size);
-                  right = right.substring(0, size);
-                  int result = WTF::codePointCompare(right, left);
-                  if (result == 0) {
-                    return originalLeftLength > originalRightLength;
-                  }
+    const auto createdSortedTypeCounts =
+        [&](JSC::TypeCountSet* typeCounts) -> JSC::JSValue {
+        WTF::Vector<std::pair<Identifier, unsigned>> counts;
+        counts.reserveInitialCapacity(typeCounts->size());
+        for (auto& it : *typeCounts) {
+            if (it.value > 0)
+                counts.append(
+                    std::make_pair(Identifier::fromLatin1(vm, it.key), it.value));
+        }
 
-                  return result > 0;
+        // Sort by count first, then by name.
+        std::sort(counts.begin(), counts.end(),
+            [](const std::pair<Identifier, unsigned>& a,
+                const std::pair<Identifier, unsigned>& b) {
+                if (a.second == b.second) {
+                    WTF::StringView left = a.first.string();
+                    WTF::StringView right = b.first.string();
+                    unsigned originalLeftLength = left.length();
+                    unsigned originalRightLength = right.length();
+                    unsigned size = std::min(left.length(), right.length());
+                    left = left.substring(0, size);
+                    right = right.substring(0, size);
+                    int result = WTF::codePointCompare(right, left);
+                    if (result == 0) {
+                        return originalLeftLength > originalRightLength;
+                    }
+
+                    return result > 0;
                 }
 
                 return a.second > b.second;
-              });
+            });
 
-    auto *objectTypeCounts = constructEmptyObject(globalObject);
-    for (auto &it : counts) {
-      objectTypeCounts->putDirect(vm, it.first, jsNumber(it.second));
-    }
-    return objectTypeCounts;
-  };
+        auto* objectTypeCounts = constructEmptyObject(globalObject);
+        for (auto& it : counts) {
+            objectTypeCounts->putDirect(vm, it.first, jsNumber(it.second));
+        }
+        return objectTypeCounts;
+    };
 
-  JSValue objectTypeCounts =
-      createdSortedTypeCounts(vm.heap.objectTypeCounts().get());
-  JSValue protectedCounts =
-      createdSortedTypeCounts(vm.heap.protectedObjectTypeCounts().get());
+    JSValue objectTypeCounts = createdSortedTypeCounts(vm.heap.objectTypeCounts().get());
+    JSValue protectedCounts = createdSortedTypeCounts(vm.heap.protectedObjectTypeCounts().get());
 
-  JSObject *object = constructEmptyObject(globalObject);
-  object->putDirect(vm, Identifier::fromString(vm, "objectTypeCounts"_s),
-                    objectTypeCounts);
+    JSObject* object = constructEmptyObject(globalObject);
+    object->putDirect(vm, Identifier::fromString(vm, "objectTypeCounts"_s),
+        objectTypeCounts);
 
-  object->putDirect(vm,
-                    Identifier::fromLatin1(vm, "protectedObjectTypeCounts"_s),
-                    protectedCounts);
-  object->putDirect(vm, Identifier::fromString(vm, "heapSize"_s),
-                    jsNumber(vm.heap.size()));
-  object->putDirect(vm, Identifier::fromString(vm, "heapCapacity"_s),
-                    jsNumber(vm.heap.capacity()));
-  object->putDirect(vm, Identifier::fromString(vm, "extraMemorySize"_s),
-                    jsNumber(vm.heap.extraMemorySize()));
-  object->putDirect(vm, Identifier::fromString(vm, "objectCount"_s),
-                    jsNumber(vm.heap.objectCount()));
-  object->putDirect(vm, Identifier::fromString(vm, "protectedObjectCount"_s),
-                    jsNumber(vm.heap.protectedObjectCount()));
-  object->putDirect(vm, Identifier::fromString(vm, "globalObjectCount"_s),
-                    jsNumber(vm.heap.globalObjectCount()));
-  object->putDirect(vm,
-                    Identifier::fromString(vm, "protectedGlobalObjectCount"_s),
-                    jsNumber(vm.heap.protectedGlobalObjectCount()));
+    object->putDirect(vm,
+        Identifier::fromLatin1(vm, "protectedObjectTypeCounts"_s),
+        protectedCounts);
+    object->putDirect(vm, Identifier::fromString(vm, "heapSize"_s),
+        jsNumber(vm.heap.size()));
+    object->putDirect(vm, Identifier::fromString(vm, "heapCapacity"_s),
+        jsNumber(vm.heap.capacity()));
+    object->putDirect(vm, Identifier::fromString(vm, "extraMemorySize"_s),
+        jsNumber(vm.heap.extraMemorySize()));
+    object->putDirect(vm, Identifier::fromString(vm, "objectCount"_s),
+        jsNumber(vm.heap.objectCount()));
+    object->putDirect(vm, Identifier::fromString(vm, "protectedObjectCount"_s),
+        jsNumber(vm.heap.protectedObjectCount()));
+    object->putDirect(vm, Identifier::fromString(vm, "globalObjectCount"_s),
+        jsNumber(vm.heap.globalObjectCount()));
+    object->putDirect(vm,
+        Identifier::fromString(vm, "protectedGlobalObjectCount"_s),
+        jsNumber(vm.heap.protectedGlobalObjectCount()));
 
 #if IS_MALLOC_DEBUGGING_ENABLED
 #if OS(DARWIN)
-  {
-    vm_address_t *zones;
-    unsigned count;
+    {
+        vm_address_t* zones;
+        unsigned count;
 
-    // Zero out the structures in case a zone is missing
-    malloc_statistics_t zone_stats;
-    zone_stats.blocks_in_use = 0;
-    zone_stats.size_in_use = 0;
-    zone_stats.max_size_in_use = 0;
-    zone_stats.size_allocated = 0;
+        // Zero out the structures in case a zone is missing
+        malloc_statistics_t zone_stats;
+        zone_stats.blocks_in_use = 0;
+        zone_stats.size_in_use = 0;
+        zone_stats.max_size_in_use = 0;
+        zone_stats.size_allocated = 0;
 
-    malloc_zone_pressure_relief(nullptr, 0);
-    malloc_get_all_zones(mach_task_self(), 0, &zones, &count);
-    Vector<std::pair<Identifier, size_t>> zoneSizes;
-    zoneSizes.reserveInitialCapacity(count);
-    for (unsigned i = 0; i < count; i++) {
-      auto zone = reinterpret_cast<malloc_zone_t *>(zones[i]);
-      if (const char *name = malloc_get_zone_name(zone)) {
-        malloc_zone_statistics(reinterpret_cast<malloc_zone_t *>(zones[i]),
-                               &zone_stats);
-        zoneSizes.append(
-            std::make_pair(Identifier::fromString(vm, String::fromUTF8(name)),
-                           zone_stats.size_in_use));
-      }
-    }
+        malloc_zone_pressure_relief(nullptr, 0);
+        malloc_get_all_zones(mach_task_self(), 0, &zones, &count);
+        Vector<std::pair<Identifier, size_t>> zoneSizes;
+        zoneSizes.reserveInitialCapacity(count);
+        for (unsigned i = 0; i < count; i++) {
+            auto zone = reinterpret_cast<malloc_zone_t*>(zones[i]);
+            if (const char* name = malloc_get_zone_name(zone)) {
+                malloc_zone_statistics(reinterpret_cast<malloc_zone_t*>(zones[i]),
+                    &zone_stats);
+                zoneSizes.append(
+                    std::make_pair(Identifier::fromString(vm, String::fromUTF8(name)),
+                        zone_stats.size_in_use));
+            }
+        }
 
-    std::sort(zoneSizes.begin(), zoneSizes.end(),
-              [](const std::pair<Identifier, size_t> &a,
-                 const std::pair<Identifier, size_t> &b) {
+        std::sort(zoneSizes.begin(), zoneSizes.end(),
+            [](const std::pair<Identifier, size_t>& a,
+                const std::pair<Identifier, size_t>& b) {
                 // Sort by name if the sizes are the same.
                 if (a.second == b.second) {
-                  WTF::StringView left = a.first.string();
-                  WTF::StringView right = b.first.string();
-                  unsigned originalLeftLength = left.length();
-                  unsigned originalRightLength = right.length();
-                  unsigned size = std::min(left.length(), right.length());
-                  left = left.substring(0, size);
-                  right = right.substring(0, size);
-                  int result = WTF::codePointCompare(right, left);
-                  if (result == 0) {
-                    return originalLeftLength > originalRightLength;
-                  }
+                    WTF::StringView left = a.first.string();
+                    WTF::StringView right = b.first.string();
+                    unsigned originalLeftLength = left.length();
+                    unsigned originalRightLength = right.length();
+                    unsigned size = std::min(left.length(), right.length());
+                    left = left.substring(0, size);
+                    right = right.substring(0, size);
+                    int result = WTF::codePointCompare(right, left);
+                    if (result == 0) {
+                        return originalLeftLength > originalRightLength;
+                    }
 
-                  return result > 0;
+                    return result > 0;
                 }
 
                 return a.second > b.second;
-              });
+            });
 
-    auto *zoneSizesObject = constructEmptyObject(globalObject);
-    for (auto &it : zoneSizes) {
-      zoneSizesObject->putDirect(vm, it.first, jsDoubleNumber(it.second));
+        auto* zoneSizesObject = constructEmptyObject(globalObject);
+        for (auto& it : zoneSizes) {
+            zoneSizesObject->putDirect(vm, it.first, jsDoubleNumber(it.second));
+        }
+
+        object->putDirect(vm, Identifier::fromString(vm, "zones"_s),
+            zoneSizesObject);
     }
-
-    object->putDirect(vm, Identifier::fromString(vm, "zones"_s),
-                      zoneSizesObject);
-  }
 #endif
 #endif
 
-  return JSValue::encode(object);
+    return JSValue::encode(object);
 }
 
 JSC_DECLARE_HOST_FUNCTION(functionCreateMemoryFootprint);
 JSC_DEFINE_HOST_FUNCTION(functionCreateMemoryFootprint,
-                         (JSGlobalObject * globalObject, CallFrame *)) {
+    (JSGlobalObject * globalObject, CallFrame*))
+{
 
-  size_t elapsed_msecs = 0;
-  size_t user_msecs = 0;
-  size_t system_msecs = 0;
-  size_t current_rss = 0;
-  size_t peak_rss = 0;
-  size_t current_commit = 0;
-  size_t peak_commit = 0;
-  size_t page_faults = 0;
+    size_t elapsed_msecs = 0;
+    size_t user_msecs = 0;
+    size_t system_msecs = 0;
+    size_t current_rss = 0;
+    size_t peak_rss = 0;
+    size_t current_commit = 0;
+    size_t peak_commit = 0;
+    size_t page_faults = 0;
 
-  mi_process_info(&elapsed_msecs, &user_msecs, &system_msecs, &current_rss,
-                  &peak_rss, &current_commit, &peak_commit, &page_faults);
+    mi_process_info(&elapsed_msecs, &user_msecs, &system_msecs, &current_rss,
+        &peak_rss, &current_commit, &peak_commit, &page_faults);
 
-  // mi_process_info produces incorrect rss size on linux.
-  Bun::getRSS(&current_rss);
+    // mi_process_info produces incorrect rss size on linux.
+    Bun::getRSS(&current_rss);
 
-  VM &vm = globalObject->vm();
-  JSC::JSObject *object = JSC::constructEmptyObject(
-      vm, JSC::jsCast<Zig::GlobalObject *>(globalObject)
-              ->memoryFootprintStructure());
+    VM& vm = globalObject->vm();
+    JSC::JSObject* object = JSC::constructEmptyObject(
+        vm, JSC::jsCast<Zig::GlobalObject*>(globalObject)->memoryFootprintStructure());
 
-  object->putDirectOffset(vm, 0, jsNumber(current_rss));
-  object->putDirectOffset(vm, 1, jsNumber(peak_rss));
-  object->putDirectOffset(vm, 2, jsNumber(current_commit));
-  object->putDirectOffset(vm, 3, jsNumber(peak_commit));
-  object->putDirectOffset(vm, 4, jsNumber(page_faults));
+    object->putDirectOffset(vm, 0, jsNumber(current_rss));
+    object->putDirectOffset(vm, 1, jsNumber(peak_rss));
+    object->putDirectOffset(vm, 2, jsNumber(current_commit));
+    object->putDirectOffset(vm, 3, jsNumber(peak_commit));
+    object->putDirectOffset(vm, 4, jsNumber(page_faults));
 
-  return JSValue::encode(object);
+    return JSValue::encode(object);
 }
 
 JSC_DECLARE_HOST_FUNCTION(functionNeverInlineFunction);
 JSC_DEFINE_HOST_FUNCTION(functionNeverInlineFunction,
-                         (JSGlobalObject * globalObject,
-                          CallFrame *callFrame)) {
-  return JSValue::encode(setNeverInline(globalObject, callFrame));
+    (JSGlobalObject * globalObject,
+        CallFrame* callFrame))
+{
+    return JSValue::encode(setNeverInline(globalObject, callFrame));
 }
 
-extern "C" bool Bun__mkdirp(JSC::JSGlobalObject *, const char *);
+extern "C" bool Bun__mkdirp(JSC::JSGlobalObject*, const char*);
 
 JSC_DECLARE_HOST_FUNCTION(functionStartSamplingProfiler);
 JSC_DEFINE_HOST_FUNCTION(functionStartSamplingProfiler,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callFrame)) {
-  JSC::VM &vm = globalObject->vm();
-  JSC::SamplingProfiler &samplingProfiler =
-      vm.ensureSamplingProfiler(WTF::Stopwatch::create());
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callFrame))
+{
+    JSC::VM& vm = globalObject->vm();
+    JSC::SamplingProfiler& samplingProfiler = vm.ensureSamplingProfiler(WTF::Stopwatch::create());
 
-  JSC::JSValue directoryValue = callFrame->argument(0);
-  JSC::JSValue sampleValue = callFrame->argument(1);
+    JSC::JSValue directoryValue = callFrame->argument(0);
+    JSC::JSValue sampleValue = callFrame->argument(1);
 
-  auto scope = DECLARE_THROW_SCOPE(vm);
-  if (directoryValue.isString()) {
-    auto path = directoryValue.toWTFString(globalObject);
-    if (!path.isEmpty()) {
-      StringPrintStream pathOut;
-      auto pathCString = toCString(String(path));
-      if (!Bun__mkdirp(globalObject, pathCString.data())) {
-        throwVMError(
-            globalObject, scope,
-            createTypeError(globalObject, "directory couldn't be created"_s));
-        return {};
-      }
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    if (directoryValue.isString()) {
+        auto path = directoryValue.toWTFString(globalObject);
+        if (!path.isEmpty()) {
+            StringPrintStream pathOut;
+            auto pathCString = toCString(String(path));
+            if (!Bun__mkdirp(globalObject, pathCString.data())) {
+                throwVMError(
+                    globalObject, scope,
+                    createTypeError(globalObject, "directory couldn't be created"_s));
+                return {};
+            }
 
-      Options::samplingProfilerPath() = pathCString.data();
-      samplingProfiler.registerForReportAtExit();
+            Options::samplingProfilerPath() = pathCString.data();
+            samplingProfiler.registerForReportAtExit();
+        }
+    }
+    if (sampleValue.isNumber()) {
+        unsigned sampleInterval = sampleValue.toUInt32(globalObject);
+        samplingProfiler.setTimingInterval(
+            Seconds::fromMicroseconds(sampleInterval));
     }
-  }
-  if (sampleValue.isNumber()) {
-    unsigned sampleInterval = sampleValue.toUInt32(globalObject);
-    samplingProfiler.setTimingInterval(
-        Seconds::fromMicroseconds(sampleInterval));
-  }
 
-  samplingProfiler.noticeCurrentThreadAsJSCExecutionThread();
-  samplingProfiler.start();
-  return JSC::JSValue::encode(jsUndefined());
+    samplingProfiler.noticeCurrentThreadAsJSCExecutionThread();
+    samplingProfiler.start();
+    return JSC::JSValue::encode(jsUndefined());
 }
 
 JSC_DECLARE_HOST_FUNCTION(functionSamplingProfilerStackTraces);
 JSC_DEFINE_HOST_FUNCTION(functionSamplingProfilerStackTraces,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *)) {
-  JSC::VM &vm = globalObject->vm();
-  JSC::DeferTermination deferScope(vm);
-  auto scope = DECLARE_THROW_SCOPE(vm);
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame*))
+{
+    JSC::VM& vm = globalObject->vm();
+    JSC::DeferTermination deferScope(vm);
+    auto scope = DECLARE_THROW_SCOPE(vm);
 
-  if (!vm.samplingProfiler())
-    return JSC::JSValue::encode(throwException(
-        globalObject, scope,
-        createError(globalObject, "Sampling profiler was never started"_s)));
+    if (!vm.samplingProfiler())
+        return JSC::JSValue::encode(throwException(
+            globalObject, scope,
+            createError(globalObject, "Sampling profiler was never started"_s)));
 
-  WTF::String jsonString =
-      vm.samplingProfiler()->stackTracesAsJSON()->toJSONString();
-  JSC::EncodedJSValue result =
-      JSC::JSValue::encode(JSONParse(globalObject, jsonString));
-  scope.releaseAssertNoException();
-  return result;
+    WTF::String jsonString = vm.samplingProfiler()->stackTracesAsJSON()->toJSONString();
+    JSC::EncodedJSValue result = JSC::JSValue::encode(JSONParse(globalObject, jsonString));
+    scope.releaseAssertNoException();
+    return result;
 }
 
 JSC_DECLARE_HOST_FUNCTION(functionGetRandomSeed);
 JSC_DEFINE_HOST_FUNCTION(functionGetRandomSeed,
-                         (JSGlobalObject * globalObject, CallFrame *)) {
-  return JSValue::encode(jsNumber(globalObject->weakRandom().seed()));
+    (JSGlobalObject * globalObject, CallFrame*))
+{
+    return JSValue::encode(jsNumber(globalObject->weakRandom().seed()));
 }
 
 JSC_DECLARE_HOST_FUNCTION(functionSetRandomSeed);
-JSC_DEFINE_HOST_FUNCTION(functionSetRandomSeed, (JSGlobalObject * globalObject,
-                                                 CallFrame *callFrame)) {
-  VM &vm = globalObject->vm();
-  auto scope = DECLARE_THROW_SCOPE(vm);
+JSC_DEFINE_HOST_FUNCTION(functionSetRandomSeed, (JSGlobalObject * globalObject, CallFrame* callFrame))
+{
+    VM& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
 
-  unsigned seed = callFrame->argument(0).toUInt32(globalObject);
-  RETURN_IF_EXCEPTION(scope, {});
-  globalObject->weakRandom().setSeed(seed);
-  return JSValue::encode(jsUndefined());
+    unsigned seed = callFrame->argument(0).toUInt32(globalObject);
+    RETURN_IF_EXCEPTION(scope, {});
+    globalObject->weakRandom().setSeed(seed);
+    return JSValue::encode(jsUndefined());
 }
 
 JSC_DECLARE_HOST_FUNCTION(functionIsRope);
 JSC_DEFINE_HOST_FUNCTION(functionIsRope,
-                         (JSGlobalObject *, CallFrame *callFrame)) {
-  JSValue argument = callFrame->argument(0);
-  if (!argument.isString())
-    return JSValue::encode(jsBoolean(false));
-  const StringImpl *impl = asString(argument)->tryGetValueImpl();
-  return JSValue::encode(jsBoolean(!impl));
+    (JSGlobalObject*, CallFrame* callFrame))
+{
+    JSValue argument = callFrame->argument(0);
+    if (!argument.isString())
+        return JSValue::encode(jsBoolean(false));
+    const StringImpl* impl = asString(argument)->tryGetValueImpl();
+    return JSValue::encode(jsBoolean(!impl));
 }
 
 JSC_DECLARE_HOST_FUNCTION(functionCallerSourceOrigin);
 JSC_DEFINE_HOST_FUNCTION(functionCallerSourceOrigin,
-                         (JSGlobalObject * globalObject,
-                          CallFrame *callFrame)) {
-  VM &vm = globalObject->vm();
-  SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-  if (sourceOrigin.url().isNull())
-    return JSValue::encode(jsNull());
-  return JSValue::encode(jsString(vm, sourceOrigin.string()));
+    (JSGlobalObject * globalObject,
+        CallFrame* callFrame))
+{
+    VM& vm = globalObject->vm();
+    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+    if (sourceOrigin.url().isNull())
+        return JSValue::encode(jsNull());
+    return JSValue::encode(jsString(vm, sourceOrigin.string()));
 }
 
 JSC_DECLARE_HOST_FUNCTION(functionNoFTL);
 JSC_DEFINE_HOST_FUNCTION(functionNoFTL,
-                         (JSGlobalObject *, CallFrame *callFrame)) {
-  if (callFrame->argumentCount()) {
-    FunctionExecutable *executable =
-        getExecutableForFunction(callFrame->argument(0));
-    if (executable)
-      executable->setNeverFTLOptimize(true);
-  }
-  return JSValue::encode(jsUndefined());
+    (JSGlobalObject*, CallFrame* callFrame))
+{
+    if (callFrame->argumentCount()) {
+        FunctionExecutable* executable = getExecutableForFunction(callFrame->argument(0));
+        if (executable)
+            executable->setNeverFTLOptimize(true);
+    }
+    return JSValue::encode(jsUndefined());
 }
 
 JSC_DECLARE_HOST_FUNCTION(functionNoOSRExitFuzzing);
 JSC_DEFINE_HOST_FUNCTION(functionNoOSRExitFuzzing,
-                         (JSGlobalObject * globalObject,
-                          CallFrame *callFrame)) {
-  return JSValue::encode(setCannotUseOSRExitFuzzing(globalObject, callFrame));
+    (JSGlobalObject * globalObject,
+        CallFrame* callFrame))
+{
+    return JSValue::encode(setCannotUseOSRExitFuzzing(globalObject, callFrame));
 }
 
 JSC_DECLARE_HOST_FUNCTION(functionOptimizeNextInvocation);
 JSC_DEFINE_HOST_FUNCTION(functionOptimizeNextInvocation,
-                         (JSGlobalObject * globalObject,
-                          CallFrame *callFrame)) {
-  return JSValue::encode(optimizeNextInvocation(globalObject, callFrame));
+    (JSGlobalObject * globalObject,
+        CallFrame* callFrame))
+{
+    return JSValue::encode(optimizeNextInvocation(globalObject, callFrame));
 }
 
 JSC_DECLARE_HOST_FUNCTION(functionNumberOfDFGCompiles);
 JSC_DEFINE_HOST_FUNCTION(functionNumberOfDFGCompiles,
-                         (JSGlobalObject * globalObject,
-                          CallFrame *callFrame)) {
-  return JSValue::encode(numberOfDFGCompiles(globalObject, callFrame));
+    (JSGlobalObject * globalObject,
+        CallFrame* callFrame))
+{
+    return JSValue::encode(numberOfDFGCompiles(globalObject, callFrame));
 }
 
 JSC_DECLARE_HOST_FUNCTION(functionReleaseWeakRefs);
 JSC_DEFINE_HOST_FUNCTION(functionReleaseWeakRefs,
-                         (JSGlobalObject * globalObject,
-                          CallFrame *callFrame)) {
-  globalObject->vm().finalizeSynchronousJSExecution();
-  return JSValue::encode(jsUndefined());
+    (JSGlobalObject * globalObject,
+        CallFrame* callFrame))
+{
+    globalObject->vm().finalizeSynchronousJSExecution();
+    return JSValue::encode(jsUndefined());
 }
 
 JSC_DECLARE_HOST_FUNCTION(functionTotalCompileTime);
 JSC_DEFINE_HOST_FUNCTION(functionTotalCompileTime,
-                         (JSGlobalObject *, CallFrame *)) {
-  return JSValue::encode(jsNumber(JIT::totalCompileTime().milliseconds()));
+    (JSGlobalObject*, CallFrame*))
+{
+    return JSValue::encode(jsNumber(JIT::totalCompileTime().milliseconds()));
 }
 
 JSC_DECLARE_HOST_FUNCTION(functionGetProtectedObjects);
 JSC_DEFINE_HOST_FUNCTION(functionGetProtectedObjects,
-                         (JSGlobalObject * globalObject, CallFrame *)) {
-  MarkedArgumentBuffer list;
-  globalObject->vm().heap.forEachProtectedCell(
-      [&](JSCell *cell) { list.append(cell); });
-  RELEASE_ASSERT(!list.hasOverflowed());
-  return JSC::JSValue::encode(constructArray(
-      globalObject, static_cast<JSC::ArrayAllocationProfile *>(nullptr), list));
+    (JSGlobalObject * globalObject, CallFrame*))
+{
+    MarkedArgumentBuffer list;
+    globalObject->vm().heap.forEachProtectedCell(
+        [&](JSCell* cell) { list.append(cell); });
+    RELEASE_ASSERT(!list.hasOverflowed());
+    return JSC::JSValue::encode(constructArray(
+        globalObject, static_cast<JSC::ArrayAllocationProfile*>(nullptr), list));
 }
 
 JSC_DECLARE_HOST_FUNCTION(functionReoptimizationRetryCount);
 JSC_DEFINE_HOST_FUNCTION(functionReoptimizationRetryCount,
-                         (JSGlobalObject *, CallFrame *callFrame)) {
-  if (callFrame->argumentCount() < 1)
-    return JSValue::encode(jsUndefined());
+    (JSGlobalObject*, CallFrame* callFrame))
+{
+    if (callFrame->argumentCount() < 1)
+        return JSValue::encode(jsUndefined());
 
-  CodeBlock *block =
-      getSomeBaselineCodeBlockForFunction(callFrame->argument(0));
-  if (!block)
-    return JSValue::encode(jsNumber(0));
+    CodeBlock* block = getSomeBaselineCodeBlockForFunction(callFrame->argument(0));
+    if (!block)
+        return JSValue::encode(jsNumber(0));
 
-  return JSValue::encode(jsNumber(block->reoptimizationRetryCounter()));
+    return JSValue::encode(jsNumber(block->reoptimizationRetryCounter()));
 }
 
 extern "C" void Bun__drainMicrotasks();
 
 JSC_DECLARE_HOST_FUNCTION(functionDrainMicrotasks);
 JSC_DEFINE_HOST_FUNCTION(functionDrainMicrotasks,
-                         (JSGlobalObject * globalObject, CallFrame *)) {
-  VM &vm = globalObject->vm();
-  vm.drainMicrotasks();
-  Bun__drainMicrotasks();
-  return JSValue::encode(jsUndefined());
+    (JSGlobalObject * globalObject, CallFrame*))
+{
+    VM& vm = globalObject->vm();
+    vm.drainMicrotasks();
+    Bun__drainMicrotasks();
+    return JSValue::encode(jsUndefined());
 }
 
-JSC_DEFINE_HOST_FUNCTION(functionSetTimeZone, (JSGlobalObject * globalObject,
-                                               CallFrame *callFrame)) {
-  VM &vm = globalObject->vm();
-  auto scope = DECLARE_THROW_SCOPE(vm);
+JSC_DEFINE_HOST_FUNCTION(functionSetTimeZone, (JSGlobalObject * globalObject, CallFrame* callFrame))
+{
+    VM& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
 
-  if (callFrame->argumentCount() < 1) {
-    throwTypeError(globalObject, scope,
-                   "setTimeZone requires a timezone string"_s);
-    return {};
-  }
-
-  if (!callFrame->argument(0).isString()) {
-    throwTypeError(globalObject, scope,
-                   "setTimeZone requires a timezone string"_s);
-    return {};
-  }
-
-  String timeZoneName = callFrame->argument(0).toWTFString(globalObject);
-  RETURN_IF_EXCEPTION(scope, {});
-
-  if (!WTF::setTimeZoneOverride(timeZoneName)) {
-    throwTypeError(globalObject, scope,
-                   makeString("Invalid timezone: \""_s, timeZoneName, "\""_s));
-    return {};
-  }
-  vm.dateCache.resetIfNecessarySlow();
-  WTF::Vector<UChar, 32> buffer;
-  WTF::getTimeZoneOverride(buffer);
-  WTF::String timeZoneString({buffer.data(), buffer.size()});
-  return JSValue::encode(jsString(vm, timeZoneString));
-}
-
-JSC_DEFINE_HOST_FUNCTION(functionRunProfiler, (JSGlobalObject * globalObject,
-                                               CallFrame *callFrame)) {
-  JSC::VM &vm = globalObject->vm();
-  JSC::SamplingProfiler &samplingProfiler =
-      vm.ensureSamplingProfiler(WTF::Stopwatch::create());
-
-  JSC::JSValue callbackValue = callFrame->argument(0);
-  JSC::JSValue sampleValue = callFrame->argument(1);
-
-  MarkedArgumentBuffer args;
-
-  if (callFrame->argumentCount() > 2) {
-    size_t count = callFrame->argumentCount();
-    args.ensureCapacity(count - 2);
-    for (size_t i = 2; i < count; i++) {
-      args.append(callFrame->argument(i));
+    if (callFrame->argumentCount() < 1) {
+        throwTypeError(globalObject, scope,
+            "setTimeZone requires a timezone string"_s);
+        return {};
     }
-  }
 
-  auto throwScope = DECLARE_THROW_SCOPE(vm);
-  if (callbackValue.isUndefinedOrNull() || !callbackValue.isCallable()) {
-    throwException(
-        globalObject, throwScope,
-        createTypeError(globalObject, "First argument must be a function."_s));
-    return JSValue::encode(JSValue{});
-  }
+    if (!callFrame->argument(0).isString()) {
+        throwTypeError(globalObject, scope,
+            "setTimeZone requires a timezone string"_s);
+        return {};
+    }
 
-  JSC::JSFunction *function = jsCast<JSC::JSFunction *>(callbackValue);
+    String timeZoneName = callFrame->argument(0).toWTFString(globalObject);
+    RETURN_IF_EXCEPTION(scope, {});
 
-  if (sampleValue.isNumber()) {
-    unsigned sampleInterval = sampleValue.toUInt32(globalObject);
-    samplingProfiler.setTimingInterval(
-        Seconds::fromMicroseconds(sampleInterval));
-  }
+    if (!WTF::setTimeZoneOverride(timeZoneName)) {
+        throwTypeError(globalObject, scope,
+            makeString("Invalid timezone: \""_s, timeZoneName, "\""_s));
+        return {};
+    }
+    vm.dateCache.resetIfNecessarySlow();
+    WTF::Vector<UChar, 32> buffer;
+    WTF::getTimeZoneOverride(buffer);
+    WTF::String timeZoneString({ buffer.data(), buffer.size() });
+    return JSValue::encode(jsString(vm, timeZoneString));
+}
+
+JSC_DEFINE_HOST_FUNCTION(functionRunProfiler, (JSGlobalObject * globalObject, CallFrame* callFrame))
+{
+    JSC::VM& vm = globalObject->vm();
+    JSC::SamplingProfiler& samplingProfiler = vm.ensureSamplingProfiler(WTF::Stopwatch::create());
+
+    JSC::JSValue callbackValue = callFrame->argument(0);
+    JSC::JSValue sampleValue = callFrame->argument(1);
+
+    MarkedArgumentBuffer args;
+
+    if (callFrame->argumentCount() > 2) {
+        size_t count = callFrame->argumentCount();
+        args.ensureCapacity(count - 2);
+        for (size_t i = 2; i < count; i++) {
+            args.append(callFrame->argument(i));
+        }
+    }
 
-  const auto report = [](JSC::VM &vm,
-                         JSC::JSGlobalObject *globalObject) -> JSC::JSValue {
     auto throwScope = DECLARE_THROW_SCOPE(vm);
-
-    auto &samplingProfiler = *vm.samplingProfiler();
-    StringPrintStream topFunctions;
-    samplingProfiler.reportTopFunctions(topFunctions);
-
-    StringPrintStream byteCodes;
-    samplingProfiler.reportTopBytecodes(byteCodes);
-
-    JSValue stackTraces = JSONParse(
-        globalObject, samplingProfiler.stackTracesAsJSON()->toJSONString());
-
-    samplingProfiler.shutdown();
-    RETURN_IF_EXCEPTION(throwScope, {});
-
-    JSObject *result =
-        constructEmptyObject(globalObject, globalObject->objectPrototype(), 3);
-    result->putDirect(vm, Identifier::fromString(vm, "functions"_s),
-                      jsString(vm, topFunctions.toString()));
-    result->putDirect(vm, Identifier::fromString(vm, "bytecodes"_s),
-                      jsString(vm, byteCodes.toString()));
-    result->putDirect(vm, Identifier::fromString(vm, "stackTraces"_s),
-                      stackTraces);
-
-    return result;
-  };
-  const auto reportFailure = [](JSC::VM &vm) -> JSC::JSValue {
-    if (auto *samplingProfiler = vm.samplingProfiler()) {
-      samplingProfiler->pause();
-      samplingProfiler->shutdown();
-      samplingProfiler->clearData();
+    if (callbackValue.isUndefinedOrNull() || !callbackValue.isCallable()) {
+        throwException(
+            globalObject, throwScope,
+            createTypeError(globalObject, "First argument must be a function."_s));
+        return JSValue::encode(JSValue {});
     }
 
-    return {};
-  };
+    JSC::JSFunction* function = jsCast<JSC::JSFunction*>(callbackValue);
 
-  JSC::CallData callData = JSC::getCallData(function);
+    if (sampleValue.isNumber()) {
+        unsigned sampleInterval = sampleValue.toUInt32(globalObject);
+        samplingProfiler.setTimingInterval(
+            Seconds::fromMicroseconds(sampleInterval));
+    }
 
-  samplingProfiler.noticeCurrentThreadAsJSCExecutionThread();
-  samplingProfiler.start();
-  JSValue returnValue =
-      JSC::call(globalObject, function, callData, JSC::jsUndefined(), args);
+    const auto report = [](JSC::VM& vm,
+                            JSC::JSGlobalObject* globalObject) -> JSC::JSValue {
+        auto throwScope = DECLARE_THROW_SCOPE(vm);
 
-  if (returnValue.isEmpty() || throwScope.exception()) {
-    return JSValue::encode(reportFailure(vm));
-  }
+        auto& samplingProfiler = *vm.samplingProfiler();
+        StringPrintStream topFunctions;
+        samplingProfiler.reportTopFunctions(topFunctions);
 
-  if (auto *promise = jsDynamicCast<JSPromise *>(returnValue)) {
-    auto afterOngoingPromiseCapability =
-        JSC::JSPromise::create(vm, globalObject->promiseStructure());
-    RETURN_IF_EXCEPTION(throwScope, {});
+        StringPrintStream byteCodes;
+        samplingProfiler.reportTopBytecodes(byteCodes);
 
-    JSNativeStdFunction *resolve = JSNativeStdFunction::create(
-        vm, globalObject, 0, "resolve"_s,
-        [report](JSGlobalObject *globalObject, CallFrame *callFrame) {
-          return JSValue::encode(JSPromise::resolvedPromise(
-              globalObject, report(globalObject->vm(), globalObject)));
-        });
-    JSNativeStdFunction *reject = JSNativeStdFunction::create(
-        vm, globalObject, 0, "reject"_s,
-        [reportFailure](JSGlobalObject *globalObject, CallFrame *callFrame) {
-          EnsureStillAliveScope error = callFrame->argument(0);
-          auto scope = DECLARE_THROW_SCOPE(globalObject->vm());
-          reportFailure(globalObject->vm());
-          throwException(globalObject, scope, error.value());
-          return JSValue::encode({});
-        });
-    promise->performPromiseThen(globalObject, resolve, reject,
-                                afterOngoingPromiseCapability);
-    return JSValue::encode(afterOngoingPromiseCapability);
-  }
+        JSValue stackTraces = JSONParse(
+            globalObject, samplingProfiler.stackTracesAsJSON()->toJSONString());
 
-  return JSValue::encode(report(vm, globalObject));
+        samplingProfiler.shutdown();
+        RETURN_IF_EXCEPTION(throwScope, {});
+
+        JSObject* result = constructEmptyObject(globalObject, globalObject->objectPrototype(), 3);
+        result->putDirect(vm, Identifier::fromString(vm, "functions"_s),
+            jsString(vm, topFunctions.toString()));
+        result->putDirect(vm, Identifier::fromString(vm, "bytecodes"_s),
+            jsString(vm, byteCodes.toString()));
+        result->putDirect(vm, Identifier::fromString(vm, "stackTraces"_s),
+            stackTraces);
+
+        return result;
+    };
+    const auto reportFailure = [](JSC::VM& vm) -> JSC::JSValue {
+        if (auto* samplingProfiler = vm.samplingProfiler()) {
+            samplingProfiler->pause();
+            samplingProfiler->shutdown();
+            samplingProfiler->clearData();
+        }
+
+        return {};
+    };
+
+    JSC::CallData callData = JSC::getCallData(function);
+
+    samplingProfiler.noticeCurrentThreadAsJSCExecutionThread();
+    samplingProfiler.start();
+    JSValue returnValue = JSC::call(globalObject, function, callData, JSC::jsUndefined(), args);
+
+    if (returnValue.isEmpty() || throwScope.exception()) {
+        return JSValue::encode(reportFailure(vm));
+    }
+
+    if (auto* promise = jsDynamicCast<JSPromise*>(returnValue)) {
+        auto afterOngoingPromiseCapability = JSC::JSPromise::create(vm, globalObject->promiseStructure());
+        RETURN_IF_EXCEPTION(throwScope, {});
+
+        JSNativeStdFunction* resolve = JSNativeStdFunction::create(
+            vm, globalObject, 0, "resolve"_s,
+            [report](JSGlobalObject* globalObject, CallFrame* callFrame) {
+                return JSValue::encode(JSPromise::resolvedPromise(
+                    globalObject, report(globalObject->vm(), globalObject)));
+            });
+        JSNativeStdFunction* reject = JSNativeStdFunction::create(
+            vm, globalObject, 0, "reject"_s,
+            [reportFailure](JSGlobalObject* globalObject, CallFrame* callFrame) {
+                EnsureStillAliveScope error = callFrame->argument(0);
+                auto scope = DECLARE_THROW_SCOPE(globalObject->vm());
+                reportFailure(globalObject->vm());
+                throwException(globalObject, scope, error.value());
+                return JSValue::encode({});
+            });
+        promise->performPromiseThen(globalObject, resolve, reject,
+            afterOngoingPromiseCapability);
+        return JSValue::encode(afterOngoingPromiseCapability);
+    }
+
+    return JSValue::encode(report(vm, globalObject));
 }
 
 JSC_DECLARE_HOST_FUNCTION(functionGenerateHeapSnapshotForDebugging);
 JSC_DEFINE_HOST_FUNCTION(functionGenerateHeapSnapshotForDebugging,
-                         (JSGlobalObject * globalObject, CallFrame *)) {
-  VM &vm = globalObject->vm();
-  JSLockHolder lock(vm);
-  DeferTermination deferScope(vm);
-  auto scope = DECLARE_THROW_SCOPE(vm);
-  String jsonString;
-  {
-    DeferGCForAWhile deferGC(vm); // Prevent concurrent GC from interfering with
-                                  // the full GC that the snapshot does.
+    (JSGlobalObject * globalObject, CallFrame*))
+{
+    VM& vm = globalObject->vm();
+    JSLockHolder lock(vm);
+    DeferTermination deferScope(vm);
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    String jsonString;
+    {
+        DeferGCForAWhile deferGC(vm); // Prevent concurrent GC from interfering with
+                                      // the full GC that the snapshot does.
 
-    HeapSnapshotBuilder snapshotBuilder(
-        vm.ensureHeapProfiler(),
-        HeapSnapshotBuilder::SnapshotType::GCDebuggingSnapshot);
-    snapshotBuilder.buildSnapshot();
+        HeapSnapshotBuilder snapshotBuilder(
+            vm.ensureHeapProfiler(),
+            HeapSnapshotBuilder::SnapshotType::GCDebuggingSnapshot);
+        snapshotBuilder.buildSnapshot();
 
-    jsonString = snapshotBuilder.json();
-  }
-  scope.releaseAssertNoException();
+        jsonString = snapshotBuilder.json();
+    }
+    scope.releaseAssertNoException();
 
-  return JSValue::encode(JSONParse(globalObject, WTFMove(jsonString)));
+    return JSValue::encode(JSONParse(globalObject, WTFMove(jsonString)));
 }
 
 JSC_DEFINE_HOST_FUNCTION(functionSerialize,
-                         (JSGlobalObject * lexicalGlobalObject,
-                          CallFrame *callFrame)) {
-  auto *globalObject = jsCast<JSDOMGlobalObject *>(lexicalGlobalObject);
-  JSC::VM &vm = globalObject->vm();
-  auto throwScope = DECLARE_THROW_SCOPE(vm);
+    (JSGlobalObject * lexicalGlobalObject,
+        CallFrame* callFrame))
+{
+    auto* globalObject = jsCast<JSDOMGlobalObject*>(lexicalGlobalObject);
+    JSC::VM& vm = globalObject->vm();
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
 
-  JSValue value = callFrame->argument(0);
-  JSValue optionsObject = callFrame->argument(1);
-  bool asNodeBuffer = false;
-  if (optionsObject.isObject()) {
-    JSC::JSObject *options = optionsObject.getObject();
-    if (JSC::JSValue binaryTypeValue = options->getIfPropertyExists(
-            globalObject, JSC::Identifier::fromString(vm, "binaryType"_s))) {
-      if (!binaryTypeValue.isString()) {
-        throwTypeError(globalObject, throwScope,
-                       "binaryType must be a string"_s);
-        return {};
-      }
+    JSValue value = callFrame->argument(0);
+    JSValue optionsObject = callFrame->argument(1);
+    bool asNodeBuffer = false;
+    if (optionsObject.isObject()) {
+        JSC::JSObject* options = optionsObject.getObject();
+        if (JSC::JSValue binaryTypeValue = options->getIfPropertyExists(
+                globalObject, JSC::Identifier::fromString(vm, "binaryType"_s))) {
+            if (!binaryTypeValue.isString()) {
+                throwTypeError(globalObject, throwScope,
+                    "binaryType must be a string"_s);
+                return {};
+            }
 
-      asNodeBuffer =
-          binaryTypeValue.toWTFString(globalObject) == "nodebuffer"_s;
-      RETURN_IF_EXCEPTION(throwScope, {});
+            asNodeBuffer = binaryTypeValue.toWTFString(globalObject) == "nodebuffer"_s;
+            RETURN_IF_EXCEPTION(throwScope, {});
+        }
     }
-  }
 
-  Vector<JSC::Strong<JSC::JSObject>> transferList;
-  Vector<RefPtr<MessagePort>> dummyPorts;
-  ExceptionOr<Ref<SerializedScriptValue>> serialized =
-      SerializedScriptValue::create(*globalObject, value, WTFMove(transferList),
-                                    dummyPorts);
+    Vector<JSC::Strong<JSC::JSObject>> transferList;
+    Vector<RefPtr<MessagePort>> dummyPorts;
+    ExceptionOr<Ref<SerializedScriptValue>> serialized = SerializedScriptValue::create(*globalObject, value, WTFMove(transferList),
+        dummyPorts);
 
-  if (serialized.hasException()) {
-    WebCore::propagateException(*globalObject, throwScope,
-                                serialized.releaseException());
-    return JSValue::encode(jsUndefined());
-  }
+    if (serialized.hasException()) {
+        WebCore::propagateException(*globalObject, throwScope,
+            serialized.releaseException());
+        return JSValue::encode(jsUndefined());
+    }
 
-  auto serializedValue = serialized.releaseReturnValue();
-  auto arrayBuffer = serializedValue->toArrayBuffer();
+    auto serializedValue = serialized.releaseReturnValue();
+    auto arrayBuffer = serializedValue->toArrayBuffer();
 
-  if (asNodeBuffer) {
-    size_t byteLength = arrayBuffer->byteLength();
-    JSC::JSUint8Array *uint8Array = JSC::JSUint8Array::create(
-        lexicalGlobalObject, globalObject->JSBufferSubclassStructure(),
-        WTFMove(arrayBuffer), 0, byteLength);
-    return JSValue::encode(uint8Array);
-  }
+    if (asNodeBuffer) {
+        size_t byteLength = arrayBuffer->byteLength();
+        JSC::JSUint8Array* uint8Array = JSC::JSUint8Array::create(
+            lexicalGlobalObject, globalObject->JSBufferSubclassStructure(),
+            WTFMove(arrayBuffer), 0, byteLength);
+        return JSValue::encode(uint8Array);
+    }
 
-  if (arrayBuffer->isShared()) {
-    return JSValue::encode(
-        JSArrayBuffer::create(vm,
-                              globalObject->arrayBufferStructureWithSharingMode<
-                                  ArrayBufferSharingMode::Shared>(),
-                              WTFMove(arrayBuffer)));
-  }
+    if (arrayBuffer->isShared()) {
+        return JSValue::encode(
+            JSArrayBuffer::create(vm,
+                globalObject->arrayBufferStructureWithSharingMode<
+                    ArrayBufferSharingMode::Shared>(),
+                WTFMove(arrayBuffer)));
+    }
 
-  return JSValue::encode(JSArrayBuffer::create(
-      vm, globalObject->arrayBufferStructure(), WTFMove(arrayBuffer)));
+    return JSValue::encode(JSArrayBuffer::create(
+        vm, globalObject->arrayBufferStructure(), WTFMove(arrayBuffer)));
 }
-JSC_DEFINE_HOST_FUNCTION(functionDeserialize, (JSGlobalObject * globalObject,
-                                               CallFrame *callFrame)) {
-  JSC::VM &vm = globalObject->vm();
-  auto throwScope = DECLARE_THROW_SCOPE(vm);
-  JSValue value = callFrame->argument(0);
+JSC_DEFINE_HOST_FUNCTION(functionDeserialize, (JSGlobalObject * globalObject, CallFrame* callFrame))
+{
+    JSC::VM& vm = globalObject->vm();
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    JSValue value = callFrame->argument(0);
 
-  JSValue result;
+    JSValue result;
 
-  if (auto *jsArrayBuffer = jsDynamicCast<JSArrayBuffer *>(value)) {
-    result = SerializedScriptValue::fromArrayBuffer(
-        *globalObject, globalObject, jsArrayBuffer->impl(), 0,
-        jsArrayBuffer->impl()->byteLength());
-  } else if (auto *view = jsDynamicCast<JSArrayBufferView *>(value)) {
-    auto arrayBuffer = view->possiblySharedImpl()->possiblySharedBuffer();
-    result = SerializedScriptValue::fromArrayBuffer(
-        *globalObject, globalObject, arrayBuffer.get(), view->byteOffset(),
-        view->byteLength());
-  } else {
-    throwTypeError(globalObject, throwScope,
-                   "First argument must be an ArrayBuffer"_s);
-    return {};
-  }
+    if (auto* jsArrayBuffer = jsDynamicCast<JSArrayBuffer*>(value)) {
+        result = SerializedScriptValue::fromArrayBuffer(
+            *globalObject, globalObject, jsArrayBuffer->impl(), 0,
+            jsArrayBuffer->impl()->byteLength());
+    } else if (auto* view = jsDynamicCast<JSArrayBufferView*>(value)) {
+        auto arrayBuffer = view->possiblySharedImpl()->possiblySharedBuffer();
+        result = SerializedScriptValue::fromArrayBuffer(
+            *globalObject, globalObject, arrayBuffer.get(), view->byteOffset(),
+            view->byteLength());
+    } else {
+        throwTypeError(globalObject, throwScope,
+            "First argument must be an ArrayBuffer"_s);
+        return {};
+    }
 
-  RETURN_IF_EXCEPTION(throwScope, {});
-  RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
+    RETURN_IF_EXCEPTION(throwScope, {});
+    RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
 extern "C" JSC::EncodedJSValue ByteRangeMapping__findExecutedLines(
-    JSC::JSGlobalObject *, BunString sourceURL, BasicBlockRange *ranges,
+    JSC::JSGlobalObject*, BunString sourceURL, BasicBlockRange* ranges,
     size_t len, size_t functionOffset, bool ignoreSourceMap);
 
 JSC_DEFINE_HOST_FUNCTION(functionCodeCoverageForFile,
-                         (JSGlobalObject * globalObject,
-                          CallFrame *callFrame)) {
-  VM &vm = globalObject->vm();
-  auto throwScope = DECLARE_THROW_SCOPE(vm);
+    (JSGlobalObject * globalObject,
+        CallFrame* callFrame))
+{
+    VM& vm = globalObject->vm();
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
 
-  String fileName = callFrame->argument(0).toWTFString(globalObject);
-  RETURN_IF_EXCEPTION(throwScope, {});
-  bool ignoreSourceMap = callFrame->argument(1).toBoolean(globalObject);
+    String fileName = callFrame->argument(0).toWTFString(globalObject);
+    RETURN_IF_EXCEPTION(throwScope, {});
+    bool ignoreSourceMap = callFrame->argument(1).toBoolean(globalObject);
 
-  auto sourceID = Zig::sourceIDForSourceURL(fileName);
-  if (!sourceID) {
-    throwException(globalObject, throwScope,
-                   createError(globalObject, "No source for file"_s));
-    return {};
-  }
+    auto sourceID = Zig::sourceIDForSourceURL(fileName);
+    if (!sourceID) {
+        throwException(globalObject, throwScope,
+            createError(globalObject, "No source for file"_s));
+        return {};
+    }
 
-  auto basicBlocks =
-      vm.controlFlowProfiler()->getBasicBlocksForSourceIDWithoutFunctionRange(
-          sourceID, vm);
+    auto basicBlocks = vm.controlFlowProfiler()->getBasicBlocksForSourceIDWithoutFunctionRange(
+        sourceID, vm);
 
-  if (basicBlocks.isEmpty()) {
-    return JSC::JSValue::encode(
-        JSC::constructEmptyArray(globalObject, nullptr, 0));
-  }
+    if (basicBlocks.isEmpty()) {
+        return JSC::JSValue::encode(
+            JSC::constructEmptyArray(globalObject, nullptr, 0));
+    }
 
-  size_t functionStartOffset = basicBlocks.size();
+    size_t functionStartOffset = basicBlocks.size();
 
-  const Vector<std::tuple<bool, unsigned, unsigned>> &functionRanges =
-      vm.functionHasExecutedCache()->getFunctionRanges(sourceID);
+    const Vector<std::tuple<bool, unsigned, unsigned>>& functionRanges = vm.functionHasExecutedCache()->getFunctionRanges(sourceID);
 
-  basicBlocks.reserveCapacity(functionRanges.size() + basicBlocks.size());
+    basicBlocks.reserveCapacity(functionRanges.size() + basicBlocks.size());
 
-  for (const auto &functionRange : functionRanges) {
-    BasicBlockRange range;
-    range.m_hasExecuted = std::get<0>(functionRange);
-    range.m_startOffset = static_cast<int>(std::get<1>(functionRange));
-    range.m_endOffset = static_cast<int>(std::get<2>(functionRange));
-    range.m_executionCount =
-        range.m_hasExecuted
+    for (const auto& functionRange : functionRanges) {
+        BasicBlockRange range;
+        range.m_hasExecuted = std::get<0>(functionRange);
+        range.m_startOffset = static_cast<int>(std::get<1>(functionRange));
+        range.m_endOffset = static_cast<int>(std::get<2>(functionRange));
+        range.m_executionCount = range.m_hasExecuted
             ? 1
             : 0; // This is a hack. We don't actually count this.
-    basicBlocks.append(range);
-  }
+        basicBlocks.append(range);
+    }
 
-  return ByteRangeMapping__findExecutedLines(
-      globalObject, Bun::toString(fileName), basicBlocks.data(),
-      basicBlocks.size(), functionStartOffset, ignoreSourceMap);
+    return ByteRangeMapping__findExecutedLines(
+        globalObject, Bun::toString(fileName), basicBlocks.data(),
+        basicBlocks.size(), functionStartOffset, ignoreSourceMap);
 }
 
 // clang-format off
diff --git a/src/bun.js/modules/BunObjectModule.cpp b/src/bun.js/modules/BunObjectModule.cpp
index 910614ce3f..f018845674 100644
--- a/src/bun.js/modules/BunObjectModule.cpp
+++ b/src/bun.js/modules/BunObjectModule.cpp
@@ -5,19 +5,19 @@
 #include "ObjectModule.h"
 
 namespace Zig {
-void generateNativeModule_BunObject(JSC::JSGlobalObject *lexicalGlobalObject,
-                                    JSC::Identifier moduleKey,
-                                    Vector<JSC::Identifier, 4> &exportNames,
-                                    JSC::MarkedArgumentBuffer &exportValues) {
-  // FIXME: this does not add each property as a top level export
-  JSC::VM &vm = lexicalGlobalObject->vm();
-  Zig::GlobalObject *globalObject =
-      jsCast<Zig::GlobalObject *>(lexicalGlobalObject);
+void generateNativeModule_BunObject(JSC::JSGlobalObject* lexicalGlobalObject,
+    JSC::Identifier moduleKey,
+    Vector<JSC::Identifier, 4>& exportNames,
+    JSC::MarkedArgumentBuffer& exportValues)
+{
+    // FIXME: this does not add each property as a top level export
+    JSC::VM& vm = lexicalGlobalObject->vm();
+    Zig::GlobalObject* globalObject = jsCast<Zig::GlobalObject*>(lexicalGlobalObject);
 
-  JSObject *object = globalObject->bunObject();
+    JSObject* object = globalObject->bunObject();
 
-  exportNames.append(vm.propertyNames->defaultKeyword);
-  exportValues.append(object);
+    exportNames.append(vm.propertyNames->defaultKeyword);
+    exportValues.append(object);
 }
 
-} // namespace Zig
\ No newline at end of file
+} // namespace Zig
diff --git a/src/bun.js/modules/BunObjectModule.h b/src/bun.js/modules/BunObjectModule.h
index 3d7ba1534f..c5aefa3e94 100644
--- a/src/bun.js/modules/BunObjectModule.h
+++ b/src/bun.js/modules/BunObjectModule.h
@@ -1,8 +1,8 @@
 
 namespace Zig {
-void generateNativeModule_BunObject(JSC::JSGlobalObject *lexicalGlobalObject,
-                                    JSC::Identifier moduleKey,
-                                    Vector<JSC::Identifier, 4> &exportNames,
-                                    JSC::MarkedArgumentBuffer &exportValues);
+void generateNativeModule_BunObject(JSC::JSGlobalObject* lexicalGlobalObject,
+    JSC::Identifier moduleKey,
+    Vector<JSC::Identifier, 4>& exportNames,
+    JSC::MarkedArgumentBuffer& exportValues);
 
-} // namespace Zig
\ No newline at end of file
+} // namespace Zig
diff --git a/src/bun.js/modules/BunTestModule.h b/src/bun.js/modules/BunTestModule.h
index 84687b6e93..4e276bd2fc 100644
--- a/src/bun.js/modules/BunTestModule.h
+++ b/src/bun.js/modules/BunTestModule.h
@@ -1,17 +1,18 @@
 
 namespace Zig {
 void generateNativeModule_BunTest(
-  JSC::JSGlobalObject *lexicalGlobalObject,
-  JSC::Identifier moduleKey,
-  Vector<JSC::Identifier, 4> &exportNames,
-  JSC::MarkedArgumentBuffer &exportValues) {
-  JSC::VM &vm = lexicalGlobalObject->vm();
-  auto globalObject = jsCast<Zig::GlobalObject*>(lexicalGlobalObject);
+    JSC::JSGlobalObject* lexicalGlobalObject,
+    JSC::Identifier moduleKey,
+    Vector<JSC::Identifier, 4>& exportNames,
+    JSC::MarkedArgumentBuffer& exportValues)
+{
+    JSC::VM& vm = lexicalGlobalObject->vm();
+    auto globalObject = jsCast<Zig::GlobalObject*>(lexicalGlobalObject);
 
-  JSObject *object = globalObject->lazyPreloadTestModuleObject();
+    JSObject* object = globalObject->lazyPreloadTestModuleObject();
 
-  exportNames.append(vm.propertyNames->defaultKeyword);
-  exportValues.append(object);
+    exportNames.append(vm.propertyNames->defaultKeyword);
+    exportValues.append(object);
 }
 
-} // namespace Zig
\ No newline at end of file
+} // namespace Zig
diff --git a/src/bun.js/modules/NodeBufferModule.h b/src/bun.js/modules/NodeBufferModule.h
index 06546bd046..e53e29950c 100644
--- a/src/bun.js/modules/NodeBufferModule.h
+++ b/src/bun.js/modules/NodeBufferModule.h
@@ -5,6 +5,7 @@
 #include "../bindings/JSBuffer.h"
 #include "ErrorCode.h"
 #include "JavaScriptCore/PageCount.h"
+#include "NodeValidator.h"
 #include "_NativeModule.h"
 #include "wtf/SIMDUTF.h"
 #include <limits>
@@ -15,206 +16,220 @@ using namespace JSC;
 
 // TODO: Add DOMJIT fast path
 JSC_DEFINE_HOST_FUNCTION(jsBufferConstructorFunction_isUtf8,
-                         (JSC::JSGlobalObject * lexicalGlobalObject,
-                          JSC::CallFrame *callframe)) {
-  auto throwScope = DECLARE_THROW_SCOPE(lexicalGlobalObject->vm());
+    (JSC::JSGlobalObject * lexicalGlobalObject,
+        JSC::CallFrame* callframe))
+{
+    auto throwScope = DECLARE_THROW_SCOPE(lexicalGlobalObject->vm());
 
-  auto buffer = callframe->argument(0);
-  auto *bufferView = JSC::jsDynamicCast<JSC::JSArrayBufferView *>(buffer);
-  const char *ptr = nullptr;
-  size_t byteLength = 0;
-  if (bufferView) {
-    if (UNLIKELY(bufferView->isDetached())) {
-      throwTypeError(lexicalGlobalObject, throwScope,
-                     "ArrayBufferView is detached"_s);
-      return {};
+    auto buffer = callframe->argument(0);
+    auto* bufferView = JSC::jsDynamicCast<JSC::JSArrayBufferView*>(buffer);
+    const char* ptr = nullptr;
+    size_t byteLength = 0;
+    if (bufferView) {
+        if (UNLIKELY(bufferView->isDetached())) {
+            throwTypeError(lexicalGlobalObject, throwScope,
+                "ArrayBufferView is detached"_s);
+            return {};
+        }
+
+        byteLength = bufferView->byteLength();
+
+        if (byteLength == 0) {
+            return JSValue::encode(jsBoolean(true));
+        }
+
+        ptr = reinterpret_cast<const char*>(bufferView->vector());
+    } else if (auto* arrayBuffer = JSC::jsDynamicCast<JSC::JSArrayBuffer*>(buffer)) {
+        auto* impl = arrayBuffer->impl();
+
+        if (!impl) {
+            return JSValue::encode(jsBoolean(true));
+        }
+
+        if (UNLIKELY(impl->isDetached())) {
+            return Bun::ERR::INVALID_STATE(throwScope, lexicalGlobalObject,
+                "Cannot validate on a detached buffer"_s);
+        }
+
+        byteLength = impl->byteLength();
+
+        if (byteLength == 0) {
+            return JSValue::encode(jsBoolean(true));
+        }
+
+        ptr = reinterpret_cast<const char*>(impl->data());
+    } else {
+        Bun::throwError(lexicalGlobalObject, throwScope,
+            Bun::ErrorCode::ERR_INVALID_ARG_TYPE,
+            "First argument must be an ArrayBufferView"_s);
+        return {};
     }
 
-    byteLength = bufferView->byteLength();
-
-    if (byteLength == 0) {
-      return JSValue::encode(jsBoolean(true));
-    }
-
-    ptr = reinterpret_cast<const char *>(bufferView->vector());
-  } else if (auto *arrayBuffer =
-                 JSC::jsDynamicCast<JSC::JSArrayBuffer *>(buffer)) {
-    auto *impl = arrayBuffer->impl();
-
-    if (!impl) {
-      return JSValue::encode(jsBoolean(true));
-    }
-
-    if (UNLIKELY(impl->isDetached())) {
-      throwTypeError(lexicalGlobalObject, throwScope,
-                     "ArrayBuffer is detached"_s);
-      return {};
-    }
-
-    byteLength = impl->byteLength();
-
-    if (byteLength == 0) {
-      return JSValue::encode(jsBoolean(true));
-    }
-
-    ptr = reinterpret_cast<const char *>(impl->data());
-  } else {
-    Bun::throwError(lexicalGlobalObject, throwScope,
-                    Bun::ErrorCode::ERR_INVALID_ARG_TYPE,
-                    "First argument must be an ArrayBufferView"_s);
-    return {};
-  }
-
-  RELEASE_AND_RETURN(throwScope, JSValue::encode(jsBoolean(
-                                     simdutf::validate_utf8(ptr, byteLength))));
+    RELEASE_AND_RETURN(throwScope, JSValue::encode(jsBoolean(simdutf::validate_utf8(ptr, byteLength))));
 }
 
 // TODO: Add DOMJIT fast path
 JSC_DEFINE_HOST_FUNCTION(jsBufferConstructorFunction_isAscii,
-                         (JSC::JSGlobalObject * lexicalGlobalObject,
-                          JSC::CallFrame *callframe)) {
-  auto throwScope = DECLARE_THROW_SCOPE(lexicalGlobalObject->vm());
+    (JSC::JSGlobalObject * lexicalGlobalObject,
+        JSC::CallFrame* callframe))
+{
+    auto throwScope = DECLARE_THROW_SCOPE(lexicalGlobalObject->vm());
 
-  auto buffer = callframe->argument(0);
-  auto *bufferView = JSC::jsDynamicCast<JSC::JSArrayBufferView *>(buffer);
-  const char *ptr = nullptr;
-  size_t byteLength = 0;
-  if (bufferView) {
+    auto buffer = callframe->argument(0);
+    auto* bufferView = JSC::jsDynamicCast<JSC::JSArrayBufferView*>(buffer);
+    const char* ptr = nullptr;
+    size_t byteLength = 0;
+    if (bufferView) {
 
-    if (UNLIKELY(bufferView->isDetached())) {
-      throwTypeError(lexicalGlobalObject, throwScope,
-                     "ArrayBufferView is detached"_s);
-      return {};
+        if (UNLIKELY(bufferView->isDetached())) {
+            return Bun::ERR::INVALID_STATE(throwScope, lexicalGlobalObject,
+                "Cannot validate on a detached buffer"_s);
+        }
+
+        byteLength = bufferView->byteLength();
+
+        if (byteLength == 0) {
+            return JSValue::encode(jsBoolean(true));
+        }
+
+        ptr = reinterpret_cast<const char*>(bufferView->vector());
+    } else if (auto* arrayBuffer = JSC::jsDynamicCast<JSC::JSArrayBuffer*>(buffer)) {
+        auto* impl = arrayBuffer->impl();
+        if (UNLIKELY(impl->isDetached())) {
+            return Bun::ERR::INVALID_STATE(throwScope, lexicalGlobalObject,
+                "Cannot validate on a detached buffer"_s);
+        }
+
+        if (!impl) {
+            return JSValue::encode(jsBoolean(true));
+        }
+
+        byteLength = impl->byteLength();
+
+        if (byteLength == 0) {
+            return JSValue::encode(jsBoolean(true));
+        }
+
+        ptr = reinterpret_cast<const char*>(impl->data());
+    } else {
+        Bun::throwError(lexicalGlobalObject, throwScope,
+            Bun::ErrorCode::ERR_INVALID_ARG_TYPE,
+            "First argument must be an ArrayBufferView"_s);
+        return {};
     }
 
-    byteLength = bufferView->byteLength();
-
-    if (byteLength == 0) {
-      return JSValue::encode(jsBoolean(true));
-    }
-
-    ptr = reinterpret_cast<const char *>(bufferView->vector());
-  } else if (auto *arrayBuffer =
-                 JSC::jsDynamicCast<JSC::JSArrayBuffer *>(buffer)) {
-    auto *impl = arrayBuffer->impl();
-    if (UNLIKELY(impl->isDetached())) {
-      throwTypeError(lexicalGlobalObject, throwScope,
-                     "ArrayBuffer is detached"_s);
-      return {};
-    }
-
-    if (!impl) {
-      return JSValue::encode(jsBoolean(true));
-    }
-
-    byteLength = impl->byteLength();
-
-    if (byteLength == 0) {
-      return JSValue::encode(jsBoolean(true));
-    }
-
-    ptr = reinterpret_cast<const char *>(impl->data());
-  } else {
-    Bun::throwError(lexicalGlobalObject, throwScope,
-                    Bun::ErrorCode::ERR_INVALID_ARG_TYPE,
-                    "First argument must be an ArrayBufferView"_s);
-    return {};
-  }
-
-  RELEASE_AND_RETURN(
-      throwScope,
-      JSValue::encode(jsBoolean(simdutf::validate_ascii(ptr, byteLength))));
+    RELEASE_AND_RETURN(
+        throwScope,
+        JSValue::encode(jsBoolean(simdutf::validate_ascii(ptr, byteLength))));
 }
 
 BUN_DECLARE_HOST_FUNCTION(jsFunctionResolveObjectURL);
 
 JSC_DEFINE_HOST_FUNCTION(jsFunctionNotImplemented,
-                         (JSGlobalObject * globalObject,
-                          CallFrame *callFrame)) {
-  VM &vm = globalObject->vm();
-  auto scope = DECLARE_THROW_SCOPE(vm);
+    (JSGlobalObject * globalObject,
+        CallFrame* callFrame))
+{
+    VM& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
 
-  throwException(globalObject, scope,
-                 createError(globalObject, "Not implemented"_s));
-  return {};
+    throwException(globalObject, scope,
+        createError(globalObject, "Not implemented"_s));
+    return {};
 }
 
-DEFINE_NATIVE_MODULE(NodeBuffer) {
-  INIT_NATIVE_MODULE(12);
+JSC_DEFINE_CUSTOM_GETTER(jsGetter_INSPECT_MAX_BYTES, (JSGlobalObject * lexicalGlobalObject, JSC::EncodedJSValue thisValue, PropertyName propertyName))
+{
+    auto globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    return JSValue::encode(jsNumber(globalObject->INSPECT_MAX_BYTES));
+}
 
-  put(JSC::Identifier::fromString(vm, "Buffer"_s),
-      globalObject->JSBufferConstructor());
+JSC_DEFINE_CUSTOM_SETTER(jsSetter_INSPECT_MAX_BYTES, (JSGlobalObject * lexicalGlobalObject, JSC::EncodedJSValue thisValue, JSC::EncodedJSValue value, PropertyName propertyName))
+{
+    auto globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    auto& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    auto val = JSValue::decode(value);
+    Bun::V::validateNumber(scope, globalObject, val, jsString(vm, String("INSPECT_MAX_BYTES"_s)), jsNumber(0), jsUndefined());
+    RETURN_IF_EXCEPTION(scope, {});
+    globalObject->INSPECT_MAX_BYTES = val.asNumber();
+    return JSValue::encode(jsUndefined());
+}
 
-  auto *slowBuffer = JSC::JSFunction::create(
-      vm, globalObject, 0, "SlowBuffer"_s, WebCore::constructSlowBuffer,
-      ImplementationVisibility::Public, NoIntrinsic,
-      WebCore::constructSlowBuffer);
-  slowBuffer->putDirect(
-      vm, vm.propertyNames->prototype, globalObject->JSBufferPrototype(),
-      JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum |
-          JSC::PropertyAttribute::DontDelete);
-  put(JSC::Identifier::fromString(vm, "SlowBuffer"_s), slowBuffer);
-  auto blobIdent = JSC::Identifier::fromString(vm, "Blob"_s);
+DEFINE_NATIVE_MODULE(NodeBuffer)
+{
+    INIT_NATIVE_MODULE(12);
 
-  JSValue blobValue = globalObject->JSBlobConstructor();
-  put(blobIdent, blobValue);
+    put(JSC::Identifier::fromString(vm, "Buffer"_s),
+        globalObject->JSBufferConstructor());
 
-  put(JSC::Identifier::fromString(vm, "File"_s),
-      globalObject->JSDOMFileConstructor());
+    auto* slowBuffer = JSC::JSFunction::create(
+        vm, globalObject, 0, "SlowBuffer"_s, WebCore::constructSlowBuffer,
+        ImplementationVisibility::Public, NoIntrinsic,
+        WebCore::constructSlowBuffer);
+    slowBuffer->putDirect(
+        vm, vm.propertyNames->prototype, globalObject->JSBufferPrototype(),
+        JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::DontDelete);
+    put(JSC::Identifier::fromString(vm, "SlowBuffer"_s), slowBuffer);
+    auto blobIdent = JSC::Identifier::fromString(vm, "Blob"_s);
 
-  put(JSC::Identifier::fromString(vm, "INSPECT_MAX_BYTES"_s),
-      JSC::jsNumber(50));
+    JSValue blobValue = globalObject->JSBlobConstructor();
+    put(blobIdent, blobValue);
 
-  put(JSC::Identifier::fromString(vm, "kMaxLength"_s),
-      JSC::jsNumber(MAX_ARRAY_BUFFER_SIZE));
+    put(JSC::Identifier::fromString(vm, "File"_s),
+        globalObject->JSDOMFileConstructor());
 
-  put(JSC::Identifier::fromString(vm, "kStringMaxLength"_s),
-      JSC::jsNumber(std::numeric_limits<unsigned>().max()));
+    {
+        auto name = Identifier::fromString(vm, "INSPECT_MAX_BYTES"_s);
+        auto value = JSC::CustomGetterSetter::create(vm, jsGetter_INSPECT_MAX_BYTES, jsSetter_INSPECT_MAX_BYTES);
+        auto attributes = PropertyAttribute::DontDelete | PropertyAttribute::CustomAccessor;
+        defaultObject->putDirectCustomAccessor(vm, name, value, (unsigned)attributes);
+        exportNames.append(name);
+        exportValues.append(value);
+        __NATIVE_MODULE_ASSERT_INCR;
+    }
 
-  JSC::JSObject *constants = JSC::constructEmptyObject(
-      lexicalGlobalObject, globalObject->objectPrototype(), 2);
-  constants->putDirect(vm, JSC::Identifier::fromString(vm, "MAX_LENGTH"_s),
-                       JSC::jsNumber(MAX_ARRAY_BUFFER_SIZE));
-  constants->putDirect(vm,
-                       JSC::Identifier::fromString(vm, "MAX_STRING_LENGTH"_s),
-                       JSC::jsNumber(std::numeric_limits<unsigned>().max()));
+    put(JSC::Identifier::fromString(vm, "kMaxLength"_s), JSC::jsNumber(Bun::Buffer::kMaxLength));
+    put(JSC::Identifier::fromString(vm, "kStringMaxLength"_s), JSC::jsNumber(Bun::Buffer::kStringMaxLength));
 
-  put(JSC::Identifier::fromString(vm, "constants"_s), constants);
+    JSC::JSObject* constants = JSC::constructEmptyObject(lexicalGlobalObject, globalObject->objectPrototype(), 2);
+    constants->putDirect(vm, JSC::Identifier::fromString(vm, "MAX_LENGTH"_s), JSC::jsNumber(Bun::Buffer::MAX_LENGTH));
+    constants->putDirect(vm, JSC::Identifier::fromString(vm, "MAX_STRING_LENGTH"_s), JSC::jsNumber(Bun::Buffer::MAX_STRING_LENGTH));
 
-  JSC::Identifier atobI = JSC::Identifier::fromString(vm, "atob"_s);
-  JSC::JSValue atobV =
-      lexicalGlobalObject->get(globalObject, PropertyName(atobI));
+    put(JSC::Identifier::fromString(vm, "constants"_s), constants);
 
-  JSC::Identifier btoaI = JSC::Identifier::fromString(vm, "btoa"_s);
-  JSC::JSValue btoaV =
-      lexicalGlobalObject->get(globalObject, PropertyName(btoaI));
+    JSC::Identifier atobI = JSC::Identifier::fromString(vm, "atob"_s);
+    JSC::JSValue atobV = lexicalGlobalObject->get(globalObject, PropertyName(atobI));
 
-  put(atobI, atobV);
-  put(btoaI, btoaV);
+    JSC::Identifier btoaI = JSC::Identifier::fromString(vm, "btoa"_s);
+    JSC::JSValue btoaV = lexicalGlobalObject->get(globalObject, PropertyName(btoaI));
 
-  auto *transcode = InternalFunction::createFunctionThatMasqueradesAsUndefined(
-      vm, globalObject, 1, "transcode"_s, jsFunctionNotImplemented);
+    put(atobI, atobV);
+    put(btoaI, btoaV);
 
-  put(JSC::Identifier::fromString(vm, "transcode"_s), transcode);
+    auto* transcode = InternalFunction::createFunctionThatMasqueradesAsUndefined(
+        vm, globalObject, 1, "transcode"_s, jsFunctionNotImplemented);
 
-  auto *resolveObjectURL =
-      InternalFunction::createFunctionThatMasqueradesAsUndefined(
-          vm, globalObject, 1, "resolveObjectURL"_s,
-          jsFunctionResolveObjectURL);
+    put(JSC::Identifier::fromString(vm, "transcode"_s), transcode);
 
-  put(JSC::Identifier::fromString(vm, "resolveObjectURL"_s), resolveObjectURL);
+    auto* resolveObjectURL = JSC::JSFunction::create(
+        vm, globalObject, 1, "resolveObjectURL"_s,
+        jsFunctionResolveObjectURL,
+        ImplementationVisibility::Public, NoIntrinsic,
+        jsFunctionResolveObjectURL);
 
-  put(JSC::Identifier::fromString(vm, "isAscii"_s),
-      JSC::JSFunction::create(vm, globalObject, 1, "isAscii"_s,
-                              jsBufferConstructorFunction_isAscii,
-                              ImplementationVisibility::Public, NoIntrinsic,
-                              jsBufferConstructorFunction_isUtf8));
+    put(JSC::Identifier::fromString(vm, "resolveObjectURL"_s), resolveObjectURL);
 
-  put(JSC::Identifier::fromString(vm, "isUtf8"_s),
-      JSC::JSFunction::create(vm, globalObject, 1, "isUtf8"_s,
-                              jsBufferConstructorFunction_isUtf8,
-                              ImplementationVisibility::Public, NoIntrinsic,
-                              jsBufferConstructorFunction_isUtf8));
+    put(JSC::Identifier::fromString(vm, "isAscii"_s),
+        JSC::JSFunction::create(vm, globalObject, 1, "isAscii"_s,
+            jsBufferConstructorFunction_isAscii,
+            ImplementationVisibility::Public, NoIntrinsic,
+            jsBufferConstructorFunction_isUtf8));
+
+    put(JSC::Identifier::fromString(vm, "isUtf8"_s),
+        JSC::JSFunction::create(vm, globalObject, 1, "isUtf8"_s,
+            jsBufferConstructorFunction_isUtf8,
+            ImplementationVisibility::Public, NoIntrinsic,
+            jsBufferConstructorFunction_isUtf8));
 }
 
 } // namespace Zig
diff --git a/src/bun.js/modules/NodeConstantsModule.h b/src/bun.js/modules/NodeConstantsModule.h
index ce701f5e32..9a0d2f0643 100644
--- a/src/bun.js/modules/NodeConstantsModule.h
+++ b/src/bun.js/modules/NodeConstantsModule.h
@@ -49,941 +49,942 @@
 namespace Zig {
 using namespace WebCore;
 
-DEFINE_NATIVE_MODULE(NodeConstants) {
-  INIT_NATIVE_MODULE(0);
+DEFINE_NATIVE_MODULE(NodeConstants)
+{
+    INIT_NATIVE_MODULE(0);
 
 #ifdef RTLD_LAZY
-  put(Identifier::fromString(vm, "RTLD_LAZY"_s), jsNumber(RTLD_LAZY));
+    put(Identifier::fromString(vm, "RTLD_LAZY"_s), jsNumber(RTLD_LAZY));
 #endif
 #ifdef RTLD_NOW
-  put(Identifier::fromString(vm, "RTLD_NOW"_s), jsNumber(RTLD_NOW));
+    put(Identifier::fromString(vm, "RTLD_NOW"_s), jsNumber(RTLD_NOW));
 #endif
 #ifdef RTLD_GLOBAL
-  put(Identifier::fromString(vm, "RTLD_GLOBAL"_s), jsNumber(RTLD_GLOBAL));
+    put(Identifier::fromString(vm, "RTLD_GLOBAL"_s), jsNumber(RTLD_GLOBAL));
 #endif
 #ifdef RTLD_LOCAL
-  put(Identifier::fromString(vm, "RTLD_LOCAL"_s), jsNumber(RTLD_LOCAL));
+    put(Identifier::fromString(vm, "RTLD_LOCAL"_s), jsNumber(RTLD_LOCAL));
 #endif
 #ifdef RTLD_DEEPBIND
-  put(Identifier::fromString(vm, "RTLD_DEEPBIND"_s), jsNumber(RTLD_DEEPBIND));
+    put(Identifier::fromString(vm, "RTLD_DEEPBIND"_s), jsNumber(RTLD_DEEPBIND));
 #endif
 #ifdef E2BIG
-  put(Identifier::fromString(vm, "E2BIG"_s), jsNumber(E2BIG));
+    put(Identifier::fromString(vm, "E2BIG"_s), jsNumber(E2BIG));
 #endif
 #ifdef EACCES
-  put(Identifier::fromString(vm, "EACCES"_s), jsNumber(EACCES));
+    put(Identifier::fromString(vm, "EACCES"_s), jsNumber(EACCES));
 #endif
 #ifdef EADDRINUSE
-  put(Identifier::fromString(vm, "EADDRINUSE"_s), jsNumber(EADDRINUSE));
+    put(Identifier::fromString(vm, "EADDRINUSE"_s), jsNumber(EADDRINUSE));
 #endif
 #ifdef EADDRNOTAVAIL
-  put(Identifier::fromString(vm, "EADDRNOTAVAIL"_s), jsNumber(EADDRNOTAVAIL));
+    put(Identifier::fromString(vm, "EADDRNOTAVAIL"_s), jsNumber(EADDRNOTAVAIL));
 #endif
 #ifdef EAFNOSUPPORT
-  put(Identifier::fromString(vm, "EAFNOSUPPORT"_s), jsNumber(EAFNOSUPPORT));
+    put(Identifier::fromString(vm, "EAFNOSUPPORT"_s), jsNumber(EAFNOSUPPORT));
 #endif
 #ifdef EAGAIN
-  put(Identifier::fromString(vm, "EAGAIN"_s), jsNumber(EAGAIN));
+    put(Identifier::fromString(vm, "EAGAIN"_s), jsNumber(EAGAIN));
 #endif
 #ifdef EALREADY
-  put(Identifier::fromString(vm, "EALREADY"_s), jsNumber(EALREADY));
+    put(Identifier::fromString(vm, "EALREADY"_s), jsNumber(EALREADY));
 #endif
 #ifdef EBADF
-  put(Identifier::fromString(vm, "EBADF"_s), jsNumber(EBADF));
+    put(Identifier::fromString(vm, "EBADF"_s), jsNumber(EBADF));
 #endif
 #ifdef EBADMSG
-  put(Identifier::fromString(vm, "EBADMSG"_s), jsNumber(EBADMSG));
+    put(Identifier::fromString(vm, "EBADMSG"_s), jsNumber(EBADMSG));
 #endif
 #ifdef EBUSY
-  put(Identifier::fromString(vm, "EBUSY"_s), jsNumber(EBUSY));
+    put(Identifier::fromString(vm, "EBUSY"_s), jsNumber(EBUSY));
 #endif
 #ifdef ECANCELED
-  put(Identifier::fromString(vm, "ECANCELED"_s), jsNumber(ECANCELED));
+    put(Identifier::fromString(vm, "ECANCELED"_s), jsNumber(ECANCELED));
 #endif
 #ifdef ECHILD
-  put(Identifier::fromString(vm, "ECHILD"_s), jsNumber(ECHILD));
+    put(Identifier::fromString(vm, "ECHILD"_s), jsNumber(ECHILD));
 #endif
 #ifdef ECONNABORTED
-  put(Identifier::fromString(vm, "ECONNABORTED"_s), jsNumber(ECONNABORTED));
+    put(Identifier::fromString(vm, "ECONNABORTED"_s), jsNumber(ECONNABORTED));
 #endif
 #ifdef ECONNREFUSED
-  put(Identifier::fromString(vm, "ECONNREFUSED"_s), jsNumber(ECONNREFUSED));
+    put(Identifier::fromString(vm, "ECONNREFUSED"_s), jsNumber(ECONNREFUSED));
 #endif
 #ifdef ECONNRESET
-  put(Identifier::fromString(vm, "ECONNRESET"_s), jsNumber(ECONNRESET));
+    put(Identifier::fromString(vm, "ECONNRESET"_s), jsNumber(ECONNRESET));
 #endif
 #ifdef EDEADLK
-  put(Identifier::fromString(vm, "EDEADLK"_s), jsNumber(EDEADLK));
+    put(Identifier::fromString(vm, "EDEADLK"_s), jsNumber(EDEADLK));
 #endif
 #ifdef EDESTADDRREQ
-  put(Identifier::fromString(vm, "EDESTADDRREQ"_s), jsNumber(EDESTADDRREQ));
+    put(Identifier::fromString(vm, "EDESTADDRREQ"_s), jsNumber(EDESTADDRREQ));
 #endif
 #ifdef EDOM
-  put(Identifier::fromString(vm, "EDOM"_s), jsNumber(EDOM));
+    put(Identifier::fromString(vm, "EDOM"_s), jsNumber(EDOM));
 #endif
 #ifdef EDQUOT
-  put(Identifier::fromString(vm, "EDQUOT"_s), jsNumber(EDQUOT));
+    put(Identifier::fromString(vm, "EDQUOT"_s), jsNumber(EDQUOT));
 #endif
 #ifdef EEXIST
-  put(Identifier::fromString(vm, "EEXIST"_s), jsNumber(EEXIST));
+    put(Identifier::fromString(vm, "EEXIST"_s), jsNumber(EEXIST));
 #endif
 #ifdef EFAULT
-  put(Identifier::fromString(vm, "EFAULT"_s), jsNumber(EFAULT));
+    put(Identifier::fromString(vm, "EFAULT"_s), jsNumber(EFAULT));
 #endif
 #ifdef EFBIG
-  put(Identifier::fromString(vm, "EFBIG"_s), jsNumber(EFBIG));
+    put(Identifier::fromString(vm, "EFBIG"_s), jsNumber(EFBIG));
 #endif
 #ifdef EHOSTUNREACH
-  put(Identifier::fromString(vm, "EHOSTUNREACH"_s), jsNumber(EHOSTUNREACH));
+    put(Identifier::fromString(vm, "EHOSTUNREACH"_s), jsNumber(EHOSTUNREACH));
 #endif
 #ifdef EIDRM
-  put(Identifier::fromString(vm, "EIDRM"_s), jsNumber(EIDRM));
+    put(Identifier::fromString(vm, "EIDRM"_s), jsNumber(EIDRM));
 #endif
 #ifdef EILSEQ
-  put(Identifier::fromString(vm, "EILSEQ"_s), jsNumber(EILSEQ));
+    put(Identifier::fromString(vm, "EILSEQ"_s), jsNumber(EILSEQ));
 #endif
 #ifdef EINPROGRESS
-  put(Identifier::fromString(vm, "EINPROGRESS"_s), jsNumber(EINPROGRESS));
+    put(Identifier::fromString(vm, "EINPROGRESS"_s), jsNumber(EINPROGRESS));
 #endif
 #ifdef EINTR
-  put(Identifier::fromString(vm, "EINTR"_s), jsNumber(EINTR));
+    put(Identifier::fromString(vm, "EINTR"_s), jsNumber(EINTR));
 #endif
 #ifdef EINVAL
-  put(Identifier::fromString(vm, "EINVAL"_s), jsNumber(EINVAL));
+    put(Identifier::fromString(vm, "EINVAL"_s), jsNumber(EINVAL));
 #endif
 #ifdef EIO
-  put(Identifier::fromString(vm, "EIO"_s), jsNumber(EIO));
+    put(Identifier::fromString(vm, "EIO"_s), jsNumber(EIO));
 #endif
 #ifdef EISCONN
-  put(Identifier::fromString(vm, "EISCONN"_s), jsNumber(EISCONN));
+    put(Identifier::fromString(vm, "EISCONN"_s), jsNumber(EISCONN));
 #endif
 #ifdef EISDIR
-  put(Identifier::fromString(vm, "EISDIR"_s), jsNumber(EISDIR));
+    put(Identifier::fromString(vm, "EISDIR"_s), jsNumber(EISDIR));
 #endif
 #ifdef ELOOP
-  put(Identifier::fromString(vm, "ELOOP"_s), jsNumber(ELOOP));
+    put(Identifier::fromString(vm, "ELOOP"_s), jsNumber(ELOOP));
 #endif
 #ifdef EMFILE
-  put(Identifier::fromString(vm, "EMFILE"_s), jsNumber(EMFILE));
+    put(Identifier::fromString(vm, "EMFILE"_s), jsNumber(EMFILE));
 #endif
 #ifdef EMLINK
-  put(Identifier::fromString(vm, "EMLINK"_s), jsNumber(EMLINK));
+    put(Identifier::fromString(vm, "EMLINK"_s), jsNumber(EMLINK));
 #endif
 #ifdef EMSGSIZE
-  put(Identifier::fromString(vm, "EMSGSIZE"_s), jsNumber(EMSGSIZE));
+    put(Identifier::fromString(vm, "EMSGSIZE"_s), jsNumber(EMSGSIZE));
 #endif
 #ifdef EMULTIHOP
-  put(Identifier::fromString(vm, "EMULTIHOP"_s), jsNumber(EMULTIHOP));
+    put(Identifier::fromString(vm, "EMULTIHOP"_s), jsNumber(EMULTIHOP));
 #endif
 #ifdef ENAMETOOLONG
-  put(Identifier::fromString(vm, "ENAMETOOLONG"_s), jsNumber(ENAMETOOLONG));
+    put(Identifier::fromString(vm, "ENAMETOOLONG"_s), jsNumber(ENAMETOOLONG));
 #endif
 #ifdef ENETDOWN
-  put(Identifier::fromString(vm, "ENETDOWN"_s), jsNumber(ENETDOWN));
+    put(Identifier::fromString(vm, "ENETDOWN"_s), jsNumber(ENETDOWN));
 #endif
 #ifdef ENETRESET
-  put(Identifier::fromString(vm, "ENETRESET"_s), jsNumber(ENETRESET));
+    put(Identifier::fromString(vm, "ENETRESET"_s), jsNumber(ENETRESET));
 #endif
 #ifdef ENETUNREACH
-  put(Identifier::fromString(vm, "ENETUNREACH"_s), jsNumber(ENETUNREACH));
+    put(Identifier::fromString(vm, "ENETUNREACH"_s), jsNumber(ENETUNREACH));
 #endif
 #ifdef ENFILE
-  put(Identifier::fromString(vm, "ENFILE"_s), jsNumber(ENFILE));
+    put(Identifier::fromString(vm, "ENFILE"_s), jsNumber(ENFILE));
 #endif
 #ifdef ENOBUFS
-  put(Identifier::fromString(vm, "ENOBUFS"_s), jsNumber(ENOBUFS));
+    put(Identifier::fromString(vm, "ENOBUFS"_s), jsNumber(ENOBUFS));
 #endif
 #ifdef ENODATA
-  put(Identifier::fromString(vm, "ENODATA"_s), jsNumber(ENODATA));
+    put(Identifier::fromString(vm, "ENODATA"_s), jsNumber(ENODATA));
 #endif
 #ifdef ENODEV
-  put(Identifier::fromString(vm, "ENODEV"_s), jsNumber(ENODEV));
+    put(Identifier::fromString(vm, "ENODEV"_s), jsNumber(ENODEV));
 #endif
 #ifdef ENOENT
-  put(Identifier::fromString(vm, "ENOENT"_s), jsNumber(ENOENT));
+    put(Identifier::fromString(vm, "ENOENT"_s), jsNumber(ENOENT));
 #endif
 #ifdef ENOEXEC
-  put(Identifier::fromString(vm, "ENOEXEC"_s), jsNumber(ENOEXEC));
+    put(Identifier::fromString(vm, "ENOEXEC"_s), jsNumber(ENOEXEC));
 #endif
 #ifdef ENOLCK
-  put(Identifier::fromString(vm, "ENOLCK"_s), jsNumber(ENOLCK));
+    put(Identifier::fromString(vm, "ENOLCK"_s), jsNumber(ENOLCK));
 #endif
 #ifdef ENOLINK
-  put(Identifier::fromString(vm, "ENOLINK"_s), jsNumber(ENOLINK));
+    put(Identifier::fromString(vm, "ENOLINK"_s), jsNumber(ENOLINK));
 #endif
 #ifdef ENOMEM
-  put(Identifier::fromString(vm, "ENOMEM"_s), jsNumber(ENOMEM));
+    put(Identifier::fromString(vm, "ENOMEM"_s), jsNumber(ENOMEM));
 #endif
 #ifdef ENOMSG
-  put(Identifier::fromString(vm, "ENOMSG"_s), jsNumber(ENOMSG));
+    put(Identifier::fromString(vm, "ENOMSG"_s), jsNumber(ENOMSG));
 #endif
 #ifdef ENOPROTOOPT
-  put(Identifier::fromString(vm, "ENOPROTOOPT"_s), jsNumber(ENOPROTOOPT));
+    put(Identifier::fromString(vm, "ENOPROTOOPT"_s), jsNumber(ENOPROTOOPT));
 #endif
 #ifdef ENOSPC
-  put(Identifier::fromString(vm, "ENOSPC"_s), jsNumber(ENOSPC));
+    put(Identifier::fromString(vm, "ENOSPC"_s), jsNumber(ENOSPC));
 #endif
 #ifdef ENOSR
-  put(Identifier::fromString(vm, "ENOSR"_s), jsNumber(ENOSR));
+    put(Identifier::fromString(vm, "ENOSR"_s), jsNumber(ENOSR));
 #endif
 #ifdef ENOSTR
-  put(Identifier::fromString(vm, "ENOSTR"_s), jsNumber(ENOSTR));
+    put(Identifier::fromString(vm, "ENOSTR"_s), jsNumber(ENOSTR));
 #endif
 #ifdef ENOSYS
-  put(Identifier::fromString(vm, "ENOSYS"_s), jsNumber(ENOSYS));
+    put(Identifier::fromString(vm, "ENOSYS"_s), jsNumber(ENOSYS));
 #endif
 #ifdef ENOTCONN
-  put(Identifier::fromString(vm, "ENOTCONN"_s), jsNumber(ENOTCONN));
+    put(Identifier::fromString(vm, "ENOTCONN"_s), jsNumber(ENOTCONN));
 #endif
 #ifdef ENOTDIR
-  put(Identifier::fromString(vm, "ENOTDIR"_s), jsNumber(ENOTDIR));
+    put(Identifier::fromString(vm, "ENOTDIR"_s), jsNumber(ENOTDIR));
 #endif
 #ifdef ENOTEMPTY
-  put(Identifier::fromString(vm, "ENOTEMPTY"_s), jsNumber(ENOTEMPTY));
+    put(Identifier::fromString(vm, "ENOTEMPTY"_s), jsNumber(ENOTEMPTY));
 #endif
 #ifdef ENOTSOCK
-  put(Identifier::fromString(vm, "ENOTSOCK"_s), jsNumber(ENOTSOCK));
+    put(Identifier::fromString(vm, "ENOTSOCK"_s), jsNumber(ENOTSOCK));
 #endif
 #ifdef ENOTSUP
-  put(Identifier::fromString(vm, "ENOTSUP"_s), jsNumber(ENOTSUP));
+    put(Identifier::fromString(vm, "ENOTSUP"_s), jsNumber(ENOTSUP));
 #endif
 #ifdef ENOTTY
-  put(Identifier::fromString(vm, "ENOTTY"_s), jsNumber(ENOTTY));
+    put(Identifier::fromString(vm, "ENOTTY"_s), jsNumber(ENOTTY));
 #endif
 #ifdef ENXIO
-  put(Identifier::fromString(vm, "ENXIO"_s), jsNumber(ENXIO));
+    put(Identifier::fromString(vm, "ENXIO"_s), jsNumber(ENXIO));
 #endif
 #ifdef EOPNOTSUPP
-  put(Identifier::fromString(vm, "EOPNOTSUPP"_s), jsNumber(EOPNOTSUPP));
+    put(Identifier::fromString(vm, "EOPNOTSUPP"_s), jsNumber(EOPNOTSUPP));
 #endif
 #ifdef EOVERFLOW
-  put(Identifier::fromString(vm, "EOVERFLOW"_s), jsNumber(EOVERFLOW));
+    put(Identifier::fromString(vm, "EOVERFLOW"_s), jsNumber(EOVERFLOW));
 #endif
 #ifdef EPERM
-  put(Identifier::fromString(vm, "EPERM"_s), jsNumber(EPERM));
+    put(Identifier::fromString(vm, "EPERM"_s), jsNumber(EPERM));
 #endif
 #ifdef EPIPE
-  put(Identifier::fromString(vm, "EPIPE"_s), jsNumber(EPIPE));
+    put(Identifier::fromString(vm, "EPIPE"_s), jsNumber(EPIPE));
 #endif
 #ifdef EPROTO
-  put(Identifier::fromString(vm, "EPROTO"_s), jsNumber(EPROTO));
+    put(Identifier::fromString(vm, "EPROTO"_s), jsNumber(EPROTO));
 #endif
 #ifdef EPROTONOSUPPORT
-  put(Identifier::fromString(vm, "EPROTONOSUPPORT"_s),
-      jsNumber(EPROTONOSUPPORT));
+    put(Identifier::fromString(vm, "EPROTONOSUPPORT"_s),
+        jsNumber(EPROTONOSUPPORT));
 #endif
 #ifdef EPROTOTYPE
-  put(Identifier::fromString(vm, "EPROTOTYPE"_s), jsNumber(EPROTOTYPE));
+    put(Identifier::fromString(vm, "EPROTOTYPE"_s), jsNumber(EPROTOTYPE));
 #endif
 #ifdef ERANGE
-  put(Identifier::fromString(vm, "ERANGE"_s), jsNumber(ERANGE));
+    put(Identifier::fromString(vm, "ERANGE"_s), jsNumber(ERANGE));
 #endif
 #ifdef EROFS
-  put(Identifier::fromString(vm, "EROFS"_s), jsNumber(EROFS));
+    put(Identifier::fromString(vm, "EROFS"_s), jsNumber(EROFS));
 #endif
 #ifdef ESPIPE
-  put(Identifier::fromString(vm, "ESPIPE"_s), jsNumber(ESPIPE));
+    put(Identifier::fromString(vm, "ESPIPE"_s), jsNumber(ESPIPE));
 #endif
 #ifdef ESRCH
-  put(Identifier::fromString(vm, "ESRCH"_s), jsNumber(ESRCH));
+    put(Identifier::fromString(vm, "ESRCH"_s), jsNumber(ESRCH));
 #endif
 #ifdef ESTALE
-  put(Identifier::fromString(vm, "ESTALE"_s), jsNumber(ESTALE));
+    put(Identifier::fromString(vm, "ESTALE"_s), jsNumber(ESTALE));
 #endif
 #ifdef ETIME
-  put(Identifier::fromString(vm, "ETIME"_s), jsNumber(ETIME));
+    put(Identifier::fromString(vm, "ETIME"_s), jsNumber(ETIME));
 #endif
 #ifdef ETIMEDOUT
-  put(Identifier::fromString(vm, "ETIMEDOUT"_s), jsNumber(ETIMEDOUT));
+    put(Identifier::fromString(vm, "ETIMEDOUT"_s), jsNumber(ETIMEDOUT));
 #endif
 #ifdef ETXTBSY
-  put(Identifier::fromString(vm, "ETXTBSY"_s), jsNumber(ETXTBSY));
+    put(Identifier::fromString(vm, "ETXTBSY"_s), jsNumber(ETXTBSY));
 #endif
 #ifdef EWOULDBLOCK
-  put(Identifier::fromString(vm, "EWOULDBLOCK"_s), jsNumber(EWOULDBLOCK));
+    put(Identifier::fromString(vm, "EWOULDBLOCK"_s), jsNumber(EWOULDBLOCK));
 #endif
 #ifdef EXDEV
-  put(Identifier::fromString(vm, "EXDEV"_s), jsNumber(EXDEV));
+    put(Identifier::fromString(vm, "EXDEV"_s), jsNumber(EXDEV));
 #endif
 #ifdef WSAEINTR
-  put(Identifier::fromString(vm, "WSAEINTR"_s), jsNumber(WSAEINTR));
+    put(Identifier::fromString(vm, "WSAEINTR"_s), jsNumber(WSAEINTR));
 #endif
 #ifdef WSAEBADF
-  put(Identifier::fromString(vm, "WSAEBADF"_s), jsNumber(WSAEBADF));
+    put(Identifier::fromString(vm, "WSAEBADF"_s), jsNumber(WSAEBADF));
 #endif
 #ifdef WSAEACCES
-  put(Identifier::fromString(vm, "WSAEACCES"_s), jsNumber(WSAEACCES));
+    put(Identifier::fromString(vm, "WSAEACCES"_s), jsNumber(WSAEACCES));
 #endif
 #ifdef WSAEFAULT
-  put(Identifier::fromString(vm, "WSAEFAULT"_s), jsNumber(WSAEFAULT));
+    put(Identifier::fromString(vm, "WSAEFAULT"_s), jsNumber(WSAEFAULT));
 #endif
 #ifdef WSAEINVAL
-  put(Identifier::fromString(vm, "WSAEINVAL"_s), jsNumber(WSAEINVAL));
+    put(Identifier::fromString(vm, "WSAEINVAL"_s), jsNumber(WSAEINVAL));
 #endif
 #ifdef WSAEMFILE
-  put(Identifier::fromString(vm, "WSAEMFILE"_s), jsNumber(WSAEMFILE));
+    put(Identifier::fromString(vm, "WSAEMFILE"_s), jsNumber(WSAEMFILE));
 #endif
 #ifdef WSAEWOULDBLOCK
-  put(Identifier::fromString(vm, "WSAEWOULDBLOCK"_s), jsNumber(WSAEWOULDBLOCK));
+    put(Identifier::fromString(vm, "WSAEWOULDBLOCK"_s), jsNumber(WSAEWOULDBLOCK));
 #endif
 #ifdef WSAEINPROGRESS
-  put(Identifier::fromString(vm, "WSAEINPROGRESS"_s), jsNumber(WSAEINPROGRESS));
+    put(Identifier::fromString(vm, "WSAEINPROGRESS"_s), jsNumber(WSAEINPROGRESS));
 #endif
 #ifdef WSAEALREADY
-  put(Identifier::fromString(vm, "WSAEALREADY"_s), jsNumber(WSAEALREADY));
+    put(Identifier::fromString(vm, "WSAEALREADY"_s), jsNumber(WSAEALREADY));
 #endif
 #ifdef WSAENOTSOCK
-  put(Identifier::fromString(vm, "WSAENOTSOCK"_s), jsNumber(WSAENOTSOCK));
+    put(Identifier::fromString(vm, "WSAENOTSOCK"_s), jsNumber(WSAENOTSOCK));
 #endif
 #ifdef WSAEDESTADDRREQ
-  put(Identifier::fromString(vm, "WSAEDESTADDRREQ"_s),
-      jsNumber(WSAEDESTADDRREQ));
+    put(Identifier::fromString(vm, "WSAEDESTADDRREQ"_s),
+        jsNumber(WSAEDESTADDRREQ));
 #endif
 #ifdef WSAEMSGSIZE
-  put(Identifier::fromString(vm, "WSAEMSGSIZE"_s), jsNumber(WSAEMSGSIZE));
+    put(Identifier::fromString(vm, "WSAEMSGSIZE"_s), jsNumber(WSAEMSGSIZE));
 #endif
 #ifdef WSAEPROTOTYPE
-  put(Identifier::fromString(vm, "WSAEPROTOTYPE"_s), jsNumber(WSAEPROTOTYPE));
+    put(Identifier::fromString(vm, "WSAEPROTOTYPE"_s), jsNumber(WSAEPROTOTYPE));
 #endif
 #ifdef WSAENOPROTOOPT
-  put(Identifier::fromString(vm, "WSAENOPROTOOPT"_s), jsNumber(WSAENOPROTOOPT));
+    put(Identifier::fromString(vm, "WSAENOPROTOOPT"_s), jsNumber(WSAENOPROTOOPT));
 #endif
 #ifdef WSAEPROTONOSUPPORT
-  put(Identifier::fromString(vm, "WSAEPROTONOSUPPORT"_s),
-      jsNumber(WSAEPROTONOSUPPORT));
+    put(Identifier::fromString(vm, "WSAEPROTONOSUPPORT"_s),
+        jsNumber(WSAEPROTONOSUPPORT));
 #endif
 #ifdef WSAESOCKTNOSUPPORT
-  put(Identifier::fromString(vm, "WSAESOCKTNOSUPPORT"_s),
-      jsNumber(WSAESOCKTNOSUPPORT));
+    put(Identifier::fromString(vm, "WSAESOCKTNOSUPPORT"_s),
+        jsNumber(WSAESOCKTNOSUPPORT));
 #endif
 #ifdef WSAEOPNOTSUPP
-  put(Identifier::fromString(vm, "WSAEOPNOTSUPP"_s), jsNumber(WSAEOPNOTSUPP));
+    put(Identifier::fromString(vm, "WSAEOPNOTSUPP"_s), jsNumber(WSAEOPNOTSUPP));
 #endif
 #ifdef WSAEPFNOSUPPORT
-  put(Identifier::fromString(vm, "WSAEPFNOSUPPORT"_s),
-      jsNumber(WSAEPFNOSUPPORT));
+    put(Identifier::fromString(vm, "WSAEPFNOSUPPORT"_s),
+        jsNumber(WSAEPFNOSUPPORT));
 #endif
 #ifdef WSAEAFNOSUPPORT
-  put(Identifier::fromString(vm, "WSAEAFNOSUPPORT"_s),
-      jsNumber(WSAEAFNOSUPPORT));
+    put(Identifier::fromString(vm, "WSAEAFNOSUPPORT"_s),
+        jsNumber(WSAEAFNOSUPPORT));
 #endif
 #ifdef WSAEADDRINUSE
-  put(Identifier::fromString(vm, "WSAEADDRINUSE"_s), jsNumber(WSAEADDRINUSE));
+    put(Identifier::fromString(vm, "WSAEADDRINUSE"_s), jsNumber(WSAEADDRINUSE));
 #endif
 #ifdef WSAEADDRNOTAVAIL
-  put(Identifier::fromString(vm, "WSAEADDRNOTAVAIL"_s),
-      jsNumber(WSAEADDRNOTAVAIL));
+    put(Identifier::fromString(vm, "WSAEADDRNOTAVAIL"_s),
+        jsNumber(WSAEADDRNOTAVAIL));
 #endif
 #ifdef WSAENETDOWN
-  put(Identifier::fromString(vm, "WSAENETDOWN"_s), jsNumber(WSAENETDOWN));
+    put(Identifier::fromString(vm, "WSAENETDOWN"_s), jsNumber(WSAENETDOWN));
 #endif
 #ifdef WSAENETUNREACH
-  put(Identifier::fromString(vm, "WSAENETUNREACH"_s), jsNumber(WSAENETUNREACH));
+    put(Identifier::fromString(vm, "WSAENETUNREACH"_s), jsNumber(WSAENETUNREACH));
 #endif
 #ifdef WSAENETRESET
-  put(Identifier::fromString(vm, "WSAENETRESET"_s), jsNumber(WSAENETRESET));
+    put(Identifier::fromString(vm, "WSAENETRESET"_s), jsNumber(WSAENETRESET));
 #endif
 #ifdef WSAECONNABORTED
-  put(Identifier::fromString(vm, "WSAECONNABORTED"_s),
-      jsNumber(WSAECONNABORTED));
+    put(Identifier::fromString(vm, "WSAECONNABORTED"_s),
+        jsNumber(WSAECONNABORTED));
 #endif
 #ifdef WSAECONNRESET
-  put(Identifier::fromString(vm, "WSAECONNRESET"_s), jsNumber(WSAECONNRESET));
+    put(Identifier::fromString(vm, "WSAECONNRESET"_s), jsNumber(WSAECONNRESET));
 #endif
 #ifdef WSAENOBUFS
-  put(Identifier::fromString(vm, "WSAENOBUFS"_s), jsNumber(WSAENOBUFS));
+    put(Identifier::fromString(vm, "WSAENOBUFS"_s), jsNumber(WSAENOBUFS));
 #endif
 #ifdef WSAEISCONN
-  put(Identifier::fromString(vm, "WSAEISCONN"_s), jsNumber(WSAEISCONN));
+    put(Identifier::fromString(vm, "WSAEISCONN"_s), jsNumber(WSAEISCONN));
 #endif
 #ifdef WSAENOTCONN
-  put(Identifier::fromString(vm, "WSAENOTCONN"_s), jsNumber(WSAENOTCONN));
+    put(Identifier::fromString(vm, "WSAENOTCONN"_s), jsNumber(WSAENOTCONN));
 #endif
 #ifdef WSAESHUTDOWN
-  put(Identifier::fromString(vm, "WSAESHUTDOWN"_s), jsNumber(WSAESHUTDOWN));
+    put(Identifier::fromString(vm, "WSAESHUTDOWN"_s), jsNumber(WSAESHUTDOWN));
 #endif
 #ifdef WSAETOOMANYREFS
-  put(Identifier::fromString(vm, "WSAETOOMANYREFS"_s),
-      jsNumber(WSAETOOMANYREFS));
+    put(Identifier::fromString(vm, "WSAETOOMANYREFS"_s),
+        jsNumber(WSAETOOMANYREFS));
 #endif
 #ifdef WSAETIMEDOUT
-  put(Identifier::fromString(vm, "WSAETIMEDOUT"_s), jsNumber(WSAETIMEDOUT));
+    put(Identifier::fromString(vm, "WSAETIMEDOUT"_s), jsNumber(WSAETIMEDOUT));
 #endif
 #ifdef WSAECONNREFUSED
-  put(Identifier::fromString(vm, "WSAECONNREFUSED"_s),
-      jsNumber(WSAECONNREFUSED));
+    put(Identifier::fromString(vm, "WSAECONNREFUSED"_s),
+        jsNumber(WSAECONNREFUSED));
 #endif
 #ifdef WSAELOOP
-  put(Identifier::fromString(vm, "WSAELOOP"_s), jsNumber(WSAELOOP));
+    put(Identifier::fromString(vm, "WSAELOOP"_s), jsNumber(WSAELOOP));
 #endif
 #ifdef WSAENAMETOOLONG
-  put(Identifier::fromString(vm, "WSAENAMETOOLONG"_s),
-      jsNumber(WSAENAMETOOLONG));
+    put(Identifier::fromString(vm, "WSAENAMETOOLONG"_s),
+        jsNumber(WSAENAMETOOLONG));
 #endif
 #ifdef WSAEHOSTDOWN
-  put(Identifier::fromString(vm, "WSAEHOSTDOWN"_s), jsNumber(WSAEHOSTDOWN));
+    put(Identifier::fromString(vm, "WSAEHOSTDOWN"_s), jsNumber(WSAEHOSTDOWN));
 #endif
 #ifdef WSAEHOSTUNREACH
-  put(Identifier::fromString(vm, "WSAEHOSTUNREACH"_s),
-      jsNumber(WSAEHOSTUNREACH));
+    put(Identifier::fromString(vm, "WSAEHOSTUNREACH"_s),
+        jsNumber(WSAEHOSTUNREACH));
 #endif
 #ifdef WSAENOTEMPTY
-  put(Identifier::fromString(vm, "WSAENOTEMPTY"_s), jsNumber(WSAENOTEMPTY));
+    put(Identifier::fromString(vm, "WSAENOTEMPTY"_s), jsNumber(WSAENOTEMPTY));
 #endif
 #ifdef WSAEPROCLIM
-  put(Identifier::fromString(vm, "WSAEPROCLIM"_s), jsNumber(WSAEPROCLIM));
+    put(Identifier::fromString(vm, "WSAEPROCLIM"_s), jsNumber(WSAEPROCLIM));
 #endif
 #ifdef WSAEUSERS
-  put(Identifier::fromString(vm, "WSAEUSERS"_s), jsNumber(WSAEUSERS));
+    put(Identifier::fromString(vm, "WSAEUSERS"_s), jsNumber(WSAEUSERS));
 #endif
 #ifdef WSAEDQUOT
-  put(Identifier::fromString(vm, "WSAEDQUOT"_s), jsNumber(WSAEDQUOT));
+    put(Identifier::fromString(vm, "WSAEDQUOT"_s), jsNumber(WSAEDQUOT));
 #endif
 #ifdef WSAESTALE
-  put(Identifier::fromString(vm, "WSAESTALE"_s), jsNumber(WSAESTALE));
+    put(Identifier::fromString(vm, "WSAESTALE"_s), jsNumber(WSAESTALE));
 #endif
 #ifdef WSAEREMOTE
-  put(Identifier::fromString(vm, "WSAEREMOTE"_s), jsNumber(WSAEREMOTE));
+    put(Identifier::fromString(vm, "WSAEREMOTE"_s), jsNumber(WSAEREMOTE));
 #endif
 #ifdef WSASYSNOTREADY
-  put(Identifier::fromString(vm, "WSASYSNOTREADY"_s), jsNumber(WSASYSNOTREADY));
+    put(Identifier::fromString(vm, "WSASYSNOTREADY"_s), jsNumber(WSASYSNOTREADY));
 #endif
 #ifdef WSAVERNOTSUPPORTED
-  put(Identifier::fromString(vm, "WSAVERNOTSUPPORTED"_s),
-      jsNumber(WSAVERNOTSUPPORTED));
+    put(Identifier::fromString(vm, "WSAVERNOTSUPPORTED"_s),
+        jsNumber(WSAVERNOTSUPPORTED));
 #endif
 #ifdef WSANOTINITIALISED
-  put(Identifier::fromString(vm, "WSANOTINITIALISED"_s),
-      jsNumber(WSANOTINITIALISED));
+    put(Identifier::fromString(vm, "WSANOTINITIALISED"_s),
+        jsNumber(WSANOTINITIALISED));
 #endif
 #ifdef WSAEDISCON
-  put(Identifier::fromString(vm, "WSAEDISCON"_s), jsNumber(WSAEDISCON));
+    put(Identifier::fromString(vm, "WSAEDISCON"_s), jsNumber(WSAEDISCON));
 #endif
 #ifdef WSAENOMORE
-  put(Identifier::fromString(vm, "WSAENOMORE"_s), jsNumber(WSAENOMORE));
+    put(Identifier::fromString(vm, "WSAENOMORE"_s), jsNumber(WSAENOMORE));
 #endif
 #ifdef WSAECANCELLED
-  put(Identifier::fromString(vm, "WSAECANCELLED"_s), jsNumber(WSAECANCELLED));
+    put(Identifier::fromString(vm, "WSAECANCELLED"_s), jsNumber(WSAECANCELLED));
 #endif
 #ifdef WSAEINVALIDPROCTABLE
-  put(Identifier::fromString(vm, "WSAEINVALIDPROCTABLE"_s),
-      jsNumber(WSAEINVALIDPROCTABLE));
+    put(Identifier::fromString(vm, "WSAEINVALIDPROCTABLE"_s),
+        jsNumber(WSAEINVALIDPROCTABLE));
 #endif
 #ifdef WSAEINVALIDPROVIDER
-  put(Identifier::fromString(vm, "WSAEINVALIDPROVIDER"_s),
-      jsNumber(WSAEINVALIDPROVIDER));
+    put(Identifier::fromString(vm, "WSAEINVALIDPROVIDER"_s),
+        jsNumber(WSAEINVALIDPROVIDER));
 #endif
 #ifdef WSAEPROVIDERFAILEDINIT
-  put(Identifier::fromString(vm, "WSAEPROVIDERFAILEDINIT"_s),
-      jsNumber(WSAEPROVIDERFAILEDINIT));
+    put(Identifier::fromString(vm, "WSAEPROVIDERFAILEDINIT"_s),
+        jsNumber(WSAEPROVIDERFAILEDINIT));
 #endif
 #ifdef WSASYSCALLFAILURE
-  put(Identifier::fromString(vm, "WSASYSCALLFAILURE"_s),
-      jsNumber(WSASYSCALLFAILURE));
+    put(Identifier::fromString(vm, "WSASYSCALLFAILURE"_s),
+        jsNumber(WSASYSCALLFAILURE));
 #endif
 #ifdef WSASERVICE_NOT_FOUND
-  put(Identifier::fromString(vm, "WSASERVICE_NOT_FOUND"_s),
-      jsNumber(WSASERVICE_NOT_FOUND));
+    put(Identifier::fromString(vm, "WSASERVICE_NOT_FOUND"_s),
+        jsNumber(WSASERVICE_NOT_FOUND));
 #endif
 #ifdef WSATYPE_NOT_FOUND
-  put(Identifier::fromString(vm, "WSATYPE_NOT_FOUND"_s),
-      jsNumber(WSATYPE_NOT_FOUND));
+    put(Identifier::fromString(vm, "WSATYPE_NOT_FOUND"_s),
+        jsNumber(WSATYPE_NOT_FOUND));
 #endif
 #ifdef WSA_E_NO_MORE
-  put(Identifier::fromString(vm, "WSA_E_NO_MORE"_s), jsNumber(WSA_E_NO_MORE));
+    put(Identifier::fromString(vm, "WSA_E_NO_MORE"_s), jsNumber(WSA_E_NO_MORE));
 #endif
 #ifdef WSA_E_CANCELLED
-  put(Identifier::fromString(vm, "WSA_E_CANCELLED"_s),
-      jsNumber(WSA_E_CANCELLED));
+    put(Identifier::fromString(vm, "WSA_E_CANCELLED"_s),
+        jsNumber(WSA_E_CANCELLED));
 #endif
 #ifdef WSAEREFUSED
-  put(Identifier::fromString(vm, "WSAEREFUSED"_s), jsNumber(WSAEREFUSED));
+    put(Identifier::fromString(vm, "WSAEREFUSED"_s), jsNumber(WSAEREFUSED));
 #endif
-  put(Identifier::fromString(vm, "PRIORITY_LOW"_s), jsNumber(19));
-  put(Identifier::fromString(vm, "PRIORITY_BELOW_NORMAL"_s), jsNumber(10));
-  put(Identifier::fromString(vm, "PRIORITY_NORMAL"_s), jsNumber(0));
-  put(Identifier::fromString(vm, "PRIORITY_ABOVE_NORMAL"_s), jsNumber(-7));
-  put(Identifier::fromString(vm, "PRIORITY_HIGH"_s), jsNumber(-14));
-  put(Identifier::fromString(vm, "PRIORITY_HIGHEST"_s), jsNumber(-20));
+    put(Identifier::fromString(vm, "PRIORITY_LOW"_s), jsNumber(19));
+    put(Identifier::fromString(vm, "PRIORITY_BELOW_NORMAL"_s), jsNumber(10));
+    put(Identifier::fromString(vm, "PRIORITY_NORMAL"_s), jsNumber(0));
+    put(Identifier::fromString(vm, "PRIORITY_ABOVE_NORMAL"_s), jsNumber(-7));
+    put(Identifier::fromString(vm, "PRIORITY_HIGH"_s), jsNumber(-14));
+    put(Identifier::fromString(vm, "PRIORITY_HIGHEST"_s), jsNumber(-20));
 #ifdef SIGHUP
-  put(Identifier::fromString(vm, "SIGHUP"_s), jsNumber(SIGHUP));
+    put(Identifier::fromString(vm, "SIGHUP"_s), jsNumber(SIGHUP));
 #endif
 #ifdef SIGINT
-  put(Identifier::fromString(vm, "SIGINT"_s), jsNumber(SIGINT));
+    put(Identifier::fromString(vm, "SIGINT"_s), jsNumber(SIGINT));
 #endif
 #ifdef SIGQUIT
-  put(Identifier::fromString(vm, "SIGQUIT"_s), jsNumber(SIGQUIT));
+    put(Identifier::fromString(vm, "SIGQUIT"_s), jsNumber(SIGQUIT));
 #endif
 #ifdef SIGILL
-  put(Identifier::fromString(vm, "SIGILL"_s), jsNumber(SIGILL));
+    put(Identifier::fromString(vm, "SIGILL"_s), jsNumber(SIGILL));
 #endif
 #ifdef SIGTRAP
-  put(Identifier::fromString(vm, "SIGTRAP"_s), jsNumber(SIGTRAP));
+    put(Identifier::fromString(vm, "SIGTRAP"_s), jsNumber(SIGTRAP));
 #endif
 #ifdef SIGABRT
-  put(Identifier::fromString(vm, "SIGABRT"_s), jsNumber(SIGABRT));
+    put(Identifier::fromString(vm, "SIGABRT"_s), jsNumber(SIGABRT));
 #endif
 #ifdef SIGIOT
-  put(Identifier::fromString(vm, "SIGIOT"_s), jsNumber(SIGIOT));
+    put(Identifier::fromString(vm, "SIGIOT"_s), jsNumber(SIGIOT));
 #endif
 #ifdef SIGBUS
-  put(Identifier::fromString(vm, "SIGBUS"_s), jsNumber(SIGBUS));
+    put(Identifier::fromString(vm, "SIGBUS"_s), jsNumber(SIGBUS));
 #endif
 #ifdef SIGFPE
-  put(Identifier::fromString(vm, "SIGFPE"_s), jsNumber(SIGFPE));
+    put(Identifier::fromString(vm, "SIGFPE"_s), jsNumber(SIGFPE));
 #endif
 #ifdef SIGKILL
-  put(Identifier::fromString(vm, "SIGKILL"_s), jsNumber(SIGKILL));
+    put(Identifier::fromString(vm, "SIGKILL"_s), jsNumber(SIGKILL));
 #endif
 #ifdef SIGUSR1
-  put(Identifier::fromString(vm, "SIGUSR1"_s), jsNumber(SIGUSR1));
+    put(Identifier::fromString(vm, "SIGUSR1"_s), jsNumber(SIGUSR1));
 #endif
 #ifdef SIGSEGV
-  put(Identifier::fromString(vm, "SIGSEGV"_s), jsNumber(SIGSEGV));
+    put(Identifier::fromString(vm, "SIGSEGV"_s), jsNumber(SIGSEGV));
 #endif
 #ifdef SIGUSR2
-  put(Identifier::fromString(vm, "SIGUSR2"_s), jsNumber(SIGUSR2));
+    put(Identifier::fromString(vm, "SIGUSR2"_s), jsNumber(SIGUSR2));
 #endif
 #ifdef SIGPIPE
-  put(Identifier::fromString(vm, "SIGPIPE"_s), jsNumber(SIGPIPE));
+    put(Identifier::fromString(vm, "SIGPIPE"_s), jsNumber(SIGPIPE));
 #endif
 #ifdef SIGALRM
-  put(Identifier::fromString(vm, "SIGALRM"_s), jsNumber(SIGALRM));
+    put(Identifier::fromString(vm, "SIGALRM"_s), jsNumber(SIGALRM));
 #endif
 #ifdef SIGTERM
-  put(Identifier::fromString(vm, "SIGTERM"_s), jsNumber(SIGTERM));
+    put(Identifier::fromString(vm, "SIGTERM"_s), jsNumber(SIGTERM));
 #endif
 #ifdef SIGCHLD
-  put(Identifier::fromString(vm, "SIGCHLD"_s), jsNumber(SIGCHLD));
+    put(Identifier::fromString(vm, "SIGCHLD"_s), jsNumber(SIGCHLD));
 #endif
 #ifdef SIGSTKFLT
-  put(Identifier::fromString(vm, "SIGSTKFLT"_s), jsNumber(SIGSTKFLT));
+    put(Identifier::fromString(vm, "SIGSTKFLT"_s), jsNumber(SIGSTKFLT));
 #endif
 #ifdef SIGCONT
-  put(Identifier::fromString(vm, "SIGCONT"_s), jsNumber(SIGCONT));
+    put(Identifier::fromString(vm, "SIGCONT"_s), jsNumber(SIGCONT));
 #endif
 #ifdef SIGSTOP
-  put(Identifier::fromString(vm, "SIGSTOP"_s), jsNumber(SIGSTOP));
+    put(Identifier::fromString(vm, "SIGSTOP"_s), jsNumber(SIGSTOP));
 #endif
 #ifdef SIGTSTP
-  put(Identifier::fromString(vm, "SIGTSTP"_s), jsNumber(SIGTSTP));
+    put(Identifier::fromString(vm, "SIGTSTP"_s), jsNumber(SIGTSTP));
 #endif
 #ifdef SIGBREAK
-  put(Identifier::fromString(vm, "SIGBREAK"_s), jsNumber(SIGBREAK));
+    put(Identifier::fromString(vm, "SIGBREAK"_s), jsNumber(SIGBREAK));
 #endif
 #ifdef SIGTTIN
-  put(Identifier::fromString(vm, "SIGTTIN"_s), jsNumber(SIGTTIN));
+    put(Identifier::fromString(vm, "SIGTTIN"_s), jsNumber(SIGTTIN));
 #endif
 #ifdef SIGTTOU
-  put(Identifier::fromString(vm, "SIGTTOU"_s), jsNumber(SIGTTOU));
+    put(Identifier::fromString(vm, "SIGTTOU"_s), jsNumber(SIGTTOU));
 #endif
 #ifdef SIGURG
-  put(Identifier::fromString(vm, "SIGURG"_s), jsNumber(SIGURG));
+    put(Identifier::fromString(vm, "SIGURG"_s), jsNumber(SIGURG));
 #endif
 #ifdef SIGXCPU
-  put(Identifier::fromString(vm, "SIGXCPU"_s), jsNumber(SIGXCPU));
+    put(Identifier::fromString(vm, "SIGXCPU"_s), jsNumber(SIGXCPU));
 #endif
 #ifdef SIGXFSZ
-  put(Identifier::fromString(vm, "SIGXFSZ"_s), jsNumber(SIGXFSZ));
+    put(Identifier::fromString(vm, "SIGXFSZ"_s), jsNumber(SIGXFSZ));
 #endif
 #ifdef SIGVTALRM
-  put(Identifier::fromString(vm, "SIGVTALRM"_s), jsNumber(SIGVTALRM));
+    put(Identifier::fromString(vm, "SIGVTALRM"_s), jsNumber(SIGVTALRM));
 #endif
 #ifdef SIGPROF
-  put(Identifier::fromString(vm, "SIGPROF"_s), jsNumber(SIGPROF));
+    put(Identifier::fromString(vm, "SIGPROF"_s), jsNumber(SIGPROF));
 #endif
 #ifdef SIGWINCH
-  put(Identifier::fromString(vm, "SIGWINCH"_s), jsNumber(SIGWINCH));
+    put(Identifier::fromString(vm, "SIGWINCH"_s), jsNumber(SIGWINCH));
 #endif
 #ifdef SIGIO
-  put(Identifier::fromString(vm, "SIGIO"_s), jsNumber(SIGIO));
+    put(Identifier::fromString(vm, "SIGIO"_s), jsNumber(SIGIO));
 #endif
 #ifdef SIGPOLL
-  put(Identifier::fromString(vm, "SIGPOLL"_s), jsNumber(SIGPOLL));
+    put(Identifier::fromString(vm, "SIGPOLL"_s), jsNumber(SIGPOLL));
 #endif
 #ifdef SIGLOST
-  put(Identifier::fromString(vm, "SIGLOST"_s), jsNumber(SIGLOST));
+    put(Identifier::fromString(vm, "SIGLOST"_s), jsNumber(SIGLOST));
 #endif
 #ifdef SIGPWR
-  put(Identifier::fromString(vm, "SIGPWR"_s), jsNumber(SIGPWR));
+    put(Identifier::fromString(vm, "SIGPWR"_s), jsNumber(SIGPWR));
 #endif
 #ifdef SIGINFO
-  put(Identifier::fromString(vm, "SIGINFO"_s), jsNumber(SIGINFO));
+    put(Identifier::fromString(vm, "SIGINFO"_s), jsNumber(SIGINFO));
 #endif
 #ifdef SIGSYS
-  put(Identifier::fromString(vm, "SIGSYS"_s), jsNumber(SIGSYS));
+    put(Identifier::fromString(vm, "SIGSYS"_s), jsNumber(SIGSYS));
 #endif
 #ifdef SIGUNUSED
-  put(Identifier::fromString(vm, "SIGUNUSED"_s), jsNumber(SIGUNUSED));
+    put(Identifier::fromString(vm, "SIGUNUSED"_s), jsNumber(SIGUNUSED));
 #endif
-  put(Identifier::fromString(vm, "UV_FS_SYMLINK_DIR"_s), jsNumber(1));
-  put(Identifier::fromString(vm, "UV_FS_SYMLINK_JUNCTION"_s), jsNumber(2));
-  put(Identifier::fromString(vm, "O_RDONLY"_s), jsNumber(O_RDONLY));
-  put(Identifier::fromString(vm, "O_WRONLY"_s), jsNumber(O_WRONLY));
-  put(Identifier::fromString(vm, "O_RDWR"_s), jsNumber(O_RDWR));
+    put(Identifier::fromString(vm, "UV_FS_SYMLINK_DIR"_s), jsNumber(1));
+    put(Identifier::fromString(vm, "UV_FS_SYMLINK_JUNCTION"_s), jsNumber(2));
+    put(Identifier::fromString(vm, "O_RDONLY"_s), jsNumber(O_RDONLY));
+    put(Identifier::fromString(vm, "O_WRONLY"_s), jsNumber(O_WRONLY));
+    put(Identifier::fromString(vm, "O_RDWR"_s), jsNumber(O_RDWR));
 
-  put(Identifier::fromString(vm, "UV_DIRENT_UNKNOWN"_s), jsNumber(0));
-  put(Identifier::fromString(vm, "UV_DIRENT_FILE"_s), jsNumber(1));
-  put(Identifier::fromString(vm, "UV_DIRENT_DIR"_s), jsNumber(2));
-  put(Identifier::fromString(vm, "UV_DIRENT_LINK"_s), jsNumber(3));
-  put(Identifier::fromString(vm, "UV_DIRENT_FIFO"_s), jsNumber(4));
-  put(Identifier::fromString(vm, "UV_DIRENT_SOCKET"_s), jsNumber(5));
-  put(Identifier::fromString(vm, "UV_DIRENT_CHAR"_s), jsNumber(6));
-  put(Identifier::fromString(vm, "UV_DIRENT_BLOCK"_s), jsNumber(7));
+    put(Identifier::fromString(vm, "UV_DIRENT_UNKNOWN"_s), jsNumber(0));
+    put(Identifier::fromString(vm, "UV_DIRENT_FILE"_s), jsNumber(1));
+    put(Identifier::fromString(vm, "UV_DIRENT_DIR"_s), jsNumber(2));
+    put(Identifier::fromString(vm, "UV_DIRENT_LINK"_s), jsNumber(3));
+    put(Identifier::fromString(vm, "UV_DIRENT_FIFO"_s), jsNumber(4));
+    put(Identifier::fromString(vm, "UV_DIRENT_SOCKET"_s), jsNumber(5));
+    put(Identifier::fromString(vm, "UV_DIRENT_CHAR"_s), jsNumber(6));
+    put(Identifier::fromString(vm, "UV_DIRENT_BLOCK"_s), jsNumber(7));
 
-  put(Identifier::fromString(vm, "S_IFMT"_s), jsNumber(S_IFMT));
-  put(Identifier::fromString(vm, "S_IFREG"_s), jsNumber(S_IFREG));
-  put(Identifier::fromString(vm, "S_IFDIR"_s), jsNumber(S_IFDIR));
-  put(Identifier::fromString(vm, "S_IFCHR"_s), jsNumber(S_IFCHR));
+    put(Identifier::fromString(vm, "S_IFMT"_s), jsNumber(S_IFMT));
+    put(Identifier::fromString(vm, "S_IFREG"_s), jsNumber(S_IFREG));
+    put(Identifier::fromString(vm, "S_IFDIR"_s), jsNumber(S_IFDIR));
+    put(Identifier::fromString(vm, "S_IFCHR"_s), jsNumber(S_IFCHR));
 #ifdef S_IFBLK
-  put(Identifier::fromString(vm, "S_IFBLK"_s), jsNumber(S_IFBLK));
+    put(Identifier::fromString(vm, "S_IFBLK"_s), jsNumber(S_IFBLK));
 #endif
 #ifdef S_IFIFO
-  put(Identifier::fromString(vm, "S_IFIFO"_s), jsNumber(S_IFIFO));
+    put(Identifier::fromString(vm, "S_IFIFO"_s), jsNumber(S_IFIFO));
 #endif
 #ifdef S_IFLNK
-  put(Identifier::fromString(vm, "S_IFLNK"_s), jsNumber(S_IFLNK));
+    put(Identifier::fromString(vm, "S_IFLNK"_s), jsNumber(S_IFLNK));
 #endif
 #ifdef S_IFSOCK
-  put(Identifier::fromString(vm, "S_IFSOCK"_s), jsNumber(S_IFSOCK));
+    put(Identifier::fromString(vm, "S_IFSOCK"_s), jsNumber(S_IFSOCK));
 #endif
 #ifdef O_CREAT
-  put(Identifier::fromString(vm, "O_CREAT"_s), jsNumber(O_CREAT));
+    put(Identifier::fromString(vm, "O_CREAT"_s), jsNumber(O_CREAT));
 #endif
 #ifdef O_EXCL
-  put(Identifier::fromString(vm, "O_EXCL"_s), jsNumber(O_EXCL));
+    put(Identifier::fromString(vm, "O_EXCL"_s), jsNumber(O_EXCL));
 #endif
-  put(Identifier::fromString(vm, "UV_FS_O_FILEMAP"_s), jsNumber(0));
+    put(Identifier::fromString(vm, "UV_FS_O_FILEMAP"_s), jsNumber(0));
 
 #ifdef O_NOCTTY
-  put(Identifier::fromString(vm, "O_NOCTTY"_s), jsNumber(O_NOCTTY));
+    put(Identifier::fromString(vm, "O_NOCTTY"_s), jsNumber(O_NOCTTY));
 #endif
 #ifdef O_TRUNC
-  put(Identifier::fromString(vm, "O_TRUNC"_s), jsNumber(O_TRUNC));
+    put(Identifier::fromString(vm, "O_TRUNC"_s), jsNumber(O_TRUNC));
 #endif
 #ifdef O_APPEND
-  put(Identifier::fromString(vm, "O_APPEND"_s), jsNumber(O_APPEND));
+    put(Identifier::fromString(vm, "O_APPEND"_s), jsNumber(O_APPEND));
 #endif
 #ifdef O_DIRECTORY
-  put(Identifier::fromString(vm, "O_DIRECTORY"_s), jsNumber(O_DIRECTORY));
+    put(Identifier::fromString(vm, "O_DIRECTORY"_s), jsNumber(O_DIRECTORY));
 #endif
 #ifdef O_NOATIME
-  put(Identifier::fromString(vm, "O_NOATIME"_s), jsNumber(O_NOATIME));
+    put(Identifier::fromString(vm, "O_NOATIME"_s), jsNumber(O_NOATIME));
 #endif
 #ifdef O_NOFOLLOW
-  put(Identifier::fromString(vm, "O_NOFOLLOW"_s), jsNumber(O_NOFOLLOW));
+    put(Identifier::fromString(vm, "O_NOFOLLOW"_s), jsNumber(O_NOFOLLOW));
 #endif
 #ifdef O_SYNC
-  put(Identifier::fromString(vm, "O_SYNC"_s), jsNumber(O_SYNC));
+    put(Identifier::fromString(vm, "O_SYNC"_s), jsNumber(O_SYNC));
 #endif
 #ifdef O_DSYNC
-  put(Identifier::fromString(vm, "O_DSYNC"_s), jsNumber(O_DSYNC));
+    put(Identifier::fromString(vm, "O_DSYNC"_s), jsNumber(O_DSYNC));
 #endif
 #ifdef O_SYMLINK
-  put(Identifier::fromString(vm, "O_SYMLINK"_s), jsNumber(O_SYMLINK));
+    put(Identifier::fromString(vm, "O_SYMLINK"_s), jsNumber(O_SYMLINK));
 #endif
 #ifdef O_DIRECT
-  put(Identifier::fromString(vm, "O_DIRECT"_s), jsNumber(O_DIRECT));
+    put(Identifier::fromString(vm, "O_DIRECT"_s), jsNumber(O_DIRECT));
 #endif
 #ifdef O_NONBLOCK
-  put(Identifier::fromString(vm, "O_NONBLOCK"_s), jsNumber(O_NONBLOCK));
+    put(Identifier::fromString(vm, "O_NONBLOCK"_s), jsNumber(O_NONBLOCK));
 #endif
 #ifdef S_IRWXU
-  put(Identifier::fromString(vm, "S_IRWXU"_s), jsNumber(S_IRWXU));
+    put(Identifier::fromString(vm, "S_IRWXU"_s), jsNumber(S_IRWXU));
 #endif
 #ifdef S_IRUSR
-  put(Identifier::fromString(vm, "S_IRUSR"_s), jsNumber(S_IRUSR));
+    put(Identifier::fromString(vm, "S_IRUSR"_s), jsNumber(S_IRUSR));
 #endif
 #ifdef S_IWUSR
-  put(Identifier::fromString(vm, "S_IWUSR"_s), jsNumber(S_IWUSR));
+    put(Identifier::fromString(vm, "S_IWUSR"_s), jsNumber(S_IWUSR));
 #endif
 #ifdef S_IXUSR
-  put(Identifier::fromString(vm, "S_IXUSR"_s), jsNumber(S_IXUSR));
+    put(Identifier::fromString(vm, "S_IXUSR"_s), jsNumber(S_IXUSR));
 #endif
 #ifdef S_IRWXG
-  put(Identifier::fromString(vm, "S_IRWXG"_s), jsNumber(S_IRWXG));
+    put(Identifier::fromString(vm, "S_IRWXG"_s), jsNumber(S_IRWXG));
 #endif
 #ifdef S_IRGRP
-  put(Identifier::fromString(vm, "S_IRGRP"_s), jsNumber(S_IRGRP));
+    put(Identifier::fromString(vm, "S_IRGRP"_s), jsNumber(S_IRGRP));
 #endif
 #ifdef S_IWGRP
-  put(Identifier::fromString(vm, "S_IWGRP"_s), jsNumber(S_IWGRP));
+    put(Identifier::fromString(vm, "S_IWGRP"_s), jsNumber(S_IWGRP));
 #endif
 #ifdef S_IXGRP
-  put(Identifier::fromString(vm, "S_IXGRP"_s), jsNumber(S_IXGRP));
+    put(Identifier::fromString(vm, "S_IXGRP"_s), jsNumber(S_IXGRP));
 #endif
 #ifdef S_IRWXO
-  put(Identifier::fromString(vm, "S_IRWXO"_s), jsNumber(S_IRWXO));
+    put(Identifier::fromString(vm, "S_IRWXO"_s), jsNumber(S_IRWXO));
 #endif
 #ifdef S_IROTH
-  put(Identifier::fromString(vm, "S_IROTH"_s), jsNumber(S_IROTH));
+    put(Identifier::fromString(vm, "S_IROTH"_s), jsNumber(S_IROTH));
 #endif
 #ifdef S_IWOTH
-  put(Identifier::fromString(vm, "S_IWOTH"_s), jsNumber(S_IWOTH));
+    put(Identifier::fromString(vm, "S_IWOTH"_s), jsNumber(S_IWOTH));
 #endif
 #ifdef S_IXOTH
-  put(Identifier::fromString(vm, "S_IXOTH"_s), jsNumber(S_IXOTH));
+    put(Identifier::fromString(vm, "S_IXOTH"_s), jsNumber(S_IXOTH));
 #endif
 #ifdef F_OK
-  put(Identifier::fromString(vm, "F_OK"_s), jsNumber(F_OK));
+    put(Identifier::fromString(vm, "F_OK"_s), jsNumber(F_OK));
 #endif
 #ifdef R_OK
-  put(Identifier::fromString(vm, "R_OK"_s), jsNumber(R_OK));
+    put(Identifier::fromString(vm, "R_OK"_s), jsNumber(R_OK));
 #endif
 #ifdef W_OK
-  put(Identifier::fromString(vm, "W_OK"_s), jsNumber(W_OK));
+    put(Identifier::fromString(vm, "W_OK"_s), jsNumber(W_OK));
 #endif
 #ifdef X_OK
-  put(Identifier::fromString(vm, "X_OK"_s), jsNumber(X_OK));
+    put(Identifier::fromString(vm, "X_OK"_s), jsNumber(X_OK));
 #endif
-  put(Identifier::fromString(vm, "UV_FS_COPYFILE_EXCL"_s), jsNumber(1));
-  put(Identifier::fromString(vm, "COPYFILE_EXCL"_s), jsNumber(1));
-  put(Identifier::fromString(vm, "UV_FS_COPYFILE_FICLONE"_s), jsNumber(2));
-  put(Identifier::fromString(vm, "COPYFILE_FICLONE"_s), jsNumber(2));
-  put(Identifier::fromString(vm, "UV_FS_COPYFILE_FICLONE_FORCE"_s),
-      jsNumber(4));
-  put(Identifier::fromString(vm, "COPYFILE_FICLONE_FORCE"_s), jsNumber(4));
+    put(Identifier::fromString(vm, "UV_FS_COPYFILE_EXCL"_s), jsNumber(1));
+    put(Identifier::fromString(vm, "COPYFILE_EXCL"_s), jsNumber(1));
+    put(Identifier::fromString(vm, "UV_FS_COPYFILE_FICLONE"_s), jsNumber(2));
+    put(Identifier::fromString(vm, "COPYFILE_FICLONE"_s), jsNumber(2));
+    put(Identifier::fromString(vm, "UV_FS_COPYFILE_FICLONE_FORCE"_s),
+        jsNumber(4));
+    put(Identifier::fromString(vm, "COPYFILE_FICLONE_FORCE"_s), jsNumber(4));
 #ifdef OPENSSL_VERSION_NUMBER
-  put(Identifier::fromString(vm, "OPENSSL_VERSION_NUMBER"_s),
-      jsNumber(OPENSSL_VERSION_NUMBER));
+    put(Identifier::fromString(vm, "OPENSSL_VERSION_NUMBER"_s),
+        jsNumber(OPENSSL_VERSION_NUMBER));
 #endif
 #ifdef SSL_OP_ALL
-  put(Identifier::fromString(vm, "SSL_OP_ALL"_s), jsNumber(SSL_OP_ALL));
+    put(Identifier::fromString(vm, "SSL_OP_ALL"_s), jsNumber(SSL_OP_ALL));
 #endif
 #ifdef SSL_OP_ALLOW_NO_DHE_KEX
-  put(Identifier::fromString(vm, "SSL_OP_ALLOW_NO_DHE_KEX"_s),
-      jsNumber(SSL_OP_ALLOW_NO_DHE_KEX));
+    put(Identifier::fromString(vm, "SSL_OP_ALLOW_NO_DHE_KEX"_s),
+        jsNumber(SSL_OP_ALLOW_NO_DHE_KEX));
 #endif
 #ifdef SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION
-  put(Identifier::fromString(vm, "SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION"_s),
-      jsNumber(SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION));
+    put(Identifier::fromString(vm, "SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION"_s),
+        jsNumber(SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION));
 #endif
 #ifdef SSL_OP_CIPHER_SERVER_PREFERENCE
-  put(Identifier::fromString(vm, "SSL_OP_CIPHER_SERVER_PREFERENCE"_s),
-      jsNumber(SSL_OP_CIPHER_SERVER_PREFERENCE));
+    put(Identifier::fromString(vm, "SSL_OP_CIPHER_SERVER_PREFERENCE"_s),
+        jsNumber(SSL_OP_CIPHER_SERVER_PREFERENCE));
 #endif
 #ifdef SSL_OP_CISCO_ANYCONNECT
-  put(Identifier::fromString(vm, "SSL_OP_CISCO_ANYCONNECT"_s),
-      jsNumber(SSL_OP_CISCO_ANYCONNECT));
+    put(Identifier::fromString(vm, "SSL_OP_CISCO_ANYCONNECT"_s),
+        jsNumber(SSL_OP_CISCO_ANYCONNECT));
 #endif
 #ifdef SSL_OP_COOKIE_EXCHANGE
-  put(Identifier::fromString(vm, "SSL_OP_COOKIE_EXCHANGE"_s),
-      jsNumber(SSL_OP_COOKIE_EXCHANGE));
+    put(Identifier::fromString(vm, "SSL_OP_COOKIE_EXCHANGE"_s),
+        jsNumber(SSL_OP_COOKIE_EXCHANGE));
 #endif
 #ifdef SSL_OP_CRYPTOPRO_TLSEXT_BUG
-  put(Identifier::fromString(vm, "SSL_OP_CRYPTOPRO_TLSEXT_BUG"_s),
-      jsNumber(SSL_OP_CRYPTOPRO_TLSEXT_BUG));
+    put(Identifier::fromString(vm, "SSL_OP_CRYPTOPRO_TLSEXT_BUG"_s),
+        jsNumber(SSL_OP_CRYPTOPRO_TLSEXT_BUG));
 #endif
 #ifdef SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS
-  put(Identifier::fromString(vm, "SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS"_s),
-      jsNumber(SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS));
+    put(Identifier::fromString(vm, "SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS"_s),
+        jsNumber(SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS));
 #endif
 #ifdef SSL_OP_LEGACY_SERVER_CONNECT
-  put(Identifier::fromString(vm, "SSL_OP_LEGACY_SERVER_CONNECT"_s),
-      jsNumber(SSL_OP_LEGACY_SERVER_CONNECT));
+    put(Identifier::fromString(vm, "SSL_OP_LEGACY_SERVER_CONNECT"_s),
+        jsNumber(SSL_OP_LEGACY_SERVER_CONNECT));
 #endif
 #ifdef SSL_OP_NO_COMPRESSION
-  put(Identifier::fromString(vm, "SSL_OP_NO_COMPRESSION"_s),
-      jsNumber(SSL_OP_NO_COMPRESSION));
+    put(Identifier::fromString(vm, "SSL_OP_NO_COMPRESSION"_s),
+        jsNumber(SSL_OP_NO_COMPRESSION));
 #endif
 #ifdef SSL_OP_NO_ENCRYPT_THEN_MAC
-  put(Identifier::fromString(vm, "SSL_OP_NO_ENCRYPT_THEN_MAC"_s),
-      jsNumber(SSL_OP_NO_ENCRYPT_THEN_MAC));
+    put(Identifier::fromString(vm, "SSL_OP_NO_ENCRYPT_THEN_MAC"_s),
+        jsNumber(SSL_OP_NO_ENCRYPT_THEN_MAC));
 #endif
 #ifdef SSL_OP_NO_QUERY_MTU
-  put(Identifier::fromString(vm, "SSL_OP_NO_QUERY_MTU"_s),
-      jsNumber(SSL_OP_NO_QUERY_MTU));
+    put(Identifier::fromString(vm, "SSL_OP_NO_QUERY_MTU"_s),
+        jsNumber(SSL_OP_NO_QUERY_MTU));
 #endif
 #ifdef SSL_OP_NO_RENEGOTIATION
-  put(Identifier::fromString(vm, "SSL_OP_NO_RENEGOTIATION"_s),
-      jsNumber(SSL_OP_NO_RENEGOTIATION));
+    put(Identifier::fromString(vm, "SSL_OP_NO_RENEGOTIATION"_s),
+        jsNumber(SSL_OP_NO_RENEGOTIATION));
 #endif
 #ifdef SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION
-  put(Identifier::fromString(vm,
-                             "SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION"_s),
-      jsNumber(SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION));
+    put(Identifier::fromString(vm,
+            "SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION"_s),
+        jsNumber(SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION));
 #endif
 #ifdef SSL_OP_NO_SSLv2
-  put(Identifier::fromString(vm, "SSL_OP_NO_SSLv2"_s),
-      jsNumber(SSL_OP_NO_SSLv2));
+    put(Identifier::fromString(vm, "SSL_OP_NO_SSLv2"_s),
+        jsNumber(SSL_OP_NO_SSLv2));
 #endif
 #ifdef SSL_OP_NO_SSLv3
-  put(Identifier::fromString(vm, "SSL_OP_NO_SSLv3"_s),
-      jsNumber(SSL_OP_NO_SSLv3));
+    put(Identifier::fromString(vm, "SSL_OP_NO_SSLv3"_s),
+        jsNumber(SSL_OP_NO_SSLv3));
 #endif
 #ifdef SSL_OP_NO_TICKET
-  put(Identifier::fromString(vm, "SSL_OP_NO_TICKET"_s),
-      jsNumber(SSL_OP_NO_TICKET));
+    put(Identifier::fromString(vm, "SSL_OP_NO_TICKET"_s),
+        jsNumber(SSL_OP_NO_TICKET));
 #endif
 #ifdef SSL_OP_NO_TLSv1
-  put(Identifier::fromString(vm, "SSL_OP_NO_TLSv1"_s),
-      jsNumber(SSL_OP_NO_TLSv1));
+    put(Identifier::fromString(vm, "SSL_OP_NO_TLSv1"_s),
+        jsNumber(SSL_OP_NO_TLSv1));
 #endif
 #ifdef SSL_OP_NO_TLSv1_1
-  put(Identifier::fromString(vm, "SSL_OP_NO_TLSv1_1"_s),
-      jsNumber(SSL_OP_NO_TLSv1_1));
+    put(Identifier::fromString(vm, "SSL_OP_NO_TLSv1_1"_s),
+        jsNumber(SSL_OP_NO_TLSv1_1));
 #endif
 #ifdef SSL_OP_NO_TLSv1_2
-  put(Identifier::fromString(vm, "SSL_OP_NO_TLSv1_2"_s),
-      jsNumber(SSL_OP_NO_TLSv1_2));
+    put(Identifier::fromString(vm, "SSL_OP_NO_TLSv1_2"_s),
+        jsNumber(SSL_OP_NO_TLSv1_2));
 #endif
 #ifdef SSL_OP_NO_TLSv1_3
-  put(Identifier::fromString(vm, "SSL_OP_NO_TLSv1_3"_s),
-      jsNumber(SSL_OP_NO_TLSv1_3));
+    put(Identifier::fromString(vm, "SSL_OP_NO_TLSv1_3"_s),
+        jsNumber(SSL_OP_NO_TLSv1_3));
 #endif
 #ifdef SSL_OP_PRIORITIZE_CHACHA
-  put(Identifier::fromString(vm, "SSL_OP_PRIORITIZE_CHACHA"_s),
-      jsNumber(SSL_OP_PRIORITIZE_CHACHA));
+    put(Identifier::fromString(vm, "SSL_OP_PRIORITIZE_CHACHA"_s),
+        jsNumber(SSL_OP_PRIORITIZE_CHACHA));
 #endif
 #ifdef SSL_OP_TLS_ROLLBACK_BUG
-  put(Identifier::fromString(vm, "SSL_OP_TLS_ROLLBACK_BUG"_s),
-      jsNumber(SSL_OP_TLS_ROLLBACK_BUG));
+    put(Identifier::fromString(vm, "SSL_OP_TLS_ROLLBACK_BUG"_s),
+        jsNumber(SSL_OP_TLS_ROLLBACK_BUG));
 #endif
 #ifndef OPENSSL_NO_ENGINE
 #ifdef ENGINE_METHOD_RSA
-  put(Identifier::fromString(vm, "ENGINE_METHOD_RSA"_s),
-      jsNumber(ENGINE_METHOD_RSA));
+    put(Identifier::fromString(vm, "ENGINE_METHOD_RSA"_s),
+        jsNumber(ENGINE_METHOD_RSA));
 #endif
 #ifdef ENGINE_METHOD_DSA
-  put(Identifier::fromString(vm, "ENGINE_METHOD_DSA"_s),
-      jsNumber(ENGINE_METHOD_DSA));
+    put(Identifier::fromString(vm, "ENGINE_METHOD_DSA"_s),
+        jsNumber(ENGINE_METHOD_DSA));
 #endif
 #ifdef ENGINE_METHOD_DH
-  put(Identifier::fromString(vm, "ENGINE_METHOD_DH"_s),
-      jsNumber(ENGINE_METHOD_DH));
+    put(Identifier::fromString(vm, "ENGINE_METHOD_DH"_s),
+        jsNumber(ENGINE_METHOD_DH));
 #endif
 #ifdef ENGINE_METHOD_RAND
-  put(Identifier::fromString(vm, "ENGINE_METHOD_RAND"_s),
-      jsNumber(ENGINE_METHOD_RAND));
+    put(Identifier::fromString(vm, "ENGINE_METHOD_RAND"_s),
+        jsNumber(ENGINE_METHOD_RAND));
 #endif
 #ifdef ENGINE_METHOD_EC
-  put(Identifier::fromString(vm, "ENGINE_METHOD_EC"_s),
-      jsNumber(ENGINE_METHOD_EC));
+    put(Identifier::fromString(vm, "ENGINE_METHOD_EC"_s),
+        jsNumber(ENGINE_METHOD_EC));
 #endif
 #ifdef ENGINE_METHOD_CIPHERS
-  put(Identifier::fromString(vm, "ENGINE_METHOD_CIPHERS"_s),
-      jsNumber(ENGINE_METHOD_CIPHERS));
+    put(Identifier::fromString(vm, "ENGINE_METHOD_CIPHERS"_s),
+        jsNumber(ENGINE_METHOD_CIPHERS));
 #endif
 #ifdef ENGINE_METHOD_DIGESTS
-  put(Identifier::fromString(vm, "ENGINE_METHOD_DIGESTS"_s),
-      jsNumber(ENGINE_METHOD_DIGESTS));
+    put(Identifier::fromString(vm, "ENGINE_METHOD_DIGESTS"_s),
+        jsNumber(ENGINE_METHOD_DIGESTS));
 #endif
 #ifdef ENGINE_METHOD_PKEY_METHS
-  put(Identifier::fromString(vm, "ENGINE_METHOD_PKEY_METHS"_s),
-      jsNumber(ENGINE_METHOD_PKEY_METHS));
+    put(Identifier::fromString(vm, "ENGINE_METHOD_PKEY_METHS"_s),
+        jsNumber(ENGINE_METHOD_PKEY_METHS));
 #endif
 #ifdef ENGINE_METHOD_PKEY_ASN1_METHS
-  put(Identifier::fromString(vm, "ENGINE_METHOD_PKEY_ASN1_METHS"_s),
-      jsNumber(ENGINE_METHOD_PKEY_ASN1_METHS));
+    put(Identifier::fromString(vm, "ENGINE_METHOD_PKEY_ASN1_METHS"_s),
+        jsNumber(ENGINE_METHOD_PKEY_ASN1_METHS));
 #endif
 #ifdef ENGINE_METHOD_ALL
-  put(Identifier::fromString(vm, "ENGINE_METHOD_ALL"_s),
-      jsNumber(ENGINE_METHOD_ALL));
+    put(Identifier::fromString(vm, "ENGINE_METHOD_ALL"_s),
+        jsNumber(ENGINE_METHOD_ALL));
 #endif
 #ifdef ENGINE_METHOD_NONE
-  put(Identifier::fromString(vm, "ENGINE_METHOD_NONE"_s),
-      jsNumber(ENGINE_METHOD_NONE));
+    put(Identifier::fromString(vm, "ENGINE_METHOD_NONE"_s),
+        jsNumber(ENGINE_METHOD_NONE));
 #endif
 #endif // !OPENSSL_NO_ENGINE
 #ifdef DH_CHECK_P_NOT_SAFE_PRIME
-  put(Identifier::fromString(vm, "DH_CHECK_P_NOT_SAFE_PRIME"_s),
-      jsNumber(DH_CHECK_P_NOT_SAFE_PRIME));
+    put(Identifier::fromString(vm, "DH_CHECK_P_NOT_SAFE_PRIME"_s),
+        jsNumber(DH_CHECK_P_NOT_SAFE_PRIME));
 #endif
 #ifdef DH_CHECK_P_NOT_PRIME
-  put(Identifier::fromString(vm, "DH_CHECK_P_NOT_PRIME"_s),
-      jsNumber(DH_CHECK_P_NOT_PRIME));
+    put(Identifier::fromString(vm, "DH_CHECK_P_NOT_PRIME"_s),
+        jsNumber(DH_CHECK_P_NOT_PRIME));
 #endif
 #ifdef DH_UNABLE_TO_CHECK_GENERATOR
-  put(Identifier::fromString(vm, "DH_UNABLE_TO_CHECK_GENERATOR"_s),
-      jsNumber(DH_UNABLE_TO_CHECK_GENERATOR));
+    put(Identifier::fromString(vm, "DH_UNABLE_TO_CHECK_GENERATOR"_s),
+        jsNumber(DH_UNABLE_TO_CHECK_GENERATOR));
 #endif
 #ifdef DH_NOT_SUITABLE_GENERATOR
-  put(Identifier::fromString(vm, "DH_NOT_SUITABLE_GENERATOR"_s),
-      jsNumber(DH_NOT_SUITABLE_GENERATOR));
+    put(Identifier::fromString(vm, "DH_NOT_SUITABLE_GENERATOR"_s),
+        jsNumber(DH_NOT_SUITABLE_GENERATOR));
 #endif
 #ifdef RSA_PKCS1_PADDING
-  put(Identifier::fromString(vm, "RSA_PKCS1_PADDING"_s),
-      jsNumber(RSA_PKCS1_PADDING));
+    put(Identifier::fromString(vm, "RSA_PKCS1_PADDING"_s),
+        jsNumber(RSA_PKCS1_PADDING));
 #endif
 #ifdef RSA_SSLV23_PADDING
-  put(Identifier::fromString(vm, "RSA_SSLV23_PADDING"_s),
-      jsNumber(RSA_SSLV23_PADDING));
+    put(Identifier::fromString(vm, "RSA_SSLV23_PADDING"_s),
+        jsNumber(RSA_SSLV23_PADDING));
 #endif
 #ifdef RSA_NO_PADDING
-  put(Identifier::fromString(vm, "RSA_NO_PADDING"_s), jsNumber(RSA_NO_PADDING));
+    put(Identifier::fromString(vm, "RSA_NO_PADDING"_s), jsNumber(RSA_NO_PADDING));
 #endif
 #ifdef RSA_PKCS1_OAEP_PADDING
-  put(Identifier::fromString(vm, "RSA_PKCS1_OAEP_PADDING"_s),
-      jsNumber(RSA_PKCS1_OAEP_PADDING));
+    put(Identifier::fromString(vm, "RSA_PKCS1_OAEP_PADDING"_s),
+        jsNumber(RSA_PKCS1_OAEP_PADDING));
 #endif
 #ifdef RSA_X931_PADDING
-  put(Identifier::fromString(vm, "RSA_X931_PADDING"_s),
-      jsNumber(RSA_X931_PADDING));
+    put(Identifier::fromString(vm, "RSA_X931_PADDING"_s),
+        jsNumber(RSA_X931_PADDING));
 #endif
 #ifdef RSA_PKCS1_PSS_PADDING
-  put(Identifier::fromString(vm, "RSA_PKCS1_PSS_PADDING"_s),
-      jsNumber(RSA_PKCS1_PSS_PADDING));
+    put(Identifier::fromString(vm, "RSA_PKCS1_PSS_PADDING"_s),
+        jsNumber(RSA_PKCS1_PSS_PADDING));
 #endif
 #ifdef RSA_PSS_SALTLEN_DIGEST
-  put(Identifier::fromString(vm, "RSA_PSS_SALTLEN_DIGEST"_s),
-      jsNumber(RSA_PSS_SALTLEN_DIGEST));
+    put(Identifier::fromString(vm, "RSA_PSS_SALTLEN_DIGEST"_s),
+        jsNumber(RSA_PSS_SALTLEN_DIGEST));
 #endif
 #ifdef RSA_PSS_SALTLEN_MAX_SIGN
-  put(Identifier::fromString(vm, "RSA_PSS_SALTLEN_MAX_SIGN"_s),
-      jsNumber(RSA_PSS_SALTLEN_MAX_SIGN));
+    put(Identifier::fromString(vm, "RSA_PSS_SALTLEN_MAX_SIGN"_s),
+        jsNumber(RSA_PSS_SALTLEN_MAX_SIGN));
 #endif
 #ifdef RSA_PSS_SALTLEN_AUTO
-  put(Identifier::fromString(vm, "RSA_PSS_SALTLEN_AUTO"_s),
-      jsNumber(RSA_PSS_SALTLEN_AUTO));
+    put(Identifier::fromString(vm, "RSA_PSS_SALTLEN_AUTO"_s),
+        jsNumber(RSA_PSS_SALTLEN_AUTO));
 #endif
-  auto cipherList = String("TLS_AES_256_GCM_SHA384:"
-                           "TLS_CHACHA20_POLY1305_SHA256:"
-                           "TLS_AES_128_GCM_SHA256:"
-                           "ECDHE-RSA-AES128-GCM-SHA256:"
-                           "ECDHE-ECDSA-AES128-GCM-SHA256:"
-                           "ECDHE-RSA-AES256-GCM-SHA384:"
-                           "ECDHE-ECDSA-AES256-GCM-SHA384:"
-                           "DHE-RSA-AES128-GCM-SHA256:"
-                           "ECDHE-RSA-AES128-SHA256:"
-                           "DHE-RSA-AES128-SHA256:"
-                           "ECDHE-RSA-AES256-SHA384:"
-                           "DHE-RSA-AES256-SHA384:"
-                           "ECDHE-RSA-AES256-SHA256:"
-                           "DHE-RSA-AES256-SHA256:"
-                           "HIGH:"
-                           "!aNULL:"
-                           "!eNULL:"
-                           "!EXPORT:"
-                           "!DES:"
-                           "!RC4:"
-                           "!MD5:"
-                           "!PSK:"
-                           "!SRP:"
-                           "!CAMELLIA"_s);
-  put(Identifier::fromString(vm, "defaultCoreCipherList"_s),
-      jsString(vm, cipherList));
-  put(Identifier::fromString(vm, "defaultCipherList"_s),
-      jsString(vm, cipherList));
+    auto cipherList = String("TLS_AES_256_GCM_SHA384:"
+                             "TLS_CHACHA20_POLY1305_SHA256:"
+                             "TLS_AES_128_GCM_SHA256:"
+                             "ECDHE-RSA-AES128-GCM-SHA256:"
+                             "ECDHE-ECDSA-AES128-GCM-SHA256:"
+                             "ECDHE-RSA-AES256-GCM-SHA384:"
+                             "ECDHE-ECDSA-AES256-GCM-SHA384:"
+                             "DHE-RSA-AES128-GCM-SHA256:"
+                             "ECDHE-RSA-AES128-SHA256:"
+                             "DHE-RSA-AES128-SHA256:"
+                             "ECDHE-RSA-AES256-SHA384:"
+                             "DHE-RSA-AES256-SHA384:"
+                             "ECDHE-RSA-AES256-SHA256:"
+                             "DHE-RSA-AES256-SHA256:"
+                             "HIGH:"
+                             "!aNULL:"
+                             "!eNULL:"
+                             "!EXPORT:"
+                             "!DES:"
+                             "!RC4:"
+                             "!MD5:"
+                             "!PSK:"
+                             "!SRP:"
+                             "!CAMELLIA"_s);
+    put(Identifier::fromString(vm, "defaultCoreCipherList"_s),
+        jsString(vm, cipherList));
+    put(Identifier::fromString(vm, "defaultCipherList"_s),
+        jsString(vm, cipherList));
 #ifdef TLS1_VERSION
-  put(Identifier::fromString(vm, "TLS1_VERSION"_s), jsNumber(TLS1_VERSION));
+    put(Identifier::fromString(vm, "TLS1_VERSION"_s), jsNumber(TLS1_VERSION));
 #endif
 #ifdef TLS1_1_VERSION
-  put(Identifier::fromString(vm, "TLS1_1_VERSION"_s), jsNumber(TLS1_1_VERSION));
+    put(Identifier::fromString(vm, "TLS1_1_VERSION"_s), jsNumber(TLS1_1_VERSION));
 #endif
 #ifdef TLS1_2_VERSION
-  put(Identifier::fromString(vm, "TLS1_2_VERSION"_s), jsNumber(TLS1_2_VERSION));
+    put(Identifier::fromString(vm, "TLS1_2_VERSION"_s), jsNumber(TLS1_2_VERSION));
 #endif
 #ifdef TLS1_3_VERSION
-  put(Identifier::fromString(vm, "TLS1_3_VERSION"_s), jsNumber(TLS1_3_VERSION));
+    put(Identifier::fromString(vm, "TLS1_3_VERSION"_s), jsNumber(TLS1_3_VERSION));
 #endif
-  put(Identifier::fromString(vm, "POINT_CONVERSION_COMPRESSED"_s),
-      jsNumber(POINT_CONVERSION_COMPRESSED));
-  put(Identifier::fromString(vm, "POINT_CONVERSION_UNCOMPRESSED"_s),
-      jsNumber(POINT_CONVERSION_UNCOMPRESSED));
-  put(Identifier::fromString(vm, "POINT_CONVERSION_HYBRID"_s),
-      jsNumber(POINT_CONVERSION_HYBRID));
+    put(Identifier::fromString(vm, "POINT_CONVERSION_COMPRESSED"_s),
+        jsNumber(POINT_CONVERSION_COMPRESSED));
+    put(Identifier::fromString(vm, "POINT_CONVERSION_UNCOMPRESSED"_s),
+        jsNumber(POINT_CONVERSION_UNCOMPRESSED));
+    put(Identifier::fromString(vm, "POINT_CONVERSION_HYBRID"_s),
+        jsNumber(POINT_CONVERSION_HYBRID));
 
-  // RETURN_NATIVE_MODULE();
+    // RETURN_NATIVE_MODULE();
 }
 
 } // namespace Zig
diff --git a/src/bun.js/modules/NodeModuleModule.cpp b/src/bun.js/modules/NodeModuleModule.cpp
new file mode 100644
index 0000000000..e913e937b9
--- /dev/null
+++ b/src/bun.js/modules/NodeModuleModule.cpp
@@ -0,0 +1,865 @@
+#include "root.h"
+
+#include <JavaScriptCore/JSCInlines.h>
+
+#include <JavaScriptCore/VM.h>
+
+#include <JavaScriptCore/JSString.h>
+
+#include "headers-handwritten.h"
+
+#include "PathInlines.h"
+#include "ZigGlobalObject.h"
+#include "headers.h"
+#include <JavaScriptCore/FunctionPrototype.h>
+
+#include "NodeModuleModule.h"
+
+#include "ErrorCode.h"
+#include <JavaScriptCore/LazyPropertyInlines.h>
+#include <JavaScriptCore/VMTrapsInlines.h>
+namespace Bun {
+
+using namespace JSC;
+
+BUN_DECLARE_HOST_FUNCTION(Resolver__nodeModulePathsForJS);
+JSC_DECLARE_HOST_FUNCTION(jsFunctionDebugNoop);
+JSC_DECLARE_HOST_FUNCTION(jsFunctionFindPath);
+JSC_DECLARE_HOST_FUNCTION(jsFunctionFindSourceMap);
+JSC_DECLARE_HOST_FUNCTION(jsFunctionIsBuiltinModule);
+JSC_DECLARE_HOST_FUNCTION(jsFunctionNodeModuleCreateRequire);
+JSC_DECLARE_HOST_FUNCTION(jsFunctionNodeModuleModuleConstructor);
+JSC_DECLARE_HOST_FUNCTION(jsFunctionResolveFileName);
+JSC_DECLARE_HOST_FUNCTION(jsFunctionResolveLookupPaths);
+JSC_DECLARE_HOST_FUNCTION(jsFunctionSourceMap);
+JSC_DECLARE_HOST_FUNCTION(jsFunctionSyncBuiltinExports);
+JSC_DECLARE_HOST_FUNCTION(jsFunctionWrap);
+
+JSC_DECLARE_CUSTOM_GETTER(getterRequireFunction);
+JSC_DECLARE_CUSTOM_SETTER(setterRequireFunction);
+
+// This is a mix of bun's builtin module names and also the ones reported by
+// node v20.4.0
+static constexpr ASCIILiteral builtinModuleNames[] = {
+    "_http_agent"_s,
+    "_http_client"_s,
+    "_http_common"_s,
+    "_http_incoming"_s,
+    "_http_outgoing"_s,
+    "_http_server"_s,
+    "_stream_duplex"_s,
+    "_stream_passthrough"_s,
+    "_stream_readable"_s,
+    "_stream_transform"_s,
+    "_stream_wrap"_s,
+    "_stream_writable"_s,
+    "_tls_common"_s,
+    "_tls_wrap"_s,
+    "assert"_s,
+    "assert/strict"_s,
+    "async_hooks"_s,
+    "buffer"_s,
+    "bun"_s,
+    "bun:ffi"_s,
+    "bun:jsc"_s,
+    "bun:sqlite"_s,
+    "bun:test"_s,
+    "bun:wrap"_s,
+    "child_process"_s,
+    "cluster"_s,
+    "console"_s,
+    "constants"_s,
+    "crypto"_s,
+    "detect-libc"_s,
+    "dgram"_s,
+    "diagnostics_channel"_s,
+    "dns"_s,
+    "dns/promises"_s,
+    "domain"_s,
+    "events"_s,
+    "fs"_s,
+    "fs/promises"_s,
+    "http"_s,
+    "http2"_s,
+    "https"_s,
+    "inspector"_s,
+    "inspector/promises"_s,
+    "module"_s,
+    "net"_s,
+    "os"_s,
+    "path"_s,
+    "path/posix"_s,
+    "path/win32"_s,
+    "perf_hooks"_s,
+    "process"_s,
+    "punycode"_s,
+    "querystring"_s,
+    "readline"_s,
+    "readline/promises"_s,
+    "repl"_s,
+    "stream"_s,
+    "stream/consumers"_s,
+    "stream/promises"_s,
+    "stream/web"_s,
+    "string_decoder"_s,
+    "sys"_s,
+    "timers"_s,
+    "timers/promises"_s,
+    "tls"_s,
+    "trace_events"_s,
+    "tty"_s,
+    "undici"_s,
+    "url"_s,
+    "util"_s,
+    "util/types"_s,
+    "v8"_s,
+    "vm"_s,
+    "wasi"_s,
+    "worker_threads"_s,
+    "ws"_s,
+    "zlib"_s,
+};
+
+template<std::size_t N, class T> consteval std::size_t countof(T (&)[N])
+{
+    return N;
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunctionDebugNoop,
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callFrame))
+{
+    return JSValue::encode(jsUndefined());
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunctionNodeModuleModuleCall,
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callFrame))
+{
+    return JSValue::encode(jsUndefined());
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunctionNodeModuleModuleConstructor,
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callFrame))
+{
+
+    // In node, this is supposed to be the actual CommonJSModule constructor.
+    // We are cutting a huge corner by not doing all that work.
+    // This code is only to support babel.
+    JSC::VM& vm = globalObject->vm();
+    JSString* idString = JSC::jsString(vm, WTF::String("."_s));
+
+    JSString* dirname = jsEmptyString(vm);
+
+    // TODO: handle when JSGlobalObject !== Zig::GlobalObject, such as in node:vm
+    Structure* structure = static_cast<Zig::GlobalObject*>(globalObject)
+                               ->CommonJSModuleObjectStructure();
+
+    // TODO: handle ShadowRealm, node:vm, new.target, subclasses
+    JSValue idValue = callFrame->argument(0);
+    JSValue parentValue = callFrame->argument(1);
+
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    if (idValue.isString()) {
+        idString = idValue.toString(globalObject);
+        RETURN_IF_EXCEPTION(scope, {});
+
+        auto index = idString->tryGetValue()->reverseFind('/', idString->length());
+
+        if (index != WTF::notFound) {
+            dirname = JSC::jsSubstring(globalObject, idString, 0, index);
+        }
+    }
+
+    auto* out = Bun::JSCommonJSModule::create(vm, structure, idString, jsNull(),
+        dirname, SourceCode());
+
+    if (!parentValue.isUndefined()) {
+        out->putDirect(vm, JSC::Identifier::fromString(vm, "parent"_s), parentValue,
+            0);
+    }
+
+    out->putDirect(vm, JSC::Identifier::fromString(vm, "exports"_s),
+        JSC::constructEmptyObject(globalObject,
+            globalObject->objectPrototype(), 0),
+        0);
+
+    return JSValue::encode(out);
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunctionIsBuiltinModule,
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callFrame))
+{
+    JSC::VM& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    JSValue moduleName = callFrame->argument(0);
+    if (!moduleName.isString()) {
+        return JSValue::encode(jsBoolean(false));
+    }
+
+    auto moduleStr = moduleName.toWTFString(globalObject);
+    RETURN_IF_EXCEPTION(scope, JSValue::encode(jsBoolean(false)));
+
+    return JSValue::encode(jsBoolean(Bun::isBuiltinModule(moduleStr)));
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunctionWrap, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    auto& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    JSString* code = callFrame->argument(0).toStringOrNull(globalObject);
+    RETURN_IF_EXCEPTION(scope, {});
+    if (!code) {
+        return JSC::JSValue::encode(JSC::jsUndefined());
+    }
+
+    JSString* prefix = jsString(
+        vm,
+        String(
+            "(function (exports, require, module, __filename, __dirname) { "_s));
+    JSString* suffix = jsString(vm, String("\n});"_s));
+
+    return JSValue::encode(jsString(globalObject, prefix, code, suffix));
+}
+extern "C" void Bun__Node__Path_joinWTF(BunString* lhs, const char* rhs,
+    size_t len, BunString* result);
+JSC_DEFINE_HOST_FUNCTION(jsFunctionNodeModuleCreateRequire,
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callFrame))
+{
+    JSC::VM& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    if (callFrame->argumentCount() < 1) {
+        return Bun::throwError(globalObject, scope,
+            Bun::ErrorCode::ERR_MISSING_ARGS,
+            "createRequire() requires at least one argument"_s);
+    }
+
+    auto val = callFrame->uncheckedArgument(0).toWTFString(globalObject);
+    RETURN_IF_EXCEPTION(scope, {});
+
+    if (val.startsWith("file://"_s)) {
+        WTF::URL url(val);
+        if (!url.isValid()) {
+            throwTypeError(globalObject, scope,
+                makeString("createRequire() was given an invalid URL '"_s,
+                    url.string(), "'"_s));
+            RELEASE_AND_RETURN(scope, JSValue::encode({}));
+        }
+        if (!url.protocolIsFile()) {
+            throwTypeError(globalObject, scope,
+                "createRequire() does not support non-file URLs"_s);
+            RELEASE_AND_RETURN(scope, JSValue::encode({}));
+        }
+        val = url.fileSystemPath();
+    }
+
+    bool trailingSlash = val.endsWith('/');
+#if OS(WINDOWS)
+    if (val.endsWith('\\')) {
+        trailingSlash = true;
+    }
+#endif
+
+    // https://github.com/nodejs/node/blob/2eff28fb7a93d3f672f80b582f664a7c701569fb/lib/internal/modules/cjs/loader.js#L1603-L1620
+    if (trailingSlash) {
+        BunString lhs = Bun::toString(val);
+        BunString result;
+        Bun__Node__Path_joinWTF(&lhs, "noop.js", sizeof("noop.js") - 1, &result);
+        val = result.toWTFString();
+        if (!val.isNull()) {
+            ASSERT(val.impl()->refCount() == 2);
+            val.impl()->deref();
+        }
+    }
+
+    RETURN_IF_EXCEPTION(scope, {});
+    RELEASE_AND_RETURN(
+        scope, JSValue::encode(Bun::JSCommonJSModule::createBoundRequireFunction(vm, globalObject, val)));
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunctionFindSourceMap,
+    (JSGlobalObject * globalObject,
+        CallFrame* callFrame))
+{
+    auto& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    throwException(
+        globalObject, scope,
+        createError(globalObject,
+            "module.SourceMap is not yet implemented in Bun"_s));
+    return {};
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunctionSyncBuiltinExports,
+    (JSGlobalObject * globalObject,
+        CallFrame* callFrame))
+{
+    return JSValue::encode(jsUndefined());
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunctionSourceMap, (JSGlobalObject * globalObject, CallFrame* callFrame))
+{
+    auto& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    throwException(globalObject, scope,
+        createError(globalObject, "Not implemented"_s));
+    return {};
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunctionResolveFileName,
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callFrame))
+{
+    JSC::VM& vm = globalObject->vm();
+
+    switch (callFrame->argumentCount()) {
+    case 0: {
+        auto scope = DECLARE_THROW_SCOPE(globalObject->vm());
+        // not "requires" because "require" could be confusing
+        JSC::throwTypeError(
+            globalObject, scope,
+            "Module._resolveFilename needs 2+ arguments (a string)"_s);
+        scope.release();
+        return JSC::JSValue::encode(JSC::JSValue {});
+    }
+    default: {
+        JSC::JSValue moduleName = callFrame->argument(0);
+        JSC::JSValue fromValue = callFrame->argument(1);
+
+        if (moduleName.isUndefinedOrNull()) {
+            auto scope = DECLARE_THROW_SCOPE(globalObject->vm());
+            JSC::throwTypeError(globalObject, scope,
+                "Module._resolveFilename expects a string"_s);
+            scope.release();
+            return JSC::JSValue::encode(JSC::JSValue {});
+        }
+
+        if (
+            // fast path: it's a real CommonJS module object.
+            auto* cjs = jsDynamicCast<Bun::JSCommonJSModule*>(fromValue)) {
+            fromValue = cjs->id();
+        } else if
+            // slow path: userland code did something weird. lets let them do that
+            // weird thing.
+            (fromValue.isObject()) {
+
+            if (auto idValue = fromValue.getObject()->getIfPropertyExists(
+                    globalObject, builtinNames(vm).filenamePublicName())) {
+                if (idValue.isString()) {
+                    fromValue = idValue;
+                }
+            }
+        }
+
+        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));
+            return JSC::JSValue::encode(JSC::JSValue {});
+        }
+
+        scope.release();
+        return result;
+    }
+    }
+}
+
+JSC_DEFINE_CUSTOM_GETTER(nodeModuleResolveFilename,
+    (JSGlobalObject * lexicalGlobalObject,
+        EncodedJSValue thisValue,
+        PropertyName propertyName))
+{
+
+    auto* globalObject = defaultGlobalObject(lexicalGlobalObject);
+    return JSValue::encode(
+        globalObject->m_moduleResolveFilenameFunction.getInitializedOnMainThread(
+            globalObject));
+}
+
+JSC_DEFINE_CUSTOM_SETTER(setNodeModuleResolveFilename,
+    (JSGlobalObject * lexicalGlobalObject,
+        EncodedJSValue thisValue, EncodedJSValue encodedValue,
+        PropertyName propertyName))
+{
+    auto* globalObject = defaultGlobalObject(lexicalGlobalObject);
+    auto value = JSValue::decode(encodedValue);
+    if (value.isCell()) {
+        bool isOriginal = false;
+        if (value.isCallable()) {
+            JSC::CallData callData = JSC::getCallData(value);
+
+            if (callData.type == JSC::CallData::Type::Native) {
+                if (callData.native.function.untaggedPtr() == &jsFunctionResolveFileName) {
+                    isOriginal = true;
+                }
+            }
+        }
+        globalObject->hasOverridenModuleResolveFilenameFunction = !isOriginal;
+        globalObject->m_moduleResolveFilenameFunction.set(
+            lexicalGlobalObject->vm(), globalObject, value.asCell());
+    }
+
+    return true;
+}
+
+extern "C" bool ModuleLoader__isBuiltin(const char* data, size_t len);
+
+struct Parent {
+    JSArray* paths;
+    JSString* filename;
+};
+
+Parent getParent(VM& vm, JSGlobalObject* global, JSValue maybe_parent)
+{
+    Parent value { nullptr, nullptr };
+
+    if (!maybe_parent) {
+        return value;
+    }
+
+    auto parent = maybe_parent.getObject();
+    if (!parent) {
+        return value;
+    }
+
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    const auto& builtinNames = Bun::builtinNames(vm);
+    JSValue paths = parent->get(global, builtinNames.pathsPublicName());
+    RETURN_IF_EXCEPTION(scope, value);
+    if (paths.isCell()) {
+        value.paths = jsDynamicCast<JSArray*>(paths);
+    }
+
+    JSValue filename = parent->get(global, builtinNames.filenamePublicName());
+    RETURN_IF_EXCEPTION(scope, value);
+    if (filename.isString()) {
+        value.filename = filename.toString(global);
+    }
+    RELEASE_AND_RETURN(scope, value);
+}
+
+// https://github.com/nodejs/node/blob/40ef9d541ed79470977f90eb445c291b95ab75a0/lib/internal/modules/cjs/loader.js#L895
+JSC_DEFINE_HOST_FUNCTION(jsFunctionResolveLookupPaths,
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callFrame))
+{
+    auto& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    String request = callFrame->argument(0).toWTFString(globalObject);
+    RETURN_IF_EXCEPTION(scope, {});
+
+    auto utf8 = request.utf8();
+    if (ModuleLoader__isBuiltin(utf8.data(), utf8.length())) {
+        return JSC::JSValue::encode(JSC::jsNull());
+    }
+
+    auto parent = getParent(vm, globalObject, callFrame->argument(1));
+    RETURN_IF_EXCEPTION(scope, {});
+
+    // Check for node modules paths.
+    if (request.characterAt(0) != '.' || (request.length() > 1 && request.characterAt(1) != '.' && request.characterAt(1) != '/' &&
+#if OS(WINDOWS)
+            request.characterAt(1) != '\\'
+#else
+            true
+#endif
+            )) {
+        auto array = JSC::constructArray(
+            globalObject, (ArrayAllocationProfile*)nullptr, nullptr, 0);
+        if (parent.paths) {
+            auto len = parent.paths->length();
+            for (size_t i = 0; i < len; i++) {
+                auto path = parent.paths->getIndex(globalObject, i);
+                array->push(globalObject, path);
+            }
+        }
+        return JSValue::encode(array);
+    }
+
+    JSValue dirname;
+    if (parent.filename) {
+        EncodedJSValue encodedFilename = JSValue::encode(parent.filename);
+#if OS(WINDOWS)
+        dirname = JSValue::decode(
+            Bun__Path__dirname(globalObject, true, &encodedFilename, 1));
+#else
+        dirname = JSValue::decode(
+            Bun__Path__dirname(globalObject, false, &encodedFilename, 1));
+#endif
+    } else {
+        dirname = jsString(vm, String("."_s));
+    }
+
+    JSValue values[] = { dirname };
+    auto array = JSC::constructArray(
+        globalObject, (ArrayAllocationProfile*)nullptr, values, 1);
+    RELEASE_AND_RETURN(scope, JSValue::encode(array));
+}
+
+extern "C" JSC::EncodedJSValue NodeModuleModule__findPath(JSGlobalObject*,
+    BunString, JSArray*);
+
+JSC_DEFINE_HOST_FUNCTION(jsFunctionFindPath, (JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    JSC::VM& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    JSValue request_value = callFrame->argument(0);
+    JSValue paths_value = callFrame->argument(1);
+
+    String request = request_value.toWTFString(globalObject);
+    RETURN_IF_EXCEPTION(scope, {});
+    BunString request_bun_str = Bun::toString(request);
+
+    JSArray* paths = paths_value.isCell() ? jsDynamicCast<JSArray*>(paths_value) : nullptr;
+
+    return NodeModuleModule__findPath(globalObject, request_bun_str, paths);
+}
+
+// These two setters are only used if you directly hit
+// `Module.prototype.require` or `module.require`. When accessing the cjs
+// require argument, this is a bound version of `require`, which calls into the
+// overridden one.
+//
+// This require function also intentionally does not have .resolve on it, nor
+// does it have any of the other properties.
+//
+// Note: allowing require to be overridable at all is only needed for Next.js to
+// work (they do Module.prototype.require = ...)
+
+JSC_DEFINE_CUSTOM_GETTER(getterRequireFunction,
+    (JSC::JSGlobalObject * globalObject,
+        JSC::EncodedJSValue thisValue, JSC::PropertyName))
+{
+    return JSValue::encode(globalObject->getDirect(
+        globalObject->vm(), WebCore::clientData(globalObject->vm())->builtinNames().overridableRequirePrivateName()));
+}
+
+JSC_DEFINE_CUSTOM_SETTER(setterRequireFunction,
+    (JSC::JSGlobalObject * globalObject,
+        JSC::EncodedJSValue thisValue,
+        JSC::EncodedJSValue value,
+        JSC::PropertyName propertyName))
+{
+    globalObject->putDirect(globalObject->vm(),
+        WebCore::clientData(globalObject->vm())
+            ->builtinNames()
+            .overridableRequirePrivateName(),
+        JSValue::decode(value), 0);
+    return true;
+}
+
+static JSValue getModuleCacheObject(VM& vm, JSObject* moduleObject)
+{
+    return jsCast<Zig::GlobalObject*>(moduleObject->globalObject())
+        ->lazyRequireCacheObject();
+}
+
+static JSValue getModuleDebugObject(VM& vm, JSObject* moduleObject)
+{
+    return JSC::constructEmptyObject(moduleObject->globalObject());
+}
+
+static JSValue getPathCacheObject(VM& vm, JSObject* moduleObject)
+{
+    auto* globalObject = defaultGlobalObject(moduleObject->globalObject());
+    return JSC::constructEmptyObject(
+        vm, globalObject->nullPrototypeObjectStructure());
+}
+
+static JSValue getModuleExtensionsObject(VM& vm, JSObject* moduleObject)
+{
+    auto* globalObject = defaultGlobalObject(moduleObject->globalObject());
+    return globalObject->requireFunctionUnbound()->getIfPropertyExists(
+        globalObject, Identifier::fromString(vm, "extensions"_s));
+}
+
+static JSValue getSourceMapFunction(VM& vm, JSObject* moduleObject)
+{
+    auto* globalObject = defaultGlobalObject(moduleObject->globalObject());
+    JSFunction* sourceMapFunction = JSFunction::create(
+        vm, globalObject, 1, "SourceMap"_s, jsFunctionSourceMap,
+        ImplementationVisibility::Public, NoIntrinsic, jsFunctionSourceMap);
+    return sourceMapFunction;
+}
+
+static JSValue getBuiltinModulesObject(VM& vm, JSObject* moduleObject)
+{
+    MarkedArgumentBuffer args;
+    args.ensureCapacity(countof(builtinModuleNames));
+
+    for (unsigned i = 0; i < countof(builtinModuleNames); ++i) {
+        args.append(JSC::jsOwnedString(vm, String(builtinModuleNames[i])));
+    }
+
+    auto* globalObject = defaultGlobalObject(moduleObject->globalObject());
+    return JSC::constructArray(
+        globalObject, static_cast<JSC::ArrayAllocationProfile*>(nullptr),
+        JSC::ArgList(args));
+}
+
+static JSValue getConstantsObject(VM& vm, JSObject* moduleObject)
+{
+    auto* globalObject = defaultGlobalObject(moduleObject->globalObject());
+    auto* compileCacheStatus = JSC::constructEmptyObject(
+        vm, globalObject->nullPrototypeObjectStructure());
+    compileCacheStatus->putDirect(vm, JSC::Identifier::fromString(vm, "FAILED"_s),
+        JSC::jsNumber(0));
+    compileCacheStatus->putDirect(
+        vm, JSC::Identifier::fromString(vm, "ENABLED"_s), JSC::jsNumber(1));
+    compileCacheStatus->putDirect(
+        vm, JSC::Identifier::fromString(vm, "ALREADY_ENABLED"_s),
+        JSC::jsNumber(2));
+    compileCacheStatus->putDirect(
+        vm, JSC::Identifier::fromString(vm, "DISABLED"_s), JSC::jsNumber(3));
+
+    auto* constantsObject = JSC::constructEmptyObject(
+        vm, globalObject->nullPrototypeObjectStructure());
+    constantsObject->putDirect(
+        vm, JSC::Identifier::fromString(vm, "compileCacheStatus"_s),
+        compileCacheStatus);
+    return constantsObject;
+}
+
+static JSValue getGlobalPathsObject(VM& vm, JSObject* moduleObject)
+{
+    return JSC::constructEmptyArray(
+        moduleObject->globalObject(),
+        static_cast<ArrayAllocationProfile*>(nullptr), 0);
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunctionInitPaths, (JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    return JSC::JSValue::encode(JSC::jsUndefined());
+}
+
+static JSValue getModulePrototypeObject(VM& vm, JSObject* moduleObject)
+{
+    auto* globalObject = defaultGlobalObject(moduleObject->globalObject());
+    auto prototype = constructEmptyObject(globalObject, globalObject->objectPrototype(), 2);
+
+    prototype->putDirectCustomAccessor(
+        vm, WebCore::clientData(vm)->builtinNames().requirePublicName(),
+        JSC::CustomGetterSetter::create(vm, getterRequireFunction,
+            setterRequireFunction),
+        0);
+
+    return prototype;
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunctionLoad, (JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    return JSC::JSValue::encode(JSC::jsUndefined());
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunctionRunMain, (JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    return JSC::JSValue::encode(JSC::jsUndefined());
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunctionPreloadModules,
+    (JSGlobalObject * globalObject,
+        JSC::CallFrame* callFrame))
+{
+    return JSC::JSValue::encode(JSC::jsUndefined());
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunctionSyncBuiltinESMExports,
+    (JSGlobalObject * globalObject,
+        JSC::CallFrame* callFrame))
+{
+    return JSC::JSValue::encode(JSC::jsUndefined());
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunctionRegister, (JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    return JSC::JSValue::encode(JSC::jsUndefined());
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunctionEnableCompileCache,
+    (JSGlobalObject * globalObject,
+        JSC::CallFrame* callFrame))
+{
+    return JSC::JSValue::encode(JSC::jsUndefined());
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunctionGetCompileCacheDir,
+    (JSGlobalObject * globalObject,
+        JSC::CallFrame* callFrame))
+{
+    return JSC::JSValue::encode(JSC::jsUndefined());
+}
+
+static JSValue getModuleObject(VM& vm, JSObject* moduleObject)
+{
+    return moduleObject;
+}
+
+/* Source for NodeModuleModule.lut.h
+@begin nodeModuleObjectTable
+_cache                  getModuleCacheObject              PropertyCallback
+_debug                  getModuleDebugObject              PropertyCallback
+_extensions             getModuleExtensionsObject         PropertyCallback
+_findPath                jsFunctionFindPath                Function 3
+_initPaths              jsFunctionInitPaths               Function 0
+_load                   jsFunctionLoad                    Function 1
+_nodeModulePaths        Resolver__nodeModulePathsForJS    Function 1
+_pathCache              getPathCacheObject                PropertyCallback
+_preloadModules         jsFunctionPreloadModules          Function 0
+_resolveFilename        nodeModuleResolveFilename         CustomAccessor
+_resolveLookupPaths     jsFunctionResolveLookupPaths      Function 2
+builtinModules          getBuiltinModulesObject           PropertyCallback
+constants               getConstantsObject                PropertyCallback
+createRequire           jsFunctionNodeModuleCreateRequire Function 1
+enableCompileCache      jsFunctionEnableCompileCache      Function 0
+findSourceMap            jsFunctionFindSourceMap           Function 0
+getCompileCacheDir      jsFunctionGetCompileCacheDir      Function 0
+globalPaths             getGlobalPathsObject              PropertyCallback
+isBuiltin               jsFunctionIsBuiltinModule         Function 1
+prototype               getModulePrototypeObject          PropertyCallback
+register                jsFunctionRegister                Function 1
+runMain                 jsFunctionRunMain                 Function 0
+SourceMap               getSourceMapFunction              PropertyCallback
+syncBuiltinESMExports   jsFunctionSyncBuiltinESMExports   Function 0
+wrap                    jsFunctionWrap                    Function 1
+Module                  getModuleObject                   PropertyCallback
+@end
+*/
+#include "NodeModuleModule.lut.h"
+
+class JSModuleConstructor : public JSC::InternalFunction {
+    using Base = JSC::InternalFunction;
+
+public:
+    DECLARE_EXPORT_INFO;
+    static constexpr bool needsDestruction = false;
+    static constexpr unsigned StructureFlags = Base::StructureFlags | HasStaticPropertyTable;
+
+    static JSC::Structure* createStructure(JSC::VM& vm,
+        JSC::JSGlobalObject* globalObject,
+        JSC::JSValue prototype)
+    {
+        ASSERT(globalObject);
+        return JSC::Structure::create(
+            vm, globalObject, prototype,
+            JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
+    }
+
+    template<typename CellType, JSC::SubspaceAccess>
+    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+    {
+        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSModuleConstructor, Base);
+        return &vm.internalFunctionSpace();
+    }
+
+    static JSModuleConstructor* create(JSC::VM& vm,
+        Zig::GlobalObject* globalObject)
+    {
+        auto* structure = createStructure(vm, globalObject, globalObject->functionPrototype());
+
+        auto* moduleConstructor = new (NotNull, JSC::allocateCell<JSModuleConstructor>(vm))
+            JSModuleConstructor(vm, structure);
+        moduleConstructor->finishCreation(vm);
+        return moduleConstructor;
+    }
+
+private:
+    JSModuleConstructor(JSC::VM& vm, JSC::Structure* structure)
+        : Base(vm, structure, jsFunctionNodeModuleModuleCall,
+              jsFunctionNodeModuleModuleConstructor)
+    {
+    }
+
+    void finishCreation(JSC::VM& vm)
+    {
+        Base::finishCreation(vm, 1, "Module"_s,
+            PropertyAdditionMode::WithoutStructureTransition);
+    }
+};
+
+const JSC::ClassInfo JSModuleConstructor::s_info = {
+    "Module"_s, &Base::s_info, &nodeModuleObjectTable, nullptr,
+    CREATE_METHOD_TABLE(JSModuleConstructor)
+};
+
+void addNodeModuleConstructorProperties(JSC::VM& vm,
+    Zig::GlobalObject* globalObject)
+{
+    globalObject->m_nodeModuleConstructor.initLater(
+        [](const Zig::GlobalObject::Initializer<JSObject>& init) {
+            JSObject* moduleConstructor = JSModuleConstructor::create(
+                init.vm, static_cast<Zig::GlobalObject*>(init.owner));
+            init.set(moduleConstructor);
+        });
+
+    globalObject->m_moduleResolveFilenameFunction.initLater(
+        [](const Zig::GlobalObject::Initializer<JSCell>& init) {
+            JSFunction* resolveFilenameFunction = JSFunction::create(
+                init.vm, init.owner, 2, "_resolveFilename"_s,
+                jsFunctionResolveFileName, JSC::ImplementationVisibility::Public,
+                JSC::NoIntrinsic, jsFunctionResolveFileName);
+            init.set(resolveFilenameFunction);
+        });
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunctionIsModuleResolveFilenameSlowPathEnabled,
+    (JSGlobalObject * globalObject,
+        CallFrame* callframe))
+{
+    return JSValue::encode(
+        jsBoolean(defaultGlobalObject(globalObject)
+                      ->hasOverridenModuleResolveFilenameFunction));
+}
+
+} // namespace Bun
+
+namespace Zig {
+void generateNativeModule_NodeModule(JSC::JSGlobalObject* lexicalGlobalObject,
+    JSC::Identifier moduleKey,
+    Vector<JSC::Identifier, 4>& exportNames,
+    JSC::MarkedArgumentBuffer& exportValues)
+{
+    Zig::GlobalObject* globalObject = defaultGlobalObject(lexicalGlobalObject);
+    auto& vm = globalObject->vm();
+    auto catchScope = DECLARE_CATCH_SCOPE(vm);
+    auto* constructor = globalObject->m_nodeModuleConstructor.getInitializedOnMainThread(
+        globalObject);
+    if (constructor->hasNonReifiedStaticProperties()) {
+        constructor->reifyAllStaticProperties(globalObject);
+        if (catchScope.exception()) {
+            catchScope.clearException();
+        }
+    }
+
+    exportNames.reserveCapacity(Bun::countof(Bun::nodeModuleObjectTableValues) + 1);
+    exportValues.ensureCapacity(Bun::countof(Bun::nodeModuleObjectTableValues) + 1);
+
+    for (unsigned i = 0; i < Bun::countof(Bun::nodeModuleObjectTableValues);
+         ++i) {
+        const auto& entry = Bun::nodeModuleObjectTableValues[i];
+        const auto& property = Identifier::fromString(vm, entry.m_key);
+        JSValue value = constructor->getIfPropertyExists(globalObject, property);
+
+        if (UNLIKELY(catchScope.exception())) {
+            value = {};
+            catchScope.clearException();
+        }
+        if (UNLIKELY(value.isEmpty())) {
+            value = JSC::jsUndefined();
+        }
+
+        exportNames.append(property);
+        exportValues.append(value);
+    }
+
+    exportNames.append(vm.propertyNames->defaultKeyword);
+    exportValues.append(constructor);
+}
+
+} // namespace Zig
diff --git a/src/bun.js/modules/NodeModuleModule.h b/src/bun.js/modules/NodeModuleModule.h
index e825170848..6750ff5ad5 100644
--- a/src/bun.js/modules/NodeModuleModule.h
+++ b/src/bun.js/modules/NodeModuleModule.h
@@ -1,559 +1,33 @@
 // clang-format off
 #pragma once
 
+#include "root.h"
+
 #include "CommonJSModuleRecord.h"
 #include "ImportMetaObject.h"
 #include "JavaScriptCore/ArgList.h"
+#include "JavaScriptCore/JSCJSValue.h"
 #include "JavaScriptCore/JSGlobalObjectInlines.h"
 #include "_NativeModule.h"
 #include "isBuiltinModule.h"
 #include <JavaScriptCore/JSBoundFunction.h>
 #include <JavaScriptCore/ObjectConstructor.h>
-#include "PathInlines.h"
 
 using namespace Zig;
 using namespace JSC;
 
-// This is a mix of bun's builtin module names and also the ones reported by
-// node v20.4.0
-static constexpr ASCIILiteral builtinModuleNames[] = {
-    "_http_agent"_s,
-    "_http_client"_s,
-    "_http_common"_s,
-    "_http_incoming"_s,
-    "_http_outgoing"_s,
-    "_http_server"_s,
-    "_stream_duplex"_s,
-    "_stream_passthrough"_s,
-    "_stream_readable"_s,
-    "_stream_transform"_s,
-    "_stream_wrap"_s,
-    "_stream_writable"_s,
-    "_tls_common"_s,
-    "_tls_wrap"_s,
-    "assert"_s,
-    "assert/strict"_s,
-    "async_hooks"_s,
-    "buffer"_s,
-    "bun"_s,
-    "bun:ffi"_s,
-    "bun:jsc"_s,
-    "bun:sqlite"_s,
-    "bun:test"_s,
-    "bun:wrap"_s,
-    "child_process"_s,
-    "cluster"_s,
-    "console"_s,
-    "constants"_s,
-    "crypto"_s,
-    "detect-libc"_s,
-    "dgram"_s,
-    "diagnostics_channel"_s,
-    "dns"_s,
-    "dns/promises"_s,
-    "domain"_s,
-    "events"_s,
-    "fs"_s,
-    "fs/promises"_s,
-    "http"_s,
-    "http2"_s,
-    "https"_s,
-    "inspector"_s,
-    "inspector/promises"_s,
-    "module"_s,
-    "net"_s,
-    "os"_s,
-    "path"_s,
-    "path/posix"_s,
-    "path/win32"_s,
-    "perf_hooks"_s,
-    "process"_s,
-    "punycode"_s,
-    "querystring"_s,
-    "readline"_s,
-    "readline/promises"_s,
-    "repl"_s,
-    "stream"_s,
-    "stream/consumers"_s,
-    "stream/promises"_s,
-    "stream/web"_s,
-    "string_decoder"_s,
-    "sys"_s,
-    "timers"_s,
-    "timers/promises"_s,
-    "tls"_s,
-    "trace_events"_s,
-    "tty"_s,
-    "undici"_s,
-    "url"_s,
-    "util"_s,
-    "util/types"_s,
-    "v8"_s,
-    "vm"_s,
-    "wasi"_s,
-    "worker_threads"_s,
-    "ws"_s,
-    "zlib"_s,
-};
 
-JSC_DEFINE_HOST_FUNCTION(jsFunctionDebugNoop, (JSC::JSGlobalObject * globalObject, JSC::CallFrame *callFrame)) {
-  return JSValue::encode(jsUndefined());
-}
-
-JSC_DEFINE_HOST_FUNCTION(jsFunctionNodeModuleModuleConstructor, (JSC::JSGlobalObject * globalObject, JSC::CallFrame *callFrame)) {
-  // In node, this is supposed to be the actual CommonJSModule constructor.
-  // We are cutting a huge corner by not doing all that work.
-  // This code is only to support babel.
-  JSC::VM &vm = globalObject->vm();
-  JSString *idString = JSC::jsString(vm, WTF::String("."_s));
-
-  JSString *dirname = jsEmptyString(vm);
-
-  // TODO: handle when JSGlobalObject !== Zig::GlobalObject, such as in node:vm
-  Structure *structure = static_cast<Zig::GlobalObject *>(globalObject)
-                             ->CommonJSModuleObjectStructure();
-
-  // TODO: handle ShadowRealm, node:vm, new.target, subclasses
-  JSValue idValue = callFrame->argument(0);
-  JSValue parentValue = callFrame->argument(1);
-
-  auto scope = DECLARE_THROW_SCOPE(vm);
-  if (idValue.isString()) {
-    idString = idValue.toString(globalObject);
-    RETURN_IF_EXCEPTION(scope, {});
-
-    auto index = idString->tryGetValue()->reverseFind('/', idString->length());
-
-    if (index != WTF::notFound) {
-      dirname = JSC::jsSubstring(globalObject, idString, 0, index);
-    }
-  }
-
-  auto *out = Bun::JSCommonJSModule::create(vm, structure, idString, jsNull(),
-                                            dirname, SourceCode());
-
-  if (!parentValue.isUndefined()) {
-    out->putDirect(vm, JSC::Identifier::fromString(vm, "parent"_s), parentValue, 0);
-  }
-
-  out->putDirect(
-    vm,
-    JSC::Identifier::fromString(vm, "exports"_s),
-    JSC::constructEmptyObject(globalObject, globalObject->objectPrototype(), 0),
-    0
-  );
-
-  return JSValue::encode(out);
-}
-
-JSC_DEFINE_HOST_FUNCTION(jsFunctionIsBuiltinModule, (JSC::JSGlobalObject * globalObject, JSC::CallFrame *callFrame)) {
-  JSC::VM &vm = globalObject->vm();
-  auto scope = DECLARE_THROW_SCOPE(vm);
-  JSValue moduleName = callFrame->argument(0);
-  if (!moduleName.isString()) {
-    return JSValue::encode(jsBoolean(false));
-  }
-
-  auto moduleStr = moduleName.toWTFString(globalObject);
-  RETURN_IF_EXCEPTION(scope, JSValue::encode(jsBoolean(false)));
-
-  return JSValue::encode(jsBoolean(Bun::isBuiltinModule(moduleStr)));
-}
-
-JSC_DEFINE_HOST_FUNCTION(jsFunctionWrap, (JSC::JSGlobalObject * globalObject,
-                                          JSC::CallFrame *callFrame)) {
-  auto &vm = globalObject->vm();
-  auto scope = DECLARE_THROW_SCOPE(vm);
-  JSString *code = callFrame->argument(0).toStringOrNull(globalObject);
-  RETURN_IF_EXCEPTION(scope, {});
-  if (!code) {
-    return JSC::JSValue::encode(JSC::jsUndefined());
-  }
-
-  JSString *prefix = jsString(vm, String( "(function (exports, require, module, __filename, __dirname) { "_s));
-  JSString *suffix = jsString(vm, String("\n});"_s));
-
-  return JSValue::encode(jsString(globalObject, prefix, code, suffix));
-}
-
-JSC_DEFINE_HOST_FUNCTION(jsFunctionNodeModuleCreateRequire,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callFrame)) {
-  JSC::VM &vm = globalObject->vm();
-  auto scope = DECLARE_THROW_SCOPE(vm);
-  if (callFrame->argumentCount() < 1) {
-    throwTypeError(globalObject, scope,
-                   "createRequire() requires at least one argument"_s);
-    RELEASE_AND_RETURN(scope, JSC::JSValue::encode({}));
-  }
-
-  auto val = callFrame->uncheckedArgument(0).toWTFString(globalObject);
-
-  if (val.startsWith("file://"_s)) {
-    WTF::URL url(val);
-    if (!url.isValid()) {
-      throwTypeError(globalObject, scope,
-                     makeString("createRequire() was given an invalid URL '"_s,
-                                url.string(), "'"_s));
-      RELEASE_AND_RETURN(scope, JSValue::encode({}));
-    }
-    if (!url.protocolIsFile()) {
-      throwTypeError(globalObject, scope,
-                     "createRequire() does not support non-file URLs"_s);
-      RELEASE_AND_RETURN(scope, JSValue::encode({}));
-    }
-    val = url.fileSystemPath();
-  }
-
-  RETURN_IF_EXCEPTION(scope, {});
-  RELEASE_AND_RETURN(
-      scope, JSValue::encode(Bun::JSCommonJSModule::createBoundRequireFunction(
-                 vm, globalObject, val)));
-}
-BUN_DECLARE_HOST_FUNCTION(Resolver__nodeModulePathsForJS);
-
-JSC_DEFINE_HOST_FUNCTION(jsFunctionFindSourceMap, (JSGlobalObject * globalObject, CallFrame *callFrame)) {
-  auto &vm = globalObject->vm();
-  auto scope = DECLARE_THROW_SCOPE(vm);
-  throwException(globalObject, scope, createError(globalObject, "module.SourceMap is not yet implemented in Bun"_s));
-  return {};
-}
-
-JSC_DEFINE_HOST_FUNCTION(jsFunctionSyncBuiltinExports,
-                         (JSGlobalObject * globalObject,
-                          CallFrame *callFrame)) {
-  return JSValue::encode(jsUndefined());
-}
-
-JSC_DEFINE_HOST_FUNCTION(jsFunctionSourceMap, (JSGlobalObject * globalObject, CallFrame *callFrame)) {
-  auto &vm = globalObject->vm();
-  auto scope = DECLARE_THROW_SCOPE(vm);
-  throwException(globalObject, scope,
-                 createError(globalObject, "Not implemented"_s));
-  return {};
-}
-
-JSC_DEFINE_HOST_FUNCTION(jsFunctionResolveFileName, (JSC::JSGlobalObject * globalObject, JSC::CallFrame *callFrame)) {
-  JSC::VM &vm = globalObject->vm();
-
-  switch (callFrame->argumentCount()) {
-  case 0: {
-    auto scope = DECLARE_THROW_SCOPE(globalObject->vm());
-    // not "requires" because "require" could be confusing
-    JSC::throwTypeError(
-        globalObject, scope,
-        "Module._resolveFilename needs 2+ arguments (a string)"_s);
-    scope.release();
-    return JSC::JSValue::encode(JSC::JSValue{});
-  }
-  default: {
-    JSC::JSValue moduleName = callFrame->argument(0);
-    JSC::JSValue fromValue = callFrame->argument(1);
-
-    if (moduleName.isUndefinedOrNull()) {
-      auto scope = DECLARE_THROW_SCOPE(globalObject->vm());
-      JSC::throwTypeError(globalObject, scope,
-                          "Module._resolveFilename expects a string"_s);
-      scope.release();
-      return JSC::JSValue::encode(JSC::JSValue{});
-    }
-
-    if (
-        // fast path: it's a real CommonJS module object.
-        auto *cjs = jsDynamicCast<Bun::JSCommonJSModule *>(fromValue)) {
-      fromValue = cjs->id();
-    } else if
-        // slow path: userland code did something weird. lets let them do that
-        // weird thing.
-        (fromValue.isObject()) {
-
-      if (auto idValue = fromValue.getObject()->getIfPropertyExists(globalObject, builtinNames(vm).filenamePublicName())) {
-        if (idValue.isString()) {
-          fromValue = idValue;
-        }
-      }
-    }
-
-    auto result = Bun__resolveSync(globalObject, JSC::JSValue::encode(moduleName), JSValue::encode(fromValue), false);
-    auto scope = DECLARE_THROW_SCOPE(globalObject->vm());
-
-    if (!JSC::JSValue::decode(result).isString()) {
-      JSC::throwException(globalObject, scope, JSC::JSValue::decode(result));
-      return JSC::JSValue::encode(JSC::JSValue{});
-    }
-
-    scope.release();
-    return result;
-  }
-  }
-}
-template <std::size_t N, class T> consteval std::size_t countof(T (&)[N]) {
-  return N;
-}
-
-JSC_DEFINE_CUSTOM_GETTER(get_resolveFilename, (JSGlobalObject * globalObject,
-                                               EncodedJSValue thisValue,
-                                               PropertyName propertyName)) {
-  auto override = static_cast<Zig::GlobalObject *>(globalObject)
-                      ->m_nodeModuleOverriddenResolveFilename.get();
-  if (override) {
-    return JSValue::encode(override);
-  }
-  // Instead of storing the original function on the global object and have
-  // those extra bytes, just have it be a property alias.
-  JSObject *thisObject = JSValue::decode(thisValue).getObject();
-  if (!thisObject)
-    return JSValue::encode(jsUndefined());
-  auto &vm = globalObject->vm();
-  return JSValue::encode(thisObject->getDirect(
-      vm, Identifier::fromString(vm, "__resolveFilename"_s)));
-}
-
-JSC_DEFINE_CUSTOM_SETTER(set_resolveFilename,
-                         (JSGlobalObject * globalObject,
-                          EncodedJSValue thisValue, EncodedJSValue value,
-                          PropertyName propertyName)) {
-  auto valueJS = JSValue::decode(value);
-  if (valueJS.isCell()) {
-    if (auto fn = jsDynamicCast<JSFunction *>(valueJS.asCell())) {
-      static_cast<Zig::GlobalObject *>(globalObject)
-          ->m_nodeModuleOverriddenResolveFilename.set(globalObject->vm(),
-                                                      globalObject, fn);
-      return true;
-    }
-  }
-  return false;
-}
-
-extern "C" bool ModuleLoader__isBuiltin(const char* data, size_t len);
-
-struct Parent {
-  JSArray* paths;
-  JSString* filename;
-};
-
-Parent getParent(VM&vm, JSGlobalObject* global, JSValue maybe_parent) {
-  Parent value { nullptr, nullptr };
-
-  if (!maybe_parent) {
-    return value;
-  }
-  
-  auto parent = maybe_parent.getObject();
-  if (!parent) {
-    return value;
-  }
-
-  auto scope = DECLARE_THROW_SCOPE(vm);
-  const auto& builtinNames = Bun::builtinNames(vm);
-  JSValue paths = parent->get(global, builtinNames.pathsPublicName());
-  RETURN_IF_EXCEPTION(scope, value);
-  if (paths.isCell()) {
-    value.paths = jsDynamicCast<JSArray*>(paths);
-  }
-
-  JSValue filename = parent->get(global, builtinNames.filenamePublicName());
-  RETURN_IF_EXCEPTION(scope, value);
-  if (filename.isString()) {
-    value.filename = filename.toString(global);
-  }
-  RELEASE_AND_RETURN(scope, value);
-}
-
-// https://github.com/nodejs/node/blob/40ef9d541ed79470977f90eb445c291b95ab75a0/lib/internal/modules/cjs/loader.js#L895
-JSC_DEFINE_HOST_FUNCTION(jsFunctionResolveLookupPaths, (JSC::JSGlobalObject * globalObject, JSC::CallFrame *callFrame)) {
-  auto &vm = globalObject->vm();
-  auto scope = DECLARE_THROW_SCOPE(vm);
-  
-  String request = callFrame->argument(0).toWTFString(globalObject);
-  RETURN_IF_EXCEPTION(scope, {});
-
-  auto utf8 = request.utf8();
-  if(ModuleLoader__isBuiltin(utf8.data(), utf8.length())) {
-    return JSC::JSValue::encode(JSC::jsNull());
-  }
-
-  auto parent = getParent(vm, globalObject, callFrame->argument(1));
-  RETURN_IF_EXCEPTION(scope, {});
-
-  // Check for node modules paths.
-  if (
-    request.characterAt(0) != '.' ||
-    (request.length() > 1 &&
-      request.characterAt(1) != '.' &&
-      request.characterAt(1) != '/' &&
-#if OS(WINDOWS)
-      request.characterAt(1) != '\\'
-#else
-      true
-#endif
-    )
-  ) {
-    auto array = JSC::constructArray(globalObject, (ArrayAllocationProfile*)nullptr, nullptr, 0);
-    if (parent.paths) {
-      auto len = parent.paths->length();
-      for (size_t i = 0; i < len; i++) {
-        auto path = parent.paths->getIndex(globalObject, i);
-        array->push(globalObject, path);
-      }
-    }
-    return JSValue::encode(array);
-  }
-
-  JSValue dirname;
-  if (parent.filename) {
-    EncodedJSValue encodedFilename = JSValue::encode(parent.filename);
-#if OS(WINDOWS)
-    dirname = JSValue::decode(Bun__Path__dirname(globalObject, true, &encodedFilename, 1));
-#else
-    dirname = JSValue::decode(Bun__Path__dirname(globalObject, false, &encodedFilename, 1));
-#endif
-  } else {
-    dirname = jsString(vm, String("."_s));
-  }
-
-  JSValue values[] = { dirname };
-  auto array = JSC::constructArray(
-    globalObject,
-    (ArrayAllocationProfile*)nullptr,
-    values,
-    1
-  );
-  RELEASE_AND_RETURN(scope, JSValue::encode(array));
-}
-
-extern "C" JSC::EncodedJSValue NodeModuleModule__findPath(JSGlobalObject*, BunString, JSArray*);
-
-JSC_DEFINE_HOST_FUNCTION(jsFunctionFindPath, (JSGlobalObject * globalObject, JSC::CallFrame *callFrame)) {
-  JSC::VM &vm = globalObject->vm();
-  auto scope = DECLARE_THROW_SCOPE(vm);
-
-  JSValue request_value = callFrame->argument(0);
-  JSValue paths_value = callFrame->argument(1);
-  
-  String request = request_value.toWTFString(globalObject);
-  RETURN_IF_EXCEPTION(scope, {});
-  BunString request_bun_str = Bun::toString(request);
-
-  JSArray* paths = paths_value.isCell() ? jsDynamicCast<JSArray*>(paths_value) : nullptr;
-
-  return NodeModuleModule__findPath(globalObject, request_bun_str, paths);
-}
-
-// These two setters are only used if you directly hit
-// `Module.prototype.require` or `module.require`. When accessing the cjs
-// require argument, this is a bound version of `require`, which calls into the
-// overridden one.
-//
-// This require function also intentionally does not have .resolve on it, nor
-// does it have any of the other properties.
-//
-// Note: allowing require to be overridable at all is only needed for Next.js to
-// work (they do Module.prototype.require = ...)
-
-JSC_DEFINE_CUSTOM_GETTER(getterRequireFunction,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::EncodedJSValue thisValue, JSC::PropertyName)) {
-  return JSValue::encode(globalObject->getDirect(
-      globalObject->vm(), WebCore::clientData(globalObject->vm())
-                              ->builtinNames()
-                              .overridableRequirePrivateName()));
-}
-
-JSC_DEFINE_CUSTOM_SETTER(setterRequireFunction,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::EncodedJSValue thisValue,
-                          JSC::EncodedJSValue value,
-                          JSC::PropertyName propertyName)) {
-  globalObject->putDirect(globalObject->vm(),
-                          WebCore::clientData(globalObject->vm())
-                              ->builtinNames()
-                              .overridableRequirePrivateName(),
-                          JSValue::decode(value), 0);
-  return true;
+namespace Bun {
+  JSC_DECLARE_HOST_FUNCTION(jsFunctionIsModuleResolveFilenameSlowPathEnabled);
+  void addNodeModuleConstructorProperties(JSC::VM &vm, Zig::GlobalObject *globalObject);
 }
 
 namespace Zig {
 
-DEFINE_NATIVE_MODULE(NodeModule) {
-  // the default object here is a function, so we cant use the
-  // INIT_NATIVE_MODULE helper
-  Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject *>(lexicalGlobalObject);
-  JSC::VM &vm = globalObject->vm();
-  JSC::JSObject *defaultObject = JSC::JSFunction::create(
-      vm, globalObject, 0, "Module"_s, jsFunctionNodeModuleModuleConstructor,
-      JSC::ImplementationVisibility::Public, JSC::NoIntrinsic,
-      jsFunctionNodeModuleModuleConstructor);
-  auto put = [&](JSC::Identifier name, JSC::JSValue value) {
-    defaultObject->putDirect(vm, name, value);
-    exportNames.append(name);
-    exportValues.append(value);
-  };
-  auto putNativeFn = [&](JSC::Identifier name, JSC::NativeFunction ptr) {
-    JSC::JSFunction *value = JSC::JSFunction::create(
-        vm, globalObject, 1, name.string(), ptr,
-        JSC::ImplementationVisibility::Public, JSC::NoIntrinsic, ptr);
-    defaultObject->putDirect(vm, name, value);
-    exportNames.append(name);
-    exportValues.append(value);
-  };
-  exportNames.reserveCapacity(16);
-  exportValues.ensureCapacity(16);
-  exportNames.append(vm.propertyNames->defaultKeyword);
-  exportValues.append(defaultObject);
+void generateNativeModule_NodeModule(                                     
+  JSC::JSGlobalObject *lexicalGlobalObject, JSC::Identifier moduleKey,     
+  Vector<JSC::Identifier, 4> &exportNames,
+  JSC::MarkedArgumentBuffer &exportValues);  
 
-  put(Identifier::fromString(vm, "Module"_s), defaultObject);
-
-  // Module._extensions === require.extensions
-  put(
-    Identifier::fromString(vm, "_extensions"_s),
-    globalObject->requireFunctionUnbound()->get( globalObject, Identifier::fromString(vm, "extensions"_s))
-  );
-
-  defaultObject->putDirectCustomAccessor(
-    vm,
-    JSC::Identifier::fromString(vm, "_resolveFilename"_s),
-    JSC::CustomGetterSetter::create(vm, get_resolveFilename, set_resolveFilename),
-    JSC::PropertyAttribute::CustomAccessor | 0
-  );
-
-  putNativeFn(Identifier::fromString(vm, "__resolveFilename"_s), jsFunctionResolveFileName);
-  putNativeFn(Identifier::fromString(vm, "_resolveLookupPaths"_s), jsFunctionResolveLookupPaths);
-
-  putNativeFn(Identifier::fromString(vm, "createRequire"_s), jsFunctionNodeModuleCreateRequire);
-  putNativeFn(builtinNames(vm).pathsPublicName(), Resolver__nodeModulePathsForJS);
-  putNativeFn(Identifier::fromString(vm, "findSourceMap"_s), jsFunctionFindSourceMap);
-  putNativeFn(Identifier::fromString(vm, "syncBuiltinExports"_s), jsFunctionSyncBuiltinExports);
-  putNativeFn(Identifier::fromString(vm, "SourceMap"_s), jsFunctionSourceMap);
-  putNativeFn(Identifier::fromString(vm, "isBuiltin"_s), jsFunctionIsBuiltinModule);
-  putNativeFn(Identifier::fromString(vm, "_nodeModulePaths"_s), Resolver__nodeModulePathsForJS);
-  putNativeFn(Identifier::fromString(vm, "wrap"_s), jsFunctionWrap);
-
-  put(Identifier::fromString(vm, "_cache"_s), jsCast<Zig::GlobalObject *>(globalObject)->lazyRequireCacheObject());
-  put(Identifier::fromString(vm, "globalPaths"_s), constructEmptyArray(globalObject, nullptr, 0));
-
-  auto prototype = constructEmptyObject(globalObject, globalObject->objectPrototype(), 1);
-  prototype->putDirectCustomAccessor(
-    vm, WebCore::clientData(vm)->builtinNames().requirePublicName(),
-    JSC::CustomGetterSetter::create(
-      vm,
-      getterRequireFunction,
-      setterRequireFunction
-    ),
-    0
-  );
-
-  defaultObject->putDirect(vm, vm.propertyNames->prototype, prototype);
-
-  MarkedArgumentBuffer args;
-  args.ensureCapacity(countof(builtinModuleNames));
-
-  for (unsigned i = 0; i < countof(builtinModuleNames); ++i) {
-    args.append(JSC::jsOwnedString(vm, String(builtinModuleNames[i])));
-  }
-
-
-  put(JSC::Identifier::fromString(vm, "builtinModules"_s), JSC::constructArray(globalObject, static_cast<JSC::ArrayAllocationProfile*>(nullptr), JSC::ArgList(args)));
-}
 
 } // namespace Zig
diff --git a/src/bun.js/modules/NodeProcessModule.h b/src/bun.js/modules/NodeProcessModule.h
index 9058c00108..edde3fa5e5 100644
--- a/src/bun.js/modules/NodeProcessModule.h
+++ b/src/bun.js/modules/NodeProcessModule.h
@@ -6,69 +6,72 @@
 namespace Zig {
 
 JSC_DEFINE_HOST_FUNCTION(jsFunctionProcessModuleCommonJS,
-                         (JSGlobalObject * globalObject,
-                          CallFrame *callFrame)) {
+    (JSGlobalObject * globalObject,
+        CallFrame* callFrame))
+{
 
-  return JSValue::encode(
-      reinterpret_cast<Zig::GlobalObject *>(globalObject)->processObject());
+    return JSValue::encode(
+        reinterpret_cast<Zig::GlobalObject*>(globalObject)->processObject());
 }
 
 JSC_DEFINE_CUSTOM_GETTER(jsFunctionProcessModuleCommonJSGetter,
-                         (JSGlobalObject * globalObject,
-                          JSC::EncodedJSValue thisValue,
-                          PropertyName propertyName)) {
+    (JSGlobalObject * globalObject,
+        JSC::EncodedJSValue thisValue,
+        PropertyName propertyName))
+{
 
-  return JSValue::encode(reinterpret_cast<Zig::GlobalObject *>(globalObject)
-                             ->processObject()
-                             ->get(globalObject, propertyName));
+    return JSValue::encode(reinterpret_cast<Zig::GlobalObject*>(globalObject)
+                               ->processObject()
+                               ->get(globalObject, propertyName));
 }
 
 JSC_DEFINE_CUSTOM_SETTER(jsFunctionProcessModuleCommonJSSetter,
-                         (JSGlobalObject * globalObject,
-                          JSC::EncodedJSValue thisValue,
-                          JSC::EncodedJSValue encodedValue,
-                          PropertyName propertyName)) {
-  VM &vm = globalObject->vm();
+    (JSGlobalObject * globalObject,
+        JSC::EncodedJSValue thisValue,
+        JSC::EncodedJSValue encodedValue,
+        PropertyName propertyName))
+{
+    VM& vm = globalObject->vm();
 
-  return reinterpret_cast<Zig::GlobalObject *>(globalObject)
-      ->processObject()
-      ->putDirect(vm, propertyName, JSValue::decode(encodedValue), 0);
+    return reinterpret_cast<Zig::GlobalObject*>(globalObject)
+        ->processObject()
+        ->putDirect(vm, propertyName, JSValue::decode(encodedValue), 0);
 }
 
-DEFINE_NATIVE_MODULE(NodeProcess) {
-  JSC::VM &vm = lexicalGlobalObject->vm();
-  GlobalObject *globalObject =
-      reinterpret_cast<GlobalObject *>(lexicalGlobalObject);
+DEFINE_NATIVE_MODULE(NodeProcess)
+{
+    JSC::VM& vm = lexicalGlobalObject->vm();
+    GlobalObject* globalObject = reinterpret_cast<GlobalObject*>(lexicalGlobalObject);
 
-  JSC::JSObject *process = globalObject->processObject();
-  auto scope = DECLARE_THROW_SCOPE(vm);
-  if (!process->staticPropertiesReified()) {
-    process->reifyAllStaticProperties(globalObject);
-    if (scope.exception())
-      return;
-  }
-
-  PropertyNameArray properties(vm, PropertyNameMode::Strings,
-                               PrivateSymbolMode::Exclude);
-  process->getPropertyNames(globalObject, properties,
-                            DontEnumPropertiesMode::Exclude);
-  if (scope.exception())
-    return;
-
-  exportNames.append(vm.propertyNames->defaultKeyword);
-  exportValues.append(process);
-
-  for (auto &entry : properties) {
-    exportNames.append(entry);
-    auto catchScope = DECLARE_CATCH_SCOPE(vm);
-    JSValue result = process->get(globalObject, entry);
-    if (catchScope.exception()) {
-      result = jsUndefined();
-      catchScope.clearException();
+    JSC::JSObject* process = globalObject->processObject();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    if (!process->staticPropertiesReified()) {
+        process->reifyAllStaticProperties(globalObject);
+        if (scope.exception())
+            return;
     }
 
-    exportValues.append(result);
-  }
+    PropertyNameArray properties(vm, PropertyNameMode::Strings,
+        PrivateSymbolMode::Exclude);
+    process->getPropertyNames(globalObject, properties,
+        DontEnumPropertiesMode::Exclude);
+    if (scope.exception())
+        return;
+
+    exportNames.append(vm.propertyNames->defaultKeyword);
+    exportValues.append(process);
+
+    for (auto& entry : properties) {
+        exportNames.append(entry);
+        auto catchScope = DECLARE_CATCH_SCOPE(vm);
+        JSValue result = process->get(globalObject, entry);
+        if (catchScope.exception()) {
+            result = jsUndefined();
+            catchScope.clearException();
+        }
+
+        exportValues.append(result);
+    }
 }
 
 } // namespace Zig
diff --git a/src/bun.js/modules/NodeStringDecoderModule.h b/src/bun.js/modules/NodeStringDecoderModule.h
index 253ba0f7e2..d4ffdc85a3 100644
--- a/src/bun.js/modules/NodeStringDecoderModule.h
+++ b/src/bun.js/modules/NodeStringDecoderModule.h
@@ -4,13 +4,14 @@
 
 namespace Zig {
 
-DEFINE_NATIVE_MODULE(NodeStringDecoder) {
-  INIT_NATIVE_MODULE(1);
+DEFINE_NATIVE_MODULE(NodeStringDecoder)
+{
+    INIT_NATIVE_MODULE(1);
 
-  put(JSC::Identifier::fromString(vm, "StringDecoder"_s),
-      globalObject->JSStringDecoder());
+    put(JSC::Identifier::fromString(vm, "StringDecoder"_s),
+        globalObject->JSStringDecoder());
 
-  RETURN_NATIVE_MODULE();
+    RETURN_NATIVE_MODULE();
 }
 
 } // namespace Zig
diff --git a/src/bun.js/modules/NodeTTYModule.cpp b/src/bun.js/modules/NodeTTYModule.cpp
index c5521dd97a..3ea4c15316 100644
--- a/src/bun.js/modules/NodeTTYModule.cpp
+++ b/src/bun.js/modules/NodeTTYModule.cpp
@@ -6,41 +6,42 @@ using namespace JSC;
 
 namespace Zig {
 
-JSC_DEFINE_HOST_FUNCTION(jsFunctionTty_isatty, (JSGlobalObject * globalObject,
-                                                CallFrame *callFrame)) {
-  VM &vm = globalObject->vm();
-  if (callFrame->argumentCount() < 1) {
-    return JSValue::encode(jsBoolean(false));
-  }
+JSC_DEFINE_HOST_FUNCTION(jsFunctionTty_isatty, (JSGlobalObject * globalObject, CallFrame* callFrame))
+{
+    VM& vm = globalObject->vm();
+    if (callFrame->argumentCount() < 1) {
+        return JSValue::encode(jsBoolean(false));
+    }
 
-  auto scope = DECLARE_CATCH_SCOPE(vm);
-  int fd = callFrame->argument(0).toInt32(globalObject);
-  RETURN_IF_EXCEPTION(scope, {});
+    auto scope = DECLARE_CATCH_SCOPE(vm);
+    int fd = callFrame->argument(0).toInt32(globalObject);
+    RETURN_IF_EXCEPTION(scope, {});
 
 #if !OS(WINDOWS)
-  bool isTTY = isatty(fd);
+    bool isTTY = isatty(fd);
 #else
-  bool isTTY = false;
-  switch (uv_guess_handle(fd)) {
-  case UV_TTY:
-    isTTY = true;
-    break;
-  default:
-    break;
-  }
+    bool isTTY = false;
+    switch (uv_guess_handle(fd)) {
+    case UV_TTY:
+        isTTY = true;
+        break;
+    default:
+        break;
+    }
 #endif
 
-  return JSValue::encode(jsBoolean(isTTY));
+    return JSValue::encode(jsBoolean(isTTY));
 }
 
 JSC_DEFINE_HOST_FUNCTION(jsFunctionNotImplementedYet,
-                         (JSGlobalObject * globalObject,
-                          CallFrame *callFrame)) {
-  VM &vm = globalObject->vm();
-  auto throwScope = DECLARE_THROW_SCOPE(vm);
-  throwException(globalObject, throwScope,
-                 createError(globalObject, "Not implemented yet"_s));
-  return {};
+    (JSGlobalObject * globalObject,
+        CallFrame* callFrame))
+{
+    VM& vm = globalObject->vm();
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    throwException(globalObject, throwScope,
+        createError(globalObject, "Not implemented yet"_s));
+    return {};
 }
 
-} // namespace Zig
\ No newline at end of file
+} // namespace Zig
diff --git a/src/bun.js/modules/NodeTTYModule.h b/src/bun.js/modules/NodeTTYModule.h
index 30a3b51586..5b897a3a48 100644
--- a/src/bun.js/modules/NodeTTYModule.h
+++ b/src/bun.js/modules/NodeTTYModule.h
@@ -13,19 +13,20 @@ using namespace WebCore;
 JSC_DECLARE_HOST_FUNCTION(jsFunctionTty_isatty);
 JSC_DECLARE_HOST_FUNCTION(jsFunctionNotImplementedYet);
 
-DEFINE_NATIVE_MODULE(NodeTTY) {
-  INIT_NATIVE_MODULE(3);
+DEFINE_NATIVE_MODULE(NodeTTY)
+{
+    INIT_NATIVE_MODULE(3);
 
-  auto *notimpl = JSFunction::create(vm, globalObject, 0, "notimpl"_s,
-                                     jsFunctionNotImplementedYet,
-                                     ImplementationVisibility::Public,
-                                     NoIntrinsic, jsFunctionNotImplementedYet);
+    auto* notimpl = JSFunction::create(vm, globalObject, 0, "notimpl"_s,
+        jsFunctionNotImplementedYet,
+        ImplementationVisibility::Public,
+        NoIntrinsic, jsFunctionNotImplementedYet);
 
-  putNativeFn(Identifier::fromString(vm, "isatty"_s), jsFunctionTty_isatty);
-  put(Identifier::fromString(vm, "ReadStream"_s), notimpl);
-  put(Identifier::fromString(vm, "WriteStream"_s), notimpl);
+    putNativeFn(Identifier::fromString(vm, "isatty"_s), jsFunctionTty_isatty);
+    put(Identifier::fromString(vm, "ReadStream"_s), notimpl);
+    put(Identifier::fromString(vm, "WriteStream"_s), notimpl);
 
-  RETURN_NATIVE_MODULE();
+    RETURN_NATIVE_MODULE();
 }
 
 } // namespace Zig
diff --git a/src/bun.js/modules/NodeUtilTypesModule.h b/src/bun.js/modules/NodeUtilTypesModule.h
index a90fd7e681..cc4117701e 100644
--- a/src/bun.js/modules/NodeUtilTypesModule.h
+++ b/src/bun.js/modules/NodeUtilTypesModule.h
@@ -18,491 +18,523 @@
 
 using namespace JSC;
 
-#define GET_FIRST_VALUE                                                        \
-  if (callframe->argumentCount() < 1)                                          \
-    return JSValue::encode(jsBoolean(false));                                  \
-  JSValue value = callframe->uncheckedArgument(0);
+#define GET_FIRST_VALUE                           \
+    if (callframe->argumentCount() < 1)           \
+        return JSValue::encode(jsBoolean(false)); \
+    JSValue value = callframe->uncheckedArgument(0);
 
-#define GET_FIRST_CELL                                                         \
-  if (callframe->argumentCount() < 1)                                          \
-    return JSValue::encode(jsBoolean(false));                                  \
-  JSValue value = callframe->uncheckedArgument(0);                             \
-  if (!value.isCell())                                                         \
-    return JSValue::encode(jsBoolean(false));                                  \
-  JSCell *cell = value.asCell();
+#define GET_FIRST_CELL                               \
+    if (callframe->argumentCount() < 1)              \
+        return JSValue::encode(jsBoolean(false));    \
+    JSValue value = callframe->uncheckedArgument(0); \
+    if (!value.isCell())                             \
+        return JSValue::encode(jsBoolean(false));    \
+    JSCell* cell = value.asCell();
 
 JSC_DEFINE_HOST_FUNCTION(jsFunctionIsExternal,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_VALUE
-  return JSValue::encode(jsBoolean(value.inherits<Bun::NapiExternal>()));
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_VALUE
+    return JSValue::encode(jsBoolean(value.inherits<Bun::NapiExternal>()));
 }
-JSC_DEFINE_HOST_FUNCTION(jsFunctionIsDate, (JSC::JSGlobalObject * globalObject,
-                                            JSC::CallFrame *callframe)) {
-  GET_FIRST_CELL
-  return JSValue::encode(jsBoolean(cell->type() == JSDateType));
+JSC_DEFINE_HOST_FUNCTION(jsFunctionIsDate, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callframe))
+{
+    GET_FIRST_CELL
+    return JSValue::encode(jsBoolean(cell->type() == JSDateType));
 }
 JSC_DEFINE_HOST_FUNCTION(jsFunctionIsArgumentsObject,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_VALUE
-  if (!value.isCell())
-    return JSValue::encode(jsBoolean(false));
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_VALUE
+    if (!value.isCell())
+        return JSValue::encode(jsBoolean(false));
 
-  auto type = value.asCell()->type();
-  switch (type) {
-  case DirectArgumentsType:
-  case ScopedArgumentsType:
-  case ClonedArgumentsType:
-    return JSValue::encode(jsBoolean(true));
-  default:
-    return JSValue::encode(jsBoolean(false));
-  }
-
-  __builtin_unreachable();
-}
-JSC_DEFINE_HOST_FUNCTION(jsFunctionIsBigIntObject,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_CELL
-  return JSValue::encode(
-      jsBoolean(globalObject->bigIntObjectStructure() == cell->structure()));
-}
-JSC_DEFINE_HOST_FUNCTION(jsFunctionIsBooleanObject,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_VALUE
-  return JSValue::encode(
-      jsBoolean(value.isCell() && value.asCell()->type() == BooleanObjectType));
-}
-JSC_DEFINE_HOST_FUNCTION(jsFunctionIsNumberObject,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_VALUE
-  return JSValue::encode(
-      jsBoolean(value.isCell() && value.asCell()->type() == NumberObjectType));
-}
-JSC_DEFINE_HOST_FUNCTION(jsFunctionIsStringObject,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_VALUE
-  return JSValue::encode(jsBoolean(
-      value.isCell() && (value.asCell()->type() == StringObjectType ||
-                         value.asCell()->type() == DerivedStringObjectType)));
-}
-JSC_DEFINE_HOST_FUNCTION(jsFunctionIsSymbolObject,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_CELL
-
-  return JSValue::encode(
-      jsBoolean(globalObject->symbolObjectStructure() == cell->structure()));
-}
-JSC_DEFINE_HOST_FUNCTION(jsFunctionIsNativeError,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_VALUE
-  if (value.isCell()) {
-    if (value.inherits<JSC::ErrorInstance>() ||
-        value.asCell()->type() == ErrorInstanceType)
-      return JSValue::encode(jsBoolean(true));
-
-    VM &vm = globalObject->vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-    JSObject *object = value.toObject(globalObject);
-
-    // node util.isError relies on toString
-    // https://github.com/nodejs/node/blob/cf8c6994e0f764af02da4fa70bc5962142181bf3/doc/api/util.md#L2923
-    PropertySlot slot(object, PropertySlot::InternalMethodType::VMInquiry, &vm);
-    if (object->getPropertySlot(globalObject,
-                                vm.propertyNames->toStringTagSymbol, slot)) {
-      EXCEPTION_ASSERT(!scope.exception());
-      if (slot.isValue()) {
-        JSValue value =
-            slot.getValue(globalObject, vm.propertyNames->toStringTagSymbol);
-        if (value.isString()) {
-          String tag = asString(value)->value(globalObject);
-          if (UNLIKELY(scope.exception()))
-            scope.clearException();
-          if (tag == "Error"_s)
-            return JSValue::encode(jsBoolean(true));
-        }
-      }
+    auto type = value.asCell()->type();
+    switch (type) {
+    case DirectArgumentsType:
+    case ScopedArgumentsType:
+    case ClonedArgumentsType:
+        return JSValue::encode(jsBoolean(true));
+    default:
+        return JSValue::encode(jsBoolean(false));
     }
 
-    JSValue proto = object->getPrototype(vm, globalObject);
-    if (proto.isCell() && (proto.inherits<JSC::ErrorInstance>() ||
-                           proto.asCell()->type() == ErrorInstanceType ||
-                           proto.inherits<JSC::ErrorPrototype>()))
-      return JSValue::encode(jsBoolean(true));
-  }
+    __builtin_unreachable();
+}
+JSC_DEFINE_HOST_FUNCTION(jsFunctionIsBigIntObject,
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_CELL
+    return JSValue::encode(
+        jsBoolean(globalObject->bigIntObjectStructure() == cell->structure()));
+}
+JSC_DEFINE_HOST_FUNCTION(jsFunctionIsBooleanObject,
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_VALUE
+    return JSValue::encode(
+        jsBoolean(value.isCell() && value.asCell()->type() == BooleanObjectType));
+}
+JSC_DEFINE_HOST_FUNCTION(jsFunctionIsNumberObject,
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_VALUE
+    return JSValue::encode(
+        jsBoolean(value.isCell() && value.asCell()->type() == NumberObjectType));
+}
+JSC_DEFINE_HOST_FUNCTION(jsFunctionIsStringObject,
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_VALUE
+    return JSValue::encode(jsBoolean(
+        value.isCell() && (value.asCell()->type() == StringObjectType || value.asCell()->type() == DerivedStringObjectType)));
+}
+JSC_DEFINE_HOST_FUNCTION(jsFunctionIsSymbolObject,
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_CELL
 
-  return JSValue::encode(jsBoolean(false));
+    return JSValue::encode(
+        jsBoolean(globalObject->symbolObjectStructure() == cell->structure()));
+}
+JSC_DEFINE_HOST_FUNCTION(jsFunctionIsNativeError,
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_VALUE
+    if (value.isCell()) {
+        if (value.inherits<JSC::ErrorInstance>() || value.asCell()->type() == ErrorInstanceType)
+            return JSValue::encode(jsBoolean(true));
+
+        VM& vm = globalObject->vm();
+        auto scope = DECLARE_THROW_SCOPE(vm);
+        JSObject* object = value.toObject(globalObject);
+
+        // node util.isError relies on toString
+        // https://github.com/nodejs/node/blob/cf8c6994e0f764af02da4fa70bc5962142181bf3/doc/api/util.md#L2923
+        PropertySlot slot(object, PropertySlot::InternalMethodType::VMInquiry, &vm);
+        if (object->getPropertySlot(globalObject,
+                vm.propertyNames->toStringTagSymbol, slot)) {
+            EXCEPTION_ASSERT(!scope.exception());
+            if (slot.isValue()) {
+                JSValue value = slot.getValue(globalObject, vm.propertyNames->toStringTagSymbol);
+                if (value.isString()) {
+                    String tag = asString(value)->value(globalObject);
+                    if (UNLIKELY(scope.exception()))
+                        scope.clearException();
+                    if (tag == "Error"_s)
+                        return JSValue::encode(jsBoolean(true));
+                }
+            }
+        }
+
+        JSValue proto = object->getPrototype(vm, globalObject);
+        if (proto.isCell() && (proto.inherits<JSC::ErrorInstance>() || proto.asCell()->type() == ErrorInstanceType || proto.inherits<JSC::ErrorPrototype>()))
+            return JSValue::encode(jsBoolean(true));
+    }
+
+    return JSValue::encode(jsBoolean(false));
 }
 JSC_DEFINE_HOST_FUNCTION(jsFunctionIsRegExp,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_VALUE
-  return JSValue::encode(
-      jsBoolean(value.isCell() && value.asCell()->type() == RegExpObjectType));
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_VALUE
+    return JSValue::encode(
+        jsBoolean(value.isCell() && value.asCell()->type() == RegExpObjectType));
 }
 JSC_DEFINE_HOST_FUNCTION(jsFunctionIsAsyncFunction,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_VALUE
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_VALUE
 
-  auto *function = jsDynamicCast<JSFunction *>(value);
-  if (!function)
-    return JSValue::encode(jsBoolean(false));
+    auto* function = jsDynamicCast<JSFunction*>(value);
+    if (!function)
+        return JSValue::encode(jsBoolean(false));
 
-  auto *executable = function->jsExecutable();
-  if (!executable)
-    return JSValue::encode(jsBoolean(false));
+    auto* executable = function->jsExecutable();
+    if (!executable)
+        return JSValue::encode(jsBoolean(false));
 
-  if (executable->isAsyncGenerator()) {
-    return JSValue::encode(jsBoolean(true));
-  }
+    if (executable->isAsyncGenerator()) {
+        return JSValue::encode(jsBoolean(true));
+    }
 
-  auto &vm = globalObject->vm();
-  auto proto = function->getPrototype(vm, globalObject);
-  if (!proto.isCell()) {
-    return JSValue::encode(jsBoolean(false));
-  }
+    auto& vm = globalObject->vm();
+    auto proto = function->getPrototype(vm, globalObject);
+    if (!proto.isCell()) {
+        return JSValue::encode(jsBoolean(false));
+    }
 
-  auto *protoCell = proto.asCell();
-  return JSValue::encode(
-      jsBoolean(protoCell->inherits<AsyncFunctionPrototype>()));
+    auto* protoCell = proto.asCell();
+    return JSValue::encode(
+        jsBoolean(protoCell->inherits<AsyncFunctionPrototype>()));
 }
 JSC_DEFINE_HOST_FUNCTION(jsFunctionIsGeneratorFunction,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_VALUE
-  auto *function = jsDynamicCast<JSFunction *>(value);
-  if (!function)
-    return JSValue::encode(jsBoolean(false));
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_VALUE
+    auto* function = jsDynamicCast<JSFunction*>(value);
+    if (!function)
+        return JSValue::encode(jsBoolean(false));
 
-  auto *executable = function->jsExecutable();
-  if (!executable)
-    return JSValue::encode(jsBoolean(false));
+    auto* executable = function->jsExecutable();
+    if (!executable)
+        return JSValue::encode(jsBoolean(false));
 
-  return JSValue::encode(
-      jsBoolean(executable->isGenerator() || executable->isAsyncGenerator()));
+    return JSValue::encode(
+        jsBoolean(executable->isGenerator() || executable->isAsyncGenerator()));
 }
 JSC_DEFINE_HOST_FUNCTION(jsFunctionIsGeneratorObject,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_CELL
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_CELL
 
-  return JSValue::encode(jsBoolean(cell->type() == JSGeneratorType ||
-                                   cell->type() == JSAsyncGeneratorType));
+    return JSValue::encode(jsBoolean(cell->type() == JSGeneratorType || cell->type() == JSAsyncGeneratorType));
 }
 JSC_DEFINE_HOST_FUNCTION(jsFunctionIsPromise,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_CELL
-  return JSValue::encode(jsBoolean(cell->type() == JSPromiseType));
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_CELL
+    return JSValue::encode(jsBoolean(cell->type() == JSPromiseType));
 }
-JSC_DEFINE_HOST_FUNCTION(jsFunctionIsMap, (JSC::JSGlobalObject * globalObject,
-                                           JSC::CallFrame *callframe)) {
-  GET_FIRST_CELL
-  return JSValue::encode(jsBoolean(cell->type() == JSMapType));
+JSC_DEFINE_HOST_FUNCTION(jsFunctionIsMap, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callframe))
+{
+    GET_FIRST_CELL
+    return JSValue::encode(jsBoolean(cell->type() == JSMapType));
 }
-JSC_DEFINE_HOST_FUNCTION(jsFunctionIsSet, (JSC::JSGlobalObject * globalObject,
-                                           JSC::CallFrame *callframe)) {
-  GET_FIRST_CELL
-  return JSValue::encode(jsBoolean(cell->type() == JSSetType));
+JSC_DEFINE_HOST_FUNCTION(jsFunctionIsSet, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callframe))
+{
+    GET_FIRST_CELL
+    return JSValue::encode(jsBoolean(cell->type() == JSSetType));
 }
 JSC_DEFINE_HOST_FUNCTION(jsFunctionIsMapIterator,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_CELL
-  return JSValue::encode(jsBoolean(cell->type() == JSMapIteratorType));
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_CELL
+    return JSValue::encode(jsBoolean(cell->type() == JSMapIteratorType));
 }
 JSC_DEFINE_HOST_FUNCTION(jsFunctionIsSetIterator,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_CELL
-  return JSValue::encode(jsBoolean(cell->type() == JSSetIteratorType));
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_CELL
+    return JSValue::encode(jsBoolean(cell->type() == JSSetIteratorType));
 }
 JSC_DEFINE_HOST_FUNCTION(jsFunctionIsWeakMap,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_CELL
-  return JSValue::encode(jsBoolean(cell->type() == JSWeakMapType));
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_CELL
+    return JSValue::encode(jsBoolean(cell->type() == JSWeakMapType));
 }
 JSC_DEFINE_HOST_FUNCTION(jsFunctionIsWeakSet,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_CELL
-  return JSValue::encode(jsBoolean(cell->type() == JSWeakSetType));
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_CELL
+    return JSValue::encode(jsBoolean(cell->type() == JSWeakSetType));
 }
 JSC_DEFINE_HOST_FUNCTION(jsFunctionIsArrayBuffer,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_CELL
-  auto *arrayBuffer = jsDynamicCast<JSArrayBuffer *>(cell);
-  if (!arrayBuffer)
-    return JSValue::encode(jsBoolean(false));
-  return JSValue::encode(jsBoolean(!arrayBuffer->isShared()));
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_CELL
+    auto* arrayBuffer = jsDynamicCast<JSArrayBuffer*>(cell);
+    if (!arrayBuffer)
+        return JSValue::encode(jsBoolean(false));
+    return JSValue::encode(jsBoolean(!arrayBuffer->isShared()));
 }
 JSC_DEFINE_HOST_FUNCTION(jsFunctionIsDataView,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_CELL
-  return JSValue::encode(jsBoolean(cell->type() == DataViewType));
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_CELL
+    return JSValue::encode(jsBoolean(cell->type() == DataViewType));
 }
 JSC_DEFINE_HOST_FUNCTION(jsFunctionIsSharedArrayBuffer,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_CELL
-  auto *arrayBuffer = jsDynamicCast<JSArrayBuffer *>(cell);
-  if (!arrayBuffer)
-    return JSValue::encode(jsBoolean(false));
-  return JSValue::encode(jsBoolean(arrayBuffer->isShared()));
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_CELL
+    auto* arrayBuffer = jsDynamicCast<JSArrayBuffer*>(cell);
+    if (!arrayBuffer)
+        return JSValue::encode(jsBoolean(false));
+    return JSValue::encode(jsBoolean(arrayBuffer->isShared()));
 }
-JSC_DEFINE_HOST_FUNCTION(jsFunctionIsProxy, (JSC::JSGlobalObject * globalObject,
-                                             JSC::CallFrame *callframe)) {
-  GET_FIRST_CELL
-  return JSValue::encode(jsBoolean(cell->type() == GlobalProxyType ||
-                                   cell->type() == ProxyObjectType));
+JSC_DEFINE_HOST_FUNCTION(jsFunctionIsProxy, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callframe))
+{
+    GET_FIRST_CELL
+    return JSValue::encode(jsBoolean(cell->type() == GlobalProxyType || cell->type() == ProxyObjectType));
 }
 JSC_DEFINE_HOST_FUNCTION(jsFunctionIsModuleNamespaceObject,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_CELL
-  return JSValue::encode(jsBoolean(cell->type() == ModuleNamespaceObjectType));
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_CELL
+    return JSValue::encode(jsBoolean(cell->type() == ModuleNamespaceObjectType));
 }
 JSC_DEFINE_HOST_FUNCTION(jsFunctionIsAnyArrayBuffer,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_CELL
-  auto *arrayBuffer = jsDynamicCast<JSArrayBuffer *>(cell);
-  return JSValue::encode(jsBoolean(arrayBuffer != nullptr));
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_CELL
+    auto* arrayBuffer = jsDynamicCast<JSArrayBuffer*>(cell);
+    return JSValue::encode(jsBoolean(arrayBuffer != nullptr));
 }
 JSC_DEFINE_HOST_FUNCTION(jsFunctionIsBoxedPrimitive,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_CELL
-  switch (cell->type()) {
-  case JSC::BooleanObjectType:
-  case JSC::NumberObjectType:
-  case JSC::StringObjectType:
-  case JSC::DerivedStringObjectType:
-    return JSValue::encode(jsBoolean(true));
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_CELL
+    switch (cell->type()) {
+    case JSC::BooleanObjectType:
+    case JSC::NumberObjectType:
+    case JSC::StringObjectType:
+    case JSC::DerivedStringObjectType:
+        return JSValue::encode(jsBoolean(true));
 
-  default: {
-    if (cell->structure() == globalObject->symbolObjectStructure())
-      return JSValue::encode(jsBoolean(true));
+    default: {
+        if (cell->structure() == globalObject->symbolObjectStructure())
+            return JSValue::encode(jsBoolean(true));
 
-    if (cell->structure() == globalObject->bigIntObjectStructure())
-      return JSValue::encode(jsBoolean(true));
-  }
-  }
+        if (cell->structure() == globalObject->bigIntObjectStructure())
+            return JSValue::encode(jsBoolean(true));
+    }
+    }
 
-  return JSValue::encode(jsBoolean(false));
+    return JSValue::encode(jsBoolean(false));
 }
 JSC_DEFINE_HOST_FUNCTION(jsFunctionIsArrayBufferView,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_CELL
-  return JSValue::encode(
-      jsBoolean(cell->type() >= Int8ArrayType && cell->type() <= DataViewType));
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_CELL
+    return JSValue::encode(
+        jsBoolean(cell->type() >= Int8ArrayType && cell->type() <= DataViewType));
 }
 JSC_DEFINE_HOST_FUNCTION(jsFunctionIsTypedArray,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_CELL
-  return JSValue::encode(jsBoolean(cell->type() >= Int8ArrayType &&
-                                   cell->type() <= BigUint64ArrayType));
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_CELL
+    return JSValue::encode(jsBoolean(cell->type() >= Int8ArrayType && cell->type() <= BigUint64ArrayType));
 }
 JSC_DEFINE_HOST_FUNCTION(jsFunctionIsUint8Array,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_CELL
-  return JSValue::encode(jsBoolean(cell->type() == Uint8ArrayType));
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_CELL
+    return JSValue::encode(jsBoolean(cell->type() == Uint8ArrayType));
 }
 JSC_DEFINE_HOST_FUNCTION(jsFunctionIsUint8ClampedArray,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_CELL
-  return JSValue::encode(jsBoolean(cell->type() == Uint8ClampedArrayType));
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_CELL
+    return JSValue::encode(jsBoolean(cell->type() == Uint8ClampedArrayType));
 }
 JSC_DEFINE_HOST_FUNCTION(jsFunctionIsUint16Array,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_CELL
-  return JSValue::encode(jsBoolean(cell->type() == Uint16ArrayType));
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_CELL
+    return JSValue::encode(jsBoolean(cell->type() == Uint16ArrayType));
 }
 JSC_DEFINE_HOST_FUNCTION(jsFunctionIsUint32Array,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_CELL
-  return JSValue::encode(jsBoolean(cell->type() == Uint32ArrayType));
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_CELL
+    return JSValue::encode(jsBoolean(cell->type() == Uint32ArrayType));
 }
 JSC_DEFINE_HOST_FUNCTION(jsFunctionIsInt8Array,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_CELL
-  return JSValue::encode(jsBoolean(cell->type() == Int8ArrayType));
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_CELL
+    return JSValue::encode(jsBoolean(cell->type() == Int8ArrayType));
 }
 JSC_DEFINE_HOST_FUNCTION(jsFunctionIsInt16Array,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_CELL
-  return JSValue::encode(jsBoolean(cell->type() == Int16ArrayType));
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_CELL
+    return JSValue::encode(jsBoolean(cell->type() == Int16ArrayType));
 }
 JSC_DEFINE_HOST_FUNCTION(jsFunctionIsInt32Array,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_CELL
-  return JSValue::encode(jsBoolean(cell->type() == Int32ArrayType));
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_CELL
+    return JSValue::encode(jsBoolean(cell->type() == Int32ArrayType));
 }
 JSC_DEFINE_HOST_FUNCTION(jsFunctionIsFloat16Array,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_CELL
-  return JSValue::encode(jsBoolean(cell->type() == Float16ArrayType));
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_CELL
+    return JSValue::encode(jsBoolean(cell->type() == Float16ArrayType));
 }
 JSC_DEFINE_HOST_FUNCTION(jsFunctionIsFloat32Array,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_CELL
-  return JSValue::encode(jsBoolean(cell->type() == Float32ArrayType));
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_CELL
+    return JSValue::encode(jsBoolean(cell->type() == Float32ArrayType));
 }
 JSC_DEFINE_HOST_FUNCTION(jsFunctionIsFloat64Array,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_CELL
-  return JSValue::encode(jsBoolean(cell->type() == Float64ArrayType));
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_CELL
+    return JSValue::encode(jsBoolean(cell->type() == Float64ArrayType));
 }
 JSC_DEFINE_HOST_FUNCTION(jsFunctionIsBigInt64Array,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_CELL
-  return JSValue::encode(jsBoolean(cell->type() == BigInt64ArrayType));
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_CELL
+    return JSValue::encode(jsBoolean(cell->type() == BigInt64ArrayType));
 }
 JSC_DEFINE_HOST_FUNCTION(jsFunctionIsBigUint64Array,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_CELL
-  return JSValue::encode(jsBoolean(cell->type() == BigUint64ArrayType));
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_CELL
+    return JSValue::encode(jsBoolean(cell->type() == BigUint64ArrayType));
 }
 JSC_DEFINE_HOST_FUNCTION(jsFunctionIsKeyObject,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_CELL
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_CELL
+
+    if (!cell->isObject()) {
+        return JSValue::encode(jsBoolean(false));
+    }
+
+    auto* object = cell->getObject();
+
+    auto& vm = globalObject->vm();
+    const auto& names = WebCore::builtinNames(vm);
+
+    auto scope = DECLARE_CATCH_SCOPE(vm);
+
+    if (auto val = object->getIfPropertyExists(globalObject,
+            names.bunNativePtrPrivateName())) {
+        if (val.isCell() && val.inherits<WebCore::JSCryptoKey>())
+            return JSValue::encode(jsBoolean(true));
+    }
+
+    if (scope.exception()) {
+        scope.clearException();
+    }
 
-  if (!cell->isObject()) {
     return JSValue::encode(jsBoolean(false));
-  }
-
-  auto *object = cell->getObject();
-
-  auto &vm = globalObject->vm();
-  const auto &names = WebCore::builtinNames(vm);
-
-  auto scope = DECLARE_CATCH_SCOPE(vm);
-
-  if (auto val = object->getIfPropertyExists(globalObject,
-                                             names.bunNativePtrPrivateName())) {
-    if (val.isCell() && val.inherits<WebCore::JSCryptoKey>())
-      return JSValue::encode(jsBoolean(true));
-  }
-
-  if (scope.exception()) {
-    scope.clearException();
-  }
-
-  return JSValue::encode(jsBoolean(false));
 }
 JSC_DEFINE_HOST_FUNCTION(jsFunctionIsCryptoKey,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callframe)) {
-  GET_FIRST_CELL
-  return JSValue::encode(jsBoolean(cell->inherits<WebCore::JSCryptoKey>()));
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    GET_FIRST_CELL
+    return JSValue::encode(jsBoolean(cell->inherits<WebCore::JSCryptoKey>()));
 }
 
 namespace Zig {
-DEFINE_NATIVE_MODULE(NodeUtilTypes) {
-  INIT_NATIVE_MODULE(43);
+DEFINE_NATIVE_MODULE(NodeUtilTypes)
+{
+    INIT_NATIVE_MODULE(43);
 
-  putNativeFn(Identifier::fromString(vm, "isExternal"_s), jsFunctionIsExternal);
-  putNativeFn(Identifier::fromString(vm, "isDate"_s), jsFunctionIsDate);
-  putNativeFn(Identifier::fromString(vm, "isArgumentsObject"_s),
-              jsFunctionIsArgumentsObject);
-  putNativeFn(Identifier::fromString(vm, "isBigIntObject"_s),
-              jsFunctionIsBigIntObject);
-  putNativeFn(Identifier::fromString(vm, "isBooleanObject"_s),
-              jsFunctionIsBooleanObject);
-  putNativeFn(Identifier::fromString(vm, "isNumberObject"_s),
-              jsFunctionIsNumberObject);
-  putNativeFn(Identifier::fromString(vm, "isStringObject"_s),
-              jsFunctionIsStringObject);
-  putNativeFn(Identifier::fromString(vm, "isSymbolObject"_s),
-              jsFunctionIsSymbolObject);
-  putNativeFn(Identifier::fromString(vm, "isNativeError"_s),
-              jsFunctionIsNativeError);
-  putNativeFn(Identifier::fromString(vm, "isRegExp"_s), jsFunctionIsRegExp);
-  putNativeFn(Identifier::fromString(vm, "isAsyncFunction"_s),
-              jsFunctionIsAsyncFunction);
-  putNativeFn(Identifier::fromString(vm, "isGeneratorFunction"_s),
-              jsFunctionIsGeneratorFunction);
-  putNativeFn(Identifier::fromString(vm, "isGeneratorObject"_s),
-              jsFunctionIsGeneratorObject);
-  putNativeFn(Identifier::fromString(vm, "isPromise"_s), jsFunctionIsPromise);
-  putNativeFn(Identifier::fromString(vm, "isMap"_s), jsFunctionIsMap);
-  putNativeFn(Identifier::fromString(vm, "isSet"_s), jsFunctionIsSet);
-  putNativeFn(Identifier::fromString(vm, "isMapIterator"_s),
-              jsFunctionIsMapIterator);
-  putNativeFn(Identifier::fromString(vm, "isSetIterator"_s),
-              jsFunctionIsSetIterator);
-  putNativeFn(Identifier::fromString(vm, "isWeakMap"_s), jsFunctionIsWeakMap);
-  putNativeFn(Identifier::fromString(vm, "isWeakSet"_s), jsFunctionIsWeakSet);
-  putNativeFn(Identifier::fromString(vm, "isArrayBuffer"_s),
-              jsFunctionIsArrayBuffer);
-  putNativeFn(Identifier::fromString(vm, "isDataView"_s), jsFunctionIsDataView);
-  putNativeFn(Identifier::fromString(vm, "isSharedArrayBuffer"_s),
-              jsFunctionIsSharedArrayBuffer);
-  putNativeFn(Identifier::fromString(vm, "isProxy"_s), jsFunctionIsProxy);
-  putNativeFn(Identifier::fromString(vm, "isModuleNamespaceObject"_s),
-              jsFunctionIsModuleNamespaceObject);
-  putNativeFn(Identifier::fromString(vm, "isAnyArrayBuffer"_s),
-              jsFunctionIsAnyArrayBuffer);
-  putNativeFn(Identifier::fromString(vm, "isBoxedPrimitive"_s),
-              jsFunctionIsBoxedPrimitive);
-  putNativeFn(Identifier::fromString(vm, "isArrayBufferView"_s),
-              jsFunctionIsArrayBufferView);
-  putNativeFn(Identifier::fromString(vm, "isTypedArray"_s),
-              jsFunctionIsTypedArray);
-  putNativeFn(Identifier::fromString(vm, "isUint8Array"_s),
-              jsFunctionIsUint8Array);
-  putNativeFn(Identifier::fromString(vm, "isUint8ClampedArray"_s),
-              jsFunctionIsUint8ClampedArray);
-  putNativeFn(Identifier::fromString(vm, "isUint16Array"_s),
-              jsFunctionIsUint16Array);
-  putNativeFn(Identifier::fromString(vm, "isUint32Array"_s),
-              jsFunctionIsUint32Array);
-  putNativeFn(Identifier::fromString(vm, "isInt8Array"_s),
-              jsFunctionIsInt8Array);
-  putNativeFn(Identifier::fromString(vm, "isInt16Array"_s),
-              jsFunctionIsInt16Array);
-  putNativeFn(Identifier::fromString(vm, "isInt32Array"_s),
-              jsFunctionIsInt32Array);
-  putNativeFn(Identifier::fromString(vm, "isFloat16Array"_s),
-              jsFunctionIsFloat16Array);
-  putNativeFn(Identifier::fromString(vm, "isFloat32Array"_s),
-              jsFunctionIsFloat32Array);
-  putNativeFn(Identifier::fromString(vm, "isFloat64Array"_s),
-              jsFunctionIsFloat64Array);
-  putNativeFn(Identifier::fromString(vm, "isBigInt64Array"_s),
-              jsFunctionIsBigInt64Array);
-  putNativeFn(Identifier::fromString(vm, "isBigUint64Array"_s),
-              jsFunctionIsBigUint64Array);
-  putNativeFn(Identifier::fromString(vm, "isKeyObject"_s),
-              jsFunctionIsKeyObject);
-  putNativeFn(Identifier::fromString(vm, "isCryptoKey"_s),
-              jsFunctionIsCryptoKey);
+    putNativeFn(Identifier::fromString(vm, "isExternal"_s), jsFunctionIsExternal);
+    putNativeFn(Identifier::fromString(vm, "isDate"_s), jsFunctionIsDate);
+    putNativeFn(Identifier::fromString(vm, "isArgumentsObject"_s),
+        jsFunctionIsArgumentsObject);
+    putNativeFn(Identifier::fromString(vm, "isBigIntObject"_s),
+        jsFunctionIsBigIntObject);
+    putNativeFn(Identifier::fromString(vm, "isBooleanObject"_s),
+        jsFunctionIsBooleanObject);
+    putNativeFn(Identifier::fromString(vm, "isNumberObject"_s),
+        jsFunctionIsNumberObject);
+    putNativeFn(Identifier::fromString(vm, "isStringObject"_s),
+        jsFunctionIsStringObject);
+    putNativeFn(Identifier::fromString(vm, "isSymbolObject"_s),
+        jsFunctionIsSymbolObject);
+    putNativeFn(Identifier::fromString(vm, "isNativeError"_s),
+        jsFunctionIsNativeError);
+    putNativeFn(Identifier::fromString(vm, "isRegExp"_s), jsFunctionIsRegExp);
+    putNativeFn(Identifier::fromString(vm, "isAsyncFunction"_s),
+        jsFunctionIsAsyncFunction);
+    putNativeFn(Identifier::fromString(vm, "isGeneratorFunction"_s),
+        jsFunctionIsGeneratorFunction);
+    putNativeFn(Identifier::fromString(vm, "isGeneratorObject"_s),
+        jsFunctionIsGeneratorObject);
+    putNativeFn(Identifier::fromString(vm, "isPromise"_s), jsFunctionIsPromise);
+    putNativeFn(Identifier::fromString(vm, "isMap"_s), jsFunctionIsMap);
+    putNativeFn(Identifier::fromString(vm, "isSet"_s), jsFunctionIsSet);
+    putNativeFn(Identifier::fromString(vm, "isMapIterator"_s),
+        jsFunctionIsMapIterator);
+    putNativeFn(Identifier::fromString(vm, "isSetIterator"_s),
+        jsFunctionIsSetIterator);
+    putNativeFn(Identifier::fromString(vm, "isWeakMap"_s), jsFunctionIsWeakMap);
+    putNativeFn(Identifier::fromString(vm, "isWeakSet"_s), jsFunctionIsWeakSet);
+    putNativeFn(Identifier::fromString(vm, "isArrayBuffer"_s),
+        jsFunctionIsArrayBuffer);
+    putNativeFn(Identifier::fromString(vm, "isDataView"_s), jsFunctionIsDataView);
+    putNativeFn(Identifier::fromString(vm, "isSharedArrayBuffer"_s),
+        jsFunctionIsSharedArrayBuffer);
+    putNativeFn(Identifier::fromString(vm, "isProxy"_s), jsFunctionIsProxy);
+    putNativeFn(Identifier::fromString(vm, "isModuleNamespaceObject"_s),
+        jsFunctionIsModuleNamespaceObject);
+    putNativeFn(Identifier::fromString(vm, "isAnyArrayBuffer"_s),
+        jsFunctionIsAnyArrayBuffer);
+    putNativeFn(Identifier::fromString(vm, "isBoxedPrimitive"_s),
+        jsFunctionIsBoxedPrimitive);
+    putNativeFn(Identifier::fromString(vm, "isArrayBufferView"_s),
+        jsFunctionIsArrayBufferView);
+    putNativeFn(Identifier::fromString(vm, "isTypedArray"_s),
+        jsFunctionIsTypedArray);
+    putNativeFn(Identifier::fromString(vm, "isUint8Array"_s),
+        jsFunctionIsUint8Array);
+    putNativeFn(Identifier::fromString(vm, "isUint8ClampedArray"_s),
+        jsFunctionIsUint8ClampedArray);
+    putNativeFn(Identifier::fromString(vm, "isUint16Array"_s),
+        jsFunctionIsUint16Array);
+    putNativeFn(Identifier::fromString(vm, "isUint32Array"_s),
+        jsFunctionIsUint32Array);
+    putNativeFn(Identifier::fromString(vm, "isInt8Array"_s),
+        jsFunctionIsInt8Array);
+    putNativeFn(Identifier::fromString(vm, "isInt16Array"_s),
+        jsFunctionIsInt16Array);
+    putNativeFn(Identifier::fromString(vm, "isInt32Array"_s),
+        jsFunctionIsInt32Array);
+    putNativeFn(Identifier::fromString(vm, "isFloat16Array"_s),
+        jsFunctionIsFloat16Array);
+    putNativeFn(Identifier::fromString(vm, "isFloat32Array"_s),
+        jsFunctionIsFloat32Array);
+    putNativeFn(Identifier::fromString(vm, "isFloat64Array"_s),
+        jsFunctionIsFloat64Array);
+    putNativeFn(Identifier::fromString(vm, "isBigInt64Array"_s),
+        jsFunctionIsBigInt64Array);
+    putNativeFn(Identifier::fromString(vm, "isBigUint64Array"_s),
+        jsFunctionIsBigUint64Array);
+    putNativeFn(Identifier::fromString(vm, "isKeyObject"_s),
+        jsFunctionIsKeyObject);
+    putNativeFn(Identifier::fromString(vm, "isCryptoKey"_s),
+        jsFunctionIsCryptoKey);
 
-  RETURN_NATIVE_MODULE();
+    RETURN_NATIVE_MODULE();
 }
 } // namespace Zig
diff --git a/src/bun.js/modules/ObjectModule.cpp b/src/bun.js/modules/ObjectModule.cpp
index 309332506c..9d3a5fe9e9 100644
--- a/src/bun.js/modules/ObjectModule.cpp
+++ b/src/bun.js/modules/ObjectModule.cpp
@@ -2,99 +2,100 @@
 
 namespace Zig {
 JSC::SyntheticSourceProvider::SyntheticSourceGenerator
-generateObjectModuleSourceCode(JSC::JSGlobalObject *globalObject,
-                               JSC::JSObject *object) {
-  gcProtectNullTolerant(object);
-  return [object](JSC::JSGlobalObject *lexicalGlobalObject,
-                  JSC::Identifier moduleKey,
-                  Vector<JSC::Identifier, 4> &exportNames,
-                  JSC::MarkedArgumentBuffer &exportValues) -> void {
-    JSC::VM &vm = lexicalGlobalObject->vm();
-    GlobalObject *globalObject =
-        reinterpret_cast<GlobalObject *>(lexicalGlobalObject);
-    JSC::EnsureStillAliveScope stillAlive(object);
+generateObjectModuleSourceCode(JSC::JSGlobalObject* globalObject,
+    JSC::JSObject* object)
+{
+    gcProtectNullTolerant(object);
+    return [object](JSC::JSGlobalObject* lexicalGlobalObject,
+               JSC::Identifier moduleKey,
+               Vector<JSC::Identifier, 4>& exportNames,
+               JSC::MarkedArgumentBuffer& exportValues) -> void {
+        JSC::VM& vm = lexicalGlobalObject->vm();
+        GlobalObject* globalObject = reinterpret_cast<GlobalObject*>(lexicalGlobalObject);
+        JSC::EnsureStillAliveScope stillAlive(object);
 
-    PropertyNameArray properties(vm, PropertyNameMode::Strings,
-                                 PrivateSymbolMode::Exclude);
-    object->getPropertyNames(globalObject, properties,
-                             DontEnumPropertiesMode::Exclude);
-    gcUnprotectNullTolerant(object);
+        PropertyNameArray properties(vm, PropertyNameMode::Strings,
+            PrivateSymbolMode::Exclude);
+        object->getPropertyNames(globalObject, properties,
+            DontEnumPropertiesMode::Exclude);
+        gcUnprotectNullTolerant(object);
 
-    for (auto &entry : properties) {
-      exportNames.append(entry);
+        for (auto& entry : properties) {
+            exportNames.append(entry);
 
-      auto scope = DECLARE_CATCH_SCOPE(vm);
-      JSValue value = object->get(globalObject, entry);
-      if (scope.exception()) {
-        scope.clearException();
-        value = jsUndefined();
-      }
-      exportValues.append(value);
-    }
-  };
+            auto scope = DECLARE_CATCH_SCOPE(vm);
+            JSValue value = object->get(globalObject, entry);
+            if (scope.exception()) {
+                scope.clearException();
+                value = jsUndefined();
+            }
+            exportValues.append(value);
+        }
+    };
 }
 
 JSC::SyntheticSourceProvider::SyntheticSourceGenerator
-generateObjectModuleSourceCodeForJSON(JSC::JSGlobalObject *globalObject,
-                                      JSC::JSObject *object) {
-  gcProtectNullTolerant(object);
-  return [object](JSC::JSGlobalObject *lexicalGlobalObject,
-                  JSC::Identifier moduleKey,
-                  Vector<JSC::Identifier, 4> &exportNames,
-                  JSC::MarkedArgumentBuffer &exportValues) -> void {
-    JSC::VM &vm = lexicalGlobalObject->vm();
-    GlobalObject *globalObject =
-        reinterpret_cast<GlobalObject *>(lexicalGlobalObject);
-    JSC::EnsureStillAliveScope stillAlive(object);
+generateObjectModuleSourceCodeForJSON(JSC::JSGlobalObject* globalObject,
+    JSC::JSObject* object)
+{
+    gcProtectNullTolerant(object);
+    return [object](JSC::JSGlobalObject* lexicalGlobalObject,
+               JSC::Identifier moduleKey,
+               Vector<JSC::Identifier, 4>& exportNames,
+               JSC::MarkedArgumentBuffer& exportValues) -> void {
+        JSC::VM& vm = lexicalGlobalObject->vm();
+        GlobalObject* globalObject = reinterpret_cast<GlobalObject*>(lexicalGlobalObject);
+        JSC::EnsureStillAliveScope stillAlive(object);
 
-    PropertyNameArray properties(vm, PropertyNameMode::Strings,
-                                 PrivateSymbolMode::Exclude);
-    object->getPropertyNames(globalObject, properties,
-                             DontEnumPropertiesMode::Exclude);
-    gcUnprotectNullTolerant(object);
+        PropertyNameArray properties(vm, PropertyNameMode::Strings,
+            PrivateSymbolMode::Exclude);
+        object->getPropertyNames(globalObject, properties,
+            DontEnumPropertiesMode::Exclude);
+        gcUnprotectNullTolerant(object);
 
-    for (auto &entry : properties) {
-      if (entry == vm.propertyNames->defaultKeyword) {
-        continue;
-      }
+        for (auto& entry : properties) {
+            if (entry == vm.propertyNames->defaultKeyword) {
+                continue;
+            }
 
-      exportNames.append(entry);
+            exportNames.append(entry);
 
-      auto scope = DECLARE_CATCH_SCOPE(vm);
-      JSValue value = object->get(globalObject, entry);
-      if (scope.exception()) {
-        scope.clearException();
-        value = jsUndefined();
-      }
-      exportValues.append(value);
-    }
+            auto scope = DECLARE_CATCH_SCOPE(vm);
+            JSValue value = object->get(globalObject, entry);
+            if (scope.exception()) {
+                scope.clearException();
+                value = jsUndefined();
+            }
+            exportValues.append(value);
+        }
 
-    exportNames.append(vm.propertyNames->defaultKeyword);
-    exportValues.append(object);
-  };
+        exportNames.append(vm.propertyNames->defaultKeyword);
+        exportValues.append(object);
+    };
 }
 
 JSC::SyntheticSourceProvider::SyntheticSourceGenerator
-generateJSValueModuleSourceCode(JSC::JSGlobalObject *globalObject,
-                                JSC::JSValue value) {
+generateJSValueModuleSourceCode(JSC::JSGlobalObject* globalObject,
+    JSC::JSValue value)
+{
 
-  if (value.isObject() && !JSC::isJSArray(value)) {
-    return generateObjectModuleSourceCodeForJSON(globalObject,
-                                                 value.getObject());
-  }
-
-  if (value.isCell())
-    gcProtectNullTolerant(value.asCell());
-  return [value](JSC::JSGlobalObject *lexicalGlobalObject,
-                 JSC::Identifier moduleKey,
-                 Vector<JSC::Identifier, 4> &exportNames,
-                 JSC::MarkedArgumentBuffer &exportValues) -> void {
-    JSC::VM &vm = lexicalGlobalObject->vm();
-    exportNames.append(vm.propertyNames->defaultKeyword);
-    exportValues.append(value);
+    if (value.isObject() && !JSC::isJSArray(value)) {
+        return generateObjectModuleSourceCodeForJSON(globalObject,
+            value.getObject());
+    }
 
     if (value.isCell())
-      gcUnprotectNullTolerant(value.asCell());
-  };
+        gcProtectNullTolerant(value.asCell());
+    return [value](JSC::JSGlobalObject* lexicalGlobalObject,
+               JSC::Identifier moduleKey,
+               Vector<JSC::Identifier, 4>& exportNames,
+               JSC::MarkedArgumentBuffer& exportValues) -> void {
+        JSC::VM& vm = lexicalGlobalObject->vm();
+        exportNames.append(vm.propertyNames->defaultKeyword);
+        exportValues.append(value);
+
+        if (value.isCell())
+            gcUnprotectNullTolerant(value.asCell());
+    };
 }
-} // namespace Zig
\ No newline at end of file
+} // namespace Zig
diff --git a/src/bun.js/modules/ObjectModule.h b/src/bun.js/modules/ObjectModule.h
index 5b9aba2cd7..6988e9a94e 100644
--- a/src/bun.js/modules/ObjectModule.h
+++ b/src/bun.js/modules/ObjectModule.h
@@ -5,15 +5,15 @@
 
 namespace Zig {
 JSC::SyntheticSourceProvider::SyntheticSourceGenerator
-generateObjectModuleSourceCode(JSC::JSGlobalObject *globalObject,
-                               JSC::JSObject *object);
+generateObjectModuleSourceCode(JSC::JSGlobalObject* globalObject,
+    JSC::JSObject* object);
 
 JSC::SyntheticSourceProvider::SyntheticSourceGenerator
-generateObjectModuleSourceCodeForJSON(JSC::JSGlobalObject *globalObject,
-                                      JSC::JSObject *object);
+generateObjectModuleSourceCodeForJSON(JSC::JSGlobalObject* globalObject,
+    JSC::JSObject* object);
 
 JSC::SyntheticSourceProvider::SyntheticSourceGenerator
-generateJSValueModuleSourceCode(JSC::JSGlobalObject *globalObject,
-                                JSC::JSValue value);
+generateJSValueModuleSourceCode(JSC::JSGlobalObject* globalObject,
+    JSC::JSValue value);
 
-} // namespace Zig
\ No newline at end of file
+} // namespace Zig
diff --git a/src/bun.js/modules/UTF8ValidateModule.h b/src/bun.js/modules/UTF8ValidateModule.h
index 18f309e630..a0ea1ff72d 100644
--- a/src/bun.js/modules/UTF8ValidateModule.h
+++ b/src/bun.js/modules/UTF8ValidateModule.h
@@ -4,17 +4,18 @@ using namespace WebCore;
 
 namespace Zig {
 inline void
-generateNativeModule_UTF8Validate(JSC::JSGlobalObject *globalObject,
-                                  JSC::Identifier moduleKey,
-                                  Vector<JSC::Identifier, 4> &exportNames,
-                                  JSC::MarkedArgumentBuffer &exportValues) {
-  auto &vm = globalObject->vm();
+generateNativeModule_UTF8Validate(JSC::JSGlobalObject* globalObject,
+    JSC::Identifier moduleKey,
+    Vector<JSC::Identifier, 4>& exportNames,
+    JSC::MarkedArgumentBuffer& exportValues)
+{
+    auto& vm = globalObject->vm();
 
-  exportNames.append(vm.propertyNames->defaultKeyword);
-  exportValues.append(JSC::JSFunction::create(
-      vm, globalObject, 1, "utf8Validate"_s, jsBufferConstructorFunction_isUtf8,
-      ImplementationVisibility::Public, NoIntrinsic,
-      jsBufferConstructorFunction_isUtf8));
+    exportNames.append(vm.propertyNames->defaultKeyword);
+    exportValues.append(JSC::JSFunction::create(
+        vm, globalObject, 1, "utf8Validate"_s, jsBufferConstructorFunction_isUtf8,
+        ImplementationVisibility::Public, NoIntrinsic,
+        jsBufferConstructorFunction_isUtf8));
 }
 
 } // namespace Zig
diff --git a/src/bun.js/modules/_NativeModule.h b/src/bun.js/modules/_NativeModule.h
index 82151175ad..cd77b528d2 100644
--- a/src/bun.js/modules/_NativeModule.h
+++ b/src/bun.js/modules/_NativeModule.h
@@ -24,18 +24,25 @@
 // If you decide to not use INIT_NATIVE_MODULE. make sure the first property
 // given is the default export
 
-#define BUN_FOREACH_NATIVE_MODULE(macro) \
+#define BUN_FOREACH_ESM_AND_CJS_NATIVE_MODULE(macro) \
     macro("bun"_s, BunObject) \
     macro("bun:test"_s, BunTest) \
     macro("bun:jsc"_s, BunJSC) \
     macro("node:buffer"_s, NodeBuffer) \
     macro("node:constants"_s, NodeConstants) \
-    macro("node:module"_s, NodeModule) \
-    macro("node:process"_s, NodeProcess) \
     macro("node:string_decoder"_s, NodeStringDecoder) \
     macro("node:util/types"_s, NodeUtilTypes)  \
     macro("utf-8-validate"_s, UTF8Validate) \
-    macro("abort-controller"_s, AbortControllerModule) \
+    macro("abort-controller"_s, AbortControllerModule)
+
+#define BUN_FOREACH_ESM_NATIVE_MODULE(macro) \
+    BUN_FOREACH_ESM_AND_CJS_NATIVE_MODULE(macro) \
+    macro("node:module"_s, NodeModule)  \
+    macro("node:process"_s, NodeProcess)
+
+#define BUN_FOREACH_CJS_NATIVE_MODULE(macro) \
+    BUN_FOREACH_ESM_AND_CJS_NATIVE_MODULE(macro)
+
 
 #if ASSERT_ENABLED
 
diff --git a/src/bun.js/node/buffer.zig b/src/bun.js/node/buffer.zig
index 3a0750f05a..86d4fc73c1 100644
--- a/src/bun.js/node/buffer.zig
+++ b/src/bun.js/node/buffer.zig
@@ -1,6 +1,7 @@
 const bun = @import("root").bun;
 const JSC = bun.JSC;
 const Encoder = JSC.WebCore.Encoder;
+const Environment = bun.Environment;
 
 pub const BufferVectorized = struct {
     pub fn fill(
@@ -49,23 +50,33 @@ pub const BufferVectorized = struct {
         } catch return false;
 
         switch (written) {
-            0 => {},
-            1 => @memset(buf, buf[0]),
-            else => {
-                var contents = buf[0..written];
-                buf = buf[written..];
-
-                while (buf.len >= contents.len) {
-                    bun.copy(u8, buf, contents);
-                    buf = buf[contents.len..];
-                    contents.len *= 2;
-                }
-
-                if (buf.len > 0) {
-                    bun.copy(u8, buf, contents[0..buf.len]);
-                }
+            0 => return true,
+            1 => {
+                @memset(buf, buf[0]);
+                return true;
             },
+            inline 4, 8, 16 => |n| if (comptime Environment.isMac) {
+                const pattern = buf[0..n];
+                buf = buf[pattern.len..];
+                @field(bun.C, bun.fmt.comptimePrint("memset_pattern{d}", .{n}))(buf.ptr, pattern.ptr, buf.len);
+                return true;
+            },
+            else => {},
         }
+
+        var contents = buf[0..written];
+        buf = buf[written..];
+
+        while (buf.len >= contents.len) {
+            bun.copy(u8, buf, contents);
+            buf = buf[contents.len..];
+            contents.len *= 2;
+        }
+
+        if (buf.len > 0) {
+            bun.copy(u8, buf, contents[0..buf.len]);
+        }
+
         return true;
     }
 };
diff --git a/src/bun.js/node/node_cluster_binding.zig b/src/bun.js/node/node_cluster_binding.zig
index 61644da41d..8f6d09381e 100644
--- a/src/bun.js/node/node_cluster_binding.zig
+++ b/src/bun.js/node/node_cluster_binding.zig
@@ -12,10 +12,10 @@ 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;
+    const arguments = callframe.arguments_old(3).ptr;
     const message = arguments[0];
     const handle = arguments[1];
     const callback = arguments[2];
@@ -26,18 +26,13 @@ pub fn sendHelperChild(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFram
         return .false;
     }
     if (message.isUndefined()) {
-        return globalThis.throwValueRet(globalThis.ERR_MISSING_ARGS_static(ZigString.static("message"), null, null));
+        return globalThis.throwMissingArgumentsValue(&.{"message"});
     }
     if (!handle.isNull()) {
-        globalThis.throw("passing 'handle' not implemented yet", .{});
-        return .zero;
+        return globalThis.throw("passing 'handle' not implemented yet", .{});
     }
     if (!message.isObject()) {
-        return globalThis.throwValueRet(globalThis.ERR_INVALID_ARG_TYPE_static(
-            ZigString.static("message"),
-            ZigString.static("object"),
-            message,
-        ));
+        return globalThis.throwInvalidArgumentTypeValue("message", "object", message);
     }
     if (callback.isFunction()) {
         child_singleton.callbacks.put(bun.default_allocator, child_singleton.seq, JSC.Strong.create(callback, globalThis)) catch bun.outOfMemory();
@@ -54,8 +49,8 @@ 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 {
-            const arguments_ = callframe_.arguments(1).slice();
+        fn impl(globalThis_: *JSC.JSGlobalObject, callframe_: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+            const arguments_ = callframe_.arguments_old(1).slice();
             const ex = arguments_[0];
             Process__emitErrorEvent(globalThis_, ex);
             return .undefined;
@@ -66,7 +61,7 @@ pub fn sendHelperChild(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFram
 
     if (!good) {
         const ex = globalThis.createTypeErrorInstance("sendInternal() failed", .{});
-        ex.put(globalThis, ZigString.static("syscall"), ZigString.static("write").toJS(globalThis));
+        ex.put(globalThis, ZigString.static("syscall"), bun.String.static("write").toJS(globalThis));
         const fnvalue = JSC.JSFunction.create(globalThis, "", S.impl, 1, .{});
         Bun__Process__queueNextTick1(globalThis, fnvalue, ex);
         return .false;
@@ -75,19 +70,19 @@ 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;
+    const arguments = callframe.arguments_old(2).ptr;
     child_singleton.worker = JSC.Strong.create(arguments[0], globalThis);
     child_singleton.cb = JSC.Strong.create(arguments[1], globalThis);
-    child_singleton.flush(globalThis);
+    try child_singleton.flush(globalThis);
     return .undefined;
 }
 
-pub fn handleInternalMessageChild(globalThis: *JSC.JSGlobalObject, message: JSC.JSValue) void {
+pub fn handleInternalMessageChild(globalThis: *JSC.JSGlobalObject, message: JSC.JSValue) bun.JSError!void {
     log("handleInternalMessageChild", .{});
 
-    child_singleton.dispatch(message, globalThis);
+    try child_singleton.dispatch(message, globalThis);
 }
 
 //
@@ -115,21 +110,21 @@ pub const InternalMsgHolder = struct {
         new_item_ptr.* = JSC.Strong.create(message, globalThis);
     }
 
-    pub fn dispatch(this: *InternalMsgHolder, message: JSC.JSValue, globalThis: *JSC.JSGlobalObject) void {
+    pub fn dispatch(this: *InternalMsgHolder, message: JSC.JSValue, globalThis: *JSC.JSGlobalObject) bun.JSError!void {
         if (!this.isReady()) {
             this.enqueue(message, globalThis);
             return;
         }
-        this.dispatchUnsafe(message, globalThis);
+        try this.dispatchUnsafe(message, globalThis);
     }
 
-    fn dispatchUnsafe(this: *InternalMsgHolder, message: JSC.JSValue, globalThis: *JSC.JSGlobalObject) void {
+    fn dispatchUnsafe(this: *InternalMsgHolder, message: JSC.JSValue, globalThis: *JSC.JSGlobalObject) bun.JSError!void {
         const cb = this.cb.get().?;
         const worker = this.worker.get().?;
 
         const event_loop = globalThis.bunVM().eventLoop();
 
-        if (message.get(globalThis, "ack")) |p| {
+        if (try message.get(globalThis, "ack")) |p| {
             if (!p.isUndefined()) {
                 const ack = p.toInt32();
                 if (this.callbacks.getEntry(ack)) |entry| {
@@ -153,13 +148,13 @@ pub const InternalMsgHolder = struct {
         });
     }
 
-    pub fn flush(this: *InternalMsgHolder, globalThis: *JSC.JSGlobalObject) void {
+    pub fn flush(this: *InternalMsgHolder, globalThis: *JSC.JSGlobalObject) bun.JSError!void {
         bun.assert(this.isReady());
         var messages = this.messages;
         this.messages = .{};
         for (messages.items) |*strong| {
             if (strong.get()) |message| {
-                this.dispatchUnsafe(message, globalThis);
+                try this.dispatchUnsafe(message, globalThis);
             }
             strong.deinit();
         }
@@ -176,10 +171,10 @@ 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;
+    const arguments = callframe.arguments_old(4).ptr;
     const subprocess = arguments[0].as(bun.JSC.Subprocess).?;
     const message = arguments[1];
     const handle = arguments[2];
@@ -188,14 +183,10 @@ pub fn sendHelperPrimary(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFr
     const ipc_data = subprocess.ipc() orelse return .false;
 
     if (message.isUndefined()) {
-        return globalThis.throwValueRet(globalThis.ERR_MISSING_ARGS_static(ZigString.static("message"), null, null));
+        return globalThis.throwMissingArgumentsValue(&.{"message"});
     }
     if (!message.isObject()) {
-        return globalThis.throwValueRet(globalThis.ERR_INVALID_ARG_TYPE_static(
-            ZigString.static("message"),
-            ZigString.static("object"),
-            message,
-        ));
+        return globalThis.throwInvalidArgumentTypeValue("message", "object", message);
     }
     if (callback.isFunction()) {
         ipc_data.internal_msg_queue.callbacks.put(bun.default_allocator, ipc_data.internal_msg_queue.seq, JSC.Strong.create(callback, globalThis)) catch bun.outOfMemory();
@@ -216,8 +207,8 @@ 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 {
-    const arguments = callframe.arguments(3).ptr;
+pub fn onInternalMessagePrimary(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+    const arguments = callframe.arguments_old(3).ptr;
     const subprocess = arguments[0].as(bun.JSC.Subprocess).?;
     const ipc_data = subprocess.ipc() orelse return .undefined;
     ipc_data.internal_msg_queue.worker = JSC.Strong.create(arguments[1], globalThis);
@@ -225,12 +216,12 @@ pub fn onInternalMessagePrimary(globalThis: *JSC.JSGlobalObject, callframe: *JSC
     return .undefined;
 }
 
-pub fn handleInternalMessagePrimary(globalThis: *JSC.JSGlobalObject, subprocess: *JSC.Subprocess, message: JSC.JSValue) void {
+pub fn handleInternalMessagePrimary(globalThis: *JSC.JSGlobalObject, subprocess: *JSC.Subprocess, message: JSC.JSValue) bun.JSError!void {
     const ipc_data = subprocess.ipc() orelse return;
 
     const event_loop = globalThis.bunVM().eventLoop();
 
-    if (message.get(globalThis, "ack")) |p| {
+    if (try message.get(globalThis, "ack")) |p| {
         if (!p.isUndefined()) {
             const ack = p.toInt32();
             if (ipc_data.internal_msg_queue.callbacks.getEntry(ack)) |entry| {
@@ -260,18 +251,14 @@ 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 {
-    const arguments = callframe.arguments(1).ptr;
+pub fn setRef(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+    const arguments = callframe.arguments_old(1).ptr;
 
     if (arguments.len == 0) {
-        return globalObject.throwValueRet(globalObject.ERR_MISSING_ARGS_1(ZigString.static("enabled").toJS(globalObject)));
+        return globalObject.throwMissingArgumentsValue(&.{"enabled"});
     }
     if (!arguments[0].isBoolean()) {
-        return globalObject.throwValueRet(globalObject.ERR_INVALID_ARG_TYPE_static(
-            ZigString.static("enabled"),
-            ZigString.static("boolean"),
-            arguments[0],
-        ));
+        return globalObject.throwInvalidArgumentTypeValue("enabled", "boolean", arguments[0]);
     }
 
     const enabled = arguments[0].toBoolean();
diff --git a/src/bun.js/node/node_crypto_binding.zig b/src/bun.js/node/node_crypto_binding.zig
index 026450dc45..2605f64fb8 100644
--- a/src/bun.js/node/node_crypto_binding.zig
+++ b/src/bun.js/node/node_crypto_binding.zig
@@ -12,8 +12,9 @@ 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 {
-    const arguments = callframe.arguments(2).slice();
+
+fn randomInt(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+    const arguments = callframe.arguments_old(2).slice();
 
     //min, max
     if (!arguments[0].isNumber()) return globalThis.throwInvalidArgumentTypeValue("min", "safe integer", arguments[0]);
@@ -21,10 +22,10 @@ fn randomInt(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSV
     const min = arguments[0].to(i64);
     const max = arguments[1].to(i64);
 
-    if (min > validators.NUMBER__MAX_SAFE_INTEGER or min < validators.NUMBER__MIN_SAFE_INTEGER) {
+    if (min > JSC.MAX_SAFE_INTEGER or min < JSC.MIN_SAFE_INTEGER) {
         return globalThis.throwInvalidArgumentRangeValue("min", "It must be a safe integer type number", min);
     }
-    if (max > validators.NUMBER__MAX_SAFE_INTEGER) {
+    if (max > JSC.MAX_SAFE_INTEGER) {
         return globalThis.throwInvalidArgumentRangeValue("max", "It must be a safe integer type number", max);
     }
     if (min >= max) {
@@ -38,31 +39,19 @@ fn randomInt(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSV
     return JSC.JSValue.jsNumberFromInt64(std.crypto.random.intRangeLessThan(i64, min, max));
 }
 
-fn pbkdf2(
-    globalThis: *JSC.JSGlobalObject,
-    callframe: *JSC.CallFrame,
-) JSC.JSValue {
-    const arguments = callframe.arguments(5);
+fn pbkdf2(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+    const arguments = callframe.arguments_old(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();
 }
 
-fn pbkdf2Sync(
-    globalThis: *JSC.JSGlobalObject,
-    callframe: *JSC.CallFrame,
-) JSC.JSValue {
-    const arguments = callframe.arguments(5);
+fn pbkdf2Sync(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+    const arguments = callframe.arguments_old(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()) {
@@ -72,30 +61,24 @@ fn pbkdf2Sync(
 
     const output = out_arraybuffer.asArrayBuffer(globalThis) orelse {
         data.deinit();
-        globalThis.throwOutOfMemory();
-        return .zero;
+        return globalThis.throwOutOfMemory();
     };
 
     if (!data.run(output.slice())) {
         const err = Crypto.createCryptoError(globalThis, BoringSSL.ERR_get_error());
         BoringSSL.ERR_clear_error();
-        globalThis.throwValue(err);
-        return .zero;
+        return globalThis.throwValue(err);
     }
 
     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 8c6de402a1..818725a0dd 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 b55b957a4b..8d725cf458 100644
--- a/src/bun.js/node/node_fs.zig
+++ b/src/bun.js/node/node_fs.zig
@@ -54,7 +54,7 @@ pub const default_permission = if (Environment.isPosix)
         Syscall.S.IROTH |
         Syscall.S.IWOTH
 else
-    // TODO:
+    // Windows does not have permissions
     0;
 
 const ArrayBuffer = JSC.MarkedArrayBuffer;
@@ -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.throwInvalidArguments("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.throwInvalidArguments("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.throwInvalidArguments("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.throwInvalidArguments("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.throwInvalidArguments("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.throwInvalidArguments("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.throwInvalidArguments("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.throwInvalidArguments("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.throwInvalidArguments("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.throwInvalidArguments("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.throwInvalidArguments("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.throwInvalidArguments("file descriptor is required", .{});
+            }) orelse {
+                return ctx.throwInvalidArguments("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,65 +1500,32 @@ 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.throwInvalidArguments("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.throwInvalidArguments("uid is required", .{});
                 };
 
                 arguments.eat();
                 if (!uid_value.isNumber()) {
-                    ctx.throwValue(ctx.ERR_INVALID_ARG_TYPE_static(
-                        JSC.ZigString.static("uid"),
-                        JSC.ZigString.static("number"),
-                        uid_value,
-                    ));
-                    return null;
+                    return ctx.throwInvalidArgumentTypeValue("uid", "number", uid_value);
                 }
                 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.throwInvalidArguments("gid is required", .{});
                 };
 
                 arguments.eat();
                 if (!gid_value.isNumber()) {
-                    ctx.throwValue(ctx.ERR_INVALID_ARG_TYPE_static(
-                        JSC.ZigString.static("gid"),
-                        JSC.ZigString.static("number"),
-                        gid_value,
-                    ));
-                    return null;
+                    return ctx.throwInvalidArgumentTypeValue("gid", "number", gid_value);
                 }
                 break :brk @as(gid_t, @intCast(gid_value.toInt32()));
             };
@@ -1686,42 +1543,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.throwInvalidArguments("file descriptor is required", .{});
+            }) orelse {
+                return ctx.throwInvalidArguments("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.throwInvalidArguments("uid is required", .{});
                 };
 
                 arguments.eat();
@@ -1730,15 +1561,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.throwInvalidArguments("gid is required", .{});
                 };
 
                 arguments.eat();
@@ -1768,65 +1591,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.throwInvalidArguments("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.throwInvalidArguments("atime is required", .{});
+            }) orelse {
+                return ctx.throwInvalidArguments("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.throwInvalidArguments("mtime is required", .{});
+            }) orelse {
+                return ctx.throwInvalidArguments("mtime must be a number or a Date", .{});
             };
 
             arguments.eat();
@@ -1851,39 +1633,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.throwInvalidArguments("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.throwInvalidArguments("mode is required", .{});
+            }) orelse {
+                return ctx.throwInvalidArguments("mode must be a string or integer", .{});
             };
 
             arguments.eat();
@@ -1900,52 +1659,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.throwInvalidArguments("file descriptor is required", .{});
+            }) orelse {
+                return ctx.throwInvalidArguments("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.throwInvalidArguments("mode is required", .{});
+            }) orelse {
+                return ctx.throwInvalidArguments("mode must be a string or integer", .{});
             };
 
             arguments.eat();
@@ -1973,40 +1699,25 @@ 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.throwInvalidArguments("path must be a string or TypedArray", .{});
             };
-
-            if (exception.* != null) return null;
+            errdefer path.deinit();
 
             var throw_if_no_entry = true;
 
             const big_int = brk: {
                 if (arguments.next()) |next_val| {
                     if (next_val.isObject()) {
-                        if (next_val.isCallable(ctx.ptr().vm())) break :brk false;
+                        if (next_val.isCallable(ctx.vm())) break :brk false;
                         arguments.eat();
 
-                        if (next_val.getOptional(ctx.ptr(), "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.ptr(), "bigint", bool) catch {
-                            path.deinit();
-                            return null;
-                        }) |big_int| {
+                        if (try next_val.getBooleanStrict(ctx, "bigint")) |big_int| {
                             break :brk big_int;
                         }
                     }
@@ -2014,8 +1725,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 };
         }
     };
@@ -2028,38 +1737,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.throwInvalidArguments("file descriptor is required", .{});
+            }) orelse {
+                return ctx.throwInvalidArguments("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.ptr().vm())) break :brk false;
+                        if (next_val.isCallable(ctx.vm())) break :brk false;
                         arguments.eat();
 
-                        if (next_val.getOptional(ctx.ptr(), "bigint", bool) catch false) |big_int| {
+                        if (try next_val.getBooleanStrict(ctx, "bigint")) |big_int| {
                             break :brk big_int;
                         }
                     }
@@ -2067,8 +1758,6 @@ pub const Arguments = struct {
                 break :brk false;
             };
 
-            if (exception.* != null) return null;
-
             return Fstat{ .fd = fd, .big_int = big_int };
         }
     };
@@ -2094,35 +1783,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.throwInvalidArguments("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.throwInvalidArguments("newPath must be a string or TypedArray", .{});
             };
 
-            if (exception.* != null) return null;
-
             return Link{ .old_path = old_path, .new_path = new_path };
         }
     };
@@ -2158,35 +1827,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.throwInvalidArguments("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.throwInvalidArguments("newPath must be a string or TypedArray", .{});
             };
 
-            if (exception.* != null) return null;
-
             const link_type: LinkType = if (!Environment.isWindows)
                 0
             else link_type: {
@@ -2201,20 +1850,12 @@ pub const Arguments = struct {
                     // will automatically be normalized to absolute path.
                     if (next_val.isString()) {
                         arguments.eat();
-                        var str = next_val.toBunString(ctx.ptr());
+                        var str = next_val.toBunString(ctx);
                         defer str.deref();
                         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;
+                        return ctx.throwInvalidArguments("Symlink type must be one of \"dir\", \"file\", or \"junction\". Received \"{}\"", .{str});
                     }
 
                     // not a string. fallthrough to auto detect.
@@ -2251,33 +1892,23 @@ 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.throwInvalidArguments("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 => {
-                        encoding = Encoding.fromJS(val, ctx.ptr()) orelse Encoding.utf8;
+                        encoding = try Encoding.assert(val, ctx, encoding);
                     },
                     else => {
                         if (val.isObject()) {
-                            if (val.get(ctx.ptr(), "encoding")) |encoding_| {
-                                encoding = Encoding.fromJS(encoding_, ctx.ptr()) orelse Encoding.utf8;
-                            }
+                            encoding = try getEncoding(val, ctx, encoding);
                         }
                     },
                 }
@@ -2303,33 +1934,23 @@ 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.throwInvalidArguments("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 => {
-                        encoding = Encoding.fromJS(val, ctx.ptr()) orelse Encoding.utf8;
+                        encoding = try Encoding.assert(val, ctx, encoding);
                     },
                     else => {
                         if (val.isObject()) {
-                            if (val.get(ctx.ptr(), "encoding")) |encoding_| {
-                                encoding = Encoding.fromJS(encoding_, ctx.ptr()) orelse Encoding.utf8;
-                            }
+                            encoding = try getEncoding(val, ctx, encoding);
                         }
                     },
                 }
@@ -2339,6 +1960,14 @@ pub const Arguments = struct {
         }
     };
 
+    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);
+        }
+
+        return default;
+    }
+
     pub const Unlink = struct {
         path: PathLike,
 
@@ -2354,20 +1983,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.throwInvalidArguments("path must be a string or TypedArray", .{});
             };
-
-            if (exception.* != null) return null;
+            errdefer path.deinit();
 
             return Unlink{
                 .path = path,
@@ -2398,20 +2018,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.throwInvalidArguments("path must be a string or TypedArray", .{});
             };
-
-            if (exception.* != null) return null;
+            errdefer path.deinit();
 
             var recursive = false;
             var force = false;
@@ -2419,17 +2030,11 @@ pub const Arguments = struct {
                 arguments.eat();
 
                 if (val.isObject()) {
-                    if (val.getOptional(ctx.ptr(), "recursive", bool) catch {
-                        path.deinit();
-                        return null;
-                    }) |boolean| {
+                    if (try val.getBooleanStrict(ctx, "recursive")) |boolean| {
                         recursive = boolean;
                     }
 
-                    if (val.getOptional(ctx.ptr(), "force", bool) catch {
-                        path.deinit();
-                        return null;
-                    }) |boolean| {
+                    if (try val.getBooleanStrict(ctx, "force")) |boolean| {
                         force = boolean;
                     }
                 }
@@ -2469,20 +2074,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.throwInvalidArguments("path must be a string or TypedArray", .{});
             };
-
-            if (exception.* != null) return null;
+            errdefer path.deinit();
 
             var recursive = false;
             var mode: Mode = 0o777;
@@ -2491,16 +2087,12 @@ pub const Arguments = struct {
                 arguments.eat();
 
                 if (val.isObject()) {
-                    if (val.getOptional(ctx.ptr(), "recursive", bool) catch {
-                        path.deinit();
-                        return null;
-                    }) |boolean| {
+                    if (try val.getBooleanStrict(ctx, "recursive")) |boolean| {
                         recursive = boolean;
                     }
 
-                    if (val.get(ctx.ptr(), "mode")) |mode_| {
-                        mode = JSC.Node.modeFromJS(ctx, mode_, exception) orelse mode;
-                        if (exception.* != null) return null;
+                    if (try val.get(ctx, "mode")) |mode_| {
+                        mode = try JSC.Node.modeFromJS(ctx, mode_) orelse mode;
                     }
                 }
             }
@@ -2529,22 +2121,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.throwInvalidArguments("prefix must be a string or TypedArray", .{});
             };
-
-            if (exception.* != null) return null;
+            errdefer prefix.deinit();
 
             arguments.eat();
 
@@ -2555,13 +2138,11 @@ pub const Arguments = struct {
 
                 switch (val.jsType()) {
                     JSC.JSValue.JSType.String, JSC.JSValue.JSType.StringObject, JSC.JSValue.JSType.DerivedStringObject => {
-                        encoding = Encoding.fromJS(val, ctx.ptr()) orelse Encoding.utf8;
+                        encoding = try Encoding.assert(val, ctx, encoding);
                     },
                     else => {
                         if (val.isObject()) {
-                            if (val.get(ctx.ptr(), "encoding")) |encoding_| {
-                                encoding = Encoding.fromJS(encoding_, ctx.ptr()) orelse Encoding.utf8;
-                            }
+                            encoding = try getEncoding(val, ctx, encoding);
                         }
                     },
                 }
@@ -2602,20 +2183,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.throwInvalidArguments("path must be a string or TypedArray", .{});
             };
-
-            if (exception.* != null) return null;
+            errdefer path.deinit();
 
             var encoding = Encoding.utf8;
             var with_file_types = false;
@@ -2625,26 +2197,21 @@ pub const Arguments = struct {
                 arguments.eat();
 
                 switch (val.jsType()) {
-                    JSC.JSValue.JSType.String, JSC.JSValue.JSType.StringObject, JSC.JSValue.JSType.DerivedStringObject => {
-                        encoding = Encoding.fromJS(val, ctx.ptr()) orelse Encoding.utf8;
+                    .String,
+                    .StringObject,
+                    .DerivedStringObject,
+                    => {
+                        encoding = try Encoding.assert(val, ctx, encoding);
                     },
                     else => {
                         if (val.isObject()) {
-                            if (val.get(ctx.ptr(), "encoding")) |encoding_| {
-                                encoding = Encoding.fromJS(encoding_, ctx.ptr()) orelse Encoding.utf8;
-                            }
+                            encoding = try getEncoding(val, ctx, encoding);
 
-                            if (val.getOptional(ctx.ptr(), "recursive", bool) catch {
-                                path.deinit();
-                                return null;
-                            }) |recursive_| {
+                            if (try val.getBooleanStrict(ctx, "recursive")) |recursive_| {
                                 recursive = recursive_;
                             }
 
-                            if (val.getOptional(ctx.ptr(), "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_;
                             }
                         }
@@ -2667,31 +2234,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.throwInvalidArguments("file descriptor is required", .{});
+            }) orelse {
+                return ctx.throwInvalidArguments("file descriptor must be a number", .{});
             };
 
-            if (exception.* != null) return null;
-
             return Close{ .fd = fd };
         }
     };
@@ -2713,20 +2262,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.throwInvalidArguments("path must be a string or TypedArray", .{});
             };
-
-            if (exception.* != null) return null;
+            errdefer path.deinit();
 
             var flags = FileSystemFlags.r;
             var mode: Mode = default_permission;
@@ -2735,31 +2275,25 @@ pub const Arguments = struct {
                 arguments.eat();
 
                 if (val.isObject()) {
-                    if (val.getTruthy(ctx.ptr(), "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.ptr(), "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,
@@ -2788,78 +2322,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.throwInvalidArguments("file descriptor is required", .{});
+            }) orelse {
+                return ctx.throwInvalidArguments("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.throwInvalidArguments("atime is required", .{});
+            }) orelse {
+                return ctx.throwInvalidArguments("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.throwInvalidArguments("mtime is required", .{});
+            }) orelse {
+                return ctx.throwInvalidArguments("mtime must be a number or a Date", .{});
             };
-
-            if (exception.* != null) return null;
+            arguments.eat();
 
             return Futimes{
                 .fd = fd,
@@ -2914,55 +2397,23 @@ 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.throwInvalidArguments("file descriptor is required", .{});
+            }) orelse {
+                return ctx.throwInvalidArguments("file descriptor must be a number", .{});
             };
-
             arguments.eat();
 
-            if (exception.* != null) return null;
-
-            const buffer = StringOrBuffer.fromJS(ctx.ptr(), bun.default_allocator, arguments.next() orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "data is required",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+            const buffer_value = arguments.next();
+            const buffer = StringOrBuffer.fromJS(ctx, bun.default_allocator, buffer_value orelse {
+                return ctx.throwInvalidArguments("data is required", .{});
             }) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "data must be a string or TypedArray",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+                return ctx.throwInvalidArgumentTypeValue("buffer", "string or TypedArray", buffer_value.?);
             };
-            if (exception.* != null) return null;
+            if (buffer_value.?.isString() and !buffer_value.?.isStringLiteral()) {
+                return ctx.throwInvalidArgumentTypeValue("buffer", "string or TypedArray", buffer_value.?);
+            }
 
             var args = Write{
                 .fd = fd,
@@ -2972,6 +2423,7 @@ pub const Arguments = struct {
                     inline else => Encoding.utf8,
                 },
             };
+            errdefer args.deinit();
 
             arguments.eat();
 
@@ -2989,7 +2441,7 @@ pub const Arguments = struct {
                             }
 
                             if (current.isString()) {
-                                args.encoding = Encoding.fromJS(current, ctx.ptr()) orelse Encoding.utf8;
+                                args.encoding = try Encoding.assert(current, ctx, args.encoding);
                                 arguments.eat();
                             }
                         },
@@ -3038,57 +2490,20 @@ 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.throwInvalidArguments("file descriptor is required", .{});
+            }) orelse {
+                return ctx.throwInvalidArguments("file descriptor must be a number", .{});
             };
-
             arguments.eat();
 
-            if (exception.* != null) return null;
-
-            const buffer = Buffer.fromJS(ctx.ptr(), arguments.next() 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_value = arguments.next();
+            const buffer = Buffer.fromJS(ctx, buffer_value orelse {
+                return ctx.throwInvalidArguments("buffer is required", .{});
+            }) orelse {
+                return ctx.throwInvalidArgumentTypeValue("buffer", "TypedArray", buffer_value.?);
             };
-
-            if (exception.* != null) return null;
-
             arguments.eat();
 
             var args = Read{
@@ -3096,26 +2511,23 @@ pub const Arguments = struct {
                 .buffer = buffer,
             };
 
+            var defined_length = false;
             if (arguments.next()) |current| {
                 arguments.eat();
                 if (current.isNumber() or current.isBigInt()) {
                     args.offset = current.to(u52);
 
                     if (arguments.remaining.len < 1) {
-                        JSC.throwInvalidArguments("length is required", .{}, ctx, exception);
-                        return null;
+                        return ctx.throwInvalidArguments("length is required", .{});
                     }
 
                     const arg_length = arguments.next().?;
                     arguments.eat();
+                    defined_length = true;
 
                     if (arg_length.isNumber() or arg_length.isBigInt()) {
                         args.length = arg_length.to(u52);
                     }
-                    if (args.length == 0) {
-                        JSC.throwInvalidArguments("length must be greater than 0", .{}, ctx, exception);
-                        return null;
-                    }
 
                     if (arguments.next()) |arg_position| {
                         arguments.eat();
@@ -3124,19 +2536,20 @@ pub const Arguments = struct {
                         }
                     }
                 } else if (current.isObject()) {
-                    if (current.getTruthy(ctx.ptr(), "offset")) |num| {
+                    if (try current.getTruthy(ctx, "offset")) |num| {
                         if (num.isNumber() or num.isBigInt()) {
                             args.offset = num.to(u52);
                         }
                     }
 
-                    if (current.getTruthy(ctx.ptr(), "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.ptr(), "position")) |num| {
+                    if (try current.getTruthy(ctx, "position")) |num| {
                         if (num.isNumber() or num.isBigInt()) {
                             args.position = num.to(i52);
                         }
@@ -3144,6 +2557,11 @@ pub const Arguments = struct {
                 }
             }
 
+            if (defined_length and args.length > 0 and buffer.slice().len == 0) {
+                var formatter = bun.JSC.ConsoleObject.Formatter{ .globalThis = ctx };
+                return ctx.ERR_INVALID_ARG_VALUE("The argument 'buffer' is empty and cannot be written. Received {}", .{buffer_value.?.toFmt(&formatter)}).throw();
+            }
+
             return args;
         }
     };
@@ -3175,20 +2593,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.throwInvalidArguments("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;
@@ -3196,45 +2605,13 @@ pub const Arguments = struct {
             if (arguments.next()) |arg| {
                 arguments.eat();
                 if (arg.isString()) {
-                    encoding = Encoding.fromJS(arg, ctx.ptr()) orelse {
-                        if (exception.* == null) {
-                            JSC.throwInvalidArguments(
-                                "Invalid encoding",
-                                .{},
-                                ctx,
-                                exception,
-                            );
-                        }
-                        return null;
-                    };
+                    encoding = try Encoding.assert(arg, ctx, encoding);
                 } else if (arg.isObject()) {
-                    if (arg.get(ctx.ptr(), "encoding")) |encoding_| {
-                        if (!encoding_.isUndefinedOrNull()) {
-                            encoding = Encoding.fromJS(encoding_, ctx.ptr()) orelse {
-                                if (exception.* == null) {
-                                    JSC.throwInvalidArguments(
-                                        "Invalid encoding",
-                                        .{},
-                                        ctx,
-                                        exception,
-                                    );
-                                }
-                                return null;
-                            };
-                        }
-                    }
+                    encoding = try getEncoding(arg, ctx, encoding);
 
-                    if (arg.getTruthy(ctx.ptr(), "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.throwInvalidArguments("Invalid flag", .{});
                         };
                     }
                 }
@@ -3277,32 +2654,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.throwInvalidArguments("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.throwInvalidArguments("data is required", .{});
             };
 
             var encoding = Encoding.buffer;
@@ -3316,82 +2675,31 @@ pub const Arguments = struct {
             if (arguments.next()) |arg| {
                 arguments.eat();
                 if (arg.isString()) {
-                    encoding = Encoding.fromJS(arg, ctx.ptr()) orelse {
-                        defer file.deinit();
-                        if (exception.* == null) {
-                            JSC.throwInvalidArguments(
-                                "Invalid encoding",
-                                .{},
-                                ctx,
-                                exception,
-                            );
-                        }
-                        return null;
-                    };
+                    encoding = try Encoding.assert(arg, ctx, encoding);
                 } else if (arg.isObject()) {
-                    if (arg.getTruthy(ctx.ptr(), "encoding")) |encoding_| {
-                        encoding = Encoding.fromJS(encoding_, ctx.ptr()) orelse {
-                            defer file.deinit();
-                            if (exception.* == null) {
-                                JSC.throwInvalidArguments(
-                                    "Invalid encoding",
-                                    .{},
-                                    ctx,
-                                    exception,
-                                );
-                            }
-                            return null;
+                    encoding = try getEncoding(arg, ctx, encoding);
+
+                    if (try arg.getTruthy(ctx, "flag")) |flag_| {
+                        flag = try FileSystemFlags.fromJS(ctx, flag_) orelse {
+                            return ctx.throwInvalidArguments("Invalid flag", .{});
                         };
                     }
 
-                    if (arg.getTruthy(ctx.ptr(), "flag")) |flag_| {
-                        flag = FileSystemFlags.fromJS(ctx, flag_, exception) orelse {
-                            defer file.deinit();
-                            if (exception.* == null) {
-                                JSC.throwInvalidArguments(
-                                    "Invalid flag",
-                                    .{},
-                                    ctx,
-                                    exception,
-                                );
-                            }
-                            return null;
-                        };
-                    }
-
-                    if (arg.getTruthy(ctx.ptr(), "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.throwInvalidArguments("Invalid mode", .{});
                         };
                     }
                 }
             }
 
-            const data = StringOrBuffer.fromJSWithEncodingMaybeAsync(ctx.ptr(), 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.throwInvalidArguments("data must be a string or TypedArray", .{});
             };
 
             // Note: Signal is not implemented
             return WriteFile{
-                .file = file,
+                .file = path,
                 .encoding = encoding,
                 .flag = flag,
                 .mode = mode,
@@ -3414,20 +2722,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.throwInvalidArguments("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;
@@ -3435,46 +2734,16 @@ pub const Arguments = struct {
             if (arguments.next()) |arg| {
                 arguments.eat();
                 if (arg.isString()) {
-                    encoding = Encoding.fromJS(arg, ctx.ptr()) orelse {
-                        if (exception.* == null) {
-                            JSC.throwInvalidArguments(
-                                "Invalid encoding",
-                                .{},
-                                ctx,
-                                exception,
-                            );
-                        }
-                        return null;
-                    };
+                    encoding = Encoding.assert(arg, ctx, encoding) catch encoding;
                 } else if (arg.isObject()) {
-                    if (arg.get(ctx.ptr(), "encoding")) |encoding_| {
-                        if (!encoding_.isUndefinedOrNull()) {
-                            encoding = Encoding.fromJS(encoding_, ctx.ptr()) orelse {
-                                if (exception.* == null) {
-                                    JSC.throwInvalidArguments(
-                                        "Invalid encoding",
-                                        .{},
-                                        ctx,
-                                        exception,
-                                    );
-                                }
-                                return null;
-                            };
-                        }
+                    if (getEncoding(arg, ctx)) |encoding_| {
+                        encoding = encoding_;
                     }
 
-                    if (arg.get(ctx.ptr(), "bufferSize")) |buffer_size_| {
+                    if (try 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.throwInvalidArguments("bufferSize must be > 0", .{});
                         }
                     }
                 }
@@ -3509,9 +2778,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),
             };
         }
     };
@@ -3532,36 +2801,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.throwInvalidArguments("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.throwInvalidArguments("Invalid mode", .{});
                     };
                 }
             }
@@ -3573,275 +2825,6 @@ pub const Arguments = struct {
         }
     };
 
-    pub const CreateReadStream = struct {
-        file: PathOrFileDescriptor,
-        flags: FileSystemFlags = FileSystemFlags.r,
-        encoding: Encoding = Encoding.utf8,
-        mode: Mode = default_permission,
-        autoClose: bool = true,
-        emitClose: bool = true,
-        start: i32 = 0,
-        end: i32 = std.math.maxInt(i32),
-        highwater_mark: u32 = 64 * 1024,
-        global_object: *JSC.JSGlobalObject,
-
-        pub fn deinit(this: CreateReadStream) void {
-            this.file.deinit();
-        }
-
-        pub fn copyToState(this: CreateReadStream, state: *JSC.Node.Readable.State) void {
-            state.encoding = this.encoding;
-            state.highwater_mark = this.highwater_mark;
-            state.start = this.start;
-            state.end = this.end;
-        }
-
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?CreateReadStream {
-            const path = PathLike.fromJS(ctx, arguments, exception);
-            if (exception.* != null) return null;
-            if (path == null) arguments.eat();
-
-            var stream = CreateReadStream{
-                .file = undefined,
-                .global_object = ctx.ptr(),
-            };
-            var fd = FileDescriptor.invalid;
-
-            if (arguments.next()) |arg| {
-                arguments.eat();
-                if (arg.isString()) {
-                    stream.encoding = Encoding.fromJS(arg, ctx.ptr()) orelse {
-                        if (exception.* != null) {
-                            JSC.throwInvalidArguments(
-                                "Invalid encoding",
-                                .{},
-                                ctx,
-                                exception,
-                            );
-                        }
-                        return null;
-                    };
-                } else if (arg.isObject()) {
-                    if (arg.get(ctx.ptr(), "mode")) |mode_| {
-                        stream.mode = JSC.Node.modeFromJS(ctx, mode_, exception) orelse {
-                            if (exception.* != null) {
-                                JSC.throwInvalidArguments(
-                                    "Invalid mode",
-                                    .{},
-                                    ctx,
-                                    exception,
-                                );
-                            }
-                            return null;
-                        };
-                    }
-
-                    if (arg.get(ctx.ptr(), "encoding")) |encoding| {
-                        stream.encoding = Encoding.fromJS(encoding, ctx.ptr()) orelse {
-                            if (exception.* != null) {
-                                JSC.throwInvalidArguments(
-                                    "Invalid encoding",
-                                    .{},
-                                    ctx,
-                                    exception,
-                                );
-                            }
-                            return null;
-                        };
-                    }
-
-                    if (arg.getTruthy(ctx.ptr(), "flags")) |flags| {
-                        stream.flags = FileSystemFlags.fromJS(ctx, flags, exception) orelse {
-                            if (exception.* == null) {
-                                JSC.throwInvalidArguments(
-                                    "Invalid flags",
-                                    .{},
-                                    ctx,
-                                    exception,
-                                );
-                            }
-                            return null;
-                        };
-                    }
-
-                    if (arg.get(ctx.ptr(), "fd")) |flags| {
-                        fd = JSC.Node.fileDescriptorFromJS(ctx, flags, exception) orelse {
-                            if (exception.* != null) {
-                                JSC.throwInvalidArguments(
-                                    "Invalid file descriptor",
-                                    .{},
-                                    ctx,
-                                    exception,
-                                );
-                            }
-                            return null;
-                        };
-                    }
-
-                    if (arg.get(ctx.ptr(), "autoClose")) |autoClose| {
-                        stream.autoClose = autoClose.toBoolean();
-                    }
-
-                    if (arg.get(ctx.ptr(), "emitClose")) |emitClose| {
-                        stream.emitClose = emitClose.toBoolean();
-                    }
-
-                    if (arg.get(ctx.ptr(), "start")) |start| {
-                        stream.start = start.coerce(i32, ctx);
-                    }
-
-                    if (arg.get(ctx.ptr(), "end")) |end| {
-                        stream.end = end.coerce(i32, ctx);
-                    }
-
-                    if (arg.get(ctx.ptr(), "highWaterMark")) |highwaterMark| {
-                        stream.highwater_mark = highwaterMark.toU32();
-                    }
-                }
-            }
-
-            if (fd.isValid()) {
-                stream.file = .{ .fd = fd };
-            } else if (path) |path_| {
-                stream.file = .{ .path = path_ };
-            } else {
-                JSC.throwInvalidArguments("Missing path or file descriptor", .{}, ctx, exception);
-                return null;
-            }
-            return stream;
-        }
-    };
-
-    pub const CreateWriteStream = struct {
-        file: PathOrFileDescriptor,
-        flags: FileSystemFlags = FileSystemFlags.w,
-        encoding: Encoding = Encoding.utf8,
-        mode: Mode = default_permission,
-        autoClose: bool = true,
-        emitClose: bool = true,
-        start: i32 = 0,
-        highwater_mark: u32 = 256 * 1024,
-        global_object: *JSC.JSGlobalObject,
-
-        pub fn deinit(this: @This()) void {
-            this.file.deinit();
-        }
-
-        pub fn copyToState(this: CreateWriteStream, state: *JSC.Node.Writable.State) void {
-            state.encoding = this.encoding;
-            state.highwater_mark = this.highwater_mark;
-            state.start = this.start;
-            state.emit_close = this.emitClose;
-        }
-
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?CreateWriteStream {
-            const path = PathLike.fromJS(ctx, arguments, exception);
-            if (exception.* != null) return null;
-            if (path == null) arguments.eat();
-
-            var stream = CreateWriteStream{
-                .file = undefined,
-                .global_object = ctx.ptr(),
-            };
-            var fd: FileDescriptor = bun.invalid_fd;
-
-            if (arguments.next()) |arg| {
-                arguments.eat();
-                if (arg.isString()) {
-                    stream.encoding = Encoding.fromJS(arg, ctx.ptr()) orelse {
-                        if (exception.* != null) {
-                            JSC.throwInvalidArguments(
-                                "Invalid encoding",
-                                .{},
-                                ctx,
-                                exception,
-                            );
-                        }
-                        return null;
-                    };
-                } else if (arg.isObject()) {
-                    if (arg.get(ctx.ptr(), "mode")) |mode_| {
-                        stream.mode = JSC.Node.modeFromJS(ctx, mode_, exception) orelse {
-                            if (exception.* != null) {
-                                JSC.throwInvalidArguments(
-                                    "Invalid mode",
-                                    .{},
-                                    ctx,
-                                    exception,
-                                );
-                            }
-                            return null;
-                        };
-                    }
-
-                    if (arg.get(ctx.ptr(), "encoding")) |encoding| {
-                        stream.encoding = Encoding.fromJS(encoding, ctx.ptr()) orelse {
-                            if (exception.* != null) {
-                                JSC.throwInvalidArguments(
-                                    "Invalid encoding",
-                                    .{},
-                                    ctx,
-                                    exception,
-                                );
-                            }
-                            return null;
-                        };
-                    }
-
-                    if (arg.getTruthy(ctx.ptr(), "flags")) |flags| {
-                        stream.flags = FileSystemFlags.fromJS(ctx, flags, exception) orelse {
-                            if (exception.* == null) {
-                                JSC.throwInvalidArguments(
-                                    "Invalid flags",
-                                    .{},
-                                    ctx,
-                                    exception,
-                                );
-                            }
-                            return null;
-                        };
-                    }
-
-                    if (arg.get(ctx.ptr(), "fd")) |flags| {
-                        fd = JSC.Node.fileDescriptorFromJS(ctx, flags, exception) orelse {
-                            if (exception.* != null) {
-                                JSC.throwInvalidArguments(
-                                    "Invalid file descriptor",
-                                    .{},
-                                    ctx,
-                                    exception,
-                                );
-                            }
-                            return null;
-                        };
-                    }
-
-                    if (arg.get(ctx.ptr(), "autoClose")) |autoClose| {
-                        stream.autoClose = autoClose.toBoolean();
-                    }
-
-                    if (arg.get(ctx.ptr(), "emitClose")) |emitClose| {
-                        stream.emitClose = emitClose.toBoolean();
-                    }
-
-                    if (arg.get(ctx.ptr(), "start")) |start| {
-                        stream.start = start.toInt32();
-                    }
-                }
-            }
-
-            if (fd != bun.invalid_fd) {
-                stream.file = .{ .fd = fd };
-            } else if (path) |path_| {
-                stream.file = .{ .path = path_ };
-            } else {
-                JSC.throwInvalidArguments("Missing path or file descriptor", .{}, ctx, exception);
-                return null;
-            }
-            return stream;
-        }
-    };
-
     pub const FdataSync = struct {
         fd: FileDescriptor,
 
@@ -3850,30 +2833,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.throwInvalidArguments("file descriptor is required", .{});
+            }) orelse {
+                return ctx.throwInvalidArguments("file descriptor must be a number", .{});
             };
-
-            if (exception.* != null) return null;
+            arguments.eat();
 
             return FdataSync{ .fd = fd };
         }
@@ -3899,36 +2865,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.throwInvalidArguments("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.throwInvalidArguments("dest must be a string or TypedArray", .{});
             };
-
-            if (exception.* != null) return null;
+            errdefer dest.deinit();
 
             var mode: i32 = 0;
             if (arguments.next()) |arg| {
@@ -3966,35 +2912,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.throwInvalidArguments("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.throwInvalidArguments("dest must be a string or TypedArray", .{});
             };
-
-            if (exception.* != null) return null;
+            errdefer dest.deinit();
 
             var recursive: bool = false;
             var errorOnExist: bool = false;
@@ -4060,30 +2987,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.throwInvalidArguments("file descriptor is required", .{});
+            }) orelse {
+                return ctx.throwInvalidArguments("file descriptor must be a number", .{});
             };
-
-            if (exception.* != null) return null;
+            arguments.eat();
 
             return Fsync{ .fd = fd };
         }
@@ -4241,6 +3151,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,
     };
@@ -4278,11 +3189,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) {
@@ -4859,21 +3766,11 @@ pub const NodeFS = struct {
     pub fn mkdirRecursiveImpl(this: *NodeFS, args: Arguments.Mkdir, comptime flavor: Flavor, comptime Ctx: type, ctx: Ctx) Maybe(Return.Mkdir) {
         _ = flavor;
         var buf: bun.OSPathBuffer = undefined;
-        const path: bun.OSPathSliceZ = if (!Environment.isWindows)
-            args.path.osPath(&buf)
-        else brk: {
-            // TODO(@paperdave): clean this up a lot.
-            var joined_buf: bun.PathBuffer = undefined;
-            if (std.fs.path.isAbsolute(args.path.slice())) {
-                const utf8 = PosixToWinNormalizer.resolveCWDWithExternalBufZ(&joined_buf, args.path.slice()) catch
-                    return .{ .err = .{ .errno = @intFromEnum(C.SystemErrno.ENOMEM), .syscall = .getcwd } };
-                break :brk strings.toWPath(&buf, utf8);
-            } else {
-                var cwd_buf: bun.PathBuffer = undefined;
-                const cwd = std.posix.getcwd(&cwd_buf) catch return .{ .err = .{ .errno = @intFromEnum(C.SystemErrno.ENOMEM), .syscall = .getcwd } };
-                break :brk strings.toWPath(&buf, bun.path.joinAbsStringBuf(cwd, &joined_buf, &.{args.path.slice()}, .windows));
-            }
-        };
+        const path: bun.OSPathSliceZ = if (Environment.isWindows)
+            strings.toNTPath(&buf, args.path.slice())
+        else
+            args.path.osPath(&buf);
+
         // TODO: remove and make it always a comptime argument
         return switch (args.always_return_none) {
             inline else => |always_return_none| this.mkdirRecursiveOSPathImpl(Ctx, ctx, path, args.mode, !always_return_none),
@@ -4923,7 +3820,12 @@ pub const NodeFS = struct {
                         return .{ .result = .{ .none = {} } };
                     },
                     // continue
-                    .NOENT => {},
+                    .NOENT => {
+                        if (len == 0) {
+                            // no path to copy
+                            return .{ .err = err };
+                        }
+                    },
                 }
             },
             .result => {
@@ -5147,6 +4049,11 @@ pub const NodeFS = struct {
     }
 
     pub fn read(this: *NodeFS, args: Arguments.Read, comptime flavor: Flavor) Maybe(Return.Read) {
+        const len1 = args.buffer.slice().len;
+        const len2 = args.length;
+        if (len1 == 0 or len2 == 0) {
+            return Maybe(Return.Read).initResult(.{ .bytes_read = 0 });
+        }
         return if (args.position != null)
             this._pread(
                 args,
@@ -5801,6 +4708,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);
 
@@ -5815,7 +4735,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: {
@@ -5851,8 +4771,8 @@ pub const NodeFS = struct {
 
                 break :brk switch (bun.sys.open(
                     path,
-                    bun.O.RDONLY | bun.O.NOCTTY,
-                    0,
+                    @intFromEnum(args.flag) | bun.O.NOCTTY,
+                    default_permission,
                 )) {
                     .err => |err| return .{
                         .err = err.withPath(if (args.path == .path) args.path.path.slice() else ""),
@@ -5879,6 +4799,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,
@@ -5886,10 +4907,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);
@@ -5903,6 +4920,7 @@ pub const NodeFS = struct {
                     // Only used in DOMFormData
                     max_size,
                 ),
+                @as(i64, @intCast(total)),
                 0,
             ),
         ) + @intFromBool(comptime string_type == .null_terminated);
@@ -5916,14 +4934,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)])) {
@@ -6081,16 +5108,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)),
                         }
                     };
 
@@ -6525,7 +5551,7 @@ pub const NodeFS = struct {
                 .message = bun.String.init(buf),
                 .code = bun.String.init(@errorName(err)),
                 .path = bun.String.init(args.path.slice()),
-            }).toErrorInstance(args.global_this));
+            }).toErrorInstance(args.global_this)) catch {};
             return Maybe(Return.Watch){ .result = JSC.JSValue.undefined };
         };
         return Maybe(Return.Watch){ .result = watcher };
@@ -6619,14 +5645,6 @@ pub const NodeFS = struct {
         return args.createFSWatcher();
     }
 
-    pub fn createReadStream(_: *NodeFS, _: Arguments.CreateReadStream, comptime _: Flavor) Maybe(Return.CreateReadStream) {
-        return Maybe(Return.CreateReadStream).todo();
-    }
-
-    pub fn createWriteStream(_: *NodeFS, _: Arguments.CreateWriteStream, comptime _: Flavor) Maybe(Return.CreateWriteStream) {
-        return Maybe(Return.CreateWriteStream).todo();
-    }
-
     /// This function is `cpSync`, but only if you pass `{ recursive: ..., force: ..., errorOnExist: ..., mode: ... }'
     /// The other options like `filter` use a JS fallback, see `src/js/internal/fs/cp.ts`
     pub fn cp(this: *NodeFS, args: Arguments.Cp, comptime flavor: Flavor) Maybe(Return.Cp) {
diff --git a/src/bun.js/node/node_fs_binding.zig b/src/bun.js/node/node_fs_binding.zig
index 4f10e96b8a..cee9ac021f 100644
--- a/src/bun.js/node/node_fs_binding.zig
+++ b/src/bun.js/node/node_fs_binding.zig
@@ -10,11 +10,7 @@ const FeatureFlags = bun.FeatureFlags;
 const Args = JSC.Node.NodeFS.Arguments;
 const d = JSC.d;
 
-const NodeFSFunction = fn (
-    this: *JSC.Node.NodeJSFS,
-    globalObject: *JSC.JSGlobalObject,
-    callframe: *JSC.CallFrame,
-) JSC.JSValue;
+const NodeFSFunction = fn (this: *JSC.Node.NodeJSFS, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue;
 
 const NodeFSFunctionEnum = std.meta.DeclEnum(JSC.Node.NodeFS);
 
@@ -30,35 +26,21 @@ fn callSync(comptime FunctionEnum: NodeFSFunctionEnum) NodeFSFunction {
     _ = Result;
 
     const NodeBindingClosure = struct {
-        pub fn bind(
-            this: *JSC.Node.NodeJSFS,
-            globalObject: *JSC.JSGlobalObject,
-            callframe: *JSC.CallFrame,
-        ) JSC.JSValue {
-            var exceptionref: JSC.C.JSValueRef = null;
-
-            var arguments = callframe.arguments(8);
+        pub fn bind(this: *JSC.Node.NodeJSFS, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+            var arguments = callframe.arguments_old(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);
+            if (globalObject.hasException()) {
                 return .zero;
             }
             var result = Function(
@@ -68,8 +50,7 @@ fn callSync(comptime FunctionEnum: NodeFSFunctionEnum) NodeFSFunction {
             );
             switch (result) {
                 .err => |err| {
-                    globalObject.throwValue(JSC.JSValue.c(err.toJS(globalObject)));
-                    return .zero;
+                    return globalObject.throwValue(JSC.JSValue.c(err.toJS(globalObject)));
                 },
                 .result => |*res| {
                     return globalObject.toJS(res, .temporary);
@@ -89,34 +70,24 @@ 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 {
-            var arguments = callframe.arguments(8);
+        pub fn bind(this: *JSC.Node.NodeJSFS, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+            var arguments = callframe.arguments_old(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);
-
+            if (globalObject.hasException()) {
                 slice.deinit();
                 return .zero;
             }
 
-            // TODO: handle globalObject.throwValue
-
             const Task = @field(JSC.Node.Async, @tagName(FunctionEnum));
             if (comptime FunctionEnum == .cp) {
                 return Task.create(globalObject, this, args, globalObject.bunVM(), slice.arena);
@@ -140,11 +111,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) {
@@ -259,22 +225,20 @@ 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 {
-    const arguments = callFrame.arguments(1);
+pub fn createMemfdForTesting(globalObject: *JSC.JSGlobalObject, callFrame: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+    const arguments = callFrame.arguments_old(1);
 
     if (arguments.len < 1) {
         return .undefined;
     }
 
     if (comptime !bun.Environment.isLinux) {
-        globalObject.throw("memfd_create is not implemented on this platform", .{});
-        return .zero;
+        return globalObject.throw("memfd_create is not implemented on this platform", .{});
     }
 
     const size = arguments.ptr[0].toInt64();
@@ -284,8 +248,7 @@ pub fn createMemfdForTesting(globalObject: *JSC.JSGlobalObject, callFrame: *JSC.
             return JSC.JSValue.jsNumber(fd.cast());
         },
         .err => |err| {
-            globalObject.throwValue(err.toJSC(globalObject));
-            return .zero;
+            return globalObject.throwValue(err.toJSC(globalObject));
         },
     }
 }
diff --git a/src/bun.js/node/node_fs_stat_watcher.zig b/src/bun.js/node/node_fs_stat_watcher.zig
index 5f197a0c1b..55418ffca8 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.throwInvalidArguments("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 (try 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.throwInvalidArguments("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.throwInvalidArguments("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 209d4c85f9..f2ccb8258c 100644
--- a/src/bun.js/node/node_fs_watcher.zig
+++ b/src/bun.js/node/node_fs_watcher.zig
@@ -340,21 +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 {
-            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;
-            };
 
-            if (exception.* != null) return null;
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!Arguments {
+            const vm = ctx.vm();
+            const path = try PathLike.fromJS(ctx, arguments) orelse {
+                return ctx.throwInvalidArguments("filename must be a string or TypedArray", .{});
+            };
+            var should_deinit_path = true;
+            defer if (should_deinit_path) path.deinit();
+
             var listener: JSC.JSValue = .zero;
             var signal: ?*JSC.AbortSignal = null;
             var persistent: bool = true;
@@ -365,107 +359,62 @@ pub const FSWatcher = struct {
 
                 // options
                 if (options_or_callable.isObject()) {
-                    if (options_or_callable.get(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.throwInvalidArguments("persistent must be a boolean", .{});
                         }
                         persistent = persistent_.toBoolean();
                     }
 
-                    if (options_or_callable.get(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.throwInvalidArguments("verbose must be a boolean", .{});
                         }
                         verbose = verbose_.toBoolean();
                     }
 
-                    if (options_or_callable.get(ctx, "encoding")) |encoding_| {
-                        if (!encoding_.isString()) {
-                            JSC.throwInvalidArguments(
-                                "encoding must be a string.",
-                                .{},
-                                ctx,
-                                exception,
-                            );
-                            return null;
-                        }
-                        if (JSC.Node.Encoding.fromJS(encoding_, ctx.ptr())) |node_encoding| {
-                            encoding = node_encoding;
-                        } else {
-                            JSC.throwInvalidArguments(
-                                "invalid encoding.",
-                                .{},
-                                ctx,
-                                exception,
-                            );
-                            return null;
-                        }
+                    if (options_or_callable.fastGet(ctx, .encoding)) |encoding_| {
+                        encoding = try JSC.Node.Encoding.assert(encoding_, ctx, encoding);
                     }
 
-                    if (options_or_callable.get(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.throwInvalidArguments("recursive must be a boolean", .{});
                         }
                         recursive = recursive_.toBoolean();
                     }
 
                     // abort signal
-                    if (options_or_callable.get(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.throwInvalidArguments("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.throwInvalidArguments("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.throwInvalidArguments("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.throwInvalidArguments("Expected \"listener\" callback", .{});
             }
 
+            should_deinit_path = false;
+
             return Arguments{
                 .path = path,
                 .listener = listener,
@@ -606,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);
@@ -614,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);
@@ -622,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);
     }
 
@@ -692,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 a393736cd2..ab4a9ae4a9 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 {
-    const arguments = callframe.arguments(1).slice();
+pub fn getBunServerAllClosedPromise(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+    const arguments = callframe.arguments_old(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 {
-    const arguments = callframe.arguments(1).slice();
+pub fn setMaxHTTPHeaderSize(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+    const arguments = callframe.arguments_old(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 8a4854261f..ade4c17c0c 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,16 +23,14 @@ 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 {
-            const arguments = callframe.arguments(1);
+        fn setter(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+            const arguments = callframe.arguments_old(1);
             if (arguments.len < 1) {
-                globalThis.throw("missing argument", .{});
-                return .undefined;
+                return globalThis.throw("missing argument", .{});
             }
             const arg = arguments.slice()[0];
             if (!arg.isBoolean()) {
-                globalThis.throwInvalidArguments("autoSelectFamilyDefault", .{});
-                return .undefined;
+                return globalThis.throwInvalidArguments("autoSelectFamilyDefault", .{});
             }
             const value = arg.toBoolean();
             autoSelectFamilyDefault = value;
@@ -48,7 +46,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,16 +56,14 @@ 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 {
-            const arguments = callframe.arguments(1);
+        fn setter(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+            const arguments = callframe.arguments_old(1);
             if (arguments.len < 1) {
-                globalThis.throw("missing argument", .{});
-                return .undefined;
+                return globalThis.throw("missing argument", .{});
             }
             const arg = arguments.slice()[0];
             if (!arg.isInt32AsAnyInt()) {
-                globalThis.throwInvalidArguments("autoSelectFamilyAttemptTimeoutDefault", .{});
-                return .undefined;
+                return globalThis.throwInvalidArguments("autoSelectFamilyAttemptTimeoutDefault", .{});
             }
             const value: u32 = @max(10, arg.coerceToInt32(globalThis));
             autoSelectFamilyAttemptTimeoutDefault = value;
diff --git a/src/bun.js/node/node_os.zig b/src/bun.js/node/node_os.zig
index 0c4dd970e0..a7c4da6691 100644
--- a/src/bun.js/node/node_os.zig
+++ b/src/bun.js/node/node_os.zig
@@ -14,22 +14,22 @@ pub const OS = struct {
     pub fn create(globalObject: *JSC.JSGlobalObject) JSC.JSValue {
         const module = JSC.JSValue.createEmptyObject(globalObject, 16);
 
-        module.put(globalObject, JSC.ZigString.static("cpus"), JSC.NewFunction(globalObject, JSC.ZigString.static("cpus"), 0, cpus, true));
-        module.put(globalObject, JSC.ZigString.static("freemem"), JSC.NewFunction(globalObject, JSC.ZigString.static("freemem"), 0, freemem, true));
-        module.put(globalObject, JSC.ZigString.static("getPriority"), JSC.NewFunction(globalObject, JSC.ZigString.static("getPriority"), 1, getPriority, true));
-        module.put(globalObject, JSC.ZigString.static("homedir"), JSC.NewFunction(globalObject, JSC.ZigString.static("homedir"), 0, homedir, true));
-        module.put(globalObject, JSC.ZigString.static("hostname"), JSC.NewFunction(globalObject, JSC.ZigString.static("hostname"), 0, hostname, true));
-        module.put(globalObject, JSC.ZigString.static("loadavg"), JSC.NewFunction(globalObject, JSC.ZigString.static("loadavg"), 0, loadavg, true));
-        module.put(globalObject, JSC.ZigString.static("machine"), JSC.NewFunction(globalObject, JSC.ZigString.static("machine"), 0, machine, true));
-        module.put(globalObject, JSC.ZigString.static("networkInterfaces"), JSC.NewFunction(globalObject, JSC.ZigString.static("networkInterfaces"), 0, networkInterfaces, true));
-        module.put(globalObject, JSC.ZigString.static("release"), JSC.NewFunction(globalObject, JSC.ZigString.static("release"), 0, release, true));
-        module.put(globalObject, JSC.ZigString.static("setPriority"), JSC.NewFunction(globalObject, JSC.ZigString.static("setPriority"), 2, setPriority, true));
-        module.put(globalObject, JSC.ZigString.static("totalmem"), JSC.NewFunction(globalObject, JSC.ZigString.static("totalmem"), 0, totalmem, true));
-        module.put(globalObject, JSC.ZigString.static("type"), JSC.NewFunction(globalObject, JSC.ZigString.static("type"), 0, OS.type, true));
-        module.put(globalObject, JSC.ZigString.static("uptime"), JSC.NewFunction(globalObject, JSC.ZigString.static("uptime"), 0, uptime, true));
-        module.put(globalObject, JSC.ZigString.static("userInfo"), JSC.NewFunction(globalObject, JSC.ZigString.static("userInfo"), 0, userInfo, true));
-        module.put(globalObject, JSC.ZigString.static("version"), JSC.NewFunction(globalObject, JSC.ZigString.static("version"), 0, version, true));
-        module.put(globalObject, JSC.ZigString.static("machine"), JSC.NewFunction(globalObject, JSC.ZigString.static("machine"), 0, machine, true));
+        module.put(globalObject, JSC.ZigString.static("cpus"), JSC.NewFunction(globalObject, JSC.ZigString.static("cpus"), 0, cpus, false));
+        module.put(globalObject, JSC.ZigString.static("freemem"), JSC.NewFunction(globalObject, JSC.ZigString.static("freemem"), 0, freemem, false));
+        module.put(globalObject, JSC.ZigString.static("getPriority"), JSC.NewFunction(globalObject, JSC.ZigString.static("getPriority"), 1, getPriority, false));
+        module.put(globalObject, JSC.ZigString.static("homedir"), JSC.NewFunction(globalObject, JSC.ZigString.static("homedir"), 0, homedir, false));
+        module.put(globalObject, JSC.ZigString.static("hostname"), JSC.NewFunction(globalObject, JSC.ZigString.static("hostname"), 0, hostname, false));
+        module.put(globalObject, JSC.ZigString.static("loadavg"), JSC.NewFunction(globalObject, JSC.ZigString.static("loadavg"), 0, loadavg, false));
+        module.put(globalObject, JSC.ZigString.static("machine"), JSC.NewFunction(globalObject, JSC.ZigString.static("machine"), 0, machine, false));
+        module.put(globalObject, JSC.ZigString.static("networkInterfaces"), JSC.NewFunction(globalObject, JSC.ZigString.static("networkInterfaces"), 0, networkInterfaces, false));
+        module.put(globalObject, JSC.ZigString.static("release"), JSC.NewFunction(globalObject, JSC.ZigString.static("release"), 0, release, false));
+        module.put(globalObject, JSC.ZigString.static("setPriority"), JSC.NewFunction(globalObject, JSC.ZigString.static("setPriority"), 2, setPriority, false));
+        module.put(globalObject, JSC.ZigString.static("totalmem"), JSC.NewFunction(globalObject, JSC.ZigString.static("totalmem"), 0, totalmem, false));
+        module.put(globalObject, JSC.ZigString.static("type"), JSC.NewFunction(globalObject, JSC.ZigString.static("type"), 0, OS.type, false));
+        module.put(globalObject, JSC.ZigString.static("uptime"), JSC.NewFunction(globalObject, JSC.ZigString.static("uptime"), 0, uptime, false));
+        module.put(globalObject, JSC.ZigString.static("userInfo"), JSC.NewFunction(globalObject, JSC.ZigString.static("userInfo"), 0, userInfo, false));
+        module.put(globalObject, JSC.ZigString.static("version"), JSC.NewFunction(globalObject, JSC.ZigString.static("version"), 0, version, false));
+        module.put(globalObject, JSC.ZigString.static("machine"), JSC.NewFunction(globalObject, JSC.ZigString.static("machine"), 0, machine, false));
 
         return module;
     }
@@ -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) {
@@ -65,8 +65,7 @@ pub const OS = struct {
                 .code = bun.String.static(@tagName(JSC.Node.ErrorCode.ERR_SYSTEM_ERROR)),
             };
 
-            globalThis.vm().throwError(globalThis, err.toErrorInstance(globalThis));
-            return .undefined;
+            return globalThis.throwValue(err.toErrorInstance(globalThis));
         };
     }
 
@@ -294,30 +293,26 @@ 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);
+        var args_ = callframe.arguments_old(1);
         const arguments: []const JSC.JSValue = args_.ptr[0..args_.len];
 
         if (arguments.len > 0 and !arguments[0].isNumber()) {
-            globalThis.ERR_INVALID_ARG_TYPE(
-                "getPriority() expects a number",
-                .{},
-            ).throw();
-            return .undefined;
+            return globalThis.ERR_INVALID_ARG_TYPE("getPriority() expects a number", .{}).throw();
         }
 
         const pid = if (arguments.len > 0) arguments[0].asInt32() else 0;
@@ -338,14 +333,13 @@ pub const OS = struct {
                 .syscall = bun.String.static("uv_os_getpriority"),
             };
 
-            globalThis.vm().throwError(globalThis, err.toErrorInstance(globalThis));
-            return .undefined;
+            return globalThis.throwValue(err.toErrorInstance(globalThis));
         }
 
         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 +357,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 +385,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,14 +396,14 @@ 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),
         };
     }
 
-    fn networkInterfacesPosix(globalThis: *JSC.JSGlobalObject) JSC.JSValue {
+    fn networkInterfacesPosix(globalThis: *JSC.JSGlobalObject) bun.JSError!JSC.JSValue {
         // getifaddrs sets a pointer to a linked list
         var interface_start: ?*C.ifaddrs = null;
         const rc = C.getifaddrs(&interface_start);
@@ -421,8 +415,7 @@ pub const OS = struct {
                 .syscall = bun.String.static("getifaddrs"),
             };
 
-            globalThis.vm().throwError(globalThis, err.toErrorInstance(globalThis));
-            return .undefined;
+            return globalThis.throwValue(err.toErrorInstance(globalThis));
         }
         defer C.freeifaddrs(interface_start);
 
@@ -576,7 +569,7 @@ pub const OS = struct {
             }
 
             // Does this entry already exist?
-            if (ret.get(globalThis, interface_name)) |array| {
+            if (ret.get_unsafe(globalThis, interface_name)) |array| {
                 // Add this interface entry to the existing array
                 const next_index = @as(u32, @intCast(array.getLength(globalThis)));
                 array.putIndex(globalThis, next_index, interface);
@@ -592,7 +585,7 @@ pub const OS = struct {
         return ret;
     }
 
-    fn networkInterfacesWindows(globalThis: *JSC.JSGlobalObject) JSC.JSValue {
+    fn networkInterfacesWindows(globalThis: *JSC.JSGlobalObject) bun.JSError!JSC.JSValue {
         var ifaces: [*]libuv.uv_interface_address_t = undefined;
         var count: c_int = undefined;
         const err = libuv.uv_interface_addresses(&ifaces, &count);
@@ -604,8 +597,7 @@ pub const OS = struct {
                 .errno = err,
                 .syscall = bun.String.static("uv_interface_addresses"),
             };
-            globalThis.vm().throwError(globalThis, sys_err.toErrorInstance(globalThis));
-            return .zero;
+            return globalThis.throwValue(sys_err.toErrorInstance(globalThis));
         }
         defer libuv.uv_free_interface_addresses(ifaces, count);
 
@@ -691,7 +683,7 @@ pub const OS = struct {
 
             // Does this entry already exist?
             const interface_name = bun.span(iface.name);
-            if (ret.get(globalThis, interface_name)) |array| {
+            if (ret.get_unsafe(globalThis, interface_name)) |array| {
                 // Add this interface entry to the existing array
                 const next_index = @as(u32, @intCast(array.getLength(globalThis)));
                 array.putIndex(globalThis, next_index, interface);
@@ -707,22 +699,22 @@ 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);
+        var args_ = callframe.arguments_old(2);
         var arguments: []const JSC.JSValue = args_.ptr[0..args_.len];
 
         if (arguments.len == 0) {
@@ -732,8 +724,7 @@ pub const OS = struct {
                 .{},
                 globalThis,
             );
-            globalThis.vm().throwError(globalThis, err);
-            return .undefined;
+            return globalThis.throwValue(err);
         }
 
         const pid = if (arguments.len == 2) arguments[0].coerce(i32, globalThis) else 0;
@@ -746,8 +737,7 @@ pub const OS = struct {
                 .{},
                 globalThis,
             );
-            globalThis.vm().throwError(globalThis, err);
-            return .undefined;
+            return globalThis.throwValue(err);
         }
 
         const errcode = C.setProcessPriority(pid, priority);
@@ -761,8 +751,7 @@ pub const OS = struct {
                     .syscall = bun.String.static("uv_os_setpriority"),
                 };
 
-                globalThis.vm().throwError(globalThis, err.toErrorInstance(globalThis));
-                return .undefined;
+                return globalThis.throwValue(err.toErrorInstance(globalThis));
             },
             .ACCES => {
                 const err = JSC.SystemError{
@@ -773,8 +762,7 @@ pub const OS = struct {
                     .syscall = bun.String.static("uv_os_setpriority"),
                 };
 
-                globalThis.vm().throwError(globalThis, err.toErrorInstance(globalThis));
-                return .undefined;
+                return globalThis.throwValue(err.toErrorInstance(globalThis));
             },
             else => {},
         }
@@ -782,26 +770,26 @@ 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)
-            return JSC.ZigString.static("Windows_NT").toJS(globalThis)
+            return bun.String.static("Windows_NT").toJS(globalThis)
         else if (comptime Environment.isMac)
-            return JSC.ZigString.static("Darwin").toJS(globalThis)
+            return bun.String.static("Darwin").toJS(globalThis)
         else if (comptime Environment.isLinux)
-            return JSC.ZigString.static("Linux").toJS(globalThis);
+            return bun.String.static("Linux").toJS(globalThis);
 
         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);
@@ -812,8 +800,7 @@ pub const OS = struct {
                     .errno = err,
                     .syscall = bun.String.static("uv_uptime"),
                 };
-                globalThis.vm().throwError(globalThis, sys_err.toErrorInstance(globalThis));
-                return .zero;
+                return globalThis.throwValue(sys_err.toErrorInstance(globalThis));
             }
             return JSC.JSValue.jsNumber(uptime_value);
         }
@@ -821,10 +808,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 +831,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 +852,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 a181265bc4..2f886cb0fa 100644
--- a/src/bun.js/node/node_util_binding.zig
+++ b/src/bun.js/node/node_util_binding.zig
@@ -7,101 +7,100 @@ 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 {
-    const arguments = callframe.arguments(1).slice();
+pub fn internalErrorName(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+    const arguments = callframe.arguments_old(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];
     const err_int = err_value.toInt32();
 
-    if (err_int == -4095) return ZigString.static("EOF").toJS(globalThis);
-    if (err_int == -4094) return ZigString.static("UNKNOWN").toJS(globalThis);
-    if (err_int == -3000) return ZigString.static("EAI_ADDRFAMILY").toJS(globalThis);
-    if (err_int == -3001) return ZigString.static("EAI_AGAIN").toJS(globalThis);
-    if (err_int == -3002) return ZigString.static("EAI_BADFLAGS").toJS(globalThis);
-    if (err_int == -3003) return ZigString.static("EAI_CANCELED").toJS(globalThis);
-    if (err_int == -3004) return ZigString.static("EAI_FAIL").toJS(globalThis);
-    if (err_int == -3005) return ZigString.static("EAI_FAMILY").toJS(globalThis);
-    if (err_int == -3006) return ZigString.static("EAI_MEMORY").toJS(globalThis);
-    if (err_int == -3007) return ZigString.static("EAI_NODATA").toJS(globalThis);
-    if (err_int == -3008) return ZigString.static("EAI_NONAME").toJS(globalThis);
-    if (err_int == -3009) return ZigString.static("EAI_OVERFLOW").toJS(globalThis);
-    if (err_int == -3010) return ZigString.static("EAI_SERVICE").toJS(globalThis);
-    if (err_int == -3011) return ZigString.static("EAI_SOCKTYPE").toJS(globalThis);
-    if (err_int == -3013) return ZigString.static("EAI_BADHINTS").toJS(globalThis);
-    if (err_int == -3014) return ZigString.static("EAI_PROTOCOL").toJS(globalThis);
+    if (err_int == -4095) return bun.String.static("EOF").toJS(globalThis);
+    if (err_int == -4094) return bun.String.static("UNKNOWN").toJS(globalThis);
+    if (err_int == -3000) return bun.String.static("EAI_ADDRFAMILY").toJS(globalThis);
+    if (err_int == -3001) return bun.String.static("EAI_AGAIN").toJS(globalThis);
+    if (err_int == -3002) return bun.String.static("EAI_BADFLAGS").toJS(globalThis);
+    if (err_int == -3003) return bun.String.static("EAI_CANCELED").toJS(globalThis);
+    if (err_int == -3004) return bun.String.static("EAI_FAIL").toJS(globalThis);
+    if (err_int == -3005) return bun.String.static("EAI_FAMILY").toJS(globalThis);
+    if (err_int == -3006) return bun.String.static("EAI_MEMORY").toJS(globalThis);
+    if (err_int == -3007) return bun.String.static("EAI_NODATA").toJS(globalThis);
+    if (err_int == -3008) return bun.String.static("EAI_NONAME").toJS(globalThis);
+    if (err_int == -3009) return bun.String.static("EAI_OVERFLOW").toJS(globalThis);
+    if (err_int == -3010) return bun.String.static("EAI_SERVICE").toJS(globalThis);
+    if (err_int == -3011) return bun.String.static("EAI_SOCKTYPE").toJS(globalThis);
+    if (err_int == -3013) return bun.String.static("EAI_BADHINTS").toJS(globalThis);
+    if (err_int == -3014) return bun.String.static("EAI_PROTOCOL").toJS(globalThis);
 
-    if (err_int == -bun.C.UV_E2BIG) return ZigString.static("E2BIG").toJS(globalThis);
-    if (err_int == -bun.C.UV_EACCES) return ZigString.static("EACCES").toJS(globalThis);
-    if (err_int == -bun.C.UV_EADDRINUSE) return ZigString.static("EADDRINUSE").toJS(globalThis);
-    if (err_int == -bun.C.UV_EADDRNOTAVAIL) return ZigString.static("EADDRNOTAVAIL").toJS(globalThis);
-    if (err_int == -bun.C.UV_EAFNOSUPPORT) return ZigString.static("EAFNOSUPPORT").toJS(globalThis);
-    if (err_int == -bun.C.UV_EAGAIN) return ZigString.static("EAGAIN").toJS(globalThis);
-    if (err_int == -bun.C.UV_EALREADY) return ZigString.static("EALREADY").toJS(globalThis);
-    if (err_int == -bun.C.UV_EBADF) return ZigString.static("EBADF").toJS(globalThis);
-    if (err_int == -bun.C.UV_EBUSY) return ZigString.static("EBUSY").toJS(globalThis);
-    if (err_int == -bun.C.UV_ECANCELED) return ZigString.static("ECANCELED").toJS(globalThis);
-    if (err_int == -bun.C.UV_ECHARSET) return ZigString.static("ECHARSET").toJS(globalThis);
-    if (err_int == -bun.C.UV_ECONNABORTED) return ZigString.static("ECONNABORTED").toJS(globalThis);
-    if (err_int == -bun.C.UV_ECONNREFUSED) return ZigString.static("ECONNREFUSED").toJS(globalThis);
-    if (err_int == -bun.C.UV_ECONNRESET) return ZigString.static("ECONNRESET").toJS(globalThis);
-    if (err_int == -bun.C.UV_EDESTADDRREQ) return ZigString.static("EDESTADDRREQ").toJS(globalThis);
-    if (err_int == -bun.C.UV_EEXIST) return ZigString.static("EEXIST").toJS(globalThis);
-    if (err_int == -bun.C.UV_EFAULT) return ZigString.static("EFAULT").toJS(globalThis);
-    if (err_int == -bun.C.UV_EHOSTUNREACH) return ZigString.static("EHOSTUNREACH").toJS(globalThis);
-    if (err_int == -bun.C.UV_EINTR) return ZigString.static("EINTR").toJS(globalThis);
-    if (err_int == -bun.C.UV_EINVAL) return ZigString.static("EINVAL").toJS(globalThis);
-    if (err_int == -bun.C.UV_EIO) return ZigString.static("EIO").toJS(globalThis);
-    if (err_int == -bun.C.UV_EISCONN) return ZigString.static("EISCONN").toJS(globalThis);
-    if (err_int == -bun.C.UV_EISDIR) return ZigString.static("EISDIR").toJS(globalThis);
-    if (err_int == -bun.C.UV_ELOOP) return ZigString.static("ELOOP").toJS(globalThis);
-    if (err_int == -bun.C.UV_EMFILE) return ZigString.static("EMFILE").toJS(globalThis);
-    if (err_int == -bun.C.UV_EMSGSIZE) return ZigString.static("EMSGSIZE").toJS(globalThis);
-    if (err_int == -bun.C.UV_ENAMETOOLONG) return ZigString.static("ENAMETOOLONG").toJS(globalThis);
-    if (err_int == -bun.C.UV_ENETDOWN) return ZigString.static("ENETDOWN").toJS(globalThis);
-    if (err_int == -bun.C.UV_ENETUNREACH) return ZigString.static("ENETUNREACH").toJS(globalThis);
-    if (err_int == -bun.C.UV_ENFILE) return ZigString.static("ENFILE").toJS(globalThis);
-    if (err_int == -bun.C.UV_ENOBUFS) return ZigString.static("ENOBUFS").toJS(globalThis);
-    if (err_int == -bun.C.UV_ENODEV) return ZigString.static("ENODEV").toJS(globalThis);
-    if (err_int == -bun.C.UV_ENOENT) return ZigString.static("ENOENT").toJS(globalThis);
-    if (err_int == -bun.C.UV_ENOMEM) return ZigString.static("ENOMEM").toJS(globalThis);
-    if (err_int == -bun.C.UV_ENONET) return ZigString.static("ENONET").toJS(globalThis);
-    if (err_int == -bun.C.UV_ENOSPC) return ZigString.static("ENOSPC").toJS(globalThis);
-    if (err_int == -bun.C.UV_ENOSYS) return ZigString.static("ENOSYS").toJS(globalThis);
-    if (err_int == -bun.C.UV_ENOTCONN) return ZigString.static("ENOTCONN").toJS(globalThis);
-    if (err_int == -bun.C.UV_ENOTDIR) return ZigString.static("ENOTDIR").toJS(globalThis);
-    if (err_int == -bun.C.UV_ENOTEMPTY) return ZigString.static("ENOTEMPTY").toJS(globalThis);
-    if (err_int == -bun.C.UV_ENOTSOCK) return ZigString.static("ENOTSOCK").toJS(globalThis);
-    if (err_int == -bun.C.UV_ENOTSUP) return ZigString.static("ENOTSUP").toJS(globalThis);
-    if (err_int == -bun.C.UV_EPERM) return ZigString.static("EPERM").toJS(globalThis);
-    if (err_int == -bun.C.UV_EPIPE) return ZigString.static("EPIPE").toJS(globalThis);
-    if (err_int == -bun.C.UV_EPROTO) return ZigString.static("EPROTO").toJS(globalThis);
-    if (err_int == -bun.C.UV_EPROTONOSUPPORT) return ZigString.static("EPROTONOSUPPORT").toJS(globalThis);
-    if (err_int == -bun.C.UV_EPROTOTYPE) return ZigString.static("EPROTOTYPE").toJS(globalThis);
-    if (err_int == -bun.C.UV_EROFS) return ZigString.static("EROFS").toJS(globalThis);
-    if (err_int == -bun.C.UV_ESHUTDOWN) return ZigString.static("ESHUTDOWN").toJS(globalThis);
-    if (err_int == -bun.C.UV_ESPIPE) return ZigString.static("ESPIPE").toJS(globalThis);
-    if (err_int == -bun.C.UV_ESRCH) return ZigString.static("ESRCH").toJS(globalThis);
-    if (err_int == -bun.C.UV_ETIMEDOUT) return ZigString.static("ETIMEDOUT").toJS(globalThis);
-    if (err_int == -bun.C.UV_ETXTBSY) return ZigString.static("ETXTBSY").toJS(globalThis);
-    if (err_int == -bun.C.UV_EXDEV) return ZigString.static("EXDEV").toJS(globalThis);
-    if (err_int == -bun.C.UV_EFBIG) return ZigString.static("EFBIG").toJS(globalThis);
-    if (err_int == -bun.C.UV_ENOPROTOOPT) return ZigString.static("ENOPROTOOPT").toJS(globalThis);
-    if (err_int == -bun.C.UV_ERANGE) return ZigString.static("ERANGE").toJS(globalThis);
-    if (err_int == -bun.C.UV_ENXIO) return ZigString.static("ENXIO").toJS(globalThis);
-    if (err_int == -bun.C.UV_EMLINK) return ZigString.static("EMLINK").toJS(globalThis);
-    if (err_int == -bun.C.UV_EHOSTDOWN) return ZigString.static("EHOSTDOWN").toJS(globalThis);
-    if (err_int == -bun.C.UV_EREMOTEIO) return ZigString.static("EREMOTEIO").toJS(globalThis);
-    if (err_int == -bun.C.UV_ENOTTY) return ZigString.static("ENOTTY").toJS(globalThis);
-    if (err_int == -bun.C.UV_EFTYPE) return ZigString.static("EFTYPE").toJS(globalThis);
-    if (err_int == -bun.C.UV_EILSEQ) return ZigString.static("EILSEQ").toJS(globalThis);
-    if (err_int == -bun.C.UV_EOVERFLOW) return ZigString.static("EOVERFLOW").toJS(globalThis);
-    if (err_int == -bun.C.UV_ESOCKTNOSUPPORT) return ZigString.static("ESOCKTNOSUPPORT").toJS(globalThis);
-    if (err_int == -bun.C.UV_ENODATA) return ZigString.static("ENODATA").toJS(globalThis);
-    if (err_int == -bun.C.UV_EUNATCH) return ZigString.static("EUNATCH").toJS(globalThis);
+    if (err_int == -bun.C.UV_E2BIG) return bun.String.static("E2BIG").toJS(globalThis);
+    if (err_int == -bun.C.UV_EACCES) return bun.String.static("EACCES").toJS(globalThis);
+    if (err_int == -bun.C.UV_EADDRINUSE) return bun.String.static("EADDRINUSE").toJS(globalThis);
+    if (err_int == -bun.C.UV_EADDRNOTAVAIL) return bun.String.static("EADDRNOTAVAIL").toJS(globalThis);
+    if (err_int == -bun.C.UV_EAFNOSUPPORT) return bun.String.static("EAFNOSUPPORT").toJS(globalThis);
+    if (err_int == -bun.C.UV_EAGAIN) return bun.String.static("EAGAIN").toJS(globalThis);
+    if (err_int == -bun.C.UV_EALREADY) return bun.String.static("EALREADY").toJS(globalThis);
+    if (err_int == -bun.C.UV_EBADF) return bun.String.static("EBADF").toJS(globalThis);
+    if (err_int == -bun.C.UV_EBUSY) return bun.String.static("EBUSY").toJS(globalThis);
+    if (err_int == -bun.C.UV_ECANCELED) return bun.String.static("ECANCELED").toJS(globalThis);
+    if (err_int == -bun.C.UV_ECHARSET) return bun.String.static("ECHARSET").toJS(globalThis);
+    if (err_int == -bun.C.UV_ECONNABORTED) return bun.String.static("ECONNABORTED").toJS(globalThis);
+    if (err_int == -bun.C.UV_ECONNREFUSED) return bun.String.static("ECONNREFUSED").toJS(globalThis);
+    if (err_int == -bun.C.UV_ECONNRESET) return bun.String.static("ECONNRESET").toJS(globalThis);
+    if (err_int == -bun.C.UV_EDESTADDRREQ) return bun.String.static("EDESTADDRREQ").toJS(globalThis);
+    if (err_int == -bun.C.UV_EEXIST) return bun.String.static("EEXIST").toJS(globalThis);
+    if (err_int == -bun.C.UV_EFAULT) return bun.String.static("EFAULT").toJS(globalThis);
+    if (err_int == -bun.C.UV_EHOSTUNREACH) return bun.String.static("EHOSTUNREACH").toJS(globalThis);
+    if (err_int == -bun.C.UV_EINTR) return bun.String.static("EINTR").toJS(globalThis);
+    if (err_int == -bun.C.UV_EINVAL) return bun.String.static("EINVAL").toJS(globalThis);
+    if (err_int == -bun.C.UV_EIO) return bun.String.static("EIO").toJS(globalThis);
+    if (err_int == -bun.C.UV_EISCONN) return bun.String.static("EISCONN").toJS(globalThis);
+    if (err_int == -bun.C.UV_EISDIR) return bun.String.static("EISDIR").toJS(globalThis);
+    if (err_int == -bun.C.UV_ELOOP) return bun.String.static("ELOOP").toJS(globalThis);
+    if (err_int == -bun.C.UV_EMFILE) return bun.String.static("EMFILE").toJS(globalThis);
+    if (err_int == -bun.C.UV_EMSGSIZE) return bun.String.static("EMSGSIZE").toJS(globalThis);
+    if (err_int == -bun.C.UV_ENAMETOOLONG) return bun.String.static("ENAMETOOLONG").toJS(globalThis);
+    if (err_int == -bun.C.UV_ENETDOWN) return bun.String.static("ENETDOWN").toJS(globalThis);
+    if (err_int == -bun.C.UV_ENETUNREACH) return bun.String.static("ENETUNREACH").toJS(globalThis);
+    if (err_int == -bun.C.UV_ENFILE) return bun.String.static("ENFILE").toJS(globalThis);
+    if (err_int == -bun.C.UV_ENOBUFS) return bun.String.static("ENOBUFS").toJS(globalThis);
+    if (err_int == -bun.C.UV_ENODEV) return bun.String.static("ENODEV").toJS(globalThis);
+    if (err_int == -bun.C.UV_ENOENT) return bun.String.static("ENOENT").toJS(globalThis);
+    if (err_int == -bun.C.UV_ENOMEM) return bun.String.static("ENOMEM").toJS(globalThis);
+    if (err_int == -bun.C.UV_ENONET) return bun.String.static("ENONET").toJS(globalThis);
+    if (err_int == -bun.C.UV_ENOSPC) return bun.String.static("ENOSPC").toJS(globalThis);
+    if (err_int == -bun.C.UV_ENOSYS) return bun.String.static("ENOSYS").toJS(globalThis);
+    if (err_int == -bun.C.UV_ENOTCONN) return bun.String.static("ENOTCONN").toJS(globalThis);
+    if (err_int == -bun.C.UV_ENOTDIR) return bun.String.static("ENOTDIR").toJS(globalThis);
+    if (err_int == -bun.C.UV_ENOTEMPTY) return bun.String.static("ENOTEMPTY").toJS(globalThis);
+    if (err_int == -bun.C.UV_ENOTSOCK) return bun.String.static("ENOTSOCK").toJS(globalThis);
+    if (err_int == -bun.C.UV_ENOTSUP) return bun.String.static("ENOTSUP").toJS(globalThis);
+    if (err_int == -bun.C.UV_EPERM) return bun.String.static("EPERM").toJS(globalThis);
+    if (err_int == -bun.C.UV_EPIPE) return bun.String.static("EPIPE").toJS(globalThis);
+    if (err_int == -bun.C.UV_EPROTO) return bun.String.static("EPROTO").toJS(globalThis);
+    if (err_int == -bun.C.UV_EPROTONOSUPPORT) return bun.String.static("EPROTONOSUPPORT").toJS(globalThis);
+    if (err_int == -bun.C.UV_EPROTOTYPE) return bun.String.static("EPROTOTYPE").toJS(globalThis);
+    if (err_int == -bun.C.UV_EROFS) return bun.String.static("EROFS").toJS(globalThis);
+    if (err_int == -bun.C.UV_ESHUTDOWN) return bun.String.static("ESHUTDOWN").toJS(globalThis);
+    if (err_int == -bun.C.UV_ESPIPE) return bun.String.static("ESPIPE").toJS(globalThis);
+    if (err_int == -bun.C.UV_ESRCH) return bun.String.static("ESRCH").toJS(globalThis);
+    if (err_int == -bun.C.UV_ETIMEDOUT) return bun.String.static("ETIMEDOUT").toJS(globalThis);
+    if (err_int == -bun.C.UV_ETXTBSY) return bun.String.static("ETXTBSY").toJS(globalThis);
+    if (err_int == -bun.C.UV_EXDEV) return bun.String.static("EXDEV").toJS(globalThis);
+    if (err_int == -bun.C.UV_EFBIG) return bun.String.static("EFBIG").toJS(globalThis);
+    if (err_int == -bun.C.UV_ENOPROTOOPT) return bun.String.static("ENOPROTOOPT").toJS(globalThis);
+    if (err_int == -bun.C.UV_ERANGE) return bun.String.static("ERANGE").toJS(globalThis);
+    if (err_int == -bun.C.UV_ENXIO) return bun.String.static("ENXIO").toJS(globalThis);
+    if (err_int == -bun.C.UV_EMLINK) return bun.String.static("EMLINK").toJS(globalThis);
+    if (err_int == -bun.C.UV_EHOSTDOWN) return bun.String.static("EHOSTDOWN").toJS(globalThis);
+    if (err_int == -bun.C.UV_EREMOTEIO) return bun.String.static("EREMOTEIO").toJS(globalThis);
+    if (err_int == -bun.C.UV_ENOTTY) return bun.String.static("ENOTTY").toJS(globalThis);
+    if (err_int == -bun.C.UV_EFTYPE) return bun.String.static("EFTYPE").toJS(globalThis);
+    if (err_int == -bun.C.UV_EILSEQ) return bun.String.static("EILSEQ").toJS(globalThis);
+    if (err_int == -bun.C.UV_EOVERFLOW) return bun.String.static("EOVERFLOW").toJS(globalThis);
+    if (err_int == -bun.C.UV_ESOCKTNOSUPPORT) return bun.String.static("ESOCKTNOSUPPORT").toJS(globalThis);
+    if (err_int == -bun.C.UV_ENODATA) return bun.String.static("ENODATA").toJS(globalThis);
+    if (err_int == -bun.C.UV_EUNATCH) return bun.String.static("EUNATCH").toJS(globalThis);
 
     var fmtstring = bun.String.createFormat("Unknown system error {d}", .{err_int}) catch bun.outOfMemory();
     return fmtstring.transferToJS(globalThis);
diff --git a/src/bun.js/node/node_zlib_binding.zig b/src/bun.js/node/node_zlib_binding.zig
index 066174d695..8531c209d5 100644
--- a/src/bun.js/node/node_zlib_binding.zig
+++ b/src/bun.js/node/node_zlib_binding.zig
@@ -5,21 +5,13 @@ const JSC = bun.JSC;
 const string = bun.string;
 const Output = bun.Output;
 const ZigString = JSC.ZigString;
+const validators = @import("./util/validators.zig");
 
-pub const createBrotliEncoder = bun.JSC.API.BrotliEncoder.create;
-
-pub const createBrotliDecoder = bun.JSC.API.BrotliDecoder.create;
-
-pub const createZlibEncoder = bun.JSC.API.ZlibEncoder.create;
-
-pub const createZlibDecoder = bun.JSC.API.ZlibDecoder.create;
-
-pub fn crc32(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(.C) JSC.JSValue {
-    const arguments = callframe.arguments(2).ptr;
+pub fn crc32(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+    const arguments = callframe.arguments_old(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);
@@ -27,16 +19,11 @@ 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;
+            return globalThis.ERR_INVALID_ARG_TYPE("The \"data\" property must be an instance of Buffer, TypedArray, DataView, or ArrayBuffer. Received {s}", .{ty_str.slice()}).throw();
         };
-        if (exceptionref) |ptr| {
-            globalThis.throwValue(JSC.JSValue.c(ptr));
-            return .zero;
-        }
         break :blk ZigString.Slice.fromUTF8NeverFree(buffer.slice());
     };
     defer data.deinit();
@@ -54,12 +41,10 @@ pub fn crc32(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callcon
         const max = std.math.maxInt(u32);
 
         if (@floor(valuef) != valuef) {
-            globalThis.ERR_OUT_OF_RANGE("The value of \"{s}\" is out of range. It must be an integer. Received {}", .{ "value", valuef }).throw();
-            return .zero;
+            return globalThis.ERR_OUT_OF_RANGE("The value of \"{s}\" is out of range. It must be an integer. Received {}", .{ "value", valuef }).throw();
         }
         if (valuef < min or valuef > max) {
-            globalThis.ERR_OUT_OF_RANGE("The value of \"{s}\" is out of range. It must be >= {d} and <= {d}. Received {d}", .{ "value", min, max, valuef }).throw();
-            return .zero;
+            return globalThis.ERR_OUT_OF_RANGE("The value of \"{s}\" is out of range. It must be >= {d} and <= {d}. Received {d}", .{ "value", min, max, valuef }).throw();
         }
         break :blk @intFromFloat(valuef);
     };
@@ -68,3 +53,848 @@ pub fn crc32(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callcon
     const slice_u8 = data.slice();
     return JSC.JSValue.jsNumber(@as(u32, @intCast(bun.zlib.crc32(value, slice_u8.ptr, @intCast(slice_u8.len)))));
 }
+
+pub fn CompressionStream(comptime T: type) type {
+    return struct {
+        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) {
+                return globalThis.ERR_MISSING_ARGS("write(flush, in, in_off, in_len, out, out_off, out_len)", .{}).throw();
+            }
+
+            var in_off: u32 = 0;
+            var in_len: u32 = 0;
+            var out_off: u32 = 0;
+            var out_len: u32 = 0;
+            var flush: u32 = 0;
+            var in: ?[]const u8 = null;
+            var out: ?[]u8 = null;
+
+            bun.assert(!arguments[0].isUndefined()); // must provide flush value
+            flush = arguments[0].toU32();
+            _ = std.meta.intToEnum(bun.zlib.FlushValue, flush) catch bun.assert(false); // Invalid flush value
+
+            if (arguments[1].isNull()) {
+                // just a flush
+                in = null;
+                in_len = 0;
+                in_off = 0;
+            } else {
+                const in_buf = arguments[1].asArrayBuffer(globalThis).?;
+                in_off = arguments[2].toU32();
+                in_len = arguments[3].toU32();
+                bun.assert(in_buf.byte_len >= in_off + in_len);
+                in = in_buf.byteSlice()[in_off..][0..in_len];
+            }
+
+            const out_buf = arguments[4].asArrayBuffer(globalThis).?;
+            out_off = arguments[5].toU32();
+            out_len = arguments[6].toU32();
+            bun.assert(out_buf.byte_len >= out_off + out_len);
+            out = out_buf.byteSlice()[out_off..][0..out_len];
+
+            bun.assert(!this.write_in_progress);
+            bun.assert(!this.pending_close);
+            this.write_in_progress = true;
+            this.ref();
+
+            this.stream.setBuffers(in, out);
+            this.stream.setFlush(@intCast(flush));
+
+            //
+
+            const vm = globalThis.bunVM();
+            this.task = .{ .callback = &AsyncJob.runTask };
+            this.poll_ref.ref(vm);
+            JSC.WorkPool.schedule(&this.task);
+
+            return .undefined;
+        }
+
+        const AsyncJob = struct {
+            pub fn runTask(task: *JSC.WorkPoolTask) void {
+                const this: *T = @fieldParentPtr("task", task);
+                AsyncJob.run(this);
+            }
+
+            pub fn run(this: *T) void {
+                const globalThis: *JSC.JSGlobalObject = this.globalThis;
+                const vm = globalThis.bunVMConcurrently();
+
+                this.stream.doWork();
+
+                vm.enqueueTaskConcurrent(JSC.ConcurrentTask.create(JSC.Task.init(this)));
+            }
+        };
+
+        pub fn runFromJSThread(this: *T) void {
+            const globalThis: *JSC.JSGlobalObject = this.globalThis;
+            const vm = globalThis.bunVM();
+            this.poll_ref.unref(vm);
+            defer this.deref();
+
+            this.write_in_progress = false;
+
+            if (!(this.checkError(globalThis) catch return globalThis.reportActiveExceptionAsUnhandled(error.JSError))) {
+                return;
+            }
+
+            this.stream.updateWriteResult(&this.write_result.?[1], &this.write_result.?[0]);
+
+            _ = this.write_callback.get().?.call(globalThis, this.this_value.get().?, &.{}) catch |err| globalThis.reportActiveExceptionAsUnhandled(err);
+
+            if (this.pending_close) _ = this._close();
+        }
+
+        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) {
+                return globalThis.ERR_MISSING_ARGS("writeSync(flush, in, in_off, in_len, out, out_off, out_len)", .{}).throw();
+            }
+
+            var in_off: u32 = 0;
+            var in_len: u32 = 0;
+            var out_off: u32 = 0;
+            var out_len: u32 = 0;
+            var flush: u32 = 0;
+            var in: ?[]const u8 = null;
+            var out: ?[]u8 = null;
+
+            bun.assert(!arguments[0].isUndefined()); // must provide flush value
+            flush = arguments[0].toU32();
+            _ = std.meta.intToEnum(bun.zlib.FlushValue, flush) catch bun.assert(false); // Invalid flush value
+
+            if (arguments[1].isNull()) {
+                // just a flush
+                in = null;
+                in_len = 0;
+                in_off = 0;
+            } else {
+                const in_buf = arguments[1].asArrayBuffer(globalThis).?;
+                in_off = arguments[2].toU32();
+                in_len = arguments[3].toU32();
+                bun.assert(in_buf.byte_len >= in_off + in_len);
+                in = in_buf.byteSlice()[in_off..][0..in_len];
+            }
+
+            const out_buf = arguments[4].asArrayBuffer(globalThis).?;
+            out_off = arguments[5].toU32();
+            out_len = arguments[6].toU32();
+            bun.assert(out_buf.byte_len >= out_off + out_len);
+            out = out_buf.byteSlice()[out_off..][0..out_len];
+
+            bun.assert(!this.write_in_progress);
+            bun.assert(!this.pending_close);
+            this.write_in_progress = true;
+            this.ref();
+
+            this.stream.setBuffers(in, out);
+            this.stream.setFlush(@intCast(flush));
+
+            //
+
+            this.stream.doWork();
+            if (try this.checkError(globalThis)) {
+                this.stream.updateWriteResult(&this.write_result.?[1], &this.write_result.?[0]);
+                this.write_in_progress = false;
+            }
+            this.deref();
+
+            return .undefined;
+        }
+
+        pub fn reset(this: *T, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+            _ = callframe;
+
+            const err = this.stream.reset();
+            if (err.isError()) {
+                try this.emitError(globalThis, err);
+            }
+            return .undefined;
+        }
+
+        pub fn close(this: *T, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+            _ = globalThis;
+            _ = callframe;
+            this._close();
+            return .undefined;
+        }
+
+        fn _close(this: *T) void {
+            if (this.write_in_progress) {
+                this.pending_close = true;
+                return;
+            }
+            this.pending_close = false;
+            this.closed = true;
+            this.this_value.deinit();
+            this.stream.close();
+        }
+
+        pub fn setOnError(this: *T, globalThis: *JSC.JSGlobalObject, value: JSC.JSValue) bool {
+            if (value.isFunction()) {
+                this.onerror_value.set(globalThis, value);
+            }
+            return true;
+        }
+
+        pub fn getOnError(this: *T, globalThis: *JSC.JSGlobalObject) JSC.JSValue {
+            _ = globalThis;
+            return this.onerror_value.get() orelse .undefined;
+        }
+
+        /// returns true if no error was detected/emitted
+        fn checkError(this: *T, globalThis: *JSC.JSGlobalObject) !bool {
+            const err = this.stream.getErrorInfo();
+            if (!err.isError()) return true;
+            try this.emitError(globalThis, err);
+            return false;
+        }
+
+        fn emitError(this: *T, globalThis: *JSC.JSGlobalObject, err_: Error) !void {
+            var msg_str = bun.String.createFormat("{s}", .{std.mem.sliceTo(err_.msg, 0) orelse ""}) catch bun.outOfMemory();
+            const msg_value = msg_str.transferToJS(globalThis);
+            const err_value = JSC.jsNumber(err_.err);
+            var code_str = bun.String.createFormat("{s}", .{std.mem.sliceTo(err_.code, 0) orelse ""}) catch bun.outOfMemory();
+            const code_value = code_str.transferToJS(globalThis);
+
+            _ = try this.onerror_value.get().?.call(globalThis, this.this_value.get().?, &.{ msg_value, err_value, code_value });
+
+            this.write_in_progress = false;
+            if (this.pending_close) _ = this._close();
+        }
+
+        pub fn finalize(this: *T) void {
+            this.deref();
+        }
+    };
+}
+
+pub const NativeZlib = JSC.Codegen.JSNativeZlib.getConstructor;
+
+const CountedKeepAlive = struct {
+    keep_alive: bun.Async.KeepAlive = .{},
+    ref_count: u32 = 0,
+
+    pub fn ref(this: *@This(), vm: *JSC.VirtualMachine) void {
+        if (this.ref_count == 0) {
+            this.keep_alive.ref(vm);
+        }
+        this.ref_count += 1;
+    }
+
+    pub fn unref(this: *@This(), vm: *JSC.VirtualMachine) void {
+        this.ref_count -= 1;
+        if (this.ref_count == 0) {
+            this.keep_alive.unref(vm);
+        }
+    }
+
+    pub fn deinit(this: *@This()) void {
+        this.keep_alive.disable();
+    }
+};
+
+pub const SNativeZlib = struct {
+    pub usingnamespace bun.NewRefCounted(@This(), deinit);
+    pub usingnamespace JSC.Codegen.JSNativeZlib;
+    pub usingnamespace CompressionStream(@This());
+
+    ref_count: u32 = 1,
+    mode: bun.zlib.NodeMode,
+    globalThis: *JSC.JSGlobalObject,
+    stream: ZlibContext = .{},
+    write_result: ?[*]u32 = null,
+    write_callback: JSC.Strong = .{},
+    onerror_value: JSC.Strong = .{},
+    poll_ref: CountedKeepAlive = .{},
+    this_value: JSC.Strong = .{},
+    write_in_progress: bool = false,
+    pending_close: bool = false,
+    closed: bool = false,
+    task: JSC.WorkPoolTask = .{ .callback = undefined },
+
+    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()) {
+            return globalThis.throwInvalidArgumentTypeValue("mode", "number", mode);
+        }
+        const mode_double = mode.asNumber();
+        if (@mod(mode_double, 1.0) != 0.0) {
+            return globalThis.throwInvalidArgumentTypeValue("mode", "integer", mode);
+        }
+        const mode_int: i64 = @intFromFloat(mode_double);
+        if (mode_int < 1 or mode_int > 7) {
+            return globalThis.throwRangeError(mode_int, .{ .field_name = "mode", .min = 1, .max = 7 });
+        }
+
+        const ptr = SNativeZlib.new(.{
+            .mode = @enumFromInt(mode_int),
+            .globalThis = globalThis,
+        });
+        ptr.stream.mode = ptr.mode;
+        return ptr;
+    }
+
+    //// adding this didnt help much but leaving it here to compare the number with later
+    // pub fn estimatedSize(this: *const SNativeZlib) usize {
+    //     _ = this;
+    //     const internal_state_size = 3309; // @sizeOf(@cImport(@cInclude("deflate.h")).internal_state) @ cloudflare/zlib @ 92530568d2c128b4432467b76a3b54d93d6350bd
+    //     return @sizeOf(SNativeZlib) + internal_state_size;
+    // }
+
+    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) {
+            return globalThis.ERR_MISSING_ARGS("init(windowBits, level, memLevel, strategy, writeResult, writeCallback, dictionary)", .{}).throw();
+        }
+
+        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 = try validators.validateFunction(globalThis, arguments[5], "writeCallback", .{});
+        const dictionary = if (arguments[6].isUndefined()) null else arguments[6].asArrayBuffer(globalThis).?.byteSlice();
+
+        this.write_result = writeResult;
+        this.write_callback.set(globalThis, writeCallback);
+
+        this.stream.init(level, windowBits, memLevel, strategy, dictionary);
+
+        return .undefined;
+    }
+
+    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) {
+            return globalThis.ERR_MISSING_ARGS("params(level, strategy)", .{}).throw();
+        }
+
+        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()) {
+            try this.emitError(globalThis, err);
+        }
+        return .undefined;
+    }
+
+    pub fn deinit(this: *@This()) void {
+        this.write_callback.deinit();
+        this.onerror_value.deinit();
+        this.poll_ref.deinit();
+        this.destroy();
+    }
+};
+
+const Error = struct {
+    msg: ?[*:0]const u8,
+    err: c_int,
+    code: ?[*:0]const u8,
+
+    pub const ok: Error = init(null, 0, null);
+
+    pub fn init(msg: ?[*:0]const u8, err: c_int, code: ?[*:0]const u8) Error {
+        return .{
+            .msg = msg,
+            .err = err,
+            .code = code,
+        };
+    }
+
+    pub fn isError(this: Error) bool {
+        return this.msg != null;
+    }
+};
+
+const ZlibContext = struct {
+    const c = bun.zlib;
+    const GZIP_HEADER_ID1: u8 = 0x1f;
+    const GZIP_HEADER_ID2: u8 = 0x8b;
+
+    mode: c.NodeMode = .NONE,
+    state: c.z_stream = std.mem.zeroes(c.z_stream),
+    err: c.ReturnCode = .Ok,
+    flush: c.FlushValue = .NoFlush,
+    dictionary: []const u8 = "",
+    gzip_id_bytes_read: u8 = 0,
+
+    pub fn init(this: *ZlibContext, level: c_int, windowBits: c_int, memLevel: c_int, strategy: c_int, dictionary: ?[]const u8) void {
+        this.flush = .NoFlush;
+        this.err = .Ok;
+
+        const windowBitsActual = switch (this.mode) {
+            .NONE => unreachable,
+            .DEFLATE, .INFLATE => windowBits,
+            .GZIP, .GUNZIP => windowBits + 16,
+            .UNZIP => windowBits + 32,
+            .DEFLATERAW, .INFLATERAW => windowBits * -1,
+            .BROTLI_DECODE, .BROTLI_ENCODE => unreachable,
+        };
+
+        this.dictionary = dictionary orelse "";
+
+        switch (this.mode) {
+            .NONE => unreachable,
+            .DEFLATE, .GZIP, .DEFLATERAW => this.err = c.deflateInit2_(&this.state, level, 8, windowBitsActual, memLevel, strategy, c.zlibVersion(), @sizeOf(c.z_stream)),
+            .INFLATE, .GUNZIP, .UNZIP, .INFLATERAW => this.err = c.inflateInit2_(&this.state, windowBitsActual, c.zlibVersion(), @sizeOf(c.z_stream)),
+            .BROTLI_DECODE => @panic("TODO"),
+            .BROTLI_ENCODE => @panic("TODO"),
+        }
+        if (this.err != .Ok) {
+            this.mode = .NONE;
+            return;
+        }
+
+        _ = this.setDictionary();
+    }
+
+    pub fn setDictionary(this: *ZlibContext) Error {
+        const dict = this.dictionary;
+        if (dict.len == 0) return Error.ok;
+        this.err = .Ok;
+        switch (this.mode) {
+            .DEFLATE, .DEFLATERAW => {
+                this.err = c.deflateSetDictionary(&this.state, dict.ptr, @intCast(dict.len));
+            },
+            .INFLATERAW => {
+                this.err = c.inflateSetDictionary(&this.state, dict.ptr, @intCast(dict.len));
+            },
+            else => {},
+        }
+        if (this.err != .Ok) {
+            return this.error_for_message("Failed to set dictionary");
+        }
+        return Error.ok;
+    }
+
+    pub fn setParams(this: *ZlibContext, level: c_int, strategy: c_int) Error {
+        this.err = .Ok;
+        switch (this.mode) {
+            .DEFLATE, .DEFLATERAW => {
+                this.err = c.deflateParams(&this.state, level, strategy);
+            },
+            else => {},
+        }
+        if (this.err != .Ok and this.err != .BufError) {
+            return this.error_for_message("Failed to set parameters");
+        }
+        return Error.ok;
+    }
+
+    fn error_for_message(this: *ZlibContext, default: [*:0]const u8) Error {
+        var message = default;
+        if (this.state.err_msg) |msg| message = msg;
+        return .{
+            .msg = message,
+            .err = @intFromEnum(this.err),
+            .code = @tagName(this.err),
+        };
+    }
+
+    pub fn reset(this: *ZlibContext) Error {
+        this.err = .Ok;
+        switch (this.mode) {
+            .DEFLATE, .DEFLATERAW, .GZIP => {
+                this.err = c.deflateReset(&this.state);
+            },
+            .INFLATE, .INFLATERAW, .GUNZIP => {
+                this.err = c.inflateReset(&this.state);
+            },
+            else => {},
+        }
+        if (this.err != .Ok) {
+            return this.error_for_message("Failed to reset stream");
+        }
+        return this.setDictionary();
+    }
+
+    pub fn setBuffers(this: *ZlibContext, in: ?[]const u8, out: ?[]u8) void {
+        this.state.avail_in = if (in) |p| @intCast(p.len) else 0;
+        this.state.next_in = if (in) |p| p.ptr else null;
+        this.state.avail_out = if (out) |p| @intCast(p.len) else 0;
+        this.state.next_out = if (out) |p| p.ptr else null;
+    }
+
+    pub fn setFlush(this: *ZlibContext, flush: c_int) void {
+        this.flush = @enumFromInt(flush);
+    }
+
+    pub fn doWork(this: *ZlibContext) void {
+        var next_expected_header_byte: ?[*]const u8 = null;
+
+        // If the avail_out is left at 0, then it means that it ran out
+        // of room.  If there was avail_out left over, then it means
+        // that all of the input was consumed.
+        switch (this.mode) {
+            .DEFLATE, .GZIP, .DEFLATERAW => {
+                return this.doWorkDeflate();
+            },
+            .UNZIP => {
+                if (this.state.avail_in > 0) {
+                    next_expected_header_byte = this.state.next_in.?;
+                }
+                if (this.gzip_id_bytes_read == 0) {
+                    if (next_expected_header_byte == null) {
+                        return this.doWorkInflate();
+                    }
+                    if (next_expected_header_byte.?[0] == GZIP_HEADER_ID1) {
+                        this.gzip_id_bytes_read = 1;
+                        next_expected_header_byte.? += 1;
+                        if (this.state.avail_in == 1) { // The only available byte was already read.
+                            return this.doWorkInflate();
+                        }
+                    } else {
+                        this.mode = .INFLATE;
+                        return this.doWorkInflate();
+                    }
+                }
+                if (this.gzip_id_bytes_read == 1) {
+                    if (next_expected_header_byte == null) {
+                        return this.doWorkInflate();
+                    }
+                    if (next_expected_header_byte.?[0] == GZIP_HEADER_ID2) {
+                        this.gzip_id_bytes_read = 2;
+                        this.mode = .GUNZIP;
+                    } else {
+                        this.mode = .INFLATE;
+                    }
+                    return this.doWorkInflate();
+                }
+                bun.assert(false); // invalid number of gzip magic number bytes read
+            },
+            .INFLATE, .GUNZIP, .INFLATERAW => {
+                return this.doWorkInflate();
+            },
+            .NONE => {},
+            .BROTLI_ENCODE, .BROTLI_DECODE => {},
+        }
+    }
+
+    fn doWorkDeflate(this: *ZlibContext) void {
+        this.err = c.deflate(&this.state, this.flush);
+    }
+
+    fn doWorkInflate(this: *ZlibContext) void {
+        this.err = c.inflate(&this.state, this.flush);
+
+        if (this.mode != .INFLATERAW and this.err == .NeedDict and this.dictionary.len > 0) {
+            this.err = c.inflateSetDictionary(&this.state, this.dictionary.ptr, @intCast(this.dictionary.len));
+
+            if (this.err == .Ok) {
+                this.err = c.inflate(&this.state, this.flush);
+            } else if (this.err == .DataError) {
+                this.err = .NeedDict;
+            }
+        }
+        while (this.state.avail_in > 0 and this.mode == .GUNZIP and this.err == .StreamEnd and this.state.next_in.?[0] != 0) {
+            // Bytes remain in input buffer. Perhaps this is another compressed member in the same archive, or just trailing garbage.
+            // Trailing zero bytes are okay, though, since they are frequently used for padding.
+            _ = this.reset();
+            this.err = c.inflate(&this.state, this.flush);
+        }
+    }
+
+    pub fn updateWriteResult(this: *ZlibContext, avail_in: *u32, avail_out: *u32) void {
+        avail_in.* = this.state.avail_in;
+        avail_out.* = this.state.avail_out;
+    }
+
+    pub fn getErrorInfo(this: *ZlibContext) Error {
+        switch (this.err) {
+            .Ok, .BufError => {
+                if (this.state.avail_out != 0 and this.flush == .Finish) {
+                    return this.error_for_message("unexpected end of file");
+                }
+            },
+            .StreamEnd => {},
+            .NeedDict => {
+                if (this.dictionary.len == 0) {
+                    return this.error_for_message("Missing dictionary");
+                } else {
+                    return this.error_for_message("Bad dictionary");
+                }
+            },
+            else => {
+                return this.error_for_message("Zlib error");
+            },
+        }
+        return Error.ok;
+    }
+
+    pub fn close(this: *ZlibContext) void {
+        var status = c.ReturnCode.Ok;
+        switch (this.mode) {
+            .DEFLATE, .DEFLATERAW, .GZIP => {
+                status = c.deflateEnd(&this.state);
+            },
+            .INFLATE, .INFLATERAW, .GUNZIP, .UNZIP => {
+                status = c.inflateEnd(&this.state);
+            },
+            .NONE => {},
+            .BROTLI_ENCODE, .BROTLI_DECODE => {},
+        }
+        bun.assert(status == .Ok or status == .DataError);
+        this.mode = .NONE;
+    }
+};
+
+pub const NativeBrotli = JSC.Codegen.JSNativeBrotli.getConstructor;
+
+pub const SNativeBrotli = struct {
+    pub usingnamespace bun.NewRefCounted(@This(), deinit);
+    pub usingnamespace JSC.Codegen.JSNativeZlib;
+    pub usingnamespace CompressionStream(@This());
+
+    ref_count: u32 = 1,
+    mode: bun.zlib.NodeMode,
+    globalThis: *JSC.JSGlobalObject,
+    stream: BrotliContext = .{},
+    write_result: ?[*]u32 = null,
+    write_callback: JSC.Strong = .{},
+    onerror_value: JSC.Strong = .{},
+    poll_ref: CountedKeepAlive = .{},
+    this_value: JSC.Strong = .{},
+    write_in_progress: bool = false,
+    pending_close: bool = false,
+    closed: bool = false,
+    task: JSC.WorkPoolTask = .{
+        .callback = undefined,
+    },
+
+    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()) {
+            return globalThis.throwInvalidArgumentTypeValue("mode", "number", mode);
+        }
+        const mode_double = mode.asNumber();
+        if (@mod(mode_double, 1.0) != 0.0) {
+            return globalThis.throwInvalidArgumentTypeValue("mode", "integer", mode);
+        }
+        const mode_int: i64 = @intFromFloat(mode_double);
+        if (mode_int < 8 or mode_int > 9) {
+            return globalThis.throwRangeError(mode_int, .{ .field_name = "mode", .min = 8, .max = 9 });
+        }
+
+        const ptr = @This().new(.{
+            .mode = @enumFromInt(mode_int),
+            .globalThis = globalThis,
+        });
+        ptr.stream.mode = ptr.mode;
+        ptr.stream.mode_ = ptr.mode;
+        return ptr;
+    }
+
+    pub fn estimatedSize(this: *const SNativeBrotli) usize {
+        const encoder_state_size: usize = 5143; // @sizeOf(@cImport(@cInclude("brotli/encode.h")).BrotliEncoderStateStruct)
+        const decoder_state_size: usize = 855; // @sizeOf(@cImport(@cInclude("brotli/decode.h")).BrotliDecoderStateStruct)
+        return @sizeOf(SNativeBrotli) + switch (this.mode) {
+            .BROTLI_ENCODE => encoder_state_size,
+            .BROTLI_DECODE => decoder_state_size,
+            else => 0,
+        };
+    }
+
+    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) {
+            return globalThis.ERR_MISSING_ARGS("init(params, writeResult, writeCallback)", .{}).throw();
+        }
+
+        // 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 = 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()) {
+            try this.emitError(globalThis, err);
+            return JSC.jsBoolean(false);
+        }
+
+        const params_ = arguments[0].asArrayBuffer(globalThis).?.asU32();
+
+        for (params_, 0..) |d, i| {
+            // (d == -1) {
+            if (d == std.math.maxInt(u32)) {
+                continue;
+            }
+            err = this.stream.setParams(@intCast(i), d);
+            if (err.isError()) {
+                // 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) bun.JSError!JSC.JSValue {
+        _ = this;
+        _ = globalThis;
+        _ = callframe;
+        // intentionally left empty
+        return .undefined;
+    }
+
+    pub fn deinit(this: *@This()) void {
+        this.write_callback.deinit();
+        this.onerror_value.deinit();
+        this.poll_ref.deinit();
+        this.destroy();
+    }
+};
+
+const BrotliContext = struct {
+    const c = bun.brotli.c;
+    const Op = bun.brotli.c.BrotliEncoder.Operation;
+
+    mode: bun.zlib.NodeMode = .NONE,
+    mode_: bun.zlib.NodeMode = .NONE,
+    state: *anyopaque = undefined,
+
+    next_in: ?[*]const u8 = null,
+    next_out: ?[*]u8 = null,
+    avail_in: usize = 0,
+    avail_out: usize = 0,
+
+    flush: Op = .process,
+
+    last_result: extern union { e: c_int, d: c.BrotliDecoderResult } = @bitCast(@as(u32, 0)),
+    error_: c.BrotliDecoderErrorCode2 = .NO_ERROR,
+
+    pub fn init(this: *BrotliContext) Error {
+        switch (this.mode_) {
+            .BROTLI_ENCODE => {
+                const alloc = &bun.brotli.BrotliAllocator.alloc;
+                const free = &bun.brotli.BrotliAllocator.free;
+                const state = c.BrotliEncoderCreateInstance(alloc, free, null);
+                if (state == null) {
+                    return Error.init("Could not initialize Brotli instance", -1, "ERR_ZLIB_INITIALIZATION_FAILED");
+                }
+                this.state = @ptrCast(state.?);
+                return Error.ok;
+            },
+            .BROTLI_DECODE => {
+                const alloc = &bun.brotli.BrotliAllocator.alloc;
+                const free = &bun.brotli.BrotliAllocator.free;
+                const state = c.BrotliDecoderCreateInstance(alloc, free, null);
+                if (state == null) {
+                    return Error.init("Could not initialize Brotli instance", -1, "ERR_ZLIB_INITIALIZATION_FAILED");
+                }
+                this.state = @ptrCast(state.?);
+                return Error.ok;
+            },
+            else => unreachable,
+        }
+    }
+
+    pub fn setParams(this: *BrotliContext, key: c_uint, value: u32) Error {
+        switch (this.mode_) {
+            .BROTLI_ENCODE => {
+                if (c.BrotliEncoderSetParameter(@ptrCast(this.state), key, value) == 0) {
+                    return Error.init("Setting parameter failed", -1, "ERR_BROTLI_PARAM_SET_FAILED");
+                }
+                return Error.ok;
+            },
+            .BROTLI_DECODE => {
+                if (c.BrotliDecoderSetParameter(@ptrCast(this.state), key, value) == 0) {
+                    return Error.init("Setting parameter failed", -1, "ERR_BROTLI_PARAM_SET_FAILED");
+                }
+                return Error.ok;
+            },
+            else => unreachable,
+        }
+    }
+
+    pub fn reset(this: *BrotliContext) Error {
+        return this.init();
+    }
+
+    pub fn setBuffers(this: *BrotliContext, in: ?[]const u8, out: ?[]u8) void {
+        this.next_in = if (in) |p| p.ptr else null;
+        this.next_out = if (out) |p| p.ptr else null;
+        this.avail_in = if (in) |p| p.len else 0;
+        this.avail_out = if (out) |p| p.len else 0;
+    }
+
+    pub fn setFlush(this: *BrotliContext, flush: c_int) void {
+        this.flush = @enumFromInt(flush);
+    }
+
+    pub fn doWork(this: *BrotliContext) void {
+        switch (this.mode_) {
+            .BROTLI_ENCODE => {
+                var next_in = this.next_in;
+                this.last_result.e = c.BrotliEncoderCompressStream(@ptrCast(this.state), this.flush, &this.avail_in, &next_in, &this.avail_out, &this.next_out, null);
+                this.next_in.? += @intFromPtr(next_in.?) - @intFromPtr(this.next_in.?);
+            },
+            .BROTLI_DECODE => {
+                var next_in = this.next_in;
+                this.last_result.d = c.BrotliDecoderDecompressStream(@ptrCast(this.state), &this.avail_in, &next_in, &this.avail_out, &this.next_out, null);
+                this.next_in.? += @intFromPtr(next_in.?) - @intFromPtr(this.next_in.?);
+                if (this.last_result.d == .err) {
+                    this.error_ = c.BrotliDecoderGetErrorCode(@ptrCast(this.state));
+                }
+            },
+            else => unreachable,
+        }
+    }
+
+    pub fn updateWriteResult(this: *BrotliContext, avail_in: *u32, avail_out: *u32) void {
+        avail_in.* = @intCast(this.avail_in);
+        avail_out.* = @intCast(this.avail_out);
+    }
+
+    pub fn getErrorInfo(this: *BrotliContext) Error {
+        switch (this.mode_) {
+            .BROTLI_ENCODE => {
+                if (this.last_result.e == 0) {
+                    return Error.init("Compression failed", -1, "ERR_BROTLI_COMPRESSION_FAILED");
+                }
+                return Error.ok;
+            },
+            .BROTLI_DECODE => {
+                if (this.error_ != .NO_ERROR) {
+                    return Error.init("Decompression failed", @intFromEnum(this.error_), code_for_error(this.error_));
+                } else if (this.flush == .finish and this.last_result.d == .needs_more_input) {
+                    return Error.init("unexpected end of file", @intFromEnum(bun.zlib.ReturnCode.BufError), "Z_BUF_ERROR");
+                }
+                return Error.ok;
+            },
+            else => unreachable,
+        }
+    }
+
+    pub fn close(this: *BrotliContext) void {
+        switch (this.mode_) {
+            .BROTLI_ENCODE => c.BrotliEncoderDestroyInstance(@ptrCast(@alignCast(this.state))),
+            .BROTLI_DECODE => c.BrotliDecoderDestroyInstance(@ptrCast(@alignCast(this.state))),
+            else => unreachable,
+        }
+        this.mode = .NONE;
+    }
+
+    fn code_for_error(err: c.BrotliDecoderErrorCode2) [:0]const u8 {
+        const E = c.BrotliDecoderErrorCode2;
+        const names = comptime std.meta.fieldNames(E);
+        const values = comptime std.enums.values(E);
+        inline for (names, values) |n, v| {
+            if (err == v) {
+                return "ERR_BROTLI_DECODER_" ++ n;
+            }
+        }
+        unreachable;
+    }
+};
diff --git a/src/bun.js/node/path.zig b/src/bun.js/node/path.zig
index dcabe3aae5..6e73e687ca 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 });
@@ -1104,6 +1104,21 @@ pub inline fn joinPosixT(comptime T: type, paths: []const []const T, buf: []T, b
     return normalizePosixT(T, joined, buf);
 }
 
+export fn Bun__Node__Path_joinWTF(lhs: *bun.String, rhs_ptr: [*]const u8, rhs_len: usize, result: *bun.String) void {
+    const rhs = rhs_ptr[0..rhs_len];
+    var buf: [PATH_SIZE(u8)]u8 = undefined;
+    var buf2: [PATH_SIZE(u8)]u8 = undefined;
+    var slice = lhs.toUTF8(bun.default_allocator);
+    defer slice.deinit();
+    if (Environment.isWindows) {
+        const win = joinWindowsT(u8, &.{ slice.slice(), rhs }, &buf, &buf2);
+        result.* = bun.String.createUTF8(win);
+    } else {
+        const posix = joinPosixT(u8, &.{ slice.slice(), rhs }, &buf, &buf2);
+        result.* = bun.String.createUTF8(posix);
+    }
+}
+
 /// Based on Node v21.6.1 path.win32.join:
 /// https://github.com/nodejs/node/blob/6ae20aa63de78294b18d5015481485b7cd8fbb60/lib/path.js#L425
 pub fn joinWindowsT(comptime T: type, paths: []const []const T, buf: []T, buf2: []T) []const T {
@@ -2938,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") });
@@ -2947,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/path_watcher.zig b/src/bun.js/node/path_watcher.zig
index 3203d7365d..4d1455fdc7 100644
--- a/src/bun.js/node/path_watcher.zig
+++ b/src/bun.js/node/path_watcher.zig
@@ -25,9 +25,10 @@ const FSWatcher = bun.JSC.Node.FSWatcher;
 const Event = FSWatcher.Event;
 const StringOrBytesToDecode = FSWatcher.FSWatchTaskWindows.StringOrBytesToDecode;
 
+const Watcher = GenericWatcher.NewWatcher;
+
 pub const PathWatcherManager = struct {
     const options = @import("../../options.zig");
-    pub const Watcher = GenericWatcher.NewWatcher(*PathWatcherManager);
     const log = Output.scoped(.PathWatcherManager, false);
     main_watcher: *Watcher,
 
@@ -148,6 +149,7 @@ pub const PathWatcherManager = struct {
             .current_fd_task = bun.FDHashMap(*DirectoryRegisterTask).init(bun.default_allocator),
             .watchers = watchers,
             .main_watcher = try Watcher.init(
+                PathWatcherManager,
                 this,
                 vm.bundler.fs,
                 bun.default_allocator,
@@ -586,7 +588,7 @@ pub const PathWatcherManager = struct {
 
         const path = watcher.path;
         if (path.is_file) {
-            try this.main_watcher.addFile(path.fd, path.path, path.hash, options.Loader.file, .zero, null, false).unwrap();
+            try this.main_watcher.addFile(path.fd, path.path, path.hash, .file, .zero, null, false).unwrap();
         } else {
             if (comptime Environment.isMac) {
                 if (watcher.fsevents_watcher != null) {
diff --git a/src/bun.js/node/types.zig b/src/bun.js/node/types.zig
index 3b4daaa54f..c664c48954 100644
--- a/src/bun.js/node/types.zig
+++ b/src/bun.js/node/types.zig
@@ -23,6 +23,7 @@ const Shimmer = @import("../bindings/shimmer.zig").Shimmer;
 const Syscall = bun.sys;
 const URL = @import("../../url.zig").URL;
 const Value = std.json.Value;
+pub const validators = @import("./util/validators.zig");
 
 pub const Path = @import("./path.zig");
 
@@ -59,8 +60,8 @@ pub const Flavor = enum {
 /// - "path"
 /// - "errno"
 pub fn Maybe(comptime ReturnTypeT: type, comptime ErrorTypeT: type) type {
-    const hasRetry = @hasDecl(ErrorTypeT, "retry");
-    const hasTodo = @hasDecl(ErrorTypeT, "todo");
+    const hasRetry = ErrorTypeT != void and @hasDecl(ErrorTypeT, "retry");
+    const hasTodo = ErrorTypeT != void and @hasDecl(ErrorTypeT, "todo");
 
     return union(Tag) {
         pub const ErrorType = ErrorTypeT;
@@ -69,7 +70,13 @@ pub fn Maybe(comptime ReturnTypeT: type, comptime ErrorTypeT: type) type {
         err: ErrorType,
         result: ReturnType,
 
-        pub const Tag = enum { err, result };
+        /// NOTE: this has to have a well defined layout (e.g. setting to `u8`)
+        /// experienced a bug with a Maybe(void, void)
+        /// creating the `err` variant of this type
+        /// resulted in Zig incorrectly setting the tag, leading to a switch
+        /// statement to just not work.
+        /// we (Zack, Dylan, Dave, Mason) observed that it was set to 0xFF in ReleaseFast in the debugger
+        pub const Tag = enum(u8) { err, result };
 
         pub const retry: @This() = if (hasRetry) .{ .err = ErrorType.retry } else .{ .err = ErrorType{} };
 
@@ -114,6 +121,23 @@ pub fn Maybe(comptime ReturnTypeT: type, comptime ErrorTypeT: type) type {
             };
         }
 
+        /// Unwrap the value if it is `result` or use the provided `default_value`
+        ///
+        /// `default_value` must be comptime known so the optimizer can optimize this branch out
+        pub inline fn unwrapOr(this: @This(), comptime default_value: ReturnType) ReturnType {
+            return switch (this) {
+                .result => |v| v,
+                .err => default_value,
+            };
+        }
+
+        pub inline fn unwrapOrNoOptmizations(this: @This(), default_value: ReturnType) ReturnType {
+            return switch (this) {
+                .result => |v| v,
+                .err => default_value,
+            };
+        }
+
         pub inline fn initErr(e: ErrorType) Maybe(ReturnType, ErrorType) {
             return .{ .err = e };
         }
@@ -131,10 +155,49 @@ pub fn Maybe(comptime ReturnTypeT: type, comptime ErrorTypeT: type) type {
             return null;
         }
 
+        pub inline fn asValue(this: *const @This()) ?ReturnType {
+            if (this.* == .result) return this.result;
+            return null;
+        }
+
+        pub inline fn isOk(this: *const @This()) bool {
+            return switch (this.*) {
+                .result => true,
+                .err => false,
+            };
+        }
+
+        pub inline fn isErr(this: *const @This()) bool {
+            return switch (this.*) {
+                .result => false,
+                .err => true,
+            };
+        }
+
         pub inline fn initResult(result: ReturnType) Maybe(ReturnType, ErrorType) {
             return .{ .result = result };
         }
 
+        pub inline fn mapErr(this: @This(), comptime E: type, err_fn: *const fn (ErrorTypeT) E) Maybe(ReturnType, E) {
+            return switch (this) {
+                .result => |v| .{ .result = v },
+                .err => |e| .{ .err = err_fn(e) },
+            };
+        }
+
+        pub inline fn toCssResult(this: @This()) Maybe(ReturnType, bun.css.ParseError(bun.css.ParserError)) {
+            return switch (ErrorTypeT) {
+                bun.css.BasicParseError => {
+                    return switch (this) {
+                        .result => |v| return .{ .result = v },
+                        .err => |e| return .{ .err = e.intoDefaultParseError() },
+                    };
+                },
+                bun.css.ParseError(bun.css.ParserError) => @compileError("Already a ParseError(ParserError)"),
+                else => @compileError("Bad!"),
+            };
+        }
+
         pub fn toJS(this: @This(), globalObject: *JSC.JSGlobalObject) JSC.JSValue {
             return switch (this) {
                 .result => |r| switch (ReturnType) {
@@ -307,18 +370,53 @@ 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 {
-        if (value.as(JSC.WebCore.Blob)) |blob| {
-            if (blob.store) |store| {
-                store.ref();
-            }
-            return .{ .blob = blob.* };
+    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) bun.JSError!?BlobOrStringOrBuffer {
+        switch (value.jsType()) {
+            .DOMWrapper => {
+                if (value.as(JSC.WebCore.Blob)) |blob| {
+                    if (blob.store) |store| {
+                        store.ref();
+                    }
+                    return .{ .blob = blob.* };
+                }
+                if (allow_request_response) {
+                    if (value.as(JSC.WebCore.Request)) |request| {
+                        request.body.value.toBlobIfPossible();
+
+                        if (request.body.value.tryUseAsAnyBlob()) |any_blob_| {
+                            var any_blob = any_blob_;
+                            defer any_blob.detach();
+                            return .{ .blob = any_blob.toBlob(global) };
+                        }
+
+                        return global.throwInvalidArguments("Only buffered Request/Response bodies are supported for now.", .{});
+                    }
+
+                    if (value.as(JSC.WebCore.Response)) |response| {
+                        response.body.value.toBlobIfPossible();
+
+                        if (response.body.value.tryUseAsAnyBlob()) |any_blob_| {
+                            var any_blob = any_blob_;
+                            defer any_blob.detach();
+                            return .{ .blob = any_blob.toBlob(global) };
+                        }
+
+                        return global.throwInvalidArguments("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 };
     }
 };
 
@@ -353,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);
@@ -432,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();
@@ -476,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),
@@ -491,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);
@@ -505,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;
@@ -515,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;
@@ -567,7 +668,6 @@ pub const Encoding = enum(u8) {
         };
     }
 
-    /// Caller must verify the value is a string
     pub fn fromJS(value: JSC.JSValue, global: *JSC.JSGlobalObject) ?Encoding {
         return map.fromJSCaseInsensitive(global, value);
     }
@@ -577,6 +677,31 @@ pub const Encoding = enum(u8) {
         return strings.inMapCaseInsensitive(slice, map);
     }
 
+    pub fn assert(value: JSC.JSValue, globalObject: *JSC.JSGlobalObject, default: Encoding) bun.JSError!Encoding {
+        if (value.isFalsey()) {
+            return default;
+        }
+
+        if (!value.isString()) {
+            return throwEncodingError(globalObject, value);
+        }
+
+        return try fromJSWithDefaultOnEmpty(value, globalObject, default) orelse throwEncodingError(globalObject, value);
+    }
+
+    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;
+        }
+        return str.inMapCaseInsensitive(Encoding.map);
+    }
+
+    pub fn throwEncodingError(globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) bun.JSError {
+        return globalObject.ERR_INVALID_ARG_VALUE("encoding '{}' is an invalid encoding", .{value.fmtString(globalObject)}).throw();
+    }
+
     pub fn encodeWithSize(encoding: Encoding, globalObject: *JSC.JSGlobalObject, comptime size: usize, input: *const [size]u8) JSC.JSValue {
         switch (encoding) {
             .base64 => {
@@ -602,8 +727,7 @@ pub const Encoding = enum(u8) {
             inline else => |enc| {
                 const res = JSC.WebCore.Encoder.toString(input.ptr, size, globalObject, enc);
                 if (res.isError()) {
-                    globalObject.throwValue(res);
-                    return .zero;
+                    return globalObject.throwValue(res) catch .zero;
                 }
 
                 return res;
@@ -639,8 +763,7 @@ pub const Encoding = enum(u8) {
             inline else => |enc| {
                 const res = JSC.WebCore.Encoder.toString(input.ptr, input.len, globalObject, enc);
                 if (res.isError()) {
-                    globalObject.throwValue(res);
-                    return .zero;
+                    return globalObject.throwValue(res) catch .zero;
                 }
 
                 return res;
@@ -793,18 +916,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 };
@@ -812,8 +935,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();
 
@@ -829,9 +951,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);
@@ -862,14 +982,11 @@ 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;
+                        return ctx.throwInvalidArguments("URL must be a non-empty \"file:\" path", .{});
                     }
                     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);
@@ -903,73 +1020,61 @@ 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;
+            return ctx.throwInvalidArguments("Invalid file descriptor, must not be negative number", .{});
         }
 
         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;
+            return ctx.throwInvalidArguments("Invalid file descriptor, must not be greater than {d}", .{std.math.maxInt(fd_t)});
         }
-
-        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;
+                return ctx.throwValue(system_error.toErrorInstance(ctx));
             },
         }
-
         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;
+                return ctx.throwValue(system_error.toErrorInstance(ctx));
             },
         }
-
         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;
+                return ctx.throwInvalidArguments("Invalid path buffer: can't be empty", .{});
             },
-
             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;
+                return ctx.throwValue(system_error.toErrorInstance(ctx));
             },
-            1...bun.MAX_PATH_BYTES => return true,
+            1...bun.MAX_PATH_BYTES => return,
         }
-
         unreachable;
     }
 };
@@ -982,10 +1087,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.throwInvalidArguments("Expected ArrayBufferView[]", .{});
         }
 
         var bufferlist = std.ArrayList(bun.PlatformIOVec).init(allocator);
@@ -997,13 +1101,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.throwInvalidArguments("Expected ArrayBufferView[]", .{});
             }
 
             const array_buffer = element.asArrayBuffer(globalObject) orelse {
-                JSC.throwInvalidArguments("Expected ArrayBufferView[]", .{}, globalObject, exception);
-                return null;
+                return globalObject.throwInvalidArguments("Expected ArrayBufferView[]", .{});
             };
 
             const buf = array_buffer.byteSlice();
@@ -1100,8 +1202,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;
@@ -1110,7 +1212,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)) {
@@ -1146,16 +1248,17 @@ 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: {
-        if (!value.isUInt32AsAnyInt()) {
-            exception.* = ctx.ERR_OUT_OF_RANGE("The value of \"mode\" is out of range. It must be an integer. Received {d}", .{value.asNumber()}).toJS().asObjectRef();
-            return null;
-        }
-        break :brk @as(Mode, @truncate(value.to(Mode)));
+        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()) {
+            return ctx.throwInvalidArgumentTypeValue("mode", "number", value);
+        }
+
         //        An easier method of constructing the mode is to use a sequence of
         //        three octal digits (e.g. 765). The left-most digit (7 in the example),
         //        specifies the permissions for the file owner. The middle digit (6 in
@@ -1163,23 +1266,18 @@ 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..];
         }
 
         break :brk std.fmt.parseInt(Mode, slice, 8) catch {
-            JSC.throwInvalidArguments("Invalid mode string: must be an octal number", .{}, ctx, exception);
-            return null;
+            var formatter = bun.JSC.ConsoleObject.Formatter{ .globalThis = ctx };
+            return 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());
         };
     };
 
-    if (mode_int < 0) {
-        JSC.throwInvalidArguments("Invalid mode: must be greater than or equal to 0.", .{}, ctx, exception);
-        return null;
-    }
-
     return mode_int & 0o777;
 }
 
@@ -1234,23 +1332,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,
         };
     }
 };
@@ -1352,11 +1443,10 @@ 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;
+                return 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());
             }
             const number = val.coerce(i32, ctx);
             return @as(FileSystemFlags, @enumFromInt(@as(Mode, @intCast(@max(number, 0)))));
@@ -1366,23 +1456,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.throwInvalidArguments("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.throwInvalidArguments("Invalid flag '{any}'. Learn more at https://nodejs.org/api/fs.html#fs_file_system_flags", .{str});
             }
 
             const flags = brk: {
@@ -1406,13 +1484,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.throwInvalidArguments("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))));
@@ -1538,13 +1610,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;
@@ -1648,10 +1720,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.throwInvalidArguments("BigIntStats is not a constructor", .{});
             }
 
             // dev, mode, nlink, uid, gid, rdev, blksize, ino, size, blocks, atimeMs, mtimeMs, ctimeMs, birthtimeMs
@@ -1754,9 +1825,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.throw("Dirent is not a constructor", .{});
     }
 
     pub fn toJS(this: *Dirent, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
@@ -1786,49 +1856,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);
     }
 
@@ -1875,6 +1945,7 @@ pub const Process = struct {
 
         var args = std.ArrayList(bun.String).initCapacity(temp_alloc, bun.argv.len - 1) catch bun.outOfMemory();
         defer args.deinit();
+        defer for (args.items) |*arg| arg.deref();
 
         var seen_run = false;
         var prev: ?[]const u8 = null;
@@ -1991,26 +2062,29 @@ pub const Process = struct {
     }
 
     pub fn getCwd(globalObject: *JSC.JSGlobalObject) callconv(.C) JSC.JSValue {
+        return JSC.toJSHostValue(globalObject, getCwd_(globalObject));
+    }
+    fn getCwd_(globalObject: *JSC.JSGlobalObject) bun.JSError!JSC.JSValue {
         var buf: bun.PathBuffer = undefined;
         switch (Path.getCwd(&buf)) {
             .result => |r| return JSC.ZigString.init(r).withEncoding().toJS(globalObject),
             .err => |e| {
-                globalObject.throwValue(e.toJSC(globalObject));
-                return .zero;
+                return globalObject.throwValue(e.toJSC(globalObject));
             },
         }
     }
 
     pub fn setCwd(globalObject: *JSC.JSGlobalObject, to: *JSC.ZigString) callconv(.C) JSC.JSValue {
+        return JSC.toJSHostValue(globalObject, setCwd_(globalObject, to));
+    }
+    fn setCwd_(globalObject: *JSC.JSGlobalObject, to: *JSC.ZigString) bun.JSError!JSC.JSValue {
         if (to.len == 0) {
-            globalObject.throwInvalidArguments("Expected path to be a non-empty string", .{});
-            return .zero;
+            return globalObject.throwInvalidArguments("Expected path to be a non-empty string", .{});
         }
 
         var buf: bun.PathBuffer = undefined;
         const slice = to.sliceZBuf(&buf) catch {
-            globalObject.throw("Invalid path", .{});
-            return .zero;
+            return globalObject.throw("Invalid path", .{});
         };
 
         switch (Syscall.chdir(slice)) {
@@ -2023,24 +2097,25 @@ pub const Process = struct {
                     .result => |r| r,
                     .err => |err| {
                         _ = Syscall.chdir(@as([:0]const u8, @ptrCast(fs.top_level_dir)));
-                        globalObject.throwValue(err.toJSC(globalObject));
-                        return .zero;
+                        return globalObject.throwValue(err.toJSC(globalObject));
                     },
                 };
                 @memcpy(fs.top_level_dir_buf[0..into_cwd_buf.len], into_cwd_buf);
                 fs.top_level_dir = fs.top_level_dir_buf[0..into_cwd_buf.len];
 
                 const len = fs.top_level_dir.len;
-                fs.top_level_dir_buf[len] = std.fs.path.sep;
-                fs.top_level_dir_buf[len + 1] = 0;
-                fs.top_level_dir = fs.top_level_dir_buf[0 .. len + 1];
+                // Ensure the path ends with a slash
+                if (fs.top_level_dir_buf[len - 1] != std.fs.path.sep) {
+                    fs.top_level_dir_buf[len] = std.fs.path.sep;
+                    fs.top_level_dir_buf[len + 1] = 0;
+                    fs.top_level_dir = fs.top_level_dir_buf[0 .. len + 1];
+                }
                 const withoutTrailingSlash = if (Environment.isWindows) strings.withoutTrailingSlashWindowsPath else strings.withoutTrailingSlash;
                 var str = bun.String.createUTF8(withoutTrailingSlash(fs.top_level_dir));
                 return str.transferToJS(globalObject);
             },
             .err => |e| {
-                globalObject.throwValue(e.toJSC(globalObject));
-                return .zero;
+                return globalObject.throwValue(e.toJSC(globalObject));
             },
         }
     }
@@ -2059,6 +2134,7 @@ pub const Process = struct {
     }
 
     pub export const Bun__version: [*:0]const u8 = "v" ++ bun.Global.package_json_version;
+    pub export const Bun__version_with_sha: [*:0]const u8 = "v" ++ bun.Global.package_json_version_with_sha;
     pub export const Bun__versions_boringssl: [*:0]const u8 = bun.Global.versions.boringssl;
     pub export const Bun__versions_libarchive: [*:0]const u8 = bun.Global.versions.libarchive;
     pub export const Bun__versions_mimalloc: [*:0]const u8 = bun.Global.versions.mimalloc;
diff --git a/src/bun.js/node/util/parse_args.zig b/src/bun.js/node/util/parse_args.zig
index c047fddd25..221823fcb1 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 };
 
@@ -207,13 +205,12 @@ fn checkOptionLikeValue(globalThis: *JSGlobalObject, token: OptionToken) ParseAr
                 globalThis,
             );
         }
-        globalThis.vm().throwError(globalThis, err);
-        return error.ParseError;
+        return globalThis.throwValue(err);
     }
 }
 
 /// 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) {
@@ -229,8 +226,7 @@ fn checkOptionUsage(globalThis: *JSGlobalObject, options: []const OptionDefiniti
                     },
                     globalThis,
                 );
-                globalThis.vm().throwError(globalThis, err);
-                return error.ParseError;
+                return globalThis.throwValue(err);
             },
             .boolean => if (token.value != .jsvalue or !token.value.jsvalue.isUndefined()) {
                 const err = JSC.toTypeError(
@@ -244,8 +240,7 @@ fn checkOptionUsage(globalThis: *JSGlobalObject, options: []const OptionDefiniti
                     },
                     globalThis,
                 );
-                globalThis.vm().throwError(globalThis, err);
-                return error.ParseError;
+                return globalThis.throwValue(err);
             },
         }
     } else {
@@ -262,8 +257,7 @@ fn checkOptionUsage(globalThis: *JSGlobalObject, options: []const OptionDefiniti
             .{raw_name},
             globalThis,
         ));
-        globalThis.vm().throwError(globalThis, err);
-        return error.ParseError;
+        return globalThis.throwValue(err);
     }
 }
 
@@ -303,7 +297,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(.{
@@ -329,8 +323,7 @@ fn parseOptionDefinitions(globalThis: *JSGlobalObject, options_obj: JSValue, opt
             var short_option_str = short_option.toBunString(globalThis);
             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 globalThis.throwValue(err);
             }
             option.short_name = short_option_str;
         }
@@ -385,8 +378,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 +571,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) {
@@ -597,8 +590,7 @@ const ParseArgsState = struct {
                         .{token.value.asBunString(globalThis)},
                         globalThis,
                     );
-                    globalThis.vm().throwError(globalThis, err);
-                    return error.ParseError;
+                    return globalThis.throwValue(err);
                 }
                 const value = token.value.asJSValue(globalThis);
                 this.positionals.push(globalThis, value);
@@ -652,17 +644,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 +655,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 f13de796c2..cf8f3b1e04 100644
--- a/src/bun.js/node/util/validators.zig
+++ b/src/bun.js/node/util/validators.zig
@@ -18,21 +18,18 @@ pub fn throwErrInvalidArgValue(
     globalThis: *JSGlobalObject,
     comptime fmt: [:0]const u8,
     args: anytype,
-) !void {
+) bun.JSError {
     @setCold(true);
-    const err = JSC.toTypeError(.ERR_INVALID_ARG_VALUE, fmt, args, globalThis);
-    globalThis.vm().throwError(globalThis, err);
-    return error.InvalidArgument;
+    return globalThis.ERR_INVALID_ARG_VALUE(fmt, args).throw();
 }
 
 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 globalThis.ERR_INVALID_ARG_TYPE(fmt, args).throw();
 }
 
 pub fn throwErrInvalidArgType(
@@ -41,86 +38,83 @@ 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);
-    const err = globalThis.createRangeErrorInstanceWithCode(JSC.Node.ErrorCode.ERR_OUT_OF_RANGE, fmt, args);
-    globalThis.vm().throwError(globalThis, err);
-    return error.InvalidArgument;
+    return globalThis.ERR_OUT_OF_RANGE(fmt, args).throw();
 }
 
-/// -(2^53 - 1)
-pub const NUMBER__MIN_SAFE_INTEGER: i64 = -9007199254740991;
-/// (2^53 – 1)
-pub const NUMBER__MAX_SAFE_INTEGER: i64 = 9007199254740991;
-
-pub fn validateInteger(globalThis: *JSGlobalObject, value: JSValue, comptime name_fmt: string, name_args: anytype, min_value: ?i64, max_value: ?i64) !i64 {
-    const min = min_value orelse NUMBER__MIN_SAFE_INTEGER;
-    const max = max_value orelse NUMBER__MAX_SAFE_INTEGER;
+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()) {
-        try throwRangeError(globalThis, "The value of \"" ++ name_fmt ++ "\" is out of range. It must be an integer. Received {s}", name_args ++ .{value});
+        var formatter = JSC.ConsoleObject.Formatter{ .globalThis = globalThis };
+        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) {
-        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 });
+        var formatter = JSC.ConsoleObject.Formatter{ .globalThis = globalThis };
+        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()) {
-        try throwRangeError(globalThis, "The value of \"" ++ name_fmt ++ "\" is out of range. It must be an integer. Received {s}", name_args ++ .{value});
+        var formatter = JSC.ConsoleObject.Formatter{ .globalThis = globalThis };
+        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) {
-        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 });
+        var formatter = JSC.ConsoleObject.Formatter{ .globalThis = globalThis };
+        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(num);
+    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;
@@ -135,19 +129,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();
 }
 
@@ -157,80 +151,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) !void {
+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))
@@ -244,6 +239,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/diff_format.zig b/src/bun.js/test/diff_format.zig
index c907d16fd4..fc04a74e33 100644
--- a/src/bun.js/test/diff_format.zig
+++ b/src/bun.js/test/diff_format.zig
@@ -129,8 +129,8 @@ pub const DiffFormatter = struct {
             buffered_writer.flush() catch unreachable;
         }
 
-        const received_slice = received_buf.toOwnedSliceLeaky();
-        const expected_slice = expected_buf.toOwnedSliceLeaky();
+        const received_slice = received_buf.slice();
+        const expected_slice = expected_buf.slice();
 
         if (this.not) {
             const not_fmt = "Expected: not <green>{s}<r>";
diff --git a/src/bun.js/test/expect.zig b/src/bun.js/test/expect.zig
index b32b9342f1..a384c42aec 100644
--- a/src/bun.js/test/expect.zig
+++ b/src/bun.js/test/expect.zig
@@ -16,7 +16,6 @@ const JSValue = JSC.JSValue;
 const JSInternalPromise = JSC.JSInternalPromise;
 const JSPromise = JSC.JSPromise;
 const JSType = JSValue.JSType;
-const JSError = JSC.JSError;
 const JSObject = JSC.JSObject;
 const CallFrame = JSC.CallFrame;
 const ZigString = JSC.ZigString;
@@ -108,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);
             }
         };
 
@@ -136,7 +137,7 @@ pub const Expect = struct {
         return received ++ matcher_name ++ "<d>(<r>" ++ args ++ "<d>)<r>";
     }
 
-    pub fn throwPrettyMatcherError(globalThis: *JSGlobalObject, custom_label: bun.String, matcher_name: anytype, matcher_params: anytype, flags: Flags, comptime message_fmt: string, message_args: anytype) void {
+    pub fn throwPrettyMatcherError(globalThis: *JSGlobalObject, custom_label: bun.String, matcher_name: anytype, matcher_params: anytype, flags: Flags, comptime message_fmt: string, message_args: anytype) bun.JSError {
         switch (Output.enable_ansi_colors) {
             inline else => |colors| {
                 const chain = switch (flags.promise) {
@@ -148,16 +149,10 @@ pub const Expect = struct {
                     inline else => |use_default_label| {
                         if (use_default_label) {
                             const fmt = comptime Output.prettyFmt("<d>expect(<r><red>received<r><d>).<r>{s}{s}<d>(<r>{s}<d>)<r>\n\n" ++ message_fmt, colors);
-                            globalThis.throwPretty(fmt, .{
-                                chain,
-                                matcher_name,
-                                matcher_params,
-                            } ++ message_args);
+                            return globalThis.throwPretty(fmt, .{ chain, matcher_name, matcher_params } ++ message_args);
                         } else {
                             const fmt = comptime Output.prettyFmt("{}\n\n" ++ message_fmt, colors);
-                            globalThis.throwPretty(fmt, .{
-                                custom_label,
-                            } ++ message_args);
+                            return globalThis.throwPretty(fmt, .{custom_label} ++ message_args);
                         }
                     },
                 }
@@ -174,8 +169,7 @@ pub const Expect = struct {
         this.flags.promise = switch (this.flags.promise) {
             .resolves, .none => .resolves,
             .rejects => {
-                globalThis.throw("Cannot chain .resolves() after .rejects()", .{});
-                return .zero;
+                return globalThis.throw("Cannot chain .resolves() after .rejects()", .{}) catch .zero;
             },
         };
 
@@ -186,18 +180,16 @@ pub const Expect = struct {
         this.flags.promise = switch (this.flags.promise) {
             .none, .rejects => .rejects,
             .resolves => {
-                globalThis.throw("Cannot chain .rejects() after .resolves()", .{});
-                return .zero;
+                return globalThis.throw("Cannot chain .rejects() after .resolves()", .{}) catch .zero;
             },
         };
 
         return thisValue;
     }
 
-    pub fn getValue(this: *Expect, globalThis: *JSGlobalObject, thisValue: JSValue, matcher_name: string, comptime matcher_params_fmt: string) ?JSValue {
+    pub fn getValue(this: *Expect, globalThis: *JSGlobalObject, thisValue: JSValue, matcher_name: string, comptime matcher_params_fmt: string) bun.JSError!JSValue {
         const value = Expect.capturedValueGetCached(thisValue) orelse {
-            globalThis.throw("Internal error: the expect(value) was garbage collected but it should not have been!", .{});
-            return null;
+            return globalThis.throw("Internal error: the expect(value) was garbage collected but it should not have been!", .{});
         };
         value.ensureStillAlive();
 
@@ -210,7 +202,7 @@ pub const Expect = struct {
     /// Processes the async flags (resolves/rejects), waiting for the async value if needed.
     /// If no flags, returns the original value
     /// If either flag is set, waits for the result, and returns either it as a JSValue, or null if the expectation failed (in which case if silent is false, also throws a js exception)
-    pub fn processPromise(custom_label: bun.String, flags: Expect.Flags, globalThis: *JSGlobalObject, value: JSValue, matcher_name: anytype, matcher_params: anytype, comptime silent: bool) ?JSValue {
+    pub fn processPromise(custom_label: bun.String, flags: Expect.Flags, globalThis: *JSGlobalObject, value: JSValue, matcher_name: anytype, matcher_params: anytype, comptime silent: bool) bun.JSError!JSValue {
         switch (flags.promise) {
             inline .resolves, .rejects => |resolution| {
                 if (value.asAnyPromise()) |promise| {
@@ -227,9 +219,9 @@ pub const Expect = struct {
                                 if (!silent) {
                                     var formatter = JSC.ConsoleObject.Formatter{ .globalThis = globalThis, .quote_strings = true };
                                     const message = "Expected promise that rejects<r>\nReceived promise that resolved: <red>{any}<r>\n";
-                                    throwPrettyMatcherError(globalThis, custom_label, matcher_name, matcher_params, flags, message, .{value.toFmt(&formatter)});
+                                    return throwPrettyMatcherError(globalThis, custom_label, matcher_name, matcher_params, flags, message, .{value.toFmt(&formatter)});
                                 }
-                                return null;
+                                return error.JSError;
                             },
                             .none => unreachable,
                         },
@@ -239,9 +231,9 @@ pub const Expect = struct {
                                 if (!silent) {
                                     var formatter = JSC.ConsoleObject.Formatter{ .globalThis = globalThis, .quote_strings = true };
                                     const message = "Expected promise that resolves<r>\nReceived promise that rejected: <red>{any}<r>\n";
-                                    throwPrettyMatcherError(globalThis, custom_label, matcher_name, matcher_params, flags, message, .{value.toFmt(&formatter)});
+                                    return throwPrettyMatcherError(globalThis, custom_label, matcher_name, matcher_params, flags, message, .{value.toFmt(&formatter)});
                                 }
-                                return null;
+                                return error.JSError;
                             },
                             .none => unreachable,
                         },
@@ -254,9 +246,9 @@ pub const Expect = struct {
                     if (!silent) {
                         var formatter = JSC.ConsoleObject.Formatter{ .globalThis = globalThis, .quote_strings = true };
                         const message = "Expected promise<r>\nReceived: <red>{any}<r>\n";
-                        throwPrettyMatcherError(globalThis, custom_label, matcher_name, matcher_params, flags, message, .{value.toFmt(&formatter)});
+                        return throwPrettyMatcherError(globalThis, custom_label, matcher_name, matcher_params, flags, message, .{value.toFmt(&formatter)});
                     }
-                    return null;
+                    return error.JSError;
                 }
             },
             else => {},
@@ -266,24 +258,14 @@ pub const Expect = struct {
     }
 
     pub fn isAsymmetricMatcher(value: JSValue) bool {
-        if (ExpectCustomAsymmetricMatcher.fromJS(value) != null) {
-            return true;
-        } else if (ExpectAny.fromJS(value) != null) {
-            return true;
-        } else if (ExpectAnything.fromJS(value) != null) {
-            return true;
-        } else if (ExpectStringMatching.fromJS(value) != null) {
-            return true;
-        } else if (ExpectCloseTo.fromJS(value) != null) {
-            return true;
-        } else if (ExpectObjectContaining.fromJS(value) != null) {
-            return true;
-        } else if (ExpectStringContaining.fromJS(value) != null) {
-            return true;
-        } else if (ExpectArrayContaining.fromJS(value) != null) {
-            return true;
-        }
-
+        if (ExpectCustomAsymmetricMatcher.fromJS(value) != null) return true;
+        if (ExpectAny.fromJS(value) != null) return true;
+        if (ExpectAnything.fromJS(value) != null) return true;
+        if (ExpectStringMatching.fromJS(value) != null) return true;
+        if (ExpectCloseTo.fromJS(value) != null) return true;
+        if (ExpectObjectContaining.fromJS(value) != null) return true;
+        if (ExpectStringContaining.fromJS(value) != null) return true;
+        if (ExpectArrayContaining.fromJS(value) != null) return true;
         return false;
     }
 
@@ -315,11 +297,8 @@ pub const Expect = struct {
         outFlags.* = flags.encode();
 
         // (note that matcher_name/matcher_args are not used because silent=true)
-        if (processPromise(bun.String.empty, flags, globalThis, value.*, "", "", true)) |result| {
-            value.* = result;
-            return true;
-        }
-        return false;
+        value.* = processPromise(bun.String.empty, flags, globalThis, value.*, "", "", true) catch return false;
+        return true;
     }
 
     pub fn getSnapshotName(this: *Expect, allocator: std.mem.Allocator, hint: string) ![]const u8 {
@@ -374,8 +353,8 @@ pub const Expect = struct {
         VirtualMachine.get().allocator.destroy(this);
     }
 
-    pub fn call(globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
-        const arguments = callframe.arguments(2).slice();
+    pub fn call(globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
+        const arguments = callframe.arguments_old(2).slice();
         const value = if (arguments.len < 1) JSValue.jsUndefined() else arguments[0];
 
         var custom_label = bun.String.empty;
@@ -389,8 +368,7 @@ pub const Expect = struct {
 
         var expect = globalThis.bunVM().allocator.create(Expect) catch {
             custom_label.deref();
-            globalThis.throwOutOfMemory();
-            return .zero;
+            return globalThis.throwOutOfMemory();
         };
 
         expect.* = .{
@@ -415,20 +393,16 @@ pub const Expect = struct {
         return expect_js_value;
     }
 
-    pub fn throw(this: *Expect, globalThis: *JSGlobalObject, comptime signature: [:0]const u8, comptime fmt: [:0]const u8, args: anytype) void {
+    pub fn throw(this: *Expect, globalThis: *JSGlobalObject, comptime signature: [:0]const u8, comptime fmt: [:0]const u8, args: anytype) bun.JSError {
         if (this.custom_label.isEmpty()) {
-            globalThis.throwPretty(signature ++ fmt, args);
+            return globalThis.throwPretty(signature ++ fmt, args);
         } else {
-            globalThis.throwPretty("{}" ++ fmt, .{this.custom_label} ++ args);
+            return globalThis.throwPretty("{}" ++ fmt, .{this.custom_label} ++ args);
         }
     }
 
-    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.throw("expect() cannot be called with new", .{});
     }
 
     // pass here has a leading underscore to avoid name collision with the pass variable in other functions
@@ -436,10 +410,10 @@ pub const Expect = struct {
         this: *Expect,
         globalThis: *JSGlobalObject,
         callFrame: *CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
-        const arguments_ = callFrame.arguments(1);
+        const arguments_ = callFrame.arguments_old(1);
         const arguments = arguments_.slice();
 
         var _msg: ZigString = ZigString.Empty;
@@ -449,8 +423,7 @@ pub const Expect = struct {
             value.ensureStillAlive();
 
             if (!value.isString()) {
-                globalThis.throwInvalidArgumentType("pass", "message", "string");
-                return .zero;
+                return globalThis.throwInvalidArgumentType("pass", "message", "string");
             }
 
             value.toZigString(&_msg, globalThis);
@@ -471,8 +444,7 @@ pub const Expect = struct {
 
         if (not) {
             const signature = comptime getSignature("pass", "", true);
-            this.throw(globalThis, signature, "\n\n{s}\n", .{msg.slice()});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n{s}\n", .{msg.slice()});
         }
 
         // should never reach here
@@ -483,10 +455,10 @@ pub const Expect = struct {
         this: *Expect,
         globalThis: *JSGlobalObject,
         callFrame: *CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
-        const arguments_ = callFrame.arguments(1);
+        const arguments_ = callFrame.arguments_old(1);
         const arguments = arguments_.slice();
 
         var _msg: ZigString = ZigString.Empty;
@@ -496,8 +468,7 @@ pub const Expect = struct {
             value.ensureStillAlive();
 
             if (!value.isString()) {
-                globalThis.throwInvalidArgumentType("fail", "message", "string");
-                return .zero;
+                return globalThis.throwInvalidArgumentType("fail", "message", "string");
             }
 
             value.toZigString(&_msg, globalThis);
@@ -517,8 +488,7 @@ pub const Expect = struct {
         defer msg.deinit();
 
         const signature = comptime getSignature("fail", "", true);
-        this.throw(globalThis, signature, "\n\n{s}\n", .{msg.slice()});
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n{s}\n", .{msg.slice()});
     }
 
     /// Object.is()
@@ -526,21 +496,20 @@ 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);
+        const arguments_ = callframe.arguments_old(2);
         const arguments = arguments_.slice();
 
         if (arguments.len < 1) {
-            globalThis.throwInvalidArguments("toBe() takes 1 argument", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("toBe() takes 1 argument", .{});
         }
 
         incrementExpectCallCounter();
         const right = arguments[0];
         right.ensureStillAlive();
-        const left = this.getValue(globalThis, thisValue, "toBe", "<green>expected<r>") orelse return .zero;
+        const left = try this.getValue(globalThis, thisValue, "toBe", "<green>expected<r>");
 
         const not = this.flags.not;
         var pass = right.isSameValue(left, globalThis);
@@ -555,18 +524,16 @@ pub const Expect = struct {
             inline else => |has_custom_label| {
                 if (not) {
                     const signature = comptime getSignature("toBe", "<green>expected<r>", true);
-                    this.throw(globalThis, signature, "\n\nExpected: not <green>{any}<r>\n", .{right.toFmt(&formatter)});
-                    return .zero;
+                    return this.throw(globalThis, signature, "\n\nExpected: not <green>{any}<r>\n", .{right.toFmt(&formatter)});
                 }
 
                 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";
-                    this.throw(globalThis, signature, fmt, .{right.toFmt(&formatter)});
-                    return .zero;
+                    return this.throw(globalThis, signature, fmt, .{right.toFmt(&formatter)});
                 }
 
                 if (right.isString() and left.isString()) {
@@ -576,15 +543,13 @@ pub const Expect = struct {
                         .globalThis = globalThis,
                         .not = not,
                     };
-                    this.throw(globalThis, signature, "\n\n{any}\n", .{diff_format});
-                    return .zero;
+                    return this.throw(globalThis, signature, "\n\n{any}\n", .{diff_format});
                 }
 
-                this.throw(globalThis, signature, "\n\nExpected: <green>{any}<r>\nReceived: <red>{any}<r>\n", .{
+                return this.throw(globalThis, signature, "\n\nExpected: <green>{any}<r>\nReceived: <red>{any}<r>\n", .{
                     right.toFmt(&formatter),
                     left.toFmt(&formatter),
                 });
-                return .zero;
             },
         }
     }
@@ -593,39 +558,35 @@ 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);
+        const arguments_ = callframe.arguments_old(1);
         const arguments = arguments_.slice();
 
         if (arguments.len < 1) {
-            globalThis.throwInvalidArguments("toHaveLength() takes 1 argument", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("toHaveLength() takes 1 argument", .{});
         }
 
         incrementExpectCallCounter();
 
         const expected: JSValue = arguments[0];
-        const value: JSValue = this.getValue(globalThis, thisValue, "toHaveLength", "<green>expected<r>") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toHaveLength", "<green>expected<r>");
 
         if (!value.isObject() and !value.isString()) {
             var fmt = JSC.ConsoleObject.Formatter{ .globalThis = globalThis, .quote_strings = true };
-            globalThis.throw("Received value does not have a length property: {any}", .{value.toFmt(&fmt)});
-            return .zero;
+            return globalThis.throw("Received value does not have a length property: {any}", .{value.toFmt(&fmt)});
         }
 
         if (!expected.isNumber()) {
             var fmt = JSC.ConsoleObject.Formatter{ .globalThis = globalThis, .quote_strings = true };
-            globalThis.throw("Expected value must be a non-negative integer: {any}", .{expected.toFmt(&fmt)});
-            return .zero;
+            return globalThis.throw("Expected value must be a non-negative integer: {any}", .{expected.toFmt(&fmt)});
         }
 
         const expected_length: f64 = expected.asNumber();
         if (@round(expected_length) != expected_length or std.math.isInf(expected_length) or std.math.isNan(expected_length) or expected_length < 0) {
             var fmt = JSC.ConsoleObject.Formatter{ .globalThis = globalThis, .quote_strings = true };
-            globalThis.throw("Expected value must be a non-negative integer: {any}", .{expected.toFmt(&fmt)});
-            return .zero;
+            return globalThis.throw("Expected value must be a non-negative integer: {any}", .{expected.toFmt(&fmt)});
         }
 
         const not = this.flags.not;
@@ -635,11 +596,9 @@ pub const Expect = struct {
 
         if (actual_length == std.math.inf(f64)) {
             var fmt = JSC.ConsoleObject.Formatter{ .globalThis = globalThis, .quote_strings = true };
-            globalThis.throw("Received value does not have a length property: {any}", .{value.toFmt(&fmt)});
-            return .zero;
+            return globalThis.throw("Received value does not have a length property: {any}", .{value.toFmt(&fmt)});
         } else if (std.math.isNan(actual_length)) {
-            globalThis.throw("Received value has non-number length property: {}", .{actual_length});
-            return .zero;
+            return globalThis.throw("Received value has non-number length property: {}", .{actual_length});
         }
 
         if (actual_length == expected_length) {
@@ -653,35 +612,32 @@ pub const Expect = struct {
         if (not) {
             const expected_line = "Expected length: not <green>{d}<r>\n";
             const signature = comptime getSignature("toHaveLength", "<green>expected<r>", true);
-            this.throw(globalThis, signature, "\n\n" ++ expected_line, .{expected_length});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ expected_line, .{expected_length});
         }
 
         const expected_line = "Expected length: <green>{d}<r>\n";
         const received_line = "Received length: <red>{d}<r>\n";
         const signature = comptime getSignature("toHaveLength", "<green>expected<r>", false);
-        this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_length, actual_length });
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_length, actual_length });
     }
 
     pub fn toBeOneOf(
         this: *Expect,
         globalThis: *JSGlobalObject,
         callFrame: *CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
         const thisValue = callFrame.this();
-        const arguments_ = callFrame.arguments(1);
+        const arguments_ = callFrame.arguments_old(1);
         const arguments = arguments_.slice();
 
         if (arguments.len < 1) {
-            globalThis.throwInvalidArguments("toBeOneOf() takes 1 argument", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("toBeOneOf() takes 1 argument", .{});
         }
 
         incrementExpectCallCounter();
 
-        const expected = this.getValue(globalThis, thisValue, "toBeOneOf", "<green>expected<r>") orelse return .zero;
+        const expected = try this.getValue(globalThis, thisValue, "toBeOneOf", "<green>expected<r>");
         const list_value: JSValue = arguments[0];
 
         const not = this.flags.not;
@@ -697,7 +653,7 @@ pub const Expect = struct {
             var itr = list_value.arrayIterator(globalThis);
             while (itr.next()) |item| {
                 // Confusingly, jest-extended uses `deepEqual`, instead of `toBe`
-                if (item.jestDeepEquals(expected, globalThis)) {
+                if (try item.jestDeepEquals(expected, globalThis)) {
                     pass = true;
                     break;
                 }
@@ -717,15 +673,14 @@ pub const Expect = struct {
                 ) callconv(.C) void {
                     const entry = bun.cast(*ExpectedEntry, entry_.?);
                     // Confusingly, jest-extended uses `deepEqual`, instead of `toBe`
-                    if (item.jestDeepEquals(entry.expected, entry.globalThis)) {
+                    if (item.jestDeepEquals(entry.expected, entry.globalThis) catch return) {
                         entry.pass.* = true;
                         // TODO(perf): break out of the `forEach` when a match is found
                     }
                 }
             }.sameValueIterator);
         } else {
-            globalThis.throw("Received value must be an array type, or both received and expected values must be strings.", .{});
-            return .zero;
+            return globalThis.throw("Received value must be an array type, or both received and expected values must be strings.", .{});
         }
 
         if (not) pass = !pass;
@@ -739,37 +694,34 @@ pub const Expect = struct {
             const received_fmt = list_value.toFmt(&formatter);
             const expected_line = "Expected to not be one of: <green>{any}<r>\nReceived: <red>{any}<r>\n";
             const signature = comptime getSignature("toBeOneOf", "<green>expected<r>", true);
-            this.throw(globalThis, signature, "\n\n" ++ expected_line, .{ received_fmt, expected_fmt });
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ expected_line, .{ received_fmt, expected_fmt });
         }
 
         const expected_line = "Expected to be one of: <green>{any}<r>\n";
         const received_line = "Received: <red>{any}<r>\n";
         const signature = comptime getSignature("toBeOneOf", "<green>expected<r>", false);
-        this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ value_fmt, expected_fmt });
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ value_fmt, expected_fmt });
     }
 
     pub fn toContain(
         this: *Expect,
         globalThis: *JSGlobalObject,
         callFrame: *CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
         const thisValue = callFrame.this();
-        const arguments_ = callFrame.arguments(1);
+        const arguments_ = callFrame.arguments_old(1);
         const arguments = arguments_.slice();
 
         if (arguments.len < 1) {
-            globalThis.throwInvalidArguments("toContain() takes 1 argument", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("toContain() takes 1 argument", .{});
         }
 
         incrementExpectCallCounter();
 
         const expected = arguments[0];
         expected.ensureStillAlive();
-        const value: JSValue = this.getValue(globalThis, thisValue, "toContain", "<green>expected<r>") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toContain", "<green>expected<r>");
 
         const not = this.flags.not;
         var pass = false;
@@ -822,8 +774,7 @@ pub const Expect = struct {
                 }
             }.sameValueIterator);
         } else {
-            globalThis.throw("Received value must be an array type, or both received and expected values must be strings.", .{});
-            return .zero;
+            return globalThis.throw("Received value must be an array type, or both received and expected values must be strings.", .{});
         }
 
         if (not) pass = !pass;
@@ -837,43 +788,39 @@ pub const Expect = struct {
             const received_fmt = value.toFmt(&formatter);
             const expected_line = "Expected to not contain: <green>{any}<r>\nReceived: <red>{any}<r>\n";
             const signature = comptime getSignature("toContain", "<green>expected<r>", true);
-            this.throw(globalThis, signature, "\n\n" ++ expected_line, .{ expected_fmt, received_fmt });
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ expected_line, .{ expected_fmt, received_fmt });
         }
 
         const expected_line = "Expected to contain: <green>{any}<r>\n";
         const received_line = "Received: <red>{any}<r>\n";
         const signature = comptime getSignature("toContain", "<green>expected<r>", false);
-        this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
     }
 
     pub fn toContainKey(
         this: *Expect,
         globalThis: *JSGlobalObject,
         callFrame: *CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
         const thisValue = callFrame.this();
-        const arguments_ = callFrame.arguments(1);
+        const arguments_ = callFrame.arguments_old(1);
         const arguments = arguments_.slice();
 
         if (arguments.len < 1) {
-            globalThis.throwInvalidArguments("toContainKey() takes 1 argument", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("toContainKey() takes 1 argument", .{});
         }
 
         incrementExpectCallCounter();
 
         const expected = arguments[0];
         expected.ensureStillAlive();
-        const value: JSValue = this.getValue(globalThis, thisValue, "toContainKey", "<green>expected<r>") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toContainKey", "<green>expected<r>");
         var formatter = JSC.ConsoleObject.Formatter{ .globalThis = globalThis, .quote_strings = true };
 
         const not = this.flags.not;
         if (!value.isObject()) {
-            globalThis.throwInvalidArguments("Expected value must be an object\nReceived: {}", .{value.toFmt(&formatter)});
-            return .zero;
+            return globalThis.throwInvalidArguments("Expected value must be an object\nReceived: {}", .{value.toFmt(&formatter)});
         }
 
         var pass = value.hasOwnPropertyValue(globalThis, expected);
@@ -893,41 +840,37 @@ pub const Expect = struct {
             const received_fmt = value.toFmt(&formatter);
             const expected_line = "Expected to not contain: <green>{any}<r>\nReceived: <red>{any}<r>\n";
             const signature = comptime getSignature("toContainKey", "<green>expected<r>", true);
-            this.throw(globalThis, signature, "\n\n" ++ expected_line, .{ expected_fmt, received_fmt });
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ expected_line, .{ expected_fmt, received_fmt });
         }
 
         const expected_line = "Expected to contain: <green>{any}<r>\n";
         const received_line = "Received: <red>{any}<r>\n";
         const signature = comptime getSignature("toContainKey", "<green>expected<r>", false);
-        this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
     }
 
     pub fn toContainKeys(
         this: *Expect,
         globalThis: *JSGlobalObject,
         callFrame: *CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
         const thisValue = callFrame.this();
-        const arguments_ = callFrame.arguments(1);
+        const arguments_ = callFrame.arguments_old(1);
         const arguments = arguments_.slice();
 
         if (arguments.len < 1) {
-            globalThis.throwInvalidArguments("toContainKeys() takes 1 argument", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("toContainKeys() takes 1 argument", .{});
         }
 
         incrementExpectCallCounter();
 
         const expected = arguments[0];
         expected.ensureStillAlive();
-        const value: JSValue = this.getValue(globalThis, thisValue, "toContainKeys", "<green>expected<r>") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toContainKeys", "<green>expected<r>");
 
         if (!expected.jsType().isArray()) {
-            globalThis.throwInvalidArgumentType("toContainKeys", "expected", "array");
-            return .zero;
+            return globalThis.throwInvalidArgumentType("toContainKeys", "expected", "array");
         }
 
         const not = this.flags.not;
@@ -966,41 +909,37 @@ pub const Expect = struct {
             const received_fmt = value.toFmt(&formatter);
             const expected_line = "Expected to not contain: <green>{any}<r>\nReceived: <red>{any}<r>\n";
             const signature = comptime getSignature("toContainKeys", "<green>expected<r>", true);
-            this.throw(globalThis, signature, "\n\n" ++ expected_line, .{ expected_fmt, received_fmt });
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ expected_line, .{ expected_fmt, received_fmt });
         }
 
         const expected_line = "Expected to contain: <green>{any}<r>\n";
         const received_line = "Received: <red>{any}<r>\n";
         const signature = comptime getSignature("toContainKeys", "<green>expected<r>", false);
-        this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
     }
 
     pub fn toContainAllKeys(
         this: *Expect,
         globalObject: *JSGlobalObject,
         callFrame: *CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         defer this.postMatch(globalObject);
         const thisValue = callFrame.this();
-        const arguments_ = callFrame.arguments(1);
+        const arguments_ = callFrame.arguments_old(1);
         const arguments = arguments_.slice();
 
         if (arguments.len < 1) {
-            globalObject.throwInvalidArguments("toContainAllKeys() takes 1 argument", .{});
-            return .zero;
+            return globalObject.throwInvalidArguments("toContainAllKeys() takes 1 argument", .{});
         }
 
         incrementExpectCallCounter();
 
         const expected = arguments[0];
         expected.ensureStillAlive();
-        const value: JSValue = this.getValue(globalObject, thisValue, "toContainAllKeys", "<green>expected<r>") orelse return .zero;
+        const value: JSValue = try this.getValue(globalObject, thisValue, "toContainAllKeys", "<green>expected<r>");
 
         if (!expected.jsType().isArray()) {
-            globalObject.throwInvalidArgumentType("toContainAllKeys", "expected", "array");
-            return .zero;
+            return globalObject.throwInvalidArgumentType("toContainAllKeys", "expected", "array");
         }
 
         const not = this.flags.not;
@@ -1016,7 +955,7 @@ pub const Expect = struct {
                     var i: u32 = 0;
                     while (i < count) : (i += 1) {
                         const key = expected.getIndex(globalObject, i);
-                        if (item.jestDeepEquals(key, globalObject)) break;
+                        if (try item.jestDeepEquals(key, globalObject)) break;
                     } else break :outer;
                 }
                 pass = true;
@@ -1034,41 +973,37 @@ pub const Expect = struct {
             const received_fmt = keys.toFmt(&formatter);
             const expected_line = "Expected to not contain all keys: <green>{any}<r>\nReceived: <red>{any}<r>\n";
             const fmt = "\n\n" ++ expected_line;
-            this.throw(globalObject, comptime getSignature("toContainAllKeys", "<green>expected<r>", true), fmt, .{ expected_fmt, received_fmt });
-            return .zero;
+            return this.throw(globalObject, comptime getSignature("toContainAllKeys", "<green>expected<r>", true), fmt, .{ expected_fmt, received_fmt });
         }
 
         const expected_line = "Expected to contain all keys: <green>{any}<r>\n";
         const received_line = "Received: <red>{any}<r>\n";
         const fmt = "\n\n" ++ expected_line ++ received_line;
-        this.throw(globalObject, comptime getSignature("toContainAllKeys", "<green>expected<r>", false), fmt, .{ expected_fmt, value_fmt });
-        return .zero;
+        return this.throw(globalObject, comptime getSignature("toContainAllKeys", "<green>expected<r>", false), fmt, .{ expected_fmt, value_fmt });
     }
 
     pub fn toContainAnyKeys(
         this: *Expect,
         globalThis: *JSGlobalObject,
         callFrame: *CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
         const thisValue = callFrame.this();
-        const arguments_ = callFrame.arguments(1);
+        const arguments_ = callFrame.arguments_old(1);
         const arguments = arguments_.slice();
 
         if (arguments.len < 1) {
-            globalThis.throwInvalidArguments("toContainAnyKeys() takes 1 argument", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("toContainAnyKeys() takes 1 argument", .{});
         }
 
         incrementExpectCallCounter();
 
         const expected = arguments[0];
         expected.ensureStillAlive();
-        const value: JSValue = this.getValue(globalThis, thisValue, "toContainAnyKeys", "<green>expected<r>") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toContainAnyKeys", "<green>expected<r>");
 
         if (!expected.jsType().isArray()) {
-            globalThis.throwInvalidArgumentType("toContainAnyKeys", "expected", "array");
-            return .zero;
+            return globalThis.throwInvalidArgumentType("toContainAnyKeys", "expected", "array");
         }
 
         const not = this.flags.not;
@@ -1102,37 +1037,34 @@ pub const Expect = struct {
             const received_fmt = value.toFmt(&formatter);
             const expected_line = "Expected to not contain: <green>{any}<r>\nReceived: <red>{any}<r>\n";
             const signature = comptime getSignature("toContainAnyKeys", "<green>expected<r>", true);
-            this.throw(globalThis, signature, "\n\n" ++ expected_line, .{ expected_fmt, received_fmt });
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ expected_line, .{ expected_fmt, received_fmt });
         }
 
         const expected_line = "Expected to contain: <green>{any}<r>\n";
         const received_line = "Received: <red>{any}<r>\n";
         const signature = comptime getSignature("toContainAnyKeys", "<green>expected<r>", false);
-        this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
     }
 
     pub fn toContainValue(
         this: *Expect,
         globalObject: *JSGlobalObject,
         callFrame: *CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         defer this.postMatch(globalObject);
         const thisValue = callFrame.this();
-        const arguments_ = callFrame.arguments(1);
+        const arguments_ = callFrame.arguments_old(1);
         const arguments = arguments_.slice();
 
         if (arguments.len < 1) {
-            globalObject.throwInvalidArguments("toContainValue() takes 1 argument", .{});
-            return .zero;
+            return globalObject.throwInvalidArguments("toContainValue() takes 1 argument", .{});
         }
 
         incrementExpectCallCounter();
 
         const expected = arguments[0];
         expected.ensureStillAlive();
-        const value: JSValue = this.getValue(globalObject, thisValue, "toContainValue", "<green>expected<r>") orelse return .zero;
+        const value: JSValue = try this.getValue(globalObject, thisValue, "toContainValue", "<green>expected<r>");
 
         const not = this.flags.not;
         var pass = false;
@@ -1141,7 +1073,7 @@ pub const Expect = struct {
             const values = value.values(globalObject);
             var itr = values.arrayIterator(globalObject);
             while (itr.next()) |item| {
-                if (item.jestDeepEquals(expected, globalObject)) {
+                if (try item.jestDeepEquals(expected, globalObject)) {
                     pass = true;
                     break;
                 }
@@ -1159,41 +1091,37 @@ pub const Expect = struct {
             const received_fmt = value.toFmt(&formatter);
             const expected_line = "Expected to not contain: <green>{any}<r>\nReceived: <red>{any}<r>\n";
             const fmt = "\n\n" ++ expected_line;
-            this.throw(globalObject, comptime getSignature("toContainValue", "<green>expected<r>", true), fmt, .{ expected_fmt, received_fmt });
-            return .zero;
+            return this.throw(globalObject, comptime getSignature("toContainValue", "<green>expected<r>", true), fmt, .{ expected_fmt, received_fmt });
         }
 
         const expected_line = "Expected to contain: <green>{any}<r>\n";
         const received_line = "Received: <red>{any}<r>\n";
         const fmt = "\n\n" ++ expected_line ++ received_line;
-        this.throw(globalObject, comptime getSignature("toContainValue", "<green>expected<r>", false), fmt, .{ expected_fmt, value_fmt });
-        return .zero;
+        return this.throw(globalObject, comptime getSignature("toContainValue", "<green>expected<r>", false), fmt, .{ expected_fmt, value_fmt });
     }
 
     pub fn toContainValues(
         this: *Expect,
         globalObject: *JSGlobalObject,
         callFrame: *CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         defer this.postMatch(globalObject);
         const thisValue = callFrame.this();
-        const arguments_ = callFrame.arguments(1);
+        const arguments_ = callFrame.arguments_old(1);
         const arguments = arguments_.slice();
 
         if (arguments.len < 1) {
-            globalObject.throwInvalidArguments("toContainValues() takes 1 argument", .{});
-            return .zero;
+            return globalObject.throwInvalidArguments("toContainValues() takes 1 argument", .{});
         }
 
         incrementExpectCallCounter();
 
         const expected = arguments[0];
         if (!expected.jsType().isArray()) {
-            globalObject.throwInvalidArgumentType("toContainValues", "expected", "array");
-            return .zero;
+            return globalObject.throwInvalidArgumentType("toContainValues", "expected", "array");
         }
         expected.ensureStillAlive();
-        const value: JSValue = this.getValue(globalObject, thisValue, "toContainValues", "<green>expected<r>") orelse return .zero;
+        const value: JSValue = try this.getValue(globalObject, thisValue, "toContainValues", "<green>expected<r>");
 
         const not = this.flags.not;
         var pass = true;
@@ -1207,7 +1135,7 @@ pub const Expect = struct {
                 var i: u32 = 0;
                 while (i < count) : (i += 1) {
                     const key = values.getIndex(globalObject, i);
-                    if (key.jestDeepEquals(item, globalObject)) break;
+                    if (try key.jestDeepEquals(item, globalObject)) break;
                 } else {
                     pass = false;
                     break;
@@ -1226,41 +1154,37 @@ pub const Expect = struct {
             const received_fmt = value.toFmt(&formatter);
             const expected_line = "Expected to not contain: <green>{any}<r>\nReceived: <red>{any}<r>\n";
             const fmt = "\n\n" ++ expected_line;
-            this.throw(globalObject, comptime getSignature("toContainValues", "<green>expected<r>", true), fmt, .{ expected_fmt, received_fmt });
-            return .zero;
+            return this.throw(globalObject, comptime getSignature("toContainValues", "<green>expected<r>", true), fmt, .{ expected_fmt, received_fmt });
         }
 
         const expected_line = "Expected to contain: <green>{any}<r>\n";
         const received_line = "Received: <red>{any}<r>\n";
         const fmt = "\n\n" ++ expected_line ++ received_line;
-        this.throw(globalObject, comptime getSignature("toContainValues", "<green>expected<r>", false), fmt, .{ expected_fmt, value_fmt });
-        return .zero;
+        return this.throw(globalObject, comptime getSignature("toContainValues", "<green>expected<r>", false), fmt, .{ expected_fmt, value_fmt });
     }
 
     pub fn toContainAllValues(
         this: *Expect,
         globalObject: *JSGlobalObject,
         callFrame: *CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         defer this.postMatch(globalObject);
         const thisValue = callFrame.this();
-        const arguments_ = callFrame.arguments(1);
+        const arguments_ = callFrame.arguments_old(1);
         const arguments = arguments_.slice();
 
         if (arguments.len < 1) {
-            globalObject.throwInvalidArguments("toContainAllValues() takes 1 argument", .{});
-            return .zero;
+            return globalObject.throwInvalidArguments("toContainAllValues() takes 1 argument", .{});
         }
 
         incrementExpectCallCounter();
 
         const expected = arguments[0];
         if (!expected.jsType().isArray()) {
-            globalObject.throwInvalidArgumentType("toContainAllValues", "expected", "array");
-            return .zero;
+            return globalObject.throwInvalidArgumentType("toContainAllValues", "expected", "array");
         }
         expected.ensureStillAlive();
-        const value: JSValue = this.getValue(globalObject, thisValue, "toContainAllValues", "<green>expected<r>") orelse return .zero;
+        const value: JSValue = try this.getValue(globalObject, thisValue, "toContainAllValues", "<green>expected<r>");
 
         const not = this.flags.not;
         var pass = false;
@@ -1276,7 +1200,7 @@ pub const Expect = struct {
                     var i: u32 = 0;
                     while (i < count) : (i += 1) {
                         const key = values.getIndex(globalObject, i);
-                        if (key.jestDeepEquals(item, globalObject)) {
+                        if (try key.jestDeepEquals(item, globalObject)) {
                             pass = true;
                             break;
                         }
@@ -1299,41 +1223,37 @@ pub const Expect = struct {
             const received_fmt = value.toFmt(&formatter);
             const expected_line = "Expected to not contain all values: <green>{any}<r>\nReceived: <red>{any}<r>\n";
             const fmt = "\n\n" ++ expected_line;
-            this.throw(globalObject, comptime getSignature("toContainAllValues", "<green>expected<r>", true), fmt, .{ expected_fmt, received_fmt });
-            return .zero;
+            return this.throw(globalObject, comptime getSignature("toContainAllValues", "<green>expected<r>", true), fmt, .{ expected_fmt, received_fmt });
         }
 
         const expected_line = "Expected to contain all values: <green>{any}<r>\n";
         const received_line = "Received: <red>{any}<r>\n";
         const fmt = "\n\n" ++ expected_line ++ received_line;
-        this.throw(globalObject, comptime getSignature("toContainAllValues", "<green>expected<r>", false), fmt, .{ expected_fmt, value_fmt });
-        return .zero;
+        return this.throw(globalObject, comptime getSignature("toContainAllValues", "<green>expected<r>", false), fmt, .{ expected_fmt, value_fmt });
     }
 
     pub fn toContainAnyValues(
         this: *Expect,
         globalObject: *JSGlobalObject,
         callFrame: *CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         defer this.postMatch(globalObject);
         const thisValue = callFrame.this();
-        const arguments_ = callFrame.arguments(1);
+        const arguments_ = callFrame.arguments_old(1);
         const arguments = arguments_.slice();
 
         if (arguments.len < 1) {
-            globalObject.throwInvalidArguments("toContainAnyValues() takes 1 argument", .{});
-            return .zero;
+            return globalObject.throwInvalidArguments("toContainAnyValues() takes 1 argument", .{});
         }
 
         incrementExpectCallCounter();
 
         const expected = arguments[0];
         if (!expected.jsType().isArray()) {
-            globalObject.throwInvalidArgumentType("toContainAnyValues", "expected", "array");
-            return .zero;
+            return globalObject.throwInvalidArgumentType("toContainAnyValues", "expected", "array");
         }
         expected.ensureStillAlive();
-        const value: JSValue = this.getValue(globalObject, thisValue, "toContainAnyValues", "<green>expected<r>") orelse return .zero;
+        const value: JSValue = try this.getValue(globalObject, thisValue, "toContainAnyValues", "<green>expected<r>");
 
         const not = this.flags.not;
         var pass = false;
@@ -1347,7 +1267,7 @@ pub const Expect = struct {
                 var i: u32 = 0;
                 while (i < count) : (i += 1) {
                     const key = values.getIndex(globalObject, i);
-                    if (key.jestDeepEquals(item, globalObject)) {
+                    if (try key.jestDeepEquals(item, globalObject)) {
                         pass = true;
                         break :outer;
                     }
@@ -1366,37 +1286,34 @@ pub const Expect = struct {
             const received_fmt = value.toFmt(&formatter);
             const expected_line = "Expected to not contain any of the following values: <green>{any}<r>\nReceived: <red>{any}<r>\n";
             const fmt = "\n\n" ++ expected_line;
-            this.throw(globalObject, comptime getSignature("toContainAnyValues", "<green>expected<r>", true), fmt, .{ expected_fmt, received_fmt });
-            return .zero;
+            return this.throw(globalObject, comptime getSignature("toContainAnyValues", "<green>expected<r>", true), fmt, .{ expected_fmt, received_fmt });
         }
 
         const expected_line = "Expected to contain any of the following values: <green>{any}<r>\n";
         const received_line = "Received: <red>{any}<r>\n";
         const fmt = "\n\n" ++ expected_line ++ received_line;
-        this.throw(globalObject, comptime getSignature("toContainAnyValues", "<green>expected<r>", false), fmt, .{ expected_fmt, value_fmt });
-        return .zero;
+        return this.throw(globalObject, comptime getSignature("toContainAnyValues", "<green>expected<r>", false), fmt, .{ expected_fmt, value_fmt });
     }
 
     pub fn toContainEqual(
         this: *Expect,
         globalThis: *JSGlobalObject,
         callFrame: *CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
         const thisValue = callFrame.this();
-        const arguments_ = callFrame.arguments(1);
+        const arguments_ = callFrame.arguments_old(1);
         const arguments = arguments_.slice();
 
         if (arguments.len < 1) {
-            globalThis.throwInvalidArguments("toContainEqual() takes 1 argument", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("toContainEqual() takes 1 argument", .{});
         }
 
         active_test_expectation_counter.actual += 1;
 
         const expected = arguments[0];
         expected.ensureStillAlive();
-        const value: JSValue = this.getValue(globalThis, thisValue, "toContainEqual", "<green>expected<r>") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toContainEqual", "<green>expected<r>");
 
         const not = this.flags.not;
         var pass = false;
@@ -1413,16 +1330,16 @@ pub const Expect = struct {
         if (value_type.isArrayLike()) {
             var itr = value.arrayIterator(globalThis);
             while (itr.next()) |item| {
-                if (item.jestDeepEquals(expected, globalThis)) {
+                if (try item.jestDeepEquals(expected, globalThis)) {
                     pass = true;
                     break;
                 }
             }
         } else if (value_type.isStringLike() and expected_type.isStringLike()) {
             if (expected_type.isStringObjectLike() and value_type.isString()) pass = false else {
-                const value_string = value.toSliceOrNull(globalThis) orelse return .zero;
+                const value_string = try value.toSliceOrNull(globalThis);
                 defer value_string.deinit();
-                const expected_string = expected.toSliceOrNull(globalThis) orelse return .zero;
+                const expected_string = try expected.toSliceOrNull(globalThis);
                 defer expected_string.deinit();
 
                 // jest does not have a `typeof === "string"` check for `toContainEqual`.
@@ -1451,15 +1368,14 @@ pub const Expect = struct {
                     item: JSValue,
                 ) callconv(.C) void {
                     const entry = bun.cast(*ExpectedEntry, entry_.?);
-                    if (item.jestDeepEquals(entry.expected, entry.globalThis)) {
+                    if (item.jestDeepEquals(entry.expected, entry.globalThis) catch return) {
                         entry.pass.* = true;
                         // TODO(perf): break out of the `forEach` when a match is found
                     }
                 }
             }.deepEqualsIterator);
         } else {
-            globalThis.throw("Received value must be an array type, or both received and expected values must be strings.", .{});
-            return .zero;
+            return globalThis.throw("Received value must be an array type, or both received and expected values must be strings.", .{});
         }
 
         if (not) pass = !pass;
@@ -1472,28 +1388,26 @@ pub const Expect = struct {
         if (not) {
             const expected_line = "Expected to not contain: <green>{any}<r>\n";
             const signature = comptime getSignature("toContainEqual", "<green>expected<r>", true);
-            this.throw(globalThis, signature, "\n\n" ++ expected_line, .{expected_fmt});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ expected_line, .{expected_fmt});
         }
 
         const expected_line = "Expected to contain: <green>{any}<r>\n";
         const received_line = "Received: <red>{any}<r>\n";
         const signature = comptime getSignature("toContainEqual", "<green>expected<r>", false);
-        this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
     }
 
-    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;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toBeTruthy", "");
 
         incrementExpectCallCounter();
 
         const not = this.flags.not;
         var pass = false;
 
-        const truthy = value.toBooleanSlow(globalThis);
+        const truthy = value.toBoolean();
         if (truthy) pass = true;
 
         if (not) pass = !pass;
@@ -1505,20 +1419,18 @@ pub const Expect = struct {
         if (not) {
             const received_line = "Received: <red>{any}<r>\n";
             const signature = comptime getSignature("toBeTruthy", "", true);
-            this.throw(globalThis, signature, "\n\n" ++ received_line, .{value_fmt});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ received_line, .{value_fmt});
         }
 
         const received_line = "Received: <red>{any}<r>\n";
         const signature = comptime getSignature("toBeTruthy", "", false);
-        this.throw(globalThis, signature, "\n\n" ++ received_line, .{value_fmt});
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ received_line, .{value_fmt});
     }
 
-    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;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toBeUndefined", "");
 
         incrementExpectCallCounter();
 
@@ -1535,21 +1447,19 @@ pub const Expect = struct {
         if (not) {
             const received_line = "Received: <red>{any}<r>\n";
             const signature = comptime getSignature("toBeUndefined", "", true);
-            this.throw(globalThis, signature, "\n\n" ++ received_line, .{value_fmt});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ received_line, .{value_fmt});
         }
 
         const received_line = "Received: <red>{any}<r>\n";
         const signature = comptime getSignature("toBeUndefined", "", false);
-        this.throw(globalThis, signature, "\n\n" ++ received_line, .{value_fmt});
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ received_line, .{value_fmt});
     }
 
-    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();
-        const value: JSValue = this.getValue(globalThis, thisValue, "toBeNaN", "") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toBeNaN", "");
 
         incrementExpectCallCounter();
 
@@ -1569,21 +1479,19 @@ pub const Expect = struct {
         if (not) {
             const received_line = "Received: <red>{any}<r>\n";
             const signature = comptime getSignature("toBeNaN", "", true);
-            this.throw(globalThis, signature, "\n\n" ++ received_line, .{value_fmt});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ received_line, .{value_fmt});
         }
 
         const received_line = "Received: <red>{any}<r>\n";
         const signature = comptime getSignature("toBeNaN", "", false);
-        this.throw(globalThis, signature, "\n\n" ++ received_line, .{value_fmt});
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ received_line, .{value_fmt});
     }
 
-    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();
-        const value: JSValue = this.getValue(globalThis, thisValue, "toBeNull", "") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toBeNull", "");
 
         incrementExpectCallCounter();
 
@@ -1598,21 +1506,19 @@ pub const Expect = struct {
         if (not) {
             const received_line = "Received: <red>{any}<r>\n";
             const signature = comptime getSignature("toBeNull", "", true);
-            this.throw(globalThis, signature, "\n\n" ++ received_line, .{value_fmt});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ received_line, .{value_fmt});
         }
 
         const received_line = "Received: <red>{any}<r>\n";
         const signature = comptime getSignature("toBeNull", "", false);
-        this.throw(globalThis, signature, "\n\n" ++ received_line, .{value_fmt});
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ received_line, .{value_fmt});
     }
 
-    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();
-        const value: JSValue = this.getValue(globalThis, thisValue, "toBeDefined", "") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toBeDefined", "");
 
         incrementExpectCallCounter();
 
@@ -1627,29 +1533,27 @@ pub const Expect = struct {
         if (not) {
             const received_line = "Received: <red>{any}<r>\n";
             const signature = comptime getSignature("toBeDefined", "", true);
-            this.throw(globalThis, signature, "\n\n" ++ received_line, .{value_fmt});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ received_line, .{value_fmt});
         }
 
         const received_line = "Received: <red>{any}<r>\n";
         const signature = comptime getSignature("toBeDefined", "", false);
-        this.throw(globalThis, signature, "\n\n" ++ received_line, .{value_fmt});
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ received_line, .{value_fmt});
     }
 
-    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();
 
-        const value: JSValue = this.getValue(globalThis, thisValue, "toBeFalsy", "") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toBeFalsy", "");
 
         incrementExpectCallCounter();
 
         const not = this.flags.not;
         var pass = false;
 
-        const truthy = value.toBooleanSlow(globalThis);
+        const truthy = value.toBoolean();
         if (!truthy) pass = true;
 
         if (not) pass = !pass;
@@ -1661,35 +1565,32 @@ pub const Expect = struct {
         if (not) {
             const received_line = "Received: <red>{any}<r>\n";
             const signature = comptime getSignature("toBeFalsy", "", true);
-            this.throw(globalThis, signature, "\n\n" ++ received_line, .{value_fmt});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ received_line, .{value_fmt});
         }
 
         const received_line = "Received: <red>{any}<r>\n";
         const signature = comptime getSignature("toBeFalsy", "", false);
-        this.throw(globalThis, signature, "\n\n" ++ received_line, .{value_fmt});
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ received_line, .{value_fmt});
     }
 
-    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();
-        const _arguments = callFrame.arguments(1);
+        const _arguments = callFrame.arguments_old(1);
         const arguments: []const JSValue = _arguments.ptr[0.._arguments.len];
 
         if (arguments.len < 1) {
-            globalThis.throwInvalidArguments("toEqual() requires 1 argument", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("toEqual() requires 1 argument", .{});
         }
 
         incrementExpectCallCounter();
 
         const expected = arguments[0];
-        const value: JSValue = this.getValue(globalThis, thisValue, "toEqual", "<green>expected<r>") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toEqual", "<green>expected<r>");
 
         const not = this.flags.not;
-        var pass = value.jestDeepEquals(expected, globalThis);
+        var pass = try value.jestDeepEquals(expected, globalThis);
 
         if (not) pass = !pass;
         if (pass) return .undefined;
@@ -1704,31 +1605,28 @@ pub const Expect = struct {
 
         if (not) {
             const signature = comptime getSignature("toEqual", "<green>expected<r>", true);
-            this.throw(globalThis, signature, "\n\n{any}\n", .{diff_formatter});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n{any}\n", .{diff_formatter});
         }
 
         const signature = comptime getSignature("toEqual", "<green>expected<r>", false);
-        this.throw(globalThis, signature, "\n\n{any}\n", .{diff_formatter});
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n{any}\n", .{diff_formatter});
     }
 
-    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();
-        const _arguments = callFrame.arguments(1);
+        const _arguments = callFrame.arguments_old(1);
         const arguments: []const JSValue = _arguments.ptr[0.._arguments.len];
 
         if (arguments.len < 1) {
-            globalThis.throwInvalidArguments("toStrictEqual() requires 1 argument", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("toStrictEqual() requires 1 argument", .{});
         }
 
         incrementExpectCallCounter();
 
         const expected = arguments[0];
-        const value: JSValue = this.getValue(globalThis, thisValue, "toStrictEqual", "<green>expected<r>") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toStrictEqual", "<green>expected<r>");
 
         const not = this.flags.not;
         var pass = value.jestStrictDeepEquals(expected, globalThis);
@@ -1741,25 +1639,22 @@ pub const Expect = struct {
 
         if (not) {
             const signature = comptime getSignature("toStrictEqual", "<green>expected<r>", true);
-            this.throw(globalThis, signature, "\n\n{any}\n", .{diff_formatter});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n{any}\n", .{diff_formatter});
         }
 
         const signature = comptime getSignature("toStrictEqual", "<green>expected<r>", false);
-        this.throw(globalThis, signature, "\n\n{any}\n", .{diff_formatter});
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n{any}\n", .{diff_formatter});
     }
 
-    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();
-        const _arguments = callFrame.arguments(2);
+        const _arguments = callFrame.arguments_old(2);
         const arguments: []const JSValue = _arguments.ptr[0.._arguments.len];
 
         if (arguments.len < 1) {
-            globalThis.throwInvalidArguments("toHaveProperty() requires at least 1 argument", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("toHaveProperty() requires at least 1 argument", .{});
         }
 
         incrementExpectCallCounter();
@@ -1769,11 +1664,10 @@ pub const Expect = struct {
         const expected_property: ?JSValue = if (arguments.len > 1) arguments[1] else null;
         if (expected_property) |ev| ev.ensureStillAlive();
 
-        const value: JSValue = this.getValue(globalThis, thisValue, "toHaveProperty", "<green>path<r><d>, <r><green>value<r>") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toHaveProperty", "<green>path<r><d>, <r><green>value<r>");
 
         if (!expected_property_path.isString() and !expected_property_path.isIterable(globalThis)) {
-            globalThis.throw("Expected path must be a string or an array", .{});
-            return .zero;
+            return globalThis.throw("Expected path must be a string or an array", .{});
         }
 
         const not = this.flags.not;
@@ -1785,11 +1679,11 @@ 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) {
-            pass = received_property.jestDeepEquals(expected_property.?, globalThis);
+            pass = try received_property.jestDeepEquals(expected_property.?, globalThis);
         }
 
         if (not) pass = !pass;
@@ -1800,26 +1694,24 @@ 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()) {
-                    this.throw(globalThis, signature, "\n\nExpected path: <green>{any}<r>\n\nExpected value: not <green>{any}<r>\n", .{
+                if (received_property != .zero) {
+                    return 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),
                     });
-                    return .zero;
                 }
             }
 
             const signature = comptime getSignature("toHaveProperty", "<green>path<r>", true);
-            this.throw(globalThis, signature, "\n\nExpected path: not <green>{any}<r>\n\nReceived value: <red>{any}<r>\n", .{
+            return this.throw(globalThis, signature, "\n\nExpected path: not <green>{any}<r>\n\nReceived value: <red>{any}<r>\n", .{
                 expected_property_path.toFmt(&formatter),
                 received_property.toFmt(&formatter),
             });
-            return .zero;
         }
 
         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,
@@ -1827,30 +1719,27 @@ pub const Expect = struct {
                     .globalThis = globalThis,
                 };
 
-                this.throw(globalThis, signature, "\n\n{any}\n", .{diff_format});
-                return .zero;
+                return this.throw(globalThis, signature, "\n\n{any}\n", .{diff_format});
             }
 
             const fmt = "\n\nExpected path: <green>{any}<r>\n\nExpected value: <green>{any}<r>\n\n" ++
                 "Unable to find property\n";
-            this.throw(globalThis, signature, fmt, .{
+            return this.throw(globalThis, signature, fmt, .{
                 expected_property_path.toFmt(&formatter),
                 expected_property.?.toFmt(&formatter),
             });
-            return .zero;
         }
 
         const signature = comptime getSignature("toHaveProperty", "<green>path<r>", false);
-        this.throw(globalThis, signature, "\n\nExpected path: <green>{any}<r>\n\nUnable to find property\n", .{expected_property_path.toFmt(&formatter)});
-        return .zero;
+        return this.throw(globalThis, signature, "\n\nExpected path: <green>{any}<r>\n\nUnable to find property\n", .{expected_property_path.toFmt(&formatter)});
     }
 
-    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();
 
-        const value: JSValue = this.getValue(globalThis, thisValue, "toBeEven", "") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toBeEven", "");
 
         incrementExpectCallCounter();
 
@@ -1889,26 +1778,23 @@ pub const Expect = struct {
         if (not) {
             const received_line = "Received: <red>{any}<r>\n";
             const signature = comptime getSignature("toBeEven", "", true);
-            this.throw(globalThis, signature, "\n\n" ++ received_line, .{value_fmt});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ received_line, .{value_fmt});
         }
 
         const received_line = "Received: <red>{any}<r>\n";
         const signature = comptime getSignature("toBeEven", "", false);
-        this.throw(globalThis, signature, "\n\n" ++ received_line, .{value_fmt});
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ received_line, .{value_fmt});
     }
 
-    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();
-        const _arguments = callFrame.arguments(1);
+        const _arguments = callFrame.arguments_old(1);
         const arguments: []const JSValue = _arguments.ptr[0.._arguments.len];
 
         if (arguments.len < 1) {
-            globalThis.throwInvalidArguments("toBeGreaterThan() requires 1 argument", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("toBeGreaterThan() requires 1 argument", .{});
         }
 
         incrementExpectCallCounter();
@@ -1916,11 +1802,10 @@ pub const Expect = struct {
         const other_value = arguments[0];
         other_value.ensureStillAlive();
 
-        const value: JSValue = this.getValue(globalThis, thisValue, "toBeGreaterThan", "<green>expected<r>") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toBeGreaterThan", "<green>expected<r>");
 
         if ((!value.isNumber() and !value.isBigInt()) or (!other_value.isNumber() and !other_value.isBigInt())) {
-            globalThis.throw("Expected and actual values must be numbers or bigints", .{});
-            return .zero;
+            return globalThis.throw("Expected and actual values must be numbers or bigints", .{});
         }
 
         const not = this.flags.not;
@@ -1951,27 +1836,24 @@ pub const Expect = struct {
             const expected_line = "Expected: not \\> <green>{any}<r>\n";
             const received_line = "Received: <red>{any}<r>\n";
             const signature = comptime getSignature("toBeGreaterThan", "<green>expected<r>", true);
-            this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
         }
 
         const expected_line = "Expected: \\> <green>{any}<r>\n";
         const received_line = "Received: <red>{any}<r>\n";
         const signature = comptime getSignature("toBeGreaterThan", "<green>expected<r>", false);
-        this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
     }
 
-    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();
-        const _arguments = callFrame.arguments(1);
+        const _arguments = callFrame.arguments_old(1);
         const arguments: []const JSValue = _arguments.ptr[0.._arguments.len];
 
         if (arguments.len < 1) {
-            globalThis.throwInvalidArguments("toBeGreaterThanOrEqual() requires 1 argument", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("toBeGreaterThanOrEqual() requires 1 argument", .{});
         }
 
         incrementExpectCallCounter();
@@ -1979,11 +1861,10 @@ pub const Expect = struct {
         const other_value = arguments[0];
         other_value.ensureStillAlive();
 
-        const value: JSValue = this.getValue(globalThis, thisValue, "toBeGreaterThanOrEqual", "<green>expected<r>") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toBeGreaterThanOrEqual", "<green>expected<r>");
 
         if ((!value.isNumber() and !value.isBigInt()) or (!other_value.isNumber() and !other_value.isBigInt())) {
-            globalThis.throw("Expected and actual values must be numbers or bigints", .{});
-            return .zero;
+            return globalThis.throw("Expected and actual values must be numbers or bigints", .{});
         }
 
         const not = this.flags.not;
@@ -2014,27 +1895,24 @@ pub const Expect = struct {
             const expected_line = "Expected: not \\>= <green>{any}<r>\n";
             const received_line = "Received: <red>{any}<r>\n";
             const signature = comptime getSignature("toBeGreaterThanOrEqual", "<green>expected<r>", true);
-            this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
         }
 
         const expected_line = "Expected: \\>= <green>{any}<r>\n";
         const received_line = "Received: <red>{any}<r>\n";
         const signature = comptime getSignature("toBeGreaterThanOrEqual", "<green>expected<r>", false);
-        this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
     }
 
-    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();
-        const _arguments = callFrame.arguments(1);
+        const _arguments = callFrame.arguments_old(1);
         const arguments: []const JSValue = _arguments.ptr[0.._arguments.len];
 
         if (arguments.len < 1) {
-            globalThis.throwInvalidArguments("toBeLessThan() requires 1 argument", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("toBeLessThan() requires 1 argument", .{});
         }
 
         incrementExpectCallCounter();
@@ -2042,11 +1920,10 @@ pub const Expect = struct {
         const other_value = arguments[0];
         other_value.ensureStillAlive();
 
-        const value: JSValue = this.getValue(globalThis, thisValue, "toBeLessThan", "<green>expected<r>") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toBeLessThan", "<green>expected<r>");
 
         if ((!value.isNumber() and !value.isBigInt()) or (!other_value.isNumber() and !other_value.isBigInt())) {
-            globalThis.throw("Expected and actual values must be numbers or bigints", .{});
-            return .zero;
+            return globalThis.throw("Expected and actual values must be numbers or bigints", .{});
         }
 
         const not = this.flags.not;
@@ -2077,27 +1954,24 @@ pub const Expect = struct {
             const expected_line = "Expected: not \\< <green>{any}<r>\n";
             const received_line = "Received: <red>{any}<r>\n";
             const signature = comptime getSignature("toBeLessThan", "<green>expected<r>", true);
-            this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
         }
 
         const expected_line = "Expected: \\< <green>{any}<r>\n";
         const received_line = "Received: <red>{any}<r>\n";
         const signature = comptime getSignature("toBeLessThan", "<green>expected<r>", false);
-        this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
     }
 
-    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();
-        const _arguments = callFrame.arguments(1);
+        const _arguments = callFrame.arguments_old(1);
         const arguments: []const JSValue = _arguments.ptr[0.._arguments.len];
 
         if (arguments.len < 1) {
-            globalThis.throwInvalidArguments("toBeLessThanOrEqual() requires 1 argument", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("toBeLessThanOrEqual() requires 1 argument", .{});
         }
 
         incrementExpectCallCounter();
@@ -2105,11 +1979,10 @@ pub const Expect = struct {
         const other_value = arguments[0];
         other_value.ensureStillAlive();
 
-        const value: JSValue = this.getValue(globalThis, thisValue, "toBeLessThanOrEqual", "<green>expected<r>") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toBeLessThanOrEqual", "<green>expected<r>");
 
         if ((!value.isNumber() and !value.isBigInt()) or (!other_value.isNumber() and !other_value.isBigInt())) {
-            globalThis.throw("Expected and actual values must be numbers or bigints", .{});
-            return .zero;
+            return globalThis.throw("Expected and actual values must be numbers or bigints", .{});
         }
 
         const not = this.flags.not;
@@ -2140,50 +2013,44 @@ pub const Expect = struct {
             const expected_line = "Expected: not \\<= <green>{any}<r>\n";
             const received_line = "Received: <red>{any}<r>\n";
             const signature = comptime getSignature("toBeLessThanOrEqual", "<green>expected<r>", true);
-            this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
         }
 
         const expected_line = "Expected: \\<= <green>{any}<r>\n";
         const received_line = "Received: <red>{any}<r>\n";
         const signature = comptime getSignature("toBeLessThanOrEqual", "<green>expected<r>", false);
-        this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
     }
 
-    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();
-        const thisArguments = callFrame.arguments(2);
+        const thisArguments = callFrame.arguments_old(2);
         const arguments = thisArguments.ptr[0..thisArguments.len];
 
         if (arguments.len < 1) {
-            globalThis.throwInvalidArguments("toBeCloseTo() requires at least 1 argument. Expected value must be a number", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("toBeCloseTo() requires at least 1 argument. Expected value must be a number", .{});
         }
 
         const expected_ = arguments[0];
         if (!expected_.isNumber()) {
-            globalThis.throwInvalidArgumentType("toBeCloseTo", "expected", "number");
-            return .zero;
+            return globalThis.throwInvalidArgumentType("toBeCloseTo", "expected", "number");
         }
 
         var precision: f64 = 2.0;
         if (arguments.len > 1) {
             const precision_ = arguments[1];
             if (!precision_.isNumber()) {
-                globalThis.throwInvalidArgumentType("toBeCloseTo", "precision", "number");
-                return .zero;
+                return globalThis.throwInvalidArgumentType("toBeCloseTo", "precision", "number");
             }
 
             precision = precision_.asNumber();
         }
 
-        const received_: JSValue = this.getValue(globalThis, thisValue, "toBeCloseTo", "<green>expected<r>, precision") orelse return .zero;
+        const received_: JSValue = try this.getValue(globalThis, thisValue, "toBeCloseTo", "<green>expected<r>, precision");
         if (!received_.isNumber()) {
-            globalThis.throwInvalidArgumentType("expect", "received", "number");
-            return .zero;
+            return globalThis.throwInvalidArgumentType("expect", "received", "number");
         }
 
         var expected = expected_.asNumber();
@@ -2225,21 +2092,19 @@ pub const Expect = struct {
 
         if (not) {
             const signature = comptime getSignature("toBeCloseTo", "<green>expected<r>, precision", true);
-            this.throw(globalThis, signature, suffix_fmt, .{ expected_fmt, received_fmt, precision, expected_diff, actual_diff });
-            return .zero;
+            return this.throw(globalThis, signature, suffix_fmt, .{ expected_fmt, received_fmt, precision, expected_diff, actual_diff });
         }
 
         const signature = comptime getSignature("toBeCloseTo", "<green>expected<r>, precision", false);
-        this.throw(globalThis, signature, suffix_fmt, .{ expected_fmt, received_fmt, precision, expected_diff, actual_diff });
-        return .zero;
+        return this.throw(globalThis, signature, suffix_fmt, .{ expected_fmt, received_fmt, precision, expected_diff, actual_diff });
     }
 
-    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();
 
-        const value: JSValue = this.getValue(globalThis, thisValue, "toBeOdd", "") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toBeOdd", "");
 
         incrementExpectCallCounter();
 
@@ -2276,32 +2141,33 @@ pub const Expect = struct {
         if (not) {
             const received_line = "Received: <red>{any}<r>\n";
             const signature = comptime getSignature("toBeOdd", "", true);
-            this.throw(globalThis, signature, "\n\n" ++ received_line, .{value_fmt});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ received_line, .{value_fmt});
         }
 
         const received_line = "Received: <red>{any}<r>\n";
         const signature = comptime getSignature("toBeOdd", "", false);
-        this.throw(globalThis, signature, "\n\n" ++ received_line, .{value_fmt});
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ received_line, .{value_fmt});
     }
 
-    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 vm = globalThis.bunVM();
         const thisValue = callFrame.this();
-        const _arguments = callFrame.arguments(1);
-        const arguments: []const JSValue = _arguments.ptr[0.._arguments.len];
+        const arguments = callFrame.argumentsAsArray(1);
 
         incrementExpectCallCounter();
 
-        const expected_value: JSValue = if (arguments.len > 0) brk: {
+        const expected_value: JSValue = brk: {
+            if (callFrame.argumentsCount() == 0) {
+                break :brk .zero;
+            }
             const value = arguments[0];
-            if (value.isEmptyOrUndefinedOrNull() or !value.isObject() and !value.isString()) {
+            if (value.isUndefinedOrNull() or !value.isObject() and !value.isString()) {
                 var fmt = JSC.ConsoleObject.Formatter{ .globalThis = globalThis, .quote_strings = true };
-                globalThis.throw("Expected value must be string or Error: {any}", .{value.toFmt(&fmt)});
-                return .zero;
-            } else if (value.isObject()) {
+                return globalThis.throw("Expected value must be string or Error: {any}", .{value.toFmt(&fmt)});
+            }
+            if (value.isObject()) {
                 if (ExpectAny.fromJSDirect(value)) |_| {
                     if (ExpectAny.constructorValueGetCached(value)) |innerConstructorValue| {
                         break :brk innerConstructorValue;
@@ -2309,24 +2175,23 @@ pub const Expect = struct {
                 }
             }
             break :brk value;
-        } else .zero;
+        };
         expected_value.ensureStillAlive();
 
-        const value: JSValue = this.getValue(globalThis, thisValue, "toThrow", "<green>expected<r>") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toThrow", "<green>expected<r>");
 
         const not = this.flags.not;
 
+        var return_value_from_function: JSValue = .zero;
         const result_: ?JSValue = brk: {
             if (!value.jsType().isFunction()) {
                 if (this.flags.promise != .none) {
                     break :brk value;
                 }
 
-                globalThis.throw("Expected value must be a function", .{});
-                return .zero;
+                return globalThis.throw("Expected value must be a function", .{});
             }
 
-            var vm = globalThis.bunVM();
             var return_value: JSValue = .zero;
 
             // Drain existing unhandled rejections
@@ -2336,8 +2201,7 @@ pub const Expect = struct {
             const prev_unhandled_pending_rejection_to_capture = vm.unhandled_pending_rejection_to_capture;
             vm.unhandled_pending_rejection_to_capture = &return_value;
             vm.onUnhandledRejection = &VirtualMachine.onQuietUnhandledRejectionHandlerCaptureValue;
-            const return_value_from_function: JSValue = value.call(globalThis, .undefined, &.{}) catch |err|
-                globalThis.takeException(err);
+            return_value_from_function = value.call(globalThis, .undefined, &.{}) catch |err| globalThis.takeException(err);
             vm.unhandled_pending_rejection_to_capture = prev_unhandled_pending_rejection_to_capture;
 
             vm.global.handleRejectedPromises();
@@ -2382,23 +2246,21 @@ 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, .{
+                    return globalThis.throwPretty(fmt, .{
                         name.toFmt(&formatter),
                         message.toFmt(&formatter),
                     });
-                    return .zero;
                 }
 
                 // non error thrown
                 const fmt = signature_no_args ++ "\n\nThrown value: <red>{any}<r>\n";
-                globalThis.throwPretty(fmt, .{result.toFmt(&formatter)});
-                return .zero;
+                return globalThis.throwPretty(fmt, .{result.toFmt(&formatter)});
             }
 
             if (expected_value.isString()) {
@@ -2413,18 +2275,17 @@ pub const Expect = struct {
                 // TODO: remove this allocation
                 // partial match
                 {
-                    const expected_slice = expected_value.toSliceOrNull(globalThis) orelse return .zero;
+                    const expected_slice = try expected_value.toSliceOrNull(globalThis);
                     defer expected_slice.deinit();
-                    const received_slice = received_message.toSliceOrNull(globalThis) orelse return .zero;
+                    const received_slice = try received_message.toSliceOrNull(globalThis);
                     defer received_slice.deinit();
                     if (!strings.contains(received_slice.slice(), expected_slice.slice())) return .undefined;
                 }
 
-                this.throw(globalThis, signature, "\n\nExpected substring: not <green>{any}<r>\nReceived message: <red>{any}<r>\n", .{
+                return this.throw(globalThis, signature, "\n\nExpected substring: not <green>{any}<r>\nReceived message: <red>{any}<r>\n", .{
                     expected_value.toFmt(&formatter),
                     received_message.toFmt(&formatter),
                 });
-                return .zero;
             }
 
             if (expected_value.isRegExp()) {
@@ -2437,16 +2298,15 @@ pub const Expect = struct {
 
                 if (globalThis.hasException()) return .zero;
                 // TODO: REMOVE THIS GETTER! Expose a binding to call .test on the RegExp object directly.
-                if (expected_value.get(globalThis, "test")) |test_fn| {
+                if (try expected_value.get(globalThis, "test")) |test_fn| {
                     const matches = test_fn.call(globalThis, expected_value, &.{received_message}) catch |err| globalThis.takeException(err);
-                    if (!matches.toBooleanSlow(globalThis)) return .undefined;
+                    if (!matches.toBoolean()) return .undefined;
                 }
 
-                this.throw(globalThis, signature, "\n\nExpected pattern: not <green>{any}<r>\nReceived message: <red>{any}<r>\n", .{
+                return this.throw(globalThis, signature, "\n\nExpected pattern: not <green>{any}<r>\nReceived message: <red>{any}<r>\n", .{
                     expected_value.toFmt(&formatter),
                     received_message.toFmt(&formatter),
                 });
-                return .zero;
             }
 
             if (expected_value.fastGet(globalThis, .message)) |expected_message| {
@@ -2461,8 +2321,7 @@ pub const Expect = struct {
                 // no partial match for this case
                 if (!expected_message.isSameValue(received_message, globalThis)) return .undefined;
 
-                this.throw(globalThis, signature, "\n\nExpected message: not <green>{any}<r>\n", .{expected_message.toFmt(&formatter)});
-                return .zero;
+                return this.throw(globalThis, signature, "\n\nExpected message: not <green>{any}<r>\n", .{expected_message.toFmt(&formatter)});
             }
 
             if (!result.isInstanceOf(globalThis, expected_value)) return .undefined;
@@ -2470,12 +2329,11 @@ pub const Expect = struct {
             var expected_class = ZigString.Empty;
             expected_value.getClassName(globalThis, &expected_class);
             const received_message = result.fastGet(globalThis, .message) orelse .undefined;
-            this.throw(globalThis, signature, "\n\nExpected constructor: not <green>{s}<r>\n\nReceived message: <red>{any}<r>\n", .{ expected_class, received_message.toFmt(&formatter) });
-            return .zero;
+            return this.throw(globalThis, signature, "\n\nExpected constructor: not <green>{s}<r>\n\nReceived message: <red>{any}<r>\n", .{ expected_class, received_message.toFmt(&formatter) });
         }
 
         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
@@ -2493,7 +2351,7 @@ pub const Expect = struct {
                 if (_received_message) |received_message| {
                     // TODO: remove this allocation
                     // partial match
-                    const expected_slice = expected_value.toSliceOrNull(globalThis) orelse return .zero;
+                    const expected_slice = try expected_value.toSliceOrNull(globalThis);
                     defer expected_slice.deinit();
                     const received_slice = received_message.toSlice(globalThis, globalThis.allocator());
                     defer received_slice.deinit();
@@ -2508,23 +2366,20 @@ pub const Expect = struct {
                 if (_received_message) |received_message| {
                     const expected_value_fmt = expected_value.toFmt(&formatter);
                     const received_message_fmt = received_message.toFmt(&formatter);
-                    this.throw(globalThis, signature, "\n\n" ++ "Expected substring: <green>{any}<r>\nReceived message: <red>{any}<r>\n", .{ expected_value_fmt, received_message_fmt });
-                    return .zero;
+                    return this.throw(globalThis, signature, "\n\n" ++ "Expected substring: <green>{any}<r>\nReceived message: <red>{any}<r>\n", .{ expected_value_fmt, received_message_fmt });
                 }
 
                 const expected_fmt = expected_value.toFmt(&formatter);
                 const received_fmt = result.toFmt(&formatter);
-                this.throw(globalThis, signature, "\n\n" ++ "Expected substring: <green>{any}<r>\nReceived value: <red>{any}<r>", .{ expected_fmt, received_fmt });
-
-                return .zero;
+                return this.throw(globalThis, signature, "\n\n" ++ "Expected substring: <green>{any}<r>\nReceived value: <red>{any}<r>", .{ expected_fmt, received_fmt });
             }
 
             if (expected_value.isRegExp()) {
                 if (_received_message) |received_message| {
                     // TODO: REMOVE THIS GETTER! Expose a binding to call .test on the RegExp object directly.
-                    if (expected_value.get(globalThis, "test")) |test_fn| {
+                    if (try expected_value.get(globalThis, "test")) |test_fn| {
                         const matches = test_fn.call(globalThis, expected_value, &.{received_message}) catch |err| globalThis.takeException(err);
-                        if (matches.toBooleanSlow(globalThis)) return .undefined;
+                        if (matches.toBoolean()) return .undefined;
                     }
                 }
 
@@ -2536,16 +2391,13 @@ pub const Expect = struct {
                     const received_message_fmt = received_message.toFmt(&formatter);
                     const signature = comptime getSignature("toThrow", "<green>expected<r>", false);
 
-                    this.throw(globalThis, signature, "\n\n" ++ "Expected pattern: <green>{any}<r>\nReceived message: <red>{any}<r>\n", .{ expected_value_fmt, received_message_fmt });
-
-                    return .zero;
+                    return this.throw(globalThis, signature, "\n\n" ++ "Expected pattern: <green>{any}<r>\nReceived message: <red>{any}<r>\n", .{ expected_value_fmt, received_message_fmt });
                 }
 
                 const expected_fmt = expected_value.toFmt(&formatter);
                 const received_fmt = result.toFmt(&formatter);
                 const signature = comptime getSignature("toThrow", "<green>expected<r>", false);
-                this.throw(globalThis, signature, "\n\n" ++ "Expected pattern: <green>{any}<r>\nReceived value: <red>{any}<r>", .{ expected_fmt, received_fmt });
-                return .zero;
+                return this.throw(globalThis, signature, "\n\n" ++ "Expected pattern: <green>{any}<r>\nReceived value: <red>{any}<r>", .{ expected_fmt, received_fmt });
             }
 
             if (Expect.isAsymmetricMatcher(expected_value)) {
@@ -2563,8 +2415,7 @@ pub const Expect = struct {
                 var formatter = JSC.ConsoleObject.Formatter{ .globalThis = globalThis, .quote_strings = true };
                 const received_fmt = result.toFmt(&formatter);
                 const expected_fmt = expected_value.toFmt(&formatter);
-                this.throw(globalThis, signature, "\n\nExpected value: <green>{any}<r>\nReceived value: <red>{any}<r>\n", .{ expected_fmt, received_fmt });
-                return .zero;
+                return this.throw(globalThis, signature, "\n\nExpected value: <green>{any}<r>\nReceived value: <red>{any}<r>\n", .{ expected_fmt, received_fmt });
             }
 
             // If it's not an object, we are going to crash here.
@@ -2583,14 +2434,12 @@ pub const Expect = struct {
                 if (_received_message) |received_message| {
                     const expected_fmt = expected_message.toFmt(&formatter);
                     const received_fmt = received_message.toFmt(&formatter);
-                    this.throw(globalThis, signature, "\n\nExpected message: <green>{any}<r>\nReceived message: <red>{any}<r>\n", .{ expected_fmt, received_fmt });
-                    return .zero;
+                    return this.throw(globalThis, signature, "\n\nExpected message: <green>{any}<r>\nReceived message: <red>{any}<r>\n", .{ expected_fmt, received_fmt });
                 }
 
                 const expected_fmt = expected_message.toFmt(&formatter);
                 const received_fmt = result.toFmt(&formatter);
-                this.throw(globalThis, signature, "\n\nExpected message: <green>{any}<r>\nReceived value: <red>{any}<r>\n", .{ expected_fmt, received_fmt });
-                return .zero;
+                return this.throw(globalThis, signature, "\n\nExpected message: <green>{any}<r>\nReceived value: <red>{any}<r>\n", .{ expected_fmt, received_fmt });
             }
 
             if (result.isInstanceOf(globalThis, expected_value)) return .undefined;
@@ -2608,65 +2457,189 @@ pub const Expect = struct {
                 const message_fmt = fmt ++ "Received message: <red>{any}<r>\n";
                 const received_message_fmt = received_message.toFmt(&formatter);
 
-                globalThis.throwPretty(message_fmt, .{
+                return globalThis.throwPretty(message_fmt, .{
                     expected_class,
                     received_class,
                     received_message_fmt,
                 });
-                return .zero;
             }
 
             const received_fmt = result.toFmt(&formatter);
             const value_fmt = fmt ++ "Received value: <red>{any}<r>\n";
 
-            globalThis.throwPretty(value_fmt, .{
+            return globalThis.throwPretty(value_fmt, .{
                 expected_class,
                 received_class,
                 received_fmt,
             });
-            return .zero;
         }
 
         // did not throw
+        const result = return_value_from_function;
         var formatter = JSC.ConsoleObject.Formatter{ .globalThis = globalThis, .quote_strings = true };
-        const received_line = "Received function did not throw\n";
+        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, .{});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ received_line, .{result.toFmt(&formatter)});
         }
 
         const signature = comptime getSignature("toThrow", "<green>expected<r>", false);
 
         if (expected_value.isString()) {
             const expected_fmt = "\n\nExpected substring: <green>{any}<r>\n\n" ++ received_line;
-            this.throw(globalThis, signature, expected_fmt, .{expected_value.toFmt(&formatter)});
-            return .zero;
+            return this.throw(globalThis, signature, expected_fmt, .{ expected_value.toFmt(&formatter), result.toFmt(&formatter) });
         }
 
         if (expected_value.isRegExp()) {
             const expected_fmt = "\n\nExpected pattern: <green>{any}<r>\n\n" ++ received_line;
-            this.throw(globalThis, signature, expected_fmt, .{expected_value.toFmt(&formatter)});
-            return .zero;
+            return this.throw(globalThis, signature, expected_fmt, .{ expected_value.toFmt(&formatter), result.toFmt(&formatter) });
         }
 
         if (expected_value.fastGet(globalThis, .message)) |expected_message| {
             const expected_fmt = "\n\nExpected message: <green>{any}<r>\n\n" ++ received_line;
-            this.throw(globalThis, signature, expected_fmt, .{expected_message.toFmt(&formatter)});
-            return .zero;
+            return this.throw(globalThis, signature, expected_fmt, .{ expected_message.toFmt(&formatter), result.toFmt(&formatter) });
         }
 
         const expected_fmt = "\n\nExpected constructor: <green>{s}<r>\n\n" ++ received_line;
         var expected_class = ZigString.Empty;
         expected_value.getClassName(globalThis, &expected_class);
-        this.throw(globalThis, signature, expected_fmt, .{expected_class});
-        return .zero;
+        return this.throw(globalThis, signature, expected_fmt, .{ expected_class, result.toFmt(&formatter) });
     }
-    pub fn toMatchSnapshot(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toMatchInlineSnapshot(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
+        // in jest, a failing inline snapshot does not block the rest from running
+        // not sure why - empty snapshots will autofill and with the `-u` flag none will fail
+
         defer this.postMatch(globalThis);
         const thisValue = callFrame.this();
-        const _arguments = callFrame.arguments(2);
+        const _arguments = callFrame.arguments_old(2);
+        const arguments: []const JSValue = _arguments.ptr[0.._arguments.len];
+
+        incrementExpectCallCounter();
+
+        const not = this.flags.not;
+        if (not) {
+            const signature = comptime getSignature("toMatchInlineSnapshot", "", true);
+            return this.throw(globalThis, signature, "\n\n<b>Matcher error<r>: Snapshot matchers cannot be used with <b>not<r>\n", .{});
+        }
+
+        var has_expected = false;
+        var expected_string: ZigString = ZigString.Empty;
+        var property_matchers: ?JSValue = null;
+        switch (arguments.len) {
+            0 => {},
+            1 => {
+                if (arguments[0].isString()) {
+                    has_expected = true;
+                    arguments[0].toZigString(&expected_string, globalThis);
+                } else if (arguments[0].isObject()) {
+                    property_matchers = arguments[0];
+                } else {
+                    return this.throw(globalThis, "", "\n\nMatcher error: Expected first argument to be a string or object\n", .{});
+                }
+            },
+            else => {
+                if (!arguments[0].isObject()) {
+                    const signature = comptime getSignature("toMatchInlineSnapshot", "<green>properties<r><d>, <r>hint", false);
+                    return this.throw(globalThis, signature, "\n\nMatcher error: Expected <green>properties<r> must be an object\n", .{});
+                }
+
+                property_matchers = arguments[0];
+
+                if (arguments[1].isString()) {
+                    has_expected = true;
+                    arguments[1].toZigString(&expected_string, globalThis);
+                }
+            },
+        }
+
+        var expected = expected_string.toSlice(default_allocator);
+        defer expected.deinit();
+
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toMatchInlineSnapshot", "<green>properties<r><d>, <r>hint");
+
+        if (!value.isObject() and property_matchers != null) {
+            const signature = comptime getSignature("toMatchInlineSnapshot", "<green>properties<r><d>, <r>hint", false);
+            return this.throw(globalThis, signature, "\n\n<b>Matcher error: <red>received<r> values must be an object when the matcher has <green>properties<r>\n", .{});
+        }
+
+        if (property_matchers) |_prop_matchers| {
+            const prop_matchers = _prop_matchers;
+
+            if (!value.jestDeepMatch(prop_matchers, globalThis, true)) {
+                // TODO: print diff with properties from propertyMatchers
+                const signature = comptime getSignature("toMatchInlineSnapshot", "<green>propertyMatchers<r>", false);
+                const fmt = signature ++ "\n\nExpected <green>propertyMatchers<r> to match properties from received object" ++
+                    "\n\nReceived: {any}\n";
+
+                var formatter = JSC.ConsoleObject.Formatter{ .globalThis = globalThis };
+                return globalThis.throwPretty(fmt, .{value.toFmt(&formatter)});
+            }
+        }
+
+        const result: ?[]const u8 = if (has_expected) expected.byteSlice() else null;
+
+        const update = Jest.runner.?.snapshots.update_snapshots;
+        var needs_write = false;
+
+        var pretty_value: MutableString = MutableString.init(default_allocator, 0) catch unreachable;
+        value.jestSnapshotPrettyFormat(&pretty_value, globalThis) catch {
+            var formatter = JSC.ConsoleObject.Formatter{ .globalThis = globalThis };
+            return globalThis.throw("Failed to pretty format value: {s}", .{value.toFmt(&formatter)});
+        };
+        defer pretty_value.deinit();
+
+        if (result) |saved_value| {
+            if (strings.eqlLong(pretty_value.slice(), saved_value, true)) {
+                Jest.runner.?.snapshots.passed += 1;
+                return .undefined;
+            } else if (update) {
+                needs_write = true;
+            } else {
+                Jest.runner.?.snapshots.failed += 1;
+                const signature = comptime getSignature("toMatchInlineSnapshot", "<green>expected<r>", false);
+                const fmt = signature ++ "\n\n{any}\n";
+                const diff_format = DiffFormatter{
+                    .received_string = pretty_value.slice(),
+                    .expected_string = saved_value,
+                    .globalThis = globalThis,
+                };
+
+                return globalThis.throwPretty(fmt, .{diff_format});
+            }
+        } else {
+            needs_write = true;
+        }
+
+        if (needs_write) {
+            if (this.testScope() == null) {
+                const signature = comptime getSignature("toMatchSnapshot", "", true);
+                return this.throw(globalThis, signature, "\n\n<b>Matcher error<r>: Snapshot matchers cannot be used outside of a test\n", .{});
+            }
+
+            // 1. find the src loc of the snapshot
+            const srcloc = callFrame.getCallerSrcLoc(globalThis);
+
+            if (srcloc.source_file_id != this.testScope().?.describe.file_id) {
+                const signature = comptime getSignature("toMatchSnapshot", "", true);
+                return this.throw(globalThis, signature, "\n\n<b>Matcher error<r>: Inline snapshot matchers must be called from the same file as the test\n", .{});
+            }
+
+            // 2. save to write later
+            try Jest.runner.?.snapshots.addInlineSnapshotToWrite(srcloc.source_file_id, .{
+                .line = srcloc.line,
+                .col = srcloc.column,
+                .value = pretty_value.toOwnedSlice(),
+                .has_matchers = property_matchers != null,
+            });
+        }
+
+        return .undefined;
+    }
+    pub fn toMatchSnapshot(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
+        defer this.postMatch(globalThis);
+        const thisValue = callFrame.this();
+        const _arguments = callFrame.arguments_old(2);
         const arguments: []const JSValue = _arguments.ptr[0.._arguments.len];
 
         incrementExpectCallCounter();
@@ -2674,13 +2647,12 @@ pub const Expect = struct {
         const not = this.flags.not;
         if (not) {
             const signature = comptime getSignature("toMatchSnapshot", "", true);
-            this.throw(globalThis, signature, "\n\n<b>Matcher error<r>: Snapshot matchers cannot be used with <b>not<r>\n", .{});
+            return this.throw(globalThis, signature, "\n\n<b>Matcher error<r>: Snapshot matchers cannot be used with <b>not<r>\n", .{});
         }
 
         if (this.testScope() == null) {
             const signature = comptime getSignature("toMatchSnapshot", "", true);
-            this.throw(globalThis, signature, "\n\n<b>Matcher error<r>: Snapshot matchers cannot be used outside of a test\n", .{});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n<b>Matcher error<r>: Snapshot matchers cannot be used outside of a test\n", .{});
         }
 
         var hint_string: ZigString = ZigString.Empty;
@@ -2692,19 +2664,22 @@ pub const Expect = struct {
                     arguments[0].toZigString(&hint_string, globalThis);
                 } else if (arguments[0].isObject()) {
                     property_matchers = arguments[0];
+                } else {
+                    return this.throw(globalThis, "", "\n\nMatcher error: Expected first argument to be a string or object\n", .{});
                 }
             },
             else => {
                 if (!arguments[0].isObject()) {
                     const signature = comptime getSignature("toMatchSnapshot", "<green>properties<r><d>, <r>hint", false);
-                    this.throw(globalThis, signature, "\n\nMatcher error: Expected <green>properties<r> must be an object\n", .{});
-                    return .zero;
+                    return this.throw(globalThis, signature, "\n\nMatcher error: Expected <green>properties<r> must be an object\n", .{});
                 }
 
                 property_matchers = arguments[0];
 
                 if (arguments[1].isString()) {
                     arguments[1].toZigString(&hint_string, globalThis);
+                } else {
+                    return this.throw(globalThis, "", "\n\nMatcher error: Expected second argument to be a string\n", .{});
                 }
             },
         }
@@ -2712,12 +2687,11 @@ pub const Expect = struct {
         var hint = hint_string.toSlice(default_allocator);
         defer hint.deinit();
 
-        const value: JSValue = this.getValue(globalThis, thisValue, "toMatchSnapshot", "<green>properties<r><d>, <r>hint") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toMatchSnapshot", "<green>properties<r><d>, <r>hint");
 
         if (!value.isObject() and property_matchers != null) {
             const signature = comptime getSignature("toMatchSnapshot", "<green>properties<r><d>, <r>hint", false);
-            this.throw(globalThis, signature, "\n\n<b>Matcher error: <red>received<r> values must be an object when the matcher has <green>properties<r>\n", .{});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n<b>Matcher error: <red>received<r> values must be an object when the matcher has <green>properties<r>\n", .{});
         }
 
         if (property_matchers) |_prop_matchers| {
@@ -2730,34 +2704,31 @@ pub const Expect = struct {
                     "\n\nReceived: {any}\n";
 
                 var formatter = JSC.ConsoleObject.Formatter{ .globalThis = globalThis };
-                globalThis.throwPretty(fmt, .{value.toFmt(&formatter)});
-                return .zero;
+                return globalThis.throwPretty(fmt, .{value.toFmt(&formatter)});
             }
         }
 
-        const result = Jest.runner.?.snapshots.getOrPut(this, value, hint.slice(), globalThis) catch |err| {
+        var pretty_value: MutableString = MutableString.init(default_allocator, 0) catch unreachable;
+        value.jestSnapshotPrettyFormat(&pretty_value, globalThis) catch {
+            var formatter = JSC.ConsoleObject.Formatter{ .globalThis = globalThis };
+            return globalThis.throw("Failed to pretty format value: {s}", .{value.toFmt(&formatter)});
+        };
+        defer pretty_value.deinit();
+
+        const existing_value = Jest.runner.?.snapshots.getOrPut(this, pretty_value.slice(), hint.slice()) catch |err| {
             var formatter = JSC.ConsoleObject.Formatter{ .globalThis = globalThis };
             const test_file_path = Jest.runner.?.files.get(this.testScope().?.describe.file_id).source.path.text;
-            switch (err) {
+            return switch (err) {
                 error.FailedToOpenSnapshotFile => globalThis.throw("Failed to open snapshot file for test file: {s}", .{test_file_path}),
                 error.FailedToMakeSnapshotDirectory => globalThis.throw("Failed to make snapshot directory for test file: {s}", .{test_file_path}),
                 error.FailedToWriteSnapshotFile => globalThis.throw("Failed write to snapshot file: {s}", .{test_file_path}),
-                error.ParseError => globalThis.throw("Failed to parse snapshot file for: {s}", .{test_file_path}),
+                error.SyntaxError, error.ParseError => globalThis.throw("Failed to parse snapshot file for: {s}", .{test_file_path}),
                 else => globalThis.throw("Failed to snapshot value: {any}", .{value.toFmt(&formatter)}),
-            }
-            return .zero;
+            };
         };
 
-        if (result) |saved_value| {
-            var pretty_value: MutableString = MutableString.init(default_allocator, 0) catch unreachable;
-            value.jestSnapshotPrettyFormat(&pretty_value, globalThis) catch {
-                var formatter = JSC.ConsoleObject.Formatter{ .globalThis = globalThis };
-                globalThis.throw("Failed to pretty format value: {s}", .{value.toFmt(&formatter)});
-                return .zero;
-            };
-            defer pretty_value.deinit();
-
-            if (strings.eqlLong(pretty_value.toOwnedSliceLeaky(), saved_value, true)) {
+        if (existing_value) |saved_value| {
+            if (strings.eqlLong(pretty_value.slice(), saved_value, true)) {
                 Jest.runner.?.snapshots.passed += 1;
                 return .undefined;
             }
@@ -2766,23 +2737,22 @@ pub const Expect = struct {
             const signature = comptime getSignature("toMatchSnapshot", "<green>expected<r>", false);
             const fmt = signature ++ "\n\n{any}\n";
             const diff_format = DiffFormatter{
-                .received_string = pretty_value.toOwnedSliceLeaky(),
+                .received_string = pretty_value.slice(),
                 .expected_string = saved_value,
                 .globalThis = globalThis,
             };
 
-            globalThis.throwPretty(fmt, .{diff_format});
-            return .zero;
+            return globalThis.throwPretty(fmt, .{diff_format});
         }
 
         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();
-        const value: JSValue = this.getValue(globalThis, thisValue, "toBeEmpty", "") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toBeEmpty", "");
 
         incrementExpectCallCounter();
 
@@ -2820,12 +2790,10 @@ pub const Expect = struct {
                 const signature = comptime getSignature("toBeEmpty", "", false);
                 const fmt = signature ++ "\n\nExpected value to be a string, object, or iterable" ++
                     "\n\nReceived: <red>{any}<r>\n";
-                globalThis.throwPretty(fmt, .{value.toFmt(&formatter)});
-                return .zero;
+                return globalThis.throwPretty(fmt, .{value.toFmt(&formatter)});
             }
         } else if (std.math.isNan(actual_length)) {
-            globalThis.throw("Received value has non-number length property: {}", .{actual_length});
-            return .zero;
+            return globalThis.throw("Received value has non-number length property: {}", .{actual_length});
         } else {
             pass = actual_length == 0;
         }
@@ -2834,8 +2802,7 @@ pub const Expect = struct {
             const signature = comptime getSignature("toBeEmpty", "", true);
             const fmt = signature ++ "\n\nExpected value <b>not<r> to be a string, object, or iterable" ++
                 "\n\nReceived: <red>{any}<r>\n";
-            globalThis.throwPretty(fmt, .{value.toFmt(&formatter)});
-            return .zero;
+            return globalThis.throwPretty(fmt, .{value.toFmt(&formatter)});
         }
 
         if (not) pass = !pass;
@@ -2845,22 +2812,20 @@ pub const Expect = struct {
             const signature = comptime getSignature("toBeEmpty", "", true);
             const fmt = signature ++ "\n\nExpected value <b>not<r> to be empty" ++
                 "\n\nReceived: <red>{any}<r>\n";
-            globalThis.throwPretty(fmt, .{value.toFmt(&formatter)});
-            return .zero;
+            return globalThis.throwPretty(fmt, .{value.toFmt(&formatter)});
         }
 
         const signature = comptime getSignature("toBeEmpty", "", false);
         const fmt = signature ++ "\n\nExpected value to be empty" ++
             "\n\nReceived: <red>{any}<r>\n";
-        globalThis.throwPretty(fmt, .{value.toFmt(&formatter)});
-        return .zero;
+        return globalThis.throwPretty(fmt, .{value.toFmt(&formatter)});
     }
 
-    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();
-        const value: JSValue = this.getValue(globalThis, thisValue, "toBeEmptyObject", "") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toBeEmptyObject", "");
 
         incrementExpectCallCounter();
 
@@ -2875,20 +2840,18 @@ pub const Expect = struct {
 
         if (not) {
             const signature = comptime getSignature("toBeEmptyObject", "", true);
-            this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
         }
 
         const signature = comptime getSignature("toBeEmptyObject", "", false);
-        this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
     }
 
-    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();
-        const value: JSValue = this.getValue(globalThis, thisValue, "toBeNil", "") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toBeNil", "");
 
         incrementExpectCallCounter();
 
@@ -2902,20 +2865,18 @@ pub const Expect = struct {
 
         if (not) {
             const signature = comptime getSignature("toBeNil", "", true);
-            this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
         }
 
         const signature = comptime getSignature("toBeNil", "", false);
-        this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
     }
 
-    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();
-        const value: JSValue = this.getValue(globalThis, thisValue, "toBeArray", "") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toBeArray", "");
 
         incrementExpectCallCounter();
 
@@ -2929,35 +2890,31 @@ pub const Expect = struct {
 
         if (not) {
             const signature = comptime getSignature("toBeArray", "", true);
-            this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
         }
 
         const signature = comptime getSignature("toBeArray", "", false);
-        this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
     }
 
-    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();
-        const _arguments = callFrame.arguments(1);
+        const _arguments = callFrame.arguments_old(1);
         const arguments = _arguments.ptr[0.._arguments.len];
 
         if (arguments.len < 1) {
-            globalThis.throwInvalidArguments("toBeArrayOfSize() requires 1 argument", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("toBeArrayOfSize() requires 1 argument", .{});
         }
 
-        const value: JSValue = this.getValue(globalThis, thisValue, "toBeArrayOfSize", "") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toBeArrayOfSize", "");
 
         const size = arguments[0];
         size.ensureStillAlive();
 
         if (!size.isAnyInt()) {
-            globalThis.throw("toBeArrayOfSize() requires the first argument to be a number", .{});
-            return .zero;
+            return globalThis.throw("toBeArrayOfSize() requires the first argument to be a number", .{});
         }
 
         incrementExpectCallCounter();
@@ -2973,20 +2930,18 @@ pub const Expect = struct {
 
         if (not) {
             const signature = comptime getSignature("toBeArrayOfSize", "", true);
-            this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
         }
 
         const signature = comptime getSignature("toBeArrayOfSize", "", false);
-        this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
     }
 
-    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();
-        const value: JSValue = this.getValue(globalThis, thisValue, "toBeBoolean", "") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toBeBoolean", "");
 
         incrementExpectCallCounter();
 
@@ -3000,35 +2955,31 @@ pub const Expect = struct {
 
         if (not) {
             const signature = comptime getSignature("toBeBoolean", "", true);
-            this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
         }
 
         const signature = comptime getSignature("toBeBoolean", "", false);
-        this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
     }
 
-    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();
-        const _arguments = callFrame.arguments(1);
+        const _arguments = callFrame.arguments_old(1);
         const arguments = _arguments.ptr[0.._arguments.len];
 
         if (arguments.len < 1) {
-            globalThis.throwInvalidArguments("toBeTypeOf() requires 1 argument", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("toBeTypeOf() requires 1 argument", .{});
         }
 
-        const value: JSValue = this.getValue(globalThis, thisValue, "toBeTypeOf", "") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toBeTypeOf", "");
 
         const expected = arguments[0];
         expected.ensureStillAlive();
 
         if (!expected.isString()) {
-            globalThis.throwInvalidArguments("toBeTypeOf() requires a string argument", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("toBeTypeOf() requires a string argument", .{});
         }
 
         const expected_type = expected.toBunString(globalThis);
@@ -3036,8 +2987,7 @@ pub const Expect = struct {
         incrementExpectCallCounter();
 
         const typeof = expected_type.inMap(JSTypeOfMap) orelse {
-            globalThis.throwInvalidArguments("toBeTypeOf() requires a valid type string argument ('function', 'object', 'bigint', 'boolean', 'number', 'string', 'symbol', 'undefined')", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("toBeTypeOf() requires a valid type string argument ('function', 'object', 'bigint', 'boolean', 'number', 'string', 'symbol', 'undefined')", .{});
         };
 
         const not = this.flags.not;
@@ -3062,8 +3012,7 @@ pub const Expect = struct {
         } else if (value.isUndefined()) {
             whatIsTheType = "undefined";
         } else {
-            globalThis.throw("Internal consistency error: unknown JSValue type", .{});
-            return .zero;
+            return globalThis.throw("Internal consistency error: unknown JSValue type", .{});
         }
 
         pass = strings.eql(typeof, whatIsTheType);
@@ -3077,20 +3026,18 @@ pub const Expect = struct {
 
         if (not) {
             const signature = comptime getSignature("toBeTypeOf", "", true);
-            this.throw(globalThis, signature, "\n\n" ++ "Expected type: not <green>{any}<r>\n" ++ "Received type: <red>\"{s}\"<r>\nReceived value: <red>{any}<r>\n", .{ expected_str, whatIsTheType, received });
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ "Expected type: not <green>{any}<r>\n" ++ "Received type: <red>\"{s}\"<r>\nReceived value: <red>{any}<r>\n", .{ expected_str, whatIsTheType, received });
         }
 
         const signature = comptime getSignature("toBeTypeOf", "", false);
-        this.throw(globalThis, signature, "\n\n" ++ "Expected type: <green>{any}<r>\n" ++ "Received type: <red>\"{s}\"<r>\nReceived value: <red>{any}<r>\n", .{ expected_str, whatIsTheType, received });
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ "Expected type: <green>{any}<r>\n" ++ "Received type: <red>\"{s}\"<r>\nReceived value: <red>{any}<r>\n", .{ expected_str, whatIsTheType, received });
     }
 
-    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();
-        const value: JSValue = this.getValue(globalThis, thisValue, "toBeTrue", "") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toBeTrue", "");
 
         incrementExpectCallCounter();
 
@@ -3104,20 +3051,18 @@ pub const Expect = struct {
 
         if (not) {
             const signature = comptime getSignature("toBeTrue", "", true);
-            this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
         }
 
         const signature = comptime getSignature("toBeTrue", "", false);
-        this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
     }
 
-    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();
-        const value: JSValue = this.getValue(globalThis, thisValue, "toBeFalse", "") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toBeFalse", "");
 
         incrementExpectCallCounter();
 
@@ -3131,20 +3076,18 @@ pub const Expect = struct {
 
         if (not) {
             const signature = comptime getSignature("toBeFalse", "", true);
-            this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
         }
 
         const signature = comptime getSignature("toBeFalse", "", false);
-        this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
     }
 
-    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();
-        const value: JSValue = this.getValue(globalThis, thisValue, "toBeNumber", "") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toBeNumber", "");
 
         incrementExpectCallCounter();
 
@@ -3158,20 +3101,18 @@ pub const Expect = struct {
 
         if (not) {
             const signature = comptime getSignature("toBeNumber", "", true);
-            this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
         }
 
         const signature = comptime getSignature("toBeNumber", "", false);
-        this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
     }
 
-    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();
-        const value: JSValue = this.getValue(globalThis, thisValue, "toBeInteger", "") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toBeInteger", "");
 
         incrementExpectCallCounter();
 
@@ -3185,20 +3126,18 @@ pub const Expect = struct {
 
         if (not) {
             const signature = comptime getSignature("toBeInteger", "", true);
-            this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
         }
 
         const signature = comptime getSignature("toBeInteger", "", false);
-        this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
     }
 
-    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();
-        const value: JSValue = this.getValue(globalThis, thisValue, "toBeObject", "") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toBeObject", "");
 
         incrementExpectCallCounter();
 
@@ -3212,20 +3151,18 @@ pub const Expect = struct {
 
         if (not) {
             const signature = comptime getSignature("toBeObject", "", true);
-            this.throw(globalThis, signature, "\n\nExpected value <b>not<r> to be an object" ++ "\n\nReceived: <red>{any}<r>\n", .{received});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\nExpected value <b>not<r> to be an object" ++ "\n\nReceived: <red>{any}<r>\n", .{received});
         }
 
         const signature = comptime getSignature("toBeObject", "", false);
-        this.throw(globalThis, signature, "\n\nExpected value to be an object" ++ "\n\nReceived: <red>{any}<r>\n", .{received});
-        return .zero;
+        return this.throw(globalThis, signature, "\n\nExpected value to be an object" ++ "\n\nReceived: <red>{any}<r>\n", .{received});
     }
 
-    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();
-        const value: JSValue = this.getValue(globalThis, thisValue, "toBeFinite", "") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toBeFinite", "");
 
         incrementExpectCallCounter();
 
@@ -3245,20 +3182,18 @@ pub const Expect = struct {
 
         if (not) {
             const signature = comptime getSignature("toBeFinite", "", true);
-            this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
         }
 
         const signature = comptime getSignature("toBeFinite", "", false);
-        this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
     }
 
-    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();
-        const value: JSValue = this.getValue(globalThis, thisValue, "toBePositive", "") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toBePositive", "");
 
         incrementExpectCallCounter();
 
@@ -3278,20 +3213,18 @@ pub const Expect = struct {
 
         if (not) {
             const signature = comptime getSignature("toBePositive", "", true);
-            this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
         }
 
         const signature = comptime getSignature("toBePositive", "", false);
-        this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
     }
 
-    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();
-        const value: JSValue = this.getValue(globalThis, thisValue, "toBeNegative", "") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toBeNegative", "");
 
         incrementExpectCallCounter();
 
@@ -3311,43 +3244,38 @@ pub const Expect = struct {
 
         if (not) {
             const signature = comptime getSignature("toBeNegative", "", true);
-            this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
         }
 
         const signature = comptime getSignature("toBeNegative", "", false);
-        this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
     }
 
-    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();
-        const _arguments = callFrame.arguments(2);
+        const _arguments = callFrame.arguments_old(2);
         const arguments = _arguments.ptr[0.._arguments.len];
 
         if (arguments.len < 1) {
-            globalThis.throwInvalidArguments("toBeWithin() requires 2 arguments", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("toBeWithin() requires 2 arguments", .{});
         }
 
-        const value: JSValue = this.getValue(globalThis, thisValue, "toBeWithin", "<green>start<r><d>, <r><green>end<r>") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toBeWithin", "<green>start<r><d>, <r><green>end<r>");
 
         const startValue = arguments[0];
         startValue.ensureStillAlive();
 
         if (!startValue.isNumber()) {
-            globalThis.throw("toBeWithin() requires the first argument to be a number", .{});
-            return .zero;
+            return globalThis.throw("toBeWithin() requires the first argument to be a number", .{});
         }
 
         const endValue = arguments[1];
         endValue.ensureStillAlive();
 
         if (!endValue.isNumber()) {
-            globalThis.throw("toBeWithin() requires the second argument to be a number", .{});
-            return .zero;
+            return globalThis.throw("toBeWithin() requires the second argument to be a number", .{});
         }
 
         incrementExpectCallCounter();
@@ -3372,37 +3300,33 @@ pub const Expect = struct {
             const expected_line = "Expected: not between <green>{any}<r> <d>(inclusive)<r> and <green>{any}<r> <d>(exclusive)<r>\n";
             const received_line = "Received: <red>{any}<r>\n";
             const signature = comptime getSignature("toBeWithin", "<green>start<r><d>, <r><green>end<r>", true);
-            this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ start_fmt, end_fmt, received_fmt });
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ start_fmt, end_fmt, received_fmt });
         }
 
         const expected_line = "Expected: between <green>{any}<r> <d>(inclusive)<r> and <green>{any}<r> <d>(exclusive)<r>\n";
         const received_line = "Received: <red>{any}<r>\n";
         const signature = comptime getSignature("toBeWithin", "<green>start<r><d>, <r><green>end<r>", false);
-        this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ start_fmt, end_fmt, received_fmt });
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ start_fmt, end_fmt, received_fmt });
     }
 
-    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();
-        const _arguments = callFrame.arguments(1);
+        const _arguments = callFrame.arguments_old(1);
         const arguments: []const JSValue = _arguments.ptr[0.._arguments.len];
 
         if (arguments.len < 1) {
-            globalThis.throwInvalidArguments("toEqualIgnoringWhitespace() requires 1 argument", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("toEqualIgnoringWhitespace() requires 1 argument", .{});
         }
 
         incrementExpectCallCounter();
 
         const expected = arguments[0];
-        const value: JSValue = this.getValue(globalThis, thisValue, "toEqualIgnoringWhitespace", "<green>expected<r>") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toEqualIgnoringWhitespace", "<green>expected<r>");
 
         if (!expected.isString()) {
-            globalThis.throw("toEqualIgnoringWhitespace() requires argument to be a string", .{});
-            return .zero;
+            return globalThis.throw("toEqualIgnoringWhitespace() requires argument to be a string", .{});
         }
 
         const not = this.flags.not;
@@ -3456,20 +3380,18 @@ pub const Expect = struct {
 
         if (not) {
             const signature = comptime getSignature("toEqualIgnoringWhitespace", "<green>expected<r>", true);
-            this.throw(globalThis, signature, "\n\n" ++ "Expected: not <green>{any}<r>\n" ++ "Received: <red>{any}<r>\n", .{ expected_fmt, value_fmt });
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ "Expected: not <green>{any}<r>\n" ++ "Received: <red>{any}<r>\n", .{ expected_fmt, value_fmt });
         }
 
         const signature = comptime getSignature("toEqualIgnoringWhitespace", "<green>expected<r>", false);
-        this.throw(globalThis, signature, "\n\n" ++ "Expected: <green>{any}<r>\n" ++ "Received: <red>{any}<r>\n", .{ expected_fmt, value_fmt });
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ "Expected: <green>{any}<r>\n" ++ "Received: <red>{any}<r>\n", .{ expected_fmt, value_fmt });
     }
 
-    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();
-        const value: JSValue = this.getValue(globalThis, thisValue, "toBeSymbol", "") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toBeSymbol", "");
 
         incrementExpectCallCounter();
 
@@ -3483,20 +3405,18 @@ pub const Expect = struct {
 
         if (not) {
             const signature = comptime getSignature("toBeSymbol", "", true);
-            this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
         }
 
         const signature = comptime getSignature("toBeSymbol", "", false);
-        this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
     }
 
-    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();
-        const value: JSValue = this.getValue(globalThis, thisValue, "toBeFunction", "") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toBeFunction", "");
 
         incrementExpectCallCounter();
 
@@ -3510,20 +3430,18 @@ pub const Expect = struct {
 
         if (not) {
             const signature = comptime getSignature("toBeFunction", "", true);
-            this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
         }
 
         const signature = comptime getSignature("toBeFunction", "", false);
-        this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
     }
 
-    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();
-        const value: JSValue = this.getValue(globalThis, thisValue, "toBeDate", "") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toBeDate", "");
 
         incrementExpectCallCounter();
 
@@ -3537,20 +3455,18 @@ pub const Expect = struct {
 
         if (not) {
             const signature = comptime getSignature("toBeDate", "", true);
-            this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
         }
 
         const signature = comptime getSignature("toBeDate", "", false);
-        this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
     }
 
-    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();
-        const value: JSValue = this.getValue(globalThis, thisValue, "toBeValidDate", "") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toBeValidDate", "");
 
         active_test_expectation_counter.actual += 1;
 
@@ -3565,20 +3481,18 @@ pub const Expect = struct {
 
         if (not) {
             const signature = comptime getSignature("toBeValidDate", "", true);
-            this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
         }
 
         const signature = comptime getSignature("toBeValidDate", "", false);
-        this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
     }
 
-    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();
-        const value: JSValue = this.getValue(globalThis, thisValue, "toBeString", "") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toBeString", "");
 
         incrementExpectCallCounter();
 
@@ -3592,44 +3506,40 @@ pub const Expect = struct {
 
         if (not) {
             const signature = comptime getSignature("toBeString", "", true);
-            this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
         }
 
         const signature = comptime getSignature("toBeString", "", false);
-        this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>\n", .{received});
     }
 
-    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();
-        const arguments_ = callFrame.arguments(1);
+        const arguments_ = callFrame.arguments_old(1);
         const arguments = arguments_.slice();
 
         if (arguments.len < 1) {
-            globalThis.throwInvalidArguments("toInclude() requires 1 argument", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("toInclude() requires 1 argument", .{});
         }
 
         const expected = arguments[0];
         expected.ensureStillAlive();
 
         if (!expected.isString()) {
-            globalThis.throw("toInclude() requires the first argument to be a string", .{});
-            return .zero;
+            return globalThis.throw("toInclude() requires the first argument to be a string", .{});
         }
 
-        const value: JSValue = this.getValue(globalThis, thisValue, "toInclude", "") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toInclude", "");
 
         incrementExpectCallCounter();
 
         var pass = value.isString();
         if (pass) {
-            const value_string = value.toSliceOrNull(globalThis) orelse return .zero;
+            const value_string = try value.toSliceOrNull(globalThis);
             defer value_string.deinit();
-            const expected_string = expected.toSliceOrNull(globalThis) orelse return .zero;
+            const expected_string = try expected.toSliceOrNull(globalThis);
             defer expected_string.deinit();
             pass = strings.contains(value_string.slice(), expected_string.slice()) or expected_string.len == 0;
         }
@@ -3647,27 +3557,24 @@ pub const Expect = struct {
             const expected_line = "Expected to not include: <green>{any}<r>\n";
             const received_line = "Received: <red>{any}<r>\n";
             const signature = comptime getSignature("toInclude", "<green>expected<r>", true);
-            this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
         }
 
         const expected_line = "Expected to include: <green>{any}<r>\n";
         const received_line = "Received: <red>{any}<r>\n";
         const signature = comptime getSignature("toInclude", "<green>expected<r>", false);
-        this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
     }
 
-    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();
-        const arguments_ = callFrame.arguments(2);
+        const arguments_ = callFrame.arguments_old(2);
         const arguments = arguments_.slice();
 
         if (arguments.len < 2) {
-            globalThis.throwInvalidArguments("toIncludeRepeated() requires 2 arguments", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("toIncludeRepeated() requires 2 arguments", .{});
         }
 
         incrementExpectCallCounter();
@@ -3676,35 +3583,31 @@ pub const Expect = struct {
         substring.ensureStillAlive();
 
         if (!substring.isString()) {
-            globalThis.throw("toIncludeRepeated() requires the first argument to be a string", .{});
-            return .zero;
+            return globalThis.throw("toIncludeRepeated() requires the first argument to be a string", .{});
         }
 
         const count = arguments[1];
         count.ensureStillAlive();
 
         if (!count.isAnyInt()) {
-            globalThis.throw("toIncludeRepeated() requires the second argument to be a number", .{});
-            return .zero;
+            return globalThis.throw("toIncludeRepeated() requires the second argument to be a number", .{});
         }
 
         const countAsNum = count.toU32();
 
         const expect_string = Expect.capturedValueGetCached(thisValue) orelse {
-            globalThis.throw("Internal consistency error: the expect(value) was garbage collected but it should not have been!", .{});
-            return .zero;
+            return globalThis.throw("Internal consistency error: the expect(value) was garbage collected but it should not have been!", .{});
         };
 
         if (!expect_string.isString()) {
-            globalThis.throw("toIncludeRepeated() requires the expect(value) to be a string", .{});
-            return .zero;
+            return globalThis.throw("toIncludeRepeated() requires the expect(value) to be a string", .{});
         }
 
         const not = this.flags.not;
         var pass = false;
 
-        const _expectStringAsStr = expect_string.toSliceOrNull(globalThis) orelse return .zero;
-        const _subStringAsStr = substring.toSliceOrNull(globalThis) orelse return .zero;
+        const _expectStringAsStr = try expect_string.toSliceOrNull(globalThis);
+        const _subStringAsStr = try substring.toSliceOrNull(globalThis);
 
         defer {
             _expectStringAsStr.deinit();
@@ -3715,8 +3618,7 @@ pub const Expect = struct {
         const subStringAsStr = _subStringAsStr.slice();
 
         if (subStringAsStr.len == 0) {
-            globalThis.throw("toIncludeRepeated() requires the first argument to be a non-empty string", .{});
-            return .zero;
+            return globalThis.throw("toIncludeRepeated() requires the first argument to be a non-empty string", .{});
         }
 
         if (countAsNum == 0)
@@ -3738,47 +3640,42 @@ pub const Expect = struct {
             if (countAsNum == 0) {
                 const expected_line = "Expected to include: <green>{any}<r> \n";
                 const signature = comptime getSignature("toIncludeRepeated", "<green>expected<r>", true);
-                this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ substring_fmt, expect_string_fmt });
+                return this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ substring_fmt, expect_string_fmt });
             } else if (countAsNum == 1) {
                 const expected_line = "Expected not to include: <green>{any}<r> \n";
                 const signature = comptime getSignature("toIncludeRepeated", "<green>expected<r>", true);
-                this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ substring_fmt, expect_string_fmt });
+                return this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ substring_fmt, expect_string_fmt });
             } else {
                 const expected_line = "Expected not to include: <green>{any}<r> <green>{any}<r> times \n";
                 const signature = comptime getSignature("toIncludeRepeated", "<green>expected<r>", true);
-                this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ substring_fmt, times_fmt, expect_string_fmt });
+                return this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ substring_fmt, times_fmt, expect_string_fmt });
             }
-
-            return .zero;
         }
 
         if (countAsNum == 0) {
             const expected_line = "Expected to not include: <green>{any}<r>\n";
             const signature = comptime getSignature("toIncludeRepeated", "<green>expected<r>", false);
-            this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ substring_fmt, expect_string_fmt });
+            return this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ substring_fmt, expect_string_fmt });
         } else if (countAsNum == 1) {
             const expected_line = "Expected to include: <green>{any}<r>\n";
             const signature = comptime getSignature("toIncludeRepeated", "<green>expected<r>", false);
-            this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ substring_fmt, expect_string_fmt });
+            return this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ substring_fmt, expect_string_fmt });
         } else {
             const expected_line = "Expected to include: <green>{any}<r> <green>{any}<r> times \n";
             const signature = comptime getSignature("toIncludeRepeated", "<green>expected<r>", false);
-            this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ substring_fmt, times_fmt, expect_string_fmt });
+            return this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ substring_fmt, times_fmt, expect_string_fmt });
         }
-
-        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();
-        const arguments_ = callFrame.arguments(1);
+        const arguments_ = callFrame.arguments_old(1);
         const arguments = arguments_.slice();
 
         if (arguments.len < 1) {
-            globalThis.throwInvalidArguments("toSatisfy() requires 1 argument", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("toSatisfy() requires 1 argument", .{});
         }
 
         incrementExpectCallCounter();
@@ -3787,21 +3684,18 @@ pub const Expect = struct {
         predicate.ensureStillAlive();
 
         if (!predicate.isCallable(globalThis.vm())) {
-            globalThis.throw("toSatisfy() argument must be a function", .{});
-            return .zero;
+            return globalThis.throw("toSatisfy() argument must be a function", .{});
         }
 
         const value = Expect.capturedValueGetCached(thisValue) orelse {
-            globalThis.throw("Internal consistency error: the expect(value) was garbage collected but it should not have been!", .{});
-            return .zero;
+            return globalThis.throw("Internal consistency error: the expect(value) was garbage collected but it should not have been!", .{});
         };
         value.ensureStillAlive();
 
         const result = predicate.call(globalThis, .undefined, &.{value}) catch |e| {
             const err = globalThis.takeException(e);
             const fmt = ZigString.init("toSatisfy() predicate threw an exception");
-            globalThis.vm().throwError(globalThis, globalThis.createAggregateError(&.{err}, &fmt));
-            return .zero;
+            return globalThis.throwValue(globalThis.createAggregateError(&.{err}, &fmt));
         };
 
         const not = this.flags.not;
@@ -3813,49 +3707,44 @@ pub const Expect = struct {
 
         if (not) {
             const signature = comptime getSignature("toSatisfy", "<green>expected<r>", true);
-            this.throw(globalThis, signature, "\n\nExpected: not <green>{any}<r>\n", .{predicate.toFmt(&formatter)});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\nExpected: not <green>{any}<r>\n", .{predicate.toFmt(&formatter)});
         }
 
         const signature = comptime getSignature("toSatisfy", "<green>expected<r>", false);
 
-        this.throw(globalThis, signature, "\n\nExpected: <green>{any}<r>\nReceived: <red>{any}<r>\n", .{
+        return this.throw(globalThis, signature, "\n\nExpected: <green>{any}<r>\nReceived: <red>{any}<r>\n", .{
             predicate.toFmt(&formatter),
             value.toFmt(&formatter),
         });
-
-        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();
-        const arguments_ = callFrame.arguments(1);
+        const arguments_ = callFrame.arguments_old(1);
         const arguments = arguments_.slice();
 
         if (arguments.len < 1) {
-            globalThis.throwInvalidArguments("toStartWith() requires 1 argument", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("toStartWith() requires 1 argument", .{});
         }
 
         const expected = arguments[0];
         expected.ensureStillAlive();
 
         if (!expected.isString()) {
-            globalThis.throw("toStartWith() requires the first argument to be a string", .{});
-            return .zero;
+            return globalThis.throw("toStartWith() requires the first argument to be a string", .{});
         }
 
-        const value: JSValue = this.getValue(globalThis, thisValue, "toStartWith", "<green>expected<r>") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toStartWith", "<green>expected<r>");
 
         incrementExpectCallCounter();
 
         var pass = value.isString();
         if (pass) {
-            const value_string = value.toSliceOrNull(globalThis) orelse return .zero;
+            const value_string = try value.toSliceOrNull(globalThis);
             defer value_string.deinit();
-            const expected_string = expected.toSliceOrNull(globalThis) orelse return .zero;
+            const expected_string = try expected.toSliceOrNull(globalThis);
             defer expected_string.deinit();
             pass = strings.startsWith(value_string.slice(), expected_string.slice()) or expected_string.len == 0;
         }
@@ -3873,46 +3762,42 @@ pub const Expect = struct {
             const expected_line = "Expected to not start with: <green>{any}<r>\n";
             const received_line = "Received: <red>{any}<r>\n";
             const signature = comptime getSignature("toStartWith", "<green>expected<r>", true);
-            this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
         }
 
         const expected_line = "Expected to start with: <green>{any}<r>\n";
         const received_line = "Received: <red>{any}<r>\n";
         const signature = comptime getSignature("toStartWith", "<green>expected<r>", false);
-        this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
     }
 
-    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();
-        const arguments_ = callFrame.arguments(1);
+        const arguments_ = callFrame.arguments_old(1);
         const arguments = arguments_.slice();
 
         if (arguments.len < 1) {
-            globalThis.throwInvalidArguments("toEndWith() requires 1 argument", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("toEndWith() requires 1 argument", .{});
         }
 
         const expected = arguments[0];
         expected.ensureStillAlive();
 
         if (!expected.isString()) {
-            globalThis.throw("toEndWith() requires the first argument to be a string", .{});
-            return .zero;
+            return globalThis.throw("toEndWith() requires the first argument to be a string", .{});
         }
 
-        const value: JSValue = this.getValue(globalThis, thisValue, "toEndWith", "<green>expected<r>") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toEndWith", "<green>expected<r>");
 
         incrementExpectCallCounter();
 
         var pass = value.isString();
         if (pass) {
-            const value_string = value.toSliceOrNull(globalThis) orelse return .zero;
+            const value_string = try value.toSliceOrNull(globalThis);
             defer value_string.deinit();
-            const expected_string = expected.toSliceOrNull(globalThis) orelse return .zero;
+            const expected_string = try expected.toSliceOrNull(globalThis);
             defer expected_string.deinit();
             pass = strings.endsWith(value_string.slice(), expected_string.slice()) or expected_string.len == 0;
         }
@@ -3930,27 +3815,24 @@ pub const Expect = struct {
             const expected_line = "Expected to not end with: <green>{any}<r>\n";
             const received_line = "Received: <red>{any}<r>\n";
             const signature = comptime getSignature("toEndWith", "<green>expected<r>", true);
-            this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
         }
 
         const expected_line = "Expected to end with: <green>{any}<r>\n";
         const received_line = "Received: <red>{any}<r>\n";
         const signature = comptime getSignature("toEndWith", "<green>expected<r>", false);
-        this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
     }
 
-    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();
-        const _arguments = callFrame.arguments(1);
+        const _arguments = callFrame.arguments_old(1);
         const arguments: []const JSValue = _arguments.ptr[0.._arguments.len];
 
         if (arguments.len < 1) {
-            globalThis.throwInvalidArguments("toBeInstanceOf() requires 1 argument", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("toBeInstanceOf() requires 1 argument", .{});
         }
 
         incrementExpectCallCounter();
@@ -3958,12 +3840,11 @@ pub const Expect = struct {
 
         const expected_value = arguments[0];
         if (!expected_value.isConstructor()) {
-            globalThis.throw("Expected value must be a function: {any}", .{expected_value.toFmt(&formatter)});
-            return .zero;
+            return globalThis.throw("Expected value must be a function: {any}", .{expected_value.toFmt(&formatter)});
         }
         expected_value.ensureStillAlive();
 
-        const value: JSValue = this.getValue(globalThis, thisValue, "toBeInstanceOf", "<green>expected<r>") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toBeInstanceOf", "<green>expected<r>");
 
         const not = this.flags.not;
         var pass = value.isInstanceOf(globalThis, expected_value);
@@ -3977,29 +3858,26 @@ pub const Expect = struct {
             const expected_line = "Expected constructor: not <green>{any}<r>\n";
             const received_line = "Received value: <red>{any}<r>\n";
             const signature = comptime getSignature("toBeInstanceOf", "<green>expected<r>", true);
-            this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
         }
 
         const expected_line = "Expected constructor: <green>{any}<r>\n";
         const received_line = "Received value: <red>{any}<r>\n";
         const signature = comptime getSignature("toBeInstanceOf", "<green>expected<r>", false);
-        this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
     }
 
-    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);
 
         const thisValue = callFrame.this();
-        const _arguments = callFrame.arguments(1);
+        const _arguments = callFrame.arguments_old(1);
         const arguments: []const JSValue = _arguments.ptr[0.._arguments.len];
 
         if (arguments.len < 1) {
-            globalThis.throwInvalidArguments("toMatch() requires 1 argument", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("toMatch() requires 1 argument", .{});
         }
 
         incrementExpectCallCounter();
@@ -4008,16 +3886,14 @@ pub const Expect = struct {
 
         const expected_value = arguments[0];
         if (!expected_value.isString() and !expected_value.isRegExp()) {
-            globalThis.throw("Expected value must be a string or regular expression: {any}", .{expected_value.toFmt(&formatter)});
-            return .zero;
+            return globalThis.throw("Expected value must be a string or regular expression: {any}", .{expected_value.toFmt(&formatter)});
         }
         expected_value.ensureStillAlive();
 
-        const value: JSValue = this.getValue(globalThis, thisValue, "toMatch", "<green>expected<r>") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toMatch", "<green>expected<r>");
 
         if (!value.isString()) {
-            globalThis.throw("Received value must be a string: {any}", .{value.toFmt(&formatter)});
-            return .zero;
+            return globalThis.throw("Received value must be a string: {any}", .{value.toFmt(&formatter)});
         }
 
         const not = this.flags.not;
@@ -4041,30 +3917,27 @@ pub const Expect = struct {
             const expected_line = "Expected substring or pattern: not <green>{any}<r>\n";
             const received_line = "Received: <red>{any}<r>\n";
             const signature = comptime getSignature("toMatch", "<green>expected<r>", true);
-            this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
         }
 
         const expected_line = "Expected substring or pattern: <green>{any}<r>\n";
         const received_line = "Received: <red>{any}<r>\n";
         const signature = comptime getSignature("toMatch", "<green>expected<r>", false);
-        this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ expected_line ++ received_line, .{ expected_fmt, value_fmt });
     }
 
-    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);
 
-        const value: JSValue = this.getValue(globalThis, thisValue, "toHaveBeenCalled", "") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toHaveBeenCalled", "");
 
         const calls = JSMockFunction__getCalls(value);
         incrementExpectCallCounter();
 
         if (calls == .zero or !calls.jsType().isArray()) {
-            globalThis.throw("Expected value must be a mock function: {}", .{value});
-            return .zero;
+            return globalThis.throw("Expected value must be a mock function: {}", .{value});
         }
 
         var pass = calls.getLength(globalThis) > 0;
@@ -4076,36 +3949,32 @@ pub const Expect = struct {
         // handle failure
         if (not) {
             const signature = comptime getSignature("toHaveBeenCalled", "", true);
-            this.throw(globalThis, signature, "\n\n" ++ "Expected number of calls: <green>0<r>\n" ++ "Received number of calls: <red>{any}<r>\n", .{calls.getLength(globalThis)});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ "Expected number of calls: <green>0<r>\n" ++ "Received number of calls: <red>{any}<r>\n", .{calls.getLength(globalThis)});
         }
 
         const signature = comptime getSignature("toHaveBeenCalled", "", false);
-        this.throw(globalThis, signature, "\n\n" ++ "Expected number of calls: \\>= <green>1<r>\n" ++ "Received number of calls: <red>{any}<r>\n", .{calls.getLength(globalThis)});
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ "Expected number of calls: \\>= <green>1<r>\n" ++ "Received number of calls: <red>{any}<r>\n", .{calls.getLength(globalThis)});
     }
 
-    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();
-        const arguments_ = callframe.arguments(1);
+        const arguments_ = callframe.arguments_old(1);
         const arguments: []const JSValue = arguments_.slice();
         defer this.postMatch(globalThis);
-        const value: JSValue = this.getValue(globalThis, thisValue, "toHaveBeenCalledTimes", "<green>expected<r>") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toHaveBeenCalledTimes", "<green>expected<r>");
 
         incrementExpectCallCounter();
 
         const calls = JSMockFunction__getCalls(value);
 
         if (calls == .zero or !calls.jsType().isArray()) {
-            globalThis.throw("Expected value must be a mock function: {}", .{value});
-            return .zero;
+            return globalThis.throw("Expected value must be a mock function: {}", .{value});
         }
 
         if (arguments.len < 1 or !arguments[0].isUInt32AsAnyInt()) {
-            globalThis.throwInvalidArguments("toHaveBeenCalledTimes() requires 1 non-negative integer argument", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("toHaveBeenCalledTimes() requires 1 non-negative integer argument", .{});
         }
 
         const times = arguments[0].coerce(i32, globalThis);
@@ -4119,51 +3988,45 @@ pub const Expect = struct {
         // handle failure
         if (not) {
             const signature = comptime getSignature("toHaveBeenCalledTimes", "<green>expected<r>", true);
-            this.throw(globalThis, signature, "\n\n" ++ "Expected number of calls: not <green>{any}<r>\n" ++ "Received number of calls: <red>{any}<r>\n", .{ times, calls.getLength(globalThis) });
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ "Expected number of calls: not <green>{any}<r>\n" ++ "Received number of calls: <red>{any}<r>\n", .{ times, calls.getLength(globalThis) });
         }
 
         const signature = comptime getSignature("toHaveBeenCalledTimes", "<green>expected<r>", false);
-        this.throw(globalThis, signature, "\n\n" ++ "Expected number of calls: <green>{any}<r>\n" ++ "Received number of calls: <red>{any}<r>\n", .{ times, calls.getLength(globalThis) });
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ "Expected number of calls: <green>{any}<r>\n" ++ "Received number of calls: <red>{any}<r>\n", .{ times, calls.getLength(globalThis) });
     }
 
-    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);
         const thisValue = callFrame.this();
-        const args = callFrame.arguments(1).slice();
+        const args = callFrame.arguments_old(1).slice();
 
         incrementExpectCallCounter();
 
         const not = this.flags.not;
 
-        const received_object: JSValue = this.getValue(globalThis, thisValue, "toMatchObject", "<green>expected<r>") orelse return .zero;
+        const received_object: JSValue = try this.getValue(globalThis, thisValue, "toMatchObject", "<green>expected<r>");
 
         if (!received_object.isObject()) {
             const matcher_error = "\n\n<b>Matcher error<r>: <red>received<r> value must be a non-null object\n";
             if (not) {
                 const signature = comptime getSignature("toMatchObject", "<green>expected<r>", true);
-                this.throw(globalThis, signature, matcher_error, .{});
-                return .zero;
+                return this.throw(globalThis, signature, matcher_error, .{});
             }
 
             const signature = comptime getSignature("toMatchObject", "<green>expected<r>", false);
-            this.throw(globalThis, signature, matcher_error, .{});
-            return .zero;
+            return this.throw(globalThis, signature, matcher_error, .{});
         }
 
         if (args.len < 1 or !args[0].isObject()) {
             const matcher_error = "\n\n<b>Matcher error<r>: <green>expected<r> value must be a non-null object\n";
             if (not) {
                 const signature = comptime getSignature("toMatchObject", "", true);
-                this.throw(globalThis, signature, matcher_error, .{});
-                return .zero;
+                return this.throw(globalThis, signature, matcher_error, .{});
             }
             const signature = comptime getSignature("toMatchObject", "", false);
-            this.throw(globalThis, signature, matcher_error, .{});
-            return .zero;
+            return this.throw(globalThis, signature, matcher_error, .{});
         }
 
         const property_matchers = args[0];
@@ -4183,30 +4046,27 @@ pub const Expect = struct {
 
         if (not) {
             const signature = comptime getSignature("toMatchObject", "<green>expected<r>", true);
-            this.throw(globalThis, signature, "\n\n{any}\n", .{diff_formatter});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n{any}\n", .{diff_formatter});
         }
 
         const signature = comptime getSignature("toMatchObject", "<green>expected<r>", false);
-        this.throw(globalThis, signature, "\n\n{any}\n", .{diff_formatter});
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n{any}\n", .{diff_formatter});
     }
 
-    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();
         const arguments = callframe.argumentsPtr()[0..callframe.argumentsCount()];
         defer this.postMatch(globalThis);
-        const value: JSValue = this.getValue(globalThis, thisValue, "toHaveBeenCalledWith", "<green>expected<r>") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toHaveBeenCalledWith", "<green>expected<r>");
 
         incrementExpectCallCounter();
 
         const calls = JSMockFunction__getCalls(value);
 
         if (calls == .zero or !calls.jsType().isArray()) {
-            globalThis.throw("Expected value must be a mock function: {}", .{value});
-            return .zero;
+            return globalThis.throw("Expected value must be a mock function: {}", .{value});
         }
 
         var pass = false;
@@ -4215,8 +4075,7 @@ pub const Expect = struct {
             var itr = calls.arrayIterator(globalThis);
             while (itr.next()) |callItem| {
                 if (callItem == .zero or !callItem.jsType().isArray()) {
-                    globalThis.throw("Expected value must be a mock function with calls: {}", .{value});
-                    return .zero;
+                    return globalThis.throw("Expected value must be a mock function with calls: {}", .{value});
                 }
 
                 if (callItem.getLength(globalThis) != arguments.len) {
@@ -4226,7 +4085,7 @@ pub const Expect = struct {
                 var callItr = callItem.arrayIterator(globalThis);
                 var match = true;
                 while (callItr.next()) |callArg| {
-                    if (!callArg.jestDeepEquals(arguments[callItr.i - 1], globalThis)) {
+                    if (!try callArg.jestDeepEquals(arguments[callItr.i - 1], globalThis)) {
                         match = false;
                         break;
                     }
@@ -4246,30 +4105,27 @@ pub const Expect = struct {
         // handle failure
         if (not) {
             const signature = comptime getSignature("toHaveBeenCalledWith", "<green>expected<r>", true);
-            this.throw(globalThis, signature, "\n\n" ++ "Number of calls: <red>{any}<r>\n", .{calls.getLength(globalThis)});
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ "Number of calls: <red>{any}<r>\n", .{calls.getLength(globalThis)});
         }
 
         const signature = comptime getSignature("toHaveBeenCalledWith", "<green>expected<r>", false);
-        this.throw(globalThis, signature, "\n\n" ++ "Number of calls: <red>{any}<r>\n", .{calls.getLength(globalThis)});
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ "Number of calls: <red>{any}<r>\n", .{calls.getLength(globalThis)});
     }
 
-    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();
         const arguments = callframe.argumentsPtr()[0..callframe.argumentsCount()];
         defer this.postMatch(globalThis);
-        const value: JSValue = this.getValue(globalThis, thisValue, "toHaveBeenLastCalledWith", "<green>expected<r>") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toHaveBeenLastCalledWith", "<green>expected<r>");
 
         incrementExpectCallCounter();
 
         const calls = JSMockFunction__getCalls(value);
 
         if (calls == .zero or !calls.jsType().isArray()) {
-            globalThis.throw("Expected value must be a mock function: {}", .{value});
-            return .zero;
+            return globalThis.throw("Expected value must be a mock function: {}", .{value});
         }
 
         const totalCalls = @as(u32, @intCast(calls.getLength(globalThis)));
@@ -4281,8 +4137,7 @@ pub const Expect = struct {
             lastCallValue = calls.getIndex(globalThis, totalCalls - 1);
 
             if (lastCallValue == .zero or !lastCallValue.jsType().isArray()) {
-                globalThis.throw("Expected value must be a mock function with calls: {}", .{value});
-                return .zero;
+                return globalThis.throw("Expected value must be a mock function with calls: {}", .{value});
             }
 
             if (lastCallValue.getLength(globalThis) != arguments.len) {
@@ -4290,7 +4145,7 @@ pub const Expect = struct {
             } else {
                 var itr = lastCallValue.arrayIterator(globalThis);
                 while (itr.next()) |callArg| {
-                    if (!callArg.jestDeepEquals(arguments[itr.i - 1], globalThis)) {
+                    if (!try callArg.jestDeepEquals(arguments[itr.i - 1], globalThis)) {
                         pass = false;
                         break;
                     }
@@ -4308,36 +4163,32 @@ pub const Expect = struct {
 
         if (not) {
             const signature = comptime getSignature("toHaveBeenLastCalledWith", "<green>expected<r>", true);
-            this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>" ++ "\n\n" ++ "Number of calls: <red>{any}<r>\n", .{ received_fmt, totalCalls });
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>" ++ "\n\n" ++ "Number of calls: <red>{any}<r>\n", .{ received_fmt, totalCalls });
         }
 
         const signature = comptime getSignature("toHaveBeenLastCalledWith", "<green>expected<r>", false);
-        this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>" ++ "\n\n" ++ "Number of calls: <red>{any}<r>\n", .{ received_fmt, totalCalls });
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ "Received: <red>{any}<r>" ++ "\n\n" ++ "Number of calls: <red>{any}<r>\n", .{ received_fmt, totalCalls });
     }
 
-    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();
         const arguments = callframe.argumentsPtr()[0..callframe.argumentsCount()];
         defer this.postMatch(globalThis);
-        const value: JSValue = this.getValue(globalThis, thisValue, "toHaveBeenNthCalledWith", "<green>expected<r>") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, "toHaveBeenNthCalledWith", "<green>expected<r>");
 
         incrementExpectCallCounter();
 
         const calls = JSMockFunction__getCalls(value);
 
         if (calls == .zero or !calls.jsType().isArray()) {
-            globalThis.throw("Expected value must be a mock function: {}", .{value});
-            return .zero;
+            return globalThis.throw("Expected value must be a mock function: {}", .{value});
         }
 
         const nthCallNum = if (arguments.len > 0 and arguments[0].isUInt32AsAnyInt()) arguments[0].coerce(i32, globalThis) else 0;
         if (nthCallNum < 1) {
-            globalThis.throwInvalidArguments("toHaveBeenNthCalledWith() requires a positive integer argument", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("toHaveBeenNthCalledWith() requires a positive integer argument", .{});
         }
 
         const totalCalls = calls.getLength(globalThis);
@@ -4349,8 +4200,7 @@ pub const Expect = struct {
             nthCallValue = calls.getIndex(globalThis, @as(u32, @intCast(nthCallNum)) - 1);
 
             if (nthCallValue == .zero or !nthCallValue.jsType().isArray()) {
-                globalThis.throw("Expected value must be a mock function with calls: {}", .{value});
-                return .zero;
+                return globalThis.throw("Expected value must be a mock function with calls: {}", .{value});
             }
 
             if (nthCallValue.getLength(globalThis) != (arguments.len - 1)) {
@@ -4358,7 +4208,7 @@ pub const Expect = struct {
             } else {
                 var itr = nthCallValue.arrayIterator(globalThis);
                 while (itr.next()) |callArg| {
-                    if (!callArg.jestDeepEquals(arguments[itr.i], globalThis)) {
+                    if (!try callArg.jestDeepEquals(arguments[itr.i], globalThis)) {
                         pass = false;
                         break;
                     }
@@ -4376,13 +4226,11 @@ pub const Expect = struct {
 
         if (not) {
             const signature = comptime getSignature("toHaveBeenNthCalledWith", "<green>expected<r>", true);
-            this.throw(globalThis, signature, "\n\n" ++ "n: {any}\n" ++ "Received: <red>{any}<r>" ++ "\n\n" ++ "Number of calls: <red>{any}<r>\n", .{ nthCallNum, received_fmt, totalCalls });
-            return .zero;
+            return this.throw(globalThis, signature, "\n\n" ++ "n: {any}\n" ++ "Received: <red>{any}<r>" ++ "\n\n" ++ "Number of calls: <red>{any}<r>\n", .{ nthCallNum, received_fmt, totalCalls });
         }
 
         const signature = comptime getSignature("toHaveBeenNthCalledWith", "<green>expected<r>", false);
-        this.throw(globalThis, signature, "\n\n" ++ "n: {any}\n" ++ "Received: <red>{any}<r>" ++ "\n\n" ++ "Number of calls: <red>{any}<r>\n", .{ nthCallNum, received_fmt, totalCalls });
-        return .zero;
+        return this.throw(globalThis, signature, "\n\n" ++ "n: {any}\n" ++ "Received: <red>{any}<r>" ++ "\n\n" ++ "Number of calls: <red>{any}<r>\n", .{ nthCallNum, received_fmt, totalCalls });
     }
 
     const ReturnStatus = enum {
@@ -4393,30 +4241,28 @@ pub const Expect = struct {
         pub const Map = bun.ComptimeEnumMap(ReturnStatus);
     };
 
-    inline fn toHaveReturnedTimesFn(this: *Expect, globalThis: *JSGlobalObject, callframe: *CallFrame, comptime known_index: ?i32) JSValue {
+    inline fn toHaveReturnedTimesFn(this: *Expect, globalThis: *JSGlobalObject, callframe: *CallFrame, comptime known_index: ?i32) bun.JSError!JSValue {
         JSC.markBinding(@src());
 
         const thisValue = callframe.this();
-        const arguments = callframe.arguments(1).slice();
+        const arguments = callframe.arguments_old(1).slice();
         defer this.postMatch(globalThis);
 
         const name = comptime if (known_index != null and known_index.? == 0) "toHaveReturned" else "toHaveReturnedTimes";
 
-        const value: JSValue = this.getValue(globalThis, thisValue, name, if (known_index != null and known_index.? == 0) "" else "<green>expected<r>") orelse return .zero;
+        const value: JSValue = try this.getValue(globalThis, thisValue, name, if (known_index != null and known_index.? == 0) "" else "<green>expected<r>");
 
         incrementExpectCallCounter();
 
         const returns = JSMockFunction__getReturns(value);
 
         if (returns == .zero or !returns.jsType().isArray()) {
-            globalThis.throw("Expected value must be a mock function: {}", .{value});
-            return .zero;
+            return globalThis.throw("Expected value must be a mock function: {}", .{value});
         }
 
         const return_count: i32 = if (known_index) |index| index else brk: {
             if (arguments.len < 1 or !arguments[0].isUInt32AsAnyInt()) {
-                globalThis.throwInvalidArguments(name ++ "() requires 1 non-negative integer argument", .{});
-                return .zero;
+                return globalThis.throwInvalidArguments(name ++ "() requires 1 non-negative integer argument", .{});
             }
 
             break :brk arguments[0].coerce(i32, globalThis);
@@ -4438,11 +4284,11 @@ pub const Expect = struct {
             //  { type: "throw" | "incomplete" | "return", value: any}
             //
             if (total_count >= return_count and times_value.isCell()) {
-                if (times_value.get(globalThis, "type")) |type_string| {
+                if (try times_value.get(globalThis, "type")) |type_string| {
                     if (type_string.isString()) {
                         break :brk ReturnStatus.Map.fromJS(globalThis, type_string) orelse {
                             if (!globalThis.hasException())
-                                globalThis.throw("Expected value must be a mock function with returns: {}", .{value});
+                                return globalThis.throw("Expected value must be a mock function with returns: {}", .{value});
                             return .zero;
                         };
                     }
@@ -4467,31 +4313,28 @@ pub const Expect = struct {
                 .globalThis = globalThis,
                 .quote_strings = true,
             };
-            globalThis.throwPretty(fmt, .{times_value.get(globalThis, "value").?.toFmt(&formatter)});
-            return .zero;
+            return globalThis.throwPretty(fmt, .{(try times_value.get(globalThis, "value")).?.toFmt(&formatter)});
         }
 
         switch (not) {
             inline else => |is_not| {
                 const signature = comptime getSignature(name, "<green>expected<r>", is_not);
-                this.throw(globalThis, signature, "\n\n" ++ "Expected number of successful calls: <green>{d}<r>\n" ++ "Received number of calls: <red>{d}<r>\n", .{ return_count, total_count });
-                return .zero;
+                return this.throw(globalThis, signature, "\n\n" ++ "Expected number of successful calls: <green>{d}<r>\n" ++ "Received number of calls: <red>{d}<r>\n", .{ return_count, total_count });
             },
         }
     }
 
-    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);
     }
 
     pub const toHaveReturnedWith = notImplementedJSCFn;
     pub const toHaveLastReturnedWith = notImplementedJSCFn;
     pub const toHaveNthReturnedWith = notImplementedJSCFn;
-    pub const toMatchInlineSnapshot = notImplementedJSCFn;
     pub const toThrowErrorMatchingSnapshot = notImplementedJSCFn;
     pub const toThrowErrorMatchingInlineSnapshot = notImplementedJSCFn;
 
@@ -4507,41 +4350,40 @@ 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 {
-        const args = callFrame.arguments(1).slice();
+    pub fn extend(globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
+        const args = callFrame.arguments_old(1).slice();
 
         if (args.len == 0 or !args[0].isObject()) {
-            globalThis.throwPretty("<d>expect.<r>extend<d>(<r>matchers<d>)<r>\n\nExpected an object containing matchers\n", .{});
-            return .zero;
+            return globalThis.throwPretty("<d>expect.<r>extend<d>(<r>matchers<d>)<r>\n\nExpected an object containing matchers\n", .{});
         }
 
         var expect_proto = Expect__getPrototype(globalThis);
@@ -4561,15 +4403,14 @@ pub const Expect = struct {
 
                 if (!matcher_fn.jsType().isFunction()) {
                     const type_name = if (matcher_fn.isNull()) bun.String.static("null") else bun.String.init(matcher_fn.jsTypeString(globalThis).getZigString(globalThis));
-                    globalThis.throwInvalidArguments("expect.extend: `{s}` is not a valid matcher. Must be a function, is \"{s}\"", .{ matcher_name, type_name });
-                    return .zero;
+                    return globalThis.throwInvalidArguments("expect.extend: `{s}` is not a valid matcher. Must be a function, is \"{s}\"", .{ matcher_name, type_name });
                 }
 
                 // Mutate the Expect/ExpectStatic prototypes/constructor with new instances of JSCustomExpectMatcherFunction.
                 // 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);
@@ -4629,7 +4470,7 @@ pub const Expect = struct {
         }
     };
 
-    fn throwInvalidMatcherError(globalThis: *JSGlobalObject, matcher_name: bun.String, result: JSValue) void {
+    fn throwInvalidMatcherError(globalThis: *JSGlobalObject, matcher_name: bun.String, result: JSValue) bun.JSError {
         @setCold(true);
 
         var formatter = JSC.ConsoleObject.Formatter{
@@ -4645,30 +4486,22 @@ pub const Expect = struct {
         const err = switch (Output.enable_ansi_colors) {
             inline else => |colors| globalThis.createErrorInstance(Output.prettyFmt(fmt, colors), .{ matcher_name, result.toFmt(&formatter) }),
         };
-        err.put(globalThis, ZigString.static("name"), ZigString.init("InvalidMatcherError").toJS(globalThis));
-        globalThis.throwValue(err);
+        err.put(globalThis, ZigString.static("name"), bun.String.static("InvalidMatcherError").toJS(globalThis));
+        return globalThis.throwValue(err);
     }
 
     /// Execute the custom matcher for the given args (the left value + the args passed to the matcher call).
     /// This function is called both for symmetric and asymmetric matching.
     /// If silent=false, throws an exception in JS if the matcher result didn't result in a pass (or if the matcher result is invalid).
-    pub fn executeCustomMatcher(globalThis: *JSGlobalObject, matcher_name: bun.String, matcher_fn: JSValue, args: []const JSValue, flags: Expect.Flags, silent: bool) bool {
+    pub fn executeCustomMatcher(globalThis: *JSGlobalObject, matcher_name: bun.String, matcher_fn: JSValue, args: []const JSValue, flags: Expect.Flags, silent: bool) bun.JSError!bool {
         // prepare the this object
-        const matcher_context = globalThis.bunVM().allocator.create(ExpectMatcherContext) catch {
-            globalThis.throwOutOfMemory();
-            return false;
-        };
+        const matcher_context = try globalThis.bunVM().allocator.create(ExpectMatcherContext);
         matcher_context.flags = flags;
         const matcher_context_jsvalue = matcher_context.toJS(globalThis);
         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 = try matcher_fn.call(globalThis, matcher_context_jsvalue, args);
         // support for async matcher results
         if (result.asAnyPromise()) |promise| {
             const vm = globalThis.vm();
@@ -4678,15 +4511,14 @@ pub const Expect = struct {
 
             result = promise.result(vm);
             result.ensureStillAlive();
-            assert(!result.isEmpty());
+            assert(result != .zero);
             switch (promise.status(vm)) {
                 .pending => unreachable,
                 .fulfilled => {},
                 .rejected => {
                     // TODO: rewrite this code to use .then() instead of blocking the event loop
                     JSC.VirtualMachine.get().runErrorHandler(result, null);
-                    globalThis.throw("Matcher `{s}` returned a promise that rejected", .{matcher_name});
-                    return false;
+                    return globalThis.throw("Matcher `{s}` returned a promise that rejected", .{matcher_name});
                 },
             }
         }
@@ -4697,8 +4529,8 @@ pub const Expect = struct {
         // Parse and validate the custom matcher result, which should conform to: { pass: boolean, message?: () => string }
         const is_valid = valid: {
             if (result.isObject()) {
-                if (result.get(globalThis, "pass")) |pass_value| {
-                    pass = pass_value.toBooleanSlow(globalThis);
+                if (try result.get(globalThis, "pass")) |pass_value| {
+                    pass = pass_value.toBoolean();
                     if (globalThis.hasException()) return false;
 
                     if (result.fastGet(globalThis, .message)) |message_value| {
@@ -4716,8 +4548,7 @@ pub const Expect = struct {
             break :valid false;
         };
         if (!is_valid) {
-            throwInvalidMatcherError(globalThis, matcher_name, result);
-            return false;
+            return throwInvalidMatcherError(globalThis, matcher_name, result);
         }
 
         if (flags.not) pass = !pass;
@@ -4734,27 +4565,8 @@ 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;
-            }
-            if (bun.String.tryFromJS(message_result, globalThis)) |str| {
-                message_text = str;
-            } else {
-                if (globalThis.hasException()) return false;
-                var formatter = JSC.ConsoleObject.Formatter{
-                    .globalThis = globalThis,
-                    .quote_strings = true,
-                };
-                globalThis.throw(
-                    "Expected custom matcher message to return a string, but got: {}",
-                    .{message_result.toFmt(&formatter)},
-                );
-                return false;
-            }
+            const message_result = try message.callWithGlobalThis(globalThis, &.{});
+            message_text = try bun.String.fromJS2(message_result, globalThis);
         }
 
         const matcher_params = CustomMatcherParamsFormatter{
@@ -4762,21 +4574,19 @@ pub const Expect = struct {
             .globalThis = globalThis,
             .matcher_fn = matcher_fn,
         };
-        throwPrettyMatcherError(globalThis, bun.String.empty, matcher_name, matcher_params, .{}, "{s}", .{message_text});
-        return false;
+        return throwPrettyMatcherError(globalThis, bun.String.empty, matcher_name, matcher_params, .{}, "{s}", .{message_text});
     }
 
     /// 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)
         const func: JSValue = callFrame.callee();
         var matcher_fn = getCustomMatcherFn(func, globalThis) orelse JSValue.undefined;
         if (!matcher_fn.jsType().isFunction()) {
-            globalThis.throw("Internal consistency error: failed to retrieve the matcher function for a custom matcher!", .{});
-            return .zero;
+            return globalThis.throw("Internal consistency error: failed to retrieve the matcher function for a custom matcher!", .{});
         }
         matcher_fn.ensureStillAlive();
 
@@ -4801,10 +4611,9 @@ pub const Expect = struct {
 
         // retrieve the captured expected value
         var value = Expect.capturedValueGetCached(thisValue) orelse {
-            globalThis.throw("Internal consistency error: failed to retrieve the captured value", .{});
-            return .zero;
+            return globalThis.throw("Internal consistency error: failed to retrieve the captured value", .{});
         };
-        value = Expect.processPromise(expect.custom_label, expect.flags, globalThis, value, matcher_name, matcher_params, false) orelse return .zero;
+        value = try Expect.processPromise(expect.custom_label, expect.flags, globalThis, value, matcher_name, matcher_params, false);
         value.ensureStillAlive();
 
         incrementExpectCallCounter();
@@ -4813,24 +4622,18 @@ pub const Expect = struct {
         const args_ptr = callFrame.argumentsPtr();
         const args_count = callFrame.argumentsCount();
         var allocator = std.heap.stackFallback(8 * @sizeOf(JSValue), globalThis.allocator());
-        var matcher_args = std.ArrayList(JSValue).initCapacity(allocator.get(), args_count + 1) catch {
-            globalThis.throwOutOfMemory();
-            return .zero;
-        };
+        var matcher_args = try std.ArrayList(JSValue).initCapacity(allocator.get(), args_count + 1);
         matcher_args.appendAssumeCapacity(value);
         for (0..args_count) |i| matcher_args.appendAssumeCapacity(args_ptr[i]);
 
-        // call the matcher, which will throw a js exception when failed
-        if (!executeCustomMatcher(globalThis, matcher_name, matcher_fn, matcher_args.items, expect.flags, false) or globalThis.hasException()) {
-            return .zero;
-        }
+        _ = try executeCustomMatcher(globalThis, matcher_name, matcher_fn, matcher_args.items, expect.flags, false);
 
         return thisValue;
     }
 
     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,30 +4642,27 @@ 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);
+        const arguments_ = callFrame.arguments_old(1);
         const arguments = arguments_.slice();
 
         if (arguments.len < 1) {
-            globalThis.throwInvalidArguments("expect.assertions() takes 1 argument", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("expect.assertions() takes 1 argument", .{});
         }
 
         const expected: JSValue = arguments[0];
 
         if (!expected.isNumber()) {
             var fmt = JSC.ConsoleObject.Formatter{ .globalThis = globalThis, .quote_strings = true };
-            globalThis.throw("Expected value must be a non-negative integer: {any}", .{expected.toFmt(&fmt)});
-            return .zero;
+            return globalThis.throw("Expected value must be a non-negative integer: {any}", .{expected.toFmt(&fmt)});
         }
 
         const expected_assertions: f64 = expected.coerceToDouble(globalThis);
         if (@round(expected_assertions) != expected_assertions or std.math.isInf(expected_assertions) or std.math.isNan(expected_assertions) or expected_assertions < 0 or expected_assertions > std.math.maxInt(u32)) {
             var fmt = JSC.ConsoleObject.Formatter{ .globalThis = globalThis, .quote_strings = true };
-            globalThis.throw("Expected value must be a non-negative integer: {any}", .{expected.toFmt(&fmt)});
-            return .zero;
+            return globalThis.throw("Expected value must be a non-negative integer: {any}", .{expected.toFmt(&fmt)});
         }
 
         const unsigned_expected_assertions: u32 = @intFromFloat(expected_assertions);
@@ -4873,24 +4673,20 @@ pub const Expect = struct {
         return .undefined;
     }
 
-    pub fn notImplementedJSCFn(_: *Expect, globalThis: *JSGlobalObject, _: *CallFrame) JSValue {
-        globalThis.throw("Not implemented", .{});
-        return .zero;
+    pub fn notImplementedJSCFn(_: *Expect, globalThis: *JSGlobalObject, _: *CallFrame) bun.JSError!JSValue {
+        return globalThis.throw("Not implemented", .{});
     }
 
-    pub fn notImplementedStaticFn(globalThis: *JSGlobalObject, _: *CallFrame) JSValue {
-        globalThis.throw("Not implemented", .{});
-        return .zero;
+    pub fn notImplementedStaticFn(globalThis: *JSGlobalObject, _: *CallFrame) bun.JSError!JSValue {
+        return globalThis.throw("Not implemented", .{});
     }
 
-    pub fn notImplementedJSCProp(_: *Expect, _: JSValue, globalThis: *JSGlobalObject) JSValue {
-        globalThis.throw("Not implemented", .{});
-        return .zero;
+    pub fn notImplementedJSCProp(_: *Expect, _: JSValue, globalThis: *JSGlobalObject) bun.JSError!JSValue {
+        return globalThis.throw("Not implemented", .{});
     }
 
-    pub fn notImplementedStaticProp(globalThis: *JSGlobalObject, _: JSValue, _: JSValue) JSValue {
-        globalThis.throw("Not implemented", .{});
-        return .zero;
+    pub fn notImplementedStaticProp(globalThis: *JSGlobalObject, _: JSValue, _: JSValue) bun.JSError!JSValue {
+        return globalThis.throw("Not implemented", .{});
     }
 
     pub fn postMatch(_: *Expect, globalThis: *JSGlobalObject) void {
@@ -4898,25 +4694,22 @@ pub const Expect = struct {
         vm.autoGarbageCollect();
     }
 
-    pub fn doUnreachable(globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
-        const arg = callframe.arguments(1).ptr[0];
+    pub fn doUnreachable(globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
+        const arg = callframe.arguments_old(1).ptr[0];
 
         if (arg.isEmptyOrUndefinedOrNull()) {
             const error_value = bun.String.init("reached unreachable code").toErrorInstance(globalThis);
             error_value.put(globalThis, ZigString.static("name"), bun.String.init("UnreachableError").toJS(globalThis));
-            globalThis.throwValue(error_value);
-            return .zero;
+            return globalThis.throwValue(error_value);
         }
 
         if (arg.isString()) {
             const error_value = arg.toBunString(globalThis).toErrorInstance(globalThis);
             error_value.put(globalThis, ZigString.static("name"), bun.String.init("UnreachableError").toJS(globalThis));
-            globalThis.throwValue(error_value);
-            return .zero;
+            return globalThis.throwValue(error_value);
         }
 
-        globalThis.throwValue(arg);
-        return .zero;
+        return globalThis.throwValue(arg);
     }
 };
 
@@ -4935,8 +4728,7 @@ pub const ExpectStatic = struct {
 
     pub fn create(globalThis: *JSGlobalObject, flags: Expect.Flags) JSValue {
         var expect = globalThis.bunVM().allocator.create(ExpectStatic) catch {
-            globalThis.throwOutOfMemory();
-            return .zero;
+            return globalThis.throwOutOfMemoryValue();
         };
         expect.flags = flags;
 
@@ -4953,67 +4745,65 @@ pub const ExpectStatic = struct {
 
     pub fn getResolvesTo(this: *ExpectStatic, _: JSValue, globalThis: *JSGlobalObject) JSValue {
         var flags = this.flags;
-        if (flags.promise != .none) return asyncChainingError(globalThis, flags, "resolvesTo");
+        if (flags.promise != .none) return asyncChainingError(globalThis, flags, "resolvesTo") catch .zero;
         flags.promise = .resolves;
         return create(globalThis, flags);
     }
 
     pub fn getRejectsTo(this: *ExpectStatic, _: JSValue, globalThis: *JSGlobalObject) JSValue {
         var flags = this.flags;
-        if (flags.promise != .none) return asyncChainingError(globalThis, flags, "rejectsTo");
+        if (flags.promise != .none) return asyncChainingError(globalThis, flags, "rejectsTo") catch .zero;
         flags.promise = .rejects;
         return create(globalThis, flags);
     }
 
-    fn asyncChainingError(globalThis: *JSGlobalObject, flags: Expect.Flags, name: string) JSValue {
+    fn asyncChainingError(globalThis: *JSGlobalObject, flags: Expect.Flags, name: string) bun.JSError!JSValue {
         @setCold(true);
         const str = switch (flags.promise) {
             .resolves => "resolvesTo",
             .rejects => "rejectsTo",
             else => unreachable,
         };
-        globalThis.throw("expect.{s}: already called expect.{s} on this chain", .{ name, str });
-        return .zero;
+        return globalThis.throw("expect.{s}: already called expect.{s} on this chain", .{ name, str });
     }
 
-    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;
+                return globalThis.throwOutOfMemory();
             };
             instance.flags = this.flags;
         }
         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,11 +4819,8 @@ pub const ExpectAnything = struct {
         VirtualMachine.get().allocator.destroy(this);
     }
 
-    pub fn call(globalThis: *JSGlobalObject, _: *CallFrame) JSValue {
-        const anything = globalThis.bunVM().allocator.create(ExpectAnything) catch {
-            globalThis.throwOutOfMemory();
-            return .zero;
-        };
+    pub fn call(globalThis: *JSGlobalObject, _: *CallFrame) bun.JSError!JSValue {
+        const anything = try globalThis.bunVM().allocator.create(ExpectAnything);
         anything.* = .{};
 
         const anything_js_value = anything.toJS(globalThis);
@@ -5057,21 +4844,17 @@ pub const ExpectStringMatching = struct {
         VirtualMachine.get().allocator.destroy(this);
     }
 
-    pub fn call(globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
-        const args = callFrame.arguments(1).slice();
+    pub fn call(globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
+        const args = callFrame.arguments_old(1).slice();
 
         if (args.len == 0 or (!args[0].isString() and !args[0].isRegExp())) {
             const fmt = "<d>expect.<r>stringContaining<d>(<r>string<d>)<r>\n\nExpected a string or regular expression\n";
-            globalThis.throwPretty(fmt, .{});
-            return .zero;
+            return globalThis.throwPretty(fmt, .{});
         }
 
         const test_value = args[0];
 
-        const string_matching = globalThis.bunVM().allocator.create(ExpectStringMatching) catch {
-            globalThis.throwOutOfMemory();
-            return .zero;
-        };
+        const string_matching = try globalThis.bunVM().allocator.create(ExpectStringMatching);
         string_matching.* = .{};
 
         const string_matching_js_value = string_matching.toJS(globalThis);
@@ -5094,12 +4877,11 @@ pub const ExpectCloseTo = struct {
         VirtualMachine.get().allocator.destroy(this);
     }
 
-    pub fn call(globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
-        const args = callFrame.arguments(2).slice();
+    pub fn call(globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
+        const args = callFrame.arguments_old(2).slice();
 
         if (args.len == 0 or !args[0].isNumber()) {
-            globalThis.throwPretty("<d>expect.<r>closeTo<d>(<r>number<d>, precision?)<r>\n\nExpected a number value", .{});
-            return .zero;
+            return globalThis.throwPretty("<d>expect.<r>closeTo<d>(<r>number<d>, precision?)<r>\n\nExpected a number value", .{});
         }
         const number_value = args[0];
 
@@ -5108,14 +4890,10 @@ pub const ExpectCloseTo = struct {
             precision_value = JSValue.jsNumberFromInt32(2); // default value from jest
         }
         if (!precision_value.isNumber()) {
-            globalThis.throwPretty("<d>expect.<r>closeTo<d>(number, <r>precision?<d>)<r>\n\nPrecision must be a number or undefined", .{});
-            return .zero;
+            return globalThis.throwPretty("<d>expect.<r>closeTo<d>(number, <r>precision?<d>)<r>\n\nPrecision must be a number or undefined", .{});
         }
 
-        const instance = globalThis.bunVM().allocator.create(ExpectCloseTo) catch {
-            globalThis.throwOutOfMemory();
-            return .zero;
-        };
+        const instance = try globalThis.bunVM().allocator.create(ExpectCloseTo);
         instance.* = .{};
 
         const instance_jsvalue = instance.toJS(globalThis);
@@ -5141,21 +4919,17 @@ pub const ExpectObjectContaining = struct {
         VirtualMachine.get().allocator.destroy(this);
     }
 
-    pub fn call(globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
-        const args = callFrame.arguments(1).slice();
+    pub fn call(globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
+        const args = callFrame.arguments_old(1).slice();
 
         if (args.len == 0 or !args[0].isObject()) {
             const fmt = "<d>expect.<r>objectContaining<d>(<r>object<d>)<r>\n\nExpected an object\n";
-            globalThis.throwPretty(fmt, .{});
-            return .zero;
+            return globalThis.throwPretty(fmt, .{});
         }
 
         const object_value = args[0];
 
-        const instance = globalThis.bunVM().allocator.create(ExpectObjectContaining) catch {
-            globalThis.throwOutOfMemory();
-            return .zero;
-        };
+        const instance = try globalThis.bunVM().allocator.create(ExpectObjectContaining);
         instance.* = .{};
 
         const instance_jsvalue = instance.toJS(globalThis);
@@ -5178,21 +4952,17 @@ pub const ExpectStringContaining = struct {
         VirtualMachine.get().allocator.destroy(this);
     }
 
-    pub fn call(globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
-        const args = callFrame.arguments(1).slice();
+    pub fn call(globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
+        const args = callFrame.arguments_old(1).slice();
 
         if (args.len == 0 or !args[0].isString()) {
             const fmt = "<d>expect.<r>stringContaining<d>(<r>string<d>)<r>\n\nExpected a string\n";
-            globalThis.throwPretty(fmt, .{});
-            return .zero;
+            return globalThis.throwPretty(fmt, .{});
         }
 
         const string_value = args[0];
 
-        const string_containing = globalThis.bunVM().allocator.create(ExpectStringContaining) catch {
-            globalThis.throwOutOfMemory();
-            return .zero;
-        };
+        const string_containing = try globalThis.bunVM().allocator.create(ExpectStringContaining);
         string_containing.* = .{};
 
         const string_containing_js_value = string_containing.toJS(globalThis);
@@ -5209,40 +4979,33 @@ 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 {
-        const _arguments = callFrame.arguments(1);
+    pub fn call(globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
+        const _arguments = callFrame.arguments_old(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.throw("any() expects to be passed a constructor function. Please pass one or use anything() to match any object.", .{});
         }
 
         const constructor = arguments[0];
         constructor.ensureStillAlive();
         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 globalThis.throwPretty(fmt, .{});
         }
 
-        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;
-        };
+        var any = try globalThis.bunVM().allocator.create(ExpectAny);
         any.* = .{
             .flags = .{
                 .asymmetric_matcher_constructor_type = asymmetric_matcher_constructor_type,
@@ -5272,21 +5035,17 @@ pub const ExpectArrayContaining = struct {
         VirtualMachine.get().allocator.destroy(this);
     }
 
-    pub fn call(globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
-        const args = callFrame.arguments(1).slice();
+    pub fn call(globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
+        const args = callFrame.arguments_old(1).slice();
 
         if (args.len == 0 or !args[0].jsType().isArray()) {
             const fmt = "<d>expect.<r>arrayContaining<d>(<r>array<d>)<r>\n\nExpected a array\n";
-            globalThis.throwPretty(fmt, .{});
-            return .zero;
+            return globalThis.throwPretty(fmt, .{});
         }
 
         const array_value = args[0];
 
-        const array_containing = globalThis.bunVM().allocator.create(ExpectArrayContaining) catch {
-            globalThis.throwOutOfMemory();
-            return .zero;
-        };
+        const array_containing = try globalThis.bunVM().allocator.create(ExpectArrayContaining);
         array_containing.* = .{};
 
         const array_containing_js_value = array_containing.toJS(globalThis);
@@ -5316,7 +5075,7 @@ pub const ExpectCustomAsymmetricMatcher = struct {
     /// Implements the static call of the custom matcher (`expect.myCustomMatcher(<args>)`),
     /// which creates an asymmetric matcher instance (`ExpectCustomAsymmetricMatcher`).
     /// This will not run the matcher, but just capture the args etc.
-    pub fn create(globalThis: *JSGlobalObject, callFrame: *CallFrame, matcher_fn: JSValue) JSValue {
+    pub fn create(globalThis: *JSGlobalObject, callFrame: *CallFrame, matcher_fn: JSValue) bun.JSError!JSValue {
         var flags: Expect.Flags = undefined;
 
         // try to retrieve the ExpectStatic instance (to get the flags)
@@ -5328,10 +5087,7 @@ pub const ExpectCustomAsymmetricMatcher = struct {
         }
 
         // create the matcher instance
-        const instance = globalThis.bunVM().allocator.create(ExpectCustomAsymmetricMatcher) catch {
-            globalThis.throwOutOfMemory();
-            return .zero;
-        };
+        const instance = try globalThis.bunVM().allocator.create(ExpectCustomAsymmetricMatcher);
         instance.* = .{};
 
         const instance_jsvalue = instance.toJS(globalThis);
@@ -5361,12 +5117,12 @@ pub const ExpectCustomAsymmetricMatcher = struct {
     pub fn execute(this: *ExpectCustomAsymmetricMatcher, thisValue: JSValue, globalThis: *JSGlobalObject, received: JSValue) callconv(.C) bool {
         // retrieve the user-provided matcher implementation function (the function passed to expect.extend({ ... }))
         const matcher_fn: JSValue = ExpectCustomAsymmetricMatcher.matcherFnGetCached(thisValue) orelse {
-            globalThis.throw("Internal consistency error: the ExpectCustomAsymmetricMatcher(matcherFn) was garbage collected but it should not have been!", .{});
+            globalThis.throw("Internal consistency error: the ExpectCustomAsymmetricMatcher(matcherFn) was garbage collected but it should not have been!", .{}) catch {};
             return false;
         };
         matcher_fn.ensureStillAlive();
         if (!matcher_fn.jsType().isFunction()) {
-            globalThis.throw("Internal consistency error: the ExpectCustomMatcher(matcherFn) is not a function!", .{});
+            globalThis.throw("Internal consistency error: the ExpectCustomMatcher(matcherFn) is not a function!", .{}) catch {};
             return false;
         }
 
@@ -5376,7 +5132,7 @@ pub const ExpectCustomAsymmetricMatcher = struct {
         // retrieve the asymmetric matcher args
         // if null, it means the function has not yet been called to capture the args, which is a misuse of the matcher
         const captured_args: JSValue = ExpectCustomAsymmetricMatcher.capturedArgsGetCached(thisValue) orelse {
-            globalThis.throw("expect.{s} misused, it needs to be instantiated by calling it with 0 or more arguments", .{matcher_name});
+            globalThis.throw("expect.{s} misused, it needs to be instantiated by calling it with 0 or more arguments", .{matcher_name}) catch {};
             return false;
         };
         captured_args.ensureStillAlive();
@@ -5385,7 +5141,7 @@ pub const ExpectCustomAsymmetricMatcher = struct {
         const args_count = captured_args.getLength(globalThis);
         var allocator = std.heap.stackFallback(8 * @sizeOf(JSValue), globalThis.allocator());
         var matcher_args = std.ArrayList(JSValue).initCapacity(allocator.get(), args_count + 1) catch {
-            globalThis.throwOutOfMemory();
+            globalThis.throwOutOfMemory() catch {};
             return false;
         };
         matcher_args.appendAssumeCapacity(received);
@@ -5393,11 +5149,11 @@ pub const ExpectCustomAsymmetricMatcher = struct {
             matcher_args.appendAssumeCapacity(captured_args.getIndex(globalThis, @truncate(i)));
         }
 
-        return Expect.executeCustomMatcher(globalThis, matcher_name, matcher_fn, matcher_args.items, this.flags, true);
+        return Expect.executeCustomMatcher(globalThis, matcher_name, matcher_fn, matcher_args.items, this.flags, true) catch false;
     }
 
-    pub fn asymmetricMatch(this: *ExpectCustomAsymmetricMatcher, globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
-        const arguments = callframe.arguments(1).slice();
+    pub fn asymmetricMatch(this: *ExpectCustomAsymmetricMatcher, globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
+        const arguments = callframe.arguments_old(1).slice();
         const received_value = if (arguments.len < 1) JSValue.jsUndefined() else arguments[0];
         const matched = execute(this, callframe.this(), globalThis, received_value);
         return JSValue.jsBoolean(matched);
@@ -5406,7 +5162,7 @@ pub const ExpectCustomAsymmetricMatcher = struct {
     /// Calls a custom implementation (if provided) to stringify this asymmetric matcher, and returns true if it was provided and it succeed
     pub fn customPrint(_: *ExpectCustomAsymmetricMatcher, thisValue: JSValue, globalThis: *JSGlobalObject, writer: anytype, comptime dontThrow: bool) !bool {
         const matcher_fn: JSValue = ExpectCustomAsymmetricMatcher.matcherFnGetCached(thisValue) orelse return false;
-        if (matcher_fn.get(globalThis, "toAsymmetricMatcher")) |fn_value| {
+        if (matcher_fn.get_unsafe(globalThis, "toAsymmetricMatcher")) |fn_value| {
             if (fn_value.jsType().isFunction()) {
                 const captured_args: JSValue = ExpectCustomAsymmetricMatcher.capturedArgsGetCached(thisValue) orelse return false;
                 var stack_fallback = std.heap.stackFallback(256, globalThis.allocator());
@@ -5430,20 +5186,14 @@ 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();
-            return .zero;
-        };
+        var mutable_string = try bun.MutableString.init2048(stack_fallback.get());
         defer mutable_string.deinit();
 
-        const printed = customPrint(this, callframe.this(), globalThis, mutable_string.writer()) catch {
-            globalThis.throwOutOfMemory();
-            return .zero;
-        };
+        const printed = try customPrint(this, callframe.this(), globalThis, mutable_string.writer());
         if (printed) {
-            return bun.String.init(mutable_string.toOwnedSliceLeaky()).toJS();
+            return bun.String.init(mutable_string.slice()).toJS();
         }
         return ExpectMatcherUtils.printValue(globalThis, this, null);
     }
@@ -5483,14 +5233,13 @@ pub const ExpectMatcherContext = struct {
         return JSValue.false;
     }
 
-    pub fn equals(_: *ExpectMatcherContext, globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
-        var arguments = callframe.arguments(3);
+    pub fn equals(_: *ExpectMatcherContext, globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
+        var arguments = callframe.arguments_old(3);
         if (arguments.len < 2) {
-            globalThis.throw("expect.extends matcher: this.util.equals expects at least 2 arguments", .{});
-            return .zero;
+            return globalThis.throw("expect.extends matcher: this.util.equals expects at least 2 arguments", .{});
         }
         const args = arguments.slice();
-        return JSValue.jsBoolean(args[0].jestDeepEquals(args[1], globalThis));
+        return JSValue.jsBoolean(try args[0].jestDeepEquals(args[1], globalThis));
     }
 };
 
@@ -5500,8 +5249,7 @@ pub const ExpectMatcherUtils = struct {
 
     fn createSingleton(globalThis: *JSGlobalObject) callconv(.C) JSValue {
         var instance = globalThis.bunVM().allocator.create(ExpectMatcherUtils) catch {
-            globalThis.throwOutOfMemory();
-            return .zero;
+            return globalThis.throwOutOfMemoryValue();
         };
         return instance.toJS(globalThis);
     }
@@ -5547,35 +5295,33 @@ pub const ExpectMatcherUtils = struct {
 
     inline fn printValueCatched(globalThis: *JSGlobalObject, value: JSValue, comptime color_or_null: ?[]const u8) JSValue {
         return printValue(globalThis, value, color_or_null) catch {
-            globalThis.throwOutOfMemory();
-            return .zero;
+            return globalThis.throwOutOfMemoryValue();
         };
     }
 
-    pub fn stringify(_: *ExpectMatcherUtils, globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
-        const arguments = callframe.arguments(1).slice();
+    pub fn stringify(_: *ExpectMatcherUtils, globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
+        const arguments = callframe.arguments_old(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 {
-        const arguments = callframe.arguments(1).slice();
+    pub fn printExpected(_: *ExpectMatcherUtils, globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
+        const arguments = callframe.arguments_old(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 {
-        const arguments = callframe.arguments(1).slice();
+    pub fn printReceived(_: *ExpectMatcherUtils, globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
+        const arguments = callframe.arguments_old(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 {
-        const arguments = callframe.arguments(4).slice();
+    pub fn matcherHint(_: *ExpectMatcherUtils, globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
+        const arguments = callframe.arguments_old(4).slice();
 
         if (arguments.len == 0 or !arguments[0].isString()) {
-            globalThis.throw("matcherHint: the first argument (matcher name) must be a string", .{});
-            return .zero;
+            return globalThis.throw("matcherHint: the first argument (matcher name) must be a string", .{});
         }
         const matcher_name = arguments[0].toBunString(globalThis);
         defer matcher_name.deref();
@@ -5595,19 +5341,18 @@ pub const ExpectMatcherUtils = struct {
 
         if (!options.isUndefinedOrNull()) {
             if (!options.isObject()) {
-                globalThis.throw("matcherHint: options must be an object (or undefined)", .{});
-                return .zero;
+                return globalThis.throw("matcherHint: options must be an object (or undefined)", .{});
             }
-            if (options.get(globalThis, "isNot")) |val| {
+            if (try options.get(globalThis, "isNot")) |val| {
                 is_not = val.coerce(bool, globalThis);
             }
-            if (options.get(globalThis, "comment")) |val| {
+            if (try options.get(globalThis, "comment")) |val| {
                 comment = val.toStringOrNull(globalThis);
             }
-            if (options.get(globalThis, "promise")) |val| {
+            if (try options.get(globalThis, "promise")) |val| {
                 promise = val.toStringOrNull(globalThis);
             }
-            if (options.get(globalThis, "secondArgument")) |val| {
+            if (try options.get(globalThis, "secondArgument")) |val| {
                 second_argument = val.toStringOrNull(globalThis);
             }
         }
@@ -5622,25 +5367,19 @@ pub const ExpectMatcherUtils = struct {
         if (is_not) {
             const signature = comptime Expect.getSignature("{s}", "<green>expected<r>", true);
             const fmt = signature ++ "\n\n{any}\n";
-            return JSValue.printStringPretty(globalThis, 2048, fmt, .{ matcher_name, diff_formatter }) catch {
-                globalThis.throwOutOfMemory();
-                return .zero;
-            };
+            return try JSValue.printStringPretty(globalThis, 2048, fmt, .{ matcher_name, diff_formatter });
         } else {
             const signature = comptime Expect.getSignature("{s}", "<green>expected<r>", false);
             const fmt = signature ++ "\n\n{any}\n";
-            return JSValue.printStringPretty(globalThis, 2048, fmt, .{ matcher_name, diff_formatter }) catch {
-                globalThis.throwOutOfMemory();
-                return .zero;
-            };
+            return try JSValue.printStringPretty(globalThis, 2048, fmt, .{ matcher_name, diff_formatter });
         }
     }
 };
 
 // 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 c057b69b57..4be73143aa 100644
--- a/src/bun.js/test/jest.zig
+++ b/src/bun.js/test/jest.zig
@@ -39,7 +39,6 @@ const JSInternalPromise = JSC.JSInternalPromise;
 const JSPromise = JSC.JSPromise;
 const JSValue = JSC.JSValue;
 const JSType = JSValue.JSType;
-const JSError = JSC.JSError;
 const JSGlobalObject = JSC.JSGlobalObject;
 const JSObject = JSC.JSObject;
 const CallFrame = JSC.CallFrame;
@@ -58,6 +57,7 @@ pub const Tag = enum(u3) {
     todo,
 };
 const debug = Output.scoped(.jest, false);
+var max_test_id_for_debugger: u32 = 0;
 pub const TestRunner = struct {
     tests: TestRunner.Test.List = .{},
     log: *logger.Log,
@@ -149,8 +149,12 @@ pub const TestRunner = struct {
         this.has_pending_tests = false;
         this.pending_test = null;
 
+        const vm = JSC.VirtualMachine.get();
+        vm.auto_killer.clear();
+        vm.auto_killer.disable();
+
         // disable idling
-        JSC.VirtualMachine.get().wakeup();
+        vm.wakeup();
     }
 
     pub fn drain(this: *TestRunner) void {
@@ -273,40 +277,30 @@ 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.throw("Cannot use " ++ name ++ "() outside of the test runner. Run \"bun test\" to run tests.", .{});
                 };
 
-                const arguments = callframe.arguments(2);
+                const arguments = callframe.arguments_old(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 globalThis.throwInvalidArgumentType(name, "callback", "function");
                 }
 
                 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.throw("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;
     }
@@ -523,25 +517,23 @@ 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);
         }
 
-        const arguments = callframe.arguments(2).slice();
+        const arguments = callframe.arguments_old(2).slice();
 
         if (arguments.len < 1 or !arguments[0].isString()) {
-            globalObject.throw("Bun.jest() expects a string filename", .{});
-            return .zero;
+            return globalObject.throw("Bun.jest() expects a string filename", .{});
         }
         var str = arguments[0].toSlice(globalObject, bun.default_allocator);
         defer str.deinit();
         const slice = str.slice();
 
         if (!std.fs.path.isAbsolute(slice)) {
-            globalObject.throw("Bun.jest() expects an absolute file path, got '{s}'", .{slice});
-            return .zero;
+            return globalObject.throw("Bun.jest() expects an absolute file path, got '{s}'", .{slice});
         }
 
         const filepath = Fs.FileSystem.instance.filename_store.append([]const u8, slice) catch unreachable;
@@ -551,11 +543,10 @@ pub const Jest = struct {
         return Bun__Jest__testModuleObject(globalObject);
     }
 
-    fn jsSetDefaultTimeout(globalObject: *JSGlobalObject, callframe: *CallFrame) JSValue {
-        const arguments = callframe.arguments(1).slice();
+    fn jsSetDefaultTimeout(globalObject: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
+        const arguments = callframe.arguments_old(1).slice();
         if (arguments.len < 1 or !arguments[0].isNumber()) {
-            globalObject.throw("setTimeout() expects a number (milliseconds)", .{});
-            return .zero;
+            return globalObject.throw("setTimeout() expects a number (milliseconds)", .{});
         }
 
         const timeout_ms: u32 = @intCast(@max(arguments[0].coerce(i32, globalObject), 0));
@@ -583,7 +574,7 @@ pub const TestScope = struct {
     func_arg: []JSValue,
     func_has_callback: bool = false,
 
-    id: TestRunner.Test.ID = 0,
+    test_id_for_debugger: TestRunner.Test.ID = 0,
     promise: ?*JSInternalPromise = null,
     ran: bool = false,
     task: ?*TestRunnerTask = null,
@@ -601,41 +592,41 @@ 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 arguments = callframe.arguments_old(2);
         const err = arguments.ptr[0];
         _ = globalThis.bunVM().uncaughtException(globalThis, err, true);
         var task: *TestRunnerTask = arguments.ptr[1].asPromisePtr(TestRunnerTask);
@@ -645,9 +636,9 @@ 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);
+        const arguments = callframe.arguments_old(2);
         var task: *TestRunnerTask = arguments.ptr[1].asPromisePtr(TestRunnerTask);
         task.handleResult(.{ .pass = expect.active_test_expectation_counter.actual }, .promise);
         globalThis.bunVM().autoGarbageCollect();
@@ -658,9 +649,9 @@ pub const TestScope = struct {
     pub fn onDone(
         globalThis: *JSGlobalObject,
         callframe: *CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         const function = callframe.callee();
-        const args = callframe.arguments(1);
+        const args = callframe.arguments_old(1);
         defer globalThis.bunVM().autoGarbageCollect();
 
         if (JSC.getFunctionData(function)) |data| {
@@ -722,6 +713,14 @@ pub const TestScope = struct {
             task.test_id,
         );
 
+        if (task.test_id_for_debugger > 0) {
+            if (vm.debugger) |*debugger| {
+                if (debugger.test_reporter_agent.isEnabled()) {
+                    debugger.test_reporter_agent.reportTestStart(@intCast(task.test_id_for_debugger));
+                }
+            }
+        }
+
         if (this.func_has_callback) {
             const callback_func = JSC.NewFunctionWithData(
                 vm.global,
@@ -775,7 +774,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,
@@ -887,24 +886,19 @@ 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 {
-                const arguments = callframe.arguments(2);
+            pub fn run(globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSC.JSValue {
+                const arguments = callframe.arguments_old(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 globalThis.throwInvalidArgumentType(@tagName(hook), "callback", "function");
                 }
 
                 cb.protect();
@@ -917,9 +911,9 @@ 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);
+        const args = callframe.arguments_old(1);
         defer ctx.bunVM().autoGarbageCollect();
 
         if (JSC.getFunctionData(function)) |data| {
@@ -1071,35 +1065,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);
     }
 
@@ -1122,10 +1116,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;
                     },
                 }
@@ -1174,6 +1168,7 @@ pub const DescribeScope = struct {
                     .describe = this,
                     .globalThis = globalObject,
                     .source_file_path = source.path.text,
+                    .test_id_for_debugger = 0,
                 };
                 runner.ref.ref(globalObject.bunVM());
 
@@ -1182,6 +1177,8 @@ pub const DescribeScope = struct {
             }
         }
 
+        const maybe_report_debugger = max_test_id_for_debugger > 0;
+
         while (i < end) : (i += 1) {
             var runner = allocator.create(TestRunnerTask) catch unreachable;
             runner.* = .{
@@ -1189,6 +1186,7 @@ pub const DescribeScope = struct {
                 .describe = this,
                 .globalThis = globalObject,
                 .source_file_path = source.path.text,
+                .test_id_for_debugger = if (maybe_report_debugger) tests[i].test_id_for_debugger else 0,
             };
             runner.ref.ref(globalObject.bunVM());
 
@@ -1225,34 +1223,16 @@ 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;
+                return globalThis.throw("Cannot use " ++ name ++ "() outside of the test runner. Run \"bun test\" to run tests.", .{});
             }
             if (globalThis.bunVM().is_in_preload) {
-                globalThis.throw("Cannot use " ++ name ++ "() outside of a test file.", .{});
-                return .zero;
+                return globalThis.throw("Cannot use " ++ name ++ "() outside of a test file.", .{});
             }
             return @call(bun.callmod_inline, func, .{ globalThis, callframe });
         }
@@ -1285,6 +1265,7 @@ pub const WrappedDescribeScope = struct {
 
 pub const TestRunnerTask = struct {
     test_id: TestRunner.Test.ID,
+    test_id_for_debugger: TestRunner.Test.ID,
     describe: *DescribeScope,
     globalThis: *JSGlobalObject,
     source_file_path: string = "",
@@ -1369,7 +1350,6 @@ pub const TestRunnerTask = struct {
         jsc_vm.last_reported_error_for_dedupe = .zero;
 
         const test_id = this.test_id;
-
         if (test_id == std.math.maxInt(TestRunner.Test.ID)) {
             describe.onTestComplete(globalThis, test_id, true);
             Jest.runner.?.runNextTest();
@@ -1379,15 +1359,17 @@ pub const TestRunnerTask = struct {
 
         var test_: TestScope = this.describe.tests.items[test_id];
         describe.current_test_id = test_id;
+        const test_id_for_debugger = test_.test_id_for_debugger;
+        this.test_id_for_debugger = test_id_for_debugger;
 
         if (test_.func == .zero or !describe.shouldEvaluateScope() or (test_.tag != .only and Jest.runner.?.only)) {
             const tag = if (!describe.shouldEvaluateScope()) describe.tag else test_.tag;
             switch (tag) {
                 .todo => {
-                    this.processTestResult(globalThis, .{ .todo = {} }, test_, test_id, describe);
+                    this.processTestResult(globalThis, .{ .todo = {} }, test_, test_id, test_id_for_debugger, describe);
                 },
                 .skip => {
-                    this.processTestResult(globalThis, .{ .skip = {} }, test_, test_id, describe);
+                    this.processTestResult(globalThis, .{ .skip = {} }, test_, test_id, test_id_for_debugger, describe);
                 },
                 else => {},
             }
@@ -1410,7 +1392,7 @@ pub const TestRunnerTask = struct {
         }
 
         this.sync_state = .pending;
-
+        jsc_vm.auto_killer.enable();
         var result = TestScope.run(&test_, this);
 
         if (this.describe.tests.items.len > test_id) {
@@ -1429,7 +1411,6 @@ pub const TestRunnerTask = struct {
                 // Let's allow any pending work to run, and then move on to the next test.
                 this.continueRunningTestsAfterMicrotasksRun();
             }
-
             return true;
         }
 
@@ -1551,22 +1532,37 @@ pub const TestRunnerTask = struct {
         describe.tests.items[test_id] = test_;
 
         if (from == .timeout) {
-            const err = this.globalThis.createErrorInstance("Test {} timed out after {d}ms", .{ bun.fmt.quote(test_.label), test_.timeout_millis });
-            _ = this.globalThis.bunVM().uncaughtException(this.globalThis, err, true);
+            const vm = this.globalThis.bunVM();
+            const cancel_result = vm.auto_killer.kill();
+
+            const err = brk: {
+                if (cancel_result.processes > 0) {
+                    switch (Output.enable_ansi_colors_stdout) {
+                        inline else => |enable_ansi_colors| {
+                            break :brk this.globalThis.createErrorInstance(comptime Output.prettyFmt("Test {} timed out after {d}ms <r><d>({})<r>", enable_ansi_colors), .{ bun.fmt.quote(test_.label), test_.timeout_millis, cancel_result });
+                        },
+                    }
+                } else {
+                    break :brk this.globalThis.createErrorInstance("Test {} timed out after {d}ms", .{ bun.fmt.quote(test_.label), test_.timeout_millis });
+                }
+            };
+
+            _ = vm.uncaughtException(this.globalThis, err, true);
         }
 
         checkAssertionsCounter(result);
-        processTestResult(this, this.globalThis, result.*, test_, test_id, describe);
+        processTestResult(this, this.globalThis, result.*, test_, test_id, this.test_id_for_debugger, describe);
     }
 
-    fn processTestResult(this: *TestRunnerTask, globalThis: *JSGlobalObject, result: Result, test_: TestScope, test_id: u32, describe: *DescribeScope) void {
+    fn processTestResult(this: *TestRunnerTask, globalThis: *JSGlobalObject, result: Result, test_: TestScope, test_id: u32, test_id_for_debugger: u32, describe: *DescribeScope) void {
+        const elapsed = this.started_at.sinceNow();
         switch (result.forceTODO(test_.tag == .todo)) {
             .pass => |count| Jest.runner.?.reportPass(
                 test_id,
                 this.source_file_path,
                 test_.label,
                 count,
-                this.started_at.sinceNow(),
+                elapsed,
                 describe,
             ),
             .fail => |count| Jest.runner.?.reportFailure(
@@ -1574,7 +1570,7 @@ pub const TestRunnerTask = struct {
                 this.source_file_path,
                 test_.label,
                 count,
-                this.started_at.sinceNow(),
+                elapsed,
                 describe,
             ),
             .fail_because_expected_has_assertions => {
@@ -1585,7 +1581,7 @@ pub const TestRunnerTask = struct {
                     this.source_file_path,
                     test_.label,
                     0,
-                    this.started_at.sinceNow(),
+                    elapsed,
                     describe,
                 );
             },
@@ -1600,7 +1596,7 @@ pub const TestRunnerTask = struct {
                     this.source_file_path,
                     test_.label,
                     counter.actual,
-                    this.started_at.sinceNow(),
+                    elapsed,
                     describe,
                 );
             },
@@ -1613,13 +1609,28 @@ pub const TestRunnerTask = struct {
                     this.source_file_path,
                     test_.label,
                     count,
-                    this.started_at.sinceNow(),
+                    elapsed,
                     describe,
                 );
             },
             .pending => @panic("Unexpected pending test"),
         }
+
+        if (test_id_for_debugger > 0) {
+            if (globalThis.bunVM().debugger) |*debugger| {
+                if (debugger.test_reporter_agent.isEnabled()) {
+                    debugger.test_reporter_agent.reportTestEnd(@intCast(test_id_for_debugger), switch (result) {
+                        .pass => .pass,
+                        .skip => .skip,
+                        .todo => .todo,
+                        else => .fail,
+                    }, @floatFromInt(elapsed));
+                }
+            }
+        }
+
         describe.onTestComplete(globalThis, test_id, result == .skip or (!Jest.runner.?.test_options.run_todo and result == .todo));
+
         Jest.runner.?.runNextTest();
     }
 
@@ -1687,14 +1698,13 @@ inline fn createScope(
     comptime signature: string,
     comptime is_test: bool,
     comptime tag: Tag,
-) JSValue {
+) bun.JSError!JSValue {
     const this = callframe.this();
-    const arguments = callframe.arguments(3);
+    const arguments = callframe.arguments_old(3);
     const args = arguments.slice();
 
     if (args.len == 0) {
-        globalThis.throwPretty("{s} expects a description or function", .{signature});
-        return .zero;
+        return globalThis.throwPretty("{s} expects a description or function", .{signature});
     }
 
     var description = args[0];
@@ -1708,8 +1718,7 @@ inline fn createScope(
 
     if (function.isEmptyOrUndefinedOrNull() or !function.isCell() or !function.isCallable(globalThis.vm())) {
         if (tag != .todo and tag != .skip) {
-            globalThis.throwPretty("{s} expects a function", .{signature});
-            return .zero;
+            return globalThis.throwPretty("{s} expects a function", .{signature});
         }
     }
 
@@ -1717,30 +1726,26 @@ inline fn createScope(
     if (options.isNumber()) {
         timeout_ms = @as(u32, @intCast(@max(args[2].coerce(i32, globalThis), 0)));
     } else if (options.isObject()) {
-        if (options.get(globalThis, "timeout")) |timeout| {
+        if (try options.get(globalThis, "timeout")) |timeout| {
             if (!timeout.isNumber()) {
-                globalThis.throwPretty("{s} expects timeout to be a number", .{signature});
-                return .zero;
+                return globalThis.throwPretty("{s} expects timeout to be a number", .{signature});
             }
             timeout_ms = @as(u32, @intCast(@max(timeout.coerce(i32, globalThis), 0)));
         }
-        if (options.get(globalThis, "retry")) |retries| {
+        if (try options.get(globalThis, "retry")) |retries| {
             if (!retries.isNumber()) {
-                globalThis.throwPretty("{s} expects retry to be a number", .{signature});
-                return .zero;
+                return globalThis.throwPretty("{s} expects retry to be a number", .{signature});
             }
             // TODO: retry_count = @intCast(u32, @max(retries.coerce(i32, globalThis), 0));
         }
-        if (options.get(globalThis, "repeats")) |repeats| {
+        if (try options.get(globalThis, "repeats")) |repeats| {
             if (!repeats.isNumber()) {
-                globalThis.throwPretty("{s} expects repeats to be a number", .{signature});
-                return .zero;
+                return globalThis.throwPretty("{s} expects repeats to be a number", .{signature});
             }
             // TODO: repeat_count = @intCast(u32, @max(repeats.coerce(i32, globalThis), 0));
         }
     } else if (!options.isEmptyOrUndefinedOrNull()) {
-        globalThis.throwPretty("{s} expects options to be a number or object", .{signature});
-        return .zero;
+        return globalThis.throwPretty("{s} expects options to be a number or object", .{signature});
     }
 
     const parent = DescribeScope.active.?;
@@ -1770,7 +1775,7 @@ inline fn createScope(
                 buffer.reset();
                 appendParentLabel(&buffer, parent) catch @panic("Bun ran out of memory while filtering tests");
                 buffer.append(label) catch unreachable;
-                const str = bun.String.fromBytes(buffer.toOwnedSliceLeaky());
+                const str = bun.String.fromBytes(buffer.slice());
                 is_skip = !regex.matches(str);
                 if (is_skip) {
                     tag_to_use = .skip;
@@ -1802,6 +1807,21 @@ inline fn createScope(
             .func_arg = function_args,
             .func_has_callback = has_callback,
             .timeout_millis = timeout_ms,
+            .test_id_for_debugger = brk: {
+                if (!is_skip) {
+                    const vm = globalThis.bunVM();
+                    if (vm.debugger) |*debugger| {
+                        if (debugger.test_reporter_agent.isEnabled()) {
+                            max_test_id_for_debugger += 1;
+                            var name = bun.String.init(label);
+                            debugger.test_reporter_agent.reportTestFound(callframe, @intCast(max_test_id_for_debugger), &name);
+                            break :brk max_test_id_for_debugger;
+                        }
+                    }
+                }
+
+                break :brk 0;
+            },
         }) catch unreachable;
     } else {
         var scope = allocator.create(DescribeScope) catch unreachable;
@@ -1825,17 +1845,16 @@ inline fn createIfScope(
     comptime signature: string,
     comptime Scope: type,
     comptime tag: Tag,
-) JSValue {
-    const arguments = callframe.arguments(1);
+) bun.JSError!JSValue {
+    const arguments = callframe.arguments_old(1);
     const args = arguments.slice();
 
     if (args.len == 0) {
-        globalThis.throwPretty("{s} expects a condition", .{signature});
-        return .zero;
+        return globalThis.throwPretty("{s} expects a condition", .{signature});
     }
 
     const name = ZigString.static(property);
-    const value = args[0].toBooleanSlow(globalThis);
+    const value = args[0].toBoolean();
 
     const truthy_falsey = comptime switch (tag) {
         .pass => .{ Scope.skip, Scope.call },
@@ -1861,7 +1880,7 @@ fn consumeArg(
 ) !void {
     const allocator = getAllocator(globalThis);
     if (should_write) {
-        const owned_slice = arg.toSliceOrNull(globalThis) orelse return error.Failed;
+        const owned_slice = try arg.toSliceOrNull(globalThis);
         defer owned_slice.deinit();
         array_list.appendSlice(allocator, owned_slice.slice()) catch bun.outOfMemory();
     } else {
@@ -1885,7 +1904,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");
@@ -1941,18 +1960,14 @@ fn formatLabel(globalThis: *JSGlobalObject, label: string, function_args: []JSVa
 
 pub const EachData = struct { strong: JSC.Strong, is_test: bool };
 
-fn eachBind(
-    globalThis: *JSGlobalObject,
-    callframe: *CallFrame,
-) JSValue {
+fn eachBind(globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
     const signature = "eachBind";
     const callee = callframe.callee();
-    const arguments = callframe.arguments(3);
+    const arguments = callframe.arguments_old(3);
     const args = arguments.slice();
 
     if (args.len < 2) {
-        globalThis.throwPretty("{s} a description and callback function", .{signature});
-        return .zero;
+        return globalThis.throwPretty("{s} a description and callback function", .{signature});
     }
 
     var description = args[0];
@@ -1960,38 +1975,33 @@ fn eachBind(
     var options = if (args.len > 2) args[2] else .zero;
 
     if (function.isEmptyOrUndefinedOrNull() or !function.isCell() or !function.isCallable(globalThis.vm())) {
-        globalThis.throwPretty("{s} expects a function", .{signature});
-        return .zero;
+        return globalThis.throwPretty("{s} expects a function", .{signature});
     }
 
     var timeout_ms: u32 = std.math.maxInt(u32);
     if (options.isNumber()) {
         timeout_ms = @as(u32, @intCast(@max(args[2].coerce(i32, globalThis), 0)));
     } else if (options.isObject()) {
-        if (options.get(globalThis, "timeout")) |timeout| {
+        if (try options.get(globalThis, "timeout")) |timeout| {
             if (!timeout.isNumber()) {
-                globalThis.throwPretty("{s} expects timeout to be a number", .{signature});
-                return .zero;
+                return globalThis.throwPretty("{s} expects timeout to be a number", .{signature});
             }
             timeout_ms = @as(u32, @intCast(@max(timeout.coerce(i32, globalThis), 0)));
         }
-        if (options.get(globalThis, "retry")) |retries| {
+        if (try options.get(globalThis, "retry")) |retries| {
             if (!retries.isNumber()) {
-                globalThis.throwPretty("{s} expects retry to be a number", .{signature});
-                return .zero;
+                return globalThis.throwPretty("{s} expects retry to be a number", .{signature});
             }
             // TODO: retry_count = @intCast(u32, @max(retries.coerce(i32, globalThis), 0));
         }
-        if (options.get(globalThis, "repeats")) |repeats| {
+        if (try options.get(globalThis, "repeats")) |repeats| {
             if (!repeats.isNumber()) {
-                globalThis.throwPretty("{s} expects repeats to be a number", .{signature});
-                return .zero;
+                return globalThis.throwPretty("{s} expects repeats to be a number", .{signature});
             }
             // TODO: repeat_count = @intCast(u32, @max(repeats.coerce(i32, globalThis), 0));
         }
     } else if (!options.isEmptyOrUndefinedOrNull()) {
-        globalThis.throwPretty("{s} expects options to be a number or object", .{signature});
-        return .zero;
+        return globalThis.throwPretty("{s} expects options to be a number or object", .{signature});
     }
 
     const parent = DescribeScope.active.?;
@@ -2052,7 +2062,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;
 
@@ -2069,7 +2079,7 @@ fn eachBind(
                 buffer.reset();
                 appendParentLabel(&buffer, parent) catch @panic("Bun ran out of memory while filtering tests");
                 buffer.append(formattedLabel) catch unreachable;
-                const str = bun.String.fromBytes(buffer.toOwnedSliceLeaky());
+                const str = bun.String.fromBytes(buffer.slice());
                 is_skip = !regex.matches(str);
             }
 
@@ -2117,19 +2127,17 @@ inline fn createEach(
     comptime property: [:0]const u8,
     comptime signature: string,
     comptime is_test: bool,
-) JSValue {
-    const arguments = callframe.arguments(1);
+) bun.JSError!JSValue {
+    const arguments = callframe.arguments_old(1);
     const args = arguments.slice();
 
     if (args.len == 0) {
-        globalThis.throwPretty("{s} expects an array", .{signature});
-        return .zero;
+        return globalThis.throwPretty("{s} expects an array", .{signature});
     }
 
     var array = args[0];
-    if (array.isEmpty() or !array.jsType().isArray()) {
-        globalThis.throwPretty("{s} expects an array", .{signature});
-        return .zero;
+    if (array == .zero or !array.jsType().isArray()) {
+        return globalThis.throwPretty("{s} expects an array", .{signature});
     }
 
     const allocator = getAllocator(globalThis);
diff --git a/src/bun.js/test/pretty_format.zig b/src/bun.js/test/pretty_format.zig
index 3b2720b995..dd119384c7 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 {
@@ -442,7 +442,7 @@ pub const JestPrettyFormat = struct {
                 }
 
                 // Is this a react element?
-                if (js_type.isObject()) {
+                if (js_type.isObject() and js_type != .ProxyObject) {
                     if (value.getOwnTruthy(globalThis, "$$typeof")) |typeof_symbol| {
                         var reactElement = ZigString.init("react.element");
                         var react_fragment = ZigString.init("react.fragment");
@@ -463,8 +463,8 @@ pub const JestPrettyFormat = struct {
                         .Symbol => .Symbol,
                         .BooleanObject => .Boolean,
                         .JSFunction => .Function,
-                        .JSWeakMap, .JSMap => .Map,
-                        .JSWeakSet, .JSSet => .Set,
+                        .WeakMap, .Map => .Map,
+                        .WeakSet, .Set => .Set,
                         .JSDate => .JSON,
                         .JSPromise => .Promise,
                         .Object,
@@ -861,7 +861,7 @@ pub const JestPrettyFormat = struct {
 
                             writer.print(
                                 comptime Output.prettyFmt("<r><green>{s}<r><d>:<r> ", enable_ansi_colors),
-                                .{JSPrinter.formatJSONString(key.slice())},
+                                .{bun.fmt.formatJSONString(key.slice())},
                             );
                         }
                     } else {
@@ -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);
                 }
             }
 
@@ -1235,7 +1235,7 @@ pub const JestPrettyFormat = struct {
                         blob.writeFormat(Formatter, this, writer_, enable_ansi_colors) catch {};
                         return;
                     } else if (value.as(JSC.DOMFormData) != null) {
-                        const toJSONFunction = value.get(this.globalThis, "toJSON").?;
+                        const toJSONFunction = value.get_unsafe(this.globalThis, "toJSON").?;
 
                         this.addForNewLine("FormData (entries) ".len);
                         writer.writeAll(comptime Output.prettyFmt("<r><blue>FormData<r> <d>(entries)<r> ", enable_ansi_colors));
@@ -1310,14 +1310,14 @@ pub const JestPrettyFormat = struct {
                     writer.writeAll(comptime Output.prettyFmt("<cyan>" ++ fmt ++ "<r>", enable_ansi_colors));
                 },
                 .Map => {
-                    const length_value = value.get(this.globalThis, "size") orelse JSC.JSValue.jsNumberFromInt32(0);
+                    const length_value = value.get_unsafe(this.globalThis, "size") orelse JSC.JSValue.jsNumberFromInt32(0);
                     const length = length_value.toInt32();
 
                     const prev_quote_strings = this.quote_strings;
                     this.quote_strings = true;
                     defer this.quote_strings = prev_quote_strings;
 
-                    const map_name = if (value.jsType() == .JSWeakMap) "WeakMap" else "Map";
+                    const map_name = if (value.jsType() == .WeakMap) "WeakMap" else "Map";
 
                     if (length == 0) {
                         return writer.print("{s} {{}}", .{map_name});
@@ -1338,7 +1338,7 @@ pub const JestPrettyFormat = struct {
                     writer.writeAll("\n");
                 },
                 .Set => {
-                    const length_value = value.get(this.globalThis, "size") orelse JSC.JSValue.jsNumberFromInt32(0);
+                    const length_value = value.get_unsafe(this.globalThis, "size") orelse JSC.JSValue.jsNumberFromInt32(0);
                     const length = length_value.toInt32();
 
                     const prev_quote_strings = this.quote_strings;
@@ -1347,7 +1347,7 @@ pub const JestPrettyFormat = struct {
 
                     this.writeIndent(Writer, writer_) catch {};
 
-                    const set_name = if (value.jsType() == .JSWeakSet) "WeakSet" else "Set";
+                    const set_name = if (value.jsType() == .WeakSet) "WeakSet" else "Set";
 
                     if (length == 0) {
                         return writer.print("{s} {{}}", .{set_name});
@@ -1390,7 +1390,7 @@ pub const JestPrettyFormat = struct {
                 },
                 .Event => {
                     const event_type_value = brk: {
-                        const value_ = value.get(this.globalThis, "type") orelse break :brk JSValue.undefined;
+                        const value_ = value.get_unsafe(this.globalThis, "type") orelse break :brk JSValue.undefined;
                         if (value_.isString()) {
                             break :brk value_;
                         }
@@ -1490,7 +1490,7 @@ pub const JestPrettyFormat = struct {
 
                     defer if (tag_name_slice.isAllocated()) tag_name_slice.deinit();
 
-                    if (value.get(this.globalThis, "type")) |type_value| {
+                    if (value.get_unsafe(this.globalThis, "type")) |type_value| {
                         const _tag = Tag.get(type_value, this.globalThis);
 
                         if (_tag.cell == .Symbol) {} else if (_tag.cell.isStringLike()) {
@@ -1520,7 +1520,7 @@ pub const JestPrettyFormat = struct {
                     writer.writeAll(tag_name_slice.slice());
                     if (enable_ansi_colors) writer.writeAll(comptime Output.prettyFmt("<r>", enable_ansi_colors));
 
-                    if (value.get(this.globalThis, "key")) |key_value| {
+                    if (value.get_unsafe(this.globalThis, "key")) |key_value| {
                         if (!key_value.isUndefinedOrNull()) {
                             if (needs_space)
                                 writer.writeAll(" key=")
@@ -1537,7 +1537,7 @@ pub const JestPrettyFormat = struct {
                         }
                     }
 
-                    if (value.get(this.globalThis, "props")) |props| {
+                    if (value.get_unsafe(this.globalThis, "props")) |props| {
                         const prev_quote_strings = this.quote_strings;
                         this.quote_strings = true;
                         defer this.quote_strings = prev_quote_strings;
@@ -1549,7 +1549,7 @@ pub const JestPrettyFormat = struct {
                         }).init(this.globalThis, props);
                         defer props_iter.deinit();
 
-                        const children_prop = props.get(this.globalThis, "children");
+                        const children_prop = props.get_unsafe(this.globalThis, "children");
                         if (props_iter.len > 0) {
                             {
                                 this.indent += 1;
diff --git a/src/bun.js/test/snapshot.zig b/src/bun.js/test/snapshot.zig
index e8d46bb378..2042d360a0 100644
--- a/src/bun.js/test/snapshot.zig
+++ b/src/bun.js/test/snapshot.zig
@@ -32,13 +32,28 @@ pub const Snapshots = struct {
     counts: *bun.StringHashMap(usize),
     _current_file: ?File = null,
     snapshot_dir_path: ?string = null,
+    inline_snapshots_to_write: *std.AutoArrayHashMap(TestRunner.File.ID, std.ArrayList(InlineSnapshotToWrite)),
+
+    pub const InlineSnapshotToWrite = struct {
+        line: c_ulong,
+        col: c_ulong,
+        value: []const u8,
+        has_matchers: bool,
+
+        fn lessThanFn(_: void, a: InlineSnapshotToWrite, b: InlineSnapshotToWrite) bool {
+            if (a.line < b.line) return true;
+            if (a.line > b.line) return false;
+            if (a.col < b.col) return true;
+            return false;
+        }
+    };
 
     const File = struct {
         id: TestRunner.File.ID,
         file: std.fs.File,
     };
 
-    pub fn getOrPut(this: *Snapshots, expect: *Expect, value: JSValue, hint: string, globalObject: *JSC.JSGlobalObject) !?string {
+    pub fn getOrPut(this: *Snapshots, expect: *Expect, target_value: []const u8, hint: string) !?string {
         switch (try this.getSnapshotFile(expect.testScope().?.describe.file_id)) {
             .result => {},
             .err => |err| {
@@ -81,30 +96,29 @@ pub const Snapshots = struct {
         }
 
         // doesn't exist. append to file bytes and add to hashmap.
-        var pretty_value = try MutableString.init(this.allocator, 0);
-        try value.jestSnapshotPrettyFormat(&pretty_value, globalObject);
-
-        const serialized_length = "\nexports[`".len + name_with_counter.len + "`] = `".len + pretty_value.list.items.len + "`;\n".len;
-        try this.file_buf.ensureUnusedCapacity(serialized_length);
-        this.file_buf.appendSliceAssumeCapacity("\nexports[`");
-        this.file_buf.appendSliceAssumeCapacity(name_with_counter);
-        this.file_buf.appendSliceAssumeCapacity("`] = `");
-        this.file_buf.appendSliceAssumeCapacity(pretty_value.list.items);
-        this.file_buf.appendSliceAssumeCapacity("`;\n");
+        const estimated_length = "\nexports[`".len + name_with_counter.len + "`] = `".len + target_value.len + "`;\n".len;
+        try this.file_buf.ensureUnusedCapacity(estimated_length + 10);
+        try this.file_buf.writer().print(
+            "\nexports[`{}`] = `{}`;\n",
+            .{
+                strings.formatEscapes(name_with_counter, .{ .quote_char = '`' }),
+                strings.formatEscapes(target_value, .{ .quote_char = '`' }),
+            },
+        );
 
         this.added += 1;
-        try this.values.put(name_hash, pretty_value.toOwnedSlice());
+        try this.values.put(name_hash, try this.allocator.dupe(u8, target_value));
         return null;
     }
 
-    pub fn parseFile(this: *Snapshots) !void {
+    pub fn parseFile(this: *Snapshots, file: File) !void {
         if (this.file_buf.items.len == 0) return;
 
         const vm = VirtualMachine.get();
         const opts = js_parser.Parser.Options.init(vm.bundler.options.jsx, .js);
         var temp_log = logger.Log.init(this.allocator);
 
-        const test_file = Jest.runner.?.files.get(this._current_file.?.id);
+        const test_file = Jest.runner.?.files.get(file.id);
         const test_filename = test_file.source.path.name.filename;
         const dir_path = test_file.source.path.name.dirWithTrailingSlash();
 
@@ -194,6 +208,227 @@ pub const Snapshots = struct {
         }
     }
 
+    pub fn addInlineSnapshotToWrite(self: *Snapshots, file_id: TestRunner.File.ID, value: InlineSnapshotToWrite) !void {
+        const gpres = try self.inline_snapshots_to_write.getOrPut(file_id);
+        if (!gpres.found_existing) {
+            gpres.value_ptr.* = std.ArrayList(InlineSnapshotToWrite).init(self.allocator);
+        }
+        try gpres.value_ptr.append(value);
+    }
+
+    const inline_snapshot_dbg = bun.Output.scoped(.inline_snapshot, false);
+    pub fn writeInlineSnapshots(this: *Snapshots) !bool {
+        var arena_backing = bun.ArenaAllocator.init(this.allocator);
+        defer arena_backing.deinit();
+        const arena = arena_backing.allocator();
+
+        var success = true;
+        const vm = VirtualMachine.get();
+        const opts = js_parser.Parser.Options.init(vm.bundler.options.jsx, .js);
+
+        for (this.inline_snapshots_to_write.keys(), this.inline_snapshots_to_write.values()) |file_id, *ils_info| {
+            _ = arena_backing.reset(.retain_capacity);
+
+            var log = bun.logger.Log.init(arena);
+            defer if (log.errors > 0) {
+                log.print(bun.Output.errorWriter()) catch {};
+                success = false;
+            };
+
+            // 1. sort ils_info by row, col
+            std.mem.sort(InlineSnapshotToWrite, ils_info.items, {}, InlineSnapshotToWrite.lessThanFn);
+
+            // 2. load file text
+            const test_file = Jest.runner.?.files.get(file_id);
+            const test_filename = try arena.dupeZ(u8, test_file.source.path.text);
+
+            const fd = switch (bun.sys.open(test_filename, bun.O.RDWR, 0o644)) {
+                .result => |r| r,
+                .err => |e| {
+                    try log.addErrorFmt(&bun.logger.Source.initEmptyFile(test_filename), .{ .start = 0 }, arena, "Failed to update inline snapshot: Failed to open file: {s}", .{e.name()});
+                    continue;
+                },
+            };
+            var file: File = .{
+                .id = file_id,
+                .file = fd.asFile(),
+            };
+            errdefer file.file.close();
+
+            const file_text = try file.file.readToEndAlloc(arena, std.math.maxInt(usize));
+
+            var source = bun.logger.Source.initPathString(test_filename, file_text);
+
+            var result_text = std.ArrayList(u8).init(arena);
+
+            // 3. start looping, finding bytes from line/col
+
+            var uncommitted_segment_end: usize = 0;
+            var last_byte: usize = 0;
+            var last_line: c_ulong = 1;
+            var last_col: c_ulong = 1;
+            for (ils_info.items) |ils| {
+                if (ils.line == last_line and ils.col == last_col) {
+                    try log.addErrorFmt(&source, .{ .start = @intCast(uncommitted_segment_end) }, arena, "Failed to update inline snapshot: Multiple inline snapshots for the same call are not supported", .{});
+                    continue;
+                }
+
+                inline_snapshot_dbg("Finding byte for {}/{}", .{ ils.line, ils.col });
+                const byte_offset_add = logger.Source.lineColToByteOffset(file_text[last_byte..], last_line, last_col, ils.line, ils.col) orelse {
+                    inline_snapshot_dbg("-> Could not find byte", .{});
+                    try log.addErrorFmt(&source, .{ .start = @intCast(uncommitted_segment_end) }, arena, "Failed to update inline snapshot: Could not find byte for line/column: {d}/{d}", .{ ils.line, ils.col });
+                    continue;
+                };
+
+                // found
+                last_byte += byte_offset_add;
+                last_line = ils.line;
+                last_col = ils.col;
+
+                var next_start = last_byte;
+                inline_snapshot_dbg("-> Found byte {}", .{next_start});
+
+                const final_start: i32, const final_end: i32, const needs_pre_comma: bool = blk: {
+                    if (file_text[next_start..].len > 0) switch (file_text[next_start]) {
+                        ' ', '.' => {
+                            // work around off-by-1 error in `expect("§").toMatchInlineSnapshot()`
+                            next_start += 1;
+                        },
+                        else => {},
+                    };
+                    const fn_name = "toMatchInlineSnapshot";
+                    if (!bun.strings.startsWith(file_text[next_start..], fn_name)) {
+                        try log.addErrorFmt(&source, .{ .start = @intCast(next_start) }, arena, "Failed to update inline snapshot: Could not find 'toMatchInlineSnapshot' here", .{});
+                        continue;
+                    }
+                    next_start += fn_name.len;
+
+                    var lexer = bun.js_lexer.Lexer.initWithoutReading(&log, source, arena);
+                    if (next_start > 0) {
+                        // equivalent to lexer.consumeRemainderBytes(next_start)
+                        lexer.current += next_start - (lexer.current - lexer.end);
+                        lexer.step();
+                    }
+                    try lexer.next();
+                    var parser: bun.js_parser.TSXParser = undefined;
+                    try bun.js_parser.TSXParser.init(arena, &log, &source, vm.bundler.options.define, lexer, opts, &parser);
+
+                    try parser.lexer.expect(.t_open_paren);
+                    const after_open_paren_loc = parser.lexer.loc().start;
+                    if (parser.lexer.token == .t_close_paren) {
+                        // zero args
+                        if (ils.has_matchers) {
+                            try log.addErrorFmt(&source, parser.lexer.loc(), arena, "Failed to update inline snapshot: Snapshot has matchers and yet has no arguments", .{});
+                            continue;
+                        }
+                        const close_paren_loc = parser.lexer.loc().start;
+                        try parser.lexer.expect(.t_close_paren);
+                        break :blk .{ after_open_paren_loc, close_paren_loc, false };
+                    }
+                    if (parser.lexer.token == .t_dot_dot_dot) {
+                        try log.addErrorFmt(&source, parser.lexer.loc(), arena, "Failed to update inline snapshot: Spread is not allowed", .{});
+                        continue;
+                    }
+
+                    const before_expr_loc = parser.lexer.loc().start;
+                    const expr_1 = try parser.parseExpr(.comma);
+                    const after_expr_loc = parser.lexer.loc().start;
+
+                    var is_one_arg = false;
+                    if (parser.lexer.token == .t_comma) {
+                        try parser.lexer.expect(.t_comma);
+                        if (parser.lexer.token == .t_close_paren) is_one_arg = true;
+                    } else is_one_arg = true;
+                    const after_comma_loc = parser.lexer.loc().start;
+
+                    if (is_one_arg) {
+                        try parser.lexer.expect(.t_close_paren);
+                        if (ils.has_matchers) {
+                            break :blk .{ after_expr_loc, after_comma_loc, true };
+                        } else {
+                            if (expr_1.data != .e_string) {
+                                try log.addErrorFmt(&source, expr_1.loc, arena, "Failed to update inline snapshot: Argument must be a string literal", .{});
+                                continue;
+                            }
+                            break :blk .{ before_expr_loc, after_expr_loc, false };
+                        }
+                    }
+
+                    if (parser.lexer.token == .t_dot_dot_dot) {
+                        try log.addErrorFmt(&source, parser.lexer.loc(), arena, "Failed to update inline snapshot: Spread is not allowed", .{});
+                        continue;
+                    }
+
+                    const before_expr_2_loc = parser.lexer.loc().start;
+                    const expr_2 = try parser.parseExpr(.comma);
+                    const after_expr_2_loc = parser.lexer.loc().start;
+
+                    if (!ils.has_matchers) {
+                        try log.addErrorFmt(&source, parser.lexer.loc(), arena, "Failed to update inline snapshot: Snapshot does not have matchers and yet has two arguments", .{});
+                        continue;
+                    }
+                    if (expr_2.data != .e_string) {
+                        try log.addErrorFmt(&source, expr_2.loc, arena, "Failed to update inline snapshot: Argument must be a string literal", .{});
+                        continue;
+                    }
+
+                    if (parser.lexer.token == .t_comma) {
+                        try parser.lexer.expect(.t_comma);
+                    }
+                    if (parser.lexer.token != .t_close_paren) {
+                        try log.addErrorFmt(&source, parser.lexer.loc(), arena, "Failed to update inline snapshot: Snapshot expects at most two arguments", .{});
+                        continue;
+                    }
+                    try parser.lexer.expect(.t_close_paren);
+
+                    break :blk .{ before_expr_2_loc, after_expr_2_loc, false };
+                };
+                const final_start_usize = std.math.cast(usize, final_start) orelse 0;
+                const final_end_usize = std.math.cast(usize, final_end) orelse 0;
+                inline_snapshot_dbg("  -> Found update range {}-{}", .{ final_start_usize, final_end_usize });
+
+                if (final_end_usize < final_start_usize or final_start_usize < uncommitted_segment_end) {
+                    try log.addErrorFmt(&source, .{ .start = final_start }, arena, "Failed to update inline snapshot: Did not advance.", .{});
+                    continue;
+                }
+
+                try result_text.appendSlice(file_text[uncommitted_segment_end..final_start_usize]);
+                uncommitted_segment_end = final_end_usize;
+
+                if (needs_pre_comma) try result_text.appendSlice(", ");
+                const result_text_writer = result_text.writer();
+                try result_text.appendSlice("`");
+                try bun.js_printer.writePreQuotedString(ils.value, @TypeOf(result_text_writer), result_text_writer, '`', false, false, .utf8);
+                try result_text.appendSlice("`");
+            }
+
+            // commit the last segment
+            try result_text.appendSlice(file_text[uncommitted_segment_end..]);
+
+            if (log.errors > 0) {
+                // skip writing the file if there were errors
+                continue;
+            }
+
+            // 4. write out result_text to the file
+            file.file.seekTo(0) catch |e| {
+                try log.addErrorFmt(&source, .{ .start = 0 }, arena, "Failed to update inline snapshot: Seek file error: {s}", .{@errorName(e)});
+                continue;
+            };
+
+            file.file.writeAll(result_text.items) catch |e| {
+                try log.addErrorFmt(&source, .{ .start = 0 }, arena, "Failed to update inline snapshot: Write file error: {s}", .{@errorName(e)});
+                continue;
+            };
+            if (result_text.items.len < file_text.len) {
+                file.file.setEndPos(result_text.items.len) catch {
+                    @panic("Failed to update inline snapshot: File was left in an invalid state");
+                };
+            }
+        }
+        return success;
+    }
+
     fn getSnapshotFile(this: *Snapshots, file_id: TestRunner.File.ID) !JSC.Maybe(void) {
         if (this._current_file == null or this._current_file.?.id != file_id) {
             try this.writeSnapshotFile();
@@ -245,6 +480,7 @@ pub const Snapshots = struct {
                 .id = file_id,
                 .file = fd.asFile(),
             };
+            errdefer file.file.close();
 
             if (this.update_snapshots) {
                 try this.file_buf.appendSlice(file_header);
@@ -263,8 +499,8 @@ pub const Snapshots = struct {
                 }
             }
 
+            try this.parseFile(file);
             this._current_file = file;
-            try this.parseFile();
         }
 
         return JSC.Maybe(void).success;
diff --git a/src/bun.js/uuid.zig b/src/bun.js/uuid.zig
index 13fbebd346..0d59acd532 100644
--- a/src/bun.js/uuid.zig
+++ b/src/bun.js/uuid.zig
@@ -87,12 +87,11 @@ pub fn format(
     try fmt.format(writer, "{s}", .{buf});
 }
 
-pub fn print(
-    self: UUID,
+fn printBytes(
+    bytes: *const [16]u8,
     buf: *[36]u8,
 ) void {
     const hex = "0123456789abcdef";
-    const bytes = self.bytes;
 
     buf[8] = '-';
     buf[13] = '-';
@@ -103,6 +102,12 @@ pub fn print(
         buf[comptime i + 1] = hex[bytes[j] & 0x0f];
     }
 }
+pub fn print(
+    self: UUID,
+    buf: *[36]u8,
+) void {
+    printBytes(&self.bytes, buf);
+}
 
 pub fn parse(buf: []const u8) Error!UUID {
     var uuid = UUID{ .bytes = undefined };
@@ -129,3 +134,76 @@ pub const zero: UUID = .{ .bytes = .{0} ** 16 };
 pub fn newV4() UUID {
     return UUID.init();
 }
+
+/// # --- 48 ---   -- 4 --   - 12 -   -- 2 --   - 62 -
+/// # unix_ts_ms | version | rand_a | variant | rand_b
+pub const UUID7 = struct {
+    bytes: [16]u8,
+
+    var uuid_v7_lock = bun.Lock{};
+    var uuid_v7_last_timestamp: std.atomic.Value(u64) = .{ .raw = 0 };
+    var uuid_v7_counter: std.atomic.Value(u32) = .{ .raw = 0 };
+
+    fn getCount(timestamp: u64) u32 {
+        uuid_v7_lock.lock();
+        defer uuid_v7_lock.unlock();
+        if (uuid_v7_last_timestamp.swap(timestamp, .monotonic) != timestamp) {
+            uuid_v7_counter.store(0, .monotonic);
+        }
+
+        return uuid_v7_counter.fetchAdd(1, .monotonic) % 4096;
+    }
+
+    pub fn init(timestamp: u64, random: *[8]u8) UUID7 {
+        const count = getCount(timestamp);
+
+        var bytes: [16]u8 = undefined;
+
+        // First 6 bytes: timestamp in big-endian
+        bytes[0] = @truncate(timestamp >> 40);
+        bytes[1] = @truncate(timestamp >> 32);
+        bytes[2] = @truncate(timestamp >> 24);
+        bytes[3] = @truncate(timestamp >> 16);
+        bytes[4] = @truncate(timestamp >> 8);
+        bytes[5] = @truncate(timestamp);
+
+        // Byte 6: Version 7 in high nibble, top 4 bits of counter in low nibble
+        bytes[6] = (@as(u8, 7) << 4) | @as(u8, @truncate((count >> 8) & 0x0F));
+
+        // Byte 7: Lower 8 bits of counter
+        bytes[7] = @truncate(count);
+
+        // Byte 8: Variant in top 2 bits, 6 bits of random
+        bytes[8] = 0x80 | (random[0] & 0x3F);
+
+        // Remaining 7 bytes: random
+        @memcpy(bytes[9..16], random[1..8]);
+
+        return UUID7{
+            .bytes = bytes,
+        };
+    }
+
+    fn toBytes(self: UUID7) [16]u8 {
+        return self.bytes;
+    }
+
+    pub fn print(self: UUID7, buf: *[36]u8) void {
+        return printBytes(&self.toBytes(), buf);
+    }
+
+    pub fn toUUID(self: UUID7) UUID {
+        const bytes: [16]u8 = self.toBytes();
+
+        return .{ .bytes = bytes };
+    }
+
+    pub fn format(
+        self: UUID7,
+        comptime layout: []const u8,
+        options: fmt.FormatOptions,
+        writer: anytype,
+    ) !void {
+        return self.toUUID().format(layout, options, writer);
+    }
+};
diff --git a/src/bun.js/web_worker.zig b/src/bun.js/web_worker.zig
index 127c0751bc..b91b917496 100644
--- a/src/bun.js/web_worker.zig
+++ b/src/bun.js/web_worker.zig
@@ -22,6 +22,7 @@ pub const WebWorker = struct {
 
     /// Already resolved.
     specifier: []const u8 = "",
+    preloads: [][]const u8 = &.{},
     store_fd: bool = false,
     arena: ?bun.MimallocArena = null,
     name: [:0]const u8 = "Worker",
@@ -76,6 +77,94 @@ pub const WebWorker = struct {
         return true;
     }
 
+    fn resolveEntryPointSpecifier(
+        parent: *JSC.VirtualMachine,
+        str: []const u8,
+        error_message: *bun.String,
+        logger: *bun.logger.Log,
+    ) ?[]const u8 {
+        if (parent.standalone_module_graph) |graph| {
+            if (graph.find(str) != null) {
+                return str;
+            }
+
+            // Since `bun build --compile` renames files to `.js` by
+            // default, we need to do the reverse of our file extension
+            // mapping.
+            //
+            //   new Worker("./foo") -> new Worker("./foo.js")
+            //   new Worker("./foo.ts") -> new Worker("./foo.js")
+            //   new Worker("./foo.jsx") -> new Worker("./foo.js")
+            //   new Worker("./foo.mjs") -> new Worker("./foo.js")
+            //   new Worker("./foo.mts") -> new Worker("./foo.js")
+            //   new Worker("./foo.cjs") -> new Worker("./foo.js")
+            //   new Worker("./foo.cts") -> new Worker("./foo.js")
+            //   new Worker("./foo.tsx") -> new Worker("./foo.js")
+            //
+            if (bun.strings.hasPrefixComptime(str, "./") or bun.strings.hasPrefixComptime(str, "../")) try_from_extension: {
+                var pathbuf: bun.PathBuffer = undefined;
+                var base = str;
+
+                base = bun.path.joinAbsStringBuf(bun.StandaloneModuleGraph.base_public_path_with_default_suffix, &pathbuf, &.{str}, .loose);
+                const extname = std.fs.path.extension(base);
+
+                // ./foo -> ./foo.js
+                if (extname.len == 0) {
+                    pathbuf[base.len..][0..3].* = ".js".*;
+                    if (graph.find(pathbuf[0 .. base.len + 3])) |js_file| {
+                        return js_file.name;
+                    }
+
+                    break :try_from_extension;
+                }
+
+                // ./foo.ts -> ./foo.js
+                if (bun.strings.eqlComptime(extname, ".ts")) {
+                    pathbuf[base.len - 3 .. base.len][0..3].* = ".js".*;
+                    if (graph.find(pathbuf[0..base.len])) |js_file| {
+                        return js_file.name;
+                    }
+
+                    break :try_from_extension;
+                }
+
+                if (extname.len == 4) {
+                    inline for (.{ ".tsx", ".jsx", ".mjs", ".mts", ".cts", ".cjs" }) |ext| {
+                        if (bun.strings.eqlComptime(extname, ext)) {
+                            pathbuf[base.len - ext.len ..][0..".js".len].* = ".js".*;
+                            const as_js = pathbuf[0 .. base.len - ext.len + ".js".len];
+                            if (graph.find(as_js)) |js_file| {
+                                return js_file.name;
+                            }
+                            break :try_from_extension;
+                        }
+                    }
+                }
+            }
+        }
+
+        if (JSC.WebCore.ObjectURLRegistry.isBlobURL(str)) {
+            if (JSC.WebCore.ObjectURLRegistry.singleton().has(str["blob:".len..])) {
+                return str;
+            } else {
+                error_message.* = bun.String.static("Blob URL is missing");
+                return null;
+            }
+        }
+
+        var resolved_entry_point: bun.resolver.Result = parent.bundler.resolveEntryPoint(str) catch {
+            const out = logger.toJS(parent.global, bun.default_allocator, "Error resolving Worker entry point").toBunString(parent.global);
+            error_message.* = out;
+            return null;
+        };
+
+        const entry_path: *bun.fs.Path = resolved_entry_point.path() orelse {
+            error_message.* = bun.String.static("Worker entry point is missing");
+            return null;
+        };
+        return entry_path.text;
+    }
+
     pub fn create(
         cpp_worker: *void,
         parent: *JSC.VirtualMachine,
@@ -90,6 +179,8 @@ pub const WebWorker = struct {
         argv_len: u32,
         execArgv_ptr: ?[*]WTFStringImpl,
         execArgv_len: u32,
+        preload_modules_ptr: ?[*]bun.String,
+        preload_modules_len: u32,
     ) callconv(.C) ?*WebWorker {
         JSC.markBinding(@src());
         log("[{d}] WebWorker.create", .{this_context_id});
@@ -101,90 +192,32 @@ pub const WebWorker = struct {
         defer parent.bundler.setLog(prev_log);
         defer temp_log.deinit();
 
-        const path = brk: {
-            const str = spec_slice.slice();
-            if (parent.standalone_module_graph) |graph| {
-                if (graph.find(str) != null) {
-                    break :brk str;
-                }
+        const preload_modules = if (preload_modules_ptr) |ptr|
+            ptr[0..preload_modules_len]
+        else
+            &.{};
 
-                // Since `bun build --compile` renames files to `.js` by
-                // default, we need to do the reverse of our file extension
-                // mapping.
-                //
-                //   new Worker("./foo") -> new Worker("./foo.js")
-                //   new Worker("./foo.ts") -> new Worker("./foo.js")
-                //   new Worker("./foo.jsx") -> new Worker("./foo.js")
-                //   new Worker("./foo.mjs") -> new Worker("./foo.js")
-                //   new Worker("./foo.mts") -> new Worker("./foo.js")
-                //   new Worker("./foo.cjs") -> new Worker("./foo.js")
-                //   new Worker("./foo.cts") -> new Worker("./foo.js")
-                //   new Worker("./foo.tsx") -> new Worker("./foo.js")
-                //
-                if (bun.strings.hasPrefixComptime(str, "./") or bun.strings.hasPrefixComptime(str, "../")) try_from_extension: {
-                    var pathbuf: bun.PathBuffer = undefined;
-                    var base = str;
-
-                    base = bun.path.joinAbsStringBuf(bun.StandaloneModuleGraph.base_public_path_with_default_suffix, &pathbuf, &.{str}, .loose);
-                    const extname = std.fs.path.extension(base);
-
-                    // ./foo -> ./foo.js
-                    if (extname.len == 0) {
-                        pathbuf[base.len..][0..3].* = ".js".*;
-                        if (graph.find(pathbuf[0 .. base.len + 3])) |js_file| {
-                            break :brk js_file.name;
-                        }
-
-                        break :try_from_extension;
-                    }
-
-                    // ./foo.ts -> ./foo.js
-                    if (bun.strings.eqlComptime(extname, ".ts")) {
-                        pathbuf[base.len - 3 .. base.len][0..3].* = ".js".*;
-                        if (graph.find(pathbuf[0..base.len])) |js_file| {
-                            break :brk js_file.name;
-                        }
-
-                        break :try_from_extension;
-                    }
-
-                    if (extname.len == 4) {
-                        inline for (.{ ".tsx", ".jsx", ".mjs", ".mts", ".cts", ".cjs" }) |ext| {
-                            if (bun.strings.eqlComptime(extname, ext)) {
-                                pathbuf[base.len - ext.len ..][0..".js".len].* = ".js".*;
-                                const as_js = pathbuf[0 .. base.len - ext.len + ".js".len];
-                                if (graph.find(as_js)) |js_file| {
-                                    break :brk js_file.name;
-                                }
-                                break :try_from_extension;
-                            }
-                        }
-                    }
-                }
-            }
-
-            if (JSC.WebCore.ObjectURLRegistry.isBlobURL(str)) {
-                if (JSC.WebCore.ObjectURLRegistry.singleton().has(str["blob:".len..])) {
-                    break :brk str;
-                } else {
-                    error_message.* = bun.String.static("Blob URL is missing");
-                    return null;
-                }
-            }
-
-            var resolved_entry_point: bun.resolver.Result = parent.bundler.resolveEntryPoint(str) catch {
-                const out = temp_log.toJS(parent.global, bun.default_allocator, "Error resolving Worker entry point").toBunString(parent.global);
-                error_message.* = out;
-                return null;
-            };
-
-            const entry_path: *bun.fs.Path = resolved_entry_point.path() orelse {
-                error_message.* = bun.String.static("Worker entry point is missing");
-                return null;
-            };
-            break :brk entry_path.text;
+        const path = resolveEntryPointSpecifier(parent, spec_slice.slice(), error_message, &temp_log) orelse {
+            return null;
         };
 
+        var preloads = std.ArrayList([]const u8).initCapacity(bun.default_allocator, preload_modules_len) catch bun.outOfMemory();
+        for (preload_modules) |module| {
+            const utf8_slice = module.toUTF8(bun.default_allocator);
+            defer utf8_slice.deinit();
+            if (resolveEntryPointSpecifier(parent, utf8_slice.slice(), error_message, &temp_log)) |preload| {
+                preloads.append(bun.default_allocator.dupe(u8, preload) catch bun.outOfMemory()) catch bun.outOfMemory();
+            }
+
+            if (!error_message.isEmpty()) {
+                for (preloads.items) |preload| {
+                    bun.default_allocator.free(preload);
+                }
+                preloads.deinit();
+                return null;
+            }
+        }
+
         var worker = bun.default_allocator.create(WebWorker) catch bun.outOfMemory();
         worker.* = WebWorker{
             .cpp_worker = cpp_worker,
@@ -204,6 +237,7 @@ pub const WebWorker = struct {
             .worker_event_loop_running = true,
             .argv = if (argv_ptr) |ptr| ptr[0..argv_len] else null,
             .execArgv = if (execArgv_ptr) |ptr| ptr[0..execArgv_len] else null,
+            .preloads = preloads.items,
         };
 
         worker.parent_poll_ref.ref(parent);
@@ -249,11 +283,6 @@ pub const WebWorker = struct {
 
         var b = &vm.bundler;
 
-        b.configureRouter(false) catch {
-            this.flushLogs();
-            this.exitAndDeinit();
-            return;
-        };
         b.configureDefines() catch {
             this.flushLogs();
             this.exitAndDeinit();
@@ -287,6 +316,10 @@ pub const WebWorker = struct {
         log("[{d}] deinit", .{this.execution_context_id});
         this.parent_poll_ref.unrefConcurrently(this.parent);
         bun.default_allocator.free(this.specifier);
+        for (this.preloads) |preload| {
+            bun.default_allocator.free(preload);
+        }
+        bun.default_allocator.free(this.preloads);
         bun.default_allocator.destroy(this);
     }
 
@@ -336,7 +369,7 @@ pub const WebWorker = struct {
             bun.outOfMemory();
         };
         JSC.markBinding(@src());
-        WebWorker__dispatchError(globalObject, worker.cpp_worker, bun.String.createUTF8(array.toOwnedSliceLeaky()), error_instance);
+        WebWorker__dispatchError(globalObject, worker.cpp_worker, bun.String.createUTF8(array.slice()), error_instance);
         if (vm.worker) |worker_| {
             _ = worker.setRequestedTerminate();
             worker.parent_poll_ref.unrefConcurrently(worker.parent);
@@ -360,7 +393,7 @@ pub const WebWorker = struct {
         var vm = this.vm.?;
         assert(this.status.load(.acquire) == .start);
         this.setStatus(.starting);
-
+        vm.preload = this.preloads;
         var promise = vm.loadEntryPointForWebWorker(this.specifier) catch {
             this.flushLogs();
             this.exitAndDeinit();
@@ -464,7 +497,9 @@ pub const WebWorker = struct {
         var exit_code: i32 = 0;
         var globalObject: ?*JSC.JSGlobalObject = null;
         var vm_to_deinit: ?*JSC.VirtualMachine = null;
+        var loop: ?*bun.uws.Loop = null;
         if (this.vm) |vm| {
+            loop = vm.uwsLoop();
             this.vm = null;
             vm.is_shutting_down = true;
             vm.onExit();
@@ -475,6 +510,9 @@ pub const WebWorker = struct {
         var arena = this.arena;
 
         WebWorker__dispatchExit(globalObject, cpp_worker, exit_code);
+        if (loop) |loop_| {
+            loop_.internal_loop_data.jsc_vm = null;
+        }
         bun.uws.onThreadExit();
         this.deinit();
 
diff --git a/src/bun.js/webcore.zig b/src/bun.js/webcore.zig
index 87797253b1..3484590697 100644
--- a/src/bun.js/webcore.zig
+++ b/src/bun.js/webcore.zig
@@ -12,6 +12,7 @@ const string = bun.string;
 pub const AbortSignal = @import("./bindings/bindings.zig").AbortSignal;
 pub const JSValue = @import("./bindings/bindings.zig").JSValue;
 const Environment = bun.Environment;
+const UUID7 = @import("./uuid.zig").UUID7;
 
 pub const Lifetime = enum {
     clone,
@@ -22,8 +23,8 @@ 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 {
-    const arguments = callframe.arguments(1).slice();
+fn alert(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+    const arguments = callframe.arguments_old(1).slice();
     var output = bun.Output.writer();
     const has_message = arguments.len != 0;
 
@@ -72,8 +73,8 @@ fn alert(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(
     return .undefined;
 }
 
-fn confirm(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
-    const arguments = callframe.arguments(1).slice();
+fn confirm(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+    const arguments = callframe.arguments_old(1).slice();
     var output = bun.Output.writer();
     const has_message = arguments.len != 0;
 
@@ -210,8 +211,8 @@ pub const Prompt = struct {
     pub fn call(
         globalObject: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) callconv(JSC.conv) JSC.JSValue {
-        const arguments = callframe.arguments(3).slice();
+    ) bun.JSError!JSC.JSValue {
+        const arguments = callframe.arguments_old(3).slice();
         var state = std.heap.stackFallback(2048, bun.default_allocator);
         const allocator = state.get();
         var output = bun.Output.writer();
@@ -369,23 +370,20 @@ 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();
 
         if (keylen_value.isEmptyOrUndefinedOrNull() or !keylen_value.isAnyInt()) {
             const err = globalThis.createInvalidArgs("keylen must be an integer", .{});
-            globalThis.throwValue(err);
-            return .zero;
+            return globalThis.throwValue(err);
         }
 
         const keylen_int = keylen_value.to(i64);
         if (keylen_int < 0) {
-            globalThis.throwValue(globalThis.createRangeError("keylen must be a positive integer", .{}));
-            return .zero;
+            return globalThis.throwValue(globalThis.createRangeError("keylen must be a positive integer", .{}));
         } else if (keylen_int > 0x7fffffff) {
-            globalThis.throwValue(globalThis.createRangeError("keylen must be less than 2^31", .{}));
-            return .zero;
+            return globalThis.throwValue(globalThis.createRangeError("keylen must be less than 2^31", .{}));
         }
 
         var blockSize: ?usize = null;
@@ -399,26 +397,20 @@ pub const Crypto = struct {
                 break :outer;
 
             if (!options_value.isObject()) {
-                globalThis.throwValue(globalThis.createInvalidArgs("options must be an object", .{}));
-                return .zero;
+                return globalThis.throwValue(globalThis.createInvalidArgs("options must be an object", .{}));
             }
 
-            if (options_value.getOwnTruthy(globalThis, "cost") orelse options_value.getOwnTruthy(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.getOwnTruthy(globalThis, "blockSize") orelse options_value.getOwn(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()) {
@@ -433,7 +425,7 @@ pub const Crypto = struct {
                 }
             }
 
-            if (options_value.getOwnTruthy(globalThis, "parallelization") orelse options_value.getOwn(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()) {
@@ -448,7 +440,7 @@ pub const Crypto = struct {
                 }
             }
 
-            if (options_value.getOwnTruthy(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(
@@ -511,8 +503,7 @@ pub const Crypto = struct {
         if (keylen > buf.len) {
             // i don't think its a real scenario, but just in case
             buf = globalThis.allocator().alloc(u8, keylen) catch {
-                globalThis.throw("Failed to allocate memory", .{});
-                return .undefined;
+                return globalThis.throw("Failed to allocate memory", .{});
             };
             needs_deinit = true;
         } else {
@@ -537,46 +528,36 @@ pub const Crypto = struct {
         return JSC.ArrayBuffer.create(globalThis, buf, .ArrayBuffer);
     }
 
-    fn throwInvalidParameter(globalThis: *JSC.JSGlobalObject) JSC.JSValue {
-        globalThis.ERR_CRYPTO_SCRYPT_INVALID_PARAMETER("Invalid scrypt parameters", .{}).throw();
-        return .zero;
+    fn throwInvalidParameter(globalThis: *JSC.JSGlobalObject) bun.JSError {
+        return globalThis.ERR_CRYPTO_SCRYPT_INVALID_PARAMETER("Invalid scrypt parameters", .{}).throw();
     }
 
-    fn throwInvalidParams(globalThis: *JSC.JSGlobalObject, comptime error_type: @Type(.EnumLiteral), comptime message: [:0]const u8, fmt: anytype) JSC.JSValue {
+    fn throwInvalidParams(globalThis: *JSC.JSGlobalObject, comptime error_type: @Type(.EnumLiteral), comptime message: [:0]const u8, fmt: anytype) bun.JSError {
         if (error_type != .RangeError) @compileError("Error type not added!");
-        globalThis.ERR_CRYPTO_INVALID_SCRYPT_PARAMS(message, fmt).throw();
         BoringSSL.ERR_clear_error();
-        return .zero;
+        return globalThis.ERR_CRYPTO_INVALID_SCRYPT_PARAMS(message, fmt).throw();
     }
 
-    pub fn timingSafeEqual(
-        _: *@This(),
-        globalThis: *JSC.JSGlobalObject,
-        callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
-        const arguments = callframe.arguments(2).slice();
+    pub fn timingSafeEqual(_: *@This(), globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+        const arguments = callframe.arguments_old(2).slice();
 
         if (arguments.len < 2) {
-            globalThis.throwInvalidArguments("Expected 2 typed arrays but got nothing", .{});
-            return .undefined;
+            return globalThis.throwInvalidArguments("Expected 2 typed arrays but got nothing", .{});
         }
 
         const array_buffer_a = arguments[0].asArrayBuffer(globalThis) orelse {
-            globalThis.throwInvalidArguments("Expected typed array but got {s}", .{@tagName(arguments[0].jsType())});
-            return .undefined;
+            return globalThis.throwInvalidArguments("Expected typed array but got {s}", .{@tagName(arguments[0].jsType())});
         };
         const a = array_buffer_a.byteSlice();
 
         const array_buffer_b = arguments[1].asArrayBuffer(globalThis) orelse {
-            globalThis.throwInvalidArguments("Expected typed array but got {s}", .{@tagName(arguments[1].jsType())});
-            return .undefined;
+            return globalThis.throwInvalidArguments("Expected typed array but got {s}", .{@tagName(arguments[1].jsType())});
         };
         const b = array_buffer_b.byteSlice();
 
         const len = a.len;
         if (b.len != len) {
-            globalThis.throw("Input buffers must have the same byte length", .{});
-            return .undefined;
+            return globalThis.throw("Input buffers must have the same byte length", .{});
         }
         return JSC.jsBoolean(len == 0 or bun.BoringSSL.CRYPTO_memcmp(a.ptr, b.ptr, len) == 0);
     }
@@ -592,8 +573,7 @@ pub const Crypto = struct {
 
         const len = a.len;
         if (b.len != len) {
-            globalThis.throw("Input buffers must have the same byte length", .{});
-            return .zero;
+            return globalThis.throw("Input buffers must have the same byte length", .{});
         }
 
         return JSC.jsBoolean(len == 0 or bun.BoringSSL.CRYPTO_memcmp(a.ptr, b.ptr, len) == 0);
@@ -603,16 +583,14 @@ pub const Crypto = struct {
         _: *@This(),
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
-        const arguments = callframe.arguments(1).slice();
+    ) bun.JSError!JSC.JSValue {
+        const arguments = callframe.arguments_old(1).slice();
         if (arguments.len == 0) {
-            globalThis.throwInvalidArguments("Expected typed array but got nothing", .{});
-            return .undefined;
+            return globalThis.throwInvalidArguments("Expected typed array but got nothing", .{});
         }
 
         var array_buffer = arguments[0].asArrayBuffer(globalThis) orelse {
-            globalThis.throwInvalidArguments("Expected typed array but got {s}", .{@tagName(arguments[0].jsType())});
-            return .undefined;
+            return globalThis.throwInvalidArguments("Expected typed array but got {s}", .{@tagName(arguments[0].jsType())});
         };
         const slice = array_buffer.byteSlice();
 
@@ -654,7 +632,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();
 
@@ -664,6 +642,62 @@ pub const Crypto = struct {
         return str.toJS(globalThis);
     }
 
+    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;
+
+        const encoding: JSC.Node.Encoding = brk: {
+            if (arguments.len > 0) {
+                if (arguments[0] != .undefined) {
+                    if (arguments[0].isString()) {
+                        encoding_value = arguments[0];
+                        break :brk JSC.Node.Encoding.fromJS(encoding_value, globalThis) orelse {
+                            return globalThis.ERR_UNKNOWN_ENCODING("Encoding must be one of base64, base64url, hex, or buffer", .{}).throw();
+                        };
+                    }
+                }
+            }
+
+            break :brk JSC.Node.Encoding.hex;
+        };
+
+        const timestamp: u64 = brk: {
+            const timestamp_value: JSC.JSValue = if (encoding_value != .undefined and arguments.len > 1)
+                arguments[1]
+            else if (arguments.len == 1 and encoding_value == .undefined)
+                arguments[0]
+            else
+                .undefined;
+
+            if (timestamp_value != .undefined) {
+                if (timestamp_value.isDate()) {
+                    const date = timestamp_value.getUnixTimestamp();
+                    break :brk @intFromFloat(@max(0, date));
+                }
+                break :brk @intCast(try globalThis.validateIntegerRange(timestamp_value, i64, 0, .{ .min = 0, .field_name = "timestamp" }));
+            }
+
+            break :brk @intCast(@max(0, std.time.milliTimestamp()));
+        };
+
+        const entropy = globalThis.bunVM().rareData().entropySlice(8);
+
+        const uuid = UUID7.init(timestamp, &entropy[0..8].*);
+
+        if (encoding == .hex) {
+            var str, var bytes = bun.String.createUninitialized(.latin1, 36);
+            uuid.print(bytes[0..36]);
+            return str.transferToJS(globalThis);
+        }
+
+        return encoding.encodeWithMaxSize(globalThis, 32, &uuid.bytes);
+    }
+
     pub fn randomUUIDWithoutTypeChecks(
         _: *Crypto,
         globalThis: *JSC.JSGlobalObject,
@@ -679,17 +713,15 @@ 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.throw("Crypto is not constructable", .{});
     }
 
     pub export fn CryptoObject__create(globalThis: *JSC.JSGlobalObject) JSC.JSValue {
         JSC.markBinding(@src());
 
         var ptr = bun.default_allocator.create(Crypto) catch {
-            globalThis.throwOutOfMemory();
-            return .zero;
+            return globalThis.throwOutOfMemoryValue();
         };
 
         return ptr.toJS(globalThis);
@@ -706,8 +738,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 10a30fdab8..846c1c0434 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 {
-    const arguments = callframe.arguments(1);
+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_old(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.throwInvalidArguments("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 {
-    const arguments = callframe.arguments(1);
+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_old(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.throwInvalidArguments("revokeObjectURL expects a string", .{});
     }
     const str = arguments.ptr[0].toBunString(globalObject);
     if (!str.hasPrefixComptime("blob:")) {
@@ -132,8 +136,12 @@ 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 {
-    const arguments = callframe.arguments(1);
+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_old(1);
 
     // Errors are ignored.
     // Not thrown.
@@ -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 069228c753..9c1467bf5d 100644
--- a/src/bun.js/webcore/blob.zig
+++ b/src/bun.js/webcore/blob.zig
@@ -27,7 +27,6 @@ const ZigString = JSC.ZigString;
 const IdentityContext = @import("../../identity_context.zig").IdentityContext;
 const JSPromise = JSC.JSPromise;
 const JSValue = JSC.JSValue;
-const JSError = JSC.JSError;
 const JSGlobalObject = JSC.JSGlobalObject;
 const NullableAllocator = bun.NullableAllocator;
 
@@ -49,22 +48,22 @@ 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,
             };
         }
 
-        const arg = args.nextEat() orelse return null;
-
+        const arg = args.nextEat() orelse {
+            return ctx.throwInvalidArgumentTypeValue("destination", "path, file descriptor, or Blob", .undefined);
+        };
         if (arg.as(Blob)) |blob| {
             return PathOrBlob{
                 .blob = blob.*,
             };
         }
-
-        return null;
+        return ctx.throwInvalidArgumentTypeValue("destination", "path, file descriptor, or Blob", arg);
     }
 };
 
@@ -280,7 +279,7 @@ pub const Blob = struct {
 
                                 switch (res) {
                                     .err => |err| {
-                                        globalThis.throwValue(err.toJSC(globalThis));
+                                        globalThis.throwValue(err.toJSC(globalThis)) catch {};
                                         this.failed = true;
                                     },
                                     .result => |result| {
@@ -365,7 +364,7 @@ pub const Blob = struct {
             },
         };
 
-        _onStructuredCloneSerialize(this, Writer, writer) catch return .zero;
+        try _onStructuredCloneSerialize(this, Writer, writer);
     }
 
     pub fn onStructuredCloneTransfer(
@@ -512,16 +511,19 @@ pub const Blob = struct {
         return blob.toJS(globalThis);
     }
 
-    pub fn onStructuredCloneDeserialize(
-        globalThis: *JSC.JSGlobalObject,
-        ptr: [*]u8,
-        end: [*]u8,
-    ) JSValue {
+    pub fn onStructuredCloneDeserialize(globalThis: *JSC.JSGlobalObject, ptr: [*]u8, end: [*]u8) bun.JSError!JSValue {
         const total_length: usize = @intFromPtr(end) - @intFromPtr(ptr);
         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 => {
+                return globalThis.throw("Blob.onStructuredCloneDeserialize failed", .{});
+            },
+            error.OutOfMemory => {
+                return globalThis.throwOutOfMemory();
+            },
+        };
     }
 
     const URLSearchParamsConverter = struct {
@@ -867,7 +869,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);
@@ -878,7 +880,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);
@@ -902,9 +904,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();
@@ -929,7 +931,7 @@ pub const Blob = struct {
 
                 destination_blob.offset,
                 destination_blob.size,
-                ctx.ptr(),
+                ctx,
                 mkdirp_if_not_exists,
             ) catch unreachable;
             file_copier.schedule();
@@ -943,15 +945,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,
             );
         }
@@ -959,25 +960,13 @@ pub const Blob = struct {
         unreachable;
     }
 
-    pub fn writeFile(
-        globalThis: *JSC.JSGlobalObject,
-        callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
-        const arguments = callframe.arguments(3).slice();
+    pub fn writeFile(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+        const arguments = callframe.arguments_old(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", .{});
-            }
-            return .zero;
-        };
+        var path_or_blob = try PathOrBlob.fromJSNoCopy(globalThis, &args);
         defer {
             if (path_or_blob == .path) {
                 path_or_blob.path.deinit();
@@ -985,21 +974,18 @@ pub const Blob = struct {
         }
 
         var data = args.nextEat() orelse {
-            globalThis.throwInvalidArguments("Bun.write(pathOrFdOrBlob, blob) expects a Blob-y thing to write", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("Bun.write(pathOrFdOrBlob, blob) expects a Blob-y thing to write", .{});
         };
 
         if (data.isEmptyOrUndefinedOrNull()) {
-            globalThis.throwInvalidArguments("Bun.write(pathOrFdOrBlob, blob) expects a Blob-y thing to write", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("Bun.write(pathOrFdOrBlob, blob) expects a Blob-y thing to write", .{});
         }
 
         if (path_or_blob == .blob) {
             if (path_or_blob.blob.store == null) {
-                globalThis.throwInvalidArguments("Blob is detached", .{});
-                return .zero;
+                return globalThis.throwInvalidArguments("Blob is detached", .{});
             } else {
-                // TODO only reset last_modified on success pathes instead of
+                // TODO only reset last_modified on success paths instead of
                 // resetting last_modified at the beginning for better performance.
                 if (path_or_blob.blob.store.?.data == .file) {
                     // reset last_modified to force getLastModified() to reload after writing.
@@ -1018,16 +1004,14 @@ pub const Blob = struct {
 
         if (args.nextEat()) |options_object| {
             if (options_object.isObject()) {
-                if (options_object.getOwnTruthy(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;
+                        return globalThis.throwInvalidArgumentType("write", "options.createPath", "boolean");
                     }
                     mkdirp_if_not_exists = create_directory.toBoolean();
                 }
             } else if (!options_object.isEmptyOrUndefinedOrNull()) {
-                globalThis.throwInvalidArgumentType("write", "options", "object");
-                return .zero;
+                return globalThis.throwInvalidArgumentType("write", "options", "object");
             }
         }
 
@@ -1038,8 +1022,7 @@ pub const Blob = struct {
                 path_or_blob.blob.store.?.data == .file and
                 path_or_blob.blob.store.?.data.file.pathlike == .fd)
             {
-                globalThis.throwInvalidArguments("Cannot create a directory for a file descriptor", .{});
-                return .zero;
+                return globalThis.throwInvalidArguments("Cannot create a directory for a file descriptor", .{});
             }
         }
 
@@ -1136,8 +1119,7 @@ pub const Blob = struct {
         } else path_or_blob.blob.dupe();
 
         if (destination_blob.store == null) {
-            globalThis.throwInvalidArguments("Writing to an empty blob is not implemented yet", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("Writing to an empty blob is not implemented yet", .{});
         }
 
         // TODO: implement a writeev() fast path
@@ -1212,15 +1194,9 @@ pub const Blob = struct {
                 false,
             ) catch |err| {
                 if (err == error.InvalidArguments) {
-                    globalThis.throwInvalidArguments(
-                        "Expected an Array",
-                        .{},
-                    );
-                    return .zero;
+                    return globalThis.throwInvalidArguments("Expected an Array", .{});
                 }
-
-                globalThis.throwOutOfMemory();
-                return .zero;
+                return globalThis.throwOutOfMemory();
             };
         };
         defer source_blob.detach();
@@ -1421,38 +1397,39 @@ 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() catch {};
+                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;
-        var arguments = callframe.arguments(3);
+        var arguments = callframe.arguments_old(3);
         const args = arguments.slice();
 
         if (args.len < 2) {
-            globalThis.throwInvalidArguments("new File(bits, name) expects at least 2 arguments", .{});
-            return null;
+            return globalThis.throwInvalidArguments("new File(bits, name) expects at least 2 arguments", .{});
         }
         {
             const name_value_str = bun.String.tryFromJS(args[1], globalThis) orelse {
                 if (!globalThis.hasException()) {
-                    globalThis.throwInvalidArguments("new File(bits, name) expects string as the second argument", .{});
+                    return globalThis.throwInvalidArguments("new File(bits, name) expects string as the second argument", .{});
                 }
-                return null;
+                return error.JSError;
             };
             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;
-                    }
-                    globalThis.throwOutOfMemory();
-                }
-                return null;
+            blob = get(globalThis, args[0], false, true) catch |err| switch (err) {
+                error.JSError, error.OutOfMemory => |e| return e,
+                error.InvalidArguments => {
+                    return globalThis.throwInvalidArguments("new Blob() expects an Array", .{});
+                },
             };
 
             if (blob.store) |store_| {
@@ -1478,7 +1455,7 @@ pub const Blob = struct {
                 // representing the media type of the Blob.
                 // Normative conditions for this member are provided
                 // in the § 3.1 Constructors.
-                if (options.get(globalThis, "type")) |content_type| {
+                if (try options.get(globalThis, "type")) |content_type| {
                     inner: {
                         if (content_type.isString()) {
                             var content_type_str = content_type.toSlice(globalThis, bun.default_allocator);
@@ -1500,7 +1477,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);
                 }
@@ -1542,7 +1519,7 @@ pub const Blob = struct {
             }
         }
 
-        this.reported_estimated_size = size + (this.content_type.len * @intFromBool(this.content_type_allocated));
+        this.reported_estimated_size = size + (this.content_type.len * @intFromBool(this.content_type_allocated)) + this.name.byteSlice().len;
     }
 
     pub fn estimatedSize(this: *Blob) usize {
@@ -1552,29 +1529,20 @@ 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();
+        const arguments = callframe.arguments_old(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 {
+            return globalObject.throwInvalidArguments("Expected file path string or file descriptor", .{});
         };
         defer path.deinitAndUnprotect();
 
@@ -1584,7 +1552,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;
@@ -1605,7 +1573,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);
                 }
             }
@@ -3260,18 +3228,17 @@ 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;
         }
         var recommended_chunk_size: SizeType = 0;
-        var arguments_ = callframe.arguments(2);
+        var arguments_ = callframe.arguments_old(2);
         var arguments = arguments_.ptr[0..arguments_.len];
         if (arguments.len > 0) {
             if (!arguments[0].isNumber() and !arguments[0].isUndefinedOrNull()) {
-                globalThis.throwInvalidArguments("chunkSize must be a number", .{});
-                return JSValue.jsUndefined();
+                return globalThis.throwInvalidArguments("chunkSize must be a number", .{});
             }
 
             recommended_chunk_size = @as(SizeType, @intCast(@max(0, @as(i52, @truncate(arguments[0].toInt64())))));
@@ -3303,9 +3270,9 @@ 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();
+        const args = callframe.arguments_old(1).slice();
 
         return JSC.WebCore.ReadableStream.fromFileBlobWithOffset(
             globalThis,
@@ -3318,7 +3285,7 @@ pub const Blob = struct {
     fn lifetimeWrap(comptime Fn: anytype, comptime lifetime: JSC.WebCore.Lifetime) fn (*Blob, *JSC.JSGlobalObject) JSC.JSValue {
         return struct {
             fn wrap(this: *Blob, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
-                return Fn(this, globalObject, lifetime);
+                return JSC.toJSHostValue(globalObject, Fn(this, globalObject, lifetime));
             }
         }.wrap;
     }
@@ -3327,7 +3294,7 @@ pub const Blob = struct {
         this: *Blob,
         globalThis: *JSC.JSGlobalObject,
         _: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         return this.getTextClone(globalThis);
     }
 
@@ -3355,7 +3322,7 @@ pub const Blob = struct {
         this: *Blob,
         globalThis: *JSC.JSGlobalObject,
         _: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         return this.getJSONShare(globalThis);
     }
 
@@ -3393,7 +3360,7 @@ pub const Blob = struct {
         this: *Blob,
         globalThis: *JSC.JSGlobalObject,
         _: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         return this.getArrayBufferClone(globalThis);
     }
 
@@ -3411,7 +3378,7 @@ pub const Blob = struct {
         this: *Blob,
         globalThis: *JSC.JSGlobalObject,
         _: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         return this.getBytesClone(globalThis);
     }
 
@@ -3429,7 +3396,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();
@@ -3461,7 +3428,7 @@ pub const Blob = struct {
         this: *Blob,
         globalThis: *JSC.JSGlobalObject,
         _: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         return JSC.JSPromise.resolvedPromiseValue(globalThis, this.getExistsSync());
     }
 
@@ -3469,23 +3436,20 @@ pub const Blob = struct {
         this: *Blob,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
-        var arguments_ = callframe.arguments(1);
+    ) bun.JSError!JSC.JSValue {
+        var arguments_ = callframe.arguments_old(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.throwInvalidArguments("options must be an object or undefined", .{});
         }
 
         var store = this.store orelse {
-            globalThis.throwInvalidArguments("Blob is detached", .{});
-            return JSValue.jsUndefined();
+            return globalThis.throwInvalidArguments("Blob is detached", .{});
         };
 
         if (store.data != .file) {
-            globalThis.throwInvalidArguments("Blob is read-only", .{});
-            return JSValue.jsUndefined();
+            return globalThis.throwInvalidArguments("Blob is read-only", .{});
         }
 
         if (Environment.isWindows) {
@@ -3503,8 +3467,7 @@ pub const Blob = struct {
                         break :brk result;
                     },
                     .err => |err| {
-                        globalThis.throwValue(err.withPath(path).toJSC(globalThis));
-                        return JSValue.jsUndefined();
+                        return globalThis.throwValue(err.withPath(path).toJSC(globalThis));
                     },
                 }
                 unreachable;
@@ -3536,20 +3499,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.throwValue(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.throwValue(err.toJSC(globalThis));
                     },
                     else => {},
                 }
@@ -3582,16 +3541,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.throwValue(err.toJSC(globalThis));
             },
             else => {},
         }
@@ -3608,9 +3565,9 @@ 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 arguments_ = callframe.arguments_old(3);
         var args = arguments_.ptr[0..arguments_.len];
 
         if (this.size == 0) {
@@ -3784,7 +3741,7 @@ pub const Blob = struct {
             return true;
         }
         if (value.isString()) {
-            this.name.deref();
+            const old_name = this.name;
 
             this.name = bun.String.tryFromJS(value, globalThis) orelse {
                 // Handle allocation failure.
@@ -3793,6 +3750,7 @@ pub const Blob = struct {
             };
             // We don't need to increment the reference count since tryFromJS already did it.
             Blob.nameSetCached(jsThis, globalThis, value);
+            old_name.deref();
             return true;
         }
         return false;
@@ -3952,13 +3910,10 @@ 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);
+        var arguments = callframe.arguments_old(2);
         const args = arguments.slice();
 
         switch (args.len) {
@@ -3967,14 +3922,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.throwInvalidArguments("new Blob() expects an Array", .{}),
                 };
 
                 if (args.len > 1) {
@@ -3984,7 +3934,7 @@ pub const Blob = struct {
                         // representing the media type of the Blob.
                         // Normative conditions for this member are provided
                         // in the § 3.1 Constructors.
-                        if (options.get(globalThis, "type")) |content_type| {
+                        if (try options.get(globalThis, "type")) |content_type| {
                             inner: {
                                 if (content_type.isString()) {
                                     var content_type_str = content_type.toSlice(globalThis, bun.default_allocator);
@@ -4181,6 +4131,7 @@ pub const Blob = struct {
         } else if (duped.content_type_allocated and duped.allocator != null and include_content_type) {
             duped.content_type = bun.default_allocator.dupe(u8, this.content_type) catch bun.outOfMemory();
         }
+        duped.name = duped.name.dupeRef();
 
         duped.allocator = null;
         return duped;
@@ -4234,7 +4185,7 @@ pub const Blob = struct {
         return this.store != null and this.store.?.data == .file;
     }
 
-    pub fn toStringWithBytes(this: *Blob, global: *JSGlobalObject, raw_bytes: []const u8, comptime lifetime: Lifetime) JSValue {
+    pub fn toStringWithBytes(this: *Blob, global: *JSGlobalObject, raw_bytes: []const u8, comptime lifetime: Lifetime) bun.JSError!JSValue {
         const bom, const buf = strings.BOM.detectAndSplit(raw_bytes);
 
         if (buf.len == 0) {
@@ -4257,10 +4208,7 @@ pub const Blob = struct {
         if (could_be_all_ascii == null or !could_be_all_ascii.?) {
             // if toUTF16Alloc returns null, it means there are no non-ASCII characters
             // instead of erroring, invalid characters will become a U+FFFD replacement character
-            if (strings.toUTF16Alloc(bun.default_allocator, buf, false, false) catch {
-                global.throwOutOfMemory();
-                return .zero;
-            }) |external| {
+            if (strings.toUTF16Alloc(bun.default_allocator, buf, false, false) catch return global.throwOutOfMemory()) |external| {
                 if (lifetime != .temporary)
                     this.setIsASCIIFlag(false);
 
@@ -4318,11 +4266,11 @@ pub const Blob = struct {
         }
     }
 
-    pub fn toStringTransfer(this: *Blob, global: *JSGlobalObject) JSValue {
+    pub fn toStringTransfer(this: *Blob, global: *JSGlobalObject) bun.JSError!JSValue {
         return this.toString(global, .transfer);
     }
 
-    pub fn toString(this: *Blob, global: *JSGlobalObject, comptime lifetime: Lifetime) JSValue {
+    pub fn toString(this: *Blob, global: *JSGlobalObject, comptime lifetime: Lifetime) bun.JSError!JSValue {
         if (this.needsToReadFile()) {
             return this.doReadFile(toStringWithBytes, global);
         }
@@ -4389,23 +4337,22 @@ pub const Blob = struct {
             global.createErrorInstance("FormData encoding failed: {s}", .{@errorName(err)});
     }
 
-    pub fn toArrayBufferWithBytes(this: *Blob, global: *JSGlobalObject, buf: []u8, comptime lifetime: Lifetime) JSValue {
+    pub fn toArrayBufferWithBytes(this: *Blob, global: *JSGlobalObject, buf: []u8, comptime lifetime: Lifetime) bun.JSError!JSValue {
         return toArrayBufferViewWithBytes(this, global, buf, lifetime, .ArrayBuffer);
     }
 
-    pub fn toUint8ArrayWithBytes(this: *Blob, global: *JSGlobalObject, buf: []u8, comptime lifetime: Lifetime) JSValue {
+    pub fn toUint8ArrayWithBytes(this: *Blob, global: *JSGlobalObject, buf: []u8, comptime lifetime: Lifetime) bun.JSError!JSValue {
         return toArrayBufferViewWithBytes(this, global, buf, lifetime, .Uint8Array);
     }
 
-    pub fn toArrayBufferViewWithBytes(this: *Blob, global: *JSGlobalObject, buf: []u8, comptime lifetime: Lifetime, comptime TypedArrayView: JSC.JSValue.JSType) JSValue {
+    pub fn toArrayBufferViewWithBytes(this: *Blob, global: *JSGlobalObject, buf: []u8, comptime lifetime: Lifetime, comptime TypedArrayView: JSC.JSValue.JSType) bun.JSError!JSValue {
         switch (comptime lifetime) {
             .clone => {
                 if (TypedArrayView != .ArrayBuffer) {
                     // ArrayBuffer doesn't have this limit.
                     if (buf.len > JSC.synthetic_allocation_limit) {
-                        global.throwOutOfMemory();
                         this.detach();
-                        return JSValue.zero;
+                        return global.throwOutOfMemory();
                     }
                 }
 
@@ -4444,8 +4391,7 @@ pub const Blob = struct {
             },
             .share => {
                 if (buf.len > JSC.synthetic_allocation_limit and TypedArrayView != .ArrayBuffer) {
-                    global.throwOutOfMemory();
-                    return JSValue.zero;
+                    return global.throwOutOfMemory();
                 }
 
                 this.store.?.ref();
@@ -4458,9 +4404,8 @@ pub const Blob = struct {
             },
             .transfer => {
                 if (buf.len > JSC.synthetic_allocation_limit and TypedArrayView != .ArrayBuffer) {
-                    global.throwOutOfMemory();
                     this.detach();
-                    return JSValue.zero;
+                    return global.throwOutOfMemory();
                 }
 
                 const store = this.store.?;
@@ -4474,9 +4419,8 @@ pub const Blob = struct {
             },
             .temporary => {
                 if (buf.len > JSC.synthetic_allocation_limit and TypedArrayView != .ArrayBuffer) {
-                    global.throwOutOfMemory();
                     bun.default_allocator.free(buf);
-                    return JSValue.zero;
+                    return global.throwOutOfMemory();
                 }
 
                 return JSC.ArrayBuffer.fromBytes(buf, TypedArrayView).toJS(
@@ -4487,17 +4431,17 @@ pub const Blob = struct {
         }
     }
 
-    pub fn toArrayBuffer(this: *Blob, global: *JSGlobalObject, comptime lifetime: Lifetime) JSValue {
+    pub fn toArrayBuffer(this: *Blob, global: *JSGlobalObject, comptime lifetime: Lifetime) bun.JSError!JSValue {
         bloblog("toArrayBuffer", .{});
         return toArrayBufferView(this, global, lifetime, .ArrayBuffer);
     }
 
-    pub fn toUint8Array(this: *Blob, global: *JSGlobalObject, comptime lifetime: Lifetime) JSValue {
+    pub fn toUint8Array(this: *Blob, global: *JSGlobalObject, comptime lifetime: Lifetime) bun.JSError!JSValue {
         bloblog("toUin8Array", .{});
         return toArrayBufferView(this, global, lifetime, .Uint8Array);
     }
 
-    pub fn toArrayBufferView(this: *Blob, global: *JSGlobalObject, comptime lifetime: Lifetime, comptime TypedArrayView: JSC.JSValue.JSType) JSValue {
+    pub fn toArrayBufferView(this: *Blob, global: *JSGlobalObject, comptime lifetime: Lifetime, comptime TypedArrayView: JSC.JSValue.JSType) bun.JSError!JSValue {
         const WithBytesFn = comptime if (TypedArrayView == .Uint8Array)
             toUint8ArrayWithBytes
         else
@@ -4526,24 +4470,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);
     }
 
@@ -4552,7 +4498,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)
@@ -4568,7 +4514,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 };
@@ -4868,7 +4814,7 @@ pub const AnyBlob = union(enum) {
         }
     }
 
-    pub fn toActionValue(this: *AnyBlob, globalThis: *JSGlobalObject, action: JSC.WebCore.BufferedReadableStreamAction) JSC.JSValue {
+    pub fn toActionValue(this: *AnyBlob, globalThis: *JSGlobalObject, action: JSC.WebCore.BufferedReadableStreamAction) bun.JSError!JSC.JSValue {
         if (action != .blob) {
             this.toInternalBlobIfPossible();
         }
@@ -4959,15 +4905,15 @@ pub const AnyBlob = union(enum) {
         return this.toJSON(global, .share);
     }
 
-    pub fn toStringTransfer(this: *AnyBlob, global: *JSGlobalObject) JSValue {
+    pub fn toStringTransfer(this: *AnyBlob, global: *JSGlobalObject) bun.JSError!JSValue {
         return this.toString(global, .transfer);
     }
 
-    pub fn toUint8ArrayTransfer(this: *AnyBlob, global: *JSGlobalObject) JSValue {
+    pub fn toUint8ArrayTransfer(this: *AnyBlob, global: *JSGlobalObject) bun.JSError!JSValue {
         return this.toUint8Array(global, .transfer);
     }
 
-    pub fn toArrayBufferTransfer(this: *AnyBlob, global: *JSGlobalObject) JSValue {
+    pub fn toArrayBufferTransfer(this: *AnyBlob, global: *JSGlobalObject) bun.JSError!JSValue {
         return this.toArrayBuffer(global, .transfer);
     }
 
@@ -4991,7 +4937,7 @@ pub const AnyBlob = union(enum) {
         return blob;
     }
 
-    pub fn toString(this: *AnyBlob, global: *JSGlobalObject, comptime lifetime: JSC.WebCore.Lifetime) JSValue {
+    pub fn toString(this: *AnyBlob, global: *JSGlobalObject, comptime lifetime: JSC.WebCore.Lifetime) bun.JSError!JSValue {
         switch (this.*) {
             .Blob => return this.Blob.toString(global, lifetime),
             // .InlineBlob => {
@@ -5021,15 +4967,15 @@ pub const AnyBlob = union(enum) {
         }
     }
 
-    pub fn toArrayBuffer(this: *AnyBlob, global: *JSGlobalObject, comptime lifetime: JSC.WebCore.Lifetime) JSValue {
+    pub fn toArrayBuffer(this: *AnyBlob, global: *JSGlobalObject, comptime lifetime: JSC.WebCore.Lifetime) bun.JSError!JSValue {
         return this.toArrayBufferView(global, lifetime, .ArrayBuffer);
     }
 
-    pub fn toUint8Array(this: *AnyBlob, global: *JSGlobalObject, comptime lifetime: JSC.WebCore.Lifetime) JSValue {
+    pub fn toUint8Array(this: *AnyBlob, global: *JSGlobalObject, comptime lifetime: JSC.WebCore.Lifetime) bun.JSError!JSValue {
         return this.toArrayBufferView(global, lifetime, .Uint8Array);
     }
 
-    pub fn toArrayBufferView(this: *AnyBlob, global: *JSGlobalObject, comptime lifetime: JSC.WebCore.Lifetime, comptime TypedArrayView: JSC.JSValue.JSType) JSValue {
+    pub fn toArrayBufferView(this: *AnyBlob, global: *JSGlobalObject, comptime lifetime: JSC.WebCore.Lifetime, comptime TypedArrayView: JSC.JSValue.JSType) bun.JSError!JSValue {
         switch (this.*) {
             .Blob => return this.Blob.toArrayBufferView(global, lifetime, TypedArrayView),
             // .InlineBlob => {
diff --git a/src/bun.js/webcore/blob/ReadFile.zig b/src/bun.js/webcore/blob/ReadFile.zig
index 02ab3921b1..2add4b0053 100644
--- a/src/bun.js/webcore/blob/ReadFile.zig
+++ b/src/bun.js/webcore/blob/ReadFile.zig
@@ -37,7 +37,7 @@ pub fn NewReadFileHandler(comptime Function: anytype) type {
                         blob.size = @min(@as(Blob.SizeType, @truncate(bytes.len)), blob.size);
                     const WrappedFn = struct {
                         pub fn wrapped(b: *Blob, g: *JSGlobalObject, by: []u8) JSC.JSValue {
-                            return Function(b, g, by, .temporary);
+                            return JSC.toJSHostValue(g, Function(b, g, by, .temporary));
                         }
                     };
 
@@ -709,9 +709,15 @@ pub const ReadFileUV = struct {
             this.onFinish();
             return;
         }
-
+        // Out of memory we can't read more than 4GB at a time (ULONG) on Windows
+        if (this.size > @as(usize, std.math.maxInt(bun.windows.ULONG))) {
+            this.errno = bun.errnoToZigErr(bun.C.E.NOMEM);
+            this.system_error = bun.sys.Error.fromCode(bun.C.E.NOMEM, .read).toSystemError();
+            this.onFinish();
+            return;
+        }
         // add an extra 16 bytes to the buffer to avoid having to resize it for trailing extra data
-        this.buffer.ensureTotalCapacityPrecise(this.byte_store.allocator, this.size + 16) catch |err| {
+        this.buffer.ensureTotalCapacityPrecise(this.byte_store.allocator, @min(this.size + 16, @as(usize, std.math.maxInt(bun.windows.ULONG)))) catch |err| {
             this.errno = err;
             this.onFinish();
             return;
diff --git a/src/bun.js/webcore/body.zig b/src/bun.js/webcore/body.zig
index 1bae953617..8505ee8789 100644
--- a/src/bun.js/webcore/body.zig
+++ b/src/bun.js/webcore/body.zig
@@ -23,13 +23,11 @@ const Properties = @import("../base.zig").Properties;
 const castObj = @import("../base.zig").castObj;
 const getAllocator = @import("../base.zig").getAllocator;
 
-const GetJSPrivateData = @import("../base.zig").GetJSPrivateData;
 const Environment = @import("../../env.zig");
 const ZigString = JSC.ZigString;
 const IdentityContext = @import("../../identity_context.zig").IdentityContext;
 const JSPromise = JSC.JSPromise;
 const JSValue = JSC.JSValue;
-const JSError = JSC.JSError;
 const JSGlobalObject = JSC.JSGlobalObject;
 const NullableAllocator = bun.NullableAllocator;
 
@@ -160,6 +158,18 @@ pub const Body = struct {
 
             return false;
         }
+
+        pub fn isDisturbed2(this: *const PendingValue, globalObject: *JSC.JSGlobalObject) bool {
+            if (this.promise != null) {
+                return true;
+            }
+
+            if (this.readable.get()) |readable| {
+                return readable.isDisturbed(globalObject);
+            }
+
+            return false;
+        }
         pub fn isStreamingOrBuffering(this: *PendingValue) bool {
             return this.readable.held.has() or (this.promise != null and !this.promise.?.isEmptyOrUndefinedOrNull());
         }
@@ -294,10 +304,10 @@ pub const Body = struct {
         /// Single-use Blob that stores the bytes in the Value itself.
         // InlineBlob: InlineBlob,
         Locked: PendingValue,
-        Used: void,
-        Empty: void,
+        Used,
+        Empty,
         Error: ValueError,
-        Null: void,
+        Null,
 
         pub const heap_breakdown_label = "BodyValue";
         pub const ValueError = union(enum) {
@@ -532,10 +542,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()) {
@@ -581,8 +588,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.throwValue(ZigString.static("Failed to clone ArrayBufferView").toErrorInstance(globalThis));
                                 },
                                 .capacity = bytes.len,
                                 .allocator = bun.default_allocator,
@@ -617,8 +623,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.throw("ReadableStream has already been used", .{});
                 }
 
                 switch (readable.ptr) {
@@ -645,14 +650,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.throwInvalidArguments("Expected an Array", .{});
                         }
 
-                        globalThis.throwInvalidArguments("Invalid Body object", .{});
+                        return globalThis.throwInvalidArguments("Invalid Body object", .{});
                     }
 
-                    return null;
+                    return error.JSError;
                 },
             };
         }
@@ -1093,10 +1097,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
 
@@ -1110,7 +1114,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);
@@ -1167,7 +1171,7 @@ pub fn BodyMixin(comptime Type: type) type {
         fn lifetimeWrap(comptime Fn: anytype, comptime lifetime: JSC.WebCore.Lifetime) fn (*AnyBlob, *JSC.JSGlobalObject) JSC.JSValue {
             return struct {
                 fn wrap(this: *AnyBlob, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
-                    return Fn(this, globalObject, lifetime);
+                    return JSC.toJSHostValue(globalObject, Fn(this, globalObject, lifetime));
                 }
             }.wrap;
         }
@@ -1176,7 +1180,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);
@@ -1206,7 +1210,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) {
@@ -1234,7 +1238,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) {
@@ -1260,7 +1264,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) {
@@ -1310,7 +1314,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());
         }
 
@@ -1512,15 +1516,15 @@ pub const BodyValueBufferer = struct {
         }
     }
 
-    pub fn onResolveStream(_: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSValue {
-        var args = callframe.arguments(2);
+    pub fn onResolveStream(_: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+        var args = callframe.arguments_old(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 {
-        const args = callframe.arguments(2);
+    pub fn onRejectStream(_: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+        const args = callframe.arguments_old(2);
         var sink = args.ptr[args.len - 1].asPromisePtr(@This());
         const err = args.ptr[0];
         sink.handleRejectStream(err, true);
@@ -1708,12 +1712,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 6ac2683709..f50424ea35 100644
--- a/src/bun.js/webcore/encoding.zig
+++ b/src/bun.js/webcore/encoding.zig
@@ -23,13 +23,11 @@ const Properties = @import("../base.zig").Properties;
 const castObj = @import("../base.zig").castObj;
 const getAllocator = @import("../base.zig").getAllocator;
 
-const GetJSPrivateData = @import("../base.zig").GetJSPrivateData;
 const Environment = @import("../../env.zig");
 const ZigString = JSC.ZigString;
 const JSInternalPromise = JSC.JSInternalPromise;
 const JSPromise = JSC.JSPromise;
 const JSValue = JSC.JSValue;
-const JSError = JSC.JSError;
 const JSGlobalObject = JSC.JSGlobalObject;
 
 const VirtualMachine = JSC.VirtualMachine;
@@ -197,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]);
@@ -418,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 {
-        const arguments = callFrame.arguments(1).slice();
+    pub fn encode(this: *TextEncoderStreamEncoder, globalObject: *JSC.JSGlobalObject, callFrame: *JSC.CallFrame) bun.JSError!JSValue {
+        const arguments = callFrame.arguments_old(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);
@@ -464,14 +461,13 @@ pub const TextEncoderStreamEncoder = struct {
         };
         // In a previous benchmark, counting the length took about as much time as allocating the buffer.
         //
-        // Benchmark	Time %	CPU (ns)	Iterations	Ratio
-        // 288.00 ms   13.5%	288.00 ms	 	  simdutf::arm64::implementation::convert_latin1_to_utf8(char const*, unsigned long, char*) const
-        // 278.00 ms   13.0%	278.00 ms	 	  simdutf::arm64::implementation::utf8_length_from_latin1(char const*, unsigned long) const
+        // Benchmark    Time %    CPU (ns)    Iterations    Ratio
+        // 288.00 ms   13.5%    288.00 ms           simdutf::arm64::implementation::convert_latin1_to_utf8(char const*, unsigned long, char*) const
+        // 278.00 ms   13.0%    278.00 ms           simdutf::arm64::implementation::utf8_length_from_latin1(char const*, unsigned long) const
         //
         //
         var buffer = std.ArrayList(u8).initCapacity(bun.default_allocator, input.len + prepend_replacement_len) catch {
-            globalObject.throwOutOfMemory();
-            return .zero;
+            return globalObject.throwOutOfMemoryValue();
         };
         if (prepend_replacement_len > 0) {
             buffer.appendSliceAssumeCapacity(&[3]u8{ 0xef, 0xbf, 0xbd });
@@ -487,14 +483,12 @@ pub const TextEncoderStreamEncoder = struct {
             if (result.written == 0 and result.read == 0) {
                 buffer.ensureUnusedCapacity(2) catch {
                     buffer.deinit();
-                    globalObject.throwOutOfMemory();
-                    return .zero;
+                    return globalObject.throwOutOfMemoryValue();
                 };
             } else if (buffer.items.len == buffer.capacity and remain.len > 0) {
                 buffer.ensureTotalCapacity(buffer.items.len + remain.len + 1) catch {
                     buffer.deinit();
-                    globalObject.throwOutOfMemory();
-                    return .zero;
+                    return globalObject.throwOutOfMemoryValue();
                 };
             }
         }
@@ -559,8 +553,7 @@ pub const TextEncoderStreamEncoder = struct {
             bun.default_allocator,
             length + @as(usize, if (prepend) |pre| pre.len else 0),
         ) catch {
-            globalObject.throwOutOfMemory();
-            return .zero;
+            return globalObject.throwOutOfMemoryValue();
         };
 
         if (prepend) |*pre| {
@@ -574,8 +567,7 @@ pub const TextEncoderStreamEncoder = struct {
                 // Slow path: there was invalid UTF-16, so we need to convert it without simdutf.
                 const lead_surrogate = strings.toUTF8ListWithTypeBun(&buf, []const u16, remain, true) catch {
                     buf.deinit();
-                    globalObject.throwOutOfMemory();
-                    return .zero;
+                    return globalObject.throwOutOfMemoryValue();
                 };
 
                 if (lead_surrogate) |pending_lead| {
@@ -592,7 +584,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);
     }
 
@@ -642,25 +634,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,
@@ -780,8 +754,8 @@ pub const TextDecoder = struct {
         return .{ output, saw_error };
     }
 
-    pub fn decode(this: *TextDecoder, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
-        const arguments = callframe.arguments(2).slice();
+    pub fn decode(this: *TextDecoder, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
+        const arguments = callframe.arguments_old(2).slice();
 
         const input_slice = input_slice: {
             if (arguments.len == 0 or arguments[0].isUndefined()) {
@@ -792,8 +766,7 @@ pub const TextDecoder = struct {
                 break :input_slice array_buffer.slice();
             }
 
-            globalThis.throwInvalidArguments("TextDecoder.decode expects an ArrayBuffer or TypedArray", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("TextDecoder.decode expects an ArrayBuffer or TypedArray", .{});
         };
 
         const stream = stream: {
@@ -815,11 +788,11 @@ pub const TextDecoder = struct {
         };
     }
 
-    pub fn decodeWithoutTypeChecks(this: *TextDecoder, globalThis: *JSC.JSGlobalObject, uint8array: *JSC.JSUint8Array) JSValue {
+    pub fn decodeWithoutTypeChecks(this: *TextDecoder, globalThis: *JSC.JSGlobalObject, uint8array: *JSC.JSUint8Array) bun.JSError!JSValue {
         return this.decodeSlice(globalThis, uint8array.slice(), false);
     }
 
-    fn decodeSlice(this: *TextDecoder, globalThis: *JSC.JSGlobalObject, buffer_slice: []const u8, comptime flush: bool) JSValue {
+    fn decodeSlice(this: *TextDecoder, globalThis: *JSC.JSGlobalObject, buffer_slice: []const u8, comptime flush: bool) bun.JSError!JSValue {
         switch (this.encoding) {
             EncodingLabel.latin1 => {
                 if (strings.isAllASCII(buffer_slice)) {
@@ -831,10 +804,7 @@ pub const TextDecoder = struct {
                 //
                 // It's not clear why we couldn't jusst use Latin1 here, but tests failures proved it necessary.
                 const out_length = strings.elementLengthLatin1IntoUTF16([]const u8, buffer_slice);
-                const bytes = globalThis.allocator().alloc(u16, out_length) catch {
-                    globalThis.throwOutOfMemory();
-                    return .zero;
-                };
+                const bytes = try globalThis.allocator().alloc(u16, out_length);
 
                 const out = strings.copyLatin1IntoUTF16([]u16, bytes, []const u8, buffer_slice);
                 return ZigString.toExternalU16(bytes.ptr, out.written, globalThis);
@@ -848,10 +818,7 @@ pub const TextDecoder = struct {
 
                     if (this.buffered.len > 0) {
                         defer this.buffered.len = 0;
-                        const joined = bun.default_allocator.alloc(u8, maybe_without_bom.len + this.buffered.len) catch {
-                            globalThis.throwOutOfMemory();
-                            return .zero;
-                        };
+                        const joined = try bun.default_allocator.alloc(u8, maybe_without_bom.len + this.buffered.len);
                         @memcpy(joined[0..this.buffered.len], this.buffered.slice());
                         @memcpy(joined[this.buffered.len..][0..maybe_without_bom.len], maybe_without_bom);
                         break :input .{ joined, true };
@@ -865,14 +832,12 @@ pub const TextDecoder = struct {
                         if (deinit) bun.default_allocator.free(input);
                         if (comptime fail_if_invalid) {
                             if (err == error.InvalidByteSequence) {
-                                globalThis.ERR_ENCODING_INVALID_ENCODED_DATA("Invalid byte sequence", .{}).throw();
-                                return .zero;
+                                return globalThis.ERR_ENCODING_INVALID_ENCODED_DATA("Invalid byte sequence", .{}).throw();
                             }
                         }
 
                         bun.assert(err == error.OutOfMemory);
-                        globalThis.throwOutOfMemory();
-                        return .zero;
+                        return globalThis.throwOutOfMemory();
                     },
                 };
 
@@ -902,32 +867,24 @@ pub const TextDecoder = struct {
                 else
                     buffer_slice;
 
-                var decoded, const saw_error = this.decodeUTF16(input, utf16_encoding == .@"UTF-16BE", flush) catch {
-                    globalThis.throwOutOfMemory();
-                    return .zero;
-                };
+                var decoded, const saw_error = try this.decodeUTF16(input, utf16_encoding == .@"UTF-16BE", flush);
 
                 if (saw_error and this.fatal) {
                     decoded.deinit(bun.default_allocator);
-                    globalThis.ERR_ENCODING_INVALID_ENCODED_DATA("The encoded data was not valid {s} data", .{@tagName(utf16_encoding)}).throw();
-                    return .zero;
+                    return globalThis.ERR_ENCODING_INVALID_ENCODED_DATA("The encoded data was not valid {s} data", .{@tagName(utf16_encoding)}).throw();
                 }
 
                 var output = bun.String.fromUTF16(decoded.items);
                 return output.toJS(globalThis);
             },
             else => {
-                globalThis.throwInvalidArguments("TextDecoder.decode set to unsupported encoding", .{});
-                return .zero;
+                return globalThis.throwInvalidArguments("TextDecoder.decode set to unsupported encoding", .{});
             },
         }
     }
 
-    pub fn constructor(
-        globalThis: *JSC.JSGlobalObject,
-        callframe: *JSC.CallFrame,
-    ) ?*TextDecoder {
-        var args_ = callframe.arguments(2);
+    pub fn constructor(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!*TextDecoder {
+        var args_ = callframe.arguments_old(2);
         var arguments: []const JSC.JSValue = args_.ptr[0..args_.len];
 
         var decoder = TextDecoder{};
@@ -941,40 +898,35 @@ 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.throwInvalidArguments("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.throwInvalidArguments("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.throwInvalidArguments("TextDecoder(options) is invalid", .{});
                 }
 
-                if (options.get(globalThis, "fatal")) |fatal| {
+                if (try 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.throwInvalidArguments("TextDecoder(options) fatal is invalid. Expected boolean value", .{});
                     }
                 }
 
-                if (options.get(globalThis, "ignoreBOM")) |ignoreBOM| {
+                if (try options.get(globalThis, "ignoreBOM")) |ignoreBOM| {
                     if (ignoreBOM.isBoolean()) {
                         decoder.ignore_bom = ignoreBOM.asBoolean();
                     } else {
-                        globalThis.throwInvalidArguments("TextDecoder(options) ignoreBOM is invalid. Expected boolean value", .{});
-                        return null;
+                        return globalThis.throwInvalidArguments("TextDecoder(options) ignoreBOM is invalid. Expected boolean value", .{});
                     }
                 }
             }
@@ -1039,27 +991,27 @@ pub const Encoder = struct {
     }
     export fn Bun__encoding__constructFromLatin1(globalObject: *JSGlobalObject, input: [*]const u8, len: usize, encoding: u8) JSValue {
         const slice = switch (@as(JSC.Node.Encoding, @enumFromInt(encoding))) {
-            .hex => constructFromU8(input, len, .hex),
-            .ascii => constructFromU8(input, len, .ascii),
-            .base64url => constructFromU8(input, len, .base64url),
-            .utf16le => constructFromU8(input, len, .utf16le),
-            .ucs2 => constructFromU8(input, len, .utf16le),
-            .utf8 => constructFromU8(input, len, .utf8),
-            .base64 => constructFromU8(input, len, .base64),
+            .hex => constructFromU8(input, len, bun.default_allocator, .hex),
+            .ascii => constructFromU8(input, len, bun.default_allocator, .ascii),
+            .base64url => constructFromU8(input, len, bun.default_allocator, .base64url),
+            .utf16le => constructFromU8(input, len, bun.default_allocator, .utf16le),
+            .ucs2 => constructFromU8(input, len, bun.default_allocator, .utf16le),
+            .utf8 => constructFromU8(input, len, bun.default_allocator, .utf8),
+            .base64 => constructFromU8(input, len, bun.default_allocator, .base64),
             else => unreachable,
         };
         return JSC.JSValue.createBuffer(globalObject, slice, globalObject.bunVM().allocator);
     }
     export fn Bun__encoding__constructFromUTF16(globalObject: *JSGlobalObject, input: [*]const u16, len: usize, encoding: u8) JSValue {
         const slice = switch (@as(JSC.Node.Encoding, @enumFromInt(encoding))) {
-            .base64 => constructFromU16(input, len, .base64),
-            .hex => constructFromU16(input, len, .hex),
-            .base64url => constructFromU16(input, len, .base64url),
-            .utf16le => constructFromU16(input, len, .utf16le),
-            .ucs2 => constructFromU16(input, len, .utf16le),
-            .utf8 => constructFromU16(input, len, .utf8),
-            .ascii => constructFromU16(input, len, .ascii),
-            .latin1 => constructFromU16(input, len, .latin1),
+            .base64 => constructFromU16(input, len, bun.default_allocator, .base64),
+            .hex => constructFromU16(input, len, bun.default_allocator, .hex),
+            .base64url => constructFromU16(input, len, bun.default_allocator, .base64url),
+            .utf16le => constructFromU16(input, len, bun.default_allocator, .utf16le),
+            .ucs2 => constructFromU16(input, len, bun.default_allocator, .utf16le),
+            .utf8 => constructFromU16(input, len, bun.default_allocator, .utf8),
+            .ascii => constructFromU16(input, len, bun.default_allocator, .ascii),
+            .latin1 => constructFromU16(input, len, bun.default_allocator, .latin1),
             else => unreachable,
         };
         return JSC.JSValue.createBuffer(globalObject, slice, globalObject.bunVM().allocator);
@@ -1261,6 +1213,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;
@@ -1440,19 +1457,17 @@ pub const Encoder = struct {
         }
     }
 
-    pub fn constructFrom(comptime T: type, input: []const T, comptime encoding: JSC.Node.Encoding) []u8 {
+    pub fn constructFrom(comptime T: type, input: []const T, allocator: std.mem.Allocator, comptime encoding: JSC.Node.Encoding) []u8 {
         return switch (comptime T) {
-            u16 => constructFromU16(input.ptr, input.len, encoding),
-            u8 => constructFromU8(input.ptr, input.len, encoding),
+            u16 => constructFromU16(input.ptr, input.len, allocator, encoding),
+            u8 => constructFromU8(input.ptr, input.len, allocator, encoding),
             else => @compileError("Unsupported type for constructFrom: " ++ @typeName(T)),
         };
     }
 
-    pub fn constructFromU8(input: [*]const u8, len: usize, comptime encoding: JSC.Node.Encoding) []u8 {
+    pub fn constructFromU8(input: [*]const u8, len: usize, allocator: std.mem.Allocator, comptime encoding: JSC.Node.Encoding) []u8 {
         if (len == 0) return &[_]u8{};
 
-        const allocator = bun.default_allocator;
-
         switch (comptime encoding) {
             .buffer => {
                 var to = allocator.alloc(u8, len) catch return &[_]u8{};
@@ -1500,11 +1515,9 @@ pub const Encoder = struct {
         }
     }
 
-    pub fn constructFromU16(input: [*]const u16, len: usize, comptime encoding: JSC.Node.Encoding) []u8 {
+    pub fn constructFromU16(input: [*]const u16, len: usize, allocator: std.mem.Allocator, comptime encoding: JSC.Node.Encoding) []u8 {
         if (len == 0) return &[_]u8{};
 
-        const allocator = bun.default_allocator;
-
         switch (comptime encoding) {
             .utf8 => {
                 return strings.toUTF8AllocWithType(allocator, []const u16, input[0..len]) catch return &[_]u8{};
@@ -1532,7 +1545,7 @@ pub const Encoder = struct {
                 // shouldn't really happen though
                 const transcoded = strings.toUTF8Alloc(allocator, input[0..len]) catch return &[_]u8{};
                 defer allocator.free(transcoded);
-                return constructFromU8(transcoded.ptr, transcoded.len, encoding);
+                return constructFromU8(transcoded.ptr, transcoded.len, allocator, encoding);
             },
         }
     }
diff --git a/src/bun.js/webcore/request.zig b/src/bun.js/webcore/request.zig
index 61c9c735e2..6d745017ec 100644
--- a/src/bun.js/webcore/request.zig
+++ b/src/bun.js/webcore/request.zig
@@ -24,13 +24,11 @@ const Properties = @import("../base.zig").Properties;
 const castObj = @import("../base.zig").castObj;
 const getAllocator = @import("../base.zig").getAllocator;
 
-const GetJSPrivateData = @import("../base.zig").GetJSPrivateData;
 const Environment = @import("../../env.zig");
 const ZigString = JSC.ZigString;
 const IdentityContext = @import("../../identity_context.zig").IdentityContext;
 const JSPromise = JSC.JSPromise;
 const JSValue = JSC.JSValue;
-const JSError = JSC.JSError;
 const JSGlobalObject = JSC.JSGlobalObject;
 const NullableAllocator = bun.NullableAllocator;
 
@@ -95,13 +93,9 @@ pub const Request = struct {
         this.request_context.enableTimeoutEvents();
     }
 
-    pub export fn Request__setTimeout(
-        this: *Request,
-        seconds: JSC.JSValue,
-        globalThis: *JSC.JSGlobalObject,
-    ) void {
+    pub export fn Request__setTimeout(this: *Request, seconds: JSC.JSValue, globalThis: *JSC.JSGlobalObject) void {
         if (!seconds.isNumber()) {
-            globalThis.throw("Failed to set timeout: The provided value is not of type 'number'.", .{});
+            globalThis.throw("Failed to set timeout: The provided value is not of type 'number'.", .{}) catch {};
             return;
         }
 
@@ -383,12 +377,9 @@ pub const Request = struct {
     ) JSC.JSValue {
         return ZigString.init("").toJS(globalThis);
     }
-    pub fn getUrl(
-        this: *Request,
-        globalObject: *JSC.JSGlobalObject,
-    ) JSC.JSValue {
+    pub fn getUrl(this: *Request, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
         this.ensureURL() catch {
-            globalObject.throw("Failed to join URL", .{});
+            globalObject.throw("Failed to join URL", .{}) catch {}; // TODO: propagate
             return .zero;
         };
 
@@ -526,15 +517,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,
         };
@@ -549,11 +535,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.throw("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.throw("Failed to construct 'Request': expected non-empty string or object, got undefined", .{});
         }
 
         const url_or_object = arguments[0];
@@ -567,16 +551,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.throw("Failed to construct 'Request': expected non-empty string or object", .{});
         }
 
         const values_to_try_ = [_]JSValue{
@@ -612,7 +593,7 @@ pub const Request = struct {
                             fields.insert(.headers);
                         }
 
-                        if (globalThis.hasException()) return null;
+                        if (globalThis.hasException()) return error.JSError;
                     }
 
                     if (!fields.contains(.body)) {
@@ -620,7 +601,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);
                             },
                         }
@@ -657,19 +638,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)) {
@@ -682,17 +661,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,18 +679,18 @@ pub const Request = struct {
                         req.signal = signal.ref();
                     } else {
                         if (!globalThis.hasException()) {
-                            globalThis.throw("Failed to construct 'Request': signal is not of type AbortSignal.", .{});
+                            return 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)) {
@@ -723,7 +702,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)) {
@@ -731,20 +710,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.throw("Failed to construct 'Request': url is required.", .{});
         }
 
         const href = JSC.URL.hrefFromString(req.url);
@@ -752,11 +730,9 @@ pub const Request = struct {
             if (!globalThis.hasException()) {
                 // globalThis.throw can cause GC, which could cause the above string to be freed.
                 // so we must increment the reference count before calling it.
-                globalThis.ERR_INVALID_URL("Failed to construct 'Request': Invalid URL \"{}\"", .{
-                    req.url,
-                }).throw();
+                return globalThis.ERR_INVALID_URL("Failed to construct 'Request': Invalid URL \"{}\"", .{req.url}).throw();
             }
-            return null;
+            return error.JSError;
         }
 
         // hrefFromString increments the reference count if they end up being
@@ -781,16 +757,12 @@ pub const Request = struct {
 
         return req;
     }
-    pub fn constructor(
-        globalThis: *JSC.JSGlobalObject,
-        callframe: *JSC.CallFrame,
-    ) ?*Request {
-        const arguments_ = callframe.arguments(2);
+
+    pub fn constructor(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!*Request {
+        const arguments_ = callframe.arguments_old(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);
     }
 
@@ -804,7 +776,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);
 
@@ -943,7 +915,7 @@ pub const Request = struct {
         const vm = globalThis.bunVM();
         const body = vm.initRequestBodyValue(this.body.value.clone(globalThis)) catch {
             if (!globalThis.hasException()) {
-                globalThis.throw("Failed to clone request", .{});
+                globalThis.throw("Failed to clone request", .{}) catch {};
             }
             return;
         };
diff --git a/src/bun.js/webcore/response.zig b/src/bun.js/webcore/response.zig
index bcbf7b0054..644c853f4c 100644
--- a/src/bun.js/webcore/response.zig
+++ b/src/bun.js/webcore/response.zig
@@ -24,13 +24,11 @@ const Properties = @import("../base.zig").Properties;
 const castObj = @import("../base.zig").castObj;
 const getAllocator = @import("../base.zig").getAllocator;
 
-const GetJSPrivateData = @import("../base.zig").GetJSPrivateData;
 const Environment = @import("../../env.zig");
 const ZigString = JSC.ZigString;
 const IdentityContext = @import("../../identity_context.zig").IdentityContext;
 const JSPromise = JSC.JSPromise;
 const JSValue = JSC.JSValue;
-const JSError = JSC.JSError;
 const JSGlobalObject = JSC.JSGlobalObject;
 const NullableAllocator = bun.NullableAllocator;
 const DataURL = @import("../../resolver/data_url.zig").DataURL;
@@ -206,10 +204,10 @@ pub const Response = struct {
         globalThis: *JSC.JSGlobalObject,
     ) JSC.JSValue {
         if (this.init.status_code < 200) {
-            return ZigString.init("error").toJS(globalThis);
+            return bun.String.static("error").toJS(globalThis);
         }
 
-        return ZigString.init("default").toJS(globalThis);
+        return bun.String.static("default").toJS(globalThis);
     }
 
     pub fn getStatusText(
@@ -262,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()) {
@@ -365,8 +363,8 @@ pub const Response = struct {
     pub fn constructJSON(
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSValue {
-        const args_list = callframe.arguments(2);
+    ) bun.JSError!JSValue {
+        const args_list = callframe.arguments_old(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]);
 
@@ -433,8 +431,8 @@ pub const Response = struct {
     pub fn constructRedirect(
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSValue {
-        var args_list = callframe.arguments(4);
+    ) bun.JSError!JSValue {
+        var args_list = callframe.arguments_old(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]);
 
@@ -455,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;
@@ -495,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{
@@ -511,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;
+    pub fn constructor(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!*Response {
+        const arguments = callframe.argumentsAsArray(2);
+
+        var init: Init = (brk: {
+            if (arguments[1].isUndefinedOrNull()) {
+                break :brk Init{
+                    .status_code = 200,
+                    .headers = null,
+                };
             }
-            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", .{});
-                    }
-
-                    break :brk null;
-                },
+            if (arguments[1].isObject()) {
+                break :brk try Init.init(globalThis, arguments[1]) orelse unreachable;
             }
-            unreachable;
-        }) orelse return null;
+            if (!globalThis.hasException()) {
+                return globalThis.throwInvalidArguments("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{
@@ -618,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);
@@ -654,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);
                 }
             }
 
@@ -669,7 +633,7 @@ pub const Response = struct {
                 } else {
                     if (!globalThis.hasException()) {
                         const err = globalThis.createRangeErrorInstance("The status provided ({d}) must be 101 or in the range of [200, 599]", .{number});
-                        globalThis.throwValue(err);
+                        return globalThis.throwValue(err);
                     }
                     return error.JSError;
                 }
@@ -800,22 +764,18 @@ 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);
+        pub const FetchTaskletStream = JSC.WebCore.FetchTaskletChunkedRequestSink;
 
+        const log = Output.scoped(.FetchTasklet, false);
+        sink: ?*FetchTaskletStream.JSSink = null,
         http: ?*http.AsyncHTTP = null,
         result: http.HTTPClientResult = .{},
         metadata: ?http.HTTPResponseMetadata = null,
         javascript_vm: *VirtualMachine = undefined,
         global_this: *JSGlobalObject = undefined,
         request_body: HTTPRequestBody = undefined,
+
         /// buffer being used by AsyncHTTP
         response_buffer: MutableString = undefined,
         /// buffer used to stream response to JS
@@ -857,6 +817,7 @@ pub const Fetch = struct {
         hostname: ?[]u8 = null,
         is_waiting_body: bool = false,
         is_waiting_abort: bool = false,
+        is_waiting_request_stream_start: bool = false,
         mutex: Mutex,
 
         tracker: JSC.AsyncTaskTracker,
@@ -877,9 +838,24 @@ pub const Fetch = struct {
             }
         }
 
+        pub fn derefFromThread(this: *FetchTasklet) void {
+            const count = this.ref_count.fetchSub(1, .monotonic);
+            bun.debugAssert(count > 0);
+
+            if (count == 1) {
+                // this is really unlikely to happen, but can happen
+                // lets make sure that we always call deinit from main thread
+
+                this.javascript_vm.eventLoop().enqueueTaskConcurrent(JSC.ConcurrentTask.fromCallback(this, FetchTasklet.deinit));
+            }
+        }
+
         pub const HTTPRequestBody = union(enum) {
             AnyBlob: AnyBlob,
             Sendfile: http.Sendfile,
+            ReadableStream: JSC.WebCore.ReadableStream.Strong,
+
+            pub const Empty: HTTPRequestBody = .{ .AnyBlob = .{ .Blob = .{} } };
 
             pub fn store(this: *HTTPRequestBody) ?*JSC.WebCore.Blob.Store {
                 return switch (this.*) {
@@ -898,6 +874,9 @@ pub const Fetch = struct {
             pub fn detach(this: *HTTPRequestBody) void {
                 switch (this.*) {
                     .AnyBlob => this.AnyBlob.detach(),
+                    .ReadableStream => |*stream| {
+                        stream.deinit();
+                    },
                     .Sendfile => {
                         if (@max(this.Sendfile.offset, this.Sendfile.remain) > 0)
                             _ = bun.sys.close(this.Sendfile.fd);
@@ -906,12 +885,71 @@ pub const Fetch = struct {
                     },
                 }
             }
+
+            pub fn fromJS(globalThis: *JSGlobalObject, value: JSValue) bun.JSError!HTTPRequestBody {
+                var body_value = try Body.Value.fromJS(globalThis, value);
+                if (body_value == .Used or (body_value == .Locked and (body_value.Locked.action != .none or body_value.Locked.isDisturbed2(globalThis)))) {
+                    return globalThis.ERR_BODY_ALREADY_USED("body already used", .{}).throw();
+                }
+                if (body_value == .Locked) {
+                    if (body_value.Locked.readable.has()) {
+                        // just grab the ref
+                        return FetchTasklet.HTTPRequestBody{ .ReadableStream = body_value.Locked.readable };
+                    }
+                    const readable = body_value.toReadableStream(globalThis);
+                    if (!readable.isEmptyOrUndefinedOrNull() and body_value == .Locked and body_value.Locked.readable.has()) {
+                        return FetchTasklet.HTTPRequestBody{ .ReadableStream = body_value.Locked.readable };
+                    }
+                }
+                return FetchTasklet.HTTPRequestBody{ .AnyBlob = body_value.useAsAnyBlob() };
+            }
+
+            pub fn needsToReadFile(this: *HTTPRequestBody) bool {
+                return switch (this.*) {
+                    .AnyBlob => |blob| blob.needsToReadFile(),
+                    else => false,
+                };
+            }
+
+            pub fn hasContentTypeFromUser(this: *HTTPRequestBody) bool {
+                return switch (this.*) {
+                    .AnyBlob => |blob| blob.hasContentTypeFromUser(),
+                    else => false,
+                };
+            }
+
+            pub fn getAnyBlob(this: *HTTPRequestBody) ?*AnyBlob {
+                return switch (this.*) {
+                    .AnyBlob => &this.AnyBlob,
+                    else => null,
+                };
+            }
+
+            pub fn hasBody(this: *HTTPRequestBody) bool {
+                return switch (this.*) {
+                    .AnyBlob => |blob| blob.size() > 0,
+                    .ReadableStream => |*stream| stream.has(),
+                    .Sendfile => true,
+                };
+            }
         };
 
         pub fn init(_: std.mem.Allocator) anyerror!FetchTasklet {
             return FetchTasklet{};
         }
 
+        fn clearSink(this: *FetchTasklet) void {
+            if (this.sink) |wrapper| {
+                this.sink = null;
+
+                wrapper.sink.done = true;
+                wrapper.sink.ended = true;
+                wrapper.sink.finalize();
+                wrapper.detach();
+                wrapper.sink.finalizeAndDestroy();
+            }
+        }
+
         fn clearData(this: *FetchTasklet) void {
             log("clearData", .{});
             const allocator = this.memory_reporter.allocator();
@@ -954,14 +992,16 @@ pub const Fetch = struct {
             this.readable_stream_ref.deinit();
 
             this.scheduled_response_buffer.deinit();
-            this.request_body.detach();
+            if (this.request_body != .ReadableStream or this.is_waiting_request_stream_start) {
+                this.request_body.detach();
+            }
 
             this.abort_reason.deinit();
             this.check_server_identity.deinit();
             this.clearAbortSignal();
         }
 
-        fn deinit(this: *FetchTasklet) void {
+        pub fn deinit(this: *FetchTasklet) void {
             log("deinit", .{});
 
             bun.assert(this.ref_count.load(.monotonic) == 0);
@@ -996,6 +1036,144 @@ pub const Fetch = struct {
             return null;
         }
 
+        pub fn onResolveRequestStream(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+            var args = callframe.arguments_old(2);
+            var this: *@This() = args.ptr[args.len - 1].asPromisePtr(@This());
+            defer this.deref();
+            if (this.request_body == .ReadableStream) {
+                var readable_stream_ref = this.request_body.ReadableStream;
+                this.request_body.ReadableStream = .{};
+                defer readable_stream_ref.deinit();
+                if (readable_stream_ref.get()) |stream| {
+                    stream.done(globalThis);
+                    this.clearSink();
+                }
+            }
+
+            return JSValue.jsUndefined();
+        }
+
+        pub fn onRejectRequestStream(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+            const args = callframe.arguments_old(2);
+            var this = args.ptr[args.len - 1].asPromisePtr(@This());
+            defer this.deref();
+            const err = args.ptr[0];
+            if (this.request_body == .ReadableStream) {
+                var readable_stream_ref = this.request_body.ReadableStream;
+                this.request_body.ReadableStream = .{};
+                defer readable_stream_ref.deinit();
+                if (readable_stream_ref.get()) |stream| {
+                    stream.cancel(globalThis);
+                    this.clearSink();
+                }
+            }
+
+            this.abortListener(err);
+            return JSValue.jsUndefined();
+        }
+        pub const shim = JSC.Shimmer("Bun", "FetchTasklet", @This());
+
+        pub const Export = shim.exportFunctions(.{
+            .onResolveRequestStream = onResolveRequestStream,
+            .onRejectRequestStream = onRejectRequestStream,
+        });
+        comptime {
+            const jsonResolveRequestStream = JSC.toJSHostFunction(onResolveRequestStream);
+            @export(jsonResolveRequestStream, .{ .name = Export[0].symbol_name });
+            const jsonRejectRequestStream = JSC.toJSHostFunction(onRejectRequestStream);
+            @export(jsonRejectRequestStream, .{ .name = Export[1].symbol_name });
+        }
+
+        pub fn startRequestStream(this: *FetchTasklet) void {
+            this.is_waiting_request_stream_start = false;
+            bun.assert(this.request_body == .ReadableStream);
+            if (this.request_body.ReadableStream.get()) |stream| {
+                this.ref(); // lets only unref when sink is done
+
+                const globalThis = this.global_this;
+                var response_stream = FetchTaskletStream.new(.{
+                    .task = this,
+                    .buffer = .{},
+                    .globalThis = globalThis,
+                }).toSink();
+                var signal = &response_stream.sink.signal;
+                this.sink = response_stream;
+
+                signal.* = FetchTaskletStream.JSSink.SinkSignal.init(JSValue.zero);
+
+                // explicitly set it to a dead pointer
+                // we use this memory address to disable signals being sent
+                signal.clear();
+                bun.assert(signal.isDead());
+
+                // We are already corked!
+                const assignment_result: JSValue = FetchTaskletStream.JSSink.assignToStream(
+                    globalThis,
+                    stream.value,
+                    response_stream,
+                    @as(**anyopaque, @ptrCast(&signal.ptr)),
+                );
+
+                assignment_result.ensureStillAlive();
+
+                // assert that it was updated
+                bun.assert(!signal.isDead());
+
+                if (assignment_result.toError()) |err_value| {
+                    response_stream.detach();
+                    this.sink = null;
+                    response_stream.sink.finalizeAndDestroy();
+                    return this.abortListener(err_value);
+                }
+
+                if (!assignment_result.isEmptyOrUndefinedOrNull()) {
+                    this.javascript_vm.drainMicrotasks();
+
+                    assignment_result.ensureStillAlive();
+                    // it returns a Promise when it goes through ReadableStreamDefaultReader
+                    if (assignment_result.asAnyPromise()) |promise| {
+                        switch (promise.status(globalThis.vm())) {
+                            .pending => {
+                                this.ref();
+                                assignment_result.then(
+                                    globalThis,
+                                    this,
+                                    onResolveRequestStream,
+                                    onRejectRequestStream,
+                                );
+                            },
+                            .fulfilled => {
+                                var readable_stream_ref = this.request_body.ReadableStream;
+                                this.request_body.ReadableStream = .{};
+                                defer {
+                                    stream.done(globalThis);
+                                    this.clearSink();
+                                    readable_stream_ref.deinit();
+                                }
+                            },
+                            .rejected => {
+                                var readable_stream_ref = this.request_body.ReadableStream;
+                                this.request_body.ReadableStream = .{};
+                                defer {
+                                    stream.cancel(globalThis);
+                                    this.clearSink();
+                                    readable_stream_ref.deinit();
+                                }
+
+                                this.abortListener(promise.result(globalThis.vm()));
+                            },
+                        }
+                        return;
+                    } else {
+                        // if is not a promise we treat it as Error
+                        response_stream.detach();
+                        this.sink = null;
+                        response_stream.sink.finalizeAndDestroy();
+                        return this.abortListener(assignment_result);
+                    }
+                }
+            }
+        }
         pub fn onBodyReceived(this: *FetchTasklet) void {
             const success = this.result.isSuccess();
             const globalThis = this.global_this;
@@ -1172,11 +1350,17 @@ pub const Fetch = struct {
                     this.deref();
                 }
             }
+            if (this.is_waiting_request_stream_start and this.result.can_stream) {
+                // start streaming
+                this.startRequestStream();
+            }
             // if we already respond the metadata and still need to process the body
             if (this.is_waiting_body) {
                 this.onBodyReceived();
                 return;
             }
+            if (this.metadata == null and this.result.isSuccess()) return;
+
             // if we abort because of cert error
             // we wait the Http Client because we already have the response
             // we just need to deinit
@@ -1226,7 +1410,6 @@ pub const Fetch = struct {
                 this.promise.deinit();
             }
             const success = this.result.isSuccess();
-
             const result = switch (success) {
                 true => JSC.Strong.create(this.onResolve(), globalThis),
                 false => brk: {
@@ -1295,17 +1478,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() catch {},
+                            }
+                            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()) {
@@ -1733,7 +1927,18 @@ pub const Fetch = struct {
                     .tls_props = fetch_options.ssl_config,
                 },
             );
-
+            // enable streaming the write side
+            const isStream = fetch_tasklet.request_body == .ReadableStream;
+            fetch_tasklet.http.?.client.flags.is_streaming_request_body = isStream;
+            fetch_tasklet.is_waiting_request_stream_start = isStream;
+            if (isStream) {
+                fetch_tasklet.http.?.request_body = .{
+                    .stream = .{
+                        .buffer = .{},
+                        .ended = false,
+                    },
+                };
+            }
             // TODO is this necessary? the http client already sets the redirect type,
             // so manually setting it here seems redundant
             if (fetch_options.redirect_type != FetchRedirect.follow) {
@@ -1760,6 +1965,22 @@ pub const Fetch = struct {
             log("abortListener", .{});
             reason.ensureStillAlive();
             this.abort_reason.set(this.global_this, reason);
+            this.abortTask();
+            if (this.sink) |wrapper| {
+                wrapper.sink.abort();
+                return;
+            }
+        }
+
+        pub fn sendRequestData(this: *FetchTasklet, data: []const u8, ended: bool) void {
+            if (this.http) |http_| {
+                http.http_thread.scheduleRequestWrite(http_, data, ended);
+            } else if (data.len != 3) {
+                bun.default_allocator.free(data);
+            }
+        }
+
+        pub fn abortTask(this: *FetchTasklet) void {
             this.signal_store.aborted.store(true, .monotonic);
             this.tracker.didCancel(this.global_this);
 
@@ -1797,7 +2018,7 @@ pub const Fetch = struct {
             fetch_options: FetchOptions,
             promise: JSC.JSPromise.Strong,
         ) !*FetchTasklet {
-            http.HTTPThread.init();
+            http.HTTPThread.init(&.{});
             var node = try get(
                 allocator,
                 global,
@@ -1817,12 +2038,15 @@ pub const Fetch = struct {
         }
 
         pub fn callback(task: *FetchTasklet, async_http: *http.AsyncHTTP, result: http.HTTPClientResult) void {
-            task.mutex.lock();
-            defer task.mutex.unlock();
+            // at this point only this thread is accessing result to is no race condition
             const is_done = !result.has_more;
             // we are done with the http client so we can deref our side
-            defer if (is_done) task.deref();
+            // this is a atomic operation and will enqueue a task to deinit on the main thread
+            defer if (is_done) task.derefFromThread();
 
+            task.mutex.lock();
+            // we need to unlock before task.deref();
+            defer task.mutex.unlock();
             task.http.?.* = async_http.*;
             task.http.?.response_buffer = async_http.response_buffer;
 
@@ -1928,18 +2152,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 {
-        const arguments = callframe.arguments(1).slice();
+    ) bun.JSError!JSC.JSValue {
+        const arguments = callframe.arguments_old(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()) {
@@ -1947,32 +2174,27 @@ pub const Fetch = struct {
         }
 
         if (url_str.tag == .Dead) {
-            globalObject.ERR_INVALID_ARG_TYPE("Invalid URL", .{}).throw();
-            return .zero;
+            return globalObject.ERR_INVALID_ARG_TYPE("Invalid URL", .{}).throw();
         }
 
         if (url_str.isEmpty()) {
-            globalObject.ERR_INVALID_ARG_TYPE(fetch_error_blank_url, .{}).throw();
-            return .zero;
+            return globalObject.ERR_INVALID_ARG_TYPE(fetch_error_blank_url, .{}).throw();
         }
 
         const url = ZigURL.parse(url_str.toOwnedSlice(bun.default_allocator) catch bun.outOfMemory());
         if (!url.isHTTP() and !url.isHTTPS()) {
-            globalObject.throwInvalidArguments("URL must be HTTP or HTTPS", .{});
             bun.default_allocator.free(url.href);
-            return .zero;
+            return globalObject.throwInvalidArguments("URL must be HTTP or HTTPS", .{});
         }
 
         if (url.hostname.len == 0) {
-            globalObject.ERR_INVALID_ARG_TYPE(fetch_error_blank_url, .{}).throw();
             bun.default_allocator.free(url.href);
-            return .zero;
+            return globalObject.ERR_INVALID_ARG_TYPE(fetch_error_blank_url, .{}).throw();
         }
 
         if (!url.hasValidPort()) {
-            globalObject.throwInvalidArguments("Invalid port", .{});
             bun.default_allocator.free(url.href);
-            return .zero;
+            return globalObject.throwInvalidArguments("Invalid port", .{});
         }
 
         bun.http.AsyncHTTP.preconnect(url, true);
@@ -1980,41 +2202,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 arguments = callframe.arguments(2);
+        const globalThis = ctx;
+        const arguments = callframe.arguments_old(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);
@@ -2040,9 +2258,7 @@ pub const Fetch = struct {
         // which is important for FormData.
         // https://github.com/oven-sh/bun/issues/2264
         //
-        var body: AnyBlob = AnyBlob{
-            .Blob = .{},
-        };
+        var body: FetchTasklet.HTTPRequestBody = FetchTasklet.HTTPRequestBody.Empty;
 
         var disable_timeout = false;
         var disable_keepalive = false;
@@ -2077,10 +2293,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);
@@ -2126,7 +2338,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;
@@ -2150,9 +2362,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);
                     }
                 }
             }
@@ -2219,7 +2429,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_);
                 }
 
@@ -2234,7 +2444,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_);
                 }
 
@@ -2261,7 +2471,7 @@ pub const Fetch = struct {
 
             inline for (0..2) |i| {
                 if (objects_to_try[i] != .zero) {
-                    if (objects_to_try[i].get(globalThis, "decompress")) |decompression_value| {
+                    if (try objects_to_try[i].get(globalThis, "decompress")) |decompression_value| {
                         if (decompression_value.isBoolean()) {
                             break :extract_disable_decompression !decompression_value.asBoolean();
                         } else if (decompression_value.isNumber()) {
@@ -2293,9 +2503,9 @@ pub const Fetch = struct {
 
             inline for (0..2) |i| {
                 if (objects_to_try[i] != .zero) {
-                    if (objects_to_try[i].get(globalThis, "tls")) |tls| {
+                    if (try objects_to_try[i].get(globalThis, "tls")) |tls| {
                         if (tls.isObject()) {
-                            if (tls.get(ctx, "rejectUnauthorized")) |reject| {
+                            if (try tls.get(ctx, "rejectUnauthorized")) |reject| {
                                 if (reject.isBoolean()) {
                                     reject_unauthorized = reject.asBoolean();
                                 } else if (reject.isNumber()) {
@@ -2308,7 +2518,7 @@ pub const Fetch = struct {
                                 return .zero;
                             }
 
-                            if (tls.get(ctx, "checkServerIdentity")) |checkServerIdentity| {
+                            if (try tls.get(ctx, "checkServerIdentity")) |checkServerIdentity| {
                                 if (checkServerIdentity.isCell() and checkServerIdentity.isCallable(globalThis.vm())) {
                                     check_server_identity = checkServerIdentity;
                                 }
@@ -2319,21 +2529,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;
-                            }
                         }
                     }
                 }
@@ -2356,7 +2559,7 @@ pub const Fetch = struct {
 
             inline for (0..2) |i| {
                 if (objects_to_try[i] != .zero) {
-                    if (objects_to_try[i].get(globalThis, "unix")) |socket_path| {
+                    if (try objects_to_try[i].get(globalThis, "unix")) |socket_path| {
                         if (socket_path.isString() and socket_path.getLength(ctx) > 0) {
                             if (socket_path.toSliceCloneWithAllocator(globalThis, allocator)) |slice| {
                                 break :extract_unix_socket_path slice;
@@ -2387,7 +2590,7 @@ pub const Fetch = struct {
 
             inline for (0..2) |i| {
                 if (objects_to_try[i] != .zero) {
-                    if (objects_to_try[i].get(globalThis, "timeout")) |timeout_value| {
+                    if (try objects_to_try[i].get(globalThis, "timeout")) |timeout_value| {
                         if (timeout_value.isBoolean()) {
                             break :extract_disable_timeout !timeout_value.asBoolean();
                         } else if (timeout_value.isNumber()) {
@@ -2445,7 +2648,7 @@ pub const Fetch = struct {
 
             inline for (0..2) |i| {
                 if (objects_to_try[i] != .zero) {
-                    if (objects_to_try[i].get(globalThis, "keepalive")) |keepalive_value| {
+                    if (try objects_to_try[i].get(globalThis, "keepalive")) |keepalive_value| {
                         if (keepalive_value.isBoolean()) {
                             break :extract_disable_keepalive !keepalive_value.asBoolean();
                         } else if (keepalive_value.isNumber()) {
@@ -2477,7 +2680,7 @@ pub const Fetch = struct {
 
             inline for (0..2) |i| {
                 if (objects_to_try[i] != .zero) {
-                    if (objects_to_try[i].get(globalThis, "verbose")) |verb| {
+                    if (try objects_to_try[i].get(globalThis, "verbose")) |verb| {
                         if (verb.isString()) {
                             if (verb.getZigString(globalThis).eqlComptime("curl")) {
                                 break :extract_verbose .curl;
@@ -2504,19 +2707,16 @@ pub const Fetch = struct {
             };
             inline for (0..2) |i| {
                 if (objects_to_try[i] != .zero) {
-                    if (objects_to_try[i].get(globalThis, "proxy")) |proxy_arg| {
+                    if (try 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;
                                 return JSPromise.rejectedPromiseValue(globalThis, err);
                             }
                             defer href.deref();
-                            const buffer = std.fmt.allocPrint(allocator, "{s}{}", .{ url_proxy_buffer, href }) catch {
-                                globalThis.throwOutOfMemory();
-                                return .zero;
-                            };
+                            const buffer = try std.fmt.allocPrint(allocator, "{s}{}", .{ url_proxy_buffer, href });
                             url = ZigURL.parse(buffer[0..url.href.len]);
                             if (url.isFile()) {
                                 url_type = URLType.file;
@@ -2548,7 +2748,7 @@ pub const Fetch = struct {
         // signal: AbortSignal | undefined;
         signal = extract_signal: {
             if (options_object) |options| {
-                if (options.get(globalThis, "signal")) |signal_| {
+                if (try options.get(globalThis, "signal")) |signal_| {
                     if (!signal_.isUndefined()) {
                         if (signal_.as(JSC.WebCore.AbortSignal)) |signal__| {
                             break :extract_signal signal__.ref();
@@ -2570,7 +2770,7 @@ pub const Fetch = struct {
             }
 
             if (request_init_object) |options| {
-                if (options.get(globalThis, "signal")) |signal_| {
+                if (try options.get(globalThis, "signal")) |signal_| {
                     if (signal_.isUndefined()) {
                         break :extract_signal null;
                     }
@@ -2598,10 +2798,7 @@ 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();
-                        }
+                        break :extract_body try FetchTasklet.HTTPRequestBody.fromJS(ctx, body__);
                     }
                 }
 
@@ -2613,27 +2810,32 @@ pub const Fetch = struct {
 
             if (request) |req| {
                 if (req.body.value == .Used or (req.body.value == .Locked and (req.body.value.Locked.action != .none or req.body.value.Locked.isDisturbed(Request, globalThis, first_arg)))) {
-                    globalThis.ERR_BODY_ALREADY_USED("Request body already used", .{}).throw();
-                    is_error = true;
-                    return .zero;
+                    return globalThis.ERR_BODY_ALREADY_USED("Request body already used", .{}).throw();
                 }
 
-                break :extract_body req.body.value.useAsAnyBlob();
+                if (req.body.value == .Locked) {
+                    if (req.body.value.Locked.readable.has()) {
+                        break :extract_body FetchTasklet.HTTPRequestBody{ .ReadableStream = JSC.WebCore.ReadableStream.Strong.init(req.body.value.Locked.readable.get().?, globalThis) };
+                    }
+                    const readable = req.body.value.toReadableStream(globalThis);
+                    if (!readable.isEmptyOrUndefinedOrNull() and req.body.value == .Locked and req.body.value.Locked.readable.has()) {
+                        break :extract_body FetchTasklet.HTTPRequestBody{ .ReadableStream = JSC.WebCore.ReadableStream.Strong.init(req.body.value.Locked.readable.get().?, globalThis) };
+                    }
+                }
+
+                break :extract_body FetchTasklet.HTTPRequestBody{ .AnyBlob = req.body.value.useAsAnyBlob() };
             }
 
             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();
-                        }
+                        break :extract_body try FetchTasklet.HTTPRequestBody.fromJS(ctx, body__);
                     }
                 }
             }
 
             break :extract_body null;
-        } orelse AnyBlob{ .Blob = .{} };
+        } orelse FetchTasklet.HTTPRequestBody.Empty;
 
         if (globalThis.hasException()) {
             is_error = true;
@@ -2661,7 +2863,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__;
                             }
@@ -2695,7 +2897,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__;
                             }
@@ -2727,7 +2929,7 @@ pub const Fetch = struct {
                     hostname = _hostname.toOwnedSliceZ(allocator) catch bun.outOfMemory();
                 }
 
-                break :extract_headers Headers.from(headers_, allocator, .{ .body = &body }) catch bun.outOfMemory();
+                break :extract_headers Headers.from(headers_, allocator, .{ .body = body.getAnyBlob() }) catch bun.outOfMemory();
             }
 
             break :extract_headers headers;
@@ -2767,8 +2969,7 @@ pub const Fetch = struct {
                     .remote => unreachable,
                 },
             ) catch |err| {
-                globalThis.throwError(err, "Failed to decode file url");
-                return .zero;
+                return globalThis.throwError(err, "Failed to decode file url");
             }];
             var url_string: bun.String = bun.String.empty;
             defer url_string.deref();
@@ -2798,8 +2999,7 @@ pub const Fetch = struct {
                                 url_path_decoded = url_path_decoded[1..];
                             }
                             break :brk PosixToWinNormalizer.resolveCWDWithExternalBufZ(&path_buf, url_path_decoded) catch |err| {
-                                globalThis.throwError(err, "Failed to resolve file url");
-                                return .zero;
+                                return globalThis.throwError(err, "Failed to resolve file url");
                             };
                         }
                         break :brk url_path_decoded;
@@ -2807,8 +3007,7 @@ pub const Fetch = struct {
 
                     var cwd_buf: bun.PathBuffer = undefined;
                     const cwd = if (Environment.isWindows) (bun.getcwd(&cwd_buf) catch |err| {
-                        globalThis.throwError(err, "Failed to resolve file url");
-                        return .zero;
+                        return globalThis.throwError(err, "Failed to resolve file url");
                     }) else globalThis.bunVM().bundler.fs.top_level_dir;
 
                     const fullpath = bun.path.joinAbsStringBuf(
@@ -2823,8 +3022,7 @@ pub const Fetch = struct {
                     );
                     if (Environment.isWindows) {
                         break :brk PosixToWinNormalizer.resolveCWDWithExternalBufZ(&path_buf2, fullpath) catch |err| {
-                            globalThis.throwError(err, "Failed to resolve file url");
-                            return .zero;
+                            return globalThis.throwError(err, "Failed to resolve file url");
                         };
                     }
                     break :brk fullpath;
@@ -2834,10 +3032,7 @@ pub const Fetch = struct {
 
                 var pathlike: JSC.Node.PathOrFileDescriptor = .{
                     .path = .{
-                        .encoded_slice = ZigString.Slice.init(bun.default_allocator, bun.default_allocator.dupe(u8, temp_file_path) catch {
-                            globalThis.throwOutOfMemory();
-                            return .zero;
-                        }),
+                        .encoded_slice = ZigString.Slice.init(bun.default_allocator, try bun.default_allocator.dupe(u8, temp_file_path)),
                     },
                 };
 
@@ -2868,27 +3063,25 @@ pub const Fetch = struct {
             }
         }
 
-        if (!method.hasRequestBody() and body.size() > 0) {
+        if (!method.hasRequestBody() and body.hasBody()) {
             const err = JSC.toTypeError(.ERR_INVALID_ARG_VALUE, fetch_error_unexpected_body, .{}, ctx);
             is_error = true;
             return JSPromise.rejectedPromiseValue(globalThis, err);
         }
 
-        if (headers == null and body.size() > 0 and body.hasContentTypeFromUser()) {
+        if (headers == null and body.hasBody() and body.hasContentTypeFromUser()) {
             headers = Headers.from(
                 null,
                 allocator,
-                .{ .body = &body },
+                .{ .body = body.getAnyBlob() },
             ) catch bun.outOfMemory();
         }
 
-        var http_body = FetchTasklet.HTTPRequestBody{
-            .AnyBlob = body,
-        };
+        var http_body = body;
 
         if (body.needsToReadFile()) {
             prepare_body: {
-                const opened_fd_res: JSC.Maybe(bun.FileDescriptor) = switch (body.Blob.store.?.data.file.pathlike) {
+                const opened_fd_res: JSC.Maybe(bun.FileDescriptor) = switch (body.store().?.data.file.pathlike) {
                     .fd => |fd| bun.sys.dup(fd),
                     .path => |path| bun.sys.open(path.sliceZ(&globalThis.bunVM().nodeFS().sync_error_buf), if (Environment.isWindows) bun.O.RDONLY else bun.O.RDONLY | bun.O.NOCTTY, 0),
                 };
@@ -2922,7 +3115,7 @@ pub const Fetch = struct {
                             break :use_sendfile;
                         }
 
-                        const original_size = body.Blob.size;
+                        const original_size = body.AnyBlob.Blob.size;
                         const stat_size = @as(Blob.SizeType, @intCast(stat.size));
                         const blob_size = if (bun.isRegularFile(stat.mode))
                             stat_size
@@ -2932,8 +3125,8 @@ pub const Fetch = struct {
                         http_body = .{
                             .Sendfile = .{
                                 .fd = opened_fd,
-                                .remain = body.Blob.offset + original_size,
-                                .offset = body.Blob.offset,
+                                .remain = body.AnyBlob.Blob.offset + original_size,
+                                .offset = body.AnyBlob.Blob.offset,
                                 .content_size = blob_size,
                             },
                         };
@@ -2954,13 +3147,13 @@ pub const Fetch = struct {
                     .{
                         .encoding = .buffer,
                         .path = .{ .fd = opened_fd },
-                        .offset = body.Blob.offset,
-                        .max_size = body.Blob.size,
+                        .offset = body.AnyBlob.Blob.offset,
+                        .max_size = body.AnyBlob.Blob.size,
                     },
                     .sync,
                 );
 
-                if (body.Blob.store.?.data.file.pathlike == .path) {
+                if (body.store().?.data.file.pathlike == .path) {
                     _ = bun.sys.close(opened_fd);
                 }
 
@@ -2974,8 +3167,8 @@ pub const Fetch = struct {
                     },
                     .result => |result| {
                         body.detach();
-                        body.from(std.ArrayList(u8).fromOwnedSlice(allocator, @constCast(result.slice())));
-                        http_body = .{ .AnyBlob = body };
+                        body.AnyBlob.from(std.ArrayList(u8).fromOwnedSlice(allocator, @constCast(result.slice())));
+                        http_body = .{ .AnyBlob = body.AnyBlob };
                     },
                 }
             }
@@ -3045,9 +3238,7 @@ pub const Fetch = struct {
             body.detach();
         } else {
             // These are single-use, and have effectively been moved to the FetchTasklet.
-            body = .{
-                .Blob = .{},
-            };
+            body = FetchTasklet.HTTPRequestBody.Empty;
         }
         proxy = null;
         url_proxy_buffer = "";
diff --git a/src/bun.js/webcore/streams.zig b/src/bun.js/webcore/streams.zig
index 56de7842c7..346296cb34 100644
--- a/src/bun.js/webcore/streams.zig
+++ b/src/bun.js/webcore/streams.zig
@@ -23,14 +23,12 @@ const Async = bun.Async;
 const castObj = @import("../base.zig").castObj;
 const getAllocator = @import("../base.zig").getAllocator;
 
-const GetJSPrivateData = @import("../base.zig").GetJSPrivateData;
 const Environment = @import("../../env.zig");
 const ZigString = JSC.ZigString;
 const IdentityContext = @import("../../identity_context.zig").IdentityContext;
 const JSInternalPromise = JSC.JSInternalPromise;
 const JSPromise = JSC.JSPromise;
 const JSValue = JSC.JSValue;
-const JSError = JSC.JSError;
 const JSGlobalObject = JSC.JSGlobalObject;
 const E = bun.C.E;
 const VirtualMachine = JSC.VirtualMachine;
@@ -378,7 +376,7 @@ pub const ReadableStream = struct {
         globalThis: *JSGlobalObject,
         blob: *const Blob,
         offset: usize,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         JSC.markBinding(@src());
         var store = blob.store orelse {
             return ReadableStream.empty(globalThis);
@@ -400,8 +398,7 @@ pub const ReadableStream = struct {
                 return reader.toReadableStream(globalThis);
             },
             else => {
-                globalThis.throw("Expected FileBlob", .{});
-                return .zero;
+                return globalThis.throw("Expected FileBlob", .{});
             },
         }
     }
@@ -473,6 +470,7 @@ pub const StreamStart = union(Tag) {
     FileSink: FileSinkOptions,
     HTTPSResponseSink: void,
     HTTPResponseSink: void,
+    FetchTaskletChunkedRequestSink: void,
     ready: void,
     owned_and_done: bun.ByteList,
     done: bun.ByteList,
@@ -499,6 +497,7 @@ pub const StreamStart = union(Tag) {
         FileSink,
         HTTPSResponseSink,
         HTTPResponseSink,
+        FetchTaskletChunkedRequestSink,
         ready,
         owned_and_done,
         done,
@@ -513,8 +512,7 @@ pub const StreamStart = union(Tag) {
                 return JSC.JSValue.jsNumber(@as(Blob.SizeType, @intCast(chunk)));
             },
             .err => |err| {
-                globalThis.vm().throwError(globalThis, err.toJSC(globalThis));
-                return .undefined;
+                return globalThis.throwValue(err.toJSC(globalThis)) catch .zero;
             },
             .owned_and_done => |list| {
                 return JSC.ArrayBuffer.fromBytes(list.slice(), .Uint8Array).toJS(globalThis, null);
@@ -528,12 +526,12 @@ 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 = {} };
         }
 
-        if (value.getOwn(globalThis, "chunkSize")) |chunkSize| {
+        if (value.get(globalThis, "chunkSize")) |chunkSize| {
             if (chunkSize.isNumber())
                 return .{ .chunk_size = @as(Blob.SizeType, @intCast(@as(i52, @truncate(chunkSize.toInt64())))) };
         }
@@ -545,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 = {} };
         }
@@ -614,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{
@@ -650,7 +648,7 @@ pub const StreamStart = union(Tag) {
                     },
                 };
             },
-            .HTTPSResponseSink, .HTTPResponseSink => {
+            .FetchTaskletChunkedRequestSink, .HTTPSResponseSink, .HTTPResponseSink => {
                 var empty = true;
                 var chunk_size: JSC.WebCore.Blob.SizeType = 2048;
 
@@ -1675,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")) {
@@ -1686,16 +1684,12 @@ pub fn NewJSSink(comptime SinkType: type, comptime name_: []const u8) type {
                     .message = bun.String.static(Static.message),
                     .code = bun.String.static(@tagName(.ERR_ILLEGAL_CONSTRUCTOR)),
                 };
-                globalThis.throwValue(err.toErrorInstance(globalThis));
-                return .undefined;
+                return globalThis.throwValue(err.toErrorInstance(globalThis));
             }
 
             var allocator = globalThis.bunVM().allocator;
             var this = allocator.create(ThisSink) catch {
-                globalThis.vm().throwError(globalThis, Syscall.Error.oom.toJSC(
-                    globalThis,
-                ));
-                return .undefined;
+                return globalThis.throwValue(Syscall.Error.oom.toJSC(globalThis));
             };
             this.sink.construct(allocator);
             return createObject(globalThis, this, 0);
@@ -1725,21 +1719,11 @@ pub fn NewJSSink(comptime SinkType: type, comptime name_: []const u8) type {
         }
 
         inline fn getThis(globalThis: *JSGlobalObject, callframe: *const JSC.CallFrame) ?*ThisSink {
-            return @as(
-                *ThisSink,
-                @ptrCast(@alignCast(
-                    fromJS(
-                        globalThis,
-                        callframe.this(),
-                    ) orelse return null,
-                )),
-            );
+            return @as(*ThisSink, @ptrCast(@alignCast(fromJS(globalThis, callframe.this()) orelse return null)));
         }
 
-        fn invalidThis(globalThis: *JSGlobalObject) JSValue {
-            const err = JSC.toTypeError(.ERR_INVALID_THIS, "Expected Sink", .{}, globalThis);
-            globalThis.vm().throwError(globalThis, err);
-            return .undefined;
+        fn invalidThis(globalThis: *JSGlobalObject) bun.JSError {
+            return globalThis.ERR_INVALID_THIS("Expected Sink", .{}).throw();
         }
 
         pub fn unprotect(this: *@This()) void {
@@ -1747,28 +1731,21 @@ 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);
 
             if (comptime @hasDecl(SinkType, "getPendingError")) {
                 if (this.sink.getPendingError()) |err| {
-                    globalThis.vm().throwError(globalThis, err);
-                    return .undefined;
+                    return globalThis.throwValue(err);
                 }
             }
 
-            const args_list = callframe.arguments(4);
+            const args_list = callframe.arguments_old(4);
             const args = args_list.ptr[0..args_list.len];
 
             if (args.len == 0) {
-                globalThis.vm().throwError(globalThis, JSC.toTypeError(
-                    .ERR_MISSING_ARGS,
-                    "write() expects a string, ArrayBufferView, or ArrayBuffer",
-                    .{},
-                    globalThis,
-                ));
-                return .undefined;
+                return globalThis.throwValue(JSC.toTypeError(.ERR_MISSING_ARGS, "write() expects a string, ArrayBufferView, or ArrayBuffer", .{}, globalThis));
             }
 
             const arg = args[0];
@@ -1776,13 +1753,7 @@ pub fn NewJSSink(comptime SinkType: type, comptime name_: []const u8) type {
             defer arg.ensureStillAlive();
 
             if (arg.isEmptyOrUndefinedOrNull()) {
-                globalThis.vm().throwError(globalThis, JSC.toTypeError(
-                    .ERR_STREAM_NULL_VALUES,
-                    "write() expects a string, ArrayBufferView, or ArrayBuffer",
-                    .{},
-                    globalThis,
-                ));
-                return .undefined;
+                return globalThis.throwValue(JSC.toTypeError(.ERR_STREAM_NULL_VALUES, "write() expects a string, ArrayBufferView, or ArrayBuffer", .{}, globalThis));
             }
 
             if (arg.asArrayBuffer(globalThis)) |buffer| {
@@ -1795,13 +1766,7 @@ pub fn NewJSSink(comptime SinkType: type, comptime name_: []const u8) type {
             }
 
             if (!arg.isString()) {
-                globalThis.vm().throwError(globalThis, JSC.toTypeError(
-                    .ERR_INVALID_ARG_TYPE,
-                    "write() expects a string, ArrayBufferView, or ArrayBuffer",
-                    .{},
-                    globalThis,
-                ));
-                return .undefined;
+                return globalThis.throwValue(JSC.toTypeError(.ERR_INVALID_ARG_TYPE, "write() expects a string, ArrayBufferView, or ArrayBuffer", .{}, globalThis));
             }
 
             const str = arg.getZigString(globalThis);
@@ -1816,19 +1781,18 @@ 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);
 
             if (comptime @hasDecl(SinkType, "getPendingError")) {
                 if (this.sink.getPendingError()) |err| {
-                    globalThis.vm().throwError(globalThis, err);
-                    return .undefined;
+                    return globalThis.throwValue(err);
                 }
             }
 
-            const args_list = callframe.arguments(4);
+            const args_list = callframe.arguments_old(4);
             const args = args_list.ptr[0..args_list.len];
             if (args.len == 0 or !args[0].isString()) {
                 const err = JSC.toTypeError(
@@ -1837,8 +1801,7 @@ pub fn NewJSSink(comptime SinkType: type, comptime name_: []const u8) type {
                     .{},
                     globalThis,
                 );
-                globalThis.vm().throwError(globalThis, err);
-                return .undefined;
+                return globalThis.throwValue(err);
             }
 
             const arg = args[0];
@@ -1857,27 +1820,25 @@ pub fn NewJSSink(comptime SinkType: type, comptime name_: []const u8) type {
 
         pub fn close(globalThis: *JSGlobalObject, sink_ptr: ?*anyopaque) callconv(.C) JSValue {
             JSC.markBinding(@src());
-            var this = @as(*ThisSink, @ptrCast(@alignCast(sink_ptr orelse return invalidThis(globalThis))));
+            var this = @as(*ThisSink, @ptrCast(@alignCast(sink_ptr orelse return invalidThis(globalThis) catch .zero)));
 
             if (comptime @hasDecl(SinkType, "getPendingError")) {
                 if (this.sink.getPendingError()) |err| {
-                    globalThis.vm().throwError(globalThis, err);
-                    return .undefined;
+                    return globalThis.vm().throwError(globalThis, err) catch .zero;
                 }
             }
 
             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);
 
             if (comptime @hasDecl(SinkType, "getPendingError")) {
                 if (this.sink.getPendingError()) |err| {
-                    globalThis.vm().throwError(globalThis, err);
-                    return .undefined;
+                    return globalThis.throwValue(err);
                 }
             }
 
@@ -1888,42 +1849,32 @@ pub fn NewJSSink(comptime SinkType: type, comptime name_: []const u8) type {
             }
 
             if (comptime @hasDecl(SinkType, "flushFromJS")) {
-                const wait = callframe.argumentsCount() > 0 and
-                    callframe.argument(0).isBoolean() and
-                    callframe.argument(0).asBoolean();
+                const wait = callframe.argumentsCount() > 0 and callframe.argument(0).isBoolean() and callframe.argument(0).asBoolean();
                 const maybe_value: JSC.Maybe(JSValue) = this.sink.flushFromJS(globalThis, wait);
                 return switch (maybe_value) {
                     .result => |value| value,
-                    .err => |err| blk: {
-                        globalThis.vm().throwError(globalThis, err.toJSC(globalThis));
-                        break :blk .undefined;
-                    },
+                    .err => |err| return globalThis.throwValue(err.toJSC(globalThis)),
                 };
             }
 
             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);
 
             if (comptime @hasDecl(SinkType, "getPendingError")) {
                 if (this.sink.getPendingError()) |err| {
-                    globalThis.vm().throwError(globalThis, err);
-                    return .undefined;
+                    return globalThis.throwValue(err);
                 }
             }
 
             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);
@@ -1931,21 +1882,20 @@ 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);
 
             if (comptime @hasDecl(SinkType, "getPendingError")) {
                 if (this.sink.getPendingError()) |err| {
-                    globalThis.vm().throwError(globalThis, err);
-                    return .undefined;
+                    return globalThis.throwValue(err);
                 }
             }
 
@@ -1967,8 +1917,7 @@ pub fn NewJSSink(comptime SinkType: type, comptime name_: []const u8) type {
 
             if (comptime @hasDecl(SinkType, "getPendingError")) {
                 if (this.sink.getPendingError()) |err| {
-                    globalThis.vm().throwError(globalThis, err);
-                    return .undefined;
+                    return globalThis.throwValue(err);
                 }
             }
 
@@ -1986,14 +1935,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") });
 
@@ -2017,13 +1972,13 @@ 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 {
 //                 const err = JSC.toTypeError(.ERR_INVALID_THIS, "Expected Socket", .{}, globalThis);
-//                 globalThis.vm().throwError(globalThis, err);
-//                 return .undefined;
+//                 globalThis.throwValue( err);
+//                 return .zero;
 //             }));
 //         }
 //     };
@@ -2253,21 +2208,26 @@ pub fn HTTPServerWritable(comptime ssl: bool) type {
 
         fn flushFromJSNoWait(this: *@This()) JSC.Maybe(JSValue) {
             log("flushFromJSNoWait", .{});
+
+            return .{ .result = JSValue.jsNumber(this.flushNoWait()) };
+        }
+
+        pub fn flushNoWait(this: *@This()) usize {
             if (this.hasBackpressureAndIsTryEnd() or this.done) {
-                return .{ .result = JSValue.jsNumberFromInt32(0) };
+                return 0;
             }
 
             const slice = this.readableSlice();
             if (slice.len == 0) {
-                return .{ .result = JSValue.jsNumberFromInt32(0) };
+                return 0;
             }
 
             const success = this.send(slice);
             if (success) {
-                return .{ .result = JSValue.jsNumber(slice.len) };
+                return slice.len;
             }
 
-            return .{ .result = JSValue.jsNumberFromInt32(0) };
+            return 0;
         }
 
         pub fn flushFromJS(this: *@This(), globalThis: *JSGlobalObject, wait: bool) JSC.Maybe(JSValue) {
@@ -2592,11 +2552,15 @@ pub fn HTTPServerWritable(comptime ssl: bool) type {
         // so it must zero out state instead of make it
         pub fn finalize(this: *@This()) void {
             log("finalize()", .{});
-
             if (!this.done) {
-                this.done = true;
                 this.unregisterAutoFlusher();
+                // make sure we detached the handlers before flushing inside the finalize function
                 this.res.clearOnWritable();
+                this.res.clearAborted();
+                this.res.clearOnData();
+                _ = this.flushNoWait();
+                this.done = true;
+                // is actually fine to call this if the socket is closed because of flushNoWait, the free will be defered by usockets
                 this.res.endStream(false);
             }
 
@@ -2638,7 +2602,276 @@ pub fn HTTPServerWritable(comptime ssl: bool) type {
 }
 pub const HTTPSResponseSink = HTTPServerWritable(true);
 pub const HTTPResponseSink = HTTPServerWritable(false);
+pub const FetchTaskletChunkedRequestSink = struct {
+    task: ?*JSC.WebCore.Fetch.FetchTasklet = null,
+    signal: Signal = .{},
+    globalThis: *JSGlobalObject = undefined,
+    highWaterMark: Blob.SizeType = 2048,
+    buffer: bun.io.StreamBuffer,
+    ended: bool = false,
+    done: bool = false,
+    auto_flusher: AutoFlusher = AutoFlusher{},
 
+    pub usingnamespace bun.New(FetchTaskletChunkedRequestSink);
+
+    fn unregisterAutoFlusher(this: *@This()) void {
+        if (this.auto_flusher.registered)
+            AutoFlusher.unregisterDeferredMicrotaskWithTypeUnchecked(@This(), this, this.globalThis.bunVM());
+    }
+
+    fn registerAutoFlusher(this: *@This()) void {
+        if (!this.auto_flusher.registered)
+            AutoFlusher.registerDeferredMicrotaskWithTypeUnchecked(@This(), this, this.globalThis.bunVM());
+    }
+
+    pub fn onAutoFlush(this: *@This()) bool {
+        if (this.done) {
+            this.auto_flusher.registered = false;
+            return false;
+        }
+
+        _ = this.internalFlush() catch 0;
+        if (this.buffer.isEmpty()) {
+            this.auto_flusher.registered = false;
+            return false;
+        }
+        return true;
+    }
+
+    pub fn start(this: *@This(), stream_start: StreamStart) JSC.Maybe(void) {
+        if (this.ended) {
+            return .{ .result = {} };
+        }
+        switch (stream_start) {
+            .chunk_size => |chunk_size| {
+                if (chunk_size > 0) {
+                    this.highWaterMark = chunk_size;
+                }
+            },
+            else => {},
+        }
+        this.ended = false;
+        this.signal.start();
+        return .{ .result = {} };
+    }
+
+    pub fn connect(this: *@This(), signal: Signal) void {
+        this.signal = signal;
+    }
+    pub fn sink(this: *@This()) Sink {
+        return Sink.init(this);
+    }
+    pub fn toSink(this: *@This()) *@This().JSSink {
+        return @ptrCast(this);
+    }
+    pub fn finalize(this: *@This()) void {
+        this.unregisterAutoFlusher();
+
+        var buffer = this.buffer;
+        this.buffer = .{};
+        buffer.deinit();
+
+        if (this.task) |task| {
+            this.task = null;
+            task.deref();
+        }
+    }
+
+    pub fn send(this: *@This(), data: []const u8, is_last: bool) !void {
+        if (this.done) return;
+
+        if (this.task) |task| {
+            if (is_last) this.done = true;
+
+            if (data.len == 0) {
+                task.sendRequestData(bun.http.end_of_chunked_http1_1_encoding_response_body, true);
+                return;
+            }
+
+            // chunk encoding is really simple
+            if (is_last) {
+                const chunk = std.fmt.allocPrint(bun.default_allocator, "{x}\r\n{s}\r\n0\r\n\r\n", .{ data.len, data }) catch return error.OOM;
+                task.sendRequestData(chunk, true);
+            } else {
+                const chunk = std.fmt.allocPrint(bun.default_allocator, "{x}\r\n{s}\r\n", .{ data.len, data }) catch return error.OOM;
+                task.sendRequestData(chunk, false);
+            }
+        }
+    }
+
+    pub fn internalFlush(this: *@This()) !usize {
+        if (this.done) return 0;
+        var flushed: usize = 0;
+        // we need to respect the max len for the chunk
+        while (this.buffer.isNotEmpty()) {
+            const bytes = this.buffer.slice();
+            const len: u32 = @min(bytes.len, std.math.maxInt(u32));
+            try this.send(bytes, this.buffer.list.items.len - (this.buffer.cursor + len) == 0 and this.ended);
+            flushed += len;
+            this.buffer.cursor = len;
+            if (this.buffer.isEmpty()) {
+                this.buffer.reset();
+            }
+        }
+        if (this.ended and !this.done) {
+            try this.send("", true);
+            this.finalize();
+        }
+        return flushed;
+    }
+
+    pub fn flush(this: *@This()) JSC.Maybe(void) {
+        _ = this.internalFlush() catch 0;
+        return .{ .result = {} };
+    }
+    pub fn flushFromJS(this: *@This(), globalThis: *JSGlobalObject, _: bool) JSC.Maybe(JSValue) {
+        return .{ .result = JSC.JSPromise.resolvedPromiseValue(globalThis, JSValue.jsNumber(this.internalFlush() catch 0)) };
+    }
+    pub fn finalizeAndDestroy(this: *@This()) void {
+        this.finalize();
+        this.destroy();
+    }
+
+    pub fn abort(this: *@This()) void {
+        this.ended = true;
+        this.done = true;
+        this.signal.close(null);
+        this.finalize();
+    }
+
+    pub fn write(this: *@This(), data: StreamResult) StreamResult.Writable {
+        if (this.ended) {
+            return .{ .owned = 0 };
+        }
+        const bytes = data.slice();
+        const len = @as(Blob.SizeType, @truncate(bytes.len));
+
+        if (this.buffer.size() == 0 and len >= this.highWaterMark) {
+            // fast path:
+            // - large-ish chunk
+            this.send(bytes, false) catch {
+                return .{ .err = Syscall.Error.fromCode(.NOMEM, .write) };
+            };
+            return .{ .owned = len };
+        } else if (this.buffer.size() + len >= this.highWaterMark) {
+            _ = this.buffer.write(bytes) catch {
+                return .{ .err = Syscall.Error.fromCode(.NOMEM, .write) };
+            };
+            _ = this.internalFlush() catch {
+                return .{ .err = Syscall.Error.fromCode(.NOMEM, .write) };
+            };
+            return .{ .owned = len };
+        } else {
+            // queue the data wait until highWaterMark is reached or the auto flusher kicks in
+            this.buffer.write(bytes) catch {
+                return .{ .err = Syscall.Error.fromCode(.NOMEM, .write) };
+            };
+        }
+        this.registerAutoFlusher();
+        return .{ .owned = len };
+    }
+
+    pub const writeBytes = write;
+    pub fn writeLatin1(this: *@This(), data: StreamResult) StreamResult.Writable {
+        if (this.ended) {
+            return .{ .owned = 0 };
+        }
+
+        const bytes = data.slice();
+        const len = @as(Blob.SizeType, @truncate(bytes.len));
+
+        if (this.buffer.size() == 0 and len >= this.highWaterMark) {
+            // common case
+            if (strings.isAllASCII(bytes)) {
+                // fast path:
+                // - large-ish chunk
+                this.send(bytes, false) catch {
+                    return .{ .err = Syscall.Error.fromCode(.NOMEM, .write) };
+                };
+                return .{ .owned = len };
+            }
+
+            this.buffer.writeLatin1(bytes) catch {
+                return .{ .err = Syscall.Error.fromCode(.NOMEM, .write) };
+            };
+
+            _ = this.internalFlush() catch {
+                return .{ .err = Syscall.Error.fromCode(.NOMEM, .write) };
+            };
+            return .{ .owned = len };
+        } else if (this.buffer.size() + len >= this.highWaterMark) {
+            // kinda fast path:
+            // - combined chunk is large enough to flush automatically
+            this.buffer.writeLatin1(bytes) catch {
+                return .{ .err = Syscall.Error.fromCode(.NOMEM, .write) };
+            };
+            _ = this.internalFlush() catch {
+                return .{ .err = Syscall.Error.fromCode(.NOMEM, .write) };
+            };
+            return .{ .owned = len };
+        } else {
+            this.buffer.writeLatin1(bytes) catch {
+                return .{ .err = Syscall.Error.fromCode(.NOMEM, .write) };
+            };
+        }
+
+        this.registerAutoFlusher();
+
+        return .{ .owned = len };
+    }
+    pub fn writeUTF16(this: *@This(), data: StreamResult) StreamResult.Writable {
+        if (this.ended) {
+            return .{ .owned = 0 };
+        }
+        const bytes = data.slice();
+        // we must always buffer UTF-16
+        // we assume the case of all-ascii UTF-16 string is pretty uncommon
+        this.buffer.writeUTF16(@alignCast(std.mem.bytesAsSlice(u16, bytes))) catch {
+            return .{ .err = Syscall.Error.fromCode(.NOMEM, .write) };
+        };
+
+        const readable = this.buffer.slice();
+        if (readable.len >= this.highWaterMark) {
+            _ = this.internalFlush() catch {
+                return .{ .err = Syscall.Error.fromCode(.NOMEM, .write) };
+            };
+            return .{ .owned = @as(Blob.SizeType, @intCast(bytes.len)) };
+        }
+
+        this.registerAutoFlusher();
+        return .{ .owned = @as(Blob.SizeType, @intCast(bytes.len)) };
+    }
+
+    pub fn end(this: *@This(), err: ?Syscall.Error) JSC.Maybe(void) {
+        if (this.ended) {
+            return .{ .result = {} };
+        }
+
+        // send EOF
+        this.ended = true;
+        // flush everything and send EOF
+        _ = this.internalFlush() catch 0;
+
+        this.signal.close(err);
+        return .{ .result = {} };
+    }
+    pub fn endFromJS(this: *@This(), _: *JSGlobalObject) JSC.Maybe(JSValue) {
+        if (this.ended) {
+            return .{ .result = JSC.JSValue.jsNumber(0) };
+        }
+
+        if (this.done) {
+            this.ended = true;
+            this.signal.close(null);
+            this.finalize();
+            return .{ .result = JSC.JSValue.jsNumber(0) };
+        }
+        _ = this.end(null);
+        return .{ .result = JSC.JSValue.jsNumber(0) };
+    }
+    const name = "FetchTaskletChunkedRequestSink";
+    pub const JSSink = NewJSSink(@This(), name);
+};
 pub const BufferedReadableStreamAction = enum {
     text,
     arrayBuffer,
@@ -2656,7 +2889,7 @@ pub fn ReadableStreamSource(
     comptime deinit_fn: fn (this: *Context) void,
     comptime setRefUnrefFn: ?fn (this: *Context, enable: bool) void,
     comptime drainInternalBuffer: ?fn (this: *Context) bun.ByteList,
-    comptime toBufferedValue: ?fn (this: *Context, globalThis: *JSC.JSGlobalObject, action: BufferedReadableStreamAction) JSC.JSValue,
+    comptime toBufferedValue: ?fn (this: *Context, globalThis: *JSC.JSGlobalObject, action: BufferedReadableStreamAction) bun.JSError!JSC.JSValue,
 ) type {
     return struct {
         context: Context,
@@ -2785,7 +3018,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) {
@@ -2821,16 +3054,10 @@ pub fn ReadableStreamSource(
         pub const blobFromJS = JSReadableStreamSource.blob;
         pub const bytesFromJS = JSReadableStreamSource.bytes;
         pub const JSReadableStreamSource = struct {
-            pub fn construct(globalThis: *JSGlobalObject, callFrame: *JSC.CallFrame) ?*ReadableStreamSourceType {
-                _ = callFrame; // autofix
-                globalThis.throw("Cannot construct 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);
+                const arguments = callFrame.arguments_old(2);
                 const view = arguments.ptr[0];
                 view.ensureStillAlive();
                 this.this_jsvalue = this_jsvalue;
@@ -2843,7 +3070,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();
@@ -2852,8 +3079,7 @@ pub fn ReadableStreamSource(
                     .ready => return JSValue.jsNumber(16384),
                     .chunk_size => |size| return JSValue.jsNumber(size),
                     .err => |err| {
-                        globalThis.vm().throwError(globalThis, err.toJSC(globalThis));
-                        return .undefined;
+                        return globalThis.throwValue(err.toJSC(globalThis));
                     },
                     else => |rc| {
                         return rc.toJS(globalThis);
@@ -2866,18 +3092,17 @@ pub fn ReadableStreamSource(
                 return JSC.JSValue.jsBoolean(this.is_closed);
             }
 
-            fn processResult(this_jsvalue: JSC.JSValue, globalThis: *JSGlobalObject, flags: JSValue, result: StreamResult) JSC.JSValue {
+            fn processResult(this_jsvalue: JSC.JSValue, globalThis: *JSGlobalObject, flags: JSValue, result: StreamResult) bun.JSError!JSC.JSValue {
                 switch (result) {
                     .err => |err| {
                         if (err == .Error) {
-                            globalThis.vm().throwError(globalThis, err.Error.toJSC(globalThis));
+                            return globalThis.throwValue(err.Error.toJSC(globalThis));
                         } else {
                             const js_err = err.JSValue;
                             js_err.ensureStillAlive();
                             js_err.unprotect();
-                            globalThis.vm().throwError(globalThis, js_err);
+                            return globalThis.throwValue(js_err);
                         }
-                        return JSValue.jsUndefined();
                     },
                     .pending => {
                         const out = result.toJS(globalThis);
@@ -2892,7 +3117,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();
@@ -2911,7 +3136,7 @@ pub fn ReadableStreamSource(
                 }
 
                 if (!value.isCallable(globalObject.vm())) {
-                    globalObject.throwInvalidArgumentType("ReadableStreamSource", "onclose", "function");
+                    globalObject.throwInvalidArgumentType("ReadableStreamSource", "onclose", "function") catch {};
                     return false;
                 }
                 const cb = value.withAsyncContextIfNeeded(globalObject);
@@ -2929,7 +3154,7 @@ pub fn ReadableStreamSource(
                 }
 
                 if (!value.isCallable(globalObject.vm())) {
-                    globalObject.throwInvalidArgumentType("ReadableStreamSource", "onDrain", "function");
+                    globalObject.throwInvalidArgumentType("ReadableStreamSource", "onDrain", "function") catch {};
                     return false;
                 }
                 const cb = value.withAsyncContextIfNeeded(globalObject);
@@ -2957,10 +3182,11 @@ 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();
-                const ref_or_unref = callFrame.argument(0).toBooleanSlow(globalObject);
+                const ref_or_unref = callFrame.argument(0).toBoolean();
                 this.setRef(ref_or_unref);
 
                 return .undefined;
@@ -2982,7 +3208,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();
@@ -2992,7 +3218,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();
 
@@ -3004,7 +3230,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();
 
@@ -3016,7 +3242,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();
 
@@ -3028,7 +3254,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();
 
@@ -3040,7 +3266,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();
 
@@ -4335,7 +4561,7 @@ pub const ByteBlobLoader = struct {
         return bun.ByteList.fromList(cloned);
     }
 
-    pub fn toBufferedValue(this: *ByteBlobLoader, globalThis: *JSC.JSGlobalObject, action: BufferedReadableStreamAction) JSC.JSValue {
+    pub fn toBufferedValue(this: *ByteBlobLoader, globalThis: *JSC.JSGlobalObject, action: BufferedReadableStreamAction) bun.JSError!JSC.JSValue {
         if (this.toAnyBlob(globalThis)) |blob_| {
             var blob = blob_;
             return blob.toPromise(globalThis, action);
@@ -4816,10 +5042,9 @@ pub const ByteStream = struct {
         return null;
     }
 
-    pub fn toBufferedValue(this: *@This(), globalThis: *JSC.JSGlobalObject, action: BufferedReadableStreamAction) JSC.JSValue {
+    pub fn toBufferedValue(this: *@This(), globalThis: *JSC.JSGlobalObject, action: BufferedReadableStreamAction) bun.JSError!JSC.JSValue {
         if (this.buffer_action != null) {
-            globalThis.throw("Cannot buffer value twice", .{});
-            return .zero;
+            return globalThis.throw("Cannot buffer value twice", .{});
         }
 
         if (this.pending.result == .err) {
diff --git a/src/bun.zig b/src/bun.zig
index 0da72ab1e1..352c6c9148 100644
--- a/src/bun.zig
+++ b/src/bun.zig
@@ -34,11 +34,42 @@ pub const auto_allocator: std.mem.Allocator = if (!use_mimalloc)
 else
     @import("./memory_allocator.zig").auto_allocator;
 
-pub const huge_allocator_threshold: comptime_int = @import("./memory_allocator.zig").huge_threshold;
-
 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;
 
+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) {
+    bun.debugAssert(min <= max);
+    if (comptime (@TypeOf(self) == f32 or @TypeOf(self) == f64)) {
+        return clampFloat(self, min, max);
+    }
+    return std.math.clamp(self, min, max);
+}
+
+/// Restrict a value to a certain interval unless it is NaN.
+///
+/// Returns `max` if `self` is greater than `max`, and `min` if `self` is
+/// less than `min`. Otherwise this returns `self`.
+///
+/// Note that this function returns NaN if the initial value was NaN as
+/// well.
+pub inline fn clampFloat(_self: anytype, min: @TypeOf(_self), max: @TypeOf(_self)) @TypeOf(_self) {
+    if (comptime !(@TypeOf(_self) == f32 or @TypeOf(_self) == f64)) {
+        @compileError("Only call this on floats.");
+    }
+    var self = _self;
+    if (self < min) {
+        self = min;
+    }
+    if (self > max) {
+        self = max;
+    }
+    return self;
+}
+
 /// We cannot use a threadlocal memory allocator for FileSystem-related things
 /// FileSystem is a singleton.
 pub const fs_allocator = default_allocator;
@@ -57,17 +88,20 @@ 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;
 pub const sha = @import("./sha.zig");
 pub const FeatureFlags = @import("feature_flags.zig");
@@ -79,6 +113,7 @@ pub const DirIterator = @import("./bun.js/node/dir_iterator.zig");
 pub const PackageJSON = @import("./resolver/package_json.zig").PackageJSON;
 pub const fmt = @import("./fmt.zig");
 pub const allocators = @import("./allocators.zig");
+pub const bun_js = @import("./bun_js.zig");
 
 /// Copied from Zig std.trait
 pub const trait = @import("./trait.zig");
@@ -93,6 +128,9 @@ pub const ComptimeStringMapWithKeyType = comptime_string_map.ComptimeStringMapWi
 pub const glob = @import("./glob.zig");
 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");
@@ -269,6 +307,8 @@ pub fn platformIOVecToSlice(iovec: PlatformIOVec) []u8 {
     return iovec.base[0..iovec.len];
 }
 
+pub const libarchive = @import("./libarchive/libarchive.zig");
+
 pub const StringTypes = @import("string_types.zig");
 pub const stringZ = StringTypes.stringZ;
 pub const string = StringTypes.string;
@@ -279,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;
@@ -684,7 +724,7 @@ pub const Analytics = @import("./analytics/analytics_thread.zig");
 
 pub usingnamespace @import("./tagged_pointer.zig");
 
-pub fn once(comptime function: anytype, comptime ReturnType: type) ReturnType {
+pub fn onceUnsafe(comptime function: anytype, comptime ReturnType: type) ReturnType {
     const Result = struct {
         var value: ReturnType = undefined;
         var ran = false;
@@ -844,7 +884,6 @@ pub fn openDirAbsoluteNotForDeletingOrRenaming(path_: []const u8) !std.fs.Dir {
 pub const MimallocArena = @import("./mimalloc_arena.zig").Arena;
 pub fn getRuntimeFeatureFlag(comptime flag: [:0]const u8) bool {
     return struct {
-        const flag_ = flag;
         const state = enum(u8) { idk, disabled, enabled };
         var is_enabled: std.atomic.Value(state) = std.atomic.Value(state).init(.idk);
         pub fn get() bool {
@@ -852,7 +891,10 @@ pub fn getRuntimeFeatureFlag(comptime flag: [:0]const u8) bool {
                 .enabled => true,
                 .disabled => false,
                 .idk => {
-                    const enabled = if (getenvZ(flag_)) |val| strings.eqlComptime(val, "1") or strings.eqlComptime(val, "true") else false;
+                    const enabled = if (getenvZ(flag)) |val|
+                        strings.eqlComptime(val, "1") or strings.eqlComptime(val, "true")
+                    else
+                        false;
                     is_enabled.store(if (enabled) .enabled else .disabled, .seq_cst);
                     return enabled;
                 },
@@ -861,6 +903,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 {
@@ -869,16 +923,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;
@@ -968,13 +1013,14 @@ pub const StringArrayHashMapContext = struct {
     pub const Prehashed = struct {
         value: u32,
         input: []const u8,
+
         pub fn hash(this: @This(), s: []const u8) u32 {
             if (s.ptr == this.input.ptr and s.len == this.input.len)
                 return this.value;
             return @as(u32, @truncate(std.hash.Wyhash.hash(0, s)));
         }
 
-        pub fn eql(_: @This(), a: []const u8, b: []const u8) bool {
+        pub fn eql(_: @This(), a: []const u8, b: []const u8, _: usize) bool {
             return strings.eqlLong(a, b, true);
         }
     };
@@ -1651,7 +1697,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();
@@ -2029,8 +2075,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;
@@ -2200,9 +2244,12 @@ pub const Stat = if (Environment.isWindows) windows.libuv.uv_stat_t else std.pos
 pub var argv: [][:0]const u8 = &[_][:0]const u8{};
 
 pub fn initArgv(allocator: std.mem.Allocator) !void {
-    if (comptime !Environment.isWindows) {
-        argv = try std.process.argsAlloc(allocator);
-    } else {
+    if (comptime Environment.isPosix) {
+        argv = try allocator.alloc([:0]const u8, std.os.argv.len);
+        for (0..argv.len) |i| {
+            argv[i] = std.mem.sliceTo(std.os.argv[i], 0);
+        }
+    } else if (comptime Environment.isWindows) {
         // Zig's implementation of `std.process.argsAlloc()`on Windows platforms
         // is not reliable, specifically the way it splits the command line string.
         //
@@ -2252,6 +2299,8 @@ pub fn initArgv(allocator: std.mem.Allocator) !void {
         }
 
         argv = out_argv;
+    } else {
+        argv = try std.process.argsAlloc(allocator);
     }
 }
 
@@ -2303,7 +2352,7 @@ pub const win32 = struct {
         return original_mode;
     }
 
-    const watcherChildEnv: [:0]const u16 = strings.toUTF16LiteralZ("_BUN_WATCHER_CHILD");
+    const watcherChildEnv: [:0]const u16 = strings.toUTF16Literal("_BUN_WATCHER_CHILD");
     // magic exit code to indicate to the watcher manager that the child process should be re-spawned
     // this was randomly generated - we need to avoid using a common exit code that might be used by the script itself
     const watcher_reload_exit: w.DWORD = 3224497970;
@@ -2959,6 +3008,12 @@ pub noinline fn outOfMemory() noreturn {
     crash_handler.crashHandler(.out_of_memory, null, @returnAddress());
 }
 
+pub fn todoPanic(src: std.builtin.SourceLocation, comptime format: string, args: anytype) noreturn {
+    @setCold(true);
+    bun.Analytics.Features.todo_panic = 1;
+    Output.panic("TODO: " ++ format ++ " ({s}:{d})", args ++ .{ src.file, src.line });
+}
+
 /// Wrapper around allocator.create(T) that safely initializes the pointer. Prefer this over
 /// `std.mem.Allocator.create`, but prefer using `bun.new` over `create(default_allocator, T, t)`
 pub fn create(allocator: std.mem.Allocator, comptime T: type, t: T) *T {
@@ -3086,8 +3141,8 @@ pub fn NewRefCounted(comptime T: type, comptime deinit_fn: ?fn (self: *T) void)
             const ptr = bun.new(T, t);
 
             if (Environment.enable_logs) {
-                if (ptr.ref_count != 1) {
-                    Output.panic("Expected ref_count to be 1, got {d}", .{ptr.ref_count});
+                if (ptr.ref_count == 0) {
+                    Output.panic("Expected ref_count to be > 0, got {d}", .{ptr.ref_count});
                 }
             }
 
@@ -3250,14 +3305,12 @@ pub fn getUserName(output_buffer: []u8) ?[]const u8 {
     return output_buffer[0..size];
 }
 
-pub fn runtimeEmbedFile(
+pub inline fn resolveSourcePath(
     comptime root: enum { codegen, src },
-    comptime sub_path: []const u8,
-) []const u8 {
-    comptime assert(Environment.isDebug);
-    comptime assert(!Environment.embed_code);
-
-    const abs_path = comptime path: {
+    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(), &.{
@@ -3270,27 +3323,56 @@ pub fn runtimeEmbedFile(
             @compileError(unreachable))[0..].*;
         break :path &resolved;
     };
+}
+
+const RuntimeEmbedRoot = enum {
+    codegen,
+    src,
+    src_eager,
+    codegen_eager,
+};
+
+pub fn runtimeEmbedFile(
+    comptime root: RuntimeEmbedRoot,
+    comptime sub_path: []const u8,
+) [:0]const u8 {
+    comptime assert(Environment.isDebug);
+    comptime assert(!Environment.codegen_embed);
+
+    const abs_path = switch (root) {
+        .codegen, .codegen_eager => resolveSourcePath(.codegen, sub_path),
+        .src, .src_eager => resolveSourcePath(.src, sub_path),
+    };
 
     const static = struct {
-        var storage: []const u8 = undefined;
-        var once = std.once(load);
+        var once = bun.once(load);
 
-        fn load() void {
-            storage = std.fs.cwd().readFileAlloc(default_allocator, abs_path, std.math.maxInt(usize)) catch |e| {
+        fn load() [:0]const u8 {
+            return std.fs.cwd().readFileAllocOptions(
+                default_allocator,
+                abs_path,
+                std.math.maxInt(usize),
+                null,
+                @alignOf(u8),
+                '\x00',
+            ) catch |e| {
                 Output.panic(
                     \\Failed to load '{s}': {}
                     \\
                     \\To improve iteration speed, some files are not embedded but
                     \\loaded at runtime, at the cost of making the binary non-portable.
-                    \\To fix this, pass -DFORCE_EMBED_CODE=1 to CMake
+                    \\To fix this, pass -DCODEGEN_EMBED=ON to CMake
                 , .{ abs_path, e });
             };
         }
     };
 
-    static.once.call();
+    if ((root == .src_eager or root == .codegen_eager) and static.once.done) {
+        static.once.done = false;
+        default_allocator.free(static.once.payload);
+    }
 
-    return static.storage;
+    return static.once.call(.{});
 }
 
 pub inline fn markWindowsOnly() if (Environment.isWindows) void else noreturn {
@@ -3376,6 +3458,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;
 
@@ -3434,7 +3519,7 @@ pub fn assertWithLocation(value: bool, src: std.builtin.SourceLocation) callconv
 }
 
 /// This has no effect on the real code but capturing 'a' and 'b' into parameters makes assertion failures much easier inspect in a debugger.
-pub fn assert_eql(a: anytype, b: anytype) callconv(callconv_inline) void {
+pub inline fn assert_eql(a: anytype, b: anytype) void {
     if (@inComptime()) {
         if (a != b) {
             @compileLog(a);
@@ -3442,7 +3527,10 @@ pub fn assert_eql(a: anytype, b: anytype) callconv(callconv_inline) void {
             @compileError("A != B");
         }
     }
-    return assert(a == b);
+    if (!Environment.allow_assert) return;
+    if (a != b) {
+        Output.panic("Assertion failure: {} != {}", .{ a, b });
+    }
 }
 
 /// This has no effect on the real code but capturing 'a' and 'b' into parameters makes assertion failures much easier inspect in a debugger.
@@ -3451,9 +3539,7 @@ pub fn assert_neql(a: anytype, b: anytype) callconv(callconv_inline) void {
 }
 
 pub fn unsafeAssert(condition: bool) callconv(callconv_inline) void {
-    if (!condition) {
-        unreachable;
-    }
+    if (!condition) unreachable;
 }
 
 pub const dns = @import("./dns.zig");
@@ -3715,7 +3801,7 @@ pub fn memmove(output: []u8, input: []const u8) void {
 pub const hmac = @import("./hmac.zig");
 pub const libdeflate = @import("./deps/libdeflate.zig");
 
-pub const kit = @import("kit/kit.zig");
+pub const bake = @import("bake/bake.zig");
 
 /// like std.enums.tagName, except it doesn't lose the sentinel value.
 pub fn tagName(comptime Enum: type, value: Enum) ?[:0]const u8 {
@@ -3785,3 +3871,250 @@ pub fn WeakPtr(comptime T: type, comptime weakable_field: std.meta.FieldEnum(T))
         }
     };
 }
+
+pub const DebugThreadLock = if (Environment.allow_assert)
+    struct {
+        owning_thread: ?std.Thread.Id = null,
+        locked_at: crash_handler.StoredTrace,
+
+        pub const unlocked: DebugThreadLock = .{
+            .owning_thread = null,
+            .locked_at = crash_handler.StoredTrace.empty,
+        };
+
+        pub fn lock(impl: *@This()) void {
+            if (impl.owning_thread) |thread| {
+                Output.err("assertion failure", "Locked by thread {d} here:", .{thread});
+                crash_handler.dumpStackTrace(impl.locked_at.trace());
+                Output.panic("Safety lock violated on thread {d}", .{std.Thread.getCurrentId()});
+            }
+            impl.owning_thread = std.Thread.getCurrentId();
+            impl.locked_at = crash_handler.StoredTrace.capture(@returnAddress());
+        }
+
+        pub fn unlock(impl: *@This()) void {
+            impl.assertLocked();
+            impl.* = unlocked;
+        }
+
+        pub fn assertLocked(impl: *const @This()) void {
+            assert(impl.owning_thread != null); // not locked
+            assert(impl.owning_thread == std.Thread.getCurrentId());
+        }
+
+        pub fn initLocked() @This() {
+            var impl = DebugThreadLock.unlocked;
+            impl.lock();
+            return impl;
+        }
+    }
+else
+    struct {
+        pub const unlocked: @This() = .{};
+        pub fn lock(_: *@This()) void {}
+        pub fn unlock(_: *@This()) void {}
+        pub fn assertLocked(_: *const @This()) void {}
+        pub fn initLocked() @This() {
+            return .{};
+        }
+    };
+
+pub const bytecode_extension = ".jsc";
+
+/// An typed index into an array or other structure.
+/// maxInt is reserved for an empty state.
+///
+/// const Thing = struct {};
+/// const Index = bun.GenericIndex(u32, Thing)
+///
+/// The second argument prevents Zig from memoizing the
+/// call, which would otherwise make all indexes
+/// equal to each other.
+pub fn GenericIndex(backing_int: type, uid: anytype) type {
+    const null_value = std.math.maxInt(backing_int);
+    return enum(backing_int) {
+        _,
+        const Index = @This();
+        comptime {
+            _ = uid;
+        }
+
+        /// Prefer this over @enumFromInt to assert the int is in range
+        pub inline fn init(int: backing_int) Index {
+            bun.assert(int != null_value); // would be confused for null
+            return @enumFromInt(int);
+        }
+
+        /// Prefer this over @intFromEnum because of type confusion with `.Optional`
+        pub inline fn get(i: @This()) backing_int {
+            bun.assert(@intFromEnum(i) != null_value); // memory corruption
+            return @intFromEnum(i);
+        }
+
+        pub inline fn toOptional(oi: @This()) Optional {
+            return @enumFromInt(oi.get());
+        }
+
+        pub fn sortFnAsc(_: void, a: @This(), b: @This()) bool {
+            return a.get() < b.get();
+        }
+
+        pub fn sortFnDesc(_: void, a: @This(), b: @This()) bool {
+            return a.get() < b.get();
+        }
+
+        pub fn format(this: @This(), comptime f: []const u8, opts: std.fmt.FormatOptions, writer: anytype) !void {
+            comptime bun.assert(strings.eql(f, "d"));
+            try std.fmt.formatInt(@intFromEnum(this), 10, .lower, opts, writer);
+        }
+
+        pub const Optional = enum(backing_int) {
+            none = std.math.maxInt(backing_int),
+            _,
+
+            pub inline fn init(maybe: ?Index) Optional {
+                return if (maybe) |i| i.toOptional() else .none;
+            }
+
+            pub inline fn unwrap(oi: Optional) ?Index {
+                return if (oi == .none) null else @enumFromInt(@intFromEnum(oi));
+            }
+        };
+    };
+}
+
+comptime {
+    // Must be nominal
+    assert(GenericIndex(u32, opaque {}) != GenericIndex(u32, opaque {}));
+}
+
+pub fn splitAtMut(comptime T: type, slice: []T, mid: usize) struct { []T, []T } {
+    bun.assert(mid <= slice.len);
+
+    return .{ slice[0..mid], slice[mid..] };
+}
+
+/// Reverse of the slice index operator.
+/// Given `&slice[index] == item`, returns the `index` needed.
+/// The item must be in the slice.
+pub fn indexOfPointerInSlice(comptime T: type, slice: []const T, item: *const T) usize {
+    bun.assert(isSliceInBufferT(T, item[0..1], slice));
+    const offset = @intFromPtr(item) - @intFromPtr(slice.ptr);
+    const index = @divExact(offset, @sizeOf(T));
+    return index;
+}
+
+pub fn getThreadCount() u16 {
+    const max_threads = 1024;
+    const min_threads = 2;
+    const ThreadCount = struct {
+        pub var cached_thread_count: u16 = 0;
+        var cached_thread_count_once = std.once(getThreadCountOnce);
+        fn getThreadCountFromUser() ?u16 {
+            inline for (.{ "UV_THREADPOOL_SIZE", "GOMAXPROCS" }) |envname| {
+                if (getenvZ(envname)) |env| {
+                    if (std.fmt.parseInt(u16, env, 10) catch null) |parsed| {
+                        if (parsed >= min_threads) {
+                            if (bun.logger.Log.default_log_level.atLeast(.debug)) {
+                                Output.note("Using {d} threads from {s}={d}", .{ parsed, envname, parsed });
+                                Output.flush();
+                            }
+                            return @min(parsed, max_threads);
+                        }
+                    }
+                }
+            }
+
+            return null;
+        }
+        fn getThreadCountOnce() void {
+            cached_thread_count = @min(max_threads, @max(min_threads, getThreadCountFromUser() orelse std.Thread.getCpuCount() catch 0));
+        }
+    };
+    ThreadCount.cached_thread_count_once.call();
+    return ThreadCount.cached_thread_count;
+}
+
+/// Copied from zig std. Modified to accept arguments.
+pub fn once(comptime f: anytype) Once(f) {
+    return Once(f){};
+}
+
+/// Copied from zig std. Modified to accept arguments.
+///
+/// An object that executes the function `f` just once.
+/// It is undefined behavior if `f` re-enters the same Once instance.
+pub fn Once(comptime f: anytype) type {
+    return struct {
+        const Return = @typeInfo(@TypeOf(f)).Fn.return_type.?;
+
+        done: bool = false,
+        payload: Return = undefined,
+        mutex: std.Thread.Mutex = .{},
+
+        /// Call the function `f`.
+        /// If `call` is invoked multiple times `f` will be executed only the
+        /// first time.
+        /// The invocations are thread-safe.
+        pub fn call(self: *@This(), args: std.meta.ArgsTuple(@TypeOf(f))) Return {
+            if (@atomicLoad(bool, &self.done, .acquire))
+                return self.payload;
+
+            return self.callSlow(args);
+        }
+
+        fn callSlow(self: *@This(), args: std.meta.ArgsTuple(@TypeOf(f))) Return {
+            @setCold(true);
+
+            self.mutex.lock();
+            defer self.mutex.unlock();
+
+            // The first thread to acquire the mutex gets to run the initializer
+            if (!self.done) {
+                self.payload = @call(.auto, f, args);
+                @atomicStore(bool, &self.done, true, .release);
+            }
+
+            return self.payload;
+        }
+    };
+}
+
+/// `val` must be a pointer to an optional type (e.g. `*?T`)
+///
+/// This function takes the value out of the optional, replacing it with null, and returns the value.
+pub inline fn take(val: anytype) ?bun.meta.OptionalChild(@TypeOf(val)) {
+    if (val.*) |v| {
+        val.* = null;
+        return v;
+    }
+    return null;
+}
+
+pub inline fn wrappingNegation(val: anytype) @TypeOf(val) {
+    return 0 -% val;
+}
+
+fn assertNoPointers(T: type) void {
+    switch (@typeInfo(T)) {
+        .Pointer => @compileError("no pointers!"),
+        inline .Struct, .Union => |s| for (s.fields) |field| {
+            assertNoPointers(field.type);
+        },
+        .Array => |a| assertNoPointers(a.child),
+        else => {},
+    }
+}
+
+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;
+}
diff --git a/src/bun_js.zig b/src/bun_js.zig
index 7144c3ae49..29198e5a73 100644
--- a/src/bun_js.zig
+++ b/src/bun_js.zig
@@ -93,6 +93,8 @@ pub const Run = struct {
         b.resolver.opts.minify_identifiers = ctx.bundler_options.minify_identifiers;
         b.resolver.opts.minify_whitespace = ctx.bundler_options.minify_whitespace;
 
+        b.options.experimental_css = ctx.bundler_options.experimental_css;
+
         // b.options.minify_syntax = ctx.bundler_options.minify_syntax;
 
         switch (ctx.debug.macros) {
@@ -107,9 +109,6 @@ pub const Run = struct {
 
         b.options.env.behavior = .load_all_without_inlining;
 
-        b.configureRouter(false) catch {
-            failWithBuildError(vm);
-        };
         b.configureDefines() catch {
             failWithBuildError(vm);
         };
@@ -128,7 +127,7 @@ pub const Run = struct {
 
     fn doPreconnect(preconnect: []const string) void {
         if (preconnect.len == 0) return;
-        bun.HTTPThread.init();
+        bun.HTTPThread.init(&.{});
 
         for (preconnect) |url_str| {
             const url = bun.URL.parse(url_str);
@@ -252,9 +251,6 @@ pub const Run = struct {
             .unspecified => {},
         }
 
-        b.configureRouter(false) catch {
-            failWithBuildError(vm);
-        };
         b.configureDefines() catch {
             failWithBuildError(vm);
         };
@@ -309,6 +305,7 @@ pub const Run = struct {
         if (vm.loadEntryPoint(this.entry_path)) |promise| {
             if (promise.status(vm.global.vm()) == .rejected) {
                 const handled = vm.uncaughtException(vm.global, promise.result(vm.global.vm()), true);
+                promise.setHandled(vm.global.vm());
 
                 if (vm.hot_reload != .none or handled) {
                     vm.eventLoop().tick();
@@ -343,23 +340,19 @@ pub const Run = struct {
                 Output.prettyErrorln("Error occurred loading entry point: {s}", .{@errorName(err)});
                 Output.flush();
             }
+            // 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();
 
-            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();
+                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
@@ -374,39 +367,24 @@ pub const Run = struct {
 
         {
             if (this.vm.isWatcherEnabled()) {
-                var prev_promise = this.vm.pending_internal_promise;
-                if (prev_promise.status(vm.global.vm()) == .rejected) {
-                    _ = vm.unhandledRejection(this.vm.global, this.vm.pending_internal_promise.result(vm.global.vm()), this.vm.pending_internal_promise.asValue());
-                }
+                vm.handlePendingInternalPromiseRejection();
 
                 while (true) {
                     while (vm.isEventLoopAlive()) {
                         vm.tick();
 
                         // Report exceptions in hot-reloaded modules
-                        if (this.vm.pending_internal_promise.status(vm.global.vm()) == .rejected and prev_promise != this.vm.pending_internal_promise) {
-                            prev_promise = this.vm.pending_internal_promise;
-                            _ = vm.unhandledRejection(this.vm.global, this.vm.pending_internal_promise.result(vm.global.vm()), this.vm.pending_internal_promise.asValue());
-                            continue;
-                        }
+                        vm.handlePendingInternalPromiseRejection();
 
                         vm.eventLoop().autoTickActive();
                     }
 
                     vm.onBeforeExit();
 
-                    if (this.vm.pending_internal_promise.status(vm.global.vm()) == .rejected and prev_promise != this.vm.pending_internal_promise) {
-                        prev_promise = this.vm.pending_internal_promise;
-                        _ = vm.unhandledRejection(this.vm.global, this.vm.pending_internal_promise.result(vm.global.vm()), this.vm.pending_internal_promise.asValue());
-                    }
+                    vm.handlePendingInternalPromiseRejection();
 
                     vm.eventLoop().tickPossiblyForever();
                 }
-
-                if (this.vm.pending_internal_promise.status(vm.global.vm()) == .rejected and prev_promise != this.vm.pending_internal_promise) {
-                    prev_promise = this.vm.pending_internal_promise;
-                    _ = vm.unhandledRejection(this.vm.global, this.vm.pending_internal_promise.result(vm.global.vm()), this.vm.pending_internal_promise.asValue());
-                }
             } else {
                 while (vm.isEventLoopAlive()) {
                     vm.tick();
@@ -419,7 +397,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();
@@ -471,7 +449,7 @@ pub const Run = struct {
 };
 
 pub export fn Bun__onResolveEntryPointResult(global: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) noreturn {
-    const arguments = callframe.arguments(1).slice();
+    const arguments = callframe.arguments_old(1).slice();
     const result = arguments[0];
     result.print(global, .Log, .Log);
     Global.exit(global.bunVM().exit_handler.exit_code);
@@ -479,7 +457,7 @@ pub export fn Bun__onResolveEntryPointResult(global: *JSC.JSGlobalObject, callfr
 }
 
 pub export fn Bun__onRejectEntryPointResult(global: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) noreturn {
-    const arguments = callframe.arguments(1).slice();
+    const arguments = callframe.arguments_old(1).slice();
     const result = arguments[0];
     result.print(global, .Log, .Log);
     Global.exit(global.bunVM().exit_handler.exit_code);
@@ -499,12 +477,10 @@ noinline fn dumpBuildError(vm: *JSC.VirtualMachine) void {
 
     const writer = buffered_writer.writer();
 
-    switch (Output.enable_ansi_colors_stderr) {
-        inline else => |enable_colors| vm.log.printForLogLevelWithEnableAnsiColors(writer, enable_colors) catch {},
-    }
+    vm.log.print(writer) catch {};
 }
 
-noinline fn failWithBuildError(vm: *JSC.VirtualMachine) noreturn {
+pub noinline fn failWithBuildError(vm: *JSC.VirtualMachine) noreturn {
     @setCold(true);
     dumpBuildError(vm);
     Global.exit(1);
diff --git a/src/bundler.zig b/src/bundler.zig
index 6d79465e43..5a11d98b28 100644
--- a/src/bundler.zig
+++ b/src/bundler.zig
@@ -15,7 +15,7 @@ const lex = bun.js_lexer;
 const logger = bun.logger;
 const options = @import("options.zig");
 const js_parser = bun.js_parser;
-const json_parser = bun.JSON;
+const JSON = bun.JSON;
 const js_printer = bun.js_printer;
 const js_ast = bun.JSAst;
 const linker = @import("linker.zig");
@@ -51,6 +51,7 @@ const Resolver = _resolver.Resolver;
 const TOML = @import("./toml/toml_parser.zig").TOML;
 const JSC = bun.JSC;
 const PackageManager = @import("./install/install.zig").PackageManager;
+const DataURL = @import("./resolver/data_url.zig").DataURL;
 
 pub fn MacroJSValueType_() type {
     if (comptime JSC.is_bindgen) {
@@ -70,13 +71,36 @@ pub const ParseResult = struct {
     source: logger.Source,
     loader: options.Loader,
     ast: js_ast.Ast,
-    already_bundled: bool = false,
+    already_bundled: AlreadyBundled = .none,
     input_fd: ?StoredFileDescriptorType = null,
     empty: bool = false,
     pending_imports: _resolver.PendingResolution.List = .{},
 
     runtime_transpiler_cache: ?*bun.JSC.RuntimeTranspilerCache = null,
 
+    pub const AlreadyBundled = union(enum) {
+        none: void,
+        source_code: void,
+        source_code_cjs: void,
+        bytecode: []u8,
+        bytecode_cjs: []u8,
+
+        pub fn bytecodeSlice(this: AlreadyBundled) []u8 {
+            return switch (this) {
+                inline .bytecode, .bytecode_cjs => |slice| slice,
+                else => &.{},
+            };
+        }
+
+        pub fn isBytecode(this: AlreadyBundled) bool {
+            return this == .bytecode or this == .bytecode_cjs;
+        }
+
+        pub fn isCommonJS(this: AlreadyBundled) bool {
+            return this == .source_code_cjs or this == .bytecode_cjs;
+        }
+    };
+
     pub fn isPendingImport(this: *const ParseResult, id: u32) bool {
         const import_record_ids = this.pending_imports.items(.import_record_id);
 
@@ -130,7 +154,7 @@ pub const PluginRunner = struct {
         log: *logger.Log,
         loc: logger.Loc,
         target: JSC.JSGlobalObject.BunPluginTarget,
-    ) ?Fs.Path {
+    ) bun.JSError!?Fs.Path {
         var global = this.global_object;
         const namespace_slice = extractNamespace(specifier);
         const namespace = if (namespace_slice.len > 0 and !strings.eqlComptime(namespace_slice, "file"))
@@ -143,7 +167,7 @@ pub const PluginRunner = struct {
             bun.String.init(importer),
             target,
         ) orelse return null;
-        const path_value = on_resolve_plugin.getOwn(global, "path") orelse return null;
+        const path_value = try on_resolve_plugin.get(global, "path") orelse return null;
         if (path_value.isEmptyOrUndefinedOrNull()) return null;
         if (!path_value.isString()) {
             log.addError(null, loc, "Expected \"path\" to be a string") catch unreachable;
@@ -176,7 +200,7 @@ pub const PluginRunner = struct {
         }
         var static_namespace = true;
         const user_namespace: bun.String = brk: {
-            if (on_resolve_plugin.getOwn(global, "namespace")) |namespace_value| {
+            if (try on_resolve_plugin.get(global, "namespace")) |namespace_value| {
                 if (!namespace_value.isString()) {
                     log.addError(null, loc, "Expected \"namespace\" to be a string") catch unreachable;
                     return null;
@@ -225,13 +249,7 @@ pub const PluginRunner = struct {
         }
     }
 
-    pub fn onResolveJSC(
-        this: *const PluginRunner,
-        namespace: bun.String,
-        specifier: bun.String,
-        importer: bun.String,
-        target: JSC.JSGlobalObject.BunPluginTarget,
-    ) ?JSC.ErrorableString {
+    pub fn onResolveJSC(this: *const PluginRunner, namespace: bun.String, specifier: bun.String, importer: bun.String, target: JSC.JSGlobalObject.BunPluginTarget) bun.JSError!?JSC.ErrorableString {
         var global = this.global_object;
         const on_resolve_plugin = global.runOnResolvePlugins(
             if (namespace.length() > 0 and !namespace.eqlComptime("file"))
@@ -242,7 +260,7 @@ pub const PluginRunner = struct {
             importer,
             target,
         ) orelse return null;
-        const path_value = on_resolve_plugin.getOwn(global, "path") orelse return null;
+        const path_value = try on_resolve_plugin.get(global, "path") orelse return null;
         if (path_value.isEmptyOrUndefinedOrNull()) return null;
         if (!path_value.isString()) {
             return JSC.ErrorableString.err(
@@ -272,7 +290,7 @@ pub const PluginRunner = struct {
         }
         var static_namespace = true;
         const user_namespace: bun.String = brk: {
-            if (on_resolve_plugin.getOwn(global, "namespace")) |namespace_value| {
+            if (try on_resolve_plugin.get(global, "namespace")) |namespace_value| {
                 if (!namespace_value.isString()) {
                     return JSC.ErrorableString.err(
                         error.JSErrorObject,
@@ -322,6 +340,12 @@ pub const PluginRunner = struct {
     }
 };
 
+/// This structure was the JavaScript bundler before bundle_v2 was written. It now
+/// acts mostly as a configuration object, but it also contains stateful logic around
+/// logging errors (.log) and module resolution (.resolve_queue)
+///
+/// This object is not exclusive to bundle_v2/Bun.build, one of these is stored
+/// on every VM so that the options can be used for transpilation.
 pub const Bundler = struct {
     options: options.BundleOptions,
     log: *logger.Log,
@@ -372,7 +396,7 @@ pub const Bundler = struct {
     }
 
     fn _resolveEntryPoint(bundler: *Bundler, entry_point: string) !_resolver.Result {
-        return bundler.resolver.resolve(bundler.fs.top_level_dir, entry_point, .entry_point) catch |err| {
+        return bundler.resolver.resolveWithFramework(bundler.fs.top_level_dir, entry_point, .entry_point) catch |err| {
             // Relative entry points that were not resolved to a node_modules package are
             // interpreted as relative to the current working directory.
             if (!std.fs.path.isAbsolute(entry_point) and
@@ -420,7 +444,7 @@ pub const Bundler = struct {
             };
 
             // Only re-query if we previously had something cached.
-            if (bundler.resolver.bustDirCache(buster_name)) {
+            if (bundler.resolver.bustDirCache(bun.strings.withoutTrailingSlashWindowsPath(buster_name))) {
                 if (_resolveEntryPoint(bundler, entry_point)) |result|
                     return result
                 else |_| {
@@ -581,15 +605,7 @@ pub const Bundler = struct {
         defer js_ast.Expr.Data.Store.reset();
         defer js_ast.Stmt.Data.Store.reset();
 
-        if (this.options.framework) |framework| {
-            if (this.options.target.isClient()) {
-                try this.options.loadDefines(this.allocator, this.env, &framework.client.env);
-            } else {
-                try this.options.loadDefines(this.allocator, this.env, &framework.server.env);
-            }
-        } else {
-            try this.options.loadDefines(this.allocator, this.env, &this.options.env);
-        }
+        try this.options.loadDefines(this.allocator, this.env, &this.options.env);
 
         if (this.options.define.dots.get("NODE_ENV")) |NODE_ENV| {
             if (NODE_ENV.len > 0 and NODE_ENV[0].data.value == .e_string and NODE_ENV[0].data.value.e_string.eqlComptime("production")) {
@@ -598,97 +614,6 @@ pub const Bundler = struct {
         }
     }
 
-    pub fn configureFramework(
-        this: *Bundler,
-        comptime load_defines: bool,
-    ) !void {
-        if (this.options.framework) |*framework| {
-            if (framework.needsResolveFromPackage()) {
-                var route_config = this.options.routes;
-                var pair = PackageJSON.FrameworkRouterPair{ .framework = framework, .router = &route_config };
-
-                if (framework.development) {
-                    try this.resolver.resolveFramework(framework.package, &pair, .development, load_defines);
-                } else {
-                    try this.resolver.resolveFramework(framework.package, &pair, .production, load_defines);
-                }
-
-                if (this.options.areDefinesUnset()) {
-                    if (this.options.target.isClient()) {
-                        this.options.env = framework.client.env;
-                    } else {
-                        this.options.env = framework.server.env;
-                    }
-                }
-
-                if (pair.loaded_routes) {
-                    this.options.routes = route_config;
-                }
-                framework.resolved = true;
-                this.options.framework = framework.*;
-            } else if (!framework.resolved) {
-                Output.panic("directly passing framework path is not implemented yet!", .{});
-            }
-        }
-    }
-
-    pub fn configureFrameworkWithResolveResult(this: *Bundler, comptime client: bool) !?_resolver.Result {
-        if (this.options.framework != null) {
-            try this.configureFramework(true);
-            if (comptime client) {
-                if (this.options.framework.?.client.isEnabled()) {
-                    return try this.resolver.resolve(this.fs.top_level_dir, this.options.framework.?.client.path, .stmt);
-                }
-
-                if (this.options.framework.?.fallback.isEnabled()) {
-                    return try this.resolver.resolve(this.fs.top_level_dir, this.options.framework.?.fallback.path, .stmt);
-                }
-            } else {
-                if (this.options.framework.?.server.isEnabled()) {
-                    return try this.resolver.resolve(this.fs.top_level_dir, this.options.framework.?.server, .stmt);
-                }
-            }
-        }
-
-        return null;
-    }
-
-    pub fn configureRouter(this: *Bundler, comptime load_defines: bool) !void {
-        try this.configureFramework(load_defines);
-        defer {
-            if (load_defines) {
-                this.configureDefines() catch {};
-            }
-        }
-
-        if (this.options.routes.routes_enabled) {
-            const dir_info_ = try this.resolver.readDirInfo(this.options.routes.dir);
-            const dir_info = dir_info_ orelse return error.MissingRoutesDir;
-
-            this.options.routes.dir = dir_info.abs_path;
-
-            this.router = try Router.init(this.fs, this.allocator, this.options.routes);
-            try this.router.?.loadRoutes(
-                this.log,
-                dir_info,
-                Resolver,
-                &this.resolver,
-                this.fs.top_level_dir,
-            );
-            this.router.?.routes.client_framework_enabled = this.options.isFrontendFrameworkEnabled();
-            return;
-        }
-
-        // If we get this far, it means they're trying to run the bundler without a preconfigured router
-        if (this.options.entry_points.len > 0) {
-            this.options.routes.routes_enabled = false;
-        }
-
-        if (this.router) |*router| {
-            router.routes.client_framework_enabled = this.options.isFrontendFrameworkEnabled();
-        }
-    }
-
     pub fn resetStore(_: *const Bundler) void {
         js_ast.Expr.Data.Store.reset();
         js_ast.Stmt.Data.Store.reset();
@@ -709,6 +634,7 @@ pub const Bundler = struct {
         input_fd: ?StoredFileDescriptorType,
         empty: bool = false,
     };
+
     pub fn buildWithResolveResult(
         bundler: *Bundler,
         resolve_result: _resolver.Result,
@@ -934,6 +860,9 @@ pub const Bundler = struct {
             .src_path = file_path,
             .loader = loader,
             .value = undefined,
+            .side = null,
+            .entry_point_index = null,
+            .output_kind = .chunk,
         };
 
         switch (loader) {
@@ -985,7 +914,7 @@ pub const Bundler = struct {
                         &writer,
                         .esm,
                     ),
-                    .bun, .bun_macro => try bundler.print(
+                    .bun, .bun_macro, .bake_server_components_ssr => try bundler.print(
                         result,
                         *js_printer.BufferPrinter,
                         &writer,
@@ -1003,75 +932,109 @@ pub const Bundler = struct {
                 Output.panic("TODO: dataurl, base64", .{}); // TODO
             },
             .css => {
-                var file: bun.sys.File = undefined;
+                if (bundler.options.experimental_css) {
+                    const alloc = bundler.allocator;
 
-                if (Outstream == std.fs.Dir) {
-                    const output_dir = outstream;
-
-                    if (std.fs.path.dirname(file_path.pretty)) |dirname| {
-                        try output_dir.makePath(dirname);
+                    const entry = bundler.resolver.caches.fs.readFileWithAllocator(
+                        bundler.allocator,
+                        bundler.fs,
+                        file_path.text,
+                        resolve_result.dirname_fd,
+                        false,
+                        null,
+                    ) catch |err| {
+                        bundler.log.addErrorFmt(null, logger.Loc.Empty, bundler.allocator, "{s} reading \"{s}\"", .{ @errorName(err), file_path.pretty }) catch {};
+                        return null;
+                    };
+                    var sheet = switch (bun.css.StyleSheet(bun.css.DefaultAtRule).parse(alloc, entry.contents, bun.css.ParserOptions.default(alloc, bundler.log), null)) {
+                        .result => |v| v,
+                        .err => |e| {
+                            bundler.log.addErrorFmt(null, logger.Loc.Empty, bundler.allocator, "{} parsing", .{e}) catch unreachable;
+                            return null;
+                        },
+                    };
+                    if (sheet.minify(alloc, bun.css.MinifyOptions.default()).asErr()) |e| {
+                        bundler.log.addErrorFmt(null, logger.Loc.Empty, bundler.allocator, "{} while minifying", .{e.kind}) catch bun.outOfMemory();
+                        return null;
                     }
-                    file = bun.sys.File.from(try output_dir.createFile(file_path.pretty, .{}));
+                    const result = sheet.toCss(alloc, bun.css.PrinterOptions{
+                        .minify = bundler.options.minify_whitespace,
+                    }, null) catch |e| {
+                        bun.handleErrorReturnTrace(e, @errorReturnTrace());
+                        return null;
+                    };
+                    output_file.value = .{ .buffer = .{ .allocator = alloc, .bytes = result.code } };
                 } else {
-                    file = bun.sys.File.from(outstream);
-                }
+                    var file: bun.sys.File = undefined;
 
-                const CSSBuildContext = struct {
-                    origin: URL,
-                };
-                const build_ctx = CSSBuildContext{ .origin = bundler.options.origin };
+                    if (Outstream == std.fs.Dir) {
+                        const output_dir = outstream;
 
-                const BufferedWriter = std.io.CountingWriter(std.io.BufferedWriter(8192, bun.sys.File.Writer));
-                const CSSWriter = Css.NewWriter(
-                    BufferedWriter.Writer,
-                    @TypeOf(&bundler.linker),
-                    import_path_format,
-                    CSSBuildContext,
-                );
-                var buffered_writer = BufferedWriter{
-                    .child_stream = .{ .unbuffered_writer = file.writer() },
-                    .bytes_written = 0,
-                };
-                const entry = bundler.resolver.caches.fs.readFile(
-                    bundler.fs,
-                    file_path.text,
-                    resolve_result.dirname_fd,
-                    !cache_files,
-                    null,
-                ) catch return null;
-
-                const _file = Fs.PathContentsPair{ .path = file_path, .contents = entry.contents };
-                var source = try logger.Source.initFile(_file, bundler.allocator);
-                source.contents_is_recycled = !cache_files;
-
-                var css_writer = CSSWriter.init(
-                    &source,
-                    buffered_writer.writer(),
-                    &bundler.linker,
-                    bundler.log,
-                );
-
-                css_writer.buildCtx = build_ctx;
-
-                try css_writer.run(bundler.log, bundler.allocator);
-                try css_writer.ctx.context.child_stream.flush();
-                output_file.size = css_writer.ctx.context.bytes_written;
-                var file_op = options.OutputFile.FileOperation.fromFile(file.handle, file_path.pretty);
-
-                file_op.fd = bun.toFD(file.handle);
-
-                file_op.is_tmpdir = false;
-
-                if (Outstream == std.fs.Dir) {
-                    file_op.dir = bun.toFD(outstream.fd);
-
-                    if (bundler.fs.fs.needToCloseFiles()) {
-                        file.close();
-                        file_op.fd = .zero;
+                        if (std.fs.path.dirname(file_path.pretty)) |dirname| {
+                            try output_dir.makePath(dirname);
+                        }
+                        file = bun.sys.File.from(try output_dir.createFile(file_path.pretty, .{}));
+                    } else {
+                        file = bun.sys.File.from(outstream);
                     }
-                }
 
-                output_file.value = .{ .move = file_op };
+                    const CSSBuildContext = struct {
+                        origin: URL,
+                    };
+                    const build_ctx = CSSBuildContext{ .origin = bundler.options.origin };
+
+                    const BufferedWriter = std.io.CountingWriter(std.io.BufferedWriter(8192, bun.sys.File.Writer));
+                    const CSSWriter = Css.NewWriter(
+                        BufferedWriter.Writer,
+                        @TypeOf(&bundler.linker),
+                        import_path_format,
+                        CSSBuildContext,
+                    );
+                    var buffered_writer = BufferedWriter{
+                        .child_stream = .{ .unbuffered_writer = file.writer() },
+                        .bytes_written = 0,
+                    };
+                    const entry = bundler.resolver.caches.fs.readFile(
+                        bundler.fs,
+                        file_path.text,
+                        resolve_result.dirname_fd,
+                        !cache_files,
+                        null,
+                    ) catch return null;
+
+                    const _file = Fs.PathContentsPair{ .path = file_path, .contents = entry.contents };
+                    var source = try logger.Source.initFile(_file, bundler.allocator);
+                    source.contents_is_recycled = !cache_files;
+
+                    var css_writer = CSSWriter.init(
+                        &source,
+                        buffered_writer.writer(),
+                        &bundler.linker,
+                        bundler.log,
+                    );
+
+                    css_writer.buildCtx = build_ctx;
+
+                    try css_writer.run(bundler.log, bundler.allocator);
+                    try css_writer.ctx.context.child_stream.flush();
+                    output_file.size = css_writer.ctx.context.bytes_written;
+                    var file_op = options.OutputFile.FileOperation.fromFile(file.handle, file_path.pretty);
+
+                    file_op.fd = bun.toFD(file.handle);
+
+                    file_op.is_tmpdir = false;
+
+                    if (Outstream == std.fs.Dir) {
+                        file_op.dir = bun.toFD(outstream.fd);
+
+                        if (bundler.fs.fs.needToCloseFiles()) {
+                            file.close();
+                            file_op.fd = .zero;
+                        }
+                    }
+
+                    output_file.value = .{ .move = file_op };
+                }
             },
 
             .bunsh, .sqlite_embedded, .sqlite, .wasm, .file, .napi => {
@@ -1089,9 +1052,6 @@ pub const Bundler = struct {
                     },
                 };
             },
-
-            // // TODO:
-            // else => {},
         }
 
         return output_file;
@@ -1121,8 +1081,7 @@ pub const Bundler = struct {
                 js_ast.Symbol.Map.initList(symbols),
                 source,
                 false,
-                js_printer.Options{
-                    .externals = ast.externals,
+                .{
                     .runtime_imports = ast.runtime_imports,
                     .require_ref = ast.require_ref,
                     .css_import_behavior = bundler.options.cssImportBehavior(),
@@ -1144,8 +1103,7 @@ pub const Bundler = struct {
                 js_ast.Symbol.Map.initList(symbols),
                 source,
                 false,
-                js_printer.Options{
-                    .externals = ast.externals,
+                .{
                     .runtime_imports = ast.runtime_imports,
                     .require_ref = ast.require_ref,
                     .source_map_handler = source_map_context,
@@ -1168,8 +1126,7 @@ pub const Bundler = struct {
                     js_ast.Symbol.Map.initList(symbols),
                     source,
                     is_bun,
-                    js_printer.Options{
-                        .externals = ast.externals,
+                    .{
                         .runtime_imports = ast.runtime_imports,
                         .require_ref = ast.require_ref,
                         .css_import_behavior = bundler.options.cssImportBehavior(),
@@ -1277,6 +1234,7 @@ pub const Bundler = struct {
         runtime_transpiler_cache: ?*bun.JSC.RuntimeTranspilerCache = null,
 
         keep_json_and_toml_as_one_statement: bool = false,
+        allow_bytecode_cache: bool = false,
     };
 
     pub fn parse(
@@ -1337,6 +1295,18 @@ pub const Bundler = struct {
                 break :brk logger.Source.initPathString(path.text, "");
             }
 
+            if (strings.startsWith(path.text, "data:")) {
+                const data_url = DataURL.parseWithoutCheck(path.text) catch |err| {
+                    bundler.log.addErrorFmt(null, logger.Loc.Empty, bundler.allocator, "{s} parsing data url \"{s}\"", .{ @errorName(err), path.text }) catch {};
+                    return null;
+                };
+                const body = data_url.decodeData(this_parse.allocator) catch |err| {
+                    bundler.log.addErrorFmt(null, logger.Loc.Empty, bundler.allocator, "{s} decoding data \"{s}\"", .{ @errorName(err), path.text }) catch {};
+                    return null;
+                };
+                break :brk logger.Source.initPathString(path.text, body);
+            }
+
             const entry = bundler.resolver.caches.fs.readFileWithAllocator(
                 if (use_shared_buffer) bun.fs_allocator else this_parse.allocator,
                 bundler.fs,
@@ -1406,12 +1376,9 @@ pub const Bundler = struct {
                 opts.tree_shaking = bundler.options.tree_shaking;
                 opts.features.inlining = bundler.options.inlining;
 
-                opts.features.react_fast_refresh = opts.features.hot_module_reloading and
-                    jsx.parse and
-                    bundler.options.jsx.supports_fast_refresh;
                 opts.filepath_hash_for_hmr = file_hash orelse 0;
                 opts.features.auto_import_jsx = bundler.options.auto_import_jsx;
-                opts.warn_about_unbundled_modules = target.isNotBun();
+                opts.warn_about_unbundled_modules = !target.isBun();
 
                 opts.features.inject_jest_globals = this_parse.inject_jest_globals;
                 opts.features.minify_syntax = bundler.options.minify_syntax;
@@ -1458,9 +1425,26 @@ pub const Bundler = struct {
                         .loader = loader,
                         .input_fd = input_fd,
                     },
-                    .already_bundled => ParseResult{
+                    .already_bundled => |already_bundled| ParseResult{
                         .ast = undefined,
-                        .already_bundled = true,
+                        .already_bundled = switch (already_bundled) {
+                            .bun => .source_code,
+                            .bun_cjs => .source_code_cjs,
+                            .bytecode_cjs, .bytecode => brk: {
+                                const default_value: ParseResult.AlreadyBundled = if (already_bundled == .bytecode_cjs) .source_code_cjs else .source_code;
+                                if (this_parse.virtual_source == null and this_parse.allow_bytecode_cache) {
+                                    var path_buf2: bun.PathBuffer = undefined;
+                                    @memcpy(path_buf2[0..path.text.len], path.text);
+                                    path_buf2[path.text.len..][0..bun.bytecode_extension.len].* = bun.bytecode_extension.*;
+                                    const bytecode = bun.sys.File.toSourceAt(dirname_fd, path_buf2[0 .. path.text.len + bun.bytecode_extension.len], bun.default_allocator).asValue() orelse break :brk default_value;
+                                    if (bytecode.contents.len == 0) {
+                                        break :brk default_value;
+                                    }
+                                    break :brk if (already_bundled == .bytecode_cjs) .{ .bytecode_cjs = @constCast(bytecode.contents) } else .{ .bytecode = @constCast(bytecode.contents) };
+                                }
+                                break :brk default_value;
+                            },
+                        },
                         .source = source,
                         .loader = loader,
                         .input_fd = input_fd,
@@ -1473,11 +1457,11 @@ pub const Bundler = struct {
                     // We allow importing tsconfig.*.json or jsconfig.*.json with comments
                     // These files implicitly become JSONC files, which aligns with the behavior of text editors.
                     if (source.path.isJSONCFile())
-                        json_parser.ParseTSConfig(&source, bundler.log, allocator) catch return null
+                        JSON.parseTSConfig(&source, bundler.log, allocator, false) catch return null
                     else
-                        json_parser.ParseJSON(&source, bundler.log, allocator) catch return null
+                        JSON.parse(&source, bundler.log, allocator, false) catch return null
                 else if (kind == .toml)
-                    TOML.parse(&source, bundler.log, allocator) catch return null
+                    TOML.parse(&source, bundler.log, allocator, false) catch return null
                 else
                     @compileError("unreachable");
 
@@ -1604,7 +1588,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 66b3ec532a..e633a9af65 100644
--- a/src/bundler/bundle_v2.zig
+++ b/src/bundler/bundle_v2.zig
@@ -43,7 +43,6 @@
 //
 const Bundler = bun.Bundler;
 const bun = @import("root").bun;
-const from = bun.from;
 const string = bun.string;
 const Output = bun.Output;
 const Global = bun.Global;
@@ -105,7 +104,7 @@ const ThisBundler = @import("../bundler.zig").Bundler;
 const Dependency = js_ast.Dependency;
 const JSAst = js_ast.BundledAst;
 const Loader = options.Loader;
-const Index = @import("../ast/base.zig").Index;
+pub const Index = @import("../ast/base.zig").Index;
 const Batcher = bun.Batcher;
 const Symbol = js_ast.Symbol;
 const EventLoop = bun.JSC.AnyEventLoop;
@@ -124,8 +123,13 @@ const MinifyRenamer = renamer.MinifyRenamer;
 const Scope = js_ast.Scope;
 const JSC = bun.JSC;
 const debugTreeShake = Output.scoped(.TreeShake, true);
+const debugPartRanges = Output.scoped(.PartRanges, true);
 const BitSet = bun.bit_set.DynamicBitSetUnmanaged;
 const Async = bun.Async;
+const Loc = Logger.Loc;
+const bake = bun.bake;
+
+const debug_deferred = bun.Output.scoped(.BUNDLER_DEFERRED, true);
 
 const logPartDependencyTree = Output.scoped(.part_dep_tree, false);
 
@@ -152,15 +156,7 @@ pub const ThreadPool = struct {
         if (existing_thread_pool) |pool| {
             this.pool = pool;
         } else {
-            var cpu_count = @as(u32, @truncate(@max(std.Thread.getCpuCount() catch 2, 2)));
-
-            if (v2.bundler.env.get("GOMAXPROCS")) |max_procs| {
-                if (std.fmt.parseInt(u32, max_procs, 10)) |cpu_count_| {
-                    cpu_count = cpu_count_;
-                } else |_| {}
-            }
-
-            cpu_count = @max(@min(cpu_count, @as(u32, @truncate(128 - 1))), 2);
+            const cpu_count = bun.getThreadCount();
             this.pool = try v2.graph.allocator.create(ThreadPoolLib);
             this.pool.* = ThreadPoolLib.init(.{
                 .max_threads = cpu_count,
@@ -324,36 +320,94 @@ pub const ThreadPool = struct {
 
 const Watcher = bun.JSC.NewHotReloader(BundleV2, EventLoop, true);
 
+/// This assigns a concise, predictable, and unique `.pretty` attribute to a Path.
+/// DevServer relies on pretty paths for identifying modules, so they must be unique.
+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;
+
+    // "file" namespace should use the relative file path for its display name.
+    // the "node" namespace is also put through this code path so that the
+    // "node:" prefix is not emitted.
+    if (path.isFile() or bun.strings.eqlComptime(path.namespace, "node")) {
+        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);
+    } else {
+        // in non-file namespaces, standard filesystem rules do not apply.
+        var path_clone = path;
+        path_clone.pretty = std.fmt.bufPrint(&buf, "{s}{}:{s}", .{
+            if (target == .bake_server_components_ssr) "ssr:" else "",
+            // make sure that a namespace including a colon wont collide with anything
+            std.fmt.Formatter(fmtEscapedNamespace){ .data = path.namespace },
+            path.text,
+        }) catch buf[0..];
+        return path_clone.dupeAllocFixPretty(allocator);
+    }
+}
+
+fn fmtEscapedNamespace(slice: []const u8, comptime fmt: []const u8, _: std.fmt.FormatOptions, w: anytype) !void {
+    comptime bun.assert(fmt.len == 0);
+    var rest = slice;
+    while (bun.strings.indexOfChar(rest, ':')) |i| {
+        try w.writeAll(rest[0..i]);
+        try w.writeAll("::");
+        rest = rest[i + 1 ..];
+    }
+    try w.writeAll(rest);
+}
+
 pub const BundleV2 = struct {
     bundler: *Bundler,
+    /// When Server Component is enabled, this is used for the client bundles
+    /// and `bundler` is used for the server bundles.
     client_bundler: *Bundler,
-    server_bundler: *Bundler,
-    graph: Graph = Graph{},
-    linker: LinkerContext = LinkerContext{ .loop = undefined },
-    bun_watcher: ?*Watcher.Watcher = null,
-    // kit_watcher: ?*bun.kit.DevServer.HotReloader.Watcher = null,
-    plugins: ?*JSC.API.JSBundler.Plugin = null,
-    completion: ?CompletionPtr = null,
-    source_code_length: usize = 0,
+    /// See bake.Framework.ServerComponents.separate_ssr_graph
+    ssr_bundler: *Bundler,
+    /// When Bun Bake is used, the resolved framework is passed here
+    framework: ?bake.Framework,
+    graph: Graph,
+    linker: LinkerContext,
+    bun_watcher: ?*bun.JSC.Watcher,
+    plugins: ?*JSC.API.JSBundler.Plugin,
+    completion: ?*JSBundleCompletionTask,
+    source_code_length: usize,
 
-    // There is a race condition where an onResolve plugin may schedule a task on the bundle thread before it's parsing task completes
+    /// There is a race condition where an onResolve plugin may schedule a task on the bundle thread before it's parsing task completes
     resolve_tasks_waiting_for_import_source_index: std.AutoArrayHashMapUnmanaged(Index.Int, BabyList(struct { to_source_index: Index, import_record_index: u32 })) = .{},
 
     /// Allocations not tracked by a threadlocal heap
-    free_list: std.ArrayList(string) = std.ArrayList(string).init(bun.default_allocator),
+    free_list: std.ArrayList([]const u8) = std.ArrayList([]const u8).init(bun.default_allocator),
 
+    /// See the comment in `Chunk.OutputPiece`
     unique_key: u64 = 0,
     dynamic_import_entry_points: std.AutoArrayHashMap(Index.Int, void) = undefined,
+    has_on_parse_plugins: bool = false,
 
-    pub const CompletionPtr = union(enum) {
-        js: *JSBundleCompletionTask,
-        kit: *bun.kit.DevServer.BundleTask,
+    finalizers: std.ArrayListUnmanaged(CacheEntry.External) = .{},
 
-        pub fn log(ptr: CompletionPtr) *bun.logger.Log {
-            return switch (ptr) {
-                inline else => |inner| &inner.log,
-            };
-        }
+    drain_defer_task: DeferredBatchTask = .{},
+
+    /// Set true by DevServer. Currently every usage of the bundler (Bun.build
+    /// and `bun build` cli) runs at the top of an event loop. When this is
+    /// true, a callback is executed after all work is complete.
+    asynchronous: bool = false,
+    thread_lock: bun.DebugThreadLock,
+
+    const BakeOptions = struct {
+        framework: bake.Framework,
+        client_bundler: *Bundler,
+        ssr_bundler: *Bundler,
+        plugins: ?*JSC.API.JSBundler.Plugin,
     };
 
     const debug = Output.scoped(.Bundle, false);
@@ -362,95 +416,166 @@ pub const BundleV2 = struct {
         return &this.linker.loop;
     }
 
-    pub fn findReachableFiles(this: *BundleV2) ![]Index {
-        const trace = tracer(@src(), "findReachableFiles");
-        defer trace.end();
+    /// Returns the JSC.EventLoop where plugin callbacks can be queued up on
+    pub fn jsLoopForPlugins(this: *BundleV2) *JSC.EventLoop {
+        bun.assert(this.plugins != null);
+        if (this.completion) |completion|
+            // From Bun.build
+            return completion.jsc_event_loop
+        else switch (this.loop().*) {
+            // From bake where the loop running the bundle is also the loop
+            // running the plugins.
+            .js => |jsc_event_loop| return jsc_event_loop,
+            // The CLI currently has no JSC event loop; for now, no plugin support
+            .mini => @panic("No JavaScript event loop for bundler plugins to run on"),
+        }
+    }
 
-        const Visitor = struct {
-            reachable: std.ArrayList(Index),
-            visited: bun.bit_set.DynamicBitSet = undefined,
-            all_import_records: []ImportRecord.List,
-            redirects: []u32,
-            redirect_map: PathToSourceIndexMap,
-            dynamic_import_entry_points: *std.AutoArrayHashMap(Index.Int, void),
+    /// Most of the time, accessing .bundler directly is OK. This is only
+    /// needed when it is important to distinct between client and server
+    ///
+    /// Note that .log, .allocator, and other things are shared
+    /// between the three bundler configurations
+    pub inline fn bundlerForTarget(this: *BundleV2, target: options.Target) *Bundler {
+        return if (!this.bundler.options.server_components)
+            this.bundler
+        else switch (target) {
+            else => this.bundler,
+            .browser => this.client_bundler,
+            .bake_server_components_ssr => this.ssr_bundler,
+        };
+    }
 
-            const MAX_REDIRECTS: usize = 64;
+    pub fn hasOnParsePlugins(this: *const BundleV2) bool {
+        return this.has_on_parse_plugins;
+    }
 
-            // Find all files reachable from all entry points. This order should be
-            // deterministic given that the entry point order is deterministic, since the
-            // returned order is the postorder of the graph traversal and import record
-            // order within a given file is deterministic.
-            pub fn visit(v: *@This(), source_index: Index, was_dynamic_import: bool, comptime check_dynamic_imports: bool) void {
-                if (source_index.isInvalid()) return;
+    /// Same semantics as bundlerForTarget for `path_to_source_index_map`
+    pub inline fn pathToSourceIndexMap(this: *BundleV2, target: options.Target) *PathToSourceIndexMap {
+        return if (!this.bundler.options.server_components)
+            &this.graph.path_to_source_index_map
+        else switch (target) {
+            else => &this.graph.path_to_source_index_map,
+            .browser => &this.graph.client_path_to_source_index_map,
+            .bake_server_components_ssr => &this.graph.ssr_path_to_source_index_map,
+        };
+    }
 
-                if (v.visited.isSet(source_index.get())) {
-                    if (comptime check_dynamic_imports) {
-                        if (was_dynamic_import) {
-                            v.dynamic_import_entry_points.put(source_index.get(), {}) catch unreachable;
-                        }
-                    }
-                    return;
-                }
-                v.visited.set(source_index.get());
+    const ReachableFileVisitor = struct {
+        reachable: std.ArrayList(Index),
+        visited: bun.bit_set.DynamicBitSet,
+        all_import_records: []ImportRecord.List,
+        redirects: []u32,
+        redirect_map: PathToSourceIndexMap,
+        dynamic_import_entry_points: *std.AutoArrayHashMap(Index.Int, void),
+        /// Files which are Server Component Boundaries
+        scb_bitset: ?bun.bit_set.DynamicBitSetUnmanaged,
+        scb_list: ServerComponentBoundary.List.Slice,
 
-                const import_record_list_id = source_index;
-                // when there are no import records, v index will be invalid
-                if (import_record_list_id.get() < v.all_import_records.len) {
-                    const import_records = v.all_import_records[import_record_list_id.get()].slice();
-                    for (import_records) |*import_record| {
-                        var other_source = import_record.source_index;
-                        if (other_source.isValid()) {
-                            var redirect_count: usize = 0;
-                            while (getRedirectId(v.redirects[other_source.get()])) |redirect_id| : (redirect_count += 1) {
-                                var other_import_records = v.all_import_records[other_source.get()].slice();
-                                const other_import_record = &other_import_records[redirect_id];
-                                import_record.source_index = other_import_record.source_index;
-                                import_record.path = other_import_record.path;
-                                other_source = other_import_record.source_index;
-                                if (redirect_count == MAX_REDIRECTS) {
-                                    import_record.path.is_disabled = true;
-                                    import_record.source_index = Index.invalid;
-                                    break;
-                                }
+        const MAX_REDIRECTS: usize = 64;
 
-                                // Handle redirects to a builtin or external module
-                                // https://github.com/oven-sh/bun/issues/3764
-                                if (!other_source.isValid()) {
-                                    break;
-                                }
-                            }
+        // Find all files reachable from all entry points. This order should be
+        // deterministic given that the entry point order is deterministic, since the
+        // returned order is the postorder of the graph traversal and import record
+        // order within a given file is deterministic.
+        pub fn visit(v: *@This(), source_index: Index, was_dynamic_import: bool, comptime check_dynamic_imports: bool) void {
+            if (source_index.isInvalid()) return;
 
-                            v.visit(import_record.source_index, check_dynamic_imports and import_record.kind == .dynamic, check_dynamic_imports);
-                        }
-                    }
-
-                    // Redirects replace the source file with another file
-                    if (getRedirectId(v.redirects[source_index.get()])) |redirect_id| {
-                        const redirect_source_index = v.all_import_records[source_index.get()].slice()[redirect_id].source_index.get();
-                        v.visit(Index.source(redirect_source_index), was_dynamic_import, check_dynamic_imports);
-                        return;
-                    }
-                }
-
-                // Each file must come after its dependencies
-                v.reachable.append(source_index) catch unreachable;
+            if (v.visited.isSet(source_index.get())) {
                 if (comptime check_dynamic_imports) {
                     if (was_dynamic_import) {
                         v.dynamic_import_entry_points.put(source_index.get(), {}) catch unreachable;
                     }
                 }
+                return;
             }
-        };
+            v.visited.set(source_index.get());
+
+            if (v.scb_bitset) |scb_bitset| {
+                if (scb_bitset.isSet(source_index.get())) {
+                    const scb_index = v.scb_list.getIndex(source_index.get()) orelse unreachable;
+                    v.visit(Index.init(v.scb_list.list.items(.reference_source_index)[scb_index]), false, check_dynamic_imports);
+                    v.visit(Index.init(v.scb_list.list.items(.ssr_source_index)[scb_index]), false, check_dynamic_imports);
+                }
+            }
+
+            const import_record_list_id = source_index;
+            // when there are no import records, v index will be invalid
+            if (import_record_list_id.get() < v.all_import_records.len) {
+                const import_records = v.all_import_records[import_record_list_id.get()].slice();
+                for (import_records) |*import_record| {
+                    var other_source = import_record.source_index;
+                    if (other_source.isValid()) {
+                        var redirect_count: usize = 0;
+                        while (getRedirectId(v.redirects[other_source.get()])) |redirect_id| : (redirect_count += 1) {
+                            var other_import_records = v.all_import_records[other_source.get()].slice();
+                            const other_import_record = &other_import_records[redirect_id];
+                            import_record.source_index = other_import_record.source_index;
+                            import_record.path = other_import_record.path;
+                            other_source = other_import_record.source_index;
+                            if (redirect_count == MAX_REDIRECTS) {
+                                import_record.path.is_disabled = true;
+                                import_record.source_index = Index.invalid;
+                                break;
+                            }
+
+                            // Handle redirects to a builtin or external module
+                            // https://github.com/oven-sh/bun/issues/3764
+                            if (!other_source.isValid()) {
+                                break;
+                            }
+                        }
+
+                        v.visit(import_record.source_index, check_dynamic_imports and import_record.kind == .dynamic, check_dynamic_imports);
+                    }
+                }
+
+                // Redirects replace the source file with another file
+                if (getRedirectId(v.redirects[source_index.get()])) |redirect_id| {
+                    const redirect_source_index = v.all_import_records[source_index.get()].slice()[redirect_id].source_index.get();
+                    v.visit(Index.source(redirect_source_index), was_dynamic_import, check_dynamic_imports);
+                    return;
+                }
+            }
+
+            // Each file must come after its dependencies
+            v.reachable.append(source_index) catch unreachable;
+            if (comptime check_dynamic_imports) {
+                if (was_dynamic_import) {
+                    v.dynamic_import_entry_points.put(source_index.get(), {}) catch unreachable;
+                }
+            }
+        }
+    };
+
+    pub fn findReachableFiles(this: *BundleV2) ![]Index {
+        const trace = tracer(@src(), "findReachableFiles");
+        defer trace.end();
+
+        // Create a quick index for server-component boundaries.
+        // We need to mark the generated files as reachable, or else many files will appear missing.
+        var sfa = std.heap.stackFallback(4096, this.graph.allocator);
+        const stack_alloc = sfa.get();
+        var scb_bitset = if (this.graph.server_component_boundaries.list.len > 0)
+            try this.graph.server_component_boundaries.slice().bitSet(stack_alloc, this.graph.input_files.len)
+        else
+            null;
+        defer if (scb_bitset) |*b| b.deinit(stack_alloc);
 
         this.dynamic_import_entry_points = std.AutoArrayHashMap(Index.Int, void).init(this.graph.allocator);
 
-        var visitor = Visitor{
+        var visitor = ReachableFileVisitor{
             .reachable = try std.ArrayList(Index).initCapacity(this.graph.allocator, this.graph.entry_points.items.len + 1),
             .visited = try bun.bit_set.DynamicBitSet.initEmpty(this.graph.allocator, this.graph.input_files.len),
             .redirects = this.graph.ast.items(.redirect_import_record_index),
             .all_import_records = this.graph.ast.items(.import_records),
             .redirect_map = this.graph.path_to_source_index_map,
             .dynamic_import_entry_points = &this.dynamic_import_entry_points,
+            .scb_bitset = scb_bitset,
+            .scb_list = if (scb_bitset != null)
+                this.graph.server_component_boundaries.slice()
+            else
+                undefined, // will never be read since the above bitset is `null`
         };
         defer visitor.visited.deinit();
 
@@ -466,15 +591,37 @@ pub const BundleV2 = struct {
             },
         }
 
-        // if (comptime Environment.allow_assert) {
-        //     Output.prettyln("Reachable count: {d} / {d}", .{ visitor.reachable.items.len, this.graph.input_files.len });
-        // }
+        const DebugLog = bun.Output.Scoped(.ReachableFiles, false);
+        if (DebugLog.isVisible()) {
+            DebugLog.log("Reachable count: {d} / {d}", .{ visitor.reachable.items.len, this.graph.input_files.len });
+            const sources: []Logger.Source = this.graph.input_files.items(.source);
+            const targets: []options.Target = this.graph.ast.items(.target);
+            for (visitor.reachable.items) |idx| {
+                const source = sources[idx.get()];
+                DebugLog.log("reachable file: #{d} {} ({s}) target=.{s}", .{
+                    source.index.get(),
+                    bun.fmt.quote(source.path.pretty),
+                    source.path.text,
+                    @tagName(targets[idx.get()]),
+                });
+            }
+        }
 
         return visitor.reachable.toOwnedSlice();
     }
 
     fn isDone(this: *BundleV2) bool {
-        return @atomicLoad(usize, &this.graph.parse_pending, .monotonic) == 0 and @atomicLoad(usize, &this.graph.resolve_pending, .monotonic) == 0;
+        this.thread_lock.assertLocked();
+
+        if (this.graph.pending_items == 0) {
+            if (this.graph.drainDeferredTasks(this)) {
+                return false;
+            }
+
+            return true;
+        }
+
+        return false;
     }
 
     pub fn waitForParse(this: *BundleV2) void {
@@ -489,14 +636,36 @@ pub const BundleV2 = struct {
         import_record: bun.JSC.API.JSBundler.Resolve.MiniImportRecord,
         target: options.Target,
     ) void {
-        var resolve_result = this.bundler.resolver.resolve(
+        const bundler = this.bundlerForTarget(target);
+        var had_busted_dir_cache: bool = false;
+        var resolve_result = while (true) break bundler.resolver.resolve(
             Fs.PathName.init(import_record.source_file).dirWithTrailingSlash(),
             import_record.specifier,
             import_record.kind,
         ) catch |err| {
+            // Only perform directory busting when hot-reloading is enabled
+            if (err == error.ModuleNotFound) {
+                if (this.bundler.options.dev_server) |dev| {
+                    if (!had_busted_dir_cache) {
+                        // Only re-query if we previously had something cached.
+                        if (bundler.resolver.bustDirCacheFromSpecifier(import_record.source_file, import_record.specifier)) {
+                            had_busted_dir_cache = true;
+                            continue;
+                        }
+                    }
+
+                    // Tell Bake's Dev Server to wait for the file to be imported.
+                    dev.directory_watchers.trackResolutionFailure(
+                        import_record.source_file,
+                        import_record.specifier,
+                        target.bakeGraph(),
+                    ) catch bun.outOfMemory();
+                }
+            }
+
             var handles_import_errors = false;
             var source: ?*const Logger.Source = null;
-            const log = this.completion.?.log();
+            const log = &this.completion.?.log;
 
             if (import_record.importer_source_index) |importer| {
                 var record: *ImportRecord = &this.graph.ast.items(.import_records)[importer].slice()[import_record.import_record_index];
@@ -518,7 +687,7 @@ pub const BundleV2 = struct {
 
                     if (!handles_import_errors) {
                         if (isPackagePath(import_record.specifier)) {
-                            if (target.isWebLike() and options.ExternalModules.isNodeBuiltin(path_to_use)) {
+                            if (target == .browser and options.ExternalModules.isNodeBuiltin(path_to_use)) {
                                 addError(
                                     log,
                                     source,
@@ -582,7 +751,7 @@ pub const BundleV2 = struct {
 
         if (path.pretty.ptr == path.text.ptr) {
             // TODO: outbase
-            const rel = bun.path.relativePlatform(this.bundler.fs.top_level_dir, path.text, .loose, false);
+            const rel = bun.path.relativePlatform(bundler.fs.top_level_dir, path.text, .loose, false);
             path.pretty = this.graph.allocator.dupe(u8, rel) catch bun.outOfMemory();
         }
         path.assertPrettyIsValid();
@@ -597,15 +766,9 @@ pub const BundleV2 = struct {
             }
         }
 
-        const entry = this.graph.path_to_source_index_map.getOrPut(this.graph.allocator, path.hashKey()) catch bun.outOfMemory();
+        const entry = this.pathToSourceIndexMap(target).getOrPut(this.graph.allocator, path.hashKey()) catch bun.outOfMemory();
         if (!entry.found_existing) {
-            path.* = path.dupeAllocFixPretty(this.graph.allocator) catch bun.outOfMemory();
-
-            // We need to parse this
-            const source_index = Index.init(@as(u32, @intCast(this.graph.ast.len)));
-            entry.value_ptr.* = source_index.get();
-            out_source_index = source_index;
-            this.graph.ast.append(bun.default_allocator, JSAst.empty) catch unreachable;
+            path.* = this.pathWithPrettyInitialized(path.*, target) catch bun.outOfMemory();
             const loader = brk: {
                 if (import_record.importer_source_index) |importer| {
                     var record: *ImportRecord = &this.graph.ast.items(.import_records)[importer].slice()[import_record.import_record_index];
@@ -614,42 +777,32 @@ pub const BundleV2 = struct {
                     }
                 }
 
-                break :brk path.loader(&this.bundler.options.loaders) orelse options.Loader.file;
+                break :brk path.loader(&bundler.options.loaders) orelse options.Loader.file;
             };
-
-            this.graph.input_files.append(bun.default_allocator, .{
-                .source = .{
+            const idx = this.enqueueParseTask(
+                &resolve_result,
+                .{
                     .path = path.*,
-                    .key_path = path.*,
                     .contents = "",
-                    .index = source_index,
                 },
-                .loader = loader,
-                .side_effects = switch (loader) {
-                    .text, .json, .toml, .file => _resolver.SideEffects.no_side_effects__pure_data,
-                    else => _resolver.SideEffects.has_side_effects,
-                },
-            }) catch bun.outOfMemory();
-            var task = this.graph.allocator.create(ParseTask) catch bun.outOfMemory();
-            task.* = ParseTask.init(&resolve_result, source_index, this);
-            task.loader = loader;
-            task.jsx = this.bundler.options.jsx;
-            task.task.node.next = null;
-            task.tree_shaking = this.linker.options.tree_shaking;
-            task.known_target = import_record.original_target;
+                loader,
+                import_record.original_target,
+            ) catch bun.outOfMemory();
+            entry.value_ptr.* = idx;
+            out_source_index = Index.init(idx);
 
-            _ = @atomicRmw(usize, &this.graph.parse_pending, .Add, 1, .monotonic);
-
-            // Handle onLoad plugins
-            if (!this.enqueueOnLoadPluginIfNeeded(task)) {
-                if (loader.shouldCopyForBundling()) {
-                    var additional_files: *BabyList(AdditionalFile) = &this.graph.input_files.items(.additional_files)[source_index.get()];
-                    additional_files.push(this.graph.allocator, .{ .source_index = task.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.pool.pool.schedule(ThreadPoolLib.Batch.from(&task.task));
+            // For non-javascript files, make all of these files share indices.
+            // For example, it is silly to bundle index.css depended on by client+server twice.
+            // It makes sense to separate these for JS because the target affects DCE
+            if (this.bundler.options.server_components and !loader.isJavaScriptLike()) {
+                const a, const b = switch (target) {
+                    else => .{ &this.graph.client_path_to_source_index_map, &this.graph.ssr_path_to_source_index_map },
+                    .browser => .{ &this.graph.path_to_source_index_map, &this.graph.ssr_path_to_source_index_map },
+                    .bake_server_components_ssr => .{ &this.graph.path_to_source_index_map, &this.graph.client_path_to_source_index_map },
+                };
+                a.put(this.graph.allocator, entry.key_ptr.*, entry.value_ptr.*) catch bun.outOfMemory();
+                if (this.framework.?.server_components.?.separate_ssr_graph)
+                    b.put(this.graph.allocator, entry.key_ptr.*, entry.value_ptr.*) catch bun.outOfMemory();
             }
         } else {
             out_source_index = Index.init(entry.value_ptr.*);
@@ -663,38 +816,33 @@ pub const BundleV2 = struct {
         }
     }
 
-    pub fn enqueueItem(
+    pub fn enqueueEntryItem(
         this: *BundleV2,
         hash: ?u64,
         batch: *ThreadPoolLib.Batch,
         resolve: _resolver.Result,
         is_entry_point: bool,
+        target: options.Target,
     ) !?Index.Int {
         var result = resolve;
         var path = result.path() orelse return null;
 
-        const entry = try this.graph.path_to_source_index_map.getOrPut(this.graph.allocator, hash orelse path.hashKey());
+        const entry = try this.pathToSourceIndexMap(target).getOrPut(this.graph.allocator, hash orelse path.hashKey());
         if (entry.found_existing) {
             return null;
         }
-        _ = @atomicRmw(usize, &this.graph.parse_pending, .Add, 1, .monotonic);
+        this.incrementScanCounter();
         const source_index = Index.source(this.graph.input_files.len);
         const loader = this.bundler.options.loaders.get(path.name.ext) orelse .file;
 
-        if (path.pretty.ptr == path.text.ptr) {
-            // TODO: outbase
-            const rel = bun.path.relativePlatform(this.bundler.fs.top_level_dir, path.text, .loose, false);
-            path.pretty = this.graph.allocator.dupe(u8, rel) catch bun.outOfMemory();
-        }
-        path.* = try path.dupeAllocFixPretty(this.graph.allocator);
+        path.* = this.pathWithPrettyInitialized(path.*, target) catch bun.outOfMemory();
         path.assertPrettyIsValid();
         entry.value_ptr.* = source_index.get();
-        this.graph.ast.append(bun.default_allocator, JSAst.empty) catch unreachable;
+        this.graph.ast.append(bun.default_allocator, JSAst.empty) catch bun.outOfMemory();
 
         try this.graph.input_files.append(bun.default_allocator, .{
             .source = .{
                 .path = path.*,
-                .key_path = path.*,
                 .contents = "",
                 .index = source_index,
             },
@@ -707,10 +855,12 @@ pub const BundleV2 = struct {
         task.task.node.next = null;
         task.tree_shaking = this.linker.options.tree_shaking;
         task.is_entry_point = is_entry_point;
+        task.known_target = target;
+        task.jsx.development = this.bundlerForTarget(target).options.jsx.development;
 
         // Handle onLoad plugins as entry points
         if (!this.enqueueOnLoadPluginIfNeeded(task)) {
-            if (loader.shouldCopyForBundling()) {
+            if (loader.shouldCopyForBundling(this.bundler.options.experimental_css)) {
                 var additional_files: *BabyList(AdditionalFile) = &this.graph.input_files.items(.additional_files)[source_index.get()];
                 additional_files.push(this.graph.allocator, .{ .source_index = task.source_index.get() }) catch unreachable;
                 this.graph.input_files.items(.side_effects)[source_index.get()] = _resolver.SideEffects.no_side_effects__pure_data;
@@ -720,14 +870,17 @@ pub const BundleV2 = struct {
             batch.push(ThreadPoolLib.Batch.from(&task.task));
         }
 
+        try this.graph.entry_points.append(this.graph.allocator, source_index);
+
         return source_index.get();
     }
 
     pub fn init(
         bundler: *ThisBundler,
+        bake_options: ?BakeOptions,
         allocator: std.mem.Allocator,
         event_loop: EventLoop,
-        enable_reloading: bool,
+        cli_watch_flag: bool,
         thread_pool: ?*ThreadPoolLib,
         heap: ?ThreadlocalArena,
     ) !*BundleV2 {
@@ -740,20 +893,38 @@ pub const BundleV2 = struct {
         this.* = .{
             .bundler = bundler,
             .client_bundler = bundler,
-            .server_bundler = bundler,
+            .ssr_bundler = bundler,
+            .framework = null,
             .graph = .{
                 .pool = undefined,
                 .heap = heap orelse try ThreadlocalArena.init(),
                 .allocator = undefined,
+                .kit_referenced_server_data = false,
+                .kit_referenced_client_data = false,
             },
             .linker = .{
                 .loop = event_loop,
                 .graph = .{
                     .allocator = undefined,
-                    .bundler_graph = undefined,
                 },
             },
+            .bun_watcher = null,
+            .plugins = null,
+            .completion = null,
+            .source_code_length = 0,
+            .thread_lock = bun.DebugThreadLock.initLocked(),
         };
+        if (bake_options) |bo| {
+            this.client_bundler = bo.client_bundler;
+            this.ssr_bundler = bo.ssr_bundler;
+            this.framework = bo.framework;
+            this.linker.framework = &this.framework.?;
+            this.plugins = bo.plugins;
+            bun.assert(bundler.options.server_components);
+            bun.assert(this.client_bundler.options.server_components);
+            if (bo.framework.server_components.?.separate_ssr_graph)
+                bun.assert(this.ssr_bundler.options.server_components);
+        }
         this.linker.graph.allocator = this.graph.heap.allocator();
         this.graph.allocator = this.linker.graph.allocator;
         this.bundler.allocator = this.graph.allocator;
@@ -762,10 +933,10 @@ pub const BundleV2 = struct {
         this.bundler.log.msgs.allocator = this.graph.allocator;
         this.bundler.log.clone_line_text = true;
 
-        // We don't expose an option to disable this. Kit requires tree-shaking
-        // disabled since every export is always referenced in case a future
-        // module depends on a previously unused export.
-        if (this.bundler.options.output_format == .internal_kit_dev) {
+        // We don't expose an option to disable this. Bake forbids tree-shaking
+        // since every export must is always exist in case a future module
+        // starts depending on it.
+        if (this.bundler.options.output_format == .internal_bake_dev) {
             this.bundler.options.tree_shaking = false;
             this.bundler.resolver.opts.tree_shaking = false;
         } else {
@@ -773,25 +944,29 @@ pub const BundleV2 = struct {
             this.bundler.resolver.opts.tree_shaking = true;
         }
 
-        this.linker.graph.bundler_graph = &this.graph;
         this.linker.resolver = &this.bundler.resolver;
         this.linker.graph.code_splitting = bundler.options.code_splitting;
-        this.graph.code_splitting = bundler.options.code_splitting;
 
         this.linker.options.minify_syntax = bundler.options.minify_syntax;
         this.linker.options.minify_identifiers = bundler.options.minify_identifiers;
         this.linker.options.minify_whitespace = bundler.options.minify_whitespace;
         this.linker.options.emit_dce_annotations = bundler.options.emit_dce_annotations;
         this.linker.options.ignore_dce_annotations = bundler.options.ignore_dce_annotations;
-
+        this.linker.options.banner = bundler.options.banner;
+        this.linker.options.footer = bundler.options.footer;
+        this.linker.options.experimental_css = bundler.options.experimental_css;
+        this.linker.options.css_chunking = bundler.options.css_chunking;
         this.linker.options.source_maps = bundler.options.source_map;
         this.linker.options.tree_shaking = bundler.options.tree_shaking;
         this.linker.options.public_path = bundler.options.public_path;
         this.linker.options.target = bundler.options.target;
         this.linker.options.output_format = bundler.options.output_format;
+        this.linker.options.generate_bytecode_cache = bundler.options.bytecode;
+
+        this.linker.dev_server = bundler.options.dev_server;
 
         var pool = try this.graph.allocator.create(ThreadPool);
-        if (enable_reloading) {
+        if (cli_watch_flag) {
             Watcher.enableHotModuleReloading(this);
         }
         // errdefer pool.destroy();
@@ -804,17 +979,44 @@ pub const BundleV2 = struct {
             thread_pool,
         );
 
-        // sanity checks for kit
-        if (this.bundler.options.output_format == .internal_kit_dev) {
-            if (this.bundler.options.compile) @panic("TODO: internal_kit_dev does not support compile");
-            if (this.bundler.options.code_splitting) @panic("TODO: internal_kit_dev does not support code splitting");
-            if (this.bundler.options.transform_only) @panic("TODO: internal_kit_dev does not support transform_only");
-        }
-
         return this;
     }
 
-    pub fn enqueueEntryPoints(this: *BundleV2, user_entry_points: []const string) !ThreadPoolLib.Batch {
+    const logScanCounter = bun.Output.scoped(.scan_counter, false);
+
+    pub fn incrementScanCounter(this: *BundleV2) void {
+        this.thread_lock.assertLocked();
+        this.graph.pending_items += 1;
+        logScanCounter(".pending_items + 1 = {d}", .{this.graph.pending_items});
+    }
+
+    pub fn decrementScanCounter(this: *BundleV2) void {
+        this.thread_lock.assertLocked();
+        this.graph.pending_items -= 1;
+        logScanCounter(".pending_items - 1 = {d}", .{this.graph.pending_items});
+        this.onAfterDecrementScanCounter();
+    }
+
+    pub fn onAfterDecrementScanCounter(this: *BundleV2) void {
+        if (this.asynchronous and this.isDone()) {
+            this.finishFromBakeDevServer(this.bundler.options.dev_server orelse
+                @panic("No dev server attached in asynchronous bundle job")) catch
+                bun.outOfMemory();
+        }
+    }
+
+    pub fn enqueueEntryPoints(
+        this: *BundleV2,
+        comptime variant: enum { normal, dev_server, bake_production },
+        data: switch (variant) {
+            .normal => []const []const u8,
+            .dev_server => struct {
+                files: bake.DevServer.EntryPointList,
+                css_data: *std.AutoArrayHashMapUnmanaged(Index, CssEntryPointMeta),
+            },
+            .bake_production => bake.production.EntryPointMap,
+        },
+    ) !ThreadPoolLib.Batch {
         var batch = ThreadPoolLib.Batch{};
 
         {
@@ -827,48 +1029,73 @@ pub const BundleV2 = struct {
             });
 
             // try this.graph.entry_points.append(allocator, Index.runtime);
-            this.graph.ast.append(bun.default_allocator, JSAst.empty) catch unreachable;
-            this.graph.path_to_source_index_map.put(this.graph.allocator, bun.hash("bun:wrap"), Index.runtime.get()) catch unreachable;
+            try this.graph.ast.append(bun.default_allocator, JSAst.empty);
+            try this.graph.path_to_source_index_map.put(this.graph.allocator, bun.hash("bun:wrap"), Index.runtime.get());
             var runtime_parse_task = try this.graph.allocator.create(ParseTask);
             runtime_parse_task.* = rt.parse_task;
             runtime_parse_task.ctx = this;
-            runtime_parse_task.task = .{
-                .callback = &ParseTask.callback,
-            };
+            runtime_parse_task.task = .{ .callback = &ParseTask.callback };
             runtime_parse_task.tree_shaking = true;
             runtime_parse_task.loader = .js;
-            _ = @atomicRmw(usize, &this.graph.parse_pending, .Add, 1, .monotonic);
+            this.incrementScanCounter();
             batch.push(ThreadPoolLib.Batch.from(&runtime_parse_task.task));
         }
 
-        if (this.bundler.router) |router| {
-            defer this.bundler.resetStore();
-            Analytics.Features.filesystem_router += 1;
-
-            const entry_points = try router.getEntryPoints();
-            try this.graph.entry_points.ensureUnusedCapacity(this.graph.allocator, entry_points.len);
-            try this.graph.input_files.ensureUnusedCapacity(this.graph.allocator, entry_points.len);
-            try this.graph.path_to_source_index_map.ensureUnusedCapacity(this.graph.allocator, @as(u32, @truncate(entry_points.len)));
-
-            for (entry_points) |entry_point| {
-                const resolved = this.bundler.resolveEntryPoint(entry_point) catch continue;
-                if (try this.enqueueItem(null, &batch, resolved, true)) |source_index| {
-                    this.graph.entry_points.append(this.graph.allocator, Index.source(source_index)) catch unreachable;
-                } else {}
-            }
-        } else {}
+        // Bake reserves two source indexes at the start of the file list, but
+        // gets its content set after the scan+parse phase, but before linking.
+        //
+        // The dev server does not use these, as it is implement in the HMR runtime.
+        if (this.bundler.options.dev_server == null) {
+            try this.reserveSourceIndexesForBake();
+        }
 
         {
             // Setup entry points
-            try this.graph.entry_points.ensureUnusedCapacity(this.graph.allocator, user_entry_points.len);
-            try this.graph.input_files.ensureUnusedCapacity(this.graph.allocator, user_entry_points.len);
-            try this.graph.path_to_source_index_map.ensureUnusedCapacity(this.graph.allocator, @as(u32, @truncate(user_entry_points.len)));
+            const num_entry_points = switch (variant) {
+                .normal => data.len,
+                .bake_production => data.files.count(),
+                .dev_server => data.files.set.count(),
+            };
 
-            for (user_entry_points) |entry_point| {
-                const resolved = this.bundler.resolveEntryPoint(entry_point) catch continue;
-                if (try this.enqueueItem(null, &batch, resolved, true)) |source_index| {
-                    this.graph.entry_points.append(this.graph.allocator, Index.source(source_index)) catch unreachable;
-                } else {}
+            try this.graph.entry_points.ensureUnusedCapacity(this.graph.allocator, num_entry_points);
+            try this.graph.input_files.ensureUnusedCapacity(this.graph.allocator, num_entry_points);
+            try this.graph.path_to_source_index_map.ensureUnusedCapacity(this.graph.allocator, @intCast(num_entry_points));
+
+            switch (variant) {
+                .normal => {
+                    for (data) |entry_point| {
+                        const resolved = this.bundler.resolveEntryPoint(entry_point) catch
+                            continue;
+                        _ = try this.enqueueEntryItem(null, &batch, resolved, true, this.bundler.options.target);
+                    }
+                },
+                .dev_server => {
+                    for (data.files.set.keys(), data.files.set.values()) |abs_path, flags| {
+                        const resolved = this.bundler.resolveEntryPoint(abs_path) catch
+                            continue;
+
+                        if (flags.client) brk: {
+                            const source_index = try this.enqueueEntryItem(null, &batch, resolved, true, .browser) orelse break :brk;
+                            if (flags.css) {
+                                try data.css_data.putNoClobber(this.graph.allocator, Index.init(source_index), .{ .imported_on_server = false });
+                            }
+                        }
+                        if (flags.server) _ = try this.enqueueEntryItem(null, &batch, resolved, true, this.bundler.options.target);
+                        if (flags.ssr) _ = try this.enqueueEntryItem(null, &batch, resolved, true, .bake_server_components_ssr);
+                    }
+                },
+                .bake_production => {
+                    for (data.files.keys()) |key| {
+                        const resolved = this.bundler.resolveEntryPoint(key.absPath()) catch
+                            continue;
+
+                        // TODO: wrap client files so the exports arent preserved.
+                        _ = try this.enqueueEntryItem(null, &batch, resolved, true, switch (key.side) {
+                            .client => .browser,
+                            .server => this.bundler.options.target,
+                        }) orelse continue;
+                    }
+                },
             }
         }
 
@@ -887,180 +1114,294 @@ pub const BundleV2 = struct {
                 child.parent = module_scope;
             }
 
+            if (comptime FeatureFlags.help_catch_memory_issues) {
+                this.graph.heap.gc(true);
+                bun.Mimalloc.mi_collect(true);
+            }
+
             module_scope.generated = try module_scope.generated.clone(this.linker.allocator);
         }
     }
 
-    pub fn enqueueShadowEntryPoints(this: *BundleV2) !void {
-        const trace = tracer(@src(), "enqueueShadowEntryPoints");
-        defer trace.end();
-        const allocator = this.graph.allocator;
+    /// 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 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;
 
-        // TODO: make this not slow
-        {
-            // process redirects
-            const initial_reachable = try this.findReachableFiles();
-            allocator.free(initial_reachable);
-            this.dynamic_import_entry_points.deinit();
-        }
+        if (!this.graph.kit_referenced_server_data and
+            !this.graph.kit_referenced_client_data) return;
 
-        const bitset_length = this.graph.input_files.len;
-        var react_client_component_boundary = bun.bit_set.DynamicBitSet.initEmpty(allocator, bitset_length) catch unreachable;
-        defer react_client_component_boundary.deinit();
-        var any_client = false;
+        const alloc = this.graph.allocator;
 
-        // Loop #1: populate the list of files that are react client components
-        for (this.graph.use_directive_entry_points.items(.use_directive), this.graph.use_directive_entry_points.items(.source_index)) |use, source_id| {
-            if (use == .@"use client") {
-                any_client = true;
-                react_client_component_boundary.set(source_id);
+        var server = try AstBuilder.init(this.graph.allocator, &bake.server_virtual_source, this.bundler.options.hot_module_reloading);
+        var client = try AstBuilder.init(this.graph.allocator, &bake.client_virtual_source, this.bundler.options.hot_module_reloading);
+
+        var server_manifest_props: std.ArrayListUnmanaged(G.Property) = .{};
+        var client_manifest_props: std.ArrayListUnmanaged(G.Property) = .{};
+
+        const scbs = this.graph.server_component_boundaries.list.slice();
+        const named_exports_array = this.graph.ast.items(.named_exports);
+
+        const id_string = server.newExpr(E.String{ .data = "id" });
+        const name_string = server.newExpr(E.String{ .data = "name" });
+        const chunks_string = server.newExpr(E.String{ .data = "chunks" });
+        const specifier_string = server.newExpr(E.String{ .data = "specifier" });
+        const empty_array = server.newExpr(E.Array{});
+
+        for (
+            scbs.items(.use_directive),
+            scbs.items(.source_index),
+            scbs.items(.ssr_source_index),
+        ) |use, source_id, ssr_index| {
+            if (use == .client) {
+                // TODO(@paperdave/bake): this file is being generated far too
+                // early. we don't know which exports are dead and which exports
+                // are live. Tree-shaking figures that out. However,
+                // tree-shaking happens after import binding, which would
+                // require this ast.
+                //
+                // The plan: change this to generate a stub ast which only has
+                // `export const serverManifest = undefined;`, and then
+                // re-generate this file later with the properly decided
+                // manifest. However, I will probably reconsider how this
+                // manifest is being generated when I write the whole
+                // "production build" part of Bake.
+
+                const keys = named_exports_array[source_id].keys();
+                const client_manifest_items = try alloc.alloc(G.Property, keys.len);
+
+                if (!sc.separate_ssr_graph) bun.todoPanic(@src(), "separate_ssr_graph=false", .{});
+
+                const client_path = server.newExpr(E.String{
+                    .data = try std.fmt.allocPrint(alloc, "{}S{d:0>8}", .{
+                        bun.fmt.hexIntLower(this.unique_key),
+                        source_id,
+                    }),
+                });
+                const ssr_path = server.newExpr(E.String{
+                    .data = try std.fmt.allocPrint(alloc, "{}S{d:0>8}", .{
+                        bun.fmt.hexIntLower(this.unique_key),
+                        ssr_index,
+                    }),
+                });
+
+                for (keys, client_manifest_items) |export_name_string, *client_item| {
+                    const server_key_string = try std.fmt.allocPrint(alloc, "{}S{d:0>8}#{s}", .{
+                        bun.fmt.hexIntLower(this.unique_key),
+                        source_id,
+                        export_name_string,
+                    });
+                    const export_name = server.newExpr(E.String{ .data = export_name_string });
+
+                    // write dependencies on the underlying module, not the proxy
+                    try server_manifest_props.append(alloc, .{
+                        .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 = client_path },
+                                .{ .key = name_string, .value = export_name },
+                                .{ .key = chunks_string, .value = empty_array },
+                            }),
+                        }),
+                    });
+                    client_item.* = .{
+                        .key = export_name,
+                        .value = server.newExpr(E.Object{
+                            .properties = try G.Property.List.fromSlice(alloc, &.{
+                                .{ .key = name_string, .value = export_name },
+                                .{ .key = specifier_string, .value = ssr_path },
+                            }),
+                        }),
+                    };
+                }
+
+                try client_manifest_props.append(alloc, .{
+                    .key = client_path,
+                    .value = server.newExpr(E.Object{
+                        .properties = G.Property.List.init(client_manifest_items),
+                    }),
+                });
+            } else {
+                bun.todoPanic(@src(), "\"use server\"", .{});
             }
         }
 
-        this.graph.shadow_entry_point_range.loc.start = -1;
+        try server.appendStmt(S.Local{
+            .kind = .k_const,
+            .decls = try G.Decl.List.fromSlice(alloc, &.{.{
+                .binding = Binding.alloc(alloc, B.Identifier{
+                    .ref = try server.newSymbol(.other, "serverManifest"),
+                }, Logger.Loc.Empty),
+                .value = server.newExpr(E.Object{
+                    .properties = G.Property.List.fromList(server_manifest_props),
+                }),
+            }}),
+            .is_export = true,
+        });
+        try server.appendStmt(S.Local{
+            .kind = .k_const,
+            .decls = try G.Decl.List.fromSlice(alloc, &.{.{
+                .binding = Binding.alloc(alloc, B.Identifier{
+                    .ref = try server.newSymbol(.other, "ssrManifest"),
+                }, Logger.Loc.Empty),
+                .value = server.newExpr(E.Object{
+                    .properties = G.Property.List.fromList(client_manifest_props),
+                }),
+            }}),
+            .is_export = true,
+        });
 
-        var visit_queue = std.fifo.LinearFifo(Index.Int, .Dynamic).init(allocator);
-        visit_queue.ensureUnusedCapacity(64) catch unreachable;
-        defer visit_queue.deinit();
-        const original_file_count = this.graph.entry_points.items.len;
+        this.graph.ast.set(Index.bake_server_data.get(), try server.toBundledAst(.bun));
+        this.graph.ast.set(Index.bake_client_data.get(), try client.toBundledAst(.browser));
+    }
 
-        for (0..original_file_count) |entry_point_id| {
-            // we are modifying the array while iterating
-            // so we should be careful
-            const entry_point_source_index = this.graph.entry_points.items[entry_point_id];
+    pub fn enqueueParseTask(
+        this: *BundleV2,
+        resolve_result: *const _resolver.Result,
+        source: Logger.Source,
+        loader: Loader,
+        known_target: options.Target,
+    ) OOM!Index.Int {
+        const source_index = Index.init(@as(u32, @intCast(this.graph.ast.len)));
+        this.graph.ast.append(bun.default_allocator, JSAst.empty) catch unreachable;
 
-            var all_imported_files = try bun.bit_set.DynamicBitSet.initEmpty(allocator, bitset_length);
-            defer all_imported_files.deinit();
-            visit_queue.head = 0;
-            visit_queue.count = 0;
-            const input_path = this.graph.input_files.items(.source)[entry_point_source_index.get()].path;
+        this.graph.input_files.append(bun.default_allocator, .{
+            .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,
+            },
+        }) catch bun.outOfMemory();
+        var task = this.graph.allocator.create(ParseTask) catch bun.outOfMemory();
+        task.* = ParseTask.init(resolve_result, source_index, this);
+        task.loader = loader;
+        task.jsx = this.bundlerForTarget(known_target).options.jsx;
+        task.task.node.next = null;
+        task.tree_shaking = this.linker.options.tree_shaking;
+        task.known_target = known_target;
 
-            {
-                const import_records = this.graph.ast.items(.import_records)[entry_point_source_index.get()];
-                for (import_records.slice()) |import_record| {
-                    if (!import_record.source_index.isValid()) {
-                        continue;
-                    }
+        this.incrementScanCounter();
 
-                    if (all_imported_files.isSet(import_record.source_index.get())) {
-                        continue;
-                    }
-
-                    all_imported_files.set(import_record.source_index.get());
-
-                    try visit_queue.writeItem(import_record.source_index.get());
-                }
+        // Handle onLoad plugins
+        if (!this.enqueueOnLoadPluginIfNeeded(task)) {
+            if (loader.shouldCopyForBundling(this.bundler.options.experimental_css)) {
+                var additional_files: *BabyList(AdditionalFile) = &this.graph.input_files.items(.additional_files)[source_index.get()];
+                additional_files.push(this.graph.allocator, .{ .source_index = task.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;
             }
 
-            while (visit_queue.readItem()) |target_source_index| {
-                const import_records = this.graph.ast.items(.import_records)[target_source_index];
-                for (import_records.slice()) |import_record| {
-                    if (!import_record.source_index.isValid()) {
-                        continue;
-                    }
-
-                    if (all_imported_files.isSet(import_record.source_index.get())) continue;
-                    all_imported_files.set(import_record.source_index.get());
-
-                    try visit_queue.writeItem(import_record.source_index.get());
-                }
-            }
-
-            all_imported_files.setIntersection(react_client_component_boundary);
-            if (all_imported_files.findFirstSet() == null) continue;
-            const source_index = Index.init(@as(u32, @intCast(this.graph.ast.len)));
-
-            var shadow = ShadowEntryPoint{
-                .from_source_index = entry_point_source_index.get(),
-                .to_source_index = source_index.get(),
-            };
-            var builder = ShadowEntryPoint.Builder{
-                .ctx = this,
-                .source_code_buffer = MutableString.initEmpty(allocator),
-                .resolved_source_indices = std.ArrayList(Index.Int).init(allocator),
-                .shadow = &shadow,
-            };
-
-            var iter = all_imported_files.iterator(.{});
-            while (iter.next()) |index| {
-                builder.addClientComponent(index);
-            }
-            bun.assert(builder.resolved_source_indices.items.len > 0);
-
-            const path = Fs.Path.initWithNamespace(
-                std.fmt.allocPrint(
-                    allocator,
-                    "{s}/{s}.client.js",
-                    .{ input_path.name.dirOrDot(), input_path.name.base },
-                ) catch unreachable,
-                "client-component",
-            );
-
-            if (this.graph.shadow_entry_point_range.loc.start < 0) {
-                this.graph.shadow_entry_point_range.loc.start = @as(i32, @intCast(source_index.get()));
-            }
-
-            this.graph.ast.append(bun.default_allocator, JSAst.empty) catch unreachable;
-            this.graph.shadow_entry_points.append(allocator, shadow) catch unreachable;
-            this.graph.input_files.append(bun.default_allocator, .{
-                .source = .{
-                    .path = path,
-                    .key_path = path,
-                    .contents = builder.source_code_buffer.toOwnedSliceLeaky(),
-                    .index = source_index,
-                },
-                .loader = options.Loader.js,
-                .side_effects = _resolver.SideEffects.has_side_effects,
-            }) catch unreachable;
-
-            var task = bun.default_allocator.create(ParseTask) catch unreachable;
-            task.* = ParseTask{
-                .ctx = this,
-                .path = path,
-                // unknown at this point:
-                .contents_or_fd = .{
-                    .contents = builder.source_code_buffer.toOwnedSliceLeaky(),
-                },
-                .side_effects = _resolver.SideEffects.has_side_effects,
-                .jsx = this.bundler.options.jsx,
-                .source_index = source_index,
-                .module_type = .unknown,
-                .loader = options.Loader.js,
-                .tree_shaking = this.linker.options.tree_shaking,
-                .known_target = options.Target.browser,
-                .presolved_source_indices = builder.resolved_source_indices.items,
-            };
-            task.task.node.next = null;
-            try this.graph.use_directive_entry_points.append(this.graph.allocator, js_ast.UseDirective.EntryPoint{
-                .source_index = source_index.get(),
-                .use_directive = .@"use client",
-            });
-
-            _ = @atomicRmw(usize, &this.graph.parse_pending, .Add, 1, .monotonic);
-            this.graph.entry_points.append(allocator, source_index) catch unreachable;
             this.graph.pool.pool.schedule(ThreadPoolLib.Batch.from(&task.task));
-            this.graph.shadow_entry_point_range.len += 1;
         }
+
+        return source_index.get();
+    }
+
+    pub fn enqueueParseTask2(
+        this: *BundleV2,
+        source: Logger.Source,
+        loader: Loader,
+        known_target: options.Target,
+    ) OOM!Index.Int {
+        const source_index = Index.init(@as(u32, @intCast(this.graph.ast.len)));
+        this.graph.ast.append(bun.default_allocator, JSAst.empty) catch unreachable;
+
+        this.graph.input_files.append(bun.default_allocator, .{
+            .source = source,
+            .loader = loader,
+            .side_effects = switch (loader) {
+                .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();
+        task.* = .{
+            .ctx = this,
+            .path = source.path,
+            .contents_or_fd = .{
+                .contents = source.contents,
+            },
+            .side_effects = .has_side_effects,
+            .jsx = if (known_target == .bake_server_components_ssr and !this.framework.?.server_components.?.separate_ssr_graph)
+                this.bundler.options.jsx
+            else
+                this.bundlerForTarget(known_target).options.jsx,
+            .source_index = source_index,
+            .module_type = .unknown,
+            .emit_decorator_metadata = false, // TODO
+            .package_version = "",
+            .loader = loader,
+            .tree_shaking = this.linker.options.tree_shaking,
+            .known_target = known_target,
+        };
+        task.task.node.next = null;
+
+        this.incrementScanCounter();
+
+        // Handle onLoad plugins
+        if (!this.enqueueOnLoadPluginIfNeeded(task)) {
+            if (loader.shouldCopyForBundling(this.bundler.options.experimental_css)) {
+                var additional_files: *BabyList(AdditionalFile) = &this.graph.input_files.items(.additional_files)[source_index.get()];
+                additional_files.push(this.graph.allocator, .{ .source_index = task.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.pool.pool.schedule(ThreadPoolLib.Batch.from(&task.task));
+        }
+        return source_index.get();
+    }
+
+    /// Enqueue a ServerComponentParseTask.
+    /// `source_without_index` is copied and assigned a new source index. That index is returned.
+    pub fn enqueueServerComponentGeneratedFile(
+        this: *BundleV2,
+        data: ServerComponentParseTask.Data,
+        source_without_index: Logger.Source,
+    ) OOM!Index.Int {
+        var new_source: Logger.Source = source_without_index;
+        const source_index = this.graph.input_files.len;
+        new_source.index = Index.init(source_index);
+        try this.graph.input_files.append(default_allocator, .{
+            .source = new_source,
+            .loader = .js,
+            .side_effects = .has_side_effects,
+        });
+        try this.graph.ast.append(default_allocator, JSAst.empty);
+
+        const task = bun.new(ServerComponentParseTask, .{
+            .data = data,
+            .ctx = this,
+            .source = new_source,
+        });
+
+        this.incrementScanCounter();
+
+        this.graph.pool.pool.schedule(ThreadPoolLib.Batch.from(&task.task));
+
+        return @intCast(source_index);
     }
 
     pub fn generateFromCLI(
         bundler: *ThisBundler,
         allocator: std.mem.Allocator,
         event_loop: EventLoop,
-        unique_key: u64,
         enable_reloading: bool,
         reachable_files_count: *usize,
         minify_duration: *u64,
         source_code_size: *u64,
     ) !std.ArrayList(options.OutputFile) {
-        var this = try BundleV2.init(bundler, allocator, event_loop, enable_reloading, null, null);
-        this.unique_key = unique_key;
+        var this = try BundleV2.init(bundler, null, allocator, event_loop, enable_reloading, null, null);
+        this.unique_key = generateUniqueKey();
 
         if (this.bundler.log.hasErrors()) {
             return error.BuildFailed;
         }
 
-        this.graph.pool.pool.schedule(try this.enqueueEntryPoints(this.bundler.options.entry_points));
+        this.graph.pool.pool.schedule(try this.enqueueEntryPoints(.normal, this.bundler.options.entry_points));
 
         if (this.bundler.log.hasErrors()) {
             return error.BuildFailed;
@@ -1071,42 +1412,98 @@ pub const BundleV2 = struct {
         minify_duration.* = @as(u64, @intCast(@divTrunc(@as(i64, @truncate(std.time.nanoTimestamp())) - @as(i64, @truncate(bun.CLI.start_time)), @as(i64, std.time.ns_per_ms))));
         source_code_size.* = this.source_code_length;
 
-        if (this.graph.use_directive_entry_points.len > 0) {
-            if (this.bundler.log.hasErrors()) {
-                return error.BuildFailed;
-            }
-
-            try this.enqueueShadowEntryPoints();
-            this.waitForParse();
-        }
-
         if (this.bundler.log.hasErrors()) {
             return error.BuildFailed;
         }
 
+        try this.processServerComponentManifestFiles();
+
         const reachable_files = try this.findReachableFiles();
         reachable_files_count.* = reachable_files.len -| 1; // - 1 for the runtime
 
         try this.processFilesToCopy(reachable_files);
 
+        try this.addServerComponentBoundariesAsExtraEntryPoints();
+
         try this.cloneAST();
 
         const chunks = try this.linker.link(
             this,
             this.graph.entry_points.items,
-            this.graph.use_directive_entry_points,
+            this.graph.server_component_boundaries,
             reachable_files,
-            unique_key,
         );
 
-        return try this.linker.generateChunksInParallel(chunks);
+        return try this.linker.generateChunksInParallel(chunks, false);
     }
 
-    pub fn processFilesToCopy(
-        this: *BundleV2,
-        reachable_files: []const Index,
-    ) !void {
+    pub fn generateFromBakeProductionCLI(
+        entry_points: bake.production.EntryPointMap,
+        server_bundler: *ThisBundler,
+        kit_options: BakeOptions,
+        allocator: std.mem.Allocator,
+        event_loop: EventLoop,
+    ) !std.ArrayList(options.OutputFile) {
+        var this = try BundleV2.init(server_bundler, kit_options, allocator, event_loop, false, null, null);
+        this.unique_key = generateUniqueKey();
+
+        if (this.bundler.log.hasErrors()) {
+            return error.BuildFailed;
+        }
+
+        this.graph.pool.pool.schedule(try this.enqueueEntryPoints(.bake_production, entry_points));
+
+        if (this.bundler.log.hasErrors()) {
+            return error.BuildFailed;
+        }
+
+        this.waitForParse();
+
+        if (this.bundler.log.hasErrors()) {
+            return error.BuildFailed;
+        }
+
+        try this.processServerComponentManifestFiles();
+
+        const reachable_files = try this.findReachableFiles();
+
+        try this.processFilesToCopy(reachable_files);
+
+        try this.addServerComponentBoundariesAsExtraEntryPoints();
+
+        try this.cloneAST();
+
+        const chunks = try this.linker.link(
+            this,
+            this.graph.entry_points.items,
+            this.graph.server_component_boundaries,
+            reachable_files,
+        );
+
+        return try this.linker.generateChunksInParallel(chunks, false);
+    }
+
+    pub fn addServerComponentBoundariesAsExtraEntryPoints(this: *BundleV2) !void {
+        // Prepare server component boundaries. Each boundary turns into two
+        // entry points, a client entrypoint and a server entrypoint.
+        //
+        // TODO: This should be able to group components by the user specified
+        // entry points. This way, using two component files in a route does not
+        // create two separate chunks. (note: bake passes each route as an entrypoint)
+        {
+            const scbs = this.graph.server_component_boundaries.slice();
+            try this.graph.entry_points.ensureUnusedCapacity(this.graph.allocator, scbs.list.len * 2);
+            for (scbs.list.items(.source_index), scbs.list.items(.ssr_source_index)) |original_index, ssr_index| {
+                inline for (.{ original_index, ssr_index }) |idx| {
+                    this.graph.entry_points.appendAssumeCapacity(Index.init(idx));
+                }
+            }
+        }
+    }
+
+    pub fn processFilesToCopy(this: *BundleV2, reachable_files: []const Index) !void {
         if (this.graph.estimated_file_loader_count > 0) {
+            const file_allocators = this.graph.input_files.items(.allocator);
             const unique_key_for_additional_files = this.graph.input_files.items(.unique_key_for_additional_file);
             const content_hashes_for_additional_files = this.graph.input_files.items(.content_hash_for_additional_file);
             const sources = this.graph.input_files.items(.source);
@@ -1140,25 +1537,22 @@ pub const BundleV2 = struct {
 
                     const loader = loaders[index];
 
-                    additional_output_files.append(
-                        options.OutputFile.init(
-                            options.OutputFile.Options{
-                                .data = .{
-                                    .buffer = .{
-                                        .data = source.contents,
-                                        .allocator = bun.default_allocator,
-                                    },
-                                },
-                                .size = source.contents.len,
-                                .output_path = std.fmt.allocPrint(bun.default_allocator, "{}", .{template}) catch bun.outOfMemory(),
-                                .input_path = bun.default_allocator.dupe(u8, source.path.text) catch bun.outOfMemory(),
-                                .input_loader = .file,
-                                .output_kind = .asset,
-                                .loader = loader,
-                                .hash = content_hashes_for_additional_files[index],
-                            },
-                        ),
-                    ) catch unreachable;
+                    additional_output_files.append(options.OutputFile.init(.{
+                        .data = .{ .buffer = .{
+                            .data = source.contents,
+                            .allocator = file_allocators[index],
+                        } },
+                        .size = source.contents.len,
+                        .output_path = std.fmt.allocPrint(bun.default_allocator, "{}", .{template}) catch bun.outOfMemory(),
+                        .input_path = bun.default_allocator.dupe(u8, source.path.text) catch bun.outOfMemory(),
+                        .input_loader = .file,
+                        .output_kind = .asset,
+                        .loader = loader,
+                        .hash = content_hashes_for_additional_files[index],
+                        .side = .client,
+                        .entry_point_index = null,
+                        .is_executable = false,
+                    })) catch unreachable;
                     additional_files[index].push(this.graph.allocator, AdditionalFile{
                         .output_file = @as(u32, @truncate(additional_output_files.items.len - 1)),
                     }) catch unreachable;
@@ -1191,8 +1585,9 @@ pub const BundleV2 = struct {
             .task = JSBundleCompletionTask.TaskCompletion.init(completion),
         };
 
-        if (plugins) |plugin|
+        if (plugins) |plugin| {
             plugin.setConfig(completion);
+        }
 
         // Ensure this exists before we spawn the thread to prevent any race
         // conditions from creating two
@@ -1247,7 +1642,7 @@ pub const BundleV2 = struct {
                     .entry_points = config.entry_points.keys(),
                     .target = config.target.toAPI(),
                     .absolute_working_dir = if (config.dir.list.items.len > 0)
-                        config.dir.toOwnedSliceLeaky()
+                        config.dir.slice()
                     else
                         null,
                     .inject = &.{},
@@ -1257,6 +1652,7 @@ pub const BundleV2 = struct {
                     .env_files = &.{},
                     .conditions = config.conditions.map.keys(),
                     .ignore_dce_annotations = bundler.options.ignore_dce_annotations,
+                    .drop = config.drop.map.keys(),
                 },
                 completion.env,
             );
@@ -1264,16 +1660,17 @@ 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.react_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;
             bundler.options.asset_naming = config.names.asset.data;
 
             bundler.options.public_path = config.public_path.list.items;
+            bundler.options.output_format = config.format;
+            bundler.options.bytecode = config.bytecode;
 
-            bundler.options.output_dir = config.outdir.toOwnedSliceLeaky();
-            bundler.options.root_dir = config.rootdir.toOwnedSliceLeaky();
+            bundler.options.output_dir = config.outdir.slice();
+            bundler.options.root_dir = config.rootdir.slice();
             bundler.options.minify_syntax = config.minify.syntax;
             bundler.options.minify_whitespace = config.minify.whitespace;
             bundler.options.minify_identifiers = config.minify.identifiers;
@@ -1283,6 +1680,10 @@ pub const BundleV2 = struct {
             bundler.options.code_splitting = config.code_splitting;
             bundler.options.emit_dce_annotations = config.emit_dce_annotations orelse !config.minify.whitespace;
             bundler.options.ignore_dce_annotations = config.ignore_dce_annotations;
+            bundler.options.experimental_css = config.experimental_css;
+            bundler.options.css_chunking = config.css_chunking;
+            bundler.options.banner = config.banner.slice();
+            bundler.options.footer = config.footer.slice();
 
             bundler.configureLinker();
             try bundler.configureDefines();
@@ -1299,6 +1700,7 @@ pub const BundleV2 = struct {
         pub fn deref(this: *JSBundleCompletionTask) void {
             if (this.ref_count.fetchSub(1, .monotonic) == 1) {
                 this.config.deinit(bun.default_allocator);
+                debug("Deinit JSBundleCompletionTask(0{x})", .{@intFromPtr(this)});
                 bun.default_allocator.destroy(this);
             }
         }
@@ -1348,7 +1750,7 @@ pub const BundleV2 = struct {
                                     bun.default_allocator.dupe(
                                         u8,
                                         bun.path.joinAbsString(
-                                            this.config.outdir.toOwnedSliceLeaky(),
+                                            this.config.outdir.slice(),
                                             &[_]string{output_file.dest_path},
                                             .auto,
                                         ),
@@ -1358,7 +1760,7 @@ pub const BundleV2 = struct {
                                         u8,
                                         bun.path.joinAbsString(
                                             Fs.FileSystem.instance.top_level_dir,
-                                            &[_]string{ this.config.dir.toOwnedSliceLeaky(), this.config.outdir.toOwnedSliceLeaky(), output_file.dest_path },
+                                            &[_]string{ this.config.dir.slice(), this.config.outdir.slice(), output_file.dest_path },
                                             .auto,
                                         ),
                                     ) catch unreachable
@@ -1402,36 +1804,45 @@ pub const BundleV2 = struct {
         }
     };
 
-    pub fn onLoadAsync(
-        this: *BundleV2,
-        load: *bun.JSC.API.JSBundler.Load,
-    ) void {
-        this.loop().enqueueTaskConcurrent(
-            bun.JSC.API.JSBundler.Load,
-            BundleV2,
-            load,
-            BundleV2.onLoad,
-            .task,
-        );
+    pub fn onLoadAsync(this: *BundleV2, load: *bun.JSC.API.JSBundler.Load) void {
+        switch (this.loop().*) {
+            .js => |jsc_event_loop| {
+                jsc_event_loop.enqueueTaskConcurrent(JSC.ConcurrentTask.fromCallback(load, onLoadFromJsLoop));
+            },
+            .mini => |*mini| {
+                mini.enqueueTaskConcurrentWithExtraCtx(
+                    bun.JSC.API.JSBundler.Load,
+                    BundleV2,
+                    load,
+                    BundleV2.onLoad,
+                    .task,
+                );
+            },
+        }
     }
 
-    pub fn onResolveAsync(
-        this: *BundleV2,
-        resolve: *bun.JSC.API.JSBundler.Resolve,
-    ) void {
-        this.loop().enqueueTaskConcurrent(
-            bun.JSC.API.JSBundler.Resolve,
-            BundleV2,
-            resolve,
-            BundleV2.onResolve,
-            .task,
-        );
+    pub fn onResolveAsync(this: *BundleV2, resolve: *bun.JSC.API.JSBundler.Resolve) void {
+        switch (this.loop().*) {
+            .js => |jsc_event_loop| {
+                jsc_event_loop.enqueueTaskConcurrent(JSC.ConcurrentTask.fromCallback(resolve, onResolveFromJsLoop));
+            },
+            .mini => |*mini| {
+                mini.enqueueTaskConcurrentWithExtraCtx(
+                    bun.JSC.API.JSBundler.Resolve,
+                    BundleV2,
+                    resolve,
+                    BundleV2.onResolve,
+                    .task,
+                );
+            },
+        }
     }
 
-    pub fn onLoad(
-        load: *bun.JSC.API.JSBundler.Load,
-        this: *BundleV2,
-    ) void {
+    pub fn onLoadFromJsLoop(load: *bun.JSC.API.JSBundler.Load) void {
+        onLoad(load, load.bv2);
+    }
+
+    pub fn onLoad(load: *bun.JSC.API.JSBundler.Load, this: *BundleV2) void {
         debug("onLoad: ({d}, {s})", .{ load.source_index.get(), @tagName(load.value) });
         defer load.deinit();
         defer {
@@ -1439,13 +1850,15 @@ pub const BundleV2 = struct {
                 this.graph.heap.gc(true);
             }
         }
-        var log = &load.completion.?.log;
+        const log = this.bundler.log;
+
+        // TODO: watcher
 
         switch (load.value.consume()) {
             .no_match => {
+                const source = &this.graph.input_files.items(.source)[load.source_index.get()];
                 // If it's a file namespace, we should run it through the parser like normal.
                 // The file could be on disk.
-                const source = &this.graph.input_files.items(.source)[load.source_index.get()];
                 if (source.path.isFile()) {
                     this.graph.pool.pool.schedule(ThreadPoolLib.Batch.from(&load.parse_task.task));
                     return;
@@ -1459,37 +1872,64 @@ pub const BundleV2 = struct {
                 }) catch {};
 
                 // An error occurred, prevent spinning the event loop forever
-                _ = @atomicRmw(usize, &this.graph.parse_pending, .Sub, 1, .monotonic);
+                this.decrementScanCounter();
             },
             .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,
                 };
                 this.graph.pool.pool.schedule(ThreadPoolLib.Batch.from(&parse_task.task));
             },
-            .err => |err| {
-                log.msgs.append(err) catch unreachable;
-                log.errors += @as(usize, @intFromBool(err.kind == .err));
-                log.warnings += @as(usize, @intFromBool(err.kind == .warn));
+            .err => |msg| {
+                if (this.bundler.options.dev_server) |dev| {
+                    const source = &this.graph.input_files.items(.source)[load.source_index.get()];
+                    // A stack-allocated Log object containing the singular message
+                    var msg_mut = msg;
+                    const temp_log: Logger.Log = .{
+                        .clone_line_text = false,
+                        .errors = @intFromBool(msg.kind == .err),
+                        .warnings = @intFromBool(msg.kind == .warn),
+                        .msgs = std.ArrayList(Logger.Msg).fromOwnedSlice(this.graph.allocator, (&msg_mut)[0..1]),
+                    };
+                    dev.handleParseTaskFailure(
+                        error.Plugin,
+                        load.bakeGraph(),
+                        source.path.keyForIncrementalGraph(),
+                        &temp_log,
+                    ) catch bun.outOfMemory();
+                } else {
+                    log.msgs.append(msg) catch bun.outOfMemory();
+                    log.errors += @intFromBool(msg.kind == .err);
+                    log.warnings += @intFromBool(msg.kind == .warn);
+                }
 
                 // An error occurred, prevent spinning the event loop forever
-                _ = @atomicRmw(usize, &this.graph.parse_pending, .Sub, 1, .monotonic);
+                this.decrementScanCounter();
             },
             .pending, .consumed => unreachable,
         }
     }
 
-    pub fn onResolve(
-        resolve: *bun.JSC.API.JSBundler.Resolve,
-        this: *BundleV2,
-    ) void {
+    pub fn onResolveFromJsLoop(resolve: *bun.JSC.API.JSBundler.Resolve) void {
+        onResolve(resolve, resolve.bv2);
+    }
+
+    pub fn onResolve(resolve: *bun.JSC.API.JSBundler.Resolve, this: *BundleV2) void {
         defer resolve.deinit();
-        defer _ = @atomicRmw(usize, &this.graph.resolve_pending, .Sub, 1, .monotonic);
+        defer this.decrementScanCounter();
         debug("onResolve: ({s}:{s}, {s})", .{ resolve.import_record.namespace, resolve.import_record.specifier, @tagName(resolve.value) });
 
         defer {
@@ -1497,7 +1937,7 @@ pub const BundleV2 = struct {
                 this.graph.heap.gc(true);
             }
         }
-        var log = &resolve.completion.?.log;
+        const log = this.bundler.log;
 
         switch (resolve.value.consume()) {
             .no_match => {
@@ -1541,10 +1981,12 @@ pub const BundleV2 = struct {
                         path.namespace = result.namespace;
                     }
 
-                    const existing = this.graph.path_to_source_index_map.getOrPut(this.graph.allocator, path.hashKey()) catch unreachable;
+                    const existing = this.pathToSourceIndexMap(resolve.import_record.original_target).getOrPut(this.graph.allocator, path.hashKey()) catch unreachable;
                     if (!existing.found_existing) {
                         this.free_list.appendSlice(&.{ result.namespace, result.path }) catch {};
 
+                        path = this.pathWithPrettyInitialized(path, resolve.import_record.original_target) catch bun.outOfMemory();
+
                         // We need to parse this
                         const source_index = Index.init(@as(u32, @intCast(this.graph.ast.len)));
                         existing.value_ptr.* = source_index.get();
@@ -1555,12 +1997,11 @@ pub const BundleV2 = struct {
                         this.graph.input_files.append(bun.default_allocator, .{
                             .source = .{
                                 .path = path,
-                                .key_path = path,
                                 .contents = "",
                                 .index = source_index,
                             },
                             .loader = loader,
-                            .side_effects = _resolver.SideEffects.has_side_effects,
+                            .side_effects = .has_side_effects,
                         }) catch unreachable;
                         var task = bun.default_allocator.create(ParseTask) catch unreachable;
                         task.* = ParseTask{
@@ -1569,12 +2010,12 @@ pub const BundleV2 = struct {
                             // unknown at this point:
                             .contents_or_fd = .{
                                 .fd = .{
-                                    .dir = .zero,
-                                    .file = .zero,
+                                    .dir = bun.invalid_fd,
+                                    .file = bun.invalid_fd,
                                 },
                             },
-                            .side_effects = _resolver.SideEffects.has_side_effects,
-                            .jsx = this.bundler.options.jsx,
+                            .side_effects = .has_side_effects,
+                            .jsx = this.bundlerForTarget(resolve.import_record.original_target).options.jsx,
                             .source_index = source_index,
                             .module_type = .unknown,
                             .loader = loader,
@@ -1583,11 +2024,11 @@ pub const BundleV2 = struct {
                         };
                         task.task.node.next = null;
 
-                        _ = @atomicRmw(usize, &this.graph.parse_pending, .Add, 1, .monotonic);
+                        this.incrementScanCounter();
 
                         // Handle onLoad plugins
                         if (!this.enqueueOnLoadPluginIfNeeded(task)) {
-                            if (loader.shouldCopyForBundling()) {
+                            if (loader.shouldCopyForBundling(this.bundler.options.experimental_css)) {
                                 var additional_files: *BabyList(AdditionalFile) = &this.graph.input_files.items(.additional_files)[source_index.get()];
                                 additional_files.push(this.graph.allocator, .{ .source_index = task.source_index.get() }) catch unreachable;
                                 this.graph.input_files.items(.side_effects)[source_index.get()] = _resolver.SideEffects.no_side_effects__pure_data;
@@ -1630,14 +2071,24 @@ pub const BundleV2 = struct {
             },
             .err => |err| {
                 log.msgs.append(err) catch unreachable;
-                log.errors += @as(usize, @intFromBool(err.kind == .err));
-                log.warnings += @as(usize, @intFromBool(err.kind == .warn));
+                log.errors += @as(u32, @intFromBool(err.kind == .err));
+                log.warnings += @as(u32, @intFromBool(err.kind == .warn));
             },
             .pending, .consumed => unreachable,
         }
     }
 
     pub fn deinit(this: *BundleV2) void {
+        {
+            // We do this first to make it harder for any dangling pointers to data to be used in there.
+            var on_parse_finalizers = this.finalizers;
+            this.finalizers = .{};
+            for (on_parse_finalizers.items) |finalizer| {
+                finalizer.call();
+            }
+            on_parse_finalizers.deinit(bun.default_allocator);
+        }
+
         defer this.graph.ast.deinit(bun.default_allocator);
         defer this.graph.input_files.deinit(bun.default_allocator);
         if (this.graph.pool.workers_assignments.count() > 0) {
@@ -1660,56 +2111,219 @@ pub const BundleV2 = struct {
         this.free_list.clearAndFree();
     }
 
-    pub fn runFromJSInNewThread(this: *BundleV2, entry_points: []const []const u8) !std.ArrayList(options.OutputFile) {
-        this.unique_key = std.crypto.random.int(u64);
+    pub fn runFromJSInNewThread(
+        this: *BundleV2,
+        entry_points: []const []const u8,
+    ) !std.ArrayList(options.OutputFile) {
+        this.unique_key = generateUniqueKey();
 
         if (this.bundler.log.errors > 0) {
             return error.BuildFailed;
         }
 
-        if (comptime FeatureFlags.help_catch_memory_issues) {
-            this.graph.heap.gc(true);
-            bun.Mimalloc.mi_collect(true);
-        }
+        this.graph.heap.helpCatchMemoryIssues();
 
-        this.graph.pool.pool.schedule(try this.enqueueEntryPoints(entry_points));
+        this.graph.pool.pool.schedule(try this.enqueueEntryPoints(.normal, entry_points));
 
         // We must wait for all the parse tasks to complete, even if there are errors.
         this.waitForParse();
 
-        if (comptime FeatureFlags.help_catch_memory_issues) {
-            this.graph.heap.gc(true);
-            bun.Mimalloc.mi_collect(true);
-        }
+        this.graph.heap.helpCatchMemoryIssues();
 
         if (this.bundler.log.errors > 0) {
             return error.BuildFailed;
         }
 
+        try this.processServerComponentManifestFiles();
+
+        this.graph.heap.helpCatchMemoryIssues();
+
         try this.cloneAST();
 
-        if (comptime FeatureFlags.help_catch_memory_issues) {
-            this.graph.heap.gc(true);
-            bun.Mimalloc.mi_collect(true);
-        }
+        this.graph.heap.helpCatchMemoryIssues();
 
         const reachable_files = try this.findReachableFiles();
 
         try this.processFilesToCopy(reachable_files);
 
+        try this.addServerComponentBoundariesAsExtraEntryPoints();
+
         const chunks = try this.linker.link(
             this,
             this.graph.entry_points.items,
-            this.graph.use_directive_entry_points,
+            this.graph.server_component_boundaries,
             reachable_files,
-            this.unique_key,
         );
 
         if (this.bundler.log.errors > 0) {
             return error.BuildFailed;
         }
 
-        return try this.linker.generateChunksInParallel(chunks);
+        return try this.linker.generateChunksInParallel(chunks, false);
+    }
+
+    /// Dev Server uses this instead to run a subset of the bundler, and to run it asynchronously.
+    pub fn startFromBakeDevServer(this: *BundleV2, bake_entry_points: bake.DevServer.EntryPointList) !BakeBundleStart {
+        this.unique_key = generateUniqueKey();
+
+        this.graph.heap.helpCatchMemoryIssues();
+
+        var ctx: BakeBundleStart = .{ .css_entry_points = .{} };
+        this.graph.pool.pool.schedule(try this.enqueueEntryPoints(.dev_server, .{
+            .files = bake_entry_points,
+            .css_data = &ctx.css_entry_points,
+        }));
+
+        this.graph.heap.helpCatchMemoryIssues();
+
+        return ctx;
+    }
+
+    pub fn finishFromBakeDevServer(this: *BundleV2, dev_server: *bake.DevServer) bun.OOM!void {
+        const start = &dev_server.current_bundle.?.start_data;
+
+        this.graph.heap.helpCatchMemoryIssues();
+
+        try this.cloneAST();
+
+        this.graph.heap.helpCatchMemoryIssues();
+
+        this.dynamic_import_entry_points = std.AutoArrayHashMap(Index.Int, void).init(this.graph.allocator);
+
+        // Separate non-failing files into two lists: JS and CSS
+        const js_reachable_files = reachable_files: {
+            var css_total_files = try std.ArrayListUnmanaged(Index).initCapacity(this.graph.allocator, this.graph.css_file_count);
+            try start.css_entry_points.ensureUnusedCapacity(this.graph.allocator, this.graph.css_file_count);
+            var js_files = try std.ArrayListUnmanaged(Index).initCapacity(this.graph.allocator, this.graph.ast.len - this.graph.css_file_count - 1);
+
+            const asts = this.graph.ast.slice();
+            const loaders = this.graph.input_files.items(.loader);
+            for (
+                asts.items(.parts)[1..],
+                asts.items(.import_records)[1..],
+                asts.items(.css)[1..],
+                asts.items(.target)[1..],
+                1..,
+            ) |part_list, import_records, maybe_css, target, index| {
+                // Dev Server proceeds even with failed files.
+                // These files are filtered out via the lack of any parts.
+                //
+                // Actual empty files will contain a part exporting an empty object.
+                if (part_list.len != 0) {
+                    if (maybe_css == null) {
+                        js_files.appendAssumeCapacity(Index.init(index));
+
+                        // Mark every part live.
+                        for (part_list.slice()) |*p| {
+                            p.is_live = true;
+                        }
+
+                        // Discover all CSS roots.
+                        for (import_records.slice()) |*record| {
+                            if (!record.source_index.isValid()) continue;
+                            if (loaders[record.source_index.get()] != .css) continue;
+                            if (asts.items(.parts)[record.source_index.get()].len == 0) {
+                                record.source_index = Index.invalid;
+                                continue;
+                            }
+
+                            const gop = start.css_entry_points.getOrPutAssumeCapacity(record.source_index);
+                            if (target != .browser)
+                                gop.value_ptr.* = .{ .imported_on_server = true }
+                            else if (!gop.found_existing)
+                                gop.value_ptr.* = .{ .imported_on_server = false };
+                        }
+                    } else {
+                        css_total_files.appendAssumeCapacity(Index.init(index));
+                    }
+                } else {
+                    _ = start.css_entry_points.swapRemove(Index.init(index));
+                }
+            }
+
+            break :reachable_files js_files.items;
+        };
+
+        this.graph.heap.helpCatchMemoryIssues();
+
+        // HMR skips most of the linker! All linking errors are converted into
+        // runtime errors to avoid a more complicated dependency graph. For
+        // example, if you remove an exported symbol, we only rebuild the
+        // changed file, then detect the missing export at runtime.
+        //
+        // Additionally, notice that we run this code generation even if we have
+        // files that failed. This allows having a large build graph (importing
+        // a new npm dependency), where one file that fails doesnt prevent the
+        // passing files to get cached in the incremental graph.
+
+        // The linker still has to be initialized as code generation expects it
+        // TODO: ???
+        try this.linker.load(
+            this,
+            this.graph.entry_points.items,
+            this.graph.server_component_boundaries,
+            js_reachable_files,
+        );
+
+        this.graph.heap.helpCatchMemoryIssues();
+
+        // Generate chunks
+        const js_part_ranges = try this.graph.allocator.alloc(PartRange, js_reachable_files.len);
+        const parts = this.graph.ast.items(.parts);
+        for (js_reachable_files, js_part_ranges) |source_index, *part_range| {
+            part_range.* = .{
+                .source_index = source_index,
+                .part_index_begin = 0,
+                .part_index_end = parts[source_index.get()].len,
+            };
+        }
+
+        const chunks = try this.graph.allocator.alloc(Chunk, start.css_entry_points.count() + 1);
+
+        chunks[0] = .{
+            .entry_point = .{
+                .entry_point_id = 0,
+                .source_index = 0,
+                .is_entry_point = true,
+            },
+            .content = .{
+                .javascript = .{
+                    // TODO(@paperdave): remove this ptrCast when Source Index is fixed
+                    .files_in_chunk_order = @ptrCast(js_reachable_files),
+                    .parts_in_chunk_in_order = js_part_ranges,
+                },
+            },
+            .output_source_map = sourcemap.SourceMapPieces.init(this.graph.allocator),
+        };
+
+        for (chunks[1..], start.css_entry_points.keys()) |*chunk, entry_point| {
+            const order = this.linker.findImportedFilesInCSSOrder(this.graph.allocator, &.{entry_point});
+            chunk.* = .{
+                .entry_point = .{
+                    .entry_point_id = @intCast(entry_point.get()),
+                    .source_index = entry_point.get(),
+                    .is_entry_point = false,
+                },
+                .content = .{
+                    .css = .{
+                        .imports_in_chunk_in_order = order,
+                        .asts = try this.graph.allocator.alloc(bun.css.BundlerStyleSheet, order.len),
+                    },
+                },
+                .output_source_map = sourcemap.SourceMapPieces.init(this.graph.allocator),
+            };
+        }
+
+        this.graph.heap.helpCatchMemoryIssues();
+
+        try this.linker.generateChunksInParallel(chunks, true);
+
+        this.graph.heap.helpCatchMemoryIssues();
+
+        try dev_server.finalizeBundle(this, .{
+            .chunks = chunks,
+            .css_file_list = start.css_entry_points,
+        });
     }
 
     pub fn enqueueOnResolvePluginIfNeeded(
@@ -1718,7 +2332,7 @@ pub const BundleV2 = struct {
         import_record: *const ImportRecord,
         source_file: []const u8,
         import_record_index: u32,
-        original_target: ?options.Target,
+        original_target: options.Target,
     ) bool {
         if (this.plugins) |plugins| {
             if (plugins.hasAnyMatches(&import_record.path, false)) {
@@ -1728,20 +2342,18 @@ pub const BundleV2 = struct {
                     import_record.path.namespace,
                     import_record.path.text,
                 });
-                _ = @atomicRmw(usize, &this.graph.resolve_pending, .Add, 1, .monotonic);
+                this.incrementScanCounter();
 
-                resolve.* = JSC.API.JSBundler.Resolve.create(
-                    .{
-                        .ImportRecord = .{
-                            .record = import_record,
-                            .source_file = source_file,
-                            .import_record_index = import_record_index,
-                            .importer_source_index = source_index,
-                            .original_target = original_target orelse this.bundler.options.target,
-                        },
-                    },
-                    this.completion.?.js,
-                );
+                resolve.* = JSC.API.JSBundler.Resolve.init(this, .{
+                    .kind = import_record.kind,
+                    .source_file = source_file,
+                    .namespace = import_record.path.namespace,
+                    .specifier = import_record.path.text,
+                    .importer_source_index = source_index,
+                    .import_record_index = import_record_index,
+                    .range = import_record.range,
+                    .original_target = original_target,
+                });
                 resolve.dispatch();
                 return true;
             }
@@ -1753,19 +2365,16 @@ 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,
                     parse.path.text,
                 });
-                var load = bun.default_allocator.create(JSC.API.JSBundler.Load) catch unreachable;
-                load.* = JSC.API.JSBundler.Load.create(
-                    this.completion.?.js,
-                    parse.source_index,
-                    parse.path.loader(&this.bundler.options.loaders) orelse options.Loader.js,
-                    parse.path,
-                );
-                load.parse_task = parse;
+                const load = bun.default_allocator.create(JSC.API.JSBundler.Load) catch bun.outOfMemory();
+                load.* = JSC.API.JSBundler.Load.init(this, parse);
                 load.dispatch();
                 return true;
             }
@@ -1774,6 +2383,42 @@ pub const BundleV2 = struct {
         return false;
     }
 
+    fn pathWithPrettyInitialized(this: *BundleV2, path: Fs.Path, target: options.Target) !Fs.Path {
+        return genericPathWithPrettyInitialized(path, target, this.bundler.fs.top_level_dir, this.graph.allocator);
+    }
+
+    fn reserveSourceIndexesForBake(this: *BundleV2) !void {
+        const fw = this.framework orelse return;
+        _ = fw.server_components orelse return;
+
+        // Call this after
+        bun.assert(this.graph.input_files.len == 1);
+        bun.assert(this.graph.ast.len == 1);
+
+        try this.graph.ast.ensureUnusedCapacity(this.graph.allocator, 2);
+        try this.graph.input_files.ensureUnusedCapacity(this.graph.allocator, 2);
+
+        const server_source = bake.server_virtual_source;
+        const client_source = bake.client_virtual_source;
+
+        this.graph.input_files.appendAssumeCapacity(.{
+            .source = server_source,
+            .loader = .js,
+            .side_effects = .no_side_effects__pure_data,
+        });
+        this.graph.input_files.appendAssumeCapacity(.{
+            .source = client_source,
+            .loader = .js,
+            .side_effects = .no_side_effects__pure_data,
+        });
+
+        bun.assert(this.graph.input_files.items(.source)[Index.bake_server_data.get()].index.get() == Index.bake_server_data.get());
+        bun.assert(this.graph.input_files.items(.source)[Index.bake_client_data.get()].index.get() == Index.bake_client_data.get());
+
+        this.graph.ast.appendAssumeCapacity(JSAst.empty);
+        this.graph.ast.appendAssumeCapacity(JSAst.empty);
+    }
+
     // TODO: remove ResolveQueue
     //
     // Moving this to the Bundle thread was a significant perf improvement on Linux for first builds
@@ -1802,7 +2447,7 @@ pub const BundleV2 = struct {
 
         var last_error: ?anyerror = null;
 
-        for (ast.import_records.slice(), 0..) |*import_record, i| {
+        outer: for (ast.import_records.slice(), 0..) |*import_record, i| {
             if (
             // Don't resolve TypeScript types
             import_record.is_unused or
@@ -1816,6 +2461,29 @@ pub const BundleV2 = struct {
                 continue;
             }
 
+            if (this.framework) |fw| if (fw.server_components != null) {
+                switch (ast.target.isServerSide()) {
+                    inline else => |is_server| {
+                        const src = if (is_server) bake.server_virtual_source else bake.client_virtual_source;
+                        if (strings.eqlComptime(import_record.path.text, src.path.pretty)) {
+                            if (this.bundler.options.dev_server != null) {
+                                import_record.is_external_without_side_effects = true;
+                                import_record.source_index = Index.invalid;
+                            } else {
+                                if (is_server) {
+                                    this.graph.kit_referenced_server_data = true;
+                                } else {
+                                    this.graph.kit_referenced_client_data = true;
+                                }
+                                import_record.path.namespace = "bun";
+                                import_record.source_index = src.index;
+                            }
+                            continue;
+                        }
+                    },
+                }
+            };
+
             if (ast.target.isBun()) {
                 if (JSC.HardcodedModule.Aliases.get(import_record.path.text, options.Target.bun)) |replacement| {
                     import_record.path.text = replacement.path;
@@ -1870,7 +2538,75 @@ pub const BundleV2 = struct {
                 continue;
             }
 
-            var resolve_result = this.bundler.resolver.resolve(source_dir, import_record.path.text, import_record.kind) catch |err| {
+            const bundler, const renderer: bake.Graph, const target =
+                if (import_record.tag == .bake_resolve_to_ssr_graph)
+            brk: {
+                // TODO: consider moving this error into js_parser so it is caught more reliably
+                // Then we can assert(this.framework != null)
+                if (this.framework == null) {
+                    this.bundler.log.addErrorFmt(
+                        source,
+                        import_record.range.loc,
+                        this.graph.allocator,
+                        "The 'bunBakeGraph' import attribute cannot be used outside of a Bun Bake bundle",
+                        .{},
+                    ) catch @panic("unexpected log error");
+                    continue;
+                }
+
+                const is_supported = this.framework.?.server_components != null and
+                    this.framework.?.server_components.?.separate_ssr_graph;
+                if (!is_supported) {
+                    this.bundler.log.addErrorFmt(
+                        source,
+                        import_record.range.loc,
+                        this.graph.allocator,
+                        "Framework does not have a separate SSR graph to put this import into",
+                        .{},
+                    ) catch @panic("unexpected log error");
+                    continue;
+                }
+
+                break :brk .{
+                    this.ssr_bundler,
+                    .ssr,
+                    .bake_server_components_ssr,
+                };
+            } else .{
+                this.bundlerForTarget(ast.target),
+                ast.target.bakeGraph(),
+                ast.target,
+            };
+
+            var had_busted_dir_cache = false;
+            var resolve_result = inner: while (true) break bundler.resolver.resolveWithFramework(
+                source_dir,
+                import_record.path.text,
+                import_record.kind,
+            ) catch |err| {
+                // Only perform directory busting when hot-reloading is enabled
+                if (err == error.ModuleNotFound) {
+                    if (this.bundler.options.dev_server) |dev| {
+                        if (!had_busted_dir_cache) {
+                            // Only re-query if we previously had something cached.
+                            if (bundler.resolver.bustDirCacheFromSpecifier(
+                                source.path.text,
+                                import_record.path.text,
+                            )) {
+                                had_busted_dir_cache = true;
+                                continue :inner;
+                            }
+                        }
+
+                        // Tell Bake's Dev Server to wait for the file to be imported.
+                        dev.directory_watchers.trackResolutionFailure(
+                            source.path.text,
+                            import_record.path.text,
+                            ast.target.bakeGraph(), // use the source file target not the altered one
+                        ) catch bun.outOfMemory();
+                    }
+                }
+
                 // Disable failing packages from being printed.
                 // This may cause broken code to write.
                 // However, doing this means we tell them all the resolve errors
@@ -1884,7 +2620,7 @@ pub const BundleV2 = struct {
                         if (!import_record.handles_import_errors) {
                             last_error = err;
                             if (isPackagePath(import_record.path.text)) {
-                                if (ast.target.isWebLike() and options.ExternalModules.isNodeBuiltin(import_record.path.text)) {
+                                if (ast.target == .browser and options.ExternalModules.isNodeBuiltin(import_record.path.text)) {
                                     addError(
                                         this.bundler.log,
                                         source,
@@ -1925,12 +2661,12 @@ pub const BundleV2 = struct {
                         last_error = err;
                     },
                 }
-                continue;
+                continue :outer;
             };
             // if there were errors, lets go ahead and collect them all
             if (last_error != null) continue;
 
-            var path: *Fs.Path = resolve_result.path() orelse {
+            const path: *Fs.Path = resolve_result.path() orelse {
                 import_record.path.is_disabled = true;
                 import_record.source_index = Index.invalid;
 
@@ -1945,26 +2681,40 @@ pub const BundleV2 = struct {
                 continue;
             }
 
+            if (this.bundler.options.dev_server) |dev_server| {
+                import_record.source_index = Index.invalid;
+                import_record.is_external_without_side_effects = true;
+
+                if (dev_server.isFileCached(path.text, renderer)) |entry| {
+                    const rel = bun.path.relativePlatform(this.bundler.fs.top_level_dir, path.text, .loose, false);
+                    import_record.path.text = rel;
+                    import_record.path.pretty = rel;
+                    import_record.path = this.pathWithPrettyInitialized(path.*, target) catch bun.outOfMemory();
+                    if (entry.kind == .css) {
+                        import_record.path.is_disabled = true;
+                    }
+                    continue;
+                }
+            }
+
             const hash_key = path.hashKey();
 
-            if (this.graph.path_to_source_index_map.get(hash_key)) |id| {
-                import_record.source_index = Index.init(id);
+            if (this.pathToSourceIndexMap(target).get(hash_key)) |id| {
+                if (this.bundler.options.dev_server != null) {
+                    import_record.path = this.graph.input_files.items(.source)[id].path;
+                } else {
+                    import_record.source_index = Index.init(id);
+                }
                 continue;
             }
 
             const resolve_entry = resolve_queue.getOrPut(hash_key) catch bun.outOfMemory();
             if (resolve_entry.found_existing) {
                 import_record.path = resolve_entry.value_ptr.*.path;
-
                 continue;
             }
 
-            if (path.pretty.ptr == path.text.ptr) {
-                // TODO: outbase
-                const rel = bun.path.relativePlatform(this.bundler.fs.top_level_dir, path.text, .loose, false);
-                path.pretty = this.graph.allocator.dupe(u8, rel) catch bun.outOfMemory();
-            }
-            path.* = path.dupeAllocFixPretty(this.graph.allocator) catch bun.outOfMemory();
+            path.* = this.pathWithPrettyInitialized(path.*, target) catch bun.outOfMemory();
 
             var secondary_path_to_copy: ?Fs.Path = null;
             if (resolve_result.path_pair.secondary) |*secondary| {
@@ -1979,18 +2729,12 @@ pub const BundleV2 = struct {
             import_record.path = path.*;
             debug("created ParseTask: {s}", .{path.text});
 
-            var resolve_task = bun.default_allocator.create(ParseTask) catch bun.outOfMemory();
-            resolve_task.* = ParseTask.init(&resolve_result, null, this);
-
+            const resolve_task = bun.default_allocator.create(ParseTask) catch bun.outOfMemory();
+            resolve_task.* = ParseTask.init(&resolve_result, Index.invalid, this);
             resolve_task.secondary_path_for_commonjs_interop = secondary_path_to_copy;
-
-            if (parse_result.value.success.use_directive != .none) {
-                resolve_task.known_target = ast.target;
-            } else {
-                resolve_task.known_target = ast.target;
-            }
-
-            resolve_task.jsx.development = resolve_result.jsx.development;
+            resolve_task.known_target = target;
+            resolve_task.jsx = resolve_result.jsx;
+            resolve_task.jsx.development = this.bundlerForTarget(target).options.jsx.development;
 
             if (import_record.tag.loader()) |loader| {
                 resolve_task.loader = loader;
@@ -2008,10 +2752,12 @@ pub const BundleV2 = struct {
             debug("failed with error: {s}", .{@errorName(err)});
             resolve_queue.clearAndFree();
             parse_result.value = .{
-                .err = ParseTask.Result.Error{
+                .err = .{
                     .err = err,
                     .step = .resolve,
                     .log = Logger.Log.init(bun.default_allocator),
+                    .source_index = source.index,
+                    .target = ast.target,
                 },
             };
         }
@@ -2021,25 +2767,48 @@ pub const BundleV2 = struct {
 
     const ResolveQueue = std.AutoArrayHashMap(u64, *ParseTask);
 
+    pub fn onNotifyDefer(this: *BundleV2) void {
+        this.thread_lock.assertLocked();
+        this.graph.deferred_pending += 1;
+        this.decrementScanCounter();
+    }
+
+    pub fn onNotifyDeferMini(_: *bun.JSC.API.JSBundler.Load, this: *BundleV2) void {
+        this.onNotifyDefer();
+    }
+
     pub fn onParseTaskComplete(parse_result: *ParseTask.Result, this: *BundleV2) void {
         const trace = tracer(@src(), "onParseTaskComplete");
         defer trace.end();
+        if (parse_result.external.function != null) {
+            const source = switch (parse_result.value) {
+                inline .empty, .err => |data| data.source_index.get(),
+                .success => |val| val.source.index.get(),
+            };
+            const loader: Loader = this.graph.input_files.items(.loader)[source];
+            if (!loader.shouldCopyForBundling(this.bundler.options.experimental_css)) {
+                this.finalizers.append(bun.default_allocator, parse_result.external) catch bun.outOfMemory();
+            } else {
+                this.graph.input_files.items(.allocator)[source] = ExternalFreeFunctionAllocator.create(@ptrCast(parse_result.external.function.?), parse_result.external.ctx.?);
+            }
+        }
+
         defer bun.default_allocator.destroy(parse_result);
 
-        var graph = &this.graph;
-
-        var diff: isize = -1;
+        const graph = &this.graph;
 
+        var diff: i32 = -1;
         defer {
-            if (diff > 0)
-                _ = @atomicRmw(usize, &graph.parse_pending, .Add, @as(usize, @intCast(diff)), .monotonic)
-            else
-                _ = @atomicRmw(usize, &graph.parse_pending, .Sub, @as(usize, @intCast(-diff)), .monotonic);
+            logScanCounter("in parse task .pending_items += {d} = {d}\n", .{ diff, @as(i32, @intCast(graph.pending_items)) + diff });
+            graph.pending_items = @intCast(@as(i32, @intCast(graph.pending_items)) + diff);
+            if (diff < 0)
+                this.onAfterDecrementScanCounter();
         }
 
         var resolve_queue = ResolveQueue.init(this.graph.allocator);
         defer resolve_queue.deinit();
         var process_log = true;
+
         if (parse_result.value == .success) {
             resolve_queue = runResolutionForParseTask(parse_result, this);
             if (parse_result.value == .err) {
@@ -2047,10 +2816,29 @@ pub const BundleV2 = struct {
             }
         }
 
+        // To minimize contention, watchers are appended by the bundler thread.
+        if (this.bun_watcher) |watcher| {
+            if (parse_result.watcher_data.fd != bun.invalid_fd and parse_result.watcher_data.fd != .zero) {
+                const source = switch (parse_result.value) {
+                    inline .empty, .err => |data| graph.input_files.items(.source)[data.source_index.get()],
+                    .success => |val| val.source,
+                };
+                _ = watcher.addFile(
+                    parse_result.watcher_data.fd,
+                    source.path.text,
+                    bun.hash32(source.path.text),
+                    graph.input_files.items(.loader)[source.index.get()],
+                    parse_result.watcher_data.dir_fd,
+                    null,
+                    false,
+                );
+            }
+        }
+
         switch (parse_result.value) {
             .empty => |empty_result| {
-                var input_files = graph.input_files.slice();
-                var side_effects = input_files.items(.side_effects);
+                const input_files = graph.input_files.slice();
+                const side_effects = input_files.items(.side_effects);
                 side_effects[empty_result.source_index.get()] = .no_side_effects__empty_ast;
                 if (comptime Environment.allow_assert) {
                     debug("onParse({d}, {s}) = empty", .{
@@ -2058,69 +2846,12 @@ pub const BundleV2 = struct {
                         input_files.items(.source)[empty_result.source_index.get()].path.text,
                     });
                 }
-
-                if (this.bun_watcher) |watcher| {
-                    if (empty_result.watcher_data.fd != .zero and empty_result.watcher_data.fd != bun.invalid_fd) {
-                        _ = watcher.addFile(
-                            empty_result.watcher_data.fd,
-                            input_files.items(.source)[empty_result.source_index.get()].path.text,
-                            bun.hash32(input_files.items(.source)[empty_result.source_index.get()].path.text),
-                            graph.input_files.items(.loader)[empty_result.source_index.get()],
-                            empty_result.watcher_data.dir_fd,
-                            null,
-                            false,
-                        );
-                    }
-                }
-                // else if (this.kit_watcher) |watcher| {
-                //     if (empty_result.watcher_data.fd != .zero and empty_result.watcher_data.fd != bun.invalid_fd) {
-                //         _ = watcher.addFile(
-                //             empty_result.watcher_data.fd,
-                //             input_files.items(.source)[empty_result.source_index.get()].path.text,
-                //             bun.hash32(input_files.items(.source)[empty_result.source_index.get()].path.text),
-                //             graph.input_files.items(.loader)[empty_result.source_index.get()],
-                //             empty_result.watcher_data.dir_fd,
-                //             null,
-                //             false,
-                //         );
-                //     }
-                // }
             },
             .success => |*result| {
                 result.log.cloneToWithRecycled(this.bundler.log, true) catch unreachable;
 
-                {
-                    // to minimize contention, we add watcher here
-                    if (this.bun_watcher) |watcher| {
-                        if (result.watcher_data.fd != .zero and result.watcher_data.fd != bun.invalid_fd) {
-                            _ = watcher.addFile(
-                                result.watcher_data.fd,
-                                result.source.path.text,
-                                bun.hash32(result.source.path.text),
-                                result.source.path.loader(&this.bundler.options.loaders) orelse options.Loader.file,
-                                result.watcher_data.dir_fd,
-                                result.watcher_data.package_json,
-                                false,
-                            );
-                        }
-                    }
-                    // else if (this.kit_watcher) |watcher| {
-                    //     if (result.watcher_data.fd != .zero and result.watcher_data.fd != bun.invalid_fd) {
-                    //         _ = watcher.addFile(
-                    //             result.watcher_data.fd,
-                    //             result.source.path.text,
-                    //             bun.hash32(result.source.path.text),
-                    //             result.source.path.loader(&this.bundler.options.loaders) orelse options.Loader.file,
-                    //             result.watcher_data.dir_fd,
-                    //             result.watcher_data.package_json,
-                    //             false,
-                    //         );
-                    //     }
-                    // }
-                }
-
-                // Warning: this array may resize in this function call
-                // do not reuse it.
+                // Warning: `input_files` and `ast` arrays may resize in this function call
+                // It is not safe to cache slices from them.
                 graph.input_files.items(.source)[result.source.index.get()] = result.source;
                 this.source_code_length += if (!result.source.index.isRuntime())
                     result.source.contents.len
@@ -2138,17 +2869,18 @@ pub const BundleV2 = struct {
 
                 var iter = resolve_queue.iterator();
 
+                const path_to_source_index_map = this.pathToSourceIndexMap(result.ast.target);
                 while (iter.next()) |entry| {
                     const hash = entry.key_ptr.*;
                     const value = entry.value_ptr.*;
 
-                    var existing = graph.path_to_source_index_map.getOrPut(graph.allocator, hash) catch unreachable;
+                    var existing = path_to_source_index_map.getOrPut(graph.allocator, hash) catch unreachable;
 
                     // If the same file is imported and required, and those point to different files
                     // Automatically rewrite it to the secondary one
                     if (value.secondary_path_for_commonjs_interop) |secondary_path| {
                         const secondary_hash = secondary_path.hashKey();
-                        if (graph.path_to_source_index_map.get(secondary_hash)) |secondary| {
+                        if (path_to_source_index_map.get(secondary_hash)) |secondary| {
                             existing.found_existing = true;
                             existing.value_ptr.* = secondary;
                         }
@@ -2165,7 +2897,6 @@ pub const BundleV2 = struct {
 
                         new_input_file.source.index = Index.source(graph.input_files.len);
                         new_input_file.source.path = new_task.path;
-                        new_input_file.source.key_path = new_input_file.source.path;
 
                         // We need to ensure the loader is set or else importstar_ts/ReExportTypeOnlyFileES6 will fail.
                         new_input_file.loader = loader;
@@ -2182,7 +2913,7 @@ pub const BundleV2 = struct {
                             continue;
                         }
 
-                        if (loader.shouldCopyForBundling()) {
+                        if (loader.shouldCopyForBundling(this.bundler.options.experimental_css)) {
                             var additional_files: *BabyList(AdditionalFile) = &graph.input_files.items(.additional_files)[result.source.index.get()];
                             additional_files.push(this.graph.allocator, .{ .source_index = new_task.source_index.get() }) catch unreachable;
                             new_input_file.side_effects = _resolver.SideEffects.no_side_effects__pure_data;
@@ -2193,7 +2924,7 @@ pub const BundleV2 = struct {
                         graph.pool.pool.schedule(ThreadPoolLib.Batch.from(&new_task.task));
                     } else {
                         const loader = value.loader orelse graph.input_files.items(.source)[existing.value_ptr.*].path.loader(&this.bundler.options.loaders) orelse options.Loader.file;
-                        if (loader.shouldCopyForBundling()) {
+                        if (loader.shouldCopyForBundling(this.bundler.options.experimental_css)) {
                             var additional_files: *BabyList(AdditionalFile) = &graph.input_files.items(.additional_files)[result.source.index.get()];
                             additional_files.push(this.graph.allocator, .{ .source_index = existing.value_ptr.* }) catch unreachable;
                             graph.estimated_file_loader_count += 1;
@@ -2205,21 +2936,34 @@ pub const BundleV2 = struct {
 
                 var import_records = result.ast.import_records.clone(this.graph.allocator) catch unreachable;
 
+                const input_file_loaders = this.graph.input_files.items(.loader);
+
                 if (this.resolve_tasks_waiting_for_import_source_index.fetchSwapRemove(result.source.index.get())) |pending_entry| {
                     for (pending_entry.value.slice()) |to_assign| {
-                        import_records.slice()[to_assign.import_record_index].source_index = to_assign.to_source_index;
+                        if (this.bundler.options.dev_server == null or
+                            input_file_loaders[to_assign.to_source_index.get()] == .css)
+                        {
+                            import_records.slice()[to_assign.import_record_index].source_index = to_assign.to_source_index;
+                        }
                     }
+
                     var list = pending_entry.value.list();
                     list.deinit(this.graph.allocator);
                 }
 
+                if (result.ast.css != null) {
+                    this.graph.css_file_count += 1;
+                }
+
                 for (import_records.slice(), 0..) |*record, i| {
-                    if (graph.path_to_source_index_map.get(record.path.hashKey())) |source_index| {
-                        record.source_index.value = source_index;
+                    if (path_to_source_index_map.get(record.path.hashKey())) |source_index| {
+                        if (this.bundler.options.dev_server == null or
+                            input_file_loaders[source_index] == .css)
+                            record.source_index.value = source_index;
 
                         if (getRedirectId(result.ast.redirect_import_record_index)) |compare| {
                             if (compare == @as(u32, @truncate(i))) {
-                                graph.path_to_source_index_map.put(
+                                path_to_source_index_map.put(
                                     graph.allocator,
                                     result.source.path.hashKey(),
                                     source_index,
@@ -2231,49 +2975,120 @@ pub const BundleV2 = struct {
                 result.ast.import_records = import_records;
 
                 graph.ast.set(result.source.index.get(), result.ast);
-                if (result.use_directive != .none) {
-                    graph.use_directive_entry_points.append(
+
+                // For files with use directives, index and prepare the other side.
+                if (result.use_directive != .none and if (this.framework.?.server_components.?.separate_ssr_graph)
+                    ((result.use_directive == .client) == (result.ast.target == .browser))
+                else
+                    ((result.use_directive == .client) != (result.ast.target == .browser)))
+                {
+                    if (result.use_directive == .server)
+                        bun.todoPanic(@src(), "\"use server\"", .{});
+
+                    const reference_source_index, const ssr_index = if (this.framework.?.server_components.?.separate_ssr_graph) brk: {
+                        // Enqueue two files, one in server graph, one in ssr graph.
+                        const reference_source_index = this.enqueueServerComponentGeneratedFile(
+                            .{ .client_reference_proxy = .{
+                                .other_source = result.source,
+                                .named_exports = result.ast.named_exports,
+                            } },
+                            result.source,
+                        ) catch bun.outOfMemory();
+
+                        var ssr_source = result.source;
+                        ssr_source.path.pretty = ssr_source.path.text;
+                        ssr_source.path = this.pathWithPrettyInitialized(ssr_source.path, .bake_server_components_ssr) catch bun.outOfMemory();
+                        const ssr_index = this.enqueueParseTask2(
+                            ssr_source,
+                            this.graph.input_files.items(.loader)[result.source.index.get()],
+                            .bake_server_components_ssr,
+                        ) catch bun.outOfMemory();
+
+                        break :brk .{ reference_source_index, ssr_index };
+                    } else brk: {
+                        // Enqueue only one file
+                        var server_source = result.source;
+                        server_source.path.pretty = server_source.path.text;
+                        server_source.path = this.pathWithPrettyInitialized(server_source.path, this.bundler.options.target) catch bun.outOfMemory();
+                        const server_index = this.enqueueParseTask2(
+                            server_source,
+                            this.graph.input_files.items(.loader)[result.source.index.get()],
+                            .browser,
+                        ) catch bun.outOfMemory();
+
+                        break :brk .{ server_index, Index.invalid.get() };
+                    };
+
+                    this.graph.path_to_source_index_map.put(
                         graph.allocator,
-                        .{
-                            .source_index = result.source.index.get(),
-                            .use_directive = result.use_directive,
-                        },
-                    ) catch unreachable;
+                        result.source.path.hashKey(),
+                        reference_source_index,
+                    ) catch bun.outOfMemory();
+
+                    graph.server_component_boundaries.put(
+                        graph.allocator,
+                        result.source.index.get(),
+                        result.use_directive,
+                        reference_source_index,
+                        ssr_index,
+                    ) catch bun.outOfMemory();
                 }
             },
             .err => |*err| {
-                if (comptime Environment.allow_assert) {
+                if (comptime Environment.enable_logs) {
                     debug("onParse() = err", .{});
                 }
 
                 if (process_log) {
-                    if (err.log.msgs.items.len > 0) {
+                    if (this.bundler.options.dev_server) |dev_server| {
+                        dev_server.handleParseTaskFailure(
+                            err.err,
+                            err.target.bakeGraph(),
+                            this.graph.input_files.items(.source)[err.source_index.get()].path.text,
+                            &err.log,
+                        ) catch bun.outOfMemory();
+                    } else if (err.log.msgs.items.len > 0) {
                         err.log.cloneToWithRecycled(this.bundler.log, true) catch unreachable;
                     } else {
                         this.bundler.log.addErrorFmt(
                             null,
                             Logger.Loc.Empty,
-                            bun.default_allocator,
+                            this.bundler.log.msgs.allocator,
                             "{s} while {s}",
                             .{ @errorName(err.err), @tagName(err.step) },
                         ) catch unreachable;
                     }
                 }
+
+                if (Environment.allow_assert and this.bundler.options.dev_server != null) {
+                    bun.assert(this.graph.ast.items(.parts)[err.source_index.get()].len == 0);
+                }
             },
         }
     }
+
+    /// To satisfy the interface from NewHotReloader()
+    pub fn getLoaders(vm: *BundleV2) *bun.options.Loader.HashTable {
+        return &vm.bundler.options.loaders;
+    }
+
+    /// To satisfy the interface from NewHotReloader()
+    pub fn bustDirCache(vm: *BundleV2, path: []const u8) bool {
+        return vm.bundler.resolver.bustDirCache(path);
+    }
 };
 
 /// Used to keep the bundle thread from spinning on Windows
 pub fn timerCallback(_: *bun.windows.libuv.Timer) callconv(.C) void {}
 
-/// Used for Bun.build and Kit, as they asynchronously schedule multiple
-/// bundles. To account for their respective differences, the scheduling code
-/// is generalized over the Task structure.
+/// Originally, bake.DevServer required a separate bundling thread, but that was
+/// later removed. The bundling thread's scheduling logic is generalized over
+/// the completion structure.
+///
+/// CompletionStruct's interface:
 ///
 /// - `configureBundler` is used to configure `Bundler`.
 /// - `completeOnBundleThread` is used to tell the task that it is done.
-///
 pub fn BundleThread(CompletionStruct: type) type {
     return struct {
         const Self = @This();
@@ -2298,8 +3113,7 @@ pub fn BundleThread(CompletionStruct: type) type {
         }
 
         /// Lazily-initialized singleton. This is used for `Bun.build` since the
-        /// bundle thread may not be needed. Kit always uses the bundler, so it
-        /// just initializes `BundleThread`
+        /// bundle thread may not be needed.
         pub const singleton = struct {
             var once = std.once(loadOnceImpl);
             var instance: ?*Self = null;
@@ -2385,6 +3199,7 @@ pub fn BundleThread(CompletionStruct: type) type {
 
             const this = try BundleV2.init(
                 bundler,
+                null, // TODO: Kit
                 allocator,
                 JSC.AnyEventLoop.init(allocator),
                 false,
@@ -2392,17 +3207,9 @@ pub fn BundleThread(CompletionStruct: type) type {
                 heap,
             );
 
-            // switch (CompletionStruct) {
-            //     bun.kit.DevServer.BundleTask => {
-            //         this.kit_watcher = completion.route.dev.bun_watcher;
-            //     },
-            //     else => {},
-            // }
-
             this.plugins = completion.plugins;
             this.completion = switch (CompletionStruct) {
-                BundleV2.JSBundleCompletionTask => .{ .js = completion },
-                bun.kit.DevServer.BundleTask => .{ .kit = completion },
+                BundleV2.JSBundleCompletionTask => completion,
                 else => @compileError("Unknown completion struct: " ++ CompletionStruct),
             };
             completion.bundler = this;
@@ -2417,7 +3224,7 @@ pub fn BundleThread(CompletionStruct: type) type {
             }
 
             errdefer {
-                // Wait for wait groups to finish. There still may be
+                // Wait for wait groups to finish. There still may be ongoing work.
                 this.linker.source_maps.line_offset_wait_group.wait();
                 this.linker.source_maps.quoted_contents_wait_group.wait();
 
@@ -2426,11 +3233,9 @@ pub fn BundleThread(CompletionStruct: type) type {
                 completion.log = out_log;
             }
 
-            completion.result = .{
-                .value = .{
-                    .output_files = try this.runFromJSInNewThread(bundler.options.entry_points),
-                },
-            };
+            completion.result = .{ .value = .{
+                .output_files = try this.runFromJSInNewThread(bundler.options.entry_points),
+            } };
 
             var out_log = Logger.Log.init(bun.default_allocator);
             this.bundler.log.appendToWithRecycled(&out_log, true) catch bun.outOfMemory();
@@ -2441,36 +3246,148 @@ pub fn BundleThread(CompletionStruct: type) type {
 }
 
 const UseDirective = js_ast.UseDirective;
+const ServerComponentBoundary = js_ast.ServerComponentBoundary;
+
+/// This task is run once all parse and resolve tasks have been complete
+/// and we have deferred onLoad plugins that we need to resume
+///
+/// It enqueues a task to be run on the JS thread which resolves the promise
+/// for every onLoad callback which called `.defer()`.
+pub const DeferredBatchTask = struct {
+    running: if (Environment.isDebug) bool else u0 = if (Environment.isDebug) false else 0,
+
+    const AnyTask = JSC.AnyTask.New(@This(), runOnJSThread);
+
+    pub fn init(this: *DeferredBatchTask) void {
+        if (comptime Environment.isDebug) bun.debugAssert(!this.running);
+        this.* = .{
+            .running = if (comptime Environment.isDebug) false else 0,
+        };
+    }
+
+    pub fn getCompletion(this: *DeferredBatchTask) ?*bun.BundleV2.JSBundleCompletionTask {
+        const bundler: *BundleV2 = @alignCast(@fieldParentPtr("drain_defer_task", this));
+        return bundler.completion;
+    }
+
+    pub fn schedule(this: *DeferredBatchTask) void {
+        if (comptime Environment.isDebug) {
+            bun.assert(!this.running);
+            this.running = false;
+        }
+        this.getCompletion().?.jsc_event_loop.enqueueTaskConcurrent(JSC.ConcurrentTask.create(JSC.Task.init(this)));
+    }
+
+    pub fn deinit(this: *DeferredBatchTask) void {
+        if (comptime Environment.isDebug) {
+            this.running = false;
+        }
+    }
+
+    pub fn runOnJSThread(this: *DeferredBatchTask) void {
+        defer this.deinit();
+        var completion: *bun.BundleV2.JSBundleCompletionTask = this.getCompletion() orelse {
+            return;
+        };
+
+        completion.bundler.plugins.?.drainDeferred(completion.result == .err);
+    }
+};
+
+const ContentsOrFd = union(Tag) {
+    fd: struct {
+        dir: StoredFileDescriptorType,
+        file: StoredFileDescriptorType,
+    },
+    contents: string,
+
+    const Tag = enum { fd, contents };
+};
 
 pub const ParseTask = struct {
     path: Fs.Path,
     secondary_path_for_commonjs_interop: ?Fs.Path = null,
-    contents_or_fd: union(enum) {
-        fd: struct {
-            dir: StoredFileDescriptorType,
-            file: StoredFileDescriptorType,
-        },
-        contents: string,
-    },
+    contents_or_fd: ContentsOrFd,
+    external: CacheEntry.External = .{},
     side_effects: _resolver.SideEffects,
     loader: ?Loader = null,
     jsx: options.JSX.Pragma,
     source_index: Index = Index.invalid,
     task: ThreadPoolLib.Task = .{ .callback = &callback },
     tree_shaking: bool = false,
-    known_target: ?options.Target = null,
+    known_target: options.Target,
     module_type: options.ModuleType = .unknown,
     emit_decorator_metadata: bool = false,
     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,
 
-    /// Used by generated client components
-    presolved_source_indices: []const Index.Int = &.{},
+    /// The information returned to the Bundler thread when a parse finishes.
+    pub const Result = struct {
+        task: EventLoop.Task,
+        ctx: *BundleV2,
+        value: Value,
+        watcher_data: WatcherData,
+        /// This is used for native onBeforeParsePlugins to store
+        /// a function pointer and context pointer to free the
+        /// returned source code by the plugin.
+        external: CacheEntry.External = .{},
+
+        pub const Value = union(enum) {
+            success: Success,
+            err: Error,
+            empty: struct {
+                source_index: Index,
+            },
+        };
+
+        const WatcherData = struct {
+            fd: bun.StoredFileDescriptorType,
+            dir_fd: bun.StoredFileDescriptorType,
+
+            /// When no files to watch, this encoding is used.
+            const none: WatcherData = .{
+                .fd = bun.invalid_fd,
+                .dir_fd = bun.invalid_fd,
+            };
+        };
+
+        pub const Success = struct {
+            ast: JSAst,
+            source: Logger.Source,
+            log: Logger.Log,
+            use_directive: UseDirective,
+            side_effects: _resolver.SideEffects,
+
+            /// Used by "file" loader files.
+            unique_key_for_additional_file: []const u8 = "",
+            /// Used by "file" loader files.
+            content_hash_for_additional_file: u64 = 0,
+        };
+
+        pub const Error = struct {
+            err: anyerror,
+            step: Step,
+            log: Logger.Log,
+            target: options.Target,
+            source_index: Index,
+
+            pub const Step = enum {
+                pending,
+                read_file,
+                parse,
+                resolve,
+            };
+        };
+    };
 
     const debug = Output.scoped(.ParseTask, false);
 
-    pub fn init(resolve_result: *const _resolver.Result, source_index: ?Index, ctx: *BundleV2) ParseTask {
+    pub fn init(resolve_result: *const _resolver.Result, source_index: Index, ctx: *BundleV2) ParseTask {
         return .{
             .ctx = ctx,
             .path = resolve_result.path_pair.primary,
@@ -2482,10 +3399,11 @@ pub const ParseTask = struct {
             },
             .side_effects = resolve_result.primary_side_effects_data,
             .jsx = resolve_result.jsx,
-            .source_index = source_index orelse Index.invalid,
+            .source_index = source_index,
             .module_type = resolve_result.module_type,
             .emit_decorator_metadata = resolve_result.emit_decorator_metadata,
             .package_version = if (resolve_result.package_json) |package_json| package_json.version else "",
+            .known_target = ctx.bundler.options.target,
         };
     }
 
@@ -2611,89 +3529,46 @@ pub const ParseTask = struct {
         const parse_task = ParseTask{
             .ctx = undefined,
             .path = Fs.Path.initWithNamespace("runtime", "bun:runtime"),
-            .side_effects = _resolver.SideEffects.no_side_effects__pure_data,
-            .jsx = options.JSX.Pragma{
+            .side_effects = .no_side_effects__pure_data,
+            .jsx = .{
                 .parse = false,
-                // .supports_react_refresh = false,
             },
             .contents_or_fd = .{
                 .contents = runtime_code,
             },
             .source_index = Index.runtime,
-            .loader = Loader.js,
+            .loader = .js,
+            .known_target = target,
         };
         const source = Logger.Source{
             .path = parse_task.path,
-            .key_path = parse_task.path,
             .contents = parse_task.contents_or_fd.contents,
             .index = Index.runtime,
         };
         return .{ .parse_task = parse_task, .source = source };
     }
+
     fn getRuntimeSource(target: options.Target) RuntimeSource {
         return switch (target) {
             inline else => |t| comptime getRuntimeSourceComptime(t),
         };
     }
 
-    pub const Result = struct {
-        task: EventLoop.Task,
-        ctx: *BundleV2,
-
-        value: union(Tag) {
-            success: Success,
-            err: Error,
-            empty: struct {
-                source_index: Index,
-
-                watcher_data: WatcherData = .{},
-            },
-        },
-
-        const WatcherData = struct {
-            fd: bun.StoredFileDescriptorType = .zero,
-            dir_fd: bun.StoredFileDescriptorType = .zero,
-            package_json: ?*PackageJSON = null,
-        };
-
-        pub const Success = struct {
-            ast: JSAst,
-            source: Logger.Source,
-            log: Logger.Log,
-
-            use_directive: UseDirective = .none,
-            watcher_data: WatcherData = .{},
-            side_effects: ?_resolver.SideEffects = null,
-
-            /// Used by "file" loader files.
-            unique_key_for_additional_file: []const u8 = "",
-
-            /// Used by "file" loader files.
-            content_hash_for_additional_file: u64 = 0,
-        };
-
-        pub const Error = struct {
-            err: anyerror,
-            step: Step,
-            log: Logger.Log,
-
-            pub const Step = enum {
-                pending,
-                read_file,
-                parse,
-                resolve,
-            };
-        };
-
-        pub const Tag = enum {
-            success,
-            err,
-            empty,
-        };
-    };
-
     threadlocal var override_file_path_buf: bun.PathBuffer = undefined;
 
+    fn getEmptyCSSAST(
+        log: *Logger.Log,
+        bundler: *Bundler,
+        opts: js_parser.Parser.Options,
+        allocator: std.mem.Allocator,
+        source: Logger.Source,
+    ) !JSAst {
+        const root = Expr.init(E.Object, E.Object{}, Logger.Loc{ .start = 0 });
+        var ast = JSAst.init((try js_parser.newLazyExportAST(allocator, bundler.options.define, opts, log, root, &source, "")).?);
+        ast.css = bun.create(allocator, bun.css.BundlerStyleSheet, bun.css.BundlerStyleSheet.empty(allocator));
+        return ast;
+    }
+
     fn getEmptyAST(log: *Logger.Log, bundler: *Bundler, opts: js_parser.Parser.Options, allocator: std.mem.Allocator, source: Logger.Source, comptime RootType: type) !JSAst {
         const root = Expr.init(RootType, RootType{}, Logger.Loc.Empty);
         return JSAst.init((try js_parser.newLazyExportAST(allocator, bundler.options.define, opts, log, root, &source, "")).?);
@@ -2736,20 +3611,22 @@ pub const ParseTask = struct {
             .json => {
                 const trace = tracer(@src(), "ParseJSON");
                 defer trace.end();
-                const root = (try resolver.caches.json.parsePackageJSON(log, source, allocator)) orelse Expr.init(E.Object, E.Object{}, Logger.Loc.Empty);
+                const root = (try resolver.caches.json.parsePackageJSON(log, source, allocator, false)) orelse Expr.init(E.Object, E.Object{}, Logger.Loc.Empty);
                 return JSAst.init((try js_parser.newLazyExportAST(allocator, bundler.options.define, opts, log, root, &source, "")).?);
             },
             .toml => {
                 const trace = tracer(@src(), "ParseTOML");
                 defer trace.end();
-                const root = try TOML.parse(&source, log, allocator);
+                const root = try TOML.parse(&source, log, allocator, false);
                 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 });
-                return JSAst.init((try js_parser.newLazyExportAST(allocator, bundler.options.define, opts, log, root, &source, "")).?);
+                var ast = JSAst.init((try js_parser.newLazyExportAST(allocator, bundler.options.define, opts, log, root, &source, "")).?);
+                ast.addUrlForCss(allocator, bundler.options.experimental_css, &source, "text/plain", null);
+                return ast;
             },
 
             .sqlite_embedded, .sqlite => {
@@ -2816,20 +3693,12 @@ pub const ParseTask = struct {
                 return JSAst.init((try js_parser.newLazyExportAST(allocator, bundler.options.define, opts, log, root, &source, "")).?);
             },
             .napi => {
-                if (bundler.options.target == .node) {
+                // (dap-eval-cb "source.contents.ptr")
+                if (bundler.options.target == .browser) {
                     log.addError(
                         null,
                         Logger.Loc.Empty,
-                        "TODO: implement .node loader for Node.js target",
-                    ) catch bun.outOfMemory();
-                    return error.ParserError;
-                }
-
-                if (bundler.options.target != .bun) {
-                    log.addError(
-                        null,
-                        Logger.Loc.Empty,
-                        "To load .node files, set target to \"bun\"",
+                        "Loading .node files won't work in the browser. Make sure to set target to \"bun\" or \"node\"",
                     ) catch bun.outOfMemory();
                     return error.ParserError;
                 }
@@ -2837,100 +3706,104 @@ pub const ParseTask = struct {
                 const unique_key = std.fmt.allocPrint(allocator, "{any}A{d:0>8}", .{ bun.fmt.hexIntLower(unique_key_prefix), source.index.get() }) catch unreachable;
                 // This injects the following code:
                 //
-                // import.meta.require(unique_key)
+                // require(unique_key)
                 //
                 const import_path = Expr.init(E.String, E.String{
                     .data = unique_key,
                 }, Logger.Loc{ .start = 0 });
 
-                // TODO: e_require_string
-                const import_meta = Expr.init(E.ImportMeta, E.ImportMeta{}, Logger.Loc{ .start = 0 });
-                const require_property = Expr.init(E.Dot, E.Dot{
-                    .target = import_meta,
-                    .name_loc = Logger.Loc.Empty,
-                    .name = "require",
-                }, Logger.Loc{ .start = 0 });
                 const require_args = allocator.alloc(Expr, 1) catch unreachable;
                 require_args[0] = import_path;
-                const require_call = Expr.init(E.Call, E.Call{
-                    .target = require_property,
+
+                const root = Expr.init(E.Call, E.Call{
+                    .target = .{ .data = .{ .e_require_call_target = {} }, .loc = .{ .start = 0 } },
                     .args = BabyList(Expr).init(require_args),
                 }, Logger.Loc{ .start = 0 });
 
-                const root = require_call;
                 unique_key_for_additional_file.* = unique_key;
                 return JSAst.init((try js_parser.newLazyExportAST(allocator, bundler.options.define, opts, log, root, &source, "")).?);
             },
-            // TODO: css
-            else => {
-                const unique_key = std.fmt.allocPrint(allocator, "{any}A{d:0>8}", .{ bun.fmt.hexIntLower(unique_key_prefix), source.index.get() }) catch unreachable;
-                const root = Expr.init(E.String, E.String{
-                    .data = unique_key,
-                }, Logger.Loc{ .start = 0 });
-                unique_key_for_additional_file.* = unique_key;
-                return JSAst.init((try js_parser.newLazyExportAST(allocator, bundler.options.define, opts, log, root, &source, "")).?);
+            .css => {
+                if (bundler.options.experimental_css) {
+                    // const unique_key = std.fmt.allocPrint(allocator, "{any}A{d:0>8}", .{ bun.fmt.hexIntLower(unique_key_prefix), source.index.get() }) catch unreachable;
+                    // unique_key_for_additional_file.* = unique_key;
+                    var import_records = BabyList(ImportRecord){};
+                    const source_code = source.contents;
+                    var css_ast = switch (bun.css.BundlerStyleSheet.parseBundler(
+                        allocator,
+                        source_code,
+                        bun.css.ParserOptions.default(allocator, bundler.log),
+                        &import_records,
+                    )) {
+                        .result => |v| v,
+                        .err => |e| {
+                            try e.addToLogger(log, &source);
+                            return error.SyntaxError;
+                        },
+                    };
+                    if (css_ast.minify(allocator, bun.css.MinifyOptions{
+                        .targets = .{},
+                        .unused_symbols = .{},
+                    }).asErr()) |e| {
+                        try e.addToLogger(log, &source);
+                        return error.MinifyError;
+                    }
+                    const root = Expr.init(E.Object, E.Object{}, Logger.Loc{ .start = 0 });
+                    const css_ast_heap = bun.create(allocator, bun.css.BundlerStyleSheet, css_ast);
+                    var ast = JSAst.init((try js_parser.newLazyExportAST(allocator, bundler.options.define, opts, log, root, &source, "")).?);
+                    ast.css = css_ast_heap;
+                    ast.import_records = import_records;
+                    return ast;
+                }
             },
+            else => {},
         }
+        const unique_key = std.fmt.allocPrint(allocator, "{any}A{d:0>8}", .{ bun.fmt.hexIntLower(unique_key_prefix), source.index.get() }) catch unreachable;
+        const root = Expr.init(E.String, E.String{
+            .data = unique_key,
+        }, Logger.Loc{ .start = 0 });
+        unique_key_for_additional_file.* = unique_key;
+        var ast = JSAst.init((try js_parser.newLazyExportAST(allocator, bundler.options.define, opts, log, root, &source, "")).?);
+        ast.url_for_css = unique_key;
+        ast.addUrlForCss(allocator, bundler.options.experimental_css, &source, null, unique_key);
+        return ast;
     }
 
-    fn run_(
+    fn getCodeForParseTaskWithoutPlugins(
         task: *ParseTask,
-        this: *ThreadPool.Worker,
-        step: *ParseTask.Result.Error.Step,
         log: *Logger.Log,
-    ) anyerror!?Result.Success {
-        const allocator = this.allocator;
-
-        var data = this.data;
-        var bundler = &data.bundler;
-        errdefer bundler.resetStore();
-        var resolver: *Resolver = &bundler.resolver;
-        var file_path = task.path;
-        step.* = .read_file;
-        const loader = task.loader orelse file_path.loader(&bundler.options.loaders) orelse options.Loader.file;
-
-        var entry: CacheEntry = switch (task.contents_or_fd) {
-            .fd => brk: {
+        bundler: *Bundler,
+        resolver: *Resolver,
+        allocator: std.mem.Allocator,
+        file_path: *Fs.Path,
+        loader: Loader,
+        experimental_css: bool,
+    ) !CacheEntry {
+        return switch (task.contents_or_fd) {
+            .fd => |contents| brk: {
                 const trace = tracer(@src(), "readFile");
                 defer trace.end();
-                if (bundler.options.framework) |framework| {
-                    if (framework.override_modules_hashes.len > 0) {
-                        const package_relative_path_hash = bun.hash(file_path.pretty);
-                        if (std.mem.indexOfScalar(
-                            u64,
-                            framework.override_modules_hashes,
-                            package_relative_path_hash,
-                        )) |index| {
-                            const relative_path = [_]string{
-                                framework.resolved_dir,
-                                framework.override_modules.values[index],
-                            };
-                            const override_path = bundler.fs.absBuf(
-                                &relative_path,
-                                &override_file_path_buf,
-                            );
-                            override_file_path_buf[override_path.len] = 0;
-                            const override_pathZ = override_file_path_buf[0..override_path.len :0];
-                            debug("{s} -> {s}", .{ file_path.text, override_path });
-                            break :brk try resolver.caches.fs.readFileWithAllocator(
-                                allocator,
-                                bundler.fs,
-                                override_pathZ,
-                                .zero,
-                                false,
-                                null,
-                            );
+
+                if (strings.eqlComptime(file_path.namespace, "node")) lookup_builtin: {
+                    if (task.ctx.framework) |f| {
+                        if (f.built_in_modules.get(file_path.text)) |file| {
+                            switch (file) {
+                                .code => |code| break :brk .{ .contents = code },
+                                .import => |path| {
+                                    file_path.* = Fs.Path.init(path);
+                                    break :lookup_builtin;
+                                },
+                            }
                         }
                     }
-                }
 
-                if (strings.eqlComptime(file_path.namespace, "node"))
-                    break :brk CacheEntry{
+                    break :brk .{
                         .contents = NodeFallbackModules.contentsFromPath(file_path.text) orelse "",
                     };
+                }
 
                 break :brk resolver.caches.fs.readFileWithAllocator(
-                    if (loader.shouldCopyForBundling())
+                    if (loader.shouldCopyForBundling(experimental_css))
                         // The OutputFile will own the memory for the contents
                         bun.default_allocator
                     else
@@ -2939,8 +3812,8 @@ pub const ParseTask = struct {
                     file_path.text,
                     task.contents_or_fd.fd.dir,
                     false,
-                    if (task.contents_or_fd.fd.file != .zero)
-                        task.contents_or_fd.fd.file
+                    if (contents.file != bun.invalid_fd and contents.file != .zero)
+                        contents.file
                     else
                         null,
                 ) catch |err| {
@@ -2954,6 +3827,7 @@ pub const ParseTask = struct {
                                 "File not found {}",
                                 .{bun.fmt.quote(file_path.text)},
                             ) catch {};
+                            return error.FileNotFound;
                         },
                         else => {
                             log.addErrorFmt(
@@ -2968,47 +3842,426 @@ pub const ParseTask = struct {
                     return err;
                 };
             },
-            .contents => |contents| CacheEntry{
+            .contents => |contents| .{
                 .contents = contents,
-                .fd = .zero,
+                .fd = bun.invalid_fd,
             },
         };
+    }
 
-        errdefer if (task.contents_or_fd == .fd) entry.deinit(allocator);
+    fn getCodeForParseTask(
+        task: *ParseTask,
+        log: *Logger.Log,
+        bundler: *Bundler,
+        resolver: *Resolver,
+        allocator: std.mem.Allocator,
+        file_path: *Fs.Path,
+        loader: *Loader,
+        experimental_css: bool,
+        from_plugin: *bool,
+    ) !CacheEntry {
+        const might_have_on_parse_plugins = brk: {
+            if (task.source_index.isRuntime()) break :brk false;
+            const plugin = task.ctx.plugins orelse break :brk false;
+            if (!plugin.hasOnBeforeParsePlugins()) break :brk false;
 
-        const will_close_file_descriptor = task.contents_or_fd == .fd and
-            !entry.fd.isStdio() and
-            (this.ctx.bun_watcher == null
-        // and this.ctx.kit_watcher == null
-        );
-        if (will_close_file_descriptor) {
-            _ = entry.closeFD();
+            if (strings.eqlComptime(file_path.namespace, "node")) {
+                break :brk false;
+            }
+            break :brk true;
+        };
+
+        if (!might_have_on_parse_plugins) {
+            return getCodeForParseTaskWithoutPlugins(task, log, bundler, resolver, allocator, file_path, loader.*, experimental_css);
         }
 
-        if (!will_close_file_descriptor and !entry.fd.isStdio()) task.contents_or_fd = .{
-            .fd = .{
+        var should_continue_running: i32 = 1;
+
+        var ctx = OnBeforeParsePlugin{
+            .task = task,
+            .log = log,
+            .bundler = bundler,
+            .resolver = resolver,
+            .allocator = allocator,
+            .file_path = file_path,
+            .loader = loader,
+            .experimental_css = experimental_css,
+            .deferred_error = null,
+            .should_continue_running = &should_continue_running,
+        };
+
+        return try ctx.run(task.ctx.plugins.?, from_plugin);
+    }
+
+    const OnBeforeParsePlugin = struct {
+        task: *ParseTask,
+        log: *Logger.Log,
+        bundler: *Bundler,
+        resolver: *Resolver,
+        allocator: std.mem.Allocator,
+        file_path: *Fs.Path,
+        loader: *Loader,
+        experimental_css: bool,
+        deferred_error: ?anyerror = null,
+        should_continue_running: *i32,
+
+        result: ?*OnBeforeParseResult = null,
+
+        const headers = @import("bun-native-bundler-plugin-api");
+
+        comptime {
+            bun.assert(@sizeOf(OnBeforeParseArguments) == @sizeOf(headers.OnBeforeParseArguments));
+            bun.assert(@alignOf(OnBeforeParseArguments) == @alignOf(headers.OnBeforeParseArguments));
+
+            bun.assert(@sizeOf(BunLogOptions) == @sizeOf(headers.BunLogOptions));
+            bun.assert(@alignOf(BunLogOptions) == @alignOf(headers.BunLogOptions));
+
+            bun.assert(@sizeOf(OnBeforeParseResult) == @sizeOf(headers.OnBeforeParseResult));
+            bun.assert(@alignOf(OnBeforeParseResult) == @alignOf(headers.OnBeforeParseResult));
+
+            bun.assert(@sizeOf(BunLogOptions) == @sizeOf(headers.BunLogOptions));
+            bun.assert(@alignOf(BunLogOptions) == @alignOf(headers.BunLogOptions));
+        }
+
+        const OnBeforeParseArguments = extern struct {
+            struct_size: usize = @sizeOf(OnBeforeParseArguments),
+            context: *OnBeforeParsePlugin,
+            path_ptr: [*]const u8 = "",
+            path_len: usize = 0,
+            namespace_ptr: [*]const u8 = "file",
+            namespace_len: usize = "file".len,
+            default_loader: Loader = .file,
+            external: ?*void = null,
+        };
+
+        const BunLogOptions = extern struct {
+            struct_size: usize = @sizeOf(BunLogOptions),
+            message_ptr: ?[*]const u8 = null,
+            message_len: usize = 0,
+            path_ptr: ?[*]const u8 = null,
+            path_len: usize = 0,
+            source_line_text_ptr: ?[*]const u8 = null,
+            source_line_text_len: usize = 0,
+            level: Logger.Log.Level = .err,
+            line: i32 = 0,
+            column: i32 = 0,
+            line_end: i32 = 0,
+            column_end: i32 = 0,
+
+            pub fn sourceLineText(this: *const BunLogOptions) string {
+                if (this.source_line_text_ptr) |ptr| {
+                    if (this.source_line_text_len > 0) {
+                        return ptr[0..this.source_line_text_len];
+                    }
+                }
+                return "";
+            }
+
+            pub fn path(this: *const BunLogOptions) string {
+                if (this.path_ptr) |ptr| {
+                    if (this.path_len > 0) {
+                        return ptr[0..this.path_len];
+                    }
+                }
+                return "";
+            }
+
+            pub fn message(this: *const BunLogOptions) string {
+                if (this.message_ptr) |ptr| {
+                    if (this.message_len > 0) {
+                        return ptr[0..this.message_len];
+                    }
+                }
+                return "";
+            }
+
+            pub fn append(this: *const BunLogOptions, log: *Logger.Log, namespace: string) void {
+                const allocator = log.msgs.allocator;
+                const source_line_text = this.sourceLineText();
+                const location = Logger.Location.init(
+                    this.path(),
+                    namespace,
+                    @max(this.line, -1),
+                    @max(this.column, -1),
+                    @max(this.column_end - this.column, 0),
+                    if (source_line_text.len > 0) allocator.dupe(u8, source_line_text) catch bun.outOfMemory() else null,
+                    null,
+                );
+                var msg = Logger.Msg{ .data = .{ .location = location, .text = allocator.dupe(u8, this.message()) catch bun.outOfMemory() } };
+                switch (this.level) {
+                    .err => msg.kind = .err,
+                    .warn => msg.kind = .warn,
+                    .verbose => msg.kind = .verbose,
+                    .debug => msg.kind = .debug,
+                    else => {},
+                }
+                if (msg.kind == .err) {
+                    log.errors += 1;
+                } else if (msg.kind == .warn) {
+                    log.warnings += 1;
+                }
+                log.addMsg(msg) catch bun.outOfMemory();
+            }
+
+            pub fn logFn(
+                args_: ?*OnBeforeParseArguments,
+                log_options_: ?*BunLogOptions,
+            ) callconv(.C) void {
+                const args = args_ orelse return;
+                const log_options = log_options_ orelse return;
+                log_options.append(args.context.log, args.context.file_path.namespace);
+            }
+        };
+
+        const OnBeforeParseResultWrapper = struct {
+            original_source: ?[]const u8 = null,
+            loader: Loader,
+            impl: OnBeforeParseResult,
+        };
+
+        const OnBeforeParseResult = extern struct {
+            struct_size: usize = @sizeOf(OnBeforeParseResult),
+            source_ptr: ?[*]const u8 = null,
+            source_len: usize = 0,
+            loader: Loader,
+
+            fetch_source_code_fn: *const fn (*const OnBeforeParseArguments, *OnBeforeParseResult) callconv(.C) i32 = &fetchSourceCode,
+
+            user_context: ?*anyopaque = null,
+            free_user_context: ?*const fn (?*anyopaque) callconv(.C) void = null,
+
+            log: *const fn (
+                args_: ?*OnBeforeParseArguments,
+                log_options_: ?*BunLogOptions,
+            ) callconv(.C) void = &BunLogOptions.logFn,
+        };
+
+        pub fn fetchSourceCode(args: *const OnBeforeParseArguments, result: *OnBeforeParseResult) callconv(.C) i32 {
+            debug("fetchSourceCode", .{});
+            const this = args.context;
+            if (this.log.errors > 0 or this.deferred_error != null or this.should_continue_running.* != 1) {
+                return 1;
+            }
+
+            if (result.source_ptr != null) {
+                return 0;
+            }
+
+            const entry = getCodeForParseTaskWithoutPlugins(
+                this.task,
+                this.log,
+                this.bundler,
+                this.resolver,
+                this.allocator,
+                this.file_path,
+
+                result.loader,
+
+                this.experimental_css,
+            ) catch |err| {
+                this.deferred_error = err;
+                this.should_continue_running.* = 0;
+                return 1;
+            };
+            result.source_ptr = entry.contents.ptr;
+            result.source_len = entry.contents.len;
+            result.free_user_context = null;
+            result.user_context = null;
+            return 0;
+        }
+
+        pub export fn OnBeforeParsePlugin__isDone(this: *OnBeforeParsePlugin) i32 {
+            if (this.should_continue_running.* != 1) {
+                return 1;
+            }
+
+            const result = this.result orelse return 1;
+            if (result.source_ptr != null) {
+                return 1;
+            }
+
+            return 0;
+        }
+
+        pub fn run(this: *OnBeforeParsePlugin, plugin: *JSC.API.JSBundler.Plugin, from_plugin: *bool) !CacheEntry {
+            var args = OnBeforeParseArguments{
+                .context = this,
+                .path_ptr = this.file_path.text.ptr,
+                .path_len = this.file_path.text.len,
+                .default_loader = this.loader.*,
+            };
+            if (this.file_path.namespace.len > 0) {
+                args.namespace_ptr = this.file_path.namespace.ptr;
+                args.namespace_len = this.file_path.namespace.len;
+            }
+            var result = OnBeforeParseResult{
+                .loader = this.loader.*,
+            };
+            this.result = &result;
+            const count = plugin.callOnBeforeParsePlugins(
+                this,
+                if (bun.strings.eqlComptime(this.file_path.namespace, "file"))
+                    &bun.String.empty
+                else
+                    &bun.String.init(this.file_path.namespace),
+
+                &bun.String.init(this.file_path.text),
+                &args,
+                &result,
+                this.should_continue_running,
+            );
+            if (comptime Environment.enable_logs)
+                debug("callOnBeforeParsePlugins({s}:{s}) = {d}", .{ this.file_path.namespace, this.file_path.text, count });
+            if (count > 0) {
+                if (this.deferred_error) |err| {
+                    if (result.free_user_context) |free_user_context| {
+                        free_user_context(result.user_context);
+                    }
+
+                    return err;
+                }
+
+                // If the plugin sets the `free_user_context` function pointer, it _must_ set the `user_context` pointer.
+                // Otherwise this is just invalid behavior.
+                if (result.user_context == null and result.free_user_context != null) {
+                    var msg = Logger.Msg{ .data = .{ .location = null, .text = bun.default_allocator.dupe(
+                        u8,
+                        "Native plugin set the `free_plugin_source_code_context` field without setting the `plugin_source_code_context` field.",
+                    ) catch bun.outOfMemory() } };
+                    msg.kind = .err;
+                    args.context.log.errors += 1;
+                    args.context.log.addMsg(msg) catch bun.outOfMemory();
+                    return error.InvalidNativePlugin;
+                }
+
+                if (this.log.errors > 0) {
+                    if (result.free_user_context) |free_user_context| {
+                        free_user_context(result.user_context);
+                    }
+
+                    return error.SyntaxError;
+                }
+
+                if (result.source_ptr) |ptr| {
+                    if (result.free_user_context != null) {
+                        this.task.external = CacheEntry.External{
+                            .ctx = result.user_context,
+                            .function = result.free_user_context,
+                        };
+                    }
+                    from_plugin.* = true;
+                    this.loader.* = result.loader;
+                    return CacheEntry{
+                        .contents = ptr[0..result.source_len],
+                        .external = .{
+                            .ctx = result.user_context,
+                            .function = result.free_user_context,
+                        },
+                    };
+                }
+            }
+
+            return try getCodeForParseTaskWithoutPlugins(this.task, this.log, this.bundler, this.resolver, this.allocator, this.file_path, this.loader.*, this.experimental_css);
+        }
+    };
+
+    fn run(
+        task: *ParseTask,
+        this: *ThreadPool.Worker,
+        step: *ParseTask.Result.Error.Step,
+        log: *Logger.Log,
+    ) anyerror!Result.Success {
+        const allocator = this.allocator;
+
+        var data = this.data;
+        var bundler = &data.bundler;
+        errdefer bundler.resetStore();
+        var resolver: *Resolver = &bundler.resolver;
+        var file_path = task.path;
+        step.* = .read_file;
+        var loader = task.loader orelse file_path.loader(&bundler.options.loaders) orelse options.Loader.file;
+
+        var contents_came_from_plugin: bool = false;
+        var entry = try getCodeForParseTask(task, log, bundler, resolver, allocator, &file_path, &loader, this.ctx.bundler.options.experimental_css, &contents_came_from_plugin);
+
+        // WARNING: Do not change the variant of `task.contents_or_fd` from
+        // `.fd` to `.contents` (or back) after this point!
+        //
+        // When `task.contents_or_fd == .fd`, `entry.contents` is an owned string.
+        // When `task.contents_or_fd == .contents`, `entry.contents` is NOT owned! Freeing it here will cause a double free!
+        //
+        // Changing from `.contents` to `.fd` will cause a double free.
+        // This was the case in the situation where the ParseTask receives its `.contents` from an onLoad plugin, which caused it to be
+        // allocated by `bun.default_allocator` and then freed in `BundleV2.deinit` (and also by `entry.deinit(allocator)` below).
+        const debug_original_variant_check: if (bun.Environment.isDebug) ContentsOrFd.Tag else u0 =
+            if (bun.Environment.isDebug)
+            @as(ContentsOrFd.Tag, task.contents_or_fd)
+        else
+            0;
+        errdefer {
+            if (comptime bun.Environment.isDebug) {
+                if (@as(ContentsOrFd.Tag, task.contents_or_fd) != debug_original_variant_check) {
+                    std.debug.panic("BUG: `task.contents_or_fd` changed in a way that will cause a double free or memory to leak!\n\n    Original = {s}\n    New = {s}\n", .{
+                        @tagName(debug_original_variant_check),
+                        @tagName(task.contents_or_fd),
+                    });
+                }
+            }
+            if (task.contents_or_fd == .fd) entry.deinit(allocator);
+        }
+
+        const will_close_file_descriptor = task.contents_or_fd == .fd and
+            entry.fd.isValid() and !entry.fd.isStdio() and
+            this.ctx.bun_watcher == null;
+        if (will_close_file_descriptor) {
+            _ = entry.closeFD();
+            task.contents_or_fd = .{ .fd = .{ .file = bun.invalid_fd, .dir = bun.invalid_fd } };
+        } else if (task.contents_or_fd == .fd) {
+            task.contents_or_fd = .{ .fd = .{
                 .file = entry.fd,
                 .dir = bun.invalid_fd,
-            },
-        };
+            } };
+        }
         step.* = .parse;
 
-        const is_empty = entry.contents.len == 0 or (entry.contents.len < 33 and strings.trim(entry.contents, " \n\r").len == 0);
+        const is_empty = strings.isAllWhitespace(entry.contents);
 
-        const use_directive = if (!is_empty and bundler.options.react_server_components)
-            UseDirective.parse(entry.contents)
+        const use_directive: UseDirective = if (!is_empty and bundler.options.server_components)
+            if (UseDirective.parse(entry.contents)) |use|
+                use
+            else
+                .none
         else
             .none;
 
+        if (
+        // separate_ssr_graph makes boundaries switch to client because the server file uses that generated file as input.
+        // this is not done when there is one server graph because it is easier for plugins to deal with.
+        (use_directive == .client and
+            task.known_target != .bake_server_components_ssr and
+            this.ctx.framework.?.server_components.?.separate_ssr_graph) or
+            // set the target to the client when bundling client-side files
+            (bundler.options.server_components and task.known_target == .browser))
+        {
+            bundler = this.ctx.client_bundler;
+            resolver = &bundler.resolver;
+            bun.assert(bundler.options.target == .browser);
+        }
+
         var source = Logger.Source{
             .path = file_path,
-            .key_path = file_path,
             .index = task.source_index,
             .contents = entry.contents,
             .contents_is_recycled = false,
         };
 
-        const target = targetFromHashbang(entry.contents) orelse use_directive.target(task.known_target orelse bundler.options.target);
+        const target = (if (task.source_index.get() == 1) targetFromHashbang(entry.contents) else null) orelse
+            if (task.known_target == .bake_server_components_ssr and bundler.options.framework.?.server_components.?.separate_ssr_graph)
+            .bake_server_components_ssr
+        else
+            bundler.options.target;
+
+        const output_format = bundler.options.output_format;
 
         var opts = js_parser.Parser.Options.init(task.jsx, loader);
         opts.bundle = true;
@@ -3016,19 +4269,38 @@ pub const ParseTask = struct {
         opts.macro_context = &this.data.macro_context;
         opts.package_version = task.package_version;
 
+        opts.features.auto_polyfill_require = output_format == .esm and !target.isBun();
         opts.features.allow_runtime = !source.index.isRuntime();
+        opts.features.unwrap_commonjs_to_esm = output_format == .esm and FeatureFlags.unwrap_commonjs_to_esm;
         opts.features.use_import_meta_require = target.isBun();
-        opts.features.top_level_await = true;
+        opts.features.top_level_await = output_format == .esm or output_format == .internal_bake_dev;
         opts.features.auto_import_jsx = task.jsx.parse and bundler.options.auto_import_jsx;
         opts.features.trim_unused_imports = loader.isTypeScript() or (bundler.options.trim_unused_imports orelse false);
         opts.features.inlining = bundler.options.minify_syntax;
+        opts.output_format = output_format;
         opts.features.minify_syntax = bundler.options.minify_syntax;
         opts.features.minify_identifiers = bundler.options.minify_identifiers;
         opts.features.emit_decorator_metadata = bundler.options.emit_decorator_metadata;
         opts.features.unwrap_commonjs_packages = bundler.options.unwrap_commonjs_packages;
-        opts.features.hot_module_reloading = bundler.options.output_format == .internal_kit_dev and !source.index.isRuntime();
-        opts.features.react_fast_refresh = (bundler.options.hot_module_reloading or bundler.options.react_fast_refresh) and
-            loader.isJSX() and !source.path.isNodeModule();
+        opts.features.hot_module_reloading = output_format == .internal_bake_dev and !source.index.isRuntime();
+        opts.features.react_fast_refresh = target == .browser and
+            bundler.options.react_fast_refresh and
+            loader.isJSX() and
+            !source.path.isNodeModule();
+
+        opts.features.server_components = if (bundler.options.server_components) switch (target) {
+            .browser => .client_side,
+            else => switch (use_directive) {
+                .none => .wrap_anon_server_functions,
+                .client => if (bundler.options.framework.?.server_components.?.separate_ssr_graph)
+                    .client_side
+                else
+                    .wrap_exports_for_client_reference,
+                .server => .wrap_exports_for_server_reference,
+            },
+        } else .none;
+
+        opts.framework = bundler.options.framework;
 
         opts.ignore_dce_annotations = bundler.options.ignore_dce_annotations and !source.index.isRuntime();
 
@@ -3047,11 +4319,16 @@ pub const ParseTask = struct {
         task.jsx.parse = loader.isJSX();
 
         var unique_key_for_additional_file: []const u8 = "";
-
         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| try getEmptyAST(
+            inline else => |as_undefined| if (loader == .css and this.ctx.bundler.options.experimental_css) try getEmptyCSSAST(
+                log,
+                bundler,
+                opts,
+                allocator,
+                source,
+            ) else try getEmptyAST(
                 log,
                 bundler,
                 opts,
@@ -3062,102 +4339,79 @@ pub const ParseTask = struct {
         };
 
         ast.target = target;
-        if (ast.parts.len <= 1) {
+        if (ast.parts.len <= 1 and ast.css == null) {
             task.side_effects = .no_side_effects__empty_ast;
         }
 
-        if (task.presolved_source_indices.len > 0) {
-            for (ast.import_records.slice(), task.presolved_source_indices) |*record, source_index| {
-                if (record.is_unused or record.is_internal)
-                    continue;
-
-                record.source_index = Index.source(source_index);
-            }
-        }
-
-        // never a react client component if RSC is not enabled.
-        bun.assert(use_directive == .none or bundler.options.react_server_components);
-
         step.* = .resolve;
-        ast.target = target;
 
-        return Result.Success{
+        return .{
             .ast = ast,
             .source = source,
             .log = log.*,
             .use_directive = use_directive,
             .unique_key_for_additional_file = unique_key_for_additional_file,
+            .side_effects = task.side_effects,
 
             // Hash the files in here so that we do it in parallel.
-            .content_hash_for_additional_file = if (loader.shouldCopyForBundling())
+            .content_hash_for_additional_file = if (loader.shouldCopyForBundling(this.ctx.bundler.options.experimental_css))
                 ContentHasher.run(source.contents)
             else
                 0,
-
-            .watcher_data = .{
-                .fd = if (task.contents_or_fd == .fd and !will_close_file_descriptor) task.contents_or_fd.fd.file else .zero,
-                .dir_fd = if (task.contents_or_fd == .fd) task.contents_or_fd.fd.dir else .zero,
-            },
         };
     }
 
-    pub fn callback(this: *ThreadPoolLib.Task) void {
-        run(@fieldParentPtr("task", this));
-    }
-
-    fn run(this: *ParseTask) void {
+    pub fn callback(task: *ThreadPoolLib.Task) void {
+        const this: *ParseTask = @fieldParentPtr("task", task);
         var worker = ThreadPool.Worker.get(this.ctx);
         defer worker.unget();
+        debug("ParseTask(0x{x}, {s}) callback", .{ @intFromPtr(this), this.path.text });
+
         var step: ParseTask.Result.Error.Step = .pending;
         var log = Logger.Log.init(worker.allocator);
         bun.assert(this.source_index.isValid()); // forgot to set source_index
 
-        const result = bun.default_allocator.create(Result) catch unreachable;
+        const result = bun.default_allocator.create(Result) catch bun.outOfMemory();
+        const value: ParseTask.Result.Value = if (run(this, worker, &step, &log)) |ast| value: {
+            // When using HMR, always flag asts with errors as parse failures.
+            // Not done outside of the dev server out of fear of breaking existing code.
+            if (this.ctx.bundler.options.dev_server != null and ast.log.hasErrors()) {
+                break :value .{
+                    .err = .{
+                        .err = error.SyntaxError,
+                        .step = .parse,
+                        .log = ast.log,
+                        .source_index = this.source_index,
+                        .target = this.known_target,
+                    },
+                };
+            }
+
+            break :value .{ .success = ast };
+        } else |err| value: {
+            if (err == error.EmptyAST) {
+                log.deinit();
+                break :value .{ .empty = .{
+                    .source_index = this.source_index,
+                } };
+            }
+
+            break :value .{ .err = .{
+                .err = err,
+                .step = step,
+                .log = log,
+                .source_index = this.source_index,
+                .target = this.known_target,
+            } };
+        };
         result.* = .{
             .ctx = this.ctx,
             .task = undefined,
-            .value = brk: {
-                if (run_(
-                    this,
-                    worker,
-                    &step,
-                    &log,
-                )) |ast_or_null| {
-                    if (ast_or_null) |ast| {
-                        break :brk .{ .success = ast };
-                    } else {
-                        log.deinit();
-                        break :brk .{
-                            .empty = .{
-                                .source_index = this.source_index,
-                                .watcher_data = .{
-                                    .fd = if (this.contents_or_fd == .fd) this.contents_or_fd.fd.file else .zero,
-                                    .dir_fd = if (this.contents_or_fd == .fd) this.contents_or_fd.fd.dir else .zero,
-                                },
-                            },
-                        };
-                    }
-                } else |err| {
-                    if (err == error.EmptyAST) {
-                        log.deinit();
-                        break :brk .{
-                            .empty = .{
-                                .source_index = this.source_index,
-                                .watcher_data = .{
-                                    .fd = if (this.contents_or_fd == .fd) this.contents_or_fd.fd.file else .zero,
-                                    .dir_fd = if (this.contents_or_fd == .fd) this.contents_or_fd.fd.dir else .zero,
-                                },
-                            },
-                        };
-                    }
-                    break :brk .{
-                        .err = .{
-                            .err = err,
-                            .step = step,
-                            .log = log,
-                        },
-                    };
-                }
+            .value = value,
+            .external = this.external,
+            .watcher_data = .{
+                .fd = if (this.contents_or_fd == .fd) this.contents_or_fd.fd.file else bun.invalid_fd,
+                .dir_fd = if (this.contents_or_fd == .fd) this.contents_or_fd.fd.dir else bun.invalid_fd,
             },
         };
 
@@ -3182,6 +4436,209 @@ pub const ParseTask = struct {
     }
 };
 
+/// Files for Server Components are generated using `AstBuilder`, instead of
+/// running through the js_parser. It emits a ParseTask.Result and joins
+/// with the same logic that it runs though.
+pub const ServerComponentParseTask = struct {
+    task: ThreadPoolLib.Task = .{ .callback = &taskCallbackWrap },
+    data: Data,
+    ctx: *BundleV2,
+    source: Logger.Source,
+
+    pub const Data = union(enum) {
+        /// Generate server-side code for a "use client" module. Given the
+        /// client ast, a "reference proxy" is created with identical exports.
+        client_reference_proxy: ReferenceProxy,
+
+        client_entry_wrapper: ClientEntryWrapper,
+
+        pub const ReferenceProxy = struct {
+            other_source: Logger.Source,
+            named_exports: JSAst.NamedExports,
+        };
+
+        pub const ClientEntryWrapper = struct {
+            path: []const u8,
+        };
+    };
+
+    fn taskCallbackWrap(thread_pool_task: *ThreadPoolLib.Task) void {
+        const task: *ServerComponentParseTask = @fieldParentPtr("task", thread_pool_task);
+        var worker = ThreadPool.Worker.get(task.ctx);
+        defer worker.unget();
+        var log = Logger.Log.init(worker.allocator);
+
+        const result = bun.default_allocator.create(ParseTask.Result) catch bun.outOfMemory();
+        result.* = .{
+            .ctx = task.ctx,
+            .task = undefined,
+
+            .value = if (taskCallback(
+                task,
+                &log,
+                worker.allocator,
+            )) |success|
+                .{ .success = success }
+            else |err| switch (err) {
+                error.OutOfMemory => bun.outOfMemory(),
+            },
+
+            .watcher_data = ParseTask.Result.WatcherData.none,
+        };
+
+        switch (worker.ctx.loop().*) {
+            .js => |jsc_event_loop| {
+                jsc_event_loop.enqueueTaskConcurrent(JSC.ConcurrentTask.fromCallback(result, ParseTask.onComplete));
+            },
+            .mini => |*mini| {
+                mini.enqueueTaskConcurrentWithExtraCtx(
+                    ParseTask.Result,
+                    BundleV2,
+                    result,
+                    BundleV2.onParseTaskComplete,
+                    .task,
+                );
+            },
+        }
+    }
+
+    fn taskCallback(
+        task: *ServerComponentParseTask,
+        log: *Logger.Log,
+        allocator: std.mem.Allocator,
+    ) bun.OOM!ParseTask.Result.Success {
+        var ab = try AstBuilder.init(allocator, &task.source, task.ctx.bundler.options.hot_module_reloading);
+
+        switch (task.data) {
+            .client_reference_proxy => |data| try task.generateClientReferenceProxy(data, &ab),
+            .client_entry_wrapper => |data| try task.generateClientEntryWrapper(data, &ab),
+        }
+
+        return .{
+            .ast = try ab.toBundledAst(switch (task.data) {
+                // Server-side
+                .client_reference_proxy => task.ctx.bundler.options.target,
+                // Client-side,
+                .client_entry_wrapper => .browser,
+            }),
+            .source = task.source,
+            .log = log.*,
+            .use_directive = .none,
+            .side_effects = .no_side_effects__pure_data,
+        };
+    }
+
+    fn generateClientEntryWrapper(_: *ServerComponentParseTask, data: Data.ClientEntryWrapper, b: *AstBuilder) !void {
+        const record = try b.addImportRecord(data.path, .stmt);
+        const namespace_ref = try b.newSymbol(.other, "main");
+        try b.appendStmt(S.Import{
+            .namespace_ref = namespace_ref,
+            .import_record_index = record,
+            .items = &.{},
+            .is_single_line = true,
+        });
+        b.import_records.items[record].was_originally_bare_import = true;
+    }
+
+    fn generateClientReferenceProxy(task: *ServerComponentParseTask, data: Data.ReferenceProxy, b: *AstBuilder) !void {
+        const server_components = task.ctx.framework.?.server_components orelse
+            unreachable; // config must be non-null to enter this function
+
+        const client_named_exports = data.named_exports;
+
+        const register_client_reference = (try b.addImportStmt(
+            server_components.server_runtime_import,
+            &.{server_components.server_register_client_reference},
+        ))[0];
+
+        const module_path = b.newExpr(E.String{
+            // In development, the path loaded is the source file: Easy!
+            //
+            // In production, the path here must be the final chunk path, but
+            // that information is not yet available since chunks are not
+            // computed. The unique_key replacement system is used here.
+            .data = if (task.ctx.bundler.options.dev_server != null)
+                data.other_source.path.pretty
+            else
+                try std.fmt.allocPrint(b.allocator, "{}S{d:0>8}", .{
+                    bun.fmt.hexIntLower(task.ctx.unique_key),
+                    data.other_source.index.get(),
+                }),
+        });
+
+        for (client_named_exports.keys()) |key| {
+            const is_default = bun.strings.eqlComptime(key, "default");
+
+            // This error message is taken from
+            // https://github.com/facebook/react/blob/c5b9375767e2c4102d7e5559d383523736f1c902/packages/react-server-dom-webpack/src/ReactFlightWebpackNodeLoader.js#L323-L354
+            const err_msg_string = try if (is_default)
+                std.fmt.allocPrint(
+                    b.allocator,
+                    "Attempted to call the default export of {[module_path]s} from " ++
+                        "the server, but it's on the client. It's not possible to invoke a " ++
+                        "client function from the server, it can only be rendered as a " ++
+                        "Component or passed to props of a Client Component.",
+                    .{ .module_path = data.other_source.path.pretty },
+                )
+            else
+                std.fmt.allocPrint(
+                    b.allocator,
+                    "Attempted to call {[key]s}() from the server but {[key]s} " ++
+                        "is on the client. It's not possible to invoke a client function from " ++
+                        "the server, it can only be rendered as a Component or passed to " ++
+                        "props of a Client Component.",
+                    .{ .key = key },
+                );
+
+            // throw new Error(...)
+            const err_msg = b.newExpr(E.New{
+                .target = b.newExpr(E.Identifier{
+                    .ref = try b.newExternalSymbol("Error"),
+                }),
+                .args = try BabyList(Expr).fromSlice(b.allocator, &.{
+                    b.newExpr(E.String{ .data = err_msg_string }),
+                }),
+                .close_parens_loc = Logger.Loc.Empty,
+            });
+
+            // registerClientReference(
+            //   () => { throw new Error(...) },
+            //   "src/filepath.tsx",
+            //   "Comp"
+            // );
+            const value = b.newExpr(E.Call{
+                .target = register_client_reference,
+                .args = try js_ast.ExprNodeList.fromSlice(b.allocator, &.{
+                    b.newExpr(E.Arrow{ .body = .{
+                        .stmts = try b.allocator.dupe(Stmt, &.{
+                            b.newStmt(S.Throw{ .value = err_msg }),
+                        }),
+                        .loc = Logger.Loc.Empty,
+                    } }),
+                    module_path,
+                    b.newExpr(E.String{ .data = key }),
+                }),
+            });
+
+            if (is_default) {
+                // export default registerClientReference(...);
+                try b.appendStmt(S.ExportDefault{ .value = .{ .expr = value }, .default_name = .{} });
+            } else {
+                // export const Component = registerClientReference(...);
+                const export_ref = try b.newSymbol(.other, key);
+                try b.appendStmt(S.Local{
+                    .decls = try G.Decl.List.fromSlice(b.allocator, &.{.{
+                        .binding = Binding.alloc(b.allocator, B.Identifier{ .ref = export_ref }, Logger.Loc.Empty),
+                        .value = value,
+                    }}),
+                    .is_export = true,
+                    .kind = .k_const,
+                });
+            }
+        }
+    }
+};
+
 const IdentityContext = @import("../identity_context.zig").IdentityContext;
 
 const RefVoidMap = std.ArrayHashMapUnmanaged(Ref, void, Ref.ArrayHashCtx, false);
@@ -3191,9 +4648,9 @@ const ResolvedExports = bun.StringArrayHashMapUnmanaged(ExportData);
 const TopLevelSymbolToParts = js_ast.Ast.TopLevelSymbolToParts;
 
 pub const WrapKind = enum(u2) {
-    none = 0,
-    cjs = 1,
-    esm = 2,
+    none,
+    cjs,
+    esm,
 };
 
 pub const ImportData = struct {
@@ -3355,44 +4812,106 @@ pub const JSMeta = struct {
 };
 
 pub const Graph = struct {
-    entry_points: std.ArrayListUnmanaged(Index) = .{},
-    ast: MultiArrayList(JSAst) = .{},
-
-    input_files: InputFile.List = .{},
-
-    code_splitting: bool = false,
-
-    pool: *ThreadPool = undefined,
-
-    heap: ThreadlocalArena = ThreadlocalArena{},
-    /// Main thread only!!
+    pool: *ThreadPool,
+    heap: ThreadlocalArena = .{},
+    /// This allocator is thread-local to the Bundler thread
+    /// .allocator == .heap.allocator()
     allocator: std.mem.Allocator = undefined,
 
-    parse_pending: usize = 0,
-    resolve_pending: usize = 0,
+    /// Mapping user-specified entry points to their Source Index
+    entry_points: std.ArrayListUnmanaged(Index) = .{},
+    /// Every source index has an associated InputFile
+    input_files: MultiArrayList(InputFile) = .{},
+    /// Every source index has an associated Ast
+    /// When a parse is in progress / queued, it is `Ast.empty`
+    ast: MultiArrayList(JSAst) = .{},
 
-    /// Stable source index mapping
-    source_index_map: std.AutoArrayHashMapUnmanaged(Index.Int, Ref.Int) = .{},
+    /// During the scan + parse phase, this value keeps a count of the remaining
+    /// tasks. Once it hits zero, the scan phase ends and linking begins. Note
+    /// that if `deferred_pending > 0`, it means there are plugin callbacks
+    /// to invoke before linking, which can initiate another scan phase.
+    ///
+    /// Increment and decrement this via `incrementScanCounter` and
+    /// `decrementScanCounter`, as asynchronous bundles check for `0` in the
+    /// decrement function, instead of at the top of the event loop.
+    ///
+    /// - Parsing a file (ParseTask and ServerComponentParseTask)
+    /// - onResolve and onLoad functions
+    /// - Resolving an onDefer promise
+    pending_items: u32 = 0,
+    /// When an `onLoad` plugin calls `.defer()`, the count from `pending_items`
+    /// is "moved" into this counter (pending_items -= 1; deferred_pending += 1)
+    ///
+    /// When `pending_items` hits zero and there are deferred pending tasks, those
+    /// tasks will be run, and the count is "moved" back to `pending_items`
+    deferred_pending: u32 = 0,
+
+    /// Maps a hashed path string to a source index, if it exists in the compilation.
+    /// Instead of accessing this directly, consider using BundleV2.pathToSourceIndexMap
     path_to_source_index_map: PathToSourceIndexMap = .{},
+    /// When using server components, a completely separate file listing is
+    /// required to avoid incorrect inlining of defines and dependencies on
+    /// other files. This is relevant for files shared between server and client
+    /// and have no "use <side>" directive, and must be duplicated.
+    ///
+    /// To make linking easier, this second graph contains indices into the
+    /// same `.ast` and `.input_files` arrays.
+    client_path_to_source_index_map: PathToSourceIndexMap = .{},
+    /// When using server components with React, there is an additional module
+    /// graph which is used to contain SSR-versions of all client components;
+    /// the SSR graph. The difference between the SSR graph and the server
+    /// graph is that this one does not apply '--conditions react-server'
+    ///
+    /// In Bun's React Framework, it includes SSR versions of 'react' and
+    /// 'react-dom' (an export condition is used to provide a different
+    /// implementation for RSC, which is potentially how they implement
+    /// server-only features such as async components).
+    ssr_path_to_source_index_map: PathToSourceIndexMap = .{},
 
-    use_directive_entry_points: UseDirective.List = .{},
+    /// When Server Components is enabled, this holds a list of all boundary
+    /// files. This happens for all files with a "use <side>" directive.
+    server_component_boundaries: ServerComponentBoundary.List = .{},
 
     estimated_file_loader_count: usize = 0,
 
+    /// For Bake, a count of the CSS asts is used to make precise
+    /// pre-allocations without re-iterating the file listing.
+    css_file_count: usize = 0,
+
     additional_output_files: std.ArrayListUnmanaged(options.OutputFile) = .{},
-    shadow_entry_point_range: Logger.Range = Logger.Range.None,
-    shadow_entry_points: std.ArrayListUnmanaged(ShadowEntryPoint) = .{},
+
+    kit_referenced_server_data: bool,
+    kit_referenced_client_data: bool,
 
     pub const InputFile = struct {
         source: Logger.Source,
         loader: options.Loader = options.Loader.file,
         side_effects: _resolver.SideEffects,
+        allocator: std.mem.Allocator = bun.default_allocator,
         additional_files: BabyList(AdditionalFile) = .{},
         unique_key_for_additional_file: string = "",
         content_hash_for_additional_file: u64 = 0,
-
-        pub const List = MultiArrayList(InputFile);
     };
+
+    /// Schedule a task to be run on the JS thread which resolves the promise of
+    /// each `.defer()` called in an onLoad plugin.
+    ///
+    /// Returns true if there were more tasks queued.
+    pub fn drainDeferredTasks(this: *@This(), bundler: *BundleV2) bool {
+        bundler.thread_lock.assertLocked();
+
+        if (this.deferred_pending > 0) {
+            this.pending_items += this.deferred_pending;
+            this.deferred_pending = 0;
+
+            bundler.drain_defer_task.init();
+            bundler.drain_defer_task.schedule();
+
+            return true;
+        }
+
+        return false;
+    }
 };
 
 pub const AdditionalFile = union(enum) {
@@ -3403,19 +4922,19 @@ pub const AdditionalFile = union(enum) {
 const PathToSourceIndexMap = std.HashMapUnmanaged(u64, Index.Int, IdentityContext(u64), 80);
 
 const EntryPoint = struct {
-    // This may be an absolute path or a relative path. If absolute, it will
-    // eventually be turned into a relative path by computing the path relative
-    // to the "outbase" directory. Then this relative path will be joined onto
-    // the "outdir" directory to form the final output path for this entry point.
+    /// This may be an absolute path or a relative path. If absolute, it will
+    /// eventually be turned into a relative path by computing the path relative
+    /// to the "outbase" directory. Then this relative path will be joined onto
+    /// the "outdir" directory to form the final output path for this entry point.
     output_path: bun.PathString = bun.PathString.empty,
 
-    // This is the source index of the entry point. This file must have a valid
-    // entry point kind (i.e. not "none").
+    /// This is the source index of the entry point. This file must have a valid
+    /// entry point kind (i.e. not "none").
     source_index: Index.Int = 0,
 
-    // Manually specified output paths are ignored when computing the default
-    // "outbase" directory, which is computed as the lowest common ancestor of
-    // all automatically generated output paths.
+    /// Manually specified output paths are ignored when computing the default
+    /// "outbase" directory, which is computed as the lowest common ancestor of
+    /// all automatically generated output paths.
     output_path_was_auto_generated: bool = false,
 
     pub const List = MultiArrayList(EntryPoint);
@@ -3425,17 +4944,9 @@ const EntryPoint = struct {
         user_specified,
         dynamic_import,
 
-        /// Created via an import of a "use client" file
-        react_client_component,
-
-        /// Created via an import of a "use server" file
-        react_server_component,
-
-        pub fn OutputKind(this: Kind) JSC.API.BuildArtifact.OutputKind {
+        pub fn outputKind(this: Kind) JSC.API.BuildArtifact.OutputKind {
             return switch (this) {
                 .user_specified => .@"entry-point",
-                .react_client_component => .@"use client",
-                .react_server_component => .@"use server",
                 else => .chunk,
             };
         }
@@ -3448,20 +4959,9 @@ const EntryPoint = struct {
             return this == .user_specified;
         }
 
+        // TODO: delete
         pub inline fn isServerEntryPoint(this: Kind) bool {
-            return this == .user_specified or this == .react_server_component;
-        }
-
-        pub fn isReactReference(this: Kind) bool {
-            return this == .react_client_component or this == .react_server_component;
-        }
-
-        pub fn useDirective(this: Kind) UseDirective {
-            return switch (this) {
-                .react_client_component => .@"use client",
-                .react_server_component => .@"use server",
-                else => .none,
-            };
+            return this == .user_specified;
         }
     };
 };
@@ -3474,10 +4974,6 @@ const AstSourceIDMapping = struct {
 const LinkerGraph = struct {
     const debug = Output.scoped(.LinkerGraph, false);
 
-    /// TODO(@paperdave): remove this. i added it before realizing this is available
-    /// via LinkerContext.parse_graph. it may also be worth removing the other cloned data.
-    bundler_graph: *const Graph,
-
     files: File.List = .{},
     files_live: BitSet = undefined,
     entry_points: EntryPoint.List = .{},
@@ -3503,8 +4999,7 @@ const LinkerGraph = struct {
 
     stable_source_indices: []const u32 = &[_]u32{},
 
-    react_client_component_boundary: BitSet = .{},
-    react_server_component_boundary: BitSet = .{},
+    is_scb_bitset: BitSet = .{},
     has_client_components: bool = false,
     has_server_components: bool = false,
 
@@ -3520,22 +5015,6 @@ const LinkerGraph = struct {
         };
     }
 
-    pub fn useDirectiveBoundary(this: *const LinkerGraph, source_index: Index.Int) UseDirective {
-        if (this.react_client_component_boundary.bit_length > 0) {
-            if (this.react_client_component_boundary.isSet(source_index)) {
-                return .@"use client";
-            }
-        }
-
-        if (this.react_server_component_boundary.bit_length > 0) {
-            if (this.react_server_component_boundary.isSet(source_index)) {
-                return .@"use server";
-            }
-        }
-
-        return .none;
-    }
-
     pub fn runtimeFunction(this: *const LinkerGraph, name: string) Ref {
         return this.ast.items(.named_exports)[Index.runtime.value].get(name).?.ref;
     }
@@ -3646,6 +5125,7 @@ const LinkerGraph = struct {
 
         return part_id;
     }
+
     pub fn generateSymbolImportAndUse(
         g: *LinkerGraph,
         source_index: u32,
@@ -3722,10 +5202,10 @@ const LinkerGraph = struct {
         this: *LinkerGraph,
         entry_points: []const Index,
         sources: []const Logger.Source,
-        use_directive_entry_points: UseDirective.List,
+        server_component_boundaries: ServerComponentBoundary.List,
         dynamic_import_entry_points: []const Index.Int,
-        shadow_entry_point_range: Logger.Range,
     ) !void {
+        const scb = server_component_boundaries.slice();
         try this.files.setCapacity(this.allocator, sources.len);
         this.files.zero();
         this.files_live = try BitSet.initEmpty(
@@ -3743,7 +5223,7 @@ const LinkerGraph = struct {
 
         // Setup entry points
         {
-            try this.entry_points.setCapacity(this.allocator, entry_points.len + use_directive_entry_points.len + dynamic_import_entry_points.len);
+            try this.entry_points.setCapacity(this.allocator, entry_points.len + server_component_boundaries.list.len + dynamic_import_entry_points.len);
             this.entry_points.len = entry_points.len;
             const source_indices = this.entry_points.items(.source_index);
 
@@ -3786,83 +5266,40 @@ const LinkerGraph = struct {
             this.meta.len = this.ast.len;
             this.meta.zero();
 
-            if (use_directive_entry_points.len > 0) {
-                this.react_client_component_boundary = BitSet.initEmpty(this.allocator, this.files.len) catch unreachable;
-                this.react_server_component_boundary = BitSet.initEmpty(this.allocator, this.files.len) catch unreachable;
-                var any_server = false;
-                var any_client = false;
+            if (scb.list.len > 0) {
+                this.is_scb_bitset = BitSet.initEmpty(this.allocator, this.files.len) catch unreachable;
 
-                // Loop #1: populate the list of files that are react client components
-                for (use_directive_entry_points.items(.use_directive), use_directive_entry_points.items(.source_index)) |use, source_id| {
-                    if (use == .@"use client") {
-                        any_client = true;
-                        this.react_client_component_boundary.set(source_id);
-                    } else if (use == .@"use server") {
-                        any_server = true;
-                        this.react_server_component_boundary.set(source_id);
+                // Index all SCBs into the bitset. This is needed so chunking
+                // can track the chunks that SCBs belong to.
+                for (scb.list.items(.use_directive), scb.list.items(.source_index), scb.list.items(.reference_source_index)) |use, original_id, ref_id| {
+                    switch (use) {
+                        .none => {},
+                        .client => {
+                            this.is_scb_bitset.set(original_id);
+                            this.is_scb_bitset.set(ref_id);
+                        },
+                        .server => {
+                            bun.todoPanic(@src(), "um", .{});
+                        },
                     }
                 }
 
-                if (any_client or any_server) {
-                    // Loop #2: For each import in the entire module graph
-                    for (this.reachable_files) |source_id| {
-                        const use_directive = this.useDirectiveBoundary(source_id.get());
-                        const source_i32 = @as(i32, @intCast(source_id.get()));
-                        const is_shadow_entrypoint = shadow_entry_point_range.contains(source_i32);
-
-                        // If the reachable file has a "use client"; at the top
-                        for (import_records_list[source_id.get()].slice()) |*import_record| {
-                            const source_index_ = import_record.source_index;
-                            if (source_index_.isValid()) {
-                                const source_index = import_record.source_index.get();
-
-                                // and the import path refers to a server entry point
-                                if (import_record.tag == .none) {
-                                    const other = this.useDirectiveBoundary(source_index);
-
-                                    if (use_directive.boundering(other)) |boundary| {
-
-                                        // That import is a React Server Component reference.
-                                        switch (boundary) {
-                                            .@"use client" => {
-                                                if (!is_shadow_entrypoint) {
-                                                    const pretty = sources[source_index].path.pretty;
-                                                    import_record.module_id = bun.hash32(pretty);
-                                                    import_record.tag = .react_client_component;
-                                                    import_record.path.namespace = "client";
-                                                    import_record.print_namespace_in_path = true;
-                                                    import_record.source_index = Index.invalid;
-                                                }
-                                            },
-                                            .@"use server" => {
-                                                import_record.module_id = bun.hash32(sources[source_index].path.pretty);
-                                                import_record.tag = .react_server_component;
-                                                import_record.path.namespace = "server";
-                                                import_record.print_namespace_in_path = true;
-
-                                                if (entry_point_kinds[source_index] == .none) {
-                                                    if (comptime Environment.allow_assert)
-                                                        debug("Adding server component entry point for {s}", .{sources[source_index].path.text});
-
-                                                    try this.entry_points.append(this.allocator, .{
-                                                        .source_index = source_index,
-                                                        .output_path = bun.PathString.init(sources[source_index].path.text),
-                                                        .output_path_was_auto_generated = true,
-                                                    });
-                                                    entry_point_kinds[source_index] = .react_server_component;
-                                                }
-                                            },
-                                            else => unreachable,
-                                        }
-                                    }
-                                }
-                            }
+                // For client components, the import record index currently points to the original source index, instead of the reference source index.
+                for (this.reachable_files) |source_id| {
+                    for (import_records_list[source_id.get()].slice()) |*import_record| {
+                        if (import_record.source_index.isValid() and this.is_scb_bitset.isSet(import_record.source_index.get())) {
+                            import_record.source_index = Index.init(
+                                scb.getReferenceSourceIndex(import_record.source_index.get()) orelse
+                                    // If this gets hit, might be fine to switch this to `orelse continue`
+                                    // not confident in this assertion
+                                    Output.panic("Missing SCB boundary for file #{d}", .{import_record.source_index.get()}),
+                            );
+                            bun.assert(import_record.source_index.isValid()); // did not generate
                         }
                     }
-                } else {
-                    this.react_client_component_boundary = .{};
-                    this.react_server_component_boundary = .{};
                 }
+            } else {
+                this.is_scb_bitset = .{};
             }
         }
 
@@ -3877,11 +5314,9 @@ const LinkerGraph = struct {
                 stable_source_indices[source_index.get()] = Index.source(i);
             }
 
-            const file = LinkerGraph.File{};
-            // TODO: verify this outputs efficient code
             @memset(
                 files.items(.distance_from_entry_point),
-                file.distance_from_entry_point,
+                (LinkerGraph.File{}).distance_from_entry_point,
             );
             this.stable_source_indices = @as([]const u32, @ptrCast(stable_source_indices));
         }
@@ -3937,16 +5372,11 @@ const LinkerGraph = struct {
             var resolved = ResolvedExports{};
             resolved.ensureTotalCapacity(this.allocator, src.count()) catch unreachable;
             for (src.keys(), src.values()) |key, value| {
-                resolved.putAssumeCapacityNoClobber(
-                    key,
-                    .{
-                        .data = .{
-                            .import_ref = value.ref,
-                            .name_loc = value.alias_loc,
-                            .source_index = Index.source(source_index),
-                        },
-                    },
-                );
+                resolved.putAssumeCapacityNoClobber(key, .{ .data = .{
+                    .import_ref = value.ref,
+                    .name_loc = value.alias_loc,
+                    .source_index = Index.source(source_index),
+                } });
             }
             dest.* = resolved;
         }
@@ -3961,16 +5391,20 @@ const LinkerGraph = struct {
         /// to this file
         distance_from_entry_point: u32 = std.math.maxInt(u32),
 
-        /// If "entryPointKind" is not "entryPointNone", this is the index of the
-        /// corresponding entry point chunk.
-        entry_point_chunk_index: u32 = 0,
-
-        /// This file is an entry point if and only if this is not "entryPointNone".
+        /// This file is an entry point if and only if this is not ".none".
         /// Note that dynamically-imported files are allowed to also be specified by
         /// the user as top-level entry points, so some dynamically-imported files
-        /// may be "entryPointUserSpecified" instead of "entryPointDynamicImport".
+        /// may be ".user_specified" instead of ".dynamic_import".
         entry_point_kind: EntryPoint.Kind = .none,
 
+        /// If "entry_point_kind" is not ".none", this is the index of the
+        /// corresponding entry point chunk.
+        ///
+        /// This is also initialized for files that are a SCB's generated
+        /// reference, pointing to its destination. This forms a lookup map from
+        /// a Source.Index to its output path inb reakOutputIntoPieces
+        entry_point_chunk_index: u32 = std.math.maxInt(u32),
+
         line_offset_table: bun.sourcemap.LineOffsetTable.List = .{},
         quoted_source_contents: string = "",
 
@@ -4024,7 +5458,16 @@ pub const LinkerContext = struct {
     /// to know whether or not we can free it safely.
     pending_task_count: std.atomic.Value(u32) = std.atomic.Value(u32).init(0),
 
+    /// Used by Bake to extract []CompileResult before it is joined
+    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 {
+        generate_bytecode_cache: bool = false,
         output_format: options.Format = .esm,
         ignore_dce_annotations: bool = false,
         emit_dce_annotations: bool = true,
@@ -4032,10 +5475,14 @@ pub const LinkerContext = struct {
         minify_whitespace: bool = false,
         minify_syntax: bool = false,
         minify_identifiers: bool = false,
+        banner: []const u8 = "",
+        footer: []const u8 = "",
+        experimental_css: bool = false,
+        css_chunking: bool = false,
         source_maps: options.SourceMapOption = .none,
         target: options.Target = .browser,
 
-        mode: Mode = Mode.bundle,
+        mode: Mode = .bundle,
 
         public_path: []const u8 = "",
 
@@ -4135,9 +5582,6 @@ pub const LinkerContext = struct {
         if (part.stmts.len == 1) {
             if (part.stmts[0].data == .s_import) {
                 const record = c.graph.ast.items(.import_records)[source_index].at(part.stmts[0].data.s_import.import_record_index);
-                if (record.tag.isReactReference())
-                    return true;
-
                 if (record.source_index.isValid() and c.graph.meta.items(.flags)[record.source_index.get()].wrap == .none) {
                     return false;
                 }
@@ -4151,7 +5595,7 @@ pub const LinkerContext = struct {
         this: *LinkerContext,
         bundle: *BundleV2,
         entry_points: []Index,
-        use_directive_entry_points: UseDirective.List,
+        server_component_boundaries: ServerComponentBoundary.List,
         reachable: []Index,
     ) !void {
         const trace = tracer(@src(), "CloneLinkerGraph");
@@ -4168,7 +5612,7 @@ pub const LinkerContext = struct {
 
         const sources: []const Logger.Source = this.parse_graph.input_files.items(.source);
 
-        try this.graph.load(entry_points, sources, use_directive_entry_points, bundle.dynamic_import_entry_points.keys(), bundle.graph.shadow_entry_point_range);
+        try this.graph.load(entry_points, sources, server_component_boundaries, bundle.dynamic_import_entry_points.keys());
         bundle.dynamic_import_entry_points.deinit();
         this.wait_group.init();
         this.ambiguous_result_pool = std.ArrayList(MatchImport).init(this.allocator);
@@ -4177,6 +5621,37 @@ pub const LinkerContext = struct {
 
         this.esm_runtime_ref = runtime_named_exports.get("__esm").?.ref;
         this.cjs_runtime_ref = runtime_named_exports.get("__commonJS").?.ref;
+
+        if (this.options.output_format == .cjs) {
+            this.unbound_module_ref = this.graph.generateNewSymbol(Index.runtime.get(), .unbound, "module");
+        }
+
+        if (this.options.output_format == .cjs or this.options.output_format == .iife) {
+            const exports_kind = this.graph.ast.items(.exports_kind);
+            const ast_flags_list = this.graph.ast.items(.flags);
+            const meta_flags_list = this.graph.meta.items(.flags);
+
+            for (entry_points) |entry_point| {
+                var ast_flags: js_ast.BundledAst.Flags = ast_flags_list[entry_point.get()];
+
+                // Loaders default to CommonJS when they are the entry point and the output
+                // format is not ESM-compatible since that avoids generating the ESM-to-CJS
+                // machinery.
+                if (ast_flags.has_lazy_export) {
+                    exports_kind[entry_point.get()] = .cjs;
+                }
+
+                // Entry points with ES6 exports must generate an exports object when
+                // targeting non-ES6 formats. Note that the IIFE format only needs this
+                // when the global name is present, since that's the only way the exports
+                // can actually be observed externally.
+                if (ast_flags.uses_export_keyword) {
+                    ast_flags.uses_exports_ref = true;
+                    ast_flags_list[entry_point.get()] = ast_flags;
+                    meta_flags_list[entry_point.get()].force_include_exports_for_entry_point = true;
+                }
+            }
+        }
     }
 
     pub fn computeDataForSourceMap(
@@ -4226,14 +5701,13 @@ pub const LinkerContext = struct {
         this: *LinkerContext,
         bundle: *BundleV2,
         entry_points: []Index,
-        use_directive_entry_points: UseDirective.List,
+        server_component_boundaries: ServerComponentBoundary.List,
         reachable: []Index,
-        unique_key: u64,
     ) ![]Chunk {
         try this.load(
             bundle,
             entry_points,
-            use_directive_entry_points,
+            server_component_boundaries,
             reachable,
         );
 
@@ -4249,7 +5723,7 @@ pub const LinkerContext = struct {
 
         // Stop now if there were errors
         if (this.log.hasErrors()) {
-            return &[_]Chunk{};
+            return error.BuildFailed;
         }
 
         if (comptime FeatureFlags.help_catch_memory_issues) {
@@ -4262,7 +5736,7 @@ pub const LinkerContext = struct {
             this.checkForMemoryCorruption();
         }
 
-        const chunks = try this.computeChunks(unique_key);
+        const chunks = try this.computeChunks(bundle.unique_key);
 
         if (comptime FeatureFlags.help_catch_memory_issues) {
             this.checkForMemoryCorruption();
@@ -4292,16 +5766,23 @@ pub const LinkerContext = struct {
         const trace = tracer(@src(), "computeChunks");
         defer trace.end();
 
+        bun.assert(this.dev_server == null); // use computeChunksForDevServer
+
         var stack_fallback = std.heap.stackFallback(4096, this.allocator);
         const stack_all = stack_fallback.get();
         var arena = bun.ArenaAllocator.init(stack_all);
         defer arena.deinit();
 
         var temp_allocator = arena.allocator();
-        var js_chunks = bun.StringArrayHashMap(Chunk).init(this.allocator);
+        var js_chunks = bun.StringArrayHashMap(Chunk).init(temp_allocator);
         try js_chunks.ensureUnusedCapacity(this.graph.entry_points.len);
 
+        // Key is the hash of the CSS order. This deduplicates identical CSS files.
+        var css_chunks = std.AutoArrayHashMap(u64, Chunk).init(temp_allocator);
+        var js_chunks_with_css: usize = 0;
+
         const entry_source_indices = this.graph.entry_points.items(.source_index);
+        const css_asts = this.graph.ast.items(.css);
 
         // Create chunks for entry points
         for (entry_source_indices, 0..) |source_index, entry_id_| {
@@ -4310,10 +5791,43 @@ pub const LinkerContext = struct {
             var entry_bits = &this.graph.files.items(.entry_bits)[source_index];
             entry_bits.set(entry_bit);
 
+            if (this.options.experimental_css and css_asts[source_index] != null) {
+                const order = this.findImportedFilesInCSSOrder(temp_allocator, &.{Index.init(source_index)});
+                // Create a chunk for the entry point here to ensure that the chunk is
+                // always generated even if the resulting file is empty
+                const hash_to_use = if (!this.options.css_chunking)
+                    bun.hash(try temp_allocator.dupe(u8, entry_bits.bytes(this.graph.entry_points.len)))
+                else brk: {
+                    var hasher = std.hash.Wyhash.init(5);
+                    bun.writeAnyToHasher(&hasher, order.len);
+                    for (order.slice()) |x| x.hash(&hasher);
+                    break :brk hasher.final();
+                };
+                const css_chunk_entry = try css_chunks.getOrPut(hash_to_use);
+                if (!css_chunk_entry.found_existing) {
+                    // const css_chunk_entry = try js_chunks.getOrPut();
+                    css_chunk_entry.value_ptr.* = .{
+                        .entry_point = .{
+                            .entry_point_id = entry_bit,
+                            .source_index = source_index,
+                            .is_entry_point = true,
+                        },
+                        .entry_bits = entry_bits.*,
+                        .content = .{
+                            .css = .{
+                                .imports_in_chunk_in_order = order,
+                                .asts = this.allocator.alloc(bun.css.BundlerStyleSheet, order.len) catch bun.outOfMemory(),
+                            },
+                        },
+                        .output_source_map = sourcemap.SourceMapPieces.init(this.allocator),
+                    };
+                }
+
+                continue;
+            }
             // Create a chunk for the entry point here to ensure that the chunk is
             // always generated even if the resulting file is empty
             const js_chunk_entry = try js_chunks.getOrPut(try temp_allocator.dupe(u8, entry_bits.bytes(this.graph.entry_points.len)));
-
             js_chunk_entry.value_ptr.* = .{
                 .entry_point = .{
                     .entry_point_id = entry_bit,
@@ -4326,6 +5840,60 @@ pub const LinkerContext = struct {
                 },
                 .output_source_map = sourcemap.SourceMapPieces.init(this.allocator),
             };
+
+            if (this.options.experimental_css) {
+                // If this JS entry point has an associated CSS entry point, generate it
+                // now. This is essentially done by generating a virtual CSS file that
+                // only contains "@import" statements in the order that the files were
+                // discovered in JS source order, where JS source order is arbitrary but
+                // consistent for dynamic imports. Then we run the CSS import order
+                // algorithm to determine the final CSS file order for the chunk.
+                const css_source_indices = this.findImportedCSSFilesInJSOrder(temp_allocator, Index.init(source_index));
+                if (css_source_indices.len > 0) {
+                    const order = this.findImportedFilesInCSSOrder(temp_allocator, css_source_indices.slice());
+
+                    const hash_to_use = if (!this.options.css_chunking)
+                        bun.hash(try temp_allocator.dupe(u8, entry_bits.bytes(this.graph.entry_points.len)))
+                    else brk: {
+                        var hasher = std.hash.Wyhash.init(5);
+                        bun.writeAnyToHasher(&hasher, order.len);
+                        for (order.slice()) |x| x.hash(&hasher);
+                        break :brk hasher.final();
+                    };
+
+                    const css_chunk_entry = try css_chunks.getOrPut(hash_to_use);
+
+                    js_chunk_entry.value_ptr.content.javascript.css_chunks = try this.allocator.dupe(u32, &.{
+                        @intCast(css_chunk_entry.index),
+                    });
+                    js_chunks_with_css += 1;
+
+                    if (!css_chunk_entry.found_existing) {
+                        var css_files_with_parts_in_chunk = std.AutoArrayHashMapUnmanaged(Index.Int, void){};
+                        for (order.slice()) |entry| {
+                            if (entry.kind == .source_index) {
+                                css_files_with_parts_in_chunk.put(this.allocator, entry.kind.source_index.get(), {}) catch bun.outOfMemory();
+                            }
+                        }
+                        css_chunk_entry.value_ptr.* = .{
+                            .entry_point = .{
+                                .entry_point_id = entry_bit,
+                                .source_index = source_index,
+                                .is_entry_point = true,
+                            },
+                            .entry_bits = entry_bits.*,
+                            .content = .{
+                                .css = .{
+                                    .imports_in_chunk_in_order = order,
+                                    .asts = this.allocator.alloc(bun.css.BundlerStyleSheet, order.len) catch bun.outOfMemory(),
+                                },
+                            },
+                            .files_with_parts_in_chunk = css_files_with_parts_in_chunk,
+                            .output_source_map = sourcemap.SourceMapPieces.init(this.allocator),
+                        };
+                    }
+                }
+            }
         }
         var file_entry_bits: []AutoBitSet = this.graph.files.items(.entry_bits);
 
@@ -4339,44 +5907,91 @@ pub const LinkerContext = struct {
             }
         };
 
+        const css_reprs = this.graph.ast.items(.css);
+
         // Figure out which JS files are in which chunk
-        for (this.graph.reachable_files) |source_index| {
-            if (this.graph.files_live.isSet(source_index.get())) {
-                const entry_bits: *const AutoBitSet = &file_entry_bits[source_index.get()];
+        if (js_chunks.count() > 0) {
+            for (this.graph.reachable_files) |source_index| {
+                if (this.graph.files_live.isSet(source_index.get())) {
+                    if (this.graph.ast.items(.css)[source_index.get()] == null) {
+                        const entry_bits: *const AutoBitSet = &file_entry_bits[source_index.get()];
+                        if (css_reprs[source_index.get()] != null) continue;
 
-                if (this.graph.code_splitting) {
-                    var js_chunk_entry = try js_chunks.getOrPut(
-                        try temp_allocator.dupe(u8, entry_bits.bytes(this.graph.entry_points.len)),
-                    );
+                        if (this.graph.code_splitting) {
+                            var js_chunk_entry = try js_chunks.getOrPut(
+                                try temp_allocator.dupe(u8, entry_bits.bytes(this.graph.entry_points.len)),
+                            );
 
-                    if (!js_chunk_entry.found_existing) {
-                        js_chunk_entry.value_ptr.* = .{
-                            .entry_bits = entry_bits.*,
-                            .entry_point = .{
-                                .source_index = source_index.get(),
-                            },
-                            .content = .{
-                                .javascript = .{},
-                            },
-                            .output_source_map = sourcemap.SourceMapPieces.init(this.allocator),
-                        };
+                            if (!js_chunk_entry.found_existing) {
+                                js_chunk_entry.value_ptr.* = .{
+                                    .entry_bits = entry_bits.*,
+                                    .entry_point = .{
+                                        .source_index = source_index.get(),
+                                    },
+                                    .content = .{
+                                        .javascript = .{},
+                                    },
+                                    .output_source_map = sourcemap.SourceMapPieces.init(this.allocator),
+                                };
+                            }
+
+                            _ = js_chunk_entry.value_ptr.files_with_parts_in_chunk.getOrPut(this.allocator, @as(u32, @truncate(source_index.get()))) catch unreachable;
+                        } else {
+                            var handler = Handler{
+                                .chunks = js_chunks.values(),
+                                .allocator = this.allocator,
+                                .source_id = source_index.get(),
+                            };
+                            entry_bits.forEach(Handler, &handler, Handler.next);
+                        }
                     }
-
-                    _ = js_chunk_entry.value_ptr.files_with_parts_in_chunk.getOrPut(this.allocator, @as(u32, @truncate(source_index.get()))) catch unreachable;
-                } else {
-                    var handler = Handler{
-                        .chunks = js_chunks.values(),
-                        .allocator = this.allocator,
-                        .source_id = source_index.get(),
-                    };
-                    entry_bits.forEach(Handler, &handler, Handler.next);
                 }
             }
         }
 
-        js_chunks.sort(strings.StringArrayByIndexSorter.init(try temp_allocator.dupe(string, js_chunks.keys())));
+        // Sort the chunks for determinism. This matters because we use chunk indices
+        // as sorting keys in a few places.
+        const chunks: []Chunk = sort_chunks: {
+            var sorted_chunks = try BabyList(Chunk).initCapacity(this.allocator, js_chunks.count() + css_chunks.count());
 
-        const chunks: []Chunk = js_chunks.values();
+            var sorted_keys = try BabyList(string).initCapacity(temp_allocator, js_chunks.count());
+
+            // JS Chunks
+            sorted_keys.appendSliceAssumeCapacity(js_chunks.keys());
+            sorted_keys.sortAsc();
+            var js_chunk_indices_with_css = try BabyList(u32).initCapacity(temp_allocator, js_chunks_with_css);
+            for (sorted_keys.slice(), 0..) |key, i| {
+                const chunk = js_chunks.get(key) orelse unreachable;
+                sorted_chunks.appendAssumeCapacity(chunk);
+
+                if (chunk.content.javascript.css_chunks.len > 0)
+                    js_chunk_indices_with_css.appendAssumeCapacity(@intCast(i));
+            }
+
+            if (css_chunks.count() > 0) {
+                const sorted_css_keys = try temp_allocator.dupe(u64, css_chunks.keys());
+                std.sort.pdq(u64, sorted_css_keys, {}, std.sort.asc(u64));
+
+                // A map from the index in `css_chunks` to it's final index in `sorted_chunks`
+                const remapped_css_indexes = try temp_allocator.alloc(u32, css_chunks.count());
+
+                const css_chunk_values = css_chunks.values();
+                for (sorted_css_keys, js_chunks.count()..) |key, sorted_index| {
+                    const index = css_chunks.getIndex(key) orelse unreachable;
+                    sorted_chunks.appendAssumeCapacity(css_chunk_values[index]);
+                    remapped_css_indexes[index] = @intCast(sorted_index);
+                }
+
+                // Update all affected JS chunks to point at the correct CSS chunk index.
+                for (js_chunk_indices_with_css.slice()) |js_index| {
+                    for (sorted_chunks.slice()[js_index].content.javascript.css_chunks) |*idx| {
+                        idx.* = remapped_css_indexes[idx.*];
+                    }
+                }
+            }
+
+            break :sort_chunks sorted_chunks.slice();
+        };
 
         const entry_point_chunk_indices: []u32 = this.graph.files.items(.entry_point_chunk_index);
         // Map from the entry point file to this chunk. We will need this later if
@@ -4406,9 +6021,9 @@ pub const LinkerContext = struct {
             // Assign a unique key to each chunk. This key encodes the index directly so
             // we can easily recover it later without needing to look it up in a map. The
             // last 8 numbers of the key are the chunk index.
-            chunk.unique_key = unique_key_builder.fmt("{any}C{d:0>8}", .{ bun.fmt.hexIntLower(unique_key), chunk_id });
+            chunk.unique_key = unique_key_builder.fmt("{}C{d:0>8}", .{ bun.fmt.hexIntLower(unique_key), chunk_id });
             if (this.unique_key_prefix.len == 0)
-                this.unique_key_prefix = chunk.unique_key[0..std.fmt.count("{any}", .{bun.fmt.hexIntLower(unique_key)})];
+                this.unique_key_prefix = chunk.unique_key[0..std.fmt.count("{}", .{bun.fmt.hexIntLower(unique_key)})];
 
             if (chunk.entry_point.is_entry_point and
                 kinds[chunk.entry_point.source_index] == .user_specified)
@@ -4424,19 +6039,22 @@ pub const LinkerContext = struct {
 
             const pathname = Fs.PathName.init(output_paths[chunk.entry_point.entry_point_id].slice());
             chunk.template.placeholder.name = pathname.base;
-            chunk.template.placeholder.ext = "js";
+            chunk.template.placeholder.ext = chunk.content.ext();
 
             // this if check is a specific fix for `bun build hi.ts --external '*'`, without leading `./`
             const dir_path = if (pathname.dir.len > 0) pathname.dir else ".";
 
-            var dir = std.fs.cwd().openDir(dir_path, .{}) catch |err| {
-                try this.log.addErrorFmt(null, Logger.Loc.Empty, bun.default_allocator, "{s}: failed to open entry point directory: {s}", .{ @errorName(err), pathname.dir });
-                return error.FailedToOpenEntryPointDirectory;
-            };
-            defer dir.close();
-
             var real_path_buf: bun.PathBuffer = undefined;
-            chunk.template.placeholder.dir = try resolve_path.relativeAlloc(this.allocator, this.resolver.opts.root_dir, try bun.getFdPath(bun.toFD(dir.fd), &real_path_buf));
+            const dir = dir: {
+                var dir = std.fs.cwd().openDir(dir_path, .{}) catch {
+                    break :dir bun.path.normalizeBuf(dir_path, &real_path_buf, .auto);
+                };
+                defer dir.close();
+
+                break :dir try bun.getFdPath(bun.toFD(dir.fd), &real_path_buf);
+            };
+
+            chunk.template.placeholder.dir = try resolve_path.relativeAlloc(this.allocator, this.resolver.opts.root_dir, dir);
         }
 
         return chunks;
@@ -4450,12 +6068,18 @@ pub const LinkerContext = struct {
         var parts_prefix_shared = std.ArrayList(PartRange).init(temp_allocator);
         defer part_ranges_shared.deinit();
         defer parts_prefix_shared.deinit();
-        for (chunks) |*chunk| {
-            try this.findImportedPartsInJSOrder(
-                chunk,
-                &part_ranges_shared,
-                &parts_prefix_shared,
-            );
+        for (chunks, 0..) |*chunk, index| {
+            switch (chunk.content) {
+                .javascript => {
+                    try this.findImportedPartsInJSOrder(
+                        chunk,
+                        &part_ranges_shared,
+                        &parts_prefix_shared,
+                        @intCast(index),
+                    );
+                },
+                .css => {}, // handled in `findImportedCSSFilesInJSOrder`
+            }
         }
     }
 
@@ -4464,6 +6088,7 @@ pub const LinkerContext = struct {
         chunk: *Chunk,
         part_ranges_shared: *std.ArrayList(PartRange),
         parts_prefix_shared: *std.ArrayList(PartRange),
+        chunk_index: u32,
     ) !void {
         var chunk_order_array = try std.ArrayList(Chunk.Order).initCapacity(this.allocator, chunk.files_with_parts_in_chunk.count());
         defer chunk_order_array.deinit();
@@ -4473,7 +6098,6 @@ pub const LinkerContext = struct {
                 .{
                     .source_index = source_index,
                     .distance = distances[source_index],
-
                     .tie_breaker = this.graph.stable_source_indices[source_index],
                 },
             );
@@ -4481,17 +6105,18 @@ pub const LinkerContext = struct {
 
         Chunk.Order.sort(chunk_order_array.items);
 
-        const Visitor = struct {
+        const FindImportedPartsVisitor = struct {
             entry_bits: *const AutoBitSet,
             flags: []const JSMeta.Flags,
             parts: []BabyList(js_ast.Part),
             import_records: []BabyList(ImportRecord),
-            files: std.ArrayList(Index.Int) = undefined,
-            part_ranges: std.ArrayList(PartRange) = undefined,
-            visited: std.AutoHashMap(Index.Int, void) = undefined,
-            parts_prefix: std.ArrayList(PartRange) = undefined,
+            files: std.ArrayList(Index.Int),
+            part_ranges: std.ArrayList(PartRange),
+            visited: std.AutoHashMap(Index.Int, void),
+            parts_prefix: std.ArrayList(PartRange),
             c: *LinkerContext,
             entry_point: Chunk.EntryPoint,
+            chunk_index: u32,
 
             fn appendOrExtendRange(
                 ranges: *std.ArrayList(PartRange),
@@ -4518,8 +6143,8 @@ pub const LinkerContext = struct {
             pub fn visit(
                 v: *@This(),
                 source_index: Index.Int,
-                comptime with_react_server_components: UseDirective.Flags,
                 comptime with_code_splitting: bool,
+                comptime with_scb: bool,
             ) void {
                 if (source_index == Index.invalid.value) return;
                 const visited_entry = v.visited.getOrPut(source_index) catch unreachable;
@@ -4532,29 +6157,6 @@ pub const LinkerContext = struct {
                     // when NOT code splitting, include the file in the chunk if ANY of the entry points overlap
                     v.entry_bits.hasIntersection(&v.c.graph.files.items(.entry_bits)[source_index]);
 
-                if (comptime with_react_server_components.is_client or with_react_server_components.is_server) {
-                    if (is_file_in_chunk and
-                        v.entry_point.is_entry_point and
-                        v.entry_point.source_index != source_index)
-                    {
-                        if (comptime with_react_server_components.is_client) {
-                            if (v.c.graph.react_client_component_boundary.isSet(source_index)) {
-                                if (!v.c.graph.react_client_component_boundary.isSet(v.entry_point.source_index)) {
-                                    return;
-                                }
-                            }
-                        }
-
-                        if (comptime with_react_server_components.is_server) {
-                            if (v.c.graph.react_server_component_boundary.isSet(source_index)) {
-                                if (!v.c.graph.react_server_component_boundary.isSet(v.entry_point.source_index)) {
-                                    return;
-                                }
-                            }
-                        }
-                    }
-                }
-
                 // Wrapped files can't be split because they are all inside the wrapper
                 const can_be_split = v.flags[source_index].wrap == .none;
 
@@ -4576,7 +6178,7 @@ pub const LinkerContext = struct {
                                 continue;
                             }
 
-                            v.visit(record.source_index.get(), with_react_server_components, with_code_splitting);
+                            v.visit(record.source_index.get(), with_code_splitting, with_scb);
                         }
                     }
 
@@ -4599,7 +6201,11 @@ pub const LinkerContext = struct {
                 }
 
                 if (is_file_in_chunk) {
-                    v.files.append(source_index) catch unreachable;
+                    if (with_scb and v.c.graph.is_scb_bitset.isSet(source_index)) {
+                        v.c.graph.files.items(.entry_point_chunk_index)[source_index] = v.chunk_index;
+                    }
+
+                    v.files.append(source_index) catch bun.outOfMemory();
 
                     // CommonJS files are all-or-nothing so all parts must be contiguous
                     if (!can_be_split) {
@@ -4609,7 +6215,7 @@ pub const LinkerContext = struct {
                                 .part_index_begin = 0,
                                 .part_index_end = @as(u32, @truncate(parts.len)),
                             },
-                        ) catch unreachable;
+                        ) catch bun.outOfMemory();
                     }
                 }
             }
@@ -4618,7 +6224,7 @@ pub const LinkerContext = struct {
         part_ranges_shared.clearRetainingCapacity();
         parts_prefix_shared.clearRetainingCapacity();
 
-        var visitor = Visitor{
+        var visitor = FindImportedPartsVisitor{
             .files = std.ArrayList(Index.Int).init(this.allocator),
             .part_ranges = part_ranges_shared.*,
             .parts_prefix = parts_prefix_shared.*,
@@ -4629,6 +6235,7 @@ pub const LinkerContext = struct {
             .entry_bits = chunk.entryBits(),
             .c = this,
             .entry_point = chunk.entry_point,
+            .chunk_index = chunk_index,
         };
         defer {
             part_ranges_shared.* = visitor.part_ranges;
@@ -4637,43 +6244,483 @@ pub const LinkerContext = struct {
         }
 
         switch (this.graph.code_splitting) {
-            inline else => |with_code_splitting| switch (this.graph.react_client_component_boundary.bit_length > 0) {
-                inline else => |with_client| switch (this.graph.react_server_component_boundary.bit_length > 0) {
-                    inline else => |with_server| {
-                        visitor.visit(
-                            Index.runtime.value,
-                            .{
-                                .is_server = with_server,
-                                .is_client = with_client,
-                            },
-                            with_code_splitting,
-                        );
-                        for (chunk_order_array.items) |order| {
-                            visitor.visit(
-                                order.source_index,
-                                .{
-                                    .is_server = with_server,
-                                    .is_client = with_client,
-                                },
-                                with_code_splitting,
-                            );
-                        }
-                    },
+            inline else => |with_code_splitting| switch (this.graph.is_scb_bitset.bit_length > 0) {
+                inline else => |with_scb| {
+                    visitor.visit(Index.runtime.value, with_code_splitting, with_scb);
+
+                    for (chunk_order_array.items) |order| {
+                        visitor.visit(order.source_index, with_code_splitting, with_scb);
+                    }
                 },
             },
         }
 
         const parts_in_chunk_order = try this.allocator.alloc(PartRange, visitor.part_ranges.items.len + visitor.parts_prefix.items.len);
-        bun.concat(
-            PartRange,
-            parts_in_chunk_order,
-            &.{ visitor.parts_prefix.items, visitor.part_ranges.items },
-        );
+        bun.concat(PartRange, parts_in_chunk_order, &.{
+            visitor.parts_prefix.items,
+            visitor.part_ranges.items,
+        });
         chunk.content.javascript.files_in_chunk_order = visitor.files.items;
-
         chunk.content.javascript.parts_in_chunk_in_order = parts_in_chunk_order;
     }
 
+    // CSS files are traversed in depth-first postorder just like JavaScript. But
+    // unlike JavaScript import statements, CSS "@import" rules are evaluated every
+    // time instead of just the first time.
+    //
+    //      A
+    //     / \
+    //    B   C
+    //     \ /
+    //      D
+    //
+    // If A imports B and then C, B imports D, and C imports D, then the CSS
+    // traversal order is D B D C A.
+    //
+    // However, evaluating a CSS file multiple times is sort of equivalent to
+    // evaluating it once at the last location. So we basically drop all but the
+    // last evaluation in the order.
+    //
+    // The only exception to this is "@layer". Evaluating a CSS file multiple
+    // times is sort of equivalent to evaluating it once at the first location
+    // as far as "@layer" is concerned. So we may in some cases keep both the
+    // first and last locations and only write out the "@layer" information
+    // for the first location.
+    pub fn findImportedFilesInCSSOrder(this: *LinkerContext, temp_allocator: std.mem.Allocator, entry_points: []const Index) BabyList(Chunk.CssImportOrder) {
+        const Visitor = struct {
+            allocator: std.mem.Allocator,
+            temp_allocator: std.mem.Allocator,
+            css_asts: []?*bun.css.BundlerStyleSheet,
+            all_import_records: []const BabyList(ImportRecord),
+
+            graph: *LinkerGraph,
+            parse_graph: *Graph,
+
+            has_external_import: bool = false,
+            visited: BabyList(Index),
+            order: BabyList(Chunk.CssImportOrder) = .{},
+
+            pub fn visit(
+                visitor: *@This(),
+                source_index: Index,
+                wrapping_conditions: *BabyList(bun.css.ImportConditions),
+                wrapping_import_records: *BabyList(*const ImportRecord),
+            ) void {
+                // The CSS specification strangely does not describe what to do when there
+                // is a cycle. So we are left with reverse-engineering the behavior from a
+                // real browser. Here's what the WebKit code base has to say about this:
+                //
+                //   "Check for a cycle in our import chain. If we encounter a stylesheet
+                //   in our parent chain with the same URL, then just bail."
+                //
+                // So that's what we do here. See "StyleRuleImport::requestStyleSheet()" in
+                // WebKit for more information.
+                for (visitor.visited.slice()) |visitedSourceIndex| {
+                    if (visitedSourceIndex.get() == source_index.get()) {
+                        return;
+                    }
+                }
+
+                visitor.visited.push(
+                    visitor.temp_allocator,
+                    source_index,
+                ) catch bun.outOfMemory();
+
+                const repr: *const bun.css.BundlerStyleSheet = visitor.css_asts[source_index.get()] orelse return; // Sanity check
+                const top_level_rules = &repr.rules;
+
+                // TODO: should we even do this? @import rules have to be the first rules in the stylesheet, why even allow pre-import layers?
+                // Any pre-import layers come first
+                // if len(repr.AST.LayersPreImport) > 0 {
+                //     order = append(order, cssImportOrder{
+                //         kind:                   cssImportLayers,
+                //         layers:                 repr.AST.LayersPreImport,
+                //         conditions:             wrappingConditions,
+                //         conditionImportRecords: wrappingImportRecords,
+                //     })
+                // }
+
+                defer {
+                    _ = visitor.visited.popOrNull();
+                }
+
+                // Iterate over the top-level "@import" rules
+                var import_record_idx: usize = 0;
+                for (top_level_rules.v.items) |*rule| {
+                    if (rule.* == .import) {
+                        defer import_record_idx += 1;
+                        const record = visitor.all_import_records[source_index.get()].at(import_record_idx);
+
+                        // Follow internal dependencies
+                        if (record.source_index.isValid()) {
+                            // TODO: conditions
+                            // If this import has conditions, fork our state so that the entire
+                            // imported stylesheet subtree is wrapped in all of the conditions
+                            if (rule.import.hasConditions()) {
+                                // Fork our state
+                                var nested_conditions = wrapping_conditions.deepClone2(visitor.allocator);
+                                // var nested_import_records = wrapping_import_records.deepClone(visitor.allocator) catch bun.outOfMemory();
+                                // _ = nested_import_records; // autofix
+
+                                // Clone these import conditions and append them to the state
+                                nested_conditions.push(visitor.allocator, rule.import.conditionsOwned(visitor.allocator)) catch bun.outOfMemory();
+                                visitor.visit(record.source_index, &nested_conditions, wrapping_import_records);
+                                continue;
+                            }
+                            visitor.visit(record.source_index, wrapping_conditions, wrapping_import_records);
+                            continue;
+                        }
+
+                        // TODO
+                        // Record external depednencies
+                        if (!record.is_internal) {
+
+                            // If this import has conditions, append it to the list of overall
+                            // conditions for this external import. Note that an external import
+                            // may actually have multiple sets of conditions that can't be
+                            // merged. When this happens we need to generate a nested imported
+                            // CSS file using a data URL.
+                            if (rule.import.hasConditions()) {
+                                var all_conditions = wrapping_conditions.deepClone2(visitor.allocator);
+                                all_conditions.push(visitor.allocator, rule.import.conditionsOwned(visitor.allocator)) catch bun.outOfMemory();
+                                visitor.order.push(
+                                    visitor.allocator,
+                                    Chunk.CssImportOrder{
+                                        .kind = .{
+                                            .external_path = record.path,
+                                        },
+                                        .conditions = all_conditions,
+                                        // .condition_import_records = wrapping_import_records.*,
+                                    },
+                                ) catch bun.outOfMemory();
+                            } else {
+                                visitor.order.push(
+                                    visitor.allocator,
+                                    Chunk.CssImportOrder{
+                                        .kind = .{
+                                            .external_path = record.path,
+                                        },
+                                        .conditions = wrapping_conditions.*,
+                                        // .condition_import_records = visitor.all,
+                                    },
+                                ) catch bun.outOfMemory();
+                            }
+                            visitor.has_external_import = true;
+                        }
+                    }
+                }
+
+                // TODO: composes?
+
+                if (comptime bun.Environment.isDebug) {
+                    debug(
+                        "Looking at file: {d}={s}",
+                        .{ source_index.get(), visitor.parse_graph.input_files.items(.source)[source_index.get()].path.pretty },
+                    );
+                    for (visitor.visited.slice()) |idx| {
+                        debug(
+                            "Visit: {d}",
+                            .{idx.get()},
+                        );
+                    }
+                }
+                // Accumulate imports in depth-first postorder
+                visitor.order.push(visitor.allocator, Chunk.CssImportOrder{
+                    .kind = .{ .source_index = source_index },
+                    .conditions = wrapping_conditions.*,
+                }) catch bun.outOfMemory();
+            }
+        };
+
+        var visitor = Visitor{
+            .allocator = this.allocator,
+            .temp_allocator = temp_allocator,
+            .graph = &this.graph,
+            .parse_graph = this.parse_graph,
+            .visited = BabyList(Index).initCapacity(temp_allocator, 16) catch bun.outOfMemory(),
+            .css_asts = this.graph.ast.items(.css),
+            .all_import_records = this.graph.ast.items(.import_records),
+        };
+        var wrapping_conditions: BabyList(bun.css.ImportConditions) = .{};
+        var wrapping_import_records: BabyList(*const ImportRecord) = .{};
+        // Include all files reachable from any entry point
+        for (entry_points) |entry_point| {
+            visitor.visit(entry_point, &wrapping_conditions, &wrapping_import_records);
+        }
+
+        var order = visitor.order;
+        var wip_order = BabyList(Chunk.CssImportOrder).initCapacity(temp_allocator, order.len) catch bun.outOfMemory();
+
+        // CSS syntax unfortunately only allows "@import" rules at the top of the
+        // file. This means we must hoist all external "@import" rules to the top of
+        // the file when bundling, even though doing so will change the order of CSS
+        // evaluation.
+        if (visitor.has_external_import) {
+            // Pass 1: Pull out leading "@layer" and external "@import" rules
+            var is_at_layer_prefix = true;
+            for (order.slice()) |*entry| {
+                if ((entry.kind == .layers and is_at_layer_prefix) or entry.kind == .external_path) {
+                    wip_order.push(temp_allocator, entry.*) catch bun.outOfMemory();
+                }
+                if (entry.kind != .layers) {
+                    is_at_layer_prefix = false;
+                }
+            }
+
+            // Pass 2: Append everything that we didn't pull out in pass 1
+            is_at_layer_prefix = true;
+            for (order.slice()) |*entry| {
+                if ((entry.kind != .layers or !is_at_layer_prefix) and entry.kind != .external_path) {
+                    wip_order.push(temp_allocator, entry.*) catch bun.outOfMemory();
+                }
+                if (entry.kind != .layers) {
+                    is_at_layer_prefix = false;
+                }
+            }
+
+            order.len = wip_order.len;
+            @memcpy(order.slice(), wip_order.slice());
+            wip_order.clearRetainingCapacity();
+        }
+
+        // Next, optimize import order. If there are duplicate copies of an imported
+        // file, replace all but the last copy with just the layers that are in that
+        // file. This works because in CSS, the last instance of a declaration
+        // overrides all previous instances of that declaration.
+        {
+            var source_index_duplicates = std.AutoArrayHashMap(u32, BabyList(u32)).init(temp_allocator);
+            var external_path_duplicates = std.StringArrayHashMap(BabyList(u32)).init(temp_allocator);
+
+            var i: u32 = visitor.order.len;
+            next_backward: while (i != 0) {
+                i -= 1;
+                const entry = visitor.order.at(i);
+                switch (entry.kind) {
+                    .source_index => |idx| {
+                        const gop = source_index_duplicates.getOrPut(idx.get()) catch bun.outOfMemory();
+                        if (!gop.found_existing) {
+                            gop.value_ptr.* = BabyList(u32){};
+                        }
+                        for (gop.value_ptr.slice()) |j| {
+                            // TODO: check conditions are redundant
+                            if (isConditionalImportRedundant(&entry.conditions, &order.at(j).conditions)) {
+                                order.mut(i).kind = .{
+                                    .layers = &.{},
+                                };
+                                continue :next_backward;
+                            }
+                        }
+                        gop.value_ptr.push(temp_allocator, i) catch bun.outOfMemory();
+                    },
+                    .external_path => |p| {
+                        const gop = external_path_duplicates.getOrPut(p.text) catch bun.outOfMemory();
+                        if (!gop.found_existing) {
+                            gop.value_ptr.* = BabyList(u32){};
+                        }
+                        for (gop.value_ptr.slice()) |j| {
+                            // TODO: check conditions are redundant
+                            if (isConditionalImportRedundant(&entry.conditions, &order.at(j).conditions)) {
+                                // Don't remove duplicates entirely. The import conditions may
+                                // still introduce layers to the layer order. Represent this as a
+                                // file with an empty layer list.
+                                order.mut(i).kind = .{
+                                    .layers = &.{},
+                                };
+                                continue :next_backward;
+                            }
+                        }
+                        gop.value_ptr.push(temp_allocator, i) catch bun.outOfMemory();
+                    },
+                    .layers => {},
+                }
+            }
+        }
+
+        // TODO: layers
+        // Then optimize "@layer" rules by removing redundant ones. This loop goes
+        // forward instead of backward because "@layer" takes effect at the first
+        // copy instead of the last copy like other things in CSS.
+
+        // TODO: layers
+        // Finally, merge adjacent "@layer" rules with identical conditions together.
+
+        if (bun.Environment.isDebug) {
+            debug("CSS order:\n", .{});
+            for (order.slice(), 0..) |entry, i| {
+                debug("  {d}: {}\n", .{ i, entry });
+            }
+        }
+
+        return order;
+    }
+
+    // Given two "@import" rules for the same source index (an earlier one and a
+    // later one), the earlier one is masked by the later one if the later one's
+    // condition list is a prefix of the earlier one's condition list.
+    //
+    // For example:
+    //
+    //    // entry.css
+    //    @import "foo.css" supports(display: flex);
+    //    @import "bar.css" supports(display: flex);
+    //
+    //    // foo.css
+    //    @import "lib.css" screen;
+    //
+    //    // bar.css
+    //    @import "lib.css";
+    //
+    // When we bundle this code we'll get an import order as follows:
+    //
+    //  1. lib.css [supports(display: flex), screen]
+    //  2. foo.css [supports(display: flex)]
+    //  3. lib.css [supports(display: flex)]
+    //  4. bar.css [supports(display: flex)]
+    //  5. entry.css []
+    //
+    // For "lib.css", the entry with the conditions [supports(display: flex)] should
+    // make the entry with the conditions [supports(display: flex), screen] redundant.
+    //
+    // Note that all of this deliberately ignores the existence of "@layer" because
+    // that is handled separately. All of this is only for handling unlayered styles.
+    pub fn isConditionalImportRedundant(earlier: *const BabyList(bun.css.ImportConditions), later: *const BabyList(bun.css.ImportConditions)) bool {
+        if (later.len > earlier.len) return false;
+
+        for (0..later.len) |i| {
+            const a = earlier.at(i);
+            const b = later.at(i);
+
+            // Only compare "@supports" and "@media" if "@layers" is equal
+            if (a.layersEql(b)) {
+                // TODO: supports
+                // TODO: media
+                const same_supports = true;
+                const same_media = true;
+
+                // If the import conditions are exactly equal, then only keep
+                // the later one. The earlier one is redundant. Example:
+                //
+                //   @import "foo.css" layer(abc) supports(display: flex) screen;
+                //   @import "foo.css" layer(abc) supports(display: flex) screen;
+                //
+                // The later one makes the earlier one redundant.
+                if (same_supports and same_media) {
+                    continue;
+                }
+
+                // If the media conditions are exactly equal and the later one
+                // doesn't have any supports conditions, then the later one will
+                // apply in all cases where the earlier one applies. Example:
+                //
+                //   @import "foo.css" layer(abc) supports(display: flex) screen;
+                //   @import "foo.css" layer(abc) screen;
+                //
+                // The later one makes the earlier one redundant.
+                if (same_media and b.supports == null) {
+                    continue;
+                }
+
+                // If the supports conditions are exactly equal and the later one
+                // doesn't have any media conditions, then the later one will
+                // apply in all cases where the earlier one applies. Example:
+                //
+                //   @import "foo.css" layer(abc) supports(display: flex) screen;
+                //   @import "foo.css" layer(abc) supports(display: flex);
+                //
+                // The later one makes the earlier one redundant.
+                if (same_supports and b.media.media_queries.items.len == 0) {
+                    continue;
+                }
+            }
+
+            return false;
+        }
+
+        return true;
+    }
+
+    // JavaScript modules are traversed in depth-first postorder. This is the
+    // order that JavaScript modules were evaluated in before the top-level await
+    // feature was introduced.
+    //
+    //      A
+    //     / \
+    //    B   C
+    //     \ /
+    //      D
+    //
+    // If A imports B and then C, B imports D, and C imports D, then the JavaScript
+    // traversal order is D B C A.
+    //
+    // This function may deviate from ESM import order for dynamic imports (both
+    // "require()" and "import()"). This is because the import order is impossible
+    // to determine since the imports happen at run-time instead of compile-time.
+    // In this case we just pick an arbitrary but consistent order.
+    pub fn findImportedCSSFilesInJSOrder(this: *LinkerContext, temp_allocator: std.mem.Allocator, entry_point: Index) BabyList(Index) {
+        var visited = BitSet.initEmpty(temp_allocator, this.graph.files.len) catch bun.outOfMemory();
+        var order: BabyList(Index) = .{};
+
+        const all_import_records = this.graph.ast.items(.import_records);
+        const all_loaders = this.parse_graph.input_files.items(.loader);
+
+        const visit = struct {
+            fn visit(
+                c: *LinkerContext,
+                import_records: []const BabyList(ImportRecord),
+                loaders: []const Loader,
+                temp: std.mem.Allocator,
+                visits: *BitSet,
+                o: *BabyList(Index),
+                source_index: Index,
+                is_css: bool,
+            ) void {
+                if (visits.isSet(source_index.get())) return;
+                visits.set(source_index.get());
+
+                const records: []ImportRecord = import_records[source_index.get()].slice();
+
+                for (records) |record| {
+                    if (record.source_index.isValid()) {
+                        // Traverse any files imported by this part. Note that CommonJS calls
+                        // to "require()" count as imports too, sort of as if the part has an
+                        // ESM "import" statement in it. This may seem weird because ESM imports
+                        // are a compile-time concept while CommonJS imports are a run-time
+                        // concept. But we don't want to manipulate <style> tags at run-time so
+                        // this is the only way to do it.
+                        visit(
+                            c,
+                            import_records,
+                            loaders,
+                            temp,
+                            visits,
+                            o,
+                            record.source_index,
+                            loaders[record.source_index.get()] == .css,
+                        );
+                    }
+                }
+
+                if (is_css and source_index.isValid()) {
+                    o.push(temp, source_index) catch bun.outOfMemory();
+                }
+            }
+        }.visit;
+
+        // Include all files reachable from the entry point
+        visit(
+            this,
+            all_import_records,
+            all_loaders,
+            temp_allocator,
+            &visited,
+            &order,
+            entry_point,
+            false,
+        );
+
+        return order;
+    }
+
     pub fn generateNamedExportInFile(this: *LinkerContext, source_index: Index.Int, module_ref: Ref, name: []const u8, alias: []const u8) !struct { Ref, u32 } {
         const ref = this.graph.generateNewSymbol(source_index, .other, name);
         const part_index = this.graph.addPartToFile(source_index, .{
@@ -4743,6 +6790,21 @@ pub const LinkerContext = struct {
                     expr,
                 );
                 try this.graph.generateSymbolImportAndUse(source_index, 0, module_ref, 1, Index.init(source_index));
+
+                // If this is a .napi addon and it's not node, we need to generate a require() call to the runtime
+                if (expr.data == .e_call and expr.data.e_call.target.data == .e_require_call_target and
+                    // if it's commonjs, use require()
+                    this.options.output_format != .cjs and
+                    // if it's esm and bun, use import.meta.require(). the code for __require is not injected into the bundle.
+                    !this.options.target.isBun())
+                {
+                    this.graph.generateRuntimeSymbolImportAndUse(
+                        source_index,
+                        Index.part(1),
+                        "__require",
+                        1,
+                    ) catch {};
+                }
             },
             else => {
                 // Otherwise, generate ES6 export statements. These are added as additional
@@ -4846,10 +6908,18 @@ pub const LinkerContext = struct {
             var named_imports: []js_ast.Ast.NamedImports = this.graph.ast.items(.named_imports);
             var flags: []JSMeta.Flags = this.graph.meta.items(.flags);
 
+            const tla_keywords = this.parse_graph.ast.items(.top_level_await_keyword);
+            const tla_checks = this.parse_graph.ast.items(.tla_check);
+            const input_files = this.parse_graph.input_files.items(.source);
+
             const export_star_import_records: [][]u32 = this.graph.ast.items(.export_star_import_records);
             const exports_refs: []Ref = this.graph.ast.items(.exports_ref);
             const module_refs: []Ref = this.graph.ast.items(.module_ref);
             const ast_flags_list = this.graph.ast.items(.flags);
+
+            const urls_for_css = this.graph.ast.items(.url_for_css);
+            const css_asts: []?*bun.css.BundlerStyleSheet = this.graph.ast.items(.css);
+
             var symbols = &this.graph.symbols;
             defer this.graph.symbols = symbols.*;
 
@@ -4863,6 +6933,30 @@ pub const LinkerContext = struct {
                 if (!(id < import_records_list.len)) continue;
 
                 const import_records: []ImportRecord = import_records_list[id].slice();
+
+                // Is it CSS?
+                if (css_asts[id]) |css| {
+                    _ = css; // autofix
+                    // Inline URLs for non-CSS files into the CSS file
+                    for (import_records, 0..) |*record, import_record_idx| {
+                        _ = import_record_idx; // autofix
+                        if (record.source_index.isValid()) {
+                            // Other file is not CSS
+                            if (css_asts[record.source_index.get()] == null) {
+                                if (urls_for_css[record.source_index.get()]) |url| {
+                                    record.path.text = url;
+                                }
+                            }
+                        }
+                        // else if (record.copy_source_index.isValid()) {}
+                    }
+                    // TODO:
+                    // Validate cross-file "composes: ... from" named imports
+                    continue;
+                }
+
+                _ = this.validateTLA(id, tla_keywords, tla_checks, input_files, import_records, flags);
+
                 for (import_records) |record| {
                     if (!record.source_index.isValid()) {
                         continue;
@@ -5196,7 +7290,7 @@ pub const LinkerContext = struct {
 
                 const string_buffer_len: usize = brk: {
                     var count: usize = 0;
-                    if (is_entry_point and this.options.output_format == .esm) {
+                    if (is_entry_point and output_format == .esm) {
                         for (aliases) |alias| {
                             count += std.fmt.count("export_{}", .{bun.fmt.fmtIdentifier(alias)});
                         }
@@ -5211,7 +7305,7 @@ pub const LinkerContext = struct {
                         count += "init_".len + ident_fmt_len;
                     }
 
-                    if (wrap != .cjs and export_kind != .cjs and this.options.output_format != .internal_kit_dev) {
+                    if (wrap != .cjs and export_kind != .cjs and output_format != .internal_bake_dev) {
                         count += "exports_".len + ident_fmt_len;
                         count += "module_".len + ident_fmt_len;
                     }
@@ -5231,7 +7325,7 @@ pub const LinkerContext = struct {
                 // Pre-generate symbols for re-exports CommonJS symbols in case they
                 // are necessary later. This is done now because the symbols map cannot be
                 // mutated later due to parallelism.
-                if (is_entry_point and this.options.output_format == .esm) {
+                if (is_entry_point and output_format == .esm) {
                     const copies = this.allocator.alloc(Ref, aliases.len) catch unreachable;
 
                     for (aliases, copies) |alias, *copy| {
@@ -5259,7 +7353,7 @@ pub const LinkerContext = struct {
                 // actual CommonJS files from being renamed. This is purely about
                 // aesthetics and is not about correctness. This is done here because by
                 // this point, we know the CommonJS status will not change further.
-                if (wrap != .cjs and export_kind != .cjs and this.options.output_format != .internal_kit_dev) {
+                if (wrap != .cjs and export_kind != .cjs and output_format != .internal_bake_dev) {
                     const exports_name = builder.fmt("exports_{}", .{source.fmtIdentifier()});
                     const module_name = builder.fmt("module_{}", .{source.fmtIdentifier()});
 
@@ -5407,7 +7501,7 @@ pub const LinkerContext = struct {
                     this.graph.meta.items(.entry_point_part_index)[id] = Index.part(entry_point_part_index);
 
                     // Pull in the "__toCommonJS" symbol if we need it due to being an entry point
-                    if (force_include_exports and this.options.output_format != .internal_kit_dev) {
+                    if (force_include_exports and output_format != .internal_bake_dev) {
                         this.graph.generateRuntimeSymbolImportAndUse(
                             source_index,
                             Index.part(entry_point_part_index),
@@ -5434,7 +7528,7 @@ pub const LinkerContext = struct {
 
                         // Don't follow external imports (this includes import() expressions)
                         if (!record.source_index.isValid() or this.isExternalDynamicImport(record, source_index)) {
-                            if (this.options.output_format == .internal_kit_dev) continue;
+                            if (output_format == .internal_bake_dev) continue;
 
                             // This is an external import. Check if it will be a "require()" call.
                             if (kind == .require or !output_format.keepES6ImportExportSyntax() or kind == .dynamic) {
@@ -5456,7 +7550,6 @@ pub const LinkerContext = struct {
                                     // generating a CommonJS output file, since it won't exist otherwise.
                                     // Disabled for target bun because `import.meta.require` will be inlined.
                                     if (shouldCallRuntimeRequire(output_format) and !this.resolver.opts.target.isBun()) {
-                                        record.calls_runtime_require = true;
                                         runtime_require_uses += 1;
                                     }
 
@@ -5473,7 +7566,6 @@ pub const LinkerContext = struct {
                                     // - The "default" and "__esModule" exports must not be accessed
                                     //
                                     if (kind != .require and
-                                        false and // TODO: c.options.UnsupportedJSFeatures.Has(compat.DynamicImport)
                                         (kind != .stmt or
                                         record.contains_import_star or
                                         record.contains_default_alias or
@@ -5507,7 +7599,7 @@ pub const LinkerContext = struct {
 
                             // This is an ES6 import of a CommonJS module, so it needs the
                             // "__toESM" wrapper as long as it's not a bare "require()"
-                            if (kind != .require and other_export_kind == .cjs and this.options.output_format != .internal_kit_dev) {
+                            if (kind != .require and other_export_kind == .cjs and output_format != .internal_bake_dev) {
                                 record.wrap_with_to_esm = true;
                                 to_esm_uses += 1;
                             }
@@ -5603,7 +7695,7 @@ pub const LinkerContext = struct {
                         }
                     }
 
-                    if (this.options.output_format != .internal_kit_dev) {
+                    if (output_format != .internal_bake_dev) {
                         // If there's an ES6 import of a CommonJS module, then we're going to need the
                         // "__toESM" symbol from the runtime to wrap the result of "require()"
                         this.graph.generateRuntimeSymbolImportAndUse(
@@ -5669,7 +7761,9 @@ pub const LinkerContext = struct {
         var ns_export_symbol_uses = js_ast.Part.SymbolUseMap{};
         ns_export_symbol_uses.ensureTotalCapacity(allocator, export_aliases.len) catch bun.outOfMemory();
 
-        const needs_exports_variable = c.graph.meta.items(.flags)[id].needs_exports_variable;
+        const initial_flags = c.graph.meta.items(.flags)[id];
+        const needs_exports_variable = initial_flags.needs_exports_variable;
+        const force_include_exports_for_entry_point = c.options.output_format == .cjs and initial_flags.force_include_exports_for_entry_point;
 
         const stmts_count =
             // 1 statement for every export
@@ -5677,7 +7771,9 @@ pub const LinkerContext = struct {
             // + 1 if there are non-zero exports
             @as(usize, @intFromBool(export_aliases.len > 0)) +
             // + 1 if we need to inject the exports variable
-            @as(usize, @intFromBool(needs_exports_variable));
+            @as(usize, @intFromBool(needs_exports_variable)) +
+            // + 1 if we need to do module.exports = __toCommonJS(exports)
+            @as(usize, @intFromBool(force_include_exports_for_entry_point));
 
         var stmts = js_ast.Stmt.Batcher.init(allocator, stmts_count) catch bun.outOfMemory();
         defer stmts.done();
@@ -5769,7 +7865,9 @@ pub const LinkerContext = struct {
 
         var declared_symbols = js_ast.DeclaredSymbol.List{};
         const exports_ref = c.graph.ast.items(.exports_ref)[id];
-        const all_export_stmts: []js_ast.Stmt = stmts.head[0 .. @as(usize, @intFromBool(needs_exports_variable)) + @as(usize, @intFromBool(properties.items.len > 0))];
+        const all_export_stmts: []js_ast.Stmt = stmts.head[0 .. @as(usize, @intFromBool(needs_exports_variable)) +
+            @as(usize, @intFromBool(properties.items.len > 0) +
+            @as(usize, @intFromBool(force_include_exports_for_entry_point)))];
         stmts.head = stmts.head[all_export_stmts.len..];
         var remaining_stmts = all_export_stmts;
         defer bun.assert(remaining_stmts.len == 0); // all must be used
@@ -5802,7 +7900,7 @@ pub const LinkerContext = struct {
         // "__export(exports, { foo: () => foo })"
         var export_ref = Ref.None;
         if (properties.items.len > 0) {
-            export_ref = c.graph.ast.items(.module_scope)[Index.runtime.get()].members.get("__export").?.ref;
+            export_ref = c.runtimeFunction("__export");
             var args = allocator.alloc(js_ast.Expr, 2) catch unreachable;
             args[0..2].* = [_]js_ast.Expr{
                 js_ast.Expr.initIdentifier(exports_ref, loc),
@@ -5838,6 +7936,40 @@ pub const LinkerContext = struct {
             c.graph.ast.items(.flags)[id].uses_exports_ref = true;
         }
 
+        // Decorate "module.exports" with the "__esModule" flag to indicate that
+        // we used to be an ES module. This is done by wrapping the exports object
+        // instead of by mutating the exports object because other modules in the
+        // bundle (including the entry point module) may do "import * as" to get
+        // access to the exports object and should NOT see the "__esModule" flag.
+        if (force_include_exports_for_entry_point) {
+            const toCommonJSRef = c.runtimeFunction("__toCommonJS");
+
+            var call_args = allocator.alloc(js_ast.Expr, 1) catch unreachable;
+            call_args[0] = Expr.initIdentifier(exports_ref, Loc.Empty);
+            remaining_stmts[0] = js_ast.Stmt.assign(
+                Expr.allocate(
+                    allocator,
+                    E.Dot,
+                    E.Dot{
+                        .name = "exports",
+                        .name_loc = Loc.Empty,
+                        .target = Expr.initIdentifier(c.unbound_module_ref, Loc.Empty),
+                    },
+                    Loc.Empty,
+                ),
+                Expr.allocate(
+                    allocator,
+                    E.Call,
+                    E.Call{
+                        .target = Expr.initIdentifier(toCommonJSRef, Loc.Empty),
+                        .args = js_ast.ExprNodeList.init(call_args),
+                    },
+                    Loc.Empty,
+                ),
+            );
+            remaining_stmts = remaining_stmts[1..];
+        }
+
         // No need to generate a part if it'll be empty
         if (all_export_stmts.len > 0) {
             // - we must already have preallocated the parts array
@@ -5846,7 +7978,7 @@ pub const LinkerContext = struct {
             // Initialize the part that was allocated for us earlier. The information
             // here will be used after this during tree shaking.
             c.graph.ast.items(.parts)[id].slice()[js_ast.namespace_export_part_index] = .{
-                .stmts = if (c.options.output_format != .internal_kit_dev) all_export_stmts else &.{},
+                .stmts = if (c.options.output_format != .internal_bake_dev) all_export_stmts else &.{},
                 .symbol_uses = ns_export_symbol_uses,
                 .dependencies = js_ast.Dependency.List.fromList(ns_export_dependencies),
                 .declared_symbols = declared_symbols,
@@ -6116,6 +8248,7 @@ pub const LinkerContext = struct {
 
         const parts = c.graph.ast.items(.parts);
         const import_records = c.graph.ast.items(.import_records);
+        const css_reprs = c.graph.ast.items(.css);
         const side_effects = c.parse_graph.input_files.items(.side_effects);
         const entry_point_kinds = c.graph.files.items(.entry_point_kind);
         const entry_points = c.graph.entry_points.items(.source_index);
@@ -6124,6 +8257,7 @@ pub const LinkerContext = struct {
         {
             const trace2 = tracer(@src(), "markFileLiveForTreeShaking");
             defer trace2.end();
+
             // Tree shaking: Each entry point marks all files reachable from itself
             for (entry_points) |entry_point| {
                 c.markFileLiveForTreeShaking(
@@ -6132,6 +8266,7 @@ pub const LinkerContext = struct {
                     parts,
                     import_records,
                     entry_point_kinds,
+                    css_reprs,
                 );
             }
         }
@@ -6164,6 +8299,7 @@ pub const LinkerContext = struct {
                     parts,
                     import_records,
                     file_entry_bits,
+                    css_reprs,
                 );
             }
         }
@@ -6199,6 +8335,10 @@ pub const LinkerContext = struct {
 
             // Go over each file in this chunk
             for (chunk.files_with_parts_in_chunk.keys()) |source_index| {
+                // TODO: make this switch
+                if (chunk.content == .css) {
+                    continue;
+                }
                 if (chunk.content != .javascript) continue;
 
                 // Go over each part in this file that's marked for inclusion in this chunk
@@ -6377,18 +8517,6 @@ pub const LinkerContext = struct {
                     if (other_chunk_index == chunk_index or other_chunk.content != .javascript) continue;
 
                     if (other_chunk.entry_bits.isSet(chunk.entry_point.entry_point_id)) {
-                        if (other_chunk.entry_point.is_entry_point) {
-                            if (c.graph.react_client_component_boundary.bit_length > 0 or c.graph.react_server_component_boundary.bit_length > 0) {
-                                const other_kind = c.graph.files.items(.entry_point_kind)[other_chunk.entry_point.source_index];
-                                const this_kind = c.graph.files.items(.entry_point_kind)[chunk.entry_point.source_index];
-
-                                if (this_kind != .react_client_component and
-                                    other_kind.isReactReference())
-                                {
-                                    continue;
-                                }
-                            }
-                        }
                         _ = js.imports_from_other_chunks.getOrPutValue(
                             c.allocator,
                             @as(u32, @truncate(other_chunk_index)),
@@ -6612,11 +8740,14 @@ pub const LinkerContext = struct {
         chunks: []Chunk,
         chunk: *Chunk,
     };
-    fn generateChunkJS(ctx: GenerateChunkCtx, chunk: *Chunk, chunk_index: usize) void {
+    fn generateChunk(ctx: GenerateChunkCtx, chunk: *Chunk, chunk_index: usize) void {
         defer ctx.wg.finish();
         const worker = ThreadPool.Worker.get(@fieldParentPtr("linker", ctx.c));
         defer worker.unget();
-        postProcessJSChunk(ctx, worker, chunk, chunk_index) catch |err| Output.panic("TODO: handle error: {s}", .{@errorName(err)});
+        switch (chunk.content) {
+            .javascript => postProcessJSChunk(ctx, worker, chunk, chunk_index) catch |err| Output.panic("TODO: handle error: {s}", .{@errorName(err)}),
+            .css => postProcessCSSChunk(ctx, worker, chunk) catch |err| Output.panic("TODO: handle error: {s}", .{@errorName(err)}),
+        }
     }
 
     // TODO: investigate if we need to parallelize this function
@@ -6635,7 +8766,7 @@ pub const LinkerContext = struct {
         const all_wrapper_refs: []const Ref = c.graph.ast.items(.wrapper_ref);
         const all_import_records: []const ImportRecord.List = c.graph.ast.items(.import_records);
 
-        var reserved_names = try renamer.computeInitialReservedNames(allocator);
+        var reserved_names = try renamer.computeInitialReservedNames(allocator, c.options.output_format);
         for (files_in_order) |source_index| {
             renamer.computeReservedNamesForScope(&all_module_scopes[source_index], &c.graph.symbols, &reserved_names, allocator);
         }
@@ -6877,7 +9008,10 @@ pub const LinkerContext = struct {
         defer ctx.wg.finish();
         var worker = ThreadPool.Worker.get(@fieldParentPtr("linker", ctx.c));
         defer worker.unget();
-        generateJSRenamer_(ctx, worker, chunk, chunk_index);
+        switch (chunk.content) {
+            .javascript => generateJSRenamer_(ctx, worker, chunk, chunk_index),
+            .css => {},
+        }
     }
 
     fn generateJSRenamer_(ctx: GenerateChunkCtx, worker: *ThreadPool.Worker, chunk: *Chunk, chunk_index: usize) void {
@@ -6889,6 +9023,99 @@ pub const LinkerContext = struct {
         ) catch @panic("TODO: handle error");
     }
 
+    fn generateCompileResultForCssChunk(task: *ThreadPoolLib.Task) void {
+        const part_range: *const PendingPartRange = @fieldParentPtr("task", task);
+        const ctx = part_range.ctx;
+        defer ctx.wg.finish();
+        var worker = ThreadPool.Worker.get(@fieldParentPtr("linker", ctx.c));
+        defer worker.unget();
+
+        const prev_action = if (Environment.isDebug) bun.crash_handler.current_action;
+        defer if (Environment.isDebug) {
+            bun.crash_handler.current_action = prev_action;
+        };
+        if (Environment.isDebug) bun.crash_handler.current_action = .{ .bundle_generate_chunk = .{
+            .chunk = ctx.chunk,
+            .context = ctx.c,
+            .part_range = &part_range.part_range,
+        } };
+
+        ctx.chunk.compile_results_for_chunk[part_range.i] = generateCompileResultForCssChunkImpl(worker, ctx.c, ctx.chunk, part_range.i);
+    }
+
+    fn generateCompileResultForCssChunkImpl(worker: *ThreadPool.Worker, c: *LinkerContext, chunk: *Chunk, imports_in_chunk_index: u32) CompileResult {
+        const trace = tracer(@src(), "generateCodeForFileInChunkCss");
+        defer trace.end();
+
+        var arena = &worker.temporary_arena;
+        var buffer_writer = js_printer.BufferWriter.init(worker.allocator) catch unreachable;
+        defer _ = arena.reset(.retain_capacity);
+
+        const css_import = chunk.content.css.imports_in_chunk_in_order.at(imports_in_chunk_index);
+
+        switch (css_import.kind) {
+            .layers => |layers| {
+                if (layers.len > 0) {
+                    @panic("TODO: layer only import");
+                }
+                return CompileResult{
+                    .css = .{
+                        .code = &.{},
+                        .source_index = Index.invalid.get(),
+                    },
+                };
+            },
+            .external_path => |p| {
+                const import_records_ = [_]ImportRecord{
+                    ImportRecord{
+                        .kind = .at,
+                        .path = p,
+                        .range = Logger.Range.None,
+                    },
+                };
+                var import_records = BabyList(ImportRecord).init(&import_records_);
+                const css: *const bun.css.BundlerStyleSheet = &chunk.content.css.asts[imports_in_chunk_index];
+                _ = css.toCssWithWriter(
+                    worker.allocator,
+                    &buffer_writer,
+                    bun.css.PrinterOptions{
+                        // TODO: make this more configurable
+                        .minify = c.options.minify_whitespace,
+                    },
+                    &import_records,
+                ) catch {
+                    @panic("TODO: HANDLE THIS ERROR!");
+                };
+                return CompileResult{
+                    .css = .{
+                        .code = buffer_writer.getWritten(),
+                        .source_index = Index.invalid.get(),
+                    },
+                };
+            },
+            .source_index => |idx| {
+                const css: *const bun.css.BundlerStyleSheet = &chunk.content.css.asts[imports_in_chunk_index];
+                _ = css.toCssWithWriter(
+                    worker.allocator,
+                    &buffer_writer,
+                    bun.css.PrinterOptions{
+                        // TODO: make this more configurable
+                        .minify = c.options.minify_whitespace or c.options.minify_syntax or c.options.minify_identifiers,
+                    },
+                    &c.graph.ast.items(.import_records)[idx.get()],
+                ) catch {
+                    @panic("TODO: HANDLE THIS ERROR!");
+                };
+                return CompileResult{
+                    .css = .{
+                        .code = buffer_writer.getWritten(),
+                        .source_index = idx.get(),
+                    },
+                };
+            },
+        }
+    }
+
     fn generateCompileResultForJSChunk(task: *ThreadPoolLib.Task) void {
         const part_range: *const PendingPartRange = @fieldParentPtr("task", task);
         const ctx = part_range.ctx;
@@ -6906,15 +9133,29 @@ pub const LinkerContext = struct {
             .part_range = &part_range.part_range,
         } };
 
-        ctx.chunk.compile_results_for_chunk[part_range.i] = generateCompileResultForJSChunk_(worker, ctx.c, ctx.chunk, part_range.part_range);
+        if (Environment.isDebug) {
+            const path = ctx.c.parse_graph.input_files.items(.source)[part_range.part_range.source_index.get()].path;
+            if (bun.CLI.debug_flags.hasPrintBreakpoint(path)) {
+                @breakpoint();
+            }
+        }
+
+        ctx.chunk.compile_results_for_chunk[part_range.i] = generateCompileResultForJSChunkImpl(worker, ctx.c, ctx.chunk, part_range.part_range);
     }
 
-    fn generateCompileResultForJSChunk_(worker: *ThreadPool.Worker, c: *LinkerContext, chunk: *Chunk, part_range: PartRange) CompileResult {
+    fn generateCompileResultForJSChunkImpl(worker: *ThreadPool.Worker, c: *LinkerContext, chunk: *Chunk, part_range: PartRange) CompileResult {
         const trace = tracer(@src(), "generateCodeForFileInChunkJS");
         defer trace.end();
 
+        // Client bundles for Bake must be globally allocated,
+        // as it must outlive the bundle task.
+        const use_global_allocator = c.dev_server != null and
+            c.parse_graph.ast.items(.target)[part_range.source_index.get()].bakeGraph() == .client;
+
         var arena = &worker.temporary_arena;
-        var buffer_writer = js_printer.BufferWriter.init(worker.allocator) catch unreachable;
+        var buffer_writer = js_printer.BufferWriter.init(
+            if (use_global_allocator) default_allocator else worker.allocator,
+        ) catch bun.outOfMemory();
         defer _ = arena.reset(.retain_capacity);
         worker.stmt_list.reset();
 
@@ -6945,6 +9186,272 @@ pub const LinkerContext = struct {
         };
     }
 
+    const PrepareCssAstTask = struct {
+        task: ThreadPoolLib.Task,
+        chunk: *Chunk,
+        linker: *LinkerContext,
+        wg: *sync.WaitGroup,
+    };
+
+    fn prepareCssAstsForChunk(task: *ThreadPoolLib.Task) void {
+        const prepare_css_asts: *const PrepareCssAstTask = @fieldParentPtr("task", task);
+        defer prepare_css_asts.wg.finish();
+        var worker = ThreadPool.Worker.get(@fieldParentPtr("linker", prepare_css_asts.linker));
+        defer worker.unget();
+
+        prepareCssAstsForChunkImpl(prepare_css_asts.linker, prepare_css_asts.chunk, worker.allocator);
+    }
+
+    fn prepareCssAstsForChunkImpl(c: *LinkerContext, chunk: *Chunk, allocator: std.mem.Allocator) void {
+        const import_records: []const BabyList(ImportRecord) = c.graph.ast.items(.import_records);
+        _ = import_records; // autofix
+        const asts: []const ?*bun.css.BundlerStyleSheet = c.graph.ast.items(.css);
+        // Prepare CSS asts
+        // Remove duplicate rules across files. This must be done in serial, not
+        // in parallel, and must be done from the last rule to the first rule.
+        {
+            var i: usize = chunk.content.css.imports_in_chunk_in_order.len;
+            while (i != 0) {
+                i -= 1;
+                const entry = chunk.content.css.imports_in_chunk_in_order.at(i);
+                switch (entry.kind) {
+                    .layers => |layers| {
+                        if (layers.len > 0) {
+                            @panic("TODO: external path");
+                        }
+                        // asts[entry.source_index.get()].?.rules.v.len = 0;
+                    },
+                    .external_path => |p| {
+                        if (entry.conditions.len > 0) {
+                            @panic("TODO: external path with conditions");
+                            // Handling a chain of nested conditions is complicated. We can't
+                            // necessarily join them together because a) there may be multiple
+                            // layer names and b) layer names are only supposed to be inserted
+                            // into the layer order if the parent conditions are applied.
+                            //
+                            // Instead we handle them by preserving the "@import" nesting using
+                            // imports of data URL stylesheets. This may seem strange but I think
+                            // this is the only way to do this in CSS.
+                            // var i: usize = entry.conditions.len;
+                            // while (i != 0) {
+                            //     i -= 1;
+
+                            // }
+                        }
+
+                        chunk.content.css.asts[i] = bun.css.BundlerStyleSheet{
+                            .rules = rules: {
+                                var rules = bun.css.BundlerCssRuleList{};
+                                rules.v.append(allocator, bun.css.BundlerCssRule{
+                                    .import = bun.css.ImportRule.fromUrl(p.pretty),
+                                }) catch bun.outOfMemory();
+                                break :rules rules;
+                            },
+                            .sources = .{},
+                            .source_map_urls = .{},
+                            .license_comments = .{},
+                            .options = bun.css.ParserOptions.default(allocator, null),
+                        };
+                    },
+                    .source_index => |source_index| {
+                        // Multiple imports may refer to the same file/AST, but they
+                        // may wrap or modify the AST in different ways. So we need
+                        // to make a shallow copy and be careful not to modify shared
+                        // references.
+                        var ast = ast: {
+                            const original_stylesheet = asts[source_index.get()].?;
+                            chunk.content.css.asts[i] = original_stylesheet.*;
+                            break :ast &chunk.content.css.asts[i];
+                        };
+
+                        filter: {
+                            // Filter out "@charset", "@import", and leading "@layer" rules
+                            // TODO: we are doing simple version rn, only @import
+                            for (ast.rules.v.items, 0..) |*rule, ruleidx| {
+                                // if ((rule.* == .import and import_records[source_index.get()].at(rule.import.import_record_idx).is_internal) or rule.* == .ignored) {} else {
+                                if (rule.* == .import or rule.* == .ignored) {} else {
+                                    // It's okay to do this because AST is allocated into arena
+                                    const reslice = ast.rules.v.items[ruleidx..];
+                                    ast.rules.v = .{
+                                        .items = reslice,
+                                        .capacity = ast.rules.v.capacity - (ast.rules.v.items.len - reslice.len),
+                                    };
+                                    break :filter;
+                                }
+                            }
+                            ast.rules.v.items.len = 0;
+                        }
+
+                        // TODO: wrapRulesWithConditions
+                        wrapRulesWithConditions(ast, allocator, &entry.conditions, &entry.condition_import_records);
+                        // TODO: Remove top-level duplicate rules across files
+                    },
+                }
+            }
+        }
+    }
+
+    fn wrapRulesWithConditions(
+        ast: *bun.css.BundlerStyleSheet,
+        temp_allocator: std.mem.Allocator,
+        conditions: *const BabyList(bun.css.ImportConditions),
+        condition_import_records: *const BabyList(ImportRecord),
+    ) void {
+        _ = condition_import_records; // autofix
+        var i: usize = conditions.len;
+        while (i > 0) {
+            i -= 1;
+            const item = conditions.at(i);
+
+            // Generate "@layer" wrappers. Note that empty "@layer" rules still have
+            // a side effect (they set the layer order) so they cannot be removed.
+            if (item.layer) |l| {
+                if (l.v) |layer| {
+                    if (ast.rules.v.items.len == 0) {
+                        if (layer.v.isEmpty()) {
+                            // Omit an empty "@layer {}" entirely
+                            continue;
+                        } else {
+                            // Generate "@layer foo;" instead of "@layer foo {}"
+                            ast.rules.v = .{};
+                        }
+                    }
+
+                    ast.rules = brk: {
+                        var new_rules = bun.css.BundlerCssRuleList{};
+                        new_rules.v.append(
+                            temp_allocator,
+                            .{ .layer_block = bun.css.BundlerLayerBlockRule{
+                                .name = layer,
+                                .rules = ast.rules,
+                                .loc = bun.css.Location.dummy(),
+                            } },
+                        ) catch bun.outOfMemory();
+
+                        break :brk new_rules;
+                    };
+                }
+            }
+
+            // TODO: @supports wrappers
+
+            // TODO: @media wrappers
+        }
+    }
+
+    // This runs after we've already populated the compile results
+    fn postProcessCSSChunk(ctx: GenerateChunkCtx, worker: *ThreadPool.Worker, chunk: *Chunk) !void {
+        const c = ctx.c;
+        var j = StringJoiner{
+            .allocator = worker.allocator,
+            .watcher = .{
+                .input = chunk.unique_key,
+            },
+        };
+
+        var line_offset: bun.sourcemap.LineColumnOffset.Optional = if (c.options.source_maps != .none) .{ .value = .{} } else .{ .null = {} };
+
+        var newline_before_comment = false;
+
+        // TODO: css banner
+        // if len(c.options.CSSBanner) > 0 {
+        //     prevOffset.AdvanceString(c.options.CSSBanner)
+        //     j.AddString(c.options.CSSBanner)
+        //     prevOffset.AdvanceString("\n")
+        //     j.AddString("\n")
+        // }
+
+        // TODO: (this is where we would put the imports)
+        // Generate any prefix rules now
+        // (THIS SHOULD BE SET WHEN GENERATING PREFIX RULES!)
+        // newline_before_comment = true;
+
+        // TODO: meta
+
+        // Concatenate the generated CSS chunks together
+        const compile_results = chunk.compile_results_for_chunk;
+
+        var compile_results_for_source_map: std.MultiArrayList(CompileResultForSourceMap) = .{};
+        compile_results_for_source_map.setCapacity(worker.allocator, compile_results.len) catch bun.outOfMemory();
+
+        const sources: []const Logger.Source = c.parse_graph.input_files.items(.source);
+        for (compile_results) |compile_result| {
+            const source_index = compile_result.sourceIndex();
+
+            if (c.options.mode == .bundle and !c.options.minify_whitespace and Index.init(source_index).isValid()) {
+                if (newline_before_comment) {
+                    j.pushStatic("\n");
+                    line_offset.advance("\n");
+                }
+
+                const pretty = sources[source_index].path.pretty;
+
+                j.pushStatic("/* ");
+                line_offset.advance("/* ");
+
+                j.pushStatic(pretty);
+                line_offset.advance(pretty);
+
+                j.pushStatic(" */\n");
+                line_offset.advance(" */\n");
+            }
+
+            if (compile_result.code().len > 0) {
+                newline_before_comment = true;
+            }
+
+            // Save the offset to the start of the stored JavaScript
+            j.push(compile_result.code(), bun.default_allocator);
+
+            if (compile_result.source_map_chunk()) |source_map_chunk| {
+                if (c.options.source_maps != .none) {
+                    try compile_results_for_source_map.append(worker.allocator, CompileResultForSourceMap{
+                        .source_map_chunk = source_map_chunk,
+                        .generated_offset = line_offset.value,
+                        .source_index = compile_result.sourceIndex(),
+                    });
+                }
+
+                line_offset.reset();
+            } else {
+                line_offset.advance(compile_result.code());
+            }
+        }
+
+        // Make sure the file ends with a newline
+        j.ensureNewlineAtEnd();
+        // if c.options.UnsupportedCSSFeatures.Has(compat.InlineStyle) {
+        //    slashTag = ""
+        // }
+        // c.maybeAppendLegalComments(c.options.LegalComments, legalCommentList, chunk, &j, slashTag)
+
+        // if len(c.options.CSSFooter) > 0 {
+        //     j.AddString(c.options.CSSFooter)
+        //     j.AddString("\n")
+        // }
+
+        chunk.intermediate_output = c.breakOutputIntoPieces(
+            worker.allocator,
+            &j,
+            @as(u32, @truncate(ctx.chunks.len)),
+        ) catch bun.outOfMemory();
+        // TODO: meta contents
+
+        chunk.isolated_hash = c.generateIsolatedHash(chunk);
+        // chunk.is_executable = is_executable;
+
+        if (c.options.source_maps != .none) {
+            const can_have_shifts = chunk.intermediate_output == .pieces;
+            chunk.output_source_map = try c.generateSourceMapForChunk(
+                chunk.isolated_hash,
+                worker,
+                compile_results_for_source_map,
+                c.resolver.opts.output_dir,
+                can_have_shifts,
+            );
+        }
+    }
+
     // This runs after we've already populated the compile results
     fn postProcessJSChunk(ctx: GenerateChunkCtx, worker: *ThreadPool.Worker, chunk: *Chunk, chunk_index: usize) !void {
         const trace = tracer(@src(), "postProcessJSChunk");
@@ -6970,7 +9477,7 @@ pub const LinkerContext = struct {
         var runtime_members = &runtime_scope.members;
         const toCommonJSRef = c.graph.symbols.follow(runtime_members.get("__toCommonJS").?.ref);
         const toESMRef = c.graph.symbols.follow(runtime_members.get("__toESM").?.ref);
-        const runtimeRequireRef = if (c.resolver.opts.target.isBun()) null else c.graph.symbols.follow(runtime_members.get("__require").?.ref);
+        const runtimeRequireRef = if (c.resolver.opts.target.isBun() or c.options.output_format == .cjs) null else c.graph.symbols.follow(runtime_members.get("__require").?.ref);
 
         {
             const print_options = js_printer.Options{
@@ -7051,6 +9558,7 @@ pub const LinkerContext = struct {
                 .input = chunk.unique_key,
             },
         };
+        const output_format = c.options.output_format;
 
         var line_offset: bun.sourcemap.LineColumnOffset.Optional = if (c.options.source_maps != .none) .{ .value = .{} } else .{ .null = {} };
 
@@ -7075,18 +9583,50 @@ pub const LinkerContext = struct {
             }
 
             if (is_bun) {
-                j.pushStatic("// @bun\n");
-                line_offset.advance("// @bun\n");
+                const cjs_entry_chunk = "(function(exports, require, module, __filename, __dirname) {";
+                if (ctx.c.options.generate_bytecode_cache and output_format == .cjs) {
+                    const input = "// @bun @bytecode @bun-cjs\n" ++ cjs_entry_chunk;
+                    j.pushStatic(input);
+                    line_offset.advance(input);
+                } else if (ctx.c.options.generate_bytecode_cache) {
+                    j.pushStatic("// @bun @bytecode\n");
+                    line_offset.advance("// @bun @bytecode\n");
+                } else if (output_format == .cjs) {
+                    j.pushStatic("// @bun @bun-cjs\n" ++ cjs_entry_chunk);
+                    line_offset.advance("// @bun @bun-cjs\n" ++ cjs_entry_chunk);
+                } else {
+                    j.pushStatic("// @bun\n");
+                    line_offset.advance("// @bun\n");
+                }
             }
         }
 
-        // TODO: banner
+        if (c.options.banner.len > 0) {
+            if (newline_before_comment) {
+                j.pushStatic("\n");
+                line_offset.advance("\n");
+            }
+            j.pushStatic(ctx.c.options.banner);
+            line_offset.advance(ctx.c.options.banner);
+            j.pushStatic("\n");
+            line_offset.advance("\n");
+        }
 
-        // TODO: directive
+        // Add the top-level directive if present (but omit "use strict" in ES
+        // modules because all ES modules are automatically in strict mode)
+        if (chunk.isEntryPoint() and !output_format.isAlwaysStrictMode()) {
+            const flags: JSAst.Flags = c.graph.ast.items(.flags)[chunk.entry_point.source_index];
+
+            if (flags.has_explicit_use_strict_directive) {
+                j.pushStatic("\"use strict\";\n");
+                line_offset.advance("\"use strict\";\n");
+                newline_before_comment = true;
+            }
+        }
 
         // For Kit, hoist runtime.js outside of the IIFE
         const compile_results = chunk.compile_results_for_chunk;
-        if (c.options.output_format == .internal_kit_dev) {
+        if (c.options.output_format == .internal_bake_dev) {
             for (compile_results) |compile_result| {
                 const source_index = compile_result.sourceIndex();
                 if (source_index != Index.runtime.value) break;
@@ -7096,8 +9636,8 @@ pub const LinkerContext = struct {
         }
 
         switch (c.options.output_format) {
-            .internal_kit_dev => {
-                const start = bun.kit.getHmrRuntime(if (c.options.target.isBun()) .server else .client);
+            .internal_bake_dev => {
+                const start = bun.bake.getHmrRuntime(if (c.options.target.isBun()) .server else .client);
                 j.pushStatic(start);
                 line_offset.advance(start);
             },
@@ -7125,7 +9665,10 @@ pub const LinkerContext = struct {
         const show_comments = c.options.mode == .bundle and
             !c.options.minify_whitespace;
 
+        const emit_targets_in_commands = show_comments and (if (ctx.c.framework) |fw| fw.server_components != null else false);
+
         const sources: []const Logger.Source = c.parse_graph.input_files.items(.source);
+        const targets: []const options.Target = c.parse_graph.ast.items(.target);
         for (compile_results) |compile_result| {
             const source_index = compile_result.sourceIndex();
             const is_runtime = source_index == Index.runtime.value;
@@ -7156,7 +9699,7 @@ pub const LinkerContext = struct {
                     CommentType.single;
 
                 if (!c.options.minify_whitespace and
-                    (c.options.output_format == .iife or c.options.output_format == .internal_kit_dev))
+                    (output_format == .iife or output_format == .internal_bake_dev))
                 {
                     j.pushStatic("  ");
                     line_offset.advance("  ");
@@ -7176,6 +9719,16 @@ pub const LinkerContext = struct {
                 j.pushStatic(pretty);
                 line_offset.advance(pretty);
 
+                if (emit_targets_in_commands) {
+                    j.pushStatic(" (");
+                    line_offset.advance(" (");
+                    const target = @tagName(targets[source_index].bakeGraph());
+                    j.pushStatic(target);
+                    line_offset.advance(target);
+                    j.pushStatic(")");
+                    line_offset.advance(")");
+                }
+
                 switch (comment_type) {
                     .multiline => {
                         j.pushStatic(" */\n");
@@ -7189,7 +9742,7 @@ pub const LinkerContext = struct {
             }
 
             if (is_runtime) {
-                if (c.options.output_format != .internal_kit_dev) {
+                if (c.options.output_format != .internal_bake_dev) {
                     line_offset.advance(compile_result.code());
                     j.push(compile_result.code(), bun.default_allocator);
                 }
@@ -7232,7 +9785,7 @@ pub const LinkerContext = struct {
             j.push(cross_chunk_suffix, bun.default_allocator);
         }
 
-        switch (c.options.output_format) {
+        switch (output_format) {
             .iife => {
                 const without_newline = "})();";
 
@@ -7243,7 +9796,7 @@ pub const LinkerContext = struct {
 
                 j.pushStatic(with_newline);
             },
-            .internal_kit_dev => {
+            .internal_bake_dev => {
                 {
                     const str = "}, {\n  main: ";
                     j.pushStatic(str);
@@ -7251,10 +9804,9 @@ pub const LinkerContext = struct {
                 }
                 {
                     const input = c.parse_graph.input_files.items(.source)[chunk.entry_point.source_index].path;
-                    // var buf = MutableString.initEmpty(c.allocator);
-                    // js_printer.quoteForJSONBuffer(input.pretty, &buf, true) catch bun.outOfMemory();
-                    // const str = buf.toOwnedSliceLeaky(); // c.allocator is an arena
-                    const str = try std.fmt.allocPrint(c.allocator, "{d}", .{input.hashForKit()});
+                    var buf = MutableString.initEmpty(worker.allocator);
+                    js_printer.quoteForJSONBuffer(input.pretty, &buf, true) catch bun.outOfMemory();
+                    const str = buf.slice(); // worker.allocator is an arena
                     j.pushStatic(str);
                     line_offset.advance(str);
                 }
@@ -7269,13 +9821,31 @@ pub const LinkerContext = struct {
                     line_offset.advance(str);
                 }
             },
+            .cjs => {
+                if (chunk.isEntryPoint()) {
+                    const is_bun = ctx.c.graph.ast.items(.target)[chunk.entry_point.source_index].isBun();
+                    if (is_bun) {
+                        j.pushStatic("})\n");
+                        line_offset.advance("})\n");
+                    }
+                }
+            },
             else => {},
         }
 
         j.ensureNewlineAtEnd();
         // TODO: maybeAppendLegalComments
 
-        // TODO: footer
+        if (c.options.footer.len > 0) {
+            if (newline_before_comment) {
+                j.pushStatic("\n");
+                line_offset.advance("\n");
+            }
+            j.pushStatic(ctx.c.options.footer);
+            line_offset.advance(ctx.c.options.footer);
+            j.pushStatic("\n");
+            line_offset.advance("\n");
+        }
 
         chunk.intermediate_output = c.breakOutputIntoPieces(
             worker.allocator,
@@ -7465,13 +10035,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
@@ -7483,7 +10057,7 @@ pub const LinkerContext = struct {
                 };
 
                 // Include the path namespace in the hash
-                hasher.write(source.key_path.namespace);
+                hasher.write(source.path.namespace);
 
                 // Then include the file path
                 hasher.write(file_path);
@@ -7546,6 +10120,99 @@ pub const LinkerContext = struct {
         return hasher.digest();
     }
 
+    pub fn validateTLA(
+        c: *LinkerContext,
+        source_index: Index.Int,
+        tla_keywords: []Logger.Range,
+        tla_checks: []js_ast.TlaCheck,
+        input_files: []Logger.Source,
+        import_records: []ImportRecord,
+        meta_flags: []JSMeta.Flags,
+    ) js_ast.TlaCheck {
+        var result_tla_check: *js_ast.TlaCheck = &tla_checks[source_index];
+
+        if (result_tla_check.depth == 0) {
+            result_tla_check.depth = 1;
+            if (tla_keywords[source_index].len > 0) {
+                result_tla_check.parent = source_index;
+            }
+
+            for (import_records, 0..) |record, import_record_index| {
+                if (Index.isValid(record.source_index) and (record.kind == .require or record.kind == .stmt)) {
+                    const parent = c.validateTLA(record.source_index.get(), tla_keywords, tla_checks, input_files, import_records, meta_flags);
+                    if (Index.isInvalid(Index.init(parent.parent))) {
+                        continue;
+                    }
+
+                    // Follow any import chains
+                    if (record.kind == .stmt and (Index.isInvalid(Index.init(result_tla_check.parent)) or parent.depth < result_tla_check.depth)) {
+                        result_tla_check.depth = parent.depth + 1;
+                        result_tla_check.parent = record.source_index.get();
+                        result_tla_check.import_record_index = @intCast(import_record_index);
+                        continue;
+                    }
+
+                    // Require of a top-level await chain is forbidden
+                    if (record.kind == .require) {
+                        var notes = std.ArrayList(Logger.Data).init(c.allocator);
+
+                        var tla_pretty_path: string = "";
+                        var other_source_index = record.source_index.get();
+
+                        // Build up a chain of notes for all of the imports
+                        while (true) {
+                            const parent_result_tla_keyword = tla_keywords[other_source_index];
+                            const parent_tla_check = tla_checks[other_source_index];
+                            const parent_source_index = other_source_index;
+
+                            if (parent_result_tla_keyword.len > 0) {
+                                tla_pretty_path = input_files[other_source_index].path.pretty;
+                                notes.append(Logger.Data{
+                                    .text = std.fmt.allocPrint(c.allocator, "The top-level await in {s} is here:", .{tla_pretty_path}) catch bun.outOfMemory(),
+                                }) catch bun.outOfMemory();
+                                break;
+                            }
+
+                            if (!Index.isValid(Index.init(parent_tla_check.parent))) {
+                                notes.append(Logger.Data{
+                                    .text = "unexpected invalid index",
+                                }) catch bun.outOfMemory();
+                                break;
+                            }
+
+                            other_source_index = parent_tla_check.parent;
+
+                            notes.append(Logger.Data{
+                                .text = std.fmt.allocPrint(c.allocator, "The file {s} imports the file {s} here:", .{
+                                    input_files[parent_source_index].path.pretty,
+                                    input_files[other_source_index].path.pretty,
+                                }) catch bun.outOfMemory(),
+                            }) catch bun.outOfMemory();
+                        }
+
+                        const source: *const Logger.Source = &input_files[source_index];
+                        const imported_pretty_path = source.path.pretty;
+                        const text: string = if (strings.eql(imported_pretty_path, tla_pretty_path))
+                            std.fmt.allocPrint(c.allocator, "This require call is not allowed because the imported file \"{s}\" contains a top-level await", .{imported_pretty_path}) catch bun.outOfMemory()
+                        else
+                            std.fmt.allocPrint(c.allocator, "This require call is not allowed because the transitive dependency \"{s}\" contains a top-level await", .{tla_pretty_path}) catch bun.outOfMemory();
+
+                        c.log.addRangeErrorWithNotes(source, record.range, text, notes.items) catch bun.outOfMemory();
+                    }
+                }
+            }
+
+            // Make sure that if we wrap this module in a closure, the closure is also
+            // async. This happens when you call "import()" on this module and code
+            // splitting is off.
+            if (Index.isValid(Index.init(result_tla_check.parent))) {
+                meta_flags[source_index].is_async_or_has_async_dependency = true;
+            }
+        }
+
+        return result_tla_check.*;
+    }
+
     pub fn generateEntryPointTailJS(
         c: *LinkerContext,
         toCommonJSRef: Ref,
@@ -7875,7 +10542,7 @@ pub const LinkerContext = struct {
             // TODO: iife
             .iife => {},
 
-            .internal_kit_dev => {
+            .internal_bake_dev => {
                 // nothing needs to be done here, as the exports are already
                 // forwarded in the module closure.
             },
@@ -8078,9 +10745,6 @@ pub const LinkerContext = struct {
         ast: *const JSAst,
     ) !bool {
         const record = ast.import_records.at(import_record_index);
-        if (record.tag.isReactReference())
-            return false;
-
         // Is this an external import?
         if (!record.source_index.isValid()) {
             // Keep the "import" statement if import statements are supported
@@ -8230,16 +10894,11 @@ pub const LinkerContext = struct {
         wrap: WrapKind,
         ast: *const JSAst,
     ) !void {
-        // for Bun Kit, export wrapping is already done. Import wrapping is special cased.
-        if (c.options.output_format == .internal_kit_dev and source_index != Index.runtime.value) {
-            try c.convertStmtsForChunkKit(source_index, stmts, part_stmts, allocator, ast);
-            return;
-        }
-
         const shouldExtractESMStmtsForWrap = wrap != .none;
         const shouldStripExports = c.options.mode != .passthrough or c.graph.files.items(.entry_point_kind)[source_index] != .none;
 
         const flags = c.graph.meta.items(.flags);
+        const output_format = c.options.output_format;
 
         // If this file is a CommonJS entry point, double-write re-exports to the
         // external CommonJS "module.exports" object in addition to our internal ESM
@@ -8249,11 +10908,13 @@ pub const LinkerContext = struct {
         // importing itself should not see the "__esModule" marker but a CommonJS module
         // importing us should see the "__esModule" marker.
         var module_exports_for_export: ?Expr = null;
-        if (c.options.output_format == .cjs and chunk.isEntryPoint()) {
-            module_exports_for_export = Expr.init(
+        if (output_format == .cjs and chunk.isEntryPoint()) {
+            module_exports_for_export = Expr.allocate(
+                allocator,
                 E.Dot,
                 E.Dot{
-                    .target = Expr.init(
+                    .target = Expr.allocate(
+                        allocator,
                         E.Identifier,
                         E.Identifier{
                             .ref = c.unbound_module_ref,
@@ -8376,10 +11037,12 @@ pub const LinkerContext = struct {
                                     Stmt.alloc(
                                         S.SExpr,
                                         S.SExpr{
-                                            .value = Expr.init(
+                                            .value = Expr.allocate(
+                                                allocator,
                                                 E.Call,
                                                 E.Call{
-                                                    .target = Expr.init(
+                                                    .target = Expr.allocate(
+                                                        allocator,
                                                         E.Identifier,
                                                         E.Identifier{
                                                             .ref = export_star_ref,
@@ -8423,11 +11086,10 @@ pub const LinkerContext = struct {
                             }
 
                             if (record.calls_runtime_re_export_fn) {
-                                const other_source_index = record.source_index.get();
                                 const target: Expr = brk: {
-                                    if (c.graph.ast.items(.exports_kind)[other_source_index].isESMWithDynamicFallback()) {
+                                    if (record.source_index.isValid() and c.graph.ast.items(.exports_kind)[record.source_index.get()].isESMWithDynamicFallback()) {
                                         // Prefix this module with "__reExport(exports, otherExports, module.exports)"
-                                        break :brk Expr.initIdentifier(c.graph.ast.items(.exports_ref)[other_source_index], stmt.loc);
+                                        break :brk Expr.initIdentifier(c.graph.ast.items(.exports_ref)[record.source_index.get()], stmt.loc);
                                     }
 
                                     break :brk Expr.init(
@@ -8454,7 +11116,7 @@ pub const LinkerContext = struct {
                                 };
 
                                 if (module_exports_for_export) |mod| {
-                                    args[3] = mod;
+                                    args[2] = mod;
                                 }
 
                                 try stmts.inside_wrapper_prefix.append(
@@ -8722,8 +11384,8 @@ pub const LinkerContext = struct {
         }
     }
 
-    /// The conversion logic is completely different for format .kit_internal_hmr
-    fn convertStmtsForChunkKit(
+    /// The conversion logic is completely different for format .internal_bake_dev
+    fn convertStmtsForChunkForBake(
         c: *LinkerContext,
         source_index: u32,
         stmts: *StmtList,
@@ -8731,26 +11393,32 @@ pub const LinkerContext = struct {
         allocator: std.mem.Allocator,
         ast: *const JSAst,
     ) !void {
-        _ = source_index; // autofix
+        _ = source_index; // may be used
 
         const receiver_args = try allocator.dupe(G.Arg, &.{
             .{ .binding = Binding.alloc(allocator, B.Identifier{ .ref = ast.module_ref }, Logger.Loc.Empty) },
         });
         const module_id = Expr.initIdentifier(ast.module_ref, Logger.Loc.Empty);
+
+        // add a marker for the client runtime to tell that this is an ES module
+        if (ast.exports_kind == .esm) {
+            try stmts.inside_wrapper_prefix.append(Stmt.alloc(S.SExpr, .{
+                .value = Expr.assign(
+                    Expr.init(E.Dot, .{
+                        .target = Expr.initIdentifier(ast.module_ref, Loc.Empty),
+                        .name = "__esModule",
+                        .name_loc = Loc.Empty,
+                    }, Loc.Empty),
+                    Expr.init(E.Boolean, .{ .value = true }, Loc.Empty),
+                ),
+            }, Loc.Empty));
+        }
+
         for (part_stmts) |stmt| {
             switch (stmt.data) {
                 else => {
                     try stmts.inside_wrapper_suffix.append(stmt);
                 },
-                .s_local => |st| {
-                    // TODO: check if this local is immediately assigned
-                    // `require()` if so, we will instrument it with hot module
-                    // reloading. other cases of `require` won't receive receive
-                    // updates.
-                    _ = st; // autofix
-
-                    try stmts.inside_wrapper_suffix.append(stmt);
-                },
                 .s_import => |st| {
                     // hmr-runtime.ts defines `module.importSync` to be
                     // a synchronous import. this is different from
@@ -8758,51 +11426,71 @@ pub const LinkerContext = struct {
                     // automatically, instead of with bundler-added
                     // annotations like '__commonJS'.
                     //
-                    // this is not done in the parse step because the final
+                    // this cannot be done in the parse step because the final
                     // pretty path is not yet known. the other statement types
                     // are not handled here because some of those generate
                     // new local variables (it is too late to do that here).
                     const record = ast.import_records.at(st.import_record_index);
-                    const path = c.parse_graph.input_files.items(.source)[record.source_index.get()].path;
 
                     const is_bare_import = st.star_name_loc == null and st.items.len == 0 and st.default_name == null;
 
-                    const key_expr = Expr.init(E.InlinedEnum, .{
-                        .comment = path.pretty,
-                        .value = Expr.init(E.Number, .{
-                            .value = @floatFromInt(path.hashForKit()),
-                        }, stmt.loc),
-                    }, stmt.loc);
+                    // CSS files and `is_disabled` records should not generate an import statement
+                    const is_enabled = !record.path.is_disabled and if (record.source_index.isValid())
+                        c.parse_graph.input_files.items(.loader)[record.source_index.get()] != .css
+                    else
+                        true;
 
-                    // module.importSync('path', (module) => ns = module)
-                    const call = Expr.init(E.Call, .{
-                        .target = Expr.init(E.Dot, .{
-                            .target = module_id,
-                            .name = "importSync",
-                            .name_loc = stmt.loc,
-                        }, stmt.loc),
-                        .args = js_ast.ExprNodeList.init(
-                            try allocator.dupe(Expr, if (is_bare_import)
-                                &.{key_expr}
-                            else
-                                &.{
-                                    key_expr,
-                                    Expr.init(E.Arrow, .{
-                                        .args = receiver_args,
-                                        .body = .{
-                                            .stmts = try allocator.dupe(Stmt, &.{Stmt.alloc(S.Return, .{
-                                                .value = Expr.assign(
-                                                    Expr.initIdentifier(st.namespace_ref, st.star_name_loc orelse stmt.loc),
-                                                    module_id,
-                                                ),
-                                            }, stmt.loc)}),
-                                            .loc = stmt.loc,
-                                        },
-                                        .prefer_expr = true,
-                                    }, stmt.loc),
-                                }),
-                        ),
-                    }, stmt.loc);
+                    // module.importSync('path', (module) => ns = module, ['dep', 'etc'])
+                    const call = if (is_enabled) call: {
+                        const path = if (record.source_index.isValid())
+                            c.parse_graph.input_files.items(.source)[record.source_index.get()].path
+                        else
+                            record.path;
+
+                        const is_builtin = record.tag == .builtin or record.tag == .bun_test or record.tag == .bun;
+
+                        const key_expr = Expr.init(E.String, .{
+                            .data = path.pretty,
+                        }, stmt.loc);
+
+                        const items = try allocator.alloc(Expr, st.items.len);
+                        for (st.items, items) |item, *str| {
+                            str.* = Expr.init(E.String, .{ .data = item.alias }, item.name.loc);
+                        }
+
+                        break :call Expr.init(E.Call, .{
+                            .target = Expr.init(E.Dot, .{
+                                .target = module_id,
+                                .name = if (is_builtin) "importBuiltin" else "importSync",
+                                .name_loc = stmt.loc,
+                            }, stmt.loc),
+                            .args = js_ast.ExprNodeList.init(
+                                try allocator.dupe(Expr, if (is_bare_import or is_builtin)
+                                    &.{key_expr}
+                                else
+                                    &.{
+                                        key_expr,
+                                        Expr.init(E.Arrow, .{
+                                            .args = receiver_args,
+                                            .body = .{
+                                                .stmts = try allocator.dupe(Stmt, &.{Stmt.alloc(S.Return, .{
+                                                    .value = Expr.assign(
+                                                        Expr.initIdentifier(st.namespace_ref, st.star_name_loc orelse stmt.loc),
+                                                        module_id,
+                                                    ),
+                                                }, stmt.loc)}),
+                                                .loc = stmt.loc,
+                                            },
+                                            .prefer_expr = true,
+                                        }, stmt.loc),
+                                        Expr.init(E.Array, .{
+                                            .items = BabyList(Expr).init(items),
+                                            .is_single_line = true,
+                                        }, stmt.loc),
+                                    }),
+                            ),
+                        }, stmt.loc);
+                    } else Expr.init(E.Object, .{}, stmt.loc);
 
                     if (is_bare_import) {
                         // the import value is never read
@@ -8856,6 +11544,65 @@ pub const LinkerContext = struct {
         // referencing everything by array makes the code a lot more annoying :(
         const ast: JSAst = c.graph.ast.get(part_range.source_index.get());
 
+        // For Bun Kit, part generation is entirely special cased.
+        // - export wrapping is already done.
+        // - import wrapping needs to know resolved paths
+        // - one part range per file (ensured by another special cased code path in findAllImportedPartsInJSOrder)
+        if (c.options.output_format == .internal_bake_dev) {
+            bun.assert(!part_range.source_index.isRuntime()); // embedded in HMR runtime
+
+            for (parts) |part| {
+                c.convertStmtsForChunkForBake(part_range.source_index.get(), stmts, part.stmts, allocator, &ast) catch |err|
+                    return .{ .err = err };
+            }
+
+            stmts.all_stmts.ensureUnusedCapacity(stmts.inside_wrapper_prefix.items.len + stmts.inside_wrapper_suffix.items.len) catch bun.outOfMemory();
+            stmts.all_stmts.appendSliceAssumeCapacity(stmts.inside_wrapper_prefix.items);
+            stmts.all_stmts.appendSliceAssumeCapacity(stmts.inside_wrapper_suffix.items);
+
+            var clousure_args = std.BoundedArray(G.Arg, 2).fromSlice(&.{
+                .{ .binding = Binding.alloc(temp_allocator, B.Identifier{
+                    .ref = ast.module_ref,
+                }, Logger.Loc.Empty) },
+            }) catch unreachable; // is within bounds
+
+            if (ast.flags.uses_exports_ref) {
+                clousure_args.appendAssumeCapacity(
+                    .{
+                        .binding = Binding.alloc(temp_allocator, B.Identifier{
+                            .ref = ast.exports_ref,
+                        }, Logger.Loc.Empty),
+                        .default = Expr.allocate(temp_allocator, E.Dot, .{
+                            .target = Expr.initIdentifier(ast.module_ref, Logger.Loc.Empty),
+                            .name = "exports",
+                            .name_loc = Logger.Loc.Empty,
+                        }, Logger.Loc.Empty),
+                    },
+                );
+            }
+
+            var single_stmt = Stmt.allocateExpr(temp_allocator, Expr.init(E.Function, .{ .func = .{
+                .args = temp_allocator.dupe(G.Arg, clousure_args.slice()) catch bun.outOfMemory(),
+                .body = .{
+                    .stmts = stmts.all_stmts.items,
+                    .loc = Logger.Loc.Empty,
+                },
+            } }, Logger.Loc.Empty));
+
+            return c.printCodeForFileInChunkJS(
+                r,
+                allocator,
+                writer,
+                (&single_stmt)[0..1],
+                &ast,
+                flags,
+                toESMRef,
+                toCommonJSRef,
+                runtimeRequireRef,
+                part_range.source_index,
+            );
+        }
+
         var needs_wrapper = false;
 
         const namespace_export_part_index = js_ast.namespace_export_part_index;
@@ -8871,6 +11618,16 @@ pub const LinkerContext = struct {
             break :brk std.math.maxInt(u32);
         };
 
+        const output_format = c.options.output_format;
+
+        // The top-level directive must come first (the non-wrapped case is handled
+        // by the chunk generation code, although only for the entry point)
+        if (flags.wrap != .none and ast.flags.has_explicit_use_strict_directive and !chunk.isEntryPoint() and !output_format.isAlwaysStrictMode()) {
+            stmts.inside_wrapper_prefix.append(Stmt.alloc(S.Directive, .{
+                .value = "use strict",
+            }, Logger.Loc.Empty)) catch unreachable;
+        }
+
         // TODO: handle directive
         if (namespace_export_part_index >= part_range.part_index_begin and
             namespace_export_part_index < part_range.part_index_end and
@@ -9041,41 +11798,8 @@ pub const LinkerContext = struct {
 
         var out_stmts: []js_ast.Stmt = stmts.all_stmts.items;
 
-        // Turn each module into a function if this is Kit
-        var stmt_storage: Stmt = undefined;
-        if (c.options.output_format == .internal_kit_dev and !part_range.source_index.isRuntime()) {
-            var clousure_args = std.BoundedArray(G.Arg, 2).fromSlice(&.{
-                .{ .binding = Binding.alloc(temp_allocator, B.Identifier{
-                    .ref = ast.module_ref,
-                }, Logger.Loc.Empty) },
-            }) catch unreachable; // is within bounds
-
-            if (flags.wrap == .cjs and ast.flags.uses_exports_ref) {
-                clousure_args.appendAssumeCapacity(
-                    .{
-                        .binding = Binding.alloc(temp_allocator, B.Identifier{
-                            .ref = ast.exports_ref,
-                        }, Logger.Loc.Empty),
-                        .default = Expr.allocate(temp_allocator, E.Dot, .{
-                            .target = Expr.initIdentifier(ast.module_ref, Logger.Loc.Empty),
-                            .name = "exports",
-                            .name_loc = Logger.Loc.Empty,
-                        }, Logger.Loc.Empty),
-                    },
-                );
-            }
-
-            stmt_storage = Stmt.allocateExpr(temp_allocator, Expr.init(E.Function, .{ .func = .{
-                .args = temp_allocator.dupe(G.Arg, clousure_args.slice()) catch bun.outOfMemory(),
-                .body = .{
-                    .stmts = stmts.all_stmts.items,
-                    .loc = Logger.Loc.Empty,
-                },
-            } }, Logger.Loc.Empty));
-            out_stmts = (&stmt_storage)[0..1];
-        }
         // Optionally wrap all statements in a closure
-        else if (needs_wrapper) {
+        if (needs_wrapper) {
             switch (flags.wrap) {
                 .cjs => {
                     // Only include the arguments that are actually used
@@ -9224,6 +11948,7 @@ pub const LinkerContext = struct {
                                                 );
                                             }
                                         } else {
+                                            hoist.next_value = null;
                                             _ = decl.binding.toExpr(&hoist);
                                         }
                                     }
@@ -9378,11 +12103,35 @@ pub const LinkerContext = struct {
             };
         }
 
+        return c.printCodeForFileInChunkJS(
+            r,
+            allocator,
+            writer,
+            out_stmts,
+            &ast,
+            flags,
+            toESMRef,
+            toCommonJSRef,
+            runtimeRequireRef,
+            part_range.source_index,
+        );
+    }
+
+    fn printCodeForFileInChunkJS(
+        c: *LinkerContext,
+        r: renamer.Renamer,
+        allocator: std.mem.Allocator,
+        writer: *js_printer.BufferWriter,
+        out_stmts: []Stmt,
+        ast: *const js_ast.BundledAst,
+        flags: JSMeta.Flags,
+        to_esm_ref: Ref,
+        to_commonjs_ref: Ref,
+        runtime_require_ref: ?Ref,
+        source_index: Index,
+    ) js_printer.PrintResult {
         const parts_to_print = &[_]js_ast.Part{
-            js_ast.Part{
-                // .tag = .stmts,
-                .stmts = out_stmts,
-            },
+            js_ast.Part{ .stmts = out_stmts },
         };
 
         const print_options = js_printer.Options{
@@ -9390,7 +12139,7 @@ pub const LinkerContext = struct {
             .indent = .{},
             .commonjs_named_exports = ast.commonjs_named_exports,
             .commonjs_named_exports_ref = ast.exports_ref,
-            .commonjs_module_ref = if (ast.flags.uses_module_ref or c.options.output_format == .internal_kit_dev)
+            .commonjs_module_ref = if (ast.flags.uses_module_ref or c.options.output_format == .internal_bake_dev)
                 ast.module_ref
             else
                 Ref.None,
@@ -9401,45 +12150,43 @@ pub const LinkerContext = struct {
 
             .minify_whitespace = c.options.minify_whitespace,
             .minify_syntax = c.options.minify_syntax,
-            .module_type = switch (c.options.output_format) {
-                else => |format| format,
-                .internal_kit_dev => if (part_range.source_index.isRuntime()) .esm else .internal_kit_dev,
-            },
+            .module_type = c.options.output_format,
             .print_dce_annotations = c.options.emit_dce_annotations,
             .has_run_symbol_renamer = true,
 
             .allocator = allocator,
-            .to_esm_ref = toESMRef,
-            .to_commonjs_ref = toCommonJSRef,
-            .require_ref = if (c.options.output_format == .internal_kit_dev) ast.require_ref else runtimeRequireRef,
+            .to_esm_ref = to_esm_ref,
+            .to_commonjs_ref = to_commonjs_ref,
+            .require_ref = switch (c.options.output_format) {
+                .cjs => null,
+                else => runtime_require_ref,
+            },
             .require_or_import_meta_for_source_callback = js_printer.RequireOrImportMeta.Callback.init(
                 LinkerContext,
                 requireOrImportMetaForSource,
                 c,
             ),
-            .line_offset_tables = c.graph.files.items(.line_offset_table)[part_range.source_index.get()],
+            .line_offset_tables = c.graph.files.items(.line_offset_table)[source_index.get()],
             .target = c.options.target,
 
-            .input_files_for_kit = if (c.options.output_format == .internal_kit_dev and !part_range.source_index.isRuntime())
+            .input_files_for_dev_server = if (c.options.output_format == .internal_bake_dev)
                 c.parse_graph.input_files.items(.source)
             else
                 null,
         };
 
         writer.buffer.reset();
-        var printer = js_printer.BufferPrinter.init(
-            writer.*,
-        );
+        var printer = js_printer.BufferPrinter.init(writer.*);
         defer writer.* = printer.ctx;
 
-        switch (c.options.source_maps != .none and !part_range.source_index.isRuntime()) {
+        switch (c.options.source_maps != .none and !source_index.isRuntime()) {
             inline else => |enable_source_maps| {
                 return js_printer.printWithWriter(
                     *js_printer.BufferPrinter,
                     &printer,
                     ast.target,
                     ast.toAST(),
-                    c.source_(part_range.source_index.get()),
+                    c.source_(source_index.get()),
                     print_options,
                     ast.import_records.slice(),
                     parts_to_print,
@@ -9480,11 +12227,17 @@ pub const LinkerContext = struct {
         shifts: []sourcemap.SourceMapShifts,
     };
 
-    pub fn generateChunksInParallel(c: *LinkerContext, chunks: []Chunk) !std.ArrayList(options.OutputFile) {
+    pub fn generateChunksInParallel(c: *LinkerContext, chunks: []Chunk, comptime is_dev_server: bool) !if (is_dev_server) void else std.ArrayList(options.OutputFile) {
         const trace = tracer(@src(), "generateChunksInParallel");
         defer trace.end();
 
+        var has_js_chunk = false;
+        var has_css_chunk = false;
+
+        bun.assert(chunks.len > 0);
+
         {
+            // TODO(@paperdave/bake): instead of running a renamer per chunk, run it per file
             debug(" START {d} renamers", .{chunks.len});
             defer debug("  DONE {d} renamers", .{chunks.len});
             var wait_group = try c.allocator.create(sync.WaitGroup);
@@ -9505,6 +12258,58 @@ pub const LinkerContext = struct {
             c.allocator.free(c.source_maps.line_offset_tasks);
             c.source_maps.line_offset_tasks.len = 0;
         }
+
+        if (c.options.experimental_css) {
+            // Per CSS chunk:
+            // Remove duplicate rules across files. This must be done in serial, not
+            // in parallel, and must be done from the last rule to the first rule.
+            if (brk: {
+                // TODO: Have count of chunks with css on linker context?
+                for (chunks) |*chunk| {
+                    if (chunk.content == .css) break :brk true;
+                }
+                break :brk false;
+            }) {
+                var wait_group = try c.allocator.create(sync.WaitGroup);
+                wait_group.init();
+                defer {
+                    wait_group.deinit();
+                    c.allocator.destroy(wait_group);
+                }
+                const total_count = total_count: {
+                    var total_count: usize = 0;
+                    for (chunks) |*chunk| {
+                        if (chunk.content == .css) total_count += 1;
+                    }
+                    break :total_count total_count;
+                };
+
+                debug(" START {d} prepare CSS ast (total count)", .{total_count});
+                defer debug("  DONE {d} prepare CSS ast (total count)", .{total_count});
+
+                var batch = ThreadPoolLib.Batch{};
+                const tasks = c.allocator.alloc(PrepareCssAstTask, total_count) catch bun.outOfMemory();
+                var i: usize = 0;
+                for (chunks) |*chunk| {
+                    if (chunk.content == .css) {
+                        tasks[i] = PrepareCssAstTask{
+                            .task = ThreadPoolLib.Task{
+                                .callback = &prepareCssAstsForChunk,
+                            },
+                            .chunk = chunk,
+                            .linker = c,
+                            .wg = wait_group,
+                        };
+                        batch.push(ThreadPoolLib.Batch.from(&tasks[i].task));
+                        i += 1;
+                    }
+                }
+                wait_group.counter = @as(u32, @truncate(total_count));
+                c.parse_graph.pool.pool.schedule(batch);
+                wait_group.wait();
+            }
+        }
+
         {
             const chunk_contexts = c.allocator.alloc(GenerateChunkCtx, chunks.len) catch unreachable;
             defer c.allocator.free(chunk_contexts);
@@ -9518,9 +12323,20 @@ pub const LinkerContext = struct {
             {
                 var total_count: usize = 0;
                 for (chunks, chunk_contexts) |*chunk, *chunk_ctx| {
-                    chunk_ctx.* = .{ .wg = wait_group, .c = c, .chunks = chunks, .chunk = chunk };
-                    total_count += chunk.content.javascript.parts_in_chunk_in_order.len;
-                    chunk.compile_results_for_chunk = c.allocator.alloc(CompileResult, chunk.content.javascript.parts_in_chunk_in_order.len) catch bun.outOfMemory();
+                    switch (chunk.content) {
+                        .javascript => {
+                            chunk_ctx.* = .{ .wg = wait_group, .c = c, .chunks = chunks, .chunk = chunk };
+                            total_count += chunk.content.javascript.parts_in_chunk_in_order.len;
+                            chunk.compile_results_for_chunk = c.allocator.alloc(CompileResult, chunk.content.javascript.parts_in_chunk_in_order.len) catch bun.outOfMemory();
+                            has_js_chunk = true;
+                        },
+                        .css => {
+                            has_css_chunk = true;
+                            chunk_ctx.* = .{ .wg = wait_group, .c = c, .chunks = chunks, .chunk = chunk };
+                            total_count += chunk.content.css.imports_in_chunk_in_order.len;
+                            chunk.compile_results_for_chunk = c.allocator.alloc(CompileResult, chunk.content.css.imports_in_chunk_in_order.len) catch bun.outOfMemory();
+                        },
+                    }
                 }
 
                 debug(" START {d} compiling part ranges", .{total_count});
@@ -9530,18 +12346,50 @@ pub const LinkerContext = struct {
                 var remaining_part_ranges = combined_part_ranges;
                 var batch = ThreadPoolLib.Batch{};
                 for (chunks, chunk_contexts) |*chunk, *chunk_ctx| {
-                    for (chunk.content.javascript.parts_in_chunk_in_order, 0..) |part_range, i| {
-                        remaining_part_ranges[0] = .{
-                            .part_range = part_range,
-                            .i = @as(u32, @truncate(i)),
-                            .task = ThreadPoolLib.Task{
-                                .callback = &generateCompileResultForJSChunk,
-                            },
-                            .ctx = chunk_ctx,
-                        };
-                        batch.push(ThreadPoolLib.Batch.from(&remaining_part_ranges[0].task));
+                    switch (chunk.content) {
+                        .javascript => {
+                            for (chunk.content.javascript.parts_in_chunk_in_order, 0..) |part_range, i| {
+                                if (Environment.enable_logs) {
+                                    debugPartRanges(
+                                        "Part Range: {s} {s} ({d}..{d})",
+                                        .{
+                                            c.parse_graph.input_files.items(.source)[part_range.source_index.get()].path.pretty,
+                                            @tagName(c.parse_graph.ast.items(.target)[part_range.source_index.get()].bakeGraph()),
+                                            part_range.part_index_begin,
+                                            part_range.part_index_end,
+                                        },
+                                    );
+                                }
 
-                        remaining_part_ranges = remaining_part_ranges[1..];
+                                remaining_part_ranges[0] = .{
+                                    .part_range = part_range,
+                                    .i = @truncate(i),
+                                    .task = .{
+                                        .callback = &generateCompileResultForJSChunk,
+                                    },
+                                    .ctx = chunk_ctx,
+                                };
+                                batch.push(ThreadPoolLib.Batch.from(&remaining_part_ranges[0].task));
+
+                                remaining_part_ranges = remaining_part_ranges[1..];
+                            }
+                        },
+                        .css => {
+                            for (chunk.content.css.imports_in_chunk_in_order.slice(), 0..) |css_import, i| {
+                                _ = css_import; // autofix
+                                remaining_part_ranges[0] = .{
+                                    .part_range = .{},
+                                    .i = @as(u32, @truncate(i)),
+                                    .task = ThreadPoolLib.Task{
+                                        .callback = &generateCompileResultForCssChunk,
+                                    },
+                                    .ctx = chunk_ctx,
+                                };
+                                batch.push(ThreadPoolLib.Batch.from(&remaining_part_ranges[0].task));
+
+                                remaining_part_ranges = remaining_part_ranges[1..];
+                            }
+                        },
                     }
                 }
                 wait_group.counter = @as(u32, @truncate(total_count));
@@ -9557,16 +12405,36 @@ pub const LinkerContext = struct {
                 c.source_maps.quoted_contents_tasks.len = 0;
             }
 
-            {
-                debug(" START {d} postprocess chunks", .{chunks.len});
-                defer debug("  DONE {d} postprocess chunks", .{chunks.len});
+            // For dev server, only post-process CSS chunks.
+            const chunks_to_do = if (is_dev_server) chunks[1..] else chunks;
+            if (!is_dev_server or chunks_to_do.len > 0) {
+                bun.assert(chunks_to_do.len > 0);
+                debug(" START {d} postprocess chunks", .{chunks_to_do.len});
+                defer debug("  DONE {d} postprocess chunks", .{chunks_to_do.len});
                 wait_group.init();
-                wait_group.counter = @as(u32, @truncate(chunks.len));
+                wait_group.counter = @as(u32, @truncate(chunks_to_do.len));
 
-                try c.parse_graph.pool.pool.doPtr(c.allocator, wait_group, chunk_contexts[0], generateChunkJS, chunks);
+                try c.parse_graph.pool.pool.doPtr(
+                    c.allocator,
+                    wait_group,
+                    chunk_contexts[0],
+                    generateChunk,
+                    chunks_to_do,
+                );
             }
         }
 
+        // When bake.DevServer is in use, we're going to take a different code path at the end.
+        // We want to extract the source code of each part instead of combining it into a single file.
+        // This is so that when hot-module updates happen, we can:
+        //
+        // - Reuse unchanged parts to assemble the full bundle if Cmd+R is used in the browser
+        // - Send only the newly changed code through a socket.
+        //
+        // When this isnt the initial bundle, concatenation as usual would produce a
+        // broken module. It is DevServer's job to create and send HMR patches.
+        if (is_dev_server) return;
+
         // TODO: enforceNoCyclicChunkImports()
         {
             var path_names_map = bun.StringHashMap(void).init(c.allocator);
@@ -9666,165 +12534,23 @@ pub const LinkerContext = struct {
             }
         }
 
-        const react_client_components_manifest: []u8 = if (c.resolver.opts.react_server_components) brk: {
-            var bytes = std.ArrayList(u8).init(c.allocator);
-            defer bytes.deinit();
-            const all_sources = c.parse_graph.input_files.items(.source);
-            var all_named_exports = c.graph.ast.items(.named_exports);
-            var export_names = std.ArrayList(Api.StringPointer).init(c.allocator);
-            defer export_names.deinit();
-
-            var client_modules = std.ArrayList(Api.ClientServerModule).initCapacity(c.allocator, c.graph.react_client_component_boundary.count()) catch unreachable;
-            defer client_modules.deinit();
-            var server_modules = std.ArrayList(Api.ClientServerModule).initCapacity(c.allocator, c.graph.react_server_component_boundary.count()) catch unreachable;
-            defer server_modules.deinit();
-
-            var react_client_components_iterator = c.graph.react_client_component_boundary.iterator(.{});
-            var react_server_components_iterator = c.graph.react_server_component_boundary.iterator(.{});
-
-            var sorted_client_component_ids = std.ArrayList(u32).initCapacity(c.allocator, client_modules.capacity) catch unreachable;
-            defer sorted_client_component_ids.deinit();
-            while (react_client_components_iterator.next()) |source_index| {
-                if (!c.graph.files_live.isSet(source_index)) continue;
-                sorted_client_component_ids.appendAssumeCapacity(@as(u32, @intCast(source_index)));
-            }
-
-            var sorted_server_component_ids = std.ArrayList(u32).initCapacity(c.allocator, server_modules.capacity) catch unreachable;
-            defer sorted_server_component_ids.deinit();
-            while (react_server_components_iterator.next()) |source_index| {
-                if (!c.graph.files_live.isSet(source_index)) continue;
-                sorted_server_component_ids.appendAssumeCapacity(@as(u32, @intCast(source_index)));
-            }
-
-            const Sorter = struct {
-                sources: []const Logger.Source,
-                pub fn isLessThan(ctx: @This(), a_index: u32, b_index: u32) bool {
-                    const a = ctx.sources[a_index].path.text;
-                    const b = ctx.sources[b_index].path.text;
-                    return strings.order(a, b) == .lt;
-                }
-            };
-            std.sort.pdq(u32, sorted_client_component_ids.items, Sorter{ .sources = all_sources }, Sorter.isLessThan);
-            std.sort.pdq(u32, sorted_server_component_ids.items, Sorter{ .sources = all_sources }, Sorter.isLessThan);
-
-            inline for (.{
-                sorted_client_component_ids.items,
-                sorted_server_component_ids.items,
-            }, .{
-                &client_modules,
-                &server_modules,
-            }) |sorted_component_ids, modules| {
-                for (sorted_component_ids) |component_source_index| {
-                    var source_index_for_named_exports = component_source_index;
-
-                    const chunk: *Chunk = brk2: {
-                        for (chunks) |*chunk_| {
-                            if (!chunk_.entry_point.is_entry_point) continue;
-                            if (chunk_.entry_point.source_index == @as(u32, @intCast(component_source_index))) {
-                                break :brk2 chunk_;
-                            }
-
-                            if (chunk_.files_with_parts_in_chunk.contains(component_source_index)) {
-                                source_index_for_named_exports = chunk_.entry_point.source_index;
-                                break :brk2 chunk_;
-                            }
-                        }
-
-                        @panic("could not find chunk for component");
-                    };
-
-                    var grow_length: usize = 0;
-
-                    const named_exports = all_named_exports[source_index_for_named_exports].keys();
-
-                    try export_names.ensureUnusedCapacity(named_exports.len);
-                    const exports_len = @as(u32, @intCast(named_exports.len));
-                    const exports_start = @as(u32, @intCast(export_names.items.len));
-
-                    grow_length += chunk.final_rel_path.len;
-
-                    grow_length += all_sources[component_source_index].path.pretty.len;
-
-                    for (named_exports) |export_name| {
-                        try export_names.append(Api.StringPointer{
-                            .offset = @as(u32, @intCast(bytes.items.len + grow_length)),
-                            .length = @as(u32, @intCast(export_name.len)),
-                        });
-                        grow_length += export_name.len;
-                    }
-
-                    try bytes.ensureUnusedCapacity(grow_length);
-
-                    const input_name = Api.StringPointer{
-                        .offset = @as(u32, @intCast(bytes.items.len)),
-                        .length = @as(u32, @intCast(all_sources[component_source_index].path.pretty.len)),
-                    };
-
-                    bytes.appendSliceAssumeCapacity(all_sources[component_source_index].path.pretty);
-
-                    const asset_name = Api.StringPointer{
-                        .offset = @as(u32, @intCast(bytes.items.len)),
-                        .length = @as(u32, @intCast(chunk.final_rel_path.len)),
-                    };
-
-                    bytes.appendSliceAssumeCapacity(chunk.final_rel_path);
-
-                    for (named_exports) |export_name| {
-                        bytes.appendSliceAssumeCapacity(export_name);
-                    }
-
-                    modules.appendAssumeCapacity(.{
-                        .module_id = bun.hash32(all_sources[component_source_index].path.pretty),
-                        .asset_name = asset_name,
-                        .input_name = input_name,
-                        .export_names = .{
-                            .length = exports_len,
-                            .offset = exports_start,
-                        },
-                    });
-                }
-            }
-
-            if (client_modules.items.len == 0 and server_modules.items.len == 0) break :brk &.{};
-
-            var manifest = Api.ClientServerModuleManifest{
-                .version = 2,
-                .client_modules = client_modules.items,
-
-                // TODO:
-                .ssr_modules = client_modules.items,
-
-                .server_modules = server_modules.items,
-                .export_names = export_names.items,
-                .contents = bytes.items,
-            };
-            var byte_buffer = std.ArrayList(u8).initCapacity(bun.default_allocator, bytes.items.len) catch unreachable;
-            var byte_buffer_writer = byte_buffer.writer();
-            const SchemaWriter = schema.Writer(@TypeOf(&byte_buffer_writer));
-            var writer = SchemaWriter.init(&byte_buffer_writer);
-            manifest.encode(&writer) catch unreachable;
-            break :brk byte_buffer.items;
-        } else &.{};
-
         var output_files = std.ArrayList(options.OutputFile).initCapacity(
             bun.default_allocator,
-            (if (c.options.source_maps.hasExternalFiles()) chunks.len * 2 else chunks.len) + @as(
-                usize,
-                @intFromBool(react_client_components_manifest.len > 0) + c.parse_graph.additional_output_files.items.len,
-            ),
+            (if (c.options.source_maps.hasExternalFiles()) chunks.len * 2 else chunks.len) +
+                @as(usize, c.parse_graph.additional_output_files.items.len),
         ) catch unreachable;
 
         const root_path = c.resolver.opts.output_dir;
+        const more_than_one_output = c.parse_graph.additional_output_files.items.len > 0 or c.options.generate_bytecode_cache or (has_css_chunk and has_js_chunk);
 
-        if (root_path.len == 0 and c.parse_graph.additional_output_files.items.len > 0 and !c.resolver.opts.compile) {
+        if (!c.resolver.opts.compile and more_than_one_output and !c.resolver.opts.supports_multiple_outputs) {
             try c.log.addError(null, Logger.Loc.Empty, "cannot write multiple output files without an output directory");
             return error.MultipleOutputFilesWithoutOutputDir;
         }
 
         if (root_path.len > 0) {
-            try c.writeOutputFilesToDisk(root_path, chunks, react_client_components_manifest, &output_files);
+            try c.writeOutputFilesToDisk(root_path, chunks, &output_files);
         } else {
-
             // In-memory build
             for (chunks) |*chunk| {
                 var display_size: usize = 0;
@@ -9832,13 +12558,13 @@ pub const LinkerContext = struct {
                 const _code_result = chunk.intermediate_output.code(
                     null,
                     c.parse_graph,
+                    &c.graph,
                     c.resolver.opts.public_path,
                     chunk,
                     chunks,
                     &display_size,
                     c.options.source_maps != .none,
                 );
-
                 var code_result = _code_result catch @panic("Failed to allocate memory for output file");
 
                 var sourcemap_output_file: ?options.OutputFile = null;
@@ -9876,22 +12602,23 @@ pub const LinkerContext = struct {
                             code_result.buffer = buf.items;
                         }
 
-                        sourcemap_output_file = options.OutputFile.init(
-                            options.OutputFile.Options{
-                                .data = .{
-                                    .buffer = .{
-                                        .data = output_source_map,
-                                        .allocator = bun.default_allocator,
-                                    },
+                        sourcemap_output_file = options.OutputFile.init(.{
+                            .data = .{
+                                .buffer = .{
+                                    .data = output_source_map,
+                                    .allocator = bun.default_allocator,
                                 },
-                                .hash = null,
-                                .loader = .json,
-                                .input_loader = .file,
-                                .output_path = source_map_final_rel_path,
-                                .output_kind = .sourcemap,
-                                .input_path = try strings.concat(bun.default_allocator, &.{ input_path, ".map" }),
                             },
-                        );
+                            .hash = null,
+                            .loader = .json,
+                            .input_loader = .file,
+                            .output_path = source_map_final_rel_path,
+                            .output_kind = .sourcemap,
+                            .input_path = try strings.concat(bun.default_allocator, &.{ input_path, ".map" }),
+                            .side = null,
+                            .entry_point_index = null,
+                            .is_executable = false,
+                        });
                     },
                     .@"inline" => {
                         const output_source_map = chunk.output_source_map.finalize(bun.default_allocator, code_result.shifts) catch @panic("Failed to allocate memory for external source map");
@@ -9914,58 +12641,118 @@ pub const LinkerContext = struct {
                     .none => {},
                 }
 
-                output_files.appendAssumeCapacity(
-                    options.OutputFile.init(
-                        options.OutputFile.Options{
-                            .data = .{
-                                .buffer = .{
-                                    .data = code_result.buffer,
-                                    .allocator = Chunk.IntermediateOutput.allocatorForSize(code_result.buffer.len),
-                                },
-                            },
-                            .hash = chunk.template.placeholder.hash,
-                            .loader = .js,
-                            .input_path = input_path,
-                            .display_size = @as(u32, @truncate(display_size)),
-                            .output_kind = if (chunk.entry_point.is_entry_point)
-                                c.graph.files.items(.entry_point_kind)[chunk.entry_point.source_index].OutputKind()
-                            else
-                                .chunk,
-                            .input_loader = if (chunk.entry_point.is_entry_point) c.parse_graph.input_files.items(.loader)[chunk.entry_point.source_index] else .js,
-                            .output_path = try bun.default_allocator.dupe(u8, chunk.final_rel_path),
-                            .is_executable = chunk.is_executable,
-                            .source_map_index = if (sourcemap_output_file != null)
-                                @as(u32, @truncate(output_files.items.len + 1))
-                            else
-                                null,
+                const bytecode_output_file: ?options.OutputFile = brk: {
+                    if (c.options.generate_bytecode_cache) {
+                        const loader: Loader = if (chunk.entry_point.is_entry_point)
+                            c.parse_graph.input_files.items(.loader)[
+                                chunk.entry_point.source_index
+                            ]
+                        else
+                            .js;
+
+                        if (loader.isJavaScriptLike()) {
+                            JSC.initialize(false);
+                            var fdpath: bun.PathBuffer = undefined;
+                            var source_provider_url = try bun.String.createFormat("{s}" ++ bun.bytecode_extension, .{chunk.final_rel_path});
+                            source_provider_url.ref();
+
+                            defer source_provider_url.deref();
+
+                            if (JSC.CachedBytecode.generate(c.options.output_format, code_result.buffer, &source_provider_url)) |result| {
+                                const bytecode, const cached_bytecode = result;
+                                const source_provider_url_str = source_provider_url.toSlice(bun.default_allocator);
+                                defer source_provider_url_str.deinit();
+                                debug("Bytecode cache generated {s}: {}", .{ source_provider_url_str.slice(), bun.fmt.size(bytecode.len, .{ .space_between_number_and_unit = true }) });
+                                @memcpy(fdpath[0..chunk.final_rel_path.len], chunk.final_rel_path);
+                                fdpath[chunk.final_rel_path.len..][0..bun.bytecode_extension.len].* = bun.bytecode_extension.*;
+
+                                break :brk options.OutputFile.init(.{
+                                    .output_path = bun.default_allocator.dupe(u8, source_provider_url_str.slice()) catch unreachable,
+                                    .input_path = std.fmt.allocPrint(bun.default_allocator, "{s}" ++ bun.bytecode_extension, .{chunk.final_rel_path}) catch unreachable,
+                                    .input_loader = .js,
+                                    .hash = if (chunk.template.placeholder.hash != null) bun.hash(bytecode) else null,
+                                    .output_kind = .bytecode,
+                                    .loader = .file,
+                                    .size = @as(u32, @truncate(bytecode.len)),
+                                    .display_size = @as(u32, @truncate(bytecode.len)),
+                                    .data = .{
+                                        .buffer = .{ .data = bytecode, .allocator = cached_bytecode.allocator() },
+                                    },
+                                    .side = null,
+                                    .entry_point_index = null,
+                                    .is_executable = false,
+                                });
+                            } else {
+                                // an error
+                                c.log.addErrorFmt(null, Logger.Loc.Empty, bun.default_allocator, "Failed to generate bytecode for {s}", .{
+                                    chunk.final_rel_path,
+                                }) catch unreachable;
+                            }
+                        }
+                    }
+
+                    break :brk null;
+                };
+
+                const source_map_index: ?u32 = if (sourcemap_output_file != null)
+                    @as(u32, @truncate(output_files.items.len + 1))
+                else
+                    null;
+
+                const bytecode_index: ?u32 = if (bytecode_output_file != null and source_map_index != null)
+                    @as(u32, @truncate(output_files.items.len + 2))
+                else if (bytecode_output_file != null)
+                    @as(u32, @truncate(output_files.items.len + 1))
+                else
+                    null;
+
+                const output_kind = if (chunk.content == .css)
+                    .asset
+                else if (chunk.entry_point.is_entry_point)
+                    c.graph.files.items(.entry_point_kind)[chunk.entry_point.source_index].outputKind()
+                else
+                    .chunk;
+                try output_files.append(options.OutputFile.init(.{
+                    .data = .{
+                        .buffer = .{
+                            .data = code_result.buffer,
+                            .allocator = Chunk.IntermediateOutput.allocatorForSize(code_result.buffer.len),
                         },
-                    ),
-                );
+                    },
+                    .hash = chunk.template.placeholder.hash,
+                    .loader = chunk.content.loader(),
+                    .input_path = input_path,
+                    .display_size = @as(u32, @truncate(display_size)),
+                    .output_kind = output_kind,
+                    .input_loader = if (chunk.entry_point.is_entry_point) c.parse_graph.input_files.items(.loader)[chunk.entry_point.source_index] else .js,
+                    .output_path = try bun.default_allocator.dupe(u8, chunk.final_rel_path),
+                    .is_executable = chunk.is_executable,
+                    .source_map_index = source_map_index,
+                    .bytecode_index = bytecode_index,
+                    .side = if (chunk.content == .css)
+                        .client
+                    else switch (c.graph.ast.items(.target)[chunk.entry_point.source_index]) {
+                        .browser => .client,
+                        else => .server,
+                    },
+                    .entry_point_index = if (output_kind == .@"entry-point")
+                        chunk.entry_point.source_index - @as(u32, (if (c.framework) |fw| if (fw.server_components != null) 3 else 1 else 1))
+                    else
+                        null,
+                    .referenced_css_files = switch (chunk.content) {
+                        .javascript => |js| @ptrCast(try bun.default_allocator.dupe(u32, js.css_chunks)),
+                        .css => &.{},
+                    },
+                }));
                 if (sourcemap_output_file) |sourcemap_file| {
-                    output_files.appendAssumeCapacity(sourcemap_file);
+                    try output_files.append(sourcemap_file);
+                }
+                if (bytecode_output_file) |bytecode_file| {
+                    try output_files.append(bytecode_file);
                 }
             }
 
-            if (react_client_components_manifest.len > 0) {
-                output_files.appendAssumeCapacity(options.OutputFile.init(
-                    .{
-                        .data = .{
-                            .buffer = .{
-                                .data = react_client_components_manifest,
-                                .allocator = bun.default_allocator,
-                            },
-                        },
-
-                        .input_path = try bun.default_allocator.dupe(u8, components_manifest_path),
-                        .output_path = try bun.default_allocator.dupe(u8, components_manifest_path),
-                        .loader = .file,
-                        .input_loader = .file,
-                        .output_kind = .@"component-manifest",
-                    },
-                ));
-            }
-
-            output_files.appendSliceAssumeCapacity(c.parse_graph.additional_output_files.items);
+            try output_files.appendSlice(c.parse_graph.additional_output_files.items);
         }
 
         return output_files;
@@ -10001,16 +12788,17 @@ pub const LinkerContext = struct {
         // Mix in hashes for referenced asset paths (i.e. the "file" loader)
         switch (chunk.intermediate_output) {
             .pieces => |pieces| for (pieces.slice()) |piece| {
-                if (piece.index.kind == .asset) {
+                if (piece.query.kind == .asset) {
                     var from_chunk_dir = std.fs.path.dirnamePosix(chunk.final_rel_path) orelse "";
                     if (strings.eqlComptime(from_chunk_dir, "."))
                         from_chunk_dir = "";
 
-                    const additional_files: []AdditionalFile = c.graph.bundler_graph.input_files.items(.additional_files)[piece.index.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| {
-                            const path = c.graph.bundler_graph.additional_output_files.items[output_file_id].dest_path;
+                            const path = c.parse_graph.additional_output_files.items[output_file_id].dest_path;
                             hash.write(bun.path.relativePlatform(from_chunk_dir, path, .posix, false));
                         },
                         .source_index => {},
@@ -10028,7 +12816,6 @@ pub const LinkerContext = struct {
         c: *LinkerContext,
         root_path: string,
         chunks: []Chunk,
-        react_client_components_manifest: []const u8,
         output_files: *std.ArrayList(options.OutputFile),
     ) !void {
         const trace = tracer(@src(), "writeOutputFilesToDisk");
@@ -10089,6 +12876,7 @@ pub const LinkerContext = struct {
             var code_result = chunk.intermediate_output.code(
                 code_allocator,
                 c.parse_graph,
+                &c.graph,
                 c.resolver.opts.public_path,
                 chunk,
                 chunks,
@@ -10165,19 +12953,20 @@ pub const LinkerContext = struct {
                         .result => {},
                     }
 
-                    source_map_output_file = options.OutputFile.init(
-                        options.OutputFile.Options{
-                            .output_path = source_map_final_rel_path,
-                            .input_path = try strings.concat(bun.default_allocator, &.{ input_path, ".map" }),
-                            .loader = .json,
-                            .input_loader = .file,
-                            .output_kind = .sourcemap,
-                            .size = @as(u32, @truncate(output_source_map.len)),
-                            .data = .{
-                                .saved = 0,
-                            },
+                    source_map_output_file = options.OutputFile.init(.{
+                        .output_path = source_map_final_rel_path,
+                        .input_path = try strings.concat(bun.default_allocator, &.{ input_path, ".map" }),
+                        .loader = .json,
+                        .input_loader = .file,
+                        .output_kind = .sourcemap,
+                        .size = @as(u32, @truncate(output_source_map.len)),
+                        .data = .{
+                            .saved = 0,
                         },
-                    );
+                        .side = .client,
+                        .entry_point_index = null,
+                        .is_executable = false,
+                    });
                 },
                 .@"inline" => {
                     const output_source_map = chunk.output_source_map.finalize(source_map_allocator, code_result.shifts) catch @panic("Failed to allocate memory for external source map");
@@ -10198,6 +12987,86 @@ pub const LinkerContext = struct {
                 },
                 .none => {},
             }
+            const bytecode_output_file: ?options.OutputFile = brk: {
+                if (c.options.generate_bytecode_cache) {
+                    const loader: Loader = if (chunk.entry_point.is_entry_point)
+                        c.parse_graph.input_files.items(.loader)[
+                            chunk.entry_point.source_index
+                        ]
+                    else
+                        .js;
+
+                    if (loader.isJavaScriptLike()) {
+                        JSC.initialize(false);
+                        var fdpath: bun.PathBuffer = undefined;
+                        var source_provider_url = try bun.String.createFormat("{s}" ++ bun.bytecode_extension, .{chunk.final_rel_path});
+                        source_provider_url.ref();
+
+                        defer source_provider_url.deref();
+
+                        if (JSC.CachedBytecode.generate(c.options.output_format, code_result.buffer, &source_provider_url)) |result| {
+                            const source_provider_url_str = source_provider_url.toSlice(bun.default_allocator);
+                            defer source_provider_url_str.deinit();
+                            const bytecode, const cached_bytecode = result;
+                            debug("Bytecode cache generated {s}: {}", .{ source_provider_url_str.slice(), bun.fmt.size(bytecode.len, .{ .space_between_number_and_unit = true }) });
+                            @memcpy(fdpath[0..chunk.final_rel_path.len], chunk.final_rel_path);
+                            fdpath[chunk.final_rel_path.len..][0..bun.bytecode_extension.len].* = bun.bytecode_extension.*;
+                            defer cached_bytecode.deref();
+                            switch (JSC.Node.NodeFS.writeFileWithPathBuffer(
+                                &pathbuf,
+                                JSC.Node.Arguments.WriteFile{
+                                    .data = JSC.Node.StringOrBuffer{
+                                        .buffer = JSC.Buffer{
+                                            .buffer = .{
+                                                .ptr = @constCast(bytecode.ptr),
+                                                .len = @as(u32, @truncate(bytecode.len)),
+                                                .byte_len = @as(u32, @truncate(bytecode.len)),
+                                            },
+                                        },
+                                    },
+                                    .encoding = .buffer,
+                                    .mode = if (chunk.is_executable) 0o755 else 0o644,
+
+                                    .dirfd = bun.toFD(root_dir.fd),
+                                    .file = .{
+                                        .path = JSC.Node.PathLike{
+                                            .string = JSC.PathString.init(fdpath[0 .. chunk.final_rel_path.len + bun.bytecode_extension.len]),
+                                        },
+                                    },
+                                },
+                            )) {
+                                .result => {},
+                                .err => |err| {
+                                    c.log.addErrorFmt(null, Logger.Loc.Empty, bun.default_allocator, "{} writing bytecode for chunk {}", .{
+                                        err,
+                                        bun.fmt.quote(chunk.final_rel_path),
+                                    }) catch unreachable;
+                                    return error.WriteFailed;
+                                },
+                            }
+
+                            break :brk options.OutputFile.init(.{
+                                .output_path = bun.default_allocator.dupe(u8, source_provider_url_str.slice()) catch unreachable,
+                                .input_path = std.fmt.allocPrint(bun.default_allocator, "{s}" ++ bun.bytecode_extension, .{chunk.final_rel_path}) catch unreachable,
+                                .input_loader = .file,
+                                .hash = if (chunk.template.placeholder.hash != null) bun.hash(bytecode) else null,
+                                .output_kind = .bytecode,
+                                .loader = .file,
+                                .size = @as(u32, @truncate(bytecode.len)),
+                                .display_size = @as(u32, @truncate(bytecode.len)),
+                                .data = .{
+                                    .saved = 0,
+                                },
+                                .side = null,
+                                .entry_point_index = null,
+                                .is_executable = false,
+                            });
+                        }
+                    }
+                }
+
+                break :brk null;
+            };
 
             switch (JSC.Node.NodeFS.writeFileWithPathBuffer(
                 &pathbuf,
@@ -10235,90 +13104,65 @@ pub const LinkerContext = struct {
                 .result => {},
             }
 
-            output_files.appendAssumeCapacity(
-                options.OutputFile.init(
-                    options.OutputFile.Options{
-                        .output_path = bun.default_allocator.dupe(u8, chunk.final_rel_path) catch unreachable,
-                        .input_path = input_path,
-                        .input_loader = if (chunk.entry_point.is_entry_point)
-                            c.parse_graph.input_files.items(.loader)[chunk.entry_point.source_index]
-                        else
-                            .js,
-                        .hash = chunk.template.placeholder.hash,
-                        .output_kind = if (chunk.entry_point.is_entry_point)
-                            c.graph.files.items(.entry_point_kind)[chunk.entry_point.source_index].OutputKind()
-                        else
-                            .chunk,
-                        .loader = .js,
-                        .source_map_index = if (source_map_output_file != null)
-                            @as(u32, @truncate(output_files.items.len + 1))
-                        else
-                            null,
-                        .size = @as(u32, @truncate(code_result.buffer.len)),
-                        .display_size = @as(u32, @truncate(display_size)),
-                        .is_executable = chunk.is_executable,
-                        .data = .{
-                            .saved = 0,
-                        },
-                    },
-                ),
-            );
+            const source_map_index: ?u32 = if (source_map_output_file != null)
+                @as(u32, @truncate(output_files.items.len + 1))
+            else
+                null;
+
+            const bytecode_index: ?u32 = if (bytecode_output_file != null and source_map_index != null)
+                @as(u32, @truncate(output_files.items.len + 2))
+            else if (bytecode_output_file != null)
+                @as(u32, @truncate(output_files.items.len + 1))
+            else
+                null;
+
+            const output_kind = if (chunk.content == .css)
+                .asset
+            else if (chunk.entry_point.is_entry_point)
+                c.graph.files.items(.entry_point_kind)[chunk.entry_point.source_index].outputKind()
+            else
+                .chunk;
+            try output_files.append(options.OutputFile.init(.{
+                .output_path = bun.default_allocator.dupe(u8, chunk.final_rel_path) catch unreachable,
+                .input_path = input_path,
+                .input_loader = if (chunk.entry_point.is_entry_point)
+                    c.parse_graph.input_files.items(.loader)[chunk.entry_point.source_index]
+                else
+                    .js,
+                .hash = chunk.template.placeholder.hash,
+                .output_kind = output_kind,
+                .loader = .js,
+                .source_map_index = source_map_index,
+                .bytecode_index = bytecode_index,
+                .size = @as(u32, @truncate(code_result.buffer.len)),
+                .display_size = @as(u32, @truncate(display_size)),
+                .is_executable = chunk.is_executable,
+                .data = .{
+                    .saved = 0,
+                },
+                .side = if (chunk.content == .css)
+                    .client
+                else switch (c.graph.ast.items(.target)[chunk.entry_point.source_index]) {
+                    .browser => .client,
+                    else => .server,
+                },
+                .entry_point_index = if (output_kind == .@"entry-point")
+                    chunk.entry_point.source_index - @as(u32, (if (c.framework) |fw| if (fw.server_components != null) 3 else 1 else 1))
+                else
+                    null,
+                .referenced_css_files = switch (chunk.content) {
+                    .javascript => |js| @ptrCast(try bun.default_allocator.dupe(u32, js.css_chunks)),
+                    .css => &.{},
+                },
+            }));
 
             if (source_map_output_file) |sourcemap_file| {
-                output_files.appendAssumeCapacity(sourcemap_file);
-            }
-        }
-
-        if (react_client_components_manifest.len > 0) {
-            switch (JSC.Node.NodeFS.writeFileWithPathBuffer(
-                &pathbuf,
-                JSC.Node.Arguments.WriteFile{
-                    .data = JSC.Node.StringOrBuffer{
-                        .buffer = JSC.Buffer{
-                            .buffer = .{
-                                .ptr = @constCast(react_client_components_manifest.ptr),
-                                // TODO: handle > 4 GB files
-                                .len = @as(u32, @truncate(react_client_components_manifest.len)),
-                                .byte_len = @as(u32, @truncate(react_client_components_manifest.len)),
-                            },
-                        },
-                    },
-                    .encoding = .buffer,
-                    .dirfd = bun.toFD(root_dir.fd),
-                    .file = .{
-                        .path = JSC.Node.PathLike{
-                            .string = JSC.PathString.init(components_manifest_path),
-                        },
-                    },
-                },
-            )) {
-                .err => |err| {
-                    const utf8 = err.toSystemError().message.toUTF8(bun.default_allocator);
-                    defer utf8.deinit();
-                    c.log.addErrorFmt(null, Logger.Loc.Empty, bun.default_allocator, "{} writing chunk {}", .{
-                        bun.fmt.quote(utf8.slice()),
-                        bun.fmt.quote(components_manifest_path),
-                    }) catch unreachable;
-                    return error.WriteFailed;
-                },
-                .result => {},
+                try output_files.append(sourcemap_file);
             }
 
-            output_files.appendAssumeCapacity(
-                options.OutputFile.init(
-                    options.OutputFile.Options{
-                        .data = .{
-                            .saved = 0,
-                        },
-                        .loader = .file,
-                        .input_loader = .file,
-                        .output_kind = .@"component-manifest",
-                        .size = @as(u32, @truncate(react_client_components_manifest.len)),
-                        .input_path = bun.default_allocator.dupe(u8, components_manifest_path) catch unreachable,
-                        .output_path = bun.default_allocator.dupe(u8, components_manifest_path) catch unreachable,
-                    },
-                ),
-            );
+            if (bytecode_output_file) |bytecode_file| {
+                try output_files.append(bytecode_file);
+            }
         }
 
         {
@@ -10423,6 +13267,7 @@ pub const LinkerContext = struct {
         parts: []bun.BabyList(js_ast.Part),
         import_records: []bun.BabyList(bun.ImportRecord),
         file_entry_bits: []AutoBitSet,
+        css_reprs: []?*bun.css.BundlerStyleSheet,
     ) void {
         if (!c.graph.files_live.isSet(source_index))
             return;
@@ -10442,24 +13287,37 @@ pub const LinkerContext = struct {
 
         bits.set(entry_points_count);
 
-        if (comptime bun.Environment.allow_assert)
+        if (comptime bun.Environment.enable_logs)
             debugTreeShake(
-                "markFileReachableForCodeSplitting(entry: {d}): {s} ({d})",
+                "markFileReachableForCodeSplitting(entry: {d}): {s} {s} ({d})",
                 .{
                     entry_points_count,
-                    c.parse_graph.input_files.get(source_index).source.path.text,
+                    c.parse_graph.input_files.items(.source)[source_index].path.pretty,
+                    @tagName(c.parse_graph.ast.items(.target)[source_index].bakeGraph()),
                     out_dist,
                 },
             );
 
-        // TODO: CSS AST
-        var imports_a_boundary = false;
-        const use_directive = c.graph.useDirectiveBoundary(source_index);
+        if (css_reprs[source_index] != null) {
+            for (import_records[source_index].slice()) |*record| {
+                if (record.source_index.isValid() and !c.isExternalDynamicImport(record, source_index)) {
+                    c.markFileReachableForCodeSplitting(
+                        record.source_index.get(),
+                        entry_points_count,
+                        distances,
+                        out_dist,
+                        parts,
+                        import_records,
+                        file_entry_bits,
+                        css_reprs,
+                    );
+                }
+            }
+            return;
+        }
 
         for (import_records[source_index].slice()) |*record| {
-            const is_boundary = use_directive.isBoundary(record.tag.useDirective());
-            imports_a_boundary = use_directive != .none and (imports_a_boundary or is_boundary);
-            if (record.source_index.isValid() and !is_boundary and !c.isExternalDynamicImport(record, source_index)) {
+            if (record.source_index.isValid() and !c.isExternalDynamicImport(record, source_index)) {
                 c.markFileReachableForCodeSplitting(
                     record.source_index.get(),
                     entry_points_count,
@@ -10468,6 +13326,7 @@ pub const LinkerContext = struct {
                     parts,
                     import_records,
                     file_entry_bits,
+                    css_reprs,
                 );
             }
         }
@@ -10476,12 +13335,6 @@ pub const LinkerContext = struct {
         for (parts_in_file) |part| {
             for (part.dependencies.slice()) |dependency| {
                 if (dependency.source_index.get() != source_index) {
-                    if (imports_a_boundary and
-                        // "use client" -> "use server" imports don't
-                        use_directive.isBoundary(c.graph.files.items(.entry_point_kind)[dependency.source_index.get()]
-                        .useDirective()))
-                        continue;
-
                     c.markFileReachableForCodeSplitting(
                         dependency.source_index.get(),
                         entry_points_count,
@@ -10490,6 +13343,7 @@ pub const LinkerContext = struct {
                         parts,
                         import_records,
                         file_entry_bits,
+                        css_reprs,
                     );
                 }
             }
@@ -10503,12 +13357,14 @@ pub const LinkerContext = struct {
         parts: []bun.BabyList(js_ast.Part),
         import_records: []bun.BabyList(bun.ImportRecord),
         entry_point_kinds: []EntryPoint.Kind,
+        css_reprs: []?*bun.css.BundlerStyleSheet,
     ) void {
         if (comptime bun.Environment.allow_assert) {
-            debugTreeShake("markFileLiveForTreeShaking({d}, {s}) = {s}", .{
+            debugTreeShake("markFileLiveForTreeShaking({d}, {s} {s}) = {s}", .{
                 source_index,
-                c.parse_graph.input_files.get(source_index).source.path.text,
-                if (c.graph.files_live.isSet(source_index)) "seen" else "not seen",
+                c.parse_graph.input_files.get(source_index).source.path.pretty,
+                @tagName(c.parse_graph.ast.items(.target)[source_index].bakeGraph()),
+                if (c.graph.files_live.isSet(source_index)) "already seen" else "first seen",
             });
         }
 
@@ -10516,12 +13372,7 @@ pub const LinkerContext = struct {
             debugTreeShake("end()", .{});
         };
 
-        if (c.graph.files_live.isSet(source_index)) {
-            if (Environment.allow_assert) {
-                debugTreeShake("already set", .{});
-            }
-            return;
-        }
+        if (c.graph.files_live.isSet(source_index)) return;
         c.graph.files_live.set(source_index);
 
         if (source_index >= c.graph.ast.len) {
@@ -10529,6 +13380,23 @@ pub const LinkerContext = struct {
             return;
         }
 
+        if (css_reprs[source_index] != null) {
+            for (import_records[source_index].slice()) |*record| {
+                const other_source_index = record.source_index.get();
+                if (record.source_index.isValid()) {
+                    c.markFileLiveForTreeShaking(
+                        other_source_index,
+                        side_effects,
+                        parts,
+                        import_records,
+                        entry_point_kinds,
+                        css_reprs,
+                    );
+                }
+            }
+            return;
+        }
+
         for (parts[source_index].slice(), 0..) |part, part_index| {
             var can_be_removed_if_unused = part.can_be_removed_if_unused;
 
@@ -10564,6 +13432,7 @@ pub const LinkerContext = struct {
                         parts,
                         import_records,
                         entry_point_kinds,
+                        css_reprs,
                     );
                 } else if (record.is_external_without_side_effects) {
                     // This can be removed if it's unused
@@ -10590,6 +13459,7 @@ pub const LinkerContext = struct {
                     parts,
                     import_records,
                     entry_point_kinds,
+                    css_reprs,
                 );
             }
         }
@@ -10603,6 +13473,7 @@ pub const LinkerContext = struct {
         parts: []bun.BabyList(js_ast.Part),
         import_records: []bun.BabyList(bun.ImportRecord),
         entry_point_kinds: []EntryPoint.Kind,
+        css_reprs: []?*bun.css.BundlerStyleSheet,
     ) void {
         const part: *js_ast.Part = &parts[source_index].slice()[part_index];
 
@@ -10615,7 +13486,7 @@ pub const LinkerContext = struct {
         if (comptime bun.Environment.isDebug) {
             debugTreeShake("markPartLiveForTreeShaking({d}): {s}:{d} = {d}, {s}", .{
                 source_index,
-                c.parse_graph.input_files.get(source_index).source.path.text,
+                c.parse_graph.input_files.get(source_index).source.path.pretty,
                 part_index,
                 if (part.stmts.len > 0) part.stmts[0].loc.start else Logger.Loc.Empty.start,
                 if (part.stmts.len > 0) @tagName(part.stmts[0].data) else @tagName(Stmt.empty().data),
@@ -10633,6 +13504,7 @@ pub const LinkerContext = struct {
             parts,
             import_records,
             entry_point_kinds,
+            css_reprs,
         );
 
         if (Environment.enable_logs and part.dependencies.slice().len == 0) {
@@ -10655,6 +13527,7 @@ pub const LinkerContext = struct {
                 parts,
                 import_records,
                 entry_point_kinds,
+                css_reprs,
             );
         }
     }
@@ -10985,7 +13858,7 @@ pub const LinkerContext = struct {
                 }
 
                 // Generate a dummy part that depends on the "__commonJS" symbol.
-                const dependencies: []js_ast.Dependency = if (c.options.output_format != .internal_kit_dev) brk: {
+                const dependencies: []js_ast.Dependency = if (c.options.output_format != .internal_bake_dev) brk: {
                     const dependencies = c.allocator.alloc(js_ast.Dependency, common_js_parts.len) catch bun.outOfMemory();
                     for (common_js_parts, dependencies) |part, *cjs| {
                         cjs.* = .{
@@ -11020,8 +13893,8 @@ pub const LinkerContext = struct {
                 bun.assert(part_index != js_ast.namespace_export_part_index);
                 wrapper_part_index.* = Index.part(part_index);
 
-                // Kit uses a wrapping approach that does not use __commonJS
-                if (c.options.output_format != .internal_kit_dev) {
+                // Bake uses a wrapping approach that does not use __commonJS
+                if (c.options.output_format != .internal_bake_dev) {
                     c.graph.generateSymbolImportAndUse(
                         source_index,
                         part_index,
@@ -11043,7 +13916,7 @@ pub const LinkerContext = struct {
                 //
                 // This depends on the "__esm" symbol and declares the "init_foo" symbol
                 // for similar reasons to the CommonJS closure above.
-                const esm_parts = if (wrapper_ref.isValid() and c.options.output_format != .internal_kit_dev)
+                const esm_parts = if (wrapper_ref.isValid() and c.options.output_format != .internal_bake_dev)
                     c.topLevelSymbolsToPartsForRuntime(c.esm_runtime_ref)
                 else
                     &.{};
@@ -11075,7 +13948,7 @@ pub const LinkerContext = struct {
                 ) catch unreachable;
                 bun.assert(part_index != js_ast.namespace_export_part_index);
                 wrapper_part_index.* = Index.part(part_index);
-                if (wrapper_ref.isValid() and c.options.output_format != .internal_kit_dev) {
+                if (wrapper_ref.isValid() and c.options.output_format != .internal_bake_dev) {
                     c.graph.generateSymbolImportAndUse(
                         source_index,
                         part_index,
@@ -11117,7 +13990,7 @@ pub const LinkerContext = struct {
         const other_source_index = record.source_index.get();
         const other_id = other_source_index;
 
-        if (other_id > c.graph.ast.len or c.parse_graph.input_files.items(.source)[other_source_index].key_path.is_disabled) {
+        if (other_id > c.graph.ast.len or c.parse_graph.input_files.items(.source)[other_source_index].path.is_disabled) {
             return .{
                 .value = .{
                     .source_index = record.source_index,
@@ -11223,7 +14096,7 @@ pub const LinkerContext = struct {
         imports_to_bind: *RefImportData,
         source_index: Index.Int,
     ) void {
-        var named_imports = named_imports_ptr.cloneWithAllocator(c.allocator) catch unreachable;
+        var named_imports = named_imports_ptr.clone(c.allocator) catch bun.outOfMemory();
         defer named_imports_ptr.* = named_imports;
 
         const Sorter = struct {
@@ -11248,13 +14121,10 @@ pub const LinkerContext = struct {
             const import_ref = ref;
 
             var re_exports = std.ArrayList(js_ast.Dependency).init(c.allocator);
-            const result = c.matchImportWithExport(
-                .{
-                    .source_index = Index.source(source_index),
-                    .import_ref = import_ref,
-                },
-                &re_exports,
-            );
+            const result = c.matchImportWithExport(.{
+                .source_index = Index.source(source_index),
+                .import_ref = import_ref,
+            }, &re_exports);
 
             switch (result.kind) {
                 .normal => {
@@ -11456,97 +14326,81 @@ pub const LinkerContext = struct {
         const trace = tracer(@src(), "breakOutputIntoPieces");
         defer trace.end();
 
+        const OutputPiece = Chunk.OutputPiece;
+
         if (!j.contains(c.unique_key_prefix))
             // There are like several cases that prohibit this from being checked more trivially, example:
             // 1. dynamic imports
             // 2. require()
             // 3. require.resolve()
             // 4. externals
-            return Chunk.IntermediateOutput{ .joiner = j.* };
+            return .{ .joiner = j.* };
 
-        var pieces = try std.ArrayList(Chunk.OutputPiece).initCapacity(allocator, count);
+        var pieces = try std.ArrayList(OutputPiece).initCapacity(allocator, count);
         const complete_output = try j.done(allocator);
         var output = complete_output;
 
         const prefix = c.unique_key_prefix;
 
-        while (true) {
-            const invalid_boundary = std.math.maxInt(usize);
+        outer: while (true) {
             // Scan for the next piece boundary
-            var boundary = strings.indexOf(output, prefix) orelse invalid_boundary;
-
-            var output_piece_index = Chunk.OutputPieceIndex{};
-            var index: usize = 0;
+            const boundary = strings.indexOf(output, prefix) orelse
+                break;
 
             // Try to parse the piece boundary
-            if (boundary != invalid_boundary) {
-                const start = boundary + prefix.len;
-                if (start + 9 > output.len) {
-                    // Not enough bytes to parse the piece index
-                    boundary = invalid_boundary;
-                } else {
-                    switch (output[start]) {
-                        'A' => {
-                            output_piece_index.kind = .asset;
-                        },
-                        'C' => {
-                            output_piece_index.kind = .chunk;
-                        },
-                        else => {},
-                    }
-
-                    for (output[start..][1..9].*) |char| {
-                        if (char < '0' or char > '9') {
-                            boundary = invalid_boundary;
-                            break;
-                        }
-
-                        index = (index * 10) + (@as(usize, char) - '0');
-                    }
-                }
-            }
-
-            // Validate the boundary
-            switch (output_piece_index.kind) {
-                .asset => {
-                    if (index >= c.graph.files.len) {
-                        boundary = invalid_boundary;
-                    }
-                },
-                .chunk => {
-                    if (index >= count) {
-                        boundary = invalid_boundary;
-                    }
-                },
-                else => {
-                    boundary = invalid_boundary;
-                },
-            }
-
-            output_piece_index.index = @as(u30, @intCast(index));
-
-            // If we're at the end, generate one final piece
-            if (boundary == invalid_boundary) {
-                try pieces.append(Chunk.OutputPiece{
-                    .index = output_piece_index,
-                    .data_ptr = output.ptr,
-                    .data_len = @as(u32, @truncate(output.len)),
-                });
+            const start = boundary + prefix.len;
+            if (start + 9 > output.len) {
+                // Not enough bytes to parse the piece index
                 break;
             }
 
-            // Otherwise, generate an interior piece and continue
-            try pieces.append(Chunk.OutputPiece{
-                .index = output_piece_index,
-                .data_ptr = output.ptr,
+            const kind: OutputPiece.Query.Kind = switch (output[start]) {
+                'A' => .asset,
+                'C' => .chunk,
+                'S' => .scb,
+                else => {
+                    if (bun.Environment.isDebug)
+                        bun.Output.debugWarn("Invalid output piece boundary", .{});
+                    break;
+                },
+            };
 
-                // sliced this way to panic if out of bounds
-                .data_len = @as(u32, @truncate(output[0..boundary].len)),
-            });
+            var index: usize = 0;
+            for (output[start..][1..9].*) |char| {
+                if (char < '0' or char > '9') {
+                    if (bun.Environment.isDebug)
+                        bun.Output.debugWarn("Invalid output piece boundary", .{});
+                    break :outer;
+                }
+
+                index = (index * 10) + (@as(usize, char) - '0');
+            }
+
+            // Validate the boundary
+            switch (kind) {
+                .asset, .scb => if (index >= c.graph.files.len) {
+                    if (bun.Environment.isDebug)
+                        bun.Output.debugWarn("Invalid output piece boundary", .{});
+                    break;
+                },
+                .chunk => if (index >= count) {
+                    if (bun.Environment.isDebug)
+                        bun.Output.debugWarn("Invalid output piece boundary", .{});
+                    break;
+                },
+                else => unreachable,
+            }
+
+            try pieces.append(OutputPiece.init(output[0..boundary], .{
+                .kind = kind,
+                .index = @intCast(index),
+            }));
             output = output[boundary + prefix.len + 9 ..];
         }
 
-        return Chunk.IntermediateOutput{
+        try pieces.append(OutputPiece.init(output, OutputPiece.Query.none));
+
+        return .{
             .pieces = bun.BabyList(Chunk.OutputPiece).init(pieces.items),
         };
     }
@@ -11691,7 +14545,8 @@ const PathTemplate = options.PathTemplate;
 
 pub const Chunk = struct {
     /// This is a random string and is used to represent the output path of this
-    /// chunk before the final output path has been computed.
+    /// chunk before the final output path has been computed. See OutputPiece
+    /// for more info on this technique.
     unique_key: string = "",
 
     files_with_parts_in_chunk: std.AutoArrayHashMapUnmanaged(Index.Int, void) = .{},
@@ -11700,6 +14555,7 @@ pub const Chunk = struct {
     entry_bits: AutoBitSet = undefined,
 
     final_rel_path: string = "",
+    /// The path template used to generate `final_rel_path`
     template: PathTemplate = .{},
 
     /// For code splitting
@@ -11751,9 +14607,11 @@ pub const Chunk = struct {
     /// Can we make the JSPrinter itself track this without increasing
     /// complexity a lot?
     pub const IntermediateOutput = union(enum) {
-        /// If the chunk has references to other chunks, then "pieces" contains the
-        /// contents of the chunk. Another joiner
-        /// will have to be constructed later when merging the pieces together.
+        /// If the chunk has references to other chunks, then "pieces" contains
+        /// the contents of the chunk. Another joiner will have to be
+        /// constructed later when merging the pieces together.
+        ///
+        /// See OutputPiece's documentation comment for more details.
         pieces: bun.BabyList(OutputPiece),
 
         /// If the chunk doesn't have any references to other chunks, then
@@ -11778,7 +14636,8 @@ pub const Chunk = struct {
         pub fn code(
             this: *IntermediateOutput,
             allocator_to_use: ?std.mem.Allocator,
-            graph: *const Graph,
+            parse_graph: *const Graph,
+            linker_graph: *const LinkerGraph,
             import_prefix: []const u8,
             chunk: *Chunk,
             chunks: []Chunk,
@@ -11788,7 +14647,8 @@ pub const Chunk = struct {
             return switch (enable_source_map_shifts) {
                 inline else => |source_map_shifts| this.codeWithSourceMapShifts(
                     allocator_to_use,
-                    graph,
+                    parse_graph,
+                    linker_graph,
                     import_prefix,
                     chunk,
                     chunks,
@@ -11802,6 +14662,7 @@ pub const Chunk = struct {
             this: *IntermediateOutput,
             allocator_to_use: ?std.mem.Allocator,
             graph: *const Graph,
+            linker_graph: *const LinkerGraph,
             import_prefix: []const u8,
             chunk: *Chunk,
             chunks: []Chunk,
@@ -11812,6 +14673,8 @@ pub const Chunk = struct {
             const unique_key_for_additional_files = graph.input_files.items(.unique_key_for_additional_file);
             switch (this.*) {
                 .pieces => |*pieces| {
+                    const entry_point_chunks_for_scb = linker_graph.files.items(.entry_point_chunk_index);
+
                     var shift = if (enable_source_map_shifts)
                         sourcemap.SourceMapShifts{
                             .after = .{},
@@ -11831,10 +14694,10 @@ pub const Chunk = struct {
                     for (pieces.slice()) |piece| {
                         count += piece.data_len;
 
-                        switch (piece.index.kind) {
-                            .chunk, .asset => {
-                                const index = piece.index.index;
-                                const file_path = switch (piece.index.kind) {
+                        switch (piece.query.kind) {
+                            .chunk, .asset, .scb => {
+                                const index = piece.query.index;
+                                const file_path = switch (piece.query.kind) {
                                     .asset => brk: {
                                         const files = additional_files[index];
                                         if (!(files.len > 0)) {
@@ -11846,7 +14709,8 @@ pub const Chunk = struct {
                                         break :brk graph.additional_output_files.items[output_file].dest_path;
                                     },
                                     .chunk => chunks[index].final_rel_path,
-                                    else => unreachable,
+                                    .scb => chunks[entry_point_chunks_for_scb[index]].final_rel_path,
+                                    .none => unreachable,
                                 };
 
                                 const cheap_normalizer = cheapPrefixNormalizer(
@@ -11889,34 +14753,41 @@ pub const Chunk = struct {
 
                         remain = remain[data.len..];
 
-                        switch (piece.index.kind) {
-                            .asset, .chunk => {
-                                const index = piece.index.index;
-                                const file_path = brk: {
-                                    switch (piece.index.kind) {
-                                        .asset => {
-                                            const files = additional_files[index];
-                                            bun.assert(files.len > 0);
+                        switch (piece.query.kind) {
+                            .asset, .chunk, .scb => {
+                                const index = piece.query.index;
+                                const file_path = switch (piece.query.kind) {
+                                    .asset => brk: {
+                                        const files = additional_files[index];
+                                        bun.assert(files.len > 0);
 
-                                            const output_file = files.last().?.output_file;
+                                        const output_file = files.last().?.output_file;
 
-                                            if (enable_source_map_shifts) {
-                                                shift.before.advance(unique_key_for_additional_files[index]);
-                                            }
+                                        if (enable_source_map_shifts) {
+                                            shift.before.advance(unique_key_for_additional_files[index]);
+                                        }
 
-                                            break :brk graph.additional_output_files.items[output_file].dest_path;
-                                        },
-                                        .chunk => {
-                                            const piece_chunk = chunks[index];
+                                        break :brk graph.additional_output_files.items[output_file].dest_path;
+                                    },
+                                    .chunk => brk: {
+                                        const piece_chunk = chunks[index];
 
-                                            if (enable_source_map_shifts) {
-                                                shift.before.advance(piece_chunk.unique_key);
-                                            }
+                                        if (enable_source_map_shifts) {
+                                            shift.before.advance(piece_chunk.unique_key);
+                                        }
 
-                                            break :brk piece_chunk.final_rel_path;
-                                        },
-                                        else => unreachable,
-                                    }
+                                        break :brk piece_chunk.final_rel_path;
+                                    },
+                                    .scb => brk: {
+                                        const piece_chunk = chunks[entry_point_chunks_for_scb[index]];
+
+                                        if (enable_source_map_shifts) {
+                                            shift.before.advance(piece_chunk.unique_key);
+                                        }
+
+                                        break :brk piece_chunk.final_rel_path;
+                                    },
+                                    else => unreachable,
                                 };
 
                                 // normalize windows paths to '/'
@@ -12005,41 +14876,65 @@ pub const Chunk = struct {
         }
     };
 
+    /// An issue with asset files and server component boundaries is they
+    /// contain references to output paths, but those paths are not known until
+    /// very late in the bundle. The solution is to have a magic word in the
+    /// bundle text (BundleV2.unique_key, a random u64; impossible to guess).
+    /// When a file wants a path to an emitted chunk, it emits the unique key
+    /// in hex followed by the kind of path it wants:
+    ///
+    ///     `74f92237f4a85a6aA00000009` --> `./some-asset.png`
+    ///      ^--------------^|^------- .query.index
+    ///      unique_key      .query.kind
+    ///
+    /// An output piece is the concatenation of source code text and an output
+    /// path, in that order. An array of pieces makes up an entire file.
     pub const OutputPiece = struct {
-        // laid out like this so it takes up the same amount of space as a []const u8
-        data_ptr: [*]const u8 = undefined,
-        data_len: u32 = 0,
+        /// Pointer and length split to reduce struct size
+        data_ptr: [*]const u8,
+        data_len: u32,
+        query: Query,
 
-        index: OutputPieceIndex = .{},
-
-        pub inline fn data(this: OutputPiece) []const u8 {
+        pub fn data(this: OutputPiece) []const u8 {
             return this.data_ptr[0..this.data_len];
         }
+
+        pub const Query = packed struct(u32) {
+            index: u30,
+            kind: Kind,
+
+            pub const Kind = enum(u2) {
+                /// The last piece in an array uses this to indicate it is just data
+                none,
+                /// Given a source index, print the asset's output
+                asset,
+                /// Given a chunk index, print the chunk's output path
+                chunk,
+                /// Given a server component boundary index, print the chunk's output path
+                scb,
+            };
+
+            pub const none: Query = .{ .index = 0, .kind = .none };
+        };
+
+        pub fn init(data_slice: []const u8, query: Query) OutputPiece {
+            return .{
+                .data_ptr = data_slice.ptr,
+                .data_len = @intCast(data_slice.len),
+                .query = query,
+            };
+        }
     };
 
-    pub const OutputPieceIndex = packed struct {
-        index: u30 = 0,
-
-        kind: Kind = Kind.none,
-
-        pub const Kind = enum(u2) {
-            /// The "kind" may be "none" in which case there is one piece
-            /// with data and no chunk index. For example, the chunk may not contain any
-            /// imports.
-            none,
-
-            asset,
-            chunk,
-        };
-    };
+    pub const OutputPieceIndex = OutputPiece.Query;
 
     pub const EntryPoint = packed struct(u64) {
         /// Index into `Graph.input_files`
-        source_index: Index.Int = 0,
-        entry_point_id: ID = 0,
+        source_index: u32 = 0,
+        entry_point_id: u31 = 0,
         is_entry_point: bool = false,
 
-        // so it fits in a 64-bit integer
+        /// so `EntryPoint` can be a u64
         pub const ID = u31;
     };
 
@@ -12052,12 +14947,107 @@ pub const Chunk = struct {
         imports_from_other_chunks: ImportsFromOtherChunks = .{},
         cross_chunk_prefix_stmts: BabyList(Stmt) = .{},
         cross_chunk_suffix_stmts: BabyList(Stmt) = .{},
+
+        /// Indexes to CSS chunks. Currently this will only ever be zero or one
+        /// items long, but smarter css chunking will allow multiple js entry points
+        /// share a css file, or have an entry point contain multiple css files.
+        ///
+        /// Mutated while sorting chunks in `computeChunks`
+        css_chunks: []u32 = &.{},
+    };
+
+    pub const CssChunk = struct {
+        imports_in_chunk_in_order: BabyList(CssImportOrder),
+        /// When creating a chunk, this is to be an uninitialized slice with
+        /// length of `imports_in_chunk_in_order`
+        ///
+        /// Multiple imports may refer to the same file/stylesheet, but may need to
+        /// wrap them in conditions (e.g. a layer).
+        ///
+        /// When we go through the `prepareCssAstsForChunk()` step, each import will
+        /// create a shallow copy of the file's AST (just dereferencing the pointer).
+        asts: []bun.css.BundlerStyleSheet,
+    };
+
+    const CssImportKind = enum {
+        source_index,
+        external_path,
+        import_layers,
+    };
+
+    pub const CssImportOrder = struct {
+        conditions: BabyList(bun.css.ImportConditions) = .{},
+        // TODO: unfuck this
+        condition_import_records: BabyList(ImportRecord) = .{},
+
+        kind: union(enum) {
+            // kind == .import_layers
+            layers: [][]const u8,
+            // kind == .external_path
+            external_path: bun.fs.Path,
+            // kind == .source_idnex
+            source_index: Index,
+        },
+
+        pub fn hash(this: *const CssImportOrder, hasher: anytype) void {
+            // TODO: conditions, condition_import_records
+
+            bun.writeAnyToHasher(hasher, std.meta.activeTag(this.kind));
+            switch (this.kind) {
+                .layers => |layers| {
+                    for (layers) |layer| hasher.update(layer);
+                    hasher.update("\x00");
+                },
+                .external_path => |path| hasher.update(path.text),
+                .source_index => |idx| bun.writeAnyToHasher(hasher, idx),
+            }
+        }
+
+        pub fn format(this: *const CssImportOrder, comptime _: []const u8, _: std.fmt.FormatOptions, writer: anytype) !void {
+            try writer.print("{s} = ", .{@tagName(this.kind)});
+            switch (this.kind) {
+                .layers => |layers| {
+                    try writer.print("[", .{});
+                    for (layers, 0..) |layer, i| {
+                        if (i > 0) try writer.print(", ", .{});
+                        try writer.print("\"{s}\"", .{layer});
+                    }
+                    try writer.print("]", .{});
+                },
+                .external_path => |path| {
+                    try writer.print("\"{s}\"", .{path.pretty});
+                },
+                .source_index => |source_index| {
+                    try writer.print("{d}", .{source_index.get()});
+                },
+            }
+        }
     };
 
     pub const ImportsFromOtherChunks = std.AutoArrayHashMapUnmanaged(Index.Int, CrossChunkImport.Item.List);
 
-    pub const Content = union(enum) {
+    pub const ContentKind = enum {
+        javascript,
+        css,
+    };
+
+    pub const Content = union(ContentKind) {
         javascript: JavaScriptChunk,
+        css: CssChunk,
+
+        pub fn loader(this: *const Content) Loader {
+            return switch (this.*) {
+                .javascript => .js,
+                .css => .css,
+            };
+        }
+
+        pub fn ext(this: *const Content) string {
+            return switch (this.*) {
+                .javascript => "js",
+                .css => "css",
+            };
+        }
     };
 };
 
@@ -12124,11 +15114,17 @@ pub const CrossChunkImport = struct {
     }
 };
 
-const CompileResult = union(enum) {
+pub const CompileResult = union(enum) {
     javascript: struct {
         source_index: Index.Int,
         result: js_printer.PrintResult,
     },
+    css: struct {
+        source_index: Index.Int,
+        code: []const u8,
+        // TODO: we need to do this
+        source_map: ?bun.sourcemap.Chunk = null,
+    },
 
     pub const empty = CompileResult{
         .javascript = .{
@@ -12147,7 +15143,7 @@ const CompileResult = union(enum) {
                 .result => |r2| r2.code,
                 else => "",
             },
-            // else => "",
+            .css => |*c| c.code,
         };
     }
 
@@ -12157,12 +15153,14 @@ const CompileResult = union(enum) {
                 .result => |r2| r2.source_map,
                 else => null,
             },
+            .css => |*c| c.source_map,
         };
     }
 
     pub fn sourceIndex(this: *const CompileResult) Index.Int {
         return switch (this.*) {
             .javascript => |r| r.source_index,
+            .css => |*c| c.source_index,
             // else => 0,
         };
     }
@@ -12206,7 +15204,7 @@ const ContentHasher = struct {
 // meant to be fast but not 100% thorough
 // users can correctly put in a trailing slash if they want
 // this is just being nice
-fn cheapPrefixNormalizer(prefix: []const u8, suffix: []const u8) [2]string {
+pub fn cheapPrefixNormalizer(prefix: []const u8, suffix: []const u8) [2]string {
     if (prefix.len == 0) {
         const suffix_no_slash = bun.strings.removeLeadingDotSlash(suffix);
         return .{
@@ -12240,113 +15238,6 @@ fn cheapPrefixNormalizer(prefix: []const u8, suffix: []const u8) [2]string {
     };
 }
 
-const components_manifest_path = "./components-manifest.blob";
-
-// For Server Components, we generate an entry point which re-exports all client components
-// This is a "shadow" of the server entry point.
-// The client is expected to import this shadow entry point
-const ShadowEntryPoint = struct {
-    from_source_index: Index.Int,
-    to_source_index: Index.Int,
-
-    named_exports: bun.BabyList(NamedExport) = .{},
-
-    pub const NamedExport = struct {
-        // TODO: packed string
-        from: string,
-        to: string,
-        source_index: Index.Int,
-    };
-
-    pub const Builder = struct {
-        source_code_buffer: MutableString,
-        ctx: *BundleV2,
-        resolved_source_indices: std.ArrayList(Index.Int),
-        shadow: *ShadowEntryPoint,
-
-        pub fn addClientComponent(
-            this: *ShadowEntryPoint.Builder,
-            source_index: usize,
-        ) void {
-            var writer = this.source_code_buffer.writer();
-            const path = this.ctx.graph.input_files.items(.source)[source_index].path;
-            // TODO: tree-shaking to named imports only
-            writer.print(
-                \\// {s}
-                \\import {} from '${d}';
-                \\export {};
-                \\
-            ,
-                .{
-                    path.pretty,
-                    ImportsFormatter{ .ctx = this.ctx, .source_index = @as(Index.Int, @intCast(source_index)), .pretty = path.pretty },
-                    bun.fmt.hexIntUpper(bun.hash(path.pretty)),
-                    ExportsFormatter{ .ctx = this.ctx, .source_index = @as(Index.Int, @intCast(source_index)), .pretty = path.pretty, .shadow = this.shadow },
-                },
-            ) catch unreachable;
-            this.resolved_source_indices.append(@as(Index.Int, @truncate(source_index))) catch unreachable;
-        }
-    };
-    const ImportsFormatter = struct {
-        ctx: *BundleV2,
-        pretty: string,
-        source_index: Index.Int,
-        pub fn format(self: ImportsFormatter, comptime _: []const u8, _: std.fmt.FormatOptions, writer: anytype) !void {
-            var this = self.ctx;
-            const named_exports: *js_ast.Ast.NamedExports = &this.graph.ast.items(.named_exports)[self.source_index];
-            try writer.writeAll("{");
-            for (named_exports.keys()) |*named| {
-                named.* = try std.fmt.allocPrint(
-                    this.graph.allocator,
-                    "${}_{s}",
-                    .{
-                        bun.fmt.hexIntLower(bun.hash(self.pretty)),
-                        named.*,
-                    },
-                );
-            }
-            try named_exports.reIndex();
-
-            for (named_exports.keys(), 0..) |name, i| {
-                try writer.writeAll(name);
-                if (i < named_exports.count() - 1) {
-                    try writer.writeAll(" , ");
-                }
-            }
-            try writer.writeAll("}");
-        }
-    };
-
-    const ExportsFormatter = struct {
-        ctx: *BundleV2,
-        pretty: string,
-        source_index: Index.Int,
-        shadow: *ShadowEntryPoint,
-        pub fn format(self: ExportsFormatter, comptime _: []const u8, _: std.fmt.FormatOptions, writer: anytype) !void {
-            var this = self.ctx;
-            const named_exports: js_ast.Ast.NamedExports = this.graph.ast.items(.named_exports)[self.source_index];
-            try writer.writeAll("{");
-            var shadow = self.shadow;
-            try shadow.named_exports.ensureUnusedCapacity(this.graph.allocator, named_exports.count());
-            const last = named_exports.count() - 1;
-            for (named_exports.keys(), 0..) |name, i| {
-                try shadow.named_exports.push(this.graph.allocator, .{
-                    .from = name,
-                    .to = name,
-                    .source_index = self.source_index,
-                });
-
-                try writer.writeAll(name);
-
-                if (i < last) {
-                    try writer.writeAll(" , ");
-                }
-            }
-            try writer.writeAll("}");
-        }
-    };
-};
-
 fn getRedirectId(id: u32) ?u32 {
     if (id == std.math.maxInt(u32)) {
         return null;
@@ -12368,3 +15259,416 @@ fn targetFromHashbang(buffer: []const u8) ?options.Target {
 
     return null;
 }
+
+/// Utility to construct `Ast`s intended for generated code, such as the
+/// boundary modules when dealing with server components. This is a saner
+/// alternative to building a string, then sending it through `js_parser`
+///
+/// For in-depth details on the fields, most of these are documented
+/// inside of `js_parser`
+pub const AstBuilder = struct {
+    allocator: std.mem.Allocator,
+    source: *const Logger.Source,
+    source_index: u31,
+    stmts: std.ArrayListUnmanaged(Stmt),
+    scopes: std.ArrayListUnmanaged(*Scope),
+    symbols: std.ArrayListUnmanaged(Symbol),
+    import_records: std.ArrayListUnmanaged(ImportRecord),
+    named_imports: js_ast.Ast.NamedImports,
+    named_exports: js_ast.Ast.NamedExports,
+    import_records_for_current_part: std.ArrayListUnmanaged(u32),
+    export_star_import_records: std.ArrayListUnmanaged(u32),
+    current_scope: *Scope,
+    log: Logger.Log,
+    module_ref: Ref,
+    declared_symbols: js_ast.DeclaredSymbol.List,
+    /// When set, codegen is altered
+    hot_reloading: bool,
+
+    // stub fields for ImportScanner duck typing
+    comptime options: js_parser.Parser.Options = .{
+        .jsx = .{},
+        .bundle = true,
+    },
+    comptime import_items_for_namespace: struct {
+        pub fn get(_: @This(), _: Ref) ?js_parser.ImportItemForNamespaceMap {
+            return null;
+        }
+    } = .{},
+    pub const parser_features = struct {
+        pub const typescript = false;
+    };
+
+    pub fn init(allocator: std.mem.Allocator, source: *const Logger.Source, hot_reloading: bool) !AstBuilder {
+        const scope = try allocator.create(Scope);
+        scope.* = .{
+            .kind = .entry,
+            .label_ref = null,
+            .parent = null,
+            .generated = .{},
+        };
+        var ab: AstBuilder = .{
+            .allocator = allocator,
+            .current_scope = scope,
+            .source = source,
+            .source_index = @intCast(source.index.get()),
+            .stmts = .{},
+            .scopes = .{},
+            .symbols = .{},
+            .import_records = .{},
+            .import_records_for_current_part = .{},
+            .named_imports = .{},
+            .named_exports = .{},
+            .log = Logger.Log.init(allocator),
+            .export_star_import_records = .{},
+            .module_ref = Ref.None,
+            .declared_symbols = .{},
+            .hot_reloading = hot_reloading,
+        };
+        ab.module_ref = try ab.newSymbol(.other, "module");
+        return ab;
+    }
+
+    pub fn pushScope(p: *AstBuilder, kind: Scope.Kind) *js_ast.Scope {
+        try p.scopes.ensureUnusedCapacity(p.allocator, 1);
+        try p.current_scope.children.ensureUnusedCapacity(p.allocator, 1);
+        const scope = try p.allocator.create(Scope);
+        scope.* = .{
+            .kind = kind,
+            .label_ref = null,
+            .parent = p.current_scope,
+            .generated = .{},
+        };
+        p.current_scope.children.appendAssumeCapacity(scope);
+        p.scopes.appendAssumeCapacity(p.current_scope);
+        p.current_scope = scope;
+        return scope;
+    }
+
+    pub fn popScope(p: *AstBuilder) void {
+        p.current_scope = p.scopes.pop();
+    }
+
+    pub fn newSymbol(p: *AstBuilder, kind: Symbol.Kind, identifier: []const u8) !Ref {
+        const inner_index: Ref.Int = @intCast(p.symbols.items.len);
+        try p.symbols.append(p.allocator, .{
+            .kind = kind,
+            .original_name = identifier,
+            .debug_mode_source_index = if (Environment.allow_assert) @intCast(p.source_index) else 0,
+        });
+        const ref: Ref = .{
+            .inner_index = inner_index,
+            .source_index = p.source_index,
+            .tag = .symbol,
+        };
+        try p.current_scope.generated.push(p.allocator, ref);
+        try p.declared_symbols.append(p.allocator, .{
+            .ref = ref,
+            .is_top_level = p.scopes.items.len == 0 or p.current_scope == p.scopes.items[0],
+        });
+        return ref;
+    }
+
+    pub fn getSymbol(p: *AstBuilder, ref: Ref) *Symbol {
+        bun.assert(ref.source_index == p.source.index.get());
+        return &p.symbols.items[ref.inner_index];
+    }
+
+    pub fn addImportRecord(p: *AstBuilder, path: []const u8, kind: ImportKind) !u32 {
+        const index = p.import_records.items.len;
+        try p.import_records.append(p.allocator, .{
+            .path = bun.fs.Path.init(path),
+            .kind = kind,
+            .range = .{},
+        });
+        return @intCast(index);
+    }
+
+    pub fn addImportStmt(
+        p: *AstBuilder,
+        path: []const u8,
+        identifiers_to_import: anytype,
+    ) ![identifiers_to_import.len]Expr {
+        var out: [identifiers_to_import.len]Expr = undefined;
+
+        const record = try p.addImportRecord(path, .stmt);
+
+        var path_name = bun.fs.PathName.init(path);
+        const name = try strings.append(p.allocator, "import_", try path_name.nonUniqueNameString(p.allocator));
+        const namespace_ref = try p.newSymbol(.other, name);
+
+        const clauses = try p.allocator.alloc(js_ast.ClauseItem, identifiers_to_import.len);
+
+        inline for (identifiers_to_import, &out, clauses) |import_id_untyped, *out_ref, *clause| {
+            const import_id: []const u8 = import_id_untyped; // must be given '[N][]const u8'
+            const ref = try p.newSymbol(.import, import_id);
+            if (p.hot_reloading) {
+                p.getSymbol(ref).namespace_alias = .{
+                    .namespace_ref = namespace_ref,
+                    .alias = import_id,
+                    .import_record_index = record,
+                };
+            }
+            out_ref.* = p.newExpr(E.ImportIdentifier{ .ref = ref });
+            clause.* = .{
+                .name = .{ .loc = Logger.Loc.Empty, .ref = ref },
+                .original_name = import_id,
+                .alias = import_id,
+            };
+        }
+
+        try p.appendStmt(S.Import{
+            .namespace_ref = namespace_ref,
+            .import_record_index = record,
+            .items = clauses,
+            .is_single_line = identifiers_to_import.len < 1,
+        });
+
+        return out;
+    }
+
+    pub fn appendStmt(p: *AstBuilder, data: anytype) !void {
+        try p.stmts.ensureUnusedCapacity(p.allocator, 1);
+        p.stmts.appendAssumeCapacity(p.newStmt(data));
+    }
+
+    pub fn newStmt(p: *AstBuilder, data: anytype) Stmt {
+        _ = p;
+        return Stmt.alloc(@TypeOf(data), data, Logger.Loc.Empty);
+    }
+
+    pub fn newExpr(p: *AstBuilder, data: anytype) Expr {
+        _ = p;
+        return Expr.init(@TypeOf(data), data, Logger.Loc.Empty);
+    }
+
+    pub fn newExternalSymbol(p: *AstBuilder, name: []const u8) !Ref {
+        const ref = try p.newSymbol(.other, name);
+        const sym = p.getSymbol(ref);
+        sym.must_not_be_renamed = true;
+        return ref;
+    }
+
+    pub fn toBundledAst(p: *AstBuilder, target: options.Target) !js_ast.BundledAst {
+        // TODO: missing import scanner
+        bun.assert(p.scopes.items.len == 0);
+        const module_scope = p.current_scope;
+
+        var parts = try js_ast.Part.List.initCapacity(p.allocator, 2);
+        parts.len = 2;
+        parts.mut(0).* = .{};
+        parts.mut(1).* = .{
+            .stmts = p.stmts.items,
+            .can_be_removed_if_unused = false,
+
+            // pretend that every symbol was used
+            .symbol_uses = uses: {
+                var map: js_ast.Part.SymbolUseMap = .{};
+                try map.ensureTotalCapacity(p.allocator, p.symbols.items.len);
+                for (0..p.symbols.items.len) |i| {
+                    map.putAssumeCapacity(Ref{
+                        .tag = .symbol,
+                        .source_index = p.source_index,
+                        .inner_index = @intCast(i),
+                    }, .{ .count_estimate = 1 });
+                }
+                break :uses map;
+            },
+        };
+
+        const single_u32 = try BabyList(u32).fromSlice(p.allocator, &.{1});
+
+        var top_level_symbols_to_parts = js_ast.Ast.TopLevelSymbolToParts{};
+        try top_level_symbols_to_parts.entries.setCapacity(p.allocator, module_scope.generated.len);
+        top_level_symbols_to_parts.entries.len = module_scope.generated.len;
+        const slice = top_level_symbols_to_parts.entries.slice();
+        for (
+            slice.items(.key),
+            slice.items(.value),
+            module_scope.generated.slice(),
+        ) |*k, *v, ref| {
+            k.* = ref;
+            v.* = single_u32;
+        }
+        try top_level_symbols_to_parts.reIndex(p.allocator);
+
+        // For more details on this section, look at js_parser.toAST
+        // This is mimicking how it calls ImportScanner
+        if (p.hot_reloading) {
+            var hmr_transform_ctx = js_parser.ConvertESMExportsForHmr{
+                .last_part = parts.last() orelse
+                    unreachable, // was definitely allocated
+            };
+            try hmr_transform_ctx.stmts.ensureTotalCapacity(p.allocator, prealloc_count: {
+                // get a estimate on how many statements there are going to be
+                const count = p.stmts.items.len;
+                break :prealloc_count count + 2;
+            });
+
+            _ = try js_parser.ImportScanner.scan(AstBuilder, p, p.stmts.items, false, true, &hmr_transform_ctx);
+
+            const new_parts = try hmr_transform_ctx.finalize(p, parts.slice());
+            // preserve original capacity
+            parts.len = @intCast(new_parts.len);
+            bun.assert(new_parts.ptr == parts.ptr);
+        } else {
+            const result = try js_parser.ImportScanner.scan(AstBuilder, p, p.stmts.items, false, false, {});
+            parts.mut(1).stmts = result.stmts;
+        }
+
+        parts.mut(1).declared_symbols = p.declared_symbols;
+        parts.mut(1).scopes = p.scopes.items;
+        parts.mut(1).import_record_indices = BabyList(u32).fromList(p.import_records_for_current_part);
+
+        return .{
+            .parts = parts,
+            .module_scope = module_scope.*,
+            .symbols = js_ast.Symbol.List.fromList(p.symbols),
+            .exports_ref = Ref.None,
+            .wrapper_ref = Ref.None,
+            .module_ref = p.module_ref,
+            .import_records = ImportRecord.List.fromList(p.import_records),
+            .export_star_import_records = &.{},
+            .approximate_newline_count = 1,
+            .exports_kind = .esm,
+            .named_imports = p.named_imports,
+            .named_exports = p.named_exports,
+            .top_level_symbols_to_parts = top_level_symbols_to_parts,
+            .char_freq = .{},
+            .flags = .{},
+            .target = target,
+            .top_level_await_keyword = Logger.Range.None,
+            // .nested_scope_slot_counts = if (p.options.features.minify_identifiers)
+            //     renamer.assignNestedScopeSlots(p.allocator, p.scopes.items[0], p.symbols.items)
+            // else
+            //     js_ast.SlotCounts{},
+        };
+    }
+
+    // stub methods for ImportScanner duck typing
+
+    pub fn generateTempRef(ab: *AstBuilder, name: ?[]const u8) Ref {
+        return ab.newSymbol(.other, name orelse "temp") catch bun.outOfMemory();
+    }
+
+    pub fn recordExport(p: *AstBuilder, _: Logger.Loc, alias: []const u8, ref: Ref) !void {
+        if (p.named_exports.get(alias)) |_| {
+            // Duplicate exports are an error
+            Output.panic(
+                "In generated file, duplicate export \"{s}\"",
+                .{alias},
+            );
+        } else {
+            try p.named_exports.put(p.allocator, alias, .{ .alias_loc = Logger.Loc.Empty, .ref = ref });
+        }
+    }
+
+    pub fn recordExportedBinding(p: *AstBuilder, binding: Binding) void {
+        switch (binding.data) {
+            .b_missing => {},
+            .b_identifier => |ident| {
+                p.recordExport(binding.loc, p.symbols.items[ident.ref.innerIndex()].original_name, ident.ref) catch unreachable;
+            },
+            .b_array => |array| {
+                for (array.items) |prop| {
+                    p.recordExportedBinding(prop.binding);
+                }
+            },
+            .b_object => |obj| {
+                for (obj.properties) |prop| {
+                    p.recordExportedBinding(prop.value);
+                }
+            },
+        }
+    }
+
+    pub fn ignoreUsage(p: *AstBuilder, ref: Ref) void {
+        _ = p;
+        _ = ref;
+    }
+
+    pub fn panic(p: *AstBuilder, comptime fmt: []const u8, args: anytype) noreturn {
+        _ = p;
+        Output.panic(fmt, args);
+    }
+
+    pub fn @"module.exports"(p: *AstBuilder, loc: Logger.Loc) Expr {
+        return p.newExpr(E.Dot{ .name = "exports", .name_loc = loc, .target = p.newExpr(E.Identifier{ .ref = p.module_ref }) });
+    }
+};
+
+pub const CssEntryPointMeta = struct {
+    /// When this is true, a stub file is added to the Server's IncrementalGraph
+    imported_on_server: bool,
+};
+
+/// The lifetime of this structure is tied to the bundler's arena
+pub const BakeBundleStart = struct {
+    css_entry_points: std.AutoArrayHashMapUnmanaged(Index, CssEntryPointMeta),
+};
+
+/// The lifetime of this structure is tied to the bundler's arena
+pub const BakeBundleOutput = struct {
+    chunks: []Chunk,
+    css_file_list: std.AutoArrayHashMapUnmanaged(Index, CssEntryPointMeta),
+
+    pub fn jsPseudoChunk(out: BakeBundleOutput) *Chunk {
+        return &out.chunks[0];
+    }
+
+    pub fn cssChunks(out: BakeBundleOutput) []Chunk {
+        return out.chunks[1..];
+    }
+};
+
+pub fn generateUniqueKey() u64 {
+    const key = std.crypto.random.int(u64) & @as(u64, 0x0FFFFFFF_FFFFFFFF);
+    // without this check, putting unique_key in an object key would
+    // sometimes get converted to an identifier. ensuring it starts
+    // with a number forces that optimization off.
+    if (Environment.isDebug) {
+        var buf: [16]u8 = undefined;
+        const hex = std.fmt.bufPrint(&buf, "{}", .{bun.fmt.hexIntLower(key)}) catch
+            unreachable;
+        switch (hex[0]) {
+            '0'...'9' => {},
+            else => Output.panic("unique key is a valid identifier: {s}", .{hex}),
+        }
+    }
+    return key;
+}
+
+const ExternalFreeFunctionAllocator = struct {
+    free_callback: *const fn (ctx: *anyopaque) void,
+    context: *anyopaque,
+
+    const vtable: std.mem.Allocator.VTable = .{
+        .alloc = &alloc,
+        .free = &free,
+        .resize = &resize,
+    };
+
+    pub fn create(free_callback: *const fn (ctx: *anyopaque) void, context: *anyopaque) std.mem.Allocator {
+        return .{
+            .ptr = bun.create(bun.default_allocator, ExternalFreeFunctionAllocator, .{
+                .free_callback = free_callback,
+                .context = context,
+            }),
+            .vtable = &vtable,
+        };
+    }
+
+    fn alloc(_: *anyopaque, _: usize, _: u8, _: usize) ?[*]u8 {
+        return null;
+    }
+
+    fn resize(_: *anyopaque, _: []u8, _: u8, _: usize, _: usize) bool {
+        return false;
+    }
+
+    fn free(ext_free_function: *anyopaque, _: []u8, _: u8, _: usize) void {
+        const info: *ExternalFreeFunctionAllocator = @alignCast(@ptrCast(ext_free_function));
+        info.free_callback(info.context);
+        bun.default_allocator.destroy(info);
+    }
+};
diff --git a/src/bundler/entry_points.zig b/src/bundler/entry_points.zig
index 1237f02fa4..306116742f 100644
--- a/src/bundler/entry_points.zig
+++ b/src/bundler/entry_points.zig
@@ -172,34 +172,37 @@ 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}}`);
                     \\   }}
                     \\}}
                     \\
                 ,
                     .{
-                        strings.QuoteEscapeFormat{ .data = path_to_use },
+                        strings.formatEscapes(path_to_use, .{ .quote_char = '\'' }),
                     },
                 );
             }
@@ -210,17 +213,19 @@ 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}}`);
                 \\}}
                 \\
             ,
                 .{
-                    strings.QuoteEscapeFormat{ .data = path_to_use },
+                    strings.formatEscapes(path_to_use, .{ .quote_char = '"' }),
                 },
             );
         };
diff --git a/src/bunfig.zig b/src/bunfig.zig
index ede8389cde..f5e41c434d 100644
--- a/src/bunfig.zig
+++ b/src/bunfig.zig
@@ -52,12 +52,20 @@ pub const Bunfig = struct {
         ctx: Command.Context,
 
         fn addError(this: *Parser, loc: logger.Loc, comptime text: string) !void {
-            this.log.addError(this.source, loc, text) catch unreachable;
+            this.log.addErrorOpts(text, .{
+                .source = this.source,
+                .loc = loc,
+                .redact_sensitive_information = true,
+            }) catch unreachable;
             return error.@"Invalid Bunfig";
         }
 
         fn addErrorFormat(this: *Parser, loc: logger.Loc, allocator: std.mem.Allocator, comptime text: string, args: anytype) !void {
-            this.log.addErrorFmt(this.source, loc, allocator, text, args) catch unreachable;
+            this.log.addErrorFmtOpts(allocator, text, args, .{
+                .source = this.source,
+                .loc = loc,
+                .redact_sensitive_information = true,
+            }) catch unreachable;
             return error.@"Invalid Bunfig";
         }
 
@@ -258,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) {
@@ -336,15 +355,15 @@ pub const Bunfig = struct {
             }
 
             if (comptime cmd.isNPMRelated() or cmd == .RunCommand or cmd == .AutoCommand) {
-                if (json.get("install")) |_bun| {
+                if (json.getObject("install")) |install_obj| {
                     var install: *Api.BunInstall = this.ctx.install orelse brk: {
-                        const install_ = try this.allocator.create(Api.BunInstall);
-                        install_.* = std.mem.zeroes(Api.BunInstall);
-                        this.ctx.install = install_;
-                        break :brk install_;
+                        const install = try this.allocator.create(Api.BunInstall);
+                        install.* = std.mem.zeroes(Api.BunInstall);
+                        this.ctx.install = install;
+                        break :brk install;
                     };
 
-                    if (_bun.get("auto")) |auto_install_expr| {
+                    if (install_obj.get("auto")) |auto_install_expr| {
                         if (auto_install_expr.data == .e_string) {
                             this.ctx.debug.global_cache = options.GlobalCache.Map.get(auto_install_expr.asString(this.allocator) orelse "") orelse {
                                 try this.addError(auto_install_expr.loc, "Invalid auto install setting, must be one of true, false, or \"force\" \"fallback\" \"disable\"");
@@ -361,13 +380,46 @@ pub const Bunfig = struct {
                         }
                     }
 
-                    if (_bun.get("exact")) |exact| {
+                    if (install_obj.get("cafile")) |cafile| {
+                        install.cafile = try cafile.asStringCloned(allocator) orelse {
+                            try this.addError(cafile.loc, "Invalid cafile. Expected a string.");
+                            return;
+                        };
+                    }
+
+                    if (install_obj.get("ca")) |ca| {
+                        switch (ca.data) {
+                            .e_array => |arr| {
+                                var list = try allocator.alloc([]const u8, arr.items.len);
+                                for (arr.items.slice(), 0..) |item, i| {
+                                    list[i] = try item.asStringCloned(allocator) orelse {
+                                        try this.addError(item.loc, "Invalid CA. Expected a string.");
+                                        return;
+                                    };
+                                }
+                                install.ca = .{
+                                    .list = list,
+                                };
+                            },
+                            .e_string => |str| {
+                                install.ca = .{
+                                    .str = try str.stringCloned(allocator),
+                                };
+                            },
+                            else => {
+                                try this.addError(ca.loc, "Invalid CA. Expected a string or an array of strings.");
+                                return;
+                            },
+                        }
+                    }
+
+                    if (install_obj.get("exact")) |exact| {
                         if (exact.asBool()) |value| {
                             install.exact = value;
                         }
                     }
 
-                    if (_bun.get("prefer")) |prefer_expr| {
+                    if (install_obj.get("prefer")) |prefer_expr| {
                         try this.expectString(prefer_expr);
 
                         if (Prefer.get(prefer_expr.asString(bun.default_allocator) orelse "")) |setting| {
@@ -377,11 +429,11 @@ pub const Bunfig = struct {
                         }
                     }
 
-                    if (_bun.get("registry")) |registry| {
+                    if (install_obj.get("registry")) |registry| {
                         install.default_registry = try this.parseRegistry(registry);
                     }
 
-                    if (_bun.get("scopes")) |scopes| {
+                    if (install_obj.get("scopes")) |scopes| {
                         var registry_map = install.scoped orelse Api.NpmRegistryMap{};
                         try this.expect(scopes, .e_object);
 
@@ -399,32 +451,32 @@ pub const Bunfig = struct {
                         install.scoped = registry_map;
                     }
 
-                    if (_bun.get("dryRun")) |dry_run| {
+                    if (install_obj.get("dryRun")) |dry_run| {
                         if (dry_run.asBool()) |value| {
                             install.dry_run = value;
                         }
                     }
 
-                    if (_bun.get("production")) |production| {
+                    if (install_obj.get("production")) |production| {
                         if (production.asBool()) |value| {
                             install.production = value;
                         }
                     }
 
-                    if (_bun.get("frozenLockfile")) |frozen_lockfile| {
+                    if (install_obj.get("frozenLockfile")) |frozen_lockfile| {
                         if (frozen_lockfile.asBool()) |value| {
                             install.frozen_lockfile = value;
                         }
                     }
 
-                    if (_bun.get("concurrentScripts")) |jobs| {
+                    if (install_obj.get("concurrentScripts")) |jobs| {
                         if (jobs.data == .e_number) {
                             install.concurrent_scripts = jobs.data.e_number.toU32();
                             if (install.concurrent_scripts.? == 0) install.concurrent_scripts = null;
                         }
                     }
 
-                    if (_bun.get("lockfile")) |lockfile_expr| {
+                    if (install_obj.get("lockfile")) |lockfile_expr| {
                         if (lockfile_expr.get("print")) |lockfile| {
                             try this.expectString(lockfile);
                             if (lockfile.asString(this.allocator)) |value| {
@@ -457,41 +509,41 @@ pub const Bunfig = struct {
                         }
                     }
 
-                    if (_bun.get("optional")) |optional| {
+                    if (install_obj.get("optional")) |optional| {
                         if (optional.asBool()) |value| {
                             install.save_optional = value;
                         }
                     }
 
-                    if (_bun.get("peer")) |optional| {
+                    if (install_obj.get("peer")) |optional| {
                         if (optional.asBool()) |value| {
                             install.save_peer = value;
                         }
                     }
 
-                    if (_bun.get("dev")) |optional| {
+                    if (install_obj.get("dev")) |optional| {
                         if (optional.asBool()) |value| {
                             install.save_dev = value;
                         }
                     }
 
-                    if (_bun.get("globalDir")) |dir| {
+                    if (install_obj.get("globalDir")) |dir| {
                         if (dir.asString(allocator)) |value| {
                             install.global_dir = value;
                         }
                     }
 
-                    if (_bun.get("globalBinDir")) |dir| {
+                    if (install_obj.get("globalBinDir")) |dir| {
                         if (dir.asString(allocator)) |value| {
                             install.global_bin_dir = value;
                         }
                     }
 
-                    if (_bun.get("logLevel")) |expr| {
+                    if (install_obj.get("logLevel")) |expr| {
                         try this.loadLogLevel(expr);
                     }
 
-                    if (_bun.get("cache")) |cache| {
+                    if (install_obj.get("cache")) |cache| {
                         load: {
                             if (cache.asBool()) |value| {
                                 if (!value) {
@@ -684,20 +736,6 @@ pub const Bunfig = struct {
                 jsx.development = jsx_dev;
             }
 
-            switch (comptime cmd) {
-                .AutoCommand, .BuildCommand => {
-                    if (json.get("publicDir")) |public_dir| {
-                        try this.expectString(public_dir);
-                        this.bunfig.router = Api.RouteConfig{
-                            .extensions = &.{},
-                            .dir = &.{},
-                            .static_dir = try public_dir.data.e_string.string(allocator),
-                        };
-                    }
-                },
-                else => {},
-            }
-
             if (json.get("debug")) |expr| {
                 if (expr.get("editor")) |editor| {
                     if (editor.asString(allocator)) |value| {
@@ -738,13 +776,6 @@ pub const Bunfig = struct {
                 }
             }
 
-            if (json.get("framework")) |expr| {
-                try this.expectString(expr);
-                this.bunfig.framework = Api.FrameworkConfig{
-                    .package = expr.asString(allocator).?,
-                };
-            }
-
             if (json.get("loader")) |expr| {
                 try this.expect(expr, .e_object);
                 const properties = expr.data.e_object.properties.slice();
@@ -777,11 +808,20 @@ 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.addErrorFmt(this.source, expr.loc, this.allocator, "expected string but received {}", .{
-                        @as(js_ast.Expr.Tag, expr.data),
-                    }) catch unreachable;
+                    this.log.addErrorFmtOpts(
+                        this.allocator,
+                        "expected string but received {}",
+                        .{
+                            @as(js_ast.Expr.Tag, expr.data),
+                        },
+                        .{
+                            .source = this.source,
+                            .loc = expr.loc,
+                            .redact_sensitive_information = true,
+                        },
+                    ) catch unreachable;
                     return error.@"Invalid Bunfig";
                 },
             }
@@ -789,10 +829,19 @@ pub const Bunfig = struct {
 
         pub fn expect(this: *Parser, expr: js_ast.Expr, token: js_ast.Expr.Tag) !void {
             if (@as(js_ast.Expr.Tag, expr.data) != token) {
-                this.log.addErrorFmt(this.source, expr.loc, this.allocator, "expected {} but received {}", .{
-                    token,
-                    @as(js_ast.Expr.Tag, expr.data),
-                }) catch unreachable;
+                this.log.addErrorFmtOpts(
+                    this.allocator,
+                    "expected {} but received {}",
+                    .{
+                        token,
+                        @as(js_ast.Expr.Tag, expr.data),
+                    },
+                    .{
+                        .source = this.source,
+                        .loc = expr.loc,
+                        .redact_sensitive_information = true,
+                    },
+                ) catch unreachable;
                 return error.@"Invalid Bunfig";
             }
         }
@@ -801,14 +850,20 @@ pub const Bunfig = struct {
     pub fn parse(allocator: std.mem.Allocator, source: logger.Source, ctx: Command.Context, comptime cmd: Command.Tag) !void {
         const log_count = ctx.log.errors + ctx.log.warnings;
 
-        const expr = if (strings.eqlComptime(source.path.name.ext[1..], "toml")) TOML.parse(&source, ctx.log, allocator) catch |err| {
+        const expr = if (strings.eqlComptime(source.path.name.ext[1..], "toml")) TOML.parse(&source, ctx.log, allocator, true) catch |err| {
             if (ctx.log.errors + ctx.log.warnings == log_count) {
-                ctx.log.addErrorFmt(&source, logger.Loc.Empty, allocator, "Failed to parse", .{}) catch unreachable;
+                try ctx.log.addErrorOpts("Failed to parse", .{
+                    .source = &source,
+                    .redact_sensitive_information = true,
+                });
             }
             return err;
-        } else JSONParser.ParseTSConfig(&source, ctx.log, allocator) catch |err| {
+        } else JSONParser.parseTSConfig(&source, ctx.log, allocator, true) catch |err| {
             if (ctx.log.errors + ctx.log.warnings == log_count) {
-                ctx.log.addErrorFmt(&source, logger.Loc.Empty, allocator, "Failed to parse", .{}) catch unreachable;
+                try ctx.log.addErrorOpts("Failed to parse", .{
+                    .source = &source,
+                    .redact_sensitive_information = true,
+                });
             }
             return err;
         };
diff --git a/src/c.zig b/src/c.zig
index ff9226a660..1579667ab9 100644
--- a/src/c.zig
+++ b/src/c.zig
@@ -31,12 +31,6 @@ pub extern "c" fn fchmodat(c_int, [*c]const u8, mode_t, c_int) c_int;
 pub extern "c" fn fchown(std.c.fd_t, std.c.uid_t, std.c.gid_t) c_int;
 pub extern "c" fn lchown(path: [*:0]const u8, std.c.uid_t, std.c.gid_t) c_int;
 pub extern "c" fn chown(path: [*:0]const u8, std.c.uid_t, std.c.gid_t) c_int;
-// TODO: this is wrong on Windows
-pub extern "c" fn lstat64([*c]const u8, [*c]libc_stat) c_int;
-// TODO: this is wrong on Windows
-pub extern "c" fn fstat64([*c]const u8, [*c]libc_stat) c_int;
-// TODO: this is wrong on Windows
-pub extern "c" fn stat64([*c]const u8, [*c]libc_stat) c_int;
 pub extern "c" fn lchmod(path: [*:0]const u8, mode: mode_t) c_int;
 pub extern "c" fn truncate([*:0]const u8, i64) c_int; // note: truncate64 is not a thing
 
@@ -46,19 +40,31 @@ pub extern "c" fn mkdtemp(template: [*c]u8) ?[*:0]u8;
 pub extern "c" fn memcmp(s1: [*c]const u8, s2: [*c]const u8, n: usize) c_int;
 pub extern "c" fn memchr(s: [*]const u8, c: u8, n: usize) ?[*]const u8;
 
-pub const lstat = lstat64;
-pub const fstat = fstat64;
-pub const stat = stat64;
-
 pub extern "c" fn strchr(str: [*]const u8, char: u8) ?[*]const u8;
 
+pub const lstat = blk: {
+    const T = *const fn ([*c]const u8, [*c]libc_stat) callconv(.C) c_int; // TODO: this is wrong on Windows
+    if (bun.Environment.isMusl) break :blk @extern(T, .{ .library_name = "c", .name = "lstat" });
+    break :blk @extern(T, .{ .name = "lstat64" });
+};
+pub const fstat = blk: {
+    const T = *const fn (c_int, [*c]libc_stat) callconv(.C) c_int; // TODO: this is wrong on Windows
+    if (bun.Environment.isMusl) break :blk @extern(T, .{ .library_name = "c", .name = "fstat" });
+    break :blk @extern(T, .{ .name = "fstat64" });
+};
+pub const stat = blk: {
+    const T = *const fn ([*c]const u8, [*c]libc_stat) callconv(.C) c_int; // TODO: this is wrong on Windows
+    if (bun.Environment.isMusl) break :blk @extern(T, .{ .library_name = "c", .name = "stat" });
+    break :blk @extern(T, .{ .name = "stat64" });
+};
+
 pub fn lstat_absolute(path: [:0]const u8) !Stat {
     if (builtin.os.tag == .windows) {
         @compileError("Not implemented yet, conside using bun.sys.lstat()");
     }
 
     var st = zeroes(libc_stat);
-    switch (errno(lstat64(path.ptr, &st))) {
+    switch (errno(lstat(path.ptr, &st))) {
         .SUCCESS => {},
         .NOENT => return error.FileNotFound,
         // .EINVAL => unreachable,
diff --git a/src/cache.zig b/src/cache.zig
index b82e2e10b7..ee164f1258 100644
--- a/src/cache.zig
+++ b/src/cache.zig
@@ -47,9 +47,23 @@ pub const Fs = struct {
     pub const Entry = struct {
         contents: string,
         fd: StoredFileDescriptorType = bun.invalid_fd,
+        external: External = .{},
+
+        pub const External = struct {
+            ctx: ?*anyopaque = null,
+            function: ?*const fn (?*anyopaque) callconv(.C) void = null,
+
+            pub fn call(this: *const @This()) void {
+                if (this.function) |func| {
+                    func(this.ctx);
+                }
+            }
+        };
 
         pub fn deinit(entry: *Entry, allocator: std.mem.Allocator) void {
-            if (entry.contents.len > 0) {
+            if (entry.external.function) |func| {
+                func(entry.external.ctx);
+            } else if (entry.contents.len > 0) {
                 allocator.free(entry.contents);
                 entry.contents = "";
             }
@@ -294,12 +308,12 @@ pub const Json = struct {
     pub fn init(_: std.mem.Allocator) Json {
         return Json{};
     }
-    fn parse(_: *@This(), log: *logger.Log, source: logger.Source, allocator: std.mem.Allocator, comptime func: anytype) anyerror!?js_ast.Expr {
+    fn parse(_: *@This(), log: *logger.Log, source: logger.Source, allocator: std.mem.Allocator, comptime func: anytype, comptime force_utf8: bool) anyerror!?js_ast.Expr {
         var temp_log = logger.Log.init(allocator);
         defer {
             temp_log.appendToMaybeRecycled(log, &source) catch {};
         }
-        return func(&source, &temp_log, allocator) catch handler: {
+        return func(&source, &temp_log, allocator, force_utf8) catch handler: {
             break :handler null;
         };
     }
@@ -308,17 +322,17 @@ pub const Json = struct {
         // They are JSON files with comments and trailing commas.
         // Sometimes tooling expects this to work.
         if (source.path.isJSONCFile()) {
-            return try parse(cache, log, source, allocator, json_parser.ParseTSConfig);
+            return try parse(cache, log, source, allocator, json_parser.parseTSConfig, true);
         }
 
-        return try parse(cache, log, source, allocator, json_parser.ParseJSON);
+        return try parse(cache, log, source, allocator, json_parser.parse, false);
     }
 
-    pub fn parsePackageJSON(cache: *@This(), log: *logger.Log, source: logger.Source, allocator: std.mem.Allocator) anyerror!?js_ast.Expr {
-        return try parse(cache, log, source, allocator, json_parser.ParseTSConfig);
+    pub fn parsePackageJSON(cache: *@This(), log: *logger.Log, source: logger.Source, allocator: std.mem.Allocator, comptime force_utf8: bool) anyerror!?js_ast.Expr {
+        return try parse(cache, log, source, allocator, json_parser.parseTSConfig, force_utf8);
     }
 
     pub fn parseTSConfig(cache: *@This(), log: *logger.Log, source: logger.Source, allocator: std.mem.Allocator) anyerror!?js_ast.Expr {
-        return try parse(cache, log, source, allocator, json_parser.ParseTSConfig);
+        return try parse(cache, log, source, allocator, json_parser.parseTSConfig, true);
     }
 };
diff --git a/src/ci_info.zig b/src/ci_info.zig
new file mode 100644
index 0000000000..ed88efc291
--- /dev/null
+++ b/src/ci_info.zig
@@ -0,0 +1,421 @@
+// A modified port of ci-info@4.0.0 (https://github.com/watson/ci-info)
+// Only gets the CI name, `isPR` is not implemented.
+
+// Names are changed to match what `npm publish` uses
+// https://github.com/npm/cli/blob/63d6a732c3c0e9c19fd4d147eaa5cc27c29b168d/workspaces/config/lib/definitions/definitions.js#L2129
+// `name.toLowerCase().split(' ').join('-')`
+
+const std = @import("std");
+const bun = @import("root").bun;
+const strings = bun.strings;
+
+var ci_name: ?[]const u8 = null;
+
+pub fn detectCI() ?[]const u8 {
+    const ci = ci_name orelse ci_name: {
+        CI.once.call();
+        break :ci_name ci_name.?;
+    };
+
+    return if (ci.len == 0) null else ci;
+}
+
+const CI = enum {
+    @"agola-ci",
+    appcircle,
+    appveyor,
+    @"aws-codebuild",
+    @"azure-pipelines",
+    bamboo,
+    @"bitbucket-pipelines",
+    bitrise,
+    buddy,
+    buildkite,
+    circleci,
+    @"cirrus-ci",
+    codefresh,
+    codemagic,
+    codeship,
+    drone,
+    dsari,
+    earthly,
+    @"expo-application-services",
+    gerrit,
+    @"gitea-actions",
+    @"github-actions",
+    @"gitlab-ci",
+    gocd,
+    @"google-cloud-build",
+    @"harness-ci",
+    // heroku,
+    hudson,
+    jenkins,
+    layerci,
+    @"magnum-ci",
+    @"netlify-ci",
+    nevercode,
+    prow,
+    releasehub,
+    render,
+    @"sail-ci",
+    screwdriver,
+    semaphore,
+    sourcehut,
+    @"strider-cd",
+    taskcluster,
+    teamcity,
+    @"travis-ci",
+    vela,
+    vercel,
+    @"visual-studio-app-center",
+    woodpecker,
+    @"xcode-cloud",
+    @"xcode-server",
+
+    pub var once = std.once(struct {
+        pub fn once() void {
+            var name: []const u8 = "";
+            defer ci_name = name;
+
+            if (bun.getenvZ("CI")) |ci| {
+                if (strings.eqlComptime(ci, "false")) {
+                    return;
+                }
+            }
+
+            // Special case Heroku
+            if (bun.getenvZ("NODE")) |node| {
+                if (strings.containsComptime(node, "/app/.heroku/node/bin/node")) {
+                    name = "heroku";
+                    return;
+                }
+            }
+
+            ci: for (CI.array.values, 0..) |item, i| {
+                const any, const pairs = item;
+
+                pairs: for (pairs) |pair| {
+                    const key, const value = pair;
+
+                    if (bun.getenvZ(key)) |env| {
+                        if (value.len == 0 or bun.strings.eqlLong(env, value, true)) {
+                            if (!any) continue :pairs;
+
+                            name = @tagName(Array.Indexer.keyForIndex(i));
+                            return;
+                        }
+                    }
+
+                    if (!any) continue :ci;
+                }
+
+                if (!any) {
+                    name = @tagName(Array.Indexer.keyForIndex(i));
+                    return;
+                }
+            }
+        }
+    }.once);
+
+    pub const Array = std.EnumArray(CI, struct { bool, []const [2][:0]const u8 });
+
+    pub const array = Array.init(.{
+        .@"agola-ci" = .{
+            false,
+            &.{
+                .{ "AGOLA_GIT_REF", "" },
+            },
+        },
+        .appcircle = .{
+            false,
+            &.{
+                .{ "AC_APPCIRCLE", "" },
+            },
+        },
+        .appveyor = .{
+            false,
+            &.{
+                .{ "APPVEYOR", "" },
+            },
+        },
+        .@"aws-codebuild" = .{
+            false,
+            &.{
+                .{ "CODEBUILD_BUILD_ARN", "" },
+            },
+        },
+        .@"azure-pipelines" = .{
+            false,
+            &.{
+                .{ "TF_BUILD", "" },
+            },
+        },
+        .bamboo = .{
+            false,
+            &.{
+                .{ "bamboo_planKey", "" },
+            },
+        },
+        .@"bitbucket-pipelines" = .{
+            false,
+            &.{
+                .{ "BITBUCKET_COMMIT", "" },
+            },
+        },
+        .bitrise = .{
+            false,
+            &.{
+                .{ "BITRISE_IO", "" },
+            },
+        },
+        .buddy = .{
+            false,
+            &.{
+                .{ "BUDDY_WORKSPACE_ID", "" },
+            },
+        },
+        .buildkite = .{
+            false,
+            &.{
+                .{ "BUILDKITE", "" },
+            },
+        },
+        .circleci = .{
+            false,
+            &.{
+                .{ "CIRCLECI", "" },
+            },
+        },
+        .@"cirrus-ci" = .{
+            false,
+            &.{
+                .{ "CIRRUS_CI", "" },
+            },
+        },
+        .codefresh = .{
+            false,
+            &.{
+                .{ "CF_BUILD_ID", "" },
+            },
+        },
+        .codemagic = .{
+            false,
+            &.{
+                .{ "CM_BUILD_ID", "" },
+            },
+        },
+        .codeship = .{
+            false,
+            &.{
+                .{ "CI_NAME", "codeship" },
+            },
+        },
+        .drone = .{
+            false,
+            &.{
+                .{ "DRONE", "" },
+            },
+        },
+        .dsari = .{
+            false,
+            &.{
+                .{ "DSARI", "" },
+            },
+        },
+        .earthly = .{
+            false,
+            &.{
+                .{ "EARTHLY_CI", "" },
+            },
+        },
+        .@"expo-application-services" = .{
+            false,
+            &.{
+                .{ "EAS_BUILD", "" },
+            },
+        },
+        .gerrit = .{
+            false,
+            &.{
+                .{ "GERRIT_PROJECT", "" },
+            },
+        },
+        .@"gitea-actions" = .{
+            false,
+            &.{
+                .{ "GITEA_ACTIONS", "" },
+            },
+        },
+        .@"github-actions" = .{
+            false,
+            &.{
+                .{ "GITHUB_ACTIONS", "" },
+            },
+        },
+        .@"gitlab-ci" = .{
+            false,
+            &.{
+                .{ "GITLAB_CI", "" },
+            },
+        },
+        .gocd = .{
+            false,
+            &.{
+                .{ "GO_PIPELINE_LABEL", "" },
+            },
+        },
+        .@"google-cloud-build" = .{
+            false,
+            &.{
+                .{ "BUILDER_OUTPUT", "" },
+            },
+        },
+        .@"harness-ci" = .{
+            false,
+            &.{
+                .{ "HARNESS_BUILD_ID", "" },
+            },
+        },
+        .hudson = .{
+            false,
+            &.{
+                .{ "HUDSON_URL", "" },
+            },
+        },
+        .jenkins = .{
+            false,
+            &.{
+                .{ "JENKINS_URL", "" },
+                .{ "BUILD_ID", "" },
+            },
+        },
+        .layerci = .{
+            false,
+            &.{
+                .{ "LAYERCI", "" },
+            },
+        },
+        .@"magnum-ci" = .{
+            false,
+            &.{
+                .{ "MAGNUM", "" },
+            },
+        },
+        .@"netlify-ci" = .{
+            false,
+            &.{
+                .{ "NETLIFY", "" },
+            },
+        },
+        .nevercode = .{
+            false,
+            &.{
+                .{ "NEVERCODE", "" },
+            },
+        },
+        .prow = .{
+            false,
+            &.{
+                .{ "PROW_JOB_ID", "" },
+            },
+        },
+        .releasehub = .{
+            false,
+            &.{
+                .{ "RELEASE_BUILD_ID", "" },
+            },
+        },
+        .render = .{
+            false,
+            &.{
+                .{ "RENDER", "" },
+            },
+        },
+        .@"sail-ci" = .{
+            false,
+            &.{
+                .{ "SAILCI", "" },
+            },
+        },
+        .screwdriver = .{
+            false,
+            &.{
+                .{ "SCREWDRIVER", "" },
+            },
+        },
+        .semaphore = .{
+            false,
+            &.{
+                .{ "SEMAPHORE", "" },
+            },
+        },
+        .sourcehut = .{
+            false,
+            &.{
+                .{ "CI_NAME", "sourcehut" },
+            },
+        },
+        .@"strider-cd" = .{
+            false,
+            &.{
+                .{ "STRIDER", "" },
+            },
+        },
+        .taskcluster = .{
+            false,
+            &.{
+                .{ "TASK_ID", "" },
+                .{ "RUN_ID", "" },
+            },
+        },
+        .teamcity = .{
+            false,
+            &.{
+                .{ "TEAMCITY_VERSION", "" },
+            },
+        },
+        .@"travis-ci" = .{
+            false,
+            &.{
+                .{ "TRAVIS", "" },
+            },
+        },
+        .vela = .{
+            false,
+            &.{
+                .{ "VELA", "" },
+            },
+        },
+        .vercel = .{
+            true,
+            &.{
+                .{ "NOW_BUILDER", "" },
+                .{ "VERCEL", "" },
+            },
+        },
+        .@"visual-studio-app-center" = .{
+            false,
+            &.{
+                .{ "APPCENTER_BUILD_ID", "" },
+            },
+        },
+        .woodpecker = .{
+            false,
+            &.{
+                .{ "CI", "woodpecker" },
+            },
+        },
+        .@"xcode-cloud" = .{
+            false,
+            &.{
+                .{ "CI_XCODE_PROJECT", "" },
+            },
+        },
+        .@"xcode-server" = .{
+            false,
+            &.{
+                .{ "XCS", "" },
+            },
+        },
+    });
+};
diff --git a/src/cli.zig b/src/cli.zig
index ad59352479..8510a5137b 100644
--- a/src/cli.zig
+++ b/src/cli.zig
@@ -44,6 +44,7 @@ const MacroMap = @import("./resolver/package_json.zig").MacroMap;
 const TestCommand = @import("./cli/test_command.zig").TestCommand;
 pub var start_time: i128 = undefined;
 const Bunfig = @import("./bunfig.zig").Bunfig;
+const OOM = bun.OOM;
 
 pub const Cli = struct {
     pub const CompileTarget = @import("./compile_target.zig");
@@ -60,7 +61,7 @@ pub const Cli = struct {
         // var panicker = MainPanicHandler.init(log);
         // MainPanicHandler.Singleton = &panicker;
         Command.start(allocator, log) catch |err| {
-            log.printForLogLevel(Output.errorWriter()) catch {};
+            log.print(Output.errorWriter()) catch {};
 
             bun.crash_handler.handleRootError(err, @errorReturnTrace());
         };
@@ -72,6 +73,7 @@ pub const Cli = struct {
 
 pub const debug_flags = if (Environment.isDebug) struct {
     var resolve_breakpoints: []const []const u8 = &.{};
+    var print_breakpoints: []const []const u8 = &.{};
 
     pub fn hasResolveBreakpoint(str: []const u8) bool {
         for (resolve_breakpoints) |bp| {
@@ -81,6 +83,18 @@ pub const debug_flags = if (Environment.isDebug) struct {
         }
         return false;
     }
+
+    pub fn hasPrintBreakpoint(path: fs.Path) bool {
+        for (print_breakpoints) |bp| {
+            if (strings.contains(path.pretty, bp)) {
+                return true;
+            }
+            if (strings.contains(path.text, bp)) {
+                return true;
+            }
+        }
+        return false;
+    }
 } else @compileError("Do not access this namespace in a release build");
 
 const LoaderMatcher = strings.ExactSizeMatcher(4);
@@ -116,6 +130,9 @@ pub const ExecCommand = @import("./cli/exec_command.zig").ExecCommand;
 pub const PatchCommand = @import("./cli/patch_command.zig").PatchCommand;
 pub const PatchCommitCommand = @import("./cli/patch_commit_command.zig").PatchCommitCommand;
 pub const OutdatedCommand = @import("./cli/outdated_command.zig").OutdatedCommand;
+pub const PublishCommand = @import("./cli/publish_command.zig").PublishCommand;
+pub const PackCommand = @import("./cli/pack_command.zig").PackCommand;
+pub const InitCommand = @import("./cli/init_command.zig").InitCommand;
 
 pub const Arguments = struct {
     pub fn loader_resolver(in: string) !Api.Loader {
@@ -165,21 +182,24 @@ 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,
+        clap.parseParam("--breakpoint-print <STR>...       DEBUG MODE: breakpoint when printing something that includes this string") catch unreachable,
     };
 
     const transpiler_params_ = [_]ParamType{
-        clap.parseParam("--main-fields <STR>...            Main fields to lookup in package.json. Defaults to --target dependent") catch unreachable,
+        clap.parseParam("--main-fields <STR>...             Main fields to lookup in package.json. Defaults to --target dependent") catch unreachable,
         clap.parseParam("--extension-order <STR>...        Defaults to: .tsx,.ts,.jsx,.js,.json ") catch unreachable,
-        clap.parseParam("--tsconfig-override <STR>         Specify custom tsconfig.json. Default <d>$cwd<r>/tsconfig.json") catch unreachable,
-        clap.parseParam("-d, --define <STR>...             Substitute K:V while parsing, e.g. --define process.env.NODE_ENV:\"development\". Values are parsed as JSON.") catch unreachable,
+        clap.parseParam("--tsconfig-override <STR>          Specify custom tsconfig.json. Default <d>$cwd<r>/tsconfig.json") catch unreachable,
+        clap.parseParam("-d, --define <STR>...              Substitute K:V while parsing, e.g. --define process.env.NODE_ENV:\"development\". Values are parsed as JSON.") catch unreachable,
+        clap.parseParam("--drop <STR>...                   Remove function calls, e.g. --drop=console removes all console.* calls.") catch unreachable,
         clap.parseParam("-l, --loader <STR>...             Parse files with .ext:loader, e.g. --loader .js:jsx. Valid loaders: js, jsx, ts, tsx, json, toml, text, file, wasm, napi") catch unreachable,
         clap.parseParam("--no-macros                       Disable macros from being executed in the bundler, transpiler and runtime") catch unreachable,
         clap.parseParam("--jsx-factory <STR>               Changes the function called when compiling JSX elements using the classic JSX runtime") catch unreachable,
@@ -237,12 +257,15 @@ pub const Arguments = struct {
 
     const build_only_params = [_]ParamType{
         clap.parseParam("--compile                        Generate a standalone Bun executable containing your bundled code") catch unreachable,
+        clap.parseParam("--bytecode                       Use a bytecode cache") catch unreachable,
         clap.parseParam("--watch                          Automatically restart the process on file change") catch unreachable,
         clap.parseParam("--no-clear-screen                Disable clearing the terminal screen on reload when --watch is enabled") catch unreachable,
         clap.parseParam("--target <STR>                   The intended execution environment for the bundle. \"browser\", \"bun\" or \"node\"") catch unreachable,
         clap.parseParam("--outdir <STR>                   Default to \"dist\" if multiple files") catch unreachable,
         clap.parseParam("--outfile <STR>                  Write to a file") catch unreachable,
         clap.parseParam("--sourcemap <STR>?               Build with sourcemaps - 'linked', 'inline', 'external', or 'none'") catch unreachable,
+        clap.parseParam("--banner <STR>                   Add a banner to the bundled output such as \"use client\"; for a bundle being used with RSCs") catch unreachable,
+        clap.parseParam("--footer <STR>                   Add a footer to the bundled output such as // built with bun!") catch unreachable,
         clap.parseParam("--format <STR>                   Specifies the module format to build to. Only \"esm\" is supported.") catch unreachable,
         clap.parseParam("--root <STR>                     Root directory used for multiple entry points") catch unreachable,
         clap.parseParam("--splitting                      Enable code splitting") catch unreachable,
@@ -253,16 +276,22 @@ pub const Arguments = struct {
         clap.parseParam("--chunk-naming <STR>             Customize chunk filenames. Defaults to \"[name]-[hash].[ext]\"") catch unreachable,
         clap.parseParam("--asset-naming <STR>             Customize asset filenames. Defaults to \"[name]-[hash].[ext]\"") catch unreachable,
         clap.parseParam("--react-fast-refresh             Enable React Fast Refresh transform (does not emit hot-module code, use this for testing)") catch unreachable,
-        clap.parseParam("--server-components              Enable React Server Components (experimental)") catch unreachable,
         clap.parseParam("--no-bundle                      Transpile file only, do not bundle") catch unreachable,
         clap.parseParam("--emit-dce-annotations           Re-emit DCE annotations in bundles. Enabled by default unless --minify-whitespace is passed.") catch unreachable,
         clap.parseParam("--minify                         Enable all minification flags") catch unreachable,
         clap.parseParam("--minify-syntax                  Minify syntax and inline data") catch unreachable,
         clap.parseParam("--minify-whitespace              Minify whitespace") catch unreachable,
         clap.parseParam("--minify-identifiers             Minify identifiers") catch unreachable,
+        clap.parseParam("--experimental-css               Enabled experimental CSS bundling") catch unreachable,
+        clap.parseParam("--experimental-css-chunking      Chunk CSS files together to reduce duplicated CSS loaded in a browser. Only has an affect when multiple entrypoints import CSS") catch unreachable,
         clap.parseParam("--dump-environment-variables") catch unreachable,
         clap.parseParam("--conditions <STR>...            Pass custom conditions to resolve") catch unreachable,
-    };
+        clap.parseParam("--app                            (EXPERIMENTAL) Build a web app for production using Bun Bake.") catch unreachable,
+        clap.parseParam("--server-components              (EXPERIMENTAL) Enable server components") catch unreachable,
+    } ++ if (FeatureFlags.bake_debugging_features) [_]ParamType{
+        clap.parseParam("--debug-dump-server-files        When --app is set, dump all server files to disk even when building statically") catch unreachable,
+        clap.parseParam("--debug-no-minify                When --app is set, do not minify anything") catch unreachable,
+    } else .{};
     pub const build_params = build_only_params ++ transpiler_params_ ++ base_params_;
 
     // TODO: update test completions
@@ -277,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_;
 
@@ -325,14 +356,21 @@ pub const Arguments = struct {
 
         return null;
     }
-    pub fn loadConfig(allocator: std.mem.Allocator, user_config_path_: ?string, ctx: Command.Context, comptime cmd: Command.Tag) !void {
+    pub fn loadConfig(allocator: std.mem.Allocator, user_config_path_: ?string, ctx: Command.Context, comptime cmd: Command.Tag) OOM!void {
         var config_buf: bun.PathBuffer = undefined;
         if (comptime cmd.readGlobalConfig()) {
             if (!ctx.has_loaded_global_config) {
                 ctx.has_loaded_global_config = true;
 
                 if (getHomeConfigPath(&config_buf)) |path| {
-                    try loadConfigPath(allocator, true, path, ctx, comptime cmd);
+                    loadConfigPath(allocator, true, path, ctx, comptime cmd) catch |err| {
+                        if (ctx.log.hasAny()) {
+                            ctx.log.print(Output.errorWriter()) catch {};
+                        }
+                        if (ctx.log.hasAny()) Output.printError("\n", .{});
+                        Output.err(err, "failed to load bunfig", .{});
+                        Global.crash();
+                    };
                 }
             }
         }
@@ -380,7 +418,14 @@ pub const Arguments = struct {
             config_path = config_buf[0..config_path_.len :0];
         }
 
-        try loadConfigPath(allocator, auto_loaded, config_path, ctx, comptime cmd);
+        loadConfigPath(allocator, auto_loaded, config_path, ctx, comptime cmd) catch |err| {
+            if (ctx.log.hasAny()) {
+                ctx.log.print(Output.errorWriter()) catch {};
+            }
+            if (ctx.log.hasAny()) Output.printError("\n", .{});
+            Output.err(err, "failed to load bunfig", .{});
+            Global.crash();
+        };
     }
 
     pub fn loadConfigWithCmdArgs(
@@ -388,7 +433,7 @@ pub const Arguments = struct {
         allocator: std.mem.Allocator,
         args: clap.Args(clap.Help, cmd.params()),
         ctx: Command.Context,
-    ) !void {
+    ) OOM!void {
         return try loadConfig(allocator, args.option("--config"), ctx, comptime cmd);
     }
 
@@ -481,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;
             }
@@ -545,6 +607,8 @@ pub const Arguments = struct {
             };
         }
 
+        opts.drop = args.options("--drop");
+
         const loader_tuple = try LoaderColonList.resolve(allocator, args.options("--loader"));
 
         if (loader_tuple.keys.len > 0) {
@@ -559,7 +623,6 @@ pub const Arguments = struct {
         else
             null;
 
-        opts.serve = false; // TODO
         opts.main_fields = args.options("--main-fields");
         // we never actually supported inject.
         // opts.inject = args.options("--inject");
@@ -724,11 +787,43 @@ pub const Arguments = struct {
 
         if (cmd == .BuildCommand) {
             ctx.bundler_options.transform_only = args.flag("--no-bundle");
+            ctx.bundler_options.bytecode = args.flag("--bytecode");
+
+            if (args.flag("--app")) {
+                if (!bun.FeatureFlags.bake()) {
+                    Output.errGeneric("To use the experimental \"--app\" option, upgrade to the canary build of bun via \"bun upgrade --canary\"", .{});
+                    Global.crash();
+                }
+
+                ctx.bundler_options.bake = true;
+                ctx.bundler_options.bake_debug_dump_server = bun.FeatureFlags.bake_debugging_features and
+                    args.flag("--debug-dump-server-files");
+                ctx.bundler_options.bake_debug_disable_minify = bun.FeatureFlags.bake_debugging_features and
+                    args.flag("--debug-no-minify");
+            }
+
+            // TODO: support --format=esm
+            if (ctx.bundler_options.bytecode) {
+                ctx.bundler_options.output_format = .cjs;
+                ctx.args.target = .bun;
+            }
 
             if (args.option("--public-path")) |public_path| {
                 ctx.bundler_options.public_path = public_path;
             }
 
+            if (args.option("--banner")) |banner| {
+                ctx.bundler_options.banner = banner;
+            }
+
+            if (args.option("--footer")) |footer| {
+                ctx.bundler_options.footer = footer;
+            }
+
+            const experimental_css = args.flag("--experimental-css");
+            ctx.bundler_options.experimental_css = experimental_css;
+            ctx.bundler_options.css_chunking = args.flag("--experimental-css-chunking");
+
             const minify_flag = args.flag("--minify");
             ctx.bundler_options.minify_syntax = minify_flag or args.flag("--minify-syntax");
             ctx.bundler_options.minify_whitespace = minify_flag or args.flag("--minify-whitespace");
@@ -780,8 +875,18 @@ pub const Arguments = struct {
                     else => invalidTarget(&diag, _target),
                 };
 
-                if (opts.target.? == .bun)
+                if (opts.target.? == .bun) {
                     ctx.debug.run_in_bun = opts.target.? == .bun;
+                } else {
+                    if (ctx.bundler_options.bytecode) {
+                        Output.errGeneric("target must be 'bun' when bytecode is true. Received: {s}", .{@tagName(opts.target.?)});
+                        Global.exit(1);
+                    }
+
+                    if (ctx.bundler_options.bake) {
+                        Output.errGeneric("target must be 'bun' when using --app. Received: {s}", .{@tagName(opts.target.?)});
+                    }
+                }
             }
 
             if (args.flag("--watch")) {
@@ -821,22 +926,23 @@ pub const Arguments = struct {
                 };
 
                 switch (format) {
-                    .internal_kit_dev => {
+                    .internal_bake_dev => {
                         bun.Output.warn("--format={s} is for debugging only, and may experience breaking changes at any moment", .{format_str});
                         bun.Output.flush();
                     },
                     .cjs => {
-                        // Make this a soft error in debug to allow experimenting with these flags.
-                        const function = if (Environment.isDebug) Output.debugWarn else Output.errGeneric;
-                        function("Format '{s}' are not implemented", .{@tagName(format)});
-                        if (!Environment.isDebug) {
-                            Global.crash();
+                        if (ctx.args.target == null) {
+                            ctx.args.target = .node;
                         }
                     },
                     else => {},
                 }
 
                 ctx.bundler_options.output_format = format;
+                if (format != .cjs and ctx.bundler_options.bytecode) {
+                    Output.errGeneric("format must be 'cjs' when bytecode is true. Eventually we'll add esm support as well.", .{});
+                    Global.exit(1);
+                }
             }
 
             if (args.flag("--splitting")) {
@@ -856,7 +962,15 @@ pub const Arguments = struct {
             }
 
             if (args.flag("--server-components")) {
-                ctx.bundler_options.react_server_components = true;
+                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;
+                    }
+                }
             }
 
             if (args.flag("--react-fast-refresh")) {
@@ -986,9 +1100,9 @@ pub const Arguments = struct {
         }
 
         if (cmd == .BuildCommand) {
-            if (opts.entry_points.len == 0 and opts.framework == null) {
-                Output.prettyErrorln("<r><b>bun build <r><d>v" ++ Global.package_json_version_with_sha ++ "<r>", .{});
-                Output.prettyError("<r><red>error: Missing entrypoints. What would you like to bundle?<r>\n\n", .{});
+            if (opts.entry_points.len == 0 and !ctx.bundler_options.bake) {
+                Output.prettyln("<r><b>bun build <r><d>v" ++ Global.package_json_version_with_sha ++ "<r>", .{});
+                Output.pretty("<r><red>error: Missing entrypoints. What would you like to bundle?<r>\n\n", .{});
                 Output.flush();
                 Output.pretty("Usage:\n  <d>$<r> <b><green>bun build<r> \\<entrypoint\\> [...\\<entrypoints\\>] <cyan>[...flags]<r>  \n", .{});
                 Output.pretty("\nTo see full documentation:\n  <d>$<r> <b><green>bun build<r> --help\n", .{});
@@ -1030,6 +1144,7 @@ pub const Arguments = struct {
 
         if (Environment.isDebug) {
             debug_flags.resolve_breakpoints = args.options("--breakpoint-resolve");
+            debug_flags.print_breakpoints = args.options("--breakpoint-print");
         }
 
         return opts;
@@ -1041,7 +1156,6 @@ const AutoCommand = struct {
         try HelpCommand.execWithReason(allocator, .invalid_command);
     }
 };
-const InitCommand = @import("./cli/init_command.zig").InitCommand;
 
 pub const HelpCommand = struct {
     pub fn exec(allocator: std.mem.Allocator) !void {
@@ -1117,9 +1231,9 @@ pub const HelpCommand = struct {
         \\  <b><blue>remove<r>    <d>{s:<16}<r>     Remove a dependency from package.json <d>(bun rm)<r>
         \\  <b><blue>update<r>    <d>{s:<16}<r>     Update outdated dependencies
         \\  <b><blue>outdated<r>                       Display latest versions of outdated dependencies
-        \\  <b><blue>pack<r>                           Archive the current workspace package
         \\  <b><blue>link<r>      <d>[\<package\>]<r>          Register or link a local npm package
         \\  <b><blue>unlink<r>                         Unregister a local npm package
+        \\  <b><blue>publish<r>                        Publish a package to the npm registry
         \\  <b><blue>patch <d>\<pkg\><r>                    Prepare a package for patching
         \\  <b><blue>pm <d>\<subcommand\><r>                Additional package management utilities
         \\
@@ -1187,9 +1301,9 @@ pub const HelpCommand = struct {
         printWithReason(reason, false);
 
         if (reason == .invalid_command) {
-            std.process.exit(1);
+            Global.exit(1);
         }
-        std.process.exit(0);
+        Global.exit(0);
     }
 };
 
@@ -1224,6 +1338,10 @@ pub var is_bunx_exe = false;
 pub const Command = struct {
     var script_name_buf: bun.PathBuffer = undefined;
 
+    pub fn get() Context {
+        return global_cli_ctx;
+    }
+
     pub const DebugOptions = struct {
         dump_environment_variables: bool = false,
         dump_limits: bool = false,
@@ -1263,6 +1381,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) {
@@ -1295,18 +1416,18 @@ pub const Command = struct {
         args: Api.TransformOptions,
         log: *logger.Log,
         allocator: std.mem.Allocator,
-        positionals: []const string = &[_]string{},
-        passthrough: []const string = &[_]string{},
+        positionals: []const string = &.{},
+        passthrough: []const string = &.{},
         install: ?*Api.BunInstall = null,
 
-        debug: DebugOptions = DebugOptions{},
-        test_options: TestOptions = TestOptions{},
-        bundler_options: BundlerOptions = BundlerOptions{},
-        runtime_options: RuntimeOptions = RuntimeOptions{},
+        debug: DebugOptions = .{},
+        test_options: TestOptions = .{},
+        bundler_options: BundlerOptions = .{},
+        runtime_options: RuntimeOptions = .{},
 
-        filters: []const []const u8 = &[_][]const u8{},
+        filters: []const []const u8 = &.{},
 
-        preloads: []const string = &[_]string{},
+        preloads: []const string = &.{},
         has_loaded_global_config: bool = false,
 
         pub const BundlerOptions = struct {
@@ -1320,7 +1441,7 @@ pub const Command = struct {
             entry_naming: []const u8 = "[dir]/[name].[ext]",
             chunk_naming: []const u8 = "./[name]-[hash].[ext]",
             asset_naming: []const u8 = "./[name]-[hash].[ext]",
-            react_server_components: bool = false,
+            server_components: bool = false,
             react_fast_refresh: bool = false,
             code_splitting: bool = false,
             transform_only: bool = false,
@@ -1331,6 +1452,15 @@ pub const Command = struct {
             ignore_dce_annotations: bool = false,
             emit_dce_annotations: bool = true,
             output_format: options.Format = .esm,
+            bytecode: bool = false,
+            banner: []const u8 = "",
+            footer: []const u8 = "",
+            experimental_css: bool = false,
+            css_chunking: bool = false,
+
+            bake: bool = false,
+            bake_debug_dump_server: bool = false,
+            bake_debug_disable_minify: bool = false,
         };
 
         pub fn create(allocator: std.mem.Allocator, log: *logger.Log, comptime command: Command.Tag) anyerror!Context {
@@ -1365,7 +1495,7 @@ pub const Command = struct {
 
     // std.process.args allocates!
     const ArgsIterator = struct {
-        buf: [][:0]const u8 = undefined,
+        buf: [][:0]const u8,
         i: u32 = 0,
 
         pub fn next(this: *ArgsIterator) ?[]const u8 {
@@ -1428,7 +1558,7 @@ pub const Command = struct {
         }
 
         const first_arg_name = next_arg;
-        const RootCommandMatcher = strings.ExactSizeMatcher(16);
+        const RootCommandMatcher = strings.ExactSizeMatcher(12);
 
         return switch (RootCommandMatcher.match(first_arg_name)) {
             RootCommandMatcher.case("init") => .InitCommand,
@@ -1477,6 +1607,7 @@ pub const Command = struct {
             RootCommandMatcher.case("exec") => .ExecCommand,
 
             RootCommandMatcher.case("outdated") => .OutdatedCommand,
+            RootCommandMatcher.case("publish") => .PublishCommand,
 
             // These are reserved for future use by Bun, so that someone
             // doing `bun deploy` to run a script doesn't accidentally break
@@ -1490,7 +1621,6 @@ pub const Command = struct {
             RootCommandMatcher.case("login") => .ReservedCommand,
             RootCommandMatcher.case("logout") => .ReservedCommand,
             RootCommandMatcher.case("whoami") => .ReservedCommand,
-            RootCommandMatcher.case("publish") => .ReservedCommand,
             RootCommandMatcher.case("prune") => .ReservedCommand,
             RootCommandMatcher.case("list") => .ReservedCommand,
             RootCommandMatcher.case("why") => .ReservedCommand,
@@ -1620,6 +1750,13 @@ pub const Command = struct {
                 try OutdatedCommand.exec(ctx);
                 return;
             },
+            .PublishCommand => {
+                if (comptime bun.fast_debug_build_mode and bun.fast_debug_build_cmd != .PublishCommand) unreachable;
+                const ctx = try Command.init(allocator, log, .PublishCommand);
+
+                try PublishCommand.exec(ctx);
+                return;
+            },
             .BunxCommand => {
                 if (comptime bun.fast_debug_build_mode and bun.fast_debug_build_cmd != .BunxCommand) unreachable;
                 const ctx = try Command.init(allocator, log, .BunxCommand);
@@ -1662,6 +1799,20 @@ pub const Command = struct {
                 if (comptime bun.fast_debug_build_mode and bun.fast_debug_build_cmd != .PackageManagerCommand) unreachable;
                 const ctx = try Command.init(allocator, log, .PackageManagerCommand);
 
+                // const maybe_subcommand, const maybe_arg = PackageManagerCommand.which(command_index);
+                // if (maybe_subcommand) |subcommand| {
+                //     return switch (subcommand) {
+                //         inline else => |tag| try PackageManagerCommand.exec(ctx, tag),
+                //     };
+                // }
+
+                // PackageManagerCommand.printHelp();
+
+                // if (maybe_arg) |arg| {
+                //     Output.errGeneric("\"{s}\" unknown command", .{arg});
+                //     Global.crash();
+                // }
+
                 try PackageManagerCommand.exec(ctx);
                 return;
             },
@@ -1712,7 +1863,7 @@ pub const Command = struct {
                     const index = AddCompletions.index;
 
                     outer: {
-                        if (filter.len > 1) {
+                        if (filter.len > 1 and filter[1].len > 0) {
                             const first_letter: FirstLetter = switch (filter[1][0]) {
                                 'a' => FirstLetter.a,
                                 'b' => FirstLetter.b,
@@ -2146,11 +2297,7 @@ pub const Command = struct {
         ) catch |err| {
             bun.handleErrorReturnTrace(err, @errorReturnTrace());
 
-            if (Output.enable_ansi_colors) {
-                ctx.log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), true) catch {};
-            } else {
-                ctx.log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), false) catch {};
-            }
+            ctx.log.print(Output.errorWriter()) catch {};
 
             Output.prettyErrorln("<r><red>error<r>: Failed to run <b>{s}<r> due to error <b>{s}<r>", .{
                 std.fs.path.basename(file_path),
@@ -2188,6 +2335,7 @@ pub const Command = struct {
         PatchCommand,
         PatchCommitCommand,
         OutdatedCommand,
+        PublishCommand,
 
         /// Used by crash reports.
         ///
@@ -2220,6 +2368,7 @@ pub const Command = struct {
                 .PatchCommand => 'x',
                 .PatchCommitCommand => 'z',
                 .OutdatedCommand => 'o',
+                .PublishCommand => 'k',
             };
         }
 
@@ -2388,19 +2537,25 @@ pub const Command = struct {
                     ;
                     const outro_text =
                         \\<b>Examples:<r>
-                        \\  <d>Install the latest stable version<r>
+                        \\  <d>Install the latest {s} version<r>
                         \\  <b><green>bun upgrade<r>
                         \\
-                        \\  <d>Install the most recent canary version of Bun<r>
-                        \\  <b><green>bun upgrade --canary<r>
+                        \\  <d>{s}<r>
+                        \\  <b><green>bun upgrade<r> <cyan>--{s}<r>
                         \\
                         \\Full documentation is available at <magenta>https://bun.sh/docs/installation#upgrading<r>
                         \\
                     ;
+
+                    const args = comptime switch (Environment.is_canary) {
+                        true => .{ "canary", "Switch from the canary version back to the latest stable release", "stable" },
+                        false => .{ "stable", "Install the most recent canary version of Bun", "canary" },
+                    };
+
                     Output.pretty(intro_text, .{});
                     Output.pretty("\n\n", .{});
                     Output.flush();
-                    Output.pretty(outro_text, .{});
+                    Output.pretty(outro_text, args);
                     Output.flush();
                 },
                 Command.Tag.ReplCommand => {
@@ -2443,9 +2598,10 @@ pub const Command = struct {
                     , .{});
                     Output.flush();
                 },
-                .OutdatedCommand => {
+                .OutdatedCommand, .PublishCommand => {
                     Install.PackageManager.CommandLineArguments.printHelp(switch (cmd) {
                         .OutdatedCommand => .outdated,
+                        .PublishCommand => .publish,
                     });
                 },
                 else => {
@@ -2465,6 +2621,7 @@ pub const Command = struct {
                 .PatchCommand,
                 .PatchCommitCommand,
                 .OutdatedCommand,
+                .PublishCommand,
                 => true,
                 else => false,
             };
@@ -2483,6 +2640,7 @@ pub const Command = struct {
                 .PatchCommand,
                 .PatchCommitCommand,
                 .OutdatedCommand,
+                .PublishCommand,
                 => true,
                 else => false,
             };
@@ -2503,6 +2661,7 @@ pub const Command = struct {
             .RunCommand = true,
             .RunAsNodeCommand = true,
             .OutdatedCommand = true,
+            .PublishCommand = true,
         });
 
         pub const always_loads_config: std.EnumArray(Tag, bool) = std.EnumArray(Tag, bool).initDefault(false, .{
@@ -2517,6 +2676,7 @@ pub const Command = struct {
             .PackageManagerCommand = true,
             .BunxCommand = true,
             .OutdatedCommand = true,
+            .PublishCommand = true,
         });
 
         pub const uses_global_options: std.EnumArray(Tag, bool) = std.EnumArray(Tag, bool).initDefault(true, .{
@@ -2532,6 +2692,7 @@ pub const Command = struct {
             .UnlinkCommand = false,
             .BunxCommand = false,
             .OutdatedCommand = false,
+            .PublishCommand = false,
         });
     };
 };
diff --git a/src/cli/build_command.zig b/src/cli/build_command.zig
index f5bb2afd6c..8b02cc40e6 100644
--- a/src/cli/build_command.zig
+++ b/src/cli/build_command.zig
@@ -30,38 +30,33 @@ const bundler = bun.bundler;
 const DotEnv = @import("../env_loader.zig");
 
 const fs = @import("../fs.zig");
-const Router = @import("../router.zig");
 const BundleV2 = @import("../bundler/bundle_v2.zig").BundleV2;
-var estimated_input_lines_of_code_: usize = undefined;
 
 pub const BuildCommand = struct {
     const compile_define_keys = &.{
         "process.platform",
         "process.arch",
+        "process.versions.bun",
     };
 
-    pub fn exec(
-        ctx: Command.Context,
-    ) !void {
+    pub fn exec(ctx: Command.Context) !void {
         Global.configureAllocator(.{ .long_running = true });
         const allocator = ctx.allocator;
         var log = ctx.log;
-        estimated_input_lines_of_code_ = 0;
-        if (ctx.bundler_options.compile) {
+        if (ctx.bundler_options.compile or ctx.bundler_options.bytecode) {
             // set this early so that externals are set up correctly and define is right
             ctx.args.target = .bun;
         }
 
+        if (ctx.bundler_options.bake) {
+            return bun.bake.production.buildCommand(ctx);
+        }
+
         const compile_target = &ctx.bundler_options.compile_target;
 
         if (ctx.bundler_options.compile) {
             const compile_define_values = compile_target.defineValues();
-            if (ctx.args.define == null) {
-                ctx.args.define = .{
-                    .keys = compile_define_keys,
-                    .values = compile_define_values,
-                };
-            } else if (ctx.args.define) |*define| {
+            if (ctx.args.define) |*define| {
                 var keys = try std.ArrayList(string).initCapacity(bun.default_allocator, compile_define_keys.len + define.keys.len);
                 keys.appendSliceAssumeCapacity(compile_define_keys);
                 keys.appendSliceAssumeCapacity(define.keys);
@@ -71,6 +66,11 @@ pub const BuildCommand = struct {
 
                 define.keys = keys.items;
                 define.values = values.items;
+            } else {
+                ctx.args.define = .{
+                    .keys = compile_define_keys,
+                    .values = compile_define_values,
+                };
             }
         }
 
@@ -85,13 +85,17 @@ pub const BuildCommand = struct {
             Global.exit(1);
             return;
         }
+
         var outfile = ctx.bundler_options.outfile;
+        const output_to_stdout = !ctx.bundler_options.compile and outfile.len == 0 and ctx.bundler_options.outdir.len == 0;
+
+        this_bundler.options.supports_multiple_outputs = !(output_to_stdout or outfile.len > 0);
 
         this_bundler.options.public_path = ctx.bundler_options.public_path;
         this_bundler.options.entry_naming = ctx.bundler_options.entry_naming;
         this_bundler.options.chunk_naming = ctx.bundler_options.chunk_naming;
         this_bundler.options.asset_naming = ctx.bundler_options.asset_naming;
-        this_bundler.options.react_server_components = ctx.bundler_options.react_server_components;
+        this_bundler.options.server_components = ctx.bundler_options.server_components;
         this_bundler.options.react_fast_refresh = ctx.bundler_options.react_fast_refresh;
         this_bundler.options.inline_entrypoint_import_meta_main = ctx.bundler_options.inline_entrypoint_import_meta_main;
         this_bundler.options.code_splitting = ctx.bundler_options.code_splitting;
@@ -101,6 +105,22 @@ pub const BuildCommand = struct {
         this_bundler.options.emit_dce_annotations = ctx.bundler_options.emit_dce_annotations;
         this_bundler.options.ignore_dce_annotations = ctx.bundler_options.ignore_dce_annotations;
 
+        this_bundler.options.banner = ctx.bundler_options.banner;
+        this_bundler.options.footer = ctx.bundler_options.footer;
+        this_bundler.options.drop = ctx.args.drop;
+
+        this_bundler.options.experimental_css = ctx.bundler_options.experimental_css;
+        this_bundler.options.css_chunking = ctx.bundler_options.css_chunking;
+
+        this_bundler.options.output_dir = ctx.bundler_options.outdir;
+        this_bundler.options.output_format = ctx.bundler_options.output_format;
+
+        if (ctx.bundler_options.output_format == .internal_bake_dev) {
+            this_bundler.options.tree_shaking = false;
+        }
+
+        this_bundler.options.bytecode = ctx.bundler_options.bytecode;
+
         if (ctx.bundler_options.compile) {
             if (ctx.bundler_options.code_splitting) {
                 Output.prettyErrorln("<r><red>error<r><d>:<r> cannot use --compile with --splitting", .{});
@@ -161,9 +181,6 @@ pub const BuildCommand = struct {
             }
         }
 
-        this_bundler.options.output_dir = ctx.bundler_options.outdir;
-        this_bundler.options.output_format = ctx.bundler_options.output_format;
-
         var src_root_dir_buf: bun.PathBuffer = undefined;
         const src_root_dir: string = brk1: {
             const path = brk2: {
@@ -194,28 +211,10 @@ pub const BuildCommand = struct {
         this_bundler.options.code_splitting = ctx.bundler_options.code_splitting;
         this_bundler.options.transform_only = ctx.bundler_options.transform_only;
 
-        if (this_bundler.options.transform_only) {
-            this_bundler.options.resolve_mode = .disable;
-        }
-
-        this_bundler.resolver.opts = this_bundler.options;
-
+        try this_bundler.configureDefines();
         this_bundler.configureLinker();
 
-        // This step is optional
-        // If it fails for any reason, ignore it and continue bundling
-        // This is partially a workaround for the 'error.MissingRoutesDir' error
-        this_bundler.configureRouter(true) catch {
-            this_bundler.options.routes.routes_enabled = false;
-            this_bundler.options.framework = null;
-            if (this_bundler.router) |*router| {
-                router.config.routes_enabled = false;
-                router.config.single_page_app_routing = false;
-                router.config.static_dir_enabled = false;
-                this_bundler.router = null;
-            }
-        };
-
+        this_bundler.resolver.opts = this_bundler.options;
         this_bundler.options.jsx.development = !this_bundler.options.production;
         this_bundler.resolver.opts.jsx.development = this_bundler.options.jsx.development;
 
@@ -229,6 +228,38 @@ pub const BuildCommand = struct {
             .unspecified => {},
         }
 
+        var client_bundler: bundler.Bundler = undefined;
+        if (this_bundler.options.server_components) {
+            client_bundler = try bundler.Bundler.init(allocator, log, ctx.args, null);
+            client_bundler.options = this_bundler.options;
+            client_bundler.options.target = .browser;
+            client_bundler.options.server_components = true;
+            try this_bundler.options.conditions.appendSlice(&.{"react-server"});
+            this_bundler.options.react_fast_refresh = false;
+            this_bundler.options.minify_syntax = true;
+            client_bundler.options.minify_syntax = true;
+            client_bundler.options.define = try options.Define.init(
+                allocator,
+                if (ctx.args.define) |user_defines|
+                    try options.Define.Data.fromInput(try options.stringHashMapFromArrays(
+                        options.defines.RawDefines,
+                        allocator,
+                        user_defines.keys,
+                        user_defines.values,
+                    ), ctx.args.drop, log, allocator)
+                else
+                    null,
+                null,
+                this_bundler.options.define.drop_debugger,
+            );
+
+            try bun.bake.addImportMetaDefines(allocator, this_bundler.options.define, .development, .server);
+            try bun.bake.addImportMetaDefines(allocator, client_bundler.options.define, .development, .client);
+
+            this_bundler.resolver.opts = this_bundler.options;
+            client_bundler.resolver.opts = client_bundler.options;
+        }
+
         // var env_loader = this_bundler.env;
 
         if (ctx.debug.dump_environment_variables) {
@@ -254,7 +285,7 @@ pub const BuildCommand = struct {
                 );
 
                 if (log.hasErrors()) {
-                    try log.printForLogLevel(Output.errorWriter());
+                    try log.print(Output.errorWriter());
 
                     if (result.errors.len > 0 or result.output_files.len == 0) {
                         Output.flush();
@@ -270,21 +301,19 @@ pub const BuildCommand = struct {
                 &this_bundler,
                 allocator,
                 bun.JSC.AnyEventLoop.init(ctx.allocator),
-                std.crypto.random.int(u64),
                 ctx.debug.hot_reload == .watch,
                 &reachable_file_count,
                 &minify_duration,
                 &input_code_length,
             ) catch |err| {
                 if (log.msgs.items.len > 0) {
-                    try log.printForLogLevel(Output.errorWriter());
+                    try log.print(Output.errorWriter());
                 } else {
                     try Output.errorWriter().print("error: {s}", .{@errorName(err)});
                 }
 
                 Output.flush();
                 exitOrWatch(1, ctx.debug.hot_reload == .watch);
-                unreachable;
             }).items;
         };
         const bundled_end = std.time.nanoTimestamp();
@@ -377,6 +406,7 @@ pub const BuildCommand = struct {
                             this_bundler.options.public_path,
                             outfile,
                             this_bundler.env,
+                            this_bundler.options.output_format,
                         );
                         const compiled_elapsed = @divTrunc(@as(i64, @truncate(std.time.nanoTimestamp() - bundled_end)), @as(i64, std.time.ns_per_ms));
                         const compiled_elapsed_digit_count: isize = switch (compiled_elapsed) {
@@ -411,79 +441,11 @@ pub const BuildCommand = struct {
                     // So don't do that unless we actually need to.
                     // const do_we_need_to_close = !FeatureFlags.store_file_descriptors or (@intCast(usize, root_dir.fd) + open_file_limit) < output_files.len;
 
-                    var filepath_buf: bun.PathBuffer = undefined;
-                    filepath_buf[0] = '.';
-                    filepath_buf[1] = '/';
-
                     for (output_files) |f| {
-                        var rel_path: []const u8 = undefined;
-                        switch (f.value) {
-                            // Nothing to do in this case
-                            .saved => {
-                                rel_path = f.dest_path;
-                                if (f.dest_path.len > from_path.len) {
-                                    rel_path = resolve_path.relative(from_path, f.dest_path);
-                                }
-                            },
-
-                            // easy mode: write the buffer
-                            .buffer => |value| {
-                                rel_path = f.dest_path;
-                                if (f.dest_path.len > from_path.len) {
-                                    rel_path = resolve_path.relative(from_path, f.dest_path);
-                                    if (std.fs.path.dirname(rel_path)) |parent| {
-                                        if (parent.len > root_path.len) {
-                                            try root_dir.makePath(parent);
-                                        }
-                                    }
-                                }
-                                const JSC = bun.JSC;
-                                var path_buf: bun.PathBuffer = undefined;
-                                switch (JSC.Node.NodeFS.writeFileWithPathBuffer(
-                                    &path_buf,
-                                    JSC.Node.Arguments.WriteFile{
-                                        .data = JSC.Node.StringOrBuffer{
-                                            .buffer = JSC.Buffer{
-                                                .buffer = .{
-                                                    .ptr = @constCast(value.bytes.ptr),
-                                                    // TODO: handle > 4 GB files
-                                                    .len = @as(u32, @truncate(value.bytes.len)),
-                                                    .byte_len = @as(u32, @truncate(value.bytes.len)),
-                                                },
-                                            },
-                                        },
-                                        .encoding = .buffer,
-                                        .mode = if (f.is_executable) 0o755 else 0o644,
-                                        .dirfd = bun.toFD(root_dir.fd),
-                                        .file = .{
-                                            .path = JSC.Node.PathLike{
-                                                .string = JSC.PathString.init(rel_path),
-                                            },
-                                        },
-                                    },
-                                )) {
-                                    .err => |err| {
-                                        Output.prettyErrorln("<r><red>error<r><d>:<r> failed to write file <b>{}<r>\n{}", .{ bun.fmt.quote(rel_path), err });
-                                    },
-                                    .result => {},
-                                }
-                            },
-                            .move => |value| {
-                                const primary = f.dest_path[from_path.len..];
-                                bun.copy(u8, filepath_buf[2..], primary);
-                                rel_path = filepath_buf[0 .. primary.len + 2];
-                                rel_path = value.pathname;
-
-                                try f.moveTo(root_path, @constCast(rel_path), bun.toFD(root_dir.fd));
-                            },
-                            .copy => |value| {
-                                rel_path = value.pathname;
-
-                                try f.copyTo(root_path, @constCast(rel_path), bun.toFD(root_dir.fd));
-                            },
-                            .noop => {},
-                            .pending => unreachable,
-                        }
+                        const rel_path = f.writeToDisk(root_dir, from_path) catch |err| {
+                            Output.err(err, "failed to write file '{}'", .{bun.fmt.quote(f.dest_path)});
+                            continue;
+                        };
 
                         // Print summary
                         _ = try writer.write("\n");
@@ -513,13 +475,13 @@ pub const BuildCommand = struct {
                 }
             }
 
-            try log.printForLogLevel(Output.errorWriter());
+            try log.print(Output.errorWriter());
             exitOrWatch(0, ctx.debug.hot_reload == .watch);
         }
     }
 };
 
-fn exitOrWatch(code: u8, watch: bool) void {
+fn exitOrWatch(code: u8, watch: bool) noreturn {
     if (watch) {
         // the watcher thread will exit the process
         std.time.sleep(std.math.maxInt(u64) - 1);
diff --git a/src/cli/bunx_command.zig b/src/cli/bunx_command.zig
index c0bb2fa7f7..1afa6fd6ff 100644
--- a/src/cli/bunx_command.zig
+++ b/src/cli/bunx_command.zig
@@ -82,7 +82,7 @@ pub const BunxCommand = struct {
         bun.JSAst.Expr.Data.Store.create();
         bun.JSAst.Stmt.Data.Store.create();
 
-        const expr = try bun.JSON.ParsePackageJSONUTF8(&source, bundler.log, bundler.allocator);
+        const expr = try bun.JSON.parsePackageJSONUTF8(&source, bundler.log, bundler.allocator);
 
         // choose the first package that fits
         if (expr.get("bin")) |bin_expr| {
@@ -271,6 +271,7 @@ pub const BunxCommand = struct {
         defer requests_buf.deinit(ctx.allocator);
         const update_requests = bun.PackageManager.UpdateRequest.parse(
             ctx.allocator,
+            null,
             ctx.log,
             &.{package_name},
             &requests_buf,
@@ -322,6 +323,15 @@ pub const BunxCommand = struct {
             root_dir_info.abs_path,
             ctx.debug.run_in_bun,
         );
+        this_bundler.env.map.put("npm_command", "exec") catch unreachable;
+        this_bundler.env.map.put("npm_lifecycle_event", "bunx") catch unreachable;
+        this_bundler.env.map.put("npm_lifecycle_script", package_name) catch unreachable;
+
+        if (strings.eqlComptime(package_name, "bun-repl")) {
+            this_bundler.env.map.remove("BUN_INSPECT_CONNECT_TO");
+            this_bundler.env.map.remove("BUN_INSPECT_NOTIFY");
+            this_bundler.env.map.remove("BUN_INSPECT");
+        }
 
         const ignore_cwd = this_bundler.env.get("BUN_WHICH_IGNORE_CWD") orelse "";
 
diff --git a/src/cli/create_command.zig b/src/cli/create_command.zig
index 7b7bf50c7c..0c81ee3730 100644
--- a/src/cli/create_command.zig
+++ b/src/cli/create_command.zig
@@ -31,8 +31,8 @@ const fs = @import("../fs.zig");
 const URL = @import("../url.zig").URL;
 const HTTP = bun.http;
 
-const ParseJSON = @import("../json_parser.zig").ParseJSONUTF8;
-const Archive = @import("../libarchive/libarchive.zig").Archive;
+const JSON = bun.JSON;
+const Archiver = bun.libarchive.Archiver;
 const Zlib = @import("../zlib.zig");
 const JSPrinter = bun.js_printer;
 const DotEnv = @import("../env_loader.zig");
@@ -241,7 +241,7 @@ pub const CreateCommand = struct {
         @setCold(true);
 
         Global.configureAllocator(.{ .long_running = false });
-        HTTP.HTTPThread.init();
+        HTTP.HTTPThread.init(&.{});
 
         var create_options = try CreateOptions.parse(ctx);
         const positionals = create_options.positionals;
@@ -377,19 +377,19 @@ pub const CreateCommand = struct {
 
                 progress.refresh();
 
-                var pluckers: [1]Archive.Plucker = if (!create_options.skip_package_json)
-                    [1]Archive.Plucker{try Archive.Plucker.init(comptime strings.literal(bun.OSPathChar, "package.json"), 2048, ctx.allocator)}
+                var pluckers: [1]Archiver.Plucker = if (!create_options.skip_package_json)
+                    [1]Archiver.Plucker{try Archiver.Plucker.init(comptime strings.literal(bun.OSPathChar, "package.json"), 2048, ctx.allocator)}
                 else
-                    [1]Archive.Plucker{undefined};
+                    [1]Archiver.Plucker{undefined};
 
-                var archive_context = Archive.Context{
+                var archive_context = Archiver.Context{
                     .pluckers = pluckers[0..@as(usize, @intCast(@intFromBool(!create_options.skip_package_json)))],
                     .all_files = undefined,
                     .overwrite_list = bun.StringArrayHashMap(void).init(ctx.allocator),
                 };
 
                 if (!create_options.overwrite) {
-                    try Archive.getOverwritingFileList(
+                    try Archiver.getOverwritingFileList(
                         tarball_buf_list.items,
                         destination,
                         &archive_context,
@@ -427,7 +427,7 @@ pub const CreateCommand = struct {
                     }
                 }
 
-                _ = try Archive.extractToDisk(
+                _ = try Archiver.extractToDisk(
                     tarball_buf_list.items,
                     destination,
                     &archive_context,
@@ -701,7 +701,7 @@ pub const CreateCommand = struct {
 
                 var source = logger.Source.initPathString("package.json", package_json_contents.list.items);
 
-                var package_json_expr = ParseJSON(&source, ctx.log, ctx.allocator) catch {
+                var package_json_expr = JSON.parseUTF8(&source, ctx.log, ctx.allocator) catch {
                     package_json_file = null;
                     break :process_package_json;
                 };
@@ -714,11 +714,7 @@ pub const CreateCommand = struct {
                 const properties_list = std.ArrayList(js_ast.G.Property).fromOwnedSlice(default_allocator, package_json_expr.data.e_object.properties.slice());
 
                 if (ctx.log.errors > 0) {
-                    if (Output.enable_ansi_colors) {
-                        try ctx.log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), true);
-                    } else {
-                        try ctx.log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), false);
-                    }
+                    try ctx.log.print(Output.errorWriter());
 
                     package_json_file = null;
                     break :process_package_json;
@@ -1983,7 +1979,7 @@ pub const Example = struct {
         async_http.client.progress_node = progress;
         async_http.client.flags.reject_unauthorized = env_loader.getTLSRejectUnauthorized();
 
-        const response = try async_http.sendSync(true);
+        const response = try async_http.sendSync();
 
         switch (response.status_code) {
             404 => return error.GitHubRepositoryNotFound,
@@ -1996,7 +1992,7 @@ pub const Example = struct {
 
         var is_expected_content_type = false;
         var content_type: string = "";
-        for (response.headers) |header| {
+        for (response.headers.list) |header| {
             if (strings.eqlCaseInsensitiveASCII(header.name, "content-type", true)) {
                 content_type = header.value;
 
@@ -2060,7 +2056,7 @@ pub const Example = struct {
         async_http.client.progress_node = progress;
         async_http.client.flags.reject_unauthorized = env_loader.getTLSRejectUnauthorized();
 
-        var response = try async_http.sendSync(true);
+        var response = try async_http.sendSync();
 
         switch (response.status_code) {
             404 => return error.ExampleNotFound,
@@ -2075,16 +2071,12 @@ pub const Example = struct {
         refresher.refresh();
         initializeStore();
         var source = logger.Source.initPathString("package.json", mutable.list.items);
-        var expr = ParseJSON(&source, ctx.log, ctx.allocator) catch |err| {
+        var expr = JSON.parseUTF8(&source, ctx.log, ctx.allocator) catch |err| {
             progress.end();
             refresher.refresh();
 
             if (ctx.log.errors > 0) {
-                if (Output.enable_ansi_colors) {
-                    try ctx.log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), true);
-                } else {
-                    try ctx.log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), false);
-                }
+                try ctx.log.print(Output.errorWriter());
                 Global.exit(1);
             } else {
                 Output.prettyErrorln("Error parsing package: <r><red>{s}<r>", .{@errorName(err)});
@@ -2096,11 +2088,7 @@ pub const Example = struct {
             progress.end();
             refresher.refresh();
 
-            if (Output.enable_ansi_colors) {
-                try ctx.log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), true);
-            } else {
-                try ctx.log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), false);
-            }
+            try ctx.log.print(Output.errorWriter());
             Global.exit(1);
         }
 
@@ -2151,7 +2139,7 @@ pub const Example = struct {
 
         refresher.maybeRefresh();
 
-        response = try async_http.sendSync(true);
+        response = try async_http.sendSync();
 
         refresher.maybeRefresh();
 
@@ -2194,7 +2182,7 @@ pub const Example = struct {
             async_http.client.progress_node = progress_node;
         }
 
-        const response = async_http.sendSync(true) catch |err| {
+        const response = async_http.sendSync() catch |err| {
             switch (err) {
                 error.WouldBlock => {
                     Output.prettyErrorln("Request timed out while trying to fetch examples list. Please try again", .{});
@@ -2214,13 +2202,9 @@ pub const Example = struct {
 
         initializeStore();
         var source = logger.Source.initPathString("examples.json", mutable.list.items);
-        const examples_object = ParseJSON(&source, ctx.log, ctx.allocator) catch |err| {
+        const examples_object = JSON.parseUTF8(&source, ctx.log, ctx.allocator) catch |err| {
             if (ctx.log.errors > 0) {
-                if (Output.enable_ansi_colors) {
-                    try ctx.log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), true);
-                } else {
-                    try ctx.log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), false);
-                }
+                try ctx.log.print(Output.errorWriter());
                 Global.exit(1);
             } else {
                 Output.prettyErrorln("Error parsing examples: <r><red>{s}<r>", .{@errorName(err)});
@@ -2229,11 +2213,7 @@ pub const Example = struct {
         };
 
         if (ctx.log.errors > 0) {
-            if (Output.enable_ansi_colors) {
-                try ctx.log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), true);
-            } else {
-                try ctx.log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), false);
-            }
+            try ctx.log.print(Output.errorWriter());
             Global.exit(1);
         }
 
diff --git a/src/cli/filter_arg.zig b/src/cli/filter_arg.zig
index 297233df3a..99031058d5 100644
--- a/src/cli/filter_arg.zig
+++ b/src/cli/filter_arg.zig
@@ -5,7 +5,7 @@ const string = bun.string;
 const Output = bun.Output;
 const Global = bun.Global;
 const strings = bun.strings;
-const json_parser = bun.JSON;
+const JSON = bun.JSON;
 const Glob = @import("../glob.zig");
 
 const Package = @import("../install/lockfile.zig").Package;
@@ -65,7 +65,7 @@ pub fn getCandidatePackagePatterns(allocator: std.mem.Allocator, log: *bun.logge
         };
         defer allocator.free(json_source.contents);
 
-        const json = try json_parser.ParsePackageJSONUTF8(&json_source, log, allocator);
+        const json = try JSON.parsePackageJSONUTF8(&json_source, log, allocator);
 
         const prop = json.asProperty("workspaces") orelse continue;
 
diff --git a/src/cli/filter_run.zig b/src/cli/filter_run.zig
index 0f404fde21..aad627d3d2 100644
--- a/src/cli/filter_run.zig
+++ b/src/cli/filter_run.zig
@@ -485,34 +485,32 @@ pub fn runScriptsWithFilter(ctx: Command.Context) !noreturn {
         const PATH = try RunCommand.configurePathForRunWithPackageJsonDir(ctx, dirpath, &this_bundler, null, dirpath, ctx.debug.run_in_bun);
 
         for (&[3][]const u8{ pre_script_name, script_name, post_script_name }) |name| {
-            const content = pkgscripts.get(name) orelse continue;
+            const original_content = pkgscripts.get(name) orelse continue;
 
+            var copy_script_capacity: usize = original_content.len;
+            for (ctx.passthrough) |part| copy_script_capacity += 1 + part.len;
             // we leak this
-            var copy_script = try std.ArrayList(u8).initCapacity(ctx.allocator, content.len);
-            try RunCommand.replacePackageManagerRun(&copy_script, content);
+            var copy_script = try std.ArrayList(u8).initCapacity(ctx.allocator, copy_script_capacity);
 
-            // and this, too
-            var combined_len = content.len;
-            for (ctx.passthrough) |p| {
-                combined_len += p.len + 1;
-            }
-            var combined = try ctx.allocator.allocSentinel(u8, combined_len, 0);
-            bun.copy(u8, combined, content);
-            var remaining_script_buf = combined[content.len..];
+            try RunCommand.replacePackageManagerRun(&copy_script, original_content);
+            const len_command_only = copy_script.items.len;
 
             for (ctx.passthrough) |part| {
-                const p = part;
-                remaining_script_buf[0] = ' ';
-                bun.copy(u8, remaining_script_buf[1..], p);
-                remaining_script_buf = remaining_script_buf[p.len + 1 ..];
+                try copy_script.append(' ');
+                if (bun.shell.needsEscapeUtf8AsciiLatin1(part)) {
+                    try bun.shell.escape8Bit(part, &copy_script, true);
+                } else {
+                    try copy_script.appendSlice(part);
+                }
             }
+            try copy_script.append(0);
 
             try scripts.append(.{
                 .package_json_path = try ctx.allocator.dupe(u8, package_json_path),
                 .package_name = pkgjson.name,
                 .script_name = name,
-                .script_content = copy_script.items,
-                .combined = combined,
+                .script_content = copy_script.items[0..len_command_only],
+                .combined = copy_script.items[0 .. copy_script.items.len - 1 :0],
                 .deps = pkgjson.dependencies,
                 .PATH = PATH,
             });
diff --git a/src/cli/init_command.zig b/src/cli/init_command.zig
index 35d22af2fe..86f6efd224 100644
--- a/src/cli/init_command.zig
+++ b/src/cli/init_command.zig
@@ -12,7 +12,7 @@ const std = @import("std");
 const open = @import("../open.zig");
 const CLI = @import("../cli.zig");
 const Fs = @import("../fs.zig");
-const ParseJSON = @import("../json_parser.zig").ParsePackageJSONUTF8;
+const JSON = bun.JSON;
 const js_parser = bun.js_parser;
 const js_ast = bun.JSAst;
 const linker = @import("../linker.zig");
@@ -21,16 +21,14 @@ const initializeStore = @import("./create_command.zig").initializeStore;
 const lex = bun.js_lexer;
 const logger = bun.logger;
 const JSPrinter = bun.js_printer;
+const exists = bun.sys.exists;
+const existsZ = bun.sys.existsZ;
 
-fn exists(path: anytype) bool {
-    return bun.sys.exists(path);
-}
 pub const InitCommand = struct {
-    fn prompt(
+    pub fn prompt(
         alloc: std.mem.Allocator,
         comptime label: string,
         default: []const u8,
-        _: bool,
     ) ![]const u8 {
         Output.pretty(label, .{});
         if (default.len > 0) {
@@ -171,7 +169,7 @@ pub const InitCommand = struct {
             process_package_json: {
                 var source = logger.Source.initPathString("package.json", package_json_contents.list.items);
                 var log = logger.Log.init(alloc);
-                var package_json_expr = ParseJSON(&source, &log, alloc) catch {
+                var package_json_expr = JSON.parsePackageJSONUTF8(&source, &log, alloc) catch {
                     package_json_file = null;
                     break :process_package_json;
                 };
@@ -211,7 +209,7 @@ pub const InitCommand = struct {
                 };
 
                 for (paths_to_try) |path| {
-                    if (exists(path)) {
+                    if (existsZ(path)) {
                         fields.entry_point = bun.asByteSlice(path);
                         break :infer;
                     }
@@ -248,7 +246,6 @@ pub const InitCommand = struct {
                     alloc,
                     "<r><cyan>package name<r> ",
                     fields.name,
-                    Output.enable_ansi_colors_stdout,
                 ) catch |err| {
                     if (err == error.EndOfStream) return;
                     return err;
@@ -260,7 +257,6 @@ pub const InitCommand = struct {
                     alloc,
                     "<r><cyan>entry point<r> ",
                     fields.entry_point,
-                    Output.enable_ansi_colors_stdout,
                 ) catch |err| {
                     if (err == error.EndOfStream) return;
                     return err;
@@ -282,16 +278,16 @@ pub const InitCommand = struct {
 
         var steps = Steps{};
 
-        steps.write_gitignore = !exists(".gitignore");
+        steps.write_gitignore = !existsZ(".gitignore");
 
-        steps.write_readme = !exists("README.md") and !exists("README") and !exists("README.txt") and !exists("README.mdx");
+        steps.write_readme = !existsZ("README.md") and !existsZ("README") and !existsZ("README.txt") and !existsZ("README.mdx");
 
         steps.write_tsconfig = brk: {
-            if (exists("tsconfig.json")) {
+            if (existsZ("tsconfig.json")) {
                 break :brk false;
             }
 
-            if (exists("jsconfig.json")) {
+            if (existsZ("jsconfig.json")) {
                 break :brk false;
             }
 
@@ -439,7 +435,7 @@ pub const InitCommand = struct {
                 " \"'",
                 fields.entry_point,
             )) {
-                Output.prettyln("  <r><cyan>bun run {any}<r>", .{JSPrinter.formatJSONString(fields.entry_point)});
+                Output.prettyln("  <r><cyan>bun run {any}<r>", .{bun.fmt.formatJSONString(fields.entry_point)});
             } else {
                 Output.prettyln("  <r><cyan>bun run {s}<r>", .{fields.entry_point});
             }
@@ -447,7 +443,7 @@ pub const InitCommand = struct {
 
         Output.flush();
 
-        if (exists("package.json")) {
+        if (existsZ("package.json")) {
             var process = std.process.Child.init(
                 &.{
                     try bun.selfExePath(),
diff --git a/src/cli/install.ps1 b/src/cli/install.ps1
index d541cd1103..4d3e36a579 100644
--- a/src/cli/install.ps1
+++ b/src/cli/install.ps1
@@ -1,6 +1,5 @@
 #!/usr/bin/env pwsh
 param(
-  # TODO: change this to 'latest' when Bun for Windows is stable.
   [String]$Version = "latest",
   # Forces installing the baseline build regardless of what CPU you are actually using.
   [Switch]$ForceBaseline = $false,
diff --git a/src/cli/install.sh b/src/cli/install.sh
index 08a0817f6d..f32e073258 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/install_command.zig b/src/cli/install_command.zig
index 6183d43d86..ca69c32e46 100644
--- a/src/cli/install_command.zig
+++ b/src/cli/install_command.zig
@@ -9,7 +9,7 @@ pub const InstallCommand = struct {
             error.InvalidPackageJSON,
             => {
                 const log = &bun.CLI.Cli.log_;
-                log.printForLogLevel(bun.Output.errorWriter()) catch {};
+                log.print(bun.Output.errorWriter()) catch {};
                 bun.Global.exit(1);
             },
             else => |e| return e,
diff --git a/src/cli/outdated_command.zig b/src/cli/outdated_command.zig
index a786e3afbb..0a951002ba 100644
--- a/src/cli/outdated_command.zig
+++ b/src/cli/outdated_command.zig
@@ -21,7 +21,7 @@ const Table = bun.fmt.Table;
 
 pub const OutdatedCommand = struct {
     pub fn exec(ctx: Command.Context) !void {
-        Output.prettyErrorln("<r><b>bun outdated <r><d>v" ++ Global.package_json_version_with_sha ++ "<r>", .{});
+        Output.prettyln("<r><b>bun outdated <r><d>v" ++ Global.package_json_version_with_sha ++ "<r>", .{});
         Output.flush();
 
         const cli = try PackageManager.CommandLineArguments.parse(ctx.allocator, .outdated);
@@ -77,12 +77,7 @@ pub const OutdatedCommand = struct {
                     }
 
                     if (ctx.log.hasErrors()) {
-                        switch (Output.enable_ansi_colors) {
-                            inline else => |enable_ansi_colors| try manager.log.printForLogLevelWithEnableAnsiColors(
-                                Output.errorWriter(),
-                                enable_ansi_colors,
-                            ),
-                        }
+                        try manager.log.print(Output.errorWriter());
                     }
                 }
 
@@ -355,9 +350,11 @@ pub const OutdatedCommand = struct {
                 const package_name = pkg_names[package_id].slice(string_buf);
                 var expired = false;
                 const manifest = manager.manifests.byNameAllowExpired(
+                    manager,
                     manager.scopeForPackageName(package_name),
                     package_name,
                     &expired,
+                    .load_from_memory_fallback_to_disk,
                 ) orelse continue;
 
                 const latest = manifest.findByDistTag("latest") orelse continue;
@@ -476,9 +473,11 @@ pub const OutdatedCommand = struct {
 
                     var expired = false;
                     const manifest = manager.manifests.byNameAllowExpired(
+                        manager,
                         manager.scopeForPackageName(package_name),
                         package_name,
                         &expired,
+                        .load_from_memory_fallback_to_disk,
                     ) orelse continue;
 
                     const latest = manifest.findByDistTag("latest") orelse continue;
@@ -500,7 +499,7 @@ pub const OutdatedCommand = struct {
                         else
                             "";
 
-                        Output.pretty("{s}", .{table.verticalEdge()});
+                        Output.pretty("{s}", .{table.symbols.verticalEdge()});
                         for (0..column_left_pad) |_| Output.pretty(" ", .{});
 
                         Output.pretty("{s}<d>{s}<r>", .{ package_name, behavior_str });
@@ -509,7 +508,7 @@ pub const OutdatedCommand = struct {
 
                     {
                         // current version
-                        Output.pretty("{s}", .{table.verticalEdge()});
+                        Output.pretty("{s}", .{table.symbols.verticalEdge()});
                         for (0..column_left_pad) |_| Output.pretty(" ", .{});
 
                         version_writer.print("{}", .{resolution.value.npm.version.fmt(string_buf)}) catch bun.outOfMemory();
@@ -520,7 +519,7 @@ pub const OutdatedCommand = struct {
 
                     {
                         // update version
-                        Output.pretty("{s}", .{table.verticalEdge()});
+                        Output.pretty("{s}", .{table.symbols.verticalEdge()});
                         for (0..column_left_pad) |_| Output.pretty(" ", .{});
 
                         version_writer.print("{}", .{update.version.fmt(manifest.string_buf)}) catch bun.outOfMemory();
@@ -531,7 +530,7 @@ pub const OutdatedCommand = struct {
 
                     {
                         // latest version
-                        Output.pretty("{s}", .{table.verticalEdge()});
+                        Output.pretty("{s}", .{table.symbols.verticalEdge()});
                         for (0..column_left_pad) |_| Output.pretty(" ", .{});
 
                         version_writer.print("{}", .{latest.version.fmt(manifest.string_buf)}) catch bun.outOfMemory();
@@ -541,7 +540,7 @@ pub const OutdatedCommand = struct {
                     }
 
                     if (was_filtered) {
-                        Output.pretty("{s}", .{table.verticalEdge()});
+                        Output.pretty("{s}", .{table.symbols.verticalEdge()});
                         for (0..column_left_pad) |_| Output.pretty(" ", .{});
 
                         const workspace_name = pkg_names[workspace_pkg_id].slice(string_buf);
@@ -550,7 +549,7 @@ pub const OutdatedCommand = struct {
                         for (workspace_name.len..workspace_column_inside_length + column_right_pad) |_| Output.pretty(" ", .{});
                     }
 
-                    Output.pretty("{s}\n", .{table.verticalEdge()});
+                    Output.pretty("{s}\n", .{table.symbols.verticalEdge()});
                 }
             }
         }
@@ -585,8 +584,10 @@ pub const OutdatedCommand = struct {
 
                 const package_name = pkg_names[package_id].slice(string_buf);
                 _ = manager.manifests.byName(
+                    manager,
                     manager.scopeForPackageName(package_name),
                     package_name,
+                    .load_from_memory_fallback_to_disk,
                 ) orelse {
                     const task_id = Install.Task.Id.forManifest(package_name);
                     if (manager.hasCreatedNetworkTask(task_id, dep.behavior.optional)) continue;
@@ -595,7 +596,7 @@ pub const OutdatedCommand = struct {
 
                     var task = manager.getNetworkTask();
                     task.* = .{
-                        .package_manager = &PackageManager.instance,
+                        .package_manager = manager,
                         .callback = undefined,
                         .task_id = task_id,
                         .allocator = manager.allocator,
diff --git a/src/cli/pack_command.zig b/src/cli/pack_command.zig
index ee41c8ddaa..1ad073b265 100644
--- a/src/cli/pack_command.zig
+++ b/src/cli/pack_command.zig
@@ -34,6 +34,8 @@ const BoringSSL = bun.BoringSSL;
 const sha = bun.sha;
 const LogLevel = PackageManager.Options.LogLevel;
 const FileDescriptor = bun.FileDescriptor;
+const Publish = bun.CLI.PublishCommand;
+const Dependency = Install.Dependency;
 
 pub const PackCommand = struct {
     pub const Context = struct {
@@ -49,49 +51,30 @@ pub const PackCommand = struct {
 
         bundled_deps: std.ArrayListUnmanaged(BundledDep) = .{},
 
-        stats: struct {
+        stats: Stats = .{},
+
+        const Stats = struct {
             unpacked_size: usize = 0,
             total_files: usize = 0,
             ignored_files: usize = 0,
             ignored_directories: usize = 0,
             packed_size: usize = 0,
             bundled_deps: usize = 0,
-        } = .{},
-
-        pub const BundledDep = struct {
-            name: string,
-            was_packed: bool = false,
-            from_root_package_json: bool,
         };
 
-        const IntegrityFormatter = struct {
-            bytes: [sha.SHA512.digest]u8,
-
-            pub fn format(this: IntegrityFormatter, comptime _: string, _: std.fmt.FormatOptions, writer: anytype) !void {
-                var buf: [std.base64.standard.Encoder.calcSize(sha.SHA512.digest)]u8 = undefined;
-                const count = bun.simdutf.base64.encode(this.bytes[0..sha.SHA512.digest], &buf, false);
-
-                const encoded = buf[0..count];
-
-                try writer.print("sha512-{s}[...]{s}", .{ encoded[0..13], encoded[encoded.len - 15 ..] });
-            }
-        };
-
-        fn fmtIntegrity(bytes: [sha.SHA512.digest]u8) IntegrityFormatter {
-            return .{
-                .bytes = bytes,
-            };
-        }
-
-        pub fn printSummary(this: *const Context, sha1_digest: ?[sha.SHA1.digest]u8, sha512_digest: ?[sha.SHA512.digest]u8, comptime log_level: LogLevel) void {
-            if (comptime log_level != .silent) {
-                const stats = this.stats;
+        pub fn printSummary(
+            stats: Stats,
+            maybe_shasum: ?[sha.SHA1.digest]u8,
+            maybe_integrity: ?[sha.SHA512.digest]u8,
+            log_level: LogLevel,
+        ) void {
+            if (log_level != .silent) {
                 Output.prettyln("\n<r><b><blue>Total files<r>: {d}", .{stats.total_files});
-                if (sha1_digest) |sha1| {
-                    Output.prettyln("<b><blue>Shasum<r>: {s}", .{bun.fmt.bytesToHex(sha1, .lower)});
+                if (maybe_shasum) |shasum| {
+                    Output.prettyln("<b><blue>Shasum<r>: {s}", .{bun.fmt.bytesToHex(shasum, .lower)});
                 }
-                if (sha512_digest) |sha512| {
-                    Output.prettyln("<b><blue>Integrity<r>: {}", .{fmtIntegrity(sha512)});
+                if (maybe_integrity) |integrity| {
+                    Output.prettyln("<b><blue>Integrity<r>: {}", .{bun.fmt.integrity(integrity, .short)});
                 }
                 Output.prettyln("<b><blue>Unpacked size<r>: {}", .{
                     bun.fmt.size(stats.unpacked_size, .{ .space_between_number_and_unit = false }),
@@ -108,8 +91,14 @@ pub const PackCommand = struct {
         }
     };
 
+    pub const BundledDep = struct {
+        name: string,
+        was_packed: bool = false,
+        from_root_package_json: bool,
+    };
+
     pub fn execWithManager(ctx: Command.Context, manager: *PackageManager) !void {
-        Output.prettyErrorln("<r><b>bun pack <r><d>v" ++ Global.package_json_version_with_sha ++ "<r>", .{});
+        Output.prettyln("<r><b>bun pack <r><d>v" ++ Global.package_json_version_with_sha ++ "<r>", .{});
         Output.flush();
 
         var lockfile: Lockfile = undefined;
@@ -146,13 +135,8 @@ pub const PackCommand = struct {
                         }),
                     }
 
-                    if (ctx.log.hasErrors()) {
-                        switch (Output.enable_ansi_colors) {
-                            inline else => |enable_ansi_colors| try manager.log.printForLogLevelWithEnableAnsiColors(
-                                Output.errorWriter(),
-                                enable_ansi_colors,
-                            ),
-                        }
+                    if (manager.log.hasErrors()) {
+                        try manager.log.print(Output.errorWriter());
                     }
 
                     Global.crash();
@@ -173,7 +157,7 @@ pub const PackCommand = struct {
                 // }
 
                 // just pack the current workspace
-                pack(&pack_ctx, manager.original_package_json_path, log_level) catch |err| {
+                pack(&pack_ctx, manager.original_package_json_path, log_level, false) catch |err| {
                     switch (err) {
                         error.OutOfMemory => bun.outOfMemory(),
                         error.MissingPackageName, error.MissingPackageVersion => {
@@ -219,13 +203,19 @@ pub const PackCommand = struct {
         return execWithManager(ctx, manager);
     }
 
-    const PackError = OOM || error{
-        MissingPackageName,
-        InvalidPackageName,
-        MissingPackageVersion,
-        InvalidPackageVersion,
-        MissingPackageJSON,
-    };
+    pub fn PackError(comptime for_publish: bool) type {
+        return OOM || error{
+            MissingPackageName,
+            InvalidPackageName,
+            MissingPackageVersion,
+            InvalidPackageVersion,
+            MissingPackageJSON,
+        } ||
+            if (for_publish) error{
+            RestrictedUnscopedPackage,
+            PrivatePackage,
+        } else error{};
+    }
 
     const package_prefix = "package/";
 
@@ -280,25 +270,25 @@ pub const PackCommand = struct {
     };
 
     fn iterateIncludedProjectTree(
-        ctx: *Context,
+        allocator: std.mem.Allocator,
         includes: []const Pattern,
         root_dir: std.fs.Dir,
         comptime log_level: LogLevel,
     ) OOM!PackQueue {
-        var pack_queue = PackQueue.init(ctx.allocator, {});
+        var pack_queue = PackQueue.init(allocator, {});
 
         var ignores: std.ArrayListUnmanaged(IgnorePatterns) = .{};
-        defer ignores.deinit(ctx.allocator);
+        defer ignores.deinit(allocator);
 
         var dirs: std.ArrayListUnmanaged(DirInfo) = .{};
-        defer dirs.deinit(ctx.allocator);
+        defer dirs.deinit(allocator);
 
-        try dirs.append(ctx.allocator, .{ root_dir, "", 1 });
+        try dirs.append(allocator, .{ root_dir, "", 1 });
 
         var included_dirs: std.ArrayListUnmanaged(DirInfo) = .{};
-        defer included_dirs.deinit(ctx.allocator);
+        defer included_dirs.deinit(allocator);
 
-        var subpath_dedupe = bun.StringHashMap(void).init(ctx.allocator);
+        var subpath_dedupe = bun.StringHashMap(void).init(allocator);
         defer subpath_dedupe.deinit();
 
         // first find included dirs and files
@@ -315,7 +305,7 @@ pub const PackCommand = struct {
                 if (entry.kind != .file and entry.kind != .directory) continue;
 
                 const entry_name = entry.name.slice();
-                const entry_subpath = try entrySubpath(ctx, dir_subpath, entry_name);
+                const entry_subpath = try entrySubpath(allocator, dir_subpath, entry_name);
 
                 var included = false;
 
@@ -358,7 +348,7 @@ pub const PackCommand = struct {
                 if (!included) {
                     if (entry.kind == .directory) {
                         const subdir = openSubdir(dir, entry_name, entry_subpath);
-                        try dirs.append(ctx.allocator, .{ subdir, entry_subpath, dir_depth + 1 });
+                        try dirs.append(allocator, .{ subdir, entry_subpath, dir_depth + 1 });
                     }
 
                     continue;
@@ -367,7 +357,7 @@ pub const PackCommand = struct {
                 switch (entry.kind) {
                     .directory => {
                         const subdir = openSubdir(dir, entry_name, entry_subpath);
-                        try included_dirs.append(ctx.allocator, .{ subdir, entry_subpath, dir_depth + 1 });
+                        try included_dirs.append(allocator, .{ subdir, entry_subpath, dir_depth + 1 });
                     },
                     .file => {
                         const dedupe_entry = try subpath_dedupe.getOrPut(entry_subpath);
@@ -383,7 +373,7 @@ pub const PackCommand = struct {
 
         // for each included dir, traverse it's entries, exclude any with `negate_no_match`.
         for (included_dirs.items) |included_dir_info| {
-            try addEntireTree(ctx, included_dir_info, &pack_queue, &subpath_dedupe, log_level);
+            try addEntireTree(allocator, included_dir_info, &pack_queue, &subpath_dedupe, log_level);
         }
 
         return pack_queue;
@@ -391,19 +381,19 @@ pub const PackCommand = struct {
 
     /// Adds all files in a directory tree to `pack_list` (default ignores still apply)
     fn addEntireTree(
-        ctx: *Context,
+        allocator: std.mem.Allocator,
         root_dir_info: DirInfo,
         pack_queue: *PackQueue,
         maybe_dedupe: ?*bun.StringHashMap(void),
         comptime log_level: LogLevel,
     ) OOM!void {
         var dirs: std.ArrayListUnmanaged(DirInfo) = .{};
-        defer dirs.deinit(ctx.allocator);
+        defer dirs.deinit(allocator);
 
-        try dirs.append(ctx.allocator, root_dir_info);
+        try dirs.append(allocator, root_dir_info);
 
         var ignores: std.ArrayListUnmanaged(IgnorePatterns) = .{};
-        defer ignores.deinit(ctx.allocator);
+        defer ignores.deinit(allocator);
 
         while (dirs.popOrNull()) |dir_info| {
             var dir, const dir_subpath, const dir_depth = dir_info;
@@ -412,12 +402,12 @@ pub const PackCommand = struct {
             while (ignores.getLastOrNull()) |last| {
                 if (last.depth < dir_depth) break;
 
-                last.deinit(ctx.allocator);
+                last.deinit(allocator);
                 ignores.items.len -= 1;
             }
 
-            if (try IgnorePatterns.readFromDisk(ctx, dir, dir_depth)) |patterns| {
-                try ignores.append(ctx.allocator, patterns);
+            if (try IgnorePatterns.readFromDisk(allocator, dir, dir_depth)) |patterns| {
+                try ignores.append(allocator, patterns);
             }
 
             if (comptime Environment.isDebug) {
@@ -434,7 +424,7 @@ pub const PackCommand = struct {
                 if (entry.kind != .file and entry.kind != .directory) continue;
 
                 const entry_name = entry.name.slice();
-                const entry_subpath = try entrySubpath(ctx, dir_subpath, entry_name);
+                const entry_subpath = try entrySubpath(allocator, dir_subpath, entry_name);
 
                 if (dir_depth == root_dir_info[2]) {
                     if (entry.kind == .directory and strings.eqlComptime(entry_name, "node_modules")) continue;
@@ -465,7 +455,7 @@ pub const PackCommand = struct {
                     .directory => {
                         const subdir = openSubdir(dir, entry_name, entry_subpath);
 
-                        try dirs.append(ctx.allocator, .{
+                        try dirs.append(allocator, .{
                             subdir,
                             entry_subpath,
                             dir_depth + 1,
@@ -492,11 +482,11 @@ pub const PackCommand = struct {
     }
 
     fn entrySubpath(
-        ctx: *Context,
+        allocator: std.mem.Allocator,
         dir_subpath: string,
         entry_name: string,
     ) OOM!stringZ {
-        return std.fmt.allocPrintZ(ctx.allocator, "{s}{s}{s}", .{
+        return std.fmt.allocPrintZ(allocator, "{s}{s}{s}", .{
             dir_subpath,
             if (dir_subpath.len == 0) "" else "/",
             entry_name,
@@ -552,7 +542,7 @@ pub const PackCommand = struct {
                 bun.assertWithLocation(dep.from_root_package_json, @src());
                 if (!strings.eqlLong(entry_name, dep.name, true)) continue;
 
-                const entry_subpath = try entrySubpath(ctx, "node_modules", entry_name);
+                const entry_subpath = try entrySubpath(ctx.allocator, "node_modules", entry_name);
 
                 const dedupe_entry = try dedupe.getOrPut(entry_subpath);
                 if (dedupe_entry.found_existing) {
@@ -628,7 +618,7 @@ pub const PackCommand = struct {
                 if (entry.kind != .file and entry.kind != .directory) continue;
 
                 const entry_name = entry.name.slice();
-                const entry_subpath = try entrySubpath(ctx, dir_subpath, entry_name);
+                const entry_subpath = try entrySubpath(ctx.allocator, dir_subpath, entry_name);
 
                 if (dir_depth == bundled_dir_info[2]) root_depth: {
                     if (strings.eqlComptime(entry_name, "package.json")) {
@@ -639,7 +629,7 @@ pub const PackCommand = struct {
                             Global.crash();
                         };
 
-                        const json = JSON.ParsePackageJSONUTF8(&source, ctx.manager.log, ctx.allocator) catch
+                        const json = JSON.parsePackageJSONUTF8(&source, ctx.manager.log, ctx.allocator) catch
                             break :root_depth;
 
                         // for each dependency in `dependencies` find the closest node_modules folder
@@ -738,21 +728,21 @@ pub const PackCommand = struct {
 
     /// Returns a list of files to pack and another list of files from bundled dependencies
     fn iterateProjectTree(
-        ctx: *Context,
+        allocator: std.mem.Allocator,
         root_dir: std.fs.Dir,
         comptime log_level: LogLevel,
     ) OOM!PackQueue {
-        var pack_queue = PackQueue.init(ctx.allocator, {});
+        var pack_queue = PackQueue.init(allocator, {});
 
         var ignores: std.ArrayListUnmanaged(IgnorePatterns) = .{};
-        defer ignores.deinit(ctx.allocator);
+        defer ignores.deinit(allocator);
 
         // Stacks and depth-first traversal. Doing so means we can push and pop from
         // ignore patterns without needing to clone the entire list for future use.
         var dirs: std.ArrayListUnmanaged(DirInfo) = .{};
-        defer dirs.deinit(ctx.allocator);
+        defer dirs.deinit(allocator);
 
-        try dirs.append(ctx.allocator, .{ root_dir, "", 1 });
+        try dirs.append(allocator, .{ root_dir, "", 1 });
 
         while (dirs.popOrNull()) |dir_info| {
             var dir, const dir_subpath, const dir_depth = dir_info;
@@ -766,12 +756,12 @@ pub const PackCommand = struct {
                 if (last.depth < dir_depth) break;
 
                 // pop patterns from files greater than or equal to the current depth.
-                last.deinit(ctx.allocator);
+                last.deinit(allocator);
                 ignores.items.len -= 1;
             }
 
-            if (try IgnorePatterns.readFromDisk(ctx, dir, dir_depth)) |patterns| {
-                try ignores.append(ctx.allocator, patterns);
+            if (try IgnorePatterns.readFromDisk(allocator, dir, dir_depth)) |patterns| {
+                try ignores.append(allocator, patterns);
             }
 
             if (comptime Environment.isDebug) {
@@ -788,7 +778,7 @@ pub const PackCommand = struct {
                 if (entry.kind != .file and entry.kind != .directory) continue;
 
                 const entry_name = entry.name.slice();
-                const entry_subpath = try entrySubpath(ctx, dir_subpath, entry_name);
+                const entry_subpath = try entrySubpath(allocator, dir_subpath, entry_name);
 
                 if (dir_depth == 1) {
                     // Special case root package.json. It is always included
@@ -823,7 +813,7 @@ pub const PackCommand = struct {
                     .directory => {
                         const subdir = openSubdir(dir, entry_name, entry_subpath);
 
-                        try dirs.append(ctx.allocator, .{
+                        try dirs.append(allocator, .{
                             subdir,
                             entry_subpath,
                             dir_depth + 1,
@@ -838,11 +828,11 @@ pub const PackCommand = struct {
     }
 
     fn getBundledDeps(
-        ctx: *Context,
+        allocator: std.mem.Allocator,
         json: Expr,
         comptime field: string,
-    ) OOM!?std.ArrayListUnmanaged(Context.BundledDep) {
-        var deps: std.ArrayListUnmanaged(Context.BundledDep) = .{};
+    ) OOM!?std.ArrayListUnmanaged(BundledDep) {
+        var deps: std.ArrayListUnmanaged(BundledDep) = .{};
         const bundled_deps = json.get(field) orelse return null;
 
         invalid_field: {
@@ -851,8 +841,8 @@ pub const PackCommand = struct {
                 else => break :invalid_field,
             };
             while (iter.next()) |bundled_dep_item| {
-                const bundled_dep = bundled_dep_item.asStringCloned(ctx.allocator) orelse break :invalid_field;
-                try deps.append(ctx.allocator, .{
+                const bundled_dep = try bundled_dep_item.asStringCloned(allocator) orelse break :invalid_field;
+                try deps.append(allocator, .{
                     .name = bundled_dep,
                     .from_root_package_json = true,
                 });
@@ -876,7 +866,7 @@ pub const PackCommand = struct {
     };
 
     fn getPackageBins(
-        ctx: *Context,
+        allocator: std.mem.Allocator,
         json: Expr,
     ) OOM![]const BinInfo {
         var bins: std.ArrayListUnmanaged(BinInfo) = .{};
@@ -884,10 +874,10 @@ pub const PackCommand = struct {
         var path_buf: PathBuffer = undefined;
 
         if (json.asProperty("bin")) |bin| {
-            if (bin.expr.asString(ctx.allocator)) |bin_str| {
+            if (bin.expr.asString(allocator)) |bin_str| {
                 const normalized = bun.path.normalizeBuf(bin_str, &path_buf, .posix);
-                try bins.append(ctx.allocator, .{
-                    .path = try ctx.allocator.dupe(u8, normalized),
+                try bins.append(allocator, .{
+                    .path = try allocator.dupe(u8, normalized),
                     .type = .file,
                 });
                 return bins.items;
@@ -899,10 +889,10 @@ pub const PackCommand = struct {
 
                     for (bin_obj.properties.slice()) |bin_prop| {
                         if (bin_prop.value) |bin_prop_value| {
-                            if (bin_prop_value.asString(ctx.allocator)) |bin_str| {
+                            if (bin_prop_value.asString(allocator)) |bin_str| {
                                 const normalized = bun.path.normalizeBuf(bin_str, &path_buf, .posix);
-                                try bins.append(ctx.allocator, .{
-                                    .path = try ctx.allocator.dupe(u8, normalized),
+                                try bins.append(allocator, .{
+                                    .path = try allocator.dupe(u8, normalized),
                                     .type = .file,
                                 });
                             }
@@ -919,10 +909,10 @@ pub const PackCommand = struct {
             switch (directories.expr.data) {
                 .e_object => |directories_obj| {
                     if (directories_obj.asProperty("bin")) |bin| {
-                        if (bin.expr.asString(ctx.allocator)) |bin_str| {
+                        if (bin.expr.asString(allocator)) |bin_str| {
                             const normalized = bun.path.normalizeBuf(bin_str, &path_buf, .posix);
-                            try bins.append(ctx.allocator, .{
-                                .path = try ctx.allocator.dupe(u8, normalized),
+                            try bins.append(allocator, .{
+                                .path = try allocator.dupe(u8, normalized),
                                 .type = .dir,
                             });
                         }
@@ -1079,11 +1069,12 @@ pub const PackCommand = struct {
 
     const BufferedFileReader = std.io.BufferedReader(1024 * 512, File.Reader);
 
-    fn pack(
+    pub fn pack(
         ctx: *Context,
         abs_package_json_path: stringZ,
         comptime log_level: LogLevel,
-    ) PackError!void {
+        comptime for_publish: bool,
+    ) PackError(for_publish)!if (for_publish) Publish.Context(true) else void {
         const manager = ctx.manager;
         const json = switch (manager.workspace_package_json_cache.getWithPath(manager.allocator, manager.log, abs_package_json_path, .{
             .guess_indentation = true,
@@ -1094,26 +1085,62 @@ pub const PackCommand = struct {
             },
             .parse_err => |err| {
                 Output.err(err, "failed to parse package.json: {s}", .{abs_package_json_path});
-                switch (Output.enable_ansi_colors) {
-                    inline else => |enable_ansi_colors| {
-                        manager.log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), enable_ansi_colors) catch {};
-                    },
-                }
+                manager.log.print(Output.errorWriter()) catch {};
                 Global.crash();
             },
             .entry => |entry| entry,
         };
 
+        if (comptime for_publish) {
+            if (json.root.get("publishConfig")) |config| {
+                if (manager.options.publish_config.tag.len == 0) {
+                    if (try config.getStringCloned(ctx.allocator, "tag")) |tag| {
+                        manager.options.publish_config.tag = tag;
+                    }
+                }
+                if (manager.options.publish_config.access == null) {
+                    if (try config.getString(ctx.allocator, "access")) |access| {
+                        manager.options.publish_config.access = PackageManager.Options.Access.fromStr(access[0]) orelse {
+                            Output.errGeneric("invalid `access` value: '{s}'", .{access[0]});
+                            Global.crash();
+                        };
+                    }
+                }
+            }
+
+            // maybe otp
+        }
+
         const package_name_expr: Expr = json.root.get("name") orelse return error.MissingPackageName;
-        const package_name = package_name_expr.asStringCloned(ctx.allocator) orelse return error.InvalidPackageName;
-        defer ctx.allocator.free(package_name);
+        const package_name = try package_name_expr.asStringCloned(ctx.allocator) orelse return error.InvalidPackageName;
+        if (comptime for_publish) {
+            const is_scoped = try Dependency.isScopedPackageName(package_name);
+            if (manager.options.publish_config.access) |access| {
+                if (access == .restricted and !is_scoped) {
+                    return error.RestrictedUnscopedPackage;
+                }
+            }
+        }
+        defer if (comptime !for_publish) ctx.allocator.free(package_name);
         if (package_name.len == 0) return error.InvalidPackageName;
 
         const package_version_expr: Expr = json.root.get("version") orelse return error.MissingPackageVersion;
-        const package_version = package_version_expr.asStringCloned(ctx.allocator) orelse return error.InvalidPackageVersion;
-        defer ctx.allocator.free(package_version);
+        const package_version = try package_version_expr.asStringCloned(ctx.allocator) orelse return error.InvalidPackageVersion;
+        defer if (comptime !for_publish) ctx.allocator.free(package_version);
         if (package_version.len == 0) return error.InvalidPackageVersion;
 
+        if (comptime for_publish) {
+            if (json.root.get("private")) |private| {
+                if (private.asBool()) |is_private| {
+                    if (is_private) {
+                        return error.PrivatePackage;
+                    }
+                }
+            }
+        }
+
+        const edited_package_json = try editRootPackageJSON(ctx.allocator, ctx.lockfile, json);
+
         var this_bundler: bun.bundler.Bundler = undefined;
 
         _ = RunCommand.configureEnvForRun(
@@ -1133,13 +1160,40 @@ pub const PackCommand = struct {
         };
 
         const abs_workspace_path: string = strings.withoutTrailingSlash(strings.withoutSuffixComptime(abs_package_json_path, "package.json"));
+        try manager.env.map.put("npm_command", "pack");
 
-        const postpack_script: ?string = postpack_script: {
+        const postpack_script, const publish_script: ?[]const u8, const postpublish_script: ?[]const u8 = post_scripts: {
             // --ignore-scripts
-            if (!manager.options.do.run_scripts) break :postpack_script null;
+            if (!manager.options.do.run_scripts) break :post_scripts .{ null, null, null };
 
-            const scripts = json.root.asProperty("scripts") orelse break :postpack_script null;
-            if (scripts.expr.data != .e_object) break :postpack_script null;
+            const scripts = json.root.asProperty("scripts") orelse break :post_scripts .{ null, null, null };
+            if (scripts.expr.data != .e_object) break :post_scripts .{ null, null, null };
+
+            if (comptime for_publish) {
+                if (scripts.expr.get("prepublishOnly")) |prepublish_only_script_str| {
+                    if (prepublish_only_script_str.asString(ctx.allocator)) |prepublish_only| {
+                        _ = RunCommand.runPackageScriptForeground(
+                            ctx.command_ctx,
+                            ctx.allocator,
+                            prepublish_only,
+                            "prepublishOnly",
+                            abs_workspace_path,
+                            this_bundler.env,
+                            &.{},
+                            manager.options.log_level == .silent,
+                            ctx.command_ctx.debug.use_system_shell,
+                        ) catch |err| {
+                            switch (err) {
+                                error.MissingShell => {
+                                    Output.errGeneric("failed to find shell executable to run prepublishOnly script", .{});
+                                    Global.crash();
+                                },
+                                error.OutOfMemory => |oom| return oom,
+                            }
+                        };
+                    }
+                }
+            }
 
             if (scripts.expr.get("prepack")) |prepack_script| {
                 if (prepack_script.asString(ctx.allocator)) |prepack_script_str| {
@@ -1189,13 +1243,25 @@ pub const PackCommand = struct {
                 }
             }
 
+            var postpack_script: ?[]const u8 = null;
             if (scripts.expr.get("postpack")) |postpack| {
-                if (postpack.asString(ctx.allocator)) |postpack_str| {
-                    break :postpack_script postpack_str;
-                }
+                postpack_script = postpack.asString(ctx.allocator);
             }
 
-            break :postpack_script null;
+            if (comptime for_publish) {
+                var publish_script: ?[]const u8 = null;
+                var postpublish_script: ?[]const u8 = null;
+                if (scripts.expr.get("publish")) |publish| {
+                    publish_script = try publish.asStringCloned(ctx.allocator);
+                }
+                if (scripts.expr.get("postpublish")) |postpublish| {
+                    postpublish_script = try postpublish.asStringCloned(ctx.allocator);
+                }
+
+                break :post_scripts .{ postpack_script, publish_script, postpublish_script };
+            }
+
+            break :post_scripts .{ postpack_script, null, null };
         };
 
         var root_dir = root_dir: {
@@ -1211,8 +1277,8 @@ pub const PackCommand = struct {
         };
         defer root_dir.close();
 
-        ctx.bundled_deps = try getBundledDeps(ctx, json.root, "bundledDependencies") orelse
-            try getBundledDeps(ctx, json.root, "bundleDependencies") orelse
+        ctx.bundled_deps = try getBundledDeps(ctx.allocator, json.root, "bundledDependencies") orelse
+            try getBundledDeps(ctx.allocator, json.root, "bundleDependencies") orelse
             .{};
 
         var pack_queue = pack_queue: {
@@ -1225,7 +1291,7 @@ pub const PackCommand = struct {
                         var files_array = _files_array;
                         while (files_array.next()) |files_entry| {
                             if (files_entry.asString(ctx.allocator)) |file_entry_str| {
-                                const parsed = try Pattern.fromUTF8(ctx, file_entry_str) orelse continue;
+                                const parsed = try Pattern.fromUTF8(ctx.allocator, file_entry_str) orelse continue;
                                 try includes.append(ctx.allocator, parsed);
                                 continue;
                             }
@@ -1234,7 +1300,7 @@ pub const PackCommand = struct {
                         }
 
                         break :pack_queue try iterateIncludedProjectTree(
-                            ctx,
+                            ctx.allocator,
                             includes.items,
                             root_dir,
                             log_level,
@@ -1248,7 +1314,7 @@ pub const PackCommand = struct {
 
             // pack from project root
             break :pack_queue try iterateProjectTree(
-                ctx,
+                ctx.allocator,
                 root_dir,
                 log_level,
             );
@@ -1266,15 +1332,23 @@ pub const PackCommand = struct {
 
             printArchivedFilesAndPackages(ctx, root_dir, true, &pack_queue, 0);
 
-            if (manager.options.pack_destination.len == 0) {
-                Output.pretty("\n{}\n", .{fmtTarballFilename(package_name, package_version)});
-            } else {
-                var dest_buf: PathBuffer = undefined;
-                const abs_tarball_dest, _ = absTarballDestination(ctx, abs_workspace_path, package_name, package_version, &dest_buf);
-                Output.pretty("\n{s}\n", .{abs_tarball_dest});
+            if (comptime !for_publish) {
+                if (manager.options.pack_destination.len == 0) {
+                    Output.pretty("\n{}\n", .{fmtTarballFilename(package_name, package_version)});
+                } else {
+                    var dest_buf: PathBuffer = undefined;
+                    const abs_tarball_dest, _ = absTarballDestination(
+                        ctx.manager.options.pack_destination,
+                        abs_workspace_path,
+                        package_name,
+                        package_version,
+                        &dest_buf,
+                    );
+                    Output.pretty("\n{s}\n", .{abs_tarball_dest});
+                }
             }
 
-            ctx.printSummary(null, null, log_level);
+            Context.printSummary(ctx.stats, null, null, log_level);
 
             if (postpack_script) |postpack_script_str| {
                 _ = RunCommand.runPackageScriptForeground(
@@ -1297,10 +1371,38 @@ pub const PackCommand = struct {
                     }
                 };
             }
+
+            if (comptime for_publish) {
+                var dest_buf: bun.PathBuffer = undefined;
+                const abs_tarball_dest, _ = absTarballDestination(
+                    ctx.manager.options.pack_destination,
+                    abs_workspace_path,
+                    package_name,
+                    package_version,
+                    &dest_buf,
+                );
+                return .{
+                    .allocator = ctx.allocator,
+                    .command_ctx = ctx.command_ctx,
+                    .manager = manager,
+                    .package_name = package_name,
+                    .package_version = package_version,
+                    .abs_tarball_path = try ctx.allocator.dupeZ(u8, abs_tarball_dest),
+                    .tarball_bytes = "",
+                    .shasum = undefined,
+                    .integrity = undefined,
+                    .uses_workspaces = false,
+                    .publish_script = publish_script,
+                    .postpublish_script = postpublish_script,
+                    .script_env = this_bundler.env,
+                    .normalized_pkg_info = "",
+                };
+            }
+
             return;
         }
 
-        const bins = try getPackageBins(ctx, json.root);
+        const bins = try getPackageBins(ctx.allocator, json.root);
         defer for (bins) |bin| ctx.allocator.free(bin.path);
 
         var print_buf = std.ArrayList(u8).init(ctx.allocator);
@@ -1316,7 +1418,7 @@ pub const PackCommand = struct {
             },
             else => {},
         }
-        switch (archive.writeSetCompressionGzip()) {
+        switch (archive.writeAddFilterGzip()) {
             .failed, .fatal, .warn => {
                 Output.errGeneric("failed to set archive compression to gzip: {s}", .{archive.errorString()});
                 Global.crash();
@@ -1337,6 +1439,14 @@ pub const PackCommand = struct {
         }
         print_buf.clearRetainingCapacity();
 
+        switch (archive.writeSetFilterOption(null, "os", "Unknown")) {
+            .failed, .fatal, .warn => {
+                Output.errGeneric("failed to set os to `Unknown`: {s}", .{archive.errorString()});
+                Global.crash();
+            },
+            else => {},
+        }
+
         switch (archive.writeSetOptions("gzip:!timestamp")) {
             .failed, .fatal, .warn => {
                 Output.errGeneric("failed to unset gzip timestamp option: {s}", .{archive.errorString()});
@@ -1347,7 +1457,7 @@ pub const PackCommand = struct {
 
         var dest_buf: PathBuffer = undefined;
         const abs_tarball_dest, const abs_tarball_dest_dir_end = absTarballDestination(
-            ctx,
+            ctx.manager.options.pack_destination,
             abs_workspace_path,
             package_name,
             package_version,
@@ -1385,7 +1495,7 @@ pub const PackCommand = struct {
 
         var entry = Archive.Entry.new2(archive);
 
-        const package_json_size = archive_with_progress: {
+        {
             var progress: if (log_level == .silent) void else Progress = if (comptime log_level == .silent) {} else .{};
             var node = if (comptime log_level == .silent) {} else node: {
                 progress.supports_ansi_escape_codes = Output.enable_ansi_colors;
@@ -1395,7 +1505,7 @@ pub const PackCommand = struct {
             };
             defer if (comptime log_level != .silent) node.end();
 
-            entry, const edited_package_json_size = try editAndArchivePackageJSON(ctx, archive, entry, root_dir, json);
+            entry = try archivePackageJSON(ctx, archive, entry, root_dir, edited_package_json);
             if (comptime log_level != .silent) node.completeOne();
 
             while (pack_queue.removeOrNull()) |pathname| {
@@ -1460,9 +1570,7 @@ pub const PackCommand = struct {
                     bins,
                 );
             }
-
-            break :archive_with_progress edited_package_json_size;
-        };
+        }
 
         entry.free();
 
@@ -1482,10 +1590,10 @@ pub const PackCommand = struct {
             else => {},
         }
 
-        var sha1_digest: sha.SHA1.Digest = undefined;
-        var sha512_digest: sha.SHA512.Digest = undefined;
+        var shasum: sha.SHA1.Digest = undefined;
+        var integrity: sha.SHA512.Digest = undefined;
 
-        {
+        const tarball_bytes = tarball_bytes: {
             const tarball_file = File.open(abs_tarball_dest, bun.O.RDONLY, 0).unwrap() catch |err| {
                 Output.err(err, "failed to open tarball at: \"{s}\"", .{abs_tarball_dest});
                 Global.crash();
@@ -1498,6 +1606,23 @@ pub const PackCommand = struct {
             var sha512 = sha.SHA512.init();
             defer sha512.deinit();
 
+            if (comptime for_publish) {
+                const tarball_bytes = tarball_file.readToEnd(ctx.allocator).unwrap() catch |err| {
+                    Output.err(err, "failed to read tarball: \"{s}\"", .{abs_tarball_dest});
+                    Global.crash();
+                };
+
+                sha1.update(tarball_bytes);
+                sha512.update(tarball_bytes);
+
+                sha1.final(&shasum);
+                sha512.final(&integrity);
+
+                ctx.stats.packed_size = tarball_bytes.len;
+
+                break :tarball_bytes tarball_bytes;
+            }
+
             file_reader.* = .{
                 .unbuffered_reader = tarball_file.reader(),
             };
@@ -1517,29 +1642,49 @@ pub const PackCommand = struct {
                 };
             }
 
-            sha1.final(&sha1_digest);
-            sha512.final(&sha512_digest);
+            sha1.final(&shasum);
+            sha512.final(&integrity);
 
             ctx.stats.packed_size = size;
-        }
+        };
+
+        const normalized_pkg_info: if (for_publish) string else void = if (comptime for_publish)
+            try Publish.normalizedPackage(
+                ctx.allocator,
+                manager,
+                package_name,
+                package_version,
+                &json.root,
+                json.source,
+                shasum,
+                integrity,
+                abs_tarball_dest,
+            );
 
         printArchivedFilesAndPackages(
             ctx,
             root_dir,
             false,
             pack_list,
-            package_json_size,
+            edited_package_json.len,
         );
 
-        if (manager.options.pack_destination.len == 0) {
-            Output.pretty("\n{}\n", .{fmtTarballFilename(package_name, package_version)});
-        } else {
-            Output.pretty("\n{s}\n", .{abs_tarball_dest});
+        if (comptime !for_publish) {
+            if (manager.options.pack_destination.len == 0) {
+                Output.pretty("\n{}\n", .{fmtTarballFilename(package_name, package_version)});
+            } else {
+                Output.pretty("\n{s}\n", .{abs_tarball_dest});
+            }
         }
 
-        ctx.printSummary(sha1_digest, sha512_digest, log_level);
+        Context.printSummary(ctx.stats, shasum, integrity, log_level);
+
+        if (comptime for_publish) {
+            Output.flush();
+        }
 
         if (postpack_script) |postpack_script_str| {
+            Output.pretty("\n", .{});
             _ = RunCommand.runPackageScriptForeground(
                 ctx.command_ctx,
                 ctx.allocator,
@@ -1560,10 +1705,29 @@ pub const PackCommand = struct {
                 }
             };
         }
+
+        if (comptime for_publish) {
+            return .{
+                .allocator = ctx.allocator,
+                .command_ctx = ctx.command_ctx,
+                .manager = manager,
+                .package_name = package_name,
+                .package_version = package_version,
+                .abs_tarball_path = try ctx.allocator.dupeZ(u8, abs_tarball_dest),
+                .tarball_bytes = tarball_bytes,
+                .shasum = shasum,
+                .integrity = integrity,
+                .uses_workspaces = false,
+                .publish_script = publish_script,
+                .postpublish_script = postpublish_script,
+                .script_env = this_bundler.env,
+                .normalized_pkg_info = normalized_pkg_info,
+            };
+        }
     }
 
     fn absTarballDestination(
-        ctx: *Context,
+        pack_destination: string,
         abs_workspace_path: string,
         package_name: string,
         package_version: string,
@@ -1572,7 +1736,7 @@ pub const PackCommand = struct {
         const tarball_destination_dir = bun.path.joinAbsStringBuf(
             abs_workspace_path,
             dest_buf,
-            &.{ctx.manager.options.pack_destination},
+            &.{pack_destination},
             .auto,
         );
 
@@ -1628,15 +1792,13 @@ pub const PackCommand = struct {
         }
     };
 
-    fn editAndArchivePackageJSON(
+    fn archivePackageJSON(
         ctx: *Context,
         archive: *Archive,
         entry: *Archive.Entry,
         root_dir: std.fs.Dir,
-        json: *PackageManager.WorkspacePackageJSONCache.MapEntry,
-    ) OOM!struct { *Archive.Entry, usize } {
-        const edited_package_json = try editRootPackageJSON(ctx, json);
-
+        edited_package_json: string,
+    ) OOM!*Archive.Entry {
         const stat = bun.sys.fstatat(bun.toFD(root_dir), "package.json").unwrap() catch |err| {
             Output.err(err, "failed to stat package.json", .{});
             Global.crash();
@@ -1661,7 +1823,7 @@ pub const PackCommand = struct {
 
         ctx.stats.unpacked_size += @intCast(archive.writeData(edited_package_json));
 
-        return .{ entry.clear(), edited_package_json.len };
+        return entry.clear();
     }
 
     fn addArchiveEntry(
@@ -1693,11 +1855,7 @@ pub const PackCommand = struct {
 
         var perm: bun.Mode = @intCast(stat.mode);
         // https://github.com/npm/cli/blob/ec105f400281a5bfd17885de1ea3d54d0c231b27/node_modules/pacote/lib/util/tar-create-options.js#L20
-        if (comptime !Environment.isWindows) {
-            // on windows we create a shim executable. the bin file permissions
-            // do not need to change
-            if (isPackageBin(bins, filename)) perm |= 0o111;
-        }
+        if (isPackageBin(bins, filename)) perm |= 0o111;
         entry.setPerm(@intCast(perm));
 
         // '1985-10-26T08:15:00.000Z'
@@ -1734,7 +1892,8 @@ pub const PackCommand = struct {
     /// Strip workspace protocols from dependency versions then
     /// returns the printed json
     fn editRootPackageJSON(
-        ctx: *Context,
+        allocator: std.mem.Allocator,
+        maybe_lockfile: ?*Lockfile,
         json: *PackageManager.WorkspacePackageJSONCache.MapEntry,
     ) OOM!string {
         for ([_]string{
@@ -1750,7 +1909,7 @@ pub const PackCommand = struct {
                             if (dependency.key == null) continue;
                             if (dependency.value == null) continue;
 
-                            const package_spec = dependency.value.?.asString(ctx.allocator) orelse continue;
+                            const package_spec = dependency.value.?.asString(allocator) orelse continue;
                             if (strings.withoutPrefixIfPossibleComptime(package_spec, "workspace:")) |without_workspace_protocol| {
 
                                 // TODO: make semver parsing more strict. `^`, `~` are not valid
@@ -1771,7 +1930,7 @@ pub const PackCommand = struct {
                                     // TODO: this might be too strict
                                     const c = without_workspace_protocol[0];
                                     if (c == '^' or c == '~' or c == '*') {
-                                        const dependency_name = dependency.key.?.asString(ctx.allocator) orelse {
+                                        const dependency_name = dependency.key.?.asString(allocator) orelse {
                                             Output.errGeneric("expected string value for dependency name in \"{s}\"", .{
                                                 dependency_group,
                                             });
@@ -1780,15 +1939,15 @@ pub const PackCommand = struct {
 
                                         failed_to_resolve: {
                                             // find the current workspace version and append to package spec without `workspace:`
-                                            const lockfile = ctx.lockfile orelse break :failed_to_resolve;
+                                            const lockfile = maybe_lockfile orelse break :failed_to_resolve;
 
                                             const workspace_version = lockfile.workspace_versions.get(Semver.String.Builder.stringHash(dependency_name)) orelse break :failed_to_resolve;
 
                                             dependency.value = Expr.allocate(
-                                                ctx.manager.allocator,
+                                                allocator,
                                                 E.String,
                                                 .{
-                                                    .data = try std.fmt.allocPrint(ctx.allocator, "{s}{}", .{
+                                                    .data = try std.fmt.allocPrint(allocator, "{s}{}", .{
                                                         switch (c) {
                                                             '^' => "^",
                                                             '~' => "~",
@@ -1814,10 +1973,10 @@ pub const PackCommand = struct {
                                 }
 
                                 dependency.value = Expr.allocate(
-                                    ctx.manager.allocator,
+                                    allocator,
                                     E.String,
                                     .{
-                                        .data = try ctx.allocator.dupe(u8, without_workspace_protocol),
+                                        .data = try allocator.dupe(u8, without_workspace_protocol),
                                     },
                                     .{},
                                 );
@@ -1830,8 +1989,8 @@ pub const PackCommand = struct {
         }
 
         const has_trailing_newline = json.source.contents.len > 0 and json.source.contents[json.source.contents.len - 1] == '\n';
-        var buffer_writer = try js_printer.BufferWriter.init(ctx.allocator);
-        try buffer_writer.buffer.list.ensureTotalCapacity(ctx.allocator, json.source.contents.len + 1);
+        var buffer_writer = try js_printer.BufferWriter.init(allocator);
+        try buffer_writer.buffer.list.ensureTotalCapacity(allocator, json.source.contents.len + 1);
         buffer_writer.append_newline = has_trailing_newline;
         var package_json_writer = js_printer.BufferPrinter.init(buffer_writer);
 
@@ -1872,7 +2031,7 @@ pub const PackCommand = struct {
 
         @"leading **/": bool,
 
-        pub fn fromUTF8(ctx: *Context, pattern: string) OOM!?Pattern {
+        pub fn fromUTF8(allocator: std.mem.Allocator, pattern: string) OOM!?Pattern {
             var remain = pattern;
             var @"has leading **/, (could start with '!')" = false;
             const has_leading_or_middle_slash, const has_trailing_slash, const add_negate = check_slashes: {
@@ -1915,10 +2074,10 @@ pub const PackCommand = struct {
             };
 
             const length = bun.simdutf.length.utf32.from.utf8.le(remain) + @intFromBool(add_negate);
-            const buf = try ctx.allocator.alloc(u32, length);
+            const buf = try allocator.alloc(u32, length);
             const result = bun.simdutf.convert.utf8.to.utf32.with_errors.le(remain, buf[@intFromBool(add_negate)..]);
             if (!result.isSuccessful()) {
-                ctx.allocator.free(buf);
+                allocator.free(buf);
                 return null;
             }
 
@@ -1982,9 +2141,9 @@ pub const PackCommand = struct {
         }
 
         // ignore files are always ignored, don't need to worry about opening or reading twice
-        pub fn readFromDisk(ctx: *Context, dir: std.fs.Dir, dir_depth: usize) OOM!?IgnorePatterns {
+        pub fn readFromDisk(allocator: std.mem.Allocator, dir: std.fs.Dir, dir_depth: usize) OOM!?IgnorePatterns {
             var patterns: std.ArrayListUnmanaged(Pattern) = .{};
-            errdefer patterns.deinit(ctx.allocator);
+            errdefer patterns.deinit(allocator);
 
             var ignore_kind: Kind = .@".npmignore";
 
@@ -2005,10 +2164,10 @@ pub const PackCommand = struct {
             };
             defer ignore_file.close();
 
-            const contents = File.from(ignore_file).readToEnd(ctx.allocator).unwrap() catch |err| {
+            const contents = File.from(ignore_file).readToEnd(allocator).unwrap() catch |err| {
                 ignoreFileFail(dir, ignore_kind, .read, err);
             };
-            defer ctx.allocator.free(contents);
+            defer allocator.free(contents);
 
             var has_rel_path = false;
 
@@ -2030,8 +2189,8 @@ pub const PackCommand = struct {
 
                 if (trimmed.len == 0) continue;
 
-                const parsed = try Pattern.fromUTF8(ctx, trimmed) orelse continue;
-                try patterns.append(ctx.allocator, parsed);
+                const parsed = try Pattern.fromUTF8(allocator, trimmed) orelse continue;
+                try patterns.append(allocator, parsed);
 
                 has_rel_path = has_rel_path or parsed.rel_path;
             }
@@ -2139,11 +2298,10 @@ pub const bindings = struct {
     //     return obj;
     // }
 
-    pub fn jsReadTarball(global: *JSGlobalObject, callFrame: *CallFrame) JSValue {
-        const args = callFrame.arguments(1).slice();
+    pub fn jsReadTarball(global: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
+        const args = callFrame.arguments_old(1).slice();
         if (args.len < 1 or !args[0].isString()) {
-            global.throw("expected tarball path string argument", .{});
-            return .zero;
+            return global.throw("expected tarball path string argument", .{});
         }
 
         const tarball_path_str = args[0].toBunString(global);
@@ -2153,14 +2311,12 @@ pub const bindings = struct {
         defer tarball_path.deinit();
 
         const tarball_file = File.from(std.fs.openFileAbsolute(tarball_path.slice(), .{}) catch |err| {
-            global.throw("failed to open tarball file \"{s}\": {s}", .{ tarball_path.slice(), @errorName(err) });
-            return .zero;
+            return global.throw("failed to open tarball file \"{s}\": {s}", .{ tarball_path.slice(), @errorName(err) });
         });
         defer tarball_file.close();
 
         const tarball = tarball_file.readToEnd(bun.default_allocator).unwrap() catch |err| {
-            global.throw("failed to read tarball contents \"{s}\": {s}", .{ tarball_path.slice(), @errorName(err) });
-            return .zero;
+            return global.throw("failed to read tarball contents \"{s}\": {s}", .{ tarball_path.slice(), @errorName(err) });
         };
         defer bun.default_allocator.free(tarball);
 
@@ -2190,39 +2346,58 @@ pub const bindings = struct {
         var entries_info = std.ArrayList(EntryInfo).init(bun.default_allocator);
         defer entries_info.deinit();
 
-        const archive = libarchive.archive_read_new();
-        defer {
-            _ = libarchive.archive_read_close(archive);
-            _ = libarchive.archive_read_free(archive);
+        const archive = Archive.readNew();
+
+        switch (archive.readSupportFormatTar()) {
+            .failed, .fatal, .warn => {
+                return global.throw("failed to support tar: {s}", .{archive.errorString()});
+            },
+            else => {},
+        }
+        switch (archive.readSupportFormatGnutar()) {
+            .failed, .fatal, .warn => {
+                return global.throw("failed to support gnutar: {s}", .{archive.errorString()});
+            },
+            else => {},
+        }
+        switch (archive.readSupportFilterGzip()) {
+            .failed, .fatal, .warn => {
+                return global.throw("failed to support gzip compression: {s}", .{archive.errorString()});
+            },
+            else => {},
         }
 
-        _ = libarchive.archive_read_support_format_tar(archive);
-        _ = libarchive.archive_read_support_format_gnutar(archive);
-        _ = libarchive.archive_read_support_compression_gzip(archive);
+        switch (archive.readSetOptions("read_concatenated_archives")) {
+            .failed, .fatal, .warn => {
+                return global.throw("failed to set read_concatenated_archives option: {s}", .{archive.errorString()});
+            },
+            else => {},
+        }
 
-        _ = libarchive.archive_read_set_options(archive, "read_concatenated_archives");
+        switch (archive.readOpenMemory(tarball)) {
+            .failed, .fatal, .warn => {
+                return global.throw("failed to open archive in memory: {s}", .{archive.errorString()});
+            },
+            else => {},
+        }
 
-        _ = libarchive.archive_read_open_memory(archive, tarball.ptr, tarball.len);
-
-        var archive_entry: *libarchive.archive_entry = undefined;
-
-        var header_status: Archive.Result = @enumFromInt(libarchive.archive_read_next_header(archive, &archive_entry));
+        var archive_entry: *Archive.Entry = undefined;
+        var header_status = archive.readNextHeader(&archive_entry);
 
         var read_buf = std.ArrayList(u8).init(bun.default_allocator);
         defer read_buf.deinit();
 
-        while (header_status != .eof) : (header_status = @enumFromInt(libarchive.archive_read_next_header(archive, &archive_entry))) {
+        while (header_status != .eof) : (header_status = archive.readNextHeader(&archive_entry)) {
             switch (header_status) {
                 .eof => unreachable,
                 .retry => continue,
                 .failed, .fatal => {
-                    global.throw("failed to read next archive header: {s}", .{Archive.errorString(@ptrCast(archive))});
-                    return .zero;
+                    return global.throw("failed to read archive header: {s}", .{Archive.errorString(@ptrCast(archive))});
                 },
                 else => {
-                    const pathname = std.mem.sliceTo(libarchive.archive_entry_pathname(archive_entry), 0);
-                    const kind = bun.C.kindFromMode(libarchive.archive_entry_filetype(archive_entry));
-                    const perm = libarchive.archive_entry_perm(archive_entry);
+                    const pathname = archive_entry.pathname();
+                    const kind = bun.C.kindFromMode(archive_entry.filetype());
+                    const perm = archive_entry.perm();
 
                     var entry_info: EntryInfo = .{
                         .pathname = String.createUTF8(pathname),
@@ -2231,17 +2406,16 @@ pub const bindings = struct {
                     };
 
                     if (kind == .file) {
-                        const size: usize = @intCast(libarchive.archive_entry_size(archive_entry));
-                        read_buf.ensureTotalCapacity(size) catch bun.outOfMemory();
+                        const size: usize = @intCast(archive_entry.size());
+                        read_buf.resize(size) catch bun.outOfMemory();
                         defer read_buf.clearRetainingCapacity();
 
-                        const read = libarchive.archive_read_data(archive, read_buf.items.ptr, size);
+                        const read = archive.readData(read_buf.items);
                         if (read < 0) {
-                            global.throw("failed to read archive entry \"{}\": {s}", .{
+                            return global.throw("failed to read archive entry \"{}\": {s}", .{
                                 bun.fmt.fmtPath(u8, pathname, .{}),
                                 Archive.errorString(@ptrCast(archive)),
                             });
-                            return .zero;
                         }
                         read_buf.items.len = @intCast(read);
                         entry_info.contents = String.createUTF8(read_buf.items);
@@ -2252,6 +2426,19 @@ pub const bindings = struct {
             }
         }
 
+        switch (archive.readClose()) {
+            .failed, .fatal, .warn => {
+                return global.throw("failed to close read archive: {s}", .{archive.errorString()});
+            },
+            else => {},
+        }
+        switch (archive.readFree()) {
+            .failed, .fatal, .warn => {
+                return global.throw("failed to close read archive: {s}", .{archive.errorString()});
+            },
+            else => {},
+        }
+
         const entries = JSArray.createEmpty(global, entries_info.items.len);
 
         for (entries_info.items, 0..) |entry, i| {
diff --git a/src/cli/package_manager_command.zig b/src/cli/package_manager_command.zig
index 90c2cb11d3..03080a5094 100644
--- a/src/cli/package_manager_command.zig
+++ b/src/cli/package_manager_command.zig
@@ -24,7 +24,8 @@ const UntrustedCommand = @import("./pm_trusted_command.zig").UntrustedCommand;
 const TrustCommand = @import("./pm_trusted_command.zig").TrustCommand;
 const DefaultTrustedCommand = @import("./pm_trusted_command.zig").DefaultTrustedCommand;
 const Environment = bun.Environment;
-const PackCommand = @import("./pack_command.zig").PackCommand;
+pub const PackCommand = @import("./pack_command.zig").PackCommand;
+const Npm = Install.Npm;
 
 const ByName = struct {
     dependencies: []const Dependency,
@@ -109,6 +110,7 @@ pub const PackageManagerCommand = struct {
             \\  <d>└<r>  <cyan>-g<r>                     print the <b>global<r> path to bin folder
             \\  bun pm <b>ls<r>                 list the dependency tree according to the current lockfile
             \\  <d>└<r>  <cyan>--all<r>                  list the entire dependency tree according to the current lockfile
+            \\  bun pm <b>whoami<r>             print the current npm username
             \\  bun pm <b>hash<r>               generate & print the hash of the current lockfile
             \\  bun pm <b>hash-string<r>        print the string used to hash the lockfile
             \\  bun pm <b>hash-print<r>         print the hash stored in the current lockfile
@@ -152,6 +154,23 @@ pub const PackageManagerCommand = struct {
         if (strings.eqlComptime(subcommand, "pack")) {
             try PackCommand.execWithManager(ctx, pm);
             Global.exit(0);
+        } else if (strings.eqlComptime(subcommand, "whoami")) {
+            const username = Npm.whoami(ctx.allocator, pm) catch |err| {
+                switch (err) {
+                    error.OutOfMemory => bun.outOfMemory(),
+                    error.NeedAuth => {
+                        Output.errGeneric("missing authentication (run <cyan>`bunx npm login`<r>)", .{});
+                    },
+                    error.ProbablyInvalidAuth => {
+                        Output.errGeneric("failed to authenticate with registry '{}'", .{
+                            bun.fmt.redactedNpmUrl(pm.options.scope.url.href),
+                        });
+                    },
+                }
+                Global.crash();
+            };
+            Output.println("{s}", .{username});
+            Global.exit(0);
         } else if (strings.eqlComptime(subcommand, "bin")) {
             const output_path = Path.joinAbs(Fs.FileSystem.instance.top_level_dir, .auto, bun.asByteSlice(pm.options.bin_path));
             Output.prettyln("{s}", .{output_path});
@@ -374,7 +393,7 @@ pub const PackageManagerCommand = struct {
             }
             handleLoadLockfileErrors(load_lockfile, pm);
             const lockfile = load_lockfile.ok.lockfile;
-            lockfile.saveToDisk(pm.options.lockfile_path);
+            lockfile.saveToDisk(pm.options.lockfile_path, pm.options.log_level.isVerbose());
             Global.exit(0);
         }
 
diff --git a/src/cli/pm_trusted_command.zig b/src/cli/pm_trusted_command.zig
index 159aad49b8..4528ce8bfa 100644
--- a/src/cli/pm_trusted_command.zig
+++ b/src/cli/pm_trusted_command.zig
@@ -344,8 +344,15 @@ pub const TrustCommand = struct {
                     }
 
                     const output_in_foreground = false;
+                    const optional = false;
                     switch (pm.options.log_level) {
-                        inline else => |log_level| try pm.spawnPackageLifecycleScripts(ctx, info.scripts_list, log_level, output_in_foreground),
+                        inline else => |log_level| try pm.spawnPackageLifecycleScripts(
+                            ctx,
+                            info.scripts_list,
+                            optional,
+                            log_level,
+                            output_in_foreground,
+                        ),
                     }
 
                     if (pm.options.log_level.showProgress()) {
@@ -370,10 +377,8 @@ pub const TrustCommand = struct {
 
         const package_json_source = logger.Source.initPathString(PackageManager.package_json_cwd, package_json_contents);
 
-        var package_json = bun.JSON.ParseJSONUTF8(&package_json_source, ctx.log, ctx.allocator) catch |err| {
-            switch (Output.enable_ansi_colors) {
-                inline else => |enable_ansi_colors| ctx.log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), enable_ansi_colors) catch {},
-            }
+        var package_json = bun.JSON.parseUTF8(&package_json_source, ctx.log, ctx.allocator) catch |err| {
+            ctx.log.print(Output.errorWriter()) catch {};
 
             Output.errGeneric("failed to parse package.json: {s}", .{@errorName(err)});
             Global.crash();
@@ -418,7 +423,7 @@ pub const TrustCommand = struct {
             try pm.lockfile.trusted_dependencies.?.put(ctx.allocator, @truncate(String.Builder.stringHash(name)), {});
         }
 
-        pm.lockfile.saveToDisk(pm.options.lockfile_path);
+        pm.lockfile.saveToDisk(pm.options.lockfile_path, pm.options.log_level.isVerbose());
 
         var buffer_writer = try bun.js_printer.BufferWriter.init(ctx.allocator);
         try buffer_writer.buffer.list.ensureTotalCapacity(ctx.allocator, package_json_contents.len + 1);
diff --git a/src/cli/publish_command.zig b/src/cli/publish_command.zig
new file mode 100644
index 0000000000..466f7ef488
--- /dev/null
+++ b/src/cli/publish_command.zig
@@ -0,0 +1,1384 @@
+const std = @import("std");
+const bun = @import("root").bun;
+const Command = bun.CLI.Command;
+const Output = bun.Output;
+const Global = bun.Global;
+const http = bun.http;
+const OOM = bun.OOM;
+const Headers = http.Headers;
+const HeaderBuilder = http.HeaderBuilder;
+const MutableString = bun.MutableString;
+const URL = bun.URL;
+const install = bun.install;
+const PackageManager = install.PackageManager;
+const strings = bun.strings;
+const string = bun.string;
+const stringZ = bun.stringZ;
+const File = bun.sys.File;
+const JSON = bun.JSON;
+const sha = bun.sha;
+const path = bun.path;
+const FileSystem = bun.fs.FileSystem;
+const Environment = bun.Environment;
+const Archive = bun.libarchive.lib.Archive;
+const logger = bun.logger;
+const Dependency = install.Dependency;
+const Pack = bun.CLI.PackCommand;
+const Lockfile = install.Lockfile;
+const MimeType = http.MimeType;
+const Expr = bun.js_parser.Expr;
+const prompt = bun.CLI.InitCommand.prompt;
+const Npm = install.Npm;
+const Run = bun.CLI.RunCommand;
+const DotEnv = bun.DotEnv;
+const Open = @import("../open.zig");
+const E = bun.JSAst.E;
+const G = bun.JSAst.G;
+const BabyList = bun.BabyList;
+
+pub const PublishCommand = struct {
+    pub fn Context(comptime directory_publish: bool) type {
+        return struct {
+            manager: *PackageManager,
+            allocator: std.mem.Allocator,
+            command_ctx: Command.Context,
+
+            package_name: string,
+            package_version: string,
+            abs_tarball_path: stringZ,
+            tarball_bytes: string,
+            shasum: sha.SHA1.Digest,
+            integrity: sha.SHA512.Digest,
+            uses_workspaces: bool,
+
+            normalized_pkg_info: string,
+
+            publish_script: if (directory_publish) ?[]const u8 else void = if (directory_publish) null else {},
+            postpublish_script: if (directory_publish) ?[]const u8 else void = if (directory_publish) null else {},
+            script_env: if (directory_publish) *DotEnv.Loader else void,
+
+            const FromTarballError = OOM || error{
+                MissingPackageJSON,
+                InvalidPackageJSON,
+                MissingPackageName,
+                MissingPackageVersion,
+                InvalidPackageName,
+                InvalidPackageVersion,
+                PrivatePackage,
+                RestrictedUnscopedPackage,
+            };
+
+            /// Retrieve information for publishing from a tarball path, `bun publish path/to/tarball.tgz`
+            pub fn fromTarballPath(
+                ctx: Command.Context,
+                manager: *PackageManager,
+                tarball_path: string,
+            ) FromTarballError!Context(directory_publish) {
+                var abs_buf: bun.PathBuffer = undefined;
+                const abs_tarball_path = path.joinAbsStringBufZ(
+                    FileSystem.instance.top_level_dir,
+                    &abs_buf,
+                    &[_]string{tarball_path},
+                    .auto,
+                );
+
+                const tarball_bytes = File.readFrom(bun.invalid_fd, abs_tarball_path, ctx.allocator).unwrap() catch |err| {
+                    Output.err(err, "failed to read tarball: '{s}'", .{tarball_path});
+                    Global.crash();
+                };
+
+                var maybe_package_json_contents: ?[]const u8 = null;
+
+                var iter = switch (Archive.Iterator.init(tarball_bytes)) {
+                    .err => |err| {
+                        Output.errGeneric("{s}: {s}", .{
+                            err.message,
+                            err.archive.errorString(),
+                        });
+
+                        Global.crash();
+                    },
+                    .result => |res| res,
+                };
+
+                var unpacked_size: usize = 0;
+                var total_files: usize = 0;
+
+                Output.print("\n", .{});
+
+                while (switch (iter.next()) {
+                    .err => |err| {
+                        Output.errGeneric("{s}: {s}", .{ err.message, err.archive.errorString() });
+                        Global.crash();
+                    },
+                    .result => |res| res,
+                }) |next| {
+                    const pathname = if (comptime Environment.isWindows)
+                        next.entry.pathnameW()
+                    else
+                        next.entry.pathname();
+
+                    const size = next.entry.size();
+
+                    unpacked_size += @intCast(@max(0, size));
+                    total_files += @intFromBool(next.kind == .file);
+
+                    // this is option `strip: 1` (npm expects a `package/` prefix for all paths)
+                    if (strings.indexOfAnyT(bun.OSPathChar, pathname, "/\\")) |slash| {
+                        const stripped = pathname[slash + 1 ..];
+                        if (stripped.len == 0) continue;
+
+                        Output.pretty("<b><cyan>packed<r> {} {}\n", .{
+                            bun.fmt.size(size, .{ .space_between_number_and_unit = false }),
+                            bun.fmt.fmtOSPath(stripped, .{}),
+                        });
+
+                        if (next.kind != .file) continue;
+
+                        if (strings.indexOfAnyT(bun.OSPathChar, stripped, "/\\") == null) {
+
+                            // check for package.json, readme.md, ...
+                            const filename = pathname[slash + 1 ..];
+
+                            if (maybe_package_json_contents == null and strings.eqlCaseInsensitiveT(bun.OSPathChar, filename, "package.json")) {
+                                maybe_package_json_contents = switch (try next.readEntryData(ctx.allocator, iter.archive)) {
+                                    .err => |err| {
+                                        Output.errGeneric("{s}: {s}", .{ err.message, err.archive.errorString() });
+                                        Global.crash();
+                                    },
+                                    .result => |bytes| bytes,
+                                };
+                            }
+                        }
+                    } else {
+                        Output.pretty("<b><cyan>packed<r> {} {}\n", .{
+                            bun.fmt.size(size, .{ .space_between_number_and_unit = false }),
+                            bun.fmt.fmtOSPath(pathname, .{}),
+                        });
+                    }
+                }
+
+                switch (iter.deinit()) {
+                    .err => |err| {
+                        Output.errGeneric("{s}: {s}", .{ err.message, err.archive.errorString() });
+                        Global.crash();
+                    },
+                    .result => {},
+                }
+
+                const package_json_contents = maybe_package_json_contents orelse return error.MissingPackageJSON;
+
+                const package_name, const package_version, var json, const json_source = package_info: {
+                    const source = logger.Source.initPathString("package.json", package_json_contents);
+                    const json = JSON.parsePackageJSONUTF8(&source, manager.log, ctx.allocator) catch |err| {
+                        return switch (err) {
+                            error.OutOfMemory => |oom| return oom,
+                            else => error.InvalidPackageJSON,
+                        };
+                    };
+
+                    if (json.get("private")) |private| {
+                        if (private.asBool()) |is_private| {
+                            if (is_private) {
+                                return error.PrivatePackage;
+                            }
+                        }
+                    }
+
+                    if (json.get("publishConfig")) |config| {
+                        if (manager.options.publish_config.tag.len == 0) {
+                            if (try config.getStringCloned(ctx.allocator, "tag")) |tag| {
+                                manager.options.publish_config.tag = tag;
+                            }
+                        }
+
+                        if (manager.options.publish_config.access == null) {
+                            if (try config.getString(ctx.allocator, "access")) |access| {
+                                manager.options.publish_config.access = PackageManager.Options.Access.fromStr(access[0]) orelse {
+                                    Output.errGeneric("invalid `access` value: '{s}'", .{access[0]});
+                                    Global.crash();
+                                };
+                            }
+                        }
+
+                        // maybe otp
+                    }
+
+                    const name = try json.getStringCloned(ctx.allocator, "name") orelse return error.MissingPackageName;
+                    const is_scoped = try Dependency.isScopedPackageName(name);
+
+                    if (manager.options.publish_config.access) |access| {
+                        if (access == .restricted and !is_scoped) {
+                            return error.RestrictedUnscopedPackage;
+                        }
+                    }
+
+                    const version = try json.getStringCloned(ctx.allocator, "version") orelse return error.MissingPackageVersion;
+                    if (version.len == 0) return error.InvalidPackageVersion;
+
+                    break :package_info .{ name, version, json, source };
+                };
+
+                var shasum: sha.SHA1.Digest = undefined;
+                var sha1 = sha.SHA1.init();
+                defer sha1.deinit();
+
+                sha1.update(tarball_bytes);
+                sha1.final(&shasum);
+
+                var integrity: sha.SHA512.Digest = undefined;
+                var sha512 = sha.SHA512.init();
+                defer sha512.deinit();
+
+                sha512.update(tarball_bytes);
+                sha512.final(&integrity);
+
+                const normalized_pkg_info = try normalizedPackage(
+                    ctx.allocator,
+                    manager,
+                    package_name,
+                    package_version,
+                    &json,
+                    json_source,
+                    shasum,
+                    integrity,
+                    abs_tarball_path,
+                );
+
+                Pack.Context.printSummary(
+                    .{
+                        .total_files = total_files,
+                        .unpacked_size = unpacked_size,
+                        .packed_size = tarball_bytes.len,
+                    },
+                    shasum,
+                    integrity,
+                    manager.options.log_level,
+                );
+
+                return .{
+                    .manager = manager,
+                    .allocator = ctx.allocator,
+                    .package_name = package_name,
+                    .package_version = package_version,
+                    .abs_tarball_path = try ctx.allocator.dupeZ(u8, abs_tarball_path),
+                    .tarball_bytes = tarball_bytes,
+                    .shasum = shasum,
+                    .integrity = integrity,
+                    .uses_workspaces = false,
+                    .command_ctx = ctx,
+                    .script_env = {},
+                    .normalized_pkg_info = normalized_pkg_info,
+                };
+            }
+
+            const FromWorkspaceError = Pack.PackError(true);
+
+            /// `bun publish` without a tarball path. Automatically pack the current workspace and get
+            /// information required for publishing
+            pub fn fromWorkspace(
+                ctx: Command.Context,
+                manager: *PackageManager,
+            ) FromWorkspaceError!Context(directory_publish) {
+                var lockfile: Lockfile = undefined;
+                const load_from_disk_result = lockfile.loadFromDisk(
+                    manager,
+                    manager.allocator,
+                    manager.log,
+                    manager.options.lockfile_path,
+                    false,
+                );
+
+                var pack_ctx: Pack.Context = .{
+                    .allocator = ctx.allocator,
+                    .manager = manager,
+                    .command_ctx = ctx,
+                    .lockfile = switch (load_from_disk_result) {
+                        .ok => |ok| ok.lockfile,
+                        .not_found => null,
+                        .err => |cause| err: {
+                            switch (cause.step) {
+                                .open_file => {
+                                    if (cause.value == error.ENOENT) break :err null;
+                                    Output.errGeneric("failed to open lockfile: {s}", .{@errorName(cause.value)});
+                                },
+                                .parse_file => {
+                                    Output.errGeneric("failed to parse lockfile: {s}", .{@errorName(cause.value)});
+                                },
+                                .read_file => {
+                                    Output.errGeneric("failed to read lockfile: {s}", .{@errorName(cause.value)});
+                                },
+                                .migrating => {
+                                    Output.errGeneric("failed to migrate lockfile: {s}", .{@errorName(cause.value)});
+                                },
+                            }
+
+                            if (manager.log.hasErrors()) {
+                                manager.log.print(Output.errorWriter()) catch {};
+                            }
+
+                            Global.crash();
+                        },
+                    },
+                };
+
+                return switch (manager.options.log_level) {
+                    inline else => |log_level| Pack.pack(&pack_ctx, manager.original_package_json_path, log_level, true),
+                };
+            }
+        };
+    }
+
+    pub fn exec(ctx: Command.Context) !void {
+        Output.prettyln("<r><b>bun publish <r><d>v" ++ Global.package_json_version_with_sha ++ "<r>", .{});
+        Output.flush();
+
+        const cli = try PackageManager.CommandLineArguments.parse(ctx.allocator, .publish);
+
+        const manager, const original_cwd = PackageManager.init(ctx, cli, .publish) catch |err| {
+            if (!cli.silent) {
+                if (err == error.MissingPackageJSON) {
+                    Output.errGeneric("missing package.json, nothing to publish", .{});
+                }
+                Output.errGeneric("failed to initialize bun install: {s}", .{@errorName(err)});
+            }
+            Global.crash();
+        };
+        defer ctx.allocator.free(original_cwd);
+
+        if (cli.positionals.len > 1) {
+            const context = Context(false).fromTarballPath(ctx, manager, cli.positionals[1]) catch |err| {
+                switch (err) {
+                    error.OutOfMemory => bun.outOfMemory(),
+                    error.MissingPackageName => {
+                        Output.errGeneric("missing `name` string in package.json", .{});
+                    },
+                    error.MissingPackageVersion => {
+                        Output.errGeneric("missing `version` string in package.json", .{});
+                    },
+                    error.InvalidPackageName, error.InvalidPackageVersion => {
+                        Output.errGeneric("package.json `name` and `version` fields must be non-empty strings", .{});
+                    },
+                    error.MissingPackageJSON => {
+                        Output.errGeneric("failed to find package.json in tarball '{s}'", .{cli.positionals[1]});
+                    },
+                    error.InvalidPackageJSON => {
+                        manager.log.print(Output.errorWriter()) catch {};
+                        Output.errGeneric("failed to parse tarball package.json", .{});
+                    },
+                    error.PrivatePackage => {
+                        Output.errGeneric("attempted to publish a private package", .{});
+                    },
+                    error.RestrictedUnscopedPackage => {
+                        Output.errGeneric("unable to restrict access to unscoped package", .{});
+                    },
+                }
+                Global.crash();
+            };
+
+            publish(false, &context) catch |err| {
+                switch (err) {
+                    error.OutOfMemory => bun.outOfMemory(),
+                    error.NeedAuth => {
+                        Output.errGeneric("missing authentication (run <cyan>`bunx npm login`<r>)", .{});
+                        Global.crash();
+                    },
+                }
+            };
+
+            Output.prettyln("\n<green> +<r> {s}@{s}{s}", .{
+                context.package_name,
+                Dependency.withoutBuildTag(context.package_version),
+                if (manager.options.dry_run) " (dry-run)" else "",
+            });
+
+            return;
+        }
+
+        const context = Context(true).fromWorkspace(ctx, manager) catch |err| {
+            switch (err) {
+                error.OutOfMemory => bun.outOfMemory(),
+                error.MissingPackageName => {
+                    Output.errGeneric("missing `name` string in package.json", .{});
+                },
+                error.MissingPackageVersion => {
+                    Output.errGeneric("missing `version` string in package.json", .{});
+                },
+                error.InvalidPackageName, error.InvalidPackageVersion => {
+                    Output.errGeneric("package.json `name` and `version` fields must be non-empty strings", .{});
+                },
+                error.MissingPackageJSON => {
+                    Output.errGeneric("failed to find package.json from: '{s}'", .{FileSystem.instance.top_level_dir});
+                },
+                error.RestrictedUnscopedPackage => {
+                    Output.errGeneric("unable to restrict access to unscoped package", .{});
+                },
+                error.PrivatePackage => {
+                    Output.errGeneric("attempted to publish a private package", .{});
+                },
+            }
+            Global.crash();
+        };
+
+        // TODO: read this into memory
+        _ = bun.sys.unlink(context.abs_tarball_path);
+
+        publish(true, &context) catch |err| {
+            switch (err) {
+                error.OutOfMemory => bun.outOfMemory(),
+                error.NeedAuth => {
+                    Output.errGeneric("missing authentication (run <cyan>`bunx npm login`<r>)", .{});
+                    Global.crash();
+                },
+            }
+        };
+
+        Output.prettyln("\n<green> +<r> {s}@{s}{s}", .{
+            context.package_name,
+            Dependency.withoutBuildTag(context.package_version),
+            if (manager.options.dry_run) " (dry-run)" else "",
+        });
+
+        if (manager.options.do.run_scripts) {
+            const abs_workspace_path: string = strings.withoutTrailingSlash(strings.withoutSuffixComptime(manager.original_package_json_path, "package.json"));
+            try context.script_env.map.put("npm_command", "publish");
+
+            if (context.publish_script) |publish_script| {
+                _ = Run.runPackageScriptForeground(
+                    context.command_ctx,
+                    context.allocator,
+                    publish_script,
+                    "publish",
+                    abs_workspace_path,
+                    context.script_env,
+                    &.{},
+                    context.manager.options.log_level == .silent,
+                    context.command_ctx.debug.use_system_shell,
+                ) catch |err| {
+                    switch (err) {
+                        error.MissingShell => {
+                            Output.errGeneric("failed to find shell executable to run publish script", .{});
+                            Global.crash();
+                        },
+                        error.OutOfMemory => |oom| return oom,
+                    }
+                };
+            }
+
+            if (context.postpublish_script) |postpublish_script| {
+                _ = Run.runPackageScriptForeground(
+                    context.command_ctx,
+                    context.allocator,
+                    postpublish_script,
+                    "postpublish",
+                    abs_workspace_path,
+                    context.script_env,
+                    &.{},
+                    context.manager.options.log_level == .silent,
+                    context.command_ctx.debug.use_system_shell,
+                ) catch |err| {
+                    switch (err) {
+                        error.MissingShell => {
+                            Output.errGeneric("failed to find shell executable to run postpublish script", .{});
+                            Global.crash();
+                        },
+                        error.OutOfMemory => |oom| return oom,
+                    }
+                };
+            }
+        }
+    }
+
+    const PublishError = OOM || error{
+        NeedAuth,
+    };
+
+    pub fn publish(
+        comptime directory_publish: bool,
+        ctx: *const Context(directory_publish),
+    ) PublishError!void {
+        const registry = ctx.manager.scopeForPackageName(ctx.package_name);
+
+        if (registry.token.len == 0 and (registry.url.password.len == 0 or registry.url.username.len == 0)) {
+            return error.NeedAuth;
+        }
+
+        // continues from `printSummary`
+        Output.pretty(
+            \\<b><blue>Tag<r>: {s}
+            \\<b><blue>Access<r>: {s}
+            \\<b><blue>Registry<r>: {s}
+            \\
+        , .{
+            if (ctx.manager.options.publish_config.tag.len > 0) ctx.manager.options.publish_config.tag else "latest",
+            if (ctx.manager.options.publish_config.access) |access| @tagName(access) else "default",
+            registry.url.href,
+        });
+
+        // dry-run stops here
+        if (ctx.manager.options.dry_run) return;
+
+        const publish_req_body = try constructPublishRequestBody(directory_publish, ctx);
+
+        var print_buf: std.ArrayListUnmanaged(u8) = .{};
+        defer print_buf.deinit(ctx.allocator);
+        var print_writer = print_buf.writer(ctx.allocator);
+
+        const publish_headers = try constructPublishHeaders(
+            ctx.allocator,
+            &print_buf,
+            registry,
+            publish_req_body.len,
+            if (ctx.manager.options.publish_config.otp.len > 0) ctx.manager.options.publish_config.otp else null,
+            ctx.uses_workspaces,
+            ctx.manager.options.publish_config.auth_type,
+        );
+
+        var response_buf = try MutableString.init(ctx.allocator, 1024);
+
+        try print_writer.print("{s}/{s}", .{
+            strings.withoutTrailingSlash(registry.url.href),
+            bun.fmt.dependencyUrl(ctx.package_name),
+        });
+        const publish_url = URL.parse(try ctx.allocator.dupe(u8, print_buf.items));
+        print_buf.clearRetainingCapacity();
+
+        var req = http.AsyncHTTP.initSync(
+            ctx.allocator,
+            .PUT,
+            publish_url,
+            publish_headers.entries,
+            publish_headers.content.ptr.?[0..publish_headers.content.len],
+            &response_buf,
+            publish_req_body,
+            null,
+            null,
+            .follow,
+        );
+
+        const res = req.sendSync() catch |err| {
+            switch (err) {
+                error.OutOfMemory => |oom| return oom,
+                else => {
+                    Output.err(err, "failed to publish package", .{});
+                    Global.crash();
+                },
+            }
+        };
+
+        switch (res.status_code) {
+            400...std.math.maxInt(@TypeOf(res.status_code)) => {
+                const prompt_for_otp = prompt_for_otp: {
+                    if (res.status_code != 401) break :prompt_for_otp false;
+
+                    if (res.headers.get("www-authenticate")) |@"www-authenticate"| {
+                        var iter = strings.split(@"www-authenticate", ",");
+                        while (iter.next()) |part| {
+                            const trimmed = strings.trim(part, &strings.whitespace_chars);
+                            if (strings.eqlCaseInsensitiveASCII(trimmed, "ipaddress", true)) {
+                                Output.errGeneric("login is not allowed from your IP address", .{});
+                                Global.crash();
+                            } else if (strings.eqlCaseInsensitiveASCII(trimmed, "otp", true)) {
+                                break :prompt_for_otp true;
+                            }
+                        }
+
+                        Output.errGeneric("unable to authenticate, need: {s}", .{@"www-authenticate"});
+                        Global.crash();
+                    } else if (strings.containsComptime(response_buf.list.items, "one-time pass")) {
+                        // missing www-authenicate header but one-time pass is still included
+                        break :prompt_for_otp true;
+                    }
+
+                    break :prompt_for_otp false;
+                };
+
+                if (!prompt_for_otp) {
+                    // general error
+                    const otp_response = false;
+                    try Npm.responseError(
+                        ctx.allocator,
+                        &req,
+                        &res,
+                        .{ ctx.package_name, ctx.package_version },
+                        &response_buf,
+                        otp_response,
+                    );
+                }
+
+                // https://github.com/npm/cli/blob/534ad7789e5c61f579f44d782bdd18ea3ff1ee20/node_modules/npm-registry-fetch/lib/check-response.js#L14
+                // ignore if x-local-cache exists
+                if (res.headers.getIfOtherIsAbsent("npm-notice", "x-local-cache")) |notice| {
+                    Output.printError("\n", .{});
+                    Output.note("{s}", .{notice});
+                    Output.flush();
+                }
+
+                const otp = try getOTP(directory_publish, ctx, registry, &response_buf, &print_buf);
+
+                const otp_headers = try constructPublishHeaders(
+                    ctx.allocator,
+                    &print_buf,
+                    registry,
+                    publish_req_body.len,
+                    otp,
+                    ctx.uses_workspaces,
+                    ctx.manager.options.publish_config.auth_type,
+                );
+
+                response_buf.reset();
+
+                var otp_req = http.AsyncHTTP.initSync(
+                    ctx.allocator,
+                    .PUT,
+                    publish_url,
+                    otp_headers.entries,
+                    otp_headers.content.ptr.?[0..otp_headers.content.len],
+                    &response_buf,
+                    publish_req_body,
+                    null,
+                    null,
+                    .follow,
+                );
+
+                const otp_res = otp_req.sendSync() catch |err| {
+                    switch (err) {
+                        error.OutOfMemory => |oom| return oom,
+                        else => {
+                            Output.err(err, "failed to publish package", .{});
+                            Global.crash();
+                        },
+                    }
+                };
+
+                switch (otp_res.status_code) {
+                    400...std.math.maxInt(@TypeOf(otp_res.status_code)) => {
+                        const otp_response = true;
+                        try Npm.responseError(
+                            ctx.allocator,
+                            &otp_req,
+                            &otp_res,
+                            .{ ctx.package_name, ctx.package_version },
+                            &response_buf,
+                            otp_response,
+                        );
+                    },
+                    else => {
+                        // https://github.com/npm/cli/blob/534ad7789e5c61f579f44d782bdd18ea3ff1ee20/node_modules/npm-registry-fetch/lib/check-response.js#L14
+                        // ignore if x-local-cache exists
+                        if (otp_res.headers.getIfOtherIsAbsent("npm-notice", "x-local-cache")) |notice| {
+                            Output.printError("\n", .{});
+                            Output.note("{s}", .{notice});
+                            Output.flush();
+                        }
+                    },
+                }
+            },
+            else => {},
+        }
+    }
+
+    const GetOTPError = OOM || error{};
+
+    fn pressEnterToOpenInBrowser(auth_url: stringZ) void {
+        // unset `ENABLE_VIRTUAL_TERMINAL_INPUT` on windows. This prevents backspace from
+        // deleting the entire line
+        const original_mode: if (Environment.isWindows) ?bun.windows.DWORD else void = if (comptime Environment.isWindows)
+            bun.win32.unsetStdioModeFlags(0, bun.windows.ENABLE_VIRTUAL_TERMINAL_INPUT) catch null
+        else {};
+
+        defer if (comptime Environment.isWindows) {
+            if (original_mode) |mode| {
+                _ = bun.windows.SetConsoleMode(bun.win32.STDIN_FD.cast(), mode);
+            }
+        };
+
+        while ('\n' != Output.buffered_stdin.reader().readByte() catch return) {}
+
+        var child = std.process.Child.init(&.{ Open.opener, auth_url }, bun.default_allocator);
+        _ = child.spawnAndWait() catch return;
+    }
+
+    fn getOTP(
+        comptime directory_publish: bool,
+        ctx: *const Context(directory_publish),
+        registry: *const Npm.Registry.Scope,
+        response_buf: *MutableString,
+        print_buf: *std.ArrayListUnmanaged(u8),
+    ) GetOTPError![]const u8 {
+        const res_source = logger.Source.initPathString("???", response_buf.list.items);
+
+        if (JSON.parseUTF8(&res_source, ctx.manager.log, ctx.allocator) catch |err| res_json: {
+            switch (err) {
+                error.OutOfMemory => |oom| return oom,
+
+                // https://github.com/npm/cli/blob/63d6a732c3c0e9c19fd4d147eaa5cc27c29b168d/node_modules/npm-registry-fetch/lib/check-response.js#L65
+                // invalid json is ignored
+                else => break :res_json null,
+            }
+        }) |json| try_web: {
+            const auth_url_str = try json.getStringClonedZ(ctx.allocator, "authUrl") orelse break :try_web;
+
+            // important to clone because it belongs to `response_buf`, and `response_buf` will be
+            // reused with the following requests
+            const done_url_str = try json.getStringCloned(ctx.allocator, "doneUrl") orelse break :try_web;
+            const done_url = URL.parse(done_url_str);
+
+            Output.prettyln("\nAuthenticate your account at (press <b>ENTER<r> to open in browser):\n", .{});
+
+            const offset = 0;
+            const padding = 1;
+
+            const horizontal = if (Output.enable_ansi_colors) "─" else "-";
+            const vertical = if (Output.enable_ansi_colors) "│" else "|";
+            const top_left = if (Output.enable_ansi_colors) "┌" else "|";
+            const top_right = if (Output.enable_ansi_colors) "┐" else "|";
+            const bottom_left = if (Output.enable_ansi_colors) "└" else "|";
+            const bottom_right = if (Output.enable_ansi_colors) "┘" else "|";
+
+            const width = (padding * 2) + auth_url_str.len;
+
+            for (0..offset) |_| Output.print(" ", .{});
+            Output.print("{s}", .{top_left});
+            for (0..width) |_| Output.print("{s}", .{horizontal});
+            Output.println("{s}", .{top_right});
+
+            for (0..offset) |_| Output.print(" ", .{});
+            Output.print("{s}", .{vertical});
+            for (0..padding) |_| Output.print(" ", .{});
+            Output.pretty("<b>{s}<r>", .{auth_url_str});
+            for (0..padding) |_| Output.print(" ", .{});
+            Output.println("{s}", .{vertical});
+
+            for (0..offset) |_| Output.print(" ", .{});
+            Output.print("{s}", .{bottom_left});
+            for (0..width) |_| Output.print("{s}", .{horizontal});
+            Output.println("{s}", .{bottom_right});
+            Output.flush();
+
+            // on another thread because pressing enter is not required
+            (std.Thread.spawn(.{}, pressEnterToOpenInBrowser, .{auth_url_str}) catch |err| {
+                Output.err(err, "failed to spawn thread for opening auth url", .{});
+                Global.crash();
+            }).detach();
+
+            var auth_headers = try constructPublishHeaders(
+                ctx.allocator,
+                print_buf,
+                registry,
+                null,
+                null,
+                ctx.uses_workspaces,
+                ctx.manager.options.publish_config.auth_type,
+            );
+
+            while (true) {
+                response_buf.reset();
+
+                var req = http.AsyncHTTP.initSync(
+                    ctx.allocator,
+                    .GET,
+                    done_url,
+                    auth_headers.entries,
+                    auth_headers.content.ptr.?[0..auth_headers.content.len],
+                    response_buf,
+                    "",
+                    null,
+                    null,
+                    .follow,
+                );
+
+                const res = req.sendSync() catch |err| {
+                    switch (err) {
+                        error.OutOfMemory => |oom| return oom,
+                        else => {
+                            Output.err(err, "failed to send OTP request", .{});
+                            Global.crash();
+                        },
+                    }
+                };
+
+                switch (res.status_code) {
+                    202 => {
+                        // retry
+                        const nanoseconds = nanoseconds: {
+                            if (res.headers.get("retry-after")) |retry| default: {
+                                const trimmed = strings.trim(retry, &strings.whitespace_chars);
+                                const seconds = bun.fmt.parseInt(u32, trimmed, 10) catch break :default;
+                                break :nanoseconds seconds * std.time.ns_per_s;
+                            }
+
+                            break :nanoseconds 500 * std.time.ns_per_ms;
+                        };
+
+                        std.time.sleep(nanoseconds);
+                        continue;
+                    },
+                    200 => {
+                        // login successful
+                        const otp_done_source = logger.Source.initPathString("???", response_buf.list.items);
+                        const otp_done_json = JSON.parseUTF8(&otp_done_source, ctx.manager.log, ctx.allocator) catch |err| {
+                            switch (err) {
+                                error.OutOfMemory => |oom| return oom,
+                                else => {
+                                    Output.err("WebLogin", "failed to parse response json", .{});
+                                    Global.crash();
+                                },
+                            }
+                        };
+
+                        const token = try otp_done_json.getStringCloned(ctx.allocator, "token") orelse {
+                            Output.err("WebLogin", "missing `token` field in reponse json", .{});
+                            Global.crash();
+                        };
+
+                        // https://github.com/npm/cli/blob/534ad7789e5c61f579f44d782bdd18ea3ff1ee20/node_modules/npm-registry-fetch/lib/check-response.js#L14
+                        // ignore if x-local-cache exists
+                        if (res.headers.getIfOtherIsAbsent("npm-notice", "x-local-cache")) |notice| {
+                            Output.printError("\n", .{});
+                            Output.note("{s}", .{notice});
+                            Output.flush();
+                        }
+
+                        return token;
+                    },
+                    else => {
+                        const otp_response = false;
+                        try Npm.responseError(
+                            ctx.allocator,
+                            &req,
+                            &res,
+                            .{ ctx.package_name, ctx.package_version },
+                            response_buf,
+                            otp_response,
+                        );
+                    },
+                }
+            }
+        }
+
+        // classic
+        return prompt(ctx.allocator, "\nThis operation requires a one-time password.\nEnter OTP: ", "") catch |err| {
+            switch (err) {
+                error.OutOfMemory => |oom| return oom,
+                else => {
+                    Output.err(err, "failed to read OTP input", .{});
+                    Global.crash();
+                },
+            }
+        };
+    }
+
+    pub fn normalizedPackage(
+        allocator: std.mem.Allocator,
+        manager: *PackageManager,
+        package_name: string,
+        package_version: string,
+        json: *Expr,
+        json_source: logger.Source,
+        shasum: sha.SHA1.Digest,
+        integrity: sha.SHA512.Digest,
+        abs_tarball_path: stringZ,
+    ) OOM!string {
+        bun.assertWithLocation(json.isObject(), @src());
+
+        const registry = manager.scopeForPackageName(package_name);
+
+        const version_without_build_tag = Dependency.withoutBuildTag(package_version);
+
+        const integrity_fmt = try std.fmt.allocPrint(allocator, "{}", .{bun.fmt.integrity(integrity, .full)});
+
+        try json.setString(allocator, "_id", try std.fmt.allocPrint(allocator, "{s}@{s}", .{ package_name, version_without_build_tag }));
+        try json.setString(allocator, "_integrity", integrity_fmt);
+        try json.setString(allocator, "_nodeVersion", Environment.reported_nodejs_version);
+        // TODO: npm version
+        try json.setString(allocator, "_npmVersion", "10.8.3");
+        try json.setString(allocator, "integrity", integrity_fmt);
+        try json.setString(allocator, "shasum", try std.fmt.allocPrint(allocator, "{s}", .{bun.fmt.bytesToHex(shasum, .lower)}));
+
+        var dist_props = try allocator.alloc(G.Property, 3);
+        dist_props[0] = .{
+            .key = Expr.init(
+                E.String,
+                .{ .data = "integrity" },
+                logger.Loc.Empty,
+            ),
+            .value = Expr.init(
+                E.String,
+                .{ .data = try std.fmt.allocPrint(allocator, "{}", .{bun.fmt.integrity(integrity, .full)}) },
+                logger.Loc.Empty,
+            ),
+        };
+        dist_props[1] = .{
+            .key = Expr.init(
+                E.String,
+                .{ .data = "shasum" },
+                logger.Loc.Empty,
+            ),
+            .value = Expr.init(
+                E.String,
+                .{ .data = try std.fmt.allocPrint(allocator, "{s}", .{bun.fmt.bytesToHex(shasum, .lower)}) },
+                logger.Loc.Empty,
+            ),
+        };
+        dist_props[2] = .{
+            .key = Expr.init(
+                E.String,
+                .{ .data = "tarball" },
+                logger.Loc.Empty,
+            ),
+            .value = Expr.init(
+                E.String,
+                .{
+                    .data = try bun.fmt.allocPrint(allocator, "http://{s}/{s}/-/{s}", .{
+                        strings.withoutTrailingSlash(registry.url.href),
+                        package_name,
+                        std.fs.path.basename(abs_tarball_path),
+                    }),
+                },
+                logger.Loc.Empty,
+            ),
+        };
+
+        try json.set(allocator, "dist", Expr.init(
+            E.Object,
+            .{ .properties = G.Property.List.init(dist_props) },
+            logger.Loc.Empty,
+        ));
+
+        {
+            const workspace_root = bun.sys.openA(
+                strings.withoutSuffixComptime(manager.original_package_json_path, "package.json"),
+                bun.O.DIRECTORY,
+                0,
+            ).unwrap() catch |err| {
+                Output.err(err, "failed to open workspace directory", .{});
+                Global.crash();
+            };
+            defer _ = bun.sys.close(workspace_root);
+
+            try normalizeBin(
+                allocator,
+                json,
+                package_name,
+                workspace_root,
+            );
+        }
+
+        const buffer_writer = try bun.js_printer.BufferWriter.init(allocator);
+        var writer = bun.js_printer.BufferPrinter.init(buffer_writer);
+
+        const written = bun.js_printer.printJSON(
+            @TypeOf(&writer),
+            &writer,
+            json.*,
+            &json_source,
+            .{
+                .minify_whitespace = true,
+            },
+        ) catch |err| {
+            switch (err) {
+                error.OutOfMemory => |oom| return oom,
+                else => {
+                    Output.errGeneric("failed to print normalized package.json: {s}", .{@errorName(err)});
+                    Global.crash();
+                },
+            }
+        };
+        _ = written;
+
+        return writer.ctx.writtenWithoutTrailingZero();
+    }
+
+    fn normalizeBin(
+        allocator: std.mem.Allocator,
+        json: *Expr,
+        package_name: string,
+        workspace_root: bun.FileDescriptor,
+    ) OOM!void {
+        var path_buf: bun.PathBuffer = undefined;
+        if (json.asProperty("bin")) |bin_query| {
+            switch (bin_query.expr.data) {
+                .e_string => |bin_str| {
+                    var bin_props = std.ArrayList(G.Property).init(allocator);
+                    const normalized = strings.withoutPrefixComptimeZ(
+                        path.normalizeBufZ(
+                            try bin_str.string(allocator),
+                            &path_buf,
+                            .posix,
+                        ),
+                        "./",
+                    );
+                    if (!bun.sys.existsAt(workspace_root, normalized)) {
+                        Output.warn("bin '{s}' does not exist", .{normalized});
+                    }
+
+                    try bin_props.append(.{
+                        .key = Expr.init(
+                            E.String,
+                            .{ .data = package_name },
+                            logger.Loc.Empty,
+                        ),
+                        .value = Expr.init(
+                            E.String,
+                            .{ .data = try allocator.dupe(u8, normalized) },
+                            logger.Loc.Empty,
+                        ),
+                    });
+
+                    json.data.e_object.properties.ptr[bin_query.i].value = Expr.init(
+                        E.Object,
+                        .{
+                            .properties = G.Property.List.fromList(bin_props),
+                        },
+                        logger.Loc.Empty,
+                    );
+                },
+                .e_object => |bin_obj| {
+                    var bin_props = std.ArrayList(G.Property).init(allocator);
+                    for (bin_obj.properties.slice()) |bin_prop| {
+                        const key = key: {
+                            if (bin_prop.key) |key| {
+                                if (key.isString() and key.data.e_string.len() != 0) {
+                                    break :key try allocator.dupeZ(
+                                        u8,
+                                        strings.withoutPrefixComptime(
+                                            path.normalizeBuf(
+                                                try key.data.e_string.string(allocator),
+                                                &path_buf,
+                                                .posix,
+                                            ),
+                                            "./",
+                                        ),
+                                    );
+                                }
+                            }
+
+                            continue;
+                        };
+
+                        if (key.len == 0) {
+                            continue;
+                        }
+
+                        const value = value: {
+                            if (bin_prop.value) |value| {
+                                if (value.isString() and value.data.e_string.len() != 0) {
+                                    break :value try allocator.dupeZ(
+                                        u8,
+                                        strings.withoutPrefixComptimeZ(
+                                            // replace separators
+                                            path.normalizeBufZ(
+                                                try value.data.e_string.string(allocator),
+                                                &path_buf,
+                                                .posix,
+                                            ),
+                                            "./",
+                                        ),
+                                    );
+                                }
+                            }
+
+                            continue;
+                        };
+                        if (value.len == 0) {
+                            continue;
+                        }
+
+                        if (!bun.sys.existsAt(workspace_root, value)) {
+                            Output.warn("bin '{s}' does not exist", .{value});
+                        }
+
+                        try bin_props.append(.{
+                            .key = Expr.init(
+                                E.String,
+                                .{ .data = key },
+                                logger.Loc.Empty,
+                            ),
+                            .value = Expr.init(
+                                E.String,
+                                .{ .data = value },
+                                logger.Loc.Empty,
+                            ),
+                        });
+                    }
+
+                    json.data.e_object.properties.ptr[bin_query.i].value = Expr.init(
+                        E.Object,
+                        .{ .properties = G.Property.List.fromList(bin_props) },
+                        logger.Loc.Empty,
+                    );
+                },
+                else => {},
+            }
+        } else if (json.asProperty("directories")) |directories_query| {
+            if (directories_query.expr.asProperty("bin")) |bin_query| {
+                const bin_dir_str = bin_query.expr.asString(allocator) orelse {
+                    return;
+                };
+                var bin_props = std.ArrayList(G.Property).init(allocator);
+                const normalized_bin_dir = try allocator.dupeZ(
+                    u8,
+                    strings.withoutTrailingSlash(
+                        strings.withoutPrefixComptime(
+                            path.normalizeBuf(
+                                bin_dir_str,
+                                &path_buf,
+                                .posix,
+                            ),
+                            "./",
+                        ),
+                    ),
+                );
+
+                if (normalized_bin_dir.len == 0) {
+                    return;
+                }
+
+                const bin_dir = bun.sys.openat(workspace_root, normalized_bin_dir, bun.O.DIRECTORY, 0).unwrap() catch |err| {
+                    if (err == error.ENOENT) {
+                        Output.warn("bin directory '{s}' does not exist", .{normalized_bin_dir});
+                        return;
+                    } else {
+                        Output.err(err, "failed to open bin directory: '{s}'", .{normalized_bin_dir});
+                        Global.crash();
+                    }
+                };
+
+                var dirs: std.ArrayListUnmanaged(struct { std.fs.Dir, string, bool }) = .{};
+                defer dirs.deinit(allocator);
+
+                try dirs.append(allocator, .{ bin_dir.asDir(), normalized_bin_dir, false });
+
+                while (dirs.popOrNull()) |dir_info| {
+                    var dir, const dir_subpath, const close_dir = dir_info;
+                    defer if (close_dir) dir.close();
+
+                    var iter = bun.DirIterator.iterate(dir, .u8);
+                    while (iter.next().unwrap() catch null) |entry| {
+                        const name, const subpath = name_and_subpath: {
+                            const name = entry.name.slice();
+                            const join = try bun.fmt.allocPrintZ(allocator, "{s}{s}{s}", .{
+                                dir_subpath,
+                                // only using posix separators
+                                if (dir_subpath.len == 0) "" else std.fs.path.sep_str_posix,
+                                strings.withoutTrailingSlash(name),
+                            });
+
+                            break :name_and_subpath .{ join[join.len - name.len ..][0..name.len :0], join };
+                        };
+
+                        if (name.len == 0 or (name.len == 1 and name[0] == '.') or (name.len == 2 and name[0] == '.' and name[1] == '.')) {
+                            continue;
+                        }
+
+                        try bin_props.append(.{
+                            .key = Expr.init(
+                                E.String,
+                                .{ .data = std.fs.path.basenamePosix(subpath) },
+                                logger.Loc.Empty,
+                            ),
+                            .value = Expr.init(
+                                E.String,
+                                .{ .data = subpath },
+                                logger.Loc.Empty,
+                            ),
+                        });
+
+                        if (entry.kind == .directory) {
+                            const subdir = dir.openDirZ(name, .{ .iterate = true }) catch {
+                                continue;
+                            };
+                            try dirs.append(allocator, .{ subdir, subpath, true });
+                        }
+                    }
+                }
+
+                try json.set(allocator, "bin", Expr.init(E.Object, .{ .properties = G.Property.List.fromList(bin_props) }, logger.Loc.Empty));
+            }
+        }
+
+        // no bins
+    }
+
+    fn constructPublishHeaders(
+        allocator: std.mem.Allocator,
+        print_buf: *std.ArrayListUnmanaged(u8),
+        registry: *const Npm.Registry.Scope,
+        maybe_json_len: ?usize,
+        maybe_otp: ?[]const u8,
+        uses_workspaces: bool,
+        auth_type: ?PackageManager.Options.AuthType,
+    ) OOM!http.HeaderBuilder {
+        var print_writer = print_buf.writer(allocator);
+        var headers: http.HeaderBuilder = .{};
+        const npm_auth_type = if (maybe_otp == null)
+            if (auth_type) |auth| @tagName(auth) else "web"
+        else
+            "legacy";
+        const ci_name = bun.detectCI();
+
+        {
+            headers.count("accept", "*/*");
+            headers.count("accept-encoding", "gzip,deflate");
+
+            if (registry.token.len > 0) {
+                try print_writer.print("Bearer {s}", .{registry.token});
+                headers.count("authorization", print_buf.items);
+                print_buf.clearRetainingCapacity();
+            } else if (registry.auth.len > 0) {
+                try print_writer.print("Basic {s}", .{registry.auth});
+                headers.count("authorization", print_buf.items);
+                print_buf.clearRetainingCapacity();
+            }
+
+            if (maybe_json_len != null) {
+                // not using `MimeType.json.value`, verdaccio will fail if it's anything other than `application/json`
+                headers.count("content-type", "application/json");
+            }
+
+            headers.count("npm-auth-type", npm_auth_type);
+            if (maybe_otp) |otp| {
+                headers.count("npm-otp", otp);
+            }
+            headers.count("npm-command", "publish");
+
+            try print_writer.print("{s} {s} {s} workspaces/{}{s}{s}", .{
+                Global.user_agent,
+                Global.os_name,
+                Global.arch_name,
+                uses_workspaces,
+                if (ci_name != null) " ci/" else "",
+                ci_name orelse "",
+            });
+            // headers.count("user-agent", "npm/10.8.3 node/v22.6.0 darwin arm64 workspaces/false");
+            headers.count("user-agent", print_buf.items);
+            print_buf.clearRetainingCapacity();
+
+            headers.count("Connection", "keep-alive");
+            headers.count("Host", registry.url.host);
+
+            if (maybe_json_len) |json_len| {
+                try print_writer.print("{d}", .{json_len});
+                headers.count("Content-Length", print_buf.items);
+                print_buf.clearRetainingCapacity();
+            }
+        }
+
+        try headers.allocate(allocator);
+
+        {
+            headers.append("accept", "*/*");
+            headers.append("accept-encoding", "gzip,deflate");
+
+            if (registry.token.len > 0) {
+                try print_writer.print("Bearer {s}", .{registry.token});
+                headers.append("authorization", print_buf.items);
+                print_buf.clearRetainingCapacity();
+            } else if (registry.auth.len > 0) {
+                try print_writer.print("Basic {s}", .{registry.auth});
+                headers.append("authorization", print_buf.items);
+                print_buf.clearRetainingCapacity();
+            }
+
+            if (maybe_json_len != null) {
+                // not using `MimeType.json.value`, verdaccio will fail if it's anything other than `application/json`
+                headers.append("content-type", "application/json");
+            }
+
+            headers.append("npm-auth-type", npm_auth_type);
+            if (maybe_otp) |otp| {
+                headers.append("npm-otp", otp);
+            }
+            headers.append("npm-command", "publish");
+
+            try print_writer.print("{s} {s} {s} workspaces/{}{s}{s}", .{
+                Global.user_agent,
+                Global.os_name,
+                Global.arch_name,
+                uses_workspaces,
+                if (ci_name != null) " ci/" else "",
+                ci_name orelse "",
+            });
+            // headers.append("user-agent", "npm/10.8.3 node/v22.6.0 darwin arm64 workspaces/false");
+            headers.append("user-agent", print_buf.items);
+            print_buf.clearRetainingCapacity();
+
+            headers.append("Connection", "keep-alive");
+            headers.append("Host", registry.url.host);
+
+            if (maybe_json_len) |json_len| {
+                try print_writer.print("{d}", .{json_len});
+                headers.append("Content-Length", print_buf.items);
+                print_buf.clearRetainingCapacity();
+            }
+        }
+
+        return headers;
+    }
+
+    fn constructPublishRequestBody(
+        comptime directory_publish: bool,
+        ctx: *const Context(directory_publish),
+    ) OOM![]const u8 {
+        const tag = if (ctx.manager.options.publish_config.tag.len > 0)
+            ctx.manager.options.publish_config.tag
+        else
+            "latest";
+
+        const encoded_tarball_len = std.base64.standard.Encoder.calcSize(ctx.tarball_bytes.len);
+        const version_without_build_tag = Dependency.withoutBuildTag(ctx.package_version);
+
+        var buf = try std.ArrayListUnmanaged(u8).initCapacity(
+            ctx.allocator,
+            ctx.package_name.len * 5 +
+                version_without_build_tag.len * 4 +
+                ctx.abs_tarball_path.len +
+                encoded_tarball_len,
+        );
+        var writer = buf.writer(ctx.allocator);
+
+        try writer.print("{{\"_id\":\"{s}\",\"name\":\"{s}\"", .{
+            ctx.package_name,
+            ctx.package_name,
+        });
+
+        try writer.print(",\"dist-tags\":{{\"{s}\":\"{s}\"}}", .{
+            tag,
+            version_without_build_tag,
+        });
+
+        // "versions"
+        {
+            try writer.print(",\"versions\":{{\"{s}\":{s}}}", .{
+                version_without_build_tag,
+                ctx.normalized_pkg_info,
+            });
+        }
+
+        if (ctx.manager.options.publish_config.access) |access| {
+            try writer.print(",\"access\":\"{s}\"", .{@tagName(access)});
+        } else {
+            try writer.writeAll(",\"access\":null");
+        }
+
+        // "_attachments"
+        {
+            try writer.print(",\"_attachments\":{{\"{s}\":{{\"content_type\":\"{s}\",\"data\":\"", .{
+                std.fs.path.basename(ctx.abs_tarball_path),
+                "application/octet-stream",
+            });
+
+            try buf.ensureUnusedCapacity(ctx.allocator, encoded_tarball_len);
+            buf.items.len += encoded_tarball_len;
+            const count = bun.simdutf.base64.encode(ctx.tarball_bytes, buf.items[buf.items.len - encoded_tarball_len ..], false);
+            bun.assertWithLocation(count == encoded_tarball_len, @src());
+
+            try writer.print("\",\"length\":{d}}}}}}}", .{
+                ctx.tarball_bytes.len,
+            });
+        }
+
+        return buf.items;
+    }
+};
diff --git a/src/cli/run_command.zig b/src/cli/run_command.zig
index 84b62dfe6d..78c0c3601d 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;
                 },
@@ -278,44 +259,37 @@ pub const RunCommand = struct {
         use_system_shell: bool,
     ) !void {
         const shell_bin = findShell(env.get("PATH") orelse "", cwd) orelse return error.MissingShell;
+        env.map.put("npm_lifecycle_event", name) catch unreachable;
+        env.map.put("npm_lifecycle_script", original_script) catch unreachable;
 
-        const script = original_script;
-        var copy_script = try std.ArrayList(u8).initCapacity(allocator, script.len);
+        var copy_script_capacity: usize = original_script.len;
+        for (passthrough) |part| copy_script_capacity += 1 + part.len;
+        var copy_script = try std.ArrayList(u8).initCapacity(allocator, copy_script_capacity);
 
         // We're going to do this slowly.
         // Find exact matches of yarn, pnpm, npm
 
-        try replacePackageManagerRun(&copy_script, script);
+        try replacePackageManagerRun(&copy_script, original_script);
 
-        var combined_script: []u8 = copy_script.items;
-
-        log("Script: \"{s}\"", .{combined_script});
-
-        if (passthrough.len > 0) {
-            var combined_script_len = script.len;
-            for (passthrough) |p| {
-                combined_script_len += p.len + 1;
+        for (passthrough) |part| {
+            try copy_script.append(' ');
+            if (bun.shell.needsEscapeUtf8AsciiLatin1(part)) {
+                try bun.shell.escape8Bit(part, &copy_script, true);
+            } else {
+                try copy_script.appendSlice(part);
             }
-            var combined_script_buf = try allocator.alloc(u8, combined_script_len);
-            bun.copy(u8, combined_script_buf, script);
-            var remaining_script_buf = combined_script_buf[script.len..];
-            for (passthrough) |part| {
-                const p = part;
-                remaining_script_buf[0] = ' ';
-                bun.copy(u8, remaining_script_buf[1..], p);
-                remaining_script_buf = remaining_script_buf[p.len + 1 ..];
-            }
-            combined_script = combined_script_buf;
         }
 
+        log("Script: \"{s}\"", .{copy_script.items});
+
         if (!silent) {
-            Output.prettyErrorln("<r><d><magenta>$<r> <d><b>{s}<r>", .{combined_script});
+            Output.prettyErrorln("<r><d><magenta>$<r> <d><b>{s}<r>", .{copy_script.items});
             Output.flush();
         }
 
         if (!use_system_shell) {
             const mini = bun.JSC.MiniEventLoop.initGlobal(env);
-            const code = bun.shell.Interpreter.initAndRunFromSource(ctx, mini, name, combined_script) catch |err| {
+            const code = bun.shell.Interpreter.initAndRunFromSource(ctx, mini, name, copy_script.items) catch |err| {
                 if (!silent) {
                     Output.prettyErrorln("<r><red>error<r>: Failed to run script <b>{s}<r> due to error <b>{s}<r>", .{ name, @errorName(err) });
                 }
@@ -338,7 +312,7 @@ pub const RunCommand = struct {
         const argv = [_]string{
             shell_bin,
             if (Environment.isWindows) "/c" else "-c",
-            combined_script,
+            copy_script.items,
         };
 
         const ipc_fd = if (!Environment.isWindows) blk: {
@@ -406,9 +380,8 @@ pub const RunCommand = struct {
                 if (signal.valid() and signal != .SIGINT and !silent) {
                     Output.prettyErrorln("<r><red>error<r><d>:<r> script <b>\"{s}\"<r> was terminated by signal {}<r>", .{ name, signal.fmt(Output.enable_ansi_colors_stderr) });
                     Output.flush();
-
-                    Global.raiseIgnoringPanicHandler(signal);
                 }
+                Global.raiseIgnoringPanicHandler(signal);
             },
 
             .err => |err| {
@@ -574,7 +547,7 @@ pub const RunCommand = struct {
                     },
 
                     .signaled => |signal| {
-                        if (!silent) {
+                        if (signal.valid() and signal != .SIGINT and !silent) {
                             Output.prettyErrorln("<r><red>error<r>: Failed to run \"<b>{s}<r>\" due to signal <b>{s}<r>", .{
                                 basenameOrBun(executable),
                                 signal.name() orelse "unknown",
@@ -841,20 +814,12 @@ pub const RunCommand = struct {
 
         const root_dir_info = this_bundler.resolver.readDirInfo(this_bundler.fs.top_level_dir) catch |err| {
             if (!log_errors) return error.CouldntReadCurrentDirectory;
-            if (Output.enable_ansi_colors) {
-                ctx.log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), true) catch {};
-            } else {
-                ctx.log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), false) catch {};
-            }
+            ctx.log.print(Output.errorWriter()) catch {};
             Output.prettyErrorln("<r><red>error<r><d>:<r> <b>{s}<r> loading directory {}", .{ @errorName(err), bun.fmt.QuotedFormatter{ .text = this_bundler.fs.top_level_dir } });
             Output.flush();
             return err;
         } orelse {
-            if (Output.enable_ansi_colors) {
-                ctx.log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), true) catch {};
-            } else {
-                ctx.log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), false) catch {};
-            }
+            ctx.log.print(Output.errorWriter()) catch {};
             Output.prettyErrorln("error loading current directory", .{});
             Output.flush();
             return error.CouldntReadCurrentDirectory;
@@ -908,6 +873,14 @@ pub const RunCommand = struct {
                     this_bundler.env.map.put(NpmArgs.package_version, package_json.version) catch unreachable;
                 }
             }
+
+            if (package_json.config) |config| {
+                try this_bundler.env.map.ensureUnusedCapacity(config.count());
+                for (config.keys(), config.values()) |k, v| {
+                    const key = try bun.strings.concat(bun.default_allocator, &.{ "npm_package_config_", k });
+                    this_bundler.env.map.putAssumeCapacity(key, v);
+                }
+            }
         }
 
         return root_dir_info;
@@ -1305,7 +1278,7 @@ pub const RunCommand = struct {
             Run.boot(ctx, ".") catch |err| {
                 bun.handleErrorReturnTrace(err, @errorReturnTrace());
 
-                ctx.log.printForLogLevel(Output.errorWriter()) catch {};
+                ctx.log.print(Output.errorWriter()) catch {};
 
                 Output.prettyErrorln("<r><red>error<r>: Failed to run <b>{s}<r> due to error <b>{s}<r>", .{
                     script_name_to_search,
@@ -1400,7 +1373,7 @@ pub const RunCommand = struct {
                     Run.boot(ctx, out_path) catch |err| {
                         bun.handleErrorReturnTrace(err, @errorReturnTrace());
 
-                        ctx.log.printForLogLevel(Output.errorWriter()) catch {};
+                        ctx.log.print(Output.errorWriter()) catch {};
 
                         Output.prettyErrorln("<r><red>error<r>: Failed to run <b>{s}<r> due to error <b>{s}<r>", .{
                             std.fs.path.basename(file_path),
@@ -1420,7 +1393,7 @@ pub const RunCommand = struct {
         var this_bundler: bundler.Bundler = undefined;
         const root_dir_info = try configureEnvForRun(ctx, &this_bundler, null, log_errors, false);
         try configurePathForRun(ctx, root_dir_info, &this_bundler, &ORIGINAL_PATH, root_dir_info.abs_path, force_using_bun);
-        this_bundler.env.map.put("npm_lifecycle_event", script_name_to_search) catch unreachable;
+        this_bundler.env.map.put("npm_command", "run-script") catch unreachable;
 
         if (script_name_to_search.len == 0) {
             // naked "bun run"
@@ -1457,17 +1430,19 @@ pub const RunCommand = struct {
                         );
                     }
 
-                    try runPackageScriptForeground(
-                        ctx,
-                        ctx.allocator,
-                        script_content,
-                        script_name_to_search,
-                        this_bundler.fs.top_level_dir,
-                        this_bundler.env,
-                        passthrough,
-                        ctx.debug.silent,
-                        ctx.debug.use_system_shell,
-                    );
+                    {
+                        try runPackageScriptForeground(
+                            ctx,
+                            ctx.allocator,
+                            script_content,
+                            script_name_to_search,
+                            this_bundler.fs.top_level_dir,
+                            this_bundler.env,
+                            passthrough,
+                            ctx.debug.silent,
+                            ctx.debug.use_system_shell,
+                        );
+                    }
 
                     temp_script_buffer[0.."post".len].* = "post".*;
 
@@ -1497,7 +1472,7 @@ pub const RunCommand = struct {
             Run.boot(ctx, ctx.allocator.dupe(u8, script_name_to_search) catch unreachable) catch |err| {
                 bun.handleErrorReturnTrace(err, @errorReturnTrace());
 
-                ctx.log.printForLogLevel(Output.errorWriter()) catch {};
+                ctx.log.print(Output.errorWriter()) catch {};
 
                 Output.prettyErrorln("<r><red>error<r>: Failed to run <b>{s}<r> due to error <b>{s}<r>", .{
                     std.fs.path.basename(script_name_to_search),
@@ -1523,7 +1498,7 @@ pub const RunCommand = struct {
             const entry_path = entry_point_buf[0 .. cwd.len + trigger.len];
 
             Run.boot(ctx, ctx.allocator.dupe(u8, entry_path) catch return false) catch |err| {
-                ctx.log.printForLogLevel(Output.errorWriter()) catch {};
+                ctx.log.print(Output.errorWriter()) catch {};
 
                 Output.prettyErrorln("<r><red>error<r>: Failed to run <b>{s}<r> due to error <b>{s}<r>", .{
                     std.fs.path.basename(script_name_to_search),
@@ -1640,7 +1615,7 @@ pub const RunCommand = struct {
         };
 
         Run.boot(ctx, normalized_filename) catch |err| {
-            ctx.log.printForLogLevel(Output.errorWriter()) catch {};
+            ctx.log.print(Output.errorWriter()) catch {};
 
             Output.err(err, "Failed to run script \"<b>{s}<r>\"", .{std.fs.path.basename(normalized_filename)});
             Global.exit(1);
@@ -1713,7 +1688,7 @@ pub const BunXFastPath = struct {
             wpath,
         ) catch return;
         Run.boot(ctx, utf8) catch |err| {
-            ctx.log.printForLogLevel(Output.errorWriter()) catch {};
+            ctx.log.print(Output.errorWriter()) catch {};
             Output.err(err, "Failed to run bin \"<b>{s}<r>\"", .{std.fs.path.basename(utf8)});
             Global.exit(1);
         };
diff --git a/src/cli/test_command.zig b/src/cli/test_command.zig
index a6ccf6f4ad..a918be8adc 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();
@@ -610,11 +1058,13 @@ const Scanner = struct {
             return false;
         }
 
-        if (jest.Jest.runner.?.test_options.coverage.skip_test_files) {
-            const name_without_extension = slice[0 .. slice.len - ext.len];
-            inline for (test_name_suffixes) |suffix| {
-                if (strings.endsWithComptime(name_without_extension, suffix)) {
-                    return false;
+        if (jest.Jest.runner) |runner| {
+            if (runner.test_options.coverage.skip_test_files) {
+                const name_without_extension = slice[0 .. slice.len - ext.len];
+                inline for (test_name_suffixes) |suffix| {
+                    if (strings.endsWithComptime(name_without_extension, suffix)) {
+                        return false;
+                    }
                 }
             }
         }
@@ -723,13 +1173,17 @@ pub const TestCommand = struct {
         lcov: bool,
     };
 
+    pub const FileReporter = enum {
+        junit,
+    };
+
     pub fn exec(ctx: Command.Context) !void {
         if (comptime is_bindgen) unreachable;
 
         Output.is_github_action = Output.isGithubAction();
 
         // print the version so you know its doing stuff if it takes a sec
-        Output.prettyErrorln("<r><b>bun test <r><d>v" ++ Global.package_json_version_with_sha ++ "<r>", .{});
+        Output.prettyln("<r><b>bun test <r><d>v" ++ Global.package_json_version_with_sha ++ "<r>", .{});
         Output.flush();
 
         var env_loader = brk: {
@@ -741,11 +1195,12 @@ pub const TestCommand = struct {
             break :brk loader;
         };
         bun.JSC.initialize(false);
-        HTTPThread.init();
+        HTTPThread.init(&.{});
 
         var snapshot_file_buf = std.ArrayList(u8).init(ctx.allocator);
         var snapshot_values = Snapshots.ValuesHashMap.init(ctx.allocator);
         var snapshot_counts = bun.StringHashMap(usize).init(ctx.allocator);
+        var inline_snapshots_to_write = std.AutoArrayHashMap(TestRunner.File.ID, std.ArrayList(Snapshots.InlineSnapshotToWrite)).init(ctx.allocator);
         JSC.isBunTest = true;
 
         var reporter = try ctx.allocator.create(CommandLineReporter);
@@ -766,6 +1221,7 @@ pub const TestCommand = struct {
                     .file_buf = &snapshot_file_buf,
                     .values = &snapshot_values,
                     .counts = &snapshot_counts,
+                    .inline_snapshots_to_write = &inline_snapshots_to_write,
                 },
             },
             .callback = undefined,
@@ -782,6 +1238,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(
@@ -846,6 +1309,11 @@ pub const TestCommand = struct {
         var results = try std.ArrayList(PathString).initCapacity(ctx.allocator, ctx.positionals.len);
         defer results.deinit();
 
+        // Start the debugger before we scan for files
+        // But, don't block the main thread waiting if they used --inspect-wait.
+        //
+        try vm.ensureDebugger(false);
+
         const test_files, const search_count = scan: {
             if (for (ctx.positionals) |arg| {
                 if (std.fs.path.isAbsolute(arg) or
@@ -915,6 +1383,7 @@ pub const TestCommand = struct {
             runAllTests(reporter, vm, test_files, ctx.allocator);
         }
 
+        const write_snapshots_success = try jest.Jest.runner.?.snapshots.writeInlineSnapshots();
         try jest.Jest.runner.?.snapshots.writeSnapshotFile();
         var coverage = ctx.test_options.coverage;
 
@@ -1089,26 +1558,41 @@ pub const TestCommand = struct {
         Output.prettyError("\n", .{});
         Output.flush();
 
-        if (vm.hot_reload == .watch) {
-            vm.eventLoop().tickPossiblyForever();
-
-            while (true) {
-                while (vm.isEventLoopAlive()) {
-                    vm.tick();
-                    vm.eventLoop().autoTickActive();
-                }
-
-                vm.eventLoop().tickPossiblyForever();
+        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 (reporter.summary.fail > 0 or (coverage.enabled and coverage.fractions.failing and coverage.fail_on_low_coverage)) {
+        if (vm.hot_reload == .watch) {
+            vm.runWithAPILock(JSC.VirtualMachine, vm, runEventLoopForWatch);
+        }
+
+        if (reporter.summary.fail > 0 or (coverage.enabled and coverage.fractions.failing and coverage.fail_on_low_coverage) or !write_snapshots_success) {
             Global.exit(1);
         } else if (reporter.jest.unhandled_errors_between_tests > 0) {
             Global.exit(reporter.jest.unhandled_errors_between_tests);
         }
     }
 
+    fn runEventLoopForWatch(vm: *JSC.VirtualMachine) void {
+        vm.eventLoop().tickPossiblyForever();
+
+        while (true) {
+            while (vm.isEventLoopAlive()) {
+                vm.tick();
+                vm.eventLoop().autoTickActive();
+            }
+
+            vm.eventLoop().tickPossiblyForever();
+        }
+    }
+
     pub fn runAllTests(
         reporter_: *CommandLineReporter,
         vm_: *JSC.VirtualMachine,
@@ -1129,13 +1613,13 @@ pub const TestCommand = struct {
 
                 if (files.len > 1) {
                     for (files[0 .. files.len - 1]) |file_name| {
-                        TestCommand.run(reporter, vm, file_name.slice(), allocator, false) catch {};
+                        TestCommand.run(reporter, vm, file_name.slice(), allocator, false) catch |err| handleTopLevelTestErrorBeforeJavaScriptStart(err);
                         reporter.jest.default_timeout_override = std.math.maxInt(u32);
                         Global.mimalloc_cleanup(false);
                     }
                 }
 
-                TestCommand.run(reporter, vm, files[files.len - 1].slice(), allocator, true) catch {};
+                TestCommand.run(reporter, vm, files[files.len - 1].slice(), allocator, true) catch |err| handleTopLevelTestErrorBeforeJavaScriptStart(err);
             }
         };
 
@@ -1161,11 +1645,7 @@ pub const TestCommand = struct {
             js_ast.Stmt.Data.Store.reset();
 
             if (vm.log.errors > 0) {
-                if (Output.enable_ansi_colors) {
-                    vm.log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), true) catch {};
-                } else {
-                    vm.log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), false) catch {};
-                }
+                vm.log.print(Output.errorWriter()) catch {};
                 vm.log.msgs.clearRetainingCapacity();
                 vm.log.errors = 0;
             }
@@ -1213,6 +1693,7 @@ pub const TestCommand = struct {
                     if (reporter.jest.bail == reporter.summary.fail) {
                         reporter.printSummary();
                         Output.prettyError("\nBailed out after {d} failure{s}<r>\n", .{ reporter.jest.bail, if (reporter.jest.bail == 1) "" else "s" });
+
                         Global.exit(1);
                     }
 
@@ -1287,6 +1768,10 @@ pub const TestCommand = struct {
                 Output.prettyErrorln("<r>\n::endgroup::\n", .{});
                 Output.flush();
             }
+
+            // Ensure these never linger across files.
+            vm.auto_killer.clear();
+            vm.auto_killer.disable();
         }
 
         if (is_last) {
@@ -1298,3 +1783,12 @@ pub const TestCommand = struct {
         }
     }
 };
+
+fn handleTopLevelTestErrorBeforeJavaScriptStart(err: anyerror) noreturn {
+    if (comptime Environment.isDebug) {
+        if (err != error.ModuleNotFound) {
+            Output.debugWarn("Unhandled error: {s}\n", .{@errorName(err)});
+        }
+    }
+    Global.exit(1);
+}
diff --git a/src/cli/upgrade_command.zig b/src/cli/upgrade_command.zig
index c5fca9ef54..d55776ad24 100644
--- a/src/cli/upgrade_command.zig
+++ b/src/cli/upgrade_command.zig
@@ -30,7 +30,7 @@ const bundler = bun.bundler;
 const fs = @import("../fs.zig");
 const URL = @import("../url.zig").URL;
 const HTTP = bun.http;
-const ParseJSON = @import("../json_parser.zig").ParseJSONUTF8;
+const JSON = bun.JSON;
 const Archive = @import("../libarchive/libarchive.zig").Archive;
 const Zlib = @import("../zlib.zig");
 const JSPrinter = bun.js_printer;
@@ -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";
@@ -133,7 +135,7 @@ pub const UpgradeCheckerThread = struct {
         std.time.sleep(std.time.ns_per_ms * delay);
 
         Output.Source.configureThread();
-        HTTP.HTTPThread.init();
+        HTTP.HTTPThread.init(&.{});
 
         defer {
             js_ast.Expr.Data.Store.deinit();
@@ -251,7 +253,7 @@ pub const UpgradeCommand = struct {
         async_http.client.flags.reject_unauthorized = env_loader.getTLSRejectUnauthorized();
 
         if (!silent) async_http.client.progress_node = progress.?;
-        const response = try async_http.sendSync(true);
+        const response = try async_http.sendSync();
 
         switch (response.status_code) {
             404 => return error.HTTP404,
@@ -266,17 +268,13 @@ pub const UpgradeCommand = struct {
         defer if (comptime silent) log.deinit();
         var source = logger.Source.initPathString("releases.json", metadata_body.list.items);
         initializeStore();
-        var expr = ParseJSON(&source, &log, allocator) catch |err| {
+        var expr = JSON.parseUTF8(&source, &log, allocator) catch |err| {
             if (!silent) {
                 progress.?.end();
                 refresher.?.refresh();
 
                 if (log.errors > 0) {
-                    if (Output.enable_ansi_colors) {
-                        try log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), true);
-                    } else {
-                        try log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), false);
-                    }
+                    try log.print(Output.errorWriter());
 
                     Global.exit(1);
                 } else {
@@ -293,11 +291,7 @@ pub const UpgradeCommand = struct {
                 progress.?.end();
                 refresher.?.refresh();
 
-                if (Output.enable_ansi_colors) {
-                    try log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), true);
-                } else {
-                    try log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), false);
-                }
+                try log.print(Output.errorWriter());
                 Global.exit(1);
             }
 
@@ -440,7 +434,7 @@ pub const UpgradeCommand = struct {
     }
 
     fn _exec(ctx: Command.Context) !void {
-        HTTP.HTTPThread.init();
+        HTTP.HTTPThread.init(&.{});
 
         var filesystem = try fs.FileSystem.init(null);
         var env_loader: DotEnv.Loader = brk: {
@@ -533,7 +527,7 @@ pub const UpgradeCommand = struct {
             async_http.client.progress_node = progress;
             async_http.client.flags.reject_unauthorized = env_loader.getTLSRejectUnauthorized();
 
-            const response = try async_http.sendSync(true);
+            const response = try async_http.sendSync();
 
             switch (response.status_code) {
                 404 => {
@@ -559,7 +553,7 @@ pub const UpgradeCommand = struct {
                 else => return error.HTTPError,
             }
 
-            const bytes = zip_file_buffer.toOwnedSliceLeaky();
+            const bytes = zip_file_buffer.slice();
 
             progress.end();
             refresher.refresh();
@@ -996,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;
 
@@ -1050,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
new file mode 100644
index 0000000000..22d389ce77
--- /dev/null
+++ b/src/codegen/bake-codegen.ts
@@ -0,0 +1,199 @@
+import assert from "node:assert";
+import { existsSync, writeFileSync, rmSync, readFileSync } from "node:fs";
+import { watch } from "node:fs/promises";
+import { basename, join } from "node:path";
+
+// arg parsing
+const options = {};
+for (const arg of process.argv.slice(2)) {
+  if (!arg.startsWith("--")) {
+    console.error("Unknown argument " + arg);
+    process.exit(1);
+  }
+  const split = arg.split("=");
+  const value = split[1] || "true";
+  options[split[0].slice(2)] = value;
+}
+
+let { codegen_root, debug, live } = options as any;
+if (!codegen_root) {
+  console.error("Missing --codegen_root=...");
+  process.exit(1);
+}
+if (debug === "false" || debug === "0" || debug == "OFF") debug = false;
+
+const base_dir = join(import.meta.dirname, "../bake");
+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 (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) => {
+    return `\n  ${name} = ${value.charCodeAt(0)},`;
+  });
+  return `/** Generated from DevServer.zig */\nexport const enum MessageId {${values}}`;
+}
+
+async function run() {
+  const devServerZig = readFileSync(join(base_dir, "DevServer.zig"), "utf-8");
+  writeFileSync(join(base_dir, "generated.ts"), convertZigEnum(devServerZig));
+
+  const results = await Promise.allSettled(
+    ["client", "server", "error"].map(async file => {
+      const side = file === "error" ? "client" : file;
+      let result = await Bun.build({
+        entrypoints: [join(base_dir, `hmr-runtime-${file}.ts`)],
+        define: {
+          side: JSON.stringify(side),
+          IS_BUN_DEVELOPMENT: String(!!debug),
+        },
+        minify: {
+          syntax: !debug,
+        },
+        target: side === 'server' ? 'bun' : 'browser',
+      });
+      if (!result.success) throw new AggregateError(result.logs);
+      assert(result.outputs.length === 1, "must bundle to a single file");
+      // @ts-ignore
+      let code = await result.outputs[0].text();
+
+      // A second pass is used to convert global variables into parameters, while
+      // allowing for renaming to properly function when minification is enabled.
+      const in_names = [
+        file !== "error" && "input_graph",
+        file !== "error" && "config",
+        file === "server" && "server_exports",
+        file === "server" && "$separateSSRGraph",
+        file === "server" && "$importMeta",
+      ].filter(Boolean);
+      const combined_source =
+        file === "error"
+          ? code
+          : `
+            __marker__;
+            ${in_names.length > 0 ? "let" : ""} ${in_names.join(",")};
+            __marker__(${in_names.join(",")});
+            ${code};
+          `;
+      const generated_entrypoint = join(base_dir, `.runtime-${file}.generated.ts`);
+
+      writeFileSync(generated_entrypoint, combined_source);
+
+      result = await Bun.build({
+        entrypoints: [generated_entrypoint],
+        minify: !debug,
+      });
+      if (!result.success) throw new AggregateError(result.logs);
+      assert(result.outputs.length === 1, "must bundle to a single file");
+      code = (await result.outputs[0].text()).replace(`// ${basename(generated_entrypoint)}`, "").trim();
+
+      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
+          .replace(/(\n?)\s*__marker__.*__marker__\((.+?)\);\s*/s, (_, n, captured) => {
+            names = captured;
+            return n;
+          })
+          .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";
+        }
+
+        if (code[code.length - 1] === ";") code = code.slice(0, -1);
+
+        if (side === "server") {
+          code = debug 
+            ? `${code}  return ${outName('server_exports')};\n`
+            : `${code};return ${outName('server_exports')};`;
+
+          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}`;
+
+          code = debug ? `((${params}) => {${code}})\n` : `((${params})=>{${code}})\n`;
+        } else {
+          code = debug ? `((${names}) => {${code}})({\n` : `((${names})=>{${code}})({`;
+        }
+      }
+
+      writeFileSync(join(codegen_root, `bake.${file}.js`), code);
+    }),
+  );
+
+  // print failures in a de-duplicated fashion.
+  interface Err {
+    kind: ("client" | "server" | "error")[];
+    err: any;
+  }
+  const failed = [
+    { kind: ["client"], result: results[0] },
+    { kind: ["server"], result: results[1] },
+    { kind: ["error"], result: results[2] },
+  ]
+    .filter(x => x.result.status === "rejected")
+    .map(x => ({ kind: x.kind, err: x.result.reason })) as Err[];
+  if (failed.length > 0) {
+    const flattened_errors: Err[] = [];
+    for (const { kind, err } of failed) {
+      if (err instanceof AggregateError) {
+        flattened_errors.push(...err.errors.map(err => ({ kind, err })));
+      }
+      flattened_errors.push({ kind, err });
+    }
+    for (let i = 0; i < flattened_errors.length; i++) {
+      const x = flattened_errors[i];
+      if (!x.err?.message) continue;
+      for (const other of flattened_errors.slice(0, i)) {
+        if (other.err?.message === x.err.message || other.err.stack === x.err.stack) {
+          other.kind = [...x.kind, ...other.kind];
+          flattened_errors.splice(i, 1);
+          i -= 1;
+          continue;
+        }
+      }
+    }
+    for (const { kind, err } of flattened_errors) {
+      const map = { error: "error runtime", client: "client runtime", server: "server runtime" };
+      console.error(`Errors while bundling Bake ${kind.map(x => map[x]).join(" and ")}:`);
+      console.error(err);
+    }
+    if (!live) process.exit(1);
+  } else {
+    console.log("-> bake.client.js, bake.server.js, bake.error.js");
+
+    const empty_file = join(codegen_root, "bake_empty_file");
+    if (!existsSync(empty_file)) writeFileSync(empty_file, "this is used to fulfill a cmake dependency");
+  }
+}
+
+await run();
+
+if (live) {
+  const watcher = watch(base_dir, { recursive: true }) as any;
+  for await (const event of watcher) {
+    if (event.filename.endsWith(".zig")) continue;
+    if (event.filename.startsWith(".")) continue;
+    try {
+      await run();
+    } catch (e) {
+      console.log(e);
+    }
+  }
+}
diff --git a/src/codegen/bundle-functions.ts b/src/codegen/bundle-functions.ts
index 0ada057c1f..7756e44afd 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 aaa86834d4..9a1d91d25a 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/class-definitions.ts b/src/codegen/class-definitions.ts
index 1e4ef00415..fe5944fce4 100644
--- a/src/codegen/class-definitions.ts
+++ b/src/codegen/class-definitions.ts
@@ -58,6 +58,7 @@ export interface ClassDefinition {
   values?: string[];
   JSType?: string;
   noConstructor?: boolean;
+  wantsThis?: boolean;
   estimatedSize?: boolean;
   hasPendingActivity?: boolean;
   isEventEmitter?: boolean;
diff --git a/src/codegen/generate-classes.ts b/src/codegen/generate-classes.ts
index 7295986bfd..bc83c72f45 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,11 +356,17 @@ 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);
+`;
+  }
+
   if (obj.structuredClone) {
     externs +=
       `extern JSC_CALLCONV void JSC_HOST_CALL_ATTRIBUTES ${symbolName(
@@ -645,7 +651,15 @@ JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES ${name}::construct(JSC::JSGlobalObj
       : ""
   }
 
-    RELEASE_AND_RETURN(scope, JSValue::encode(instance));
+    auto value = JSValue::encode(instance);
+${
+  obj.wantsThis
+    ? `
+    ${classSymbolName(typeName, "_setThis")}(globalObject, ptr, value);
+`
+    : ""
+}
+    RELEASE_AND_RETURN(scope, value);
 }
 
 void ${name}::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, ${prototypeName(typeName)}* prototype)
@@ -795,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;
@@ -1013,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, " : ""
@@ -1509,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;
   }
 
@@ -1606,6 +1620,7 @@ function generateZig(
     construct,
     finalize,
     noConstructor = false,
+    wantsThis = false,
     overridesToJS = false,
     estimatedSize,
     call = false,
@@ -1676,8 +1691,8 @@ function generateZig(
   function renderMethods() {
     const exports = new Map();
     var output = `
-const JavaScriptCoreBindings = struct {    
-    
+const JavaScriptCoreBindings = struct {
+
 `;
 
     if (estimatedSize) {
@@ -1711,9 +1726,25 @@ 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() catch {};
+              return null;
+            },
+          });
+        }
+      `;
+    }
+
+    if (construct && !noConstructor && wantsThis) {
+      exports.set("_setThis", classSymbolName(typeName, "_setThis"));
+      output += `
+        pub fn ${classSymbolName(typeName, "_setThis")}(globalObject: *JSC.JSGlobalObject, ptr: *anyopaque, this: JSC.JSValue) callconv(JSC.conv) void {
+          const real: *${typeName} = @ptrCast(@alignCast(ptr));
+          real.this_value.set(globalObject, this);
         }
       `;
     }
@@ -1723,7 +1754,7 @@ 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, JSC.toJSHostFunction(${typeName}.call), .{globalObject, callFrame});
         }
       `;
     }
@@ -1776,7 +1807,7 @@ 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, JSC.toJSHostValue, .{globalObject, @call(.always_inline, ${typeName}.${fn}, .{thisValue, globalObject, callFrame${proto[name].passThis ? ", js_this_value" : ""}})});
         }
         `;
         }
@@ -1823,7 +1854,7 @@ 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, JSC.toJSHostFunction(${typeName}.${fn}), .{globalObject, callFrame});
         }
         `;
         }
@@ -1854,7 +1885,7 @@ const JavaScriptCoreBindings = struct {
       output += `
       pub fn ${symbolName(typeName, "onStructuredCloneDeserialize")}(globalObject: *JSC.JSGlobalObject, ptr: [*]u8, end: [*]u8) callconv(JSC.conv) JSC.JSValue {
         if (comptime Environment.enable_logs) JSC.markBinding(@src());
-        return @call(.always_inline, ${typeName}.onStructuredCloneDeserialize, .{globalObject, ptr, end});
+        return @call(.always_inline, JSC.toJSHostValue, .{ globalObject, @call(.always_inline, ${typeName}.onStructuredCloneDeserialize, .{globalObject, ptr, end}) });
       }
       `;
     } else {
@@ -2113,6 +2144,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 1d9ffee55c..eb98745618 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,7 @@ 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))}).${
-          call.symbol
-        }(global);`,
+        `  return JSC.toJSHostValue(global, @import(${JSON.stringify(path.relative(path.dirname(gs2NativeZigPath), call.filename))}).${call.symbol}(global));`,
         "}",
       ]),
     ...wrapperCalls
@@ -201,19 +209,14 @@ 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, JSC.toJSHostFunction(function.${x.symbol_target}), .{global, call_frame});`,
         "}",
       ]),
-    "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/generate-jssink.ts b/src/codegen/generate-jssink.ts
index b8e760e3fb..527ef8caf0 100644
--- a/src/codegen/generate-jssink.ts
+++ b/src/codegen/generate-jssink.ts
@@ -1,6 +1,12 @@
 import { join, resolve } from "path";
 
-const classes = ["ArrayBufferSink", "FileSink", "HTTPResponseSink", "HTTPSResponseSink"];
+const classes = [
+  "ArrayBufferSink",
+  "FileSink",
+  "HTTPResponseSink",
+  "HTTPSResponseSink",
+  "FetchTaskletChunkedRequestSink",
+];
 
 function names(name) {
   return {
diff --git a/src/codegen/generate-node-errors.ts b/src/codegen/generate-node-errors.ts
index e8683237f1..6dfcedb4e1 100644
--- a/src/codegen/generate-node-errors.ts
+++ b/src/codegen/generate-node-errors.ts
@@ -39,16 +39,14 @@ const std = @import("std");
 const bun = @import("root").bun;
 const JSC = bun.JSC;
 
-fn ErrorBuilder(comptime code_: Error, comptime fmt_: [:0]const u8, Args: type) type {
+fn ErrorBuilder(comptime code: Error, comptime fmt: [:0]const u8, Args: type) type {
   return struct {
-      const code = code_;
-      const fmt = fmt_;
       globalThis: *JSC.JSGlobalObject,
       args: Args,
 
       // Throw this error as a JS exception
-      pub inline fn throw(this: @This()) void {
-        code.throw(this.globalThis, fmt, this.args);
+      pub inline fn throw(this: @This()) bun.JSError {
+        return code.throw(this.globalThis, fmt, this.args);
       }
 
       /// Turn this into a JSValue
@@ -60,7 +58,6 @@ fn ErrorBuilder(comptime code_: Error, comptime fmt_: [:0]const u8, Args: type)
       pub inline fn reject(this: @This()) JSC.JSValue {
         return JSC.JSPromise.rejectedPromiseValue(this.globalThis, code.fmt(this.globalThis, fmt, this.args));
       }
-
   };
 }
 
@@ -91,10 +88,10 @@ listHeader += `
 `;
 
 zig += `
- 
+
 
   extern fn Bun__createErrorWithCode(globalThis: *JSC.JSGlobalObject, code: Error, message: *bun.String) JSC.JSValue;
-  
+
   /// Creates an Error object with the given error code.
   /// Derefs the message string.
   pub fn toJS(this: Error, globalThis: *JSC.JSGlobalObject, message: *bun.String) JSC.JSValue {
@@ -112,8 +109,8 @@ zig += `
     return toJS(this, globalThis, &message);
   }
 
-  pub fn throw(this: Error, globalThis: *JSC.JSGlobalObject, comptime fmt_str: [:0]const u8, args: anytype) void {
-    globalThis.throwValue(fmt(this, globalThis, fmt_str, args)); 
+  pub fn throw(this: Error, globalThis: *JSC.JSGlobalObject, comptime fmt_str: [:0]const u8, args: anytype) bun.JSError {
+    return globalThis.throwValue(fmt(this, globalThis, fmt_str, args));
   }
 
 };
diff --git a/src/codegen/internal-module-registry-scanner.ts b/src/codegen/internal-module-registry-scanner.ts
index 5f1dee4621..71458fd2e2 100644
--- a/src/codegen/internal-module-registry-scanner.ts
+++ b/src/codegen/internal-module-registry-scanner.ts
@@ -29,19 +29,14 @@ export function createInternalModuleRegistry(basedir: string) {
   moduleList.push("internal-for-testing.ts");
   internalRegistry.set("bun:internal-for-testing", moduleList.length - 1);
 
-  // Native Module registry
-  const nativeModuleH = fs.readFileSync(path.join(basedir, "../bun.js/modules/_NativeModule.h"), "utf8");
-  const nativeModuleDefine = nativeModuleH.match(/BUN_FOREACH_NATIVE_MODULE\(macro\)\s*\\\n((.*\\\n)*\n)/);
-  if (!nativeModuleDefine) {
-    throw new Error(
-      "Could not find BUN_FOREACH_NATIVE_MODULE in _NativeModule.h. Knowing native module IDs is a part of the codegen process.",
-    );
-  }
   let nextNativeModuleId = 0;
   const nativeModuleIds: Record<string, number> = {};
   const nativeModuleEnums: Record<string, string> = {};
   const nativeModuleEnumToId: Record<string, number> = {};
-  for (const [_, idString, enumValue] of nativeModuleDefine[0].matchAll(/macro\((.*?),(.*?)\)/g)) {
+
+  // Native Module registry
+  const nativeModuleH = fs.readFileSync(path.join(basedir, "../bun.js/modules/_NativeModule.h"), "utf8");
+  for (const [_, idString, enumValue] of nativeModuleH.matchAll(/macro\((.*?),(.*?)\)/g)) {
     const processedIdString = JSON.parse(idString.trim().replace(/_s$/, ""));
     const processedEnumValue = enumValue.trim();
     const processedNumericId = nextNativeModuleId++;
@@ -50,6 +45,12 @@ export function createInternalModuleRegistry(basedir: string) {
     nativeModuleEnumToId[processedEnumValue] = processedNumericId;
   }
 
+  if (nextNativeModuleId === 0) {
+    throw new Error(
+      "Could not find BUN_FOREACH_ESM_AND_CJS_NATIVE_MODULE in _NativeModule.h. Knowing native module IDs is a part of the codegen process.",
+    );
+  }
+
   function codegenRequireId(id: string) {
     return `(__intrinsic__getInternalField(__intrinsic__internalModuleRegistry, ${id}) || __intrinsic__createInternalModuleById(${id}))`;
   }
diff --git a/src/codegen/kit-codegen.ts b/src/codegen/kit-codegen.ts
deleted file mode 100644
index d3bb39f2da..0000000000
--- a/src/codegen/kit-codegen.ts
+++ /dev/null
@@ -1,153 +0,0 @@
-import assert from "node:assert";
-import { existsSync, writeFileSync } from "node:fs";
-import { basename, join } from "node:path";
-
-// arg parsing
-const options = {};
-for (const arg of process.argv.slice(2)) {
-  if (!arg.startsWith("--")) {
-    console.error("Unknown argument " + arg);
-    process.exit(1);
-  }
-  const split = arg.split("=");
-  const value = split[1] || "true";
-  options[split[0].slice(2)] = value;
-}
-
-let { codegen_root, debug } = options as any;
-if (!codegen_root) {
-  console.error("Missing --codegen_root=...");
-  process.exit(1);
-}
-if (debug === "false" || debug === "0" || debug == "OFF") debug = false;
-
-const kit_dir = join(import.meta.dirname, "../kit");
-process.chdir(kit_dir); // to make bun build predictable in development
-
-const results = await Promise.allSettled(
-  ["client", "server"].map(async mode => {
-    let result = await Bun.build({
-      entrypoints: [join(kit_dir, "hmr-runtime.ts")],
-      define: {
-        mode: JSON.stringify(mode),
-        IS_BUN_DEVELOPMENT: String(!!debug),
-      },
-      minify: {
-        syntax: true,
-      },
-    });
-    if (!result.success) throw new AggregateError(result.logs);
-    assert(result.outputs.length === 1, "must bundle to a single file");
-    // @ts-ignore
-    let code = await result.outputs[0].text();
-
-    // A second pass is used to convert global variables into parameters, while
-    // allowing for renaming to properly function when minification is enabled.
-    const in_names = ["input_graph", "config", mode === "server" && "server_fetch_function"].filter(Boolean);
-    const combined_source = `
-    __marker__;
-    let ${in_names.join(",")};
-    __marker__(${in_names.join(",")});
-    ${code};
-  `;
-    const generated_entrypoint = join(kit_dir, `.runtime-${mode}.generated.ts`);
-
-    writeFileSync(generated_entrypoint, combined_source);
-    using _ = {
-      [Symbol.dispose]: () => {
-        try {
-          rmSync(generated_entrypoint);
-        } catch {}
-      },
-    };
-
-    result = await Bun.build({
-      entrypoints: [generated_entrypoint],
-      minify: {
-        syntax: true,
-        whitespace: !debug,
-        identifiers: !debug,
-      },
-    });
-    if (!result.success) throw new AggregateError(result.logs);
-    assert(result.outputs.length === 1, "must bundle to a single file");
-    // @ts-ignore
-    code = await result.outputs[0].text();
-
-    let names: string = "";
-    code = code
-      .replace(/(\n?)\s*__marker__.*__marker__\((.+?)\);\s*/s, (_, n, captured) => {
-        names = captured;
-        return n;
-      })
-      .replace(`// ${basename(generated_entrypoint)}`, "")
-      .trim();
-    assert(names, "missing name");
-
-    if (debug) {
-      code = "\n  " + code.replace(/\n/g, "\n  ") + "\n";
-    }
-
-    if (code[code.length - 1] === ";") code = code.slice(0, -1);
-
-    if (mode === "server") {
-      const server_fetch_function = names.split(",")[2].trim();
-      code = debug ? `${code}  return ${server_fetch_function};\n` : `${code};return ${server_fetch_function};`;
-    }
-
-    code = debug ? `((${names}) => {${code}})({\n` : `((${names})=>{${code}})({`;
-
-    if (mode === "server") {
-      code = `export default await ${code}`;
-    }
-
-    writeFileSync(join(codegen_root, `kit.${mode}.js`), code);
-  }),
-);
-
-// print failures in a de-duplicated fashion.
-interface Err {
-  kind: "client" | "server" | "both";
-  err: any;
-}
-const failed = [
-  { kind: "client", result: results[0] },
-  { kind: "server", result: results[1] },
-]
-  .filter(x => x.result.status === "rejected")
-  .map(x => ({ kind: x.kind, err: x.result.reason })) as Err[];
-if (failed.length > 0) {
-  const flattened_errors: Err[] = [];
-  for (const { kind, err } of failed) {
-    if (err instanceof AggregateError) {
-      flattened_errors.push(...err.errors.map(err => ({ kind, err })));
-    }
-    flattened_errors.push({ kind, err });
-  }
-  for (let i = 0; i < flattened_errors.length; i++) {
-    const x = flattened_errors[i];
-    if (!x.err?.message) continue;
-    for (const other of flattened_errors.slice(0, i)) {
-      if (other.err?.message === x.err.message || other.err.stack === x.err.stack) {
-        other.kind = "both";
-        flattened_errors.splice(i, 1);
-        i -= 1;
-        continue;
-      }
-    }
-  }
-  let current = "";
-  for (const { kind, err } of flattened_errors) {
-    if (kind !== current) {
-      const map = { both: "runtime", client: "client runtime", server: "server runtime" };
-      console.error(`Errors while bundling Kit ${map[kind]}:`);
-    }
-    console.error(err);
-  }
-  process.exit(1);
-} else {
-  console.log("-> kit.client.js, kit.server.js");
-
-  const empty_file = join(codegen_root, "kit_empty_file");
-  if (!existsSync(empty_file)) writeFileSync(empty_file, "this is used to fulfill a cmake dependency");
-}
diff --git a/src/codegen/replacements.ts b/src/codegen/replacements.ts
index 3d20dc4fa1..025f0f854d 100644
--- a/src/codegen/replacements.ts
+++ b/src/codegen/replacements.ts
@@ -120,7 +120,7 @@ for (const name in enums) {
   if (typeof value === null) throw new Error("Invalid enum object " + name + " defined in " + import.meta.file);
   const keys = Array.isArray(value) ? value : Object.keys(value).filter(k => !k.match(/^[0-9]+$/));
   define[`$${name}IdToLabel`] = "[" + keys.map(k => `"${k}"`).join(", ") + "]";
-  define[`$${name}LabelToId`] = "{" + keys.map(k => `"${k}": ${keys.indexOf(k)}`).join(", ") + "}";
+  define[`$${name}LabelToId`] = "{" + keys.map(k => `"${k}": ${keys.indexOf(k) + 1}`).join(", ") + "}";
 }
 
 for (const name of globalsToPrefix) {
@@ -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 67d0c0aab1..e6d9367fb6 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
@@ -137,7 +137,7 @@ const HTTP = bun.http;
 const MutableString = bun.MutableString;
 const Global = bun.Global;
 pub fn downloadToPath(this: *const CompileTarget, env: *bun.DotEnv.Loader, allocator: std.mem.Allocator, dest_z: [:0]const u8) !void {
-    HTTP.HTTPThread.init();
+    HTTP.HTTPThread.init(&.{});
     var refresher = bun.Progress{};
 
     {
@@ -170,7 +170,7 @@ pub fn downloadToPath(this: *const CompileTarget, env: *bun.DotEnv.Loader, alloc
             async_http.client.progress_node = progress;
             async_http.client.flags.reject_unauthorized = env.getTLSRejectUnauthorized();
 
-            const response = try async_http.sendSync(true);
+            const response = try async_http.sendSync();
 
             switch (response.status_code) {
                 404 => {
@@ -254,13 +254,13 @@ pub fn downloadToPath(this: *const CompileTarget, env: *bun.DotEnv.Loader, alloc
                 var node = refresher.start("Extracting", 0);
                 defer node.end();
 
-                const libarchive = @import("./libarchive//libarchive.zig");
+                const libarchive = bun.libarchive;
                 var tmpname_buf: [1024]u8 = undefined;
                 const tempdir_name = bun.span(try bun.fs.FileSystem.instance.tmpname("tmp", &tmpname_buf, bun.fastRandom()));
                 var tmpdir = try std.fs.cwd().makeOpenPath(tempdir_name, .{});
                 defer tmpdir.close();
                 defer std.fs.cwd().deleteTree(tempdir_name) catch {};
-                _ = libarchive.Archive.extractToDir(
+                _ = libarchive.Archiver.extractToDir(
                     tarball_bytes.items,
                     tmpdir,
                     null,
@@ -311,8 +311,10 @@ pub fn downloadToPath(this: *const CompileTarget, env: *bun.DotEnv.Loader, alloc
 pub fn isSupported(this: *const CompileTarget) bool {
     return switch (this.os) {
         .windows => this.arch == .x64,
+
         .mac => true,
-        .linux => this.libc == .default,
+        .linux => true,
+
         .wasm => false,
     };
 }
@@ -429,6 +431,8 @@ pub fn defineValues(this: *const CompileTarget) []const []const u8 {
                         .arm64 => "\"arm64\"",
                         else => @compileError("TODO"),
                     },
+
+                    "\"" ++ Global.package_json_version ++ "\"",
                 };
             }.values,
             else => @panic("TODO"),
diff --git a/src/comptime_string_map.zig b/src/comptime_string_map.zig
index 0dad921d9f..f5cecafc37 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,11 +187,40 @@ 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());
         }
 
+        pub fn getASCIIICaseInsensitive(input: anytype) ?V {
+            return getWithEqlLowercase(input, bun.strings.eqlComptimeIgnoreLen);
+        }
+
+        pub fn getWithEqlLowercase(input: anytype, comptime eql: anytype) ?V {
+            const Input = @TypeOf(input);
+            const length = if (@hasField(Input, "len")) input.len else input.length();
+            if (length < precomputed.min_len or length > precomputed.max_len)
+                return null;
+
+            comptime var i: usize = precomputed.min_len;
+            inline while (i <= precomputed.max_len) : (i += 1) {
+                if (length == i) {
+                    const lowerbuf: [i]u8 = brk: {
+                        var buf: [i]u8 = undefined;
+                        for (input, &buf) |c, *j| {
+                            j.* = std.ascii.toLower(c);
+                        }
+                        break :brk buf;
+                    };
+
+                    return getWithLengthAndEql(&lowerbuf, i, eql);
+                }
+            }
+
+            return null;
+        }
+
         pub fn getWithEql(input: anytype, comptime eql: anytype) ?V {
             const Input = @TypeOf(input);
             const length = if (@hasField(Input, "len")) input.len else input.length();
@@ -207,6 +237,36 @@ pub fn ComptimeStringMapWithKeyType(comptime KeyType: type, comptime V: type, co
             return null;
         }
 
+        pub fn getAnyCase(input: anytype) ?V {
+            return getCaseInsensitiveWithEql(input, bun.strings.eqlComptimeIgnoreLen);
+        }
+
+        pub fn getCaseInsensitiveWithEql(input: anytype, comptime eql: anytype) ?V {
+            const Input = @TypeOf(input);
+            const length = if (@hasField(Input, "len")) input.len else input.length();
+            if (length < precomputed.min_len or length > precomputed.max_len)
+                return null;
+
+            comptime var i: usize = precomputed.min_len;
+            inline while (i <= precomputed.max_len) : (i += 1) {
+                if (length == i) {
+                    const lowercased: [i]u8 = brk: {
+                        var buf: [i]u8 = undefined;
+                        for (input[0..i], &buf) |c, *b| {
+                            b.* = switch (c) {
+                                'A'...'Z' => c + 32,
+                                else => c,
+                            };
+                        }
+                        break :brk buf;
+                    };
+                    return getWithLengthAndEql(&lowercased, i, eql);
+                }
+            }
+
+            return null;
+        }
+
         pub fn getWithEqlList(input: anytype, comptime eql: anytype) ?V {
             const Input = @TypeOf(input);
             const length = if (@hasField(Input, "len")) input.len else input.length();
diff --git a/src/crash_handler.zig b/src/crash_handler.zig
index f7d77d3d6e..15d6821ec6 100644
--- a/src/crash_handler.zig
+++ b/src/crash_handler.zig
@@ -50,6 +50,12 @@ var panic_mutex = std.Thread.Mutex{};
 /// This is used to catch and handle panics triggered by the panic handler.
 threadlocal var panic_stage: usize = 0;
 
+threadlocal var inside_native_plugin: ?[*:0]const u8 = null;
+
+export fn CrashHandler__setInsideNativePlugin(name: ?[*:0]const u8) callconv(.C) void {
+    inside_native_plugin = name;
+}
+
 /// This can be set by various parts of the codebase to indicate a broader
 /// action being taken. It is printed when a crash happens, which can help
 /// narrow down what the bug is. Example: "Crashed while parsing /path/to/file.js"
@@ -59,6 +65,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.
@@ -132,17 +141,17 @@ pub const Action = union(enum) {
             .bundle_generate_chunk => |data| if (bun.Environment.isDebug) {
                 try writer.print(
                     \\generating bundler chunk
-                    \\  chunk entry point: {s}
-                    \\  source: {s}
+                    \\  chunk entry point: {?s}
+                    \\  source: {?s}
                     \\  part range: {d}..{d}
                 ,
                     .{
-                        data.linkerContext().graph.bundler_graph.input_files
+                        if (data.part_range.source_index.isValid()) data.linkerContext().parse_graph.input_files
                             .items(.source)[data.chunk.entry_point.source_index]
-                            .path.text,
-                        data.linkerContext().graph.bundler_graph.input_files
+                            .path.text else null,
+                        if (data.part_range.source_index.isValid()) data.linkerContext().parse_graph.input_files
                             .items(.source)[data.part_range.source_index.get()]
-                            .path.text,
+                            .path.text else null,
                         data.part_range.part_index_begin,
                         data.part_range.part_index_end,
                     },
@@ -180,6 +189,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();
@@ -216,6 +232,18 @@ pub fn crashHandler(
 
                     writer.writeAll("=" ** 60 ++ "\n") catch std.posix.abort();
                     printMetadata(writer) catch std.posix.abort();
+
+                    if (inside_native_plugin) |name| {
+                        const native_plugin_name = name;
+                        const fmt =
+                            \\
+                            \\Bun has encountered a crash while running the <red><d>"{s}"<r> native plugin.
+                            \\
+                            \\This indicates either a bug in the native plugin or in Bun.
+                            \\
+                        ;
+                        writer.print(Output.prettyFmt(fmt, true), .{native_plugin_name}) catch std.posix.abort();
+                    }
                 } else {
                     if (Output.enable_ansi_colors) {
                         writer.writeAll(Output.prettyFmt("<red>", true)) catch std.posix.abort();
@@ -298,7 +326,17 @@ pub fn crashHandler(
                         } else {
                             writer.writeAll(Output.prettyFmt(": ", true)) catch std.posix.abort();
                         }
-                        if (reason == .out_of_memory) {
+                        if (inside_native_plugin) |name| {
+                            const native_plugin_name = name;
+                            writer.print(Output.prettyFmt(
+                                \\Bun has encountered a crash while running the <red><d>"{s}"<r> native plugin.
+                                \\
+                                \\To send a redacted crash report to Bun's team,
+                                \\please file a GitHub issue using the link below:
+                                \\
+                                \\
+                            , true), .{native_plugin_name}) catch std.posix.abort();
+                        } else if (reason == .out_of_memory) {
                             writer.writeAll(
                                 \\Bun has ran out of memory.
                                 \\
@@ -840,8 +878,7 @@ pub fn printMetadata(writer: anytype) !void {
     {
         const platform = bun.Analytics.GenerateHeader.GeneratePlatform.forOS();
         const cpu_features = CPUFeatures.get();
-        if (bun.Environment.isLinux) {
-            // TODO: musl
+        if (bun.Environment.isLinux and !bun.Environment.isMusl) {
             const version = gnu_get_libc_version() orelse "";
             const kernel_version = bun.Analytics.GenerateHeader.GeneratePlatform.kernelVersion();
             if (platform.os == .wsl) {
@@ -849,6 +886,9 @@ pub fn printMetadata(writer: anytype) !void {
             } else {
                 try writer.print("Linux Kernel v{d}.{d}.{d} | glibc v{s}\n", .{ kernel_version.major, kernel_version.minor, kernel_version.patch, bun.sliceTo(version, 0) });
             }
+        } else if (bun.Environment.isLinux and bun.Environment.isMusl) {
+            const kernel_version = bun.Analytics.GenerateHeader.GeneratePlatform.kernelVersion();
+            try writer.print("Linux Kernel v{d}.{d}.{d} | musl\n", .{ kernel_version.major, kernel_version.minor, kernel_version.patch });
         } else if (bun.Environment.isMac) {
             try writer.print("macOS v{s}\n", .{platform.version});
         } else if (bun.Environment.isWindows) {
@@ -1437,63 +1477,70 @@ fn crash() noreturn {
 
 pub var verbose_error_trace = false;
 
-fn handleErrorReturnTraceExtra(err: anyerror, maybe_trace: ?*std.builtin.StackTrace, comptime is_root: bool) void {
+noinline fn coldHandleErrorReturnTrace(err_int_workaround_for_zig_ccall_bug: std.meta.Int(.unsigned, @bitSizeOf(anyerror)), trace: *std.builtin.StackTrace, comptime is_root: bool) void {
+    @setCold(true);
+    const err = @errorFromInt(err_int_workaround_for_zig_ccall_bug);
+
+    // The format of the panic trace is slightly different in debug
+    // builds Mainly, we demangle the backtrace immediately instead
+    // of using a trace string.
+    //
+    // To make the release-mode behavior easier to demo, debug mode
+    // checks for this CLI flag.
+    const is_debug = bun.Environment.isDebug and check_flag: {
+        for (bun.argv) |arg| {
+            if (bun.strings.eqlComptime(arg, "--debug-crash-handler-use-trace-string")) {
+                break :check_flag false;
+            }
+        }
+        break :check_flag true;
+    };
+
+    if (is_debug) {
+        if (is_root) {
+            if (verbose_error_trace) {
+                Output.note("Release build will not have this trace by default:", .{});
+            }
+        } else {
+            Output.note(
+                "caught error.{s}:",
+                .{@errorName(err)},
+            );
+        }
+        Output.flush();
+        dumpStackTrace(trace.*);
+    } else {
+        const ts = TraceString{
+            .trace = trace,
+            .reason = .{ .zig_error = err },
+            .action = .view_trace,
+        };
+        if (is_root) {
+            Output.prettyErrorln(
+                \\
+                \\To send a redacted crash report to Bun's team,
+                \\please file a GitHub issue using the link below:
+                \\
+                \\ <cyan>{}<r>
+                \\
+            ,
+                .{ts},
+            );
+        } else {
+            Output.prettyErrorln(
+                "<cyan>trace<r>: error.{s}: <d>{}<r>",
+                .{ @errorName(err), ts },
+            );
+        }
+    }
+}
+
+inline fn handleErrorReturnTraceExtra(err: anyerror, maybe_trace: ?*std.builtin.StackTrace, comptime is_root: bool) void {
     if (!builtin.have_error_return_tracing) return;
     if (!verbose_error_trace and !is_root) return;
 
     if (maybe_trace) |trace| {
-        // The format of the panic trace is slightly different in debug
-        // builds Mainly, we demangle the backtrace immediately instead
-        // of using a trace string.
-        //
-        // To make the release-mode behavior easier to demo, debug mode
-        // checks for this CLI flag.
-        const is_debug = bun.Environment.isDebug and check_flag: {
-            for (bun.argv) |arg| {
-                if (bun.strings.eqlComptime(arg, "--debug-crash-handler-use-trace-string")) {
-                    break :check_flag false;
-                }
-            }
-            break :check_flag true;
-        };
-
-        if (is_debug) {
-            if (is_root) {
-                if (verbose_error_trace) {
-                    Output.note("Release build will not have this trace by default:", .{});
-                }
-            } else {
-                Output.note(
-                    "caught error.{s}:",
-                    .{@errorName(err)},
-                );
-            }
-            Output.flush();
-            dumpStackTrace(trace.*);
-        } else {
-            const ts = TraceString{
-                .trace = trace,
-                .reason = .{ .zig_error = err },
-                .action = .view_trace,
-            };
-            if (is_root) {
-                Output.prettyErrorln(
-                    \\
-                    \\To send a redacted crash report to Bun's team,
-                    \\please file a GitHub issue using the link below:
-                    \\
-                    \\ <cyan>{}<r>
-                    \\
-                ,
-                    .{ts},
-                );
-            } else {
-                Output.prettyErrorln(
-                    "<cyan>trace<r>: error.{s}: <d>{}<r>",
-                    .{ @errorName(err), ts },
-                );
-            }
-        }
+        coldHandleErrorReturnTrace(@intFromError(err), trace, is_root);
     }
 }
 
@@ -1513,6 +1560,7 @@ const stdDumpStackTrace = debug.dumpStackTrace;
 /// Version of the standard library dumpStackTrace that has some fallbacks for
 /// cases where such logic fails to run.
 pub fn dumpStackTrace(trace: std.builtin.StackTrace) void {
+    Output.flush();
     const stderr = std.io.getStdErr().writer();
     if (!bun.Environment.isDebug) {
         // debug symbols aren't available, lets print a tracestring
@@ -1520,7 +1568,7 @@ pub fn dumpStackTrace(trace: std.builtin.StackTrace) void {
             .action = .view_trace,
             .reason = .{ .zig_error = error.DumpStackTrace },
             .trace = &trace,
-        }});
+        }}) catch {};
         return;
     }
 
@@ -1601,6 +1649,49 @@ pub fn dumpStackTrace(trace: std.builtin.StackTrace) void {
     stderr.writeAll(proc.stderr) catch return;
 }
 
+/// A variant of `std.builtin.StackTrace` that stores its data within itself
+/// instead of being a pointer. This allows storing captured stack traces
+/// for later printing.
+pub const StoredTrace = struct {
+    data: [31]usize,
+    index: usize,
+
+    pub const empty: StoredTrace = .{
+        .data = .{0} ** 31,
+        .index = 0,
+    };
+
+    pub fn trace(stored: *StoredTrace) std.builtin.StackTrace {
+        return .{
+            .index = stored.index,
+            .instruction_addresses = &stored.data,
+        };
+    }
+
+    pub fn capture(begin: ?usize) StoredTrace {
+        var stored: StoredTrace = StoredTrace.empty;
+        var frame = stored.trace();
+        std.debug.captureStackTrace(begin orelse @returnAddress(), &frame);
+        stored.index = frame.index;
+        return stored;
+    }
+
+    pub fn from(stack_trace: ?*std.builtin.StackTrace) StoredTrace {
+        if (stack_trace) |stack| {
+            var data: [31]usize = undefined;
+            @memset(&data, 0);
+            const items = @min(stack.instruction_addresses.len, 31);
+            @memcpy(data[0..items], stack.instruction_addresses[0..items]);
+            return .{
+                .data = data,
+                .index = @min(items, stack.index),
+            };
+        } else {
+            return empty;
+        }
+    }
+};
+
 pub const js_bindings = struct {
     const JSC = bun.JSC;
     const JSValue = JSC.JSValue;
@@ -1624,7 +1715,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;
@@ -1634,7 +1725,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;
@@ -1642,23 +1733,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 {
@@ -1669,7 +1760,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);
@@ -1688,3 +1779,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/README.md b/src/css/README.md
new file mode 100644
index 0000000000..75b7dead60
--- /dev/null
+++ b/src/css/README.md
@@ -0,0 +1,3 @@
+# CSS
+
+This is the code for Bun's experimental CSS parser. This code is derived from the [Lightning CSS](https://github.com/parcel-bundler/lightningcss) (huge, huge thanks to Devon Govett and contributors) project and the [Servo](https://github.com/servo/servo) project.
diff --git a/src/css/build-prefixes.js b/src/css/build-prefixes.js
new file mode 100644
index 0000000000..bb36e78669
--- /dev/null
+++ b/src/css/build-prefixes.js
@@ -0,0 +1,745 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// const { execSync } = require("child_process");
+const prefixes = require("autoprefixer/data/prefixes");
+const browsers = require("caniuse-lite").agents;
+const unpack = require("caniuse-lite").feature;
+const features = require("caniuse-lite").features;
+const mdn = require("@mdn/browser-compat-data");
+const fs = require("fs");
+
+const BROWSER_MAPPING = {
+  and_chr: "chrome",
+  and_ff: "firefox",
+  ie_mob: "ie",
+  op_mob: "opera",
+  and_qq: null,
+  and_uc: null,
+  baidu: null,
+  bb: null,
+  kaios: null,
+  op_mini: null,
+  oculus: null,
+};
+
+const MDN_BROWSER_MAPPING = {
+  chrome_android: "chrome",
+  firefox_android: "firefox",
+  opera_android: "opera",
+  safari_ios: "ios_saf",
+  samsunginternet_android: "samsung",
+  webview_android: "android",
+  oculus: null,
+};
+
+const latestBrowserVersions = {};
+for (let b in browsers) {
+  let versions = browsers[b].versions.slice(-10);
+  for (let i = versions.length - 1; i >= 0; i--) {
+    if (versions[i] != null && versions[i] != "all" && versions[i] != "TP") {
+      latestBrowserVersions[b] = versions[i];
+      break;
+    }
+  }
+}
+
+// Caniuse data for clip-path is incorrect.
+// https://github.com/Fyrd/caniuse/issues/6209
+prefixes["clip-path"].browsers = prefixes["clip-path"].browsers.filter(b => {
+  let [name, version] = b.split(" ");
+  return !(
+    (name === "safari" && parseVersion(version) >= ((9 << 16) | (1 << 8))) ||
+    (name === "ios_saf" && parseVersion(version) >= ((9 << 16) | (3 << 8)))
+  );
+});
+
+prefixes["any-pseudo"] = {
+  browsers: Object.entries(mdn.css.selectors.is.__compat.support).flatMap(([key, value]) => {
+    if (Array.isArray(value)) {
+      key = MDN_BROWSER_MAPPING[key] || key;
+      let any = value.find(v => v.alternative_name?.includes("-any"))?.version_added;
+      let supported = value.find(x => x.version_added && !x.alternative_name)?.version_added;
+      if (any && supported) {
+        let parts = supported.split(".");
+        parts[0]--;
+        supported = parts.join(".");
+        return [`${key} ${any}}`, `${key} ${supported}`];
+      }
+    }
+
+    return [];
+  }),
+};
+
+let flexSpec = {};
+let oldGradient = {};
+let p = new Map();
+for (let prop in prefixes) {
+  let browserMap = {};
+  for (let b of prefixes[prop].browsers) {
+    let [name, version, variant] = b.split(" ");
+    if (BROWSER_MAPPING[name] === null) {
+      continue;
+    }
+    let prefix = browsers[name].prefix_exceptions?.[version] || browsers[name].prefix;
+
+    // https://github.com/postcss/autoprefixer/blob/main/lib/hacks/backdrop-filter.js#L11
+    if (prefix === "ms" && prop === "backdrop-filter") {
+      prefix = "webkit";
+    }
+
+    let origName = name;
+    let isCurrentVersion = version === latestBrowserVersions[name];
+    name = BROWSER_MAPPING[name] || name;
+    let v = parseVersion(version);
+    if (v == null) {
+      console.log("BAD VERSION", prop, name, version);
+      continue;
+    }
+    if (browserMap[name]?.[prefix] == null) {
+      browserMap[name] = browserMap[name] || {};
+      browserMap[name][prefix] =
+        prefixes[prop].browsers.filter(b => b.startsWith(origName) || b.startsWith(name)).length === 1
+          ? isCurrentVersion
+            ? [null, null]
+            : [null, v]
+          : isCurrentVersion
+            ? [v, null]
+            : [v, v];
+    } else {
+      if (v < browserMap[name][prefix][0]) {
+        browserMap[name][prefix][0] = v;
+      }
+
+      if (isCurrentVersion && browserMap[name][prefix][0] != null) {
+        browserMap[name][prefix][1] = null;
+      } else if (v > browserMap[name][prefix][1] && browserMap[name][prefix][1] != null) {
+        browserMap[name][prefix][1] = v;
+      }
+    }
+
+    if (variant === "2009") {
+      if (flexSpec[name] == null) {
+        flexSpec[name] = [v, v];
+      } else {
+        if (v < flexSpec[name][0]) {
+          flexSpec[name][0] = v;
+        }
+
+        if (v > flexSpec[name][1]) {
+          flexSpec[name][1] = v;
+        }
+      }
+    } else if (variant === "old" && prop.includes("gradient")) {
+      if (oldGradient[name] == null) {
+        oldGradient[name] = [v, v];
+      } else {
+        if (v < oldGradient[name][0]) {
+          oldGradient[name][0] = v;
+        }
+
+        if (v > oldGradient[name][1]) {
+          oldGradient[name][1] = v;
+        }
+      }
+    }
+  }
+  addValue(p, browserMap, prop);
+}
+
+function addValue(map, value, prop) {
+  let s = JSON.stringify(value);
+  let found = false;
+  for (let [key, val] of map) {
+    if (JSON.stringify(val) === s) {
+      key.push(prop);
+      found = true;
+      break;
+    }
+  }
+  if (!found) {
+    map.set([prop], value);
+  }
+}
+
+let cssFeatures = [
+  "css-sel2",
+  "css-sel3",
+  "css-gencontent",
+  "css-first-letter",
+  "css-first-line",
+  "css-in-out-of-range",
+  "form-validation",
+  "css-any-link",
+  "css-default-pseudo",
+  "css-dir-pseudo",
+  "css-focus-within",
+  "css-focus-visible",
+  "css-indeterminate-pseudo",
+  "css-matches-pseudo",
+  "css-optional-pseudo",
+  "css-placeholder-shown",
+  "dialog",
+  "fullscreen",
+  "css-marker-pseudo",
+  "css-placeholder",
+  "css-selection",
+  "css-case-insensitive",
+  "css-read-only-write",
+  "css-autofill",
+  "css-namespaces",
+  "shadowdomv1",
+  "css-rrggbbaa",
+  "css-nesting",
+  "css-not-sel-list",
+  "css-has",
+  "font-family-system-ui",
+  "extended-system-fonts",
+  "calc",
+];
+
+let cssFeatureMappings = {
+  "css-dir-pseudo": "DirSelector",
+  "css-rrggbbaa": "HexAlphaColors",
+  "css-not-sel-list": "NotSelectorList",
+  "css-has": "HasSelector",
+  "css-matches-pseudo": "IsSelector",
+  "css-sel2": "Selectors2",
+  "css-sel3": "Selectors3",
+  "calc": "CalcFunction",
+};
+
+let cssFeatureOverrides = {
+  // Safari supports the ::marker pseudo element, but only supports styling some properties.
+  // However this does not break using the selector itself, so ignore for our purposes.
+  // https://bugs.webkit.org/show_bug.cgi?id=204163
+  // https://github.com/parcel-bundler/lightningcss/issues/508
+  "css-marker-pseudo": {
+    safari: {
+      "y #1": "y",
+    },
+  },
+};
+
+let compat = new Map();
+for (let feature of cssFeatures) {
+  let data = unpack(features[feature]);
+  let overrides = cssFeatureOverrides[feature];
+  let browserMap = {};
+  for (let name in data.stats) {
+    if (BROWSER_MAPPING[name] === null) {
+      continue;
+    }
+
+    name = BROWSER_MAPPING[name] || name;
+    let browserOverrides = overrides?.[name];
+    for (let version in data.stats[name]) {
+      let value = data.stats[name][version];
+      value = browserOverrides?.[value] || value;
+      if (value === "y") {
+        let v = parseVersion(version);
+        if (v == null) {
+          console.log("BAD VERSION", feature, name, version);
+          continue;
+        }
+
+        if (browserMap[name] == null || v < browserMap[name]) {
+          browserMap[name] = v;
+        }
+      }
+    }
+  }
+
+  let name = (cssFeatureMappings[feature] || feature).replace(/^css-/, "");
+  addValue(compat, browserMap, name);
+}
+
+// No browser supports custom media queries yet.
+addValue(compat, {}, "custom-media-queries");
+
+let mdnFeatures = {
+  doublePositionGradients: mdn.css.types.image.gradient["radial-gradient"].doubleposition.__compat.support,
+  clampFunction: mdn.css.types.clamp.__compat.support,
+  placeSelf: mdn.css.properties["place-self"].__compat.support,
+  placeContent: mdn.css.properties["place-content"].__compat.support,
+  placeItems: mdn.css.properties["place-items"].__compat.support,
+  overflowShorthand: mdn.css.properties["overflow"].multiple_keywords.__compat.support,
+  mediaRangeSyntax: mdn.css["at-rules"].media.range_syntax.__compat.support,
+  mediaIntervalSyntax: Object.fromEntries(
+    Object.entries(mdn.css["at-rules"].media.range_syntax.__compat.support).map(([browser, value]) => {
+      // Firefox supported only ranges and not intervals for a while.
+      if (Array.isArray(value)) {
+        value = value.filter(v => !v.partial_implementation);
+      } else if (value.partial_implementation) {
+        value = undefined;
+      }
+
+      return [browser, value];
+    }),
+  ),
+  logicalBorders: mdn.css.properties["border-inline-start"].__compat.support,
+  logicalBorderShorthand: mdn.css.properties["border-inline"].__compat.support,
+  logicalBorderRadius: mdn.css.properties["border-start-start-radius"].__compat.support,
+  logicalMargin: mdn.css.properties["margin-inline-start"].__compat.support,
+  logicalMarginShorthand: mdn.css.properties["margin-inline"].__compat.support,
+  logicalPadding: mdn.css.properties["padding-inline-start"].__compat.support,
+  logicalPaddingShorthand: mdn.css.properties["padding-inline"].__compat.support,
+  logicalInset: mdn.css.properties["inset-inline-start"].__compat.support,
+  logicalSize: mdn.css.properties["inline-size"].__compat.support,
+  logicalTextAlign: mdn.css.properties["text-align"].start.__compat.support,
+  labColors: mdn.css.types.color.lab.__compat.support,
+  oklabColors: mdn.css.types.color.oklab.__compat.support,
+  colorFunction: mdn.css.types.color.color.__compat.support,
+  spaceSeparatedColorNotation: mdn.css.types.color.rgb.space_separated_parameters.__compat.support,
+  textDecorationThicknessPercent: mdn.css.properties["text-decoration-thickness"].percentage.__compat.support,
+  textDecorationThicknessShorthand: mdn.css.properties["text-decoration"].includes_thickness.__compat.support,
+  cue: mdn.css.selectors.cue.__compat.support,
+  cueFunction: mdn.css.selectors.cue.selector_argument.__compat.support,
+  anyPseudo: Object.fromEntries(
+    Object.entries(mdn.css.selectors.is.__compat.support).map(([key, value]) => {
+      if (Array.isArray(value)) {
+        value = value.filter(v => v.alternative_name?.includes("-any")).map(({ alternative_name, ...other }) => other);
+      }
+
+      if (value && value.length) {
+        return [key, value];
+      } else {
+        return [key, { version_added: false }];
+      }
+    }),
+  ),
+  partPseudo: mdn.css.selectors.part.__compat.support,
+  imageSet: mdn.css.types.image["image-set"].__compat.support,
+  xResolutionUnit: mdn.css.types.resolution.x.__compat.support,
+  nthChildOf: mdn.css.selectors["nth-child"].of_syntax.__compat.support,
+  minFunction: mdn.css.types.min.__compat.support,
+  maxFunction: mdn.css.types.max.__compat.support,
+  roundFunction: mdn.css.types.round.__compat.support,
+  remFunction: mdn.css.types.rem.__compat.support,
+  modFunction: mdn.css.types.mod.__compat.support,
+  absFunction: mdn.css.types.abs.__compat.support,
+  signFunction: mdn.css.types.sign.__compat.support,
+  hypotFunction: mdn.css.types.hypot.__compat.support,
+  gradientInterpolationHints: mdn.css.types.image.gradient["linear-gradient"].interpolation_hints.__compat.support,
+  borderImageRepeatRound: mdn.css.properties["border-image-repeat"].round.__compat.support,
+  borderImageRepeatSpace: mdn.css.properties["border-image-repeat"].space.__compat.support,
+  fontSizeRem: mdn.css.properties["font-size"].rem_values.__compat.support,
+  fontSizeXXXLarge: mdn.css.properties["font-size"]["xxx-large"].__compat.support,
+  fontStyleObliqueAngle: mdn.css.properties["font-style"]["oblique-angle"].__compat.support,
+  fontWeightNumber: mdn.css.properties["font-weight"].number.__compat.support,
+  fontStretchPercentage: mdn.css.properties["font-stretch"].percentage.__compat.support,
+  lightDark: mdn.css.types.color["light-dark"].__compat.support,
+  accentSystemColor: mdn.css.types.color["system-color"].accentcolor_accentcolortext.__compat.support,
+  animationTimelineShorthand: mdn.css.properties.animation["animation-timeline_included"].__compat.support,
+};
+
+for (let key in mdn.css.types.length) {
+  if (key === "__compat") {
+    continue;
+  }
+
+  let feat = key.includes("_") ? key.replace(/_([a-z])/g, (_, l) => l.toUpperCase()) : key + "Unit";
+
+  mdnFeatures[feat] = mdn.css.types.length[key].__compat.support;
+}
+
+for (let key in mdn.css.types.image.gradient) {
+  if (key === "__compat") {
+    continue;
+  }
+
+  let feat = key.replace(/-([a-z])/g, (_, l) => l.toUpperCase());
+  mdnFeatures[feat] = mdn.css.types.image.gradient[key].__compat.support;
+}
+
+const nonStandardListStyleType = new Set([
+  // https://developer.mozilla.org/en-US/docs/Web/CSS/list-style-type#non-standard_extensions
+  "ethiopic-halehame",
+  "ethiopic-halehame-am",
+  "ethiopic-halehame-ti-er",
+  "ethiopic-halehame-ti-et",
+  "hangul",
+  "hangul-consonant",
+  "urdu",
+  "cjk-ideographic",
+  // https://github.com/w3c/csswg-drafts/issues/135
+  "upper-greek",
+]);
+
+for (let key in mdn.css.properties["list-style-type"]) {
+  if (
+    key === "__compat" ||
+    nonStandardListStyleType.has(key) ||
+    mdn.css.properties["list-style-type"][key].__compat.support.chrome.version_removed
+  ) {
+    continue;
+  }
+
+  let feat = key[0].toUpperCase() + key.slice(1).replace(/-([a-z])/g, (_, l) => l.toUpperCase()) + "ListStyleType";
+  mdnFeatures[feat] = mdn.css.properties["list-style-type"][key].__compat.support;
+}
+
+for (let key in mdn.css.properties["width"]) {
+  if (key === "__compat" || key === "animatable") {
+    continue;
+  }
+
+  let feat = key[0].toUpperCase() + key.slice(1).replace(/[-_]([a-z])/g, (_, l) => l.toUpperCase()) + "Size";
+  mdnFeatures[feat] = mdn.css.properties["width"][key].__compat.support;
+}
+
+Object.entries(mdn.css.properties.width.stretch.__compat.support)
+  .filter(([, v]) => v.alternative_name)
+  .forEach(([k, v]) => {
+    let name = v.alternative_name.slice(1).replace(/[-_]([a-z])/g, (_, l) => l.toUpperCase()) + "Size";
+    mdnFeatures[name] ??= {};
+    mdnFeatures[name][k] = { version_added: v.version_added };
+  });
+
+for (let feature in mdnFeatures) {
+  let browserMap = {};
+  for (let name in mdnFeatures[feature]) {
+    if (MDN_BROWSER_MAPPING[name] === null) {
+      continue;
+    }
+
+    let feat = mdnFeatures[feature][name];
+    let version;
+    if (Array.isArray(feat)) {
+      version = feat
+        .filter(x => x.version_added && !x.alternative_name && !x.flags)
+        .sort((a, b) => (parseVersion(a.version_added) < parseVersion(b.version_added) ? -1 : 1))[0].version_added;
+    } else if (!feat.alternative_name && !feat.flags) {
+      version = feat.version_added;
+    }
+
+    if (!version) {
+      continue;
+    }
+
+    let v = parseVersion(version);
+    if (v == null) {
+      console.log("BAD VERSION", feature, name, version);
+      continue;
+    }
+
+    name = MDN_BROWSER_MAPPING[name] || name;
+    browserMap[name] = v;
+  }
+
+  addValue(compat, browserMap, feature);
+}
+
+addValue(
+  compat,
+  {
+    safari: parseVersion("10.1"),
+    ios_saf: parseVersion("10.3"),
+  },
+  "p3Colors",
+);
+
+addValue(
+  compat,
+  {
+    // https://github.com/WebKit/WebKit/commit/baed0d8b0abf366e1d9a6105dc378c59a5f21575
+    safari: parseVersion("10.1"),
+    ios_saf: parseVersion("10.3"),
+  },
+  "LangSelectorList",
+);
+
+let prefixMapping = {
+  webkit: "webkit",
+  moz: "moz",
+  ms: "ms",
+  o: "o",
+};
+
+let flags = [
+  "nesting",
+  "not_selector_list",
+  "dir_selector",
+  "lang_selector_list",
+  "is_selector",
+  "text_decoration_thickness_percent",
+  "media_interval_syntax",
+  "media_range_syntax",
+  "custom_media_queries",
+  "clamp_function",
+  "color_function",
+  "oklab_colors",
+  "lab_colors",
+  "p3_colors",
+  "hex_alpha_colors",
+  "space_separated_color_notation",
+  "font_family_system_ui",
+  "double_position_gradients",
+  "vendor_prefixes",
+  "logical_properties",
+  ["selectors", ["nesting", "not_selector_list", "dir_selector", "lang_selector_list", "is_selector"]],
+  ["media_queries", ["media_interval_syntax", "media_range_syntax", "custom_media_queries"]],
+  [
+    "colors",
+    ["color_function", "oklab_colors", "lab_colors", "p3_colors", "hex_alpha_colors", "space_separated_color_notation"],
+  ],
+];
+
+function snakecase(str) {
+  let s = "";
+  for (let i = 0; i < str.length; i++) {
+    let c = str[i].charCodeAt(0);
+    if (c === "-") {
+      s += "_";
+    } else {
+      if (i > 0 && c >= 65 && c <= 90) {
+        s += "_";
+      }
+      s += str[i].toLowerCase();
+    }
+  }
+  return s;
+}
+
+let enumify = f =>
+  snakecase(
+    f
+      .replace(/^@([a-z])/, (_, x) => "at_" + x)
+      .replace(/^::([a-z])/, (_, x) => "pseudo_element_" + x)
+      .replace(/^:([a-z])/, (_, x) => "pseudo_class_" + x)
+      // .replace(/(^|-)([a-z])/g, (_, a, x) => (a === "-" ? "_" + x : x));
+      .replace(/(^|-)([a-z])/g, (_, a, x) => (a === "-" ? "_" + x : x)),
+  );
+
+let allBrowsers = Object.keys(browsers)
+  .filter(b => !(b in BROWSER_MAPPING))
+  .sort();
+let browsersZig = `pub const Browsers = struct {
+  ${allBrowsers.join(": ?u32 = null,\n")}: ?u32 = null,
+    pub usingnamespace BrowsersImpl(@This());
+}`;
+let flagsZig = `pub const Features = packed struct(u32) {
+    ${flags
+      .map((flag, i) => {
+        if (Array.isArray(flag)) {
+          // return `const ${flag[0]} = ${flag[1].map(f => `Self::${f}.bits()`).join(" | ")};`;
+          return `const ${flag[0]} = Features.fromNames(${flag[1].map(f => `"${f}"`).join(", ")});`;
+        } else {
+          return `${flag}: bool = 1 << ${i},`;
+        }
+      })
+      .join("\n    ")}
+
+      pub usingnamespace css.Bitflags(@This());
+      pub usingnamespace FeaturesImpl(@This());
+  }`;
+let targets = fs
+  .readFileSync("src/css/targets.zig", "utf8")
+  .replace(/pub const Browsers = struct \{((?:.|\n)+?)\}/, browsersZig)
+  .replace(/pub const Features = packed struct\(u32\) \{((?:.|\n)+?)\}/, flagsZig);
+
+console.log("TARGETS", targets);
+fs.writeFileSync("src/css/targets.zig", targets);
+await Bun.$`zig fmt src/css/targets.zig`;
+
+let targets_dts = `// This file is autogenerated by build-prefixes.js. DO NOT EDIT!
+
+export interface Targets {
+  ${allBrowsers.join("?: number,\n  ")}?: number
+}
+
+export const Features: {
+  ${flags
+    .map((flag, i) => {
+      if (Array.isArray(flag)) {
+        return `${flag[0]}: ${flag[1].reduce((p, f) => p | (1 << flags.indexOf(f)), 0)},`;
+      } else {
+        return `${flag}: ${1 << i},`;
+      }
+    })
+    .join("\n  ")}
+};
+`;
+
+// fs.writeFileSync("node/targets.d.ts", targets_dts);
+
+let flagsJs = `// This file is autogenerated by build-prefixes.js. DO NOT EDIT!
+
+exports.Features = {
+  ${flags
+    .map((flag, i) => {
+      if (Array.isArray(flag)) {
+        return `${flag[0]}: ${flag[1].reduce((p, f) => p | (1 << flags.indexOf(f)), 0)},`;
+      } else {
+        return `${flag}: ${1 << i},`;
+      }
+    })
+    .join("\n  ")}
+};
+`;
+
+// fs.writeFileSync("node/flags.js", flagsJs);
+
+let s = `// This file is autogenerated by build-prefixes.js. DO NOT EDIT!
+
+const css = @import("./css_parser.zig");
+const VendorPrefix = css.VendorPrefix;
+const Browsers = css.targets.Browsers;
+
+pub const Feature = enum {
+  ${[...p.keys()].flat().map(enumify).sort().join(",\n  ")},
+
+  pub fn prefixesFor(this: *const Feature, browsers: Browsers) VendorPrefix {
+    var prefixes = VendorPrefix{ .none = true };
+    switch (this.*) {
+      ${[...p]
+        .map(([features, versions]) => {
+          return `${features.map(name => `.${enumify(name)}`).join(" ,\n      ")} => {
+        ${Object.entries(versions)
+          .map(([name, prefixes]) => {
+            let needsVersion = !Object.values(prefixes).every(([min, max]) => min == null && max == null);
+            return `if ${needsVersion ? `(browsers.${name}) |version|` : `(browsers.${name} != null)`} {
+          ${Object.entries(prefixes)
+            .map(([prefix, [min, max]]) => {
+              if (!prefixMapping[prefix]) {
+                throw new Error("Missing prefix " + prefix);
+              }
+              let addPrefix = `prefixes = prefixes.bitwiseOr(VendorPrefix{.${prefixMapping[prefix]} = true });`;
+              let condition;
+              if (min == null && max == null) {
+                return addPrefix;
+              } else if (min == null) {
+                condition = `version <= ${max}`;
+              } else if (max == null) {
+                condition = `version >= ${min}`;
+              } else if (min == max) {
+                condition = `version == ${min}`;
+              } else {
+                condition = `version >= ${min} and version <= ${max}`;
+              }
+
+              return `if (${condition}) {
+            ${addPrefix}
+          }`;
+            })
+            .join("\n          ")}
+        }`;
+          })
+          .join("\n        ")}
+      }`;
+        })
+        .join(",\n      ")}
+    }
+    return prefixes;
+  }
+
+pub fn isFlex2009(browsers: Browsers) bool {
+  ${Object.entries(flexSpec)
+    .map(([name, [min, max]]) => {
+      return `if (browsers.${name}) |version| {
+    if (version >= ${min} and version <= ${max}) {
+      return true;
+    }
+  }`;
+    })
+    .join("\n  ")}
+  return false;
+}
+
+pub fn isWebkitGradient(browsers: Browsers) bool {
+  ${Object.entries(oldGradient)
+    .map(([name, [min, max]]) => {
+      return `if (browsers.${name}) |version| {
+    if (version >= ${min} and version <= ${max}) {
+      return true;
+    }
+  }`;
+    })
+    .join("\n  ")}
+  return false;
+}
+};
+`;
+
+fs.writeFileSync("src/css/prefixes.zig", s);
+await Bun.$`zig fmt src/css/prefixes.zig`;
+
+let c = `// This file is autogenerated by build-prefixes.js. DO NOT EDIT!
+
+const Browsers = @import("./targets.zig").Browsers;
+
+pub const Feature = enum {
+  ${[...compat.keys()].flat().map(enumify).sort().join(",\n  ")},
+
+  pub fn isCompatible(this: *const Feature, browsers: Browsers) bool {
+    switch (this.*) {
+      ${[...compat]
+        .map(
+          ([features, supportedBrowsers]) =>
+            `${features.map(name => `.${enumify(name)}`).join(" ,\n      ")} => {` +
+            (Object.entries(supportedBrowsers).length === 0
+              ? "\n        return false;\n      },"
+              : `
+        ${Object.entries(supportedBrowsers)
+          .map(
+            ([browser, min]) =>
+              `if (browsers.${browser}) |version| {
+          if (version < ${min}) {
+            return false;
+          }
+        }`,
+          )
+          .join("\n        ")}${
+          Object.keys(supportedBrowsers).length === allBrowsers.length
+            ? ""
+            : `\n        if (${allBrowsers
+                .filter(b => !supportedBrowsers[b])
+                .map(browser => `browsers.${browser} != null`)
+                .join(" or ")}) {
+          return false;
+        }`
+        }
+      },`),
+        )
+        .join("\n      ")}
+    }
+    return true;
+  }
+
+
+pub fn isPartiallyCompatible(this: *const Feature, targets: Browsers) bool {
+  var browsers = Browsers{};
+  ${allBrowsers
+    .map(
+      browser => `if (targets.${browser} != null) {
+    browsers.${browser} = targets.${browser};
+    if (this.isCompatible(browsers)) {
+      return true;
+    }
+    browsers.${browser} = null;
+  }\n`,
+    )
+    .join("    ")}
+  return false;
+}
+};
+`;
+
+fs.writeFileSync("src/css/compat.zig", c);
+await Bun.$`zig fmt src/css/compat.zig`;
+
+function parseVersion(version) {
+  version = version.replace("≤", "");
+  let [major, minor = "0", patch = "0"] = version
+    .split("-")[0]
+    .split(".")
+    .map(v => parseInt(v, 10));
+
+  if (isNaN(major) || isNaN(minor) || isNaN(patch)) {
+    return null;
+  }
+
+  return (major << 16) | (minor << 8) | patch;
+}
diff --git a/src/css/compat.zig b/src/css/compat.zig
new file mode 100644
index 0000000000..7d94f023d8
--- /dev/null
+++ b/src/css/compat.zig
@@ -0,0 +1,5407 @@
+// This file is autogenerated by build-prefixes.js. DO NOT EDIT!
+
+const Browsers = @import("./targets.zig").Browsers;
+
+pub const Feature = enum {
+    abs_function,
+    accent_system_color,
+    afar_list_style_type,
+    amharic_abegede_list_style_type,
+    amharic_list_style_type,
+    anchor_size_size,
+    animation_timeline_shorthand,
+    any_link,
+    any_pseudo,
+    arabic_indic_list_style_type,
+    armenian_list_style_type,
+    asterisks_list_style_type,
+    auto_size,
+    autofill,
+    bengali_list_style_type,
+    binary_list_style_type,
+    border_image_repeat_round,
+    border_image_repeat_space,
+    calc_function,
+    cambodian_list_style_type,
+    cap_unit,
+    case_insensitive,
+    ch_unit,
+    circle_list_style_type,
+    cjk_decimal_list_style_type,
+    cjk_earthly_branch_list_style_type,
+    cjk_heavenly_stem_list_style_type,
+    clamp_function,
+    color_function,
+    conic_gradient,
+    container_query_length_units,
+    cue,
+    cue_function,
+    custom_media_queries,
+    decimal_leading_zero_list_style_type,
+    decimal_list_style_type,
+    default_pseudo,
+    devanagari_list_style_type,
+    dialog,
+    dir_selector,
+    disc_list_style_type,
+    disclosure_closed_list_style_type,
+    disclosure_open_list_style_type,
+    double_position_gradients,
+    em_unit,
+    ethiopic_abegede_am_et_list_style_type,
+    ethiopic_abegede_gez_list_style_type,
+    ethiopic_abegede_list_style_type,
+    ethiopic_abegede_ti_er_list_style_type,
+    ethiopic_abegede_ti_et_list_style_type,
+    ethiopic_halehame_aa_er_list_style_type,
+    ethiopic_halehame_aa_et_list_style_type,
+    ethiopic_halehame_am_et_list_style_type,
+    ethiopic_halehame_gez_list_style_type,
+    ethiopic_halehame_om_et_list_style_type,
+    ethiopic_halehame_sid_et_list_style_type,
+    ethiopic_halehame_so_et_list_style_type,
+    ethiopic_halehame_tig_list_style_type,
+    ethiopic_list_style_type,
+    ethiopic_numeric_list_style_type,
+    ex_unit,
+    extended_system_fonts,
+    first_letter,
+    first_line,
+    fit_content_function_size,
+    fit_content_size,
+    focus_visible,
+    focus_within,
+    font_family_system_ui,
+    font_size_rem,
+    font_size_x_x_x_large,
+    font_stretch_percentage,
+    font_style_oblique_angle,
+    font_weight_number,
+    footnotes_list_style_type,
+    form_validation,
+    fullscreen,
+    gencontent,
+    georgian_list_style_type,
+    gradient_interpolation_hints,
+    gujarati_list_style_type,
+    gurmukhi_list_style_type,
+    has_selector,
+    hebrew_list_style_type,
+    hex_alpha_colors,
+    hiragana_iroha_list_style_type,
+    hiragana_list_style_type,
+    hypot_function,
+    ic_unit,
+    image_set,
+    in_out_of_range,
+    indeterminate_pseudo,
+    is_animatable_size,
+    is_selector,
+    japanese_formal_list_style_type,
+    japanese_informal_list_style_type,
+    kannada_list_style_type,
+    katakana_iroha_list_style_type,
+    katakana_list_style_type,
+    khmer_list_style_type,
+    korean_hangul_formal_list_style_type,
+    korean_hanja_formal_list_style_type,
+    korean_hanja_informal_list_style_type,
+    lab_colors,
+    lang_selector_list,
+    lao_list_style_type,
+    lh_unit,
+    light_dark,
+    linear_gradient,
+    logical_border_radius,
+    logical_border_shorthand,
+    logical_borders,
+    logical_inset,
+    logical_margin,
+    logical_margin_shorthand,
+    logical_padding,
+    logical_padding_shorthand,
+    logical_size,
+    logical_text_align,
+    lower_alpha_list_style_type,
+    lower_armenian_list_style_type,
+    lower_greek_list_style_type,
+    lower_hexadecimal_list_style_type,
+    lower_latin_list_style_type,
+    lower_norwegian_list_style_type,
+    lower_roman_list_style_type,
+    malayalam_list_style_type,
+    marker_pseudo,
+    max_content_size,
+    max_function,
+    media_interval_syntax,
+    media_range_syntax,
+    min_content_size,
+    min_function,
+    mod_function,
+    mongolian_list_style_type,
+    moz_available_size,
+    myanmar_list_style_type,
+    namespaces,
+    nesting,
+    none_list_style_type,
+    not_selector_list,
+    nth_child_of,
+    octal_list_style_type,
+    oklab_colors,
+    optional_pseudo,
+    oriya_list_style_type,
+    oromo_list_style_type,
+    overflow_shorthand,
+    p3_colors,
+    part_pseudo,
+    persian_list_style_type,
+    place_content,
+    place_items,
+    place_self,
+    placeholder,
+    placeholder_shown,
+    q_unit,
+    radial_gradient,
+    rcap_unit,
+    rch_unit,
+    read_only_write,
+    rem_function,
+    rem_unit,
+    repeating_conic_gradient,
+    repeating_linear_gradient,
+    repeating_radial_gradient,
+    rex_unit,
+    ric_unit,
+    rlh_unit,
+    round_function,
+    selection,
+    selectors2,
+    selectors3,
+    shadowdomv1,
+    sidama_list_style_type,
+    sign_function,
+    simp_chinese_formal_list_style_type,
+    simp_chinese_informal_list_style_type,
+    somali_list_style_type,
+    space_separated_color_notation,
+    square_list_style_type,
+    stretch_size,
+    string_list_style_type,
+    symbols_list_style_type,
+    tamil_list_style_type,
+    telugu_list_style_type,
+    text_decoration_thickness_percent,
+    text_decoration_thickness_shorthand,
+    thai_list_style_type,
+    tibetan_list_style_type,
+    tigre_list_style_type,
+    tigrinya_er_abegede_list_style_type,
+    tigrinya_er_list_style_type,
+    tigrinya_et_abegede_list_style_type,
+    tigrinya_et_list_style_type,
+    trad_chinese_formal_list_style_type,
+    trad_chinese_informal_list_style_type,
+    upper_alpha_list_style_type,
+    upper_armenian_list_style_type,
+    upper_hexadecimal_list_style_type,
+    upper_latin_list_style_type,
+    upper_norwegian_list_style_type,
+    upper_roman_list_style_type,
+    vb_unit,
+    vh_unit,
+    vi_unit,
+    viewport_percentage_units_dynamic,
+    viewport_percentage_units_large,
+    viewport_percentage_units_small,
+    vmax_unit,
+    vmin_unit,
+    vw_unit,
+    webkit_fill_available_size,
+    x_resolution_unit,
+
+    pub fn isCompatible(this: Feature, browsers: Browsers) bool {
+        switch (this) {
+            .selectors2 => {
+                if (browsers.ie) |version| {
+                    if (version < 458752) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 786432) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 131072) {
+                        return false;
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 196864) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 589824) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 197120) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 131328) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+            },
+            .selectors3 => {
+                if (browsers.ie) |version| {
+                    if (version < 589824) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 786432) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 197888) {
+                        return false;
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 197120) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 591104) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 197120) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 131328) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+            },
+            .gencontent, .first_line => {
+                if (browsers.ie) |version| {
+                    if (version < 589824) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 786432) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 131072) {
+                        return false;
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 196864) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 589824) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 197120) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 131328) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+            },
+            .first_letter => {
+                if (browsers.ie) |version| {
+                    if (version < 589824) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 786432) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 197888) {
+                        return false;
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version < 589824) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 327936) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 722432) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 327680) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 196608) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+            },
+            .in_out_of_range => {
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 3276800) {
+                        return false;
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version < 3473408) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 655616) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 2621440) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 656128) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 8323072) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 327680) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .form_validation => {
+                if (browsers.ie) |version| {
+                    if (version < 655360) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 786432) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version < 655360) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 655616) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 655360) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 656128) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 263171) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+            },
+            .any_link => {
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 3276800) {
+                        return false;
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version < 4259840) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 589824) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 3407872) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 589824) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 8323072) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 590336) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .default_pseudo => {
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version < 3342336) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 655616) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 2490368) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 656128) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 8323072) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 327680) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .dir_selector => {
+                if (browsers.edge) |version| {
+                    if (version < 7864320) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 3211264) {
+                        return false;
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version < 7864320) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 1049600) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 6946816) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 1049600) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 8323072) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 1638400) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .focus_within => {
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 3407872) {
+                        return false;
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version < 3932160) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 655616) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 3080192) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 656128) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 8323072) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 524800) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .focus_visible => {
+                if (browsers.edge) |version| {
+                    if (version < 5636096) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 5570560) {
+                        return false;
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version < 5636096) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 984064) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 4718592) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 984064) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 8323072) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 917504) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .indeterminate_pseudo => {
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 3342336) {
+                        return false;
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version < 2555904) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 655616) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 1703936) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 656128) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 8323072) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .is_selector => {
+                if (browsers.edge) |version| {
+                    if (version < 5767168) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 5111808) {
+                        return false;
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version < 5767168) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 917504) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 4915200) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 917504) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 8323072) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 983040) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .optional_pseudo => {
+                if (browsers.ie) |version| {
+                    if (version < 655360) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 786432) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version < 983040) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 327680) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 983040) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 327680) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 131840) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+            },
+            .placeholder_shown => {
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 3342336) {
+                        return false;
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version < 3080192) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 589824) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 2228224) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 589824) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 8323072) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 327680) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .dialog => {
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 6422528) {
+                        return false;
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version < 2424832) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 984064) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 1572864) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 984064) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 8323072) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .fullscreen => {
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 4194304) {
+                        return false;
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version < 4653056) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 1049600) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 786688) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 655616) {
+                        return false;
+                    }
+                }
+                if (browsers.android != null or browsers.ie != null or browsers.ios_saf != null) {
+                    return false;
+                }
+            },
+            .marker_pseudo => {
+                if (browsers.edge) |version| {
+                    if (version < 5636096) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 4456448) {
+                        return false;
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version < 5636096) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 721152) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 4718592) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 721664) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 8323072) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 917504) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .placeholder => {
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 3342336) {
+                        return false;
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version < 3735552) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 655616) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 2883584) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 656128) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 8323072) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 459264) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .selection => {
+                if (browsers.ie) |version| {
+                    if (version < 589824) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 786432) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 4063232) {
+                        return false;
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 196864) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 591104) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 263168) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf != null) {
+                    return false;
+                }
+            },
+            .case_insensitive => {
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 3080192) {
+                        return false;
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version < 3211264) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 589824) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 2359296) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 589824) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 8323072) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 327680) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .read_only_write => {
+                if (browsers.edge) |version| {
+                    if (version < 851968) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 5111808) {
+                        return false;
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version < 2359296) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 589824) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 1507328) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 589824) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 8323072) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .autofill => {
+                if (browsers.chrome) |version| {
+                    if (version < 7208960) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 7208960) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 5636096) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 6291456) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 983040) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 983040) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 1376256) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 8323072) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .namespaces => {
+                if (browsers.ie) |version| {
+                    if (version < 589824) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 786432) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 131072) {
+                        return false;
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 589824) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 262656) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 131328) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+            },
+            .shadowdomv1 => {
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 4128768) {
+                        return false;
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version < 3473408) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 655360) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 2621440) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 720896) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 8323072) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 393728) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .hex_alpha_colors => {
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 3211264) {
+                        return false;
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version < 4063232) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 655360) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 3407872) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 655360) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 8323072) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 524800) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .nesting => {
+                if (browsers.edge) |version| {
+                    if (version < 7864320) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 7667712) {
+                        return false;
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version < 7864320) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 1114624) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 6946816) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 1114624) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 8323072) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null or browsers.samsung != null) {
+                    return false;
+                }
+            },
+            .not_selector_list => {
+                if (browsers.edge) |version| {
+                    if (version < 5767168) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 5505024) {
+                        return false;
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version < 5767168) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 589824) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 4915200) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 589824) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 8323072) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 983040) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .has_selector => {
+                if (browsers.edge) |version| {
+                    if (version < 6881280) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 7929856) {
+                        return false;
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version < 6881280) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 984064) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 5963776) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 984064) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 8323072) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 1310720) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .font_family_system_ui => {
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 6029312) {
+                        return false;
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version < 3670016) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 720896) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 2818048) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 720896) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 8323072) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 393728) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .extended_system_fonts => {
+                if (browsers.safari) |version| {
+                    if (version < 852224) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 852992) {
+                        return false;
+                    }
+                }
+                if (browsers.android != null or browsers.chrome != null or browsers.edge != null or browsers.firefox != null or browsers.ie != null or browsers.opera != null or browsers.samsung != null) {
+                    return false;
+                }
+            },
+            .calc_function => {
+                if (browsers.edge) |version| {
+                    if (version < 786432) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 1048576) {
+                        return false;
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version < 1703936) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 393472) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 983040) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 458752) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 8323072) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .custom_media_queries, .fit_content_function_size, .stretch_size => {
+                return false;
+            },
+            .double_position_gradients => {
+                if (browsers.chrome) |version| {
+                    if (version < 4653056) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 4194304) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 3276800) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 786688) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 786944) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 655360) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 4653056) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .clamp_function => {
+                if (browsers.chrome) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 3735552) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 852224) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 852992) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 786432) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .place_self, .place_items => {
+                if (browsers.chrome) |version| {
+                    if (version < 3866624) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 2949120) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 2818048) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 720896) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 720896) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 458752) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 3866624) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .place_content => {
+                if (browsers.chrome) |version| {
+                    if (version < 3866624) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 2949120) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 2818048) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 589824) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 589824) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 458752) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 3866624) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .overflow_shorthand => {
+                if (browsers.chrome) |version| {
+                    if (version < 4456448) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 3997696) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 3145728) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 852224) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 852992) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 655360) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 4456448) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .media_range_syntax => {
+                if (browsers.chrome) |version| {
+                    if (version < 6815744) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 6815744) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 4128768) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 4653056) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 1049600) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 1049600) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 1310720) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 6815744) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .media_interval_syntax => {
+                if (browsers.chrome) |version| {
+                    if (version < 6815744) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 6815744) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 6684672) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 4653056) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 1049600) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 1049600) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 1310720) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 6815744) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .logical_borders => {
+                if (browsers.chrome) |version| {
+                    if (version < 4521984) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 2686976) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 3145728) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 786688) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 786944) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 655360) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 4521984) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .logical_border_shorthand, .logical_margin_shorthand, .logical_padding_shorthand => {
+                if (browsers.chrome) |version| {
+                    if (version < 5701632) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5701632) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 4325376) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 4063232) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 917760) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 918784) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 917504) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 5701632) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .logical_border_radius => {
+                if (browsers.chrome) |version| {
+                    if (version < 5832704) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5832704) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 4325376) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 4128768) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 983040) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 983040) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 983040) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 5832704) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .logical_margin, .logical_padding => {
+                if (browsers.chrome) |version| {
+                    if (version < 4521984) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 2686976) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 3145728) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 786688) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 786944) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 655360) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 5701632) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .logical_inset => {
+                if (browsers.chrome) |version| {
+                    if (version < 5701632) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5701632) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 4128768) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 4063232) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 917760) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 918784) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 917504) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 5701632) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .logical_size => {
+                if (browsers.chrome) |version| {
+                    if (version < 3735552) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 2686976) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 2818048) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 786688) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 786944) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 327680) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 3735552) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .logical_text_align => {
+                if (browsers.chrome) |version| {
+                    if (version < 1179648) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 917504) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 196864) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 131072) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 65536) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 2424832) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .lab_colors => {
+                if (browsers.chrome) |version| {
+                    if (version < 7274496) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 7274496) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 7405568) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 4915200) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 983040) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 983040) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 1441792) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 7274496) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .oklab_colors => {
+                if (browsers.chrome) |version| {
+                    if (version < 7274496) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 7274496) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 7405568) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 4915200) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 984064) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 984064) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 1441792) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 7274496) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .color_function => {
+                if (browsers.chrome) |version| {
+                    if (version < 7274496) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 7274496) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 7405568) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 4915200) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 655616) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 656128) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 1441792) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 7274496) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .space_separated_color_notation => {
+                if (browsers.chrome) |version| {
+                    if (version < 4259840) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 3407872) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 3080192) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 786688) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 786944) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 589824) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 4259840) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .text_decoration_thickness_percent => {
+                if (browsers.chrome) |version| {
+                    if (version < 5701632) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5701632) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 4063232) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 1115136) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 1115136) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 917504) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 5701632) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .text_decoration_thickness_shorthand => {
+                if (browsers.chrome) |version| {
+                    if (version < 5701632) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5701632) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 4063232) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 917504) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 5701632) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null or browsers.ios_saf != null or browsers.safari != null) {
+                    return false;
+                }
+            },
+            .cue => {
+                if (browsers.chrome) |version| {
+                    if (version < 1703936) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 3604480) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 917504) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 458752) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 458752) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 66816) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 263168) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .cue_function => {
+                if (browsers.chrome) |version| {
+                    if (version < 1703936) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 917504) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 458752) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 458752) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 66816) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 263168) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox != null or browsers.ie != null) {
+                    return false;
+                }
+            },
+            .any_pseudo => {
+                if (browsers.chrome) |version| {
+                    if (version < 1179648) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 917504) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 327680) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 327680) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 65536) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 2424832) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .part_pseudo => {
+                if (browsers.chrome) |version| {
+                    if (version < 4784128) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 3407872) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 852224) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 852992) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 720896) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 4784128) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .image_set => {
+                if (browsers.chrome) |version| {
+                    if (version < 1638400) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 5767168) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 917504) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 393216) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 393216) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 66816) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 263168) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .x_resolution_unit => {
+                if (browsers.chrome) |version| {
+                    if (version < 4456448) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 4063232) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 3145728) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 655360) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 4456448) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null or browsers.ios_saf != null or browsers.safari != null) {
+                    return false;
+                }
+            },
+            .nth_child_of => {
+                if (browsers.chrome) |version| {
+                    if (version < 7274496) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 7274496) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 7405568) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 4915200) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 589824) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 589824) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 1441792) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 7274496) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .min_function, .max_function => {
+                if (browsers.chrome) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 3735552) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 721152) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 721664) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 786432) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .round_function, .rem_function, .mod_function => {
+                if (browsers.chrome) |version| {
+                    if (version < 8192000) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 8192000) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 7733248) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 5439488) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 984064) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 984064) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 8192000) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null or browsers.samsung != null) {
+                    return false;
+                }
+            },
+            .abs_function, .sign_function => {
+                if (browsers.firefox) |version| {
+                    if (version < 7733248) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 984064) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 984064) {
+                        return false;
+                    }
+                }
+                if (browsers.android != null or browsers.chrome != null or browsers.edge != null or browsers.ie != null or browsers.opera != null or browsers.samsung != null) {
+                    return false;
+                }
+            },
+            .hypot_function => {
+                if (browsers.chrome) |version| {
+                    if (version < 7864320) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 7864320) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 7733248) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 5242880) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 984064) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 984064) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 1638400) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 7864320) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .gradient_interpolation_hints => {
+                if (browsers.chrome) |version| {
+                    if (version < 2621440) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 2359296) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 1769472) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 458752) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 458752) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 2621440) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .border_image_repeat_round => {
+                if (browsers.chrome) |version| {
+                    if (version < 1966080) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 786432) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 983040) {
+                        return false;
+                    }
+                }
+                if (browsers.ie) |version| {
+                    if (version < 720896) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 1179648) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 590080) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 590592) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 131072) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 263168) {
+                        return false;
+                    }
+                }
+            },
+            .border_image_repeat_space => {
+                if (browsers.chrome) |version| {
+                    if (version < 3670016) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 786432) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 3276800) {
+                        return false;
+                    }
+                }
+                if (browsers.ie) |version| {
+                    if (version < 720896) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 2818048) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 590080) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 590592) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 393216) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 3670016) {
+                        return false;
+                    }
+                }
+            },
+            .font_size_rem => {
+                if (browsers.chrome) |version| {
+                    if (version < 2752512) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 786432) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 2031616) {
+                        return false;
+                    }
+                }
+                if (browsers.ie) |version| {
+                    if (version < 589824) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 1835008) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 458752) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 458752) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 2752512) {
+                        return false;
+                    }
+                }
+            },
+            .font_size_x_x_x_large => {
+                if (browsers.chrome) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 3735552) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 1049600) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 1049600) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 786432) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .font_style_oblique_angle => {
+                if (browsers.chrome) |version| {
+                    if (version < 4063232) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 3997696) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 3014656) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 721152) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 721664) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 524288) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 4063232) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .font_weight_number => {
+                if (browsers.chrome) |version| {
+                    if (version < 4063232) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 1114112) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 3997696) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 3014656) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 720896) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 720896) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 524288) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 4063232) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .font_stretch_percentage => {
+                if (browsers.chrome) |version| {
+                    if (version < 4063232) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 1179648) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 3997696) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 3014656) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 721152) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 721664) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 524288) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 4063232) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .light_dark => {
+                if (browsers.chrome) |version| {
+                    if (version < 8060928) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 8060928) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 7864320) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 5373952) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 1115392) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 1115392) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 8060928) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null or browsers.samsung != null) {
+                    return false;
+                }
+            },
+            .accent_system_color => {
+                if (browsers.firefox) |version| {
+                    if (version < 6750208) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 1049856) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 1049856) {
+                        return false;
+                    }
+                }
+                if (browsers.android != null or browsers.chrome != null or browsers.edge != null or browsers.ie != null or browsers.opera != null or browsers.samsung != null) {
+                    return false;
+                }
+            },
+            .animation_timeline_shorthand => {
+                if (browsers.chrome) |version| {
+                    if (version < 7536640) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 7536640) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 5046272) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 1507328) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 7536640) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox != null or browsers.ie != null or browsers.ios_saf != null or browsers.safari != null) {
+                    return false;
+                }
+            },
+            .q_unit => {
+                if (browsers.chrome) |version| {
+                    if (version < 4128768) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 3211264) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 3014656) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 852224) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 852992) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 524288) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 4128768) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .cap_unit => {
+                if (browsers.chrome) |version| {
+                    if (version < 7733248) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 7733248) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 6356992) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 1114624) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 1114624) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 1638400) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 7733248) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .ch_unit => {
+                if (browsers.chrome) |version| {
+                    if (version < 1769472) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 786432) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+                if (browsers.ie) |version| {
+                    if (version < 589824) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 983040) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 458752) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 458752) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 66816) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 263168) {
+                        return false;
+                    }
+                }
+            },
+            .container_query_length_units => {
+                if (browsers.chrome) |version| {
+                    if (version < 6881280) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 6881280) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 7208960) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 4718592) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 1048576) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 1048576) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 1310720) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 6881280) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .em_unit => {
+                if (browsers.chrome) |version| {
+                    if (version < 1179648) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 786432) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+                if (browsers.ie) |version| {
+                    if (version < 196608) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 655616) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 65536) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 65536) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 65536) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 65536) {
+                        return false;
+                    }
+                }
+            },
+            .ex_unit, .circle_list_style_type, .decimal_list_style_type, .disc_list_style_type, .square_list_style_type => {
+                if (browsers.chrome) |version| {
+                    if (version < 1179648) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 786432) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+                if (browsers.ie) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 655616) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 65536) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 65536) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 65536) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 263168) {
+                        return false;
+                    }
+                }
+            },
+            .ic_unit => {
+                if (browsers.chrome) |version| {
+                    if (version < 6946816) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 6946816) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 6356992) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 4718592) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 984064) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 984064) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 1310720) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 6946816) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .lh_unit => {
+                if (browsers.chrome) |version| {
+                    if (version < 7143424) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 7143424) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 7864320) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 4849664) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 1049600) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 1049600) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 1376256) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 7143424) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .rcap_unit => {
+                if (browsers.chrome) |version| {
+                    if (version < 7733248) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 7733248) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 1114624) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 1114624) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 1638400) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 7733248) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox != null or browsers.ie != null) {
+                    return false;
+                }
+            },
+            .rch_unit, .rex_unit, .ric_unit => {
+                if (browsers.chrome) |version| {
+                    if (version < 7274496) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 7274496) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 4915200) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 1114624) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 1114624) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 1441792) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 7274496) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox != null or browsers.ie != null) {
+                    return false;
+                }
+            },
+            .rem_unit => {
+                if (browsers.chrome) |version| {
+                    if (version < 1179648) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 786432) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+                if (browsers.ie) |version| {
+                    if (version < 589824) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 786432) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 327680) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 65536) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 131072) {
+                        return false;
+                    }
+                }
+            },
+            .rlh_unit => {
+                if (browsers.chrome) |version| {
+                    if (version < 7274496) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 7274496) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 7864320) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 4915200) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 1049600) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 1049600) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 1441792) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 7274496) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .vb_unit, .vi_unit, .viewport_percentage_units_dynamic, .viewport_percentage_units_large, .viewport_percentage_units_small => {
+                if (browsers.chrome) |version| {
+                    if (version < 7077888) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 7077888) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 6619136) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 4784128) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 984064) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 984064) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 1376256) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 7077888) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .vh_unit, .vw_unit => {
+                if (browsers.chrome) |version| {
+                    if (version < 1638400) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 786432) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 1245184) {
+                        return false;
+                    }
+                }
+                if (browsers.ie) |version| {
+                    if (version < 589824) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 917504) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 393216) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 393216) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 66816) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 263168) {
+                        return false;
+                    }
+                }
+            },
+            .vmax_unit => {
+                if (browsers.chrome) |version| {
+                    if (version < 1703936) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 1048576) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 1245184) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 917504) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 458752) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 458752) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 66816) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 66816) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .vmin_unit => {
+                if (browsers.chrome) |version| {
+                    if (version < 1703936) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 786432) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 1245184) {
+                        return false;
+                    }
+                }
+                if (browsers.ie) |version| {
+                    if (version < 655360) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 917504) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 458752) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 458752) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 66816) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 263168) {
+                        return false;
+                    }
+                }
+            },
+            .conic_gradient, .repeating_conic_gradient => {
+                if (browsers.chrome) |version| {
+                    if (version < 4521984) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 5439488) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 3145728) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 786688) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 786944) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 655360) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 4521984) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .linear_gradient, .repeating_linear_gradient => {
+                if (browsers.chrome) |version| {
+                    if (version < 1179648) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 786432) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+                if (browsers.ie) |version| {
+                    if (version < 655360) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 720896) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 327936) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 327680) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 65536) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 2424832) {
+                        return false;
+                    }
+                }
+            },
+            .radial_gradient => {
+                if (browsers.chrome) |version| {
+                    if (version < 1179648) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 786432) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+                if (browsers.ie) |version| {
+                    if (version < 655360) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 786432) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 327936) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 327680) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 65536) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 2424832) {
+                        return false;
+                    }
+                }
+            },
+            .repeating_radial_gradient => {
+                if (browsers.chrome) |version| {
+                    if (version < 1179648) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 786432) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 655360) {
+                        return false;
+                    }
+                }
+                if (browsers.ie) |version| {
+                    if (version < 655360) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 786432) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 327936) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 327680) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 65536) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 263168) {
+                        return false;
+                    }
+                }
+            },
+            .afar_list_style_type, .amharic_list_style_type, .amharic_abegede_list_style_type, .ethiopic_list_style_type, .ethiopic_abegede_list_style_type, .ethiopic_abegede_am_et_list_style_type, .ethiopic_abegede_gez_list_style_type, .ethiopic_abegede_ti_er_list_style_type, .ethiopic_abegede_ti_et_list_style_type, .ethiopic_halehame_aa_er_list_style_type, .ethiopic_halehame_aa_et_list_style_type, .ethiopic_halehame_am_et_list_style_type, .ethiopic_halehame_gez_list_style_type, .ethiopic_halehame_om_et_list_style_type, .ethiopic_halehame_sid_et_list_style_type, .ethiopic_halehame_so_et_list_style_type, .ethiopic_halehame_tig_list_style_type, .lower_hexadecimal_list_style_type, .lower_norwegian_list_style_type, .upper_hexadecimal_list_style_type, .upper_norwegian_list_style_type => {
+                if (browsers.chrome) |version| {
+                    if (version < 1179648) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5963776) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 917504) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 327680) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 262656) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 65536) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 196608) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox != null or browsers.ie != null) {
+                    return false;
+                }
+            },
+            .arabic_indic_list_style_type, .bengali_list_style_type, .cjk_earthly_branch_list_style_type, .cjk_heavenly_stem_list_style_type, .devanagari_list_style_type, .gujarati_list_style_type, .gurmukhi_list_style_type, .kannada_list_style_type, .khmer_list_style_type, .lao_list_style_type, .malayalam_list_style_type, .myanmar_list_style_type, .oriya_list_style_type, .persian_list_style_type, .telugu_list_style_type, .thai_list_style_type => {
+                if (browsers.chrome) |version| {
+                    if (version < 1179648) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 917504) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 327680) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 262656) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 65536) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 263168) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .armenian_list_style_type, .decimal_leading_zero_list_style_type, .georgian_list_style_type, .lower_alpha_list_style_type, .lower_greek_list_style_type, .lower_roman_list_style_type, .upper_alpha_list_style_type, .upper_latin_list_style_type, .upper_roman_list_style_type => {
+                if (browsers.chrome) |version| {
+                    if (version < 1179648) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 786432) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+                if (browsers.ie) |version| {
+                    if (version < 524288) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 655616) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 65536) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 65536) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 65536) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 263168) {
+                        return false;
+                    }
+                }
+            },
+            .asterisks_list_style_type, .footnotes_list_style_type => {
+                if (browsers.chrome) |version| {
+                    if (version < 1179648) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5963776) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 917504) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 327936) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 327680) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 65536) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 263168) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox != null or browsers.ie != null) {
+                    return false;
+                }
+            },
+            .binary_list_style_type, .octal_list_style_type, .oromo_list_style_type, .sidama_list_style_type, .somali_list_style_type, .tigre_list_style_type, .tigrinya_er_list_style_type, .tigrinya_er_abegede_list_style_type, .tigrinya_et_list_style_type, .tigrinya_et_abegede_list_style_type => {
+                if (browsers.chrome) |version| {
+                    if (version < 1179648) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5963776) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 917504) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 327680) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 262656) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 65536) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 263168) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox != null or browsers.ie != null) {
+                    return false;
+                }
+            },
+            .cambodian_list_style_type, .mongolian_list_style_type, .tibetan_list_style_type => {
+                if (browsers.chrome) |version| {
+                    if (version < 1179648) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 2162688) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 917504) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 327680) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 262656) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 65536) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 263168) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .cjk_decimal_list_style_type => {
+                if (browsers.chrome) |version| {
+                    if (version < 5963776) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5963776) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 1835008) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 4194304) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 983040) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 983040) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 1048576) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 5963776) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .disclosure_closed_list_style_type, .disclosure_open_list_style_type => {
+                if (browsers.chrome) |version| {
+                    if (version < 5832704) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5832704) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 2162688) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 4128768) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 983040) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 983040) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 983040) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 5832704) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .ethiopic_numeric_list_style_type, .japanese_formal_list_style_type, .japanese_informal_list_style_type, .tamil_list_style_type => {
+                if (browsers.chrome) |version| {
+                    if (version < 5963776) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5963776) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 4194304) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 983040) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 983040) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 1048576) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 5963776) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .hebrew_list_style_type, .hiragana_list_style_type, .hiragana_iroha_list_style_type, .katakana_list_style_type, .katakana_iroha_list_style_type, .auto_size => {
+                if (browsers.chrome) |version| {
+                    if (version < 1179648) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 786432) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+                if (browsers.ie) |version| {
+                    if (version < 720896) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 917504) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 65536) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 65536) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 65536) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 263168) {
+                        return false;
+                    }
+                }
+            },
+            .korean_hangul_formal_list_style_type, .korean_hanja_formal_list_style_type, .korean_hanja_informal_list_style_type => {
+                if (browsers.chrome) |version| {
+                    if (version < 2949120) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 1835008) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 2097152) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 983040) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 983040) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 327680) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 2949120) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .lower_armenian_list_style_type, .upper_armenian_list_style_type => {
+                if (browsers.chrome) |version| {
+                    if (version < 1179648) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 2162688) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 917504) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 327936) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 327680) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 65536) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 263168) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .lower_latin_list_style_type => {
+                if (browsers.chrome) |version| {
+                    if (version < 1179648) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 786432) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+                if (browsers.ie) |version| {
+                    if (version < 524288) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 655616) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 65536) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 65536) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 327680) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 263168) {
+                        return false;
+                    }
+                }
+            },
+            .none_list_style_type => {
+                if (browsers.chrome) |version| {
+                    if (version < 1179648) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 786432) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.ie) |version| {
+                    if (version < 720896) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 917504) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 65536) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 65536) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 65536) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 263168) {
+                        return false;
+                    }
+                }
+            },
+            .simp_chinese_formal_list_style_type, .simp_chinese_informal_list_style_type, .trad_chinese_formal_list_style_type, .trad_chinese_informal_list_style_type => {
+                if (browsers.chrome) |version| {
+                    if (version < 2949120) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 2097152) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 983040) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 983040) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 327680) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 2949120) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .string_list_style_type => {
+                if (browsers.chrome) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 2555904) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 3735552) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 917760) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 918784) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 786432) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .symbols_list_style_type => {
+                if (browsers.firefox) |version| {
+                    if (version < 2293760) {
+                        return false;
+                    }
+                }
+                if (browsers.android != null or browsers.chrome != null or browsers.edge != null or browsers.ie != null or browsers.ios_saf != null or browsers.opera != null or browsers.safari != null or browsers.samsung != null) {
+                    return false;
+                }
+            },
+            .anchor_size_size => {
+                if (browsers.chrome) |version| {
+                    if (version < 8192000) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 8192000) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 5439488) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 8192000) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox != null or browsers.ie != null or browsers.ios_saf != null or browsers.safari != null or browsers.samsung != null) {
+                    return false;
+                }
+            },
+            .fit_content_size => {
+                if (browsers.chrome) |version| {
+                    if (version < 1638400) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 917504) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 458752) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 458752) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 66816) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 263168) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .is_animatable_size => {
+                if (browsers.chrome) |version| {
+                    if (version < 1703936) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 786432) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 1048576) {
+                        return false;
+                    }
+                }
+                if (browsers.ie) |version| {
+                    if (version < 720896) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 917504) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 458752) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 458752) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 66816) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 263168) {
+                        return false;
+                    }
+                }
+            },
+            .max_content_size => {
+                if (browsers.chrome) |version| {
+                    if (version < 1638400) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 2818048) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 720896) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 720896) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 66816) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 263168) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .min_content_size => {
+                if (browsers.chrome) |version| {
+                    if (version < 3014656) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 2162688) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 720896) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 720896) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 327680) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 3014656) {
+                        return false;
+                    }
+                }
+                if (browsers.ie != null) {
+                    return false;
+                }
+            },
+            .webkit_fill_available_size => {
+                if (browsers.chrome) |version| {
+                    if (version < 1638400) {
+                        return false;
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version < 5177344) {
+                        return false;
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version < 917504) {
+                        return false;
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version < 458752) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 458752) {
+                        return false;
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version < 327680) {
+                        return false;
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version < 263168) {
+                        return false;
+                    }
+                }
+                if (browsers.firefox != null or browsers.ie != null) {
+                    return false;
+                }
+            },
+            .moz_available_size => {
+                if (browsers.firefox) |version| {
+                    if (version < 262144) {
+                        return false;
+                    }
+                }
+                if (browsers.android != null or browsers.chrome != null or browsers.edge != null or browsers.ie != null or browsers.ios_saf != null or browsers.opera != null or browsers.safari != null or browsers.samsung != null) {
+                    return false;
+                }
+            },
+            .p3_colors, .lang_selector_list => {
+                if (browsers.safari) |version| {
+                    if (version < 655616) {
+                        return false;
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version < 656128) {
+                        return false;
+                    }
+                }
+                if (browsers.android != null or browsers.chrome != null or browsers.edge != null or browsers.firefox != null or browsers.ie != null or browsers.opera != null or browsers.samsung != null) {
+                    return false;
+                }
+            },
+        }
+        return true;
+    }
+
+    pub fn isPartiallyCompatible(this: *const Feature, targets: Browsers) bool {
+        var browsers = Browsers{};
+        if (targets.android != null) {
+            browsers.android = targets.android;
+            if (this.isCompatible(browsers)) {
+                return true;
+            }
+            browsers.android = null;
+        }
+        if (targets.chrome != null) {
+            browsers.chrome = targets.chrome;
+            if (this.isCompatible(browsers)) {
+                return true;
+            }
+            browsers.chrome = null;
+        }
+        if (targets.edge != null) {
+            browsers.edge = targets.edge;
+            if (this.isCompatible(browsers)) {
+                return true;
+            }
+            browsers.edge = null;
+        }
+        if (targets.firefox != null) {
+            browsers.firefox = targets.firefox;
+            if (this.isCompatible(browsers)) {
+                return true;
+            }
+            browsers.firefox = null;
+        }
+        if (targets.ie != null) {
+            browsers.ie = targets.ie;
+            if (this.isCompatible(browsers)) {
+                return true;
+            }
+            browsers.ie = null;
+        }
+        if (targets.ios_saf != null) {
+            browsers.ios_saf = targets.ios_saf;
+            if (this.isCompatible(browsers)) {
+                return true;
+            }
+            browsers.ios_saf = null;
+        }
+        if (targets.opera != null) {
+            browsers.opera = targets.opera;
+            if (this.isCompatible(browsers)) {
+                return true;
+            }
+            browsers.opera = null;
+        }
+        if (targets.safari != null) {
+            browsers.safari = targets.safari;
+            if (this.isCompatible(browsers)) {
+                return true;
+            }
+            browsers.safari = null;
+        }
+        if (targets.samsung != null) {
+            browsers.samsung = targets.samsung;
+            if (this.isCompatible(browsers)) {
+                return true;
+            }
+            browsers.samsung = null;
+        }
+
+        return false;
+    }
+};
diff --git a/src/css/context.zig b/src/css/context.zig
new file mode 100644
index 0000000000..db6b3964a2
--- /dev/null
+++ b/src/css/context.zig
@@ -0,0 +1,307 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const bun = @import("root").bun;
+const logger = bun.logger;
+const Log = logger.Log;
+
+pub const css = @import("./css_parser.zig");
+
+const ArrayList = std.ArrayListUnmanaged;
+
+const MediaRule = css.css_rules.media.MediaRule;
+const MediaQuery = css.media_query.MediaQuery;
+const MediaCondition = css.media_query.MediaCondition;
+const MediaList = css.media_query.MediaList;
+const MediaFeature = css.media_query.MediaFeature;
+const MediaFeatureName = css.media_query.MediaFeatureName;
+const MediaFeatureValue = css.media_query.MediaFeatureValue;
+const MediaFeatureId = css.media_query.MediaFeatureId;
+
+const UnparsedProperty = css.css_properties.custom.UnparsedProperty;
+
+pub const SupportsEntry = struct {
+    condition: css.SupportsCondition,
+    declarations: ArrayList(css.Property),
+    important_declarations: ArrayList(css.Property),
+
+    pub fn deinit(this: *@This(), allocator: std.mem.Allocator) void {
+        _ = this; // autofix
+        _ = allocator; // autofix
+        @panic(css.todo_stuff.depth);
+    }
+};
+
+pub const DeclarationContext = enum {
+    none,
+    style_rule,
+    keyframes,
+    style_attribute,
+};
+
+pub const PropertyHandlerContext = struct {
+    allocator: Allocator,
+    targets: css.targets.Targets,
+    is_important: bool,
+    supports: ArrayList(SupportsEntry),
+    ltr: ArrayList(css.Property),
+    rtl: ArrayList(css.Property),
+    dark: ArrayList(css.Property),
+    context: DeclarationContext,
+    unused_symbols: *const std.StringArrayHashMapUnmanaged(void),
+
+    pub fn new(
+        allocator: Allocator,
+        targets: css.targets.Targets,
+        unused_symbols: *const std.StringArrayHashMapUnmanaged(void),
+    ) PropertyHandlerContext {
+        return PropertyHandlerContext{
+            .allocator = allocator,
+            .targets = targets,
+            .is_important = false,
+            .supports = ArrayList(SupportsEntry){},
+            .ltr = ArrayList(css.Property){},
+            .rtl = ArrayList(css.Property){},
+            .dark = ArrayList(css.Property){},
+            .context = DeclarationContext.none,
+            .unused_symbols = unused_symbols,
+        };
+    }
+
+    pub fn child(this: *const PropertyHandlerContext, context: DeclarationContext) PropertyHandlerContext {
+        return PropertyHandlerContext{
+            .allocator = this.allocator,
+            .targets = this.targets,
+            .is_important = false,
+            .supports = .{},
+            .ltr = .{},
+            .rtl = .{},
+            .dark = .{},
+            .context = context,
+            .unused_symbols = this.unused_symbols,
+        };
+    }
+
+    pub fn addLogicalRule(this: *@This(), allocator: Allocator, ltr: css.Property, rtl: css.Property) void {
+        this.ltr.append(allocator, ltr) catch unreachable;
+        this.rtl.append(allocator, rtl) catch unreachable;
+    }
+
+    pub fn shouldCompileLogical(this: *const @This(), feature: css.compat.Feature) bool {
+        // Don't convert logical properties in style attributes because
+        // our fallbacks rely on extra rules to define --ltr and --rtl.
+        if (this.context == DeclarationContext.style_attribute) return false;
+
+        return this.targets.shouldCompileLogical(feature);
+    }
+
+    pub fn getSupportsRules(
+        this: *const @This(),
+        comptime T: type,
+        style_rule: *const css.StyleRule(T),
+    ) ArrayList(css.CssRule(T)) {
+        if (this.supports.items.len == 0) {
+            return .{};
+        }
+
+        var dest = ArrayList(css.CssRule(T)).initCapacity(
+            this.allocator,
+            this.supports.items.len,
+        ) catch bun.outOfMemory();
+
+        for (this.supports.items) |*entry| {
+            dest.appendAssumeCapacity(css.CssRule(T){
+                .supports = css.SupportsRule(T){
+                    .condition = entry.condition.deepClone(this.allocator),
+                    .rules = css.CssRuleList(T){
+                        .v = v: {
+                            var v = ArrayList(css.CssRule(T)).initCapacity(this.allocator, 1) catch bun.outOfMemory();
+
+                            v.appendAssumeCapacity(.{ .style = css.StyleRule(T){
+                                .selectors = style_rule.selectors.deepClone(this.allocator),
+                                .vendor_prefix = css.VendorPrefix{ .none = true },
+                                .declarations = css.DeclarationBlock{
+                                    .declarations = css.deepClone(css.Property, this.allocator, &entry.declarations),
+                                    .important_declarations = css.deepClone(css.Property, this.allocator, &entry.important_declarations),
+                                },
+                                .rules = css.CssRuleList(T){},
+                                .loc = style_rule.loc,
+                            } });
+
+                            break :v v;
+                        },
+                    },
+                    .loc = style_rule.loc,
+                },
+            });
+        }
+
+        return dest;
+    }
+
+    pub fn getAdditionalRules(
+        this: *const @This(),
+        comptime T: type,
+        style_rule: *const css.StyleRule(T),
+    ) ArrayList(css.CssRule(T)) {
+        // TODO: :dir/:lang raises the specificity of the selector. Use :where to lower it?
+        var dest = ArrayList(css.CssRule(T)){};
+
+        if (this.ltr.items.len > 0) {
+            getAdditionalRulesHelper(this, T, "ltr", "ltr", style_rule, &dest);
+        }
+
+        if (this.rtl.items.len > 0) {
+            getAdditionalRulesHelper(this, T, "rtl", "rtl", style_rule, &dest);
+        }
+
+        if (this.dark.items.len > 0) {
+            dest.append(this.allocator, css.CssRule(T){
+                .media = MediaRule(T){
+                    .query = MediaList{
+                        .media_queries = brk: {
+                            var list = ArrayList(MediaQuery).initCapacity(
+                                this.allocator,
+                                1,
+                            ) catch bun.outOfMemory();
+
+                            list.appendAssumeCapacity(MediaQuery{
+                                .qualifier = null,
+                                .media_type = .all,
+                                .condition = MediaCondition{
+                                    .feature = MediaFeature{
+                                        .plain = .{
+                                            .name = .{ .standard = MediaFeatureId.@"prefers-color-scheme" },
+                                            .value = .{ .ident = .{ .v = "dark " } },
+                                        },
+                                    },
+                                },
+                            });
+
+                            break :brk list;
+                        },
+                    },
+                    .rules = brk: {
+                        var list: css.CssRuleList(T) = .{};
+
+                        list.v.append(this.allocator, css.CssRule(T){
+                            .style = css.StyleRule(T){
+                                .selectors = style_rule.selectors.deepClone(this.allocator),
+                                .vendor_prefix = css.VendorPrefix{ .none = true },
+                                .declarations = css.DeclarationBlock{
+                                    .declarations = css.deepClone(css.Property, this.allocator, &this.dark),
+                                    .important_declarations = .{},
+                                },
+                                .rules = .{},
+                                .loc = style_rule.loc,
+                            },
+                        }) catch bun.outOfMemory();
+
+                        break :brk list;
+                    },
+                    .loc = style_rule.loc,
+                },
+            }) catch bun.outOfMemory();
+        }
+
+        return dest;
+    }
+    pub fn getAdditionalRulesHelper(
+        this: *const @This(),
+        comptime T: type,
+        comptime dir: []const u8,
+        comptime decls: []const u8,
+        sty: *const css.StyleRule(T),
+        dest: *ArrayList(css.CssRule(T)),
+    ) void {
+        var selectors = sty.selectors.deepClone(this.allocator);
+        for (selectors.v.slice_mut()) |*selector| {
+            selector.append(this.allocator, css.Component{
+                .non_ts_pseudo_class = css.PseudoClass{
+                    .dir = .{ .direction = @field(css.selector.parser.Direction, dir) },
+                },
+            });
+        }
+
+        const rule = css.StyleRule(T){
+            .selectors = selectors,
+            .vendor_prefix = css.VendorPrefix{ .none = true },
+            .declarations = css.DeclarationBlock{
+                .declarations = css.deepClone(css.Property, this.allocator, &@field(this, decls)),
+                .important_declarations = .{},
+            },
+            .rules = .{},
+            .loc = sty.loc,
+        };
+
+        dest.append(this.allocator, .{ .style = rule }) catch bun.outOfMemory();
+    }
+
+    pub fn reset(this: *@This()) void {
+        for (this.supports.items) |*supp| {
+            supp.deinit(this.allocator);
+        }
+        this.supports.clearRetainingCapacity();
+
+        for (this.ltr.items) |*ltr| {
+            ltr.deinit(this.allocator);
+        }
+        this.ltr.clearRetainingCapacity();
+
+        for (this.rtl.items) |*rtl| {
+            rtl.deinit(this.allocator);
+        }
+        this.rtl.clearRetainingCapacity();
+
+        for (this.dark.items) |*dark| {
+            dark.deinit(this.allocator);
+        }
+        this.dark.clearRetainingCapacity();
+    }
+
+    pub fn addConditionalProperty(this: *@This(), condition: css.SupportsCondition, property: css.Property) void {
+        if (this.context != DeclarationContext.style_rule) return;
+
+        if (brk: {
+            for (this.supports.items) |*supp| {
+                if (condition.eql(&supp.condition)) break :brk supp;
+            }
+            break :brk null;
+        }) |entry| {
+            if (this.is_important) {
+                entry.important_declarations.append(this.allocator, property) catch bun.outOfMemory();
+            } else {
+                entry.declarations.append(this.allocator, property) catch bun.outOfMemory();
+            }
+        } else {
+            var important_declarations = ArrayList(css.Property){};
+            var declarations = ArrayList(css.Property){};
+            if (this.is_important) {
+                important_declarations.append(this.allocator, property) catch bun.outOfMemory();
+            } else {
+                declarations.append(this.allocator, property) catch bun.outOfMemory();
+            }
+            this.supports.append(this.allocator, SupportsEntry{
+                .condition = condition,
+                .declarations = declarations,
+                .important_declarations = important_declarations,
+            }) catch bun.outOfMemory();
+        }
+    }
+
+    pub fn addUnparsedFallbacks(this: *@This(), unparsed: *UnparsedProperty) void {
+        if (this.context != DeclarationContext.style_rule and this.context != DeclarationContext.style_attribute) {
+            return;
+        }
+
+        const fallbacks = unparsed.value.getFallbacks(this.allocator, this.targets);
+
+        for (fallbacks.slice()) |condition_and_fallback| {
+            this.addConditionalProperty(condition_and_fallback[0], css.Property{
+                .unparsed = UnparsedProperty{
+                    .property_id = unparsed.property_id.deepClone(this.allocator),
+                    .value = condition_and_fallback[1],
+                },
+            });
+        }
+    }
+};
diff --git a/src/css/css_internals.zig b/src/css/css_internals.zig
new file mode 100644
index 0000000000..46b7f133f0
--- /dev/null
+++ b/src/css/css_internals.zig
@@ -0,0 +1,266 @@
+const bun = @import("root").bun;
+const std = @import("std");
+const builtin = @import("builtin");
+const Arena = @import("../mimalloc_arena.zig").Arena;
+const Allocator = std.mem.Allocator;
+const ArrayList = std.ArrayList;
+const JSC = bun.JSC;
+const JSValue = bun.JSC.JSValue;
+const JSPromise = bun.JSC.JSPromise;
+const JSGlobalObject = bun.JSC.JSGlobalObject;
+
+threadlocal var arena_: ?Arena = null;
+
+const TestKind = enum {
+    normal,
+    minify,
+    prefix,
+};
+
+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) bun.JSError!JSC.JSValue {
+    return testingImpl(globalThis, callframe, .prefix);
+}
+
+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) bun.JSError!JSC.JSValue {
+    var arena = arena_ orelse brk: {
+        break :brk Arena.init() catch @panic("oopsie arena no good");
+    };
+    defer arena.reset();
+    const alloc = arena.allocator();
+
+    const arguments_ = callframe.arguments_old(3);
+    var arguments = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments_.slice());
+    const source_arg: JSC.JSValue = arguments.nextEat() orelse {
+        return globalThis.throw("minifyTestWithOptions: expected 2 arguments, got 0", .{});
+    };
+    if (!source_arg.isString()) {
+        return globalThis.throw("minifyTestWithOptions: expected source to be a string", .{});
+    }
+    const source_bunstr = source_arg.toBunString(globalThis);
+    defer source_bunstr.deref();
+    const source = source_bunstr.toUTF8(bun.default_allocator);
+    defer source.deinit();
+
+    const expected_arg = arguments.nextEat() orelse {
+        return globalThis.throw("minifyTestWithOptions: expected 2 arguments, got 1", .{});
+    };
+    if (!expected_arg.isString()) {
+        return globalThis.throw("minifyTestWithOptions: expected `expected` arg to be a string", .{});
+    }
+    const expected_bunstr = expected_arg.toBunString(globalThis);
+    defer expected_bunstr.deref();
+    const expected = expected_bunstr.toUTF8(bun.default_allocator);
+    defer expected.deinit();
+
+    const options_arg = arguments.nextEat();
+
+    var log = bun.logger.Log.init(alloc);
+    defer log.deinit();
+
+    const parser_options = parser_options: {
+        const opts = bun.css.ParserOptions.default(alloc, &log);
+        // if (test_kind == .prefix) break :parser_options opts;
+
+        if (options_arg) |optargs| {
+            if (optargs.isObject()) {
+                // minify_options.targets.browsers = targetsFromJS(globalThis, optarg);
+            }
+        }
+
+        break :parser_options opts;
+    };
+
+    var import_records = bun.BabyList(bun.ImportRecord){};
+    switch (bun.css.StyleSheet(bun.css.DefaultAtRule).parse(
+        alloc,
+        source.slice(),
+        parser_options,
+        &import_records,
+    )) {
+        .result => |stylesheet_| {
+            var stylesheet = stylesheet_;
+            var minify_options: bun.css.MinifyOptions = bun.css.MinifyOptions.default();
+            if (options_arg) |optarg| {
+                if (optarg.isObject()) {
+                    minify_options.targets.browsers = try targetsFromJS(globalThis, optarg);
+                }
+            }
+            _ = stylesheet.minify(alloc, minify_options).assert();
+
+            const result = stylesheet.toCss(alloc, bun.css.PrinterOptions{
+                .minify = switch (test_kind) {
+                    .minify => true,
+                    .normal => false,
+                    .prefix => false,
+                },
+                .targets = .{
+                    .browsers = minify_options.targets.browsers,
+                },
+            }, &import_records) catch |e| {
+                bun.handleErrorReturnTrace(e, @errorReturnTrace());
+                return .undefined;
+            };
+
+            return bun.String.fromBytes(result.code).toJS(globalThis);
+        },
+        .err => |err| {
+            if (log.hasAny()) {
+                return log.toJS(globalThis, bun.default_allocator, "parsing failed:");
+            }
+            return globalThis.throw("parsing failed: {}", .{err.kind});
+        },
+    }
+}
+
+fn targetsFromJS(globalThis: *JSC.JSGlobalObject, jsobj: JSValue) bun.JSError!bun.css.targets.Browsers {
+    var targets = bun.css.targets.Browsers{};
+
+    if (try jsobj.getTruthy(globalThis, "android")) |val| {
+        if (val.isInt32()) {
+            if (val.getNumber()) |value| {
+                targets.android = @intFromFloat(value);
+            }
+        }
+    }
+    if (try jsobj.getTruthy(globalThis, "chrome")) |val| {
+        if (val.isInt32()) {
+            if (val.getNumber()) |value| {
+                targets.chrome = @intFromFloat(value);
+            }
+        }
+    }
+    if (try jsobj.getTruthy(globalThis, "edge")) |val| {
+        if (val.isInt32()) {
+            if (val.getNumber()) |value| {
+                targets.edge = @intFromFloat(value);
+            }
+        }
+    }
+    if (try jsobj.getTruthy(globalThis, "firefox")) |val| {
+        if (val.isInt32()) {
+            if (val.getNumber()) |value| {
+                targets.firefox = @intFromFloat(value);
+            }
+        }
+    }
+    if (try jsobj.getTruthy(globalThis, "ie")) |val| {
+        if (val.isInt32()) {
+            if (val.getNumber()) |value| {
+                targets.ie = @intFromFloat(value);
+            }
+        }
+    }
+    if (try jsobj.getTruthy(globalThis, "ios_saf")) |val| {
+        if (val.isInt32()) {
+            if (val.getNumber()) |value| {
+                targets.ios_saf = @intFromFloat(value);
+            }
+        }
+    }
+    if (try jsobj.getTruthy(globalThis, "opera")) |val| {
+        if (val.isInt32()) {
+            if (val.getNumber()) |value| {
+                targets.opera = @intFromFloat(value);
+            }
+        }
+    }
+    if (try jsobj.getTruthy(globalThis, "safari")) |val| {
+        if (val.isInt32()) {
+            if (val.getNumber()) |value| {
+                targets.safari = @intFromFloat(value);
+            }
+        }
+    }
+    if (try jsobj.getTruthy(globalThis, "samsung")) |val| {
+        if (val.isInt32()) {
+            if (val.getNumber()) |value| {
+                targets.samsung = @intFromFloat(value);
+            }
+        }
+    }
+
+    return targets;
+}
+
+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");
+    };
+    defer arena.reset();
+    const alloc = arena.allocator();
+
+    const arguments_ = callframe.arguments_old(4);
+    var arguments = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments_.slice());
+    const source_arg: JSC.JSValue = arguments.nextEat() orelse {
+        return globalThis.throw("attrTest: expected 3 arguments, got 0", .{});
+    };
+    if (!source_arg.isString()) {
+        return globalThis.throw("attrTest: expected source to be a string", .{});
+    }
+    const source_bunstr = source_arg.toBunString(globalThis);
+    defer source_bunstr.deref();
+    const source = source_bunstr.toUTF8(bun.default_allocator);
+    defer source.deinit();
+
+    const expected_arg = arguments.nextEat() orelse {
+        return globalThis.throw("attrTest: expected 3 arguments, got 1", .{});
+    };
+    if (!expected_arg.isString()) {
+        return globalThis.throw("attrTest: expected `expected` arg to be a string", .{});
+    }
+    const expected_bunstr = expected_arg.toBunString(globalThis);
+    defer expected_bunstr.deref();
+    const expected = expected_bunstr.toUTF8(bun.default_allocator);
+    defer expected.deinit();
+
+    const minify_arg: JSC.JSValue = arguments.nextEat() orelse {
+        return globalThis.throw("attrTest: expected 3 arguments, got 2", .{});
+    };
+    const minify = minify_arg.isBoolean() and minify_arg.toBoolean();
+
+    var targets: bun.css.targets.Targets = .{};
+    if (arguments.nextEat()) |arg| {
+        if (arg.isObject()) {
+            targets.browsers = try targetsFromJS(globalThis, arg);
+        }
+    }
+
+    var log = bun.logger.Log.init(alloc);
+    defer log.deinit();
+
+    const parser_options = bun.css.ParserOptions.default(alloc, &log);
+
+    var import_records = bun.BabyList(bun.ImportRecord){};
+    switch (bun.css.StyleAttribute.parse(alloc, source.slice(), parser_options, &import_records)) {
+        .result => |stylesheet_| {
+            var stylesheet = stylesheet_;
+            var minify_options: bun.css.MinifyOptions = bun.css.MinifyOptions.default();
+            minify_options.targets = targets;
+            stylesheet.minify(alloc, minify_options);
+
+            const result = stylesheet.toCss(alloc, bun.css.PrinterOptions{
+                .minify = minify,
+                .targets = targets,
+            }, &import_records) catch |e| {
+                bun.handleErrorReturnTrace(e, @errorReturnTrace());
+                return .undefined;
+            };
+
+            return bun.String.fromBytes(result.code).toJS(globalThis);
+        },
+        .err => |err| {
+            if (log.hasAny()) {
+                return log.toJS(globalThis, bun.default_allocator, "parsing failed:");
+            }
+            return globalThis.throw("parsing failed: {}", .{err.kind});
+        },
+    }
+}
diff --git a/src/css/css_modules.zig b/src/css/css_modules.zig
new file mode 100644
index 0000000000..14767a4a8c
--- /dev/null
+++ b/src/css/css_modules.zig
@@ -0,0 +1,406 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const bun = @import("root").bun;
+const logger = bun.logger;
+const Log = logger.Log;
+
+pub const css = @import("./css_parser.zig");
+pub const css_values = @import("./values/values.zig");
+const DashedIdent = css_values.ident.DashedIdent;
+const Ident = css_values.ident.Ident;
+pub const Error = css.Error;
+const PrintErr = css.PrintErr;
+
+const ArrayList = std.ArrayListUnmanaged;
+
+pub const CssModule = struct {
+    config: *const Config,
+    sources: *const ArrayList([]const u8),
+    hashes: ArrayList([]const u8),
+    exports_by_source_index: ArrayList(CssModuleExports),
+    references: *CssModuleReferences,
+
+    pub fn new(
+        allocator: Allocator,
+        config: *const Config,
+        sources: *const ArrayList([]const u8),
+        project_root: ?[]const u8,
+        references: *CssModuleReferences,
+    ) CssModule {
+        const hashes = hashes: {
+            var hashes = ArrayList([]const u8).initCapacity(allocator, sources.items.len) catch bun.outOfMemory();
+            for (sources.items) |path| {
+                var alloced = false;
+                const source = source: {
+                    if (project_root) |root| {
+                        if (bun.path.Platform.auto.isAbsolute(root)) {
+                            alloced = true;
+                            // TODO: should we use this allocator or something else
+                            break :source allocator.dupe(u8, bun.path.relative(root, path)) catch bun.outOfMemory();
+                        }
+                    }
+                    break :source path;
+                };
+                defer if (alloced) allocator.free(source);
+                hashes.appendAssumeCapacity(hash(
+                    allocator,
+                    "{s}",
+                    .{source},
+                    config.pattern.segments.at(0).* == .hash,
+                ));
+            }
+            break :hashes hashes;
+        };
+        const exports_by_source_index = exports_by_source_index: {
+            var exports_by_source_index = ArrayList(CssModuleExports).initCapacity(allocator, sources.items.len) catch bun.outOfMemory();
+            exports_by_source_index.appendNTimesAssumeCapacity(CssModuleExports{}, sources.items.len);
+            break :exports_by_source_index exports_by_source_index;
+        };
+        return CssModule{
+            .config = config,
+            .sources = sources,
+            .references = references,
+            .hashes = hashes,
+            .exports_by_source_index = exports_by_source_index,
+        };
+    }
+
+    pub fn deinit(this: *CssModule) void {
+        _ = this; // autofix
+        // TODO: deinit
+    }
+
+    pub fn referenceDashed(
+        this: *CssModule,
+        name: []const u8,
+        from: *const ?css.css_properties.css_modules.Specifier,
+        source_index: u32,
+    ) ?[]const u8 {
+        _ = this; // autofix
+        _ = name; // autofix
+        _ = from; // autofix
+        _ = source_index; // autofix
+        @panic(css.todo_stuff.depth);
+    }
+
+    pub fn handleComposes(
+        this: *CssModule,
+        allocator: Allocator,
+        selectors: *const css.selector.parser.SelectorList,
+        composes: *const css.css_properties.css_modules.Composes,
+        source_index: u32,
+    ) css.Maybe(void, css.PrinterErrorKind) {
+        for (selectors.v.slice()) |*sel| {
+            if (sel.len() == 1) {
+                const component: *const css.selector.parser.Component = &sel.components.items[0];
+                switch (component.*) {
+                    .class => |id| {
+                        for (composes.names.slice()) |name| {
+                            const reference: CssModuleReference = if (composes.from) |*specifier|
+                                switch (specifier.*) {
+                                    .source_index => |dep_source_index| {
+                                        if (this.exports_by_source_index.items[dep_source_index].get(name.v)) |entry| {
+                                            const entry_name = entry.name;
+                                            const composes2 = &entry.composes;
+                                            const @"export" = this.exports_by_source_index.items[source_index].getPtr(id.v).?;
+
+                                            @"export".composes.append(allocator, .{ .local = .{ .name = entry_name } }) catch bun.outOfMemory();
+                                            @"export".composes.appendSlice(allocator, composes2.items) catch bun.outOfMemory();
+                                        }
+                                        continue;
+                                    },
+                                    .global => CssModuleReference{ .global = .{ .name = name.v } },
+                                    .file => |file| CssModuleReference{
+                                        .dependency = .{
+                                            .name = name.v,
+                                            .specifier = file,
+                                        },
+                                    },
+                                }
+                            else
+                                CssModuleReference{
+                                    .local = .{
+                                        .name = this.config.pattern.writeToString(
+                                            allocator,
+                                            ArrayList(u8){},
+                                            this.hashes.items[source_index],
+                                            this.sources.items[source_index],
+                                            name.v,
+                                        ),
+                                    },
+                                };
+
+                            const export_value = this.exports_by_source_index.items[source_index].getPtr(id.v) orelse unreachable;
+                            export_value.composes.append(allocator, reference) catch bun.outOfMemory();
+
+                            const contains_reference = brk: {
+                                for (export_value.composes.items) |*compose_| {
+                                    const compose: *const CssModuleReference = compose_;
+                                    if (compose.eql(&reference)) {
+                                        break :brk true;
+                                    }
+                                }
+                                break :brk false;
+                            };
+                            if (!contains_reference) {
+                                export_value.composes.append(allocator, reference) catch bun.outOfMemory();
+                            }
+                        }
+                    },
+                    else => {},
+                }
+            }
+
+            // The composes property can only be used within a simple class selector.
+            return .{ .err = css.PrinterErrorKind.invalid_composes_selector };
+        }
+
+        return .{ .result = {} };
+    }
+
+    pub fn addDashed(this: *CssModule, allocator: Allocator, local: []const u8, source_index: u32) void {
+        const gop = this.exports_by_source_index.items[source_index].getOrPut(allocator, local) catch bun.outOfMemory();
+        if (!gop.found_existing) {
+            gop.value_ptr.* = CssModuleExport{
+                // todo_stuff.depth
+                .name = this.config.pattern.writeToStringWithPrefix(
+                    allocator,
+                    "--",
+                    this.hashes.items[source_index],
+                    this.sources.items[source_index],
+                    local[2..],
+                ),
+                .composes = .{},
+                .is_referenced = false,
+            };
+        }
+    }
+
+    pub fn addLocal(this: *CssModule, allocator: Allocator, exported: []const u8, local: []const u8, source_index: u32) void {
+        const gop = this.exports_by_source_index.items[source_index].getOrPut(allocator, exported) catch bun.outOfMemory();
+        if (!gop.found_existing) {
+            gop.value_ptr.* = CssModuleExport{
+                // todo_stuff.depth
+                .name = this.config.pattern.writeToString(
+                    allocator,
+                    .{},
+                    this.hashes.items[source_index],
+                    this.sources.items[source_index],
+                    local,
+                ),
+                .composes = .{},
+                .is_referenced = false,
+            };
+        }
+    }
+};
+
+/// Configuration for CSS modules.
+pub const Config = struct {
+    /// The name pattern to use when renaming class names and other identifiers.
+    /// Default is `[hash]_[local]`.
+    pattern: Pattern,
+
+    /// Whether to rename dashed identifiers, e.g. custom properties.
+    dashed_idents: bool,
+
+    /// Whether to scope animation names.
+    /// Default is `true`.
+    animation: bool,
+
+    /// Whether to scope grid names.
+    /// Default is `true`.
+    grid: bool,
+
+    /// Whether to scope custom identifiers
+    /// Default is `true`.
+    custom_idents: bool,
+};
+
+/// A CSS modules class name pattern.
+pub const Pattern = struct {
+    /// The list of segments in the pattern.
+    segments: css.SmallList(Segment, 2),
+
+    /// Write the substituted pattern to a destination.
+    pub fn write(
+        this: *const Pattern,
+        hash_: []const u8,
+        path: []const u8,
+        local: []const u8,
+        closure: anytype,
+        comptime writefn: *const fn (@TypeOf(closure), []const u8, replace_dots: bool) void,
+    ) void {
+        for (this.segments.slice()) |*segment| {
+            switch (segment.*) {
+                .literal => |s| {
+                    writefn(closure, s, false);
+                },
+                .name => {
+                    const stem = std.fs.path.stem(path);
+                    if (std.mem.indexOf(u8, stem, ".")) |_| {
+                        writefn(closure, stem, true);
+                    } else {
+                        writefn(closure, stem, false);
+                    }
+                },
+                .local => {
+                    writefn(closure, local, false);
+                },
+                .hash => {
+                    writefn(closure, hash_, false);
+                },
+            }
+        }
+    }
+
+    pub fn writeToStringWithPrefix(
+        this: *const Pattern,
+        allocator: Allocator,
+        comptime prefix: []const u8,
+        hash_: []const u8,
+        path: []const u8,
+        local: []const u8,
+    ) []const u8 {
+        const Closure = struct { res: ArrayList(u8), allocator: Allocator };
+        var closure = Closure{ .res = .{}, .allocator = allocator };
+        this.write(
+            hash_,
+            path,
+            local,
+            &closure,
+            struct {
+                pub fn writefn(self: *Closure, slice: []const u8, replace_dots: bool) void {
+                    self.res.appendSlice(self.allocator, prefix) catch bun.outOfMemory();
+                    if (replace_dots) {
+                        const start = self.res.items.len;
+                        self.res.appendSlice(self.allocator, slice) catch bun.outOfMemory();
+                        const end = self.res.items.len;
+                        for (self.res.items[start..end]) |*c| {
+                            if (c.* == '.') {
+                                c.* = '-';
+                            }
+                        }
+                        return;
+                    }
+                    self.res.appendSlice(self.allocator, slice) catch bun.outOfMemory();
+                }
+            }.writefn,
+        );
+        return closure.res.items;
+    }
+
+    pub fn writeToString(
+        this: *const Pattern,
+        allocator: Allocator,
+        res_: ArrayList(u8),
+        hash_: []const u8,
+        path: []const u8,
+        local: []const u8,
+    ) []const u8 {
+        var res = res_;
+        const Closure = struct { res: *ArrayList(u8), allocator: Allocator };
+        var closure = Closure{ .res = &res, .allocator = allocator };
+        this.write(
+            hash_,
+            path,
+            local,
+            &closure,
+            struct {
+                pub fn writefn(self: *Closure, slice: []const u8, replace_dots: bool) void {
+                    if (replace_dots) {
+                        const start = self.res.items.len;
+                        self.res.appendSlice(self.allocator, slice) catch bun.outOfMemory();
+                        const end = self.res.items.len;
+                        for (self.res.items[start..end]) |*c| {
+                            if (c.* == '.') {
+                                c.* = '-';
+                            }
+                        }
+                        return;
+                    }
+                    self.res.appendSlice(self.allocator, slice) catch bun.outOfMemory();
+                    return;
+                }
+            }.writefn,
+        );
+
+        return res.items;
+    }
+};
+
+/// A segment in a CSS modules class name pattern.
+///
+/// See [Pattern](Pattern).
+pub const Segment = union(enum) {
+    /// A literal string segment.
+    literal: []const u8,
+
+    /// The base file name.
+    name,
+
+    /// The original class name.
+    local,
+
+    /// A hash of the file name.
+    hash,
+};
+
+/// A map of exported names to values.
+pub const CssModuleExports = std.StringArrayHashMapUnmanaged(CssModuleExport);
+
+/// A map of placeholders to references.
+pub const CssModuleReferences = std.StringArrayHashMapUnmanaged(CssModuleReference);
+
+/// An exported value from a CSS module.
+pub const CssModuleExport = struct {
+    /// The local (compiled) name for this export.
+    name: []const u8,
+    /// Other names that are composed by this export.
+    composes: ArrayList(CssModuleReference),
+    /// Whether the export is referenced in this file.
+    is_referenced: bool,
+};
+
+/// A referenced name within a CSS module, e.g. via the `composes` property.
+///
+/// See [CssModuleExport](CssModuleExport).
+pub const CssModuleReference = union(enum) {
+    /// A local reference.
+    local: struct {
+        /// The local (compiled) name for the reference.
+        name: []const u8,
+    },
+    /// A global reference.
+    global: struct {
+        /// The referenced global name.
+        name: []const u8,
+    },
+    /// A reference to an export in a different file.
+    dependency: struct {
+        /// The name to reference within the dependency.
+        name: []const u8,
+        /// The dependency specifier for the referenced file.
+        specifier: []const u8,
+    },
+
+    pub fn eql(this: *const @This(), other: *const @This()) bool {
+        if (@intFromEnum(this.*) != @intFromEnum(other.*)) return false;
+
+        return switch (this.*) {
+            .local => |v| bun.strings.eql(v.name, other.local.name),
+            .global => |v| bun.strings.eql(v.name, other.global.name),
+            .dependency => |v| bun.strings.eql(v.name, other.dependency.name) and bun.strings.eql(v.specifier, other.dependency.specifier),
+        };
+    }
+};
+
+// TODO: replace with bun's hash
+pub fn hash(allocator: Allocator, comptime fmt: []const u8, args: anytype, at_start: bool) []const u8 {
+    _ = fmt; // autofix
+    _ = args; // autofix
+    _ = allocator; // autofix
+    _ = at_start; // autofix
+    // @compileError(css.todo_stuff.depth);
+    @panic(css.todo_stuff.depth);
+}
diff --git a/src/css/css_parser.zig b/src/css/css_parser.zig
new file mode 100644
index 0000000000..ab434d3f0f
--- /dev/null
+++ b/src/css/css_parser.zig
@@ -0,0 +1,6830 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const bun = @import("root").bun;
+const logger = bun.logger;
+const Log = logger.Log;
+
+const ArrayList = std.ArrayListUnmanaged;
+
+const ImportRecord = bun.ImportRecord;
+const ImportKind = bun.ImportKind;
+
+pub const prefixes = @import("./prefixes.zig");
+
+pub const dependencies = @import("./dependencies.zig");
+pub const Dependency = dependencies.Dependency;
+
+pub const css_modules = @import("./css_modules.zig");
+pub const CssModuleExports = css_modules.CssModuleExports;
+pub const CssModule = css_modules.CssModule;
+pub const CssModuleReferences = css_modules.CssModuleReferences;
+pub const CssModuleReference = css_modules.CssModuleReference;
+
+pub const css_rules = @import("./rules/rules.zig");
+pub const CssRule = css_rules.CssRule;
+pub const CssRuleList = css_rules.CssRuleList;
+pub const LayerName = css_rules.layer.LayerName;
+pub const SupportsCondition = css_rules.supports.SupportsCondition;
+pub const CustomMedia = css_rules.custom_media.CustomMediaRule;
+pub const NamespaceRule = css_rules.namespace.NamespaceRule;
+pub const UnknownAtRule = css_rules.unknown.UnknownAtRule;
+pub const ImportRule = css_rules.import.ImportRule;
+pub const StyleRule = css_rules.style.StyleRule;
+pub const StyleContext = css_rules.StyleContext;
+pub const SupportsRule = css_rules.supports.SupportsRule;
+pub const TailwindAtRule = css_rules.tailwind.TailwindAtRule;
+
+pub const MinifyContext = css_rules.MinifyContext;
+
+pub const media_query = @import("./media_query.zig");
+pub const MediaList = media_query.MediaList;
+pub const MediaFeatureType = media_query.MediaFeatureType;
+
+pub const css_values = @import("./values/values.zig");
+pub const DashedIdent = css_values.ident.DashedIdent;
+pub const DashedIdentFns = css_values.ident.DashedIdentFns;
+pub const CssColor = css_values.color.CssColor;
+pub const ColorFallbackKind = css_values.color.ColorFallbackKind;
+pub const CSSString = css_values.string.CSSString;
+pub const CSSStringFns = css_values.string.CSSStringFns;
+pub const CSSInteger = css_values.number.CSSInteger;
+pub const CSSIntegerFns = css_values.number.CSSIntegerFns;
+pub const CSSNumber = css_values.number.CSSNumber;
+pub const CSSNumberFns = css_values.number.CSSNumberFns;
+pub const Ident = css_values.ident.Ident;
+pub const IdentFns = css_values.ident.IdentFns;
+pub const CustomIdent = css_values.ident.CustomIdent;
+pub const CustomIdentFns = css_values.ident.CustomIdentFns;
+pub const Url = css_values.url.Url;
+
+pub const declaration = @import("./declaration.zig");
+
+pub const css_properties = @import("./properties/properties.zig");
+pub const Property = css_properties.Property;
+pub const PropertyId = css_properties.PropertyId;
+pub const PropertyIdTag = css_properties.PropertyIdTag;
+pub const TokenList = css_properties.custom.TokenList;
+pub const TokenListFns = css_properties.custom.TokenListFns;
+
+const css_decls = @import("./declaration.zig");
+pub const DeclarationList = css_decls.DeclarationList;
+pub const DeclarationBlock = css_decls.DeclarationBlock;
+
+pub const selector = @import("./selectors/selector.zig");
+pub const SelectorList = selector.parser.SelectorList;
+pub const Selector = selector.parser.Selector;
+pub const Component = selector.parser.Component;
+pub const PseudoClass = selector.parser.PseudoClass;
+pub const PseudoElement = selector.parser.PseudoElement;
+
+pub const logical = @import("./logical.zig");
+pub const PropertyCategory = logical.PropertyCategory;
+pub const LogicalGroup = logical.LogicalGroup;
+
+pub const css_printer = @import("./printer.zig");
+pub const Printer = css_printer.Printer;
+pub const PrinterOptions = css_printer.PrinterOptions;
+pub const targets = @import("./targets.zig");
+pub const Targets = css_printer.Targets;
+// pub const Features = css_printer.Features;
+
+const context = @import("./context.zig");
+pub const PropertyHandlerContext = context.PropertyHandlerContext;
+pub const DeclarationHandler = declaration.DeclarationHandler;
+
+pub const Maybe = bun.JSC.Node.Maybe;
+// TODO: Remove existing Error defined here and replace it with these
+const errors_ = @import("./error.zig");
+pub const Err = errors_.Err;
+pub const PrinterErrorKind = errors_.PrinterErrorKind;
+pub const PrinterError = errors_.PrinterError;
+pub const ErrorLocation = errors_.ErrorLocation;
+pub const ParseError = errors_.ParseError;
+pub const ParserError = errors_.ParserError;
+pub const BasicParseError = errors_.BasicParseError;
+pub const BasicParseErrorKind = errors_.BasicParseErrorKind;
+pub const SelectorError = errors_.SelectorError;
+pub const MinifyErrorKind = errors_.MinifyErrorKind;
+pub const MinifyError = errors_.MinifyError;
+pub const MinifyErr = errors_.MinifyErr;
+
+pub const generic = @import("./generics.zig");
+pub const HASH_SEED = generic.HASH_SEED;
+
+pub const ImportConditions = css_rules.import.ImportConditions;
+
+pub const compat = @import("./compat.zig");
+
+pub const Features = targets.Features;
+pub const Feature = compat.Feature;
+
+pub const fmtPrinterError = errors_.fmtPrinterError;
+
+pub const PrintErr = error{
+    lol,
+};
+
+pub fn OOM(e: anyerror) noreturn {
+    if (comptime bun.Environment.isDebug) {
+        std.debug.assert(e == std.mem.Allocator.Error.OutOfMemory);
+    }
+    bun.outOfMemory();
+}
+
+pub const SmallList = @import("./small_list.zig").SmallList;
+pub const Bitflags = bun.Bitflags;
+
+pub const todo_stuff = struct {
+    pub const think_mem_mgmt = "TODO: think about memory management";
+
+    pub const depth = "TODO: we need to go deeper";
+
+    pub const match_ignore_ascii_case = "TODO: implement match_ignore_ascii_case";
+
+    pub const enum_property = "TODO: implement enum_property!";
+
+    pub const match_byte = "TODO: implement match_byte!";
+
+    pub const warn = "TODO: implement warning";
+};
+
+pub const VendorPrefix = packed struct(u8) {
+    /// No vendor prefixes.
+    /// 0b00000001
+    none: bool = false,
+    /// The `-webkit` vendor prefix.
+    /// 0b00000010
+    webkit: bool = false,
+    /// The `-moz` vendor prefix.
+    /// 0b00000100
+    moz: bool = false,
+    /// The `-ms` vendor prefix.
+    /// 0b00001000
+    ms: bool = false,
+    /// The `-o` vendor prefix.
+    /// 0b00010000
+    o: bool = false,
+    __unused: u3 = 0,
+
+    pub const NONE = VendorPrefix{ .none = true };
+    pub const WEBKIT = VendorPrefix{ .webkit = true };
+    pub const MOZ = VendorPrefix{ .moz = true };
+
+    /// Fields listed here so we can iterate them in the order we want
+    pub const FIELDS: []const []const u8 = &.{ "webkit", "moz", "ms", "o", "none" };
+
+    pub usingnamespace Bitflags(@This());
+
+    pub fn toCss(this: *const VendorPrefix, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        return switch (this.asBits()) {
+            VendorPrefix.asBits(.{ .webkit = true }) => dest.writeStr("-webkit-"),
+            VendorPrefix.asBits(.{ .moz = true }) => dest.writeStr("-moz-"),
+            VendorPrefix.asBits(.{ .ms = true }) => dest.writeStr("-ms-"),
+            VendorPrefix.asBits(.{ .o = true }) => dest.writeStr("-o-"),
+            else => {},
+        };
+    }
+
+    /// Returns VendorPrefix::None if empty.
+    pub fn orNone(this: VendorPrefix) VendorPrefix {
+        return this.bitwiseOr(VendorPrefix{ .none = true });
+    }
+};
+
+pub const SourceLocation = struct {
+    line: u32,
+    column: u32,
+
+    /// Create a new BasicParseError at this location for an unexpected token
+    pub fn newBasicUnexpectedTokenError(this: SourceLocation, token: Token) ParseError(ParserError) {
+        return BasicParseError.intoDefaultParseError(.{
+            .kind = .{ .unexpected_token = token },
+            .location = this,
+        });
+    }
+
+    /// Create a new ParseError at this location for an unexpected token
+    pub fn newUnexpectedTokenError(this: SourceLocation, token: Token) ParseError(ParserError) {
+        return ParseError(ParserError){
+            .kind = .{ .basic = .{ .unexpected_token = token } },
+            .location = this,
+        };
+    }
+
+    pub fn newCustomError(this: SourceLocation, err: anytype) ParseError(ParserError) {
+        return switch (@TypeOf(err)) {
+            ParserError => .{
+                .kind = .{ .custom = err },
+                .location = this,
+            },
+            BasicParseError => .{
+                .kind = .{ .custom = BasicParseError.intoDefaultParseError(err) },
+                .location = this,
+            },
+            selector.parser.SelectorParseErrorKind => .{
+                .kind = .{ .custom = selector.parser.SelectorParseErrorKind.intoDefaultParserError(err) },
+                .location = this,
+            },
+            else => @compileError("TODO implement this for: " ++ @typeName(@TypeOf(err))),
+        };
+    }
+};
+pub const Location = css_rules.Location;
+
+pub const Error = Err(ParserError);
+
+pub fn Result(comptime T: type) type {
+    return Maybe(T, ParseError(ParserError));
+}
+
+pub fn PrintResult(comptime T: type) type {
+    return Maybe(T, PrinterError);
+}
+
+pub fn todo(comptime fmt: []const u8, args: anytype) noreturn {
+    bun.Analytics.Features.todo_panic = 1;
+    std.debug.panic("TODO: " ++ fmt, args);
+}
+
+pub fn voidWrap(comptime T: type, comptime parsefn: *const fn (*Parser) Result(T)) *const fn (void, *Parser) Result(T) {
+    const Wrapper = struct {
+        fn wrapped(_: void, p: *Parser) Result(T) {
+            return parsefn(p);
+        }
+    };
+    return Wrapper.wrapped;
+}
+
+pub fn DefineListShorthand(comptime T: type) type {
+    _ = T; // autofix
+    // TODO: implement this when we implement visit?
+    // does nothing now
+    return struct {};
+}
+
+pub fn DefineShorthand(comptime T: type, comptime property_name: PropertyIdTag) type {
+    _ = property_name; // autofix
+    // TODO: validate map, make sure each field is set
+    // make sure each field is same index as in T
+    _ = T.PropertyFieldMap;
+
+    return struct {
+        /// Returns a shorthand from the longhand properties defined in the given declaration block.
+        pub fn fromLonghands(allocator: Allocator, decls: *const DeclarationBlock, vendor_prefix: VendorPrefix) ?struct { T, bool } {
+            _ = allocator; // autofix
+            _ = decls; // autofix
+            _ = vendor_prefix; // autofix
+            // var count: usize = 0;
+            // var important_count: usize = 0;
+            // var this: T = undefined;
+            // var set_fields = std.StaticBitSet(std.meta.fields(T).len).initEmpty();
+            // const all_fields_set = std.StaticBitSet(std.meta.fields(T).len).initFull();
+
+            // // Loop through each property in `decls.declarations` and then `decls.important_declarations`
+            // // The inline for loop is so we can share the code for both
+            // const DECL_FIELDS = &.{ "declarations", "important_declarations" };
+            // inline for (DECL_FIELDS) |decl_field_name| {
+            //     const decl_list: *const ArrayList(css_properties.Property) = &@field(decls, decl_field_name);
+            //     const important = comptime std.mem.eql(u8, decl_field_name, "important_declarations");
+
+            //     // Now loop through each property in the list
+            //     main_loop: for (decl_list.items) |*property| {
+            //         // The property field map maps each field in `T` to a tag of `Property`
+            //         // Here we do `inline for` to basically switch on the tag of `property` to see
+            //         // if it matches a field in `T` which maps to the same tag
+            //         //
+            //         // Basically, check that `@as(PropertyIdTag, property.*)` equals `T.PropertyFieldMap[field.name]`
+            //         inline for (std.meta.fields(@TypeOf(T.PropertyFieldMap))) |field| {
+            //             const tag: PropertyIdTag = @as(?*const PropertyIdTag, field.default_value).?.*;
+
+            //             if (@intFromEnum(@as(PropertyIdTag, property.*)) == tag) {
+            //                 if (@hasField(T.VendorPrefixMap, field.name)) {
+            //                     if (@hasField(T.VendorPrefixMap, field.name) and
+            //                         !VendorPrefix.eq(@field(property, field.name)[1], vendor_prefix))
+            //                     {
+            //                         return null;
+            //                     }
+
+            //                     @field(this, field.name) = if (@hasDecl(@TypeOf(@field(property, field.name)[0]), "clone"))
+            //                         @field(property, field.name)[0].deepClone(allocator)
+            //                     else
+            //                         @field(property, field.name)[0];
+            //                 } else {
+            //                     @field(this, field.name) = if (@hasDecl(@TypeOf(@field(property, field.name)), "clone"))
+            //                         @field(property, field.name).deepClone(allocator)
+            //                     else
+            //                         @field(property, field.name);
+            //                 }
+
+            //                 set_fields.set(std.meta.fieldIndex(T, field.name));
+            //                 count += 1;
+            //                 if (important) {
+            //                     important_count += 1;
+            //                 }
+
+            //                 continue :main_loop;
+            //             }
+            //         }
+
+            //         // If `property` matches none of the tags in `T.PropertyFieldMap` then let's try
+            //         // if it matches the tag specified by `property_name`
+            //         if (@as(PropertyIdTag, property.*) == property_name) {
+            //             inline for (std.meta.fields(@TypeOf(T.PropertyFieldMap))) |field| {
+            //                 if (@hasField(T.VendorPrefixMap, field.name)) {
+            //                     @field(this, field.name) = if (@hasDecl(@TypeOf(@field(property, field.name)[0]), "clone"))
+            //                         @field(property, field.name)[0].deepClone(allocator)
+            //                     else
+            //                         @field(property, field.name)[0];
+            //                 } else {
+            //                     @field(this, field.name) = if (@hasDecl(@TypeOf(@field(property, field.name)), "clone"))
+            //                         @field(property, field.name).deepClone(allocator)
+            //                     else
+            //                         @field(property, field.name);
+            //                 }
+
+            //                 set_fields.set(std.meta.fieldIndex(T, field.name));
+            //                 count += 1;
+            //                 if (important) {
+            //                     important_count += 1;
+            //                 }
+            //             }
+            //             continue :main_loop;
+            //         }
+
+            //         // Otherwise, try to convert to te fields using `.longhand()`
+            //         inline for (std.meta.fields(@TypeOf(T.PropertyFieldMap))) |field| {
+            //             const property_id = @unionInit(
+            //                 PropertyId,
+            //                 field.name,
+            //                 if (@hasDecl(T.VendorPrefixMap, field.name)) vendor_prefix else {},
+            //             );
+            //             const value = property.longhand(&property_id);
+            //             if (@as(PropertyIdTag, value) == @as(PropertyIdTag, property_id)) {
+            //                 @field(this, field.name) = if (@hasDecl(T.VendorPrefixMap, field.name))
+            //                     @field(value, field.name)[0]
+            //                 else
+            //                     @field(value, field.name);
+            //                 set_fields.set(std.meta.fieldIndex(T, field.name));
+            //                 count += 1;
+            //                 if (important) {
+            //                     important_count += 1;
+            //                 }
+            //             }
+            //         }
+            //     }
+            // }
+
+            // if (important_count > 0 and important_count != count) {
+            //     return null;
+            // }
+
+            // // All properties in the group must have a matching value to produce a shorthand.
+            // if (set_fields.eql(all_fields_set)) {
+            //     return .{ this, important_count > 0 };
+            // }
+
+            // return null;
+            @panic(todo_stuff.depth);
+        }
+
+        /// Returns a shorthand from the longhand properties defined in the given declaration block.
+        pub fn longhands(vendor_prefix: VendorPrefix) []const PropertyId {
+            _ = vendor_prefix; // autofix
+            // const out: []const PropertyId = comptime out: {
+            //     var out: [std.meta.fields(@TypeOf(T.PropertyFieldMap)).len]PropertyId = undefined;
+
+            //     for (std.meta.fields(@TypeOf(T.PropertyFieldMap)), 0..) |field, i| {
+            //         out[i] = @unionInit(
+            //             PropertyId,
+            //             field.name,
+            //             if (@hasField(T.VendorPrefixMap, field.name)) vendor_prefix else {},
+            //         );
+            //     }
+
+            //     break :out out;
+            // };
+            // return out;
+
+            @panic(todo_stuff.depth);
+        }
+
+        /// Returns a longhand property for this shorthand.
+        pub fn longhand(this: *const T, allocator: Allocator, property_id: *const PropertyId) ?Property {
+            _ = this; // autofix
+            _ = allocator; // autofix
+            _ = property_id; // autofix
+            // inline for (std.meta.fields(@TypeOf(T.PropertyFieldMap))) |field| {
+            //     if (@as(PropertyIdTag, property_id.*) == @field(T.PropertyFieldMap, field.name)) {
+            //         const val = if (@hasDecl(@TypeOf(@field(T, field.namee)), "clone"))
+            //             @field(this, field.name).deepClone(allocator)
+            //         else
+            //             @field(this, field.name);
+            //         return @unionInit(
+            //             Property,
+            //             field.name,
+            //             if (@field(T.VendorPrefixMap, field.name))
+            //                 .{ val, @field(property_id, field.name)[1] }
+            //             else
+            //                 val,
+            //         );
+            //     }
+            // }
+            // return null;
+            @panic(todo_stuff.depth);
+        }
+
+        /// Updates this shorthand from a longhand property.
+        pub fn setLonghand(this: *T, allocator: Allocator, property: *const Property) bool {
+            _ = this; // autofix
+            _ = allocator; // autofix
+            _ = property; // autofix
+            // inline for (std.meta.fields(T.PropertyFieldMap)) |field| {
+            //     if (@as(PropertyIdTag, property.*) == @field(T.PropertyFieldMap, field.name)) {
+            //         const val = if (@hasDecl(@TypeOf(@field(T, field.name)), "clone"))
+            //             @field(this, field.name).deepClone(allocator)
+            //         else
+            //             @field(this, field.name);
+
+            //         @field(this, field.name) = val;
+
+            //         return true;
+            //     }
+            // }
+            // return false;
+            @panic(todo_stuff.depth);
+        }
+    };
+}
+
+pub fn DefineRectShorthand(comptime T: type, comptime V: type) type {
+    return struct {
+        pub fn parse(input: *Parser) Result(T) {
+            const rect = switch (css_values.rect.Rect(V).parse(input)) {
+                .result => |v| v,
+                .err => |e| return .{ .err = e },
+            };
+
+            return .{
+                .result = .{
+                    .top = rect.top,
+                    .right = rect.right,
+                    .bottom = rect.bottom,
+                    .left = rect.left,
+                },
+            };
+        }
+
+        pub fn toCss(this: *const T, comptime W: type, dest: *Printer(W)) PrintErr!void {
+            const rect = css_values.rect.Rect(V){
+                .top = this.top,
+                .right = this.right,
+                .bottom = this.bottom,
+                .left = this.left,
+            };
+            return rect.toCss(W, dest);
+        }
+    };
+}
+
+pub fn DefineSizeShorthand(comptime T: type, comptime V: type) type {
+    if (std.meta.fields(T).len != 2) @compileError("DefineSizeShorthand must be used on a struct with 2 fields");
+    return struct {
+        pub fn toCss(this: *const T, comptime W: type, dest: *Printer(W)) PrintErr!void {
+            const size: css_values.size.Size2D(V) = .{
+                .a = @field(this, std.meta.fields(T)[0].name),
+                .b = @field(this, std.meta.fields(T)[1].name),
+            };
+            return size.toCss(W, dest);
+            // TODO: unfuck this
+            // @panic(todo_stuff.depth);
+        }
+
+        pub fn parse(input: *Parser) Result(T) {
+            const size = switch (css_values.size.Size2D(V).parse(input)) {
+                .result => |v| v,
+                .err => |e| return .{ .err = e },
+            };
+
+            var this: T = undefined;
+            @field(this, std.meta.fields(T)[0].name) = size.a;
+            @field(this, std.meta.fields(T)[1].name) = size.b;
+
+            return .{ .result = this };
+            // TODO: unfuck this
+            // @panic(todo_stuff.depth);
+        }
+    };
+}
+
+pub fn DeriveParse(comptime T: type) type {
+    const tyinfo = @typeInfo(T);
+    const is_union_enum = tyinfo == .Union;
+    const enum_type = if (comptime is_union_enum) @typeInfo(tyinfo.Union.tag_type.?) else tyinfo;
+    const enum_actual_type = if (comptime is_union_enum) tyinfo.Union.tag_type.? else T;
+
+    const Map = bun.ComptimeEnumMap(enum_actual_type);
+
+    return struct {
+        pub fn parse(input: *Parser) Result(T) {
+            if (comptime is_union_enum) {
+                const payload_count, const first_payload_index, const void_count, const first_void_index = comptime counts: {
+                    var first_void_index: ?usize = null;
+                    var first_payload_index: ?usize = null;
+                    var payload_count: usize = 0;
+                    var void_count: usize = 0;
+                    for (tyinfo.Union.fields, 0..) |field, i| {
+                        if (field.type == void) {
+                            void_count += 1;
+                            if (first_void_index == null) first_void_index = i;
+                        } else {
+                            payload_count += 1;
+                            if (first_payload_index == null) first_payload_index = i;
+                        }
+                    }
+                    if (first_payload_index == null) {
+                        @compileError("Type defined as `union(enum)` but no variant carries a payload. Make it an `enum` instead.");
+                    }
+                    if (first_void_index) |void_index| {
+                        // Check if they overlap
+                        if (first_payload_index.? < void_index and void_index < first_payload_index.? + payload_count) @compileError("Please put all the fields with data together and all the fields with no data together.");
+                        if (first_payload_index.? > void_index and first_payload_index.? < void_index + void_count) @compileError("Please put all the fields with data together and all the fields with no data together.");
+                    }
+                    break :counts .{ payload_count, first_payload_index.?, void_count, first_void_index };
+                };
+
+                return gnerateCode(input, first_payload_index, first_void_index, void_count, payload_count);
+            }
+
+            const location = input.currentSourceLocation();
+            const ident = switch (input.expectIdent()) {
+                .result => |v| v,
+                .err => |e| return .{ .err = e },
+            };
+            if (Map.getCaseInsensitiveWithEql(ident, bun.strings.eqlComptimeIgnoreLen)) |matched| {
+                inline for (bun.meta.EnumFields(enum_actual_type)) |field| {
+                    if (field.value == @intFromEnum(matched)) {
+                        if (comptime is_union_enum) return .{ .result = @unionInit(T, field.name, void) };
+                        return .{ .result = @enumFromInt(field.value) };
+                    }
+                }
+                unreachable;
+            }
+            return .{ .err = location.newUnexpectedTokenError(.{ .ident = ident }) };
+        }
+
+        /// Comptime code which constructs the parsing code for a union(enum) which could contain
+        /// void fields (fields with no associated data) and payload fields (fields which carry data),
+        /// for example:
+        ///
+        /// ```zig
+        /// /// A value for the [border-width](https://www.w3.org/TR/css-backgrounds-3/#border-width) property.
+        /// pub const BorderSideWidth = union(enum) {
+        ///     /// A UA defined `thin` value.
+        ///     thin,
+        ///     /// A UA defined `medium` value.
+        ///     medium,
+        ///     /// A UA defined `thick` value.
+        ///     thick,
+        ///     /// An explicit width.
+        ///     length: Length,
+        /// }
+        /// ```
+        ///
+        /// During parsing, we can check if it is one of the void fields (in this case `thin`, `medium`, or `thick`) by reading a single
+        /// identifier from the Parser, and checking if it matches any of the void field names. We already constructed a ComptimeEnumMap (see above)
+        /// to make this super cheap.
+        ///
+        /// If we don't get an identifier that matches any of the void fields, we can then try to parse the payload fields.
+        ///
+        /// This function is made more complicated by the fact that it tries to parse in order of the fields that were declared in the union(enum).
+        /// If, for example, all the void fields were declared after the `length: Length` field, this function will try to parse the `length` field first,
+        /// and then try to parse the void fields.
+        ///
+        /// This parsing order is a detail copied from LightningCSS. I'm not sure if it is necessary. But it could be.
+        inline fn gnerateCode(
+            input: *Parser,
+            comptime first_payload_index: usize,
+            comptime maybe_first_void_index: ?usize,
+            comptime void_count: usize,
+            comptime payload_count: usize,
+        ) Result(T) {
+            const last_payload_index = first_payload_index + payload_count - 1;
+            if (comptime maybe_first_void_index == null) {
+                inline for (tyinfo.Union.fields[first_payload_index .. first_payload_index + payload_count], first_payload_index..) |field, i| {
+                    if (comptime (i == last_payload_index)) {
+                        return .{ .result = switch (generic.parseFor(field.type)(input)) {
+                            .result => |v| @unionInit(T, field.name, v),
+                            .err => |e| return .{ .err = e },
+                        } };
+                    }
+                    if (input.tryParse(generic.parseFor(field.type), .{}).asValue()) |v| {
+                        return .{ .result = @unionInit(T, field.name, v) };
+                    }
+                }
+            }
+
+            const first_void_index = maybe_first_void_index.?;
+
+            const void_fields = bun.meta.EnumFields(T)[first_void_index .. first_void_index + void_count];
+
+            if (comptime void_count == 1) {
+                const void_field = enum_type.Enum.fields[first_void_index];
+                // The field is declared before the payload fields.
+                // So try to parse an ident matching the name of the field, then fallthrough
+                // to parsing the payload fields.
+                if (comptime first_void_index < first_payload_index) {
+                    if (input.tryParse(Parser.expectIdentMatching, .{void_field.name}).isOk()) {
+                        if (comptime is_union_enum) return .{ .result = @unionInit(T, void_field.name, {}) };
+                        return .{ .result = @enumFromInt(void_field.value) };
+                    }
+
+                    inline for (tyinfo.Union.fields[first_payload_index .. first_payload_index + payload_count], first_payload_index..) |field, i| {
+                        if (comptime (i == last_payload_index and last_payload_index > first_void_index)) {
+                            return .{ .result = switch (generic.parseFor(field.type)(input)) {
+                                .result => |v| @unionInit(T, field.name, v),
+                                .err => |e| return .{ .err = e },
+                            } };
+                        }
+                        if (input.tryParse(generic.parseFor(field.type), .{}).asValue()) |v| {
+                            return .{ .result = @unionInit(T, field.name, v) };
+                        }
+                    }
+                } else {
+                    inline for (tyinfo.Union.fields[first_payload_index .. first_payload_index + payload_count], first_payload_index..) |field, i| {
+                        if (comptime (i == last_payload_index and last_payload_index > first_void_index)) {
+                            return .{ .result = switch (generic.parseFor(field.type)(input)) {
+                                .result => |v| @unionInit(T, field.name, v),
+                                .err => |e| return .{ .err = e },
+                            } };
+                        }
+                        if (input.tryParse(generic.parseFor(field.type), .{}).asValue()) |v| {
+                            return .{ .result = @unionInit(T, field.name, v) };
+                        }
+                    }
+
+                    // We can generate this as the last statements of the function, avoiding the `input.tryParse` routine above
+                    if (input.expectIdentMatching(void_field.name).asErr()) |e| return .{ .err = e };
+                    if (comptime is_union_enum) return .{ .result = @unionInit(T, void_field.name, {}) };
+                    return .{ .result = @enumFromInt(void_field.value) };
+                }
+            } else if (comptime first_void_index < first_payload_index) {
+                // Multiple fields declared before the payload fields, use tryParse
+                const state = input.state();
+                if (input.tryParse(Parser.expectIdent, .{}).asValue()) |ident| {
+                    if (Map.getCaseInsensitiveWithEql(ident, bun.strings.eqlComptimeIgnoreLen)) |matched| {
+                        inline for (void_fields) |field| {
+                            if (field.value == @intFromEnum(matched)) {
+                                if (comptime is_union_enum) return .{ .result = @unionInit(T, field.name, {}) };
+                                return .{ .result = @enumFromInt(field.value) };
+                            }
+                        }
+                        unreachable;
+                    }
+                    input.reset(&state);
+                }
+
+                inline for (tyinfo.Union.fields[first_payload_index .. first_payload_index + payload_count], first_payload_index..) |field, i| {
+                    if (comptime (i == last_payload_index and last_payload_index > first_void_index)) {
+                        return .{ .result = switch (generic.parseFor(field.type)(input)) {
+                            .result => |v| @unionInit(T, field.name, v),
+                            .err => |e| return .{ .err = e },
+                        } };
+                    }
+                    if (input.tryParse(generic.parseFor(field.type), .{}).asValue()) |v| {
+                        return .{ .result = @unionInit(T, field.name, v) };
+                    }
+                }
+            } else if (comptime first_void_index > first_payload_index) {
+                inline for (tyinfo.Union.fields[first_payload_index .. first_payload_index + payload_count], first_payload_index..) |field, i| {
+                    if (comptime (i == last_payload_index and last_payload_index > first_void_index)) {
+                        return .{ .result = switch (generic.parseFor(field.type)(input)) {
+                            .result => |v| @unionInit(T, field.name, v),
+                            .err => |e| return .{ .err = e },
+                        } };
+                    }
+                    if (input.tryParse(generic.parseFor(field.type), .{}).asValue()) |v| {
+                        return .{ .result = @unionInit(T, field.name, v) };
+                    }
+                }
+
+                const location = input.currentSourceLocation();
+                const ident = switch (input.expectIdent()) {
+                    .result => |v| v,
+                    .err => |e| return .{ .err = e },
+                };
+                if (Map.getCaseInsensitiveWithEql(ident, bun.strings.eqlComptimeIgnoreLen)) |matched| {
+                    inline for (void_fields) |field| {
+                        if (field.value == @intFromEnum(matched)) {
+                            if (comptime is_union_enum) return .{ .result = @unionInit(T, field.name, {}) };
+                            return .{ .result = @enumFromInt(field.value) };
+                        }
+                    }
+                    unreachable;
+                }
+                return .{ .err = location.newUnexpectedTokenError(.{ .ident = ident }) };
+            }
+            @compileError("SHOULD BE UNREACHABLE!");
+        }
+
+        // inline fn generatePayloadBranches(
+        //     input: *Parser,
+        //     comptime first_payload_index: usize,
+        //     comptime first_void_index: usize,
+        //     comptime payload_count: usize,
+        // ) Result(T) {
+        //     const last_payload_index = first_payload_index + payload_count - 1;
+        //     inline for (tyinfo.Union.fields[first_payload_index..], first_payload_index..) |field, i| {
+        //         if (comptime (i == last_payload_index and last_payload_index > first_void_index)) {
+        //             return generic.parseFor(field.type)(input);
+        //         }
+        //         if (input.tryParse(generic.parseFor(field.type), .{}).asValue()) |v| {
+        //             return .{ .result = @unionInit(T, field.name, v) };
+        //         }
+        //     }
+        //     // The last field will return so this is never reachable
+        //     unreachable;
+        // }
+
+        // pub fn parse(this: *const T, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        //     // to implement this, we need to cargo expand the derive macro
+        //     _ = this; // autofix
+        //     _ = dest; // autofix
+        //     @compileError(todo_stuff.depth);
+        // }
+    };
+}
+
+/// This uses comptime reflection to generate a `toCss` function enums and union(enum)s.
+///
+/// Supported payload types for union(enum)s are:
+/// - any type that has a `toCss` function
+/// - void types (stringifies the identifier)
+/// - optional types (unwraps the optional)
+/// - anonymous structs, will automatically serialize it if it has a `__generateToCss` function
+pub fn DeriveToCss(comptime T: type) type {
+    const tyinfo = @typeInfo(T);
+    const enum_fields = bun.meta.EnumFields(T);
+    const is_enum_or_union_enum = tyinfo == .Union or tyinfo == .Enum;
+
+    return struct {
+        pub fn toCss(this: *const T, comptime W: type, dest: *Printer(W)) PrintErr!void {
+            if (comptime is_enum_or_union_enum) {
+                inline for (std.meta.fields(T), 0..) |field, i| {
+                    if (@intFromEnum(this.*) == enum_fields[i].value) {
+                        if (comptime field.type == void) {
+                            return dest.writeStr(enum_fields[i].name);
+                        } else if (comptime generic.hasToCss(field.type)) {
+                            return generic.toCss(field.type, &@field(this, field.name), W, dest);
+                        } else if (@hasDecl(field.type, "__generateToCss") and @typeInfo(field.type) == .Struct) {
+                            const variant_fields = std.meta.fields(field.type);
+                            if (variant_fields.len > 1) {
+                                const last = variant_fields.len - 1;
+                                inline for (variant_fields, 0..) |variant_field, j| {
+                                    // Unwrap it from the optional
+                                    if (@typeInfo(variant_field.type) == .Optional) {
+                                        if (@field(@field(this, field.name), variant_field.name)) |*value| {
+                                            try value.toCss(W, dest);
+                                        }
+                                    } else {
+                                        try @field(@field(this, field.name), variant_field.name).toCss(W, dest);
+                                    }
+
+                                    // Emit a space if there are more fields after
+                                    if (comptime j != last) {
+                                        try dest.writeChar(' ');
+                                    }
+                                }
+                            } else {
+                                const variant_field = variant_fields[0];
+                                try @field(variant_field.type, "toCss")(@field(@field(this, field.name), variant_field.name), W, dest);
+                            }
+                        } else {
+                            @compileError("Don't know how to serialize this variant: " ++ @typeName(field.type) ++ ", on " ++ @typeName(T) ++ ".\n\nYou probably want to implement a `toCss` function for this type, or add a dummy `fn __generateToCss() void {}` to the type signal that it is okay for it to be auto-generated by this function..");
+                        }
+                    }
+                }
+            } else {
+                @compileError("Unsupported type: " ++ @typeName(T));
+            }
+            return;
+        }
+    };
+}
+
+pub const enum_property_util = struct {
+    pub fn asStr(comptime T: type, this: *const T) []const u8 {
+        const tag = @intFromEnum(this.*);
+        inline for (bun.meta.EnumFields(T)) |field| {
+            if (tag == field.value) return field.name;
+        }
+        unreachable;
+    }
+
+    pub inline fn parse(comptime T: type, input: *Parser) Result(T) {
+        const location = input.currentSourceLocation();
+        const ident = switch (input.expectIdent()) {
+            .err => |e| return .{ .err = e },
+            .result => |v| v,
+        };
+
+        const Map = comptime bun.ComptimeEnumMap(T);
+        if (Map.getASCIIICaseInsensitive(ident)) |x| return .{ .result = x };
+        // inline for (std.meta.fields(T)) |field| {
+        //     if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(ident, field.name)) return .{ .result = @enumFromInt(field.value) };
+        // }
+
+        return .{ .err = location.newUnexpectedTokenError(.{ .ident = ident }) };
+    }
+
+    pub fn toCss(comptime T: type, this: *const T, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        return dest.writeStr(asStr(T, this));
+    }
+};
+
+pub fn DefineEnumProperty(comptime T: type) type {
+    const fields: []const std.builtin.Type.EnumField = std.meta.fields(T);
+
+    return struct {
+        pub fn eql(lhs: *const T, rhs: *const T) bool {
+            return @intFromEnum(lhs.*) == @intFromEnum(rhs.*);
+        }
+
+        pub fn asStr(this: *const T) []const u8 {
+            const tag = @intFromEnum(this.*);
+            inline for (fields) |field| {
+                if (tag == field.value) return field.name;
+            }
+            unreachable;
+        }
+
+        pub fn parse(input: *Parser) Result(T) {
+            const location = input.currentSourceLocation();
+            const ident = switch (input.expectIdent()) {
+                .err => |e| return .{ .err = e },
+                .result => |v| v,
+            };
+
+            // todo_stuff.match_ignore_ascii_case
+            inline for (fields) |field| {
+                if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(ident, field.name)) return .{ .result = @enumFromInt(field.value) };
+            }
+
+            return .{ .err = location.newUnexpectedTokenError(.{ .ident = ident }) };
+            // @panic("TODO renable this");
+        }
+
+        pub fn toCss(this: *const T, comptime W: type, dest: *Printer(W)) PrintErr!void {
+            return dest.writeStr(asStr(this));
+        }
+
+        pub inline fn deepClone(this: *const T, _: std.mem.Allocator) T {
+            return this.*;
+        }
+
+        pub fn hash(this: *const T, hasher: *std.hash.Wyhash) void {
+            const tag = @intFromEnum(this.*);
+            hasher.update(std.mem.asBytes(&tag));
+        }
+    };
+}
+
+pub fn DeriveValueType(comptime T: type) type {
+    _ = @typeInfo(T).Enum;
+
+    const ValueTypeMap = T.ValueTypeMap;
+    const field_values: []const MediaFeatureType = field_values: {
+        const fields = std.meta.fields(T);
+        var mapping: [fields.len]MediaFeatureType = undefined;
+        for (fields, 0..) |field, i| {
+            // Check that it exists in the type map
+            mapping[i] = @field(ValueTypeMap, field.name);
+        }
+        const mapping_final = mapping;
+        break :field_values mapping_final[0..];
+    };
+
+    return struct {
+        pub fn valueType(this: *const T) MediaFeatureType {
+            inline for (std.meta.fields(T), 0..) |field, i| {
+                if (field.value == @intFromEnum(this.*)) {
+                    return field_values[i];
+                }
+            }
+            unreachable;
+        }
+    };
+}
+
+fn consume_until_end_of_block(block_type: BlockType, tokenizer: *Tokenizer) void {
+    const StackCount = 16;
+    var sfb = std.heap.stackFallback(@sizeOf(BlockType) * StackCount, tokenizer.allocator);
+    const alloc = sfb.get();
+    var stack = std.ArrayList(BlockType).initCapacity(alloc, StackCount) catch unreachable;
+    defer stack.deinit();
+
+    stack.appendAssumeCapacity(block_type);
+
+    while (switch (tokenizer.next()) {
+        .result => |v| v,
+        .err => null,
+    }) |tok| {
+        if (BlockType.closing(&tok)) |b| {
+            if (stack.getLast() == b) {
+                _ = stack.pop();
+                if (stack.items.len == 0) return;
+            }
+        }
+
+        if (BlockType.opening(&tok)) |bt| stack.append(bt) catch unreachable;
+    }
+}
+
+fn parse_at_rule(
+    allocator: Allocator,
+    start: *const ParserState,
+    name: []const u8,
+    input: *Parser,
+    comptime P: type,
+    parser: *P,
+) Result(P.AtRuleParser.AtRule) {
+    _ = allocator; // autofix
+    ValidAtRuleParser(P);
+    const delimiters = Delimiters{ .semicolon = true, .curly_bracket = true };
+    const Closure = struct {
+        name: []const u8,
+        parser: *P,
+
+        pub fn parsefn(this: *@This(), input2: *Parser) Result(P.AtRuleParser.Prelude) {
+            return P.AtRuleParser.parsePrelude(this.parser, this.name, input2);
+        }
+    };
+    var closure = Closure{ .name = name, .parser = parser };
+    const prelude: P.AtRuleParser.Prelude = switch (input.parseUntilBefore(delimiters, P.AtRuleParser.Prelude, &closure, Closure.parsefn)) {
+        .result => |vvv| vvv,
+        .err => |e| {
+            // const end_position = input.position();
+            // _ = end_position; k
+            out: {
+                const tok = switch (input.next()) {
+                    .result => |v| v,
+                    .err => break :out,
+                };
+                if (tok.* != .open_curly and tok.* != .semicolon) bun.unreachablePanic("Should have consumed these delimiters", .{});
+                break :out;
+            }
+            return .{ .err = e };
+        },
+    };
+    const next = switch (input.next()) {
+        .result => |v| v.*,
+        .err => {
+            return switch (P.AtRuleParser.ruleWithoutBlock(parser, prelude, start)) {
+                .result => |v| {
+                    return .{ .result = v };
+                },
+                .err => {
+                    return .{ .err = input.newUnexpectedTokenError(.semicolon) };
+                },
+            };
+        },
+    };
+    switch (next) {
+        .semicolon => {
+            switch (P.AtRuleParser.ruleWithoutBlock(parser, prelude, start)) {
+                .result => |v| {
+                    return .{ .result = v };
+                },
+                .err => {
+                    return .{ .err = input.newUnexpectedTokenError(.semicolon) };
+                },
+            }
+        },
+        .open_curly => {
+            const AnotherClosure = struct {
+                prelude: P.AtRuleParser.Prelude,
+                start: *const ParserState,
+                parser: *P,
+                pub fn parsefn(this: *@This(), input2: *Parser) Result(P.AtRuleParser.AtRule) {
+                    return P.AtRuleParser.parseBlock(this.parser, this.prelude, this.start, input2);
+                }
+            };
+            var another_closure = AnotherClosure{
+                .prelude = prelude,
+                .start = start,
+                .parser = parser,
+            };
+            return parse_nested_block(input, P.AtRuleParser.AtRule, &another_closure, AnotherClosure.parsefn);
+        },
+        else => {
+            bun.unreachablePanic("", .{});
+        },
+    }
+}
+
+fn parse_custom_at_rule_prelude(name: []const u8, input: *Parser, options: *const ParserOptions, comptime T: type, at_rule_parser: *T) Result(AtRulePrelude(T.CustomAtRuleParser.Prelude)) {
+    ValidCustomAtRuleParser(T);
+    switch (T.CustomAtRuleParser.parsePrelude(at_rule_parser, name, input, options)) {
+        .result => |prelude| {
+            return .{ .result = .{ .custom = prelude } };
+        },
+        .err => |e| {
+            if (e.kind == .basic and e.kind.basic == .at_rule_invalid) {
+                // do nothing
+            } else return .{
+                .err = input.newCustomError(
+                    ParserError{ .at_rule_prelude_invalid = {} },
+                ),
+            };
+        },
+    }
+
+    options.warn(input.newError(.{ .at_rule_invalid = name }));
+    input.skipWhitespace();
+    const tokens = switch (TokenListFns.parse(input, options, 0)) {
+        .err => |e| return .{ .err = e },
+        .result => |v| v,
+    };
+    return .{ .result = .{ .unknown = .{
+        .name = name,
+        .tokens = tokens,
+    } } };
+}
+
+fn parse_custom_at_rule_without_block(
+    comptime T: type,
+    prelude: T.CustomAtRuleParser.Prelude,
+    start: *const ParserState,
+    options: *const ParserOptions,
+    at_rule_parser: *T,
+    is_nested: bool,
+) Maybe(CssRule(T.CustomAtRuleParser.AtRule), void) {
+    return switch (T.CustomAtRuleParser.ruleWithoutBlock(at_rule_parser, prelude, start, options, is_nested)) {
+        .result => |v| .{ .result = CssRule(T.CustomAtRuleParser.AtRule){ .custom = v } },
+        .err => |e| .{ .err = e },
+    };
+}
+
+fn parse_custom_at_rule_body(
+    comptime T: type,
+    prelude: T.CustomAtRuleParser.Prelude,
+    input: *Parser,
+    start: *const ParserState,
+    options: *const ParserOptions,
+    at_rule_parser: *T,
+    is_nested: bool,
+) Result(T.CustomAtRuleParser.AtRule) {
+    const result = switch (T.CustomAtRuleParser.parseBlock(at_rule_parser, prelude, start, input, options, is_nested)) {
+        .result => |vv| vv,
+        .err => |e| {
+            _ = e; // autofix
+            // match &err.kind {
+            //   ParseErrorKind::Basic(kind) => ParseError {
+            //     kind: ParseErrorKind::Basic(kind.clone()),
+            //     location: err.location,
+            //   },
+            //   _ => input.new_error(BasicParseErrorKind::AtRuleBodyInvalid),
+            // }
+            todo("This part here", .{});
+        },
+    };
+    return .{ .result = result };
+}
+
+fn parse_qualified_rule(
+    start: *const ParserState,
+    input: *Parser,
+    comptime P: type,
+    parser: *P,
+    delimiters: Delimiters,
+) Result(P.QualifiedRuleParser.QualifiedRule) {
+    ValidQualifiedRuleParser(P);
+    const prelude_result = brk: {
+        const prelude = input.parseUntilBefore(delimiters, P.QualifiedRuleParser.Prelude, parser, P.QualifiedRuleParser.parsePrelude);
+        break :brk prelude;
+    };
+    if (input.expectCurlyBracketBlock().asErr()) |e| return .{ .err = e };
+    const prelude = switch (prelude_result) {
+        .err => |e| return .{ .err = e },
+        .result => |v| v,
+    };
+    const Closure = struct {
+        start: *const ParserState,
+        prelude: P.QualifiedRuleParser.Prelude,
+        parser: *P,
+
+        pub fn parsefn(this: *@This(), input2: *Parser) Result(P.QualifiedRuleParser.QualifiedRule) {
+            return P.QualifiedRuleParser.parseBlock(this.parser, this.prelude, this.start, input2);
+        }
+    };
+    var closure = Closure{
+        .start = start,
+        .prelude = prelude,
+        .parser = parser,
+    };
+    return parse_nested_block(input, P.QualifiedRuleParser.QualifiedRule, &closure, Closure.parsefn);
+}
+
+fn parse_until_before(
+    parser: *Parser,
+    delimiters_: Delimiters,
+    error_behavior: ParseUntilErrorBehavior,
+    comptime T: type,
+    closure: anytype,
+    comptime parse_fn: *const fn (@TypeOf(closure), *Parser) Result(T),
+) Result(T) {
+    const delimiters = parser.stop_before.bitwiseOr(delimiters_);
+    const result = result: {
+        var delimited_parser = Parser{
+            .input = parser.input,
+            .at_start_of = if (parser.at_start_of) |block_type| brk: {
+                parser.at_start_of = null;
+                break :brk block_type;
+            } else null,
+            .stop_before = delimiters,
+            .import_records = parser.import_records,
+        };
+        const result = delimited_parser.parseEntirely(T, closure, parse_fn);
+        if (error_behavior == .stop and result.isErr()) {
+            return result;
+        }
+        if (delimited_parser.at_start_of) |block_type| {
+            consume_until_end_of_block(block_type, &delimited_parser.input.tokenizer);
+        }
+        break :result result;
+    };
+
+    // FIXME: have a special-purpose tokenizer method for this that does less work.
+    while (true) {
+        if (delimiters.contains(Delimiters.fromByte(parser.input.tokenizer.nextByte()))) break;
+
+        switch (parser.input.tokenizer.next()) {
+            .result => |token| {
+                if (BlockType.opening(&token)) |block_type| {
+                    consume_until_end_of_block(block_type, &parser.input.tokenizer);
+                }
+            },
+            else => break,
+        }
+    }
+
+    return result;
+}
+
+// fn parse_until_before_impl(parser: *Parser, delimiters: Delimiters, error_behavior: Parse
+
+pub fn parse_until_after(
+    parser: *Parser,
+    delimiters: Delimiters,
+    error_behavior: ParseUntilErrorBehavior,
+    comptime T: type,
+    closure: anytype,
+    comptime parsefn: *const fn (@TypeOf(closure), *Parser) Result(T),
+) Result(T) {
+    const result = parse_until_before(parser, delimiters, error_behavior, T, closure, parsefn);
+    const is_err = result.isErr();
+    if (error_behavior == .stop and is_err) {
+        return result;
+    }
+    const next_byte = parser.input.tokenizer.nextByte();
+    if (next_byte != null and !parser.stop_before.contains(Delimiters.fromByte(next_byte))) {
+        bun.debugAssert(delimiters.contains(Delimiters.fromByte(next_byte)));
+        // We know this byte is ASCII.
+        parser.input.tokenizer.advance(1);
+        if (next_byte == '{') {
+            consume_until_end_of_block(BlockType.curly_bracket, &parser.input.tokenizer);
+        }
+    }
+    return result;
+}
+
+fn parse_nested_block(parser: *Parser, comptime T: type, closure: anytype, comptime parsefn: *const fn (@TypeOf(closure), *Parser) Result(T)) Result(T) {
+    const block_type: BlockType = if (parser.at_start_of) |block_type| brk: {
+        parser.at_start_of = null;
+        break :brk block_type;
+    } else @panic(
+        \\
+        \\A nested parser can only be created when a Function,
+        \\ParenthisisBlock, SquareBracketBlock, or CurlyBracketBlock
+        \\token was just consumed.
+    );
+
+    const closing_delimiter = switch (block_type) {
+        .curly_bracket => Delimiters{ .close_curly_bracket = true },
+        .square_bracket => Delimiters{ .close_square_bracket = true },
+        .parenthesis => Delimiters{ .close_parenthesis = true },
+    };
+    var nested_parser = Parser{
+        .input = parser.input,
+        .stop_before = closing_delimiter,
+        .import_records = parser.import_records,
+    };
+    const result = nested_parser.parseEntirely(T, closure, parsefn);
+    if (nested_parser.at_start_of) |block_type2| {
+        consume_until_end_of_block(block_type2, &nested_parser.input.tokenizer);
+    }
+    consume_until_end_of_block(block_type, &parser.input.tokenizer);
+    return result;
+}
+
+pub fn ValidQualifiedRuleParser(comptime T: type) void {
+    // The intermediate representation of a qualified rule prelude.
+    _ = T.QualifiedRuleParser.Prelude;
+
+    // The finished representation of a qualified rule.
+    _ = T.QualifiedRuleParser.QualifiedRule;
+
+    // Parse the prelude of a qualified rule. For style rules, this is as Selector list.
+    //
+    // Return the representation of the prelude,
+    // or `Err(())` to ignore the entire at-rule as invalid.
+    //
+    // The prelude is the part before the `{ /* ... */ }` block.
+    //
+    // The given `input` is a "delimited" parser
+    // that ends where the prelude should end (before the next `{`).
+    //
+    // fn parsePrelude(this: *T, input: *Parser) Error!T.QualifiedRuleParser.Prelude;
+    _ = T.QualifiedRuleParser.parsePrelude;
+
+    // Parse the content of a `{ /* ... */ }` block for the body of the qualified rule.
+    //
+    // The location passed in is source location of the start of the prelude.
+    //
+    // Return the finished representation of the qualified rule
+    // as returned by `RuleListParser::next`,
+    // or `Err(())` to ignore the entire at-rule as invalid.
+    //
+    // fn parseBlock(this: *T, prelude: P.QualifiedRuleParser.Prelude, start: *const ParserState, input: *Parser) Error!P.QualifiedRuleParser.QualifiedRule;
+    _ = T.QualifiedRuleParser.parseBlock;
+}
+
+pub const DefaultAtRule = struct {
+    pub fn toCss(_: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+        return dest.newError(.fmt_error, null);
+    }
+
+    pub fn deepClone(_: *const @This(), _: std.mem.Allocator) @This() {
+        return .{};
+    }
+};
+
+pub const DefaultAtRuleParser = struct {
+    const This = @This();
+
+    pub const CustomAtRuleParser = struct {
+        pub const Prelude = void;
+        pub const AtRule = DefaultAtRule;
+
+        pub fn parsePrelude(_: *This, name: []const u8, input: *Parser, _: *const ParserOptions) Result(Prelude) {
+            return .{ .err = input.newError(BasicParseErrorKind{ .at_rule_invalid = name }) };
+        }
+
+        pub fn parseBlock(_: *This, _: CustomAtRuleParser.Prelude, _: *const ParserState, input: *Parser, _: *const ParserOptions, _: bool) Result(CustomAtRuleParser.AtRule) {
+            return .{ .err = input.newError(BasicParseErrorKind.at_rule_body_invalid) };
+        }
+
+        pub fn ruleWithoutBlock(_: *This, _: CustomAtRuleParser.Prelude, _: *const ParserState, _: *const ParserOptions, _: bool) Maybe(CustomAtRuleParser.AtRule, void) {
+            return .{ .err = {} };
+        }
+
+        pub fn onImportRule(_: *This, _: *ImportRule, _: u32, _: u32) void {}
+    };
+};
+
+/// We may want to enable this later
+pub const ENABLE_TAILWIND_PARSING = false;
+
+pub const BundlerAtRule = if (ENABLE_TAILWIND_PARSING) TailwindAtRule else DefaultAtRule;
+pub const BundlerAtRuleParser = struct {
+    const This = @This();
+    allocator: Allocator,
+    import_records: *bun.BabyList(ImportRecord),
+    options: *const ParserOptions,
+
+    pub const CustomAtRuleParser = struct {
+        pub const Prelude = if (ENABLE_TAILWIND_PARSING) union(enum) {
+            tailwind: TailwindAtRule,
+        } else void;
+        pub const AtRule = if (ENABLE_TAILWIND_PARSING) TailwindAtRule else DefaultAtRule;
+
+        pub fn parsePrelude(this: *This, name: []const u8, input: *Parser, _: *const ParserOptions) Result(Prelude) {
+            if (comptime ENABLE_TAILWIND_PARSING) {
+                const PreludeNames = enum {
+                    tailwind,
+                };
+                const Map = comptime bun.ComptimeEnumMap(PreludeNames);
+                if (Map.getASCIIICaseInsensitive(name)) |prelude| return switch (prelude) {
+                    .tailwind => {
+                        const loc_ = input.currentSourceLocation();
+                        const loc = css_rules.Location{
+                            .source_index = this.options.source_index,
+                            .line = loc_.line,
+                            .column = loc_.column,
+                        };
+                        const style_name = switch (css_rules.tailwind.TailwindStyleName.parse(input)) {
+                            .result => |v| v,
+                            .err => return .{ .err = input.newError(BasicParseErrorKind{ .at_rule_invalid = name }) },
+                        };
+                        return .{ .result = .{
+                            .tailwind = .{
+                                .style_name = style_name,
+                                .loc = loc,
+                            },
+                        } };
+                    },
+                };
+            }
+            return .{ .err = input.newError(BasicParseErrorKind{ .at_rule_invalid = name }) };
+        }
+
+        pub fn parseBlock(_: *This, _: CustomAtRuleParser.Prelude, _: *const ParserState, input: *Parser, _: *const ParserOptions, _: bool) Result(CustomAtRuleParser.AtRule) {
+            return .{ .err = input.newError(BasicParseErrorKind.at_rule_body_invalid) };
+        }
+
+        pub fn ruleWithoutBlock(_: *This, prelude: CustomAtRuleParser.Prelude, _: *const ParserState, _: *const ParserOptions, _: bool) Maybe(CustomAtRuleParser.AtRule, void) {
+            if (comptime ENABLE_TAILWIND_PARSING) {
+                return switch (prelude) {
+                    .tailwind => |v| return .{ .result = v },
+                };
+            }
+            return .{ .err = {} };
+        }
+
+        pub fn onImportRule(this: *This, import_rule: *ImportRule, start_position: u32, end_position: u32) void {
+            const import_record_index = this.import_records.len;
+            import_rule.import_record_idx = import_record_index;
+            this.import_records.push(this.allocator, ImportRecord{
+                .path = bun.fs.Path.init(import_rule.url),
+                .kind = if (import_rule.supports != null) .at_conditional else .at,
+                .range = bun.logger.Range{
+                    .loc = bun.logger.Loc{ .start = @intCast(start_position) },
+                    .len = @intCast(end_position - start_position),
+                },
+            }) catch bun.outOfMemory();
+        }
+    };
+};
+
+/// Same as `ValidAtRuleParser` but modified to provide parser options
+///
+/// Also added:
+/// - onImportRule to handle @import rules
+pub fn ValidCustomAtRuleParser(comptime T: type) void {
+    // The intermediate representation of prelude of an at-rule.
+    _ = T.CustomAtRuleParser.Prelude;
+
+    // The finished representation of an at-rule.
+    _ = T.CustomAtRuleParser.AtRule;
+
+    // Parse the prelude of an at-rule with the given `name`.
+    //
+    // Return the representation of the prelude and the type of at-rule,
+    // or `Err(())` to ignore the entire at-rule as invalid.
+    //
+    // The prelude is the part after the at-keyword
+    // and before the `;` semicolon or `{ /* ... */ }` block.
+    //
+    // At-rule name matching should be case-insensitive in the ASCII range.
+    // This can be done with `std::ascii::Ascii::eq_ignore_ascii_case`,
+    // or with the `match_ignore_ascii_case!` macro.
+    //
+    // The given `input` is a "delimited" parser
+    // that ends wherever the prelude should end.
+    // (Before the next semicolon, the next `{`, or the end of the current block.)
+    //
+    // pub fn parsePrelude(this: *T, allocator: Allocator, name: []const u8, *Parser, options: *ParserOptions) Result(T.CustomAtRuleParser.Prelude) {}
+    _ = T.CustomAtRuleParser.parsePrelude;
+
+    // End an at-rule which doesn't have block. Return the finished
+    // representation of the at-rule.
+    //
+    // The location passed in is source location of the start of the prelude.
+    // `is_nested` indicates whether the rule is nested inside a style rule.
+    //
+    // This is only called when either the `;` semicolon indeed follows the prelude,
+    // or parser is at the end of the input.
+    _ = T.CustomAtRuleParser.ruleWithoutBlock;
+
+    // Parse the content of a `{ /* ... */ }` block for the body of the at-rule.
+    //
+    // The location passed in is source location of the start of the prelude.
+    // `is_nested` indicates whether the rule is nested inside a style rule.
+    //
+    // Return the finished representation of the at-rule
+    // as returned by `RuleListParser::next` or `DeclarationListParser::next`,
+    // or `Err(())` to ignore the entire at-rule as invalid.
+    //
+    // This is only called when a block was found following the prelude.
+    _ = T.CustomAtRuleParser.parseBlock;
+
+    _ = T.CustomAtRuleParser.onImportRule;
+}
+
+pub fn ValidAtRuleParser(comptime T: type) void {
+    _ = T.AtRuleParser.AtRule;
+    _ = T.AtRuleParser.Prelude;
+
+    // Parse the prelude of an at-rule with the given `name`.
+    //
+    // Return the representation of the prelude and the type of at-rule,
+    // or `Err(())` to ignore the entire at-rule as invalid.
+    //
+    // The prelude is the part after the at-keyword
+    // and before the `;` semicolon or `{ /* ... */ }` block.
+    //
+    // At-rule name matching should be case-insensitive in the ASCII range.
+    // This can be done with `std::ascii::Ascii::eq_ignore_ascii_case`,
+    // or with the `match_ignore_ascii_case!` macro.
+    //
+    // The given `input` is a "delimited" parser
+    // that ends wherever the prelude should end.
+    // (Before the next semicolon, the next `{`, or the end of the current block.)
+    //
+    // pub fn parsePrelude(this: *T, allocator: Allocator, name: []const u8, *Parser) Result(T.AtRuleParser.Prelude) {}
+    _ = T.AtRuleParser.parsePrelude;
+
+    // End an at-rule which doesn't have block. Return the finished
+    // representation of the at-rule.
+    //
+    // The location passed in is source location of the start of the prelude.
+    //
+    // This is only called when `parse_prelude` returned `WithoutBlock`, and
+    // either the `;` semicolon indeed follows the prelude, or parser is at
+    // the end of the input.
+    // fn ruleWithoutBlock(this: *T, allocator: Allocator, prelude: T.AtRuleParser.Prelude, state: *const ParserState) Maybe(T.AtRuleParser.AtRule, void)
+    _ = T.AtRuleParser.ruleWithoutBlock;
+
+    // Parse the content of a `{ /* ... */ }` block for the body of the at-rule.
+    //
+    // The location passed in is source location of the start of the prelude.
+    //
+    // Return the finished representation of the at-rule
+    // as returned by `RuleListParser::next` or `DeclarationListParser::next`,
+    // or `Err(())` to ignore the entire at-rule as invalid.
+    //
+    // This is only called when `parse_prelude` returned `WithBlock`, and a block
+    // was indeed found following the prelude.
+    //
+    // fn parseBlock(this: *T, prelude: T.AtRuleParser.Prelude, start: *const ParserState, input: *Parser) Error!T.AtRuleParser.AtRule
+    _ = T.AtRuleParser.parseBlock;
+}
+
+pub fn AtRulePrelude(comptime T: type) type {
+    return union(enum) {
+        font_face,
+        font_feature_values,
+        font_palette_values: DashedIdent,
+        counter_style: CustomIdent,
+        import: struct {
+            []const u8,
+            MediaList,
+            ?SupportsCondition,
+            ?struct { value: ?LayerName },
+        },
+        namespace: struct {
+            ?[]const u8,
+            []const u8,
+        },
+        charset,
+        custom_media: struct {
+            DashedIdent,
+            MediaList,
+        },
+        property: struct {
+            DashedIdent,
+        },
+        media: MediaList,
+        supports: SupportsCondition,
+        viewport: VendorPrefix,
+        keyframes: struct {
+            name: css_rules.keyframes.KeyframesName,
+            prefix: VendorPrefix,
+        },
+        page: ArrayList(css_rules.page.PageSelector),
+        moz_document,
+        layer: ArrayList(LayerName),
+        container: struct {
+            name: ?css_rules.container.ContainerName,
+            condition: css_rules.container.ContainerCondition,
+        },
+        starting_style,
+        nest: selector.parser.SelectorList,
+        scope: struct {
+            scope_start: ?selector.parser.SelectorList,
+            scope_end: ?selector.parser.SelectorList,
+        },
+        unknown: struct {
+            name: []const u8,
+            /// The tokens of the prelude
+            tokens: TokenList,
+        },
+        custom: T,
+
+        pub fn allowedInStyleRule(this: *const @This()) bool {
+            return switch (this.*) {
+                .media, .supports, .container, .moz_document, .layer, .starting_style, .scope, .nest, .unknown, .custom => true,
+                .namespace, .font_face, .font_feature_values, .font_palette_values, .counter_style, .keyframes, .page, .property, .import, .custom_media, .viewport, .charset => false,
+            };
+        }
+    };
+}
+
+pub fn TopLevelRuleParser(comptime AtRuleParserT: type) type {
+    ValidCustomAtRuleParser(AtRuleParserT);
+    const AtRuleT = AtRuleParserT.CustomAtRuleParser.AtRule;
+    const AtRulePreludeT = AtRulePrelude(AtRuleParserT.CustomAtRuleParser.Prelude);
+
+    return struct {
+        allocator: Allocator,
+        options: *const ParserOptions,
+        state: State,
+        at_rule_parser: *AtRuleParserT,
+        // TODO: think about memory management
+        rules: *CssRuleList(AtRuleT),
+
+        const State = enum(u8) {
+            start = 1,
+            layers = 2,
+            imports = 3,
+            namespaces = 4,
+            body = 5,
+        };
+
+        const This = @This();
+
+        pub const AtRuleParser = struct {
+            pub const Prelude = AtRulePreludeT;
+            pub const AtRule = void;
+
+            pub fn parsePrelude(this: *This, name: []const u8, input: *Parser) Result(Prelude) {
+                const PreludeEnum = enum {
+                    import,
+                    charset,
+                    namespace,
+                    @"custom-media",
+                    property,
+                };
+                const Map = comptime bun.ComptimeEnumMap(PreludeEnum);
+
+                if (Map.getASCIIICaseInsensitive(name)) |prelude| {
+                    switch (prelude) {
+                        .import => {
+                            if (@intFromEnum(this.state) > @intFromEnum(State.imports)) {
+                                return .{ .err = input.newCustomError(@as(ParserError, ParserError.unexpected_import_rule)) };
+                            }
+                            const url_str = switch (input.expectUrlOrString()) {
+                                .err => |e| return .{ .err = e },
+                                .result => |v| v,
+                            };
+
+                            const layer: ?struct { value: ?LayerName } =
+                                if (input.tryParse(Parser.expectIdentMatching, .{"layer"}) == .result)
+                                .{ .value = null }
+                            else if (input.tryParse(Parser.expectFunctionMatching, .{"layer"}) == .result) brk: {
+                                break :brk .{
+                                    .value = switch (input.parseNestedBlock(LayerName, {}, voidWrap(LayerName, LayerName.parse))) {
+                                        .result => |v| v,
+                                        .err => |e| return .{ .err = e },
+                                    },
+                                };
+                            } else null;
+
+                            const supports = if (input.tryParse(Parser.expectFunctionMatching, .{"supports"}) == .result) brk: {
+                                const Func = struct {
+                                    pub fn do(_: void, p: *Parser) Result(SupportsCondition) {
+                                        const result = p.tryParse(SupportsCondition.parse, .{});
+                                        if (result == .err) return SupportsCondition.parseDeclaration(p);
+                                        return result;
+                                    }
+                                };
+                                break :brk switch (input.parseNestedBlock(SupportsCondition, {}, Func.do)) {
+                                    .result => |v| v,
+                                    .err => |e| return .{ .err = e },
+                                };
+                            } else null;
+
+                            const media = switch (MediaList.parse(input)) {
+                                .err => |e| return .{ .err = e },
+                                .result => |v| v,
+                            };
+
+                            return .{
+                                .result = .{
+                                    .import = .{
+                                        url_str,
+                                        media,
+                                        supports,
+                                        if (layer) |l| .{ .value = if (l.value) |ll| ll else null } else null,
+                                    },
+                                },
+                            };
+                        },
+                        .namespace => {
+                            if (@intFromEnum(this.state) > @intFromEnum(State.namespaces)) {
+                                return .{ .err = input.newCustomError(ParserError{ .unexpected_namespace_rule = {} }) };
+                            }
+
+                            const prefix = switch (input.tryParse(Parser.expectIdent, .{})) {
+                                .result => |v| v,
+                                .err => null,
+                            };
+                            const namespace = switch (input.expectUrlOrString()) {
+                                .err => |e| return .{ .err = e },
+                                .result => |v| v,
+                            };
+                            return .{ .result = .{ .namespace = .{ prefix, namespace } } };
+                        },
+                        .charset => {
+                            // @charset is removed by rust-cssparser if it's the first rule in the stylesheet.
+                            // Anything left is technically invalid, however, users often concatenate CSS files
+                            // together, so we are more lenient and simply ignore @charset rules in the middle of a file.
+                            if (input.expectString().asErr()) |e| return .{ .err = e };
+                            return .{ .result = .charset };
+                        },
+                        .@"custom-media" => {
+                            const custom_media_name = switch (DashedIdentFns.parse(input)) {
+                                .err => |e| return .{ .err = e },
+                                .result => |v| v,
+                            };
+                            const media = switch (MediaList.parse(input)) {
+                                .err => |e| return .{ .err = e },
+                                .result => |v| v,
+                            };
+                            return .{
+                                .result = .{
+                                    .custom_media = .{
+                                        custom_media_name,
+                                        media,
+                                    },
+                                },
+                            };
+                        },
+                        .property => {
+                            const property_name = switch (DashedIdentFns.parse(input)) {
+                                .err => |e| return .{ .err = e },
+                                .result => |v| v,
+                            };
+                            return .{ .result = .{ .property = .{property_name} } };
+                        },
+                    }
+                }
+
+                const Nested = NestedRuleParser(AtRuleParserT);
+                var nested_rule_parser: Nested = this.nested();
+                return Nested.AtRuleParser.parsePrelude(&nested_rule_parser, name, input);
+            }
+
+            pub fn parseBlock(this: *This, prelude: AtRuleParser.Prelude, start: *const ParserState, input: *Parser) Result(AtRuleParser.AtRule) {
+                this.state = .body;
+                var nested_parser = this.nested();
+                return NestedRuleParser(AtRuleParserT).AtRuleParser.parseBlock(&nested_parser, prelude, start, input);
+            }
+
+            pub fn ruleWithoutBlock(this: *This, prelude: AtRuleParser.Prelude, start: *const ParserState) Maybe(AtRuleParser.AtRule, void) {
+                const loc_ = start.sourceLocation();
+                const loc = css_rules.Location{
+                    .source_index = this.options.source_index,
+                    .line = loc_.line,
+                    .column = loc_.column,
+                };
+
+                switch (prelude) {
+                    .import => {
+                        this.state = State.imports;
+                        var import_rule = ImportRule{
+                            .url = prelude.import[0],
+                            .media = prelude.import[1],
+                            .supports = prelude.import[2],
+                            .layer = if (prelude.import[3]) |v| .{ .v = v.value } else null,
+                            .loc = loc,
+                        };
+                        AtRuleParserT.CustomAtRuleParser.onImportRule(this.at_rule_parser, &import_rule, @intCast(start.position), @intCast(start.position + 1));
+                        this.rules.v.append(this.allocator, .{
+                            .import = import_rule,
+                        }) catch bun.outOfMemory();
+                        return .{ .result = {} };
+                    },
+                    .namespace => {
+                        this.state = State.namespaces;
+
+                        const prefix = prelude.namespace[0];
+                        const url = prelude.namespace[1];
+
+                        this.rules.v.append(this.allocator, .{
+                            .namespace = NamespaceRule{
+                                .prefix = if (prefix) |p| .{ .v = p } else null,
+                                .url = url,
+                                .loc = loc,
+                            },
+                        }) catch bun.outOfMemory();
+
+                        return .{ .result = {} };
+                    },
+                    .custom_media => {
+                        const name = prelude.custom_media[0];
+                        const query = prelude.custom_media[1];
+                        this.state = State.body;
+                        this.rules.v.append(
+                            this.allocator,
+                            .{
+                                .custom_media = css_rules.custom_media.CustomMediaRule{
+                                    .name = name,
+                                    .query = query,
+                                    .loc = loc,
+                                },
+                            },
+                        ) catch bun.outOfMemory();
+                        return .{ .result = {} };
+                    },
+                    .layer => {
+                        if (@intFromEnum(this.state) <= @intFromEnum(State.layers)) {
+                            this.state = .layers;
+                        } else {
+                            this.state = .body;
+                        }
+                        var nested_parser = this.nested();
+                        return NestedRuleParser(AtRuleParserT).AtRuleParser.ruleWithoutBlock(&nested_parser, prelude, start);
+                    },
+                    .charset => return .{ .result = {} },
+                    .unknown => {
+                        const name = prelude.unknown.name;
+                        const prelude2 = prelude.unknown.tokens;
+                        this.rules.v.append(this.allocator, .{ .unknown = UnknownAtRule{
+                            .name = name,
+                            .prelude = prelude2,
+                            .block = null,
+                            .loc = loc,
+                        } }) catch bun.outOfMemory();
+                        return .{ .result = {} };
+                    },
+                    .custom => {
+                        this.state = .body;
+                        var nested_parser = this.nested();
+                        return NestedRuleParser(AtRuleParserT).AtRuleParser.ruleWithoutBlock(&nested_parser, prelude, start);
+                    },
+                    else => return .{ .err = {} },
+                }
+            }
+        };
+
+        pub const QualifiedRuleParser = struct {
+            pub const Prelude = selector.parser.SelectorList;
+            pub const QualifiedRule = void;
+
+            pub fn parsePrelude(this: *This, input: *Parser) Result(Prelude) {
+                this.state = .body;
+                var nested_parser = this.nested();
+                const N = @TypeOf(nested_parser);
+                return N.QualifiedRuleParser.parsePrelude(&nested_parser, input);
+            }
+
+            pub fn parseBlock(this: *This, prelude: Prelude, start: *const ParserState, input: *Parser) Result(QualifiedRule) {
+                var nested_parser = this.nested();
+                const N = @TypeOf(nested_parser);
+                return N.QualifiedRuleParser.parseBlock(&nested_parser, prelude, start, input);
+            }
+        };
+
+        pub fn new(allocator: Allocator, options: *const ParserOptions, at_rule_parser: *AtRuleParserT, rules: *CssRuleList(AtRuleT)) @This() {
+            return .{
+                .options = options,
+                .state = .start,
+                .at_rule_parser = at_rule_parser,
+                .rules = rules,
+                .allocator = allocator,
+            };
+        }
+
+        pub fn nested(this: *This) NestedRuleParser(AtRuleParserT) {
+            return NestedRuleParser(AtRuleParserT){
+                .options = this.options,
+                .at_rule_parser = this.at_rule_parser,
+                .declarations = DeclarationList{},
+                .important_declarations = DeclarationList{},
+                .rules = this.rules,
+                .is_in_style_rule = false,
+                .allow_declarations = false,
+                .allocator = this.allocator,
+            };
+        }
+    };
+}
+
+pub fn NestedRuleParser(comptime T: type) type {
+    ValidCustomAtRuleParser(T);
+
+    const AtRuleT = T.CustomAtRuleParser.AtRule;
+
+    return struct {
+        options: *const ParserOptions,
+        at_rule_parser: *T,
+        // todo_stuff.think_mem_mgmt
+        declarations: DeclarationList,
+        // todo_stuff.think_mem_mgmt
+        important_declarations: DeclarationList,
+        // todo_stuff.think_mem_mgmt
+        rules: *CssRuleList(T.CustomAtRuleParser.AtRule),
+        is_in_style_rule: bool,
+        allow_declarations: bool,
+        allocator: Allocator,
+
+        const This = @This();
+
+        pub fn getLoc(this: *This, start: *const ParserState) Location {
+            const loc = start.sourceLocation();
+            return Location{
+                .source_index = this.options.source_index,
+                .line = loc.line,
+                .column = loc.column,
+            };
+        }
+
+        pub const AtRuleParser = struct {
+            pub const Prelude = AtRulePrelude(T.CustomAtRuleParser.Prelude);
+            pub const AtRule = void;
+
+            pub fn parsePrelude(this: *This, name: []const u8, input: *Parser) Result(Prelude) {
+                const result: Prelude = brk: {
+                    const PreludeEnum = enum {
+                        media,
+                        supports,
+                        @"font-face",
+                        @"font-palette-values",
+                        @"counter-style",
+                        viewport,
+                        keyframes,
+                        @"-ms-viewport",
+                        @"-moz-keyframes",
+                        @"-o-keyframes",
+                        @"-ms-keyframes",
+                        page,
+                        @"-moz-document",
+                        layer,
+                        container,
+                        @"starting-style",
+                        scope,
+                        nest,
+                    };
+                    const Map = comptime bun.ComptimeEnumMap(PreludeEnum);
+                    if (Map.getASCIIICaseInsensitive(name)) |kind| switch (kind) {
+                        .media => {
+                            const media = switch (MediaList.parse(input)) {
+                                .err => |e| return .{ .err = e },
+                                .result => |v| v,
+                            };
+                            break :brk .{ .media = media };
+                        },
+                        .supports => {
+                            const cond = switch (SupportsCondition.parse(input)) {
+                                .err => |e| return .{ .err = e },
+                                .result => |v| v,
+                            };
+                            break :brk .{ .supports = cond };
+                        },
+                        .@"font-face" => break :brk .font_face,
+                        .@"font-palette-values" => {
+                            const dashed_ident_name = switch (DashedIdentFns.parse(input)) {
+                                .err => |e| return .{ .err = e },
+                                .result => |v| v,
+                            };
+                            break :brk .{ .font_palette_values = dashed_ident_name };
+                        },
+                        .@"counter-style" => {
+                            const custom_name = switch (CustomIdentFns.parse(input)) {
+                                .err => |e| return .{ .err = e },
+                                .result => |v| v,
+                            };
+                            break :brk .{ .counter_style = custom_name };
+                        },
+                        .viewport, .@"-ms-viewport" => {
+                            const prefix: VendorPrefix = if (bun.strings.startsWithCaseInsensitiveAscii(name, "-ms")) VendorPrefix{ .ms = true } else VendorPrefix{ .none = true };
+                            break :brk .{ .viewport = prefix };
+                        },
+                        .keyframes, .@"-moz-keyframes", .@"-o-keyframes", .@"-ms-keyframes" => {
+                            const prefix: VendorPrefix = if (bun.strings.startsWithCaseInsensitiveAscii(name, "-webkit"))
+                                VendorPrefix{ .webkit = true }
+                            else if (bun.strings.startsWithCaseInsensitiveAscii(name, "-moz-"))
+                                VendorPrefix{ .moz = true }
+                            else if (bun.strings.startsWithCaseInsensitiveAscii(name, "-o-"))
+                                VendorPrefix{ .o = true }
+                            else if (bun.strings.startsWithCaseInsensitiveAscii(name, "-ms-")) VendorPrefix{ .ms = true } else VendorPrefix{ .none = true };
+
+                            const keyframes_name = switch (input.tryParse(css_rules.keyframes.KeyframesName.parse, .{})) {
+                                .err => |e| return .{ .err = e },
+                                .result => |v| v,
+                            };
+                            break :brk .{ .keyframes = .{ .name = keyframes_name, .prefix = prefix } };
+                        },
+                        .page => {
+                            const Fn = struct {
+                                pub fn parsefn(input2: *Parser) Result(ArrayList(css_rules.page.PageSelector)) {
+                                    return input2.parseCommaSeparated(css_rules.page.PageSelector, css_rules.page.PageSelector.parse);
+                                }
+                            };
+                            const selectors = switch (input.tryParse(Fn.parsefn, .{})) {
+                                .result => |v| v,
+                                .err => ArrayList(css_rules.page.PageSelector){},
+                            };
+                            break :brk .{ .page = selectors };
+                        },
+                        .@"-moz-document" => {
+                            // Firefox only supports the url-prefix() function with no arguments as a legacy CSS hack.
+                            // See https://css-tricks.com/snippets/css/css-hacks-targeting-firefox/
+                            if (input.expectFunctionMatching("url-prefix").asErr()) |e| return .{ .err = e };
+                            const Fn = struct {
+                                pub fn parsefn(_: void, input2: *Parser) Result(void) {
+                                    // Firefox also allows an empty string as an argument...
+                                    // https://github.com/mozilla/gecko-dev/blob/0077f2248712a1b45bf02f0f866449f663538164/servo/components/style/stylesheets/document_rule.rs#L303
+                                    _ = input2.tryParse(parseInner, .{});
+                                    if (input2.expectExhausted().asErr()) |e| return .{ .err = e };
+                                    return .{ .result = {} };
+                                }
+                                fn parseInner(input2: *Parser) Result(void) {
+                                    const s = switch (input2.expectString()) {
+                                        .err => |e| return .{ .err = e },
+                                        .result => |v| v,
+                                    };
+                                    if (s.len > 0) {
+                                        return .{ .err = input2.newCustomError(ParserError.invalid_value) };
+                                    }
+                                    return .{ .result = {} };
+                                }
+                            };
+                            if (input.parseNestedBlock(void, {}, Fn.parsefn).asErr()) |e| return .{ .err = e };
+                            break :brk .moz_document;
+                        },
+                        .layer => {
+                            const names = switch (input.parseList(LayerName, LayerName.parse)) {
+                                .result => |vv| vv,
+                                .err => |e| names: {
+                                    if (e.kind == .basic and e.kind.basic == .end_of_input) {
+                                        break :names ArrayList(LayerName){};
+                                    }
+                                    return .{ .err = e };
+                                },
+                            };
+
+                            break :brk .{ .layer = names };
+                        },
+                        .container => {
+                            const container_name = switch (input.tryParse(css_rules.container.ContainerName.parse, .{})) {
+                                .result => |vv| vv,
+                                .err => null,
+                            };
+                            const condition = switch (css_rules.container.ContainerCondition.parse(input)) {
+                                .err => |e| return .{ .err = e },
+                                .result => |v| v,
+                            };
+                            break :brk .{ .container = .{ .name = container_name, .condition = condition } };
+                        },
+                        .@"starting-style" => break :brk .starting_style,
+                        .scope => {
+                            var selector_parser = selector.parser.SelectorParser{
+                                .is_nesting_allowed = true,
+                                .options = this.options,
+                                .allocator = input.allocator(),
+                            };
+                            const Closure = struct {
+                                selector_parser: *selector.parser.SelectorParser,
+                                pub fn parsefn(self: *@This(), input2: *Parser) Result(selector.parser.SelectorList) {
+                                    return selector.parser.SelectorList.parseRelative(self.selector_parser, input2, .ignore_invalid_selector, .none);
+                                }
+                            };
+                            var closure = Closure{
+                                .selector_parser = &selector_parser,
+                            };
+
+                            const scope_start = if (input.tryParse(Parser.expectParenthesisBlock, .{}).isOk()) scope_start: {
+                                break :scope_start switch (input.parseNestedBlock(selector.parser.SelectorList, &closure, Closure.parsefn)) {
+                                    .result => |v| v,
+                                    .err => |e| return .{ .err = e },
+                                };
+                            } else null;
+
+                            const scope_end = if (input.tryParse(Parser.expectIdentMatching, .{"to"}).isOk()) scope_end: {
+                                if (input.expectParenthesisBlock().asErr()) |e| return .{ .err = e };
+                                break :scope_end switch (input.parseNestedBlock(selector.parser.SelectorList, &closure, Closure.parsefn)) {
+                                    .result => |v| v,
+                                    .err => |e| return .{ .err = e },
+                                };
+                            } else null;
+
+                            break :brk .{
+                                .scope = .{
+                                    .scope_start = scope_start,
+                                    .scope_end = scope_end,
+                                },
+                            };
+                        },
+                        .nest => {
+                            if (this.is_in_style_rule) {
+                                this.options.warn(input.newCustomError(ParserError{ .deprecated_nest_rule = {} }));
+                                var selector_parser = selector.parser.SelectorParser{
+                                    .is_nesting_allowed = true,
+                                    .options = this.options,
+                                    .allocator = input.allocator(),
+                                };
+                                const selectors = switch (selector.parser.SelectorList.parse(&selector_parser, input, .discard_list, .contained)) {
+                                    .err => |e| return .{ .err = e },
+                                    .result => |v| v,
+                                };
+                                break :brk .{ .nest = selectors };
+                            }
+                        },
+                    };
+
+                    switch (parse_custom_at_rule_prelude(
+                        name,
+                        input,
+                        this.options,
+                        T,
+                        this.at_rule_parser,
+                    )) {
+                        .result => |v| break :brk v,
+                        .err => |e| return .{ .err = e },
+                    }
+                };
+
+                if (this.is_in_style_rule and !result.allowedInStyleRule()) {
+                    return .{ .err = input.newError(BasicParseErrorKind{ .at_rule_invalid = name }) };
+                }
+
+                return .{ .result = result };
+            }
+
+            pub fn parseBlock(this: *This, prelude: AtRuleParser.Prelude, start: *const ParserState, input: *Parser) Result(AtRuleParser.AtRule) {
+                const loc = this.getLoc(start);
+                switch (prelude) {
+                    .font_face => {
+                        var decl_parser = css_rules.font_face.FontFaceDeclarationParser{};
+                        var parser = RuleBodyParser(css_rules.font_face.FontFaceDeclarationParser).new(input, &decl_parser);
+                        // todo_stuff.think_mem_mgmt
+                        var properties: ArrayList(css_rules.font_face.FontFaceProperty) = .{};
+
+                        while (parser.next()) |result| {
+                            if (result.asValue()) |decl| {
+                                properties.append(
+                                    input.allocator(),
+                                    decl,
+                                ) catch bun.outOfMemory();
+                            }
+                        }
+
+                        this.rules.v.append(
+                            input.allocator(),
+                            .{
+                                .font_face = css_rules.font_face.FontFaceRule{
+                                    .properties = properties,
+                                    .loc = loc,
+                                },
+                            },
+                        ) catch bun.outOfMemory();
+                        return .{ .result = {} };
+                    },
+                    .font_palette_values => {
+                        const name = prelude.font_palette_values;
+                        const rule = switch (css_rules.font_palette_values.FontPaletteValuesRule.parse(name, input, loc)) {
+                            .err => |e| return .{ .err = e },
+                            .result => |v| v,
+                        };
+                        this.rules.v.append(
+                            input.allocator(),
+                            .{ .font_palette_values = rule },
+                        ) catch bun.outOfMemory();
+                        return .{ .result = {} };
+                    },
+                    .counter_style => {
+                        const name = prelude.counter_style;
+                        this.rules.v.append(
+                            input.allocator(),
+                            .{
+                                .counter_style = css_rules.counter_style.CounterStyleRule{
+                                    .name = name,
+                                    .declarations = switch (DeclarationBlock.parse(input, this.options)) {
+                                        .err => |e| return .{ .err = e },
+                                        .result => |v| v,
+                                    },
+                                    .loc = loc,
+                                },
+                            },
+                        ) catch bun.outOfMemory();
+                        return .{ .result = {} };
+                    },
+                    .media => {
+                        const query = prelude.media;
+                        const rules = switch (this.parseStyleBlock(input)) {
+                            .err => |e| return .{ .err = e },
+                            .result => |v| v,
+                        };
+                        this.rules.v.append(
+                            input.allocator(),
+                            .{
+                                .media = css_rules.media.MediaRule(T.CustomAtRuleParser.AtRule){
+                                    .query = query,
+                                    .rules = rules,
+                                    .loc = loc,
+                                },
+                            },
+                        ) catch bun.outOfMemory();
+                        return .{ .result = {} };
+                    },
+                    .supports => {
+                        const condition = prelude.supports;
+                        const rules = switch (this.parseStyleBlock(input)) {
+                            .err => |e| return .{ .err = e },
+                            .result => |v| v,
+                        };
+                        this.rules.v.append(input.allocator(), .{
+                            .supports = css_rules.supports.SupportsRule(T.CustomAtRuleParser.AtRule){
+                                .condition = condition,
+                                .rules = rules,
+                                .loc = loc,
+                            },
+                        }) catch bun.outOfMemory();
+                        return .{ .result = {} };
+                    },
+                    .container => {
+                        const rules = switch (this.parseStyleBlock(input)) {
+                            .err => |e| return .{ .err = e },
+                            .result => |v| v,
+                        };
+                        this.rules.v.append(
+                            input.allocator(),
+                            .{
+                                .container = css_rules.container.ContainerRule(T.CustomAtRuleParser.AtRule){
+                                    .name = prelude.container.name,
+                                    .condition = prelude.container.condition,
+                                    .rules = rules,
+                                    .loc = loc,
+                                },
+                            },
+                        ) catch bun.outOfMemory();
+                        return .{ .result = {} };
+                    },
+                    .scope => {
+                        const rules = switch (this.parseStyleBlock(input)) {
+                            .err => |e| return .{ .err = e },
+                            .result => |v| v,
+                        };
+                        this.rules.v.append(
+                            input.allocator(),
+                            .{
+                                .scope = css_rules.scope.ScopeRule(T.CustomAtRuleParser.AtRule){
+                                    .scope_start = prelude.scope.scope_start,
+                                    .scope_end = prelude.scope.scope_end,
+                                    .rules = rules,
+                                    .loc = loc,
+                                },
+                            },
+                        ) catch bun.outOfMemory();
+                        return .{ .result = {} };
+                    },
+                    .viewport => {
+                        this.rules.v.append(input.allocator(), .{
+                            .viewport = css_rules.viewport.ViewportRule{
+                                .vendor_prefix = prelude.viewport,
+                                .declarations = switch (DeclarationBlock.parse(input, this.options)) {
+                                    .err => |e| return .{ .err = e },
+                                    .result => |v| v,
+                                },
+                                .loc = loc,
+                            },
+                        }) catch bun.outOfMemory();
+                        return .{ .result = {} };
+                    },
+                    .keyframes => {
+                        var parser = css_rules.keyframes.KeyframesListParser{};
+                        var iter = RuleBodyParser(css_rules.keyframes.KeyframesListParser).new(input, &parser);
+                        // todo_stuff.think_mem_mgmt
+                        var keyframes = ArrayList(css_rules.keyframes.Keyframe){};
+
+                        while (iter.next()) |result| {
+                            if (result.asValue()) |keyframe| {
+                                keyframes.append(
+                                    input.allocator(),
+                                    keyframe,
+                                ) catch bun.outOfMemory();
+                            }
+                        }
+
+                        this.rules.v.append(input.allocator(), .{
+                            .keyframes = css_rules.keyframes.KeyframesRule{
+                                .name = prelude.keyframes.name,
+                                .keyframes = keyframes,
+                                .vendor_prefix = prelude.keyframes.prefix,
+                                .loc = loc,
+                            },
+                        }) catch bun.outOfMemory();
+                        return .{ .result = {} };
+                    },
+                    .page => {
+                        const selectors = prelude.page;
+                        const rule = switch (css_rules.page.PageRule.parse(selectors, input, loc, this.options)) {
+                            .err => |e| return .{ .err = e },
+                            .result => |v| v,
+                        };
+                        this.rules.v.append(
+                            input.allocator(),
+                            .{ .page = rule },
+                        ) catch bun.outOfMemory();
+                        return .{ .result = {} };
+                    },
+                    .moz_document => {
+                        const rules = switch (this.parseStyleBlock(input)) {
+                            .err => |e| return .{ .err = e },
+                            .result => |v| v,
+                        };
+                        this.rules.v.append(input.allocator(), .{
+                            .moz_document = css_rules.document.MozDocumentRule(T.CustomAtRuleParser.AtRule){
+                                .rules = rules,
+                                .loc = loc,
+                            },
+                        }) catch bun.outOfMemory();
+                        return .{ .result = {} };
+                    },
+                    .layer => {
+                        const name = if (prelude.layer.items.len == 0) null else if (prelude.layer.items.len == 1) names: {
+                            var out: LayerName = .{};
+                            std.mem.swap(LayerName, &out, &prelude.layer.items[0]);
+                            break :names out;
+                        } else return .{ .err = input.newError(.at_rule_body_invalid) };
+
+                        const rules = switch (this.parseStyleBlock(input)) {
+                            .err => |e| return .{ .err = e },
+                            .result => |v| v,
+                        };
+
+                        this.rules.v.append(input.allocator(), .{
+                            .layer_block = css_rules.layer.LayerBlockRule(T.CustomAtRuleParser.AtRule){ .name = name, .rules = rules, .loc = loc },
+                        }) catch bun.outOfMemory();
+                        return .{ .result = {} };
+                    },
+                    .property => {
+                        const name = prelude.property[0];
+                        this.rules.v.append(input.allocator(), .{
+                            .property = switch (css_rules.property.PropertyRule.parse(name, input, loc)) {
+                                .err => |e| return .{ .err = e },
+                                .result => |v| v,
+                            },
+                        }) catch bun.outOfMemory();
+                        return .{ .result = {} };
+                    },
+                    .import, .namespace, .custom_media, .charset => {
+                        // These rules don't have blocks
+                        return .{ .err = input.newUnexpectedTokenError(.open_curly) };
+                    },
+                    .starting_style => {
+                        const rules = switch (this.parseStyleBlock(input)) {
+                            .err => |e| return .{ .err = e },
+                            .result => |v| v,
+                        };
+                        this.rules.v.append(
+                            input.allocator(),
+                            .{
+                                .starting_style = css_rules.starting_style.StartingStyleRule(T.CustomAtRuleParser.AtRule){
+                                    .rules = rules,
+                                    .loc = loc,
+                                },
+                            },
+                        ) catch bun.outOfMemory();
+                        return .{ .result = {} };
+                    },
+                    .nest => {
+                        const selectors = prelude.nest;
+                        const result = switch (this.parseNested(input, true)) {
+                            .err => |e| return .{ .err = e },
+                            .result => |v| v,
+                        };
+                        const declarations = result[0];
+                        const rules = result[1];
+                        this.rules.v.append(
+                            input.allocator(),
+                            .{
+                                .nesting = css_rules.nesting.NestingRule(T.CustomAtRuleParser.AtRule){
+                                    .style = css_rules.style.StyleRule(T.CustomAtRuleParser.AtRule){
+                                        .selectors = selectors,
+                                        .declarations = declarations,
+                                        .vendor_prefix = VendorPrefix.empty(),
+                                        .rules = rules,
+                                        .loc = loc,
+                                    },
+                                    .loc = loc,
+                                },
+                            },
+                        ) catch bun.outOfMemory();
+                        return .{ .result = {} };
+                    },
+                    .font_feature_values => bun.unreachablePanic("", .{}),
+                    .unknown => {
+                        this.rules.v.append(
+                            input.allocator(),
+                            .{
+                                .unknown = css_rules.unknown.UnknownAtRule{
+                                    .name = prelude.unknown.name,
+                                    .prelude = prelude.unknown.tokens,
+                                    .block = switch (TokenListFns.parse(input, this.options, 0)) {
+                                        .err => |e| return .{ .err = e },
+                                        .result => |v| v,
+                                    },
+                                    .loc = loc,
+                                },
+                            },
+                        ) catch bun.outOfMemory();
+                        return .{ .result = {} };
+                    },
+                    .custom => {
+                        this.rules.v.append(
+                            input.allocator(),
+                            .{
+                                .custom = switch (parse_custom_at_rule_body(T, prelude.custom, input, start, this.options, this.at_rule_parser, this.is_in_style_rule)) {
+                                    .err => |e| return .{ .err = e },
+                                    .result => |v| v,
+                                },
+                            },
+                        ) catch bun.outOfMemory();
+                        return .{ .result = {} };
+                    },
+                }
+            }
+
+            pub fn ruleWithoutBlock(this: *This, prelude: AtRuleParser.Prelude, start: *const ParserState) Maybe(AtRuleParser.AtRule, void) {
+                const loc = this.getLoc(start);
+                switch (prelude) {
+                    .layer => {
+                        if (this.is_in_style_rule or prelude.layer.items.len == 0) {
+                            return .{ .err = {} };
+                        }
+
+                        this.rules.v.append(
+                            this.allocator,
+                            .{
+                                .layer_statement = css_rules.layer.LayerStatementRule{
+                                    .names = prelude.layer,
+                                    .loc = loc,
+                                },
+                            },
+                        ) catch bun.outOfMemory();
+                        return .{ .result = {} };
+                    },
+                    .unknown => {
+                        this.rules.v.append(
+                            this.allocator,
+                            .{
+                                .unknown = css_rules.unknown.UnknownAtRule{
+                                    .name = prelude.unknown.name,
+                                    .prelude = prelude.unknown.tokens,
+                                    .block = null,
+                                    .loc = loc,
+                                },
+                            },
+                        ) catch bun.outOfMemory();
+                        return .{ .result = {} };
+                    },
+                    .custom => {
+                        this.rules.v.append(this.allocator, switch (parse_custom_at_rule_without_block(
+                            T,
+                            prelude.custom,
+                            start,
+                            this.options,
+                            this.at_rule_parser,
+                            this.is_in_style_rule,
+                        )) {
+                            .err => |e| return .{ .err = e },
+                            .result => |v| v,
+                        }) catch bun.outOfMemory();
+                        return .{ .result = {} };
+                    },
+                    else => return .{ .err = {} },
+                }
+            }
+        };
+
+        pub const QualifiedRuleParser = struct {
+            pub const Prelude = selector.parser.SelectorList;
+            pub const QualifiedRule = void;
+
+            pub fn parsePrelude(this: *This, input: *Parser) Result(Prelude) {
+                var selector_parser = selector.parser.SelectorParser{
+                    .is_nesting_allowed = true,
+                    .options = this.options,
+                    .allocator = input.allocator(),
+                };
+
+                if (this.is_in_style_rule) {
+                    return selector.parser.SelectorList.parseRelative(&selector_parser, input, .discard_list, .implicit);
+                } else {
+                    return selector.parser.SelectorList.parse(&selector_parser, input, .discard_list, .none);
+                }
+            }
+
+            pub fn parseBlock(this: *This, selectors: Prelude, start: *const ParserState, input: *Parser) Result(QualifiedRule) {
+                const loc = this.getLoc(start);
+                const result = switch (this.parseNested(input, true)) {
+                    .err => |e| return .{ .err = e },
+                    .result => |v| v,
+                };
+                const declarations = result[0];
+                const rules = result[1];
+
+                this.rules.v.append(this.allocator, .{
+                    .style = StyleRule(AtRuleT){
+                        .selectors = selectors,
+                        .vendor_prefix = VendorPrefix{},
+                        .declarations = declarations,
+                        .rules = rules,
+                        .loc = loc,
+                    },
+                }) catch bun.outOfMemory();
+
+                return Result(QualifiedRule).success;
+            }
+        };
+
+        pub const RuleBodyItemParser = struct {
+            pub fn parseQualified(this: *This) bool {
+                _ = this; // autofix
+                return true;
+            }
+
+            pub fn parseDeclarations(this: *This) bool {
+                return this.allow_declarations;
+            }
+        };
+
+        pub const DeclarationParser = struct {
+            pub const Declaration = void;
+
+            pub fn parseValue(this: *This, name: []const u8, input: *Parser) Result(Declaration) {
+                return css_decls.parse_declaration(
+                    name,
+                    input,
+                    &this.declarations,
+                    &this.important_declarations,
+                    this.options,
+                );
+            }
+        };
+
+        pub fn parseNested(this: *This, input: *Parser, is_style_rule: bool) Result(struct { DeclarationBlock, CssRuleList(T.CustomAtRuleParser.AtRule) }) {
+            // TODO: think about memory management in error cases
+            var rules = CssRuleList(T.CustomAtRuleParser.AtRule){};
+            var nested_parser = This{
+                .allocator = input.allocator(),
+                .options = this.options,
+                .at_rule_parser = this.at_rule_parser,
+                .declarations = DeclarationList{},
+                .important_declarations = DeclarationList{},
+                .rules = &rules,
+                .is_in_style_rule = this.is_in_style_rule or is_style_rule,
+                .allow_declarations = this.allow_declarations or this.is_in_style_rule or is_style_rule,
+            };
+
+            const parse_declarations = This.RuleBodyItemParser.parseDeclarations(&nested_parser);
+            // TODO: think about memory management
+            var errors = ArrayList(ParseError(ParserError)){};
+            var iter = RuleBodyParser(This).new(input, &nested_parser);
+
+            while (iter.next()) |result| {
+                if (result.asErr()) |e| {
+                    if (parse_declarations) {
+                        iter.parser.declarations.clearRetainingCapacity();
+                        iter.parser.important_declarations.clearRetainingCapacity();
+                        errors.append(
+                            this.allocator,
+                            e,
+                        ) catch bun.outOfMemory();
+                    } else {
+                        if (iter.parser.options.error_recovery) {
+                            iter.parser.options.warn(e);
+                            continue;
+                        }
+                        return .{ .err = e };
+                    }
+                }
+            }
+
+            if (parse_declarations) {
+                if (errors.items.len > 0) {
+                    if (this.options.error_recovery) {
+                        for (errors.items) |e| {
+                            this.options.warn(e);
+                        }
+                    } else {
+                        return .{ .err = errors.orderedRemove(0) };
+                    }
+                }
+            }
+
+            return .{
+                .result = .{
+                    DeclarationBlock{
+                        .declarations = nested_parser.declarations,
+                        .important_declarations = nested_parser.important_declarations,
+                    },
+                    rules,
+                },
+            };
+        }
+
+        pub fn parseStyleBlock(this: *This, input: *Parser) Result(CssRuleList(T.CustomAtRuleParser.AtRule)) {
+            const srcloc = input.currentSourceLocation();
+            const loc = Location{
+                .source_index = this.options.source_index,
+                .line = srcloc.line,
+                .column = srcloc.column,
+            };
+
+            // Declarations can be immediately within @media and @supports blocks that are nested within a parent style rule.
+            // These act the same way as if they were nested within a `& { ... }` block.
+            const declarations, var rules = switch (this.parseNested(input, false)) {
+                .err => |e| return .{ .err = e },
+                .result => |v| v,
+            };
+
+            if (declarations.len() > 0) {
+                rules.v.insert(
+                    input.allocator(),
+                    0,
+                    .{
+                        .style = StyleRule(T.CustomAtRuleParser.AtRule){
+                            .selectors = selector.parser.SelectorList.fromSelector(
+                                input.allocator(),
+                                selector.parser.Selector.fromComponent(input.allocator(), .nesting),
+                            ),
+                            .declarations = declarations,
+                            .vendor_prefix = VendorPrefix.empty(),
+                            .rules = .{},
+                            .loc = loc,
+                        },
+                    },
+                ) catch unreachable;
+            }
+
+            return .{ .result = rules };
+        }
+    };
+}
+
+pub fn StyleSheetParser(comptime P: type) type {
+    ValidAtRuleParser(P);
+    ValidQualifiedRuleParser(P);
+
+    if (P.QualifiedRuleParser.QualifiedRule != P.AtRuleParser.AtRule) {
+        @compileError("StyleSheetParser: P.QualifiedRuleParser.QualifiedRule != P.AtRuleParser.AtRule");
+    }
+
+    const Item = P.AtRuleParser.AtRule;
+
+    return struct {
+        input: *Parser,
+        parser: *P,
+        any_rule_so_far: bool = false,
+
+        pub fn new(input: *Parser, parser: *P) @This() {
+            return .{
+                .input = input,
+                .parser = parser,
+            };
+        }
+
+        pub fn next(this: *@This(), allocator: Allocator) ?(Result(Item)) {
+            while (true) {
+                this.input.@"skip cdc and cdo"();
+
+                const start = this.input.state();
+                const at_keyword: ?[]const u8 = switch (this.input.nextByte() orelse return null) {
+                    '@' => brk: {
+                        const at_keyword: *Token = switch (this.input.nextIncludingWhitespaceAndComments()) {
+                            .result => |vv| vv,
+                            .err => {
+                                this.input.reset(&start);
+                                break :brk null;
+                            },
+                        };
+
+                        if (at_keyword.* == .at_keyword) break :brk at_keyword.at_keyword;
+                        this.input.reset(&start);
+                        break :brk null;
+                    },
+                    else => null,
+                };
+
+                if (at_keyword) |name| {
+                    const first_stylesheet_rule = !this.any_rule_so_far;
+                    this.any_rule_so_far = true;
+
+                    if (first_stylesheet_rule and bun.strings.eqlCaseInsensitiveASCII(name, "charset", true)) {
+                        const delimiters = Delimiters{
+                            .semicolon = true,
+                            .close_curly_bracket = true,
+                        };
+                        _ = this.input.parseUntilAfter(delimiters, void, {}, voidWrap(void, Parser.parseEmpty));
+                    } else {
+                        return parse_at_rule(allocator, &start, name, this.input, P, this.parser);
+                    }
+                } else {
+                    this.any_rule_so_far = true;
+                    const result = parse_qualified_rule(&start, this.input, P, this.parser, Delimiters{ .curly_bracket = true });
+                    return result;
+                }
+            }
+        }
+    };
+}
+
+/// A result returned from `to_css`, including the serialized CSS
+/// and other metadata depending on the input options.
+pub const ToCssResult = struct {
+    /// Serialized CSS code.
+    code: []const u8,
+    /// A map of CSS module exports, if the `css_modules` option was
+    /// enabled during parsing.
+    exports: ?CssModuleExports,
+    /// A map of CSS module references, if the `css_modules` config
+    /// had `dashed_idents` enabled.
+    references: ?CssModuleReferences,
+    /// A list of dependencies (e.g. `@import` or `url()`) found in
+    /// the style sheet, if the `analyze_dependencies` option is enabled.
+    dependencies: ?ArrayList(Dependency),
+};
+
+pub const ToCssResultInternal = struct {
+    /// A map of CSS module exports, if the `css_modules` option was
+    /// enabled during parsing.
+    exports: ?CssModuleExports,
+    /// A map of CSS module references, if the `css_modules` config
+    /// had `dashed_idents` enabled.
+    references: ?CssModuleReferences,
+    /// A list of dependencies (e.g. `@import` or `url()`) found in
+    /// the style sheet, if the `analyze_dependencies` option is enabled.
+    dependencies: ?ArrayList(Dependency),
+};
+
+pub const MinifyOptions = struct {
+    /// Targets to compile the CSS for.
+    targets: targets.Targets,
+    /// A list of known unused symbols, including CSS class names,
+    /// ids, and `@keyframe` names. The declarations of these will be removed.
+    unused_symbols: std.StringArrayHashMapUnmanaged(void),
+
+    pub fn default() MinifyOptions {
+        return MinifyOptions{
+            .targets = .{},
+            .unused_symbols = .{},
+        };
+    }
+};
+
+pub const BundlerStyleSheet = StyleSheet(BundlerAtRule);
+pub const BundlerCssRuleList = CssRuleList(BundlerAtRule);
+pub const BundlerCssRule = CssRule(BundlerAtRule);
+pub const BundlerLayerBlockRule = css_rules.layer.LayerBlockRule(BundlerAtRule);
+pub const BundlerTailwindState = struct {
+    source: []const u8,
+    index: bun.bundle_v2.Index,
+    output_from_tailwind: ?[]const u8 = null,
+};
+
+pub fn StyleSheet(comptime AtRule: type) type {
+    return struct {
+        /// A list of top-level rules within the style sheet.
+        rules: CssRuleList(AtRule),
+        sources: ArrayList([]const u8),
+        source_map_urls: ArrayList(?[]const u8),
+        license_comments: ArrayList([]const u8),
+        options: ParserOptions,
+        tailwind: if (AtRule == BundlerAtRule) ?*BundlerTailwindState else u0 = if (AtRule == BundlerAtRule) null else 0,
+
+        const This = @This();
+
+        pub fn empty(allocator: Allocator) This {
+            return This{
+                .rules = .{},
+                .sources = .{},
+                .source_map_urls = .{},
+                .license_comments = .{},
+                .options = ParserOptions.default(allocator, null),
+            };
+        }
+
+        /// Minify and transform the style sheet for the provided browser targets.
+        pub fn minify(this: *@This(), allocator: Allocator, options: MinifyOptions) Maybe(void, Err(MinifyErrorKind)) {
+            const ctx = PropertyHandlerContext.new(allocator, options.targets, &options.unused_symbols);
+            var handler = declaration.DeclarationHandler.default();
+            var important_handler = declaration.DeclarationHandler.default();
+
+            // @custom-media rules may be defined after they are referenced, but may only be defined at the top level
+            // of a stylesheet. Do a pre-scan here and create a lookup table by name.
+            var custom_media: ?std.StringArrayHashMapUnmanaged(css_rules.custom_media.CustomMediaRule) = if (this.options.flags.contains(ParserFlags{ .custom_media = true }) and options.targets.shouldCompileSame(.custom_media_queries)) brk: {
+                var custom_media = std.StringArrayHashMapUnmanaged(css_rules.custom_media.CustomMediaRule){};
+
+                for (this.rules.v.items) |*rule| {
+                    if (rule.* == .custom_media) {
+                        custom_media.put(allocator, rule.custom_media.name.v, rule.custom_media.deepClone(allocator)) catch bun.outOfMemory();
+                    }
+                }
+
+                break :brk custom_media;
+            } else null;
+            defer if (custom_media) |*media| media.deinit(allocator);
+
+            var minify_ctx = MinifyContext{
+                .allocator = allocator,
+                .targets = &options.targets,
+                .handler = &handler,
+                .important_handler = &important_handler,
+                .handler_context = ctx,
+                .unused_symbols = &options.unused_symbols,
+                .custom_media = custom_media,
+                .css_modules = this.options.css_modules != null,
+            };
+
+            this.rules.minify(&minify_ctx, false) catch {
+                @panic("TODO: Handle");
+            };
+
+            return .{ .result = {} };
+        }
+
+        pub fn toCssWithWriter(this: *const @This(), allocator: Allocator, writer: anytype, options: css_printer.PrinterOptions, import_records: ?*const bun.BabyList(ImportRecord)) PrintErr!ToCssResultInternal {
+            const W = @TypeOf(writer);
+            const project_root = options.project_root;
+            var printer = Printer(@TypeOf(writer)).new(allocator, std.ArrayList(u8).init(allocator), writer, options, import_records);
+
+            // #[cfg(feature = "sourcemap")]
+            // {
+            //   printer.sources = Some(&self.sources);
+            // }
+
+            // #[cfg(feature = "sourcemap")]
+            // if printer.source_map.is_some() {
+            //   printer.source_maps = self.sources.iter().enumerate().map(|(i, _)| self.source_map(i)).collect();
+            // }
+
+            for (this.license_comments.items) |comment| {
+                try printer.writeStr("/*");
+                try printer.writeComment(comment);
+                try printer.writeStr("*/");
+                try printer.newline();
+            }
+
+            if (this.options.css_modules) |*config| {
+                var references = CssModuleReferences{};
+                printer.css_module = CssModule.new(allocator, config, &this.sources, project_root, &references);
+
+                try this.rules.toCss(W, &printer);
+                try printer.newline();
+
+                return ToCssResultInternal{
+                    .dependencies = printer.dependencies,
+                    .exports = exports: {
+                        const val = printer.css_module.?.exports_by_source_index.items[0];
+                        printer.css_module.?.exports_by_source_index.items[0] = .{};
+                        break :exports val;
+                    },
+                    // .code = dest.items,
+                    .references = references,
+                };
+            } else {
+                try this.rules.toCss(W, &printer);
+                try printer.newline();
+                return ToCssResultInternal{
+                    .dependencies = printer.dependencies,
+                    // .code = dest.items,
+                    .exports = null,
+                    .references = null,
+                };
+            }
+        }
+
+        pub fn toCss(this: *const @This(), allocator: Allocator, options: css_printer.PrinterOptions, import_records: ?*const bun.BabyList(ImportRecord)) PrintErr!ToCssResult {
+            // TODO: this is not necessary
+            // Make sure we always have capacity > 0: https://github.com/napi-rs/napi-rs/issues/1124.
+            var dest = ArrayList(u8).initCapacity(allocator, 1) catch unreachable;
+            const writer = dest.writer(allocator);
+            const result = try toCssWithWriter(this, allocator, writer, options, import_records);
+            return ToCssResult{
+                .code = dest.items,
+                .dependencies = result.dependencies,
+                .exports = result.exports,
+                .references = result.references,
+            };
+        }
+
+        pub fn parse(allocator: Allocator, code: []const u8, options: ParserOptions, import_records: ?*bun.BabyList(ImportRecord)) Maybe(This, Err(ParserError)) {
+            var default_at_rule_parser = DefaultAtRuleParser{};
+            return parseWith(allocator, code, options, DefaultAtRuleParser, &default_at_rule_parser, import_records);
+        }
+
+        pub fn parseBundler(allocator: Allocator, code: []const u8, options: ParserOptions, import_records: *bun.BabyList(ImportRecord)) Maybe(This, Err(ParserError)) {
+            var at_rule_parser = BundlerAtRuleParser{
+                .import_records = import_records,
+                .allocator = allocator,
+                .options = &options,
+            };
+            return parseWith(allocator, code, options, BundlerAtRuleParser, &at_rule_parser, import_records);
+        }
+
+        /// Parse a style sheet from a string.
+        pub fn parseWith(
+            allocator: Allocator,
+            code: []const u8,
+            options: ParserOptions,
+            comptime P: type,
+            at_rule_parser: *P,
+            import_records: ?*bun.BabyList(ImportRecord),
+        ) Maybe(This, Err(ParserError)) {
+            var input = ParserInput.new(allocator, code);
+            var parser = Parser.new(&input, import_records);
+
+            var license_comments = ArrayList([]const u8){};
+            var state = parser.state();
+            while (switch (parser.nextIncludingWhitespaceAndComments()) {
+                .result => |v| v,
+                .err => null,
+            }) |token| {
+                switch (token.*) {
+                    .whitespace => {},
+                    .comment => |comment| {
+                        if (bun.strings.startsWithChar(comment, '!')) {
+                            license_comments.append(allocator, comment) catch bun.outOfMemory();
+                        }
+                    },
+                    else => break,
+                }
+                state = parser.state();
+            }
+            parser.reset(&state);
+
+            var rules = CssRuleList(AtRule){};
+            var rule_parser = TopLevelRuleParser(P).new(allocator, &options, at_rule_parser, &rules);
+            var rule_list_parser = StyleSheetParser(TopLevelRuleParser(P)).new(&parser, &rule_parser);
+
+            while (rule_list_parser.next(allocator)) |result| {
+                if (result.asErr()) |e| {
+                    const result_options = rule_list_parser.parser.options;
+                    if (result_options.error_recovery) {
+                        // todo_stuff.warn
+                        continue;
+                    }
+
+                    return .{ .err = Err(ParserError).fromParseError(e, options.filename) };
+                }
+            }
+
+            var sources = ArrayList([]const u8){};
+            sources.append(allocator, options.filename) catch bun.outOfMemory();
+            var source_map_urls = ArrayList(?[]const u8){};
+            source_map_urls.append(allocator, parser.currentSourceMapUrl()) catch bun.outOfMemory();
+
+            return .{
+                .result = This{
+                    .rules = rules,
+                    .sources = sources,
+                    .source_map_urls = source_map_urls,
+                    .license_comments = license_comments,
+                    .options = options,
+                },
+            };
+        }
+
+        pub fn containsTailwindDirectives(this: *const @This()) bool {
+            if (comptime AtRule != BundlerAtRule) @compileError("Expected BundlerAtRule for this function.");
+            var found_import: bool = false;
+            for (this.rules.v.items) |*rule| {
+                switch (rule.*) {
+                    .custom => {
+                        return true;
+                    },
+                    // .charset => {},
+                    // TODO: layer
+                    .layer_block => {},
+                    .import => {
+                        found_import = true;
+                    },
+                    else => {
+                        return false;
+                    },
+                }
+            }
+            return false;
+        }
+
+        pub fn newFromTailwindImports(
+            allocator: Allocator,
+            options: ParserOptions,
+            imports_from_tailwind: CssRuleList(AtRule),
+        ) @This() {
+            _ = allocator; // autofix
+            if (comptime AtRule != BundlerAtRule) @compileError("Expected BundlerAtRule for this function.");
+
+            const stylesheet = This{
+                .rules = imports_from_tailwind,
+                .sources = .{},
+                .source_map_urls = .{},
+                .license_comments = .{},
+                .options = options,
+            };
+
+            return stylesheet;
+        }
+
+        /// *NOTE*: Used for Tailwind stylesheets only
+        ///
+        /// This plucks out the import rules from the Tailwind stylesheet into a separate rule list,
+        /// replacing them with `.ignored` rules.
+        ///
+        /// We do this because Tailwind's compiler pipeline does not bundle imports, so we handle that
+        /// ourselves in the bundler.
+        pub fn pluckImports(this: *const @This(), allocator: Allocator, out: *CssRuleList(AtRule), new_import_records: *bun.BabyList(ImportRecord)) void {
+            if (comptime AtRule != BundlerAtRule) @compileError("Expected BundlerAtRule for this function.");
+            const State = enum { count, exec };
+
+            const STATES = comptime [_]State{ .count, .exec };
+
+            var count: u32 = 0;
+            inline for (STATES[0..]) |state| {
+                if (comptime state == .exec) {
+                    out.v.ensureUnusedCapacity(allocator, count) catch bun.outOfMemory();
+                }
+                var saw_imports = false;
+                for (this.rules.v.items) |*rule| {
+                    switch (rule.*) {
+                        // TODO: layer, might have imports
+                        .layer_block => {},
+                        .import => {
+                            if (!saw_imports) saw_imports = true;
+                            switch (state) {
+                                .count => count += 1,
+                                .exec => {
+                                    const import_rule = &rule.import;
+                                    out.v.appendAssumeCapacity(rule.*);
+                                    const import_record_idx = new_import_records.len;
+                                    import_rule.import_record_idx = import_record_idx;
+                                    new_import_records.push(allocator, ImportRecord{
+                                        .path = bun.fs.Path.init(import_rule.url),
+                                        .kind = if (import_rule.supports != null) .at_conditional else .at,
+                                        .range = bun.logger.Range.None,
+                                    }) catch bun.outOfMemory();
+                                    rule.* = .ignored;
+                                },
+                            }
+                        },
+                        .unknown => {
+                            if (bun.strings.eqlComptime(rule.unknown.name, "tailwind")) {
+                                continue;
+                            }
+                        },
+                        else => {},
+                    }
+                    if (saw_imports) break;
+                }
+            }
+        }
+    };
+}
+
+pub const StyleAttribute = struct {
+    declarations: DeclarationBlock,
+    sources: ArrayList([]const u8),
+
+    pub fn parse(allocator: Allocator, code: []const u8, options: ParserOptions, import_records: *bun.BabyList(ImportRecord)) Maybe(StyleAttribute, Err(ParserError)) {
+        var input = ParserInput.new(allocator, code);
+        var parser = Parser.new(&input, import_records);
+        const sources = sources: {
+            var s = ArrayList([]const u8).initCapacity(allocator, 1) catch bun.outOfMemory();
+            s.appendAssumeCapacity(options.filename);
+            break :sources s;
+        };
+        return .{ .result = StyleAttribute{
+            .declarations = switch (DeclarationBlock.parse(&parser, &options)) {
+                .result => |v| v,
+                .err => |e| return .{ .err = Err(ParserError).fromParseError(e, "") },
+            },
+            .sources = sources,
+        } };
+    }
+
+    pub fn toCss(this: *const StyleAttribute, allocator: Allocator, options: PrinterOptions, import_records: *bun.BabyList(ImportRecord)) PrintErr!ToCssResult {
+        // #[cfg(feature = "sourcemap")]
+        // assert!(
+        //   options.source_map.is_none(),
+        //   "Source maps are not supported for style attributes"
+        // );
+
+        var dest = ArrayList(u8){};
+        const writer = dest.writer(allocator);
+        var printer = Printer(@TypeOf(writer)).new(allocator, std.ArrayList(u8).init(allocator), writer, options, import_records);
+        printer.sources = &this.sources;
+
+        try this.declarations.toCss(@TypeOf(writer), &printer);
+
+        return ToCssResult{
+            .dependencies = printer.dependencies,
+            .code = dest.items,
+            .exports = null,
+            .references = null,
+        };
+    }
+
+    pub fn minify(this: *@This(), allocator: Allocator, options: MinifyOptions) void {
+        _ = allocator; // autofix
+        _ = this; // autofix
+        _ = options; // autofix
+        // TODO: IMPLEMENT THIS!
+    }
+};
+
+pub fn ValidDeclarationParser(comptime P: type) void {
+    // The finished representation of a declaration.
+    _ = P.DeclarationParser.Declaration;
+
+    // Parse the value of a declaration with the given `name`.
+    //
+    // Return the finished representation for the declaration
+    // as returned by `DeclarationListParser::next`,
+    // or `Err(())` to ignore the entire declaration as invalid.
+    //
+    // Declaration name matching should be case-insensitive in the ASCII range.
+    // This can be done with `std::ascii::Ascii::eq_ignore_ascii_case`,
+    // or with the `match_ignore_ascii_case!` macro.
+    //
+    // The given `input` is a "delimited" parser
+    // that ends wherever the declaration value should end.
+    // (In declaration lists, before the next semicolon or end of the current block.)
+    //
+    // If `!important` can be used in a given context,
+    // `input.try_parse(parse_important).is_ok()` should be used at the end
+    // of the implementation of this method and the result should be part of the return value.
+    //
+    // fn parseValue(this: *T, name: []const u8, input: *Parser) Error!T.DeclarationParser.Declaration
+    _ = P.DeclarationParser.parseValue;
+}
+
+/// Also checks that P is:
+/// - ValidDeclarationParser(P)
+/// - ValidQualifiedRuleParser(P)
+/// - ValidAtRuleParser(P)
+pub fn ValidRuleBodyItemParser(comptime P: type) void {
+    ValidDeclarationParser(P);
+    ValidQualifiedRuleParser(P);
+    ValidAtRuleParser(P);
+
+    // Whether we should attempt to parse declarations. If you know you won't, returning false
+    // here is slightly faster.
+    _ = P.RuleBodyItemParser.parseDeclarations;
+
+    // Whether we should attempt to parse qualified rules. If you know you won't, returning false
+    // would be slightly faster.
+    _ = P.RuleBodyItemParser.parseQualified;
+
+    // We should have:
+    // P.DeclarationParser.Declaration == P.QualifiedRuleParser.QualifiedRule == P.AtRuleParser.AtRule
+    if (P.DeclarationParser.Declaration != P.QualifiedRuleParser.QualifiedRule or
+        P.DeclarationParser.Declaration != P.AtRuleParser.AtRule)
+    {
+        @compileError("ValidRuleBodyItemParser: P.DeclarationParser.Declaration != P.QualifiedRuleParser.QualifiedRule or\n  P.DeclarationParser.Declaration != P.AtRuleParser.AtRule");
+    }
+}
+
+pub fn RuleBodyParser(comptime P: type) type {
+    ValidRuleBodyItemParser(P);
+    // Same as P.AtRuleParser.AtRule and P.DeclarationParser.Declaration
+    const I = P.QualifiedRuleParser.QualifiedRule;
+
+    return struct {
+        input: *Parser,
+        parser: *P,
+
+        const This = @This();
+
+        pub fn new(input: *Parser, parser: *P) This {
+            return .{
+                .input = input,
+                .parser = parser,
+            };
+        }
+
+        /// TODO: result is actually:
+        ///     type Item = Result<I, (ParseError<'i, E>, &'i str)>;
+        ///
+        /// but nowhere in the source do i actually see it using the string part of the tuple
+        pub fn next(this: *This) ?(Result(I)) {
+            while (true) {
+                this.input.skipWhitespace();
+                const start = this.input.state();
+
+                const tok: *Token = switch (this.input.nextIncludingWhitespaceAndComments()) {
+                    .err => |_| return null,
+                    .result => |vvv| vvv,
+                };
+
+                switch (tok.*) {
+                    .close_curly, .whitespace, .semicolon, .comment => continue,
+                    .at_keyword => {
+                        const name = tok.at_keyword;
+                        return parse_at_rule(
+                            this.input.allocator(),
+                            &start,
+                            name,
+                            this.input,
+                            P,
+                            this.parser,
+                        );
+                    },
+                    .ident => {
+                        if (P.RuleBodyItemParser.parseDeclarations(this.parser)) {
+                            const name = tok.ident;
+                            const parse_qualified = P.RuleBodyItemParser.parseQualified(this.parser);
+                            const result: Result(I) = result: {
+                                const error_behavior: ParseUntilErrorBehavior = if (parse_qualified) .stop else .consume;
+                                const Closure = struct {
+                                    parser: *P,
+                                    name: []const u8,
+                                    pub fn parsefn(self: *@This(), input: *Parser) Result(I) {
+                                        if (input.expectColon().asErr()) |e| return .{ .err = e };
+                                        return P.DeclarationParser.parseValue(self.parser, self.name, input);
+                                    }
+                                };
+                                var closure = Closure{
+                                    .parser = this.parser,
+                                    .name = name,
+                                };
+                                break :result parse_until_after(this.input, Delimiters{ .semicolon = true }, error_behavior, I, &closure, Closure.parsefn);
+                            };
+                            if (result.isErr() and parse_qualified) {
+                                this.input.reset(&start);
+                                if (parse_qualified_rule(
+                                    &start,
+                                    this.input,
+                                    P,
+                                    this.parser,
+                                    Delimiters{ .semicolon = true, .curly_bracket = true },
+                                ).asValue()) |qual| {
+                                    return .{ .result = qual };
+                                }
+                            }
+
+                            return result;
+                        }
+                    },
+                    else => {},
+                }
+
+                const result: Result(I) = if (P.RuleBodyItemParser.parseQualified(this.parser)) result: {
+                    this.input.reset(&start);
+                    const delimiters = if (P.RuleBodyItemParser.parseDeclarations(this.parser)) Delimiters{
+                        .semicolon = true,
+                        .curly_bracket = true,
+                    } else Delimiters{ .curly_bracket = true };
+                    break :result parse_qualified_rule(&start, this.input, P, this.parser, delimiters);
+                } else result: {
+                    const token = tok.*;
+
+                    const Closure = struct { token: Token, start: ParserState };
+                    break :result this.input.parseUntilAfter(Delimiters{ .semicolon = true }, I, &Closure{ .token = token, .start = start }, struct {
+                        pub fn parseFn(closure: *const Closure, i: *Parser) Result(I) {
+                            _ = i; // autofix
+                            return .{ .err = closure.start.sourceLocation().newUnexpectedTokenError(closure.token) };
+                        }
+                    }.parseFn);
+                };
+
+                return result;
+            }
+        }
+    };
+}
+
+pub const ParserOptions = struct {
+    /// Filename to use in error messages.
+    filename: []const u8,
+    /// Whether the enable [CSS modules](https://github.com/css-modules/css-modules).
+    css_modules: ?css_modules.Config,
+    /// The source index to assign to all parsed rules. Impacts the source map when
+    /// the style sheet is serialized.
+    source_index: u32,
+    /// Whether to ignore invalid rules and declarations rather than erroring.
+    error_recovery: bool,
+    /// A list that will be appended to when a warning occurs.
+    logger: ?*Log = null,
+    /// Feature flags to enable.
+    flags: ParserFlags,
+    allocator: Allocator,
+
+    pub fn warn(this: *const ParserOptions, warning: ParseError(ParserError)) void {
+        if (this.logger) |lg| {
+            lg.addWarningFmtLineCol(
+                this.filename,
+                warning.location.line,
+                warning.location.column,
+                this.allocator,
+                "{}",
+                .{warning.kind},
+            ) catch unreachable;
+        }
+    }
+
+    pub fn default(allocator: std.mem.Allocator, log: ?*Log) ParserOptions {
+        return ParserOptions{
+            .filename = "",
+            .css_modules = null,
+            .source_index = 0,
+            .error_recovery = false,
+            .logger = log,
+            .flags = ParserFlags{},
+            .allocator = allocator,
+        };
+    }
+};
+
+/// Parser feature flags to enable.
+pub const ParserFlags = packed struct(u8) {
+    /// Whether the enable the [CSS nesting](https://www.w3.org/TR/css-nesting-1/) draft syntax.
+    nesting: bool = false,
+    /// Whether to enable the [custom media](https://drafts.csswg.org/mediaqueries-5/#custom-mq) draft syntax.
+    custom_media: bool = false,
+    /// Whether to enable the non-standard >>> and /deep/ selector combinators used by Vue and Angular.
+    deep_selector_combinator: bool = false,
+    __unused: u5 = 0,
+
+    pub usingnamespace Bitflags(@This());
+};
+
+const ParseUntilErrorBehavior = enum {
+    consume,
+    stop,
+};
+
+// const ImportRecordHandler = union(enum) {
+//     list: *bun.BabyList(ImportRecord),
+//     // dummy: u32,
+
+//     pub fn add(this: *ImportRecordHandler, allocator: Allocator, record: ImportRecord) u32 {
+//         return switch (this.*) {
+//             .list => |list| {
+//                 const len = list.len;
+//                 list.push(allocator, record) catch bun.outOfMemory();
+//                 return len;
+//             },
+//             // .dummy => |*d| {
+//             //     const val = d.*;
+//             //     d.* += 1;
+//             //     return val;
+//             // },
+//         };
+//     }
+// };
+
+pub const Parser = struct {
+    input: *ParserInput,
+    at_start_of: ?BlockType = null,
+    stop_before: Delimiters = Delimiters.NONE,
+    import_records: ?*bun.BabyList(ImportRecord),
+
+    // TODO: dedupe import records??
+    pub fn addImportRecordForUrl(this: *Parser, url: []const u8, start_position: usize) Result(u32) {
+        if (this.import_records) |import_records| {
+            const idx = import_records.len;
+            import_records.push(this.allocator(), ImportRecord{
+                .path = bun.fs.Path.init(url),
+                .kind = .url,
+                .range = bun.logger.Range{
+                    .loc = bun.logger.Loc{ .start = @intCast(start_position) },
+                    .len = @intCast(url.len), // TODO: technically this is not correct because the url could be escaped
+                },
+            }) catch bun.outOfMemory();
+            return .{ .result = idx };
+        } else {
+            return .{ .err = this.newBasicUnexpectedTokenError(.{ .unquoted_url = url }) };
+        }
+    }
+
+    pub inline fn allocator(self: *Parser) Allocator {
+        return self.input.tokenizer.allocator;
+    }
+
+    /// Create a new Parser
+    ///
+    /// Pass in `import_records` to track imports (`@import` rules, `url()` tokens). If this
+    /// is `null`, calling `Parser.addImportRecordForUrl` will error.
+    pub fn new(input: *ParserInput, import_records: ?*bun.BabyList(ImportRecord)) Parser {
+        return Parser{
+            .input = input,
+            .import_records = import_records,
+        };
+    }
+
+    pub fn newCustomError(this: *const Parser, err: ParserError) ParseError(ParserError) {
+        return this.currentSourceLocation().newCustomError(err);
+    }
+
+    pub fn newBasicError(this: *const Parser, kind: BasicParseErrorKind) BasicParseError {
+        return BasicParseError{
+            .kind = kind,
+            .location = this.currentSourceLocation(),
+        };
+    }
+
+    pub fn newError(this: *const Parser, kind: BasicParseErrorKind) ParseError(ParserError) {
+        return .{
+            .kind = .{ .basic = kind },
+            .location = this.currentSourceLocation(),
+        };
+    }
+
+    pub fn newUnexpectedTokenError(this: *const Parser, token: Token) ParseError(ParserError) {
+        return this.newError(.{ .unexpected_token = token });
+    }
+
+    pub fn newBasicUnexpectedTokenError(this: *const Parser, token: Token) ParseError(ParserError) {
+        return this.newBasicError(.{ .unexpected_token = token }).intoDefaultParseError();
+    }
+
+    pub fn currentSourceLocation(this: *const Parser) SourceLocation {
+        return this.input.tokenizer.currentSourceLocation();
+    }
+
+    pub fn currentSourceMapUrl(this: *const Parser) ?[]const u8 {
+        return this.input.tokenizer.currentSourceMapUrl();
+    }
+
+    /// Return a slice of the CSS input, from the given position to the current one.
+    pub fn sliceFrom(this: *const Parser, start_position: usize) []const u8 {
+        return this.input.tokenizer.sliceFrom(start_position);
+    }
+
+    /// Implementation of Vec::<T>::parse
+    pub fn parseList(this: *Parser, comptime T: type, comptime parse_one: *const fn (*Parser) Result(T)) Result(ArrayList(T)) {
+        return this.parseCommaSeparated(T, parse_one);
+    }
+
+    /// Parse a list of comma-separated values, all with the same syntax.
+    ///
+    /// The given closure is called repeatedly with a "delimited" parser
+    /// (see the `Parser::parse_until_before` method) so that it can over
+    /// consume the input past a comma at this block/function nesting level.
+    ///
+    /// Successful results are accumulated in a vector.
+    ///
+    /// This method returns `Err(())` the first time that a closure call does,
+    /// or if a closure call leaves some input before the next comma or the end
+    /// of the input.
+    pub fn parseCommaSeparated(
+        this: *Parser,
+        comptime T: type,
+        comptime parse_one: *const fn (*Parser) Result(T),
+    ) Result(ArrayList(T)) {
+        return this.parseCommaSeparatedInternal(T, {}, voidWrap(T, parse_one), false);
+    }
+
+    pub fn parseCommaSeparatedWithCtx(
+        this: *Parser,
+        comptime T: type,
+        closure: anytype,
+        comptime parse_one: *const fn (@TypeOf(closure), *Parser) Result(T),
+    ) Result(ArrayList(T)) {
+        return this.parseCommaSeparatedInternal(T, closure, parse_one, false);
+    }
+
+    fn parseCommaSeparatedInternal(
+        this: *Parser,
+        comptime T: type,
+        closure: anytype,
+        comptime parse_one: *const fn (@TypeOf(closure), *Parser) Result(T),
+        ignore_errors: bool,
+    ) Result(ArrayList(T)) {
+        // Vec grows from 0 to 4 by default on first push().  So allocate with
+        // capacity 1, so in the somewhat common case of only one item we don't
+        // way overallocate.  Note that we always push at least one item if
+        // parsing succeeds.
+        //
+        // TODO(zack): might be faster to use stack fallback here
+        // in the common case we may have just 1, but I feel like it is also very common to have >1
+        // which means every time we have >1 items we will always incur 1 more additional allocation
+        var sfb = std.heap.stackFallback(@sizeOf(T), this.allocator());
+        const alloc = sfb.get();
+        var values = ArrayList(T).initCapacity(alloc, 1) catch unreachable;
+
+        while (true) {
+            this.skipWhitespace(); // Unnecessary for correctness, but may help try() in parse_one rewind less.
+            switch (this.parseUntilBefore(Delimiters{ .comma = true }, T, closure, parse_one)) {
+                .result => |v| {
+                    values.append(alloc, v) catch unreachable;
+                },
+                .err => |e| {
+                    if (!ignore_errors) return .{ .err = e };
+                },
+            }
+
+            const tok = switch (this.next()) {
+                .result => |v| v,
+                .err => {
+                    // need to clone off the stack
+                    const needs_clone = values.items.len == 1;
+                    if (needs_clone) return .{ .result = values.clone(this.allocator()) catch bun.outOfMemory() };
+                    return .{ .result = values };
+                },
+            };
+            if (tok.* != .comma) bun.unreachablePanic("", .{});
+        }
+    }
+
+    /// Execute the given closure, passing it the parser.
+    /// If the result (returned unchanged) is `Err`,
+    /// the internal state of the parser  (including position within the input)
+    /// is restored to what it was before the call.
+    ///
+    /// func needs to be a funtion like this: `fn func(*Parser, ...@TypeOf(args_)) T`
+    pub inline fn tryParse(this: *Parser, comptime func: anytype, args_: anytype) bun.meta.ReturnOf(func) {
+        const start = this.state();
+        const result = result: {
+            const args = brk: {
+                var args: std.meta.ArgsTuple(@TypeOf(func)) = undefined;
+                args[0] = this;
+
+                inline for (args_, 1..) |a, i| {
+                    args[i] = a;
+                }
+
+                break :brk args;
+            };
+
+            break :result @call(.auto, func, args);
+        };
+        if (result == .err) {
+            this.reset(&start);
+        }
+        return result;
+    }
+
+    pub inline fn tryParseImpl(this: *Parser, comptime Ret: type, comptime func: anytype, args: anytype) Ret {
+        const start = this.state();
+        const result = result: {
+            break :result @call(.auto, func, args);
+        };
+        if (result == .err) {
+            this.reset(&start);
+        }
+        return result;
+    }
+
+    pub inline fn parseNestedBlock(this: *Parser, comptime T: type, closure: anytype, comptime parsefn: *const fn (@TypeOf(closure), *Parser) Result(T)) Result(T) {
+        return parse_nested_block(this, T, closure, parsefn);
+    }
+
+    pub fn isExhausted(this: *Parser) bool {
+        return this.expectExhausted().isOk();
+    }
+
+    /// Parse the input until exhaustion and check that it contains no “error” token.
+    ///
+    /// See `Token::is_parse_error`. This also checks nested blocks and functions recursively.
+    pub fn expectNoErrorToken(this: *Parser) Result(void) {
+        while (true) {
+            const tok = switch (this.nextIncludingWhitespaceAndComments()) {
+                .err => return .{ .result = {} },
+                .result => |v| v,
+            };
+            switch (tok.*) {
+                .function, .open_paren, .open_square, .open_curly => {
+                    if (this.parseNestedBlock(void, {}, struct {
+                        pub fn parse(_: void, i: *Parser) Result(void) {
+                            if (i.expectNoErrorToken().asErr()) |e| {
+                                return .{ .err = e };
+                            }
+                            return .{ .result = {} };
+                        }
+                    }.parse).asErr()) |err| {
+                        return .{ .err = err };
+                    }
+                    return .{ .result = {} };
+                },
+                else => {
+                    if (tok.isParseError()) {
+                        return .{ .err = this.newUnexpectedTokenError(tok.*) };
+                    }
+                },
+            }
+        }
+    }
+
+    pub fn expectPercentage(this: *Parser) Result(f32) {
+        const start_location = this.currentSourceLocation();
+        const tok = switch (this.next()) {
+            .err => |e| return .{ .err = e },
+            .result => |v| v,
+        };
+        if (tok.* == .percentage) return .{ .result = tok.percentage.unit_value };
+        return .{ .err = start_location.newUnexpectedTokenError(tok.*) };
+    }
+
+    pub fn expectComma(this: *Parser) Result(void) {
+        const start_location = this.currentSourceLocation();
+        const tok = switch (this.next()) {
+            .err => |e| return .{ .err = e },
+            .result => |v| v,
+        };
+        switch (tok.*) {
+            .comma => return .{ .result = {} },
+            else => {},
+        }
+        return .{ .err = start_location.newUnexpectedTokenError(tok.*) };
+    }
+
+    /// Parse a <number-token> that does not have a fractional part, and return the integer value.
+    pub fn expectInteger(this: *Parser) Result(i32) {
+        const start_location = this.currentSourceLocation();
+        const tok = switch (this.next()) {
+            .err => |e| return .{ .err = e },
+            .result => |v| v,
+        };
+        if (tok.* == .number and tok.number.int_value != null) return .{ .result = tok.number.int_value.? };
+        return .{ .err = start_location.newUnexpectedTokenError(tok.*) };
+    }
+
+    /// Parse a <number-token> and return the integer value.
+    pub fn expectNumber(this: *Parser) Result(f32) {
+        const start_location = this.currentSourceLocation();
+        const tok = switch (this.next()) {
+            .err => |e| return .{ .err = e },
+            .result => |v| v,
+        };
+        if (tok.* == .number) return .{ .result = tok.number.value };
+        return .{ .err = start_location.newUnexpectedTokenError(tok.*) };
+    }
+
+    pub fn expectDelim(this: *Parser, delim: u8) Result(void) {
+        const start_location = this.currentSourceLocation();
+        const tok = switch (this.next()) {
+            .err => |e| return .{ .err = e },
+            .result => |v| v,
+        };
+        if (tok.* == .delim and tok.delim == delim) return .{ .result = {} };
+        return .{ .err = start_location.newUnexpectedTokenError(tok.*) };
+    }
+
+    pub fn expectParenthesisBlock(this: *Parser) Result(void) {
+        const start_location = this.currentSourceLocation();
+        const tok = switch (this.next()) {
+            .err => |e| return .{ .err = e },
+            .result => |v| v,
+        };
+        if (tok.* == .open_paren) return .{ .result = {} };
+        return .{ .err = start_location.newUnexpectedTokenError(tok.*) };
+    }
+
+    pub fn expectColon(this: *Parser) Result(void) {
+        const start_location = this.currentSourceLocation();
+        const tok = switch (this.next()) {
+            .err => |e| return .{ .err = e },
+            .result => |v| v,
+        };
+        if (tok.* == .colon) return .{ .result = {} };
+        return .{ .err = start_location.newUnexpectedTokenError(tok.*) };
+    }
+
+    pub fn expectString(this: *Parser) Result([]const u8) {
+        const start_location = this.currentSourceLocation();
+        const tok = switch (this.next()) {
+            .err => |e| return .{ .err = e },
+            .result => |v| v,
+        };
+        if (tok.* == .quoted_string) return .{ .result = tok.quoted_string };
+        return .{ .err = start_location.newUnexpectedTokenError(tok.*) };
+    }
+
+    pub fn expectIdent(this: *Parser) Result([]const u8) {
+        const start_location = this.currentSourceLocation();
+        const tok = switch (this.next()) {
+            .err => |e| return .{ .err = e },
+            .result => |v| v,
+        };
+        if (tok.* == .ident) return .{ .result = tok.ident };
+        return .{ .err = start_location.newUnexpectedTokenError(tok.*) };
+    }
+
+    /// Parse either a <ident-token> or a <string-token>, and return the unescaped value.
+    pub fn expectIdentOrString(this: *Parser) Result([]const u8) {
+        const start_location = this.currentSourceLocation();
+        const tok = switch (this.next()) {
+            .err => |e| return .{ .err = e },
+            .result => |v| v,
+        };
+        switch (tok.*) {
+            .ident => |i| return .{ .result = i },
+            .quoted_string => |s| return .{ .result = s },
+            else => {},
+        }
+        return .{ .err = start_location.newUnexpectedTokenError(tok.*) };
+    }
+
+    pub fn expectIdentMatching(this: *Parser, name: []const u8) Result(void) {
+        const start_location = this.currentSourceLocation();
+        const tok = switch (this.next()) {
+            .err => |e| return .{ .err = e },
+            .result => |v| v,
+        };
+        switch (tok.*) {
+            .ident => |i| if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, i)) return .{ .result = {} },
+            else => {},
+        }
+        return .{ .err = start_location.newUnexpectedTokenError(tok.*) };
+    }
+
+    pub fn expectFunction(this: *Parser) Result([]const u8) {
+        const start_location = this.currentSourceLocation();
+        const tok = switch (this.next()) {
+            .err => |e| return .{ .err = e },
+            .result => |v| v,
+        };
+        switch (tok.*) {
+            .function => |fn_name| return .{ .result = fn_name },
+            else => {},
+        }
+        return .{ .err = start_location.newUnexpectedTokenError(tok.*) };
+    }
+
+    pub fn expectFunctionMatching(this: *Parser, name: []const u8) Result(void) {
+        const start_location = this.currentSourceLocation();
+        const tok = switch (this.next()) {
+            .err => |e| return .{ .err = e },
+            .result => |v| v,
+        };
+        switch (tok.*) {
+            .function => |fn_name| if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, fn_name)) return .{ .result = {} },
+            else => {},
+        }
+        return .{ .err = start_location.newUnexpectedTokenError(tok.*) };
+    }
+
+    pub fn expectCurlyBracketBlock(this: *Parser) Result(void) {
+        const start_location = this.currentSourceLocation();
+        const tok = switch (this.next()) {
+            .err => |e| return .{ .err = e },
+            .result => |v| v,
+        };
+        switch (tok.*) {
+            .open_curly => return .{ .result = {} },
+            else => return .{ .err = start_location.newUnexpectedTokenError(tok.*) },
+        }
+    }
+
+    /// Parse a <url-token> and return the unescaped value.
+    pub fn expectUrl(this: *Parser) Result([]const u8) {
+        const start_location = this.currentSourceLocation();
+        const tok = switch (this.next()) {
+            .err => |e| return .{ .err = e },
+            .result => |v| v,
+        };
+        switch (tok.*) {
+            .unquoted_url => |value| return .{ .result = value },
+            .function => |name| {
+                if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("url", name)) {
+                    const result = this.parseNestedBlock([]const u8, {}, struct {
+                        fn parse(_: void, parser: *Parser) Result([]const u8) {
+                            return switch (parser.expectString()) {
+                                .result => |v| .{ .result = v },
+                                .err => |e| .{ .err = e },
+                            };
+                        }
+                    }.parse);
+                    return switch (result) {
+                        .result => |v| .{ .result = v },
+                        .err => |e| .{ .err = e },
+                    };
+                }
+            },
+            else => {},
+        }
+        return .{ .err = start_location.newUnexpectedTokenError(tok.*) };
+    }
+
+    /// Parse either a <url-token> or a <string-token>, and return the unescaped value.
+    pub fn expectUrlOrString(this: *Parser) Result([]const u8) {
+        const start_location = this.currentSourceLocation();
+        const tok = switch (this.next()) {
+            .err => |e| return .{ .err = e },
+            .result => |v| v,
+        };
+        switch (tok.*) {
+            .unquoted_url => |value| return .{ .result = value },
+            .quoted_string => |value| return .{ .result = value },
+            .function => |name| {
+                if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("url", name)) {
+                    const result = this.parseNestedBlock([]const u8, {}, struct {
+                        fn parse(_: void, parser: *Parser) Result([]const u8) {
+                            return switch (parser.expectString()) {
+                                .result => |v| .{ .result = v },
+                                .err => |e| .{ .err = e },
+                            };
+                        }
+                    }.parse);
+                    return switch (result) {
+                        .result => |v| .{ .result = v },
+                        .err => |e| .{ .err = e },
+                    };
+                }
+            },
+            else => {},
+        }
+        return .{ .err = start_location.newUnexpectedTokenError(tok.*) };
+    }
+
+    pub fn position(this: *Parser) usize {
+        bun.debugAssert(bun.strings.isOnCharBoundary(this.input.tokenizer.src, this.input.tokenizer.position));
+        return this.input.tokenizer.position;
+    }
+
+    fn parseEmpty(_: *Parser) Result(void) {
+        return .{ .result = {} };
+    }
+
+    /// Like `parse_until_before`, but also consume the delimiter token.
+    ///
+    /// This can be useful when you don’t need to know which delimiter it was
+    /// (e.g. if these is only one in the given set)
+    /// or if it was there at all (as opposed to reaching the end of the input).
+    pub fn parseUntilAfter(
+        this: *Parser,
+        delimiters: Delimiters,
+        comptime T: type,
+        closure: anytype,
+        comptime parse_fn: *const fn (@TypeOf(closure), *Parser) Result(T),
+    ) Result(T) {
+        return parse_until_after(
+            this,
+            delimiters,
+            ParseUntilErrorBehavior.consume,
+            T,
+            closure,
+            parse_fn,
+        );
+    }
+
+    pub fn parseUntilBefore(this: *Parser, delimiters: Delimiters, comptime T: type, closure: anytype, comptime parse_fn: *const fn (@TypeOf(closure), *Parser) Result(T)) Result(T) {
+        return parse_until_before(this, delimiters, .consume, T, closure, parse_fn);
+    }
+
+    pub fn parseEntirely(this: *Parser, comptime T: type, closure: anytype, comptime parsefn: *const fn (@TypeOf(closure), *Parser) Result(T)) Result(T) {
+        const result = switch (parsefn(closure, this)) {
+            .err => |e| return .{ .err = e },
+            .result => |v| v,
+        };
+        if (this.expectExhausted().asErr()) |e| return .{ .err = e };
+        return .{ .result = result };
+    }
+
+    /// Check whether the input is exhausted. That is, if `.next()` would return a token.
+    /// Return a `Result` so that the `?` operator can be used: `input.expect_exhausted()?`
+    ///
+    /// This ignores whitespace and comments.
+    pub fn expectExhausted(this: *Parser) Result(void) {
+        const start = this.state();
+        const result: Result(void) = switch (this.next()) {
+            .result => |t| .{ .err = start.sourceLocation().newUnexpectedTokenError(t.*) },
+            .err => |e| brk: {
+                if (e.kind == .basic and e.kind.basic == .end_of_input) break :brk .{ .result = {} };
+                bun.unreachablePanic("Unexpected error encountered: {}", .{e.kind});
+            },
+        };
+        this.reset(&start);
+        return result;
+    }
+
+    pub fn @"skip cdc and cdo"(this: *@This()) void {
+        if (this.at_start_of) |block_type| {
+            this.at_start_of = null;
+            consume_until_end_of_block(block_type, &this.input.tokenizer);
+        }
+
+        this.input.tokenizer.@"skip cdc and cdo"();
+    }
+
+    pub fn skipWhitespace(this: *@This()) void {
+        if (this.at_start_of) |block_type| {
+            this.at_start_of = null;
+            consume_until_end_of_block(block_type, &this.input.tokenizer);
+        }
+
+        this.input.tokenizer.skipWhitespace();
+    }
+
+    pub fn next(this: *@This()) Result(*Token) {
+        this.skipWhitespace();
+        return this.nextIncludingWhitespaceAndComments();
+    }
+
+    /// Same as `Parser::next`, but does not skip whitespace tokens.
+    pub fn nextIncludingWhitespace(this: *@This()) Result(*Token) {
+        while (true) {
+            switch (this.nextIncludingWhitespaceAndComments()) {
+                .result => |tok| if (tok.* == .comment) {} else break,
+                .err => |e| return .{ .err = e },
+            }
+        }
+        return .{ .result = &this.input.cached_token.?.token };
+    }
+
+    pub fn nextByte(this: *@This()) ?u8 {
+        const byte = this.input.tokenizer.nextByte();
+        if (this.stop_before.contains(Delimiters.fromByte(byte))) {
+            return null;
+        }
+        return byte;
+    }
+
+    pub fn reset(this: *Parser, state_: *const ParserState) void {
+        this.input.tokenizer.reset(state_);
+        this.at_start_of = state_.at_start_of;
+        if (this.import_records) |import_records| import_records.len = state_.import_record_count;
+    }
+
+    pub fn state(this: *Parser) ParserState {
+        return ParserState{
+            .position = this.input.tokenizer.getPosition(),
+            .current_line_start_position = this.input.tokenizer.current_line_start_position,
+            .current_line_number = @intCast(this.input.tokenizer.current_line_number),
+            .at_start_of = this.at_start_of,
+            .import_record_count = if (this.import_records) |import_records| import_records.len else 0,
+        };
+    }
+
+    /// Same as `Parser::next`, but does not skip whitespace or comment tokens.
+    ///
+    /// **Note**: This should only be used in contexts like a CSS pre-processor
+    /// where comments are preserved.
+    /// When parsing higher-level values, per the CSS Syntax specification,
+    /// comments should always be ignored between tokens.
+    pub fn nextIncludingWhitespaceAndComments(this: *Parser) Result(*Token) {
+        if (this.at_start_of) |block_type| {
+            this.at_start_of = null;
+            consume_until_end_of_block(block_type, &this.input.tokenizer);
+        }
+
+        const byte = this.input.tokenizer.nextByte();
+        if (this.stop_before.contains(Delimiters.fromByte(byte))) {
+            return .{ .err = this.newError(BasicParseErrorKind.end_of_input) };
+        }
+
+        const token_start_position = this.input.tokenizer.getPosition();
+        const using_cached_token = this.input.cached_token != null and this.input.cached_token.?.start_position == token_start_position;
+
+        const token = if (using_cached_token) token: {
+            const cached_token = &this.input.cached_token.?;
+            this.input.tokenizer.reset(&cached_token.end_state);
+            if (cached_token.token == .function) {
+                this.input.tokenizer.seeFunction(cached_token.token.function);
+            }
+            break :token &cached_token.token;
+        } else token: {
+            const new_token = switch (this.input.tokenizer.next()) {
+                .result => |v| v,
+                .err => return .{ .err = this.newError(BasicParseErrorKind.end_of_input) },
+            };
+            this.input.cached_token = CachedToken{
+                .token = new_token,
+                .start_position = token_start_position,
+                .end_state = this.input.tokenizer.state(),
+            };
+            break :token &this.input.cached_token.?.token;
+        };
+
+        if (BlockType.opening(token)) |block_type| {
+            this.at_start_of = block_type;
+        }
+
+        return .{ .result = token };
+    }
+
+    /// Create a new unexpected token or EOF ParseError at the current location
+    pub fn newErrorForNextToken(this: *Parser) ParseError(ParserError) {
+        const token = switch (this.next()) {
+            .result => |t| t.*,
+            .err => |e| return e,
+        };
+        return this.newError(BasicParseErrorKind{ .unexpected_token = token });
+    }
+};
+
+/// A set of characters, to be used with the `Parser::parse_until*` methods.
+///
+/// The union of two sets can be obtained with the `|` operator. Example:
+///
+/// ```{rust,ignore}
+/// input.parse_until_before(Delimiter::CurlyBracketBlock | Delimiter::Semicolon)
+/// ```
+pub const Delimiters = packed struct(u8) {
+    /// The delimiter set with only the `{` opening curly bracket
+    curly_bracket: bool = false,
+    /// The delimiter set with only the `;` semicolon
+    semicolon: bool = false,
+    /// The delimiter set with only the `!` exclamation point
+    bang: bool = false,
+    /// The delimiter set with only the `,` comma
+    comma: bool = false,
+    close_curly_bracket: bool = false,
+    close_square_bracket: bool = false,
+    close_parenthesis: bool = false,
+    __unused: u1 = 0,
+
+    pub usingnamespace Bitflags(Delimiters);
+
+    const NONE: Delimiters = .{};
+
+    pub fn getDelimiter(comptime tag: @TypeOf(.EnumLiteral)) Delimiters {
+        var empty = Delimiters{};
+        @field(empty, @tagName(tag)) = true;
+        return empty;
+    }
+
+    const TABLE: [256]Delimiters = brk: {
+        var table: [256]Delimiters = [_]Delimiters{.{}} ** 256;
+        table[';'] = getDelimiter(.semicolon);
+        table['!'] = getDelimiter(.bang);
+        table[','] = getDelimiter(.comma);
+        table['{'] = getDelimiter(.curly_bracket);
+        table['}'] = getDelimiter(.close_curly_bracket);
+        table[']'] = getDelimiter(.close_square_bracket);
+        table[')'] = getDelimiter(.close_parenthesis);
+        break :brk table;
+    };
+
+    // pub fn bitwiseOr(lhs: Delimiters, rhs: Delimiters) Delimiters {
+    //     return @bitCast(@as(u8, @bitCast(lhs)) | @as(u8, @bitCast(rhs)));
+    // }
+
+    // pub fn contains(lhs: Delimiters, rhs: Delimiters) bool {
+    //     return @as(u8, @bitCast(lhs)) & @as(u8, @bitCast(rhs)) != 0;
+    // }
+
+    pub fn fromByte(byte: ?u8) Delimiters {
+        if (byte) |b| return TABLE[b];
+        return .{};
+    }
+};
+
+pub const ParserInput = struct {
+    tokenizer: Tokenizer,
+    cached_token: ?CachedToken = null,
+
+    pub fn new(allocator: Allocator, code: []const u8) ParserInput {
+        return ParserInput{
+            .tokenizer = Tokenizer.init(allocator, code),
+        };
+    }
+};
+
+/// A capture of the internal state of a `Parser` (including the position within the input),
+/// obtained from the `Parser::position` method.
+///
+/// Can be used with the `Parser::reset` method to restore that state.
+/// Should only be used with the `Parser` instance it came from.
+pub const ParserState = struct {
+    position: usize,
+    current_line_start_position: usize,
+    current_line_number: u32,
+    import_record_count: u32,
+    at_start_of: ?BlockType,
+
+    pub fn sourceLocation(this: *const ParserState) SourceLocation {
+        return .{
+            .line = this.current_line_number,
+            .column = @intCast(this.position - this.current_line_start_position + 1),
+        };
+    }
+};
+
+const BlockType = enum {
+    parenthesis,
+    square_bracket,
+    curly_bracket,
+
+    fn opening(token: *const Token) ?BlockType {
+        return switch (token.*) {
+            .function, .open_paren => .parenthesis,
+            .open_square => .square_bracket,
+            .open_curly => .curly_bracket,
+            else => null,
+        };
+    }
+
+    fn closing(token: *const Token) ?BlockType {
+        return switch (token.*) {
+            .close_paren => .parenthesis,
+            .close_square => .square_bracket,
+            .close_curly => .curly_bracket,
+            else => null,
+        };
+    }
+};
+
+pub const nth = struct {
+    const NthResult = struct { i32, i32 };
+    /// Parse the *An+B* notation, as found in the `:nth-child()` selector.
+    /// The input is typically the arguments of a function,
+    /// in which case the caller needs to check if the arguments’ parser is exhausted.
+    /// Return `Ok((A, B))`, or `Err(())` for a syntax error.
+    pub fn parse_nth(input: *Parser) Result(NthResult) {
+        const tok = switch (input.next()) {
+            .err => |e| return .{ .err = e },
+            .result => |v| v,
+        };
+        switch (tok.*) {
+            .number => {
+                if (tok.number.int_value) |b| return .{ .result = .{ 0, b } };
+            },
+            .dimension => {
+                if (tok.dimension.num.int_value) |a| {
+                    // @compileError(todo_stuff.match_ignore_ascii_case);
+                    const unit = tok.dimension.unit;
+                    if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(unit, "n")) {
+                        return parse_b(input, a);
+                    } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(unit, "n-")) {
+                        return parse_signless_b(input, a, -1);
+                    } else {
+                        if (parse_n_dash_digits(input.allocator(), unit).asValue()) |b| {
+                            return .{ .result = .{ a, b } };
+                        } else {
+                            return .{ .err = input.newUnexpectedTokenError(.{ .ident = unit }) };
+                        }
+                    }
+                }
+            },
+            .ident => {
+                const value = tok.ident;
+                // @compileError(todo_stuff.match_ignore_ascii_case);
+                if (bun.strings.eqlCaseInsensitiveASCIIIgnoreLength(value, "even")) {
+                    return .{ .result = .{ 2, 0 } };
+                } else if (bun.strings.eqlCaseInsensitiveASCIIIgnoreLength(value, "odd")) {
+                    return .{ .result = .{ 2, 1 } };
+                } else if (bun.strings.eqlCaseInsensitiveASCIIIgnoreLength(value, "n")) {
+                    return parse_b(input, 1);
+                } else if (bun.strings.eqlCaseInsensitiveASCIIIgnoreLength(value, "-n")) {
+                    return parse_b(input, -1);
+                } else if (bun.strings.eqlCaseInsensitiveASCIIIgnoreLength(value, "n-")) {
+                    return parse_signless_b(input, 1, -1);
+                } else if (bun.strings.eqlCaseInsensitiveASCIIIgnoreLength(value, "-n-")) {
+                    return parse_signless_b(input, -1, -1);
+                } else {
+                    const slice, const a: i32 = if (bun.strings.startsWithChar(value, '-')) .{ value[1..], -1 } else .{ value, 1 };
+                    if (parse_n_dash_digits(input.allocator(), slice).asValue()) |b| return .{ .result = .{ a, b } };
+                    return .{ .err = input.newUnexpectedTokenError(.{ .ident = value }) };
+                }
+            },
+            .delim => {
+                const next_tok = switch (input.nextIncludingWhitespace()) {
+                    .err => |e| return .{ .err = e },
+                    .result => |v| v,
+                };
+                if (next_tok.* == .ident) {
+                    const value = next_tok.ident;
+                    if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(value, "n")) {
+                        return parse_b(input, 1);
+                    } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(value, "-n")) {
+                        return parse_signless_b(input, 1, -1);
+                    } else {
+                        if (parse_n_dash_digits(input.allocator(), value).asValue()) |b| {
+                            return .{ .result = .{ 1, b } };
+                        } else {
+                            return .{ .err = input.newUnexpectedTokenError(.{ .ident = value }) };
+                        }
+                    }
+                } else {
+                    return .{ .err = input.newUnexpectedTokenError(next_tok.*) };
+                }
+            },
+            else => {},
+        }
+        return .{ .err = input.newUnexpectedTokenError(tok.*) };
+    }
+
+    fn parse_b(input: *Parser, a: i32) Result(NthResult) {
+        const start = input.state();
+        const tok = switch (input.next()) {
+            .result => |v| v,
+            .err => {
+                input.reset(&start);
+                return .{ .result = .{ a, 0 } };
+            },
+        };
+
+        if (tok.* == .delim and tok.delim == '+') return parse_signless_b(input, a, 1);
+        if (tok.* == .delim and tok.delim == '-') return parse_signless_b(input, a, -1);
+        if (tok.* == .number and tok.number.has_sign and tok.number.int_value != null) return .{ .result = NthResult{ a, tok.number.int_value.? } };
+        input.reset(&start);
+        return .{ .result = .{ a, 0 } };
+    }
+
+    fn parse_signless_b(input: *Parser, a: i32, b_sign: i32) Result(NthResult) {
+        const tok = switch (input.next()) {
+            .err => |e| return .{ .err = e },
+            .result => |v| v,
+        };
+        if (tok.* == .number and !tok.number.has_sign and tok.number.int_value != null) {
+            const b = tok.number.int_value.?;
+            return .{ .result = .{ a, b_sign * b } };
+        }
+        return .{ .err = input.newUnexpectedTokenError(tok.*) };
+    }
+
+    fn parse_n_dash_digits(allocator: Allocator, str: []const u8) Maybe(i32, void) {
+        const bytes = str;
+        if (bytes.len >= 3 and
+            bun.strings.eqlCaseInsensitiveASCIIICheckLength(bytes[0..2], "n-") and
+            brk: {
+            for (bytes[2..]) |b| {
+                if (b < '0' or b > '9') break :brk false;
+            }
+            break :brk true;
+        }) {
+            return parse_number_saturate(allocator, str[1..]); // Include the minus sign
+        } else {
+            return .{ .err = {} };
+        }
+    }
+
+    fn parse_number_saturate(allocator: Allocator, string: []const u8) Maybe(i32, void) {
+        var input = ParserInput.new(allocator, string);
+        var parser = Parser.new(&input, null);
+        const tok = switch (parser.nextIncludingWhitespaceAndComments()) {
+            .result => |v| v,
+            .err => {
+                return .{ .err = {} };
+            },
+        };
+        const int = if (tok.* == .number and tok.number.int_value != null) tok.number.int_value.? else {
+            return .{ .err = {} };
+        };
+        if (!parser.isExhausted()) {
+            return .{ .err = {} };
+        }
+        return .{ .result = int };
+    }
+};
+
+const CachedToken = struct {
+    token: Token,
+    start_position: usize,
+    end_state: ParserState,
+};
+
+const Tokenizer = struct {
+    src: []const u8,
+    position: usize = 0,
+    source_map_url: ?[]const u8 = null,
+    current_line_start_position: usize = 0,
+    current_line_number: u32 = 0,
+    allocator: Allocator,
+    var_or_env_functions: SeenStatus = .dont_care,
+    current: Token = undefined,
+    previous: Token = undefined,
+
+    const SeenStatus = enum {
+        dont_care,
+        looking_for_them,
+        seen_at_least_one,
+    };
+
+    const FORM_FEED_BYTE = 0x0C;
+    const REPLACEMENT_CHAR = 0xFFFD;
+    const REPLACEMENT_CHAR_UNICODE: [3]u8 = [3]u8{ 0xEF, 0xBF, 0xBD };
+    const MAX_ONE_B: u32 = 0x80;
+    const MAX_TWO_B: u32 = 0x800;
+    const MAX_THREE_B: u32 = 0x10000;
+
+    pub fn init(allocator: Allocator, src: []const u8) Tokenizer {
+        var lexer = Tokenizer{
+            .src = src,
+            .allocator = allocator,
+            .position = 0,
+        };
+
+        // make current point to the first token
+        _ = lexer.next();
+        lexer.position = 0;
+
+        return lexer;
+    }
+
+    pub fn currentSourceMapUrl(this: *const Tokenizer) ?[]const u8 {
+        return this.source_map_url;
+    }
+
+    pub fn getPosition(this: *const Tokenizer) usize {
+        bun.debugAssert(bun.strings.isOnCharBoundary(this.src, this.position));
+        return this.position;
+    }
+
+    pub fn state(this: *const Tokenizer) ParserState {
+        return ParserState{
+            .position = this.position,
+            .current_line_start_position = this.current_line_start_position,
+            .current_line_number = this.current_line_number,
+            .at_start_of = null,
+            .import_record_count = 0,
+        };
+    }
+
+    pub fn skipWhitespace(this: *Tokenizer) void {
+        while (!this.isEof()) {
+            // todo_stuff.match_byte
+            switch (this.nextByteUnchecked()) {
+                ' ', '\t' => this.advance(1),
+                '\n', 0x0C, '\r' => this.consumeNewline(),
+                '/' => {
+                    if (this.startsWith("/*")) {
+                        _ = this.consumeComment();
+                    } else return;
+                },
+                else => return,
+            }
+        }
+    }
+
+    pub fn currentSourceLocation(this: *const Tokenizer) SourceLocation {
+        return SourceLocation{
+            .line = this.current_line_number,
+            .column = @intCast((this.position - this.current_line_start_position) + 1),
+        };
+    }
+
+    pub fn prev(this: *Tokenizer) Token {
+        bun.assert(this.position > 0);
+        return this.previous;
+    }
+
+    pub inline fn isEof(this: *Tokenizer) bool {
+        return this.position >= this.src.len;
+    }
+
+    pub fn seeFunction(this: *Tokenizer, name: []const u8) void {
+        if (this.var_or_env_functions == .looking_for_them) {
+            if (std.ascii.eqlIgnoreCase(name, "var") and std.ascii.eqlIgnoreCase(name, "env")) {
+                this.var_or_env_functions = .seen_at_least_one;
+            }
+        }
+    }
+
+    /// TODO: fix this, remove the additional shit I added
+    /// return error if it is eof
+    pub inline fn next(this: *Tokenizer) Maybe(Token, void) {
+        return this.nextImpl();
+    }
+
+    pub fn nextImpl(this: *Tokenizer) Maybe(Token, void) {
+        if (this.isEof()) return .{ .err = {} };
+
+        // todo_stuff.match_byte;
+        const b = this.byteAt(0);
+        const token: Token = switch (b) {
+            ' ', '\t' => this.consumeWhitespace(false),
+            '\n', FORM_FEED_BYTE, '\r' => this.consumeWhitespace(true),
+            '"' => this.consumeString(false),
+            '#' => brk: {
+                this.advance(1);
+                if (this.isIdentStart()) break :brk .{ .idhash = this.consumeName() };
+                if (!this.isEof() and switch (this.nextByteUnchecked()) {
+                    // Any other valid case here already resulted in IDHash.
+                    '0'...'9', '-' => true,
+                    else => false,
+                }) break :brk .{ .hash = this.consumeName() };
+                break :brk .{ .delim = '#' };
+            },
+            '$' => brk: {
+                if (this.startsWith("$=")) {
+                    this.advance(2);
+                    break :brk .suffix_match;
+                }
+                this.advance(1);
+                break :brk .{ .delim = '$' };
+            },
+            '\'' => this.consumeString(true),
+            '(' => brk: {
+                this.advance(1);
+                break :brk .open_paren;
+            },
+            ')' => brk: {
+                this.advance(1);
+                break :brk .close_paren;
+            },
+            '*' => brk: {
+                if (this.startsWith("*=")) {
+                    this.advance(2);
+                    break :brk .substring_match;
+                }
+                this.advance(1);
+                break :brk .{ .delim = '*' };
+            },
+            '+' => brk: {
+                if ((this.hasAtLeast(1) and switch (this.byteAt(1)) {
+                    '0'...'9' => true,
+                    else => false,
+                }) or (this.hasAtLeast(2) and
+                    this.byteAt(1) == '.' and switch (this.byteAt(2)) {
+                    '0'...'9' => true,
+                    else => false,
+                })) {
+                    break :brk this.consumeNumeric();
+                }
+
+                this.advance(1);
+                break :brk .{ .delim = '+' };
+            },
+            ',' => brk: {
+                this.advance(1);
+                break :brk .comma;
+            },
+            '-' => brk: {
+                if ((this.hasAtLeast(1) and switch (this.byteAt(1)) {
+                    '0'...'9' => true,
+                    else => false,
+                }) or (this.hasAtLeast(2) and this.byteAt(1) == '.' and switch (this.byteAt(2)) {
+                    '0'...'9' => true,
+                    else => false,
+                })) break :brk this.consumeNumeric();
+
+                if (this.startsWith("-->")) {
+                    this.advance(3);
+                    break :brk .cdc;
+                }
+
+                if (this.isIdentStart()) break :brk this.consumeIdentLike();
+
+                this.advance(1);
+                break :brk .{ .delim = '-' };
+            },
+            '.' => brk: {
+                if (this.hasAtLeast(1) and switch (this.byteAt(1)) {
+                    '0'...'9' => true,
+                    else => false,
+                }) {
+                    break :brk this.consumeNumeric();
+                }
+                this.advance(1);
+                break :brk .{ .delim = '.' };
+            },
+            '/' => brk: {
+                if (this.startsWith("/*")) break :brk .{ .comment = this.consumeComment() };
+                this.advance(1);
+                break :brk .{ .delim = '/' };
+            },
+            '0'...'9' => this.consumeNumeric(),
+            ':' => brk: {
+                this.advance(1);
+                break :brk .colon;
+            },
+            ';' => brk: {
+                this.advance(1);
+                break :brk .semicolon;
+            },
+            '<' => brk: {
+                if (this.startsWith("<!--")) {
+                    this.advance(4);
+                    break :brk .cdo;
+                }
+                this.advance(1);
+                break :brk .{ .delim = '<' };
+            },
+            '@' => brk: {
+                this.advance(1);
+                if (this.isIdentStart()) break :brk .{ .at_keyword = this.consumeName() };
+                break :brk .{ .delim = '@' };
+            },
+            'a'...'z', 'A'...'Z', '_', 0 => this.consumeIdentLike(),
+            '[' => brk: {
+                this.advance(1);
+                break :brk .open_square;
+            },
+            '\\' => brk: {
+                if (!this.hasNewlineAt(1)) break :brk this.consumeIdentLike();
+                this.advance(1);
+                break :brk .{ .delim = '\\' };
+            },
+            ']' => brk: {
+                this.advance(1);
+                break :brk .close_square;
+            },
+            '^' => brk: {
+                if (this.startsWith("^=")) {
+                    this.advance(2);
+                    break :brk .prefix_match;
+                }
+                this.advance(1);
+                break :brk .{ .delim = '^' };
+            },
+            '{' => brk: {
+                this.advance(1);
+                break :brk .open_curly;
+            },
+            '|' => brk: {
+                if (this.startsWith("|=")) {
+                    this.advance(2);
+                    break :brk .dash_match;
+                }
+                this.advance(1);
+                break :brk .{ .delim = '|' };
+            },
+            '}' => brk: {
+                this.advance(1);
+                break :brk .close_curly;
+            },
+            '~' => brk: {
+                if (this.startsWith("~=")) {
+                    this.advance(2);
+                    break :brk .include_match;
+                }
+                this.advance(1);
+                break :brk .{ .delim = '~' };
+            },
+            else => brk: {
+                if (!std.ascii.isASCII(b)) {
+                    break :brk this.consumeIdentLike();
+                }
+                this.advance(1);
+                break :brk .{ .delim = b };
+            },
+        };
+
+        return .{ .result = token };
+    }
+
+    pub fn reset(this: *Tokenizer, state2: *const ParserState) void {
+        this.position = state2.position;
+        this.current_line_start_position = state2.current_line_start_position;
+        this.current_line_number = state2.current_line_number;
+    }
+
+    pub fn @"skip cdc and cdo"(this: *@This()) void {
+        while (!this.isEof()) {
+            // todo_stuff.match_byte
+            switch (this.nextByteUnchecked()) {
+                ' ', '\t' => this.advance(1),
+                '\n', 0x0C, '\r' => this.consumeNewline(),
+                '/' => if (this.startsWith("/*")) {
+                    _ = this.consumeComment();
+                } else return,
+                '<' => if (this.startsWith("<!--")) this.advance(4) else return,
+                '-' => if (this.startsWith("-->")) this.advance(3) else return,
+                else => return,
+            }
+        }
+    }
+
+    pub fn consumeNumeric(this: *Tokenizer) Token {
+        // Parse [+-]?\d*(\.\d+)?([eE][+-]?\d+)?
+        // But this is always called so that there is at least one digit in \d*(\.\d+)?
+
+        // Do all the math in f64 so that large numbers overflow to +/-inf
+        // and i32::{MIN, MAX} are within range.
+        const has_sign: bool, const sign: f64 = brk: {
+            switch (this.nextByteUnchecked()) {
+                '-' => break :brk .{ true, -1.0 },
+                '+' => break :brk .{ true, 1.0 },
+                else => break :brk .{ false, 1.0 },
+            }
+        };
+
+        if (has_sign) this.advance(1);
+
+        var integral_part: f64 = 0.0;
+        while (byteToDecimalDigit(this.nextByteUnchecked())) |digit| {
+            integral_part = integral_part * 10.0 + @as(f64, @floatFromInt(digit));
+            this.advance(1);
+            if (this.isEof()) break;
+        }
+
+        var is_integer = true;
+
+        var fractional_part: f64 = 0.0;
+        if (this.hasAtLeast(1) and this.nextByteUnchecked() == '.' and switch (this.byteAt(1)) {
+            '0'...'9' => true,
+            else => false,
+        }) {
+            is_integer = false;
+            this.advance(1); // Consume '.'
+            var factor: f64 = 0.1;
+            while (byteToDecimalDigit(this.nextByteUnchecked())) |digit| {
+                fractional_part += @as(f64, @floatFromInt(digit)) * factor;
+                factor *= 0.1;
+                this.advance(1);
+                if (this.isEof()) break;
+            }
+        }
+
+        var value: f64 = sign * (integral_part + fractional_part);
+
+        if (this.hasAtLeast(1) and switch (this.nextByteUnchecked()) {
+            'e', 'E' => true,
+            else => false,
+        }) {
+            if (switch (this.byteAt(1)) {
+                '0'...'9' => true,
+                else => false,
+            } or (this.hasAtLeast(2) and switch (this.byteAt(1)) {
+                '+', '-' => true,
+                else => false,
+            } and switch (this.byteAt(2)) {
+                '0'...'9' => true,
+                else => false,
+            })) {
+                is_integer = false;
+                this.advance(1);
+                const has_sign2: bool, const sign2: f64 = brk: {
+                    switch (this.nextByteUnchecked()) {
+                        '-' => break :brk .{ true, -1.0 },
+                        '+' => break :brk .{ true, 1.0 },
+                        else => break :brk .{ false, 1.0 },
+                    }
+                };
+
+                if (has_sign2) this.advance(1);
+
+                var exponent: f64 = 0.0;
+                while (byteToDecimalDigit(this.nextByteUnchecked())) |digit| {
+                    exponent = exponent * 10.0 + @as(f64, @floatFromInt(digit));
+                    this.advance(1);
+                    if (this.isEof()) break;
+                }
+                value *= bun.pow(10, sign2 * exponent);
+            }
+        }
+
+        const int_value: ?i32 = brk: {
+            const i32_max = comptime std.math.maxInt(i32);
+            const i32_min = comptime std.math.minInt(i32);
+            if (is_integer) {
+                if (value >= @as(f64, @floatFromInt(i32_max))) {
+                    break :brk i32_max;
+                } else if (value <= @as(f64, @floatFromInt(i32_min))) {
+                    break :brk i32_min;
+                } else {
+                    break :brk @intFromFloat(value);
+                }
+            }
+
+            break :brk null;
+        };
+
+        if (!this.isEof() and this.nextByteUnchecked() == '%') {
+            this.advance(1);
+            return .{ .percentage = .{ .unit_value = @floatCast(value / 100), .int_value = int_value, .has_sign = has_sign } };
+        }
+
+        if (this.isIdentStart()) {
+            const unit = this.consumeName();
+            return .{
+                .dimension = .{
+                    .num = .{ .value = @floatCast(value), .int_value = int_value, .has_sign = has_sign },
+                    .unit = unit,
+                },
+            };
+        }
+
+        return .{
+            .number = .{ .value = @floatCast(value), .int_value = int_value, .has_sign = has_sign },
+        };
+    }
+
+    pub fn consumeWhitespace(this: *Tokenizer, comptime newline: bool) Token {
+        const start_position = this.position;
+        if (newline) {
+            this.consumeNewline();
+        } else {
+            this.advance(1);
+        }
+
+        while (!this.isEof()) {
+            // todo_stuff.match_byte
+            const b = this.nextByteUnchecked();
+            switch (b) {
+                ' ', '\t' => this.advance(1),
+                '\n', FORM_FEED_BYTE, '\r' => this.consumeNewline(),
+                else => break,
+            }
+        }
+
+        return .{ .whitespace = this.sliceFrom(start_position) };
+    }
+
+    pub fn consumeString(this: *Tokenizer, comptime single_quote: bool) Token {
+        const quoted_string = this.consumeQuotedString(single_quote);
+        if (quoted_string.bad) return .{ .bad_string = quoted_string.str };
+        return .{ .quoted_string = quoted_string.str };
+    }
+
+    pub fn consumeIdentLike(this: *Tokenizer) Token {
+        const value = this.consumeName();
+        if (!this.isEof() and this.nextByteUnchecked() == '(') {
+            this.advance(1);
+            if (std.ascii.eqlIgnoreCase(value, "url")) return if (this.consumeUnquotedUrl()) |tok| return tok else .{ .function = value };
+            this.seeFunction(value);
+            return .{ .function = value };
+        }
+        return .{ .ident = value };
+    }
+
+    pub fn consumeName(this: *Tokenizer) []const u8 {
+        const start_pos = this.position;
+        var value_bytes: CopyOnWriteStr = undefined;
+
+        while (true) {
+            if (this.isEof()) return this.sliceFrom(start_pos);
+
+            // todo_stuff.match_byte
+            switch (this.nextByteUnchecked()) {
+                'a'...'z', 'A'...'Z', '0'...'9', '_', '-' => this.advance(1),
+                '\\', 0 => {
+                    // * The tokenizer’s input is UTF-8 since it’s `&str`.
+                    // * start_pos is at a code point boundary
+                    // * so is the current position (which is before '\\' or '\0'
+                    //
+                    // So `value_bytes` is well-formed UTF-8.
+                    value_bytes = .{ .borrowed = this.sliceFrom(start_pos) };
+                    break;
+                },
+                0x80...0xBF => this.consumeContinuationByte(),
+                // This is the range of the leading byte of a 2-3 byte character
+                // encoding
+                0xC0...0xEF => this.advance(1),
+                0xF0...0xFF => this.consume4byteIntro(),
+                else => return this.sliceFrom(start_pos),
+            }
+        }
+
+        while (!this.isEof()) {
+            const b = this.nextByteUnchecked();
+            // todo_stuff.match_byte
+            switch (b) {
+                'a'...'z', 'A'...'Z', '0'...'9', '_', '-' => {
+                    this.advance(1);
+                    value_bytes.append(this.allocator, &[_]u8{b});
+                },
+                '\\' => {
+                    if (this.hasNewlineAt(1)) break;
+                    this.advance(1);
+                    this.consumeEscapeAndWrite(&value_bytes);
+                },
+                0 => {
+                    this.advance(1);
+                    value_bytes.append(this.allocator, REPLACEMENT_CHAR_UNICODE[0..]);
+                },
+                0x80...0xBF => {
+                    // This byte *is* part of a multi-byte code point,
+                    // we’ll end up copying the whole code point before this loop does something else.
+                    this.consumeContinuationByte();
+                    value_bytes.append(this.allocator, &[_]u8{b});
+                },
+                0xC0...0xEF => {
+                    // This byte *is* part of a multi-byte code point,
+                    // we’ll end up copying the whole code point before this loop does something else.
+                    this.advance(1);
+                    value_bytes.append(this.allocator, &[_]u8{b});
+                },
+                0xF0...0xFF => {
+                    this.consume4byteIntro();
+                    value_bytes.append(this.allocator, &[_]u8{b});
+                },
+                else => {
+                    // ASCII
+                    break;
+                },
+            }
+        }
+
+        return value_bytes.toSlice();
+    }
+
+    pub fn consumeQuotedString(this: *Tokenizer, comptime single_quote: bool) struct { str: []const u8, bad: bool = false } {
+        this.advance(1); // Skip the initial quote
+        const start_pos = this.position;
+        var string_bytes: CopyOnWriteStr = undefined;
+
+        while (true) {
+            if (this.isEof()) return .{ .str = this.sliceFrom(start_pos) };
+
+            // todo_stuff.match_byte
+            switch (this.nextByteUnchecked()) {
+                '"' => {
+                    if (!single_quote) {
+                        const value = this.sliceFrom(start_pos);
+                        this.advance(1);
+                        return .{ .str = value };
+                    }
+                    this.advance(1);
+                },
+                '\'' => {
+                    if (single_quote) {
+                        const value = this.sliceFrom(start_pos);
+                        this.advance(1);
+                        return .{ .str = value };
+                    }
+                    this.advance(1);
+                },
+                // The CSS spec says NULL bytes ('\0') should be turned into replacement characters: 0xFFFD
+                '\\', 0 => {
+                    // * The tokenizer’s input is UTF-8 since it’s `&str`.
+                    // * start_pos is at a code point boundary
+                    // * so is the current position (which is before '\\' or '\0'
+                    //
+                    // So `string_bytes` is well-formed UTF-8.
+                    string_bytes = .{ .borrowed = this.sliceFrom(start_pos) };
+                    break;
+                },
+                '\n', '\r', FORM_FEED_BYTE => return .{ .str = this.sliceFrom(start_pos), .bad = true },
+                0x80...0xBF => this.consumeContinuationByte(),
+                0xF0...0xFF => this.consume4byteIntro(),
+                else => {
+                    this.advance(1);
+                },
+            }
+        }
+
+        while (!this.isEof()) {
+            const b = this.nextByteUnchecked();
+            // todo_stuff.match_byte
+            switch (b) {
+                // string_bytes is well-formed UTF-8, see other comments
+                '\n', '\r', FORM_FEED_BYTE => return .{ .str = string_bytes.toSlice(), .bad = true },
+                '"' => {
+                    this.advance(1);
+                    if (!single_quote) break;
+                },
+                '\'' => {
+                    this.advance(1);
+                    if (single_quote) break;
+                },
+                '\\' => {
+                    this.advance(1);
+                    if (!this.isEof()) {
+                        switch (this.nextByteUnchecked()) {
+                            // Escaped newline
+                            '\n', FORM_FEED_BYTE, '\r' => this.consumeNewline(),
+                            else => this.consumeEscapeAndWrite(&string_bytes),
+                        }
+                    }
+                    // else: escaped EOF, do nothing.
+                    // continue;
+                },
+                0 => {
+                    this.advance(1);
+                    string_bytes.append(this.allocator, REPLACEMENT_CHAR_UNICODE[0..]);
+                    continue;
+                },
+                0x80...0xBF => this.consumeContinuationByte(),
+                0xF0...0xFF => this.consume4byteIntro(),
+                else => {
+                    this.advance(1);
+                },
+            }
+
+            string_bytes.append(this.allocator, &[_]u8{b});
+        }
+
+        return .{ .str = string_bytes.toSlice() };
+    }
+
+    pub fn consumeUnquotedUrl(this: *Tokenizer) ?Token {
+        // This is only called after "url(", so the current position is a code point boundary.
+        const start_position = this.position;
+        const from_start = this.src[this.position..];
+        var newlines: u32 = 0;
+        var last_newline: usize = 0;
+        var found_printable_char = false;
+
+        var offset: usize = 0;
+        var b: u8 = undefined;
+        while (true) {
+            defer offset += 1;
+
+            if (offset < from_start.len) {
+                b = from_start[offset];
+            } else {
+                this.position = this.src.len;
+                break;
+            }
+
+            // todo_stuff.match_byte
+            switch (b) {
+                ' ', '\t' => {},
+                '\n', FORM_FEED_BYTE => {
+                    newlines += 1;
+                    last_newline = offset;
+                },
+                '\r' => {
+                    if (offset + 1 < from_start.len and from_start[offset + 1] != '\n') {
+                        newlines += 1;
+                        last_newline = offset;
+                    }
+                },
+                '"', '\'' => return null, // Do not advance
+                ')' => {
+                    // Don't use advance, because we may be skipping
+                    // newlines here, and we want to avoid the assert.
+                    this.position += offset + 1;
+                    break;
+                },
+                else => {
+                    // Don't use advance, because we may be skipping
+                    // newlines here, and we want to avoid the assert.
+                    this.position += offset;
+                    found_printable_char = true;
+                    break;
+                },
+            }
+        }
+
+        if (newlines > 0) {
+            this.current_line_number += newlines;
+            // No need for wrapping_add here, because there's no possible
+            // way to wrap.
+            this.current_line_start_position = start_position + last_newline + 1;
+        }
+
+        if (found_printable_char) {
+            // This function only consumed ASCII (whitespace) bytes,
+            // so the current position is a code point boundary.
+            return this.consumeUnquotedUrlInternal();
+        }
+        return .{ .unquoted_url = "" };
+    }
+
+    pub fn consumeUnquotedUrlInternal(this: *Tokenizer) Token {
+        // This function is only called with start_pos at a code point boundary.;
+        const start_pos = this.position;
+        var string_bytes: CopyOnWriteStr = undefined;
+
+        while (true) {
+            if (this.isEof()) return .{ .unquoted_url = this.sliceFrom(start_pos) };
+
+            // todo_stuff.match_byte
+            switch (this.nextByteUnchecked()) {
+                ' ', '\t', '\n', '\r', FORM_FEED_BYTE => {
+                    var value = .{ .borrowed = this.sliceFrom(start_pos) };
+                    return this.consumeUrlEnd(start_pos, &value);
+                },
+                ')' => {
+                    const value = this.sliceFrom(start_pos);
+                    this.advance(1);
+                    return .{ .unquoted_url = value };
+                },
+                // non-printable
+                0x01...0x08,
+                0x0B,
+                0x0E...0x1F,
+                0x7F,
+
+                // not valid in this context
+                '"',
+                '\'',
+                '(',
+                => {
+                    this.advance(1);
+                    return this.consumeBadUrl(start_pos);
+                },
+                '\\', 0 => {
+                    // * The tokenizer’s input is UTF-8 since it’s `&str`.
+                    // * start_pos is at a code point boundary
+                    // * so is the current position (which is before '\\' or '\0'
+                    //
+                    // So `string_bytes` is well-formed UTF-8.
+                    string_bytes = .{ .borrowed = this.sliceFrom(start_pos) };
+                    break;
+                },
+                0x80...0xBF => this.consumeContinuationByte(),
+                0xF0...0xFF => this.consume4byteIntro(),
+                else => {
+                    // ASCII or other leading byte.
+                    this.advance(1);
+                },
+            }
+        }
+
+        while (!this.isEof()) {
+            const b = this.nextByteUnchecked();
+            // todo_stuff.match_byte
+            switch (b) {
+                ' ', '\t', '\n', '\r', FORM_FEED_BYTE => {
+                    // string_bytes is well-formed UTF-8, see other comments.
+                    // const string = string_bytes.toSlice();
+                    // return this.consumeUrlEnd(start_pos, &string);
+                    return this.consumeUrlEnd(start_pos, &string_bytes);
+                },
+                ')' => {
+                    this.advance(1);
+                    break;
+                },
+                // non-printable
+                0x01...0x08,
+                0x0B,
+                0x0E...0x1F,
+                0x7F,
+
+                // invalid in this context
+                '"',
+                '\'',
+                '(',
+                => {
+                    this.advance(1);
+                    return this.consumeBadUrl(start_pos);
+                },
+                '\\' => {
+                    this.advance(1);
+                    if (this.hasNewlineAt(0)) return this.consumeBadUrl(start_pos);
+
+                    // This pushes one well-formed code point to string_bytes
+                    this.consumeEscapeAndWrite(&string_bytes);
+                },
+                0 => {
+                    this.advance(1);
+                    string_bytes.append(this.allocator, REPLACEMENT_CHAR_UNICODE[0..]);
+                },
+                0x80...0xBF => {
+                    // We’ll end up copying the whole code point
+                    // before this loop does something else.
+                    this.consumeContinuationByte();
+                    string_bytes.append(this.allocator, &[_]u8{b});
+                },
+                0xF0...0xFF => {
+                    // We’ll end up copying the whole code point
+                    // before this loop does something else.
+                    this.consume4byteIntro();
+                    string_bytes.append(this.allocator, &[_]u8{b});
+                },
+                // If this byte is part of a multi-byte code point,
+                // we’ll end up copying the whole code point before this loop does something else.
+                else => {
+                    // ASCII or other leading byte.
+                    this.advance(1);
+                    string_bytes.append(this.allocator, &[_]u8{b});
+                },
+            }
+        }
+
+        // string_bytes is well-formed UTF-8, see other comments.
+        return .{ .unquoted_url = string_bytes.toSlice() };
+    }
+
+    pub fn consumeUrlEnd(this: *Tokenizer, start_pos: usize, string: *CopyOnWriteStr) Token {
+        while (!this.isEof()) {
+            // todo_stuff.match_byte
+            switch (this.nextByteUnchecked()) {
+                ')' => {
+                    this.advance(1);
+                    break;
+                },
+                ' ', '\t' => this.advance(1),
+                '\n', FORM_FEED_BYTE, '\r' => this.consumeNewline(),
+                else => |b| {
+                    this.consumeKnownByte(b);
+                    return this.consumeBadUrl(start_pos);
+                },
+            }
+        }
+
+        return .{ .unquoted_url = string.toSlice() };
+    }
+
+    pub fn consumeBadUrl(this: *Tokenizer, start_pos: usize) Token {
+        // Consume up to the closing )
+        while (!this.isEof()) {
+            // todo_stuff.match_byte
+            switch (this.nextByteUnchecked()) {
+                ')' => {
+                    const contents = this.sliceFrom(start_pos);
+                    this.advance(1);
+                    return .{ .bad_url = contents };
+                },
+                '\\' => {
+                    this.advance(1);
+                    if (this.nextByte()) |b| {
+                        if (b == ')' or b == '\\') this.advance(1); // Skip an escaped ')' or '\'
+                    }
+                },
+                '\n', FORM_FEED_BYTE, '\r' => this.consumeNewline(),
+                else => |b| this.consumeKnownByte(b),
+            }
+        }
+        return .{ .bad_url = this.sliceFrom(start_pos) };
+    }
+
+    pub fn consumeEscapeAndWrite(this: *Tokenizer, bytes: *CopyOnWriteStr) void {
+        const val = this.consumeEscape();
+        var utf8bytes: [4]u8 = undefined;
+        const len = std.unicode.utf8Encode(@truncate(val), utf8bytes[0..]) catch @panic("Invalid");
+        bytes.append(this.allocator, utf8bytes[0..len]);
+    }
+
+    pub fn consumeEscape(this: *Tokenizer) u32 {
+        if (this.isEof()) return 0xFFFD; // Unicode replacement character
+
+        // todo_stuff.match_byte
+        switch (this.nextByteUnchecked()) {
+            '0'...'9', 'A'...'F', 'a'...'f' => {
+                const c = this.consumeHexDigits().value;
+                if (!this.isEof()) {
+                    // todo_stuff.match_byte
+                    switch (this.nextByteUnchecked()) {
+                        ' ', '\t' => this.advance(1),
+                        '\n', FORM_FEED_BYTE, '\r' => this.consumeNewline(),
+                        else => {},
+                    }
+                }
+
+                if (c != 0 and std.unicode.utf8ValidCodepoint(@truncate(c))) return c;
+                return REPLACEMENT_CHAR;
+            },
+            0 => {
+                this.advance(1);
+                return REPLACEMENT_CHAR;
+            },
+            else => return this.consumeChar(),
+        }
+    }
+
+    pub fn consumeHexDigits(this: *Tokenizer) struct { value: u32, num_digits: u32 } {
+        var value: u32 = 0;
+        var digits: u32 = 0;
+        while (digits < 6 and !this.isEof()) {
+            if (byteToHexDigit(this.nextByteUnchecked())) |digit| {
+                value = value * 16 + digit;
+                digits += 1;
+                this.advance(1);
+            } else break;
+        }
+
+        return .{ .value = value, .num_digits = digits };
+    }
+
+    pub fn consumeChar(this: *Tokenizer) u32 {
+        const c = this.nextChar();
+        const len_utf8 = lenUtf8(c);
+        this.position += len_utf8;
+        // Note that due to the special case for the 4-byte sequence
+        // intro, we must use wrapping add here.
+        this.current_line_start_position +%= len_utf8 - lenUtf16(c);
+        return c;
+    }
+
+    fn lenUtf8(code: u32) usize {
+        if (code < MAX_ONE_B) {
+            return 1;
+        } else if (code < MAX_TWO_B) {
+            return 2;
+        } else if (code < MAX_THREE_B) {
+            return 3;
+        } else {
+            return 4;
+        }
+    }
+
+    fn lenUtf16(ch: u32) usize {
+        if ((ch & 0xFFFF) == ch) {
+            return 1;
+        } else {
+            return 2;
+        }
+    }
+
+    fn byteToHexDigit(b: u8) ?u32 {
+
+        // todo_stuff.match_byte
+        return switch (b) {
+            '0'...'9' => b - '0',
+            'a'...'f' => b - 'a' + 10,
+            'A'...'F' => b - 'A' + 10,
+            else => null,
+        };
+    }
+
+    fn byteToDecimalDigit(b: u8) ?u32 {
+        if (b >= '0' and b <= '9') {
+            return b - '0';
+        }
+        return null;
+    }
+
+    pub fn consumeComment(this: *Tokenizer) []const u8 {
+        this.advance(2);
+        const start_position = this.position;
+        while (!this.isEof()) {
+            const b = this.nextByteUnchecked();
+            // todo_stuff.match_byte
+            switch (b) {
+                '*' => {
+                    const end_position = this.position;
+                    this.advance(1);
+                    if (this.nextByte() == '/') {
+                        this.advance(1);
+                        const contents = this.src[start_position..end_position];
+                        this.checkForSourceMap(contents);
+                        return contents;
+                    }
+                },
+                '\n', FORM_FEED_BYTE, '\r' => {
+                    this.consumeNewline();
+                },
+                0x80...0xBF => this.consumeContinuationByte(),
+                0xF0...0xFF => this.consume4byteIntro(),
+                else => {
+                    // ASCII or other leading byte
+                    this.advance(1);
+                },
+            }
+        }
+        const contents = this.sliceFrom(start_position);
+        this.checkForSourceMap(contents);
+        return contents;
+    }
+
+    pub fn checkForSourceMap(this: *Tokenizer, contents: []const u8) void {
+        {
+            const directive = "# sourceMappingURL=";
+            const directive_old = "@ sourceMappingURL=";
+            if (std.mem.startsWith(u8, contents, directive) or std.mem.startsWith(u8, contents, directive_old)) {
+                this.source_map_url = splitSourceMap(contents[directive.len..]);
+            }
+        }
+
+        {
+            const directive = "# sourceURL=";
+            const directive_old = "@ sourceURL=";
+            if (std.mem.startsWith(u8, contents, directive) or std.mem.startsWith(u8, contents, directive_old)) {
+                this.source_map_url = splitSourceMap(contents[directive.len..]);
+            }
+        }
+    }
+
+    pub fn splitSourceMap(contents: []const u8) ?[]const u8 {
+        // FIXME: Use bun CodepointIterator
+        var iter = std.unicode.Utf8Iterator{ .bytes = contents, .i = 0 };
+        while (iter.nextCodepoint()) |c| {
+            switch (c) {
+                ' ', '\t', FORM_FEED_BYTE, '\r', '\n' => {
+                    const start = 0;
+                    const end = iter.i;
+                    return contents[start..end];
+                },
+                else => {},
+            }
+        }
+        return null;
+    }
+
+    pub fn consumeNewline(this: *Tokenizer) void {
+        const byte = this.nextByteUnchecked();
+        if (bun.Environment.allow_assert) {
+            std.debug.assert(byte == '\r' or byte == '\n' or byte == FORM_FEED_BYTE);
+        }
+        this.position += 1;
+        if (byte == '\r' and this.nextByte() == '\n') {
+            this.position += 1;
+        }
+        this.current_line_start_position = this.position;
+        this.current_line_number += 1;
+    }
+
+    /// Advance over a single byte; the byte must be a UTF-8
+    /// continuation byte.
+    ///
+    /// Binary    Hex          Comments
+    /// 0xxxxxxx  0x00..0x7F   Only byte of a 1-byte character encoding
+    /// 110xxxxx  0xC0..0xDF   First byte of a 2-byte character encoding
+    /// 1110xxxx  0xE0..0xEF   First byte of a 3-byte character encoding
+    /// 11110xxx  0xF0..0xF7   First byte of a 4-byte character encoding
+    /// 10xxxxxx  0x80..0xBF   Continuation byte: one of 1-3 bytes following the first <--
+    pub fn consumeContinuationByte(this: *Tokenizer) void {
+        if (bun.Environment.allow_assert) std.debug.assert(this.nextByteUnchecked() & 0xC0 == 0x80);
+        // Continuation bytes contribute to column overcount. Note
+        // that due to the special case for the 4-byte sequence intro,
+        // we must use wrapping add here.
+        this.current_line_start_position +%= 1;
+        this.position += 1;
+    }
+
+    /// Advance over a single byte; the byte must be a UTF-8 sequence
+    /// leader for a 4-byte sequence.
+    ///
+    /// Binary    Hex          Comments
+    /// 0xxxxxxx  0x00..0x7F   Only byte of a 1-byte character encoding
+    /// 110xxxxx  0xC0..0xDF   First byte of a 2-byte character encoding
+    /// 1110xxxx  0xE0..0xEF   First byte of a 3-byte character encoding
+    /// 11110xxx  0xF0..0xF7   First byte of a 4-byte character encoding <--
+    /// 10xxxxxx  0x80..0xBF   Continuation byte: one of 1-3 bytes following the first
+    pub fn consume4byteIntro(this: *Tokenizer) void {
+        if (bun.Environment.allow_assert) std.debug.assert(this.nextByteUnchecked() & 0xF0 == 0xF0);
+        // This takes two UTF-16 characters to represent, so we
+        // actually have an undercount.
+        // this.current_line_start_position = self.current_line_start_position.wrapping_sub(1);
+        this.current_line_start_position -%= 1;
+        this.position += 1;
+    }
+
+    pub fn isIdentStart(this: *Tokenizer) bool {
+
+        // todo_stuff.match_byte
+        return !this.isEof() and switch (this.nextByteUnchecked()) {
+            'a'...'z', 'A'...'Z', '_', 0 => true,
+
+            // todo_stuff.match_byte
+            '-' => this.hasAtLeast(1) and switch (this.byteAt(1)) {
+                'a'...'z', 'A'...'Z', '-', '_', 0 => true,
+                '\\' => !this.hasNewlineAt(1),
+                else => |b| !std.ascii.isASCII(b),
+            },
+            '\\' => !this.hasNewlineAt(1),
+            else => |b| !std.ascii.isASCII(b),
+        };
+    }
+
+    /// If true, the input has at least `n` bytes left *after* the current one.
+    /// That is, `tokenizer.char_at(n)` will not panic.
+    fn hasAtLeast(this: *Tokenizer, n: usize) bool {
+        return this.position + n < this.src.len;
+    }
+
+    fn hasNewlineAt(this: *Tokenizer, offset: usize) bool {
+        return this.position + offset < this.src.len and switch (this.byteAt(offset)) {
+            '\n', '\r', FORM_FEED_BYTE => true,
+            else => false,
+        };
+    }
+
+    pub fn startsWith(this: *Tokenizer, comptime needle: []const u8) bool {
+        return bun.strings.hasPrefixComptime(this.src[this.position..], needle);
+    }
+
+    /// Advance over N bytes in the input.  This function can advance
+    /// over ASCII bytes (excluding newlines), or UTF-8 sequence
+    /// leaders (excluding leaders for 4-byte sequences).
+    pub fn advance(this: *Tokenizer, n: usize) void {
+        if (bun.Environment.allow_assert) {
+            // Each byte must either be an ASCII byte or a sequence
+            // leader, but not a 4-byte leader; also newlines are
+            // rejected.
+            for (0..n) |i| {
+                const b = this.byteAt(i);
+                std.debug.assert(std.ascii.isASCII(b) or (b & 0xF0 != 0xF0 and b & 0xC0 != 0x80));
+                std.debug.assert(b != '\r' and b != '\n' and b != '\x0C');
+            }
+        }
+        this.position += n;
+    }
+
+    /// Advance over any kind of byte, excluding newlines.
+    pub fn consumeKnownByte(this: *Tokenizer, byte: u8) void {
+        if (bun.Environment.allow_assert) std.debug.assert(byte != '\r' and byte != '\n' and byte != FORM_FEED_BYTE);
+        this.position += 1;
+        // Continuation bytes contribute to column overcount.
+        if (byte & 0xF0 == 0xF0) {
+            // This takes two UTF-16 characters to represent, so we
+            // actually have an undercount.
+            this.current_line_start_position -%= 1;
+        } else if (byte & 0xC0 == 0x80) {
+            // Note that due to the special case for the 4-byte
+            // sequence intro, we must use wrapping add here.
+            this.current_line_start_position +%= 1;
+        }
+    }
+
+    pub inline fn byteAt(this: *Tokenizer, n: usize) u8 {
+        return this.src[this.position + n];
+    }
+
+    pub inline fn nextByte(this: *Tokenizer) ?u8 {
+        if (this.isEof()) return null;
+        return this.src[this.position];
+    }
+
+    pub inline fn nextChar(this: *Tokenizer) u32 {
+        const len = bun.strings.utf8ByteSequenceLength(this.src[this.position]);
+        return bun.strings.decodeWTF8RuneT(this.src[this.position..].ptr[0..4], len, u32, bun.strings.unicode_replacement);
+    }
+
+    pub inline fn nextByteUnchecked(this: *Tokenizer) u8 {
+        return this.src[this.position];
+    }
+
+    pub inline fn sliceFrom(this: *Tokenizer, start: usize) []const u8 {
+        return this.src[start..this.position];
+    }
+};
+
+const TokenKind = enum {
+    /// An [<ident-token>](https://drafts.csswg.org/css-syntax/#typedef-ident-token)
+    ident,
+
+    /// Value is the ident
+    function,
+
+    /// Value is the ident
+    at_keyword,
+
+    /// A [`<hash-token>`](https://drafts.csswg.org/css-syntax/#hash-token-diagram) with the type flag set to "unrestricted"
+    ///
+    /// The value does not include the `#` marker.
+    hash,
+
+    /// A [`<hash-token>`](https://drafts.csswg.org/css-syntax/#hash-token-diagram) with the type flag set to "id"
+    ///
+    /// The value does not include the `#` marker.
+    idhash,
+
+    quoted_string,
+
+    bad_string,
+
+    /// `url(<string-token>)` is represented by a `.function` token
+    unquoted_url,
+
+    bad_url,
+
+    /// Value of a single codepoint
+    delim,
+
+    /// A <number-token> can be fractional or an integer, and can contain an optional + or - sign
+    number,
+
+    percentage,
+
+    dimension,
+
+    whitespace,
+
+    /// `<!---`
+    cdo,
+
+    /// `-->`
+    cdc,
+
+    /// `~=` (https://www.w3.org/TR/selectors-4/#attribute-representation)
+    include_match,
+
+    /// `|=` (https://www.w3.org/TR/selectors-4/#attribute-representation)
+    dash_match,
+
+    /// `^=` (https://www.w3.org/TR/selectors-4/#attribute-substrings)
+    prefix_match,
+
+    /// `$=`(https://www.w3.org/TR/selectors-4/#attribute-substrings)
+    suffix_match,
+
+    /// `*=` (https://www.w3.org/TR/selectors-4/#attribute-substrings)
+    substring_match,
+
+    colon,
+    semicolon,
+    comma,
+    open_square,
+    close_square,
+    open_paren,
+    close_paren,
+    open_curly,
+    close_curly,
+
+    /// Not an actual token in the spec, but we keep it anyway
+    comment,
+
+    pub fn toString(this: TokenKind) []const u8 {
+        return switch (this) {
+            .at_keyword => "@-keyword",
+            .bad_string => "bad string token",
+            .bad_url => "bad URL token",
+            .cdc => "\"-->\"",
+            .cdo => "\"<!--\"",
+            .close_curly => "\"}\"",
+            .close_bracket => "\"]\"",
+            .close_paren => "\")\"",
+            .colon => "\":\"",
+            .comma => "\",\"",
+            // TODO esbuild has additional delimiter tokens (e.g. TDelimAmpersand), should we?
+            .delim => |c| switch (c) {
+                '&' => "\"&\"",
+                '*' => "\"*\"",
+                '|' => "\"|\"",
+                '^' => "\"^\"",
+                '$' => "\"$\"",
+                '.' => "\".\"",
+                '=' => "\"=\"",
+                '!' => "\"!\"",
+                '>' => "\">\"",
+                '-' => "\"-\"",
+                '+' => "\"+\"",
+                '/' => "\"/\"",
+                '~' => "\"~\"",
+                else => "delimiter",
+            },
+            .dimension => "dimension",
+            .function => "function token",
+            .hash => "hash token",
+            .ident => "identifier",
+            .number => "number",
+            .open_curly => "\"{\"",
+            .open_square => "\"[\"",
+            .open_paren => "\"(\"",
+            .percentage => "percentage",
+            .semicolon => "\";\"",
+            .string => "string token",
+            .unquoted_url => "URL token",
+            .whitespace => "whitespace",
+            // TODO: esbuild does this, should we?
+            // .TSymbol => "identifier",
+        };
+    }
+};
+
+// TODO: make strings be allocated in string pool
+pub const Token = union(TokenKind) {
+    /// An [<ident-token>](https://drafts.csswg.org/css-syntax/#typedef-ident-token)
+    ident: []const u8,
+
+    /// Value is the ident
+    function: []const u8,
+
+    /// Value is the ident
+    at_keyword: []const u8,
+
+    /// A [`<hash-token>`](https://drafts.csswg.org/css-syntax/#hash-token-diagram) with the type flag set to "unrestricted"
+    ///
+    /// The value does not include the `#` marker.
+    hash: []const u8,
+
+    /// A [`<hash-token>`](https://drafts.csswg.org/css-syntax/#hash-token-diagram) with the type flag set to "id"
+    ///
+    /// The value does not include the `#` marker.
+    idhash: []const u8,
+
+    /// A [`<string-token>`](https://drafts.csswg.org/css-syntax/#string-token-diagram)
+    ///
+    /// The value does not include the quotes.
+    quoted_string: []const u8,
+
+    bad_string: []const u8,
+
+    /// `url(<string-token>)` is represented by a `.function` token
+    unquoted_url: []const u8,
+
+    bad_url: []const u8,
+
+    /// A `<delim-token>`
+    /// Value of a single codepoint
+    ///
+    /// NOTE/PERF: the css spec says this should be the value of a single codepoint, meaning it needs to 4 bytes long
+    /// but in practice, and in this code, we only ever return ascii bytes
+    delim: u32,
+
+    /// A <number-token> can be fractional or an integer, and can contain an optional + or - sign
+    number: Num,
+
+    percentage: struct {
+        has_sign: bool,
+        unit_value: f32,
+        int_value: ?i32,
+
+        pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+            return implementEql(@This(), lhs, rhs);
+        }
+
+        pub fn __generateHash() void {}
+    },
+
+    dimension: Dimension,
+
+    /// [<unicode-range-token>](https://drafts.csswg.org/css-syntax/#typedef-unicode-range-token)
+    /// FIXME: this is not complete
+    // unicode_range: struct {
+    //     start: u32,
+    //     end: ?u32,
+    // },
+
+    whitespace: []const u8,
+
+    /// `<!---`
+    cdo,
+
+    /// `-->`
+    cdc,
+
+    /// `~=` (https://www.w3.org/TR/selectors-4/#attribute-representation)
+    include_match,
+
+    /// `|=` (https://www.w3.org/TR/selectors-4/#attribute-representation)
+    dash_match,
+
+    /// `^=` (https://www.w3.org/TR/selectors-4/#attribute-substrings)
+    prefix_match,
+
+    /// `$=`(https://www.w3.org/TR/selectors-4/#attribute-substrings)
+    suffix_match,
+
+    /// `*=` (https://www.w3.org/TR/selectors-4/#attribute-substrings)
+    substring_match,
+
+    colon,
+    semicolon,
+    comma,
+    open_square,
+    close_square,
+    open_paren,
+    close_paren,
+    open_curly,
+    close_curly,
+
+    /// Not an actual token in the spec, but we keep it anyway
+    comment: []const u8,
+
+    pub fn eql(lhs: *const Token, rhs: *const Token) bool {
+        return implementEql(Token, lhs, rhs);
+    }
+
+    pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+        return implementHash(@This(), this, hasher);
+    }
+
+    /// Return whether this token represents a parse error.
+    ///
+    /// `BadUrl` and `BadString` are tokenizer-level parse errors.
+    ///
+    /// `CloseParenthesis`, `CloseSquareBracket`, and `CloseCurlyBracket` are *unmatched*
+    /// and therefore parse errors when returned by one of the `Parser::next*` methods.
+    pub fn isParseError(this: *const Token) bool {
+        return switch (this.*) {
+            .bad_url, .bad_string, .close_paren, .close_square, .close_curly => true,
+            else => false,
+        };
+    }
+
+    pub fn format(
+        this: *const Token,
+        comptime fmt: []const u8,
+        opts: std.fmt.FormatOptions,
+        writer: anytype,
+    ) !void {
+        _ = fmt; // autofix
+        _ = opts; // autofix
+        return switch (this.*) {
+            inline .ident,
+            .function,
+            .at_keyword,
+            .hash,
+            .idhash,
+            .quoted_string,
+            .bad_string,
+            .unquoted_url,
+            .bad_url,
+            .whitespace,
+            .comment,
+            => |str| {
+                try writer.print("{s} = {s}", .{ @tagName(this.*), str });
+            },
+            .delim => |d| {
+                try writer.print("'{c}'", .{@as(u8, @truncate(d))});
+            },
+            else => {
+                try writer.print("{s}", .{@tagName(this.*)});
+            },
+        };
+    }
+
+    pub fn raw(this: Token) []const u8 {
+        return switch (this) {
+            .ident => this.ident,
+            // .function =>
+        };
+    }
+
+    pub inline fn kind(this: Token) TokenKind {
+        return @as(TokenKind, this);
+    }
+
+    pub inline fn kindString(this: Token) []const u8 {
+        return this.kind.toString();
+    }
+
+    // ~toCssImpl
+    const This = @This();
+
+    pub fn toCssGeneric(this: *const This, writer: anytype) !void {
+        return switch (this.*) {
+            .ident => {
+                try serializer.serializeIdentifier(this.ident, writer);
+            },
+            .at_keyword => {
+                try writer.writeAll("@");
+                try serializer.serializeIdentifier(this.at_keyword, writer);
+            },
+            .hash => {
+                try writer.writeAll("#");
+                try serializer.serializeName(this.hash, writer);
+            },
+            .idhash => {
+                try writer.writeAll("#");
+                try serializer.serializeName(this.idhash, writer);
+            },
+            .quoted_string => |x| {
+                try serializer.serializeName(x, writer);
+            },
+            .unquoted_url => |x| {
+                try writer.writeAll("url(");
+                try serializer.serializeUnquotedUrl(x, writer);
+                try writer.writeAll(")");
+            },
+            .delim => |x| {
+                bun.assert(x <= 0x7F);
+                try writer.writeByte(@intCast(x));
+            },
+            .number => |n| {
+                try serializer.writeNumeric(n.value, n.int_value, n.has_sign, writer);
+            },
+            .percentage => |p| {
+                try serializer.writeNumeric(p.unit_value * 100.0, p.int_value, p.has_sign, writer);
+            },
+            .dimension => |d| {
+                try serializer.writeNumeric(d.num.value, d.num.int_value, d.num.has_sign, writer);
+                // Disambiguate with scientific notation.
+                const unit = d.unit;
+                // TODO(emilio): This doesn't handle e.g. 100E1m, which gets us
+                // an unit of "E1m"...
+                if ((unit.len == 1 and unit[0] == 'e') or
+                    (unit.len == 1 and unit[0] == 'E') or
+                    bun.strings.startsWith(unit, "e-") or
+                    bun.strings.startsWith(unit, "E-"))
+                {
+                    try writer.writeAll("\\65 ");
+                    try serializer.serializeName(unit[1..], writer);
+                } else {
+                    try serializer.serializeIdentifier(unit, writer);
+                }
+            },
+            .whitespace => |content| {
+                try writer.writeAll(content);
+            },
+            .comment => |content| {
+                try writer.writeAll("/*");
+                try writer.writeAll(content);
+                try writer.writeAll("*/");
+            },
+            .colon => try writer.writeAll(":"),
+            .semicolon => try writer.writeAll(";"),
+            .comma => try writer.writeAll(","),
+            .include_match => try writer.writeAll("~="),
+            .dash_match => try writer.writeAll("|="),
+            .prefix_match => try writer.writeAll("^="),
+            .suffix_match => try writer.writeAll("$="),
+            .substring_match => try writer.writeAll("*="),
+            .cdo => try writer.writeAll("<!--"),
+            .cdc => try writer.writeAll("-->"),
+
+            .function => |name| {
+                try serializer.serializeIdentifier(name, writer);
+                try writer.writeAll("(");
+            },
+            .open_paren => try writer.writeAll("("),
+            .open_square => try writer.writeAll("["),
+            .open_curly => try writer.writeAll("{"),
+
+            .bad_url => |contents| {
+                try writer.writeAll("url(");
+                try writer.writeAll(contents);
+                try writer.writeByte(')');
+            },
+            .bad_string => |value| {
+                // During tokenization, an unescaped newline after a quote causes
+                // the token to be a BadString instead of a QuotedString.
+                // The BadString token ends just before the newline
+                // (which is in a separate WhiteSpace token),
+                // and therefore does not have a closing quote.
+                try writer.writeByte('"');
+                var string_writer = serializer.CssStringWriter(@TypeOf(writer)).new(writer);
+                try string_writer.writeStr(value);
+            },
+            .close_paren => try writer.writeAll(")"),
+            .close_square => try writer.writeAll("]"),
+            .close_curly => try writer.writeAll("}"),
+        };
+    }
+
+    pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        // zack is here: verify this is correct
+        return switch (this.*) {
+            .ident => |value| serializer.serializeIdentifier(value, dest) catch return dest.addFmtError(),
+            .at_keyword => |value| {
+                try dest.writeStr("@");
+                return serializer.serializeIdentifier(value, dest) catch return dest.addFmtError();
+            },
+            .hash => |value| {
+                try dest.writeStr("#");
+                return serializer.serializeName(value, dest) catch return dest.addFmtError();
+            },
+            .idhash => |value| {
+                try dest.writeStr("#");
+                return serializer.serializeIdentifier(value, dest) catch return dest.addFmtError();
+            },
+            .quoted_string => |value| serializer.serializeString(value, dest) catch return dest.addFmtError(),
+            .unquoted_url => |value| {
+                try dest.writeStr("url(");
+                serializer.serializeUnquotedUrl(value, dest) catch return dest.addFmtError();
+                return dest.writeStr(")");
+            },
+            .delim => |value| {
+                // See comment for this variant in declaration of Token
+                // The value of delim is only ever ascii
+                bun.debugAssert(value <= 0x7F);
+                return dest.writeChar(@truncate(value));
+            },
+            .number => |num| serializer.writeNumeric(num.value, num.int_value, num.has_sign, dest) catch return dest.addFmtError(),
+            .percentage => |num| {
+                serializer.writeNumeric(num.unit_value * 100, num.int_value, num.has_sign, dest) catch return dest.addFmtError();
+                return dest.writeStr("%");
+            },
+            .dimension => |dim| {
+                serializer.writeNumeric(dim.num.value, dim.num.int_value, dim.num.has_sign, dest) catch return dest.addFmtError();
+                // Disambiguate with scientific notation.
+                const unit = dim.unit;
+                if (std.mem.eql(u8, unit, "e") or std.mem.eql(u8, unit, "E") or
+                    std.mem.startsWith(u8, unit, "e-") or std.mem.startsWith(u8, unit, "E-"))
+                {
+                    try dest.writeStr("\\65 ");
+                    serializer.serializeName(unit[1..], dest) catch return dest.addFmtError();
+                } else {
+                    serializer.serializeIdentifier(unit, dest) catch return dest.addFmtError();
+                }
+                return;
+            },
+            .whitespace => |content| dest.writeStr(content),
+            .comment => |content| {
+                try dest.writeStr("/*");
+                try dest.writeStr(content);
+                return dest.writeStr("*/");
+            },
+            .colon => dest.writeStr(":"),
+            .semicolon => dest.writeStr(";"),
+            .comma => dest.writeStr(","),
+            .include_match => dest.writeStr("~="),
+            .dash_match => dest.writeStr("|="),
+            .prefix_match => dest.writeStr("^="),
+            .suffix_match => dest.writeStr("$="),
+            .substring_match => dest.writeStr("*="),
+            .cdo => dest.writeStr("<!--"),
+            .cdc => dest.writeStr("-->"),
+            .function => |name| {
+                serializer.serializeIdentifier(name, dest) catch return dest.addFmtError();
+                return dest.writeStr("(");
+            },
+            .open_paren => dest.writeStr("("),
+            .open_square => dest.writeStr("["),
+            .open_curly => dest.writeStr("{"),
+            .bad_url => |contents| {
+                try dest.writeStr("url(");
+                try dest.writeStr(contents);
+                return dest.writeChar(')');
+            },
+            .bad_string => |value| {
+                try dest.writeChar('"');
+                var writer = serializer.CssStringWriter(*Printer(W)).new(dest);
+                return writer.writeStr(value) catch return dest.addFmtError();
+            },
+            .close_paren => dest.writeStr(")"),
+            .close_square => dest.writeStr("]"),
+            .close_curly => dest.writeStr("}"),
+        };
+    }
+};
+
+const Num = struct {
+    has_sign: bool,
+    value: f32,
+    int_value: ?i32,
+
+    pub fn eql(lhs: *const Num, rhs: *const Num) bool {
+        return implementEql(Num, lhs, rhs);
+    }
+
+    pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+        return implementHash(@This(), this, hasher);
+    }
+};
+
+const Dimension = struct {
+    num: Num,
+    /// e.g. "px"
+    unit: []const u8,
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+        return implementHash(@This(), this, hasher);
+    }
+};
+
+const CopyOnWriteStr = union(enum) {
+    borrowed: []const u8,
+    owned: std.ArrayList(u8),
+
+    pub fn append(this: *@This(), allocator: Allocator, slice: []const u8) void {
+        switch (this.*) {
+            .borrowed => {
+                var list = std.ArrayList(u8).initCapacity(allocator, this.borrowed.len + slice.len) catch bun.outOfMemory();
+                list.appendSliceAssumeCapacity(this.borrowed);
+                list.appendSliceAssumeCapacity(slice);
+                this.* = .{ .owned = list };
+            },
+            .owned => {
+                this.owned.appendSlice(slice) catch bun.outOfMemory();
+            },
+        }
+    }
+
+    pub fn toSlice(this: *@This()) []const u8 {
+        return switch (this.*) {
+            .borrowed => this.borrowed,
+            .owned => this.owned.items[0..],
+        };
+    }
+};
+
+pub const color = struct {
+    /// The opaque alpha value of 1.0.
+    pub const OPAQUE: f32 = 1.0;
+
+    const ColorError = error{
+        parse,
+    };
+
+    /// Either an angle or a number.
+    pub const AngleOrNumber = union(enum) {
+        /// `<number>`.
+        number: struct {
+            /// The numeric value parsed, as a float.
+            value: f32,
+        },
+        /// `<angle>`
+        angle: struct {
+            /// The value as a number of degrees.
+            degrees: f32,
+        },
+    };
+
+    const RGB = struct { u8, u8, u8 };
+    pub const named_colors = bun.ComptimeStringMap(RGB, .{
+        .{ "aliceblue", .{ 240, 248, 255 } },
+        .{ "antiquewhite", .{ 250, 235, 215 } },
+        .{ "aqua", .{ 0, 255, 255 } },
+        .{ "aquamarine", .{ 127, 255, 212 } },
+        .{ "azure", .{ 240, 255, 255 } },
+        .{ "beige", .{ 245, 245, 220 } },
+        .{ "bisque", .{ 255, 228, 196 } },
+        .{ "black", .{ 0, 0, 0 } },
+        .{ "blanchedalmond", .{ 255, 235, 205 } },
+        .{ "blue", .{ 0, 0, 255 } },
+        .{ "blueviolet", .{ 138, 43, 226 } },
+        .{ "brown", .{ 165, 42, 42 } },
+        .{ "burlywood", .{ 222, 184, 135 } },
+        .{ "cadetblue", .{ 95, 158, 160 } },
+        .{ "chartreuse", .{ 127, 255, 0 } },
+        .{ "chocolate", .{ 210, 105, 30 } },
+        .{ "coral", .{ 255, 127, 80 } },
+        .{ "cornflowerblue", .{ 100, 149, 237 } },
+        .{ "cornsilk", .{ 255, 248, 220 } },
+        .{ "crimson", .{ 220, 20, 60 } },
+        .{ "cyan", .{ 0, 255, 255 } },
+        .{ "darkblue", .{ 0, 0, 139 } },
+        .{ "darkcyan", .{ 0, 139, 139 } },
+        .{ "darkgoldenrod", .{ 184, 134, 11 } },
+        .{ "darkgray", .{ 169, 169, 169 } },
+        .{ "darkgreen", .{ 0, 100, 0 } },
+        .{ "darkgrey", .{ 169, 169, 169 } },
+        .{ "darkkhaki", .{ 189, 183, 107 } },
+        .{ "darkmagenta", .{ 139, 0, 139 } },
+        .{ "darkolivegreen", .{ 85, 107, 47 } },
+        .{ "darkorange", .{ 255, 140, 0 } },
+        .{ "darkorchid", .{ 153, 50, 204 } },
+        .{ "darkred", .{ 139, 0, 0 } },
+        .{ "darksalmon", .{ 233, 150, 122 } },
+        .{ "darkseagreen", .{ 143, 188, 143 } },
+        .{ "darkslateblue", .{ 72, 61, 139 } },
+        .{ "darkslategray", .{ 47, 79, 79 } },
+        .{ "darkslategrey", .{ 47, 79, 79 } },
+        .{ "darkturquoise", .{ 0, 206, 209 } },
+        .{ "darkviolet", .{ 148, 0, 211 } },
+        .{ "deeppink", .{ 255, 20, 147 } },
+        .{ "deepskyblue", .{ 0, 191, 255 } },
+        .{ "dimgray", .{ 105, 105, 105 } },
+        .{ "dimgrey", .{ 105, 105, 105 } },
+        .{ "dodgerblue", .{ 30, 144, 255 } },
+        .{ "firebrick", .{ 178, 34, 34 } },
+        .{ "floralwhite", .{ 255, 250, 240 } },
+        .{ "forestgreen", .{ 34, 139, 34 } },
+        .{ "fuchsia", .{ 255, 0, 255 } },
+        .{ "gainsboro", .{ 220, 220, 220 } },
+        .{ "ghostwhite", .{ 248, 248, 255 } },
+        .{ "gold", .{ 255, 215, 0 } },
+        .{ "goldenrod", .{ 218, 165, 32 } },
+        .{ "gray", .{ 128, 128, 128 } },
+        .{ "green", .{ 0, 128, 0 } },
+        .{ "greenyellow", .{ 173, 255, 47 } },
+        .{ "grey", .{ 128, 128, 128 } },
+        .{ "honeydew", .{ 240, 255, 240 } },
+        .{ "hotpink", .{ 255, 105, 180 } },
+        .{ "indianred", .{ 205, 92, 92 } },
+        .{ "indigo", .{ 75, 0, 130 } },
+        .{ "ivory", .{ 255, 255, 240 } },
+        .{ "khaki", .{ 240, 230, 140 } },
+        .{ "lavender", .{ 230, 230, 250 } },
+        .{ "lavenderblush", .{ 255, 240, 245 } },
+        .{ "lawngreen", .{ 124, 252, 0 } },
+        .{ "lemonchiffon", .{ 255, 250, 205 } },
+        .{ "lightblue", .{ 173, 216, 230 } },
+        .{ "lightcoral", .{ 240, 128, 128 } },
+        .{ "lightcyan", .{ 224, 255, 255 } },
+        .{ "lightgoldenrodyellow", .{ 250, 250, 210 } },
+        .{ "lightgray", .{ 211, 211, 211 } },
+        .{ "lightgreen", .{ 144, 238, 144 } },
+        .{ "lightgrey", .{ 211, 211, 211 } },
+        .{ "lightpink", .{ 255, 182, 193 } },
+        .{ "lightsalmon", .{ 255, 160, 122 } },
+        .{ "lightseagreen", .{ 32, 178, 170 } },
+        .{ "lightskyblue", .{ 135, 206, 250 } },
+        .{ "lightslategray", .{ 119, 136, 153 } },
+        .{ "lightslategrey", .{ 119, 136, 153 } },
+        .{ "lightsteelblue", .{ 176, 196, 222 } },
+        .{ "lightyellow", .{ 255, 255, 224 } },
+        .{ "lime", .{ 0, 255, 0 } },
+        .{ "limegreen", .{ 50, 205, 50 } },
+        .{ "linen", .{ 250, 240, 230 } },
+        .{ "magenta", .{ 255, 0, 255 } },
+        .{ "maroon", .{ 128, 0, 0 } },
+        .{ "mediumaquamarine", .{ 102, 205, 170 } },
+        .{ "mediumblue", .{ 0, 0, 205 } },
+        .{ "mediumorchid", .{ 186, 85, 211 } },
+        .{ "mediumpurple", .{ 147, 112, 219 } },
+        .{ "mediumseagreen", .{ 60, 179, 113 } },
+        .{ "mediumslateblue", .{ 123, 104, 238 } },
+        .{ "mediumspringgreen", .{ 0, 250, 154 } },
+        .{ "mediumturquoise", .{ 72, 209, 204 } },
+        .{ "mediumvioletred", .{ 199, 21, 133 } },
+        .{ "midnightblue", .{ 25, 25, 112 } },
+        .{ "mintcream", .{ 245, 255, 250 } },
+        .{ "mistyrose", .{ 255, 228, 225 } },
+        .{ "moccasin", .{ 255, 228, 181 } },
+        .{ "navajowhite", .{ 255, 222, 173 } },
+        .{ "navy", .{ 0, 0, 128 } },
+        .{ "oldlace", .{ 253, 245, 230 } },
+        .{ "olive", .{ 128, 128, 0 } },
+        .{ "olivedrab", .{ 107, 142, 35 } },
+        .{ "orange", .{ 255, 165, 0 } },
+        .{ "orangered", .{ 255, 69, 0 } },
+        .{ "orchid", .{ 218, 112, 214 } },
+        .{ "palegoldenrod", .{ 238, 232, 170 } },
+        .{ "palegreen", .{ 152, 251, 152 } },
+        .{ "paleturquoise", .{ 175, 238, 238 } },
+        .{ "palevioletred", .{ 219, 112, 147 } },
+        .{ "papayawhip", .{ 255, 239, 213 } },
+        .{ "peachpuff", .{ 255, 218, 185 } },
+        .{ "peru", .{ 205, 133, 63 } },
+        .{ "pink", .{ 255, 192, 203 } },
+        .{ "plum", .{ 221, 160, 221 } },
+        .{ "powderblue", .{ 176, 224, 230 } },
+        .{ "purple", .{ 128, 0, 128 } },
+        .{ "rebeccapurple", .{ 102, 51, 153 } },
+        .{ "red", .{ 255, 0, 0 } },
+        .{ "rosybrown", .{ 188, 143, 143 } },
+        .{ "royalblue", .{ 65, 105, 225 } },
+        .{ "saddlebrown", .{ 139, 69, 19 } },
+        .{ "salmon", .{ 250, 128, 114 } },
+        .{ "sandybrown", .{ 244, 164, 96 } },
+        .{ "seagreen", .{ 46, 139, 87 } },
+        .{ "seashell", .{ 255, 245, 238 } },
+        .{ "sienna", .{ 160, 82, 45 } },
+        .{ "silver", .{ 192, 192, 192 } },
+        .{ "skyblue", .{ 135, 206, 235 } },
+        .{ "slateblue", .{ 106, 90, 205 } },
+        .{ "slategray", .{ 112, 128, 144 } },
+        .{ "slategrey", .{ 112, 128, 144 } },
+        .{ "snow", .{ 255, 250, 250 } },
+        .{ "springgreen", .{ 0, 255, 127 } },
+        .{ "steelblue", .{ 70, 130, 180 } },
+        .{ "tan", .{ 210, 180, 140 } },
+        .{ "teal", .{ 0, 128, 128 } },
+        .{ "thistle", .{ 216, 191, 216 } },
+        .{ "tomato", .{ 255, 99, 71 } },
+        .{ "turquoise", .{ 64, 224, 208 } },
+        .{ "violet", .{ 238, 130, 238 } },
+        .{ "wheat", .{ 245, 222, 179 } },
+        .{ "white", .{ 255, 255, 255 } },
+        .{ "whitesmoke", .{ 245, 245, 245 } },
+        .{ "yellow", .{ 255, 255, 0 } },
+        .{ "yellowgreen", .{ 154, 205, 50 } },
+    });
+
+    /// Returns the named color with the given name.
+    /// <https://drafts.csswg.org/css-color-4/#typedef-named-color>
+    pub fn parseNamedColor(ident: []const u8) ?struct { u8, u8, u8 } {
+        return named_colors.get(ident);
+    }
+
+    /// Parse a color hash, without the leading '#' character.
+    pub fn parseHashColor(value: []const u8) ?struct { u8, u8, u8, f32 } {
+        return parseHashColorImpl(value) catch return null;
+    }
+
+    pub fn parseHashColorImpl(value: []const u8) ColorError!struct { u8, u8, u8, f32 } {
+        return switch (value.len) {
+            8 => .{
+                (try fromHex(value[0])) * 16 + (try fromHex(value[1])),
+                (try fromHex(value[2])) * 16 + (try fromHex(value[3])),
+                (try fromHex(value[4])) * 16 + (try fromHex(value[5])),
+                @as(f32, @floatFromInt((try fromHex(value[6])) * 16 + (try fromHex(value[7])))) / 255.0,
+            },
+            6 => {
+                const r = (try fromHex(value[0])) * 16 + (try fromHex(value[1]));
+                const g = (try fromHex(value[2])) * 16 + (try fromHex(value[3]));
+                const b = (try fromHex(value[4])) * 16 + (try fromHex(value[5]));
+                return .{
+                    r,      g, b,
+
+                    OPAQUE,
+                };
+            },
+            4 => .{
+                (try fromHex(value[0])) * 17,
+                (try fromHex(value[1])) * 17,
+                (try fromHex(value[2])) * 17,
+                @as(f32, @floatFromInt((try fromHex(value[3])) * 17)) / 255.0,
+            },
+            3 => .{
+                (try fromHex(value[0])) * 17,
+                (try fromHex(value[1])) * 17,
+                (try fromHex(value[2])) * 17,
+                OPAQUE,
+            },
+            else => ColorError.parse,
+        };
+    }
+
+    pub fn fromHex(c: u8) ColorError!u8 {
+        return switch (c) {
+            '0'...'9' => c - '0',
+            'a'...'f' => c - 'a' + 10,
+            'A'...'F' => c - 'A' + 10,
+            else => ColorError.parse,
+        };
+    }
+
+    /// <https://drafts.csswg.org/css-color/#hsl-color>
+    /// except with h pre-multiplied by 3, to avoid some rounding errors.
+    pub fn hslToRgb(hue: f32, saturation: f32, lightness: f32) struct { f32, f32, f32 } {
+        bun.debugAssert(saturation >= 0.0 and saturation <= 1.0);
+        const Helpers = struct {
+            pub fn hueToRgb(m1: f32, m2: f32, _h3: f32) f32 {
+                var h3 = _h3;
+                if (h3 < 0.0) {
+                    h3 += 3.0;
+                }
+                if (h3 > 3.0) {
+                    h3 -= 3.0;
+                }
+                if (h3 * 2.0 < 1.0) {
+                    return m1 + (m2 - m1) * h3 * 2.0;
+                } else if (h3 * 2.0 < 3.0) {
+                    return m2;
+                } else if (h3 < 2.0) {
+                    return m1 + (m2 - m1) * (2.0 - h3) * 2.0;
+                } else {
+                    return m1;
+                }
+            }
+        };
+        const m2 = if (lightness <= 0.5)
+            lightness * (saturation + 1.0)
+        else
+            lightness + saturation - lightness * saturation;
+        const m1 = lightness * 2.0 - m2;
+        const hue_times_3 = hue * 3.0;
+        const red = Helpers.hueToRgb(m1, m2, hue_times_3 + 1.0);
+        const green = Helpers.hueToRgb(m1, m2, hue_times_3);
+        const blue = Helpers.hueToRgb(m1, m2, hue_times_3 - 1.0);
+        return .{ red, green, blue };
+    }
+};
+
+// pub const Bitflags
+
+pub const serializer = struct {
+    /// Write a CSS name, like a custom property name.
+    ///
+    /// You should only use this when you know what you're doing, when in doubt,
+    /// consider using `serialize_identifier`.
+    pub fn serializeName(value: []const u8, writer: anytype) !void {
+        var chunk_start: usize = 0;
+        for (value, 0..) |b, i| {
+            const escaped: ?[]const u8 = switch (b) {
+                '0'...'9', 'A'...'Z', 'a'...'z', '_', '-' => continue,
+                // the unicode replacement character
+                0 => bun.strings.encodeUTF8Comptime(0xFFD),
+                else => if (!std.ascii.isASCII(b)) continue else null,
+            };
+
+            try writer.writeAll(value[chunk_start..i]);
+            if (escaped) |esc| {
+                try writer.writeAll(esc);
+            } else if ((b >= 0x01 and b <= 0x1F) or b == 0x7F) {
+                try hexEscape(b, writer);
+            } else {
+                try charEscape(b, writer);
+            }
+            chunk_start = i + 1;
+        }
+        return writer.writeAll(value[chunk_start..]);
+    }
+
+    /// Write a double-quoted CSS string token, escaping content as necessary.
+    pub fn serializeString(value: []const u8, writer: anytype) !void {
+        try writer.writeAll("\"");
+        var string_writer = CssStringWriter(@TypeOf(writer)).new(writer);
+        try string_writer.writeStr(value);
+        return writer.writeAll("\"");
+    }
+
+    pub fn serializeDimension(value: f32, unit: []const u8, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        const int_value: ?i32 = if (fract(value) == 0.0) @intFromFloat(value) else null;
+        const token = Token{ .dimension = .{
+            .num = .{
+                .has_sign = value < 0.0,
+                .value = value,
+                .int_value = int_value,
+            },
+            .unit = unit,
+        } };
+        if (value != 0.0 and @abs(value) < 1.0) {
+            // TODO: calculate the actual number of chars here
+            var buf: [64]u8 = undefined;
+            var fbs = std.io.fixedBufferStream(&buf);
+            token.toCssGeneric(fbs.writer()) catch return dest.addFmtError();
+            const s = fbs.getWritten();
+            if (value < 0.0) {
+                try dest.writeStr("-");
+                return dest.writeStr(bun.strings.trimLeadingPattern2(s, '-', '0'));
+            } else {
+                return dest.writeStr(bun.strings.trimLeadingChar(s, '0'));
+            }
+        } else {
+            return token.toCssGeneric(dest) catch return dest.addFmtError();
+        }
+    }
+
+    /// Write a CSS identifier, escaping characters as necessary.
+    pub fn serializeIdentifier(value: []const u8, writer: anytype) !void {
+        if (value.len == 0) {
+            return;
+        }
+
+        if (bun.strings.startsWith(value, "--")) {
+            try writer.writeAll("--");
+            return serializeName(value[2..], writer);
+        } else if (bun.strings.eql(value, "-")) {
+            return writer.writeAll("\\-");
+        } else {
+            var slice = value;
+            if (slice[0] == '-') {
+                try writer.writeAll("-");
+                slice = slice[1..];
+            }
+            if (slice.len > 0 and slice[0] >= '0' and slice[0] <= '9') {
+                try hexEscape(slice[0], writer);
+                slice = slice[1..];
+            }
+            return serializeName(slice, writer);
+        }
+    }
+
+    pub fn serializeUnquotedUrl(value: []const u8, writer: anytype) !void {
+        var chunk_start: usize = 0;
+        for (value, 0..) |b, i| {
+            const hex = switch (b) {
+                0...' ', 0x7F => true,
+                '(', ')', '"', '\'', '\\' => false,
+                else => continue,
+            };
+            try writer.writeAll(value[chunk_start..i]);
+            if (hex) {
+                try hexEscape(b, writer);
+            } else {
+                try charEscape(b, writer);
+            }
+            chunk_start = i + 1;
+        }
+        return writer.writeAll(value[chunk_start..]);
+    }
+
+    // pub fn writeNumeric(value: f32, int_value: ?i32, has_sign: bool, writer: anytype) !void {
+    //     // `value >= 0` is true for negative 0.
+    //     if (has_sign and !std.math.signbit(value)) {
+    //         try writer.writeAll("+");
+    //     }
+
+    //     if (value == 0.0 and signfns.isSignNegative(value)) {
+    //         // Negative zero. Work around #20596.
+    //         try writer.writeAll("-0");
+    //         if (int_value == null and @mod(value, 1) == 0) {
+    //             try writer.writeAll(".0");
+    //         }
+    //     } else {
+    //         var buf: [124]u8 = undefined;
+    //         const bytes = bun.fmt.FormatDouble.dtoa(&buf, @floatCast(value));
+    //         try writer.writeAll(bytes);
+    //     }
+    // }
+
+    pub fn writeNumeric(value: f32, int_value: ?i32, has_sign: bool, writer: anytype) !void {
+        // `value >= 0` is true for negative 0.
+        if (has_sign and !std.math.signbit(value)) {
+            try writer.writeAll("+");
+        }
+
+        const notation: Notation = if (value == 0.0 and std.math.signbit(value)) notation: {
+            // Negative zero. Work around #20596.
+            try writer.writeAll("-0");
+            break :notation Notation{
+                .decimal_point = false,
+                .scientific = false,
+            };
+        } else notation: {
+            var buf: [129]u8 = undefined;
+            const str, const notation = dtoa_short(&buf, value, 6);
+            try writer.writeAll(str);
+            break :notation notation;
+        };
+
+        if (int_value == null and fract(value) == 0) {
+            if (!notation.decimal_point and !notation.scientific) {
+                try writer.writeAll(".0");
+            }
+        }
+
+        return;
+    }
+
+    pub fn hexEscape(ascii_byte: u8, writer: anytype) !void {
+        const HEX_DIGITS = "0123456789abcdef";
+        var bytes: [4]u8 = undefined;
+        const slice: []const u8 = if (ascii_byte > 0x0F) slice: {
+            const high: usize = @intCast(ascii_byte >> 4);
+            const low: usize = @intCast(ascii_byte & 0x0F);
+            bytes[0] = '\\';
+            bytes[1] = HEX_DIGITS[high];
+            bytes[2] = HEX_DIGITS[low];
+            bytes[3] = ' ';
+            break :slice bytes[0..4];
+        } else slice: {
+            bytes[0] = '\\';
+            bytes[1] = HEX_DIGITS[ascii_byte];
+            bytes[2] = ' ';
+            break :slice bytes[0..3];
+        };
+        return writer.writeAll(slice);
+    }
+
+    pub fn charEscape(ascii_byte: u8, writer: anytype) !void {
+        const bytes = [_]u8{ '\\', ascii_byte };
+        return writer.writeAll(&bytes);
+    }
+
+    pub fn CssStringWriter(comptime W: type) type {
+        return struct {
+            inner: W,
+
+            /// Wrap a text writer to create a `CssStringWriter`.
+            pub fn new(inner: W) @This() {
+                return .{ .inner = inner };
+            }
+
+            pub fn writeStr(this: *@This(), str: []const u8) !void {
+                var chunk_start: usize = 0;
+                for (str, 0..) |b, i| {
+                    const escaped = switch (b) {
+                        '"' => "\\\"",
+                        '\\' => "\\\\",
+                        // replacement character
+                        0 => bun.strings.encodeUTF8Comptime(0xFFD),
+                        0x01...0x1F, 0x7F => null,
+                        else => continue,
+                    };
+                    try this.inner.writeAll(str[chunk_start..i]);
+                    if (escaped) |e| {
+                        try this.inner.writeAll(e);
+                    } else {
+                        try serializer.hexEscape(b, this.inner);
+                    }
+                    chunk_start = i + 1;
+                }
+                return this.inner.writeAll(str[chunk_start..]);
+            }
+        };
+    }
+};
+
+pub inline fn implementDeepClone(comptime T: type, this: *const T, allocator: Allocator) T {
+    const tyinfo = @typeInfo(T);
+
+    if (comptime bun.meta.isSimpleCopyType(T)) {
+        return this.*;
+    }
+
+    if (comptime bun.meta.looksLikeListContainerType(T)) |result| {
+        return switch (result) {
+            .array_list => deepClone(result.child, allocator, this),
+            .baby_list => @panic("Not implemented."),
+            .small_list => this.deepClone(allocator),
+        };
+    }
+
+    if (comptime T == []const u8) {
+        return this.*;
+    }
+
+    if (comptime @typeInfo(T) == .Pointer) {
+        const TT = std.meta.Child(T);
+        return implementEql(TT, this.*);
+    }
+
+    return switch (tyinfo) {
+        .Struct => {
+            var strct: T = undefined;
+            inline for (tyinfo.Struct.fields) |field| {
+                if (comptime generic.canTransitivelyImplementDeepClone(field.type) and @hasDecl(field.type, "__generateDeepClone")) {
+                    @field(strct, field.name) = implementDeepClone(field.type, &field(this, field.name, allocator));
+                } else {
+                    @field(strct, field.name) = generic.deepClone(field.type, &@field(this, field.name), allocator);
+                }
+            }
+            return strct;
+        },
+        .Union => {
+            inline for (bun.meta.EnumFields(T), tyinfo.Union.fields) |enum_field, union_field| {
+                if (@intFromEnum(this.*) == enum_field.value) {
+                    if (comptime generic.canTransitivelyImplementDeepClone(union_field.type) and @hasDecl(union_field.type, "__generateDeepClone")) {
+                        return @unionInit(T, enum_field.name, implementDeepClone(union_field.type, &@field(this, enum_field.name), allocator));
+                    }
+                    return @unionInit(T, enum_field.name, generic.deepClone(union_field.type, &@field(this, enum_field.name), allocator));
+                }
+            }
+            unreachable;
+        },
+        else => @compileError("Unhandled type " ++ @typeName(T)),
+    };
+}
+
+/// A function to implement `lhs.eql(&rhs)` for the many types in the CSS parser that needs this.
+///
+/// This is the equivalent of doing `#[derive(PartialEq])` in Rust.
+///
+/// This function only works on simple types like:
+/// - Simple equality types (e.g. integers, floats, strings, enums, etc.)
+/// - Types which implement a `.eql(lhs: *const @This(), rhs: *const @This()) bool` function
+///
+/// Or compound types composed of simple types such as:
+/// - Pointers to simple types
+/// - Optional simple types
+/// - Structs, Arrays, and Unions
+pub fn implementEql(comptime T: type, this: *const T, other: *const T) bool {
+    const tyinfo = @typeInfo(T);
+    if (comptime bun.meta.isSimpleEqlType(T)) {
+        return this.* == other.*;
+    }
+    if (comptime T == []const u8) {
+        return bun.strings.eql(this.*, other.*);
+    }
+    if (comptime @typeInfo(T) == .Pointer) {
+        const TT = std.meta.Child(T);
+        return implementEql(TT, this.*, other.*);
+    }
+    if (comptime @typeInfo(T) == .Optional) {
+        const TT = std.meta.Child(T);
+        if (this.* != null and other.* != null) return implementEql(TT, &this.*.?, &other.*.?);
+        return false;
+    }
+    return switch (tyinfo) {
+        .Optional => @compileError("Handled above, this means Zack wrote a bug."),
+        .Pointer => @compileError("Handled above, this means Zack wrote a bug."),
+        .Array => {
+            const Child = std.meta.Child(T);
+            if (comptime bun.meta.isSimpleEqlType(Child)) {
+                return std.mem.eql(Child, &this.*, &other.*);
+            }
+            if (this.len != other.len) return false;
+            if (comptime generic.canTransitivelyImplementEql(Child) and @hasDecl(Child, "__generateEql")) {
+                for (this.*, other.*) |*a, *b| {
+                    if (!implementEql(Child, &a, &b)) return false;
+                }
+            } else {
+                for (this.*, other.*) |*a, *b| {
+                    if (!generic.eql(Child, a, b)) return false;
+                }
+            }
+            return true;
+        },
+        .Struct => {
+            inline for (tyinfo.Struct.fields) |field| {
+                if (!generic.eql(field.type, &@field(this, field.name), &@field(other, field.name))) return false;
+            }
+            return true;
+        },
+        .Union => {
+            if (tyinfo.Union.tag_type == null) @compileError("Unions must have a tag type");
+            if (@intFromEnum(this.*) != @intFromEnum(other.*)) return false;
+            const enum_fields = bun.meta.EnumFields(T);
+            inline for (enum_fields, std.meta.fields(T)) |enum_field, union_field| {
+                if (enum_field.value == @intFromEnum(this.*)) {
+                    if (union_field.type != void) {
+                        if (comptime generic.canTransitivelyImplementEql(union_field.type) and @hasDecl(union_field.type, "__generateEql")) {
+                            return implementEql(union_field.type, &@field(this, enum_field.name), &@field(other, enum_field.name));
+                        }
+                        return generic.eql(union_field.type, &@field(this, enum_field.name), &@field(other, enum_field.name));
+                    } else {
+                        return true;
+                    }
+                }
+            }
+            unreachable;
+        },
+        else => @compileError("Unsupported type: " ++ @typeName(T)),
+    };
+}
+
+pub fn implementHash(comptime T: type, this: *const T, hasher: *std.hash.Wyhash) void {
+    const tyinfo = @typeInfo(T);
+    if (comptime T == void) return;
+    if (comptime bun.meta.isSimpleEqlType(T)) {
+        return hasher.update(std.mem.asBytes(&this));
+    }
+    if (comptime T == []const u8) {
+        return hasher.update(this.*);
+    }
+    if (comptime @typeInfo(T) == .Pointer) {
+        @compileError("Invalid type for implementHash(): " ++ @typeName(T));
+    }
+    if (comptime @typeInfo(T) == .Optional) {
+        @compileError("Invalid type for implementHash(): " ++ @typeName(T));
+    }
+    return switch (tyinfo) {
+        .Optional => unreachable,
+        .Pointer => unreachable,
+        .Array => {
+            if (comptime @typeInfo(T) == .Optional) {
+                @compileError("Invalid type for implementHash(): " ++ @typeName(T));
+            }
+        },
+        .Struct => {
+            inline for (tyinfo.Struct.fields) |field| {
+                if (comptime generic.hasHash(field.type)) {
+                    generic.hash(field.type, &@field(this, field.name), hasher);
+                } else if (@hasDecl(field.type, "__generateHash") and @typeInfo(field.type) == .Struct) {
+                    implementHash(field.type, &@field(this, field.name), hasher);
+                } else {
+                    @compileError("Can't hash these fields: " ++ @typeName(field.type) ++ ". On " ++ @typeName(T));
+                }
+            }
+            return;
+        },
+        .Union => {
+            if (tyinfo.Union.tag_type == null) @compileError("Unions must have a tag type");
+            const enum_fields = bun.meta.EnumFields(T);
+            inline for (enum_fields, std.meta.fields(T)) |enum_field, union_field| {
+                if (enum_field.value == @intFromEnum(this.*)) {
+                    const field = union_field;
+                    if (comptime generic.hasHash(field.type)) {
+                        generic.hash(field.type, &@field(this, field.name), hasher);
+                    } else if (@hasDecl(field.type, "__generateHash") and @typeInfo(field.type) == .Struct) {
+                        implementHash(field.type, &@field(this, field.name), hasher);
+                    } else {
+                        @compileError("Can't hash these fields: " ++ @typeName(field.type) ++ ". On " ++ @typeName(T));
+                    }
+                }
+            }
+            return;
+        },
+        else => @compileError("Unsupported type: " ++ @typeName(T)),
+    };
+}
+
+pub const parse_utility = struct {
+    /// Parse a value from a string.
+    ///
+    /// (This is a convenience wrapper for `parse` and probably should not be overridden.)
+    ///
+    /// NOTE: `input` should live as long as the returned value. Otherwise, strings in the
+    /// returned parsed value will point to undefined memory.
+    pub fn parseString(
+        allocator: Allocator,
+        comptime T: type,
+        input: []const u8,
+        comptime parse_one: *const fn (*Parser) Result(T),
+    ) Result(T) {
+        // I hope this is okay
+        var import_records = bun.BabyList(bun.ImportRecord){};
+        defer import_records.deinitWithAllocator(allocator);
+        var i = ParserInput.new(allocator, input);
+        var parser = Parser.new(&i, &import_records);
+        const result = switch (parse_one(&parser)) {
+            .err => |e| return .{ .err = e },
+            .result => |v| v,
+        };
+        if (parser.expectExhausted().asErr()) |e| return .{ .err = e };
+        return .{ .result = result };
+    }
+};
+
+pub const to_css = struct {
+    /// Serialize `self` in CSS syntax and return a string.
+    ///
+    /// (This is a convenience wrapper for `to_css` and probably should not be overridden.)
+    pub fn string(
+        allocator: Allocator,
+        comptime T: type,
+        this: *const T,
+        options: PrinterOptions,
+        import_records: ?*const bun.BabyList(ImportRecord),
+    ) PrintErr![]const u8 {
+        var s = ArrayList(u8){};
+        errdefer s.deinit(allocator);
+        const writer = s.writer(allocator);
+        const W = @TypeOf(writer);
+        // PERF: think about how cheap this is to create
+        var printer = Printer(W).new(allocator, std.ArrayList(u8).init(allocator), writer, options, import_records);
+        defer printer.deinit();
+        switch (T) {
+            CSSString => try CSSStringFns.toCss(this, W, &printer),
+            else => try this.toCss(W, &printer),
+        }
+        return s.items;
+    }
+
+    pub fn fromList(comptime T: type, this: *const ArrayList(T), comptime W: type, dest: *Printer(W)) PrintErr!void {
+        const len = this.items.len;
+        for (this.items, 0..) |*val, idx| {
+            try val.toCss(W, dest);
+            if (idx < len - 1) {
+                try dest.delim(',', false);
+            }
+        }
+        return;
+    }
+
+    pub fn fromBabyList(comptime T: type, this: *const bun.BabyList(T), comptime W: type, dest: *Printer(W)) PrintErr!void {
+        const len = this.len;
+        for (this.sliceConst(), 0..) |*val, idx| {
+            try val.toCss(W, dest);
+            if (idx < len - 1) {
+                try dest.delim(',', false);
+            }
+        }
+        return;
+    }
+
+    pub fn integer(comptime T: type, this: T, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        const MAX_LEN = comptime maxDigits(T);
+        var buf: [MAX_LEN]u8 = undefined;
+        const str = std.fmt.bufPrint(buf[0..], "{d}", .{this}) catch unreachable;
+        return dest.writeStr(str);
+    }
+
+    pub fn float32(this: f32, writer: anytype) !void {
+        var scratch: [64]u8 = undefined;
+        // PERF/TODO: Compare this to Rust dtoa-short crate
+        const floats = std.fmt.formatFloat(scratch[0..], this, .{
+            .mode = .decimal,
+        }) catch unreachable;
+        return writer.writeAll(floats);
+    }
+
+    fn maxDigits(comptime T: type) usize {
+        const max_val = std.math.maxInt(T);
+        return std.fmt.count("{d}", .{max_val});
+    }
+};
+
+/// Parse `!important`.
+///
+/// Typical usage is `input.try_parse(parse_important).is_ok()`
+/// at the end of a `DeclarationParser::parse_value` implementation.
+pub fn parseImportant(input: *Parser) Result(void) {
+    if (input.expectDelim('!').asErr()) |e| return .{ .err = e };
+    return switch (input.expectIdentMatching("important")) {
+        .result => |v| .{ .result = v },
+        .err => |e| .{ .err = e },
+    };
+}
+
+pub const signfns = struct {
+    pub inline fn isSignPositive(x: f32) bool {
+        return !isSignNegative(x);
+    }
+    pub inline fn isSignNegative(x: f32) bool {
+        // IEEE754 says: isSignMinus(x) is true if and only if x has negative sign. isSignMinus
+        // applies to zeros and NaNs as well.
+        // SAFETY: This is just transmuting to get the sign bit, it's fine.
+        return @as(u32, @bitCast(x)) & 0x8000_0000 != 0;
+    }
+    /// Returns a number that represents the sign of `self`.
+    ///
+    /// - `1.0` if the number is positive, `+0.0` or `INFINITY`
+    /// - `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY`
+    /// - NaN if the number is NaN
+    pub fn signum(x: f32) f32 {
+        if (std.math.isNan(x)) return std.math.nan(f32);
+        return copysign(1, x);
+    }
+
+    pub inline fn signF32(x: f32) f32 {
+        if (x == 0.0) return if (isSignNegative(x)) 0.0 else -0.0;
+        return signum(x);
+    }
+};
+
+/// TODO(zack) is this correct
+/// Copies the sign of `sign` to `self`, returning a new f32 value
+pub inline fn copysign(self: f32, sign: f32) f32 {
+    // Convert both floats to their bit representations
+    const self_bits = @as(u32, @bitCast(self));
+    const sign_bits = @as(u32, @bitCast(sign));
+
+    // Clear the sign bit of self and combine with the sign bit of sign
+    const result_bits = (self_bits & 0x7FFFFFFF) | (sign_bits & 0x80000000);
+
+    // Convert the result back to f32
+    return @as(f32, @bitCast(result_bits));
+}
+
+pub fn deepClone(comptime V: type, allocator: Allocator, list: *const ArrayList(V)) ArrayList(V) {
+    var newlist = ArrayList(V).initCapacity(allocator, list.items.len) catch bun.outOfMemory();
+
+    for (list.items) |*item| {
+        newlist.appendAssumeCapacity(generic.deepClone(V, item, allocator));
+    }
+
+    return newlist;
+}
+
+pub fn deepDeinit(comptime V: type, allocator: Allocator, list: *ArrayList(V)) void {
+    if (comptime !@hasDecl(V, "deinit")) return;
+    for (list.items) |*item| {
+        item.deinit(allocator);
+    }
+
+    list.deinit(allocator);
+}
+
+const Notation = struct {
+    decimal_point: bool,
+    scientific: bool,
+
+    pub fn integer() Notation {
+        return .{
+            .decimal_point = false,
+            .scientific = false,
+        };
+    }
+};
+
+pub fn dtoa_short(buf: *[129]u8, value: f32, comptime precision: u8) struct { []u8, Notation } {
+    buf[0] = '0';
+    const buf_len = bun.fmt.FormatDouble.dtoa(@ptrCast(buf[1..].ptr), @floatCast(value)).len;
+    return restrict_prec(buf[0 .. buf_len + 1], precision);
+}
+
+fn restrict_prec(buf: []u8, comptime prec: u8) struct { []u8, Notation } {
+    const len: u8 = @intCast(buf.len);
+
+    // Put a leading zero to capture any carry.
+    // Caller must prepare an empty byte for us;
+    bun.debugAssert(buf[0] == '0');
+    buf[0] = '0';
+    // Remove the sign for now. We will put it back at the end.
+    const sign = switch (buf[1]) {
+        '+', '-' => brk: {
+            const s = buf[1];
+            buf[1] = '0';
+            break :brk s;
+        },
+        else => null,
+    };
+
+    // Locate dot, exponent, and the first significant digit.
+    var _pos_dot: ?u8 = null;
+    var pos_exp: ?u8 = null;
+    var _prec_start: ?u8 = null;
+    for (1..len) |i| {
+        if (buf[i] == '.') {
+            bun.debugAssert(_pos_dot == null);
+            _pos_dot = @intCast(i);
+        } else if (buf[i] == 'e') {
+            pos_exp = @intCast(i);
+            // We don't change exponent part, so stop here.
+            break;
+        } else if (_prec_start == null and buf[i] != '0') {
+            bun.debugAssert(buf[i] >= '1' and buf[i] <= '9');
+            _prec_start = @intCast(i);
+        }
+    }
+
+    const prec_start = if (_prec_start) |i|
+        i
+    else
+        // If there is no non-zero digit at all, it is just zero.
+        return .{
+            buf[0..1],
+            Notation.integer(),
+        };
+
+    // Coefficient part ends at 'e' or the length.
+    const coeff_end = pos_exp orelse len;
+    // Decimal dot is effectively at the end of coefficient part if no
+    // dot presents before that.
+    const had_pos_dot = _pos_dot != null;
+    const pos_dot = _pos_dot orelse coeff_end;
+    // Find the end position of the number within the given precision.
+    const prec_end: u8 = brk: {
+        const end = prec_start + prec;
+        break :brk if (pos_dot > prec_start and pos_dot <= end) end + 1 else end;
+    };
+    var new_coeff_end = coeff_end;
+    if (prec_end < coeff_end) {
+        // Round to the given precision.
+        const next_char = buf[prec_end];
+        new_coeff_end = prec_end;
+        if (next_char >= '5') {
+            var i = prec_end;
+            while (i != 0) {
+                i -= 1;
+                if (buf[i] == '.') {
+                    continue;
+                }
+                if (buf[i] != '9') {
+                    buf[i] += 1;
+                    new_coeff_end = i + 1;
+                    break;
+                }
+                buf[i] = '0';
+            }
+        }
+    }
+    if (new_coeff_end < pos_dot) {
+        // If the precision isn't enough to reach the dot, set all digits
+        // in-between to zero and keep the number until the dot.
+        for (new_coeff_end..pos_dot) |i| {
+            buf[i] = '0';
+        }
+        new_coeff_end = pos_dot;
+    } else if (had_pos_dot) {
+        // Strip any trailing zeros.
+        var i = new_coeff_end;
+        while (i != 0) {
+            i -= 1;
+            if (buf[i] != '0') {
+                if (buf[i] == '.') {
+                    new_coeff_end = i;
+                }
+                break;
+            }
+            new_coeff_end = i;
+        }
+    }
+    // Move exponent part if necessary.
+    const real_end = if (pos_exp) |posexp| brk: {
+        const exp_len = len - posexp;
+        if (new_coeff_end != posexp) {
+            for (0..exp_len) |i| {
+                buf[new_coeff_end + i] = buf[posexp + i];
+            }
+        }
+        break :brk new_coeff_end + exp_len;
+    } else new_coeff_end;
+    // Add back the sign and strip the leading zero.
+    const result = if (sign) |sgn| brk: {
+        if (buf[1] == '0' and buf[2] != '.') {
+            buf[1] = sgn;
+            break :brk buf[1..real_end];
+        }
+        bun.debugAssert(buf[0] == '0');
+        buf[0] = sgn;
+        break :brk buf[0..real_end];
+    } else brk: {
+        if (buf[0] == '0' and buf[1] != '.') {
+            break :brk buf[1..real_end];
+        }
+        break :brk buf[0..real_end];
+    };
+    // Generate the notation info.
+    const notation = Notation{
+        .decimal_point = pos_dot < new_coeff_end,
+        .scientific = pos_exp != null,
+    };
+    return .{ result, notation };
+}
+
+pub inline fn fract(val: f32) f32 {
+    return val - @trunc(val);
+}
diff --git a/src/css/declaration.zig b/src/css/declaration.zig
new file mode 100644
index 0000000000..f84c4f9c11
--- /dev/null
+++ b/src/css/declaration.zig
@@ -0,0 +1,379 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const bun = @import("root").bun;
+const logger = bun.logger;
+const Log = logger.Log;
+
+pub const css = @import("./css_parser.zig");
+pub const Error = css.Error;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const PrintResult = css.PrintResult;
+const Result = css.Result;
+
+const ArrayList = std.ArrayListUnmanaged;
+pub const DeclarationList = ArrayList(css.Property);
+
+const BackgroundHandler = css.css_properties.background.BackgroundHandler;
+const FallbackHandler = css.css_properties.prefix_handler.FallbackHandler;
+const MarginHandler = css.css_properties.margin_padding.MarginHandler;
+const PaddingHandler = css.css_properties.margin_padding.PaddingHandler;
+const ScrollMarginHandler = css.css_properties.margin_padding.ScrollMarginHandler;
+const InsetHandler = css.css_properties.margin_padding.InsetHandler;
+const SizeHandler = css.css_properties.size.SizeHandler;
+
+/// A CSS declaration block.
+///
+/// Properties are separated into a list of `!important` declararations,
+/// and a list of normal declarations. This reduces memory usage compared
+/// with storing a boolean along with each property.
+///
+/// TODO: multiarraylist will probably be faster here, as it makes one allocation
+/// instead of two.
+pub const DeclarationBlock = struct {
+    /// A list of `!important` declarations in the block.
+    important_declarations: ArrayList(css.Property) = .{},
+    /// A list of normal declarations in the block.
+    declarations: ArrayList(css.Property) = .{},
+
+    const This = @This();
+
+    const DebugFmt = struct {
+        self: *const DeclarationBlock,
+
+        pub fn format(this: @This(), comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
+            _ = fmt; // autofix
+            _ = options; // autofix
+            var arraylist = ArrayList(u8){};
+            const w = arraylist.writer(bun.default_allocator);
+            defer arraylist.deinit(bun.default_allocator);
+            var printer = css.Printer(@TypeOf(w)).new(bun.default_allocator, std.ArrayList(u8).init(bun.default_allocator), w, .{}, null);
+            defer printer.deinit();
+            this.self.toCss(@TypeOf(w), &printer) catch |e| return try writer.print("<error writing declaration block: {s}>\n", .{@errorName(e)});
+            try writer.writeAll(arraylist.items);
+        }
+    };
+
+    pub fn debug(this: *const @This()) DebugFmt {
+        return DebugFmt{ .self = this };
+    }
+
+    pub fn isEmpty(this: *const This) bool {
+        return this.declarations.items.len == 0 and this.important_declarations.items.len == 0;
+    }
+
+    pub fn parse(input: *css.Parser, options: *const css.ParserOptions) Result(DeclarationBlock) {
+        var important_declarations = DeclarationList{};
+        var declarations = DeclarationList{};
+        var decl_parser = PropertyDeclarationParser{
+            .important_declarations = &important_declarations,
+            .declarations = &declarations,
+            .options = options,
+        };
+        errdefer decl_parser.deinit();
+
+        var parser = css.RuleBodyParser(PropertyDeclarationParser).new(input, &decl_parser);
+
+        while (parser.next()) |res| {
+            if (res.asErr()) |e| {
+                if (options.error_recovery) {
+                    options.warn(e);
+                    continue;
+                }
+                return .{ .err = e };
+            }
+        }
+
+        return .{ .result = DeclarationBlock{
+            .important_declarations = important_declarations,
+            .declarations = declarations,
+        } };
+    }
+
+    pub fn len(this: *const DeclarationBlock) usize {
+        return this.declarations.items.len + this.important_declarations.items.len;
+    }
+
+    pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        const length = this.len();
+        var i: usize = 0;
+
+        const DECLS: []const []const u8 = &[_][]const u8{ "declarations", "important_declarations" };
+
+        inline for (DECLS) |decl_field_name| {
+            const decls = &@field(this, decl_field_name);
+            const is_important = comptime std.mem.eql(u8, decl_field_name, "important_declarations");
+
+            for (decls.items) |*decl| {
+                try decl.toCss(W, dest, is_important);
+                if (i != length - 1) {
+                    try dest.writeChar(';');
+                    try dest.whitespace();
+                }
+                i += 1;
+            }
+        }
+
+        return;
+    }
+
+    /// Writes the declarations to a CSS block, including starting and ending braces.
+    pub fn toCssBlock(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        try dest.whitespace();
+        try dest.writeChar('{');
+        dest.indent();
+
+        var i: usize = 0;
+        const length = this.len();
+
+        const DECLS: []const []const u8 = &[_][]const u8{ "declarations", "important_declarations" };
+
+        inline for (DECLS) |decl_field_name| {
+            const decls = &@field(this, decl_field_name);
+            const is_important = comptime std.mem.eql(u8, decl_field_name, "important_declarations");
+            for (decls.items) |*decl| {
+                try dest.newline();
+                try decl.toCss(W, dest, is_important);
+                if (i != length - 1 or !dest.minify) {
+                    try dest.writeChar(';');
+                }
+                i += 1;
+            }
+        }
+
+        dest.dedent();
+        try dest.newline();
+        return dest.writeChar('}');
+    }
+
+    pub fn minify(
+        this: *This,
+        handler: *DeclarationHandler,
+        important_handler: *DeclarationHandler,
+        context: *css.PropertyHandlerContext,
+    ) void {
+        const handle = struct {
+            inline fn handle(
+                self: *This,
+                ctx: *css.PropertyHandlerContext,
+                hndlr: *DeclarationHandler,
+                comptime decl_field: []const u8,
+                comptime important: bool,
+            ) void {
+                for (@field(self, decl_field).items) |*prop| {
+                    ctx.is_important = important;
+
+                    const handled = hndlr.handleProperty(prop, ctx);
+
+                    if (!handled) {
+                        hndlr.decls.append(ctx.allocator, prop.*) catch bun.outOfMemory();
+                        // replacing with a property which does not require allocation
+                        // to "delete"
+                        prop.* = css.Property{ .all = .@"revert-layer" };
+                    }
+                }
+            }
+        }.handle;
+
+        handle(this, context, important_handler, "important_declarations", true);
+        handle(this, context, handler, "declarations", false);
+
+        handler.finalize(context);
+        important_handler.finalize(context);
+        var old_import = this.important_declarations;
+        var old_declarations = this.declarations;
+        this.important_declarations = .{};
+        this.declarations = .{};
+        defer {
+            old_import.deinit(context.allocator);
+            old_declarations.deinit(context.allocator);
+        }
+        this.important_declarations = important_handler.decls;
+        this.declarations = handler.decls;
+        important_handler.decls = .{};
+        handler.decls = .{};
+    }
+
+    pub fn hashPropertyIds(this: *const @This(), hasher: *std.hash.Wyhash) void {
+        for (this.declarations.items) |*decl| {
+            decl.propertyId().hash(hasher);
+        }
+
+        for (this.important_declarations.items) |*decl| {
+            decl.propertyId().hash(hasher);
+        }
+    }
+
+    pub fn eql(this: *const This, other: *const This) bool {
+        return css.implementEql(@This(), this, other);
+    }
+
+    pub fn deepClone(this: *const This, allocator: std.mem.Allocator) This {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+pub const PropertyDeclarationParser = struct {
+    important_declarations: *ArrayList(css.Property),
+    declarations: *ArrayList(css.Property),
+    options: *const css.ParserOptions,
+
+    const This = @This();
+
+    pub const AtRuleParser = struct {
+        pub const Prelude = void;
+        pub const AtRule = void;
+
+        pub fn parsePrelude(_: *This, name: []const u8, input: *css.Parser) Result(Prelude) {
+            return .{
+                .err = input.newError(css.BasicParseErrorKind{ .at_rule_invalid = name }),
+            };
+        }
+
+        pub fn parseBlock(_: *This, _: Prelude, _: *const css.ParserState, input: *css.Parser) Result(AtRule) {
+            return .{ .err = input.newError(css.BasicParseErrorKind.at_rule_body_invalid) };
+        }
+
+        pub fn ruleWithoutBlock(_: *This, _: Prelude, _: *const css.ParserState) css.Maybe(AtRule, void) {
+            return .{ .err = {} };
+        }
+    };
+
+    pub const QualifiedRuleParser = struct {
+        pub const Prelude = void;
+        pub const QualifiedRule = void;
+
+        pub fn parsePrelude(this: *This, input: *css.Parser) Result(Prelude) {
+            _ = this; // autofix
+            return .{ .err = input.newError(css.BasicParseErrorKind.qualified_rule_invalid) };
+        }
+
+        pub fn parseBlock(this: *This, prelude: Prelude, start: *const css.ParserState, input: *css.Parser) Result(QualifiedRule) {
+            _ = this; // autofix
+            _ = prelude; // autofix
+            _ = start; // autofix
+            return .{ .err = input.newError(css.BasicParseErrorKind.qualified_rule_invalid) };
+        }
+    };
+
+    pub const DeclarationParser = struct {
+        pub const Declaration = void;
+
+        pub fn parseValue(this: *This, name: []const u8, input: *css.Parser) Result(Declaration) {
+            return parse_declaration(
+                name,
+                input,
+                this.declarations,
+                this.important_declarations,
+                this.options,
+            );
+        }
+    };
+
+    pub const RuleBodyItemParser = struct {
+        pub fn parseQualified(this: *This) bool {
+            _ = this; // autofix
+            return false;
+        }
+
+        pub fn parseDeclarations(this: *This) bool {
+            _ = this; // autofix
+            return true;
+        }
+    };
+};
+
+pub fn parse_declaration(
+    name: []const u8,
+    input: *css.Parser,
+    declarations: *DeclarationList,
+    important_declarations: *DeclarationList,
+    options: *const css.ParserOptions,
+) Result(void) {
+    const property_id = css.PropertyId.fromStr(name);
+    var delimiters = css.Delimiters{ .bang = true };
+    if (property_id != .custom or property_id.custom != .custom) {
+        delimiters.curly_bracket = true;
+    }
+    const Closure = struct {
+        property_id: css.PropertyId,
+        options: *const css.ParserOptions,
+    };
+    var closure = Closure{
+        .property_id = property_id,
+        .options = options,
+    };
+    const property = switch (input.parseUntilBefore(delimiters, css.Property, &closure, struct {
+        pub fn parseFn(this: *Closure, input2: *css.Parser) Result(css.Property) {
+            return css.Property.parse(this.property_id, input2, this.options);
+        }
+    }.parseFn)) {
+        .err => |e| return .{ .err = e },
+        .result => |v| v,
+    };
+    const important = input.tryParse(struct {
+        pub fn parsefn(i: *css.Parser) Result(void) {
+            if (i.expectDelim('!').asErr()) |e| return .{ .err = e };
+            return i.expectIdentMatching("important");
+        }
+    }.parsefn, .{}).isOk();
+    if (input.expectExhausted().asErr()) |e| return .{ .err = e };
+    if (important) {
+        important_declarations.append(input.allocator(), property) catch bun.outOfMemory();
+    } else {
+        declarations.append(input.allocator(), property) catch bun.outOfMemory();
+    }
+
+    return .{ .result = {} };
+}
+
+pub const DeclarationHandler = struct {
+    background: BackgroundHandler = .{},
+    size: SizeHandler = .{},
+    margin: MarginHandler = .{},
+    padding: PaddingHandler = .{},
+    scroll_margin: ScrollMarginHandler = .{},
+    inset: InsetHandler = .{},
+    fallback: FallbackHandler = .{},
+    direction: ?css.css_properties.text.Direction,
+    decls: DeclarationList,
+
+    pub fn finalize(this: *DeclarationHandler, context: *css.PropertyHandlerContext) void {
+        const allocator = context.allocator;
+        _ = allocator; // autofix
+        if (this.direction) |direction| {
+            this.direction = null;
+            this.decls.append(context.allocator, css.Property{ .direction = direction }) catch bun.outOfMemory();
+        }
+        // if (this.unicode_bidi) |unicode_bidi| {
+        //     this.unicode_bidi = null;
+        //     this.decls.append(context.allocator, css.Property{ .unicode_bidi = unicode_bidi }) catch bun.outOfMemory();
+        // }
+
+        this.background.finalize(&this.decls, context);
+        this.size.finalize(&this.decls, context);
+        this.margin.finalize(&this.decls, context);
+        this.padding.finalize(&this.decls, context);
+        this.scroll_margin.finalize(&this.decls, context);
+        this.inset.finalize(&this.decls, context);
+        this.fallback.finalize(&this.decls, context);
+    }
+
+    pub fn handleProperty(this: *DeclarationHandler, property: *const css.Property, context: *css.PropertyHandlerContext) bool {
+        // return this.background.handleProperty(property, &this.decls, context);
+        return this.background.handleProperty(property, &this.decls, context) or
+            this.size.handleProperty(property, &this.decls, context) or
+            this.margin.handleProperty(property, &this.decls, context) or
+            this.padding.handleProperty(property, &this.decls, context) or
+            this.scroll_margin.handleProperty(property, &this.decls, context) or
+            this.inset.handleProperty(property, &this.decls, context) or
+            this.fallback.handleProperty(property, &this.decls, context);
+    }
+
+    pub fn default() DeclarationHandler {
+        return .{
+            .decls = .{},
+            .direction = null,
+        };
+    }
+};
diff --git a/src/css/dependencies.zig b/src/css/dependencies.zig
new file mode 100644
index 0000000000..7d922244dd
--- /dev/null
+++ b/src/css/dependencies.zig
@@ -0,0 +1,155 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const bun = @import("root").bun;
+const logger = bun.logger;
+const Log = logger.Log;
+
+pub const css = @import("./css_parser.zig");
+pub const css_values = @import("./values/values.zig");
+const DashedIdent = css_values.ident.DashedIdent;
+const Url = css_values.url.Url;
+const Ident = css_values.ident.Ident;
+pub const Error = css.Error;
+// const Location = css.Location;
+
+const ArrayList = std.ArrayListUnmanaged;
+
+/// Options for `analyze_dependencies` in `PrinterOptions`.
+pub const DependencyOptions = struct {
+    /// Whether to remove `@import` rules.
+    remove_imports: bool,
+};
+
+/// A dependency.
+pub const Dependency = union(enum) {
+    /// An `@import` dependency.
+    import: ImportDependency,
+    /// A `url()` dependency.
+    url: UrlDependency,
+};
+
+/// A line and column position within a source file.
+pub const Location = struct {
+    /// The line number, starting from 1.
+    line: u32,
+    /// The column number, starting from 1.
+    column: u32,
+
+    pub fn fromSourceLocation(loc: css.SourceLocation) Location {
+        return Location{
+            .line = loc.line + 1,
+            .column = loc.column,
+        };
+    }
+
+    pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+        return css.implementHash(@This(), this, hasher);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+/// An `@import` dependency.
+pub const ImportDependency = struct {
+    /// The url to import.
+    url: []const u8,
+    /// The placeholder that the URL was replaced with.
+    placeholder: []const u8,
+    /// An optional `supports()` condition.
+    supports: ?[]const u8,
+    /// A media query.
+    media: ?[]const u8,
+    /// The location of the dependency in the source file.
+    loc: SourceRange,
+
+    pub fn new(allocator: Allocator, rule: *const css.css_rules.import.ImportRule, filename: []const u8) ImportDependency {
+        const supports = if (rule.supports) |*supports| brk: {
+            const s = css.to_css.string(
+                allocator,
+                css.css_rules.supports.SupportsCondition,
+                supports,
+                css.PrinterOptions{},
+                null,
+            ) catch bun.Output.panic(
+                "Unreachable code: failed to stringify SupportsCondition.\n\nThis is a bug in Bun's CSS printer. Please file a bug report at https://github.com/oven-sh/bun/issues/new/choose",
+                .{},
+            );
+            break :brk s;
+        } else null;
+
+        const media = if (rule.media.media_queries.items.len > 0) media: {
+            const s = css.to_css.string(allocator, css.MediaList, &rule.media, css.PrinterOptions{}, null) catch bun.Output.panic(
+                "Unreachable code: failed to stringify MediaList.\n\nThis is a bug in Bun's CSS printer. Please file a bug report at https://github.com/oven-sh/bun/issues/new/choose",
+                .{},
+            );
+            break :media s;
+        } else null;
+
+        const placeholder = css.css_modules.hash(allocator, "{s}_{s}", .{ filename, rule.url }, false);
+
+        return ImportDependency{
+            // TODO(zack): should we clone this? lightningcss does that
+            .url = rule.url,
+            .placeholder = placeholder,
+            .supports = supports,
+            .media = media,
+            .loc = SourceRange.new(
+                filename,
+                css.dependencies.Location{ .line = rule.loc.line + 1, .column = rule.loc.column },
+                8,
+                rule.url.len + 2,
+            ), // TODO: what about @import url(...)?
+        };
+    }
+};
+
+/// A `url()` dependency.
+pub const UrlDependency = struct {
+    /// The url of the dependency.
+    url: []const u8,
+    /// The placeholder that the URL was replaced with.
+    placeholder: []const u8,
+    /// The location of the dependency in the source file.
+    loc: SourceRange,
+
+    pub fn new(allocator: Allocator, url: *const Url, filename: []const u8, import_records: *const bun.BabyList(bun.ImportRecord)) UrlDependency {
+        const theurl = import_records.at(url.import_record_idx).path.pretty;
+        const placeholder = css.css_modules.hash(
+            allocator,
+            "{s}_{s}",
+            .{ filename, theurl },
+            false,
+        );
+        return UrlDependency{
+            .url = theurl,
+            .placeholder = placeholder,
+            .loc = SourceRange.new(filename, url.loc, 4, theurl.len),
+        };
+    }
+};
+
+/// Represents the range of source code where a dependency was found.
+pub const SourceRange = struct {
+    /// The filename in which the dependency was found.
+    file_path: []const u8,
+    /// The starting line and column position of the dependency.
+    start: Location,
+    /// The ending line and column position of the dependency.
+    end: Location,
+
+    pub fn new(filename: []const u8, loc: Location, offset: u32, len: usize) SourceRange {
+        return SourceRange{
+            .file_path = filename,
+            .start = Location{
+                .line = loc.line,
+                .column = loc.column + offset,
+            },
+            .end = Location{
+                .line = loc.line,
+                .column = loc.column + offset + @as(u32, @intCast(len)) - 1,
+            },
+        };
+    }
+};
diff --git a/src/css/error.zig b/src/css/error.zig
new file mode 100644
index 0000000000..b70281f28e
--- /dev/null
+++ b/src/css/error.zig
@@ -0,0 +1,392 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const bun = @import("root").bun;
+const logger = bun.logger;
+const Log = logger.Log;
+
+pub const css = @import("./css_parser.zig");
+pub const css_values = @import("./values/values.zig");
+const DashedIdent = css_values.ident.DashedIdent;
+const Ident = css_values.ident.Ident;
+pub const Error = css.Error;
+const Location = css.Location;
+
+const ArrayList = std.ArrayListUnmanaged;
+
+/// A printer error.
+pub const PrinterError = Err(PrinterErrorKind);
+
+pub fn fmtPrinterError() PrinterError {
+    return .{
+        .kind = .fmt_error,
+        .loc = null,
+    };
+}
+
+/// An error with a source location.
+pub fn Err(comptime T: type) type {
+    return struct {
+        /// The type of error that occurred.
+        kind: T,
+        /// The location where the error occurred.
+        loc: ?ErrorLocation,
+
+        pub fn fromParseError(err: ParseError(ParserError), filename: []const u8) Err(ParserError) {
+            if (T != ParserError) {
+                @compileError("Called .fromParseError() when T is not ParserError");
+            }
+
+            const kind = switch (err.kind) {
+                .basic => |b| switch (b) {
+                    .unexpected_token => |t| ParserError{ .unexpected_token = t },
+                    .end_of_input => ParserError.end_of_input,
+                    .at_rule_invalid => |a| ParserError{ .at_rule_invalid = a },
+                    .at_rule_body_invalid => ParserError.at_rule_body_invalid,
+                    .qualified_rule_invalid => ParserError.qualified_rule_invalid,
+                },
+                .custom => |c| c,
+            };
+
+            return .{
+                .kind = kind,
+                .loc = ErrorLocation{
+                    .filename = filename,
+                    .line = err.location.line,
+                    .column = err.location.column,
+                },
+            };
+        }
+
+        pub fn addToLogger(this: @This(), log: *logger.Log, source: *const logger.Source) !void {
+            try log.addMsg(.{
+                .kind = .err,
+                .data = .{
+                    .location = if (this.loc) |*loc| try loc.toLocation(source, log.msgs.allocator) else null,
+                    .text = try std.fmt.allocPrint(log.msgs.allocator, "{}", .{this.kind}),
+                },
+            });
+
+            log.errors += 1;
+        }
+    };
+}
+
+/// Extensible parse errors that can be encountered by client parsing implementations.
+pub fn ParseError(comptime T: type) type {
+    return struct {
+        /// Details of this error
+        kind: ParserErrorKind(T),
+        /// Location where this error occurred
+        location: css.SourceLocation,
+
+        pub fn basic(this: @This()) BasicParseError {
+            return switch (this.kind) {
+                .basic => |kind| BasicParseError{
+                    .kind = kind,
+                    .location = this.location,
+                },
+                .custom => @panic("Not a basic parse error. This is a bug in Bun's css parser."),
+            };
+        }
+    };
+}
+
+pub fn ParserErrorKind(comptime T: type) type {
+    return union(enum) {
+        /// A fundamental parse error from a built-in parsing routine.
+        basic: BasicParseErrorKind,
+        /// A parse error reported by downstream consumer code.
+        custom: T,
+
+        pub fn format(this: @This(), comptime formatter: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
+            return switch (this) {
+                inline else => |kind| try kind.format(formatter, options, writer),
+            };
+        }
+    };
+}
+
+/// Details about a `BasicParseError`
+pub const BasicParseErrorKind = union(enum) {
+    /// An unexpected token was encountered.
+    unexpected_token: css.Token,
+    /// The end of the input was encountered unexpectedly.
+    end_of_input,
+    /// An `@` rule was encountered that was invalid.
+    at_rule_invalid: []const u8,
+    /// The body of an '@' rule was invalid.
+    at_rule_body_invalid,
+    /// A qualified rule was encountered that was invalid.
+    qualified_rule_invalid,
+
+    pub fn format(this: BasicParseErrorKind, comptime fmt: []const u8, opts: std.fmt.FormatOptions, writer: anytype) !void {
+        _ = fmt; // autofix
+        _ = opts; // autofix
+        return switch (this) {
+            .unexpected_token => |token| {
+                try writer.print("unexpected token: {}", .{token});
+            },
+            .end_of_input => {
+                try writer.print("unexpected end of input", .{});
+            },
+            .at_rule_invalid => |rule| {
+                try writer.print("invalid @ rule encountered: '@{s}'", .{rule});
+            },
+            .at_rule_body_invalid => {
+                // try writer.print("invalid @ body rule encountered: '@{s}'", .{});
+                try writer.print("invalid @ body rule encountered", .{});
+            },
+            .qualified_rule_invalid => {
+                try writer.print("invalid qualified rule encountered", .{});
+            },
+        };
+    }
+};
+
+/// A line and column location within a source file.
+pub const ErrorLocation = struct {
+    /// The filename in which the error occurred.
+    filename: []const u8,
+    /// The line number, starting from 0.
+    line: u32,
+    /// The column number, starting from 1.
+    column: u32,
+
+    pub fn withFilename(this: ErrorLocation, filename: []const u8) ErrorLocation {
+        return ErrorLocation{
+            .filename = filename,
+            .line = this.line,
+            .column = this.column,
+        };
+    }
+
+    pub fn format(this: *const @This(), comptime _: []const u8, _: std.fmt.FormatOptions, writer: anytype) !void {
+        try writer.print("{s}:{d}:{d}", .{ this.filename, this.line, this.column });
+    }
+
+    pub fn toLocation(this: @This(), source: *const logger.Source, allocator: Allocator) !logger.Location {
+        return logger.Location{
+            .file = source.path.text,
+            .namespace = source.path.namespace,
+            .line = @intCast(this.line + 1),
+            .column = @intCast(this.column),
+            .line_text = if (bun.strings.getLinesInText(source.contents, this.line, 1)) |lines| try allocator.dupe(u8, lines.buffer[0]) else null,
+        };
+    }
+};
+
+/// A printer error type.
+pub const PrinterErrorKind = union(enum) {
+    /// An ambiguous relative `url()` was encountered in a custom property declaration.
+    ambiguous_url_in_custom_property: struct {
+        /// The ambiguous URL.
+        url: []const u8,
+    },
+    /// A [std::fmt::Error](std::fmt::Error) was encountered in the underlying destination.
+    fmt_error,
+    /// The CSS modules `composes` property cannot be used within nested rules.
+    invalid_composes_nesting,
+    /// The CSS modules `composes` property cannot be used with a simple class selector.
+    invalid_composes_selector,
+    /// The CSS modules pattern must end with `[local]` for use in CSS grid.
+    invalid_css_modules_pattern_in_grid,
+    no_import_records,
+};
+
+/// A parser error.
+pub const ParserError = union(enum) {
+    /// An at rule body was invalid.
+    at_rule_body_invalid,
+    /// An at rule prelude was invalid.
+    at_rule_prelude_invalid,
+    /// An unknown or unsupported at rule was encountered.
+    at_rule_invalid: []const u8,
+    /// Unexpectedly encountered the end of input data.
+    end_of_input,
+    /// A declaration was invalid.
+    invalid_declaration,
+    /// A media query was invalid.
+    invalid_media_query,
+    /// Invalid CSS nesting.
+    invalid_nesting,
+    /// The @nest rule is deprecated.
+    deprecated_nest_rule,
+    /// An invalid selector in an `@page` rule.
+    invalid_page_selector,
+    /// An invalid value was encountered.
+    invalid_value,
+    /// Invalid qualified rule.
+    qualified_rule_invalid,
+    /// A selector was invalid.
+    selector_error: SelectorError,
+    /// An `@import` rule was encountered after any rule besides `@charset` or `@layer`.
+    unexpected_import_rule,
+    /// A `@namespace` rule was encountered after any rules besides `@charset`, `@import`, or `@layer`.
+    unexpected_namespace_rule,
+    /// An unexpected token was encountered.
+    unexpected_token: css.Token,
+    /// Maximum nesting depth was reached.
+    maximum_nesting_depth,
+
+    pub fn format(this: @This(), comptime _: []const u8, _: std.fmt.FormatOptions, writer: anytype) !void {
+        return switch (this) {
+            .at_rule_body_invalid => writer.writeAll("Invalid at-rule body"),
+            .at_rule_prelude_invalid => writer.writeAll("Invalid at-rule prelude"),
+            .at_rule_invalid => |name| writer.print("Unknown at-rule @{s}", .{name}),
+            .end_of_input => writer.writeAll("Unexpected end of input"),
+            .invalid_declaration => writer.writeAll("Invalid declaration"),
+            .invalid_media_query => writer.writeAll("Invalid media query"),
+            .invalid_nesting => writer.writeAll("Invalid CSS nesting"),
+            .deprecated_nest_rule => writer.writeAll("The @nest rule is deprecated, use standard CSS nesting instead"),
+            .invalid_page_selector => writer.writeAll("Invalid @page selector"),
+            .invalid_value => writer.writeAll("Invalid value"),
+            .qualified_rule_invalid => writer.writeAll("Invalid qualified rule"),
+            .selector_error => |err| writer.print("Invalid selector. {s}", .{err}),
+            .unexpected_import_rule => writer.writeAll("@import rules must come before any other rules except @charset and @layer"),
+            .unexpected_namespace_rule => writer.writeAll("@namespace rules must come before any other rules except @charset, @import, and @layer"),
+            .unexpected_token => |token| writer.print("Unexpected token. {}", .{token}),
+            .maximum_nesting_depth => writer.writeAll("Maximum CSS nesting depth exceeded"),
+        };
+    }
+};
+
+/// The fundamental parsing errors that can be triggered by built-in parsing routines.
+pub const BasicParseError = struct {
+    /// Details of this error
+    kind: BasicParseErrorKind,
+    /// Location where this error occurred
+    location: css.SourceLocation,
+
+    pub fn intoParseError(
+        this: @This(),
+        comptime T: type,
+    ) ParseError(T) {
+        return ParseError(T){
+            .kind = .{ .basic = this.kind },
+            .location = this.location,
+        };
+    }
+
+    pub inline fn intoDefaultParseError(
+        this: @This(),
+    ) ParseError(ParserError) {
+        return ParseError(ParserError){
+            .kind = .{ .basic = this.kind },
+            .location = this.location,
+        };
+    }
+};
+
+/// A selector parsing error.
+pub const SelectorError = union(enum) {
+    /// An unexpected token was found in an attribute selector.
+    bad_value_in_attr: css.Token,
+    /// An unexpected token was found in a class selector.
+    class_needs_ident: css.Token,
+    /// A dangling combinator was found.
+    dangling_combinator,
+    /// An empty selector.
+    empty_selector,
+    /// A `|` was expected in an attribute selector.
+    expected_bar_in_attr: css.Token,
+    /// A namespace was expected.
+    expected_namespace: []const u8,
+    /// An unexpected token was encountered in a namespace.
+    explicit_namespace_unexpected_token: css.Token,
+    /// An invalid pseudo class was encountered after a pseudo element.
+    invalid_pseudo_class_after_pseudo_element,
+    /// An invalid pseudo class was encountered after a `-webkit-scrollbar` pseudo element.
+    invalid_pseudo_class_after_webkit_scrollbar,
+    /// A `-webkit-scrollbar` state was encountered before a `-webkit-scrollbar` pseudo element.
+    invalid_pseudo_class_before_webkit_scrollbar,
+    /// Invalid qualified name in attribute selector.
+    invalid_qual_name_in_attr: css.Token,
+    /// The current token is not allowed in this state.
+    invalid_state,
+    /// The selector is required to have the `&` nesting selector at the start.
+    missing_nesting_prefix,
+    /// The selector is missing a `&` nesting selector.
+    missing_nesting_selector,
+    /// No qualified name in attribute selector.
+    no_qualified_name_in_attribute_selector: css.Token,
+    /// An invalid token was encountered in a pseudo element.
+    pseudo_element_expected_ident: css.Token,
+    /// An unexpected identifier was encountered.
+    unexpected_ident: []const u8,
+    /// An unexpected token was encountered inside an attribute selector.
+    unexpected_token_in_attribute_selector: css.Token,
+    /// An unsupported pseudo class or pseudo element was encountered.
+    unsupported_pseudo_class_or_element: []const u8,
+    unexpected_selector_after_pseudo_element: css.Token,
+
+    pub fn format(this: @This(), comptime _: []const u8, _: std.fmt.FormatOptions, writer: anytype) !void {
+        return switch (this) {
+            .dangling_combinator => try writer.writeAll("Found a dangling combinator with no selector"),
+            .empty_selector => try writer.writeAll("Empty selector is not allowed"),
+            .invalid_state => try writer.writeAll("Token is not allowed in this state"),
+            .missing_nesting_prefix => try writer.writeAll("Selector must start with the '&' nesting selector"),
+            .missing_nesting_selector => try writer.writeAll("Missing '&' nesting selector"),
+            .invalid_pseudo_class_after_pseudo_element => try writer.writeAll("Invalid pseudo-class after pseudo-element"),
+            .invalid_pseudo_class_after_webkit_scrollbar => try writer.writeAll("Invalid pseudo-class after -webkit-scrollbar"),
+            .invalid_pseudo_class_before_webkit_scrollbar => try writer.writeAll("-webkit-scrollbar state found before -webkit-scrollbar pseudo-element"),
+
+            .expected_namespace => |str| try writer.print("Expected namespace '{s}'", .{str}),
+            .unexpected_ident => |str| try writer.print("Unexpected identifier '{s}'", .{str}),
+            .unsupported_pseudo_class_or_element => |str| try writer.print("Unsupported pseudo-class or pseudo-element '{s}'", .{str}),
+
+            .bad_value_in_attr => |tok| try writer.print("Invalid value in attribute selector: {}", .{tok}),
+            .class_needs_ident => |tok| try writer.print("Expected identifier after '.' in class selector, found: {}", .{tok}),
+            .expected_bar_in_attr => |tok| try writer.print("Expected '|' in attribute selector, found: {}", .{tok}),
+            .explicit_namespace_unexpected_token => |tok| try writer.print("Unexpected token in namespace: {}", .{tok}),
+            .invalid_qual_name_in_attr => |tok| try writer.print("Invalid qualified name in attribute selector: {}", .{tok}),
+            .no_qualified_name_in_attribute_selector => |tok| try writer.print("Missing qualified name in attribute selector: {}", .{tok}),
+            .pseudo_element_expected_ident => |tok| try writer.print("Expected identifier in pseudo-element, found: {}", .{tok}),
+            .unexpected_token_in_attribute_selector => |tok| try writer.print("Unexpected token in attribute selector: {}", .{tok}),
+            .unexpected_selector_after_pseudo_element => |tok| try writer.print("Unexpected selector after pseudo-element: {}", .{tok}),
+        };
+    }
+};
+
+pub fn ErrorWithLocation(comptime T: type) type {
+    return struct {
+        kind: T,
+        loc: css.Location,
+    };
+}
+
+pub const MinifyErr = error{
+    minify_err,
+};
+pub const MinifyError = ErrorWithLocation(MinifyErrorKind);
+/// A transformation error.
+pub const MinifyErrorKind = union(enum) {
+    /// A circular `@custom-media` rule was detected.
+    circular_custom_media: struct {
+        /// The name of the `@custom-media` rule that was referenced circularly.
+        name: []const u8,
+    },
+    /// Attempted to reference a custom media rule that doesn't exist.
+    custom_media_not_defined: struct {
+        /// The name of the `@custom-media` rule that was not defined.
+        name: []const u8,
+    },
+    /// Boolean logic with media types in @custom-media rules is not supported.
+    unsupported_custom_media_boolean_logic: struct {
+        /// The source location of the `@custom-media` rule with unsupported boolean logic.
+        custom_media_loc: Location,
+    },
+
+    pub fn format(this: *const @This(), comptime _: []const u8, _: anytype, writer: anytype) !void {
+        return switch (this.*) {
+            .circular_custom_media => |name| try writer.print("Circular @custom-media rule: \"{s}\"", .{name.name}),
+            .custom_media_not_defined => |name| try writer.print("Custom media rule \"{s}\" not defined", .{name.name}),
+            .unsupported_custom_media_boolean_logic => |custom_media_loc| try writer.print(
+                "Unsupported boolean logic in custom media rule at line {d}, column {d}",
+                .{
+                    custom_media_loc.custom_media_loc.line,
+                    custom_media_loc.custom_media_loc.column,
+                },
+            ),
+        };
+    }
+};
diff --git a/src/css/generics.zig b/src/css/generics.zig
new file mode 100644
index 0000000000..7dc3a08878
--- /dev/null
+++ b/src/css/generics.zig
@@ -0,0 +1,425 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const bun = @import("root").bun;
+const logger = bun.logger;
+const Log = logger.Log;
+
+const ArrayList = std.ArrayListUnmanaged;
+
+const css = @import("./css_parser.zig");
+const css_values = css.css_values;
+
+const Parser = css.Parser;
+const ParserOptions = css.ParserOptions;
+const Result = css.Result;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const CSSNumber = css.CSSNumber;
+const CSSNumberFns = css.CSSNumberFns;
+const CSSInteger = css.CSSInteger;
+const CSSIntegerFns = css.CSSIntegerFns;
+const CustomIdent = css.CustomIdent;
+const CustomIdentFns = css.CustomIdentFns;
+const DashedIdent = css.DashedIdent;
+const DashedIdentFns = css.DashedIdentFns;
+const Ident = css.Ident;
+const IdentFns = css.IdentFns;
+
+pub inline fn parseWithOptions(comptime T: type, input: *Parser, options: *const ParserOptions) Result(T) {
+    if (T != f32 and T != i32 and @hasDecl(T, "parseWithOptions")) return T.parseWithOptions(input, options);
+    if (comptime bun.meta.looksLikeListContainerType(T)) |result| {
+        switch (result.list) {
+            .array_list => return input.parseCommaSeparated(result.child, parseFor(result.child)),
+            .baby_list => {},
+            .small_list => {},
+        }
+    }
+    return switch (T) {
+        f32 => CSSNumberFns.parse(input),
+        CSSInteger => CSSIntegerFns.parse(input),
+        CustomIdent => CustomIdentFns.parse(input),
+        DashedIdent => DashedIdentFns.parse(input),
+        Ident => IdentFns.parse(input),
+        else => T.parse(input),
+    };
+}
+
+pub inline fn parse(comptime T: type, input: *Parser) Result(T) {
+    if (comptime @typeInfo(T) == .Pointer) {
+        const TT = std.meta.Child(T);
+        return switch (parse(TT, input)) {
+            .result => |v| .{ .result = bun.create(input.allocator(), TT, v) },
+            .err => |e| .{ .err = e },
+        };
+    }
+    if (comptime @typeInfo(T) == .Optional) {
+        const TT = std.meta.Child(T);
+        return .{ .result = parse(TT, input).asValue() };
+    }
+    if (comptime bun.meta.looksLikeListContainerType(T)) |result| {
+        switch (result.list) {
+            .array_list => return input.parseCommaSeparated(result.child, parseFor(result.child)),
+            .baby_list => {},
+            .small_list => {},
+        }
+    }
+    return switch (T) {
+        f32 => CSSNumberFns.parse(input),
+        CSSInteger => CSSIntegerFns.parse(input),
+        CustomIdent => CustomIdentFns.parse(input),
+        DashedIdent => DashedIdentFns.parse(input),
+        Ident => IdentFns.parse(input),
+        else => T.parse(input),
+    };
+}
+
+pub inline fn parseFor(comptime T: type) @TypeOf(struct {
+    fn parsefn(input: *Parser) Result(T) {
+        return parse(T, input);
+    }
+}.parsefn) {
+    return struct {
+        fn parsefn(input: *Parser) Result(T) {
+            return parse(T, input);
+        }
+    }.parsefn;
+}
+
+pub fn hasToCss(comptime T: type) bool {
+    const tyinfo = @typeInfo(T);
+    if (comptime T == []const u8) return false;
+    if (tyinfo == .Pointer) {
+        const TT = std.meta.Child(T);
+        return hasToCss(TT);
+    }
+    if (tyinfo == .Optional) {
+        const TT = std.meta.Child(T);
+        return hasToCss(TT);
+    }
+    if (comptime bun.meta.looksLikeListContainerType(T)) |result| {
+        switch (result.list) {
+            .array_list => return true,
+            .baby_list => return true,
+            .small_list => return true,
+        }
+    }
+    return switch (T) {
+        f32 => true,
+        else => @hasDecl(T, "toCss"),
+    };
+}
+
+pub inline fn toCss(comptime T: type, this: *const T, comptime W: type, dest: *Printer(W)) PrintErr!void {
+    if (@typeInfo(T) == .Pointer) {
+        const TT = std.meta.Child(T);
+        return toCss(TT, this.*, W, dest);
+    }
+    if (@typeInfo(T) == .Optional) {
+        const TT = std.meta.Child(T);
+
+        if (this.*) |*val| {
+            return toCss(TT, val, W, dest);
+        }
+        return;
+    }
+    if (comptime bun.meta.looksLikeListContainerType(T)) |result| {
+        switch (result.list) {
+            .array_list => {
+                return css.to_css.fromList(result.child, this, W, dest);
+            },
+            .baby_list => {},
+            .small_list => {},
+        }
+    }
+    return switch (T) {
+        f32 => CSSNumberFns.toCss(this, W, dest),
+        CSSInteger => CSSIntegerFns.toCss(this, W, dest),
+        CustomIdent => CustomIdentFns.toCss(this, W, dest),
+        DashedIdent => DashedIdentFns.toCss(this, W, dest),
+        Ident => IdentFns.toCss(this, W, dest),
+        else => T.toCss(this, W, dest),
+    };
+}
+
+pub fn eqlList(comptime T: type, lhs: *const ArrayList(T), rhs: *const ArrayList(T)) bool {
+    if (lhs.items.len != rhs.items.len) return false;
+    for (lhs.items, 0..) |*item, i| {
+        if (!eql(T, item, &rhs.items[i])) return false;
+    }
+    return true;
+}
+
+pub fn canTransitivelyImplementEql(comptime T: type) bool {
+    return switch (@typeInfo(T)) {
+        .Struct, .Union => true,
+        else => false,
+    };
+}
+
+pub inline fn eql(comptime T: type, lhs: *const T, rhs: *const T) bool {
+    const tyinfo = comptime @typeInfo(T);
+    if (comptime tyinfo == .Pointer) {
+        if (comptime T == []const u8) return bun.strings.eql(lhs.*, rhs.*);
+        if (comptime tyinfo.Pointer.size == .One) {
+            const TT = std.meta.Child(T);
+            return eql(TT, lhs.*, rhs.*);
+        } else if (comptime tyinfo.Pointer.size == .Slice) {
+            if (lhs.*.len != rhs.*.len) return false;
+            for (lhs.*[0..], rhs.*[0..]) |*a, *b| {
+                if (!eql(tyinfo.Pointer.child, a, b)) return false;
+            }
+            return true;
+        } else {
+            @compileError("Unsupported pointer size: " ++ @tagName(tyinfo.Pointer.size) ++ " (" ++ @typeName(T) ++ ")");
+        }
+    }
+    if (comptime tyinfo == .Optional) {
+        const TT = std.meta.Child(T);
+        if (lhs.* != null and rhs.* != null) return eql(TT, &lhs.*.?, &rhs.*.?);
+        return false;
+    }
+    if (comptime bun.meta.isSimpleEqlType(T)) {
+        return lhs.* == rhs.*;
+    }
+    if (comptime bun.meta.looksLikeListContainerType(T)) |result| {
+        return switch (result.list) {
+            .array_list => eqlList(result.child, lhs, rhs),
+            .baby_list => return lhs.eql(rhs),
+            .small_list => lhs.eql(rhs),
+        };
+    }
+    return switch (T) {
+        f32 => lhs.* == rhs.*,
+        CSSInteger => lhs.* == rhs.*,
+        CustomIdent, DashedIdent, Ident => bun.strings.eql(lhs.v, rhs.v),
+        []const u8 => bun.strings.eql(lhs.*, rhs.*),
+        css.VendorPrefix => css.VendorPrefix.eq(lhs.*, rhs.*),
+        else => T.eql(lhs, rhs),
+    };
+}
+
+pub fn canTransitivelyImplementDeepClone(comptime T: type) bool {
+    return switch (@typeInfo(T)) {
+        .Struct, .Union => true,
+        else => false,
+    };
+}
+
+pub inline fn deepClone(comptime T: type, this: *const T, allocator: Allocator) T {
+    const tyinfo = comptime @typeInfo(T);
+    if (comptime tyinfo == .Pointer) {
+        if (comptime tyinfo.Pointer.size == .One) {
+            const TT = std.meta.Child(T);
+            return bun.create(allocator, TT, deepClone(TT, this.*, allocator));
+        }
+        if (comptime tyinfo.Pointer.size == .Slice) {
+            var slice = allocator.alloc(tyinfo.Pointer.child, this.len) catch bun.outOfMemory();
+            if (comptime bun.meta.isSimpleCopyType(tyinfo.Pointer.child) or tyinfo.Pointer.child == []const u8) {
+                @memcpy(slice, this.*);
+            } else {
+                for (this.*, 0..) |*e, i| {
+                    slice[i] = deepClone(tyinfo.Pointer.child, e, allocator);
+                }
+            }
+            return slice;
+        }
+        @compileError("Deep clone not supported for this kind of pointer: " ++ @tagName(tyinfo.Pointer.size) ++ " (" ++ @typeName(T) ++ ")");
+    }
+    if (comptime tyinfo == .Optional) {
+        const TT = std.meta.Child(T);
+        if (this.* != null) return deepClone(TT, &this.*.?, allocator);
+        return null;
+    }
+    if (comptime bun.meta.isSimpleCopyType(T)) {
+        return this.*;
+    }
+    if (comptime bun.meta.looksLikeListContainerType(T)) |result| {
+        return switch (result.list) {
+            .array_list => css.deepClone(result.child, allocator, this),
+            .baby_list => {
+                var ret = bun.BabyList(result.child){
+                    .ptr = (allocator.alloc(result.child, this.len) catch bun.outOfMemory()).ptr,
+                    .len = this.len,
+                    .cap = this.len,
+                };
+                for (this.sliceConst(), ret.ptr[0..this.len]) |*old, *new| {
+                    new.* = bun.css.generic.deepClone(result.child, old, allocator);
+                }
+                return ret;
+            },
+            .small_list => this.deepClone(allocator),
+        };
+    }
+    // Strings in the CSS parser are always arena allocated
+    // So it is safe to skip const strings as they will never be mutated
+    if (comptime T == []const u8) {
+        return this.*;
+    }
+
+    if (!@hasDecl(T, "deepClone")) {
+        @compileError(@typeName(T) ++ " does not have a deepClone() function");
+    }
+
+    return T.deepClone(this, allocator);
+}
+
+const Angle = css_values.angle.Angle;
+pub inline fn tryFromAngle(comptime T: type, angle: Angle) ?T {
+    return switch (T) {
+        CSSNumber => CSSNumberFns.tryFromAngle(angle),
+        Angle => return Angle.tryFromAngle(angle),
+        else => T.tryFromAngle(angle),
+    };
+}
+
+pub inline fn trySign(comptime T: type, val: *const T) ?f32 {
+    return switch (T) {
+        CSSNumber => CSSNumberFns.sign(val),
+        else => {
+            if (@hasDecl(T, "sign")) return T.sign(val);
+            return T.trySign(val);
+        },
+    };
+}
+
+pub inline fn tryMap(
+    comptime T: type,
+    val: *const T,
+    comptime map_fn: *const fn (a: f32) f32,
+) ?T {
+    return switch (T) {
+        CSSNumber => map_fn(val.*),
+        else => {
+            if (@hasDecl(T, "map")) return T.map(val, map_fn);
+            return T.tryMap(val, map_fn);
+        },
+    };
+}
+
+pub inline fn tryOpTo(
+    comptime T: type,
+    comptime R: type,
+    lhs: *const T,
+    rhs: *const T,
+    ctx: anytype,
+    comptime op_fn: *const fn (@TypeOf(ctx), a: f32, b: f32) R,
+) ?R {
+    return switch (T) {
+        CSSNumber => op_fn(ctx, lhs.*, rhs.*),
+        else => {
+            if (@hasDecl(T, "opTo")) return T.opTo(lhs, rhs, R, ctx, op_fn);
+            return T.tryOpTo(lhs, rhs, R, ctx, op_fn);
+        },
+    };
+}
+
+pub inline fn tryOp(
+    comptime T: type,
+    lhs: *const T,
+    rhs: *const T,
+    ctx: anytype,
+    comptime op_fn: *const fn (@TypeOf(ctx), a: f32, b: f32) f32,
+) ?T {
+    return switch (T) {
+        Angle => Angle.tryOp(lhs, rhs, ctx, op_fn),
+        CSSNumber => op_fn(ctx, lhs.*, rhs.*),
+        else => {
+            if (@hasDecl(T, "op")) return T.op(lhs, rhs, ctx, op_fn);
+            return T.tryOp(lhs, rhs, ctx, op_fn);
+        },
+    };
+}
+
+pub inline fn partialCmp(comptime T: type, lhs: *const T, rhs: *const T) ?std.math.Order {
+    return switch (T) {
+        f32 => partialCmpF32(lhs, rhs),
+        CSSInteger => std.math.order(lhs.*, rhs.*),
+        css_values.angle.Angle => css_values.angle.Angle.partialCmp(lhs, rhs),
+        else => T.partialCmp(lhs, rhs),
+    };
+}
+
+pub inline fn partialCmpF32(lhs: *const f32, rhs: *const f32) ?std.math.Order {
+    const lte = lhs.* <= rhs.*;
+    const rte = lhs.* >= rhs.*;
+    if (!lte and !rte) return null;
+    if (!lte and rte) return .gt;
+    if (lte and !rte) return .lt;
+    return .eq;
+}
+
+pub const HASH_SEED: u64 = 0;
+
+pub fn hashArrayList(comptime V: type, this: *const ArrayList(V), hasher: *std.hash.Wyhash) void {
+    for (this.items) |*item| {
+        hash(V, item, hasher);
+    }
+}
+pub fn hashBabyList(comptime V: type, this: *const bun.BabyList(V), hasher: *std.hash.Wyhash) void {
+    for (this.sliceConst()) |*item| {
+        hash(V, item, hasher);
+    }
+}
+
+pub fn hasHash(comptime T: type) bool {
+    const tyinfo = @typeInfo(T);
+    if (comptime T == []const u8) return true;
+    if (comptime bun.meta.isSimpleEqlType(T)) return true;
+    if (tyinfo == .Pointer) {
+        const TT = std.meta.Child(T);
+        return hasHash(TT);
+    }
+    if (tyinfo == .Optional) {
+        const TT = std.meta.Child(T);
+        return hasHash(TT);
+    }
+    if (comptime bun.meta.looksLikeListContainerType(T)) |result| {
+        switch (result.list) {
+            .array_list => return true,
+            .baby_list => return true,
+            .small_list => return true,
+        }
+    }
+    return switch (T) {
+        else => @hasDecl(T, "hash"),
+    };
+}
+
+pub fn hash(comptime T: type, this: *const T, hasher: *std.hash.Wyhash) void {
+    if (comptime T == void) return;
+    const tyinfo = @typeInfo(T);
+    if (comptime tyinfo == .Pointer and T != []const u8) {
+        const TT = std.meta.Child(T);
+        if (tyinfo.Pointer.size == .One) {
+            return hash(TT, this.*, hasher);
+        } else if (tyinfo.Pointer.size == .Slice) {
+            for (this.*) |*item| {
+                hash(TT, item, hasher);
+            }
+            return;
+        } else {
+            @compileError("Can't hash this pointer type: " ++ @typeName(T));
+        }
+    }
+    if (comptime @typeInfo(T) == .Optional) {
+        const TT = std.meta.Child(T);
+        if (this.* != null) return hash(TT, &this.*.?, hasher);
+        return;
+    }
+    if (comptime bun.meta.looksLikeListContainerType(T)) |result| {
+        switch (result.list) {
+            .array_list => return hashArrayList(result.child, this, hasher),
+            .baby_list => return hashBabyList(result.child, this, hasher),
+            .small_list => return this.hash(hasher),
+        }
+    }
+    if (comptime bun.meta.isSimpleEqlType(T)) {
+        const bytes = std.mem.asBytes(&this);
+        hasher.update(bytes);
+        return;
+    }
+    return switch (T) {
+        []const u8 => hasher.update(this.*),
+        else => T.hash(this, hasher),
+    };
+}
diff --git a/src/css/logical.zig b/src/css/logical.zig
new file mode 100644
index 0000000000..adcbf8a346
--- /dev/null
+++ b/src/css/logical.zig
@@ -0,0 +1,34 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const bun = @import("root").bun;
+const logger = bun.logger;
+const Log = logger.Log;
+
+pub const css = @import("./css_parser.zig");
+pub const Error = css.Error;
+
+const ArrayList = std.ArrayListUnmanaged;
+
+pub const PropertyCategory = enum {
+    logical,
+    physical,
+
+    pub fn default() PropertyCategory {
+        return .physical;
+    }
+};
+
+pub const LogicalGroup = enum {
+    border_color,
+    border_style,
+    border_width,
+    border_radius,
+    margin,
+    scroll_margin,
+    padding,
+    scroll_padding,
+    inset,
+    size,
+    min_size,
+    max_size,
+};
diff --git a/src/css/media_query.zig b/src/css/media_query.zig
new file mode 100644
index 0000000000..1f56da703e
--- /dev/null
+++ b/src/css/media_query.zig
@@ -0,0 +1,1518 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const bun = @import("root").bun;
+const logger = bun.logger;
+const Log = logger.Log;
+
+pub const css = @import("./css_parser.zig");
+pub const Error = css.Error;
+const ArrayList = std.ArrayListUnmanaged;
+
+const Length = css.css_values.length.Length;
+const CSSNumber = css.css_values.number.CSSNumber;
+const Integer = css.css_values.number.Integer;
+const CSSNumberFns = css.css_values.number.CSSNumberFns;
+const CSSInteger = css.css_values.number.CSSInteger;
+const CSSIntegerFns = css.css_values.number.CSSIntegerFns;
+const Resolution = css.css_values.resolution.Resolution;
+const Ratio = css.css_values.ratio.Ratio;
+const Ident = css.css_values.ident.Ident;
+const IdentFns = css.css_values.ident.IdentFns;
+const EnvironmentVariable = css.css_properties.custom.EnvironmentVariable;
+const DashedIdent = css.css_values.ident.DashedIdent;
+const DashedIdentFns = css.css_values.ident.DashedIdentFns;
+
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const PrintResult = css.PrintResult;
+const Result = css.Result;
+
+pub fn ValidQueryCondition(comptime T: type) void {
+    //   fn parse_feature<'t>(input: &mut Parser<'i, 't>) -> Result<Self, ParseError<'i, ParserError<'i>>>;
+    _ = T.parseFeature;
+    //   fn create_negation(condition: Box<Self>) -> Self;
+    _ = T.createNegation;
+    //   fn create_operation(operator: Operator, conditions: Vec<Self>) -> Self;
+    _ = T.createOperation;
+    //   fn parse_style_query<'t>(input: &mut Parser<'i, 't>) -> Result<Self, ParseError<'i, ParserError<'i>>> {
+    _ = T.parseStyleQuery;
+    //   fn needs_parens(&self, parent_operator: Option<Operator>, targets: &Targets) -> bool;
+    _ = T.needsParens;
+}
+
+/// A [media query list](https://drafts.csswg.org/mediaqueries/#mq-list).
+pub const MediaList = struct {
+    /// The list of media queries.
+    media_queries: ArrayList(MediaQuery) = .{},
+
+    /// Parse a media query list from CSS.
+    pub fn parse(input: *css.Parser) Result(MediaList) {
+        var media_queries = ArrayList(MediaQuery){};
+        while (true) {
+            const mq = switch (input.parseUntilBefore(css.Delimiters{ .comma = true }, MediaQuery, {}, css.voidWrap(MediaQuery, MediaQuery.parse))) {
+                .result => |v| v,
+                .err => |e| {
+                    if (e.kind == .basic and e.kind.basic == .end_of_input) break;
+                    return .{ .err = e };
+                },
+            };
+            media_queries.append(input.allocator(), mq) catch bun.outOfMemory();
+
+            if (input.next().asValue()) |tok| {
+                if (tok.* != .comma) {
+                    bun.Output.panic("Unreachable code: expected a comma after parsing a MediaQuery.\n\nThis is a bug in Bun's CSS parser. Please file a bug report at https://github.com/oven-sh/bun/issues/new/choose", .{});
+                }
+            } else break;
+        }
+
+        return .{ .result = MediaList{ .media_queries = media_queries } };
+    }
+
+    pub fn toCss(this: *const MediaList, comptime W: type, dest: *css.Printer(W)) PrintErr!void {
+        if (this.media_queries.items.len == 0) {
+            return dest.writeStr("not all");
+        }
+
+        var first = true;
+        for (this.media_queries.items) |*query| {
+            if (!first) {
+                try dest.delim(',', false);
+            }
+            first = false;
+            try query.toCss(W, dest);
+        }
+        return;
+    }
+
+    pub fn eql(lhs: *const MediaList, rhs: *const MediaList) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn deepClone(this: *const MediaList, allocator: std.mem.Allocator) MediaList {
+        return MediaList{
+            .media_queries = css.deepClone(MediaQuery, allocator, &this.media_queries),
+        };
+    }
+
+    /// Returns whether the media query list always matches.
+    pub fn alwaysMatches(this: *const MediaList) bool {
+        // If the media list is empty, it always matches.
+        return this.media_queries.items.len == 0 or brk: {
+            for (this.media_queries.items) |*query| {
+                if (!query.alwaysMatches()) break :brk false;
+            }
+            break :brk true;
+        };
+    }
+};
+
+/// A binary `and` or `or` operator.
+pub const Operator = enum {
+    /// The `and` operator.
+    @"and",
+    /// The `or` operator.
+    @"or",
+
+    pub fn asStr(this: *const @This()) []const u8 {
+        return css.enum_property_util.asStr(@This(), this);
+    }
+
+    pub fn parse(input: *css.Parser) Result(@This()) {
+        return css.enum_property_util.parse(@This(), input);
+    }
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+        return css.enum_property_util.toCss(@This(), this, W, dest);
+    }
+};
+
+/// A [media query](https://drafts.csswg.org/mediaqueries/#media).
+pub const MediaQuery = struct {
+    /// The qualifier for this query.
+    qualifier: ?Qualifier,
+    /// The media type for this query, that can be known, unknown, or "all".
+    media_type: MediaType,
+    /// The condition that this media query contains. This cannot have `or`
+    /// in the first level.
+    condition: ?MediaCondition,
+    // ~toCssImpl
+    const This = @This();
+
+    pub fn deepClone(this: *const MediaQuery, allocator: std.mem.Allocator) MediaQuery {
+        return MediaQuery{
+            .qualifier = if (this.qualifier) |q| q else null,
+            .media_type = this.media_type,
+            .condition = if (this.condition) |*c| c.deepClone(allocator) else null,
+        };
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    /// Returns whether the media query is guaranteed to always match.
+    pub fn alwaysMatches(this: *const MediaQuery) bool {
+        return this.qualifier == null and this.media_type == .all and this.condition == null;
+    }
+
+    pub fn parse(input: *css.Parser) Result(MediaQuery) {
+        const Fn = struct {
+            pub fn tryParseFn(i: *css.Parser) Result(struct { ?Qualifier, ?MediaType }) {
+                const qualifier = switch (i.tryParse(Qualifier.parse, .{})) {
+                    .result => |vv| vv,
+                    .err => null,
+                };
+                const media_type = switch (MediaType.parse(i)) {
+                    .result => |vv| vv,
+                    .err => |e| return .{ .err = e },
+                };
+                return .{ .result = .{ qualifier, media_type } };
+            }
+        };
+        const qualifier, const explicit_media_type = switch (input.tryParse(Fn.tryParseFn, .{})) {
+            .result => |v| v,
+            .err => .{ null, null },
+        };
+
+        const condition = if (explicit_media_type == null)
+            switch (MediaCondition.parseWithFlags(input, QueryConditionFlags{ .allow_or = true })) {
+                .result => |v| v,
+                .err => |e| return .{ .err = e },
+            }
+        else if (input.tryParse(css.Parser.expectIdentMatching, .{"and"}).isOk())
+            switch (MediaCondition.parseWithFlags(input, QueryConditionFlags.empty())) {
+                .result => |v| v,
+                .err => |e| return .{ .err = e },
+            }
+        else
+            null;
+
+        const media_type = explicit_media_type orelse MediaType.all;
+
+        return .{
+            .result = MediaQuery{
+                .qualifier = qualifier,
+                .media_type = media_type,
+                .condition = condition,
+            },
+        };
+    }
+
+    pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        if (this.qualifier) |qual| {
+            try qual.toCss(W, dest);
+            try dest.writeChar(' ');
+        }
+
+        switch (this.media_type) {
+            .all => {
+                // We need to print "all" if there's a qualifier, or there's
+                // just an empty list of expressions.
+                //
+                // Otherwise, we'd serialize media queries like "(min-width:
+                // 40px)" in "all (min-width: 40px)", which is unexpected.
+                if (this.qualifier != null or this.condition == null) {
+                    try dest.writeStr("all");
+                }
+            },
+            .print => {
+                try dest.writeStr("print");
+            },
+            .screen => {
+                try dest.writeStr("screen");
+            },
+            .custom => |desc| {
+                try dest.writeStr(desc);
+            },
+        }
+
+        const condition = if (this.condition) |*cond| cond else return;
+
+        const needs_parens = if (this.media_type != .all or this.qualifier != null) needs_parens: {
+            try dest.writeStr(" and ");
+            break :needs_parens condition.* == .operation and condition.operation.operator != .@"and";
+        } else false;
+
+        return toCssWithParensIfNeeded(condition, W, dest, needs_parens);
+    }
+};
+
+/// Flags for `parse_query_condition`.
+pub const QueryConditionFlags = packed struct(u8) {
+    /// Whether to allow top-level "or" boolean logic.
+    allow_or: bool = false,
+    /// Whether to allow style container queries.
+    allow_style: bool = false,
+    __unused: u6 = 0,
+
+    pub usingnamespace css.Bitflags(@This());
+};
+
+pub fn toCssWithParensIfNeeded(
+    v: anytype,
+    comptime W: type,
+    dest: *Printer(W),
+    needs_parens: bool,
+) PrintErr!void {
+    if (needs_parens) {
+        try dest.writeChar('(');
+    }
+    try v.toCss(W, dest);
+    if (needs_parens) {
+        try dest.writeChar(')');
+    }
+    return;
+}
+
+/// A [media query qualifier](https://drafts.csswg.org/mediaqueries/#mq-prefix).
+pub const Qualifier = enum {
+    /// Prevents older browsers from matching the media query.
+    only,
+    /// Negates a media query.
+    not,
+
+    pub fn asStr(this: *const @This()) []const u8 {
+        return css.enum_property_util.asStr(@This(), this);
+    }
+
+    pub fn parse(input: *css.Parser) Result(@This()) {
+        return css.enum_property_util.parse(@This(), input);
+    }
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+        return css.enum_property_util.toCss(@This(), this, W, dest);
+    }
+};
+
+/// A [media type](https://drafts.csswg.org/mediaqueries/#media-types) within a media query.
+pub const MediaType = union(enum) {
+    /// Matches all devices.
+    all,
+    /// Matches printers, and devices intended to reproduce a printed
+    /// display, such as a web browser showing a document in “Print Preview”.
+    print,
+    /// Matches all devices that aren’t matched by print.
+    screen,
+    /// An unknown media type.
+    custom: []const u8,
+
+    pub fn parse(input: *css.Parser) Result(MediaType) {
+        const name = switch (input.expectIdent()) {
+            .result => |v| v,
+            .err => |e| return .{ .err = e },
+        };
+        return .{ .result = MediaType.fromStr(name) };
+    }
+
+    pub fn fromStr(name: []const u8) MediaType {
+        const Enumerations = enum { all, print, screen };
+        const Map = comptime bun.ComptimeEnumMap(Enumerations);
+        if (Map.getASCIIICaseInsensitive(name)) |x| return switch (x) {
+            .all => .all,
+            .print => .print,
+            .screen => .screen,
+        };
+        return .{ .custom = name };
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+pub fn operationToCss(comptime QueryCondition: type, operator: Operator, conditions: *const ArrayList(QueryCondition), comptime W: type, dest: *Printer(W)) PrintErr!void {
+    ValidQueryCondition(QueryCondition);
+    const first = &conditions.items[0];
+    try toCssWithParensIfNeeded(first, W, dest, first.needsParens(operator, &dest.targets));
+    if (conditions.items.len == 1) return;
+    for (conditions.items[1..]) |*item| {
+        try dest.writeChar(' ');
+        try operator.toCss(W, dest);
+        try dest.writeChar(' ');
+        try toCssWithParensIfNeeded(item, W, dest, item.needsParens(operator, &dest.targets));
+    }
+    return;
+}
+
+/// Represents a media condition.
+///
+/// Implements QueryCondition interface.
+pub const MediaCondition = union(enum) {
+    feature: MediaFeature,
+    not: *MediaCondition,
+    operation: struct {
+        operator: Operator,
+        conditions: ArrayList(MediaCondition),
+
+        pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+            return css.implementEql(@This(), lhs, rhs);
+        }
+    },
+
+    const This = @This();
+
+    pub fn deepClone(this: *const MediaCondition, allocator: std.mem.Allocator) MediaCondition {
+        return switch (this.*) {
+            .feature => |*f| MediaCondition{ .feature = f.deepClone(allocator) },
+            .not => |c| MediaCondition{ .not = bun.create(allocator, MediaCondition, c.deepClone(allocator)) },
+            .operation => |op| MediaCondition{
+                .operation = .{
+                    .operator = op.operator,
+                    .conditions = css.deepClone(MediaCondition, allocator, &op.conditions),
+                },
+            },
+        };
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        switch (this.*) {
+            .feature => |*f| {
+                try f.toCss(W, dest);
+            },
+            .not => |c| {
+                try dest.writeStr("not ");
+                try toCssWithParensIfNeeded(c, W, dest, c.needsParens(null, &dest.targets));
+            },
+            .operation => |operation| {
+                try operationToCss(MediaCondition, operation.operator, &operation.conditions, W, dest);
+            },
+        }
+
+        return;
+    }
+
+    /// QueryCondition.parseFeature
+    pub fn parseFeature(input: *css.Parser) Result(MediaCondition) {
+        const feature = switch (MediaFeature.parse(input)) {
+            .err => |e| return .{ .err = e },
+            .result => |v| v,
+        };
+        return .{ .result = MediaCondition{ .feature = feature } };
+    }
+
+    /// QueryCondition.createNegation
+    pub fn createNegation(condition: *MediaCondition) MediaCondition {
+        return MediaCondition{ .not = condition };
+    }
+
+    /// QueryCondition.createOperation
+    pub fn createOperation(operator: Operator, conditions: ArrayList(MediaCondition)) MediaCondition {
+        return MediaCondition{
+            .operation = .{
+                .operator = operator,
+                .conditions = conditions,
+            },
+        };
+    }
+
+    /// QueryCondition.parseStyleQuery
+    pub fn parseStyleQuery(input: *css.Parser) Result(MediaCondition) {
+        return .{ .err = input.newErrorForNextToken() };
+    }
+
+    /// QueryCondition.needsParens
+    pub fn needsParens(this: *const MediaCondition, parent_operator: ?Operator, targets: *const css.targets.Targets) bool {
+        return switch (this.*) {
+            .not => true,
+            .operation => |operation| operation.operator != parent_operator,
+            .feature => |f| f.needsParens(parent_operator, targets),
+        };
+    }
+
+    pub fn parseWithFlags(input: *css.Parser, flags: QueryConditionFlags) Result(MediaCondition) {
+        return parseQueryCondition(MediaCondition, input, flags);
+    }
+};
+
+/// Parse a single query condition.
+pub fn parseQueryCondition(
+    comptime QueryCondition: type,
+    input: *css.Parser,
+    flags: QueryConditionFlags,
+) Result(QueryCondition) {
+    const location = input.currentSourceLocation();
+    const is_negation, const is_style = brk: {
+        const tok = switch (input.next()) {
+            .err => |e| return .{ .err = e },
+            .result => |v| v,
+        };
+        switch (tok.*) {
+            .open_paren => break :brk .{ false, false },
+            .ident => |ident| {
+                if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(ident, "not")) break :brk .{ true, false };
+            },
+            .function => |f| {
+                if (flags.contains(QueryConditionFlags{ .allow_style = true }) and
+                    bun.strings.eqlCaseInsensitiveASCIIICheckLength(f, "style"))
+                {
+                    break :brk .{ false, true };
+                }
+            },
+            else => {},
+        }
+        return .{ .err = location.newUnexpectedTokenError(tok.*) };
+    };
+
+    const first_condition: QueryCondition = first_condition: {
+        const val: u8 = @as(u8, @intFromBool(is_negation)) << 1 | @as(u8, @intFromBool(is_style));
+        // (is_negation, is_style)
+        switch (val) {
+            // (true, false)
+            0b10 => {
+                const inner_condition = switch (parseParensOrFunction(QueryCondition, input, flags)) {
+                    .err => |e| return .{ .err = e },
+                    .result => |v| v,
+                };
+                return .{ .result = QueryCondition.createNegation(bun.create(input.allocator(), QueryCondition, inner_condition)) };
+            },
+            // (true, true)
+            0b11 => {
+                const inner_condition = switch (QueryCondition.parseStyleQuery(input)) {
+                    .err => |e| return .{ .err = e },
+                    .result => |v| v,
+                };
+                return .{ .result = QueryCondition.createNegation(bun.create(input.allocator(), QueryCondition, inner_condition)) };
+            },
+            0b00 => break :first_condition switch (parseParenBlock(QueryCondition, input, flags)) {
+                .err => |e| return .{ .err = e },
+                .result => |v| v,
+            },
+            0b01 => break :first_condition switch (QueryCondition.parseStyleQuery(input)) {
+                .err => |e| return .{ .err = e },
+                .result => |v| v,
+            },
+            else => unreachable,
+        }
+    };
+
+    const operator: Operator = if (input.tryParse(Operator.parse, .{}).asValue()) |op|
+        op
+    else
+        return .{ .result = first_condition };
+
+    if (!flags.contains(QueryConditionFlags{ .allow_or = true }) and operator == .@"or") {
+        return .{ .err = location.newUnexpectedTokenError(css.Token{ .ident = "or" }) };
+    }
+
+    var conditions = ArrayList(QueryCondition){};
+    conditions.append(
+        input.allocator(),
+        first_condition,
+    ) catch unreachable;
+    conditions.append(
+        input.allocator(),
+        switch (parseParensOrFunction(QueryCondition, input, flags)) {
+            .err => |e| return .{ .err = e },
+            .result => |v| v,
+        },
+    ) catch unreachable;
+
+    const delim = switch (operator) {
+        .@"and" => "and",
+        .@"or" => "or",
+    };
+
+    while (true) {
+        if (input.tryParse(css.Parser.expectIdentMatching, .{delim}).isErr()) {
+            return .{ .result = QueryCondition.createOperation(operator, conditions) };
+        }
+
+        conditions.append(
+            input.allocator(),
+            switch (parseParensOrFunction(QueryCondition, input, flags)) {
+                .err => |e| return .{ .err = e },
+                .result => |v| v,
+            },
+        ) catch unreachable;
+    }
+}
+
+/// Parse a media condition in parentheses, or a style() function.
+pub fn parseParensOrFunction(
+    comptime QueryCondition: type,
+    input: *css.Parser,
+    flags: QueryConditionFlags,
+) Result(QueryCondition) {
+    const location = input.currentSourceLocation();
+    const t = switch (input.next()) {
+        .err => |e| return .{ .err = e },
+        .result => |v| v,
+    };
+    switch (t.*) {
+        .open_paren => return parseParenBlock(QueryCondition, input, flags),
+        .function => |f| {
+            if (flags.contains(QueryConditionFlags{ .allow_style = true }) and
+                bun.strings.eqlCaseInsensitiveASCIIICheckLength(f, "style"))
+            {
+                return QueryCondition.parseStyleQuery(input);
+            }
+        },
+        else => {},
+    }
+    return .{ .err = location.newUnexpectedTokenError(t.*) };
+}
+
+fn parseParenBlock(
+    comptime QueryCondition: type,
+    input: *css.Parser,
+    flags: QueryConditionFlags,
+) Result(QueryCondition) {
+    const Closure = struct {
+        flags: QueryConditionFlags,
+        pub fn parseNestedBlockFn(this: *@This(), i: *css.Parser) Result(QueryCondition) {
+            if (i.tryParse(@This().tryParseFn, .{this}).asValue()) |inner| {
+                return .{ .result = inner };
+            }
+
+            return QueryCondition.parseFeature(i);
+        }
+
+        pub fn tryParseFn(i: *css.Parser, this: *@This()) Result(QueryCondition) {
+            return parseQueryCondition(QueryCondition, i, this.flags);
+        }
+    };
+
+    var closure = Closure{
+        .flags = flags,
+    };
+    return input.parseNestedBlock(QueryCondition, &closure, Closure.parseNestedBlockFn);
+}
+
+/// A [media feature](https://drafts.csswg.org/mediaqueries/#typedef-media-feature)
+pub const MediaFeature = QueryFeature(MediaFeatureId);
+
+pub const MediaFeatureId = enum {
+    /// The [width](https://w3c.github.io/csswg-drafts/mediaqueries-5/#width) media feature.
+    width,
+    /// The [height](https://w3c.github.io/csswg-drafts/mediaqueries-5/#height) media feature.
+    height,
+    /// The [aspect-ratio](https://w3c.github.io/csswg-drafts/mediaqueries-5/#aspect-ratio) media feature.
+    @"aspect-ratio",
+    /// The [orientation](https://w3c.github.io/csswg-drafts/mediaqueries-5/#orientation) media feature.
+    orientation,
+    /// The [overflow-block](https://w3c.github.io/csswg-drafts/mediaqueries-5/#overflow-block) media feature.
+    @"overflow-block",
+    /// The [overflow-inline](https://w3c.github.io/csswg-drafts/mediaqueries-5/#overflow-inline) media feature.
+    @"overflow-inline",
+    /// The [horizontal-viewport-segments](https://w3c.github.io/csswg-drafts/mediaqueries-5/#horizontal-viewport-segments) media feature.
+    @"horizontal-viewport-segments",
+    /// The [vertical-viewport-segments](https://w3c.github.io/csswg-drafts/mediaqueries-5/#vertical-viewport-segments) media feature.
+    @"vertical-viewport-segments",
+    /// The [display-mode](https://w3c.github.io/csswg-drafts/mediaqueries-5/#display-mode) media feature.
+    @"display-mode",
+    /// The [resolution](https://w3c.github.io/csswg-drafts/mediaqueries-5/#resolution) media feature.
+    resolution,
+    /// The [scan](https://w3c.github.io/csswg-drafts/mediaqueries-5/#scan) media feature.
+    scan,
+    /// The [grid](https://w3c.github.io/csswg-drafts/mediaqueries-5/#grid) media feature.
+    grid,
+    /// The [update](https://w3c.github.io/csswg-drafts/mediaqueries-5/#update) media feature.
+    update,
+    /// The [environment-blending](https://w3c.github.io/csswg-drafts/mediaqueries-5/#environment-blending) media feature.
+    @"environment-blending",
+    /// The [color](https://w3c.github.io/csswg-drafts/mediaqueries-5/#color) media feature.
+    color,
+    /// The [color-index](https://w3c.github.io/csswg-drafts/mediaqueries-5/#color-index) media feature.
+    @"color-index",
+    /// The [monochrome](https://w3c.github.io/csswg-drafts/mediaqueries-5/#monochrome) media feature.
+    monochrome,
+    /// The [color-gamut](https://w3c.github.io/csswg-drafts/mediaqueries-5/#color-gamut) media feature.
+    @"color-gamut",
+    /// The [dynamic-range](https://w3c.github.io/csswg-drafts/mediaqueries-5/#dynamic-range) media feature.
+    @"dynamic-range",
+    /// The [inverted-colors](https://w3c.github.io/csswg-drafts/mediaqueries-5/#inverted-colors) media feature.
+    @"inverted-colors",
+    /// The [pointer](https://w3c.github.io/csswg-drafts/mediaqueries-5/#pointer) media feature.
+    pointer,
+    /// The [hover](https://w3c.github.io/csswg-drafts/mediaqueries-5/#hover) media feature.
+    hover,
+    /// The [any-pointer](https://w3c.github.io/csswg-drafts/mediaqueries-5/#any-pointer) media feature.
+    @"any-pointer",
+    /// The [any-hover](https://w3c.github.io/csswg-drafts/mediaqueries-5/#any-hover) media feature.
+    @"any-hover",
+    /// The [nav-controls](https://w3c.github.io/csswg-drafts/mediaqueries-5/#nav-controls) media feature.
+    @"nav-controls",
+    /// The [video-color-gamut](https://w3c.github.io/csswg-drafts/mediaqueries-5/#video-color-gamut) media feature.
+    @"video-color-gamut",
+    /// The [video-dynamic-range](https://w3c.github.io/csswg-drafts/mediaqueries-5/#video-dynamic-range) media feature.
+    @"video-dynamic-range",
+    /// The [scripting](https://w3c.github.io/csswg-drafts/mediaqueries-5/#scripting) media feature.
+    scripting,
+    /// The [prefers-reduced-motion](https://w3c.github.io/csswg-drafts/mediaqueries-5/#prefers-reduced-motion) media feature.
+    @"prefers-reduced-motion",
+    /// The [prefers-reduced-transparency](https://w3c.github.io/csswg-drafts/mediaqueries-5/#prefers-reduced-transparency) media feature.
+    @"prefers-reduced-transparency",
+    /// The [prefers-contrast](https://w3c.github.io/csswg-drafts/mediaqueries-5/#prefers-contrast) media feature.
+    @"prefers-contrast",
+    /// The [forced-colors](https://w3c.github.io/csswg-drafts/mediaqueries-5/#forced-colors) media feature.
+    @"forced-colors",
+    /// The [prefers-color-scheme](https://w3c.github.io/csswg-drafts/mediaqueries-5/#prefers-color-scheme) media feature.
+    @"prefers-color-scheme",
+    /// The [prefers-reduced-data](https://w3c.github.io/csswg-drafts/mediaqueries-5/#prefers-reduced-data) media feature.
+    @"prefers-reduced-data",
+    /// The [device-width](https://w3c.github.io/csswg-drafts/mediaqueries-5/#device-width) media feature.
+    @"device-width",
+    /// The [device-height](https://w3c.github.io/csswg-drafts/mediaqueries-5/#device-height) media feature.
+    @"device-height",
+    /// The [device-aspect-ratio](https://w3c.github.io/csswg-drafts/mediaqueries-5/#device-aspect-ratio) media feature.
+    @"device-aspect-ratio",
+
+    /// The non-standard -webkit-device-pixel-ratio media feature.
+    @"-webkit-device-pixel-ratio",
+    /// The non-standard -moz-device-pixel-ratio media feature.
+    @"-moz-device-pixel-ratio",
+
+    pub usingnamespace css.DeriveValueType(@This());
+
+    pub const ValueTypeMap = .{
+        .width = MediaFeatureType.length,
+        .height = MediaFeatureType.length,
+        .@"aspect-ratio" = MediaFeatureType.ratio,
+        .orientation = MediaFeatureType.ident,
+        .@"overflow-block" = MediaFeatureType.ident,
+        .@"overflow-inline" = MediaFeatureType.ident,
+        .@"horizontal-viewport-segments" = MediaFeatureType.integer,
+        .@"vertical-viewport-segments" = MediaFeatureType.integer,
+        .@"display-mode" = MediaFeatureType.ident,
+        .resolution = MediaFeatureType.resolution,
+        .scan = MediaFeatureType.ident,
+        .grid = MediaFeatureType.boolean,
+        .update = MediaFeatureType.ident,
+        .@"environment-blending" = MediaFeatureType.ident,
+        .color = MediaFeatureType.integer,
+        .@"color-index" = MediaFeatureType.integer,
+        .monochrome = MediaFeatureType.integer,
+        .@"color-gamut" = MediaFeatureType.ident,
+        .@"dynamic-range" = MediaFeatureType.ident,
+        .@"inverted-colors" = MediaFeatureType.ident,
+        .pointer = MediaFeatureType.ident,
+        .hover = MediaFeatureType.ident,
+        .@"any-pointer" = MediaFeatureType.ident,
+        .@"any-hover" = MediaFeatureType.ident,
+        .@"nav-controls" = MediaFeatureType.ident,
+        .@"video-color-gamut" = MediaFeatureType.ident,
+        .@"video-dynamic-range" = MediaFeatureType.ident,
+        .scripting = MediaFeatureType.ident,
+        .@"prefers-reduced-motion" = MediaFeatureType.ident,
+        .@"prefers-reduced-transparency" = MediaFeatureType.ident,
+        .@"prefers-contrast" = MediaFeatureType.ident,
+        .@"forced-colors" = MediaFeatureType.ident,
+        .@"prefers-color-scheme" = MediaFeatureType.ident,
+        .@"prefers-reduced-data" = MediaFeatureType.ident,
+        .@"device-width" = MediaFeatureType.length,
+        .@"device-height" = MediaFeatureType.length,
+        .@"device-aspect-ratio" = MediaFeatureType.ratio,
+        .@"-webkit-device-pixel-ratio" = MediaFeatureType.number,
+        .@"-moz-device-pixel-ratio" = MediaFeatureType.number,
+    };
+
+    pub fn toCssWithPrefix(
+        this: *const MediaFeatureId,
+        prefix: []const u8,
+        comptime W: type,
+        dest: *Printer(W),
+    ) PrintErr!void {
+        switch (this.*) {
+            .@"-webkit-device-pixel-ratio" => {
+                return dest.writeFmt("-webkit-{s}device-pixel-ratio", .{prefix});
+            },
+            else => {
+                try dest.writeStr(prefix);
+                return this.toCss(W, dest);
+            },
+        }
+    }
+
+    pub inline fn asStr(this: *const @This()) []const u8 {
+        return css.enum_property_util.asStr(@This(), this);
+    }
+
+    pub fn parse(input: *css.Parser) Result(@This()) {
+        return css.enum_property_util.parse(@This(), input);
+    }
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+        return css.enum_property_util.toCss(@This(), this, W, dest);
+    }
+};
+
+pub fn QueryFeature(comptime FeatureId: type) type {
+    return union(enum) {
+        /// A plain media feature, e.g. `(min-width: 240px)`.
+        plain: struct {
+            /// The name of the feature.
+            name: MediaFeatureName(FeatureId),
+            /// The feature value.
+            value: MediaFeatureValue,
+
+            pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+                return css.implementEql(@This(), lhs, rhs);
+            }
+        },
+
+        /// A boolean feature, e.g. `(hover)`.
+        boolean: struct {
+            /// The name of the feature.
+            name: MediaFeatureName(FeatureId),
+
+            pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+                return css.implementEql(@This(), lhs, rhs);
+            }
+        },
+
+        /// A range, e.g. `(width > 240px)`.
+        range: struct {
+            /// The name of the feature.
+            name: MediaFeatureName(FeatureId),
+            /// A comparator.
+            operator: MediaFeatureComparison,
+            /// The feature value.
+            value: MediaFeatureValue,
+
+            pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+                return css.implementEql(@This(), lhs, rhs);
+            }
+        },
+
+        /// An interval, e.g. `(120px < width < 240px)`.
+        interval: struct {
+            /// The name of the feature.
+            name: MediaFeatureName(FeatureId),
+            /// A start value.
+            start: MediaFeatureValue,
+            /// A comparator for the start value.
+            start_operator: MediaFeatureComparison,
+            /// The end value.
+            end: MediaFeatureValue,
+            /// A comparator for the end value.
+            end_operator: MediaFeatureComparison,
+
+            pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+                return css.implementEql(@This(), lhs, rhs);
+            }
+        },
+
+        const This = @This();
+
+        pub fn deepClone(this: *const This, allocator: std.mem.Allocator) This {
+            return switch (this.*) {
+                .plain => .{
+                    .plain = .{
+                        .name = this.plain.name,
+                        .value = this.plain.value.deepClone(allocator),
+                    },
+                },
+                .boolean => .{
+                    .boolean = .{
+                        .name = this.boolean.name,
+                    },
+                },
+                .range => .{
+                    .range = .{
+                        .name = this.range.name,
+                        .operator = this.range.operator,
+                        .value = this.range.value.deepClone(allocator),
+                    },
+                },
+                .interval => .{
+                    .interval = .{
+                        .name = this.interval.name,
+                        .start = this.interval.start.deepClone(allocator),
+                        .start_operator = this.interval.start_operator,
+                        .end = this.interval.end.deepClone(allocator),
+                        .end_operator = this.interval.end_operator,
+                    },
+                },
+            };
+        }
+
+        pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+            return css.implementEql(@This(), lhs, rhs);
+        }
+
+        pub fn needsParens(this: *const This, parent_operator: ?Operator, targets: *const css.Targets) bool {
+            return parent_operator != .@"and" and
+                this.* == .interval and
+                targets.shouldCompileSame(.media_interval_syntax);
+        }
+
+        pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+            try dest.writeChar('(');
+
+            switch (this.*) {
+                .boolean => {
+                    try this.boolean.name.toCss(W, dest);
+                },
+                .plain => {
+                    try this.plain.name.toCss(W, dest);
+                    try dest.delim(':', false);
+                    try this.plain.value.toCss(W, dest);
+                },
+                .range => {
+                    // If range syntax is unsupported, use min/max prefix if possible.
+                    if (dest.targets.shouldCompileSame(.media_range_syntax)) {
+                        return writeMinMax(
+                            &this.range.operator,
+                            FeatureId,
+                            &this.range.name,
+                            &this.range.value,
+                            W,
+                            dest,
+                        );
+                    }
+                    try this.range.name.toCss(W, dest);
+                    try this.range.operator.toCss(W, dest);
+                    try this.range.value.toCss(W, dest);
+                },
+                .interval => |interval| {
+                    if (dest.targets.shouldCompileSame(.media_interval_syntax)) {
+                        try writeMinMax(
+                            &interval.start_operator.opposite(),
+                            FeatureId,
+                            &interval.name,
+                            &interval.start,
+                            W,
+                            dest,
+                        );
+                        try dest.writeStr(" and (");
+                        return writeMinMax(
+                            &interval.end_operator,
+                            FeatureId,
+                            &interval.name,
+                            &interval.end,
+                            W,
+                            dest,
+                        );
+                    }
+
+                    try interval.start.toCss(W, dest);
+                    try interval.start_operator.toCss(W, dest);
+                    try interval.name.toCss(W, dest);
+                    try interval.end_operator.toCss(W, dest);
+                    try interval.end.toCss(W, dest);
+                },
+            }
+
+            return dest.writeChar(')');
+        }
+
+        pub fn parse(input: *css.Parser) Result(This) {
+            switch (input.tryParse(parseNameFirst, .{})) {
+                .result => |res| {
+                    return .{ .result = res };
+                },
+                .err => |e| {
+                    if (e.kind == .custom and e.kind.custom == .invalid_media_query) {
+                        return .{ .err = e };
+                    }
+                    return parseValueFirst(input);
+                },
+            }
+            return Result(This).success;
+        }
+
+        pub fn parseNameFirst(input: *css.Parser) Result(This) {
+            const name, const legacy_op = switch (MediaFeatureName(FeatureId).parse(input)) {
+                .err => |e| return .{ .err = e },
+                .result => |v| v,
+            };
+
+            const operator = if (input.tryParse(consumeOperationOrColon, .{true}).asValue()) |operator| operator else return .{
+                .result = .{
+                    .boolean = .{ .name = name },
+                },
+            };
+
+            if (operator != null and legacy_op != null) {
+                return .{ .err = input.newCustomError(css.ParserError.invalid_media_query) };
+            }
+
+            const value = switch (MediaFeatureValue.parse(input, name.valueType())) {
+                .err => |e| return .{ .err = e },
+                .result => |v| v,
+            };
+            if (!value.checkType(name.valueType())) {
+                return .{ .err = input.newCustomError(css.ParserError.invalid_media_query) };
+            }
+
+            if (operator orelse legacy_op) |op| {
+                if (!name.valueType().allowsRanges()) {
+                    return .{ .err = input.newCustomError(css.ParserError.invalid_media_query) };
+                }
+
+                return .{ .result = .{
+                    .range = .{
+                        .name = name,
+                        .operator = op,
+                        .value = value,
+                    },
+                } };
+            } else {
+                return .{ .result = .{
+                    .plain = .{
+                        .name = name,
+                        .value = value,
+                    },
+                } };
+            }
+        }
+
+        pub fn parseValueFirst(input: *css.Parser) Result(This) {
+            // We need to find the feature name first so we know the type.
+            const start = input.state();
+            const name = name: {
+                while (true) {
+                    if (MediaFeatureName(FeatureId).parse(input).asValue()) |result| {
+                        const name: MediaFeatureName(FeatureId) = result[0];
+                        const legacy_op: ?MediaFeatureComparison = result[1];
+                        if (legacy_op != null) {
+                            return .{ .err = input.newCustomError(css.ParserError.invalid_media_query) };
+                        }
+                        break :name name;
+                    }
+                    if (input.isExhausted()) {
+                        return .{ .err = input.newCustomError(css.ParserError.invalid_media_query) };
+                    }
+                }
+            };
+
+            input.reset(&start);
+
+            // Now we can parse the first value.
+            const value = switch (MediaFeatureValue.parse(input, name.valueType())) {
+                .err => |e| return .{ .err = e },
+                .result => |v| v,
+            };
+            const operator = switch (consumeOperationOrColon(input, false)) {
+                .err => |e| return .{ .err = e },
+                .result => |v| v,
+            };
+
+            // Skip over the feature name again.
+            {
+                const feature_name, const blah = switch (MediaFeatureName(FeatureId).parse(input)) {
+                    .err => |e| return .{ .err = e },
+                    .result => |v| v,
+                };
+                _ = blah;
+                bun.debugAssert(feature_name.eql(&name));
+            }
+
+            if (!name.valueType().allowsRanges() or !value.checkType(name.valueType())) {
+                return .{ .err = input.newCustomError(css.ParserError.invalid_media_query) };
+            }
+
+            if (input.tryParse(consumeOperationOrColon, .{false}).asValue()) |end_operator_| {
+                const start_operator = operator.?;
+                const end_operator = end_operator_.?;
+                // Start and end operators must be matching.
+                const GT: u8 = comptime @intFromEnum(MediaFeatureComparison.@"greater-than");
+                const GTE: u8 = comptime @intFromEnum(MediaFeatureComparison.@"greater-than-equal");
+                const LT: u8 = comptime @intFromEnum(MediaFeatureComparison.@"less-than");
+                const LTE: u8 = comptime @intFromEnum(MediaFeatureComparison.@"less-than-equal");
+                const check_val: u8 = @intFromEnum(start_operator) | @intFromEnum(end_operator);
+                switch (check_val) {
+                    GT | GT,
+                    GT | GTE,
+                    GTE | GTE,
+                    LT | LT,
+                    LT | LTE,
+                    LTE | LTE,
+                    => {},
+                    else => return .{ .err = input.newCustomError(css.ParserError.invalid_media_query) },
+                }
+
+                const end_value = switch (MediaFeatureValue.parse(input, name.valueType())) {
+                    .err => |e| return .{ .err = e },
+                    .result => |v| v,
+                };
+                if (!end_value.checkType(name.valueType())) {
+                    return .{ .err = input.newCustomError(css.ParserError.invalid_media_query) };
+                }
+
+                return .{ .result = .{
+                    .interval = .{
+                        .name = name,
+                        .start = value,
+                        .start_operator = start_operator,
+                        .end = end_value,
+                        .end_operator = end_operator,
+                    },
+                } };
+            } else {
+                const final_operator = operator.?.opposite();
+                return .{ .result = .{
+                    .range = .{
+                        .name = name,
+                        .operator = final_operator,
+                        .value = value,
+                    },
+                } };
+            }
+        }
+    };
+}
+
+/// Consumes an operation or a colon, or returns an error.
+fn consumeOperationOrColon(input: *css.Parser, allow_colon: bool) Result(?MediaFeatureComparison) {
+    const location = input.currentSourceLocation();
+    const first_delim = first_delim: {
+        const loc = input.currentSourceLocation();
+        const next_token = switch (input.next()) {
+            .err => |e| return .{ .err = e },
+            .result => |v| v,
+        };
+        switch (next_token.*) {
+            .colon => if (allow_colon) return .{ .result = null },
+            .delim => |oper| break :first_delim oper,
+            else => {},
+        }
+        return .{ .err = loc.newUnexpectedTokenError(next_token.*) };
+    };
+
+    switch (first_delim) {
+        '=' => return .{ .result = .equal },
+        '>' => {
+            if (input.tryParse(css.Parser.expectDelim, .{'='}).isOk()) {
+                return .{ .result = .@"greater-than-equal" };
+            }
+            return .{ .result = .@"greater-than" };
+        },
+        '<' => {
+            if (input.tryParse(css.Parser.expectDelim, .{'='}).isOk()) {
+                return .{ .result = .@"less-than-equal" };
+            }
+            return .{ .result = .@"less-than" };
+        },
+        else => return .{ .err = location.newUnexpectedTokenError(.{ .delim = first_delim }) },
+    }
+}
+
+pub const MediaFeatureComparison = enum(u8) {
+    /// `=`
+    equal = 1,
+    /// `>`
+    @"greater-than" = 2,
+    /// `>=`
+    @"greater-than-equal" = 4,
+    /// `<`
+    @"less-than" = 8,
+    /// `<=`
+    @"less-than-equal" = 16,
+
+    pub fn asStr(this: *const @This()) []const u8 {
+        return css.enum_property_util.asStr(@This(), this);
+    }
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+        switch (this.*) {
+            .equal => {
+                try dest.delim('-', true);
+            },
+            .@"greater-than" => {
+                try dest.delim('>', true);
+            },
+            .@"greater-than-equal" => {
+                try dest.whitespace();
+                try dest.writeStr(">=");
+                try dest.whitespace();
+            },
+            .@"less-than" => {
+                try dest.delim('<', true);
+            },
+            .@"less-than-equal" => {
+                try dest.whitespace();
+                try dest.writeStr("<=");
+                try dest.whitespace();
+            },
+        }
+    }
+
+    pub fn opposite(self: @This()) @This() {
+        return switch (self) {
+            .@"greater-than" => .@"less-than",
+            .@"greater-than-equal" => .@"less-than-equal",
+            .@"less-than" => .@"greater-than",
+            .@"less-than-equal" => .@"greater-than-equal",
+            .equal => .equal,
+        };
+    }
+};
+
+/// [media feature value](https://drafts.csswg.org/mediaqueries/#typedef-mf-value) within a media query.
+///
+/// See [MediaFeature](MediaFeature).
+pub const MediaFeatureValue = union(enum) {
+    /// A length value.
+    length: Length,
+    /// A number value.
+    number: CSSNumber,
+    /// An integer value.
+    integer: CSSInteger,
+    /// A boolean value.
+    boolean: bool,
+    /// A resolution.
+    resolution: Resolution,
+    /// A ratio.
+    ratio: Ratio,
+    /// An identifier.
+    ident: Ident,
+    /// An environment variable reference.
+    env: EnvironmentVariable,
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn deepClone(this: *const MediaFeatureValue, allocator: std.mem.Allocator) MediaFeatureValue {
+        return switch (this.*) {
+            .length => |*l| .{ .length = l.deepClone(allocator) },
+            .number => |n| .{ .number = n },
+            .integer => |i| .{ .integer = i },
+            .boolean => |b| .{ .boolean = b },
+            .resolution => |r| .{ .resolution = r },
+            .ratio => |r| .{ .ratio = r },
+            .ident => |i| .{ .ident = i },
+            .env => |*e| .{ .env = e.deepClone(allocator) },
+        };
+    }
+
+    pub fn deinit(this: *MediaFeatureValue, allocator: std.mem.Allocator) void {
+        return switch (this.*) {
+            .length => |l| l.deinit(allocator),
+            .number => {},
+            .integer => {},
+            .boolean => {},
+            .resolution => {},
+            .ratio => {},
+            .ident => {},
+            .env => |*env| env.deinit(allocator),
+        };
+    }
+
+    pub fn toCss(
+        this: *const MediaFeatureValue,
+        comptime W: type,
+        dest: *Printer(W),
+    ) PrintErr!void {
+        switch (this.*) {
+            .length => |len| return len.toCss(W, dest),
+            .number => |num| return CSSNumberFns.toCss(&num, W, dest),
+            .integer => |int| return CSSIntegerFns.toCss(&int, W, dest),
+            .boolean => |b| {
+                if (b) {
+                    return dest.writeChar('1');
+                } else {
+                    return dest.writeChar('0');
+                }
+            },
+            .resolution => |res| return res.toCss(W, dest),
+            .ratio => |ratio| return ratio.toCss(W, dest),
+            .ident => |id| return IdentFns.toCss(&id, W, dest),
+            .env => |*env| return EnvironmentVariable.toCss(env, W, dest, false),
+        }
+    }
+
+    pub fn checkType(this: *const @This(), expected_type: MediaFeatureType) bool {
+        const vt = this.valueType();
+        if (expected_type == .unknown or vt == .unknown) return true;
+        return expected_type == vt;
+    }
+
+    /// Parses a single media query feature value, with an expected type.
+    /// If the type is unknown, pass MediaFeatureType::Unknown instead.
+    pub fn parse(input: *css.Parser, expected_type: MediaFeatureType) Result(MediaFeatureValue) {
+        if (input.tryParse(parseKnown, .{expected_type}).asValue()) |value| {
+            return .{ .result = value };
+        }
+
+        return parseUnknown(input);
+    }
+
+    pub fn parseKnown(input: *css.Parser, expected_type: MediaFeatureType) Result(MediaFeatureValue) {
+        return .{
+            .result = switch (expected_type) {
+                .boolean => {
+                    const value = switch (CSSIntegerFns.parse(input)) {
+                        .err => |e| return .{ .err = e },
+                        .result => |v| v,
+                    };
+                    if (value != 0 and value != 1) return .{ .err = input.newCustomError(css.ParserError.invalid_value) };
+                    return .{ .result = .{ .boolean = value == 1 } };
+                },
+                .number => .{ .number = switch (CSSNumberFns.parse(input)) {
+                    .result => |v| v,
+                    .err => |e| return .{ .err = e },
+                } },
+                .integer => .{ .integer = switch (CSSIntegerFns.parse(input)) {
+                    .result => |v| v,
+                    .err => |e| return .{ .err = e },
+                } },
+                .length => .{ .length = switch (Length.parse(input)) {
+                    .result => |v| v,
+                    .err => |e| return .{ .err = e },
+                } },
+                .resolution => .{ .resolution = switch (Resolution.parse(input)) {
+                    .result => |v| v,
+                    .err => |e| return .{ .err = e },
+                } },
+                .ratio => .{ .ratio = switch (Ratio.parse(input)) {
+                    .result => |v| v,
+                    .err => |e| return .{ .err = e },
+                } },
+                .ident => .{ .ident = switch (IdentFns.parse(input)) {
+                    .result => |v| v,
+                    .err => |e| return .{ .err = e },
+                } },
+                .unknown => return .{ .err = input.newCustomError(.invalid_value) },
+            },
+        };
+    }
+
+    pub fn parseUnknown(input: *css.Parser) Result(MediaFeatureValue) {
+        // Ratios are ambiguous with numbers because the second param is optional (e.g. 2/1 == 2).
+        // We require the / delimiter when parsing ratios so that 2/1 ends up as a ratio and 2 is
+        // parsed as a number.
+        if (input.tryParse(Ratio.parseRequired, .{}).asValue()) |ratio| return .{ .result = .{ .ratio = ratio } };
+
+        // Parse number next so that unitless values are not parsed as lengths.
+        if (input.tryParse(CSSNumberFns.parse, .{}).asValue()) |num| return .{ .result = .{ .number = num } };
+
+        if (input.tryParse(Length.parse, .{}).asValue()) |res| return .{ .result = .{ .length = res } };
+
+        if (input.tryParse(Resolution.parse, .{}).asValue()) |res| return .{ .result = .{ .resolution = res } };
+
+        if (input.tryParse(EnvironmentVariable.parse, .{}).asValue()) |env| return .{ .result = .{ .env = env } };
+
+        const ident = switch (IdentFns.parse(input)) {
+            .err => |e| return .{ .err = e },
+            .result => |v| v,
+        };
+        return .{ .result = .{ .ident = ident } };
+    }
+
+    pub fn addF32(this: MediaFeatureValue, allocator: Allocator, other: f32) MediaFeatureValue {
+        return switch (this) {
+            .length => |len| .{ .length = len.add(allocator, Length.px(other)) },
+            // .length => |len| .{
+            //     .length = .{
+            //         .value = .{ .px = other },
+            //     },
+            // },
+            .number => |num| .{ .number = num + other },
+            .integer => |num| .{ .integer = num + if (css.signfns.isSignPositive(other)) @as(i32, 1) else @as(i32, -1) },
+            .boolean => |v| .{ .boolean = v },
+            .resolution => |res| .{ .resolution = res.addF32(allocator, other) },
+            .ratio => |ratio| .{ .ratio = ratio.addF32(allocator, other) },
+            .ident => |id| .{ .ident = id },
+            .env => |env| .{ .env = env }, // TODO: calc support
+        };
+    }
+
+    pub fn valueType(this: *const MediaFeatureValue) MediaFeatureType {
+        return switch (this.*) {
+            .length => .length,
+            .number => .number,
+            .integer => .integer,
+            .boolean => .boolean,
+            .resolution => .resolution,
+            .ratio => .ratio,
+            .ident => .ident,
+            .env => .unknown,
+        };
+    }
+};
+
+/// The type of a media feature.
+pub const MediaFeatureType = enum {
+    /// A length value.
+    length,
+    /// A number value.
+    number,
+    /// An integer value.
+    integer,
+    /// A boolean value, either 0 or 1.
+    boolean,
+    /// A resolution.
+    resolution,
+    /// A ratio.
+    ratio,
+    /// An identifier.
+    ident,
+    /// An unknown type.
+    unknown,
+
+    pub fn allowsRanges(this: MediaFeatureType) bool {
+        return switch (this) {
+            .length, .number, .integer, .resolution, .ratio, .unknown => true,
+            .boolean, .ident => false,
+        };
+    }
+};
+
+pub fn MediaFeatureName(comptime FeatureId: type) type {
+    return union(enum) {
+        /// A standard media query feature identifier.
+        standard: FeatureId,
+
+        /// A custom author-defined environment variable.
+        custom: DashedIdent,
+
+        /// An unknown environment variable.
+        unknown: Ident,
+
+        const This = @This();
+
+        pub fn eql(lhs: *const This, rhs: *const This) bool {
+            if (@intFromEnum(lhs.*) != @intFromEnum(rhs.*)) return false;
+            return switch (lhs.*) {
+                .standard => |fid| fid == rhs.standard,
+                .custom => |ident| bun.strings.eql(ident.v, rhs.custom.v),
+                .unknown => |ident| bun.strings.eql(ident.v, rhs.unknown.v),
+            };
+        }
+
+        pub fn valueType(this: *const This) MediaFeatureType {
+            return switch (this.*) {
+                .standard => |standard| standard.valueType(),
+                else => .unknown,
+            };
+        }
+
+        pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+            return switch (this.*) {
+                .standard => |v| v.toCss(W, dest),
+                .custom => |d| DashedIdentFns.toCss(&d, W, dest),
+                .unknown => |v| IdentFns.toCss(&v, W, dest),
+            };
+        }
+
+        pub fn toCssWithPrefix(this: *const This, prefix: []const u8, comptime W: type, dest: *Printer(W)) PrintErr!void {
+            return switch (this.*) {
+                .standard => |v| v.toCssWithPrefix(prefix, W, dest),
+                .custom => |d| {
+                    try dest.writeStr(prefix);
+                    return DashedIdentFns.toCss(&d, W, dest);
+                },
+                .unknown => |v| {
+                    try dest.writeStr(prefix);
+                    return IdentFns.toCss(&v, W, dest);
+                },
+            };
+        }
+
+        /// Parses a media feature name.
+        pub fn parse(input: *css.Parser) Result(struct { This, ?MediaFeatureComparison }) {
+            const ident = switch (input.expectIdent()) {
+                .err => |e| return .{ .err = e },
+                .result => |v| v,
+            };
+
+            if (bun.strings.startsWith(ident, "--")) {
+                return .{ .result = .{
+                    .{
+                        .custom = .{ .v = ident },
+                    },
+                    null,
+                } };
+            }
+
+            var name = ident;
+
+            // Webkit places its prefixes before "min" and "max". Remove it first, and
+            // re-add after removing min/max.
+            const is_webkit = bun.strings.startsWithCaseInsensitiveAscii(name, "-webkit-");
+            if (is_webkit) {
+                name = name[8..];
+            }
+
+            const comparator: ?MediaFeatureComparison = comparator: {
+                if (bun.strings.startsWithCaseInsensitiveAscii(name, "min-")) {
+                    name = name[4..];
+                    break :comparator .@"greater-than-equal";
+                } else if (bun.strings.startsWithCaseInsensitiveAscii(name, "max-")) {
+                    name = name[4..];
+                    break :comparator .@"less-than-equal";
+                } else break :comparator null;
+            };
+
+            var free_str = false;
+            const final_name = if (is_webkit) name: {
+                // PERF: stack buffer here?
+                free_str = true;
+                break :name std.fmt.allocPrint(input.allocator(), "-webkit-{s}", .{name}) catch bun.outOfMemory();
+            } else name;
+
+            defer if (is_webkit) {
+                // If we made an allocation let's try to free it,
+                // this only works if FeatureId doesn't hold any references to the input string.
+                // i.e. it is an enum
+                comptime {
+                    std.debug.assert(@typeInfo(FeatureId) == .Enum);
+                }
+                input.allocator().free(final_name);
+            };
+
+            if (css.parse_utility.parseString(
+                input.allocator(),
+                FeatureId,
+                final_name,
+                FeatureId.parse,
+            ).asValue()) |standard| {
+                return .{ .result = .{
+                    .{ .standard = standard },
+                    comparator,
+                } };
+            }
+
+            return .{ .result = .{
+                .{
+                    .unknown = .{ .v = ident },
+                },
+                null,
+            } };
+        }
+    };
+}
+
+fn writeMinMax(
+    operator: *const MediaFeatureComparison,
+    comptime FeatureId: type,
+    name: *const MediaFeatureName(FeatureId),
+    value: *const MediaFeatureValue,
+    comptime W: type,
+    dest: *Printer(W),
+) PrintErr!void {
+    const prefix = switch (operator.*) {
+        .@"greater-than", .@"greater-than-equal" => "min-",
+        .@"less-than", .@"less-than-equal" => "max-",
+        .equal => null,
+    };
+
+    if (prefix) |p| {
+        try name.toCssWithPrefix(p, W, dest);
+    } else {
+        try name.toCss(W, dest);
+    }
+
+    try dest.delim(':', false);
+
+    var adjusted: ?MediaFeatureValue = switch (operator.*) {
+        .@"greater-than" => value.deepClone(dest.allocator).addF32(dest.allocator, 0.001),
+        .@"less-than" => value.deepClone(dest.allocator).addF32(dest.allocator, -0.001),
+        else => null,
+    };
+
+    if (adjusted) |*val| {
+        defer val.deinit(dest.allocator);
+        try val.toCss(W, dest);
+    } else {
+        try value.toCss(W, dest);
+    }
+
+    return dest.writeChar(')');
+}
diff --git a/src/css/prefixes.zig b/src/css/prefixes.zig
new file mode 100644
index 0000000000..2a9b29edaf
--- /dev/null
+++ b/src/css/prefixes.zig
@@ -0,0 +1,2201 @@
+// This file is autogenerated by build-prefixes.js. DO NOT EDIT!
+
+const css = @import("./css_parser.zig");
+const VendorPrefix = css.VendorPrefix;
+const Browsers = css.targets.Browsers;
+
+pub const Feature = enum {
+    align_content,
+    align_items,
+    align_self,
+    animation,
+    animation_delay,
+    animation_direction,
+    animation_duration,
+    animation_fill_mode,
+    animation_iteration_count,
+    animation_name,
+    animation_play_state,
+    animation_timing_function,
+    any_pseudo,
+    appearance,
+    at_keyframes,
+    at_resolution,
+    at_viewport,
+    backdrop_filter,
+    backface_visibility,
+    background_clip,
+    background_origin,
+    background_size,
+    border_block_end,
+    border_block_start,
+    border_bottom_left_radius,
+    border_bottom_right_radius,
+    border_image,
+    border_inline_end,
+    border_inline_start,
+    border_radius,
+    border_top_left_radius,
+    border_top_right_radius,
+    box_decoration_break,
+    box_shadow,
+    box_sizing,
+    break_after,
+    break_before,
+    break_inside,
+    calc,
+    clip_path,
+    color_adjust,
+    column_count,
+    column_fill,
+    column_gap,
+    column_rule,
+    column_rule_color,
+    column_rule_style,
+    column_rule_width,
+    column_span,
+    column_width,
+    columns,
+    cross_fade,
+    display_flex,
+    display_grid,
+    element,
+    fill,
+    fill_available,
+    filter,
+    filter_function,
+    fit_content,
+    flex,
+    flex_basis,
+    flex_direction,
+    flex_flow,
+    flex_grow,
+    flex_shrink,
+    flex_wrap,
+    flow_from,
+    flow_into,
+    font_feature_settings,
+    font_kerning,
+    font_language_override,
+    font_variant_ligatures,
+    grab,
+    grabbing,
+    grid_area,
+    grid_column,
+    grid_column_align,
+    grid_column_end,
+    grid_column_start,
+    grid_row,
+    grid_row_align,
+    grid_row_end,
+    grid_row_start,
+    grid_template,
+    grid_template_areas,
+    grid_template_columns,
+    grid_template_rows,
+    hyphens,
+    image_rendering,
+    image_set,
+    inline_flex,
+    inline_grid,
+    isolate,
+    isolate_override,
+    justify_content,
+    linear_gradient,
+    margin_block_end,
+    margin_block_start,
+    margin_inline_end,
+    margin_inline_start,
+    mask,
+    mask_border,
+    mask_border_outset,
+    mask_border_repeat,
+    mask_border_slice,
+    mask_border_source,
+    mask_border_width,
+    mask_clip,
+    mask_composite,
+    mask_image,
+    mask_origin,
+    mask_position,
+    mask_repeat,
+    mask_size,
+    max_content,
+    min_content,
+    object_fit,
+    object_position,
+    order,
+    overscroll_behavior,
+    padding_block_end,
+    padding_block_start,
+    padding_inline_end,
+    padding_inline_start,
+    perspective,
+    perspective_origin,
+    pixelated,
+    place_self,
+    plaintext,
+    print_color_adjust,
+    pseudo_class_any_link,
+    pseudo_class_autofill,
+    pseudo_class_fullscreen,
+    pseudo_class_placeholder_shown,
+    pseudo_class_read_only,
+    pseudo_class_read_write,
+    pseudo_element_backdrop,
+    pseudo_element_file_selector_button,
+    pseudo_element_placeholder,
+    pseudo_element_selection,
+    radial_gradient,
+    region_fragment,
+    repeating_linear_gradient,
+    repeating_radial_gradient,
+    scroll_snap_coordinate,
+    scroll_snap_destination,
+    scroll_snap_points_x,
+    scroll_snap_points_y,
+    scroll_snap_type,
+    shape_image_threshold,
+    shape_margin,
+    shape_outside,
+    sticky,
+    stretch,
+    tab_size,
+    text_align_last,
+    text_decoration,
+    text_decoration_color,
+    text_decoration_line,
+    text_decoration_skip,
+    text_decoration_skip_ink,
+    text_decoration_style,
+    text_emphasis,
+    text_emphasis_color,
+    text_emphasis_position,
+    text_emphasis_style,
+    text_orientation,
+    text_overflow,
+    text_size_adjust,
+    text_spacing,
+    touch_action,
+    transform,
+    transform_origin,
+    transform_style,
+    transition,
+    transition_delay,
+    transition_duration,
+    transition_property,
+    transition_timing_function,
+    user_select,
+    writing_mode,
+    zoom_in,
+    zoom_out,
+
+    pub fn prefixesFor(this: *const Feature, browsers: Browsers) VendorPrefix {
+        var prefixes = VendorPrefix{ .none = true };
+        switch (this.*) {
+            .border_radius, .border_top_left_radius, .border_top_right_radius, .border_bottom_right_radius, .border_bottom_left_radius => {
+                if (browsers.android) |version| {
+                    if (version <= 131328) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version <= 262144) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version >= 131072 and version <= 198144) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version <= 197120) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 196864 and version <= 262144) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .box_shadow => {
+                if (browsers.android) |version| {
+                    if (version >= 131328 and version <= 196608) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version >= 262144 and version <= 589824) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version >= 197888 and version <= 198144) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 197120 and version <= 262656) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 196864 and version <= 327680) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .animation, .animation_name, .animation_duration, .animation_delay, .animation_direction, .animation_fill_mode, .animation_iteration_count, .animation_play_state, .animation_timing_function, .at_keyframes => {
+                if (browsers.android) |version| {
+                    if (version >= 131328 and version <= 263171) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version >= 262144 and version <= 2752512) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version >= 327680 and version <= 983040) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 197120 and version <= 524544) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version == 786432) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .o = true });
+                    }
+                    if (version >= 983040 and version <= 1900544) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 262144 and version <= 524288) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .transition, .transition_property, .transition_duration, .transition_delay, .transition_timing_function => {
+                if (browsers.android) |version| {
+                    if (version >= 131328 and version <= 262656) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version >= 262144 and version <= 1638400) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version >= 262144 and version <= 983040) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 197120 and version <= 393216) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 655360 and version <= 786432) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .o = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 196864 and version <= 393216) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .transform, .transform_origin => {
+                if (browsers.android) |version| {
+                    if (version >= 131328 and version <= 263171) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version >= 262144 and version <= 2293760) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version >= 197888 and version <= 983040) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.ie) |version| {
+                    if (version <= 589824) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .ms = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 197120 and version <= 524544) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 656640 and version <= 786432) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .o = true });
+                    }
+                    if (version >= 983040 and version <= 1441792) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 196864 and version <= 524288) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .perspective, .perspective_origin, .transform_style => {
+                if (browsers.android) |version| {
+                    if (version >= 196608 and version <= 263171) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version >= 786432 and version <= 2293760) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version >= 655360 and version <= 983040) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 197120 and version <= 524544) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 983040 and version <= 1441792) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 262144 and version <= 524288) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .backface_visibility => {
+                if (browsers.android) |version| {
+                    if (version >= 196608 and version <= 263171) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version >= 786432 and version <= 2293760) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version >= 655360 and version <= 983040) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 197120 and version <= 983552) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 983040 and version <= 1441792) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 262144 and version <= 983552) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .linear_gradient, .repeating_linear_gradient, .radial_gradient, .repeating_radial_gradient => {
+                if (browsers.android) |version| {
+                    if (version >= 131328 and version <= 262656) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version >= 262144 and version <= 1638400) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version >= 198144 and version <= 983040) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 197120 and version <= 393216) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 721152 and version <= 786432) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .o = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 262144 and version <= 393216) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .box_sizing => {
+                if (browsers.android) |version| {
+                    if (version >= 131328 and version <= 196608) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version >= 262144 and version <= 589824) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version >= 131072 and version <= 1835008) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 197120 and version <= 262656) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 196864 and version <= 327680) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .filter => {
+                if (browsers.android) |version| {
+                    if (version >= 263168 and version <= 263171) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version >= 1179648 and version <= 3407872) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 393216 and version <= 589824) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 983040 and version <= 2555904) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 393216 and version <= 589824) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version >= 262144 and version <= 393728) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .filter_function => {
+                if (browsers.ios_saf) |version| {
+                    if (version >= 589824 and version <= 590592) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version <= 589824) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .backdrop_filter => {
+                if (browsers.edge) |version| {
+                    if (version >= 1114112 and version <= 1179648) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 589824 and version <= 1115648) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 589824 and version <= 1115648) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .element => {
+                if (browsers.firefox) |version| {
+                    if (version >= 131072) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+            },
+            .columns, .column_width, .column_gap, .column_rule, .column_rule_color, .column_rule_width, .column_count, .column_rule_style, .column_span, .column_fill => {
+                if (browsers.android) |version| {
+                    if (version >= 131328 and version <= 263171) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version >= 262144 and version <= 3211264) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version >= 131072 and version <= 3342336) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 197120 and version <= 524544) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 983040 and version <= 2359296) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 196864 and version <= 524288) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version <= 262144) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .break_before, .break_after, .break_inside => {
+                if (browsers.android) |version| {
+                    if (version >= 131328 and version <= 263171) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version >= 262144 and version <= 3211264) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 197120 and version <= 524544) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 983040 and version <= 2359296) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 196864 and version <= 524288) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version <= 262144) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .user_select => {
+                if (browsers.android) |version| {
+                    if (version >= 131328 and version <= 263171) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version >= 262144 and version <= 3473408) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version >= 786432 and version <= 1179648) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .ms = true });
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version >= 131072 and version <= 4456448) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.ie) |version| {
+                    if (version >= 655360) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .ms = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 197120) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 983040 and version <= 2621440) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 196864) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version >= 262144 and version <= 327680) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .display_flex, .inline_flex, .flex, .flex_grow, .flex_shrink, .flex_basis, .flex_direction, .flex_wrap, .flex_flow, .justify_content, .order, .align_items, .align_self, .align_content => {
+                if (browsers.android) |version| {
+                    if (version >= 131328 and version <= 262656) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version >= 262144 and version <= 1835008) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version >= 131072 and version <= 1376256) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.ie) |version| {
+                    if (version == 655360) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .ms = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 197120 and version <= 524544) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 983040 and version <= 1048576) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 196864 and version <= 524288) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .calc => {
+                if (browsers.chrome) |version| {
+                    if (version >= 1245184 and version <= 1638400) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version >= 262144 and version <= 983040) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version <= 393216) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version <= 393216) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .background_origin, .background_size => {
+                if (browsers.android) |version| {
+                    if (version >= 131328 and version <= 131840) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version <= 198144) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version <= 655360) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .o = true });
+                    }
+                }
+            },
+            .background_clip => {
+                if (browsers.android) |version| {
+                    if (version >= 262144 and version <= 263171) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version >= 262144 and version <= 7798784) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version >= 786432 and version <= 917504) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .ms = true });
+                    }
+                    if (version >= 5177344 and version <= 7798784) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 393216 and version <= 852992) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 983040 and version <= 6881280) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 262144 and version <= 852224) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version >= 262144 and version <= 1572864) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .font_feature_settings, .font_variant_ligatures, .font_language_override => {
+                if (browsers.android) |version| {
+                    if (version >= 263168 and version <= 263171) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version >= 1048576 and version <= 3080192) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version >= 262144 and version <= 2162688) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 983040 and version <= 2228224) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version <= 262144) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .font_kerning => {
+                if (browsers.android) |version| {
+                    if (version <= 263168) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version >= 1900544 and version <= 2097152) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 524288 and version <= 721664) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 1048576 and version <= 1245184) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 458752 and version <= 589824) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .border_image => {
+                if (browsers.android) |version| {
+                    if (version >= 131328 and version <= 262656) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version >= 262144 and version <= 917504) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version >= 197888 and version <= 917504) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 197120 and version <= 327680) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 720896 and version <= 786688) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .o = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 196864 and version <= 327936) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .pseudo_element_selection => {
+                if (browsers.firefox) |version| {
+                    if (version >= 131072 and version <= 3997696) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+            },
+            .pseudo_element_placeholder => {
+                if (browsers.android) |version| {
+                    if (version >= 131328 and version <= 263171) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version >= 262144 and version <= 3670016) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version >= 786432 and version <= 1179648) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .ms = true });
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version >= 1179648 and version <= 3276800) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.ie) |version| {
+                    if (version >= 655360) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .ms = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 262656 and version <= 655360) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 983040 and version <= 2818048) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 327680 and version <= 655360) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version >= 262144 and version <= 393728) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .pseudo_class_placeholder_shown => {
+                if (browsers.firefox) |version| {
+                    if (version >= 262144 and version <= 3276800) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.ie) |version| {
+                    if (version >= 655360) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .ms = true });
+                    }
+                }
+            },
+            .hyphens => {
+                if (browsers.edge) |version| {
+                    if (version >= 786432 and version <= 1179648) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .ms = true });
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version >= 393216 and version <= 2752512) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.ie) |version| {
+                    if (version >= 655360) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .ms = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 262656 and version <= 1050112) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 327936 and version <= 1050112) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .pseudo_class_fullscreen => {
+                if (browsers.chrome) |version| {
+                    if (version >= 983040 and version <= 4587520) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version >= 655360 and version <= 4128768) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.ie) |version| {
+                    if (version >= 720896) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .ms = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 983040 and version <= 4128768) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 327936 and version <= 1049344) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version >= 262144 and version <= 590336) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .pseudo_element_backdrop => {
+                if (browsers.android) |version| {
+                    if (version >= 263168 and version <= 263171) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version >= 2097152 and version <= 2359296) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version >= 786432 and version <= 1179648) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .ms = true });
+                    }
+                }
+                if (browsers.ie != null) {
+                    prefixes = prefixes.bitwiseOr(VendorPrefix{ .ms = true });
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 1245184 and version <= 1507328) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .pseudo_element_file_selector_button => {
+                if (browsers.android) |version| {
+                    if (version >= 263168 and version <= 263171) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version >= 262144 and version <= 5767168) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version >= 786432 and version <= 1179648) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .ms = true });
+                    }
+                    if (version >= 5177344 and version <= 5767168) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.ie) |version| {
+                    if (version >= 655360) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .ms = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 197120 and version <= 917504) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 983040 and version <= 4849664) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 196864 and version <= 917504) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version >= 262144 and version <= 917504) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .pseudo_class_autofill => {
+                if (browsers.android) |version| {
+                    if (version >= 263168 and version <= 263171) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version >= 262144 and version <= 7143424) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version >= 5177344 and version <= 7143424) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 197120 and version <= 918784) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 983040 and version <= 6225920) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 196864 and version <= 917760) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version >= 262144 and version <= 1310720) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .tab_size => {
+                if (browsers.firefox) |version| {
+                    if (version >= 262144 and version <= 5898240) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 656896 and version <= 786688) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .o = true });
+                    }
+                }
+            },
+            .max_content, .min_content => {
+                if (browsers.android) |version| {
+                    if (version >= 263168 and version <= 263171) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version >= 1441792 and version <= 2949120) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version >= 196608 and version <= 4259840) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 458752 and version <= 852992) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 983040 and version <= 2097152) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 393472 and version <= 655616) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version <= 262144) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .fill, .fill_available => {
+                if (browsers.chrome) |version| {
+                    if (version >= 1441792) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version >= 263168) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version >= 5177344) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version >= 196608 and version <= 4259840) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 458752 and version <= 852992) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 983040) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 393472 and version <= 655616) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version >= 262144) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .fit_content => {
+                if (browsers.android) |version| {
+                    if (version >= 263168 and version <= 263171) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version >= 1441792 and version <= 2949120) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version >= 196608 and version <= 6094848) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 458752 and version <= 852992) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 983040 and version <= 2097152) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 393472 and version <= 655616) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version <= 262144) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .stretch => {
+                if (browsers.chrome) |version| {
+                    if (version >= 1441792) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version >= 196608) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version >= 263168) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version >= 5177344) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 458752) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 983040) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 458752) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version >= 327680) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .zoom_in, .zoom_out => {
+                if (browsers.chrome) |version| {
+                    if (version >= 262144 and version <= 2359296) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version >= 131072 and version <= 1507328) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 983040 and version <= 1507328) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 196864 and version <= 524288) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .grab, .grabbing => {
+                if (browsers.chrome) |version| {
+                    if (version >= 262144 and version <= 4390912) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version >= 131072 and version <= 1703936) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 983040 and version <= 3538944) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 196864 and version <= 655616) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .sticky => {
+                if (browsers.ios_saf) |version| {
+                    if (version >= 393216 and version <= 786944) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 393472 and version <= 786688) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .touch_action => {
+                if (browsers.ie) |version| {
+                    if (version == 655360) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .ms = true });
+                    }
+                }
+            },
+            .text_decoration_skip, .text_decoration_skip_ink => {
+                if (browsers.ios_saf) |version| {
+                    if (version >= 524288) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 459008 and version <= 786432) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .text_decoration => {
+                if (browsers.ios_saf) |version| {
+                    if (version >= 524288) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 524288) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .text_decoration_color, .text_decoration_line, .text_decoration_style => {
+                if (browsers.firefox) |version| {
+                    if (version >= 393216 and version <= 2293760) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 524288 and version <= 786432) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 524288 and version <= 786432) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .text_size_adjust => {
+                if (browsers.firefox != null) {
+                    prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                }
+                if (browsers.edge) |version| {
+                    if (version >= 786432 and version <= 1179648) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .ms = true });
+                    }
+                }
+                if (browsers.ie) |version| {
+                    if (version >= 655360) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .ms = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 327680) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .mask_clip, .mask_composite, .mask_image, .mask_origin, .mask_repeat, .mask_border_repeat, .mask_border_source, .mask, .mask_position, .mask_size, .mask_border, .mask_border_outset, .mask_border_width, .mask_border_slice => {
+                if (browsers.android) |version| {
+                    if (version >= 131328 and version <= 263171) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version >= 262144 and version <= 7798784) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version >= 5177344 and version <= 7798784) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 197120 and version <= 983552) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 983040 and version <= 6881280) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 262144 and version <= 983552) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version >= 262144 and version <= 1572864) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .clip_path => {
+                if (browsers.android) |version| {
+                    if (version >= 263168 and version <= 263171) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version >= 1572864 and version <= 3538944) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 458752 and version <= 589824) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 983040 and version <= 2686976) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 458752 and version <= 589824) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version >= 262144 and version <= 327680) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .box_decoration_break => {
+                if (browsers.chrome) |version| {
+                    if (version >= 1441792) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version >= 263168) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version >= 5177344) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 458752) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 983040) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 393472) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version >= 262144) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .object_fit, .object_position => {
+                if (browsers.opera) |version| {
+                    if (version >= 656896 and version <= 786688) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .o = true });
+                    }
+                }
+            },
+            .shape_margin, .shape_outside, .shape_image_threshold => {
+                if (browsers.ios_saf) |version| {
+                    if (version >= 524288 and version <= 655360) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 459008 and version <= 655360) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .text_overflow => {
+                if (browsers.opera) |version| {
+                    if (version >= 589824 and version <= 786432) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .o = true });
+                    }
+                }
+            },
+            .at_viewport => {
+                if (browsers.edge) |version| {
+                    if (version >= 786432 and version <= 1179648) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .ms = true });
+                    }
+                }
+                if (browsers.ie) |version| {
+                    if (version >= 655360) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .ms = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 720896 and version <= 786688) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .o = true });
+                    }
+                }
+            },
+            .at_resolution => {
+                if (browsers.android) |version| {
+                    if (version >= 131840 and version <= 262656) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version >= 262144 and version <= 1835008) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version >= 197888 and version <= 983040) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 262144 and version <= 984576) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 591104 and version <= 786432) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .o = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 262144 and version <= 984576) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .text_align_last => {
+                if (browsers.firefox) |version| {
+                    if (version >= 786432 and version <= 3145728) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+            },
+            .pixelated => {
+                if (browsers.firefox) |version| {
+                    if (version >= 198144 and version <= 4194304) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 327680 and version <= 393216) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 722432 and version <= 786688) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .o = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version <= 393216) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .image_rendering => {
+                if (browsers.ie) |version| {
+                    if (version >= 458752) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .ms = true });
+                    }
+                }
+            },
+            .border_inline_start, .border_inline_end, .margin_inline_start, .margin_inline_end, .padding_inline_start, .padding_inline_end => {
+                if (browsers.android) |version| {
+                    if (version >= 131328 and version <= 263171) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version >= 262144 and version <= 4456448) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version >= 196608 and version <= 2621440) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 197120 and version <= 786432) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 983040 and version <= 3604480) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 196864 and version <= 786432) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version >= 262144 and version <= 590336) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .border_block_start, .border_block_end, .margin_block_start, .margin_block_end, .padding_block_start, .padding_block_end => {
+                if (browsers.android) |version| {
+                    if (version >= 131328 and version <= 263171) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version >= 262144 and version <= 4456448) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 197120 and version <= 786432) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 983040 and version <= 3604480) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 196864 and version <= 786432) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version >= 262144 and version <= 590336) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .appearance => {
+                if (browsers.android) |version| {
+                    if (version >= 131328 and version <= 263171) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version >= 262144 and version <= 5439488) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version >= 786432 and version <= 1179648) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .ms = true });
+                    }
+                    if (version >= 5177344 and version <= 5439488) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version >= 131072 and version <= 5177344) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.ie != null) {
+                    prefixes = prefixes.bitwiseOr(VendorPrefix{ .ms = true });
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 197120 and version <= 983552) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 983040 and version <= 4718592) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 196864 and version <= 983552) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version >= 262144 and version <= 851968) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .scroll_snap_type, .scroll_snap_coordinate, .scroll_snap_destination, .scroll_snap_points_x, .scroll_snap_points_y => {
+                if (browsers.edge) |version| {
+                    if (version >= 786432 and version <= 1179648) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .ms = true });
+                    }
+                }
+                if (browsers.ie) |version| {
+                    if (version >= 655360) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .ms = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 589824 and version <= 656128) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 589824 and version <= 655616) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .flow_into, .flow_from, .region_fragment => {
+                if (browsers.chrome) |version| {
+                    if (version >= 983040 and version <= 1179648) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version >= 786432 and version <= 1179648) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .ms = true });
+                    }
+                }
+                if (browsers.ie) |version| {
+                    if (version >= 655360) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .ms = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 458752 and version <= 720896) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 393472 and version <= 720896) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .image_set => {
+                if (browsers.android) |version| {
+                    if (version >= 263168 and version <= 263171) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version >= 1376256 and version <= 7340032) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version >= 5177344 and version <= 7340032) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 393216 and version <= 590592) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 983040 and version <= 6422528) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 393216 and version <= 590080) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version >= 262144 and version <= 1441792) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .writing_mode => {
+                if (browsers.android) |version| {
+                    if (version >= 196608 and version <= 263171) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version >= 524288 and version <= 3080192) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.ie) |version| {
+                    if (version >= 328960) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .ms = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 327680 and version <= 656128) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 983040 and version <= 2228224) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 327936 and version <= 655616) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version <= 262144) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .cross_fade => {
+                if (browsers.chrome) |version| {
+                    if (version >= 1114112) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version >= 263168) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version >= 5177344) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 327680 and version <= 590592) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 983040) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 327936 and version <= 590080) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version >= 262144) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .pseudo_class_read_only, .pseudo_class_read_write => {
+                if (browsers.firefox) |version| {
+                    if (version >= 196608 and version <= 5046272) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+            },
+            .text_emphasis, .text_emphasis_position, .text_emphasis_style, .text_emphasis_color => {
+                if (browsers.android) |version| {
+                    if (version >= 263168 and version <= 263171) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version >= 1638400 and version <= 6422528) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version >= 5177344 and version <= 6422528) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 983040 and version <= 5570560) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 393472 and version <= 458752) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version >= 262144 and version <= 1114112) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .display_grid, .inline_grid, .grid_template_columns, .grid_template_rows, .grid_row_start, .grid_column_start, .grid_row_end, .grid_column_end, .grid_row, .grid_column, .grid_area, .grid_template, .grid_template_areas, .place_self, .grid_column_align, .grid_row_align => {
+                if (browsers.edge) |version| {
+                    if (version >= 786432 and version <= 983040) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .ms = true });
+                    }
+                }
+                if (browsers.ie) |version| {
+                    if (version >= 655360) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .ms = true });
+                    }
+                }
+            },
+            .text_spacing => {
+                if (browsers.edge) |version| {
+                    if (version >= 786432 and version <= 1179648) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .ms = true });
+                    }
+                }
+                if (browsers.ie) |version| {
+                    if (version >= 524288) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .ms = true });
+                    }
+                }
+            },
+            .pseudo_class_any_link => {
+                if (browsers.android) |version| {
+                    if (version >= 263168 and version <= 263171) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.chrome) |version| {
+                    if (version >= 983040 and version <= 4194304) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version >= 196608 and version <= 3211264) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 393216 and version <= 524544) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 983040 and version <= 3342336) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 393472 and version <= 524288) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version >= 327680 and version <= 524800) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .isolate => {
+                if (browsers.chrome) |version| {
+                    if (version >= 1048576 and version <= 3080192) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version >= 655360 and version <= 3211264) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 393216 and version <= 656128) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 983040 and version <= 2228224) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 393216 and version <= 655616) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .plaintext => {
+                if (browsers.firefox) |version| {
+                    if (version >= 655360 and version <= 3211264) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 393216 and version <= 656128) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 393216 and version <= 655616) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .isolate_override => {
+                if (browsers.firefox) |version| {
+                    if (version >= 1114112 and version <= 3211264) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 458752 and version <= 656128) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 458752 and version <= 655616) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .overscroll_behavior => {
+                if (browsers.edge) |version| {
+                    if (version >= 786432 and version <= 1114112) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .ms = true });
+                    }
+                }
+                if (browsers.ie) |version| {
+                    if (version >= 655360) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .ms = true });
+                    }
+                }
+            },
+            .text_orientation => {
+                if (browsers.safari) |version| {
+                    if (version >= 655616 and version <= 852224) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .print_color_adjust, .color_adjust => {
+                if (browsers.chrome) |version| {
+                    if (version >= 1114112) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version >= 263168) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version >= 5177344) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version >= 3145728 and version <= 6291456) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 393216 and version <= 983552) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 983040) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 393216 and version <= 983552) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version >= 262144) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+            .any_pseudo => {
+                if (browsers.chrome) |version| {
+                    if (version >= 786432 and version <= 5701632) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.edge) |version| {
+                    if (version >= 5177344 and version <= 5701632) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.firefox) |version| {
+                    if (version >= 262144 and version <= 5111808) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .moz = true });
+                    }
+                }
+                if (browsers.opera) |version| {
+                    if (version >= 917504 and version <= 4784128) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.safari) |version| {
+                    if (version >= 327680 and version <= 851968) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.ios_saf) |version| {
+                    if (version >= 327680 and version <= 851968) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.samsung) |version| {
+                    if (version >= 65536 and version <= 917504) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+                if (browsers.android) |version| {
+                    if (version >= 2424832 and version <= 5701632) {
+                        prefixes = prefixes.bitwiseOr(VendorPrefix{ .webkit = true });
+                    }
+                }
+            },
+        }
+        return prefixes;
+    }
+
+    pub fn isFlex2009(browsers: Browsers) bool {
+        if (browsers.android) |version| {
+            if (version >= 131328 and version <= 262656) {
+                return true;
+            }
+        }
+        if (browsers.chrome) |version| {
+            if (version >= 262144 and version <= 1310720) {
+                return true;
+            }
+        }
+        if (browsers.ios_saf) |version| {
+            if (version >= 197120 and version <= 393216) {
+                return true;
+            }
+        }
+        if (browsers.safari) |version| {
+            if (version >= 196864 and version <= 393216) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    pub fn isWebkitGradient(browsers: Browsers) bool {
+        if (browsers.android) |version| {
+            if (version >= 131328 and version <= 196608) {
+                return true;
+            }
+        }
+        if (browsers.chrome) |version| {
+            if (version >= 262144 and version <= 589824) {
+                return true;
+            }
+        }
+        if (browsers.ios_saf) |version| {
+            if (version >= 197120 and version <= 393216) {
+                return true;
+            }
+        }
+        if (browsers.safari) |version| {
+            if (version >= 262144 and version <= 393216) {
+                return true;
+            }
+        }
+        return false;
+    }
+};
diff --git a/src/css/printer.zig b/src/css/printer.zig
new file mode 100644
index 0000000000..9d7b029e2a
--- /dev/null
+++ b/src/css/printer.zig
@@ -0,0 +1,480 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const bun = @import("root").bun;
+const logger = bun.logger;
+const Log = logger.Log;
+
+pub const css = @import("./css_parser.zig");
+pub const css_values = @import("./values/values.zig");
+const DashedIdent = css_values.ident.DashedIdent;
+const Ident = css_values.ident.Ident;
+pub const Error = css.Error;
+const Location = css.Location;
+const PrintErr = css.PrintErr;
+
+const ArrayList = std.ArrayListUnmanaged;
+
+const sourcemap = @import("./sourcemap.zig");
+
+/// Options that control how CSS is serialized to a string.
+pub const PrinterOptions = struct {
+    /// Whether to minify the CSS, i.e. remove white space.
+    minify: bool = false,
+    /// An optional reference to a source map to write mappings into.
+    /// (Available when the `sourcemap` feature is enabled.)
+    source_map: ?*sourcemap.SourceMap = null,
+    /// An optional project root path, used to generate relative paths for sources used in CSS module hashes.
+    project_root: ?[]const u8 = null,
+    /// Targets to output the CSS for.
+    targets: Targets = .{},
+    /// Whether to analyze dependencies (i.e. `@import` and `url()`).
+    /// If true, the dependencies are returned as part of the
+    /// [ToCssResult](super::stylesheet::ToCssResult).
+    ///
+    /// When enabled, `@import` and `url()` dependencies
+    /// are replaced with hashed placeholders that can be replaced with the final
+    /// urls later (after bundling).
+    analyze_dependencies: ?css.dependencies.DependencyOptions = null,
+    /// A mapping of pseudo classes to replace with class names that can be applied
+    /// from JavaScript. Useful for polyfills, for example.
+    pseudo_classes: ?PseudoClasses = null,
+    public_path: []const u8 = "",
+};
+
+/// A mapping of user action pseudo classes to replace with class names.
+///
+/// See [PrinterOptions](PrinterOptions).
+const PseudoClasses = struct {
+    /// The class name to replace `:hover` with.
+    hover: ?[]const u8 = null,
+    /// The class name to replace `:active` with.
+    active: ?[]const u8 = null,
+    /// The class name to replace `:focus` with.
+    focus: ?[]const u8 = null,
+    /// The class name to replace `:focus-visible` with.
+    focus_visible: ?[]const u8 = null,
+    /// The class name to replace `:focus-within` with.
+    focus_within: ?[]const u8 = null,
+};
+
+pub const Targets = css.targets.Targets;
+
+pub const Features = css.targets.Features;
+
+const Browsers = css.targets.Browsers;
+
+/// A `Printer` represents a destination to output serialized CSS, as used in
+/// the [ToCss](super::traits::ToCss) trait. It can wrap any destination that
+/// implements [std::fmt::Write](std::fmt::Write), such as a [String](String).
+///
+/// A `Printer` keeps track of the current line and column position, and uses
+/// this to generate a source map if provided in the options.
+///
+/// `Printer` also includes helper functions that assist with writing output
+/// that respects options such as `minify`, and `css_modules`.
+pub fn Printer(comptime Writer: type) type {
+    return struct {
+        // #[cfg(feature = "sourcemap")]
+        sources: ?*const ArrayList([]const u8),
+        dest: Writer,
+        loc: Location = Location{
+            .source_index = 0,
+            .line = 0,
+            .column = 1,
+        },
+        indent_amt: u8 = 0,
+        line: u32 = 0,
+        col: u32 = 0,
+        minify: bool,
+        targets: Targets,
+        vendor_prefix: css.VendorPrefix = css.VendorPrefix.empty(),
+        in_calc: bool = false,
+        css_module: ?css.CssModule = null,
+        dependencies: ?ArrayList(css.Dependency) = null,
+        remove_imports: bool,
+        pseudo_classes: ?PseudoClasses = null,
+        indentation_buf: std.ArrayList(u8),
+        ctx: ?*const css.StyleContext = null,
+        scratchbuf: std.ArrayList(u8),
+        error_kind: ?css.PrinterError = null,
+        import_records: ?*const bun.BabyList(bun.ImportRecord),
+        public_path: []const u8,
+        /// NOTE This should be the same mimalloc heap arena allocator
+        allocator: Allocator,
+        // TODO: finish the fields
+
+        const This = @This();
+
+        inline fn getWrittenAmt(writer: Writer) usize {
+            return switch (Writer) {
+                ArrayList(u8).Writer => writer.context.self.items.len,
+                *bun.js_printer.BufferWriter => writer.written.len,
+                else => @compileError("Dunno what to do with this type yo: " ++ @typeName(Writer)),
+            };
+        }
+
+        /// Returns the current source filename that is being printed.
+        pub fn filename(this: *const This) []const u8 {
+            if (this.sources) |sources| {
+                if (this.loc.source_index < sources.items.len) return sources.items[this.loc.source_index];
+            }
+            return "unknown.css";
+        }
+
+        /// Returns whether the indent level is greater than one.
+        pub fn isNested(this: *const This) bool {
+            return this.indent_amt > 2;
+        }
+
+        /// Add an error related to std lib fmt errors
+        pub fn addFmtError(this: *This) PrintErr!void {
+            this.error_kind = css.PrinterError{
+                .kind = .fmt_error,
+                .loc = null,
+            };
+            return PrintErr.lol;
+        }
+
+        pub fn addNoImportRecordError(this: *This) PrintErr!void {
+            this.error_kind = css.PrinterError{
+                .kind = .no_import_records,
+                .loc = null,
+            };
+            return PrintErr.lol;
+        }
+
+        /// Returns an error of the given kind at the provided location in the current source file.
+        pub fn newError(
+            this: *This,
+            kind: css.PrinterErrorKind,
+            maybe_loc: ?css.dependencies.Location,
+        ) PrintErr!void {
+            bun.debugAssert(this.error_kind == null);
+            this.error_kind = css.PrinterError{
+                .kind = kind,
+                .loc = if (maybe_loc) |loc| css.ErrorLocation{
+                    .filename = this.filename(),
+                    .line = loc.line - 1,
+                    .column = loc.column,
+                } else null,
+            };
+            return PrintErr.lol;
+        }
+
+        pub fn deinit(this: *This) void {
+            this.scratchbuf.deinit();
+            this.indentation_buf.deinit();
+            if (this.dependencies) |*dependencies| {
+                dependencies.deinit(this.allocator);
+            }
+        }
+
+        /// If `import_records` is null, then the printer will error when it encounters code that relies on import records (urls())
+        pub fn new(
+            allocator: Allocator,
+            scratchbuf: std.ArrayList(u8),
+            dest: Writer,
+            options: PrinterOptions,
+            import_records: ?*const bun.BabyList(bun.ImportRecord),
+        ) This {
+            return .{
+                .sources = null,
+                .dest = dest,
+                .minify = options.minify,
+                .targets = options.targets,
+                .dependencies = if (options.analyze_dependencies != null) ArrayList(css.Dependency){} else null,
+                .remove_imports = options.analyze_dependencies != null and options.analyze_dependencies.?.remove_imports,
+                .pseudo_classes = options.pseudo_classes,
+                .indentation_buf = std.ArrayList(u8).init(allocator),
+                .import_records = import_records,
+                .scratchbuf = scratchbuf,
+                .allocator = allocator,
+                .public_path = options.public_path,
+                .loc = Location{
+                    .source_index = 0,
+                    .line = 0,
+                    .column = 1,
+                },
+            };
+        }
+
+        pub inline fn getImportRecords(this: *This) PrintErr!*const bun.BabyList(bun.ImportRecord) {
+            if (this.import_records) |import_records| return import_records;
+            try this.addNoImportRecordError();
+            unreachable;
+        }
+
+        pub fn printImportRecord(this: *This, import_record_idx: u32) PrintErr!void {
+            if (this.import_records) |import_records| {
+                const import_record = import_records.at(import_record_idx);
+                const a, const b = bun.bundle_v2.cheapPrefixNormalizer(this.public_path, import_record.path.text);
+                try this.writeStr(a);
+                try this.writeStr(b);
+                return;
+            }
+            return this.addNoImportRecordError();
+        }
+
+        pub inline fn importRecord(this: *Printer(Writer), import_record_idx: u32) PrintErr!*const bun.ImportRecord {
+            if (this.import_records) |import_records| return import_records.at(import_record_idx);
+            try this.addNoImportRecordError();
+            unreachable;
+        }
+
+        pub inline fn getImportRecordUrl(this: *This, import_record_idx: u32) PrintErr![]const u8 {
+            return (try this.importRecord(import_record_idx)).path.text;
+        }
+
+        pub fn context(this: *const Printer(Writer)) ?*const css.StyleContext {
+            return this.ctx;
+        }
+
+        /// To satisfy io.Writer interface
+        ///
+        /// NOTE: Same constraints as `writeStr`, the `str` param is assumted to not
+        /// contain any newline characters
+        pub fn writeAll(this: *This, str: []const u8) !void {
+            return this.writeStr(str) catch std.mem.Allocator.Error.OutOfMemory;
+        }
+
+        pub fn writeComment(this: *This, comment: []const u8) PrintErr!void {
+            _ = this.dest.writeAll(comment) catch {
+                return this.addFmtError();
+            };
+            const new_lines = std.mem.count(u8, comment, "\n");
+            this.line += @intCast(new_lines);
+            this.col = 0;
+            const last_line_start = comment.len - (std.mem.lastIndexOfScalar(u8, comment, '\n') orelse comment.len);
+            this.col += @intCast(last_line_start);
+            return;
+        }
+
+        /// Writes a raw string to the underlying destination.
+        ///
+        /// NOTE: Is is assumed that the string does not contain any newline characters.
+        /// If such a string is written, it will break source maps.
+        pub fn writeStr(this: *This, s: []const u8) PrintErr!void {
+            if (comptime bun.Environment.isDebug) {
+                bun.assert(std.mem.indexOfScalar(u8, s, '\n') == null);
+            }
+            this.col += @intCast(s.len);
+            _ = this.dest.writeAll(s) catch {
+                return this.addFmtError();
+            };
+            return;
+        }
+
+        /// Writes a formatted string to the underlying destination.
+        ///
+        /// NOTE: Is is assumed that the formatted string does not contain any newline characters.
+        /// If such a string is written, it will break source maps.
+        pub fn writeFmt(this: *This, comptime fmt: []const u8, args: anytype) PrintErr!void {
+            // assuming the writer comes from an ArrayList
+            const start: usize = getWrittenAmt(this.dest);
+            this.dest.print(fmt, args) catch bun.outOfMemory();
+            const written = getWrittenAmt(this.dest) - start;
+            this.col += @intCast(written);
+        }
+
+        fn replaceDots(allocator: Allocator, s: []const u8) []const u8 {
+            var str = allocator.dupe(u8, s) catch bun.outOfMemory();
+            std.mem.replaceScalar(u8, str[0..], '.', '-');
+            return str;
+        }
+
+        /// Writes a CSS identifier to the underlying destination, escaping it
+        /// as appropriate. If the `css_modules` option was enabled, then a hash
+        /// is added, and the mapping is added to the CSS module.
+        pub fn writeIdent(this: *This, ident: []const u8, handle_css_module: bool) PrintErr!void {
+            if (handle_css_module) {
+                if (this.css_module) |*css_module| {
+                    const Closure = struct { first: bool, printer: *This };
+                    var closure = Closure{ .first = true, .printer = this };
+                    css_module.config.pattern.write(
+                        css_module.hashes.items[this.loc.source_index],
+                        css_module.sources.items[this.loc.source_index],
+                        ident,
+                        &closure,
+                        struct {
+                            pub fn writeFn(self: *Closure, s1: []const u8, replace_dots: bool) void {
+                                // PERF: stack fallback?
+                                const s = if (!replace_dots) s1 else replaceDots(self.printer.allocator, s1);
+                                defer if (replace_dots) self.printer.allocator.free(s);
+                                self.printer.col += @intCast(s.len);
+                                if (self.first) {
+                                    self.first = false;
+                                    return css.serializer.serializeIdentifier(s, self.printer) catch |e| css.OOM(e);
+                                } else {
+                                    return css.serializer.serializeName(s, self.printer) catch |e| css.OOM(e);
+                                }
+                            }
+                        }.writeFn,
+                    );
+
+                    css_module.addLocal(this.allocator, ident, ident, this.loc.source_index);
+                    return;
+                }
+            }
+
+            return css.serializer.serializeIdentifier(ident, this) catch return this.addFmtError();
+        }
+
+        pub fn writeDashedIdent(this: *This, ident: *const DashedIdent, is_declaration: bool) !void {
+            try this.writeStr("--");
+
+            if (this.css_module) |*css_module| {
+                if (css_module.config.dashed_idents) {
+                    const Fn = struct {
+                        pub fn writeFn(self: *This, s1: []const u8, replace_dots: bool) void {
+                            const s = if (!replace_dots) s1 else replaceDots(self.allocator, s1);
+                            defer if (replace_dots) self.allocator.free(s);
+                            self.col += @intCast(s.len);
+                            return css.serializer.serializeName(s, self) catch |e| css.OOM(e);
+                        }
+                    };
+                    css_module.config.pattern.write(
+                        css_module.hashes.items[this.loc.source_index],
+                        css_module.sources.items[this.loc.source_index],
+                        ident.v[2..],
+                        this,
+                        Fn.writeFn,
+                    );
+
+                    if (is_declaration) {
+                        css_module.addDashed(this.allocator, ident.v, this.loc.source_index);
+                    }
+                }
+            }
+
+            return css.serializer.serializeName(ident.v[2..], this) catch return this.addFmtError();
+        }
+
+        pub fn writeByte(this: *This, char: u8) !void {
+            return this.writeChar(char) catch return Allocator.Error.OutOfMemory;
+        }
+
+        /// Write a single character to the underlying destination.
+        pub fn writeChar(this: *This, char: u8) PrintErr!void {
+            if (char == '\n') {
+                this.line += 1;
+                this.col = 0;
+            } else {
+                this.col += 1;
+            }
+            _ = this.dest.writeByte(char) catch {
+                return this.addFmtError();
+            };
+        }
+
+        /// Writes a newline character followed by indentation.
+        /// If the `minify` option is enabled, then nothing is printed.
+        pub fn newline(this: *This) PrintErr!void {
+            if (this.minify) {
+                return;
+            }
+
+            try this.writeChar('\n');
+            return this.writeIndent();
+        }
+
+        /// Writes a delimiter character, followed by whitespace (depending on the `minify` option).
+        /// If `ws_before` is true, then whitespace is also written before the delimiter.
+        pub fn delim(this: *This, delim_: u8, ws_before: bool) PrintErr!void {
+            if (ws_before) {
+                try this.whitespace();
+            }
+            try this.writeChar(delim_);
+            return this.whitespace();
+        }
+
+        /// Writes a single whitespace character, unless the `minify` option is enabled.
+        ///
+        /// Use `write_char` instead if you wish to force a space character to be written,
+        /// regardless of the `minify` option.
+        pub fn whitespace(this: *This) PrintErr!void {
+            if (this.minify) return;
+            return this.writeChar(' ');
+        }
+
+        pub fn withContext(
+            this: *This,
+            selectors: *const css.SelectorList,
+            closure: anytype,
+            comptime func: anytype,
+        ) PrintErr!void {
+            const parent = if (this.ctx) |ctx| parent: {
+                this.ctx = null;
+                break :parent ctx;
+            } else null;
+
+            const ctx = css.StyleContext{ .selectors = selectors, .parent = parent };
+
+            this.ctx = &ctx;
+            const res = func(closure, Writer, this);
+            this.ctx = parent;
+
+            return res;
+        }
+
+        pub fn withClearedContext(
+            this: *This,
+            closure: anytype,
+            comptime func: anytype,
+        ) PrintErr!void {
+            const parent = if (this.ctx) |ctx| parent: {
+                this.ctx = null;
+                break :parent ctx;
+            } else null;
+            const res = func(closure, Writer, this);
+            this.ctx = parent;
+            return res;
+        }
+
+        /// Increases the current indent level.
+        pub fn indent(this: *This) void {
+            this.indent_amt += 2;
+        }
+
+        /// Decreases the current indent level.
+        pub fn dedent(this: *This) void {
+            this.indent_amt -= 2;
+        }
+
+        const INDENTS: []const []const u8 = indents: {
+            const levels = 32;
+            var indents: [levels][]const u8 = undefined;
+            for (0..levels) |i| {
+                const n = i * 2;
+                var str: [n]u8 = undefined;
+                for (0..n) |j| {
+                    str[j] = ' ';
+                }
+                indents[i] = str;
+            }
+            break :indents indents;
+        };
+
+        fn getIndent(this: *This, idnt: u8) []const u8 {
+            // divide by 2 to get index into table
+            const i = idnt >> 1;
+            // PERF: may be faster to just do `i < (IDENTS.len - 1) * 2` (e.g. 62 if IDENTS.len == 32) here
+            if (i < INDENTS.len) {
+                return INDENTS[i];
+            }
+            if (this.indentation_buf.items.len < idnt) {
+                this.indentation_buf.appendNTimes(' ', this.indentation_buf.items.len - idnt) catch unreachable;
+            } else {
+                this.indentation_buf.items = this.indentation_buf.items[0..idnt];
+            }
+            return this.indentation_buf.items;
+        }
+
+        fn writeIndent(this: *This) PrintErr!void {
+            bun.debugAssert(!this.minify);
+            if (this.indent_amt > 0) {
+                // try this.writeStr(this.getIndent(this.ident));
+                this.dest.writeByteNTimes(' ', this.indent_amt) catch return this.addFmtError();
+            }
+        }
+    };
+}
diff --git a/src/css/properties/align.zig b/src/css/properties/align.zig
new file mode 100644
index 0000000000..d5f3f5b716
--- /dev/null
+++ b/src/css/properties/align.zig
@@ -0,0 +1,1085 @@
+const std = @import("std");
+const bun = @import("root").bun;
+const Allocator = std.mem.Allocator;
+const ArrayList = std.ArrayListUnmanaged;
+
+pub const css = @import("../css_parser.zig");
+
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+
+const LengthPercentage = css.css_values.length.LengthPercentage;
+
+/// A value for the [align-content](https://www.w3.org/TR/css-align-3/#propdef-align-content) property.
+pub const AlignContent = union(enum) {
+    /// Default alignment.
+    normal: void,
+    /// A baseline position.
+    baseline_position: BaselinePosition,
+    /// A content distribution keyword.
+    content_distribution: ContentDistribution,
+    /// A content position keyword.
+    content_position: struct {
+        /// An overflow alignment mode.
+        overflow: ?OverflowPosition,
+        /// A content position keyword.
+        value: ContentPosition,
+
+        pub fn toInner(this: *const @This()) ContentPositionInner {
+            return .{
+                .overflow = this.overflow,
+                .value = this.value,
+            };
+        }
+
+        pub fn __generateToCss() void {}
+
+        pub fn parse(input: *css.Parser) css.Result(@This()) {
+            const overflow = OverflowPosition.parse(input).asValue();
+            const value = switch (ContentPosition.parse(input)) {
+                .result => |v| v,
+                .err => |e| return .{ .err = e },
+            };
+            return .{ .result = .{ .overflow = overflow, .value = value } };
+        }
+
+        pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+            return css.implementEql(@This(), lhs, rhs);
+        }
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    },
+
+    pub usingnamespace css.DeriveParse(@This());
+    pub usingnamespace css.DeriveToCss(@This());
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A [`<baseline-position>`](https://www.w3.org/TR/css-align-3/#typedef-baseline-position) value,
+/// as used in the alignment properties.
+pub const BaselinePosition = enum {
+    /// The first baseline.
+    first,
+    /// The last baseline.
+    last,
+
+    pub fn parse(input: *css.Parser) css.Result(@This()) {
+        const location = input.currentSourceLocation();
+        const ident = switch (input.expectIdent()) {
+            .err => |e| return .{ .err = e },
+            .result => |v| v,
+        };
+
+        const BaselinePositionIdent = enum {
+            baseline,
+            first,
+            last,
+        };
+
+        const BaselinePositionMap = bun.ComptimeEnumMap(BaselinePositionIdent);
+        if (BaselinePositionMap.getASCIIICaseInsensitive(ident)) |value|
+            switch (value) {
+                .baseline => return .{ .result = BaselinePosition.first },
+                .first => {
+                    if (input.expectIdentMatching("baseline").asErr()) |e| return .{ .err = e };
+                    return .{ .result = BaselinePosition.first };
+                },
+                .last => {
+                    if (input.expectIdentMatching("baseline").asErr()) |e| return .{ .err = e };
+                    return .{ .result = BaselinePosition.last };
+                },
+            }
+        else
+            return .{ .err = location.newUnexpectedTokenError(.{ .ident = ident }) };
+    }
+
+    pub fn toCss(this: *const BaselinePosition, comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+        return switch (this.*) {
+            .first => try dest.writeStr("baseline"),
+            .last => try dest.writeStr("last baseline"),
+        };
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A value for the [justify-content](https://www.w3.org/TR/css-align-3/#propdef-justify-content) property.
+pub const JustifyContent = union(enum) {
+    /// Default justification.
+    normal,
+    /// A content distribution keyword.
+    content_distribution: ContentDistribution,
+    /// A content position keyword.
+    content_position: struct {
+        /// A content position keyword.
+        value: ContentPosition,
+        /// An overflow alignment mode.
+        overflow: ?OverflowPosition,
+
+        pub fn toInner(this: *const @This()) ContentPositionInner {
+            return .{
+                .overflow = this.overflow,
+                .value = this.value,
+            };
+        }
+
+        pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+            return css.implementEql(@This(), lhs, rhs);
+        }
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    },
+    /// Justify to the left.
+    left: struct {
+        /// An overflow alignment mode.
+        overflow: ?OverflowPosition,
+
+        pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+            return css.implementEql(@This(), lhs, rhs);
+        }
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    },
+    /// Justify to the right.
+    right: struct {
+        /// An overflow alignment mode.
+        overflow: ?OverflowPosition,
+
+        pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+            return css.implementEql(@This(), lhs, rhs);
+        }
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    },
+
+    pub fn parse(input: *css.Parser) css.Result(@This()) {
+        if (input.expectIdentMatching("normal").isOk()) {
+            return .{ .result = .normal };
+        }
+
+        if (ContentDistribution.parse(input).asValue()) |val| {
+            return .{ .result = .{ .content_distribution = val } };
+        }
+
+        const overflow = OverflowPosition.parse(input).asValue();
+        if (ContentPosition.parse(input).asValue()) |content_position| {
+            return .{ .result = .{
+                .content_position = .{
+                    .overflow = overflow,
+                    .value = content_position,
+                },
+            } };
+        }
+
+        const location = input.currentSourceLocation();
+        const ident = switch (input.expectIdent()) {
+            .result => |v| v,
+            .err => |e| return .{ .err = e },
+        };
+
+        const JustifyContentIdent = enum {
+            left,
+            right,
+        };
+
+        const JustifyContentIdentMap = bun.ComptimeEnumMap(JustifyContentIdent);
+        if (JustifyContentIdentMap.getASCIIICaseInsensitive(ident)) |value|
+            return switch (value) {
+                .left => .{ .result = .{ .left = .{ .overflow = overflow } } },
+                .right => .{ .result = .{ .right = .{ .overflow = overflow } } },
+            }
+        else
+            return .{ .err = location.newUnexpectedTokenError(.{ .ident = ident }) };
+    }
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+        return switch (this.*) {
+            .normal => dest.writeStr("normal"),
+            .content_distribution => |value| value.toCss(W, dest),
+            .content_position => |*cp| {
+                if (cp.overflow) |*overflow| {
+                    try overflow.toCss(W, dest);
+                    try dest.writeStr(" ");
+                }
+                return cp.value.toCss(W, dest);
+            },
+            .left => |*l| {
+                if (l.overflow) |*overflow| {
+                    try overflow.toCss(W, dest);
+                    try dest.writeStr(" ");
+                }
+                return dest.writeStr("left");
+            },
+            .right => |*r| {
+                if (r.overflow) |*overflow| {
+                    try overflow.toCss(W, dest);
+                    try dest.writeStr(" ");
+                }
+                return dest.writeStr("right");
+            },
+        };
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A value for the [align-self](https://www.w3.org/TR/css-align-3/#align-self-property) property.
+pub const AlignSelf = union(enum) {
+    /// Automatic alignment.
+    auto,
+    /// Default alignment.
+    normal,
+    /// Item is stretched.
+    stretch,
+    /// A baseline position keyword.
+    baseline_position: BaselinePosition,
+    /// A self position keyword.
+    self_position: struct {
+        /// An overflow alignment mode.
+        overflow: ?OverflowPosition,
+        /// A self position keyword.
+        value: SelfPosition,
+
+        pub fn toInner(this: *const @This()) SelfPositionInner {
+            return .{
+                .overflow = this.overflow,
+                .value = this.value,
+            };
+        }
+
+        pub fn __generateToCss() void {}
+
+        pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+            return css.implementEql(@This(), lhs, rhs);
+        }
+
+        pub fn parse(input: *css.Parser) css.Result(@This()) {
+            const overflow = OverflowPosition.parse(input).asValue();
+            const self_position = switch (SelfPosition.parse(input)) {
+                .result => |v| v,
+                .err => |e| return .{ .err = e },
+            };
+            return .{
+                .result = .{
+                    .overflow = overflow,
+                    .value = self_position,
+                },
+            };
+        }
+    },
+
+    pub usingnamespace css.DeriveParse(@This());
+    pub usingnamespace css.DeriveToCss(@This());
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+/// A value for the [justify-self](https://www.w3.org/TR/css-align-3/#justify-self-property) property.
+pub const JustifySelf = union(enum) {
+    /// Automatic justification.
+    auto,
+    /// Default justification.
+    normal,
+    /// Item is stretched.
+    stretch,
+    /// A baseline position keyword.
+    baseline_position: BaselinePosition,
+    /// A self position keyword.
+    self_position: struct {
+        /// A self position keyword.
+        value: SelfPosition,
+        /// An overflow alignment mode.
+        overflow: ?OverflowPosition,
+
+        pub fn toInner(this: *const @This()) SelfPositionInner {
+            return .{
+                .overflow = this.overflow,
+                .value = this.value,
+            };
+        }
+
+        pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+            return css.implementEql(@This(), lhs, rhs);
+        }
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    },
+    /// Item is justified to the left.
+    left: struct {
+        /// An overflow alignment mode.
+        overflow: ?OverflowPosition,
+
+        pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+            return css.implementEql(@This(), lhs, rhs);
+        }
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    },
+    /// Item is justified to the right.
+    right: struct {
+        /// An overflow alignment mode.
+        overflow: ?OverflowPosition,
+
+        pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+            return css.implementEql(@This(), lhs, rhs);
+        }
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    },
+
+    pub fn parse(input: *css.Parser) css.Result(@This()) {
+        if (input.tryParse(css.Parser.expectIdentMatching, .{"auto"}).isOk()) {
+            return .{ .result = .auto };
+        }
+
+        if (input.tryParse(css.Parser.expectIdentMatching, .{"normal"}).isOk()) {
+            return .{ .result = .normal };
+        }
+
+        if (input.tryParse(css.Parser.expectIdentMatching, .{"stretch"}).isOk()) {
+            return .{ .result = .stretch };
+        }
+
+        if (input.tryParse(BaselinePosition.parse, .{}).asValue()) |val| {
+            return .{ .result = .{ .baseline_position = val } };
+        }
+
+        const overflow = input.tryParse(OverflowPosition.parse, .{}).asValue();
+        if (input.tryParse(SelfPosition.parse, .{}).asValue()) |self_position| {
+            return .{ .result = .{ .self_position = .{ .overflow = overflow, .value = self_position } } };
+        }
+
+        const location = input.currentSourceLocation();
+        const ident = switch (input.expectIdent()) {
+            .result => |v| v,
+            .err => |e| return .{ .err = e },
+        };
+        const Enum = enum { left, right };
+        const Map = bun.ComptimeEnumMap(Enum);
+        if (Map.getASCIIICaseInsensitive(ident)) |val| return .{ .result = switch (val) {
+            .left => .{ .left = .{ .overflow = overflow } },
+            .right => .{ .right = .{ .overflow = overflow } },
+        } };
+        return .{ .err = location.newUnexpectedTokenError(.{ .ident = ident }) };
+    }
+
+    pub fn toCss(this: *const JustifySelf, comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+        return switch (this.*) {
+            .auto => try dest.writeStr("auto"),
+            .normal => try dest.writeStr("normal"),
+            .stretch => try dest.writeStr("stretch"),
+            .baseline_position => |*baseline_position| baseline_position.toCss(W, dest),
+            .self_position => |*self_position| {
+                if (self_position.overflow) |*overflow| {
+                    try overflow.toCss(W, dest);
+                    try dest.writeStr(" ");
+                }
+
+                try self_position.value.toCss(W, dest);
+            },
+            .left => |*left| {
+                if (left.overflow) |*overflow| {
+                    try overflow.toCss(W, dest);
+                    try dest.writeStr(" ");
+                }
+                try dest.writeStr("left");
+            },
+            .right => |*right| {
+                if (right.overflow) |*overflow| {
+                    try overflow.toCss(W, dest);
+                    try dest.writeStr(" ");
+                }
+                try dest.writeStr("right");
+            },
+        };
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A value for the [align-items](https://www.w3.org/TR/css-align-3/#align-items-property) property.
+pub const AlignItems = union(enum) {
+    /// Default alignment.
+    normal,
+    /// Items are stretched.
+    stretch,
+    /// A baseline position keyword.
+    baseline_position: BaselinePosition,
+    /// A self position keyword.
+    self_position: struct {
+        /// An overflow alignment mode.
+        overflow: ?OverflowPosition,
+        /// A self position keyword.
+        value: SelfPosition,
+
+        pub fn toInner(this: *const @This()) SelfPositionInner {
+            return .{
+                .overflow = this.overflow,
+                .value = this.value,
+            };
+        }
+
+        pub fn parse(input: *css.Parser) css.Result(@This()) {
+            const overflow = OverflowPosition.parse(input).asValue();
+            const self_position = switch (SelfPosition.parse(input)) {
+                .result => |v| v,
+                .err => |e| return .{ .err = e },
+            };
+            return .{
+                .result = .{
+                    .overflow = overflow,
+                    .value = self_position,
+                },
+            };
+        }
+
+        pub fn __generateToCss() void {}
+
+        pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+            return css.implementEql(@This(), lhs, rhs);
+        }
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    },
+
+    pub usingnamespace css.DeriveParse(@This());
+    pub usingnamespace css.DeriveToCss(@This());
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A value for the [justify-items](https://www.w3.org/TR/css-align-3/#justify-items-property) property.
+pub const JustifyItems = union(enum) {
+    /// Default justification.
+    normal,
+    /// Items are stretched.
+    stretch,
+    /// A baseline position keyword.
+    baseline_position: BaselinePosition,
+    /// A self position keyword, with optional overflow position.
+    self_position: struct {
+        /// A self position keyword.
+        value: SelfPosition,
+        /// An overflow alignment mode.
+        overflow: ?OverflowPosition,
+
+        pub fn toInner(this: *const @This()) SelfPositionInner {
+            return .{
+                .overflow = this.overflow,
+                .value = this.value,
+            };
+        }
+
+        pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+            return css.implementEql(@This(), lhs, rhs);
+        }
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    },
+    /// Items are justified to the left, with an optional overflow position.
+    left: struct {
+        /// An overflow alignment mode.
+        overflow: ?OverflowPosition,
+
+        pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+            return css.implementEql(@This(), lhs, rhs);
+        }
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    },
+    /// Items are justified to the right, with an optional overflow position.
+    right: struct {
+        /// An overflow alignment mode.
+        overflow: ?OverflowPosition,
+
+        pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+            return css.implementEql(@This(), lhs, rhs);
+        }
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    },
+    /// A legacy justification keyword.
+    legacy: LegacyJustify,
+
+    pub fn parse(input: *css.Parser) css.Result(@This()) {
+        if (input.tryParse(css.Parser.expectIdentMatching, .{"normal"}).isOk()) {
+            return .{ .result = .normal };
+        }
+
+        if (input.tryParse(css.Parser.expectIdentMatching, .{"stretch"}).isOk()) {
+            return .{ .result = .stretch };
+        }
+
+        if (input.tryParse(BaselinePosition.parse, .{}).asValue()) |val| {
+            return .{ .result = .{ .baseline_position = val } };
+        }
+
+        if (input.tryParse(LegacyJustify.parse, .{}).asValue()) |val| {
+            return .{ .result = .{ .legacy = val } };
+        }
+
+        const overflow = input.tryParse(OverflowPosition.parse, .{}).asValue();
+        if (input.tryParse(SelfPosition.parse, .{}).asValue()) |self_position| {
+            return .{ .result = .{ .self_position = .{ .overflow = overflow, .value = self_position } } };
+        }
+
+        const location = input.currentSourceLocation();
+        const ident = switch (input.expectIdent()) {
+            .result => |v| v,
+            .err => |e| return .{ .err = e },
+        };
+
+        const Enum = enum { left, right };
+        const Map = bun.ComptimeEnumMap(Enum);
+        if (Map.getASCIIICaseInsensitive(ident)) |val| return .{ .result = switch (val) {
+            .left => .{ .left = .{ .overflow = overflow } },
+            .right => .{ .right = .{ .overflow = overflow } },
+        } };
+        return .{ .err = location.newUnexpectedTokenError(.{ .ident = ident }) };
+    }
+
+    pub fn toCss(this: *const JustifyItems, comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+        switch (this.*) {
+            .normal => try dest.writeStr("normal"),
+            .stretch => try dest.writeStr("stretch"),
+            .baseline_position => |*val| try val.toCss(W, dest),
+            .self_position => |*sp| {
+                if (sp.overflow) |*overflow| {
+                    try overflow.toCss(W, dest);
+                    try dest.writeStr(" ");
+                }
+                try sp.value.toCss(W, dest);
+            },
+            .left => |*l| {
+                if (l.overflow) |*overflow| {
+                    try overflow.toCss(W, dest);
+                    try dest.writeStr(" ");
+                }
+                try dest.writeStr("left");
+            },
+            .right => |*r| {
+                if (r.overflow) |*overflow| {
+                    try overflow.toCss(W, dest);
+                    try dest.writeStr(" ");
+                }
+                try dest.writeStr("right");
+            },
+            .legacy => |l| try l.toCss(W, dest),
+        }
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A legacy justification keyword, as used in the `justify-items` property.
+pub const LegacyJustify = enum {
+    /// Left justify.
+    left,
+    /// Right justify.
+    right,
+    /// Centered.
+    center,
+
+    pub fn parse(input: *css.Parser) css.Result(@This()) {
+        const location = input.currentSourceLocation();
+        const ident = switch (input.expectIdent()) {
+            .err => |e| return .{ .err = e },
+            .result => |v| v,
+        };
+
+        const LegacyJustifyIdent = enum {
+            legacy,
+            left,
+            right,
+            center,
+        };
+
+        const LegacyJustifyMap = bun.ComptimeEnumMap(LegacyJustifyIdent);
+        if (LegacyJustifyMap.getASCIIICaseInsensitive(ident)) |value| {
+            switch (value) {
+                .legacy => {
+                    const inner_location = input.currentSourceLocation();
+                    const inner_ident = switch (input.expectIdent()) {
+                        .err => |e| return .{ .err = e },
+                        .result => |v| v,
+                    };
+                    const InnerEnum = enum { left, right, center };
+                    const InnerLegacyJustifyMap = bun.ComptimeEnumMap(InnerEnum);
+                    if (InnerLegacyJustifyMap.getASCIIICaseInsensitive(inner_ident)) |inner_value| {
+                        return switch (inner_value) {
+                            .left => .{ .result = .left },
+                            .right => .{ .result = .right },
+                            .center => .{ .result = .center },
+                        };
+                    } else {
+                        return .{ .err = inner_location.newUnexpectedTokenError(.{ .ident = inner_ident }) };
+                    }
+                },
+                .left => {
+                    if (input.expectIdentMatching("legacy").asErr()) |e| return .{ .err = e };
+                    return .{ .result = .left };
+                },
+                .right => {
+                    if (input.expectIdentMatching("legacy").asErr()) |e| return .{ .err = e };
+                    return .{ .result = .right };
+                },
+                .center => {
+                    if (input.expectIdentMatching("legacy").asErr()) |e| return .{ .err = e };
+                    return .{ .result = .center };
+                },
+            }
+        }
+        return .{ .err = location.newUnexpectedTokenError(.{ .ident = ident }) };
+    }
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+        try dest.writeStr("legacy ");
+        switch (this.*) {
+            .left => try dest.writeStr("left"),
+            .right => try dest.writeStr("right"),
+            .center => try dest.writeStr("center"),
+        }
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A [gap](https://www.w3.org/TR/css-align-3/#column-row-gap) value, as used in the
+/// `column-gap` and `row-gap` properties.
+pub const GapValue = union(enum) {
+    /// Equal to `1em` for multi-column containers, and zero otherwise.
+    normal,
+    /// An explicit length.
+    length_percentage: LengthPercentage,
+
+    pub usingnamespace css.DeriveParse(@This());
+    pub usingnamespace css.DeriveToCss(@This());
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A value for the [gap](https://www.w3.org/TR/css-align-3/#gap-shorthand) shorthand property.
+pub const Gap = struct {
+    /// The row gap.
+    row: GapValue,
+    /// The column gap.
+    column: GapValue,
+
+    pub usingnamespace css.DefineShorthand(@This(), css.PropertyIdTag.gap);
+
+    pub const PropertyFieldMap = .{
+        .row = "row-gap",
+        .column = "column-gap",
+    };
+
+    pub fn parse(input: *css.Parser) css.Result(@This()) {
+        const row = switch (@call(.auto, @field(GapValue, "parse"), .{input})) {
+            .result => |v| v,
+            .err => |e| return .{ .err = e },
+        };
+        const column = switch (input.tryParse(@field(GapValue, "parse"), .{})) {
+            .result => |v| v,
+            .err => row,
+        };
+        return .{ .result = .{ .row = row, .column = column } };
+    }
+
+    pub fn toCss(this: *const Gap, comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+        try this.row.toCss(W, dest);
+        if (!this.column.eql(&this.row)) {
+            try dest.writeStr(" ");
+            try this.column.toCss(W, dest);
+        }
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A value for the [place-items](https://www.w3.org/TR/css-align-3/#place-items-property) shorthand property.
+pub const PlaceItems = struct {
+    /// The item alignment.
+    @"align": AlignItems,
+    /// The item justification.
+    justify: JustifyItems,
+
+    pub usingnamespace css.DefineShorthand(@This(), css.PropertyIdTag.@"place-items");
+
+    pub const PropertyFieldMap = .{
+        .@"align" = "align-items",
+        .justify = "justify-items",
+    };
+
+    pub const VendorPrefixMap = .{
+        .@"align" = true,
+    };
+
+    pub fn parse(input: *css.Parser) css.Result(@This()) {
+        const @"align" = switch (@call(.auto, @field(AlignItems, "parse"), .{input})) {
+            .result => |v| v,
+            .err => |e| return .{ .err = e },
+        };
+        const justify = switch (input.tryParse(@field(JustifyItems, "parse"), .{})) {
+            .result => |v| v,
+            .err => switch (@"align") {
+                .normal => JustifyItems.normal,
+                .stretch => JustifyItems.stretch,
+                .baseline_position => |p| JustifyItems{ .baseline_position = p },
+                .self_position => |sp| JustifyItems{
+                    .self_position = .{
+                        .overflow = if (sp.overflow) |o| o else null,
+                        .value = sp.value,
+                    },
+                },
+            },
+        };
+
+        return .{ .result = .{ .@"align" = @"align", .justify = justify } };
+    }
+
+    pub fn toCss(this: *const PlaceItems, comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+        try this.@"align".toCss(W, dest);
+        const is_equal = switch (this.justify) {
+            .normal => this.@"align".eql(&AlignItems{ .normal = {} }),
+            .stretch => this.@"align".eql(&AlignItems{ .stretch = {} }),
+            .baseline_position => |*p| brk: {
+                if (this.@"align" == .baseline_position) break :brk p.eql(&this.@"align".baseline_position);
+                break :brk false;
+            },
+            .self_position => |*p| brk: {
+                if (this.@"align" == .self_position) break :brk p.toInner().eql(&this.@"align".self_position.toInner());
+                break :brk false;
+            },
+            else => false,
+        };
+
+        if (!is_equal) {
+            try dest.writeStr(" ");
+            try this.justify.toCss(W, dest);
+        }
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A value for the [place-self](https://www.w3.org/TR/css-align-3/#place-self-property) shorthand property.
+pub const PlaceSelf = struct {
+    /// The item alignment.
+    @"align": AlignSelf,
+    /// The item justification.
+    justify: JustifySelf,
+
+    pub usingnamespace css.DefineShorthand(@This(), css.PropertyIdTag.@"place-self");
+
+    pub const PropertyFieldMap = .{
+        .@"align" = "align-self",
+        .justify = "justify-self",
+    };
+
+    pub const VendorPrefixMap = .{
+        .@"align" = true,
+    };
+
+    pub fn parse(input: *css.Parser) css.Result(@This()) {
+        const @"align" = switch (@call(.auto, @field(AlignSelf, "parse"), .{input})) {
+            .result => |v| v,
+            .err => |e| return .{ .err = e },
+        };
+        const justify = switch (input.tryParse(@field(JustifySelf, "parse"), .{})) {
+            .result => |v| v,
+            .err => switch (@"align") {
+                .auto => JustifySelf.auto,
+                .normal => JustifySelf.normal,
+                .stretch => JustifySelf.stretch,
+                .baseline_position => |p| JustifySelf{ .baseline_position = p },
+                .self_position => |sp| JustifySelf{
+                    .self_position = .{
+                        .overflow = if (sp.overflow) |o| o else null,
+                        .value = sp.value,
+                    },
+                },
+            },
+        };
+
+        return .{ .result = .{ .@"align" = @"align", .justify = justify } };
+    }
+
+    pub fn toCss(this: *const PlaceSelf, comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+        try this.@"align".toCss(W, dest);
+        const is_equal = switch (this.justify) {
+            .auto => true,
+            .normal => this.@"align" == .normal,
+            .stretch => this.@"align" == .stretch,
+            .baseline_position => |p| switch (this.@"align") {
+                .baseline_position => |p2| p.eql(&p2),
+                else => false,
+            },
+            .self_position => |sp| brk: {
+                if (this.@"align" == .self_position) break :brk sp.toInner().eql(&this.@"align".self_position.toInner());
+                break :brk false;
+            },
+            else => false,
+        };
+
+        if (!is_equal) {
+            try dest.writeStr(" ");
+            try this.justify.toCss(W, dest);
+        }
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A [`<self-position>`](https://www.w3.org/TR/css-align-3/#typedef-self-position) value.
+pub const SelfPosition = enum {
+    /// Item is centered within the container.
+    center,
+    /// Item is aligned to the start of the container.
+    start,
+    /// Item is aligned to the end of the container.
+    end,
+    /// Item is aligned to the edge of the container corresponding to the start side of the item.
+    @"self-start",
+    /// Item is aligned to the edge of the container corresponding to the end side of the item.
+    @"self-end",
+    /// Item  is aligned to the start of the container, within flexbox layouts.
+    @"flex-start",
+    /// Item  is aligned to the end of the container, within flexbox layouts.
+    @"flex-end",
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+};
+
+/// A value for the [place-content](https://www.w3.org/TR/css-align-3/#place-content) shorthand property.
+pub const PlaceContent = struct {
+    /// The content alignment.
+    @"align": AlignContent,
+    /// The content justification.
+    justify: JustifyContent,
+
+    pub usingnamespace css.DefineShorthand(@This(), css.PropertyIdTag.@"place-content");
+
+    pub const PropertyFieldMap = .{
+        .@"align" = css.PropertyIdTag.@"align-content",
+        .justify = css.PropertyIdTag.@"justify-content",
+    };
+
+    pub const VendorPrefixMap = .{
+        .@"align" = true,
+        .justify = true,
+    };
+
+    pub fn parse(input: *css.Parser) css.Result(@This()) {
+        const @"align" = switch (@call(.auto, @field(AlignContent, "parse"), .{input})) {
+            .result => |v| v,
+            .err => |e| return .{ .err = e },
+        };
+        const justify = switch (@call(.auto, @field(JustifyContent, "parse"), .{input})) {
+            .result => |v| v,
+            .err => |_| switch (@"align") {
+                .baseline_position => JustifyContent{ .content_position = .{
+                    .overflow = null,
+                    .value = .start,
+                } },
+                .normal => JustifyContent.normal,
+                .content_distribution => |value| JustifyContent{ .content_distribution = value },
+                .content_position => |pos| JustifyContent{ .content_position = .{
+                    .overflow = if (pos.overflow) |*overflow| overflow.deepClone(input.allocator()) else null,
+                    .value = pos.value.deepClone(input.allocator()),
+                } },
+            },
+        };
+
+        return .{ .result = .{ .@"align" = @"align", .justify = justify } };
+    }
+
+    pub fn toCss(this: *const PlaceContent, comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+        try this.@"align".toCss(W, dest);
+        const is_equal = switch (this.justify) {
+            .normal => brk: {
+                if (this.@"align" == .normal) break :brk true;
+                break :brk false;
+            },
+            .content_distribution => |*d| brk: {
+                if (this.@"align" == .content_distribution) break :brk d.eql(&this.@"align".content_distribution);
+                break :brk false;
+            },
+            .content_position => |*p| brk: {
+                if (this.@"align" == .content_position) break :brk p.toInner().eql(&this.@"align".content_position.toInner());
+                break :brk false;
+            },
+            else => false,
+        };
+
+        if (!is_equal) {
+            try dest.writeStr(" ");
+            try this.justify.toCss(W, dest);
+        }
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A [`<content-distribution>`](https://www.w3.org/TR/css-align-3/#typedef-content-distribution) value.
+pub const ContentDistribution = enum {
+    /// Items are spaced evenly, with the first and last items against the edge of the container.
+    @"space-between",
+    /// Items are spaced evenly, with half-size spaces at the start and end.
+    @"space-around",
+    /// Items are spaced evenly, with full-size spaces at the start and end.
+    @"space-evenly",
+    /// Items are stretched evenly to fill free space.
+    stretch,
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+};
+
+/// An [`<overflow-position>`](https://www.w3.org/TR/css-align-3/#typedef-overflow-position) value.
+pub const OverflowPosition = enum {
+    /// If the size of the alignment subject overflows the alignment container,
+    /// the alignment subject is instead aligned as if the alignment mode were start.
+    safe,
+    /// Regardless of the relative sizes of the alignment subject and alignment
+    /// container, the given alignment value is honored.
+    unsafe,
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+};
+
+/// A [`<content-position>`](https://www.w3.org/TR/css-align-3/#typedef-content-position) value.
+pub const ContentPosition = enum {
+    /// Content is centered within the container.
+    center,
+    /// Content is aligned to the start of the container.
+    start,
+    /// Content is aligned to the end of the container.
+    end,
+    /// Same as `start` when within a flexbox container.
+    @"flex-start",
+    /// Same as `end` when within a flexbox container.
+    @"flex-end",
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+};
+
+pub const SelfPositionInner = struct {
+    /// An overflow alignment mode.
+    overflow: ?OverflowPosition,
+    /// A self position keyword.
+    value: SelfPosition,
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+pub const ContentPositionInner = struct {
+    /// An overflow alignment mode.
+    overflow: ?OverflowPosition,
+    /// A content position keyword.
+    value: ContentPosition,
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
diff --git a/src/css/properties/animation.zig b/src/css/properties/animation.zig
new file mode 100644
index 0000000000..b6136db261
--- /dev/null
+++ b/src/css/properties/animation.zig
@@ -0,0 +1,161 @@
+const std = @import("std");
+const bun = @import("root").bun;
+const Allocator = std.mem.Allocator;
+const ArrayList = std.ArrayListUnmanaged;
+
+pub const css = @import("../css_parser.zig");
+
+const SmallList = css.SmallList;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+
+const LengthPercentage = css.css_values.length.LengthPercentage;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CSSString = css.css_values.string.CSSString;
+const CSSNumber = css.css_values.number.CSSNumber;
+const LengthPercentageOrAuto = css.css_values.length.LengthPercentageOrAuto;
+const Size2D = css.css_values.size.Size2D;
+const DashedIdent = css.css_values.ident.DashedIdent;
+
+/// A list of animations.
+pub const AnimationList = SmallList(Animation, 1);
+
+/// A list of animation names.
+pub const AnimationNameList = SmallList(AnimationName, 1);
+
+/// A value for the [animation](https://drafts.csswg.org/css-animations/#animation) shorthand property.
+pub const Animation = @compileError(css.todo_stuff.depth);
+
+/// A value for the [animation-name](https://drafts.csswg.org/css-animations/#animation-name) property.
+pub const AnimationName = union(enum) {
+    /// The `none` keyword.
+    none,
+    /// An identifier of a `@keyframes` rule.
+    ident: CustomIdent,
+    /// A `<string>` name of a `@keyframes` rule.
+    string: CSSString,
+
+    // ~toCssImpl
+    const This = @This();
+
+    pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+        return css.implementHash(@This(), this, hasher);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        _ = this; // autofix
+        _ = dest; // autofix
+        @panic(css.todo_stuff.depth);
+    }
+};
+
+/// A value for the [animation-iteration-count](https://drafts.csswg.org/css-animations/#animation-iteration-count) property.
+pub const AnimationIterationCount = union(enum) {
+    /// The animation will repeat the specified number of times.
+    number: CSSNumber,
+    /// The animation will repeat forever.
+    infinite,
+};
+
+/// A value for the [animation-direction](https://drafts.csswg.org/css-animations/#animation-direction) property.
+pub const AnimationDirection = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A value for the [animation-play-state](https://drafts.csswg.org/css-animations/#animation-play-state) property.
+pub const AnimationPlayState = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A value for the [animation-fill-mode](https://drafts.csswg.org/css-animations/#animation-fill-mode) property.
+pub const AnimationFillMode = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A value for the [animation-composition](https://drafts.csswg.org/css-animations-2/#animation-composition) property.
+pub const AnimationComposition = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A value for the [animation-timeline](https://drafts.csswg.org/css-animations-2/#animation-timeline) property.
+pub const AnimationTimeline = union(enum) {
+    /// The animation's timeline is a DocumentTimeline, more specifically the default document timeline.
+    auto,
+    /// The animation is not associated with a timeline.
+    none,
+    /// A timeline referenced by name.
+    dashed_ident: DashedIdent,
+    /// The scroll() function.
+    scroll: ScrollTimeline,
+    /// The view() function.
+    view: ViewTimeline,
+};
+
+/// The [scroll()](https://drafts.csswg.org/scroll-animations-1/#scroll-notation) function.
+pub const ScrollTimeline = struct {
+    /// Specifies which element to use as the scroll container.
+    scroller: Scroller,
+    /// Specifies which axis of the scroll container to use as the progress for the timeline.
+    axis: ScrollAxis,
+};
+
+/// The [view()](https://drafts.csswg.org/scroll-animations-1/#view-notation) function.
+pub const ViewTimeline = struct {
+    /// Specifies which axis of the scroll container to use as the progress for the timeline.
+    axis: ScrollAxis,
+    /// Provides an adjustment of the view progress visibility range.
+    inset: Size2D(LengthPercentageOrAuto),
+};
+
+/// A scroller, used in the `scroll()` function.
+pub const Scroller = @compileError(css.todo_stuff.depth);
+
+/// A scroll axis, used in the `scroll()` function.
+pub const ScrollAxis = @compileError(css.todo_stuff.depth);
+
+/// A value for the animation-range shorthand property.
+pub const AnimationRange = struct {
+    /// The start of the animation's attachment range.
+    start: AnimationRangeStart,
+    /// The end of the animation's attachment range.
+    end: AnimationRangeEnd,
+};
+
+/// A value for the [animation-range-start](https://drafts.csswg.org/scroll-animations/#animation-range-start) property.
+pub const AnimationRangeStart = struct {
+    v: AnimationAttachmentRange,
+};
+
+/// A value for the [animation-range-end](https://drafts.csswg.org/scroll-animations/#animation-range-start) property.
+pub const AnimationRangeEnd = struct {
+    v: AnimationAttachmentRange,
+};
+
+/// A value for the [animation-range-start](https://drafts.csswg.org/scroll-animations/#animation-range-start)
+/// or [animation-range-end](https://drafts.csswg.org/scroll-animations/#animation-range-end) property.
+pub const AnimationAttachmentRange = union(enum) {
+    /// The start of the animation's attachment range is the start of its associated timeline.
+    normal,
+    /// The animation attachment range starts at the specified point on the timeline measuring from the start of the timeline.
+    length_percentage: LengthPercentage,
+    /// The animation attachment range starts at the specified point on the timeline measuring from the start of the specified named timeline range.
+    timeline_range: struct {
+        /// The name of the timeline range.
+        name: TimelineRangeName,
+        /// The offset from the start of the named timeline range.
+        offset: LengthPercentage,
+    },
+};
+
+/// A [view progress timeline range](https://drafts.csswg.org/scroll-animations/#view-timelines-ranges)
+pub const TimelineRangeName = enum {
+    /// Represents the full range of the view progress timeline.
+    cover,
+    /// Represents the range during which the principal box is either fully contained by,
+    /// or fully covers, its view progress visibility range within the scrollport.
+    contain,
+    /// Represents the range during which the principal box is entering the view progress visibility range.
+    entry,
+    /// Represents the range during which the principal box is exiting the view progress visibility range.
+    exit,
+    /// Represents the range during which the principal box crosses the end border edge.
+    entry_crossing,
+    /// Represents the range during which the principal box crosses the start border edge.
+    exit_crossing,
+};
diff --git a/src/css/properties/background.zig b/src/css/properties/background.zig
new file mode 100644
index 0000000000..438b43ade6
--- /dev/null
+++ b/src/css/properties/background.zig
@@ -0,0 +1,1054 @@
+const std = @import("std");
+const bun = @import("root").bun;
+const Allocator = std.mem.Allocator;
+const ArrayList = std.ArrayListUnmanaged;
+
+pub const css = @import("../css_parser.zig");
+
+const Property = css.Property;
+const VendorPrefix = css.VendorPrefix;
+const SmallList = css.SmallList;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+
+const LengthPercentage = css.css_values.length.LengthPercentage;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CSSString = css.css_values.string.CSSString;
+const CSSNumber = css.css_values.number.CSSNumber;
+const LengthPercentageOrAuto = css.css_values.length.LengthPercentageOrAuto;
+const Size2D = css.css_values.size.Size2D;
+const DashedIdent = css.css_values.ident.DashedIdent;
+const Image = css.css_values.image.Image;
+const CssColor = css.css_values.color.CssColor;
+const Ratio = css.css_values.ratio.Ratio;
+const HorizontalPosition = css.css_values.position.HorizontalPosition;
+const VerticalPosition = css.css_values.position.VerticalPosition;
+
+const Position = css.css_values.position.Position;
+
+/// A value for the [background](https://www.w3.org/TR/css-backgrounds-3/#background) shorthand property.
+pub const Background = struct {
+    /// The background image.
+    image: Image,
+    /// The background color.
+    color: CssColor,
+    /// The background position.
+    position: BackgroundPosition,
+    /// How the background image should repeat.
+    repeat: BackgroundRepeat,
+    /// The size of the background image.
+    size: BackgroundSize,
+    /// The background attachment.
+    attachment: BackgroundAttachment,
+    /// The background origin.
+    origin: BackgroundOrigin,
+    /// How the background should be clipped.
+    clip: BackgroundClip,
+
+    pub fn deinit(_: *@This(), _: Allocator) void {
+        // TODO: implement this
+        // not necessary right now because all allocations in CSS parser are in arena
+    }
+
+    pub fn parse(input: *css.Parser) css.Result(@This()) {
+        var color: ?CssColor = null;
+        var position: ?BackgroundPosition = null;
+        var size: ?BackgroundSize = null;
+        var image: ?Image = null;
+        var repeat: ?BackgroundRepeat = null;
+        var attachment: ?BackgroundAttachment = null;
+        var origin: ?BackgroundOrigin = null;
+        var clip: ?BackgroundClip = null;
+
+        while (true) {
+            // TODO: only allowed on the last background.
+            if (color == null) {
+                if (input.tryParse(CssColor.parse, .{}).asValue()) |value| {
+                    color = value;
+                    continue;
+                }
+            }
+
+            if (position == null) {
+                if (input.tryParse(BackgroundPosition.parse, .{}).asValue()) |value| {
+                    position = value;
+
+                    size = input.tryParse(struct {
+                        fn parse(i: *css.Parser) css.Result(BackgroundSize) {
+                            if (i.expectDelim('/').asErr()) |e| return .{ .err = e };
+                            return BackgroundSize.parse(i);
+                        }
+                    }.parse, .{}).asValue();
+
+                    continue;
+                }
+            }
+
+            if (image == null) {
+                if (input.tryParse(Image.parse, .{}).asValue()) |value| {
+                    image = value;
+                    continue;
+                }
+            }
+
+            if (repeat == null) {
+                if (input.tryParse(BackgroundRepeat.parse, .{}).asValue()) |value| {
+                    repeat = value;
+                    continue;
+                }
+            }
+
+            if (attachment == null) {
+                if (input.tryParse(BackgroundAttachment.parse, .{}).asValue()) |value| {
+                    attachment = value;
+                    continue;
+                }
+            }
+
+            if (origin == null) {
+                if (input.tryParse(BackgroundOrigin.parse, .{}).asValue()) |value| {
+                    origin = value;
+                    continue;
+                }
+            }
+
+            if (clip == null) {
+                if (input.tryParse(BackgroundClip.parse, .{}).asValue()) |value| {
+                    clip = value;
+                    continue;
+                }
+            }
+
+            break;
+        }
+
+        if (clip == null) {
+            if (origin) |o| {
+                clip = @as(BackgroundClip, @enumFromInt(@intFromEnum(o)));
+            }
+        }
+
+        return .{ .result = .{
+            .image = image orelse Image.default(),
+            .color = color orelse CssColor.default(),
+            .position = position orelse BackgroundPosition.default(),
+            .repeat = repeat orelse BackgroundRepeat.default(),
+            .size = size orelse BackgroundSize.default(),
+            .attachment = attachment orelse BackgroundAttachment.default(),
+            .origin = origin orelse .@"padding-box",
+            .clip = clip orelse .@"border-box",
+        } };
+    }
+
+    pub fn toCss(this: *const Background, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        var has_output = false;
+
+        if (!this.color.eql(&CssColor.default())) {
+            try this.color.toCss(W, dest);
+            has_output = true;
+        }
+
+        if (!this.image.eql(&Image.default())) {
+            if (has_output) try dest.writeStr(" ");
+            try this.image.toCss(W, dest);
+            has_output = true;
+        }
+
+        const position: Position = this.position.intoPosition();
+        if (!position.isZero() or !this.size.eql(&BackgroundSize.default())) {
+            if (has_output) {
+                try dest.writeStr(" ");
+            }
+            try position.toCss(W, dest);
+
+            if (!this.size.eql(&BackgroundSize.default())) {
+                try dest.delim('/', true);
+                try this.size.toCss(W, dest);
+            }
+
+            has_output = true;
+        }
+
+        if (!this.repeat.eql(&BackgroundRepeat.default())) {
+            if (has_output) try dest.writeStr(" ");
+            try this.repeat.toCss(W, dest);
+            has_output = true;
+        }
+
+        if (!this.attachment.eql(&BackgroundAttachment.default())) {
+            if (has_output) try dest.writeStr(" ");
+            try this.attachment.toCss(W, dest);
+            has_output = true;
+        }
+
+        const output_padding_box = !this.origin.eql(&BackgroundOrigin.@"padding-box") or
+            (!this.clip.eqlOrigin(&BackgroundOrigin.@"border-box") and this.clip.isBackgroundBox());
+
+        if (output_padding_box) {
+            if (has_output) try dest.writeStr(" ");
+            try this.origin.toCss(W, dest);
+            has_output = true;
+        }
+
+        if ((output_padding_box and !this.clip.eqlOrigin(&BackgroundOrigin.@"border-box")) or
+            !this.clip.eqlOrigin(&BackgroundOrigin.@"border-box"))
+        {
+            if (has_output) try dest.writeStr(" ");
+
+            try this.clip.toCss(W, dest);
+            has_output = true;
+        }
+
+        // If nothing was output, then this is the initial value, e.g. background: transparent
+        if (!has_output) {
+            if (dest.minify) {
+                // `0 0` is the shortest valid background value
+                try this.position.toCss(W, dest);
+            } else {
+                try dest.writeStr("none");
+            }
+        }
+    }
+
+    pub fn getImage(this: *const @This()) *const Image {
+        return &this.image;
+    }
+
+    pub fn withImage(this: *const @This(), allocator: Allocator, image: Image) @This() {
+        var ret = this.*;
+        ret.image = .none;
+        ret = ret.deepClone(allocator);
+        ret.image = image;
+        return ret;
+    }
+
+    pub fn getFallback(this: *const @This(), allocator: Allocator, kind: css.ColorFallbackKind) Background {
+        var ret: Background = this.*;
+        // Dummy values for the clone
+        ret.color = CssColor.default();
+        ret.image = Image.default();
+        ret = ret.deepClone(allocator);
+        ret.color = this.color.getFallback(allocator, kind);
+        ret.image = this.image.getFallback(allocator, kind);
+        return ret;
+    }
+
+    pub fn getNecessaryFallbacks(this: *const @This(), targets: css.targets.Targets) css.ColorFallbackKind {
+        return this.color.getNecessaryFallbacks(targets).bitwiseOr(this.getImage().getNecessaryFallbacks(targets));
+    }
+
+    pub inline fn deepClone(this: *const @This(), allocator: Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+/// A value for the [background-size](https://www.w3.org/TR/css-backgrounds-3/#background-size) property.
+pub const BackgroundSize = union(enum) {
+    /// An explicit background size.
+    explicit: struct {
+        /// The width of the background.
+        width: css.css_values.length.LengthPercentageOrAuto,
+        /// The height of the background.
+        height: css.css_values.length.LengthPercentageOrAuto,
+
+        pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+            return css.implementEql(@This(), lhs, rhs);
+        }
+
+        pub inline fn deepClone(this: *const @This(), allocator: Allocator) @This() {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    },
+    /// The `cover` keyword. Scales the background image to cover both the width and height of the element.
+    cover,
+    /// The `contain` keyword. Scales the background image so that it fits within the element.
+    contain,
+
+    pub fn parse(input: *css.Parser) css.Result(@This()) {
+        if (input.tryParse(LengthPercentageOrAuto.parse, .{}).asValue()) |width| {
+            const height = input.tryParse(LengthPercentageOrAuto.parse, .{}).unwrapOr(.auto);
+            return .{ .result = .{ .explicit = .{ .width = width, .height = height } } };
+        }
+
+        const location = input.currentSourceLocation();
+        const ident = switch (input.expectIdent()) {
+            .result => |v| v,
+            .err => |e| return .{ .err = e },
+        };
+
+        if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(ident, "cover")) {
+            return .{ .result = .cover };
+        } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(ident, "contain")) {
+            return .{ .result = .contain };
+        } else {
+            return .{ .err = location.newBasicUnexpectedTokenError(.{ .ident = ident }) };
+        }
+    }
+
+    pub fn toCss(this: *const BackgroundSize, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        return switch (this.*) {
+            .cover => dest.writeStr("cover"),
+            .contain => dest.writeStr("contain"),
+            .explicit => |explicit| {
+                try explicit.width.toCss(W, dest);
+                if (explicit.height != .auto) {
+                    try dest.writeStr(" ");
+                    try explicit.height.toCss(W, dest);
+                }
+                return;
+            },
+        };
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn default() @This() {
+        return BackgroundSize{ .explicit = .{
+            .width = .auto,
+            .height = .auto,
+        } };
+    }
+
+    pub inline fn deepClone(this: *const @This(), allocator: Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A value for the [background-position](https://drafts.csswg.org/css-backgrounds/#background-position) shorthand property.
+pub const BackgroundPosition = struct {
+    /// The x-position.
+    x: HorizontalPosition,
+    /// The y-position.
+    y: VerticalPosition,
+
+    pub usingnamespace css.DefineListShorthand(@This());
+
+    const PropertyFieldMap = .{
+        .x = css.PropertyIdTag.@"background-position-x",
+        .y = css.PropertyIdTag.@"background-position-y",
+    };
+
+    pub fn parse(input: *css.Parser) css.Result(@This()) {
+        const pos = switch (css.css_values.position.Position.parse(input)) {
+            .result => |v| v,
+            .err => |e| return .{ .err = e },
+        };
+        return .{ .result = BackgroundPosition.fromPosition(pos) };
+    }
+
+    pub fn toCss(this: *const BackgroundPosition, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        const pos = this.intoPosition();
+        return pos.toCss(W, dest);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn default() @This() {
+        return BackgroundPosition.fromPosition(Position.default());
+    }
+
+    pub fn fromPosition(pos: Position) BackgroundPosition {
+        return BackgroundPosition{ .x = pos.x, .y = pos.y };
+    }
+
+    pub fn intoPosition(this: *const BackgroundPosition) Position {
+        return Position{ .x = this.x, .y = this.y };
+    }
+
+    pub inline fn deepClone(this: *const @This(), allocator: Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A value for the [background-repeat](https://www.w3.org/TR/css-backgrounds-3/#background-repeat) property.
+pub const BackgroundRepeat = struct {
+    /// A repeat style for the x direction.
+    x: BackgroundRepeatKeyword,
+    /// A repeat style for the y direction.
+    y: BackgroundRepeatKeyword,
+
+    pub fn default() @This() {
+        return BackgroundRepeat{
+            .x = .repeat,
+            .y = .repeat,
+        };
+    }
+
+    pub fn parse(input: *css.Parser) css.Result(@This()) {
+        const state = input.state();
+        const ident = switch (input.expectIdent()) {
+            .result => |v| v,
+            .err => |e| return .{ .err = e },
+        };
+
+        if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(ident, "repeat-x")) {
+            return .{ .result = .{ .x = .repeat, .y = .@"no-repeat" } };
+        } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(ident, "repeat-y")) {
+            return .{ .result = .{ .x = .@"no-repeat", .y = .repeat } };
+        }
+
+        input.reset(&state);
+
+        const x = switch (BackgroundRepeatKeyword.parse(input)) {
+            .result => |v| v,
+            .err => |e| return .{ .err = e },
+        };
+
+        const y = input.tryParse(BackgroundRepeatKeyword.parse, .{}).unwrapOrNoOptmizations(x);
+
+        return .{ .result = .{ .x = x, .y = y } };
+    }
+
+    pub fn toCss(this: *const BackgroundRepeat, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        const Repeat = BackgroundRepeatKeyword.repeat;
+        const NoRepeat = BackgroundRepeatKeyword.@"no-repeat";
+
+        if (this.x == Repeat and this.y == NoRepeat) {
+            return dest.writeStr("repeat-x");
+        } else if (this.x == NoRepeat and this.y == Repeat) {
+            return dest.writeStr("repeat-y");
+        } else {
+            try this.x.toCss(W, dest);
+            if (this.y != this.x) {
+                try dest.writeStr(" ");
+                try this.y.toCss(W, dest);
+            }
+        }
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A [`<repeat-style>`](https://www.w3.org/TR/css-backgrounds-3/#typedef-repeat-style) value,
+/// used within the `background-repeat` property to represent how a background image is repeated
+/// in a single direction.
+///
+/// See [BackgroundRepeat](BackgroundRepeat).
+pub const BackgroundRepeatKeyword = enum {
+    /// The image is repeated in this direction.
+    repeat,
+    /// The image is repeated so that it fits, and then spaced apart evenly.
+    space,
+    /// The image is scaled so that it repeats an even number of times.
+    round,
+    /// The image is placed once and not repeated in this direction.
+    @"no-repeat",
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+};
+
+/// A value for the [background-attachment](https://www.w3.org/TR/css-backgrounds-3/#background-attachment) property.
+pub const BackgroundAttachment = enum {
+    /// The background scrolls with the container.
+    scroll,
+    /// The background is fixed to the viewport.
+    fixed,
+    /// The background is fixed with regard to the element's contents.
+    local,
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+
+    pub fn default() @This() {
+        return .scroll;
+    }
+};
+
+/// A value for the [background-origin](https://www.w3.org/TR/css-backgrounds-3/#background-origin) property.
+pub const BackgroundOrigin = enum {
+    /// The position is relative to the border box.
+    @"border-box",
+    /// The position is relative to the padding box.
+    @"padding-box",
+    /// The position is relative to the content box.
+    @"content-box",
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+};
+
+/// A value for the [background-clip](https://drafts.csswg.org/css-backgrounds-4/#background-clip) property.
+pub const BackgroundClip = enum {
+    /// The background is clipped to the border box.
+    @"border-box",
+    /// The background is clipped to the padding box.
+    @"padding-box",
+    /// The background is clipped to the content box.
+    @"content-box",
+    /// The background is clipped to the area painted by the border.
+    border,
+    /// The background is clipped to the text content of the element.
+    text,
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+
+    pub fn default() BackgroundClip {
+        return .@"border-box";
+    }
+
+    pub fn eqlOrigin(this: *const @This(), other: *const BackgroundOrigin) bool {
+        return switch (this.*) {
+            .@"border-box" => other.* == .@"border-box",
+            .@"padding-box" => other.* == .@"padding-box",
+            .@"content-box" => other.* == .@"content-box",
+            else => false,
+        };
+    }
+
+    pub fn isBackgroundBox(this: *const @This()) bool {
+        return switch (this.*) {
+            .@"border-box", .@"padding-box", .@"content-box" => true,
+            else => false,
+        };
+    }
+};
+
+/// A value for the [aspect-ratio](https://drafts.csswg.org/css-sizing-4/#aspect-ratio) property.
+pub const AspectRatio = struct {
+    /// The `auto` keyword.
+    auto: bool,
+    /// A preferred aspect ratio for the box, specified as width / height.
+    ratio: ?Ratio,
+};
+
+pub const BackgroundProperty = packed struct(u16) {
+    @"background-color": bool = false,
+    @"background-image": bool = false,
+    @"background-position-x": bool = false,
+    @"background-position-y": bool = false,
+    @"background-repeat": bool = false,
+    @"background-size": bool = false,
+    @"background-attachment": bool = false,
+    @"background-origin": bool = false,
+    @"background-clip": bool = false,
+    __unused: u7 = 0,
+
+    pub usingnamespace css.Bitflags(@This());
+
+    pub const @"background-color" = BackgroundProperty{ .@"background-color" = true };
+    pub const @"background-image" = BackgroundProperty{ .@"background-image" = true };
+    pub const @"background-position-x" = BackgroundProperty{ .@"background-position-x" = true };
+    pub const @"background-position-y" = BackgroundProperty{ .@"background-position-y" = true };
+    pub const @"background-position" = BackgroundProperty{ .@"background-position-x" = true, .@"background-position-y" = true };
+    pub const @"background-repeat" = BackgroundProperty{ .@"background-repeat" = true };
+    pub const @"background-size" = BackgroundProperty{ .@"background-size" = true };
+    pub const @"background-attachment" = BackgroundProperty{ .@"background-attachment" = true };
+    pub const @"background-origin" = BackgroundProperty{ .@"background-origin" = true };
+    pub const @"background-clip" = BackgroundProperty{ .@"background-clip" = true };
+    pub const background = BackgroundProperty{
+        .@"background-color" = true,
+        .@"background-image" = true,
+        .@"background-position-x" = true,
+        .@"background-position-y" = true,
+        .@"background-repeat" = true,
+        .@"background-size" = true,
+        .@"background-attachment" = true,
+        .@"background-origin" = true,
+        .@"background-clip" = true,
+    };
+
+    pub fn fromPropertyId(property_id: css.PropertyId) ?BackgroundProperty {
+        return switch (property_id) {
+            .@"background-color" => BackgroundProperty{ .@"background-color" = true },
+            .@"background-image" => BackgroundProperty{ .@"background-image" = true },
+            .@"background-position-x" => BackgroundProperty{ .@"background-position-x" = true },
+            .@"background-position-y" => BackgroundProperty{ .@"background-position-y" = true },
+            .@"background-position" => BackgroundProperty{ .@"background-position-x" = true, .@"background-position-y" = true },
+            .@"background-repeat" => BackgroundProperty{ .@"background-repeat" = true },
+            .@"background-size" => BackgroundProperty{ .@"background-size" = true },
+            .@"background-attachment" => BackgroundProperty{ .@"background-attachment" = true },
+            .@"background-origin" => BackgroundProperty{ .@"background-origin" = true },
+            .background => BackgroundProperty{
+                .@"background-color" = true,
+                .@"background-image" = true,
+                .@"background-position-x" = true,
+                .@"background-position-y" = true,
+                .@"background-repeat" = true,
+                .@"background-size" = true,
+                .@"background-attachment" = true,
+                .@"background-origin" = true,
+                .@"background-clip" = true,
+            },
+            else => null,
+        };
+    }
+};
+
+pub const BackgroundHandler = struct {
+    color: ?CssColor = null,
+    images: ?css.SmallList(Image, 1) = null,
+    has_prefix: bool = false,
+    x_positions: ?css.SmallList(HorizontalPosition, 1) = null,
+    y_positions: ?css.SmallList(VerticalPosition, 1) = null,
+    repeats: ?css.SmallList(BackgroundRepeat, 1) = null,
+    sizes: ?css.SmallList(BackgroundSize, 1) = null,
+    attachments: ?css.SmallList(BackgroundAttachment, 1) = null,
+    origins: ?css.SmallList(BackgroundOrigin, 1) = null,
+    clips: ?struct { css.SmallList(BackgroundClip, 1), VendorPrefix } = null,
+    decls: ArrayList(Property) = undefined,
+    flushed_properties: BackgroundProperty = undefined,
+    has_any: bool = false,
+
+    pub fn handleProperty(
+        this: *BackgroundHandler,
+        property: *const Property,
+        dest: *css.DeclarationList,
+        context: *css.PropertyHandlerContext,
+    ) bool {
+        const allocator = context.allocator;
+        switch (property.*) {
+            .@"background-color" => |*val| {
+                this.flushHelper(allocator, "color", CssColor, val, dest, context);
+                this.color = val.deepClone(allocator);
+            },
+            .@"background-image" => |*val| {
+                this.backgroundHelper(allocator, SmallList(Image, 1), val, property, dest, context);
+                this.images = val.deepClone(allocator);
+            },
+            .@"background-position" => |val| {
+                const x_positions = this.initSmallListHelper(HorizontalPosition, 1, "x_positions", allocator, val.len());
+                const y_positions = this.initSmallListHelper(VerticalPosition, 1, "y_positions", allocator, val.len());
+                for (val.slice(), x_positions, y_positions) |position, *x, *y| {
+                    x.* = position.x.deepClone(allocator);
+                    y.* = position.y.deepClone(allocator);
+                }
+            },
+            .@"background-position-x" => |val| {
+                if (this.x_positions) |*x_positions| x_positions.deinit(allocator);
+                this.x_positions = val.deepClone(allocator);
+            },
+            .@"background-position-y" => |val| {
+                if (this.y_positions) |*y_positions| y_positions.deinit(allocator);
+                this.y_positions = val.deepClone(allocator);
+            },
+            .@"background-repeat" => |val| {
+                if (this.repeats) |*repeats| repeats.deinit(allocator);
+                this.repeats = val.deepClone(allocator);
+            },
+            .@"background-size" => |val| {
+                if (this.sizes) |*sizes| sizes.deinit(allocator);
+                this.sizes = val.deepClone(allocator);
+            },
+            .@"background-attachment" => |val| {
+                if (this.attachments) |*attachments| attachments.deinit(allocator);
+                this.attachments = val.deepClone(allocator);
+            },
+            .@"background-origin" => |val| {
+                if (this.origins) |*origins| origins.deinit(allocator);
+                this.origins = val.deepClone(allocator);
+            },
+            .@"background-clip" => |*x| {
+                const val: *const SmallList(BackgroundClip, 1) = &x.*[0];
+                const vendor_prefix: VendorPrefix = x.*[1];
+                if (this.clips) |*clips_and_vp| {
+                    var clips: *SmallList(BackgroundClip, 1) = &clips_and_vp.*[0];
+                    const vp: *VendorPrefix = &clips_and_vp.*[1];
+                    if (!vendor_prefix.eql(vp.*) and !val.eql(clips)) {
+                        this.flush(allocator, dest, context);
+                        clips.deinit(allocator);
+                        this.clips = .{ val.deepClone(allocator), vendor_prefix };
+                    } else {
+                        if (!val.eql(clips)) {
+                            clips.deinit(allocator);
+                            clips.* = val.deepClone(allocator);
+                        }
+                        vp.insert(vendor_prefix);
+                    }
+                } else {
+                    this.clips = .{ val.deepClone(allocator), vendor_prefix };
+                }
+            },
+            .background => |*val| {
+                var images = SmallList(Image, 1).initCapacity(allocator, val.len());
+                for (val.slice()) |*b| {
+                    images.appendAssumeCapacity(b.image.deepClone(allocator));
+                }
+                this.backgroundHelper(allocator, SmallList(Image, 1), &images, property, dest, context);
+                const color = val.last().?.color.deepClone(allocator);
+                this.flushHelper(allocator, "color", CssColor, &color, dest, context);
+                var clips = SmallList(BackgroundClip, 1).initCapacity(allocator, val.len());
+                for (val.slice()) |*b| {
+                    clips.appendAssumeCapacity(b.clip.deepClone(allocator));
+                }
+                var clips_vp = VendorPrefix{ .none = true };
+                if (this.clips) |*clips_and_vp| {
+                    if (!clips_vp.eql(clips_and_vp.*[1]) and !clips_and_vp.*[0].eql(&clips_and_vp[0])) {
+                        this.flush(allocator, dest, context);
+                    } else {
+                        clips_vp.insert(clips_and_vp.*[1]);
+                    }
+                }
+
+                if (this.color) |*c| c.deinit(allocator);
+                this.color = color;
+                if (this.images) |*i| i.deinit(allocator);
+                this.images = images;
+                const x_positions = this.initSmallListHelper(HorizontalPosition, 1, "x_positions", allocator, val.len());
+                const y_positions = this.initSmallListHelper(VerticalPosition, 1, "y_positions", allocator, val.len());
+                const repeats = this.initSmallListHelper(BackgroundRepeat, 1, "repeats", allocator, val.len());
+                const sizes = this.initSmallListHelper(BackgroundSize, 1, "sizes", allocator, val.len());
+                const attachments = this.initSmallListHelper(BackgroundAttachment, 1, "attachments", allocator, val.len());
+                const origins = this.initSmallListHelper(BackgroundOrigin, 1, "origins", allocator, val.len());
+
+                for (
+                    val.slice(),
+                    x_positions,
+                    y_positions,
+                    repeats,
+                    sizes,
+                    attachments,
+                    origins,
+                ) |*b, *x, *y, *r, *s, *a, *o| {
+                    x.* = b.position.x.deepClone(allocator);
+                    y.* = b.position.y.deepClone(allocator);
+                    r.* = b.repeat.deepClone(allocator);
+                    s.* = b.size.deepClone(allocator);
+                    a.* = b.attachment.deepClone(allocator);
+                    o.* = b.origin.deepClone(allocator);
+                }
+
+                this.clips = .{ clips, clips_vp };
+            },
+            .unparsed => |*val| {
+                if (isBackgroundProperty(val.property_id)) {
+                    this.flush(allocator, dest, context);
+                    var unparsed = val.deepClone(allocator);
+                    context.addUnparsedFallbacks(&unparsed);
+                    if (BackgroundProperty.fromPropertyId(val.property_id)) |prop| {
+                        this.flushed_properties.insert(prop);
+                    }
+
+                    dest.append(allocator, Property{ .unparsed = unparsed }) catch bun.outOfMemory();
+                } else return false;
+            },
+            else => return false,
+        }
+
+        this.has_any = true;
+        return true;
+    }
+
+    // Either get the value from the field on `this` or initialize a new one
+    fn initSmallListHelper(
+        this: *@This(),
+        comptime T: type,
+        comptime N: comptime_int,
+        comptime field: []const u8,
+        allocator: Allocator,
+        length: u32,
+    ) []T {
+        if (@field(this, field)) |*list| {
+            list.clearRetainingCapacity();
+            list.ensureTotalCapacity(allocator, length);
+            list.setLen(length);
+            return list.slice_mut();
+        } else {
+            @field(this, field) = SmallList(T, N).initCapacity(allocator, length);
+            @field(this, field).?.setLen(length);
+            return @field(this, field).?.slice_mut();
+        }
+    }
+
+    fn backgroundHelper(
+        this: *@This(),
+        allocator: Allocator,
+        comptime T: type,
+        val: *const T,
+        property: *const Property,
+        dest: *css.DeclarationList,
+        context: *css.PropertyHandlerContext,
+    ) void {
+        this.flushHelper(allocator, "images", T, val, dest, context);
+
+        // Store prefixed properties. Clear if we hit an unprefixed property and we have
+        // targets. In this case, the necessary prefixes will be generated.
+        this.has_prefix = val.any(struct {
+            pub fn predicate(item: *const Image) bool {
+                return item.hasVendorPrefix();
+            }
+        }.predicate);
+        if (this.has_prefix) {
+            this.decls.append(allocator, property.deepClone(allocator)) catch bun.outOfMemory();
+        } else if (context.targets.browsers != null) {
+            this.decls.clearRetainingCapacity();
+        }
+    }
+
+    fn flushHelper(
+        this: *@This(),
+        allocator: Allocator,
+        comptime field: []const u8,
+        comptime T: type,
+        val: *const T,
+        dest: *css.DeclarationList,
+        context: *css.PropertyHandlerContext,
+    ) void {
+        if (@field(this, field) != null and
+            !@field(this, field).?.eql(val) and
+            context.targets.browsers != null and !val.isCompatible(context.targets.browsers.?))
+        {
+            this.flush(allocator, dest, context);
+        }
+    }
+
+    fn flush(this: *@This(), allocator: Allocator, dest: *css.DeclarationList, context: *css.PropertyHandlerContext) void {
+        if (!this.has_any) return;
+        this.has_any = false;
+        const push = struct {
+            fn push(self: *BackgroundHandler, alloc: Allocator, d: *css.DeclarationList, comptime property_field_name: []const u8, val: anytype) void {
+                d.append(alloc, @unionInit(Property, property_field_name, val)) catch bun.outOfMemory();
+                const prop = @field(BackgroundProperty, property_field_name);
+                self.flushed_properties.insert(prop);
+            }
+        }.push;
+
+        var maybe_color: ?CssColor = bun.take(&this.color);
+        var maybe_images: ?css.SmallList(Image, 1) = bun.take(&this.images);
+        var maybe_x_positions: ?css.SmallList(HorizontalPosition, 1) = bun.take(&this.x_positions);
+        var maybe_y_positions: ?css.SmallList(VerticalPosition, 1) = bun.take(&this.y_positions);
+        var maybe_repeats: ?css.SmallList(BackgroundRepeat, 1) = bun.take(&this.repeats);
+        var maybe_sizes: ?css.SmallList(BackgroundSize, 1) = bun.take(&this.sizes);
+        var maybe_attachments: ?css.SmallList(BackgroundAttachment, 1) = bun.take(&this.attachments);
+        var maybe_origins: ?css.SmallList(BackgroundOrigin, 1) = bun.take(&this.origins);
+        var maybe_clips: ?struct { css.SmallList(BackgroundClip, 1), css.VendorPrefix } = bun.take(&this.clips);
+        defer {
+            if (maybe_color) |*c| c.deinit(allocator);
+            if (maybe_images) |*i| i.deinit(allocator);
+            if (maybe_x_positions) |*x| x.deinit(allocator);
+            if (maybe_y_positions) |*y| y.deinit(allocator);
+            if (maybe_repeats) |*r| r.deinit(allocator);
+            if (maybe_sizes) |*s| s.deinit(allocator);
+            if (maybe_attachments) |*a| a.deinit(allocator);
+            if (maybe_origins) |*o| o.deinit(allocator);
+            if (maybe_clips) |*c| c.*[0].deinit(allocator);
+        }
+
+        if (maybe_color != null and
+            maybe_images != null and
+            maybe_x_positions != null and
+            maybe_y_positions != null and
+            maybe_repeats != null and
+            maybe_sizes != null and
+            maybe_attachments != null and
+            maybe_origins != null and
+            maybe_clips != null)
+        {
+            const color = &maybe_color.?;
+            var images = &maybe_images.?;
+            var x_positions = &maybe_x_positions.?;
+            var y_positions = &maybe_y_positions.?;
+            var repeats = &maybe_repeats.?;
+            var sizes = &maybe_sizes.?;
+            var attachments = &maybe_attachments.?;
+            var origins = &maybe_origins.?;
+            var clips = &maybe_clips.?;
+
+            // Only use shorthand syntax if the number of layers matches on all properties.
+            const len = images.len();
+            if (x_positions.len() == len and
+                y_positions.len() == len and
+                repeats.len() == len and
+                sizes.len() == len and attachments.len() == len and origins.len() == len and clips[0].len() == len)
+            {
+                const clip_prefixes = if (clips.*[0].any(struct {
+                    fn predicate(clip: *const BackgroundClip) bool {
+                        return clip.* == BackgroundClip.text;
+                    }
+                }.predicate)) context.targets.prefixes(clips.*[1], .background_clip) else clips.*[1];
+                const clip_property = if (!clip_prefixes.eql(css.VendorPrefix{ .none = true }))
+                    css.Property{ .@"background-clip" = .{ clips.*[0].deepClone(allocator), clip_prefixes } }
+                else
+                    null;
+
+                var backgrounds = SmallList(Background, 1).initCapacity(allocator, len);
+                for (
+                    images.slice(),
+                    x_positions.slice(),
+                    y_positions.slice(),
+                    repeats.slice(),
+                    sizes.slice(),
+                    attachments.slice(),
+                    origins.slice(),
+                    clips.*[0].slice(),
+                    0..,
+                ) |image, x_position, y_position, repeat, size, attachment, origin, clip, i| {
+                    backgrounds.appendAssumeCapacity(Background{
+                        .color = if (i == len - 1) color.deepClone(allocator) else CssColor.default(),
+                        .image = image,
+                        .position = BackgroundPosition{ .x = x_position, .y = y_position },
+                        .repeat = repeat,
+                        .size = size,
+                        .attachment = attachment,
+                        .origin = origin,
+                        .clip = if (clip_prefixes.eql(css.VendorPrefix{ .none = true })) clip else BackgroundClip.default(),
+                    });
+                }
+                defer {
+                    images.clearRetainingCapacity();
+                    x_positions.clearRetainingCapacity();
+                    y_positions.clearRetainingCapacity();
+                    repeats.clearRetainingCapacity();
+                    sizes.clearRetainingCapacity();
+                    attachments.clearRetainingCapacity();
+                    origins.clearRetainingCapacity();
+                    clips.*[0].clearRetainingCapacity();
+                }
+
+                if (!this.flushed_properties.intersects(BackgroundProperty.background)) {
+                    for (backgrounds.getFallbacks(allocator, context.targets).slice()) |fallback| {
+                        push(this, allocator, dest, "background", fallback);
+                    }
+                }
+
+                push(this, allocator, dest, "background", backgrounds);
+
+                if (clip_property) |clip| {
+                    dest.append(allocator, clip) catch bun.outOfMemory();
+                    this.flushed_properties.insert(BackgroundProperty.@"background-clip");
+                }
+
+                this.reset(allocator);
+                return;
+            }
+        }
+
+        if (bun.take(&maybe_color)) |color_| {
+            var color: CssColor = color_;
+            if (!this.flushed_properties.contains(BackgroundProperty.@"background-color")) {
+                for (color.getFallbacks(allocator, context.targets).slice()) |fallback| {
+                    push(this, allocator, dest, "background-color", fallback);
+                }
+            }
+            push(this, allocator, dest, "background-color", color);
+        }
+
+        if (bun.take(&maybe_images)) |images_| {
+            var images: css.SmallList(Image, 1) = images_;
+            if (!this.flushed_properties.contains(BackgroundProperty.@"background-image")) {
+                var fallbacks = images.getFallbacks(allocator, context.targets);
+                for (fallbacks.slice()) |fallback| {
+                    push(this, allocator, dest, "background-image", fallback);
+                }
+            }
+            push(this, allocator, dest, "background-image", images);
+        }
+
+        if (maybe_x_positions != null and maybe_y_positions != null and maybe_x_positions.?.len() == maybe_y_positions.?.len()) {
+            var positions = SmallList(BackgroundPosition, 1).initCapacity(allocator, maybe_x_positions.?.len());
+            for (maybe_x_positions.?.slice(), maybe_y_positions.?.slice()) |x, y| {
+                positions.appendAssumeCapacity(BackgroundPosition{ .x = x, .y = y });
+            }
+            maybe_x_positions.?.clearRetainingCapacity();
+            maybe_y_positions.?.clearRetainingCapacity();
+            push(this, allocator, dest, "background-position", positions);
+        } else {
+            if (bun.take(&maybe_x_positions)) |x| {
+                push(this, allocator, dest, "background-position-x", x);
+            }
+            if (bun.take(&maybe_y_positions)) |y| {
+                push(this, allocator, dest, "background-position-y", y);
+            }
+        }
+
+        if (bun.take(&maybe_repeats)) |rep| {
+            push(this, allocator, dest, "background-repeat", rep);
+        }
+
+        if (bun.take(&maybe_sizes)) |rep| {
+            push(this, allocator, dest, "background-size", rep);
+        }
+
+        if (bun.take(&maybe_attachments)) |rep| {
+            push(this, allocator, dest, "background-attachment", rep);
+        }
+
+        if (bun.take(&maybe_origins)) |rep| {
+            push(this, allocator, dest, "background-origin", rep);
+        }
+
+        if (bun.take(&maybe_clips)) |c| {
+            const clips: css.SmallList(BackgroundClip, 1), const vp: css.VendorPrefix = c;
+            const prefixes = if (clips.any(struct {
+                pub fn predicate(clip: *const BackgroundClip) bool {
+                    return clip.* == BackgroundClip.text;
+                }
+            }.predicate)) context.targets.prefixes(vp, css.prefixes.Feature.background_clip) else vp;
+            dest.append(
+                allocator,
+                Property{
+                    .@"background-clip" = .{ clips.deepClone(allocator), prefixes },
+                },
+            ) catch bun.outOfMemory();
+            this.flushed_properties.insert(BackgroundProperty.@"background-clip");
+        }
+
+        this.reset(allocator);
+    }
+
+    fn reset(this: *@This(), allocator: Allocator) void {
+        if (this.color) |c| c.deinit(allocator);
+        this.color = null;
+        if (this.images) |*i| i.deinit(allocator);
+        this.images = null;
+        if (this.x_positions) |*x| x.deinit(allocator);
+        this.x_positions = null;
+        if (this.y_positions) |*y| y.deinit(allocator);
+        this.y_positions = null;
+        if (this.repeats) |*r| r.deinit(allocator);
+        this.repeats = null;
+        if (this.sizes) |*s| s.deinit(allocator);
+        this.sizes = null;
+        if (this.attachments) |*a| a.deinit(allocator);
+        this.attachments = null;
+        if (this.origins) |*o| o.deinit(allocator);
+        this.origins = null;
+        if (this.clips) |*c| c.*[0].deinit(allocator);
+        this.clips = null;
+    }
+
+    pub fn finalize(this: *@This(), dest: *css.DeclarationList, context: *css.PropertyHandlerContext) void {
+        const allocator = context.allocator;
+        // If the last declaration is prefixed, pop the last value
+        // so it isn't duplicated when we flush.
+        if (this.has_prefix) {
+            var prop = this.decls.pop();
+            prop.deinit(allocator);
+        }
+
+        dest.appendSlice(allocator, this.decls.items) catch bun.outOfMemory();
+        this.decls.clearRetainingCapacity();
+
+        this.flush(allocator, dest, context);
+        this.flushed_properties = BackgroundProperty.empty();
+    }
+};
+
+fn isBackgroundProperty(property_id: css.PropertyId) bool {
+    return switch (property_id) {
+        .@"background-color",
+        .@"background-image",
+        .@"background-position",
+        .@"background-position-x",
+        .@"background-position-y",
+        .@"background-repeat",
+        .@"background-size",
+        .@"background-attachment",
+        .@"background-origin",
+        .@"background-clip",
+        .background,
+        => true,
+        else => false,
+    };
+}
diff --git a/src/css/properties/border.zig b/src/css/properties/border.zig
new file mode 100644
index 0000000000..6f89d00d28
--- /dev/null
+++ b/src/css/properties/border.zig
@@ -0,0 +1,458 @@
+const std = @import("std");
+const bun = @import("root").bun;
+const Allocator = std.mem.Allocator;
+const ArrayList = std.ArrayListUnmanaged;
+
+pub const css = @import("../css_parser.zig");
+
+const SmallList = css.SmallList;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+
+const LengthPercentage = css.css_values.length.LengthPercentage;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CSSString = css.css_values.string.CSSString;
+const CSSNumber = css.css_values.number.CSSNumber;
+const LengthPercentageOrAuto = css.css_values.length.LengthPercentageOrAuto;
+const Size2D = css.css_values.size.Size2D;
+const DashedIdent = css.css_values.ident.DashedIdent;
+const Image = css.css_values.image.Image;
+const CssColor = css.css_values.color.CssColor;
+const Ratio = css.css_values.ratio.Ratio;
+const Length = css.css_values.length.Length;
+
+/// A value for the [border-top](https://www.w3.org/TR/css-backgrounds-3/#propdef-border-top) shorthand property.
+pub const BorderTop = GenericBorder(LineStyle, 0);
+/// A value for the [border-right](https://www.w3.org/TR/css-backgrounds-3/#propdef-border-right) shorthand property.
+pub const BorderRight = GenericBorder(LineStyle, 1);
+/// A value for the [border-bottom](https://www.w3.org/TR/css-backgrounds-3/#propdef-border-bottom) shorthand property.
+pub const BorderBottom = GenericBorder(LineStyle, 2);
+/// A value for the [border-left](https://www.w3.org/TR/css-backgrounds-3/#propdef-border-left) shorthand property.
+pub const BorderLeft = GenericBorder(LineStyle, 3);
+/// A value for the [border-block-start](https://drafts.csswg.org/css-logical/#propdef-border-block-start) shorthand property.
+pub const BorderBlockStart = GenericBorder(LineStyle, 4);
+/// A value for the [border-block-end](https://drafts.csswg.org/css-logical/#propdef-border-block-end) shorthand property.
+pub const BorderBlockEnd = GenericBorder(LineStyle, 5);
+/// A value for the [border-inline-start](https://drafts.csswg.org/css-logical/#propdef-border-inline-start) shorthand property.
+pub const BorderInlineStart = GenericBorder(LineStyle, 6);
+/// A value for the [border-inline-end](https://drafts.csswg.org/css-logical/#propdef-border-inline-end) shorthand property.
+pub const BorderInlineEnd = GenericBorder(LineStyle, 7);
+/// A value for the [border-block](https://drafts.csswg.org/css-logical/#propdef-border-block) shorthand property.
+pub const BorderBlock = GenericBorder(LineStyle, 8);
+/// A value for the [border-inline](https://drafts.csswg.org/css-logical/#propdef-border-inline) shorthand property.
+pub const BorderInline = GenericBorder(LineStyle, 9);
+/// A value for the [border](https://www.w3.org/TR/css-backgrounds-3/#propdef-border) shorthand property.
+pub const Border = GenericBorder(LineStyle, 10);
+
+/// A generic type that represents the `border` and `outline` shorthand properties.
+pub fn GenericBorder(comptime S: type, comptime P: u8) type {
+    _ = P; // autofix
+    return struct {
+        /// The width of the border.
+        width: BorderSideWidth,
+        /// The border style.
+        style: S,
+        /// The border color.
+        color: CssColor,
+
+        const This = @This();
+
+        pub fn parse(input: *css.Parser) css.Result(@This()) {
+            // Order doesn't matter
+            var color: ?CssColor = null;
+            var style: ?S = null;
+            var width: ?BorderSideWidth = null;
+            var any = false;
+
+            while (true) {
+                if (width == null) {
+                    if (input.tryParse(BorderSideWidth.parse, .{}).asValue()) |value| {
+                        width = value;
+                        any = true;
+                    }
+                }
+
+                if (style == null) {
+                    if (input.tryParse(S.parse, .{}).asValue()) |value| {
+                        style = value;
+                        any = true;
+                        continue;
+                    }
+                }
+
+                if (color == null) {
+                    if (input.tryParse(CssColor.parse, .{}).asValue()) |value| {
+                        color = value;
+                        any = true;
+                        continue;
+                    }
+                }
+                break;
+            }
+
+            if (any) {
+                return .{
+                    .result = This{
+                        .width = width orelse BorderSideWidth.medium,
+                        .style = style orelse S.default(),
+                        .color = color orelse CssColor.current_color,
+                    },
+                };
+            }
+
+            return .{ .err = input.newCustomError(css.ParserError.invalid_declaration) };
+        }
+
+        pub fn toCss(this: *const This, W: anytype, dest: *Printer(W)) PrintErr!void {
+            if (this.eql(&This.default())) {
+                try this.style.toCss(W, dest);
+                return;
+            }
+
+            var needs_space = false;
+            if (!this.width.eql(&BorderSideWidth.default())) {
+                try this.width.toCss(W, dest);
+                needs_space = true;
+            }
+            if (!this.style.eql(&S.default())) {
+                if (needs_space) {
+                    try dest.writeStr(" ");
+                }
+                try this.style.toCss(W, dest);
+                needs_space = true;
+            }
+            if (!this.color.eql(&CssColor{ .current_color = {} })) {
+                if (needs_space) {
+                    try dest.writeStr(" ");
+                }
+                try this.color.toCss(W, dest);
+                needs_space = true;
+            }
+            return;
+        }
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+
+        pub fn eql(this: *const This, other: *const This) bool {
+            return this.width.eql(&other.width) and this.style.eql(&other.style) and this.color.eql(&other.color);
+        }
+
+        pub inline fn default() This {
+            return This{
+                .width = .medium,
+                .style = S.default(),
+                .color = CssColor.current_color,
+            };
+        }
+    };
+}
+/// A [`<line-style>`](https://drafts.csswg.org/css-backgrounds/#typedef-line-style) value, used in the `border-style` property.
+/// A [`<line-style>`](https://drafts.csswg.org/css-backgrounds/#typedef-line-style) value, used in the `border-style` property.
+pub const LineStyle = enum {
+    /// No border.
+    none,
+    /// Similar to `none` but with different rules for tables.
+    hidden,
+    /// Looks as if the content on the inside of the border is sunken into the canvas.
+    inset,
+    /// Looks as if it were carved in the canvas.
+    groove,
+    /// Looks as if the content on the inside of the border is coming out of the canvas.
+    outset,
+    /// Looks as if it were coming out of the canvas.
+    ridge,
+    /// A series of round dots.
+    dotted,
+    /// A series of square-ended dashes.
+    dashed,
+    /// A single line segment.
+    solid,
+    /// Two parallel solid lines with some space between them.
+    double,
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+
+    pub fn default() LineStyle {
+        return .none;
+    }
+};
+
+/// A value for the [border-width](https://www.w3.org/TR/css-backgrounds-3/#border-width) property.
+pub const BorderSideWidth = union(enum) {
+    /// A UA defined `thin` value.
+    thin,
+    /// A UA defined `medium` value.
+    medium,
+    /// A UA defined `thick` value.
+    thick,
+    /// An explicit width.
+    length: Length,
+
+    pub usingnamespace css.DeriveParse(@This());
+    pub usingnamespace css.DeriveToCss(@This());
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn default() BorderSideWidth {
+        return .medium;
+    }
+
+    pub fn eql(this: *const @This(), other: *const @This()) bool {
+        return switch (this.*) {
+            .thin => switch (other.*) {
+                .thin => true,
+                else => false,
+            },
+            .medium => switch (other.*) {
+                .medium => true,
+                else => false,
+            },
+            .thick => switch (other.*) {
+                .thick => true,
+                else => false,
+            },
+            .length => switch (other.*) {
+                .length => this.length.eql(&other.length),
+                else => false,
+            },
+        };
+    }
+};
+
+// TODO: fallbacks
+/// A value for the [border-color](https://drafts.csswg.org/css-backgrounds/#propdef-border-color) shorthand property.
+pub const BorderColor = struct {
+    top: CssColor,
+    right: CssColor,
+    bottom: CssColor,
+    left: CssColor,
+
+    // TODO: bring this back
+    // pub usingnamespace css.DefineShorthand(@This(), css.PropertyIdTag.@"border-color");
+    pub usingnamespace css.DefineRectShorthand(@This(), CssColor);
+
+    pub const PropertyFieldMap = .{
+        .top = css.PropertyIdTag.@"border-top-color",
+        .right = css.PropertyIdTag.@"border-right-color",
+        .bottom = css.PropertyIdTag.@"border-bottom-color",
+        .left = css.PropertyIdTag.@"border-left-color",
+    };
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+/// A value for the [border-style](https://drafts.csswg.org/css-backgrounds/#propdef-border-style) shorthand property.
+pub const BorderStyle = struct {
+    top: LineStyle,
+    right: LineStyle,
+    bottom: LineStyle,
+    left: LineStyle,
+
+    // TODO: bring this back
+    // pub usingnamespace css.DefineShorthand(@This(), css.PropertyIdTag.@"border-style");
+    pub usingnamespace css.DefineRectShorthand(@This(), LineStyle);
+
+    pub const PropertyFieldMap = .{
+        .top = css.PropertyIdTag.@"border-top-style",
+        .right = css.PropertyIdTag.@"border-right-style",
+        .bottom = css.PropertyIdTag.@"border-bottom-style",
+        .left = css.PropertyIdTag.@"border-left-style",
+    };
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+/// A value for the [border-width](https://drafts.csswg.org/css-backgrounds/#propdef-border-width) shorthand property.
+pub const BorderWidth = struct {
+    top: BorderSideWidth,
+    right: BorderSideWidth,
+    bottom: BorderSideWidth,
+    left: BorderSideWidth,
+
+    // TODO: bring this back
+    // pub usingnamespace css.DefineShorthand(@This(), css.PropertyIdTag.@"border-width");
+    pub usingnamespace css.DefineRectShorthand(@This(), BorderSideWidth);
+
+    pub const PropertyFieldMap = .{
+        .top = css.PropertyIdTag.@"border-top-width",
+        .right = css.PropertyIdTag.@"border-right-width",
+        .bottom = css.PropertyIdTag.@"border-bottom-width",
+        .left = css.PropertyIdTag.@"border-left-width",
+    };
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+// TODO: fallbacks
+/// A value for the [border-block-color](https://drafts.csswg.org/css-logical/#propdef-border-block-color) shorthand property.
+pub const BorderBlockColor = struct {
+    /// The block start value.
+    start: CssColor,
+    /// The block end value.
+    end: CssColor,
+
+    // TODO: bring this back
+    // pub usingnamespace css.DefineShorthand(@This(), css.PropertyIdTag.@"border-block-color");
+    pub usingnamespace css.DefineSizeShorthand(@This(), CssColor);
+
+    pub const PropertyFieldMap = .{
+        .start = css.PropertyIdTag.@"border-block-start-color",
+        .end = css.PropertyIdTag.@"border-block-end-color",
+    };
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+/// A value for the [border-block-style](https://drafts.csswg.org/css-logical/#propdef-border-block-style) shorthand property.
+pub const BorderBlockStyle = struct {
+    /// The block start value.
+    start: LineStyle,
+    /// The block end value.
+    end: LineStyle,
+
+    // TODO: bring this back
+    // pub usingnamespace css.DefineShorthand(@This(), css.PropertyIdTag.@"border-block-style");
+    pub usingnamespace css.DefineSizeShorthand(@This(), LineStyle);
+
+    pub const PropertyFieldMap = .{
+        .start = css.PropertyIdTag.@"border-block-start-style",
+        .end = css.PropertyIdTag.@"border-block-end-style",
+    };
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+/// A value for the [border-block-width](https://drafts.csswg.org/css-logical/#propdef-border-block-width) shorthand property.
+pub const BorderBlockWidth = struct {
+    /// The block start value.
+    start: BorderSideWidth,
+    /// The block end value.
+    end: BorderSideWidth,
+
+    // TODO: bring this back
+    // pub usingnamespace css.DefineShorthand(@This(), css.PropertyIdTag.@"border-block-width");
+    pub usingnamespace css.DefineSizeShorthand(@This(), BorderSideWidth);
+
+    pub const PropertyFieldMap = .{
+        .start = css.PropertyIdTag.@"border-block-start-width",
+        .end = css.PropertyIdTag.@"border-block-end-width",
+    };
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+// TODO: fallbacks
+/// A value for the [border-inline-color](https://drafts.csswg.org/css-logical/#propdef-border-inline-color) shorthand property.
+pub const BorderInlineColor = struct {
+    /// The inline start value.
+    start: CssColor,
+    /// The inline end value.
+    end: CssColor,
+
+    // TODO: bring this back
+    // pub usingnamespace css.DefineShorthand(@This(), css.PropertyIdTag.@"border-inline-color");
+    pub usingnamespace css.DefineSizeShorthand(@This(), CssColor);
+
+    pub const PropertyFieldMap = .{
+        .start = css.PropertyIdTag.@"border-inline-start-color",
+        .end = css.PropertyIdTag.@"border-inline-end-color",
+    };
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+/// A value for the [border-inline-style](https://drafts.csswg.org/css-logical/#propdef-border-inline-style) shorthand property.
+pub const BorderInlineStyle = struct {
+    /// The inline start value.
+    start: LineStyle,
+    /// The inline end value.
+    end: LineStyle,
+
+    // TODO: bring this back
+    // pub usingnamespace css.DefineShorthand(@This(), css.PropertyIdTag.@"border-inline-style");
+    pub usingnamespace css.DefineSizeShorthand(@This(), LineStyle);
+
+    pub const PropertyFieldMap = .{
+        .start = css.PropertyIdTag.@"border-inline-start-style",
+        .end = css.PropertyIdTag.@"border-inline-end-style",
+    };
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+/// A value for the [border-inline-width](https://drafts.csswg.org/css-logical/#propdef-border-inline-width) shorthand property.
+pub const BorderInlineWidth = struct {
+    /// The inline start value.
+    start: BorderSideWidth,
+    /// The inline end value.
+    end: BorderSideWidth,
+
+    // TODO: bring this back
+    // pub usingnamespace css.DefineShorthand(@This(), css.PropertyIdTag.@"border-inline-width");
+    pub usingnamespace css.DefineSizeShorthand(@This(), BorderSideWidth);
+
+    pub const PropertyFieldMap = .{
+        .start = css.PropertyIdTag.@"border-inline-start-width",
+        .end = css.PropertyIdTag.@"border-inline-end-width",
+    };
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
diff --git a/src/css/properties/border_image.zig b/src/css/properties/border_image.zig
new file mode 100644
index 0000000000..bde899c8ee
--- /dev/null
+++ b/src/css/properties/border_image.zig
@@ -0,0 +1,347 @@
+const std = @import("std");
+const bun = @import("root").bun;
+const Allocator = std.mem.Allocator;
+const ArrayList = std.ArrayListUnmanaged;
+
+pub const css = @import("../css_parser.zig");
+
+const SmallList = css.SmallList;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+
+const LengthPercentage = css.css_values.length.LengthPercentage;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CSSString = css.css_values.string.CSSString;
+const CSSNumber = css.css_values.number.CSSNumber;
+const LengthPercentageOrAuto = css.css_values.length.LengthPercentageOrAuto;
+const LengthOrNumber = css.css_values.length.LengthOrNumber;
+const Size2D = css.css_values.size.Size2D;
+const DashedIdent = css.css_values.ident.DashedIdent;
+const Image = css.css_values.image.Image;
+const CssColor = css.css_values.color.CssColor;
+const Ratio = css.css_values.ratio.Ratio;
+const Length = css.css_values.length.LengthValue;
+const Rect = css.css_values.rect.Rect;
+const NumberOrPercentage = css.css_values.percentage.NumberOrPercentage;
+const Percentage = css.css_values.percentage.Percentage;
+
+/// A value for the [border-image](https://www.w3.org/TR/css-backgrounds-3/#border-image) shorthand property.
+pub const BorderImage = struct {
+    /// The border image.
+    source: Image,
+    /// The offsets that define where the image is sliced.
+    slice: BorderImageSlice,
+    /// The width of the border image.
+    width: Rect(BorderImageSideWidth),
+    /// The amount that the image extends beyond the border box.
+    outset: Rect(css.css_values.length.LengthOrNumber),
+    /// How the border image is scaled and tiled.
+    repeat: BorderImageRepeat,
+
+    pub usingnamespace css.DefineShorthand(@This(), css.PropertyIdTag.@"border-image");
+
+    pub const PropertyFieldMap = .{
+        .source = css.PropertyIdTag.@"border-image-source",
+        .slice = css.PropertyIdTag.@"border-image-slice",
+        .width = css.PropertyIdTag.@"border-image-width",
+        .outset = css.PropertyIdTag.@"border-image-outset",
+        .repeat = css.PropertyIdTag.@"border-image-repeat",
+    };
+
+    pub const VendorPrefixMap = .{
+        .source = true,
+        .slice = true,
+        .width = true,
+        .outset = true,
+        .repeat = true,
+    };
+
+    pub fn parse(input: *css.Parser) css.Result(BorderImage) {
+        return parseWithCallback(input, {}, struct {
+            pub fn cb(_: void, _: *css.Parser) bool {
+                return false;
+            }
+        }.cb);
+    }
+
+    pub fn parseWithCallback(input: *css.Parser, ctx: anytype, comptime callback: anytype) css.Result(BorderImage) {
+        var source: ?Image = null;
+        var slice: ?BorderImageSlice = null;
+        var width: ?Rect(BorderImageSideWidth) = null;
+        var outset: ?Rect(LengthOrNumber) = null;
+        var repeat: ?BorderImageRepeat = null;
+
+        while (true) {
+            if (slice == null) {
+                if (input.tryParse(BorderImageSlice.parse, .{}).asValue()) |value| {
+                    slice = value;
+                    // Parse border image width and outset, if applicable.
+                    const maybe_width_outset = input.tryParse(struct {
+                        pub fn parse(i: *css.Parser) css.Result(struct { ?Rect(BorderImageSideWidth), ?Rect(LengthOrNumber) }) {
+                            if (i.expectDelim('/').asErr()) |e| return .{ .err = e };
+
+                            const w = i.tryParse(Rect(BorderImageSideWidth).parse, .{}).asValue();
+
+                            const o = i.tryParse(struct {
+                                pub fn parseFn(in: *css.Parser) css.Result(Rect(LengthOrNumber)) {
+                                    if (in.expectDelim('/').asErr()) |e| return .{ .err = e };
+                                    return Rect(LengthOrNumber).parse(in);
+                                }
+                            }.parseFn, .{}).asValue();
+
+                            if (w == null and o == null) return .{ .err = i.newCustomError(css.ParserError.invalid_declaration) };
+                            return .{ .result = .{ w, o } };
+                        }
+                    }.parse, .{});
+
+                    if (maybe_width_outset.asValue()) |val| {
+                        width = val[0];
+                        outset = val[1];
+                    }
+                    continue;
+                }
+            }
+
+            if (source == null) {
+                if (input.tryParse(Image.parse, .{}).asValue()) |value| {
+                    source = value;
+                    continue;
+                }
+            }
+
+            if (repeat == null) {
+                if (input.tryParse(BorderImageRepeat.parse, .{}).asValue()) |value| {
+                    repeat = value;
+                    continue;
+                }
+            }
+
+            if (@call(.auto, callback, .{ ctx, input })) {
+                continue;
+            }
+
+            break;
+        }
+
+        if (source != null or slice != null or width != null or outset != null or repeat != null) {
+            return .{
+                .result = BorderImage{
+                    .source = source orelse Image.default(),
+                    .slice = slice orelse BorderImageSlice.default(),
+                    .width = width orelse Rect(BorderImageSideWidth).all(BorderImageSideWidth.default()),
+                    .outset = outset orelse Rect(LengthOrNumber).all(LengthOrNumber.default()),
+                    .repeat = repeat orelse BorderImageRepeat.default(),
+                },
+            };
+        }
+        return .{ .err = input.newCustomError(css.ParserError.invalid_declaration) };
+    }
+
+    pub fn toCss(this: *const BorderImage, comptime W: type, dest: *css.Printer(W)) PrintErr!void {
+        return toCssInternal(&this.source, &this.slice, &this.width, &this.outset, &this.repeat, W, dest);
+    }
+
+    pub fn toCssInternal(
+        source: *const Image,
+        slice: *const BorderImageSlice,
+        width: *const Rect(BorderImageSideWidth),
+        outset: *const Rect(LengthOrNumber),
+        repeat: *const BorderImageRepeat,
+        comptime W: type,
+        dest: *css.Printer(W),
+    ) PrintErr!void {
+        if (!css.generic.eql(Image, source, &Image.default())) {
+            try source.toCss(W, dest);
+        }
+        const has_slice = !css.generic.eql(BorderImageSlice, slice, &BorderImageSlice.default());
+        const has_width = !css.generic.eql(Rect(BorderImageSideWidth), width, &Rect(BorderImageSideWidth).all(BorderImageSideWidth.default()));
+        const has_outset = !css.generic.eql(Rect(LengthOrNumber), outset, &Rect(LengthOrNumber).all(LengthOrNumber{ .number = 0.0 }));
+        if (has_slice or has_width or has_outset) {
+            try dest.writeStr(" ");
+            try slice.toCss(W, dest);
+            if (has_width or has_outset) {
+                try dest.delim('/', true);
+            }
+            if (has_width) {
+                try width.toCss(W, dest);
+            }
+
+            if (has_outset) {
+                try dest.delim('/', true);
+                try outset.toCss(W, dest);
+            }
+        }
+
+        if (!css.generic.eql(BorderImageRepeat, repeat, &BorderImageRepeat.default())) {
+            try dest.writeStr(" ");
+            return repeat.toCss(W, dest);
+        }
+
+        return;
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(this: *const BorderImage, other: *const BorderImage) bool {
+        return this.source.eql(&other.source) and
+            this.slice.eql(&other.slice) and
+            this.width.eql(&other.width) and
+            this.outset.eql(&other.outset) and
+            this.repeat.eql(&other.repeat);
+    }
+
+    pub fn default() BorderImage {
+        return BorderImage{
+            .source = Image.default(),
+            .slice = BorderImageSlice.default(),
+            .width = Rect(BorderImageSideWidth).all(BorderImageSideWidth.default()),
+            .outset = Rect(LengthOrNumber).all(LengthOrNumber.default()),
+            .repeat = BorderImageRepeat.default(),
+        };
+    }
+};
+
+/// A value for the [border-image-repeat](https://www.w3.org/TR/css-backgrounds-3/#border-image-repeat) property.
+pub const BorderImageRepeat = struct {
+    /// The horizontal repeat value.
+    horizontal: BorderImageRepeatKeyword,
+    /// The vertical repeat value.
+    vertical: BorderImageRepeatKeyword,
+
+    pub fn parse(input: *css.Parser) css.Result(BorderImageRepeat) {
+        const horizontal = switch (BorderImageRepeatKeyword.parse(input)) {
+            .result => |v| v,
+            .err => |e| return .{ .err = e },
+        };
+        const vertical = input.tryParse(BorderImageRepeatKeyword.parse, .{}).asValue();
+        return .{ .result = BorderImageRepeat{
+            .horizontal = horizontal,
+            .vertical = vertical orelse horizontal,
+        } };
+    }
+
+    pub fn toCss(this: *const BorderImageRepeat, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        try this.horizontal.toCss(W, dest);
+        if (this.horizontal != this.vertical) {
+            try dest.writeStr(" ");
+            try this.vertical.toCss(W, dest);
+        }
+    }
+
+    pub fn default() BorderImageRepeat {
+        return BorderImageRepeat{
+            .horizontal = BorderImageRepeatKeyword.stretch,
+            .vertical = BorderImageRepeatKeyword.stretch,
+        };
+    }
+
+    pub fn eql(this: *const BorderImageRepeat, other: *const BorderImageRepeat) bool {
+        return this.horizontal.eql(&other.horizontal) and this.vertical.eql(&other.vertical);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A value for the [border-image-width](https://www.w3.org/TR/css-backgrounds-3/#border-image-width) property.
+pub const BorderImageSideWidth = union(enum) {
+    /// A number representing a multiple of the border width.
+    number: CSSNumber,
+    /// An explicit length or percentage.
+    length_percentage: LengthPercentage,
+    /// The `auto` keyword, representing the natural width of the image slice.
+    auto: void,
+
+    pub usingnamespace css.DeriveParse(@This());
+    pub usingnamespace css.DeriveToCss(@This());
+
+    pub fn default() BorderImageSideWidth {
+        return .{ .number = 1.0 };
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(this: *const BorderImageSideWidth, other: *const BorderImageSideWidth) bool {
+        return switch (this.*) {
+            .number => |*a| switch (other.*) {
+                .number => |*b| a.* == b.*,
+                else => false,
+            },
+            .length_percentage => |*a| switch (other.*) {
+                .length_percentage => css.generic.eql(LengthPercentage, a, &other.length_percentage),
+                else => false,
+            },
+            .auto => switch (other.*) {
+                .auto => true,
+                else => false,
+            },
+        };
+    }
+};
+
+/// A single [border-image-repeat](https://www.w3.org/TR/css-backgrounds-3/#border-image-repeat) keyword.
+pub const BorderImageRepeatKeyword = enum {
+    /// The image is stretched to fill the area.
+    stretch,
+    /// The image is tiled (repeated) to fill the area.
+    repeat,
+    /// The image is scaled so that it repeats an even number of times.
+    round,
+    /// The image is repeated so that it fits, and then spaced apart evenly.
+    space,
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+};
+
+/// A value for the [border-image-slice](https://www.w3.org/TR/css-backgrounds-3/#border-image-slice) property.
+pub const BorderImageSlice = struct {
+    /// The offsets from the edges of the image.
+    offsets: Rect(NumberOrPercentage),
+    /// Whether the middle of the border image should be preserved.
+    fill: bool,
+
+    pub fn parse(input: *css.Parser) css.Result(BorderImageSlice) {
+        var fill = switch (input.expectIdentMatching("fill")) {
+            .err => false,
+            .result => true,
+        };
+        const offsets = switch (Rect(NumberOrPercentage).parse(input)) {
+            .err => |e| return .{ .err = e },
+            .result => |v| v,
+        };
+        if (!fill) {
+            fill = switch (input.expectIdentMatching("fill")) {
+                .err => false,
+                .result => true,
+            };
+        }
+        return .{ .result = BorderImageSlice{ .offsets = offsets, .fill = fill } };
+    }
+
+    pub fn toCss(this: *const BorderImageSlice, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        try this.offsets.toCss(W, dest);
+        if (this.fill) {
+            try dest.writeStr(" fill");
+        }
+    }
+
+    pub fn eql(this: *const BorderImageSlice, other: *const BorderImageSlice) bool {
+        return this.offsets.eql(&other.offsets) and this.fill == other.fill;
+    }
+
+    pub fn default() BorderImageSlice {
+        return BorderImageSlice{
+            .offsets = Rect(NumberOrPercentage).all(NumberOrPercentage{ .percentage = Percentage{ .v = 1.0 } }),
+            .fill = false,
+        };
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
diff --git a/src/css/properties/border_radius.zig b/src/css/properties/border_radius.zig
new file mode 100644
index 0000000000..befd591f75
--- /dev/null
+++ b/src/css/properties/border_radius.zig
@@ -0,0 +1,109 @@
+const std = @import("std");
+const bun = @import("root").bun;
+const Allocator = std.mem.Allocator;
+const ArrayList = std.ArrayListUnmanaged;
+
+pub const css = @import("../css_parser.zig");
+
+const SmallList = css.SmallList;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+
+const LengthPercentage = css.css_values.length.LengthPercentage;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CSSString = css.css_values.string.CSSString;
+const CSSNumber = css.css_values.number.CSSNumber;
+const LengthPercentageOrAuto = css.css_values.length.LengthPercentageOrAuto;
+const Size2D = css.css_values.size.Size2D;
+const DashedIdent = css.css_values.ident.DashedIdent;
+const Image = css.css_values.image.Image;
+const CssColor = css.css_values.color.CssColor;
+const Ratio = css.css_values.ratio.Ratio;
+const Length = css.css_values.length.LengthValue;
+const Rect = css.css_values.rect.Rect;
+const NumberOrPercentage = css.css_values.percentage.NumberOrPercentage;
+
+/// A value for the [border-radius](https://www.w3.org/TR/css-backgrounds-3/#border-radius) property.
+pub const BorderRadius = struct {
+    /// The x and y radius values for the top left corner.
+    top_left: Size2D(LengthPercentage),
+    /// The x and y radius values for the top right corner.
+    top_right: Size2D(LengthPercentage),
+    /// The x and y radius values for the bottom right corner.
+    bottom_right: Size2D(LengthPercentage),
+    /// The x and y radius values for the bottom left corner.
+    bottom_left: Size2D(LengthPercentage),
+
+    pub usingnamespace css.DefineShorthand(@This(), css.PropertyIdTag.@"border-radius");
+
+    pub const PropertyFieldMap = .{
+        .top_left = "border-top-left-radius",
+        .top_right = "border-top-right-radius",
+        .bottom_right = "border-bottom-right-radius",
+        .bottom_left = "border-bottom-left-radius",
+    };
+
+    pub const VendorPrefixMap = .{
+        .top_left = true,
+        .top_right = true,
+        .bottom_right = true,
+        .bottom_left = true,
+    };
+
+    pub fn parse(input: *css.Parser) css.Result(BorderRadius) {
+        const widths = switch (Rect(LengthPercentage).parse(input)) {
+            .result => |v| v,
+            .err => |e| return .{ .err = e },
+        };
+        const heights = if (input.tryParse(css.Parser.expectDelim, .{'/'}).isOk())
+            switch (Rect(LengthPercentage).parse(input)) {
+                .result => |v| v,
+                .err => |e| {
+                    widths.deinit(input.allocator());
+                    return .{ .err = e };
+                },
+            }
+        else
+            widths.deepClone(input.allocator());
+
+        return .{
+            .result = BorderRadius{
+                .top_left = Size2D(LengthPercentage){ .a = widths.top, .b = heights.top },
+                .top_right = Size2D(LengthPercentage){ .a = widths.right, .b = heights.right },
+                .bottom_right = Size2D(LengthPercentage){ .a = widths.bottom, .b = heights.bottom },
+                .bottom_left = Size2D(LengthPercentage){ .a = widths.left, .b = heights.left },
+            },
+        };
+    }
+
+    pub fn toCss(this: *const BorderRadius, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        const widths = Rect(*const LengthPercentage){
+            .top = &this.top_left.a,
+            .right = &this.top_right.a,
+            .bottom = &this.bottom_right.a,
+            .left = &this.bottom_left.a,
+        };
+
+        const heights = Rect(*const LengthPercentage){
+            .top = &this.top_left.b,
+            .right = &this.top_right.b,
+            .bottom = &this.bottom_right.b,
+            .left = &this.bottom_left.b,
+        };
+
+        try widths.toCss(W, dest);
+
+        if (!widths.eql(&heights)) {
+            try dest.delim('/', true);
+            try heights.toCss(W, dest);
+        }
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
diff --git a/src/css/properties/box_shadow.zig b/src/css/properties/box_shadow.zig
new file mode 100644
index 0000000000..dea6c1bf53
--- /dev/null
+++ b/src/css/properties/box_shadow.zig
@@ -0,0 +1,131 @@
+const std = @import("std");
+const bun = @import("root").bun;
+const Allocator = std.mem.Allocator;
+const ArrayList = std.ArrayListUnmanaged;
+
+pub const css = @import("../css_parser.zig");
+
+const SmallList = css.SmallList;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+
+const LengthPercentage = css.css_values.length.LengthPercentage;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CSSString = css.css_values.string.CSSString;
+const CSSNumber = css.css_values.number.CSSNumber;
+const LengthPercentageOrAuto = css.css_values.length.LengthPercentageOrAuto;
+const Size2D = css.css_values.size.Size2D;
+const DashedIdent = css.css_values.ident.DashedIdent;
+const Image = css.css_values.image.Image;
+const CssColor = css.css_values.color.CssColor;
+const Ratio = css.css_values.ratio.Ratio;
+const Length = css.css_values.length.LengthValue;
+const Rect = css.css_values.rect.Rect;
+const NumberOrPercentage = css.css_values.percentage.NumberOrPercentage;
+
+/// A value for the [box-shadow](https://drafts.csswg.org/css-backgrounds/#box-shadow) property.
+pub const BoxShadow = struct {
+    /// The color of the box shadow.
+    color: CssColor,
+    /// The x offset of the shadow.
+    x_offset: Length,
+    /// The y offset of the shadow.
+    y_offset: Length,
+    /// The blur radius of the shadow.
+    blur: Length,
+    /// The spread distance of the shadow.
+    spread: Length,
+    /// Whether the shadow is inset within the box.
+    inset: bool,
+
+    pub fn parse(input: *css.Parser) css.Result(@This()) {
+        var color: ?CssColor = null;
+        const Lengths = struct { x: Length, y: Length, blur: Length, spread: Length };
+        var lengths: ?Lengths = null;
+        var inset = false;
+
+        while (true) {
+            if (!inset) {
+                if (input.tryParse(css.Parser.expectIdentMatching, .{"inset"}).isOk()) {
+                    inset = true;
+                    continue;
+                }
+            }
+
+            if (lengths == null) {
+                const value = input.tryParse(struct {
+                    fn parse(p: *css.Parser) css.Result(Lengths) {
+                        const horizontal = switch (Length.parse(p)) {
+                            .result => |v| v,
+                            .err => |e| return .{ .err = e },
+                        };
+                        const vertical = switch (Length.parse(p)) {
+                            .result => |v| v,
+                            .err => |e| return .{ .err = e },
+                        };
+                        const blur = p.tryParse(Length.parse, .{}).asValue() orelse Length.zero();
+                        const spread = p.tryParse(Length.parse, .{}).asValue() orelse Length.zero();
+                        return .{ .result = .{ .x = horizontal, .y = vertical, .blur = blur, .spread = spread } };
+                    }
+                }.parse, .{});
+
+                if (value.isOk()) {
+                    lengths = value.result;
+                    continue;
+                }
+            }
+
+            if (color == null) {
+                if (input.tryParse(CssColor.parse, .{}).asValue()) |c| {
+                    color = c;
+                    continue;
+                }
+            }
+
+            break;
+        }
+
+        const final_lengths = lengths orelse return .{ .err = input.newError(.qualified_rule_invalid) };
+        return .{ .result = BoxShadow{
+            .color = color orelse CssColor{ .current_color = {} },
+            .x_offset = final_lengths.x,
+            .y_offset = final_lengths.y,
+            .blur = final_lengths.blur,
+            .spread = final_lengths.spread,
+            .inset = inset,
+        } };
+    }
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+        if (this.inset) {
+            try dest.writeStr("inset ");
+        }
+
+        try this.x_offset.toCss(W, dest);
+        try dest.writeChar(' ');
+        try this.y_offset.toCss(W, dest);
+
+        if (!this.blur.eql(&Length.zero()) or !this.spread.eql(&Length.zero())) {
+            try dest.writeChar(' ');
+            try this.blur.toCss(W, dest);
+
+            if (!this.spread.eql(&Length.zero())) {
+                try dest.writeChar(' ');
+                try this.spread.toCss(W, dest);
+            }
+        }
+
+        if (!this.color.eql(&CssColor{ .current_color = {} })) {
+            try dest.writeChar(' ');
+            try this.color.toCss(W, dest);
+        }
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
diff --git a/src/css/properties/contain.zig b/src/css/properties/contain.zig
new file mode 100644
index 0000000000..a095c5228c
--- /dev/null
+++ b/src/css/properties/contain.zig
@@ -0,0 +1,43 @@
+const std = @import("std");
+const bun = @import("root").bun;
+const Allocator = std.mem.Allocator;
+const ArrayList = std.ArrayListUnmanaged;
+
+pub const css = @import("../css_parser.zig");
+
+const SmallList = css.SmallList;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+
+const ContainerName = css.css_rules.container.ContainerName;
+
+const LengthPercentage = css.css_values.length.LengthPercentage;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CSSString = css.css_values.string.CSSString;
+const CSSNumber = css.css_values.number.CSSNumber;
+const LengthPercentageOrAuto = css.css_values.length.LengthPercentageOrAuto;
+const Size2D = css.css_values.size.Size2D;
+const DashedIdent = css.css_values.ident.DashedIdent;
+const Image = css.css_values.image.Image;
+const CssColor = css.css_values.color.CssColor;
+const Ratio = css.css_values.ratio.Ratio;
+const Length = css.css_values.length.LengthValue;
+const Rect = css.css_values.rect.Rect;
+const NumberOrPercentage = css.css_values.percentage.NumberOrPercentage;
+
+const ContainerIdent = ContainerName;
+
+/// A value for the [container-type](https://drafts.csswg.org/css-contain-3/#container-type) property.
+/// Establishes the element as a query container for the purpose of container queries.
+pub const ContainerType = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A value for the [container-name](https://drafts.csswg.org/css-contain-3/#container-name) property.
+pub const ContainerNameList = union(enum) {
+    /// The `none` keyword.
+    none,
+    /// A list of container names.
+    names: SmallList(ContainerIdent, 1),
+};
+
+/// A value for the [container](https://drafts.csswg.org/css-contain-3/#container-shorthand) shorthand property.
+pub const Container = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
diff --git a/src/css/properties/css_modules.zig b/src/css/properties/css_modules.zig
new file mode 100644
index 0000000000..fa087a3866
--- /dev/null
+++ b/src/css/properties/css_modules.zig
@@ -0,0 +1,111 @@
+const std = @import("std");
+const bun = @import("root").bun;
+const Allocator = std.mem.Allocator;
+const ArrayList = std.ArrayListUnmanaged;
+
+pub const css = @import("../css_parser.zig");
+
+const SmallList = css.SmallList;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const Error = css.Error;
+
+const ContainerName = css.css_rules.container.ContainerName;
+
+const LengthPercentage = css.css_values.length.LengthPercentage;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CSSString = css.css_values.string.CSSString;
+const CSSNumber = css.css_values.number.CSSNumber;
+const LengthPercentageOrAuto = css.css_values.length.LengthPercentageOrAuto;
+const Size2D = css.css_values.size.Size2D;
+const DashedIdent = css.css_values.ident.DashedIdent;
+const Image = css.css_values.image.Image;
+const CssColor = css.css_values.color.CssColor;
+const Ratio = css.css_values.ratio.Ratio;
+const Length = css.css_values.length.LengthValue;
+const Rect = css.css_values.rect.Rect;
+const NumberOrPercentage = css.css_values.percentage.NumberOrPercentage;
+const CustomIdentList = css.css_values.ident.CustomIdentList;
+const CustomIdentFns = css.css_values.ident.CustomIdentFns;
+
+const Location = css.dependencies.Location;
+
+/// A value for the [composes](https://github.com/css-modules/css-modules/#dependencies) property from CSS modules.
+pub const Composes = struct {
+    /// A list of class names to compose.
+    names: CustomIdentList,
+    /// Where the class names are composed from.
+    from: ?Specifier,
+    /// The source location of the `composes` property.
+    loc: Location,
+
+    pub fn parse(input: *css.Parser) css.Result(Composes) {
+        _ = input; // autofix
+        @panic(css.todo_stuff.depth);
+    }
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+        var first = true;
+        for (this.names.slice()) |name| {
+            if (first) {
+                first = false;
+            } else {
+                try dest.writeChar(' ');
+            }
+            try CustomIdentFns.toCss(&name, W, dest);
+        }
+
+        if (this.from) |*from| {
+            try dest.writeStr(" from ");
+            try from.toCss(W, dest);
+        }
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+/// Defines where the class names referenced in the `composes` property are located.
+///
+/// See [Composes](Composes).
+pub const Specifier = union(enum) {
+    /// The referenced name is global.
+    global,
+    /// The referenced name comes from the specified file.
+    file: []const u8,
+    /// The referenced name comes from a source index (used during bundling).
+    source_index: u32,
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn parse(input: *css.Parser) css.Result(Specifier) {
+        if (input.tryParse(css.Parser.expectString, .{}).asValue()) |file| {
+            return .{ .result = .{ .file = file } };
+        }
+        if (input.expectIdentMatching("global").asErr()) |e| return .{ .err = e };
+        return .{ .result = .global };
+    }
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+        return switch (this.*) {
+            .global => dest.writeStr("global"),
+            .file => |file| css.serializer.serializeString(file, dest) catch return dest.addFmtError(),
+            .source_index => {},
+        };
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+        return css.implementHash(@This(), this, hasher);
+    }
+};
diff --git a/src/css/properties/custom.zig b/src/css/properties/custom.zig
new file mode 100644
index 0000000000..eaa7ad2f89
--- /dev/null
+++ b/src/css/properties/custom.zig
@@ -0,0 +1,1545 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const bun = @import("root").bun;
+const logger = bun.logger;
+const Log = logger.Log;
+
+pub const css = @import("../css_parser.zig");
+pub const css_values = @import("../values/values.zig");
+pub const Printer = css.Printer;
+pub const PrintErr = css.PrintErr;
+const DashedIdent = css_values.ident.DashedIdent;
+const DashedIdentFns = css_values.ident.DashedIdentFns;
+const Ident = css_values.ident.Ident;
+const IdentFns = css_values.ident.IdentFns;
+pub const Result = css.Result;
+
+pub const CssColor = css.css_values.color.CssColor;
+pub const RGBA = css.css_values.color.RGBA;
+pub const SRGB = css.css_values.color.SRGB;
+pub const HSL = css.css_values.color.HSL;
+pub const CSSInteger = css.css_values.number.CSSInteger;
+pub const CSSIntegerFns = css.css_values.number.CSSIntegerFns;
+pub const CSSNumberFns = css.css_values.number.CSSNumberFns;
+pub const Percentage = css.css_values.percentage.Percentage;
+pub const Url = css.css_values.url.Url;
+pub const DashedIdentReference = css.css_values.ident.DashedIdentReference;
+pub const CustomIdent = css.css_values.ident.CustomIdent;
+pub const CustomIdentFns = css.css_values.ident.CustomIdentFns;
+pub const LengthValue = css.css_values.length.LengthValue;
+pub const Angle = css.css_values.angle.Angle;
+pub const Time = css.css_values.time.Time;
+pub const Resolution = css.css_values.resolution.Resolution;
+pub const AnimationName = css.css_properties.animation.AnimationName;
+const ComponentParser = css.css_values.color.ComponentParser;
+
+const SupportsCondition = css.SupportsCondition;
+const ColorFallbackKind = css.ColorFallbackKind;
+
+const ArrayList = std.ArrayListUnmanaged;
+
+/// PERF: nullable optimization
+pub const TokenList = struct {
+    v: std.ArrayListUnmanaged(TokenOrValue) = .{},
+
+    const This = @This();
+
+    pub fn deinit(this: *TokenList, allocator: Allocator) void {
+        for (this.v.items) |*token_or_value| {
+            token_or_value.deinit(allocator);
+        }
+        this.v.deinit(allocator);
+    }
+
+    pub fn toCss(
+        this: *const This,
+        comptime W: type,
+        dest: *Printer(W),
+        is_custom_property: bool,
+    ) PrintErr!void {
+        if (!dest.minify and this.v.items.len == 1 and this.v.items[0].isWhitespace()) {
+            return;
+        }
+
+        var has_whitespace = false;
+        for (this.v.items, 0..) |*token_or_value, i| {
+            switch (token_or_value.*) {
+                .color => |color| {
+                    try color.toCss(W, dest);
+                    has_whitespace = false;
+                },
+                .unresolved_color => |color| {
+                    try color.toCss(W, dest, is_custom_property);
+                    has_whitespace = false;
+                },
+                .url => |url| {
+                    if (dest.dependencies != null and is_custom_property and !url.isAbsolute(try dest.getImportRecords())) {
+                        return dest.newError(css.PrinterErrorKind{
+                            .ambiguous_url_in_custom_property = .{ .url = (try dest.getImportRecords()).at(url.import_record_idx).path.pretty },
+                        }, url.loc);
+                    }
+                    try url.toCss(W, dest);
+                    has_whitespace = false;
+                },
+                .@"var" => |@"var"| {
+                    try @"var".toCss(W, dest, is_custom_property);
+                    has_whitespace = try this.writeWhitespaceIfNeeded(i, W, dest);
+                },
+                .env => |env| {
+                    try env.toCss(W, dest, is_custom_property);
+                    has_whitespace = try this.writeWhitespaceIfNeeded(i, W, dest);
+                },
+                .function => |f| {
+                    try f.toCss(W, dest, is_custom_property);
+                    has_whitespace = try this.writeWhitespaceIfNeeded(i, W, dest);
+                },
+                .length => |v| {
+                    // Do not serialize unitless zero lengths in custom properties as it may break calc().
+                    const value, const unit = v.toUnitValue();
+                    try css.serializer.serializeDimension(value, unit, W, dest);
+                    has_whitespace = false;
+                },
+                .angle => |v| {
+                    try v.toCss(W, dest);
+                    has_whitespace = false;
+                },
+                .time => |v| {
+                    try v.toCss(W, dest);
+                    has_whitespace = false;
+                },
+                .resolution => |v| {
+                    try v.toCss(W, dest);
+                    has_whitespace = false;
+                },
+                .dashed_ident => |v| {
+                    try DashedIdentFns.toCss(&v, W, dest);
+                    has_whitespace = false;
+                },
+                .animation_name => |v| {
+                    try v.toCss(W, dest);
+                    has_whitespace = false;
+                },
+                .token => |token| switch (token) {
+                    .delim => |d| {
+                        if (d == '+' or d == '-') {
+                            try dest.writeChar(' ');
+                            bun.assert(d <= 0x7F);
+                            try dest.writeChar(@intCast(d));
+                            try dest.writeChar(' ');
+                        } else {
+                            const ws_before = !has_whitespace and (d == '/' or d == '*');
+                            bun.assert(d <= 0x7F);
+                            try dest.delim(@intCast(d), ws_before);
+                        }
+                        has_whitespace = true;
+                    },
+                    .comma => {
+                        try dest.delim(',', false);
+                        has_whitespace = true;
+                    },
+                    .close_paren, .close_square, .close_curly => {
+                        try token.toCss(W, dest);
+                        has_whitespace = try this.writeWhitespaceIfNeeded(i, W, dest);
+                    },
+                    .dimension => {
+                        try css.serializer.serializeDimension(token.dimension.num.value, token.dimension.unit, W, dest);
+                        has_whitespace = false;
+                    },
+                    .number => |v| {
+                        try css.css_values.number.CSSNumberFns.toCss(&v.value, W, dest);
+                        has_whitespace = false;
+                    },
+                    else => {
+                        try token.toCss(W, dest);
+                        has_whitespace = token == .whitespace;
+                    },
+                },
+            }
+        }
+    }
+
+    pub fn toCssRaw(this: *const TokenList, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        for (this.v.items) |*token_or_value| {
+            if (token_or_value.* == .token) {
+                try token_or_value.token.toCss(W, dest);
+            } else {
+                return dest.addFmtError();
+            }
+        }
+    }
+
+    pub fn writeWhitespaceIfNeeded(
+        this: *const This,
+        i: usize,
+        comptime W: type,
+        dest: *Printer(W),
+    ) PrintErr!bool {
+        if (!dest.minify and
+            i != this.v.items.len - 1 and
+            !(this.v.items[i + 1] == .token and switch (this.v.items[i + 1].token) {
+            .comma, .close_paren => true,
+            else => false,
+        })) {
+            // Whitespace is removed during parsing, so add it back if we aren't minifying.
+            try dest.writeChar(' ');
+            return true;
+        } else return false;
+    }
+
+    pub fn parse(input: *css.Parser, options: *const css.ParserOptions, depth: usize) Result(TokenList) {
+        var tokens = ArrayList(TokenOrValue){}; // PERF: deinit on error
+        if (TokenListFns.parseInto(input, &tokens, options, depth).asErr()) |e| return .{ .err = e };
+
+        // Slice off leading and trailing whitespace if there are at least two tokens.
+        // If there is only one token, we must preserve it. e.g. `--foo: ;` is valid.
+        // PERF(alloc): this feels like a common codepath, idk how I feel about reallocating a new array just to slice off whitespace.
+        if (tokens.items.len >= 2) {
+            var slice = tokens.items[0..];
+            if (tokens.items.len > 0 and tokens.items[0].isWhitespace()) {
+                slice = slice[1..];
+            }
+            if (tokens.items.len > 0 and tokens.items[tokens.items.len - 1].isWhitespace()) {
+                slice = slice[0 .. slice.len - 1];
+            }
+            var newlist = ArrayList(TokenOrValue){};
+            newlist.insertSlice(input.allocator(), 0, slice) catch unreachable;
+            tokens.deinit(input.allocator());
+            return .{ .result = TokenList{ .v = newlist } };
+        }
+
+        return .{ .result = .{ .v = tokens } };
+    }
+
+    pub fn parseWithOptions(input: *css.Parser, options: *const css.ParserOptions) Result(TokenList) {
+        return parse(input, options, 0);
+    }
+
+    pub fn parseRaw(
+        input: *css.Parser,
+        tokens: *ArrayList(TokenOrValue),
+        options: *const css.ParserOptions,
+        depth: usize,
+    ) Result(void) {
+        if (depth > 500) {
+            return .{ .err = input.newCustomError(css.ParserError.maximum_nesting_depth) };
+        }
+
+        while (true) {
+            const state = input.state();
+            const token = switch (input.nextIncludingWhitespace()) {
+                .result => |vv| vv,
+                .err => break,
+            };
+            switch (token.*) {
+                .open_paren, .open_square, .open_curly => {
+                    tokens.append(
+                        input.allocator(),
+                        .{ .token = token.* },
+                    ) catch unreachable;
+                    const closing_delimiter: css.Token = switch (token.*) {
+                        .open_paren => .close_paren,
+                        .open_square => .close_square,
+                        .open_curly => .close_curly,
+                        else => unreachable,
+                    };
+                    const Closure = struct {
+                        options: *const css.ParserOptions,
+                        depth: usize,
+                        tokens: *ArrayList(TokenOrValue),
+                        pub fn parsefn(this: *@This(), input2: *css.Parser) Result(void) {
+                            return TokenListFns.parseRaw(
+                                input2,
+                                this.tokens,
+                                this.options,
+                                this.depth + 1,
+                            );
+                        }
+                    };
+                    var closure = Closure{
+                        .options = options,
+                        .depth = depth,
+                        .tokens = tokens,
+                    };
+                    if (input.parseNestedBlock(void, &closure, Closure.parsefn).asErr()) |e| return .{ .err = e };
+                    tokens.append(
+                        input.allocator(),
+                        .{ .token = closing_delimiter },
+                    ) catch unreachable;
+                },
+                .function => {
+                    tokens.append(
+                        input.allocator(),
+                        .{ .token = token.* },
+                    ) catch unreachable;
+                    const Closure = struct {
+                        options: *const css.ParserOptions,
+                        depth: usize,
+                        tokens: *ArrayList(TokenOrValue),
+                        pub fn parsefn(this: *@This(), input2: *css.Parser) Result(void) {
+                            return TokenListFns.parseRaw(
+                                input2,
+                                this.tokens,
+                                this.options,
+                                this.depth + 1,
+                            );
+                        }
+                    };
+                    var closure = Closure{
+                        .options = options,
+                        .depth = depth,
+                        .tokens = tokens,
+                    };
+                    if (input.parseNestedBlock(void, &closure, Closure.parsefn).asErr()) |e| return .{ .err = e };
+                    tokens.append(
+                        input.allocator(),
+                        .{ .token = .close_paren },
+                    ) catch unreachable;
+                },
+                else => {
+                    if (token.isParseError()) {
+                        return .{
+                            .err = css.ParseError(css.ParserError){
+                                .kind = .{ .basic = .{ .unexpected_token = token.* } },
+                                .location = state.sourceLocation(),
+                            },
+                        };
+                    }
+                    tokens.append(
+                        input.allocator(),
+                        .{ .token = token.* },
+                    ) catch unreachable;
+                },
+            }
+        }
+
+        return .{ .result = {} };
+    }
+
+    pub fn parseInto(
+        input: *css.Parser,
+        tokens: *ArrayList(TokenOrValue),
+        options: *const css.ParserOptions,
+        depth: usize,
+    ) Result(void) {
+        if (depth > 500) {
+            return .{ .err = input.newCustomError(css.ParserError.maximum_nesting_depth) };
+        }
+
+        var last_is_delim = false;
+        var last_is_whitespace = false;
+
+        while (true) {
+            const state = input.state();
+            const tok = switch (input.nextIncludingWhitespace()) {
+                .result => |vv| vv,
+                .err => break,
+            };
+            switch (tok.*) {
+                .whitespace, .comment => {
+                    // Skip whitespace if the last token was a delimiter.
+                    // Otherwise, replace all whitespace and comments with a single space character.
+                    if (!last_is_delim) {
+                        tokens.append(
+                            input.allocator(),
+                            .{ .token = .{ .whitespace = " " } },
+                        ) catch unreachable;
+                        last_is_whitespace = true;
+                    }
+                    continue;
+                },
+                .function => |f| {
+                    // Attempt to parse embedded color values into hex tokens.
+                    if (tryParseColorToken(f, &state, input)) |color| {
+                        tokens.append(
+                            input.allocator(),
+                            .{ .color = color },
+                        ) catch unreachable;
+                        last_is_delim = false;
+                        last_is_whitespace = true;
+                    } else if (input.tryParse(UnresolvedColor.parse, .{ f, options }).asValue()) |color| {
+                        tokens.append(
+                            input.allocator(),
+                            .{ .unresolved_color = color },
+                        ) catch unreachable;
+                        last_is_delim = false;
+                        last_is_whitespace = true;
+                    } else if (bun.strings.eql(f, "url")) {
+                        input.reset(&state);
+                        tokens.append(
+                            input.allocator(),
+                            .{ .url = switch (Url.parse(input)) {
+                                .result => |vv| vv,
+                                .err => |e| return .{ .err = e },
+                            } },
+                        ) catch unreachable;
+                        last_is_delim = false;
+                        last_is_whitespace = false;
+                    } else if (bun.strings.eql(f, "var")) {
+                        const Closure = struct {
+                            options: *const css.ParserOptions,
+                            depth: usize,
+                            tokens: *ArrayList(TokenOrValue),
+                            pub fn parsefn(this: *@This(), input2: *css.Parser) Result(TokenOrValue) {
+                                const thevar = switch (Variable.parse(input2, this.options, this.depth + 1)) {
+                                    .result => |vv| vv,
+                                    .err => |e| return .{ .err = e },
+                                };
+                                return .{ .result = TokenOrValue{ .@"var" = thevar } };
+                            }
+                        };
+                        var closure = Closure{
+                            .options = options,
+                            .depth = depth,
+                            .tokens = tokens,
+                        };
+                        const @"var" = switch (input.parseNestedBlock(TokenOrValue, &closure, Closure.parsefn)) {
+                            .result => |vv| vv,
+                            .err => |e| return .{ .err = e },
+                        };
+                        tokens.append(
+                            input.allocator(),
+                            @"var",
+                        ) catch unreachable;
+                        last_is_delim = true;
+                        last_is_whitespace = false;
+                    } else if (bun.strings.eql(f, "env")) {
+                        const Closure = struct {
+                            options: *const css.ParserOptions,
+                            depth: usize,
+                            pub fn parsefn(this: *@This(), input2: *css.Parser) Result(TokenOrValue) {
+                                const env = switch (EnvironmentVariable.parseNested(input2, this.options, this.depth + 1)) {
+                                    .result => |vv| vv,
+                                    .err => |e| return .{ .err = e },
+                                };
+                                return .{ .result = TokenOrValue{ .env = env } };
+                            }
+                        };
+                        var closure = Closure{
+                            .options = options,
+                            .depth = depth,
+                        };
+                        const env = switch (input.parseNestedBlock(TokenOrValue, &closure, Closure.parsefn)) {
+                            .result => |vv| vv,
+                            .err => |e| return .{ .err = e },
+                        };
+                        tokens.append(
+                            input.allocator(),
+                            env,
+                        ) catch unreachable;
+                        last_is_delim = true;
+                        last_is_whitespace = false;
+                    } else {
+                        const Closure = struct {
+                            options: *const css.ParserOptions,
+                            depth: usize,
+                            pub fn parsefn(this: *@This(), input2: *css.Parser) Result(TokenList) {
+                                const args = switch (TokenListFns.parse(input2, this.options, this.depth + 1)) {
+                                    .result => |vv| vv,
+                                    .err => |e| return .{ .err = e },
+                                };
+                                return .{ .result = args };
+                            }
+                        };
+                        var closure = Closure{
+                            .options = options,
+                            .depth = depth,
+                        };
+                        const arguments = switch (input.parseNestedBlock(TokenList, &closure, Closure.parsefn)) {
+                            .result => |vv| vv,
+                            .err => |e| return .{ .err = e },
+                        };
+                        tokens.append(
+                            input.allocator(),
+                            .{
+                                .function = .{
+                                    .name = .{ .v = f },
+                                    .arguments = arguments,
+                                },
+                            },
+                        ) catch unreachable;
+                        last_is_delim = true; // Whitespace is not required after any of these chars.
+                        last_is_whitespace = false;
+                    }
+                    continue;
+                },
+                .hash, .idhash => {
+                    const h = switch (tok.*) {
+                        .hash => |h| h,
+                        .idhash => |h| h,
+                        else => unreachable,
+                    };
+                    brk: {
+                        const r, const g, const b, const a = css.color.parseHashColor(h) orelse {
+                            tokens.append(
+                                input.allocator(),
+                                .{ .token = .{ .hash = h } },
+                            ) catch unreachable;
+                            break :brk;
+                        };
+                        tokens.append(
+                            input.allocator(),
+                            .{
+                                .color = CssColor{ .rgba = RGBA.new(r, g, b, a) },
+                            },
+                        ) catch unreachable;
+                    }
+                    last_is_delim = false;
+                    last_is_whitespace = false;
+                    continue;
+                },
+                .unquoted_url => {
+                    input.reset(&state);
+                    tokens.append(
+                        input.allocator(),
+                        .{ .url = switch (Url.parse(input)) {
+                            .result => |vv| vv,
+                            .err => |e| return .{ .err = e },
+                        } },
+                    ) catch unreachable;
+                    last_is_delim = false;
+                    last_is_whitespace = false;
+                    continue;
+                },
+                .ident => |name| {
+                    if (bun.strings.startsWith(name, "--")) {
+                        tokens.append(input.allocator(), .{ .dashed_ident = .{ .v = name } }) catch unreachable;
+                        last_is_delim = false;
+                        last_is_whitespace = false;
+                        continue;
+                    }
+                },
+                .open_paren, .open_square, .open_curly => {
+                    tokens.append(
+                        input.allocator(),
+                        .{ .token = tok.* },
+                    ) catch unreachable;
+                    const closing_delimiter: css.Token = switch (tok.*) {
+                        .open_paren => .close_paren,
+                        .open_square => .close_square,
+                        .open_curly => .close_curly,
+                        else => unreachable,
+                    };
+                    const Closure = struct {
+                        options: *const css.ParserOptions,
+                        depth: usize,
+                        tokens: *ArrayList(TokenOrValue),
+                        pub fn parsefn(this: *@This(), input2: *css.Parser) Result(void) {
+                            return TokenListFns.parseInto(
+                                input2,
+                                this.tokens,
+                                this.options,
+                                this.depth + 1,
+                            );
+                        }
+                    };
+                    var closure = Closure{
+                        .options = options,
+                        .depth = depth,
+                        .tokens = tokens,
+                    };
+                    if (input.parseNestedBlock(void, &closure, Closure.parsefn).asErr()) |e| return .{ .err = e };
+                    tokens.append(
+                        input.allocator(),
+                        .{ .token = closing_delimiter },
+                    ) catch unreachable;
+                    last_is_delim = true; // Whitespace is not required after any of these chars.
+                    last_is_whitespace = false;
+                    continue;
+                },
+                .dimension => {
+                    const value = if (LengthValue.tryFromToken(tok).asValue()) |length|
+                        TokenOrValue{ .length = length }
+                    else if (Angle.tryFromToken(tok).asValue()) |angle|
+                        TokenOrValue{ .angle = angle }
+                    else if (Time.tryFromToken(tok).asValue()) |time|
+                        TokenOrValue{ .time = time }
+                    else if (Resolution.tryFromToken(tok).asValue()) |resolution|
+                        TokenOrValue{ .resolution = resolution }
+                    else
+                        TokenOrValue{ .token = tok.* };
+
+                    tokens.append(
+                        input.allocator(),
+                        value,
+                    ) catch unreachable;
+
+                    last_is_delim = false;
+                    last_is_whitespace = false;
+                    continue;
+                },
+                else => {},
+            }
+
+            if (tok.isParseError()) {
+                return .{
+                    .err = .{
+                        .kind = .{ .basic = .{ .unexpected_token = tok.* } },
+                        .location = state.sourceLocation(),
+                    },
+                };
+            }
+            last_is_delim = switch (tok.*) {
+                .delim, .comma => true,
+                else => false,
+            };
+
+            // If this is a delimiter, and the last token was whitespace,
+            // replace the whitespace with the delimiter since both are not required.
+            if (last_is_delim and last_is_whitespace) {
+                const last = &tokens.items[tokens.items.len - 1];
+                last.* = .{ .token = tok.* };
+            } else {
+                tokens.append(
+                    input.allocator(),
+                    .{ .token = tok.* },
+                ) catch unreachable;
+            }
+
+            last_is_whitespace = false;
+        }
+
+        return .{ .result = {} };
+    }
+
+    pub fn getFallback(this: *const TokenList, allocator: Allocator, kind: ColorFallbackKind) @This() {
+        var tokens = TokenList{};
+        tokens.v.ensureTotalCapacity(allocator, this.v.items.len) catch bun.outOfMemory();
+        for (this.v.items, tokens.v.items[0..this.v.items.len]) |*old, *new| {
+            new.* = switch (old.*) {
+                .color => |*color| TokenOrValue{ .color = color.getFallback(allocator, kind) },
+                .function => |*f| TokenOrValue{ .function = f.getFallback(allocator, kind) },
+                .@"var" => |*v| TokenOrValue{ .@"var" = v.getFallback(allocator, kind) },
+                .env => |*e| TokenOrValue{ .env = e.getFallback(allocator, kind) },
+                else => old.deepClone(allocator),
+            };
+        }
+        tokens.v.items.len = this.v.items.len;
+        return tokens;
+    }
+
+    pub const Fallbacks = struct { SupportsCondition, TokenList };
+    pub fn getFallbacks(this: *const TokenList, allocator: Allocator, targets: css.targets.Targets) css.SmallList(Fallbacks, 2) {
+        // Get the full list of possible fallbacks, and remove the lowest one, which will replace
+        // the original declaration. The remaining fallbacks need to be added as @supports rules.
+        var fallbacks = this.getNecessaryFallbacks(targets);
+        const lowest_fallback = fallbacks.lowest();
+        fallbacks.remove(lowest_fallback);
+
+        var res = css.SmallList(Fallbacks, 2){};
+        if (fallbacks.contains(ColorFallbackKind.P3)) {
+            res.appendAssumeCapacity(.{
+                ColorFallbackKind.P3.supportsCondition(),
+                this.getFallback(allocator, ColorFallbackKind.P3),
+            });
+        }
+
+        if (fallbacks.contains(ColorFallbackKind.LAB)) {
+            res.appendAssumeCapacity(.{
+                ColorFallbackKind.LAB.supportsCondition(),
+                this.getFallback(allocator, ColorFallbackKind.LAB),
+            });
+        }
+
+        if (!lowest_fallback.isEmpty()) {
+            for (this.v.items) |*token_or_value| {
+                switch (token_or_value.*) {
+                    .color => |*color| {
+                        color.* = color.getFallback(allocator, lowest_fallback);
+                    },
+                    .function => |*f| {
+                        f.* = f.getFallback(allocator, lowest_fallback);
+                    },
+                    .@"var" => |*v| {
+                        if (v.fallback) |*fallback| {
+                            fallback.* = fallback.getFallback(allocator, lowest_fallback);
+                        }
+                    },
+                    .env => |*v| {
+                        if (v.fallback) |*fallback| {
+                            fallback.* = fallback.getFallback(allocator, lowest_fallback);
+                        }
+                    },
+                    else => {},
+                }
+            }
+        }
+
+        return res;
+    }
+
+    pub fn getNecessaryFallbacks(this: *const TokenList, targets: css.targets.Targets) ColorFallbackKind {
+        var fallbacks = ColorFallbackKind.empty();
+        for (this.v.items) |*token_or_value| {
+            switch (token_or_value.*) {
+                .color => |*color| {
+                    fallbacks.insert(color.getPossibleFallbacks(targets));
+                },
+                .function => |*f| {
+                    fallbacks.insert(f.arguments.getNecessaryFallbacks(targets));
+                },
+                .@"var" => |*v| {
+                    if (v.fallback) |*fallback| {
+                        fallbacks.insert(fallback.getNecessaryFallbacks(targets));
+                    }
+                },
+                .env => |*v| {
+                    if (v.fallback) |*fallback| {
+                        fallbacks.insert(fallback.getNecessaryFallbacks(targets));
+                    }
+                },
+                else => {},
+            }
+        }
+
+        return fallbacks;
+    }
+
+    pub fn eql(lhs: *const TokenList, rhs: *const TokenList) bool {
+        return css.generic.eqlList(TokenOrValue, &lhs.v, &rhs.v);
+    }
+
+    pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+        return css.implementHash(@This(), this, hasher);
+    }
+
+    pub fn deepClone(this: *const TokenList, allocator: Allocator) TokenList {
+        return .{
+            .v = css.deepClone(TokenOrValue, allocator, &this.v),
+        };
+    }
+};
+pub const TokenListFns = TokenList;
+
+/// A color value with an unresolved alpha value (e.g. a variable).
+/// These can be converted from the modern slash syntax to older comma syntax.
+/// This can only be done when the only unresolved component is the alpha
+/// since variables can resolve to multiple tokens.
+pub const UnresolvedColor = union(enum) {
+    /// An rgb() color.
+    RGB: struct {
+        /// The red component.
+        r: f32,
+        /// The green component.
+        g: f32,
+        /// The blue component.
+        b: f32,
+        /// The unresolved alpha component.
+        alpha: TokenList,
+        pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+            return css.implementEql(@This(), lhs, rhs);
+        }
+        pub fn __generateHash() void {}
+    },
+    /// An hsl() color.
+    HSL: struct {
+        /// The hue component.
+        h: f32,
+        /// The saturation component.
+        s: f32,
+        /// The lightness component.
+        l: f32,
+        /// The unresolved alpha component.
+        alpha: TokenList,
+        pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+            return css.implementEql(@This(), lhs, rhs);
+        }
+        pub fn __generateHash() void {}
+    },
+    /// The light-dark() function.
+    light_dark: struct {
+        /// The light value.
+        light: TokenList,
+        /// The dark value.
+        dark: TokenList,
+
+        pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+            return css.implementEql(@This(), lhs, rhs);
+        }
+
+        pub fn __generateHash() void {}
+    },
+    const This = @This();
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+        return css.implementHash(@This(), this, hasher);
+    }
+
+    pub fn deepClone(this: *const This, allocator: Allocator) This {
+        return switch (this.*) {
+            .RGB => |*rgb| .{ .RGB = .{ .r = rgb.r, .g = rgb.g, .b = rgb.b, .alpha = rgb.alpha.deepClone(allocator) } },
+            .HSL => |*hsl| .{ .HSL = .{ .h = hsl.h, .s = hsl.s, .l = hsl.l, .alpha = hsl.alpha.deepClone(allocator) } },
+            .light_dark => |*light_dark| .{
+                .light_dark = .{
+                    .light = light_dark.light.deepClone(allocator),
+                    .dark = light_dark.dark.deepClone(allocator),
+                },
+            },
+        };
+    }
+
+    pub fn deinit(this: *This, allocator: Allocator) void {
+        return switch (this.*) {
+            .RGB => |*rgb| rgb.alpha.deinit(allocator),
+            .HSL => |*hsl| hsl.alpha.deinit(allocator),
+            .light_dark => |*light_dark| {
+                light_dark.light.deinit(allocator);
+                light_dark.dark.deinit(allocator);
+            },
+        };
+    }
+
+    pub fn toCss(
+        this: *const This,
+        comptime W: type,
+        dest: *Printer(W),
+        is_custom_property: bool,
+    ) PrintErr!void {
+        const Helper = struct {
+            pub fn conv(c: f32) i32 {
+                return @intFromFloat(bun.clamp(@round(c * 255.0), 0.0, 255.0));
+            }
+        };
+
+        switch (this.*) {
+            .RGB => |rgb| {
+                if (dest.targets.shouldCompileSame(.space_separated_color_notation)) {
+                    try dest.writeStr("rgba(");
+                    try css.to_css.integer(i32, Helper.conv(rgb.r), W, dest);
+                    try dest.delim(',', false);
+                    try css.to_css.integer(i32, Helper.conv(rgb.g), W, dest);
+                    try dest.delim(',', false);
+                    try css.to_css.integer(i32, Helper.conv(rgb.b), W, dest);
+                    try rgb.alpha.toCss(W, dest, is_custom_property);
+                    try dest.writeChar(')');
+                    return;
+                }
+
+                try dest.writeStr("rgb(");
+                try css.to_css.integer(i32, Helper.conv(rgb.r), W, dest);
+                try dest.writeChar(' ');
+                try css.to_css.integer(i32, Helper.conv(rgb.g), W, dest);
+                try dest.writeChar(' ');
+                try css.to_css.integer(i32, Helper.conv(rgb.b), W, dest);
+                try dest.delim('/', true);
+                try rgb.alpha.toCss(W, dest, is_custom_property);
+                try dest.writeChar(')');
+            },
+            .HSL => |hsl| {
+                if (dest.targets.shouldCompileSame(.space_separated_color_notation)) {
+                    try dest.writeStr("hsla(");
+                    try CSSNumberFns.toCss(&hsl.h, W, dest);
+                    try dest.delim(',', false);
+                    try (Percentage{ .v = hsl.s }).toCss(W, dest);
+                    try dest.delim(',', false);
+                    try (Percentage{ .v = hsl.l }).toCss(W, dest);
+                    try dest.delim(',', false);
+                    try hsl.alpha.toCss(W, dest, is_custom_property);
+                    try dest.writeChar(')');
+                    return;
+                }
+
+                try dest.writeStr("hsl(");
+                try CSSNumberFns.toCss(&hsl.h, W, dest);
+                try dest.writeChar(' ');
+                try (Percentage{ .v = hsl.s }).toCss(W, dest);
+                try dest.writeChar(' ');
+                try (Percentage{ .v = hsl.l }).toCss(W, dest);
+                try dest.delim('/', true);
+                try hsl.alpha.toCss(W, dest, is_custom_property);
+                try dest.writeChar(')');
+                return;
+            },
+            .light_dark => |*ld| {
+                const light: *const TokenList = &ld.light;
+                const dark: *const TokenList = &ld.dark;
+
+                if (!dest.targets.isCompatible(.light_dark)) {
+                    // TODO(zack): lightningcss -> buncss
+                    try dest.writeStr("var(--lightningcss-light)");
+                    try dest.delim(',', false);
+                    try light.toCss(W, dest, is_custom_property);
+                    try dest.writeChar(')');
+                    try dest.whitespace();
+                    try dest.writeStr("var(--lightningcss-dark");
+                    try dest.delim(',', false);
+                    try dark.toCss(W, dest, is_custom_property);
+                    return dest.writeChar(')');
+                }
+
+                try dest.writeStr("light-dark(");
+                try light.toCss(W, dest, is_custom_property);
+                try dest.delim(',', false);
+                try dark.toCss(W, dest, is_custom_property);
+                try dest.writeChar(')');
+            },
+        }
+    }
+
+    pub fn parse(
+        input: *css.Parser,
+        f: []const u8,
+        options: *const css.ParserOptions,
+    ) Result(UnresolvedColor) {
+        var parser = ComponentParser.new(false);
+        // css.todo_stuff.match_ignore_ascii_case
+        if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(f, "rgb")) {
+            const Closure = struct {
+                options: *const css.ParserOptions,
+                parser: *ComponentParser,
+                pub fn parsefn(this: *@This(), input2: *css.Parser) Result(UnresolvedColor) {
+                    return this.parser.parseRelative(input2, SRGB, UnresolvedColor, @This().innerParseFn, .{this.options});
+                }
+                pub fn innerParseFn(i: *css.Parser, p: *ComponentParser, opts: *const css.ParserOptions) Result(UnresolvedColor) {
+                    const r, const g, const b, const is_legacy = switch (css.css_values.color.parseRGBComponents(i, p)) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    };
+                    if (is_legacy) {
+                        return .{ .err = i.newCustomError(css.ParserError.invalid_value) };
+                    }
+                    if (i.expectDelim('/').asErr()) |e| return .{ .err = e };
+                    const alpha = switch (TokenListFns.parse(i, opts, 0)) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    };
+                    return .{ .result = UnresolvedColor{
+                        .RGB = .{
+                            .r = r,
+                            .g = g,
+                            .b = b,
+                            .alpha = alpha,
+                        },
+                    } };
+                }
+            };
+            var closure = Closure{
+                .options = options,
+                .parser = &parser,
+            };
+            return input.parseNestedBlock(UnresolvedColor, &closure, Closure.parsefn);
+        } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(f, "hsl")) {
+            const Closure = struct {
+                options: *const css.ParserOptions,
+                parser: *ComponentParser,
+                pub fn parsefn(this: *@This(), input2: *css.Parser) Result(UnresolvedColor) {
+                    return this.parser.parseRelative(input2, HSL, UnresolvedColor, @This().innerParseFn, .{this.options});
+                }
+                pub fn innerParseFn(i: *css.Parser, p: *ComponentParser, opts: *const css.ParserOptions) Result(UnresolvedColor) {
+                    const h, const s, const l, const is_legacy = switch (css.css_values.color.parseHSLHWBComponents(HSL, i, p, false)) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    };
+                    if (is_legacy) {
+                        return .{ .err = i.newCustomError(css.ParserError.invalid_value) };
+                    }
+                    if (i.expectDelim('/').asErr()) |e| return .{ .err = e };
+                    const alpha = switch (TokenListFns.parse(i, opts, 0)) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    };
+                    return .{ .result = UnresolvedColor{
+                        .HSL = .{
+                            .h = h,
+                            .s = s,
+                            .l = l,
+                            .alpha = alpha,
+                        },
+                    } };
+                }
+            };
+            var closure = Closure{
+                .options = options,
+                .parser = &parser,
+            };
+            return input.parseNestedBlock(UnresolvedColor, &closure, Closure.parsefn);
+        } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(f, "light-dark")) {
+            const Closure = struct {
+                options: *const css.ParserOptions,
+                parser: *ComponentParser,
+                pub fn parsefn(this: *@This(), input2: *css.Parser) Result(UnresolvedColor) {
+                    const light = switch (input2.parseUntilBefore(css.Delimiters{ .comma = true }, TokenList, this, @This().parsefn2)) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    };
+                    // TODO: fix this
+                    errdefer light.deinit();
+                    if (input2.expectComma().asErr()) |e| return .{ .err = e };
+                    const dark = switch (TokenListFns.parse(input2, this.options, 0)) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    };
+                    // TODO: fix this
+                    errdefer dark.deinit();
+                    return .{ .result = UnresolvedColor{
+                        .light_dark = .{
+                            .light = light,
+                            .dark = dark,
+                        },
+                    } };
+                }
+
+                pub fn parsefn2(this: *@This(), input2: *css.Parser) Result(TokenList) {
+                    return TokenListFns.parse(input2, this.options, 1);
+                }
+            };
+            var closure = Closure{
+                .options = options,
+                .parser = &parser,
+            };
+            return input.parseNestedBlock(UnresolvedColor, &closure, Closure.parsefn);
+        } else {
+            return .{ .err = input.newCustomError(css.ParserError.invalid_value) };
+        }
+    }
+
+    pub fn lightDarkOwned(allocator: Allocator, light: UnresolvedColor, dark: UnresolvedColor) UnresolvedColor {
+        var lightlist = ArrayList(TokenOrValue).initCapacity(allocator, 1) catch bun.outOfMemory();
+        lightlist.append(allocator, TokenOrValue{ .unresolved_color = light }) catch bun.outOfMemory();
+        var darklist = ArrayList(TokenOrValue).initCapacity(allocator, 1) catch bun.outOfMemory();
+        darklist.append(allocator, TokenOrValue{ .unresolved_color = dark }) catch bun.outOfMemory();
+        return UnresolvedColor{
+            .light_dark = .{
+                .light = css.TokenList{ .v = lightlist },
+                .dark = css.TokenList{ .v = darklist },
+            },
+        };
+    }
+};
+
+/// A CSS variable reference.
+pub const Variable = struct {
+    /// The variable name.
+    name: DashedIdentReference,
+    /// A fallback value in case the variable is not defined.
+    fallback: ?TokenList,
+
+    const This = @This();
+
+    pub fn deinit(this: *Variable, allocator: Allocator) void {
+        if (this.fallback) |*fallback| {
+            fallback.deinit(allocator);
+        }
+    }
+
+    pub fn parse(
+        input: *css.Parser,
+        options: *const css.ParserOptions,
+        depth: usize,
+    ) Result(This) {
+        const name = switch (DashedIdentReference.parseWithOptions(input, options)) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+
+        const fallback = if (input.tryParse(css.Parser.expectComma, .{}).isOk())
+            switch (TokenList.parse(input, options, depth)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            }
+        else
+            null;
+
+        return .{ .result = Variable{ .name = name, .fallback = fallback } };
+    }
+
+    pub fn toCss(
+        this: *const This,
+        comptime W: type,
+        dest: *Printer(W),
+        is_custom_property: bool,
+    ) PrintErr!void {
+        try dest.writeStr("var(");
+        try this.name.toCss(W, dest);
+        if (this.fallback) |*fallback| {
+            try dest.delim(',', false);
+            try fallback.toCss(W, dest, is_custom_property);
+        }
+        return try dest.writeChar(')');
+    }
+
+    pub fn getFallback(this: *const Variable, allocator: Allocator, kind: ColorFallbackKind) @This() {
+        return Variable{
+            .name = this.name,
+            .fallback = if (this.fallback) |*fallback| fallback.getFallback(allocator, kind) else null,
+        };
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+        return css.implementHash(@This(), this, hasher);
+    }
+
+    pub fn deepClone(this: *const Variable, allocator: Allocator) Variable {
+        return .{
+            .name = this.name,
+            .fallback = if (this.fallback) |*fallback| fallback.deepClone(allocator) else null,
+        };
+    }
+};
+
+/// A CSS environment variable reference.
+pub const EnvironmentVariable = struct {
+    /// The environment variable name.
+    name: EnvironmentVariableName,
+    /// Optional indices into the dimensions of the environment variable.
+    /// TODO(zack): this could totally be a smallvec, why isn't it?
+    indices: ArrayList(CSSInteger) = ArrayList(CSSInteger){},
+    /// A fallback value in case the variable is not defined.
+    fallback: ?TokenList,
+
+    pub fn deinit(this: *EnvironmentVariable, allocator: Allocator) void {
+        this.indices.deinit(allocator);
+        if (this.fallback) |*fallback| {
+            fallback.deinit(allocator);
+        }
+    }
+
+    pub fn parse(input: *css.Parser, options: *const css.ParserOptions, depth: usize) Result(EnvironmentVariable) {
+        if (input.expectFunctionMatching("env").asErr()) |e| return .{ .err = e };
+        const Closure = struct {
+            options: *const css.ParserOptions,
+            depth: usize,
+            pub fn parsefn(this: *@This(), i: *css.Parser) Result(EnvironmentVariable) {
+                return EnvironmentVariable.parseNested(i, this.options, this.depth);
+            }
+        };
+        var closure = Closure{
+            .options = options,
+            .depth = depth,
+        };
+        return input.parseNestedBlock(EnvironmentVariable, &closure, Closure.parsefn);
+    }
+
+    pub fn parseNested(input: *css.Parser, options: *const css.ParserOptions, depth: usize) Result(EnvironmentVariable) {
+        const name = switch (EnvironmentVariableName.parse(input)) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+        var indices = ArrayList(i32){};
+        while (switch (input.tryParse(CSSIntegerFns.parse, .{})) {
+            .result => |v| v,
+            .err => null,
+        }) |idx| {
+            indices.append(
+                input.allocator(),
+                idx,
+            ) catch unreachable;
+        }
+
+        const fallback = if (input.tryParse(css.Parser.expectComma, .{}).isOk())
+            switch (TokenListFns.parse(input, options, depth + 1)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            }
+        else
+            null;
+
+        return .{ .result = EnvironmentVariable{
+            .name = name,
+            .indices = indices,
+            .fallback = fallback,
+        } };
+    }
+
+    pub fn toCss(
+        this: *const EnvironmentVariable,
+        comptime W: type,
+        dest: *Printer(W),
+        is_custom_property: bool,
+    ) PrintErr!void {
+        try dest.writeStr("env(");
+        try this.name.toCss(W, dest);
+
+        for (this.indices.items) |index| {
+            try dest.writeChar(' ');
+            try css.to_css.integer(i32, index, W, dest);
+        }
+
+        if (this.fallback) |*fallback| {
+            try dest.delim(',', false);
+            try fallback.toCss(W, dest, is_custom_property);
+        }
+
+        return try dest.writeChar(')');
+    }
+
+    pub fn getFallback(this: *const EnvironmentVariable, allocator: Allocator, kind: ColorFallbackKind) @This() {
+        return EnvironmentVariable{
+            .name = this.name,
+            .indices = this.indices.clone(allocator) catch bun.outOfMemory(),
+            .fallback = if (this.fallback) |*fallback| fallback.getFallback(allocator, kind) else null,
+        };
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+        return css.implementHash(@This(), this, hasher);
+    }
+
+    pub fn deepClone(this: *const EnvironmentVariable, allocator: Allocator) EnvironmentVariable {
+        return .{
+            .name = this.name,
+            .indices = this.indices.clone(allocator) catch bun.outOfMemory(),
+            .fallback = if (this.fallback) |*fallback| fallback.deepClone(allocator) else null,
+        };
+    }
+};
+
+/// A CSS environment variable name.
+pub const EnvironmentVariableName = union(enum) {
+    /// A UA-defined environment variable.
+    ua: UAEnvironmentVariable,
+    /// A custom author-defined environment variable.
+    custom: DashedIdentReference,
+    /// An unknown environment variable.
+    unknown: CustomIdent,
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+    pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+        return css.implementHash(@This(), this, hasher);
+    }
+
+    pub fn parse(input: *css.Parser) Result(EnvironmentVariableName) {
+        if (input.tryParse(UAEnvironmentVariable.parse, .{}).asValue()) |ua| {
+            return .{ .result = .{ .ua = ua } };
+        }
+
+        if (input.tryParse(DashedIdentReference.parseWithOptions, .{
+            &css.ParserOptions.default(
+                input.allocator(),
+                null,
+            ),
+        }).asValue()) |dashed| {
+            return .{ .result = .{ .custom = dashed } };
+        }
+
+        const ident = switch (CustomIdentFns.parse(input)) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+        return .{ .result = .{ .unknown = ident } };
+    }
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+        return switch (this.*) {
+            .ua => |ua| ua.toCss(W, dest),
+            .custom => |custom| custom.toCss(W, dest),
+            .unknown => |unknown| CustomIdentFns.toCss(&unknown, W, dest),
+        };
+    }
+};
+
+/// A UA-defined environment variable name.
+pub const UAEnvironmentVariable = enum {
+    /// The safe area inset from the top of the viewport.
+    @"safe-area-inset-top",
+    /// The safe area inset from the right of the viewport.
+    @"safe-area-inset-right",
+    /// The safe area inset from the bottom of the viewport.
+    @"safe-area-inset-bottom",
+    /// The safe area inset from the left of the viewport.
+    @"safe-area-inset-left",
+    /// The viewport segment width.
+    @"viewport-segment-width",
+    /// The viewport segment height.
+    @"viewport-segment-height",
+    /// The viewport segment top position.
+    @"viewport-segment-top",
+    /// The viewport segment left position.
+    @"viewport-segment-left",
+    /// The viewport segment bottom position.
+    @"viewport-segment-bottom",
+    /// The viewport segment right position.
+    @"viewport-segment-right",
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+/// A custom CSS function.
+pub const Function = struct {
+    /// The function name.
+    name: Ident,
+    /// The function arguments.
+    arguments: TokenList,
+
+    const This = @This();
+
+    pub fn deinit(this: *Function, allocator: Allocator) void {
+        this.arguments.deinit(allocator);
+    }
+
+    pub fn toCss(
+        this: *const This,
+        comptime W: type,
+        dest: *Printer(W),
+        is_custom_property: bool,
+    ) PrintErr!void {
+        try IdentFns.toCss(&this.name, W, dest);
+        try dest.writeChar('(');
+        try this.arguments.toCss(W, dest, is_custom_property);
+        return try dest.writeChar(')');
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+        return css.implementHash(@This(), this, hasher);
+    }
+
+    pub fn deepClone(this: *const Function, allocator: Allocator) Function {
+        return .{
+            .name = this.name,
+            .arguments = this.arguments.deepClone(allocator),
+        };
+    }
+
+    pub fn getFallback(this: *const Function, allocator: Allocator, kind: ColorFallbackKind) @This() {
+        return Function{
+            .name = this.name.deepClone(allocator),
+            .arguments = this.arguments.getFallback(allocator, kind),
+        };
+    }
+};
+
+/// A raw CSS token, or a parsed value.
+pub const TokenOrValue = union(enum) {
+    /// A token.
+    token: css.Token,
+    /// A parsed CSS color.
+    color: CssColor,
+    /// A color with unresolved components.
+    unresolved_color: UnresolvedColor,
+    /// A parsed CSS url.
+    url: Url,
+    /// A CSS variable reference.
+    @"var": Variable,
+    /// A CSS environment variable reference.
+    env: EnvironmentVariable,
+    /// A custom CSS function.
+    function: Function,
+    /// A length.
+    length: LengthValue,
+    /// An angle.
+    angle: Angle,
+    /// A time.
+    time: Time,
+    /// A resolution.
+    resolution: Resolution,
+    /// A dashed ident.
+    dashed_ident: DashedIdent,
+    /// An animation name.
+    animation_name: AnimationName,
+
+    pub fn eql(lhs: *const TokenOrValue, rhs: *const TokenOrValue) bool {
+        return css.implementEql(TokenOrValue, lhs, rhs);
+    }
+
+    pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+        return css.implementHash(@This(), this, hasher);
+    }
+
+    pub fn deepClone(this: *const TokenOrValue, allocator: Allocator) TokenOrValue {
+        return switch (this.*) {
+            .token => this.*,
+            .color => |*color| .{ .color = color.deepClone(allocator) },
+            .unresolved_color => |*color| .{ .unresolved_color = color.deepClone(allocator) },
+            .url => this.*,
+            .@"var" => |*@"var"| .{ .@"var" = @"var".deepClone(allocator) },
+            .env => |*env| .{ .env = env.deepClone(allocator) },
+            .function => |*f| .{ .function = f.deepClone(allocator) },
+            .length => this.*,
+            .angle => this.*,
+            .time => this.*,
+            .resolution => this.*,
+            .dashed_ident => this.*,
+            .animation_name => this.*,
+        };
+    }
+
+    pub fn deinit(this: *TokenOrValue, allocator: Allocator) void {
+        return switch (this.*) {
+            .token => {},
+            .color => |*color| color.deinit(allocator),
+            .unresolved_color => |*color| color.deinit(allocator),
+            .url => {},
+            .@"var" => |*@"var"| @"var".deinit(allocator),
+            .env => |*env| env.deinit(allocator),
+            .function => |*f| f.deinit(allocator),
+            .length => {},
+            .angle => {},
+            .time => {},
+            .resolution => {},
+            .dashed_ident => {},
+            .animation_name => {},
+        };
+    }
+
+    pub fn isWhitespace(self: *const TokenOrValue) bool {
+        switch (self.*) {
+            .token => |tok| return tok == .whitespace,
+            else => return false,
+        }
+    }
+};
+
+/// A known property with an unparsed value.
+///
+/// This type is used when the value of a known property could not
+/// be parsed, e.g. in the case css `var()` references are encountered.
+/// In this case, the raw tokens are stored instead.
+pub const UnparsedProperty = struct {
+    /// The id of the property.
+    property_id: css.PropertyId,
+    /// The property value, stored as a raw token list.
+    value: TokenList,
+
+    pub fn parse(property_id: css.PropertyId, input: *css.Parser, options: *const css.ParserOptions) Result(UnparsedProperty) {
+        const Closure = struct { options: *const css.ParserOptions };
+        const value = switch (input.parseUntilBefore(css.Delimiters{ .bang = true, .semicolon = true }, css.TokenList, &Closure{ .options = options }, struct {
+            pub fn parseFn(self: *const Closure, i: *css.Parser) Result(TokenList) {
+                return TokenList.parse(i, self.options, 0);
+            }
+        }.parseFn)) {
+            .result => |v| v,
+            .err => |e| return .{ .err = e },
+        };
+
+        return .{ .result = .{ .property_id = property_id, .value = value } };
+    }
+
+    /// Returns a new UnparsedProperty with the same value and the given property id.
+    pub fn withPropertyId(this: *const @This(), allocator: Allocator, property_id: css.PropertyId) UnparsedProperty {
+        return UnparsedProperty{ .property_id = property_id, .value = this.value.deepClone(allocator) };
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A CSS custom property, representing any unknown property.
+pub const CustomProperty = struct {
+    /// The name of the property.
+    name: CustomPropertyName,
+    /// The property value, stored as a raw token list.
+    value: TokenList,
+
+    pub fn parse(name: CustomPropertyName, input: *css.Parser, options: *const css.ParserOptions) Result(CustomProperty) {
+        const Closure = struct {
+            options: *const css.ParserOptions,
+
+            pub fn parsefn(this: *@This(), input2: *css.Parser) Result(TokenList) {
+                return TokenListFns.parse(input2, this.options, 0);
+            }
+        };
+
+        var closure = Closure{
+            .options = options,
+        };
+
+        const value = switch (input.parseUntilBefore(
+            css.Delimiters{
+                .bang = true,
+                .semicolon = true,
+            },
+            TokenList,
+            &closure,
+            Closure.parsefn,
+        )) {
+            .result => |v| v,
+            .err => |e| return .{ .err = e },
+        };
+
+        return .{ .result = CustomProperty{
+            .name = name,
+            .value = value,
+        } };
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+/// A CSS custom property name.
+pub const CustomPropertyName = union(enum) {
+    /// An author-defined CSS custom property.
+    custom: DashedIdent,
+    /// An unknown CSS property.
+    unknown: Ident,
+
+    pub fn toCss(this: *const CustomPropertyName, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        return switch (this.*) {
+            .custom => |custom| try custom.toCss(W, dest),
+            .unknown => |unknown| css.serializer.serializeIdentifier(unknown.v, dest) catch return dest.addFmtError(),
+        };
+    }
+
+    pub fn fromStr(name: []const u8) CustomPropertyName {
+        if (bun.strings.startsWith(name, "--")) return .{ .custom = .{ .v = name } };
+        return .{ .unknown = .{ .v = name } };
+    }
+
+    pub fn asStr(self: *const CustomPropertyName) []const u8 {
+        switch (self.*) {
+            .custom => |custom| return custom.v,
+            .unknown => |unknown| return unknown.v,
+        }
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+pub fn tryParseColorToken(f: []const u8, state: *const css.ParserState, input: *css.Parser) ?CssColor {
+    // css.todo_stuff.match_ignore_ascii_case
+    if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(f, "rgb") or
+        bun.strings.eqlCaseInsensitiveASCIIICheckLength(f, "rgba") or
+        bun.strings.eqlCaseInsensitiveASCIIICheckLength(f, "hsl") or
+        bun.strings.eqlCaseInsensitiveASCIIICheckLength(f, "hsla") or
+        bun.strings.eqlCaseInsensitiveASCIIICheckLength(f, "hwb") or
+        bun.strings.eqlCaseInsensitiveASCIIICheckLength(f, "lab") or
+        bun.strings.eqlCaseInsensitiveASCIIICheckLength(f, "lch") or
+        bun.strings.eqlCaseInsensitiveASCIIICheckLength(f, "oklab") or
+        bun.strings.eqlCaseInsensitiveASCIIICheckLength(f, "oklch") or
+        bun.strings.eqlCaseInsensitiveASCIIICheckLength(f, "color") or
+        bun.strings.eqlCaseInsensitiveASCIIICheckLength(f, "color-mix") or
+        bun.strings.eqlCaseInsensitiveASCIIICheckLength(f, "light-dark"))
+    {
+        const s = input.state();
+        input.reset(state);
+        if (CssColor.parse(input).asValue()) |color| {
+            return color;
+        }
+        input.reset(&s);
+    }
+
+    return null;
+}
diff --git a/src/css/properties/display.zig b/src/css/properties/display.zig
new file mode 100644
index 0000000000..eba2fee7cd
--- /dev/null
+++ b/src/css/properties/display.zig
@@ -0,0 +1,292 @@
+const std = @import("std");
+const bun = @import("root").bun;
+const Allocator = std.mem.Allocator;
+const ArrayList = std.ArrayListUnmanaged;
+
+pub const css = @import("../css_parser.zig");
+
+const SmallList = css.SmallList;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const Error = css.Error;
+
+const ContainerName = css.css_rules.container.ContainerName;
+
+const LengthPercentage = css.css_values.length.LengthPercentage;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CSSString = css.css_values.string.CSSString;
+const CSSNumber = css.css_values.number.CSSNumber;
+const LengthPercentageOrAuto = css.css_values.length.LengthPercentageOrAuto;
+const Size2D = css.css_values.size.Size2D;
+const DashedIdent = css.css_values.ident.DashedIdent;
+const Image = css.css_values.image.Image;
+const CssColor = css.css_values.color.CssColor;
+const Ratio = css.css_values.ratio.Ratio;
+const Length = css.css_values.length.LengthValue;
+const Rect = css.css_values.rect.Rect;
+const NumberOrPercentage = css.css_values.percentage.NumberOrPercentage;
+const CustomIdentList = css.css_values.ident.CustomIdentList;
+
+/// A value for the [display](https://drafts.csswg.org/css-display-3/#the-display-properties) property.
+pub const Display = union(enum) {
+    /// A display keyword.
+    keyword: DisplayKeyword,
+    /// The inside and outside display values.
+    pair: DisplayPair,
+
+    pub usingnamespace css.DeriveParse(@This());
+    pub usingnamespace css.DeriveToCss(@This());
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+        return css.implementHash(@This(), this, hasher);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+/// A value for the [visibility](https://drafts.csswg.org/css-display-3/#visibility) property.
+pub const Visibility = enum {
+    /// The element is visible.
+    visible,
+    /// The element is hidden.
+    hidden,
+    /// The element is collapsed.
+    collapse,
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+};
+
+/// A `display` keyword.
+///
+/// See [Display](Display).
+pub const DisplayKeyword = enum {
+    none,
+    contents,
+    @"table-row-group",
+    @"table-header-group",
+    @"table-footer-group",
+    @"table-row",
+    @"table-cell",
+    @"table-column-group",
+    @"table-column",
+    @"table-caption",
+    @"ruby-base",
+    @"ruby-text",
+    @"ruby-base-container",
+    @"ruby-text-container",
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+};
+
+/// A pair of inside and outside display values, as used in the `display` property.
+///
+/// See [Display](Display).
+pub const DisplayPair = struct {
+    /// The outside display value.
+    outside: DisplayOutside,
+    /// The inside display value.
+    inside: DisplayInside,
+    /// Whether this is a list item.
+    is_list_item: bool,
+
+    pub fn parse(input: *css.Parser) css.Result(@This()) {
+        var list_item = false;
+        var outside: ?DisplayOutside = null;
+        var inside: ?DisplayInside = null;
+
+        while (true) {
+            if (input.tryParse(css.Parser.expectIdentMatching, .{"list-item"}).isOk()) {
+                list_item = true;
+                continue;
+            }
+
+            if (outside == null) {
+                if (input.tryParse(DisplayOutside.parse, .{}).asValue()) |o| {
+                    outside = o;
+                    continue;
+                }
+            }
+
+            if (inside == null) {
+                if (input.tryParse(DisplayInside.parse, .{}).asValue()) |i| {
+                    inside = i;
+                    continue;
+                }
+            }
+
+            break;
+        }
+
+        if (list_item or inside != null or outside != null) {
+            const final_inside: DisplayInside = inside orelse DisplayInside.flow;
+            const final_outside: DisplayOutside = outside orelse switch (final_inside) {
+                // "If <display-outside> is omitted, the element’s outside display type
+                // defaults to block — except for ruby, which defaults to inline."
+                // https://drafts.csswg.org/css-display/#inside-model
+                .ruby => .@"inline",
+                else => .block,
+            };
+
+            if (list_item and !(final_inside == .flow or final_inside == .flow_root)) {
+                return .{ .err = input.newCustomError(.invalid_declaration) };
+            }
+
+            return .{ .result = .{
+                .outside = final_outside,
+                .inside = final_inside,
+                .is_list_item = list_item,
+            } };
+        }
+
+        const location = input.currentSourceLocation();
+        const ident = switch (input.expectIdent()) {
+            .result => |v| v,
+            .err => |e| return .{ .err = e },
+        };
+
+        const displayIdentMap = bun.ComptimeStringMap(DisplayPair, .{
+            .{ "inline-block", DisplayPair{ .outside = .@"inline", .inside = .flow_root, .is_list_item = false } },
+            .{ "inline-table", DisplayPair{ .outside = .@"inline", .inside = .table, .is_list_item = false } },
+            .{ "inline-flex", DisplayPair{ .outside = .@"inline", .inside = .{ .flex = css.VendorPrefix{ .none = true } }, .is_list_item = false } },
+            .{ "-webkit-inline-flex", DisplayPair{ .outside = .@"inline", .inside = .{ .flex = css.VendorPrefix{ .webkit = true } }, .is_list_item = false } },
+            .{ "-ms-inline-flexbox", DisplayPair{ .outside = .@"inline", .inside = .{ .flex = css.VendorPrefix{ .ms = true } }, .is_list_item = false } },
+            .{ "-webkit-inline-box", DisplayPair{ .outside = .@"inline", .inside = .{ .box = css.VendorPrefix{ .webkit = true } }, .is_list_item = false } },
+            .{ "-moz-inline-box", DisplayPair{ .outside = .@"inline", .inside = .{ .box = css.VendorPrefix{ .moz = true } }, .is_list_item = false } },
+            .{ "inline-grid", DisplayPair{ .outside = .@"inline", .inside = .grid, .is_list_item = false } },
+        });
+        if (displayIdentMap.getASCIIICaseInsensitive(ident)) |pair| {
+            return .{ .result = pair };
+        }
+
+        return .{ .err = location.newUnexpectedTokenError(.{ .ident = ident }) };
+    }
+
+    pub fn toCss(this: *const DisplayPair, comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+        if (this.outside == .@"inline" and this.inside == .flow_root and !this.is_list_item) {
+            return dest.writeStr("inline-block");
+        } else if (this.outside == .@"inline" and this.inside == .table and !this.is_list_item) {
+            return dest.writeStr("inline-table");
+        } else if (this.outside == .@"inline" and this.inside == .flex and !this.is_list_item) {
+            try this.inside.flex.toCss(W, dest);
+            if (this.inside.flex.eql(css.VendorPrefix{ .ms = true })) {
+                return dest.writeStr("inline-flexbox");
+            } else {
+                return dest.writeStr("inline-flex");
+            }
+        } else if (this.outside == .@"inline" and this.inside == .box and !this.is_list_item) {
+            try this.inside.box.toCss(W, dest);
+            return dest.writeStr("inline-box");
+        } else if (this.outside == .@"inline" and this.inside == .grid and !this.is_list_item) {
+            return dest.writeStr("inline-grid");
+        } else {
+            const default_outside: DisplayOutside = switch (this.inside) {
+                .ruby => .@"inline",
+                else => .block,
+            };
+
+            var needs_space = false;
+            if (!this.outside.eql(&default_outside) or (this.inside.eql(&DisplayInside{ .flow = {} }) and !this.is_list_item)) {
+                try this.outside.toCss(W, dest);
+                needs_space = true;
+            }
+
+            if (!this.inside.eql(&DisplayInside{ .flow = {} })) {
+                if (needs_space) {
+                    try dest.writeChar(' ');
+                }
+                try this.inside.toCss(W, dest);
+                needs_space = true;
+            }
+
+            if (this.is_list_item) {
+                if (needs_space) {
+                    try dest.writeChar(' ');
+                }
+                try dest.writeStr("list-item");
+            }
+        }
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+/// A [`<display-outside>`](https://drafts.csswg.org/css-display-3/#typedef-display-outside) value.
+pub const DisplayOutside = enum {
+    block,
+    @"inline",
+    @"run-in",
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+};
+
+/// A [`<display-inside>`](https://drafts.csswg.org/css-display-3/#typedef-display-inside) value.
+pub const DisplayInside = union(enum) {
+    flow,
+    flow_root,
+    table,
+    flex: css.VendorPrefix,
+    box: css.VendorPrefix,
+    grid,
+    ruby,
+
+    pub fn parse(input: *css.Parser) css.Result(@This()) {
+        const displayInsideMap = bun.ComptimeStringMap(DisplayInside, .{
+            .{ "flow", DisplayInside.flow },
+            .{ "flow-root", DisplayInside.flow_root },
+            .{ "table", .table },
+            .{ "flex", .{ .flex = css.VendorPrefix{ .none = true } } },
+            .{ "-webkit-flex", .{ .flex = css.VendorPrefix{ .webkit = true } } },
+            .{ "-ms-flexbox", .{ .flex = css.VendorPrefix{ .ms = true } } },
+            .{ "-webkit-box", .{ .box = css.VendorPrefix{ .webkit = true } } },
+            .{ "-moz-box", .{ .box = css.VendorPrefix{ .moz = true } } },
+            .{ "grid", .grid },
+            .{ "ruby", .ruby },
+        });
+
+        const location = input.currentSourceLocation();
+        const ident = switch (input.expectIdent()) {
+            .result => |v| v,
+            .err => |e| return .{ .err = e },
+        };
+
+        if (displayInsideMap.getASCIIICaseInsensitive(ident)) |value| {
+            return .{ .result = value };
+        }
+
+        return .{ .err = location.newUnexpectedTokenError(.{ .ident = ident }) };
+    }
+
+    pub fn toCss(this: *const DisplayInside, comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+        switch (this.*) {
+            .flow => try dest.writeStr("flow"),
+            .flow_root => try dest.writeStr("flow-root"),
+            .table => try dest.writeStr("table"),
+            .flex => |prefix| {
+                try prefix.toCss(W, dest);
+                if (prefix.eql(css.VendorPrefix{ .ms = true })) {
+                    try dest.writeStr("flexbox");
+                } else {
+                    try dest.writeStr("flex");
+                }
+            },
+            .box => |prefix| {
+                try prefix.toCss(W, dest);
+                try dest.writeStr("box");
+            },
+            .grid => try dest.writeStr("grid"),
+            .ruby => try dest.writeStr("ruby"),
+        }
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
diff --git a/src/css/properties/effects.zig b/src/css/properties/effects.zig
new file mode 100644
index 0000000000..34da8b7759
--- /dev/null
+++ b/src/css/properties/effects.zig
@@ -0,0 +1,77 @@
+const std = @import("std");
+const bun = @import("root").bun;
+const Allocator = std.mem.Allocator;
+const ArrayList = std.ArrayListUnmanaged;
+
+pub const css = @import("../css_parser.zig");
+
+const SmallList = css.SmallList;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const Error = css.Error;
+
+const ContainerName = css.css_rules.container.ContainerName;
+
+const LengthPercentage = css.css_values.length.LengthPercentage;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CSSString = css.css_values.string.CSSString;
+const CSSNumber = css.css_values.number.CSSNumber;
+const LengthPercentageOrAuto = css.css_values.length.LengthPercentageOrAuto;
+const Size2D = css.css_values.size.Size2D;
+const DashedIdent = css.css_values.ident.DashedIdent;
+const Image = css.css_values.image.Image;
+const CssColor = css.css_values.color.CssColor;
+const Ratio = css.css_values.ratio.Ratio;
+const Length = css.css_values.length.LengthValue;
+const Rect = css.css_values.rect.Rect;
+const NumberOrPercentage = css.css_values.percentage.NumberOrPercentage;
+const CustomIdentList = css.css_values.ident.CustomIdentList;
+const Angle = css.css_values.angle.Angle;
+const Url = css.css_values.url.Url;
+
+/// A value for the [filter](https://drafts.fxtf.org/filter-effects-1/#FilterProperty) and
+/// [backdrop-filter](https://drafts.fxtf.org/filter-effects-2/#BackdropFilterProperty) properties.
+pub const FilterList = union(enum) {
+    /// The `none` keyword.
+    none,
+    /// A list of filter functions.
+    filters: SmallList(Filter, 1),
+};
+
+/// A [filter](https://drafts.fxtf.org/filter-effects-1/#filter-functions) function.
+pub const Filter = union(enum) {
+    /// A `blur()` filter.
+    blur: Length,
+    /// A `brightness()` filter.
+    brightness: NumberOrPercentage,
+    /// A `contrast()` filter.
+    contrast: NumberOrPercentage,
+    /// A `grayscale()` filter.
+    grayscale: NumberOrPercentage,
+    /// A `hue-rotate()` filter.
+    hue_rotate: Angle,
+    /// An `invert()` filter.
+    invert: NumberOrPercentage,
+    /// An `opacity()` filter.
+    opacity: NumberOrPercentage,
+    /// A `saturate()` filter.
+    saturate: NumberOrPercentage,
+    /// A `sepia()` filter.
+    sepia: NumberOrPercentage,
+    /// A `drop-shadow()` filter.
+    drop_shadow: DropShadow,
+    /// A `url()` reference to an SVG filter.
+    url: Url,
+};
+
+/// A [`drop-shadow()`](https://drafts.fxtf.org/filter-effects-1/#funcdef-filter-drop-shadow) filter function.
+pub const DropShadow = struct {
+    /// The color of the drop shadow.
+    color: CssColor,
+    /// The x offset of the drop shadow.
+    x_offset: Length,
+    /// The y offset of the drop shadow.
+    y_offset: Length,
+    /// The blur radius of the drop shadow.
+    blur: Length,
+};
diff --git a/src/css/properties/flex.zig b/src/css/properties/flex.zig
new file mode 100644
index 0000000000..c94bfeb637
--- /dev/null
+++ b/src/css/properties/flex.zig
@@ -0,0 +1,395 @@
+const std = @import("std");
+const bun = @import("root").bun;
+const Allocator = std.mem.Allocator;
+const ArrayList = std.ArrayListUnmanaged;
+
+pub const css = @import("../css_parser.zig");
+
+const SmallList = css.SmallList;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const Error = css.Error;
+
+const ContainerName = css.css_rules.container.ContainerName;
+
+const CSSNumberFns = css.css_values.number.CSSNumberFns;
+const LengthPercentage = css.css_values.length.LengthPercentage;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CSSString = css.css_values.string.CSSString;
+const CSSNumber = css.css_values.number.CSSNumber;
+const LengthPercentageOrAuto = css.css_values.length.LengthPercentageOrAuto;
+const Size2D = css.css_values.size.Size2D;
+const DashedIdent = css.css_values.ident.DashedIdent;
+const Image = css.css_values.image.Image;
+const CssColor = css.css_values.color.CssColor;
+const Ratio = css.css_values.ratio.Ratio;
+const Length = css.css_values.length.LengthValue;
+const Rect = css.css_values.rect.Rect;
+const NumberOrPercentage = css.css_values.percentage.NumberOrPercentage;
+const CustomIdentList = css.css_values.ident.CustomIdentList;
+const Angle = css.css_values.angle.Angle;
+const Url = css.css_values.url.Url;
+
+/// A value for the [flex-direction](https://www.w3.org/TR/2018/CR-css-flexbox-1-20181119/#propdef-flex-direction) property.
+/// A value for the [flex-direction](https://www.w3.org/TR/2018/CR-css-flexbox-1-20181119/#propdef-flex-direction) property.
+pub const FlexDirection = enum {
+    /// Flex items are laid out in a row.
+    row,
+    /// Flex items are laid out in a row, and reversed.
+    @"row-reverse",
+    /// Flex items are laid out in a column.
+    column,
+    /// Flex items are laid out in a column, and reversed.
+    @"column-reverse",
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+
+    pub fn default() FlexDirection {
+        return .row;
+    }
+};
+
+/// A value for the [flex-wrap](https://www.w3.org/TR/2018/CR-css-flexbox-1-20181119/#flex-wrap-property) property.
+/// A value for the [flex-wrap](https://www.w3.org/TR/2018/CR-css-flexbox-1-20181119/#flex-wrap-property) property.
+pub const FlexWrap = enum {
+    /// The flex items do not wrap.
+    nowrap,
+    /// The flex items wrap.
+    wrap,
+    /// The flex items wrap, in reverse.
+    @"wrap-reverse",
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+
+    pub fn default() FlexWrap {
+        return .nowrap;
+    }
+};
+
+/// A value for the [flex-flow](https://www.w3.org/TR/2018/CR-css-flexbox-1-20181119/#flex-flow-property) shorthand property.
+/// A value for the [flex-flow](https://www.w3.org/TR/2018/CR-css-flexbox-1-20181119/#flex-flow-property) shorthand property.
+pub const FlexFlow = struct {
+    /// The direction that flex items flow.
+    direction: FlexDirection,
+    /// How the flex items wrap.
+    wrap: FlexWrap,
+
+    pub usingnamespace css.DefineShorthand(@This(), css.PropertyIdTag.@"flex-flow");
+
+    pub const PropertyFieldMap = .{
+        .direction = css.PropertyIdTag.@"flex-direction",
+        .wrap = css.PropertyIdTag.@"flex-wrap",
+    };
+
+    pub const VendorPrefixMap = .{
+        .direction = true,
+        .wrap = true,
+    };
+
+    pub fn parse(input: *css.Parser) css.Result(@This()) {
+        var direction: ?FlexDirection = null;
+        var wrap: ?FlexWrap = null;
+
+        while (true) {
+            if (direction == null) {
+                if (input.tryParse(FlexDirection.parse, .{}).asValue()) |value| {
+                    direction = value;
+                    continue;
+                }
+            }
+            if (wrap == null) {
+                if (input.tryParse(FlexWrap.parse, .{}).asValue()) |value| {
+                    wrap = value;
+                    continue;
+                }
+            }
+            break;
+        }
+
+        return .{
+            .result = FlexFlow{
+                .direction = direction orelse FlexDirection.row,
+                .wrap = wrap orelse FlexWrap.nowrap,
+            },
+        };
+    }
+
+    pub fn toCss(this: *const FlexFlow, comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+        var needs_space = false;
+        if (!this.direction.eql(&FlexDirection.default()) or this.wrap.eql(&FlexWrap.default())) {
+            try this.direction.toCss(W, dest);
+            needs_space = true;
+        }
+
+        if (!this.wrap.eql(&FlexWrap.default())) {
+            if (needs_space) {
+                try dest.writeStr(" ");
+            }
+            try this.wrap.toCss(W, dest);
+        }
+
+        return;
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+/// A value for the [flex](https://www.w3.org/TR/2018/CR-css-flexbox-1-20181119/#flex-property) shorthand property.
+/// A value for the [flex](https://www.w3.org/TR/2018/CR-css-flexbox-1-20181119/#flex-property) shorthand property.
+pub const Flex = struct {
+    /// The flex grow factor.
+    grow: CSSNumber,
+    /// The flex shrink factor.
+    shrink: CSSNumber,
+    /// The flex basis.
+    basis: LengthPercentageOrAuto,
+
+    pub usingnamespace css.DefineShorthand(@This(), css.PropertyIdTag.flex);
+
+    pub const PropertyFieldMap = .{
+        .grow = css.PropertyIdTag.@"flex-grow",
+        .shrink = css.PropertyIdTag.@"flex-shrink",
+        .basis = css.PropertyIdTag.@"flex-basis",
+    };
+
+    pub const VendorPrefixMap = .{
+        .grow = true,
+        .shrink = true,
+        .basis = true,
+    };
+
+    pub fn parse(input: *css.Parser) css.Result(@This()) {
+        if (input.tryParse(css.Parser.expectIdentMatching, .{"none"}).isOk()) {
+            return .{
+                .result = .{
+                    .grow = 0.0,
+                    .shrink = 0.0,
+                    .basis = LengthPercentageOrAuto.auto,
+                },
+            };
+        }
+
+        var grow: ?CSSNumber = null;
+        var shrink: ?CSSNumber = null;
+        var basis: ?LengthPercentageOrAuto = null;
+
+        while (true) {
+            if (grow == null) {
+                if (input.tryParse(CSSNumberFns.parse, .{}).asValue()) |value| {
+                    grow = value;
+                    shrink = input.tryParse(CSSNumberFns.parse, .{}).asValue();
+                    continue;
+                }
+            }
+
+            if (basis == null) {
+                if (input.tryParse(LengthPercentageOrAuto.parse, .{}).asValue()) |value| {
+                    basis = value;
+                    continue;
+                }
+            }
+
+            break;
+        }
+
+        return .{
+            .result = .{
+                .grow = grow orelse 1.0,
+                .shrink = shrink orelse 1.0,
+                .basis = basis orelse LengthPercentageOrAuto{ .length = LengthPercentage{ .percentage = .{ .v = 0.0 } } },
+            },
+        };
+    }
+
+    pub fn toCss(this: *const Flex, comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+        if (this.grow == 0.0 and this.shrink == 0.0 and this.basis == .auto) {
+            try dest.writeStr("none");
+            return;
+        }
+
+        const ZeroKind = enum {
+            NonZero,
+            Length,
+            Percentage,
+        };
+
+        // If the basis is unitless 0, we must write all three components to disambiguate.
+        // If the basis is 0%, we can omit the basis.
+        const basis_kind = switch (this.basis) {
+            .length => |lp| brk: {
+                if (lp == .dimension and lp.dimension.isZero()) break :brk ZeroKind.Length;
+                if (lp == .percentage and lp.percentage.isZero()) break :brk ZeroKind.Percentage;
+                break :brk ZeroKind.NonZero;
+            },
+            else => ZeroKind.NonZero,
+        };
+
+        if (this.grow != 1.0 or this.shrink != 1.0 or basis_kind != .NonZero) {
+            try CSSNumberFns.toCss(&this.grow, W, dest);
+            if (this.shrink != 1.0 or basis_kind == .Length) {
+                try dest.writeStr(" ");
+                try CSSNumberFns.toCss(&this.shrink, W, dest);
+            }
+        }
+
+        if (basis_kind != .Percentage) {
+            if (this.grow != 1.0 or this.shrink != 1.0 or basis_kind == .Length) {
+                try dest.writeStr(" ");
+            }
+            try this.basis.toCss(W, dest);
+        }
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+/// A value for the legacy (prefixed) [box-orient](https://www.w3.org/TR/2009/WD-css3-flexbox-20090723/#orientation) property.
+/// Partially equivalent to `flex-direction` in the standard syntax.
+/// A value for the legacy (prefixed) [box-orient](https://www.w3.org/TR/2009/WD-css3-flexbox-20090723/#orientation) property.
+/// Partially equivalent to `flex-direction` in the standard syntax.
+pub const BoxOrient = enum {
+    /// Items are laid out horizontally.
+    horizontal,
+    /// Items are laid out vertically.
+    vertical,
+    /// Items are laid out along the inline axis, according to the writing direction.
+    @"inline-axis",
+    /// Items are laid out along the block axis, according to the writing direction.
+    @"block-axis",
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+};
+
+/// A value for the legacy (prefixed) [box-direction](https://www.w3.org/TR/2009/WD-css3-flexbox-20090723/#displayorder) property.
+/// Partially equivalent to the `flex-direction` property in the standard syntax.
+pub const BoxDirection = enum {
+    /// Items flow in the natural direction.
+    normal,
+    /// Items flow in the reverse direction.
+    reverse,
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+};
+
+/// A value for the legacy (prefixed) [box-align](https://www.w3.org/TR/2009/WD-css3-flexbox-20090723/#alignment) property.
+/// Equivalent to the `align-items` property in the standard syntax.
+/// A value for the legacy (prefixed) [box-align](https://www.w3.org/TR/2009/WD-css3-flexbox-20090723/#alignment) property.
+/// Equivalent to the `align-items` property in the standard syntax.
+pub const BoxAlign = enum {
+    /// Items are aligned to the start.
+    start,
+    /// Items are aligned to the end.
+    end,
+    /// Items are centered.
+    center,
+    /// Items are aligned to the baseline.
+    baseline,
+    /// Items are stretched.
+    stretch,
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+};
+
+/// A value for the legacy (prefixed) [box-pack](https://www.w3.org/TR/2009/WD-css3-flexbox-20090723/#packing) property.
+/// Equivalent to the `justify-content` property in the standard syntax.
+/// A value for the legacy (prefixed) [box-pack](https://www.w3.org/TR/2009/WD-css3-flexbox-20090723/#packing) property.
+/// Equivalent to the `justify-content` property in the standard syntax.
+pub const BoxPack = enum {
+    /// Items are justified to the start.
+    start,
+    /// Items are justified to the end.
+    end,
+    /// Items are centered.
+    center,
+    /// Items are justified to the start and end.
+    justify,
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+};
+
+/// A value for the legacy (prefixed) [box-lines](https://www.w3.org/TR/2009/WD-css3-flexbox-20090723/#multiple) property.
+/// Equivalent to the `flex-wrap` property in the standard syntax.
+/// A value for the legacy (prefixed) [box-lines](https://www.w3.org/TR/2009/WD-css3-flexbox-20090723/#multiple) property.
+/// Equivalent to the `flex-wrap` property in the standard syntax.
+pub const BoxLines = enum {
+    /// Items are laid out in a single line.
+    single,
+    /// Items may wrap into multiple lines.
+    multiple,
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+};
+
+// Old flex (2012): https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/
+/// A value for the legacy (prefixed) [flex-pack](https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/#flex-pack) property.
+/// Equivalent to the `justify-content` property in the standard syntax.
+/// A value for the legacy (prefixed) [flex-pack](https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/#flex-pack) property.
+/// Equivalent to the `justify-content` property in the standard syntax.
+pub const FlexPack = enum {
+    /// Items are justified to the start.
+    start,
+    /// Items are justified to the end.
+    end,
+    /// Items are centered.
+    center,
+    /// Items are justified to the start and end.
+    justify,
+    /// Items are distributed evenly, with half size spaces on either end.
+    distribute,
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+};
+
+/// A value for the legacy (prefixed) [flex-item-align](https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/#flex-align) property.
+/// Equivalent to the `align-self` property in the standard syntax.
+/// A value for the legacy (prefixed) [flex-item-align](https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/#flex-align) property.
+/// Equivalent to the `align-self` property in the standard syntax.
+pub const FlexItemAlign = enum {
+    /// Equivalent to the value of `flex-align`.
+    auto,
+    /// The item is aligned to the start.
+    start,
+    /// The item is aligned to the end.
+    end,
+    /// The item is centered.
+    center,
+    /// The item is aligned to the baseline.
+    baseline,
+    /// The item is stretched.
+    stretch,
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+};
+
+/// A value for the legacy (prefixed) [flex-line-pack](https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/#flex-line-pack) property.
+/// Equivalent to the `align-content` property in the standard syntax.
+/// A value for the legacy (prefixed) [flex-line-pack](https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/#flex-line-pack) property.
+/// Equivalent to the `align-content` property in the standard syntax.
+pub const FlexLinePack = enum {
+    /// Content is aligned to the start.
+    start,
+    /// Content is aligned to the end.
+    end,
+    /// Content is centered.
+    center,
+    /// Content is justified.
+    justify,
+    /// Content is distributed evenly, with half size spaces on either end.
+    distribute,
+    /// Content is stretched.
+    stretch,
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+};
diff --git a/src/css/properties/font.zig b/src/css/properties/font.zig
new file mode 100644
index 0000000000..fe1980e19a
--- /dev/null
+++ b/src/css/properties/font.zig
@@ -0,0 +1,655 @@
+const std = @import("std");
+const bun = @import("root").bun;
+const Allocator = std.mem.Allocator;
+
+pub const css = @import("../css_parser.zig");
+const Error = css.Error;
+
+const ArrayList = std.ArrayListUnmanaged;
+const SmallList = css.SmallList;
+
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+
+const css_values = css.css_values;
+const CssColor = css.css_values.color.CssColor;
+const Image = css.css_values.image.Image;
+const Length = css.css_values.length.LengthValue;
+const LengthPercentage = css_values.length.LengthPercentage;
+const LengthPercentageOrAuto = css_values.length.LengthPercentageOrAuto;
+const PropertyCategory = css.PropertyCategory;
+const LogicalGroup = css.LogicalGroup;
+const CSSNumber = css.css_values.number.CSSNumber;
+const CSSNumberFns = css.css_values.number.CSSNumberFns;
+const CSSInteger = css.css_values.number.CSSInteger;
+const NumberOrPercentage = css.css_values.percentage.NumberOrPercentage;
+const Percentage = css.css_values.percentage.Percentage;
+const Angle = css.css_values.angle.Angle;
+const DashedIdentReference = css.css_values.ident.DashedIdentReference;
+const Time = css.css_values.time.Time;
+const EasingFunction = css.css_values.easing.EasingFunction;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CSSString = css.css_values.string.CSSString;
+const DashedIdent = css.css_values.ident.DashedIdent;
+const Url = css.css_values.url.Url;
+const CustomIdentList = css.css_values.ident.CustomIdentList;
+const Location = css.Location;
+const HorizontalPosition = css.css_values.position.HorizontalPosition;
+const VerticalPosition = css.css_values.position.VerticalPosition;
+const ContainerName = css.css_rules.container.ContainerName;
+
+/// A value for the [font-weight](https://www.w3.org/TR/css-fonts-4/#font-weight-prop) property.
+pub const FontWeight = union(enum) {
+    /// An absolute font weight.
+    absolute: AbsoluteFontWeight,
+    /// The `bolder` keyword.
+    bolder,
+    /// The `lighter` keyword.
+    lighter,
+
+    // TODO: implement this
+    pub usingnamespace css.DeriveParse(@This());
+    pub usingnamespace css.DeriveToCss(@This());
+
+    pub inline fn default() FontWeight {
+        return .{ .absolute = AbsoluteFontWeight.default() };
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// An [absolute font weight](https://www.w3.org/TR/css-fonts-4/#font-weight-absolute-values),
+/// as used in the `font-weight` property.
+///
+/// See [FontWeight](FontWeight).
+pub const AbsoluteFontWeight = union(enum) {
+    /// An explicit weight.
+    weight: CSSNumber,
+    /// Same as `400`.
+    normal,
+    /// Same as `700`.
+    bold,
+
+    pub usingnamespace css.DeriveParse(@This());
+
+    pub fn toCss(this: *const AbsoluteFontWeight, comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+        return switch (this.*) {
+            .weight => |*weight| CSSNumberFns.toCss(weight, W, dest),
+            .normal => try dest.writeStr(if (dest.minify) "400" else "normal"),
+            .bold => try dest.writeStr(if (dest.minify) "700" else "bold"),
+        };
+    }
+
+    pub inline fn default() AbsoluteFontWeight {
+        return .normal;
+    }
+
+    pub fn eql(lhs: *const AbsoluteFontWeight, rhs: *const AbsoluteFontWeight) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+/// A value for the [font-size](https://www.w3.org/TR/css-fonts-4/#font-size-prop) property.
+pub const FontSize = union(enum) {
+    /// An explicit size.
+    length: LengthPercentage,
+    /// An absolute font size keyword.
+    absolute: AbsoluteFontSize,
+    /// A relative font size keyword.
+    relative: RelativeFontSize,
+
+    pub usingnamespace css.DeriveParse(@This());
+    pub usingnamespace css.DeriveToCss(@This());
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// An [absolute font size](https://www.w3.org/TR/css-fonts-3/#absolute-size-value),
+/// as used in the `font-size` property.
+///
+/// See [FontSize](FontSize).
+pub const AbsoluteFontSize = enum {
+    /// "xx-small"
+    @"xx-small",
+    /// "x-small"
+    @"x-small",
+    /// "small"
+    small,
+    /// "medium"
+    medium,
+    /// "large"
+    large,
+    /// "x-large"
+    @"x-large",
+    /// "xx-large"
+    @"xx-large",
+    /// "xxx-large"
+    @"xxx-large",
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+};
+
+/// A [relative font size](https://www.w3.org/TR/css-fonts-3/#relative-size-value),
+/// as used in the `font-size` property.
+///
+/// See [FontSize](FontSize).
+pub const RelativeFontSize = enum {
+    smaller,
+    larger,
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+};
+
+/// A value for the [font-stretch](https://www.w3.org/TR/css-fonts-4/#font-stretch-prop) property.
+pub const FontStretch = union(enum) {
+    /// A font stretch keyword.
+    keyword: FontStretchKeyword,
+    /// A percentage.
+    percentage: Percentage,
+
+    // TODO: implement this
+    // pub usingnamespace css.DeriveParse(@This());
+
+    pub fn parse(input: *css.Parser) css.Result(FontStretch) {
+        _ = input; // autofix
+        @panic(css.todo_stuff.depth);
+    }
+
+    pub fn toCss(this: *const FontStretch, comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+        _ = this; // autofix
+        _ = dest; // autofix
+        @panic(css.todo_stuff.depth);
+    }
+
+    pub fn eql(lhs: *const FontStretch, rhs: *const FontStretch) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub inline fn default() FontStretch {
+        return .{ .keyword = FontStretchKeyword.default() };
+    }
+};
+
+/// A [font stretch keyword](https://www.w3.org/TR/css-fonts-4/#font-stretch-prop),
+/// as used in the `font-stretch` property.
+///
+/// See [FontStretch](FontStretch).
+pub const FontStretchKeyword = enum {
+    /// 100%
+    normal,
+    /// 50%
+    @"ultra-condensed",
+    /// 62.5%
+    @"extra-condensed",
+    /// 75%
+    condensed,
+    /// 87.5%
+    @"semi-condensed",
+    /// 112.5%
+    @"semi-expanded",
+    /// 125%
+    expanded,
+    /// 150%
+    @"extra-expanded",
+    /// 200%
+    @"ultra-expanded",
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+
+    pub inline fn default() FontStretchKeyword {
+        return .normal;
+    }
+};
+
+/// A value for the [font-family](https://www.w3.org/TR/css-fonts-4/#font-family-prop) property.
+pub const FontFamily = union(enum) {
+    /// A generic family name.
+    generic: GenericFontFamily,
+    /// A custom family name.
+    family_name: []const u8,
+
+    pub fn parse(input: *css.Parser) css.Result(@This()) {
+        if (input.tryParse(css.Parser.expectString, .{}).asValue()) |value| {
+            return .{ .result = .{ .family_name = value } };
+        }
+
+        if (input.tryParse(GenericFontFamily.parse, .{}).asValue()) |value| {
+            return .{ .result = .{ .generic = value } };
+        }
+
+        const stralloc = input.allocator();
+        const value = switch (input.expectIdent()) {
+            .result => |v| v,
+            .err => |e| return .{ .err = e },
+        };
+        var string: ?ArrayList(u8) = null;
+        while (input.tryParse(css.Parser.expectIdent, .{}).asValue()) |ident| {
+            if (string == null) {
+                string = ArrayList(u8){};
+                string.?.appendSlice(stralloc, value) catch bun.outOfMemory();
+            }
+
+            if (string) |*s| {
+                s.append(stralloc, ' ') catch bun.outOfMemory();
+                s.appendSlice(stralloc, ident) catch bun.outOfMemory();
+            }
+        }
+
+        const final_value = if (string) |s| s.items else value;
+
+        return .{ .result = .{ .family_name = final_value } };
+    }
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+        switch (this.*) {
+            .generic => |val| {
+                try val.toCss(W, dest);
+            },
+            .family_name => |val| {
+                // Generic family names such as sans-serif must be quoted if parsed as a string.
+                // CSS wide keywords, as well as "default", must also be quoted.
+                // https://www.w3.org/TR/css-fonts-4/#family-name-syntax
+
+                if (val.len > 0 and
+                    !css.parse_utility.parseString(
+                    dest.allocator,
+                    GenericFontFamily,
+                    val,
+                    GenericFontFamily.parse,
+                ).isOk()) {
+                    var id = ArrayList(u8){};
+                    defer id.deinit(dest.allocator);
+                    var first = true;
+                    var split_iter = std.mem.splitScalar(u8, val, ' ');
+                    while (split_iter.next()) |slice| {
+                        if (first) {
+                            first = false;
+                        } else {
+                            id.append(dest.allocator, ' ') catch bun.outOfMemory();
+                        }
+                        css.serializer.serializeIdentifier(slice, dest) catch return dest.addFmtError();
+                    }
+                    if (id.items.len < val.len + 2) {
+                        return dest.writeStr(id.items);
+                    }
+                }
+                return css.serializer.serializeString(val, dest) catch return dest.addFmtError();
+            },
+        }
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A [generic font family](https://www.w3.org/TR/css-fonts-4/#generic-font-families) name,
+/// as used in the `font-family` property.
+///
+/// See [FontFamily](FontFamily).
+pub const GenericFontFamily = enum {
+    serif,
+    @"sans-serif",
+    cursive,
+    fantasy,
+    monospace,
+    @"system-ui",
+    emoji,
+    math,
+    fangsong,
+    @"ui-serif",
+    @"ui-sans-serif",
+    @"ui-monospace",
+    @"ui-rounded",
+
+    // CSS wide keywords. These must be parsed as identifiers so they
+    // don't get serialized as strings.
+    // https://www.w3.org/TR/css-values-4/#common-keywords
+    initial,
+    inherit,
+    unset,
+    // Default is also reserved by the <custom-ident> type.
+    // https://www.w3.org/TR/css-values-4/#custom-idents
+    default,
+
+    // CSS defaulting keywords
+    // https://drafts.csswg.org/css-cascade-5/#defaulting-keywords
+    revert,
+    @"revert-layer",
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+};
+
+/// A value for the [font-style](https://www.w3.org/TR/css-fonts-4/#font-style-prop) property.
+pub const FontStyle = union(enum) {
+    /// Normal font style.
+    normal,
+    /// Italic font style.
+    italic,
+    /// Oblique font style, with a custom angle.
+    oblique: Angle,
+
+    pub fn default() FontStyle {
+        return .normal;
+    }
+
+    pub fn parse(input: *css.Parser) css.Result(FontStyle) {
+        const location = input.currentSourceLocation();
+        const ident = switch (input.expectIdent()) {
+            .result => |v| v,
+            .err => |e| return .{ .err = e },
+        };
+        // todo_stuff.match_ignore_ascii_case
+        if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("normal", ident)) {
+            return .{ .result = .normal };
+        } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("italic", ident)) {
+            return .{ .result = .italic };
+        } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("oblique", ident)) {
+            const angle = input.tryParse(Angle.parse, .{}).unwrapOr(FontStyle.defaultObliqueAngle());
+            return .{ .result = .{ .oblique = angle } };
+        } else {
+            //
+            return .{ .err = location.newUnexpectedTokenError(.{ .ident = ident }) };
+        }
+    }
+
+    pub fn toCss(this: *const FontStyle, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        switch (this.*) {
+            .normal => try dest.writeStr("normal"),
+            .italic => try dest.writeStr("italic"),
+            .oblique => |angle| {
+                try dest.writeStr("oblique");
+                if (angle.eql(&FontStyle.defaultObliqueAngle())) {
+                    try dest.writeChar(' ');
+                    try angle.toCss(W, dest);
+                }
+            },
+        }
+    }
+
+    pub fn defaultObliqueAngle() Angle {
+        return Angle{ .deg = 14.0 };
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A value for the [font-variant-caps](https://www.w3.org/TR/css-fonts-4/#font-variant-caps-prop) property.
+pub const FontVariantCaps = enum {
+    /// No special capitalization features are applied.
+    normal,
+    /// The small capitals feature is used for lower case letters.
+    @"small-caps",
+    /// Small capitals are used for both upper and lower case letters.
+    @"all-small-caps",
+    /// Petite capitals are used.
+    @"petite-caps",
+    /// Petite capitals are used for both upper and lower case letters.
+    @"all-petite-caps",
+    /// Enables display of mixture of small capitals for uppercase letters with normal lowercase letters.
+    unicase,
+    /// Uses titling capitals.
+    @"titling-caps",
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+
+    pub fn default() FontVariantCaps {
+        return .normal;
+    }
+
+    fn isCss2(this: *const FontVariantCaps) bool {
+        return switch (this.*) {
+            .normal, .@"small-caps" => true,
+            else => false,
+        };
+    }
+
+    pub fn parseCss2(input: *css.Parser) css.Result(FontVariantCaps) {
+        const value = switch (FontVariantCaps.parse(input)) {
+            .result => |v| v,
+            .err => |e| return .{ .err = e },
+        };
+        if (!value.isCss2()) {
+            return .{ .err = input.newCustomError(css.ParserError.invalid_value) };
+        }
+        return .{ .result = value };
+    }
+};
+
+/// A value for the [line-height](https://www.w3.org/TR/2020/WD-css-inline-3-20200827/#propdef-line-height) property.
+pub const LineHeight = union(enum) {
+    /// The UA sets the line height based on the font.
+    normal,
+    /// A multiple of the element's font size.
+    number: CSSNumber,
+    /// An explicit height.
+    length: LengthPercentage,
+
+    pub usingnamespace @call(.auto, css.DeriveParse, .{@This()});
+    pub usingnamespace @call(.auto, css.DeriveToCss, .{@This()});
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn default() LineHeight {
+        return .normal;
+    }
+};
+
+/// A value for the [font](https://www.w3.org/TR/css-fonts-4/#font-prop) shorthand property.
+pub const Font = struct {
+    /// The font family.
+    family: bun.BabyList(FontFamily),
+    /// The font size.
+    size: FontSize,
+    /// The font style.
+    style: FontStyle,
+    /// The font weight.
+    weight: FontWeight,
+    /// The font stretch.
+    stretch: FontStretch,
+    /// The line height.
+    line_height: LineHeight,
+    /// How the text should be capitalized. Only CSS 2.1 values are supported.
+    variant_caps: FontVariantCaps,
+
+    pub usingnamespace css.DefineShorthand(@This(), css.PropertyIdTag.font);
+
+    pub const PropertyFieldMap = .{
+        .family = css.PropertyIdTag.@"font-family",
+        .size = css.PropertyIdTag.@"font-size",
+        .style = css.PropertyIdTag.@"font-style",
+        .weight = css.PropertyIdTag.@"font-weight",
+        .stretch = css.PropertyIdTag.@"font-stretch",
+        .line_height = css.PropertyIdTag.@"line-height",
+        .variant_caps = css.PropertyIdTag.@"font-variant-caps",
+    };
+
+    pub fn parse(input: *css.Parser) css.Result(Font) {
+        var style: ?FontStyle = null;
+        var weight: ?FontWeight = null;
+        var stretch: ?FontStretch = null;
+        var size: ?FontSize = null;
+        var variant_caps: ?FontVariantCaps = null;
+        var count: i32 = 0;
+
+        while (true) {
+            // Skip "normal" since it is valid for several properties, but we don't know which ones it will be used for yet.
+            if (input.tryParse(css.Parser.expectIdentMatching, .{"normal"}).isOk()) {
+                count += 1;
+                continue;
+            }
+
+            if (style == null) {
+                if (input.tryParse(FontStyle.parse, .{}).asValue()) |value| {
+                    style = value;
+                    count += 1;
+                    continue;
+                }
+            }
+
+            if (weight == null) {
+                if (input.tryParse(FontWeight.parse, .{}).asValue()) |value| {
+                    weight = value;
+                    count += 1;
+                    continue;
+                }
+            }
+
+            if (variant_caps != null) {
+                if (input.tryParse(FontVariantCaps.parseCss2, .{}).asValue()) |value| {
+                    variant_caps = value;
+                    count += 1;
+                    continue;
+                }
+            }
+
+            if (stretch == null) {
+                if (input.tryParse(FontStretchKeyword.parse, .{}).asValue()) |value| {
+                    stretch = .{ .keyword = value };
+                    count += 1;
+                    continue;
+                }
+            }
+
+            size = switch (@call(.auto, @field(FontSize, "parse"), .{input})) {
+                .result => |v| v,
+                .err => |e| return .{ .err = e },
+            };
+            break;
+        }
+
+        if (count > 4) return .{ .err = input.newCustomError(css.ParserError.invalid_declaration) };
+
+        const final_size = size orelse return .{ .err = input.newCustomError(css.ParserError.invalid_declaration) };
+
+        const line_height = if (input.tryParse(css.Parser.expectDelim, .{'/'}).isOk()) switch (LineHeight.parse(input)) {
+            .result => |v| v,
+            .err => |e| return .{ .err = e },
+        } else null;
+
+        const family = switch (bun.BabyList(FontFamily).parse(input)) {
+            .result => |v| v,
+            .err => |e| return .{ .err = e },
+        };
+
+        return .{ .result = Font{
+            .family = family,
+            .size = final_size,
+            .style = style orelse FontStyle.default(),
+            .weight = weight orelse FontWeight.default(),
+            .stretch = stretch orelse FontStretch.default(),
+            .line_height = line_height orelse LineHeight.default(),
+            .variant_caps = variant_caps orelse FontVariantCaps.default(),
+        } };
+    }
+
+    pub fn toCss(this: *const Font, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        if (!this.style.eql(&FontStyle.default())) {
+            try this.style.toCss(W, dest);
+            try dest.writeChar(' ');
+        }
+
+        if (!this.variant_caps.eql(&FontVariantCaps.default())) {
+            try this.variant_caps.toCss(W, dest);
+            try dest.writeChar(' ');
+        }
+
+        if (!this.weight.eql(&FontWeight.default())) {
+            try this.weight.toCss(W, dest);
+            try dest.writeChar(' ');
+        }
+
+        if (!this.stretch.eql(&FontStretch.default())) {
+            try this.stretch.toCss(W, dest);
+            try dest.writeChar(' ');
+        }
+
+        try this.size.toCss(W, dest);
+
+        if (!this.line_height.eql(&LineHeight.default())) {
+            try dest.delim('/', true);
+            try this.line_height.toCss(W, dest);
+        }
+
+        try dest.writeChar(' ');
+
+        const len = this.family.len;
+        for (this.family.sliceConst(), 0..) |*val, idx| {
+            try val.toCss(W, dest);
+            if (idx < len - 1) {
+                try dest.delim(',', false);
+            }
+        }
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A value for the [vertical align](https://drafts.csswg.org/css2/#propdef-vertical-align) property.
+// TODO: there is a more extensive spec in CSS3 but it doesn't seem any browser implements it? https://www.w3.org/TR/css-inline-3/#transverse-alignment
+pub const VerticalAlign = union(enum) {
+    /// A vertical align keyword.
+    keyword: VerticalAlignKeyword,
+    /// An explicit length.
+    length: LengthPercentage,
+};
+
+/// A keyword for the [vertical align](https://drafts.csswg.org/css2/#propdef-vertical-align) property.
+pub const VerticalAlignKeyword = enum {
+    /// Align the baseline of the box with the baseline of the parent box.
+    baseline,
+    /// Lower the baseline of the box to the proper position for subscripts of the parent’s box.
+    sub,
+    /// Raise the baseline of the box to the proper position for superscripts of the parent’s box.
+    super,
+    /// Align the top of the aligned subtree with the top of the line box.
+    top,
+    /// Align the top of the box with the top of the parent’s content area.
+    @"text-top",
+    /// Align the vertical midpoint of the box with the baseline of the parent box plus half the x-height of the parent.
+    middle,
+    /// Align the bottom of the aligned subtree with the bottom of the line box.
+    bottom,
+    /// Align the bottom of the box with the bottom of the parent’s content area.
+    @"text-bottom",
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+};
diff --git a/src/css/properties/generate_properties.ts b/src/css/properties/generate_properties.ts
new file mode 100644
index 0000000000..e7f79c1e2e
--- /dev/null
+++ b/src/css/properties/generate_properties.ts
@@ -0,0 +1,1993 @@
+type VendorPrefixes = "none" | "webkit" | "moz" | "ms" | "o";
+
+type LogicalGroup =
+  | "border_color"
+  | "border_style"
+  | "border_width"
+  | "border_radius"
+  | "margin"
+  | "scroll_margin"
+  | "padding"
+  | "scroll_padding"
+  | "inset"
+  | "size"
+  | "min_size"
+  | "max_size";
+
+type PropertyCategory = "logical" | "physical";
+
+type PropertyDef = {
+  ty: string;
+  shorthand?: boolean;
+  valid_prefixes?: VendorPrefixes[];
+  logical_group?: {
+    ty: LogicalGroup;
+    category: PropertyCategory;
+  };
+  /// By default true
+  unprefixed?: boolean;
+  conditional?: {
+    css_modules: boolean;
+  };
+  eval_branch_quota?: number;
+};
+
+const OUTPUT_FILE = "src/css/properties/properties_generated.zig";
+
+async function generateCode(property_defs: Record<string, PropertyDef>) {
+  const EMIT_COMPLETED_MD_FILE = true;
+  if (EMIT_COMPLETED_MD_FILE) {
+    const completed = Object.entries(property_defs)
+      .map(([name, meta]) => `- [x] \`${name}\``)
+      .join("\n");
+    await Bun.$`echo ${completed} > completed.md`;
+  }
+  await Bun.$`echo ${prelude()} > ${OUTPUT_FILE}`;
+  await Bun.$`echo ${generateProperty(property_defs)} >> ${OUTPUT_FILE}`;
+  await Bun.$`echo ${generatePropertyId(property_defs)} >> ${OUTPUT_FILE}`;
+  await Bun.$`echo ${generatePropertyIdTag(property_defs)} >> ${OUTPUT_FILE}`;
+  await Bun.$`vendor/zig/zig.exe fmt ${OUTPUT_FILE}`;
+}
+
+function generatePropertyIdTag(property_defs: Record<string, PropertyDef>): string {
+  return `pub const PropertyIdTag = enum(u16) {
+  ${Object.keys(property_defs)
+    .map(key => `${escapeIdent(key)},`)
+    .join("\n")}
+    all,
+    unparsed,
+    custom,
+
+    /// Helper function used in comptime code to know whether to access the underlying value
+    /// with tuple indexing syntax because it may have a VendorPrefix associated with it.
+    pub fn hasVendorPrefix(this: PropertyIdTag) bool {
+      return switch (this) {
+        ${Object.entries(property_defs)
+          .map(([name, meta]) => `.${escapeIdent(name)} => ${meta.valid_prefixes === undefined ? "false" : "true"},`)
+          .join("\n")}
+        .unparsed => false,
+        .custom => false,
+        .all => false,
+      };
+    }
+
+    /// Helper function used in comptime code to know whether to access the underlying value
+    /// with tuple indexing syntax because it may have a VendorPrefix associated with it.
+    pub fn valueType(this: PropertyIdTag) type {
+      return switch (this) {
+        ${Object.entries(property_defs)
+          .map(([name, meta]) => `.${escapeIdent(name)} => ${meta.ty},`)
+          .join("\n")}
+        .all => CSSWideKeyword,
+        .unparsed => UnparsedProperty,
+        .custom => CustomProperty,
+      };
+    }
+};`;
+}
+
+function generateProperty(property_defs: Record<string, PropertyDef>): string {
+  return `pub const Property = union(PropertyIdTag) {
+${Object.entries(property_defs)
+  .map(([name, meta]) => generatePropertyField(name, meta))
+  .join("\n")}
+  all: CSSWideKeyword,
+  unparsed: UnparsedProperty,
+  custom: CustomProperty,
+
+  ${generatePropertyImpl(property_defs)}
+};`;
+}
+
+function generatePropertyImpl(property_defs: Record<string, PropertyDef>): string {
+  const required_functions = ["deepClone", "parse", "toCss", "eql"];
+
+  return `
+  pub usingnamespace PropertyImpl();
+
+  // Sanity check to make sure all types have the following functions:
+  // - deepClone()
+  // - eql()
+  // - parse()
+  // - toCss()
+  // 
+  // We do this string concatenation thing so we get all the errors at once,
+  // instead of relying on Zig semantic analysis which usualy stops at the first error.
+  comptime {
+  const compile_error: []const u8 = compile_error: {
+      var compile_error: []const u8 = "";
+      ${Object.entries(property_defs)
+        .map(([name, meta]) => {
+          if (meta.ty != "void" && meta.ty != "CSSNumber" && meta.ty != "CSSInteger") {
+            return required_functions
+              .map(
+                fn => `
+            if (!@hasDecl(${meta.ty}, "${fn}")) {
+              compile_error = compile_error ++ @typeName(${meta.ty}) ++ ": does not have a ${fn}() function.\\n";
+            }
+            `,
+              )
+              .join("\n");
+          }
+          return "";
+        })
+        .join("\n")}
+      const final_compile_error = compile_error;
+      break :compile_error final_compile_error;
+    };
+    if (compile_error.len > 0) {
+      @compileError(compile_error);
+    }
+  }
+
+  /// Parses a CSS property by name.
+  pub fn parse(property_id: PropertyId, input: *css.Parser, options: *const css.ParserOptions) Result(Property) {
+    const state = input.state();
+
+    switch (property_id) {
+      ${generatePropertyImplParseCases(property_defs)}
+      .all => return .{ .result = .{ .all = switch (CSSWideKeyword.parse(input)) {
+        .result => |v| v,
+        .err => |e| return .{ .err = e },
+      } } },
+      .custom => |name| return .{ .result = .{ .custom = switch (CustomProperty.parse(name, input, options)) {
+        .result => |v| v,
+        .err => |e| return .{ .err = e },
+      } } },
+      else => {},
+    }
+
+    // If a value was unable to be parsed, treat as an unparsed property.
+    // This is different from a custom property, handled below, in that the property name is known
+    // and stored as an enum rather than a string. This lets property handlers more easily deal with it.
+    // Ideally we'd only do this if var() or env() references were seen, but err on the safe side for now.
+    input.reset(&state);
+    return .{ .result = .{ .unparsed = switch (UnparsedProperty.parse(property_id, input, options)) {
+    .result => |v| v,
+    .err => |e| return .{ .err = e },
+    } } };
+  }
+
+  pub fn propertyId(this: *const Property) PropertyId {
+    return switch (this.*) {
+      ${Object.entries(property_defs)
+        .map(([name, meta]) => {
+          if (meta.valid_prefixes !== undefined) {
+            return `.${escapeIdent(name)} => |*v| PropertyId{ .${escapeIdent(name)} = v[1]  },`;
+          }
+          return `.${escapeIdent(name)} => .${escapeIdent(name)},`;
+        })
+        .join("\n")}
+      .all => PropertyId.all,
+      .unparsed => |unparsed| unparsed.property_id,
+      .custom => |c| .{ .custom = c.name },
+    };
+  }
+
+  pub fn deepClone(this: *const Property, allocator: std.mem.Allocator) Property {
+    return switch (this.*) {
+      ${Object.entries(property_defs)
+        .map(([name, meta]) => {
+          if (meta.valid_prefixes !== undefined) {
+            const clone_expr =
+              meta.ty === "CSSNumber" || meta.ty === "CSSInteger" ? "v[0]" : "v[0].deepClone(allocator)";
+            return `.${escapeIdent(name)} => |*v| .{ .${escapeIdent(name)} = .{ ${clone_expr}, v[1] } },`;
+          }
+          const clone_expr =
+            meta.ty === "CSSNumber" || meta.ty === "CSSInteger"
+              ? "v.*"
+              : meta.ty.includes("BabyList(")
+                ? `css.generic.deepClone(${meta.ty}, v, allocator)`
+                : "v.deepClone(allocator)";
+          return `.${escapeIdent(name)} => |*v| .{ .${escapeIdent(name)} = ${clone_expr} },`;
+        })
+        .join("\n")}
+      .all => |*a| return .{ .all = a.deepClone(allocator) },
+      .unparsed => |*u| return .{ .unparsed = u.deepClone(allocator) },
+      .custom => |*c| return .{ .custom = c.deepClone(allocator) },
+    };
+  }
+
+  /// We're going to have this empty for now since not every property has a deinit function.
+  /// It's not strictly necessary since all allocations are into an arena.
+  /// It's mostly intended as a performance optimization in the case where mimalloc arena is used,
+  /// since it can reclaim the memory and use it for subsequent allocations.
+  /// I haven't benchmarked that though, so I don't actually know how much faster it would actually make it.
+  pub fn deinit(this: *@This(), allocator: std.mem.Allocator) void {
+      _ = this;
+      _ = allocator;
+  }
+
+  pub inline fn __toCssHelper(this: *const Property) struct{[]const u8, VendorPrefix} {
+    return switch (this.*) {
+      ${generatePropertyImplToCssHelper(property_defs)}
+      .all => .{ "all", VendorPrefix{ .none = true } },
+      .unparsed => |*unparsed| brk: {
+        var prefix = unparsed.property_id.prefix();
+        if (prefix.isEmpty()) {
+          prefix = VendorPrefix{ .none = true };
+        }
+        break :brk .{ unparsed.property_id.name(), prefix };
+      },
+      .custom => unreachable,
+    };
+  }
+
+  /// Serializes the value of a CSS property without its name or \`!important\` flag.
+  pub fn valueToCss(this: *const Property, comptime W: type, dest: *css.Printer(W)) PrintErr!void {
+    return switch(this.*) {
+      ${Object.entries(property_defs)
+        .map(([name, meta]) => {
+          const value = meta.valid_prefixes === undefined ? "value" : "value[0]";
+          const to_css =
+            meta.ty === "CSSNumber"
+              ? `CSSNumberFns.toCss(&${value}, W, dest)`
+              : meta.ty === "CSSInteger"
+                ? `CSSIntegerFns.toCss(&${value}, W, dest)`
+                : meta.ty.includes("ArrayList")
+                  ? `css.generic.toCss(${meta.ty}, ${value}, W, dest)`
+                  : `${value}.toCss(W, dest)`;
+          return `.${escapeIdent(name)} => |*value| ${to_css},`;
+        })
+        .join("\n")}
+      .all => |*keyword| keyword.toCss(W, dest),
+      .unparsed => |*unparsed| unparsed.value.toCss(W, dest, false),
+      .custom => |*c| c.value.toCss(W, dest, c.name == .custom),
+    };
+  }
+
+  /// Returns the given longhand property for a shorthand.
+  pub fn longhand(this: *const Property, property_id: *const PropertyId) ?Property {
+    switch (this.*) {
+      ${Object.entries(property_defs)
+        .filter(([_, meta]) => meta.shorthand)
+        .map(([name, meta]) => {
+          if (meta.valid_prefixes !== undefined) {
+            return `.${escapeIdent(name)} => |*v| {
+              if (!v[1].eq(property_id.prefix())) return null;
+              return v[0].longhand(property_id);
+            },`;
+          }
+
+          return `.${escapeIdent(name)} => |*v| return v.longhand(property_id),`;
+        })
+        .join("\n")}
+      else => {},
+    }
+    return null;
+  }
+
+  pub fn eql(lhs: *const Property, rhs: *const Property) bool {
+    if (@intFromEnum(lhs.*) != @intFromEnum(rhs.*)) return false;
+    return switch (lhs.*) {
+      ${Object.entries(property_defs)
+        .map(([name, meta]) => {
+          if (meta.valid_prefixes !== undefined)
+            return `.${escapeIdent(name)} => |*v| css.generic.eql(${meta.ty}, &v[0], &v[0]) and v[1].eq(rhs.${escapeIdent(name)}[1]),`;
+          return `.${escapeIdent(name)} => |*v| css.generic.eql(${meta.ty}, v, &rhs.${escapeIdent(name)}),`;
+        })
+        .join("\n")}
+      .all, .unparsed => true,
+      .custom => |*c| c.eql(&rhs.custom),
+    };
+  }
+`;
+}
+
+function generatePropertyImplToCssHelper(property_defs: Record<string, PropertyDef>): string {
+  return Object.entries(property_defs)
+    .map(([name, meta]) => {
+      const capture = meta.valid_prefixes === undefined ? "" : "|*x|";
+      const prefix = meta.valid_prefixes === undefined ? "VendorPrefix{ .none = true }" : 'x.@"1"';
+      return `.${escapeIdent(name)} => ${capture} .{"${name}", ${prefix}},`;
+    })
+    .join("\n");
+}
+
+function generatePropertyImplParseCases(property_defs: Record<string, PropertyDef>): string {
+  return Object.entries(property_defs)
+    .map(([name, meta]) => {
+      const capture = meta.valid_prefixes === undefined ? "" : "|pre|";
+      const ret =
+        meta.valid_prefixes === undefined
+          ? `.{ .${escapeIdent(name)} = c }`
+          : `.{ .${escapeIdent(name)} = .{ c, pre } }`;
+      return `.${escapeIdent(name)} => ${capture} {
+    ${meta.eval_branch_quota !== undefined ? `@setEvalBranchQuota(${meta.eval_branch_quota});` : ""}
+  if (css.generic.parseWithOptions(${meta.ty}, input, options).asValue()) |c| {
+    if (input.expectExhausted().isOk()) {
+      return .{ .result = ${ret} };
+    }
+  }
+},`;
+    })
+    .join("\n");
+}
+
+function generatePropertyField(name: string, meta: PropertyDef): string {
+  if (meta.valid_prefixes !== undefined) {
+    return ` ${escapeIdent(name)}: struct{ ${meta.ty}, VendorPrefix },`;
+  }
+  return ` ${escapeIdent(name)}: ${meta.ty},`;
+}
+
+function generatePropertyId(property_defs: Record<string, PropertyDef>): string {
+  return `pub const PropertyId = union(PropertyIdTag) {
+${Object.entries(property_defs)
+  .map(([name, meta]) => generatePropertyIdField(name, meta))
+  .join("\n")}
+  all,
+  unparsed,
+  custom: CustomPropertyName,
+
+pub usingnamespace PropertyIdImpl();
+
+${generatePropertyIdImpl(property_defs)}
+};`;
+}
+
+function generatePropertyIdField(name: string, meta: PropertyDef): string {
+  if (meta.valid_prefixes !== undefined) {
+    return ` ${escapeIdent(name)}: VendorPrefix,`;
+  }
+  return ` ${escapeIdent(name)},`;
+}
+
+function generatePropertyIdImpl(property_defs: Record<string, PropertyDef>): string {
+  return `
+  /// Returns the property name, without any vendor prefixes.
+  pub inline fn name(this: *const PropertyId) []const u8 {
+      return @tagName(this.*);
+  }
+
+  /// Returns the vendor prefix for this property id.
+  pub fn prefix(this: *const PropertyId) VendorPrefix {
+    return switch (this.*) {
+      ${generatePropertyIdImplPrefix(property_defs)}
+      .all, .custom, .unparsed => VendorPrefix.empty(),
+    };
+  }
+
+  pub fn fromNameAndPrefix(name1: []const u8, pre: VendorPrefix) ?PropertyId {
+    const Enum = enum { ${Object.entries(property_defs)
+      .map(
+        ([prop_name, def], i) => `${escapeIdent(prop_name)}${i === Object.keys(property_defs).length - 1 ? "" : ", "}`,
+      )
+      .join("")} };
+    const Map = comptime bun.ComptimeEnumMap(Enum);
+    if (Map.getASCIIICaseInsensitive(name1)) |prop| {
+      switch (prop) {
+        ${Object.entries(property_defs).map(([name, meta]) => {
+          return `.${escapeIdent(name)} => {
+            const allowed_prefixes = ${constructVendorPrefix(meta.valid_prefixes)};
+            if (allowed_prefixes.contains(pre)) return ${meta.valid_prefixes === undefined ? `.${escapeIdent(name)}` : `.{ .${escapeIdent(name)} = pre }`};
+          }`;
+        })}
+      }
+    }
+
+    return null;
+  }
+
+  pub fn withPrefix(this: *const PropertyId, pre: VendorPrefix) PropertyId {
+    return switch (this.*) {
+      ${Object.entries(property_defs)
+        .map(([prop_name, def]) => {
+          if (def.valid_prefixes === undefined) return `.${escapeIdent(prop_name)} => .${escapeIdent(prop_name)},`;
+          return `.${escapeIdent(prop_name)} => .{ .${escapeIdent(prop_name)} = pre },`;
+        })
+        .join("\n")}
+      else => this.*,
+    };
+  }
+
+  pub fn addPrefix(this: *PropertyId, pre: VendorPrefix) void {
+    return switch (this.*) {
+      ${Object.entries(property_defs)
+        .map(([prop_name, def]) => {
+          if (def.valid_prefixes === undefined) return `.${escapeIdent(prop_name)} => {},`;
+          return `.${escapeIdent(prop_name)} => |*p| { p.insert(pre); },`;
+        })
+        .join("\n")}
+      else => {},
+    };
+  }
+
+  pub inline fn deepClone(this: *const PropertyId, _: std.mem.Allocator) PropertyId {
+    return this.*;
+  }
+
+  pub fn eql(lhs: *const PropertyId, rhs: *const PropertyId) bool {
+    if (@intFromEnum(lhs.*) != @intFromEnum(rhs.*)) return false;
+    inline for (bun.meta.EnumFields(PropertyId), std.meta.fields(PropertyId)) |enum_field, union_field| {
+      if (enum_field.value == @intFromEnum(lhs.*)) {
+        if (comptime union_field.type == css.VendorPrefix) {
+          return @field(lhs, union_field.name).eql(@field(rhs, union_field.name));
+        } else {
+          return true;
+        }
+      }
+    }
+    unreachable;
+  }
+
+  pub fn hash(this: *const PropertyId, hasher: *std.hash.Wyhash) void {
+    const tag = @intFromEnum(this.*);
+    hasher.update(std.mem.asBytes(&tag));
+  }
+`;
+}
+
+function generatePropertyIdImplPrefix(property_defs: Record<string, PropertyDef>): string {
+  return Object.entries(property_defs)
+    .map(([name, meta]) => {
+      if (meta.valid_prefixes === undefined) return `.${escapeIdent(name)} => VendorPrefix.empty(),`;
+      return `.${escapeIdent(name)} => |p| p,`;
+    })
+    .join("\n");
+}
+
+// TODO: todo_stuff.match_ignore_ascii_case
+function generatePropertyIdImplFromNameAndPrefix(property_defs: Record<string, PropertyDef>): string {
+  return Object.entries(property_defs)
+    .map(([name, meta]) => {
+      if (name === "unparsed") return "";
+      return `if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name1, "${name}")) {
+  const allowed_prefixes = ${constructVendorPrefix(meta.valid_prefixes)};
+  if (allowed_prefixes.contains(pre)) return ${meta.valid_prefixes === undefined ? `.${escapeIdent(name)}` : `.{ .${escapeIdent(name)} = pre }`};
+} else `;
+    })
+    .join("\n");
+}
+
+function constructVendorPrefix(prefixes: VendorPrefixes[] | undefined): string {
+  if (prefixes === undefined) return `VendorPrefix{ .none = true }`;
+  return `VendorPrefix{ ${[`.none = true`, ...prefixes.map(prefix => `.${prefix} = true`)].join(", ")} }`;
+}
+
+function needsEscaping(name: string): boolean {
+  switch (name) {
+    case "align":
+      return true;
+    case "var":
+    default: {
+      return ["-", "(", ")", " ", ":", ";", ","].some(c => name.includes(c));
+    }
+  }
+}
+
+function escapeIdent(name: string): string {
+  if (needsEscaping(name)) {
+    return `@"${name}"`;
+  }
+  return name;
+}
+
+generateCode({
+  "background-color": {
+    ty: "CssColor",
+  },
+  "background-image": {
+    ty: "SmallList(Image, 1)",
+  },
+  "background-position-x": {
+    ty: "SmallList(css_values.position.HorizontalPosition, 1)",
+  },
+  "background-position-y": {
+    ty: "SmallList(css_values.position.VerticalPosition, 1)",
+  },
+  "background-position": {
+    ty: "SmallList(background.BackgroundPosition, 1)",
+    shorthand: true,
+  },
+  "background-size": {
+    ty: "SmallList(background.BackgroundSize, 1)",
+  },
+  "background-repeat": {
+    ty: "SmallList(background.BackgroundRepeat, 1)",
+  },
+  "background-attachment": {
+    ty: "SmallList(background.BackgroundAttachment, 1)",
+  },
+  "background-clip": {
+    ty: "SmallList(background.BackgroundClip, 1)",
+    valid_prefixes: ["webkit", "moz"],
+  },
+  "background-origin": {
+    ty: "SmallList(background.BackgroundOrigin, 1)",
+  },
+  background: {
+    ty: "SmallList(background.Background, 1)",
+  },
+  "box-shadow": {
+    ty: "SmallList(box_shadow.BoxShadow, 1)",
+    valid_prefixes: ["webkit", "moz"],
+  },
+  opacity: {
+    ty: "css.css_values.alpha.AlphaValue",
+  },
+  color: {
+    ty: "CssColor",
+  },
+  display: {
+    ty: "display.Display",
+  },
+  visibility: {
+    ty: "display.Visibility",
+  },
+  width: {
+    ty: "size.Size",
+    logical_group: { ty: "size", category: "physical" },
+  },
+  height: {
+    ty: "size.Size",
+    logical_group: { ty: "size", category: "physical" },
+  },
+  "min-width": {
+    ty: "size.Size",
+    logical_group: { ty: "min_size", category: "physical" },
+  },
+  "min-height": {
+    ty: "size.Size",
+    logical_group: { ty: "min_size", category: "physical" },
+  },
+  "max-width": {
+    ty: "size.MaxSize",
+    logical_group: { ty: "max_size", category: "physical" },
+  },
+  "max-height": {
+    ty: "size.MaxSize",
+    logical_group: { ty: "max_size", category: "physical" },
+  },
+  "block-size": {
+    ty: "size.Size",
+    logical_group: { ty: "size", category: "logical" },
+  },
+  "inline-size": {
+    ty: "size.Size",
+    logical_group: { ty: "size", category: "logical" },
+  },
+  "min-block-size": {
+    ty: "size.Size",
+    logical_group: { ty: "min_size", category: "logical" },
+  },
+  "min-inline-size": {
+    ty: "size.Size",
+    logical_group: { ty: "min_size", category: "logical" },
+  },
+  "max-block-size": {
+    ty: "size.MaxSize",
+    logical_group: { ty: "max_size", category: "logical" },
+  },
+  "max-inline-size": {
+    ty: "size.MaxSize",
+    logical_group: { ty: "max_size", category: "logical" },
+  },
+  "box-sizing": {
+    ty: "size.BoxSizing",
+    valid_prefixes: ["webkit", "moz"],
+  },
+  "aspect-ratio": {
+    ty: "size.AspectRatio",
+  },
+  overflow: {
+    ty: "overflow.Overflow",
+    shorthand: true,
+  },
+  "overflow-x": {
+    ty: "overflow.OverflowKeyword",
+  },
+  "overflow-y": {
+    ty: "overflow.OverflowKeyword",
+  },
+  "text-overflow": {
+    ty: "overflow.TextOverflow",
+    valid_prefixes: ["o"],
+  },
+  position: {
+    ty: "position.Position",
+  },
+  top: {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "inset", category: "physical" },
+  },
+  bottom: {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "inset", category: "physical" },
+  },
+  left: {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "inset", category: "physical" },
+  },
+  right: {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "inset", category: "physical" },
+  },
+  "inset-block-start": {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "inset", category: "logical" },
+  },
+  "inset-block-end": {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "inset", category: "logical" },
+  },
+  "inset-inline-start": {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "inset", category: "logical" },
+  },
+  "inset-inline-end": {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "inset", category: "logical" },
+  },
+  "inset-block": {
+    ty: "margin_padding.InsetBlock",
+    shorthand: true,
+  },
+  "inset-inline": {
+    ty: "margin_padding.InsetInline",
+    shorthand: true,
+  },
+  inset: {
+    ty: "margin_padding.Inset",
+    shorthand: true,
+  },
+  "border-spacing": {
+    ty: "css.css_values.size.Size2D(Length)",
+  },
+  "border-top-color": {
+    ty: "CssColor",
+    logical_group: { ty: "border_color", category: "physical" },
+  },
+  "border-bottom-color": {
+    ty: "CssColor",
+    logical_group: { ty: "border_color", category: "physical" },
+  },
+  "border-left-color": {
+    ty: "CssColor",
+    logical_group: { ty: "border_color", category: "physical" },
+  },
+  "border-right-color": {
+    ty: "CssColor",
+    logical_group: { ty: "border_color", category: "physical" },
+  },
+  "border-block-start-color": {
+    ty: "CssColor",
+    logical_group: { ty: "border_color", category: "logical" },
+  },
+  "border-block-end-color": {
+    ty: "CssColor",
+    logical_group: { ty: "border_color", category: "logical" },
+  },
+  "border-inline-start-color": {
+    ty: "CssColor",
+    logical_group: { ty: "border_color", category: "logical" },
+  },
+  "border-inline-end-color": {
+    ty: "CssColor",
+    logical_group: { ty: "border_color", category: "logical" },
+  },
+  "border-top-style": {
+    ty: "border.LineStyle",
+    logical_group: { ty: "border_style", category: "physical" },
+  },
+  "border-bottom-style": {
+    ty: "border.LineStyle",
+    logical_group: { ty: "border_style", category: "physical" },
+  },
+  "border-left-style": {
+    ty: "border.LineStyle",
+    logical_group: { ty: "border_style", category: "physical" },
+  },
+  "border-right-style": {
+    ty: "border.LineStyle",
+    logical_group: { ty: "border_style", category: "physical" },
+  },
+  "border-block-start-style": {
+    ty: "border.LineStyle",
+    logical_group: { ty: "border_style", category: "logical" },
+  },
+  "border-block-end-style": {
+    ty: "border.LineStyle",
+    logical_group: { ty: "border_style", category: "logical" },
+  },
+  "border-inline-start-style": {
+    ty: "border.LineStyle",
+    logical_group: { ty: "border_style", category: "logical" },
+  },
+  "border-inline-end-style": {
+    ty: "border.LineStyle",
+    logical_group: { ty: "border_style", category: "logical" },
+  },
+  "border-top-width": {
+    ty: "BorderSideWidth",
+    logical_group: { ty: "border_width", category: "physical" },
+  },
+  "border-bottom-width": {
+    ty: "BorderSideWidth",
+    logical_group: { ty: "border_width", category: "physical" },
+  },
+  "border-left-width": {
+    ty: "BorderSideWidth",
+    logical_group: { ty: "border_width", category: "physical" },
+  },
+  "border-right-width": {
+    ty: "BorderSideWidth",
+    logical_group: { ty: "border_width", category: "physical" },
+  },
+  "border-block-start-width": {
+    ty: "BorderSideWidth",
+    logical_group: { ty: "border_width", category: "logical" },
+  },
+  "border-block-end-width": {
+    ty: "BorderSideWidth",
+    logical_group: { ty: "border_width", category: "logical" },
+  },
+  "border-inline-start-width": {
+    ty: "BorderSideWidth",
+    logical_group: { ty: "border_width", category: "logical" },
+  },
+  "border-inline-end-width": {
+    ty: "BorderSideWidth",
+    logical_group: { ty: "border_width", category: "logical" },
+  },
+  "border-top-left-radius": {
+    ty: "Size2D(LengthPercentage)",
+    valid_prefixes: ["webkit", "moz"],
+    logical_group: { ty: "border_radius", category: "physical" },
+  },
+  "border-top-right-radius": {
+    ty: "Size2D(LengthPercentage)",
+    valid_prefixes: ["webkit", "moz"],
+    logical_group: { ty: "border_radius", category: "physical" },
+  },
+  "border-bottom-left-radius": {
+    ty: "Size2D(LengthPercentage)",
+    valid_prefixes: ["webkit", "moz"],
+    logical_group: { ty: "border_radius", category: "physical" },
+  },
+  "border-bottom-right-radius": {
+    ty: "Size2D(LengthPercentage)",
+    valid_prefixes: ["webkit", "moz"],
+    logical_group: { ty: "border_radius", category: "physical" },
+  },
+  "border-start-start-radius": {
+    ty: "Size2D(LengthPercentage)",
+    logical_group: { ty: "border_radius", category: "logical" },
+  },
+  "border-start-end-radius": {
+    ty: "Size2D(LengthPercentage)",
+    logical_group: { ty: "border_radius", category: "logical" },
+  },
+  "border-end-start-radius": {
+    ty: "Size2D(LengthPercentage)",
+    logical_group: { ty: "border_radius", category: "logical" },
+  },
+  "border-end-end-radius": {
+    ty: "Size2D(LengthPercentage)",
+    logical_group: { ty: "border_radius", category: "logical" },
+  },
+  "border-radius": {
+    ty: "BorderRadius",
+    valid_prefixes: ["webkit", "moz"],
+    shorthand: true,
+  },
+  "border-image-source": {
+    ty: "Image",
+  },
+  "border-image-outset": {
+    ty: "Rect(LengthOrNumber)",
+  },
+  "border-image-repeat": {
+    ty: "BorderImageRepeat",
+  },
+  "border-image-width": {
+    ty: "Rect(BorderImageSideWidth)",
+  },
+  "border-image-slice": {
+    ty: "BorderImageSlice",
+  },
+  "border-image": {
+    ty: "BorderImage",
+    valid_prefixes: ["webkit", "moz", "o"],
+    shorthand: true,
+  },
+  "border-color": {
+    ty: "BorderColor",
+    shorthand: true,
+  },
+  "border-style": {
+    ty: "BorderStyle",
+    shorthand: true,
+  },
+  "border-width": {
+    ty: "BorderWidth",
+    shorthand: true,
+  },
+  "border-block-color": {
+    ty: "BorderBlockColor",
+    shorthand: true,
+  },
+  "border-block-style": {
+    ty: "BorderBlockStyle",
+    shorthand: true,
+  },
+  "border-block-width": {
+    ty: "BorderBlockWidth",
+    shorthand: true,
+  },
+  "border-inline-color": {
+    ty: "BorderInlineColor",
+    shorthand: true,
+  },
+  "border-inline-style": {
+    ty: "BorderInlineStyle",
+    shorthand: true,
+  },
+  "border-inline-width": {
+    ty: "BorderInlineWidth",
+    shorthand: true,
+  },
+  border: {
+    ty: "Border",
+    shorthand: true,
+  },
+  "border-top": {
+    ty: "BorderTop",
+    shorthand: true,
+  },
+  "border-bottom": {
+    ty: "BorderBottom",
+    shorthand: true,
+  },
+  "border-left": {
+    ty: "BorderLeft",
+    shorthand: true,
+  },
+  "border-right": {
+    ty: "BorderRight",
+    shorthand: true,
+  },
+  "border-block": {
+    ty: "BorderBlock",
+    shorthand: true,
+  },
+  "border-block-start": {
+    ty: "BorderBlockStart",
+    shorthand: true,
+  },
+  "border-block-end": {
+    ty: "BorderBlockEnd",
+    shorthand: true,
+  },
+  "border-inline": {
+    ty: "BorderInline",
+    shorthand: true,
+  },
+  "border-inline-start": {
+    ty: "BorderInlineStart",
+    shorthand: true,
+  },
+  "border-inline-end": {
+    ty: "BorderInlineEnd",
+    shorthand: true,
+  },
+  outline: {
+    ty: "Outline",
+    shorthand: true,
+  },
+  "outline-color": {
+    ty: "CssColor",
+  },
+  "outline-style": {
+    ty: "OutlineStyle",
+  },
+  "outline-width": {
+    ty: "BorderSideWidth",
+  },
+  "flex-direction": {
+    ty: "FlexDirection",
+    valid_prefixes: ["webkit", "ms"],
+  },
+  "flex-wrap": {
+    ty: "FlexWrap",
+    valid_prefixes: ["webkit", "ms"],
+  },
+  "flex-flow": {
+    ty: "FlexFlow",
+    valid_prefixes: ["webkit", "ms"],
+    shorthand: true,
+  },
+  "flex-grow": {
+    ty: "CSSNumber",
+    valid_prefixes: ["webkit"],
+  },
+  "flex-shrink": {
+    ty: "CSSNumber",
+    valid_prefixes: ["webkit"],
+  },
+  "flex-basis": {
+    ty: "LengthPercentageOrAuto",
+    valid_prefixes: ["webkit"],
+  },
+  flex: {
+    ty: "Flex",
+    valid_prefixes: ["webkit", "ms"],
+    shorthand: true,
+  },
+  order: {
+    ty: "CSSInteger",
+    valid_prefixes: ["webkit"],
+  },
+  "align-content": {
+    ty: "AlignContent",
+    valid_prefixes: ["webkit"],
+  },
+  "justify-content": {
+    ty: "JustifyContent",
+    valid_prefixes: ["webkit"],
+  },
+  "place-content": {
+    ty: "PlaceContent",
+    shorthand: true,
+  },
+  "align-self": {
+    ty: "AlignSelf",
+    valid_prefixes: ["webkit"],
+  },
+  "justify-self": {
+    ty: "JustifySelf",
+  },
+  "place-self": {
+    ty: "PlaceSelf",
+    shorthand: true,
+  },
+  "align-items": {
+    ty: "AlignItems",
+    valid_prefixes: ["webkit"],
+  },
+  "justify-items": {
+    ty: "JustifyItems",
+  },
+  "place-items": {
+    ty: "PlaceItems",
+    shorthand: true,
+  },
+  "row-gap": {
+    ty: "GapValue",
+  },
+  "column-gap": {
+    ty: "GapValue",
+  },
+  gap: {
+    ty: "Gap",
+    shorthand: true,
+  },
+  "box-orient": {
+    ty: "BoxOrient",
+    valid_prefixes: ["webkit", "moz"],
+    unprefixed: false,
+  },
+  "box-direction": {
+    ty: "BoxDirection",
+    valid_prefixes: ["webkit", "moz"],
+    unprefixed: false,
+  },
+  "box-ordinal-group": {
+    ty: "CSSInteger",
+    valid_prefixes: ["webkit", "moz"],
+    unprefixed: false,
+  },
+  "box-align": {
+    ty: "BoxAlign",
+    valid_prefixes: ["webkit", "moz"],
+    unprefixed: false,
+  },
+  "box-flex": {
+    ty: "CSSNumber",
+    valid_prefixes: ["webkit", "moz"],
+    unprefixed: false,
+  },
+  "box-flex-group": {
+    ty: "CSSInteger",
+    valid_prefixes: ["webkit"],
+    unprefixed: false,
+  },
+  "box-pack": {
+    ty: "BoxPack",
+    valid_prefixes: ["webkit", "moz"],
+    unprefixed: false,
+  },
+  "box-lines": {
+    ty: "BoxLines",
+    valid_prefixes: ["webkit", "moz"],
+    unprefixed: false,
+  },
+  "flex-pack": {
+    ty: "FlexPack",
+    valid_prefixes: ["ms"],
+    unprefixed: false,
+  },
+  "flex-order": {
+    ty: "CSSInteger",
+    valid_prefixes: ["ms"],
+    unprefixed: false,
+  },
+  "flex-align": {
+    ty: "BoxAlign",
+    valid_prefixes: ["ms"],
+    unprefixed: false,
+  },
+  "flex-item-align": {
+    ty: "FlexItemAlign",
+    valid_prefixes: ["ms"],
+    unprefixed: false,
+  },
+  "flex-line-pack": {
+    ty: "FlexLinePack",
+    valid_prefixes: ["ms"],
+    unprefixed: false,
+  },
+  "flex-positive": {
+    ty: "CSSNumber",
+    valid_prefixes: ["ms"],
+    unprefixed: false,
+  },
+  "flex-negative": {
+    ty: "CSSNumber",
+    valid_prefixes: ["ms"],
+    unprefixed: false,
+  },
+  "flex-preferred-size": {
+    ty: "LengthPercentageOrAuto",
+    valid_prefixes: ["ms"],
+    unprefixed: false,
+  },
+  "margin-top": {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "margin", category: "physical" },
+  },
+  "margin-bottom": {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "margin", category: "physical" },
+  },
+  "margin-left": {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "margin", category: "physical" },
+  },
+  "margin-right": {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "margin", category: "physical" },
+  },
+  "margin-block-start": {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "margin", category: "logical" },
+    eval_branch_quota: 5000,
+  },
+  "margin-block-end": {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "margin", category: "logical" },
+  },
+  "margin-inline-start": {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "margin", category: "logical" },
+  },
+  "margin-inline-end": {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "margin", category: "logical" },
+  },
+  "margin-block": {
+    ty: "MarginBlock",
+    shorthand: true,
+  },
+  "margin-inline": {
+    ty: "MarginInline",
+    shorthand: true,
+  },
+  margin: {
+    ty: "Margin",
+    shorthand: true,
+    eval_branch_quota: 5000,
+  },
+  "padding-top": {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "padding", category: "physical" },
+  },
+  "padding-bottom": {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "padding", category: "physical" },
+  },
+  "padding-left": {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "padding", category: "physical" },
+  },
+  "padding-right": {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "padding", category: "physical" },
+  },
+  "padding-block-start": {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "padding", category: "logical" },
+  },
+  "padding-block-end": {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "padding", category: "logical" },
+  },
+  "padding-inline-start": {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "padding", category: "logical" },
+  },
+  "padding-inline-end": {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "padding", category: "logical" },
+  },
+  "padding-block": {
+    ty: "PaddingBlock",
+    shorthand: true,
+  },
+  "padding-inline": {
+    ty: "PaddingInline",
+    shorthand: true,
+  },
+  padding: {
+    ty: "Padding",
+    shorthand: true,
+  },
+  "scroll-margin-top": {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "scroll_margin", category: "physical" },
+  },
+  "scroll-margin-bottom": {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "scroll_margin", category: "physical" },
+  },
+  "scroll-margin-left": {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "scroll_margin", category: "physical" },
+  },
+  "scroll-margin-right": {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "scroll_margin", category: "physical" },
+  },
+  "scroll-margin-block-start": {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "scroll_margin", category: "logical" },
+  },
+  "scroll-margin-block-end": {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "scroll_margin", category: "logical" },
+  },
+  "scroll-margin-inline-start": {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "scroll_margin", category: "logical" },
+  },
+  "scroll-margin-inline-end": {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "scroll_margin", category: "logical" },
+  },
+  "scroll-margin-block": {
+    ty: "ScrollMarginBlock",
+    shorthand: true,
+  },
+  "scroll-margin-inline": {
+    ty: "ScrollMarginInline",
+    shorthand: true,
+  },
+  "scroll-margin": {
+    ty: "ScrollMargin",
+    shorthand: true,
+  },
+  "scroll-padding-top": {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "scroll_padding", category: "physical" },
+  },
+  "scroll-padding-bottom": {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "scroll_padding", category: "physical" },
+  },
+  "scroll-padding-left": {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "scroll_padding", category: "physical" },
+  },
+  "scroll-padding-right": {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "scroll_padding", category: "physical" },
+  },
+  "scroll-padding-block-start": {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "scroll_padding", category: "logical" },
+  },
+  "scroll-padding-block-end": {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "scroll_padding", category: "logical" },
+  },
+  "scroll-padding-inline-start": {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "scroll_padding", category: "logical" },
+  },
+  "scroll-padding-inline-end": {
+    ty: "LengthPercentageOrAuto",
+    logical_group: { ty: "scroll_padding", category: "logical" },
+  },
+  "scroll-padding-block": {
+    ty: "ScrollPaddingBlock",
+    shorthand: true,
+  },
+  "scroll-padding-inline": {
+    ty: "ScrollPaddingInline",
+    shorthand: true,
+  },
+  "scroll-padding": {
+    ty: "ScrollPadding",
+    shorthand: true,
+  },
+  "font-weight": {
+    ty: "FontWeight",
+  },
+  "font-size": {
+    ty: "FontSize",
+  },
+  "font-stretch": {
+    ty: "FontStretch",
+  },
+  "font-family": {
+    ty: "BabyList(FontFamily)",
+  },
+  "font-style": {
+    ty: "FontStyle",
+  },
+  "font-variant-caps": {
+    ty: "FontVariantCaps",
+  },
+  "line-height": {
+    ty: "LineHeight",
+  },
+  font: {
+    ty: "Font",
+    shorthand: true,
+  },
+  // "vertical-align": {
+  //   ty: "VerticalAlign",
+  // },
+  // "font-palette": {
+  //   ty: "DashedIdentReference",
+  // },
+  // "transition-property": {
+  //   ty: "SmallList(PropertyId, 1)",
+  //   valid_prefixes: ["webkit", "moz", "ms"],
+  // },
+  // "transition-duration": {
+  //   ty: "SmallList(Time, 1)",
+  //   valid_prefixes: ["webkit", "moz", "ms"],
+  // },
+  // "transition-delay": {
+  //   ty: "SmallList(Time, 1)",
+  //   valid_prefixes: ["webkit", "moz", "ms"],
+  // },
+  // "transition-timing-function": {
+  //   ty: "SmallList(EasingFunction, 1)",
+  //   valid_prefixes: ["webkit", "moz", "ms"],
+  // },
+  // transition: {
+  //   ty: "SmallList(Transition, 1)",
+  //   valid_prefixes: ["webkit", "moz", "ms"],
+  //   shorthand: true,
+  // },
+  // "animation-name": {
+  //   ty: "AnimationNameList",
+  //   valid_prefixes: ["webkit", "moz", "o"],
+  // },
+  // "animation-duration": {
+  //   ty: "SmallList(Time, 1)",
+  //   valid_prefixes: ["webkit", "moz", "o"],
+  // },
+  // "animation-timing-function": {
+  //   ty: "SmallList(EasingFunction, 1)",
+  //   valid_prefixes: ["webkit", "moz", "o"],
+  // },
+  // "animation-iteration-count": {
+  //   ty: "SmallList(AnimationIterationCount, 1)",
+  //   valid_prefixes: ["webkit", "moz", "o"],
+  // },
+  // "animation-direction": {
+  //   ty: "SmallList(AnimationDirection, 1)",
+  //   valid_prefixes: ["webkit", "moz", "o"],
+  // },
+  // "animation-play-state": {
+  //   ty: "SmallList(AnimationPlayState, 1)",
+  //   valid_prefixes: ["webkit", "moz", "o"],
+  // },
+  // "animation-delay": {
+  //   ty: "SmallList(Time, 1)",
+  //   valid_prefixes: ["webkit", "moz", "o"],
+  // },
+  // "animation-fill-mode": {
+  //   ty: "SmallList(AnimationFillMode, 1)",
+  //   valid_prefixes: ["webkit", "moz", "o"],
+  // },
+  // "animation-composition": {
+  //   ty: "SmallList(AnimationComposition, 1)",
+  // },
+  // "animation-timeline": {
+  //   ty: "SmallList(AnimationTimeline, 1)",
+  // },
+  // "animation-range-start": {
+  //   ty: "SmallList(AnimationRangeStart, 1)",
+  // },
+  // "animation-range-end": {
+  //   ty: "SmallList(AnimationRangeEnd, 1)",
+  // },
+  // "animation-range": {
+  //   ty: "SmallList(AnimationRange, 1)",
+  // },
+  // animation: {
+  //   ty: "AnimationList",
+  //   valid_prefixes: ["webkit", "moz", "o"],
+  //   shorthand: true,
+  // },
+  // transform: {
+  //   ty: "TransformList",
+  //   valid_prefixes: ["webkit", "moz", "ms", "o"],
+  // },
+  // "transform-origin": {
+  //   ty: "Position",
+  //   valid_prefixes: ["webkit", "moz", "ms", "o"],
+  // },
+  // "transform-style": {
+  //   ty: "TransformStyle",
+  //   valid_prefixes: ["webkit", "moz"],
+  // },
+  // "transform-box": {
+  //   ty: "TransformBox",
+  // },
+  // "backface-visibility": {
+  //   ty: "BackfaceVisibility",
+  //   valid_prefixes: ["webkit", "moz"],
+  // },
+  // perspective: {
+  //   ty: "Perspective",
+  //   valid_prefixes: ["webkit", "moz"],
+  // },
+  // "perspective-origin": {
+  //   ty: "Position",
+  //   valid_prefixes: ["webkit", "moz"],
+  // },
+  // translate: {
+  //   ty: "Translate",
+  // },
+  // rotate: {
+  //   ty: "Rotate",
+  // },
+  // scale: {
+  //   ty: "Scale",
+  // },
+  // "text-transform": {
+  //   ty: "TextTransform",
+  // },
+  // "white-space": {
+  //   ty: "WhiteSpace",
+  // },
+  // "tab-size": {
+  //   ty: "LengthOrNumber",
+  //   valid_prefixes: ["moz", "o"],
+  // },
+  // "word-break": {
+  //   ty: "WordBreak",
+  // },
+  // "line-break": {
+  //   ty: "LineBreak",
+  // },
+  // hyphens: {
+  //   ty: "Hyphens",
+  //   valid_prefixes: ["webkit", "moz", "ms"],
+  // },
+  // "overflow-wrap": {
+  //   ty: "OverflowWrap",
+  // },
+  // "word-wrap": {
+  //   ty: "OverflowWrap",
+  // },
+  // "text-align": {
+  //   ty: "TextAlign",
+  // },
+  // "text-align-last": {
+  //   ty: "TextAlignLast",
+  //   valid_prefixes: ["moz"],
+  // },
+  // "text-justify": {
+  //   ty: "TextJustify",
+  // },
+  // "word-spacing": {
+  //   ty: "Spacing",
+  // },
+  // "letter-spacing": {
+  //   ty: "Spacing",
+  // },
+  // "text-indent": {
+  //   ty: "TextIndent",
+  // },
+  // "text-decoration-line": {
+  //   ty: "TextDecorationLine",
+  //   valid_prefixes: ["webkit", "moz"],
+  // },
+  // "text-decoration-style": {
+  //   ty: "TextDecorationStyle",
+  //   valid_prefixes: ["webkit", "moz"],
+  // },
+  "text-decoration-color": {
+    ty: "CssColor",
+    valid_prefixes: ["webkit", "moz"],
+  },
+  // "text-decoration-thickness": {
+  //   ty: "TextDecorationThickness",
+  // },
+  // "text-decoration": {
+  //   ty: "TextDecoration",
+  //   valid_prefixes: ["webkit", "moz"],
+  //   shorthand: true,
+  // },
+  // "text-decoration-skip-ink": {
+  //   ty: "TextDecorationSkipInk",
+  //   valid_prefixes: ["webkit"],
+  // },
+  // "text-emphasis-style": {
+  //   ty: "TextEmphasisStyle",
+  //   valid_prefixes: ["webkit"],
+  // },
+  "text-emphasis-color": {
+    ty: "CssColor",
+    valid_prefixes: ["webkit"],
+  },
+  // "text-emphasis": {
+  //   ty: "TextEmphasis",
+  //   valid_prefixes: ["webkit"],
+  //   shorthand: true,
+  // },
+  // "text-emphasis-position": {
+  //   ty: "TextEmphasisPosition",
+  //   valid_prefixes: ["webkit"],
+  // },
+  "text-shadow": {
+    ty: "SmallList(TextShadow, 1)",
+  },
+  // "text-size-adjust": {
+  //   ty: "TextSizeAdjust",
+  //   valid_prefixes: ["webkit", "moz", "ms"],
+  // },
+  direction: {
+    ty: "Direction",
+  },
+  // "unicode-bidi": {
+  //   ty: "UnicodeBidi",
+  // },
+  // "box-decoration-break": {
+  //   ty: "BoxDecorationBreak",
+  //   valid_prefixes: ["webkit"],
+  // },
+  // resize: {
+  //   ty: "Resize",
+  // },
+  // cursor: {
+  //   ty: "Cursor",
+  // },
+  // TODO: Hello future Zack, if you uncomment this, remember to uncomment the corresponding value in FallbackHandler in prefix_handler.zig :)
+  // "caret-color": {
+  //   ty: "ColorOrAuto",
+  // },
+  // "caret-shape": {
+  //   ty: "CaretShape",
+  // },
+  // TODO: Hello future Zack, if you uncomment this, remember to uncomment the corresponding value in FallbackHandler in prefix_handler.zig :)
+  // caret: {
+  //   ty: "Caret",
+  //   shorthand: true,
+  // },
+  // "user-select": {
+  //   ty: "UserSelect",
+  //   valid_prefixes: ["webkit", "moz", "ms"],
+  // },
+  // "accent-color": {
+  //   ty: "ColorOrAuto",
+  // },
+  // appearance: {
+  //   ty: "Appearance",
+  //   valid_prefixes: ["webkit", "moz", "ms"],
+  // },
+  // "list-style-type": {
+  //   ty: "ListStyleType",
+  // },
+  // "list-style-image": {
+  //   ty: "Image",
+  // },
+  // "list-style-position": {
+  //   ty: "ListStylePosition",
+  // },
+  // "list-style": {
+  //   ty: "ListStyle",
+  //   shorthand: true,
+  // },
+  // "marker-side": {
+  //   ty: "MarkerSide",
+  // },
+  composes: {
+    ty: "Composes",
+    conditional: { css_modules: true },
+  },
+  // TODO: Hello future Zack, if you uncomment this, remember to uncomment the corresponding value in FallbackHandler in prefix_handler.zig :)
+  // fill: {
+  //   ty: "SVGPaint",
+  // },
+  // "fill-rule": {
+  //   ty: "FillRule",
+  // },
+  // "fill-opacity": {
+  //   ty: "AlphaValue",
+  // },
+  // TODO: Hello future Zack, if you uncomment this, remember to uncomment the corresponding value in FallbackHandler in prefix_handler.zig :)
+  // stroke: {
+  //   ty: "SVGPaint",
+  // },
+  // "stroke-opacity": {
+  //   ty: "AlphaValue",
+  // },
+  // "stroke-width": {
+  //   ty: "LengthPercentage",
+  // },
+  // "stroke-linecap": {
+  //   ty: "StrokeLinecap",
+  // },
+  // "stroke-linejoin": {
+  //   ty: "StrokeLinejoin",
+  // },
+  // "stroke-miterlimit": {
+  //   ty: "CSSNumber",
+  // },
+  // "stroke-dasharray": {
+  //   ty: "StrokeDasharray",
+  // },
+  // "stroke-dashoffset": {
+  //   ty: "LengthPercentage",
+  // },
+  // "marker-start": {
+  //   ty: "Marker",
+  // },
+  // "marker-mid": {
+  //   ty: "Marker",
+  // },
+  // "marker-end": {
+  //   ty: "Marker",
+  // },
+  // marker: {
+  //   ty: "Marker",
+  // },
+  // "color-interpolation": {
+  //   ty: "ColorInterpolation",
+  // },
+  // "color-interpolation-filters": {
+  //   ty: "ColorInterpolation",
+  // },
+  // "color-rendering": {
+  //   ty: "ColorRendering",
+  // },
+  // "shape-rendering": {
+  //   ty: "ShapeRendering",
+  // },
+  // "text-rendering": {
+  //   ty: "TextRendering",
+  // },
+  // "image-rendering": {
+  //   ty: "ImageRendering",
+  // },
+  // "clip-path": {
+  //   ty: "ClipPath",
+  //   valid_prefixes: ["webkit"],
+  // },
+  // "clip-rule": {
+  //   ty: "FillRule",
+  // },
+  "mask-image": {
+    ty: "SmallList(Image, 1)",
+    valid_prefixes: ["webkit"],
+  },
+  "mask-mode": {
+    ty: "SmallList(MaskMode, 1)",
+  },
+  "mask-repeat": {
+    ty: "SmallList(BackgroundRepeat, 1)",
+    valid_prefixes: ["webkit"],
+  },
+  "mask-position-x": {
+    ty: "SmallList(HorizontalPosition, 1)",
+  },
+  "mask-position-y": {
+    ty: "SmallList(VerticalPosition, 1)",
+  },
+  "mask-position": {
+    ty: "SmallList(Position, 1)",
+    valid_prefixes: ["webkit"],
+  },
+  "mask-clip": {
+    ty: "SmallList(MaskClip, 1)",
+    valid_prefixes: ["webkit"],
+    eval_branch_quota: 5000,
+  },
+  "mask-origin": {
+    ty: "SmallList(GeometryBox, 1)",
+    valid_prefixes: ["webkit"],
+  },
+  "mask-size": {
+    ty: "SmallList(BackgroundSize, 1)",
+    valid_prefixes: ["webkit"],
+  },
+  "mask-composite": {
+    ty: "SmallList(MaskComposite, 1)",
+  },
+  "mask-type": {
+    ty: "MaskType",
+  },
+  mask: {
+    ty: "SmallList(Mask, 1)",
+    valid_prefixes: ["webkit"],
+    shorthand: true,
+  },
+  "mask-border-source": {
+    ty: "Image",
+  },
+  "mask-border-mode": {
+    ty: "MaskBorderMode",
+  },
+  "mask-border-slice": {
+    ty: "BorderImageSlice",
+  },
+  "mask-border-width": {
+    ty: "Rect(BorderImageSideWidth)",
+  },
+  "mask-border-outset": {
+    ty: "Rect(LengthOrNumber)",
+  },
+  "mask-border-repeat": {
+    ty: "BorderImageRepeat",
+  },
+  "mask-border": {
+    ty: "MaskBorder",
+    shorthand: true,
+  },
+  "-webkit-mask-composite": {
+    ty: "SmallList(WebKitMaskComposite, 1)",
+  },
+  "mask-source-type": {
+    ty: "SmallList(WebKitMaskSourceType, 1)",
+    valid_prefixes: ["webkit"],
+    unprefixed: false,
+  },
+  "mask-box-image": {
+    ty: "BorderImage",
+    valid_prefixes: ["webkit"],
+    unprefixed: false,
+  },
+  "mask-box-image-source": {
+    ty: "Image",
+    valid_prefixes: ["webkit"],
+    unprefixed: false,
+  },
+  "mask-box-image-slice": {
+    ty: "BorderImageSlice",
+    valid_prefixes: ["webkit"],
+    unprefixed: false,
+  },
+  "mask-box-image-width": {
+    ty: "Rect(BorderImageSideWidth)",
+    valid_prefixes: ["webkit"],
+    unprefixed: false,
+  },
+  "mask-box-image-outset": {
+    ty: "Rect(LengthOrNumber)",
+    valid_prefixes: ["webkit"],
+    unprefixed: false,
+  },
+  "mask-box-image-repeat": {
+    ty: "BorderImageRepeat",
+    valid_prefixes: ["webkit"],
+    unprefixed: false,
+  },
+  // TODO: Hello future Zack, if you uncomment this, remember to uncomment the corresponding value in FallbackHandler in prefix_handler.zig :)
+  // filter: {
+  //   ty: "FilterList",
+  //   valid_prefixes: ["webkit"],
+  // },
+  // TODO: Hello future Zack, if you uncomment this, remember to uncomment the corresponding value in FallbackHandler in prefix_handler.zig :)
+  // "backdrop-filter": {
+  //   ty: "FilterList",
+  //   valid_prefixes: ["webkit"],
+  // },
+  // "z-index": {
+  //   ty: "position.ZIndex",
+  // },
+  // "container-type": {
+  //   ty: "ContainerType",
+  // },
+  // "container-name": {
+  //   ty: "ContainerNameList",
+  // },
+  // container: {
+  //   ty: "Container",
+  //   shorthand: true,
+  // },
+  // "view-transition-name": {
+  //   ty: "CustomIdent",
+  // },
+  // "color-scheme": {
+  //   ty: "ColorScheme",
+  // },
+});
+
+function prelude() {
+  return /* zig */ `const std = @import("std");
+const bun = @import("root").bun;
+const Allocator = std.mem.Allocator;
+
+pub const css = @import("../css_parser.zig");
+
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const VendorPrefix = css.VendorPrefix;
+
+
+const PropertyImpl = @import("./properties_impl.zig").PropertyImpl;
+const PropertyIdImpl = @import("./properties_impl.zig").PropertyIdImpl;
+
+const CSSWideKeyword = css.css_properties.CSSWideKeyword;
+const UnparsedProperty = css.css_properties.custom.UnparsedProperty;
+const CustomProperty = css.css_properties.custom.CustomProperty;
+
+const css_values = css.css_values;
+const CssColor = css.css_values.color.CssColor;
+const Image = css.css_values.image.Image;
+const Length = css.css_values.length.Length;
+const LengthValue = css.css_values.length.LengthValue;
+const LengthPercentage = css_values.length.LengthPercentage;
+const LengthPercentageOrAuto = css_values.length.LengthPercentageOrAuto;
+const PropertyCategory = css.PropertyCategory;
+const LogicalGroup = css.LogicalGroup;
+const CSSNumber = css.css_values.number.CSSNumber;
+const CSSNumberFns = css.css_values.number.CSSNumberFns;
+const CSSInteger = css.css_values.number.CSSInteger;
+const CSSIntegerFns = css.css_values.number.CSSIntegerFns;
+const NumberOrPercentage = css.css_values.percentage.NumberOrPercentage;
+const Percentage = css.css_values.percentage.Percentage;
+const Angle = css.css_values.angle.Angle;
+const DashedIdentReference = css.css_values.ident.DashedIdentReference;
+const Time = css.css_values.time.Time;
+const EasingFunction = css.css_values.easing.EasingFunction;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CSSString = css.css_values.string.CSSString;
+const DashedIdent = css.css_values.ident.DashedIdent;
+const Url = css.css_values.url.Url;
+const CustomIdentList = css.css_values.ident.CustomIdentList;
+const Location = css.Location;
+const HorizontalPosition = css.css_values.position.HorizontalPosition;
+const VerticalPosition = css.css_values.position.VerticalPosition;
+const ContainerName = css.css_rules.container.ContainerName;
+
+pub const font = css.css_properties.font;
+const border = css.css_properties.border;
+const border_radius = css.css_properties.border_radius;
+const border_image = css.css_properties.border_image;
+const outline = css.css_properties.outline;
+const flex = css.css_properties.flex;
+const @"align" = css.css_properties.@"align";
+const margin_padding = css.css_properties.margin_padding;
+const transition = css.css_properties.transition;
+const animation = css.css_properties.animation;
+const transform = css.css_properties.transform;
+const text = css.css_properties.text;
+const ui = css.css_properties.ui;
+const list = css.css_properties.list;
+const css_modules = css.css_properties.css_modules;
+const svg = css.css_properties.svg;
+const shape = css.css_properties.shape;
+const masking = css.css_properties.masking;
+const background = css.css_properties.background;
+const effects = css.css_properties.effects;
+const contain = css.css_properties.contain;
+const custom = css.css_properties.custom;
+const position = css.css_properties.position;
+const box_shadow = css.css_properties.box_shadow;
+const size = css.css_properties.size;
+const overflow = css.css_properties.overflow;
+
+const BorderSideWidth = border.BorderSideWidth;
+const Size2D = css_values.size.Size2D;
+const BorderRadius = border_radius.BorderRadius;
+const Rect = css_values.rect.Rect;
+const LengthOrNumber = css_values.length.LengthOrNumber;
+const BorderImageRepeat = border_image.BorderImageRepeat;
+const BorderImageSideWidth = border_image.BorderImageSideWidth;
+const BorderImageSlice = border_image.BorderImageSlice;
+const BorderImage = border_image.BorderImage;
+const BorderColor = border.BorderColor;
+const BorderStyle = border.BorderStyle;
+const BorderWidth = border.BorderWidth;
+const BorderBlockColor = border.BorderBlockColor;
+const BorderBlockStyle = border.BorderBlockStyle;
+const BorderBlockWidth = border.BorderBlockWidth;
+const BorderInlineColor = border.BorderInlineColor;
+const BorderInlineStyle = border.BorderInlineStyle;
+const BorderInlineWidth = border.BorderInlineWidth;
+const Border = border.Border;
+const BorderTop = border.BorderTop;
+const BorderRight = border.BorderRight;
+const BorderLeft = border.BorderLeft;
+const BorderBottom = border.BorderBottom;
+const BorderBlockStart = border.BorderBlockStart;
+const BorderBlockEnd = border.BorderBlockEnd;
+const BorderInlineStart = border.BorderInlineStart;
+const BorderInlineEnd = border.BorderInlineEnd;
+const BorderBlock = border.BorderBlock;
+const BorderInline = border.BorderInline;
+const Outline = outline.Outline;
+const OutlineStyle = outline.OutlineStyle;
+const FlexDirection = flex.FlexDirection;
+const FlexWrap = flex.FlexWrap;
+const FlexFlow = flex.FlexFlow;
+const Flex = flex.Flex;
+const BoxOrient = flex.BoxOrient;
+const BoxDirection = flex.BoxDirection;
+const BoxAlign = flex.BoxAlign;
+const BoxPack = flex.BoxPack;
+const BoxLines = flex.BoxLines;
+const FlexPack = flex.FlexPack;
+const FlexItemAlign = flex.FlexItemAlign;
+const FlexLinePack = flex.FlexLinePack;
+const AlignContent = @"align".AlignContent;
+const JustifyContent = @"align".JustifyContent;
+const PlaceContent = @"align".PlaceContent;
+const AlignSelf = @"align".AlignSelf;
+const JustifySelf = @"align".JustifySelf;
+const PlaceSelf = @"align".PlaceSelf;
+const AlignItems = @"align".AlignItems;
+const JustifyItems = @"align".JustifyItems;
+const PlaceItems = @"align".PlaceItems;
+const GapValue = @"align".GapValue;
+const Gap = @"align".Gap;
+const MarginBlock = margin_padding.MarginBlock;
+const Margin = margin_padding.Margin;
+const MarginInline = margin_padding.MarginInline;
+const PaddingBlock = margin_padding.PaddingBlock;
+const PaddingInline = margin_padding.PaddingInline;
+const Padding = margin_padding.Padding;
+const ScrollMarginBlock = margin_padding.ScrollMarginBlock;
+const ScrollMarginInline = margin_padding.ScrollMarginInline;
+const ScrollMargin = margin_padding.ScrollMargin;
+const ScrollPaddingBlock = margin_padding.ScrollPaddingBlock;
+const ScrollPaddingInline = margin_padding.ScrollPaddingInline;
+const ScrollPadding = margin_padding.ScrollPadding;
+const FontWeight = font.FontWeight;
+const FontSize = font.FontSize;
+const FontStretch = font.FontStretch;
+const FontFamily = font.FontFamily;
+const FontStyle = font.FontStyle;
+const FontVariantCaps = font.FontVariantCaps;
+const LineHeight = font.LineHeight;
+const Font = font.Font;
+// const VerticalAlign = font.VerticalAlign;
+// const Transition = transition.Transition;
+// const AnimationNameList = animation.AnimationNameList;
+// const AnimationList = animation.AnimationList;
+// const AnimationIterationCount = animation.AnimationIterationCount;
+// const AnimationDirection = animation.AnimationDirection;
+// const AnimationPlayState = animation.AnimationPlayState;
+// const AnimationFillMode = animation.AnimationFillMode;
+// const AnimationComposition = animation.AnimationComposition;
+// const AnimationTimeline = animation.AnimationTimeline;
+// const AnimationRangeStart = animation.AnimationRangeStart;
+// const AnimationRangeEnd = animation.AnimationRangeEnd;
+// const AnimationRange = animation.AnimationRange;
+// const TransformList = transform.TransformList;
+// const TransformStyle = transform.TransformStyle;
+// const TransformBox = transform.TransformBox;
+// const BackfaceVisibility = transform.BackfaceVisibility;
+// const Perspective = transform.Perspective;
+// const Translate = transform.Translate;
+// const Rotate = transform.Rotate;
+// const Scale = transform.Scale;
+// const TextTransform = text.TextTransform;
+// const WhiteSpace = text.WhiteSpace;
+// const WordBreak = text.WordBreak;
+// const LineBreak = text.LineBreak;
+// const Hyphens = text.Hyphens;
+// const OverflowWrap = text.OverflowWrap;
+// const TextAlign = text.TextAlign;
+// const TextIndent = text.TextIndent;
+// const Spacing = text.Spacing;
+// const TextJustify = text.TextJustify;
+// const TextAlignLast = text.TextAlignLast;
+// const TextDecorationLine = text.TextDecorationLine;
+// const TextDecorationStyle = text.TextDecorationStyle;
+// const TextDecorationThickness = text.TextDecorationThickness;
+// const TextDecoration = text.TextDecoration;
+// const TextDecorationSkipInk = text.TextDecorationSkipInk;
+// const TextEmphasisStyle = text.TextEmphasisStyle;
+// const TextEmphasis = text.TextEmphasis;
+// const TextEmphasisPositionVertical = text.TextEmphasisPositionVertical;
+// const TextEmphasisPositionHorizontal = text.TextEmphasisPositionHorizontal;
+// const TextEmphasisPosition = text.TextEmphasisPosition;
+const TextShadow = text.TextShadow;
+// const TextSizeAdjust = text.TextSizeAdjust;
+const Direction = text.Direction;
+// const UnicodeBidi = text.UnicodeBidi;
+// const BoxDecorationBreak = text.BoxDecorationBreak;
+// const Resize = ui.Resize;
+// const Cursor = ui.Cursor;
+// const ColorOrAuto = ui.ColorOrAuto;
+// const CaretShape = ui.CaretShape;
+// const Caret = ui.Caret;
+// const UserSelect = ui.UserSelect;
+// const Appearance = ui.Appearance;
+// const ColorScheme = ui.ColorScheme;
+// const ListStyleType = list.ListStyleType;
+// const ListStylePosition = list.ListStylePosition;
+// const ListStyle = list.ListStyle;
+// const MarkerSide = list.MarkerSide;
+const Composes = css_modules.Composes;
+// const SVGPaint = svg.SVGPaint;
+// const FillRule = shape.FillRule;
+// const AlphaValue = shape.AlphaValue;
+// const StrokeLinecap = svg.StrokeLinecap;
+// const StrokeLinejoin = svg.StrokeLinejoin;
+// const StrokeDasharray = svg.StrokeDasharray;
+// const Marker = svg.Marker;
+// const ColorInterpolation = svg.ColorInterpolation;
+// const ColorRendering = svg.ColorRendering;
+// const ShapeRendering = svg.ShapeRendering;
+// const TextRendering = svg.TextRendering;
+// const ImageRendering = svg.ImageRendering;
+const ClipPath = masking.ClipPath;
+const MaskMode = masking.MaskMode;
+const MaskClip = masking.MaskClip;
+const GeometryBox = masking.GeometryBox;
+const MaskComposite = masking.MaskComposite;
+const MaskType = masking.MaskType;
+const Mask = masking.Mask;
+const MaskBorderMode = masking.MaskBorderMode;
+const MaskBorder = masking.MaskBorder;
+const WebKitMaskComposite = masking.WebKitMaskComposite;
+const WebKitMaskSourceType = masking.WebKitMaskSourceType;
+const BackgroundRepeat = background.BackgroundRepeat;
+const BackgroundSize = background.BackgroundSize;
+// const FilterList = effects.FilterList;
+// const ContainerType = contain.ContainerType;
+// const Container = contain.Container;
+// const ContainerNameList = contain.ContainerNameList;
+const CustomPropertyName = custom.CustomPropertyName;
+const display = css.css_properties.display;
+
+const Position = position.Position;
+
+const Result = css.Result;
+
+const BabyList = bun.BabyList;
+const ArrayList = std.ArrayListUnmanaged;
+const SmallList = css.SmallList;
+
+`;
+}
diff --git a/src/css/properties/list.zig b/src/css/properties/list.zig
new file mode 100644
index 0000000000..9c6e488a4f
--- /dev/null
+++ b/src/css/properties/list.zig
@@ -0,0 +1,86 @@
+const std = @import("std");
+const bun = @import("root").bun;
+const Allocator = std.mem.Allocator;
+const ArrayList = std.ArrayListUnmanaged;
+
+pub const css = @import("../css_parser.zig");
+
+const SmallList = css.SmallList;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const Error = css.Error;
+
+const ContainerName = css.css_rules.container.ContainerName;
+
+const LengthPercentage = css.css_values.length.LengthPercentage;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CSSString = css.css_values.string.CSSString;
+const CSSNumber = css.css_values.number.CSSNumber;
+const LengthPercentageOrAuto = css.css_values.length.LengthPercentageOrAuto;
+const Size2D = css.css_values.size.Size2D;
+const DashedIdent = css.css_values.ident.DashedIdent;
+const Image = css.css_values.image.Image;
+const CssColor = css.css_values.color.CssColor;
+const Ratio = css.css_values.ratio.Ratio;
+const Length = css.css_values.length.LengthValue;
+const Rect = css.css_values.rect.Rect;
+const NumberOrPercentage = css.css_values.percentage.NumberOrPercentage;
+const CustomIdentList = css.css_values.ident.CustomIdentList;
+const Angle = css.css_values.angle.Angle;
+const Url = css.css_values.url.Url;
+
+/// A value for the [list-style-type](https://www.w3.org/TR/2020/WD-css-lists-3-20201117/#text-markers) property.
+pub const ListStyleType = union(enum) {
+    /// No marker.
+    none,
+    /// An explicit marker string.
+    string: CSSString,
+    /// A named counter style.
+    counter_style: CounterStyle,
+};
+
+/// A [counter-style](https://www.w3.org/TR/css-counter-styles-3/#typedef-counter-style) name.
+pub const CounterStyle = union(enum) {
+    /// A predefined counter style name.
+    predefined: PredefinedCounterStyle,
+    /// A custom counter style name.
+    name: CustomIdent,
+    /// An inline `symbols()` definition.
+    symbols: Symbols,
+
+    const Symbols = struct {
+        /// The counter system.
+        system: SymbolsType,
+        /// The symbols.
+        symbols: ArrayList(Symbol),
+    };
+};
+
+/// A single [symbol](https://www.w3.org/TR/css-counter-styles-3/#funcdef-symbols) as used in the
+/// `symbols()` function.
+///
+/// See [CounterStyle](CounterStyle).
+const Symbol = union(enum) {
+    /// A string.
+    string: CSSString,
+    /// An image.
+    image: Image,
+};
+
+/// A [predefined counter](https://www.w3.org/TR/css-counter-styles-3/#predefined-counters) style.
+pub const PredefinedCounterStyle = @compileError(css.todo_stuff.depth);
+
+/// A [`<symbols-type>`](https://www.w3.org/TR/css-counter-styles-3/#typedef-symbols-type) value,
+/// as used in the `symbols()` function.
+///
+/// See [CounterStyle](CounterStyle).
+pub const SymbolsType = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A value for the [list-style-position](https://www.w3.org/TR/2020/WD-css-lists-3-20201117/#list-style-position-property) property.
+pub const ListStylePosition = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A value for the [list-style](https://www.w3.org/TR/2020/WD-css-lists-3-20201117/#list-style-property) shorthand property.
+pub const ListStyle = @compileError(css.todo_stuff.depth);
+
+/// A value for the [marker-side](https://www.w3.org/TR/2020/WD-css-lists-3-20201117/#marker-side) property.
+pub const MarkerSide = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
diff --git a/src/css/properties/margin_padding.zig b/src/css/properties/margin_padding.zig
new file mode 100644
index 0000000000..523a674d17
--- /dev/null
+++ b/src/css/properties/margin_padding.zig
@@ -0,0 +1,846 @@
+const std = @import("std");
+const bun = @import("root").bun;
+const Allocator = std.mem.Allocator;
+const ArrayList = std.ArrayListUnmanaged;
+
+pub const css = @import("../css_parser.zig");
+const Property = css.Property;
+const PropertyId = css.PropertyId;
+const PropertyIdTag = css.PropertyIdTag;
+const PropertyCategory = css.logical.PropertyCategory;
+
+const SmallList = css.SmallList;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const Error = css.Error;
+
+const ContainerName = css.css_rules.container.ContainerName;
+
+const LengthPercentage = css.css_values.length.LengthPercentage;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CSSString = css.css_values.string.CSSString;
+const CSSNumber = css.css_values.number.CSSNumber;
+const LengthPercentageOrAuto = css.css_values.length.LengthPercentageOrAuto;
+const Size2D = css.css_values.size.Size2D;
+const DashedIdent = css.css_values.ident.DashedIdent;
+const Image = css.css_values.image.Image;
+const CssColor = css.css_values.color.CssColor;
+const Ratio = css.css_values.ratio.Ratio;
+const Length = css.css_values.length.LengthValue;
+const Rect = css.css_values.rect.Rect;
+const NumberOrPercentage = css.css_values.percentage.NumberOrPercentage;
+const CustomIdentList = css.css_values.ident.CustomIdentList;
+const Angle = css.css_values.angle.Angle;
+const Url = css.css_values.url.Url;
+
+/// A value for the [inset](https://drafts.csswg.org/css-logical/#propdef-inset) shorthand property.
+pub const Inset = struct {
+    top: LengthPercentageOrAuto,
+    right: LengthPercentageOrAuto,
+    bottom: LengthPercentageOrAuto,
+    left: LengthPercentageOrAuto,
+
+    // TODO: bring this back
+    // pub usingnamespace css.DefineShorthand(@This(), css.PropertyIdTag.inset);
+    pub usingnamespace css.DefineRectShorthand(@This(), LengthPercentageOrAuto);
+
+    pub const PropertyFieldMap = .{
+        .top = css.PropertyIdTag.top,
+        .right = css.PropertyIdTag.right,
+        .bottom = css.PropertyIdTag.bottom,
+        .left = css.PropertyIdTag.left,
+    };
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+/// A value for the [inset-block](https://drafts.csswg.org/css-logical/#propdef-inset-block) shorthand property.
+pub const InsetBlock = struct {
+    /// The block start value.
+    block_start: LengthPercentageOrAuto,
+    /// The block end value.
+    block_end: LengthPercentageOrAuto,
+
+    // TODO: bring this back
+    // pub usingnamespace css.DefineShorthand(@This(), css.PropertyIdTag.@"inset-block");
+    pub usingnamespace css.DefineSizeShorthand(@This(), LengthPercentageOrAuto);
+
+    pub const PropertyFieldMap = .{
+        .block_start = css.PropertyIdTag.@"inset-block-start",
+        .block_end = css.PropertyIdTag.@"inset-block-end",
+    };
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+/// A value for the [inset-inline](https://drafts.csswg.org/css-logical/#propdef-inset-inline) shorthand property.
+pub const InsetInline = struct {
+    /// The inline start value.
+    inline_start: LengthPercentageOrAuto,
+    /// The inline end value.
+    inline_end: LengthPercentageOrAuto,
+
+    pub const PropertyFieldMap = .{
+        .inline_start = css.PropertyIdTag.@"inset-inline-start",
+        .inline_end = css.PropertyIdTag.@"inset-inline-end",
+    };
+
+    // TODO: bring this back
+    // pub usingnamespace css.DefineShorthand(@This(), css.PropertyIdTag.@"inset-inline");
+    pub usingnamespace css.DefineSizeShorthand(@This(), LengthPercentageOrAuto);
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+/// A value for the [margin-block](https://drafts.csswg.org/css-logical/#propdef-margin-block) shorthand property.
+pub const MarginBlock = struct {
+    /// The block start value.
+    block_start: LengthPercentageOrAuto,
+    /// The block end value.
+    block_end: LengthPercentageOrAuto,
+
+    // TODO: bring this back
+    // pub usingnamespace css.DefineShorthand(@This(), css.PropertyIdTag.@"margin-block");
+    pub usingnamespace css.DefineSizeShorthand(@This(), LengthPercentageOrAuto);
+
+    pub const PropertyFieldMap = .{
+        .block_start = css.PropertyIdTag.@"margin-block-start",
+        .block_end = css.PropertyIdTag.@"margin-block-end",
+    };
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+/// A value for the [margin-inline](https://drafts.csswg.org/css-logical/#propdef-margin-inline) shorthand property.
+pub const MarginInline = struct {
+    /// The inline start value.
+    inline_start: LengthPercentageOrAuto,
+    /// The inline end value.
+    inline_end: LengthPercentageOrAuto,
+
+    // TODO: bring this back
+    // pub usingnamespace css.DefineShorthand(@This(), css.PropertyIdTag.@"margin-inline");
+    pub usingnamespace css.DefineSizeShorthand(@This(), LengthPercentageOrAuto);
+
+    pub const PropertyFieldMap = .{
+        .inline_start = css.PropertyIdTag.@"margin-inline-start",
+        .inline_end = css.PropertyIdTag.@"margin-inline-end",
+    };
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+/// A value for the [margin](https://drafts.csswg.org/css-box-4/#propdef-margin) shorthand property.
+pub const Margin = struct {
+    top: LengthPercentageOrAuto,
+    right: LengthPercentageOrAuto,
+    bottom: LengthPercentageOrAuto,
+    left: LengthPercentageOrAuto,
+
+    // TODO: bring this back
+    // pub usingnamespace css.DefineShorthand(@This(), css.PropertyIdTag.margin);
+    pub usingnamespace css.DefineRectShorthand(@This(), LengthPercentageOrAuto);
+
+    pub const PropertyFieldMap = .{
+        .top = css.PropertyIdTag.@"margin-top",
+        .right = css.PropertyIdTag.@"margin-right",
+        .bottom = css.PropertyIdTag.@"margin-bottom",
+        .left = css.PropertyIdTag.@"margin-left",
+    };
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+/// A value for the [padding-block](https://drafts.csswg.org/css-logical/#propdef-padding-block) shorthand property.
+pub const PaddingBlock = struct {
+    /// The block start value.
+    block_start: LengthPercentageOrAuto,
+    /// The block end value.
+    block_end: LengthPercentageOrAuto,
+
+    // TODO: bring this back
+    // pub usingnamespace css.DefineShorthand(@This(), css.PropertyIdTag.@"padding-block");
+    pub usingnamespace css.DefineSizeShorthand(@This(), LengthPercentageOrAuto);
+
+    pub const PropertyFieldMap = .{
+        .block_start = css.PropertyIdTag.@"padding-block-start",
+        .block_end = css.PropertyIdTag.@"padding-block-end",
+    };
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+/// A value for the [padding-inline](https://drafts.csswg.org/css-logical/#propdef-padding-inline) shorthand property.
+pub const PaddingInline = struct {
+    /// The inline start value.
+    inline_start: LengthPercentageOrAuto,
+    /// The inline end value.
+    inline_end: LengthPercentageOrAuto,
+
+    // TODO: bring this back
+    // pub usingnamespace css.DefineShorthand(@This(), css.PropertyIdTag.@"padding-inline");
+    pub usingnamespace css.DefineSizeShorthand(@This(), LengthPercentageOrAuto);
+
+    pub const PropertyFieldMap = .{
+        .inline_start = css.PropertyIdTag.@"padding-inline-start",
+        .inline_end = css.PropertyIdTag.@"padding-inline-end",
+    };
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+/// A value for the [padding](https://drafts.csswg.org/css-box-4/#propdef-padding) shorthand property.
+pub const Padding = struct {
+    top: LengthPercentageOrAuto,
+    right: LengthPercentageOrAuto,
+    bottom: LengthPercentageOrAuto,
+    left: LengthPercentageOrAuto,
+
+    // TODO: bring this back
+    // pub usingnamespace css.DefineShorthand(@This(), css.PropertyIdTag.padding);
+    pub usingnamespace css.DefineRectShorthand(@This(), LengthPercentageOrAuto);
+
+    pub const PropertyFieldMap = .{
+        .top = css.PropertyIdTag.@"padding-top",
+        .right = css.PropertyIdTag.@"padding-right",
+        .bottom = css.PropertyIdTag.@"padding-bottom",
+        .left = css.PropertyIdTag.@"padding-left",
+    };
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+/// A value for the [scroll-margin-block](https://drafts.csswg.org/css-scroll-snap/#propdef-scroll-margin-block) shorthand property.
+pub const ScrollMarginBlock = struct {
+    /// The block start value.
+    block_start: LengthPercentageOrAuto,
+    /// The block end value.
+    block_end: LengthPercentageOrAuto,
+
+    // TODO: bring this back
+    // pub usingnamespace css.DefineShorthand(@This(), css.PropertyIdTag.@"scroll-margin-block");
+    pub usingnamespace css.DefineSizeShorthand(@This(), LengthPercentageOrAuto);
+
+    pub const PropertyFieldMap = .{
+        .block_start = css.PropertyIdTag.@"scroll-margin-block-start",
+        .block_end = css.PropertyIdTag.@"scroll-margin-block-end",
+    };
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+/// A value for the [scroll-margin-inline](https://drafts.csswg.org/css-scroll-snap/#propdef-scroll-margin-inline) shorthand property.
+pub const ScrollMarginInline = struct {
+    /// The inline start value.
+    inline_start: LengthPercentageOrAuto,
+    /// The inline end value.
+    inline_end: LengthPercentageOrAuto,
+
+    // TODO: bring this back
+    // pub usingnamespace css.DefineShorthand(@This(), css.PropertyIdTag.@"scroll-margin-inline");
+    pub usingnamespace css.DefineSizeShorthand(@This(), LengthPercentageOrAuto);
+
+    pub const PropertyFieldMap = .{
+        .inline_start = css.PropertyIdTag.@"scroll-margin-inline-start",
+        .inline_end = css.PropertyIdTag.@"scroll-margin-inline-end",
+    };
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+/// A value for the [scroll-margin](https://drafts.csswg.org/css-scroll-snap/#scroll-margin) shorthand property.
+pub const ScrollMargin = struct {
+    top: LengthPercentageOrAuto,
+    right: LengthPercentageOrAuto,
+    bottom: LengthPercentageOrAuto,
+    left: LengthPercentageOrAuto,
+
+    // TODO: bring this back
+    // pub usingnamespace css.DefineShorthand(@This(), css.PropertyIdTag.@"scroll-margin");
+    pub usingnamespace css.DefineRectShorthand(@This(), LengthPercentageOrAuto);
+
+    pub const PropertyFieldMap = .{
+        .top = css.PropertyIdTag.@"scroll-margin-top",
+        .right = css.PropertyIdTag.@"scroll-margin-right",
+        .bottom = css.PropertyIdTag.@"scroll-margin-bottom",
+        .left = css.PropertyIdTag.@"scroll-margin-left",
+    };
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+/// A value for the [scroll-padding-block](https://drafts.csswg.org/css-scroll-snap/#propdef-scroll-padding-block) shorthand property.
+pub const ScrollPaddingBlock = struct {
+    /// The block start value.
+    block_start: LengthPercentageOrAuto,
+    /// The block end value.
+    block_end: LengthPercentageOrAuto,
+
+    // TODO: bring this back
+    // pub usingnamespace css.DefineShorthand(@This(), css.PropertyIdTag.@"scroll-padding-block");
+    pub usingnamespace css.DefineSizeShorthand(@This(), LengthPercentageOrAuto);
+
+    pub const PropertyFieldMap = .{
+        .block_start = css.PropertyIdTag.@"scroll-padding-block-start",
+        .block_end = css.PropertyIdTag.@"scroll-padding-block-end",
+    };
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+/// A value for the [scroll-padding-inline](https://drafts.csswg.org/css-scroll-snap/#propdef-scroll-padding-inline) shorthand property.
+pub const ScrollPaddingInline = struct {
+    /// The inline start value.
+    inline_start: LengthPercentageOrAuto,
+    /// The inline end value.
+    inline_end: LengthPercentageOrAuto,
+
+    // TODO: bring this back
+    // pub usingnamespace css.DefineShorthand(@This(), css.PropertyIdTag.@"scroll-padding-inline");
+    pub usingnamespace css.DefineSizeShorthand(@This(), LengthPercentageOrAuto);
+
+    pub const PropertyFieldMap = .{
+        .inline_start = css.PropertyIdTag.@"scroll-padding-inline-start",
+        .inline_end = css.PropertyIdTag.@"scroll-padding-inline-end",
+    };
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+/// A value for the [scroll-padding](https://drafts.csswg.org/css-scroll-snap/#scroll-padding) shorthand property.
+pub const ScrollPadding = struct {
+    top: LengthPercentageOrAuto,
+    right: LengthPercentageOrAuto,
+    bottom: LengthPercentageOrAuto,
+    left: LengthPercentageOrAuto,
+
+    // TODO: bring this back
+    // pub usingnamespace css.DefineShorthand(@This(), css.PropertyIdTag.@"scroll-padding");
+    pub usingnamespace css.DefineRectShorthand(@This(), LengthPercentageOrAuto);
+
+    pub const PropertyFieldMap = .{
+        .top = css.PropertyIdTag.@"scroll-padding-top",
+        .right = css.PropertyIdTag.@"scroll-padding-right",
+        .bottom = css.PropertyIdTag.@"scroll-padding-bottom",
+        .left = css.PropertyIdTag.@"scroll-padding-left",
+    };
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+pub const MarginHandler = NewSizeHandler(
+    PropertyIdTag.@"margin-top",
+    PropertyIdTag.@"margin-bottom",
+    PropertyIdTag.@"margin-left",
+    PropertyIdTag.@"margin-right",
+    PropertyIdTag.@"margin-block-start",
+    PropertyIdTag.@"margin-block-end",
+    PropertyIdTag.@"margin-inline-start",
+    PropertyIdTag.@"margin-inline-end",
+    PropertyIdTag.margin,
+    PropertyIdTag.@"margin-block",
+    PropertyIdTag.@"margin-inline",
+    PropertyCategory.physical,
+    .{
+        .feature = css.Feature.logical_margin,
+        .shorthand_feature = css.Feature.logical_margin_shorthand,
+    },
+);
+
+pub const PaddingHandler = NewSizeHandler(
+    PropertyIdTag.@"padding-top",
+    PropertyIdTag.@"padding-bottom",
+    PropertyIdTag.@"padding-left",
+    PropertyIdTag.@"padding-right",
+    PropertyIdTag.@"padding-block-start",
+    PropertyIdTag.@"padding-block-end",
+    PropertyIdTag.@"padding-inline-start",
+    PropertyIdTag.@"padding-inline-end",
+    PropertyIdTag.padding,
+    PropertyIdTag.@"padding-block",
+    PropertyIdTag.@"padding-inline",
+    PropertyCategory.physical,
+    .{
+        .feature = css.Feature.logical_padding,
+        .shorthand_feature = css.Feature.logical_padding_shorthand,
+    },
+);
+
+pub const ScrollMarginHandler = NewSizeHandler(
+    PropertyIdTag.@"scroll-margin-top",
+    PropertyIdTag.@"scroll-margin-bottom",
+    PropertyIdTag.@"scroll-margin-left",
+    PropertyIdTag.@"scroll-margin-right",
+    PropertyIdTag.@"scroll-margin-block-start",
+    PropertyIdTag.@"scroll-margin-block-end",
+    PropertyIdTag.@"scroll-margin-inline-start",
+    PropertyIdTag.@"scroll-margin-inline-end",
+    PropertyIdTag.@"scroll-margin",
+    PropertyIdTag.@"scroll-margin-block",
+    PropertyIdTag.@"scroll-margin-inline",
+    PropertyCategory.physical,
+    null,
+);
+
+pub const InsetHandler = NewSizeHandler(
+    PropertyIdTag.top,
+    PropertyIdTag.bottom,
+    PropertyIdTag.left,
+    PropertyIdTag.right,
+    PropertyIdTag.@"inset-block-start",
+    PropertyIdTag.@"inset-block-end",
+    PropertyIdTag.@"inset-inline-start",
+    PropertyIdTag.@"inset-inline-end",
+    PropertyIdTag.inset,
+    PropertyIdTag.@"inset-block",
+    PropertyIdTag.@"inset-inline",
+    PropertyCategory.physical,
+    .{
+        .feature = css.Feature.logical_inset,
+        .shorthand_feature = css.Feature.logical_inset,
+    },
+);
+
+pub fn NewSizeHandler(
+    comptime top_prop: css.PropertyIdTag,
+    comptime bottom_prop: css.PropertyIdTag,
+    comptime left_prop: css.PropertyIdTag,
+    comptime right_prop: css.PropertyIdTag,
+    comptime block_start_prop: css.PropertyIdTag,
+    comptime block_end_prop: css.PropertyIdTag,
+    comptime inline_start_prop: css.PropertyIdTag,
+    comptime inline_end_prop: css.PropertyIdTag,
+    comptime shorthand_prop: css.PropertyIdTag,
+    comptime block_shorthand: css.PropertyIdTag,
+    comptime inline_shorthand: css.PropertyIdTag,
+    comptime shorthand_category: css.logical.PropertyCategory,
+    comptime shorthand_extra: ?struct { feature: css.compat.Feature, shorthand_feature: css.compat.Feature },
+) type {
+    return struct {
+        top: ?LengthPercentageOrAuto = null,
+        bottom: ?LengthPercentageOrAuto = null,
+        left: ?LengthPercentageOrAuto = null,
+        right: ?LengthPercentageOrAuto = null,
+        block_start: ?Property = null,
+        block_end: ?Property = null,
+        inline_start: ?Property = null,
+        inline_end: ?Property = null,
+        has_any: bool = false,
+        category: css.logical.PropertyCategory = css.logical.PropertyCategory.default(),
+
+        pub fn handleProperty(
+            this: *@This(),
+            property: *const Property,
+            dest: *css.DeclarationList,
+            context: *css.PropertyHandlerContext,
+        ) bool {
+            switch (@as(PropertyIdTag, property.*)) {
+                top_prop => this.propertyHelper("top", top_prop.valueType(), &@field(property, @tagName(top_prop)), PropertyCategory.physical, dest, context),
+                bottom_prop => this.propertyHelper("bottom", bottom_prop.valueType(), &@field(property, @tagName(bottom_prop)), PropertyCategory.physical, dest, context),
+                left_prop => this.propertyHelper("left", left_prop.valueType(), &@field(property, @tagName(left_prop)), PropertyCategory.physical, dest, context),
+                right_prop => this.propertyHelper("right", right_prop.valueType(), &@field(property, @tagName(right_prop)), PropertyCategory.physical, dest, context),
+                block_start_prop => {
+                    this.flushHelper("block_start", block_start_prop.valueType(), &@field(property, @tagName(block_start_prop)), PropertyCategory.logical, dest, context);
+                    this.logicalPropertyHelper("block_start", property.deepClone(context.allocator), dest, context);
+                },
+                block_end_prop => {
+                    this.flushHelper("block_end", block_end_prop.valueType(), &@field(property, @tagName(block_end_prop)), PropertyCategory.logical, dest, context);
+                    this.logicalPropertyHelper("block_end", property.deepClone(context.allocator), dest, context);
+                },
+                inline_start_prop => {
+                    this.flushHelper("inline_start", inline_start_prop.valueType(), &@field(property, @tagName(inline_start_prop)), PropertyCategory.logical, dest, context);
+                    this.logicalPropertyHelper("inline_start", property.deepClone(context.allocator), dest, context);
+                },
+                inline_end_prop => {
+                    this.flushHelper("inline_end", inline_end_prop.valueType(), &@field(property, @tagName(inline_end_prop)), PropertyCategory.logical, dest, context);
+                    this.logicalPropertyHelper("inline_end", property.deepClone(context.allocator), dest, context);
+                },
+                block_shorthand => {
+                    const val = &@field(property, @tagName(block_shorthand));
+                    this.flushHelper("block_start", block_start_prop.valueType(), &val.block_start, .logical, dest, context);
+                    this.flushHelper("block_end", block_end_prop.valueType(), &val.block_end, .logical, dest, context);
+                    this.logicalPropertyHelper("block_start", @unionInit(Property, @tagName(block_start_prop), val.block_start.deepClone(context.allocator)), dest, context);
+                    this.logicalPropertyHelper("block_end", @unionInit(Property, @tagName(block_end_prop), val.block_end.deepClone(context.allocator)), dest, context);
+                },
+                inline_shorthand => {
+                    const val = &@field(property, @tagName(inline_shorthand));
+                    this.flushHelper("inline_start", inline_start_prop.valueType(), &val.inline_start, .logical, dest, context);
+                    this.flushHelper("inline_end", inline_end_prop.valueType(), &val.inline_end, .logical, dest, context);
+                    this.logicalPropertyHelper("inline_start", @unionInit(Property, @tagName(inline_start_prop), val.inline_start.deepClone(context.allocator)), dest, context);
+                    this.logicalPropertyHelper("inline_end", @unionInit(Property, @tagName(inline_end_prop), val.inline_end.deepClone(context.allocator)), dest, context);
+                },
+                shorthand_prop => {
+                    const val = &@field(property, @tagName(shorthand_prop));
+                    this.flushHelper("top", top_prop.valueType(), &val.top, shorthand_category, dest, context);
+                    this.flushHelper("right", right_prop.valueType(), &val.right, shorthand_category, dest, context);
+                    this.flushHelper("bottom", bottom_prop.valueType(), &val.bottom, shorthand_category, dest, context);
+                    this.flushHelper("left", left_prop.valueType(), &val.left, shorthand_category, dest, context);
+                    this.top = val.top.deepClone(context.allocator);
+                    this.right = val.right.deepClone(context.allocator);
+                    this.bottom = val.bottom.deepClone(context.allocator);
+                    this.left = val.left.deepClone(context.allocator);
+                    this.block_start = null;
+                    this.block_end = null;
+                    this.inline_start = null;
+                    this.inline_end = null;
+                    this.has_any = true;
+                },
+                css.PropertyIdTag.unparsed => {
+                    switch (property.unparsed.property_id) {
+                        top_prop, bottom_prop, left_prop, right_prop, block_start_prop, block_end_prop, inline_start_prop, inline_end_prop, block_shorthand, inline_shorthand, shorthand_prop => {
+                            // Even if we weren't able to parse the value (e.g. due to var() references),
+                            // we can still add vendor prefixes to the property itself.
+                            switch (property.unparsed.property_id) {
+                                block_start_prop => this.logicalPropertyHelper("block_start", property.deepClone(context.allocator), dest, context),
+                                block_end_prop => this.logicalPropertyHelper("block_end", property.deepClone(context.allocator), dest, context),
+                                inline_start_prop => this.logicalPropertyHelper("inline_start", property.deepClone(context.allocator), dest, context),
+                                inline_end_prop => this.logicalPropertyHelper("inline_end", property.deepClone(context.allocator), dest, context),
+                                else => {
+                                    this.flush(dest, context);
+                                    dest.append(context.allocator, property.deepClone(context.allocator)) catch unreachable;
+                                },
+                            }
+                        },
+                        else => return false,
+                    }
+                },
+                else => return false,
+            }
+
+            return true;
+        }
+
+        pub fn finalize(this: *@This(), dest: *css.DeclarationList, context: *css.PropertyHandlerContext) void {
+            this.flush(dest, context);
+        }
+
+        fn flushHelper(
+            this: *@This(),
+            comptime field: []const u8,
+            comptime T: type,
+            val: *const T,
+            comptime category: PropertyCategory,
+            dest: *css.DeclarationList,
+            context: *css.PropertyHandlerContext,
+        ) void {
+            // If the category changes betweet logical and physical,
+            // or if the value contains syntax that isn't supported across all targets,
+            // preserve the previous value as a fallback.
+            if (category != this.category or (@field(this, field) != null and context.targets.browsers != null and !val.isCompatible(context.targets.browsers.?))) {
+                this.flush(dest, context);
+            }
+        }
+
+        fn propertyHelper(
+            this: *@This(),
+            comptime field: []const u8,
+            comptime T: type,
+            val: *const T,
+            comptime category: PropertyCategory,
+            dest: *css.DeclarationList,
+            context: *css.PropertyHandlerContext,
+        ) void {
+            this.flushHelper(field, T, val, category, dest, context);
+            @field(this, field) = val.deepClone(context.allocator);
+            this.category = category;
+            this.has_any = true;
+        }
+
+        fn logicalPropertyHelper(
+            this: *@This(),
+            comptime field: []const u8,
+            val: css.Property,
+            dest: *css.DeclarationList,
+            context: *css.PropertyHandlerContext,
+        ) void {
+            // Assume unparsed properties might contain unsupported syntax that we must preserve as a fallback.
+            if (this.category != PropertyCategory.logical or (@field(this, field) != null and val == .unparsed)) {
+                this.flush(dest, context);
+            }
+
+            if (@field(this, field)) |*p| p.deinit(context.allocator);
+            @field(this, field) = val;
+            this.category = PropertyCategory.logical;
+            this.has_any = true;
+        }
+
+        fn flush(this: *@This(), dest: *css.DeclarationList, context: *css.PropertyHandlerContext) void {
+            if (!this.has_any) return;
+
+            this.has_any = false;
+
+            const top = bun.take(&this.top);
+            const bottom = bun.take(&this.bottom);
+            const left = bun.take(&this.left);
+            const right = bun.take(&this.right);
+            const logical_supported = if (comptime shorthand_extra != null) !context.shouldCompileLogical(shorthand_extra.?.feature) else true;
+
+            if ((shorthand_category != .logical or logical_supported) and top != null and bottom != null and left != null and right != null) {
+                dest.append(
+                    context.allocator,
+                    @unionInit(
+                        Property,
+                        @tagName(shorthand_prop),
+                        .{
+                            .top = top.?,
+                            .bottom = bottom.?,
+                            .left = left.?,
+                            .right = right.?,
+                        },
+                    ),
+                ) catch bun.outOfMemory();
+            } else {
+                if (top) |t| {
+                    dest.append(
+                        context.allocator,
+                        @unionInit(Property, @tagName(top_prop), t),
+                    ) catch bun.outOfMemory();
+                }
+
+                if (bottom) |b| {
+                    dest.append(
+                        context.allocator,
+                        @unionInit(Property, @tagName(bottom_prop), b),
+                    ) catch bun.outOfMemory();
+                }
+
+                if (left) |b| {
+                    dest.append(
+                        context.allocator,
+                        @unionInit(Property, @tagName(left_prop), b),
+                    ) catch bun.outOfMemory();
+                }
+
+                if (right) |b| {
+                    dest.append(
+                        context.allocator,
+                        @unionInit(Property, @tagName(right_prop), b),
+                    ) catch bun.outOfMemory();
+                }
+            }
+
+            var block_start = bun.take(&this.block_start);
+            var block_end = bun.take(&this.block_end);
+            var inline_start = bun.take(&this.inline_start);
+            var inline_end = bun.take(&this.inline_end);
+
+            if (logical_supported) {
+                this.logicalSideHelper(&block_start, &block_end, "block_start", "block_end", block_shorthand, block_start_prop, block_end_prop, logical_supported, dest, context);
+            } else {
+                this.prop(&block_start, block_start_prop, top_prop, dest, context);
+                this.prop(&block_end, block_end_prop, bottom_prop, dest, context);
+            }
+
+            if (logical_supported) {
+                this.logicalSideHelper(&inline_start, &inline_end, "inline_start", "inline_end", inline_shorthand, inline_start_prop, inline_end_prop, logical_supported, dest, context);
+            } else if (inline_start != null or inline_end != null) {
+                if (inline_start != null and inline_start.? == @field(Property, @tagName(inline_start_prop)) and inline_end != null and inline_end.? == @field(Property, @tagName(inline_end_prop)) and
+                    @field(inline_start.?, @tagName(inline_start_prop)).eql(&@field(inline_end.?, @tagName(inline_end_prop))))
+                {
+                    this.prop(&inline_start, inline_start_prop, left_prop, dest, context);
+                    this.prop(&inline_end, inline_end_prop, right_prop, dest, context);
+                } else {
+                    this.logicalPropHelper(&inline_start, inline_start_prop, left_prop, right_prop, dest, context);
+                    this.logicalPropHelper(&inline_end, inline_end_prop, right_prop, left_prop, dest, context);
+                }
+            }
+        }
+
+        inline fn logicalPropHelper(
+            this: *@This(),
+            val: *?Property,
+            comptime logical: css.PropertyIdTag,
+            comptime ltr: css.PropertyIdTag,
+            comptime rtl: css.PropertyIdTag,
+            dest: *css.DeclarationList,
+            context: *css.PropertyHandlerContext,
+        ) void {
+            _ = this; // autofix
+            _ = dest; // autofix
+            if (val.*) |*_v| {
+                if (@as(css.PropertyIdTag, _v.*) == logical) {
+                    const v = &@field(_v, @tagName(logical));
+                    context.addLogicalRule(
+                        context.allocator,
+                        @unionInit(Property, @tagName(ltr), v.deepClone(context.allocator)),
+                        @unionInit(Property, @tagName(rtl), v.deepClone(context.allocator)),
+                    );
+                } else if (_v.* == .unparsed) {
+                    const v = &_v.unparsed;
+                    context.addLogicalRule(
+                        context.allocator,
+                        Property{
+                            .unparsed = v.withPropertyId(context.allocator, ltr),
+                        },
+                        Property{
+                            .unparsed = v.withPropertyId(context.allocator, rtl),
+                        },
+                    );
+                }
+            }
+        }
+
+        inline fn logicalSideHelper(
+            this: *@This(),
+            start: *?Property,
+            end: *?Property,
+            comptime start_name: []const u8,
+            comptime end_name: []const u8,
+            comptime shorthand_property: css.PropertyIdTag,
+            comptime start_prop: css.PropertyIdTag,
+            comptime end_prop: css.PropertyIdTag,
+            logical_supported: bool,
+            dest: *css.DeclarationList,
+            context: *css.PropertyHandlerContext,
+        ) void {
+            _ = this; // autofix
+            const shorthand_supported = logical_supported and if (comptime shorthand_extra != null) !context.shouldCompileLogical(shorthand_extra.?.shorthand_feature) else true;
+
+            if (start.* != null and @as(PropertyIdTag, start.*.?) == start_prop and
+                end.* != null and @as(PropertyIdTag, end.*.?) == end_prop and
+                shorthand_supported)
+            {
+                const ValueType = shorthand_property.valueType();
+                var value: ValueType = undefined;
+                @field(value, start_name) = @field(start.*.?, @tagName(start_prop)).deepClone(context.allocator);
+                @field(value, end_name) = @field(end.*.?, @tagName(end_prop)).deepClone(context.allocator);
+                if (std.meta.fields(ValueType).len != 2) {
+                    @compileError(@typeName(ValueType) ++ " has more than two fields. This could cause undefined memory.");
+                }
+
+                dest.append(context.allocator, @unionInit(
+                    Property,
+                    @tagName(shorthand_property),
+                    value,
+                )) catch bun.outOfMemory();
+            } else {
+                if (start.* != null) {
+                    dest.append(context.allocator, start.*.?) catch bun.outOfMemory();
+                }
+                if (end.* != null) {
+                    dest.append(context.allocator, end.*.?) catch bun.outOfMemory();
+                }
+            }
+        }
+
+        inline fn prop(
+            this: *@This(),
+            val: *?Property,
+            comptime logical: css.PropertyIdTag,
+            comptime physical: css.PropertyIdTag,
+            dest: *css.DeclarationList,
+            context: *css.PropertyHandlerContext,
+        ) void {
+            _ = this; // autofix
+            if (val.*) |*v| {
+                if (@as(css.PropertyIdTag, v.*) == logical) {
+                    dest.append(
+                        context.allocator,
+                        @unionInit(
+                            Property,
+                            @tagName(physical),
+                            @field(v, @tagName(logical)),
+                        ),
+                    ) catch bun.outOfMemory();
+                } else if (v.* == .unparsed) {
+                    dest.append(
+                        context.allocator,
+                        Property{
+                            .unparsed = v.unparsed.withPropertyId(context.allocator, physical),
+                        },
+                    ) catch bun.outOfMemory();
+                }
+            }
+        }
+    };
+}
diff --git a/src/css/properties/masking.zig b/src/css/properties/masking.zig
new file mode 100644
index 0000000000..e4d1573ef8
--- /dev/null
+++ b/src/css/properties/masking.zig
@@ -0,0 +1,541 @@
+const std = @import("std");
+const bun = @import("root").bun;
+const Allocator = std.mem.Allocator;
+const ArrayList = std.ArrayListUnmanaged;
+
+pub const css = @import("../css_parser.zig");
+
+const SmallList = css.SmallList;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const Error = css.Error;
+
+const ContainerName = css.css_rules.container.ContainerName;
+
+const LengthPercentage = css.css_values.length.LengthPercentage;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CSSString = css.css_values.string.CSSString;
+const CSSNumber = css.css_values.number.CSSNumber;
+const LengthPercentageOrAuto = css.css_values.length.LengthPercentageOrAuto;
+const Size2D = css.css_values.size.Size2D;
+const DashedIdent = css.css_values.ident.DashedIdent;
+const Image = css.css_values.image.Image;
+const CssColor = css.css_values.color.CssColor;
+const Ratio = css.css_values.ratio.Ratio;
+const Length = css.css_values.length.LengthValue;
+const Rect = css.css_values.rect.Rect;
+const NumberOrPercentage = css.css_values.percentage.NumberOrPercentage;
+const CustomIdentList = css.css_values.ident.CustomIdentList;
+const Angle = css.css_values.angle.Angle;
+const Url = css.css_values.url.Url;
+const LengthOrNumber = css.css_values.length.LengthOrNumber;
+const Position = css.css_values.position.Position;
+
+const BorderRadius = css.css_properties.border_radius.BorderRadius;
+const FillRule = css.css_properties.shape.FillRule;
+
+const BackgroundSize = css.css_properties.background.BackgroundSize;
+const BackgroundRepeat = css.css_properties.background.BackgroundRepeat;
+const BorderImageSlice = css.css_properties.border_image.BorderImageSlice;
+const BorderImageSideWidth = css.css_properties.border_image.BorderImageSideWidth;
+const BorderImageRepeat = css.css_properties.border_image.BorderImageRepeat;
+const BorderImage = css.css_properties.border_image.BorderImage;
+
+/// A value for the [clip-path](https://www.w3.org/TR/css-masking-1/#the-clip-path) property.
+const ClipPath = union(enum) {
+    /// No clip path.
+    None,
+    /// A url reference to an SVG path element.
+    Url: Url,
+    /// A basic shape, positioned according to the reference box.
+    Shape: struct {
+        /// A basic shape.
+        // todo_stuff.think_about_mem_mgmt
+        shape: *BasicShape,
+        /// A reference box that the shape is positioned according to.
+        reference_box: GeometryBox,
+    },
+    /// A reference box.
+    Box: GeometryBox,
+};
+
+/// A [`<geometry-box>`](https://www.w3.org/TR/css-masking-1/#typedef-geometry-box) value
+/// as used in the `mask-clip` and `clip-path` properties.
+pub const GeometryBox = enum {
+    /// The painted content is clipped to the content box.
+    @"border-box",
+    /// The painted content is clipped to the padding box.
+    @"padding-box",
+    /// The painted content is clipped to the border box.
+    @"content-box",
+    /// The painted content is clipped to the margin box.
+    @"margin-box",
+    /// The painted content is clipped to the object bounding box.
+    @"fill-box",
+    /// The painted content is clipped to the stroke bounding box.
+    @"stroke-box",
+    /// Uses the nearest SVG viewport as reference box.
+    @"view-box",
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+
+    pub fn intoMaskClip(this: *const @This()) MaskClip {
+        return MaskClip{ .@"geometry-box" = this.* };
+    }
+
+    pub fn default() GeometryBox {
+        return .@"border-box";
+    }
+};
+
+/// A CSS [`<basic-shape>`](https://www.w3.org/TR/css-shapes-1/#basic-shape-functions) value.
+pub const BasicShape = union(enum) {
+    /// An inset rectangle.
+    Inset: InsetRect,
+    /// A circle.
+    Circle: Circle,
+    /// An ellipse.
+    Ellipse: Ellipse,
+    /// A polygon.
+    Polygon: Polygon,
+};
+
+/// An [`inset()`](https://www.w3.org/TR/css-shapes-1/#funcdef-inset) rectangle shape.
+const InsetRect = struct {
+    /// The rectangle.
+    rect: Rect(LengthPercentage),
+    /// A corner radius for the rectangle.
+    radius: BorderRadius,
+};
+
+/// A [`circle()`](https://www.w3.org/TR/css-shapes-1/#funcdef-circle) shape.
+pub const Circle = struct {
+    /// The radius of the circle.
+    radius: ShapeRadius,
+    /// The position of the center of the circle.
+    position: Position,
+};
+
+/// An [`ellipse()`](https://www.w3.org/TR/css-shapes-1/#funcdef-ellipse) shape.
+pub const Ellipse = struct {
+    /// The x-radius of the ellipse.
+    radius_x: ShapeRadius,
+    /// The y-radius of the ellipse.
+    radius_y: ShapeRadius,
+    /// The position of the center of the ellipse.
+    position: Position,
+};
+
+/// A [`polygon()`](https://www.w3.org/TR/css-shapes-1/#funcdef-polygon) shape.
+pub const Polygon = struct {
+    /// The fill rule used to determine the interior of the polygon.
+    fill_rule: FillRule,
+    /// The points of each vertex of the polygon.
+    points: ArrayList(Point),
+};
+
+/// A [`<shape-radius>`](https://www.w3.org/TR/css-shapes-1/#typedef-shape-radius) value
+/// that defines the radius of a `circle()` or `ellipse()` shape.
+pub const ShapeRadius = union(enum) {
+    /// An explicit length or percentage.
+    LengthPercentage: LengthPercentage,
+    /// The length from the center to the closest side of the box.
+    ClosestSide,
+    /// The length from the center to the farthest side of the box.
+    FarthestSide,
+};
+
+/// A point within a `polygon()` shape.
+///
+/// See [Polygon](Polygon).
+pub const Point = struct {
+    /// The x position of the point.
+    x: LengthPercentage,
+    /// The y position of the point.
+    y: LengthPercentage,
+};
+
+/// A value for the [mask-mode](https://www.w3.org/TR/css-masking-1/#the-mask-mode) property.
+pub const MaskMode = enum {
+    /// The luminance values of the mask image is used.
+    luminance,
+    /// The alpha values of the mask image is used.
+    alpha,
+    /// If an SVG source is used, the value matches the `mask-type` property. Otherwise, the alpha values are used.
+    @"match-source",
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+
+    pub fn default() MaskMode {
+        return .@"match-source";
+    }
+};
+
+/// A value for the [mask-clip](https://www.w3.org/TR/css-masking-1/#the-mask-clip) property.
+pub const MaskClip = union(enum) {
+    /// A geometry box.
+    @"geometry-box": GeometryBox,
+    /// The painted content is not clipped.
+    @"no-clip",
+
+    pub usingnamespace @call(.auto, css.DeriveParse, .{@This()});
+    pub usingnamespace @call(.auto, css.DeriveToCss, .{@This()});
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A value for the [mask-composite](https://www.w3.org/TR/css-masking-1/#the-mask-composite) property.
+pub const MaskComposite = enum {
+    /// The source is placed over the destination.
+    add,
+    /// The source is placed, where it falls outside of the destination.
+    subtract,
+    /// The parts of source that overlap the destination, replace the destination.
+    intersect,
+    /// The non-overlapping regions of source and destination are combined.
+    exclude,
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+
+    pub fn default() MaskComposite {
+        return .add;
+    }
+};
+
+/// A value for the [mask-type](https://www.w3.org/TR/css-masking-1/#the-mask-type) property.
+pub const MaskType = enum {
+    /// The luminance values of the mask is used.
+    luminance,
+    /// The alpha values of the mask is used.
+    alpha,
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+};
+
+/// A value for the [mask](https://www.w3.org/TR/css-masking-1/#the-mask) shorthand property.
+pub const Mask = struct {
+    /// The mask image.
+    image: Image,
+    /// The position of the mask.
+    position: Position,
+    /// The size of the mask image.
+    size: BackgroundSize,
+    /// How the mask repeats.
+    repeat: BackgroundRepeat,
+    /// The box in which the mask is clipped.
+    clip: MaskClip,
+    /// The origin of the mask.
+    origin: GeometryBox,
+    /// How the mask is composited with the element.
+    composite: MaskComposite,
+    /// How the mask image is interpreted.
+    mode: MaskMode,
+
+    pub usingnamespace css.DefineListShorthand(@This());
+
+    pub const PropertyFieldMap = .{
+        .image = css.PropertyIdTag.@"mask-image",
+        .position = css.PropertyIdTag.@"mask-position",
+        .size = css.PropertyIdTag.@"mask-size",
+        .repeat = css.PropertyIdTag.@"mask-repeat",
+        .clip = css.PropertyIdTag.@"mask-clip",
+        .origin = css.PropertyIdTag.@"mask-origin",
+        .composite = css.PropertyIdTag.@"mask-composite",
+        .mode = css.PropertyIdTag.@"mask-mode",
+    };
+
+    pub const VendorPrefixMap = .{
+        .image = true,
+        .position = true,
+        .size = true,
+        .repeat = true,
+        .clip = true,
+        .origin = true,
+    };
+
+    pub fn parse(input: *css.Parser) css.Result(@This()) {
+        var image: ?Image = null;
+        var position: ?Position = null;
+        var size: ?BackgroundSize = null;
+        var repeat: ?BackgroundRepeat = null;
+        var clip: ?MaskClip = null;
+        var origin: ?GeometryBox = null;
+        var composite: ?MaskComposite = null;
+        var mode: ?MaskMode = null;
+
+        while (true) {
+            if (image == null) {
+                if (@call(.auto, @field(Image, "parse"), .{input}).asValue()) |value| {
+                    image = value;
+                    continue;
+                }
+            }
+
+            if (position == null) {
+                if (Position.parse(input).asValue()) |value| {
+                    position = value;
+                    size = input.tryParse(struct {
+                        pub inline fn parseFn(i: *css.Parser) css.Result(BackgroundSize) {
+                            if (i.expectDelim('/').asErr()) |e| return .{ .err = e };
+                            return BackgroundSize.parse(i);
+                        }
+                    }.parseFn, .{}).asValue();
+                    continue;
+                }
+            }
+
+            if (repeat == null) {
+                if (BackgroundRepeat.parse(input).asValue()) |value| {
+                    repeat = value;
+                    continue;
+                }
+            }
+
+            if (origin == null) {
+                if (GeometryBox.parse(input).asValue()) |value| {
+                    origin = value;
+                    continue;
+                }
+            }
+
+            if (clip == null) {
+                if (MaskClip.parse(input).asValue()) |value| {
+                    clip = value;
+                    continue;
+                }
+            }
+
+            if (composite == null) {
+                if (MaskComposite.parse(input).asValue()) |value| {
+                    composite = value;
+                    continue;
+                }
+            }
+
+            if (mode == null) {
+                if (MaskMode.parse(input).asValue()) |value| {
+                    mode = value;
+                    continue;
+                }
+            }
+
+            break;
+        }
+
+        if (clip == null) {
+            if (origin) |o| {
+                clip = o.intoMaskClip();
+            }
+        }
+
+        return .{ .result = .{
+            .image = image orelse Image.default(),
+            .position = position orelse Position.default(),
+            .repeat = repeat orelse BackgroundRepeat.default(),
+            .size = size orelse BackgroundSize.default(),
+            .origin = origin orelse .@"border-box",
+            .clip = clip orelse GeometryBox.@"border-box".intoMaskClip(),
+            .composite = composite orelse .add,
+            .mode = mode orelse .@"match-source",
+        } };
+    }
+
+    pub fn toCss(this: *const Mask, comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+        try this.image.toCss(W, dest);
+
+        if (!this.position.eql(&Position.default()) or !this.size.eql(&BackgroundSize.default())) {
+            try dest.writeChar(' ');
+            try this.position.toCss(W, dest);
+
+            if (!this.size.eql(&BackgroundSize.default())) {
+                try dest.delim('/', true);
+                try this.size.toCss(W, dest);
+            }
+        }
+
+        if (!this.repeat.eql(&BackgroundRepeat.default())) {
+            try dest.writeChar(' ');
+            try this.repeat.toCss(W, dest);
+        }
+
+        if (!this.origin.eql(&GeometryBox.@"border-box") or !this.clip.eql(&GeometryBox.@"border-box".intoMaskClip())) {
+            try dest.writeChar(' ');
+            try this.origin.toCss(W, dest);
+
+            if (!this.clip.eql(&this.origin.intoMaskClip())) {
+                try dest.writeChar(' ');
+                try this.clip.toCss(W, dest);
+            }
+        }
+
+        if (!this.composite.eql(&MaskComposite.default())) {
+            try dest.writeChar(' ');
+            try this.composite.toCss(W, dest);
+        }
+
+        if (!this.mode.eql(&MaskMode.default())) {
+            try dest.writeChar(' ');
+            try this.mode.toCss(W, dest);
+        }
+
+        return;
+    }
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A value for the [mask-border-mode](https://www.w3.org/TR/css-masking-1/#the-mask-border-mode) property.
+pub const MaskBorderMode = enum {
+    /// The luminance values of the mask image is used.
+    luminance,
+    /// The alpha values of the mask image is used.
+    alpha,
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+
+    pub fn default() @This() {
+        return .alpha;
+    }
+};
+
+/// A value for the [mask-border](https://www.w3.org/TR/css-masking-1/#the-mask-border) shorthand property.
+/// A value for the [mask-border](https://www.w3.org/TR/css-masking-1/#the-mask-border) shorthand property.
+pub const MaskBorder = struct {
+    /// The mask image.
+    source: Image,
+    /// The offsets that define where the image is sliced.
+    slice: BorderImageSlice,
+    /// The width of the mask image.
+    width: Rect(BorderImageSideWidth),
+    /// The amount that the image extends beyond the border box.
+    outset: Rect(LengthOrNumber),
+    /// How the mask image is scaled and tiled.
+    repeat: BorderImageRepeat,
+    /// How the mask image is interpreted.
+    mode: MaskBorderMode,
+
+    pub usingnamespace css.DefineShorthand(@This(), css.PropertyIdTag.@"mask-border");
+
+    pub const PropertyFieldMap = .{
+        .source = css.PropertyIdTag.@"mask-border-source",
+        .slice = css.PropertyIdTag.@"mask-border-slice",
+        .width = css.PropertyIdTag.@"mask-border-width",
+        .outset = css.PropertyIdTag.@"mask-border-outset",
+        .repeat = css.PropertyIdTag.@"mask-border-repeat",
+        .mode = css.PropertyIdTag.@"mask-border-mode",
+    };
+
+    pub fn parse(input: *css.Parser) css.Result(@This()) {
+        const Closure = struct {
+            mode: ?MaskBorderMode = null,
+        };
+        var closure = Closure{ .mode = null };
+        const border_image = BorderImage.parseWithCallback(input, &closure, struct {
+            inline fn callback(c: *Closure, p: *css.Parser) bool {
+                if (c.mode == null) {
+                    if (p.tryParse(MaskBorderMode.parse, .{}).asValue()) |value| {
+                        c.mode = value;
+                        return true;
+                    }
+                }
+                return false;
+            }
+        }.callback);
+
+        if (border_image.isOk() or closure.mode != null) {
+            const bi = border_image.unwrapOr(comptime BorderImage.default());
+            return .{ .result = MaskBorder{
+                .source = bi.source,
+                .slice = bi.slice,
+                .width = bi.width,
+                .outset = bi.outset,
+                .repeat = bi.repeat,
+                .mode = closure.mode orelse MaskBorderMode.default(),
+            } };
+        } else {
+            return .{ .err = input.newCustomError(.invalid_declaration) };
+        }
+    }
+
+    pub fn toCss(this: *const MaskBorder, comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+        try BorderImage.toCssInternal(
+            &this.source,
+            &this.slice,
+            &this.width,
+            &this.outset,
+            &this.repeat,
+            W,
+            dest,
+        );
+        if (!this.mode.eql(&MaskBorderMode.default())) {
+            try dest.writeChar(' ');
+            try this.mode.toCss(W, dest);
+        }
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A value for the [-webkit-mask-composite](https://developer.mozilla.org/en-US/docs/Web/CSS/-webkit-mask-composite)
+/// property.
+///
+/// See also [MaskComposite](MaskComposite).
+/// A value for the [-webkit-mask-composite](https://developer.mozilla.org/en-US/docs/Web/CSS/-webkit-mask-composite)
+/// property.
+///
+/// See also [MaskComposite](MaskComposite).
+pub const WebKitMaskComposite = enum {
+    clear,
+    copy,
+    /// Equivalent to `add` in the standard `mask-composite` syntax.
+    @"source-over",
+    /// Equivalent to `intersect` in the standard `mask-composite` syntax.
+    @"source-in",
+    /// Equivalent to `subtract` in the standard `mask-composite` syntax.
+    @"source-out",
+    @"source-atop",
+    @"destination-over",
+    @"destination-in",
+    @"destination-out",
+    @"destination-atop",
+    /// Equivalent to `exclude` in the standard `mask-composite` syntax.
+    xor,
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+};
+
+/// A value for the [-webkit-mask-source-type](https://github.com/WebKit/WebKit/blob/6eece09a1c31e47489811edd003d1e36910e9fd3/Source/WebCore/css/CSSProperties.json#L6578-L6587)
+/// property.
+///
+/// See also [MaskMode](MaskMode).
+/// A value for the [-webkit-mask-source-type](https://github.com/WebKit/WebKit/blob/6eece09a1c31e47489811edd003d1e36910e9fd3/Source/WebCore/css/CSSProperties.json#L6578-L6587)
+/// property.
+///
+/// See also [MaskMode](MaskMode).
+pub const WebKitMaskSourceType = enum {
+    /// Equivalent to `match-source` in the standard `mask-mode` syntax.
+    auto,
+    /// The luminance values of the mask image is used.
+    luminance,
+    /// The alpha values of the mask image is used.
+    alpha,
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+};
diff --git a/src/css/properties/outline.zig b/src/css/properties/outline.zig
new file mode 100644
index 0000000000..cf98f18c6f
--- /dev/null
+++ b/src/css/properties/outline.zig
@@ -0,0 +1,59 @@
+const std = @import("std");
+const bun = @import("root").bun;
+const Allocator = std.mem.Allocator;
+const ArrayList = std.ArrayListUnmanaged;
+
+pub const css = @import("../css_parser.zig");
+
+const SmallList = css.SmallList;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const Error = css.Error;
+
+const ContainerName = css.css_rules.container.ContainerName;
+
+const LengthPercentage = css.css_values.length.LengthPercentage;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CSSString = css.css_values.string.CSSString;
+const CSSNumber = css.css_values.number.CSSNumber;
+const LengthPercentageOrAuto = css.css_values.length.LengthPercentageOrAuto;
+const Size2D = css.css_values.size.Size2D;
+const DashedIdent = css.css_values.ident.DashedIdent;
+const Image = css.css_values.image.Image;
+const CssColor = css.css_values.color.CssColor;
+const Ratio = css.css_values.ratio.Ratio;
+const Length = css.css_values.length.LengthValue;
+const Rect = css.css_values.rect.Rect;
+const NumberOrPercentage = css.css_values.percentage.NumberOrPercentage;
+const CustomIdentList = css.css_values.ident.CustomIdentList;
+const Angle = css.css_values.angle.Angle;
+const Url = css.css_values.url.Url;
+
+const GenericBorder = css.css_properties.border.GenericBorder;
+const LineStyle = css.css_properties.border.LineStyle;
+
+/// A value for the [outline](https://drafts.csswg.org/css-ui/#outline) shorthand property.
+pub const Outline = GenericBorder(OutlineStyle, 11);
+
+/// A value for the [outline-style](https://drafts.csswg.org/css-ui/#outline-style) property.
+pub const OutlineStyle = union(enum) {
+    /// The `auto` keyword.
+    auto: void,
+    /// A value equivalent to the `border-style` property.
+    line_style: LineStyle,
+
+    pub usingnamespace css.DeriveParse(@This());
+    pub usingnamespace css.DeriveToCss(@This());
+
+    pub fn default() @This() {
+        return .{ .line_style = .none };
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
diff --git a/src/css/properties/overflow.zig b/src/css/properties/overflow.zig
new file mode 100644
index 0000000000..39b246b9d4
--- /dev/null
+++ b/src/css/properties/overflow.zig
@@ -0,0 +1,96 @@
+const std = @import("std");
+const bun = @import("root").bun;
+const Allocator = std.mem.Allocator;
+const ArrayList = std.ArrayListUnmanaged;
+
+pub const css = @import("../css_parser.zig");
+
+const SmallList = css.SmallList;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const Error = css.Error;
+
+const ContainerName = css.css_rules.container.ContainerName;
+
+const LengthPercentage = css.css_values.length.LengthPercentage;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CSSString = css.css_values.string.CSSString;
+const CSSNumber = css.css_values.number.CSSNumber;
+const LengthPercentageOrAuto = css.css_values.length.LengthPercentageOrAuto;
+const Size2D = css.css_values.size.Size2D;
+const DashedIdent = css.css_values.ident.DashedIdent;
+const Image = css.css_values.image.Image;
+const CssColor = css.css_values.color.CssColor;
+const Ratio = css.css_values.ratio.Ratio;
+const Length = css.css_values.length.LengthValue;
+const Rect = css.css_values.rect.Rect;
+const NumberOrPercentage = css.css_values.percentage.NumberOrPercentage;
+const CustomIdentList = css.css_values.ident.CustomIdentList;
+const Angle = css.css_values.angle.Angle;
+const Url = css.css_values.url.Url;
+
+const GenericBorder = css.css_properties.border.GenericBorder;
+const LineStyle = css.css_properties.border.LineStyle;
+
+/// A value for the [overflow](https://www.w3.org/TR/css-overflow-3/#overflow-properties) shorthand property.
+pub const Overflow = struct {
+    /// A value for the [overflow](https://www.w3.org/TR/css-overflow-3/#overflow-properties) shorthand property.
+    x: OverflowKeyword,
+    /// The overflow mode for the y direction.
+    y: OverflowKeyword,
+
+    pub fn parse(input: *css.Parser) css.Result(Overflow) {
+        const x = switch (OverflowKeyword.parse(input)) {
+            .result => |v| v,
+            .err => |e| return .{ .err = e },
+        };
+        const y = switch (input.tryParse(OverflowKeyword.parse, .{})) {
+            .result => |v| v,
+            else => x,
+        };
+        return .{ .result = Overflow{ .x = x, .y = y } };
+    }
+
+    pub fn toCss(this: *const Overflow, comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+        try this.x.toCss(W, dest);
+        if (this.y != this.x) {
+            try dest.writeChar(' ');
+            try this.y.toCss(W, dest);
+        }
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub inline fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+/// An [overflow](https://www.w3.org/TR/css-overflow-3/#overflow-properties) keyword
+/// as used in the `overflow-x`, `overflow-y`, and `overflow` properties.
+pub const OverflowKeyword = enum {
+    /// Overflowing content is visible.
+    visible,
+    /// Overflowing content is hidden. Programmatic scrolling is allowed.
+    hidden,
+    /// Overflowing content is clipped. Programmatic scrolling is not allowed.
+    clip,
+    /// The element is scrollable.
+    scroll,
+    /// Overflowing content scrolls if needed.
+    auto,
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+};
+
+/// A value for the [text-overflow](https://www.w3.org/TR/css-overflow-3/#text-overflow) property.
+pub const TextOverflow = enum {
+    /// Overflowing text is clipped.
+    clip,
+    /// Overflowing text is truncated with an ellipsis.
+    ellipsis,
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+};
diff --git a/src/css/properties/position.zig b/src/css/properties/position.zig
new file mode 100644
index 0000000000..2eeb39147b
--- /dev/null
+++ b/src/css/properties/position.zig
@@ -0,0 +1,107 @@
+const std = @import("std");
+const bun = @import("root").bun;
+const Allocator = std.mem.Allocator;
+const ArrayList = std.ArrayListUnmanaged;
+
+pub const css = @import("../css_parser.zig");
+
+const SmallList = css.SmallList;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const Error = css.Error;
+
+const ContainerName = css.css_rules.container.ContainerName;
+
+const LengthPercentage = css.css_values.length.LengthPercentage;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CSSString = css.css_values.string.CSSString;
+const CSSNumber = css.css_values.number.CSSNumber;
+const LengthPercentageOrAuto = css.css_values.length.LengthPercentageOrAuto;
+const Size2D = css.css_values.size.Size2D;
+const DashedIdent = css.css_values.ident.DashedIdent;
+const Image = css.css_values.image.Image;
+const CssColor = css.css_values.color.CssColor;
+const Ratio = css.css_values.ratio.Ratio;
+const Length = css.css_values.length.LengthValue;
+const Rect = css.css_values.rect.Rect;
+const NumberOrPercentage = css.css_values.percentage.NumberOrPercentage;
+const CustomIdentList = css.css_values.ident.CustomIdentList;
+const Angle = css.css_values.angle.Angle;
+const Url = css.css_values.url.Url;
+
+const GenericBorder = css.css_properties.border.GenericBorder;
+const LineStyle = css.css_properties.border.LineStyle;
+
+/// A value for the [position](https://www.w3.org/TR/css-position-3/#position-property) property.
+pub const Position = union(enum) {
+    /// The box is laid in the document flow.
+    static,
+    /// The box is laid out in the document flow and offset from the resulting position.
+    relative,
+    /// The box is taken out of document flow and positioned in reference to its relative ancestor.
+    absolute,
+    /// Similar to relative but adjusted according to the ancestor scrollable element.
+    sticky: css.VendorPrefix,
+    /// The box is taken out of the document flow and positioned in reference to the page viewport.
+    fixed,
+
+    pub fn parse(input: *css.Parser) css.Result(Position) {
+        const location = input.currentSourceLocation();
+        const ident = switch (input.expectIdent()) {
+            .err => |e| return .{ .err = e },
+            .result => |v| v,
+        };
+
+        const PositionKeyword = enum {
+            static,
+            relative,
+            absolute,
+            fixed,
+            sticky,
+            @"-webkit-sticky",
+        };
+
+        const keyword_map = bun.ComptimeStringMap(PositionKeyword, .{
+            .{ "static", .static },
+            .{ "relative", .relative },
+            .{ "absolute", .absolute },
+            .{ "fixed", .fixed },
+            .{ "sticky", .sticky },
+            .{ "-webkit-sticky", .@"-webkit-sticky" },
+        });
+
+        const keyword = keyword_map.get(ident) orelse {
+            return .{ .err = location.newUnexpectedTokenError(.{ .ident = ident }) };
+        };
+
+        return .{ .result = switch (keyword) {
+            .static => .static,
+            .relative => .relative,
+            .absolute => .absolute,
+            .fixed => .fixed,
+            .sticky => .{ .sticky = css.VendorPrefix{ .none = true } },
+            .@"-webkit-sticky" => .{ .sticky = css.VendorPrefix{ .webkit = true } },
+        } };
+    }
+
+    pub fn toCss(this: *const Position, comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+        return switch (this.*) {
+            .static => dest.writeStr("static"),
+            .relative => dest.writeStr("relative"),
+            .absolute => dest.writeStr("absolute"),
+            .fixed => dest.writeStr("fixed"),
+            .sticky => |prefix| {
+                try prefix.toCss(W, dest);
+                return dest.writeStr("sticky");
+            },
+        };
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
diff --git a/src/css/properties/prefix_handler.zig b/src/css/properties/prefix_handler.zig
new file mode 100644
index 0000000000..a5ba88ff16
--- /dev/null
+++ b/src/css/properties/prefix_handler.zig
@@ -0,0 +1,142 @@
+const std = @import("std");
+const bun = @import("root").bun;
+const Allocator = std.mem.Allocator;
+
+pub const css = @import("../css_parser.zig");
+
+const CustomPropertyName = css.css_properties.CustomPropertyName;
+
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const VendorPrefix = css.VendorPrefix;
+const Error = css.Error;
+
+const PropertyId = css.PropertyId;
+const PropertyIdTag = css.PropertyIdTag;
+const Property = css.Property;
+const UnparsedProperty = css.css_properties.custom.UnparsedProperty;
+
+/// *NOTE* The struct field names must match their corresponding names in `Property`!
+pub const FallbackHandler = struct {
+    color: ?usize = null,
+    @"text-shadow": ?usize = null,
+    // TODO: add these back plz
+    // filter: ?usize = null,
+    // @"backdrop-filter": ?usize = null,
+    // fill: ?usize = null,
+    // stroke: ?usize = null,
+    // @"caret-color": ?usize = null,
+    // caret: ?usize = null,
+
+    const field_count = @typeInfo(FallbackHandler).Struct.fields.len;
+
+    pub fn handleProperty(
+        this: *FallbackHandler,
+        property: *const Property,
+        dest: *css.DeclarationList,
+        context: *css.PropertyHandlerContext,
+    ) bool {
+        inline for (std.meta.fields(FallbackHandler)) |field| {
+            if (@intFromEnum(@field(PropertyIdTag, field.name)) == @intFromEnum(@as(PropertyIdTag, property.*))) {
+                const has_vendor_prefix = comptime PropertyIdTag.hasVendorPrefix(@field(PropertyIdTag, field.name));
+                var val = if (comptime has_vendor_prefix)
+                    @field(property, field.name)[0].deepClone(context.allocator)
+                else
+                    @field(property, field.name).deepClone(context.allocator);
+
+                if (@field(this, field.name) == null) {
+                    const fallbacks = val.getFallbacks(context.allocator, context.targets);
+                    const has_fallbacks = !fallbacks.isEmpty();
+
+                    for (fallbacks.slice()) |fallback| {
+                        dest.append(
+                            context.allocator,
+                            @unionInit(
+                                Property,
+                                field.name,
+                                if (comptime has_vendor_prefix)
+                                    .{ fallback, @field(property, field.name)[1] }
+                                else
+                                    fallback,
+                            ),
+                        ) catch bun.outOfMemory();
+                    }
+                    if (comptime has_vendor_prefix) {
+                        if (has_fallbacks and @field(property, field.name[1]).contains(VendorPrefix{ .none = true })) {
+                            @field(property, field.name[1]) = css.VendorPrefix{ .none = true };
+                        }
+                    }
+                }
+
+                if (@field(this, field.name) == null or
+                    context.targets.browsers != null and !val.isCompatible(context.targets.browsers.?))
+                {
+                    @field(this, field.name) = dest.items.len;
+                    dest.append(
+                        context.allocator,
+                        @unionInit(
+                            Property,
+                            field.name,
+                            if (comptime has_vendor_prefix)
+                                .{ val, @field(property, field.name)[1] }
+                            else
+                                val,
+                        ),
+                    ) catch bun.outOfMemory();
+                } else if (@field(this, field.name) != null) {
+                    const index = @field(this, field.name).?;
+                    dest.items[index] = @unionInit(
+                        Property,
+                        field.name,
+                        if (comptime has_vendor_prefix)
+                            .{ val, @field(property, field.name)[1] }
+                        else
+                            val,
+                    );
+                } else {
+                    val.deinit(context.allocator);
+                }
+
+                return true;
+            }
+        }
+
+        if (@as(PropertyIdTag, property.*) == .unparsed) {
+            const val: *const UnparsedProperty = &property.unparsed;
+            var unparsed, const index = unparsed_and_index: {
+                inline for (std.meta.fields(FallbackHandler)) |field| {
+                    if (@intFromEnum(@field(PropertyIdTag, field.name)) == @intFromEnum(val.property_id)) {
+                        const has_vendor_prefix = comptime PropertyIdTag.hasVendorPrefix(@field(PropertyIdTag, field.name));
+                        const newval = newval: {
+                            if (comptime has_vendor_prefix) {
+                                if (@field(val.property_id, field.name)[1].contains(VendorPrefix{ .none = true }))
+                                    break :newval val.getPrefixed(context.targets, @field(css.prefixes.Feature, field.name));
+                            }
+                            break :newval val.deepClone(context.allocator);
+                        };
+                        break :unparsed_and_index .{ newval, &@field(this, field.name) };
+                    }
+                }
+                return false;
+            };
+
+            context.addUnparsedFallbacks(&unparsed);
+            if (index.*) |i| {
+                dest.items[i] = Property{ .unparsed = unparsed };
+            } else {
+                index.* = dest.items.len;
+                dest.append(context.allocator, Property{ .unparsed = unparsed }) catch bun.outOfMemory();
+            }
+
+            return true;
+        }
+
+        return false;
+    }
+
+    pub fn finalize(this: *FallbackHandler, _: *css.DeclarationList, _: *css.PropertyHandlerContext) void {
+        inline for (std.meta.fields(FallbackHandler)) |field| {
+            @field(this, field.name) = null;
+        }
+    }
+};
diff --git a/src/css/properties/properties.zig b/src/css/properties/properties.zig
new file mode 100644
index 0000000000..4ec12ffa41
--- /dev/null
+++ b/src/css/properties/properties.zig
@@ -0,0 +1,1880 @@
+const std = @import("std");
+const bun = @import("root").bun;
+const Allocator = std.mem.Allocator;
+const css = @import("../css_parser.zig");
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const Position = position.Position;
+const Error = css.Error;
+const ArrayList = std.ArrayListUnmanaged;
+const SmallList = css.SmallList;
+
+pub const CustomPropertyName = @import("./custom.zig").CustomPropertyName;
+
+pub const @"align" = @import("./align.zig");
+pub const animation = @import("./animation.zig");
+pub const background = @import("./background.zig");
+pub const border = @import("./border.zig");
+pub const border_image = @import("./border_image.zig");
+pub const border_radius = @import("./border_radius.zig");
+pub const box_shadow = @import("./box_shadow.zig");
+pub const contain = @import("./contain.zig");
+pub const css_modules = @import("./css_modules.zig");
+pub const custom = @import("./custom.zig");
+pub const display = @import("./display.zig");
+pub const effects = @import("./effects.zig");
+pub const flex = @import("./flex.zig");
+pub const font = @import("./font.zig");
+pub const list = @import("./list.zig");
+pub const margin_padding = @import("./margin_padding.zig");
+pub const masking = @import("./masking.zig");
+pub const outline = @import("./outline.zig");
+pub const overflow = @import("./overflow.zig");
+pub const position = @import("./position.zig");
+pub const prefix_handler = @import("./prefix_handler.zig");
+pub const shape = @import("./shape.zig");
+pub const size = @import("./size.zig");
+pub const svg = @import("./svg.zig");
+pub const text = @import("./text.zig");
+pub const transform = @import("./transform.zig");
+pub const transition = @import("./transition.zig");
+pub const ui = @import("./ui.zig");
+
+const generated = @import("./properties_generated.zig");
+pub const PropertyId = generated.PropertyId;
+pub const Property = generated.Property;
+pub const PropertyIdTag = generated.PropertyIdTag;
+
+/// A [CSS-wide keyword](https://drafts.csswg.org/css-cascade-5/#defaulting-keywords).
+pub const CSSWideKeyword = enum {
+    /// The property's initial value.
+    initial,
+    /// The property's computed value on the parent element.
+    inherit,
+    /// Either inherit or initial depending on whether the property is inherited.
+    unset,
+    /// Rolls back the cascade to the cascaded value of the earlier origin.
+    revert,
+    /// Rolls back the cascade to the value of the previous cascade layer.
+    @"revert-layer",
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+};
+
+// pub fn DefineProperties(comptime properties: anytype) type {
+//     const input_fields: []const std.builtin.Type.StructField = std.meta.fields(@TypeOf(properties));
+//     const total_fields_len = input_fields.len + 2; // +2 for the custom property and the `all` property
+//     const TagSize = u16;
+//     const PropertyIdT, const max_enum_name_length: usize = brk: {
+//         var max: usize = 0;
+//         var property_id_type = std.builtin.Type.Enum{
+//             .tag_type = TagSize,
+//             .is_exhaustive = true,
+//             .decls = &.{},
+//             .fields = undefined,
+//         };
+//         var enum_fields: [total_fields_len]std.builtin.Type.EnumField = undefined;
+//         for (input_fields, 0..) |field, i| {
+//             enum_fields[i] = .{
+//                 .name = field.name,
+//                 .value = i,
+//             };
+//             max = @max(max, field.name.len);
+//         }
+//         enum_fields[input_fields.len] = std.builtin.Type.EnumField{
+//             .name = "all",
+//             .value = input_fields.len,
+//             //         };
+//             //         enum_fields[input_fields.len + 1] = std.builtin.Type.EnumField{
+//             .name = "custom",
+//             .value = input_fields.len + 1,
+//         };
+//         property_id_type.fields = &enum_fields;
+//         break :brk .{ property_id_type, max };
+//     };
+
+//     const types: []const type = types: {
+//         var types: [total_fields_len]type = undefined;
+//         inline for (input_fields, 0..) |field, i| {
+//             types[i] = @field(properties, field.name).ty;
+
+//             if (std.mem.eql(u8, field.name, "transition-property")) {
+//                 types[i] = struct { SmallList(PropertyIdT, 1), css.VendorPrefix };
+//             }
+
+//             // Validate it
+
+//             const value = @field(properties, field.name);
+//             const ValueT = @TypeOf(value);
+//             const value_ty = value.ty;
+//             const ValueTy = @TypeOf(value_ty);
+//             const value_ty_info = @typeInfo(ValueTy);
+//             // If `valid_prefixes` is defined, the `ty` should be a two item tuple where
+//             // the second item is of type `VendorPrefix`
+//             if (@hasField(ValueT, "valid_prefixes")) {
+//                 if (!value_ty_info.Struct.is_tuple) {
+//                     @compileError("Expected a tuple type for `ty` when `valid_prefixes` is defined");
+//                 }
+//                 if (value_ty_info.Struct.fields[1].type != css.VendorPrefix) {
+//                     @compileError("Expected the second item in the tuple to be of type `VendorPrefix`");
+//                 }
+//             }
+//         }
+//         types[input_fields.len] = void;
+//         types[input_fields.len + 1] = CustomPropertyName;
+//         break :types &types;
+//     };
+//     const PropertyT = PropertyT: {
+//         var union_fields: [total_fields_len]std.builtin.Type.UnionField = undefined;
+//         inline for (input_fields, 0..) |input_field, i| {
+//             const Ty = types[i];
+//             union_fields[i] = std.builtin.Type.UnionField{
+//                 .alignment = @alignOf(Ty),
+//                 .type = type,
+//                 .name = input_field.name,
+//             };
+//         }
+//         union_fields[input_fields.len] = std.builtin.Type.UnionField{
+//             .alignment = 0,
+//             .type = void,
+//             .name = "all",
+//         };
+//         union_fields[input_fields.len + 1] = std.builtin.Type.UnionField{
+//             .alignment = @alignOf(CustomPropertyName),
+//             .type = CustomPropertyName,
+//             .name = "custom",
+//         };
+//         break :PropertyT std.builtin.Type.Union{
+//             .layout = .auto,
+//             .tag_type = PropertyIdT,
+//             .decls = &.{},
+//             .fields = union_fields,
+//         };
+//     };
+//     _ = PropertyT; // autofix
+//     return struct {
+//         pub const PropertyId = PropertyIdT;
+
+//         pub fn propertyIdEq(lhs: PropertyId, rhs: PropertyId) bool {
+//             _ = lhs; // autofix
+//             _ = rhs; // autofix
+//             @compileError(css.todo_stuff.depth);
+//         }
+
+//         pub fn propertyIdIsShorthand(id: PropertyId) bool {
+//             inline for (std.meta.fields(PropertyId)) |field| {
+//                 if (field.value == @intFromEnum(id)) {
+//                     const is_shorthand = if (@hasField(@TypeOf(@field(properties, field.name)), "shorthand"))
+//                         @field(@field(properties, field.name), "shorthand")
+//                     else
+//                         false;
+//                     return is_shorthand;
+//                 }
+//             }
+//             return false;
+//         }
+
+//         /// PropertyId.prefix()
+//         pub fn propertyIdPrefix(id: PropertyId) css.VendorPrefix {
+//             _ = id; // autofix
+//             @compileError(css.todo_stuff.depth);
+//         }
+
+//         /// PropertyId.name()
+//         pub fn propertyIdName(id: PropertyId) []const u8 {
+//             _ = id; // autofix
+//             @compileError(css.todo_stuff.depth);
+//         }
+
+//         pub fn propertyIdFromStr(name: []const u8) PropertyId {
+//             const prefix, const name_ref = if (bun.strings.startsWithCaseInsensitiveAscii(name, "-webkit-"))
+//                 .{ css.VendorPrefix.webkit, name[8..] }
+//             else if (bun.strings.startsWithCaseInsensitiveAscii(name, "-moz-"))
+//                 .{ css.VendorPrefix.moz, name[5..] }
+//             else if (bun.strings.startsWithCaseInsensitiveAscii(name, "-o-"))
+//                 .{ css.VendorPrefix.moz, name[3..] }
+//             else if (bun.strings.startsWithCaseInsensitiveAscii(name, "-ms-"))
+//                 .{ css.VendorPrefix.moz, name[4..] }
+//             else
+//                 .{ css.VendorPrefix.none, name };
+
+//             return parsePropertyIdFromNameAndPrefix(name_ref, prefix) catch .{
+//                 .custom = CustomPropertyName.fromStr(name),
+//             };
+//         }
+
+//         pub fn parsePropertyIdFromNameAndPrefix(name: []const u8, prefix: css.VendorPrefix) Error!PropertyId {
+//             var buffer: [max_enum_name_length]u8 = undefined;
+//             if (name.len > buffer.len) {
+//                 // TODO: actual source just returns empty Err(())
+//                 return Error.InvalidPropertyName;
+//             }
+//             const lower = bun.strings.copyLowercase(name, buffer[0..name.len]);
+//             inline for (std.meta.fields(PropertyIdT)) |field_| {
+//                 const field: std.builtin.Type.EnumField = field_;
+//                 // skip custom
+//                 if (bun.strings.eql(field.name, "custom")) continue;
+
+//                 if (bun.strings.eql(lower, field.name)) {
+//                     const prop = @field(properties, field.name);
+//                     const allowed_prefixes = allowed_prefixes: {
+//                         var prefixes: css.VendorPrefix = if (@hasField(@TypeOf(prop), "unprefixed") and !prop.unprefixed)
+//                             css.VendorPrefix.empty()
+//                         else
+//                             css.VendorPrefix{ .none = true };
+
+//                         if (@hasField(@TypeOf(prop), "valid_prefixes")) {
+//                             prefixes = css.VendorPrefix.bitwiseOr(prefixes, prop.valid_prefixes);
+//                         }
+
+//                         break :allowed_prefixes prefixes;
+//                     };
+
+//                     if (allowed_prefixes.contains(prefix)) return @enumFromInt(field.value);
+//                 }
+//             }
+//             return Error.InvalidPropertyName;
+//         }
+//     };
+// }
+
+// /// SmallList(PropertyId)
+// const SmallListPropertyIdPlaceholder = struct {};
+
+// pub const Property = DefineProperties(.{
+//     .@"background-color" = .{
+//         .ty = CssColor,
+//     },
+//     .@"background-image" = .{
+//         // PERF: make this equivalent to SmallVec<[_; 1]>
+//         .ty = SmallList(Image, 1),
+//     },
+//     .@"background-position-x" = .{
+//         // PERF: make this equivalent to SmallVec<[_; 1]>
+//         .ty = SmallList(css_values.position.HorizontalPosition, 1),
+//     },
+//     .@"background-position-y" = .{
+//         // PERF: make this equivalent to SmallVec<[_; 1]>
+//         .ty = SmallList(css_values.position.HorizontalPosition, 1),
+//     },
+//     .@"background-position" = .{
+//         // PERF: make this equivalent to SmallVec<[_; 1]>
+//         .ty = SmallList(background.BackgroundPosition, 1),
+//         .shorthand = true,
+//     },
+//     .@"background-size" = .{
+//         // PERF: make this equivalent to SmallVec<[_; 1]>
+//         .ty = SmallList(background.BackgroundSize, 1),
+//     },
+//     .@"background-repeat" = .{
+//         // PERF: make this equivalent to SmallVec<[_; 1]>
+//         .ty = SmallList(background.BackgroundSize, 1),
+//     },
+//     .@"background-attachment" = .{
+//         // PERF: make this equivalent to SmallVec<[_; 1]>
+//         .ty = SmallList(background.BackgroundAttachment, 1),
+//     },
+//     .@"background-clip" = .{
+//         // PERF: make this equivalent to SmallVec<[_; 1]>
+//         .ty = struct {
+//             SmallList(background.BackgroundAttachment, 1),
+//             css.VendorPrefix,
+//         },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//         },
+//     },
+//     .@"background-origin" = .{
+//         // PERF: make this equivalent to SmallVec<[_; 1]>
+//         .ty = SmallList(background.BackgroundOrigin, 1),
+//     },
+//     .background = .{
+//         // PERF: make this equivalent to SmallVec<[_; 1]>
+//         .ty = SmallList(background.Background, 1),
+//     },
+
+//     .@"box-shadow" = .{
+//         // PERF: make this equivalent to SmallVec<[_; 1]>
+//         .ty = struct { SmallList(box_shadow.BoxShadow, 1), css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//         },
+//     },
+//     .opacity = .{
+//         .ty = css.css_values.alpha.AlphaValue,
+//     },
+//     .color = .{
+//         .ty = CssColor,
+//     },
+//     .display = .{
+//         .ty = display.Display,
+//     },
+//     .visibility = .{
+//         .ty = display.Visibility,
+//     },
+
+//     .width = .{
+//         .ty = size.Size,
+//         .logical_group = .{ .ty = LogicalGroup.size, .category = PropertyCategory.physical },
+//     },
+//     .height = .{
+//         .ty = size.Size,
+//         .logical_group = .{ .ty = LogicalGroup.size, .category = PropertyCategory.physical },
+//     },
+//     .@"min-width" = .{
+//         .ty = size.Size,
+//         .logical_group = .{ .ty = LogicalGroup.min_size, .category = PropertyCategory.physical },
+//     },
+//     .@"min-height" = .{
+//         .ty = size.Size,
+//         .logical_group = .{ .ty = LogicalGroup.min_size, .category = PropertyCategory.physical },
+//     },
+//     .@"max-width" = .{
+//         .ty = size.MaxSize,
+//         .logical_group = .{ .ty = LogicalGroup.max_size, .category = PropertyCategory.physical },
+//     },
+//     .@"max-height" = .{
+//         .ty = size.MaxSize,
+//         .logical_group = .{ .ty = LogicalGroup.max_size, .category = PropertyCategory.physical },
+//     },
+//     .@"block-size" = .{
+//         .ty = size.Size,
+//         .logical_group = .{ .ty = LogicalGroup.size, .category = PropertyCategory.logical },
+//     },
+//     .@"inline-size" = .{
+//         .ty = size.Size,
+//         .logical_group = .{ .ty = LogicalGroup.size, .category = PropertyCategory.logical },
+//     },
+//     .min_block_size = .{
+//         .ty = size.Size,
+//         .logical_group = .{ .ty = LogicalGroup.min_size, .category = PropertyCategory.logical },
+//     },
+//     .@"min-inline-size" = .{
+//         .ty = size.Size,
+//         .logical_group = .{ .ty = LogicalGroup.min_size, .category = PropertyCategory.logical },
+//     },
+//     .@"max-block-size" = .{
+//         .ty = size.MaxSize,
+//         .logical_group = .{ .ty = LogicalGroup.max_size, .category = PropertyCategory.logical },
+//     },
+//     .@"max-inline-size" = .{
+//         .ty = size.MaxSize,
+//         .logical_group = .{ .ty = LogicalGroup.max_size, .category = PropertyCategory.logical },
+//     },
+//     .@"box-sizing" = .{
+//         .ty = struct { size.BoxSizing, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//         },
+//     },
+//     .@"aspect-ratio" = .{
+//         .ty = size.AspectRatio,
+//     },
+
+//     .overflow = .{
+//         .ty = overflow.Overflow,
+//         .shorthand = true,
+//     },
+//     .@"overflow-x" = .{
+//         .ty = overflow.OverflowKeyword,
+//     },
+//     .@"overflow-y" = .{
+//         .ty = overflow.OverflowKeyword,
+//     },
+//     .@"text-overflow" = .{
+//         .ty = struct { overflow.TextOverflow, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .o = true,
+//         },
+//     },
+
+//     // https://www.w3.org/TR/2020/WD-css-position-3-20200519
+//     .position = .{
+//         .ty = position.Position,
+//     },
+//     .top = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.inset, .category = PropertyCategory.physical },
+//     },
+//     .bottom = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.inset, .category = PropertyCategory.physical },
+//     },
+//     .left = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.inset, .category = PropertyCategory.physical },
+//     },
+//     .right = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.inset, .category = PropertyCategory.physical },
+//     },
+//     .@"inset-block-start" = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.inset, .category = PropertyCategory.logical },
+//     },
+//     .@"inset-block-end" = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.inset, .category = PropertyCategory.logical },
+//     },
+//     .@"inset-inline-start" = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.inset, .category = PropertyCategory.logical },
+//     },
+//     .@"inset-inline-end" = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.inset, .category = PropertyCategory.logical },
+//     },
+//     .@"inset-block" = .{
+//         .ty = margin_padding.InsetBlock,
+//         .shorthand = true,
+//     },
+//     .@"inset-inline" = .{
+//         .ty = margin_padding.InsetInline,
+//         .shorthand = true,
+//     },
+//     .inset = .{
+//         .ty = margin_padding.Inset,
+//         .shorthand = true,
+//     },
+
+//     .@"border-spacing" = .{
+//         .ty = css.css_values.size.Size(Length),
+//     },
+
+//     .@"border-top-color" = .{
+//         .ty = CssColor,
+//         .logical_group = .{ .ty = LogicalGroup.border_color, .category = PropertyCategory.physical },
+//     },
+//     .@"border-bottom-color" = .{
+//         .ty = CssColor,
+//         .logical_group = .{ .ty = LogicalGroup.border_color, .category = PropertyCategory.physical },
+//     },
+//     .@"border-left-color" = .{
+//         .ty = CssColor,
+//         .logical_group = .{ .ty = LogicalGroup.border_color, .category = PropertyCategory.physical },
+//     },
+//     .@"border-right-color" = .{
+//         .ty = CssColor,
+//         .logical_group = .{ .ty = LogicalGroup.border_color, .category = PropertyCategory.physical },
+//     },
+//     .@"border-block-start-color" = .{
+//         .ty = CssColor,
+//         .logical_group = .{ .ty = LogicalGroup.border_color, .category = PropertyCategory.logical },
+//     },
+//     .@"border-block-end-color" = .{
+//         .ty = CssColor,
+//         .logical_group = .{ .ty = LogicalGroup.border_color, .category = PropertyCategory.logical },
+//     },
+//     .@"border-inline-start-color" = .{
+//         .ty = CssColor,
+//         .logical_group = .{ .ty = LogicalGroup.border_color, .category = PropertyCategory.logical },
+//     },
+//     .@"border-inline-end-color" = .{
+//         .ty = CssColor,
+//         .logical_group = .{ .ty = LogicalGroup.border_color, .category = PropertyCategory.logical },
+//     },
+
+//     .@"border-top-style" = .{
+//         .ty = border.LineStyle,
+//         .logical_group = .{ .ty = LogicalGroup.border_style, .category = PropertyCategory.physical },
+//     },
+//     .@"border-bottom-style" = .{
+//         .ty = border.LineStyle,
+//         .logical_group = .{ .ty = LogicalGroup.border_style, .category = PropertyCategory.physical },
+//     },
+//     .@"border-left-style" = .{
+//         .ty = border.LineStyle,
+//         .logical_group = .{ .ty = LogicalGroup.border_style, .category = PropertyCategory.physical },
+//     },
+//     .@"border-right-style" = .{
+//         .ty = border.LineStyle,
+//         .logical_group = .{ .ty = LogicalGroup.border_style, .category = PropertyCategory.physical },
+//     },
+//     .@"border-block-start-style" = .{
+//         .ty = border.LineStyle,
+//         .logical_group = .{ .ty = LogicalGroup.border_style, .category = PropertyCategory.logical },
+//     },
+//     .@"border-block-end-style" = .{
+//         .ty = border.LineStyle,
+//         .logical_group = .{ .ty = LogicalGroup.border_style, .category = PropertyCategory.logical },
+//     },
+//     .@"border-inline-start-style" = .{
+//         .ty = border.LineStyle,
+//         .logical_group = .{ .ty = LogicalGroup.border_style, .category = PropertyCategory.logical },
+//     },
+//     .@"border-inline-end-style" = .{
+//         .ty = border.LineStyle,
+//         .logical_group = .{ .ty = LogicalGroup.border_style, .category = PropertyCategory.logical },
+//     },
+
+//     .@"border-top-width" = .{
+//         .ty = BorderSideWidth,
+//         .logical_group = .{ .ty = LogicalGroup.border_width, .category = PropertyCategory.physical },
+//     },
+//     .@"border-bottom-width" = .{
+//         .ty = BorderSideWidth,
+//         .logical_group = .{ .ty = LogicalGroup.border_width, .category = PropertyCategory.physical },
+//     },
+//     .@"border-left-width" = .{
+//         .ty = BorderSideWidth,
+//         .logical_group = .{ .ty = LogicalGroup.border_width, .category = PropertyCategory.physical },
+//     },
+//     .@"border-right-width" = .{
+//         .ty = BorderSideWidth,
+//         .logical_group = .{ .ty = LogicalGroup.border_width, .category = PropertyCategory.physical },
+//     },
+//     .@"border-block-start-width" = .{
+//         .ty = BorderSideWidth,
+//         .logical_group = .{ .ty = LogicalGroup.border_width, .category = PropertyCategory.logical },
+//     },
+//     .@"border-block-end-width" = .{
+//         .ty = BorderSideWidth,
+//         .logical_group = .{ .ty = LogicalGroup.border_width, .category = PropertyCategory.logical },
+//     },
+//     .@"border-inline-start-width" = .{
+//         .ty = BorderSideWidth,
+//         .logical_group = .{ .ty = LogicalGroup.border_width, .category = PropertyCategory.logical },
+//     },
+//     .@"border-inline-end-width" = .{
+//         .ty = BorderSideWidth,
+//         .logical_group = .{ .ty = LogicalGroup.border_width, .category = PropertyCategory.logical },
+//     },
+
+//     .@"border-top-left-radius" = .{
+//         .ty = struct { Size2D(LengthPercentage), css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//         },
+//         .logical_group = .{ .ty = LogicalGroup.border_radius, .category = PropertyCategory.physical },
+//     },
+//     .@"border-top-right-radius" = .{
+//         .ty = struct { Size2D(LengthPercentage), css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//         },
+//         .logical_group = .{ .ty = LogicalGroup.border_radius, .category = PropertyCategory.physical },
+//     },
+//     .@"border-bottom-left-radius" = .{
+//         .ty = struct { Size2D(LengthPercentage), css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//         },
+//         .logical_group = .{ .ty = LogicalGroup.border_radius, .category = PropertyCategory.physical },
+//     },
+//     .@"border-bottom-right-radius" = .{
+//         .ty = struct { Size2D(LengthPercentage), css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//         },
+//         .logical_group = .{ .ty = LogicalGroup.border_radius, .category = PropertyCategory.physical },
+//     },
+//     .@"border-start-start-radius" = .{
+//         .ty = Size2D(LengthPercentage),
+//         .logical_group = .{ .ty = LogicalGroup.border_radius, .category = PropertyCategory.logical },
+//     },
+//     .@"border-start-end-radius" = .{
+//         .ty = Size2D(LengthPercentage),
+//         .logical_group = .{ .ty = LogicalGroup.border_radius, .category = PropertyCategory.logical },
+//     },
+//     .@"border-end-start-radius" = .{
+//         .ty = Size2D(LengthPercentage),
+//         .logical_group = .{ .ty = LogicalGroup.border_radius, .category = PropertyCategory.logical },
+//     },
+//     .@"border-end-end-radius" = .{
+//         .ty = Size2D(LengthPercentage),
+//         .logical_group = .{ .ty = LogicalGroup.border_radius, .category = PropertyCategory.logical },
+//     },
+//     .@"border-radius" = .{
+//         .ty = struct { BorderRadius, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//         },
+//         .shorthand = true,
+//     },
+
+//     .@"border-image-source" = .{
+//         .ty = Image,
+//     },
+//     .@"border-image-outset" = .{
+//         .ty = Rect(LengthOrNumber),
+//     },
+//     .@"border-image-repeat" = .{
+//         .ty = BorderImageRepeat,
+//     },
+//     .@"border-image-width" = .{
+//         .ty = Rect(BorderImageSideWidth),
+//     },
+//     .@"border-image-slice" = .{
+//         .ty = BorderImageSlice,
+//     },
+//     .@"border-image" = .{
+//         .ty = struct { BorderImage, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//             .o = true,
+//         },
+//         .shorthand = true,
+//     },
+
+//     .@"border-color" = .{
+//         .ty = BorderColor,
+//         .shorthand = true,
+//     },
+//     .@"border-style" = .{
+//         .ty = BorderStyle,
+//         .shorthand = true,
+//     },
+//     .@"border-width" = .{
+//         .ty = BorderWidth,
+//         .shorthand = true,
+//     },
+
+//     .@"border-block-color" = .{
+//         .ty = BorderBlockColor,
+//         .shorthand = true,
+//     },
+//     .@"border-block-style" = .{
+//         .ty = BorderBlockStyle,
+//         .shorthand = true,
+//     },
+//     .@"border-block-width" = .{
+//         .ty = BorderBlockWidth,
+//         .shorthand = true,
+//     },
+
+//     .@"border-inline-color" = .{
+//         .ty = BorderInlineColor,
+//         .shorthand = true,
+//     },
+//     .@"border-inline-style" = .{
+//         .ty = BorderInlineStyle,
+//         .shorthand = true,
+//     },
+//     .@"border-inline-width" = .{
+//         .ty = BorderInlineWidth,
+//         .shorthand = true,
+//     },
+
+//     .border = .{
+//         .ty = Border,
+//         .shorthand = true,
+//     },
+//     .@"border-top" = .{
+//         .ty = BorderTop,
+//         .shorthand = true,
+//     },
+//     .@"border-bottom" = .{
+//         .ty = BorderBottom,
+//         .shorthand = true,
+//     },
+//     .@"border-left" = .{
+//         .ty = BorderLeft,
+//         .shorthand = true,
+//     },
+//     .@"border-right" = .{
+//         .ty = BorderRight,
+//         .shorthand = true,
+//     },
+//     .@"border-block" = .{
+//         .ty = BorderBlock,
+//         .shorthand = true,
+//     },
+//     .@"border-block-start" = .{
+//         .ty = BorderBlockStart,
+//         .shorthand = true,
+//     },
+//     .@"border-block-end" = .{
+//         .ty = BorderBlockEnd,
+//         .shorthand = true,
+//     },
+//     .@"border-inline" = .{
+//         .ty = BorderInline,
+//         .shorthand = true,
+//     },
+//     .@"border-inline-start" = .{
+//         .ty = BorderInlineStart,
+//         .shorthand = true,
+//     },
+//     .@"border-inline-end" = .{
+//         .ty = BorderInlineEnd,
+//         .shorthand = true,
+//     },
+
+//     .outline = .{
+//         .ty = Outline,
+//         .shorthand = true,
+//     },
+//     .@"outline-color" = .{
+//         .ty = CssColor,
+//     },
+//     .@"outline-style" = .{
+//         .ty = OutlineStyle,
+//     },
+//     .@"outline-width" = .{
+//         .ty = BorderSideWidth,
+//     },
+
+//     // Flex properties: https://www.w3.org/TR/2018/CR-css-flexbox-1-20181119
+//     .@"flex-direction" = .{
+//         .ty = struct { FlexDirection, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .ms = true,
+//         },
+//     },
+//     .@"flex-wrap" = .{
+//         .ty = struct { FlexWrap, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .ms = true,
+//         },
+//     },
+//     .@"flex-flow" = .{
+//         .ty = struct { FlexFlow, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .ms = true,
+//         },
+//         .shorthand = true,
+//     },
+//     .@"flex-grow" = .{
+//         .ty = struct { CSSNumber, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//         },
+//     },
+//     .@"flex-shrink" = .{
+//         .ty = struct { CSSNumber, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//         },
+//     },
+//     .@"flex-basis" = .{
+//         .ty = struct { LengthPercentageOrAuto, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//         },
+//     },
+//     .flex = .{
+//         .ty = struct { Flex, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .ms = true,
+//         },
+//         .shorthand = true,
+//     },
+//     .order = .{
+//         .ty = struct { CSSInteger, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//         },
+//     },
+
+//     // Align properties: https://www.w3.org/TR/2020/WD-css-align-3-20200421
+//     .@"align-content" = .{
+//         .ty = struct { AlignContent, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//         },
+//     },
+//     .@"justify-content" = .{
+//         .ty = struct { JustifyContent, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//         },
+//     },
+//     .@"place-content" = .{
+//         .ty = PlaceContent,
+//         .shorthand = true,
+//     },
+//     .@"align-self" = .{
+//         .ty = struct { AlignSelf, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//         },
+//     },
+//     .@"justify-self" = .{
+//         .ty = JustifySelf,
+//     },
+//     .@"place-self" = .{
+//         .ty = PlaceSelf,
+//         .shorthand = true,
+//     },
+//     .@"align-items" = .{
+//         .ty = struct { AlignItems, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//         },
+//     },
+//     .@"justify-items" = .{
+//         .ty = JustifyItems,
+//     },
+//     .@"place-items" = .{
+//         .ty = PlaceItems,
+//         .shorthand = true,
+//     },
+//     .@"row-gap" = .{
+//         .ty = GapValue,
+//     },
+//     .@"column-gap" = .{
+//         .ty = GapValue,
+//     },
+//     .gap = .{
+//         .ty = Gap,
+//         .shorthand = true,
+//     },
+
+//     // Old flex (2009): https://www.w3.org/TR/2009/WD-css3-flexbox-20090723/
+//     .@"box-orient" = .{
+//         .ty = struct { BoxOrient, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//         },
+//         .unprefixed = false,
+//     },
+//     .@"box-direction" = .{
+//         .ty = struct { BoxDirection, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//         },
+//         .unprefixed = false,
+//     },
+//     .@"box-ordinal-group" = .{
+//         .ty = struct { CSSInteger, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//         },
+//         .unprefixed = false,
+//     },
+//     .@"box-align" = .{
+//         .ty = struct { BoxAlign, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//         },
+//         .unprefixed = false,
+//     },
+//     .@"box-flex" = .{
+//         .ty = struct { CSSNumber, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//         },
+//         .unprefixed = false,
+//     },
+//     .@"box-flex-group" = .{
+//         .ty = struct { CSSInteger, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//         },
+//         .unprefixed = false,
+//     },
+//     .@"box-pack" = .{
+//         .ty = struct { BoxPack, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//         },
+//         .unprefixed = false,
+//     },
+//     .@"box-lines" = .{
+//         .ty = struct { BoxLines, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//         },
+//         .unprefixed = false,
+//     },
+
+//     // Old flex (2012): https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/
+//     .@"flex-pack" = .{
+//         .ty = struct { FlexPack, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .ms = true,
+//         },
+//         .unprefixed = false,
+//     },
+//     .@"flex-order" = .{
+//         .ty = struct { CSSInteger, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .ms = true,
+//         },
+//         .unprefixed = false,
+//     },
+//     .@"flex-align" = .{
+//         .ty = struct { BoxAlign, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .ms = true,
+//         },
+//         .unprefixed = false,
+//     },
+//     .@"flex-item-align" = .{
+//         .ty = struct { FlexItemAlign, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .ms = true,
+//         },
+//         .unprefixed = false,
+//     },
+//     .@"flex-line-pack" = .{
+//         .ty = struct { FlexLinePack, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .ms = true,
+//         },
+//         .unprefixed = false,
+//     },
+
+//     // Microsoft extensions
+//     .@"flex-positive" = .{
+//         .ty = struct { CSSNumber, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .ms = true,
+//         },
+//         .unprefixed = false,
+//     },
+//     .@"flex-negative" = .{
+//         .ty = struct { CSSNumber, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .ms = true,
+//         },
+//         .unprefixed = false,
+//     },
+//     .@"flex-preferred-size" = .{
+//         .ty = struct { LengthPercentageOrAuto, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .ms = true,
+//         },
+//         .unprefixed = false,
+//     },
+
+//     // TODO: the following is enabled with #[cfg(feature = "grid")]
+//     // .@"grid-template-columns" = .{
+//     //     .ty = TrackSizing,
+//     // },
+//     // .@"grid-template-rows" = .{
+//     //     .ty = TrackSizing,
+//     // },
+//     // .@"grid-auto-columns" = .{
+//     //     .ty = TrackSizeList,
+//     // },
+//     // .@"grid-auto-rows" = .{
+//     //     .ty = TrackSizeList,
+//     // },
+//     // .@"grid-auto-flow" = .{
+//     //     .ty = GridAutoFlow,
+//     // },
+//     // .@"grid-template-areas" = .{
+//     //     .ty = GridTemplateAreas,
+//     // },
+//     // .@"grid-template" = .{
+//     //     .ty = GridTemplate,
+//     //     .shorthand = true,
+//     // },
+//     // .grid = .{
+//     //     .ty = Grid,
+//     //     .shorthand = true,
+//     // },
+//     // .@"grid-row-start" = .{
+//     //     .ty = GridLine,
+//     // },
+//     // .@"grid-row-end" = .{
+//     //     .ty = GridLine,
+//     // },
+//     // .@"grid-column-start" = .{
+//     //     .ty = GridLine,
+//     // },
+//     // .@"grid-column-end" = .{
+//     //     .ty = GridLine,
+//     // },
+//     // .@"grid-row" = .{
+//     //     .ty = GridRow,
+//     //     .shorthand = true,
+//     // },
+//     // .@"grid-column" = .{
+//     //     .ty = GridColumn,
+//     //     .shorthand = true,
+//     // },
+//     // .@"grid-area" = .{
+//     //     .ty = GridArea,
+//     //     .shorthand = true,
+//     // },
+
+//     .@"margin-top" = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.margin, .category = PropertyCategory.physical },
+//     },
+//     .@"margin-bottom" = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.margin, .category = PropertyCategory.physical },
+//     },
+//     .@"margin-left" = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.margin, .category = PropertyCategory.physical },
+//     },
+//     .@"margin-right" = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.margin, .category = PropertyCategory.physical },
+//     },
+//     .@"margin-block-start" = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.margin, .category = PropertyCategory.logical },
+//     },
+//     .@"margin-block-end" = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.margin, .category = PropertyCategory.logical },
+//     },
+//     .@"margin-inline-start" = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.margin, .category = PropertyCategory.logical },
+//     },
+//     .@"margin-inline-end" = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.margin, .category = PropertyCategory.logical },
+//     },
+//     .@"margin-block" = .{
+//         .ty = MarginBlock,
+//         .shorthand = true,
+//     },
+//     .@"margin-inline" = .{
+//         .ty = MarginInline,
+//         .shorthand = true,
+//     },
+//     .margin = .{
+//         .ty = Margin,
+//         .shorthand = true,
+//     },
+
+//     .@"padding-top" = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.padding, .category = PropertyCategory.physical },
+//     },
+//     .@"padding-bottom" = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.padding, .category = PropertyCategory.physical },
+//     },
+//     .@"padding-left" = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.padding, .category = PropertyCategory.physical },
+//     },
+//     .@"padding-right" = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.padding, .category = PropertyCategory.physical },
+//     },
+//     .@"padding-block-start" = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.padding, .category = PropertyCategory.logical },
+//     },
+//     .@"padding-block-end" = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.padding, .category = PropertyCategory.logical },
+//     },
+//     .@"padding-inline-start" = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.padding, .category = PropertyCategory.logical },
+//     },
+//     .@"padding-inline-end" = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.padding, .category = PropertyCategory.logical },
+//     },
+//     .@"padding-block" = .{
+//         .ty = PaddingBlock,
+//         .shorthand = true,
+//     },
+//     .@"padding-inline" = .{
+//         .ty = PaddingInline,
+//         .shorthand = true,
+//     },
+//     .padding = .{
+//         .ty = Padding,
+//         .shorthand = true,
+//     },
+
+//     .@"scroll-margin-top" = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.scroll_margin, .category = PropertyCategory.physical },
+//     },
+//     .@"scroll-margin-bottom" = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.scroll_margin, .category = PropertyCategory.physical },
+//     },
+//     .@"scroll-margin-left" = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.scroll_margin, .category = PropertyCategory.physical },
+//     },
+//     .@"scroll-margin-right" = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.scroll_margin, .category = PropertyCategory.physical },
+//     },
+//     .@"scroll-margin-block-start" = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.scroll_margin, .category = PropertyCategory.logical },
+//     },
+//     .@"scroll-margin-block-end" = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.scroll_margin, .category = PropertyCategory.logical },
+//     },
+//     .@"scroll-margin-inline-start" = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.scroll_margin, .category = PropertyCategory.logical },
+//     },
+//     .@"scroll-margin-inline-end" = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.scroll_margin, .category = PropertyCategory.logical },
+//     },
+//     .@"scroll-margin-block" = .{
+//         .ty = ScrollMarginBlock,
+//         .shorthand = true,
+//     },
+//     .@"scroll-margin-inline" = .{
+//         .ty = ScrollMarginInline,
+//         .shorthand = true,
+//     },
+//     .@"scroll-margin" = .{
+//         .ty = ScrollMargin,
+//         .shorthand = true,
+//     },
+
+//     .@"scroll-padding-top" = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.scroll_padding, .category = PropertyCategory.physical },
+//     },
+//     .@"scroll-padding-bottom" = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.scroll_padding, .category = PropertyCategory.physical },
+//     },
+//     .@"scroll-padding-left" = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.scroll_padding, .category = PropertyCategory.physical },
+//     },
+//     .@"scroll-padding-right" = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.scroll_padding, .category = PropertyCategory.physical },
+//     },
+//     .@"scroll-padding-block-start" = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.scroll_padding, .category = PropertyCategory.logical },
+//     },
+//     .@"scroll-padding-block-end" = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.scroll_padding, .category = PropertyCategory.logical },
+//     },
+//     .@"scroll-padding-inline-start" = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.scroll_padding, .category = PropertyCategory.logical },
+//     },
+//     .@"scroll-padding-inline-end" = .{
+//         .ty = LengthPercentageOrAuto,
+//         .logical_group = .{ .ty = LogicalGroup.scroll_padding, .category = PropertyCategory.logical },
+//     },
+//     .@"scroll-padding-block" = .{
+//         .ty = ScrollPaddingBlock,
+//         .shorthand = true,
+//     },
+//     .@"scroll-padding-inline" = .{
+//         .ty = ScrollPaddingInline,
+//         .shorthand = true,
+//     },
+//     .@"scroll-padding" = .{
+//         .ty = ScrollPadding,
+//         .shorthand = true,
+//     },
+
+//     .@"font-weight" = .{
+//         .ty = FontWeight,
+//     },
+//     .@"font-size" = .{
+//         .ty = FontSize,
+//     },
+//     .@"font-stretch" = .{
+//         .ty = FontStretch,
+//     },
+//     .@"font-family" = .{
+//         .ty = ArrayList(FontFamily),
+//     },
+//     .@"font-style" = .{
+//         .ty = FontStyle,
+//     },
+//     .@"font-variant-caps" = .{
+//         .ty = FontVariantCaps,
+//     },
+//     .@"line-height" = .{
+//         .ty = LineHeight,
+//     },
+//     .font = .{
+//         .ty = Font,
+//         .shorthand = true,
+//     },
+//     .@"vertical-align" = .{
+//         .ty = VerticalAlign,
+//     },
+//     .@"font-palette" = .{
+//         .ty = DashedIdentReference,
+//     },
+
+//     .@"transition-property" = .{
+//         .ty = struct { SmallListPropertyIdPlaceholder, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//             .ms = true,
+//         },
+//     },
+//     .@"transition-duration" = .{
+//         .ty = struct { SmallList(Time, 1), css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//             .ms = true,
+//         },
+//     },
+//     .@"transition-delay" = .{
+//         .ty = struct { SmallList(Time, 1), css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//             .ms = true,
+//         },
+//     },
+//     .@"transition-timing-function" = .{
+//         .ty = struct { SmallList(EasingFunction, 1), css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//             .ms = true,
+//         },
+//     },
+//     .transition = .{
+//         .ty = struct { SmallList(Transition, 1), css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//             .ms = true,
+//         },
+//         .shorthand = true,
+//     },
+
+//     .@"animation-name" = .{
+//         .ty = struct { AnimationNameList, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//             .o = true,
+//         },
+//     },
+//     .@"animation-duration" = .{
+//         .ty = struct { SmallList(Time, 1), css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//             .o = true,
+//         },
+//     },
+//     .@"animation-timing-function" = .{
+//         .ty = struct { SmallList(EasingFunction, 1), css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//             .o = true,
+//         },
+//     },
+//     .@"animation-iteration-count" = .{
+//         .ty = struct { SmallList(AnimationIterationCount, 1), css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//             .o = true,
+//         },
+//     },
+//     .@"animation-direction" = .{
+//         .ty = struct { SmallList(AnimationDirection, 1), css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//             .o = true,
+//         },
+//     },
+//     .@"animation-play-state" = .{
+//         .ty = struct { SmallList(AnimationPlayState, 1), css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//             .o = true,
+//         },
+//     },
+//     .@"animation-delay" = .{
+//         .ty = struct { SmallList(Time, 1), css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//             .o = true,
+//         },
+//     },
+//     .@"animation-fill-mode" = .{
+//         .ty = struct { SmallList(AnimationFillMode, 1), css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//             .o = true,
+//         },
+//     },
+//     .@"animation-composition" = .{
+//         .ty = SmallList(AnimationComposition, 1),
+//     },
+//     .@"animation-timeline" = .{
+//         .ty = SmallList(AnimationTimeline, 1),
+//     },
+//     .@"animation-range-start" = .{
+//         .ty = SmallList(AnimationRangeStart, 1),
+//     },
+//     .@"animation-range-end" = .{
+//         .ty = SmallList(AnimationRangeEnd, 1),
+//     },
+//     .@"animation-range" = .{
+//         .ty = SmallList(AnimationRange, 1),
+//     },
+//     .animation = .{
+//         .ty = struct { AnimationList, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//             .o = true,
+//         },
+//         .shorthand = true,
+//     },
+
+//     // https://drafts.csswg.org/css-transforms-2/
+//     .transform = .{
+//         .ty = struct { TransformList, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//             .ms = true,
+//             .o = true,
+//         },
+//     },
+//     .@"transform-origin" = .{
+//         .ty = struct { Position, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//             .ms = true,
+//             .o = true,
+//         },
+//         // TODO: handle z offset syntax
+//     },
+//     .@"transform-style" = .{
+//         .ty = struct { TransformStyle, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//         },
+//     },
+//     .@"transform-box" = .{
+//         .ty = TransformBox,
+//     },
+//     .@"backface-visibility" = .{
+//         .ty = struct { BackfaceVisibility, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//         },
+//     },
+//     .perspective = .{
+//         .ty = struct { Perspective, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//         },
+//     },
+//     .@"perspective-origin" = .{
+//         .ty = struct { Position, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//         },
+//     },
+//     .translate = .{
+//         .ty = Translate,
+//     },
+//     .rotate = .{
+//         .ty = Rotate,
+//     },
+//     .scale = .{
+//         .ty = Scale,
+//     },
+
+//     // https://www.w3.org/TR/2021/CRD-css-text-3-20210422
+//     .@"text-transform" = .{
+//         .ty = TextTransform,
+//     },
+//     .@"white-space" = .{
+//         .ty = WhiteSpace,
+//     },
+//     .@"tab-size" = .{
+//         .ty = struct { LengthOrNumber, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .moz = true,
+//             .o = true,
+//         },
+//     },
+//     .@"word-break" = .{
+//         .ty = WordBreak,
+//     },
+//     .@"line-break" = .{
+//         .ty = LineBreak,
+//     },
+//     .hyphens = .{
+//         .ty = struct { Hyphens, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//             .ms = true,
+//         },
+//     },
+//     .@"overflow-wrap" = .{
+//         .ty = OverflowWrap,
+//     },
+//     .@"word-wrap" = .{
+//         .ty = OverflowWrap,
+//     },
+//     .@"text-align" = .{
+//         .ty = TextAlign,
+//     },
+//     .@"text-align-last" = .{
+//         .ty = struct { TextAlignLast, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .moz = true,
+//         },
+//     },
+//     .@"text-justify" = .{
+//         .ty = TextJustify,
+//     },
+//     .@"word-spacing" = .{
+//         .ty = Spacing,
+//     },
+//     .@"letter-spacing" = .{
+//         .ty = Spacing,
+//     },
+//     .@"text-indent" = .{
+//         .ty = TextIndent,
+//     },
+
+//     // https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506
+//     .@"text-decoration-line" = .{
+//         .ty = struct { TextDecorationLine, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//         },
+//     },
+//     .@"text-decoration-style" = .{
+//         .ty = struct { TextDecorationStyle, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//         },
+//     },
+//     .@"text-decoration-color" = .{
+//         .ty = struct { CssColor, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//         },
+//     },
+//     .@"text-decoration-thickness" = .{
+//         .ty = TextDecorationThickness,
+//     },
+//     .@"text-decoration" = .{
+//         .ty = struct { TextDecoration, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//         },
+//         .shorthand = true,
+//     },
+//     .@"text-decoration-skip-ink" = .{
+//         .ty = struct { TextDecorationSkipInk, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//         },
+//     },
+//     .@"text-emphasis-style" = .{
+//         .ty = struct { TextEmphasisStyle, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//         },
+//     },
+//     .@"text-emphasis-color" = .{
+//         .ty = struct { CssColor, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//         },
+//     },
+//     .@"text-emphasis" = .{
+//         .ty = struct { TextEmphasis, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//         },
+//         .shorthand = true,
+//     },
+//     .@"text-emphasis-position" = .{
+//         .ty = struct { TextEmphasisPosition, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//         },
+//     },
+//     .@"text-shadow" = .{
+//         .ty = SmallList(TextShadow, 1),
+//     },
+
+//     // https://w3c.github.io/csswg-drafts/css-size-adjust/
+//     .@"text-size-adjust" = .{
+//         .ty = struct { TextSizeAdjust, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//             .ms = true,
+//         },
+//     },
+
+//     // https://drafts.csswg.org/css-writing-modes-3/
+//     .direction = .{
+//         .ty = Direction,
+//     },
+//     .@"unicode-bidi" = .{
+//         .ty = UnicodeBidi,
+//     },
+
+//     // https://www.w3.org/TR/css-break-3/
+//     .@"box-decoration-break" = .{
+//         .ty = struct { BoxDecorationBreak, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//         },
+//     },
+
+//     // https://www.w3.org/TR/2021/WD-css-ui-4-20210316
+//     .resize = .{
+//         .ty = Resize,
+//     },
+//     .cursor = .{
+//         .ty = Cursor,
+//     },
+//     .@"caret-color" = .{
+//         .ty = ColorOrAuto,
+//     },
+//     .@"caret-shape" = .{
+//         .ty = CaretShape,
+//     },
+//     .caret = .{
+//         .ty = Caret,
+//         .shorthand = true,
+//     },
+//     .@"user-select" = .{
+//         .ty = struct { UserSelect, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//             .ms = true,
+//         },
+//     },
+//     .@"accent-color" = .{
+//         .ty = ColorOrAuto,
+//     },
+//     .appearance = .{
+//         .ty = struct { Appearance, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//             .moz = true,
+//             .ms = true,
+//         },
+//     },
+
+//     // https://www.w3.org/TR/2020/WD-css-lists-3-20201117
+//     .@"list-style-type" = .{
+//         .ty = ListStyleType,
+//     },
+//     .@"list-style-image" = .{
+//         .ty = Image,
+//     },
+//     .@"list-style-position" = .{
+//         .ty = ListStylePosition,
+//     },
+//     .@"list-style" = .{
+//         .ty = ListStyle,
+//         .shorthand = true,
+//     },
+//     .@"marker-side" = .{
+//         .ty = MarkerSide,
+//     },
+
+//     // CSS modules
+//     .composes = .{
+//         .ty = Composes,
+//         .conditional = .{
+//             .css_modules = true,
+//         },
+//     },
+
+//     // https://www.w3.org/TR/SVG2/painting.html
+//     .fill = .{
+//         .ty = SVGPaint,
+//     },
+//     .@"fill-rule" = .{
+//         .ty = FillRule,
+//     },
+//     .@"fill-opacity" = .{
+//         .ty = AlphaValue,
+//     },
+//     .stroke = .{
+//         .ty = SVGPaint,
+//     },
+//     .@"stroke-opacity" = .{
+//         .ty = AlphaValue,
+//     },
+//     .@"stroke-width" = .{
+//         .ty = LengthPercentage,
+//     },
+//     .@"stroke-linecap" = .{
+//         .ty = StrokeLinecap,
+//     },
+//     .@"stroke-linejoin" = .{
+//         .ty = StrokeLinejoin,
+//     },
+//     .@"stroke-miterlimit" = .{
+//         .ty = CSSNumber,
+//     },
+//     .@"stroke-dasharray" = .{
+//         .ty = StrokeDasharray,
+//     },
+//     .@"stroke-dashoffset" = .{
+//         .ty = LengthPercentage,
+//     },
+//     .@"marker-start" = .{
+//         .ty = Marker,
+//     },
+//     .@"marker-mid" = .{
+//         .ty = Marker,
+//     },
+//     .@"marker-end" = .{
+//         .ty = Marker,
+//     },
+//     .marker = .{
+//         .ty = Marker,
+//     },
+//     .@"color-interpolation" = .{
+//         .ty = ColorInterpolation,
+//     },
+//     .@"color-interpolation-filters" = .{
+//         .ty = ColorInterpolation,
+//     },
+//     .@"color-rendering" = .{
+//         .ty = ColorRendering,
+//     },
+//     .@"shape-rendering" = .{
+//         .ty = ShapeRendering,
+//     },
+//     .@"text-rendering" = .{
+//         .ty = TextRendering,
+//     },
+//     .@"image-rendering" = .{
+//         .ty = ImageRendering,
+//     },
+
+//     // https://www.w3.org/TR/css-masking-1/
+//     .@"clip-path" = .{
+//         .ty = struct { ClipPath, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//         },
+//     },
+//     .@"clip-rule" = .{
+//         .ty = FillRule,
+//     },
+//     .@"mask-image" = .{
+//         .ty = struct { SmallList(Image, 1), css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//         },
+//     },
+//     .@"mask-mode" = .{
+//         .ty = SmallList(MaskMode, 1),
+//     },
+//     .@"mask-repeat" = .{
+//         .ty = struct { SmallList(BackgroundRepeat, 1), css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//         },
+//     },
+//     .@"mask-position-x" = .{
+//         .ty = SmallList(HorizontalPosition, 1),
+//     },
+//     .@"mask-position-y" = .{
+//         .ty = SmallList(VerticalPosition, 1),
+//     },
+//     .@"mask-position" = .{
+//         .ty = struct { SmallList(Position, 1), css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//         },
+//     },
+//     .@"mask-clip" = .{
+//         .ty = struct { SmallList(MaskClip, 1), css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//         },
+//     },
+//     .@"mask-origin" = .{
+//         .ty = struct { SmallList(GeometryBox, 1), css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//         },
+//     },
+//     .@"mask-size" = .{
+//         .ty = struct { SmallList(BackgroundSize, 1), css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//         },
+//     },
+//     .@"mask-composite" = .{
+//         .ty = SmallList(MaskComposite, 1),
+//     },
+//     .@"mask-type" = .{
+//         .ty = MaskType,
+//     },
+//     .mask = .{
+//         .ty = struct { SmallList(Mask, 1), css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//         },
+//         .shorthand = true,
+//     },
+//     .@"mask-border-source" = .{
+//         .ty = Image,
+//     },
+//     .@"mask-border-mode" = .{
+//         .ty = MaskBorderMode,
+//     },
+//     .@"mask-border-slice" = .{
+//         .ty = BorderImageSlice,
+//     },
+//     .@"mask-border-width" = .{
+//         .ty = Rect(BorderImageSideWidth),
+//     },
+//     .@"mask-border-outset" = .{
+//         .ty = Rect(LengthOrNumber),
+//     },
+//     .@"mask-border-repeat" = .{
+//         .ty = BorderImageRepeat,
+//     },
+//     .@"mask-border" = .{
+//         .ty = MaskBorder,
+//         .shorthand = true,
+//     },
+
+//     // WebKit additions
+//     .@"-webkit-mask-composite" = .{
+//         .ty = SmallList(WebKitMaskComposite, 1),
+//     },
+//     .@"mask-source-type" = .{
+//         .ty = struct { SmallList(WebKitMaskSourceType, 1), css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//         },
+//         .unprefixed = false,
+//     },
+//     .@"mask-box-image" = .{
+//         .ty = struct { BorderImage, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//         },
+//         .unprefixed = false,
+//     },
+//     .@"mask-box-image-source" = .{
+//         .ty = struct { Image, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//         },
+//         .unprefixed = false,
+//     },
+//     .@"mask-box-image-slice" = .{
+//         .ty = struct { BorderImageSlice, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//         },
+//         .unprefixed = false,
+//     },
+//     .@"mask-box-image-width" = .{
+//         .ty = struct { Rect(BorderImageSideWidth), css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//         },
+//         .unprefixed = false,
+//     },
+//     .@"mask-box-image-outset" = .{
+//         .ty = struct { Rect(LengthOrNumber), css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//         },
+//         .unprefixed = false,
+//     },
+//     .@"mask-box-image-repeat" = .{
+//         .ty = struct { BorderImageRepeat, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//         },
+//         .unprefixed = false,
+//     },
+
+//     // https://drafts.fxtf.org/filter-effects-1/
+//     .filter = .{
+//         .ty = struct { FilterList, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//         },
+//     },
+//     .@"backdrop-filter" = .{
+//         .ty = struct { FilterList, css.VendorPrefix },
+//         .valid_prefixes = css.VendorPrefix{
+//             .webkit = true,
+//         },
+//     },
+
+//     // https://drafts.csswg.org/css2/
+//     .@"z-index" = .{
+//         .ty = position.ZIndex,
+//     },
+
+//     // https://drafts.csswg.org/css-contain-3/
+//     .@"container-type" = .{
+//         .ty = ContainerType,
+//     },
+//     .@"container-name" = .{
+//         .ty = ContainerNameList,
+//     },
+//     .container = .{
+//         .ty = Container,
+//         .shorthand = true,
+//     },
+
+//     // https://w3c.github.io/csswg-drafts/css-view-transitions-1/
+//     .@"view-transition-name" = .{
+//         .ty = CustomIdent,
+//     },
+
+//     // https://drafts.csswg.org/css-color-adjust/
+//     .@"color-scheme" = .{
+//         .ty = ColorScheme,
+//     },
+// });
diff --git a/src/css/properties/properties_generated.zig b/src/css/properties/properties_generated.zig
new file mode 100644
index 0000000000..be76ee77a7
--- /dev/null
+++ b/src/css/properties/properties_generated.zig
@@ -0,0 +1,9686 @@
+const std = @import("std");
+const bun = @import("root").bun;
+const Allocator = std.mem.Allocator;
+
+pub const css = @import("../css_parser.zig");
+
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const VendorPrefix = css.VendorPrefix;
+
+const PropertyImpl = @import("./properties_impl.zig").PropertyImpl;
+const PropertyIdImpl = @import("./properties_impl.zig").PropertyIdImpl;
+
+const CSSWideKeyword = css.css_properties.CSSWideKeyword;
+const UnparsedProperty = css.css_properties.custom.UnparsedProperty;
+const CustomProperty = css.css_properties.custom.CustomProperty;
+
+const css_values = css.css_values;
+const CssColor = css.css_values.color.CssColor;
+const Image = css.css_values.image.Image;
+const Length = css.css_values.length.Length;
+const LengthValue = css.css_values.length.LengthValue;
+const LengthPercentage = css_values.length.LengthPercentage;
+const LengthPercentageOrAuto = css_values.length.LengthPercentageOrAuto;
+const PropertyCategory = css.PropertyCategory;
+const LogicalGroup = css.LogicalGroup;
+const CSSNumber = css.css_values.number.CSSNumber;
+const CSSNumberFns = css.css_values.number.CSSNumberFns;
+const CSSInteger = css.css_values.number.CSSInteger;
+const CSSIntegerFns = css.css_values.number.CSSIntegerFns;
+const NumberOrPercentage = css.css_values.percentage.NumberOrPercentage;
+const Percentage = css.css_values.percentage.Percentage;
+const Angle = css.css_values.angle.Angle;
+const DashedIdentReference = css.css_values.ident.DashedIdentReference;
+const Time = css.css_values.time.Time;
+const EasingFunction = css.css_values.easing.EasingFunction;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CSSString = css.css_values.string.CSSString;
+const DashedIdent = css.css_values.ident.DashedIdent;
+const Url = css.css_values.url.Url;
+const CustomIdentList = css.css_values.ident.CustomIdentList;
+const Location = css.Location;
+const HorizontalPosition = css.css_values.position.HorizontalPosition;
+const VerticalPosition = css.css_values.position.VerticalPosition;
+const ContainerName = css.css_rules.container.ContainerName;
+
+pub const font = css.css_properties.font;
+const border = css.css_properties.border;
+const border_radius = css.css_properties.border_radius;
+const border_image = css.css_properties.border_image;
+const outline = css.css_properties.outline;
+const flex = css.css_properties.flex;
+const @"align" = css.css_properties.@"align";
+const margin_padding = css.css_properties.margin_padding;
+const transition = css.css_properties.transition;
+const animation = css.css_properties.animation;
+const transform = css.css_properties.transform;
+const text = css.css_properties.text;
+const ui = css.css_properties.ui;
+const list = css.css_properties.list;
+const css_modules = css.css_properties.css_modules;
+const svg = css.css_properties.svg;
+const shape = css.css_properties.shape;
+const masking = css.css_properties.masking;
+const background = css.css_properties.background;
+const effects = css.css_properties.effects;
+const contain = css.css_properties.contain;
+const custom = css.css_properties.custom;
+const position = css.css_properties.position;
+const box_shadow = css.css_properties.box_shadow;
+const size = css.css_properties.size;
+const overflow = css.css_properties.overflow;
+
+const BorderSideWidth = border.BorderSideWidth;
+const Size2D = css_values.size.Size2D;
+const BorderRadius = border_radius.BorderRadius;
+const Rect = css_values.rect.Rect;
+const LengthOrNumber = css_values.length.LengthOrNumber;
+const BorderImageRepeat = border_image.BorderImageRepeat;
+const BorderImageSideWidth = border_image.BorderImageSideWidth;
+const BorderImageSlice = border_image.BorderImageSlice;
+const BorderImage = border_image.BorderImage;
+const BorderColor = border.BorderColor;
+const BorderStyle = border.BorderStyle;
+const BorderWidth = border.BorderWidth;
+const BorderBlockColor = border.BorderBlockColor;
+const BorderBlockStyle = border.BorderBlockStyle;
+const BorderBlockWidth = border.BorderBlockWidth;
+const BorderInlineColor = border.BorderInlineColor;
+const BorderInlineStyle = border.BorderInlineStyle;
+const BorderInlineWidth = border.BorderInlineWidth;
+const Border = border.Border;
+const BorderTop = border.BorderTop;
+const BorderRight = border.BorderRight;
+const BorderLeft = border.BorderLeft;
+const BorderBottom = border.BorderBottom;
+const BorderBlockStart = border.BorderBlockStart;
+const BorderBlockEnd = border.BorderBlockEnd;
+const BorderInlineStart = border.BorderInlineStart;
+const BorderInlineEnd = border.BorderInlineEnd;
+const BorderBlock = border.BorderBlock;
+const BorderInline = border.BorderInline;
+const Outline = outline.Outline;
+const OutlineStyle = outline.OutlineStyle;
+const FlexDirection = flex.FlexDirection;
+const FlexWrap = flex.FlexWrap;
+const FlexFlow = flex.FlexFlow;
+const Flex = flex.Flex;
+const BoxOrient = flex.BoxOrient;
+const BoxDirection = flex.BoxDirection;
+const BoxAlign = flex.BoxAlign;
+const BoxPack = flex.BoxPack;
+const BoxLines = flex.BoxLines;
+const FlexPack = flex.FlexPack;
+const FlexItemAlign = flex.FlexItemAlign;
+const FlexLinePack = flex.FlexLinePack;
+const AlignContent = @"align".AlignContent;
+const JustifyContent = @"align".JustifyContent;
+const PlaceContent = @"align".PlaceContent;
+const AlignSelf = @"align".AlignSelf;
+const JustifySelf = @"align".JustifySelf;
+const PlaceSelf = @"align".PlaceSelf;
+const AlignItems = @"align".AlignItems;
+const JustifyItems = @"align".JustifyItems;
+const PlaceItems = @"align".PlaceItems;
+const GapValue = @"align".GapValue;
+const Gap = @"align".Gap;
+const MarginBlock = margin_padding.MarginBlock;
+const Margin = margin_padding.Margin;
+const MarginInline = margin_padding.MarginInline;
+const PaddingBlock = margin_padding.PaddingBlock;
+const PaddingInline = margin_padding.PaddingInline;
+const Padding = margin_padding.Padding;
+const ScrollMarginBlock = margin_padding.ScrollMarginBlock;
+const ScrollMarginInline = margin_padding.ScrollMarginInline;
+const ScrollMargin = margin_padding.ScrollMargin;
+const ScrollPaddingBlock = margin_padding.ScrollPaddingBlock;
+const ScrollPaddingInline = margin_padding.ScrollPaddingInline;
+const ScrollPadding = margin_padding.ScrollPadding;
+const FontWeight = font.FontWeight;
+const FontSize = font.FontSize;
+const FontStretch = font.FontStretch;
+const FontFamily = font.FontFamily;
+const FontStyle = font.FontStyle;
+const FontVariantCaps = font.FontVariantCaps;
+const LineHeight = font.LineHeight;
+const Font = font.Font;
+// const VerticalAlign = font.VerticalAlign;
+// const Transition = transition.Transition;
+// const AnimationNameList = animation.AnimationNameList;
+// const AnimationList = animation.AnimationList;
+// const AnimationIterationCount = animation.AnimationIterationCount;
+// const AnimationDirection = animation.AnimationDirection;
+// const AnimationPlayState = animation.AnimationPlayState;
+// const AnimationFillMode = animation.AnimationFillMode;
+// const AnimationComposition = animation.AnimationComposition;
+// const AnimationTimeline = animation.AnimationTimeline;
+// const AnimationRangeStart = animation.AnimationRangeStart;
+// const AnimationRangeEnd = animation.AnimationRangeEnd;
+// const AnimationRange = animation.AnimationRange;
+// const TransformList = transform.TransformList;
+// const TransformStyle = transform.TransformStyle;
+// const TransformBox = transform.TransformBox;
+// const BackfaceVisibility = transform.BackfaceVisibility;
+// const Perspective = transform.Perspective;
+// const Translate = transform.Translate;
+// const Rotate = transform.Rotate;
+// const Scale = transform.Scale;
+// const TextTransform = text.TextTransform;
+// const WhiteSpace = text.WhiteSpace;
+// const WordBreak = text.WordBreak;
+// const LineBreak = text.LineBreak;
+// const Hyphens = text.Hyphens;
+// const OverflowWrap = text.OverflowWrap;
+// const TextAlign = text.TextAlign;
+// const TextIndent = text.TextIndent;
+// const Spacing = text.Spacing;
+// const TextJustify = text.TextJustify;
+// const TextAlignLast = text.TextAlignLast;
+// const TextDecorationLine = text.TextDecorationLine;
+// const TextDecorationStyle = text.TextDecorationStyle;
+// const TextDecorationThickness = text.TextDecorationThickness;
+// const TextDecoration = text.TextDecoration;
+// const TextDecorationSkipInk = text.TextDecorationSkipInk;
+// const TextEmphasisStyle = text.TextEmphasisStyle;
+// const TextEmphasis = text.TextEmphasis;
+// const TextEmphasisPositionVertical = text.TextEmphasisPositionVertical;
+// const TextEmphasisPositionHorizontal = text.TextEmphasisPositionHorizontal;
+// const TextEmphasisPosition = text.TextEmphasisPosition;
+const TextShadow = text.TextShadow;
+// const TextSizeAdjust = text.TextSizeAdjust;
+const Direction = text.Direction;
+// const UnicodeBidi = text.UnicodeBidi;
+// const BoxDecorationBreak = text.BoxDecorationBreak;
+// const Resize = ui.Resize;
+// const Cursor = ui.Cursor;
+// const ColorOrAuto = ui.ColorOrAuto;
+// const CaretShape = ui.CaretShape;
+// const Caret = ui.Caret;
+// const UserSelect = ui.UserSelect;
+// const Appearance = ui.Appearance;
+// const ColorScheme = ui.ColorScheme;
+// const ListStyleType = list.ListStyleType;
+// const ListStylePosition = list.ListStylePosition;
+// const ListStyle = list.ListStyle;
+// const MarkerSide = list.MarkerSide;
+const Composes = css_modules.Composes;
+// const SVGPaint = svg.SVGPaint;
+// const FillRule = shape.FillRule;
+// const AlphaValue = shape.AlphaValue;
+// const StrokeLinecap = svg.StrokeLinecap;
+// const StrokeLinejoin = svg.StrokeLinejoin;
+// const StrokeDasharray = svg.StrokeDasharray;
+// const Marker = svg.Marker;
+// const ColorInterpolation = svg.ColorInterpolation;
+// const ColorRendering = svg.ColorRendering;
+// const ShapeRendering = svg.ShapeRendering;
+// const TextRendering = svg.TextRendering;
+// const ImageRendering = svg.ImageRendering;
+const ClipPath = masking.ClipPath;
+const MaskMode = masking.MaskMode;
+const MaskClip = masking.MaskClip;
+const GeometryBox = masking.GeometryBox;
+const MaskComposite = masking.MaskComposite;
+const MaskType = masking.MaskType;
+const Mask = masking.Mask;
+const MaskBorderMode = masking.MaskBorderMode;
+const MaskBorder = masking.MaskBorder;
+const WebKitMaskComposite = masking.WebKitMaskComposite;
+const WebKitMaskSourceType = masking.WebKitMaskSourceType;
+const BackgroundRepeat = background.BackgroundRepeat;
+const BackgroundSize = background.BackgroundSize;
+// const FilterList = effects.FilterList;
+// const ContainerType = contain.ContainerType;
+// const Container = contain.Container;
+// const ContainerNameList = contain.ContainerNameList;
+const CustomPropertyName = custom.CustomPropertyName;
+const display = css.css_properties.display;
+
+const Position = position.Position;
+
+const Result = css.Result;
+
+const BabyList = bun.BabyList;
+const ArrayList = std.ArrayListUnmanaged;
+const SmallList = css.SmallList;
+pub const Property = union(PropertyIdTag) {
+    @"background-color": CssColor,
+    @"background-image": SmallList(Image, 1),
+    @"background-position-x": SmallList(css_values.position.HorizontalPosition, 1),
+    @"background-position-y": SmallList(css_values.position.VerticalPosition, 1),
+    @"background-position": SmallList(background.BackgroundPosition, 1),
+    @"background-size": SmallList(background.BackgroundSize, 1),
+    @"background-repeat": SmallList(background.BackgroundRepeat, 1),
+    @"background-attachment": SmallList(background.BackgroundAttachment, 1),
+    @"background-clip": struct { SmallList(background.BackgroundClip, 1), VendorPrefix },
+    @"background-origin": SmallList(background.BackgroundOrigin, 1),
+    background: SmallList(background.Background, 1),
+    @"box-shadow": struct { SmallList(box_shadow.BoxShadow, 1), VendorPrefix },
+    opacity: css.css_values.alpha.AlphaValue,
+    color: CssColor,
+    display: display.Display,
+    visibility: display.Visibility,
+    width: size.Size,
+    height: size.Size,
+    @"min-width": size.Size,
+    @"min-height": size.Size,
+    @"max-width": size.MaxSize,
+    @"max-height": size.MaxSize,
+    @"block-size": size.Size,
+    @"inline-size": size.Size,
+    @"min-block-size": size.Size,
+    @"min-inline-size": size.Size,
+    @"max-block-size": size.MaxSize,
+    @"max-inline-size": size.MaxSize,
+    @"box-sizing": struct { size.BoxSizing, VendorPrefix },
+    @"aspect-ratio": size.AspectRatio,
+    overflow: overflow.Overflow,
+    @"overflow-x": overflow.OverflowKeyword,
+    @"overflow-y": overflow.OverflowKeyword,
+    @"text-overflow": struct { overflow.TextOverflow, VendorPrefix },
+    position: position.Position,
+    top: LengthPercentageOrAuto,
+    bottom: LengthPercentageOrAuto,
+    left: LengthPercentageOrAuto,
+    right: LengthPercentageOrAuto,
+    @"inset-block-start": LengthPercentageOrAuto,
+    @"inset-block-end": LengthPercentageOrAuto,
+    @"inset-inline-start": LengthPercentageOrAuto,
+    @"inset-inline-end": LengthPercentageOrAuto,
+    @"inset-block": margin_padding.InsetBlock,
+    @"inset-inline": margin_padding.InsetInline,
+    inset: margin_padding.Inset,
+    @"border-spacing": css.css_values.size.Size2D(Length),
+    @"border-top-color": CssColor,
+    @"border-bottom-color": CssColor,
+    @"border-left-color": CssColor,
+    @"border-right-color": CssColor,
+    @"border-block-start-color": CssColor,
+    @"border-block-end-color": CssColor,
+    @"border-inline-start-color": CssColor,
+    @"border-inline-end-color": CssColor,
+    @"border-top-style": border.LineStyle,
+    @"border-bottom-style": border.LineStyle,
+    @"border-left-style": border.LineStyle,
+    @"border-right-style": border.LineStyle,
+    @"border-block-start-style": border.LineStyle,
+    @"border-block-end-style": border.LineStyle,
+    @"border-inline-start-style": border.LineStyle,
+    @"border-inline-end-style": border.LineStyle,
+    @"border-top-width": BorderSideWidth,
+    @"border-bottom-width": BorderSideWidth,
+    @"border-left-width": BorderSideWidth,
+    @"border-right-width": BorderSideWidth,
+    @"border-block-start-width": BorderSideWidth,
+    @"border-block-end-width": BorderSideWidth,
+    @"border-inline-start-width": BorderSideWidth,
+    @"border-inline-end-width": BorderSideWidth,
+    @"border-top-left-radius": struct { Size2D(LengthPercentage), VendorPrefix },
+    @"border-top-right-radius": struct { Size2D(LengthPercentage), VendorPrefix },
+    @"border-bottom-left-radius": struct { Size2D(LengthPercentage), VendorPrefix },
+    @"border-bottom-right-radius": struct { Size2D(LengthPercentage), VendorPrefix },
+    @"border-start-start-radius": Size2D(LengthPercentage),
+    @"border-start-end-radius": Size2D(LengthPercentage),
+    @"border-end-start-radius": Size2D(LengthPercentage),
+    @"border-end-end-radius": Size2D(LengthPercentage),
+    @"border-radius": struct { BorderRadius, VendorPrefix },
+    @"border-image-source": Image,
+    @"border-image-outset": Rect(LengthOrNumber),
+    @"border-image-repeat": BorderImageRepeat,
+    @"border-image-width": Rect(BorderImageSideWidth),
+    @"border-image-slice": BorderImageSlice,
+    @"border-image": struct { BorderImage, VendorPrefix },
+    @"border-color": BorderColor,
+    @"border-style": BorderStyle,
+    @"border-width": BorderWidth,
+    @"border-block-color": BorderBlockColor,
+    @"border-block-style": BorderBlockStyle,
+    @"border-block-width": BorderBlockWidth,
+    @"border-inline-color": BorderInlineColor,
+    @"border-inline-style": BorderInlineStyle,
+    @"border-inline-width": BorderInlineWidth,
+    border: Border,
+    @"border-top": BorderTop,
+    @"border-bottom": BorderBottom,
+    @"border-left": BorderLeft,
+    @"border-right": BorderRight,
+    @"border-block": BorderBlock,
+    @"border-block-start": BorderBlockStart,
+    @"border-block-end": BorderBlockEnd,
+    @"border-inline": BorderInline,
+    @"border-inline-start": BorderInlineStart,
+    @"border-inline-end": BorderInlineEnd,
+    outline: Outline,
+    @"outline-color": CssColor,
+    @"outline-style": OutlineStyle,
+    @"outline-width": BorderSideWidth,
+    @"flex-direction": struct { FlexDirection, VendorPrefix },
+    @"flex-wrap": struct { FlexWrap, VendorPrefix },
+    @"flex-flow": struct { FlexFlow, VendorPrefix },
+    @"flex-grow": struct { CSSNumber, VendorPrefix },
+    @"flex-shrink": struct { CSSNumber, VendorPrefix },
+    @"flex-basis": struct { LengthPercentageOrAuto, VendorPrefix },
+    flex: struct { Flex, VendorPrefix },
+    order: struct { CSSInteger, VendorPrefix },
+    @"align-content": struct { AlignContent, VendorPrefix },
+    @"justify-content": struct { JustifyContent, VendorPrefix },
+    @"place-content": PlaceContent,
+    @"align-self": struct { AlignSelf, VendorPrefix },
+    @"justify-self": JustifySelf,
+    @"place-self": PlaceSelf,
+    @"align-items": struct { AlignItems, VendorPrefix },
+    @"justify-items": JustifyItems,
+    @"place-items": PlaceItems,
+    @"row-gap": GapValue,
+    @"column-gap": GapValue,
+    gap: Gap,
+    @"box-orient": struct { BoxOrient, VendorPrefix },
+    @"box-direction": struct { BoxDirection, VendorPrefix },
+    @"box-ordinal-group": struct { CSSInteger, VendorPrefix },
+    @"box-align": struct { BoxAlign, VendorPrefix },
+    @"box-flex": struct { CSSNumber, VendorPrefix },
+    @"box-flex-group": struct { CSSInteger, VendorPrefix },
+    @"box-pack": struct { BoxPack, VendorPrefix },
+    @"box-lines": struct { BoxLines, VendorPrefix },
+    @"flex-pack": struct { FlexPack, VendorPrefix },
+    @"flex-order": struct { CSSInteger, VendorPrefix },
+    @"flex-align": struct { BoxAlign, VendorPrefix },
+    @"flex-item-align": struct { FlexItemAlign, VendorPrefix },
+    @"flex-line-pack": struct { FlexLinePack, VendorPrefix },
+    @"flex-positive": struct { CSSNumber, VendorPrefix },
+    @"flex-negative": struct { CSSNumber, VendorPrefix },
+    @"flex-preferred-size": struct { LengthPercentageOrAuto, VendorPrefix },
+    @"margin-top": LengthPercentageOrAuto,
+    @"margin-bottom": LengthPercentageOrAuto,
+    @"margin-left": LengthPercentageOrAuto,
+    @"margin-right": LengthPercentageOrAuto,
+    @"margin-block-start": LengthPercentageOrAuto,
+    @"margin-block-end": LengthPercentageOrAuto,
+    @"margin-inline-start": LengthPercentageOrAuto,
+    @"margin-inline-end": LengthPercentageOrAuto,
+    @"margin-block": MarginBlock,
+    @"margin-inline": MarginInline,
+    margin: Margin,
+    @"padding-top": LengthPercentageOrAuto,
+    @"padding-bottom": LengthPercentageOrAuto,
+    @"padding-left": LengthPercentageOrAuto,
+    @"padding-right": LengthPercentageOrAuto,
+    @"padding-block-start": LengthPercentageOrAuto,
+    @"padding-block-end": LengthPercentageOrAuto,
+    @"padding-inline-start": LengthPercentageOrAuto,
+    @"padding-inline-end": LengthPercentageOrAuto,
+    @"padding-block": PaddingBlock,
+    @"padding-inline": PaddingInline,
+    padding: Padding,
+    @"scroll-margin-top": LengthPercentageOrAuto,
+    @"scroll-margin-bottom": LengthPercentageOrAuto,
+    @"scroll-margin-left": LengthPercentageOrAuto,
+    @"scroll-margin-right": LengthPercentageOrAuto,
+    @"scroll-margin-block-start": LengthPercentageOrAuto,
+    @"scroll-margin-block-end": LengthPercentageOrAuto,
+    @"scroll-margin-inline-start": LengthPercentageOrAuto,
+    @"scroll-margin-inline-end": LengthPercentageOrAuto,
+    @"scroll-margin-block": ScrollMarginBlock,
+    @"scroll-margin-inline": ScrollMarginInline,
+    @"scroll-margin": ScrollMargin,
+    @"scroll-padding-top": LengthPercentageOrAuto,
+    @"scroll-padding-bottom": LengthPercentageOrAuto,
+    @"scroll-padding-left": LengthPercentageOrAuto,
+    @"scroll-padding-right": LengthPercentageOrAuto,
+    @"scroll-padding-block-start": LengthPercentageOrAuto,
+    @"scroll-padding-block-end": LengthPercentageOrAuto,
+    @"scroll-padding-inline-start": LengthPercentageOrAuto,
+    @"scroll-padding-inline-end": LengthPercentageOrAuto,
+    @"scroll-padding-block": ScrollPaddingBlock,
+    @"scroll-padding-inline": ScrollPaddingInline,
+    @"scroll-padding": ScrollPadding,
+    @"font-weight": FontWeight,
+    @"font-size": FontSize,
+    @"font-stretch": FontStretch,
+    @"font-family": BabyList(FontFamily),
+    @"font-style": FontStyle,
+    @"font-variant-caps": FontVariantCaps,
+    @"line-height": LineHeight,
+    font: Font,
+    @"text-decoration-color": struct { CssColor, VendorPrefix },
+    @"text-emphasis-color": struct { CssColor, VendorPrefix },
+    @"text-shadow": SmallList(TextShadow, 1),
+    direction: Direction,
+    composes: Composes,
+    @"mask-image": struct { SmallList(Image, 1), VendorPrefix },
+    @"mask-mode": SmallList(MaskMode, 1),
+    @"mask-repeat": struct { SmallList(BackgroundRepeat, 1), VendorPrefix },
+    @"mask-position-x": SmallList(HorizontalPosition, 1),
+    @"mask-position-y": SmallList(VerticalPosition, 1),
+    @"mask-position": struct { SmallList(Position, 1), VendorPrefix },
+    @"mask-clip": struct { SmallList(MaskClip, 1), VendorPrefix },
+    @"mask-origin": struct { SmallList(GeometryBox, 1), VendorPrefix },
+    @"mask-size": struct { SmallList(BackgroundSize, 1), VendorPrefix },
+    @"mask-composite": SmallList(MaskComposite, 1),
+    @"mask-type": MaskType,
+    mask: struct { SmallList(Mask, 1), VendorPrefix },
+    @"mask-border-source": Image,
+    @"mask-border-mode": MaskBorderMode,
+    @"mask-border-slice": BorderImageSlice,
+    @"mask-border-width": Rect(BorderImageSideWidth),
+    @"mask-border-outset": Rect(LengthOrNumber),
+    @"mask-border-repeat": BorderImageRepeat,
+    @"mask-border": MaskBorder,
+    @"-webkit-mask-composite": SmallList(WebKitMaskComposite, 1),
+    @"mask-source-type": struct { SmallList(WebKitMaskSourceType, 1), VendorPrefix },
+    @"mask-box-image": struct { BorderImage, VendorPrefix },
+    @"mask-box-image-source": struct { Image, VendorPrefix },
+    @"mask-box-image-slice": struct { BorderImageSlice, VendorPrefix },
+    @"mask-box-image-width": struct { Rect(BorderImageSideWidth), VendorPrefix },
+    @"mask-box-image-outset": struct { Rect(LengthOrNumber), VendorPrefix },
+    @"mask-box-image-repeat": struct { BorderImageRepeat, VendorPrefix },
+    all: CSSWideKeyword,
+    unparsed: UnparsedProperty,
+    custom: CustomProperty,
+
+    pub usingnamespace PropertyImpl();
+
+    // Sanity check to make sure all types have the following functions:
+    // - deepClone()
+    // - eql()
+    // - parse()
+    // - toCss()
+    //
+    // We do this string concatenation thing so we get all the errors at once,
+    // instead of relying on Zig semantic analysis which usualy stops at the first error.
+    comptime {
+        const compile_error: []const u8 = compile_error: {
+            var compile_error: []const u8 = "";
+
+            if (!@hasDecl(CssColor, "deepClone")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "parse")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "toCss")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "eql")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(Image, 1), "deepClone")) {
+                compile_error = compile_error ++ @typeName(SmallList(Image, 1)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(Image, 1), "parse")) {
+                compile_error = compile_error ++ @typeName(SmallList(Image, 1)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(Image, 1), "toCss")) {
+                compile_error = compile_error ++ @typeName(SmallList(Image, 1)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(Image, 1), "eql")) {
+                compile_error = compile_error ++ @typeName(SmallList(Image, 1)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(css_values.position.HorizontalPosition, 1), "deepClone")) {
+                compile_error = compile_error ++ @typeName(SmallList(css_values.position.HorizontalPosition, 1)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(css_values.position.HorizontalPosition, 1), "parse")) {
+                compile_error = compile_error ++ @typeName(SmallList(css_values.position.HorizontalPosition, 1)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(css_values.position.HorizontalPosition, 1), "toCss")) {
+                compile_error = compile_error ++ @typeName(SmallList(css_values.position.HorizontalPosition, 1)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(css_values.position.HorizontalPosition, 1), "eql")) {
+                compile_error = compile_error ++ @typeName(SmallList(css_values.position.HorizontalPosition, 1)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(css_values.position.VerticalPosition, 1), "deepClone")) {
+                compile_error = compile_error ++ @typeName(SmallList(css_values.position.VerticalPosition, 1)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(css_values.position.VerticalPosition, 1), "parse")) {
+                compile_error = compile_error ++ @typeName(SmallList(css_values.position.VerticalPosition, 1)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(css_values.position.VerticalPosition, 1), "toCss")) {
+                compile_error = compile_error ++ @typeName(SmallList(css_values.position.VerticalPosition, 1)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(css_values.position.VerticalPosition, 1), "eql")) {
+                compile_error = compile_error ++ @typeName(SmallList(css_values.position.VerticalPosition, 1)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(background.BackgroundPosition, 1), "deepClone")) {
+                compile_error = compile_error ++ @typeName(SmallList(background.BackgroundPosition, 1)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(background.BackgroundPosition, 1), "parse")) {
+                compile_error = compile_error ++ @typeName(SmallList(background.BackgroundPosition, 1)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(background.BackgroundPosition, 1), "toCss")) {
+                compile_error = compile_error ++ @typeName(SmallList(background.BackgroundPosition, 1)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(background.BackgroundPosition, 1), "eql")) {
+                compile_error = compile_error ++ @typeName(SmallList(background.BackgroundPosition, 1)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(background.BackgroundSize, 1), "deepClone")) {
+                compile_error = compile_error ++ @typeName(SmallList(background.BackgroundSize, 1)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(background.BackgroundSize, 1), "parse")) {
+                compile_error = compile_error ++ @typeName(SmallList(background.BackgroundSize, 1)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(background.BackgroundSize, 1), "toCss")) {
+                compile_error = compile_error ++ @typeName(SmallList(background.BackgroundSize, 1)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(background.BackgroundSize, 1), "eql")) {
+                compile_error = compile_error ++ @typeName(SmallList(background.BackgroundSize, 1)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(background.BackgroundRepeat, 1), "deepClone")) {
+                compile_error = compile_error ++ @typeName(SmallList(background.BackgroundRepeat, 1)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(background.BackgroundRepeat, 1), "parse")) {
+                compile_error = compile_error ++ @typeName(SmallList(background.BackgroundRepeat, 1)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(background.BackgroundRepeat, 1), "toCss")) {
+                compile_error = compile_error ++ @typeName(SmallList(background.BackgroundRepeat, 1)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(background.BackgroundRepeat, 1), "eql")) {
+                compile_error = compile_error ++ @typeName(SmallList(background.BackgroundRepeat, 1)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(background.BackgroundAttachment, 1), "deepClone")) {
+                compile_error = compile_error ++ @typeName(SmallList(background.BackgroundAttachment, 1)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(background.BackgroundAttachment, 1), "parse")) {
+                compile_error = compile_error ++ @typeName(SmallList(background.BackgroundAttachment, 1)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(background.BackgroundAttachment, 1), "toCss")) {
+                compile_error = compile_error ++ @typeName(SmallList(background.BackgroundAttachment, 1)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(background.BackgroundAttachment, 1), "eql")) {
+                compile_error = compile_error ++ @typeName(SmallList(background.BackgroundAttachment, 1)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(background.BackgroundClip, 1), "deepClone")) {
+                compile_error = compile_error ++ @typeName(SmallList(background.BackgroundClip, 1)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(background.BackgroundClip, 1), "parse")) {
+                compile_error = compile_error ++ @typeName(SmallList(background.BackgroundClip, 1)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(background.BackgroundClip, 1), "toCss")) {
+                compile_error = compile_error ++ @typeName(SmallList(background.BackgroundClip, 1)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(background.BackgroundClip, 1), "eql")) {
+                compile_error = compile_error ++ @typeName(SmallList(background.BackgroundClip, 1)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(background.BackgroundOrigin, 1), "deepClone")) {
+                compile_error = compile_error ++ @typeName(SmallList(background.BackgroundOrigin, 1)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(background.BackgroundOrigin, 1), "parse")) {
+                compile_error = compile_error ++ @typeName(SmallList(background.BackgroundOrigin, 1)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(background.BackgroundOrigin, 1), "toCss")) {
+                compile_error = compile_error ++ @typeName(SmallList(background.BackgroundOrigin, 1)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(background.BackgroundOrigin, 1), "eql")) {
+                compile_error = compile_error ++ @typeName(SmallList(background.BackgroundOrigin, 1)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(background.Background, 1), "deepClone")) {
+                compile_error = compile_error ++ @typeName(SmallList(background.Background, 1)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(background.Background, 1), "parse")) {
+                compile_error = compile_error ++ @typeName(SmallList(background.Background, 1)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(background.Background, 1), "toCss")) {
+                compile_error = compile_error ++ @typeName(SmallList(background.Background, 1)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(background.Background, 1), "eql")) {
+                compile_error = compile_error ++ @typeName(SmallList(background.Background, 1)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(box_shadow.BoxShadow, 1), "deepClone")) {
+                compile_error = compile_error ++ @typeName(SmallList(box_shadow.BoxShadow, 1)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(box_shadow.BoxShadow, 1), "parse")) {
+                compile_error = compile_error ++ @typeName(SmallList(box_shadow.BoxShadow, 1)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(box_shadow.BoxShadow, 1), "toCss")) {
+                compile_error = compile_error ++ @typeName(SmallList(box_shadow.BoxShadow, 1)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(box_shadow.BoxShadow, 1), "eql")) {
+                compile_error = compile_error ++ @typeName(SmallList(box_shadow.BoxShadow, 1)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(css.css_values.alpha.AlphaValue, "deepClone")) {
+                compile_error = compile_error ++ @typeName(css.css_values.alpha.AlphaValue) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(css.css_values.alpha.AlphaValue, "parse")) {
+                compile_error = compile_error ++ @typeName(css.css_values.alpha.AlphaValue) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(css.css_values.alpha.AlphaValue, "toCss")) {
+                compile_error = compile_error ++ @typeName(css.css_values.alpha.AlphaValue) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(css.css_values.alpha.AlphaValue, "eql")) {
+                compile_error = compile_error ++ @typeName(css.css_values.alpha.AlphaValue) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "deepClone")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "parse")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "toCss")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "eql")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(display.Display, "deepClone")) {
+                compile_error = compile_error ++ @typeName(display.Display) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(display.Display, "parse")) {
+                compile_error = compile_error ++ @typeName(display.Display) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(display.Display, "toCss")) {
+                compile_error = compile_error ++ @typeName(display.Display) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(display.Display, "eql")) {
+                compile_error = compile_error ++ @typeName(display.Display) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(display.Visibility, "deepClone")) {
+                compile_error = compile_error ++ @typeName(display.Visibility) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(display.Visibility, "parse")) {
+                compile_error = compile_error ++ @typeName(display.Visibility) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(display.Visibility, "toCss")) {
+                compile_error = compile_error ++ @typeName(display.Visibility) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(display.Visibility, "eql")) {
+                compile_error = compile_error ++ @typeName(display.Visibility) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(size.Size, "deepClone")) {
+                compile_error = compile_error ++ @typeName(size.Size) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(size.Size, "parse")) {
+                compile_error = compile_error ++ @typeName(size.Size) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(size.Size, "toCss")) {
+                compile_error = compile_error ++ @typeName(size.Size) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(size.Size, "eql")) {
+                compile_error = compile_error ++ @typeName(size.Size) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(size.Size, "deepClone")) {
+                compile_error = compile_error ++ @typeName(size.Size) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(size.Size, "parse")) {
+                compile_error = compile_error ++ @typeName(size.Size) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(size.Size, "toCss")) {
+                compile_error = compile_error ++ @typeName(size.Size) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(size.Size, "eql")) {
+                compile_error = compile_error ++ @typeName(size.Size) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(size.Size, "deepClone")) {
+                compile_error = compile_error ++ @typeName(size.Size) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(size.Size, "parse")) {
+                compile_error = compile_error ++ @typeName(size.Size) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(size.Size, "toCss")) {
+                compile_error = compile_error ++ @typeName(size.Size) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(size.Size, "eql")) {
+                compile_error = compile_error ++ @typeName(size.Size) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(size.Size, "deepClone")) {
+                compile_error = compile_error ++ @typeName(size.Size) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(size.Size, "parse")) {
+                compile_error = compile_error ++ @typeName(size.Size) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(size.Size, "toCss")) {
+                compile_error = compile_error ++ @typeName(size.Size) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(size.Size, "eql")) {
+                compile_error = compile_error ++ @typeName(size.Size) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(size.MaxSize, "deepClone")) {
+                compile_error = compile_error ++ @typeName(size.MaxSize) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(size.MaxSize, "parse")) {
+                compile_error = compile_error ++ @typeName(size.MaxSize) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(size.MaxSize, "toCss")) {
+                compile_error = compile_error ++ @typeName(size.MaxSize) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(size.MaxSize, "eql")) {
+                compile_error = compile_error ++ @typeName(size.MaxSize) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(size.MaxSize, "deepClone")) {
+                compile_error = compile_error ++ @typeName(size.MaxSize) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(size.MaxSize, "parse")) {
+                compile_error = compile_error ++ @typeName(size.MaxSize) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(size.MaxSize, "toCss")) {
+                compile_error = compile_error ++ @typeName(size.MaxSize) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(size.MaxSize, "eql")) {
+                compile_error = compile_error ++ @typeName(size.MaxSize) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(size.Size, "deepClone")) {
+                compile_error = compile_error ++ @typeName(size.Size) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(size.Size, "parse")) {
+                compile_error = compile_error ++ @typeName(size.Size) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(size.Size, "toCss")) {
+                compile_error = compile_error ++ @typeName(size.Size) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(size.Size, "eql")) {
+                compile_error = compile_error ++ @typeName(size.Size) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(size.Size, "deepClone")) {
+                compile_error = compile_error ++ @typeName(size.Size) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(size.Size, "parse")) {
+                compile_error = compile_error ++ @typeName(size.Size) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(size.Size, "toCss")) {
+                compile_error = compile_error ++ @typeName(size.Size) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(size.Size, "eql")) {
+                compile_error = compile_error ++ @typeName(size.Size) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(size.Size, "deepClone")) {
+                compile_error = compile_error ++ @typeName(size.Size) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(size.Size, "parse")) {
+                compile_error = compile_error ++ @typeName(size.Size) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(size.Size, "toCss")) {
+                compile_error = compile_error ++ @typeName(size.Size) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(size.Size, "eql")) {
+                compile_error = compile_error ++ @typeName(size.Size) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(size.Size, "deepClone")) {
+                compile_error = compile_error ++ @typeName(size.Size) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(size.Size, "parse")) {
+                compile_error = compile_error ++ @typeName(size.Size) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(size.Size, "toCss")) {
+                compile_error = compile_error ++ @typeName(size.Size) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(size.Size, "eql")) {
+                compile_error = compile_error ++ @typeName(size.Size) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(size.MaxSize, "deepClone")) {
+                compile_error = compile_error ++ @typeName(size.MaxSize) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(size.MaxSize, "parse")) {
+                compile_error = compile_error ++ @typeName(size.MaxSize) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(size.MaxSize, "toCss")) {
+                compile_error = compile_error ++ @typeName(size.MaxSize) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(size.MaxSize, "eql")) {
+                compile_error = compile_error ++ @typeName(size.MaxSize) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(size.MaxSize, "deepClone")) {
+                compile_error = compile_error ++ @typeName(size.MaxSize) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(size.MaxSize, "parse")) {
+                compile_error = compile_error ++ @typeName(size.MaxSize) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(size.MaxSize, "toCss")) {
+                compile_error = compile_error ++ @typeName(size.MaxSize) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(size.MaxSize, "eql")) {
+                compile_error = compile_error ++ @typeName(size.MaxSize) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(size.BoxSizing, "deepClone")) {
+                compile_error = compile_error ++ @typeName(size.BoxSizing) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(size.BoxSizing, "parse")) {
+                compile_error = compile_error ++ @typeName(size.BoxSizing) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(size.BoxSizing, "toCss")) {
+                compile_error = compile_error ++ @typeName(size.BoxSizing) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(size.BoxSizing, "eql")) {
+                compile_error = compile_error ++ @typeName(size.BoxSizing) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(size.AspectRatio, "deepClone")) {
+                compile_error = compile_error ++ @typeName(size.AspectRatio) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(size.AspectRatio, "parse")) {
+                compile_error = compile_error ++ @typeName(size.AspectRatio) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(size.AspectRatio, "toCss")) {
+                compile_error = compile_error ++ @typeName(size.AspectRatio) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(size.AspectRatio, "eql")) {
+                compile_error = compile_error ++ @typeName(size.AspectRatio) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(overflow.Overflow, "deepClone")) {
+                compile_error = compile_error ++ @typeName(overflow.Overflow) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(overflow.Overflow, "parse")) {
+                compile_error = compile_error ++ @typeName(overflow.Overflow) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(overflow.Overflow, "toCss")) {
+                compile_error = compile_error ++ @typeName(overflow.Overflow) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(overflow.Overflow, "eql")) {
+                compile_error = compile_error ++ @typeName(overflow.Overflow) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(overflow.OverflowKeyword, "deepClone")) {
+                compile_error = compile_error ++ @typeName(overflow.OverflowKeyword) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(overflow.OverflowKeyword, "parse")) {
+                compile_error = compile_error ++ @typeName(overflow.OverflowKeyword) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(overflow.OverflowKeyword, "toCss")) {
+                compile_error = compile_error ++ @typeName(overflow.OverflowKeyword) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(overflow.OverflowKeyword, "eql")) {
+                compile_error = compile_error ++ @typeName(overflow.OverflowKeyword) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(overflow.OverflowKeyword, "deepClone")) {
+                compile_error = compile_error ++ @typeName(overflow.OverflowKeyword) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(overflow.OverflowKeyword, "parse")) {
+                compile_error = compile_error ++ @typeName(overflow.OverflowKeyword) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(overflow.OverflowKeyword, "toCss")) {
+                compile_error = compile_error ++ @typeName(overflow.OverflowKeyword) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(overflow.OverflowKeyword, "eql")) {
+                compile_error = compile_error ++ @typeName(overflow.OverflowKeyword) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(overflow.TextOverflow, "deepClone")) {
+                compile_error = compile_error ++ @typeName(overflow.TextOverflow) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(overflow.TextOverflow, "parse")) {
+                compile_error = compile_error ++ @typeName(overflow.TextOverflow) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(overflow.TextOverflow, "toCss")) {
+                compile_error = compile_error ++ @typeName(overflow.TextOverflow) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(overflow.TextOverflow, "eql")) {
+                compile_error = compile_error ++ @typeName(overflow.TextOverflow) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(position.Position, "deepClone")) {
+                compile_error = compile_error ++ @typeName(position.Position) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(position.Position, "parse")) {
+                compile_error = compile_error ++ @typeName(position.Position) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(position.Position, "toCss")) {
+                compile_error = compile_error ++ @typeName(position.Position) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(position.Position, "eql")) {
+                compile_error = compile_error ++ @typeName(position.Position) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(margin_padding.InsetBlock, "deepClone")) {
+                compile_error = compile_error ++ @typeName(margin_padding.InsetBlock) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(margin_padding.InsetBlock, "parse")) {
+                compile_error = compile_error ++ @typeName(margin_padding.InsetBlock) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(margin_padding.InsetBlock, "toCss")) {
+                compile_error = compile_error ++ @typeName(margin_padding.InsetBlock) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(margin_padding.InsetBlock, "eql")) {
+                compile_error = compile_error ++ @typeName(margin_padding.InsetBlock) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(margin_padding.InsetInline, "deepClone")) {
+                compile_error = compile_error ++ @typeName(margin_padding.InsetInline) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(margin_padding.InsetInline, "parse")) {
+                compile_error = compile_error ++ @typeName(margin_padding.InsetInline) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(margin_padding.InsetInline, "toCss")) {
+                compile_error = compile_error ++ @typeName(margin_padding.InsetInline) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(margin_padding.InsetInline, "eql")) {
+                compile_error = compile_error ++ @typeName(margin_padding.InsetInline) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(margin_padding.Inset, "deepClone")) {
+                compile_error = compile_error ++ @typeName(margin_padding.Inset) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(margin_padding.Inset, "parse")) {
+                compile_error = compile_error ++ @typeName(margin_padding.Inset) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(margin_padding.Inset, "toCss")) {
+                compile_error = compile_error ++ @typeName(margin_padding.Inset) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(margin_padding.Inset, "eql")) {
+                compile_error = compile_error ++ @typeName(margin_padding.Inset) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(css.css_values.size.Size2D(Length), "deepClone")) {
+                compile_error = compile_error ++ @typeName(css.css_values.size.Size2D(Length)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(css.css_values.size.Size2D(Length), "parse")) {
+                compile_error = compile_error ++ @typeName(css.css_values.size.Size2D(Length)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(css.css_values.size.Size2D(Length), "toCss")) {
+                compile_error = compile_error ++ @typeName(css.css_values.size.Size2D(Length)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(css.css_values.size.Size2D(Length), "eql")) {
+                compile_error = compile_error ++ @typeName(css.css_values.size.Size2D(Length)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "deepClone")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "parse")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "toCss")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "eql")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "deepClone")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "parse")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "toCss")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "eql")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "deepClone")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "parse")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "toCss")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "eql")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "deepClone")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "parse")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "toCss")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "eql")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "deepClone")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "parse")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "toCss")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "eql")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "deepClone")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "parse")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "toCss")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "eql")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "deepClone")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "parse")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "toCss")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "eql")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "deepClone")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "parse")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "toCss")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "eql")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(border.LineStyle, "deepClone")) {
+                compile_error = compile_error ++ @typeName(border.LineStyle) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(border.LineStyle, "parse")) {
+                compile_error = compile_error ++ @typeName(border.LineStyle) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(border.LineStyle, "toCss")) {
+                compile_error = compile_error ++ @typeName(border.LineStyle) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(border.LineStyle, "eql")) {
+                compile_error = compile_error ++ @typeName(border.LineStyle) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(border.LineStyle, "deepClone")) {
+                compile_error = compile_error ++ @typeName(border.LineStyle) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(border.LineStyle, "parse")) {
+                compile_error = compile_error ++ @typeName(border.LineStyle) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(border.LineStyle, "toCss")) {
+                compile_error = compile_error ++ @typeName(border.LineStyle) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(border.LineStyle, "eql")) {
+                compile_error = compile_error ++ @typeName(border.LineStyle) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(border.LineStyle, "deepClone")) {
+                compile_error = compile_error ++ @typeName(border.LineStyle) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(border.LineStyle, "parse")) {
+                compile_error = compile_error ++ @typeName(border.LineStyle) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(border.LineStyle, "toCss")) {
+                compile_error = compile_error ++ @typeName(border.LineStyle) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(border.LineStyle, "eql")) {
+                compile_error = compile_error ++ @typeName(border.LineStyle) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(border.LineStyle, "deepClone")) {
+                compile_error = compile_error ++ @typeName(border.LineStyle) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(border.LineStyle, "parse")) {
+                compile_error = compile_error ++ @typeName(border.LineStyle) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(border.LineStyle, "toCss")) {
+                compile_error = compile_error ++ @typeName(border.LineStyle) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(border.LineStyle, "eql")) {
+                compile_error = compile_error ++ @typeName(border.LineStyle) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(border.LineStyle, "deepClone")) {
+                compile_error = compile_error ++ @typeName(border.LineStyle) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(border.LineStyle, "parse")) {
+                compile_error = compile_error ++ @typeName(border.LineStyle) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(border.LineStyle, "toCss")) {
+                compile_error = compile_error ++ @typeName(border.LineStyle) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(border.LineStyle, "eql")) {
+                compile_error = compile_error ++ @typeName(border.LineStyle) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(border.LineStyle, "deepClone")) {
+                compile_error = compile_error ++ @typeName(border.LineStyle) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(border.LineStyle, "parse")) {
+                compile_error = compile_error ++ @typeName(border.LineStyle) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(border.LineStyle, "toCss")) {
+                compile_error = compile_error ++ @typeName(border.LineStyle) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(border.LineStyle, "eql")) {
+                compile_error = compile_error ++ @typeName(border.LineStyle) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(border.LineStyle, "deepClone")) {
+                compile_error = compile_error ++ @typeName(border.LineStyle) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(border.LineStyle, "parse")) {
+                compile_error = compile_error ++ @typeName(border.LineStyle) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(border.LineStyle, "toCss")) {
+                compile_error = compile_error ++ @typeName(border.LineStyle) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(border.LineStyle, "eql")) {
+                compile_error = compile_error ++ @typeName(border.LineStyle) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(border.LineStyle, "deepClone")) {
+                compile_error = compile_error ++ @typeName(border.LineStyle) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(border.LineStyle, "parse")) {
+                compile_error = compile_error ++ @typeName(border.LineStyle) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(border.LineStyle, "toCss")) {
+                compile_error = compile_error ++ @typeName(border.LineStyle) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(border.LineStyle, "eql")) {
+                compile_error = compile_error ++ @typeName(border.LineStyle) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderSideWidth, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderSideWidth) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderSideWidth, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderSideWidth) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderSideWidth, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderSideWidth) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderSideWidth, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderSideWidth) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderSideWidth, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderSideWidth) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderSideWidth, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderSideWidth) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderSideWidth, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderSideWidth) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderSideWidth, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderSideWidth) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderSideWidth, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderSideWidth) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderSideWidth, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderSideWidth) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderSideWidth, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderSideWidth) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderSideWidth, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderSideWidth) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderSideWidth, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderSideWidth) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderSideWidth, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderSideWidth) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderSideWidth, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderSideWidth) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderSideWidth, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderSideWidth) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderSideWidth, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderSideWidth) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderSideWidth, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderSideWidth) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderSideWidth, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderSideWidth) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderSideWidth, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderSideWidth) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderSideWidth, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderSideWidth) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderSideWidth, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderSideWidth) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderSideWidth, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderSideWidth) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderSideWidth, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderSideWidth) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderSideWidth, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderSideWidth) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderSideWidth, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderSideWidth) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderSideWidth, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderSideWidth) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderSideWidth, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderSideWidth) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderSideWidth, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderSideWidth) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderSideWidth, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderSideWidth) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderSideWidth, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderSideWidth) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderSideWidth, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderSideWidth) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(Size2D(LengthPercentage), "deepClone")) {
+                compile_error = compile_error ++ @typeName(Size2D(LengthPercentage)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(Size2D(LengthPercentage), "parse")) {
+                compile_error = compile_error ++ @typeName(Size2D(LengthPercentage)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(Size2D(LengthPercentage), "toCss")) {
+                compile_error = compile_error ++ @typeName(Size2D(LengthPercentage)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(Size2D(LengthPercentage), "eql")) {
+                compile_error = compile_error ++ @typeName(Size2D(LengthPercentage)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(Size2D(LengthPercentage), "deepClone")) {
+                compile_error = compile_error ++ @typeName(Size2D(LengthPercentage)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(Size2D(LengthPercentage), "parse")) {
+                compile_error = compile_error ++ @typeName(Size2D(LengthPercentage)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(Size2D(LengthPercentage), "toCss")) {
+                compile_error = compile_error ++ @typeName(Size2D(LengthPercentage)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(Size2D(LengthPercentage), "eql")) {
+                compile_error = compile_error ++ @typeName(Size2D(LengthPercentage)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(Size2D(LengthPercentage), "deepClone")) {
+                compile_error = compile_error ++ @typeName(Size2D(LengthPercentage)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(Size2D(LengthPercentage), "parse")) {
+                compile_error = compile_error ++ @typeName(Size2D(LengthPercentage)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(Size2D(LengthPercentage), "toCss")) {
+                compile_error = compile_error ++ @typeName(Size2D(LengthPercentage)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(Size2D(LengthPercentage), "eql")) {
+                compile_error = compile_error ++ @typeName(Size2D(LengthPercentage)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(Size2D(LengthPercentage), "deepClone")) {
+                compile_error = compile_error ++ @typeName(Size2D(LengthPercentage)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(Size2D(LengthPercentage), "parse")) {
+                compile_error = compile_error ++ @typeName(Size2D(LengthPercentage)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(Size2D(LengthPercentage), "toCss")) {
+                compile_error = compile_error ++ @typeName(Size2D(LengthPercentage)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(Size2D(LengthPercentage), "eql")) {
+                compile_error = compile_error ++ @typeName(Size2D(LengthPercentage)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(Size2D(LengthPercentage), "deepClone")) {
+                compile_error = compile_error ++ @typeName(Size2D(LengthPercentage)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(Size2D(LengthPercentage), "parse")) {
+                compile_error = compile_error ++ @typeName(Size2D(LengthPercentage)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(Size2D(LengthPercentage), "toCss")) {
+                compile_error = compile_error ++ @typeName(Size2D(LengthPercentage)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(Size2D(LengthPercentage), "eql")) {
+                compile_error = compile_error ++ @typeName(Size2D(LengthPercentage)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(Size2D(LengthPercentage), "deepClone")) {
+                compile_error = compile_error ++ @typeName(Size2D(LengthPercentage)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(Size2D(LengthPercentage), "parse")) {
+                compile_error = compile_error ++ @typeName(Size2D(LengthPercentage)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(Size2D(LengthPercentage), "toCss")) {
+                compile_error = compile_error ++ @typeName(Size2D(LengthPercentage)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(Size2D(LengthPercentage), "eql")) {
+                compile_error = compile_error ++ @typeName(Size2D(LengthPercentage)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(Size2D(LengthPercentage), "deepClone")) {
+                compile_error = compile_error ++ @typeName(Size2D(LengthPercentage)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(Size2D(LengthPercentage), "parse")) {
+                compile_error = compile_error ++ @typeName(Size2D(LengthPercentage)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(Size2D(LengthPercentage), "toCss")) {
+                compile_error = compile_error ++ @typeName(Size2D(LengthPercentage)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(Size2D(LengthPercentage), "eql")) {
+                compile_error = compile_error ++ @typeName(Size2D(LengthPercentage)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(Size2D(LengthPercentage), "deepClone")) {
+                compile_error = compile_error ++ @typeName(Size2D(LengthPercentage)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(Size2D(LengthPercentage), "parse")) {
+                compile_error = compile_error ++ @typeName(Size2D(LengthPercentage)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(Size2D(LengthPercentage), "toCss")) {
+                compile_error = compile_error ++ @typeName(Size2D(LengthPercentage)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(Size2D(LengthPercentage), "eql")) {
+                compile_error = compile_error ++ @typeName(Size2D(LengthPercentage)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderRadius, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderRadius) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderRadius, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderRadius) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderRadius, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderRadius) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderRadius, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderRadius) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(Image, "deepClone")) {
+                compile_error = compile_error ++ @typeName(Image) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(Image, "parse")) {
+                compile_error = compile_error ++ @typeName(Image) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(Image, "toCss")) {
+                compile_error = compile_error ++ @typeName(Image) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(Image, "eql")) {
+                compile_error = compile_error ++ @typeName(Image) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(Rect(LengthOrNumber), "deepClone")) {
+                compile_error = compile_error ++ @typeName(Rect(LengthOrNumber)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(Rect(LengthOrNumber), "parse")) {
+                compile_error = compile_error ++ @typeName(Rect(LengthOrNumber)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(Rect(LengthOrNumber), "toCss")) {
+                compile_error = compile_error ++ @typeName(Rect(LengthOrNumber)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(Rect(LengthOrNumber), "eql")) {
+                compile_error = compile_error ++ @typeName(Rect(LengthOrNumber)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderImageRepeat, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderImageRepeat) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderImageRepeat, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderImageRepeat) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderImageRepeat, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderImageRepeat) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderImageRepeat, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderImageRepeat) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(Rect(BorderImageSideWidth), "deepClone")) {
+                compile_error = compile_error ++ @typeName(Rect(BorderImageSideWidth)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(Rect(BorderImageSideWidth), "parse")) {
+                compile_error = compile_error ++ @typeName(Rect(BorderImageSideWidth)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(Rect(BorderImageSideWidth), "toCss")) {
+                compile_error = compile_error ++ @typeName(Rect(BorderImageSideWidth)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(Rect(BorderImageSideWidth), "eql")) {
+                compile_error = compile_error ++ @typeName(Rect(BorderImageSideWidth)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderImageSlice, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderImageSlice) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderImageSlice, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderImageSlice) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderImageSlice, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderImageSlice) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderImageSlice, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderImageSlice) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderImage, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderImage) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderImage, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderImage) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderImage, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderImage) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderImage, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderImage) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderColor, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderColor) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderColor, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderColor) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderColor, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderColor) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderColor, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderColor) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderStyle, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderStyle) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderStyle, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderStyle) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderStyle, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderStyle) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderStyle, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderStyle) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderWidth, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderWidth) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderWidth, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderWidth) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderWidth, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderWidth) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderWidth, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderWidth) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderBlockColor, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderBlockColor) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderBlockColor, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderBlockColor) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderBlockColor, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderBlockColor) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderBlockColor, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderBlockColor) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderBlockStyle, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderBlockStyle) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderBlockStyle, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderBlockStyle) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderBlockStyle, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderBlockStyle) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderBlockStyle, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderBlockStyle) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderBlockWidth, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderBlockWidth) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderBlockWidth, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderBlockWidth) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderBlockWidth, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderBlockWidth) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderBlockWidth, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderBlockWidth) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderInlineColor, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderInlineColor) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderInlineColor, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderInlineColor) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderInlineColor, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderInlineColor) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderInlineColor, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderInlineColor) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderInlineStyle, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderInlineStyle) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderInlineStyle, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderInlineStyle) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderInlineStyle, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderInlineStyle) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderInlineStyle, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderInlineStyle) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderInlineWidth, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderInlineWidth) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderInlineWidth, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderInlineWidth) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderInlineWidth, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderInlineWidth) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderInlineWidth, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderInlineWidth) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(Border, "deepClone")) {
+                compile_error = compile_error ++ @typeName(Border) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(Border, "parse")) {
+                compile_error = compile_error ++ @typeName(Border) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(Border, "toCss")) {
+                compile_error = compile_error ++ @typeName(Border) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(Border, "eql")) {
+                compile_error = compile_error ++ @typeName(Border) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderTop, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderTop) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderTop, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderTop) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderTop, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderTop) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderTop, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderTop) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderBottom, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderBottom) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderBottom, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderBottom) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderBottom, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderBottom) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderBottom, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderBottom) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderLeft, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderLeft) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderLeft, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderLeft) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderLeft, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderLeft) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderLeft, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderLeft) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderRight, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderRight) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderRight, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderRight) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderRight, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderRight) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderRight, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderRight) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderBlock, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderBlock) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderBlock, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderBlock) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderBlock, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderBlock) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderBlock, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderBlock) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderBlockStart, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderBlockStart) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderBlockStart, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderBlockStart) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderBlockStart, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderBlockStart) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderBlockStart, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderBlockStart) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderBlockEnd, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderBlockEnd) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderBlockEnd, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderBlockEnd) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderBlockEnd, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderBlockEnd) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderBlockEnd, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderBlockEnd) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderInline, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderInline) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderInline, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderInline) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderInline, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderInline) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderInline, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderInline) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderInlineStart, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderInlineStart) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderInlineStart, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderInlineStart) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderInlineStart, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderInlineStart) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderInlineStart, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderInlineStart) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderInlineEnd, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderInlineEnd) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderInlineEnd, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderInlineEnd) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderInlineEnd, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderInlineEnd) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderInlineEnd, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderInlineEnd) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(Outline, "deepClone")) {
+                compile_error = compile_error ++ @typeName(Outline) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(Outline, "parse")) {
+                compile_error = compile_error ++ @typeName(Outline) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(Outline, "toCss")) {
+                compile_error = compile_error ++ @typeName(Outline) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(Outline, "eql")) {
+                compile_error = compile_error ++ @typeName(Outline) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "deepClone")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "parse")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "toCss")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "eql")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(OutlineStyle, "deepClone")) {
+                compile_error = compile_error ++ @typeName(OutlineStyle) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(OutlineStyle, "parse")) {
+                compile_error = compile_error ++ @typeName(OutlineStyle) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(OutlineStyle, "toCss")) {
+                compile_error = compile_error ++ @typeName(OutlineStyle) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(OutlineStyle, "eql")) {
+                compile_error = compile_error ++ @typeName(OutlineStyle) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderSideWidth, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderSideWidth) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderSideWidth, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderSideWidth) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderSideWidth, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderSideWidth) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderSideWidth, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderSideWidth) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(FlexDirection, "deepClone")) {
+                compile_error = compile_error ++ @typeName(FlexDirection) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(FlexDirection, "parse")) {
+                compile_error = compile_error ++ @typeName(FlexDirection) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(FlexDirection, "toCss")) {
+                compile_error = compile_error ++ @typeName(FlexDirection) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(FlexDirection, "eql")) {
+                compile_error = compile_error ++ @typeName(FlexDirection) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(FlexWrap, "deepClone")) {
+                compile_error = compile_error ++ @typeName(FlexWrap) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(FlexWrap, "parse")) {
+                compile_error = compile_error ++ @typeName(FlexWrap) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(FlexWrap, "toCss")) {
+                compile_error = compile_error ++ @typeName(FlexWrap) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(FlexWrap, "eql")) {
+                compile_error = compile_error ++ @typeName(FlexWrap) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(FlexFlow, "deepClone")) {
+                compile_error = compile_error ++ @typeName(FlexFlow) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(FlexFlow, "parse")) {
+                compile_error = compile_error ++ @typeName(FlexFlow) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(FlexFlow, "toCss")) {
+                compile_error = compile_error ++ @typeName(FlexFlow) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(FlexFlow, "eql")) {
+                compile_error = compile_error ++ @typeName(FlexFlow) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(Flex, "deepClone")) {
+                compile_error = compile_error ++ @typeName(Flex) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(Flex, "parse")) {
+                compile_error = compile_error ++ @typeName(Flex) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(Flex, "toCss")) {
+                compile_error = compile_error ++ @typeName(Flex) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(Flex, "eql")) {
+                compile_error = compile_error ++ @typeName(Flex) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(AlignContent, "deepClone")) {
+                compile_error = compile_error ++ @typeName(AlignContent) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(AlignContent, "parse")) {
+                compile_error = compile_error ++ @typeName(AlignContent) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(AlignContent, "toCss")) {
+                compile_error = compile_error ++ @typeName(AlignContent) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(AlignContent, "eql")) {
+                compile_error = compile_error ++ @typeName(AlignContent) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(JustifyContent, "deepClone")) {
+                compile_error = compile_error ++ @typeName(JustifyContent) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(JustifyContent, "parse")) {
+                compile_error = compile_error ++ @typeName(JustifyContent) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(JustifyContent, "toCss")) {
+                compile_error = compile_error ++ @typeName(JustifyContent) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(JustifyContent, "eql")) {
+                compile_error = compile_error ++ @typeName(JustifyContent) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(PlaceContent, "deepClone")) {
+                compile_error = compile_error ++ @typeName(PlaceContent) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(PlaceContent, "parse")) {
+                compile_error = compile_error ++ @typeName(PlaceContent) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(PlaceContent, "toCss")) {
+                compile_error = compile_error ++ @typeName(PlaceContent) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(PlaceContent, "eql")) {
+                compile_error = compile_error ++ @typeName(PlaceContent) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(AlignSelf, "deepClone")) {
+                compile_error = compile_error ++ @typeName(AlignSelf) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(AlignSelf, "parse")) {
+                compile_error = compile_error ++ @typeName(AlignSelf) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(AlignSelf, "toCss")) {
+                compile_error = compile_error ++ @typeName(AlignSelf) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(AlignSelf, "eql")) {
+                compile_error = compile_error ++ @typeName(AlignSelf) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(JustifySelf, "deepClone")) {
+                compile_error = compile_error ++ @typeName(JustifySelf) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(JustifySelf, "parse")) {
+                compile_error = compile_error ++ @typeName(JustifySelf) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(JustifySelf, "toCss")) {
+                compile_error = compile_error ++ @typeName(JustifySelf) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(JustifySelf, "eql")) {
+                compile_error = compile_error ++ @typeName(JustifySelf) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(PlaceSelf, "deepClone")) {
+                compile_error = compile_error ++ @typeName(PlaceSelf) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(PlaceSelf, "parse")) {
+                compile_error = compile_error ++ @typeName(PlaceSelf) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(PlaceSelf, "toCss")) {
+                compile_error = compile_error ++ @typeName(PlaceSelf) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(PlaceSelf, "eql")) {
+                compile_error = compile_error ++ @typeName(PlaceSelf) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(AlignItems, "deepClone")) {
+                compile_error = compile_error ++ @typeName(AlignItems) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(AlignItems, "parse")) {
+                compile_error = compile_error ++ @typeName(AlignItems) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(AlignItems, "toCss")) {
+                compile_error = compile_error ++ @typeName(AlignItems) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(AlignItems, "eql")) {
+                compile_error = compile_error ++ @typeName(AlignItems) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(JustifyItems, "deepClone")) {
+                compile_error = compile_error ++ @typeName(JustifyItems) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(JustifyItems, "parse")) {
+                compile_error = compile_error ++ @typeName(JustifyItems) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(JustifyItems, "toCss")) {
+                compile_error = compile_error ++ @typeName(JustifyItems) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(JustifyItems, "eql")) {
+                compile_error = compile_error ++ @typeName(JustifyItems) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(PlaceItems, "deepClone")) {
+                compile_error = compile_error ++ @typeName(PlaceItems) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(PlaceItems, "parse")) {
+                compile_error = compile_error ++ @typeName(PlaceItems) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(PlaceItems, "toCss")) {
+                compile_error = compile_error ++ @typeName(PlaceItems) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(PlaceItems, "eql")) {
+                compile_error = compile_error ++ @typeName(PlaceItems) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(GapValue, "deepClone")) {
+                compile_error = compile_error ++ @typeName(GapValue) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(GapValue, "parse")) {
+                compile_error = compile_error ++ @typeName(GapValue) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(GapValue, "toCss")) {
+                compile_error = compile_error ++ @typeName(GapValue) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(GapValue, "eql")) {
+                compile_error = compile_error ++ @typeName(GapValue) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(GapValue, "deepClone")) {
+                compile_error = compile_error ++ @typeName(GapValue) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(GapValue, "parse")) {
+                compile_error = compile_error ++ @typeName(GapValue) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(GapValue, "toCss")) {
+                compile_error = compile_error ++ @typeName(GapValue) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(GapValue, "eql")) {
+                compile_error = compile_error ++ @typeName(GapValue) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(Gap, "deepClone")) {
+                compile_error = compile_error ++ @typeName(Gap) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(Gap, "parse")) {
+                compile_error = compile_error ++ @typeName(Gap) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(Gap, "toCss")) {
+                compile_error = compile_error ++ @typeName(Gap) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(Gap, "eql")) {
+                compile_error = compile_error ++ @typeName(Gap) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BoxOrient, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BoxOrient) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BoxOrient, "parse")) {
+                compile_error = compile_error ++ @typeName(BoxOrient) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BoxOrient, "toCss")) {
+                compile_error = compile_error ++ @typeName(BoxOrient) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BoxOrient, "eql")) {
+                compile_error = compile_error ++ @typeName(BoxOrient) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BoxDirection, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BoxDirection) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BoxDirection, "parse")) {
+                compile_error = compile_error ++ @typeName(BoxDirection) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BoxDirection, "toCss")) {
+                compile_error = compile_error ++ @typeName(BoxDirection) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BoxDirection, "eql")) {
+                compile_error = compile_error ++ @typeName(BoxDirection) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BoxAlign, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BoxAlign) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BoxAlign, "parse")) {
+                compile_error = compile_error ++ @typeName(BoxAlign) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BoxAlign, "toCss")) {
+                compile_error = compile_error ++ @typeName(BoxAlign) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BoxAlign, "eql")) {
+                compile_error = compile_error ++ @typeName(BoxAlign) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BoxPack, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BoxPack) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BoxPack, "parse")) {
+                compile_error = compile_error ++ @typeName(BoxPack) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BoxPack, "toCss")) {
+                compile_error = compile_error ++ @typeName(BoxPack) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BoxPack, "eql")) {
+                compile_error = compile_error ++ @typeName(BoxPack) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BoxLines, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BoxLines) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BoxLines, "parse")) {
+                compile_error = compile_error ++ @typeName(BoxLines) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BoxLines, "toCss")) {
+                compile_error = compile_error ++ @typeName(BoxLines) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BoxLines, "eql")) {
+                compile_error = compile_error ++ @typeName(BoxLines) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(FlexPack, "deepClone")) {
+                compile_error = compile_error ++ @typeName(FlexPack) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(FlexPack, "parse")) {
+                compile_error = compile_error ++ @typeName(FlexPack) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(FlexPack, "toCss")) {
+                compile_error = compile_error ++ @typeName(FlexPack) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(FlexPack, "eql")) {
+                compile_error = compile_error ++ @typeName(FlexPack) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BoxAlign, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BoxAlign) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BoxAlign, "parse")) {
+                compile_error = compile_error ++ @typeName(BoxAlign) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BoxAlign, "toCss")) {
+                compile_error = compile_error ++ @typeName(BoxAlign) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BoxAlign, "eql")) {
+                compile_error = compile_error ++ @typeName(BoxAlign) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(FlexItemAlign, "deepClone")) {
+                compile_error = compile_error ++ @typeName(FlexItemAlign) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(FlexItemAlign, "parse")) {
+                compile_error = compile_error ++ @typeName(FlexItemAlign) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(FlexItemAlign, "toCss")) {
+                compile_error = compile_error ++ @typeName(FlexItemAlign) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(FlexItemAlign, "eql")) {
+                compile_error = compile_error ++ @typeName(FlexItemAlign) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(FlexLinePack, "deepClone")) {
+                compile_error = compile_error ++ @typeName(FlexLinePack) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(FlexLinePack, "parse")) {
+                compile_error = compile_error ++ @typeName(FlexLinePack) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(FlexLinePack, "toCss")) {
+                compile_error = compile_error ++ @typeName(FlexLinePack) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(FlexLinePack, "eql")) {
+                compile_error = compile_error ++ @typeName(FlexLinePack) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(MarginBlock, "deepClone")) {
+                compile_error = compile_error ++ @typeName(MarginBlock) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(MarginBlock, "parse")) {
+                compile_error = compile_error ++ @typeName(MarginBlock) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(MarginBlock, "toCss")) {
+                compile_error = compile_error ++ @typeName(MarginBlock) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(MarginBlock, "eql")) {
+                compile_error = compile_error ++ @typeName(MarginBlock) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(MarginInline, "deepClone")) {
+                compile_error = compile_error ++ @typeName(MarginInline) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(MarginInline, "parse")) {
+                compile_error = compile_error ++ @typeName(MarginInline) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(MarginInline, "toCss")) {
+                compile_error = compile_error ++ @typeName(MarginInline) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(MarginInline, "eql")) {
+                compile_error = compile_error ++ @typeName(MarginInline) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(Margin, "deepClone")) {
+                compile_error = compile_error ++ @typeName(Margin) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(Margin, "parse")) {
+                compile_error = compile_error ++ @typeName(Margin) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(Margin, "toCss")) {
+                compile_error = compile_error ++ @typeName(Margin) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(Margin, "eql")) {
+                compile_error = compile_error ++ @typeName(Margin) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(PaddingBlock, "deepClone")) {
+                compile_error = compile_error ++ @typeName(PaddingBlock) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(PaddingBlock, "parse")) {
+                compile_error = compile_error ++ @typeName(PaddingBlock) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(PaddingBlock, "toCss")) {
+                compile_error = compile_error ++ @typeName(PaddingBlock) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(PaddingBlock, "eql")) {
+                compile_error = compile_error ++ @typeName(PaddingBlock) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(PaddingInline, "deepClone")) {
+                compile_error = compile_error ++ @typeName(PaddingInline) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(PaddingInline, "parse")) {
+                compile_error = compile_error ++ @typeName(PaddingInline) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(PaddingInline, "toCss")) {
+                compile_error = compile_error ++ @typeName(PaddingInline) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(PaddingInline, "eql")) {
+                compile_error = compile_error ++ @typeName(PaddingInline) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(Padding, "deepClone")) {
+                compile_error = compile_error ++ @typeName(Padding) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(Padding, "parse")) {
+                compile_error = compile_error ++ @typeName(Padding) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(Padding, "toCss")) {
+                compile_error = compile_error ++ @typeName(Padding) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(Padding, "eql")) {
+                compile_error = compile_error ++ @typeName(Padding) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(ScrollMarginBlock, "deepClone")) {
+                compile_error = compile_error ++ @typeName(ScrollMarginBlock) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(ScrollMarginBlock, "parse")) {
+                compile_error = compile_error ++ @typeName(ScrollMarginBlock) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(ScrollMarginBlock, "toCss")) {
+                compile_error = compile_error ++ @typeName(ScrollMarginBlock) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(ScrollMarginBlock, "eql")) {
+                compile_error = compile_error ++ @typeName(ScrollMarginBlock) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(ScrollMarginInline, "deepClone")) {
+                compile_error = compile_error ++ @typeName(ScrollMarginInline) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(ScrollMarginInline, "parse")) {
+                compile_error = compile_error ++ @typeName(ScrollMarginInline) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(ScrollMarginInline, "toCss")) {
+                compile_error = compile_error ++ @typeName(ScrollMarginInline) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(ScrollMarginInline, "eql")) {
+                compile_error = compile_error ++ @typeName(ScrollMarginInline) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(ScrollMargin, "deepClone")) {
+                compile_error = compile_error ++ @typeName(ScrollMargin) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(ScrollMargin, "parse")) {
+                compile_error = compile_error ++ @typeName(ScrollMargin) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(ScrollMargin, "toCss")) {
+                compile_error = compile_error ++ @typeName(ScrollMargin) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(ScrollMargin, "eql")) {
+                compile_error = compile_error ++ @typeName(ScrollMargin) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "parse")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "toCss")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LengthPercentageOrAuto, "eql")) {
+                compile_error = compile_error ++ @typeName(LengthPercentageOrAuto) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(ScrollPaddingBlock, "deepClone")) {
+                compile_error = compile_error ++ @typeName(ScrollPaddingBlock) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(ScrollPaddingBlock, "parse")) {
+                compile_error = compile_error ++ @typeName(ScrollPaddingBlock) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(ScrollPaddingBlock, "toCss")) {
+                compile_error = compile_error ++ @typeName(ScrollPaddingBlock) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(ScrollPaddingBlock, "eql")) {
+                compile_error = compile_error ++ @typeName(ScrollPaddingBlock) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(ScrollPaddingInline, "deepClone")) {
+                compile_error = compile_error ++ @typeName(ScrollPaddingInline) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(ScrollPaddingInline, "parse")) {
+                compile_error = compile_error ++ @typeName(ScrollPaddingInline) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(ScrollPaddingInline, "toCss")) {
+                compile_error = compile_error ++ @typeName(ScrollPaddingInline) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(ScrollPaddingInline, "eql")) {
+                compile_error = compile_error ++ @typeName(ScrollPaddingInline) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(ScrollPadding, "deepClone")) {
+                compile_error = compile_error ++ @typeName(ScrollPadding) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(ScrollPadding, "parse")) {
+                compile_error = compile_error ++ @typeName(ScrollPadding) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(ScrollPadding, "toCss")) {
+                compile_error = compile_error ++ @typeName(ScrollPadding) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(ScrollPadding, "eql")) {
+                compile_error = compile_error ++ @typeName(ScrollPadding) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(FontWeight, "deepClone")) {
+                compile_error = compile_error ++ @typeName(FontWeight) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(FontWeight, "parse")) {
+                compile_error = compile_error ++ @typeName(FontWeight) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(FontWeight, "toCss")) {
+                compile_error = compile_error ++ @typeName(FontWeight) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(FontWeight, "eql")) {
+                compile_error = compile_error ++ @typeName(FontWeight) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(FontSize, "deepClone")) {
+                compile_error = compile_error ++ @typeName(FontSize) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(FontSize, "parse")) {
+                compile_error = compile_error ++ @typeName(FontSize) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(FontSize, "toCss")) {
+                compile_error = compile_error ++ @typeName(FontSize) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(FontSize, "eql")) {
+                compile_error = compile_error ++ @typeName(FontSize) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(FontStretch, "deepClone")) {
+                compile_error = compile_error ++ @typeName(FontStretch) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(FontStretch, "parse")) {
+                compile_error = compile_error ++ @typeName(FontStretch) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(FontStretch, "toCss")) {
+                compile_error = compile_error ++ @typeName(FontStretch) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(FontStretch, "eql")) {
+                compile_error = compile_error ++ @typeName(FontStretch) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BabyList(FontFamily), "deepClone")) {
+                compile_error = compile_error ++ @typeName(BabyList(FontFamily)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BabyList(FontFamily), "parse")) {
+                compile_error = compile_error ++ @typeName(BabyList(FontFamily)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BabyList(FontFamily), "toCss")) {
+                compile_error = compile_error ++ @typeName(BabyList(FontFamily)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BabyList(FontFamily), "eql")) {
+                compile_error = compile_error ++ @typeName(BabyList(FontFamily)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(FontStyle, "deepClone")) {
+                compile_error = compile_error ++ @typeName(FontStyle) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(FontStyle, "parse")) {
+                compile_error = compile_error ++ @typeName(FontStyle) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(FontStyle, "toCss")) {
+                compile_error = compile_error ++ @typeName(FontStyle) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(FontStyle, "eql")) {
+                compile_error = compile_error ++ @typeName(FontStyle) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(FontVariantCaps, "deepClone")) {
+                compile_error = compile_error ++ @typeName(FontVariantCaps) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(FontVariantCaps, "parse")) {
+                compile_error = compile_error ++ @typeName(FontVariantCaps) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(FontVariantCaps, "toCss")) {
+                compile_error = compile_error ++ @typeName(FontVariantCaps) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(FontVariantCaps, "eql")) {
+                compile_error = compile_error ++ @typeName(FontVariantCaps) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(LineHeight, "deepClone")) {
+                compile_error = compile_error ++ @typeName(LineHeight) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(LineHeight, "parse")) {
+                compile_error = compile_error ++ @typeName(LineHeight) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(LineHeight, "toCss")) {
+                compile_error = compile_error ++ @typeName(LineHeight) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(LineHeight, "eql")) {
+                compile_error = compile_error ++ @typeName(LineHeight) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(Font, "deepClone")) {
+                compile_error = compile_error ++ @typeName(Font) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(Font, "parse")) {
+                compile_error = compile_error ++ @typeName(Font) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(Font, "toCss")) {
+                compile_error = compile_error ++ @typeName(Font) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(Font, "eql")) {
+                compile_error = compile_error ++ @typeName(Font) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "deepClone")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "parse")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "toCss")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "eql")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "deepClone")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "parse")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "toCss")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(CssColor, "eql")) {
+                compile_error = compile_error ++ @typeName(CssColor) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(TextShadow, 1), "deepClone")) {
+                compile_error = compile_error ++ @typeName(SmallList(TextShadow, 1)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(TextShadow, 1), "parse")) {
+                compile_error = compile_error ++ @typeName(SmallList(TextShadow, 1)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(TextShadow, 1), "toCss")) {
+                compile_error = compile_error ++ @typeName(SmallList(TextShadow, 1)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(TextShadow, 1), "eql")) {
+                compile_error = compile_error ++ @typeName(SmallList(TextShadow, 1)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(Direction, "deepClone")) {
+                compile_error = compile_error ++ @typeName(Direction) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(Direction, "parse")) {
+                compile_error = compile_error ++ @typeName(Direction) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(Direction, "toCss")) {
+                compile_error = compile_error ++ @typeName(Direction) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(Direction, "eql")) {
+                compile_error = compile_error ++ @typeName(Direction) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(Composes, "deepClone")) {
+                compile_error = compile_error ++ @typeName(Composes) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(Composes, "parse")) {
+                compile_error = compile_error ++ @typeName(Composes) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(Composes, "toCss")) {
+                compile_error = compile_error ++ @typeName(Composes) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(Composes, "eql")) {
+                compile_error = compile_error ++ @typeName(Composes) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(Image, 1), "deepClone")) {
+                compile_error = compile_error ++ @typeName(SmallList(Image, 1)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(Image, 1), "parse")) {
+                compile_error = compile_error ++ @typeName(SmallList(Image, 1)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(Image, 1), "toCss")) {
+                compile_error = compile_error ++ @typeName(SmallList(Image, 1)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(Image, 1), "eql")) {
+                compile_error = compile_error ++ @typeName(SmallList(Image, 1)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(MaskMode, 1), "deepClone")) {
+                compile_error = compile_error ++ @typeName(SmallList(MaskMode, 1)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(MaskMode, 1), "parse")) {
+                compile_error = compile_error ++ @typeName(SmallList(MaskMode, 1)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(MaskMode, 1), "toCss")) {
+                compile_error = compile_error ++ @typeName(SmallList(MaskMode, 1)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(MaskMode, 1), "eql")) {
+                compile_error = compile_error ++ @typeName(SmallList(MaskMode, 1)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(BackgroundRepeat, 1), "deepClone")) {
+                compile_error = compile_error ++ @typeName(SmallList(BackgroundRepeat, 1)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(BackgroundRepeat, 1), "parse")) {
+                compile_error = compile_error ++ @typeName(SmallList(BackgroundRepeat, 1)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(BackgroundRepeat, 1), "toCss")) {
+                compile_error = compile_error ++ @typeName(SmallList(BackgroundRepeat, 1)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(BackgroundRepeat, 1), "eql")) {
+                compile_error = compile_error ++ @typeName(SmallList(BackgroundRepeat, 1)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(HorizontalPosition, 1), "deepClone")) {
+                compile_error = compile_error ++ @typeName(SmallList(HorizontalPosition, 1)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(HorizontalPosition, 1), "parse")) {
+                compile_error = compile_error ++ @typeName(SmallList(HorizontalPosition, 1)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(HorizontalPosition, 1), "toCss")) {
+                compile_error = compile_error ++ @typeName(SmallList(HorizontalPosition, 1)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(HorizontalPosition, 1), "eql")) {
+                compile_error = compile_error ++ @typeName(SmallList(HorizontalPosition, 1)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(VerticalPosition, 1), "deepClone")) {
+                compile_error = compile_error ++ @typeName(SmallList(VerticalPosition, 1)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(VerticalPosition, 1), "parse")) {
+                compile_error = compile_error ++ @typeName(SmallList(VerticalPosition, 1)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(VerticalPosition, 1), "toCss")) {
+                compile_error = compile_error ++ @typeName(SmallList(VerticalPosition, 1)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(VerticalPosition, 1), "eql")) {
+                compile_error = compile_error ++ @typeName(SmallList(VerticalPosition, 1)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(Position, 1), "deepClone")) {
+                compile_error = compile_error ++ @typeName(SmallList(Position, 1)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(Position, 1), "parse")) {
+                compile_error = compile_error ++ @typeName(SmallList(Position, 1)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(Position, 1), "toCss")) {
+                compile_error = compile_error ++ @typeName(SmallList(Position, 1)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(Position, 1), "eql")) {
+                compile_error = compile_error ++ @typeName(SmallList(Position, 1)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(MaskClip, 1), "deepClone")) {
+                compile_error = compile_error ++ @typeName(SmallList(MaskClip, 1)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(MaskClip, 1), "parse")) {
+                compile_error = compile_error ++ @typeName(SmallList(MaskClip, 1)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(MaskClip, 1), "toCss")) {
+                compile_error = compile_error ++ @typeName(SmallList(MaskClip, 1)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(MaskClip, 1), "eql")) {
+                compile_error = compile_error ++ @typeName(SmallList(MaskClip, 1)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(GeometryBox, 1), "deepClone")) {
+                compile_error = compile_error ++ @typeName(SmallList(GeometryBox, 1)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(GeometryBox, 1), "parse")) {
+                compile_error = compile_error ++ @typeName(SmallList(GeometryBox, 1)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(GeometryBox, 1), "toCss")) {
+                compile_error = compile_error ++ @typeName(SmallList(GeometryBox, 1)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(GeometryBox, 1), "eql")) {
+                compile_error = compile_error ++ @typeName(SmallList(GeometryBox, 1)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(BackgroundSize, 1), "deepClone")) {
+                compile_error = compile_error ++ @typeName(SmallList(BackgroundSize, 1)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(BackgroundSize, 1), "parse")) {
+                compile_error = compile_error ++ @typeName(SmallList(BackgroundSize, 1)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(BackgroundSize, 1), "toCss")) {
+                compile_error = compile_error ++ @typeName(SmallList(BackgroundSize, 1)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(BackgroundSize, 1), "eql")) {
+                compile_error = compile_error ++ @typeName(SmallList(BackgroundSize, 1)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(MaskComposite, 1), "deepClone")) {
+                compile_error = compile_error ++ @typeName(SmallList(MaskComposite, 1)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(MaskComposite, 1), "parse")) {
+                compile_error = compile_error ++ @typeName(SmallList(MaskComposite, 1)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(MaskComposite, 1), "toCss")) {
+                compile_error = compile_error ++ @typeName(SmallList(MaskComposite, 1)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(MaskComposite, 1), "eql")) {
+                compile_error = compile_error ++ @typeName(SmallList(MaskComposite, 1)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(MaskType, "deepClone")) {
+                compile_error = compile_error ++ @typeName(MaskType) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(MaskType, "parse")) {
+                compile_error = compile_error ++ @typeName(MaskType) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(MaskType, "toCss")) {
+                compile_error = compile_error ++ @typeName(MaskType) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(MaskType, "eql")) {
+                compile_error = compile_error ++ @typeName(MaskType) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(Mask, 1), "deepClone")) {
+                compile_error = compile_error ++ @typeName(SmallList(Mask, 1)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(Mask, 1), "parse")) {
+                compile_error = compile_error ++ @typeName(SmallList(Mask, 1)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(Mask, 1), "toCss")) {
+                compile_error = compile_error ++ @typeName(SmallList(Mask, 1)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(Mask, 1), "eql")) {
+                compile_error = compile_error ++ @typeName(SmallList(Mask, 1)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(Image, "deepClone")) {
+                compile_error = compile_error ++ @typeName(Image) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(Image, "parse")) {
+                compile_error = compile_error ++ @typeName(Image) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(Image, "toCss")) {
+                compile_error = compile_error ++ @typeName(Image) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(Image, "eql")) {
+                compile_error = compile_error ++ @typeName(Image) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(MaskBorderMode, "deepClone")) {
+                compile_error = compile_error ++ @typeName(MaskBorderMode) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(MaskBorderMode, "parse")) {
+                compile_error = compile_error ++ @typeName(MaskBorderMode) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(MaskBorderMode, "toCss")) {
+                compile_error = compile_error ++ @typeName(MaskBorderMode) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(MaskBorderMode, "eql")) {
+                compile_error = compile_error ++ @typeName(MaskBorderMode) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderImageSlice, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderImageSlice) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderImageSlice, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderImageSlice) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderImageSlice, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderImageSlice) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderImageSlice, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderImageSlice) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(Rect(BorderImageSideWidth), "deepClone")) {
+                compile_error = compile_error ++ @typeName(Rect(BorderImageSideWidth)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(Rect(BorderImageSideWidth), "parse")) {
+                compile_error = compile_error ++ @typeName(Rect(BorderImageSideWidth)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(Rect(BorderImageSideWidth), "toCss")) {
+                compile_error = compile_error ++ @typeName(Rect(BorderImageSideWidth)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(Rect(BorderImageSideWidth), "eql")) {
+                compile_error = compile_error ++ @typeName(Rect(BorderImageSideWidth)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(Rect(LengthOrNumber), "deepClone")) {
+                compile_error = compile_error ++ @typeName(Rect(LengthOrNumber)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(Rect(LengthOrNumber), "parse")) {
+                compile_error = compile_error ++ @typeName(Rect(LengthOrNumber)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(Rect(LengthOrNumber), "toCss")) {
+                compile_error = compile_error ++ @typeName(Rect(LengthOrNumber)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(Rect(LengthOrNumber), "eql")) {
+                compile_error = compile_error ++ @typeName(Rect(LengthOrNumber)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderImageRepeat, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderImageRepeat) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderImageRepeat, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderImageRepeat) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderImageRepeat, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderImageRepeat) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderImageRepeat, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderImageRepeat) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(MaskBorder, "deepClone")) {
+                compile_error = compile_error ++ @typeName(MaskBorder) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(MaskBorder, "parse")) {
+                compile_error = compile_error ++ @typeName(MaskBorder) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(MaskBorder, "toCss")) {
+                compile_error = compile_error ++ @typeName(MaskBorder) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(MaskBorder, "eql")) {
+                compile_error = compile_error ++ @typeName(MaskBorder) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(WebKitMaskComposite, 1), "deepClone")) {
+                compile_error = compile_error ++ @typeName(SmallList(WebKitMaskComposite, 1)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(WebKitMaskComposite, 1), "parse")) {
+                compile_error = compile_error ++ @typeName(SmallList(WebKitMaskComposite, 1)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(WebKitMaskComposite, 1), "toCss")) {
+                compile_error = compile_error ++ @typeName(SmallList(WebKitMaskComposite, 1)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(WebKitMaskComposite, 1), "eql")) {
+                compile_error = compile_error ++ @typeName(SmallList(WebKitMaskComposite, 1)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(WebKitMaskSourceType, 1), "deepClone")) {
+                compile_error = compile_error ++ @typeName(SmallList(WebKitMaskSourceType, 1)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(WebKitMaskSourceType, 1), "parse")) {
+                compile_error = compile_error ++ @typeName(SmallList(WebKitMaskSourceType, 1)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(WebKitMaskSourceType, 1), "toCss")) {
+                compile_error = compile_error ++ @typeName(SmallList(WebKitMaskSourceType, 1)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(SmallList(WebKitMaskSourceType, 1), "eql")) {
+                compile_error = compile_error ++ @typeName(SmallList(WebKitMaskSourceType, 1)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderImage, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderImage) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderImage, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderImage) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderImage, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderImage) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderImage, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderImage) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(Image, "deepClone")) {
+                compile_error = compile_error ++ @typeName(Image) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(Image, "parse")) {
+                compile_error = compile_error ++ @typeName(Image) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(Image, "toCss")) {
+                compile_error = compile_error ++ @typeName(Image) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(Image, "eql")) {
+                compile_error = compile_error ++ @typeName(Image) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderImageSlice, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderImageSlice) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderImageSlice, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderImageSlice) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderImageSlice, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderImageSlice) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderImageSlice, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderImageSlice) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(Rect(BorderImageSideWidth), "deepClone")) {
+                compile_error = compile_error ++ @typeName(Rect(BorderImageSideWidth)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(Rect(BorderImageSideWidth), "parse")) {
+                compile_error = compile_error ++ @typeName(Rect(BorderImageSideWidth)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(Rect(BorderImageSideWidth), "toCss")) {
+                compile_error = compile_error ++ @typeName(Rect(BorderImageSideWidth)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(Rect(BorderImageSideWidth), "eql")) {
+                compile_error = compile_error ++ @typeName(Rect(BorderImageSideWidth)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(Rect(LengthOrNumber), "deepClone")) {
+                compile_error = compile_error ++ @typeName(Rect(LengthOrNumber)) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(Rect(LengthOrNumber), "parse")) {
+                compile_error = compile_error ++ @typeName(Rect(LengthOrNumber)) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(Rect(LengthOrNumber), "toCss")) {
+                compile_error = compile_error ++ @typeName(Rect(LengthOrNumber)) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(Rect(LengthOrNumber), "eql")) {
+                compile_error = compile_error ++ @typeName(Rect(LengthOrNumber)) ++ ": does not have a eql() function.\n";
+            }
+
+            if (!@hasDecl(BorderImageRepeat, "deepClone")) {
+                compile_error = compile_error ++ @typeName(BorderImageRepeat) ++ ": does not have a deepClone() function.\n";
+            }
+
+            if (!@hasDecl(BorderImageRepeat, "parse")) {
+                compile_error = compile_error ++ @typeName(BorderImageRepeat) ++ ": does not have a parse() function.\n";
+            }
+
+            if (!@hasDecl(BorderImageRepeat, "toCss")) {
+                compile_error = compile_error ++ @typeName(BorderImageRepeat) ++ ": does not have a toCss() function.\n";
+            }
+
+            if (!@hasDecl(BorderImageRepeat, "eql")) {
+                compile_error = compile_error ++ @typeName(BorderImageRepeat) ++ ": does not have a eql() function.\n";
+            }
+
+            const final_compile_error = compile_error;
+            break :compile_error final_compile_error;
+        };
+        if (compile_error.len > 0) {
+            @compileError(compile_error);
+        }
+    }
+
+    /// Parses a CSS property by name.
+    pub fn parse(property_id: PropertyId, input: *css.Parser, options: *const css.ParserOptions) Result(Property) {
+        const state = input.state();
+
+        switch (property_id) {
+            .@"background-color" => {
+                if (css.generic.parseWithOptions(CssColor, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"background-color" = c } };
+                    }
+                }
+            },
+            .@"background-image" => {
+                if (css.generic.parseWithOptions(SmallList(Image, 1), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"background-image" = c } };
+                    }
+                }
+            },
+            .@"background-position-x" => {
+                if (css.generic.parseWithOptions(SmallList(css_values.position.HorizontalPosition, 1), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"background-position-x" = c } };
+                    }
+                }
+            },
+            .@"background-position-y" => {
+                if (css.generic.parseWithOptions(SmallList(css_values.position.VerticalPosition, 1), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"background-position-y" = c } };
+                    }
+                }
+            },
+            .@"background-position" => {
+                if (css.generic.parseWithOptions(SmallList(background.BackgroundPosition, 1), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"background-position" = c } };
+                    }
+                }
+            },
+            .@"background-size" => {
+                if (css.generic.parseWithOptions(SmallList(background.BackgroundSize, 1), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"background-size" = c } };
+                    }
+                }
+            },
+            .@"background-repeat" => {
+                if (css.generic.parseWithOptions(SmallList(background.BackgroundRepeat, 1), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"background-repeat" = c } };
+                    }
+                }
+            },
+            .@"background-attachment" => {
+                if (css.generic.parseWithOptions(SmallList(background.BackgroundAttachment, 1), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"background-attachment" = c } };
+                    }
+                }
+            },
+            .@"background-clip" => |pre| {
+                if (css.generic.parseWithOptions(SmallList(background.BackgroundClip, 1), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"background-clip" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"background-origin" => {
+                if (css.generic.parseWithOptions(SmallList(background.BackgroundOrigin, 1), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"background-origin" = c } };
+                    }
+                }
+            },
+            .background => {
+                if (css.generic.parseWithOptions(SmallList(background.Background, 1), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .background = c } };
+                    }
+                }
+            },
+            .@"box-shadow" => |pre| {
+                if (css.generic.parseWithOptions(SmallList(box_shadow.BoxShadow, 1), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"box-shadow" = .{ c, pre } } };
+                    }
+                }
+            },
+            .opacity => {
+                if (css.generic.parseWithOptions(css.css_values.alpha.AlphaValue, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .opacity = c } };
+                    }
+                }
+            },
+            .color => {
+                if (css.generic.parseWithOptions(CssColor, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .color = c } };
+                    }
+                }
+            },
+            .display => {
+                if (css.generic.parseWithOptions(display.Display, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .display = c } };
+                    }
+                }
+            },
+            .visibility => {
+                if (css.generic.parseWithOptions(display.Visibility, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .visibility = c } };
+                    }
+                }
+            },
+            .width => {
+                if (css.generic.parseWithOptions(size.Size, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .width = c } };
+                    }
+                }
+            },
+            .height => {
+                if (css.generic.parseWithOptions(size.Size, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .height = c } };
+                    }
+                }
+            },
+            .@"min-width" => {
+                if (css.generic.parseWithOptions(size.Size, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"min-width" = c } };
+                    }
+                }
+            },
+            .@"min-height" => {
+                if (css.generic.parseWithOptions(size.Size, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"min-height" = c } };
+                    }
+                }
+            },
+            .@"max-width" => {
+                if (css.generic.parseWithOptions(size.MaxSize, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"max-width" = c } };
+                    }
+                }
+            },
+            .@"max-height" => {
+                if (css.generic.parseWithOptions(size.MaxSize, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"max-height" = c } };
+                    }
+                }
+            },
+            .@"block-size" => {
+                if (css.generic.parseWithOptions(size.Size, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"block-size" = c } };
+                    }
+                }
+            },
+            .@"inline-size" => {
+                if (css.generic.parseWithOptions(size.Size, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"inline-size" = c } };
+                    }
+                }
+            },
+            .@"min-block-size" => {
+                if (css.generic.parseWithOptions(size.Size, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"min-block-size" = c } };
+                    }
+                }
+            },
+            .@"min-inline-size" => {
+                if (css.generic.parseWithOptions(size.Size, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"min-inline-size" = c } };
+                    }
+                }
+            },
+            .@"max-block-size" => {
+                if (css.generic.parseWithOptions(size.MaxSize, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"max-block-size" = c } };
+                    }
+                }
+            },
+            .@"max-inline-size" => {
+                if (css.generic.parseWithOptions(size.MaxSize, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"max-inline-size" = c } };
+                    }
+                }
+            },
+            .@"box-sizing" => |pre| {
+                if (css.generic.parseWithOptions(size.BoxSizing, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"box-sizing" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"aspect-ratio" => {
+                if (css.generic.parseWithOptions(size.AspectRatio, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"aspect-ratio" = c } };
+                    }
+                }
+            },
+            .overflow => {
+                if (css.generic.parseWithOptions(overflow.Overflow, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .overflow = c } };
+                    }
+                }
+            },
+            .@"overflow-x" => {
+                if (css.generic.parseWithOptions(overflow.OverflowKeyword, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"overflow-x" = c } };
+                    }
+                }
+            },
+            .@"overflow-y" => {
+                if (css.generic.parseWithOptions(overflow.OverflowKeyword, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"overflow-y" = c } };
+                    }
+                }
+            },
+            .@"text-overflow" => |pre| {
+                if (css.generic.parseWithOptions(overflow.TextOverflow, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"text-overflow" = .{ c, pre } } };
+                    }
+                }
+            },
+            .position => {
+                if (css.generic.parseWithOptions(position.Position, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .position = c } };
+                    }
+                }
+            },
+            .top => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .top = c } };
+                    }
+                }
+            },
+            .bottom => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .bottom = c } };
+                    }
+                }
+            },
+            .left => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .left = c } };
+                    }
+                }
+            },
+            .right => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .right = c } };
+                    }
+                }
+            },
+            .@"inset-block-start" => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"inset-block-start" = c } };
+                    }
+                }
+            },
+            .@"inset-block-end" => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"inset-block-end" = c } };
+                    }
+                }
+            },
+            .@"inset-inline-start" => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"inset-inline-start" = c } };
+                    }
+                }
+            },
+            .@"inset-inline-end" => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"inset-inline-end" = c } };
+                    }
+                }
+            },
+            .@"inset-block" => {
+                if (css.generic.parseWithOptions(margin_padding.InsetBlock, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"inset-block" = c } };
+                    }
+                }
+            },
+            .@"inset-inline" => {
+                if (css.generic.parseWithOptions(margin_padding.InsetInline, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"inset-inline" = c } };
+                    }
+                }
+            },
+            .inset => {
+                if (css.generic.parseWithOptions(margin_padding.Inset, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .inset = c } };
+                    }
+                }
+            },
+            .@"border-spacing" => {
+                if (css.generic.parseWithOptions(css.css_values.size.Size2D(Length), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-spacing" = c } };
+                    }
+                }
+            },
+            .@"border-top-color" => {
+                if (css.generic.parseWithOptions(CssColor, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-top-color" = c } };
+                    }
+                }
+            },
+            .@"border-bottom-color" => {
+                if (css.generic.parseWithOptions(CssColor, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-bottom-color" = c } };
+                    }
+                }
+            },
+            .@"border-left-color" => {
+                if (css.generic.parseWithOptions(CssColor, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-left-color" = c } };
+                    }
+                }
+            },
+            .@"border-right-color" => {
+                if (css.generic.parseWithOptions(CssColor, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-right-color" = c } };
+                    }
+                }
+            },
+            .@"border-block-start-color" => {
+                if (css.generic.parseWithOptions(CssColor, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-block-start-color" = c } };
+                    }
+                }
+            },
+            .@"border-block-end-color" => {
+                if (css.generic.parseWithOptions(CssColor, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-block-end-color" = c } };
+                    }
+                }
+            },
+            .@"border-inline-start-color" => {
+                if (css.generic.parseWithOptions(CssColor, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-inline-start-color" = c } };
+                    }
+                }
+            },
+            .@"border-inline-end-color" => {
+                if (css.generic.parseWithOptions(CssColor, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-inline-end-color" = c } };
+                    }
+                }
+            },
+            .@"border-top-style" => {
+                if (css.generic.parseWithOptions(border.LineStyle, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-top-style" = c } };
+                    }
+                }
+            },
+            .@"border-bottom-style" => {
+                if (css.generic.parseWithOptions(border.LineStyle, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-bottom-style" = c } };
+                    }
+                }
+            },
+            .@"border-left-style" => {
+                if (css.generic.parseWithOptions(border.LineStyle, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-left-style" = c } };
+                    }
+                }
+            },
+            .@"border-right-style" => {
+                if (css.generic.parseWithOptions(border.LineStyle, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-right-style" = c } };
+                    }
+                }
+            },
+            .@"border-block-start-style" => {
+                if (css.generic.parseWithOptions(border.LineStyle, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-block-start-style" = c } };
+                    }
+                }
+            },
+            .@"border-block-end-style" => {
+                if (css.generic.parseWithOptions(border.LineStyle, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-block-end-style" = c } };
+                    }
+                }
+            },
+            .@"border-inline-start-style" => {
+                if (css.generic.parseWithOptions(border.LineStyle, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-inline-start-style" = c } };
+                    }
+                }
+            },
+            .@"border-inline-end-style" => {
+                if (css.generic.parseWithOptions(border.LineStyle, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-inline-end-style" = c } };
+                    }
+                }
+            },
+            .@"border-top-width" => {
+                if (css.generic.parseWithOptions(BorderSideWidth, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-top-width" = c } };
+                    }
+                }
+            },
+            .@"border-bottom-width" => {
+                if (css.generic.parseWithOptions(BorderSideWidth, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-bottom-width" = c } };
+                    }
+                }
+            },
+            .@"border-left-width" => {
+                if (css.generic.parseWithOptions(BorderSideWidth, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-left-width" = c } };
+                    }
+                }
+            },
+            .@"border-right-width" => {
+                if (css.generic.parseWithOptions(BorderSideWidth, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-right-width" = c } };
+                    }
+                }
+            },
+            .@"border-block-start-width" => {
+                if (css.generic.parseWithOptions(BorderSideWidth, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-block-start-width" = c } };
+                    }
+                }
+            },
+            .@"border-block-end-width" => {
+                if (css.generic.parseWithOptions(BorderSideWidth, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-block-end-width" = c } };
+                    }
+                }
+            },
+            .@"border-inline-start-width" => {
+                if (css.generic.parseWithOptions(BorderSideWidth, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-inline-start-width" = c } };
+                    }
+                }
+            },
+            .@"border-inline-end-width" => {
+                if (css.generic.parseWithOptions(BorderSideWidth, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-inline-end-width" = c } };
+                    }
+                }
+            },
+            .@"border-top-left-radius" => |pre| {
+                if (css.generic.parseWithOptions(Size2D(LengthPercentage), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-top-left-radius" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"border-top-right-radius" => |pre| {
+                if (css.generic.parseWithOptions(Size2D(LengthPercentage), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-top-right-radius" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"border-bottom-left-radius" => |pre| {
+                if (css.generic.parseWithOptions(Size2D(LengthPercentage), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-bottom-left-radius" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"border-bottom-right-radius" => |pre| {
+                if (css.generic.parseWithOptions(Size2D(LengthPercentage), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-bottom-right-radius" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"border-start-start-radius" => {
+                if (css.generic.parseWithOptions(Size2D(LengthPercentage), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-start-start-radius" = c } };
+                    }
+                }
+            },
+            .@"border-start-end-radius" => {
+                if (css.generic.parseWithOptions(Size2D(LengthPercentage), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-start-end-radius" = c } };
+                    }
+                }
+            },
+            .@"border-end-start-radius" => {
+                if (css.generic.parseWithOptions(Size2D(LengthPercentage), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-end-start-radius" = c } };
+                    }
+                }
+            },
+            .@"border-end-end-radius" => {
+                if (css.generic.parseWithOptions(Size2D(LengthPercentage), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-end-end-radius" = c } };
+                    }
+                }
+            },
+            .@"border-radius" => |pre| {
+                if (css.generic.parseWithOptions(BorderRadius, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-radius" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"border-image-source" => {
+                if (css.generic.parseWithOptions(Image, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-image-source" = c } };
+                    }
+                }
+            },
+            .@"border-image-outset" => {
+                if (css.generic.parseWithOptions(Rect(LengthOrNumber), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-image-outset" = c } };
+                    }
+                }
+            },
+            .@"border-image-repeat" => {
+                if (css.generic.parseWithOptions(BorderImageRepeat, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-image-repeat" = c } };
+                    }
+                }
+            },
+            .@"border-image-width" => {
+                if (css.generic.parseWithOptions(Rect(BorderImageSideWidth), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-image-width" = c } };
+                    }
+                }
+            },
+            .@"border-image-slice" => {
+                if (css.generic.parseWithOptions(BorderImageSlice, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-image-slice" = c } };
+                    }
+                }
+            },
+            .@"border-image" => |pre| {
+                if (css.generic.parseWithOptions(BorderImage, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-image" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"border-color" => {
+                if (css.generic.parseWithOptions(BorderColor, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-color" = c } };
+                    }
+                }
+            },
+            .@"border-style" => {
+                if (css.generic.parseWithOptions(BorderStyle, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-style" = c } };
+                    }
+                }
+            },
+            .@"border-width" => {
+                if (css.generic.parseWithOptions(BorderWidth, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-width" = c } };
+                    }
+                }
+            },
+            .@"border-block-color" => {
+                if (css.generic.parseWithOptions(BorderBlockColor, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-block-color" = c } };
+                    }
+                }
+            },
+            .@"border-block-style" => {
+                if (css.generic.parseWithOptions(BorderBlockStyle, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-block-style" = c } };
+                    }
+                }
+            },
+            .@"border-block-width" => {
+                if (css.generic.parseWithOptions(BorderBlockWidth, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-block-width" = c } };
+                    }
+                }
+            },
+            .@"border-inline-color" => {
+                if (css.generic.parseWithOptions(BorderInlineColor, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-inline-color" = c } };
+                    }
+                }
+            },
+            .@"border-inline-style" => {
+                if (css.generic.parseWithOptions(BorderInlineStyle, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-inline-style" = c } };
+                    }
+                }
+            },
+            .@"border-inline-width" => {
+                if (css.generic.parseWithOptions(BorderInlineWidth, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-inline-width" = c } };
+                    }
+                }
+            },
+            .border => {
+                if (css.generic.parseWithOptions(Border, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .border = c } };
+                    }
+                }
+            },
+            .@"border-top" => {
+                if (css.generic.parseWithOptions(BorderTop, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-top" = c } };
+                    }
+                }
+            },
+            .@"border-bottom" => {
+                if (css.generic.parseWithOptions(BorderBottom, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-bottom" = c } };
+                    }
+                }
+            },
+            .@"border-left" => {
+                if (css.generic.parseWithOptions(BorderLeft, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-left" = c } };
+                    }
+                }
+            },
+            .@"border-right" => {
+                if (css.generic.parseWithOptions(BorderRight, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-right" = c } };
+                    }
+                }
+            },
+            .@"border-block" => {
+                if (css.generic.parseWithOptions(BorderBlock, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-block" = c } };
+                    }
+                }
+            },
+            .@"border-block-start" => {
+                if (css.generic.parseWithOptions(BorderBlockStart, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-block-start" = c } };
+                    }
+                }
+            },
+            .@"border-block-end" => {
+                if (css.generic.parseWithOptions(BorderBlockEnd, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-block-end" = c } };
+                    }
+                }
+            },
+            .@"border-inline" => {
+                if (css.generic.parseWithOptions(BorderInline, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-inline" = c } };
+                    }
+                }
+            },
+            .@"border-inline-start" => {
+                if (css.generic.parseWithOptions(BorderInlineStart, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-inline-start" = c } };
+                    }
+                }
+            },
+            .@"border-inline-end" => {
+                if (css.generic.parseWithOptions(BorderInlineEnd, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"border-inline-end" = c } };
+                    }
+                }
+            },
+            .outline => {
+                if (css.generic.parseWithOptions(Outline, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .outline = c } };
+                    }
+                }
+            },
+            .@"outline-color" => {
+                if (css.generic.parseWithOptions(CssColor, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"outline-color" = c } };
+                    }
+                }
+            },
+            .@"outline-style" => {
+                if (css.generic.parseWithOptions(OutlineStyle, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"outline-style" = c } };
+                    }
+                }
+            },
+            .@"outline-width" => {
+                if (css.generic.parseWithOptions(BorderSideWidth, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"outline-width" = c } };
+                    }
+                }
+            },
+            .@"flex-direction" => |pre| {
+                if (css.generic.parseWithOptions(FlexDirection, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"flex-direction" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"flex-wrap" => |pre| {
+                if (css.generic.parseWithOptions(FlexWrap, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"flex-wrap" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"flex-flow" => |pre| {
+                if (css.generic.parseWithOptions(FlexFlow, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"flex-flow" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"flex-grow" => |pre| {
+                if (css.generic.parseWithOptions(CSSNumber, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"flex-grow" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"flex-shrink" => |pre| {
+                if (css.generic.parseWithOptions(CSSNumber, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"flex-shrink" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"flex-basis" => |pre| {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"flex-basis" = .{ c, pre } } };
+                    }
+                }
+            },
+            .flex => |pre| {
+                if (css.generic.parseWithOptions(Flex, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .flex = .{ c, pre } } };
+                    }
+                }
+            },
+            .order => |pre| {
+                if (css.generic.parseWithOptions(CSSInteger, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .order = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"align-content" => |pre| {
+                if (css.generic.parseWithOptions(AlignContent, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"align-content" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"justify-content" => |pre| {
+                if (css.generic.parseWithOptions(JustifyContent, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"justify-content" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"place-content" => {
+                if (css.generic.parseWithOptions(PlaceContent, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"place-content" = c } };
+                    }
+                }
+            },
+            .@"align-self" => |pre| {
+                if (css.generic.parseWithOptions(AlignSelf, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"align-self" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"justify-self" => {
+                if (css.generic.parseWithOptions(JustifySelf, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"justify-self" = c } };
+                    }
+                }
+            },
+            .@"place-self" => {
+                if (css.generic.parseWithOptions(PlaceSelf, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"place-self" = c } };
+                    }
+                }
+            },
+            .@"align-items" => |pre| {
+                if (css.generic.parseWithOptions(AlignItems, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"align-items" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"justify-items" => {
+                if (css.generic.parseWithOptions(JustifyItems, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"justify-items" = c } };
+                    }
+                }
+            },
+            .@"place-items" => {
+                if (css.generic.parseWithOptions(PlaceItems, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"place-items" = c } };
+                    }
+                }
+            },
+            .@"row-gap" => {
+                if (css.generic.parseWithOptions(GapValue, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"row-gap" = c } };
+                    }
+                }
+            },
+            .@"column-gap" => {
+                if (css.generic.parseWithOptions(GapValue, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"column-gap" = c } };
+                    }
+                }
+            },
+            .gap => {
+                if (css.generic.parseWithOptions(Gap, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .gap = c } };
+                    }
+                }
+            },
+            .@"box-orient" => |pre| {
+                if (css.generic.parseWithOptions(BoxOrient, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"box-orient" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"box-direction" => |pre| {
+                if (css.generic.parseWithOptions(BoxDirection, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"box-direction" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"box-ordinal-group" => |pre| {
+                if (css.generic.parseWithOptions(CSSInteger, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"box-ordinal-group" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"box-align" => |pre| {
+                if (css.generic.parseWithOptions(BoxAlign, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"box-align" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"box-flex" => |pre| {
+                if (css.generic.parseWithOptions(CSSNumber, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"box-flex" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"box-flex-group" => |pre| {
+                if (css.generic.parseWithOptions(CSSInteger, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"box-flex-group" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"box-pack" => |pre| {
+                if (css.generic.parseWithOptions(BoxPack, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"box-pack" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"box-lines" => |pre| {
+                if (css.generic.parseWithOptions(BoxLines, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"box-lines" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"flex-pack" => |pre| {
+                if (css.generic.parseWithOptions(FlexPack, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"flex-pack" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"flex-order" => |pre| {
+                if (css.generic.parseWithOptions(CSSInteger, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"flex-order" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"flex-align" => |pre| {
+                if (css.generic.parseWithOptions(BoxAlign, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"flex-align" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"flex-item-align" => |pre| {
+                if (css.generic.parseWithOptions(FlexItemAlign, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"flex-item-align" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"flex-line-pack" => |pre| {
+                if (css.generic.parseWithOptions(FlexLinePack, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"flex-line-pack" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"flex-positive" => |pre| {
+                if (css.generic.parseWithOptions(CSSNumber, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"flex-positive" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"flex-negative" => |pre| {
+                if (css.generic.parseWithOptions(CSSNumber, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"flex-negative" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"flex-preferred-size" => |pre| {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"flex-preferred-size" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"margin-top" => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"margin-top" = c } };
+                    }
+                }
+            },
+            .@"margin-bottom" => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"margin-bottom" = c } };
+                    }
+                }
+            },
+            .@"margin-left" => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"margin-left" = c } };
+                    }
+                }
+            },
+            .@"margin-right" => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"margin-right" = c } };
+                    }
+                }
+            },
+            .@"margin-block-start" => {
+                @setEvalBranchQuota(5000);
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"margin-block-start" = c } };
+                    }
+                }
+            },
+            .@"margin-block-end" => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"margin-block-end" = c } };
+                    }
+                }
+            },
+            .@"margin-inline-start" => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"margin-inline-start" = c } };
+                    }
+                }
+            },
+            .@"margin-inline-end" => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"margin-inline-end" = c } };
+                    }
+                }
+            },
+            .@"margin-block" => {
+                if (css.generic.parseWithOptions(MarginBlock, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"margin-block" = c } };
+                    }
+                }
+            },
+            .@"margin-inline" => {
+                if (css.generic.parseWithOptions(MarginInline, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"margin-inline" = c } };
+                    }
+                }
+            },
+            .margin => {
+                @setEvalBranchQuota(5000);
+                if (css.generic.parseWithOptions(Margin, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .margin = c } };
+                    }
+                }
+            },
+            .@"padding-top" => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"padding-top" = c } };
+                    }
+                }
+            },
+            .@"padding-bottom" => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"padding-bottom" = c } };
+                    }
+                }
+            },
+            .@"padding-left" => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"padding-left" = c } };
+                    }
+                }
+            },
+            .@"padding-right" => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"padding-right" = c } };
+                    }
+                }
+            },
+            .@"padding-block-start" => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"padding-block-start" = c } };
+                    }
+                }
+            },
+            .@"padding-block-end" => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"padding-block-end" = c } };
+                    }
+                }
+            },
+            .@"padding-inline-start" => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"padding-inline-start" = c } };
+                    }
+                }
+            },
+            .@"padding-inline-end" => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"padding-inline-end" = c } };
+                    }
+                }
+            },
+            .@"padding-block" => {
+                if (css.generic.parseWithOptions(PaddingBlock, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"padding-block" = c } };
+                    }
+                }
+            },
+            .@"padding-inline" => {
+                if (css.generic.parseWithOptions(PaddingInline, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"padding-inline" = c } };
+                    }
+                }
+            },
+            .padding => {
+                if (css.generic.parseWithOptions(Padding, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .padding = c } };
+                    }
+                }
+            },
+            .@"scroll-margin-top" => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"scroll-margin-top" = c } };
+                    }
+                }
+            },
+            .@"scroll-margin-bottom" => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"scroll-margin-bottom" = c } };
+                    }
+                }
+            },
+            .@"scroll-margin-left" => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"scroll-margin-left" = c } };
+                    }
+                }
+            },
+            .@"scroll-margin-right" => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"scroll-margin-right" = c } };
+                    }
+                }
+            },
+            .@"scroll-margin-block-start" => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"scroll-margin-block-start" = c } };
+                    }
+                }
+            },
+            .@"scroll-margin-block-end" => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"scroll-margin-block-end" = c } };
+                    }
+                }
+            },
+            .@"scroll-margin-inline-start" => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"scroll-margin-inline-start" = c } };
+                    }
+                }
+            },
+            .@"scroll-margin-inline-end" => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"scroll-margin-inline-end" = c } };
+                    }
+                }
+            },
+            .@"scroll-margin-block" => {
+                if (css.generic.parseWithOptions(ScrollMarginBlock, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"scroll-margin-block" = c } };
+                    }
+                }
+            },
+            .@"scroll-margin-inline" => {
+                if (css.generic.parseWithOptions(ScrollMarginInline, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"scroll-margin-inline" = c } };
+                    }
+                }
+            },
+            .@"scroll-margin" => {
+                if (css.generic.parseWithOptions(ScrollMargin, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"scroll-margin" = c } };
+                    }
+                }
+            },
+            .@"scroll-padding-top" => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"scroll-padding-top" = c } };
+                    }
+                }
+            },
+            .@"scroll-padding-bottom" => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"scroll-padding-bottom" = c } };
+                    }
+                }
+            },
+            .@"scroll-padding-left" => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"scroll-padding-left" = c } };
+                    }
+                }
+            },
+            .@"scroll-padding-right" => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"scroll-padding-right" = c } };
+                    }
+                }
+            },
+            .@"scroll-padding-block-start" => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"scroll-padding-block-start" = c } };
+                    }
+                }
+            },
+            .@"scroll-padding-block-end" => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"scroll-padding-block-end" = c } };
+                    }
+                }
+            },
+            .@"scroll-padding-inline-start" => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"scroll-padding-inline-start" = c } };
+                    }
+                }
+            },
+            .@"scroll-padding-inline-end" => {
+                if (css.generic.parseWithOptions(LengthPercentageOrAuto, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"scroll-padding-inline-end" = c } };
+                    }
+                }
+            },
+            .@"scroll-padding-block" => {
+                if (css.generic.parseWithOptions(ScrollPaddingBlock, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"scroll-padding-block" = c } };
+                    }
+                }
+            },
+            .@"scroll-padding-inline" => {
+                if (css.generic.parseWithOptions(ScrollPaddingInline, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"scroll-padding-inline" = c } };
+                    }
+                }
+            },
+            .@"scroll-padding" => {
+                if (css.generic.parseWithOptions(ScrollPadding, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"scroll-padding" = c } };
+                    }
+                }
+            },
+            .@"font-weight" => {
+                if (css.generic.parseWithOptions(FontWeight, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"font-weight" = c } };
+                    }
+                }
+            },
+            .@"font-size" => {
+                if (css.generic.parseWithOptions(FontSize, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"font-size" = c } };
+                    }
+                }
+            },
+            .@"font-stretch" => {
+                if (css.generic.parseWithOptions(FontStretch, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"font-stretch" = c } };
+                    }
+                }
+            },
+            .@"font-family" => {
+                if (css.generic.parseWithOptions(BabyList(FontFamily), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"font-family" = c } };
+                    }
+                }
+            },
+            .@"font-style" => {
+                if (css.generic.parseWithOptions(FontStyle, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"font-style" = c } };
+                    }
+                }
+            },
+            .@"font-variant-caps" => {
+                if (css.generic.parseWithOptions(FontVariantCaps, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"font-variant-caps" = c } };
+                    }
+                }
+            },
+            .@"line-height" => {
+                if (css.generic.parseWithOptions(LineHeight, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"line-height" = c } };
+                    }
+                }
+            },
+            .font => {
+                if (css.generic.parseWithOptions(Font, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .font = c } };
+                    }
+                }
+            },
+            .@"text-decoration-color" => |pre| {
+                if (css.generic.parseWithOptions(CssColor, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"text-decoration-color" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"text-emphasis-color" => |pre| {
+                if (css.generic.parseWithOptions(CssColor, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"text-emphasis-color" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"text-shadow" => {
+                if (css.generic.parseWithOptions(SmallList(TextShadow, 1), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"text-shadow" = c } };
+                    }
+                }
+            },
+            .direction => {
+                if (css.generic.parseWithOptions(Direction, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .direction = c } };
+                    }
+                }
+            },
+            .composes => {
+                if (css.generic.parseWithOptions(Composes, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .composes = c } };
+                    }
+                }
+            },
+            .@"mask-image" => |pre| {
+                if (css.generic.parseWithOptions(SmallList(Image, 1), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"mask-image" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"mask-mode" => {
+                if (css.generic.parseWithOptions(SmallList(MaskMode, 1), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"mask-mode" = c } };
+                    }
+                }
+            },
+            .@"mask-repeat" => |pre| {
+                if (css.generic.parseWithOptions(SmallList(BackgroundRepeat, 1), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"mask-repeat" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"mask-position-x" => {
+                if (css.generic.parseWithOptions(SmallList(HorizontalPosition, 1), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"mask-position-x" = c } };
+                    }
+                }
+            },
+            .@"mask-position-y" => {
+                if (css.generic.parseWithOptions(SmallList(VerticalPosition, 1), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"mask-position-y" = c } };
+                    }
+                }
+            },
+            .@"mask-position" => |pre| {
+                if (css.generic.parseWithOptions(SmallList(Position, 1), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"mask-position" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"mask-clip" => |pre| {
+                @setEvalBranchQuota(5000);
+                if (css.generic.parseWithOptions(SmallList(MaskClip, 1), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"mask-clip" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"mask-origin" => |pre| {
+                if (css.generic.parseWithOptions(SmallList(GeometryBox, 1), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"mask-origin" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"mask-size" => |pre| {
+                if (css.generic.parseWithOptions(SmallList(BackgroundSize, 1), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"mask-size" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"mask-composite" => {
+                if (css.generic.parseWithOptions(SmallList(MaskComposite, 1), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"mask-composite" = c } };
+                    }
+                }
+            },
+            .@"mask-type" => {
+                if (css.generic.parseWithOptions(MaskType, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"mask-type" = c } };
+                    }
+                }
+            },
+            .mask => |pre| {
+                if (css.generic.parseWithOptions(SmallList(Mask, 1), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .mask = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"mask-border-source" => {
+                if (css.generic.parseWithOptions(Image, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"mask-border-source" = c } };
+                    }
+                }
+            },
+            .@"mask-border-mode" => {
+                if (css.generic.parseWithOptions(MaskBorderMode, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"mask-border-mode" = c } };
+                    }
+                }
+            },
+            .@"mask-border-slice" => {
+                if (css.generic.parseWithOptions(BorderImageSlice, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"mask-border-slice" = c } };
+                    }
+                }
+            },
+            .@"mask-border-width" => {
+                if (css.generic.parseWithOptions(Rect(BorderImageSideWidth), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"mask-border-width" = c } };
+                    }
+                }
+            },
+            .@"mask-border-outset" => {
+                if (css.generic.parseWithOptions(Rect(LengthOrNumber), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"mask-border-outset" = c } };
+                    }
+                }
+            },
+            .@"mask-border-repeat" => {
+                if (css.generic.parseWithOptions(BorderImageRepeat, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"mask-border-repeat" = c } };
+                    }
+                }
+            },
+            .@"mask-border" => {
+                if (css.generic.parseWithOptions(MaskBorder, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"mask-border" = c } };
+                    }
+                }
+            },
+            .@"-webkit-mask-composite" => {
+                if (css.generic.parseWithOptions(SmallList(WebKitMaskComposite, 1), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"-webkit-mask-composite" = c } };
+                    }
+                }
+            },
+            .@"mask-source-type" => |pre| {
+                if (css.generic.parseWithOptions(SmallList(WebKitMaskSourceType, 1), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"mask-source-type" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"mask-box-image" => |pre| {
+                if (css.generic.parseWithOptions(BorderImage, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"mask-box-image" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"mask-box-image-source" => |pre| {
+                if (css.generic.parseWithOptions(Image, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"mask-box-image-source" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"mask-box-image-slice" => |pre| {
+                if (css.generic.parseWithOptions(BorderImageSlice, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"mask-box-image-slice" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"mask-box-image-width" => |pre| {
+                if (css.generic.parseWithOptions(Rect(BorderImageSideWidth), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"mask-box-image-width" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"mask-box-image-outset" => |pre| {
+                if (css.generic.parseWithOptions(Rect(LengthOrNumber), input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"mask-box-image-outset" = .{ c, pre } } };
+                    }
+                }
+            },
+            .@"mask-box-image-repeat" => |pre| {
+                if (css.generic.parseWithOptions(BorderImageRepeat, input, options).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .@"mask-box-image-repeat" = .{ c, pre } } };
+                    }
+                }
+            },
+            .all => return .{ .result = .{ .all = switch (CSSWideKeyword.parse(input)) {
+                .result => |v| v,
+                .err => |e| return .{ .err = e },
+            } } },
+            .custom => |name| return .{ .result = .{ .custom = switch (CustomProperty.parse(name, input, options)) {
+                .result => |v| v,
+                .err => |e| return .{ .err = e },
+            } } },
+            else => {},
+        }
+
+        // If a value was unable to be parsed, treat as an unparsed property.
+        // This is different from a custom property, handled below, in that the property name is known
+        // and stored as an enum rather than a string. This lets property handlers more easily deal with it.
+        // Ideally we'd only do this if var() or env() references were seen, but err on the safe side for now.
+        input.reset(&state);
+        return .{ .result = .{ .unparsed = switch (UnparsedProperty.parse(property_id, input, options)) {
+            .result => |v| v,
+            .err => |e| return .{ .err = e },
+        } } };
+    }
+
+    pub fn propertyId(this: *const Property) PropertyId {
+        return switch (this.*) {
+            .@"background-color" => .@"background-color",
+            .@"background-image" => .@"background-image",
+            .@"background-position-x" => .@"background-position-x",
+            .@"background-position-y" => .@"background-position-y",
+            .@"background-position" => .@"background-position",
+            .@"background-size" => .@"background-size",
+            .@"background-repeat" => .@"background-repeat",
+            .@"background-attachment" => .@"background-attachment",
+            .@"background-clip" => |*v| PropertyId{ .@"background-clip" = v[1] },
+            .@"background-origin" => .@"background-origin",
+            .background => .background,
+            .@"box-shadow" => |*v| PropertyId{ .@"box-shadow" = v[1] },
+            .opacity => .opacity,
+            .color => .color,
+            .display => .display,
+            .visibility => .visibility,
+            .width => .width,
+            .height => .height,
+            .@"min-width" => .@"min-width",
+            .@"min-height" => .@"min-height",
+            .@"max-width" => .@"max-width",
+            .@"max-height" => .@"max-height",
+            .@"block-size" => .@"block-size",
+            .@"inline-size" => .@"inline-size",
+            .@"min-block-size" => .@"min-block-size",
+            .@"min-inline-size" => .@"min-inline-size",
+            .@"max-block-size" => .@"max-block-size",
+            .@"max-inline-size" => .@"max-inline-size",
+            .@"box-sizing" => |*v| PropertyId{ .@"box-sizing" = v[1] },
+            .@"aspect-ratio" => .@"aspect-ratio",
+            .overflow => .overflow,
+            .@"overflow-x" => .@"overflow-x",
+            .@"overflow-y" => .@"overflow-y",
+            .@"text-overflow" => |*v| PropertyId{ .@"text-overflow" = v[1] },
+            .position => .position,
+            .top => .top,
+            .bottom => .bottom,
+            .left => .left,
+            .right => .right,
+            .@"inset-block-start" => .@"inset-block-start",
+            .@"inset-block-end" => .@"inset-block-end",
+            .@"inset-inline-start" => .@"inset-inline-start",
+            .@"inset-inline-end" => .@"inset-inline-end",
+            .@"inset-block" => .@"inset-block",
+            .@"inset-inline" => .@"inset-inline",
+            .inset => .inset,
+            .@"border-spacing" => .@"border-spacing",
+            .@"border-top-color" => .@"border-top-color",
+            .@"border-bottom-color" => .@"border-bottom-color",
+            .@"border-left-color" => .@"border-left-color",
+            .@"border-right-color" => .@"border-right-color",
+            .@"border-block-start-color" => .@"border-block-start-color",
+            .@"border-block-end-color" => .@"border-block-end-color",
+            .@"border-inline-start-color" => .@"border-inline-start-color",
+            .@"border-inline-end-color" => .@"border-inline-end-color",
+            .@"border-top-style" => .@"border-top-style",
+            .@"border-bottom-style" => .@"border-bottom-style",
+            .@"border-left-style" => .@"border-left-style",
+            .@"border-right-style" => .@"border-right-style",
+            .@"border-block-start-style" => .@"border-block-start-style",
+            .@"border-block-end-style" => .@"border-block-end-style",
+            .@"border-inline-start-style" => .@"border-inline-start-style",
+            .@"border-inline-end-style" => .@"border-inline-end-style",
+            .@"border-top-width" => .@"border-top-width",
+            .@"border-bottom-width" => .@"border-bottom-width",
+            .@"border-left-width" => .@"border-left-width",
+            .@"border-right-width" => .@"border-right-width",
+            .@"border-block-start-width" => .@"border-block-start-width",
+            .@"border-block-end-width" => .@"border-block-end-width",
+            .@"border-inline-start-width" => .@"border-inline-start-width",
+            .@"border-inline-end-width" => .@"border-inline-end-width",
+            .@"border-top-left-radius" => |*v| PropertyId{ .@"border-top-left-radius" = v[1] },
+            .@"border-top-right-radius" => |*v| PropertyId{ .@"border-top-right-radius" = v[1] },
+            .@"border-bottom-left-radius" => |*v| PropertyId{ .@"border-bottom-left-radius" = v[1] },
+            .@"border-bottom-right-radius" => |*v| PropertyId{ .@"border-bottom-right-radius" = v[1] },
+            .@"border-start-start-radius" => .@"border-start-start-radius",
+            .@"border-start-end-radius" => .@"border-start-end-radius",
+            .@"border-end-start-radius" => .@"border-end-start-radius",
+            .@"border-end-end-radius" => .@"border-end-end-radius",
+            .@"border-radius" => |*v| PropertyId{ .@"border-radius" = v[1] },
+            .@"border-image-source" => .@"border-image-source",
+            .@"border-image-outset" => .@"border-image-outset",
+            .@"border-image-repeat" => .@"border-image-repeat",
+            .@"border-image-width" => .@"border-image-width",
+            .@"border-image-slice" => .@"border-image-slice",
+            .@"border-image" => |*v| PropertyId{ .@"border-image" = v[1] },
+            .@"border-color" => .@"border-color",
+            .@"border-style" => .@"border-style",
+            .@"border-width" => .@"border-width",
+            .@"border-block-color" => .@"border-block-color",
+            .@"border-block-style" => .@"border-block-style",
+            .@"border-block-width" => .@"border-block-width",
+            .@"border-inline-color" => .@"border-inline-color",
+            .@"border-inline-style" => .@"border-inline-style",
+            .@"border-inline-width" => .@"border-inline-width",
+            .border => .border,
+            .@"border-top" => .@"border-top",
+            .@"border-bottom" => .@"border-bottom",
+            .@"border-left" => .@"border-left",
+            .@"border-right" => .@"border-right",
+            .@"border-block" => .@"border-block",
+            .@"border-block-start" => .@"border-block-start",
+            .@"border-block-end" => .@"border-block-end",
+            .@"border-inline" => .@"border-inline",
+            .@"border-inline-start" => .@"border-inline-start",
+            .@"border-inline-end" => .@"border-inline-end",
+            .outline => .outline,
+            .@"outline-color" => .@"outline-color",
+            .@"outline-style" => .@"outline-style",
+            .@"outline-width" => .@"outline-width",
+            .@"flex-direction" => |*v| PropertyId{ .@"flex-direction" = v[1] },
+            .@"flex-wrap" => |*v| PropertyId{ .@"flex-wrap" = v[1] },
+            .@"flex-flow" => |*v| PropertyId{ .@"flex-flow" = v[1] },
+            .@"flex-grow" => |*v| PropertyId{ .@"flex-grow" = v[1] },
+            .@"flex-shrink" => |*v| PropertyId{ .@"flex-shrink" = v[1] },
+            .@"flex-basis" => |*v| PropertyId{ .@"flex-basis" = v[1] },
+            .flex => |*v| PropertyId{ .flex = v[1] },
+            .order => |*v| PropertyId{ .order = v[1] },
+            .@"align-content" => |*v| PropertyId{ .@"align-content" = v[1] },
+            .@"justify-content" => |*v| PropertyId{ .@"justify-content" = v[1] },
+            .@"place-content" => .@"place-content",
+            .@"align-self" => |*v| PropertyId{ .@"align-self" = v[1] },
+            .@"justify-self" => .@"justify-self",
+            .@"place-self" => .@"place-self",
+            .@"align-items" => |*v| PropertyId{ .@"align-items" = v[1] },
+            .@"justify-items" => .@"justify-items",
+            .@"place-items" => .@"place-items",
+            .@"row-gap" => .@"row-gap",
+            .@"column-gap" => .@"column-gap",
+            .gap => .gap,
+            .@"box-orient" => |*v| PropertyId{ .@"box-orient" = v[1] },
+            .@"box-direction" => |*v| PropertyId{ .@"box-direction" = v[1] },
+            .@"box-ordinal-group" => |*v| PropertyId{ .@"box-ordinal-group" = v[1] },
+            .@"box-align" => |*v| PropertyId{ .@"box-align" = v[1] },
+            .@"box-flex" => |*v| PropertyId{ .@"box-flex" = v[1] },
+            .@"box-flex-group" => |*v| PropertyId{ .@"box-flex-group" = v[1] },
+            .@"box-pack" => |*v| PropertyId{ .@"box-pack" = v[1] },
+            .@"box-lines" => |*v| PropertyId{ .@"box-lines" = v[1] },
+            .@"flex-pack" => |*v| PropertyId{ .@"flex-pack" = v[1] },
+            .@"flex-order" => |*v| PropertyId{ .@"flex-order" = v[1] },
+            .@"flex-align" => |*v| PropertyId{ .@"flex-align" = v[1] },
+            .@"flex-item-align" => |*v| PropertyId{ .@"flex-item-align" = v[1] },
+            .@"flex-line-pack" => |*v| PropertyId{ .@"flex-line-pack" = v[1] },
+            .@"flex-positive" => |*v| PropertyId{ .@"flex-positive" = v[1] },
+            .@"flex-negative" => |*v| PropertyId{ .@"flex-negative" = v[1] },
+            .@"flex-preferred-size" => |*v| PropertyId{ .@"flex-preferred-size" = v[1] },
+            .@"margin-top" => .@"margin-top",
+            .@"margin-bottom" => .@"margin-bottom",
+            .@"margin-left" => .@"margin-left",
+            .@"margin-right" => .@"margin-right",
+            .@"margin-block-start" => .@"margin-block-start",
+            .@"margin-block-end" => .@"margin-block-end",
+            .@"margin-inline-start" => .@"margin-inline-start",
+            .@"margin-inline-end" => .@"margin-inline-end",
+            .@"margin-block" => .@"margin-block",
+            .@"margin-inline" => .@"margin-inline",
+            .margin => .margin,
+            .@"padding-top" => .@"padding-top",
+            .@"padding-bottom" => .@"padding-bottom",
+            .@"padding-left" => .@"padding-left",
+            .@"padding-right" => .@"padding-right",
+            .@"padding-block-start" => .@"padding-block-start",
+            .@"padding-block-end" => .@"padding-block-end",
+            .@"padding-inline-start" => .@"padding-inline-start",
+            .@"padding-inline-end" => .@"padding-inline-end",
+            .@"padding-block" => .@"padding-block",
+            .@"padding-inline" => .@"padding-inline",
+            .padding => .padding,
+            .@"scroll-margin-top" => .@"scroll-margin-top",
+            .@"scroll-margin-bottom" => .@"scroll-margin-bottom",
+            .@"scroll-margin-left" => .@"scroll-margin-left",
+            .@"scroll-margin-right" => .@"scroll-margin-right",
+            .@"scroll-margin-block-start" => .@"scroll-margin-block-start",
+            .@"scroll-margin-block-end" => .@"scroll-margin-block-end",
+            .@"scroll-margin-inline-start" => .@"scroll-margin-inline-start",
+            .@"scroll-margin-inline-end" => .@"scroll-margin-inline-end",
+            .@"scroll-margin-block" => .@"scroll-margin-block",
+            .@"scroll-margin-inline" => .@"scroll-margin-inline",
+            .@"scroll-margin" => .@"scroll-margin",
+            .@"scroll-padding-top" => .@"scroll-padding-top",
+            .@"scroll-padding-bottom" => .@"scroll-padding-bottom",
+            .@"scroll-padding-left" => .@"scroll-padding-left",
+            .@"scroll-padding-right" => .@"scroll-padding-right",
+            .@"scroll-padding-block-start" => .@"scroll-padding-block-start",
+            .@"scroll-padding-block-end" => .@"scroll-padding-block-end",
+            .@"scroll-padding-inline-start" => .@"scroll-padding-inline-start",
+            .@"scroll-padding-inline-end" => .@"scroll-padding-inline-end",
+            .@"scroll-padding-block" => .@"scroll-padding-block",
+            .@"scroll-padding-inline" => .@"scroll-padding-inline",
+            .@"scroll-padding" => .@"scroll-padding",
+            .@"font-weight" => .@"font-weight",
+            .@"font-size" => .@"font-size",
+            .@"font-stretch" => .@"font-stretch",
+            .@"font-family" => .@"font-family",
+            .@"font-style" => .@"font-style",
+            .@"font-variant-caps" => .@"font-variant-caps",
+            .@"line-height" => .@"line-height",
+            .font => .font,
+            .@"text-decoration-color" => |*v| PropertyId{ .@"text-decoration-color" = v[1] },
+            .@"text-emphasis-color" => |*v| PropertyId{ .@"text-emphasis-color" = v[1] },
+            .@"text-shadow" => .@"text-shadow",
+            .direction => .direction,
+            .composes => .composes,
+            .@"mask-image" => |*v| PropertyId{ .@"mask-image" = v[1] },
+            .@"mask-mode" => .@"mask-mode",
+            .@"mask-repeat" => |*v| PropertyId{ .@"mask-repeat" = v[1] },
+            .@"mask-position-x" => .@"mask-position-x",
+            .@"mask-position-y" => .@"mask-position-y",
+            .@"mask-position" => |*v| PropertyId{ .@"mask-position" = v[1] },
+            .@"mask-clip" => |*v| PropertyId{ .@"mask-clip" = v[1] },
+            .@"mask-origin" => |*v| PropertyId{ .@"mask-origin" = v[1] },
+            .@"mask-size" => |*v| PropertyId{ .@"mask-size" = v[1] },
+            .@"mask-composite" => .@"mask-composite",
+            .@"mask-type" => .@"mask-type",
+            .mask => |*v| PropertyId{ .mask = v[1] },
+            .@"mask-border-source" => .@"mask-border-source",
+            .@"mask-border-mode" => .@"mask-border-mode",
+            .@"mask-border-slice" => .@"mask-border-slice",
+            .@"mask-border-width" => .@"mask-border-width",
+            .@"mask-border-outset" => .@"mask-border-outset",
+            .@"mask-border-repeat" => .@"mask-border-repeat",
+            .@"mask-border" => .@"mask-border",
+            .@"-webkit-mask-composite" => .@"-webkit-mask-composite",
+            .@"mask-source-type" => |*v| PropertyId{ .@"mask-source-type" = v[1] },
+            .@"mask-box-image" => |*v| PropertyId{ .@"mask-box-image" = v[1] },
+            .@"mask-box-image-source" => |*v| PropertyId{ .@"mask-box-image-source" = v[1] },
+            .@"mask-box-image-slice" => |*v| PropertyId{ .@"mask-box-image-slice" = v[1] },
+            .@"mask-box-image-width" => |*v| PropertyId{ .@"mask-box-image-width" = v[1] },
+            .@"mask-box-image-outset" => |*v| PropertyId{ .@"mask-box-image-outset" = v[1] },
+            .@"mask-box-image-repeat" => |*v| PropertyId{ .@"mask-box-image-repeat" = v[1] },
+            .all => PropertyId.all,
+            .unparsed => |unparsed| unparsed.property_id,
+            .custom => |c| .{ .custom = c.name },
+        };
+    }
+
+    pub fn deepClone(this: *const Property, allocator: std.mem.Allocator) Property {
+        return switch (this.*) {
+            .@"background-color" => |*v| .{ .@"background-color" = v.deepClone(allocator) },
+            .@"background-image" => |*v| .{ .@"background-image" = v.deepClone(allocator) },
+            .@"background-position-x" => |*v| .{ .@"background-position-x" = v.deepClone(allocator) },
+            .@"background-position-y" => |*v| .{ .@"background-position-y" = v.deepClone(allocator) },
+            .@"background-position" => |*v| .{ .@"background-position" = v.deepClone(allocator) },
+            .@"background-size" => |*v| .{ .@"background-size" = v.deepClone(allocator) },
+            .@"background-repeat" => |*v| .{ .@"background-repeat" = v.deepClone(allocator) },
+            .@"background-attachment" => |*v| .{ .@"background-attachment" = v.deepClone(allocator) },
+            .@"background-clip" => |*v| .{ .@"background-clip" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"background-origin" => |*v| .{ .@"background-origin" = v.deepClone(allocator) },
+            .background => |*v| .{ .background = v.deepClone(allocator) },
+            .@"box-shadow" => |*v| .{ .@"box-shadow" = .{ v[0].deepClone(allocator), v[1] } },
+            .opacity => |*v| .{ .opacity = v.deepClone(allocator) },
+            .color => |*v| .{ .color = v.deepClone(allocator) },
+            .display => |*v| .{ .display = v.deepClone(allocator) },
+            .visibility => |*v| .{ .visibility = v.deepClone(allocator) },
+            .width => |*v| .{ .width = v.deepClone(allocator) },
+            .height => |*v| .{ .height = v.deepClone(allocator) },
+            .@"min-width" => |*v| .{ .@"min-width" = v.deepClone(allocator) },
+            .@"min-height" => |*v| .{ .@"min-height" = v.deepClone(allocator) },
+            .@"max-width" => |*v| .{ .@"max-width" = v.deepClone(allocator) },
+            .@"max-height" => |*v| .{ .@"max-height" = v.deepClone(allocator) },
+            .@"block-size" => |*v| .{ .@"block-size" = v.deepClone(allocator) },
+            .@"inline-size" => |*v| .{ .@"inline-size" = v.deepClone(allocator) },
+            .@"min-block-size" => |*v| .{ .@"min-block-size" = v.deepClone(allocator) },
+            .@"min-inline-size" => |*v| .{ .@"min-inline-size" = v.deepClone(allocator) },
+            .@"max-block-size" => |*v| .{ .@"max-block-size" = v.deepClone(allocator) },
+            .@"max-inline-size" => |*v| .{ .@"max-inline-size" = v.deepClone(allocator) },
+            .@"box-sizing" => |*v| .{ .@"box-sizing" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"aspect-ratio" => |*v| .{ .@"aspect-ratio" = v.deepClone(allocator) },
+            .overflow => |*v| .{ .overflow = v.deepClone(allocator) },
+            .@"overflow-x" => |*v| .{ .@"overflow-x" = v.deepClone(allocator) },
+            .@"overflow-y" => |*v| .{ .@"overflow-y" = v.deepClone(allocator) },
+            .@"text-overflow" => |*v| .{ .@"text-overflow" = .{ v[0].deepClone(allocator), v[1] } },
+            .position => |*v| .{ .position = v.deepClone(allocator) },
+            .top => |*v| .{ .top = v.deepClone(allocator) },
+            .bottom => |*v| .{ .bottom = v.deepClone(allocator) },
+            .left => |*v| .{ .left = v.deepClone(allocator) },
+            .right => |*v| .{ .right = v.deepClone(allocator) },
+            .@"inset-block-start" => |*v| .{ .@"inset-block-start" = v.deepClone(allocator) },
+            .@"inset-block-end" => |*v| .{ .@"inset-block-end" = v.deepClone(allocator) },
+            .@"inset-inline-start" => |*v| .{ .@"inset-inline-start" = v.deepClone(allocator) },
+            .@"inset-inline-end" => |*v| .{ .@"inset-inline-end" = v.deepClone(allocator) },
+            .@"inset-block" => |*v| .{ .@"inset-block" = v.deepClone(allocator) },
+            .@"inset-inline" => |*v| .{ .@"inset-inline" = v.deepClone(allocator) },
+            .inset => |*v| .{ .inset = v.deepClone(allocator) },
+            .@"border-spacing" => |*v| .{ .@"border-spacing" = v.deepClone(allocator) },
+            .@"border-top-color" => |*v| .{ .@"border-top-color" = v.deepClone(allocator) },
+            .@"border-bottom-color" => |*v| .{ .@"border-bottom-color" = v.deepClone(allocator) },
+            .@"border-left-color" => |*v| .{ .@"border-left-color" = v.deepClone(allocator) },
+            .@"border-right-color" => |*v| .{ .@"border-right-color" = v.deepClone(allocator) },
+            .@"border-block-start-color" => |*v| .{ .@"border-block-start-color" = v.deepClone(allocator) },
+            .@"border-block-end-color" => |*v| .{ .@"border-block-end-color" = v.deepClone(allocator) },
+            .@"border-inline-start-color" => |*v| .{ .@"border-inline-start-color" = v.deepClone(allocator) },
+            .@"border-inline-end-color" => |*v| .{ .@"border-inline-end-color" = v.deepClone(allocator) },
+            .@"border-top-style" => |*v| .{ .@"border-top-style" = v.deepClone(allocator) },
+            .@"border-bottom-style" => |*v| .{ .@"border-bottom-style" = v.deepClone(allocator) },
+            .@"border-left-style" => |*v| .{ .@"border-left-style" = v.deepClone(allocator) },
+            .@"border-right-style" => |*v| .{ .@"border-right-style" = v.deepClone(allocator) },
+            .@"border-block-start-style" => |*v| .{ .@"border-block-start-style" = v.deepClone(allocator) },
+            .@"border-block-end-style" => |*v| .{ .@"border-block-end-style" = v.deepClone(allocator) },
+            .@"border-inline-start-style" => |*v| .{ .@"border-inline-start-style" = v.deepClone(allocator) },
+            .@"border-inline-end-style" => |*v| .{ .@"border-inline-end-style" = v.deepClone(allocator) },
+            .@"border-top-width" => |*v| .{ .@"border-top-width" = v.deepClone(allocator) },
+            .@"border-bottom-width" => |*v| .{ .@"border-bottom-width" = v.deepClone(allocator) },
+            .@"border-left-width" => |*v| .{ .@"border-left-width" = v.deepClone(allocator) },
+            .@"border-right-width" => |*v| .{ .@"border-right-width" = v.deepClone(allocator) },
+            .@"border-block-start-width" => |*v| .{ .@"border-block-start-width" = v.deepClone(allocator) },
+            .@"border-block-end-width" => |*v| .{ .@"border-block-end-width" = v.deepClone(allocator) },
+            .@"border-inline-start-width" => |*v| .{ .@"border-inline-start-width" = v.deepClone(allocator) },
+            .@"border-inline-end-width" => |*v| .{ .@"border-inline-end-width" = v.deepClone(allocator) },
+            .@"border-top-left-radius" => |*v| .{ .@"border-top-left-radius" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"border-top-right-radius" => |*v| .{ .@"border-top-right-radius" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"border-bottom-left-radius" => |*v| .{ .@"border-bottom-left-radius" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"border-bottom-right-radius" => |*v| .{ .@"border-bottom-right-radius" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"border-start-start-radius" => |*v| .{ .@"border-start-start-radius" = v.deepClone(allocator) },
+            .@"border-start-end-radius" => |*v| .{ .@"border-start-end-radius" = v.deepClone(allocator) },
+            .@"border-end-start-radius" => |*v| .{ .@"border-end-start-radius" = v.deepClone(allocator) },
+            .@"border-end-end-radius" => |*v| .{ .@"border-end-end-radius" = v.deepClone(allocator) },
+            .@"border-radius" => |*v| .{ .@"border-radius" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"border-image-source" => |*v| .{ .@"border-image-source" = v.deepClone(allocator) },
+            .@"border-image-outset" => |*v| .{ .@"border-image-outset" = v.deepClone(allocator) },
+            .@"border-image-repeat" => |*v| .{ .@"border-image-repeat" = v.deepClone(allocator) },
+            .@"border-image-width" => |*v| .{ .@"border-image-width" = v.deepClone(allocator) },
+            .@"border-image-slice" => |*v| .{ .@"border-image-slice" = v.deepClone(allocator) },
+            .@"border-image" => |*v| .{ .@"border-image" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"border-color" => |*v| .{ .@"border-color" = v.deepClone(allocator) },
+            .@"border-style" => |*v| .{ .@"border-style" = v.deepClone(allocator) },
+            .@"border-width" => |*v| .{ .@"border-width" = v.deepClone(allocator) },
+            .@"border-block-color" => |*v| .{ .@"border-block-color" = v.deepClone(allocator) },
+            .@"border-block-style" => |*v| .{ .@"border-block-style" = v.deepClone(allocator) },
+            .@"border-block-width" => |*v| .{ .@"border-block-width" = v.deepClone(allocator) },
+            .@"border-inline-color" => |*v| .{ .@"border-inline-color" = v.deepClone(allocator) },
+            .@"border-inline-style" => |*v| .{ .@"border-inline-style" = v.deepClone(allocator) },
+            .@"border-inline-width" => |*v| .{ .@"border-inline-width" = v.deepClone(allocator) },
+            .border => |*v| .{ .border = v.deepClone(allocator) },
+            .@"border-top" => |*v| .{ .@"border-top" = v.deepClone(allocator) },
+            .@"border-bottom" => |*v| .{ .@"border-bottom" = v.deepClone(allocator) },
+            .@"border-left" => |*v| .{ .@"border-left" = v.deepClone(allocator) },
+            .@"border-right" => |*v| .{ .@"border-right" = v.deepClone(allocator) },
+            .@"border-block" => |*v| .{ .@"border-block" = v.deepClone(allocator) },
+            .@"border-block-start" => |*v| .{ .@"border-block-start" = v.deepClone(allocator) },
+            .@"border-block-end" => |*v| .{ .@"border-block-end" = v.deepClone(allocator) },
+            .@"border-inline" => |*v| .{ .@"border-inline" = v.deepClone(allocator) },
+            .@"border-inline-start" => |*v| .{ .@"border-inline-start" = v.deepClone(allocator) },
+            .@"border-inline-end" => |*v| .{ .@"border-inline-end" = v.deepClone(allocator) },
+            .outline => |*v| .{ .outline = v.deepClone(allocator) },
+            .@"outline-color" => |*v| .{ .@"outline-color" = v.deepClone(allocator) },
+            .@"outline-style" => |*v| .{ .@"outline-style" = v.deepClone(allocator) },
+            .@"outline-width" => |*v| .{ .@"outline-width" = v.deepClone(allocator) },
+            .@"flex-direction" => |*v| .{ .@"flex-direction" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"flex-wrap" => |*v| .{ .@"flex-wrap" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"flex-flow" => |*v| .{ .@"flex-flow" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"flex-grow" => |*v| .{ .@"flex-grow" = .{ v[0], v[1] } },
+            .@"flex-shrink" => |*v| .{ .@"flex-shrink" = .{ v[0], v[1] } },
+            .@"flex-basis" => |*v| .{ .@"flex-basis" = .{ v[0].deepClone(allocator), v[1] } },
+            .flex => |*v| .{ .flex = .{ v[0].deepClone(allocator), v[1] } },
+            .order => |*v| .{ .order = .{ v[0], v[1] } },
+            .@"align-content" => |*v| .{ .@"align-content" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"justify-content" => |*v| .{ .@"justify-content" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"place-content" => |*v| .{ .@"place-content" = v.deepClone(allocator) },
+            .@"align-self" => |*v| .{ .@"align-self" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"justify-self" => |*v| .{ .@"justify-self" = v.deepClone(allocator) },
+            .@"place-self" => |*v| .{ .@"place-self" = v.deepClone(allocator) },
+            .@"align-items" => |*v| .{ .@"align-items" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"justify-items" => |*v| .{ .@"justify-items" = v.deepClone(allocator) },
+            .@"place-items" => |*v| .{ .@"place-items" = v.deepClone(allocator) },
+            .@"row-gap" => |*v| .{ .@"row-gap" = v.deepClone(allocator) },
+            .@"column-gap" => |*v| .{ .@"column-gap" = v.deepClone(allocator) },
+            .gap => |*v| .{ .gap = v.deepClone(allocator) },
+            .@"box-orient" => |*v| .{ .@"box-orient" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"box-direction" => |*v| .{ .@"box-direction" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"box-ordinal-group" => |*v| .{ .@"box-ordinal-group" = .{ v[0], v[1] } },
+            .@"box-align" => |*v| .{ .@"box-align" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"box-flex" => |*v| .{ .@"box-flex" = .{ v[0], v[1] } },
+            .@"box-flex-group" => |*v| .{ .@"box-flex-group" = .{ v[0], v[1] } },
+            .@"box-pack" => |*v| .{ .@"box-pack" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"box-lines" => |*v| .{ .@"box-lines" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"flex-pack" => |*v| .{ .@"flex-pack" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"flex-order" => |*v| .{ .@"flex-order" = .{ v[0], v[1] } },
+            .@"flex-align" => |*v| .{ .@"flex-align" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"flex-item-align" => |*v| .{ .@"flex-item-align" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"flex-line-pack" => |*v| .{ .@"flex-line-pack" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"flex-positive" => |*v| .{ .@"flex-positive" = .{ v[0], v[1] } },
+            .@"flex-negative" => |*v| .{ .@"flex-negative" = .{ v[0], v[1] } },
+            .@"flex-preferred-size" => |*v| .{ .@"flex-preferred-size" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"margin-top" => |*v| .{ .@"margin-top" = v.deepClone(allocator) },
+            .@"margin-bottom" => |*v| .{ .@"margin-bottom" = v.deepClone(allocator) },
+            .@"margin-left" => |*v| .{ .@"margin-left" = v.deepClone(allocator) },
+            .@"margin-right" => |*v| .{ .@"margin-right" = v.deepClone(allocator) },
+            .@"margin-block-start" => |*v| .{ .@"margin-block-start" = v.deepClone(allocator) },
+            .@"margin-block-end" => |*v| .{ .@"margin-block-end" = v.deepClone(allocator) },
+            .@"margin-inline-start" => |*v| .{ .@"margin-inline-start" = v.deepClone(allocator) },
+            .@"margin-inline-end" => |*v| .{ .@"margin-inline-end" = v.deepClone(allocator) },
+            .@"margin-block" => |*v| .{ .@"margin-block" = v.deepClone(allocator) },
+            .@"margin-inline" => |*v| .{ .@"margin-inline" = v.deepClone(allocator) },
+            .margin => |*v| .{ .margin = v.deepClone(allocator) },
+            .@"padding-top" => |*v| .{ .@"padding-top" = v.deepClone(allocator) },
+            .@"padding-bottom" => |*v| .{ .@"padding-bottom" = v.deepClone(allocator) },
+            .@"padding-left" => |*v| .{ .@"padding-left" = v.deepClone(allocator) },
+            .@"padding-right" => |*v| .{ .@"padding-right" = v.deepClone(allocator) },
+            .@"padding-block-start" => |*v| .{ .@"padding-block-start" = v.deepClone(allocator) },
+            .@"padding-block-end" => |*v| .{ .@"padding-block-end" = v.deepClone(allocator) },
+            .@"padding-inline-start" => |*v| .{ .@"padding-inline-start" = v.deepClone(allocator) },
+            .@"padding-inline-end" => |*v| .{ .@"padding-inline-end" = v.deepClone(allocator) },
+            .@"padding-block" => |*v| .{ .@"padding-block" = v.deepClone(allocator) },
+            .@"padding-inline" => |*v| .{ .@"padding-inline" = v.deepClone(allocator) },
+            .padding => |*v| .{ .padding = v.deepClone(allocator) },
+            .@"scroll-margin-top" => |*v| .{ .@"scroll-margin-top" = v.deepClone(allocator) },
+            .@"scroll-margin-bottom" => |*v| .{ .@"scroll-margin-bottom" = v.deepClone(allocator) },
+            .@"scroll-margin-left" => |*v| .{ .@"scroll-margin-left" = v.deepClone(allocator) },
+            .@"scroll-margin-right" => |*v| .{ .@"scroll-margin-right" = v.deepClone(allocator) },
+            .@"scroll-margin-block-start" => |*v| .{ .@"scroll-margin-block-start" = v.deepClone(allocator) },
+            .@"scroll-margin-block-end" => |*v| .{ .@"scroll-margin-block-end" = v.deepClone(allocator) },
+            .@"scroll-margin-inline-start" => |*v| .{ .@"scroll-margin-inline-start" = v.deepClone(allocator) },
+            .@"scroll-margin-inline-end" => |*v| .{ .@"scroll-margin-inline-end" = v.deepClone(allocator) },
+            .@"scroll-margin-block" => |*v| .{ .@"scroll-margin-block" = v.deepClone(allocator) },
+            .@"scroll-margin-inline" => |*v| .{ .@"scroll-margin-inline" = v.deepClone(allocator) },
+            .@"scroll-margin" => |*v| .{ .@"scroll-margin" = v.deepClone(allocator) },
+            .@"scroll-padding-top" => |*v| .{ .@"scroll-padding-top" = v.deepClone(allocator) },
+            .@"scroll-padding-bottom" => |*v| .{ .@"scroll-padding-bottom" = v.deepClone(allocator) },
+            .@"scroll-padding-left" => |*v| .{ .@"scroll-padding-left" = v.deepClone(allocator) },
+            .@"scroll-padding-right" => |*v| .{ .@"scroll-padding-right" = v.deepClone(allocator) },
+            .@"scroll-padding-block-start" => |*v| .{ .@"scroll-padding-block-start" = v.deepClone(allocator) },
+            .@"scroll-padding-block-end" => |*v| .{ .@"scroll-padding-block-end" = v.deepClone(allocator) },
+            .@"scroll-padding-inline-start" => |*v| .{ .@"scroll-padding-inline-start" = v.deepClone(allocator) },
+            .@"scroll-padding-inline-end" => |*v| .{ .@"scroll-padding-inline-end" = v.deepClone(allocator) },
+            .@"scroll-padding-block" => |*v| .{ .@"scroll-padding-block" = v.deepClone(allocator) },
+            .@"scroll-padding-inline" => |*v| .{ .@"scroll-padding-inline" = v.deepClone(allocator) },
+            .@"scroll-padding" => |*v| .{ .@"scroll-padding" = v.deepClone(allocator) },
+            .@"font-weight" => |*v| .{ .@"font-weight" = v.deepClone(allocator) },
+            .@"font-size" => |*v| .{ .@"font-size" = v.deepClone(allocator) },
+            .@"font-stretch" => |*v| .{ .@"font-stretch" = v.deepClone(allocator) },
+            .@"font-family" => |*v| .{ .@"font-family" = css.generic.deepClone(BabyList(FontFamily), v, allocator) },
+            .@"font-style" => |*v| .{ .@"font-style" = v.deepClone(allocator) },
+            .@"font-variant-caps" => |*v| .{ .@"font-variant-caps" = v.deepClone(allocator) },
+            .@"line-height" => |*v| .{ .@"line-height" = v.deepClone(allocator) },
+            .font => |*v| .{ .font = v.deepClone(allocator) },
+            .@"text-decoration-color" => |*v| .{ .@"text-decoration-color" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"text-emphasis-color" => |*v| .{ .@"text-emphasis-color" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"text-shadow" => |*v| .{ .@"text-shadow" = v.deepClone(allocator) },
+            .direction => |*v| .{ .direction = v.deepClone(allocator) },
+            .composes => |*v| .{ .composes = v.deepClone(allocator) },
+            .@"mask-image" => |*v| .{ .@"mask-image" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"mask-mode" => |*v| .{ .@"mask-mode" = v.deepClone(allocator) },
+            .@"mask-repeat" => |*v| .{ .@"mask-repeat" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"mask-position-x" => |*v| .{ .@"mask-position-x" = v.deepClone(allocator) },
+            .@"mask-position-y" => |*v| .{ .@"mask-position-y" = v.deepClone(allocator) },
+            .@"mask-position" => |*v| .{ .@"mask-position" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"mask-clip" => |*v| .{ .@"mask-clip" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"mask-origin" => |*v| .{ .@"mask-origin" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"mask-size" => |*v| .{ .@"mask-size" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"mask-composite" => |*v| .{ .@"mask-composite" = v.deepClone(allocator) },
+            .@"mask-type" => |*v| .{ .@"mask-type" = v.deepClone(allocator) },
+            .mask => |*v| .{ .mask = .{ v[0].deepClone(allocator), v[1] } },
+            .@"mask-border-source" => |*v| .{ .@"mask-border-source" = v.deepClone(allocator) },
+            .@"mask-border-mode" => |*v| .{ .@"mask-border-mode" = v.deepClone(allocator) },
+            .@"mask-border-slice" => |*v| .{ .@"mask-border-slice" = v.deepClone(allocator) },
+            .@"mask-border-width" => |*v| .{ .@"mask-border-width" = v.deepClone(allocator) },
+            .@"mask-border-outset" => |*v| .{ .@"mask-border-outset" = v.deepClone(allocator) },
+            .@"mask-border-repeat" => |*v| .{ .@"mask-border-repeat" = v.deepClone(allocator) },
+            .@"mask-border" => |*v| .{ .@"mask-border" = v.deepClone(allocator) },
+            .@"-webkit-mask-composite" => |*v| .{ .@"-webkit-mask-composite" = v.deepClone(allocator) },
+            .@"mask-source-type" => |*v| .{ .@"mask-source-type" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"mask-box-image" => |*v| .{ .@"mask-box-image" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"mask-box-image-source" => |*v| .{ .@"mask-box-image-source" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"mask-box-image-slice" => |*v| .{ .@"mask-box-image-slice" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"mask-box-image-width" => |*v| .{ .@"mask-box-image-width" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"mask-box-image-outset" => |*v| .{ .@"mask-box-image-outset" = .{ v[0].deepClone(allocator), v[1] } },
+            .@"mask-box-image-repeat" => |*v| .{ .@"mask-box-image-repeat" = .{ v[0].deepClone(allocator), v[1] } },
+            .all => |*a| return .{ .all = a.deepClone(allocator) },
+            .unparsed => |*u| return .{ .unparsed = u.deepClone(allocator) },
+            .custom => |*c| return .{ .custom = c.deepClone(allocator) },
+        };
+    }
+
+    /// We're going to have this empty for now since not every property has a deinit function.
+    /// It's not strictly necessary since all allocations are into an arena.
+    /// It's mostly intended as a performance optimization in the case where mimalloc arena is used,
+    /// since it can reclaim the memory and use it for subsequent allocations.
+    /// I haven't benchmarked that though, so I don't actually know how much faster it would actually make it.
+    pub fn deinit(this: *@This(), allocator: std.mem.Allocator) void {
+        _ = this;
+        _ = allocator;
+    }
+
+    pub inline fn __toCssHelper(this: *const Property) struct { []const u8, VendorPrefix } {
+        return switch (this.*) {
+            .@"background-color" => .{ "background-color", VendorPrefix{ .none = true } },
+            .@"background-image" => .{ "background-image", VendorPrefix{ .none = true } },
+            .@"background-position-x" => .{ "background-position-x", VendorPrefix{ .none = true } },
+            .@"background-position-y" => .{ "background-position-y", VendorPrefix{ .none = true } },
+            .@"background-position" => .{ "background-position", VendorPrefix{ .none = true } },
+            .@"background-size" => .{ "background-size", VendorPrefix{ .none = true } },
+            .@"background-repeat" => .{ "background-repeat", VendorPrefix{ .none = true } },
+            .@"background-attachment" => .{ "background-attachment", VendorPrefix{ .none = true } },
+            .@"background-clip" => |*x| .{ "background-clip", x.@"1" },
+            .@"background-origin" => .{ "background-origin", VendorPrefix{ .none = true } },
+            .background => .{ "background", VendorPrefix{ .none = true } },
+            .@"box-shadow" => |*x| .{ "box-shadow", x.@"1" },
+            .opacity => .{ "opacity", VendorPrefix{ .none = true } },
+            .color => .{ "color", VendorPrefix{ .none = true } },
+            .display => .{ "display", VendorPrefix{ .none = true } },
+            .visibility => .{ "visibility", VendorPrefix{ .none = true } },
+            .width => .{ "width", VendorPrefix{ .none = true } },
+            .height => .{ "height", VendorPrefix{ .none = true } },
+            .@"min-width" => .{ "min-width", VendorPrefix{ .none = true } },
+            .@"min-height" => .{ "min-height", VendorPrefix{ .none = true } },
+            .@"max-width" => .{ "max-width", VendorPrefix{ .none = true } },
+            .@"max-height" => .{ "max-height", VendorPrefix{ .none = true } },
+            .@"block-size" => .{ "block-size", VendorPrefix{ .none = true } },
+            .@"inline-size" => .{ "inline-size", VendorPrefix{ .none = true } },
+            .@"min-block-size" => .{ "min-block-size", VendorPrefix{ .none = true } },
+            .@"min-inline-size" => .{ "min-inline-size", VendorPrefix{ .none = true } },
+            .@"max-block-size" => .{ "max-block-size", VendorPrefix{ .none = true } },
+            .@"max-inline-size" => .{ "max-inline-size", VendorPrefix{ .none = true } },
+            .@"box-sizing" => |*x| .{ "box-sizing", x.@"1" },
+            .@"aspect-ratio" => .{ "aspect-ratio", VendorPrefix{ .none = true } },
+            .overflow => .{ "overflow", VendorPrefix{ .none = true } },
+            .@"overflow-x" => .{ "overflow-x", VendorPrefix{ .none = true } },
+            .@"overflow-y" => .{ "overflow-y", VendorPrefix{ .none = true } },
+            .@"text-overflow" => |*x| .{ "text-overflow", x.@"1" },
+            .position => .{ "position", VendorPrefix{ .none = true } },
+            .top => .{ "top", VendorPrefix{ .none = true } },
+            .bottom => .{ "bottom", VendorPrefix{ .none = true } },
+            .left => .{ "left", VendorPrefix{ .none = true } },
+            .right => .{ "right", VendorPrefix{ .none = true } },
+            .@"inset-block-start" => .{ "inset-block-start", VendorPrefix{ .none = true } },
+            .@"inset-block-end" => .{ "inset-block-end", VendorPrefix{ .none = true } },
+            .@"inset-inline-start" => .{ "inset-inline-start", VendorPrefix{ .none = true } },
+            .@"inset-inline-end" => .{ "inset-inline-end", VendorPrefix{ .none = true } },
+            .@"inset-block" => .{ "inset-block", VendorPrefix{ .none = true } },
+            .@"inset-inline" => .{ "inset-inline", VendorPrefix{ .none = true } },
+            .inset => .{ "inset", VendorPrefix{ .none = true } },
+            .@"border-spacing" => .{ "border-spacing", VendorPrefix{ .none = true } },
+            .@"border-top-color" => .{ "border-top-color", VendorPrefix{ .none = true } },
+            .@"border-bottom-color" => .{ "border-bottom-color", VendorPrefix{ .none = true } },
+            .@"border-left-color" => .{ "border-left-color", VendorPrefix{ .none = true } },
+            .@"border-right-color" => .{ "border-right-color", VendorPrefix{ .none = true } },
+            .@"border-block-start-color" => .{ "border-block-start-color", VendorPrefix{ .none = true } },
+            .@"border-block-end-color" => .{ "border-block-end-color", VendorPrefix{ .none = true } },
+            .@"border-inline-start-color" => .{ "border-inline-start-color", VendorPrefix{ .none = true } },
+            .@"border-inline-end-color" => .{ "border-inline-end-color", VendorPrefix{ .none = true } },
+            .@"border-top-style" => .{ "border-top-style", VendorPrefix{ .none = true } },
+            .@"border-bottom-style" => .{ "border-bottom-style", VendorPrefix{ .none = true } },
+            .@"border-left-style" => .{ "border-left-style", VendorPrefix{ .none = true } },
+            .@"border-right-style" => .{ "border-right-style", VendorPrefix{ .none = true } },
+            .@"border-block-start-style" => .{ "border-block-start-style", VendorPrefix{ .none = true } },
+            .@"border-block-end-style" => .{ "border-block-end-style", VendorPrefix{ .none = true } },
+            .@"border-inline-start-style" => .{ "border-inline-start-style", VendorPrefix{ .none = true } },
+            .@"border-inline-end-style" => .{ "border-inline-end-style", VendorPrefix{ .none = true } },
+            .@"border-top-width" => .{ "border-top-width", VendorPrefix{ .none = true } },
+            .@"border-bottom-width" => .{ "border-bottom-width", VendorPrefix{ .none = true } },
+            .@"border-left-width" => .{ "border-left-width", VendorPrefix{ .none = true } },
+            .@"border-right-width" => .{ "border-right-width", VendorPrefix{ .none = true } },
+            .@"border-block-start-width" => .{ "border-block-start-width", VendorPrefix{ .none = true } },
+            .@"border-block-end-width" => .{ "border-block-end-width", VendorPrefix{ .none = true } },
+            .@"border-inline-start-width" => .{ "border-inline-start-width", VendorPrefix{ .none = true } },
+            .@"border-inline-end-width" => .{ "border-inline-end-width", VendorPrefix{ .none = true } },
+            .@"border-top-left-radius" => |*x| .{ "border-top-left-radius", x.@"1" },
+            .@"border-top-right-radius" => |*x| .{ "border-top-right-radius", x.@"1" },
+            .@"border-bottom-left-radius" => |*x| .{ "border-bottom-left-radius", x.@"1" },
+            .@"border-bottom-right-radius" => |*x| .{ "border-bottom-right-radius", x.@"1" },
+            .@"border-start-start-radius" => .{ "border-start-start-radius", VendorPrefix{ .none = true } },
+            .@"border-start-end-radius" => .{ "border-start-end-radius", VendorPrefix{ .none = true } },
+            .@"border-end-start-radius" => .{ "border-end-start-radius", VendorPrefix{ .none = true } },
+            .@"border-end-end-radius" => .{ "border-end-end-radius", VendorPrefix{ .none = true } },
+            .@"border-radius" => |*x| .{ "border-radius", x.@"1" },
+            .@"border-image-source" => .{ "border-image-source", VendorPrefix{ .none = true } },
+            .@"border-image-outset" => .{ "border-image-outset", VendorPrefix{ .none = true } },
+            .@"border-image-repeat" => .{ "border-image-repeat", VendorPrefix{ .none = true } },
+            .@"border-image-width" => .{ "border-image-width", VendorPrefix{ .none = true } },
+            .@"border-image-slice" => .{ "border-image-slice", VendorPrefix{ .none = true } },
+            .@"border-image" => |*x| .{ "border-image", x.@"1" },
+            .@"border-color" => .{ "border-color", VendorPrefix{ .none = true } },
+            .@"border-style" => .{ "border-style", VendorPrefix{ .none = true } },
+            .@"border-width" => .{ "border-width", VendorPrefix{ .none = true } },
+            .@"border-block-color" => .{ "border-block-color", VendorPrefix{ .none = true } },
+            .@"border-block-style" => .{ "border-block-style", VendorPrefix{ .none = true } },
+            .@"border-block-width" => .{ "border-block-width", VendorPrefix{ .none = true } },
+            .@"border-inline-color" => .{ "border-inline-color", VendorPrefix{ .none = true } },
+            .@"border-inline-style" => .{ "border-inline-style", VendorPrefix{ .none = true } },
+            .@"border-inline-width" => .{ "border-inline-width", VendorPrefix{ .none = true } },
+            .border => .{ "border", VendorPrefix{ .none = true } },
+            .@"border-top" => .{ "border-top", VendorPrefix{ .none = true } },
+            .@"border-bottom" => .{ "border-bottom", VendorPrefix{ .none = true } },
+            .@"border-left" => .{ "border-left", VendorPrefix{ .none = true } },
+            .@"border-right" => .{ "border-right", VendorPrefix{ .none = true } },
+            .@"border-block" => .{ "border-block", VendorPrefix{ .none = true } },
+            .@"border-block-start" => .{ "border-block-start", VendorPrefix{ .none = true } },
+            .@"border-block-end" => .{ "border-block-end", VendorPrefix{ .none = true } },
+            .@"border-inline" => .{ "border-inline", VendorPrefix{ .none = true } },
+            .@"border-inline-start" => .{ "border-inline-start", VendorPrefix{ .none = true } },
+            .@"border-inline-end" => .{ "border-inline-end", VendorPrefix{ .none = true } },
+            .outline => .{ "outline", VendorPrefix{ .none = true } },
+            .@"outline-color" => .{ "outline-color", VendorPrefix{ .none = true } },
+            .@"outline-style" => .{ "outline-style", VendorPrefix{ .none = true } },
+            .@"outline-width" => .{ "outline-width", VendorPrefix{ .none = true } },
+            .@"flex-direction" => |*x| .{ "flex-direction", x.@"1" },
+            .@"flex-wrap" => |*x| .{ "flex-wrap", x.@"1" },
+            .@"flex-flow" => |*x| .{ "flex-flow", x.@"1" },
+            .@"flex-grow" => |*x| .{ "flex-grow", x.@"1" },
+            .@"flex-shrink" => |*x| .{ "flex-shrink", x.@"1" },
+            .@"flex-basis" => |*x| .{ "flex-basis", x.@"1" },
+            .flex => |*x| .{ "flex", x.@"1" },
+            .order => |*x| .{ "order", x.@"1" },
+            .@"align-content" => |*x| .{ "align-content", x.@"1" },
+            .@"justify-content" => |*x| .{ "justify-content", x.@"1" },
+            .@"place-content" => .{ "place-content", VendorPrefix{ .none = true } },
+            .@"align-self" => |*x| .{ "align-self", x.@"1" },
+            .@"justify-self" => .{ "justify-self", VendorPrefix{ .none = true } },
+            .@"place-self" => .{ "place-self", VendorPrefix{ .none = true } },
+            .@"align-items" => |*x| .{ "align-items", x.@"1" },
+            .@"justify-items" => .{ "justify-items", VendorPrefix{ .none = true } },
+            .@"place-items" => .{ "place-items", VendorPrefix{ .none = true } },
+            .@"row-gap" => .{ "row-gap", VendorPrefix{ .none = true } },
+            .@"column-gap" => .{ "column-gap", VendorPrefix{ .none = true } },
+            .gap => .{ "gap", VendorPrefix{ .none = true } },
+            .@"box-orient" => |*x| .{ "box-orient", x.@"1" },
+            .@"box-direction" => |*x| .{ "box-direction", x.@"1" },
+            .@"box-ordinal-group" => |*x| .{ "box-ordinal-group", x.@"1" },
+            .@"box-align" => |*x| .{ "box-align", x.@"1" },
+            .@"box-flex" => |*x| .{ "box-flex", x.@"1" },
+            .@"box-flex-group" => |*x| .{ "box-flex-group", x.@"1" },
+            .@"box-pack" => |*x| .{ "box-pack", x.@"1" },
+            .@"box-lines" => |*x| .{ "box-lines", x.@"1" },
+            .@"flex-pack" => |*x| .{ "flex-pack", x.@"1" },
+            .@"flex-order" => |*x| .{ "flex-order", x.@"1" },
+            .@"flex-align" => |*x| .{ "flex-align", x.@"1" },
+            .@"flex-item-align" => |*x| .{ "flex-item-align", x.@"1" },
+            .@"flex-line-pack" => |*x| .{ "flex-line-pack", x.@"1" },
+            .@"flex-positive" => |*x| .{ "flex-positive", x.@"1" },
+            .@"flex-negative" => |*x| .{ "flex-negative", x.@"1" },
+            .@"flex-preferred-size" => |*x| .{ "flex-preferred-size", x.@"1" },
+            .@"margin-top" => .{ "margin-top", VendorPrefix{ .none = true } },
+            .@"margin-bottom" => .{ "margin-bottom", VendorPrefix{ .none = true } },
+            .@"margin-left" => .{ "margin-left", VendorPrefix{ .none = true } },
+            .@"margin-right" => .{ "margin-right", VendorPrefix{ .none = true } },
+            .@"margin-block-start" => .{ "margin-block-start", VendorPrefix{ .none = true } },
+            .@"margin-block-end" => .{ "margin-block-end", VendorPrefix{ .none = true } },
+            .@"margin-inline-start" => .{ "margin-inline-start", VendorPrefix{ .none = true } },
+            .@"margin-inline-end" => .{ "margin-inline-end", VendorPrefix{ .none = true } },
+            .@"margin-block" => .{ "margin-block", VendorPrefix{ .none = true } },
+            .@"margin-inline" => .{ "margin-inline", VendorPrefix{ .none = true } },
+            .margin => .{ "margin", VendorPrefix{ .none = true } },
+            .@"padding-top" => .{ "padding-top", VendorPrefix{ .none = true } },
+            .@"padding-bottom" => .{ "padding-bottom", VendorPrefix{ .none = true } },
+            .@"padding-left" => .{ "padding-left", VendorPrefix{ .none = true } },
+            .@"padding-right" => .{ "padding-right", VendorPrefix{ .none = true } },
+            .@"padding-block-start" => .{ "padding-block-start", VendorPrefix{ .none = true } },
+            .@"padding-block-end" => .{ "padding-block-end", VendorPrefix{ .none = true } },
+            .@"padding-inline-start" => .{ "padding-inline-start", VendorPrefix{ .none = true } },
+            .@"padding-inline-end" => .{ "padding-inline-end", VendorPrefix{ .none = true } },
+            .@"padding-block" => .{ "padding-block", VendorPrefix{ .none = true } },
+            .@"padding-inline" => .{ "padding-inline", VendorPrefix{ .none = true } },
+            .padding => .{ "padding", VendorPrefix{ .none = true } },
+            .@"scroll-margin-top" => .{ "scroll-margin-top", VendorPrefix{ .none = true } },
+            .@"scroll-margin-bottom" => .{ "scroll-margin-bottom", VendorPrefix{ .none = true } },
+            .@"scroll-margin-left" => .{ "scroll-margin-left", VendorPrefix{ .none = true } },
+            .@"scroll-margin-right" => .{ "scroll-margin-right", VendorPrefix{ .none = true } },
+            .@"scroll-margin-block-start" => .{ "scroll-margin-block-start", VendorPrefix{ .none = true } },
+            .@"scroll-margin-block-end" => .{ "scroll-margin-block-end", VendorPrefix{ .none = true } },
+            .@"scroll-margin-inline-start" => .{ "scroll-margin-inline-start", VendorPrefix{ .none = true } },
+            .@"scroll-margin-inline-end" => .{ "scroll-margin-inline-end", VendorPrefix{ .none = true } },
+            .@"scroll-margin-block" => .{ "scroll-margin-block", VendorPrefix{ .none = true } },
+            .@"scroll-margin-inline" => .{ "scroll-margin-inline", VendorPrefix{ .none = true } },
+            .@"scroll-margin" => .{ "scroll-margin", VendorPrefix{ .none = true } },
+            .@"scroll-padding-top" => .{ "scroll-padding-top", VendorPrefix{ .none = true } },
+            .@"scroll-padding-bottom" => .{ "scroll-padding-bottom", VendorPrefix{ .none = true } },
+            .@"scroll-padding-left" => .{ "scroll-padding-left", VendorPrefix{ .none = true } },
+            .@"scroll-padding-right" => .{ "scroll-padding-right", VendorPrefix{ .none = true } },
+            .@"scroll-padding-block-start" => .{ "scroll-padding-block-start", VendorPrefix{ .none = true } },
+            .@"scroll-padding-block-end" => .{ "scroll-padding-block-end", VendorPrefix{ .none = true } },
+            .@"scroll-padding-inline-start" => .{ "scroll-padding-inline-start", VendorPrefix{ .none = true } },
+            .@"scroll-padding-inline-end" => .{ "scroll-padding-inline-end", VendorPrefix{ .none = true } },
+            .@"scroll-padding-block" => .{ "scroll-padding-block", VendorPrefix{ .none = true } },
+            .@"scroll-padding-inline" => .{ "scroll-padding-inline", VendorPrefix{ .none = true } },
+            .@"scroll-padding" => .{ "scroll-padding", VendorPrefix{ .none = true } },
+            .@"font-weight" => .{ "font-weight", VendorPrefix{ .none = true } },
+            .@"font-size" => .{ "font-size", VendorPrefix{ .none = true } },
+            .@"font-stretch" => .{ "font-stretch", VendorPrefix{ .none = true } },
+            .@"font-family" => .{ "font-family", VendorPrefix{ .none = true } },
+            .@"font-style" => .{ "font-style", VendorPrefix{ .none = true } },
+            .@"font-variant-caps" => .{ "font-variant-caps", VendorPrefix{ .none = true } },
+            .@"line-height" => .{ "line-height", VendorPrefix{ .none = true } },
+            .font => .{ "font", VendorPrefix{ .none = true } },
+            .@"text-decoration-color" => |*x| .{ "text-decoration-color", x.@"1" },
+            .@"text-emphasis-color" => |*x| .{ "text-emphasis-color", x.@"1" },
+            .@"text-shadow" => .{ "text-shadow", VendorPrefix{ .none = true } },
+            .direction => .{ "direction", VendorPrefix{ .none = true } },
+            .composes => .{ "composes", VendorPrefix{ .none = true } },
+            .@"mask-image" => |*x| .{ "mask-image", x.@"1" },
+            .@"mask-mode" => .{ "mask-mode", VendorPrefix{ .none = true } },
+            .@"mask-repeat" => |*x| .{ "mask-repeat", x.@"1" },
+            .@"mask-position-x" => .{ "mask-position-x", VendorPrefix{ .none = true } },
+            .@"mask-position-y" => .{ "mask-position-y", VendorPrefix{ .none = true } },
+            .@"mask-position" => |*x| .{ "mask-position", x.@"1" },
+            .@"mask-clip" => |*x| .{ "mask-clip", x.@"1" },
+            .@"mask-origin" => |*x| .{ "mask-origin", x.@"1" },
+            .@"mask-size" => |*x| .{ "mask-size", x.@"1" },
+            .@"mask-composite" => .{ "mask-composite", VendorPrefix{ .none = true } },
+            .@"mask-type" => .{ "mask-type", VendorPrefix{ .none = true } },
+            .mask => |*x| .{ "mask", x.@"1" },
+            .@"mask-border-source" => .{ "mask-border-source", VendorPrefix{ .none = true } },
+            .@"mask-border-mode" => .{ "mask-border-mode", VendorPrefix{ .none = true } },
+            .@"mask-border-slice" => .{ "mask-border-slice", VendorPrefix{ .none = true } },
+            .@"mask-border-width" => .{ "mask-border-width", VendorPrefix{ .none = true } },
+            .@"mask-border-outset" => .{ "mask-border-outset", VendorPrefix{ .none = true } },
+            .@"mask-border-repeat" => .{ "mask-border-repeat", VendorPrefix{ .none = true } },
+            .@"mask-border" => .{ "mask-border", VendorPrefix{ .none = true } },
+            .@"-webkit-mask-composite" => .{ "-webkit-mask-composite", VendorPrefix{ .none = true } },
+            .@"mask-source-type" => |*x| .{ "mask-source-type", x.@"1" },
+            .@"mask-box-image" => |*x| .{ "mask-box-image", x.@"1" },
+            .@"mask-box-image-source" => |*x| .{ "mask-box-image-source", x.@"1" },
+            .@"mask-box-image-slice" => |*x| .{ "mask-box-image-slice", x.@"1" },
+            .@"mask-box-image-width" => |*x| .{ "mask-box-image-width", x.@"1" },
+            .@"mask-box-image-outset" => |*x| .{ "mask-box-image-outset", x.@"1" },
+            .@"mask-box-image-repeat" => |*x| .{ "mask-box-image-repeat", x.@"1" },
+            .all => .{ "all", VendorPrefix{ .none = true } },
+            .unparsed => |*unparsed| brk: {
+                var prefix = unparsed.property_id.prefix();
+                if (prefix.isEmpty()) {
+                    prefix = VendorPrefix{ .none = true };
+                }
+                break :brk .{ unparsed.property_id.name(), prefix };
+            },
+            .custom => unreachable,
+        };
+    }
+
+    /// Serializes the value of a CSS property without its name or `!important` flag.
+    pub fn valueToCss(this: *const Property, comptime W: type, dest: *css.Printer(W)) PrintErr!void {
+        return switch (this.*) {
+            .@"background-color" => |*value| value.toCss(W, dest),
+            .@"background-image" => |*value| value.toCss(W, dest),
+            .@"background-position-x" => |*value| value.toCss(W, dest),
+            .@"background-position-y" => |*value| value.toCss(W, dest),
+            .@"background-position" => |*value| value.toCss(W, dest),
+            .@"background-size" => |*value| value.toCss(W, dest),
+            .@"background-repeat" => |*value| value.toCss(W, dest),
+            .@"background-attachment" => |*value| value.toCss(W, dest),
+            .@"background-clip" => |*value| value[0].toCss(W, dest),
+            .@"background-origin" => |*value| value.toCss(W, dest),
+            .background => |*value| value.toCss(W, dest),
+            .@"box-shadow" => |*value| value[0].toCss(W, dest),
+            .opacity => |*value| value.toCss(W, dest),
+            .color => |*value| value.toCss(W, dest),
+            .display => |*value| value.toCss(W, dest),
+            .visibility => |*value| value.toCss(W, dest),
+            .width => |*value| value.toCss(W, dest),
+            .height => |*value| value.toCss(W, dest),
+            .@"min-width" => |*value| value.toCss(W, dest),
+            .@"min-height" => |*value| value.toCss(W, dest),
+            .@"max-width" => |*value| value.toCss(W, dest),
+            .@"max-height" => |*value| value.toCss(W, dest),
+            .@"block-size" => |*value| value.toCss(W, dest),
+            .@"inline-size" => |*value| value.toCss(W, dest),
+            .@"min-block-size" => |*value| value.toCss(W, dest),
+            .@"min-inline-size" => |*value| value.toCss(W, dest),
+            .@"max-block-size" => |*value| value.toCss(W, dest),
+            .@"max-inline-size" => |*value| value.toCss(W, dest),
+            .@"box-sizing" => |*value| value[0].toCss(W, dest),
+            .@"aspect-ratio" => |*value| value.toCss(W, dest),
+            .overflow => |*value| value.toCss(W, dest),
+            .@"overflow-x" => |*value| value.toCss(W, dest),
+            .@"overflow-y" => |*value| value.toCss(W, dest),
+            .@"text-overflow" => |*value| value[0].toCss(W, dest),
+            .position => |*value| value.toCss(W, dest),
+            .top => |*value| value.toCss(W, dest),
+            .bottom => |*value| value.toCss(W, dest),
+            .left => |*value| value.toCss(W, dest),
+            .right => |*value| value.toCss(W, dest),
+            .@"inset-block-start" => |*value| value.toCss(W, dest),
+            .@"inset-block-end" => |*value| value.toCss(W, dest),
+            .@"inset-inline-start" => |*value| value.toCss(W, dest),
+            .@"inset-inline-end" => |*value| value.toCss(W, dest),
+            .@"inset-block" => |*value| value.toCss(W, dest),
+            .@"inset-inline" => |*value| value.toCss(W, dest),
+            .inset => |*value| value.toCss(W, dest),
+            .@"border-spacing" => |*value| value.toCss(W, dest),
+            .@"border-top-color" => |*value| value.toCss(W, dest),
+            .@"border-bottom-color" => |*value| value.toCss(W, dest),
+            .@"border-left-color" => |*value| value.toCss(W, dest),
+            .@"border-right-color" => |*value| value.toCss(W, dest),
+            .@"border-block-start-color" => |*value| value.toCss(W, dest),
+            .@"border-block-end-color" => |*value| value.toCss(W, dest),
+            .@"border-inline-start-color" => |*value| value.toCss(W, dest),
+            .@"border-inline-end-color" => |*value| value.toCss(W, dest),
+            .@"border-top-style" => |*value| value.toCss(W, dest),
+            .@"border-bottom-style" => |*value| value.toCss(W, dest),
+            .@"border-left-style" => |*value| value.toCss(W, dest),
+            .@"border-right-style" => |*value| value.toCss(W, dest),
+            .@"border-block-start-style" => |*value| value.toCss(W, dest),
+            .@"border-block-end-style" => |*value| value.toCss(W, dest),
+            .@"border-inline-start-style" => |*value| value.toCss(W, dest),
+            .@"border-inline-end-style" => |*value| value.toCss(W, dest),
+            .@"border-top-width" => |*value| value.toCss(W, dest),
+            .@"border-bottom-width" => |*value| value.toCss(W, dest),
+            .@"border-left-width" => |*value| value.toCss(W, dest),
+            .@"border-right-width" => |*value| value.toCss(W, dest),
+            .@"border-block-start-width" => |*value| value.toCss(W, dest),
+            .@"border-block-end-width" => |*value| value.toCss(W, dest),
+            .@"border-inline-start-width" => |*value| value.toCss(W, dest),
+            .@"border-inline-end-width" => |*value| value.toCss(W, dest),
+            .@"border-top-left-radius" => |*value| value[0].toCss(W, dest),
+            .@"border-top-right-radius" => |*value| value[0].toCss(W, dest),
+            .@"border-bottom-left-radius" => |*value| value[0].toCss(W, dest),
+            .@"border-bottom-right-radius" => |*value| value[0].toCss(W, dest),
+            .@"border-start-start-radius" => |*value| value.toCss(W, dest),
+            .@"border-start-end-radius" => |*value| value.toCss(W, dest),
+            .@"border-end-start-radius" => |*value| value.toCss(W, dest),
+            .@"border-end-end-radius" => |*value| value.toCss(W, dest),
+            .@"border-radius" => |*value| value[0].toCss(W, dest),
+            .@"border-image-source" => |*value| value.toCss(W, dest),
+            .@"border-image-outset" => |*value| value.toCss(W, dest),
+            .@"border-image-repeat" => |*value| value.toCss(W, dest),
+            .@"border-image-width" => |*value| value.toCss(W, dest),
+            .@"border-image-slice" => |*value| value.toCss(W, dest),
+            .@"border-image" => |*value| value[0].toCss(W, dest),
+            .@"border-color" => |*value| value.toCss(W, dest),
+            .@"border-style" => |*value| value.toCss(W, dest),
+            .@"border-width" => |*value| value.toCss(W, dest),
+            .@"border-block-color" => |*value| value.toCss(W, dest),
+            .@"border-block-style" => |*value| value.toCss(W, dest),
+            .@"border-block-width" => |*value| value.toCss(W, dest),
+            .@"border-inline-color" => |*value| value.toCss(W, dest),
+            .@"border-inline-style" => |*value| value.toCss(W, dest),
+            .@"border-inline-width" => |*value| value.toCss(W, dest),
+            .border => |*value| value.toCss(W, dest),
+            .@"border-top" => |*value| value.toCss(W, dest),
+            .@"border-bottom" => |*value| value.toCss(W, dest),
+            .@"border-left" => |*value| value.toCss(W, dest),
+            .@"border-right" => |*value| value.toCss(W, dest),
+            .@"border-block" => |*value| value.toCss(W, dest),
+            .@"border-block-start" => |*value| value.toCss(W, dest),
+            .@"border-block-end" => |*value| value.toCss(W, dest),
+            .@"border-inline" => |*value| value.toCss(W, dest),
+            .@"border-inline-start" => |*value| value.toCss(W, dest),
+            .@"border-inline-end" => |*value| value.toCss(W, dest),
+            .outline => |*value| value.toCss(W, dest),
+            .@"outline-color" => |*value| value.toCss(W, dest),
+            .@"outline-style" => |*value| value.toCss(W, dest),
+            .@"outline-width" => |*value| value.toCss(W, dest),
+            .@"flex-direction" => |*value| value[0].toCss(W, dest),
+            .@"flex-wrap" => |*value| value[0].toCss(W, dest),
+            .@"flex-flow" => |*value| value[0].toCss(W, dest),
+            .@"flex-grow" => |*value| CSSNumberFns.toCss(&value[0], W, dest),
+            .@"flex-shrink" => |*value| CSSNumberFns.toCss(&value[0], W, dest),
+            .@"flex-basis" => |*value| value[0].toCss(W, dest),
+            .flex => |*value| value[0].toCss(W, dest),
+            .order => |*value| CSSIntegerFns.toCss(&value[0], W, dest),
+            .@"align-content" => |*value| value[0].toCss(W, dest),
+            .@"justify-content" => |*value| value[0].toCss(W, dest),
+            .@"place-content" => |*value| value.toCss(W, dest),
+            .@"align-self" => |*value| value[0].toCss(W, dest),
+            .@"justify-self" => |*value| value.toCss(W, dest),
+            .@"place-self" => |*value| value.toCss(W, dest),
+            .@"align-items" => |*value| value[0].toCss(W, dest),
+            .@"justify-items" => |*value| value.toCss(W, dest),
+            .@"place-items" => |*value| value.toCss(W, dest),
+            .@"row-gap" => |*value| value.toCss(W, dest),
+            .@"column-gap" => |*value| value.toCss(W, dest),
+            .gap => |*value| value.toCss(W, dest),
+            .@"box-orient" => |*value| value[0].toCss(W, dest),
+            .@"box-direction" => |*value| value[0].toCss(W, dest),
+            .@"box-ordinal-group" => |*value| CSSIntegerFns.toCss(&value[0], W, dest),
+            .@"box-align" => |*value| value[0].toCss(W, dest),
+            .@"box-flex" => |*value| CSSNumberFns.toCss(&value[0], W, dest),
+            .@"box-flex-group" => |*value| CSSIntegerFns.toCss(&value[0], W, dest),
+            .@"box-pack" => |*value| value[0].toCss(W, dest),
+            .@"box-lines" => |*value| value[0].toCss(W, dest),
+            .@"flex-pack" => |*value| value[0].toCss(W, dest),
+            .@"flex-order" => |*value| CSSIntegerFns.toCss(&value[0], W, dest),
+            .@"flex-align" => |*value| value[0].toCss(W, dest),
+            .@"flex-item-align" => |*value| value[0].toCss(W, dest),
+            .@"flex-line-pack" => |*value| value[0].toCss(W, dest),
+            .@"flex-positive" => |*value| CSSNumberFns.toCss(&value[0], W, dest),
+            .@"flex-negative" => |*value| CSSNumberFns.toCss(&value[0], W, dest),
+            .@"flex-preferred-size" => |*value| value[0].toCss(W, dest),
+            .@"margin-top" => |*value| value.toCss(W, dest),
+            .@"margin-bottom" => |*value| value.toCss(W, dest),
+            .@"margin-left" => |*value| value.toCss(W, dest),
+            .@"margin-right" => |*value| value.toCss(W, dest),
+            .@"margin-block-start" => |*value| value.toCss(W, dest),
+            .@"margin-block-end" => |*value| value.toCss(W, dest),
+            .@"margin-inline-start" => |*value| value.toCss(W, dest),
+            .@"margin-inline-end" => |*value| value.toCss(W, dest),
+            .@"margin-block" => |*value| value.toCss(W, dest),
+            .@"margin-inline" => |*value| value.toCss(W, dest),
+            .margin => |*value| value.toCss(W, dest),
+            .@"padding-top" => |*value| value.toCss(W, dest),
+            .@"padding-bottom" => |*value| value.toCss(W, dest),
+            .@"padding-left" => |*value| value.toCss(W, dest),
+            .@"padding-right" => |*value| value.toCss(W, dest),
+            .@"padding-block-start" => |*value| value.toCss(W, dest),
+            .@"padding-block-end" => |*value| value.toCss(W, dest),
+            .@"padding-inline-start" => |*value| value.toCss(W, dest),
+            .@"padding-inline-end" => |*value| value.toCss(W, dest),
+            .@"padding-block" => |*value| value.toCss(W, dest),
+            .@"padding-inline" => |*value| value.toCss(W, dest),
+            .padding => |*value| value.toCss(W, dest),
+            .@"scroll-margin-top" => |*value| value.toCss(W, dest),
+            .@"scroll-margin-bottom" => |*value| value.toCss(W, dest),
+            .@"scroll-margin-left" => |*value| value.toCss(W, dest),
+            .@"scroll-margin-right" => |*value| value.toCss(W, dest),
+            .@"scroll-margin-block-start" => |*value| value.toCss(W, dest),
+            .@"scroll-margin-block-end" => |*value| value.toCss(W, dest),
+            .@"scroll-margin-inline-start" => |*value| value.toCss(W, dest),
+            .@"scroll-margin-inline-end" => |*value| value.toCss(W, dest),
+            .@"scroll-margin-block" => |*value| value.toCss(W, dest),
+            .@"scroll-margin-inline" => |*value| value.toCss(W, dest),
+            .@"scroll-margin" => |*value| value.toCss(W, dest),
+            .@"scroll-padding-top" => |*value| value.toCss(W, dest),
+            .@"scroll-padding-bottom" => |*value| value.toCss(W, dest),
+            .@"scroll-padding-left" => |*value| value.toCss(W, dest),
+            .@"scroll-padding-right" => |*value| value.toCss(W, dest),
+            .@"scroll-padding-block-start" => |*value| value.toCss(W, dest),
+            .@"scroll-padding-block-end" => |*value| value.toCss(W, dest),
+            .@"scroll-padding-inline-start" => |*value| value.toCss(W, dest),
+            .@"scroll-padding-inline-end" => |*value| value.toCss(W, dest),
+            .@"scroll-padding-block" => |*value| value.toCss(W, dest),
+            .@"scroll-padding-inline" => |*value| value.toCss(W, dest),
+            .@"scroll-padding" => |*value| value.toCss(W, dest),
+            .@"font-weight" => |*value| value.toCss(W, dest),
+            .@"font-size" => |*value| value.toCss(W, dest),
+            .@"font-stretch" => |*value| value.toCss(W, dest),
+            .@"font-family" => |*value| value.toCss(W, dest),
+            .@"font-style" => |*value| value.toCss(W, dest),
+            .@"font-variant-caps" => |*value| value.toCss(W, dest),
+            .@"line-height" => |*value| value.toCss(W, dest),
+            .font => |*value| value.toCss(W, dest),
+            .@"text-decoration-color" => |*value| value[0].toCss(W, dest),
+            .@"text-emphasis-color" => |*value| value[0].toCss(W, dest),
+            .@"text-shadow" => |*value| value.toCss(W, dest),
+            .direction => |*value| value.toCss(W, dest),
+            .composes => |*value| value.toCss(W, dest),
+            .@"mask-image" => |*value| value[0].toCss(W, dest),
+            .@"mask-mode" => |*value| value.toCss(W, dest),
+            .@"mask-repeat" => |*value| value[0].toCss(W, dest),
+            .@"mask-position-x" => |*value| value.toCss(W, dest),
+            .@"mask-position-y" => |*value| value.toCss(W, dest),
+            .@"mask-position" => |*value| value[0].toCss(W, dest),
+            .@"mask-clip" => |*value| value[0].toCss(W, dest),
+            .@"mask-origin" => |*value| value[0].toCss(W, dest),
+            .@"mask-size" => |*value| value[0].toCss(W, dest),
+            .@"mask-composite" => |*value| value.toCss(W, dest),
+            .@"mask-type" => |*value| value.toCss(W, dest),
+            .mask => |*value| value[0].toCss(W, dest),
+            .@"mask-border-source" => |*value| value.toCss(W, dest),
+            .@"mask-border-mode" => |*value| value.toCss(W, dest),
+            .@"mask-border-slice" => |*value| value.toCss(W, dest),
+            .@"mask-border-width" => |*value| value.toCss(W, dest),
+            .@"mask-border-outset" => |*value| value.toCss(W, dest),
+            .@"mask-border-repeat" => |*value| value.toCss(W, dest),
+            .@"mask-border" => |*value| value.toCss(W, dest),
+            .@"-webkit-mask-composite" => |*value| value.toCss(W, dest),
+            .@"mask-source-type" => |*value| value[0].toCss(W, dest),
+            .@"mask-box-image" => |*value| value[0].toCss(W, dest),
+            .@"mask-box-image-source" => |*value| value[0].toCss(W, dest),
+            .@"mask-box-image-slice" => |*value| value[0].toCss(W, dest),
+            .@"mask-box-image-width" => |*value| value[0].toCss(W, dest),
+            .@"mask-box-image-outset" => |*value| value[0].toCss(W, dest),
+            .@"mask-box-image-repeat" => |*value| value[0].toCss(W, dest),
+            .all => |*keyword| keyword.toCss(W, dest),
+            .unparsed => |*unparsed| unparsed.value.toCss(W, dest, false),
+            .custom => |*c| c.value.toCss(W, dest, c.name == .custom),
+        };
+    }
+
+    /// Returns the given longhand property for a shorthand.
+    pub fn longhand(this: *const Property, property_id: *const PropertyId) ?Property {
+        switch (this.*) {
+            .@"background-position" => |*v| return v.longhand(property_id),
+            .overflow => |*v| return v.longhand(property_id),
+            .@"inset-block" => |*v| return v.longhand(property_id),
+            .@"inset-inline" => |*v| return v.longhand(property_id),
+            .inset => |*v| return v.longhand(property_id),
+            .@"border-radius" => |*v| {
+                if (!v[1].eq(property_id.prefix())) return null;
+                return v[0].longhand(property_id);
+            },
+            .@"border-image" => |*v| {
+                if (!v[1].eq(property_id.prefix())) return null;
+                return v[0].longhand(property_id);
+            },
+            .@"border-color" => |*v| return v.longhand(property_id),
+            .@"border-style" => |*v| return v.longhand(property_id),
+            .@"border-width" => |*v| return v.longhand(property_id),
+            .@"border-block-color" => |*v| return v.longhand(property_id),
+            .@"border-block-style" => |*v| return v.longhand(property_id),
+            .@"border-block-width" => |*v| return v.longhand(property_id),
+            .@"border-inline-color" => |*v| return v.longhand(property_id),
+            .@"border-inline-style" => |*v| return v.longhand(property_id),
+            .@"border-inline-width" => |*v| return v.longhand(property_id),
+            .border => |*v| return v.longhand(property_id),
+            .@"border-top" => |*v| return v.longhand(property_id),
+            .@"border-bottom" => |*v| return v.longhand(property_id),
+            .@"border-left" => |*v| return v.longhand(property_id),
+            .@"border-right" => |*v| return v.longhand(property_id),
+            .@"border-block" => |*v| return v.longhand(property_id),
+            .@"border-block-start" => |*v| return v.longhand(property_id),
+            .@"border-block-end" => |*v| return v.longhand(property_id),
+            .@"border-inline" => |*v| return v.longhand(property_id),
+            .@"border-inline-start" => |*v| return v.longhand(property_id),
+            .@"border-inline-end" => |*v| return v.longhand(property_id),
+            .outline => |*v| return v.longhand(property_id),
+            .@"flex-flow" => |*v| {
+                if (!v[1].eq(property_id.prefix())) return null;
+                return v[0].longhand(property_id);
+            },
+            .flex => |*v| {
+                if (!v[1].eq(property_id.prefix())) return null;
+                return v[0].longhand(property_id);
+            },
+            .@"place-content" => |*v| return v.longhand(property_id),
+            .@"place-self" => |*v| return v.longhand(property_id),
+            .@"place-items" => |*v| return v.longhand(property_id),
+            .gap => |*v| return v.longhand(property_id),
+            .@"margin-block" => |*v| return v.longhand(property_id),
+            .@"margin-inline" => |*v| return v.longhand(property_id),
+            .margin => |*v| return v.longhand(property_id),
+            .@"padding-block" => |*v| return v.longhand(property_id),
+            .@"padding-inline" => |*v| return v.longhand(property_id),
+            .padding => |*v| return v.longhand(property_id),
+            .@"scroll-margin-block" => |*v| return v.longhand(property_id),
+            .@"scroll-margin-inline" => |*v| return v.longhand(property_id),
+            .@"scroll-margin" => |*v| return v.longhand(property_id),
+            .@"scroll-padding-block" => |*v| return v.longhand(property_id),
+            .@"scroll-padding-inline" => |*v| return v.longhand(property_id),
+            .@"scroll-padding" => |*v| return v.longhand(property_id),
+            .font => |*v| return v.longhand(property_id),
+            .mask => |*v| {
+                if (!v[1].eq(property_id.prefix())) return null;
+                return v[0].longhand(property_id);
+            },
+            .@"mask-border" => |*v| return v.longhand(property_id),
+            else => {},
+        }
+        return null;
+    }
+
+    pub fn eql(lhs: *const Property, rhs: *const Property) bool {
+        if (@intFromEnum(lhs.*) != @intFromEnum(rhs.*)) return false;
+        return switch (lhs.*) {
+            .@"background-color" => |*v| css.generic.eql(CssColor, v, &rhs.@"background-color"),
+            .@"background-image" => |*v| css.generic.eql(SmallList(Image, 1), v, &rhs.@"background-image"),
+            .@"background-position-x" => |*v| css.generic.eql(SmallList(css_values.position.HorizontalPosition, 1), v, &rhs.@"background-position-x"),
+            .@"background-position-y" => |*v| css.generic.eql(SmallList(css_values.position.VerticalPosition, 1), v, &rhs.@"background-position-y"),
+            .@"background-position" => |*v| css.generic.eql(SmallList(background.BackgroundPosition, 1), v, &rhs.@"background-position"),
+            .@"background-size" => |*v| css.generic.eql(SmallList(background.BackgroundSize, 1), v, &rhs.@"background-size"),
+            .@"background-repeat" => |*v| css.generic.eql(SmallList(background.BackgroundRepeat, 1), v, &rhs.@"background-repeat"),
+            .@"background-attachment" => |*v| css.generic.eql(SmallList(background.BackgroundAttachment, 1), v, &rhs.@"background-attachment"),
+            .@"background-clip" => |*v| css.generic.eql(SmallList(background.BackgroundClip, 1), &v[0], &v[0]) and v[1].eq(rhs.@"background-clip"[1]),
+            .@"background-origin" => |*v| css.generic.eql(SmallList(background.BackgroundOrigin, 1), v, &rhs.@"background-origin"),
+            .background => |*v| css.generic.eql(SmallList(background.Background, 1), v, &rhs.background),
+            .@"box-shadow" => |*v| css.generic.eql(SmallList(box_shadow.BoxShadow, 1), &v[0], &v[0]) and v[1].eq(rhs.@"box-shadow"[1]),
+            .opacity => |*v| css.generic.eql(css.css_values.alpha.AlphaValue, v, &rhs.opacity),
+            .color => |*v| css.generic.eql(CssColor, v, &rhs.color),
+            .display => |*v| css.generic.eql(display.Display, v, &rhs.display),
+            .visibility => |*v| css.generic.eql(display.Visibility, v, &rhs.visibility),
+            .width => |*v| css.generic.eql(size.Size, v, &rhs.width),
+            .height => |*v| css.generic.eql(size.Size, v, &rhs.height),
+            .@"min-width" => |*v| css.generic.eql(size.Size, v, &rhs.@"min-width"),
+            .@"min-height" => |*v| css.generic.eql(size.Size, v, &rhs.@"min-height"),
+            .@"max-width" => |*v| css.generic.eql(size.MaxSize, v, &rhs.@"max-width"),
+            .@"max-height" => |*v| css.generic.eql(size.MaxSize, v, &rhs.@"max-height"),
+            .@"block-size" => |*v| css.generic.eql(size.Size, v, &rhs.@"block-size"),
+            .@"inline-size" => |*v| css.generic.eql(size.Size, v, &rhs.@"inline-size"),
+            .@"min-block-size" => |*v| css.generic.eql(size.Size, v, &rhs.@"min-block-size"),
+            .@"min-inline-size" => |*v| css.generic.eql(size.Size, v, &rhs.@"min-inline-size"),
+            .@"max-block-size" => |*v| css.generic.eql(size.MaxSize, v, &rhs.@"max-block-size"),
+            .@"max-inline-size" => |*v| css.generic.eql(size.MaxSize, v, &rhs.@"max-inline-size"),
+            .@"box-sizing" => |*v| css.generic.eql(size.BoxSizing, &v[0], &v[0]) and v[1].eq(rhs.@"box-sizing"[1]),
+            .@"aspect-ratio" => |*v| css.generic.eql(size.AspectRatio, v, &rhs.@"aspect-ratio"),
+            .overflow => |*v| css.generic.eql(overflow.Overflow, v, &rhs.overflow),
+            .@"overflow-x" => |*v| css.generic.eql(overflow.OverflowKeyword, v, &rhs.@"overflow-x"),
+            .@"overflow-y" => |*v| css.generic.eql(overflow.OverflowKeyword, v, &rhs.@"overflow-y"),
+            .@"text-overflow" => |*v| css.generic.eql(overflow.TextOverflow, &v[0], &v[0]) and v[1].eq(rhs.@"text-overflow"[1]),
+            .position => |*v| css.generic.eql(position.Position, v, &rhs.position),
+            .top => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.top),
+            .bottom => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.bottom),
+            .left => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.left),
+            .right => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.right),
+            .@"inset-block-start" => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.@"inset-block-start"),
+            .@"inset-block-end" => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.@"inset-block-end"),
+            .@"inset-inline-start" => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.@"inset-inline-start"),
+            .@"inset-inline-end" => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.@"inset-inline-end"),
+            .@"inset-block" => |*v| css.generic.eql(margin_padding.InsetBlock, v, &rhs.@"inset-block"),
+            .@"inset-inline" => |*v| css.generic.eql(margin_padding.InsetInline, v, &rhs.@"inset-inline"),
+            .inset => |*v| css.generic.eql(margin_padding.Inset, v, &rhs.inset),
+            .@"border-spacing" => |*v| css.generic.eql(css.css_values.size.Size2D(Length), v, &rhs.@"border-spacing"),
+            .@"border-top-color" => |*v| css.generic.eql(CssColor, v, &rhs.@"border-top-color"),
+            .@"border-bottom-color" => |*v| css.generic.eql(CssColor, v, &rhs.@"border-bottom-color"),
+            .@"border-left-color" => |*v| css.generic.eql(CssColor, v, &rhs.@"border-left-color"),
+            .@"border-right-color" => |*v| css.generic.eql(CssColor, v, &rhs.@"border-right-color"),
+            .@"border-block-start-color" => |*v| css.generic.eql(CssColor, v, &rhs.@"border-block-start-color"),
+            .@"border-block-end-color" => |*v| css.generic.eql(CssColor, v, &rhs.@"border-block-end-color"),
+            .@"border-inline-start-color" => |*v| css.generic.eql(CssColor, v, &rhs.@"border-inline-start-color"),
+            .@"border-inline-end-color" => |*v| css.generic.eql(CssColor, v, &rhs.@"border-inline-end-color"),
+            .@"border-top-style" => |*v| css.generic.eql(border.LineStyle, v, &rhs.@"border-top-style"),
+            .@"border-bottom-style" => |*v| css.generic.eql(border.LineStyle, v, &rhs.@"border-bottom-style"),
+            .@"border-left-style" => |*v| css.generic.eql(border.LineStyle, v, &rhs.@"border-left-style"),
+            .@"border-right-style" => |*v| css.generic.eql(border.LineStyle, v, &rhs.@"border-right-style"),
+            .@"border-block-start-style" => |*v| css.generic.eql(border.LineStyle, v, &rhs.@"border-block-start-style"),
+            .@"border-block-end-style" => |*v| css.generic.eql(border.LineStyle, v, &rhs.@"border-block-end-style"),
+            .@"border-inline-start-style" => |*v| css.generic.eql(border.LineStyle, v, &rhs.@"border-inline-start-style"),
+            .@"border-inline-end-style" => |*v| css.generic.eql(border.LineStyle, v, &rhs.@"border-inline-end-style"),
+            .@"border-top-width" => |*v| css.generic.eql(BorderSideWidth, v, &rhs.@"border-top-width"),
+            .@"border-bottom-width" => |*v| css.generic.eql(BorderSideWidth, v, &rhs.@"border-bottom-width"),
+            .@"border-left-width" => |*v| css.generic.eql(BorderSideWidth, v, &rhs.@"border-left-width"),
+            .@"border-right-width" => |*v| css.generic.eql(BorderSideWidth, v, &rhs.@"border-right-width"),
+            .@"border-block-start-width" => |*v| css.generic.eql(BorderSideWidth, v, &rhs.@"border-block-start-width"),
+            .@"border-block-end-width" => |*v| css.generic.eql(BorderSideWidth, v, &rhs.@"border-block-end-width"),
+            .@"border-inline-start-width" => |*v| css.generic.eql(BorderSideWidth, v, &rhs.@"border-inline-start-width"),
+            .@"border-inline-end-width" => |*v| css.generic.eql(BorderSideWidth, v, &rhs.@"border-inline-end-width"),
+            .@"border-top-left-radius" => |*v| css.generic.eql(Size2D(LengthPercentage), &v[0], &v[0]) and v[1].eq(rhs.@"border-top-left-radius"[1]),
+            .@"border-top-right-radius" => |*v| css.generic.eql(Size2D(LengthPercentage), &v[0], &v[0]) and v[1].eq(rhs.@"border-top-right-radius"[1]),
+            .@"border-bottom-left-radius" => |*v| css.generic.eql(Size2D(LengthPercentage), &v[0], &v[0]) and v[1].eq(rhs.@"border-bottom-left-radius"[1]),
+            .@"border-bottom-right-radius" => |*v| css.generic.eql(Size2D(LengthPercentage), &v[0], &v[0]) and v[1].eq(rhs.@"border-bottom-right-radius"[1]),
+            .@"border-start-start-radius" => |*v| css.generic.eql(Size2D(LengthPercentage), v, &rhs.@"border-start-start-radius"),
+            .@"border-start-end-radius" => |*v| css.generic.eql(Size2D(LengthPercentage), v, &rhs.@"border-start-end-radius"),
+            .@"border-end-start-radius" => |*v| css.generic.eql(Size2D(LengthPercentage), v, &rhs.@"border-end-start-radius"),
+            .@"border-end-end-radius" => |*v| css.generic.eql(Size2D(LengthPercentage), v, &rhs.@"border-end-end-radius"),
+            .@"border-radius" => |*v| css.generic.eql(BorderRadius, &v[0], &v[0]) and v[1].eq(rhs.@"border-radius"[1]),
+            .@"border-image-source" => |*v| css.generic.eql(Image, v, &rhs.@"border-image-source"),
+            .@"border-image-outset" => |*v| css.generic.eql(Rect(LengthOrNumber), v, &rhs.@"border-image-outset"),
+            .@"border-image-repeat" => |*v| css.generic.eql(BorderImageRepeat, v, &rhs.@"border-image-repeat"),
+            .@"border-image-width" => |*v| css.generic.eql(Rect(BorderImageSideWidth), v, &rhs.@"border-image-width"),
+            .@"border-image-slice" => |*v| css.generic.eql(BorderImageSlice, v, &rhs.@"border-image-slice"),
+            .@"border-image" => |*v| css.generic.eql(BorderImage, &v[0], &v[0]) and v[1].eq(rhs.@"border-image"[1]),
+            .@"border-color" => |*v| css.generic.eql(BorderColor, v, &rhs.@"border-color"),
+            .@"border-style" => |*v| css.generic.eql(BorderStyle, v, &rhs.@"border-style"),
+            .@"border-width" => |*v| css.generic.eql(BorderWidth, v, &rhs.@"border-width"),
+            .@"border-block-color" => |*v| css.generic.eql(BorderBlockColor, v, &rhs.@"border-block-color"),
+            .@"border-block-style" => |*v| css.generic.eql(BorderBlockStyle, v, &rhs.@"border-block-style"),
+            .@"border-block-width" => |*v| css.generic.eql(BorderBlockWidth, v, &rhs.@"border-block-width"),
+            .@"border-inline-color" => |*v| css.generic.eql(BorderInlineColor, v, &rhs.@"border-inline-color"),
+            .@"border-inline-style" => |*v| css.generic.eql(BorderInlineStyle, v, &rhs.@"border-inline-style"),
+            .@"border-inline-width" => |*v| css.generic.eql(BorderInlineWidth, v, &rhs.@"border-inline-width"),
+            .border => |*v| css.generic.eql(Border, v, &rhs.border),
+            .@"border-top" => |*v| css.generic.eql(BorderTop, v, &rhs.@"border-top"),
+            .@"border-bottom" => |*v| css.generic.eql(BorderBottom, v, &rhs.@"border-bottom"),
+            .@"border-left" => |*v| css.generic.eql(BorderLeft, v, &rhs.@"border-left"),
+            .@"border-right" => |*v| css.generic.eql(BorderRight, v, &rhs.@"border-right"),
+            .@"border-block" => |*v| css.generic.eql(BorderBlock, v, &rhs.@"border-block"),
+            .@"border-block-start" => |*v| css.generic.eql(BorderBlockStart, v, &rhs.@"border-block-start"),
+            .@"border-block-end" => |*v| css.generic.eql(BorderBlockEnd, v, &rhs.@"border-block-end"),
+            .@"border-inline" => |*v| css.generic.eql(BorderInline, v, &rhs.@"border-inline"),
+            .@"border-inline-start" => |*v| css.generic.eql(BorderInlineStart, v, &rhs.@"border-inline-start"),
+            .@"border-inline-end" => |*v| css.generic.eql(BorderInlineEnd, v, &rhs.@"border-inline-end"),
+            .outline => |*v| css.generic.eql(Outline, v, &rhs.outline),
+            .@"outline-color" => |*v| css.generic.eql(CssColor, v, &rhs.@"outline-color"),
+            .@"outline-style" => |*v| css.generic.eql(OutlineStyle, v, &rhs.@"outline-style"),
+            .@"outline-width" => |*v| css.generic.eql(BorderSideWidth, v, &rhs.@"outline-width"),
+            .@"flex-direction" => |*v| css.generic.eql(FlexDirection, &v[0], &v[0]) and v[1].eq(rhs.@"flex-direction"[1]),
+            .@"flex-wrap" => |*v| css.generic.eql(FlexWrap, &v[0], &v[0]) and v[1].eq(rhs.@"flex-wrap"[1]),
+            .@"flex-flow" => |*v| css.generic.eql(FlexFlow, &v[0], &v[0]) and v[1].eq(rhs.@"flex-flow"[1]),
+            .@"flex-grow" => |*v| css.generic.eql(CSSNumber, &v[0], &v[0]) and v[1].eq(rhs.@"flex-grow"[1]),
+            .@"flex-shrink" => |*v| css.generic.eql(CSSNumber, &v[0], &v[0]) and v[1].eq(rhs.@"flex-shrink"[1]),
+            .@"flex-basis" => |*v| css.generic.eql(LengthPercentageOrAuto, &v[0], &v[0]) and v[1].eq(rhs.@"flex-basis"[1]),
+            .flex => |*v| css.generic.eql(Flex, &v[0], &v[0]) and v[1].eq(rhs.flex[1]),
+            .order => |*v| css.generic.eql(CSSInteger, &v[0], &v[0]) and v[1].eq(rhs.order[1]),
+            .@"align-content" => |*v| css.generic.eql(AlignContent, &v[0], &v[0]) and v[1].eq(rhs.@"align-content"[1]),
+            .@"justify-content" => |*v| css.generic.eql(JustifyContent, &v[0], &v[0]) and v[1].eq(rhs.@"justify-content"[1]),
+            .@"place-content" => |*v| css.generic.eql(PlaceContent, v, &rhs.@"place-content"),
+            .@"align-self" => |*v| css.generic.eql(AlignSelf, &v[0], &v[0]) and v[1].eq(rhs.@"align-self"[1]),
+            .@"justify-self" => |*v| css.generic.eql(JustifySelf, v, &rhs.@"justify-self"),
+            .@"place-self" => |*v| css.generic.eql(PlaceSelf, v, &rhs.@"place-self"),
+            .@"align-items" => |*v| css.generic.eql(AlignItems, &v[0], &v[0]) and v[1].eq(rhs.@"align-items"[1]),
+            .@"justify-items" => |*v| css.generic.eql(JustifyItems, v, &rhs.@"justify-items"),
+            .@"place-items" => |*v| css.generic.eql(PlaceItems, v, &rhs.@"place-items"),
+            .@"row-gap" => |*v| css.generic.eql(GapValue, v, &rhs.@"row-gap"),
+            .@"column-gap" => |*v| css.generic.eql(GapValue, v, &rhs.@"column-gap"),
+            .gap => |*v| css.generic.eql(Gap, v, &rhs.gap),
+            .@"box-orient" => |*v| css.generic.eql(BoxOrient, &v[0], &v[0]) and v[1].eq(rhs.@"box-orient"[1]),
+            .@"box-direction" => |*v| css.generic.eql(BoxDirection, &v[0], &v[0]) and v[1].eq(rhs.@"box-direction"[1]),
+            .@"box-ordinal-group" => |*v| css.generic.eql(CSSInteger, &v[0], &v[0]) and v[1].eq(rhs.@"box-ordinal-group"[1]),
+            .@"box-align" => |*v| css.generic.eql(BoxAlign, &v[0], &v[0]) and v[1].eq(rhs.@"box-align"[1]),
+            .@"box-flex" => |*v| css.generic.eql(CSSNumber, &v[0], &v[0]) and v[1].eq(rhs.@"box-flex"[1]),
+            .@"box-flex-group" => |*v| css.generic.eql(CSSInteger, &v[0], &v[0]) and v[1].eq(rhs.@"box-flex-group"[1]),
+            .@"box-pack" => |*v| css.generic.eql(BoxPack, &v[0], &v[0]) and v[1].eq(rhs.@"box-pack"[1]),
+            .@"box-lines" => |*v| css.generic.eql(BoxLines, &v[0], &v[0]) and v[1].eq(rhs.@"box-lines"[1]),
+            .@"flex-pack" => |*v| css.generic.eql(FlexPack, &v[0], &v[0]) and v[1].eq(rhs.@"flex-pack"[1]),
+            .@"flex-order" => |*v| css.generic.eql(CSSInteger, &v[0], &v[0]) and v[1].eq(rhs.@"flex-order"[1]),
+            .@"flex-align" => |*v| css.generic.eql(BoxAlign, &v[0], &v[0]) and v[1].eq(rhs.@"flex-align"[1]),
+            .@"flex-item-align" => |*v| css.generic.eql(FlexItemAlign, &v[0], &v[0]) and v[1].eq(rhs.@"flex-item-align"[1]),
+            .@"flex-line-pack" => |*v| css.generic.eql(FlexLinePack, &v[0], &v[0]) and v[1].eq(rhs.@"flex-line-pack"[1]),
+            .@"flex-positive" => |*v| css.generic.eql(CSSNumber, &v[0], &v[0]) and v[1].eq(rhs.@"flex-positive"[1]),
+            .@"flex-negative" => |*v| css.generic.eql(CSSNumber, &v[0], &v[0]) and v[1].eq(rhs.@"flex-negative"[1]),
+            .@"flex-preferred-size" => |*v| css.generic.eql(LengthPercentageOrAuto, &v[0], &v[0]) and v[1].eq(rhs.@"flex-preferred-size"[1]),
+            .@"margin-top" => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.@"margin-top"),
+            .@"margin-bottom" => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.@"margin-bottom"),
+            .@"margin-left" => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.@"margin-left"),
+            .@"margin-right" => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.@"margin-right"),
+            .@"margin-block-start" => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.@"margin-block-start"),
+            .@"margin-block-end" => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.@"margin-block-end"),
+            .@"margin-inline-start" => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.@"margin-inline-start"),
+            .@"margin-inline-end" => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.@"margin-inline-end"),
+            .@"margin-block" => |*v| css.generic.eql(MarginBlock, v, &rhs.@"margin-block"),
+            .@"margin-inline" => |*v| css.generic.eql(MarginInline, v, &rhs.@"margin-inline"),
+            .margin => |*v| css.generic.eql(Margin, v, &rhs.margin),
+            .@"padding-top" => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.@"padding-top"),
+            .@"padding-bottom" => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.@"padding-bottom"),
+            .@"padding-left" => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.@"padding-left"),
+            .@"padding-right" => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.@"padding-right"),
+            .@"padding-block-start" => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.@"padding-block-start"),
+            .@"padding-block-end" => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.@"padding-block-end"),
+            .@"padding-inline-start" => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.@"padding-inline-start"),
+            .@"padding-inline-end" => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.@"padding-inline-end"),
+            .@"padding-block" => |*v| css.generic.eql(PaddingBlock, v, &rhs.@"padding-block"),
+            .@"padding-inline" => |*v| css.generic.eql(PaddingInline, v, &rhs.@"padding-inline"),
+            .padding => |*v| css.generic.eql(Padding, v, &rhs.padding),
+            .@"scroll-margin-top" => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.@"scroll-margin-top"),
+            .@"scroll-margin-bottom" => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.@"scroll-margin-bottom"),
+            .@"scroll-margin-left" => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.@"scroll-margin-left"),
+            .@"scroll-margin-right" => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.@"scroll-margin-right"),
+            .@"scroll-margin-block-start" => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.@"scroll-margin-block-start"),
+            .@"scroll-margin-block-end" => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.@"scroll-margin-block-end"),
+            .@"scroll-margin-inline-start" => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.@"scroll-margin-inline-start"),
+            .@"scroll-margin-inline-end" => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.@"scroll-margin-inline-end"),
+            .@"scroll-margin-block" => |*v| css.generic.eql(ScrollMarginBlock, v, &rhs.@"scroll-margin-block"),
+            .@"scroll-margin-inline" => |*v| css.generic.eql(ScrollMarginInline, v, &rhs.@"scroll-margin-inline"),
+            .@"scroll-margin" => |*v| css.generic.eql(ScrollMargin, v, &rhs.@"scroll-margin"),
+            .@"scroll-padding-top" => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.@"scroll-padding-top"),
+            .@"scroll-padding-bottom" => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.@"scroll-padding-bottom"),
+            .@"scroll-padding-left" => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.@"scroll-padding-left"),
+            .@"scroll-padding-right" => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.@"scroll-padding-right"),
+            .@"scroll-padding-block-start" => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.@"scroll-padding-block-start"),
+            .@"scroll-padding-block-end" => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.@"scroll-padding-block-end"),
+            .@"scroll-padding-inline-start" => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.@"scroll-padding-inline-start"),
+            .@"scroll-padding-inline-end" => |*v| css.generic.eql(LengthPercentageOrAuto, v, &rhs.@"scroll-padding-inline-end"),
+            .@"scroll-padding-block" => |*v| css.generic.eql(ScrollPaddingBlock, v, &rhs.@"scroll-padding-block"),
+            .@"scroll-padding-inline" => |*v| css.generic.eql(ScrollPaddingInline, v, &rhs.@"scroll-padding-inline"),
+            .@"scroll-padding" => |*v| css.generic.eql(ScrollPadding, v, &rhs.@"scroll-padding"),
+            .@"font-weight" => |*v| css.generic.eql(FontWeight, v, &rhs.@"font-weight"),
+            .@"font-size" => |*v| css.generic.eql(FontSize, v, &rhs.@"font-size"),
+            .@"font-stretch" => |*v| css.generic.eql(FontStretch, v, &rhs.@"font-stretch"),
+            .@"font-family" => |*v| css.generic.eql(BabyList(FontFamily), v, &rhs.@"font-family"),
+            .@"font-style" => |*v| css.generic.eql(FontStyle, v, &rhs.@"font-style"),
+            .@"font-variant-caps" => |*v| css.generic.eql(FontVariantCaps, v, &rhs.@"font-variant-caps"),
+            .@"line-height" => |*v| css.generic.eql(LineHeight, v, &rhs.@"line-height"),
+            .font => |*v| css.generic.eql(Font, v, &rhs.font),
+            .@"text-decoration-color" => |*v| css.generic.eql(CssColor, &v[0], &v[0]) and v[1].eq(rhs.@"text-decoration-color"[1]),
+            .@"text-emphasis-color" => |*v| css.generic.eql(CssColor, &v[0], &v[0]) and v[1].eq(rhs.@"text-emphasis-color"[1]),
+            .@"text-shadow" => |*v| css.generic.eql(SmallList(TextShadow, 1), v, &rhs.@"text-shadow"),
+            .direction => |*v| css.generic.eql(Direction, v, &rhs.direction),
+            .composes => |*v| css.generic.eql(Composes, v, &rhs.composes),
+            .@"mask-image" => |*v| css.generic.eql(SmallList(Image, 1), &v[0], &v[0]) and v[1].eq(rhs.@"mask-image"[1]),
+            .@"mask-mode" => |*v| css.generic.eql(SmallList(MaskMode, 1), v, &rhs.@"mask-mode"),
+            .@"mask-repeat" => |*v| css.generic.eql(SmallList(BackgroundRepeat, 1), &v[0], &v[0]) and v[1].eq(rhs.@"mask-repeat"[1]),
+            .@"mask-position-x" => |*v| css.generic.eql(SmallList(HorizontalPosition, 1), v, &rhs.@"mask-position-x"),
+            .@"mask-position-y" => |*v| css.generic.eql(SmallList(VerticalPosition, 1), v, &rhs.@"mask-position-y"),
+            .@"mask-position" => |*v| css.generic.eql(SmallList(Position, 1), &v[0], &v[0]) and v[1].eq(rhs.@"mask-position"[1]),
+            .@"mask-clip" => |*v| css.generic.eql(SmallList(MaskClip, 1), &v[0], &v[0]) and v[1].eq(rhs.@"mask-clip"[1]),
+            .@"mask-origin" => |*v| css.generic.eql(SmallList(GeometryBox, 1), &v[0], &v[0]) and v[1].eq(rhs.@"mask-origin"[1]),
+            .@"mask-size" => |*v| css.generic.eql(SmallList(BackgroundSize, 1), &v[0], &v[0]) and v[1].eq(rhs.@"mask-size"[1]),
+            .@"mask-composite" => |*v| css.generic.eql(SmallList(MaskComposite, 1), v, &rhs.@"mask-composite"),
+            .@"mask-type" => |*v| css.generic.eql(MaskType, v, &rhs.@"mask-type"),
+            .mask => |*v| css.generic.eql(SmallList(Mask, 1), &v[0], &v[0]) and v[1].eq(rhs.mask[1]),
+            .@"mask-border-source" => |*v| css.generic.eql(Image, v, &rhs.@"mask-border-source"),
+            .@"mask-border-mode" => |*v| css.generic.eql(MaskBorderMode, v, &rhs.@"mask-border-mode"),
+            .@"mask-border-slice" => |*v| css.generic.eql(BorderImageSlice, v, &rhs.@"mask-border-slice"),
+            .@"mask-border-width" => |*v| css.generic.eql(Rect(BorderImageSideWidth), v, &rhs.@"mask-border-width"),
+            .@"mask-border-outset" => |*v| css.generic.eql(Rect(LengthOrNumber), v, &rhs.@"mask-border-outset"),
+            .@"mask-border-repeat" => |*v| css.generic.eql(BorderImageRepeat, v, &rhs.@"mask-border-repeat"),
+            .@"mask-border" => |*v| css.generic.eql(MaskBorder, v, &rhs.@"mask-border"),
+            .@"-webkit-mask-composite" => |*v| css.generic.eql(SmallList(WebKitMaskComposite, 1), v, &rhs.@"-webkit-mask-composite"),
+            .@"mask-source-type" => |*v| css.generic.eql(SmallList(WebKitMaskSourceType, 1), &v[0], &v[0]) and v[1].eq(rhs.@"mask-source-type"[1]),
+            .@"mask-box-image" => |*v| css.generic.eql(BorderImage, &v[0], &v[0]) and v[1].eq(rhs.@"mask-box-image"[1]),
+            .@"mask-box-image-source" => |*v| css.generic.eql(Image, &v[0], &v[0]) and v[1].eq(rhs.@"mask-box-image-source"[1]),
+            .@"mask-box-image-slice" => |*v| css.generic.eql(BorderImageSlice, &v[0], &v[0]) and v[1].eq(rhs.@"mask-box-image-slice"[1]),
+            .@"mask-box-image-width" => |*v| css.generic.eql(Rect(BorderImageSideWidth), &v[0], &v[0]) and v[1].eq(rhs.@"mask-box-image-width"[1]),
+            .@"mask-box-image-outset" => |*v| css.generic.eql(Rect(LengthOrNumber), &v[0], &v[0]) and v[1].eq(rhs.@"mask-box-image-outset"[1]),
+            .@"mask-box-image-repeat" => |*v| css.generic.eql(BorderImageRepeat, &v[0], &v[0]) and v[1].eq(rhs.@"mask-box-image-repeat"[1]),
+            .all, .unparsed => true,
+            .custom => |*c| c.eql(&rhs.custom),
+        };
+    }
+};
+pub const PropertyId = union(PropertyIdTag) {
+    @"background-color",
+    @"background-image",
+    @"background-position-x",
+    @"background-position-y",
+    @"background-position",
+    @"background-size",
+    @"background-repeat",
+    @"background-attachment",
+    @"background-clip": VendorPrefix,
+    @"background-origin",
+    background,
+    @"box-shadow": VendorPrefix,
+    opacity,
+    color,
+    display,
+    visibility,
+    width,
+    height,
+    @"min-width",
+    @"min-height",
+    @"max-width",
+    @"max-height",
+    @"block-size",
+    @"inline-size",
+    @"min-block-size",
+    @"min-inline-size",
+    @"max-block-size",
+    @"max-inline-size",
+    @"box-sizing": VendorPrefix,
+    @"aspect-ratio",
+    overflow,
+    @"overflow-x",
+    @"overflow-y",
+    @"text-overflow": VendorPrefix,
+    position,
+    top,
+    bottom,
+    left,
+    right,
+    @"inset-block-start",
+    @"inset-block-end",
+    @"inset-inline-start",
+    @"inset-inline-end",
+    @"inset-block",
+    @"inset-inline",
+    inset,
+    @"border-spacing",
+    @"border-top-color",
+    @"border-bottom-color",
+    @"border-left-color",
+    @"border-right-color",
+    @"border-block-start-color",
+    @"border-block-end-color",
+    @"border-inline-start-color",
+    @"border-inline-end-color",
+    @"border-top-style",
+    @"border-bottom-style",
+    @"border-left-style",
+    @"border-right-style",
+    @"border-block-start-style",
+    @"border-block-end-style",
+    @"border-inline-start-style",
+    @"border-inline-end-style",
+    @"border-top-width",
+    @"border-bottom-width",
+    @"border-left-width",
+    @"border-right-width",
+    @"border-block-start-width",
+    @"border-block-end-width",
+    @"border-inline-start-width",
+    @"border-inline-end-width",
+    @"border-top-left-radius": VendorPrefix,
+    @"border-top-right-radius": VendorPrefix,
+    @"border-bottom-left-radius": VendorPrefix,
+    @"border-bottom-right-radius": VendorPrefix,
+    @"border-start-start-radius",
+    @"border-start-end-radius",
+    @"border-end-start-radius",
+    @"border-end-end-radius",
+    @"border-radius": VendorPrefix,
+    @"border-image-source",
+    @"border-image-outset",
+    @"border-image-repeat",
+    @"border-image-width",
+    @"border-image-slice",
+    @"border-image": VendorPrefix,
+    @"border-color",
+    @"border-style",
+    @"border-width",
+    @"border-block-color",
+    @"border-block-style",
+    @"border-block-width",
+    @"border-inline-color",
+    @"border-inline-style",
+    @"border-inline-width",
+    border,
+    @"border-top",
+    @"border-bottom",
+    @"border-left",
+    @"border-right",
+    @"border-block",
+    @"border-block-start",
+    @"border-block-end",
+    @"border-inline",
+    @"border-inline-start",
+    @"border-inline-end",
+    outline,
+    @"outline-color",
+    @"outline-style",
+    @"outline-width",
+    @"flex-direction": VendorPrefix,
+    @"flex-wrap": VendorPrefix,
+    @"flex-flow": VendorPrefix,
+    @"flex-grow": VendorPrefix,
+    @"flex-shrink": VendorPrefix,
+    @"flex-basis": VendorPrefix,
+    flex: VendorPrefix,
+    order: VendorPrefix,
+    @"align-content": VendorPrefix,
+    @"justify-content": VendorPrefix,
+    @"place-content",
+    @"align-self": VendorPrefix,
+    @"justify-self",
+    @"place-self",
+    @"align-items": VendorPrefix,
+    @"justify-items",
+    @"place-items",
+    @"row-gap",
+    @"column-gap",
+    gap,
+    @"box-orient": VendorPrefix,
+    @"box-direction": VendorPrefix,
+    @"box-ordinal-group": VendorPrefix,
+    @"box-align": VendorPrefix,
+    @"box-flex": VendorPrefix,
+    @"box-flex-group": VendorPrefix,
+    @"box-pack": VendorPrefix,
+    @"box-lines": VendorPrefix,
+    @"flex-pack": VendorPrefix,
+    @"flex-order": VendorPrefix,
+    @"flex-align": VendorPrefix,
+    @"flex-item-align": VendorPrefix,
+    @"flex-line-pack": VendorPrefix,
+    @"flex-positive": VendorPrefix,
+    @"flex-negative": VendorPrefix,
+    @"flex-preferred-size": VendorPrefix,
+    @"margin-top",
+    @"margin-bottom",
+    @"margin-left",
+    @"margin-right",
+    @"margin-block-start",
+    @"margin-block-end",
+    @"margin-inline-start",
+    @"margin-inline-end",
+    @"margin-block",
+    @"margin-inline",
+    margin,
+    @"padding-top",
+    @"padding-bottom",
+    @"padding-left",
+    @"padding-right",
+    @"padding-block-start",
+    @"padding-block-end",
+    @"padding-inline-start",
+    @"padding-inline-end",
+    @"padding-block",
+    @"padding-inline",
+    padding,
+    @"scroll-margin-top",
+    @"scroll-margin-bottom",
+    @"scroll-margin-left",
+    @"scroll-margin-right",
+    @"scroll-margin-block-start",
+    @"scroll-margin-block-end",
+    @"scroll-margin-inline-start",
+    @"scroll-margin-inline-end",
+    @"scroll-margin-block",
+    @"scroll-margin-inline",
+    @"scroll-margin",
+    @"scroll-padding-top",
+    @"scroll-padding-bottom",
+    @"scroll-padding-left",
+    @"scroll-padding-right",
+    @"scroll-padding-block-start",
+    @"scroll-padding-block-end",
+    @"scroll-padding-inline-start",
+    @"scroll-padding-inline-end",
+    @"scroll-padding-block",
+    @"scroll-padding-inline",
+    @"scroll-padding",
+    @"font-weight",
+    @"font-size",
+    @"font-stretch",
+    @"font-family",
+    @"font-style",
+    @"font-variant-caps",
+    @"line-height",
+    font,
+    @"text-decoration-color": VendorPrefix,
+    @"text-emphasis-color": VendorPrefix,
+    @"text-shadow",
+    direction,
+    composes,
+    @"mask-image": VendorPrefix,
+    @"mask-mode",
+    @"mask-repeat": VendorPrefix,
+    @"mask-position-x",
+    @"mask-position-y",
+    @"mask-position": VendorPrefix,
+    @"mask-clip": VendorPrefix,
+    @"mask-origin": VendorPrefix,
+    @"mask-size": VendorPrefix,
+    @"mask-composite",
+    @"mask-type",
+    mask: VendorPrefix,
+    @"mask-border-source",
+    @"mask-border-mode",
+    @"mask-border-slice",
+    @"mask-border-width",
+    @"mask-border-outset",
+    @"mask-border-repeat",
+    @"mask-border",
+    @"-webkit-mask-composite",
+    @"mask-source-type": VendorPrefix,
+    @"mask-box-image": VendorPrefix,
+    @"mask-box-image-source": VendorPrefix,
+    @"mask-box-image-slice": VendorPrefix,
+    @"mask-box-image-width": VendorPrefix,
+    @"mask-box-image-outset": VendorPrefix,
+    @"mask-box-image-repeat": VendorPrefix,
+    all,
+    unparsed,
+    custom: CustomPropertyName,
+
+    pub usingnamespace PropertyIdImpl();
+
+    /// Returns the property name, without any vendor prefixes.
+    pub inline fn name(this: *const PropertyId) []const u8 {
+        return @tagName(this.*);
+    }
+
+    /// Returns the vendor prefix for this property id.
+    pub fn prefix(this: *const PropertyId) VendorPrefix {
+        return switch (this.*) {
+            .@"background-color" => VendorPrefix.empty(),
+            .@"background-image" => VendorPrefix.empty(),
+            .@"background-position-x" => VendorPrefix.empty(),
+            .@"background-position-y" => VendorPrefix.empty(),
+            .@"background-position" => VendorPrefix.empty(),
+            .@"background-size" => VendorPrefix.empty(),
+            .@"background-repeat" => VendorPrefix.empty(),
+            .@"background-attachment" => VendorPrefix.empty(),
+            .@"background-clip" => |p| p,
+            .@"background-origin" => VendorPrefix.empty(),
+            .background => VendorPrefix.empty(),
+            .@"box-shadow" => |p| p,
+            .opacity => VendorPrefix.empty(),
+            .color => VendorPrefix.empty(),
+            .display => VendorPrefix.empty(),
+            .visibility => VendorPrefix.empty(),
+            .width => VendorPrefix.empty(),
+            .height => VendorPrefix.empty(),
+            .@"min-width" => VendorPrefix.empty(),
+            .@"min-height" => VendorPrefix.empty(),
+            .@"max-width" => VendorPrefix.empty(),
+            .@"max-height" => VendorPrefix.empty(),
+            .@"block-size" => VendorPrefix.empty(),
+            .@"inline-size" => VendorPrefix.empty(),
+            .@"min-block-size" => VendorPrefix.empty(),
+            .@"min-inline-size" => VendorPrefix.empty(),
+            .@"max-block-size" => VendorPrefix.empty(),
+            .@"max-inline-size" => VendorPrefix.empty(),
+            .@"box-sizing" => |p| p,
+            .@"aspect-ratio" => VendorPrefix.empty(),
+            .overflow => VendorPrefix.empty(),
+            .@"overflow-x" => VendorPrefix.empty(),
+            .@"overflow-y" => VendorPrefix.empty(),
+            .@"text-overflow" => |p| p,
+            .position => VendorPrefix.empty(),
+            .top => VendorPrefix.empty(),
+            .bottom => VendorPrefix.empty(),
+            .left => VendorPrefix.empty(),
+            .right => VendorPrefix.empty(),
+            .@"inset-block-start" => VendorPrefix.empty(),
+            .@"inset-block-end" => VendorPrefix.empty(),
+            .@"inset-inline-start" => VendorPrefix.empty(),
+            .@"inset-inline-end" => VendorPrefix.empty(),
+            .@"inset-block" => VendorPrefix.empty(),
+            .@"inset-inline" => VendorPrefix.empty(),
+            .inset => VendorPrefix.empty(),
+            .@"border-spacing" => VendorPrefix.empty(),
+            .@"border-top-color" => VendorPrefix.empty(),
+            .@"border-bottom-color" => VendorPrefix.empty(),
+            .@"border-left-color" => VendorPrefix.empty(),
+            .@"border-right-color" => VendorPrefix.empty(),
+            .@"border-block-start-color" => VendorPrefix.empty(),
+            .@"border-block-end-color" => VendorPrefix.empty(),
+            .@"border-inline-start-color" => VendorPrefix.empty(),
+            .@"border-inline-end-color" => VendorPrefix.empty(),
+            .@"border-top-style" => VendorPrefix.empty(),
+            .@"border-bottom-style" => VendorPrefix.empty(),
+            .@"border-left-style" => VendorPrefix.empty(),
+            .@"border-right-style" => VendorPrefix.empty(),
+            .@"border-block-start-style" => VendorPrefix.empty(),
+            .@"border-block-end-style" => VendorPrefix.empty(),
+            .@"border-inline-start-style" => VendorPrefix.empty(),
+            .@"border-inline-end-style" => VendorPrefix.empty(),
+            .@"border-top-width" => VendorPrefix.empty(),
+            .@"border-bottom-width" => VendorPrefix.empty(),
+            .@"border-left-width" => VendorPrefix.empty(),
+            .@"border-right-width" => VendorPrefix.empty(),
+            .@"border-block-start-width" => VendorPrefix.empty(),
+            .@"border-block-end-width" => VendorPrefix.empty(),
+            .@"border-inline-start-width" => VendorPrefix.empty(),
+            .@"border-inline-end-width" => VendorPrefix.empty(),
+            .@"border-top-left-radius" => |p| p,
+            .@"border-top-right-radius" => |p| p,
+            .@"border-bottom-left-radius" => |p| p,
+            .@"border-bottom-right-radius" => |p| p,
+            .@"border-start-start-radius" => VendorPrefix.empty(),
+            .@"border-start-end-radius" => VendorPrefix.empty(),
+            .@"border-end-start-radius" => VendorPrefix.empty(),
+            .@"border-end-end-radius" => VendorPrefix.empty(),
+            .@"border-radius" => |p| p,
+            .@"border-image-source" => VendorPrefix.empty(),
+            .@"border-image-outset" => VendorPrefix.empty(),
+            .@"border-image-repeat" => VendorPrefix.empty(),
+            .@"border-image-width" => VendorPrefix.empty(),
+            .@"border-image-slice" => VendorPrefix.empty(),
+            .@"border-image" => |p| p,
+            .@"border-color" => VendorPrefix.empty(),
+            .@"border-style" => VendorPrefix.empty(),
+            .@"border-width" => VendorPrefix.empty(),
+            .@"border-block-color" => VendorPrefix.empty(),
+            .@"border-block-style" => VendorPrefix.empty(),
+            .@"border-block-width" => VendorPrefix.empty(),
+            .@"border-inline-color" => VendorPrefix.empty(),
+            .@"border-inline-style" => VendorPrefix.empty(),
+            .@"border-inline-width" => VendorPrefix.empty(),
+            .border => VendorPrefix.empty(),
+            .@"border-top" => VendorPrefix.empty(),
+            .@"border-bottom" => VendorPrefix.empty(),
+            .@"border-left" => VendorPrefix.empty(),
+            .@"border-right" => VendorPrefix.empty(),
+            .@"border-block" => VendorPrefix.empty(),
+            .@"border-block-start" => VendorPrefix.empty(),
+            .@"border-block-end" => VendorPrefix.empty(),
+            .@"border-inline" => VendorPrefix.empty(),
+            .@"border-inline-start" => VendorPrefix.empty(),
+            .@"border-inline-end" => VendorPrefix.empty(),
+            .outline => VendorPrefix.empty(),
+            .@"outline-color" => VendorPrefix.empty(),
+            .@"outline-style" => VendorPrefix.empty(),
+            .@"outline-width" => VendorPrefix.empty(),
+            .@"flex-direction" => |p| p,
+            .@"flex-wrap" => |p| p,
+            .@"flex-flow" => |p| p,
+            .@"flex-grow" => |p| p,
+            .@"flex-shrink" => |p| p,
+            .@"flex-basis" => |p| p,
+            .flex => |p| p,
+            .order => |p| p,
+            .@"align-content" => |p| p,
+            .@"justify-content" => |p| p,
+            .@"place-content" => VendorPrefix.empty(),
+            .@"align-self" => |p| p,
+            .@"justify-self" => VendorPrefix.empty(),
+            .@"place-self" => VendorPrefix.empty(),
+            .@"align-items" => |p| p,
+            .@"justify-items" => VendorPrefix.empty(),
+            .@"place-items" => VendorPrefix.empty(),
+            .@"row-gap" => VendorPrefix.empty(),
+            .@"column-gap" => VendorPrefix.empty(),
+            .gap => VendorPrefix.empty(),
+            .@"box-orient" => |p| p,
+            .@"box-direction" => |p| p,
+            .@"box-ordinal-group" => |p| p,
+            .@"box-align" => |p| p,
+            .@"box-flex" => |p| p,
+            .@"box-flex-group" => |p| p,
+            .@"box-pack" => |p| p,
+            .@"box-lines" => |p| p,
+            .@"flex-pack" => |p| p,
+            .@"flex-order" => |p| p,
+            .@"flex-align" => |p| p,
+            .@"flex-item-align" => |p| p,
+            .@"flex-line-pack" => |p| p,
+            .@"flex-positive" => |p| p,
+            .@"flex-negative" => |p| p,
+            .@"flex-preferred-size" => |p| p,
+            .@"margin-top" => VendorPrefix.empty(),
+            .@"margin-bottom" => VendorPrefix.empty(),
+            .@"margin-left" => VendorPrefix.empty(),
+            .@"margin-right" => VendorPrefix.empty(),
+            .@"margin-block-start" => VendorPrefix.empty(),
+            .@"margin-block-end" => VendorPrefix.empty(),
+            .@"margin-inline-start" => VendorPrefix.empty(),
+            .@"margin-inline-end" => VendorPrefix.empty(),
+            .@"margin-block" => VendorPrefix.empty(),
+            .@"margin-inline" => VendorPrefix.empty(),
+            .margin => VendorPrefix.empty(),
+            .@"padding-top" => VendorPrefix.empty(),
+            .@"padding-bottom" => VendorPrefix.empty(),
+            .@"padding-left" => VendorPrefix.empty(),
+            .@"padding-right" => VendorPrefix.empty(),
+            .@"padding-block-start" => VendorPrefix.empty(),
+            .@"padding-block-end" => VendorPrefix.empty(),
+            .@"padding-inline-start" => VendorPrefix.empty(),
+            .@"padding-inline-end" => VendorPrefix.empty(),
+            .@"padding-block" => VendorPrefix.empty(),
+            .@"padding-inline" => VendorPrefix.empty(),
+            .padding => VendorPrefix.empty(),
+            .@"scroll-margin-top" => VendorPrefix.empty(),
+            .@"scroll-margin-bottom" => VendorPrefix.empty(),
+            .@"scroll-margin-left" => VendorPrefix.empty(),
+            .@"scroll-margin-right" => VendorPrefix.empty(),
+            .@"scroll-margin-block-start" => VendorPrefix.empty(),
+            .@"scroll-margin-block-end" => VendorPrefix.empty(),
+            .@"scroll-margin-inline-start" => VendorPrefix.empty(),
+            .@"scroll-margin-inline-end" => VendorPrefix.empty(),
+            .@"scroll-margin-block" => VendorPrefix.empty(),
+            .@"scroll-margin-inline" => VendorPrefix.empty(),
+            .@"scroll-margin" => VendorPrefix.empty(),
+            .@"scroll-padding-top" => VendorPrefix.empty(),
+            .@"scroll-padding-bottom" => VendorPrefix.empty(),
+            .@"scroll-padding-left" => VendorPrefix.empty(),
+            .@"scroll-padding-right" => VendorPrefix.empty(),
+            .@"scroll-padding-block-start" => VendorPrefix.empty(),
+            .@"scroll-padding-block-end" => VendorPrefix.empty(),
+            .@"scroll-padding-inline-start" => VendorPrefix.empty(),
+            .@"scroll-padding-inline-end" => VendorPrefix.empty(),
+            .@"scroll-padding-block" => VendorPrefix.empty(),
+            .@"scroll-padding-inline" => VendorPrefix.empty(),
+            .@"scroll-padding" => VendorPrefix.empty(),
+            .@"font-weight" => VendorPrefix.empty(),
+            .@"font-size" => VendorPrefix.empty(),
+            .@"font-stretch" => VendorPrefix.empty(),
+            .@"font-family" => VendorPrefix.empty(),
+            .@"font-style" => VendorPrefix.empty(),
+            .@"font-variant-caps" => VendorPrefix.empty(),
+            .@"line-height" => VendorPrefix.empty(),
+            .font => VendorPrefix.empty(),
+            .@"text-decoration-color" => |p| p,
+            .@"text-emphasis-color" => |p| p,
+            .@"text-shadow" => VendorPrefix.empty(),
+            .direction => VendorPrefix.empty(),
+            .composes => VendorPrefix.empty(),
+            .@"mask-image" => |p| p,
+            .@"mask-mode" => VendorPrefix.empty(),
+            .@"mask-repeat" => |p| p,
+            .@"mask-position-x" => VendorPrefix.empty(),
+            .@"mask-position-y" => VendorPrefix.empty(),
+            .@"mask-position" => |p| p,
+            .@"mask-clip" => |p| p,
+            .@"mask-origin" => |p| p,
+            .@"mask-size" => |p| p,
+            .@"mask-composite" => VendorPrefix.empty(),
+            .@"mask-type" => VendorPrefix.empty(),
+            .mask => |p| p,
+            .@"mask-border-source" => VendorPrefix.empty(),
+            .@"mask-border-mode" => VendorPrefix.empty(),
+            .@"mask-border-slice" => VendorPrefix.empty(),
+            .@"mask-border-width" => VendorPrefix.empty(),
+            .@"mask-border-outset" => VendorPrefix.empty(),
+            .@"mask-border-repeat" => VendorPrefix.empty(),
+            .@"mask-border" => VendorPrefix.empty(),
+            .@"-webkit-mask-composite" => VendorPrefix.empty(),
+            .@"mask-source-type" => |p| p,
+            .@"mask-box-image" => |p| p,
+            .@"mask-box-image-source" => |p| p,
+            .@"mask-box-image-slice" => |p| p,
+            .@"mask-box-image-width" => |p| p,
+            .@"mask-box-image-outset" => |p| p,
+            .@"mask-box-image-repeat" => |p| p,
+            .all, .custom, .unparsed => VendorPrefix.empty(),
+        };
+    }
+
+    pub fn fromNameAndPrefix(name1: []const u8, pre: VendorPrefix) ?PropertyId {
+        const Enum = enum { @"background-color", @"background-image", @"background-position-x", @"background-position-y", @"background-position", @"background-size", @"background-repeat", @"background-attachment", @"background-clip", @"background-origin", background, @"box-shadow", opacity, color, display, visibility, width, height, @"min-width", @"min-height", @"max-width", @"max-height", @"block-size", @"inline-size", @"min-block-size", @"min-inline-size", @"max-block-size", @"max-inline-size", @"box-sizing", @"aspect-ratio", overflow, @"overflow-x", @"overflow-y", @"text-overflow", position, top, bottom, left, right, @"inset-block-start", @"inset-block-end", @"inset-inline-start", @"inset-inline-end", @"inset-block", @"inset-inline", inset, @"border-spacing", @"border-top-color", @"border-bottom-color", @"border-left-color", @"border-right-color", @"border-block-start-color", @"border-block-end-color", @"border-inline-start-color", @"border-inline-end-color", @"border-top-style", @"border-bottom-style", @"border-left-style", @"border-right-style", @"border-block-start-style", @"border-block-end-style", @"border-inline-start-style", @"border-inline-end-style", @"border-top-width", @"border-bottom-width", @"border-left-width", @"border-right-width", @"border-block-start-width", @"border-block-end-width", @"border-inline-start-width", @"border-inline-end-width", @"border-top-left-radius", @"border-top-right-radius", @"border-bottom-left-radius", @"border-bottom-right-radius", @"border-start-start-radius", @"border-start-end-radius", @"border-end-start-radius", @"border-end-end-radius", @"border-radius", @"border-image-source", @"border-image-outset", @"border-image-repeat", @"border-image-width", @"border-image-slice", @"border-image", @"border-color", @"border-style", @"border-width", @"border-block-color", @"border-block-style", @"border-block-width", @"border-inline-color", @"border-inline-style", @"border-inline-width", border, @"border-top", @"border-bottom", @"border-left", @"border-right", @"border-block", @"border-block-start", @"border-block-end", @"border-inline", @"border-inline-start", @"border-inline-end", outline, @"outline-color", @"outline-style", @"outline-width", @"flex-direction", @"flex-wrap", @"flex-flow", @"flex-grow", @"flex-shrink", @"flex-basis", flex, order, @"align-content", @"justify-content", @"place-content", @"align-self", @"justify-self", @"place-self", @"align-items", @"justify-items", @"place-items", @"row-gap", @"column-gap", gap, @"box-orient", @"box-direction", @"box-ordinal-group", @"box-align", @"box-flex", @"box-flex-group", @"box-pack", @"box-lines", @"flex-pack", @"flex-order", @"flex-align", @"flex-item-align", @"flex-line-pack", @"flex-positive", @"flex-negative", @"flex-preferred-size", @"margin-top", @"margin-bottom", @"margin-left", @"margin-right", @"margin-block-start", @"margin-block-end", @"margin-inline-start", @"margin-inline-end", @"margin-block", @"margin-inline", margin, @"padding-top", @"padding-bottom", @"padding-left", @"padding-right", @"padding-block-start", @"padding-block-end", @"padding-inline-start", @"padding-inline-end", @"padding-block", @"padding-inline", padding, @"scroll-margin-top", @"scroll-margin-bottom", @"scroll-margin-left", @"scroll-margin-right", @"scroll-margin-block-start", @"scroll-margin-block-end", @"scroll-margin-inline-start", @"scroll-margin-inline-end", @"scroll-margin-block", @"scroll-margin-inline", @"scroll-margin", @"scroll-padding-top", @"scroll-padding-bottom", @"scroll-padding-left", @"scroll-padding-right", @"scroll-padding-block-start", @"scroll-padding-block-end", @"scroll-padding-inline-start", @"scroll-padding-inline-end", @"scroll-padding-block", @"scroll-padding-inline", @"scroll-padding", @"font-weight", @"font-size", @"font-stretch", @"font-family", @"font-style", @"font-variant-caps", @"line-height", font, @"text-decoration-color", @"text-emphasis-color", @"text-shadow", direction, composes, @"mask-image", @"mask-mode", @"mask-repeat", @"mask-position-x", @"mask-position-y", @"mask-position", @"mask-clip", @"mask-origin", @"mask-size", @"mask-composite", @"mask-type", mask, @"mask-border-source", @"mask-border-mode", @"mask-border-slice", @"mask-border-width", @"mask-border-outset", @"mask-border-repeat", @"mask-border", @"-webkit-mask-composite", @"mask-source-type", @"mask-box-image", @"mask-box-image-source", @"mask-box-image-slice", @"mask-box-image-width", @"mask-box-image-outset", @"mask-box-image-repeat" };
+        const Map = comptime bun.ComptimeEnumMap(Enum);
+        if (Map.getASCIIICaseInsensitive(name1)) |prop| {
+            switch (prop) {
+                .@"background-color" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"background-color";
+                },
+                .@"background-image" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"background-image";
+                },
+                .@"background-position-x" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"background-position-x";
+                },
+                .@"background-position-y" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"background-position-y";
+                },
+                .@"background-position" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"background-position";
+                },
+                .@"background-size" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"background-size";
+                },
+                .@"background-repeat" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"background-repeat";
+                },
+                .@"background-attachment" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"background-attachment";
+                },
+                .@"background-clip" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true, .moz = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"background-clip" = pre };
+                },
+                .@"background-origin" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"background-origin";
+                },
+                .background => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .background;
+                },
+                .@"box-shadow" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true, .moz = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"box-shadow" = pre };
+                },
+                .opacity => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .opacity;
+                },
+                .color => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .color;
+                },
+                .display => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .display;
+                },
+                .visibility => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .visibility;
+                },
+                .width => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .width;
+                },
+                .height => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .height;
+                },
+                .@"min-width" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"min-width";
+                },
+                .@"min-height" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"min-height";
+                },
+                .@"max-width" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"max-width";
+                },
+                .@"max-height" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"max-height";
+                },
+                .@"block-size" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"block-size";
+                },
+                .@"inline-size" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"inline-size";
+                },
+                .@"min-block-size" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"min-block-size";
+                },
+                .@"min-inline-size" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"min-inline-size";
+                },
+                .@"max-block-size" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"max-block-size";
+                },
+                .@"max-inline-size" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"max-inline-size";
+                },
+                .@"box-sizing" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true, .moz = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"box-sizing" = pre };
+                },
+                .@"aspect-ratio" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"aspect-ratio";
+                },
+                .overflow => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .overflow;
+                },
+                .@"overflow-x" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"overflow-x";
+                },
+                .@"overflow-y" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"overflow-y";
+                },
+                .@"text-overflow" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .o = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"text-overflow" = pre };
+                },
+                .position => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .position;
+                },
+                .top => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .top;
+                },
+                .bottom => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .bottom;
+                },
+                .left => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .left;
+                },
+                .right => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .right;
+                },
+                .@"inset-block-start" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"inset-block-start";
+                },
+                .@"inset-block-end" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"inset-block-end";
+                },
+                .@"inset-inline-start" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"inset-inline-start";
+                },
+                .@"inset-inline-end" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"inset-inline-end";
+                },
+                .@"inset-block" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"inset-block";
+                },
+                .@"inset-inline" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"inset-inline";
+                },
+                .inset => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .inset;
+                },
+                .@"border-spacing" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-spacing";
+                },
+                .@"border-top-color" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-top-color";
+                },
+                .@"border-bottom-color" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-bottom-color";
+                },
+                .@"border-left-color" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-left-color";
+                },
+                .@"border-right-color" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-right-color";
+                },
+                .@"border-block-start-color" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-block-start-color";
+                },
+                .@"border-block-end-color" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-block-end-color";
+                },
+                .@"border-inline-start-color" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-inline-start-color";
+                },
+                .@"border-inline-end-color" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-inline-end-color";
+                },
+                .@"border-top-style" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-top-style";
+                },
+                .@"border-bottom-style" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-bottom-style";
+                },
+                .@"border-left-style" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-left-style";
+                },
+                .@"border-right-style" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-right-style";
+                },
+                .@"border-block-start-style" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-block-start-style";
+                },
+                .@"border-block-end-style" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-block-end-style";
+                },
+                .@"border-inline-start-style" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-inline-start-style";
+                },
+                .@"border-inline-end-style" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-inline-end-style";
+                },
+                .@"border-top-width" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-top-width";
+                },
+                .@"border-bottom-width" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-bottom-width";
+                },
+                .@"border-left-width" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-left-width";
+                },
+                .@"border-right-width" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-right-width";
+                },
+                .@"border-block-start-width" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-block-start-width";
+                },
+                .@"border-block-end-width" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-block-end-width";
+                },
+                .@"border-inline-start-width" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-inline-start-width";
+                },
+                .@"border-inline-end-width" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-inline-end-width";
+                },
+                .@"border-top-left-radius" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true, .moz = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"border-top-left-radius" = pre };
+                },
+                .@"border-top-right-radius" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true, .moz = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"border-top-right-radius" = pre };
+                },
+                .@"border-bottom-left-radius" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true, .moz = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"border-bottom-left-radius" = pre };
+                },
+                .@"border-bottom-right-radius" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true, .moz = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"border-bottom-right-radius" = pre };
+                },
+                .@"border-start-start-radius" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-start-start-radius";
+                },
+                .@"border-start-end-radius" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-start-end-radius";
+                },
+                .@"border-end-start-radius" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-end-start-radius";
+                },
+                .@"border-end-end-radius" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-end-end-radius";
+                },
+                .@"border-radius" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true, .moz = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"border-radius" = pre };
+                },
+                .@"border-image-source" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-image-source";
+                },
+                .@"border-image-outset" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-image-outset";
+                },
+                .@"border-image-repeat" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-image-repeat";
+                },
+                .@"border-image-width" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-image-width";
+                },
+                .@"border-image-slice" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-image-slice";
+                },
+                .@"border-image" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true, .moz = true, .o = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"border-image" = pre };
+                },
+                .@"border-color" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-color";
+                },
+                .@"border-style" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-style";
+                },
+                .@"border-width" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-width";
+                },
+                .@"border-block-color" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-block-color";
+                },
+                .@"border-block-style" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-block-style";
+                },
+                .@"border-block-width" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-block-width";
+                },
+                .@"border-inline-color" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-inline-color";
+                },
+                .@"border-inline-style" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-inline-style";
+                },
+                .@"border-inline-width" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-inline-width";
+                },
+                .border => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .border;
+                },
+                .@"border-top" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-top";
+                },
+                .@"border-bottom" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-bottom";
+                },
+                .@"border-left" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-left";
+                },
+                .@"border-right" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-right";
+                },
+                .@"border-block" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-block";
+                },
+                .@"border-block-start" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-block-start";
+                },
+                .@"border-block-end" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-block-end";
+                },
+                .@"border-inline" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-inline";
+                },
+                .@"border-inline-start" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-inline-start";
+                },
+                .@"border-inline-end" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"border-inline-end";
+                },
+                .outline => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .outline;
+                },
+                .@"outline-color" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"outline-color";
+                },
+                .@"outline-style" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"outline-style";
+                },
+                .@"outline-width" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"outline-width";
+                },
+                .@"flex-direction" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true, .ms = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"flex-direction" = pre };
+                },
+                .@"flex-wrap" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true, .ms = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"flex-wrap" = pre };
+                },
+                .@"flex-flow" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true, .ms = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"flex-flow" = pre };
+                },
+                .@"flex-grow" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"flex-grow" = pre };
+                },
+                .@"flex-shrink" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"flex-shrink" = pre };
+                },
+                .@"flex-basis" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"flex-basis" = pre };
+                },
+                .flex => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true, .ms = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .flex = pre };
+                },
+                .order => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .order = pre };
+                },
+                .@"align-content" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"align-content" = pre };
+                },
+                .@"justify-content" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"justify-content" = pre };
+                },
+                .@"place-content" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"place-content";
+                },
+                .@"align-self" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"align-self" = pre };
+                },
+                .@"justify-self" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"justify-self";
+                },
+                .@"place-self" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"place-self";
+                },
+                .@"align-items" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"align-items" = pre };
+                },
+                .@"justify-items" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"justify-items";
+                },
+                .@"place-items" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"place-items";
+                },
+                .@"row-gap" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"row-gap";
+                },
+                .@"column-gap" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"column-gap";
+                },
+                .gap => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .gap;
+                },
+                .@"box-orient" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true, .moz = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"box-orient" = pre };
+                },
+                .@"box-direction" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true, .moz = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"box-direction" = pre };
+                },
+                .@"box-ordinal-group" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true, .moz = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"box-ordinal-group" = pre };
+                },
+                .@"box-align" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true, .moz = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"box-align" = pre };
+                },
+                .@"box-flex" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true, .moz = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"box-flex" = pre };
+                },
+                .@"box-flex-group" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"box-flex-group" = pre };
+                },
+                .@"box-pack" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true, .moz = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"box-pack" = pre };
+                },
+                .@"box-lines" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true, .moz = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"box-lines" = pre };
+                },
+                .@"flex-pack" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .ms = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"flex-pack" = pre };
+                },
+                .@"flex-order" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .ms = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"flex-order" = pre };
+                },
+                .@"flex-align" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .ms = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"flex-align" = pre };
+                },
+                .@"flex-item-align" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .ms = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"flex-item-align" = pre };
+                },
+                .@"flex-line-pack" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .ms = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"flex-line-pack" = pre };
+                },
+                .@"flex-positive" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .ms = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"flex-positive" = pre };
+                },
+                .@"flex-negative" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .ms = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"flex-negative" = pre };
+                },
+                .@"flex-preferred-size" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .ms = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"flex-preferred-size" = pre };
+                },
+                .@"margin-top" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"margin-top";
+                },
+                .@"margin-bottom" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"margin-bottom";
+                },
+                .@"margin-left" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"margin-left";
+                },
+                .@"margin-right" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"margin-right";
+                },
+                .@"margin-block-start" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"margin-block-start";
+                },
+                .@"margin-block-end" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"margin-block-end";
+                },
+                .@"margin-inline-start" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"margin-inline-start";
+                },
+                .@"margin-inline-end" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"margin-inline-end";
+                },
+                .@"margin-block" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"margin-block";
+                },
+                .@"margin-inline" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"margin-inline";
+                },
+                .margin => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .margin;
+                },
+                .@"padding-top" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"padding-top";
+                },
+                .@"padding-bottom" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"padding-bottom";
+                },
+                .@"padding-left" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"padding-left";
+                },
+                .@"padding-right" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"padding-right";
+                },
+                .@"padding-block-start" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"padding-block-start";
+                },
+                .@"padding-block-end" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"padding-block-end";
+                },
+                .@"padding-inline-start" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"padding-inline-start";
+                },
+                .@"padding-inline-end" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"padding-inline-end";
+                },
+                .@"padding-block" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"padding-block";
+                },
+                .@"padding-inline" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"padding-inline";
+                },
+                .padding => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .padding;
+                },
+                .@"scroll-margin-top" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"scroll-margin-top";
+                },
+                .@"scroll-margin-bottom" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"scroll-margin-bottom";
+                },
+                .@"scroll-margin-left" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"scroll-margin-left";
+                },
+                .@"scroll-margin-right" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"scroll-margin-right";
+                },
+                .@"scroll-margin-block-start" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"scroll-margin-block-start";
+                },
+                .@"scroll-margin-block-end" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"scroll-margin-block-end";
+                },
+                .@"scroll-margin-inline-start" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"scroll-margin-inline-start";
+                },
+                .@"scroll-margin-inline-end" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"scroll-margin-inline-end";
+                },
+                .@"scroll-margin-block" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"scroll-margin-block";
+                },
+                .@"scroll-margin-inline" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"scroll-margin-inline";
+                },
+                .@"scroll-margin" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"scroll-margin";
+                },
+                .@"scroll-padding-top" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"scroll-padding-top";
+                },
+                .@"scroll-padding-bottom" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"scroll-padding-bottom";
+                },
+                .@"scroll-padding-left" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"scroll-padding-left";
+                },
+                .@"scroll-padding-right" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"scroll-padding-right";
+                },
+                .@"scroll-padding-block-start" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"scroll-padding-block-start";
+                },
+                .@"scroll-padding-block-end" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"scroll-padding-block-end";
+                },
+                .@"scroll-padding-inline-start" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"scroll-padding-inline-start";
+                },
+                .@"scroll-padding-inline-end" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"scroll-padding-inline-end";
+                },
+                .@"scroll-padding-block" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"scroll-padding-block";
+                },
+                .@"scroll-padding-inline" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"scroll-padding-inline";
+                },
+                .@"scroll-padding" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"scroll-padding";
+                },
+                .@"font-weight" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"font-weight";
+                },
+                .@"font-size" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"font-size";
+                },
+                .@"font-stretch" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"font-stretch";
+                },
+                .@"font-family" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"font-family";
+                },
+                .@"font-style" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"font-style";
+                },
+                .@"font-variant-caps" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"font-variant-caps";
+                },
+                .@"line-height" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"line-height";
+                },
+                .font => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .font;
+                },
+                .@"text-decoration-color" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true, .moz = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"text-decoration-color" = pre };
+                },
+                .@"text-emphasis-color" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"text-emphasis-color" = pre };
+                },
+                .@"text-shadow" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"text-shadow";
+                },
+                .direction => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .direction;
+                },
+                .composes => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .composes;
+                },
+                .@"mask-image" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"mask-image" = pre };
+                },
+                .@"mask-mode" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"mask-mode";
+                },
+                .@"mask-repeat" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"mask-repeat" = pre };
+                },
+                .@"mask-position-x" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"mask-position-x";
+                },
+                .@"mask-position-y" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"mask-position-y";
+                },
+                .@"mask-position" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"mask-position" = pre };
+                },
+                .@"mask-clip" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"mask-clip" = pre };
+                },
+                .@"mask-origin" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"mask-origin" = pre };
+                },
+                .@"mask-size" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"mask-size" = pre };
+                },
+                .@"mask-composite" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"mask-composite";
+                },
+                .@"mask-type" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"mask-type";
+                },
+                .mask => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .mask = pre };
+                },
+                .@"mask-border-source" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"mask-border-source";
+                },
+                .@"mask-border-mode" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"mask-border-mode";
+                },
+                .@"mask-border-slice" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"mask-border-slice";
+                },
+                .@"mask-border-width" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"mask-border-width";
+                },
+                .@"mask-border-outset" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"mask-border-outset";
+                },
+                .@"mask-border-repeat" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"mask-border-repeat";
+                },
+                .@"mask-border" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"mask-border";
+                },
+                .@"-webkit-mask-composite" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true };
+                    if (allowed_prefixes.contains(pre)) return .@"-webkit-mask-composite";
+                },
+                .@"mask-source-type" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"mask-source-type" = pre };
+                },
+                .@"mask-box-image" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"mask-box-image" = pre };
+                },
+                .@"mask-box-image-source" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"mask-box-image-source" = pre };
+                },
+                .@"mask-box-image-slice" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"mask-box-image-slice" = pre };
+                },
+                .@"mask-box-image-width" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"mask-box-image-width" = pre };
+                },
+                .@"mask-box-image-outset" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"mask-box-image-outset" = pre };
+                },
+                .@"mask-box-image-repeat" => {
+                    const allowed_prefixes = VendorPrefix{ .none = true, .webkit = true };
+                    if (allowed_prefixes.contains(pre)) return .{ .@"mask-box-image-repeat" = pre };
+                },
+            }
+        }
+
+        return null;
+    }
+
+    pub fn withPrefix(this: *const PropertyId, pre: VendorPrefix) PropertyId {
+        return switch (this.*) {
+            .@"background-color" => .@"background-color",
+            .@"background-image" => .@"background-image",
+            .@"background-position-x" => .@"background-position-x",
+            .@"background-position-y" => .@"background-position-y",
+            .@"background-position" => .@"background-position",
+            .@"background-size" => .@"background-size",
+            .@"background-repeat" => .@"background-repeat",
+            .@"background-attachment" => .@"background-attachment",
+            .@"background-clip" => .{ .@"background-clip" = pre },
+            .@"background-origin" => .@"background-origin",
+            .background => .background,
+            .@"box-shadow" => .{ .@"box-shadow" = pre },
+            .opacity => .opacity,
+            .color => .color,
+            .display => .display,
+            .visibility => .visibility,
+            .width => .width,
+            .height => .height,
+            .@"min-width" => .@"min-width",
+            .@"min-height" => .@"min-height",
+            .@"max-width" => .@"max-width",
+            .@"max-height" => .@"max-height",
+            .@"block-size" => .@"block-size",
+            .@"inline-size" => .@"inline-size",
+            .@"min-block-size" => .@"min-block-size",
+            .@"min-inline-size" => .@"min-inline-size",
+            .@"max-block-size" => .@"max-block-size",
+            .@"max-inline-size" => .@"max-inline-size",
+            .@"box-sizing" => .{ .@"box-sizing" = pre },
+            .@"aspect-ratio" => .@"aspect-ratio",
+            .overflow => .overflow,
+            .@"overflow-x" => .@"overflow-x",
+            .@"overflow-y" => .@"overflow-y",
+            .@"text-overflow" => .{ .@"text-overflow" = pre },
+            .position => .position,
+            .top => .top,
+            .bottom => .bottom,
+            .left => .left,
+            .right => .right,
+            .@"inset-block-start" => .@"inset-block-start",
+            .@"inset-block-end" => .@"inset-block-end",
+            .@"inset-inline-start" => .@"inset-inline-start",
+            .@"inset-inline-end" => .@"inset-inline-end",
+            .@"inset-block" => .@"inset-block",
+            .@"inset-inline" => .@"inset-inline",
+            .inset => .inset,
+            .@"border-spacing" => .@"border-spacing",
+            .@"border-top-color" => .@"border-top-color",
+            .@"border-bottom-color" => .@"border-bottom-color",
+            .@"border-left-color" => .@"border-left-color",
+            .@"border-right-color" => .@"border-right-color",
+            .@"border-block-start-color" => .@"border-block-start-color",
+            .@"border-block-end-color" => .@"border-block-end-color",
+            .@"border-inline-start-color" => .@"border-inline-start-color",
+            .@"border-inline-end-color" => .@"border-inline-end-color",
+            .@"border-top-style" => .@"border-top-style",
+            .@"border-bottom-style" => .@"border-bottom-style",
+            .@"border-left-style" => .@"border-left-style",
+            .@"border-right-style" => .@"border-right-style",
+            .@"border-block-start-style" => .@"border-block-start-style",
+            .@"border-block-end-style" => .@"border-block-end-style",
+            .@"border-inline-start-style" => .@"border-inline-start-style",
+            .@"border-inline-end-style" => .@"border-inline-end-style",
+            .@"border-top-width" => .@"border-top-width",
+            .@"border-bottom-width" => .@"border-bottom-width",
+            .@"border-left-width" => .@"border-left-width",
+            .@"border-right-width" => .@"border-right-width",
+            .@"border-block-start-width" => .@"border-block-start-width",
+            .@"border-block-end-width" => .@"border-block-end-width",
+            .@"border-inline-start-width" => .@"border-inline-start-width",
+            .@"border-inline-end-width" => .@"border-inline-end-width",
+            .@"border-top-left-radius" => .{ .@"border-top-left-radius" = pre },
+            .@"border-top-right-radius" => .{ .@"border-top-right-radius" = pre },
+            .@"border-bottom-left-radius" => .{ .@"border-bottom-left-radius" = pre },
+            .@"border-bottom-right-radius" => .{ .@"border-bottom-right-radius" = pre },
+            .@"border-start-start-radius" => .@"border-start-start-radius",
+            .@"border-start-end-radius" => .@"border-start-end-radius",
+            .@"border-end-start-radius" => .@"border-end-start-radius",
+            .@"border-end-end-radius" => .@"border-end-end-radius",
+            .@"border-radius" => .{ .@"border-radius" = pre },
+            .@"border-image-source" => .@"border-image-source",
+            .@"border-image-outset" => .@"border-image-outset",
+            .@"border-image-repeat" => .@"border-image-repeat",
+            .@"border-image-width" => .@"border-image-width",
+            .@"border-image-slice" => .@"border-image-slice",
+            .@"border-image" => .{ .@"border-image" = pre },
+            .@"border-color" => .@"border-color",
+            .@"border-style" => .@"border-style",
+            .@"border-width" => .@"border-width",
+            .@"border-block-color" => .@"border-block-color",
+            .@"border-block-style" => .@"border-block-style",
+            .@"border-block-width" => .@"border-block-width",
+            .@"border-inline-color" => .@"border-inline-color",
+            .@"border-inline-style" => .@"border-inline-style",
+            .@"border-inline-width" => .@"border-inline-width",
+            .border => .border,
+            .@"border-top" => .@"border-top",
+            .@"border-bottom" => .@"border-bottom",
+            .@"border-left" => .@"border-left",
+            .@"border-right" => .@"border-right",
+            .@"border-block" => .@"border-block",
+            .@"border-block-start" => .@"border-block-start",
+            .@"border-block-end" => .@"border-block-end",
+            .@"border-inline" => .@"border-inline",
+            .@"border-inline-start" => .@"border-inline-start",
+            .@"border-inline-end" => .@"border-inline-end",
+            .outline => .outline,
+            .@"outline-color" => .@"outline-color",
+            .@"outline-style" => .@"outline-style",
+            .@"outline-width" => .@"outline-width",
+            .@"flex-direction" => .{ .@"flex-direction" = pre },
+            .@"flex-wrap" => .{ .@"flex-wrap" = pre },
+            .@"flex-flow" => .{ .@"flex-flow" = pre },
+            .@"flex-grow" => .{ .@"flex-grow" = pre },
+            .@"flex-shrink" => .{ .@"flex-shrink" = pre },
+            .@"flex-basis" => .{ .@"flex-basis" = pre },
+            .flex => .{ .flex = pre },
+            .order => .{ .order = pre },
+            .@"align-content" => .{ .@"align-content" = pre },
+            .@"justify-content" => .{ .@"justify-content" = pre },
+            .@"place-content" => .@"place-content",
+            .@"align-self" => .{ .@"align-self" = pre },
+            .@"justify-self" => .@"justify-self",
+            .@"place-self" => .@"place-self",
+            .@"align-items" => .{ .@"align-items" = pre },
+            .@"justify-items" => .@"justify-items",
+            .@"place-items" => .@"place-items",
+            .@"row-gap" => .@"row-gap",
+            .@"column-gap" => .@"column-gap",
+            .gap => .gap,
+            .@"box-orient" => .{ .@"box-orient" = pre },
+            .@"box-direction" => .{ .@"box-direction" = pre },
+            .@"box-ordinal-group" => .{ .@"box-ordinal-group" = pre },
+            .@"box-align" => .{ .@"box-align" = pre },
+            .@"box-flex" => .{ .@"box-flex" = pre },
+            .@"box-flex-group" => .{ .@"box-flex-group" = pre },
+            .@"box-pack" => .{ .@"box-pack" = pre },
+            .@"box-lines" => .{ .@"box-lines" = pre },
+            .@"flex-pack" => .{ .@"flex-pack" = pre },
+            .@"flex-order" => .{ .@"flex-order" = pre },
+            .@"flex-align" => .{ .@"flex-align" = pre },
+            .@"flex-item-align" => .{ .@"flex-item-align" = pre },
+            .@"flex-line-pack" => .{ .@"flex-line-pack" = pre },
+            .@"flex-positive" => .{ .@"flex-positive" = pre },
+            .@"flex-negative" => .{ .@"flex-negative" = pre },
+            .@"flex-preferred-size" => .{ .@"flex-preferred-size" = pre },
+            .@"margin-top" => .@"margin-top",
+            .@"margin-bottom" => .@"margin-bottom",
+            .@"margin-left" => .@"margin-left",
+            .@"margin-right" => .@"margin-right",
+            .@"margin-block-start" => .@"margin-block-start",
+            .@"margin-block-end" => .@"margin-block-end",
+            .@"margin-inline-start" => .@"margin-inline-start",
+            .@"margin-inline-end" => .@"margin-inline-end",
+            .@"margin-block" => .@"margin-block",
+            .@"margin-inline" => .@"margin-inline",
+            .margin => .margin,
+            .@"padding-top" => .@"padding-top",
+            .@"padding-bottom" => .@"padding-bottom",
+            .@"padding-left" => .@"padding-left",
+            .@"padding-right" => .@"padding-right",
+            .@"padding-block-start" => .@"padding-block-start",
+            .@"padding-block-end" => .@"padding-block-end",
+            .@"padding-inline-start" => .@"padding-inline-start",
+            .@"padding-inline-end" => .@"padding-inline-end",
+            .@"padding-block" => .@"padding-block",
+            .@"padding-inline" => .@"padding-inline",
+            .padding => .padding,
+            .@"scroll-margin-top" => .@"scroll-margin-top",
+            .@"scroll-margin-bottom" => .@"scroll-margin-bottom",
+            .@"scroll-margin-left" => .@"scroll-margin-left",
+            .@"scroll-margin-right" => .@"scroll-margin-right",
+            .@"scroll-margin-block-start" => .@"scroll-margin-block-start",
+            .@"scroll-margin-block-end" => .@"scroll-margin-block-end",
+            .@"scroll-margin-inline-start" => .@"scroll-margin-inline-start",
+            .@"scroll-margin-inline-end" => .@"scroll-margin-inline-end",
+            .@"scroll-margin-block" => .@"scroll-margin-block",
+            .@"scroll-margin-inline" => .@"scroll-margin-inline",
+            .@"scroll-margin" => .@"scroll-margin",
+            .@"scroll-padding-top" => .@"scroll-padding-top",
+            .@"scroll-padding-bottom" => .@"scroll-padding-bottom",
+            .@"scroll-padding-left" => .@"scroll-padding-left",
+            .@"scroll-padding-right" => .@"scroll-padding-right",
+            .@"scroll-padding-block-start" => .@"scroll-padding-block-start",
+            .@"scroll-padding-block-end" => .@"scroll-padding-block-end",
+            .@"scroll-padding-inline-start" => .@"scroll-padding-inline-start",
+            .@"scroll-padding-inline-end" => .@"scroll-padding-inline-end",
+            .@"scroll-padding-block" => .@"scroll-padding-block",
+            .@"scroll-padding-inline" => .@"scroll-padding-inline",
+            .@"scroll-padding" => .@"scroll-padding",
+            .@"font-weight" => .@"font-weight",
+            .@"font-size" => .@"font-size",
+            .@"font-stretch" => .@"font-stretch",
+            .@"font-family" => .@"font-family",
+            .@"font-style" => .@"font-style",
+            .@"font-variant-caps" => .@"font-variant-caps",
+            .@"line-height" => .@"line-height",
+            .font => .font,
+            .@"text-decoration-color" => .{ .@"text-decoration-color" = pre },
+            .@"text-emphasis-color" => .{ .@"text-emphasis-color" = pre },
+            .@"text-shadow" => .@"text-shadow",
+            .direction => .direction,
+            .composes => .composes,
+            .@"mask-image" => .{ .@"mask-image" = pre },
+            .@"mask-mode" => .@"mask-mode",
+            .@"mask-repeat" => .{ .@"mask-repeat" = pre },
+            .@"mask-position-x" => .@"mask-position-x",
+            .@"mask-position-y" => .@"mask-position-y",
+            .@"mask-position" => .{ .@"mask-position" = pre },
+            .@"mask-clip" => .{ .@"mask-clip" = pre },
+            .@"mask-origin" => .{ .@"mask-origin" = pre },
+            .@"mask-size" => .{ .@"mask-size" = pre },
+            .@"mask-composite" => .@"mask-composite",
+            .@"mask-type" => .@"mask-type",
+            .mask => .{ .mask = pre },
+            .@"mask-border-source" => .@"mask-border-source",
+            .@"mask-border-mode" => .@"mask-border-mode",
+            .@"mask-border-slice" => .@"mask-border-slice",
+            .@"mask-border-width" => .@"mask-border-width",
+            .@"mask-border-outset" => .@"mask-border-outset",
+            .@"mask-border-repeat" => .@"mask-border-repeat",
+            .@"mask-border" => .@"mask-border",
+            .@"-webkit-mask-composite" => .@"-webkit-mask-composite",
+            .@"mask-source-type" => .{ .@"mask-source-type" = pre },
+            .@"mask-box-image" => .{ .@"mask-box-image" = pre },
+            .@"mask-box-image-source" => .{ .@"mask-box-image-source" = pre },
+            .@"mask-box-image-slice" => .{ .@"mask-box-image-slice" = pre },
+            .@"mask-box-image-width" => .{ .@"mask-box-image-width" = pre },
+            .@"mask-box-image-outset" => .{ .@"mask-box-image-outset" = pre },
+            .@"mask-box-image-repeat" => .{ .@"mask-box-image-repeat" = pre },
+            else => this.*,
+        };
+    }
+
+    pub fn addPrefix(this: *PropertyId, pre: VendorPrefix) void {
+        return switch (this.*) {
+            .@"background-color" => {},
+            .@"background-image" => {},
+            .@"background-position-x" => {},
+            .@"background-position-y" => {},
+            .@"background-position" => {},
+            .@"background-size" => {},
+            .@"background-repeat" => {},
+            .@"background-attachment" => {},
+            .@"background-clip" => |*p| {
+                p.insert(pre);
+            },
+            .@"background-origin" => {},
+            .background => {},
+            .@"box-shadow" => |*p| {
+                p.insert(pre);
+            },
+            .opacity => {},
+            .color => {},
+            .display => {},
+            .visibility => {},
+            .width => {},
+            .height => {},
+            .@"min-width" => {},
+            .@"min-height" => {},
+            .@"max-width" => {},
+            .@"max-height" => {},
+            .@"block-size" => {},
+            .@"inline-size" => {},
+            .@"min-block-size" => {},
+            .@"min-inline-size" => {},
+            .@"max-block-size" => {},
+            .@"max-inline-size" => {},
+            .@"box-sizing" => |*p| {
+                p.insert(pre);
+            },
+            .@"aspect-ratio" => {},
+            .overflow => {},
+            .@"overflow-x" => {},
+            .@"overflow-y" => {},
+            .@"text-overflow" => |*p| {
+                p.insert(pre);
+            },
+            .position => {},
+            .top => {},
+            .bottom => {},
+            .left => {},
+            .right => {},
+            .@"inset-block-start" => {},
+            .@"inset-block-end" => {},
+            .@"inset-inline-start" => {},
+            .@"inset-inline-end" => {},
+            .@"inset-block" => {},
+            .@"inset-inline" => {},
+            .inset => {},
+            .@"border-spacing" => {},
+            .@"border-top-color" => {},
+            .@"border-bottom-color" => {},
+            .@"border-left-color" => {},
+            .@"border-right-color" => {},
+            .@"border-block-start-color" => {},
+            .@"border-block-end-color" => {},
+            .@"border-inline-start-color" => {},
+            .@"border-inline-end-color" => {},
+            .@"border-top-style" => {},
+            .@"border-bottom-style" => {},
+            .@"border-left-style" => {},
+            .@"border-right-style" => {},
+            .@"border-block-start-style" => {},
+            .@"border-block-end-style" => {},
+            .@"border-inline-start-style" => {},
+            .@"border-inline-end-style" => {},
+            .@"border-top-width" => {},
+            .@"border-bottom-width" => {},
+            .@"border-left-width" => {},
+            .@"border-right-width" => {},
+            .@"border-block-start-width" => {},
+            .@"border-block-end-width" => {},
+            .@"border-inline-start-width" => {},
+            .@"border-inline-end-width" => {},
+            .@"border-top-left-radius" => |*p| {
+                p.insert(pre);
+            },
+            .@"border-top-right-radius" => |*p| {
+                p.insert(pre);
+            },
+            .@"border-bottom-left-radius" => |*p| {
+                p.insert(pre);
+            },
+            .@"border-bottom-right-radius" => |*p| {
+                p.insert(pre);
+            },
+            .@"border-start-start-radius" => {},
+            .@"border-start-end-radius" => {},
+            .@"border-end-start-radius" => {},
+            .@"border-end-end-radius" => {},
+            .@"border-radius" => |*p| {
+                p.insert(pre);
+            },
+            .@"border-image-source" => {},
+            .@"border-image-outset" => {},
+            .@"border-image-repeat" => {},
+            .@"border-image-width" => {},
+            .@"border-image-slice" => {},
+            .@"border-image" => |*p| {
+                p.insert(pre);
+            },
+            .@"border-color" => {},
+            .@"border-style" => {},
+            .@"border-width" => {},
+            .@"border-block-color" => {},
+            .@"border-block-style" => {},
+            .@"border-block-width" => {},
+            .@"border-inline-color" => {},
+            .@"border-inline-style" => {},
+            .@"border-inline-width" => {},
+            .border => {},
+            .@"border-top" => {},
+            .@"border-bottom" => {},
+            .@"border-left" => {},
+            .@"border-right" => {},
+            .@"border-block" => {},
+            .@"border-block-start" => {},
+            .@"border-block-end" => {},
+            .@"border-inline" => {},
+            .@"border-inline-start" => {},
+            .@"border-inline-end" => {},
+            .outline => {},
+            .@"outline-color" => {},
+            .@"outline-style" => {},
+            .@"outline-width" => {},
+            .@"flex-direction" => |*p| {
+                p.insert(pre);
+            },
+            .@"flex-wrap" => |*p| {
+                p.insert(pre);
+            },
+            .@"flex-flow" => |*p| {
+                p.insert(pre);
+            },
+            .@"flex-grow" => |*p| {
+                p.insert(pre);
+            },
+            .@"flex-shrink" => |*p| {
+                p.insert(pre);
+            },
+            .@"flex-basis" => |*p| {
+                p.insert(pre);
+            },
+            .flex => |*p| {
+                p.insert(pre);
+            },
+            .order => |*p| {
+                p.insert(pre);
+            },
+            .@"align-content" => |*p| {
+                p.insert(pre);
+            },
+            .@"justify-content" => |*p| {
+                p.insert(pre);
+            },
+            .@"place-content" => {},
+            .@"align-self" => |*p| {
+                p.insert(pre);
+            },
+            .@"justify-self" => {},
+            .@"place-self" => {},
+            .@"align-items" => |*p| {
+                p.insert(pre);
+            },
+            .@"justify-items" => {},
+            .@"place-items" => {},
+            .@"row-gap" => {},
+            .@"column-gap" => {},
+            .gap => {},
+            .@"box-orient" => |*p| {
+                p.insert(pre);
+            },
+            .@"box-direction" => |*p| {
+                p.insert(pre);
+            },
+            .@"box-ordinal-group" => |*p| {
+                p.insert(pre);
+            },
+            .@"box-align" => |*p| {
+                p.insert(pre);
+            },
+            .@"box-flex" => |*p| {
+                p.insert(pre);
+            },
+            .@"box-flex-group" => |*p| {
+                p.insert(pre);
+            },
+            .@"box-pack" => |*p| {
+                p.insert(pre);
+            },
+            .@"box-lines" => |*p| {
+                p.insert(pre);
+            },
+            .@"flex-pack" => |*p| {
+                p.insert(pre);
+            },
+            .@"flex-order" => |*p| {
+                p.insert(pre);
+            },
+            .@"flex-align" => |*p| {
+                p.insert(pre);
+            },
+            .@"flex-item-align" => |*p| {
+                p.insert(pre);
+            },
+            .@"flex-line-pack" => |*p| {
+                p.insert(pre);
+            },
+            .@"flex-positive" => |*p| {
+                p.insert(pre);
+            },
+            .@"flex-negative" => |*p| {
+                p.insert(pre);
+            },
+            .@"flex-preferred-size" => |*p| {
+                p.insert(pre);
+            },
+            .@"margin-top" => {},
+            .@"margin-bottom" => {},
+            .@"margin-left" => {},
+            .@"margin-right" => {},
+            .@"margin-block-start" => {},
+            .@"margin-block-end" => {},
+            .@"margin-inline-start" => {},
+            .@"margin-inline-end" => {},
+            .@"margin-block" => {},
+            .@"margin-inline" => {},
+            .margin => {},
+            .@"padding-top" => {},
+            .@"padding-bottom" => {},
+            .@"padding-left" => {},
+            .@"padding-right" => {},
+            .@"padding-block-start" => {},
+            .@"padding-block-end" => {},
+            .@"padding-inline-start" => {},
+            .@"padding-inline-end" => {},
+            .@"padding-block" => {},
+            .@"padding-inline" => {},
+            .padding => {},
+            .@"scroll-margin-top" => {},
+            .@"scroll-margin-bottom" => {},
+            .@"scroll-margin-left" => {},
+            .@"scroll-margin-right" => {},
+            .@"scroll-margin-block-start" => {},
+            .@"scroll-margin-block-end" => {},
+            .@"scroll-margin-inline-start" => {},
+            .@"scroll-margin-inline-end" => {},
+            .@"scroll-margin-block" => {},
+            .@"scroll-margin-inline" => {},
+            .@"scroll-margin" => {},
+            .@"scroll-padding-top" => {},
+            .@"scroll-padding-bottom" => {},
+            .@"scroll-padding-left" => {},
+            .@"scroll-padding-right" => {},
+            .@"scroll-padding-block-start" => {},
+            .@"scroll-padding-block-end" => {},
+            .@"scroll-padding-inline-start" => {},
+            .@"scroll-padding-inline-end" => {},
+            .@"scroll-padding-block" => {},
+            .@"scroll-padding-inline" => {},
+            .@"scroll-padding" => {},
+            .@"font-weight" => {},
+            .@"font-size" => {},
+            .@"font-stretch" => {},
+            .@"font-family" => {},
+            .@"font-style" => {},
+            .@"font-variant-caps" => {},
+            .@"line-height" => {},
+            .font => {},
+            .@"text-decoration-color" => |*p| {
+                p.insert(pre);
+            },
+            .@"text-emphasis-color" => |*p| {
+                p.insert(pre);
+            },
+            .@"text-shadow" => {},
+            .direction => {},
+            .composes => {},
+            .@"mask-image" => |*p| {
+                p.insert(pre);
+            },
+            .@"mask-mode" => {},
+            .@"mask-repeat" => |*p| {
+                p.insert(pre);
+            },
+            .@"mask-position-x" => {},
+            .@"mask-position-y" => {},
+            .@"mask-position" => |*p| {
+                p.insert(pre);
+            },
+            .@"mask-clip" => |*p| {
+                p.insert(pre);
+            },
+            .@"mask-origin" => |*p| {
+                p.insert(pre);
+            },
+            .@"mask-size" => |*p| {
+                p.insert(pre);
+            },
+            .@"mask-composite" => {},
+            .@"mask-type" => {},
+            .mask => |*p| {
+                p.insert(pre);
+            },
+            .@"mask-border-source" => {},
+            .@"mask-border-mode" => {},
+            .@"mask-border-slice" => {},
+            .@"mask-border-width" => {},
+            .@"mask-border-outset" => {},
+            .@"mask-border-repeat" => {},
+            .@"mask-border" => {},
+            .@"-webkit-mask-composite" => {},
+            .@"mask-source-type" => |*p| {
+                p.insert(pre);
+            },
+            .@"mask-box-image" => |*p| {
+                p.insert(pre);
+            },
+            .@"mask-box-image-source" => |*p| {
+                p.insert(pre);
+            },
+            .@"mask-box-image-slice" => |*p| {
+                p.insert(pre);
+            },
+            .@"mask-box-image-width" => |*p| {
+                p.insert(pre);
+            },
+            .@"mask-box-image-outset" => |*p| {
+                p.insert(pre);
+            },
+            .@"mask-box-image-repeat" => |*p| {
+                p.insert(pre);
+            },
+            else => {},
+        };
+    }
+
+    pub inline fn deepClone(this: *const PropertyId, _: std.mem.Allocator) PropertyId {
+        return this.*;
+    }
+
+    pub fn eql(lhs: *const PropertyId, rhs: *const PropertyId) bool {
+        if (@intFromEnum(lhs.*) != @intFromEnum(rhs.*)) return false;
+        inline for (bun.meta.EnumFields(PropertyId), std.meta.fields(PropertyId)) |enum_field, union_field| {
+            if (enum_field.value == @intFromEnum(lhs.*)) {
+                if (comptime union_field.type == css.VendorPrefix) {
+                    return @field(lhs, union_field.name).eql(@field(rhs, union_field.name));
+                } else {
+                    return true;
+                }
+            }
+        }
+        unreachable;
+    }
+
+    pub fn hash(this: *const PropertyId, hasher: *std.hash.Wyhash) void {
+        const tag = @intFromEnum(this.*);
+        hasher.update(std.mem.asBytes(&tag));
+    }
+};
+pub const PropertyIdTag = enum(u16) {
+    @"background-color",
+    @"background-image",
+    @"background-position-x",
+    @"background-position-y",
+    @"background-position",
+    @"background-size",
+    @"background-repeat",
+    @"background-attachment",
+    @"background-clip",
+    @"background-origin",
+    background,
+    @"box-shadow",
+    opacity,
+    color,
+    display,
+    visibility,
+    width,
+    height,
+    @"min-width",
+    @"min-height",
+    @"max-width",
+    @"max-height",
+    @"block-size",
+    @"inline-size",
+    @"min-block-size",
+    @"min-inline-size",
+    @"max-block-size",
+    @"max-inline-size",
+    @"box-sizing",
+    @"aspect-ratio",
+    overflow,
+    @"overflow-x",
+    @"overflow-y",
+    @"text-overflow",
+    position,
+    top,
+    bottom,
+    left,
+    right,
+    @"inset-block-start",
+    @"inset-block-end",
+    @"inset-inline-start",
+    @"inset-inline-end",
+    @"inset-block",
+    @"inset-inline",
+    inset,
+    @"border-spacing",
+    @"border-top-color",
+    @"border-bottom-color",
+    @"border-left-color",
+    @"border-right-color",
+    @"border-block-start-color",
+    @"border-block-end-color",
+    @"border-inline-start-color",
+    @"border-inline-end-color",
+    @"border-top-style",
+    @"border-bottom-style",
+    @"border-left-style",
+    @"border-right-style",
+    @"border-block-start-style",
+    @"border-block-end-style",
+    @"border-inline-start-style",
+    @"border-inline-end-style",
+    @"border-top-width",
+    @"border-bottom-width",
+    @"border-left-width",
+    @"border-right-width",
+    @"border-block-start-width",
+    @"border-block-end-width",
+    @"border-inline-start-width",
+    @"border-inline-end-width",
+    @"border-top-left-radius",
+    @"border-top-right-radius",
+    @"border-bottom-left-radius",
+    @"border-bottom-right-radius",
+    @"border-start-start-radius",
+    @"border-start-end-radius",
+    @"border-end-start-radius",
+    @"border-end-end-radius",
+    @"border-radius",
+    @"border-image-source",
+    @"border-image-outset",
+    @"border-image-repeat",
+    @"border-image-width",
+    @"border-image-slice",
+    @"border-image",
+    @"border-color",
+    @"border-style",
+    @"border-width",
+    @"border-block-color",
+    @"border-block-style",
+    @"border-block-width",
+    @"border-inline-color",
+    @"border-inline-style",
+    @"border-inline-width",
+    border,
+    @"border-top",
+    @"border-bottom",
+    @"border-left",
+    @"border-right",
+    @"border-block",
+    @"border-block-start",
+    @"border-block-end",
+    @"border-inline",
+    @"border-inline-start",
+    @"border-inline-end",
+    outline,
+    @"outline-color",
+    @"outline-style",
+    @"outline-width",
+    @"flex-direction",
+    @"flex-wrap",
+    @"flex-flow",
+    @"flex-grow",
+    @"flex-shrink",
+    @"flex-basis",
+    flex,
+    order,
+    @"align-content",
+    @"justify-content",
+    @"place-content",
+    @"align-self",
+    @"justify-self",
+    @"place-self",
+    @"align-items",
+    @"justify-items",
+    @"place-items",
+    @"row-gap",
+    @"column-gap",
+    gap,
+    @"box-orient",
+    @"box-direction",
+    @"box-ordinal-group",
+    @"box-align",
+    @"box-flex",
+    @"box-flex-group",
+    @"box-pack",
+    @"box-lines",
+    @"flex-pack",
+    @"flex-order",
+    @"flex-align",
+    @"flex-item-align",
+    @"flex-line-pack",
+    @"flex-positive",
+    @"flex-negative",
+    @"flex-preferred-size",
+    @"margin-top",
+    @"margin-bottom",
+    @"margin-left",
+    @"margin-right",
+    @"margin-block-start",
+    @"margin-block-end",
+    @"margin-inline-start",
+    @"margin-inline-end",
+    @"margin-block",
+    @"margin-inline",
+    margin,
+    @"padding-top",
+    @"padding-bottom",
+    @"padding-left",
+    @"padding-right",
+    @"padding-block-start",
+    @"padding-block-end",
+    @"padding-inline-start",
+    @"padding-inline-end",
+    @"padding-block",
+    @"padding-inline",
+    padding,
+    @"scroll-margin-top",
+    @"scroll-margin-bottom",
+    @"scroll-margin-left",
+    @"scroll-margin-right",
+    @"scroll-margin-block-start",
+    @"scroll-margin-block-end",
+    @"scroll-margin-inline-start",
+    @"scroll-margin-inline-end",
+    @"scroll-margin-block",
+    @"scroll-margin-inline",
+    @"scroll-margin",
+    @"scroll-padding-top",
+    @"scroll-padding-bottom",
+    @"scroll-padding-left",
+    @"scroll-padding-right",
+    @"scroll-padding-block-start",
+    @"scroll-padding-block-end",
+    @"scroll-padding-inline-start",
+    @"scroll-padding-inline-end",
+    @"scroll-padding-block",
+    @"scroll-padding-inline",
+    @"scroll-padding",
+    @"font-weight",
+    @"font-size",
+    @"font-stretch",
+    @"font-family",
+    @"font-style",
+    @"font-variant-caps",
+    @"line-height",
+    font,
+    @"text-decoration-color",
+    @"text-emphasis-color",
+    @"text-shadow",
+    direction,
+    composes,
+    @"mask-image",
+    @"mask-mode",
+    @"mask-repeat",
+    @"mask-position-x",
+    @"mask-position-y",
+    @"mask-position",
+    @"mask-clip",
+    @"mask-origin",
+    @"mask-size",
+    @"mask-composite",
+    @"mask-type",
+    mask,
+    @"mask-border-source",
+    @"mask-border-mode",
+    @"mask-border-slice",
+    @"mask-border-width",
+    @"mask-border-outset",
+    @"mask-border-repeat",
+    @"mask-border",
+    @"-webkit-mask-composite",
+    @"mask-source-type",
+    @"mask-box-image",
+    @"mask-box-image-source",
+    @"mask-box-image-slice",
+    @"mask-box-image-width",
+    @"mask-box-image-outset",
+    @"mask-box-image-repeat",
+    all,
+    unparsed,
+    custom,
+
+    /// Helper function used in comptime code to know whether to access the underlying value
+    /// with tuple indexing syntax because it may have a VendorPrefix associated with it.
+    pub fn hasVendorPrefix(this: PropertyIdTag) bool {
+        return switch (this) {
+            .@"background-color" => false,
+            .@"background-image" => false,
+            .@"background-position-x" => false,
+            .@"background-position-y" => false,
+            .@"background-position" => false,
+            .@"background-size" => false,
+            .@"background-repeat" => false,
+            .@"background-attachment" => false,
+            .@"background-clip" => true,
+            .@"background-origin" => false,
+            .background => false,
+            .@"box-shadow" => true,
+            .opacity => false,
+            .color => false,
+            .display => false,
+            .visibility => false,
+            .width => false,
+            .height => false,
+            .@"min-width" => false,
+            .@"min-height" => false,
+            .@"max-width" => false,
+            .@"max-height" => false,
+            .@"block-size" => false,
+            .@"inline-size" => false,
+            .@"min-block-size" => false,
+            .@"min-inline-size" => false,
+            .@"max-block-size" => false,
+            .@"max-inline-size" => false,
+            .@"box-sizing" => true,
+            .@"aspect-ratio" => false,
+            .overflow => false,
+            .@"overflow-x" => false,
+            .@"overflow-y" => false,
+            .@"text-overflow" => true,
+            .position => false,
+            .top => false,
+            .bottom => false,
+            .left => false,
+            .right => false,
+            .@"inset-block-start" => false,
+            .@"inset-block-end" => false,
+            .@"inset-inline-start" => false,
+            .@"inset-inline-end" => false,
+            .@"inset-block" => false,
+            .@"inset-inline" => false,
+            .inset => false,
+            .@"border-spacing" => false,
+            .@"border-top-color" => false,
+            .@"border-bottom-color" => false,
+            .@"border-left-color" => false,
+            .@"border-right-color" => false,
+            .@"border-block-start-color" => false,
+            .@"border-block-end-color" => false,
+            .@"border-inline-start-color" => false,
+            .@"border-inline-end-color" => false,
+            .@"border-top-style" => false,
+            .@"border-bottom-style" => false,
+            .@"border-left-style" => false,
+            .@"border-right-style" => false,
+            .@"border-block-start-style" => false,
+            .@"border-block-end-style" => false,
+            .@"border-inline-start-style" => false,
+            .@"border-inline-end-style" => false,
+            .@"border-top-width" => false,
+            .@"border-bottom-width" => false,
+            .@"border-left-width" => false,
+            .@"border-right-width" => false,
+            .@"border-block-start-width" => false,
+            .@"border-block-end-width" => false,
+            .@"border-inline-start-width" => false,
+            .@"border-inline-end-width" => false,
+            .@"border-top-left-radius" => true,
+            .@"border-top-right-radius" => true,
+            .@"border-bottom-left-radius" => true,
+            .@"border-bottom-right-radius" => true,
+            .@"border-start-start-radius" => false,
+            .@"border-start-end-radius" => false,
+            .@"border-end-start-radius" => false,
+            .@"border-end-end-radius" => false,
+            .@"border-radius" => true,
+            .@"border-image-source" => false,
+            .@"border-image-outset" => false,
+            .@"border-image-repeat" => false,
+            .@"border-image-width" => false,
+            .@"border-image-slice" => false,
+            .@"border-image" => true,
+            .@"border-color" => false,
+            .@"border-style" => false,
+            .@"border-width" => false,
+            .@"border-block-color" => false,
+            .@"border-block-style" => false,
+            .@"border-block-width" => false,
+            .@"border-inline-color" => false,
+            .@"border-inline-style" => false,
+            .@"border-inline-width" => false,
+            .border => false,
+            .@"border-top" => false,
+            .@"border-bottom" => false,
+            .@"border-left" => false,
+            .@"border-right" => false,
+            .@"border-block" => false,
+            .@"border-block-start" => false,
+            .@"border-block-end" => false,
+            .@"border-inline" => false,
+            .@"border-inline-start" => false,
+            .@"border-inline-end" => false,
+            .outline => false,
+            .@"outline-color" => false,
+            .@"outline-style" => false,
+            .@"outline-width" => false,
+            .@"flex-direction" => true,
+            .@"flex-wrap" => true,
+            .@"flex-flow" => true,
+            .@"flex-grow" => true,
+            .@"flex-shrink" => true,
+            .@"flex-basis" => true,
+            .flex => true,
+            .order => true,
+            .@"align-content" => true,
+            .@"justify-content" => true,
+            .@"place-content" => false,
+            .@"align-self" => true,
+            .@"justify-self" => false,
+            .@"place-self" => false,
+            .@"align-items" => true,
+            .@"justify-items" => false,
+            .@"place-items" => false,
+            .@"row-gap" => false,
+            .@"column-gap" => false,
+            .gap => false,
+            .@"box-orient" => true,
+            .@"box-direction" => true,
+            .@"box-ordinal-group" => true,
+            .@"box-align" => true,
+            .@"box-flex" => true,
+            .@"box-flex-group" => true,
+            .@"box-pack" => true,
+            .@"box-lines" => true,
+            .@"flex-pack" => true,
+            .@"flex-order" => true,
+            .@"flex-align" => true,
+            .@"flex-item-align" => true,
+            .@"flex-line-pack" => true,
+            .@"flex-positive" => true,
+            .@"flex-negative" => true,
+            .@"flex-preferred-size" => true,
+            .@"margin-top" => false,
+            .@"margin-bottom" => false,
+            .@"margin-left" => false,
+            .@"margin-right" => false,
+            .@"margin-block-start" => false,
+            .@"margin-block-end" => false,
+            .@"margin-inline-start" => false,
+            .@"margin-inline-end" => false,
+            .@"margin-block" => false,
+            .@"margin-inline" => false,
+            .margin => false,
+            .@"padding-top" => false,
+            .@"padding-bottom" => false,
+            .@"padding-left" => false,
+            .@"padding-right" => false,
+            .@"padding-block-start" => false,
+            .@"padding-block-end" => false,
+            .@"padding-inline-start" => false,
+            .@"padding-inline-end" => false,
+            .@"padding-block" => false,
+            .@"padding-inline" => false,
+            .padding => false,
+            .@"scroll-margin-top" => false,
+            .@"scroll-margin-bottom" => false,
+            .@"scroll-margin-left" => false,
+            .@"scroll-margin-right" => false,
+            .@"scroll-margin-block-start" => false,
+            .@"scroll-margin-block-end" => false,
+            .@"scroll-margin-inline-start" => false,
+            .@"scroll-margin-inline-end" => false,
+            .@"scroll-margin-block" => false,
+            .@"scroll-margin-inline" => false,
+            .@"scroll-margin" => false,
+            .@"scroll-padding-top" => false,
+            .@"scroll-padding-bottom" => false,
+            .@"scroll-padding-left" => false,
+            .@"scroll-padding-right" => false,
+            .@"scroll-padding-block-start" => false,
+            .@"scroll-padding-block-end" => false,
+            .@"scroll-padding-inline-start" => false,
+            .@"scroll-padding-inline-end" => false,
+            .@"scroll-padding-block" => false,
+            .@"scroll-padding-inline" => false,
+            .@"scroll-padding" => false,
+            .@"font-weight" => false,
+            .@"font-size" => false,
+            .@"font-stretch" => false,
+            .@"font-family" => false,
+            .@"font-style" => false,
+            .@"font-variant-caps" => false,
+            .@"line-height" => false,
+            .font => false,
+            .@"text-decoration-color" => true,
+            .@"text-emphasis-color" => true,
+            .@"text-shadow" => false,
+            .direction => false,
+            .composes => false,
+            .@"mask-image" => true,
+            .@"mask-mode" => false,
+            .@"mask-repeat" => true,
+            .@"mask-position-x" => false,
+            .@"mask-position-y" => false,
+            .@"mask-position" => true,
+            .@"mask-clip" => true,
+            .@"mask-origin" => true,
+            .@"mask-size" => true,
+            .@"mask-composite" => false,
+            .@"mask-type" => false,
+            .mask => true,
+            .@"mask-border-source" => false,
+            .@"mask-border-mode" => false,
+            .@"mask-border-slice" => false,
+            .@"mask-border-width" => false,
+            .@"mask-border-outset" => false,
+            .@"mask-border-repeat" => false,
+            .@"mask-border" => false,
+            .@"-webkit-mask-composite" => false,
+            .@"mask-source-type" => true,
+            .@"mask-box-image" => true,
+            .@"mask-box-image-source" => true,
+            .@"mask-box-image-slice" => true,
+            .@"mask-box-image-width" => true,
+            .@"mask-box-image-outset" => true,
+            .@"mask-box-image-repeat" => true,
+            .unparsed => false,
+            .custom => false,
+            .all => false,
+        };
+    }
+
+    /// Helper function used in comptime code to know whether to access the underlying value
+    /// with tuple indexing syntax because it may have a VendorPrefix associated with it.
+    pub fn valueType(this: PropertyIdTag) type {
+        return switch (this) {
+            .@"background-color" => CssColor,
+            .@"background-image" => SmallList(Image, 1),
+            .@"background-position-x" => SmallList(css_values.position.HorizontalPosition, 1),
+            .@"background-position-y" => SmallList(css_values.position.VerticalPosition, 1),
+            .@"background-position" => SmallList(background.BackgroundPosition, 1),
+            .@"background-size" => SmallList(background.BackgroundSize, 1),
+            .@"background-repeat" => SmallList(background.BackgroundRepeat, 1),
+            .@"background-attachment" => SmallList(background.BackgroundAttachment, 1),
+            .@"background-clip" => SmallList(background.BackgroundClip, 1),
+            .@"background-origin" => SmallList(background.BackgroundOrigin, 1),
+            .background => SmallList(background.Background, 1),
+            .@"box-shadow" => SmallList(box_shadow.BoxShadow, 1),
+            .opacity => css.css_values.alpha.AlphaValue,
+            .color => CssColor,
+            .display => display.Display,
+            .visibility => display.Visibility,
+            .width => size.Size,
+            .height => size.Size,
+            .@"min-width" => size.Size,
+            .@"min-height" => size.Size,
+            .@"max-width" => size.MaxSize,
+            .@"max-height" => size.MaxSize,
+            .@"block-size" => size.Size,
+            .@"inline-size" => size.Size,
+            .@"min-block-size" => size.Size,
+            .@"min-inline-size" => size.Size,
+            .@"max-block-size" => size.MaxSize,
+            .@"max-inline-size" => size.MaxSize,
+            .@"box-sizing" => size.BoxSizing,
+            .@"aspect-ratio" => size.AspectRatio,
+            .overflow => overflow.Overflow,
+            .@"overflow-x" => overflow.OverflowKeyword,
+            .@"overflow-y" => overflow.OverflowKeyword,
+            .@"text-overflow" => overflow.TextOverflow,
+            .position => position.Position,
+            .top => LengthPercentageOrAuto,
+            .bottom => LengthPercentageOrAuto,
+            .left => LengthPercentageOrAuto,
+            .right => LengthPercentageOrAuto,
+            .@"inset-block-start" => LengthPercentageOrAuto,
+            .@"inset-block-end" => LengthPercentageOrAuto,
+            .@"inset-inline-start" => LengthPercentageOrAuto,
+            .@"inset-inline-end" => LengthPercentageOrAuto,
+            .@"inset-block" => margin_padding.InsetBlock,
+            .@"inset-inline" => margin_padding.InsetInline,
+            .inset => margin_padding.Inset,
+            .@"border-spacing" => css.css_values.size.Size2D(Length),
+            .@"border-top-color" => CssColor,
+            .@"border-bottom-color" => CssColor,
+            .@"border-left-color" => CssColor,
+            .@"border-right-color" => CssColor,
+            .@"border-block-start-color" => CssColor,
+            .@"border-block-end-color" => CssColor,
+            .@"border-inline-start-color" => CssColor,
+            .@"border-inline-end-color" => CssColor,
+            .@"border-top-style" => border.LineStyle,
+            .@"border-bottom-style" => border.LineStyle,
+            .@"border-left-style" => border.LineStyle,
+            .@"border-right-style" => border.LineStyle,
+            .@"border-block-start-style" => border.LineStyle,
+            .@"border-block-end-style" => border.LineStyle,
+            .@"border-inline-start-style" => border.LineStyle,
+            .@"border-inline-end-style" => border.LineStyle,
+            .@"border-top-width" => BorderSideWidth,
+            .@"border-bottom-width" => BorderSideWidth,
+            .@"border-left-width" => BorderSideWidth,
+            .@"border-right-width" => BorderSideWidth,
+            .@"border-block-start-width" => BorderSideWidth,
+            .@"border-block-end-width" => BorderSideWidth,
+            .@"border-inline-start-width" => BorderSideWidth,
+            .@"border-inline-end-width" => BorderSideWidth,
+            .@"border-top-left-radius" => Size2D(LengthPercentage),
+            .@"border-top-right-radius" => Size2D(LengthPercentage),
+            .@"border-bottom-left-radius" => Size2D(LengthPercentage),
+            .@"border-bottom-right-radius" => Size2D(LengthPercentage),
+            .@"border-start-start-radius" => Size2D(LengthPercentage),
+            .@"border-start-end-radius" => Size2D(LengthPercentage),
+            .@"border-end-start-radius" => Size2D(LengthPercentage),
+            .@"border-end-end-radius" => Size2D(LengthPercentage),
+            .@"border-radius" => BorderRadius,
+            .@"border-image-source" => Image,
+            .@"border-image-outset" => Rect(LengthOrNumber),
+            .@"border-image-repeat" => BorderImageRepeat,
+            .@"border-image-width" => Rect(BorderImageSideWidth),
+            .@"border-image-slice" => BorderImageSlice,
+            .@"border-image" => BorderImage,
+            .@"border-color" => BorderColor,
+            .@"border-style" => BorderStyle,
+            .@"border-width" => BorderWidth,
+            .@"border-block-color" => BorderBlockColor,
+            .@"border-block-style" => BorderBlockStyle,
+            .@"border-block-width" => BorderBlockWidth,
+            .@"border-inline-color" => BorderInlineColor,
+            .@"border-inline-style" => BorderInlineStyle,
+            .@"border-inline-width" => BorderInlineWidth,
+            .border => Border,
+            .@"border-top" => BorderTop,
+            .@"border-bottom" => BorderBottom,
+            .@"border-left" => BorderLeft,
+            .@"border-right" => BorderRight,
+            .@"border-block" => BorderBlock,
+            .@"border-block-start" => BorderBlockStart,
+            .@"border-block-end" => BorderBlockEnd,
+            .@"border-inline" => BorderInline,
+            .@"border-inline-start" => BorderInlineStart,
+            .@"border-inline-end" => BorderInlineEnd,
+            .outline => Outline,
+            .@"outline-color" => CssColor,
+            .@"outline-style" => OutlineStyle,
+            .@"outline-width" => BorderSideWidth,
+            .@"flex-direction" => FlexDirection,
+            .@"flex-wrap" => FlexWrap,
+            .@"flex-flow" => FlexFlow,
+            .@"flex-grow" => CSSNumber,
+            .@"flex-shrink" => CSSNumber,
+            .@"flex-basis" => LengthPercentageOrAuto,
+            .flex => Flex,
+            .order => CSSInteger,
+            .@"align-content" => AlignContent,
+            .@"justify-content" => JustifyContent,
+            .@"place-content" => PlaceContent,
+            .@"align-self" => AlignSelf,
+            .@"justify-self" => JustifySelf,
+            .@"place-self" => PlaceSelf,
+            .@"align-items" => AlignItems,
+            .@"justify-items" => JustifyItems,
+            .@"place-items" => PlaceItems,
+            .@"row-gap" => GapValue,
+            .@"column-gap" => GapValue,
+            .gap => Gap,
+            .@"box-orient" => BoxOrient,
+            .@"box-direction" => BoxDirection,
+            .@"box-ordinal-group" => CSSInteger,
+            .@"box-align" => BoxAlign,
+            .@"box-flex" => CSSNumber,
+            .@"box-flex-group" => CSSInteger,
+            .@"box-pack" => BoxPack,
+            .@"box-lines" => BoxLines,
+            .@"flex-pack" => FlexPack,
+            .@"flex-order" => CSSInteger,
+            .@"flex-align" => BoxAlign,
+            .@"flex-item-align" => FlexItemAlign,
+            .@"flex-line-pack" => FlexLinePack,
+            .@"flex-positive" => CSSNumber,
+            .@"flex-negative" => CSSNumber,
+            .@"flex-preferred-size" => LengthPercentageOrAuto,
+            .@"margin-top" => LengthPercentageOrAuto,
+            .@"margin-bottom" => LengthPercentageOrAuto,
+            .@"margin-left" => LengthPercentageOrAuto,
+            .@"margin-right" => LengthPercentageOrAuto,
+            .@"margin-block-start" => LengthPercentageOrAuto,
+            .@"margin-block-end" => LengthPercentageOrAuto,
+            .@"margin-inline-start" => LengthPercentageOrAuto,
+            .@"margin-inline-end" => LengthPercentageOrAuto,
+            .@"margin-block" => MarginBlock,
+            .@"margin-inline" => MarginInline,
+            .margin => Margin,
+            .@"padding-top" => LengthPercentageOrAuto,
+            .@"padding-bottom" => LengthPercentageOrAuto,
+            .@"padding-left" => LengthPercentageOrAuto,
+            .@"padding-right" => LengthPercentageOrAuto,
+            .@"padding-block-start" => LengthPercentageOrAuto,
+            .@"padding-block-end" => LengthPercentageOrAuto,
+            .@"padding-inline-start" => LengthPercentageOrAuto,
+            .@"padding-inline-end" => LengthPercentageOrAuto,
+            .@"padding-block" => PaddingBlock,
+            .@"padding-inline" => PaddingInline,
+            .padding => Padding,
+            .@"scroll-margin-top" => LengthPercentageOrAuto,
+            .@"scroll-margin-bottom" => LengthPercentageOrAuto,
+            .@"scroll-margin-left" => LengthPercentageOrAuto,
+            .@"scroll-margin-right" => LengthPercentageOrAuto,
+            .@"scroll-margin-block-start" => LengthPercentageOrAuto,
+            .@"scroll-margin-block-end" => LengthPercentageOrAuto,
+            .@"scroll-margin-inline-start" => LengthPercentageOrAuto,
+            .@"scroll-margin-inline-end" => LengthPercentageOrAuto,
+            .@"scroll-margin-block" => ScrollMarginBlock,
+            .@"scroll-margin-inline" => ScrollMarginInline,
+            .@"scroll-margin" => ScrollMargin,
+            .@"scroll-padding-top" => LengthPercentageOrAuto,
+            .@"scroll-padding-bottom" => LengthPercentageOrAuto,
+            .@"scroll-padding-left" => LengthPercentageOrAuto,
+            .@"scroll-padding-right" => LengthPercentageOrAuto,
+            .@"scroll-padding-block-start" => LengthPercentageOrAuto,
+            .@"scroll-padding-block-end" => LengthPercentageOrAuto,
+            .@"scroll-padding-inline-start" => LengthPercentageOrAuto,
+            .@"scroll-padding-inline-end" => LengthPercentageOrAuto,
+            .@"scroll-padding-block" => ScrollPaddingBlock,
+            .@"scroll-padding-inline" => ScrollPaddingInline,
+            .@"scroll-padding" => ScrollPadding,
+            .@"font-weight" => FontWeight,
+            .@"font-size" => FontSize,
+            .@"font-stretch" => FontStretch,
+            .@"font-family" => BabyList(FontFamily),
+            .@"font-style" => FontStyle,
+            .@"font-variant-caps" => FontVariantCaps,
+            .@"line-height" => LineHeight,
+            .font => Font,
+            .@"text-decoration-color" => CssColor,
+            .@"text-emphasis-color" => CssColor,
+            .@"text-shadow" => SmallList(TextShadow, 1),
+            .direction => Direction,
+            .composes => Composes,
+            .@"mask-image" => SmallList(Image, 1),
+            .@"mask-mode" => SmallList(MaskMode, 1),
+            .@"mask-repeat" => SmallList(BackgroundRepeat, 1),
+            .@"mask-position-x" => SmallList(HorizontalPosition, 1),
+            .@"mask-position-y" => SmallList(VerticalPosition, 1),
+            .@"mask-position" => SmallList(Position, 1),
+            .@"mask-clip" => SmallList(MaskClip, 1),
+            .@"mask-origin" => SmallList(GeometryBox, 1),
+            .@"mask-size" => SmallList(BackgroundSize, 1),
+            .@"mask-composite" => SmallList(MaskComposite, 1),
+            .@"mask-type" => MaskType,
+            .mask => SmallList(Mask, 1),
+            .@"mask-border-source" => Image,
+            .@"mask-border-mode" => MaskBorderMode,
+            .@"mask-border-slice" => BorderImageSlice,
+            .@"mask-border-width" => Rect(BorderImageSideWidth),
+            .@"mask-border-outset" => Rect(LengthOrNumber),
+            .@"mask-border-repeat" => BorderImageRepeat,
+            .@"mask-border" => MaskBorder,
+            .@"-webkit-mask-composite" => SmallList(WebKitMaskComposite, 1),
+            .@"mask-source-type" => SmallList(WebKitMaskSourceType, 1),
+            .@"mask-box-image" => BorderImage,
+            .@"mask-box-image-source" => Image,
+            .@"mask-box-image-slice" => BorderImageSlice,
+            .@"mask-box-image-width" => Rect(BorderImageSideWidth),
+            .@"mask-box-image-outset" => Rect(LengthOrNumber),
+            .@"mask-box-image-repeat" => BorderImageRepeat,
+            .all => CSSWideKeyword,
+            .unparsed => UnparsedProperty,
+            .custom => CustomProperty,
+        };
+    }
+};
diff --git a/src/css/properties/properties_impl.zig b/src/css/properties/properties_impl.zig
new file mode 100644
index 0000000000..6a56e20d0e
--- /dev/null
+++ b/src/css/properties/properties_impl.zig
@@ -0,0 +1,119 @@
+const std = @import("std");
+const bun = @import("root").bun;
+const Allocator = std.mem.Allocator;
+
+pub const css = @import("../css_parser.zig");
+
+const CustomPropertyName = css.css_properties.CustomPropertyName;
+
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const VendorPrefix = css.VendorPrefix;
+const Error = css.Error;
+
+const PropertyId = css.PropertyId;
+const Property = css.Property;
+
+pub fn PropertyIdImpl() type {
+    return struct {
+        pub fn toCss(this: *const PropertyId, comptime W: type, dest: *Printer(W)) PrintErr!void {
+            var first = true;
+            const name = this.name(this);
+            const prefix_value = this.prefix().orNone();
+            inline for (VendorPrefix.FIELDS) |field| {
+                if (@field(prefix_value, field)) {
+                    var prefix: VendorPrefix = .{};
+                    @field(prefix, field) = true;
+
+                    if (first) {
+                        first = false;
+                    } else {
+                        try dest.delim(',', false);
+                    }
+                    try prefix.toCss(W, dest);
+                    try dest.writeStr(name);
+                }
+            }
+        }
+
+        pub fn parse(input: *css.Parser) css.Result(PropertyId) {
+            const name = switch (input.expectIdent()) {
+                .result => |v| v,
+                .err => |e| return .{ .err = e },
+            };
+            return .{ .result = fromString(name) };
+        }
+
+        pub fn fromStr(name: []const u8) PropertyId {
+            return fromString(name);
+        }
+
+        pub fn fromString(name_: []const u8) PropertyId {
+            const name_ref = name_;
+            var prefix: VendorPrefix = undefined;
+            var trimmed_name: []const u8 = undefined;
+
+            // TODO: todo_stuff.match_ignore_ascii_case
+            if (bun.strings.startsWithCaseInsensitiveAscii(name_ref, "-webkit-")) {
+                prefix = VendorPrefix{ .webkit = true };
+                trimmed_name = name_ref[8..];
+            } else if (bun.strings.startsWithCaseInsensitiveAscii(name_ref, "-moz-")) {
+                prefix = VendorPrefix{ .moz = true };
+                trimmed_name = name_ref[5..];
+            } else if (bun.strings.startsWithCaseInsensitiveAscii(name_ref, "-o-")) {
+                prefix = VendorPrefix{ .o = true };
+                trimmed_name = name_ref[3..];
+            } else if (bun.strings.startsWithCaseInsensitiveAscii(name_ref, "-ms-")) {
+                prefix = VendorPrefix{ .ms = true };
+                trimmed_name = name_ref[4..];
+            } else {
+                prefix = VendorPrefix{ .none = true };
+                trimmed_name = name_ref;
+            }
+
+            return PropertyId.fromNameAndPrefix(trimmed_name, prefix) orelse .{ .custom = CustomPropertyName.fromStr(name_) };
+        }
+    };
+}
+
+pub fn PropertyImpl() type {
+    return struct {
+        /// Serializes the CSS property, with an optional `!important` flag.
+        pub fn toCss(this: *const Property, comptime W: type, dest: *Printer(W), important: bool) PrintErr!void {
+            if (this.* == .custom) {
+                try this.custom.name.toCss(W, dest);
+                try dest.delim(':', false);
+                try this.valueToCss(W, dest);
+                if (important) {
+                    try dest.whitespace();
+                    try dest.writeStr("!important");
+                }
+                return;
+            }
+            const name, const prefix = this.__toCssHelper();
+            var first = true;
+
+            inline for (VendorPrefix.FIELDS) |field| {
+                if (@field(prefix, field)) {
+                    var p: VendorPrefix = .{};
+                    @field(p, field) = true;
+
+                    if (first) {
+                        first = false;
+                    } else {
+                        try dest.writeChar(';');
+                        try dest.newline();
+                    }
+                    try p.toCss(W, dest);
+                    try dest.writeStr(name);
+                    try dest.delim(':', false);
+                    try this.valueToCss(W, dest);
+                    if (important) {
+                        try dest.whitespace();
+                        try dest.writeStr("!important");
+                    }
+                }
+            }
+        }
+    };
+}
diff --git a/src/css/properties/shape.zig b/src/css/properties/shape.zig
new file mode 100644
index 0000000000..5d815259dc
--- /dev/null
+++ b/src/css/properties/shape.zig
@@ -0,0 +1,47 @@
+const std = @import("std");
+const bun = @import("root").bun;
+const Allocator = std.mem.Allocator;
+const ArrayList = std.ArrayListUnmanaged;
+
+pub const css = @import("../css_parser.zig");
+
+const SmallList = css.SmallList;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const Error = css.Error;
+
+const ContainerName = css.css_rules.container.ContainerName;
+
+const LengthPercentage = css.css_values.length.LengthPercentage;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CSSString = css.css_values.string.CSSString;
+const CSSNumber = css.css_values.number.CSSNumber;
+const LengthPercentageOrAuto = css.css_values.length.LengthPercentageOrAuto;
+const Size2D = css.css_values.size.Size2D;
+const DashedIdent = css.css_values.ident.DashedIdent;
+const Image = css.css_values.image.Image;
+const CssColor = css.css_values.color.CssColor;
+const Ratio = css.css_values.ratio.Ratio;
+const Length = css.css_values.length.LengthValue;
+const Rect = css.css_values.rect.Rect;
+const NumberOrPercentage = css.css_values.percentage.NumberOrPercentage;
+const CustomIdentList = css.css_values.ident.CustomIdentList;
+const Angle = css.css_values.angle.Angle;
+const Url = css.css_values.url.Url;
+
+const GenericBorder = css.css_properties.border.GenericBorder;
+const LineStyle = css.css_properties.border.LineStyle;
+
+/// A [`<fill-rule>`](https://www.w3.org/TR/css-shapes-1/#typedef-fill-rule) used to
+/// determine the interior of a `polygon()` shape.
+///
+/// See [Polygon](Polygon).
+pub const FillRule = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A CSS [`<alpha-value>`](https://www.w3.org/TR/css-color-4/#typedef-alpha-value),
+/// used to represent opacity.
+///
+/// Parses either a `<number>` or `<percentage>`, but is always stored and serialized as a number.
+pub const AlphaValue = struct {
+    v: f32,
+};
diff --git a/src/css/properties/size.zig b/src/css/properties/size.zig
new file mode 100644
index 0000000000..c0f48f137e
--- /dev/null
+++ b/src/css/properties/size.zig
@@ -0,0 +1,626 @@
+const std = @import("std");
+const bun = @import("root").bun;
+const Allocator = std.mem.Allocator;
+const ArrayList = std.ArrayListUnmanaged;
+
+pub const css = @import("../css_parser.zig");
+
+const SmallList = css.SmallList;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const Error = css.Error;
+
+const PropertyId = css.PropertyId;
+const PropertyIdTag = css.PropertyIdTag;
+const Property = css.Property;
+const UnparsedProperty = css.css_properties.custom.UnparsedProperty;
+
+const PropertyCategory = css.logical.PropertyCategory;
+
+const ContainerName = css.css_rules.container.ContainerName;
+
+const LengthPercentage = css.css_values.length.LengthPercentage;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CSSString = css.css_values.string.CSSString;
+const CSSNumber = css.css_values.number.CSSNumber;
+const LengthPercentageOrAuto = css.css_values.length.LengthPercentageOrAuto;
+const Size2D = css.css_values.size.Size2D;
+const DashedIdent = css.css_values.ident.DashedIdent;
+const Image = css.css_values.image.Image;
+const CssColor = css.css_values.color.CssColor;
+const Ratio = css.css_values.ratio.Ratio;
+const Length = css.css_values.length.LengthValue;
+const Rect = css.css_values.rect.Rect;
+const NumberOrPercentage = css.css_values.percentage.NumberOrPercentage;
+const CustomIdentList = css.css_values.ident.CustomIdentList;
+const Angle = css.css_values.angle.Angle;
+const Url = css.css_values.url.Url;
+
+const GenericBorder = css.css_properties.border.GenericBorder;
+const LineStyle = css.css_properties.border.LineStyle;
+
+pub const BoxSizing = enum {
+    /// Exclude the margin/border/padding from the width and height.
+    @"content-box",
+    /// Include the padding and border (but not the margin) in the width and height.
+    @"border-box",
+    pub usingnamespace css.DefineEnumProperty(@This());
+};
+
+pub const Size = union(enum) {
+    /// The `auto` keyworda
+    auto,
+    /// An explicit length or percentage.
+    length_percentage: LengthPercentage,
+    /// The `min-content` keyword.
+    min_content: css.VendorPrefix,
+    /// The `max-content` keyword.
+    max_content: css.VendorPrefix,
+    /// The `fit-content` keyword.
+    fit_content: css.VendorPrefix,
+    /// The `fit-content()` function.
+    fit_content_function: LengthPercentage,
+    /// The `stretch` keyword, or the `-webkit-fill-available` or `-moz-available` prefixed keywords.
+    stretch: css.VendorPrefix,
+    /// The `contain` keyword.
+    contain,
+
+    pub fn parse(input: *css.Parser) css.Result(Size) {
+        const Enum = enum {
+            auto,
+            @"min-content",
+            @"-webkit-min-content",
+            @"-moz-min-content",
+            @"max-content",
+            @"-webkit-max-content",
+            @"-moz-max-content",
+            stretch,
+            @"-webkit-fill-available",
+            @"-moz-available",
+            @"fit-content",
+            @"-webkit-fit-content",
+            @"-moz-fit-content",
+            contain,
+        };
+        const Map = comptime bun.ComptimeEnumMap(Enum);
+        const res = input.tryParse(struct {
+            pub fn parseFn(i: *css.Parser) css.Result(Size) {
+                const ident = switch (i.expectIdent()) {
+                    .result => |v| v,
+                    .err => |e| return .{ .err = e },
+                };
+
+                if (Map.getASCIIICaseInsensitive(ident)) |res| {
+                    return .{ .result = switch (res) {
+                        .auto => .auto,
+                        .@"min-content" => .{ .min_content = css.VendorPrefix{ .none = true } },
+                        .@"-webkit-min-content" => .{ .min_content = css.VendorPrefix{ .webkit = true } },
+                        .@"-moz-min-content" => .{ .min_content = css.VendorPrefix{ .moz = true } },
+                        .@"max-content" => .{ .max_content = css.VendorPrefix{ .none = true } },
+                        .@"-webkit-max-content" => .{ .max_content = css.VendorPrefix{ .webkit = true } },
+                        .@"-moz-max-content" => .{ .max_content = css.VendorPrefix{ .moz = true } },
+                        .stretch => .{ .stretch = css.VendorPrefix{ .none = true } },
+                        .@"-webkit-fill-available" => .{ .stretch = css.VendorPrefix{ .webkit = true } },
+                        .@"-moz-available" => .{ .stretch = css.VendorPrefix{ .moz = true } },
+                        .@"fit-content" => .{ .fit_content = css.VendorPrefix{ .none = true } },
+                        .@"-webkit-fit-content" => .{ .fit_content = css.VendorPrefix{ .webkit = true } },
+                        .@"-moz-fit-content" => .{ .fit_content = css.VendorPrefix{ .moz = true } },
+                        .contain => .contain,
+                    } };
+                } else return .{ .err = i.newCustomError(css.ParserError.invalid_value) };
+            }
+        }.parseFn, .{});
+
+        if (res == .result) return res;
+
+        if (input.tryParse(parseFitContent, .{}).asValue()) |v| {
+            return .{ .result = Size{ .fit_content_function = v } };
+        }
+
+        const lp = switch (input.tryParse(LengthPercentage.parse, .{})) {
+            .result => |v| v,
+            .err => |e| return .{ .err = e },
+        };
+        return .{ .result = Size{ .length_percentage = lp } };
+    }
+
+    pub fn toCss(this: *const Size, comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+        return switch (this.*) {
+            .auto => dest.writeStr("auto"),
+            .contain => dest.writeStr("contain"),
+            .min_content => |vp| {
+                try vp.toCss(W, dest);
+                try dest.writeStr("min-content");
+            },
+            .max_content => |vp| {
+                try vp.toCss(W, dest);
+                try dest.writeStr("max-content");
+            },
+            .fit_content => |vp| {
+                try vp.toCss(W, dest);
+                try dest.writeStr("fit-content");
+            },
+            .stretch => |vp| {
+                if (vp.eql(css.VendorPrefix{ .none = true })) {
+                    try dest.writeStr("stretch");
+                } else if (vp.eql(css.VendorPrefix{ .webkit = true })) {
+                    try dest.writeStr("-webkit-fill-available");
+                } else if (vp.eql(css.VendorPrefix{ .moz = true })) {
+                    try dest.writeStr("-moz-available");
+                } else {
+                    bun.unreachablePanic("Unexpected vendor prefixes", .{});
+                }
+            },
+            .fit_content_function => |l| {
+                try dest.writeStr("fit-content(");
+                try l.toCss(W, dest);
+                try dest.writeChar(')');
+            },
+            .length_percentage => |l| return l.toCss(W, dest),
+        };
+    }
+
+    pub fn isCompatible(this: *const @This(), browsers: css.targets.Browsers) bool {
+        const F = css.compat.Feature;
+        return switch (this.*) {
+            .length_percentage => |*l| l.isCompatible(browsers),
+            .min_content => F.isCompatible(.min_content_size, browsers),
+            .max_content => F.isCompatible(.max_content_size, browsers),
+            .fit_content => F.isCompatible(.fit_content_size, browsers),
+            .fit_content_function => |*l| F.isCompatible(.fit_content_function_size, browsers) and l.isCompatible(browsers),
+            .stretch => |*vp| F.isCompatible(switch (vp.asBits()) {
+                css.VendorPrefix.NONE.asBits() => F.stretch_size,
+                css.VendorPrefix.WEBKIT.asBits() => F.webkit_fill_available_size,
+                css.VendorPrefix.MOZ.asBits() => F.moz_available_size,
+                else => return false,
+            }, browsers),
+            .contain => false, // ??? no data in mdn
+            .auto => true,
+        };
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+/// A value for the [minimum](https://drafts.csswg.org/css-sizing-3/#min-size-properties)
+/// and [maximum](https://drafts.csswg.org/css-sizing-3/#max-size-properties) size properties,
+/// e.g. `min-width` and `max-height`.
+pub const MaxSize = union(enum) {
+    /// The `none` keyword.
+    none,
+    /// An explicit length or percentage.
+    length_percentage: LengthPercentage,
+    /// The `min-content` keyword.
+    min_content: css.VendorPrefix,
+    /// The `max-content` keyword.
+    max_content: css.VendorPrefix,
+    /// The `fit-content` keyword.
+    fit_content: css.VendorPrefix,
+    /// The `fit-content()` function.
+    fit_content_function: LengthPercentage,
+    /// The `stretch` keyword, or the `-webkit-fill-available` or `-moz-available` prefixed keywords.
+    stretch: css.VendorPrefix,
+    /// The `contain` keyword.
+    contain,
+
+    pub fn parse(input: *css.Parser) css.Result(MaxSize) {
+        const Ident = enum {
+            none,
+            min_content,
+            webkit_min_content,
+            moz_min_content,
+            max_content,
+            webkit_max_content,
+            moz_max_content,
+            stretch,
+            webkit_fill_available,
+            moz_available,
+            fit_content,
+            webkit_fit_content,
+            moz_fit_content,
+            contain,
+        };
+
+        const IdentMap = bun.ComptimeStringMap(Ident, .{
+            .{ "none", .none },
+            .{ "min-content", .min_content },
+            .{ "-webkit-min-content", .webkit_min_content },
+            .{ "-moz-min-content", .moz_min_content },
+            .{ "max-content", .max_content },
+            .{ "-webkit-max-content", .webkit_max_content },
+            .{ "-moz-max-content", .moz_max_content },
+            .{ "stretch", .stretch },
+            .{ "-webkit-fill-available", .webkit_fill_available },
+            .{ "-moz-available", .moz_available },
+            .{ "fit-content", .fit_content },
+            .{ "-webkit-fit-content", .webkit_fit_content },
+            .{ "-moz-fit-content", .moz_fit_content },
+            .{ "contain", .contain },
+        });
+
+        const res = input.tryParse(struct {
+            fn parse(i: *css.Parser) css.Result(MaxSize) {
+                const ident = switch (i.expectIdent()) {
+                    .result => |v| v,
+                    .err => |e| return .{ .err = e },
+                };
+                const mapped = IdentMap.getASCIIICaseInsensitive(ident) orelse return .{ .err = i.newCustomError(css.ParserError.invalid_value) };
+                return .{ .result = switch (mapped) {
+                    .none => .none,
+                    .min_content => .{ .min_content = .{ .none = true } },
+                    .webkit_min_content => .{ .min_content = .{ .webkit = true } },
+                    .moz_min_content => .{ .min_content = .{ .moz = true } },
+                    .max_content => .{ .max_content = .{ .none = true } },
+                    .webkit_max_content => .{ .max_content = .{ .webkit = true } },
+                    .moz_max_content => .{ .max_content = .{ .moz = true } },
+                    .stretch => .{ .stretch = .{ .none = true } },
+                    .webkit_fill_available => .{ .stretch = .{ .webkit = true } },
+                    .moz_available => .{ .stretch = .{ .moz = true } },
+                    .fit_content => .{ .fit_content = .{ .none = true } },
+                    .webkit_fit_content => .{ .fit_content = .{ .webkit = true } },
+                    .moz_fit_content => .{ .fit_content = .{ .moz = true } },
+                    .contain => .contain,
+                } };
+            }
+        }.parse, .{});
+
+        if (res.isOk()) {
+            return res;
+        }
+
+        if (input.tryParse(parseFitContent, .{}).asValue()) |v| {
+            return .{ .result = .{ .fit_content_function = v } };
+        }
+
+        return switch (input.tryParse(LengthPercentage.parse, .{})) {
+            .result => |v| .{ .result = .{ .length_percentage = v } },
+            .err => |e| .{ .err = e },
+        };
+    }
+
+    pub fn toCss(this: *const MaxSize, comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+        switch (this.*) {
+            .none => try dest.writeStr("none"),
+            .contain => try dest.writeStr("contain"),
+            .min_content => |vp| {
+                try vp.toCss(W, dest);
+                try dest.writeStr("min-content");
+            },
+            .max_content => |vp| {
+                try vp.toCss(W, dest);
+                try dest.writeStr("max-content");
+            },
+            .fit_content => |vp| {
+                try vp.toCss(W, dest);
+                try dest.writeStr("fit-content");
+            },
+            .stretch => |vp| {
+                if (css.VendorPrefix.eql(vp, css.VendorPrefix{ .none = true })) {
+                    try dest.writeStr("stretch");
+                } else if (css.VendorPrefix.eql(vp, css.VendorPrefix{ .webkit = true })) {
+                    try dest.writeStr("-webkit-fill-available");
+                } else if (css.VendorPrefix.eql(vp, css.VendorPrefix{ .moz = true })) {
+                    try dest.writeStr("-moz-available");
+                } else {
+                    bun.unreachablePanic("Unexpected vendor prefixes", .{});
+                }
+            },
+            .fit_content_function => |l| {
+                try dest.writeStr("fit-content(");
+                try l.toCss(W, dest);
+                try dest.writeChar(')');
+            },
+            .length_percentage => |l| try l.toCss(W, dest),
+        }
+    }
+
+    pub fn isCompatible(this: *const @This(), browsers: css.targets.Browsers) bool {
+        const F = css.compat.Feature;
+        return switch (this.*) {
+            .length_percentage => |*l| l.isCompatible(browsers),
+            .min_content => F.isCompatible(.min_content_size, browsers),
+            .max_content => F.isCompatible(.max_content_size, browsers),
+            .fit_content => F.isCompatible(.fit_content_size, browsers),
+            .fit_content_function => |*l| F.isCompatible(F.fit_content_function_size, browsers) and l.isCompatible(browsers),
+            .stretch => |*vp| F.isCompatible(
+                switch (vp.asBits()) {
+                    css.VendorPrefix.NONE.asBits() => F.stretch_size,
+                    css.VendorPrefix.WEBKIT.asBits() => F.webkit_fill_available_size,
+                    css.VendorPrefix.MOZ.asBits() => F.moz_available_size,
+                    else => return false,
+                },
+                browsers,
+            ),
+            .contain => false, // ??? no data in mdn
+            .none => true,
+        };
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+/// A value for the [aspect-ratio](https://drafts.csswg.org/css-sizing-4/#aspect-ratio) property.
+pub const AspectRatio = struct {
+    /// The `auto` keyword.
+    auto: bool,
+    /// A preferred aspect ratio for the box, specified as width / height.
+    ratio: ?Ratio,
+
+    pub fn parse(input: *css.Parser) css.Result(AspectRatio) {
+        const location = input.currentSourceLocation();
+        var auto = input.tryParse(css.Parser.expectIdentMatching, .{"auto"});
+
+        const ratio = input.tryParse(Ratio.parse, .{});
+        if (auto.isErr()) {
+            auto = input.tryParse(css.Parser.expectIdentMatching, .{"auto"});
+        }
+        if (auto.isErr() and ratio.isErr()) {
+            return .{ .err = location.newCustomError(css.ParserError{ .invalid_value = {} }) };
+        }
+
+        return .{
+            .result = AspectRatio{
+                .auto = auto.isOk(),
+                .ratio = ratio.asValue(),
+            },
+        };
+    }
+
+    pub fn toCss(this: *const AspectRatio, comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+        if (this.auto) {
+            try dest.writeStr("auto");
+        }
+
+        if (this.ratio) |*ratio| {
+            if (this.auto) try dest.writeChar(' ');
+            try ratio.toCss(W, dest);
+        }
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
+
+fn parseFitContent(input: *css.Parser) css.Result(LengthPercentage) {
+    if (input.expectFunctionMatching("fit-content").asErr()) |e| return .{ .err = e };
+    return input.parseNestedBlock(LengthPercentage, {}, css.voidWrap(LengthPercentage, LengthPercentage.parse));
+}
+
+pub const SizeProperty = packed struct(u16) {
+    width: bool = false,
+    height: bool = false,
+    @"min-width": bool = false,
+    @"min-height": bool = false,
+    @"max-width": bool = false,
+    @"max-height": bool = false,
+    @"block-size": bool = false,
+    @"inline-size": bool = false,
+    @"min-block-size": bool = false,
+    @"min-inline-size": bool = false,
+    @"max-block-size": bool = false,
+    @"max-inline-size": bool = false,
+    __unused: u4 = 0,
+
+    pub usingnamespace css.Bitflags(@This());
+
+    pub fn tryFromPropertyIdTag(property_id: PropertyIdTag) ?SizeProperty {
+        inline for (std.meta.fields(@This())) |field| {
+            if (comptime std.mem.eql(u8, field.name, "__unused")) continue;
+            if (@intFromEnum(@field(PropertyIdTag, field.name)) == @intFromEnum(@as(PropertyIdTag, property_id))) {
+                var ret: SizeProperty = .{};
+                @field(ret, field.name) = true;
+                return ret;
+            }
+        }
+        return null;
+    }
+};
+
+pub const SizeHandler = struct {
+    width: ?Size = null,
+    height: ?Size = null,
+    min_width: ?Size = null,
+    min_height: ?Size = null,
+    max_width: ?MaxSize = null,
+    max_height: ?MaxSize = null,
+    block_size: ?Size = null,
+    inline_size: ?Size = null,
+    min_block_size: ?Size = null,
+    min_inline_size: ?Size = null,
+    max_block_size: ?MaxSize = null,
+    max_inline_size: ?MaxSize = null,
+    has_any: bool = false,
+    flushed_properties: SizeProperty = .{},
+    category: PropertyCategory = PropertyCategory.default(),
+
+    const Feature = css.Feature;
+
+    pub fn handleProperty(this: *@This(), property: *const Property, dest: *css.DeclarationList, context: *css.PropertyHandlerContext) bool {
+        const logical_supported = !context.shouldCompileLogical(Feature.logical_size);
+
+        switch (property.*) {
+            .width => |*v| this.propertyHelper("width", Size, v, PropertyCategory.physical, dest, context),
+            .height => |*v| this.propertyHelper("height", Size, v, PropertyCategory.physical, dest, context),
+            .@"min-width" => |*v| this.propertyHelper("min_width", Size, v, PropertyCategory.physical, dest, context),
+            .@"min-height" => |*v| this.propertyHelper("min_height", Size, v, PropertyCategory.physical, dest, context),
+            .@"max-width" => |*v| this.propertyHelper("max_width", MaxSize, v, PropertyCategory.physical, dest, context),
+            .@"max-height" => |*v| this.propertyHelper("max_height", MaxSize, v, PropertyCategory.physical, dest, context),
+            .@"block-size" => |*v| this.propertyHelper("block_size", Size, v, PropertyCategory.logical, dest, context),
+            .@"min-block-size" => |*v| this.propertyHelper("min_block_size", Size, v, PropertyCategory.logical, dest, context),
+            .@"max-block-size" => |*v| this.propertyHelper("max_block_size", MaxSize, v, PropertyCategory.logical, dest, context),
+            .@"inline-size" => |*v| this.propertyHelper("inline_size", Size, v, PropertyCategory.logical, dest, context),
+            .@"min-inline-size" => |*v| this.propertyHelper("min_inline_size", Size, v, PropertyCategory.logical, dest, context),
+            .@"max-inline-size" => |*v| this.propertyHelper("max_inline_size", MaxSize, v, PropertyCategory.logical, dest, context),
+            .unparsed => |*unparsed| {
+                switch (unparsed.property_id) {
+                    .width, .height, .@"min-width", .@"max-width", .@"min-height", .@"max-height" => {
+                        this.flushed_properties.insert(SizeProperty.tryFromPropertyIdTag(@as(PropertyIdTag, unparsed.property_id)).?);
+                        dest.append(context.allocator, property.deepClone(context.allocator)) catch unreachable;
+                    },
+                    .@"block-size" => this.logicalUnparsedHelper(property, unparsed, .height, logical_supported, dest, context),
+                    .@"min-block-size" => this.logicalUnparsedHelper(property, unparsed, .@"min-height", logical_supported, dest, context),
+                    .@"max-block-size" => this.logicalUnparsedHelper(property, unparsed, .@"max-height", logical_supported, dest, context),
+                    .@"inline-size" => this.logicalUnparsedHelper(property, unparsed, .width, logical_supported, dest, context),
+                    .@"min-inline-size" => this.logicalUnparsedHelper(property, unparsed, .@"min-width", logical_supported, dest, context),
+                    .@"max-inline-size" => this.logicalUnparsedHelper(property, unparsed, .@"max-width", logical_supported, dest, context),
+                    else => return false,
+                }
+            },
+            else => return false,
+        }
+
+        return true;
+    }
+
+    inline fn logicalUnparsedHelper(this: *@This(), property: *const Property, unparsed: *const UnparsedProperty, comptime physical: PropertyIdTag, logical_supported: bool, dest: *css.DeclarationList, context: *css.PropertyHandlerContext) void {
+        if (logical_supported) {
+            this.flushed_properties.insert(SizeProperty.tryFromPropertyIdTag(@as(PropertyIdTag, unparsed.property_id)).?);
+            dest.append(context.allocator, property.deepClone(context.allocator)) catch bun.outOfMemory();
+        } else {
+            dest.append(context.allocator, Property{
+                .unparsed = unparsed.withPropertyId(
+                    context.allocator,
+                    @unionInit(PropertyId, @tagName(physical), {}),
+                ),
+            }) catch bun.outOfMemory();
+            this.flushed_properties.insert(SizeProperty.fromName(@tagName(physical)));
+        }
+    }
+
+    inline fn propertyHelper(
+        this: *@This(),
+        comptime property: []const u8,
+        comptime T: type,
+        value: *const T,
+        comptime category: PropertyCategory,
+        dest: *css.DeclarationList,
+        context: *css.PropertyHandlerContext,
+    ) void {
+        // If the category changes betweet logical and physical,
+        // or if the value contains syntax that isn't supported across all targets,
+        // preserve the previous value as a fallback.
+
+        if (@field(PropertyCategory, @tagName(category)) != this.category or (@field(this, property) != null and context.targets.browsers != null and !value.isCompatible(context.targets.browsers.?))) {
+            this.flush(dest, context);
+        }
+
+        @field(this, property) = value.deepClone(context.allocator);
+        this.category = category;
+        this.has_any = true;
+    }
+
+    pub fn flush(this: *@This(), dest: *css.DeclarationList, context: *css.PropertyHandlerContext) void {
+        if (!this.has_any) return;
+
+        this.has_any = false;
+        const logical_supported = !context.shouldCompileLogical(Feature.logical_size);
+
+        this.flushPropertyHelper(PropertyIdTag.width, "width", Size, dest, context);
+        this.flushPropertyHelper(PropertyIdTag.@"min-width", "min_width", Size, dest, context);
+        this.flushPropertyHelper(PropertyIdTag.@"max-width", "max_width", MaxSize, dest, context);
+        this.flushPropertyHelper(PropertyIdTag.height, "height", Size, dest, context);
+        this.flushPropertyHelper(PropertyIdTag.@"min-height", "min_height", Size, dest, context);
+        this.flushPropertyHelper(PropertyIdTag.@"max-height", "max_height", MaxSize, dest, context);
+        this.flushLogicalHelper(PropertyIdTag.@"block-size", "block_size", PropertyIdTag.height, Size, logical_supported, dest, context);
+        this.flushLogicalHelper(PropertyIdTag.@"min-block-size", "min_block_size", PropertyIdTag.@"min-height", Size, logical_supported, dest, context);
+        this.flushLogicalHelper(PropertyIdTag.@"max-block-size", "max_block_size", PropertyIdTag.@"max-height", MaxSize, logical_supported, dest, context);
+        this.flushLogicalHelper(PropertyIdTag.@"inline-size", "inline_size", PropertyIdTag.width, Size, logical_supported, dest, context);
+        this.flushLogicalHelper(PropertyIdTag.@"min-inline-size", "min_inline_size", PropertyIdTag.@"min-width", Size, logical_supported, dest, context);
+        this.flushLogicalHelper(PropertyIdTag.@"max-inline-size", "max_inline_size", PropertyIdTag.@"max-width", MaxSize, logical_supported, dest, context);
+    }
+
+    pub fn finalize(this: *@This(), dest: *css.DeclarationList, context: *css.PropertyHandlerContext) void {
+        this.flush(dest, context);
+        this.flushed_properties = SizeProperty.empty();
+    }
+
+    inline fn flushPrefixHelper(
+        this: *@This(),
+        comptime property: PropertyIdTag,
+        comptime SizeType: type,
+        comptime feature: css.prefixes.Feature,
+        dest: *css.DeclarationList,
+        context: *css.PropertyHandlerContext,
+    ) void {
+        if (!this.flushed_properties.contains(comptime SizeProperty.fromName(@tagName(property)))) {
+            const prefixes = context.targets.prefixes(css.VendorPrefix{ .none = true }, feature).difference(css.VendorPrefix{ .none = true });
+            inline for (css.VendorPrefix.FIELDS) |field| {
+                if (@field(prefixes, field)) {
+                    var prefix: css.VendorPrefix = .{};
+                    @field(prefix, field) = true;
+                    dest.append(
+                        context.allocator,
+                        @unionInit(
+                            Property,
+                            @tagName(property),
+                            @unionInit(SizeType, @tagName(feature), prefix),
+                        ),
+                    ) catch bun.outOfMemory();
+                }
+            }
+        }
+    }
+
+    inline fn flushPropertyHelper(
+        this: *@This(),
+        comptime property: PropertyIdTag,
+        comptime field: []const u8,
+        comptime SizeType: type,
+        dest: *css.DeclarationList,
+        context: *css.PropertyHandlerContext,
+    ) void {
+        if (bun.take(&@field(this, field))) |val| {
+            switch (val) {
+                .stretch => |vp| if (vp.eql(css.VendorPrefix{ .none = true })) {
+                    this.flushPrefixHelper(property, SizeType, .stretch, dest, context);
+                },
+                .min_content => |vp| if (vp.eql(css.VendorPrefix{ .none = true })) {
+                    this.flushPrefixHelper(property, SizeType, .min_content, dest, context);
+                },
+                .max_content => |vp| if (vp.eql(css.VendorPrefix{ .none = true })) {
+                    this.flushPrefixHelper(property, SizeType, .max_content, dest, context);
+                },
+                .fit_content => |vp| if (vp.eql(css.VendorPrefix{ .none = true })) {
+                    this.flushPrefixHelper(property, SizeType, .fit_content, dest, context);
+                },
+                else => {},
+            }
+            dest.append(context.allocator, @unionInit(Property, @tagName(property), val.deepClone(context.allocator))) catch bun.outOfMemory();
+            this.flushed_properties.insert(comptime SizeProperty.fromName(@tagName(property)));
+        }
+    }
+
+    inline fn flushLogicalHelper(
+        this: *@This(),
+        comptime property: PropertyIdTag,
+        comptime field: []const u8,
+        comptime physical: PropertyIdTag,
+        comptime SizeType: type,
+        logical_supported: bool,
+        dest: *css.DeclarationList,
+        context: *css.PropertyHandlerContext,
+    ) void {
+        if (logical_supported) {
+            this.flushPropertyHelper(property, field, SizeType, dest, context);
+        } else {
+            this.flushPropertyHelper(physical, field, SizeType, dest, context);
+        }
+    }
+};
diff --git a/src/css/properties/svg.zig b/src/css/properties/svg.zig
new file mode 100644
index 0000000000..b46734d7cb
--- /dev/null
+++ b/src/css/properties/svg.zig
@@ -0,0 +1,100 @@
+const std = @import("std");
+const bun = @import("root").bun;
+const Allocator = std.mem.Allocator;
+const ArrayList = std.ArrayListUnmanaged;
+
+pub const css = @import("../css_parser.zig");
+
+const SmallList = css.SmallList;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const Error = css.Error;
+
+const ContainerName = css.css_rules.container.ContainerName;
+
+const LengthPercentage = css.css_values.length.LengthPercentage;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CSSString = css.css_values.string.CSSString;
+const CSSNumber = css.css_values.number.CSSNumber;
+const LengthPercentageOrAuto = css.css_values.length.LengthPercentageOrAuto;
+const Size2D = css.css_values.size.Size2D;
+const DashedIdent = css.css_values.ident.DashedIdent;
+const Image = css.css_values.image.Image;
+const CssColor = css.css_values.color.CssColor;
+const Ratio = css.css_values.ratio.Ratio;
+const Length = css.css_values.length.LengthValue;
+const Rect = css.css_values.rect.Rect;
+const NumberOrPercentage = css.css_values.percentage.NumberOrPercentage;
+const CustomIdentList = css.css_values.ident.CustomIdentList;
+const Angle = css.css_values.angle.Angle;
+const Url = css.css_values.url.Url;
+
+const GenericBorder = css.css_properties.border.GenericBorder;
+const LineStyle = css.css_properties.border.LineStyle;
+
+/// An SVG [`<paint>`](https://www.w3.org/TR/SVG2/painting.html#SpecifyingPaint) value
+/// used in the `fill` and `stroke` properties.
+const SVGPaint = union(enum) {
+    /// A URL reference to a paint server element, e.g. `linearGradient`, `radialGradient`, and `pattern`.
+    Url: struct {
+        /// The url of the paint server.
+        url: Url,
+        /// A fallback to be used in case the paint server cannot be resolved.
+        fallback: ?SVGPaintFallback,
+    },
+    /// A solid color paint.
+    Color: CssColor,
+    /// Use the paint value of fill from a context element.
+    ContextFill,
+    /// Use the paint value of stroke from a context element.
+    ContextStroke,
+    /// No paint.
+    None,
+};
+
+/// A fallback for an SVG paint in case a paint server `url()` cannot be resolved.
+///
+/// See [SVGPaint](SVGPaint).
+const SVGPaintFallback = union(enum) {
+    /// No fallback.
+    None,
+    /// A solid color.
+    Color: CssColor,
+};
+
+/// A value for the [stroke-linecap](https://www.w3.org/TR/SVG2/painting.html#LineCaps) property.
+pub const StrokeLinecap = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A value for the [stroke-linejoin](https://www.w3.org/TR/SVG2/painting.html#LineJoin) property.
+pub const StrokeLinejoin = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A value for the [stroke-dasharray](https://www.w3.org/TR/SVG2/painting.html#StrokeDashing) property.
+const StrokeDasharray = union(enum) {
+    /// No dashing is used.
+    None,
+    /// Specifies a dashing pattern to use.
+    Values: ArrayList(LengthPercentage),
+};
+
+/// A value for the [marker](https://www.w3.org/TR/SVG2/painting.html#VertexMarkerProperties) properties.
+const Marker = union(enum) {
+    /// No marker.
+    None,
+    /// A url reference to a `<marker>` element.
+    Url: Url,
+};
+
+/// A value for the [color-interpolation](https://www.w3.org/TR/SVG2/painting.html#ColorInterpolation) property.
+pub const ColorInterpolation = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A value for the [color-rendering](https://www.w3.org/TR/SVG2/painting.html#ColorRendering) property.
+pub const ColorRendering = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A value for the [shape-rendering](https://www.w3.org/TR/SVG2/painting.html#ShapeRendering) property.
+pub const ShapeRendering = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A value for the [text-rendering](https://www.w3.org/TR/SVG2/painting.html#TextRendering) property.
+pub const TextRendering = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A value for the [image-rendering](https://www.w3.org/TR/SVG2/painting.html#ImageRendering) property.
+pub const ImageRendering = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
diff --git a/src/css/properties/text.zig b/src/css/properties/text.zig
new file mode 100644
index 0000000000..7ad11f9a05
--- /dev/null
+++ b/src/css/properties/text.zig
@@ -0,0 +1,289 @@
+const std = @import("std");
+const bun = @import("root").bun;
+const Allocator = std.mem.Allocator;
+const ArrayList = std.ArrayListUnmanaged;
+
+pub const css = @import("../css_parser.zig");
+
+const SmallList = css.SmallList;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const Error = css.Error;
+
+const ContainerName = css.css_rules.container.ContainerName;
+
+const LengthPercentage = css.css_values.length.LengthPercentage;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CSSString = css.css_values.string.CSSString;
+const CSSNumber = css.css_values.number.CSSNumber;
+const LengthPercentageOrAuto = css.css_values.length.LengthPercentageOrAuto;
+const Size2D = css.css_values.size.Size2D;
+const DashedIdent = css.css_values.ident.DashedIdent;
+const Image = css.css_values.image.Image;
+const CssColor = css.css_values.color.CssColor;
+const Ratio = css.css_values.ratio.Ratio;
+const Length = css.css_values.length.LengthValue;
+const Rect = css.css_values.rect.Rect;
+const NumberOrPercentage = css.css_values.percentage.NumberOrPercentage;
+const CustomIdentList = css.css_values.ident.CustomIdentList;
+const Angle = css.css_values.angle.Angle;
+const Url = css.css_values.url.Url;
+const Percentage = css.css_values.percentage.Percentage;
+
+const GenericBorder = css.css_properties.border.GenericBorder;
+const LineStyle = css.css_properties.border.LineStyle;
+
+/// A value for the [text-transform](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#text-transform-property) property.
+pub const TextTransform = struct {
+    /// How case should be transformed.
+    case: TextTransformCase,
+    /// How ideographic characters should be transformed.
+    other: TextTransformOther,
+};
+
+pub const TextTransformOther = packed struct(u8) {
+    /// Puts all typographic character units in full-width form.
+    full_width: bool = false,
+    /// Converts all small Kana characters to the equivalent full-size Kana.
+    full_size_kana: bool = false,
+};
+
+/// Defines how text case should be transformed in the
+/// [text-transform](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#text-transform-property) property.
+const TextTransformCase = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A value for the [white-space](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#white-space-property) property.
+pub const WhiteSpace = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A value for the [word-break](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#word-break-property) property.
+pub const WordBreak = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A value for the [line-break](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#line-break-property) property.
+pub const LineBreak = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A value for the [hyphens](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#hyphenation) property.
+pub const Hyphens = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A value for the [overflow-wrap](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#overflow-wrap-property) property.
+pub const OverflowWrap = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A value for the [text-align](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#text-align-property) property.
+pub const TextAlign = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A value for the [text-align-last](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#text-align-last-property) property.
+pub const TextAlignLast = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A value for the [text-justify](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#text-justify-property) property.
+pub const TextJustify = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A value for the [word-spacing](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#word-spacing-property)
+/// and [letter-spacing](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#letter-spacing-property) properties.
+pub const Spacing = union(enum) {
+    /// No additional spacing is applied.
+    normal,
+    /// Additional spacing between each word or letter.
+    length: Length,
+};
+
+/// A value for the [text-indent](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#text-indent-property) property.
+pub const TextIndent = struct {
+    /// The amount to indent.
+    value: LengthPercentage,
+    /// Inverts which lines are affected.
+    hanging: bool,
+    /// Affects the first line after each hard break.
+    each_line: bool,
+};
+
+/// A value for the [text-decoration-line](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-decoration-line-property) property.
+///
+/// Multiple lines may be specified by combining the flags.
+pub const TextDecorationLine = packed struct(u8) {
+    /// Each line of text is underlined.
+    underline: bool = false,
+    /// Each line of text has a line over it.
+    overline: bool = false,
+    /// Each line of text has a line through the middle.
+    line_through: bool = false,
+    /// The text blinks.
+    blink: bool = false,
+    /// The text is decorated as a spelling error.
+    spelling_error: bool = false,
+    /// The text is decorated as a grammar error.
+    grammar_error: bool = false,
+};
+
+/// A value for the [text-decoration-style](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-decoration-style-property) property.
+pub const TextDecorationStyle = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A value for the [text-decoration-thickness](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-decoration-width-property) property.
+pub const TextDecorationThickness = union(enum) {
+    /// The UA chooses an appropriate thickness for text decoration lines.
+    auto,
+    /// Use the thickness defined in the current font.
+    from_font,
+    /// An explicit length.
+    length_percentage: LengthPercentage,
+};
+
+/// A value for the [text-decoration](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-decoration-property) shorthand property.
+pub const TextDecoration = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A value for the [text-decoration-skip-ink](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-decoration-skip-ink-property) property.
+pub const TextDecorationSkipInk = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A text emphasis shape for the [text-emphasis-style](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-emphasis-style-property) property.
+///
+/// See [TextEmphasisStyle](TextEmphasisStyle).
+pub const TextEmphasisStyle = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A value for the [text-emphasis](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-emphasis-property) shorthand property.
+pub const TextEmphasis = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A value for the [text-emphasis-position](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-emphasis-position-property) property.
+pub const TextEmphasisPosition = struct {
+    /// The vertical position.
+    vertical: TextEmphasisPositionVertical,
+    /// The horizontal position.
+    horizontal: TextEmphasisPositionHorizontal,
+};
+
+/// A vertical position keyword for the [text-emphasis-position](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-emphasis-position-property) property.
+///
+/// See [TextEmphasisPosition](TextEmphasisPosition).
+pub const TextEmphasisPositionVertical = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A horizontal position keyword for the [text-emphasis-position](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-emphasis-position-property) property.
+///
+/// See [TextEmphasisPosition](TextEmphasisPosition).
+pub const TextEmphasisPositionHorizontal = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A value for the [text-shadow](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-shadow-property) property.
+pub const TextShadow = struct {
+    /// The color of the text shadow.
+    color: CssColor,
+    /// The x offset of the text shadow.
+    x_offset: Length,
+    /// The y offset of the text shadow.
+    y_offset: Length,
+    /// The blur radius of the text shadow.
+    blur: Length,
+    /// The spread distance of the text shadow.
+    spread: Length, // added in Level 4 spec
+
+    pub fn parse(input: *css.Parser) css.Result(@This()) {
+        var color: ?CssColor = null;
+        const Lengths = struct { Length, Length, Length, Length };
+        var lengths: ?Lengths = null;
+
+        while (true) {
+            if (lengths == null) {
+                const value = input.tryParse(struct {
+                    pub fn parseFn(i: *css.Parser) css.Result(Lengths) {
+                        const horizontal = switch (Length.parse(i)) {
+                            .result => |v| v,
+                            .err => |e| return .{ .err = e },
+                        };
+                        const vertical = switch (Length.parse(i)) {
+                            .result => |v| v,
+                            .err => |e| return .{ .err = e },
+                        };
+                        const blur = i.tryParse(Length.parse, .{}).asValue() orelse Length.zero();
+                        const spread = i.tryParse(Length.parse, .{}).asValue() orelse Length.zero();
+                        return .{ .result = .{ horizontal, vertical, blur, spread } };
+                    }
+                }.parseFn, .{});
+
+                if (value.asValue()) |v| {
+                    lengths = v;
+                    continue;
+                }
+            }
+
+            if (color == null) {
+                if (input.tryParse(CssColor.parse, .{}).asValue()) |value| {
+                    color = value;
+                    continue;
+                }
+            }
+
+            break;
+        }
+
+        const l = lengths orelse return .{ .err = input.newError(.qualified_rule_invalid) };
+        return .{
+            .result = .{
+                .color = color orelse CssColor.current_color,
+                .x_offset = l[0],
+                .y_offset = l[1],
+                .blur = l[2],
+                .spread = l[3],
+            },
+        };
+    }
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+        try this.x_offset.toCss(W, dest);
+        try dest.writeChar(' ');
+        try this.y_offset.toCss(W, dest);
+
+        if (!this.blur.eql(&Length.zero()) or !this.spread.eql(&Length.zero())) {
+            try dest.writeChar(' ');
+            try this.blur.toCss(W, dest);
+
+            if (!this.spread.eql(&Length.zero())) {
+                try dest.writeChar(' ');
+                try this.spread.toCss(W, dest);
+            }
+        }
+
+        if (!this.color.eql(&CssColor{ .current_color = {} })) {
+            try dest.writeChar(' ');
+            try this.color.toCss(W, dest);
+        }
+
+        return;
+    }
+
+    pub fn isCompatible(this: *const @This(), browsers: css.targets.Browsers) bool {
+        return this.color.isCompatible(browsers) and
+            this.x_offset.isCompatible(browsers) and
+            this.y_offset.isCompatible(browsers) and
+            this.blur.isCompatible(browsers) and
+            this.spread.isCompatible(browsers);
+    }
+
+    pub fn eql(this: *const @This(), other: *const @This()) bool {
+        return css.implementEql(@This(), this, other);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A value for the [text-size-adjust](https://w3c.github.io/csswg-drafts/css-size-adjust/#adjustment-control) property.
+pub const TextSizeAdjust = union(enum) {
+    /// Use the default size adjustment when displaying on a small device.
+    auto,
+    /// No size adjustment when displaying on a small device.
+    none,
+    /// When displaying on a small device, the font size is multiplied by this percentage.
+    percentage: Percentage,
+};
+
+/// A value for the [direction](https://drafts.csswg.org/css-writing-modes-3/#direction) property.
+pub const Direction = enum {
+    /// This value sets inline base direction (bidi directionality) to line-left-to-line-right.
+    ltr,
+    /// This value sets inline base direction (bidi directionality) to line-right-to-line-left.
+    rtl,
+
+    pub usingnamespace css.DefineEnumProperty(@This());
+};
+
+/// A value for the [unicode-bidi](https://drafts.csswg.org/css-writing-modes-3/#unicode-bidi) property.
+pub const UnicodeBidi = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A value for the [box-decoration-break](https://www.w3.org/TR/css-break-3/#break-decoration) property.
+pub const BoxDecorationBreak = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
diff --git a/src/css/properties/transform.zig b/src/css/properties/transform.zig
new file mode 100644
index 0000000000..576779ad30
--- /dev/null
+++ b/src/css/properties/transform.zig
@@ -0,0 +1,264 @@
+const std = @import("std");
+const bun = @import("root").bun;
+const Allocator = std.mem.Allocator;
+const ArrayList = std.ArrayListUnmanaged;
+
+pub const css = @import("../css_parser.zig");
+
+const SmallList = css.SmallList;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const Result = css.Result;
+
+const ContainerName = css.css_rules.container.ContainerName;
+
+const LengthPercentage = css.css_values.length.LengthPercentage;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CSSString = css.css_values.string.CSSString;
+const CSSNumber = css.css_values.number.CSSNumber;
+const LengthPercentageOrAuto = css.css_values.length.LengthPercentageOrAuto;
+const Size2D = css.css_values.size.Size2D;
+const DashedIdent = css.css_values.ident.DashedIdent;
+const Image = css.css_values.image.Image;
+const CssColor = css.css_values.color.CssColor;
+const Ratio = css.css_values.ratio.Ratio;
+const Length = css.css_values.length.LengthValue;
+const Rect = css.css_values.rect.Rect;
+const NumberOrPercentage = css.css_values.percentage.NumberOrPercentage;
+const CustomIdentList = css.css_values.ident.CustomIdentList;
+const Angle = css.css_values.angle.Angle;
+const Url = css.css_values.url.Url;
+const Percentage = css.css_values.percentage.Percentage;
+
+const GenericBorder = css.css_properties.border.GenericBorder;
+const LineStyle = css.css_properties.border.LineStyle;
+
+/// A value for the [transform](https://www.w3.org/TR/2019/CR-css-transforms-1-20190214/#propdef-transform) property.
+pub const TransformList = struct {
+    v: ArrayList(Transform),
+
+    pub fn parse(input: *css.Parser) Result(@This()) {
+        _ = input; // autofix
+        @panic(css.todo_stuff.depth);
+    }
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+        _ = this; // autofix
+        _ = dest; // autofix
+        @panic(css.todo_stuff.depth);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// An individual transform function (https://www.w3.org/TR/2019/CR-css-transforms-1-20190214/#two-d-transform-functions).
+pub const Transform = union(enum) {
+    /// A 2D translation.
+    translate: struct {
+        x: LengthPercentage,
+        y: LengthPercentage,
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    },
+    /// A translation in the X direction.
+    translate_x: LengthPercentage,
+    /// A translation in the Y direction.
+    translate_y: LengthPercentage,
+    /// A translation in the Z direction.
+    translate_z: Length,
+    /// A 3D translation.
+    translate_3d: struct {
+        x: LengthPercentage,
+        y: LengthPercentage,
+        z: Length,
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    },
+    /// A 2D scale.
+    scale: struct {
+        x: NumberOrPercentage,
+        y: NumberOrPercentage,
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    },
+    /// A scale in the X direction.
+    scale_x: NumberOrPercentage,
+    /// A scale in the Y direction.
+    scale_y: NumberOrPercentage,
+    /// A scale in the Z direction.
+    scale_z: NumberOrPercentage,
+    /// A 3D scale.
+    scale_3d: struct {
+        x: NumberOrPercentage,
+        y: NumberOrPercentage,
+        z: NumberOrPercentage,
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    },
+    /// A 2D rotation.
+    rotate: Angle,
+    /// A rotation around the X axis.
+    rotate_x: Angle,
+    /// A rotation around the Y axis.
+    rotate_y: Angle,
+    /// A rotation around the Z axis.
+    rotate_z: Angle,
+    /// A 3D rotation.
+    rotate_3d: struct {
+        x: f32,
+        y: f32,
+        z: f32,
+        angle: Angle,
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    },
+    /// A 2D skew.
+    skew: struct {
+        x: Angle,
+        y: Angle,
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    },
+    /// A skew along the X axis.
+    skew_x: Angle,
+    /// A skew along the Y axis.
+    skew_y: Angle,
+    /// A perspective transform.
+    perspective: Length,
+    /// A 2D matrix transform.
+    matrix: Matrix(f32),
+    /// A 3D matrix transform.
+    matrix_3d: Matrix3d(f32),
+
+    pub fn parse(input: *css.Parser) Result(Transform) {
+        _ = input; // autofix
+        @panic(css.todo_stuff.depth);
+    }
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+        _ = this; // autofix
+        _ = dest; // autofix
+        @panic(css.todo_stuff.depth);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A 2D matrix.
+pub fn Matrix(comptime T: type) type {
+    return struct {
+        a: T,
+        b: T,
+        c: T,
+        d: T,
+        e: T,
+        f: T,
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+
+        pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+            return css.implementEql(@This(), lhs, rhs);
+        }
+    };
+}
+
+/// A 3D matrix.
+pub fn Matrix3d(comptime T: type) type {
+    return struct {
+        m11: T,
+        m12: T,
+        m13: T,
+        m14: T,
+        m21: T,
+        m22: T,
+        m23: T,
+        m24: T,
+        m31: T,
+        m32: T,
+        m33: T,
+        m34: T,
+        m41: T,
+        m42: T,
+        m43: T,
+        m44: T,
+    };
+}
+
+/// A value for the [transform-style](https://drafts.csswg.org/css-transforms-2/#transform-style-property) property.
+pub const TransformStyle = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A value for the [transform-box](https://drafts.csswg.org/css-transforms-1/#transform-box) property.
+pub const TransformBox = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A value for the [backface-visibility](https://drafts.csswg.org/css-transforms-2/#backface-visibility-property) property.
+pub const BackfaceVisibility = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A value for the perspective property.
+pub const Perspective = union(enum) {
+    /// No perspective transform is applied.
+    none,
+    /// Distance to the center of projection.
+    length: Length,
+};
+
+/// A value for the [translate](https://drafts.csswg.org/css-transforms-2/#propdef-translate) property.
+pub const Translate = union(enum) {
+    /// The "none" keyword.
+    none,
+
+    /// The x, y, and z translations.
+    xyz: struct {
+        /// The x translation.
+        x: LengthPercentage,
+        /// The y translation.
+        y: LengthPercentage,
+        /// The z translation.
+        z: Length,
+    },
+};
+
+/// A value for the [rotate](https://drafts.csswg.org/css-transforms-2/#propdef-rotate) property.
+pub const Rotate = struct {
+    /// Rotation around the x axis.
+    x: f32,
+    /// Rotation around the y axis.
+    y: f32,
+    /// Rotation around the z axis.
+    z: f32,
+    /// The angle of rotation.
+    angle: Angle,
+};
+
+/// A value for the [scale](https://drafts.csswg.org/css-transforms-2/#propdef-scale) property.
+pub const Scale = union(enum) {
+    /// The "none" keyword.
+    none,
+
+    /// Scale on the x, y, and z axis.
+    xyz: struct {
+        /// Scale on the x axis.
+        x: NumberOrPercentage,
+        /// Scale on the y axis.
+        y: NumberOrPercentage,
+        /// Scale on the z axis.
+        z: NumberOrPercentage,
+    },
+};
diff --git a/src/css/properties/transition.zig b/src/css/properties/transition.zig
new file mode 100644
index 0000000000..a44aa5cc11
--- /dev/null
+++ b/src/css/properties/transition.zig
@@ -0,0 +1,37 @@
+const std = @import("std");
+const bun = @import("root").bun;
+const Allocator = std.mem.Allocator;
+const ArrayList = std.ArrayListUnmanaged;
+
+pub const css = @import("../css_parser.zig");
+
+const SmallList = css.SmallList;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const Error = css.Error;
+
+const ContainerName = css.css_rules.container.ContainerName;
+
+const LengthPercentage = css.css_values.length.LengthPercentage;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CSSString = css.css_values.string.CSSString;
+const CSSNumber = css.css_values.number.CSSNumber;
+const LengthPercentageOrAuto = css.css_values.length.LengthPercentageOrAuto;
+const Size2D = css.css_values.size.Size2D;
+const DashedIdent = css.css_values.ident.DashedIdent;
+const Image = css.css_values.image.Image;
+const CssColor = css.css_values.color.CssColor;
+const Ratio = css.css_values.ratio.Ratio;
+const Length = css.css_values.length.LengthValue;
+const Rect = css.css_values.rect.Rect;
+const NumberOrPercentage = css.css_values.percentage.NumberOrPercentage;
+const CustomIdentList = css.css_values.ident.CustomIdentList;
+const Angle = css.css_values.angle.Angle;
+const Url = css.css_values.url.Url;
+const Percentage = css.css_values.percentage.Percentage;
+
+const GenericBorder = css.css_properties.border.GenericBorder;
+const LineStyle = css.css_properties.border.LineStyle;
+
+/// A value for the [transition](https://www.w3.org/TR/2018/WD-css-transitions-1-20181011/#transition-shorthand-property) property.
+pub const Transition = @compileError(css.todo_stuff.depth);
diff --git a/src/css/properties/ui.zig b/src/css/properties/ui.zig
new file mode 100644
index 0000000000..58b7cec84d
--- /dev/null
+++ b/src/css/properties/ui.zig
@@ -0,0 +1,109 @@
+const std = @import("std");
+const bun = @import("root").bun;
+const Allocator = std.mem.Allocator;
+const ArrayList = std.ArrayListUnmanaged;
+
+pub const css = @import("../css_parser.zig");
+
+const SmallList = css.SmallList;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const Error = css.Error;
+
+const ContainerName = css.css_rules.container.ContainerName;
+
+const LengthPercentage = css.css_values.length.LengthPercentage;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CSSString = css.css_values.string.CSSString;
+const CSSNumber = css.css_values.number.CSSNumber;
+const LengthPercentageOrAuto = css.css_values.length.LengthPercentageOrAuto;
+const Size2D = css.css_values.size.Size2D;
+const DashedIdent = css.css_values.ident.DashedIdent;
+const Image = css.css_values.image.Image;
+const CssColor = css.css_values.color.CssColor;
+const Ratio = css.css_values.ratio.Ratio;
+const Length = css.css_values.length.LengthValue;
+const Rect = css.css_values.rect.Rect;
+const NumberOrPercentage = css.css_values.percentage.NumberOrPercentage;
+const CustomIdentList = css.css_values.ident.CustomIdentList;
+const Angle = css.css_values.angle.Angle;
+const Url = css.css_values.url.Url;
+const Percentage = css.css_values.percentage.Percentage;
+
+const GenericBorder = css.css_properties.border.GenericBorder;
+const LineStyle = css.css_properties.border.LineStyle;
+
+/// A value for the [color-scheme](https://drafts.csswg.org/css-color-adjust/#color-scheme-prop) property.
+pub const ColorScheme = packed struct(u8) {
+    /// Indicates that the element supports a light color scheme.
+    light: bool = false,
+    /// Indicates that the element supports a dark color scheme.
+    dark: bool = false,
+    /// Forbids the user agent from overriding the color scheme for the element.
+    only: bool = false,
+};
+
+/// A value for the [resize](https://www.w3.org/TR/2021/WD-css-ui-4-20210316/#resize) property.
+pub const Resize = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A value for the [cursor](https://www.w3.org/TR/2021/WD-css-ui-4-20210316/#cursor) property.
+pub const Cursor = struct {
+    /// A list of cursor images.
+    images: SmallList(CursorImage),
+    /// A pre-defined cursor.
+    keyword: CursorKeyword,
+};
+
+/// A [cursor image](https://www.w3.org/TR/2021/WD-css-ui-4-20210316/#cursor) value, used in the `cursor` property.
+///
+/// See [Cursor](Cursor).
+pub const CursorImage = struct {
+    /// A url to the cursor image.
+    url: Url,
+    /// The location in the image where the mouse pointer appears.
+    hotspot: ?[2]CSSNumber,
+};
+
+/// A pre-defined [cursor](https://www.w3.org/TR/2021/WD-css-ui-4-20210316/#cursor) value,
+/// used in the `cursor` property.
+///
+/// See [Cursor](Cursor).
+pub const CursorKeyword = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A value for the [caret-color](https://www.w3.org/TR/2021/WD-css-ui-4-20210316/#caret-color) property.
+pub const ColorOrAuto = union(enum) {
+    /// The `currentColor`, adjusted by the UA to ensure contrast against the background.
+    auto,
+    /// A color.
+    color: CssColor,
+};
+
+/// A value for the [caret-shape](https://www.w3.org/TR/2021/WD-css-ui-4-20210316/#caret-shape) property.
+pub const CaretShape = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A value for the [caret](https://www.w3.org/TR/2021/WD-css-ui-4-20210316/#caret) shorthand property.
+pub const Caret = @compileError(css.todo_stuff.depth);
+
+/// A value for the [user-select](https://www.w3.org/TR/2021/WD-css-ui-4-20210316/#content-selection) property.
+pub const UserSelect = css.DefineEnumProperty(@compileError(css.todo_stuff.depth));
+
+/// A value for the [appearance](https://www.w3.org/TR/2021/WD-css-ui-4-20210316/#appearance-switching) property.
+pub const Appearance = union(enum) {
+    none,
+    auto,
+    textfield,
+    menulist_button,
+    button,
+    checkbox,
+    listbox,
+    menulist,
+    meter,
+    progress_bar,
+    push_button,
+    radio,
+    searchfield,
+    slider_horizontal,
+    square_button,
+    textarea,
+    non_standard: []const u8,
+};
diff --git a/src/css/rules/container.zig b/src/css/rules/container.zig
new file mode 100644
index 0000000000..13a11ca966
--- /dev/null
+++ b/src/css/rules/container.zig
@@ -0,0 +1,355 @@
+const std = @import("std");
+pub const css = @import("../css_parser.zig");
+const bun = @import("root").bun;
+const Result = css.Result;
+const ArrayList = std.ArrayListUnmanaged;
+const MediaList = css.MediaList;
+const CustomMedia = css.CustomMedia;
+const Printer = css.Printer;
+const Maybe = css.Maybe;
+const PrinterError = css.PrinterError;
+const PrintErr = css.PrintErr;
+const Location = css.css_rules.Location;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CustomIdentFns = css.css_values.ident.CustomIdentFns;
+const QueryFeature = css.media_query.QueryFeature;
+const QueryConditionFlags = css.media_query.QueryConditionFlags;
+const Operator = css.media_query.Operator;
+
+pub const ContainerName = struct {
+    v: css.css_values.ident.CustomIdent,
+    pub fn parse(input: *css.Parser) Result(ContainerName) {
+        const ident = switch (CustomIdentFns.parse(input)) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+
+        // todo_stuff.match_ignore_ascii_case;
+        if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("none", ident.v) or
+            bun.strings.eqlCaseInsensitiveASCIIICheckLength("and", ident.v) or
+            bun.strings.eqlCaseInsensitiveASCIIICheckLength("not", ident.v) or
+            bun.strings.eqlCaseInsensitiveASCIIICheckLength("or", ident.v))
+            return .{ .err = input.newUnexpectedTokenError(.{ .ident = ident.v }) };
+
+        return .{ .result = ContainerName{ .v = ident } };
+    }
+
+    const This = @This();
+
+    pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        return try CustomIdentFns.toCss(&this.v, W, dest);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+pub const ContainerNameFns = ContainerName;
+pub const ContainerSizeFeature = QueryFeature(ContainerSizeFeatureId);
+
+pub const ContainerSizeFeatureId = enum {
+    /// The [width](https://w3c.github.io/csswg-drafts/css-contain-3/#width) size container feature.
+    width,
+    /// The [height](https://w3c.github.io/csswg-drafts/css-contain-3/#height) size container feature.
+    height,
+    /// The [inline-size](https://w3c.github.io/csswg-drafts/css-contain-3/#inline-size) size container feature.
+    @"inline-size",
+    /// The [block-size](https://w3c.github.io/csswg-drafts/css-contain-3/#block-size) size container feature.
+    @"block-size",
+    /// The [aspect-ratio](https://w3c.github.io/csswg-drafts/css-contain-3/#aspect-ratio) size container feature.
+    @"aspect-ratio",
+    /// The [orientation](https://w3c.github.io/csswg-drafts/css-contain-3/#orientation) size container feature.
+    orientation,
+
+    pub usingnamespace css.DeriveValueType(@This());
+
+    pub const ValueTypeMap = .{
+        .width = css.MediaFeatureType.length,
+        .height = css.MediaFeatureType.length,
+        .@"inline-size" = css.MediaFeatureType.length,
+        .@"block-size" = css.MediaFeatureType.length,
+        .@"aspect-ratio" = css.MediaFeatureType.ratio,
+        .orientation = css.MediaFeatureType.ident,
+    };
+
+    pub fn asStr(this: *const @This()) []const u8 {
+        return css.enum_property_util.asStr(@This(), this);
+    }
+
+    pub fn parse(input: *css.Parser) Result(@This()) {
+        return css.enum_property_util.parse(@This(), input);
+    }
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+        return css.enum_property_util.toCss(@This(), this, W, dest);
+    }
+
+    pub fn toCssWithPrefix(this: *const @This(), prefix: []const u8, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        try dest.writeStr(prefix);
+        try this.toCss(W, dest);
+    }
+};
+
+/// Represents a style query within a container condition.
+pub const StyleQuery = union(enum) {
+    /// A style feature, implicitly parenthesized.
+    feature: css.Property,
+
+    /// A negation of a condition.
+    not: *StyleQuery,
+
+    /// A set of joint operations.
+    operation: struct {
+        /// The operator for the conditions.
+        operator: css.media_query.Operator,
+        /// The conditions for the operator.
+        conditions: ArrayList(StyleQuery),
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    },
+
+    pub fn toCss(this: *const StyleQuery, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        switch (this.*) {
+            .feature => |f| try f.toCss(W, dest, false),
+            .not => |c| {
+                try dest.writeStr("not ");
+                return try css.media_query.toCssWithParensIfNeeded(
+                    c,
+                    W,
+                    dest,
+                    c.needsParens(null, &dest.targets),
+                );
+            },
+            .operation => |op| return css.media_query.operationToCss(
+                StyleQuery,
+                op.operator,
+                &op.conditions,
+                W,
+                dest,
+            ),
+        }
+    }
+
+    pub fn parseFeature(input: *css.Parser) Result(StyleQuery) {
+        const property_id = switch (css.PropertyId.parse(input)) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+        if (input.expectColon().asErr()) |e| return .{ .err = e };
+        input.skipWhitespace();
+        const opts = css.ParserOptions.default(input.allocator(), null);
+        const feature = .{
+            .feature = switch (css.Property.parse(
+                property_id,
+                input,
+                &opts,
+            )) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            },
+        };
+        _ = input.tryParse(css.parseImportant, .{});
+        return .{ .result = feature };
+    }
+
+    pub fn createNegation(condition: *StyleQuery) StyleQuery {
+        return .{ .not = condition };
+    }
+
+    pub fn createOperation(operator: Operator, conditions: ArrayList(StyleQuery)) StyleQuery {
+        return .{
+            .operation = .{
+                .operator = operator,
+                .conditions = conditions,
+            },
+        };
+    }
+
+    pub fn needsParens(
+        this: *const StyleQuery,
+        parent_operator: ?Operator,
+        _: *const css.Targets,
+    ) bool {
+        return switch (this.*) {
+            .not => true,
+            .operation => |op| op.operator == parent_operator,
+            .feature => true,
+        };
+    }
+
+    pub fn parseStyleQuery(input: *css.Parser) Result(@This()) {
+        return .{ .err = input.newErrorForNextToken() };
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+pub const ContainerCondition = union(enum) {
+    /// A size container feature, implicitly parenthesized.
+    feature: ContainerSizeFeature,
+    /// A negation of a condition.
+    not: *ContainerCondition,
+    /// A set of joint operations.
+    operation: struct {
+        /// The operator for the conditions.
+        operator: css.media_query.Operator,
+        /// The conditions for the operator.
+        conditions: ArrayList(ContainerCondition),
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    },
+    /// A style query.
+    style: StyleQuery,
+
+    const This = @This();
+
+    pub fn parse(input: *css.Parser) Result(ContainerCondition) {
+        return css.media_query.parseQueryCondition(
+            ContainerCondition,
+            input,
+            QueryConditionFlags{
+                .allow_or = true,
+                .allow_style = true,
+            },
+        );
+    }
+
+    pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        switch (this.*) {
+            .feature => |f| try f.toCss(W, dest),
+            .not => |c| {
+                try dest.writeStr("not ");
+                return try css.media_query.toCssWithParensIfNeeded(
+                    c,
+                    W,
+                    dest,
+                    c.needsParens(null, &dest.targets),
+                );
+            },
+            .operation => |op| try css.media_query.operationToCss(ContainerCondition, op.operator, &op.conditions, W, dest),
+            .style => |query| {
+                try dest.writeStr("style(");
+                try query.toCss(W, dest);
+                try dest.writeChar(')');
+            },
+        }
+    }
+
+    pub fn parseFeature(input: *css.Parser) Result(ContainerCondition) {
+        const feature = switch (QueryFeature(ContainerSizeFeatureId).parse(input)) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+        return .{ .result = .{ .feature = feature } };
+    }
+
+    pub fn createNegation(condition: *ContainerCondition) ContainerCondition {
+        return .{ .not = condition };
+    }
+
+    pub fn createOperation(operator: Operator, conditions: ArrayList(ContainerCondition)) ContainerCondition {
+        return .{
+            .operation = .{
+                .operator = operator,
+                .conditions = conditions,
+            },
+        };
+    }
+
+    pub fn parseStyleQuery(input: *css.Parser) Result(ContainerCondition) {
+        const Fns = struct {
+            pub inline fn adaptedParseQueryCondition(i: *css.Parser, flags: QueryConditionFlags) Result(StyleQuery) {
+                return css.media_query.parseQueryCondition(StyleQuery, i, flags);
+            }
+
+            pub fn parseNestedBlockFn(_: void, i: *css.Parser) Result(ContainerCondition) {
+                if (i.tryParse(
+                    @This().adaptedParseQueryCondition,
+                    .{
+                        QueryConditionFlags{ .allow_or = true },
+                    },
+                ).asValue()) |res| {
+                    return .{ .result = .{ .style = res } };
+                }
+
+                return .{ .result = .{
+                    .style = switch (StyleQuery.parseFeature(i)) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    },
+                } };
+            }
+        };
+        return input.parseNestedBlock(ContainerCondition, {}, Fns.parseNestedBlockFn);
+    }
+
+    pub fn needsParens(
+        this: *const ContainerCondition,
+        parent_operator: ?Operator,
+        targets: *const css.Targets,
+    ) bool {
+        return switch (this.*) {
+            .not => true,
+            .operation => |op| op.operator == parent_operator,
+            .feature => |f| f.needsParens(parent_operator, targets),
+            .style => false,
+        };
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A [@container](https://drafts.csswg.org/css-contain-3/#container-rule) rule.
+pub fn ContainerRule(comptime R: type) type {
+    return struct {
+        /// The name of the container.
+        name: ?ContainerName,
+        /// The container condition.
+        condition: ContainerCondition,
+        /// The rules within the `@container` rule.
+        rules: css.CssRuleList(R),
+        /// The location of the rule in the source file.
+        loc: Location,
+
+        const This = @This();
+
+        pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+            // #[cfg(feature = "sourcemap")]
+            // dest.add_mapping(self.loc);
+
+            try dest.writeStr("@container ");
+            if (this.name) |*name| {
+                try name.toCss(W, dest);
+                try dest.writeChar(' ');
+            }
+
+            // Don't downlevel range syntax in container queries.
+            const exclude = dest.targets.exclude;
+            dest.targets.exclude.insert(css.targets.Features.media_queries);
+            try this.condition.toCss(W, dest);
+            dest.targets.exclude = exclude;
+
+            try dest.whitespace();
+            try dest.writeChar('{');
+            dest.indent();
+            try dest.newline();
+            try this.rules.toCss(W, dest);
+            dest.dedent();
+            try dest.newline();
+            try dest.writeChar('}');
+        }
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) This {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    };
+}
diff --git a/src/css/rules/counter_style.zig b/src/css/rules/counter_style.zig
new file mode 100644
index 0000000000..568aae137e
--- /dev/null
+++ b/src/css/rules/counter_style.zig
@@ -0,0 +1,51 @@
+const std = @import("std");
+pub const css = @import("../css_parser.zig");
+const bun = @import("root").bun;
+const Error = css.Error;
+const ArrayList = std.ArrayListUnmanaged;
+const MediaList = css.MediaList;
+const CustomMedia = css.CustomMedia;
+const Printer = css.Printer;
+const Maybe = css.Maybe;
+const PrinterError = css.PrinterError;
+const PrintErr = css.PrintErr;
+const Dependency = css.Dependency;
+const dependencies = css.dependencies;
+const Url = css.css_values.url.Url;
+const Size2D = css.css_values.size.Size2D;
+const fontprops = css.css_properties.font;
+const LayerName = css.css_rules.layer.LayerName;
+const Location = css.css_rules.Location;
+const Angle = css.css_values.angle.Angle;
+const FontStyleProperty = css.css_properties.font.FontStyle;
+const FontFamily = css.css_properties.font.FontFamily;
+const FontWeight = css.css_properties.font.FontWeight;
+const FontStretch = css.css_properties.font.FontStretch;
+const CustomProperty = css.css_properties.custom.CustomProperty;
+const CustomPropertyName = css.css_properties.custom.CustomPropertyName;
+const DashedIdent = css.css_values.ident.DashedIdent;
+
+/// A [@counter-style](https://drafts.csswg.org/css-counter-styles/#the-counter-style-rule) rule.
+pub const CounterStyleRule = struct {
+    /// The name of the counter style to declare.
+    name: css.css_values.ident.CustomIdent,
+    /// Declarations in the `@counter-style` rule.
+    declarations: css.DeclarationBlock,
+    /// The location of the rule in the source file.
+    loc: Location,
+
+    const This = @This();
+
+    pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        // #[cfg(feature = "sourcemap")]
+        // dest.add_mapping(self.loc);
+
+        try dest.writeStr("@counter-style");
+        try css.css_values.ident.CustomIdentFns.toCss(&this.name, W, dest);
+        try this.declarations.toCssBlock(W, dest);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) This {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
diff --git a/src/css/rules/custom_media.zig b/src/css/rules/custom_media.zig
new file mode 100644
index 0000000000..cc0d7d363e
--- /dev/null
+++ b/src/css/rules/custom_media.zig
@@ -0,0 +1,41 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const bun = @import("root").bun;
+const logger = bun.logger;
+const Log = logger.Log;
+
+pub const css = @import("../css_parser.zig");
+pub const css_values = @import("../values/values.zig");
+pub const Error = css.Error;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+
+/// A [@custom-media](https://drafts.csswg.org/mediaqueries-5/#custom-mq) rule.
+pub const CustomMediaRule = struct {
+    /// The name of the declared media query.
+    name: css_values.ident.DashedIdent,
+    /// The media query to declare.
+    query: css.MediaList,
+    /// The location of the rule in the source file.
+    loc: css.Location,
+
+    const This = @This();
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) This {
+        return This{
+            .name = this.name,
+            .query = this.query.deepClone(allocator),
+            .loc = this.loc,
+        };
+    }
+
+    pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        // #[cfg(feature = "sourcemap")]
+        // dest.add_mapping(self.loc);
+        try dest.writeStr("@custom-media ");
+        try css_values.ident.DashedIdentFns.toCss(&this.name, W, dest);
+        try dest.writeChar(' ');
+        try this.query.toCss(W, dest);
+        try dest.writeChar(';');
+    }
+};
diff --git a/src/css/rules/document.zig b/src/css/rules/document.zig
new file mode 100644
index 0000000000..485aef4464
--- /dev/null
+++ b/src/css/rules/document.zig
@@ -0,0 +1,59 @@
+const std = @import("std");
+pub const css = @import("../css_parser.zig");
+const bun = @import("root").bun;
+const Error = css.Error;
+const ArrayList = std.ArrayListUnmanaged;
+const MediaList = css.MediaList;
+const CustomMedia = css.CustomMedia;
+const Printer = css.Printer;
+const Maybe = css.Maybe;
+const PrinterError = css.PrinterError;
+const PrintErr = css.PrintErr;
+const Dependency = css.Dependency;
+const dependencies = css.dependencies;
+const Url = css.css_values.url.Url;
+const Size2D = css.css_values.size.Size2D;
+const fontprops = css.css_properties.font;
+const LayerName = css.css_rules.layer.LayerName;
+const Location = css.css_rules.Location;
+const Angle = css.css_values.angle.Angle;
+const FontStyleProperty = css.css_properties.font.FontStyle;
+const FontFamily = css.css_properties.font.FontFamily;
+const FontWeight = css.css_properties.font.FontWeight;
+const FontStretch = css.css_properties.font.FontStretch;
+const CustomProperty = css.css_properties.custom.CustomProperty;
+const CustomPropertyName = css.css_properties.custom.CustomPropertyName;
+const DashedIdent = css.css_values.ident.DashedIdent;
+
+/// A [@-moz-document](https://www.w3.org/TR/2012/WD-css3-conditional-20120911/#at-document) rule.
+///
+/// Note that only the `url-prefix()` function with no arguments is supported, and only the `-moz` prefix
+/// is allowed since Firefox was the only browser that ever implemented this rule.
+pub fn MozDocumentRule(comptime R: type) type {
+    return struct {
+        /// Nested rules within the `@-moz-document` rule.
+        rules: css.CssRuleList(R),
+        /// The location of the rule in the source file.
+        loc: Location,
+
+        const This = @This();
+
+        pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+            // #[cfg(feature = "sourcemap")]
+            // dest.add_mapping(self.loc);
+            try dest.writeStr("@-moz-document url-prefix()");
+            try dest.whitespace();
+            try dest.writeChar('{');
+            dest.indent();
+            try dest.newline();
+            try this.rules.toCss(W, dest);
+            dest.dedent();
+            try dest.newline();
+            try dest.writeChar('}');
+        }
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) This {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    };
+}
diff --git a/src/css/rules/font_face.zig b/src/css/rules/font_face.zig
new file mode 100644
index 0000000000..2867b2ca64
--- /dev/null
+++ b/src/css/rules/font_face.zig
@@ -0,0 +1,743 @@
+const std = @import("std");
+pub const css = @import("../css_parser.zig");
+const bun = @import("root").bun;
+const ArrayList = std.ArrayListUnmanaged;
+const MediaList = css.MediaList;
+const CustomMedia = css.CustomMedia;
+const Printer = css.Printer;
+const Maybe = css.Maybe;
+const PrinterError = css.PrinterError;
+const PrintErr = css.PrintErr;
+const Dependency = css.Dependency;
+const dependencies = css.dependencies;
+const Url = css.css_values.url.Url;
+const Size2D = css.css_values.size.Size2D;
+const fontprops = css.css_properties.font;
+const LayerName = css.css_rules.layer.LayerName;
+const SupportsCondition = css.css_rules.supports.SupportsCondition;
+const Location = css.css_rules.Location;
+const Angle = css.css_values.angle.Angle;
+const FontStyleProperty = css.css_properties.font.FontStyle;
+const FontFamily = css.css_properties.font.FontFamily;
+const FontWeight = css.css_properties.font.FontWeight;
+const FontStretch = css.css_properties.font.FontStretch;
+const CustomProperty = css.css_properties.custom.CustomProperty;
+const CustomPropertyName = css.css_properties.custom.CustomPropertyName;
+const Result = css.Result;
+
+/// A property within an `@font-face` rule.
+///
+/// See [FontFaceRule](FontFaceRule).
+pub const FontFaceProperty = union(enum) {
+    /// The `src` property.
+    source: ArrayList(Source),
+
+    /// The `font-family` property.
+    font_family: fontprops.FontFamily,
+
+    /// The `font-style` property.
+    font_style: FontStyle,
+
+    /// The `font-weight` property.
+    font_weight: Size2D(fontprops.FontWeight),
+
+    /// The `font-stretch` property.
+    font_stretch: Size2D(fontprops.FontStretch),
+
+    /// The `unicode-range` property.
+    unicode_range: ArrayList(UnicodeRange),
+
+    /// An unknown or unsupported property.
+    custom: css.css_properties.custom.CustomProperty,
+
+    const This = @This();
+
+    pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        const Helpers = struct {
+            pub fn writeProperty(
+                d: *Printer(W),
+                comptime prop: []const u8,
+                value: anytype,
+                comptime multi: bool,
+            ) PrintErr!void {
+                try d.writeStr(prop);
+                try d.delim(':', false);
+                if (comptime multi) {
+                    const len = value.items.len;
+                    for (value.items, 0..) |*val, idx| {
+                        try val.toCss(W, d);
+                        if (idx < len - 1) {
+                            try d.delim(',', false);
+                        }
+                    }
+                } else {
+                    try value.toCss(W, d);
+                }
+            }
+        };
+        return switch (this.*) {
+            .source => |value| Helpers.writeProperty(dest, "src", value, true),
+            .font_family => |value| Helpers.writeProperty(dest, "font-family", value, false),
+            .font_style => |value| Helpers.writeProperty(dest, "font-style", value, false),
+            .font_weight => |value| Helpers.writeProperty(dest, "font-weight", value, false),
+            .font_stretch => |value| Helpers.writeProperty(dest, "font-stretch", value, false),
+            .unicode_range => |value| Helpers.writeProperty(dest, "unicode-range", value, true),
+            .custom => |custom| {
+                try dest.writeStr(this.custom.name.asStr());
+                try dest.delim(':', false);
+                return custom.value.toCss(W, dest, true);
+            },
+        };
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) This {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A contiguous range of Unicode code points.
+///
+/// Cannot be empty. Can represent a single code point when start == end.
+pub const UnicodeRange = struct {
+    /// Inclusive start of the range. In [0, end].
+    start: u32,
+
+    /// Inclusive end of the range. In [0, 0x10FFFF].
+    end: u32,
+
+    pub fn toCss(this: *const UnicodeRange, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        // Attempt to optimize the range to use question mark syntax.
+        if (this.start != this.end) {
+            // Find the first hex digit that differs between the start and end values.
+            var shift: u5 = 24;
+            var mask: u32 = @as(u32, 0xf) << shift;
+            while (shift > 0) {
+                const c1 = this.start & mask;
+                const c2 = this.end & mask;
+                if (c1 != c2) {
+                    break;
+                }
+
+                mask = mask >> 4;
+                shift -= 4;
+            }
+
+            // Get the remainder of the value. This must be 0x0 to 0xf for the rest
+            // of the value to use the question mark syntax.
+            shift += 4;
+            const remainder_mask: u32 = (@as(u32, 1) << shift) - @as(u32, 1);
+            const start_remainder = this.start & remainder_mask;
+            const end_remainder = this.end & remainder_mask;
+
+            if (start_remainder == 0 and end_remainder == remainder_mask) {
+                const start = (this.start & ~remainder_mask) >> shift;
+                if (start != 0) {
+                    try dest.writeFmt("U+{x}", .{start});
+                } else {
+                    try dest.writeStr("U+");
+                }
+
+                while (shift > 0) {
+                    try dest.writeChar('?');
+                    shift -= 4;
+                }
+
+                return;
+            }
+        }
+
+        try dest.writeFmt("U+{x}", .{this.start});
+        if (this.end != this.start) {
+            try dest.writeFmt("-{x}", .{this.end});
+        }
+    }
+
+    /// https://drafts.csswg.org/css-syntax/#urange-syntax
+    pub fn parse(input: *css.Parser) Result(UnicodeRange) {
+        // <urange> =
+        //   u '+' <ident-token> '?'* |
+        //   u <dimension-token> '?'* |
+        //   u <number-token> '?'* |
+        //   u <number-token> <dimension-token> |
+        //   u <number-token> <number-token> |
+        //   u '+' '?'+
+
+        if (input.expectIdentMatching("u").asErr()) |e| return .{ .err = e };
+        const after_u = input.position();
+        if (parseTokens(input).asErr()) |e| return .{ .err = e };
+
+        // This deviates from the spec in case there are CSS comments
+        // between tokens in the middle of one <unicode-range>,
+        // but oh well…
+        const concatenated_tokens = input.sliceFrom(after_u);
+
+        const range = if (parseConcatenated(concatenated_tokens).asValue()) |range|
+            range
+        else
+            return .{ .err = input.newBasicUnexpectedTokenError(.{ .ident = concatenated_tokens }) };
+
+        if (range.end > 0x10FFFF or range.start > range.end) {
+            return .{ .err = input.newBasicUnexpectedTokenError(.{ .ident = concatenated_tokens }) };
+        }
+
+        return .{ .result = range };
+    }
+
+    fn parseTokens(input: *css.Parser) Result(void) {
+        const tok = switch (input.nextIncludingWhitespace()) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+        switch (tok.*) {
+            .dimension => return parseQuestionMarks(input),
+            .number => {
+                const after_number = input.state();
+                const token = switch (input.nextIncludingWhitespace()) {
+                    .result => |vv| vv,
+                    .err => {
+                        input.reset(&after_number);
+                        return .{ .result = {} };
+                    },
+                };
+
+                if (token.* == .delim and token.delim == '?') return parseQuestionMarks(input);
+                if (token.* == .delim or token.* == .number) return .{ .result = {} };
+                return .{ .result = {} };
+            },
+            .delim => |c| {
+                if (c == '+') {
+                    const next = switch (input.nextIncludingWhitespace()) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    };
+                    if (!(next.* == .ident or (next.* == .delim and next.delim == '?'))) {
+                        return .{ .err = input.newBasicUnexpectedTokenError(next.*) };
+                    }
+                    return parseQuestionMarks(input);
+                }
+            },
+            else => {},
+        }
+        return .{ .err = input.newBasicUnexpectedTokenError(tok.*) };
+    }
+
+    /// Consume as many '?' as possible
+    fn parseQuestionMarks(input: *css.Parser) Result(void) {
+        while (true) {
+            const start = input.state();
+            if (input.nextIncludingWhitespace().asValue()) |tok| if (tok.* == .delim and tok.delim == '?') continue;
+            input.reset(&start);
+            return .{ .result = {} };
+        }
+    }
+
+    fn parseConcatenated(_text: []const u8) css.Maybe(UnicodeRange, void) {
+        var text = if (_text.len > 0 and _text[0] == '+') _text[1..] else {
+            return .{ .err = {} };
+        };
+        const first_hex_value, const hex_digit_count = consumeHex(&text);
+        const question_marks = consumeQuestionMarks(&text);
+        const consumed = hex_digit_count + question_marks;
+
+        if (consumed == 0 or consumed > 6) {
+            return .{ .err = {} };
+        }
+
+        if (question_marks > 0) {
+            if (text.len == 0) return .{ .result = UnicodeRange{
+                .start = first_hex_value << @intCast(question_marks * 4),
+                .end = ((first_hex_value + 1) << @intCast(question_marks * 4)) - 1,
+            } };
+        } else if (text.len == 0) {
+            return .{ .result = UnicodeRange{
+                .start = first_hex_value,
+                .end = first_hex_value,
+            } };
+        } else {
+            if (text.len > 0 and text[0] == '-') {
+                text = text[1..];
+                const second_hex_value, const hex_digit_count2 = consumeHex(&text);
+                if (hex_digit_count2 > 0 and hex_digit_count2 <= 6 and text.len == 0) {
+                    return .{ .result = UnicodeRange{
+                        .start = first_hex_value,
+                        .end = second_hex_value,
+                    } };
+                }
+            }
+        }
+        return .{ .err = {} };
+    }
+
+    fn consumeQuestionMarks(text: *[]const u8) usize {
+        var question_marks: usize = 0;
+        while (bun.strings.splitFirstWithExpected(text.*, '?')) |rest| {
+            question_marks += 1;
+            text.* = rest;
+        }
+        return question_marks;
+    }
+
+    fn consumeHex(text: *[]const u8) struct { u32, usize } {
+        var value: u32 = 0;
+        var digits: usize = 0;
+        while (bun.strings.splitFirst(text.*)) |result| {
+            if (toHexDigit(result.first)) |digit_value| {
+                value = value * 0x10 + digit_value;
+                digits += 1;
+                text.* = result.rest;
+            } else {
+                break;
+            }
+        }
+        return .{ value, digits };
+    }
+
+    fn toHexDigit(b: u8) ?u32 {
+        var digit = @as(u32, b) -% @as(u32, '0');
+        if (digit < 10) return digit;
+        // Force the 6th bit to be set to ensure ascii is lower case.
+        // digit = (@as(u32, b) | 0b10_0000).wrapping_sub('a' as u32).saturating_add(10);
+        digit = (@as(u32, b) | 0b10_0000) -% (@as(u32, 'a') +% 10);
+        return if (digit < 16) digit else null;
+    }
+};
+
+pub const FontStyle = union(enum) {
+    /// Normal font style.
+    normal,
+
+    /// Italic font style.
+    italic,
+
+    /// Oblique font style, with a custom angle.
+    oblique: Size2D(css.css_values.angle.Angle),
+
+    pub fn parse(input: *css.Parser) Result(FontStyle) {
+        const property = switch (FontStyleProperty.parse(input)) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+        return .{
+            .result = switch (property) {
+                .normal => .normal,
+                .italic => .italic,
+                .oblique => |angle| {
+                    const second_angle = if (input.tryParse(css.css_values.angle.Angle.parse, .{}).asValue()) |a| a else angle;
+                    return .{ .result = .{
+                        .oblique = .{ .a = angle, .b = second_angle },
+                    } };
+                },
+            },
+        };
+    }
+
+    pub fn toCss(this: *const FontStyle, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        switch (this.*) {
+            .normal => try dest.writeStr("normal"),
+            .italic => try dest.writeStr("italic"),
+            .oblique => |angle| {
+                try dest.writeStr("oblique");
+                if (!angle.eql(&FontStyle.defaultObliqueAngle())) {
+                    try dest.writeChar(' ');
+                    try angle.toCss(W, dest);
+                }
+            },
+        }
+    }
+
+    fn defaultObliqueAngle() Size2D(Angle) {
+        return Size2D(Angle){
+            .a = FontStyleProperty.defaultObliqueAngle(),
+            .b = FontStyleProperty.defaultObliqueAngle(),
+        };
+    }
+};
+
+/// A font format keyword in the `format()` function of the
+/// [src](https://drafts.csswg.org/css-fonts/#src-desc)
+/// property of an `@font-face` rule.
+pub const FontFormat = union(enum) {
+    /// A WOFF 1.0 font.
+    woff,
+
+    /// A WOFF 2.0 font.
+    woff2,
+
+    /// A TrueType font.
+    truetype,
+
+    /// An OpenType font.
+    opentype,
+
+    /// An Embedded OpenType (.eot) font.
+    embedded_opentype,
+
+    /// OpenType Collection.
+    collection,
+
+    /// An SVG font.
+    svg,
+
+    /// An unknown format.
+    string: []const u8,
+
+    pub fn parse(input: *css.Parser) Result(FontFormat) {
+        const s = switch (input.expectIdentOrString()) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+
+        if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("woff", s)) {
+            return .{ .result = .woff };
+        } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("woff2", s)) {
+            return .{ .result = .woff2 };
+        } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("truetype", s)) {
+            return .{ .result = .truetype };
+        } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("opentype", s)) {
+            return .{ .result = .opentype };
+        } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("embedded-opentype", s)) {
+            return .{ .result = .embedded_opentype };
+        } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("collection", s)) {
+            return .{ .result = .collection };
+        } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("svg", s)) {
+            return .{ .result = .svg };
+        } else {
+            return .{ .result = .{ .string = s } };
+        }
+    }
+
+    pub fn toCss(this: *const FontFormat, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        // Browser support for keywords rather than strings is very limited.
+        // https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/src
+        switch (this.*) {
+            .woff => try dest.writeStr("woff"),
+            .woff2 => try dest.writeStr("woff2"),
+            .truetype => try dest.writeStr("truetype"),
+            .opentype => try dest.writeStr("opentype"),
+            .embedded_opentype => try dest.writeStr("embedded-opentype"),
+            .collection => try dest.writeStr("collection"),
+            .svg => try dest.writeStr("svg"),
+            .string => try dest.writeStr(this.string),
+        }
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A value for the [src](https://drafts.csswg.org/css-fonts/#src-desc)
+/// property in an `@font-face` rule.
+pub const Source = union(enum) {
+    /// A `url()` with optional format metadata.
+    url: UrlSource,
+
+    /// The `local()` function.
+    local: fontprops.FontFamily,
+
+    pub fn parse(input: *css.Parser) Result(Source) {
+        switch (input.tryParse(UrlSource.parse, .{})) {
+            .result => |url| .{ .result = return .{ .result = .{ .url = url } } },
+            .err => |e| {
+                if (e.kind == .basic and e.kind.basic == .at_rule_body_invalid) {
+                    return .{ .err = e };
+                }
+            },
+        }
+
+        if (input.expectFunctionMatching("local").asErr()) |e| return .{ .err = e };
+
+        const Fn = struct {
+            pub fn parseNestedBlock(_: void, i: *css.Parser) Result(fontprops.FontFamily) {
+                return fontprops.FontFamily.parse(i);
+            }
+        };
+        const local = switch (input.parseNestedBlock(fontprops.FontFamily, {}, Fn.parseNestedBlock)) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+        return .{ .result = .{ .local = local } };
+    }
+
+    pub fn toCss(this: *const Source, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        switch (this.*) {
+            .url => try this.url.toCss(W, dest),
+            .local => {
+                try dest.writeStr("local(");
+                try this.local.toCss(W, dest);
+                try dest.writeChar(')');
+            },
+        }
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+pub const FontTechnology = enum {
+    /// A font format keyword in the `format()` function of the
+    /// [src](https://drafts.csswg.org/css-fonts/#src-desc)
+    /// property of an `@font-face` rule.
+    /// A font features tech descriptor in the `tech()`function of the
+    /// [src](https://drafts.csswg.org/css-fonts/#font-features-tech-values)
+    /// property of an `@font-face` rule.
+    /// Supports OpenType Features.
+    /// https://docs.microsoft.com/en-us/typography/opentype/spec/featurelist
+    @"features-opentype",
+
+    /// Supports Apple Advanced Typography Font Features.
+    /// https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html
+    @"features-aat",
+
+    /// Supports Graphite Table Format.
+    /// https://scripts.sil.org/cms/scripts/render_download.php?site_id=nrsi&format=file&media_id=GraphiteBinaryFormat_3_0&filename=GraphiteBinaryFormat_3_0.pdf
+    @"features-graphite",
+
+    /// A color font tech descriptor in the `tech()`function of the
+    /// [src](https://drafts.csswg.org/css-fonts/#src-desc)
+    /// property of an `@font-face` rule.
+    /// Supports the `COLR` v0 table.
+    @"color-colrv0",
+
+    /// Supports the `COLR` v1 table.
+    @"color-colrv1",
+
+    /// Supports the `SVG` table.
+    @"color-svg",
+
+    /// Supports the `sbix` table.
+    @"color-sbix",
+
+    /// Supports the `CBDT` table.
+    @"color-cbdt",
+
+    /// Supports Variations
+    /// The variations tech refers to the support of font variations
+    variations,
+
+    /// Supports Palettes
+    /// The palettes tech refers to support for font palettes
+    palettes,
+
+    /// Supports Incremental
+    /// The incremental tech refers to client support for incremental font loading, using either the range-request or the patch-subset method
+    incremental,
+
+    pub fn asStr(this: *const @This()) []const u8 {
+        return css.enum_property_util.asStr(@This(), this);
+    }
+
+    pub fn parse(input: *css.Parser) Result(@This()) {
+        return css.enum_property_util.parse(@This(), input);
+    }
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+        return css.enum_property_util.toCss(@This(), this, W, dest);
+    }
+};
+
+/// A `url()` value for the [src](https://drafts.csswg.org/css-fonts/#src-desc)
+/// property in an `@font-face` rule.
+pub const UrlSource = struct {
+    /// The URL.
+    url: Url,
+
+    /// Optional `format()` function.
+    format: ?FontFormat,
+
+    /// Optional `tech()` function.
+    tech: ArrayList(FontTechnology),
+
+    pub fn parse(input: *css.Parser) Result(UrlSource) {
+        const url = switch (Url.parse(input)) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+
+        const format = if (input.tryParse(css.Parser.expectFunctionMatching, .{"format"}).isOk()) format: {
+            switch (input.parseNestedBlock(FontFormat, {}, css.voidWrap(FontFormat, FontFormat.parse))) {
+                .result => |vv| break :format vv,
+                .err => |e| return .{ .err = e },
+            }
+        } else null;
+
+        const tech = if (input.tryParse(css.Parser.expectFunctionMatching, .{"tech"}).isOk()) tech: {
+            const Fn = struct {
+                pub fn parseNestedBlockFn(_: void, i: *css.Parser) Result(ArrayList(FontTechnology)) {
+                    return i.parseList(FontTechnology, FontTechnology.parse);
+                }
+            };
+            break :tech switch (input.parseNestedBlock(ArrayList(FontTechnology), {}, Fn.parseNestedBlockFn)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            };
+        } else ArrayList(FontTechnology){};
+
+        return .{
+            .result = UrlSource{ .url = url, .format = format, .tech = tech },
+        };
+    }
+
+    pub fn toCss(this: *const UrlSource, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        try this.url.toCss(W, dest);
+        if (this.format) |*format| {
+            try dest.whitespace();
+            try dest.writeStr("format(");
+            try format.toCss(W, dest);
+            try dest.writeChar(')');
+        }
+
+        if (this.tech.items.len != 0) {
+            try dest.whitespace();
+            try dest.writeStr("tech(");
+            try css.to_css.fromList(FontTechnology, &this.tech, W, dest);
+            try dest.writeChar(')');
+        }
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A [@font-face](https://drafts.csswg.org/css-fonts/#font-face-rule) rule.
+pub const FontFaceRule = struct {
+    /// Declarations in the `@font-face` rule.
+    properties: ArrayList(FontFaceProperty),
+    /// The location of the rule in the source file.
+    loc: Location,
+
+    const This = @This();
+
+    pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        // #[cfg(feature = "sourcemap")]
+        // dest.add_mapping(self.loc);
+
+        try dest.writeStr("@font-face");
+        try dest.whitespace();
+        try dest.writeChar('{');
+        dest.indent();
+        const len = this.properties.items.len;
+        for (this.properties.items, 0..) |*prop, i| {
+            try dest.newline();
+            try prop.toCss(W, dest);
+            if (i != len - 1 or !dest.minify) {
+                try dest.writeChar(';');
+            }
+        }
+        dest.dedent();
+        try dest.newline();
+        try dest.writeChar('}');
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) This {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+pub const FontFaceDeclarationParser = struct {
+    const This = @This();
+
+    pub const AtRuleParser = struct {
+        pub const Prelude = void;
+        pub const AtRule = FontFaceProperty;
+
+        pub fn parsePrelude(_: *This, name: []const u8, input: *css.Parser) Result(Prelude) {
+            return .{
+                .err = input.newError(css.BasicParseErrorKind{ .at_rule_invalid = name }),
+            };
+        }
+
+        pub fn parseBlock(_: *This, _: Prelude, _: *const css.ParserState, input: *css.Parser) Result(AtRule) {
+            return .{ .err = input.newError(css.BasicParseErrorKind{ .at_rule_body_invalid = {} }) };
+        }
+
+        pub fn ruleWithoutBlock(_: *This, _: Prelude, _: *const css.ParserState) css.Maybe(AtRule, void) {
+            return .{ .err = {} };
+        }
+    };
+
+    pub const QualifiedRuleParser = struct {
+        pub const Prelude = void;
+        pub const QualifiedRule = FontFaceProperty;
+
+        pub fn parsePrelude(_: *This, input: *css.Parser) Result(Prelude) {
+            return .{ .err = input.newError(css.BasicParseErrorKind{ .qualified_rule_invalid = {} }) };
+        }
+
+        pub fn parseBlock(_: *This, _: Prelude, _: *const css.ParserState, input: *css.Parser) Result(QualifiedRule) {
+            return .{ .err = input.newError(css.BasicParseErrorKind.qualified_rule_invalid) };
+        }
+    };
+
+    pub const DeclarationParser = struct {
+        pub const Declaration = FontFaceProperty;
+
+        pub fn parseValue(this: *This, name: []const u8, input: *css.Parser) Result(Declaration) {
+            _ = this; // autofix
+            const state = input.state();
+            // todo_stuff.match_ignore_ascii_case
+            if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "src")) {
+                if (input.parseCommaSeparated(Source, Source.parse).asValue()) |sources| {
+                    return .{ .result = .{ .source = sources } };
+                }
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "font-family")) {
+                if (FontFamily.parse(input).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .font_family = c } };
+                    }
+                }
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "font-weight")) {
+                if (Size2D(FontWeight).parse(input).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .font_weight = c } };
+                    }
+                }
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "font-style")) {
+                if (FontStyle.parse(input).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .font_style = c } };
+                    }
+                }
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "font-stretch")) {
+                if (Size2D(FontStretch).parse(input).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .font_stretch = c } };
+                    }
+                }
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "unicode-renage")) {
+                if (input.parseList(UnicodeRange, UnicodeRange.parse).asValue()) |c| {
+                    if (input.expectExhausted().isOk()) {
+                        return .{ .result = .{ .unicode_range = c } };
+                    }
+                }
+            } else {
+                //
+            }
+
+            input.reset(&state);
+            const opts = css.ParserOptions.default(input.allocator(), null);
+            return .{
+                .result = .{
+                    .custom = switch (CustomProperty.parse(CustomPropertyName.fromStr(name), input, &opts)) {
+                        .result => |v| v,
+                        .err => |e| return .{ .err = e },
+                    },
+                },
+            };
+        }
+    };
+
+    pub const RuleBodyItemParser = struct {
+        pub fn parseQualified(this: *This) bool {
+            _ = this; // autofix
+            return false;
+        }
+
+        pub fn parseDeclarations(this: *This) bool {
+            _ = this; // autofix
+            return true;
+        }
+    };
+};
diff --git a/src/css/rules/font_palette_values.zig b/src/css/rules/font_palette_values.zig
new file mode 100644
index 0000000000..d5f1eb0c1b
--- /dev/null
+++ b/src/css/rules/font_palette_values.zig
@@ -0,0 +1,302 @@
+const std = @import("std");
+pub const css = @import("../css_parser.zig");
+const bun = @import("root").bun;
+const Result = css.Result;
+const ArrayList = std.ArrayListUnmanaged;
+const MediaList = css.MediaList;
+const CustomMedia = css.CustomMedia;
+const Printer = css.Printer;
+const Maybe = css.Maybe;
+const PrinterError = css.PrinterError;
+const PrintErr = css.PrintErr;
+const Dependency = css.Dependency;
+const dependencies = css.dependencies;
+const Url = css.css_values.url.Url;
+const Size2D = css.css_values.size.Size2D;
+const fontprops = css.css_properties.font;
+const LayerName = css.css_rules.layer.LayerName;
+const SupportsCondition = css.css_rules.supports.SupportsCondition;
+const Location = css.css_rules.Location;
+const Angle = css.css_values.angle.Angle;
+const CustomProperty = css.css_properties.custom.CustomProperty;
+const CustomPropertyName = css.css_properties.custom.CustomPropertyName;
+const DashedIdent = css.css_values.ident.DashedIdent;
+const FontFamily = css.css_properties.font.FontFamily;
+
+/// A [@font-palette-values](https://drafts.csswg.org/css-fonts-4/#font-palette-values) rule.
+pub const FontPaletteValuesRule = struct {
+    /// The name of the font palette.
+    name: css.css_values.ident.DashedIdent,
+    /// Declarations in the `@font-palette-values` rule.
+    properties: ArrayList(FontPaletteValuesProperty),
+    /// The location of the rule in the source file.
+    loc: Location,
+
+    const This = @This();
+
+    pub fn parse(name: DashedIdent, input: *css.Parser, loc: Location) Result(FontPaletteValuesRule) {
+        var decl_parser = FontPaletteValuesDeclarationParser{};
+        var parser = css.RuleBodyParser(FontPaletteValuesDeclarationParser).new(input, &decl_parser);
+        var properties = ArrayList(FontPaletteValuesProperty){};
+        while (parser.next()) |result| {
+            if (result.asValue()) |decl| {
+                properties.append(
+                    input.allocator(),
+                    decl,
+                ) catch unreachable;
+            }
+        }
+
+        return .{ .result = FontPaletteValuesRule{
+            .name = name,
+            .properties = properties,
+            .loc = loc,
+        } };
+    }
+
+    pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        // #[cfg(feature = "sourcemap")]
+        // dest.add_mapping(self.loc);
+
+        try dest.writeStr("@font-palette-values ");
+        try css.css_values.ident.DashedIdentFns.toCss(&this.name, W, dest);
+        try dest.whitespace();
+        try dest.writeChar('{');
+        dest.indent();
+        const len = this.properties.items.len;
+        for (this.properties.items, 0..) |*prop, i| {
+            try dest.newline();
+            try prop.toCss(W, dest);
+            if (i != len - 1 or !dest.minify) {
+                try dest.writeChar(';');
+            }
+        }
+        dest.dedent();
+        try dest.newline();
+        try dest.writeChar('}');
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) This {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+pub const FontPaletteValuesProperty = union(enum) {
+    /// The `font-family` property.
+    font_family: fontprops.FontFamily,
+
+    /// The `base-palette` property.
+    base_palette: BasePalette,
+
+    /// The `override-colors` property.
+    override_colors: ArrayList(OverrideColors),
+
+    /// An unknown or unsupported property.
+    custom: css.css_properties.custom.CustomProperty,
+
+    /// A property within an `@font-palette-values` rule.
+    ///
+    /// See [FontPaletteValuesRule](FontPaletteValuesRule).
+    const This = @This();
+
+    pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        switch (this.*) {
+            .font_family => |*f| {
+                try dest.writeStr("font-family");
+                try dest.delim(':', false);
+                try f.toCss(W, dest);
+            },
+            .base_palette => |*b| {
+                try dest.writeStr("base-palette");
+                try dest.delim(':', false);
+                try b.toCss(W, dest);
+            },
+            .override_colors => |*o| {
+                try dest.writeStr("override-colors");
+                try dest.delim(':', false);
+                try css.to_css.fromList(OverrideColors, o, W, dest);
+            },
+            .custom => |*custom| {
+                try dest.writeStr(custom.name.asStr());
+                try dest.delim(':', false);
+                try custom.value.toCss(W, dest, true);
+            },
+        }
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A value for the [override-colors](https://drafts.csswg.org/css-fonts-4/#override-color)
+/// property in an `@font-palette-values` rule.
+pub const OverrideColors = struct {
+    /// The index of the color within the palette to override.
+    index: u16,
+
+    /// The replacement color.
+    color: css.css_values.color.CssColor,
+
+    pub fn parse(input: *css.Parser) Result(OverrideColors) {
+        const index = switch (css.CSSIntegerFns.parse(input)) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+        if (index < 0) return .{ .err = input.newCustomError(css.ParserError.invalid_value) };
+
+        const color = switch (css.CssColor.parse(input)) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+        if (color == .current_color) return .{ .err = input.newCustomError(css.ParserError.invalid_value) };
+
+        return .{
+            .result = OverrideColors{
+                .index = @intCast(index),
+                .color = color,
+            },
+        };
+    }
+
+    pub fn toCss(this: *const OverrideColors, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        try css.CSSIntegerFns.toCss(&@as(i32, @intCast(this.index)), W, dest);
+        try dest.writeChar(' ');
+        try this.color.toCss(W, dest);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A value for the [base-palette](https://drafts.csswg.org/css-fonts-4/#base-palette-desc)
+/// property in an `@font-palette-values` rule.
+pub const BasePalette = union(enum) {
+    /// A light color palette as defined within the font.
+    light,
+
+    /// A dark color palette as defined within the font.
+    dark,
+
+    /// A palette index within the font.
+    integer: u16,
+
+    pub fn parse(input: *css.Parser) Result(BasePalette) {
+        if (input.tryParse(css.CSSIntegerFns.parse, .{}).asValue()) |i| {
+            if (i < 0) return .{ .err = input.newCustomError(css.ParserError.invalid_value) };
+            return .{ .result = .{ .integer = @intCast(i) } };
+        }
+
+        const location = input.currentSourceLocation();
+        const ident = switch (input.expectIdent()) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+        if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("light", ident)) {
+            return .{ .result = .light };
+        } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("dark", ident)) {
+            return .{ .result = .dark };
+        } else return .{ .err = location.newUnexpectedTokenError(.{ .ident = ident }) };
+    }
+
+    pub fn toCss(this: *const BasePalette, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        switch (this.*) {
+            .light => try dest.writeStr("light"),
+            .dark => try dest.writeStr("dark"),
+            .integer => try css.CSSIntegerFns.toCss(&@as(i32, @intCast(this.integer)), W, dest),
+        }
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+pub const FontPaletteValuesDeclarationParser = struct {
+    const This = @This();
+
+    pub const DeclarationParser = struct {
+        pub const Declaration = FontPaletteValuesProperty;
+
+        pub fn parseValue(this: *This, name: []const u8, input: *css.Parser) Result(Declaration) {
+            _ = this; // autofix
+            const state = input.state();
+            // todo_stuff.match_ignore_ascii_case
+            if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("font-family", name)) {
+                // https://drafts.csswg.org/css-fonts-4/#font-family-2-desc
+                if (FontFamily.parse(input).asValue()) |font_family| {
+                    if (font_family == .generic) {
+                        return .{ .err = input.newCustomError(css.ParserError.invalid_declaration) };
+                    }
+                    return .{ .result = .{ .font_family = font_family } };
+                }
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("base-palette", name)) {
+                // https://drafts.csswg.org/css-fonts-4/#base-palette-desc
+                if (BasePalette.parse(input).asValue()) |base_palette| {
+                    return .{ .result = .{ .base_palette = base_palette } };
+                }
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("override-colors", name)) {
+                // https://drafts.csswg.org/css-fonts-4/#override-color
+                if (input.parseCommaSeparated(OverrideColors, OverrideColors.parse).asValue()) |override_colors| {
+                    return .{ .result = .{ .override_colors = override_colors } };
+                }
+            } else {
+                return .{ .err = input.newCustomError(css.ParserError.invalid_declaration) };
+            }
+
+            input.reset(&state);
+            const opts = css.ParserOptions.default(input.allocator(), null);
+            return .{ .result = .{
+                .custom = switch (CustomProperty.parse(
+                    CustomPropertyName.fromStr(name),
+                    input,
+                    &opts,
+                )) {
+                    .result => |v| v,
+                    .err => |e| return .{ .err = e },
+                },
+            } };
+        }
+    };
+
+    pub const RuleBodyItemParser = struct {
+        pub fn parseQualified(_: *This) bool {
+            return false;
+        }
+
+        pub fn parseDeclarations(_: *This) bool {
+            return true;
+        }
+    };
+
+    pub const AtRuleParser = struct {
+        pub const Prelude = void;
+        pub const AtRule = FontPaletteValuesProperty;
+
+        pub fn parsePrelude(_: *This, name: []const u8, input: *css.Parser) Result(Prelude) {
+            return .{ .err = input.newError(css.BasicParseErrorKind{ .at_rule_invalid = name }) };
+        }
+
+        pub fn parseBlock(_: *This, _: AtRuleParser.Prelude, _: *const css.ParserState, input: *css.Parser) Result(AtRuleParser.AtRule) {
+            return .{ .err = input.newError(css.BasicParseErrorKind.at_rule_body_invalid) };
+        }
+
+        pub fn ruleWithoutBlock(_: *This, _: AtRuleParser.Prelude, _: *const css.ParserState) css.Maybe(AtRuleParser.AtRule, void) {
+            return .{ .err = {} };
+        }
+    };
+
+    pub const QualifiedRuleParser = struct {
+        pub const Prelude = void;
+        pub const QualifiedRule = FontPaletteValuesProperty;
+
+        pub fn parsePrelude(_: *This, input: *css.Parser) Result(Prelude) {
+            return .{ .err = input.newError(css.BasicParseErrorKind.qualified_rule_invalid) };
+        }
+
+        pub fn parseBlock(_: *This, _: Prelude, _: *const css.ParserState, input: *css.Parser) Result(QualifiedRule) {
+            return .{ .err = input.newError(css.BasicParseErrorKind.qualified_rule_invalid) };
+        }
+    };
+};
diff --git a/src/css/rules/import.zig b/src/css/rules/import.zig
new file mode 100644
index 0000000000..7c42e67834
--- /dev/null
+++ b/src/css/rules/import.zig
@@ -0,0 +1,178 @@
+const std = @import("std");
+const bun = @import("root").bun;
+pub const css = @import("../css_parser.zig");
+const Error = css.Error;
+const ArrayList = std.ArrayListUnmanaged;
+const MediaList = css.MediaList;
+const CustomMedia = css.CustomMedia;
+const Printer = css.Printer;
+const Maybe = css.Maybe;
+const PrinterError = css.PrinterError;
+const PrintErr = css.PrintErr;
+const Dependency = css.Dependency;
+const dependencies = css.dependencies;
+const Url = css.css_values.url.Url;
+const Size2D = css.css_values.size.Size2D;
+const fontprops = css.css_properties.font;
+const LayerName = css.css_rules.layer.LayerName;
+const SupportsCondition = css.css_rules.supports.SupportsCondition;
+const Location = css.css_rules.Location;
+
+pub const ImportConditions = struct {
+    /// An optional cascade layer name, or `None` for an anonymous layer.
+    layer: ?struct {
+        /// PERF: null pointer optimizaiton, nullable
+        v: ?LayerName,
+    },
+
+    /// An optional `supports()` condition.
+    supports: ?SupportsCondition,
+
+    /// A media query.
+    media: css.MediaList,
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) ImportConditions {
+        return ImportConditions{
+            .layer = if (this.layer) |*l| if (l.v) |layer| .{ .v = layer.deepClone(allocator) } else .{ .v = null } else null,
+            .supports = if (this.supports) |*s| s.deepClone(allocator) else null,
+            .media = this.media.deepClone(allocator),
+        };
+    }
+
+    pub fn layersEql(lhs: *const @This(), rhs: *const @This()) bool {
+        if (lhs.layer) |ll| {
+            if (rhs.layer) |rl| {
+                if (ll.v) |lv| {
+                    if (rl.v) |rv| {
+                        return lv.eql(&rv);
+                    }
+                    return false;
+                }
+                return true;
+            }
+            return false;
+        }
+        return false;
+    }
+};
+
+/// A [@import](https://drafts.csswg.org/css-cascade/#at-import) rule.
+pub const ImportRule = struct {
+    /// The url to import.
+    url: []const u8,
+
+    /// An optional cascade layer name, or `None` for an anonymous layer.
+    layer: ?struct {
+        /// PERF: null pointer optimizaiton, nullable
+        v: ?LayerName,
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    },
+
+    /// An optional `supports()` condition.
+    supports: ?SupportsCondition,
+
+    /// A media query.
+    media: css.MediaList,
+
+    /// This is default initialized to 2^32 - 1 when parsing.
+    /// If we are bundling, this will be set to the index of the corresponding ImportRecord
+    /// created for this import rule.
+    import_record_idx: u32 = std.math.maxInt(u32),
+
+    /// The location of the rule in the source file.
+    loc: Location,
+
+    const This = @This();
+
+    pub fn fromUrl(url: []const u8) This {
+        return .{
+            .url = url,
+            .layer = null,
+            .supports = null,
+            .media = MediaList{ .media_queries = .{} },
+            .import_record_idx = std.math.maxInt(u32),
+            .loc = Location.dummy(),
+        };
+    }
+
+    pub fn fromConditionsAndUrl(url: []const u8, conditions: ImportConditions) This {
+        return ImportRule{
+            .url = url,
+            .layer = if (conditions.layer) |layer| if (layer.v) |ly| .{ .v = ly } else .{ .v = null } else null,
+            .supports = conditions.supports,
+            .media = conditions.media,
+            .import_record_idx = std.math.maxInt(u32),
+            .loc = Location.dummy(),
+        };
+    }
+
+    pub fn conditionsOwned(this: *const This, allocator: std.mem.Allocator) ImportConditions {
+        return ImportConditions{
+            .layer = if (this.layer) |*l| if (l.v) |layer| .{ .v = layer.deepClone(allocator) } else .{ .v = null } else null,
+            .supports = if (this.supports) |*s| s.deepClone(allocator) else null,
+            .media = this.media.deepClone(allocator),
+        };
+    }
+
+    pub fn hasConditions(this: *const This) bool {
+        return this.layer != null or this.supports != null or this.media.media_queries.items.len > 0;
+    }
+
+    pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        const dep = if (dest.dependencies != null) dependencies.ImportDependency.new(
+            dest.allocator,
+            this,
+            dest.filename(),
+        ) else null;
+
+        // #[cfg(feature = "sourcemap")]
+        // dest.add_mapping(self.loc);
+
+        try dest.writeStr("@import ");
+        if (dep) |d| {
+            css.serializer.serializeString(d.placeholder, dest) catch return dest.addFmtError();
+
+            if (dest.dependencies) |*deps| {
+                deps.append(
+                    dest.allocator,
+                    Dependency{ .import = d },
+                ) catch unreachable;
+            }
+        } else {
+            css.serializer.serializeString(this.url, dest) catch return dest.addFmtError();
+        }
+
+        if (this.layer) |*lyr| {
+            try dest.writeStr(" layer");
+            if (lyr.v) |l| {
+                try dest.writeChar('(');
+                try l.toCss(W, dest);
+                try dest.writeChar(')');
+            }
+        }
+
+        if (this.supports) |*sup| {
+            try dest.writeStr(" supports");
+            if (sup.* == .declaration) {
+                try sup.toCss(W, dest);
+            } else {
+                try dest.writeChar('(');
+                try sup.toCss(W, dest);
+                try dest.writeChar(')');
+            }
+        }
+
+        if (this.media.media_queries.items.len > 0) {
+            try dest.writeChar(' ');
+            try this.media.toCss(W, dest);
+        }
+        try dest.writeStr(";");
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) This {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
diff --git a/src/css/rules/keyframes.zig b/src/css/rules/keyframes.zig
new file mode 100644
index 0000000000..640683d41a
--- /dev/null
+++ b/src/css/rules/keyframes.zig
@@ -0,0 +1,315 @@
+const std = @import("std");
+pub const css = @import("../css_parser.zig");
+const bun = @import("root").bun;
+const ArrayList = std.ArrayListUnmanaged;
+const MediaList = css.MediaList;
+const CustomMedia = css.CustomMedia;
+const Printer = css.Printer;
+const Maybe = css.Maybe;
+const PrinterError = css.PrinterError;
+const PrintErr = css.PrintErr;
+const Dependency = css.Dependency;
+const dependencies = css.dependencies;
+const Url = css.css_values.url.Url;
+const Size2D = css.css_values.size.Size2D;
+const fontprops = css.css_properties.font;
+const LayerName = css.css_rules.layer.LayerName;
+const SupportsCondition = css.css_rules.supports.SupportsCondition;
+const Location = css.css_rules.Location;
+const Result = css.Result;
+
+pub const KeyframesListParser = struct {
+    const This = @This();
+
+    pub const DeclarationParser = struct {
+        pub const Declaration = Keyframe;
+
+        pub fn parseValue(_: *This, name: []const u8, input: *css.Parser) Result(Declaration) {
+            return .{ .err = input.newError(css.BasicParseErrorKind{ .unexpected_token = .{ .ident = name } }) };
+        }
+    };
+
+    pub const RuleBodyItemParser = struct {
+        pub fn parseQualified(_: *This) bool {
+            return true;
+        }
+
+        pub fn parseDeclarations(_: *This) bool {
+            return false;
+        }
+    };
+
+    pub const AtRuleParser = struct {
+        pub const Prelude = void;
+        pub const AtRule = Keyframe;
+
+        pub fn parsePrelude(_: *This, name: []const u8, input: *css.Parser) Result(Prelude) {
+            return .{ .err = input.newError(css.BasicParseErrorKind{ .at_rule_invalid = name }) };
+        }
+
+        pub fn parseBlock(_: *This, _: AtRuleParser.Prelude, _: *const css.ParserState, input: *css.Parser) Result(AtRuleParser.AtRule) {
+            return .{ .err = input.newError(css.BasicParseErrorKind.at_rule_body_invalid) };
+        }
+
+        pub fn ruleWithoutBlock(_: *This, _: AtRuleParser.Prelude, _: *const css.ParserState) css.Maybe(AtRuleParser.AtRule, void) {
+            return .{ .err = {} };
+        }
+    };
+
+    pub const QualifiedRuleParser = struct {
+        pub const Prelude = ArrayList(KeyframeSelector);
+        pub const QualifiedRule = Keyframe;
+
+        pub fn parsePrelude(_: *This, input: *css.Parser) Result(Prelude) {
+            return input.parseCommaSeparated(KeyframeSelector, KeyframeSelector.parse);
+        }
+
+        pub fn parseBlock(_: *This, prelude: Prelude, _: *const css.ParserState, input: *css.Parser) Result(QualifiedRule) {
+            // For now there are no options that apply within @keyframes
+            const options = css.ParserOptions.default(input.allocator(), null);
+            return .{
+                .result = Keyframe{
+                    .selectors = prelude,
+                    .declarations = switch (css.DeclarationBlock.parse(input, &options)) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    },
+                },
+            };
+        }
+    };
+};
+
+/// KeyframesName
+pub const KeyframesName = union(enum) {
+    /// `<custom-ident>` of a `@keyframes` name.
+    ident: css.css_values.ident.CustomIdent,
+    /// `<string>` of a `@keyframes` name.
+    custom: []const u8,
+
+    const This = @This();
+
+    pub fn HashMap(comptime V: type) type {
+        return std.ArrayHashMapUnmanaged(KeyframesName, V, struct {
+            pub fn hash(_: @This(), key: KeyframesName) u32 {
+                return switch (key) {
+                    .ident => std.array_hash_map.hashString(key.ident.v),
+                    .custom => std.array_hash_map.hashString(key.custom),
+                };
+            }
+
+            pub fn eql(_: @This(), a: KeyframesName, b: KeyframesName, _: usize) bool {
+                return switch (a) {
+                    .ident => switch (b) {
+                        .ident => bun.strings.eql(a.ident.v, b.ident.v),
+                        .custom => false,
+                    },
+                    .custom => switch (b) {
+                        .ident => false,
+                        .custom => bun.strings.eql(a.custom, b.custom),
+                    },
+                };
+            }
+        }, false);
+    }
+
+    pub fn parse(input: *css.Parser) Result(KeyframesName) {
+        switch (switch (input.next()) {
+            .result => |v| v.*,
+            .err => |e| return .{ .err = e },
+        }) {
+            .ident => |s| {
+                // todo_stuff.match_ignore_ascii_case
+                // CSS-wide keywords without quotes throws an error.
+                if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(s, "none") or
+                    bun.strings.eqlCaseInsensitiveASCIIICheckLength(s, "initial") or
+                    bun.strings.eqlCaseInsensitiveASCIIICheckLength(s, "inherit") or
+                    bun.strings.eqlCaseInsensitiveASCIIICheckLength(s, "unset") or
+                    bun.strings.eqlCaseInsensitiveASCIIICheckLength(s, "default") or
+                    bun.strings.eqlCaseInsensitiveASCIIICheckLength(s, "revert") or
+                    bun.strings.eqlCaseInsensitiveASCIIICheckLength(s, "revert-layer"))
+                {
+                    return .{ .err = input.newUnexpectedTokenError(.{ .ident = s }) };
+                } else {
+                    return .{ .result = .{ .ident = .{ .v = s } } };
+                }
+            },
+            .quoted_string => |s| return .{ .result = .{ .custom = s } },
+            else => |t| {
+                return .{ .err = input.newUnexpectedTokenError(t) };
+            },
+        }
+    }
+
+    pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        const css_module_aimation_enabled = if (dest.css_module) |css_module| css_module.config.animation else false;
+
+        switch (this.*) {
+            .ident => |ident| {
+                try dest.writeIdent(ident.v, css_module_aimation_enabled);
+            },
+            .custom => |s| {
+                // todo_stuff.match_ignore_ascii_case
+                // CSS-wide keywords and `none` cannot remove quotes.
+                if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(s, "none") or
+                    bun.strings.eqlCaseInsensitiveASCIIICheckLength(s, "initial") or
+                    bun.strings.eqlCaseInsensitiveASCIIICheckLength(s, "inherit") or
+                    bun.strings.eqlCaseInsensitiveASCIIICheckLength(s, "unset") or
+                    bun.strings.eqlCaseInsensitiveASCIIICheckLength(s, "default") or
+                    bun.strings.eqlCaseInsensitiveASCIIICheckLength(s, "revert") or
+                    bun.strings.eqlCaseInsensitiveASCIIICheckLength(s, "revert-layer"))
+                {
+                    css.serializer.serializeString(s, dest) catch return dest.addFmtError();
+                } else {
+                    try dest.writeIdent(s, css_module_aimation_enabled);
+                }
+            },
+        }
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+pub const KeyframeSelector = union(enum) {
+    /// An explicit percentage.
+    percentage: css.css_values.percentage.Percentage,
+    /// The `from` keyword. Equivalent to 0%.
+    from,
+    /// The `to` keyword. Equivalent to 100%.
+    to,
+
+    // TODO: implement this
+    pub usingnamespace css.DeriveParse(@This());
+
+    // pub fn parse(input: *css.Parser) Result(KeyframeSelector) {
+    //     _ = input; // autofix
+    //     @panic(css.todo_stuff.depth);
+    // }
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+        switch (this.*) {
+            .percentage => |p| {
+                if (dest.minify and p.v == 1.0) {
+                    try dest.writeStr("to");
+                } else {
+                    try p.toCss(W, dest);
+                }
+            },
+            .from => {
+                if (dest.minify) {
+                    try dest.writeStr("0%");
+                } else {
+                    try dest.writeStr("from");
+                }
+            },
+            .to => {
+                try dest.writeStr("to");
+            },
+        }
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// An individual keyframe within an `@keyframes` rule.
+///
+/// See [KeyframesRule](KeyframesRule).
+pub const Keyframe = struct {
+    /// A list of keyframe selectors to associate with the declarations in this keyframe.
+    selectors: ArrayList(KeyframeSelector),
+    /// The declarations for this keyframe.
+    declarations: css.DeclarationBlock,
+
+    const This = @This();
+
+    pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        var first = true;
+        for (this.selectors.items) |sel| {
+            if (!first) {
+                try dest.delim(',', false);
+            }
+            first = false;
+            try sel.toCss(W, dest);
+        }
+
+        try this.declarations.toCssBlock(W, dest);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+pub const KeyframesRule = struct {
+    /// The animation name.
+    /// <keyframes-name> = <custom-ident> | <string>
+    name: KeyframesName,
+    /// A list of keyframes in the animation.
+    keyframes: ArrayList(Keyframe),
+    /// A vendor prefix for the rule, e.g. `@-webkit-keyframes`.
+    vendor_prefix: css.VendorPrefix,
+    /// The location of the rule in the source file.
+    loc: Location,
+
+    const This = @This();
+
+    pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        // #[cfg(feature = "sourcemap")]
+        // dest.add_mapping(self.loc);
+
+        var first_rule = true;
+
+        const PREFIXES = .{ "webkit", "moz", "ms", "o", "none" };
+
+        inline for (PREFIXES) |prefix_name| {
+            const prefix = css.VendorPrefix.fromName(prefix_name);
+
+            if (this.vendor_prefix.contains(prefix)) {
+                if (first_rule) {
+                    first_rule = false;
+                } else {
+                    if (!dest.minify) {
+                        try dest.writeChar('\n'); // no indent
+                    }
+                    try dest.newline();
+                }
+
+                try dest.writeChar('@');
+                try prefix.toCss(W, dest);
+                try dest.writeStr("keyframes ");
+                try this.name.toCss(W, dest);
+                try dest.whitespace();
+                try dest.writeChar('{');
+                dest.indent();
+
+                var first = true;
+                for (this.keyframes.items) |*keyframe| {
+                    if (first) {
+                        first = false;
+                    } else if (!dest.minify) {
+                        try dest.writeChar('\n'); // no indent
+                    }
+                    try dest.newline();
+                    try keyframe.toCss(W, dest);
+                }
+                dest.dedent();
+                try dest.newline();
+                try dest.writeChar('}');
+            }
+        }
+    }
+
+    pub fn getFallbacks(this: *This, comptime T: type, targets: *const css.targets.Targets) []css.CssRule(T) {
+        _ = this; // autofix
+        _ = targets; // autofix
+        @panic(css.todo_stuff.depth);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) This {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
diff --git a/src/css/rules/layer.zig b/src/css/rules/layer.zig
new file mode 100644
index 0000000000..05c2d692a8
--- /dev/null
+++ b/src/css/rules/layer.zig
@@ -0,0 +1,186 @@
+const std = @import("std");
+const bun = @import("root").bun;
+pub const css = @import("../css_parser.zig");
+const ArrayList = std.ArrayListUnmanaged;
+const MediaList = css.MediaList;
+const CustomMedia = css.CustomMedia;
+const Printer = css.Printer;
+const Maybe = css.Maybe;
+const PrinterError = css.PrinterError;
+const PrintErr = css.PrintErr;
+const SupportsCondition = css.css_rules.supports.SupportsCondition;
+const Location = css.css_rules.Location;
+const Result = css.Result;
+
+// TODO: make this equivalent of SmallVec<[CowArcStr<'i>; 1]
+pub const LayerName = struct {
+    v: css.SmallList([]const u8, 1) = .{},
+
+    pub fn HashMap(comptime V: type) type {
+        return std.ArrayHashMapUnmanaged(LayerName, V, struct {
+            pub fn hash(_: @This(), key: LayerName) u32 {
+                var hasher = std.hash.Wyhash.init(0);
+                for (key.v.items) |part| {
+                    hasher.update(part);
+                }
+                return hasher.final();
+            }
+
+            pub fn eql(_: @This(), a: LayerName, b: LayerName, _: usize) bool {
+                if (a.v.len != b.v.len) return false;
+                for (a.v.items, 0..) |part, i| {
+                    if (!bun.strings.eql(part, b.v.items[i])) return false;
+                }
+                return true;
+            }
+        }, false);
+    }
+
+    pub fn deepClone(this: *const LayerName, allocator: std.mem.Allocator) LayerName {
+        return LayerName{
+            .v = this.v.clone(allocator),
+        };
+    }
+
+    pub fn eql(lhs: *const LayerName, rhs: *const LayerName) bool {
+        if (lhs.v.len() != rhs.v.len()) return false;
+        for (lhs.v.slice(), 0..) |part, i| {
+            if (!bun.strings.eql(part, rhs.v.at(@intCast(i)).*)) return false;
+        }
+        return true;
+    }
+
+    pub fn parse(input: *css.Parser) Result(LayerName) {
+        var parts: css.SmallList([]const u8, 1) = .{};
+        const ident = switch (input.expectIdent()) {
+            .result => |v| v,
+            .err => |e| return .{ .err = e },
+        };
+        parts.append(
+            input.allocator(),
+            ident,
+        );
+
+        while (true) {
+            const Fn = struct {
+                pub fn tryParseFn(
+                    i: *css.Parser,
+                ) Result([]const u8) {
+                    const name = name: {
+                        out: {
+                            const start_location = i.currentSourceLocation();
+                            const tok = switch (i.nextIncludingWhitespace()) {
+                                .err => |e| return .{ .err = e },
+                                .result => |vvv| vvv,
+                            };
+                            if (tok.* == .delim and tok.delim == '.') {
+                                break :out;
+                            }
+                            return .{ .err = start_location.newBasicUnexpectedTokenError(tok.*) };
+                        }
+
+                        const start_location = i.currentSourceLocation();
+                        const tok = switch (i.nextIncludingWhitespace()) {
+                            .err => |e| return .{ .err = e },
+                            .result => |vvv| vvv,
+                        };
+                        if (tok.* == .ident) {
+                            break :name tok.ident;
+                        }
+                        return .{ .err = start_location.newBasicUnexpectedTokenError(tok.*) };
+                    };
+                    return .{ .result = name };
+                }
+            };
+
+            while (true) {
+                const name = switch (input.tryParse(Fn.tryParseFn, .{})) {
+                    .err => break,
+                    .result => |vvv| vvv,
+                };
+                parts.append(
+                    input.allocator(),
+                    name,
+                );
+            }
+
+            return .{ .result = LayerName{ .v = parts } };
+        }
+    }
+
+    pub fn toCss(this: *const LayerName, comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+        var first = true;
+        for (this.v.slice()) |name| {
+            if (first) {
+                first = false;
+            } else {
+                try dest.writeChar('.');
+            }
+
+            css.serializer.serializeIdentifier(name, dest) catch return dest.addFmtError();
+        }
+    }
+};
+
+/// A [@layer block](https://drafts.csswg.org/css-cascade-5/#layer-block) rule.
+pub fn LayerBlockRule(comptime R: type) type {
+    return struct {
+        /// PERF: null pointer optimizaiton, nullable
+        /// The name of the layer to declare, or `None` to declare an anonymous layer.
+        name: ?LayerName,
+        /// The rules within the `@layer` rule.
+        rules: css.CssRuleList(R),
+        /// The location of the rule in the source file.
+        loc: Location,
+
+        const This = @This();
+
+        pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+            // #[cfg(feature = "sourcemap")]
+            // dest.add_mapping(self.loc);
+
+            try dest.writeStr("@layer");
+            if (this.name) |*name| {
+                try dest.writeChar(' ');
+                try name.toCss(W, dest);
+            }
+
+            try dest.whitespace();
+            try dest.writeChar('{');
+            dest.indent();
+            try dest.newline();
+            try this.rules.toCss(W, dest);
+            dest.dedent();
+            try dest.newline();
+            try dest.writeChar('}');
+        }
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) This {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    };
+}
+
+/// A [@layer statement](https://drafts.csswg.org/css-cascade-5/#layer-empty) rule.
+///
+/// See also [LayerBlockRule](LayerBlockRule).
+pub const LayerStatementRule = struct {
+    /// The layer names to declare.
+    names: ArrayList(LayerName),
+    /// The location of the rule in the source file.
+    loc: Location,
+
+    const This = @This();
+
+    pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        // #[cfg(feature = "sourcemap")]
+        // dest.add_mapping(self.loc);
+        try dest.writeStr("@layer ");
+        try css.to_css.fromList(LayerName, &this.names, W, dest);
+        try dest.writeChar(';');
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) This {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
diff --git a/src/css/rules/media.zig b/src/css/rules/media.zig
new file mode 100644
index 0000000000..7cbb5214ac
--- /dev/null
+++ b/src/css/rules/media.zig
@@ -0,0 +1,58 @@
+const std = @import("std");
+pub const css = @import("../css_parser.zig");
+const bun = @import("root").bun;
+const Error = css.Error;
+const ArrayList = std.ArrayListUnmanaged;
+const MediaList = css.MediaList;
+const CustomMedia = css.CustomMedia;
+const Printer = css.Printer;
+const Maybe = css.Maybe;
+const PrinterError = css.PrinterError;
+const PrintErr = css.PrintErr;
+const Location = css.css_rules.Location;
+const style = css.css_rules.style;
+const CssRuleList = css.CssRuleList;
+
+pub fn MediaRule(comptime R: type) type {
+    return struct {
+        /// The media query list.
+        query: css.MediaList,
+        /// The rules within the `@media` rule.
+        rules: css.CssRuleList(R),
+        /// The location of the rule in the source file.
+        loc: Location,
+
+        const This = @This();
+
+        pub fn minify(this: *This, context: *css.MinifyContext, parent_is_unused: bool) css.MinifyErr!bool {
+            _ = this; // autofix
+            _ = context; // autofix
+            _ = parent_is_unused; // autofix
+            return false;
+        }
+
+        pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+            if (dest.minify and this.query.alwaysMatches()) {
+                try this.rules.toCss(W, dest);
+                return;
+            }
+            // #[cfg(feature = "sourcemap")]
+            // dest.addMapping(this.loc);
+
+            try dest.writeStr("@media ");
+            try this.query.toCss(W, dest);
+            try dest.whitespace();
+            try dest.writeChar('{');
+            dest.indent();
+            try dest.newline();
+            try this.rules.toCss(W, dest);
+            dest.dedent();
+            try dest.newline();
+            return dest.writeChar('}');
+        }
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) This {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    };
+}
diff --git a/src/css/rules/namespace.zig b/src/css/rules/namespace.zig
new file mode 100644
index 0000000000..30bdade77f
--- /dev/null
+++ b/src/css/rules/namespace.zig
@@ -0,0 +1,41 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const bun = @import("root").bun;
+const logger = bun.logger;
+const Log = logger.Log;
+
+pub const css = @import("../css_parser.zig");
+pub const css_values = @import("../values/values.zig");
+pub const Error = css.Error;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+
+/// A [@namespace](https://drafts.csswg.org/css-namespaces/#declaration) rule.
+pub const NamespaceRule = struct {
+    /// An optional namespace prefix to declare, or `None` to declare the default namespace.
+    prefix: ?css.Ident,
+    /// The url of the namespace.
+    url: css.CSSString,
+    /// The location of the rule in the source file.
+    loc: css.Location,
+
+    const This = @This();
+
+    pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        // #[cfg(feature = "sourcemap")]
+        // dest.add_mapping(self.loc);
+
+        try dest.writeStr("@namespace ");
+        if (this.prefix) |*prefix| {
+            try css.css_values.ident.IdentFns.toCss(prefix, W, dest);
+            try dest.writeChar(' ');
+        }
+
+        try css.css_values.string.CSSStringFns.toCss(&this.url, W, dest);
+        try dest.writeChar(':');
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) This {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
diff --git a/src/css/rules/nesting.zig b/src/css/rules/nesting.zig
new file mode 100644
index 0000000000..9aceb97b51
--- /dev/null
+++ b/src/css/rules/nesting.zig
@@ -0,0 +1,38 @@
+const std = @import("std");
+pub const css = @import("../css_parser.zig");
+const bun = @import("root").bun;
+const Error = css.Error;
+const ArrayList = std.ArrayListUnmanaged;
+const MediaList = css.MediaList;
+const CustomMedia = css.CustomMedia;
+const Printer = css.Printer;
+const Maybe = css.Maybe;
+const PrinterError = css.PrinterError;
+const PrintErr = css.PrintErr;
+const Location = css.css_rules.Location;
+const style = css.css_rules.style;
+
+/// A [@nest](https://www.w3.org/TR/css-nesting-1/#at-nest) rule.
+pub fn NestingRule(comptime R: type) type {
+    return struct {
+        /// The style rule that defines the selector and declarations for the `@nest` rule.
+        style: style.StyleRule(R),
+        /// The location of the rule in the source file.
+        loc: Location,
+
+        const This = @This();
+
+        pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+            // #[cfg(feature = "sourcemap")]
+            // dest.add_mapping(self.loc);
+            if (dest.context() == null) {
+                try dest.writeStr("@nest ");
+            }
+            return try this.style.toCss(W, dest);
+        }
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) This {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    };
+}
diff --git a/src/css/rules/page.zig b/src/css/rules/page.zig
new file mode 100644
index 0000000000..267c49f8c5
--- /dev/null
+++ b/src/css/rules/page.zig
@@ -0,0 +1,400 @@
+const std = @import("std");
+pub const css = @import("../css_parser.zig");
+const bun = @import("root").bun;
+const Result = css.Result;
+const ArrayList = std.ArrayListUnmanaged;
+const MediaList = css.MediaList;
+const CustomMedia = css.CustomMedia;
+const Printer = css.Printer;
+const Maybe = css.Maybe;
+const PrinterError = css.PrinterError;
+const PrintErr = css.PrintErr;
+const Dependency = css.Dependency;
+const dependencies = css.dependencies;
+const Url = css.css_values.url.Url;
+const Size2D = css.css_values.size.Size2D;
+const fontprops = css.css_properties.font;
+const LayerName = css.css_rules.layer.LayerName;
+const SupportsCondition = css.css_rules.supports.SupportsCondition;
+const Location = css.css_rules.Location;
+const Angle = css.css_values.angle.Angle;
+const FontStyleProperty = css.css_properties.font.FontStyle;
+const FontFamily = css.css_properties.font.FontFamily;
+const FontWeight = css.css_properties.font.FontWeight;
+const FontStretch = css.css_properties.font.FontStretch;
+const CustomProperty = css.css_properties.custom.CustomProperty;
+const CustomPropertyName = css.css_properties.custom.CustomPropertyName;
+const DashedIdent = css.css_values.ident.DashedIdent;
+
+/// A [page selector](https://www.w3.org/TR/css-page-3/#typedef-page-selector)
+/// within a `@page` rule.
+///
+/// Either a name or at least one pseudo class is required.
+pub const PageSelector = struct {
+    /// An optional named page type.
+    name: ?[]const u8,
+    /// A list of page pseudo classes.
+    pseudo_classes: ArrayList(PagePseudoClass),
+
+    pub fn parse(input: *css.Parser) Result(PageSelector) {
+        const name = if (input.tryParse(css.Parser.expectIdent, .{}).asValue()) |name| name else null;
+        var pseudo_classes = ArrayList(PagePseudoClass){};
+
+        while (true) {
+            // Whitespace is not allowed between pseudo classes
+            const state = input.state();
+            if (switch (input.nextIncludingWhitespace()) {
+                .result => |tok| tok.* == .colon,
+                .err => |e| return .{ .err = e },
+            }) {
+                pseudo_classes.append(
+                    input.allocator(),
+                    switch (PagePseudoClass.parse(input)) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    },
+                ) catch bun.outOfMemory();
+            } else {
+                input.reset(&state);
+                break;
+            }
+        }
+
+        if (name == null and pseudo_classes.items.len == 0) {
+            return .{ .err = input.newCustomError(css.ParserError.invalid_page_selector) };
+        }
+
+        return .{
+            .result = PageSelector{
+                .name = name,
+                .pseudo_classes = pseudo_classes,
+            },
+        };
+    }
+
+    const This = @This();
+
+    pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        if (this.name) |name| {
+            try dest.writeStr(name);
+        }
+
+        for (this.pseudo_classes.items) |*pseudo| {
+            try dest.writeChar(':');
+            try pseudo.toCss(W, dest);
+        }
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+pub const PageMarginRule = struct {
+    /// The margin box identifier for this rule.
+    margin_box: PageMarginBox,
+    /// The declarations within the rule.
+    declarations: css.DeclarationBlock,
+    /// The location of the rule in the source file.
+    loc: Location,
+
+    const This = @This();
+
+    pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        // #[cfg(feature = "sourcemap")]
+        // dest.add_mapping(self.loc);
+
+        try dest.writeChar('@');
+        try this.margin_box.toCss(W, dest);
+        try this.declarations.toCssBlock(W, dest);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A [@page](https://www.w3.org/TR/css-page-3/#at-page-rule) rule.
+pub const PageRule = struct {
+    /// A list of page selectors.
+    selectors: ArrayList(PageSelector),
+    /// The declarations within the `@page` rule.
+    declarations: css.DeclarationBlock,
+    /// The nested margin rules.
+    rules: ArrayList(PageMarginRule),
+    /// The location of the rule in the source file.
+    loc: Location,
+
+    pub fn parse(selectors: ArrayList(PageSelector), input: *css.Parser, loc: Location, options: *const css.ParserOptions) Result(PageRule) {
+        var declarations = css.DeclarationBlock{};
+        var rules = ArrayList(PageMarginRule){};
+        var rule_parser = PageRuleParser{
+            .declarations = &declarations,
+            .rules = &rules,
+            .options = options,
+        };
+        var parser = css.RuleBodyParser(PageRuleParser).new(input, &rule_parser);
+
+        while (parser.next()) |decl| {
+            if (decl.asErr()) |e| {
+                if (parser.parser.options.error_recovery) {
+                    parser.parser.options.warn(e);
+                    continue;
+                }
+
+                return .{ .err = e };
+            }
+        }
+
+        return .{ .result = PageRule{
+            .selectors = selectors,
+            .declarations = declarations,
+            .rules = rules,
+            .loc = loc,
+        } };
+    }
+
+    const This = @This();
+
+    pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        // #[cfg(feature = "sourcemap")]
+        // dest.add_mapping(self.loc);
+        try dest.writeStr("@page");
+        if (this.selectors.items.len >= 1) {
+            const firstsel = &this.selectors.items[0];
+            // Space is only required if the first selector has a name.
+            if (!dest.minify and firstsel.name != null) {
+                try dest.writeChar(' ');
+            }
+            var first = true;
+            for (this.selectors.items) |selector| {
+                if (first) {
+                    first = false;
+                } else {
+                    try dest.delim(',', false);
+                }
+                try selector.toCss(W, dest);
+            }
+        }
+
+        try dest.whitespace();
+        try dest.writeChar('{');
+        dest.indent();
+
+        var i: usize = 0;
+        const len = this.declarations.len() + this.rules.items.len;
+
+        const DECLS = .{ "declarations", "important_declarations" };
+        inline for (DECLS) |decl_field_name| {
+            const decls: *const ArrayList(css.Property) = &@field(this.declarations, decl_field_name);
+            const important = comptime std.mem.eql(u8, decl_field_name, "important_declarations");
+            for (decls.items) |*decl| {
+                try dest.newline();
+                try decl.toCss(W, dest, important);
+                if (i != len - 1 or !dest.minify) {
+                    try dest.writeChar(';');
+                }
+                i += 1;
+            }
+        }
+
+        if (this.rules.items.len > 0) {
+            if (!dest.minify and this.declarations.len() > 0) {
+                try dest.writeChar('\n');
+            }
+            try dest.newline();
+
+            var first = true;
+            for (this.rules.items) |*rule| {
+                if (first) {
+                    first = false;
+                } else {
+                    if (!dest.minify) {
+                        try dest.writeChar('\n');
+                    }
+                    try dest.newline();
+                }
+                try rule.toCss(W, dest);
+            }
+        }
+
+        dest.dedent();
+        try dest.newline();
+        try dest.writeChar('}');
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) This {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A page pseudo class within an `@page` selector.
+///
+/// See [PageSelector](PageSelector).
+pub const PagePseudoClass = enum {
+    /// The `:left` pseudo class.
+    left,
+    /// The `:right` pseudo class.
+    right,
+    /// The `:first` pseudo class.
+    first,
+    /// The `:last` pseudo class.
+    last,
+    /// The `:blank` pseudo class.
+    blank,
+
+    pub fn asStr(this: *const @This()) []const u8 {
+        return css.enum_property_util.asStr(@This(), this);
+    }
+
+    pub fn parse(input: *css.Parser) Result(@This()) {
+        return css.enum_property_util.parse(@This(), input);
+    }
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+        return css.enum_property_util.toCss(@This(), this, W, dest);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A [page margin box](https://www.w3.org/TR/css-page-3/#margin-boxes).
+pub const PageMarginBox = enum {
+    /// A fixed-size box defined by the intersection of the top and left margins of the page box.
+    @"top-left-corner",
+    /// A variable-width box filling the top page margin between the top-left-corner and top-center page-margin boxes.
+    @"top-left",
+    /// A variable-width box centered horizontally between the page’s left and right border edges and filling the
+    /// page top margin between the top-left and top-right page-margin boxes.
+    @"top-center",
+    /// A variable-width box filling the top page margin between the top-center and top-right-corner page-margin boxes.
+    @"top-right",
+    /// A fixed-size box defined by the intersection of the top and right margins of the page box.
+    @"top-right-corner",
+    /// A variable-height box filling the left page margin between the top-left-corner and left-middle page-margin boxes.
+    @"left-top",
+    /// A variable-height box centered vertically between the page’s top and bottom border edges and filling the
+    /// left page margin between the left-top and left-bottom page-margin boxes.
+    @"left-middle",
+    /// A variable-height box filling the left page margin between the left-middle and bottom-left-corner page-margin boxes.
+    @"left-bottom",
+    /// A variable-height box filling the right page margin between the top-right-corner and right-middle page-margin boxes.
+    @"right-top",
+    /// A variable-height box centered vertically between the page’s top and bottom border edges and filling the right
+    /// page margin between the right-top and right-bottom page-margin boxes.
+    @"right-middle",
+    /// A variable-height box filling the right page margin between the right-middle and bottom-right-corner page-margin boxes.
+    @"right-bottom",
+    /// A fixed-size box defined by the intersection of the bottom and left margins of the page box.
+    @"bottom-left-corner",
+    /// A variable-width box filling the bottom page margin between the bottom-left-corner and bottom-center page-margin boxes.
+    @"bottom-left",
+    /// A variable-width box centered horizontally between the page’s left and right border edges and filling the bottom
+    /// page margin between the bottom-left and bottom-right page-margin boxes.
+    @"bottom-center",
+    /// A variable-width box filling the bottom page margin between the bottom-center and bottom-right-corner page-margin boxes.
+    @"bottom-right",
+    /// A fixed-size box defined by the intersection of the bottom and right margins of the page box.
+    @"bottom-right-corner",
+
+    pub fn asStr(this: *const @This()) []const u8 {
+        return css.enum_property_util.asStr(@This(), this);
+    }
+
+    pub fn parse(input: *css.Parser) Result(@This()) {
+        return css.enum_property_util.parse(@This(), input);
+    }
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+        return css.enum_property_util.toCss(@This(), this, W, dest);
+    }
+};
+
+pub const PageRuleParser = struct {
+    declarations: *css.DeclarationBlock,
+    rules: *ArrayList(PageMarginRule),
+    options: *const css.ParserOptions,
+
+    const This = @This();
+
+    pub const DeclarationParser = struct {
+        pub const Declaration = void;
+
+        pub fn parseValue(this: *This, name: []const u8, input: *css.Parser) Result(Declaration) {
+            return css.declaration.parse_declaration(
+                name,
+                input,
+                &this.declarations.declarations,
+                &this.declarations.important_declarations,
+                this.options,
+            );
+        }
+    };
+
+    pub const RuleBodyItemParser = struct {
+        pub fn parseQualified(_: *This) bool {
+            return false;
+        }
+
+        pub fn parseDeclarations(_: *This) bool {
+            return true;
+        }
+    };
+
+    pub const AtRuleParser = struct {
+        pub const Prelude = PageMarginBox;
+        pub const AtRule = void;
+
+        pub fn parsePrelude(_: *This, name: []const u8, input: *css.Parser) Result(Prelude) {
+            const loc = input.currentSourceLocation();
+            return switch (css.parse_utility.parseString(
+                input.allocator(),
+                PageMarginBox,
+                name,
+                PageMarginBox.parse,
+            )) {
+                .result => |v| return .{ .result = v },
+                .err => {
+                    return .{ .err = loc.newCustomError(css.ParserError{ .at_rule_invalid = name }) };
+                },
+            };
+        }
+
+        pub fn parseBlock(this: *This, prelude: AtRuleParser.Prelude, start: *const css.ParserState, input: *css.Parser) Result(AtRuleParser.AtRule) {
+            const loc = start.sourceLocation();
+            const declarations = switch (css.DeclarationBlock.parse(input, this.options)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            };
+            this.rules.append(input.allocator(), PageMarginRule{
+                .margin_box = prelude,
+                .declarations = declarations,
+                .loc = Location{
+                    .source_index = this.options.source_index,
+                    .line = loc.line,
+                    .column = loc.column,
+                },
+            }) catch bun.outOfMemory();
+            return Result(AtRuleParser.AtRule).success;
+        }
+
+        pub fn ruleWithoutBlock(_: *This, _: AtRuleParser.Prelude, _: *const css.ParserState) css.Maybe(AtRuleParser.AtRule, void) {
+            return .{ .err = {} };
+        }
+    };
+
+    pub const QualifiedRuleParser = struct {
+        pub const Prelude = void;
+        pub const QualifiedRule = void;
+
+        pub fn parsePrelude(_: *This, input: *css.Parser) Result(Prelude) {
+            return .{ .err = input.newError(css.BasicParseErrorKind.qualified_rule_invalid) };
+        }
+
+        pub fn parseBlock(_: *This, _: Prelude, _: *const css.ParserState, input: *css.Parser) Result(QualifiedRule) {
+            return .{ .err = input.newError(css.BasicParseErrorKind.qualified_rule_invalid) };
+        }
+    };
+};
diff --git a/src/css/rules/property.zig b/src/css/rules/property.zig
new file mode 100644
index 0000000000..b3044d1836
--- /dev/null
+++ b/src/css/rules/property.zig
@@ -0,0 +1,229 @@
+const std = @import("std");
+pub const css = @import("../css_parser.zig");
+const bun = @import("root").bun;
+const Result = css.Result;
+const ArrayList = std.ArrayListUnmanaged;
+const MediaList = css.MediaList;
+const CustomMedia = css.CustomMedia;
+const Printer = css.Printer;
+const Maybe = css.Maybe;
+const PrinterError = css.PrinterError;
+const PrintErr = css.PrintErr;
+const Location = css.css_rules.Location;
+const style = css.css_rules.style;
+const SyntaxString = css.css_values.syntax.SyntaxString;
+const ParsedComponent = css.css_values.syntax.ParsedComponent;
+
+pub const PropertyRule = struct {
+    name: css.css_values.ident.DashedIdent,
+    syntax: SyntaxString,
+    inherits: bool,
+    initial_value: ?css.css_values.syntax.ParsedComponent,
+    loc: Location,
+
+    pub fn parse(name: css.css_values.ident.DashedIdent, input: *css.Parser, loc: Location) Result(PropertyRule) {
+        var p = PropertyRuleDeclarationParser{
+            .syntax = null,
+            .inherits = null,
+            .initial_value = null,
+        };
+
+        var decl_parser = css.RuleBodyParser(PropertyRuleDeclarationParser).new(input, &p);
+        while (decl_parser.next()) |decl| {
+            if (decl.asErr()) |e| {
+                return .{ .err = e };
+            }
+        }
+
+        // `syntax` and `inherits` are always required.
+        const parser = decl_parser.parser;
+        // TODO(zack): source clones these two, but I omitted here becaues it seems 100% unnecessary
+        const syntax: SyntaxString = parser.syntax orelse return .{ .err = decl_parser.input.newCustomError(css.ParserError.at_rule_body_invalid) };
+        const inherits: bool = parser.inherits orelse return .{ .err = decl_parser.input.newCustomError(css.ParserError.at_rule_body_invalid) };
+
+        // `initial-value` is required unless the syntax is a universal definition.
+        const initial_value = switch (syntax) {
+            .universal => if (parser.initial_value) |val| brk: {
+                var i = css.ParserInput.new(input.allocator(), val);
+                var p2 = css.Parser.new(&i, null);
+
+                if (p2.isExhausted()) {
+                    break :brk ParsedComponent{
+                        .token_list = css.TokenList{
+                            .v = .{},
+                        },
+                    };
+                }
+                break :brk switch (syntax.parseValue(&p2)) {
+                    .result => |vv| vv,
+                    .err => |e| return .{ .err = e },
+                };
+            } else null,
+            else => brk: {
+                const val = parser.initial_value orelse return .{ .err = input.newCustomError(css.ParserError.at_rule_body_invalid) };
+                var i = css.ParserInput.new(input.allocator(), val);
+                var p2 = css.Parser.new(&i, null);
+                break :brk switch (syntax.parseValue(&p2)) {
+                    .result => |vv| vv,
+                    .err => |e| return .{ .err = e },
+                };
+            },
+        };
+
+        return .{
+            .result = PropertyRule{
+                .name = name,
+                .syntax = syntax,
+                .inherits = inherits,
+                .initial_value = initial_value,
+                .loc = loc,
+            },
+        };
+    }
+
+    const This = @This();
+
+    pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        // #[cfg(feature = "sourcemap")]
+        // dest.add_mapping(self.loc);
+
+        try dest.writeStr("@property ");
+        try css.css_values.ident.DashedIdentFns.toCss(&this.name, W, dest);
+        try dest.whitespace();
+        try dest.writeChar('{');
+        dest.indent();
+        try dest.newline();
+
+        try dest.writeStr("syntax:");
+        try dest.whitespace();
+        try this.syntax.toCss(W, dest);
+        try dest.writeChar(';');
+        try dest.newline();
+
+        try dest.writeStr("inherits:");
+        try dest.whitespace();
+        if (this.inherits) {
+            try dest.writeStr("true");
+        } else {
+            try dest.writeStr("false");
+        }
+
+        if (this.initial_value) |*initial_value| {
+            try dest.writeChar(';');
+            try dest.newline();
+
+            try dest.writeStr("initial-value:");
+            try dest.whitespace();
+            try initial_value.toCss(W, dest);
+
+            if (!dest.minify) {
+                try dest.writeChar(';');
+            }
+        }
+
+        dest.dedent();
+        try dest.newline();
+        try dest.writeChar(';');
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) This {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+pub const PropertyRuleDeclarationParser = struct {
+    syntax: ?SyntaxString,
+    inherits: ?bool,
+    initial_value: ?[]const u8,
+
+    const This = @This();
+
+    pub const DeclarationParser = struct {
+        pub const Declaration = void;
+        const Map = bun.ComptimeStringMap(std.meta.FieldEnum(PropertyRuleDeclarationParser), .{
+            .{ "syntax", .syntax },
+            .{ "inherits", .inherits },
+            .{ "initial-value", .initial_value },
+        });
+
+        pub fn parseValue(this: *This, name: []const u8, input: *css.Parser) Result(Declaration) {
+            // todo_stuff.match_ignore_ascii_case
+
+            //   if (Map.getASCIIICaseInsensitive(
+            //   name)) |field| {
+            //     return switch (field) {
+            //         .syntax => |syntax| {
+
+            if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("syntax", name)) {
+                const syntax = switch (SyntaxString.parse(input)) {
+                    .result => |vv| vv,
+                    .err => |e| return .{ .err = e },
+                };
+                this.syntax = syntax;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("inherits", name)) {
+                const location = input.currentSourceLocation();
+                const ident = switch (input.expectIdent()) {
+                    .result => |vv| vv,
+                    .err => |e| return .{ .err = e },
+                };
+                const inherits = if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("true", ident))
+                    true
+                else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("false", ident))
+                    false
+                else
+                    return .{ .err = location.newUnexpectedTokenError(.{ .ident = ident }) };
+                this.inherits = inherits;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("initial-value", name)) {
+                // Buffer the value into a string. We will parse it later.
+                const start = input.position();
+                while (input.next().isOk()) {}
+                const initial_value = input.sliceFrom(start);
+                this.initial_value = initial_value;
+            } else {
+                return .{ .err = input.newCustomError(css.ParserError.invalid_declaration) };
+            }
+
+            return .{ .result = {} };
+        }
+    };
+
+    pub const RuleBodyItemParser = struct {
+        pub fn parseQualified(_: *This) bool {
+            return false;
+        }
+
+        pub fn parseDeclarations(_: *This) bool {
+            return true;
+        }
+    };
+
+    pub const AtRuleParser = struct {
+        pub const Prelude = void;
+        pub const AtRule = void;
+
+        pub fn parsePrelude(_: *This, name: []const u8, input: *css.Parser) Result(Prelude) {
+            return .{ .err = input.newError(css.BasicParseErrorKind{ .at_rule_invalid = name }) };
+        }
+
+        pub fn parseBlock(_: *This, _: AtRuleParser.Prelude, _: *const css.ParserState, input: *css.Parser) Result(AtRuleParser.AtRule) {
+            return .{ .err = input.newError(css.BasicParseErrorKind.at_rule_body_invalid) };
+        }
+
+        pub fn ruleWithoutBlock(_: *This, _: AtRuleParser.Prelude, _: *const css.ParserState) css.Maybe(AtRuleParser.AtRule, void) {
+            return .{ .err = {} };
+        }
+    };
+
+    pub const QualifiedRuleParser = struct {
+        pub const Prelude = void;
+        pub const QualifiedRule = void;
+
+        pub fn parsePrelude(_: *This, input: *css.Parser) Result(Prelude) {
+            return .{ .err = input.newError(css.BasicParseErrorKind.qualified_rule_invalid) };
+        }
+
+        pub fn parseBlock(_: *This, _: Prelude, _: *const css.ParserState, input: *css.Parser) Result(QualifiedRule) {
+            return .{ .err = input.newError(css.BasicParseErrorKind.qualified_rule_invalid) };
+        }
+    };
+};
diff --git a/src/css/rules/rules.zig b/src/css/rules/rules.zig
new file mode 100644
index 0000000000..a66ebd6cd2
--- /dev/null
+++ b/src/css/rules/rules.zig
@@ -0,0 +1,677 @@
+const std = @import("std");
+pub const css = @import("../css_parser.zig");
+const bun = @import("root").bun;
+
+const Error = css.Error;
+const ArrayList = std.ArrayListUnmanaged;
+const MediaList = css.MediaList;
+const CustomMedia = css.CustomMedia;
+const Printer = css.Printer;
+const Maybe = css.Maybe;
+const PrinterError = css.PrinterError;
+const PrintErr = css.PrintErr;
+const Dependency = css.Dependency;
+const dependencies = css.dependencies;
+const Url = css.css_values.url.Url;
+const Size2D = css.css_values.size.Size2D;
+const fontprops = css.css_properties.font;
+
+pub const import = @import("./import.zig");
+pub const layer = @import("./layer.zig");
+pub const style = @import("./style.zig");
+pub const keyframes = @import("./keyframes.zig");
+pub const font_face = @import("./font_face.zig");
+pub const font_palette_values = @import("./font_palette_values.zig");
+pub const page = @import("./page.zig");
+pub const supports = @import("./supports.zig");
+pub const counter_style = @import("./counter_style.zig");
+pub const custom_media = @import("./custom_media.zig");
+pub const namespace = @import("./namespace.zig");
+pub const unknown = @import("./unknown.zig");
+pub const document = @import("./document.zig");
+pub const nesting = @import("./nesting.zig");
+pub const viewport = @import("./viewport.zig");
+pub const property = @import("./property.zig");
+pub const container = @import("./container.zig");
+pub const scope = @import("./scope.zig");
+pub const media = @import("./media.zig");
+pub const starting_style = @import("./starting_style.zig");
+
+pub const tailwind = @import("./tailwind.zig");
+
+const debug = bun.Output.scoped(.CSS_MINIFY, false);
+
+pub fn CssRule(comptime Rule: type) type {
+    return union(enum) {
+        /// A `@media` rule.
+        media: media.MediaRule(Rule),
+        /// An `@import` rule.
+        import: import.ImportRule,
+        /// A style rule.
+        style: style.StyleRule(Rule),
+        /// A `@keyframes` rule.
+        keyframes: keyframes.KeyframesRule,
+        /// A `@font-face` rule.
+        font_face: font_face.FontFaceRule,
+        /// A `@font-palette-values` rule.
+        font_palette_values: font_palette_values.FontPaletteValuesRule,
+        /// A `@page` rule.
+        page: page.PageRule,
+        /// A `@supports` rule.
+        supports: supports.SupportsRule(Rule),
+        /// A `@counter-style` rule.
+        counter_style: counter_style.CounterStyleRule,
+        /// A `@namespace` rule.
+        namespace: namespace.NamespaceRule,
+        /// A `@-moz-document` rule.
+        moz_document: document.MozDocumentRule(Rule),
+        /// A `@nest` rule.
+        nesting: nesting.NestingRule(Rule),
+        /// A `@viewport` rule.
+        viewport: viewport.ViewportRule,
+        /// A `@custom-media` rule.
+        custom_media: CustomMedia,
+        /// A `@layer` statement rule.
+        layer_statement: layer.LayerStatementRule,
+        /// A `@layer` block rule.
+        layer_block: layer.LayerBlockRule(Rule),
+        /// A `@property` rule.
+        property: property.PropertyRule,
+        /// A `@container` rule.
+        container: container.ContainerRule(Rule),
+        /// A `@scope` rule.
+        scope: scope.ScopeRule(Rule),
+        /// A `@starting-style` rule.
+        starting_style: starting_style.StartingStyleRule(Rule),
+        /// A placeholder for a rule that was removed.
+        ignored,
+        /// An unknown at-rule.
+        unknown: unknown.UnknownAtRule,
+        /// A custom at-rule.
+        custom: Rule,
+
+        const This = @This();
+
+        pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+            return switch (this.*) {
+                .media => |x| x.toCss(W, dest),
+                .import => |x| x.toCss(W, dest),
+                .style => |x| x.toCss(W, dest),
+                .keyframes => |x| x.toCss(W, dest),
+                .font_face => |x| x.toCss(W, dest),
+                .font_palette_values => |x| x.toCss(W, dest),
+                .page => |x| x.toCss(W, dest),
+                .supports => |x| x.toCss(W, dest),
+                .counter_style => |x| x.toCss(W, dest),
+                .namespace => |x| x.toCss(W, dest),
+                .moz_document => |x| x.toCss(W, dest),
+                .nesting => |x| x.toCss(W, dest),
+                .viewport => |x| x.toCss(W, dest),
+                .custom_media => |x| x.toCss(W, dest),
+                .layer_statement => |x| x.toCss(W, dest),
+                .layer_block => |x| x.toCss(W, dest),
+                .property => |x| x.toCss(W, dest),
+                .starting_style => |x| x.toCss(W, dest),
+                .container => |x| x.toCss(W, dest),
+                .scope => |x| x.toCss(W, dest),
+                .unknown => |x| x.toCss(W, dest),
+                .custom => |x| x.toCss(W, dest) catch return dest.addFmtError(),
+                .ignored => {},
+            };
+        }
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) This {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    };
+}
+
+pub fn CssRuleList(comptime AtRule: type) type {
+    return struct {
+        v: ArrayList(CssRule(AtRule)) = .{},
+
+        const This = @This();
+
+        pub fn minify(this: *This, context: *MinifyContext, parent_is_unused: bool) css.MinifyErr!void {
+            // var keyframe_rules: keyframes.KeyframesName.HashMap(usize) = .{};
+            // _ = keyframe_rules; // autofix
+            // const layer_rules: layer.LayerName.HashMap(usize) = .{};
+            // _ = layer_rules; // autofix
+            // const property_rules: css.css_values.ident.DashedIdent.HashMap(usize) = .{};
+            // _ = property_rules; // autofix
+            var style_rules = StyleRuleKey(AtRule).HashMap(usize){};
+            // _ = style_rules; // autofix
+            var rules = ArrayList(CssRule(AtRule)){};
+
+            for (this.v.items) |*rule| {
+                // NOTE Anytime you append to `rules` with this `rule`, you must set `moved_rule` to true.
+                var moved_rule = false;
+                defer if (moved_rule) {
+                    // PERF calling deinit here might allow mimalloc to reuse the freed memory
+                    rule.* = .ignored;
+                };
+
+                switch (rule.*) {
+                    .keyframes => |*keyframez| {
+                        _ = keyframez; // autofix
+                        // if (context.unused_symbols.contains(switch (keyframez.name) {
+                        //     .ident => |ident| ident.v,
+                        //     .custom => |custom| custom,
+                        // })) {
+                        //     continue;
+                        // }
+
+                        // keyframez.minify(context);
+
+                        // // Merge @keyframes rules with the same name.
+                        // if (keyframe_rules.get(keyframez.name)) |existing_idx| {
+                        //     if (existing_idx < rules.items.len and rules.items[existing_idx] == .keyframes) {
+                        //         var existing = &rules.items[existing_idx].keyframes;
+                        //         // If the existing rule has the same vendor prefixes, replace it with this rule.
+                        //         if (existing.vendor_prefix.eq(keyframez.vendor_prefix)) {
+                        //             existing.* = keyframez.clone(context.allocator);
+                        //             continue;
+                        //         }
+                        //         // Otherwise, if the keyframes are identical, merge the prefixes.
+                        //         if (existing.keyframes == keyframez.keyframes) {
+                        //             existing.vendor_prefix |= keyframez.vendor_prefix;
+                        //             existing.vendor_prefix = context.targets.prefixes(existing.vendor_prefix, css.prefixes.Feature.at_keyframes);
+                        //             continue;
+                        //         }
+                        //     }
+                        // }
+
+                        // keyframez.vendor_prefix = context.targets.prefixes(keyframez.vendor_prefix, css.prefixes.Feature.at_keyframes);
+                        // keyframe_rules.put(context.allocator, keyframez.name, rules.items.len) catch bun.outOfMemory();
+
+                        // const fallbacks = keyframez.getFallbacks(AtRule, context.targets);
+                        // moved_rule = true;
+                        // rules.append(context.allocator, rule.*) catch bun.outOfMemory();
+                        // rules.appendSlice(context.allocator, fallbacks) catch bun.outOfMemory();
+                        // continue;
+                        debug("TODO: KeyframesRule", .{});
+                    },
+                    .custom_media => {
+                        if (context.custom_media != null) {
+                            continue;
+                        }
+                    },
+                    .media => |*med| {
+                        moved_rule = false;
+                        if (rules.items.len > 0 and rules.items[rules.items.len - 1] == .media) {
+                            var last_rule = &rules.items[rules.items.len - 1].media;
+                            if (last_rule.query.eql(&med.query)) {
+                                last_rule.rules.v.appendSlice(context.allocator, med.rules.v.items) catch bun.outOfMemory();
+                                _ = try last_rule.minify(context, parent_is_unused);
+                                continue;
+                            }
+
+                            if (try med.minify(context, parent_is_unused)) {
+                                continue;
+                            }
+                        }
+                    },
+                    .supports => |*supp| {
+                        if (rules.items.len > 0 and rules.items[rules.items.len - 1] == .supports) {
+                            var last_rule = &rules.items[rules.items.len - 1].supports;
+                            if (last_rule.condition.eql(&supp.condition)) {
+                                continue;
+                            }
+                        }
+
+                        try supp.minify(context, parent_is_unused);
+                        if (supp.rules.v.items.len == 0) continue;
+                    },
+                    .container => |*cont| {
+                        _ = cont; // autofix
+                        debug("TODO: ContainerRule", .{});
+                    },
+                    .layer_block => |*lay| {
+                        _ = lay; // autofix
+                        debug("TODO: LayerBlockRule", .{});
+                    },
+                    .layer_statement => |*lay| {
+                        _ = lay; // autofix
+                        debug("TODO: LayerStatementRule", .{});
+                    },
+                    .moz_document => |*doc| {
+                        _ = doc; // autofix
+                        debug("TODO: MozDocumentRule", .{});
+                    },
+                    .style => |*sty| {
+                        const Selector = css.selector.Selector;
+                        const SelectorList = css.selector.SelectorList;
+                        const Component = css.selector.Component;
+                        debug("Input style:\n  Selectors: {}\n  Decls: {}\n", .{ sty.selectors.debug(), sty.declarations.debug() });
+                        if (parent_is_unused or try sty.minify(context, parent_is_unused)) {
+                            continue;
+                        }
+
+                        // If some of the selectors in this rule are not compatible with the targets,
+                        // we need to either wrap in :is() or split them into multiple rules.
+                        var incompatible: css.SmallList(css.selector.parser.Selector, 1) = if (sty.selectors.v.len() > 1 and
+                            context.targets.shouldCompileSelectors() and
+                            !sty.isCompatible(context.targets.*))
+                        incompatible: {
+                            debug("Making incompatible!\n", .{});
+                            // The :is() selector accepts a forgiving selector list, so use that if possible.
+                            // Note that :is() does not allow pseudo elements, so we need to check for that.
+                            // In addition, :is() takes the highest specificity of its arguments, so if the selectors
+                            // have different weights, we need to split them into separate rules as well.
+                            if (context.targets.isCompatible(css.compat.Feature.is_selector) and !sty.selectors.anyHasPseudoElement() and sty.selectors.specifitiesAllEqual()) {
+                                const component = Component{ .is = sty.selectors.v.toOwnedSlice(context.allocator) };
+                                var list = css.SmallList(css.selector.parser.Selector, 1){};
+                                list.append(context.allocator, Selector.fromComponent(context.allocator, component));
+                                sty.selectors = SelectorList{
+                                    .v = list,
+                                };
+                                break :incompatible css.SmallList(Selector, 1){};
+                            } else {
+                                // Otherwise, partition the selectors and keep the compatible ones in this rule.
+                                // We will generate additional rules for incompatible selectors later.
+                                var incompatible = css.SmallList(Selector, 1){};
+                                var i: u32 = 0;
+                                while (i < sty.selectors.v.len()) {
+                                    if (css.selector.isCompatible(sty.selectors.v.slice()[i .. i + 1], context.targets.*)) {
+                                        i += 1;
+                                    } else {
+                                        // Move the selector to the incompatible list.
+                                        incompatible.append(
+                                            context.allocator,
+                                            sty.selectors.v.orderedRemove(i),
+                                        );
+                                    }
+                                }
+                                break :incompatible incompatible;
+                            }
+                        } else .{};
+
+                        sty.updatePrefix(context);
+
+                        // Attempt to merge the new rule with the last rule we added.
+                        var merged = false;
+                        const ZACK_REMOVE_THIS = false;
+                        _ = ZACK_REMOVE_THIS; // autofix
+                        if (rules.items.len > 0 and rules.items[rules.items.len - 1] == .style) {
+                            const last_style_rule = &rules.items[rules.items.len - 1].style;
+                            if (mergeStyleRules(AtRule, sty, last_style_rule, context)) {
+                                // If that was successful, then the last rule has been updated to include the
+                                // selectors/declarations of the new rule. This might mean that we can merge it
+                                // with the previous rule, so continue trying while we have style rules available.
+                                while (rules.items.len >= 2) {
+                                    const len = rules.items.len;
+                                    var a, var b = bun.splitAtMut(CssRule(AtRule), rules.items, len - 1);
+                                    if (b[0] == .style and a[len - 2] == .style) {
+                                        if (mergeStyleRules(AtRule, &b[0].style, &a[len - 2].style, context)) {
+                                            // If we were able to merge the last rule into the previous one, remove the last.
+                                            const popped = rules.pop();
+                                            _ = popped; // autofix
+                                            // TODO: deinit?
+                                            // popped.deinit(contet.allocator);
+                                            continue;
+                                        }
+                                    }
+                                    // If we didn't see a style rule, or were unable to merge, stop.
+                                    break;
+                                }
+                                merged = true;
+                            }
+                        }
+
+                        // Create additional rules for logical properties, @supports overrides, and incompatible selectors.
+                        const supps = context.handler_context.getSupportsRules(AtRule, sty);
+                        const logical = context.handler_context.getAdditionalRules(AtRule, sty);
+                        debug("LOGICAL: {d}\n", .{logical.items.len});
+                        const StyleRule = style.StyleRule(AtRule);
+
+                        const IncompatibleRuleEntry = struct { rule: StyleRule, supports: ArrayList(css.CssRule(AtRule)), logical: ArrayList(css.CssRule(AtRule)) };
+                        var incompatible_rules: css.SmallList(IncompatibleRuleEntry, 1) = incompatible_rules: {
+                            var incompatible_rules = css.SmallList(IncompatibleRuleEntry, 1).initCapacity(
+                                context.allocator,
+                                incompatible.len(),
+                            );
+
+                            for (incompatible.slice_mut()) |sel| {
+                                // Create a clone of the rule with only the one incompatible selector.
+                                const list = SelectorList{ .v = css.SmallList(Selector, 1).withOne(sel) };
+                                var clone: StyleRule = .{
+                                    .selectors = list,
+                                    .vendor_prefix = sty.vendor_prefix,
+                                    .declarations = sty.declarations.deepClone(context.allocator),
+                                    .rules = sty.rules.deepClone(context.allocator),
+                                    .loc = sty.loc,
+                                };
+                                clone.updatePrefix(context);
+
+                                // Also add rules for logical properties and @supports overrides.
+                                const s = context.handler_context.getSupportsRules(AtRule, &clone);
+                                const l = context.handler_context.getAdditionalRules(AtRule, &clone);
+                                incompatible_rules.append(context.allocator, IncompatibleRuleEntry{
+                                    .rule = clone,
+                                    .supports = s,
+                                    .logical = l,
+                                });
+                            }
+
+                            break :incompatible_rules incompatible_rules;
+                        };
+                        debug("Incompatible rules: {d}\n", .{incompatible_rules.len()});
+                        defer incompatible.deinit(context.allocator);
+                        defer incompatible_rules.deinit(context.allocator);
+
+                        context.handler_context.reset();
+
+                        // If the rule has nested rules, and we have extra rules to insert such as for logical properties,
+                        // we need to split the rule in two so we can insert the extra rules in between the declarations from
+                        // the main rule and the nested rules.
+                        const nested_rule: ?StyleRule = if (sty.rules.v.items.len > 0 and
+                            // can happen if there are no compatible rules, above.
+                            sty.selectors.v.len() > 0 and
+                            (logical.items.len > 0 or supps.items.len > 0 or !incompatible_rules.isEmpty()))
+                        brk: {
+                            var rulesss: CssRuleList(AtRule) = .{};
+                            std.mem.swap(CssRuleList(AtRule), &sty.rules, &rulesss);
+                            break :brk StyleRule{
+                                .selectors = sty.selectors.deepClone(context.allocator),
+                                .declarations = css.DeclarationBlock{},
+                                .rules = rulesss,
+                                .vendor_prefix = sty.vendor_prefix,
+                                .loc = sty.loc,
+                            };
+                        } else null;
+
+                        if (!merged and !sty.isEmpty()) {
+                            const source_index = sty.loc.source_index;
+                            const has_no_rules = sty.rules.v.items.len == 0;
+                            const idx = rules.items.len;
+
+                            rules.append(context.allocator, rule.*) catch bun.outOfMemory();
+                            moved_rule = true;
+
+                            // Check if this rule is a duplicate of an earlier rule, meaning it has
+                            // the same selectors and defines the same properties. If so, remove the
+                            // earlier rule because this one completely overrides it.
+                            if (has_no_rules) {
+                                const key = StyleRuleKey(AtRule).new(&rules, idx);
+                                if (idx > 0) {
+                                    if (style_rules.fetchSwapRemove(key)) |i_| {
+                                        const i = i_.value;
+                                        if (i < rules.items.len and rules.items[i] == .style) {
+                                            const other = &rules.items[i].style;
+                                            // Don't remove the rule if this is a CSS module and the other rule came from a different file.
+                                            if (!context.css_modules or source_index == other.loc.source_index) {
+                                                // Only mark the rule as ignored so we don't need to change all of the indices.
+                                                rules.items[i] = .ignored;
+                                            }
+                                        }
+                                    }
+                                }
+
+                                style_rules.put(context.allocator, key, idx) catch bun.outOfMemory();
+                            }
+                        }
+
+                        if (logical.items.len > 0) {
+                            debug("Adding logical: {}\n", .{logical.items[0].style.selectors.debug()});
+                            var log = CssRuleList(AtRule){ .v = logical };
+                            try log.minify(context, parent_is_unused);
+                            rules.appendSlice(context.allocator, log.v.items) catch bun.outOfMemory();
+                        }
+                        rules.appendSlice(context.allocator, supps.items) catch bun.outOfMemory();
+                        for (incompatible_rules.slice_mut()) |incompatible_entry| {
+                            if (!incompatible_entry.rule.isEmpty()) {
+                                rules.append(context.allocator, .{ .style = incompatible_entry.rule }) catch bun.outOfMemory();
+                            }
+                            if (incompatible_entry.logical.items.len > 0) {
+                                var log = CssRuleList(AtRule){ .v = incompatible_entry.logical };
+                                try log.minify(context, parent_is_unused);
+                                rules.appendSlice(context.allocator, log.v.items) catch bun.outOfMemory();
+                            }
+                            rules.appendSlice(context.allocator, incompatible_entry.supports.items) catch bun.outOfMemory();
+                        }
+                        if (nested_rule) |nested| {
+                            rules.append(context.allocator, .{ .style = nested }) catch bun.outOfMemory();
+                        }
+
+                        continue;
+                    },
+                    .counter_style => |*cntr| {
+                        _ = cntr; // autofix
+                        debug("TODO: CounterStyleRule", .{});
+                    },
+                    .scope => |*scpe| {
+                        _ = scpe; // autofix
+                        debug("TODO: ScopeRule", .{});
+                    },
+                    .nesting => |*nst| {
+                        _ = nst; // autofix
+                        debug("TODO: NestingRule", .{});
+                    },
+                    .starting_style => |*rl| {
+                        _ = rl; // autofix
+                        debug("TODO: StartingStyleRule", .{});
+                    },
+                    .font_palette_values => |*f| {
+                        _ = f; // autofix
+                        debug("TODO: FontPaletteValuesRule", .{});
+                    },
+                    .property => |*prop| {
+                        _ = prop; // autofix
+                        debug("TODO: PropertyRule", .{});
+                    },
+                    else => {},
+                }
+
+                rules.append(context.allocator, rule.*) catch bun.outOfMemory();
+            }
+
+            // MISSING SHIT HERE
+
+            css.deepDeinit(CssRule(AtRule), context.allocator, &this.v);
+            this.v = rules;
+            return;
+        }
+
+        pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+            var first = true;
+            var last_without_block = false;
+
+            for (this.v.items) |*rule| {
+                if (rule.* == .ignored) continue;
+
+                // Skip @import rules if collecting dependencies.
+                if (rule.* == .import) {
+                    if (dest.remove_imports) {
+                        const dep = if (dest.dependencies != null) Dependency{
+                            .import = dependencies.ImportDependency.new(dest.allocator, &rule.import, dest.filename()),
+                        } else null;
+
+                        if (dest.dependencies) |*deps| {
+                            deps.append(dest.allocator, dep.?) catch unreachable;
+                            continue;
+                        }
+                    }
+                }
+
+                if (first) {
+                    first = false;
+                } else {
+                    if (!dest.minify and
+                        !(last_without_block and
+                        (rule.* == .import or rule.* == .namespace or rule.* == .layer_statement)))
+                    {
+                        try dest.writeChar('\n');
+                    }
+                    try dest.newline();
+                }
+                try rule.toCss(W, dest);
+                last_without_block = rule.* == .import or rule.* == .namespace or rule.* == .layer_statement;
+            }
+        }
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    };
+}
+
+pub const MinifyContext = struct {
+    /// NOTE: this should the same allocator the AST was allocated with
+    allocator: std.mem.Allocator,
+    targets: *const css.targets.Targets,
+    handler: *css.DeclarationHandler,
+    important_handler: *css.DeclarationHandler,
+    handler_context: css.PropertyHandlerContext,
+    unused_symbols: *const std.StringArrayHashMapUnmanaged(void),
+    custom_media: ?std.StringArrayHashMapUnmanaged(custom_media.CustomMediaRule),
+    css_modules: bool,
+    err: ?css.MinifyError = null,
+};
+
+pub const Location = struct {
+    /// The index of the source file within the source map.
+    source_index: u32,
+    /// The line number, starting at 0.
+    line: u32,
+    /// The column number within a line, starting at 1 for first the character of the line.
+    /// Column numbers are counted in UTF-16 code units.
+    column: u32,
+
+    pub fn dummy() Location {
+        return .{
+            .source_index = std.math.maxInt(u32),
+            .line = std.math.maxInt(u32),
+            .column = std.math.maxInt(u32),
+        };
+    }
+};
+
+pub const StyleContext = struct {
+    selectors: *const css.SelectorList,
+    parent: ?*const StyleContext,
+};
+
+/// A key to a StyleRule meant for use in a HashMap for quickly detecting duplicates.
+/// It stores a reference to a list and an index so it can access items without cloning
+/// even when the list is reallocated. A hash is also pre-computed for fast lookups.
+pub fn StyleRuleKey(comptime R: type) type {
+    return struct {
+        list: *const ArrayList(CssRule(R)),
+        index: usize,
+        // TODO: store in the hashmap by setting `store_hash` to true
+        hash: u64,
+
+        const This = @This();
+
+        pub fn HashMap(comptime V: type) type {
+            return std.ArrayHashMapUnmanaged(
+                StyleRuleKey(R),
+                V,
+                struct {
+                    pub fn hash(_: @This(), key: This) u32 {
+                        return @truncate(key.hash);
+                    }
+
+                    pub fn eql(_: @This(), a: This, b: This, _: usize) bool {
+                        return a.eql(&b);
+                    }
+                },
+                // TODO: make this true
+                false,
+            );
+        }
+
+        pub fn new(list: *const ArrayList(CssRule(R)), index: usize) This {
+            const rule = &list.items[index].style;
+            return This{
+                .list = list,
+                .index = index,
+                .hash = rule.hashKey(),
+            };
+        }
+
+        pub fn eql(this: *const This, other: *const This) bool {
+            const rule = if (this.index < this.list.items.len and this.list.items[this.index] == .style)
+                &this.list.items[this.index].style
+            else
+                return false;
+
+            const other_rule = if (other.index < other.list.items.len and other.list.items[other.index] == .style)
+                &other.list.items[other.index].style
+            else
+                return false;
+
+            return rule.isDuplicate(other_rule);
+        }
+    };
+}
+
+fn mergeStyleRules(
+    comptime T: type,
+    sty: *style.StyleRule(T),
+    last_style_rule: *style.StyleRule(T),
+    context: *MinifyContext,
+) bool {
+    // Merge declarations if the selectors are equivalent, and both are compatible with all targets.
+    if (sty.selectors.eql(&last_style_rule.selectors) and
+        sty.isCompatible(context.targets.*) and
+        last_style_rule.isCompatible(context.targets.*) and
+        sty.rules.v.items.len == 0 and
+        last_style_rule.rules.v.items.len == 0 and
+        (!context.css_modules or sty.loc.source_index == last_style_rule.loc.source_index))
+    {
+        last_style_rule.declarations.declarations.appendSlice(
+            context.allocator,
+            sty.declarations.declarations.items,
+        ) catch bun.outOfMemory();
+        sty.declarations.declarations.clearRetainingCapacity();
+
+        last_style_rule.declarations.important_declarations.appendSlice(
+            context.allocator,
+            sty.declarations.important_declarations.items,
+        ) catch bun.outOfMemory();
+        sty.declarations.important_declarations.clearRetainingCapacity();
+
+        last_style_rule.declarations.minify(
+            context.handler,
+            context.important_handler,
+            &context.handler_context,
+        );
+        return true;
+    } else if (sty.declarations.eql(&last_style_rule.declarations) and
+        sty.rules.v.items.len == 0 and
+        last_style_rule.rules.v.items.len == 0)
+    {
+        // If both selectors are potentially vendor prefixable, and they are
+        // equivalent minus prefixes, add the prefix to the last rule.
+        if (!sty.vendor_prefix.isEmpty() and
+            !last_style_rule.vendor_prefix.isEmpty() and
+            css.selector.isEquivalent(sty.selectors.v.slice(), last_style_rule.selectors.v.slice()))
+        {
+            // If the new rule is unprefixed, replace the prefixes of the last rule.
+            // Otherwise, add the new prefix.
+            if (sty.vendor_prefix.contains(css.VendorPrefix{ .none = true }) and context.targets.shouldCompileSelectors()) {
+                last_style_rule.vendor_prefix = sty.vendor_prefix;
+            } else {
+                last_style_rule.vendor_prefix.insert(sty.vendor_prefix);
+            }
+            return true;
+        }
+
+        // Append the selectors to the last rule if the declarations are the same, and all selectors are compatible.
+        if (sty.isCompatible(context.targets.*) and last_style_rule.isCompatible(context.targets.*)) {
+            last_style_rule.selectors.v.appendSlice(
+                context.allocator,
+                sty.selectors.v.slice(),
+            );
+            sty.selectors.v.clearRetainingCapacity();
+            if (sty.vendor_prefix.contains(css.VendorPrefix{ .none = true }) and context.targets.shouldCompileSelectors()) {
+                last_style_rule.vendor_prefix = sty.vendor_prefix;
+            } else {
+                last_style_rule.vendor_prefix.insert(sty.vendor_prefix);
+            }
+            return true;
+        }
+    }
+    return false;
+}
diff --git a/src/css/rules/scope.zig b/src/css/rules/scope.zig
new file mode 100644
index 0000000000..51436f416a
--- /dev/null
+++ b/src/css/rules/scope.zig
@@ -0,0 +1,82 @@
+const std = @import("std");
+pub const css = @import("../css_parser.zig");
+const bun = @import("root").bun;
+const Error = css.Error;
+const ArrayList = std.ArrayListUnmanaged;
+const MediaList = css.MediaList;
+const CustomMedia = css.CustomMedia;
+const Printer = css.Printer;
+const Maybe = css.Maybe;
+const PrinterError = css.PrinterError;
+const PrintErr = css.PrintErr;
+const Location = css.css_rules.Location;
+const style = css.css_rules.style;
+const CssRuleList = css.CssRuleList;
+
+/// A [@scope](https://drafts.csswg.org/css-cascade-6/#scope-atrule) rule.
+///
+/// @scope (<scope-start>) [to (<scope-end>)]? {
+///  <stylesheet>
+/// }
+pub fn ScopeRule(comptime R: type) type {
+    return struct {
+        /// A selector list used to identify the scoping root(s).
+        scope_start: ?css.selector.parser.SelectorList,
+        /// A selector list used to identify any scoping limits.
+        scope_end: ?css.selector.parser.SelectorList,
+        /// Nested rules within the `@scope` rule.
+        rules: css.CssRuleList(R),
+        /// The location of the rule in the source file.
+        loc: Location,
+
+        const This = @This();
+
+        pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+            // #[cfg(feature = "sourcemap")]
+            // dest.add_mapping(self.loc);
+
+            try dest.writeStr("@scope");
+            try dest.whitespace();
+            if (this.scope_start) |*scope_start| {
+                try dest.writeChar('(');
+                // try scope_start.toCss(W, dest);
+                try css.selector.serialize.serializeSelectorList(scope_start.v.slice(), W, dest, dest.context(), false);
+                try dest.writeChar(')');
+                try dest.whitespace();
+            }
+            if (this.scope_end) |*scope_end| {
+                if (dest.minify) {
+                    try dest.writeChar(' ');
+                }
+                try dest.writeStr("to (");
+                // <scope-start> is treated as an ancestor of scope end.
+                // https://drafts.csswg.org/css-nesting/#nesting-at-scope
+                if (this.scope_start) |*scope_start| {
+                    try dest.withContext(scope_start, scope_end, struct {
+                        pub fn toCssFn(scope_end_: *const css.selector.parser.SelectorList, comptime WW: type, d: *Printer(WW)) PrintErr!void {
+                            return css.selector.serialize.serializeSelectorList(scope_end_.v.slice(), WW, d, d.context(), false);
+                        }
+                    }.toCssFn);
+                } else {
+                    return css.selector.serialize.serializeSelectorList(scope_end.v.slice(), W, dest, dest.context(), false);
+                }
+                try dest.writeChar(')');
+                try dest.whitespace();
+            }
+            try dest.writeChar('{');
+            dest.indent();
+            try dest.newline();
+            // Nested style rules within @scope are implicitly relative to the <scope-start>
+            // so clear our style context while printing them to avoid replacing & ourselves.
+            // https://drafts.csswg.org/css-cascade-6/#scoped-rules
+            try dest.withClearedContext(&this.rules, CssRuleList(R).toCss);
+            dest.dedent();
+            try dest.newline();
+            try dest.writeChar('}');
+        }
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) This {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    };
+}
diff --git a/src/css/rules/starting_style.zig b/src/css/rules/starting_style.zig
new file mode 100644
index 0000000000..f86a656931
--- /dev/null
+++ b/src/css/rules/starting_style.zig
@@ -0,0 +1,45 @@
+const std = @import("std");
+pub const css = @import("../css_parser.zig");
+const bun = @import("root").bun;
+const Error = css.Error;
+const ArrayList = std.ArrayListUnmanaged;
+const MediaList = css.MediaList;
+const CustomMedia = css.CustomMedia;
+const Printer = css.Printer;
+const Maybe = css.Maybe;
+const PrinterError = css.PrinterError;
+const PrintErr = css.PrintErr;
+const Location = css.css_rules.Location;
+const style = css.css_rules.style;
+const CssRuleList = css.CssRuleList;
+
+/// A [@starting-style](https://drafts.csswg.org/css-transitions-2/#defining-before-change-style-the-starting-style-rule) rule.
+pub fn StartingStyleRule(comptime R: type) type {
+    return struct {
+        /// Nested rules within the `@starting-style` rule.
+        rules: css.CssRuleList(R),
+        /// The location of the rule in the source file.
+        loc: Location,
+
+        const This = @This();
+
+        pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+            // #[cfg(feature = "sourcemap")]
+            // dest.add_mapping(self.loc);
+
+            try dest.writeStr("@starting-style");
+            try dest.whitespace();
+            try dest.writeChar('{');
+            dest.indent();
+            try dest.newline();
+            try this.rules.toCss(W, dest);
+            dest.dedent();
+            try dest.newline();
+            try dest.writeChar('}');
+        }
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) This {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    };
+}
diff --git a/src/css/rules/style.zig b/src/css/rules/style.zig
new file mode 100644
index 0000000000..a972865541
--- /dev/null
+++ b/src/css/rules/style.zig
@@ -0,0 +1,260 @@
+const std = @import("std");
+pub const css = @import("../css_parser.zig");
+const bun = @import("root").bun;
+const ArrayList = std.ArrayListUnmanaged;
+const MediaList = css.MediaList;
+const CustomMedia = css.CustomMedia;
+const Printer = css.Printer;
+const Maybe = css.Maybe;
+const PrinterError = css.PrinterError;
+const PrintErr = css.PrintErr;
+const Dependency = css.Dependency;
+const dependencies = css.dependencies;
+const Url = css.css_values.url.Url;
+const Size2D = css.css_values.size.Size2D;
+const fontprops = css.css_properties.font;
+const LayerName = css.css_rules.layer.LayerName;
+const SupportsCondition = css.css_rules.supports.SupportsCondition;
+const Location = css.css_rules.Location;
+
+pub fn StyleRule(comptime R: type) type {
+    return struct {
+        /// The selectors for the style rule.
+        selectors: css.selector.parser.SelectorList,
+        /// A vendor prefix override, used during selector printing.
+        vendor_prefix: css.VendorPrefix,
+        /// The declarations within the style rule.
+        declarations: css.DeclarationBlock,
+        /// Nested rules within the style rule.
+        rules: css.CssRuleList(R),
+        /// The location of the rule in the source file.
+        loc: css.Location,
+
+        const This = @This();
+
+        /// Returns whether the rule is empty.
+        pub fn isEmpty(this: *const This) bool {
+            return this.selectors.v.isEmpty() or (this.declarations.isEmpty() and this.rules.v.items.len == 0);
+        }
+
+        /// Returns a hash of this rule for use when deduplicating.
+        /// Includes the selectors and properties.
+        pub fn hashKey(this: *const This) u64 {
+            var hasher = std.hash.Wyhash.init(0);
+            this.selectors.hash(&hasher);
+            this.declarations.hashPropertyIds(&hasher);
+            return hasher.final();
+        }
+
+        pub fn deepClone(this: *const This, allocator: std.mem.Allocator) This {
+            return This{
+                .selectors = this.selectors.deepClone(allocator),
+                .vendor_prefix = this.vendor_prefix,
+                .declarations = this.declarations.deepClone(allocator),
+                .rules = this.rules.deepClone(allocator),
+                .loc = this.loc,
+            };
+        }
+
+        pub fn updatePrefix(this: *This, context: *css.MinifyContext) void {
+            this.vendor_prefix = css.selector.getPrefix(&this.selectors);
+            if (this.vendor_prefix.contains(css.VendorPrefix{ .none = true }) and
+                context.targets.shouldCompileSelectors())
+            {
+                this.vendor_prefix = css.selector.downlevelSelectors(context.allocator, this.selectors.v.slice_mut(), context.targets.*);
+            }
+        }
+
+        pub fn isCompatible(this: *const This, targets: css.targets.Targets) bool {
+            return css.selector.isCompatible(this.selectors.v.slice(), targets);
+        }
+
+        pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+            if (this.vendor_prefix.isEmpty()) {
+                try this.toCssBase(W, dest);
+            } else {
+                var first_rule = true;
+                inline for (css.VendorPrefix.FIELDS) |field| {
+                    if (@field(this.vendor_prefix, field)) {
+                        if (first_rule) {
+                            first_rule = false;
+                        } else {
+                            if (!dest.minify) {
+                                try dest.writeChar('\n'); // no indent
+                            }
+                            try dest.newline();
+                        }
+
+                        const prefix = css.VendorPrefix.fromName(field);
+                        dest.vendor_prefix = prefix;
+                        try this.toCssBase(W, dest);
+                    }
+                }
+
+                dest.vendor_prefix = css.VendorPrefix.empty();
+            }
+        }
+
+        fn toCssBase(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+            // If supported, or there are no targets, preserve nesting. Otherwise, write nested rules after parent.
+            const supports_nesting = this.rules.v.items.len == 0 or
+                !css.Targets.shouldCompileSame(
+                &dest.targets,
+                .nesting,
+            );
+
+            const len = this.declarations.declarations.items.len + this.declarations.important_declarations.items.len;
+            const has_declarations = supports_nesting or len > 0 or this.rules.v.items.len == 0;
+
+            if (has_declarations) {
+                //   #[cfg(feature = "sourcemap")]
+                //   dest.add_mapping(self.loc);
+
+                try css.selector.serialize.serializeSelectorList(this.selectors.v.slice(), W, dest, dest.context(), false);
+                try dest.whitespace();
+                try dest.writeChar('{');
+                dest.indent();
+
+                var i: usize = 0;
+                const DECLS = .{ "declarations", "important_declarations" };
+                inline for (DECLS) |decl_field_name| {
+                    const important = comptime std.mem.eql(u8, decl_field_name, "important_declarations");
+                    const decls: *const ArrayList(css.Property) = &@field(this.declarations, decl_field_name);
+
+                    for (decls.items) |*decl| {
+                        // The CSS modules `composes` property is handled specially, and omitted during printing.
+                        // We need to add the classes it references to the list for the selectors in this rule.
+                        if (decl.* == .composes) {
+                            const composes = &decl.composes;
+                            if (dest.isNested() and dest.css_module != null) {
+                                return dest.newError(css.PrinterErrorKind.invalid_composes_nesting, composes.loc);
+                            }
+
+                            if (dest.css_module) |*css_module| {
+                                if (css_module.handleComposes(
+                                    dest.allocator,
+                                    &this.selectors,
+                                    composes,
+                                    this.loc.source_index,
+                                ).asErr()) |error_kind| {
+                                    return dest.newError(error_kind, composes.loc);
+                                }
+                                continue;
+                            }
+                        }
+
+                        try dest.newline();
+                        try decl.toCss(W, dest, important);
+                        if (i != len - 1 or !dest.minify or (supports_nesting and this.rules.v.items.len > 0)) {
+                            try dest.writeChar(';');
+                        }
+
+                        i += 1;
+                    }
+                }
+            }
+
+            const Helpers = struct {
+                pub fn newline(
+                    self: *const This,
+                    comptime W2: type,
+                    d: *Printer(W2),
+                    supports_nesting2: bool,
+                    len1: usize,
+                ) PrintErr!void {
+                    if (!d.minify and (supports_nesting2 or len1 > 0) and self.rules.v.items.len > 0) {
+                        if (len1 > 0) {
+                            try d.writeChar('\n');
+                        }
+                        try d.newline();
+                    }
+                }
+
+                pub fn end(comptime W2: type, d: *Printer(W2), has_decls: bool) PrintErr!void {
+                    if (has_decls) {
+                        d.dedent();
+                        try d.newline();
+                        try d.writeChar('}');
+                    }
+                }
+            };
+
+            // Write nested rules after the parent.
+            if (supports_nesting) {
+                try Helpers.newline(this, W, dest, supports_nesting, len);
+                try this.rules.toCss(W, dest);
+                try Helpers.end(W, dest, has_declarations);
+            } else {
+                try Helpers.end(W, dest, has_declarations);
+                try Helpers.newline(this, W, dest, supports_nesting, len);
+                try dest.withContext(&this.selectors, this, struct {
+                    pub fn toCss(self: *const This, WW: type, d: *Printer(WW)) PrintErr!void {
+                        return self.rules.toCss(WW, d);
+                    }
+                }.toCss);
+            }
+        }
+
+        pub fn minify(this: *This, context: *css.MinifyContext, parent_is_unused: bool) css.MinifyErr!bool {
+            var unused = false;
+            if (context.unused_symbols.count() > 0) {
+                if (css.selector.isUnused(this.selectors.v.slice(), context.unused_symbols, parent_is_unused)) {
+                    if (this.rules.v.items.len == 0) {
+                        return true;
+                    }
+
+                    this.declarations.declarations.clearRetainingCapacity();
+                    this.declarations.important_declarations.clearRetainingCapacity();
+                    unused = true;
+                }
+            }
+
+            // TODO: this
+            // let pure_css_modules = context.pure_css_modules;
+            // if context.pure_css_modules {
+            //   if !self.selectors.0.iter().all(is_pure_css_modules_selector) {
+            //     return Err(MinifyError {
+            //       kind: crate::error::MinifyErrorKind::ImpureCSSModuleSelector,
+            //       loc: self.loc,
+            //     });
+            //   }
+
+            //   // Parent rule contained id or class, so child rules don't need to.
+            //   context.pure_css_modules = false;
+            // }
+
+            context.handler_context.context = .style_rule;
+            this.declarations.minify(context.handler, context.important_handler, &context.handler_context);
+            context.handler_context.context = .none;
+
+            if (this.rules.v.items.len > 0) {
+                var handler_context = context.handler_context.child(.style_rule);
+                std.mem.swap(css.PropertyHandlerContext, &context.handler_context, &handler_context);
+                try this.rules.minify(context, unused);
+                if (unused and this.rules.v.items.len == 0) {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// Returns whether this rule is a duplicate of another rule.
+        /// This means it has the same selectors and properties.
+        pub inline fn isDuplicate(this: *const This, other: *const This) bool {
+            return this.declarations.len() == other.declarations.len() and
+                this.selectors.eql(&other.selectors) and
+                brk: {
+                var len = @min(this.declarations.declarations.items.len, other.declarations.declarations.items.len);
+                for (this.declarations.declarations.items[0..len], other.declarations.declarations.items[0..len]) |*a, *b| {
+                    if (!a.propertyId().eql(&b.propertyId())) break :brk false;
+                }
+                len = @min(this.declarations.important_declarations.items.len, other.declarations.important_declarations.items.len);
+                for (this.declarations.important_declarations.items[0..len], other.declarations.important_declarations.items[0..len]) |*a, *b| {
+                    if (!a.propertyId().eql(&b.propertyId())) break :brk false;
+                }
+                break :brk true;
+            };
+        }
+    };
+}
diff --git a/src/css/rules/supports.zig b/src/css/rules/supports.zig
new file mode 100644
index 0000000000..a07a78494e
--- /dev/null
+++ b/src/css/rules/supports.zig
@@ -0,0 +1,408 @@
+const std = @import("std");
+pub const css = @import("../css_parser.zig");
+const bun = @import("root").bun;
+const Result = css.Result;
+const ArrayList = std.ArrayListUnmanaged;
+const MediaList = css.MediaList;
+const CustomMedia = css.CustomMedia;
+const Printer = css.Printer;
+const Maybe = css.Maybe;
+const PrinterError = css.PrinterError;
+const PrintErr = css.PrintErr;
+const Dependency = css.Dependency;
+const dependencies = css.dependencies;
+const Url = css.css_values.url.Url;
+const Size2D = css.css_values.size.Size2D;
+const fontprops = css.css_properties.font;
+const LayerName = css.css_rules.layer.LayerName;
+const Location = css.css_rules.Location;
+const Angle = css.css_values.angle.Angle;
+const FontStyleProperty = css.css_properties.font.FontStyle;
+const FontFamily = css.css_properties.font.FontFamily;
+const FontWeight = css.css_properties.font.FontWeight;
+const FontStretch = css.css_properties.font.FontStretch;
+const CustomProperty = css.css_properties.custom.CustomProperty;
+const CustomPropertyName = css.css_properties.custom.CustomPropertyName;
+const DashedIdent = css.css_values.ident.DashedIdent;
+
+/// A [`<supports-condition>`](https://drafts.csswg.org/css-conditional-3/#typedef-supports-condition),
+/// as used in the `@supports` and `@import` rules.
+pub const SupportsCondition = union(enum) {
+    /// A `not` expression.
+    not: *SupportsCondition,
+
+    /// An `and` expression.
+    @"and": ArrayList(SupportsCondition),
+
+    /// An `or` expression.
+    @"or": ArrayList(SupportsCondition),
+
+    /// A declaration to evaluate.
+    declaration: struct {
+        /// The property id for the declaration.
+        property_id: css.PropertyId,
+        /// The raw value of the declaration.
+        value: []const u8,
+
+        pub fn eql(this: *const @This(), other: *const @This()) bool {
+            return css.implementEql(@This(), this, other);
+        }
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    },
+
+    /// A selector to evaluate.
+    selector: []const u8,
+
+    /// An unknown condition.
+    unknown: []const u8,
+
+    pub fn eql(this: *const SupportsCondition, other: *const SupportsCondition) bool {
+        return css.implementEql(SupportsCondition, this, other);
+    }
+
+    pub fn deepClone(this: *const SupportsCondition, allocator: std.mem.Allocator) SupportsCondition {
+        return css.implementDeepClone(SupportsCondition, this, allocator);
+    }
+
+    fn needsParens(this: *const SupportsCondition, parent: *const SupportsCondition) bool {
+        return switch (this.*) {
+            .not => true,
+            .@"and" => parent.* != .@"and",
+            .@"or" => parent.* != .@"or",
+            else => false,
+        };
+    }
+
+    const SeenDeclKey = struct {
+        css.PropertyId,
+        []const u8,
+    };
+
+    pub fn parse(input: *css.Parser) Result(SupportsCondition) {
+        if (input.tryParse(css.Parser.expectIdentMatching, .{"not"}).isOk()) {
+            const in_parens = switch (SupportsCondition.parseInParens(input)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            };
+            return .{
+                .result = .{
+                    .not = bun.create(
+                        input.allocator(),
+                        SupportsCondition,
+                        in_parens,
+                    ),
+                },
+            };
+        }
+
+        const in_parens: SupportsCondition = switch (SupportsCondition.parseInParens(input)) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+        var expected_type: ?i32 = null;
+        var conditions = ArrayList(SupportsCondition){};
+        const mapalloc: std.mem.Allocator = input.allocator();
+        var seen_declarations = std.ArrayHashMap(
+            SeenDeclKey,
+            usize,
+            struct {
+                pub fn hash(self: @This(), s: SeenDeclKey) u32 {
+                    _ = self; // autofix
+                    return std.array_hash_map.hashString(s[1]) +% @intFromEnum(s[0]);
+                }
+                pub fn eql(self: @This(), a: SeenDeclKey, b: SeenDeclKey, b_index: usize) bool {
+                    _ = self; // autofix
+                    _ = b_index; // autofix
+                    return seenDeclKeyEql(a, b);
+                }
+
+                pub inline fn seenDeclKeyEql(this: SeenDeclKey, that: SeenDeclKey) bool {
+                    return @intFromEnum(this[0]) == @intFromEnum(that[0]) and bun.strings.eql(this[1], that[1]);
+                }
+            },
+            false,
+        ).init(mapalloc);
+        defer seen_declarations.deinit();
+
+        while (true) {
+            const Closure = struct {
+                expected_type: *?i32,
+                pub fn tryParseFn(i: *css.Parser, this: *@This()) Result(SupportsCondition) {
+                    const location = i.currentSourceLocation();
+                    const s = switch (i.expectIdent()) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    };
+                    const found_type: i32 = found_type: {
+                        // todo_stuff.match_ignore_ascii_case
+                        if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("and", s)) break :found_type 1;
+                        if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("or", s)) break :found_type 2;
+                        return .{ .err = location.newUnexpectedTokenError(.{ .ident = s }) };
+                    };
+
+                    if (this.expected_type.*) |expected| {
+                        if (found_type != expected) {
+                            return .{ .err = location.newUnexpectedTokenError(.{ .ident = s }) };
+                        }
+                    } else {
+                        this.expected_type.* = found_type;
+                    }
+
+                    return SupportsCondition.parseInParens(i);
+                }
+            };
+            var closure = Closure{
+                .expected_type = &expected_type,
+            };
+            const _condition = input.tryParse(Closure.tryParseFn, .{&closure});
+
+            switch (_condition) {
+                .result => |condition| {
+                    if (conditions.items.len == 0) {
+                        conditions.append(input.allocator(), in_parens.deepClone(input.allocator())) catch bun.outOfMemory();
+                        if (in_parens == .declaration) {
+                            const property_id = in_parens.declaration.property_id;
+                            const value = in_parens.declaration.value;
+                            seen_declarations.put(
+                                .{ property_id.withPrefix(css.VendorPrefix{ .none = true }), value },
+                                0,
+                            ) catch bun.outOfMemory();
+                        }
+                    }
+
+                    if (condition == .declaration) {
+                        // Merge multiple declarations with the same property id (minus prefix) and value together.
+                        const property_id_ = condition.declaration.property_id;
+                        const value = condition.declaration.value;
+
+                        const property_id = property_id_.withPrefix(css.VendorPrefix{ .none = true });
+                        const key = SeenDeclKey{ property_id, value };
+                        if (seen_declarations.get(key)) |index| {
+                            const cond = &conditions.items[index];
+                            if (cond.* == .declaration) {
+                                cond.declaration.property_id.addPrefix(property_id.prefix());
+                            }
+                        } else {
+                            seen_declarations.put(key, conditions.items.len) catch bun.outOfMemory();
+                            conditions.append(input.allocator(), SupportsCondition{ .declaration = .{
+                                .property_id = property_id,
+                                .value = value,
+                            } }) catch bun.outOfMemory();
+                        }
+                    } else {
+                        conditions.append(
+                            input.allocator(),
+                            condition,
+                        ) catch bun.outOfMemory();
+                    }
+                },
+                else => break,
+            }
+        }
+
+        if (conditions.items.len == 1) {
+            const ret = conditions.pop();
+            defer conditions.deinit(input.allocator());
+            return .{ .result = ret };
+        }
+
+        if (expected_type == 1) return .{ .result = .{ .@"and" = conditions } };
+        if (expected_type == 2) return .{ .result = .{ .@"or" = conditions } };
+        return .{ .result = in_parens };
+    }
+
+    pub fn parseDeclaration(input: *css.Parser) Result(SupportsCondition) {
+        const property_id = switch (css.PropertyId.parse(input)) {
+            .result => |v| v,
+            .err => |e| return .{ .err = e },
+        };
+        if (input.expectColon().asErr()) |e| return .{ .err = e };
+        input.skipWhitespace();
+        const pos = input.position();
+        if (input.expectNoErrorToken().asErr()) |e| return .{ .err = e };
+        return .{ .result = SupportsCondition{
+            .declaration = .{
+                .property_id = property_id,
+                .value = input.sliceFrom(pos),
+            },
+        } };
+    }
+
+    fn parseInParens(input: *css.Parser) Result(SupportsCondition) {
+        input.skipWhitespace();
+        const location = input.currentSourceLocation();
+        const pos = input.position();
+        const tok = switch (input.next()) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+        switch (tok.*) {
+            .function => |f| {
+                if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("selector", f)) {
+                    const Fn = struct {
+                        pub fn tryParseFn(i: *css.Parser) Result(SupportsCondition) {
+                            return i.parseNestedBlock(SupportsCondition, {}, @This().parseNestedBlockFn);
+                        }
+                        pub fn parseNestedBlockFn(_: void, i: *css.Parser) Result(SupportsCondition) {
+                            const p = i.position();
+                            if (i.expectNoErrorToken().asErr()) |e| return .{ .err = e };
+                            return .{ .result = SupportsCondition{ .selector = i.sliceFrom(p) } };
+                        }
+                    };
+                    const res = input.tryParse(Fn.tryParseFn, .{});
+                    if (res.isOk()) return res;
+                }
+            },
+            .open_paren => {
+                const res = input.tryParse(struct {
+                    pub fn parseFn(i: *css.Parser) Result(SupportsCondition) {
+                        return i.parseNestedBlock(SupportsCondition, {}, css.voidWrap(SupportsCondition, parse));
+                    }
+                }.parseFn, .{});
+                if (res.isOk()) return res;
+            },
+            else => return .{ .err = location.newUnexpectedTokenError(tok.*) },
+        }
+
+        if (input.parseNestedBlock(void, {}, struct {
+            pub fn parseFn(_: void, i: *css.Parser) Result(void) {
+                return i.expectNoErrorToken();
+            }
+        }.parseFn).asErr()) |err| {
+            return .{ .err = err };
+        }
+
+        return .{ .result = SupportsCondition{ .unknown = input.sliceFrom(pos) } };
+    }
+
+    pub fn toCss(this: *const SupportsCondition, comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+        switch (this.*) {
+            .not => |condition| {
+                try dest.writeStr(" not ");
+                try condition.toCssWithParensIfNeeded(W, dest, condition.needsParens(this));
+            },
+            .@"and" => |conditions| {
+                var first = true;
+                for (conditions.items) |*cond| {
+                    if (first) {
+                        first = false;
+                    } else {
+                        try dest.writeStr(" and ");
+                    }
+                    try cond.toCssWithParensIfNeeded(W, dest, cond.needsParens(this));
+                }
+            },
+            .@"or" => |conditions| {
+                var first = true;
+                for (conditions.items) |*cond| {
+                    if (first) {
+                        first = false;
+                    } else {
+                        try dest.writeStr(" or ");
+                    }
+                    try cond.toCssWithParensIfNeeded(W, dest, cond.needsParens(this));
+                }
+            },
+            .declaration => |decl| {
+                const property_id = decl.property_id;
+                const value = decl.value;
+
+                try dest.writeChar('(');
+
+                const prefix: css.VendorPrefix = property_id.prefix().orNone();
+                if (!prefix.eq(css.VendorPrefix{ .none = true })) {
+                    try dest.writeChar('(');
+                }
+
+                const name = property_id.name();
+                var first = true;
+                inline for (css.VendorPrefix.FIELDS) |field| {
+                    if (@field(prefix, field)) {
+                        if (first) {
+                            first = false;
+                        } else {
+                            try dest.writeStr(") or (");
+                        }
+
+                        var p = css.VendorPrefix{};
+                        @field(p, field) = true;
+                        css.serializer.serializeName(name, dest) catch return dest.addFmtError();
+                        try dest.delim(':', false);
+                        try dest.writeStr(value);
+                    }
+                }
+
+                if (!prefix.eq(css.VendorPrefix{ .none = true })) {
+                    try dest.writeChar(')');
+                }
+                try dest.writeChar(')');
+            },
+            .selector => |sel| {
+                try dest.writeStr("selector(");
+                try dest.writeStr(sel);
+                try dest.writeChar(')');
+            },
+            .unknown => |unk| {
+                try dest.writeStr(unk);
+            },
+        }
+    }
+
+    pub fn toCssWithParensIfNeeded(
+        this: *const SupportsCondition,
+        comptime W: type,
+        dest: *css.Printer(
+            W,
+        ),
+        needs_parens: bool,
+    ) css.PrintErr!void {
+        if (needs_parens) try dest.writeStr("(");
+        try this.toCss(W, dest);
+        if (needs_parens) try dest.writeStr(")");
+    }
+};
+
+/// A [@supports](https://drafts.csswg.org/css-conditional-3/#at-supports) rule.
+pub fn SupportsRule(comptime R: type) type {
+    return struct {
+        /// The supports condition.
+        condition: SupportsCondition,
+        /// The rules within the `@supports` rule.
+        rules: css.CssRuleList(R),
+        /// The location of the rule in the source file.
+        loc: Location,
+
+        const This = @This();
+
+        pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+            // #[cfg(feature = "sourcemap")]
+            // dest.add_mapping(self.loc);
+
+            try dest.writeStr("@supports ");
+            try this.condition.toCss(W, dest);
+            try dest.whitespace();
+            try dest.writeChar('{');
+            dest.indent();
+            try dest.newline();
+            try this.rules.toCss(W, dest);
+            dest.dedent();
+            try dest.newline();
+            try dest.writeChar('}');
+        }
+
+        pub fn minify(this: *This, context: *css.MinifyContext, parent_is_unused: bool) css.MinifyErr!void {
+            _ = this; // autofix
+            _ = context; // autofix
+            _ = parent_is_unused; // autofix
+            // TODO: Implement this
+            return;
+        }
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) This {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    };
+}
diff --git a/src/css/rules/tailwind.zig b/src/css/rules/tailwind.zig
new file mode 100644
index 0000000000..b3e15e3e1b
--- /dev/null
+++ b/src/css/rules/tailwind.zig
@@ -0,0 +1,60 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const bun = @import("root").bun;
+const logger = bun.logger;
+const Log = logger.Log;
+
+pub const css = @import("../css_parser.zig");
+pub const css_values = @import("../values/values.zig");
+pub const Error = css.Error;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+
+/// @tailwind
+/// https://github.com/tailwindlabs/tailwindcss.com/blob/4d6ac11425d96bc963f936e0157df460a364c43b/src/pages/docs/functions-and-directives.mdx?plain=1#L13
+pub const TailwindAtRule = struct {
+    style_name: TailwindStyleName,
+    /// The location of the rule in the source file.
+    loc: css.Location,
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+        try dest.writeStr("@tailwind");
+        try dest.whitespace();
+        try this.style_name.toCss(W, dest);
+        try dest.writeChar(';');
+    }
+
+    pub fn deepClone(this: *const @This(), _: std.mem.Allocator) @This() {
+        return this.*;
+    }
+};
+
+pub const TailwindStyleName = enum {
+    /// This injects Tailwind's base styles and any base styles registered by
+    ///  plugins.
+    base,
+    /// This injects Tailwind's component classes and any component classes
+    /// registered by plugins.
+    components,
+    /// This injects Tailwind's utility classes and any utility classes registered
+    /// by plugins.
+    utilities,
+    /// Use this directive to control where Tailwind injects the hover, focus,
+    /// responsive, dark mode, and other variants of each class.
+    ///
+    /// If omitted, Tailwind will append these classes to the very end of
+    /// your stylesheet by default.
+    variants,
+
+    pub fn asStr(this: *const @This()) []const u8 {
+        return css.enum_property_util.asStr(@This(), this);
+    }
+
+    pub fn parse(input: *css.Parser) css.Result(@This()) {
+        return css.enum_property_util.parse(@This(), input);
+    }
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+        return css.enum_property_util.toCss(@This(), this, W, dest);
+    }
+};
diff --git a/src/css/rules/unknown.zig b/src/css/rules/unknown.zig
new file mode 100644
index 0000000000..a1ab9408ff
--- /dev/null
+++ b/src/css/rules/unknown.zig
@@ -0,0 +1,55 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const bun = @import("root").bun;
+const logger = bun.logger;
+const Log = logger.Log;
+
+pub const css = @import("../css_parser.zig");
+pub const css_values = @import("../values/values.zig");
+pub const Error = css.Error;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+
+/// An unknown at-rule, stored as raw tokens.
+pub const UnknownAtRule = struct {
+    /// The name of the at-rule (without the @).
+    name: []const u8,
+    /// The prelude of the rule.
+    prelude: css.TokenList,
+    /// The contents of the block, if any.
+    block: ?css.TokenList,
+    /// The location of the rule in the source file.
+    loc: css.Location,
+
+    const This = @This();
+
+    pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        // #[cfg(feature = "sourcemap")]
+        // dest.add_mapping(self.loc);
+
+        try dest.writeChar('@');
+        try dest.writeStr(this.name);
+
+        if (this.prelude.v.items.len > 0) {
+            try dest.writeChar(' ');
+            try this.prelude.toCss(W, dest, false);
+        }
+
+        if (this.block) |*block| {
+            try dest.whitespace();
+            try dest.writeChar('{');
+            dest.indent();
+            try dest.newline();
+            try block.toCss(W, dest, false);
+            dest.dedent();
+            try dest.newline();
+            try dest.writeChar('}');
+        } else {
+            try dest.writeChar(';');
+        }
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) This {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
diff --git a/src/css/rules/viewport.zig b/src/css/rules/viewport.zig
new file mode 100644
index 0000000000..03f88aa8c5
--- /dev/null
+++ b/src/css/rules/viewport.zig
@@ -0,0 +1,38 @@
+const std = @import("std");
+pub const css = @import("../css_parser.zig");
+const bun = @import("root").bun;
+const Error = css.Error;
+const ArrayList = std.ArrayListUnmanaged;
+const MediaList = css.MediaList;
+const CustomMedia = css.CustomMedia;
+const Printer = css.Printer;
+const Maybe = css.Maybe;
+const PrinterError = css.PrinterError;
+const PrintErr = css.PrintErr;
+const Location = css.css_rules.Location;
+const style = css.css_rules.style;
+
+/// A [@viewport](https://drafts.csswg.org/css-device-adapt/#atviewport-rule) rule.
+pub const ViewportRule = struct {
+    /// The vendor prefix for this rule, e.g. `@-ms-viewport`.
+    vendor_prefix: css.VendorPrefix,
+    /// The declarations within the `@viewport` rule.
+    declarations: css.DeclarationBlock,
+    /// The location of the rule in the source file.
+    loc: Location,
+
+    const This = @This();
+
+    pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        // #[cfg(feature = "sourcemap")]
+        // dest.add_mapping(self.loc);
+        try dest.writeChar('@');
+        try this.vendor_prefix.toCss(W, dest);
+        try dest.writeStr("viewport");
+        try this.declarations.toCssBlock(W, dest);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) This {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
diff --git a/src/css/selectors/builder.zig b/src/css/selectors/builder.zig
new file mode 100644
index 0000000000..e07aef3eb7
--- /dev/null
+++ b/src/css/selectors/builder.zig
@@ -0,0 +1,215 @@
+//! This is the selector builder module ported from the copypasted implementation from
+//! servo in lightningcss.
+//!
+//! -- original comment from servo --
+//! Helper module to build up a selector safely and efficiently.
+//!
+//! Our selector representation is designed to optimize matching, and has
+//! several requirements:
+//! * All simple selectors and combinators are stored inline in the same buffer
+//!   as Component instances.
+//! * We store the top-level compound selectors from right to left, i.e. in
+//!   matching order.
+//! * We store the simple selectors for each combinator from left to right, so
+//!   that we match the cheaper simple selectors first.
+//!
+//! Meeting all these constraints without extra memmove traffic during parsing
+//! is non-trivial. This module encapsulates those details and presents an
+//! easy-to-use API for the parser.
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const bun = @import("root").bun;
+const logger = bun.logger;
+const Log = logger.Log;
+
+pub const css = @import("../css_parser.zig");
+const CSSString = css.CSSString;
+const CSSStringFns = css.CSSStringFns;
+
+pub const Printer = css.Printer;
+pub const PrintErr = css.PrintErr;
+
+const Result = css.Result;
+const PrintResult = css.PrintResult;
+
+const ArrayList = std.ArrayListUnmanaged;
+
+const parser = css.selector.parser;
+
+const ValidSelectorImpl = parser.ValidSelectorImpl;
+const GenericComponent = parser.GenericComponent;
+const Combinator = parser.Combinator;
+const SpecifityAndFlags = parser.SpecifityAndFlags;
+const compute_specifity = parser.compute_specifity;
+const SelectorFlags = parser.SelectorFlags;
+
+/// Top-level SelectorBuilder struct. This should be stack-allocated by the
+/// consumer and never moved (because it contains a lot of inline data that
+/// would be slow to memmov).
+///
+/// After instantiation, callers may call the push_simple_selector() and
+/// push_combinator() methods to append selector data as it is encountered
+/// (from left to right). Once the process is complete, callers should invoke
+/// build(), which transforms the contents of the SelectorBuilder into a heap-
+/// allocated Selector and leaves the builder in a drained state.
+pub fn SelectorBuilder(comptime Impl: type) type {
+    ValidSelectorImpl(Impl);
+
+    return struct {
+        /// The entire sequence of simple selectors, from left to right, without combinators.
+        ///
+        /// We make this large because the result of parsing a selector is fed into a new
+        /// Arc-ed allocation, so any spilled vec would be a wasted allocation. Also,
+        /// Components are large enough that we don't have much cache locality benefit
+        /// from reserving stack space for fewer of them.
+        ///
+        simple_selectors: css.SmallList(GenericComponent(Impl), 32) = .{},
+
+        /// The combinators, and the length of the compound selector to their left.
+        ///
+        combinators: css.SmallList(struct { Combinator, usize }, 32) = .{},
+
+        /// The length of the current compound selector.
+        current_len: usize = 0,
+
+        allocator: Allocator,
+
+        const This = @This();
+
+        const BuildResult = struct {
+            specifity_and_flags: SpecifityAndFlags,
+            components: ArrayList(GenericComponent(Impl)),
+        };
+
+        pub inline fn init(allocator: Allocator) This {
+            return This{
+                .allocator = allocator,
+            };
+        }
+
+        /// Returns true if combinators have ever been pushed to this builder.
+        pub inline fn hasCombinators(this: *This) bool {
+            return this.combinators.len() > 0;
+        }
+
+        /// Completes the current compound selector and starts a new one, delimited
+        /// by the given combinator.
+        pub inline fn pushCombinator(this: *This, combinator: Combinator) void {
+            this.combinators.append(this.allocator, .{ combinator, this.current_len });
+            this.current_len = 0;
+        }
+
+        /// Pushes a simple selector onto the current compound selector.
+        pub fn pushSimpleSelector(this: *This, ss: GenericComponent(Impl)) void {
+            bun.assert(!ss.isCombinator());
+            this.simple_selectors.append(this.allocator, ss);
+            this.current_len += 1;
+        }
+
+        pub fn addNestingPrefix(this: *This) void {
+            this.combinators.insert(this.allocator, 0, .{ Combinator.descendant, 1 });
+            this.simple_selectors.insert(this.allocator, 0, .nesting);
+        }
+
+        pub fn deinit(this: *This) void {
+            this.simple_selectors.deinit(this.allocator);
+            this.combinators.deinit(this.allocator);
+        }
+
+        /// Consumes the builder, producing a Selector.
+        ///
+        /// *NOTE*: This will free all allocated memory in the builder
+        pub fn build(
+            this: *This,
+            parsed_pseudo: bool,
+            parsed_slotted: bool,
+            parsed_part: bool,
+        ) BuildResult {
+            const specifity = compute_specifity(Impl, this.simple_selectors.slice());
+            var flags = SelectorFlags.empty();
+            // PERF: is it faster to do these ORs all at once
+            if (parsed_pseudo) {
+                flags.has_pseudo = true;
+            }
+            if (parsed_slotted) {
+                flags.has_slotted = true;
+            }
+            if (parsed_part) {
+                flags.has_part = true;
+            }
+            // `buildWithSpecificityAndFlags()` will
+            defer this.deinit();
+            return this.buildWithSpecificityAndFlags(SpecifityAndFlags{ .specificity = specifity, .flags = flags });
+        }
+
+        /// Builds a selector with the given specifity and flags.
+        ///
+        /// PERF:
+        ///     Recall that this code is ported from servo, which optimizes for matching speed, so
+        ///     the final AST has the components of the selector stored in reverse order, which is
+        ///     optimized for matching.
+        ///
+        ///     We don't really care about matching selectors, and storing the components in reverse
+        ///     order requires additional allocations, and undoing the reversal when serializing the
+        ///     selector. So we could just change this code to store the components in the same order
+        ///     as the source.
+        pub fn buildWithSpecificityAndFlags(this: *This, spec: SpecifityAndFlags) BuildResult {
+            const T = GenericComponent(Impl);
+            const rest: []const T, const current: []const T = splitFromEnd(T, this.simple_selectors.slice(), this.current_len);
+            const combinators = this.combinators.slice();
+            defer {
+                // This function should take every component from `this.simple_selectors`
+                // and place it into `components` and return it.
+                //
+                // This means that we shouldn't leak any `GenericComponent(Impl)`, so
+                // it is safe to just set the length to 0.
+                //
+                // Combinators don't need to be deinitialized because they are simple enums.
+                this.simple_selectors.setLen(0);
+                this.combinators.setLen(0);
+            }
+
+            var components = ArrayList(T){};
+
+            var current_simple_selectors_i: usize = 0;
+            var combinator_i: i64 = @as(i64, @intCast(this.combinators.len())) - 1;
+            var rest_of_simple_selectors = rest;
+            var current_simple_selectors = current;
+
+            while (true) {
+                if (current_simple_selectors_i < current_simple_selectors.len) {
+                    components.append(
+                        this.allocator,
+                        current_simple_selectors[current_simple_selectors_i],
+                    ) catch unreachable;
+                    current_simple_selectors_i += 1;
+                } else {
+                    if (combinator_i >= 0) {
+                        const combo: Combinator, const len: usize = combinators[@intCast(combinator_i)];
+                        const rest2, const current2 = splitFromEnd(GenericComponent(Impl), rest_of_simple_selectors, len);
+                        rest_of_simple_selectors = rest2;
+                        current_simple_selectors_i = 0;
+                        current_simple_selectors = current2;
+                        combinator_i -= 1;
+                        components.append(
+                            this.allocator,
+                            .{ .combinator = combo },
+                        ) catch unreachable;
+                        continue;
+                    }
+                    break;
+                }
+            }
+
+            return .{ .specifity_and_flags = spec, .components = components };
+        }
+
+        pub fn splitFromEnd(comptime T: type, s: []const T, at: usize) struct { []const T, []const T } {
+            const midpoint = s.len - at;
+            return .{
+                s[0..midpoint],
+                s[midpoint..],
+            };
+        }
+    };
+}
diff --git a/src/css/selectors/parser.zig b/src/css/selectors/parser.zig
new file mode 100644
index 0000000000..a89dd6345a
--- /dev/null
+++ b/src/css/selectors/parser.zig
@@ -0,0 +1,3664 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const bun = @import("root").bun;
+const logger = bun.logger;
+const Log = logger.Log;
+
+pub const css = @import("../css_parser.zig");
+const CSSString = css.CSSString;
+const CSSStringFns = css.CSSStringFns;
+
+pub const Printer = css.Printer;
+pub const PrintErr = css.PrintErr;
+
+const Result = css.Result;
+const PrintResult = css.PrintResult;
+const SmallList = css.SmallList;
+const ArrayList = std.ArrayListUnmanaged;
+
+const impl = css.selector.impl;
+const serialize = css.selector.serialize;
+
+/// Instantiation of generic selector structs using our implementation of the `SelectorImpl` trait.
+pub const Component = GenericComponent(impl.Selectors);
+pub const Selector = GenericSelector(impl.Selectors);
+pub const SelectorList = GenericSelectorList(impl.Selectors);
+
+pub const ToCssCtx = enum {
+    lightning,
+    servo,
+};
+
+/// The definition of whitespace per CSS Selectors Level 3 § 4.
+pub const SELECTOR_WHITESPACE: []const u8 = &[_]u8{ ' ', '\t', '\n', '\r', 0x0C };
+
+pub fn ValidSelectorImpl(comptime T: type) void {
+    _ = T.SelectorImpl.ExtraMatchingData;
+    _ = T.SelectorImpl.AttrValue;
+    _ = T.SelectorImpl.Identifier;
+    _ = T.SelectorImpl.LocalName;
+    _ = T.SelectorImpl.NamespaceUrl;
+    _ = T.SelectorImpl.NamespacePrefix;
+    _ = T.SelectorImpl.BorrowedNamespaceUrl;
+    _ = T.SelectorImpl.BorrowedLocalName;
+
+    _ = T.SelectorImpl.NonTSPseudoClass;
+    _ = T.SelectorImpl.VendorPrefix;
+    _ = T.SelectorImpl.PseudoElement;
+}
+
+const selector_builder = @import("./builder.zig");
+
+pub const attrs = struct {
+    pub fn NamespaceUrl(comptime Impl: type) type {
+        return struct {
+            prefix: Impl.SelectorImpl.NamespacePrefix,
+            url: Impl.SelectorImpl.NamespaceUrl,
+
+            pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+                return css.implementEql(@This(), lhs, rhs);
+            }
+
+            pub fn deepClone(this: *const @This(), allocator: Allocator) @This() {
+                return css.implementDeepClone(@This(), this, allocator);
+            }
+
+            pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+                return css.implementHash(@This(), this, hasher);
+            }
+        };
+    }
+
+    pub fn AttrSelectorWithOptionalNamespace(comptime Impl: type) type {
+        return struct {
+            namespace: ?NamespaceConstraint(NamespaceUrl(Impl)),
+            local_name: Impl.SelectorImpl.LocalName,
+            local_name_lower: Impl.SelectorImpl.LocalName,
+            operation: ParsedAttrSelectorOperation(Impl.SelectorImpl.AttrValue),
+            never_matches: bool,
+
+            pub fn toCss(this: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+                try dest.writeChar('[');
+                if (this.namespace) |nsp| switch (nsp) {
+                    .specific => |v| {
+                        try css.IdentFns.toCss(&v.prefix, W, dest);
+                        try dest.writeChar('|');
+                    },
+                    .any => {
+                        try dest.writeStr("*|");
+                    },
+                };
+                try css.IdentFns.toCss(&this.local_name, W, dest);
+                switch (this.operation) {
+                    .exists => {},
+                    .with_value => |v| {
+                        try v.operator.toCss(W, dest);
+                        // try v.expected_value.toCss(dest);
+                        try CSSStringFns.toCss(&v.expected_value, W, dest);
+                        switch (v.case_sensitivity) {
+                            .case_sensitive, .ascii_case_insensitive_if_in_html_element_in_html_document => {},
+                            .ascii_case_insensitive => {
+                                try dest.writeStr(" i");
+                            },
+                            .explicit_case_sensitive => {
+                                try dest.writeStr(" s");
+                            },
+                        }
+                    },
+                }
+                return dest.writeChar(']');
+            }
+
+            pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+                return css.implementEql(@This(), lhs, rhs);
+            }
+
+            pub fn deepClone(this: *const @This(), allocator: Allocator) @This() {
+                return css.implementDeepClone(@This(), this, allocator);
+            }
+
+            pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+                return css.implementHash(@This(), this, hasher);
+            }
+        };
+    }
+
+    pub fn NamespaceConstraint(comptime NamespaceUrl_: type) type {
+        return union(enum) {
+            any,
+            /// Empty string for no namespace
+            specific: NamespaceUrl_,
+
+            pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+                return css.implementEql(@This(), lhs, rhs);
+            }
+
+            pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+                return css.implementHash(@This(), this, hasher);
+            }
+
+            pub fn deepClone(this: *const @This(), allocator: Allocator) @This() {
+                return css.implementDeepClone(@This(), this, allocator);
+            }
+        };
+    }
+
+    pub fn ParsedAttrSelectorOperation(comptime AttrValue: type) type {
+        return union(enum) {
+            exists,
+            with_value: struct {
+                operator: AttrSelectorOperator,
+                case_sensitivity: ParsedCaseSensitivity,
+                expected_value: AttrValue,
+
+                pub fn __generateEql() void {}
+                pub fn __generateDeepClone() void {}
+                pub fn __generateHash() void {}
+            },
+
+            pub fn deepClone(this: *const @This(), allocator: Allocator) @This() {
+                return css.implementDeepClone(@This(), this, allocator);
+            }
+
+            pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+                return css.implementEql(@This(), lhs, rhs);
+            }
+
+            pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+                return css.implementHash(@This(), this, hasher);
+            }
+        };
+    }
+
+    pub const AttrSelectorOperator = enum {
+        equal,
+        includes,
+        dash_match,
+        prefix,
+        substring,
+        suffix,
+
+        const This = @This();
+        pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+            // https://drafts.csswg.org/cssom/#serializing-selectors
+            // See "attribute selector".
+            return dest.writeStr(switch (this.*) {
+                .equal => "=",
+                .includes => "~=",
+                .dash_match => "|=",
+                .prefix => "^=",
+                .substring => "*=",
+                .suffix => "$=",
+            });
+        }
+
+        pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+            return css.implementHash(@This(), this, hasher);
+        }
+    };
+
+    pub const AttrSelectorOperation = enum {
+        equal,
+        includes,
+        dash_match,
+        prefix,
+        substring,
+        suffix,
+    };
+
+    pub const ParsedCaseSensitivity = enum {
+        // 's' was specified.
+        explicit_case_sensitive,
+        // 'i' was specified.
+        ascii_case_insensitive,
+        // No flags were specified and HTML says this is a case-sensitive attribute.
+        case_sensitive,
+        // No flags were specified and HTML says this is a case-insensitive attribute.
+        ascii_case_insensitive_if_in_html_element_in_html_document,
+    };
+};
+
+pub const Specifity = struct {
+    id_selectors: u32 = 0,
+    class_like_selectors: u32 = 0,
+    element_selectors: u32 = 0,
+
+    const MAX_10BIT: u32 = (1 << 10) - 1;
+
+    pub fn toU32(this: Specifity) u32 {
+        return @as(u32, @as(u32, @min(this.id_selectors, MAX_10BIT)) << @as(u32, 20)) |
+            @as(u32, @as(u32, @min(this.class_like_selectors, MAX_10BIT)) << @as(u32, 10)) |
+            @min(this.element_selectors, MAX_10BIT);
+    }
+
+    pub fn fromU32(value: u32) Specifity {
+        bun.assert(value <= MAX_10BIT << 20 | MAX_10BIT << 10 | MAX_10BIT);
+        return Specifity{
+            .id_selectors = value >> 20,
+            .class_like_selectors = (value >> 10) & MAX_10BIT,
+            .element_selectors = value & MAX_10BIT,
+        };
+    }
+
+    pub fn add(lhs: *Specifity, rhs: Specifity) void {
+        lhs.id_selectors += rhs.id_selectors;
+        lhs.element_selectors += rhs.element_selectors;
+        lhs.class_like_selectors += rhs.class_like_selectors;
+    }
+};
+
+pub fn compute_specifity(comptime Impl: type, iter: []const GenericComponent(Impl)) u32 {
+    const spec = compute_complex_selector_specifity(Impl, iter);
+    return spec.toU32();
+}
+
+fn compute_complex_selector_specifity(comptime Impl: type, iter: []const GenericComponent(Impl)) Specifity {
+    var specifity: Specifity = .{};
+
+    for (iter) |*simple_selector| {
+        compute_simple_selector_specifity(Impl, simple_selector, &specifity);
+    }
+
+    return specifity;
+}
+
+fn compute_simple_selector_specifity(
+    comptime Impl: type,
+    simple_selector: *const GenericComponent(Impl),
+    specifity: *Specifity,
+) void {
+    switch (simple_selector.*) {
+        .combinator => {
+            bun.unreachablePanic("Found combinator in simple selectors vector?", .{});
+        },
+        .part, .pseudo_element, .local_name => {
+            specifity.element_selectors += 1;
+        },
+        .slotted => |selector| {
+            specifity.element_selectors += 1;
+            // Note that due to the way ::slotted works we only compete with
+            // other ::slotted rules, so the above rule doesn't really
+            // matter, but we do it still for consistency with other
+            // pseudo-elements.
+            //
+            // See: https://github.com/w3c/csswg-drafts/issues/1915
+            specifity.add(Specifity.fromU32(selector.specifity()));
+        },
+        .host => |maybe_selector| {
+            specifity.class_like_selectors += 1;
+            if (maybe_selector) |*selector| {
+                // See: https://github.com/w3c/csswg-drafts/issues/1915
+                specifity.add(Specifity.fromU32(selector.specifity()));
+            }
+        },
+        .id => {
+            specifity.id_selectors += 1;
+        },
+        .class,
+        .attribute_in_no_namespace,
+        .attribute_in_no_namespace_exists,
+        .attribute_other,
+        .root,
+        .empty,
+        .scope,
+        .nth,
+        .non_ts_pseudo_class,
+        => {
+            specifity.class_like_selectors += 1;
+        },
+        .nth_of => |nth_of_data| {
+            // https://drafts.csswg.org/selectors/#specificity-rules:
+            //
+            //     The specificity of the :nth-last-child() pseudo-class,
+            //     like the :nth-child() pseudo-class, combines the
+            //     specificity of a regular pseudo-class with that of its
+            //     selector argument S.
+            specifity.class_like_selectors += 1;
+            var max: u32 = 0;
+            for (nth_of_data.selectors) |*selector| {
+                max = @max(selector.specifity(), max);
+            }
+            specifity.add(Specifity.fromU32(max));
+        },
+        .negation, .is, .any => {
+            // https://drafts.csswg.org/selectors/#specificity-rules:
+            //
+            //     The specificity of an :is() pseudo-class is replaced by the
+            //     specificity of the most specific complex selector in its
+            //     selector list argument.
+            const list: []GenericSelector(Impl) = switch (simple_selector.*) {
+                .negation => |list| list,
+                .is => |list| list,
+                .any => |a| a.selectors,
+                else => unreachable,
+            };
+            var max: u32 = 0;
+            for (list) |*selector| {
+                max = @max(selector.specifity(), max);
+            }
+            specifity.add(Specifity.fromU32(max));
+        },
+        .where,
+        .has,
+        .explicit_universal_type,
+        .explicit_any_namespace,
+        .explicit_no_namespace,
+        .default_namespace,
+        .namespace,
+        => {
+            // Does not affect specifity
+        },
+        .nesting => {
+            // TODO
+        },
+    }
+}
+
+const SelectorBuilder = selector_builder.SelectorBuilder;
+
+/// Build up a Selector.
+/// selector : simple_selector_sequence [ combinator simple_selector_sequence ]* ;
+///
+/// `Err` means invalid selector.
+fn parse_selector(
+    comptime Impl: type,
+    parser: *SelectorParser,
+    input: *css.Parser,
+    state: *SelectorParsingState,
+    nesting_requirement: NestingRequirement,
+) Result(GenericSelector(Impl)) {
+    if (nesting_requirement == .prefixed) {
+        const parser_state = input.state();
+        if (!input.expectDelim('&').isOk()) {
+            return .{ .err = input.newCustomError(SelectorParseErrorKind.intoDefaultParserError(.missing_nesting_prefix)) };
+        }
+        input.reset(&parser_state);
+    }
+
+    // PERF: allocations here
+    var builder = selector_builder.SelectorBuilder(Impl){
+        .allocator = input.allocator(),
+    };
+
+    outer_loop: while (true) {
+        // Parse a sequence of simple selectors.
+        const empty = switch (parse_compound_selector(Impl, parser, state, input, &builder)) {
+            .err => |e| return .{ .err = e },
+            .result => |v| v,
+        };
+        if (empty) {
+            const kind: SelectorParseErrorKind = if (builder.hasCombinators())
+                .dangling_combinator
+            else
+                .empty_selector;
+
+            return .{ .err = input.newCustomError(kind.intoDefaultParserError()) };
+        }
+
+        if (state.intersects(SelectorParsingState.AFTER_PSEUDO)) {
+            const source_location = input.currentSourceLocation();
+            if (input.next().asValue()) |next| {
+                return .{ .err = source_location.newCustomError(SelectorParseErrorKind.intoDefaultParserError(.{ .unexpected_selector_after_pseudo_element = next.* })) };
+            }
+            break;
+        }
+
+        // Parse a combinator
+        var combinator: Combinator = undefined;
+        var any_whitespace = false;
+        while (true) {
+            const before_this_token = input.state();
+            const tok: *css.Token = switch (input.nextIncludingWhitespace()) {
+                .result => |vv| vv,
+                .err => break :outer_loop,
+            };
+            switch (tok.*) {
+                .whitespace => {
+                    any_whitespace = true;
+                    continue;
+                },
+                .delim => |d| {
+                    switch (d) {
+                        '>' => {
+                            if (parser.deepCombinatorEnabled() and input.tryParse(struct {
+                                pub fn parseFn(i: *css.Parser) Result(void) {
+                                    if (i.expectDelim('>').asErr()) |e| return .{ .err = e };
+                                    return i.expectDelim('>');
+                                }
+                            }.parseFn, .{}).isOk()) {
+                                combinator = Combinator.deep_descendant;
+                            } else {
+                                combinator = Combinator.child;
+                            }
+                            break;
+                        },
+                        '+' => {
+                            combinator = .next_sibling;
+                            break;
+                        },
+                        '~' => {
+                            combinator = .later_sibling;
+                            break;
+                        },
+                        '/' => {
+                            if (parser.deepCombinatorEnabled()) {
+                                if (input.tryParse(struct {
+                                    pub fn parseFn(i: *css.Parser) Result(void) {
+                                        if (i.expectIdentMatching("deep").asErr()) |e| return .{ .err = e };
+                                        return i.expectDelim('/');
+                                    }
+                                }.parseFn, .{}).isOk()) {
+                                    combinator = .deep;
+                                    break;
+                                } else {
+                                    break :outer_loop;
+                                }
+                            }
+                        },
+                        else => {},
+                    }
+                },
+                else => {},
+            }
+
+            input.reset(&before_this_token);
+
+            if (any_whitespace) {
+                combinator = .descendant;
+                break;
+            } else {
+                break :outer_loop;
+            }
+        }
+
+        if (!state.allowsCombinators()) {
+            return .{ .err = input.newCustomError(SelectorParseErrorKind.intoDefaultParserError(.invalid_state)) };
+        }
+
+        builder.pushCombinator(combinator);
+    }
+
+    if (!state.contains(SelectorParsingState{ .after_nesting = true })) {
+        switch (nesting_requirement) {
+            .implicit => {
+                builder.addNestingPrefix();
+            },
+            .contained, .prefixed => {
+                return .{ .err = input.newCustomError(SelectorParseErrorKind.intoDefaultParserError(.missing_nesting_selector)) };
+            },
+            else => {},
+        }
+    }
+
+    const has_pseudo_element = state.intersects(SelectorParsingState{
+        .after_pseudo_element = true,
+        .after_unknown_pseudo_element = true,
+    });
+    const slotted = state.intersects(SelectorParsingState{ .after_slotted = true });
+    const part = state.intersects(SelectorParsingState{ .after_part = true });
+    const result = builder.build(has_pseudo_element, slotted, part);
+    return .{ .result = Selector{
+        .specifity_and_flags = result.specifity_and_flags,
+        .components = result.components,
+    } };
+}
+
+/// simple_selector_sequence
+/// : [ type_selector | universal ] [ HASH | class | attrib | pseudo | negation ]*
+/// | [ HASH | class | attrib | pseudo | negation ]+
+///
+/// `Err(())` means invalid selector.
+/// `Ok(true)` is an empty selector
+fn parse_compound_selector(
+    comptime Impl: type,
+    parser: *SelectorParser,
+    state: *SelectorParsingState,
+    input: *css.Parser,
+    builder: *SelectorBuilder(Impl),
+) Result(bool) {
+    input.skipWhitespace();
+
+    var empty: bool = true;
+    if (parser.isNestingAllowed() and if (input.tryParse(css.Parser.expectDelim, .{'&'}).isOk()) true else false) {
+        state.insert(SelectorParsingState{ .after_nesting = true });
+        builder.pushSimpleSelector(.nesting);
+        empty = false;
+    }
+
+    if (parse_type_selector(Impl, parser, input, state.*, builder).asValue()) |_| {
+        empty = false;
+    }
+
+    while (true) {
+        const result: SimpleSelectorParseResult(Impl) = result: {
+            const ret = switch (parse_one_simple_selector(Impl, parser, input, state)) {
+                .result => |r| r,
+                .err => |e| return .{ .err = e },
+            };
+            if (ret) |result| {
+                break :result result;
+            }
+            break;
+        };
+
+        if (empty) {
+            if (parser.defaultNamespace()) |url| {
+                // If there was no explicit type selector, but there is a
+                // default namespace, there is an implicit "<defaultns>|*" type
+                // selector. Except for :host() or :not() / :is() / :where(),
+                // where we ignore it.
+                //
+                // https://drafts.csswg.org/css-scoping/#host-element-in-tree:
+                //
+                //     When considered within its own shadow trees, the shadow
+                //     host is featureless. Only the :host, :host(), and
+                //     :host-context() pseudo-classes are allowed to match it.
+                //
+                // https://drafts.csswg.org/selectors-4/#featureless:
+                //
+                //     A featureless element does not match any selector at all,
+                //     except those it is explicitly defined to match. If a
+                //     given selector is allowed to match a featureless element,
+                //     it must do so while ignoring the default namespace.
+                //
+                // https://drafts.csswg.org/selectors-4/#matches
+                //
+                //     Default namespace declarations do not affect the compound
+                //     selector representing the subject of any selector within
+                //     a :is() pseudo-class, unless that compound selector
+                //     contains an explicit universal selector or type selector.
+                //
+                //     (Similar quotes for :where() / :not())
+                //
+                const ignore_default_ns = state.intersects(SelectorParsingState{ .skip_default_namespace = true }) or
+                    (result == .simple_selector and result.simple_selector == .host);
+                if (!ignore_default_ns) {
+                    builder.pushSimpleSelector(.{ .default_namespace = url });
+                }
+            }
+        }
+
+        empty = false;
+
+        switch (result) {
+            .simple_selector => {
+                builder.pushSimpleSelector(result.simple_selector);
+            },
+            .part_pseudo => {
+                const selector = result.part_pseudo;
+                state.insert(SelectorParsingState{ .after_part = true });
+                builder.pushCombinator(.part);
+                builder.pushSimpleSelector(.{ .part = selector });
+            },
+            .slotted_pseudo => |selector| {
+                state.insert(.{ .after_slotted = true });
+                builder.pushCombinator(.slot_assignment);
+                builder.pushSimpleSelector(.{ .slotted = selector });
+            },
+            .pseudo_element => |p| {
+                if (!p.isUnknown()) {
+                    state.insert(SelectorParsingState{ .after_pseudo_element = true });
+                    builder.pushCombinator(.pseudo_element);
+                } else {
+                    state.insert(.{ .after_unknown_pseudo_element = true });
+                }
+
+                if (!p.acceptsStatePseudoClasses()) {
+                    state.insert(.{ .after_non_stateful_pseudo_element = true });
+                }
+
+                if (p.isWebkitScrollbar()) {
+                    state.insert(.{ .after_webkit_scrollbar = true });
+                }
+
+                if (p.isViewTransition()) {
+                    state.insert(.{ .after_view_transition = true });
+                }
+
+                builder.pushSimpleSelector(.{ .pseudo_element = p });
+            },
+        }
+    }
+
+    return .{ .result = empty };
+}
+
+fn parse_relative_selector(
+    comptime Impl: type,
+    parser: *SelectorParser,
+    input: *css.Parser,
+    state: *SelectorParsingState,
+    nesting_requirement_: NestingRequirement,
+) Result(GenericSelector(Impl)) {
+    // https://www.w3.org/TR/selectors-4/#parse-relative-selector
+    var nesting_requirement = nesting_requirement_;
+    const s = input.state();
+
+    const combinator: ?Combinator = combinator: {
+        const tok = switch (input.next()) {
+            .err => |e| return .{ .err = e },
+            .result => |v| v,
+        };
+        switch (tok.*) {
+            .delim => |c| {
+                switch (c) {
+                    '>' => break :combinator Combinator.child,
+                    '+' => break :combinator Combinator.next_sibling,
+                    '~' => break :combinator Combinator.later_sibling,
+                    else => {},
+                }
+            },
+            else => {},
+        }
+        input.reset(&s);
+        break :combinator null;
+    };
+
+    const scope: GenericComponent(Impl) = if (nesting_requirement == .implicit) .nesting else .scope;
+
+    if (combinator != null) {
+        nesting_requirement = .none;
+    }
+
+    var selector = switch (parse_selector(Impl, parser, input, state, nesting_requirement)) {
+        .err => |e| return .{ .err = e },
+        .result => |v| v,
+    };
+    if (combinator) |wombo_combo| {
+        // https://www.w3.org/TR/selectors/#absolutizing
+        selector.components.append(
+            parser.allocator,
+            .{ .combinator = wombo_combo },
+        ) catch unreachable;
+        selector.components.append(
+            parser.allocator,
+            scope,
+        ) catch unreachable;
+    }
+
+    return .{ .result = selector };
+}
+
+pub fn ValidSelectorParser(comptime T: type) type {
+    ValidSelectorImpl(T.SelectorParser.Impl);
+
+    // Whether to parse the `::slotted()` pseudo-element.
+    _ = T.SelectorParser.parseSlotted;
+
+    _ = T.SelectorParser.parsePart;
+
+    _ = T.SelectorParser.parseIsAndWhere;
+
+    _ = T.SelectorParser.isAndWhereErrorRecovery;
+
+    _ = T.SelectorParser.parseAnyPrefix;
+
+    _ = T.SelectorParser.parseHost;
+
+    _ = T.SelectorParser.parseNonTsPseudoClass;
+
+    _ = T.SelectorParser.parseNonTsFunctionalPseudoClass;
+
+    _ = T.SelectorParser.parsePseudoElement;
+
+    _ = T.SelectorParser.parseFunctionalPseudoElement;
+
+    _ = T.SelectorParser.defaultNamespace;
+
+    _ = T.SelectorParser.namespaceForPrefix;
+
+    _ = T.SelectorParser.isNestingAllowed;
+
+    _ = T.SelectorParser.deepCombinatorEnabled;
+}
+
+/// The [:dir()](https://drafts.csswg.org/selectors-4/#the-dir-pseudo) pseudo class.
+pub const Direction = enum {
+    /// Left to right
+    ltr,
+    /// Right to left
+    rtl,
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn asStr(this: *const @This()) []const u8 {
+        return css.enum_property_util.asStr(@This(), this);
+    }
+
+    pub fn parse(input: *css.Parser) Result(@This()) {
+        return css.enum_property_util.parse(@This(), input);
+    }
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+        return css.enum_property_util.toCss(@This(), this, W, dest);
+    }
+};
+
+/// A pseudo class.
+pub const PseudoClass = union(enum) {
+    /// https://drafts.csswg.org/selectors-4/#linguistic-pseudos
+    /// The [:lang()](https://drafts.csswg.org/selectors-4/#the-lang-pseudo) pseudo class.
+    lang: struct {
+        /// A list of language codes.
+        languages: ArrayList([]const u8),
+
+        pub fn __generateEql() void {}
+        pub fn __generateDeepClone() void {}
+        pub fn __generateHash() void {}
+    },
+    /// The [:dir()](https://drafts.csswg.org/selectors-4/#the-dir-pseudo) pseudo class.
+    dir: struct {
+        /// A direction.
+        direction: Direction,
+
+        pub fn __generateEql() void {}
+        pub fn __generateDeepClone() void {}
+        pub fn __generateHash() void {}
+    },
+
+    // https://drafts.csswg.org/selectors-4/#useraction-pseudos
+    /// The [:hover](https://drafts.csswg.org/selectors-4/#the-hover-pseudo) pseudo class.
+    hover,
+    /// The [:active](https://drafts.csswg.org/selectors-4/#the-active-pseudo) pseudo class.
+    active,
+    /// The [:focus](https://drafts.csswg.org/selectors-4/#the-focus-pseudo) pseudo class.
+    focus,
+    /// The [:focus-visible](https://drafts.csswg.org/selectors-4/#the-focus-visible-pseudo) pseudo class.
+    focus_visible,
+    /// The [:focus-within](https://drafts.csswg.org/selectors-4/#the-focus-within-pseudo) pseudo class.
+    focus_within,
+
+    /// https://drafts.csswg.org/selectors-4/#time-pseudos
+    /// The [:current](https://drafts.csswg.org/selectors-4/#the-current-pseudo) pseudo class.
+    current,
+    /// The [:past](https://drafts.csswg.org/selectors-4/#the-past-pseudo) pseudo class.
+    past,
+    /// The [:future](https://drafts.csswg.org/selectors-4/#the-future-pseudo) pseudo class.
+    future,
+
+    /// https://drafts.csswg.org/selectors-4/#resource-pseudos
+    /// The [:playing](https://drafts.csswg.org/selectors-4/#selectordef-playing) pseudo class.
+    playing,
+    /// The [:paused](https://drafts.csswg.org/selectors-4/#selectordef-paused) pseudo class.
+    paused,
+    /// The [:seeking](https://drafts.csswg.org/selectors-4/#selectordef-seeking) pseudo class.
+    seeking,
+    /// The [:buffering](https://drafts.csswg.org/selectors-4/#selectordef-buffering) pseudo class.
+    buffering,
+    /// The [:stalled](https://drafts.csswg.org/selectors-4/#selectordef-stalled) pseudo class.
+    stalled,
+    /// The [:muted](https://drafts.csswg.org/selectors-4/#selectordef-muted) pseudo class.
+    muted,
+    /// The [:volume-locked](https://drafts.csswg.org/selectors-4/#selectordef-volume-locked) pseudo class.
+    volume_locked,
+
+    /// The [:fullscreen](https://fullscreen.spec.whatwg.org/#:fullscreen-pseudo-class) pseudo class.
+    fullscreen: css.VendorPrefix,
+
+    /// https://drafts.csswg.org/selectors/#display-state-pseudos
+    /// The [:open](https://drafts.csswg.org/selectors/#selectordef-open) pseudo class.
+    open,
+    /// The [:closed](https://drafts.csswg.org/selectors/#selectordef-closed) pseudo class.
+    closed,
+    /// The [:modal](https://drafts.csswg.org/selectors/#modal-state) pseudo class.
+    modal,
+    /// The [:picture-in-picture](https://drafts.csswg.org/selectors/#pip-state) pseudo class.
+    picture_in_picture,
+
+    /// https://html.spec.whatwg.org/multipage/semantics-other.html#selector-popover-open
+    /// The [:popover-open](https://html.spec.whatwg.org/multipage/semantics-other.html#selector-popover-open) pseudo class.
+    popover_open,
+
+    /// The [:defined](https://drafts.csswg.org/selectors-4/#the-defined-pseudo) pseudo class.
+    defined,
+
+    /// https://drafts.csswg.org/selectors-4/#location
+    /// The [:any-link](https://drafts.csswg.org/selectors-4/#the-any-link-pseudo) pseudo class.
+    any_link: css.VendorPrefix,
+    /// The [:link](https://drafts.csswg.org/selectors-4/#link-pseudo) pseudo class.
+    link,
+    /// The [:local-link](https://drafts.csswg.org/selectors-4/#the-local-link-pseudo) pseudo class.
+    local_link,
+    /// The [:target](https://drafts.csswg.org/selectors-4/#the-target-pseudo) pseudo class.
+    target,
+    /// The [:target-within](https://drafts.csswg.org/selectors-4/#the-target-within-pseudo) pseudo class.
+    target_within,
+    /// The [:visited](https://drafts.csswg.org/selectors-4/#visited-pseudo) pseudo class.
+    visited,
+
+    /// https://drafts.csswg.org/selectors-4/#input-pseudos
+    /// The [:enabled](https://drafts.csswg.org/selectors-4/#enabled-pseudo) pseudo class.
+    enabled,
+    /// The [:disabled](https://drafts.csswg.org/selectors-4/#disabled-pseudo) pseudo class.
+    disabled,
+    /// The [:read-only](https://drafts.csswg.org/selectors-4/#read-only-pseudo) pseudo class.
+    read_only: css.VendorPrefix,
+    /// The [:read-write](https://drafts.csswg.org/selectors-4/#read-write-pseudo) pseudo class.
+    read_write: css.VendorPrefix,
+    /// The [:placeholder-shown](https://drafts.csswg.org/selectors-4/#placeholder) pseudo class.
+    placeholder_shown: css.VendorPrefix,
+    /// The [:default](https://drafts.csswg.org/selectors-4/#the-default-pseudo) pseudo class.
+    default,
+    /// The [:checked](https://drafts.csswg.org/selectors-4/#checked) pseudo class.
+    checked,
+    /// The [:indeterminate](https://drafts.csswg.org/selectors-4/#indeterminate) pseudo class.
+    indeterminate,
+    /// The [:blank](https://drafts.csswg.org/selectors-4/#blank) pseudo class.
+    blank,
+    /// The [:valid](https://drafts.csswg.org/selectors-4/#valid-pseudo) pseudo class.
+    valid,
+    /// The [:invalid](https://drafts.csswg.org/selectors-4/#invalid-pseudo) pseudo class.
+    invalid,
+    /// The [:in-range](https://drafts.csswg.org/selectors-4/#in-range-pseudo) pseudo class.
+    in_range,
+    /// The [:out-of-range](https://drafts.csswg.org/selectors-4/#out-of-range-pseudo) pseudo class.
+    out_of_range,
+    /// The [:required](https://drafts.csswg.org/selectors-4/#required-pseudo) pseudo class.
+    required,
+    /// The [:optional](https://drafts.csswg.org/selectors-4/#optional-pseudo) pseudo class.
+    optional,
+    /// The [:user-valid](https://drafts.csswg.org/selectors-4/#user-valid-pseudo) pseudo class.
+    user_valid,
+    /// The [:used-invalid](https://drafts.csswg.org/selectors-4/#user-invalid-pseudo) pseudo class.
+    user_invalid,
+
+    /// The [:autofill](https://html.spec.whatwg.org/multipage/semantics-other.html#selector-autofill) pseudo class.
+    autofill: css.VendorPrefix,
+
+    // CSS modules
+    /// The CSS modules :local() pseudo class.
+    local: struct {
+        /// A local selector.
+        selector: *Selector,
+
+        pub fn __generateEql() void {}
+        pub fn __generateDeepClone() void {}
+        pub fn __generateHash() void {}
+    },
+    /// The CSS modules :global() pseudo class.
+    global: struct {
+        /// A global selector.
+        selector: *Selector,
+
+        pub fn __generateEql() void {}
+        pub fn __generateDeepClone() void {}
+        pub fn __generateHash() void {}
+    },
+
+    /// A [webkit scrollbar](https://webkit.org/blog/363/styling-scrollbars/) pseudo class.
+    // https://webkit.org/blog/363/styling-scrollbars/
+    webkit_scrollbar: WebKitScrollbarPseudoClass,
+    /// An unknown pseudo class.
+    custom: struct {
+        /// The pseudo class name.
+        name: []const u8,
+
+        pub fn __generateEql() void {}
+        pub fn __generateDeepClone() void {}
+        pub fn __generateHash() void {}
+    },
+    /// An unknown functional pseudo class.
+    custom_function: struct {
+        /// The pseudo class name.
+        name: []const u8,
+        /// The arguments of the pseudo class function.
+        arguments: css.TokenList,
+
+        pub fn __generateEql() void {}
+        pub fn __generateDeepClone() void {}
+        pub fn __generateHash() void {}
+    },
+
+    pub fn isEquivalent(this: *const PseudoClass, other: *const PseudoClass) bool {
+        if (this.* == .fullscreen and other.* == .fullscreen) return true;
+        if (this.* == .any_link and other.* == .any_link) return true;
+        if (this.* == .read_only and other.* == .read_only) return true;
+        if (this.* == .read_write and other.* == .read_write) return true;
+        if (this.* == .placeholder_shown and other.* == .placeholder_shown) return true;
+        if (this.* == .autofill and other.* == .autofill) return true;
+        return this.eql(other);
+    }
+
+    pub fn toCss(this: *const PseudoClass, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        var s = ArrayList(u8){};
+        // PERF(alloc): I don't like making these little allocations
+        const writer = s.writer(dest.allocator);
+        const W2 = @TypeOf(writer);
+        const scratchbuf = std.ArrayList(u8).init(dest.allocator);
+        var printer = Printer(W2).new(dest.allocator, scratchbuf, writer, css.PrinterOptions{}, dest.import_records);
+        try serialize.serializePseudoClass(this, W2, &printer, null);
+        return dest.writeStr(s.items);
+    }
+
+    pub fn eql(lhs: *const PseudoClass, rhs: *const PseudoClass) bool {
+        return css.implementEql(PseudoClass, lhs, rhs);
+    }
+
+    pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+        return css.implementHash(@This(), this, hasher);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn getPrefix(this: *const PseudoClass) css.VendorPrefix {
+        return switch (this.*) {
+            inline .fullscreen, .any_link, .read_only, .read_write, .placeholder_shown, .autofill => |p| p,
+            else => css.VendorPrefix.empty(),
+        };
+    }
+
+    pub fn getNecessaryPrefixes(this: *PseudoClass, targets: css.targets.Targets) css.VendorPrefix {
+        const F = css.prefixes.Feature;
+        const p: *css.VendorPrefix, const feature: F = switch (this.*) {
+            .fullscreen => |*p| .{ p, F.pseudo_class_fullscreen },
+            .any_link => |*p| .{ p, F.pseudo_class_any_link },
+            .read_only => |*p| .{ p, F.pseudo_class_read_only },
+            .read_write => |*p| .{ p, F.pseudo_class_read_write },
+            .placeholder_shown => |*p| .{ p, F.pseudo_class_placeholder_shown },
+            .autofill => |*p| .{ p, F.pseudo_class_autofill },
+            else => return css.VendorPrefix.empty(),
+        };
+        p.* = targets.prefixes(p.*, feature);
+        return p.*;
+    }
+
+    pub fn isUserActionState(this: *const PseudoClass) bool {
+        return switch (this.*) {
+            .active, .hover, .focus, .focus_within, .focus_visible => true,
+            else => false,
+        };
+    }
+
+    pub fn isValidBeforeWebkitScrollbar(this: *const PseudoClass) bool {
+        return !switch (this.*) {
+            .webkit_scrollbar => true,
+            else => false,
+        };
+    }
+
+    pub fn isValidAfterWebkitScrollbar(this: *const PseudoClass) bool {
+        return switch (this.*) {
+            .webkit_scrollbar, .enabled, .disabled, .hover, .active => true,
+            else => false,
+        };
+    }
+};
+
+/// A [webkit scrollbar](https://webkit.org/blog/363/styling-scrollbars/) pseudo class.
+pub const WebKitScrollbarPseudoClass = enum {
+    /// :horizontal
+    horizontal,
+    /// :vertical
+    vertical,
+    /// :decrement
+    decrement,
+    /// :increment
+    increment,
+    /// :start
+    start,
+    /// :end
+    end,
+    /// :double-button
+    double_button,
+    /// :single-button
+    single_button,
+    /// :no-button
+    no_button,
+    /// :corner-present
+    corner_present,
+    /// :window-inactive
+    window_inactive,
+};
+
+/// A [webkit scrollbar](https://webkit.org/blog/363/styling-scrollbars/) pseudo element.
+pub const WebKitScrollbarPseudoElement = enum {
+    /// ::-webkit-scrollbar
+    scrollbar,
+    /// ::-webkit-scrollbar-button
+    button,
+    /// ::-webkit-scrollbar-track
+    track,
+    /// ::-webkit-scrollbar-track-piece
+    track_piece,
+    /// ::-webkit-scrollbar-thumb
+    thumb,
+    /// ::-webkit-scrollbar-corner
+    corner,
+    /// ::-webkit-resizer
+    resizer,
+
+    pub inline fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return lhs.* == rhs.*;
+    }
+};
+
+pub const SelectorParser = struct {
+    is_nesting_allowed: bool,
+    options: *const css.ParserOptions,
+    allocator: Allocator,
+
+    pub const Impl = impl.Selectors;
+
+    pub fn namespaceForPrefix(this: *SelectorParser, prefix: css.css_values.ident.Ident) ?[]const u8 {
+        _ = this; // autofix
+        return prefix.v;
+    }
+
+    pub fn parseFunctionalPseudoElement(this: *SelectorParser, name: []const u8, input: *css.Parser) Result(Impl.SelectorImpl.PseudoElement) {
+        _ = this; // autofix
+        _ = name; // autofix
+        _ = input; // autofix
+        @panic(css.todo_stuff.depth);
+    }
+
+    fn parseIsAndWhere(this: *const SelectorParser) bool {
+        _ = this; // autofix
+        return true;
+    }
+
+    /// Whether the given function name is an alias for the `:is()` function.
+    fn parseAnyPrefix(this: *const SelectorParser, name: []const u8) ?css.VendorPrefix {
+        _ = this; // autofix
+        _ = name; // autofix
+        return null;
+    }
+
+    pub fn parseNonTsPseudoClass(
+        this: *SelectorParser,
+        loc: css.SourceLocation,
+        name: []const u8,
+    ) Result(PseudoClass) {
+        // @compileError(css.todo_stuff.match_ignore_ascii_case);
+        const pseudo_class: PseudoClass = pseudo_class: {
+            if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "hover")) {
+                // https://drafts.csswg.org/selectors-4/#useraction-pseudos
+                break :pseudo_class .hover;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "active")) {
+                // https://drafts.csswg.org/selectors-4/#useraction-pseudos
+                break :pseudo_class .active;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "focus")) {
+                // https://drafts.csswg.org/selectors-4/#useraction-pseudos
+                break :pseudo_class .focus;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "focus-visible")) {
+                // https://drafts.csswg.org/selectors-4/#useraction-pseudos
+                break :pseudo_class .focus_visible;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "focus-within")) {
+                // https://drafts.csswg.org/selectors-4/#useraction-pseudos
+                break :pseudo_class .focus_within;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "current")) {
+                // https://drafts.csswg.org/selectors-4/#time-pseudos
+                break :pseudo_class .current;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "past")) {
+                // https://drafts.csswg.org/selectors-4/#time-pseudos
+                break :pseudo_class .past;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "future")) {
+                // https://drafts.csswg.org/selectors-4/#time-pseudos
+                break :pseudo_class .future;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "playing")) {
+                // https://drafts.csswg.org/selectors-4/#resource-pseudos
+                break :pseudo_class .playing;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "paused")) {
+                // https://drafts.csswg.org/selectors-4/#resource-pseudos
+                break :pseudo_class .paused;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "seeking")) {
+                // https://drafts.csswg.org/selectors-4/#resource-pseudos
+                break :pseudo_class .seeking;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "buffering")) {
+                // https://drafts.csswg.org/selectors-4/#resource-pseudos
+                break :pseudo_class .buffering;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "stalled")) {
+                // https://drafts.csswg.org/selectors-4/#resource-pseudos
+                break :pseudo_class .stalled;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "muted")) {
+                // https://drafts.csswg.org/selectors-4/#resource-pseudos
+                break :pseudo_class .muted;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "volume-locked")) {
+                // https://drafts.csswg.org/selectors-4/#resource-pseudos
+                break :pseudo_class .volume_locked;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "fullscreen")) {
+                // https://fullscreen.spec.whatwg.org/#:fullscreen-pseudo-class
+                break :pseudo_class .{ .fullscreen = css.VendorPrefix{ .none = true } };
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "-webkit-full-screen")) {
+                // https://fullscreen.spec.whatwg.org/#:fullscreen-pseudo-class
+                break :pseudo_class .{ .fullscreen = css.VendorPrefix{ .webkit = true } };
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "-moz-full-screen")) {
+                // https://fullscreen.spec.whatwg.org/#:fullscreen-pseudo-class
+                break :pseudo_class .{ .fullscreen = css.VendorPrefix{ .moz = true } };
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "-ms-fullscreen")) {
+                // https://fullscreen.spec.whatwg.org/#:fullscreen-pseudo-class
+                break :pseudo_class .{ .fullscreen = css.VendorPrefix{ .ms = true } };
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "open")) {
+                // https://drafts.csswg.org/selectors/#display-state-pseudos
+                break :pseudo_class .open;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "closed")) {
+                // https://drafts.csswg.org/selectors/#display-state-pseudos
+                break :pseudo_class .closed;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "modal")) {
+                // https://drafts.csswg.org/selectors/#display-state-pseudos
+                break :pseudo_class .modal;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "picture-in-picture")) {
+                // https://drafts.csswg.org/selectors/#display-state-pseudos
+                break :pseudo_class .picture_in_picture;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "popover-open")) {
+                // https://html.spec.whatwg.org/multipage/semantics-other.html#selector-popover-open
+                break :pseudo_class .popover_open;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "defined")) {
+                // https://drafts.csswg.org/selectors-4/#the-defined-pseudo
+                break :pseudo_class .defined;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "any-link")) {
+                // https://drafts.csswg.org/selectors-4/#location
+                break :pseudo_class .{ .any_link = css.VendorPrefix{ .none = true } };
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "-webkit-any-link")) {
+                // https://drafts.csswg.org/selectors-4/#location
+                break :pseudo_class .{ .any_link = css.VendorPrefix{ .webkit = true } };
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "-moz-any-link")) {
+                // https://drafts.csswg.org/selectors-4/#location
+                break :pseudo_class .{ .any_link = css.VendorPrefix{ .moz = true } };
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "link")) {
+                // https://drafts.csswg.org/selectors-4/#location
+                break :pseudo_class .link;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "local-link")) {
+                // https://drafts.csswg.org/selectors-4/#location
+                break :pseudo_class .local_link;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "target")) {
+                // https://drafts.csswg.org/selectors-4/#location
+                break :pseudo_class .target;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "target-within")) {
+                // https://drafts.csswg.org/selectors-4/#location
+                break :pseudo_class .target_within;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "visited")) {
+                // https://drafts.csswg.org/selectors-4/#location
+                break :pseudo_class .visited;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "enabled")) {
+                // https://drafts.csswg.org/selectors-4/#input-pseudos
+                break :pseudo_class .enabled;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "disabled")) {
+                // https://drafts.csswg.org/selectors-4/#input-pseudos
+                break :pseudo_class .disabled;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "read-only")) {
+                // https://drafts.csswg.org/selectors-4/#input-pseudos
+                break :pseudo_class .{ .read_only = css.VendorPrefix{ .none = true } };
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "-moz-read-only")) {
+                // https://drafts.csswg.org/selectors-4/#input-pseudos
+                break :pseudo_class .{ .read_only = css.VendorPrefix{ .moz = true } };
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "read-write")) {
+                // https://drafts.csswg.org/selectors-4/#input-pseudos
+                break :pseudo_class .{ .read_write = css.VendorPrefix{ .none = true } };
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "-moz-read-write")) {
+                // https://drafts.csswg.org/selectors-4/#input-pseudos
+                break :pseudo_class .{ .read_write = css.VendorPrefix{ .moz = true } };
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "placeholder-shown")) {
+                // https://drafts.csswg.org/selectors-4/#input-pseudos
+                break :pseudo_class .{ .placeholder_shown = css.VendorPrefix{ .none = true } };
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "-moz-placeholder-shown")) {
+                // https://drafts.csswg.org/selectors-4/#input-pseudos
+                break :pseudo_class .{ .placeholder_shown = css.VendorPrefix{ .moz = true } };
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "-ms-placeholder-shown")) {
+                // https://drafts.csswg.org/selectors-4/#input-pseudos
+                break :pseudo_class .{ .placeholder_shown = css.VendorPrefix{ .ms = true } };
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "default")) {
+                // https://drafts.csswg.org/selectors-4/#input-pseudos
+                break :pseudo_class .default;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "checked")) {
+                // https://drafts.csswg.org/selectors-4/#input-pseudos
+                break :pseudo_class .checked;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "indeterminate")) {
+                // https://drafts.csswg.org/selectors-4/#input-pseudos
+                break :pseudo_class .indeterminate;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "blank")) {
+                // https://drafts.csswg.org/selectors-4/#input-pseudos
+                break :pseudo_class .blank;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "valid")) {
+                // https://drafts.csswg.org/selectors-4/#input-pseudos
+                break :pseudo_class .valid;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "invalid")) {
+                // https://drafts.csswg.org/selectors-4/#input-pseudos
+                break :pseudo_class .invalid;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "in-range")) {
+                // https://drafts.csswg.org/selectors-4/#input-pseudos
+                break :pseudo_class .in_range;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "out-of-range")) {
+                // https://drafts.csswg.org/selectors-4/#input-pseudos
+                break :pseudo_class .out_of_range;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "required")) {
+                // https://drafts.csswg.org/selectors-4/#input-pseudos
+                break :pseudo_class .required;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "optional")) {
+                // https://drafts.csswg.org/selectors-4/#input-pseudos
+                break :pseudo_class .optional;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "user-valid")) {
+                // https://drafts.csswg.org/selectors-4/#input-pseudos
+                break :pseudo_class .user_valid;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "user-invalid")) {
+                // https://drafts.csswg.org/selectors-4/#input-pseudos
+                break :pseudo_class .user_invalid;
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "autofill")) {
+                // https://html.spec.whatwg.org/multipage/semantics-other.html#selector-autofill
+                break :pseudo_class .{ .autofill = css.VendorPrefix{ .none = true } };
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "-webkit-autofill")) {
+                // https://html.spec.whatwg.org/multipage/semantics-other.html#selector-autofill
+                break :pseudo_class .{ .autofill = css.VendorPrefix{ .webkit = true } };
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "-o-autofill")) {
+                // https://html.spec.whatwg.org/multipage/semantics-other.html#selector-autofill
+                break :pseudo_class .{ .autofill = css.VendorPrefix{ .o = true } };
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "horizontal")) {
+                // https://webkit.org/blog/363/styling-scrollbars/
+                break :pseudo_class .{ .webkit_scrollbar = .horizontal };
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "vertical")) {
+                // https://webkit.org/blog/363/styling-scrollbars/
+                break :pseudo_class .{ .webkit_scrollbar = .vertical };
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "decrement")) {
+                // https://webkit.org/blog/363/styling-scrollbars/
+                break :pseudo_class .{ .webkit_scrollbar = .decrement };
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "increment")) {
+                // https://webkit.org/blog/363/styling-scrollbars/
+                break :pseudo_class .{ .webkit_scrollbar = .increment };
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "start")) {
+                // https://webkit.org/blog/363/styling-scrollbars/
+                break :pseudo_class .{ .webkit_scrollbar = .start };
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "end")) {
+                // https://webkit.org/blog/363/styling-scrollbars/
+                break :pseudo_class .{ .webkit_scrollbar = .end };
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "double-button")) {
+                // https://webkit.org/blog/363/styling-scrollbars/
+                break :pseudo_class .{ .webkit_scrollbar = .double_button };
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "single-button")) {
+                // https://webkit.org/blog/363/styling-scrollbars/
+                break :pseudo_class .{ .webkit_scrollbar = .single_button };
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "no-button")) {
+                // https://webkit.org/blog/363/styling-scrollbars/
+                break :pseudo_class .{ .webkit_scrollbar = .no_button };
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "corner-present")) {
+                // https://webkit.org/blog/363/styling-scrollbars/
+                break :pseudo_class .{ .webkit_scrollbar = .corner_present };
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "window-inactive")) {
+                // https://webkit.org/blog/363/styling-scrollbars/
+                break :pseudo_class .{ .webkit_scrollbar = .window_inactive };
+            } else {
+                if (bun.strings.startsWithChar(name, '_')) {
+                    this.options.warn(loc.newCustomError(SelectorParseErrorKind{ .unsupported_pseudo_class_or_element = name }));
+                }
+                return .{ .result = PseudoClass{ .custom = .{ .name = name } } };
+            }
+        };
+
+        return .{ .result = pseudo_class };
+    }
+
+    pub fn parseNonTsFunctionalPseudoClass(
+        this: *SelectorParser,
+        name: []const u8,
+        parser: *css.Parser,
+    ) Result(PseudoClass) {
+
+        // todo_stuff.match_ignore_ascii_case
+        const pseudo_class = pseudo_class: {
+            if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "lang")) {
+                const languages = switch (parser.parseCommaSeparated([]const u8, css.Parser.expectIdentOrString)) {
+                    .err => |e| return .{ .err = e },
+                    .result => |v| v,
+                };
+                return .{ .result = PseudoClass{
+                    .lang = .{ .languages = languages },
+                } };
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "dir")) {
+                break :pseudo_class PseudoClass{
+                    .dir = .{
+                        .direction = switch (Direction.parse(parser)) {
+                            .err => |e| return .{ .err = e },
+                            .result => |v| v,
+                        },
+                    },
+                };
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "local") and this.options.css_modules != null) {
+                break :pseudo_class PseudoClass{
+                    .local = .{
+                        .selector = brk: {
+                            const selector = switch (Selector.parse(this, parser)) {
+                                .err => |e| return .{ .err = e },
+                                .result => |v| v,
+                            };
+
+                            break :brk bun.create(this.allocator, Selector, selector);
+                        },
+                    },
+                };
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "global") and this.options.css_modules != null) {
+                break :pseudo_class PseudoClass{
+                    .global = .{
+                        .selector = brk: {
+                            const selector = switch (Selector.parse(this, parser)) {
+                                .err => |e| return .{ .err = e },
+                                .result => |v| v,
+                            };
+
+                            break :brk bun.create(this.allocator, Selector, selector);
+                        },
+                    },
+                };
+            } else {
+                if (!bun.strings.startsWithChar(name, '-')) {
+                    this.options.warn(parser.newCustomError(SelectorParseErrorKind.intoDefaultParserError(.{ .unsupported_pseudo_class_or_element = name })));
+                }
+                var args = ArrayList(css.css_properties.custom.TokenOrValue){};
+                _ = switch (css.TokenListFns.parseRaw(parser, &args, this.options, 0)) {
+                    .err => |e| return .{ .err = e },
+                    .result => |v| v,
+                };
+                break :pseudo_class PseudoClass{
+                    .custom_function = .{
+                        .name = name,
+                        .arguments = css.TokenList{ .v = args },
+                    },
+                };
+            }
+        };
+
+        return .{ .result = pseudo_class };
+    }
+
+    pub fn isNestingAllowed(this: *SelectorParser) bool {
+        return this.is_nesting_allowed;
+    }
+
+    pub fn deepCombinatorEnabled(this: *SelectorParser) bool {
+        return this.options.flags.contains(css.ParserFlags{ .deep_selector_combinator = true });
+    }
+
+    pub fn defaultNamespace(this: *SelectorParser) ?impl.Selectors.SelectorImpl.NamespaceUrl {
+        _ = this; // autofix
+        return null;
+    }
+
+    pub fn parsePart(this: *SelectorParser) bool {
+        _ = this; // autofix
+        return true;
+    }
+
+    pub fn parseSlotted(this: *SelectorParser) bool {
+        _ = this; // autofix
+        return true;
+    }
+
+    /// The error recovery that selector lists inside :is() and :where() have.
+    fn isAndWhereErrorRecovery(this: *SelectorParser) ParseErrorRecovery {
+        _ = this; // autofix
+        return .ignore_invalid_selector;
+    }
+
+    pub fn parsePseudoElement(this: *SelectorParser, loc: css.SourceLocation, name: []const u8) Result(PseudoElement) {
+        const Map = comptime bun.ComptimeStringMap(PseudoElement, .{
+            .{ "before", PseudoElement.before },
+            .{ "after", PseudoElement.after },
+            .{ "first-line", PseudoElement.first_line },
+            .{ "first-letter", PseudoElement.first_letter },
+            .{ "cue", PseudoElement.cue },
+            .{ "cue-region", PseudoElement.cue_region },
+            .{ "selection", PseudoElement{ .selection = css.VendorPrefix{ .none = true } } },
+            .{ "-moz-selection", PseudoElement{ .selection = css.VendorPrefix{ .moz = true } } },
+            .{ "placeholder", PseudoElement{ .placeholder = css.VendorPrefix{ .none = true } } },
+            .{ "-webkit-input-placeholder", PseudoElement{ .placeholder = css.VendorPrefix{ .webkit = true } } },
+            .{ "-moz-placeholder", PseudoElement{ .placeholder = css.VendorPrefix{ .moz = true } } },
+            .{ "-ms-input-placeholder", PseudoElement{ .placeholder = css.VendorPrefix{ .ms = true } } },
+            .{ "marker", PseudoElement.marker },
+            .{ "backdrop", PseudoElement{ .backdrop = css.VendorPrefix{ .none = true } } },
+            .{ "-webkit-backdrop", PseudoElement{ .backdrop = css.VendorPrefix{ .webkit = true } } },
+            .{ "file-selector-button", PseudoElement{ .file_selector_button = css.VendorPrefix{ .none = true } } },
+            .{ "-webkit-file-upload-button", PseudoElement{ .file_selector_button = css.VendorPrefix{ .webkit = true } } },
+            .{ "-ms-browse", PseudoElement{ .file_selector_button = css.VendorPrefix{ .ms = true } } },
+            .{ "-webkit-scrollbar", PseudoElement{ .webkit_scrollbar = .scrollbar } },
+            .{ "-webkit-scrollbar-button", PseudoElement{ .webkit_scrollbar = .button } },
+            .{ "-webkit-scrollbar-track", PseudoElement{ .webkit_scrollbar = .track } },
+            .{ "-webkit-scrollbar-track-piece", PseudoElement{ .webkit_scrollbar = .track_piece } },
+            .{ "-webkit-scrollbar-thumb", PseudoElement{ .webkit_scrollbar = .thumb } },
+            .{ "-webkit-scrollbar-corner", PseudoElement{ .webkit_scrollbar = .corner } },
+            .{ "-webkit-resizer", PseudoElement{ .webkit_scrollbar = .resizer } },
+            .{ "view-transition", PseudoElement.view_transition },
+        });
+
+        const pseudo_element = Map.getCaseInsensitiveWithEql(name, bun.strings.eqlComptimeIgnoreLen) orelse brk: {
+            if (!bun.strings.startsWithChar(name, '-')) {
+                this.options.warn(loc.newCustomError(SelectorParseErrorKind{ .unsupported_pseudo_class_or_element = name }));
+            }
+            break :brk PseudoElement{ .custom = .{ .name = name } };
+        };
+
+        return .{ .result = pseudo_element };
+    }
+};
+
+pub fn GenericSelectorList(comptime Impl: type) type {
+    ValidSelectorImpl(Impl);
+
+    const SelectorT = GenericSelector(Impl);
+    return struct {
+        // PERF: make this equivalent to SmallVec<[Selector; 1]>
+        v: css.SmallList(SelectorT, 1) = .{},
+
+        const This = @This();
+
+        const DebugFmt = struct {
+            this: *const This,
+
+            pub fn format(this: @This(), comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
+                if (comptime !bun.Environment.isDebug) return;
+                _ = fmt; // autofix
+                _ = options; // autofix
+                try writer.print("SelectorList[\n", .{});
+                const last = this.this.v.len() -| 1;
+                for (this.this.v.slice(), 0..) |*sel, i| {
+                    if (i != last) {
+                        try writer.print(" {}\n", .{sel.debug()});
+                    } else {
+                        try writer.print(" {},\n", .{sel.debug()});
+                    }
+                }
+                try writer.print("]\n", .{});
+            }
+        };
+
+        pub fn debug(this: *const @This()) DebugFmt {
+            return DebugFmt{ .this = this };
+        }
+
+        pub fn anyHasPseudoElement(this: *const This) bool {
+            for (this.v.slice()) |*sel| {
+                if (sel.hasPseudoElement()) return true;
+            }
+            return false;
+        }
+
+        pub fn specifitiesAllEqual(this: *const This) bool {
+            if (this.v.len() == 0) return true;
+            if (this.v.len() == 1) return true;
+
+            const value = this.v.at(0).specifity();
+            for (this.v.slice()[1..]) |*sel| {
+                if (sel.specifity() != value) return false;
+            }
+            return true;
+        }
+
+        pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+            _ = this; // autofix
+            _ = dest; // autofix
+            @compileError("Do not call this! Use `serializer.serializeSelectorList()` or `tocss_servo.toCss_SelectorList()` instead.");
+        }
+
+        pub fn parseWithOptions(input: *css.Parser, options: *const css.ParserOptions) Result(This) {
+            var parser = SelectorParser{
+                .options = options,
+                .is_nesting_allowed = true,
+            };
+            return parse(&parser, input, .discard_list, .none);
+        }
+
+        pub fn parse(
+            parser: *SelectorParser,
+            input: *css.Parser,
+            error_recovery: ParseErrorRecovery,
+            nesting_requirement: NestingRequirement,
+        ) Result(This) {
+            var state = SelectorParsingState.empty();
+            return parseWithState(parser, input, &state, error_recovery, nesting_requirement);
+        }
+
+        pub fn parseRelative(
+            parser: *SelectorParser,
+            input: *css.Parser,
+            error_recovery: ParseErrorRecovery,
+            nesting_requirement: NestingRequirement,
+        ) Result(This) {
+            var state = SelectorParsingState.empty();
+            return parseRelativeWithState(parser, input, &state, error_recovery, nesting_requirement);
+        }
+
+        pub fn parseWithState(
+            parser: *SelectorParser,
+            input: *css.Parser,
+            state: *SelectorParsingState,
+            recovery: ParseErrorRecovery,
+            nesting_requirement: NestingRequirement,
+        ) Result(This) {
+            const original_state = state.*;
+            // TODO: Think about deinitialization in error cases
+            var values = SmallList(SelectorT, 1){};
+
+            while (true) {
+                const Closure = struct {
+                    outer_state: *SelectorParsingState,
+                    original_state: SelectorParsingState,
+                    nesting_requirement: NestingRequirement,
+                    parser: *SelectorParser,
+
+                    pub fn parsefn(this: *@This(), input2: *css.Parser) Result(SelectorT) {
+                        var selector_state = this.original_state;
+                        const result = parse_selector(Impl, this.parser, input2, &selector_state, this.nesting_requirement);
+                        if (selector_state.after_nesting) {
+                            this.outer_state.after_nesting = true;
+                        }
+                        return result;
+                    }
+                };
+                var closure = Closure{
+                    .outer_state = state,
+                    .original_state = original_state,
+                    .nesting_requirement = nesting_requirement,
+                    .parser = parser,
+                };
+                const selector = input.parseUntilBefore(css.Delimiters{ .comma = true }, SelectorT, &closure, Closure.parsefn);
+
+                const was_ok = selector.isOk();
+                switch (selector) {
+                    .result => |sel| {
+                        values.append(input.allocator(), sel);
+                    },
+                    .err => |e| {
+                        switch (recovery) {
+                            .discard_list => return .{ .err = e },
+                            .ignore_invalid_selector => {},
+                        }
+                    },
+                }
+
+                while (true) {
+                    if (input.next().asValue()) |tok| {
+                        if (tok.* == .comma) break;
+                        // Shouldn't have got a selector if getting here.
+                        bun.debugAssert(!was_ok);
+                    }
+                    return .{ .result = .{ .v = values } };
+                }
+            }
+        }
+
+        // TODO: this looks exactly the same as `parseWithState()` except it uses `parse_relative_selector()` instead of `parse_selector()`
+        pub fn parseRelativeWithState(
+            parser: *SelectorParser,
+            input: *css.Parser,
+            state: *SelectorParsingState,
+            recovery: ParseErrorRecovery,
+            nesting_requirement: NestingRequirement,
+        ) Result(This) {
+            const original_state = state.*;
+            // TODO: Think about deinitialization in error cases
+            var values = SmallList(SelectorT, 1){};
+
+            while (true) {
+                const Closure = struct {
+                    outer_state: *SelectorParsingState,
+                    original_state: SelectorParsingState,
+                    nesting_requirement: NestingRequirement,
+                    parser: *SelectorParser,
+
+                    pub fn parsefn(this: *@This(), input2: *css.Parser) Result(SelectorT) {
+                        var selector_state = this.original_state;
+                        const result = parse_relative_selector(Impl, this.parser, input2, &selector_state, this.nesting_requirement);
+                        if (selector_state.after_nesting) {
+                            this.outer_state.after_nesting = true;
+                        }
+                        return result;
+                    }
+                };
+                var closure = Closure{
+                    .outer_state = state,
+                    .original_state = original_state,
+                    .nesting_requirement = nesting_requirement,
+                    .parser = parser,
+                };
+                const selector = input.parseUntilBefore(css.Delimiters{ .comma = true }, SelectorT, &closure, Closure.parsefn);
+
+                const was_ok = selector.isOk();
+                switch (selector) {
+                    .result => |sel| {
+                        values.append(input.allocator(), sel);
+                    },
+                    .err => |e| {
+                        switch (recovery) {
+                            .discard_list => return .{ .err = e },
+                            .ignore_invalid_selector => {},
+                        }
+                    },
+                }
+
+                while (true) {
+                    if (input.next().asValue()) |tok| {
+                        if (tok.* == .comma) break;
+                        // Shouldn't have got a selector if getting here.
+                        bun.debugAssert(!was_ok);
+                    }
+                    return .{ .result = .{ .v = values } };
+                }
+            }
+        }
+
+        pub fn fromSelector(allocator: Allocator, selector: GenericSelector(Impl)) This {
+            var result = This{};
+            result.v.append(allocator, selector);
+            return result;
+        }
+
+        pub fn deepClone(this: *const @This(), allocator: Allocator) This {
+            return .{ .v = this.v.deepClone(allocator) };
+        }
+
+        pub fn eql(lhs: *const This, rhs: *const This) bool {
+            return lhs.v.eql(&rhs.v);
+        }
+
+        pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+            return css.implementHash(@This(), this, hasher);
+        }
+    };
+}
+
+/// -- original comment from servo --
+/// A Selector stores a sequence of simple selectors and combinators. The
+/// iterator classes allow callers to iterate at either the raw sequence level or
+/// at the level of sequences of simple selectors separated by combinators. Most
+/// callers want the higher-level iterator.
+///
+/// We store compound selectors internally right-to-left (in matching order).
+/// Additionally, we invert the order of top-level compound selectors so that
+/// each one matches left-to-right. This is because matching namespace, local name,
+/// id, and class are all relatively cheap, whereas matching pseudo-classes might
+/// be expensive (depending on the pseudo-class). Since authors tend to put the
+/// pseudo-classes on the right, it's faster to start matching on the left.
+///
+/// This reordering doesn't change the semantics of selector matching, and we
+/// handle it in to_css to make it invisible to serialization.
+pub fn GenericSelector(comptime Impl: type) type {
+    ValidSelectorImpl(Impl);
+
+    return struct {
+        specifity_and_flags: SpecifityAndFlags,
+        components: ArrayList(GenericComponent(Impl)),
+
+        const This = @This();
+
+        const DebugFmt = struct {
+            this: *const This,
+
+            pub fn format(this: @This(), comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
+                if (comptime !bun.Environment.isDebug) return;
+                _ = fmt; // autofix
+                _ = options; // autofix
+                try writer.print("Selector(", .{});
+                var arraylist = ArrayList(u8){};
+                const w = arraylist.writer(bun.default_allocator);
+                defer arraylist.deinit(bun.default_allocator);
+                var printer = css.Printer(@TypeOf(w)).new(bun.default_allocator, std.ArrayList(u8).init(bun.default_allocator), w, .{}, null);
+                defer printer.deinit();
+                css.selector.tocss_servo.toCss_Selector(this.this, @TypeOf(w), &printer) catch |e| return try writer.print("<error writing selector: {s}>\n", .{@errorName(e)});
+                try writer.writeAll(arraylist.items);
+            }
+        };
+
+        pub fn debug(this: *const This) DebugFmt {
+            return DebugFmt{ .this = this };
+        }
+
+        /// Parse a selector, without any pseudo-element.
+        pub fn parse(parser: *SelectorParser, input: *css.Parser) Result(This) {
+            var state = SelectorParsingState.empty();
+            return parse_selector(Impl, parser, input, &state, .none);
+        }
+
+        pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+            _ = this; // autofix
+            _ = dest; // autofix
+            @compileError("Do not call this! Use `serializer.serializeSelector()` or `tocss_servo.toCss_Selector()` instead.");
+        }
+
+        pub fn append(this: *This, allocator: Allocator, component: GenericComponent(Impl)) void {
+            const index = index: {
+                for (this.components.items, 0..) |*comp, i| {
+                    switch (comp.*) {
+                        .combinator, .pseudo_element => break :index i,
+                        else => {},
+                    }
+                }
+                break :index this.components.items.len;
+            };
+            this.components.insert(allocator, index, component) catch bun.outOfMemory();
+        }
+
+        pub fn deepClone(this: *const @This(), allocator: Allocator) This {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+
+        pub fn eql(this: *const This, other: *const This) bool {
+            return css.implementEql(This, this, other);
+        }
+
+        pub fn hasCombinator(this: *const This) bool {
+            for (this.components.items) |*c| {
+                if (c.* == .combinator and c.combinator.isTreeCombinator()) return true;
+            }
+            return false;
+        }
+
+        pub fn hasPseudoElement(this: *const This) bool {
+            return this.specifity_and_flags.hasPseudoElement();
+        }
+
+        /// Returns count of simple selectors and combinators in the Selector.
+        pub fn len(this: *const This) usize {
+            return this.components.items.len;
+        }
+
+        pub fn fromComponent(allocator: Allocator, component: GenericComponent(Impl)) This {
+            var builder = SelectorBuilder(Impl).init(allocator);
+            if (component.asCombinator()) |combinator| {
+                builder.pushCombinator(combinator);
+            } else {
+                builder.pushSimpleSelector(component);
+            }
+            const result = builder.build(false, false, false);
+            return This{
+                .specifity_and_flags = result.specifity_and_flags,
+                .components = result.components,
+            };
+        }
+
+        pub fn specifity(this: *const This) u32 {
+            return this.specifity_and_flags.specificity;
+        }
+
+        pub fn parseWithOptions(input: *css.Parser, options: *const css.ParserOptions) Result(This) {
+            var selector_parser = SelectorParser{
+                .is_nesting_allowed = true,
+                .options = options,
+            };
+            return parse(&selector_parser, input);
+        }
+
+        /// Returns an iterator over the sequence of simple selectors and
+        /// combinators, in parse order (from left to right), starting from
+        /// `offset`.
+        pub fn iterRawParseOrderFrom(this: *const This, offset: usize) RawParseOrderFromIter {
+            return RawParseOrderFromIter{
+                .slice = this.components.items[0 .. this.components.items.len - offset],
+            };
+        }
+
+        const RawParseOrderFromIter = struct {
+            slice: []const GenericComponent(Impl),
+            i: usize = 0,
+
+            pub fn next(this: *@This()) ?GenericComponent(Impl) {
+                if (!(this.i < this.slice.len)) return null;
+                const result = this.slice[this.slice.len - 1 - this.i];
+                this.i += 1;
+                return result;
+            }
+        };
+
+        pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+            return css.implementHash(@This(), this, hasher);
+        }
+    };
+}
+
+/// A CSS simple selector or combinator. We store both in the same enum for
+/// optimal packing and cache performance, see [1].
+///
+/// [1] https://bugzilla.mozilla.org/show_bug.cgi?id=1357973
+pub fn GenericComponent(comptime Impl: type) type {
+    ValidSelectorImpl(Impl);
+
+    return union(enum) {
+        combinator: Combinator,
+
+        explicit_any_namespace,
+        explicit_no_namespace,
+        default_namespace: Impl.SelectorImpl.NamespaceUrl,
+        namespace: struct {
+            prefix: Impl.SelectorImpl.NamespacePrefix,
+            url: Impl.SelectorImpl.NamespaceUrl,
+
+            pub fn __generateEql() void {}
+            pub fn __generateDeepClone() void {}
+            pub fn __generateHash() void {}
+        },
+
+        explicit_universal_type,
+        local_name: LocalName(Impl),
+
+        id: Impl.SelectorImpl.Identifier,
+        class: Impl.SelectorImpl.Identifier,
+
+        attribute_in_no_namespace_exists: struct {
+            local_name: Impl.SelectorImpl.LocalName,
+            local_name_lower: Impl.SelectorImpl.LocalName,
+
+            pub fn __generateEql() void {}
+            pub fn __generateDeepClone() void {}
+            pub fn __generateHash() void {}
+        },
+        /// Used only when local_name is already lowercase.
+        attribute_in_no_namespace: struct {
+            local_name: Impl.SelectorImpl.LocalName,
+            operator: attrs.AttrSelectorOperator,
+            value: Impl.SelectorImpl.AttrValue,
+            case_sensitivity: attrs.ParsedCaseSensitivity,
+            never_matches: bool,
+
+            pub fn __generateEql() void {}
+            pub fn __generateDeepClone() void {}
+            pub fn __generateHash() void {}
+        },
+        /// Use a Box in the less common cases with more data to keep size_of::<Component>() small.
+        attribute_other: *attrs.AttrSelectorWithOptionalNamespace(Impl),
+
+        /// Pseudo-classes
+        negation: []GenericSelector(Impl),
+        root,
+        empty,
+        scope,
+        nth: NthSelectorData,
+        nth_of: NthOfSelectorData(Impl),
+        non_ts_pseudo_class: Impl.SelectorImpl.NonTSPseudoClass,
+        /// The ::slotted() pseudo-element:
+        ///
+        /// https://drafts.csswg.org/css-scoping/#slotted-pseudo
+        ///
+        /// The selector here is a compound selector, that is, no combinators.
+        ///
+        /// NOTE(emilio): This should support a list of selectors, but as of this
+        /// writing no other browser does, and that allows them to put ::slotted()
+        /// in the rule hash, so we do that too.
+        ///
+        /// See https://github.com/w3c/csswg-drafts/issues/2158
+        slotted: GenericSelector(Impl),
+        /// The `::part` pseudo-element.
+        ///   https://drafts.csswg.org/css-shadow-parts/#part
+        part: []Impl.SelectorImpl.Identifier,
+        /// The `:host` pseudo-class:
+        ///
+        /// https://drafts.csswg.org/css-scoping/#host-selector
+        ///
+        /// NOTE(emilio): This should support a list of selectors, but as of this
+        /// writing no other browser does, and that allows them to put :host()
+        /// in the rule hash, so we do that too.
+        ///
+        /// See https://github.com/w3c/csswg-drafts/issues/2158
+        host: ?GenericSelector(Impl),
+        /// The `:where` pseudo-class.
+        ///
+        /// https://drafts.csswg.org/selectors/#zero-matches
+        ///
+        /// The inner argument is conceptually a SelectorList, but we move the
+        /// selectors to the heap to keep Component small.
+        where: []GenericSelector(Impl),
+        /// The `:is` pseudo-class.
+        ///
+        /// https://drafts.csswg.org/selectors/#matches-pseudo
+        ///
+        /// Same comment as above re. the argument.
+        is: []GenericSelector(Impl),
+        any: struct {
+            vendor_prefix: Impl.SelectorImpl.VendorPrefix,
+            selectors: []GenericSelector(Impl),
+
+            pub fn __generateEql() void {}
+            pub fn __generateDeepClone() void {}
+            pub fn __generateHash() void {}
+        },
+        /// The `:has` pseudo-class.
+        ///
+        /// https://www.w3.org/TR/selectors/#relational
+        has: []GenericSelector(Impl),
+        /// An implementation-dependent pseudo-element selector.
+        pseudo_element: Impl.SelectorImpl.PseudoElement,
+        /// A nesting selector:
+        ///
+        /// https://drafts.csswg.org/css-nesting-1/#nest-selector
+        ///
+        /// NOTE: This is a lightningcss addition.
+        nesting,
+
+        const This = @This();
+
+        pub fn deepClone(this: *const @This(), allocator: Allocator) @This() {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+
+        pub fn eql(lhs: *const This, rhs: *const This) bool {
+            return css.implementEql(This, lhs, rhs);
+        }
+
+        pub fn format(this: *const This, comptime _: []const u8, _: std.fmt.FormatOptions, writer: anytype) !void {
+            switch (this.*) {
+                .local_name => return try writer.print("local_name={s}", .{this.local_name.name.v}),
+                .combinator => return try writer.print("combinator={}", .{this.combinator}),
+                .pseudo_element => return try writer.print("pseudo_element={}", .{this.pseudo_element}),
+                else => {},
+            }
+            return writer.print("{s}", .{@tagName(this.*)});
+        }
+
+        pub fn asCombinator(this: *const This) ?Combinator {
+            if (this.* == .combinator) return this.combinator;
+            return null;
+        }
+
+        pub fn convertHelper_is(s: []GenericSelector(Impl)) This {
+            return .{ .is = s };
+        }
+
+        pub fn convertHelper_where(s: []GenericSelector(Impl)) This {
+            return .{ .where = s };
+        }
+
+        pub fn convertHelper_any(s: []GenericSelector(Impl), prefix: Impl.SelectorImpl.VendorPrefix) This {
+            return .{
+                .any = .{
+                    .vendor_prefix = prefix,
+                    .selectors = s,
+                },
+            };
+        }
+
+        /// Returns true if this is a combinator.
+        pub fn isCombinator(this: *const This) bool {
+            return this.* == .combinator;
+        }
+
+        pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+            _ = this; // autofix
+            _ = dest; // autofix
+            @compileError("Do not call this! Use `serializer.serializeComponent()` or `tocss_servo.toCss_Component()` instead.");
+        }
+
+        pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+            return css.implementHash(@This(), this, hasher);
+        }
+    };
+}
+
+/// The properties that comprise an :nth- pseudoclass as of Selectors 3 (e.g.,
+/// nth-child(An+B)).
+/// https://www.w3.org/TR/selectors-3/#nth-child-pseudo
+pub const NthSelectorData = struct {
+    ty: NthType,
+    is_function: bool,
+    a: i32,
+    b: i32,
+
+    /// Returns selector data for :only-{child,of-type}
+    pub fn only(of_type: bool) NthSelectorData {
+        return NthSelectorData{
+            .ty = if (of_type) NthType.only_of_type else NthType.only_child,
+            .is_function = false,
+            .a = 0,
+            .b = 1,
+        };
+    }
+
+    /// Returns selector data for :first-{child,of-type}
+    pub fn first(of_type: bool) NthSelectorData {
+        return NthSelectorData{
+            .ty = if (of_type) NthType.of_type else NthType.child,
+            .is_function = false,
+            .a = 0,
+            .b = 1,
+        };
+    }
+
+    /// Returns selector data for :last-{child,of-type}
+    pub fn last(of_type: bool) NthSelectorData {
+        return NthSelectorData{
+            .ty = if (of_type) NthType.last_of_type else NthType.last_child,
+            .is_function = false,
+            .a = 0,
+            .b = 1,
+        };
+    }
+
+    pub fn writeStart(this: *const @This(), comptime W: type, dest: *Printer(W), is_function: bool) PrintErr!void {
+        try dest.writeStr(switch (this.ty) {
+            .child => if (is_function) ":nth-child(" else ":first-child",
+            .last_child => if (is_function) ":nth-last-child(" else ":last-child",
+            .of_type => if (is_function) ":nth-of-type(" else ":first-of-type",
+            .last_of_type => if (is_function) ":nth-last-of-type(" else ":last-of-type",
+            .only_child => if (is_function) ":nth-only-child(" else ":only-of-type",
+            .only_of_type => ":only-of-type",
+            .col => ":nth-col(",
+            .last_col => ":nth-last-col(",
+        });
+    }
+
+    pub fn isFunction(this: *const @This()) bool {
+        return this.a != 0 or this.b != 1;
+    }
+
+    fn numberSign(num: i32) []const u8 {
+        if (num >= 0) return "+";
+        return "-";
+    }
+
+    pub fn writeAffine(this: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+        // PERF: this could be made faster
+        if (this.a == 0 and this.b == 0) {
+            try dest.writeChar('0');
+        } else if (this.a == 1 and this.b == 0) {
+            try dest.writeChar('n');
+        } else if (this.a == -1 and this.b == 0) {
+            try dest.writeStr("-n");
+        } else if (this.b == 0) {
+            try dest.writeFmt("{d}n", .{this.a});
+        } else if (this.a == 2 and this.b == 1) {
+            try dest.writeStr("odd");
+        } else if (this.a == 0) {
+            try dest.writeFmt("{d}", .{this.b});
+        } else if (this.a == 1) {
+            try dest.writeFmt("n{s}{d}", .{ numberSign(this.b), this.b });
+        } else if (this.a == -1) {
+            try dest.writeFmt("-n{s}{d}", .{ numberSign(this.b), this.b });
+        } else {
+            try dest.writeFmt("{}n{s}{d}", .{ this.a, numberSign(this.b), this.b });
+        }
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+        return css.implementHash(@This(), this, hasher);
+    }
+};
+
+/// The properties that comprise an :nth- pseudoclass as of Selectors 4 (e.g.,
+/// nth-child(An+B [of S]?)).
+/// https://www.w3.org/TR/selectors-4/#nth-child-pseudo
+pub fn NthOfSelectorData(comptime Impl: type) type {
+    return struct {
+        data: NthSelectorData,
+        selectors: []GenericSelector(Impl),
+
+        pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+            return css.implementEql(@This(), lhs, rhs);
+        }
+
+        pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+            return css.implementHash(@This(), this, hasher);
+        }
+
+        pub fn deepClone(this: *const @This(), allocator: Allocator) @This() {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+
+        pub fn nthData(this: *const @This()) NthSelectorData {
+            return this.data;
+        }
+
+        pub fn selectors(this: *const @This()) []GenericSelector(Impl) {
+            return this.selectors;
+        }
+    };
+}
+
+pub const SelectorParsingState = packed struct(u16) {
+    /// Whether we should avoid adding default namespaces to selectors that
+    /// aren't type or universal selectors.
+    skip_default_namespace: bool = false,
+
+    /// Whether we've parsed a ::slotted() pseudo-element already.
+    ///
+    /// If so, then we can only parse a subset of pseudo-elements, and
+    /// whatever comes after them if so.
+    after_slotted: bool = false,
+
+    /// Whether we've parsed a ::part() pseudo-element already.
+    ///
+    /// If so, then we can only parse a subset of pseudo-elements, and
+    /// whatever comes after them if so.
+    after_part: bool = false,
+
+    /// Whether we've parsed a pseudo-element (as in, an
+    /// `Impl::PseudoElement` thus not accounting for `::slotted` or
+    /// `::part`) already.
+    ///
+    /// If so, then other pseudo-elements and most other selectors are
+    /// disallowed.
+    after_pseudo_element: bool = false,
+
+    /// Whether we've parsed a non-stateful pseudo-element (again, as-in
+    /// `Impl::PseudoElement`) already. If so, then other pseudo-classes are
+    /// disallowed. If this flag is set, `AFTER_PSEUDO_ELEMENT` must be set
+    /// as well.
+    after_non_stateful_pseudo_element: bool = false,
+
+    /// Whether we explicitly disallow combinators.
+    disallow_combinators: bool = false,
+
+    /// Whether we explicitly disallow pseudo-element-like things.
+    disallow_pseudos: bool = false,
+
+    /// Whether we have seen a nesting selector.
+    after_nesting: bool = false,
+
+    after_webkit_scrollbar: bool = false,
+    after_view_transition: bool = false,
+    after_unknown_pseudo_element: bool = false,
+    __unused: u5 = 0,
+
+    /// Whether we are after any of the pseudo-like things.
+    pub const AFTER_PSEUDO = SelectorParsingState{ .after_part = true, .after_slotted = true, .after_pseudo_element = true };
+
+    pub usingnamespace css.Bitflags(@This());
+
+    pub fn allowsPseudos(this: SelectorParsingState) bool {
+        return !this.intersects(SelectorParsingState{
+            .after_pseudo_element = true,
+            .disallow_pseudos = true,
+        });
+    }
+
+    pub fn allowsPart(this: SelectorParsingState) bool {
+        return !this.intersects(SelectorParsingState.AFTER_PSEUDO.bitwiseOr(SelectorParsingState{ .disallow_pseudos = true }));
+    }
+
+    pub fn allowsSlotted(this: SelectorParsingState) bool {
+        return !this.intersects(SelectorParsingState.AFTER_PSEUDO.bitwiseOr(.{ .disallow_pseudos = true }));
+    }
+
+    pub fn allowsTreeStructuralPseudoClasses(this: SelectorParsingState) bool {
+        return !this.intersects(SelectorParsingState.AFTER_PSEUDO);
+    }
+
+    pub fn allowsNonFunctionalPseudoClasses(this: SelectorParsingState) bool {
+        return !this.intersects(SelectorParsingState{ .after_slotted = true, .after_non_stateful_pseudo_element = true });
+    }
+
+    pub fn allowsCombinators(this: SelectorParsingState) bool {
+        return !this.intersects(SelectorParsingState{ .disallow_combinators = true });
+    }
+
+    pub fn allowsCustomFunctionalPseudoClasses(this: SelectorParsingState) bool {
+        return !this.intersects(SelectorParsingState.AFTER_PSEUDO);
+    }
+};
+
+pub const SpecifityAndFlags = struct {
+    /// There are two free bits here, since we use ten bits for each specificity
+    /// kind (id, class, element).
+    specificity: u32,
+    /// There's padding after this field due to the size of the flags.
+    flags: SelectorFlags,
+
+    pub fn eql(this: *const SpecifityAndFlags, other: *const SpecifityAndFlags) bool {
+        return this.specificity == other.specificity and this.flags.eql(other.flags);
+    }
+
+    pub fn hasPseudoElement(this: *const SpecifityAndFlags) bool {
+        return this.flags.intersects(SelectorFlags{ .has_pseudo = true });
+    }
+
+    pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+        return css.implementHash(@This(), this, hasher);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+pub const SelectorFlags = packed struct(u8) {
+    has_pseudo: bool = false,
+    has_slotted: bool = false,
+    has_part: bool = false,
+    __unused: u5 = 0,
+
+    pub usingnamespace css.Bitflags(@This());
+};
+
+/// How to treat invalid selectors in a selector list.
+pub const ParseErrorRecovery = enum {
+    /// Discard the entire selector list, this is the default behavior for
+    /// almost all of CSS.
+    discard_list,
+    /// Ignore invalid selectors, potentially creating an empty selector list.
+    ///
+    /// This is the error recovery mode of :is() and :where()
+    ignore_invalid_selector,
+};
+
+pub const NestingRequirement = enum {
+    none,
+    prefixed,
+    contained,
+    implicit,
+};
+
+pub const Combinator = enum {
+    child, // >
+    descendant, // space
+    next_sibling, // +
+    later_sibling, // ~
+    /// A dummy combinator we use to the left of pseudo-elements.
+    ///
+    /// It serializes as the empty string, and acts effectively as a child
+    /// combinator in most cases.  If we ever actually start using a child
+    /// combinator for this, we will need to fix up the way hashes are computed
+    /// for revalidation selectors.
+    pseudo_element,
+    /// Another combinator used for ::slotted(), which represent the jump from
+    /// a node to its assigned slot.
+    slot_assignment,
+
+    /// Another combinator used for `::part()`, which represents the jump from
+    /// the part to the containing shadow host.
+    part,
+
+    /// Non-standard Vue >>> combinator.
+    /// https://vue-loader.vuejs.org/guide/scoped-css.html#deep-selectors
+    deep_descendant,
+    /// Non-standard /deep/ combinator.
+    /// Appeared in early versions of the css-scoping-1 specification:
+    /// https://www.w3.org/TR/2014/WD-css-scoping-1-20140403/#deep-combinator
+    /// And still supported as an alias for >>> by Vue.
+    deep,
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return lhs.* == rhs.*;
+    }
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+        _ = this; // autofix
+        _ = dest; // autofix
+        @compileError("Do not call this! Use `serializer.serializeCombinator()` or `tocss_servo.toCss_Combinator()` instead.");
+    }
+
+    pub fn isTreeCombinator(this: *const @This()) bool {
+        return switch (this.*) {
+            .child, .descendant, .next_sibling, .later_sibling => true,
+            else => false,
+        };
+    }
+
+    pub fn format(this: *const Combinator, comptime _: []const u8, _: std.fmt.FormatOptions, writer: anytype) !void {
+        return switch (this.*) {
+            .child => writer.print(">", .{}),
+            .descendant => writer.print("`descendant` (space)", .{}),
+            .next_sibling => writer.print("+", .{}),
+            .later_sibling => writer.print("~", .{}),
+            else => writer.print("{s}", .{@tagName(this.*)}),
+        };
+    }
+};
+
+pub const SelectorParseErrorKind = union(enum) {
+    invalid_state,
+    class_needs_ident: css.Token,
+    pseudo_element_expected_ident: css.Token,
+    unsupported_pseudo_class_or_element: []const u8,
+    no_qualified_name_in_attribute_selector: css.Token,
+    unexpected_token_in_attribute_selector: css.Token,
+    unexpected_selector_after_pseudo_element: css.Token,
+    invalid_qual_name_in_attr: css.Token,
+    expected_bar_in_attr: css.Token,
+    empty_selector,
+    dangling_combinator,
+    invalid_pseudo_class_before_webkit_scrollbar,
+    invalid_pseudo_class_after_webkit_scrollbar,
+    invalid_pseudo_class_after_pseudo_element,
+    missing_nesting_selector,
+    missing_nesting_prefix,
+    expected_namespace: []const u8,
+    bad_value_in_attr: css.Token,
+    explicit_namespace_unexpected_token: css.Token,
+    unexpected_ident: []const u8,
+
+    pub fn intoDefaultParserError(this: SelectorParseErrorKind) css.ParserError {
+        return css.ParserError{
+            .selector_error = this.intoSelectorError(),
+        };
+    }
+
+    pub fn intoSelectorError(this: SelectorParseErrorKind) css.SelectorError {
+        return switch (this) {
+            .invalid_state => .invalid_state,
+            .class_needs_ident => |token| .{ .class_needs_ident = token },
+            .pseudo_element_expected_ident => |token| .{ .pseudo_element_expected_ident = token },
+            .unsupported_pseudo_class_or_element => |name| .{ .unsupported_pseudo_class_or_element = name },
+            .no_qualified_name_in_attribute_selector => |token| .{ .no_qualified_name_in_attribute_selector = token },
+            .unexpected_token_in_attribute_selector => |token| .{ .unexpected_token_in_attribute_selector = token },
+            .invalid_qual_name_in_attr => |token| .{ .invalid_qual_name_in_attr = token },
+            .expected_bar_in_attr => |token| .{ .expected_bar_in_attr = token },
+            .empty_selector => .empty_selector,
+            .dangling_combinator => .dangling_combinator,
+            .invalid_pseudo_class_before_webkit_scrollbar => .invalid_pseudo_class_before_webkit_scrollbar,
+            .invalid_pseudo_class_after_webkit_scrollbar => .invalid_pseudo_class_after_webkit_scrollbar,
+            .invalid_pseudo_class_after_pseudo_element => .invalid_pseudo_class_after_pseudo_element,
+            .missing_nesting_selector => .missing_nesting_selector,
+            .missing_nesting_prefix => .missing_nesting_prefix,
+            .expected_namespace => |name| .{ .expected_namespace = name },
+            .bad_value_in_attr => |token| .{ .bad_value_in_attr = token },
+            .explicit_namespace_unexpected_token => |token| .{ .explicit_namespace_unexpected_token = token },
+            .unexpected_ident => |ident| .{ .unexpected_ident = ident },
+            .unexpected_selector_after_pseudo_element => |tok| .{ .unexpected_selector_after_pseudo_element = tok },
+        };
+    }
+};
+
+pub fn SimpleSelectorParseResult(comptime Impl: type) type {
+    ValidSelectorImpl(Impl);
+
+    return union(enum) {
+        simple_selector: GenericComponent(Impl),
+        pseudo_element: Impl.SelectorImpl.PseudoElement,
+        slotted_pseudo: GenericSelector(Impl),
+        // todo_stuff.think_mem_mgmt
+        part_pseudo: []Impl.SelectorImpl.Identifier,
+    };
+}
+
+/// A pseudo element.
+pub const PseudoElement = union(enum) {
+    /// The [::after](https://drafts.csswg.org/css-pseudo-4/#selectordef-after) pseudo element.
+    after,
+    /// The [::before](https://drafts.csswg.org/css-pseudo-4/#selectordef-before) pseudo element.
+    before,
+    /// The [::first-line](https://drafts.csswg.org/css-pseudo-4/#first-line-pseudo) pseudo element.
+    first_line,
+    /// The [::first-letter](https://drafts.csswg.org/css-pseudo-4/#first-letter-pseudo) pseudo element.
+    first_letter,
+    /// The [::selection](https://drafts.csswg.org/css-pseudo-4/#selectordef-selection) pseudo element.
+    selection: css.VendorPrefix,
+    /// The [::placeholder](https://drafts.csswg.org/css-pseudo-4/#placeholder-pseudo) pseudo element.
+    placeholder: css.VendorPrefix,
+    /// The [::marker](https://drafts.csswg.org/css-pseudo-4/#marker-pseudo) pseudo element.
+    marker,
+    /// The [::backdrop](https://fullscreen.spec.whatwg.org/#::backdrop-pseudo-element) pseudo element.
+    backdrop: css.VendorPrefix,
+    /// The [::file-selector-button](https://drafts.csswg.org/css-pseudo-4/#file-selector-button-pseudo) pseudo element.
+    file_selector_button: css.VendorPrefix,
+    /// A [webkit scrollbar](https://webkit.org/blog/363/styling-scrollbars/) pseudo element.
+    webkit_scrollbar: WebKitScrollbarPseudoElement,
+    /// The [::cue](https://w3c.github.io/webvtt/#the-cue-pseudo-element) pseudo element.
+    cue,
+    /// The [::cue-region](https://w3c.github.io/webvtt/#the-cue-region-pseudo-element) pseudo element.
+    cue_region,
+    /// The [::cue()](https://w3c.github.io/webvtt/#cue-selector) functional pseudo element.
+    cue_function: struct {
+        /// The selector argument.
+        selector: *Selector,
+
+        pub fn __generateEql() void {}
+        pub fn __generateDeepClone() void {}
+        pub fn __generateHash() void {}
+    },
+    /// The [::cue-region()](https://w3c.github.io/webvtt/#cue-region-selector) functional pseudo element.
+    cue_region_function: struct {
+        /// The selector argument.
+        selector: *Selector,
+
+        pub fn __generateEql() void {}
+        pub fn __generateDeepClone() void {}
+        pub fn __generateHash() void {}
+    },
+    /// The [::view-transition](https://w3c.github.io/csswg-drafts/css-view-transitions-1/#view-transition) pseudo element.
+    view_transition,
+    /// The [::view-transition-group()](https://w3c.github.io/csswg-drafts/css-view-transitions-1/#view-transition-group-pt-name-selector) functional pseudo element.
+    view_transition_group: struct {
+        /// A part name selector.
+        part_name: ViewTransitionPartName,
+
+        pub fn __generateEql() void {}
+        pub fn __generateDeepClone() void {}
+        pub fn __generateHash() void {}
+    },
+    /// The [::view-transition-image-pair()](https://w3c.github.io/csswg-drafts/css-view-transitions-1/#view-transition-image-pair-pt-name-selector) functional pseudo element.
+    view_transition_image_pair: struct {
+        /// A part name selector.
+        part_name: ViewTransitionPartName,
+
+        pub fn __generateEql() void {}
+        pub fn __generateDeepClone() void {}
+        pub fn __generateHash() void {}
+    },
+    /// The [::view-transition-old()](https://w3c.github.io/csswg-drafts/css-view-transitions-1/#view-transition-old-pt-name-selector) functional pseudo element.
+    view_transition_old: struct {
+        /// A part name selector.
+        part_name: ViewTransitionPartName,
+
+        pub fn __generateEql() void {}
+        pub fn __generateDeepClone() void {}
+        pub fn __generateHash() void {}
+    },
+    /// The [::view-transition-new()](https://w3c.github.io/csswg-drafts/css-view-transitions-1/#view-transition-new-pt-name-selector) functional pseudo element.
+    view_transition_new: struct {
+        /// A part name selector.
+        part_name: ViewTransitionPartName,
+
+        pub fn __generateEql() void {}
+        pub fn __generateDeepClone() void {}
+        pub fn __generateHash() void {}
+    },
+    /// An unknown pseudo element.
+    custom: struct {
+        /// The name of the pseudo element.
+        name: []const u8,
+
+        pub fn __generateEql() void {}
+        pub fn __generateDeepClone() void {}
+        pub fn __generateHash() void {}
+    },
+    /// An unknown functional pseudo element.
+    custom_function: struct {
+        /// The name of the pseudo element.
+        name: []const u8,
+        /// The arguments of the pseudo element function.
+        arguments: css.TokenList,
+
+        pub fn __generateEql() void {}
+        pub fn __generateDeepClone() void {}
+        pub fn __generateHash() void {}
+    },
+
+    pub fn isEquivalent(this: *const PseudoElement, other: *const PseudoElement) bool {
+        if (this.* == .selection and other.* == .selection) return true;
+        if (this.* == .placeholder and other.* == .placeholder) return true;
+        if (this.* == .backdrop and other.* == .backdrop) return true;
+        if (this.* == .file_selector_button and other.* == .file_selector_button) return true;
+        return this.eql(other);
+    }
+
+    pub fn eql(this: *const PseudoElement, other: *const PseudoElement) bool {
+        return css.implementEql(PseudoElement, this, other);
+    }
+
+    pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+        return css.implementHash(@This(), this, hasher);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn getNecessaryPrefixes(this: *PseudoElement, targets: css.targets.Targets) css.VendorPrefix {
+        const F = css.prefixes.Feature;
+        const p: *css.VendorPrefix, const feature: F = switch (this.*) {
+            .selection => |*p| .{ p, F.pseudo_element_selection },
+            .placeholder => |*p| .{ p, F.pseudo_element_placeholder },
+            .backdrop => |*p| .{ p, F.pseudo_element_backdrop },
+            .file_selector_button => |*p| .{ p, F.pseudo_element_file_selector_button },
+            else => return css.VendorPrefix.empty(),
+        };
+
+        p.* = targets.prefixes(p.*, feature);
+
+        return p.*;
+    }
+
+    pub fn getPrefix(this: *const PseudoElement) css.VendorPrefix {
+        return switch (this.*) {
+            .selection, .placeholder, .backdrop, .file_selector_button => |p| p,
+            else => css.VendorPrefix.empty(),
+        };
+    }
+
+    pub fn format(this: *const PseudoElement, comptime _: []const u8, _: std.fmt.FormatOptions, writer: anytype) !void {
+        try writer.print("{s}", .{@tagName(this.*)});
+    }
+
+    pub fn validAfterSlotted(this: *const PseudoElement) bool {
+        return switch (this.*) {
+            .before, .after, .marker, .placeholder, .file_selector_button => true,
+            else => false,
+        };
+    }
+
+    pub fn isUnknown(this: *const PseudoElement) bool {
+        return switch (this.*) {
+            .custom, .custom_function => true,
+            else => false,
+        };
+    }
+
+    pub fn acceptsStatePseudoClasses(this: *const PseudoElement) bool {
+        _ = this; // autofix
+        // Be lienient.
+        return true;
+    }
+
+    pub fn isWebkitScrollbar(this: *const PseudoElement) bool {
+        return this.* == .webkit_scrollbar;
+    }
+
+    pub fn isViewTransition(this: *const PseudoElement) bool {
+        return switch (this.*) {
+            .view_transition_group, .view_transition_image_pair, .view_transition_new, .view_transition_old => true,
+            else => false,
+        };
+    }
+
+    pub fn toCss(this: *const PseudoElement, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        var s = ArrayList(u8){};
+        // PERF(alloc): I don't like making small allocations here for the string.
+        const writer = s.writer(dest.allocator);
+        const W2 = @TypeOf(writer);
+        const scratchbuf = std.ArrayList(u8).init(dest.allocator);
+        var printer = Printer(W2).new(dest.allocator, scratchbuf, writer, css.PrinterOptions{}, dest.import_records);
+        try serialize.serializePseudoElement(this, W2, &printer, null);
+        return dest.writeStr(s.items);
+    }
+};
+
+/// An enum for the different types of :nth- pseudoclasses
+pub const NthType = enum {
+    child,
+    last_child,
+    only_child,
+    of_type,
+    last_of_type,
+    only_of_type,
+    col,
+    last_col,
+
+    pub fn isOnly(self: NthType) bool {
+        return self == NthType.only_child or self == NthType.only_of_type;
+    }
+
+    pub fn isOfType(self: NthType) bool {
+        return self == NthType.of_type or self == NthType.last_of_type or self == NthType.only_of_type;
+    }
+
+    pub fn isFromEnd(self: NthType) bool {
+        return self == NthType.last_child or self == NthType.last_of_type or self == NthType.last_col;
+    }
+
+    pub fn allowsOfSelector(self: NthType) bool {
+        return self == NthType.child or self == NthType.last_child;
+    }
+};
+
+/// * `Err(())`: Invalid selector, abort
+/// * `Ok(false)`: Not a type selector, could be something else. `input` was not consumed.
+/// * `Ok(true)`: Length 0 (`*|*`), 1 (`*|E` or `ns|*`) or 2 (`|E` or `ns|E`)
+pub fn parse_type_selector(
+    comptime Impl: type,
+    parser: *SelectorParser,
+    input: *css.Parser,
+    state: SelectorParsingState,
+    sink: *SelectorBuilder(Impl),
+) Result(bool) {
+    const result = switch (parse_qualified_name(
+        Impl,
+        parser,
+        input,
+        false,
+    )) {
+        .result => |v| v,
+        .err => |e| {
+            if (e.kind == .basic and e.kind.basic == .end_of_input) {
+                return .{ .result = false };
+            }
+
+            return .{ .err = e };
+        },
+    };
+
+    if (result == .none) return .{ .result = false };
+
+    const namespace: QNamePrefix(Impl) = result.some[0];
+    const local_name: ?[]const u8 = result.some[1];
+    if (state.intersects(SelectorParsingState.AFTER_PSEUDO)) {
+        return .{ .err = input.newCustomError(SelectorParseErrorKind.intoDefaultParserError(.invalid_state)) };
+    }
+
+    switch (namespace) {
+        .implicit_any_namespace => {},
+        .implicit_default_namespace => |url| {
+            sink.pushSimpleSelector(.{ .default_namespace = url });
+        },
+        .explicit_namespace => {
+            const prefix = namespace.explicit_namespace[0];
+            const url = namespace.explicit_namespace[1];
+            const component: GenericComponent(Impl) = component: {
+                if (parser.defaultNamespace()) |default_url| {
+                    if (bun.strings.eql(url, default_url)) {
+                        break :component .{ .default_namespace = url };
+                    }
+                }
+                break :component .{
+                    .namespace = .{
+                        .prefix = prefix,
+                        .url = url,
+                    },
+                };
+            };
+            sink.pushSimpleSelector(component);
+        },
+        .explicit_no_namespace => {
+            sink.pushSimpleSelector(.explicit_no_namespace);
+        },
+        .explicit_any_namespace => {
+            // Element type selectors that have no namespace
+            // component (no namespace separator) represent elements
+            // without regard to the element's namespace (equivalent
+            // to "*|") unless a default namespace has been declared
+            // for namespaced selectors (e.g. in CSS, in the style
+            // sheet). If a default namespace has been declared,
+            // such selectors will represent only elements in the
+            // default namespace.
+            // -- Selectors § 6.1.1
+            // So we'll have this act the same as the
+            // QNamePrefix::ImplicitAnyNamespace case.
+            // For lightning css this logic was removed, should be handled when matching.
+            sink.pushSimpleSelector(.explicit_any_namespace);
+        },
+        .implicit_no_namespace => {
+            bun.unreachablePanic("Should not be returned with in_attr_selector = false", .{});
+        },
+    }
+
+    if (local_name) |name| {
+        sink.pushSimpleSelector(.{
+            .local_name = LocalName(Impl){
+                .lower_name = brk: {
+                    var lowercase = parser.allocator.alloc(u8, name.len) catch unreachable; // PERF: check if it's already lowercase
+                    break :brk .{ .v = bun.strings.copyLowercase(name, lowercase[0..]) };
+                },
+                .name = .{ .v = name },
+            },
+        });
+    } else {
+        sink.pushSimpleSelector(.explicit_universal_type);
+    }
+
+    return .{ .result = true };
+}
+
+/// Parse a simple selector other than a type selector.
+///
+/// * `Err(())`: Invalid selector, abort
+/// * `Ok(None)`: Not a simple selector, could be something else. `input` was not consumed.
+/// * `Ok(Some(_))`: Parsed a simple selector or pseudo-element
+pub fn parse_one_simple_selector(
+    comptime Impl: type,
+    parser: *SelectorParser,
+    input: *css.Parser,
+    state: *SelectorParsingState,
+) Result(?SimpleSelectorParseResult(Impl)) {
+    const S = SimpleSelectorParseResult(Impl);
+
+    const start = input.state();
+    const token = switch (input.nextIncludingWhitespace()) {
+        .result => |v| v.*,
+        .err => {
+            input.reset(&start);
+            return .{ .result = null };
+        },
+    };
+
+    switch (token) {
+        .idhash => |id| {
+            if (state.intersects(SelectorParsingState.AFTER_PSEUDO)) {
+                return .{ .err = input.newCustomError(SelectorParseErrorKind.intoDefaultParserError(.invalid_state)) };
+            }
+            const component: GenericComponent(Impl) = .{ .id = .{ .v = id } };
+            return .{ .result = S{
+                .simple_selector = component,
+            } };
+        },
+        .open_square => {
+            if (state.intersects(SelectorParsingState.AFTER_PSEUDO)) {
+                return .{ .err = input.newCustomError(SelectorParseErrorKind.intoDefaultParserError(.invalid_state)) };
+            }
+            const Closure = struct {
+                parser: *SelectorParser,
+                pub fn parsefn(this: *@This(), input2: *css.Parser) Result(GenericComponent(Impl)) {
+                    return parse_attribute_selector(Impl, this.parser, input2);
+                }
+            };
+            var closure = Closure{
+                .parser = parser,
+            };
+            const attr = switch (input.parseNestedBlock(GenericComponent(Impl), &closure, Closure.parsefn)) {
+                .err => |e| return .{ .err = e },
+                .result => |v| v,
+            };
+            return .{ .result = .{ .simple_selector = attr } };
+        },
+        .colon => {
+            const location = input.currentSourceLocation();
+            const is_single_colon: bool, const next_token: css.Token = switch ((switch (input.nextIncludingWhitespace()) {
+                .err => |e| return .{ .err = e },
+                .result => |v| v,
+            }).*) {
+                .colon => .{ false, (switch (input.nextIncludingWhitespace()) {
+                    .err => |e| return .{ .err = e },
+                    .result => |v| v,
+                }).* },
+                else => |t| .{ true, t },
+            };
+            const name: []const u8, const is_functional = switch (next_token) {
+                .ident => |name| .{ name, false },
+                .function => |name| .{ name, true },
+                else => |t| {
+                    const e = SelectorParseErrorKind{ .pseudo_element_expected_ident = t };
+                    return .{ .err = input.newCustomError(e.intoDefaultParserError()) };
+                },
+            };
+            const is_pseudo_element = !is_single_colon or is_css2_pseudo_element(name);
+            if (is_pseudo_element) {
+                if (!state.allowsPseudos()) {
+                    return .{ .err = input.newCustomError(SelectorParseErrorKind.intoDefaultParserError(.invalid_state)) };
+                }
+                const pseudo_element: Impl.SelectorImpl.PseudoElement = if (is_functional) pseudo_element: {
+                    if (parser.parsePart() and bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "part")) {
+                        if (!state.allowsPart()) {
+                            return .{ .err = input.newCustomError(SelectorParseErrorKind.intoDefaultParserError(.invalid_state)) };
+                        }
+
+                        const Closure = struct {
+                            parser: *SelectorParser,
+
+                            pub fn parsefn(self: *const @This(), input2: *css.Parser) Result([]Impl.SelectorImpl.Identifier) {
+                                // todo_stuff.think_about_mem_mgmt
+                                var result = ArrayList(Impl.SelectorImpl.Identifier).initCapacity(
+                                    self.parser.allocator,
+                                    // TODO: source does this, should see if initializing to 1 is actually better
+                                    // when appending empty std.ArrayList(T), it will usually initially reserve 8 elements,
+                                    // maybe that's unnecessary, or maybe smallvec is gud here
+                                    1,
+                                ) catch unreachable;
+
+                                result.append(
+                                    self.parser.allocator,
+                                    switch (input2.expectIdent()) {
+                                        .err => |e| return .{ .err = e },
+                                        .result => |v| .{ .v = v },
+                                    },
+                                ) catch unreachable;
+
+                                while (!input2.isExhausted()) {
+                                    result.append(
+                                        self.parser.allocator,
+                                        switch (input2.expectIdent()) {
+                                            .err => |e| return .{ .err = e },
+                                            .result => |v| .{ .v = v },
+                                        },
+                                    ) catch unreachable;
+                                }
+
+                                return .{ .result = result.items };
+                            }
+                        };
+
+                        const names = switch (input.parseNestedBlock([]Impl.SelectorImpl.Identifier, &Closure{ .parser = parser }, Closure.parsefn)) {
+                            .err => |e| return .{ .err = e },
+                            .result => |v| v,
+                        };
+
+                        return .{ .result = .{ .part_pseudo = names } };
+                    }
+
+                    if (parser.parseSlotted() and bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "slotted")) {
+                        if (!state.allowsSlotted()) {
+                            return .{ .err = input.newCustomError(SelectorParseErrorKind.intoDefaultParserError(.invalid_state)) };
+                        }
+                        const Closure = struct {
+                            parser: *SelectorParser,
+                            state: *SelectorParsingState,
+                            pub fn parsefn(this: *@This(), input2: *css.Parser) Result(GenericSelector(Impl)) {
+                                return parse_inner_compound_selector(Impl, this.parser, input2, this.state);
+                            }
+                        };
+                        var closure = Closure{
+                            .parser = parser,
+                            .state = state,
+                        };
+                        const selector = switch (input.parseNestedBlock(GenericSelector(Impl), &closure, Closure.parsefn)) {
+                            .err => |e| return .{ .err = e },
+                            .result => |v| v,
+                        };
+                        return .{ .result = .{ .slotted_pseudo = selector } };
+                    }
+
+                    const Closure = struct {
+                        parser: *SelectorParser,
+                        state: *SelectorParsingState,
+                        name: []const u8,
+                    };
+                    break :pseudo_element switch (input.parseNestedBlock(Impl.SelectorImpl.PseudoElement, &Closure{ .parser = parser, .state = state, .name = name }, struct {
+                        pub fn parseFn(closure: *const Closure, i: *css.Parser) Result(Impl.SelectorImpl.PseudoElement) {
+                            return closure.parser.parseFunctionalPseudoElement(closure.name, i);
+                        }
+                    }.parseFn)) {
+                        .result => |v| v,
+                        .err => |e| return .{ .err = e },
+                    };
+                } else pseudo_element: {
+                    break :pseudo_element switch (parser.parsePseudoElement(location, name)) {
+                        .err => |e| return .{ .err = e },
+                        .result => |v| v,
+                    };
+                };
+
+                if (state.intersects(.{ .after_slotted = true }) and pseudo_element.validAfterSlotted()) {
+                    return .{ .result = .{ .pseudo_element = pseudo_element } };
+                }
+
+                return .{ .result = .{ .pseudo_element = pseudo_element } };
+            } else {
+                const pseudo_class: GenericComponent(Impl) = if (is_functional) pseudo_class: {
+                    const Closure = struct {
+                        parser: *SelectorParser,
+                        name: []const u8,
+                        state: *SelectorParsingState,
+                        pub fn parsefn(this: *@This(), input2: *css.Parser) Result(GenericComponent(Impl)) {
+                            return parse_functional_pseudo_class(Impl, this.parser, input2, this.name, this.state);
+                        }
+                    };
+                    var closure = Closure{
+                        .parser = parser,
+                        .name = name,
+                        .state = state,
+                    };
+
+                    break :pseudo_class switch (input.parseNestedBlock(GenericComponent(Impl), &closure, Closure.parsefn)) {
+                        .err => |e| return .{ .err = e },
+                        .result => |v| v,
+                    };
+                } else switch (parse_simple_pseudo_class(Impl, parser, location, name, state.*)) {
+                    .err => |e| return .{ .err = e },
+                    .result => |v| v,
+                };
+                return .{ .result = .{ .simple_selector = pseudo_class } };
+            }
+        },
+        .delim => |d| {
+            switch (d) {
+                '.' => {
+                    if (state.intersects(SelectorParsingState.AFTER_PSEUDO)) {
+                        return .{ .err = input.newCustomError(SelectorParseErrorKind.intoDefaultParserError(.invalid_state)) };
+                    }
+                    const location = input.currentSourceLocation();
+                    const class = switch ((switch (input.nextIncludingWhitespace()) {
+                        .err => |e| return .{ .err = e },
+                        .result => |v| v,
+                    }).*) {
+                        .ident => |class| class,
+                        else => |t| {
+                            const e = SelectorParseErrorKind{ .class_needs_ident = t };
+                            return .{ .err = location.newCustomError(e.intoDefaultParserError()) };
+                        },
+                    };
+                    return .{ .result = .{ .simple_selector = .{ .class = .{ .v = class } } } };
+                },
+                '&' => {
+                    if (parser.isNestingAllowed()) {
+                        state.insert(SelectorParsingState{ .after_nesting = true });
+                        return .{ .result = S{
+                            .simple_selector = .nesting,
+                        } };
+                    }
+                },
+                else => {},
+            }
+        },
+        else => {},
+    }
+
+    input.reset(&start);
+    return .{ .result = null };
+}
+
+pub fn parse_attribute_selector(comptime Impl: type, parser: *SelectorParser, input: *css.Parser) Result(GenericComponent(Impl)) {
+    const N = attrs.NamespaceConstraint(attrs.NamespaceUrl(Impl));
+
+    const namespace: ?N, const local_name: []const u8 = brk: {
+        input.skipWhitespace();
+
+        const _qname = switch (parse_qualified_name(Impl, parser, input, true)) {
+            .err => |e| return .{ .err = e },
+            .result => |v| v,
+        };
+        switch (_qname) {
+            .none => |t| return .{ .err = input.newCustomError(SelectorParseErrorKind.intoDefaultParserError(.{ .no_qualified_name_in_attribute_selector = t })) },
+            .some => |qname| {
+                if (qname[1] == null) {
+                    bun.unreachablePanic("", .{});
+                }
+                const ns: QNamePrefix(Impl) = qname[0];
+                const ln = qname[1].?;
+                break :brk .{
+                    switch (ns) {
+                        .implicit_no_namespace, .explicit_no_namespace => null,
+                        .explicit_namespace => |x| .{ .specific = .{ .prefix = x[0], .url = x[1] } },
+                        .explicit_any_namespace => .any,
+                        .implicit_any_namespace, .implicit_default_namespace => {
+                            bun.unreachablePanic("Not returned with in_attr_selector = true", .{});
+                        },
+                    },
+                    ln,
+                };
+            },
+        }
+    };
+
+    const location = input.currentSourceLocation();
+    const operator: attrs.AttrSelectorOperator = operator: {
+        const tok = switch (input.next()) {
+            .result => |v| v,
+            .err => {
+                // [foo]
+                const local_name_lower = local_name_lower: {
+                    const lower = parser.allocator.alloc(u8, local_name.len) catch unreachable;
+                    _ = bun.strings.copyLowercase(local_name, lower);
+                    break :local_name_lower lower;
+                };
+                if (namespace) |ns| {
+                    const x = attrs.AttrSelectorWithOptionalNamespace(Impl){
+                        .namespace = ns,
+                        .local_name = .{ .v = local_name },
+                        .local_name_lower = .{ .v = local_name_lower },
+                        .never_matches = false,
+                        .operation = .exists,
+                    };
+                    return .{
+                        .result = .{ .attribute_other = bun.create(parser.allocator, attrs.AttrSelectorWithOptionalNamespace(Impl), x) },
+                    };
+                } else {
+                    return .{ .result = .{
+                        .attribute_in_no_namespace_exists = .{
+                            .local_name = .{ .v = local_name },
+                            .local_name_lower = .{ .v = local_name_lower },
+                        },
+                    } };
+                }
+            },
+        };
+
+        switch (tok.*) {
+            // [foo=bar]
+            .delim => |d| {
+                if (d == '=') break :operator .equal;
+            },
+            // [foo~=bar]
+            .include_match => break :operator .includes,
+            // [foo|=bar]
+            .dash_match => break :operator .dash_match,
+            // [foo^=bar]
+            .prefix_match => break :operator .prefix,
+            // [foo*=bar]
+            .substring_match => break :operator .substring,
+            // [foo$=bar]
+            .suffix_match => break :operator .suffix,
+            else => {},
+        }
+        return .{ .err = location.newCustomError(SelectorParseErrorKind.intoDefaultParserError(.{ .unexpected_token_in_attribute_selector = tok.* })) };
+    };
+
+    const value_str: []const u8 = switch (input.expectIdentOrString()) {
+        .result => |v| v,
+        .err => |e| {
+            if (e.kind == .basic and e.kind.basic == .unexpected_token) {
+                return .{ .err = e.location.newCustomError(SelectorParseErrorKind.intoDefaultParserError(.{ .bad_value_in_attr = e.kind.basic.unexpected_token })) };
+            }
+            return .{
+                .err = .{
+                    .kind = e.kind,
+                    .location = e.location,
+                },
+            };
+        },
+    };
+    const never_matches = switch (operator) {
+        .equal, .dash_match => false,
+        .includes => value_str.len == 0 or std.mem.indexOfAny(u8, value_str, SELECTOR_WHITESPACE) != null,
+        .prefix, .substring, .suffix => value_str.len == 0,
+    };
+
+    const attribute_flags = switch (parse_attribute_flags(input)) {
+        .err => |e| return .{ .err = e },
+        .result => |v| v,
+    };
+
+    const value: Impl.SelectorImpl.AttrValue = value_str;
+    const local_name_lower: Impl.SelectorImpl.LocalName, const local_name_is_ascii_lowercase: bool = brk: {
+        if (a: {
+            for (local_name, 0..) |b, i| {
+                if (b >= 'A' and b <= 'Z') break :a i;
+            }
+            break :a null;
+        }) |first_uppercase| {
+            const str = local_name[first_uppercase..];
+            const lower = parser.allocator.alloc(u8, str.len) catch unreachable;
+            break :brk .{ .{ .v = bun.strings.copyLowercase(str, lower) }, false };
+        } else {
+            break :brk .{ .{ .v = local_name }, true };
+        }
+    };
+    const case_sensitivity: attrs.ParsedCaseSensitivity = attribute_flags.toCaseSensitivity(local_name_lower.v, namespace != null);
+    if (namespace != null and !local_name_is_ascii_lowercase) {
+        return .{ .result = .{
+            .attribute_other = brk: {
+                const x = attrs.AttrSelectorWithOptionalNamespace(Impl){
+                    .namespace = namespace,
+                    .local_name = .{ .v = local_name },
+                    .local_name_lower = local_name_lower,
+                    .never_matches = never_matches,
+                    .operation = .{
+                        .with_value = .{
+                            .operator = operator,
+                            .case_sensitivity = case_sensitivity,
+                            .expected_value = value,
+                        },
+                    },
+                };
+                break :brk bun.create(parser.allocator, @TypeOf(x), x);
+            },
+        } };
+    } else {
+        return .{ .result = .{
+            .attribute_in_no_namespace = .{
+                .local_name = .{ .v = local_name },
+                .operator = operator,
+                .value = value,
+                .case_sensitivity = case_sensitivity,
+                .never_matches = never_matches,
+            },
+        } };
+    }
+}
+
+/// Returns whether the name corresponds to a CSS2 pseudo-element that
+/// can be specified with the single colon syntax (in addition to the
+/// double-colon syntax, which can be used for all pseudo-elements).
+pub fn is_css2_pseudo_element(name: []const u8) bool {
+    // ** Do not add to this list! **
+    // TODO: todo_stuff.match_ignore_ascii_case
+    return bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "before") or
+        bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "after") or
+        bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "first-line") or
+        bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "first-letter");
+}
+
+/// Parses one compound selector suitable for nested stuff like :-moz-any, etc.
+pub fn parse_inner_compound_selector(
+    comptime Impl: type,
+    parser: *SelectorParser,
+    input: *css.Parser,
+    state: *SelectorParsingState,
+) Result(GenericSelector(Impl)) {
+    var child_state = brk: {
+        var child_state = state.*;
+        child_state.disallow_pseudos = true;
+        child_state.disallow_combinators = true;
+        break :brk child_state;
+    };
+    const result = switch (parse_selector(Impl, parser, input, &child_state, NestingRequirement.none)) {
+        .err => |e| return .{ .err = e },
+        .result => |v| v,
+    };
+    if (child_state.after_nesting) {
+        state.after_nesting = true;
+    }
+    return .{ .result = result };
+}
+
+pub fn parse_functional_pseudo_class(
+    comptime Impl: type,
+    parser: *SelectorParser,
+    input: *css.Parser,
+    name: []const u8,
+    state: *SelectorParsingState,
+) Result(GenericComponent(Impl)) {
+    const FunctionalPseudoClass = enum {
+        @"nth-child",
+        @"nth-of-type",
+        @"nth-last-child",
+        @"nth-last-of-type",
+        @"nth-col",
+        @"nth-last-col",
+        is,
+        where,
+        has,
+        host,
+        not,
+    };
+    const Map = bun.ComptimeEnumMap(FunctionalPseudoClass);
+
+    if (Map.getASCIIICaseInsensitive(name)) |functional_pseudo_class| {
+        switch (functional_pseudo_class) {
+            .@"nth-child" => return parse_nth_pseudo_class(Impl, parser, input, state.*, .child),
+            .@"nth-of-type" => return parse_nth_pseudo_class(Impl, parser, input, state.*, .of_type),
+            .@"nth-last-child" => return parse_nth_pseudo_class(Impl, parser, input, state.*, .last_child),
+            .@"nth-last-of-type" => return parse_nth_pseudo_class(Impl, parser, input, state.*, .last_of_type),
+            .@"nth-col" => return parse_nth_pseudo_class(Impl, parser, input, state.*, .col),
+            .@"nth-last-col" => return parse_nth_pseudo_class(Impl, parser, input, state.*, .last_col),
+            .is => if (parser.parseIsAndWhere()) return parse_is_or_where(Impl, parser, input, state, GenericComponent(Impl).convertHelper_is, .{}),
+            .where => if (parser.parseIsAndWhere()) return parse_is_or_where(Impl, parser, input, state, GenericComponent(Impl).convertHelper_where, .{}),
+            .has => return parse_has(Impl, parser, input, state),
+            .host => if (!state.allowsTreeStructuralPseudoClasses())
+                return .{ .err = input.newCustomError(SelectorParseErrorKind.intoDefaultParserError(.invalid_state)) }
+            else
+                return .{ .result = .{
+                    .host = switch (parse_inner_compound_selector(Impl, parser, input, state)) {
+                        .err => |e| return .{ .err = e },
+                        .result => |v| v,
+                    },
+                } },
+            .not => return parse_negation(Impl, parser, input, state),
+        }
+    }
+
+    if (parser.parseAnyPrefix(name)) |prefix| {
+        return parse_is_or_where(Impl, parser, input, state, GenericComponent(Impl).convertHelper_any, .{prefix});
+    }
+
+    if (!state.allowsCustomFunctionalPseudoClasses()) {
+        return .{ .err = input.newCustomError(SelectorParseErrorKind.intoDefaultParserError(.invalid_state)) };
+    }
+
+    const result = switch (parser.parseNonTsFunctionalPseudoClass(name, input)) {
+        .err => |e| return .{ .err = e },
+        .result => |v| v,
+    };
+
+    return .{ .result = .{ .non_ts_pseudo_class = result } };
+}
+
+pub fn parse_simple_pseudo_class(
+    comptime Impl: type,
+    parser: *SelectorParser,
+    location: css.SourceLocation,
+    name: []const u8,
+    state: SelectorParsingState,
+) Result(GenericComponent(Impl)) {
+    if (!state.allowsNonFunctionalPseudoClasses()) {
+        return .{ .err = location.newCustomError(SelectorParseErrorKind.intoDefaultParserError(.invalid_state)) };
+    }
+
+    if (state.allowsTreeStructuralPseudoClasses()) {
+        // css.todo_stuff.match_ignore_ascii_case
+        if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "first-child")) {
+            return .{ .result = .{ .nth = NthSelectorData.first(false) } };
+        } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "last-child")) {
+            return .{ .result = .{ .nth = NthSelectorData.last(false) } };
+        } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "only-child")) {
+            return .{ .result = .{ .nth = NthSelectorData.only(false) } };
+        } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "root")) {
+            return .{ .result = .root };
+        } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "empty")) {
+            return .{ .result = .empty };
+        } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "scope")) {
+            return .{ .result = .scope };
+        } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "host")) {
+            return .{ .result = .{ .host = null } };
+        } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "first-of-type")) {
+            return .{ .result = .{ .nth = NthSelectorData.first(true) } };
+        } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "last-of-type")) {
+            return .{ .result = .{ .nth = NthSelectorData.last(true) } };
+        } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "only-of-type")) {
+            return .{ .result = .{ .nth = NthSelectorData.only(true) } };
+        } else {}
+    }
+
+    // The view-transition pseudo elements accept the :only-child pseudo class.
+    // https://w3c.github.io/csswg-drafts/css-view-transitions-1/#pseudo-root
+    if (state.intersects(SelectorParsingState{ .after_view_transition = true })) {
+        if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "only-child")) {
+            return .{ .result = .{ .nth = NthSelectorData.only(false) } };
+        }
+    }
+
+    const pseudo_class = switch (parser.parseNonTsPseudoClass(location, name)) {
+        .err => |e| return .{ .err = e },
+        .result => |v| v,
+    };
+    if (state.intersects(SelectorParsingState{ .after_webkit_scrollbar = true })) {
+        if (!pseudo_class.isValidAfterWebkitScrollbar()) {
+            return .{ .err = location.newCustomError(SelectorParseErrorKind.intoDefaultParserError(.invalid_pseudo_class_after_webkit_scrollbar)) };
+        }
+    } else if (state.intersects(SelectorParsingState{ .after_pseudo_element = true })) {
+        if (!pseudo_class.isUserActionState()) {
+            return .{ .err = location.newCustomError(SelectorParseErrorKind.intoDefaultParserError(.invalid_pseudo_class_after_pseudo_element)) };
+        }
+    } else if (!pseudo_class.isValidBeforeWebkitScrollbar()) {
+        return .{ .err = location.newCustomError(SelectorParseErrorKind.intoDefaultParserError(.invalid_pseudo_class_before_webkit_scrollbar)) };
+    }
+
+    return .{ .result = .{ .non_ts_pseudo_class = pseudo_class } };
+}
+
+pub fn parse_nth_pseudo_class(
+    comptime Impl: type,
+    parser: *SelectorParser,
+    input: *css.Parser,
+    state: SelectorParsingState,
+    ty: NthType,
+) Result(GenericComponent(Impl)) {
+    if (!state.allowsTreeStructuralPseudoClasses()) {
+        return .{ .err = input.newCustomError(SelectorParseErrorKind.intoDefaultParserError(.invalid_state)) };
+    }
+
+    const a, const b = switch (css.nth.parse_nth(input)) {
+        .err => |e| return .{ .err = e },
+        .result => |v| v,
+    };
+    const nth_data = NthSelectorData{
+        .ty = ty,
+        .is_function = true,
+        .a = a,
+        .b = b,
+    };
+
+    if (!ty.allowsOfSelector()) {
+        return .{ .result = .{ .nth = nth_data } };
+    }
+
+    // Try to parse "of <selector-list>".
+    if (input.tryParse(css.Parser.expectIdentMatching, .{"of"}).isErr()) {
+        return .{ .result = .{ .nth = nth_data } };
+    }
+
+    // Whitespace between "of" and the selector list is optional
+    // https://github.com/w3c/csswg-drafts/issues/8285
+    var child_state = child_state: {
+        var s = state;
+        s.skip_default_namespace = true;
+        s.disallow_pseudos = true;
+        break :child_state s;
+    };
+
+    const selectors = switch (SelectorList.parseWithState(
+        parser,
+        input,
+        &child_state,
+        .ignore_invalid_selector,
+        .none,
+    )) {
+        .err => |e| return .{ .err = e },
+        .result => |v| v,
+    };
+
+    return .{ .result = .{
+        .nth_of = NthOfSelectorData(Impl){
+            .data = nth_data,
+            .selectors = selectors.v.toOwnedSlice(input.allocator()),
+        },
+    } };
+}
+
+/// `func` must be of the type: fn([]GenericSelector(Impl), ...@TypeOf(args_)) GenericComponent(Impl)
+pub fn parse_is_or_where(
+    comptime Impl: type,
+    parser: *SelectorParser,
+    input: *css.Parser,
+    state: *SelectorParsingState,
+    comptime func: anytype,
+    args_: anytype,
+) Result(GenericComponent(Impl)) {
+    bun.debugAssert(parser.parseIsAndWhere());
+    // https://drafts.csswg.org/selectors/#matches-pseudo:
+    //
+    //     Pseudo-elements cannot be represented by the matches-any
+    //     pseudo-class; they are not valid within :is().
+    //
+    var child_state = brk: {
+        var child_state = state.*;
+        child_state.skip_default_namespace = true;
+        child_state.disallow_pseudos = true;
+        break :brk child_state;
+    };
+
+    const inner = switch (SelectorList.parseWithState(parser, input, &child_state, parser.isAndWhereErrorRecovery(), NestingRequirement.none)) {
+        .err => |e| return .{ .err = e },
+        .result => |v| v,
+    };
+    if (child_state.after_nesting) {
+        state.after_nesting = true;
+    }
+
+    const selector_slice = inner.v.toOwnedSlice(input.allocator());
+
+    const result = result: {
+        const args = brk: {
+            var args: std.meta.ArgsTuple(@TypeOf(func)) = undefined;
+            args[0] = selector_slice;
+
+            inline for (args_, 1..) |a, i| {
+                args[i] = a;
+            }
+
+            break :brk args;
+        };
+
+        break :result @call(.auto, func, args);
+    };
+
+    return .{ .result = result };
+}
+
+pub fn parse_has(
+    comptime Impl: type,
+    parser: *SelectorParser,
+    input: *css.Parser,
+    state: *SelectorParsingState,
+) Result(GenericComponent(Impl)) {
+    var child_state = state.*;
+    const inner = switch (SelectorList.parseRelativeWithState(
+        parser,
+        input,
+        &child_state,
+        parser.isAndWhereErrorRecovery(),
+        .none,
+    )) {
+        .err => |e| return .{ .err = e },
+        .result => |v| v,
+    };
+
+    if (child_state.after_nesting) {
+        state.after_nesting = true;
+    }
+    return .{ .result = .{ .has = inner.v.toOwnedSlice(input.allocator()) } };
+}
+
+/// Level 3: Parse **one** simple_selector.  (Though we might insert a second
+/// implied "<defaultns>|*" type selector.)
+pub fn parse_negation(
+    comptime Impl: type,
+    parser: *SelectorParser,
+    input: *css.Parser,
+    state: *SelectorParsingState,
+) Result(GenericComponent(Impl)) {
+    var child_state = state.*;
+    child_state.skip_default_namespace = true;
+    child_state.disallow_pseudos = true;
+
+    const list = switch (SelectorList.parseWithState(parser, input, &child_state, .discard_list, .none)) {
+        .err => |e| return .{ .err = e },
+        .result => |v| v,
+    };
+
+    if (child_state.after_nesting) {
+        state.after_nesting = true;
+    }
+
+    return .{ .result = .{ .negation = list.v.toOwnedSlice(input.allocator()) } };
+}
+
+pub fn OptionalQName(comptime Impl: type) type {
+    return union(enum) {
+        some: struct { QNamePrefix(Impl), ?[]const u8 },
+        none: css.Token,
+    };
+}
+
+pub fn QNamePrefix(comptime Impl: type) type {
+    return union(enum) {
+        implicit_no_namespace, // `foo` in attr selectors
+        implicit_any_namespace, // `foo` in type selectors, without a default ns
+        implicit_default_namespace: Impl.SelectorImpl.NamespaceUrl, // `foo` in type selectors, with a default ns
+        explicit_no_namespace, // `|foo`
+        explicit_any_namespace, // `*|foo`
+        explicit_namespace: struct { Impl.SelectorImpl.NamespacePrefix, Impl.SelectorImpl.NamespaceUrl }, // `prefix|foo`
+    };
+}
+
+/// * `Err(())`: Invalid selector, abort
+/// * `Ok(None(token))`: Not a simple selector, could be something else. `input` was not consumed,
+///                      but the token is still returned.
+/// * `Ok(Some(namespace, local_name))`: `None` for the local name means a `*` universal selector
+pub fn parse_qualified_name(
+    comptime Impl: type,
+    parser: *SelectorParser,
+    input: *css.Parser,
+    in_attr_selector: bool,
+) Result(OptionalQName(Impl)) {
+    const start = input.state();
+
+    const tok = switch (input.nextIncludingWhitespace()) {
+        .result => |v| v,
+        .err => |e| {
+            input.reset(&start);
+            return .{ .err = e };
+        },
+    };
+    switch (tok.*) {
+        .ident => |value| {
+            const after_ident = input.state();
+            const n = if (input.nextIncludingWhitespace().asValue()) |t| t.* == .delim and t.delim == '|' else false;
+            if (n) {
+                const prefix: Impl.SelectorImpl.NamespacePrefix = .{ .v = value };
+                const result: ?Impl.SelectorImpl.NamespaceUrl = parser.namespaceForPrefix(prefix);
+                const url: Impl.SelectorImpl.NamespaceUrl = brk: {
+                    if (result) |url| break :brk url;
+                    return .{ .err = input.newCustomError(SelectorParseErrorKind.intoDefaultParserError(.{ .unsupported_pseudo_class_or_element = value })) };
+                };
+                return parse_qualified_name_eplicit_namespace_helper(
+                    Impl,
+                    input,
+                    .{ .explicit_namespace = .{ prefix, url } },
+                    in_attr_selector,
+                );
+            } else {
+                input.reset(&after_ident);
+                if (in_attr_selector) return .{ .result = .{ .some = .{ .implicit_no_namespace, value } } };
+                return .{ .result = parse_qualified_name_default_namespace_helper(Impl, parser, value) };
+            }
+        },
+        .delim => |c| {
+            switch (c) {
+                '*' => {
+                    const after_star = input.state();
+                    const result = input.nextIncludingWhitespace();
+                    if (result.asValue()) |t| if (t.* == .delim and t.delim == '|')
+                        return parse_qualified_name_eplicit_namespace_helper(
+                            Impl,
+                            input,
+                            .explicit_any_namespace,
+                            in_attr_selector,
+                        );
+                    input.reset(&after_star);
+                    if (in_attr_selector) {
+                        switch (result) {
+                            .result => |t| {
+                                return .{ .err = after_star.sourceLocation().newCustomError(SelectorParseErrorKind{
+                                    .expected_bar_in_attr = t.*,
+                                }) };
+                            },
+                            .err => |e| {
+                                return .{ .err = e };
+                            },
+                        }
+                    } else {
+                        return .{ .result = parse_qualified_name_default_namespace_helper(Impl, parser, null) };
+                    }
+                },
+                '|' => return parse_qualified_name_eplicit_namespace_helper(Impl, input, .explicit_no_namespace, in_attr_selector),
+                else => {},
+            }
+        },
+        else => {},
+    }
+    input.reset(&start);
+    return .{ .result = .{ .none = tok.* } };
+}
+
+fn parse_qualified_name_default_namespace_helper(
+    comptime Impl: type,
+    parser: *SelectorParser,
+    local_name: ?[]const u8,
+) OptionalQName(Impl) {
+    const namespace: QNamePrefix(Impl) = if (parser.defaultNamespace()) |url| .{ .implicit_default_namespace = url } else .implicit_any_namespace;
+    return .{
+        .some = .{
+            namespace,
+            local_name,
+        },
+    };
+}
+
+fn parse_qualified_name_eplicit_namespace_helper(
+    comptime Impl: type,
+    input: *css.Parser,
+    namespace: QNamePrefix(Impl),
+    in_attr_selector: bool,
+) Result(OptionalQName(Impl)) {
+    const location = input.currentSourceLocation();
+    const t = switch (input.nextIncludingWhitespace()) {
+        .result => |v| v,
+        .err => |e| return .{ .err = e },
+    };
+    switch (t.*) {
+        .ident => |local_name| return .{ .result = .{ .some = .{ namespace, local_name } } },
+        .delim => |c| {
+            if (c == '*') {
+                return .{ .result = .{ .some = .{ namespace, null } } };
+            }
+        },
+        else => {},
+    }
+    if (in_attr_selector) {
+        const e = SelectorParseErrorKind{ .invalid_qual_name_in_attr = t.* };
+        return .{ .err = location.newCustomError(e) };
+    }
+    return .{ .err = location.newCustomError(SelectorParseErrorKind{ .explicit_namespace_unexpected_token = t.* }) };
+}
+
+pub fn LocalName(comptime Impl: type) type {
+    return struct {
+        name: Impl.SelectorImpl.LocalName,
+        lower_name: Impl.SelectorImpl.LocalName,
+
+        pub fn toCss(this: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+            return css.IdentFns.toCss(&this.name, W, dest);
+        }
+
+        pub fn __generateEql() void {}
+        pub fn __generateDeepClone() void {}
+        pub fn __generateHash() void {}
+    };
+}
+
+/// An attribute selector can have 's' or 'i' as flags, or no flags at all.
+pub const AttributeFlags = enum {
+    // Matching should be case-sensitive ('s' flag).
+    case_sensitive,
+    // Matching should be case-insensitive ('i' flag).
+    ascii_case_insensitive,
+    // No flags.  Matching behavior depends on the name of the attribute.
+    case_sensitivity_depends_on_name,
+
+    pub fn toCaseSensitivity(this: AttributeFlags, local_name: []const u8, have_namespace: bool) attrs.ParsedCaseSensitivity {
+        return switch (this) {
+            .case_sensitive => .explicit_case_sensitive,
+            .ascii_case_insensitive => .ascii_case_insensitive,
+            .case_sensitivity_depends_on_name => {
+                // <https://html.spec.whatwg.org/multipage/#selectors>
+                const AsciiCaseInsensitiveHtmlAttributes = enum {
+                    dir,
+                    http_equiv,
+                    rel,
+                    enctype,
+                    @"align",
+                    accept,
+                    nohref,
+                    lang,
+                    bgcolor,
+                    direction,
+                    valign,
+                    checked,
+                    frame,
+                    link,
+                    accept_charset,
+                    hreflang,
+                    text,
+                    valuetype,
+                    language,
+                    nowrap,
+                    vlink,
+                    disabled,
+                    noshade,
+                    codetype,
+                    @"defer",
+                    noresize,
+                    target,
+                    scrolling,
+                    rules,
+                    scope,
+                    rev,
+                    media,
+                    method,
+                    charset,
+                    alink,
+                    selected,
+                    multiple,
+                    color,
+                    shape,
+                    type,
+                    clear,
+                    compact,
+                    face,
+                    declare,
+                    axis,
+                    readonly,
+                };
+                const Map = comptime bun.ComptimeEnumMap(AsciiCaseInsensitiveHtmlAttributes);
+                if (!have_namespace and Map.has(local_name)) return .ascii_case_insensitive_if_in_html_element_in_html_document;
+                return .case_sensitive;
+            },
+        };
+    }
+};
+
+/// A [view transition part name](https://w3c.github.io/csswg-drafts/css-view-transitions-1/#typedef-pt-name-selector).
+pub const ViewTransitionPartName = union(enum) {
+    /// *
+    all,
+    /// <custom-ident>
+    name: css.css_values.ident.CustomIdent,
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+        return switch (this.*) {
+            .all => try dest.writeStr("*"),
+            .name => |name| try css.CustomIdentFns.toCss(&name, W, dest),
+        };
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+        return css.implementHash(@This(), this, hasher);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+pub fn parse_attribute_flags(input: *css.Parser) Result(AttributeFlags) {
+    const location = input.currentSourceLocation();
+    const token = switch (input.next()) {
+        .result => |v| v,
+        .err => {
+            // Selectors spec says language-defined; HTML says it depends on the
+            // exact attribute name.
+            return .{ .result = AttributeFlags.case_sensitivity_depends_on_name };
+        },
+    };
+
+    const ident = if (token.* == .ident) token.ident else return .{ .err = location.newBasicUnexpectedTokenError(token.*) };
+
+    if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(ident, "i")) {
+        return .{ .result = AttributeFlags.ascii_case_insensitive };
+    } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(ident, "s")) {
+        return .{ .result = AttributeFlags.case_sensitive };
+    } else {
+        return .{ .err = location.newBasicUnexpectedTokenError(token.*) };
+    }
+}
diff --git a/src/css/selectors/selector.zig b/src/css/selectors/selector.zig
new file mode 100644
index 0000000000..84364080ae
--- /dev/null
+++ b/src/css/selectors/selector.zig
@@ -0,0 +1,1608 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const bun = @import("root").bun;
+const logger = bun.logger;
+const Log = logger.Log;
+
+pub const css = @import("../css_parser.zig");
+const CSSString = css.CSSString;
+const CSSStringFns = css.CSSStringFns;
+
+pub const Printer = css.Printer;
+pub const PrintErr = css.PrintErr;
+
+const Result = css.Result;
+const PrintResult = css.PrintResult;
+
+const ArrayList = std.ArrayListUnmanaged;
+
+pub const Selector = parser.Selector;
+pub const SelectorList = parser.SelectorList;
+pub const Component = parser.Component;
+pub const PseudoClass = parser.PseudoClass;
+pub const PseudoElement = parser.PseudoElement;
+
+const debug = bun.Output.scoped(.CSS_SELECTORS, false);
+
+/// Our implementation of the `SelectorImpl` interface
+///
+pub const impl = struct {
+    pub const Selectors = struct {
+        pub const SelectorImpl = struct {
+            pub const AttrValue = css.css_values.string.CSSString;
+            pub const Identifier = css.css_values.ident.Ident;
+            pub const LocalName = css.css_values.ident.Ident;
+            pub const NamespacePrefix = css.css_values.ident.Ident;
+            pub const NamespaceUrl = []const u8;
+            pub const BorrowedNamespaceUrl = []const u8;
+            pub const BorrowedLocalName = css.css_values.ident.Ident;
+
+            pub const NonTSPseudoClass = parser.PseudoClass;
+            pub const PseudoElement = parser.PseudoElement;
+            pub const VendorPrefix = css.VendorPrefix;
+            pub const ExtraMatchingData = void;
+        };
+    };
+};
+
+pub const parser = @import("./parser.zig");
+
+/// Returns whether two selector lists are equivalent, i.e. the same minus any vendor prefix differences.
+pub fn isEquivalent(selectors: []const Selector, other: []const Selector) bool {
+    if (selectors.len != other.len) return false;
+
+    for (selectors, 0..) |*a, i| {
+        const b = &other[i];
+        if (a.len() != b.len()) return false;
+
+        for (a.components.items, b.components.items) |*a_comp, *b_comp| {
+            const is_equivalent = blk: {
+                if (a_comp.* == .non_ts_pseudo_class and b_comp.* == .non_ts_pseudo_class) {
+                    break :blk a_comp.non_ts_pseudo_class.isEquivalent(&b_comp.non_ts_pseudo_class);
+                } else if (a_comp.* == .pseudo_element and b_comp.* == .pseudo_element) {
+                    break :blk a_comp.pseudo_element.isEquivalent(&b_comp.pseudo_element);
+                } else if ((a_comp.* == .any and b_comp.* == .is) or
+                    (a_comp.* == .is and b_comp.* == .any) or
+                    (a_comp.* == .any and b_comp.* == .any) or
+                    (a_comp.* == .is and b_comp.* == .is))
+                {
+                    const a_selectors = switch (a_comp.*) {
+                        .any => |v| v.selectors,
+                        .is => |v| v,
+                        else => unreachable,
+                    };
+                    const b_selectors = switch (b_comp.*) {
+                        .any => |v| v.selectors,
+                        .is => |v| v,
+                        else => unreachable,
+                    };
+                    break :blk isEquivalent(a_selectors, b_selectors);
+                } else {
+                    break :blk Component.eql(a_comp, b_comp);
+                }
+            };
+
+            if (!is_equivalent) {
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
+/// Downlevels the given selectors to be compatible with the given browser targets.
+/// Returns the necessary vendor prefixes.
+pub fn downlevelSelectors(allocator: Allocator, selectors: []Selector, targets: css.targets.Targets) css.VendorPrefix {
+    var necessary_prefixes = css.VendorPrefix.empty();
+    for (selectors) |*selector| {
+        for (selector.components.items) |*component| {
+            necessary_prefixes.insert(downlevelComponent(allocator, component, targets));
+        }
+    }
+    return necessary_prefixes;
+}
+
+pub fn downlevelComponent(allocator: Allocator, component: *Component, targets: css.targets.Targets) css.VendorPrefix {
+    return switch (component.*) {
+        .non_ts_pseudo_class => |*pc| {
+            return switch (pc.*) {
+                .dir => |*d| {
+                    if (targets.shouldCompileSame(.dir_selector)) {
+                        component.* = downlevelDir(allocator, d.direction, targets);
+                        return downlevelComponent(allocator, component, targets);
+                    }
+                    return css.VendorPrefix.empty();
+                },
+                .lang => |l| {
+                    // :lang() with multiple languages is not supported everywhere.
+                    // compile this to :is(:lang(a), :lang(b)) etc.
+                    if (l.languages.items.len > 1 and targets.shouldCompileSame(.lang_selector_list)) {
+                        component.* = .{ .is = langListToSelectors(allocator, l.languages.items) };
+                        return downlevelComponent(allocator, component, targets);
+                    }
+                    return css.VendorPrefix.empty();
+                },
+                else => pc.getNecessaryPrefixes(targets),
+            };
+        },
+        .pseudo_element => |*pe| pe.getNecessaryPrefixes(targets),
+        .is => |selectors| {
+            var necessary_prefixes = downlevelSelectors(allocator, selectors, targets);
+
+            // Convert :is to :-webkit-any/:-moz-any if needed.
+            // All selectors must be simple, no combinators are supported.
+            if (targets.shouldCompileSame(.is_selector) and
+                !shouldUnwrapIs(selectors) and brk: {
+                for (selectors) |*selector| {
+                    if (selector.hasCombinator()) break :brk false;
+                }
+                break :brk true;
+            }) {
+                necessary_prefixes.insert(targets.prefixes(css.VendorPrefix{ .none = true }, .any_pseudo));
+            } else {
+                necessary_prefixes.insert(css.VendorPrefix{ .none = true });
+            }
+
+            return necessary_prefixes;
+        },
+        .negation => |selectors| {
+            var necessary_prefixes = downlevelSelectors(allocator, selectors, targets);
+
+            // Downlevel :not(.a, .b) -> :not(:is(.a, .b)) if not list is unsupported.
+            // We need to use :is() / :-webkit-any() rather than :not(.a):not(.b) to ensure the specificity is equivalent.
+            // https://drafts.csswg.org/selectors/#specificity-rules
+            if (selectors.len > 1 and css.targets.Targets.shouldCompileSame(&targets, .not_selector_list)) {
+                const is: Selector = Selector.fromComponent(allocator, Component{ .is = selectors: {
+                    const new_selectors = allocator.alloc(Selector, selectors.len) catch bun.outOfMemory();
+                    for (new_selectors, selectors) |*new, *sel| {
+                        new.* = sel.deepClone(allocator);
+                    }
+                    break :selectors new_selectors;
+                } });
+                var list = ArrayList(Selector).initCapacity(allocator, 1) catch bun.outOfMemory();
+                list.appendAssumeCapacity(is);
+                component.* = .{ .negation = list.items };
+
+                if (targets.shouldCompileSame(.is_selector)) {
+                    necessary_prefixes.insert(targets.prefixes(css.VendorPrefix{ .none = true }, .any_pseudo));
+                } else {
+                    necessary_prefixes.insert(css.VendorPrefix{ .none = true });
+                }
+            }
+
+            return necessary_prefixes;
+        },
+        .where, .has => |s| downlevelSelectors(allocator, s, targets),
+        .any => |*a| downlevelSelectors(allocator, a.selectors, targets),
+        else => css.VendorPrefix.empty(),
+    };
+}
+
+const RTL_LANGS: []const []const u8 = &.{
+    "ae", "ar", "arc", "bcc", "bqi", "ckb", "dv", "fa", "glk", "he", "ku", "mzn", "nqo", "pnb", "ps", "sd", "ug",
+    "ur", "yi",
+};
+
+fn downlevelDir(allocator: Allocator, dir: parser.Direction, targets: css.targets.Targets) Component {
+    // Convert :dir to :lang. If supported, use a list of languages in a single :lang,
+    // otherwise, use :is/:not, which may be further downleveled to e.g. :-webkit-any.
+    if (!targets.shouldCompileSame(.lang_selector_list)) {
+        const c = Component{
+            .non_ts_pseudo_class = PseudoClass{
+                .lang = .{ .languages = lang: {
+                    var list = ArrayList([]const u8).initCapacity(allocator, RTL_LANGS.len) catch bun.outOfMemory();
+                    list.appendSliceAssumeCapacity(RTL_LANGS);
+                    break :lang list;
+                } },
+            },
+        };
+        if (dir == .ltr) return Component{
+            .negation = negation: {
+                var list = allocator.alloc(Selector, 1) catch bun.outOfMemory();
+                list[0] = Selector.fromComponent(allocator, c);
+                break :negation list;
+            },
+        };
+        return c;
+    } else {
+        if (dir == .ltr) return Component{ .negation = langListToSelectors(allocator, RTL_LANGS) };
+        return Component{ .is = langListToSelectors(allocator, RTL_LANGS) };
+    }
+}
+
+fn langListToSelectors(allocator: Allocator, langs: []const []const u8) []Selector {
+    var selectors = allocator.alloc(Selector, langs.len) catch bun.outOfMemory();
+    for (langs, selectors[0..]) |lang, *sel| {
+        sel.* = Selector.fromComponent(allocator, Component{
+            .non_ts_pseudo_class = PseudoClass{
+                .lang = .{ .languages = langs: {
+                    var list = ArrayList([]const u8).initCapacity(allocator, 1) catch bun.outOfMemory();
+                    list.appendAssumeCapacity(lang);
+                    break :langs list;
+                } },
+            },
+        });
+    }
+    return selectors;
+}
+
+/// Returns the vendor prefix (if any) used in the given selector list.
+/// If multiple vendor prefixes are seen, this is invalid, and an empty result is returned.
+pub fn getPrefix(selectors: *const SelectorList) css.VendorPrefix {
+    var prefix = css.VendorPrefix.empty();
+    for (selectors.v.slice()) |*selector| {
+        for (selector.components.items) |*component_| {
+            const component: *const Component = component_;
+            const p = switch (component.*) {
+                // Return none rather than empty for these so that we call downlevel_selectors.
+                .non_ts_pseudo_class => |*pc| switch (pc.*) {
+                    .lang => css.VendorPrefix{ .none = true },
+                    .dir => css.VendorPrefix{ .none = true },
+                    else => pc.getPrefix(),
+                },
+                .is => css.VendorPrefix{ .none = true },
+                .where => css.VendorPrefix{ .none = true },
+                .has => css.VendorPrefix{ .none = true },
+                .negation => css.VendorPrefix{ .none = true },
+                .any => |*any| any.vendor_prefix,
+                .pseudo_element => |*pe| pe.getPrefix(),
+                else => css.VendorPrefix.empty(),
+            };
+
+            if (!p.isEmpty()) {
+                // Allow none to be mixed with a prefix.
+                const prefix_without_none = prefix.maskOut(css.VendorPrefix{ .none = true });
+                if (prefix_without_none.isEmpty() or prefix_without_none.eql(p)) {
+                    prefix.insert(p);
+                } else {
+                    return css.VendorPrefix.empty();
+                }
+            }
+        }
+    }
+
+    return prefix;
+}
+
+pub fn isCompatible(selectors: []const parser.Selector, targets: css.targets.Targets) bool {
+    const F = css.compat.Feature;
+    for (selectors) |*selector| {
+        for (selector.components.items) |*component| {
+            const feature = switch (component.*) {
+                .id, .class, .local_name => continue,
+
+                .explicit_any_namespace,
+                .explicit_no_namespace,
+                .default_namespace,
+                .namespace,
+                => F.namespaces,
+
+                .explicit_universal_type => F.selectors2,
+
+                .attribute_in_no_namespace_exists => F.selectors2,
+
+                .attribute_in_no_namespace => |x| brk: {
+                    if (x.case_sensitivity != parser.attrs.ParsedCaseSensitivity.case_sensitive) break :brk F.case_insensitive;
+                    break :brk switch (x.operator) {
+                        .equal, .includes, .dash_match => F.selectors2,
+                        .prefix, .substring, .suffix => F.selectors3,
+                    };
+                },
+
+                .attribute_other => |attr| switch (attr.operation) {
+                    .exists => F.selectors2,
+                    .with_value => |*x| brk: {
+                        if (x.case_sensitivity != parser.attrs.ParsedCaseSensitivity.case_sensitive) break :brk F.case_insensitive;
+
+                        break :brk switch (x.operator) {
+                            .equal, .includes, .dash_match => F.selectors2,
+                            .prefix, .substring, .suffix => F.selectors3,
+                        };
+                    },
+                },
+
+                .empty, .root => F.selectors3,
+                .negation => |sels| {
+                    // :not() selector list is not forgiving.
+                    if (!targets.isCompatible(F.selectors3) or !isCompatible(sels, targets)) return false;
+                    continue;
+                },
+
+                .nth => |*data| brk: {
+                    if (data.ty == .child and data.a == 0 and data.b == 1) break :brk F.selectors2;
+                    if (data.ty == .col or data.ty == .last_col) return false;
+                    break :brk F.selectors3;
+                },
+                .nth_of => |*n| {
+                    if (!targets.isCompatible(F.nth_child_of) or !isCompatible(n.selectors, targets)) return false;
+                    continue;
+                },
+
+                // These support forgiving selector lists, so no need to check nested selectors.
+                .is => |sels| brk: {
+                    // ... except if we are going to unwrap them.
+                    if (shouldUnwrapIs(sels) and isCompatible(sels, targets)) continue;
+                    break :brk F.is_selector;
+                },
+                .where, .nesting => F.is_selector,
+                .any => return false,
+                .has => |sels| {
+                    if (!targets.isCompatible(F.has_selector) or !isCompatible(sels, targets)) return false;
+                    continue;
+                },
+
+                .scope, .host, .slotted => F.shadowdomv1,
+
+                .part => F.part_pseudo,
+
+                .non_ts_pseudo_class => |*pseudo| brk: {
+                    switch (pseudo.*) {
+                        .link, .visited, .active, .hover, .focus, .lang => break :brk F.selectors2,
+
+                        .checked, .disabled, .enabled, .target => break :brk F.selectors3,
+
+                        .any_link => |prefix| {
+                            if (prefix.eql(css.VendorPrefix{ .none = true })) break :brk F.any_link;
+                        },
+                        .indeterminate => break :brk F.indeterminate_pseudo,
+
+                        .fullscreen => |prefix| {
+                            if (prefix.eql(css.VendorPrefix{ .none = true })) break :brk F.fullscreen;
+                        },
+
+                        .focus_visible => break :brk F.focus_visible,
+                        .focus_within => break :brk F.focus_within,
+                        .default => break :brk F.default_pseudo,
+                        .dir => break :brk F.dir_selector,
+                        .optional => break :brk F.optional_pseudo,
+                        .placeholder_shown => |prefix| {
+                            if (prefix.eql(css.VendorPrefix{ .none = true })) break :brk F.placeholder_shown;
+                        },
+
+                        inline .read_only, .read_write => |prefix| {
+                            if (prefix.eql(css.VendorPrefix{ .none = true })) break :brk F.read_only_write;
+                        },
+
+                        .valid, .invalid, .required => break :brk F.form_validation,
+                        .in_range, .out_of_range => break :brk F.in_out_of_range,
+
+                        .autofill => |prefix| {
+                            if (prefix.eql(css.VendorPrefix{ .none = true })) break :brk F.autofill;
+                        },
+
+                        // Experimental, no browser support.
+                        .current,
+                        .past,
+                        .future,
+                        .playing,
+                        .paused,
+                        .seeking,
+                        .stalled,
+                        .buffering,
+                        .muted,
+                        .volume_locked,
+                        .target_within,
+                        .local_link,
+                        .blank,
+                        .user_invalid,
+                        .user_valid,
+                        .defined,
+                        => return false,
+
+                        .custom => {},
+
+                        else => {},
+                    }
+                    return false;
+                },
+
+                .pseudo_element => |*pseudo| brk: {
+                    switch (pseudo.*) {
+                        .after, .before => break :brk F.gencontent,
+                        .first_line => break :brk F.first_line,
+                        .first_letter => break :brk F.first_letter,
+                        .selection => |prefix| {
+                            if (prefix.eql(css.VendorPrefix{ .none = true })) break :brk F.selection;
+                        },
+                        .placeholder => |prefix| {
+                            if (prefix.eql(css.VendorPrefix{ .none = true })) break :brk F.placeholder;
+                        },
+                        .marker => break :brk F.marker_pseudo,
+                        .backdrop => |prefix| {
+                            if (prefix.eql(css.VendorPrefix{ .none = true })) break :brk F.dialog;
+                        },
+                        .cue => break :brk F.cue,
+                        .cue_function => break :brk F.cue_function,
+                        .custom => return false,
+                        else => {},
+                    }
+                    return false;
+                },
+
+                .combinator => |*combinator| brk: {
+                    break :brk switch (combinator.*) {
+                        .child, .next_sibling => F.selectors2,
+                        .later_sibling => F.selectors3,
+                        else => continue,
+                    };
+                },
+            };
+
+            if (!targets.isCompatible(feature)) return false;
+        }
+    }
+
+    return true;
+}
+
+/// Determines whether a selector list contains only unused selectors.
+/// A selector is considered unused if it contains a class or id component that exists in the set of unused symbols.
+pub fn isUnused(
+    selectors: []const parser.Selector,
+    unused_symbols: *const std.StringArrayHashMapUnmanaged(void),
+    parent_is_unused: bool,
+) bool {
+    if (unused_symbols.count() == 0) return false;
+
+    for (selectors) |*selector| {
+        if (!isSelectorUnused(selector, unused_symbols, parent_is_unused)) return false;
+    }
+
+    return true;
+}
+
+fn isSelectorUnused(
+    selector: *const parser.Selector,
+    unused_symbols: *const std.StringArrayHashMapUnmanaged(void),
+    parent_is_unused: bool,
+) bool {
+    for (selector.components.items) |*component| {
+        switch (component.*) {
+            .class, .id => |ident| {
+                if (unused_symbols.contains(ident.v)) return true;
+            },
+            .is, .where => |is| {
+                if (isUnused(is, unused_symbols, parent_is_unused)) return true;
+            },
+            .any => |any| {
+                if (isUnused(any.selectors, unused_symbols, parent_is_unused)) return true;
+            },
+            .nesting => {
+                if (parent_is_unused) return true;
+            },
+            else => {},
+        }
+    }
+    return false;
+}
+
+/// The serialization module ported from lightningcss.
+///
+/// Note that we have two serialization modules, one from lightningcss and one from servo.
+///
+/// This is because it actually uses both implementations. This is confusing.
+pub const serialize = struct {
+    pub fn serializeSelectorList(
+        list: []const parser.Selector,
+        comptime W: type,
+        dest: *Printer(W),
+        context: ?*const css.StyleContext,
+        is_relative: bool,
+    ) PrintErr!void {
+        var first = true;
+        for (list) |*selector| {
+            if (!first) {
+                try dest.delim(',', false);
+            }
+            first = false;
+            try serializeSelector(selector, W, dest, context, is_relative);
+        }
+    }
+
+    pub fn serializeSelector(
+        selector: *const parser.Selector,
+        comptime W: type,
+        dest: *css.Printer(W),
+        context: ?*const css.StyleContext,
+        __is_relative: bool,
+    ) PrintErr!void {
+        var is_relative = __is_relative;
+
+        if (comptime bun.Environment.isDebug) {
+            debug("Selector components:\n", .{});
+            for (selector.components.items) |*comp| {
+                debug(" {}\n", .{comp});
+            }
+
+            debug("Compound selector iter\n", .{});
+            var compound_selectors = CompoundSelectorIter{ .sel = selector };
+            while (compound_selectors.next()) |comp| {
+                for (comp) |c| {
+                    debug("  {}, ", .{c});
+                }
+            }
+            debug("\n", .{});
+        }
+
+        // Compound selectors invert the order of their contents, so we need to
+        // undo that during serialization.
+        //
+        // This two-iterator strategy involves walking over the selector twice.
+        // We could do something more clever, but selector serialization probably
+        // isn't hot enough to justify it, and the stringification likely
+        // dominates anyway.
+        //
+        // NB: A parse-order iterator is a Rev<>, which doesn't expose as_slice(),
+        // which we need for |split|. So we split by combinators on a match-order
+        // sequence and then reverse.
+        var combinators = CombinatorIter{ .sel = selector };
+        var compound_selectors = CompoundSelectorIter{ .sel = selector };
+        const should_compile_nesting = dest.targets.shouldCompileSame(.nesting);
+
+        var first = true;
+        var combinators_exhausted = false;
+        while (compound_selectors.next()) |_compound_| {
+            bun.debugAssert(!combinators_exhausted);
+            var compound = _compound_;
+
+            // Skip implicit :scope in relative selectors (e.g. :has(:scope > foo) -> :has(> foo))
+            if (is_relative and compound.len >= 1 and compound[0] == .scope) {
+                if (combinators.next()) |*combinator| {
+                    try serializeCombinator(combinator, W, dest);
+                }
+                compound = compound[1..];
+                is_relative = false;
+            }
+
+            // https://drafts.csswg.org/cssom/#serializing-selectors
+            if (compound.len == 0) continue;
+
+            const has_leading_nesting = first and compound[0] == .nesting;
+            const first_index: usize = if (has_leading_nesting) 1 else 0;
+            first = false;
+
+            // 1. If there is only one simple selector in the compound selectors
+            //    which is a universal selector, append the result of
+            //    serializing the universal selector to s.
+            //
+            // Check if `!compound.empty()` first--this can happen if we have
+            // something like `... > ::before`, because we store `>` and `::`
+            // both as combinators internally.
+            //
+            // If we are in this case, after we have serialized the universal
+            // selector, we skip Step 2 and continue with the algorithm.
+            const can_elide_namespace, const first_non_namespace = if (first_index >= compound.len)
+                .{ true, first_index }
+            else switch (compound[0]) {
+                .explicit_any_namespace, .explicit_no_namespace, .namespace => .{ false, first_index + 1 },
+                .default_namespace => .{ true, first_index + 1 },
+                else => .{ true, first_index },
+            };
+            var perform_step_2 = true;
+            const next_combinator = combinators.next();
+            if (first_non_namespace == compound.len - 1) {
+                // We have to be careful here, because if there is a
+                // pseudo element "combinator" there isn't really just
+                // the one simple selector. Technically this compound
+                // selector contains the pseudo element selector as well
+                // -- Combinator::PseudoElement, just like
+                // Combinator::SlotAssignment, don't exist in the
+                // spec.
+                if (next_combinator == .pseudo_element and compound[first_non_namespace].asCombinator() == .slot_assignment) {
+                    // do nothing
+                } else if (compound[first_non_namespace] == .explicit_universal_type) {
+                    // Iterate over everything so we serialize the namespace
+                    // too.
+                    const swap_nesting = has_leading_nesting and should_compile_nesting;
+                    const slice = if (swap_nesting) brk: {
+                        // Swap nesting and type selector (e.g. &div -> div&).
+                        break :brk compound[@min(1, compound.len)..];
+                    } else compound;
+
+                    for (slice) |*simple| {
+                        try serializeComponent(simple, W, dest, context);
+                    }
+
+                    if (swap_nesting) {
+                        try serializeNesting(W, dest, context, false);
+                    }
+
+                    // Skip step 2, which is an "otherwise".
+                    perform_step_2 = false;
+                } else {
+                    // do nothing
+                }
+            }
+
+            // 2. Otherwise, for each simple selector in the compound selectors
+            //    that is not a universal selector of which the namespace prefix
+            //    maps to a namespace that is not the default namespace
+            //    serialize the simple selector and append the result to s.
+            //
+            // See https://github.com/w3c/csswg-drafts/issues/1606, which is
+            // proposing to change this to match up with the behavior asserted
+            // in cssom/serialize-namespaced-type-selectors.html, which the
+            // following code tries to match.
+            if (perform_step_2) {
+                const iter = compound;
+                var i: usize = 0;
+                if (has_leading_nesting and
+                    should_compile_nesting and
+                    isTypeSelector(if (first_non_namespace < compound.len) &compound[first_non_namespace] else null))
+                {
+                    // Swap nesting and type selector (e.g. &div -> div&).
+                    // This ensures that the compiled selector is valid. e.g. (div.foo is valid, .foodiv is not).
+                    const nesting = &iter[i];
+                    i += 1;
+                    const local = &iter[i];
+                    i += 1;
+                    try serializeComponent(local, W, dest, context);
+
+                    // Also check the next item in case of namespaces.
+                    if (first_non_namespace > first_index) {
+                        const local2 = &iter[i];
+                        i += 1;
+                        try serializeComponent(local2, W, dest, context);
+                    }
+
+                    try serializeComponent(nesting, W, dest, context);
+                } else if (has_leading_nesting and should_compile_nesting) {
+                    // Nesting selector may serialize differently if it is leading, due to type selectors.
+                    i += 1;
+                    try serializeNesting(W, dest, context, true);
+                }
+
+                if (i < compound.len) {
+                    for (iter[i..]) |*simple| {
+                        if (simple.* == .explicit_universal_type) {
+                            // Can't have a namespace followed by a pseudo-element
+                            // selector followed by a universal selector in the same
+                            // compound selector, so we don't have to worry about the
+                            // real namespace being in a different `compound`.
+                            if (can_elide_namespace) {
+                                continue;
+                            }
+                        }
+                        try serializeComponent(simple, W, dest, context);
+                    }
+                }
+            }
+
+            // 3. If this is not the last part of the chain of the selector
+            //    append a single SPACE (U+0020), followed by the combinator
+            //    ">", "+", "~", ">>", "||", as appropriate, followed by another
+            //    single SPACE (U+0020) if the combinator was not whitespace, to
+            //    s.
+            if (next_combinator) |*c| {
+                try serializeCombinator(c, W, dest);
+            } else {
+                combinators_exhausted = true;
+            }
+
+            // 4. If this is the last part of the chain of the selector and
+            //    there is a pseudo-element, append "::" followed by the name of
+            //    the pseudo-element, to s.
+            //
+            // (we handle this above)
+        }
+    }
+
+    pub fn serializeComponent(
+        component: *const parser.Component,
+        comptime W: type,
+        dest: *css.Printer(W),
+        context: ?*const css.StyleContext,
+    ) PrintErr!void {
+        switch (component.*) {
+            .combinator => |c| return serializeCombinator(&c, W, dest),
+            .attribute_in_no_namespace => |*v| {
+                try dest.writeChar('[');
+                try css.css_values.ident.IdentFns.toCss(&v.local_name, W, dest);
+                try v.operator.toCss(W, dest);
+
+                if (dest.minify) {
+                    // PERF: should we put a scratch buffer in the printer
+                    // Serialize as both an identifier and a string and choose the shorter one.
+                    var id = std.ArrayList(u8).init(dest.allocator);
+                    const writer = id.writer();
+                    css.serializer.serializeIdentifier(v.value, writer) catch return dest.addFmtError();
+
+                    const s = try css.to_css.string(dest.allocator, CSSString, &v.value, css.PrinterOptions{}, dest.import_records);
+
+                    if (id.items.len > 0 and id.items.len < s.len) {
+                        try dest.writeStr(id.items);
+                    } else {
+                        try dest.writeStr(s);
+                    }
+                } else {
+                    try css.CSSStringFns.toCss(&v.value, W, dest);
+                }
+
+                switch (v.case_sensitivity) {
+                    .case_sensitive, .ascii_case_insensitive_if_in_html_element_in_html_document => {},
+                    .ascii_case_insensitive => try dest.writeStr(" i"),
+                    .explicit_case_sensitive => try dest.writeStr(" s"),
+                }
+                return dest.writeChar(']');
+            },
+            .is, .where, .negation, .any => {
+                switch (component.*) {
+                    .where => try dest.writeStr(":where("),
+                    .is => |selectors| {
+                        // If there's only one simple selector, serialize it directly.
+                        if (shouldUnwrapIs(selectors)) {
+                            return serializeSelector(&selectors[0], W, dest, context, false);
+                        }
+
+                        const vp = dest.vendor_prefix;
+                        if (vp.intersects(css.VendorPrefix{ .webkit = true, .moz = true })) {
+                            try dest.writeChar(':');
+                            try vp.toCss(W, dest);
+                            try dest.writeStr("any(");
+                        } else {
+                            try dest.writeStr(":is(");
+                        }
+                    },
+                    .negation => {
+                        try dest.writeStr(":not(");
+                    },
+                    .any => |v| {
+                        const vp = dest.vendor_prefix.bitwiseOr(v.vendor_prefix);
+                        if (vp.intersects(css.VendorPrefix{ .webkit = true, .moz = true })) {
+                            try dest.writeChar(':');
+                            try vp.toCss(W, dest);
+                            try dest.writeStr("any(");
+                        } else {
+                            try dest.writeStr(":is(");
+                        }
+                    },
+                    else => unreachable,
+                }
+                try serializeSelectorList(switch (component.*) {
+                    .where, .is, .negation => |list| list,
+                    .any => |v| v.selectors,
+                    else => unreachable,
+                }, W, dest, context, false);
+                return dest.writeStr(")");
+            },
+            .has => |list| {
+                try dest.writeStr(":has(");
+                try serializeSelectorList(list, W, dest, context, true);
+                return dest.writeStr(")");
+            },
+            .non_ts_pseudo_class => |*pseudo| {
+                return serializePseudoClass(pseudo, W, dest, context);
+            },
+            .pseudo_element => |*pseudo| {
+                return serializePseudoElement(pseudo, W, dest, context);
+            },
+            .nesting => {
+                return serializeNesting(W, dest, context, false);
+            },
+            .class => |class| {
+                try dest.writeChar('.');
+                return dest.writeIdent(class.v, true);
+            },
+            .id => |id| {
+                try dest.writeChar('#');
+                return dest.writeIdent(id.v, true);
+            },
+            .host => |selector| {
+                try dest.writeStr(":host");
+                if (selector) |*sel| {
+                    try dest.writeChar('(');
+                    try serializeSelector(sel, W, dest, dest.context(), false);
+                    try dest.writeChar(')');
+                }
+                return;
+            },
+            .slotted => |*selector| {
+                try dest.writeStr("::slotted(");
+                try serializeSelector(selector, W, dest, dest.context(), false);
+                try dest.writeChar(')');
+            },
+            // .nth => |nth_data| {
+            //     try nth_data.writeStart(W, dest, nth_data.isFunction());
+            //     if (nth_data.isFunction()) {
+            //         try nth_data.writeAffine(W, dest);
+            //         try dest.writeChar(')');
+            //     }
+            // },
+
+            else => {
+                try tocss_servo.toCss_Component(component, W, dest);
+            },
+        }
+    }
+
+    pub fn serializeCombinator(
+        combinator: *const parser.Combinator,
+        comptime W: type,
+        dest: *Printer(W),
+    ) PrintErr!void {
+        switch (combinator.*) {
+            .child => try dest.delim('>', true),
+            .descendant => try dest.writeStr(" "),
+            .next_sibling => try dest.delim('+', true),
+            .later_sibling => try dest.delim('~', true),
+            .deep => try dest.writeStr(" /deep/ "),
+            .deep_descendant => {
+                try dest.whitespace();
+                try dest.writeStr(">>>");
+                try dest.whitespace();
+            },
+            .pseudo_element, .part, .slot_assignment => return,
+        }
+    }
+
+    pub fn serializePseudoClass(
+        pseudo_class: *const parser.PseudoClass,
+        comptime W: type,
+        dest: *Printer(W),
+        context: ?*const css.StyleContext,
+    ) PrintErr!void {
+        switch (pseudo_class.*) {
+            .lang => {
+                try dest.writeStr(":lang(");
+                var first = true;
+                for (pseudo_class.lang.languages.items) |lang| {
+                    if (first) {
+                        first = false;
+                    } else {
+                        try dest.delim(',', false);
+                    }
+                    css.serializer.serializeIdentifier(lang, dest) catch return dest.addFmtError();
+                }
+                return dest.writeStr(")");
+            },
+            .dir => {
+                const dir = pseudo_class.dir.direction;
+                try dest.writeStr(":dir(");
+                try dir.toCss(W, dest);
+                return try dest.writeStr(")");
+            },
+            else => {},
+        }
+
+        const Helpers = struct {
+            pub inline fn writePrefixed(
+                d: *Printer(W),
+                prefix: css.VendorPrefix,
+                comptime val: []const u8,
+            ) PrintErr!void {
+                try d.writeChar(':');
+                // If the printer has a vendor prefix override, use that.
+                const vp = if (!d.vendor_prefix.isEmpty())
+                    d.vendor_prefix.bitwiseOr(prefix).orNone()
+                else
+                    prefix;
+
+                try vp.toCss(W, d);
+                try d.writeStr(val);
+            }
+            pub inline fn pseudo(
+                d: *Printer(W),
+                comptime key: []const u8,
+                comptime s: []const u8,
+            ) PrintErr!void {
+                const key_snake_case = comptime key_snake_case: {
+                    var buf: [key.len]u8 = undefined;
+                    for (key, 0..) |c, i| {
+                        buf[i] = if (c >= 'A' and c <= 'Z') c + 32 else if (c == '-') '_' else c;
+                    }
+                    const buf2 = buf;
+                    break :key_snake_case buf2;
+                };
+                const _class = if (d.pseudo_classes) |*pseudo_classes| @field(pseudo_classes, &key_snake_case) else null;
+
+                if (_class) |class| {
+                    try d.writeChar('.');
+                    try d.writeIdent(class, true);
+                } else {
+                    try d.writeStr(s);
+                }
+            }
+        };
+
+        switch (pseudo_class.*) {
+            // https://drafts.csswg.org/selectors-4/#useraction-pseudos
+            .hover => try Helpers.pseudo(dest, "hover", ":hover"),
+            .active => try Helpers.pseudo(dest, "active", ":active"),
+            .focus => try Helpers.pseudo(dest, "focus", ":focus"),
+            .focus_visible => try Helpers.pseudo(dest, "focus-visible", ":focus-visible"),
+            .focus_within => try Helpers.pseudo(dest, "focus-within", ":focus-within"),
+
+            // https://drafts.csswg.org/selectors-4/#time-pseudos
+            .current => try dest.writeStr(":current"),
+            .past => try dest.writeStr(":past"),
+            .future => try dest.writeStr(":future"),
+
+            // https://drafts.csswg.org/selectors-4/#resource-pseudos
+            .playing => try dest.writeStr(":playing"),
+            .paused => try dest.writeStr(":paused"),
+            .seeking => try dest.writeStr(":seeking"),
+            .buffering => try dest.writeStr(":buffering"),
+            .stalled => try dest.writeStr(":stalled"),
+            .muted => try dest.writeStr(":muted"),
+            .volume_locked => try dest.writeStr(":volume-locked"),
+
+            // https://fullscreen.spec.whatwg.org/#:fullscreen-pseudo-class
+            .fullscreen => |prefix| {
+                try dest.writeChar(':');
+                const vp = if (!dest.vendor_prefix.isEmpty())
+                    dest.vendor_prefix.bitwiseAnd(prefix).orNone()
+                else
+                    prefix;
+                try vp.toCss(W, dest);
+                if (vp.webkit or vp.moz) {
+                    try dest.writeStr("full-screen");
+                } else {
+                    try dest.writeStr("fullscreen");
+                }
+            },
+
+            // https://drafts.csswg.org/selectors/#display-state-pseudos
+            .open => try dest.writeStr(":open"),
+            .closed => try dest.writeStr(":closed"),
+            .modal => try dest.writeStr(":modal"),
+            .picture_in_picture => try dest.writeStr(":picture-in-picture"),
+
+            // https://html.spec.whatwg.org/multipage/semantics-other.html#selector-popover-open
+            .popover_open => try dest.writeStr(":popover-open"),
+
+            // https://drafts.csswg.org/selectors-4/#the-defined-pseudo
+            .defined => try dest.writeStr(":defined"),
+
+            // https://drafts.csswg.org/selectors-4/#location
+            .any_link => |prefix| try Helpers.writePrefixed(dest, prefix, "any-link"),
+            .link => try dest.writeStr(":link"),
+            .local_link => try dest.writeStr(":local-link"),
+            .target => try dest.writeStr(":target"),
+            .target_within => try dest.writeStr(":target-within"),
+            .visited => try dest.writeStr(":visited"),
+
+            // https://drafts.csswg.org/selectors-4/#input-pseudos
+            .enabled => try dest.writeStr(":enabled"),
+            .disabled => try dest.writeStr(":disabled"),
+            .read_only => |prefix| try Helpers.writePrefixed(dest, prefix, "read-only"),
+            .read_write => |prefix| try Helpers.writePrefixed(dest, prefix, "read-write"),
+            .placeholder_shown => |prefix| try Helpers.writePrefixed(dest, prefix, "placeholder-shown"),
+            .default => try dest.writeStr(":default"),
+            .checked => try dest.writeStr(":checked"),
+            .indeterminate => try dest.writeStr(":indeterminate"),
+            .blank => try dest.writeStr(":blank"),
+            .valid => try dest.writeStr(":valid"),
+            .invalid => try dest.writeStr(":invalid"),
+            .in_range => try dest.writeStr(":in-range"),
+            .out_of_range => try dest.writeStr(":out-of-range"),
+            .required => try dest.writeStr(":required"),
+            .optional => try dest.writeStr(":optional"),
+            .user_valid => try dest.writeStr(":user-valid"),
+            .user_invalid => try dest.writeStr(":user-invalid"),
+
+            // https://html.spec.whatwg.org/multipage/semantics-other.html#selector-autofill
+            .autofill => |prefix| try Helpers.writePrefixed(dest, prefix, "autofill"),
+
+            .local => |selector| try serializeSelector(selector.selector, W, dest, context, false),
+            .global => |selector| {
+                const css_module = if (dest.css_module) |module| css_module: {
+                    dest.css_module = null;
+                    break :css_module module;
+                } else null;
+                try serializeSelector(selector.selector, W, dest, context, false);
+                dest.css_module = css_module;
+            },
+
+            // https://webkit.org/blog/363/styling-scrollbars/
+            .webkit_scrollbar => |s| {
+                try dest.writeStr(switch (s) {
+                    .horizontal => ":horizontal",
+                    .vertical => ":vertical",
+                    .decrement => ":decrement",
+                    .increment => ":increment",
+                    .start => ":start",
+                    .end => ":end",
+                    .double_button => ":double-button",
+                    .single_button => ":single-button",
+                    .no_button => ":no-button",
+                    .corner_present => ":corner-present",
+                    .window_inactive => ":window-inactive",
+                });
+            },
+
+            .lang => unreachable,
+            .dir => unreachable,
+            .custom => |name| {
+                try dest.writeChar(':');
+                return dest.writeStr(name.name);
+            },
+            .custom_function => |v| {
+                try dest.writeChar(':');
+                try dest.writeStr(v.name);
+                try dest.writeChar('(');
+                try v.arguments.toCssRaw(W, dest);
+                try dest.writeChar(')');
+            },
+        }
+    }
+
+    pub fn serializePseudoElement(
+        pseudo_element: *const parser.PseudoElement,
+        comptime W: type,
+        dest: *Printer(W),
+        context: ?*const css.StyleContext,
+    ) PrintErr!void {
+        const Helpers = struct {
+            pub fn writePrefix(d: *Printer(W), prefix: css.VendorPrefix) PrintErr!css.VendorPrefix {
+                try d.writeStr("::");
+                // If the printer has a vendor prefix override, use that.
+                const vp = if (!d.vendor_prefix.isEmpty()) d.vendor_prefix.bitwiseAnd(prefix).orNone() else prefix;
+                try vp.toCss(W, d);
+                return vp;
+            }
+
+            pub fn writePrefixed(d: *Printer(W), prefix: css.VendorPrefix, comptime val: []const u8) PrintErr!void {
+                _ = try writePrefix(d, prefix);
+                try d.writeStr(val);
+            }
+        };
+        // switch (pseudo_element.*) {
+        //     // CSS2 pseudo elements support a single colon syntax in addition
+        //     // to the more correct double colon for other pseudo elements.
+        //     // We use that here because it's supported everywhere and is shorter.
+        //     .after => try dest.writeStr(":after"),
+        //     .before => try dest.writeStr(":before"),
+        //     .marker => try dest.writeStr(":first-letter"),
+        //     .selection => |prefix| Helpers.writePrefixed(dest, prefix, "selection"),
+        //     .cue => dest.writeStr("::cue"),
+        //     .cue_region => dest.writeStr("::cue-region"),
+        //     .cue_function => |v| {
+        //         dest.writeStr("::cue(");
+        //         try serializeSelector(v.selector, W, dest, context, false);
+        //         try dest.writeChar(')');
+        //     },
+        // }
+        switch (pseudo_element.*) {
+            // CSS2 pseudo elements support a single colon syntax in addition
+            // to the more correct double colon for other pseudo elements.
+            // We use that here because it's supported everywhere and is shorter.
+            .after => try dest.writeStr(":after"),
+            .before => try dest.writeStr(":before"),
+            .first_line => try dest.writeStr(":first-line"),
+            .first_letter => try dest.writeStr(":first-letter"),
+            .marker => try dest.writeStr("::marker"),
+            .selection => |prefix| try Helpers.writePrefixed(dest, prefix, "selection"),
+            .cue => try dest.writeStr("::cue"),
+            .cue_region => try dest.writeStr("::cue-region"),
+            .cue_function => |v| {
+                try dest.writeStr("::cue(");
+                try serializeSelector(v.selector, W, dest, context, false);
+                try dest.writeChar(')');
+            },
+            .cue_region_function => |v| {
+                try dest.writeStr("::cue-region(");
+                try serializeSelector(v.selector, W, dest, context, false);
+                try dest.writeChar(')');
+            },
+            .placeholder => |prefix| {
+                const vp = try Helpers.writePrefix(dest, prefix);
+                if (vp.webkit or vp.ms) {
+                    try dest.writeStr("input-placeholder");
+                } else {
+                    try dest.writeStr("placeholder");
+                }
+            },
+            .backdrop => |prefix| try Helpers.writePrefixed(dest, prefix, "backdrop"),
+            .file_selector_button => |prefix| {
+                const vp = try Helpers.writePrefix(dest, prefix);
+                if (vp.webkit) {
+                    try dest.writeStr("file-upload-button");
+                } else if (vp.ms) {
+                    try dest.writeStr("browse");
+                } else {
+                    try dest.writeStr("file-selector-button");
+                }
+            },
+            .webkit_scrollbar => |s| {
+                try dest.writeStr(switch (s) {
+                    .scrollbar => "::-webkit-scrollbar",
+                    .button => "::-webkit-scrollbar-button",
+                    .track => "::-webkit-scrollbar-track",
+                    .track_piece => "::-webkit-scrollbar-track-piece",
+                    .thumb => "::-webkit-scrollbar-thumb",
+                    .corner => "::-webkit-scrollbar-corner",
+                    .resizer => "::-webkit-resizer",
+                });
+            },
+            .view_transition => try dest.writeStr("::view-transition"),
+            .view_transition_group => |v| {
+                try dest.writeStr("::view-transition-group(");
+                try v.part_name.toCss(W, dest);
+                try dest.writeChar(')');
+            },
+            .view_transition_image_pair => |v| {
+                try dest.writeStr("::view-transition-image-pair(");
+                try v.part_name.toCss(W, dest);
+                try dest.writeChar(')');
+            },
+            .view_transition_old => |v| {
+                try dest.writeStr("::view-transition-old(");
+                try v.part_name.toCss(W, dest);
+                try dest.writeChar(')');
+            },
+            .view_transition_new => |v| {
+                try dest.writeStr("::view-transition-new(");
+                try v.part_name.toCss(W, dest);
+                try dest.writeChar(')');
+            },
+            .custom => |val| {
+                try dest.writeStr("::");
+                return dest.writeStr(val.name);
+            },
+            .custom_function => |v| {
+                const name = v.name;
+                try dest.writeStr("::");
+                try dest.writeStr(name);
+                try dest.writeChar('(');
+                try v.arguments.toCssRaw(W, dest);
+                try dest.writeChar(')');
+            },
+        }
+    }
+
+    pub fn serializeNesting(
+        comptime W: type,
+        dest: *Printer(W),
+        context: ?*const css.StyleContext,
+        first: bool,
+    ) PrintErr!void {
+        if (context) |ctx| {
+            // If there's only one simple selector, just serialize it directly.
+            // Otherwise, use an :is() pseudo class.
+            // Type selectors are only allowed at the start of a compound selector,
+            // so use :is() if that is not the case.
+            if (ctx.selectors.v.len() == 1 and
+                (first or (!hasTypeSelector(ctx.selectors.v.at(0)) and
+                isSimple(ctx.selectors.v.at(0)))))
+            {
+                try serializeSelector(ctx.selectors.v.at(0), W, dest, ctx.parent, false);
+            } else {
+                try dest.writeStr(":is(");
+                try serializeSelectorList(ctx.selectors.v.slice(), W, dest, ctx.parent, false);
+                try dest.writeChar(')');
+            }
+        } else {
+            // If there is no context, we are at the root if nesting is supported. This is equivalent to :scope.
+            // Otherwise, if nesting is supported, serialize the nesting selector directly.
+            if (dest.targets.shouldCompileSame(.nesting)) {
+                try dest.writeStr(":scope");
+            } else {
+                try dest.writeChar('&');
+            }
+        }
+    }
+};
+
+pub const tocss_servo = struct {
+    pub fn toCss_SelectorList(
+        selectors: []const parser.Selector,
+        comptime W: type,
+        dest: *css.Printer(W),
+    ) PrintErr!void {
+        if (selectors.len == 0) {
+            return;
+        }
+
+        try tocss_servo.toCss_Selector(&selectors[0], W, dest);
+
+        if (selectors.len > 1) {
+            for (selectors[1..]) |*selector| {
+                try dest.writeStr(", ");
+                try tocss_servo.toCss_Selector(selector, W, dest);
+            }
+        }
+    }
+
+    pub fn toCss_Selector(
+        selector: *const parser.Selector,
+        comptime W: type,
+        dest: *css.Printer(W),
+    ) PrintErr!void {
+        // Compound selectors invert the order of their contents, so we need to
+        // undo that during serialization.
+        //
+        // This two-iterator strategy involves walking over the selector twice.
+        // We could do something more clever, but selector serialization probably
+        // isn't hot enough to justify it, and the stringification likely
+        // dominates anyway.
+        //
+        // NB: A parse-order iterator is a Rev<>, which doesn't expose as_slice(),
+        // which we need for |split|. So we split by combinators on a match-order
+        // sequence and then reverse.
+        var combinators = CombinatorIter{ .sel = selector };
+        var compound_selectors = CompoundSelectorIter{ .sel = selector };
+
+        var combinators_exhausted = false;
+        while (compound_selectors.next()) |compound| {
+            bun.debugAssert(!combinators_exhausted);
+
+            // https://drafts.csswg.org/cssom/#serializing-selectors
+            if (compound.len == 0) continue;
+
+            // 1. If there is only one simple selector in the compound selectors
+            //    which is a universal selector, append the result of
+            //    serializing the universal selector to s.
+            //
+            // Check if `!compound.empty()` first--this can happen if we have
+            // something like `... > ::before`, because we store `>` and `::`
+            // both as combinators internally.
+            //
+            // If we are in this case, after we have serialized the universal
+            // selector, we skip Step 2 and continue with the algorithm.
+            const can_elide_namespace, const first_non_namespace: usize = if (0 >= compound.len)
+                .{ true, 0 }
+            else switch (compound[0]) {
+                .explicit_any_namespace, .explicit_no_namespace, .namespace => .{ false, 1 },
+                .default_namespace => .{ true, 1 },
+                else => .{ true, 0 },
+            };
+            var perform_step_2 = true;
+            const next_combinator = combinators.next();
+            if (first_non_namespace == compound.len - 1) {
+                // We have to be careful here, because if there is a
+                // pseudo element "combinator" there isn't really just
+                // the one simple selector. Technically this compound
+                // selector contains the pseudo element selector as well
+                // -- Combinator::PseudoElement, just like
+                // Combinator::SlotAssignment, don't exist in the
+                // spec.
+                if (next_combinator == .pseudo_element and compound[first_non_namespace].asCombinator() == .slot_assignment) {
+                    // do nothing
+                } else if (compound[first_non_namespace] == .explicit_universal_type) {
+                    // Iterate over everything so we serialize the namespace
+                    // too.
+                    for (compound) |*simple| {
+                        try tocss_servo.toCss_Component(simple, W, dest);
+                    }
+                    // Skip step 2, which is an "otherwise".
+                    perform_step_2 = false;
+                } else {
+                    // do nothing
+                }
+            }
+
+            // 2. Otherwise, for each simple selector in the compound selectors
+            //    that is not a universal selector of which the namespace prefix
+            //    maps to a namespace that is not the default namespace
+            //    serialize the simple selector and append the result to s.
+            //
+            // See https://github.com/w3c/csswg-drafts/issues/1606, which is
+            // proposing to change this to match up with the behavior asserted
+            // in cssom/serialize-namespaced-type-selectors.html, which the
+            // following code tries to match.
+            if (perform_step_2) {
+                for (compound) |*simple| {
+                    if (simple.* == .explicit_universal_type) {
+                        // Can't have a namespace followed by a pseudo-element
+                        // selector followed by a universal selector in the same
+                        // compound selector, so we don't have to worry about the
+                        // real namespace being in a different `compound`.
+                        if (can_elide_namespace) {
+                            continue;
+                        }
+                    }
+                    try tocss_servo.toCss_Component(simple, W, dest);
+                }
+            }
+
+            // 3. If this is not the last part of the chain of the selector
+            //    append a single SPACE (U+0020), followed by the combinator
+            //    ">", "+", "~", ">>", "||", as appropriate, followed by another
+            //    single SPACE (U+0020) if the combinator was not whitespace, to
+            //    s.
+            if (next_combinator) |c| {
+                try toCss_Combinator(&c, W, dest);
+            } else {
+                combinators_exhausted = true;
+            }
+
+            // 4. If this is the last part of the chain of the selector and
+            //    there is a pseudo-element, append "::" followed by the name of
+            //    the pseudo-element, to s.
+            //
+            // (we handle this above)
+        }
+    }
+
+    pub fn toCss_Component(
+        component: *const parser.Component,
+        comptime W: type,
+        dest: *Printer(W),
+    ) PrintErr!void {
+        switch (component.*) {
+            .combinator => |*c| try toCss_Combinator(c, W, dest),
+            .slotted => |*selector| {
+                try dest.writeStr("::slotted(");
+                try tocss_servo.toCss_Selector(selector, W, dest);
+                try dest.writeChar(')');
+            },
+            .part => |part_names| {
+                try dest.writeStr("::part(");
+                for (part_names, 0..) |name, i| {
+                    if (i != 0) {
+                        try dest.writeChar(' ');
+                    }
+                    try css.IdentFns.toCss(&name, W, dest);
+                }
+                try dest.writeChar(')');
+            },
+            .pseudo_element => |*p| {
+                try p.toCss(W, dest);
+            },
+            .id => |s| {
+                try dest.writeChar('#');
+                try css.IdentFns.toCss(&s, W, dest);
+            },
+            .class => |s| {
+                try dest.writeChar('.');
+                try css.IdentFns.toCss(&s, W, dest);
+            },
+            .local_name => |local_name| {
+                try local_name.toCss(W, dest);
+            },
+            .explicit_universal_type => {
+                try dest.writeChar('*');
+            },
+            .default_namespace => return,
+
+            .explicit_no_namespace => {
+                try dest.writeChar('|');
+            },
+            .explicit_any_namespace => {
+                try dest.writeStr("*|");
+            },
+            .namespace => |ns| {
+                try css.IdentFns.toCss(&ns.prefix, W, dest);
+                try dest.writeChar('|');
+            },
+            .attribute_in_no_namespace_exists => |v| {
+                try dest.writeChar('[');
+                try css.IdentFns.toCss(&v.local_name, W, dest);
+                try dest.writeChar(']');
+            },
+            .attribute_in_no_namespace => |v| {
+                try dest.writeChar('[');
+                try css.IdentFns.toCss(&v.local_name, W, dest);
+                try v.operator.toCss(W, dest);
+                try css.CSSStringFns.toCss(&v.value, W, dest);
+                switch (v.case_sensitivity) {
+                    .case_sensitive, .ascii_case_insensitive_if_in_html_element_in_html_document => {},
+                    .ascii_case_insensitive => try dest.writeStr(" i"),
+                    .explicit_case_sensitive => try dest.writeStr(" s"),
+                }
+                try dest.writeChar(']');
+            },
+            .attribute_other => |attr_selector| {
+                try attr_selector.toCss(W, dest);
+            },
+            // Pseudo-classes
+            .root => {
+                try dest.writeStr(":root");
+            },
+            .empty => {
+                try dest.writeStr(":empty");
+            },
+            .scope => {
+                try dest.writeStr(":scope");
+            },
+            .host => |selector| {
+                try dest.writeStr(":host");
+                if (selector) |*sel| {
+                    try dest.writeChar('(');
+                    try tocss_servo.toCss_Selector(sel, W, dest);
+                    try dest.writeChar(')');
+                }
+            },
+            .nth => |nth_data| {
+                try nth_data.writeStart(W, dest, nth_data.isFunction());
+                if (nth_data.isFunction()) {
+                    try nth_data.writeAffine(W, dest);
+                    try dest.writeChar(')');
+                }
+            },
+            .nth_of => |nth_of_data| {
+                const nth_data = nth_of_data.nthData();
+                try nth_data.writeStart(W, dest, true);
+                // A selector must be a function to hold An+B notation
+                bun.debugAssert(nth_data.is_function);
+                try nth_data.writeAffine(W, dest);
+                // Only :nth-child or :nth-last-child can be of a selector list
+                bun.debugAssert(nth_data.ty == .child or nth_data.ty == .last_child);
+                // The selector list should not be empty
+                bun.debugAssert(nth_of_data.selectors.len != 0);
+                try dest.writeStr(" of ");
+                try tocss_servo.toCss_SelectorList(nth_of_data.selectors, W, dest);
+                try dest.writeChar(')');
+            },
+            .is, .where, .negation, .has, .any => {
+                switch (component.*) {
+                    .where => try dest.writeStr(":where("),
+                    .is => try dest.writeStr(":is("),
+                    .negation => try dest.writeStr(":not("),
+                    .has => try dest.writeStr(":has("),
+                    .any => |v| {
+                        try dest.writeChar(':');
+                        try v.vendor_prefix.toCss(W, dest);
+                        try dest.writeStr("any(");
+                    },
+                    else => unreachable,
+                }
+                try tocss_servo.toCss_SelectorList(
+                    switch (component.*) {
+                        .where, .is, .negation, .has => |list| list,
+                        .any => |v| v.selectors,
+                        else => unreachable,
+                    },
+                    W,
+                    dest,
+                );
+                try dest.writeStr(")");
+            },
+            .non_ts_pseudo_class => |*pseudo| {
+                try pseudo.toCss(W, dest);
+            },
+            .nesting => try dest.writeChar('&'),
+        }
+    }
+
+    pub fn toCss_Combinator(
+        combinator: *const parser.Combinator,
+        comptime W: type,
+        dest: *Printer(W),
+    ) PrintErr!void {
+        switch (combinator.*) {
+            .child => try dest.writeStr(" > "),
+            .descendant => try dest.writeStr(" "),
+            .next_sibling => try dest.writeStr(" + "),
+            .later_sibling => try dest.writeStr(" ~ "),
+            .deep => try dest.writeStr(" /deep/ "),
+            .deep_descendant => {
+                try dest.writeStr(" >>> ");
+            },
+            .pseudo_element, .part, .slot_assignment => return,
+        }
+    }
+
+    pub fn toCss_PseudoElement(
+        pseudo_element: *const parser.PseudoElement,
+        comptime W: type,
+        dest: *Printer(W),
+    ) PrintErr!void {
+        switch (pseudo_element.*) {
+            .before => try dest.writeStr("::before"),
+            .after => try dest.writeStr("::after"),
+        }
+    }
+};
+
+pub fn shouldUnwrapIs(selectors: []const parser.Selector) bool {
+    if (selectors.len == 1) {
+        const first = selectors[0];
+        if (!hasTypeSelector(&first) and isSimple(&first)) return true;
+    }
+
+    return false;
+}
+
+fn hasTypeSelector(selector: *const parser.Selector) bool {
+    var iter = selector.iterRawParseOrderFrom(0);
+    const first = iter.next();
+
+    if (isNamespace(if (first) |*f| f else null)) return isTypeSelector(if (iter.next()) |*n| n else null);
+
+    return isTypeSelector(if (first) |*f| f else null);
+}
+
+fn isNamespace(component: ?*const parser.Component) bool {
+    if (component) |c| return switch (c.*) {
+        .explicit_any_namespace, .explicit_no_namespace, .namespace, .default_namespace => true,
+        else => false,
+    };
+    return false;
+}
+
+fn isTypeSelector(component: ?*const parser.Component) bool {
+    if (component) |c| return switch (c.*) {
+        .local_name, .explicit_universal_type => true,
+        else => false,
+    };
+    return false;
+}
+
+fn isSimple(selector: *const parser.Selector) bool {
+    var iter = selector.iterRawParseOrderFrom(0);
+    while (iter.next()) |component| {
+        if (component.isCombinator()) return true;
+    }
+    return false;
+}
+
+const CombinatorIter = struct {
+    sel: *const parser.Selector,
+    i: usize = 0,
+
+    /// Original source has this iterator defined like so:
+    /// ```rs
+    /// selector
+    ///   .iter_raw_match_order() // just returns an iterator
+    ///   .rev() // reverses the iterator
+    ///   .filter_map(|x| x.as_combinator()) // returns only entries which are combinators
+    /// ```
+    pub fn next(this: *@This()) ?parser.Combinator {
+        while (this.i < this.sel.components.items.len) {
+            defer this.i += 1;
+            const combinator = this.sel.components.items[this.sel.components.items.len - 1 - this.i].asCombinator() orelse continue;
+            return combinator;
+        }
+        return null;
+    }
+};
+const CompoundSelectorIter = struct {
+    sel: *const parser.Selector,
+    i: usize = 0,
+
+    /// This iterator is basically like doing `selector.components.splitByCombinator()`.
+    ///
+    /// For example:
+    /// ```css
+    /// div > p.class
+    /// ```
+    ///
+    /// The iterator would return:
+    /// ```
+    /// First slice:
+    /// .{
+    ///   .{ .local_name = "div" }
+    /// }
+    ///
+    /// Second slice:
+    /// .{
+    ///   .{ .local_name = "p" },
+    ///   .{ .class = "class" }
+    /// }
+    /// ```
+    ///
+    /// BUT, the selectors are stored in reverse order, so this code needs to split the components backwards.
+    ///
+    /// Original source has this iterator defined like so:
+    /// ```rs
+    /// selector
+    ///  .iter_raw_match_order()
+    ///  .as_slice()
+    ///  .split(|x| x.is_combinator()) // splits the slice into subslices by elements that match over the predicate
+    ///  .rev() // reverse
+    /// ```
+    pub inline fn next(this: *@This()) ?[]const parser.Component {
+        // Since we iterating backwards, we convert all indices into "backwards form" by doing `this.sel.components.items.len - 1 - i`
+        while (this.i < this.sel.components.items.len) {
+            const next_index: ?usize = next_index: {
+                for (this.i..this.sel.components.items.len) |j| {
+                    if (this.sel.components.items[this.sel.components.items.len - 1 - j].isCombinator()) break :next_index j;
+                }
+                break :next_index null;
+            };
+            if (next_index) |combinator_index| {
+                const start = if (combinator_index == 0) 0 else combinator_index - 1;
+                const end = this.i;
+                const slice = this.sel.components.items[this.sel.components.items.len - 1 - start .. this.sel.components.items.len - end];
+                this.i = combinator_index + 1;
+                return slice;
+            }
+            const slice = this.sel.components.items[0 .. this.sel.components.items.len - 1 - this.i + 1];
+            this.i = this.sel.components.items.len;
+            return slice;
+        }
+        return null;
+    }
+};
diff --git a/src/css/small_list.zig b/src/css/small_list.zig
new file mode 100644
index 0000000000..fbc86efdd0
--- /dev/null
+++ b/src/css/small_list.zig
@@ -0,0 +1,560 @@
+const std = @import("std");
+const bun = @import("root").bun;
+const css = @import("./css_parser.zig");
+const Printer = css.Printer;
+const Parser = css.Parser;
+const Result = css.Result;
+const voidWrap = css.voidWrap;
+const generic = css.generic;
+const Delimiters = css.Delimiters;
+const PrintErr = css.PrintErr;
+const Allocator = std.mem.Allocator;
+const implementEql = css.implementEql;
+const TextShadow = css.css_properties.text.TextShadow;
+
+/// This is a type whose items can either be heap-allocated (essentially the
+/// same as a BabyList(T)) or inlined in the struct itself.
+///
+/// This is type is a performance optimizations for avoiding allocations, especially when you know the list
+/// will commonly have N or fewer items.
+///
+/// The `capacity` field is used to disambiguate between the two states: - When
+/// `capacity <= N`, the items are stored inline, and `capacity` is the length
+/// of the items.  - When `capacity > N`, the items are stored on the heap, and
+/// this type essentially becomes a BabyList(T), but with the fields reordered.
+///
+/// This code is based on servo/rust-smallvec and the Zig std.ArrayList source.
+pub fn SmallList(comptime T: type, comptime N: comptime_int) type {
+    return struct {
+        capacity: u32 = 0,
+        data: Data = .{ .inlined = undefined },
+
+        const Data = union {
+            inlined: [N]T,
+            heap: HeapData,
+        };
+
+        const HeapData = struct {
+            len: u32,
+            ptr: [*]T,
+
+            pub fn initCapacity(allocator: Allocator, capacity: u32) HeapData {
+                return .{
+                    .len = 0,
+                    .ptr = (allocator.alloc(T, capacity) catch bun.outOfMemory()).ptr,
+                };
+            }
+        };
+
+        const This = @This();
+
+        pub fn parse(input: *Parser) Result(@This()) {
+            const parseFn = comptime voidWrap(T, generic.parseFor(T));
+            var values: @This() = .{};
+            while (true) {
+                input.skipWhitespace();
+                switch (input.parseUntilBefore(Delimiters{ .comma = true }, T, {}, parseFn)) {
+                    .result => |v| {
+                        values.append(input.allocator(), v);
+                    },
+                    .err => |e| return .{ .err = e },
+                }
+                switch (input.next()) {
+                    .err => return .{ .result = values },
+                    .result => |t| {
+                        if (t.* == .comma) continue;
+                        std.debug.panic("Expected a comma", .{});
+                    },
+                }
+            }
+            unreachable;
+        }
+
+        pub fn toCss(this: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+            const length = this.len();
+            for (this.slice(), 0..) |*val, idx| {
+                try val.toCss(W, dest);
+                if (idx < length - 1) {
+                    try dest.delim(',', false);
+                }
+            }
+        }
+
+        pub fn withOne(val: T) @This() {
+            var ret = This{};
+            ret.capacity = 1;
+            ret.data.inlined[0] = val;
+            return ret;
+        }
+
+        pub inline fn at(this: *const @This(), idx: u32) *const T {
+            return &this.as_const_ptr()[idx];
+        }
+
+        pub inline fn mut(this: *@This(), idx: u32) *T {
+            return &this.as_ptr()[idx];
+        }
+
+        pub inline fn last(this: *const @This()) ?*const T {
+            const sl = this.slice();
+            if (sl.len == 0) return null;
+            return &sl[sl.len - 1];
+        }
+
+        pub inline fn toOwnedSlice(this: *const @This(), allocator: Allocator) []T {
+            if (this.spilled()) return this.data.heap.ptr[0..this.data.heap.len];
+            return allocator.dupe(T, this.data.inlined[0..this.capacity]) catch bun.outOfMemory();
+        }
+
+        /// NOTE: If this is inlined then this will refer to stack memory, if
+        /// need it to be stable then you should use `.toOwnedSlice()`
+        pub inline fn slice(this: *const @This()) []const T {
+            if (this.capacity > N) return this.data.heap.ptr[0..this.data.heap.len];
+            return this.data.inlined[0..this.capacity];
+        }
+
+        /// NOTE: If this is inlined then this will refer to stack memory, if
+        /// need it to be stable then you should use `.toOwnedSlice()`
+        pub inline fn slice_mut(this: *@This()) []T {
+            if (this.capacity > N) return this.data.heap.ptr[0..this.data.heap.len];
+            return this.data.inlined[0..this.capacity];
+        }
+
+        pub fn isCompatible(this: *const @This(), browsers: css.targets.Browsers) bool {
+            for (this.slice()) |*v| {
+                if (!v.isCompatible(browsers)) return false;
+            }
+            return true;
+        }
+
+        /// For this function to be called the T here must implement the ImageFallback interface
+        pub fn getFallbacks(this: *@This(), allocator: Allocator, targets: css.targets.Targets) getFallbacksReturnType(T, N) {
+            // Implements ImageFallback interface
+            if (@hasDecl(T, "getImage") and N == 1) {
+                const ColorFallbackKind = css.css_values.color.ColorFallbackKind;
+                // Determine what vendor prefixes and color fallbacks are needed.
+                var prefixes = css.VendorPrefix.empty();
+                var fallbacks = ColorFallbackKind.empty();
+                var res: bun.BabyList(@This()) = .{};
+                for (this.slice()) |*item| {
+                    prefixes.insert(item.getImage().getNecessaryPrefixes(targets));
+                    fallbacks.insert(item.getNecessaryFallbacks(targets));
+                }
+
+                // Get RGB fallbacks if needed.
+                const rgb: ?SmallList(T, 1) = if (fallbacks.contains(ColorFallbackKind{ .rgb = true })) brk: {
+                    var shallow_clone = this.shallowClone(allocator);
+                    for (shallow_clone.slice_mut(), this.slice_mut()) |*out, *in| {
+                        out.* = in.getFallback(allocator, ColorFallbackKind{ .rgb = true });
+                    }
+                    break :brk shallow_clone;
+                } else null;
+
+                // Prefixed properties only support RGB.
+                const prefix_images: *const SmallList(T, 1) = if (rgb) |*r| r else this;
+
+                // Legacy -webkit-gradient()
+                if (prefixes.contains(css.VendorPrefix{ .webkit = true }) and targets.browsers != null and css.prefixes.Feature.isWebkitGradient(targets.browsers.?)) {
+                    const images = images: {
+                        var images = SmallList(T, 1){};
+                        for (prefix_images.slice()) |*item| {
+                            if (item.getImage().getLegacyWebkit(allocator)) |img| {
+                                images.append(allocator, item.withImage(allocator, img));
+                            }
+                        }
+                        break :images images;
+                    };
+                    if (!images.isEmpty()) {
+                        res.push(allocator, images) catch bun.outOfMemory();
+                    }
+                }
+
+                const prefix = struct {
+                    pub inline fn helper(comptime prefix: []const u8, pfs: *css.VendorPrefix, pfi: *const SmallList(T, 1), r: *bun.BabyList(This), alloc: Allocator) void {
+                        if (pfs.contains(css.VendorPrefix.fromName(prefix))) {
+                            var images = SmallList(T, 1).initCapacity(alloc, pfi.len());
+                            for (images.slice_mut(), pfi.slice()) |*out, *in| {
+                                const image = in.getImage().getPrefixed(alloc, css.VendorPrefix.fromName(prefix));
+                                out.* = in.withImage(alloc, image);
+                            }
+                            r.push(alloc, images) catch bun.outOfMemory();
+                        }
+                    }
+                }.helper;
+
+                prefix("webkit", &prefixes, prefix_images, &res, allocator);
+                prefix("moz", &prefixes, prefix_images, &res, allocator);
+                prefix("o", &prefixes, prefix_images, &res, allocator);
+
+                if (prefixes.contains(css.VendorPrefix{ .none = true })) {
+                    if (rgb) |r| {
+                        res.push(allocator, r) catch bun.outOfMemory();
+                    }
+
+                    if (fallbacks.contains(ColorFallbackKind{ .p3 = true })) {
+                        var p3_images = this.shallowClone(allocator);
+                        for (p3_images.slice_mut(), this.slice_mut()) |*out, *in| {
+                            out.* = in.getFallback(allocator, ColorFallbackKind{ .p3 = true });
+                        }
+                    }
+
+                    // Convert to lab if needed (e.g. if oklab is not supported but lab is).
+                    if (fallbacks.contains(ColorFallbackKind{ .lab = true })) {
+                        for (this.slice_mut()) |*item| {
+                            var old = item.*;
+                            item.* = item.getFallback(allocator, ColorFallbackKind{ .lab = true });
+                            old.deinit(allocator);
+                        }
+                    }
+                } else if (res.popOrNull()) |the_last| {
+                    var old = this.*;
+                    // Prefixed property with no unprefixed version.
+                    // Replace self with the last prefixed version so that it doesn't
+                    // get duplicated when the caller pushes the original value.
+                    this.* = the_last;
+                    old.deinit(allocator);
+                }
+                return res;
+            }
+            if (T == TextShadow and N == 1) {
+                var fallbacks = css.ColorFallbackKind.empty();
+                for (this.slice()) |*shadow| {
+                    fallbacks.insert(shadow.color.getNecessaryFallbacks(targets));
+                }
+
+                var res = SmallList(SmallList(TextShadow, 1), 2){};
+                if (fallbacks.contains(css.ColorFallbackKind{ .rgb = true })) {
+                    var rgb = SmallList(TextShadow, 1).initCapacity(allocator, this.len());
+                    for (this.slice()) |*shadow| {
+                        var new_shadow = shadow.*;
+                        // dummy non-alloced color to avoid deep cloning the real one since we will replace it
+                        new_shadow.color = .current_color;
+                        new_shadow = new_shadow.deepClone(allocator);
+                        new_shadow.color = shadow.color.toRGB(allocator).?;
+                        rgb.appendAssumeCapacity(new_shadow);
+                    }
+                    res.append(allocator, rgb);
+                }
+
+                if (fallbacks.contains(css.ColorFallbackKind{ .p3 = true })) {
+                    var p3 = SmallList(TextShadow, 1).initCapacity(allocator, this.len());
+                    for (this.slice()) |*shadow| {
+                        var new_shadow = shadow.*;
+                        // dummy non-alloced color to avoid deep cloning the real one since we will replace it
+                        new_shadow.color = .current_color;
+                        new_shadow = new_shadow.deepClone(allocator);
+                        new_shadow.color = shadow.color.toP3(allocator).?;
+                        p3.appendAssumeCapacity(new_shadow);
+                    }
+                    res.append(allocator, p3);
+                }
+
+                if (fallbacks.contains(css.ColorFallbackKind{ .lab = true })) {
+                    for (this.slice_mut()) |*shadow| {
+                        const out = shadow.color.toLAB(allocator).?;
+                        shadow.color.deinit(allocator);
+                        shadow.color = out;
+                    }
+                }
+
+                return res;
+            }
+            @compileError("Dunno what to do here.");
+        }
+
+        fn getFallbacksReturnType(comptime Type: type, comptime InlineSize: comptime_int) type {
+            // Implements ImageFallback interface
+            if (@hasDecl(Type, "getImage") and InlineSize == 1) {
+                return bun.BabyList(SmallList(Type, 1));
+            }
+            if (Type == TextShadow and InlineSize == 1) {
+                return SmallList(SmallList(TextShadow, 1), 2);
+            }
+            @compileError("Unhandled for: " ++ @typeName(Type));
+        }
+
+        // TODO: remove this stupid function
+        pub fn map(this: *@This(), comptime func: anytype) void {
+            for (this.slice_mut()) |*item| {
+                func(item);
+            }
+        }
+
+        /// `predicate` must be: `fn(*const T) bool`
+        pub fn any(this: *const @This(), comptime predicate: anytype) bool {
+            for (this.slice()) |*item| {
+                if (predicate(item)) return true;
+            }
+            return false;
+        }
+
+        pub fn orderedRemove(this: *@This(), idx: u32) T {
+            var ptr, const len_ptr, const capp = this.tripleMut();
+            _ = capp; // autofix
+            bun.assert(idx < len_ptr.*);
+
+            const length = len_ptr.*;
+
+            len_ptr.* = len_ptr.* - 1;
+            ptr += idx;
+            const item = ptr[0];
+            std.mem.copyForwards(T, ptr[0 .. length - idx - 1], ptr[1..][0 .. length - idx - 1]);
+
+            return item;
+        }
+
+        pub fn swapRemove(this: *@This(), idx: u32) T {
+            var ptr, const len_ptr, const capp = this.tripleMut();
+            _ = capp; // autofix
+            bun.assert(idx < len_ptr.*);
+
+            const ret = ptr[idx];
+            ptr[idx] = ptr[len_ptr.* -| 1];
+            len_ptr.* = len_ptr.* - 1;
+
+            return ret;
+        }
+
+        pub fn clearRetainingCapacity(this: *@This()) void {
+            if (this.spilled()) {
+                this.data.heap.len = 0;
+            } else {
+                this.capacity = 0;
+            }
+        }
+
+        pub fn shallowClone(this: *const @This(), allocator: Allocator) @This() {
+            if (!this.spilled()) return this.*;
+            var h = HeapData.initCapacity(allocator, this.capacity);
+            @memcpy(h.ptr[0..this.capacity], this.data.heap.ptr[0..this.capacity]);
+            return .{
+                .capacity = this.capacity,
+                .data = .{ .heap = h },
+            };
+        }
+
+        pub fn deepClone(this: *const @This(), allocator: Allocator) @This() {
+            var ret: @This() = .{};
+            ret.appendSlice(allocator, this.slice());
+            for (ret.slice_mut()) |*item| {
+                item.* = generic.deepClone(T, item, allocator);
+            }
+            return ret;
+        }
+
+        pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+            if (lhs.len() != rhs.len()) return false;
+            for (lhs.slice(), rhs.slice()) |*a, *b| {
+                if (!generic.eql(T, a, b)) return false;
+            }
+            return true;
+        }
+
+        /// Shallow clone
+        pub fn clone(this: *const @This(), allocator: Allocator) @This() {
+            var ret = this.*;
+            if (!this.spilled()) return ret;
+            ret.data.heap.ptr = (allocator.dupe(T, ret.data.heap.ptr[0..ret.data.heap.len]) catch bun.outOfMemory()).ptr;
+            return ret;
+        }
+
+        pub fn deinit(this: *@This(), allocator: Allocator) void {
+            if (this.spilled()) {
+                allocator.free(this.data.heap.ptr[0..this.data.heap.len]);
+            }
+        }
+
+        pub fn hash(this: *const @This(), hasher: anytype) void {
+            for (this.slice()) |*item| {
+                css.generic.hash(T, item, hasher);
+            }
+        }
+
+        pub inline fn len(this: *const @This()) u32 {
+            if (this.spilled()) return this.data.heap.len;
+            return this.capacity;
+        }
+
+        pub inline fn isEmpty(this: *const @This()) bool {
+            return this.len() == 0;
+        }
+
+        pub fn initCapacity(allocator: Allocator, capacity: u32) @This() {
+            if (capacity > N) {
+                var list: This = .{};
+                list.capacity = capacity;
+                list.data = .{ .heap = HeapData.initCapacity(allocator, capacity) };
+                return list;
+            }
+
+            return .{
+                .capacity = 0,
+            };
+        }
+
+        pub fn ensureTotalCapacity(this: *@This(), allocator: Allocator, new_capacity: u32) void {
+            if (this.capacity >= new_capacity) return;
+            this.tryGrow(allocator, new_capacity);
+        }
+
+        pub fn insert(
+            this: *@This(),
+            allocator: Allocator,
+            index: u32,
+            item: T,
+        ) void {
+            var ptr, var len_ptr, const capp = this.tripleMut();
+            if (len_ptr.* == capp) {
+                this.reserveOneUnchecked(allocator);
+                const heap_ptr, const heap_len_ptr = this.heap();
+                ptr = heap_ptr;
+                len_ptr = heap_len_ptr;
+            }
+            const length = len_ptr.*;
+            ptr += index;
+            if (index < length) {
+                const count = length - index;
+                std.mem.copyBackwards(T, ptr[1..][0..count], ptr[0..count]);
+            } else if (index == length) {
+                // No elements need shifting.
+            } else {
+                @panic("index exceeds length");
+            }
+            len_ptr.* = length + 1;
+            ptr[0] = item;
+        }
+
+        pub fn appendAssumeCapacity(this: *@This(), item: T) void {
+            var ptr, const len_ptr, const capp = this.tripleMut();
+            bun.debugAssert(len_ptr.* < capp);
+            ptr[len_ptr.*] = item;
+            len_ptr.* += 1;
+        }
+
+        pub fn append(this: *@This(), allocator: Allocator, item: T) void {
+            var ptr, var len_ptr, const capp = this.tripleMut();
+            if (len_ptr.* == capp) {
+                this.reserveOneUnchecked(allocator);
+                const heap_ptr, const heap_len = this.heap();
+                ptr = heap_ptr;
+                len_ptr = heap_len;
+            }
+            ptr[len_ptr.*] = item;
+            len_ptr.* += 1;
+        }
+
+        pub fn appendSlice(this: *@This(), allocator: Allocator, items: []const T) void {
+            this.insertSlice(allocator, this.len(), items);
+        }
+
+        pub fn insertSlice(this: *@This(), allocator: Allocator, index: u32, items: []const T) void {
+            this.reserve(allocator, @intCast(items.len));
+
+            const length = this.len();
+            bun.assert(index <= length);
+            const ptr: [*]T = this.as_ptr()[index..];
+            const count = length - index;
+            std.mem.copyBackwards(T, ptr[items.len..][0..count], ptr[0..count]);
+            @memcpy(ptr[0..items.len], items);
+            this.setLen(length + @as(u32, @intCast(items.len)));
+        }
+
+        pub fn setLen(this: *@This(), new_len: u32) void {
+            const len_ptr = this.lenMut();
+            len_ptr.* = new_len;
+        }
+
+        inline fn heap(this: *@This()) struct { [*]T, *u32 } {
+            return .{ this.data.heap.ptr, &this.data.heap.len };
+        }
+
+        fn as_const_ptr(this: *const @This()) [*]const T {
+            if (this.spilled()) return this.data.heap.ptr;
+            return &this.data.inlined;
+        }
+
+        fn as_ptr(this: *@This()) [*]T {
+            if (this.spilled()) return this.data.heap.ptr;
+            return &this.data.inlined;
+        }
+
+        fn reserve(this: *@This(), allocator: Allocator, additional: u32) void {
+            const ptr, const __len, const capp = this.tripleMut();
+            _ = ptr; // autofix
+            const len_ = __len.*;
+
+            if (capp - len_ >= additional) return;
+            const new_cap = growCapacity(capp, len_ + additional);
+            this.tryGrow(allocator, new_cap);
+        }
+
+        fn reserveOneUnchecked(this: *@This(), allocator: Allocator) void {
+            @setCold(true);
+            bun.assert(this.len() == this.capacity);
+            const new_cap = growCapacity(this.capacity, this.len() + 1);
+            this.tryGrow(allocator, new_cap);
+        }
+
+        fn tryGrow(this: *@This(), allocator: Allocator, new_cap: u32) void {
+            const unspilled = !this.spilled();
+            const ptr, const __len, const cap = this.tripleMut();
+            const length = __len.*;
+            bun.assert(new_cap >= length);
+            if (new_cap <= N) {
+                if (unspilled) return;
+                this.data = .{ .inlined = undefined };
+                @memcpy(ptr[0..length], this.data.inlined[0..length]);
+                this.capacity = length;
+                allocator.free(ptr[0..length]);
+            } else if (new_cap != cap) {
+                const new_alloc: [*]T = if (unspilled) new_alloc: {
+                    const new_alloc = allocator.alloc(T, new_cap) catch bun.outOfMemory();
+                    @memcpy(new_alloc[0..length], ptr[0..length]);
+                    break :new_alloc new_alloc.ptr;
+                } else new_alloc: {
+                    break :new_alloc (allocator.realloc(ptr[0..length], new_cap * @sizeOf(T)) catch bun.outOfMemory()).ptr;
+                };
+                this.data = .{ .heap = .{ .ptr = new_alloc, .len = length } };
+                this.capacity = new_cap;
+            }
+        }
+
+        /// Returns a tuple with (data ptr, len, capacity)
+        /// Useful to get all SmallVec properties with a single check of the current storage variant.
+        inline fn tripleMut(this: *@This()) struct { [*]T, *u32, u32 } {
+            if (this.spilled()) return .{ this.data.heap.ptr, &this.data.heap.len, this.capacity };
+            return .{ &this.data.inlined, &this.capacity, N };
+        }
+
+        inline fn lenMut(this: *@This()) *u32 {
+            if (this.spilled()) return &this.data.heap.len;
+            return &this.capacity;
+        }
+
+        fn growToHeap(this: *@This(), allocator: Allocator, additional: usize) void {
+            bun.assert(!this.spilled());
+            const new_size = growCapacity(this.capacity, this.capacity + additional);
+            var slc = allocator.alloc(T, new_size) catch bun.outOfMemory();
+            @memcpy(slc[0..this.capacity], this.data.inlined[0..this.capacity]);
+            this.data = .{ .heap = HeapData{ .len = this.capacity, .ptr = slc.ptr } };
+            this.capacity = new_size;
+        }
+
+        inline fn spilled(this: *const @This()) bool {
+            return this.capacity > N;
+        }
+
+        /// Copy pasted from Zig std in array list:
+        ///
+        /// Called when memory growth is necessary. Returns a capacity larger than
+        /// minimum that grows super-linearly.
+        fn growCapacity(current: u32, minimum: u32) u32 {
+            var new = current;
+            while (true) {
+                new +|= new / 2 + 8;
+                if (new >= minimum)
+                    return new;
+            }
+        }
+    };
+}
diff --git a/src/css/sourcemap.zig b/src/css/sourcemap.zig
new file mode 100644
index 0000000000..57f5cab30f
--- /dev/null
+++ b/src/css/sourcemap.zig
@@ -0,0 +1,36 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const bun = @import("root").bun;
+const logger = bun.logger;
+const Log = logger.Log;
+
+pub const css = @import("./css_parser.zig");
+pub const css_values = @import("./values/values.zig");
+const DashedIdent = css_values.ident.DashedIdent;
+const Ident = css_values.ident.Ident;
+pub const Error = css.Error;
+const Location = css.Location;
+const ArrayList = std.ArrayListUnmanaged;
+
+pub const SourceMap = struct {
+    project_root: []const u8,
+    inner: SourceMapInner,
+};
+
+pub const SourceMapInner = struct {
+    sources: ArrayList([]const u8),
+    sources_content: ArrayList([]const u8),
+    names: ArrayList([]const u8),
+    mapping_lines: ArrayList(MappingLine),
+};
+
+pub const MappingLine = struct { mappings: ArrayList(LineMapping), last_column: u32, is_sorted: bool };
+
+pub const LineMapping = struct { generated_column: u32, original: ?OriginalLocation };
+
+pub const OriginalLocation = struct {
+    original_line: u32,
+    original_column: u32,
+    source: u32,
+    name: ?u32,
+};
diff --git a/src/css/targets.zig b/src/css/targets.zig
new file mode 100644
index 0000000000..ab720f8304
--- /dev/null
+++ b/src/css/targets.zig
@@ -0,0 +1,135 @@
+const std = @import("std");
+const bun = @import("root").bun;
+const Allocator = std.mem.Allocator;
+
+pub const css = @import("./css_parser.zig");
+
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const VendorPrefix = css.VendorPrefix;
+
+/// Target browsers and features to compile.
+pub const Targets = struct {
+    /// Browser targets to compile the CSS for.
+    browsers: ?Browsers = null,
+    /// Features that should always be compiled, even when supported by targets.
+    include: Features = .{},
+    /// Features that should never be compiled, even when unsupported by targets.
+    exclude: Features = .{},
+
+    pub fn prefixes(this: *const Targets, prefix: css.VendorPrefix, feature: css.prefixes.Feature) css.VendorPrefix {
+        if (prefix.contains(css.VendorPrefix{ .none = true }) and !this.exclude.contains(css.targets.Features{ .vendor_prefixes = true })) {
+            if (this.include.contains(css.targets.Features{ .vendor_prefixes = true })) {
+                return css.VendorPrefix.all();
+            } else {
+                return if (this.browsers) |b| feature.prefixesFor(b) else prefix;
+            }
+        } else {
+            return prefix;
+        }
+    }
+
+    pub fn shouldCompileLogical(this: *const Targets, feature: css.compat.Feature) bool {
+        return this.shouldCompile(feature, css.Features{ .logical_properties = true });
+    }
+
+    pub fn shouldCompile(this: *const Targets, feature: css.compat.Feature, flag: Features) bool {
+        return this.include.contains(flag) or (!this.exclude.contains(flag) and !this.isCompatible(feature));
+    }
+
+    pub fn shouldCompileSame(this: *const Targets, comptime prop: @Type(.EnumLiteral)) bool {
+        const compat_feature: css.compat.Feature = prop;
+        const target_feature: css.targets.Features = target_feature: {
+            var feature: css.targets.Features = .{};
+            @field(feature, @tagName(prop)) = true;
+            break :target_feature feature;
+        };
+
+        return shouldCompile(this, compat_feature, target_feature);
+    }
+
+    pub fn shouldCompileSelectors(this: *const Targets) bool {
+        return this.include.intersects(Features.selectors) or
+            (!this.exclude.intersects(Features.selectors) and this.browsers != null);
+    }
+
+    pub fn isCompatible(this: *const Targets, feature: css.compat.Feature) bool {
+        if (this.browsers) |*targets| {
+            return feature.isCompatible(targets.*);
+        }
+        return true;
+    }
+};
+
+/// Autogenerated by build-prefixes.js
+///
+/// Browser versions to compile CSS for.
+///
+/// Versions are represented as a single 24-bit integer, with one byte
+/// per `major.minor.patch` component.
+///
+/// # Example
+///
+/// This example represents a target of Safari 13.2.0.
+///
+/// ```
+/// const Browsers = struct {
+///   safari: ?u32 = (13 << 16) | (2 << 8),
+///   ..Browsers{}
+/// };
+/// ```
+pub const Browsers = struct {
+    android: ?u32 = null,
+    chrome: ?u32 = null,
+    edge: ?u32 = null,
+    firefox: ?u32 = null,
+    ie: ?u32 = null,
+    ios_saf: ?u32 = null,
+    opera: ?u32 = null,
+    safari: ?u32 = null,
+    samsung: ?u32 = null,
+    pub usingnamespace BrowsersImpl(@This());
+};
+
+/// Autogenerated by build-prefixes.js
+/// Features to explicitly enable or disable.
+pub const Features = packed struct(u32) {
+    nesting: bool = false,
+    not_selector_list: bool = false,
+    dir_selector: bool = false,
+    lang_selector_list: bool = false,
+    is_selector: bool = false,
+    text_decoration_thickness_percent: bool = false,
+    media_interval_syntax: bool = false,
+    media_range_syntax: bool = false,
+    custom_media_queries: bool = false,
+    clamp_function: bool = false,
+    color_function: bool = false,
+    oklab_colors: bool = false,
+    lab_colors: bool = false,
+    p3_colors: bool = false,
+    hex_alpha_colors: bool = false,
+    space_separated_color_notation: bool = false,
+    font_family_system_ui: bool = false,
+    double_position_gradients: bool = false,
+    vendor_prefixes: bool = false,
+    logical_properties: bool = false,
+    __unused: u12 = 0,
+
+    pub const selectors = Features.fromNames(&.{ "nesting", "not_selector_list", "dir_selector", "lang_selector_list", "is_selector" });
+    pub const media_queries = Features.fromNames(&.{ "media_interval_syntax", "media_range_syntax", "custom_media_queries" });
+    pub const colors = Features.fromNames(&.{ "color_function", "oklab_colors", "lab_colors", "p3_colors", "hex_alpha_colors", "space_separated_color_notation" });
+
+    pub usingnamespace css.Bitflags(@This());
+    pub usingnamespace FeaturesImpl(@This());
+};
+
+pub fn BrowsersImpl(comptime T: type) type {
+    _ = T; // autofix
+    return struct {};
+}
+
+pub fn FeaturesImpl(comptime T: type) type {
+    _ = T; // autofix
+    return struct {};
+}
diff --git a/src/css/values/alpha.zig b/src/css/values/alpha.zig
new file mode 100644
index 0000000000..531e718b52
--- /dev/null
+++ b/src/css/values/alpha.zig
@@ -0,0 +1,63 @@
+const std = @import("std");
+const bun = @import("root").bun;
+pub const css = @import("../css_parser.zig");
+const Result = css.Result;
+const ArrayList = std.ArrayListUnmanaged;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const CSSNumber = css.css_values.number.CSSNumber;
+const CSSNumberFns = css.css_values.number.CSSNumberFns;
+const Calc = css.css_values.calc.Calc;
+const DimensionPercentage = css.css_values.percentage.DimensionPercentage;
+const LengthPercentage = css.css_values.length.LengthPercentage;
+const Length = css.css_values.length.Length;
+const Percentage = css.css_values.percentage.Percentage;
+const CssColor = css.css_values.color.CssColor;
+const Image = css.css_values.image.Image;
+const Url = css.css_values.url.Url;
+const CSSInteger = css.css_values.number.CSSInteger;
+const CSSIntegerFns = css.css_values.number.CSSIntegerFns;
+const Angle = css.css_values.angle.Angle;
+const Time = css.css_values.time.Time;
+const Resolution = css.css_values.resolution.Resolution;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CustomIdentFns = css.css_values.ident.CustomIdentFns;
+const Ident = css.css_values.ident.Ident;
+const NumberOrPercentage = css.css_values.percentage.NumberOrPercentage;
+
+/// A CSS [`<alpha-value>`](https://www.w3.org/TR/css-color-4/#typedef-alpha-value),
+/// used to represent opacity.
+///
+/// Parses either a `<number>` or `<percentage>`, but is always stored and serialized as a number.
+pub const AlphaValue = struct {
+    v: f32,
+
+    pub fn parse(input: *css.Parser) Result(AlphaValue) {
+        // For some reason NumberOrPercentage.parse makes zls crash, using this instead.
+        const val: NumberOrPercentage = switch (@call(.auto, @field(NumberOrPercentage, "parse"), .{input})) {
+            .result => |v| v,
+            .err => |e| return .{ .err = e },
+        };
+        const final = switch (val) {
+            .percentage => |percent| AlphaValue{ .v = percent.v },
+            .number => |num| AlphaValue{ .v = num },
+        };
+        return .{ .result = final };
+    }
+
+    pub fn toCss(this: *const AlphaValue, comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+        return CSSNumberFns.toCss(&this.v, W, dest);
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+        return css.implementHash(@This(), this, hasher);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
diff --git a/src/css/values/angle.zig b/src/css/values/angle.zig
new file mode 100644
index 0000000000..ee207c553a
--- /dev/null
+++ b/src/css/values/angle.zig
@@ -0,0 +1,302 @@
+const std = @import("std");
+const bun = @import("root").bun;
+pub const css = @import("../css_parser.zig");
+const Result = css.Result;
+const ArrayList = std.ArrayListUnmanaged;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const CSSNumber = css.css_values.number.CSSNumber;
+const CSSNumberFns = css.css_values.number.CSSNumberFns;
+const Calc = css.css_values.calc.Calc;
+
+const Tag = enum(u8) {
+    deg = 1,
+    rad = 2,
+    grad = 4,
+    turn = 8,
+};
+
+/// A CSS [`<angle>`](https://www.w3.org/TR/css-values-4/#angles) value.
+///
+/// Angles may be explicit or computed by `calc()`, but are always stored and serialized
+/// as their computed value.
+pub const Angle = union(Tag) {
+    /// An angle in degrees. There are 360 degrees in a full circle.
+    deg: CSSNumber,
+    /// An angle in radians. There are 2π radians in a full circle.
+    rad: CSSNumber,
+    /// An angle in gradians. There are 400 gradians in a full circle.
+    grad: CSSNumber,
+    /// An angle in turns. There is 1 turn in a full circle.
+    turn: CSSNumber,
+
+    // ~toCssImpl
+    const This = @This();
+
+    pub fn parse(input: *css.Parser) Result(Angle) {
+        return Angle.parseInternal(input, false);
+    }
+
+    fn parseInternal(input: *css.Parser, allow_unitless_zero: bool) Result(Angle) {
+        if (input.tryParse(Calc(Angle).parse, .{}).asValue()) |calc_value| {
+            if (calc_value == .value) return .{ .result = calc_value.value.* };
+            // Angles are always compatible, so they will always compute to a value.
+            return .{ .err = input.newCustomError(css.ParserError.invalid_value) };
+        }
+
+        const location = input.currentSourceLocation();
+        const token = switch (input.next()) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+        switch (token.*) {
+            .dimension => |*dim| {
+                const value = dim.num.value;
+                const unit = dim.unit;
+                // todo_stuff.match_ignore_ascii_case
+                if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("deg", unit)) {
+                    return .{ .result = Angle{ .deg = value } };
+                } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("grad", unit)) {
+                    return .{ .result = Angle{ .grad = value } };
+                } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("turn", unit)) {
+                    return .{ .result = Angle{ .turn = value } };
+                } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("rad", unit)) {
+                    return .{ .result = Angle{ .rad = value } };
+                } else {
+                    return .{ .err = location.newUnexpectedTokenError(token.*) };
+                }
+            },
+            .number => |num| {
+                if (num.value == 0.0 and allow_unitless_zero) return .{ .result = Angle.zero() };
+            },
+            else => {},
+        }
+        return .{ .err = location.newUnexpectedTokenError(token.*) };
+    }
+
+    pub fn parseWithUnitlessZero(input: *css.Parser) Result(Angle) {
+        return Angle.parseInternal(input, true);
+    }
+
+    pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        const value, const unit = switch (this.*) {
+            .deg => |val| .{ val, "deg" },
+            .grad => |val| .{ val, "grad" },
+            .rad => |val| brk: {
+                const deg = this.toDegrees();
+
+                // We print 5 digits of precision by default.
+                // Switch to degrees if there are an even number of them.
+                if (css.fract(std.math.round(deg * 100000.0)) == 0) {
+                    break :brk .{ val, "deg" };
+                } else {
+                    break :brk .{ val, "rad" };
+                }
+            },
+            .turn => |val| .{ val, "turn" },
+        };
+        css.serializer.serializeDimension(value, unit, W, dest) catch return dest.addFmtError();
+    }
+
+    pub fn toCssWithUnitlessZero(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        if (this.isZero()) {
+            const v: f32 = 0.0;
+            try CSSNumberFns.toCss(&v, W, dest);
+        } else {
+            return this.toCss(W, dest);
+        }
+    }
+
+    pub fn tryFromAngle(angle: Angle) ?This {
+        return angle;
+    }
+
+    pub fn tryFromToken(token: *const css.Token) css.Maybe(Angle, void) {
+        if (token.* == .dimension) {
+            const value = token.dimension.num.value;
+            const unit = token.dimension.unit;
+            if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(unit, "deg")) {
+                return .{ .result = .{ .deg = value } };
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(unit, "grad")) {
+                return .{ .result = .{ .grad = value } };
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(unit, "turn")) {
+                return .{ .result = .{ .turn = value } };
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(unit, "rad")) {
+                return .{ .result = .{ .rad = value } };
+            }
+        }
+        return .{ .err = {} };
+    }
+
+    /// Returns the angle in radians.
+    pub fn toRadians(this: *const Angle) CSSNumber {
+        const RAD_PER_DEG: f32 = std.math.pi / 180.0;
+        return switch (this.*) {
+            .deg => |deg| return deg * RAD_PER_DEG,
+            .rad => |rad| return rad,
+            .grad => |grad| return grad * 180.0 / 200.0 * RAD_PER_DEG,
+            .turn => |turn| return turn * 360.0 * RAD_PER_DEG,
+        };
+    }
+
+    /// Returns the angle in degrees.
+    pub fn toDegrees(this: *const Angle) CSSNumber {
+        const DEG_PER_RAD: f32 = 180.0 / std.math.pi;
+        switch (this.*) {
+            .deg => |deg| return deg,
+            .rad => |rad| return rad * DEG_PER_RAD,
+            .grad => |grad| return grad * 180.0 / 200.0,
+            .turn => |turn| return turn * 360.0,
+        }
+    }
+
+    pub fn zero() Angle {
+        return .{ .deg = 0.0 };
+    }
+
+    pub fn isZero(this: *const Angle) bool {
+        const v = switch (this.*) {
+            .deg => |deg| deg,
+            .rad => |rad| rad,
+            .grad => |grad| grad,
+            .turn => |turn| turn,
+        };
+        return v == 0.0;
+    }
+
+    pub fn intoCalc(this: *const Angle, allocator: std.mem.Allocator) Calc(Angle) {
+        return Calc(Angle){
+            .value = bun.create(allocator, Angle, this.*),
+        };
+    }
+
+    pub fn map(this: *const Angle, comptime opfn: *const fn (f32) f32) Angle {
+        return switch (this.*) {
+            .deg => |deg| .{ .deg = opfn(deg) },
+            .rad => |rad| .{ .rad = opfn(rad) },
+            .grad => |grad| .{ .grad = opfn(grad) },
+            .turn => |turn| .{ .turn = opfn(turn) },
+        };
+    }
+
+    pub fn tryMap(this: *const Angle, comptime opfn: *const fn (f32) f32) ?Angle {
+        return map(this, opfn);
+    }
+
+    pub fn add(this: Angle, rhs: Angle) Angle {
+        const addfn = struct {
+            pub fn add(_: void, a: f32, b: f32) f32 {
+                return a + b;
+            }
+        };
+        return Angle.op(&this, &rhs, {}, addfn.add);
+    }
+
+    pub fn tryAdd(this: *const Angle, _: std.mem.Allocator, rhs: *const Angle) ?Angle {
+        return .{ .deg = this.toDegrees() + rhs.toDegrees() };
+    }
+
+    pub fn eql(lhs: *const Angle, rhs: *const Angle) bool {
+        return lhs.toDegrees() == rhs.toDegrees();
+    }
+
+    pub fn mulF32(this: Angle, _: std.mem.Allocator, other: f32) Angle {
+        // return Angle.op(&this, &other, Angle.mulF32);
+        return switch (this) {
+            .deg => |v| .{ .deg = v * other },
+            .rad => |v| .{ .rad = v * other },
+            .grad => |v| .{ .grad = v * other },
+            .turn => |v| .{ .turn = v * other },
+        };
+    }
+
+    pub fn partialCmp(this: *const Angle, other: *const Angle) ?std.math.Order {
+        return css.generic.partialCmpF32(&this.toDegrees(), &other.toDegrees());
+    }
+
+    pub fn tryOp(
+        this: *const Angle,
+        other: *const Angle,
+        ctx: anytype,
+        comptime op_fn: *const fn (@TypeOf(ctx), a: f32, b: f32) f32,
+    ) ?Angle {
+        return Angle.op(this, other, ctx, op_fn);
+    }
+
+    pub fn tryOpTo(
+        this: *const Angle,
+        other: *const Angle,
+        comptime R: type,
+        ctx: anytype,
+        comptime op_fn: *const fn (@TypeOf(ctx), a: f32, b: f32) R,
+    ) ?R {
+        return Angle.opTo(this, other, R, ctx, op_fn);
+    }
+
+    pub fn op(
+        this: *const Angle,
+        other: *const Angle,
+        ctx: anytype,
+        comptime op_fn: *const fn (@TypeOf(ctx), a: f32, b: f32) f32,
+    ) Angle {
+        // PERF: not sure if this is faster
+        const self_tag: u8 = @intFromEnum(this.*);
+        const other_tag: u8 = @intFromEnum(this.*);
+        const DEG: u8 = @intFromEnum(Tag.deg);
+        const GRAD: u8 = @intFromEnum(Tag.grad);
+        const RAD: u8 = @intFromEnum(Tag.rad);
+        const TURN: u8 = @intFromEnum(Tag.turn);
+
+        const switch_val: u8 = self_tag | other_tag;
+        return switch (switch_val) {
+            DEG | DEG => Angle{ .deg = op_fn(ctx, this.deg, other.deg) },
+            RAD | RAD => Angle{ .rad = op_fn(ctx, this.rad, other.rad) },
+            GRAD | GRAD => Angle{ .grad = op_fn(ctx, this.grad, other.grad) },
+            TURN | TURN => Angle{ .turn = op_fn(ctx, this.turn, other.turn) },
+            else => Angle{ .deg = op_fn(ctx, this.toDegrees(), other.toDegrees()) },
+        };
+    }
+
+    pub fn opTo(
+        this: *const Angle,
+        other: *const Angle,
+        comptime T: type,
+        ctx: anytype,
+        comptime op_fn: *const fn (@TypeOf(ctx), a: f32, b: f32) T,
+    ) T {
+        // PERF: not sure if this is faster
+        const self_tag: u8 = @intFromEnum(this.*);
+        const other_tag: u8 = @intFromEnum(this.*);
+        const DEG: u8 = @intFromEnum(Tag.deg);
+        const GRAD: u8 = @intFromEnum(Tag.grad);
+        const RAD: u8 = @intFromEnum(Tag.rad);
+        const TURN: u8 = @intFromEnum(Tag.turn);
+
+        const switch_val: u8 = self_tag | other_tag;
+        return switch (switch_val) {
+            DEG | DEG => op_fn(ctx, this.deg, other.deg),
+            RAD | RAD => op_fn(ctx, this.rad, other.rad),
+            GRAD | GRAD => op_fn(ctx, this.grad, other.grad),
+            TURN | TURN => op_fn(ctx, this.turn, other.turn),
+            else => op_fn(ctx, this.toDegrees(), other.toDegrees()),
+        };
+    }
+
+    pub fn sign(this: *const Angle) f32 {
+        return switch (this.*) {
+            .deg, .rad, .grad, .turn => |v| CSSNumberFns.sign(&v),
+        };
+    }
+
+    pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+        return css.implementHash(@This(), this, hasher);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A CSS [`<angle-percentage>`](https://www.w3.org/TR/css-values-4/#typedef-angle-percentage) value.
+/// May be specified as either an angle or a percentage that resolves to an angle.
+pub const AnglePercentage = css.css_values.percentage.DimensionPercentage(Angle);
diff --git a/src/css/values/calc.zig b/src/css/values/calc.zig
new file mode 100644
index 0000000000..cf4d213738
--- /dev/null
+++ b/src/css/values/calc.zig
@@ -0,0 +1,1850 @@
+const std = @import("std");
+const bun = @import("root").bun;
+const Allocator = std.mem.Allocator;
+pub const css = @import("../css_parser.zig");
+const Result = css.Result;
+const ArrayList = std.ArrayListUnmanaged;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const Angle = css.css_values.angle.Angle;
+const Length = css.css_values.length.Length;
+const LengthValue = css.css_values.length.LengthValue;
+const Percentage = css.css_values.percentage.Percentage;
+const DimensionPercentage = css.css_values.percentage.DimensionPercentage;
+const Time = css.css_values.time.Time;
+
+const CSSNumber = css.css_values.number.CSSNumber;
+const CSSNumberFns = css.css_values.number.CSSNumberFns;
+
+const eql = css.generic.eql;
+const deepClone = css.deepClone;
+
+pub fn needsDeinit(comptime V: type) bool {
+    return switch (V) {
+        Length => true,
+        DimensionPercentage(Angle) => true,
+        DimensionPercentage(LengthValue) => true,
+        Percentage => false,
+        Angle => false,
+        Time => false,
+        f32 => false,
+        else => @compileError("Can't tell if " ++ @typeName(V) ++ " needs deinit, please add it to the switch statement."),
+    };
+}
+
+pub fn needsDeepclone(comptime V: type) bool {
+    return switch (V) {
+        Length => true,
+        DimensionPercentage(Angle) => true,
+        DimensionPercentage(LengthValue) => true,
+        Percentage => false,
+        Angle => false,
+        Time => false,
+        f32 => false,
+        else => @compileError("Can't tell if " ++ @typeName(V) ++ " needs deepclone, please add it to the switch statement."),
+    };
+}
+
+/// A mathematical expression used within the `calc()` function.
+///
+/// This type supports generic value types. Values such as `Length`, `Percentage`,
+/// `Time`, and `Angle` support `calc()` expressions.
+pub fn Calc(comptime V: type) type {
+    const needs_deinit = needsDeinit(V);
+    const needs_deepclone = needsDeepclone(V);
+
+    return union(Tag) {
+        /// A literal value.
+        /// PERF: this pointer feels unnecessary if V is small
+        value: *V,
+        /// A literal number.
+        number: CSSNumber,
+        /// A sum of two calc expressions.
+        sum: struct {
+            left: *Calc(V),
+            right: *Calc(V),
+        },
+        /// A product of a number and another calc expression.
+        product: struct {
+            number: CSSNumber,
+            expression: *Calc(V),
+        },
+        /// A math function, such as `calc()`, `min()`, or `max()`.
+        function: *MathFunction(V),
+
+        const Tag = enum(u8) {
+            /// A literal value.
+            value = 1,
+            /// A literal number.
+            number = 2,
+            /// A sum of two calc expressions.
+            sum = 4,
+            /// A product of a number and another calc expression.
+            product = 8,
+            /// A math function, such as `calc()`, `min()`, or `max()`.
+            function = 16,
+        };
+
+        const This = @This();
+
+        pub fn deepClone(this: *const This, allocator: Allocator) This {
+            return switch (this.*) {
+                .value => |v| {
+                    return .{
+                        .value = bun.create(
+                            allocator,
+                            V,
+                            if (needs_deepclone) v.deepClone(allocator) else v.*,
+                        ),
+                    };
+                },
+                .number => this.*,
+                .sum => |sum| {
+                    return .{ .sum = .{
+                        .left = bun.create(allocator, This, sum.left.deepClone(allocator)),
+                        .right = bun.create(allocator, This, sum.right.deepClone(allocator)),
+                    } };
+                },
+                .product => |product| {
+                    return .{
+                        .product = .{
+                            .number = product.number,
+                            .expression = bun.create(allocator, This, product.expression.deepClone(allocator)),
+                        },
+                    };
+                },
+                .function => |function| {
+                    return .{
+                        .function = bun.create(
+                            allocator,
+                            MathFunction(V),
+                            function.deepClone(allocator),
+                        ),
+                    };
+                },
+            };
+        }
+
+        pub fn deinit(this: *This, allocator: Allocator) void {
+            return switch (this.*) {
+                .value => |v| {
+                    if (comptime needs_deinit) {
+                        v.deinit(allocator);
+                    }
+                    allocator.destroy(this.value);
+                },
+                .number => {},
+                .sum => |sum| {
+                    sum.left.deinit(allocator);
+                    sum.right.deinit(allocator);
+                    allocator.destroy(sum.left);
+                    allocator.destroy(sum.right);
+                },
+                .product => |product| {
+                    product.expression.deinit(allocator);
+                    allocator.destroy(product.expression);
+                },
+                .function => |function| {
+                    function.deinit(allocator);
+                    allocator.destroy(function);
+                },
+            };
+        }
+
+        pub fn eql(this: *const @This(), other: *const @This()) bool {
+            return switch (this.*) {
+                .value => |a| return other.* == .value and css.generic.eql(V, a, other.value),
+                .number => |*a| return other.* == .number and css.generic.eql(f32, a, &other.number),
+                .sum => |s| return other.* == .sum and s.left.eql(other.sum.left) and s.right.eql(other.sum.right),
+                .product => |p| return other.* == .product and p.number == other.product.number and p.expression.eql(other.product.expression),
+                .function => |f| return other.* == .function and f.eql(other.function),
+            };
+        }
+
+        fn mulValueF32(lhs: V, allocator: Allocator, rhs: f32) V {
+            return switch (V) {
+                f32 => lhs * rhs,
+                else => lhs.mulF32(allocator, rhs),
+            };
+        }
+
+        // TODO: addValueOwned
+        fn addValue(allocator: Allocator, lhs: V, rhs: V) V {
+            return switch (V) {
+                f32 => return lhs + rhs,
+                Angle => return lhs.add(rhs),
+                // CSSNumber => return lhs.add(rhs),
+                Length => return lhs.add(allocator, rhs),
+                Percentage => return lhs.add(allocator, rhs),
+                Time => return lhs.add(allocator, rhs),
+                else => lhs.add(allocator, rhs),
+            };
+        }
+
+        // TODO: intoValueOwned
+        fn intoValue(this: @This(), allocator: std.mem.Allocator) V {
+            switch (V) {
+                Angle => return switch (this) {
+                    .value => |v| v.*,
+                    // TODO: give a better error message
+                    else => bun.unreachablePanic("", .{}),
+                },
+                CSSNumber => return switch (this) {
+                    .value => |v| v.*,
+                    .number => |n| n,
+                    // TODO: give a better error message
+                    else => bun.unreachablePanic("", .{}),
+                },
+                Length => return Length{
+                    .calc = bun.create(allocator, Calc(Length), this),
+                },
+                Percentage => return switch (this) {
+                    .value => |v| v.*,
+                    // TODO: give a better error message
+                    else => bun.unreachablePanic("", .{}),
+                },
+                Time => return switch (this) {
+                    .value => |v| v.*,
+                    // TODO: give a better error message
+                    else => bun.unreachablePanic("", .{}),
+                },
+                DimensionPercentage(LengthValue) => return DimensionPercentage(LengthValue){ .calc = bun.create(
+                    allocator,
+                    Calc(DimensionPercentage(LengthValue)),
+                    this,
+                ) },
+                DimensionPercentage(Angle) => return DimensionPercentage(Angle){ .calc = bun.create(
+                    allocator,
+                    Calc(DimensionPercentage(Angle)),
+                    this,
+                ) },
+                else => @compileError("Unimplemented, intoValue() for V = " ++ @typeName(V)),
+            }
+        }
+
+        // TODO: change to addOwned()
+        pub fn add(this: @This(), allocator: std.mem.Allocator, rhs: @This()) @This() {
+            if (this == .value and rhs == .value) {
+                // PERF: we can reuse the allocation here
+                return .{ .value = bun.create(allocator, V, addValue(allocator, this.value.*, rhs.value.*)) };
+            } else if (this == .number and rhs == .number) {
+                return .{ .number = this.number + rhs.number };
+            } else if (this == .value) {
+                // PERF: we can reuse the allocation here
+                return .{ .value = bun.create(allocator, V, addValue(allocator, this.value.*, intoValue(rhs, allocator))) };
+            } else if (rhs == .value) {
+                // PERF: we can reuse the allocation here
+                return .{ .value = bun.create(allocator, V, addValue(allocator, intoValue(this, allocator), rhs.value.*)) };
+            } else if (this == .function) {
+                return This{
+                    .sum = .{
+                        .left = bun.create(allocator, This, this),
+                        .right = bun.create(allocator, This, rhs),
+                    },
+                };
+            } else if (rhs == .function) {
+                return This{
+                    .sum = .{
+                        .left = bun.create(allocator, This, this),
+                        .right = bun.create(allocator, This, rhs),
+                    },
+                };
+            } else {
+                return .{ .value = bun.create(
+                    allocator,
+                    V,
+                    addValue(allocator, intoValue(this, allocator), intoValue(rhs, allocator)),
+                ) };
+            }
+        }
+
+        // TODO: users of this and `parseWith` don't need the pointer and often throwaway heap allocated values immediately
+        // use temp allocator or something?
+        pub fn parse(input: *css.Parser) Result(This) {
+            const Fn = struct {
+                pub fn parseWithFn(_: void, _: []const u8) ?This {
+                    return null;
+                }
+            };
+            return parseWith(input, {}, Fn.parseWithFn);
+        }
+
+        const CalcUnit = enum {
+            abs,
+            acos,
+            asin,
+            atan,
+            atan2,
+            calc,
+            clamp,
+            cos,
+            exp,
+            hypot,
+            log,
+            max,
+            min,
+            mod,
+            pow,
+            rem,
+            round,
+            sign,
+            sin,
+            sqrt,
+            tan,
+
+            pub const Map = bun.ComptimeEnumMap(CalcUnit);
+        };
+
+        pub fn parseWith(
+            input: *css.Parser,
+            ctx: anytype,
+            comptime parseIdent: *const fn (@TypeOf(ctx), []const u8) ?This,
+        ) Result(This) {
+            const location = input.currentSourceLocation();
+            const f = switch (input.expectFunction()) {
+                .result => |v| v,
+                .err => |e| return .{ .err = e },
+            };
+
+            switch (CalcUnit.Map.getAnyCase(f) orelse return .{ .err = location.newUnexpectedTokenError(.{ .ident = f }) }) {
+                .calc => {
+                    const Closure = struct {
+                        ctx: @TypeOf(ctx),
+                        pub fn parseNestedBlockFn(self: *@This(), i: *css.Parser) Result(This) {
+                            return This.parseSum(i, self.ctx, parseIdent);
+                        }
+                    };
+                    var closure = Closure{ .ctx = ctx };
+                    const calc = switch (input.parseNestedBlock(This, &closure, Closure.parseNestedBlockFn)) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    };
+                    if (calc == .value or calc == .number) return .{ .result = calc };
+                    return .{ .result = Calc(V){
+                        .function = bun.create(
+                            input.allocator(),
+                            MathFunction(V),
+                            MathFunction(V){ .calc = calc },
+                        ),
+                    } };
+                },
+                .min => {
+                    const Closure = struct {
+                        ctx: @TypeOf(ctx),
+                        pub fn parseNestedBlockFn(self: *@This(), i: *css.Parser) Result(ArrayList(This)) {
+                            return i.parseCommaSeparatedWithCtx(This, self, @This().parseOne);
+                        }
+                        pub fn parseOne(self: *@This(), i: *css.Parser) Result(This) {
+                            return This.parseSum(i, self.ctx, parseIdent);
+                        }
+                    };
+                    var closure = Closure{ .ctx = ctx };
+                    var reduced = switch (input.parseNestedBlock(ArrayList(This), &closure, Closure.parseNestedBlockFn)) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    };
+                    // PERF(alloc): i don't like this additional allocation
+                    // can we use stack fallback here if the common case is that there will be 1 argument?
+                    This.reduceArgs(input.allocator(), &reduced, std.math.Order.lt);
+                    // var reduced: ArrayList(This) = This.reduceArgs(&args, std.math.Order.lt);
+                    if (reduced.items.len == 1) {
+                        defer reduced.deinit(input.allocator());
+                        return .{ .result = reduced.swapRemove(0) };
+                    }
+                    return .{ .result = This{
+                        .function = bun.create(
+                            input.allocator(),
+                            MathFunction(V),
+                            MathFunction(V){ .min = reduced },
+                        ),
+                    } };
+                },
+                .max => {
+                    const Closure = struct {
+                        ctx: @TypeOf(ctx),
+                        pub fn parseNestedBlockFn(self: *@This(), i: *css.Parser) Result(ArrayList(This)) {
+                            return i.parseCommaSeparatedWithCtx(This, self, @This().parseOne);
+                        }
+                        pub fn parseOne(self: *@This(), i: *css.Parser) Result(This) {
+                            return This.parseSum(i, self.ctx, parseIdent);
+                        }
+                    };
+                    var closure = Closure{ .ctx = ctx };
+                    var reduced = switch (input.parseNestedBlock(ArrayList(This), &closure, Closure.parseNestedBlockFn)) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    };
+                    // PERF: i don't like this additional allocation
+                    This.reduceArgs(input.allocator(), &reduced, std.math.Order.gt);
+                    // var reduced: ArrayList(This) = This.reduceArgs(&args, std.math.Order.gt);
+                    if (reduced.items.len == 1) {
+                        return .{ .result = reduced.orderedRemove(0) };
+                    }
+                    return .{ .result = This{
+                        .function = bun.create(
+                            input.allocator(),
+                            MathFunction(V),
+                            MathFunction(V){ .max = reduced },
+                        ),
+                    } };
+                },
+                .clamp => {
+                    const ClosureResult = struct { ?This, This, ?This };
+                    const Closure = struct {
+                        ctx: @TypeOf(ctx),
+
+                        pub fn parseNestedBlock(self: *@This(), i: *css.Parser) Result(ClosureResult) {
+                            const min = switch (This.parseSum(i, self, parseIdentWrapper)) {
+                                .result => |vv| vv,
+                                .err => |e| return .{ .err = e },
+                            };
+                            if (i.expectComma().asErr()) |e| return .{ .err = e };
+                            const center = switch (This.parseSum(i, self, parseIdentWrapper)) {
+                                .result => |vv| vv,
+                                .err => |e| return .{ .err = e },
+                            };
+                            if (i.expectComma().asErr()) |e| return .{ .err = e };
+                            const max = switch (This.parseSum(i, self, parseIdentWrapper)) {
+                                .result => |vv| vv,
+                                .err => |e| return .{ .err = e },
+                            };
+                            return .{ .result = .{ min, center, max } };
+                        }
+
+                        pub fn parseIdentWrapper(self: *@This(), ident: []const u8) ?This {
+                            return parseIdent(self.ctx, ident);
+                        }
+                    };
+                    var closure = Closure{
+                        .ctx = ctx,
+                    };
+                    var min, var center, var max = switch (input.parseNestedBlock(
+                        ClosureResult,
+                        &closure,
+                        Closure.parseNestedBlock,
+                    )) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    };
+
+                    // According to the spec, the minimum should "win" over the maximum if they are in the wrong order.
+                    const cmp = if (max != null and max.? == .value and center == .value)
+                        css.generic.partialCmp(V, center.value, max.?.value)
+                    else
+                        null;
+
+                    // If center is known to be greater than the maximum, replace it with maximum and remove the max argument.
+                    // Otherwise, if center is known to be less than the maximum, remove the max argument.
+                    if (cmp) |cmp_val| {
+                        if (cmp_val == std.math.Order.gt) {
+                            const val = max.?;
+                            center = val;
+                            max = null;
+                        } else {
+                            min = null;
+                        }
+                    }
+
+                    const switch_val: u8 = (@as(u8, @intFromBool(min != null)) << 1) | (@as(u8, @intFromBool(min != null)));
+                    // switch (min, max)
+                    return .{ .result = switch (switch_val) {
+                        0b00 => center,
+                        0b10 => This{
+                            .function = bun.create(
+                                input.allocator(),
+                                MathFunction(V),
+                                MathFunction(V){
+                                    .max = arr2(
+                                        input.allocator(),
+                                        min.?,
+                                        center,
+                                    ),
+                                },
+                            ),
+                        },
+                        0b01 => This{
+                            .function = bun.create(
+                                input.allocator(),
+                                MathFunction(V),
+                                MathFunction(V){
+                                    .min = arr2(
+                                        input.allocator(),
+                                        max.?,
+                                        center,
+                                    ),
+                                },
+                            ),
+                        },
+                        0b11 => This{
+                            .function = bun.create(
+                                input.allocator(),
+                                MathFunction(V),
+                                MathFunction(V){
+                                    .clamp = .{
+                                        .min = min.?,
+                                        .center = center,
+                                        .max = max.?,
+                                    },
+                                },
+                            ),
+                        },
+                        else => unreachable,
+                    } };
+                },
+                .round => {
+                    const Closure = struct {
+                        ctx: @TypeOf(ctx),
+                        pub fn parseNestedBlockFn(self: *@This(), i: *css.Parser) Result(This) {
+                            const strategy = if (i.tryParse(RoundingStrategy.parse, .{}).asValue()) |s| brk: {
+                                if (i.expectComma().asErr()) |e| return .{ .err = e };
+                                break :brk s;
+                            } else RoundingStrategy.default();
+
+                            const OpAndFallbackCtx = struct {
+                                strategy: RoundingStrategy,
+
+                                pub fn op(this: *const @This(), a: f32, b: f32) f32 {
+                                    return round({}, a, b, this.strategy);
+                                }
+
+                                pub fn fallback(this: *const @This(), a: This, b: This) MathFunction(V) {
+                                    return MathFunction(V){
+                                        .round = .{
+                                            .strategy = this.strategy,
+                                            .value = a,
+                                            .interval = b,
+                                        },
+                                    };
+                                }
+                            };
+                            var ctx_for_op_and_fallback = OpAndFallbackCtx{
+                                .strategy = strategy,
+                            };
+                            return This.parseMathFn(
+                                i,
+                                &ctx_for_op_and_fallback,
+                                OpAndFallbackCtx.op,
+                                OpAndFallbackCtx.fallback,
+                                self.ctx,
+                                parseIdent,
+                            );
+                        }
+                    };
+                    var closure = Closure{
+                        .ctx = ctx,
+                    };
+                    return input.parseNestedBlock(This, &closure, Closure.parseNestedBlockFn);
+                },
+                .rem => {
+                    const Closure = struct {
+                        ctx: @TypeOf(ctx),
+
+                        pub fn parseNestedBlockFn(self: *@This(), i: *css.Parser) Result(This) {
+                            return This.parseMathFn(
+                                i,
+                                {},
+                                @This().rem,
+                                mathFunctionRem,
+                                self.ctx,
+                                parseIdent,
+                            );
+                        }
+
+                        pub fn rem(_: void, a: f32, b: f32) f32 {
+                            return @mod(a, b);
+                        }
+                        pub fn mathFunctionRem(_: void, a: This, b: This) MathFunction(V) {
+                            return MathFunction(V){
+                                .rem = .{
+                                    .dividend = a,
+                                    .divisor = b,
+                                },
+                            };
+                        }
+                    };
+                    var closure = Closure{
+                        .ctx = ctx,
+                    };
+                    return input.parseNestedBlock(This, &closure, Closure.parseNestedBlockFn);
+                },
+                .mod => {
+                    const Closure = struct {
+                        ctx: @TypeOf(ctx),
+
+                        pub fn parseNestedBlockFn(self: *@This(), i: *css.Parser) Result(This) {
+                            return This.parseMathFn(
+                                i,
+                                {},
+                                @This().modulo,
+                                mathFunctionMod,
+                                self.ctx,
+                                parseIdent,
+                            );
+                        }
+
+                        pub fn modulo(_: void, a: f32, b: f32) f32 {
+                            // return ((a % b) + b) % b;
+                            return @mod((@mod(a, b) + b), b);
+                        }
+                        pub fn mathFunctionMod(_: void, a: This, b: This) MathFunction(V) {
+                            return MathFunction(V){
+                                .mod_ = .{
+                                    .dividend = a,
+                                    .divisor = b,
+                                },
+                            };
+                        }
+                    };
+                    var closure = Closure{
+                        .ctx = ctx,
+                    };
+                    return input.parseNestedBlock(This, &closure, Closure.parseNestedBlockFn);
+                },
+                .sin => {
+                    return This.parseTrig(input, .sin, false, ctx, parseIdent);
+                },
+                .cos => {
+                    return This.parseTrig(input, .cos, false, ctx, parseIdent);
+                },
+                .tan => {
+                    return This.parseTrig(input, .tan, false, ctx, parseIdent);
+                },
+                .asin => {
+                    return This.parseTrig(input, .asin, true, ctx, parseIdent);
+                },
+                .acos => {
+                    return This.parseTrig(input, .acos, true, ctx, parseIdent);
+                },
+                .atan => {
+                    return This.parseTrig(input, .atan, true, ctx, parseIdent);
+                },
+                .atan2 => {
+                    const Closure = struct {
+                        ctx: @TypeOf(ctx),
+                        pub fn parseNestedBlockFn(self: *@This(), i: *css.Parser) Result(This) {
+                            const res = switch (This.parseAtan2(i, self.ctx, parseIdent)) {
+                                .result => |v| v,
+                                .err => |e| return .{ .err = e },
+                            };
+                            if (css.generic.tryFromAngle(V, res)) |v| {
+                                return .{ .result = This{
+                                    .value = bun.create(
+                                        i.allocator(),
+                                        V,
+                                        v,
+                                    ),
+                                } };
+                            }
+
+                            return .{ .err = i.newCustomError(css.ParserError{ .invalid_value = {} }) };
+                        }
+                    };
+                    var closure = Closure{ .ctx = ctx };
+                    return input.parseNestedBlock(This, &closure, Closure.parseNestedBlockFn);
+                },
+                .pow => {
+                    const Closure = struct {
+                        ctx: @TypeOf(ctx),
+                        pub fn parseNestedBlockFn(self: *@This(), i: *css.Parser) Result(This) {
+                            const a = switch (This.parseNumeric(i, self.ctx, parseIdent)) {
+                                .result => |vv| vv,
+                                .err => |e| return .{ .err = e },
+                            };
+
+                            if (i.expectComma().asErr()) |e| return .{ .err = e };
+
+                            const b = switch (This.parseNumeric(i, self.ctx, parseIdent)) {
+                                .result => |vv| vv,
+                                .err => |e| return .{ .err = e },
+                            };
+
+                            return .{ .result = This{
+                                .number = bun.powf(a, b),
+                            } };
+                        }
+                    };
+                    var closure = Closure{ .ctx = ctx };
+                    return input.parseNestedBlock(This, &closure, Closure.parseNestedBlockFn);
+                },
+                .log => {
+                    const Closure = struct {
+                        ctx: @TypeOf(ctx),
+                        pub fn parseNestedBlockFn(self: *@This(), i: *css.Parser) Result(This) {
+                            const value = switch (This.parseNumeric(i, self.ctx, parseIdent)) {
+                                .result => |vv| vv,
+                                .err => |e| return .{ .err = e },
+                            };
+                            if (i.tryParse(css.Parser.expectComma, .{}).isOk()) {
+                                const base = switch (This.parseNumeric(i, self.ctx, parseIdent)) {
+                                    .result => |vv| vv,
+                                    .err => |e| return .{ .err = e },
+                                };
+                                return .{ .result = This{ .number = std.math.log(f32, base, value) } };
+                            }
+                            return .{ .result = This{ .number = std.math.log(f32, std.math.e, value) } };
+                        }
+                    };
+                    var closure = Closure{ .ctx = ctx };
+                    return input.parseNestedBlock(This, &closure, Closure.parseNestedBlockFn);
+                },
+                .sqrt => {
+                    return This.parseNumericFn(input, .sqrt, ctx, parseIdent);
+                },
+                .exp => {
+                    return This.parseNumericFn(input, .exp, ctx, parseIdent);
+                },
+                .hypot => {
+                    const Closure = struct {
+                        ctx: @TypeOf(ctx),
+                        pub fn parseNestedBlockFn(self: *@This(), i: *css.Parser) Result(This) {
+                            var args = switch (i.parseCommaSeparatedWithCtx(This, self, parseOne)) {
+                                .result => |v| v,
+                                .err => |e| return .{ .err = e },
+                            };
+                            const val = switch (This.parseHypot(i.allocator(), &args)) {
+                                .result => |vv| vv,
+                                .err => |e| return .{ .err = e },
+                            };
+
+                            if (val) |v| return .{ .result = v };
+
+                            return .{ .result = This{
+                                .function = bun.create(
+                                    i.allocator(),
+                                    MathFunction(V),
+                                    MathFunction(V){ .hypot = args },
+                                ),
+                            } };
+                        }
+
+                        pub fn parseOne(self: *@This(), i: *css.Parser) Result(This) {
+                            return This.parseSum(i, self.ctx, parseIdent);
+                        }
+                    };
+                    var closure = Closure{ .ctx = ctx };
+                    return input.parseNestedBlock(This, &closure, Closure.parseNestedBlockFn);
+                },
+                .abs => {
+                    const Closure = struct {
+                        ctx: @TypeOf(ctx),
+                        pub fn parseNestedBlockFn(self: *@This(), i: *css.Parser) Result(This) {
+                            const v = switch (This.parseSum(i, self.ctx, parseIdent)) {
+                                .result => |vv| vv,
+                                .err => |e| return .{ .err = e },
+                            };
+                            return .{
+                                .result = if (This.applyMap(&v, i.allocator(), absf)) |vv| vv else This{
+                                    .function = bun.create(
+                                        i.allocator(),
+                                        MathFunction(V),
+                                        MathFunction(V){ .abs = v },
+                                    ),
+                                },
+                            };
+                        }
+                    };
+                    var closure = Closure{ .ctx = ctx };
+                    return input.parseNestedBlock(This, &closure, Closure.parseNestedBlockFn);
+                },
+                .sign => {
+                    const Closure = struct {
+                        ctx: @TypeOf(ctx),
+                        pub fn parseNestedBlockFn(self: *@This(), i: *css.Parser) Result(This) {
+                            const v = switch (This.parseSum(i, self.ctx, parseIdent)) {
+                                .result => |vv| vv,
+                                .err => |e| return .{ .err = e },
+                            };
+                            switch (v) {
+                                .number => |*n| return .{ .result = This{ .number = std.math.sign(n.*) } },
+                                .value => |v2| {
+                                    const MapFn = struct {
+                                        pub fn sign(s: f32) f32 {
+                                            return std.math.sign(s);
+                                        }
+                                    };
+                                    // First map so we ignore percentages, which must be resolved to their
+                                    // computed value in order to determine the sign.
+                                    if (css.generic.tryMap(V, v2, MapFn.sign)) |new_v| {
+                                        // sign() alwasy resolves to a number.
+                                        return .{
+                                            .result = This{
+                                                // .number = css.generic.trySign(V, &new_v) orelse bun.unreachablePanic("sign always resolved to a number.", .{}),
+                                                .number = css.generic.trySign(V, &new_v) orelse @panic("sign() always resolves to a number."),
+                                            },
+                                        };
+                                    }
+                                },
+                                else => {},
+                            }
+
+                            return .{ .result = This{
+                                .function = bun.create(
+                                    i.allocator(),
+                                    MathFunction(V),
+                                    MathFunction(V){ .sign = v },
+                                ),
+                            } };
+                        }
+                    };
+                    var closure = Closure{ .ctx = ctx };
+                    return input.parseNestedBlock(This, &closure, Closure.parseNestedBlockFn);
+                },
+            }
+        }
+
+        pub fn parseNumericFn(input: *css.Parser, comptime op: enum { sqrt, exp }, ctx: anytype, comptime parse_ident: *const fn (@TypeOf(ctx), []const u8) ?This) Result(This) {
+            const Closure = struct { ctx: @TypeOf(ctx) };
+            var closure = Closure{ .ctx = ctx };
+            return input.parseNestedBlock(This, &closure, struct {
+                pub fn parseNestedBlockFn(self: *Closure, i: *css.Parser) Result(This) {
+                    const v = switch (This.parseNumeric(i, self.ctx, parse_ident)) {
+                        .result => |v| v,
+                        .err => |e| return .{ .err = e },
+                    };
+
+                    return .{
+                        .result = Calc(V){
+                            .number = switch (op) {
+                                .sqrt => std.math.sqrt(v),
+                                .exp => std.math.exp(v),
+                            },
+                        },
+                    };
+                }
+            }.parseNestedBlockFn);
+        }
+
+        pub fn parseMathFn(
+            input: *css.Parser,
+            ctx_for_op_and_fallback: anytype,
+            comptime op: *const fn (@TypeOf(ctx_for_op_and_fallback), f32, f32) f32,
+            comptime fallback: *const fn (@TypeOf(ctx_for_op_and_fallback), This, This) MathFunction(V),
+            ctx_for_parse_ident: anytype,
+            comptime parse_ident: *const fn (@TypeOf(ctx_for_parse_ident), []const u8) ?This,
+        ) Result(This) {
+            const a = switch (This.parseSum(input, ctx_for_parse_ident, parse_ident)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            };
+            if (input.expectComma().asErr()) |e| return .{ .err = e };
+            const b = switch (This.parseSum(input, ctx_for_parse_ident, parse_ident)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            };
+
+            const val = This.applyOp(&a, &b, input.allocator(), ctx_for_op_and_fallback, op) orelse This{
+                .function = bun.create(
+                    input.allocator(),
+                    MathFunction(V),
+                    fallback(ctx_for_op_and_fallback, a, b),
+                ),
+            };
+
+            return .{ .result = val };
+        }
+
+        pub fn parseSum(
+            input: *css.Parser,
+            ctx: anytype,
+            comptime parse_ident: *const fn (@TypeOf(ctx), []const u8) ?This,
+        ) Result(This) {
+            var cur = switch (This.parseProduct(input, ctx, parse_ident)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            };
+            while (true) {
+                const start = input.state();
+                const tok = switch (input.nextIncludingWhitespace()) {
+                    .result => |vv| vv,
+                    .err => {
+                        input.reset(&start);
+                        break;
+                    },
+                };
+
+                if (tok.* == .whitespace) {
+                    if (input.isExhausted()) {
+                        break; // allow trailing whitespace
+                    }
+                    const next_tok = switch (input.next()) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    };
+                    if (next_tok.* == .delim and next_tok.delim == '+') {
+                        const next = switch (Calc(V).parseProduct(input, ctx, parse_ident)) {
+                            .result => |vv| vv,
+                            .err => |e| return .{ .err = e },
+                        };
+                        cur = cur.add(input.allocator(), next);
+                    } else if (next_tok.* == .delim and next_tok.delim == '-') {
+                        var rhs = switch (This.parseProduct(input, ctx, parse_ident)) {
+                            .result => |vv| vv,
+                            .err => |e| return .{ .err = e },
+                        };
+                        rhs = rhs.mulF32(input.allocator(), -1.0);
+                        cur = cur.add(input.allocator(), rhs);
+                    } else {
+                        return .{ .err = input.newUnexpectedTokenError(next_tok.*) };
+                    }
+                    continue;
+                }
+                input.reset(&start);
+                break;
+            }
+
+            return .{ .result = cur };
+        }
+
+        pub fn parseProduct(
+            input: *css.Parser,
+            ctx: anytype,
+            comptime parse_ident: *const fn (@TypeOf(ctx), []const u8) ?This,
+        ) Result(This) {
+            var node = switch (This.parseValue(input, ctx, parse_ident)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            };
+            while (true) {
+                const start = input.state();
+                const tok = switch (input.next()) {
+                    .result => |vv| vv,
+                    .err => {
+                        input.reset(&start);
+                        break;
+                    },
+                };
+
+                if (tok.* == .delim and tok.delim == '*') {
+                    // At least one of the operands must be a number.
+                    const rhs = switch (This.parseValue(input, ctx, parse_ident)) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    };
+                    if (rhs == .number) {
+                        node = node.mulF32(input.allocator(), rhs.number);
+                    } else if (node == .number) {
+                        const val = node.number;
+                        node = rhs;
+                        node = node.mulF32(input.allocator(), val);
+                    } else {
+                        return .{ .err = input.newUnexpectedTokenError(.{ .delim = '*' }) };
+                    }
+                } else if (tok.* == .delim and tok.delim == '/') {
+                    const rhs = switch (This.parseValue(input, ctx, parse_ident)) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    };
+                    if (rhs == .number) {
+                        const val = rhs.number;
+                        node = node.mulF32(input.allocator(), 1.0 / val);
+                        continue;
+                    }
+                    return .{ .err = input.newCustomError(css.ParserError{ .invalid_value = {} }) };
+                } else {
+                    input.reset(&start);
+                    break;
+                }
+            }
+            return .{ .result = node };
+        }
+
+        pub fn parseValue(
+            input: *css.Parser,
+            ctx: anytype,
+            comptime parse_ident: *const fn (@TypeOf(ctx), []const u8) ?This,
+        ) Result(This) {
+            // Parse nested calc() and other math functions.
+            if (input.tryParse(This.parse, .{}).asValue()) |_calc| {
+                const calc: This = _calc;
+                switch (calc) {
+                    .function => |f| return switch (f.*) {
+                        .calc => |c| .{ .result = c },
+                        else => .{ .result = .{ .function = f } },
+                    },
+                    else => return .{ .result = calc },
+                }
+            }
+
+            if (input.tryParse(css.Parser.expectParenthesisBlock, .{}).isOk()) {
+                const Closure = struct {
+                    ctx: @TypeOf(ctx),
+                    pub fn parseNestedBlockFn(self: *@This(), i: *css.Parser) Result(This) {
+                        return This.parseSum(i, self.ctx, parse_ident);
+                    }
+                };
+                var closure = Closure{
+                    .ctx = ctx,
+                };
+                return input.parseNestedBlock(This, &closure, Closure.parseNestedBlockFn);
+            }
+
+            if (input.tryParse(css.Parser.expectNumber, .{}).asValue()) |num| {
+                return .{ .result = .{ .number = num } };
+            }
+
+            if (input.tryParse(Constant.parse, .{}).asValue()) |constant| {
+                return .{ .result = .{ .number = constant.intoF32() } };
+            }
+
+            const location = input.currentSourceLocation();
+            if (input.tryParse(css.Parser.expectIdent, .{}).asValue()) |ident| {
+                if (parse_ident(ctx, ident)) |c| {
+                    return .{ .result = c };
+                }
+
+                return .{ .err = location.newUnexpectedTokenError(.{ .ident = ident }) };
+            }
+
+            const value = switch (input.tryParse(css.generic.parseFor(V), .{})) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            };
+            return .{ .result = .{
+                .value = bun.create(
+                    input.allocator(),
+                    V,
+                    value,
+                ),
+            } };
+        }
+
+        pub fn parseTrig(
+            input: *css.Parser,
+            comptime trig_fn_kind: enum {
+                sin,
+                cos,
+                tan,
+                asin,
+                acos,
+                atan,
+            },
+            to_angle: bool,
+            ctx: anytype,
+            comptime parse_ident: *const fn (@TypeOf(ctx), []const u8) ?This,
+        ) Result(This) {
+            const trig_fn = struct {
+                pub fn run(x: f32) f32 {
+                    const mathfn = comptime switch (trig_fn_kind) {
+                        .sin => std.math.sin,
+                        .cos => std.math.cos,
+                        .tan => std.math.tan,
+                        .asin => std.math.asin,
+                        .acos => std.math.acos,
+                        .atan => std.math.atan,
+                    };
+                    return mathfn(x);
+                }
+            };
+            const Closure = struct {
+                ctx: @TypeOf(ctx),
+                to_angle: bool,
+
+                pub fn parseNestedBockFn(this: *@This(), i: *css.Parser) Result(This) {
+                    const v = switch (Calc(Angle).parseSum(
+                        i,
+                        this,
+                        @This().parseIdentFn,
+                    )) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    };
+
+                    const rad = rad: {
+                        switch (v) {
+                            .value => |angle| {
+                                if (!this.to_angle) break :rad trig_fn.run(angle.toRadians());
+                            },
+                            .number => break :rad trig_fn.run(v.number),
+                            else => {},
+                        }
+                        return .{ .err = i.newCustomError(css.ParserError{ .invalid_value = {} }) };
+                    };
+
+                    if (this.to_angle and !std.math.isNan(rad)) {
+                        if (css.generic.tryFromAngle(V, .{ .rad = rad })) |val| {
+                            return .{ .result = .{
+                                .value = bun.create(
+                                    i.allocator(),
+                                    V,
+                                    val,
+                                ),
+                            } };
+                        }
+                        return .{ .err = i.newCustomError(css.ParserError{ .invalid_value = {} }) };
+                    } else {
+                        return .{ .result = .{ .number = rad } };
+                    }
+                }
+
+                pub fn parseIdentFn(this: *@This(), ident: []const u8) ?Calc(Angle) {
+                    const v = parse_ident(this.ctx, ident) orelse return null;
+                    if (v == .number) return .{ .number = v.number };
+                    return null;
+                }
+            };
+            var closure = Closure{
+                .ctx = ctx,
+                .to_angle = to_angle,
+            };
+            return input.parseNestedBlock(This, &closure, Closure.parseNestedBockFn);
+        }
+
+        pub fn ParseIdentNone(comptime Ctx: type, comptime Value: type) type {
+            return struct {
+                pub fn func(_: Ctx, _: []const u8) ?Calc(Value) {
+                    return null;
+                }
+            };
+        }
+
+        pub fn parseAtan2(
+            input: *css.Parser,
+            ctx: anytype,
+            comptime parse_ident: *const fn (@TypeOf(ctx), []const u8) ?This,
+        ) Result(Angle) {
+            const Ctx = @TypeOf(ctx);
+
+            // atan2 supports arguments of any <number>, <dimension>, or <percentage>, even ones that wouldn't
+            // normally be supported by V. The only requirement is that the arguments be of the same type.
+            // Try parsing with each type, and return the first one that parses successfully.
+            if (tryParseAtan2Args(Ctx, Length, input, ctx).asValue()) |v| {
+                return .{ .result = v };
+            }
+
+            if (tryParseAtan2Args(Ctx, Percentage, input, ctx).asValue()) |v| {
+                return .{ .result = v };
+            }
+
+            if (tryParseAtan2Args(Ctx, Angle, input, ctx).asValue()) |v| {
+                return .{ .result = v };
+            }
+
+            if (tryParseAtan2Args(Ctx, Time, input, ctx).asValue()) |v| {
+                return .{ .result = v };
+            }
+
+            const Closure = struct {
+                ctx: @TypeOf(ctx),
+
+                pub fn parseIdentFn(self: *@This(), ident: []const u8) ?Calc(CSSNumber) {
+                    const v = parse_ident(self.ctx, ident) orelse return null;
+                    if (v == .number) return .{ .number = v.number };
+                    return null;
+                }
+            };
+            var closure = Closure{
+                .ctx = ctx,
+            };
+            return Calc(CSSNumber).parseAtan2Args(input, &closure, Closure.parseIdentFn);
+        }
+
+        inline fn tryParseAtan2Args(
+            comptime Ctx: type,
+            comptime Value: type,
+            input: *css.Parser,
+            ctx: Ctx,
+        ) Result(Angle) {
+            const func = ParseIdentNone(Ctx, Value).func;
+            return input.tryParseImpl(Result(Angle), Calc(Value).parseAtan2Args, .{ input, ctx, func });
+        }
+
+        pub fn parseAtan2Args(
+            input: *css.Parser,
+            ctx: anytype,
+            comptime parse_ident: *const fn (@TypeOf(ctx), []const u8) ?This,
+        ) Result(Angle) {
+            const a = switch (This.parseSum(input, ctx, parse_ident)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            };
+            if (input.expectComma().asErr()) |e| return .{ .err = e };
+            const b = switch (This.parseSum(input, ctx, parse_ident)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            };
+
+            if (a == .value and b == .value) {
+                const Fn = struct {
+                    pub fn opToFn(_: void, x: f32, y: f32) Angle {
+                        return .{ .rad = std.math.atan2(x, y) };
+                    }
+                };
+                if (css.generic.tryOpTo(V, Angle, a.value, b.value, {}, Fn.opToFn)) |v| {
+                    return .{ .result = v };
+                }
+            } else if (a == .number and b == .number) {
+                return .{ .result = Angle{ .rad = std.math.atan2(a.number, b.number) } };
+            } else {
+                // doo nothing
+            }
+
+            // We don't have a way to represent arguments that aren't angles, so just error.
+            // This will fall back to an unparsed property, leaving the atan2() function intact.
+            return .{ .err = input.newCustomError(css.ParserError{ .invalid_value = {} }) };
+        }
+
+        pub fn parseNumeric(
+            input: *css.Parser,
+            ctx: anytype,
+            comptime parse_ident: *const fn (@TypeOf(ctx), []const u8) ?This,
+        ) Result(f32) {
+            const Closure = struct {
+                ctx: @TypeOf(ctx),
+
+                pub fn parseIdentFn(self: *@This(), ident: []const u8) ?Calc(CSSNumber) {
+                    const v = parse_ident(self.ctx, ident) orelse return null;
+                    if (v == .number) return .{ .number = v.number };
+                    return null;
+                }
+            };
+            var closure = Closure{
+                .ctx = ctx,
+            };
+            const v: Calc(CSSNumber) = switch (Calc(CSSNumber).parseSum(input, &closure, Closure.parseIdentFn)) {
+                .result => |v| v,
+                .err => |e| return .{ .err = e },
+            };
+            const val = switch (v) {
+                .number => v.number,
+                .value => v.value.*,
+                else => return .{ .err = input.newCustomError(css.ParserError.invalid_value) },
+            };
+            return .{ .result = val };
+        }
+
+        pub fn parseHypot(allocator: Allocator, args: *ArrayList(This)) Result(?This) {
+            if (args.items.len == 1) {
+                const v = args.items[0];
+                args.items[0] = This{ .number = 0 };
+                return .{ .result = v };
+            }
+
+            if (args.items.len == 2) {
+                return .{ .result = This.applyOp(&args.items[0], &args.items[1], allocator, {}, hypot) };
+            }
+
+            var i: usize = 0;
+            const first = if (This.applyMap(
+                &args.items[0],
+                allocator,
+                powi2,
+            )) |v| v else return .{ .result = null };
+            i += 1;
+            var errored: bool = false;
+            var sum: This = first;
+            for (args.items[i..]) |*arg| {
+                const Fn = struct {
+                    pub fn applyOpFn(_: void, a: f32, b: f32) f32 {
+                        return a + bun.powf(b, 2);
+                    }
+                };
+                sum = This.applyOp(&sum, arg, allocator, {}, Fn.applyOpFn) orelse {
+                    errored = true;
+                    break;
+                };
+            }
+
+            if (errored) return .{ .result = null };
+
+            return .{ .result = This.applyMap(&sum, allocator, sqrtf32) };
+        }
+
+        pub fn applyOp(
+            a: *const This,
+            b: *const This,
+            allocator: std.mem.Allocator,
+            ctx: anytype,
+            comptime op: *const fn (@TypeOf(ctx), f32, f32) f32,
+        ) ?This {
+            if (a.* == .value and b.* == .value) {
+                if (css.generic.tryOp(V, a.value, b.value, ctx, op)) |v| {
+                    return This{
+                        .value = bun.create(
+                            allocator,
+                            V,
+                            v,
+                        ),
+                    };
+                }
+                return null;
+            }
+
+            if (a.* == .number and b.* == .number) {
+                return This{
+                    .number = op(ctx, a.number, b.number),
+                };
+            }
+
+            return null;
+        }
+
+        pub fn applyMap(this: *const This, allocator: Allocator, comptime op: *const fn (f32) f32) ?This {
+            switch (this.*) {
+                .number => |n| return This{ .number = op(n) },
+                .value => |v| {
+                    if (css.generic.tryMap(V, v, op)) |new_v| {
+                        return This{
+                            .value = bun.create(
+                                allocator,
+                                V,
+                                new_v,
+                            ),
+                        };
+                    }
+                },
+                else => {},
+            }
+
+            return null;
+        }
+
+        pub fn toCss(this: *const @This(), comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+            const was_in_calc = dest.in_calc;
+            dest.in_calc = true;
+
+            const res = toCssImpl(this, W, dest);
+
+            dest.in_calc = was_in_calc;
+            return res;
+        }
+
+        pub fn toCssImpl(this: *const @This(), comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+            return switch (this.*) {
+                .value => |v| v.toCss(W, dest),
+                .number => |n| CSSNumberFns.toCss(&n, W, dest),
+                .sum => |sum| {
+                    const a = sum.left;
+                    const b = sum.right;
+                    try a.toCss(W, dest);
+                    // White space is always required.
+                    if (b.isSignNegative()) {
+                        try dest.writeStr(" - ");
+                        var b2 = b.deepClone(dest.allocator).mulF32(dest.allocator, -1.0);
+                        defer b2.deinit(dest.allocator);
+                        try b2.toCss(W, dest);
+                    } else {
+                        try dest.writeStr(" + ");
+                        try b.toCss(W, dest);
+                    }
+                    return;
+                },
+                .product => {
+                    const num = this.product.number;
+                    const calc = this.product.expression;
+                    if (@abs(num) < 1.0) {
+                        const div = 1.0 / num;
+                        try calc.toCss(W, dest);
+                        try dest.delim('/', true);
+                        try CSSNumberFns.toCss(&div, W, dest);
+                    } else {
+                        try CSSNumberFns.toCss(&num, W, dest);
+                        try dest.delim('*', true);
+                        try calc.toCss(W, dest);
+                    }
+                },
+                .function => |f| return f.toCss(W, dest),
+            };
+        }
+
+        pub fn trySign(this: *const @This()) ?f32 {
+            return switch (this.*) {
+                .value => |v| return switch (V) {
+                    f32 => css.signfns.signF32(v),
+                    else => v.trySign(),
+                },
+                .number => |n| css.signfns.signF32(n),
+                else => null,
+            };
+        }
+
+        pub fn isSignNegative(this: *const @This()) bool {
+            return css.signfns.isSignNegative(this.trySign() orelse return false);
+        }
+
+        pub fn mulF32(this: @This(), allocator: Allocator, other: f32) This {
+            if (other == 1.0) {
+                return this;
+            }
+
+            return switch (this) {
+                // PERF: why not reuse the allocation here?
+                .value => This{ .value = bun.create(allocator, V, mulValueF32(this.value.*, allocator, other)) },
+                .number => This{ .number = this.number * other },
+                // PERF: why not reuse the allocation here?
+                .sum => This{ .sum = .{
+                    .left = bun.create(
+                        allocator,
+                        This,
+                        this.sum.left.mulF32(allocator, other),
+                    ),
+                    .right = bun.create(
+                        allocator,
+                        This,
+                        this.sum.right.mulF32(allocator, other),
+                    ),
+                } },
+                .product => {
+                    const num = this.product.number * other;
+                    if (num == 1.0) {
+                        return this.product.expression.*;
+                    }
+                    return This{
+                        .product = .{
+                            .number = num,
+                            .expression = this.product.expression,
+                        },
+                    };
+                },
+                .function => switch (this.function.*) {
+                    // PERF: why not reuse the allocation here?
+                    .calc => This{
+                        .function = bun.create(
+                            allocator,
+                            MathFunction(V),
+                            MathFunction(V){
+                                .calc = this.function.calc.mulF32(allocator, other),
+                            },
+                        ),
+                    },
+                    else => This{
+                        .product = .{
+                            .number = other,
+                            .expression = bun.create(allocator, This, this),
+                        },
+                    },
+                },
+            };
+        }
+
+        /// PERF:
+        /// I don't like how this function requires allocating a second ArrayList
+        /// I am pretty sure we could do this reduction in place, or do it as the
+        /// arguments are being parsed.
+        fn reduceArgs(allocator: Allocator, args: *ArrayList(This), order: std.math.Order) void {
+            // Reduces the arguments of a min() or max() expression, combining compatible values.
+            // e.g. min(1px, 1em, 2px, 3in) => min(1px, 1em)
+            var reduced = ArrayList(This){};
+
+            for (args.items) |*arg| {
+                var found: ??*Calc(V) = null;
+                switch (arg.*) {
+                    .value => |val| {
+                        for (reduced.items) |*b| {
+                            switch (b.*) {
+                                .value => |v| {
+                                    const result = css.generic.partialCmp(V, val, v);
+                                    if (result != null) {
+                                        if (result == order) {
+                                            found = b;
+                                            break;
+                                        } else {
+                                            found = @as(?*Calc(V), null);
+                                            break;
+                                        }
+                                    }
+                                },
+                                else => {},
+                            }
+                        }
+                    },
+                    else => {},
+                }
+
+                if (found) |__r| {
+                    if (__r) |r| {
+                        r.* = arg.*;
+                        // set to dummy value since we moved it into `reduced`
+                        arg.* = This{ .number = 420 };
+                        continue;
+                    }
+                } else {
+                    reduced.append(allocator, arg.*) catch bun.outOfMemory();
+                    // set to dummy value since we moved it into `reduced`
+                    arg.* = This{ .number = 420 };
+                    continue;
+                }
+                arg.deinit(allocator);
+                arg.* = This{ .number = 420 };
+            }
+
+            css.deepDeinit(This, allocator, args);
+            args.* = reduced;
+        }
+
+        pub fn isCompatible(this: *const @This(), browsers: css.targets.Browsers) bool {
+            return switch (this.*) {
+                .sum => |*args| return args.left.isCompatible(browsers) and args.right.isCompatible(browsers),
+                .product => |*args| return args.expression.isCompatible(browsers),
+                .function => |f| f.isCompatible(browsers),
+                .value => |v| v.isCompatible(browsers),
+                .number => true,
+            };
+        }
+    };
+}
+
+/// A CSS math function.
+///
+/// Math functions may be used in most properties and values that accept numeric
+/// values, including lengths, percentages, angles, times, etc.
+pub fn MathFunction(comptime V: type) type {
+    return union(enum) {
+        /// The `calc()` function.
+        calc: Calc(V),
+        /// The `min()` function.
+        min: ArrayList(Calc(V)),
+        /// The `max()` function.
+        max: ArrayList(Calc(V)),
+        /// The `clamp()` function.
+        clamp: struct {
+            min: Calc(V),
+            center: Calc(V),
+            max: Calc(V),
+        },
+        /// The `round()` function.
+        round: struct {
+            strategy: RoundingStrategy,
+            value: Calc(V),
+            interval: Calc(V),
+        },
+        /// The `rem()` function.
+        rem: struct {
+            dividend: Calc(V),
+            divisor: Calc(V),
+        },
+        /// The `mod()` function.
+        mod_: struct {
+            dividend: Calc(V),
+            divisor: Calc(V),
+        },
+        /// The `abs()` function.
+        abs: Calc(V),
+        /// The `sign()` function.
+        sign: Calc(V),
+        /// The `hypot()` function.
+        hypot: ArrayList(Calc(V)),
+
+        pub fn eql(this: *const @This(), other: *const @This()) bool {
+            return switch (this.*) {
+                .calc => |a| return other.* == .calc and a.eql(&other.calc),
+                .min => |*a| return other.* == .min and css.generic.eqlList(Calc(V), a, &other.min),
+                .max => |*a| return other.* == .max and css.generic.eqlList(Calc(V), a, &other.max),
+                .clamp => |*a| return other.* == .clamp and a.min.eql(&other.clamp.min) and a.center.eql(&other.clamp.center) and a.max.eql(&other.clamp.max),
+                .round => |*a| return other.* == .round and a.strategy == other.round.strategy and a.value.eql(&other.round.value) and a.interval.eql(&other.round.interval),
+                .rem => |*a| return other.* == .rem and a.dividend.eql(&other.rem.dividend) and a.divisor.eql(&other.rem.divisor),
+                .mod_ => |*a| return other.* == .mod_ and a.dividend.eql(&other.mod_.dividend) and a.divisor.eql(&other.mod_.divisor),
+                .abs => |*a| return other.* == .abs and a.eql(&other.abs),
+                .sign => |*a| return other.* == .sign and a.eql(&other.sign),
+                .hypot => |*a| return other.* == .hypot and css.generic.eqlList(Calc(V), a, &other.hypot),
+            };
+        }
+
+        pub fn deepClone(this: *const @This(), allocator: Allocator) @This() {
+            return switch (this.*) {
+                .calc => |*calc| .{ .calc = calc.deepClone(allocator) },
+                .min => |*min| .{ .min = css.deepClone(Calc(V), allocator, min) },
+                .max => |*max| .{ .max = css.deepClone(Calc(V), allocator, max) },
+                .clamp => |*clamp| .{
+                    .clamp = .{
+                        .min = clamp.min.deepClone(allocator),
+                        .center = clamp.center.deepClone(allocator),
+                        .max = clamp.max.deepClone(allocator),
+                    },
+                },
+                .round => |*rnd| .{ .round = .{
+                    .strategy = rnd.strategy,
+                    .value = rnd.value.deepClone(allocator),
+                    .interval = rnd.interval.deepClone(allocator),
+                } },
+                .rem => |*rem| .{ .rem = .{
+                    .dividend = rem.dividend.deepClone(allocator),
+                    .divisor = rem.divisor.deepClone(allocator),
+                } },
+                .mod_ => |*mod_| .{ .mod_ = .{
+                    .dividend = mod_.dividend.deepClone(allocator),
+                    .divisor = mod_.divisor.deepClone(allocator),
+                } },
+                .abs => |*abs| .{ .abs = abs.deepClone(allocator) },
+                .sign => |*sign| .{ .sign = sign.deepClone(allocator) },
+                .hypot => |*hyp| .{
+                    .hypot = css.deepClone(Calc(V), allocator, hyp),
+                },
+            };
+        }
+
+        pub fn deinit(this: *@This(), allocator: Allocator) void {
+            switch (this.*) {
+                .calc => |*calc| calc.deinit(allocator),
+                .min => |*min| css.deepDeinit(Calc(V), allocator, min),
+                .max => |*max| css.deepDeinit(Calc(V), allocator, max),
+                .clamp => |*clamp| {
+                    clamp.min.deinit(allocator);
+                    clamp.center.deinit(allocator);
+                    clamp.max.deinit(allocator);
+                },
+                .round => |*rnd| {
+                    rnd.value.deinit(allocator);
+                    rnd.interval.deinit(allocator);
+                },
+                .rem => |*rem| {
+                    rem.dividend.deinit(allocator);
+                    rem.divisor.deinit(allocator);
+                },
+                .mod_ => |*mod_| {
+                    mod_.dividend.deinit(allocator);
+                    mod_.divisor.deinit(allocator);
+                },
+                .abs => |*abs| {
+                    abs.deinit(allocator);
+                },
+                .sign => |*sign| {
+                    sign.deinit(allocator);
+                },
+                .hypot => |*hyp| {
+                    css.deepDeinit(Calc(V), allocator, hyp);
+                },
+            }
+        }
+
+        pub fn toCss(this: *const @This(), comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+            return switch (this.*) {
+                .calc => |*calc| {
+                    try dest.writeStr("calc(");
+                    try calc.toCss(W, dest);
+                    try dest.writeChar(')');
+                },
+                .min => |*args| {
+                    try dest.writeStr("min(");
+                    var first = true;
+                    for (args.items) |*arg| {
+                        if (first) {
+                            first = false;
+                        } else {
+                            try dest.delim(',', false);
+                        }
+                        try arg.toCss(W, dest);
+                    }
+                    try dest.writeChar(')');
+                },
+                .max => |*args| {
+                    try dest.writeStr("max(");
+                    var first = true;
+                    for (args.items) |*arg| {
+                        if (first) {
+                            first = false;
+                        } else {
+                            try dest.delim(',', false);
+                        }
+                        try arg.toCss(W, dest);
+                    }
+                    try dest.writeChar(')');
+                },
+                .clamp => |*clamp| {
+                    try dest.writeStr("clamp(");
+                    try clamp.min.toCss(W, dest);
+                    try dest.delim(',', false);
+                    try clamp.center.toCss(W, dest);
+                    try dest.delim(',', false);
+                    try clamp.max.toCss(W, dest);
+                    try dest.writeChar(')');
+                },
+                .round => |*rnd| {
+                    try dest.writeStr("round(");
+                    if (rnd.strategy != RoundingStrategy.default()) {
+                        try rnd.strategy.toCss(W, dest);
+                        try dest.delim(',', false);
+                    }
+                    try rnd.value.toCss(W, dest);
+                    try dest.delim(',', false);
+                    try rnd.interval.toCss(W, dest);
+                    try dest.writeChar(')');
+                },
+                .rem => |*rem| {
+                    try dest.writeStr("rem(");
+                    try rem.dividend.toCss(W, dest);
+                    try dest.delim(',', false);
+                    try rem.divisor.toCss(W, dest);
+                    try dest.writeChar(')');
+                },
+                .mod_ => |*mod_| {
+                    try dest.writeStr("mod(");
+                    try mod_.dividend.toCss(W, dest);
+                    try dest.delim(',', false);
+                    try mod_.divisor.toCss(W, dest);
+                    try dest.writeChar(')');
+                },
+                .abs => |*v| {
+                    try dest.writeStr("abs(");
+                    try v.toCss(W, dest);
+                    try dest.writeChar(')');
+                },
+                .sign => |*v| {
+                    try dest.writeStr("sign(");
+                    try v.toCss(W, dest);
+                    try dest.writeChar(')');
+                },
+                .hypot => |*args| {
+                    try dest.writeStr("hypot(");
+                    var first = true;
+                    for (args.items) |*arg| {
+                        if (first) {
+                            first = false;
+                        } else {
+                            try dest.delim(',', false);
+                        }
+                        try arg.toCss(W, dest);
+                    }
+                    try dest.writeChar(')');
+                },
+            };
+        }
+
+        pub fn isCompatible(this: *const @This(), browsers: css.targets.Browsers) bool {
+            const F = css.compat.Feature;
+            return switch (this.*) {
+                .calc => |*c| F.isCompatible(F.calc_function, browsers) and c.isCompatible(browsers),
+                .min => |*m| F.isCompatible(F.min_function, browsers) and brk: {
+                    for (m.items) |*arg| {
+                        if (!arg.isCompatible(browsers)) {
+                            break :brk false;
+                        }
+                    }
+                    break :brk true;
+                },
+                .max => |*m| F.isCompatible(F.max_function, browsers) and brk: {
+                    for (m.items) |*arg| {
+                        if (!arg.isCompatible(browsers)) {
+                            break :brk false;
+                        }
+                    }
+                    break :brk true;
+                },
+                .clamp => |*c| F.isCompatible(F.clamp_function, browsers) and
+                    c.min.isCompatible(browsers) and
+                    c.center.isCompatible(browsers) and
+                    c.max.isCompatible(browsers),
+                .round => |*r| F.isCompatible(F.round_function, browsers) and
+                    r.value.isCompatible(browsers) and
+                    r.interval.isCompatible(browsers),
+                .rem => |*r| F.isCompatible(F.rem_function, browsers) and
+                    r.dividend.isCompatible(browsers) and
+                    r.divisor.isCompatible(browsers),
+                .mod_ => |*m| F.isCompatible(F.mod_function, browsers) and
+                    m.dividend.isCompatible(browsers) and
+                    m.divisor.isCompatible(browsers),
+                .abs => |*a| F.isCompatible(F.abs_function, browsers) and
+                    a.isCompatible(browsers),
+                .sign => |*s| F.isCompatible(F.sign_function, browsers) and
+                    s.isCompatible(browsers),
+                .hypot => |*h| F.isCompatible(F.hypot_function, browsers) and brk: {
+                    for (h.items) |*arg| {
+                        if (!arg.isCompatible(browsers)) {
+                            break :brk false;
+                        }
+                    }
+                    break :brk true;
+                },
+            };
+        }
+    };
+}
+
+/// A [rounding strategy](https://www.w3.org/TR/css-values-4/#typedef-rounding-strategy),
+/// as used in the `round()` function.
+pub const RoundingStrategy = enum {
+    /// Round to the nearest integer.
+    nearest,
+    /// Round up (ceil).
+    up,
+    /// Round down (floor).
+    down,
+    /// Round toward zero (truncate).
+    @"to-zero",
+
+    pub fn asStr(this: *const @This()) []const u8 {
+        return css.enum_property_util.asStr(@This(), this);
+    }
+
+    pub fn parse(input: *css.Parser) Result(@This()) {
+        return css.enum_property_util.parse(@This(), input);
+    }
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+        return css.enum_property_util.toCss(@This(), this, W, dest);
+    }
+
+    pub fn default() RoundingStrategy {
+        return .nearest;
+    }
+};
+
+fn arr2(allocator: std.mem.Allocator, a: anytype, b: anytype) ArrayList(@TypeOf(a)) {
+    const T = @TypeOf(a);
+    if (T != @TypeOf(b)) {
+        @compileError("arr2: types must match");
+    }
+    var arr = ArrayList(T){};
+    arr.appendSlice(allocator, &.{ a, b }) catch bun.outOfMemory();
+    return arr;
+}
+
+fn round(_: void, value: f32, to: f32, strategy: RoundingStrategy) f32 {
+    const v = value / to;
+    return switch (strategy) {
+        .down => @floor(v) * to,
+        .up => @ceil(v) * to,
+        .nearest => @round(v) * to,
+        .@"to-zero" => @trunc(v) * to,
+    };
+}
+
+fn hypot(_: void, a: f32, b: f32) f32 {
+    return std.math.hypot(a, b);
+}
+
+fn powi2(v: f32) f32 {
+    return bun.powf(v, 2);
+}
+
+fn sqrtf32(v: f32) f32 {
+    return std.math.sqrt(v);
+}
+/// A mathematical constant.
+pub const Constant = enum {
+    /// The base of the natural logarithm
+    e,
+    /// The ratio of a circle's circumference to its diameter
+    pi,
+    /// infinity
+    infinity,
+    /// -infinity
+    @"-infinity",
+    /// Not a number.
+    nan,
+
+    pub fn asStr(this: *const @This()) []const u8 {
+        return css.enum_property_util.asStr(@This(), this);
+    }
+
+    pub fn parse(input: *css.Parser) Result(@This()) {
+        return css.enum_property_util.parse(@This(), input);
+    }
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+        return css.enum_property_util.toCss(@This(), this, W, dest);
+    }
+
+    pub fn intoF32(this: *const @This()) f32 {
+        return switch (this.*) {
+            .e => std.math.e,
+            .pi => std.math.pi,
+            .infinity => std.math.inf(f32),
+            .@"-infinity" => -std.math.inf(f32),
+            .nan => std.math.nan(f32),
+        };
+    }
+};
+
+fn absf(a: f32) f32 {
+    return @abs(a);
+}
diff --git a/src/css/values/color.zig b/src/css/values/color.zig
new file mode 100644
index 0000000000..e742af54b7
--- /dev/null
+++ b/src/css/values/color.zig
@@ -0,0 +1,4445 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const bun = @import("root").bun;
+const logger = bun.logger;
+const Log = logger.Log;
+
+pub const css = @import("../css_parser.zig");
+pub const Result = css.Result;
+
+const Percentage = css.css_values.percentage.Percentage;
+const CSSNumberFns = css.css_values.number.CSSNumberFns;
+const Calc = css.css_values.calc.Calc;
+const Angle = css.css_values.angle.Angle;
+
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+
+pub fn UnboundedColorGamut(comptime T: type) type {
+    return struct {
+        pub fn inGamut(_: *const T) bool {
+            return true;
+        }
+
+        pub fn clip(this: *const T) T {
+            return this.*;
+        }
+    };
+}
+
+pub fn HslHwbColorGamut(comptime T: type, comptime a: []const u8, comptime b: []const u8) type {
+    return struct {
+        pub fn inGamut(this: *const T) bool {
+            return @field(this, a) >= 0.0 and
+                @field(this, a) <= 1.0 and
+                @field(this, b) >= 0.0 and
+                @field(this, b) <= 1.0;
+        }
+
+        pub fn clip(this: *const T) T {
+            var result: T = this.*;
+            // result.h = this.h % 360.0;
+            result.h = @mod(this.h, 360.0);
+            @field(result, a) = bun.clamp(@field(this, a), 0.0, 1.0);
+            @field(result, b) = bun.clamp(@field(this, b), 0.0, 1.0);
+            result.alpha = bun.clamp(this.alpha, 0.0, 1.0);
+            return result;
+        }
+    };
+}
+
+/// A CSS `<color>` value.
+///
+/// CSS supports many different color spaces to represent colors. The most common values
+/// are stored as RGBA using a single byte per component. Less common values are stored
+/// using a `Box` to reduce the amount of memory used per color.
+///
+/// Each color space is represented as a struct that implements the `From` and `Into` traits
+/// for all other color spaces, so it is possible to convert between color spaces easily.
+/// In addition, colors support interpolation as in the `color-mix()` function.
+pub const CssColor = union(enum) {
+    /// The `currentColor` keyword.
+    current_color,
+    /// A value in the RGB color space, including values parsed as hex colors, or the `rgb()`, `hsl()`, and `hwb()` functions.
+    rgba: RGBA,
+    /// A value in a LAB color space, including the `lab()`, `lch()`, `oklab()`, and `oklch()` functions.
+    lab: *LABColor,
+    /// A value in a predefined color space, e.g. `display-p3`.
+    predefined: *PredefinedColor,
+    /// A floating point representation of an RGB, HSL, or HWB color when it contains `none` components.
+    float: *FloatColor,
+    /// The `light-dark()` function.
+    light_dark: struct {
+        // TODO: why box the two fields separately? why not one allocation?
+        light: *CssColor,
+        dark: *CssColor,
+
+        pub fn takeLightFreeDark(this: *const @This(), allocator: Allocator) *CssColor {
+            const ret = this.light;
+            this.dark.deinit(allocator);
+            allocator.destroy(this.dark);
+            return ret;
+        }
+
+        pub fn takeDarkFreeLight(this: *const @This(), allocator: Allocator) *CssColor {
+            const ret = this.dark;
+            this.light.deinit(allocator);
+            allocator.destroy(this.light);
+            return ret;
+        }
+
+        pub fn __generateHash() void {}
+    },
+    /// A system color keyword.
+    system: SystemColor,
+
+    const This = @This();
+
+    pub const jsFunctionColor = @import("./color_js.zig").jsFunctionColor;
+
+    pub fn isCompatible(this: *const CssColor, browsers: css.targets.Browsers) bool {
+        return switch (this.*) {
+            .current_color, .rgba, .float => true,
+            .lab => |lab| switch (lab.*) {
+                .lab, .lch => css.Feature.isCompatible(.lab_colors, browsers),
+                .oklab, .oklch => css.Feature.isCompatible(.oklab_colors, browsers),
+            },
+            .predefined => |predefined| switch (predefined.*) {
+                .display_p3 => css.Feature.isCompatible(.p3_colors, browsers),
+                else => css.Feature.isCompatible(.color_function, browsers),
+            },
+            .light_dark => |light_dark| css.Feature.isCompatible(.light_dark, browsers) and
+                light_dark.light.isCompatible(browsers) and
+                light_dark.dark.isCompatible(browsers),
+            .system => |system| system.isCompatible(browsers),
+        };
+    }
+
+    pub fn toCss(
+        this: *const This,
+        comptime W: type,
+        dest: *Printer(W),
+    ) PrintErr!void {
+        switch (this.*) {
+            .current_color => try dest.writeStr("currentColor"),
+            .rgba => |*color| {
+                if (color.alpha == 255) {
+                    const hex: u32 = (@as(u32, color.red) << 16) | (@as(u32, color.green) << 8) | @as(u32, color.blue);
+                    if (shortColorName(hex)) |name| return dest.writeStr(name);
+
+                    const compact = compactHex(hex);
+                    if (hex == expandHex(compact)) {
+                        try dest.writeFmt("#{x:0>3}", .{compact});
+                    } else {
+                        try dest.writeFmt("#{x:0>6}", .{hex});
+                    }
+                } else {
+                    // If the #rrggbbaa syntax is not supported by the browser targets, output rgba()
+                    if (dest.targets.shouldCompileSame(.hex_alpha_colors)) {
+                        // If the browser doesn't support `#rrggbbaa` color syntax, it is converted to `transparent` when compressed(minify = true).
+                        // https://www.w3.org/TR/css-color-4/#transparent-black
+                        if (dest.minify and color.red == 0 and color.green == 0 and color.blue == 0 and color.alpha == 0) {
+                            return dest.writeStr("transparent");
+                        } else {
+                            try dest.writeFmt("rgba({d}", .{color.red});
+                            try dest.delim(',', false);
+                            try dest.writeFmt("{d}", .{color.green});
+                            try dest.delim(',', false);
+                            try dest.writeFmt("{d}", .{color.blue});
+                            try dest.delim(',', false);
+
+                            // Try first with two decimal places, then with three.
+                            var rounded_alpha = @round(color.alphaF32() * 100.0) / 100.0;
+                            const clamped: u8 = @intFromFloat(@min(
+                                @max(
+                                    @round(rounded_alpha * 255.0),
+                                    0.0,
+                                ),
+                                255.0,
+                            ));
+                            if (clamped != color.alpha) {
+                                rounded_alpha = @round(color.alphaF32() * 1000.0) / 1000.0;
+                            }
+
+                            try CSSNumberFns.toCss(&rounded_alpha, W, dest);
+                            try dest.writeChar(')');
+                            return;
+                        }
+                    }
+
+                    const hex: u32 = (@as(u32, color.red) << 24) |
+                        (@as(u32, color.green) << 16) |
+                        (@as(u32, color.blue) << 8) |
+                        (@as(u32, color.alpha));
+                    const compact = compactHex(hex);
+                    if (hex == expandHex(compact)) {
+                        try dest.writeFmt("#{x:0>4}", .{compact});
+                    } else {
+                        try dest.writeFmt("#{x:0>8}", .{hex});
+                    }
+                }
+                return;
+            },
+            .lab => |_lab| {
+                return switch (_lab.*) {
+                    .lab => |*lab| writeComponents(
+                        "lab",
+                        lab.l,
+                        lab.a,
+                        lab.b,
+                        lab.alpha,
+                        W,
+                        dest,
+                    ),
+                    .lch => |*lch| writeComponents(
+                        "lch",
+                        lch.l,
+                        lch.c,
+                        lch.h,
+                        lch.alpha,
+                        W,
+                        dest,
+                    ),
+                    .oklab => |*oklab| writeComponents(
+                        "oklab",
+                        oklab.l,
+                        oklab.a,
+                        oklab.b,
+                        oklab.alpha,
+                        W,
+                        dest,
+                    ),
+                    .oklch => |*oklch| writeComponents(
+                        "oklch",
+                        oklch.l,
+                        oklch.c,
+                        oklch.h,
+                        oklch.alpha,
+                        W,
+                        dest,
+                    ),
+                };
+            },
+            .predefined => |predefined| return writePredefined(predefined, W, dest),
+            .float => |*float| {
+                // Serialize as hex.
+                const srgb = SRGB.fromFloatColor(float.*);
+                const as_css_color = srgb.intoCssColor(dest.allocator);
+                defer as_css_color.deinit(dest.allocator);
+                try as_css_color.toCss(W, dest);
+            },
+            .light_dark => |*light_dark| {
+                if (!dest.targets.isCompatible(css.compat.Feature.light_dark)) {
+                    // TODO(zack): lightningcss -> buncss
+                    try dest.writeStr("var(--lightningcss-light");
+                    try dest.delim(',', false);
+                    try light_dark.light.toCss(W, dest);
+                    try dest.writeChar(')');
+                    try dest.whitespace();
+                    try dest.writeStr("var(--lightningcss-dark");
+                    try dest.delim(',', false);
+                    try light_dark.dark.toCss(W, dest);
+                    try light_dark.dark.toCss(W, dest);
+                    return dest.writeChar(')');
+                }
+
+                try dest.writeStr("light-dark(");
+                try light_dark.light.toCss(W, dest);
+                try dest.delim(',', false);
+                try light_dark.dark.toCss(W, dest);
+                return dest.writeChar(')');
+            },
+            .system => |*system| return system.toCss(W, dest),
+        }
+    }
+
+    pub const ParseResult = Result(CssColor);
+    pub fn parse(input: *css.Parser) ParseResult {
+        const location = input.currentSourceLocation();
+        const token = switch (input.next()) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+
+        switch (token.*) {
+            .hash, .idhash => |v| {
+                const r, const g, const b, const a = css.color.parseHashColor(v) orelse return .{ .err = location.newUnexpectedTokenError(token.*) };
+                return .{ .result = .{
+                    .rgba = RGBA.new(r, g, b, a),
+                } };
+            },
+            .ident => |value| {
+                if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(value, "currentcolor")) {
+                    return .{ .result = .current_color };
+                } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(value, "transparent")) {
+                    return .{ .result = .{
+                        .rgba = RGBA.transparent(),
+                    } };
+                } else {
+                    if (css.color.parseNamedColor(value)) |named| {
+                        const r, const g, const b = named;
+                        return .{ .result = .{ .rgba = RGBA.new(r, g, b, 255.0) } };
+                        // } else if (SystemColor.parseString(value)) |system_color| {
+                    } else if (css.parse_utility.parseString(input.allocator(), SystemColor, value, SystemColor.parse).asValue()) |system_color| {
+                        return .{ .result = .{ .system = system_color } };
+                    } else return .{ .err = location.newUnexpectedTokenError(token.*) };
+                }
+            },
+            .function => |name| return parseColorFunction(location, name, input),
+            else => return .{
+                .err = location.newUnexpectedTokenError(token.*),
+            },
+        }
+    }
+
+    pub fn deinit(this: CssColor, allocator: Allocator) void {
+        switch (this) {
+            .current_color => {},
+            .rgba => {},
+            .lab => {
+                allocator.destroy(this.lab);
+            },
+            .predefined => {
+                allocator.destroy(this.predefined);
+            },
+            .float => {
+                allocator.destroy(this.float);
+            },
+            .light_dark => {
+                this.light_dark.light.deinit(allocator);
+                this.light_dark.dark.deinit(allocator);
+                allocator.destroy(this.light_dark.light);
+                allocator.destroy(this.light_dark.dark);
+            },
+            .system => {},
+        }
+    }
+
+    pub fn deepClone(this: *const CssColor, allocator: Allocator) CssColor {
+        return switch (this.*) {
+            .current_color => .current_color,
+            .rgba => |rgba| CssColor{ .rgba = rgba },
+            .lab => |lab| CssColor{ .lab = bun.create(allocator, LABColor, lab.*) },
+            .predefined => |pre| CssColor{ .predefined = bun.create(allocator, PredefinedColor, pre.*) },
+            .float => |float| CssColor{ .float = bun.create(allocator, FloatColor, float.*) },
+            .light_dark => CssColor{
+                .light_dark = .{
+                    .light = bun.create(allocator, CssColor, this.light_dark.light.deepClone(allocator)),
+                    .dark = bun.create(allocator, CssColor, this.light_dark.dark.deepClone(allocator)),
+                },
+            },
+            .system => |sys| CssColor{ .system = sys },
+        };
+    }
+
+    pub fn toLightDark(this: *const CssColor, allocator: Allocator) CssColor {
+        return switch (this.*) {
+            .light_dark => this.deepClone(allocator),
+            else => .{
+                .light_dark = .{
+                    .light = bun.create(allocator, CssColor, this.deepClone(allocator)),
+                    .dark = bun.create(allocator, CssColor, this.deepClone(allocator)),
+                },
+            },
+        };
+    }
+
+    /// Mixes this color with another color, including the specified amount of each.
+    /// Implemented according to the [`color-mix()`](https://www.w3.org/TR/css-color-5/#color-mix) function.
+    // PERF: these little allocations feel bad
+    pub fn interpolate(
+        this: *const CssColor,
+        allocator: Allocator,
+        comptime T: type,
+        p1_: f32,
+        other: *const CssColor,
+        p2_: f32,
+        method: HueInterpolationMethod,
+    ) ?CssColor {
+        var p1 = p1_;
+        var p2 = p2_;
+
+        if (this.* == .current_color or other.* == .current_color) {
+            return null;
+        }
+
+        if (this.* == .light_dark or other.* == .light_dark) {
+            const this_light_dark = this.toLightDark(allocator);
+            const other_light_dark = this.toLightDark(allocator);
+
+            const al = this_light_dark.light_dark.light;
+            const ad = this_light_dark.light_dark.dark;
+
+            const bl = other_light_dark.light_dark.light;
+            const bd = other_light_dark.light_dark.dark;
+
+            return .{
+                .light_dark = .{
+                    .light = bun.create(
+                        allocator,
+                        CssColor,
+                        al.interpolate(allocator, T, p1, bl, p2, method) orelse return null,
+                    ),
+                    .dark = bun.create(
+                        allocator,
+                        CssColor,
+                        ad.interpolate(allocator, T, p1, bd, p2, method) orelse return null,
+                    ),
+                },
+            };
+        }
+
+        const check_converted = struct {
+            fn run(color: *const CssColor) bool {
+                bun.debugAssert(color.* != .light_dark and color.* != .current_color and color.* != .system);
+                return switch (color.*) {
+                    .rgba => T == RGBA,
+                    .lab => |lab| switch (lab.*) {
+                        .lab => T == LAB,
+                        .lch => T == LCH,
+                        .oklab => T == OKLAB,
+                        .oklch => T == OKLCH,
+                    },
+                    .predefined => |pre| switch (pre.*) {
+                        .srgb => T == SRGB,
+                        .srgb_linear => T == SRGBLinear,
+                        .display_p3 => T == P3,
+                        .a98 => T == A98,
+                        .prophoto => T == ProPhoto,
+                        .rec2020 => T == Rec2020,
+                        .xyz_d50 => T == XYZd50,
+                        .xyz_d65 => T == XYZd65,
+                    },
+                    .float => |f| switch (f.*) {
+                        .rgb => T == SRGB,
+                        .hsl => T == HSL,
+                        .hwb => T == HWB,
+                    },
+                    .system => bun.Output.panic("Unreachable code: system colors cannot be converted to a color.\n\nThis is a bug in Bun's CSS color parser. Please file a bug report at https://github.com/oven-sh/bun/issues/new/choose", .{}),
+                    // We checked these above
+                    .light_dark, .current_color => unreachable,
+                };
+            }
+        };
+
+        const converted_first = check_converted.run(this);
+        const converted_second = check_converted.run(other);
+
+        // https://drafts.csswg.org/css-color-5/#color-mix-result
+        var first_color = T.tryFromCssColor(this) orelse return null;
+        var second_color = T.tryFromCssColor(other) orelse return null;
+
+        if (converted_first and !first_color.inGamut()) {
+            first_color = mapGamut(T, first_color);
+        }
+
+        if (converted_second and !second_color.inGamut()) {
+            second_color = mapGamut(T, second_color);
+        }
+
+        // https://www.w3.org/TR/css-color-4/#powerless
+        if (converted_first) {
+            first_color.adjustPowerlessComponents();
+        }
+
+        if (converted_second) {
+            second_color.adjustPowerlessComponents();
+        }
+
+        // https://drafts.csswg.org/css-color-4/#interpolation-missing
+        first_color.fillMissingComponents(&second_color);
+        second_color.fillMissingComponents(&first_color);
+
+        // https://www.w3.org/TR/css-color-4/#hue-interpolation
+        first_color.adjustHue(&second_color, method);
+
+        // https://www.w3.org/TR/css-color-4/#interpolation-alpha
+        first_color.premultiply();
+        second_color.premultiply();
+
+        // https://drafts.csswg.org/css-color-5/#color-mix-percent-norm
+        var alpha_multiplier = p1 + p2;
+        if (alpha_multiplier != 1.0) {
+            p1 = p1 / alpha_multiplier;
+            p2 = p2 / alpha_multiplier;
+            if (alpha_multiplier > 1.0) {
+                alpha_multiplier = 1.0;
+            }
+        }
+
+        var result_color = first_color.interpolate(p1, &second_color, p2);
+
+        result_color.unpremultiply(alpha_multiplier);
+
+        return result_color.intoCssColor(allocator);
+    }
+
+    pub fn lightDarkOwned(allocator: Allocator, light: CssColor, dark: CssColor) CssColor {
+        return CssColor{
+            .light_dark = .{
+                .light = bun.create(allocator, CssColor, light),
+                .dark = bun.create(allocator, CssColor, dark),
+            },
+        };
+    }
+
+    pub fn getFallback(this: *const @This(), allocator: Allocator, kind: ColorFallbackKind) CssColor {
+        if (this.* == .rgba) return this.deepClone(allocator);
+
+        return switch (kind.asBits()) {
+            ColorFallbackKind.RGB.asBits() => this.toRGB(allocator).?,
+            ColorFallbackKind.P3.asBits() => this.toP3(allocator).?,
+            ColorFallbackKind.LAB.asBits() => this.toLAB(allocator).?,
+            else => bun.unreachablePanic("Expected RGBA, P3, LAB fallback. This is a bug in Bun.", .{}),
+        };
+    }
+
+    pub fn getFallbacks(this: *@This(), allocator: Allocator, targets: css.targets.Targets) css.SmallList(CssColor, 2) {
+        const fallbacks = this.getNecessaryFallbacks(targets);
+
+        var res = css.SmallList(CssColor, 2){};
+
+        if (fallbacks.contains(ColorFallbackKind{ .rgb = true })) {
+            res.appendAssumeCapacity(this.toRGB(allocator).?);
+        }
+
+        if (fallbacks.contains(ColorFallbackKind{ .p3 = true })) {
+            res.appendAssumeCapacity(this.toP3(allocator).?);
+        }
+
+        if (fallbacks.contains(ColorFallbackKind{ .lab = true })) {
+            this.* = this.toLAB(allocator).?;
+        }
+
+        return res;
+    }
+
+    /// Returns the color fallback types needed for the given browser targets.
+    pub fn getNecessaryFallbacks(this: *const @This(), targets: css.targets.Targets) ColorFallbackKind {
+        // Get the full set of possible fallbacks, and remove the highest one, which
+        // will replace the original declaration. The remaining fallbacks need to be added.
+        const fallbacks = this.getPossibleFallbacks(targets);
+        return fallbacks.difference(fallbacks.highest());
+    }
+
+    pub fn getPossibleFallbacks(this: *const @This(), targets: css.targets.Targets) ColorFallbackKind {
+        // Fallbacks occur in levels: Oklab -> Lab -> P3 -> RGB. We start with all levels
+        // below and including the authored color space, and remove the ones that aren't
+        // compatible with our browser targets.
+        var fallbacks = switch (this.*) {
+            .current_color, .rgba, .float, .system => return ColorFallbackKind.empty(),
+            .lab => |lab| brk: {
+                if (lab.* == .lab or lab.* == .lch and targets.shouldCompileSame(.lab_colors))
+                    break :brk ColorFallbackKind.andBelow(.{ .lab = true });
+                if (lab.* == .oklab or lab.* == .oklch and targets.shouldCompileSame(.oklab_colors))
+                    break :brk ColorFallbackKind.andBelow(.{ .lab = true });
+                return ColorFallbackKind.empty();
+            },
+            .predefined => |predefined| brk: {
+                if (predefined.* == .display_p3 and targets.shouldCompileSame(.p3_colors)) break :brk ColorFallbackKind.andBelow(.{ .p3 = true });
+                if (targets.shouldCompileSame(.color_function)) break :brk ColorFallbackKind.andBelow(.{ .lab = true });
+                return ColorFallbackKind.empty();
+            },
+            .light_dark => |*ld| {
+                return ld.light.getPossibleFallbacks(targets).bitwiseOr(ld.dark.getPossibleFallbacks(targets));
+            },
+        };
+
+        if (fallbacks.contains(.{ .oklab = true })) {
+            if (!targets.shouldCompileSame(.oklab_colors)) {
+                fallbacks.remove(ColorFallbackKind.andBelow(.{ .lab = true }));
+            }
+        }
+
+        if (fallbacks.contains(.{ .lab = true })) {
+            if (!targets.shouldCompileSame(.lab_colors)) {
+                fallbacks = fallbacks.difference(ColorFallbackKind.andBelow(.{ .p3 = true }));
+            } else if (targets.browsers != null and css.compat.Feature.isPartiallyCompatible(&css.compat.Feature.lab_colors, targets.browsers.?)) {
+                // We don't need P3 if Lab is supported by some of our targets.
+                // No browser implements Lab but not P3.
+                fallbacks.remove(.{ .p3 = true });
+            }
+        }
+
+        if (fallbacks.contains(.{ .p3 = true })) {
+            if (!targets.shouldCompileSame(.p3_colors)) {
+                fallbacks.remove(.{ .rgb = true });
+            } else if (fallbacks.highest().asBits() != ColorFallbackKind.asBits(.{ .p3 = true }) and
+                (targets.browsers == null or !css.compat.Feature.isPartiallyCompatible(&css.compat.Feature.p3_colors, targets.browsers.?)))
+            {
+                // Remove P3 if it isn't supported by any targets, and wasn't the
+                // original authored color.
+                fallbacks.remove(.{ .p3 = true });
+            }
+        }
+
+        return fallbacks;
+    }
+
+    pub fn default() @This() {
+        return .{ .rgba = RGBA.transparent() };
+    }
+
+    pub fn eql(this: *const This, other: *const This) bool {
+        if (@intFromEnum(this.*) != @intFromEnum(other.*)) return false;
+
+        return switch (this.*) {
+            .current_color => true,
+            .rgba => std.meta.eql(this.rgba, other.rgba),
+            .lab => std.meta.eql(this.lab.*, other.lab.*),
+            .predefined => std.meta.eql(this.predefined.*, other.predefined.*),
+            .float => std.meta.eql(this.float.*, other.float.*),
+            .light_dark => this.light_dark.light.eql(other.light_dark.light) and this.light_dark.dark.eql(other.light_dark.dark),
+            .system => this.system == other.system,
+        };
+    }
+
+    pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+        return css.implementHash(@This(), this, hasher);
+    }
+
+    pub fn toRGB(this: *const @This(), allocator: Allocator) ?CssColor {
+        if (this.* == .light_dark) {
+            return CssColor{ .light_dark = .{
+                .light = bun.create(allocator, CssColor, this.light_dark.light.toRGB(allocator) orelse return null),
+                .dark = bun.create(allocator, CssColor, this.light_dark.dark.toRGB(allocator) orelse return null),
+            } };
+        }
+        return CssColor{ .rgba = RGBA.tryFromCssColor(this) orelse return null };
+    }
+
+    pub fn toP3(this: *const @This(), allocator: Allocator) ?CssColor {
+        return switch (this.*) {
+            .light_dark => |ld| blk: {
+                const light = ld.light.toP3(allocator) orelse break :blk null;
+                const dark = ld.dark.toP3(allocator) orelse break :blk null;
+                break :blk .{
+                    .light_dark = .{
+                        .light = bun.create(allocator, CssColor, light),
+                        .dark = bun.create(allocator, CssColor, dark),
+                    },
+                };
+            },
+            else => return .{ .predefined = bun.create(allocator, PredefinedColor, .{ .display_p3 = P3.tryFromCssColor(this) orelse return null }) },
+        };
+    }
+
+    pub fn toLAB(this: *const @This(), allocator: Allocator) ?CssColor {
+        return switch (this.*) {
+            .light_dark => |ld| blk: {
+                const light = ld.light.toLAB(allocator) orelse break :blk null;
+                const dark = ld.dark.toLAB(allocator) orelse break :blk null;
+                break :blk .{
+                    .light_dark = .{
+                        .light = bun.create(allocator, CssColor, light),
+                        .dark = bun.create(allocator, CssColor, dark),
+                    },
+                };
+            },
+            else => .{ .lab = bun.create(allocator, LABColor, .{ .lab = LAB.tryFromCssColor(this) orelse return null }) },
+        };
+    }
+};
+
+pub fn parseColorFunction(location: css.SourceLocation, function: []const u8, input: *css.Parser) Result(CssColor) {
+    var parser = ComponentParser.new(true);
+
+    const ColorFunctions = enum { lab, oklab, lch, oklch, color, hsl, hsla, hwb, rgb, rgba, @"color-mix", @"light-dark" };
+    const Map = bun.ComptimeEnumMap(ColorFunctions);
+
+    if (Map.getASCIIICaseInsensitive(function)) |val| {
+        return switch (val) {
+            .lab => parseLab(LAB, input, &parser, struct {
+                fn callback(l: f32, a: f32, b: f32, alpha: f32) LABColor {
+                    return .{ .lab = .{ .l = l, .a = a, .b = b, .alpha = alpha } };
+                }
+            }.callback),
+            .oklab => parseLab(OKLAB, input, &parser, struct {
+                fn callback(l: f32, a: f32, b: f32, alpha: f32) LABColor {
+                    return .{ .oklab = .{ .l = l, .a = a, .b = b, .alpha = alpha } };
+                }
+            }.callback),
+            .lch => parseLch(LCH, input, &parser, struct {
+                fn callback(l: f32, c: f32, h: f32, alpha: f32) LABColor {
+                    return .{ .lch = .{ .l = l, .c = c, .h = h, .alpha = alpha } };
+                }
+            }.callback),
+            .oklch => parseLch(OKLCH, input, &parser, struct {
+                fn callback(l: f32, c: f32, h: f32, alpha: f32) LABColor {
+                    return .{ .oklch = .{ .l = l, .c = c, .h = h, .alpha = alpha } };
+                }
+            }.callback),
+            .color => parsePredefined(input, &parser),
+            .hsl, .hsla => parseHslHwb(HSL, input, &parser, true, struct {
+                fn callback(allocator: Allocator, h: f32, s: f32, l: f32, a: f32) CssColor {
+                    const hsl = HSL{ .h = h, .s = s, .l = l, .alpha = a };
+                    if (!std.math.isNan(h) and !std.math.isNan(s) and !std.math.isNan(l) and !std.math.isNan(a)) {
+                        return CssColor{ .rgba = hsl.intoRGBA() };
+                    } else {
+                        return CssColor{ .float = bun.create(allocator, FloatColor, .{ .hsl = hsl }) };
+                    }
+                }
+            }.callback),
+            .hwb => parseHslHwb(HWB, input, &parser, false, struct {
+                fn callback(allocator: Allocator, h: f32, w: f32, b: f32, a: f32) CssColor {
+                    const hwb = HWB{ .h = h, .w = w, .b = b, .alpha = a };
+                    if (!std.math.isNan(h) and !std.math.isNan(w) and !std.math.isNan(b) and !std.math.isNan(a)) {
+                        return CssColor{ .rgba = hwb.intoRGBA() };
+                    } else {
+                        return CssColor{ .float = bun.create(allocator, FloatColor, .{ .hwb = hwb }) };
+                    }
+                }
+            }.callback),
+            .rgb, .rgba => parseRgb(input, &parser),
+            .@"color-mix" => input.parseNestedBlock(CssColor, {}, struct {
+                pub fn parseFn(_: void, i: *css.Parser) Result(CssColor) {
+                    return parseColorMix(i);
+                }
+            }.parseFn),
+            .@"light-dark" => input.parseNestedBlock(CssColor, {}, struct {
+                fn callback(_: void, i: *css.Parser) Result(CssColor) {
+                    const light = switch (switch (CssColor.parse(i)) {
+                        .result => |v| v,
+                        .err => |e| return .{ .err = e },
+                    }) {
+                        .light_dark => |ld| ld.takeLightFreeDark(i.allocator()),
+                        else => |v| bun.create(i.allocator(), CssColor, v),
+                    };
+                    if (i.expectComma().asErr()) |e| return .{ .err = e };
+                    const dark = switch (switch (CssColor.parse(i)) {
+                        .result => |v| v,
+                        .err => |e| return .{ .err = e },
+                    }) {
+                        .light_dark => |ld| ld.takeDarkFreeLight(i.allocator()),
+                        else => |v| bun.create(i.allocator(), CssColor, v),
+                    };
+                    return .{ .result = .{
+                        .light_dark = .{
+                            .light = light,
+                            .dark = dark,
+                        },
+                    } };
+                }
+            }.callback),
+        };
+    }
+    return .{ .err = location.newUnexpectedTokenError(.{ .ident = function }) };
+}
+
+pub fn parseRGBComponents(input: *css.Parser, parser: *ComponentParser) Result(struct { f32, f32, f32, bool }) {
+    const red = switch (parser.parseNumberOrPercentage(input)) {
+        .err => |e| return .{ .err = e },
+        .result => |v| v,
+    };
+
+    const is_legacy_syntax = parser.from == null and
+        !std.math.isNan(red.unitValue()) and
+        input.tryParse(css.Parser.expectComma, .{}).isOk();
+
+    const r, const g, const b = if (is_legacy_syntax) switch (red) {
+        .number => |v| brk: {
+            const r = bun.clamp(@round(v.value), 0.0, 255.0);
+            const g = switch (parser.parseNumber(input)) {
+                .err => |e| return .{ .err = e },
+                .result => |vv| bun.clamp(@round(vv), 0.0, 255.0),
+            };
+            if (input.expectComma().asErr()) |e| return .{ .err = e };
+            const b = switch (parser.parseNumber(input)) {
+                .err => |e| return .{ .err = e },
+                .result => |vv| bun.clamp(@round(vv), 0.0, 255.0),
+            };
+            break :brk .{ r, g, b };
+        },
+        .percentage => |v| brk: {
+            const r = bun.clamp(@round(v.unit_value * 255.0), 0.0, 255.0);
+            const g = switch (parser.parsePercentage(input)) {
+                .err => |e| return .{ .err = e },
+                .result => |vv| bun.clamp(@round(vv * 255.0), 0.0, 255.0),
+            };
+            if (input.expectComma().asErr()) |e| return .{ .err = e };
+            const b = switch (parser.parsePercentage(input)) {
+                .err => |e| return .{ .err = e },
+                .result => |vv| bun.clamp(@round(vv * 255.0), 0.0, 255.0),
+            };
+            break :brk .{ r, g, b };
+        },
+    } else blk: {
+        const getComponent = struct {
+            fn get(value: NumberOrPercentage) f32 {
+                return switch (value) {
+                    .number => |v| if (std.math.isNan(v.value)) v.value else bun.clamp(@round(v.value), 0.0, 255.0) / 255.0,
+                    .percentage => |v| bun.clamp(v.unit_value, 0.0, 1.0),
+                };
+            }
+        }.get;
+
+        const r = getComponent(red);
+        const g = getComponent(switch (parser.parseNumberOrPercentage(input)) {
+            .err => |e| return .{ .err = e },
+            .result => |v| v,
+        });
+        const b = getComponent(switch (parser.parseNumberOrPercentage(input)) {
+            .err => |e| return .{ .err = e },
+            .result => |v| v,
+        });
+        break :blk .{ r, g, b };
+    };
+
+    if (is_legacy_syntax and (std.math.isNan(g) or std.math.isNan(b))) {
+        return .{ .err = input.newCustomError(css.ParserError.invalid_value) };
+    }
+    return .{ .result = .{ r, g, b, is_legacy_syntax } };
+}
+
+pub fn parseHSLHWBComponents(comptime T: type, input: *css.Parser, parser: *ComponentParser, allows_legacy: bool) Result(struct { f32, f32, f32, bool }) {
+    _ = T; // autofix
+    const h = switch (parseAngleOrNumber(input, parser)) {
+        .result => |v| v,
+        .err => |e| return .{ .err = e },
+    };
+    const is_legacy_syntax = allows_legacy and
+        parser.from == null and
+        !std.math.isNan(h) and
+        input.tryParse(css.Parser.expectComma, .{}).isOk();
+    const a = switch (parser.parsePercentage(input)) {
+        .result => |v| bun.clamp(v, 0.0, 1.0),
+        .err => |e| return .{ .err = e },
+    };
+    if (is_legacy_syntax) {
+        if (input.expectColon().asErr()) |e| return .{ .err = e };
+    }
+    const b = switch (parser.parsePercentage(input)) {
+        .result => |v| bun.clamp(v, 0.0, 1.0),
+        .err => |e| return .{ .err = e },
+    };
+    if (is_legacy_syntax and (std.math.isNan(a) or std.math.isNan(b))) {
+        return .{ .err = input.newCustomError(css.ParserError.invalid_value) };
+    }
+    return .{ .result = .{ h, a, b, is_legacy_syntax } };
+}
+
+pub fn mapGamut(comptime T: type, color: T) T {
+    const conversion_function_name = "into" ++ comptime bun.meta.typeName(T);
+    const JND: f32 = 0.02;
+    const EPSILON: f32 = 0.00001;
+
+    // https://www.w3.org/TR/css-color-4/#binsearch
+    var current: OKLCH = color.intoOKLCH();
+
+    // If lightness is >= 100%, return pure white.
+    if (@abs(current.l - 1.0) < EPSILON or current.l > 1.0) {
+        const oklch = OKLCH{
+            .l = 1.0,
+            .c = 0.0,
+            .h = 0.0,
+            .alpha = current.alpha,
+        };
+        return @call(.auto, @field(OKLCH, conversion_function_name), .{&oklch});
+    }
+
+    // If lightness <= 0%, return pure black.
+    if (current.l < EPSILON) {
+        const oklch = OKLCH{
+            .l = 0.0,
+            .c = 0.0,
+            .h = 0.0,
+            .alpha = current.alpha,
+        };
+        return @call(.auto, @field(OKLCH, conversion_function_name), .{&oklch});
+    }
+
+    var min: f32 = 0.0;
+    var max = current.c;
+
+    while ((max - min) > EPSILON) {
+        const chroma = (min + max) / 2.0;
+        current.c = chroma;
+
+        const converted = @call(.auto, @field(OKLCH, conversion_function_name), .{&current});
+        if (converted.inGamut()) {
+            min = chroma;
+            continue;
+        }
+
+        const clipped = converted.clip();
+        const delta_e = deltaEok(T, clipped, current);
+        if (delta_e < JND) {
+            return clipped;
+        }
+
+        max = chroma;
+    }
+
+    return @call(.auto, @field(OKLCH, conversion_function_name), .{&current});
+}
+
+pub fn deltaEok(comptime T: type, _a: T, _b: OKLCH) f32 {
+    // https://www.w3.org/TR/css-color-4/#color-difference-OK
+    const a = T.intoOKLAB(&_a);
+    const b: OKLAB = _b.intoOKLAB();
+
+    const delta_l = a.l - b.l;
+    const delta_a = a.a - b.a;
+    const delta_b = a.b - b.b;
+
+    return @sqrt(
+        bun.powf(delta_l, 2) +
+            bun.powf(delta_a, 2) +
+            bun.powf(delta_b, 2),
+    );
+}
+
+pub fn parseLab(
+    comptime T: type,
+    input: *css.Parser,
+    parser: *ComponentParser,
+    comptime func: *const fn (f32, f32, f32, f32) LABColor,
+) Result(CssColor) {
+    const Closure = struct {
+        parser: *ComponentParser,
+
+        pub fn parsefn(this: *@This(), i: *css.Parser) Result(CssColor) {
+            return this.parser.parseRelative(i, T, CssColor, @This().innerfn, .{});
+        }
+
+        pub fn innerfn(i: *css.Parser, p: *ComponentParser) Result(CssColor) {
+            // f32::max() does not propagate NaN, so use clamp for now until f32::maximum() is stable.
+            const l = bun.clamp(
+                switch (p.parsePercentage(i)) {
+                    .result => |v| v,
+                    .err => |e| return .{ .err = e },
+                },
+                0.0,
+                std.math.floatMax(f32),
+            );
+            const a = switch (p.parseNumber(i)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            };
+            const b = switch (p.parseNumber(i)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            };
+            const alpha = switch (parseAlpha(i, p)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            };
+            const lab = func(l, a, b, alpha);
+            const heap_lab = bun.create(i.allocator(), LABColor, lab);
+            heap_lab.* = lab;
+            return .{ .result = CssColor{ .lab = heap_lab } };
+        }
+    };
+    var closure = Closure{
+        .parser = parser,
+    };
+    // https://www.w3.org/TR/css-color-4/#funcdef-lab
+    return input.parseNestedBlock(
+        CssColor,
+        &closure,
+        Closure.parsefn,
+    );
+}
+
+pub fn parseLch(
+    comptime T: type,
+    input: *css.Parser,
+    parser: *ComponentParser,
+    comptime func: *const fn (
+        f32,
+        f32,
+        f32,
+        f32,
+    ) LABColor,
+) Result(CssColor) {
+    const Closure = struct {
+        parser: *ComponentParser,
+
+        pub fn parseNestedBlockFn(this: *@This(), i: *css.Parser) Result(CssColor) {
+            return this.parser.parseRelative(i, T, CssColor, @This().parseRelativeFn, .{this});
+        }
+
+        pub fn parseRelativeFn(i: *css.Parser, p: *ComponentParser, this: *@This()) Result(CssColor) {
+            _ = this; // autofix
+            if (p.from) |*from| {
+                // Relative angles should be normalized.
+                // https://www.w3.org/TR/css-color-5/#relative-LCH
+                // from.components[2] %= 360.0;
+                from.components[2] = @mod(from.components[2], 360.0);
+                if (from.components[2] < 0.0) {
+                    from.components[2] += 360.0;
+                }
+            }
+
+            const l = bun.clamp(
+                switch (p.parsePercentage(i)) {
+                    .result => |vv| vv,
+                    .err => |e| return .{ .err = e },
+                },
+                0.0,
+                std.math.floatMax(f32),
+            );
+            const c = bun.clamp(
+                switch (p.parseNumber(i)) {
+                    .result => |vv| vv,
+                    .err => |e| return .{ .err = e },
+                },
+                0.0,
+                std.math.floatMax(f32),
+            );
+            const h = switch (parseAngleOrNumber(i, p)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            };
+            const alpha = switch (parseAlpha(i, p)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            };
+            const lab = func(l, c, h, alpha);
+            return .{
+                .result = .{
+                    .lab = bun.create(i.allocator(), LABColor, lab),
+                },
+            };
+        }
+    };
+
+    var closure = Closure{
+        .parser = parser,
+    };
+
+    return input.parseNestedBlock(CssColor, &closure, Closure.parseNestedBlockFn);
+}
+
+/// Parses the hsl() and hwb() functions.
+/// The results of this function are stored as floating point if there are any `none` components.
+/// https://drafts.csswg.org/css-color-4/#the-hsl-notation
+pub fn parseHslHwb(
+    comptime T: type,
+    input: *css.Parser,
+    parser: *ComponentParser,
+    allows_legacy: bool,
+    comptime func: *const fn (
+        Allocator,
+        f32,
+        f32,
+        f32,
+        f32,
+    ) CssColor,
+) Result(CssColor) {
+    const Closure = struct {
+        parser: *ComponentParser,
+        allows_legacy: bool,
+
+        pub fn parseNestedBlockFn(this: *@This(), i: *css.Parser) Result(CssColor) {
+            return this.parser.parseRelative(i, T, CssColor, @This().parseRelativeFn, .{this});
+        }
+
+        pub fn parseRelativeFn(i: *css.Parser, p: *ComponentParser, this: *@This()) Result(CssColor) {
+            const h, const a, const b, const is_legacy = switch (parseHslHwbComponents(T, i, p, this.allows_legacy)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            };
+            const alpha = switch (if (is_legacy) parseLegacyAlpha(i, p) else parseAlpha(i, p)) {
+                .result => |v| v,
+                .err => |e| return .{ .err = e },
+            };
+
+            return .{ .result = func(i.allocator(), h, a, b, alpha) };
+        }
+    };
+
+    var closure = Closure{
+        .parser = parser,
+        .allows_legacy = allows_legacy,
+    };
+
+    return input.parseNestedBlock(CssColor, &closure, Closure.parseNestedBlockFn);
+}
+
+pub fn parseHslHwbComponents(
+    comptime T: type,
+    input: *css.Parser,
+    parser: *ComponentParser,
+    allows_legacy: bool,
+) Result(struct { f32, f32, f32, bool }) {
+    _ = T; // autofix
+    const h = switch (parseAngleOrNumber(input, parser)) {
+        .result => |vv| vv,
+        .err => |e| return .{ .err = e },
+    };
+    const is_legacy_syntax = allows_legacy and
+        parser.from == null and
+        !std.math.isNan(h) and
+        input.tryParse(css.Parser.expectComma, .{}).isOk();
+
+    const a = bun.clamp(
+        switch (parser.parsePercentage(input)) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        },
+        0.0,
+        1.0,
+    );
+
+    if (is_legacy_syntax) {
+        if (input.expectComma().asErr()) |e| return .{ .err = e };
+    }
+
+    const b = bun.clamp(
+        switch (parser.parsePercentage(input)) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        },
+        0.0,
+        1.0,
+    );
+
+    if (is_legacy_syntax and (std.math.isNan(a) or std.math.isNan(b))) {
+        return .{ .err = input.newCustomError(css.ParserError.invalid_value) };
+    }
+
+    return .{ .result = .{ h, a, b, is_legacy_syntax } };
+}
+
+pub fn parseAngleOrNumber(input: *css.Parser, parser: *const ComponentParser) Result(f32) {
+    const result = switch (parser.parseAngleOrNumber(input)) {
+        .result => |vv| vv,
+        .err => |e| return .{ .err = e },
+    };
+    return .{
+        .result = switch (result) {
+            .number => |v| v.value,
+            .angle => |v| v.degrees,
+        },
+    };
+}
+
+fn parseRgb(input: *css.Parser, parser: *ComponentParser) Result(CssColor) {
+    // https://drafts.csswg.org/css-color-4/#rgb-functions
+
+    const Closure = struct {
+        p: *ComponentParser,
+
+        pub fn parseNestedBlockFn(this: *@This(), i: *css.Parser) Result(CssColor) {
+            return this.p.parseRelative(i, SRGB, CssColor, @This().parseRelativeFn, .{this});
+        }
+
+        pub fn parseRelativeFn(i: *css.Parser, p: *ComponentParser, this: *@This()) Result(CssColor) {
+            _ = this; // autofix
+            const r, const g, const b, const is_legacy = switch (parseRGBComponents(i, p)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            };
+            const alpha = switch (if (is_legacy) parseLegacyAlpha(i, p) else parseAlpha(i, p)) {
+                .result => |v| v,
+                .err => |e| return .{ .err = e },
+            };
+
+            if (!std.math.isNan(r) and
+                !std.math.isNan(g) and
+                !std.math.isNan(b) and
+                !std.math.isNan(alpha))
+            {
+                if (is_legacy) return .{
+                    .result = .{
+                        .rgba = RGBA.new(
+                            @intFromFloat(r),
+                            @intFromFloat(g),
+                            @intFromFloat(b),
+                            alpha,
+                        ),
+                    },
+                };
+
+                return .{
+                    .result = .{
+                        .rgba = RGBA.fromFloats(
+                            r,
+                            g,
+                            b,
+                            alpha,
+                        ),
+                    },
+                };
+            } else {
+                return .{
+                    .result = .{
+                        .float = bun.create(
+                            i.allocator(),
+                            FloatColor,
+                            .{
+                                .rgb = .{
+                                    .r = r,
+                                    .g = g,
+                                    .b = b,
+                                    .alpha = alpha,
+                                },
+                            },
+                        ),
+                    },
+                };
+            }
+        }
+    };
+    var closure = Closure{
+        .p = parser,
+    };
+    return input.parseNestedBlock(CssColor, &closure, Closure.parseNestedBlockFn);
+}
+
+// pub fn parseRgbComponents(input: *css.Parser, parser: *ComponentParser) Result(struct {
+//     f32,
+//     f32,
+//     f32,
+//     bool,
+// }) {
+//     const red = switch (parser.parseNumberOrPercentage(input)) {
+//         .result => |vv| vv,
+//         .err => |e| return .{ .err = e },
+//     };
+//     const is_legacy_syntax = parser.from == null and !std.math.isNan(red.unitValue()) and input.tryParse(css.Parser.expectComma, .{}).isOk();
+
+//     const r, const g, const b = if (is_legacy_syntax) switch (red) {
+//         .number => |num| brk: {
+//             const r = bun.clamp(@round(num.value), 0.0, 255.0);
+//             const g = bun.clamp(
+//                 @round(
+//                     switch (parser.parseNumber(input)) {
+//                         .result => |vv| vv,
+//                         .err => |e| return .{ .err = e },
+//                     },
+//                 ),
+//                 0.0,
+//                 255.0,
+//             );
+//             if (input.expectComma().asErr()) |e| return .{ .err = e };
+//             const b = bun.clamp(
+//                 @round(
+//                     switch (parser.parseNumber(input)) {
+//                         .result => |vv| vv,
+//                         .err => |e| return .{ .err = e },
+//                     },
+//                 ),
+//                 0.0,
+//                 255.0,
+//             );
+//             break :brk .{ r, g, b };
+//         },
+//         .percentage => |per| brk: {
+//             const unit_value = per.unit_value;
+//             const r = bun.clamp(@round(unit_value * 255.0), 0.0, 255.0);
+//             const g = bun.clamp(
+//                 @round(
+//                     switch (parser.parsePercentage(input)) {
+//                         .result => |vv| vv,
+//                         .err => |e| return .{ .err = e },
+//                     } * 255.0,
+//                 ),
+//                 0.0,
+//                 255.0,
+//             );
+//             if (input.expectComma().asErr()) |e| return .{ .err = e };
+//             const b = bun.clamp(
+//                 @round(
+//                     switch (parser.parsePercentage(input)) {
+//                         .result => |vv| vv,
+//                         .err => |e| return .{ .err = e },
+//                     } * 255.0,
+//                 ),
+//                 0.0,
+//                 255.0,
+//             );
+//             break :brk .{ r, g, b };
+//         },
+//     } else brk: {
+//         const get = struct {
+//             pub fn component(value: NumberOrPercentage) f32 {
+//                 return switch (value) {
+//                     .number => |num| {
+//                         const v = num.value;
+//                         if (std.math.isNan(v)) return v;
+//                         return bun.clamp(@round(v), 0.0, 255.0) / 255.0;
+//                     },
+//                     .percentage => |per| bun.clamp(per.unit_value, 0.0, 1.0),
+//                 };
+//             }
+//         };
+//         const r = get.component(red);
+//         const g = get.component(
+//             switch (parser.parseNumberOrPercentage(input)) {
+//                 .result => |vv| vv,
+//                 .err => |e| return .{ .err = e },
+//             },
+//         );
+//         const b = get.component(
+//             switch (parser.parseNumberOrPercentage(input)) {
+//                 .result => |vv| vv,
+//                 .err => |e| return .{ .err = e },
+//             },
+//         );
+//         break :brk .{ r, g, b };
+//     };
+
+//     if (is_legacy_syntax and (std.math.isNan(g) or std.math.isNan(b))) {
+//         return .{ .err = input.newCustomError(css.ParserError.invalid_value) };
+//     }
+
+//     return .{ .result = .{ r, g, b, is_legacy_syntax } };
+// }
+
+fn parseLegacyAlpha(input: *css.Parser, parser: *const ComponentParser) Result(f32) {
+    if (!input.isExhausted()) {
+        if (input.expectComma().asErr()) |e| return .{ .err = e };
+        return .{ .result = bun.clamp(
+            switch (parseNumberOrPercentage(input, parser)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            },
+            0.0,
+            1.0,
+        ) };
+    }
+    return .{ .result = 1.0 };
+}
+
+fn parseAlpha(input: *css.Parser, parser: *const ComponentParser) Result(f32) {
+    const res = if (input.tryParse(css.Parser.expectDelim, .{'/'}).isOk())
+        bun.clamp(switch (parseNumberOrPercentage(input, parser)) {
+            .result => |v| v,
+            .err => |e| return .{ .err = e },
+        }, 0.0, 1.0)
+    else
+        1.0;
+
+    return .{ .result = res };
+}
+
+pub fn parseNumberOrPercentage(input: *css.Parser, parser: *const ComponentParser) Result(f32) {
+    const result = switch (parser.parseNumberOrPercentage(input)) {
+        .result => |vv| vv,
+        .err => |e| return .{ .err = e },
+    };
+    return switch (result) {
+        .number => |value| .{ .result = value.value },
+        .percentage => |value| .{ .result = value.unit_value },
+    };
+}
+
+// Copied from an older version of cssparser.
+/// A color with red, green, blue, and alpha components, in a byte each.
+pub const RGBA = struct {
+    /// The red component.
+    red: u8,
+    /// The green component.
+    green: u8,
+    /// The blue component.
+    blue: u8,
+    /// The alpha component.
+    alpha: u8,
+
+    pub usingnamespace ColorspaceConversions(@This());
+    pub usingnamespace color_conversions.convert_RGBA;
+
+    pub fn new(red: u8, green: u8, blue: u8, alpha: f32) RGBA {
+        return RGBA{
+            .red = red,
+            .green = green,
+            .blue = blue,
+            .alpha = clamp_unit_f32(alpha),
+        };
+    }
+
+    /// Constructs a new RGBA value from float components. It expects the red,
+    /// green, blue and alpha channels in that order, and all values will be
+    /// clamped to the 0.0 ... 1.0 range.
+    pub fn fromFloats(red: f32, green: f32, blue: f32, alpha: f32) RGBA {
+        return RGBA.new(
+            clamp_unit_f32(red),
+            clamp_unit_f32(green),
+            clamp_unit_f32(blue),
+            alpha,
+        );
+    }
+
+    pub fn transparent() RGBA {
+        return RGBA.new(0, 0, 0, 0.0);
+    }
+
+    /// Returns the red channel in a floating point number form, from 0 to 1.
+    pub fn redF32(this: *const RGBA) f32 {
+        return @as(f32, @floatFromInt(this.red)) / 255.0;
+    }
+
+    /// Returns the green channel in a floating point number form, from 0 to 1.
+    pub fn greenF32(this: *const RGBA) f32 {
+        return @as(f32, @floatFromInt(this.green)) / 255.0;
+    }
+
+    /// Returns the blue channel in a floating point number form, from 0 to 1.
+    pub fn blueF32(this: *const RGBA) f32 {
+        return @as(f32, @floatFromInt(this.blue)) / 255.0;
+    }
+
+    /// Returns the alpha channel in a floating point number form, from 0 to 1.
+    pub fn alphaF32(this: *const RGBA) f32 {
+        return @as(f32, @floatFromInt(this.alpha)) / 255.0;
+    }
+
+    pub fn intoSRGB(rgb: *const RGBA) SRGB {
+        return SRGB{
+            .r = rgb.redF32(),
+            .g = rgb.greenF32(),
+            .b = rgb.blueF32(),
+            .alpha = rgb.alphaF32(),
+        };
+    }
+};
+
+fn clamp_unit_f32(val: f32) u8 {
+    // Whilst scaling by 256 and flooring would provide
+    // an equal distribution of integers to percentage inputs,
+    // this is not what Gecko does so we instead multiply by 255
+    // and round (adding 0.5 and flooring is equivalent to rounding)
+    //
+    // Chrome does something similar for the alpha value, but not
+    // the rgb values.
+    //
+    // See https://bugzilla.mozilla.org/show_bug.cgi?id=1340484
+    //
+    // Clamping to 256 and rounding after would let 1.0 map to 256, and
+    // `256.0_f32 as u8` is undefined behavior:
+    //
+    // https://github.com/rust-lang/rust/issues/10184
+    return clamp_floor_256_f32(val * 255.0);
+}
+
+fn clamp_floor_256_f32(val: f32) u8 {
+    return @intFromFloat(@min(255.0, @max(0.0, @round(val))));
+    //   val.round().max(0.).min(255.) as u8
+}
+
+/// A color in a LAB color space, including the `lab()`, `lch()`, `oklab()`, and `oklch()` functions.
+pub const LABColor = union(enum) {
+    /// A `lab()` color.
+    lab: LAB,
+    /// An `lch()` color.
+    lch: LCH,
+    /// An `oklab()` color.
+    oklab: OKLAB,
+    /// An `oklch()` color.
+    oklch: OKLCH,
+
+    pub fn newLAB(l: f32, a: f32, b: f32, alpha: f32) LABColor {
+        return LABColor{
+            .lab = LAB.new(l, a, b, alpha),
+        };
+    }
+
+    pub fn newOKLAB(l: f32, a: f32, b: f32, alpha: f32) LABColor {
+        return LABColor{
+            .lab = OKLAB.new(l, a, b, alpha),
+        };
+    }
+
+    pub fn newLCH(l: f32, a: f32, b: f32, alpha: f32) LABColor {
+        return LABColor{
+            .lab = LCH.new(l, a, b, alpha),
+        };
+    }
+
+    pub fn newOKLCH(l: f32, a: f32, b: f32, alpha: f32) LABColor {
+        return LABColor{
+            .lab = LCH.new(l, a, b, alpha),
+        };
+    }
+
+    pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+        return css.implementHash(@This(), this, hasher);
+    }
+};
+
+/// A color in a predefined color space, e.g. `display-p3`.
+pub const PredefinedColor = union(enum) {
+    /// A color in the `srgb` color space.
+    srgb: SRGB,
+    /// A color in the `srgb-linear` color space.
+    srgb_linear: SRGBLinear,
+    /// A color in the `display-p3` color space.
+    display_p3: P3,
+    /// A color in the `a98-rgb` color space.
+    a98: A98,
+    /// A color in the `prophoto-rgb` color space.
+    prophoto: ProPhoto,
+    /// A color in the `rec2020` color space.
+    rec2020: Rec2020,
+    /// A color in the `xyz-d50` color space.
+    xyz_d50: XYZd50,
+    /// A color in the `xyz-d65` color space.
+    xyz_d65: XYZd65,
+
+    pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+        return css.implementHash(@This(), this, hasher);
+    }
+};
+
+/// A floating point representation of color types that
+/// are usually stored as RGBA. These are used when there
+/// are any `none` components, which are represented as NaN.
+pub const FloatColor = union(enum) {
+    /// An RGB color.
+    rgb: SRGB,
+    /// An HSL color.
+    hsl: HSL,
+    /// An HWB color.
+    hwb: HWB,
+
+    pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+        return css.implementHash(@This(), this, hasher);
+    }
+};
+
+/// A CSS [system color](https://drafts.csswg.org/css-color/#css-system-colors) keyword.
+/// *NOTE* these are intentionally in flat case
+pub const SystemColor = enum {
+    /// Background of accented user interface controls.
+    accentcolor,
+    /// Text of accented user interface controls.
+    accentcolortext,
+    /// Text in active links. For light backgrounds, traditionally red.
+    activetext,
+    /// The base border color for push buttons.
+    buttonborder,
+    /// The face background color for push buttons.
+    buttonface,
+    /// Text on push buttons.
+    buttontext,
+    /// Background of application content or documents.
+    canvas,
+    /// Text in application content or documents.
+    canvastext,
+    /// Background of input fields.
+    field,
+    /// Text in input fields.
+    fieldtext,
+    /// Disabled text. (Often, but not necessarily, gray.)
+    graytext,
+    /// Background of selected text, for example from ::selection.
+    highlight,
+    /// Text of selected text.
+    highlighttext,
+    /// Text in non-active, non-visited links. For light backgrounds, traditionally blue.
+    linktext,
+    /// Background of text that has been specially marked (such as by the HTML mark element).
+    mark,
+    /// Text that has been specially marked (such as by the HTML mark element).
+    marktext,
+    /// Background of selected items, for example a selected checkbox.
+    selecteditem,
+    /// Text of selected items.
+    selecteditemtext,
+    /// Text in visited links. For light backgrounds, traditionally purple.
+    visitedtext,
+
+    // Deprecated colors: https://drafts.csswg.org/css-color/#deprecated-system-colors
+
+    /// Active window border. Same as ButtonBorder.
+    activeborder,
+    /// Active window caption. Same as Canvas.
+    activecaption,
+    /// Background color of multiple document interface. Same as Canvas.
+    appworkspace,
+    /// Desktop background. Same as Canvas.
+    background,
+    /// The color of the border facing the light source for 3-D elements that appear 3-D due to one layer of surrounding border. Same as ButtonFace.
+    buttonhighlight,
+    /// The color of the border away from the light source for 3-D elements that appear 3-D due to one layer of surrounding border. Same as ButtonFace.
+    buttonshadow,
+    /// Text in caption, size box, and scrollbar arrow box. Same as CanvasText.
+    captiontext,
+    /// Inactive window border. Same as ButtonBorder.
+    inactiveborder,
+    /// Inactive window caption. Same as Canvas.
+    inactivecaption,
+    /// Color of text in an inactive caption. Same as GrayText.
+    inactivecaptiontext,
+    /// Background color for tooltip controls. Same as Canvas.
+    infobackground,
+    /// Text color for tooltip controls. Same as CanvasText.
+    infotext,
+    /// Menu background. Same as Canvas.
+    menu,
+    /// Text in menus. Same as CanvasText.
+    menutext,
+    /// Scroll bar gray area. Same as Canvas.
+    scrollbar,
+    /// The color of the darker (generally outer) of the two borders away from the light source for 3-D elements that appear 3-D due to two concentric layers of surrounding border. Same as ButtonBorder.
+    threeddarkshadow,
+    /// The face background color for 3-D elements that appear 3-D due to two concentric layers of surrounding border. Same as ButtonFace.
+    threedface,
+    /// The color of the lighter (generally outer) of the two borders facing the light source for 3-D elements that appear 3-D due to two concentric layers of surrounding border. Same as ButtonBorder.
+    threedhighlight,
+    /// The color of the darker (generally inner) of the two borders facing the light source for 3-D elements that appear 3-D due to two concentric layers of surrounding border. Same as ButtonBorder.
+    threedlightshadow,
+    /// The color of the lighter (generally inner) of the two borders away from the light source for 3-D elements that appear 3-D due to two concentric layers of surrounding border. Same as ButtonBorder.
+    threedshadow,
+    /// Window background. Same as Canvas.
+    window,
+    /// Window frame. Same as ButtonBorder.
+    windowframe,
+    /// Text in windows. Same as CanvasText.
+    windowtext,
+
+    pub fn isCompatible(this: SystemColor, browsers: css.targets.Browsers) bool {
+        return switch (this) {
+            .accentcolor, .accentcolortext => css.Feature.isCompatible(.accent_system_color, browsers),
+            else => true,
+        };
+    }
+
+    pub fn asStr(this: *const @This()) []const u8 {
+        return css.enum_property_util.asStr(@This(), this);
+    }
+
+    pub fn parse(input: *css.Parser) Result(@This()) {
+        return css.enum_property_util.parse(@This(), input);
+    }
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+        return css.enum_property_util.toCss(@This(), this, W, dest);
+    }
+};
+
+/// A color in the [CIE Lab](https://www.w3.org/TR/css-color-4/#cie-lab) color space.
+pub const LAB = struct {
+    /// The lightness component.
+    l: f32,
+    /// The a component.
+    a: f32,
+    /// The b component.
+    b: f32,
+    /// The alpha component.
+    alpha: f32,
+
+    pub usingnamespace DefineColorspace(@This());
+    pub usingnamespace ColorspaceConversions(@This());
+    pub usingnamespace UnboundedColorGamut(@This());
+
+    pub usingnamespace AdjustPowerlessLAB(@This());
+    pub usingnamespace DeriveInterpolate(@This(), "l", "a", "b");
+    pub usingnamespace RecangularPremultiply(@This(), "l", "a", "b");
+
+    pub usingnamespace color_conversions.convert_LAB;
+
+    pub const ChannelTypeMap = .{
+        .l = ChannelType{ .percentage = true },
+        .a = ChannelType{ .number = true },
+        .b = ChannelType{ .number = true },
+    };
+
+    pub fn adjustHue(_: *@This(), _: *@This(), _: HueInterpolationMethod) void {}
+};
+
+/// A color in the [`sRGB`](https://www.w3.org/TR/css-color-4/#predefined-sRGB) color space.
+pub const SRGB = struct {
+    /// The red component.
+    r: f32,
+    /// The green component.
+    g: f32,
+    /// The blue component.
+    b: f32,
+    /// The alpha component.
+    alpha: f32,
+
+    pub usingnamespace DefineColorspace(@This());
+    pub usingnamespace ColorspaceConversions(@This());
+    pub usingnamespace BoundedColorGamut(@This());
+
+    pub usingnamespace DeriveInterpolate(@This(), "r", "g", "b");
+    pub usingnamespace RecangularPremultiply(@This(), "r", "g", "b");
+
+    pub usingnamespace color_conversions.convert_SRGB;
+
+    pub const ChannelTypeMap = .{
+        .r = ChannelType{ .percentage = true },
+        .g = ChannelType{ .percentage = true },
+        .b = ChannelType{ .percentage = true },
+    };
+
+    pub fn adjustPowerlessComponents(_: *@This()) void {}
+    pub fn adjustHue(_: *@This(), _: *@This(), _: HueInterpolationMethod) void {}
+
+    pub fn intoRGBA(_rgb: *const SRGB) RGBA {
+        const rgb = _rgb.resolve();
+        return RGBA.fromFloats(
+            rgb.r,
+            rgb.g,
+            rgb.b,
+            rgb.alpha,
+        );
+    }
+};
+
+/// A color in the [`hsl`](https://www.w3.org/TR/css-color-4/#the-hsl-notation) color space.
+pub const HSL = struct {
+    /// The hue component.
+    h: f32,
+    /// The saturation component.
+    s: f32,
+    /// The lightness component.
+    l: f32,
+    /// The alpha component.
+    alpha: f32,
+
+    pub usingnamespace DefineColorspace(@This());
+    pub usingnamespace ColorspaceConversions(@This());
+    pub usingnamespace HslHwbColorGamut(@This(), "s", "l");
+
+    pub usingnamespace PolarPremultiply(@This(), "s", "l");
+    pub usingnamespace DeriveInterpolate(@This(), "h", "s", "l");
+
+    pub usingnamespace color_conversions.convert_HSL;
+
+    pub const ChannelTypeMap = .{
+        .h = ChannelType{ .angle = true },
+        .s = ChannelType{ .percentage = true },
+        .l = ChannelType{ .percentage = true },
+    };
+
+    pub fn adjustPowerlessComponents(this: *HSL) void {
+        // If the saturation of an HSL color is 0%, then the hue component is powerless.
+        // If the lightness of an HSL color is 0% or 100%, both the saturation and hue components are powerless.
+        if (@abs(this.s) < std.math.floatEps(f32)) {
+            this.h = std.math.nan(f32);
+        }
+
+        if (@abs(this.l) < std.math.floatEps(f32) or @abs(this.l - 1.0) < std.math.floatEps(f32)) {
+            this.h = std.math.nan(f32);
+            this.s = std.math.nan(f32);
+        }
+    }
+
+    pub fn adjustHue(this: *HSL, other: *HSL, method: HueInterpolationMethod) void {
+        _ = method.interpolate(&this.h, &other.h);
+    }
+};
+
+/// A color in the [`hwb`](https://www.w3.org/TR/css-color-4/#the-hwb-notation) color space.
+pub const HWB = struct {
+    /// The hue component.
+    h: f32,
+    /// The whiteness component.
+    w: f32,
+    /// The blackness component.
+    b: f32,
+    /// The alpha component.
+    alpha: f32,
+
+    pub usingnamespace DefineColorspace(@This());
+    pub usingnamespace ColorspaceConversions(@This());
+    pub usingnamespace HslHwbColorGamut(@This(), "w", "b");
+
+    pub usingnamespace PolarPremultiply(@This(), "w", "b");
+    pub usingnamespace DeriveInterpolate(@This(), "h", "w", "b");
+
+    pub usingnamespace color_conversions.convert_HWB;
+
+    pub const ChannelTypeMap = .{
+        .h = ChannelType{ .angle = true },
+        .w = ChannelType{ .percentage = true },
+        .b = ChannelType{ .percentage = true },
+    };
+
+    pub fn adjustPowerlessComponents(this: *HWB) void {
+        // If white+black is equal to 100% (after normalization), it defines an achromatic color,
+        // i.e. some shade of gray, without any hint of the chosen hue. In this case, the hue component is powerless.
+        if (@abs(this.w + this.b - 1.0) < std.math.floatEps(f32)) {
+            this.h = std.math.nan(f32);
+        }
+    }
+
+    pub fn adjustHue(this: *HWB, other: *HWB, method: HueInterpolationMethod) void {
+        _ = method.interpolate(&this.h, &other.h);
+    }
+};
+
+/// A color in the [`sRGB-linear`](https://www.w3.org/TR/css-color-4/#predefined-sRGB-linear) color space.
+pub const SRGBLinear = struct {
+    /// The red component.
+    r: f32,
+    /// The green component.
+    g: f32,
+    /// The blue component.
+    b: f32,
+    /// The alpha component.
+    alpha: f32,
+
+    pub usingnamespace DefineColorspace(@This());
+    pub usingnamespace ColorspaceConversions(@This());
+    pub usingnamespace BoundedColorGamut(@This());
+
+    pub usingnamespace DeriveInterpolate(@This(), "r", "g", "b");
+    pub usingnamespace RecangularPremultiply(@This(), "r", "g", "b");
+
+    pub usingnamespace color_conversions.convert_SRGBLinear;
+
+    pub const ChannelTypeMap = .{
+        .r = ChannelType{ .angle = true },
+        .g = ChannelType{ .percentage = true },
+        .b = ChannelType{ .percentage = true },
+    };
+
+    pub fn adjustPowerlessComponents(_: *@This()) void {}
+    pub fn adjustHue(_: *@This(), _: *@This(), _: HueInterpolationMethod) void {}
+};
+
+/// A color in the [`display-p3`](https://www.w3.org/TR/css-color-4/#predefined-display-p3) color space.
+pub const P3 = struct {
+    /// The red component.
+    r: f32,
+    /// The green component.
+    g: f32,
+    /// The blue component.
+    b: f32,
+    /// The alpha component.
+    alpha: f32,
+
+    pub usingnamespace DefineColorspace(@This());
+    pub usingnamespace ColorspaceConversions(@This());
+    pub usingnamespace BoundedColorGamut(@This());
+
+    pub usingnamespace color_conversions.convert_P3;
+
+    pub const ChannelTypeMap = .{
+        .r = ChannelType{ .percentage = true },
+        .g = ChannelType{ .percentage = true },
+        .b = ChannelType{ .percentage = true },
+    };
+};
+
+/// A color in the [`a98-rgb`](https://www.w3.org/TR/css-color-4/#predefined-a98-rgb) color space.
+pub const A98 = struct {
+    /// The red component.
+    r: f32,
+    /// The green component.
+    g: f32,
+    /// The blue component.
+    b: f32,
+    /// The alpha component.
+    alpha: f32,
+
+    pub usingnamespace DefineColorspace(@This());
+    pub usingnamespace ColorspaceConversions(@This());
+    pub usingnamespace BoundedColorGamut(@This());
+
+    pub usingnamespace color_conversions.convert_A98;
+
+    pub const ChannelTypeMap = .{
+        .r = ChannelType{ .percentage = true },
+        .g = ChannelType{ .percentage = true },
+        .b = ChannelType{ .percentage = true },
+    };
+};
+
+/// A color in the [`prophoto-rgb`](https://www.w3.org/TR/css-color-4/#predefined-prophoto-rgb) color space.
+pub const ProPhoto = struct {
+    /// The red component.
+    r: f32,
+    /// The green component.
+    g: f32,
+    /// The blue component.
+    b: f32,
+    /// The alpha component.
+    alpha: f32,
+
+    pub usingnamespace DefineColorspace(@This());
+    pub usingnamespace ColorspaceConversions(@This());
+    pub usingnamespace BoundedColorGamut(@This());
+
+    pub usingnamespace color_conversions.convert_ProPhoto;
+
+    pub const ChannelTypeMap = .{
+        .r = ChannelType{ .percentage = true },
+        .g = ChannelType{ .percentage = true },
+        .b = ChannelType{ .percentage = true },
+    };
+};
+
+/// A color in the [`rec2020`](https://www.w3.org/TR/css-color-4/#predefined-rec2020) color space.
+pub const Rec2020 = struct {
+    /// The red component.
+    r: f32,
+    /// The green component.
+    g: f32,
+    /// The blue component.
+    b: f32,
+    /// The alpha component.
+    alpha: f32,
+
+    pub usingnamespace DefineColorspace(@This());
+    pub usingnamespace ColorspaceConversions(@This());
+    pub usingnamespace BoundedColorGamut(@This());
+
+    pub usingnamespace color_conversions.convert_Rec2020;
+
+    pub const ChannelTypeMap = .{
+        .r = ChannelType{ .percentage = true },
+        .g = ChannelType{ .percentage = true },
+        .b = ChannelType{ .percentage = true },
+    };
+};
+
+/// A color in the [`xyz-d50`](https://www.w3.org/TR/css-color-4/#predefined-xyz) color space.
+pub const XYZd50 = struct {
+    /// The x component.
+    x: f32,
+    /// The y component.
+    y: f32,
+    /// The z component.
+    z: f32,
+    /// The alpha component.
+    alpha: f32,
+
+    pub usingnamespace DefineColorspace(@This());
+    pub usingnamespace ColorspaceConversions(@This());
+    pub usingnamespace UnboundedColorGamut(@This());
+
+    pub usingnamespace DeriveInterpolate(@This(), "x", "y", "z");
+    pub usingnamespace RecangularPremultiply(@This(), "x", "y", "z");
+
+    pub usingnamespace color_conversions.convert_XYZd50;
+
+    pub const ChannelTypeMap = .{
+        .x = ChannelType{ .percentage = true },
+        .y = ChannelType{ .percentage = true },
+        .z = ChannelType{ .percentage = true },
+    };
+};
+
+/// A color in the [`xyz-d65`](https://www.w3.org/TR/css-color-4/#predefined-xyz) color space.
+pub const XYZd65 = struct {
+    /// The x component.
+    x: f32,
+    /// The y component.
+    y: f32,
+    /// The z component.
+    z: f32,
+    /// The alpha component.
+    alpha: f32,
+
+    pub usingnamespace DefineColorspace(@This());
+    pub usingnamespace ColorspaceConversions(@This());
+    pub usingnamespace UnboundedColorGamut(@This());
+
+    pub usingnamespace DeriveInterpolate(@This(), "x", "y", "z");
+    pub usingnamespace RecangularPremultiply(@This(), "x", "y", "z");
+
+    pub usingnamespace color_conversions.convert_XYZd65;
+
+    pub const ChannelTypeMap = .{
+        .x = ChannelType{ .percentage = true },
+        .y = ChannelType{ .percentage = true },
+        .z = ChannelType{ .percentage = true },
+    };
+
+    pub fn adjustPowerlessComponents(_: *@This()) void {}
+    pub fn adjustHue(_: *@This(), _: *@This(), _: HueInterpolationMethod) void {}
+};
+
+/// A color in the [CIE LCH](https://www.w3.org/TR/css-color-4/#cie-lab) color space.
+pub const LCH = struct {
+    /// The lightness component.
+    l: f32,
+    /// The chroma component.
+    c: f32,
+    /// The hue component.
+    h: f32,
+    /// The alpha component.
+    alpha: f32,
+
+    pub usingnamespace DefineColorspace(@This());
+    pub usingnamespace ColorspaceConversions(@This());
+    pub usingnamespace UnboundedColorGamut(@This());
+
+    pub usingnamespace AdjustPowerlessLCH(@This());
+    pub usingnamespace DeriveInterpolate(@This(), "l", "c", "h");
+    pub usingnamespace RecangularPremultiply(@This(), "l", "c", "h");
+
+    pub usingnamespace color_conversions.convert_LCH;
+
+    pub const ChannelTypeMap = .{
+        .l = ChannelType{ .percentage = true },
+        .c = ChannelType{ .number = true },
+        .h = ChannelType{ .angle = true },
+    };
+};
+
+/// A color in the [OKLab](https://www.w3.org/TR/css-color-4/#ok-lab) color space.
+pub const OKLAB = struct {
+    /// The lightness component.
+    l: f32,
+    /// The a component.
+    a: f32,
+    /// The b component.
+    b: f32,
+    /// The alpha component.
+    alpha: f32,
+
+    pub usingnamespace DefineColorspace(@This());
+    pub usingnamespace ColorspaceConversions(@This());
+    pub usingnamespace UnboundedColorGamut(@This());
+
+    pub usingnamespace AdjustPowerlessLAB(@This());
+    pub usingnamespace DeriveInterpolate(@This(), "l", "a", "b");
+    pub usingnamespace RecangularPremultiply(@This(), "l", "a", "b");
+
+    pub usingnamespace color_conversions.convert_OKLAB;
+
+    pub const ChannelTypeMap = .{
+        .l = ChannelType{ .percentage = true },
+        .a = ChannelType{ .number = true },
+        .b = ChannelType{ .number = true },
+    };
+
+    pub fn adjustHue(_: *@This(), _: *@This(), _: HueInterpolationMethod) void {}
+};
+
+/// A color in the [OKLCH](https://www.w3.org/TR/css-color-4/#ok-lab) color space.
+pub const OKLCH = struct {
+    /// The lightness component.
+    l: f32,
+    /// The chroma component.
+    c: f32,
+    /// The hue component.
+    h: f32,
+    /// The alpha component.
+    alpha: f32,
+
+    pub usingnamespace DefineColorspace(@This());
+    pub usingnamespace ColorspaceConversions(@This());
+    pub usingnamespace UnboundedColorGamut(@This());
+
+    pub usingnamespace AdjustPowerlessLCH(@This());
+    pub usingnamespace DeriveInterpolate(@This(), "l", "c", "h");
+    pub usingnamespace RecangularPremultiply(@This(), "l", "c", "h");
+
+    pub usingnamespace color_conversions.convert_OKLCH;
+
+    pub const ChannelTypeMap = .{
+        .l = ChannelType{ .percentage = true },
+        .c = ChannelType{ .number = true },
+        .h = ChannelType{ .angle = true },
+    };
+};
+
+pub const ComponentParser = struct {
+    allow_none: bool,
+    from: ?RelativeComponentParser,
+
+    pub fn new(allow_none: bool) ComponentParser {
+        return ComponentParser{
+            .allow_none = allow_none,
+            .from = null,
+        };
+    }
+
+    /// `func` must be a function like:
+    /// fn (*css.Parser, *ComponentParser, ...args)
+    pub fn parseRelative(
+        this: *ComponentParser,
+        input: *css.Parser,
+        comptime T: type,
+        comptime C: type,
+        comptime func: anytype,
+        args_: anytype,
+    ) Result(C) {
+        if (input.tryParse(css.Parser.expectIdentMatching, .{"from"}).isOk()) {
+            const from = switch (CssColor.parse(input)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            };
+            return this.parseFrom(from, input, T, C, func, args_);
+        }
+
+        const args = bun.meta.ConcatArgs2(func, input, this, args_);
+        return @call(.auto, func, args);
+    }
+
+    pub fn parseFrom(
+        this: *ComponentParser,
+        from: CssColor,
+        input: *css.Parser,
+        comptime T: type,
+        comptime C: type,
+        comptime func: anytype,
+        args_: anytype,
+    ) Result(C) {
+        if (from == .light_dark) {
+            const state = input.state();
+            const light = switch (this.parseFrom(from.light_dark.light.*, input, T, C, func, args_)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            };
+            input.reset(&state);
+            const dark = switch (this.parseFrom(from.light_dark.dark.*, input, T, C, func, args_)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            };
+            return .{ .result = C.lightDarkOwned(input.allocator(), light, dark) };
+        }
+
+        const new_from = if (T.tryFromCssColor(&from)) |v| v.resolve() else return .{ .err = input.newCustomError(css.ParserError.invalid_value) };
+
+        this.from = RelativeComponentParser.new(&new_from);
+
+        const args = bun.meta.ConcatArgs2(func, input, this, args_);
+        return @call(.auto, func, args);
+    }
+
+    pub fn parseNumberOrPercentage(this: *const ComponentParser, input: *css.Parser) Result(NumberOrPercentage) {
+        if (this.from) |*from| {
+            if (input.tryParse(RelativeComponentParser.parseNumberOrPercentage, .{from}).asValue()) |res| {
+                return .{ .result = res };
+            }
+        }
+
+        if (input.tryParse(CSSNumberFns.parse, .{}).asValue()) |value| {
+            return .{ .result = NumberOrPercentage{ .number = .{ .value = value } } };
+        } else if (input.tryParse(Percentage.parse, .{}).asValue()) |value| {
+            return .{
+                .result = NumberOrPercentage{
+                    .percentage = .{ .unit_value = value.v },
+                },
+            };
+        } else if (this.allow_none) {
+            if (input.expectIdentMatching("none").asErr()) |e| return .{ .err = e };
+            return .{ .result = NumberOrPercentage{
+                .number = .{
+                    .value = std.math.nan(f32),
+                },
+            } };
+        } else {
+            return .{ .err = input.newCustomError(css.ParserError.invalid_value) };
+        }
+    }
+
+    pub fn parseAngleOrNumber(this: *const ComponentParser, input: *css.Parser) Result(css.color.AngleOrNumber) {
+        if (this.from) |*from| {
+            if (input.tryParse(RelativeComponentParser.parseAngleOrNumber, .{from}).asValue()) |res| {
+                return .{ .result = res };
+            }
+        }
+
+        if (input.tryParse(Angle.parse, .{}).asValue()) |angle| {
+            return .{
+                .result = .{
+                    .angle = .{
+                        .degrees = angle.toDegrees(),
+                    },
+                },
+            };
+        } else if (input.tryParse(CSSNumberFns.parse, .{}).asValue()) |value| {
+            return .{
+                .result = .{
+                    .number = .{
+                        .value = value,
+                    },
+                },
+            };
+        } else if (this.allow_none) {
+            if (input.expectIdentMatching("none").asErr()) |e| return .{ .err = e };
+            return .{
+                .result = .{
+                    .number = .{
+                        .value = std.math.nan(f32),
+                    },
+                },
+            };
+        } else {
+            return .{ .err = input.newCustomError(css.ParserError.invalid_value) };
+        }
+    }
+
+    pub fn parsePercentage(this: *const ComponentParser, input: *css.Parser) Result(f32) {
+        if (this.from) |*from| {
+            if (input.tryParse(RelativeComponentParser.parsePercentage, .{from}).asValue()) |res| {
+                return .{ .result = res };
+            }
+        }
+
+        if (input.tryParse(Percentage.parse, .{}).asValue()) |val| {
+            return .{ .result = val.v };
+        } else if (this.allow_none) {
+            if (input.expectIdentMatching("none").asErr()) |e| return .{ .err = e };
+            return .{ .result = std.math.nan(f32) };
+        } else {
+            return .{ .err = input.newCustomError(css.ParserError.invalid_value) };
+        }
+    }
+
+    pub fn parseNumber(this: *const ComponentParser, input: *css.Parser) Result(f32) {
+        if (this.from) |*from| {
+            if (input.tryParse(RelativeComponentParser.parseNumber, .{from}).asValue()) |res| {
+                return .{ .result = res };
+            }
+        }
+
+        if (input.tryParse(CSSNumberFns.parse, .{}).asValue()) |val| {
+            return .{ .result = val };
+        } else if (this.allow_none) {
+            if (input.expectIdentMatching("none").asErr()) |e| return .{ .err = e };
+            return .{ .result = std.math.nan(f32) };
+        } else {
+            return .{ .err = input.newCustomError(css.ParserError.invalid_value) };
+        }
+    }
+};
+
+/// Either a number or a percentage.
+pub const NumberOrPercentage = union(enum) {
+    /// `<number>`.
+    number: struct {
+        /// The numeric value parsed, as a float.
+        value: f32,
+    },
+    /// `<percentage>`
+    percentage: struct {
+        /// The value as a float, divided by 100 so that the nominal range is
+        /// 0.0 to 1.0.
+        unit_value: f32,
+    },
+
+    /// Return the value as a percentage.
+    pub fn unitValue(this: *const NumberOrPercentage) f32 {
+        return switch (this.*) {
+            .number => |v| v.value,
+            .percentage => |v| v.unit_value,
+        };
+    }
+
+    /// Return the value as a number with a percentage adjusted to the
+    /// `percentage_basis`.
+    pub fn value(this: *const NumberOrPercentage, percentage_basis: f32) f32 {
+        return switch (this.*) {
+            .number => |v| v.value,
+            .percentage => |v| v.unit_value * percentage_basis,
+        };
+    }
+};
+
+const RelativeComponentParser = struct {
+    names: struct { []const u8, []const u8, []const u8 },
+    components: struct { f32, f32, f32, f32 },
+    types: struct { ChannelType, ChannelType, ChannelType },
+
+    pub fn new(color: anytype) RelativeComponentParser {
+        return RelativeComponentParser{
+            .names = color.channels(),
+            .components = color.components(),
+            .types = color.types(),
+        };
+    }
+
+    pub fn parseAngleOrNumber(input: *css.Parser, this: *const RelativeComponentParser) Result(css.color.AngleOrNumber) {
+        if (input.tryParse(
+            RelativeComponentParser.parseIdent,
+            .{
+                this,
+                ChannelType{ .angle = true, .number = true },
+            },
+        ).asValue()) |value| {
+            return .{ .result = .{
+                .number = .{
+                    .value = value,
+                },
+            } };
+        }
+
+        if (input.tryParse(
+            RelativeComponentParser.parseCalc,
+            .{
+                this,
+                ChannelType{ .angle = true, .number = true },
+            },
+        ).asValue()) |value| {
+            return .{ .result = .{
+                .number = .{
+                    .value = value,
+                },
+            } };
+        }
+
+        const Closure = struct {
+            angle: Angle,
+            parser: *const RelativeComponentParser,
+            pub fn tryParseFn(i: *css.Parser, t: *@This()) Result(Angle) {
+                if (Calc(Angle).parseWith(i, t, @This().calcParseIdentFn).asValue()) |val| {
+                    if (val == .value) {
+                        return .{ .result = val.value.* };
+                    }
+                }
+                return .{ .err = i.newCustomError(css.ParserError.invalid_value) };
+            }
+
+            pub fn calcParseIdentFn(t: *@This(), ident: []const u8) ?Calc(Angle) {
+                const value = t.parser.getIdent(ident, ChannelType{ .angle = true, .number = true }) orelse return null;
+                t.angle = .{ .deg = value };
+                return Calc(Angle){
+                    .value = &t.angle,
+                };
+            }
+        };
+        var closure = Closure{
+            .angle = undefined,
+            .parser = this,
+        };
+        if (input.tryParse(Closure.tryParseFn, .{&closure}).asValue()) |value| {
+            return .{ .result = .{
+                .angle = .{
+                    .degrees = value.toDegrees(),
+                },
+            } };
+        }
+
+        return .{ .err = input.newErrorForNextToken() };
+    }
+
+    pub fn parseNumberOrPercentage(input: *css.Parser, this: *const RelativeComponentParser) Result(NumberOrPercentage) {
+        if (input.tryParse(RelativeComponentParser.parseIdent, .{ this, ChannelType{ .percentage = true, .number = true } }).asValue()) |value| {
+            return .{ .result = NumberOrPercentage{ .percentage = .{ .unit_value = value } } };
+        }
+
+        if (input.tryParse(RelativeComponentParser.parseCalc, .{ this, ChannelType{ .percentage = true, .number = true } }).asValue()) |value| {
+            return .{ .result = NumberOrPercentage{
+                .percentage = .{
+                    .unit_value = value,
+                },
+            } };
+        }
+
+        {
+            const Closure = struct {
+                parser: *const RelativeComponentParser,
+                percentage: Percentage = .{ .v = 0 },
+
+                pub fn parsefn(i: *css.Parser, self: *@This()) Result(Percentage) {
+                    if (Calc(Percentage).parseWith(i, self, @This().calcparseident).asValue()) |calc_value| {
+                        if (calc_value == .value) return .{ .result = calc_value.value.* };
+                    }
+                    return .{ .err = i.newCustomError(css.ParserError.invalid_value) };
+                }
+
+                pub fn calcparseident(self: *@This(), ident: []const u8) ?Calc(Percentage) {
+                    const v = self.parser.getIdent(ident, ChannelType{ .percentage = true, .number = true }) orelse return null;
+                    self.percentage = .{ .v = v };
+                    // value variant is a *Percentage
+                    // but we immediately dereference it and discard the pointer
+                    // so using a field on this closure struct instead of making a gratuitous allocation
+                    return .{
+                        .value = &self.percentage,
+                    };
+                }
+            };
+            var closure = Closure{
+                .parser = this,
+            };
+            if (input.tryParse(Closure.parsefn, .{
+                &closure,
+            }).asValue()) |value| {
+                return .{ .result = NumberOrPercentage{
+                    .percentage = .{
+                        .unit_value = value.v,
+                    },
+                } };
+            }
+        }
+
+        return .{ .err = input.newErrorForNextToken() };
+    }
+
+    pub fn parsePercentage(
+        input: *css.Parser,
+        this: *const RelativeComponentParser,
+    ) Result(f32) {
+        if (input.tryParse(RelativeComponentParser.parseIdent, .{ this, ChannelType{ .percentage = true } }).asValue()) |value| {
+            return .{ .result = value };
+        }
+
+        const Closure = struct { self: *const RelativeComponentParser, temp: Percentage = .{ .v = 0 } };
+        var _closure = Closure{ .self = this };
+        if (input.tryParse(struct {
+            pub fn parseFn(i: *css.Parser, closure: *Closure) Result(Percentage) {
+                const calc_value = switch (Calc(Percentage).parseWith(i, closure, parseIdentFn)) {
+                    .result => |v| v,
+                    .err => return .{ .err = i.newCustomError(css.ParserError.invalid_value) },
+                };
+                if (calc_value == .value) return .{ .result = calc_value.value.* };
+                return .{ .err = i.newCustomError(css.ParserError.invalid_value) };
+            }
+
+            pub fn parseIdentFn(closure: *Closure, ident: []const u8) ?Calc(Percentage) {
+                const v = closure.self.getIdent(ident, ChannelType{ .percentage = true }) orelse return null;
+                closure.temp = .{ .v = v };
+                return Calc(Percentage){ .value = &closure.temp };
+            }
+        }.parseFn, .{&_closure}).asValue()) |value| {
+            return .{ .result = value.v };
+        }
+
+        return .{ .err = input.newErrorForNextToken() };
+    }
+
+    pub fn parseNumber(
+        input: *css.Parser,
+        this: *const RelativeComponentParser,
+    ) Result(f32) {
+        if (input.tryParse(
+            RelativeComponentParser.parseIdent,
+            .{ this, ChannelType{ .number = true } },
+        ).asValue()) |value| {
+            return .{ .result = value };
+        }
+
+        if (input.tryParse(
+            RelativeComponentParser.parseCalc,
+            .{ this, ChannelType{ .number = true } },
+        ).asValue()) |value| {
+            return .{ .result = value };
+        }
+
+        return .{ .err = input.newErrorForNextToken() };
+    }
+
+    pub fn parseIdent(
+        input: *css.Parser,
+        this: *const RelativeComponentParser,
+        allowed_types: ChannelType,
+    ) Result(f32) {
+        const v = this.getIdent(
+            switch (input.expectIdent()) {
+                .result => |v| v,
+                .err => |e| return .{ .err = e },
+            },
+            allowed_types,
+        ) orelse return .{ .err = input.newErrorForNextToken() };
+        return .{ .result = v };
+    }
+
+    pub fn parseCalc(
+        input: *css.Parser,
+        this: *const RelativeComponentParser,
+        allowed_types: ChannelType,
+    ) Result(f32) {
+        const Closure = struct {
+            p: *const RelativeComponentParser,
+            allowed_types: ChannelType,
+
+            pub fn parseIdentFn(self: *@This(), ident: []const u8) ?Calc(f32) {
+                const v = self.p.getIdent(ident, self.allowed_types) orelse return null;
+                return .{ .number = v };
+            }
+        };
+        var closure = Closure{
+            .p = this,
+            .allowed_types = allowed_types,
+        };
+        if (Calc(f32).parseWith(input, &closure, Closure.parseIdentFn).asValue()) |calc_val| {
+            // PERF: I don't like this redundant allocation
+            if (calc_val == .value) return .{ .result = calc_val.value.* };
+            if (calc_val == .number) return .{ .result = calc_val.number };
+        }
+        return .{ .err = input.newCustomError(css.ParserError.invalid_value) };
+    }
+
+    pub fn getIdent(
+        this: *const RelativeComponentParser,
+        ident: []const u8,
+        allowed_types: ChannelType,
+    ) ?f32 {
+        if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(ident, this.names[0]) and allowed_types.intersects(this.types[0])) {
+            return this.components[0];
+        }
+
+        if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(ident, this.names[1]) and allowed_types.intersects(this.types[1])) {
+            return this.components[1];
+        }
+
+        if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(ident, this.names[2]) and allowed_types.intersects(this.types[2])) {
+            return this.components[2];
+        }
+
+        if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(ident, "alpha") and allowed_types.intersects(ChannelType{ .percentage = true })) {
+            return this.components[3];
+        }
+
+        return null;
+    }
+};
+
+/// A channel type for a color space.
+/// TODO(zack): why tf is this bitflags?
+pub const ChannelType = packed struct(u8) {
+    /// Channel represents a percentage.
+    percentage: bool = false,
+    /// Channel represents an angle.
+    angle: bool = false,
+    /// Channel represents a number.
+    number: bool = false,
+    __unused: u5 = 0,
+
+    pub usingnamespace css.Bitflags(@This());
+};
+
+pub fn parsePredefined(input: *css.Parser, parser: *ComponentParser) Result(CssColor) {
+    const Closure = struct { p: *ComponentParser };
+    var closure = Closure{
+        .p = parser,
+    };
+    const res = switch (input.parseNestedBlock(CssColor, &closure, struct {
+        // https://www.w3.org/TR/css-color-4/#color-function
+        pub fn parseFn(this: *Closure, i: *css.Parser) Result(CssColor) {
+            const from: ?CssColor = if (i.tryParse(css.Parser.expectIdentMatching, .{"from"}).isOk())
+                switch (CssColor.parse(i)) {
+                    .result => |vv| vv,
+                    .err => |e| return .{ .err = e },
+                }
+            else
+                null;
+
+            const colorspace = switch (i.expectIdent()) {
+                .result => |v| v,
+                .err => |e| return .{ .err = e },
+            };
+
+            if (from) |f| {
+                if (f == .light_dark) {
+                    const state = i.state();
+                    const light = switch (parsePredefinedRelative(i, this.p, colorspace, f.light_dark.light)) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    };
+                    i.reset(&state);
+                    const dark = switch (parsePredefinedRelative(i, this.p, colorspace, f.light_dark.dark)) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    };
+                    return .{ .result = CssColor{
+                        .light_dark = .{
+                            .light = bun.create(
+                                i.allocator(),
+                                CssColor,
+                                light,
+                            ),
+                            .dark = bun.create(
+                                i.allocator(),
+                                CssColor,
+                                dark,
+                            ),
+                        },
+                    } };
+                }
+            }
+
+            return parsePredefinedRelative(i, this.p, colorspace, if (from) |*f| f else null);
+        }
+    }.parseFn)) {
+        .result => |vv| vv,
+        .err => |e| return .{ .err = e },
+    };
+
+    return .{ .result = res };
+}
+
+pub fn parsePredefinedRelative(
+    input: *css.Parser,
+    parser: *ComponentParser,
+    colorspace: []const u8,
+    _from: ?*const CssColor,
+) Result(CssColor) {
+    const location = input.currentSourceLocation();
+    if (_from) |from| {
+        parser.from = set_from: {
+            // todo_stuff.match_ignore_ascii_case
+            if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("srgb", colorspace)) {
+                break :set_from RelativeComponentParser.new(
+                    if (SRGB.tryFromCssColor(from)) |v| v.resolveMissing() else return .{ .err = input.newCustomError(css.ParserError.invalid_value) },
+                );
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("srgb-linear", colorspace)) {
+                break :set_from RelativeComponentParser.new(
+                    if (SRGBLinear.tryFromCssColor(from)) |v| v.resolveMissing() else return .{ .err = input.newCustomError(css.ParserError.invalid_value) },
+                );
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("display-p3", colorspace)) {
+                break :set_from RelativeComponentParser.new(
+                    if (P3.tryFromCssColor(from)) |v| v.resolveMissing() else return .{ .err = input.newCustomError(css.ParserError.invalid_value) },
+                );
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("a98-rgb", colorspace)) {
+                break :set_from RelativeComponentParser.new(
+                    if (A98.tryFromCssColor(from)) |v| v.resolveMissing() else return .{ .err = input.newCustomError(css.ParserError.invalid_value) },
+                );
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("prophoto-rgb", colorspace)) {
+                break :set_from RelativeComponentParser.new(
+                    if (ProPhoto.tryFromCssColor(from)) |v| v.resolveMissing() else return .{ .err = input.newCustomError(css.ParserError.invalid_value) },
+                );
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("rec2020", colorspace)) {
+                break :set_from RelativeComponentParser.new(
+                    if (Rec2020.tryFromCssColor(from)) |v| v.resolveMissing() else return .{ .err = input.newCustomError(css.ParserError.invalid_value) },
+                );
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("xyz-d50", colorspace)) {
+                break :set_from RelativeComponentParser.new(
+                    if (XYZd50.tryFromCssColor(from)) |v| v.resolveMissing() else return .{ .err = input.newCustomError(css.ParserError.invalid_value) },
+                );
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("xyz", colorspace) or
+                bun.strings.eqlCaseInsensitiveASCIIICheckLength("xyz-d65", colorspace))
+            {
+                break :set_from RelativeComponentParser.new(
+                    if (XYZd65.tryFromCssColor(from)) |v| v.resolveMissing() else return .{ .err = input.newCustomError(css.ParserError.invalid_value) },
+                );
+            } else {
+                return .{ .err = location.newUnexpectedTokenError(.{ .ident = colorspace }) };
+            }
+        };
+    }
+
+    // Out of gamut values should not be clamped, i.e. values < 0 or > 1 should be preserved.
+    // The browser will gamut-map the color for the target device that it is rendered on.
+    const a = switch (input.tryParse(parseNumberOrPercentage, .{parser})) {
+        .result => |vv| vv,
+        .err => |e| return .{ .err = e },
+    };
+    const b = switch (input.tryParse(parseNumberOrPercentage, .{parser})) {
+        .result => |vv| vv,
+        .err => |e| return .{ .err = e },
+    };
+    const c = switch (input.tryParse(parseNumberOrPercentage, .{parser})) {
+        .result => |vv| vv,
+        .err => |e| return .{ .err = e },
+    };
+    const alpha = switch (parseAlpha(input, parser)) {
+        .result => |vv| vv,
+        .err => |e| return .{ .err = e },
+    };
+
+    const predefined: PredefinedColor = predefined: {
+        const Variants = enum {
+            srgb,
+            @"srgb-linear",
+            @"display-p3",
+            @"a99-rgb",
+            @"prophoto-rgb",
+            rec2020,
+            @"xyz-d50",
+            @"xyz-d65",
+            xyz,
+        };
+        const Map = bun.ComptimeEnumMap(Variants);
+        if (Map.getAnyCase(colorspace)) |ret| {
+            switch (ret) {
+                .srgb => break :predefined .{ .srgb = SRGB{
+                    .r = a,
+                    .g = b,
+                    .b = c,
+                    .alpha = alpha,
+                } },
+                .@"srgb-linear" => break :predefined .{ .srgb_linear = SRGBLinear{
+                    .r = a,
+                    .g = b,
+                    .b = c,
+                    .alpha = alpha,
+                } },
+                .@"display-p3" => break :predefined .{ .display_p3 = P3{
+                    .r = a,
+                    .g = b,
+                    .b = c,
+                    .alpha = alpha,
+                } },
+                .@"a99-rgb" => break :predefined .{ .a98 = A98{
+                    .r = a,
+                    .g = b,
+                    .b = c,
+                    .alpha = alpha,
+                } },
+                .@"prophoto-rgb" => break :predefined .{ .prophoto = ProPhoto{
+                    .r = a,
+                    .g = b,
+                    .b = c,
+                    .alpha = alpha,
+                } },
+                .rec2020 => break :predefined .{ .rec2020 = Rec2020{
+                    .r = a,
+                    .g = b,
+                    .b = c,
+                    .alpha = alpha,
+                } },
+                .@"xyz-d50" => break :predefined .{ .xyz_d50 = XYZd50{
+                    .x = a,
+                    .y = b,
+                    .z = c,
+                    .alpha = alpha,
+                } },
+                .@"xyz-d65", .xyz => break :predefined .{ .xyz_d65 = XYZd65{
+                    .x = a,
+                    .y = b,
+                    .z = c,
+                    .alpha = alpha,
+                } },
+            }
+        } else return .{ .err = location.newUnexpectedTokenError(.{ .ident = colorspace }) };
+    };
+
+    return .{ .result = .{
+        .predefined = bun.create(
+            input.allocator(),
+            PredefinedColor,
+            predefined,
+        ),
+    } };
+}
+
+/// A color type that is used as a fallback when compiling colors for older browsers.
+pub const ColorFallbackKind = packed struct(u8) {
+    rgb: bool = false,
+    p3: bool = false,
+    lab: bool = false,
+    oklab: bool = false,
+    __unused: u4 = 0,
+
+    pub const P3 = ColorFallbackKind{ .p3 = true };
+    pub const RGB = ColorFallbackKind{ .rgb = true };
+    pub const LAB = ColorFallbackKind{ .lab = true };
+    pub const OKLAB = ColorFallbackKind{ .oklab = true };
+
+    pub usingnamespace css.Bitflags(@This());
+
+    pub fn lowest(this: @This()) ColorFallbackKind {
+        return this.bitwiseAnd(ColorFallbackKind.fromBitsTruncate(bun.wrappingNegation(this.asBits())));
+    }
+
+    pub fn highest(this: @This()) ColorFallbackKind {
+        // This finds the highest set bit.
+        if (this.isEmpty()) return ColorFallbackKind.empty();
+
+        const zeroes: u3 = @intCast(@as(u4, 7) - this.leadingZeroes());
+        return ColorFallbackKind.fromBitsTruncate(@as(u8, 1) << zeroes);
+    }
+
+    pub fn andBelow(this: @This()) ColorFallbackKind {
+        if (this.isEmpty()) return ColorFallbackKind.empty();
+
+        return this.bitwiseOr(ColorFallbackKind.fromBitsTruncate(this.asBits() - 1));
+    }
+
+    pub fn supportsCondition(this: @This()) css.SupportsCondition {
+        const s = switch (this.asBits()) {
+            ColorFallbackKind.P3.asBits() => "color(display-p3 0 0 0)",
+            ColorFallbackKind.LAB.asBits() => "lab(0% 0 0)",
+            else => bun.unreachablePanic("Expected P3 or LAB. This is a bug in Bun.", .{}),
+        };
+
+        return css.SupportsCondition{
+            .declaration = .{
+                .property_id = .color,
+                .value = s,
+            },
+        };
+    }
+};
+
+/// A [color space](https://www.w3.org/TR/css-color-4/#interpolation-space) keyword
+/// used in interpolation functions such as `color-mix()`.
+pub const ColorSpaceName = enum {
+    srgb,
+    @"srgb-linear",
+    lab,
+    oklab,
+    xyz,
+    @"xyz-d50",
+    @"xyz-d65",
+    hsl,
+    hwb,
+    lch,
+    oklch,
+
+    pub fn asStr(this: *const @This()) []const u8 {
+        return css.enum_property_util.asStr(@This(), this);
+    }
+
+    pub fn parse(input: *css.Parser) Result(@This()) {
+        return css.enum_property_util.parse(@This(), input);
+    }
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+        return css.enum_property_util.toCss(@This(), this, W, dest);
+    }
+};
+
+pub fn parseColorMix(input: *css.Parser) Result(CssColor) {
+    if (input.expectIdentMatching("in").asErr()) |e| return .{ .err = e };
+    const method = switch (ColorSpaceName.parse(input)) {
+        .result => |vv| vv,
+        .err => |e| return .{ .err = e },
+    };
+
+    const hue_method_: Result(HueInterpolationMethod) = if (switch (method) {
+        .hsl, .hwb, .lch, .oklch => true,
+        else => false,
+    }) brk: {
+        const hue_method = input.tryParse(HueInterpolationMethod.parse, .{});
+        if (hue_method.isOk()) {
+            if (input.expectIdentMatching("hue").asErr()) |e| return .{ .err = e };
+        }
+        break :brk hue_method;
+    } else .{ .result = HueInterpolationMethod.shorter };
+
+    const hue_method = hue_method_.unwrapOr(HueInterpolationMethod.shorter);
+
+    const first_percent_ = input.tryParse(css.Parser.expectPercentage, .{});
+    const first_color = switch (CssColor.parse(input)) {
+        .result => |vv| vv,
+        .err => |e| return .{ .err = e },
+    };
+    const first_percent = switch (first_percent_) {
+        .result => |v| v,
+        .err => switch (input.tryParse(css.Parser.expectPercentage, .{})) {
+            .result => |vv| vv,
+            .err => null,
+        },
+    };
+    if (input.expectComma().asErr()) |e| return .{ .err = e };
+
+    const second_percent_ = input.tryParse(css.Parser.expectPercentage, .{});
+    const second_color = switch (CssColor.parse(input)) {
+        .result => |vv| vv,
+        .err => |e| return .{ .err = e },
+    };
+    const second_percent = switch (second_percent_) {
+        .result => |vv| vv,
+        .err => switch (input.tryParse(css.Parser.expectPercentage, .{})) {
+            .result => |vv| vv,
+            .err => null,
+        },
+    };
+
+    // https://drafts.csswg.org/css-color-5/#color-mix-percent-norm
+    const p1, const p2 = if (first_percent == null and second_percent == null) .{ 0.5, 0.5 } else brk: {
+        const p2 = second_percent orelse (1.0 - first_percent.?);
+        const p1 = first_percent orelse (1.0 - second_percent.?);
+        break :brk .{ p1, p2 };
+    };
+
+    if ((p1 + p2) == 0.0) return .{ .err = input.newCustomError(css.ParserError.invalid_value) };
+
+    const result = switch (method) {
+        .srgb => first_color.interpolate(input.allocator(), SRGB, p1, &second_color, p2, hue_method),
+        .@"srgb-linear" => first_color.interpolate(input.allocator(), SRGBLinear, p1, &second_color, p2, hue_method),
+        .hsl => first_color.interpolate(input.allocator(), HSL, p1, &second_color, p2, hue_method),
+        .hwb => first_color.interpolate(input.allocator(), HWB, p1, &second_color, p2, hue_method),
+        .lab => first_color.interpolate(input.allocator(), LAB, p1, &second_color, p2, hue_method),
+        .lch => first_color.interpolate(input.allocator(), LCH, p1, &second_color, p2, hue_method),
+        .oklab => first_color.interpolate(input.allocator(), OKLAB, p1, &second_color, p2, hue_method),
+        .oklch => first_color.interpolate(input.allocator(), OKLCH, p1, &second_color, p2, hue_method),
+        .xyz, .@"xyz-d65" => first_color.interpolate(input.allocator(), XYZd65, p1, &second_color, p2, hue_method),
+        .@"xyz-d50" => first_color.interpolate(input.allocator(), XYZd65, p1, &second_color, p2, hue_method),
+    } orelse return .{ .err = input.newCustomError(css.ParserError.invalid_value) };
+
+    return .{ .result = result };
+}
+
+/// A hue [interpolation method](https://www.w3.org/TR/css-color-4/#typedef-hue-interpolation-method)
+/// used in interpolation functions such as `color-mix()`.
+pub const HueInterpolationMethod = enum {
+    /// Angles are adjusted so that θ₂ - θ₁ ∈ [-180, 180].
+    shorter,
+    /// Angles are adjusted so that θ₂ - θ₁ ∈ {0, [180, 360)}.
+    longer,
+    /// Angles are adjusted so that θ₂ - θ₁ ∈ [0, 360).
+    increasing,
+    /// Angles are adjusted so that θ₂ - θ₁ ∈ (-360, 0].
+    decreasing,
+    /// No fixup is performed. Angles are interpolated in the same way as every other component.
+    specified,
+
+    pub fn asStr(this: *const @This()) []const u8 {
+        return css.enum_property_util.asStr(@This(), this);
+    }
+
+    pub fn parse(input: *css.Parser) Result(@This()) {
+        return css.enum_property_util.parse(@This(), input);
+    }
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+        return css.enum_property_util.toCss(@This(), this, W, dest);
+    }
+
+    pub fn interpolate(
+        this: *const HueInterpolationMethod,
+        a: *f32,
+        b: *f32,
+    ) void {
+        // https://drafts.csswg.org/css-color/#hue-interpolation
+        if (this.* == .specified) {
+            // a.* = ((a.* % 360.0) + 360.0) % 360.0;
+            // b.* = ((b.* % 360.0) + 360.0) % 360.0;
+            a.* = @mod((@mod(a.*, 360.0) + 360.0), 360.0);
+            b.* = @mod((@mod(b.*, 360.0) + 360.0), 360.0);
+        }
+
+        switch (this.*) {
+            .shorter => {
+                // https://www.w3.org/TR/css-color-4/#hue-shorter
+                const delta = b.* - a.*;
+                if (delta > 180.0) {
+                    a.* += 360.0;
+                } else if (delta < -180.0) {
+                    b.* += 360.0;
+                }
+            },
+            .longer => {
+                // https://www.w3.org/TR/css-color-4/#hue-longer
+                const delta = b.* - a.*;
+                if (0.0 < delta and delta < 180.0) {
+                    a.* += 360.0;
+                } else if (-180.0 < delta and delta < 0.0) {
+                    b.* += 360.0;
+                }
+            },
+            .increasing => {
+                // https://www.w3.org/TR/css-color-4/#hue-decreasing
+                if (b.* < a.*) {
+                    b.* += 360.0;
+                }
+            },
+            .decreasing => {
+                // https://www.w3.org/TR/css-color-4/#hue-decreasing
+                if (a.* < b.*) {
+                    a.* += 360.0;
+                }
+            },
+            .specified => {},
+        }
+    }
+};
+
+fn rectangularToPolar(l: f32, a: f32, b: f32) struct { f32, f32, f32 } {
+    // https://github.com/w3c/csswg-drafts/blob/fba005e2ce9bcac55b49e4aa19b87208b3a0631e/css-color-4/conversions.js#L375
+
+    var h = std.math.atan2(b, a) * 180.0 / std.math.pi;
+    if (h < 0.0) {
+        h += 360.0;
+    }
+
+    // const c = @sqrt(std.math.powi(f32, a, 2) + std.math.powi(f32, b, 2));
+    // PERF: Zig does not have Rust's f32::powi
+    const c = @sqrt(bun.powf(a, 2) + bun.powf(b, 2));
+
+    // h = h % 360.0;
+    h = @mod(h, 360.0);
+    return .{ l, c, h };
+}
+
+pub fn ColorspaceConversions(comptime T: type) type {
+    // e.g. T = LAB, so then: into_this_function_name = "intoLAB"
+    const into_this_function_name = "into" ++ comptime bun.meta.typeName(T);
+
+    return struct {
+        pub fn fromLABColor(color: *const LABColor) T {
+            return switch (color.*) {
+                .lab => |*v| {
+                    if (comptime @TypeOf(v.*) == T) return v.*;
+                    return @call(.auto, @field(@TypeOf(v.*), into_this_function_name), .{v});
+                },
+                .lch => |*v| {
+                    if (comptime @TypeOf(v.*) == T) return v.*;
+                    return @call(.auto, @field(@TypeOf(v.*), into_this_function_name), .{v});
+                },
+                .oklab => |*v| {
+                    if (comptime @TypeOf(v.*) == T) return v.*;
+                    return @call(.auto, @field(@TypeOf(v.*), into_this_function_name), .{v});
+                },
+                .oklch => |*v| {
+                    if (comptime @TypeOf(v.*) == T) return v.*;
+                    return @call(.auto, @field(@TypeOf(v.*), into_this_function_name), .{v});
+                },
+            };
+        }
+
+        pub fn fromPredefinedColor(color: *const PredefinedColor) T {
+            return switch (color.*) {
+                .srgb => |*v| {
+                    if (comptime @TypeOf(v.*) == T) return v.*;
+                    return @call(.auto, @field(@TypeOf(v.*), into_this_function_name), .{v});
+                },
+                .srgb_linear => |*v| {
+                    if (comptime @TypeOf(v.*) == T) return v.*;
+                    return @call(.auto, @field(@TypeOf(v.*), into_this_function_name), .{v});
+                },
+                .display_p3 => |*v| {
+                    if (comptime @TypeOf(v.*) == T) return v.*;
+                    return @call(.auto, @field(@TypeOf(v.*), into_this_function_name), .{v});
+                },
+                .a98 => |*v| {
+                    if (comptime @TypeOf(v.*) == T) return v.*;
+                    return @call(.auto, @field(@TypeOf(v.*), into_this_function_name), .{v});
+                },
+                .prophoto => |*v| {
+                    if (comptime @TypeOf(v.*) == T) return v.*;
+                    return @call(.auto, @field(@TypeOf(v.*), into_this_function_name), .{v});
+                },
+                .rec2020 => |*v| {
+                    if (comptime @TypeOf(v.*) == T) return v.*;
+                    return @call(.auto, @field(@TypeOf(v.*), into_this_function_name), .{v});
+                },
+                .xyz_d50 => |*v| {
+                    if (comptime @TypeOf(v.*) == T) return v.*;
+                    return @call(.auto, @field(@TypeOf(v.*), into_this_function_name), .{v});
+                },
+                .xyz_d65 => |*v| {
+                    if (comptime @TypeOf(v.*) == T) return v.*;
+                    return @call(.auto, @field(@TypeOf(v.*), into_this_function_name), .{v});
+                },
+            };
+        }
+
+        pub fn fromFloatColor(color: *const FloatColor) T {
+            return switch (color.*) {
+                .rgb => |*v| {
+                    if (comptime T == SRGB) return v.*;
+                    return @call(.auto, @field(@TypeOf(v.*), into_this_function_name), .{v});
+                },
+                .hsl => |*v| {
+                    if (comptime T == HSL) return v.*;
+                    return @call(.auto, @field(@TypeOf(v.*), into_this_function_name), .{v});
+                },
+                .hwb => |*v| {
+                    if (comptime T == HWB) return v.*;
+                    return @call(.auto, @field(@TypeOf(v.*), into_this_function_name), .{v});
+                },
+            };
+        }
+
+        pub fn tryFromCssColor(color: *const CssColor) ?T {
+            return switch (color.*) {
+                .rgba => |*rgba| {
+                    if (comptime T == RGBA) return rgba.*;
+                    return @call(.auto, @field(@TypeOf(rgba.*), into_this_function_name), .{rgba});
+                },
+                .lab => |lab| fromLABColor(lab),
+                .predefined => |predefined| fromPredefinedColor(predefined),
+                .float => |float| fromFloatColor(float),
+                .current_color => null,
+                .light_dark => null,
+                .system => null,
+            };
+        }
+
+        pub fn hash(this: *const T, hasher: *std.hash.Wyhash) void {
+            return css.implementHash(T, this, hasher);
+        }
+    };
+}
+
+pub fn DefineColorspace(comptime T: type) type {
+    if (!@hasDecl(T, "ChannelTypeMap")) {
+        @compileError("A Colorspace must define a ChannelTypeMap");
+    }
+    const ChannelTypeMap = T.ChannelTypeMap;
+
+    const fields: []const std.builtin.Type.StructField = std.meta.fields(T);
+    const a = fields[0].name;
+    const b = fields[1].name;
+    const c = fields[2].name;
+    const alpha = "alpha";
+    if (!@hasField(T, "alpha")) {
+        @compileError("A Colorspace must define an alpha field");
+    }
+
+    if (!@hasField(@TypeOf(ChannelTypeMap), a)) {
+        @compileError("A Colorspace must define a field for each channel, missing: " ++ a);
+    }
+    if (!@hasField(@TypeOf(ChannelTypeMap), b)) {
+        @compileError("A Colorspace must define a field for each channel, missing: " ++ b);
+    }
+    if (!@hasField(@TypeOf(ChannelTypeMap), c)) {
+        @compileError("A Colorspace must define a field for each channel, missing: " ++ c);
+    }
+
+    return struct {
+        pub fn components(this: *const T) struct { f32, f32, f32, f32 } {
+            return .{
+                @field(this, a),
+                @field(this, b),
+                @field(this, c),
+                @field(this, alpha),
+            };
+        }
+
+        pub fn channels(_: *const T) struct { []const u8, []const u8, []const u8 } {
+            return .{ a, b, c };
+        }
+
+        pub fn types(_: *const T) struct { ChannelType, ChannelType, ChannelType } {
+            return .{
+                @field(ChannelTypeMap, a),
+                @field(ChannelTypeMap, b),
+                @field(ChannelTypeMap, c),
+            };
+        }
+
+        pub fn resolveMissing(this: *const T) T {
+            var result: T = this.*;
+            @field(result, a) = if (std.math.isNan(@field(this, a))) 0.0 else @field(this, a);
+            @field(result, b) = if (std.math.isNan(@field(this, b))) 0.0 else @field(this, b);
+            @field(result, c) = if (std.math.isNan(@field(this, c))) 0.0 else @field(this, c);
+            @field(result, alpha) = if (std.math.isNan(@field(this, alpha))) 0.0 else @field(this, alpha);
+            return result;
+        }
+
+        pub fn resolve(this: *const T) T {
+            var resolved = resolveMissing(this);
+            if (!resolved.inGamut()) {
+                resolved = mapGamut(T, resolved);
+            }
+            return resolved;
+        }
+    };
+}
+
+pub fn BoundedColorGamut(comptime T: type) type {
+    const fields: []const std.builtin.Type.StructField = std.meta.fields(T);
+    const a = fields[0].name;
+    const b = fields[1].name;
+    const c = fields[2].name;
+    return struct {
+        pub fn inGamut(this: *const T) bool {
+            return @field(this, a) >= 0.0 and
+                @field(this, a) <= 1.0 and
+                @field(this, b) >= 0.0 and
+                @field(this, b) <= 1.0 and
+                @field(this, c) >= 0.0 and
+                @field(this, c) <= 1.0;
+        }
+
+        pub fn clip(this: *const T) T {
+            var result: T = this.*;
+            @field(result, a) = bun.clamp(@field(this, a), 0.0, 1.0);
+            @field(result, b) = bun.clamp(@field(this, b), 0.0, 1.0);
+            @field(result, c) = bun.clamp(@field(this, c), 0.0, 1.0);
+            result.alpha = bun.clamp(this.alpha, 0.0, 1.0);
+            return result;
+        }
+    };
+}
+
+pub fn DeriveInterpolate(
+    comptime T: type,
+    comptime a: []const u8,
+    comptime b: []const u8,
+    comptime c: []const u8,
+) type {
+    if (!@hasField(T, a)) @compileError("Missing field: " ++ a);
+    if (!@hasField(T, b)) @compileError("Missing field: " ++ b);
+    if (!@hasField(T, c)) @compileError("Missing field: " ++ c);
+
+    return struct {
+        pub fn fillMissingComponents(this: *T, other: *T) void {
+            if (std.math.isNan(@field(this, a))) {
+                @field(this, a) = @field(other, a);
+            }
+
+            if (std.math.isNan(@field(this, b))) {
+                @field(this, b) = @field(other, b);
+            }
+
+            if (std.math.isNan(@field(this, c))) {
+                @field(this, c) = @field(other, c);
+            }
+
+            if (std.math.isNan(this.alpha)) {
+                this.alpha = other.alpha;
+            }
+        }
+
+        pub fn interpolate(this: *const T, p1: f32, other: *const T, p2: f32) T {
+            var result: T = undefined;
+            @field(result, a) = @field(this, a) * p1 + @field(other, a) * p2;
+            @field(result, b) = @field(this, b) * p1 + @field(other, b) * p2;
+            @field(result, c) = @field(this, c) * p1 + @field(other, c) * p2;
+            result.alpha = this.alpha * p1 + other.alpha * p2;
+            return result;
+        }
+    };
+}
+
+// pub fn DerivePredefined(comptime T: type, comptime predefined_color_field: []const u8) type {
+//     return struct {
+//         pub fn
+//     };
+// }
+
+pub fn RecangularPremultiply(
+    comptime T: type,
+    comptime a: []const u8,
+    comptime b: []const u8,
+    comptime c: []const u8,
+) type {
+    if (!@hasField(T, a)) @compileError("Missing field: " ++ a);
+    if (!@hasField(T, b)) @compileError("Missing field: " ++ b);
+    if (!@hasField(T, c)) @compileError("Missing field: " ++ c);
+    return struct {
+        pub fn premultiply(this: *T) void {
+            if (!std.math.isNan(this.alpha)) {
+                @field(this, a) *= this.alpha;
+                @field(this, b) *= this.alpha;
+                @field(this, c) *= this.alpha;
+            }
+        }
+
+        pub fn unpremultiply(this: *T, alpha_multiplier: f32) void {
+            if (!std.math.isNan(this.alpha) and this.alpha != 0.0) {
+                // PERF: precalculate 1/alpha?
+                @field(this, a) /= this.alpha;
+                @field(this, b) /= this.alpha;
+                @field(this, c) /= this.alpha;
+                this.alpha *= alpha_multiplier;
+            }
+        }
+    };
+}
+
+pub fn PolarPremultiply(
+    comptime T: type,
+    comptime a: []const u8,
+    comptime b: []const u8,
+) type {
+    if (!@hasField(T, a)) @compileError("Missing field: " ++ a);
+    if (!@hasField(T, b)) @compileError("Missing field: " ++ b);
+    return struct {
+        pub fn premultiply(this: *T) void {
+            if (!std.math.isNan(this.alpha)) {
+                @field(this, a) *= this.alpha;
+                @field(this, b) *= this.alpha;
+            }
+        }
+
+        pub fn unpremultiply(this: *T, alpha_multiplier: f32) void {
+            // this.h %= 360.0;
+            this.h = @mod(this.h, 360.0);
+            if (!std.math.isNan(this.alpha)) {
+                // PERF: precalculate 1/alpha?
+                @field(this, a) /= this.alpha;
+                @field(this, b) /= this.alpha;
+                this.alpha *= alpha_multiplier;
+            }
+        }
+    };
+}
+
+pub fn AdjustPowerlessLAB(comptime T: type) type {
+    return struct {
+        pub fn adjustPowerlessComponents(this: *T) void {
+            // If the lightness of a LAB color is 0%, both the a and b components are powerless.
+            if (@abs(this.l) < std.math.floatEps(f32)) {
+                this.a = std.math.nan(f32);
+                this.b = std.math.nan(f32);
+            }
+        }
+    };
+}
+
+pub fn AdjustPowerlessLCH(comptime T: type) type {
+    return struct {
+        pub fn adjustPowerlessComponents(this: *T) void {
+            // If the chroma of an LCH color is 0%, the hue component is powerless.
+            // If the lightness of an LCH color is 0%, both the hue and chroma components are powerless.
+            if (@abs(this.c) < std.math.floatEps(f32)) {
+                this.h = std.math.nan(f32);
+            }
+
+            if (@abs(this.l) < std.math.floatEps(f32)) {
+                this.c = std.math.nan(f32);
+                this.h = std.math.nan(f32);
+            }
+        }
+
+        pub fn adjustHue(this: *T, other: *T, method: HueInterpolationMethod) void {
+            _ = method.interpolate(&this.h, &other.h);
+        }
+    };
+}
+
+pub fn shortColorName(v: u32) ?[]const u8 {
+    // These names are shorter than their hex codes
+    return switch (v) {
+        0x000080 => "navy",
+        0x008000 => "green",
+        0x008080 => "teal",
+        0x4b0082 => "indigo",
+        0x800000 => "maroon",
+        0x800080 => "purple",
+        0x808000 => "olive",
+        0x808080 => "gray",
+        0xa0522d => "sienna",
+        0xa52a2a => "brown",
+        0xc0c0c0 => "silver",
+        0xcd853f => "peru",
+        0xd2b48c => "tan",
+        0xda70d6 => "orchid",
+        0xdda0dd => "plum",
+        0xee82ee => "violet",
+        0xf0e68c => "khaki",
+        0xf0ffff => "azure",
+        0xf5deb3 => "wheat",
+        0xf5f5dc => "beige",
+        0xfa8072 => "salmon",
+        0xfaf0e6 => "linen",
+        0xff0000 => "red",
+        0xff6347 => "tomato",
+        0xff7f50 => "coral",
+        0xffa500 => "orange",
+        0xffc0cb => "pink",
+        0xffd700 => "gold",
+        0xffe4c4 => "bisque",
+        0xfffafa => "snow",
+        0xfffff0 => "ivory",
+        else => return null,
+    };
+}
+
+// From esbuild: https://github.com/evanw/esbuild/blob/18e13bdfdca5cd3c7a2fae1a8bd739f8f891572c/internal/css_parser/css_decls_color.go#L218
+// 0xAABBCCDD => 0xABCD
+pub fn compactHex(v: u32) u32 {
+    return ((v & 0x0FF00000) >> 12) | ((v & 0x00000FF0) >> 4);
+}
+
+// 0xABCD => 0xAABBCCDD
+pub fn expandHex(v: u32) u32 {
+    return ((v & 0xF000) << 16) |
+        ((v & 0xFF00) << 12) |
+        ((v & 0x0FF0) << 8) |
+        ((v & 0x00FF) << 4) |
+        (v & 0x000F);
+}
+
+pub fn writeComponents(
+    name: []const u8,
+    a: f32,
+    b: f32,
+    c: f32,
+    alpha: f32,
+    comptime W: type,
+    dest: *Printer(W),
+) PrintErr!void {
+    try dest.writeStr(name);
+    try dest.writeChar('(');
+    if (std.math.isNan(a)) {
+        try dest.writeStr("none");
+    } else {
+        try (Percentage{ .v = a }).toCss(W, dest);
+    }
+    try dest.writeChar(' ');
+    try writeComponent(b, W, dest);
+    try dest.writeChar(' ');
+    try writeComponent(c, W, dest);
+    if (std.math.isNan(alpha) or @abs(alpha - 1.0) > std.math.floatEps(f32)) {
+        try dest.delim('/', true);
+        try writeComponent(alpha, W, dest);
+    }
+    return dest.writeChar(')');
+}
+
+pub fn writeComponent(c: f32, comptime W: type, dest: *Printer(W)) PrintErr!void {
+    if (std.math.isNan(c)) {
+        return dest.writeStr("none");
+    } else {
+        return CSSNumberFns.toCss(&c, W, dest);
+    }
+}
+
+pub fn writePredefined(
+    predefined: *const PredefinedColor,
+    comptime W: type,
+    dest: *Printer(W),
+) PrintErr!void {
+    const name, const a, const b, const c, const alpha = switch (predefined.*) {
+        .srgb => |*rgb| .{ "srgb", rgb.r, rgb.g, rgb.b, rgb.alpha },
+        .srgb_linear => |*rgb| .{ "srgb-linear", rgb.r, rgb.g, rgb.b, rgb.alpha },
+        .display_p3 => |*rgb| .{ "display-p3", rgb.r, rgb.g, rgb.b, rgb.alpha },
+        .a98 => |*rgb| .{ "a98-rgb", rgb.r, rgb.g, rgb.b, rgb.alpha },
+        .prophoto => |*rgb| .{ "prophoto-rgb", rgb.r, rgb.g, rgb.b, rgb.alpha },
+        .rec2020 => |*rgb| .{ "rec2020", rgb.r, rgb.g, rgb.b, rgb.alpha },
+        .xyz_d50 => |*xyz| .{ "xyz-d50", xyz.x, xyz.y, xyz.z, xyz.alpha },
+        // "xyz" has better compatibility (Safari 15) than "xyz-d65", and it is shorter.
+        .xyz_d65 => |*xyz| .{ "xyz", xyz.x, xyz.y, xyz.z, xyz.alpha },
+    };
+
+    try dest.writeStr("color(");
+    try dest.writeStr(name);
+    try dest.writeChar(' ');
+    try writeComponent(a, W, dest);
+    try dest.writeChar(' ');
+    try writeComponent(b, W, dest);
+    try dest.writeChar(' ');
+    try writeComponent(c, W, dest);
+
+    if (std.math.isNan(alpha) or @abs(alpha - 1.0) > std.math.floatEps(f32)) {
+        try dest.delim('/', true);
+        try writeComponent(alpha, W, dest);
+    }
+
+    return dest.writeChar(')');
+}
+
+extern "c" fn powf(f32, f32) f32;
+
+pub fn gamSrgb(r: f32, g: f32, b: f32) struct { f32, f32, f32 } {
+    // https://github.com/w3c/csswg-drafts/blob/fba005e2ce9bcac55b49e4aa19b87208b3a0631e/css-color-4/conversions.js#L31
+    // convert an array of linear-light sRGB values in the range 0.0-1.0
+    // to gamma corrected form
+    // https://en.wikipedia.org/wiki/SRGB
+    // Extended transfer function:
+    // For negative values, linear portion extends on reflection
+    // of axis, then uses reflected pow below that
+
+    const Helpers = struct {
+        pub fn gamSrgbComponent(c: f32) f32 {
+            const abs = @abs(c);
+            if (abs > 0.0031308) {
+                const sign: f32 = if (c < 0.0) @as(f32, -1.0) else @as(f32, 1.0);
+                // const x: f32 = bun.powf( abs,  1.0 / 2.4);
+                const x: f32 = powf(abs, 1.0 / 2.4);
+                const y: f32 = 1.055 * x;
+                const z: f32 = y - 0.055;
+                // return sign * (1.055 * bun.powf( abs,  1.0 / 2.4) - 0.055);
+                return sign * z;
+            }
+
+            return 12.92 * c;
+        }
+    };
+
+    const rr = Helpers.gamSrgbComponent(r);
+    const gg = Helpers.gamSrgbComponent(g);
+    const bb = Helpers.gamSrgbComponent(b);
+    return .{
+        rr,
+        gg,
+        bb,
+    };
+}
+
+pub fn linSrgb(r: f32, g: f32, b: f32) struct { f32, f32, f32 } {
+    // https://github.com/w3c/csswg-drafts/blob/fba005e2ce9bcac55b49e4aa19b87208b3a0631e/css-color-4/conversions.js#L11
+    // convert sRGB values where in-gamut values are in the range [0 - 1]
+    // to linear light (un-companded) form.
+    // https://en.wikipedia.org/wiki/SRGB
+    // Extended transfer function:
+    // for negative values, linear portion is extended on reflection of axis,
+    // then reflected power function is used.
+
+    const H = struct {
+        pub fn linSrgbComponent(c: f32) f32 {
+            const abs = @abs(c);
+            if (abs < 0.04045) {
+                return c / 12.92;
+            }
+
+            const sign: f32 = if (c < 0.0) -1.0 else 1.0;
+            return sign * bun.powf(
+                ((abs + 0.055) / 1.055),
+                2.4,
+            );
+        }
+    };
+
+    return .{
+        H.linSrgbComponent(r),
+        H.linSrgbComponent(g),
+        H.linSrgbComponent(b),
+    };
+}
+
+/// PERF: SIMD?
+pub fn multiplyMatrix(m: *const [9]f32, x: f32, y: f32, z: f32) struct { f32, f32, f32 } {
+    const a = m[0] * x + m[1] * y + m[2] * z;
+    const b = m[3] * x + m[4] * y + m[5] * z;
+    const c = m[6] * x + m[7] * y + m[8] * z;
+    return .{ a, b, c };
+}
+
+pub fn polarToRectangular(l: f32, c: f32, h: f32) struct { f32, f32, f32 } {
+    // https://github.com/w3c/csswg-drafts/blob/fba005e2ce9bcac55b49e4aa19b87208b3a0631e/css-color-4/conversions.js#L385
+
+    const a = c * @cos(h * std.math.pi / 180.0);
+    const b = c * @sin(h * std.math.pi / 180.0);
+    return .{ l, a, b };
+}
+
+const D50: []const f32 = &.{ @floatCast(@as(f64, 0.3457) / @as(f64, 0.3585)), 1.00000, @floatCast((@as(f64, 1.0) - @as(f64, 0.3457) - @as(f64, 0.3585)) / @as(f64, 0.3585)) };
+// const D50: []const f32 = &.{ 0.9642956, 1.0, 0.82510453 };
+
+const color_conversions = struct {
+    const generated = @import("./color_generated.zig").generated_color_conversions;
+
+    pub const convert_RGBA = struct {
+        pub usingnamespace generated.convert_RGBA;
+    };
+
+    pub const convert_LAB = struct {
+        pub usingnamespace generated.convert_LAB;
+
+        pub fn intoCssColor(c: *const LAB, allocator: Allocator) CssColor {
+            return CssColor{ .lab = bun.create(
+                allocator,
+                LABColor,
+                LABColor{ .lab = c.* },
+            ) };
+        }
+
+        pub fn intoLCH(_lab: *const LAB) LCH {
+            const lab = _lab.resolveMissing();
+            const l, const c, const h = rectangularToPolar(lab.l, lab.a, lab.b);
+            return LCH{
+                .l = l,
+                .c = c,
+                .h = h,
+                .alpha = lab.alpha,
+            };
+        }
+
+        pub fn intoXYZd50(_lab: *const LAB) XYZd50 {
+            // https://github.com/w3c/csswg-drafts/blob/fba005e2ce9bcac55b49e4aa19b87208b3a0631e/css-color-4/conversions.js#L352
+            const K: f32 = @floatCast(@as(f64, 24389.0) / @as(f64, 27.0)); // 29^3/3^3
+            const E: f32 = @floatCast(@as(f64, 216.0) / @as(f64, 24389.0)); // 6^3/29^3
+
+            const lab = _lab.resolveMissing();
+            const l = lab.l * 100.0;
+            const a = lab.a;
+            const b = lab.b;
+
+            // compute f, starting with the luminance-related term
+            const f1: f32 = (l + 16.0) / 116.0;
+            const f0: f32 = a / 500.0 + f1;
+            const f2: f32 = f1 - b / 200.0;
+
+            // compute xyz
+            const x = if (bun.powf(f0, 3) > E)
+                bun.powf(f0, 3)
+            else
+                (116.0 * f0 - 16.0) / K;
+
+            const y = if (l > K * E) bun.powf((l + 16.0) / 116.0, 3) else l / K;
+
+            const z = if (bun.powf(f2, 3) > E)
+                bun.powf(f2, 3)
+            else
+                (@as(f32, 116.0) * f2 - 16.0) / K;
+
+            const final_x = x * D50[0];
+            const final_y = y * D50[1];
+            const final_z = z * D50[2];
+
+            // Compute XYZ by scaling xyz by reference white
+            return XYZd50{
+                .x = final_x,
+                .y = final_y,
+                .z = final_z,
+                .alpha = lab.alpha,
+            };
+        }
+    };
+
+    pub const convert_SRGB = struct {
+        pub usingnamespace generated.convert_SRGB;
+
+        pub fn intoCssColor(srgb: *const SRGB, _: Allocator) CssColor {
+            // TODO: should we serialize as color(srgb, ...)?
+            // would be more precise than 8-bit color.
+            return CssColor{ .rgba = srgb.intoRGBA() };
+        }
+
+        pub fn intoSRGBLinear(rgb: *const SRGB) SRGBLinear {
+            const srgb = rgb.resolveMissing();
+            const r, const g, const b = linSrgb(srgb.r, srgb.g, srgb.b);
+            return SRGBLinear{
+                .r = r,
+                .g = g,
+                .b = b,
+                .alpha = srgb.alpha,
+            };
+        }
+
+        pub fn intoHSL(_rgb: *const SRGB) HSL {
+            // https://drafts.csswg.org/css-color/#rgb-to-hsl
+            const rgb = _rgb.resolve();
+            const r = rgb.r;
+            const g = rgb.g;
+            const b = rgb.b;
+            const max = @max(
+                @max(r, g),
+                b,
+            );
+            const min = @min(@min(r, g), b);
+            var h = std.math.nan(f32);
+            var s: f32 = 0.0;
+            const l = (min + max) / 2.0;
+            const d = max - min;
+
+            if (d != 0.0) {
+                s = if (l == 0.0 or l == 1.0)
+                    0.0
+                else
+                    (max - l) / @min(l, 1.0 - l);
+
+                if (max == r) {
+                    h = (g - b) / d + (if (g < b) @as(f32, 6.0) else @as(f32, 0.0));
+                } else if (max == g) {
+                    h = (b - r) / d + 2.0;
+                } else if (max == b) {
+                    h = (r - g) / d + 4.0;
+                }
+
+                h = h * 60.0;
+            }
+
+            return HSL{
+                .h = h,
+                .s = s,
+                .l = l,
+                .alpha = rgb.alpha,
+            };
+        }
+
+        pub fn intoHWB(_rgb: *const SRGB) HWB {
+            const rgb = _rgb.resolve();
+            const hsl = rgb.intoHSL();
+            const r = rgb.r;
+            const g = rgb.g;
+            const _b = rgb.b;
+            const w = @min(@min(r, g), _b);
+            const b = 1.0 - @max(@max(r, g), _b);
+            return HWB{
+                .h = hsl.h,
+                .w = w,
+                .b = b,
+                .alpha = rgb.alpha,
+            };
+        }
+    };
+
+    pub const convert_HSL = struct {
+        pub usingnamespace generated.convert_HSL;
+
+        pub fn intoCssColor(c: *const HSL, _: Allocator) CssColor {
+            // TODO: should we serialize as color(srgb, ...)?
+            // would be more precise than 8-bit color.
+            return CssColor{ .rgba = c.intoRGBA() };
+        }
+
+        pub fn intoSRGB(hsl_: *const HSL) SRGB {
+            // https://drafts.csswg.org/css-color/#hsl-to-rgb
+            const hsl = hsl_.resolveMissing();
+            const h = (hsl.h - 360.0 * @floor(hsl.h / 360.0)) / 360.0;
+            const r, const g, const b = css.color.hslToRgb(h, hsl.s, hsl.l);
+            return SRGB{
+                .r = r,
+                .g = g,
+                .b = b,
+                .alpha = hsl.alpha,
+            };
+        }
+    };
+
+    pub const convert_HWB = struct {
+        pub usingnamespace generated.convert_HWB;
+
+        pub fn intoCssColor(c: *const HWB, _: Allocator) CssColor {
+            // TODO: should we serialize as color(srgb, ...)?
+            // would be more precise than 8-bit color.
+            return CssColor{ .rgba = c.intoRGBA() };
+        }
+
+        pub fn intoSRGB(_hwb: *const HWB) SRGB {
+            // https://drafts.csswg.org/css-color/#hwb-to-rgb
+            const hwb = _hwb.resolveMissing();
+            const h = hwb.h;
+            const w = hwb.w;
+            const b = hwb.b;
+
+            if (w + b >= 1.0) {
+                const gray = w / (w + b);
+                return SRGB{
+                    .r = gray,
+                    .g = gray,
+                    .b = gray,
+                    .alpha = hwb.alpha,
+                };
+            }
+
+            var rgba = (HSL{ .h = h, .s = 1.0, .l = 0.5, .alpha = hwb.alpha }).intoSRGB();
+            const x = 1.0 - w - b;
+            rgba.r = rgba.r * x + w;
+            rgba.g = rgba.g * x + w;
+            rgba.b = rgba.b * x + w;
+            return rgba;
+        }
+    };
+
+    pub const convert_SRGBLinear = struct {
+        pub usingnamespace generated.convert_SRGBLinear;
+
+        pub fn intoPredefinedColor(rgb: *const SRGBLinear) PredefinedColor {
+            return PredefinedColor{ .srgb_linear = rgb.* };
+        }
+
+        pub fn intoCssColor(rgb: *const SRGBLinear, allocator: Allocator) CssColor {
+            return CssColor{
+                .predefined = bun.create(
+                    allocator,
+                    PredefinedColor,
+                    rgb.intoPredefinedColor(),
+                ),
+            };
+        }
+
+        pub fn intoSRGB(_rgb: *const SRGBLinear) SRGB {
+            const rgb = _rgb.resolveMissing();
+            const r, const g, const b = gamSrgb(rgb.r, rgb.g, rgb.b);
+            return SRGB{
+                .r = r,
+                .g = g,
+                .b = b,
+                .alpha = rgb.alpha,
+            };
+        }
+
+        pub fn intoXYZd65(_rgb: *const SRGBLinear) XYZd65 {
+            // https://github.com/w3c/csswg-drafts/blob/fba005e2ce9bcac55b49e4aa19b87208b3a0631e/css-color-4/conversions.js#L50
+            // convert an array of linear-light sRGB values to CIE XYZ
+            // using sRGB's own white, D65 (no chromatic adaptation)
+            const MATRIX: [9]f32 = .{
+                0.41239079926595934,
+                0.357584339383878,
+                0.1804807884018343,
+                0.21263900587151027,
+                0.715168678767756,
+                0.07219231536073371,
+                0.01933081871559182,
+                0.11919477979462598,
+                0.9505321522496607,
+            };
+
+            const rgb = _rgb.resolveMissing();
+            const x, const y, const z = multiplyMatrix(&MATRIX, rgb.r, rgb.g, rgb.b);
+            return XYZd65{
+                .x = x,
+                .y = y,
+                .z = z,
+                .alpha = rgb.alpha,
+            };
+        }
+    };
+
+    pub const convert_P3 = struct {
+        pub usingnamespace generated.convert_P3;
+
+        pub fn intoPredefinedColor(rgb: *const P3) PredefinedColor {
+            return PredefinedColor{ .display_p3 = rgb.* };
+        }
+
+        pub fn intoCssColor(rgb: *const P3, allocator: Allocator) CssColor {
+            return CssColor{
+                .predefined = bun.create(
+                    allocator,
+                    PredefinedColor,
+                    rgb.intoPredefinedColor(),
+                ),
+            };
+        }
+
+        pub fn intoXYZd65(_p3: *const P3) XYZd65 {
+            // https://github.com/w3c/csswg-drafts/blob/fba005e2ce9bcac55b49e4aa19b87208b3a0631e/css-color-4/conversions.js#L91
+            // convert linear-light display-p3 values to CIE XYZ
+            // using D65 (no chromatic adaptation)
+            // http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html
+            const MATRIX: [9]f32 = .{
+                0.4865709486482162,
+                0.26566769316909306,
+                0.1982172852343625,
+                0.2289745640697488,
+                0.6917385218365064,
+                0.079286914093745,
+                0.0000000000000000,
+                0.04511338185890264,
+                1.043944368900976,
+            };
+
+            const p3 = _p3.resolveMissing();
+            const r, const g, const b = linSrgb(p3.r, p3.g, p3.b);
+            const x, const y, const z = multiplyMatrix(&MATRIX, r, g, b);
+            return XYZd65{
+                .x = x,
+                .y = y,
+                .z = z,
+                .alpha = p3.alpha,
+            };
+        }
+    };
+
+    pub const convert_A98 = struct {
+        pub usingnamespace generated.convert_A98;
+
+        pub fn intoPredefinedColor(rgb: *const A98) PredefinedColor {
+            return PredefinedColor{ .a98 = rgb.* };
+        }
+
+        pub fn intoCssColor(rgb: *const A98, allocator: Allocator) CssColor {
+            return CssColor{
+                .predefined = bun.create(
+                    allocator,
+                    PredefinedColor,
+                    rgb.intoPredefinedColor(),
+                ),
+            };
+        }
+
+        pub fn intoXYZd65(_a98: *const A98) XYZd65 {
+            // https://github.com/w3c/csswg-drafts/blob/fba005e2ce9bcac55b49e4aa19b87208b3a0631e/css-color-4/conversions.js#L181
+            const H = struct {
+                pub fn linA98rgbComponent(c: f32) f32 {
+                    const sign: f32 = if (c < 0.0) @as(f32, -1.0) else @as(f32, 1.0);
+                    return sign * bun.powf(@abs(c), 563.0 / 256.0);
+                }
+            };
+
+            // convert an array of a98-rgb values in the range 0.0 - 1.0
+            // to linear light (un-companded) form.
+            // negative values are also now accepted
+            const a98 = _a98.resolveMissing();
+            const r = H.linA98rgbComponent(a98.r);
+            const g = H.linA98rgbComponent(a98.g);
+            const b = H.linA98rgbComponent(a98.b);
+
+            // convert an array of linear-light a98-rgb values to CIE XYZ
+            // http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html
+            // has greater numerical precision than section 4.3.5.3 of
+            // https://www.adobe.com/digitalimag/pdfs/AdobeRGB1998.pdf
+            // but the values below were calculated from first principles
+            // from the chromaticity coordinates of R G B W
+            // see matrixmaker.html
+            const MATRIX: [9]f32 = .{
+                0.5766690429101305,
+                0.1855582379065463,
+                0.1882286462349947,
+                0.29734497525053605,
+                0.6273635662554661,
+                0.07529145849399788,
+                0.02703136138641234,
+                0.07068885253582723,
+                0.9913375368376388,
+            };
+
+            const x, const y, const z = multiplyMatrix(&MATRIX, r, g, b);
+            return XYZd65{
+                .x = x,
+                .y = y,
+                .z = z,
+                .alpha = a98.alpha,
+            };
+        }
+    };
+
+    pub const convert_ProPhoto = struct {
+        pub usingnamespace generated.convert_ProPhoto;
+
+        pub fn intoPredefinedColor(rgb: *const ProPhoto) PredefinedColor {
+            return PredefinedColor{ .prophoto = rgb.* };
+        }
+
+        pub fn intoCssColor(rgb: *const ProPhoto, allocator: Allocator) CssColor {
+            return CssColor{
+                .predefined = bun.create(
+                    allocator,
+                    PredefinedColor,
+                    rgb.intoPredefinedColor(),
+                ),
+            };
+        }
+
+        pub fn intoXYZd50(_prophoto: *const ProPhoto) XYZd50 {
+            // https://github.com/w3c/csswg-drafts/blob/fba005e2ce9bcac55b49e4aa19b87208b3a0631e/css-color-4/conversions.js#L118
+            // convert an array of prophoto-rgb values
+            // where in-gamut colors are in the range [0.0 - 1.0]
+            // to linear light (un-companded) form.
+            // Transfer curve is gamma 1.8 with a small linear portion
+            // Extended transfer function
+
+            const H = struct {
+                pub fn linProPhotoComponent(c: f32) f32 {
+                    const ET2: f32 = 16.0 / 512.0;
+                    const abs = @abs(c);
+                    if (abs <= ET2) {
+                        return c / 16.0;
+                    }
+                    const sign: f32 = if (c < 0.0) -1.0 else 1.0;
+                    return sign * bun.powf(abs, 1.8);
+                }
+            };
+
+            const prophoto = _prophoto.resolveMissing();
+            const r = H.linProPhotoComponent(prophoto.r);
+            const g = H.linProPhotoComponent(prophoto.g);
+            const b = H.linProPhotoComponent(prophoto.b);
+
+            // https://github.com/w3c/csswg-drafts/blob/fba005e2ce9bcac55b49e4aa19b87208b3a0631e/css-color-4/conversions.js#L155
+            // convert an array of linear-light prophoto-rgb values to CIE XYZ
+            // using  D50 (so no chromatic adaptation needed afterwards)
+            // http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html
+            const MATRIX: [9]f32 = .{
+                0.7977604896723027,
+                0.13518583717574031,
+                0.0313493495815248,
+                0.2880711282292934,
+                0.7118432178101014,
+                0.00008565396060525902,
+                0.0,
+                0.0,
+                0.8251046025104601,
+            };
+
+            const x, const y, const z = multiplyMatrix(&MATRIX, r, g, b);
+            return XYZd50{
+                .x = x,
+                .y = y,
+                .z = z,
+                .alpha = prophoto.alpha,
+            };
+        }
+    };
+
+    pub const convert_Rec2020 = struct {
+        pub usingnamespace generated.convert_Rec2020;
+
+        pub fn intoPredefinedColor(rgb: *const Rec2020) PredefinedColor {
+            return PredefinedColor{ .rec2020 = rgb.* };
+        }
+
+        pub fn intoCssColor(rgb: *const Rec2020, allocator: Allocator) CssColor {
+            return CssColor{
+                .predefined = bun.create(
+                    allocator,
+                    PredefinedColor,
+                    rgb.intoPredefinedColor(),
+                ),
+            };
+        }
+
+        pub fn intoXYZd65(_rec2020: *const Rec2020) XYZd65 {
+            // https://github.com/w3c/csswg-drafts/blob/fba005e2ce9bcac55b49e4aa19b87208b3a0631e/css-color-4/conversions.js#L235
+            // convert an array of rec2020 RGB values in the range 0.0 - 1.0
+            // to linear light (un-companded) form.
+            // ITU-R BT.2020-2 p.4
+
+            const H = struct {
+                pub fn linRec2020Component(c: f32) f32 {
+                    const A: f32 = 1.09929682680944;
+                    const B: f32 = 0.018053968510807;
+
+                    const abs = @abs(c);
+                    if (abs < B * 4.5) {
+                        return c / 4.5;
+                    }
+
+                    const sign: f32 = if (c < 0.0) -1.0 else 1.0;
+                    return sign * bun.powf(
+                        (abs + A - 1.0) / A,
+                        1.0 / 0.45,
+                    );
+                }
+            };
+
+            const rec2020 = _rec2020.resolveMissing();
+            const r = H.linRec2020Component(rec2020.r);
+            const g = H.linRec2020Component(rec2020.g);
+            const b = H.linRec2020Component(rec2020.b);
+
+            // https://github.com/w3c/csswg-drafts/blob/fba005e2ce9bcac55b49e4aa19b87208b3a0631e/css-color-4/conversions.js#L276
+            // convert an array of linear-light rec2020 values to CIE XYZ
+            // using  D65 (no chromatic adaptation)
+            // http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html
+            const MATRIX: [9]f32 = .{
+                0.6369580483012914,
+                0.14461690358620832,
+                0.1688809751641721,
+                0.2627002120112671,
+                0.6779980715188708,
+                0.05930171646986196,
+                0.000000000000000,
+                0.028072693049087428,
+                1.060985057710791,
+            };
+
+            const x, const y, const z = multiplyMatrix(&MATRIX, r, g, b);
+
+            return XYZd65{
+                .x = x,
+                .y = y,
+                .z = z,
+                .alpha = rec2020.alpha,
+            };
+        }
+    };
+
+    pub const convert_XYZd50 = struct {
+        pub usingnamespace generated.convert_XYZd50;
+
+        pub fn intoPredefinedColor(rgb: *const XYZd50) PredefinedColor {
+            return PredefinedColor{ .xyz_d50 = rgb.* };
+        }
+
+        pub fn intoCssColor(rgb: *const XYZd50, allocator: Allocator) CssColor {
+            return CssColor{
+                .predefined = bun.create(
+                    allocator,
+                    PredefinedColor,
+                    rgb.intoPredefinedColor(),
+                ),
+            };
+        }
+
+        pub fn intoLAB(_xyz: *const XYZd50) LAB {
+            // https://github.com/w3c/csswg-drafts/blob/fba005e2ce9bcac55b49e4aa19b87208b3a0631e/css-color-4/conversions.js#L332
+            // Assuming XYZ is relative to D50, convert to CIE LAB
+            // from CIE standard, which now defines these as a rational fraction
+            const E: f32 = 216.0 / 24389.0; // 6^3/29^3
+            const K: f32 = 24389.0 / 27.0; // 29^3/3^3
+
+            // compute xyz, which is XYZ scaled relative to reference white
+            const xyz = _xyz.resolveMissing();
+            const x = xyz.x / D50[0];
+            const y = xyz.y / D50[1];
+            const z = xyz.y / D50[2];
+
+            // now compute f
+
+            const f0 = if (x > E) std.math.cbrt(x) else (K * x + 16.0) / 116.0;
+
+            const f1 = if (y > E) std.math.cbrt(y) else (K * y + 16.0) / 116.0;
+
+            const f2 = if (z > E) std.math.cbrt(z) else (K * z + 16.0) / 116.0;
+
+            const l = ((116.0 * f1) - 16.0) / 100.0;
+            const a = 500.0 * (f0 - f1);
+            const b = 500.0 * (f1 - f2);
+
+            return LAB{
+                .l = l,
+                .a = a,
+                .b = b,
+                .alpha = xyz.alpha,
+            };
+        }
+
+        pub fn intoXYZd65(_xyz: *const XYZd50) XYZd65 {
+            // https://github.com/w3c/csswg-drafts/blob/fba005e2ce9bcac55b49e4aa19b87208b3a0631e/css-color-4/conversions.js#L105
+            const MATRIX: [9]f32 = .{
+                0.9554734527042182,
+                -0.023098536874261423,
+                0.0632593086610217,
+                -0.028369706963208136,
+                1.0099954580058226,
+                0.021041398966943008,
+                0.012314001688319899,
+                -0.020507696433477912,
+                1.3303659366080753,
+            };
+
+            const xyz = _xyz.resolveMissing();
+            const x, const y, const z = multiplyMatrix(&MATRIX, xyz.x, xyz.y, xyz.z);
+            return XYZd65{
+                .x = x,
+                .y = y,
+                .z = z,
+                .alpha = xyz.alpha,
+            };
+        }
+
+        pub fn intoProPhoto(_xyz: *const XYZd50) ProPhoto {
+            // convert XYZ to linear-light prophoto-rgb
+            const MATRIX: [9]f32 = .{
+                1.3457989731028281,
+                -0.25558010007997534,
+                -0.05110628506753401,
+                -0.5446224939028347,
+                1.5082327413132781,
+                0.02053603239147973,
+                0.0,
+                0.0,
+                1.2119675456389454,
+            };
+            const H = struct {
+                pub fn gamProPhotoComponent(c: f32) f32 {
+                    // https://github.com/w3c/csswg-drafts/blob/fba005e2ce9bcac55b49e4aa19b87208b3a0631e/css-color-4/conversions.js#L137
+                    // convert linear-light prophoto-rgb  in the range 0.0-1.0
+                    // to gamma corrected form
+                    // Transfer curve is gamma 1.8 with a small linear portion
+                    // TODO for negative values, extend linear portion on reflection of axis, then add pow below that
+                    const ET: f32 = 1.0 / 512.0;
+                    const abs = @abs(c);
+                    if (abs >= ET) {
+                        const sign: f32 = if (c < 0.0) -1.0 else 1.0;
+                        return sign * bun.powf(abs, 1.0 / 1.8);
+                    }
+                    return 16.0 * c;
+                }
+            };
+            const xyz = _xyz.resolveMissing();
+            const r1, const g1, const b1 = multiplyMatrix(&MATRIX, xyz.x, xyz.y, xyz.z);
+            const r = H.gamProPhotoComponent(r1);
+            const g = H.gamProPhotoComponent(g1);
+            const b = H.gamProPhotoComponent(b1);
+            return ProPhoto{
+                .r = r,
+                .g = g,
+                .b = b,
+                .alpha = xyz.alpha,
+            };
+        }
+    };
+
+    pub const convert_XYZd65 = struct {
+        pub usingnamespace generated.convert_XYZd65;
+
+        pub fn intoPredefinedColor(rgb: *const XYZd65) PredefinedColor {
+            return PredefinedColor{ .xyz_d65 = rgb.* };
+        }
+
+        pub fn intoCssColor(rgb: *const XYZd65, allocator: Allocator) CssColor {
+            return CssColor{
+                .predefined = bun.create(
+                    allocator,
+                    PredefinedColor,
+                    rgb.intoPredefinedColor(),
+                ),
+            };
+        }
+
+        pub fn intoXYZd50(_xyz: *const XYZd65) XYZd50 {
+            // https://github.com/w3c/csswg-drafts/blob/fba005e2ce9bcac55b49e4aa19b87208b3a0631e/css-color-4/conversions.js#L319
+
+            const MATRIX: [9]f32 = .{
+                1.0479298208405488,
+                0.022946793341019088,
+                -0.05019222954313557,
+                0.029627815688159344,
+                0.990434484573249,
+                -0.01707382502938514,
+                -0.009243058152591178,
+                0.015055144896577895,
+                0.7518742899580008,
+            };
+
+            const xyz = _xyz.resolveMissing();
+            const x, const y, const z = multiplyMatrix(&MATRIX, xyz.x, xyz.y, xyz.z);
+            return XYZd50{
+                .x = x,
+                .y = y,
+                .z = z,
+                .alpha = xyz.alpha,
+            };
+        }
+
+        pub fn intoSRGBLinear(_xyz: *const XYZd65) SRGBLinear {
+            // https://github.com/w3c/csswg-drafts/blob/fba005e2ce9bcac55b49e4aa19b87208b3a0631e/css-color-4/conversions.js#L62
+            const MATRIX: [9]f32 = .{
+                3.2409699419045226,
+                -1.537383177570094,
+                -0.4986107602930034,
+                -0.9692436362808796,
+                1.8759675015077202,
+                0.04155505740717559,
+                0.05563007969699366,
+                -0.20397695888897652,
+                1.0569715142428786,
+            };
+
+            const xyz = _xyz.resolveMissing();
+            const r, const g, const b = multiplyMatrix(&MATRIX, xyz.x, xyz.y, xyz.z);
+            return SRGBLinear{
+                .r = r,
+                .g = g,
+                .b = b,
+                .alpha = xyz.alpha,
+            };
+        }
+
+        pub fn intoA98(_xyz: *const XYZd65) A98 {
+            // https://github.com/w3c/csswg-drafts/blob/fba005e2ce9bcac55b49e4aa19b87208b3a0631e/css-color-4/conversions.js#L222
+            // convert XYZ to linear-light a98-rgb
+
+            const MATRIX: [9]f32 = .{
+                2.0415879038107465,
+                -0.5650069742788596,
+                -0.34473135077832956,
+                -0.9692436362808795,
+                1.8759675015077202,
+                0.04155505740717557,
+                0.013444280632031142,
+                -0.11836239223101838,
+                1.0151749943912054,
+            };
+
+            const H = struct {
+                pub fn gamA98Component(c: f32) f32 {
+                    // https://github.com/w3c/csswg-drafts/blob/fba005e2ce9bcac55b49e4aa19b87208b3a0631e/css-color-4/conversions.js#L193
+                    // convert linear-light a98-rgb  in the range 0.0-1.0
+                    // to gamma corrected form
+                    // negative values are also now accepted
+                    const sign: f32 = if (c < 0.0) -1.0 else 1.0;
+                    return sign * bun.powf(@abs(c), 256.0 / 563.0);
+                }
+            };
+
+            const xyz = _xyz.resolveMissing();
+            const r1, const g1, const b1 = multiplyMatrix(&MATRIX, xyz.x, xyz.y, xyz.z);
+            const r = H.gamA98Component(r1);
+            const g = H.gamA98Component(g1);
+            const b = H.gamA98Component(b1);
+            return A98{
+                .r = r,
+                .g = g,
+                .b = b,
+                .alpha = xyz.alpha,
+            };
+        }
+
+        pub fn intoRec2020(_xyz: *const XYZd65) Rec2020 {
+            // convert XYZ to linear-light rec2020
+            const MATRIX: [9]f32 = .{
+                1.7166511879712674,
+                -0.35567078377639233,
+                -0.25336628137365974,
+                -0.6666843518324892,
+                1.6164812366349395,
+                0.01576854581391113,
+                0.017639857445310783,
+                -0.042770613257808524,
+                0.9421031212354738,
+            };
+
+            const H = struct {
+                pub fn gamRec2020Component(c: f32) f32 {
+                    // convert linear-light rec2020 RGB  in the range 0.0-1.0
+                    // to gamma corrected form
+                    // ITU-R BT.2020-2 p.4
+
+                    const A: f32 = 1.09929682680944;
+                    const B: f32 = 0.018053968510807;
+
+                    const abs = @abs(c);
+                    if (abs > B) {
+                        const sign: f32 = if (c < 0.0) -1.0 else 1.0;
+                        return sign * (A * bun.powf(abs, 0.45) - (A - 1.0));
+                    }
+
+                    return 4.5 * c;
+                }
+            };
+
+            const xyz = _xyz.resolveMissing();
+            const r1, const g1, const b1 = multiplyMatrix(&MATRIX, xyz.x, xyz.y, xyz.z);
+            const r = H.gamRec2020Component(r1);
+            const g = H.gamRec2020Component(g1);
+            const b = H.gamRec2020Component(b1);
+            return Rec2020{
+                .r = r,
+                .g = g,
+                .b = b,
+                .alpha = xyz.alpha,
+            };
+        }
+
+        pub fn intoOKLAB(_xyz: *const XYZd65) OKLAB {
+            // https://github.com/w3c/csswg-drafts/blob/fba005e2ce9bcac55b49e4aa19b87208b3a0631e/css-color-4/conversions.js#L400
+            const XYZ_TO_LMS: [9]f32 = .{
+                0.8190224432164319,
+                0.3619062562801221,
+                -0.12887378261216414,
+                0.0329836671980271,
+                0.9292868468965546,
+                0.03614466816999844,
+                0.048177199566046255,
+                0.26423952494422764,
+                0.6335478258136937,
+            };
+
+            const LMS_TO_OKLAB: [9]f32 = .{
+                0.2104542553,
+                0.7936177850,
+                -0.0040720468,
+                1.9779984951,
+                -2.4285922050,
+                0.4505937099,
+                0.0259040371,
+                0.7827717662,
+                -0.8086757660,
+            };
+
+            const cbrt = std.math.cbrt;
+
+            const xyz = _xyz.resolveMissing();
+            const a1, const b1, const c1 = multiplyMatrix(&XYZ_TO_LMS, xyz.x, xyz.y, xyz.z);
+            const l, const a, const b = multiplyMatrix(&LMS_TO_OKLAB, cbrt(a1), cbrt(b1), cbrt(c1));
+
+            return OKLAB{
+                .l = l,
+                .a = a,
+                .b = b,
+                .alpha = xyz.alpha,
+            };
+        }
+
+        pub fn intoP3(_xyz: *const XYZd65) P3 {
+            // https://github.com/w3c/csswg-drafts/blob/fba005e2ce9bcac55b49e4aa19b87208b3a0631e/css-color-4/conversions.js#L105
+            const MATRIX: [9]f32 = .{
+                2.493496911941425,
+                -0.9313836179191239,
+                -0.40271078445071684,
+                -0.8294889695615747,
+                1.7626640603183463,
+                0.023624685841943577,
+                0.03584583024378447,
+                -0.07617238926804182,
+                0.9568845240076872,
+            };
+
+            const xyz = _xyz.resolveMissing();
+            const r1, const g1, const b1 = multiplyMatrix(&MATRIX, xyz.x, xyz.y, xyz.z);
+            const r, const g, const b = gamSrgb(r1, g1, b1); // same as sRGB
+            return P3{
+                .r = r,
+                .g = g,
+                .b = b,
+                .alpha = xyz.alpha,
+            };
+        }
+    };
+
+    pub const convert_LCH = struct {
+        pub usingnamespace generated.convert_LCH;
+
+        pub fn intoCssColor(c: *const LCH, allocator: Allocator) CssColor {
+            return CssColor{ .lab = bun.create(
+                allocator,
+                LABColor,
+                LABColor{ .lch = c.* },
+            ) };
+        }
+
+        pub fn intoLAB(_lch: *const LCH) LAB {
+            const lch = _lch.resolveMissing();
+            const l, const a, const b = polarToRectangular(lch.l, lch.c, lch.h);
+            return LAB{
+                .l = l,
+                .a = a,
+                .b = b,
+                .alpha = lch.alpha,
+            };
+        }
+    };
+
+    pub const convert_OKLAB = struct {
+        pub usingnamespace generated.convert_OKLAB;
+
+        pub fn intoCssColor(c: *const OKLAB, allocator: Allocator) CssColor {
+            return CssColor{ .lab = bun.create(
+                allocator,
+                LABColor,
+                LABColor{ .oklab = c.* },
+            ) };
+        }
+
+        pub fn intoOKLAB(labb: *const OKLAB) OKLAB {
+            return labb.*;
+        }
+
+        pub fn intoOKLCH(labb: *const OKLAB) OKLCH {
+            const lab = labb.resolveMissing();
+            const l, const c, const h = rectangularToPolar(lab.l, lab.a, lab.b);
+            return OKLCH{
+                .l = l,
+                .c = c,
+                .h = h,
+                .alpha = lab.alpha,
+            };
+        }
+
+        pub fn intoXYZd65(_lab: *const OKLAB) XYZd65 {
+            // https://github.com/w3c/csswg-drafts/blob/fba005e2ce9bcac55b49e4aa19b87208b3a0631e/css-color-4/conversions.js#L418
+            const LMS_TO_XYZ: [9]f32 = .{
+                1.2268798733741557,
+                -0.5578149965554813,
+                0.28139105017721583,
+                -0.04057576262431372,
+                1.1122868293970594,
+                -0.07171106666151701,
+                -0.07637294974672142,
+                -0.4214933239627914,
+                1.5869240244272418,
+            };
+
+            const OKLAB_TO_LMS: [9]f32 = .{
+                0.99999999845051981432,
+                0.39633779217376785678,
+                0.21580375806075880339,
+                1.0000000088817607767,
+                -0.1055613423236563494,
+                -0.063854174771705903402,
+                1.0000000546724109177,
+                -0.089484182094965759684,
+                -1.2914855378640917399,
+            };
+
+            const lab = _lab.resolveMissing();
+            const a, const b, const c = multiplyMatrix(&OKLAB_TO_LMS, lab.l, lab.a, lab.b);
+            const x, const y, const z = multiplyMatrix(
+                &LMS_TO_XYZ,
+                bun.powf(a, 3),
+                bun.powf(b, 3),
+                bun.powf(c, 3),
+            );
+
+            return XYZd65{
+                .x = x,
+                .y = y,
+                .z = z,
+                .alpha = lab.alpha,
+            };
+        }
+    };
+
+    pub const convert_OKLCH = struct {
+        pub usingnamespace generated.convert_OKLCH;
+
+        pub fn intoCssColor(c: *const OKLCH, allocator: Allocator) CssColor {
+            return CssColor{ .lab = bun.create(
+                allocator,
+                LABColor,
+                LABColor{ .oklch = c.* },
+            ) };
+        }
+
+        pub fn intoOKLAB(_lch: *const OKLCH) OKLAB {
+            const lch = _lch.resolveMissing();
+            const l, const a, const b = polarToRectangular(lch.l, lch.c, lch.h);
+            return OKLAB{
+                .l = l,
+                .a = a,
+                .b = b,
+                .alpha = lch.alpha,
+            };
+        }
+
+        pub fn intoOKLCH(x: *const OKLCH) OKLCH {
+            return x.*;
+        }
+    };
+};
diff --git a/src/css/values/color_generated.zig b/src/css/values/color_generated.zig
new file mode 100644
index 0000000000..a767990f1f
--- /dev/null
+++ b/src/css/values/color_generated.zig
@@ -0,0 +1,945 @@
+//!This file is generated by `color_via.ts`. Do not edit it directly!
+const color = @import("./color.zig");
+const RGBA = color.RGBA;
+const LAB = color.LAB;
+const LCH = color.LCH;
+const SRGB = color.SRGB;
+const HSL = color.HSL;
+const HWB = color.HWB;
+const SRGBLinear = color.SRGBLinear;
+const P3 = color.P3;
+const A98 = color.A98;
+const ProPhoto = color.ProPhoto;
+const XYZd50 = color.XYZd50;
+const XYZd65 = color.XYZd65;
+const OKLAB = color.OKLAB;
+const OKLCH = color.OKLCH;
+const Rec2020 = color.Rec2020;
+
+pub const generated_color_conversions = struct {
+    pub const convert_RGBA = struct {
+        pub fn intoLAB(this: *const RGBA) LAB {
+            const xyz: SRGB = this.intoSRGB();
+            return xyz.intoLAB();
+        }
+
+        pub fn intoLCH(this: *const RGBA) LCH {
+            const xyz: SRGB = this.intoSRGB();
+            return xyz.intoLCH();
+        }
+
+        pub fn intoOKLAB(this: *const RGBA) OKLAB {
+            const xyz: SRGB = this.intoSRGB();
+            return xyz.intoOKLAB();
+        }
+
+        pub fn intoOKLCH(this: *const RGBA) OKLCH {
+            const xyz: SRGB = this.intoSRGB();
+            return xyz.intoOKLCH();
+        }
+
+        pub fn intoP3(this: *const RGBA) P3 {
+            const xyz: SRGB = this.intoSRGB();
+            return xyz.intoP3();
+        }
+
+        pub fn intoSRGBLinear(this: *const RGBA) SRGBLinear {
+            const xyz: SRGB = this.intoSRGB();
+            return xyz.intoSRGBLinear();
+        }
+
+        pub fn intoA98(this: *const RGBA) A98 {
+            const xyz: SRGB = this.intoSRGB();
+            return xyz.intoA98();
+        }
+
+        pub fn intoProPhoto(this: *const RGBA) ProPhoto {
+            const xyz: SRGB = this.intoSRGB();
+            return xyz.intoProPhoto();
+        }
+
+        pub fn intoXYZd50(this: *const RGBA) XYZd50 {
+            const xyz: SRGB = this.intoSRGB();
+            return xyz.intoXYZd50();
+        }
+
+        pub fn intoXYZd65(this: *const RGBA) XYZd65 {
+            const xyz: SRGB = this.intoSRGB();
+            return xyz.intoXYZd65();
+        }
+
+        pub fn intoRec2020(this: *const RGBA) Rec2020 {
+            const xyz: SRGB = this.intoSRGB();
+            return xyz.intoRec2020();
+        }
+
+        pub fn intoHSL(this: *const RGBA) HSL {
+            const xyz: SRGB = this.intoSRGB();
+            return xyz.intoHSL();
+        }
+
+        pub fn intoHWB(this: *const RGBA) HWB {
+            const xyz: SRGB = this.intoSRGB();
+            return xyz.intoHWB();
+        }
+    };
+    pub const convert_LAB = struct {
+        pub fn intoXYZd65(this: *const LAB) XYZd65 {
+            const xyz: XYZd50 = this.intoXYZd50();
+            return xyz.intoXYZd65();
+        }
+
+        pub fn intoOKLAB(this: *const LAB) OKLAB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoOKLAB();
+        }
+
+        pub fn intoOKLCH(this: *const LAB) OKLCH {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoOKLCH();
+        }
+
+        pub fn intoSRGB(this: *const LAB) SRGB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoSRGB();
+        }
+
+        pub fn intoSRGBLinear(this: *const LAB) SRGBLinear {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoSRGBLinear();
+        }
+
+        pub fn intoP3(this: *const LAB) P3 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoP3();
+        }
+
+        pub fn intoA98(this: *const LAB) A98 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoA98();
+        }
+
+        pub fn intoProPhoto(this: *const LAB) ProPhoto {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoProPhoto();
+        }
+
+        pub fn intoRec2020(this: *const LAB) Rec2020 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoRec2020();
+        }
+
+        pub fn intoHSL(this: *const LAB) HSL {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoHSL();
+        }
+
+        pub fn intoHWB(this: *const LAB) HWB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoHWB();
+        }
+
+        pub fn intoRGBA(this: *const LAB) RGBA {
+            const xyz: SRGB = this.intoSRGB();
+            return xyz.intoRGBA();
+        }
+    };
+    pub const convert_SRGB = struct {
+        pub fn intoLAB(this: *const SRGB) LAB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoLAB();
+        }
+
+        pub fn intoLCH(this: *const SRGB) LCH {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoLCH();
+        }
+
+        pub fn intoXYZd65(this: *const SRGB) XYZd65 {
+            const xyz: SRGBLinear = this.intoSRGBLinear();
+            return xyz.intoXYZd65();
+        }
+
+        pub fn intoOKLAB(this: *const SRGB) OKLAB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoOKLAB();
+        }
+
+        pub fn intoOKLCH(this: *const SRGB) OKLCH {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoOKLCH();
+        }
+
+        pub fn intoP3(this: *const SRGB) P3 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoP3();
+        }
+
+        pub fn intoA98(this: *const SRGB) A98 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoA98();
+        }
+
+        pub fn intoProPhoto(this: *const SRGB) ProPhoto {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoProPhoto();
+        }
+
+        pub fn intoRec2020(this: *const SRGB) Rec2020 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoRec2020();
+        }
+
+        pub fn intoXYZd50(this: *const SRGB) XYZd50 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoXYZd50();
+        }
+    };
+    pub const convert_HSL = struct {
+        pub fn intoLAB(this: *const HSL) LAB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoLAB();
+        }
+
+        pub fn intoLCH(this: *const HSL) LCH {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoLCH();
+        }
+
+        pub fn intoP3(this: *const HSL) P3 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoP3();
+        }
+
+        pub fn intoSRGBLinear(this: *const HSL) SRGBLinear {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoSRGBLinear();
+        }
+
+        pub fn intoA98(this: *const HSL) A98 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoA98();
+        }
+
+        pub fn intoProPhoto(this: *const HSL) ProPhoto {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoProPhoto();
+        }
+
+        pub fn intoXYZd50(this: *const HSL) XYZd50 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoXYZd50();
+        }
+
+        pub fn intoRec2020(this: *const HSL) Rec2020 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoRec2020();
+        }
+
+        pub fn intoOKLAB(this: *const HSL) OKLAB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoOKLAB();
+        }
+
+        pub fn intoOKLCH(this: *const HSL) OKLCH {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoOKLCH();
+        }
+
+        pub fn intoXYZd65(this: *const HSL) XYZd65 {
+            const xyz: SRGB = this.intoSRGB();
+            return xyz.intoXYZd65();
+        }
+
+        pub fn intoHWB(this: *const HSL) HWB {
+            const xyz: SRGB = this.intoSRGB();
+            return xyz.intoHWB();
+        }
+
+        pub fn intoRGBA(this: *const HSL) RGBA {
+            const xyz: SRGB = this.intoSRGB();
+            return xyz.intoRGBA();
+        }
+    };
+    pub const convert_HWB = struct {
+        pub fn intoLAB(this: *const HWB) LAB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoLAB();
+        }
+
+        pub fn intoLCH(this: *const HWB) LCH {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoLCH();
+        }
+
+        pub fn intoP3(this: *const HWB) P3 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoP3();
+        }
+
+        pub fn intoSRGBLinear(this: *const HWB) SRGBLinear {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoSRGBLinear();
+        }
+
+        pub fn intoA98(this: *const HWB) A98 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoA98();
+        }
+
+        pub fn intoProPhoto(this: *const HWB) ProPhoto {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoProPhoto();
+        }
+
+        pub fn intoXYZd50(this: *const HWB) XYZd50 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoXYZd50();
+        }
+
+        pub fn intoRec2020(this: *const HWB) Rec2020 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoRec2020();
+        }
+
+        pub fn intoHSL(this: *const HWB) HSL {
+            const xyz: SRGB = this.intoSRGB();
+            return xyz.intoHSL();
+        }
+
+        pub fn intoXYZd65(this: *const HWB) XYZd65 {
+            const xyz: SRGB = this.intoSRGB();
+            return xyz.intoXYZd65();
+        }
+
+        pub fn intoOKLAB(this: *const HWB) OKLAB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoOKLAB();
+        }
+
+        pub fn intoOKLCH(this: *const HWB) OKLCH {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoOKLCH();
+        }
+
+        pub fn intoRGBA(this: *const HWB) RGBA {
+            const xyz: SRGB = this.intoSRGB();
+            return xyz.intoRGBA();
+        }
+    };
+    pub const convert_SRGBLinear = struct {
+        pub fn intoLAB(this: *const SRGBLinear) LAB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoLAB();
+        }
+
+        pub fn intoLCH(this: *const SRGBLinear) LCH {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoLCH();
+        }
+
+        pub fn intoP3(this: *const SRGBLinear) P3 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoP3();
+        }
+
+        pub fn intoOKLAB(this: *const SRGBLinear) OKLAB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoOKLAB();
+        }
+
+        pub fn intoOKLCH(this: *const SRGBLinear) OKLCH {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoOKLCH();
+        }
+
+        pub fn intoA98(this: *const SRGBLinear) A98 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoA98();
+        }
+
+        pub fn intoProPhoto(this: *const SRGBLinear) ProPhoto {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoProPhoto();
+        }
+
+        pub fn intoRec2020(this: *const SRGBLinear) Rec2020 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoRec2020();
+        }
+
+        pub fn intoXYZd50(this: *const SRGBLinear) XYZd50 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoXYZd50();
+        }
+
+        pub fn intoHSL(this: *const SRGBLinear) HSL {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoHSL();
+        }
+
+        pub fn intoHWB(this: *const SRGBLinear) HWB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoHWB();
+        }
+
+        pub fn intoRGBA(this: *const SRGBLinear) RGBA {
+            const xyz: SRGB = this.intoSRGB();
+            return xyz.intoRGBA();
+        }
+    };
+    pub const convert_P3 = struct {
+        pub fn intoLAB(this: *const P3) LAB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoLAB();
+        }
+
+        pub fn intoLCH(this: *const P3) LCH {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoLCH();
+        }
+
+        pub fn intoSRGB(this: *const P3) SRGB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoSRGB();
+        }
+
+        pub fn intoSRGBLinear(this: *const P3) SRGBLinear {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoSRGBLinear();
+        }
+
+        pub fn intoOKLAB(this: *const P3) OKLAB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoOKLAB();
+        }
+
+        pub fn intoOKLCH(this: *const P3) OKLCH {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoOKLCH();
+        }
+
+        pub fn intoA98(this: *const P3) A98 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoA98();
+        }
+
+        pub fn intoProPhoto(this: *const P3) ProPhoto {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoProPhoto();
+        }
+
+        pub fn intoRec2020(this: *const P3) Rec2020 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoRec2020();
+        }
+
+        pub fn intoXYZd50(this: *const P3) XYZd50 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoXYZd50();
+        }
+
+        pub fn intoHSL(this: *const P3) HSL {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoHSL();
+        }
+
+        pub fn intoHWB(this: *const P3) HWB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoHWB();
+        }
+
+        pub fn intoRGBA(this: *const P3) RGBA {
+            const xyz: SRGB = this.intoSRGB();
+            return xyz.intoRGBA();
+        }
+    };
+    pub const convert_A98 = struct {
+        pub fn intoLAB(this: *const A98) LAB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoLAB();
+        }
+
+        pub fn intoLCH(this: *const A98) LCH {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoLCH();
+        }
+
+        pub fn intoSRGB(this: *const A98) SRGB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoSRGB();
+        }
+
+        pub fn intoP3(this: *const A98) P3 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoP3();
+        }
+
+        pub fn intoSRGBLinear(this: *const A98) SRGBLinear {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoSRGBLinear();
+        }
+
+        pub fn intoOKLAB(this: *const A98) OKLAB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoOKLAB();
+        }
+
+        pub fn intoOKLCH(this: *const A98) OKLCH {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoOKLCH();
+        }
+
+        pub fn intoProPhoto(this: *const A98) ProPhoto {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoProPhoto();
+        }
+
+        pub fn intoRec2020(this: *const A98) Rec2020 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoRec2020();
+        }
+
+        pub fn intoXYZd50(this: *const A98) XYZd50 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoXYZd50();
+        }
+
+        pub fn intoHSL(this: *const A98) HSL {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoHSL();
+        }
+
+        pub fn intoHWB(this: *const A98) HWB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoHWB();
+        }
+
+        pub fn intoRGBA(this: *const A98) RGBA {
+            const xyz: SRGB = this.intoSRGB();
+            return xyz.intoRGBA();
+        }
+    };
+    pub const convert_ProPhoto = struct {
+        pub fn intoXYZd65(this: *const ProPhoto) XYZd65 {
+            const xyz: XYZd50 = this.intoXYZd50();
+            return xyz.intoXYZd65();
+        }
+
+        pub fn intoLAB(this: *const ProPhoto) LAB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoLAB();
+        }
+
+        pub fn intoLCH(this: *const ProPhoto) LCH {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoLCH();
+        }
+
+        pub fn intoSRGB(this: *const ProPhoto) SRGB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoSRGB();
+        }
+
+        pub fn intoP3(this: *const ProPhoto) P3 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoP3();
+        }
+
+        pub fn intoSRGBLinear(this: *const ProPhoto) SRGBLinear {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoSRGBLinear();
+        }
+
+        pub fn intoA98(this: *const ProPhoto) A98 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoA98();
+        }
+
+        pub fn intoOKLAB(this: *const ProPhoto) OKLAB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoOKLAB();
+        }
+
+        pub fn intoOKLCH(this: *const ProPhoto) OKLCH {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoOKLCH();
+        }
+
+        pub fn intoRec2020(this: *const ProPhoto) Rec2020 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoRec2020();
+        }
+
+        pub fn intoHSL(this: *const ProPhoto) HSL {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoHSL();
+        }
+
+        pub fn intoHWB(this: *const ProPhoto) HWB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoHWB();
+        }
+
+        pub fn intoRGBA(this: *const ProPhoto) RGBA {
+            const xyz: SRGB = this.intoSRGB();
+            return xyz.intoRGBA();
+        }
+    };
+    pub const convert_Rec2020 = struct {
+        pub fn intoLAB(this: *const Rec2020) LAB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoLAB();
+        }
+
+        pub fn intoLCH(this: *const Rec2020) LCH {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoLCH();
+        }
+
+        pub fn intoSRGB(this: *const Rec2020) SRGB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoSRGB();
+        }
+
+        pub fn intoP3(this: *const Rec2020) P3 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoP3();
+        }
+
+        pub fn intoSRGBLinear(this: *const Rec2020) SRGBLinear {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoSRGBLinear();
+        }
+
+        pub fn intoA98(this: *const Rec2020) A98 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoA98();
+        }
+
+        pub fn intoProPhoto(this: *const Rec2020) ProPhoto {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoProPhoto();
+        }
+
+        pub fn intoXYZd50(this: *const Rec2020) XYZd50 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoXYZd50();
+        }
+
+        pub fn intoOKLAB(this: *const Rec2020) OKLAB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoOKLAB();
+        }
+
+        pub fn intoOKLCH(this: *const Rec2020) OKLCH {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoOKLCH();
+        }
+
+        pub fn intoHSL(this: *const Rec2020) HSL {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoHSL();
+        }
+
+        pub fn intoHWB(this: *const Rec2020) HWB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoHWB();
+        }
+
+        pub fn intoRGBA(this: *const Rec2020) RGBA {
+            const xyz: SRGB = this.intoSRGB();
+            return xyz.intoRGBA();
+        }
+    };
+    pub const convert_XYZd50 = struct {
+        pub fn intoLCH(this: *const XYZd50) LCH {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoLCH();
+        }
+
+        pub fn intoSRGB(this: *const XYZd50) SRGB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoSRGB();
+        }
+
+        pub fn intoP3(this: *const XYZd50) P3 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoP3();
+        }
+
+        pub fn intoSRGBLinear(this: *const XYZd50) SRGBLinear {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoSRGBLinear();
+        }
+
+        pub fn intoA98(this: *const XYZd50) A98 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoA98();
+        }
+
+        pub fn intoOKLAB(this: *const XYZd50) OKLAB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoOKLAB();
+        }
+
+        pub fn intoOKLCH(this: *const XYZd50) OKLCH {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoOKLCH();
+        }
+
+        pub fn intoRec2020(this: *const XYZd50) Rec2020 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoRec2020();
+        }
+
+        pub fn intoHSL(this: *const XYZd50) HSL {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoHSL();
+        }
+
+        pub fn intoHWB(this: *const XYZd50) HWB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoHWB();
+        }
+
+        pub fn intoRGBA(this: *const XYZd50) RGBA {
+            const xyz: SRGB = this.intoSRGB();
+            return xyz.intoRGBA();
+        }
+    };
+    pub const convert_XYZd65 = struct {
+        pub fn intoLAB(this: *const XYZd65) LAB {
+            const xyz: XYZd50 = this.intoXYZd50();
+            return xyz.intoLAB();
+        }
+
+        pub fn intoProPhoto(this: *const XYZd65) ProPhoto {
+            const xyz: XYZd50 = this.intoXYZd50();
+            return xyz.intoProPhoto();
+        }
+
+        pub fn intoOKLCH(this: *const XYZd65) OKLCH {
+            const xyz: OKLAB = this.intoOKLAB();
+            return xyz.intoOKLCH();
+        }
+
+        pub fn intoLCH(this: *const XYZd65) LCH {
+            const xyz: LAB = this.intoLAB();
+            return xyz.intoLCH();
+        }
+
+        pub fn intoSRGB(this: *const XYZd65) SRGB {
+            const xyz: SRGBLinear = this.intoSRGBLinear();
+            return xyz.intoSRGB();
+        }
+
+        pub fn intoHSL(this: *const XYZd65) HSL {
+            const xyz: SRGB = this.intoSRGB();
+            return xyz.intoHSL();
+        }
+
+        pub fn intoHWB(this: *const XYZd65) HWB {
+            const xyz: SRGB = this.intoSRGB();
+            return xyz.intoHWB();
+        }
+
+        pub fn intoRGBA(this: *const XYZd65) RGBA {
+            const xyz: SRGB = this.intoSRGB();
+            return xyz.intoRGBA();
+        }
+    };
+    pub const convert_LCH = struct {
+        pub fn intoXYZd65(this: *const LCH) XYZd65 {
+            const xyz: LAB = this.intoLAB();
+            return xyz.intoXYZd65();
+        }
+
+        pub fn intoOKLAB(this: *const LCH) OKLAB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoOKLAB();
+        }
+
+        pub fn intoOKLCH(this: *const LCH) OKLCH {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoOKLCH();
+        }
+
+        pub fn intoSRGB(this: *const LCH) SRGB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoSRGB();
+        }
+
+        pub fn intoSRGBLinear(this: *const LCH) SRGBLinear {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoSRGBLinear();
+        }
+
+        pub fn intoP3(this: *const LCH) P3 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoP3();
+        }
+
+        pub fn intoA98(this: *const LCH) A98 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoA98();
+        }
+
+        pub fn intoProPhoto(this: *const LCH) ProPhoto {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoProPhoto();
+        }
+
+        pub fn intoRec2020(this: *const LCH) Rec2020 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoRec2020();
+        }
+
+        pub fn intoXYZd50(this: *const LCH) XYZd50 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoXYZd50();
+        }
+
+        pub fn intoHSL(this: *const LCH) HSL {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoHSL();
+        }
+
+        pub fn intoHWB(this: *const LCH) HWB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoHWB();
+        }
+
+        pub fn intoRGBA(this: *const LCH) RGBA {
+            const xyz: SRGB = this.intoSRGB();
+            return xyz.intoRGBA();
+        }
+    };
+    pub const convert_OKLAB = struct {
+        pub fn intoLAB(this: *const OKLAB) LAB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoLAB();
+        }
+
+        pub fn intoLCH(this: *const OKLAB) LCH {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoLCH();
+        }
+
+        pub fn intoSRGB(this: *const OKLAB) SRGB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoSRGB();
+        }
+
+        pub fn intoP3(this: *const OKLAB) P3 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoP3();
+        }
+
+        pub fn intoSRGBLinear(this: *const OKLAB) SRGBLinear {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoSRGBLinear();
+        }
+
+        pub fn intoA98(this: *const OKLAB) A98 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoA98();
+        }
+
+        pub fn intoProPhoto(this: *const OKLAB) ProPhoto {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoProPhoto();
+        }
+
+        pub fn intoXYZd50(this: *const OKLAB) XYZd50 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoXYZd50();
+        }
+
+        pub fn intoRec2020(this: *const OKLAB) Rec2020 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoRec2020();
+        }
+
+        pub fn intoHSL(this: *const OKLAB) HSL {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoHSL();
+        }
+
+        pub fn intoHWB(this: *const OKLAB) HWB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoHWB();
+        }
+
+        pub fn intoRGBA(this: *const OKLAB) RGBA {
+            const xyz: SRGB = this.intoSRGB();
+            return xyz.intoRGBA();
+        }
+    };
+    pub const convert_OKLCH = struct {
+        pub fn intoXYZd65(this: *const OKLCH) XYZd65 {
+            const xyz: OKLAB = this.intoOKLAB();
+            return xyz.intoXYZd65();
+        }
+
+        pub fn intoLAB(this: *const OKLCH) LAB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoLAB();
+        }
+
+        pub fn intoLCH(this: *const OKLCH) LCH {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoLCH();
+        }
+
+        pub fn intoSRGB(this: *const OKLCH) SRGB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoSRGB();
+        }
+
+        pub fn intoP3(this: *const OKLCH) P3 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoP3();
+        }
+
+        pub fn intoSRGBLinear(this: *const OKLCH) SRGBLinear {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoSRGBLinear();
+        }
+
+        pub fn intoA98(this: *const OKLCH) A98 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoA98();
+        }
+
+        pub fn intoProPhoto(this: *const OKLCH) ProPhoto {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoProPhoto();
+        }
+
+        pub fn intoXYZd50(this: *const OKLCH) XYZd50 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoXYZd50();
+        }
+
+        pub fn intoRec2020(this: *const OKLCH) Rec2020 {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoRec2020();
+        }
+
+        pub fn intoHSL(this: *const OKLCH) HSL {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoHSL();
+        }
+
+        pub fn intoHWB(this: *const OKLCH) HWB {
+            const xyz: XYZd65 = this.intoXYZd65();
+            return xyz.intoHWB();
+        }
+
+        pub fn intoRGBA(this: *const OKLCH) RGBA {
+            const xyz: SRGB = this.intoSRGB();
+            return xyz.intoRGBA();
+        }
+    };
+};
diff --git a/src/css/values/color_js.zig b/src/css/values/color_js.zig
new file mode 100644
index 0000000000..052d92ed70
--- /dev/null
+++ b/src/css/values/color_js.zig
@@ -0,0 +1,441 @@
+const bun = @import("root").bun;
+const std = @import("std");
+const color = @import("./color.zig");
+const RGBA = color.RGBA;
+const LAB = color.LAB;
+const LCH = color.LCH;
+const SRGB = color.SRGB;
+const HSL = color.HSL;
+const HWB = color.HWB;
+const SRGBLinear = color.SRGBLinear;
+const P3 = color.P3;
+const JSC = bun.JSC;
+const css = bun.css;
+
+const OutputColorFormat = enum {
+    ansi,
+    ansi_16,
+    ansi_16m,
+    ansi_256,
+    css,
+    hex,
+    HEX,
+    hsl,
+    lab,
+    number,
+    rgb,
+    rgba,
+    @"[rgb]",
+    @"[rgba]",
+    @"{rgb}",
+    @"{rgba}",
+
+    pub const Map = bun.ComptimeStringMap(OutputColorFormat, .{
+        .{ "[r,g,b,a]", .@"[rgba]" },
+        .{ "[rgb]", .@"[rgb]" },
+        .{ "[rgba]", .@"[rgba]" },
+        .{ "{r,g,b}", .@"{rgb}" },
+        .{ "{rgb}", .@"{rgb}" },
+        .{ "{rgba}", .@"{rgba}" },
+        .{ "ansi_256", .ansi_256 },
+        .{ "ansi-256", .ansi_256 },
+        .{ "ansi_16", .ansi_16 },
+        .{ "ansi-16", .ansi_16 },
+        .{ "ansi_16m", .ansi_16m },
+        .{ "ansi-16m", .ansi_16m },
+        .{ "ansi-24bit", .ansi_16m },
+        .{ "ansi-truecolor", .ansi_16m },
+        .{ "ansi", .ansi },
+        .{ "ansi256", .ansi_256 },
+        .{ "css", .css },
+        .{ "hex", .hex },
+        .{ "HEX", .HEX },
+        .{ "hsl", .hsl },
+        .{ "lab", .lab },
+        .{ "number", .number },
+        .{ "rgb", .rgb },
+        .{ "rgba", .rgba },
+    });
+};
+
+fn colorIntFromJS(globalThis: *JSC.JSGlobalObject, input: JSC.JSValue, comptime property: []const u8) bun.JSError!i32 {
+    if (input == .zero or input == .undefined or !input.isNumber()) {
+        return globalThis.throwInvalidArgumentType("color", property, "integer");
+    }
+
+    // CSS spec says to clamp values to their valid range so we'll respect that here
+    return std.math.clamp(input.coerce(i32, globalThis), 0, 255);
+}
+
+// https://github.com/tmux/tmux/blob/dae2868d1227b95fd076fb4a5efa6256c7245943/colour.c#L44-L55
+pub const Ansi256 = struct {
+    const q2c = [_]u32{ 0x00, 0x5f, 0x87, 0xaf, 0xd7, 0xff };
+
+    fn sqdist(R: u32, G: u32, B: u32, r: u32, g: u32, b: u32) u32 {
+        return ((R -% r) *% (R -% r) +% (G -% g) *% (G -% g) +% (B -% b) *% (B -% b));
+    }
+
+    fn to6Cube(v: u32) u32 {
+        if (v < 48)
+            return (0);
+        if (v < 114)
+            return (1);
+        return ((v - 35) / 40);
+    }
+
+    fn get(r: u32, g: u32, b: u32) u32 {
+        const qr = to6Cube(r);
+        const cr = q2c[@intCast(qr)];
+        const qg = to6Cube(g);
+        const cg = q2c[@intCast(qg)];
+        const qb = to6Cube(b);
+        const cb = q2c[@intCast(qb)];
+
+        if (cr == r and cg == g and cb == b) {
+            return 16 +% (36 *% qr) +% (6 *% qg) +% qb;
+        }
+
+        const grey_avg = (r +% g +% b) / 3;
+        const grey_idx = if (grey_avg > 238) 23 else (grey_avg -% 3) / 10;
+        const grey = 8 +% (10 *% grey_idx);
+
+        const d = sqdist(cr, cg, cb, r, g, b);
+        const idx = if (sqdist(grey, grey, grey, r, g, b) < d) 232 +% grey_idx else 16 +% (36 *% qr) +% (6 *% qg) +% qb;
+        return idx;
+    }
+
+    const table_256: [256]u8 = .{
+        0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
+        0,  4,  4,  4,  12, 12, 2,  6,  4,  4,  12, 12, 2,  2,  6,  4,
+        12, 12, 2,  2,  2,  6,  12, 12, 10, 10, 10, 10, 14, 12, 10, 10,
+        10, 10, 10, 14, 1,  5,  4,  4,  12, 12, 3,  8,  4,  4,  12, 12,
+        2,  2,  6,  4,  12, 12, 2,  2,  2,  6,  12, 12, 10, 10, 10, 10,
+        14, 12, 10, 10, 10, 10, 10, 14, 1,  1,  5,  4,  12, 12, 1,  1,
+        5,  4,  12, 12, 3,  3,  8,  4,  12, 12, 2,  2,  2,  6,  12, 12,
+        10, 10, 10, 10, 14, 12, 10, 10, 10, 10, 10, 14, 1,  1,  1,  5,
+        12, 12, 1,  1,  1,  5,  12, 12, 1,  1,  1,  5,  12, 12, 3,  3,
+        3,  7,  12, 12, 10, 10, 10, 10, 14, 12, 10, 10, 10, 10, 10, 14,
+        9,  9,  9,  9,  13, 12, 9,  9,  9,  9,  13, 12, 9,  9,  9,  9,
+        13, 12, 9,  9,  9,  9,  13, 12, 11, 11, 11, 11, 7,  12, 10, 10,
+        10, 10, 10, 14, 9,  9,  9,  9,  9,  13, 9,  9,  9,  9,  9,  13,
+        9,  9,  9,  9,  9,  13, 9,  9,  9,  9,  9,  13, 9,  9,  9,  9,
+        9,  13, 11, 11, 11, 11, 11, 15, 0,  0,  0,  0,  0,  0,  8,  8,
+        8,  8,  8,  8,  7,  7,  7,  7,  7,  7,  15, 15, 15, 15, 15, 15,
+    };
+
+    pub fn get16(r: u32, g: u32, b: u32) u8 {
+        const val = get(r, g, b);
+        return table_256[val & 0xff];
+    }
+
+    pub const Buffer = [24]u8;
+
+    pub fn from(rgba: RGBA, buf: *Buffer) []u8 {
+        const val = get(rgba.red, rgba.green, rgba.blue);
+        // 0x1b is the escape character
+        buf[0] = 0x1b;
+        buf[1] = '[';
+        buf[2] = '3';
+        buf[3] = '8';
+        buf[4] = ';';
+        buf[5] = '5';
+        buf[6] = ';';
+        const extra = std.fmt.bufPrint(buf[7..], "{d}m", .{val}) catch unreachable;
+        return buf[0 .. 7 + extra.len];
+    }
+};
+
+pub fn jsFunctionColor(globalThis: *JSC.JSGlobalObject, callFrame: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+    const args = callFrame.argumentsAsArray(2);
+    if (args[0].isUndefined()) {
+        return globalThis.throwInvalidArgumentType("color", "input", "string, number, or object");
+    }
+
+    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 log = bun.logger.Log.init(allocator);
+    defer log.deinit();
+
+    const unresolved_format: OutputColorFormat = brk: {
+        if (!args[1].isEmptyOrUndefinedOrNull()) {
+            if (!args[1].isString()) {
+                return globalThis.throwInvalidArgumentType("color", "format", "string");
+            }
+
+            break :brk try args[1].toEnum(globalThis, "format", OutputColorFormat);
+        }
+
+        break :brk OutputColorFormat.css;
+    };
+    var input = JSC.ZigString.Slice.empty;
+    defer input.deinit();
+
+    var parsed_color: css.CssColor.ParseResult = brk: {
+        if (args[0].isNumber()) {
+            const number: i64 = args[0].toInt64();
+            const Packed = packed struct(u32) {
+                blue: u8,
+                green: u8,
+                red: u8,
+                alpha: u8,
+            };
+            const int: u32 = @truncate(@abs(@mod(number, std.math.maxInt(u32))));
+            const rgba: Packed = @bitCast(int);
+
+            break :brk .{ .result = css.CssColor{ .rgba = .{ .alpha = rgba.alpha, .red = rgba.red, .green = rgba.green, .blue = rgba.blue } } };
+        } else if (args[0].jsType().isArrayLike()) {
+            switch (args[0].getLength(globalThis)) {
+                3 => {
+                    const r = try colorIntFromJS(globalThis, args[0].getIndex(globalThis, 0), "[0]");
+                    const g = try colorIntFromJS(globalThis, args[0].getIndex(globalThis, 1), "[1]");
+                    const b = try colorIntFromJS(globalThis, args[0].getIndex(globalThis, 2), "[2]");
+                    break :brk .{ .result = css.CssColor{ .rgba = .{ .alpha = 255, .red = @intCast(r), .green = @intCast(g), .blue = @intCast(b) } } };
+                },
+                4 => {
+                    const r = try colorIntFromJS(globalThis, args[0].getIndex(globalThis, 0), "[0]");
+                    const g = try colorIntFromJS(globalThis, args[0].getIndex(globalThis, 1), "[1]");
+                    const b = try colorIntFromJS(globalThis, args[0].getIndex(globalThis, 2), "[2]");
+                    const a = try colorIntFromJS(globalThis, args[0].getIndex(globalThis, 3), "[3]");
+                    break :brk .{ .result = css.CssColor{ .rgba = .{ .alpha = @intCast(a), .red = @intCast(r), .green = @intCast(g), .blue = @intCast(b) } } };
+                },
+                else => {
+                    return globalThis.throw("Expected array length 3 or 4", .{});
+                },
+            }
+        } else if (args[0].isObject()) {
+            const r = try colorIntFromJS(globalThis, try args[0].get(globalThis, "r") orelse .zero, "r");
+            const g = try colorIntFromJS(globalThis, try args[0].get(globalThis, "g") orelse .zero, "g");
+            const b = try colorIntFromJS(globalThis, try args[0].get(globalThis, "b") orelse .zero, "b");
+
+            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));
+                }
+                break :brk2 null;
+            } else null;
+            if (globalThis.hasException()) {
+                return .zero;
+            }
+
+            break :brk .{
+                .result = css.CssColor{
+                    .rgba = .{
+                        .alpha = if (a != null) @intCast(a.?) else 255,
+                        .red = @intCast(r),
+                        .green = @intCast(g),
+                        .blue = @intCast(b),
+                    },
+                },
+            };
+        }
+
+        input = args[0].toSlice(globalThis, bun.default_allocator);
+
+        var parser_input = css.ParserInput.new(allocator, input.slice());
+        var parser = css.Parser.new(&parser_input, null);
+        break :brk css.CssColor.parse(&parser);
+    };
+
+    switch (parsed_color) {
+        .err => |err| {
+            if (log.msgs.items.len == 0) {
+                return .null;
+            }
+
+            return globalThis.throw("color() failed to parse {s}", .{@tagName(err.basic().kind)});
+        },
+        .result => |*result| {
+            const format: OutputColorFormat = if (unresolved_format == .ansi) switch (bun.Output.Source.colorDepth()) {
+                // No color terminal, therefore return an empty string
+                .none => return JSC.JSValue.jsEmptyString(globalThis),
+                .@"16" => .ansi_16,
+                .@"16m" => .ansi_16m,
+                .@"256" => .ansi_256,
+            } else unresolved_format;
+
+            formatted: {
+                var str = color: {
+                    switch (format) {
+                        // resolved above.
+                        .ansi => unreachable,
+
+                        // Use the CSS printer.
+                        .css => break :formatted,
+
+                        .number,
+                        .rgb,
+                        .rgba,
+                        .hex,
+                        .HEX,
+                        .ansi_16,
+                        .ansi_16m,
+                        .ansi_256,
+                        .@"{rgba}",
+                        .@"{rgb}",
+                        .@"[rgba]",
+                        .@"[rgb]",
+                        => |tag| {
+                            const srgba = switch (result.*) {
+                                .float => |float| switch (float.*) {
+                                    .rgb => |rgb| rgb,
+                                    inline else => |*val| val.intoSRGB(),
+                                },
+                                .rgba => |*rgba| rgba.intoSRGB(),
+                                .lab => |lab| switch (lab.*) {
+                                    inline else => |entry| entry.intoSRGB(),
+                                },
+                                else => break :formatted,
+                            };
+                            const rgba = srgba.intoRGBA();
+                            switch (tag) {
+                                .@"{rgba}" => {
+                                    const object = JSC.JSValue.createEmptyObject(globalThis, 4);
+                                    object.put(globalThis, "r", JSC.JSValue.jsNumber(rgba.red));
+                                    object.put(globalThis, "g", JSC.JSValue.jsNumber(rgba.green));
+                                    object.put(globalThis, "b", JSC.JSValue.jsNumber(rgba.blue));
+                                    object.put(globalThis, "a", JSC.JSValue.jsNumber(rgba.alphaF32()));
+                                    return object;
+                                },
+                                .@"{rgb}" => {
+                                    const object = JSC.JSValue.createEmptyObject(globalThis, 4);
+                                    object.put(globalThis, "r", JSC.JSValue.jsNumber(rgba.red));
+                                    object.put(globalThis, "g", JSC.JSValue.jsNumber(rgba.green));
+                                    object.put(globalThis, "b", JSC.JSValue.jsNumber(rgba.blue));
+                                    return object;
+                                },
+                                .@"[rgb]" => {
+                                    const object = JSC.JSValue.createEmptyArray(globalThis, 3);
+                                    object.putIndex(globalThis, 0, JSC.JSValue.jsNumber(rgba.red));
+                                    object.putIndex(globalThis, 1, JSC.JSValue.jsNumber(rgba.green));
+                                    object.putIndex(globalThis, 2, JSC.JSValue.jsNumber(rgba.blue));
+                                    return object;
+                                },
+                                .@"[rgba]" => {
+                                    const object = JSC.JSValue.createEmptyArray(globalThis, 4);
+                                    object.putIndex(globalThis, 0, JSC.JSValue.jsNumber(rgba.red));
+                                    object.putIndex(globalThis, 1, JSC.JSValue.jsNumber(rgba.green));
+                                    object.putIndex(globalThis, 2, JSC.JSValue.jsNumber(rgba.blue));
+                                    object.putIndex(globalThis, 3, JSC.JSValue.jsNumber(rgba.alpha));
+                                    return object;
+                                },
+                                .number => {
+                                    var int: u32 = 0;
+                                    int |= @as(u32, rgba.red) << 16;
+                                    int |= @as(u32, rgba.green) << 8;
+                                    int |= @as(u32, rgba.blue);
+                                    return JSC.JSValue.jsNumber(int);
+                                },
+                                .hex => {
+                                    break :color bun.String.createFormat("#{}{}{}", .{ bun.fmt.hexIntLower(rgba.red), bun.fmt.hexIntLower(rgba.green), bun.fmt.hexIntLower(rgba.blue) });
+                                },
+                                .HEX => {
+                                    break :color bun.String.createFormat("#{}{}{}", .{ bun.fmt.hexIntUpper(rgba.red), bun.fmt.hexIntUpper(rgba.green), bun.fmt.hexIntUpper(rgba.blue) });
+                                },
+                                .rgb => {
+                                    break :color bun.String.createFormat("rgb({d}, {d}, {d})", .{ rgba.red, rgba.green, rgba.blue });
+                                },
+                                .rgba => {
+                                    break :color bun.String.createFormat("rgba({d}, {d}, {d}, {d})", .{ rgba.red, rgba.green, rgba.blue, rgba.alphaF32() });
+                                },
+                                .ansi_16 => {
+                                    const ansi_16_color = Ansi256.get16(rgba.red, rgba.green, rgba.blue);
+                                    // 16-color ansi, foreground text color
+                                    break :color bun.String.createLatin1(&[_]u8{
+                                        // 0x1b is the escape character
+                                        // 38 is the foreground color code
+                                        // 5 is the 16-color mode
+                                        // {d} is the color index
+                                        0x1b, '[', '3', '8', ';', '5', ';', ansi_16_color, 'm',
+                                    });
+                                },
+                                .ansi_16m => {
+                                    // true color ansi
+                                    var buf: [48]u8 = undefined;
+                                    // 0x1b is the escape character
+                                    buf[0] = 0x1b;
+                                    buf[1] = '[';
+                                    buf[2] = '3';
+                                    buf[3] = '8';
+                                    buf[4] = ';';
+                                    buf[5] = '2';
+                                    buf[6] = ';';
+                                    const additional = std.fmt.bufPrint(buf[7..], "{d};{d};{d}m", .{
+                                        rgba.red,
+                                        rgba.green,
+                                        rgba.blue,
+                                    }) catch unreachable;
+
+                                    break :color bun.String.createLatin1(buf[0 .. 7 + additional.len]);
+                                },
+                                .ansi_256 => {
+                                    // ANSI escape sequence
+                                    var buf: Ansi256.Buffer = undefined;
+                                    const val = Ansi256.from(rgba, &buf);
+                                    break :color bun.String.createLatin1(val);
+                                },
+                                else => unreachable,
+                            }
+                        },
+
+                        .hsl => {
+                            const hsl = switch (result.*) {
+                                .float => |float| brk: {
+                                    switch (float.*) {
+                                        .hsl => |hsl| break :brk hsl,
+                                        inline else => |*val| break :brk val.intoHSL(),
+                                    }
+                                },
+                                .rgba => |*rgba| rgba.intoHSL(),
+                                .lab => |lab| switch (lab.*) {
+                                    inline else => |entry| entry.intoHSL(),
+                                },
+                                else => break :formatted,
+                            };
+
+                            break :color bun.String.createFormat("hsl({d}, {d}, {d})", .{ hsl.h, hsl.s, hsl.l });
+                        },
+                        .lab => {
+                            const lab = switch (result.*) {
+                                .float => |float| switch (float.*) {
+                                    inline else => |*val| val.intoLAB(),
+                                },
+                                .lab => |lab| switch (lab.*) {
+                                    .lab => |lab_| lab_,
+                                    inline else => |entry| entry.intoLAB(),
+                                },
+                                .rgba => |*rgba| rgba.intoLAB(),
+                                else => break :formatted,
+                            };
+
+                            break :color bun.String.createFormat("lab({d}, {d}, {d})", .{ lab.l, lab.a, lab.b });
+                        },
+                    }
+                } catch bun.outOfMemory();
+
+                return str.transferToJS(globalThis);
+            }
+
+            // Fallback to CSS string output
+            var dest = std.ArrayListUnmanaged(u8){};
+            const writer = dest.writer(allocator);
+
+            var printer = css.Printer(@TypeOf(writer)).new(
+                allocator,
+                std.ArrayList(u8).init(allocator),
+                writer,
+                .{},
+                null,
+            );
+
+            result.toCss(@TypeOf(writer), &printer) catch |err| {
+                return globalThis.throw("color() internal error: {s}", .{@errorName(err)});
+            };
+
+            var out = bun.String.createUTF8(dest.items);
+            return out.transferToJS(globalThis);
+        },
+    }
+}
diff --git a/src/css/values/color_via.ts b/src/css/values/color_via.ts
new file mode 100644
index 0000000000..fd1127c6f0
--- /dev/null
+++ b/src/css/values/color_via.ts
@@ -0,0 +1,231 @@
+const RGBA = "RGBA";
+const LAB = "LAB";
+const SRGB = "SRGB";
+const HSL = "HSL";
+const HWB = "HWB";
+const SRGBLinear = "SRGBLinear";
+const P3 = "P3";
+const A98 = "A98";
+const ProPhoto = "ProPhoto";
+const Rec2020 = "Rec2020";
+const XYZd50 = "XYZd50";
+const XYZd65 = "XYZd65";
+const LCH = "LCH";
+const OKLAB = "OKLAB";
+const OKLCH = "OKLCH";
+const color_spaces = [
+  RGBA,
+  LAB,
+  SRGB,
+  HSL,
+  HWB,
+  SRGBLinear,
+  P3,
+  A98,
+  ProPhoto,
+  Rec2020,
+  XYZd50,
+  XYZd65,
+  LCH,
+  OKLAB,
+  OKLCH,
+];
+
+type ColorSpaces =
+  | typeof RGBA
+  | typeof LAB
+  | typeof SRGB
+  | typeof HSL
+  | typeof HWB
+  | typeof SRGBLinear
+  | typeof P3
+  | typeof A98
+  | typeof ProPhoto
+  | typeof Rec2020
+  | typeof XYZd50
+  | typeof XYZd65
+  | typeof LCH
+  | typeof OKLAB
+  | typeof OKLCH;
+
+type Foo = "a" | "b";
+
+let code: Map<ColorSpaces, string[]> = new Map();
+
+initColorSpaces();
+addConversions();
+await generateCode();
+
+function initColorSpaces() {
+  for (const space of color_spaces as ColorSpaces[]) {
+    code.set(space, []);
+  }
+}
+
+async function generateCode() {
+  const output = `//!This file is generated by \`color_via.ts\`. Do not edit it directly!
+const color = @import("./color.zig");
+const RGBA = color.RGBA;
+const LAB = color.LAB;
+const LCH = color.LCH;
+const SRGB = color.SRGB;
+const HSL = color.HSL;
+const HWB = color.HWB;
+const SRGBLinear = color.SRGBLinear;
+const P3 = color.P3;
+const A98 = color.A98;
+const ProPhoto = color.ProPhoto;
+const XYZd50 = color.XYZd50;
+const XYZd65 = color.XYZd65;
+const OKLAB = color.OKLAB;
+const OKLCH = color.OKLCH;
+const Rec2020 = color.Rec2020;
+
+pub const generated_color_conversions = struct {
+${(() => {
+  let result = "";
+  for (const [space, functions] of code) {
+    result += "\n";
+    result += `pub const convert_${space} = struct {\n`;
+    result += functions.join("\n");
+    result += "\n};";
+  }
+  return result;
+})()}
+};`;
+  await Bun.$`echo ${output} > src/css/values/color_generated.zig; zig fmt src/css/values/color_generated.zig
+`;
+}
+
+function addConversions() {
+  // Once Rust specialization is stable, this could be simplified.
+  via("LAB", "XYZd50", "XYZd65");
+  via("ProPhoto", "XYZd50", "XYZd65");
+  via("OKLCH", "OKLAB", "XYZd65");
+
+  via("LAB", "XYZd65", "OKLAB");
+  via("LAB", "XYZd65", "OKLCH");
+  via("LAB", "XYZd65", "SRGB");
+  via("LAB", "XYZd65", "SRGBLinear");
+  via("LAB", "XYZd65", "P3");
+  via("LAB", "XYZd65", "A98");
+  via("LAB", "XYZd65", "ProPhoto");
+  via("LAB", "XYZd65", "Rec2020");
+  via("LAB", "XYZd65", "HSL");
+  via("LAB", "XYZd65", "HWB");
+
+  via("LCH", "LAB", "XYZd65");
+  via("LCH", "XYZd65", "OKLAB");
+  via("LCH", "XYZd65", "OKLCH");
+  via("LCH", "XYZd65", "SRGB");
+  via("LCH", "XYZd65", "SRGBLinear");
+  via("LCH", "XYZd65", "P3");
+  via("LCH", "XYZd65", "A98");
+  via("LCH", "XYZd65", "ProPhoto");
+  via("LCH", "XYZd65", "Rec2020");
+  via("LCH", "XYZd65", "XYZd50");
+  via("LCH", "XYZd65", "HSL");
+  via("LCH", "XYZd65", "HWB");
+
+  via("SRGB", "SRGBLinear", "XYZd65");
+  via("SRGB", "XYZd65", "OKLAB");
+  via("SRGB", "XYZd65", "OKLCH");
+  via("SRGB", "XYZd65", "P3");
+  via("SRGB", "XYZd65", "A98");
+  via("SRGB", "XYZd65", "ProPhoto");
+  via("SRGB", "XYZd65", "Rec2020");
+  via("SRGB", "XYZd65", "XYZd50");
+
+  via("P3", "XYZd65", "SRGBLinear");
+  via("P3", "XYZd65", "OKLAB");
+  via("P3", "XYZd65", "OKLCH");
+  via("P3", "XYZd65", "A98");
+  via("P3", "XYZd65", "ProPhoto");
+  via("P3", "XYZd65", "Rec2020");
+  via("P3", "XYZd65", "XYZd50");
+  via("P3", "XYZd65", "HSL");
+  via("P3", "XYZd65", "HWB");
+
+  via("SRGBLinear", "XYZd65", "OKLAB");
+  via("SRGBLinear", "XYZd65", "OKLCH");
+  via("SRGBLinear", "XYZd65", "A98");
+  via("SRGBLinear", "XYZd65", "ProPhoto");
+  via("SRGBLinear", "XYZd65", "Rec2020");
+  via("SRGBLinear", "XYZd65", "XYZd50");
+  via("SRGBLinear", "XYZd65", "HSL");
+  via("SRGBLinear", "XYZd65", "HWB");
+
+  via("A98", "XYZd65", "OKLAB");
+  via("A98", "XYZd65", "OKLCH");
+  via("A98", "XYZd65", "ProPhoto");
+  via("A98", "XYZd65", "Rec2020");
+  via("A98", "XYZd65", "XYZd50");
+  via("A98", "XYZd65", "HSL");
+  via("A98", "XYZd65", "HWB");
+
+  via("ProPhoto", "XYZd65", "OKLAB");
+  via("ProPhoto", "XYZd65", "OKLCH");
+  via("ProPhoto", "XYZd65", "Rec2020");
+  via("ProPhoto", "XYZd65", "HSL");
+  via("ProPhoto", "XYZd65", "HWB");
+
+  via("XYZd50", "XYZd65", "OKLAB");
+  via("XYZd50", "XYZd65", "OKLCH");
+  via("XYZd50", "XYZd65", "Rec2020");
+  via("XYZd50", "XYZd65", "HSL");
+  via("XYZd50", "XYZd65", "HWB");
+
+  via("Rec2020", "XYZd65", "OKLAB");
+  via("Rec2020", "XYZd65", "OKLCH");
+  via("Rec2020", "XYZd65", "HSL");
+  via("Rec2020", "XYZd65", "HWB");
+
+  via("HSL", "XYZd65", "OKLAB");
+  via("HSL", "XYZd65", "OKLCH");
+  via("HSL", "SRGB", "XYZd65");
+  via("HSL", "SRGB", "HWB");
+
+  via("HWB", "SRGB", "XYZd65");
+  via("HWB", "XYZd65", "OKLAB");
+  via("HWB", "XYZd65", "OKLCH");
+
+  // RGBA is an 8-bit version. Convert to SRGB, which is a
+  // more accurate floating point representation for all operations.
+  via("RGBA", "SRGB", "LAB");
+  via("RGBA", "SRGB", "LCH");
+  via("RGBA", "SRGB", "OKLAB");
+  via("RGBA", "SRGB", "OKLCH");
+  via("RGBA", "SRGB", "P3");
+  via("RGBA", "SRGB", "SRGBLinear");
+  via("RGBA", "SRGB", "A98");
+  via("RGBA", "SRGB", "ProPhoto");
+  via("RGBA", "SRGB", "XYZd50");
+  via("RGBA", "SRGB", "XYZd65");
+  via("RGBA", "SRGB", "Rec2020");
+  via("RGBA", "SRGB", "HSL");
+  via("RGBA", "SRGB", "HWB");
+}
+
+function via<T extends ColorSpaces, U extends Exclude<ColorSpaces, T>, V extends Exclude<ColorSpaces, U>>(
+  from: T,
+  middle: U,
+  to: V,
+) {
+  // Generate T, U, V function (where T, U, V are ColorSpaces)
+  let fromFunctions = code.get(from) || [];
+  fromFunctions.push(`pub fn into${to}(this: *const ${from}) ${to} {
+  const xyz: ${middle} = this.into${middle}();
+  return xyz.into${to}();
+}
+`);
+  code.set(from, fromFunctions);
+
+  // Generate V, U, function
+  let toFunctions = code.get(to) || [];
+  toFunctions.push(`pub fn into${from}(this: *const ${to}) ${from} {
+  const xyz: ${middle} = this.into${middle}();
+  return xyz.into${from}();
+}
+`);
+  code.set(to, toFunctions);
+}
diff --git a/src/css/values/css_string.zig b/src/css/values/css_string.zig
new file mode 100644
index 0000000000..7cb042cd3d
--- /dev/null
+++ b/src/css/values/css_string.zig
@@ -0,0 +1,22 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const bun = @import("root").bun;
+const logger = bun.logger;
+const Log = logger.Log;
+
+pub const css = @import("../css_parser.zig");
+pub const Result = css.Result;
+pub const Printer = css.Printer;
+pub const PrintErr = css.PrintErr;
+
+/// A quoted CSS string.
+pub const CSSString = []const u8;
+pub const CSSStringFns = struct {
+    pub fn parse(input: *css.Parser) Result(CSSString) {
+        return input.expectString();
+    }
+
+    pub fn toCss(this: *const []const u8, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        return css.serializer.serializeString(this.*, dest) catch return dest.addFmtError();
+    }
+};
diff --git a/src/css/values/easing.zig b/src/css/values/easing.zig
new file mode 100644
index 0000000000..4d7c7cd00c
--- /dev/null
+++ b/src/css/values/easing.zig
@@ -0,0 +1,257 @@
+const std = @import("std");
+const bun = @import("root").bun;
+pub const css = @import("../css_parser.zig");
+const Result = css.Result;
+const ArrayList = std.ArrayListUnmanaged;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const CSSNumber = css.css_values.number.CSSNumber;
+const CSSNumberFns = css.css_values.number.CSSNumberFns;
+const Calc = css.css_values.calc.Calc;
+const DimensionPercentage = css.css_values.percentage.DimensionPercentage;
+const LengthPercentage = css.css_values.length.LengthPercentage;
+const Length = css.css_values.length.Length;
+const Percentage = css.css_values.percentage.Percentage;
+const CssColor = css.css_values.color.CssColor;
+const Image = css.css_values.image.Image;
+const Url = css.css_values.url.Url;
+const CSSInteger = css.css_values.number.CSSInteger;
+const CSSIntegerFns = css.css_values.number.CSSIntegerFns;
+const Angle = css.css_values.angle.Angle;
+const Time = css.css_values.time.Time;
+const Resolution = css.css_values.resolution.Resolution;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CustomIdentFns = css.css_values.ident.CustomIdentFns;
+const Ident = css.css_values.ident.Ident;
+
+/// A CSS [easing function](https://www.w3.org/TR/css-easing-1/#easing-functions).
+pub const EasingFunction = union(enum) {
+    /// A linear easing function.
+    linear,
+    /// Equivalent to `cubic-bezier(0.25, 0.1, 0.25, 1)`.
+    ease,
+    /// Equivalent to `cubic-bezier(0.42, 0, 1, 1)`.
+    ease_in,
+    /// Equivalent to `cubic-bezier(0, 0, 0.58, 1)`.
+    ease_out,
+    /// Equivalent to `cubic-bezier(0.42, 0, 0.58, 1)`.
+    ease_in_out,
+    /// A custom cubic Bézier easing function.
+    cubic_bezier: struct {
+        /// The x-position of the first point in the curve.
+        x1: CSSNumber,
+        /// The y-position of the first point in the curve.
+        y1: CSSNumber,
+        /// The x-position of the second point in the curve.
+        x2: CSSNumber,
+        /// The y-position of the second point in the curve.
+        y2: CSSNumber,
+    },
+    /// A step easing function.
+    steps: struct {
+        /// The number of intervals in the function.
+        count: CSSInteger,
+        /// The step position.
+        position: StepPosition = StepPosition.default,
+    },
+
+    pub fn parse(input: *css.Parser) Result(EasingFunction) {
+        const location = input.currentSourceLocation();
+        if (input.tryParse(struct {
+            fn parse(i: *css.Parser) Result([]const u8) {
+                return i.expectIdent();
+            }
+        }.parse, .{}).asValue()) |ident| {
+            // todo_stuff.match_ignore_ascii_case
+            const keyword = if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(ident, "linear"))
+                EasingFunction.linear
+            else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(ident, "ease"))
+                EasingFunction.ease
+            else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(ident, "ease-in"))
+                EasingFunction.ease_in
+            else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(ident, "ease-out"))
+                EasingFunction.ease_out
+            else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(ident, "ease-in-out"))
+                EasingFunction.ease_in_out
+            else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(ident, "step-start"))
+                EasingFunction{ .steps = .{ .count = 1, .position = .start } }
+            else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(ident, "step-end"))
+                EasingFunction{ .steps = .{ .count = 1, .position = .end } }
+            else
+                return .{ .err = location.newUnexpectedTokenError(.{ .ident = ident }) };
+            return .{ .result = keyword };
+        }
+
+        const function = switch (input.expectFunction()) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+        return input.parseNestedBlock(
+            EasingFunction,
+            .{ .loc = location, .function = function },
+            struct {
+                fn parse(
+                    closure: *const struct { loc: css.SourceLocation, function: []const u8 },
+                    i: *css.Parser,
+                ) Result(EasingFunction) {
+                    if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(closure.function, "cubic-bezier")) {
+                        const x1 = switch (CSSNumberFns.parse(i)) {
+                            .result => |vv| vv,
+                            .err => |e| return .{ .err = e },
+                        };
+                        if (i.expectComma().asErr()) |e| return .{ .err = e };
+                        const y1 = switch (CSSNumberFns.parse(i)) {
+                            .result => |vv| vv,
+                            .err => |e| return .{ .err = e },
+                        };
+                        if (i.expectComma().asErr()) |e| return .{ .err = e };
+                        const x2 = switch (CSSNumberFns.parse(i)) {
+                            .result => |vv| vv,
+                            .err => |e| return .{ .err = e },
+                        };
+                        if (i.expectComma().asErr()) |e| return .{ .err = e };
+                        const y2 = switch (CSSNumberFns.parse(i)) {
+                            .result => |vv| vv,
+                            .err => |e| return .{ .err = e },
+                        };
+                        return .{ .result = EasingFunction{ .cubic_bezier = .{ .x1 = x1, .y1 = y1, .x2 = x2, .y2 = y2 } } };
+                    } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(closure.function, "steps")) {
+                        const count = switch (CSSIntegerFns.parse(i)) {
+                            .result => |vv| vv,
+                            .err => |e| return .{ .err = e },
+                        };
+                        const position = i.tryParse(struct {
+                            fn parse(p: *css.Parser) Result(StepPosition) {
+                                if (p.expectComma().asErr()) |e| return .{ .err = e };
+                                return StepPosition.parse(p);
+                            }
+                        }.parse, .{}).unwrapOr(StepPosition.default);
+                        return .{ .result = EasingFunction{ .steps = .{ .count = count, .position = position } } };
+                    } else {
+                        return closure.loc.newUnexpectedTokenError(.{ .ident = closure.function });
+                    }
+                }
+            }.parse,
+        );
+    }
+
+    pub fn toCss(this: *const EasingFunction, comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+        return switch (this.*) {
+            .linear => try dest.writeStr("linear"),
+            .ease => try dest.writeStr("ease"),
+            .ease_in => try dest.writeStr("ease-in"),
+            .ease_out => try dest.writeStr("ease-out"),
+            .ease_in_out => try dest.writeStr("ease-in-out"),
+            else => {
+                if (this.isEase()) {
+                    return dest.writeStr("ease");
+                } else if (this == .cubic_bezier and std.meta.eql(this.cubic_bezier, .{
+                    .x1 = 0.42,
+                    .y1 = 0.0,
+                    .x2 = 1.0,
+                    .y2 = 1.0,
+                })) {
+                    return dest.writeStr("ease-in");
+                } else if (this == .cubic_bezier and std.meta.eql(this.cubic_bezier, .{
+                    .x1 = 0.0,
+                    .y1 = 0.0,
+                    .x2 = 0.58,
+                    .y2 = 1.0,
+                })) {
+                    return dest.writeStr("ease-out");
+                } else if (this == .cubic_bezier and std.meta.eql(this.cubic_bezier, .{
+                    .x1 = 0.42,
+                    .y1 = 0.0,
+                    .x2 = 0.58,
+                    .y2 = 1.0,
+                })) {
+                    return dest.writeStr("ease-in-out");
+                }
+
+                switch (this.*) {
+                    .cubic_bezier => |cb| {
+                        try dest.writeStr("cubic-bezier(");
+                        try css.generic.toCss(cb.x1, W, dest);
+                        try dest.writeChar(',');
+                        try css.generic.toCss(cb.y1, W, dest);
+                        try dest.writeChar(',');
+                        try css.generic.toCss(cb.x2, W, dest);
+                        try dest.writeChar(',');
+                        try css.generic.toCss(cb.y2, W, dest);
+                        try dest.writeChar(')');
+                    },
+                    .steps => {
+                        if (this.steps.count == 1 and this.steps.position == .start) {
+                            return try dest.writeStr("step-start");
+                        }
+                        if (this.steps.count == 1 and this.steps.position == .end) {
+                            return try dest.writeStr("step-end");
+                        }
+                        try dest.writeStr("steps(");
+                        try dest.writeFmt("steps({d}", .{this.steps.count});
+                        try dest.delim(',', false);
+                        try this.steps.position.toCss(W, dest);
+                        return try dest.writeChar(')');
+                    },
+                    .linear, .ease, .ease_in, .ease_out, .ease_in_out => unreachable,
+                }
+            },
+        };
+    }
+
+    /// Returns whether the easing function is equivalent to the `ease` keyword.
+    pub fn isEase(this: *const EasingFunction) bool {
+        return this.* == .ease or
+            (this.* == .cubic_bezier and std.meta.eql(this.cubic_bezier == .{
+            .x1 = 0.25,
+            .y1 = 0.1,
+            .x2 = 0.25,
+            .y2 = 1.0,
+        }));
+    }
+};
+
+/// A [step position](https://www.w3.org/TR/css-easing-1/#step-position), used within the `steps()` function.
+pub const StepPosition = enum {
+    /// The first rise occurs at input progress value of 0.
+    start,
+    /// The last rise occurs at input progress value of 1.
+    end,
+    /// All rises occur within the range (0, 1).
+    jump_none,
+    /// The first rise occurs at input progress value of 0 and the last rise occurs at input progress value of 1.
+    jump_both,
+
+    // TODO: implement this
+    // pub usingnamespace css.DeriveToCss(@This());
+
+    pub fn toCss(this: *const StepPosition, comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+        _ = this; // autofix
+        _ = dest; // autofix
+        @panic(css.todo_stuff.depth);
+    }
+
+    pub fn parse(input: *css.Parser) Result(StepPosition) {
+        const location = input.currentSourceLocation();
+        const ident = switch (input.expectIdent()) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+        // todo_stuff.match_ignore_ascii_case
+        const keyword = if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(ident, "start"))
+            StepPosition.start
+        else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(ident, "end"))
+            StepPosition.end
+        else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(ident, "jump-start"))
+            StepPosition.start
+        else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(ident, "jump-end"))
+            StepPosition.end
+        else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(ident, "jump-none"))
+            StepPosition.jump_none
+        else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(ident, "jump-both"))
+            StepPosition.jump_both
+        else
+            return .{ .err = location.newUnexpectedTokenError(.{ .ident = ident }) };
+        return .{ .result = keyword };
+    }
+};
diff --git a/src/css/values/gradient.zig b/src/css/values/gradient.zig
new file mode 100644
index 0000000000..292db6ec88
--- /dev/null
+++ b/src/css/values/gradient.zig
@@ -0,0 +1,1662 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const bun = @import("root").bun;
+const ArrayList = std.ArrayListUnmanaged;
+pub const css = @import("../css_parser.zig");
+const Result = css.Result;
+const VendorPrefix = css.VendorPrefix;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const CssColor = css.css_values.color.CssColor;
+const CSSNumber = css.css_values.number.CSSNumber;
+const CSSNumberFns = css.css_values.number.CSSNumberFns;
+const Url = css.css_values.url.Url;
+const Angle = css.css_values.angle.Angle;
+const AnglePercentage = css.css_values.angle.AnglePercentage;
+const HorizontalPositionKeyword = css.css_values.position.HorizontalPositionKeyword;
+const VerticalPositionKeyword = css.css_values.position.VerticalPositionKeyword;
+const Position = css.css_values.position.Position;
+const Length = css.css_values.length.Length;
+const LengthPercentage = css.css_values.length.LengthPercentage;
+const NumberOrPercentage = css.css_values.percentage.NumberOrPercentage;
+
+/// A CSS [`<gradient>`](https://www.w3.org/TR/css-images-3/#gradients) value.
+pub const Gradient = union(enum) {
+    /// A `linear-gradient()`, and its vendor prefix.
+    linear: LinearGradient,
+    /// A `repeating-linear-gradient()`, and its vendor prefix.
+    repeating_linear: LinearGradient,
+    /// A `radial-gradient()`, and its vendor prefix.
+    radial: RadialGradient,
+    /// A `repeating-radial-gradient`, and its vendor prefix.
+    repeating_radial: RadialGradient,
+    /// A `conic-gradient()`.
+    conic: ConicGradient,
+    /// A `repeating-conic-gradient()`.
+    repeating_conic: ConicGradient,
+    /// A legacy `-webkit-gradient()`.
+    @"webkit-gradient": WebKitGradient,
+
+    pub fn parse(input: *css.Parser) Result(Gradient) {
+        const location = input.currentSourceLocation();
+        const func = switch (input.expectFunction()) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+        const Closure = struct { location: css.SourceLocation, func: []const u8 };
+        return input.parseNestedBlock(Gradient, Closure{ .location = location, .func = func }, struct {
+            fn parse(
+                closure: Closure,
+                input_: *css.Parser,
+            ) Result(Gradient) {
+                // css.todo_stuff.match_ignore_ascii_case
+                if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(closure.func, "linear-gradient")) {
+                    return .{ .result = .{ .linear = switch (LinearGradient.parse(input_, css.VendorPrefix{ .none = true })) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    } } };
+                } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(closure.func, "repeating-linear-gradient")) {
+                    return .{ .result = .{ .repeating_linear = switch (LinearGradient.parse(input_, css.VendorPrefix{ .none = true })) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    } } };
+                } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(closure.func, "radial-gradient")) {
+                    return .{ .result = .{ .radial = switch (RadialGradient.parse(input_, css.VendorPrefix{ .none = true })) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    } } };
+                } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(closure.func, "repeating-radial-gradient")) {
+                    return .{ .result = .{ .repeating_radial = switch (RadialGradient.parse(input_, css.VendorPrefix{ .none = true })) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    } } };
+                } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(closure.func, "conic-gradient")) {
+                    return .{ .result = .{ .conic = switch (ConicGradient.parse(input_)) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    } } };
+                } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(closure.func, "repeating-conic-gradient")) {
+                    return .{ .result = .{ .repeating_conic = switch (ConicGradient.parse(input_)) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    } } };
+                } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(closure.func, "-webkit-linear-gradient")) {
+                    return .{ .result = .{ .linear = switch (LinearGradient.parse(input_, css.VendorPrefix{ .webkit = true })) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    } } };
+                } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(closure.func, "-webkit-repeating-linear-gradient")) {
+                    return .{ .result = .{ .repeating_linear = switch (LinearGradient.parse(input_, css.VendorPrefix{ .webkit = true })) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    } } };
+                } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(closure.func, "-webkit-radial-gradient")) {
+                    return .{ .result = .{ .radial = switch (RadialGradient.parse(input_, css.VendorPrefix{ .webkit = true })) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    } } };
+                } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(closure.func, "-webkit-repeating-radial-gradient")) {
+                    return .{ .result = .{ .repeating_radial = switch (RadialGradient.parse(input_, css.VendorPrefix{ .webkit = true })) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    } } };
+                } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(closure.func, "-moz-linear-gradient")) {
+                    return .{ .result = .{ .linear = switch (LinearGradient.parse(input_, css.VendorPrefix{ .moz = true })) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    } } };
+                } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(closure.func, "-moz-repeating-linear-gradient")) {
+                    return .{ .result = .{ .repeating_linear = switch (LinearGradient.parse(input_, css.VendorPrefix{ .moz = true })) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    } } };
+                } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(closure.func, "-moz-radial-gradient")) {
+                    return .{ .result = .{ .radial = switch (RadialGradient.parse(input_, css.VendorPrefix{ .moz = true })) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    } } };
+                } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(closure.func, "-moz-repeating-radial-gradient")) {
+                    return .{ .result = .{ .repeating_radial = switch (RadialGradient.parse(input_, css.VendorPrefix{ .moz = true })) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    } } };
+                } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(closure.func, "-o-linear-gradient")) {
+                    return .{ .result = .{ .linear = switch (LinearGradient.parse(input_, css.VendorPrefix{ .o = true })) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    } } };
+                } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(closure.func, "-o-repeating-linear-gradient")) {
+                    return .{ .result = .{ .repeating_linear = switch (LinearGradient.parse(input_, css.VendorPrefix{ .o = true })) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    } } };
+                } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(closure.func, "-o-radial-gradient")) {
+                    return .{ .result = .{ .radial = switch (RadialGradient.parse(input_, css.VendorPrefix{ .o = true })) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    } } };
+                } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(closure.func, "-o-repeating-radial-gradient")) {
+                    return .{ .result = .{ .repeating_radial = switch (RadialGradient.parse(input_, css.VendorPrefix{ .o = true })) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    } } };
+                } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(closure.func, "-webkit-gradient")) {
+                    return .{ .result = .{ .@"webkit-gradient" = switch (WebKitGradient.parse(input_)) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    } } };
+                } else {
+                    return .{ .err = closure.location.newUnexpectedTokenError(.{ .ident = closure.func }) };
+                }
+            }
+        }.parse);
+    }
+
+    pub fn toCss(this: *const Gradient, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        const f: []const u8, const prefix: ?css.VendorPrefix = switch (this.*) {
+            .linear => |g| .{ "linear-gradient(", g.vendor_prefix },
+            .repeating_linear => |g| .{ "repeating-linear-gradient(", g.vendor_prefix },
+            .radial => |g| .{ "radial-gradient(", g.vendor_prefix },
+            .repeating_radial => |g| .{ "repeating-linear-gradient(", g.vendor_prefix },
+            .conic => .{ "conic-gradient(", null },
+            .repeating_conic => .{ "repeating-conic-gradient(", null },
+            .@"webkit-gradient" => .{ "-webkit-gradient(", null },
+        };
+
+        if (prefix) |p| {
+            try p.toCss(W, dest);
+        }
+
+        try dest.writeStr(f);
+
+        switch (this.*) {
+            .linear, .repeating_linear => |*linear| {
+                try linear.toCss(W, dest, linear.vendor_prefix.eq(css.VendorPrefix{ .none = true }));
+            },
+            .radial, .repeating_radial => |*radial| {
+                try radial.toCss(W, dest);
+            },
+            .conic, .repeating_conic => |*conic| {
+                try conic.toCss(W, dest);
+            },
+            .@"webkit-gradient" => |*g| {
+                try g.toCss(W, dest);
+            },
+        }
+
+        return dest.writeChar(')');
+    }
+
+    /// Attempts to convert the gradient to the legacy `-webkit-gradient()` syntax.
+    ///
+    /// Returns an error in case the conversion is not possible.
+    pub fn getLegacyWebkit(this: *const @This(), allocator: Allocator) ?Gradient {
+        return Gradient{ .@"webkit-gradient" = WebKitGradient.fromStandard(this, allocator) orelse return null };
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(this: *const Gradient, other: *const Gradient) bool {
+        return css.implementEql(Gradient, this, other);
+        // if (this.* == .linear and other.* == .linear) {
+        //     return this.linear.eql(&other.linear);
+        // } else if (this.* == .repeating_linear and other.* == .repeating_linear) {
+        //     return this.repeating_linear.eql(&other.repeating_linear);
+        // } else if (this.* == .radial and other.* == .radial) {
+        //     return this.radial.eql(&other.radial);
+        // } else if (this.* == .repeating_radial and other.* == .repeating_radial) {
+        //     return this.repeating_radial.eql(&other.repeating_radial);
+        // } else if (this.* == .conic and other.* == .conic) {
+        //     return this.conic.eql(&other.conic);
+        // } else if (this.* == .repeating_conic and other.* == .repeating_conic) {
+        //     return this.repeating_conic.eql(&other.repeating_conic);
+        // } else if (this.* == .@"webkit-gradient" and other.* == .@"webkit-gradient") {
+        //     return this.@"webkit-gradient".eql(&other.@"webkit-gradient");
+        // }
+        // ret
+    }
+
+    /// Returns the vendor prefix of the gradient.
+    pub fn getVendorPrefix(this: *const @This()) VendorPrefix {
+        return switch (this.*) {
+            .linear => |linear| linear.vendor_prefix,
+            .repeating_linear => |linear| linear.vendor_prefix,
+            .radial => |radial| radial.vendor_prefix,
+            .repeating_radial => |radial| radial.vendor_prefix,
+            .@"webkit-gradient" => VendorPrefix{ .webkit = true },
+            else => VendorPrefix{ .none = true },
+        };
+    }
+
+    /// Returns the vendor prefixes needed for the given browser targets.
+    pub fn getNecessaryPrefixes(this: *const @This(), targets: css.targets.Targets) css.VendorPrefix {
+        const getPrefixes = struct {
+            fn call(tgts: css.targets.Targets, feature: css.prefixes.Feature, prefix: VendorPrefix) VendorPrefix {
+                return tgts.prefixes(prefix, feature);
+            }
+        }.call;
+
+        return switch (this.*) {
+            .linear => |linear| getPrefixes(targets, .linear_gradient, linear.vendor_prefix),
+            .repeating_linear => |linear| getPrefixes(targets, .repeating_linear_gradient, linear.vendor_prefix),
+            .radial => |radial| getPrefixes(targets, .radial_gradient, radial.vendor_prefix),
+            .repeating_radial => |radial| getPrefixes(targets, .repeating_radial_gradient, radial.vendor_prefix),
+            else => VendorPrefix{ .none = true },
+        };
+    }
+
+    /// Returns a copy of the gradient with the given vendor prefix.
+    pub fn getPrefixed(this: *const @This(), allocator: Allocator, prefix: css.VendorPrefix) Gradient {
+        return switch (this.*) {
+            .linear => |*linear| .{ .linear = brk: {
+                var x = linear.deepClone(allocator);
+                x.vendor_prefix = prefix;
+                break :brk x;
+            } },
+            .repeating_linear => |*linear| .{ .repeating_linear = brk: {
+                var x = linear.deepClone(allocator);
+                x.vendor_prefix = prefix;
+                break :brk x;
+            } },
+            .radial => |*radial| .{ .radial = brk: {
+                var x = radial.deepClone(allocator);
+                x.vendor_prefix = prefix;
+                break :brk x;
+            } },
+            .repeating_radial => |*radial| .{ .repeating_radial = brk: {
+                var x = radial.deepClone(allocator);
+                x.vendor_prefix = prefix;
+                break :brk x;
+            } },
+            else => this.deepClone(allocator),
+        };
+    }
+
+    /// Returns a fallback gradient for the given color fallback type.
+    pub fn getFallback(this: *const @This(), allocator: Allocator, kind: css.ColorFallbackKind) Gradient {
+        return switch (this.*) {
+            .linear => |g| .{ .linear = g.getFallback(allocator, kind) },
+            .repeating_linear => |g| .{ .repeating_linear = g.getFallback(allocator, kind) },
+            .radial => |g| .{ .radial = g.getFallback(allocator, kind) },
+            .repeating_radial => |g| .{ .repeating_radial = g.getFallback(allocator, kind) },
+            .conic => |g| .{ .conic = g.getFallback(allocator, kind) },
+            .repeating_conic => |g| .{ .repeating_conic = g.getFallback(allocator, kind) },
+            .@"webkit-gradient" => |g| .{ .@"webkit-gradient" = g.getFallback(allocator, kind) },
+        };
+    }
+
+    /// Returns the color fallback types needed for the given browser targets.
+    pub fn getNecessaryFallbacks(this: *const @This(), targets: css.targets.Targets) css.ColorFallbackKind {
+        var fallbacks = css.ColorFallbackKind.empty();
+        switch (this.*) {
+            .linear, .repeating_linear => |*linear| {
+                for (linear.items.items) |*item| {
+                    fallbacks = fallbacks.bitwiseOr(item.getNecessaryFallbacks(targets));
+                }
+            },
+            .radial, .repeating_radial => |*radial| {
+                for (radial.items.items) |*item| {
+                    fallbacks = fallbacks.bitwiseOr(item.getNecessaryFallbacks(targets));
+                }
+            },
+            .conic, .repeating_conic => |*conic| {
+                for (conic.items.items) |*item| {
+                    fallbacks = fallbacks.bitwiseOr(item.getNecessaryFallbacks(targets));
+                }
+            },
+            .@"webkit-gradient" => {},
+        }
+        return fallbacks;
+    }
+};
+
+/// A CSS [`linear-gradient()`](https://www.w3.org/TR/css-images-3/#linear-gradients) or `repeating-linear-gradient()`.
+pub const LinearGradient = struct {
+    /// The vendor prefixes for the gradient.
+    vendor_prefix: VendorPrefix,
+    /// The direction of the gradient.
+    direction: LineDirection,
+    /// The color stops and transition hints for the gradient.
+    items: ArrayList(GradientItem(LengthPercentage)),
+
+    pub fn parse(input: *css.Parser, vendor_prefix: VendorPrefix) Result(LinearGradient) {
+        const direction: LineDirection = if (input.tryParse(LineDirection.parse, .{vendor_prefix.neq(VendorPrefix{ .none = true })}).asValue()) |dir| direction: {
+            if (input.expectComma().asErr()) |e| return .{ .err = e };
+            break :direction dir;
+        } else LineDirection{ .vertical = .bottom };
+        const items = switch (parseItems(LengthPercentage, input)) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+        return .{ .result = LinearGradient{ .direction = direction, .items = items, .vendor_prefix = vendor_prefix } };
+    }
+
+    pub fn toCss(this: *const LinearGradient, comptime W: type, dest: *Printer(W), is_prefixed: bool) PrintErr!void {
+        const angle: f32 = switch (this.direction) {
+            .vertical => |v| switch (v) {
+                .bottom => 180.0,
+                .top => 0.0,
+            },
+            .angle => |a| a.toDegrees(),
+            else => -1.0,
+        };
+
+        // We can omit `to bottom` or `180deg` because it is the default.
+        if (angle == 180.0) {
+            // todo_stuff.depth
+            try serializeItems(LengthPercentage, &this.items, W, dest);
+        }
+        // If we have `to top` or `0deg`, and all of the positions and hints are percentages,
+        // we can flip the gradient the other direction and omit the direction.
+        else if (angle == 0.0 and dest.minify and brk: {
+            for (this.items.items) |*item| {
+                if (item.* == .hint and item.hint != .percentage) break :brk false;
+                if (item.* == .color_stop and item.color_stop.position != null and item.color_stop.position.? != .percentage) break :brk false;
+            }
+            break :brk true;
+        }) {
+            var flipped_items = ArrayList(GradientItem(LengthPercentage)).initCapacity(
+                dest.allocator,
+                this.items.items.len,
+            ) catch bun.outOfMemory();
+            defer flipped_items.deinit(dest.allocator);
+
+            var i: usize = this.items.items.len;
+            while (i > 0) {
+                i -= 1;
+                const item = &this.items.items[i];
+                switch (item.*) {
+                    .hint => |*h| switch (h.*) {
+                        .percentage => |p| flipped_items.append(dest.allocator, .{ .hint = .{ .percentage = .{ .v = 1.0 - p.v } } }) catch bun.outOfMemory(),
+                        else => unreachable,
+                    },
+                    .color_stop => |*cs| flipped_items.append(dest.allocator, .{
+                        .color_stop = .{
+                            .color = cs.color,
+                            .position = if (cs.position) |*p| switch (p.*) {
+                                .percentage => |perc| .{ .percentage = .{ .v = 1.0 - perc.v } },
+                                else => unreachable,
+                            } else null,
+                        },
+                    }) catch bun.outOfMemory(),
+                }
+            }
+
+            serializeItems(LengthPercentage, &flipped_items, W, dest) catch return dest.addFmtError();
+        } else {
+            if ((this.direction != .vertical or this.direction.vertical != .bottom) and
+                (this.direction != .angle or this.direction.angle.deg != 180.0))
+            {
+                try this.direction.toCss(W, dest, is_prefixed);
+                try dest.delim(',', false);
+            }
+
+            serializeItems(LengthPercentage, &this.items, W, dest) catch return dest.addFmtError();
+        }
+    }
+
+    pub fn isCompatible(this: *const @This(), browsers: css.targets.Browsers) bool {
+        for (this.items.items) |*item| {
+            if (!item.isCompatible(browsers)) return false;
+        }
+        return true;
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(this: *const LinearGradient, other: *const LinearGradient) bool {
+        return this.vendor_prefix.eql(other.vendor_prefix) and this.direction.eql(&other.direction) and css.generic.eqlList(GradientItem(LengthPercentage), &this.items, &other.items);
+    }
+
+    pub fn getFallback(this: *const @This(), allocator: std.mem.Allocator, kind: css.ColorFallbackKind) LinearGradient {
+        var fallback_items = ArrayList(GradientItem(LengthPercentage)).initCapacity(allocator, this.items.items.len) catch bun.outOfMemory();
+        fallback_items.items.len = this.items.items.len;
+        for (fallback_items.items, this.items.items) |*out, *in| {
+            out.* = in.getFallback(allocator, kind);
+        }
+
+        return LinearGradient{
+            .direction = this.direction.deepClone(allocator),
+            .items = fallback_items,
+            .vendor_prefix = this.vendor_prefix,
+        };
+    }
+};
+
+/// A CSS [`radial-gradient()`](https://www.w3.org/TR/css-images-3/#radial-gradients) or `repeating-radial-gradient()`.
+pub const RadialGradient = struct {
+    /// The vendor prefixes for the gradient.
+    vendor_prefix: VendorPrefix,
+    /// The shape of the gradient.
+    shape: EndingShape,
+    /// The position of the gradient.
+    position: Position,
+    /// The color stops and transition hints for the gradient.
+    items: ArrayList(GradientItem(LengthPercentage)),
+
+    pub fn parse(input: *css.Parser, vendor_prefix: VendorPrefix) Result(RadialGradient) {
+        // todo_stuff.depth
+        const shape = switch (input.tryParse(EndingShape.parse, .{})) {
+            .result => |vv| vv,
+            .err => null,
+        };
+        const position = switch (input.tryParse(struct {
+            fn parse(input_: *css.Parser) Result(Position) {
+                if (input_.expectIdentMatching("at").asErr()) |e| return .{ .err = e };
+                return Position.parse(input_);
+            }
+        }.parse, .{})) {
+            .result => |v| v,
+            .err => null,
+        };
+
+        if (shape != null or position != null) {
+            if (input.expectComma().asErr()) |e| return .{ .err = e };
+        }
+
+        const items = switch (parseItems(LengthPercentage, input)) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+        return .{
+            .result = RadialGradient{
+                // todo_stuff.depth
+                .shape = shape orelse EndingShape.default(),
+                // todo_stuff.depth
+                .position = position orelse Position.center(),
+                .items = items,
+                .vendor_prefix = vendor_prefix,
+            },
+        };
+    }
+
+    pub fn toCss(this: *const RadialGradient, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        if (std.meta.eql(this.shape, EndingShape.default())) {
+            try this.shape.toCss(W, dest);
+            if (this.position.isCenter()) {
+                try dest.delim(',', false);
+            } else {
+                try dest.writeChar(' ');
+            }
+        }
+
+        if (!this.position.isCenter()) {
+            try dest.writeStr("at ");
+            try this.position.toCss(W, dest);
+            try dest.delim(',', false);
+        }
+
+        try serializeItems(LengthPercentage, &this.items, W, dest);
+    }
+
+    pub fn isCompatible(this: *const @This(), browsers: css.targets.Browsers) bool {
+        for (this.items.items) |*item| {
+            if (!item.isCompatible(browsers)) return false;
+        }
+        return true;
+    }
+
+    pub fn getFallback(this: *const RadialGradient, allocator: Allocator, kind: css.ColorFallbackKind) RadialGradient {
+        var items = ArrayList(GradientItem(LengthPercentage)).initCapacity(allocator, this.items.items.len) catch bun.outOfMemory();
+        items.items.len = this.items.items.len;
+        for (items.items, this.items.items) |*out, *in| {
+            out.* = in.getFallback(allocator, kind);
+        }
+
+        return RadialGradient{
+            .shape = this.shape.deepClone(allocator),
+            .position = this.position.deepClone(allocator),
+            .items = items,
+            .vendor_prefix = this.vendor_prefix,
+        };
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(this: *const RadialGradient, other: *const RadialGradient) bool {
+        return this.vendor_prefix.eql(other.vendor_prefix) and
+            this.shape.eql(&other.shape) and
+            this.position.eql(&other.position) and
+            css.generic.eqlList(GradientItem(LengthPercentage), &this.items, &other.items);
+    }
+};
+
+/// A CSS [`conic-gradient()`](https://www.w3.org/TR/css-images-4/#conic-gradients) or `repeating-conic-gradient()`.
+pub const ConicGradient = struct {
+    /// The angle of the gradient.
+    angle: Angle,
+    /// The position of the gradient.
+    position: Position,
+    /// The color stops and transition hints for the gradient.
+    items: ArrayList(GradientItem(AnglePercentage)),
+
+    pub fn parse(input: *css.Parser) Result(ConicGradient) {
+        const angle = input.tryParse(struct {
+            inline fn parse(i: *css.Parser) Result(Angle) {
+                if (i.expectIdentMatching("from").asErr()) |e| return .{ .err = e };
+                // Spec allows unitless zero angles for gradients.
+                // https://w3c.github.io/csswg-drafts/css-images-4/#valdef-conic-gradient-angle
+                return Angle.parseWithUnitlessZero(i);
+            }
+        }.parse, .{}).unwrapOr(Angle{ .deg = 0.0 });
+
+        const position = input.tryParse(struct {
+            inline fn parse(i: *css.Parser) Result(Position) {
+                if (i.expectIdentMatching("at").asErr()) |e| return .{ .err = e };
+                return Position.parse(i);
+            }
+        }.parse, .{}).unwrapOr(Position.center());
+
+        if (!angle.eql(&Angle{ .deg = 0.0 }) or !std.meta.eql(position, Position.center())) {
+            if (input.expectComma().asErr()) |e| return .{ .err = e };
+        }
+
+        const items = switch (parseItems(AnglePercentage, input)) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+        return .{ .result = ConicGradient{
+            .angle = angle,
+            .position = position,
+            .items = items,
+        } };
+    }
+
+    pub fn toCss(this: *const ConicGradient, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        if (!this.angle.isZero()) {
+            try dest.writeStr("from ");
+            try this.angle.toCss(W, dest);
+
+            if (this.position.isCenter()) {
+                try dest.delim(',', false);
+            } else {
+                try dest.writeChar(' ');
+            }
+        }
+
+        if (!this.position.isCenter()) {
+            try dest.writeStr("at ");
+            try this.position.toCss(W, dest);
+            try dest.delim(',', false);
+        }
+
+        return try serializeItems(AnglePercentage, &this.items, W, dest);
+    }
+
+    pub fn isCompatible(this: *const @This(), browsers: css.targets.Browsers) bool {
+        for (this.items.items) |*item| {
+            if (!item.isCompatible(browsers)) return false;
+        }
+        return true;
+    }
+
+    pub fn getFallback(this: *const @This(), allocator: Allocator, kind: css.ColorFallbackKind) ConicGradient {
+        var items = ArrayList(GradientItem(AnglePercentage)).initCapacity(allocator, this.items.items.len) catch bun.outOfMemory();
+        items.items.len = this.items.items.len;
+        for (items.items, this.items.items) |*out, *in| {
+            out.* = in.getFallback(allocator, kind);
+        }
+
+        return ConicGradient{
+            .angle = this.angle.deepClone(allocator),
+            .position = this.position.deepClone(allocator),
+            .items = items,
+        };
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(this: *const ConicGradient, other: *const ConicGradient) bool {
+        return this.angle.eql(&other.angle) and
+            this.position.eql(&other.position) and
+            css.generic.eqlList(GradientItem(AnglePercentage), &this.items, &other.items);
+    }
+};
+
+/// A legacy `-webkit-gradient()`.
+pub const WebKitGradient = union(enum) {
+    /// A linear `-webkit-gradient()`.
+    linear: struct {
+        /// The starting point of the gradient.
+        from: WebKitGradientPoint,
+        /// The ending point of the gradient.
+        to: WebKitGradientPoint,
+        /// The color stops in the gradient.
+        stops: ArrayList(WebKitColorStop),
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    },
+    /// A radial `-webkit-gradient()`.
+    radial: struct {
+        /// The starting point of the gradient.
+        from: WebKitGradientPoint,
+        /// The starting radius of the gradient.
+        r0: CSSNumber,
+        /// The ending point of the gradient.
+        to: WebKitGradientPoint,
+        /// The ending radius of the gradient.
+        r1: CSSNumber,
+        /// The color stops in the gradient.
+        stops: ArrayList(WebKitColorStop),
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    },
+
+    pub fn parse(input: *css.Parser) Result(WebKitGradient) {
+        const location = input.currentSourceLocation();
+        const ident = switch (input.expectIdent()) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+        if (input.expectComma().asErr()) |e| return .{ .err = e };
+
+        // todo_stuff.match_ignore_ascii_case
+        if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(ident, "linear")) {
+            // todo_stuff.depth
+            const from = switch (WebKitGradientPoint.parse(input)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            };
+            if (input.expectComma().asErr()) |e| return .{ .err = e };
+            const to = switch (WebKitGradientPoint.parse(input)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            };
+            if (input.expectComma().asErr()) |e| return .{ .err = e };
+            const stops = switch (input.parseCommaSeparated(WebKitColorStop, WebKitColorStop.parse)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            };
+            return .{ .result = WebKitGradient{ .linear = .{
+                .from = from,
+                .to = to,
+                .stops = stops,
+            } } };
+        } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(ident, "radial")) {
+            const from = switch (WebKitGradientPoint.parse(input)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            };
+            if (input.expectComma().asErr()) |e| return .{ .err = e };
+            const r0 = switch (CSSNumberFns.parse(input)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            };
+            if (input.expectComma().asErr()) |e| return .{ .err = e };
+            const to = switch (WebKitGradientPoint.parse(input)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            };
+            if (input.expectComma().asErr()) |e| return .{ .err = e };
+            const r1 = switch (CSSNumberFns.parse(input)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            };
+            if (input.expectComma().asErr()) |e| return .{ .err = e };
+            // todo_stuff.depth
+            const stops = switch (input.parseCommaSeparated(WebKitColorStop, WebKitColorStop.parse)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            };
+            return .{ .result = WebKitGradient{
+                .radial = .{
+                    .from = from,
+                    .r0 = r0,
+                    .to = to,
+                    .r1 = r1,
+                    .stops = stops,
+                },
+            } };
+        } else {
+            return .{ .err = location.newUnexpectedTokenError(.{ .ident = ident }) };
+        }
+    }
+
+    pub fn toCss(this: *const WebKitGradient, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        switch (this.*) {
+            .linear => |*linear| {
+                try dest.writeStr("linear");
+                try dest.delim(',', false);
+                try linear.from.toCss(W, dest);
+                try dest.delim(',', false);
+                try linear.to.toCss(W, dest);
+                for (linear.stops.items) |*stop| {
+                    try dest.delim(',', false);
+                    try stop.toCss(W, dest);
+                }
+            },
+            .radial => |*radial| {
+                try dest.writeStr("radial");
+                try dest.delim(',', false);
+                try radial.from.toCss(W, dest);
+                try dest.delim(',', false);
+                try CSSNumberFns.toCss(&radial.r0, W, dest);
+                try dest.delim(',', false);
+                try radial.to.toCss(W, dest);
+                try dest.delim(',', false);
+                try CSSNumberFns.toCss(&radial.r1, W, dest);
+                for (radial.stops.items) |*stop| {
+                    try dest.delim(',', false);
+                    try stop.toCss(W, dest);
+                }
+            },
+        }
+    }
+
+    pub fn getFallback(this: *const @This(), allocator: Allocator, kind: css.ColorFallbackKind) WebKitGradient {
+        var stops: ArrayList(WebKitColorStop) = .{};
+        switch (this.*) {
+            .linear => |linear| {
+                stops = ArrayList(WebKitColorStop).initCapacity(allocator, linear.stops.items.len) catch bun.outOfMemory();
+                stops.items.len = linear.stops.items.len;
+                for (stops.items, linear.stops.items) |*out, *in| {
+                    out.* = in.getFallback(allocator, kind);
+                }
+                return WebKitGradient{
+                    .linear = .{
+                        .from = linear.from.deepClone(allocator),
+                        .to = linear.to.deepClone(allocator),
+                        .stops = stops,
+                    },
+                };
+            },
+            .radial => |radial| {
+                stops = ArrayList(WebKitColorStop).initCapacity(allocator, radial.stops.items.len) catch bun.outOfMemory();
+                stops.items.len = radial.stops.items.len;
+                for (stops.items, radial.stops.items) |*out, *in| {
+                    out.* = in.getFallback(allocator, kind);
+                }
+                return WebKitGradient{
+                    .radial = .{
+                        .from = radial.from.deepClone(allocator),
+                        .r0 = radial.r0,
+                        .to = radial.to.deepClone(allocator),
+                        .r1 = radial.r1,
+                        .stops = stops,
+                    },
+                };
+            },
+        }
+    }
+
+    pub fn fromStandard(gradient: *const Gradient, allocator: Allocator) ?WebKitGradient {
+        switch (gradient.*) {
+            .linear => |*linear| {
+                // Convert from line direction to a from and to point, if possible.
+                const from: struct { f32, f32 }, const to: struct { f32, f32 } = switch (linear.direction) {
+                    .horizontal => |horizontal| switch (horizontal) {
+                        .left => .{ .{ 1.0, 0.0 }, .{ 0.0, 0.0 } },
+                        .right => .{ .{ 0.0, 0.0 }, .{ 1.0, 0.0 } },
+                    },
+                    .vertical => |vertical| switch (vertical) {
+                        .top => .{ .{ 0.0, 1.0 }, .{ 0.0, 0.0 } },
+                        .bottom => .{ .{ 0.0, 0.0 }, .{ 0.0, 1.0 } },
+                    },
+                    .corner => |corner| switch (corner.horizontal) {
+                        .left => switch (corner.vertical) {
+                            .top => .{ .{ 1.0, 1.0 }, .{ 0.0, 0.0 } },
+                            .bottom => .{ .{ 1.0, 0.0 }, .{ 0.0, 1.0 } },
+                        },
+                        .right => switch (corner.vertical) {
+                            .top => .{ .{ 0.0, 1.0 }, .{ 1.0, 0.0 } },
+                            .bottom => .{ .{ 0.0, 0.0 }, .{ 1.0, 1.0 } },
+                        },
+                    },
+                    .angle => |angle| brk: {
+                        const degrees = angle.toDegrees();
+                        if (degrees == 0.0) {
+                            break :brk .{ .{ 0.0, 1.0 }, .{ 0.0, 0.0 } };
+                        } else if (degrees == 90.0) {
+                            break :brk .{ .{ 0.0, 0.0 }, .{ 1.0, 0.0 } };
+                        } else if (degrees == 180.0) {
+                            break :brk .{ .{ 0.0, 0.0 }, .{ 0.0, 1.0 } };
+                        } else if (degrees == 270.0) {
+                            break :brk .{ .{ 1.0, 0.0 }, .{ 0.0, 0.0 } };
+                        } else {
+                            return null;
+                        }
+                    },
+                };
+
+                return WebKitGradient{
+                    .linear = .{
+                        .from = .{
+                            .x = .{ .number = .{ .percentage = .{ .v = from[0] } } },
+                            .y = .{ .number = .{ .percentage = .{ .v = from[1] } } },
+                        },
+                        .to = .{
+                            .x = .{ .number = .{ .percentage = .{ .v = to[0] } } },
+                            .y = .{ .number = .{ .percentage = .{ .v = to[1] } } },
+                        },
+                        .stops = convertStopsToWebkit(allocator, &linear.items) orelse return null,
+                    },
+                };
+            },
+            .radial => |*radial| {
+                // Webkit radial gradients are always circles, not ellipses, and must be specified in pixels.
+                const radius = switch (radial.shape) {
+                    .circle => |*circle| switch (circle.*) {
+                        .radius => |r| if (r.toPx()) |px| px else return null,
+                        else => return null,
+                    },
+                    else => return null,
+                };
+
+                const x = WebKitGradientPointComponent(HorizontalPositionKeyword).fromPosition(&radial.position.x, allocator) orelse return null;
+                const y = WebKitGradientPointComponent(VerticalPositionKeyword).fromPosition(&radial.position.y, allocator) orelse return null;
+                const point = WebKitGradientPoint{ .x = x, .y = y };
+                return WebKitGradient{
+                    .radial = .{
+                        .from = point.deepClone(allocator),
+                        .r0 = 0.0,
+                        .to = point,
+                        .r1 = radius,
+                        .stops = convertStopsToWebkit(allocator, &radial.items) orelse return null,
+                    },
+                };
+            },
+            else => return null,
+        }
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(this: *const WebKitGradient, other: *const WebKitGradient) bool {
+        return switch (this.*) {
+            .linear => |*a| switch (other.*) {
+                .linear => a.from.eql(&other.linear.from) and a.to.eql(&other.linear.to) and css.generic.eqlList(WebKitColorStop, &a.stops, &other.linear.stops),
+                else => false,
+            },
+            .radial => |*a| switch (other.*) {
+                .radial => a.from.eql(&other.radial.from) and a.to.eql(&other.radial.to) and a.r0 == other.radial.r0 and a.r1 == other.radial.r1 and css.generic.eqlList(WebKitColorStop, &a.stops, &other.radial.stops),
+                else => false,
+            },
+        };
+    }
+};
+
+/// The direction of a CSS `linear-gradient()`.
+///
+/// See [LinearGradient](LinearGradient).
+pub const LineDirection = union(enum) {
+    /// An angle.
+    angle: Angle,
+    /// A horizontal position keyword, e.g. `left` or `right`.
+    horizontal: HorizontalPositionKeyword,
+    /// A vertical position keyword, e.g. `top` or `bottom`.
+    vertical: VerticalPositionKeyword,
+    /// A corner, e.g. `bottom left` or `top right`.
+    corner: struct {
+        /// A horizontal position keyword, e.g. `left` or `right`.
+        horizontal: HorizontalPositionKeyword,
+        /// A vertical position keyword, e.g. `top` or `bottom`.
+        vertical: VerticalPositionKeyword,
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    },
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(this: *const LineDirection, other: *const LineDirection) bool {
+        return switch (this.*) {
+            .angle => |*a| switch (other.*) {
+                .angle => a.eql(&other.angle),
+                else => false,
+            },
+            .horizontal => |*v| switch (other.*) {
+                .horizontal => v.* == other.horizontal,
+                else => false,
+            },
+            .vertical => |*v| switch (other.*) {
+                .vertical => v.* == other.vertical,
+                else => false,
+            },
+            .corner => |*c| switch (other.*) {
+                .corner => c.horizontal == other.corner.horizontal and c.vertical == other.corner.vertical,
+                else => false,
+            },
+        };
+    }
+
+    pub fn parse(input: *css.Parser, is_prefixed: bool) Result(LineDirection) {
+        // Spec allows unitless zero angles for gradients.
+        // https://w3c.github.io/csswg-drafts/css-images-3/#linear-gradient-syntax
+        if (input.tryParse(Angle.parseWithUnitlessZero, .{}).asValue()) |angle| {
+            return .{ .result = LineDirection{ .angle = angle } };
+        }
+
+        if (!is_prefixed) {
+            if (input.expectIdentMatching("to").asErr()) |e| return .{ .err = e };
+        }
+
+        if (input.tryParse(HorizontalPositionKeyword.parse, .{}).asValue()) |x| {
+            if (input.tryParse(VerticalPositionKeyword.parse, .{}).asValue()) |y| {
+                return .{ .result = LineDirection{ .corner = .{
+                    .horizontal = x,
+                    .vertical = y,
+                } } };
+            }
+            return .{ .result = LineDirection{ .horizontal = x } };
+        }
+
+        const y = switch (VerticalPositionKeyword.parse(input)) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+        if (input.tryParse(HorizontalPositionKeyword.parse, .{}).asValue()) |x| {
+            return .{ .result = LineDirection{ .corner = .{
+                .horizontal = x,
+                .vertical = y,
+            } } };
+        }
+        return .{ .result = LineDirection{ .vertical = y } };
+    }
+
+    pub fn toCss(this: *const LineDirection, comptime W: type, dest: *Printer(W), is_prefixed: bool) PrintErr!void {
+        switch (this.*) {
+            .angle => |*angle| try angle.toCss(W, dest),
+            .horizontal => |*k| {
+                if (dest.minify) {
+                    try dest.writeStr(switch (k.*) {
+                        .left => "270deg",
+                        .right => "90deg",
+                    });
+                } else {
+                    if (!is_prefixed) {
+                        try dest.writeStr("to ");
+                    }
+                    try k.toCss(W, dest);
+                }
+            },
+            .vertical => |*k| {
+                if (dest.minify) {
+                    try dest.writeStr(switch (k.*) {
+                        .top => "0deg",
+                        .bottom => "180deg",
+                    });
+                } else {
+                    if (!is_prefixed) {
+                        try dest.writeStr("to ");
+                    }
+                    try k.toCss(W, dest);
+                }
+            },
+            .corner => |*c| {
+                if (!is_prefixed) {
+                    try dest.writeStr("to ");
+                }
+                try c.vertical.toCss(W, dest);
+                try dest.writeChar(' ');
+                try c.horizontal.toCss(W, dest);
+            },
+        }
+    }
+};
+
+/// Either a color stop or interpolation hint within a gradient.
+///
+/// This type is generic, and items may be either a [LengthPercentage](super::length::LengthPercentage)
+/// or [Angle](super::angle::Angle) depending on what type of gradient it is within.
+pub fn GradientItem(comptime D: type) type {
+    return union(enum) {
+        /// A color stop.
+        color_stop: ColorStop(D),
+        /// A color interpolation hint.
+        hint: D,
+
+        pub fn toCss(this: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+            return switch (this.*) {
+                .color_stop => |*c| try c.toCss(W, dest),
+                .hint => |*h| try css.generic.toCss(D, h, W, dest),
+            };
+        }
+
+        pub fn eql(this: *const GradientItem(D), other: *const GradientItem(D)) bool {
+            return switch (this.*) {
+                .color_stop => |*a| switch (other.*) {
+                    .color_stop => a.eql(&other.color_stop),
+                    else => false,
+                },
+                .hint => |*a| switch (other.*) {
+                    .hint => css.generic.eql(D, a, &other.hint),
+                    else => false,
+                },
+            };
+        }
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+
+        pub fn isCompatible(this: *const @This(), browsers: css.targets.Browsers) bool {
+            return switch (this.*) {
+                .color_stop => |*c| c.color.isCompatible(browsers),
+                .hint => css.compat.Feature.isCompatible(.gradient_interpolation_hints, browsers),
+            };
+        }
+
+        /// Returns a fallback gradient item for the given color fallback type.
+        pub fn getFallback(this: *const @This(), allocator: Allocator, kind: css.ColorFallbackKind) GradientItem(D) {
+            return switch (this.*) {
+                .color_stop => |*stop| .{
+                    .color_stop = .{
+                        .color = stop.color.getFallback(allocator, kind),
+                        .position = if (stop.position) |*p| p.deepClone(allocator) else null,
+                    },
+                },
+                .hint => this.deepClone(allocator),
+            };
+        }
+
+        /// Returns the color fallback types needed for the given browser targets.
+        pub fn getNecessaryFallbacks(this: *const @This(), targets: css.targets.Targets) css.ColorFallbackKind {
+            return switch (this.*) {
+                .color_stop => |*stop| stop.color.getNecessaryFallbacks(targets),
+                .hint => css.ColorFallbackKind.empty(),
+            };
+        }
+    };
+}
+
+/// A `radial-gradient()` [ending shape](https://www.w3.org/TR/css-images-3/#valdef-radial-gradient-ending-shape).
+///
+/// See [RadialGradient](RadialGradient).
+pub const EndingShape = union(enum) {
+    /// An ellipse.
+    ellipse: Ellipse,
+    /// A circle.
+    circle: Circle,
+
+    pub usingnamespace css.DeriveParse(@This());
+    pub usingnamespace css.DeriveToCss(@This());
+
+    pub fn default() EndingShape {
+        return .{ .ellipse = .{ .extent = .@"farthest-corner" } };
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(this: *const EndingShape, other: *const EndingShape) bool {
+        return switch (this.*) {
+            .ellipse => |*a| switch (other.*) {
+                .ellipse => a.eql(&other.ellipse),
+                else => false,
+            },
+            .circle => |*a| switch (other.*) {
+                .circle => a.eql(&other.circle),
+                else => false,
+            },
+        };
+    }
+};
+
+/// An x/y position within a legacy `-webkit-gradient()`.
+pub const WebKitGradientPoint = struct {
+    /// The x-position.
+    x: WebKitGradientPointComponent(HorizontalPositionKeyword),
+    /// The y-position.
+    y: WebKitGradientPointComponent(VerticalPositionKeyword),
+
+    pub fn parse(input: *css.Parser) Result(WebKitGradientPoint) {
+        const x = switch (WebKitGradientPointComponent(HorizontalPositionKeyword).parse(input)) {
+            .result => |v| v,
+            .err => |e| return .{ .err = e },
+        };
+        const y = switch (WebKitGradientPointComponent(VerticalPositionKeyword).parse(input)) {
+            .result => |v| v,
+            .err => |e| return .{ .err = e },
+        };
+        return .{ .result = .{ .x = x, .y = y } };
+    }
+
+    pub fn toCss(this: *const WebKitGradientPoint, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        try this.x.toCss(W, dest);
+        try dest.writeChar(' ');
+        return try this.y.toCss(W, dest);
+    }
+
+    pub fn eql(this: *const WebKitGradientPoint, other: *const WebKitGradientPoint) bool {
+        return this.x.eql(&other.x) and this.y.eql(&other.y);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A keyword or number within a [WebKitGradientPoint](WebKitGradientPoint).
+pub fn WebKitGradientPointComponent(comptime S: type) type {
+    return union(enum) {
+        /// The `center` keyword.
+        center,
+        /// A number or percentage.
+        number: NumberOrPercentage,
+        /// A side keyword.
+        side: S,
+
+        const This = @This();
+
+        pub fn parse(input: *css.Parser) Result(This) {
+            if (input.tryParse(css.Parser.expectIdentMatching, .{"center"}).isOk()) {
+                return .{ .result = .center };
+            }
+
+            if (input.tryParse(NumberOrPercentage.parse, .{}).asValue()) |number| {
+                return .{ .result = .{ .number = number } };
+            }
+
+            const keyword = switch (css.generic.parse(S, input)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            };
+            return .{ .result = .{ .side = keyword } };
+        }
+
+        pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+            switch (this.*) {
+                .center => {
+                    if (dest.minify) {
+                        try dest.writeStr("50%");
+                    } else {
+                        try dest.writeStr("center");
+                    }
+                },
+                .number => |*lp| {
+                    if (lp.* == .percentage and lp.percentage.v == 0.0) {
+                        try dest.writeChar('0');
+                    } else {
+                        try lp.toCss(W, dest);
+                    }
+                },
+                .side => |*s| {
+                    if (dest.minify) {
+                        const lp: LengthPercentage = s.intoLengthPercentage();
+                        try lp.toCss(W, dest);
+                    } else {
+                        try s.toCss(W, dest);
+                    }
+                },
+            }
+        }
+
+        /// Attempts to convert a standard position to a webkit gradient point.
+        pub fn fromPosition(this: *const css.css_values.position.PositionComponent(S), allocator: Allocator) ?WebKitGradientPointComponent(S) {
+            return switch (this.*) {
+                .center => .center,
+                .length => |len| .{
+                    .number = switch (len) {
+                        .percentage => |p| .{ .percentage = p },
+                        // Webkit gradient points can only be specified in pixels.
+                        .dimension => |*d| if (d.toPx()) |px| .{ .number = px } else return null,
+                        else => return null,
+                    },
+                },
+                .side => |s| if (s.offset != null)
+                    return null
+                else
+                    .{
+                        .side = s.side.deepClone(allocator),
+                    },
+            };
+        }
+
+        pub fn eql(this: *const This, other: *const This) bool {
+            return switch (this.*) {
+                .center => switch (other.*) {
+                    .center => true,
+                    else => false,
+                },
+                .number => |*a| switch (other.*) {
+                    .number => a.eql(&other.number),
+                    else => false,
+                },
+                .side => |*a| switch (other.*) {
+                    .side => |*b| a.eql(&b.*),
+                    else => false,
+                },
+            };
+        }
+    };
+}
+
+/// A color stop within a legacy `-webkit-gradient()`.
+pub const WebKitColorStop = struct {
+    /// The color of the color stop.
+    color: CssColor,
+    /// The position of the color stop.
+    position: CSSNumber,
+
+    pub fn parse(input: *css.Parser) Result(WebKitColorStop) {
+        const location = input.currentSourceLocation();
+        const function = switch (input.expectFunction()) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+        const Closure = struct { loc: css.SourceLocation, function: []const u8 };
+        return input.parseNestedBlock(
+            WebKitColorStop,
+            Closure{ .loc = location, .function = function },
+            struct {
+                fn parse(
+                    closure: Closure,
+                    i: *css.Parser,
+                ) Result(WebKitColorStop) {
+                    // todo_stuff.match_ignore_ascii_case
+                    const position: f32 = if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(closure.function, "color-stop")) position: {
+                        const p: NumberOrPercentage = switch (@call(.auto, @field(NumberOrPercentage, "parse"), .{i})) {
+                            .result => |vv| vv,
+                            .err => |e| return .{ .err = e },
+                        };
+                        if (i.expectComma().asErr()) |e| return .{ .err = e };
+                        break :position p.intoF32();
+                    } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(closure.function, "from")) position: {
+                        break :position 0.0;
+                    } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(closure.function, "to")) position: {
+                        break :position 1.0;
+                    } else {
+                        return .{ .err = closure.loc.newUnexpectedTokenError(.{ .ident = closure.function }) };
+                    };
+                    const color = switch (CssColor.parse(i)) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    };
+                    return .{ .result = WebKitColorStop{ .color = color, .position = position } };
+                }
+            }.parse,
+        );
+    }
+
+    pub fn toCss(this: *const WebKitColorStop, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        if (this.position == 0.0) {
+            try dest.writeStr("from(");
+            try this.color.toCss(W, dest);
+        } else if (this.position == 1.0) {
+            try dest.writeStr("to(");
+            try this.color.toCss(W, dest);
+        } else {
+            try dest.writeStr("color-stop(");
+            try css.generic.toCss(CSSNumber, &this.position, W, dest);
+            try dest.delim(',', false);
+            try this.color.toCss(W, dest);
+        }
+        try dest.writeChar(')');
+    }
+
+    pub fn getFallback(this: *const @This(), allocator: Allocator, kind: css.ColorFallbackKind) WebKitColorStop {
+        return WebKitColorStop{
+            .color = this.color.getFallback(allocator, kind),
+            .position = this.position,
+        };
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(this: *const WebKitColorStop, other: *const WebKitColorStop) bool {
+        return css.implementEql(WebKitColorStop, this, other);
+    }
+};
+
+/// A [`<color-stop>`](https://www.w3.org/TR/css-images-4/#color-stop-syntax) within a gradient.
+///
+/// This type is generic, and may be either a [LengthPercentage](super::length::LengthPercentage)
+/// or [Angle](super::angle::Angle) depending on what type of gradient it is within.
+pub fn ColorStop(comptime D: type) type {
+    return struct {
+        /// The color of the color stop.
+        color: CssColor,
+        /// The position of the color stop.
+        position: ?D,
+
+        const This = @This();
+
+        pub fn parse(input: *css.Parser) Result(ColorStop(D)) {
+            const color = switch (CssColor.parse(input)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            };
+            const position = switch (input.tryParse(css.generic.parseFor(D), .{})) {
+                .result => |v| v,
+                .err => null,
+            };
+            return .{ .result = .{ .color = color, .position = position } };
+        }
+
+        pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+            try this.color.toCss(W, dest);
+            if (this.position) |*position| {
+                try dest.delim(',', false);
+                try css.generic.toCss(D, position, W, dest);
+            }
+            return;
+        }
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+
+        pub fn eql(this: *const This, other: *const This) bool {
+            return this.color.eql(&other.color) and css.generic.eql(?D, &this.position, &other.position);
+        }
+    };
+}
+
+/// An ellipse ending shape for a `radial-gradient()`.
+///
+/// See [RadialGradient](RadialGradient).
+pub const Ellipse = union(enum) {
+    /// An ellipse with a specified horizontal and vertical radius.
+    size: struct {
+        /// The x-radius of the ellipse.
+        x: LengthPercentage,
+        /// The y-radius of the ellipse.
+        y: LengthPercentage,
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    },
+    /// A shape extent keyword.
+    extent: ShapeExtent,
+
+    pub fn parse(input: *css.Parser) Result(Ellipse) {
+        if (input.tryParse(ShapeExtent.parse, .{}).asValue()) |extent| {
+            // The `ellipse` keyword is optional, but only if the `circle` keyword is not present.
+            // If it is, then we'll re-parse as a circle.
+            if (input.tryParse(css.Parser.expectIdentMatching, .{"circle"}).isOk()) {
+                return .{ .err = input.newErrorForNextToken() };
+            }
+            _ = input.tryParse(css.Parser.expectIdentMatching, .{"ellipse"});
+            return .{ .result = Ellipse{ .extent = extent } };
+        }
+
+        if (input.tryParse(LengthPercentage.parse, .{}).asValue()) |x| {
+            const y = switch (LengthPercentage.parse(input)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            };
+            // The `ellipse` keyword is optional if there are two lengths.
+            _ = input.tryParse(css.Parser.expectIdentMatching, .{"ellipse"});
+            return .{ .result = Ellipse{ .size = .{ .x = x, .y = y } } };
+        }
+
+        if (input.tryParse(css.Parser.expectIdentMatching, .{"ellipse"}).isOk()) {
+            if (input.tryParse(ShapeExtent.parse, .{}).asValue()) |extent| {
+                return .{ .result = Ellipse{ .extent = extent } };
+            }
+
+            if (input.tryParse(LengthPercentage.parse, .{}).asValue()) |x| {
+                const y = switch (LengthPercentage.parse(input)) {
+                    .result => |vv| vv,
+                    .err => |e| return .{ .err = e },
+                };
+                return .{ .result = Ellipse{ .size = .{ .x = x, .y = y } } };
+            }
+
+            // Assume `farthest-corner` if only the `ellipse` keyword is present.
+            return .{ .result = Ellipse{ .extent = .@"farthest-corner" } };
+        }
+
+        return .{ .err = input.newErrorForNextToken() };
+    }
+
+    pub fn toCss(this: *const Ellipse, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        // The `ellipse` keyword is optional, so we don't emit it.
+        return switch (this.*) {
+            .size => |*s| {
+                try s.x.toCss(W, dest);
+                try dest.writeChar(' ');
+                return try s.y.toCss(W, dest);
+            },
+            .extent => |*e| try e.toCss(W, dest),
+        };
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(this: *const Ellipse, other: *const Ellipse) bool {
+        return this.size.x.eql(&other.size.x) and this.size.y.eql(&other.size.y) and this.extent.eql(&other.extent);
+    }
+};
+
+pub const ShapeExtent = enum {
+    /// The closest side of the box to the gradient's center.
+    @"closest-side",
+    /// The farthest side of the box from the gradient's center.
+    @"farthest-side",
+    /// The closest corner of the box to the gradient's center.
+    @"closest-corner",
+    /// The farthest corner of the box from the gradient's center.
+    @"farthest-corner",
+
+    pub fn eql(this: *const ShapeExtent, other: *const ShapeExtent) bool {
+        return this.* == other.*;
+    }
+
+    pub fn asStr(this: *const @This()) []const u8 {
+        return css.enum_property_util.asStr(@This(), this);
+    }
+
+    pub fn parse(input: *css.Parser) Result(@This()) {
+        return css.enum_property_util.parse(@This(), input);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+        return css.enum_property_util.toCss(@This(), this, W, dest);
+    }
+};
+
+/// A circle ending shape for a `radial-gradient()`.
+///
+/// See [RadialGradient](RadialGradient).
+pub const Circle = union(enum) {
+    /// A circle with a specified radius.
+    radius: Length,
+    /// A shape extent keyword.
+    extent: ShapeExtent,
+
+    pub fn parse(input: *css.Parser) Result(Circle) {
+        if (input.tryParse(ShapeExtent.parse, .{}).asValue()) |extent| {
+            // The `circle` keyword is required. If it's not there, then it's an ellipse.
+            if (input.expectIdentMatching("circle").asErr()) |e| return .{ .err = e };
+            return .{ .result = Circle{ .extent = extent } };
+        }
+
+        if (input.tryParse(Length.parse, .{}).asValue()) |length| {
+            // The `circle` keyword is optional if there is only a single length.
+            // We are assuming here that Ellipse.parse ran first.
+            _ = input.tryParse(css.Parser.expectIdentMatching, .{"circle"});
+            return .{ .result = Circle{ .radius = length } };
+        }
+
+        if (input.tryParse(css.Parser.expectIdentMatching, .{"circle"}).isOk()) {
+            if (input.tryParse(ShapeExtent.parse, .{}).asValue()) |extent| {
+                return .{ .result = Circle{ .extent = extent } };
+            }
+
+            if (input.tryParse(Length.parse, .{}).asValue()) |length| {
+                return .{ .result = Circle{ .radius = length } };
+            }
+
+            // If only the `circle` keyword was given, default to `farthest-corner`.
+            return .{ .result = Circle{ .extent = .@"farthest-corner" } };
+        }
+
+        return .{ .err = input.newErrorForNextToken() };
+    }
+
+    pub fn toCss(this: *const Circle, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        return switch (this.*) {
+            .radius => |r| try r.toCss(W, dest),
+            .extent => |extent| {
+                try dest.writeStr("circle");
+                if (extent != .@"farthest-corner") {
+                    try dest.writeChar(' ');
+                    try extent.toCss(W, dest);
+                }
+            },
+        };
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(this: *const Circle, other: *const Circle) bool {
+        return this.radius.eql(&other.radius) and this.extent.eql(&other.extent);
+    }
+};
+
+pub fn parseItems(comptime D: type, input: *css.Parser) Result(ArrayList(GradientItem(D))) {
+    var items = ArrayList(GradientItem(D)){};
+    var seen_stop = false;
+
+    while (true) {
+        const Closure = struct { items: *ArrayList(GradientItem(D)), seen_stop: *bool };
+        if (input.parseUntilBefore(
+            css.Delimiters{ .comma = true },
+            void,
+            Closure{ .items = &items, .seen_stop = &seen_stop },
+            struct {
+                fn parse(closure: Closure, i: *css.Parser) Result(void) {
+                    if (closure.seen_stop.*) {
+                        if (i.tryParse(comptime css.generic.parseFor(D), .{}).asValue()) |hint| {
+                            closure.seen_stop.* = false;
+                            closure.items.append(i.allocator(), .{ .hint = hint }) catch bun.outOfMemory();
+                            return Result(void).success;
+                        }
+                    }
+
+                    const stop = switch (ColorStop(D).parse(i)) {
+                        .result => |vv| vv,
+                        .err => |e| return .{ .err = e },
+                    };
+
+                    if (i.tryParse(comptime css.generic.parseFor(D), .{}).asValue()) |position| {
+                        const color = stop.color.deepClone(i.allocator());
+                        closure.items.append(i.allocator(), .{ .color_stop = stop }) catch bun.outOfMemory();
+                        closure.items.append(i.allocator(), .{ .color_stop = .{
+                            .color = color,
+                            .position = position,
+                        } }) catch bun.outOfMemory();
+                    } else {
+                        closure.items.append(i.allocator(), .{ .color_stop = stop }) catch bun.outOfMemory();
+                    }
+
+                    closure.seen_stop.* = true;
+                    return Result(void).success;
+                }
+            }.parse,
+        ).asErr()) |e| return .{ .err = e };
+
+        if (input.next().asValue()) |tok| {
+            if (tok.* == .comma) continue;
+            bun.unreachablePanic("expected a comma after parsing a gradient", .{});
+        } else {
+            break;
+        }
+    }
+
+    return .{ .result = items };
+}
+
+pub fn serializeItems(
+    comptime D: type,
+    items: *const ArrayList(GradientItem(D)),
+    comptime W: type,
+    dest: *Printer(W),
+) PrintErr!void {
+    var first = true;
+    var last: ?*const GradientItem(D) = null;
+    for (items.items) |*item| {
+        // Skip useless hints
+        if (item.* == .hint and item.hint == .percentage and item.hint.percentage.v == 0.5) {
+            continue;
+        }
+
+        // Use double position stop if the last stop is the same color and all targets support it.
+        if (last) |prev| {
+            if (!dest.targets.shouldCompile(.double_position_gradients, .{ .double_position_gradients = true })) {
+                if (prev.* == .color_stop and prev.color_stop.position != null and
+                    item.* == .color_stop and item.color_stop.position != null and
+                    prev.color_stop.color.eql(&item.color_stop.color))
+                {
+                    try dest.writeChar(' ');
+                    try item.color_stop.position.?.toCss(W, dest);
+                    last = null;
+                    continue;
+                }
+            }
+        }
+
+        if (first) {
+            first = false;
+        } else {
+            try dest.delim(',', false);
+        }
+        try item.toCss(W, dest);
+        last = item;
+    }
+}
+
+pub fn convertStopsToWebkit(allocator: Allocator, items: *const ArrayList(GradientItem(LengthPercentage))) ?ArrayList(WebKitColorStop) {
+    var stops: ArrayList(WebKitColorStop) = ArrayList(WebKitColorStop).initCapacity(allocator, items.items.len) catch bun.outOfMemory();
+    for (items.items, 0..) |*item, i| {
+        switch (item.*) {
+            .color_stop => |*stop| {
+                // webkit stops must always be percentage based, not length based.
+                const position: f32 = if (stop.position) |pos| brk: {
+                    break :brk switch (pos) {
+                        .percentage => |percentage| percentage.v,
+                        else => {
+                            stops.deinit(allocator);
+                            return null;
+                        },
+                    };
+                } else if (i == 0) brk: {
+                    break :brk 0.0;
+                } else if (i == items.items.len - 1) brk: {
+                    break :brk 1.0;
+                } else {
+                    stops.deinit(allocator);
+                    return null;
+                };
+
+                stops.append(allocator, .{
+                    .color = stop.color.deepClone(allocator),
+                    .position = position,
+                }) catch return null;
+            },
+            else => return null,
+        }
+    }
+
+    return stops;
+}
diff --git a/src/css/values/ident.zig b/src/css/values/ident.zig
new file mode 100644
index 0000000000..ee861540c9
--- /dev/null
+++ b/src/css/values/ident.zig
@@ -0,0 +1,197 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const bun = @import("root").bun;
+const logger = bun.logger;
+const Log = logger.Log;
+
+pub const css = @import("../css_parser.zig");
+pub const Result = css.Result;
+pub const Printer = css.Printer;
+pub const PrintErr = css.PrintErr;
+
+pub const Specifier = css.css_properties.css_modules.Specifier;
+
+/// A CSS [`<dashed-ident>`](https://www.w3.org/TR/css-values-4/#dashed-idents) reference.
+///
+/// Dashed idents are used in cases where an identifier can be either author defined _or_ CSS-defined.
+/// Author defined idents must start with two dash characters ("--") or parsing will fail.
+///
+/// In CSS modules, when the `dashed_idents` option is enabled, the identifier may be followed by the
+/// `from` keyword and an argument indicating where the referenced identifier is declared (e.g. a filename).
+pub const DashedIdentReference = struct {
+    /// The referenced identifier.
+    ident: DashedIdent,
+    /// CSS modules extension: the filename where the variable is defined.
+    /// Only enabled when the CSS modules `dashed_idents` option is turned on.
+    from: ?Specifier,
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub fn parseWithOptions(input: *css.Parser, options: *const css.ParserOptions) Result(DashedIdentReference) {
+        const ident = switch (DashedIdentFns.parse(input)) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+
+        const from = if (options.css_modules != null and options.css_modules.?.dashed_idents) from: {
+            if (input.tryParse(css.Parser.expectIdentMatching, .{"from"}).isOk()) break :from switch (Specifier.parse(input)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            };
+            break :from null;
+        } else null;
+
+        return .{ .result = DashedIdentReference{ .ident = ident, .from = from } };
+    }
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+        if (dest.css_module) |*css_module| {
+            if (css_module.config.dashed_idents) {
+                if (css_module.referenceDashed(this.ident.v, &this.from, dest.loc.source_index)) |name| {
+                    try dest.writeStr("--");
+                    css.serializer.serializeName(name, dest) catch return dest.addFmtError();
+                    return;
+                }
+            }
+        }
+
+        return dest.writeDashedIdent(&this.ident, false);
+    }
+
+    pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+        return css.implementHash(@This(), this, hasher);
+    }
+};
+
+pub const DashedIdentFns = DashedIdent;
+/// A CSS [`<dashed-ident>`](https://www.w3.org/TR/css-values-4/#dashed-idents) declaration.
+///
+/// Dashed idents are used in cases where an identifier can be either author defined _or_ CSS-defined.
+/// Author defined idents must start with two dash characters ("--") or parsing will fail.
+pub const DashedIdent = struct {
+    v: []const u8,
+
+    pub fn HashMap(comptime V: type) type {
+        return std.ArrayHashMapUnmanaged(
+            DashedIdent,
+            V,
+            struct {
+                pub fn hash(_: @This(), s: DashedIdent) u32 {
+                    return std.array_hash_map.hashString(s.v);
+                }
+                pub fn eql(_: @This(), a: DashedIdent, b: DashedIdent, _: usize) bool {
+                    return bun.strings.eql(a, b);
+                }
+            },
+            false,
+        );
+    }
+
+    pub fn parse(input: *css.Parser) Result(DashedIdent) {
+        const location = input.currentSourceLocation();
+        const ident = switch (input.expectIdent()) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+        if (!bun.strings.startsWith(ident, "--")) return .{ .err = location.newUnexpectedTokenError(.{ .ident = ident }) };
+
+        return .{ .result = .{ .v = ident } };
+    }
+
+    const This = @This();
+
+    pub fn toCss(this: *const DashedIdent, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        return dest.writeDashedIdent(this, true);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+        return css.implementHash(@This(), this, hasher);
+    }
+};
+
+/// A CSS [`<ident>`](https://www.w3.org/TR/css-values-4/#css-css-identifier).
+pub const IdentFns = Ident;
+pub const Ident = struct {
+    v: []const u8,
+
+    pub fn parse(input: *css.Parser) Result(Ident) {
+        const ident = switch (input.expectIdent()) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+        return .{ .result = .{ .v = ident } };
+    }
+
+    pub fn toCss(this: *const Ident, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        return css.serializer.serializeIdentifier(this.v, dest) catch return dest.addFmtError();
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+        return css.implementHash(@This(), this, hasher);
+    }
+};
+
+pub const CustomIdentFns = CustomIdent;
+pub const CustomIdent = struct {
+    v: []const u8,
+
+    pub fn parse(input: *css.Parser) Result(CustomIdent) {
+        const location = input.currentSourceLocation();
+        const ident = switch (input.expectIdent()) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+        // css.todo_stuff.match_ignore_ascii_case
+        const valid = !(bun.strings.eqlCaseInsensitiveASCIIICheckLength(ident, "initial") or
+            bun.strings.eqlCaseInsensitiveASCIIICheckLength(ident, "inherit") or
+            bun.strings.eqlCaseInsensitiveASCIIICheckLength(ident, "unset") or
+            bun.strings.eqlCaseInsensitiveASCIIICheckLength(ident, "default") or
+            bun.strings.eqlCaseInsensitiveASCIIICheckLength(ident, "revert") or
+            bun.strings.eqlCaseInsensitiveASCIIICheckLength(ident, "revert-layer"));
+
+        if (!valid) return .{ .err = location.newUnexpectedTokenError(.{ .ident = ident }) };
+        return .{ .result = .{ .v = ident } };
+    }
+
+    const This = @This();
+
+    pub fn toCss(this: *const CustomIdent, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        return @This().toCssWithOptions(this, W, dest, true);
+    }
+
+    /// Write the custom ident to CSS.
+    pub fn toCssWithOptions(
+        this: *const CustomIdent,
+        comptime W: type,
+        dest: *Printer(W),
+        enabled_css_modules: bool,
+    ) PrintErr!void {
+        const css_module_custom_idents_enabled = enabled_css_modules and
+            if (dest.css_module) |*css_module|
+            css_module.config.custom_idents
+        else
+            false;
+        return dest.writeIdent(this.v, css_module_custom_idents_enabled);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+        return css.implementHash(@This(), this, hasher);
+    }
+};
+
+/// A list of CSS [`<custom-ident>`](https://www.w3.org/TR/css-values-4/#custom-idents) values.
+pub const CustomIdentList = css.SmallList(CustomIdent, 1);
diff --git a/src/css/values/image.zig b/src/css/values/image.zig
new file mode 100644
index 0000000000..b19fe98efe
--- /dev/null
+++ b/src/css/values/image.zig
@@ -0,0 +1,367 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const bun = @import("root").bun;
+pub const css = @import("../css_parser.zig");
+const Result = css.Result;
+const ArrayList = std.ArrayListUnmanaged;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const CSSNumber = css.css_values.number.CSSNumber;
+const CSSNumberFns = css.css_values.number.CSSNumberFns;
+const Url = css.css_values.url.Url;
+const Gradient = css.css_values.gradient.Gradient;
+const Resolution = css.css_values.resolution.Resolution;
+const VendorPrefix = css.VendorPrefix;
+const UrlDependency = css.dependencies.UrlDependency;
+
+/// A CSS [`<image>`](https://www.w3.org/TR/css-images-3/#image-values) value.
+pub const Image = union(enum) {
+    /// The `none` keyword.
+    none,
+    /// A `url()`.
+    url: Url,
+    /// A gradient.
+    gradient: *Gradient,
+    /// An `image-set()`.
+    image_set: ImageSet,
+
+    pub usingnamespace css.DeriveParse(@This());
+    pub usingnamespace css.DeriveToCss(@This());
+
+    pub fn deinit(_: *@This(), _: std.mem.Allocator) void {
+        // TODO: implement this
+        // Right now not implementing this.
+        // It is not a bug to implement this since all memory allocated in CSS parser is allocated into arena.
+    }
+
+    pub fn isCompatible(this: *const @This(), browsers: css.targets.Browsers) bool {
+        return switch (this.*) {
+            .gradient => |g| switch (g.*) {
+                .linear => |linear| css.Feature.isCompatible(.linear_gradient, browsers) and linear.isCompatible(browsers),
+                .repeating_linear => |repeating_linear| css.Feature.isCompatible(.repeating_linear_gradient, browsers) and repeating_linear.isCompatible(browsers),
+                .radial => |radial| css.Feature.isCompatible(.radial_gradient, browsers) and radial.isCompatible(browsers),
+                .repeating_radial => |repeating_radial| css.Feature.isCompatible(.repeating_radial_gradient, browsers) and repeating_radial.isCompatible(browsers),
+                .conic => |conic| css.Feature.isCompatible(.conic_gradient, browsers) and conic.isCompatible(browsers),
+                .repeating_conic => |repeating_conic| css.Feature.isCompatible(.repeating_conic_gradient, browsers) and repeating_conic.isCompatible(browsers),
+                .@"webkit-gradient" => css.prefixes.Feature.isWebkitGradient(browsers),
+            },
+            .image_set => |image_set| image_set.isCompatible(browsers),
+            .url, .none => true,
+        };
+    }
+
+    pub fn getPrefixed(this: *const @This(), allocator: Allocator, prefix: css.VendorPrefix) Image {
+        return switch (this.*) {
+            .gradient => |grad| .{ .gradient = bun.create(allocator, Gradient, grad.getPrefixed(allocator, prefix)) },
+            .image_set => |image_set| .{ .image_set = image_set.getPrefixed(allocator, prefix) },
+            else => this.deepClone(allocator),
+        };
+    }
+
+    pub fn getNecessaryPrefixes(this: *const @This(), targets: css.targets.Targets) css.VendorPrefix {
+        return switch (this.*) {
+            .gradient => |grad| grad.getNecessaryPrefixes(targets),
+            .image_set => |*image_set| image_set.getNecessaryPrefixes(targets),
+            else => css.VendorPrefix{ .none = true },
+        };
+    }
+
+    pub fn hasVendorPrefix(this: *const @This()) bool {
+        const prefix = this.getVendorPrefix();
+        return !prefix.isEmpty() and !prefix.eq(VendorPrefix{ .none = true });
+    }
+
+    /// Returns the vendor prefix used in the image value.
+    pub fn getVendorPrefix(this: *const @This()) VendorPrefix {
+        return switch (this.*) {
+            .gradient => |a| a.getVendorPrefix(),
+            .image_set => |a| a.getVendorPrefix(),
+            else => VendorPrefix.empty(),
+        };
+    }
+
+    /// Needed to satisfy ImageFallback interface
+    pub fn getImage(this: *const @This()) *const Image {
+        return this;
+    }
+
+    /// Needed to satisfy ImageFallback interface
+    pub fn withImage(_: *const @This(), _: Allocator, image: Image) @This() {
+        return image;
+    }
+
+    pub fn default() Image {
+        return .none;
+    }
+
+    pub inline fn eql(this: *const Image, other: *const Image) bool {
+        return switch (this.*) {
+            .none => switch (other.*) {
+                .none => true,
+                else => false,
+            },
+            .url => |*a| switch (other.*) {
+                .url => a.eql(&other.url),
+                else => false,
+            },
+            .image_set => |*a| switch (other.*) {
+                .image_set => a.eql(&other.image_set),
+                else => false,
+            },
+            .gradient => |a| switch (other.*) {
+                .gradient => a.eql(other.gradient),
+                else => false,
+            },
+        };
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    /// Returns a legacy `-webkit-gradient()` value for the image.
+    ///
+    /// May return an error in case the gradient cannot be converted.
+    pub fn getLegacyWebkit(this: *const @This(), allocator: Allocator) ?Image {
+        return switch (this.*) {
+            .gradient => |gradient| Image{ .gradient = bun.create(allocator, Gradient, gradient.getLegacyWebkit(allocator) orelse return null) },
+            else => this.deepClone(allocator),
+        };
+    }
+
+    pub fn getFallback(this: *const @This(), allocator: Allocator, kind: css.ColorFallbackKind) Image {
+        return switch (this.*) {
+            .gradient => |grad| .{ .gradient = bun.create(allocator, Gradient, grad.getFallback(allocator, kind)) },
+            else => this.deepClone(allocator),
+        };
+    }
+
+    pub fn getNecessaryFallbacks(this: *const @This(), targets: css.targets.Targets) css.ColorFallbackKind {
+        return switch (this.*) {
+            .gradient => |grad| grad.getNecessaryFallbacks(targets),
+            else => css.ColorFallbackKind.empty(),
+        };
+    }
+
+    // pub fn parse(input: *css.Parser) Result(Image) {
+    //     _ = input; // autofix
+    //     @panic(css.todo_stuff.depth);
+    // }
+
+    // pub fn toCss(this: *const Image, comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+    //     _ = this; // autofix
+    //     _ = dest; // autofix
+    //     @panic(css.todo_stuff.depth);
+    // }
+};
+
+/// A CSS [`image-set()`](https://drafts.csswg.org/css-images-4/#image-set-notation) value.
+///
+/// `image-set()` allows the user agent to choose between multiple versions of an image to
+/// display the most appropriate resolution or file type that it supports.
+pub const ImageSet = struct {
+    /// The image options to choose from.
+    options: ArrayList(ImageSetOption),
+
+    /// The vendor prefix for the `image-set()` function.
+    vendor_prefix: VendorPrefix,
+
+    pub fn parse(input: *css.Parser) Result(ImageSet) {
+        const location = input.currentSourceLocation();
+        const f = switch (input.expectFunction()) {
+            .result => |v| v,
+            .err => |e| return .{ .err = e },
+        };
+        const vendor_prefix = vendor_prefix: {
+            // todo_stuff.match_ignore_ascii_case
+            if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("image-set", f)) {
+                break :vendor_prefix VendorPrefix{ .none = true };
+            } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("-webkit-image-set", f)) {
+                break :vendor_prefix VendorPrefix{ .webkit = true };
+            } else return .{ .err = location.newUnexpectedTokenError(.{ .ident = f }) };
+        };
+
+        const Fn = struct {
+            pub fn parseNestedBlockFn(_: void, i: *css.Parser) Result(ArrayList(ImageSetOption)) {
+                return i.parseCommaSeparated(ImageSetOption, ImageSetOption.parse);
+            }
+        };
+
+        const options = switch (input.parseNestedBlock(ArrayList(ImageSetOption), {}, Fn.parseNestedBlockFn)) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+
+        return .{ .result = ImageSet{
+            .options = options,
+            .vendor_prefix = vendor_prefix,
+        } };
+    }
+
+    pub fn toCss(this: *const ImageSet, comptime W: type, dest: *css.Printer(W)) PrintErr!void {
+        try this.vendor_prefix.toCss(W, dest);
+        try dest.writeStr("image-set(");
+        var first = true;
+        for (this.options.items) |*option| {
+            if (first) {
+                first = false;
+            } else {
+                try dest.delim(',', false);
+            }
+            try option.toCss(W, dest, this.vendor_prefix.neq(VendorPrefix{ .none = true }));
+        }
+        return dest.writeChar(')');
+    }
+
+    pub fn isCompatible(this: *const @This(), browsers: css.targets.Browsers) bool {
+        return css.Feature.isCompatible(.image_set, browsers) and
+            for (this.options.items) |opt|
+        {
+            if (!opt.image.isCompatible(browsers)) break false;
+        } else true;
+    }
+
+    /// Returns the `image-set()` value with the given vendor prefix.
+    pub fn getPrefixed(this: *const @This(), allocator: Allocator, prefix: css.VendorPrefix) ImageSet {
+        return ImageSet{
+            .options = css.deepClone(ImageSetOption, allocator, &this.options),
+            .vendor_prefix = prefix,
+        };
+    }
+
+    pub fn eql(this: *const ImageSet, other: *const ImageSet) bool {
+        return this.vendor_prefix.eql(other.vendor_prefix) and css.generic.eqlList(ImageSetOption, &this.options, &other.options);
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn getVendorPrefix(this: *const @This()) VendorPrefix {
+        return this.vendor_prefix;
+    }
+
+    /// Returns the vendor prefixes needed for the given browser targets.
+    pub fn getNecessaryPrefixes(this: *const @This(), targets: css.targets.Targets) css.VendorPrefix {
+        return targets.prefixes(this.vendor_prefix, css.prefixes.Feature.image_set);
+    }
+};
+
+/// An image option within the `image-set()` function. See [ImageSet](ImageSet).
+pub const ImageSetOption = struct {
+    /// The image for this option.
+    image: Image,
+    /// The resolution of the image.
+    resolution: Resolution,
+    /// The mime type of the image.
+    file_type: ?[]const u8,
+
+    pub fn parse(input: *css.Parser) Result(ImageSetOption) {
+        const start_position = input.input.tokenizer.getPosition();
+        const loc = input.currentSourceLocation();
+        const image = if (input.tryParse(css.Parser.expectUrlOrString, .{}).asValue()) |url| brk: {
+            const record_idx = switch (input.addImportRecordForUrl(
+                url,
+                start_position,
+            )) {
+                .result => |idx| idx,
+                .err => |e| return .{ .err = e },
+            };
+            break :brk Image{ .url = Url{
+                .import_record_idx = record_idx,
+                .loc = css.dependencies.Location.fromSourceLocation(loc),
+            } };
+        } else switch (@call(.auto, @field(Image, "parse"), .{input})) { // For some reason, `Image.parse` makes zls crash, using this syntax until that's fixed
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+
+        const resolution: Resolution, const file_type: ?[]const u8 = if (input.tryParse(Resolution.parse, .{}).asValue()) |res| brk: {
+            const file_type = input.tryParse(parseFileType, .{}).asValue();
+            break :brk .{ res, file_type };
+        } else brk: {
+            const file_type = input.tryParse(parseFileType, .{}).asValue();
+            const resolution = input.tryParse(Resolution.parse, .{}).unwrapOr(Resolution{ .dppx = 1.0 });
+            break :brk .{ resolution, file_type };
+        };
+
+        return .{ .result = ImageSetOption{
+            .image = image,
+            .resolution = resolution,
+            .file_type = if (file_type) |x| x else null,
+        } };
+    }
+
+    pub fn toCss(
+        this: *const ImageSetOption,
+        comptime W: type,
+        dest: *css.Printer(W),
+        is_prefixed: bool,
+    ) PrintErr!void {
+        if (this.image == .url and !is_prefixed) {
+            const _dep: ?UrlDependency = if (dest.dependencies != null)
+                UrlDependency.new(dest.allocator, &this.image.url, dest.filename(), try dest.getImportRecords())
+            else
+                null;
+
+            if (_dep) |dep| {
+                css.serializer.serializeString(dep.placeholder, dest) catch return dest.addFmtError();
+                if (dest.dependencies) |*dependencies| {
+                    dependencies.append(
+                        dest.allocator,
+                        .{ .url = dep },
+                    ) catch bun.outOfMemory();
+                }
+            } else {
+                css.serializer.serializeString(try dest.getImportRecordUrl(this.image.url.import_record_idx), dest) catch return dest.addFmtError();
+            }
+        } else {
+            try this.image.toCss(W, dest);
+        }
+
+        // TODO: Throwing an error when `self.resolution = Resolution::Dppx(0.0)`
+        // TODO: -webkit-image-set() does not support `<image()> | <image-set()> |
+        // <cross-fade()> | <element()> | <gradient>` and `type(<string>)`.
+        try dest.writeChar(' ');
+
+        // Safari only supports the x resolution unit in image-set().
+        // In other places, x was added as an alias later.
+        // Temporarily ignore the targets while printing here.
+        const targets = targets: {
+            const targets = dest.targets;
+            dest.targets = .{};
+            break :targets targets;
+        };
+        try this.resolution.toCss(W, dest);
+        dest.targets = targets;
+
+        if (this.file_type) |file_type| {
+            try dest.writeStr(" type(");
+            css.serializer.serializeString(file_type, dest) catch return dest.addFmtError();
+            try dest.writeChar(')');
+        }
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(lhs: *const ImageSetOption, rhs: *const ImageSetOption) bool {
+        return lhs.image.eql(&rhs.image) and lhs.resolution.eql(&rhs.resolution) and (brk: {
+            if (lhs.file_type != null and rhs.file_type != null) {
+                break :brk bun.strings.eql(lhs.file_type.?, rhs.file_type.?);
+            }
+            break :brk false;
+        });
+    }
+};
+
+fn parseFileType(input: *css.Parser) Result([]const u8) {
+    if (input.expectFunctionMatching("type").asErr()) |e| return .{ .err = e };
+    const Fn = struct {
+        pub fn parseNestedBlockFn(_: void, i: *css.Parser) Result([]const u8) {
+            return i.expectString();
+        }
+    };
+    return input.parseNestedBlock([]const u8, {}, Fn.parseNestedBlockFn);
+}
diff --git a/src/css/values/length.zig b/src/css/values/length.zig
new file mode 100644
index 0000000000..3cd1fc1b44
--- /dev/null
+++ b/src/css/values/length.zig
@@ -0,0 +1,800 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const bun = @import("root").bun;
+pub const css = @import("../css_parser.zig");
+const Result = css.Result;
+const ArrayList = std.ArrayListUnmanaged;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const CSSNumber = css.css_values.number.CSSNumber;
+const CSSNumberFns = css.css_values.number.CSSNumberFns;
+const Calc = css.css_values.calc.Calc;
+const MathFunction = css.css_values.calc.MathFunction;
+const DimensionPercentage = css.css_values.percentage.DimensionPercentage;
+
+/// Either a [`<length>`](https://www.w3.org/TR/css-values-4/#lengths) or a [`<number>`](https://www.w3.org/TR/css-values-4/#numbers).
+pub const LengthOrNumber = union(enum) {
+    /// A number.
+    number: CSSNumber,
+    /// A length.
+    length: Length,
+
+    pub usingnamespace css.DeriveParse(@This());
+    pub usingnamespace css.DeriveToCss(@This());
+
+    pub fn default() LengthOrNumber {
+        return .{ .number = 0.0 };
+    }
+
+    pub fn eql(this: *const @This(), other: *const @This()) bool {
+        return switch (this.*) {
+            .number => |*n| n.* == other.number,
+            .length => |*l| l.eql(&other.length),
+        };
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+pub const LengthPercentage = DimensionPercentage(LengthValue);
+/// Either a [`<length-percentage>`](https://www.w3.org/TR/css-values-4/#typedef-length-percentage), or the `auto` keyword.
+pub const LengthPercentageOrAuto = union(enum) {
+    /// The `auto` keyword.
+    auto,
+    /// A [`<length-percentage>`](https://www.w3.org/TR/css-values-4/#typedef-length-percentage).
+    length: LengthPercentage,
+
+    pub usingnamespace css.DeriveParse(@This());
+    pub usingnamespace css.DeriveToCss(@This());
+
+    pub fn isCompatible(this: *const @This(), browsers: css.targets.Browsers) bool {
+        return switch (this.*) {
+            .length => this.length.isCompatible(browsers),
+            else => true,
+        };
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+
+    pub inline fn deepClone(this: *const @This(), allocator: Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+const PX_PER_IN: f32 = 96.0;
+const PX_PER_CM: f32 = PX_PER_IN / 2.54;
+const PX_PER_MM: f32 = PX_PER_CM / 10.0;
+const PX_PER_Q: f32 = PX_PER_CM / 40.0;
+const PX_PER_PT: f32 = PX_PER_IN / 72.0;
+const PX_PER_PC: f32 = PX_PER_IN / 6.0;
+
+pub const LengthValue = union(enum) {
+    // https://www.w3.org/TR/css-values-4/#absolute-lengths
+    /// A length in pixels.
+    px: CSSNumber,
+    /// A length in inches. 1in = 96px.
+    in: CSSNumber,
+    /// A length in centimeters. 1cm = 96px / 2.54.
+    cm: CSSNumber,
+    /// A length in millimeters. 1mm = 1/10th of 1cm.
+    mm: CSSNumber,
+    /// A length in quarter-millimeters. 1Q = 1/40th of 1cm.
+    q: CSSNumber,
+    /// A length in points. 1pt = 1/72nd of 1in.
+    pt: CSSNumber,
+    /// A length in picas. 1pc = 1/6th of 1in.
+    pc: CSSNumber,
+
+    // https://www.w3.org/TR/css-values-4/#font-relative-lengths
+    /// A length in the `em` unit. An `em` is equal to the computed value of the
+    /// font-size property of the element on which it is used.
+    em: CSSNumber,
+    /// A length in the `rem` unit. A `rem` is equal to the computed value of the
+    /// `em` unit on the root element.
+    rem: CSSNumber,
+    /// A length in `ex` unit. An `ex` is equal to the x-height of the font.
+    ex: CSSNumber,
+    /// A length in the `rex` unit. A `rex` is equal to the value of the `ex` unit on the root element.
+    rex: CSSNumber,
+    /// A length in the `ch` unit. A `ch` is equal to the width of the zero ("0") character in the current font.
+    ch: CSSNumber,
+    /// A length in the `rch` unit. An `rch` is equal to the value of the `ch` unit on the root element.
+    rch: CSSNumber,
+    /// A length in the `cap` unit. A `cap` is equal to the cap-height of the font.
+    cap: CSSNumber,
+    /// A length in the `rcap` unit. An `rcap` is equal to the value of the `cap` unit on the root element.
+    rcap: CSSNumber,
+    /// A length in the `ic` unit. An `ic` is equal to the width of the “水” (CJK water ideograph) character in the current font.
+    ic: CSSNumber,
+    /// A length in the `ric` unit. An `ric` is equal to the value of the `ic` unit on the root element.
+    ric: CSSNumber,
+    /// A length in the `lh` unit. An `lh` is equal to the computed value of the `line-height` property.
+    lh: CSSNumber,
+    /// A length in the `rlh` unit. An `rlh` is equal to the value of the `lh` unit on the root element.
+    rlh: CSSNumber,
+
+    // https://www.w3.org/TR/css-values-4/#viewport-relative-units
+    /// A length in the `vw` unit. A `vw` is equal to 1% of the [viewport width](https://www.w3.org/TR/css-values-4/#ua-default-viewport-size).
+    vw: CSSNumber,
+    /// A length in the `lvw` unit. An `lvw` is equal to 1% of the [large viewport width](https://www.w3.org/TR/css-values-4/#large-viewport-size).
+    lvw: CSSNumber,
+    /// A length in the `svw` unit. An `svw` is equal to 1% of the [small viewport width](https://www.w3.org/TR/css-values-4/#small-viewport-size).
+    svw: CSSNumber,
+    /// A length in the `dvw` unit. An `dvw` is equal to 1% of the [dynamic viewport width](https://www.w3.org/TR/css-values-4/#dynamic-viewport-size).
+    dvw: CSSNumber,
+    /// A length in the `cqw` unit. An `cqw` is equal to 1% of the [query container](https://drafts.csswg.org/css-contain-3/#query-container) width.
+    cqw: CSSNumber,
+
+    /// A length in the `vh` unit. A `vh` is equal to 1% of the [viewport height](https://www.w3.org/TR/css-values-4/#ua-default-viewport-size).
+    vh: CSSNumber,
+    /// A length in the `lvh` unit. An `lvh` is equal to 1% of the [large viewport height](https://www.w3.org/TR/css-values-4/#large-viewport-size).
+    lvh: CSSNumber,
+    /// A length in the `svh` unit. An `svh` is equal to 1% of the [small viewport height](https://www.w3.org/TR/css-values-4/#small-viewport-size).
+    svh: CSSNumber,
+    /// A length in the `dvh` unit. An `dvh` is equal to 1% of the [dynamic viewport height](https://www.w3.org/TR/css-values-4/#dynamic-viewport-size).
+    dvh: CSSNumber,
+    /// A length in the `cqh` unit. An `cqh` is equal to 1% of the [query container](https://drafts.csswg.org/css-contain-3/#query-container) height.
+    cqh: CSSNumber,
+
+    /// A length in the `vi` unit. A `vi` is equal to 1% of the [viewport size](https://www.w3.org/TR/css-values-4/#ua-default-viewport-size)
+    /// in the box's [inline axis](https://www.w3.org/TR/css-writing-modes-4/#inline-axis).
+    vi: CSSNumber,
+    /// A length in the `svi` unit. A `svi` is equal to 1% of the [small viewport size](https://www.w3.org/TR/css-values-4/#small-viewport-size)
+    /// in the box's [inline axis](https://www.w3.org/TR/css-writing-modes-4/#inline-axis).
+    svi: CSSNumber,
+    /// A length in the `lvi` unit. A `lvi` is equal to 1% of the [large viewport size](https://www.w3.org/TR/css-values-4/#large-viewport-size)
+    /// in the box's [inline axis](https://www.w3.org/TR/css-writing-modes-4/#inline-axis).
+    lvi: CSSNumber,
+    /// A length in the `dvi` unit. A `dvi` is equal to 1% of the [dynamic viewport size](https://www.w3.org/TR/css-values-4/#dynamic-viewport-size)
+    /// in the box's [inline axis](https://www.w3.org/TR/css-writing-modes-4/#inline-axis).
+    dvi: CSSNumber,
+    /// A length in the `cqi` unit. An `cqi` is equal to 1% of the [query container](https://drafts.csswg.org/css-contain-3/#query-container) inline size.
+    cqi: CSSNumber,
+
+    /// A length in the `vb` unit. A `vb` is equal to 1% of the [viewport size](https://www.w3.org/TR/css-values-4/#ua-default-viewport-size)
+    /// in the box's [block axis](https://www.w3.org/TR/css-writing-modes-4/#block-axis).
+    vb: CSSNumber,
+    /// A length in the `svb` unit. A `svb` is equal to 1% of the [small viewport size](https://www.w3.org/TR/css-values-4/#small-viewport-size)
+    /// in the box's [block axis](https://www.w3.org/TR/css-writing-modes-4/#block-axis).
+    svb: CSSNumber,
+    /// A length in the `lvb` unit. A `lvb` is equal to 1% of the [large viewport size](https://www.w3.org/TR/css-values-4/#large-viewport-size)
+    /// in the box's [block axis](https://www.w3.org/TR/css-writing-modes-4/#block-axis).
+    lvb: CSSNumber,
+    /// A length in the `dvb` unit. A `dvb` is equal to 1% of the [dynamic viewport size](https://www.w3.org/TR/css-values-4/#dynamic-viewport-size)
+    /// in the box's [block axis](https://www.w3.org/TR/css-writing-modes-4/#block-axis).
+    dvb: CSSNumber,
+    /// A length in the `cqb` unit. An `cqb` is equal to 1% of the [query container](https://drafts.csswg.org/css-contain-3/#query-container) block size.
+    cqb: CSSNumber,
+
+    /// A length in the `vmin` unit. A `vmin` is equal to the smaller of `vw` and `vh`.
+    vmin: CSSNumber,
+    /// A length in the `svmin` unit. An `svmin` is equal to the smaller of `svw` and `svh`.
+    svmin: CSSNumber,
+    /// A length in the `lvmin` unit. An `lvmin` is equal to the smaller of `lvw` and `lvh`.
+    lvmin: CSSNumber,
+    /// A length in the `dvmin` unit. An `dvmin` is equal to the smaller of `dvw` and `dvh`.
+    dvmin: CSSNumber,
+    /// A length in the `cqmin` unit. An `cqmin` is equal to the smaller of `cqi` and `cqb`.
+    cqmin: CSSNumber,
+
+    /// A length in the `vmax` unit. A `vmax` is equal to the larger of `vw` and `vh`.
+    vmax: CSSNumber,
+    /// A length in the `svmax` unit. An `svmax` is equal to the larger of `svw` and `svh`.
+    svmax: CSSNumber,
+    /// A length in the `lvmax` unit. An `lvmax` is equal to the larger of `lvw` and `lvh`.
+    lvmax: CSSNumber,
+    /// A length in the `dvmax` unit. An `dvmax` is equal to the larger of `dvw` and `dvh`.
+    dvmax: CSSNumber,
+    /// A length in the `cqmax` unit. An `cqmin` is equal to the larger of `cqi` and `cqb`.
+    cqmax: CSSNumber,
+
+    const FeatureMap = .{
+        .px = null,
+        .in = null,
+        .cm = null,
+        .mm = null,
+        .q = css.Feature.q_unit,
+        .pt = null,
+        .pc = null,
+        .em = null,
+        .rem = css.Feature.rem_unit,
+        .ex = css.Feature.ex_unit,
+        .rex = null,
+        .ch = css.Feature.ch_unit,
+        .rch = null,
+        .cap = css.Feature.cap_unit,
+        .rcap = null,
+        .ic = css.Feature.ic_unit,
+        .ric = null,
+        .lh = css.Feature.lh_unit,
+        .rlh = css.Feature.rlh_unit,
+        .vw = css.Feature.vw_unit,
+        .lvw = css.Feature.viewport_percentage_units_large,
+        .svw = css.Feature.viewport_percentage_units_small,
+        .dvw = css.Feature.viewport_percentage_units_dynamic,
+        .cqw = css.Feature.container_query_length_units,
+        .vh = css.Feature.vh_unit,
+        .lvh = css.Feature.viewport_percentage_units_large,
+        .svh = css.Feature.viewport_percentage_units_small,
+        .dvh = css.Feature.viewport_percentage_units_dynamic,
+        .cqh = css.Feature.container_query_length_units,
+        .vi = css.Feature.vi_unit,
+        .svi = css.Feature.viewport_percentage_units_small,
+        .lvi = css.Feature.viewport_percentage_units_large,
+        .dvi = css.Feature.viewport_percentage_units_dynamic,
+        .cqi = css.Feature.container_query_length_units,
+        .vb = css.Feature.vb_unit,
+        .svb = css.Feature.viewport_percentage_units_small,
+        .lvb = css.Feature.viewport_percentage_units_large,
+        .dvb = css.Feature.viewport_percentage_units_dynamic,
+        .cqb = css.Feature.container_query_length_units,
+        .vmin = css.Feature.vmin_unit,
+        .svmin = css.Feature.viewport_percentage_units_small,
+        .lvmin = css.Feature.viewport_percentage_units_large,
+        .dvmin = css.Feature.viewport_percentage_units_dynamic,
+        .cqmin = css.Feature.container_query_length_units,
+        .vmax = css.Feature.vmax_unit,
+        .svmax = css.Feature.viewport_percentage_units_small,
+        .lvmax = css.Feature.viewport_percentage_units_large,
+        .dvmax = css.Feature.viewport_percentage_units_dynamic,
+        .cqmax = css.Feature.container_query_length_units,
+    };
+
+    comptime {
+        const struct_fields = std.meta.fields(LengthValue);
+        const feature_fields = std.meta.fields(@TypeOf(FeatureMap));
+        if (struct_fields.len != feature_fields.len) {
+            @compileError("LengthValue and FeatureMap must have the same number of fields");
+        }
+        for (struct_fields) |field| {
+            _ = @field(FeatureMap, field.name);
+        }
+    }
+
+    pub fn parse(input: *css.Parser) Result(@This()) {
+        const location = input.currentSourceLocation();
+        const token = switch (input.next()) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+        switch (token.*) {
+            .dimension => |*dim| {
+                // todo_stuff.match_ignore_ascii_case
+                inline for (std.meta.fields(@This())) |field| {
+                    if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(field.name, dim.unit)) {
+                        return .{ .result = @unionInit(LengthValue, field.name, dim.num.value) };
+                    }
+                }
+            },
+            .number => |*num| return .{ .result = .{ .px = num.value } },
+            else => {},
+        }
+        return .{ .err = location.newUnexpectedTokenError(token.*) };
+    }
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+        const value, const unit = this.toUnitValue();
+
+        // The unit can be omitted if the value is zero, except inside calc()
+        // expressions, where unitless numbers won't be parsed as dimensions.
+        if (!dest.in_calc and value == 0.0) {
+            return dest.writeChar('0');
+        }
+
+        return css.serializer.serializeDimension(value, unit, W, dest);
+    }
+
+    pub fn isZero(this: *const LengthValue) bool {
+        inline for (bun.meta.EnumFields(@This())) |field| {
+            if (@intFromEnum(this.*) == field.value) {
+                return @field(this, field.name) == 0.0;
+            }
+        }
+        unreachable;
+    }
+
+    pub fn zero() LengthValue {
+        return .{ .px = 0.0 };
+    }
+
+    /// Attempts to convert the value to pixels.
+    /// Returns `None` if the conversion is not possible.
+    pub fn toPx(this: *const @This()) ?CSSNumber {
+        return switch (this.*) {
+            .px => |v| v,
+            .in => |v| v * PX_PER_IN,
+            .cm => |v| v * PX_PER_CM,
+            .mm => |v| v * PX_PER_MM,
+            .q => |v| v * PX_PER_Q,
+            .pt => |v| v * PX_PER_PT,
+            .pc => |v| v * PX_PER_PC,
+            else => null,
+        };
+    }
+
+    pub inline fn eql(this: *const @This(), other: *const @This()) bool {
+        inline for (bun.meta.EnumFields(@This())) |field| {
+            if (field.value == @intFromEnum(this.*) and field.value == @intFromEnum(other.*)) {
+                return @field(this, field.name) == @field(other, field.name);
+            }
+        }
+        return false;
+    }
+
+    pub fn isSignNegative(this: *const @This()) bool {
+        const s = this.trySign() orelse return false;
+        return css.signfns.isSignNegative(s);
+    }
+
+    pub fn isSignPositive(this: *const @This()) bool {
+        const s = this.trySign() orelse return false;
+        return css.signfns.isSignPositive(s);
+    }
+
+    pub fn trySign(this: *const @This()) ?f32 {
+        return sign(this);
+    }
+
+    pub fn sign(this: *const @This()) f32 {
+        const enum_fields = @typeInfo(@typeInfo(@This()).Union.tag_type.?).Enum.fields;
+        inline for (std.meta.fields(@This()), 0..) |field, i| {
+            if (enum_fields[i].value == @intFromEnum(this.*)) {
+                return css.signfns.signF32(@field(this, field.name));
+            }
+        }
+        unreachable;
+    }
+
+    pub fn tryFromToken(token: *const css.Token) css.Maybe(@This(), void) {
+        switch (token.*) {
+            .dimension => |*dim| {
+                inline for (std.meta.fields(@This())) |field| {
+                    if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(field.name, dim.unit)) {
+                        return .{ .result = @unionInit(LengthValue, field.name, dim.num.value) };
+                    }
+                }
+            },
+            else => {},
+        }
+        return .{ .err = {} };
+    }
+
+    pub fn toUnitValue(this: *const @This()) struct { CSSNumber, []const u8 } {
+        const enum_fields = @typeInfo(@typeInfo(@This()).Union.tag_type.?).Enum.fields;
+        inline for (std.meta.fields(@This()), 0..) |field, i| {
+            if (enum_fields[i].value == @intFromEnum(this.*)) {
+                return .{ @field(this, field.name), field.name };
+            }
+        }
+        unreachable;
+    }
+
+    pub fn map(this: *const @This(), comptime map_fn: *const fn (f32) f32) LengthValue {
+        inline for (comptime bun.meta.EnumFields(@This())) |field| {
+            if (field.value == @intFromEnum(this.*)) {
+                return @unionInit(LengthValue, field.name, map_fn(@field(this, field.name)));
+            }
+        }
+        unreachable;
+    }
+
+    pub fn mulF32(this: @This(), _: Allocator, other: f32) LengthValue {
+        const fields = comptime bun.meta.EnumFields(@This());
+        inline for (fields) |field| {
+            if (field.value == @intFromEnum(this)) {
+                return @unionInit(LengthValue, field.name, @field(this, field.name) * other);
+            }
+        }
+        unreachable;
+    }
+
+    pub fn tryFromAngle(_: css.css_values.angle.Angle) ?@This() {
+        return null;
+    }
+
+    pub fn partialCmp(this: *const LengthValue, other: *const LengthValue) ?std.math.Order {
+        if (@intFromEnum(this.*) == @intFromEnum(other.*)) {
+            inline for (bun.meta.EnumFields(LengthValue)) |field| {
+                if (field.value == @intFromEnum(this.*)) {
+                    const a = @field(this, field.name);
+                    const b = @field(other, field.name);
+                    return css.generic.partialCmpF32(&a, &b);
+                }
+            }
+            unreachable;
+        }
+
+        const a = this.toPx();
+        const b = other.toPx();
+        if (a != null and b != null) {
+            return css.generic.partialCmpF32(&a.?, &b.?);
+        }
+        return null;
+    }
+
+    pub fn tryOp(
+        this: *const LengthValue,
+        other: *const LengthValue,
+        ctx: anytype,
+        comptime op_fn: *const fn (@TypeOf(ctx), a: f32, b: f32) f32,
+    ) ?LengthValue {
+        if (@intFromEnum(this.*) == @intFromEnum(other.*)) {
+            inline for (bun.meta.EnumFields(LengthValue)) |field| {
+                if (field.value == @intFromEnum(this.*)) {
+                    const a = @field(this, field.name);
+                    const b = @field(other, field.name);
+                    return @unionInit(LengthValue, field.name, op_fn(ctx, a, b));
+                }
+            }
+            unreachable;
+        }
+
+        const a = this.toPx();
+        const b = this.toPx();
+        if (a != null and b != null) {
+            return .{ .px = op_fn(ctx, a.?, b.?) };
+        }
+        return null;
+    }
+
+    pub fn tryOpTo(
+        this: *const LengthValue,
+        other: *const LengthValue,
+        comptime R: type,
+        ctx: anytype,
+        comptime op_fn: *const fn (@TypeOf(ctx), a: f32, b: f32) R,
+    ) ?R {
+        if (@intFromEnum(this.*) == @intFromEnum(other.*)) {
+            inline for (bun.meta.EnumFields(LengthValue)) |field| {
+                if (field.value == @intFromEnum(this.*)) {
+                    const a = @field(this, field.name);
+                    const b = @field(other, field.name);
+                    return op_fn(ctx, a, b);
+                }
+            }
+            unreachable;
+        }
+
+        const a = this.toPx();
+        const b = this.toPx();
+        if (a != null and b != null) {
+            return op_fn(ctx, a.?, b.?);
+        }
+        return null;
+    }
+
+    pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+        return css.implementHash(@This(), this, hasher);
+    }
+
+    pub fn tryAdd(this: *const LengthValue, _: std.mem.Allocator, rhs: *const LengthValue) ?LengthValue {
+        if (@intFromEnum(this.*) == @intFromEnum(rhs.*)) {
+            inline for (bun.meta.EnumFields(LengthValue)) |field| {
+                if (field.value == @intFromEnum(this.*)) {
+                    return @unionInit(LengthValue, field.name, @field(this, field.name) + @field(rhs, field.name));
+                }
+            }
+            unreachable;
+        }
+        if (this.toPx()) |a| {
+            if (rhs.toPx()) |b| {
+                return .{ .px = a + b };
+            }
+        }
+        return null;
+    }
+
+    pub fn isCompatible(this: *const @This(), browsers: css.targets.Browsers) bool {
+        inline for (bun.meta.EnumFields(LengthValue)) |field| {
+            if (field.value == @intFromEnum(this.*)) {
+                if (comptime @TypeOf(@field(FeatureMap, field.name)) == css.compat.Feature) {
+                    const feature = @field(FeatureMap, field.name);
+                    return css.compat.Feature.isCompatible(feature, browsers);
+                }
+                return true;
+            }
+        }
+        unreachable;
+    }
+};
+
+/// A CSS [`<length>`](https://www.w3.org/TR/css-values-4/#lengths) value, with support for `calc()`.
+pub const Length = union(enum) {
+    /// An explicitly specified length value.
+    value: LengthValue,
+    /// A computed length value using `calc()`.
+    calc: *Calc(Length),
+
+    pub fn deepClone(this: *const Length, allocator: Allocator) Length {
+        return switch (this.*) {
+            .value => |v| .{ .value = v },
+            .calc => |calc| .{ .calc = bun.create(allocator, Calc(Length), Calc(Length).deepClone(calc, allocator)) },
+        };
+    }
+
+    pub fn deinit(this: *const Length, allocator: Allocator) void {
+        return switch (this.*) {
+            .calc => |calc| calc.deinit(allocator),
+            .value => {},
+        };
+    }
+
+    pub fn parse(input: *css.Parser) Result(Length) {
+        if (input.tryParse(Calc(Length).parse, .{}).asValue()) |calc_value| {
+            // PERF: I don't like this redundant allocation
+            if (calc_value == .value) {
+                const ret = calc_value.value.*;
+                input.allocator().destroy(calc_value.value);
+                return .{ .result = ret };
+            }
+            return .{ .result = .{
+                .calc = bun.create(
+                    input.allocator(),
+                    Calc(Length),
+                    calc_value,
+                ),
+            } };
+        }
+
+        const len = switch (LengthValue.parse(input)) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+        return .{ .result = .{ .value = len } };
+    }
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+        return switch (this.*) {
+            .value => |a| a.toCss(W, dest),
+            .calc => |c| c.toCss(W, dest),
+        };
+    }
+
+    pub fn eql(this: *const @This(), other: *const @This()) bool {
+        return switch (this.*) {
+            .value => |a| other.* == .value and a.eql(&other.value),
+            .calc => |a| other.* == .calc and a.eql(other.calc),
+        };
+    }
+
+    pub fn px(p: CSSNumber) Length {
+        return .{ .value = .{ .px = p } };
+    }
+
+    pub fn toPx(this: *const Length) ?CSSNumber {
+        return switch (this.*) {
+            .value => |a| a.toPx(),
+            else => null,
+        };
+    }
+
+    pub fn mulF32(this: Length, allocator: Allocator, other: f32) Length {
+        return switch (this) {
+            .value => Length{ .value = this.value.mulF32(allocator, other) },
+            .calc => Length{
+                .calc = bun.create(
+                    allocator,
+                    Calc(Length),
+                    this.calc.mulF32(allocator, other),
+                ),
+            },
+        };
+    }
+
+    pub fn add(this: Length, allocator: Allocator, other: Length) Length {
+        // Unwrap calc(...) functions so we can add inside.
+        // Then wrap the result in a calc(...) again if necessary.
+        const a = unwrapCalc(allocator, this);
+        const b = unwrapCalc(allocator, other);
+        const res: Length = Length.addInternal(a, allocator, b);
+        if (res == .calc) {
+            if (res.calc.* == .value) return res.calc.value.*;
+            if (res.calc.* == .function and res.calc.function.* != .calc) return Length{ .calc = bun.create(allocator, Calc(Length), Calc(Length){ .function = res.calc.function }) };
+            return Length{ .calc = bun.create(allocator, Calc(Length), Calc(Length){
+                .function = bun.create(allocator, MathFunction(Length), MathFunction(Length){ .calc = res.calc.* }),
+            }) };
+        }
+        return res;
+    }
+
+    fn addInternal(this: Length, allocator: Allocator, other: Length) Length {
+        if (this.tryAdd(allocator, &other)) |r| return r;
+        return this.add__(allocator, other);
+    }
+
+    fn intoCalc(this: Length, allocator: Allocator) Calc(Length) {
+        return switch (this) {
+            .calc => |c| c.*,
+            else => |v| Calc(Length){ .value = bun.create(allocator, Length, v) },
+        };
+    }
+
+    fn add__(this: Length, allocator: Allocator, other: Length) Length {
+        var a = this;
+        var b = other;
+
+        if (a.isZero()) return b;
+
+        if (b.isZero()) return a;
+
+        if (a.isSignNegative() and b.isSignPositive()) {
+            std.mem.swap(Length, &a, &b);
+        }
+
+        if (a == .calc and b == .calc) {
+            return Length{ .calc = bun.create(allocator, Calc(Length), a.calc.add(allocator, b.calc.*)) };
+        } else if (a == .calc) {
+            switch (a.calc.*) {
+                .value => |v| return v.add__(allocator, b),
+                else => return Length{ .calc = bun.create(allocator, Calc(Length), Calc(Length){
+                    .sum = .{
+                        .left = bun.create(allocator, Calc(Length), a.calc.*),
+                        .right = bun.create(allocator, Calc(Length), b.intoCalc(allocator)),
+                    },
+                }) },
+            }
+        } else if (b == .calc) {
+            switch (b.calc.*) {
+                .value => |v| return a.add__(allocator, v.*),
+                else => return Length{ .calc = bun.create(allocator, Calc(Length), Calc(Length){
+                    .sum = .{
+                        .left = bun.create(allocator, Calc(Length), a.intoCalc(allocator)),
+                        .right = bun.create(allocator, Calc(Length), b.calc.*),
+                    },
+                }) },
+            }
+        } else {
+            return Length{ .calc = bun.create(allocator, Calc(Length), Calc(Length){
+                .sum = .{
+                    .left = bun.create(allocator, Calc(Length), a.intoCalc(allocator)),
+                    .right = bun.create(allocator, Calc(Length), b.intoCalc(allocator)),
+                },
+            }) };
+        }
+    }
+
+    fn tryAdd(this: *const Length, allocator: Allocator, other: *const Length) ?Length {
+        if (this.* == .value and other.* == .value) {
+            if (this.value.tryAdd(allocator, &other.value)) |res| {
+                return Length{ .value = res };
+            }
+            return null;
+        }
+
+        if (this.* == .calc) {
+            switch (this.calc.*) {
+                .value => |v| return v.tryAdd(allocator, other),
+                .sum => |s| {
+                    const a = Length{ .calc = s.left };
+                    if (a.tryAdd(allocator, other)) |res| {
+                        return res.add__(allocator, Length{ .calc = s.right });
+                    }
+
+                    const b = Length{ .calc = s.right };
+                    if (b.tryAdd(allocator, other)) |res| {
+                        return (Length{ .calc = s.left }).add__(allocator, res);
+                    }
+
+                    return null;
+                },
+                else => return null,
+            }
+        }
+
+        if (other.* == .calc) {
+            switch (other.calc.*) {
+                .value => |v| return v.tryAdd(allocator, this),
+                .sum => |s| {
+                    const a = Length{ .calc = s.left };
+                    if (this.tryAdd(allocator, &a)) |res| {
+                        return res.add__(allocator, Length{ .calc = s.right });
+                    }
+
+                    const b = Length{ .calc = s.right };
+                    if (this.tryAdd(allocator, &b)) |res| {
+                        return (Length{ .calc = s.left }).add__(allocator, res);
+                    }
+
+                    return null;
+                },
+                else => return null,
+            }
+        }
+
+        return null;
+    }
+
+    fn unwrapCalc(allocator: Allocator, length: Length) Length {
+        return switch (length) {
+            .calc => |c| switch (c.*) {
+                .function => |f| switch (f.*) {
+                    .calc => |c2| .{ .calc = bun.create(allocator, Calc(Length), c2) },
+                    else => |c2| .{ .calc = bun.create(
+                        allocator,
+                        Calc(Length),
+                        Calc(Length){ .function = bun.create(allocator, css.css_values.calc.MathFunction(Length), c2) },
+                    ) },
+                },
+                else => .{ .calc = c },
+            },
+            else => length,
+        };
+    }
+
+    pub fn trySign(this: *const Length) ?f32 {
+        return switch (this.*) {
+            .value => |v| v.sign(),
+            .calc => |v| v.trySign(),
+        };
+    }
+
+    pub fn isSignNegative(this: *const @This()) bool {
+        const s = this.trySign() orelse return false;
+        return css.signfns.isSignNegative(s);
+    }
+
+    pub fn isSignPositive(this: *const @This()) bool {
+        const s = this.trySign() orelse return false;
+        return css.signfns.isSignPositive(s);
+    }
+
+    pub fn partialCmp(this: *const Length, other: *const Length) ?std.math.Order {
+        if (this.* == .value and other.* == .value) return css.generic.partialCmp(LengthValue, &this.value, &other.value);
+        return null;
+    }
+
+    pub fn tryFromAngle(_: css.css_values.angle.Angle) ?@This() {
+        return null;
+    }
+
+    pub fn tryMap(this: *const Length, comptime map_fn: *const fn (f32) f32) ?Length {
+        return switch (this.*) {
+            .value => |v| .{ .value = v.map(map_fn) },
+            else => null,
+        };
+    }
+
+    pub fn tryOp(
+        this: *const Length,
+        other: *const Length,
+        ctx: anytype,
+        comptime op_fn: *const fn (@TypeOf(ctx), a: f32, b: f32) f32,
+    ) ?Length {
+        if (this.* == .value and other.* == .value) {
+            if (this.value.tryOp(&other.value, ctx, op_fn)) |val| return .{ .value = val };
+            return null;
+        }
+        return null;
+    }
+
+    pub fn tryOpTo(
+        this: *const Length,
+        other: *const Length,
+        comptime R: type,
+        ctx: anytype,
+        comptime op_fn: *const fn (@TypeOf(ctx), a: f32, b: f32) R,
+    ) ?R {
+        if (this.* == .value and other.* == .value) {
+            return this.value.tryOpTo(&other.value, R, ctx, op_fn);
+        }
+        return null;
+    }
+
+    pub fn isZero(this: *const Length) bool {
+        return switch (this.*) {
+            .value => |v| v.isZero(),
+            else => false,
+        };
+    }
+
+    pub fn isCompatible(this: *const @This(), browsers: css.targets.Browsers) bool {
+        return switch (this.*) {
+            .value => |*v| v.isCompatible(browsers),
+            .calc => |c| c.isCompatible(browsers),
+        };
+    }
+};
diff --git a/src/css/values/number.zig b/src/css/values/number.zig
new file mode 100644
index 0000000000..ddb701a7c0
--- /dev/null
+++ b/src/css/values/number.zig
@@ -0,0 +1,69 @@
+const std = @import("std");
+const bun = @import("root").bun;
+pub const css = @import("../css_parser.zig");
+const Result = css.Result;
+const ArrayList = std.ArrayListUnmanaged;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const Calc = css.css_values.calc.Calc;
+
+pub const CSSNumber = f32;
+pub const CSSNumberFns = struct {
+    pub fn parse(input: *css.Parser) Result(CSSNumber) {
+        if (input.tryParse(Calc(f32).parse, .{}).asValue()) |calc_value| {
+            switch (calc_value) {
+                .value => |v| return .{ .result = v.* },
+                .number => |n| return .{ .result = n },
+                // Numbers are always compatible, so they will always compute to a value.
+                else => return .{ .err = input.newCustomError(css.ParserError.invalid_value) },
+            }
+        }
+
+        return input.expectNumber();
+    }
+
+    pub fn toCss(this: *const CSSNumber, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        const number: f32 = this.*;
+        if (number != 0.0 and @abs(number) < 1.0) {
+            // PERF(alloc): Use stack fallback here?
+            // why the extra allocation anyway? isn't max amount of digits to stringify an f32 small?
+            var s = ArrayList(u8){};
+            defer s.deinit(dest.allocator);
+            const writer = s.writer(dest.allocator);
+            css.to_css.float32(number, writer) catch {
+                return dest.addFmtError();
+            };
+            if (number < 0.0) {
+                try dest.writeChar('-');
+                try dest.writeStr(bun.strings.trimLeadingPattern2(s.items, '-', '0'));
+            } else {
+                try dest.writeStr(bun.strings.trimLeadingChar(s.items, '0'));
+            }
+        } else {
+            return css.to_css.float32(number, dest) catch {
+                return dest.addFmtError();
+            };
+        }
+    }
+
+    pub fn tryFromAngle(_: css.css_values.angle.Angle) ?CSSNumber {
+        return null;
+    }
+
+    pub fn sign(this: *const CSSNumber) f32 {
+        if (this.* == 0.0) return if (css.signfns.isSignPositive(this.*)) 0.0 else 0.0;
+        return css.signfns.signum(this.*);
+    }
+};
+
+/// A CSS [`<integer>`](https://www.w3.org/TR/css-values-4/#integers) value.
+pub const CSSInteger = i32;
+pub const CSSIntegerFns = struct {
+    pub fn parse(input: *css.Parser) Result(CSSInteger) {
+        // TODO: calc??
+        return input.expectInteger();
+    }
+    pub inline fn toCss(this: *const CSSInteger, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        try css.to_css.integer(i32, this.*, W, dest);
+    }
+};
diff --git a/src/css/values/percentage.zig b/src/css/values/percentage.zig
new file mode 100644
index 0000000000..bdafae93e6
--- /dev/null
+++ b/src/css/values/percentage.zig
@@ -0,0 +1,501 @@
+const std = @import("std");
+const bun = @import("root").bun;
+pub const css = @import("../css_parser.zig");
+const Result = css.Result;
+const ArrayList = std.ArrayListUnmanaged;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const CSSNumber = css.css_values.number.CSSNumber;
+const CSSNumberFns = css.css_values.number.CSSNumberFns;
+const Calc = css.css_values.calc.Calc;
+
+pub const Percentage = struct {
+    v: CSSNumber,
+
+    pub fn parse(input: *css.Parser) Result(Percentage) {
+        if (input.tryParse(Calc(Percentage).parse, .{}).asValue()) |calc_value| {
+            if (calc_value == .value) return .{ .result = calc_value.value.* };
+            // Percentages are always compatible, so they will always compute to a value.
+            bun.unreachablePanic("Percentages are always compatible, so they will always compute to a value.", .{});
+        }
+
+        const percent = switch (input.expectPercentage()) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+
+        return .{ .result = Percentage{ .v = percent } };
+    }
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+        const x = this.v * 100.0;
+        const int_value: ?i32 = if ((x - @trunc(x)) == 0.0)
+            @intFromFloat(this.v)
+        else
+            null;
+
+        const percent = css.Token{ .percentage = .{
+            .has_sign = this.v < 0.0,
+            .unit_value = this.v,
+            .int_value = int_value,
+        } };
+
+        if (this.v != 0.0 and @abs(this.v) < 0.01) {
+            // TODO: is this the max length?
+            var buf: [32]u8 = undefined;
+            var fba = std.heap.FixedBufferAllocator.init(&buf);
+            var string = std.ArrayList(u8).init(fba.allocator());
+            const writer = string.writer();
+            percent.toCssGeneric(writer) catch return dest.addFmtError();
+            if (this.v < 0.0) {
+                try dest.writeChar('-');
+                try dest.writeStr(bun.strings.trimLeadingPattern2(string.items, '-', '0'));
+            } else {
+                try dest.writeStr(bun.strings.trimLeadingChar(string.items, '0'));
+            }
+        } else {
+            try percent.toCss(W, dest);
+        }
+    }
+
+    pub inline fn eql(this: *const Percentage, other: *const Percentage) bool {
+        return this.v == other.v;
+    }
+
+    pub fn add(lhs: Percentage, _: std.mem.Allocator, rhs: Percentage) Percentage {
+        return Percentage{ .v = lhs.v + rhs.v };
+    }
+
+    pub fn mulF32(this: Percentage, _: std.mem.Allocator, other: f32) Percentage {
+        return Percentage{ .v = this.v * other };
+    }
+
+    pub fn isZero(this: *const Percentage) bool {
+        return this.v == 0.0;
+    }
+
+    pub fn sign(this: *const Percentage) f32 {
+        return css.signfns.signF32(this.v);
+    }
+
+    pub fn trySign(this: *const Percentage) ?f32 {
+        return this.sign();
+    }
+
+    pub fn partialCmp(this: *const Percentage, other: *const Percentage) ?std.math.Order {
+        return css.generic.partialCmp(f32, &this.v, &other.v);
+    }
+
+    pub fn tryFromAngle(_: css.css_values.angle.Angle) ?Percentage {
+        return null;
+    }
+
+    pub fn tryMap(_: *const Percentage, comptime _: *const fn (f32) f32) ?Percentage {
+        // Percentages cannot be mapped because we don't know what they will resolve to.
+        // For example, they might be positive or negative depending on what they are a
+        // percentage of, which we don't know.
+        return null;
+    }
+
+    pub fn op(
+        this: *const Percentage,
+        other: *const Percentage,
+        ctx: anytype,
+        comptime op_fn: *const fn (@TypeOf(ctx), a: f32, b: f32) f32,
+    ) Percentage {
+        return Percentage{ .v = op_fn(ctx, this.v, other.v) };
+    }
+
+    pub fn opTo(
+        this: *const Percentage,
+        other: *const Percentage,
+        comptime R: type,
+        ctx: anytype,
+        comptime op_fn: *const fn (@TypeOf(ctx), a: f32, b: f32) R,
+    ) R {
+        return op_fn(ctx, this.v, other.v);
+    }
+
+    pub fn tryOp(
+        this: *const Percentage,
+        other: *const Percentage,
+        ctx: anytype,
+        comptime op_fn: *const fn (@TypeOf(ctx), a: f32, b: f32) f32,
+    ) ?Percentage {
+        return Percentage{ .v = op_fn(ctx, this.v, other.v) };
+    }
+};
+
+fn needsDeepclone(comptime D: type) bool {
+    return switch (D) {
+        css.css_values.angle.Angle => false,
+        css.css_values.length.LengthValue => false,
+        else => @compileError("Can't tell if " ++ @typeName(D) ++ " needs deepclone, please add it to this switch statement."),
+    };
+}
+
+pub fn DimensionPercentage(comptime D: type) type {
+    const needs_deepclone = needsDeepclone(D);
+    return union(enum) {
+        dimension: D,
+        percentage: Percentage,
+        calc: *Calc(DimensionPercentage(D)),
+
+        const This = @This();
+
+        pub fn parse(input: *css.Parser) Result(@This()) {
+            if (input.tryParse(Calc(This).parse, .{}).asValue()) |calc_value| {
+                if (calc_value == .value) return .{ .result = calc_value.value.* };
+                return .{ .result = .{
+                    .calc = bun.create(input.allocator(), Calc(DimensionPercentage(D)), calc_value),
+                } };
+            }
+
+            if (input.tryParse(D.parse, .{}).asValue()) |length| {
+                return .{ .result = .{ .dimension = length } };
+            }
+
+            if (input.tryParse(Percentage.parse, .{}).asValue()) |percentage| {
+                return .{ .result = .{ .percentage = percentage } };
+            }
+
+            return .{ .err = input.newErrorForNextToken() };
+        }
+
+        pub fn toCss(this: *const @This(), comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+            return switch (this.*) {
+                .dimension => |*length| length.toCss(W, dest),
+                .percentage => |*per| per.toCss(W, dest),
+                .calc => |calc| calc.toCss(W, dest),
+            };
+        }
+
+        pub fn isCompatible(this: *const @This(), browsers: css.targets.Browsers) bool {
+            return switch (this.*) {
+                .dimension => |*d| d.isCompatible(browsers),
+                .calc => |c| c.isCompatible(browsers),
+                .percentage => true,
+            };
+        }
+
+        pub fn eql(this: *const This, other: *const This) bool {
+            return css.implementEql(@This(), this, other);
+        }
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) This {
+            return switch (this.*) {
+                .dimension => |d| if (comptime needs_deepclone) .{ .dimension = d.deepClone(allocator) } else this.*,
+                .percentage => return this.*,
+                .calc => |calc| .{ .calc = bun.create(allocator, Calc(DimensionPercentage(D)), calc.deepClone(allocator)) },
+            };
+        }
+
+        pub fn deinit(this: *const @This(), allocator: std.mem.Allocator) void {
+            return switch (this.*) {
+                .dimension => |d| if (comptime @hasDecl(D, "deinit")) d.deinit(allocator),
+                .percentage => {},
+                .calc => |calc| calc.deinit(allocator),
+            };
+        }
+
+        pub fn zero() This {
+            return This{ .dimension = switch (D) {
+                f32 => 0.0,
+                else => D.zero(),
+            } };
+        }
+
+        pub fn isZero(this: *const This) bool {
+            return switch (this.*) {
+                .dimension => |*d| switch (D) {
+                    f32 => d == 0.0,
+                    else => d.isZero(),
+                },
+                .percentage => |*p| p.isZero(),
+                else => false,
+            };
+        }
+
+        fn mulValueF32(lhs: D, allocator: std.mem.Allocator, rhs: f32) D {
+            return switch (D) {
+                f32 => lhs * rhs,
+                else => lhs.mulF32(allocator, rhs),
+            };
+        }
+
+        pub fn mulF32(this: This, allocator: std.mem.Allocator, other: f32) This {
+            return switch (this) {
+                .dimension => |d| .{ .dimension = mulValueF32(d, allocator, other) },
+                .percentage => |p| .{ .percentage = p.mulF32(allocator, other) },
+                .calc => |c| .{ .calc = bun.create(allocator, Calc(DimensionPercentage(D)), c.mulF32(allocator, other)) },
+            };
+        }
+
+        pub fn add(this: This, allocator: std.mem.Allocator, other: This) This {
+            // Unwrap calc(...) functions so we can add inside.
+            // Then wrap the result in a calc(...) again if necessary.
+            const a = unwrapCalc(this, allocator);
+            const b = unwrapCalc(other, allocator);
+            const res = a.addInternal(allocator, b);
+            return switch (res) {
+                .calc => |c| switch (c.*) {
+                    .value => |l| l.*,
+                    .function => |f| if (f.* != .calc) .{
+                        .calc = bun.create(allocator, Calc(DimensionPercentage(D)), .{
+                            .function = f,
+                        }),
+                    } else .{
+                        .calc = bun.create(allocator, Calc(DimensionPercentage(D)), .{
+                            .function = bun.create(
+                                allocator,
+                                css.css_values.calc.MathFunction(DimensionPercentage(D)),
+                                .{ .calc = c.* },
+                            ),
+                        }),
+                    },
+                    else => .{
+                        .calc = bun.create(allocator, Calc(DimensionPercentage(D)), .{
+                            .function = bun.create(
+                                allocator,
+                                css.css_values.calc.MathFunction(DimensionPercentage(D)),
+                                .{ .calc = c.* },
+                            ),
+                        }),
+                    },
+                },
+                else => res,
+            };
+        }
+
+        fn addInternal(this: This, allocator: std.mem.Allocator, other: This) This {
+            if (this.addRecursive(allocator, &other)) |res| return res;
+            return this.addImpl(allocator, other);
+        }
+
+        fn addRecursive(this: *const This, allocator: std.mem.Allocator, other: *const This) ?This {
+            if (this.* == .dimension and other.* == .dimension) {
+                if (this.dimension.tryAdd(allocator, &other.dimension)) |res| {
+                    return .{ .dimension = res };
+                }
+            } else if (this.* == .percentage and other.* == .percentage) {
+                return .{ .percentage = .{ .v = this.percentage.v + other.percentage.v } };
+            } else if (this.* == .calc) {
+                switch (this.calc.*) {
+                    .value => |v| return v.addRecursive(allocator, other),
+                    .sum => |sum| {
+                        const left_calc = This{ .calc = sum.left };
+                        if (left_calc.addRecursive(allocator, other)) |res| {
+                            return res.add(allocator, This{ .calc = sum.right });
+                        }
+
+                        const right_calc = This{ .calc = sum.right };
+                        if (right_calc.addRecursive(allocator, other)) |res| {
+                            return (This{ .calc = sum.left }).add(allocator, res);
+                        }
+                    },
+                    else => {},
+                }
+            } else if (other.* == .calc) {
+                switch (other.calc.*) {
+                    .value => |v| return this.addRecursive(allocator, v),
+                    .sum => |sum| {
+                        const left_calc = This{ .calc = sum.left };
+                        if (this.addRecursive(allocator, &left_calc)) |res| {
+                            return res.add(allocator, This{ .calc = sum.right });
+                        }
+
+                        const right_calc = This{ .calc = sum.right };
+                        if (this.addRecursive(allocator, &right_calc)) |res| {
+                            return (This{ .calc = sum.left }).add(allocator, res);
+                        }
+                    },
+                    else => {},
+                }
+            }
+
+            return null;
+        }
+
+        fn addImpl(this: This, allocator: std.mem.Allocator, other: This) This {
+            var a = this;
+            var b = other;
+
+            if (a.isZero()) return b;
+            if (b.isZero()) return a;
+
+            if (a.isSignNegative() and b.isSignPositive()) {
+                std.mem.swap(This, &a, &b);
+            }
+
+            if (a == .calc and b == .calc) {
+                return .{ .calc = bun.create(allocator, Calc(DimensionPercentage(D)), a.calc.add(allocator, b.calc.*)) };
+            } else if (a == .calc) {
+                if (a.calc.* == .value) {
+                    return a.calc.value.add(allocator, b);
+                } else {
+                    return .{
+                        .calc = bun.create(
+                            allocator,
+                            Calc(DimensionPercentage(D)),
+                            .{ .sum = .{
+                                .left = bun.create(allocator, Calc(DimensionPercentage(D)), a.calc.*),
+                                .right = bun.create(allocator, Calc(DimensionPercentage(D)), b.intoCalc(allocator)),
+                            } },
+                        ),
+                    };
+                }
+            } else if (b == .calc) {
+                if (b.calc.* == .value) {
+                    return a.add(allocator, b.calc.value.*);
+                } else {
+                    return .{
+                        .calc = bun.create(
+                            allocator,
+                            Calc(DimensionPercentage(D)),
+                            .{ .sum = .{
+                                .left = bun.create(allocator, Calc(DimensionPercentage(D)), a.intoCalc(allocator)),
+                                .right = bun.create(allocator, Calc(DimensionPercentage(D)), b.calc.*),
+                            } },
+                        ),
+                    };
+                }
+            } else {
+                return .{
+                    .calc = bun.create(
+                        allocator,
+                        Calc(DimensionPercentage(D)),
+                        .{ .sum = .{
+                            .left = bun.create(allocator, Calc(DimensionPercentage(D)), a.intoCalc(allocator)),
+                            .right = bun.create(allocator, Calc(DimensionPercentage(D)), b.intoCalc(allocator)),
+                        } },
+                    ),
+                };
+            }
+        }
+
+        inline fn isSignPositive(this: This) bool {
+            const sign = this.trySign() orelse return false;
+            return css.signfns.isSignPositive(sign);
+        }
+
+        inline fn isSignNegative(this: This) bool {
+            const sign = this.trySign() orelse return false;
+            return css.signfns.isSignNegative(sign);
+        }
+
+        fn unwrapCalc(this: This, allocator: std.mem.Allocator) This {
+            return switch (this) {
+                .calc => |calc| switch (calc.*) {
+                    .function => |f| switch (f.*) {
+                        .calc => |c2| .{ .calc = bun.create(allocator, Calc(DimensionPercentage(D)), c2) },
+                        else => .{ .calc = bun.create(
+                            allocator,
+                            Calc(DimensionPercentage(D)),
+                            .{
+                                .function = bun.create(
+                                    allocator,
+                                    css.css_values.calc.MathFunction(DimensionPercentage(D)),
+                                    f.*,
+                                ),
+                            },
+                        ) },
+                    },
+                    else => .{ .calc = calc },
+                },
+                else => this,
+            };
+        }
+
+        pub fn partialCmp(this: *const This, other: *const This) ?std.math.Order {
+            if (this.* == .dimension and other.* == .dimension) {
+                return this.dimension.partialCmp(&other.dimension);
+            } else if (this.* == .percentage and other.* == .percentage) {
+                return this.percentage.partialCmp(&other.percentage);
+            } else {
+                return null;
+            }
+        }
+
+        pub fn trySign(this: *const This) ?f32 {
+            return switch (this.*) {
+                .dimension => |*d| css.generic.trySign(@TypeOf(d.*), d),
+                .percentage => |p| p.trySign(),
+                .calc => |c| c.trySign(),
+            };
+        }
+
+        pub fn tryFromAngle(angle: css.css_values.angle.Angle) ?This {
+            return DimensionPercentage(D){
+                .dimension = D.tryFromAngle(angle) orelse return null,
+            };
+        }
+
+        pub fn tryMap(this: *const This, comptime mapfn: *const fn (f32) f32) ?This {
+            return switch (this.*) {
+                .dimension => |vv| if (css.generic.tryMap(D, &vv, mapfn)) |v| .{ .dimension = v } else null,
+                else => null,
+            };
+        }
+
+        pub fn tryOp(
+            this: *const This,
+            other: *const This,
+            ctx: anytype,
+            comptime op_fn: *const fn (@TypeOf(ctx), a: f32, b: f32) f32,
+        ) ?This {
+            if (this.* == .dimension and other.* == .dimension) return .{ .dimension = css.generic.tryOp(D, &this.dimension, &other.dimension, ctx, op_fn) orelse return null };
+            if (this.* == .percentage and other.* == .percentage) return .{ .percentage = Percentage{ .v = op_fn(ctx, this.percentage.v, other.percentage.v) } };
+            return null;
+        }
+
+        pub fn intoCalc(this: This, allocator: std.mem.Allocator) Calc(DimensionPercentage(D)) {
+            return switch (this) {
+                .calc => |calc| calc.*,
+                else => .{ .value = bun.create(allocator, This, this) },
+            };
+        }
+    };
+}
+
+/// Either a `<number>` or `<percentage>`.
+pub const NumberOrPercentage = union(enum) {
+    /// A number.
+    number: CSSNumber,
+    /// A percentage.
+    percentage: Percentage,
+
+    // TODO: implement this
+    pub usingnamespace css.DeriveParse(@This());
+    pub usingnamespace css.DeriveToCss(@This());
+
+    // pub fn parse(input: *css.Parser) Result(NumberOrPercentage) {
+    //     _ = input; // autofix
+    //     @panic(css.todo_stuff.depth);
+    // }
+
+    // pub fn toCss(this: *const NumberOrPercentage, comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+    //     _ = this; // autofix
+    //     _ = dest; // autofix
+    //     @panic(css.todo_stuff.depth);
+    // }
+
+    pub fn eql(this: *const NumberOrPercentage, other: *const NumberOrPercentage) bool {
+        return switch (this.*) {
+            .number => |*a| switch (other.*) {
+                .number => a.* == other.number,
+                .percentage => false,
+            },
+            .percentage => |*a| switch (other.*) {
+                .number => false,
+                .percentage => a.eql(&other.percentage),
+            },
+        };
+    }
+
+    pub fn intoF32(this: *const @This()) f32 {
+        return switch (this.*) {
+            .number => this.number,
+            .percentage => this.percentage.v,
+        };
+    }
+};
diff --git a/src/css/values/position.zig b/src/css/values/position.zig
new file mode 100644
index 0000000000..83c00b9692
--- /dev/null
+++ b/src/css/values/position.zig
@@ -0,0 +1,443 @@
+const std = @import("std");
+const bun = @import("root").bun;
+pub const css = @import("../css_parser.zig");
+const Result = css.Result;
+const ArrayList = std.ArrayListUnmanaged;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const CSSNumber = css.css_values.number.CSSNumber;
+const CSSNumberFns = css.css_values.number.CSSNumberFns;
+const Calc = css.css_values.calc.Calc;
+const DimensionPercentage = css.css_values.percentage.DimensionPercentage;
+const LengthPercentage = css.css_values.length.LengthPercentage;
+const Percentage = css.css_values.percentage.Percentage;
+
+/// A CSS `<position>` value,
+/// as used in the `background-position` property, gradients, masks, etc.
+pub const Position = struct {
+    /// The x-position.
+    x: HorizontalPosition,
+    /// The y-position.
+    y: VerticalPosition,
+
+    pub fn parse(input: *css.Parser) Result(Position) {
+        // Try parsing a horizontal position first
+        if (input.tryParse(HorizontalPosition.parse, .{}).asValue()) |horizontal_pos| {
+            switch (horizontal_pos) {
+                .center => {
+                    // Try parsing a vertical position next
+                    if (input.tryParse(VerticalPosition.parse, .{}).asValue()) |y| {
+                        return .{ .result = Position{
+                            .x = .center,
+                            .y = y,
+                        } };
+                    }
+
+                    // If it didn't work, assume the first actually represents a y position,
+                    // and the next is an x position. e.g. `center left` rather than `left center`.
+                    const x = input.tryParse(HorizontalPosition.parse, .{}).unwrapOr(HorizontalPosition.center);
+                    const y = VerticalPosition.center;
+                    return .{ .result = Position{ .x = x, .y = y } };
+                },
+                .length => |*x| {
+                    // If we got a length as the first component, then the second must
+                    // be a keyword or length (not a side offset).
+                    if (input.tryParse(VerticalPositionKeyword.parse, .{}).asValue()) |y_keyword| {
+                        const y = VerticalPosition{ .side = .{
+                            .side = y_keyword,
+                            .offset = null,
+                        } };
+                        return .{ .result = Position{ .x = .{ .length = x.* }, .y = y } };
+                    }
+                    if (input.tryParse(LengthPercentage.parse, .{}).asValue()) |y_lp| {
+                        const y = VerticalPosition{ .length = y_lp };
+                        return .{ .result = Position{ .x = .{ .length = x.* }, .y = y } };
+                    }
+                    const y = VerticalPosition.center;
+                    _ = input.tryParse(css.Parser.expectIdentMatching, .{"center"});
+                    return .{ .result = Position{ .x = .{ .length = x.* }, .y = y } };
+                },
+                .side => |*side| {
+                    const x_keyword = side.side;
+                    const lp = side.offset;
+
+                    // If we got a horizontal side keyword (and optional offset), expect another for the vertical side.
+                    // e.g. `left center` or `left 20px center`
+                    if (input.tryParse(css.Parser.expectIdentMatching, .{"center"}).isOk()) {
+                        const x = HorizontalPosition{ .side = .{
+                            .side = x_keyword,
+                            .offset = lp,
+                        } };
+                        const y = VerticalPosition.center;
+                        return .{ .result = Position{ .x = x, .y = y } };
+                    }
+
+                    // e.g. `left top`, `left top 20px`, `left 20px top`, or `left 20px top 20px`
+                    if (input.tryParse(VerticalPositionKeyword.parse, .{}).asValue()) |y_keyword| {
+                        const y_lp = switch (input.tryParse(LengthPercentage.parse, .{})) {
+                            .result => |vv| vv,
+                            .err => null,
+                        };
+                        const x = HorizontalPosition{ .side = .{
+                            .side = x_keyword,
+                            .offset = lp,
+                        } };
+                        const y = VerticalPosition{ .side = .{
+                            .side = y_keyword,
+                            .offset = y_lp,
+                        } };
+                        return .{ .result = Position{ .x = x, .y = y } };
+                    }
+
+                    // If we didn't get a vertical side keyword (e.g. `left 20px`), then apply the offset to the vertical side.
+                    const x = HorizontalPosition{ .side = .{
+                        .side = x_keyword,
+                        .offset = null,
+                    } };
+                    const y = if (lp) |lp_val|
+                        VerticalPosition{ .length = lp_val }
+                    else
+                        VerticalPosition.center;
+                    return .{ .result = Position{ .x = x, .y = y } };
+                },
+            }
+        }
+
+        // If the horizontal position didn't parse, then it must be out of order. Try vertical position keyword.
+        const y_keyword = switch (VerticalPositionKeyword.parse(input)) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+        const lp_and_x_pos = input.tryParse(struct {
+            fn parse(i: *css.Parser) Result(struct { ?LengthPercentage, HorizontalPosition }) {
+                const y_lp = i.tryParse(LengthPercentage.parse, .{}).asValue();
+                if (i.tryParse(HorizontalPositionKeyword.parse, .{}).asValue()) |x_keyword| {
+                    const x_lp = i.tryParse(LengthPercentage.parse, .{}).asValue();
+                    const x_pos = HorizontalPosition{ .side = .{
+                        .side = x_keyword,
+                        .offset = x_lp,
+                    } };
+                    return .{ .result = .{ y_lp, x_pos } };
+                }
+                if (i.expectIdentMatching("center").asErr()) |e| return .{ .err = e };
+                const x_pos = HorizontalPosition.center;
+                return .{ .result = .{ y_lp, x_pos } };
+            }
+        }.parse, .{});
+
+        if (lp_and_x_pos.asValue()) |tuple| {
+            const y_lp = tuple[0];
+            const x = tuple[1];
+            const y = VerticalPosition{ .side = .{
+                .side = y_keyword,
+                .offset = y_lp,
+            } };
+            return .{ .result = Position{ .x = x, .y = y } };
+        }
+
+        const x = HorizontalPosition.center;
+        const y = VerticalPosition{ .side = .{
+            .side = y_keyword,
+            .offset = null,
+        } };
+        return .{ .result = Position{ .x = x, .y = y } };
+    }
+
+    pub fn toCss(this: *const Position, comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+        if (this.x == .side and this.y == .length and this.x.side.side != .left) {
+            try this.x.toCss(W, dest);
+            try dest.writeStr(" top ");
+            try this.y.length.toCss(W, dest);
+        } else if (this.x == .side and this.x.side.side != .left and this.y.isCenter()) {
+            // If there is a side keyword with an offset, "center" must be a keyword not a percentage.
+            try this.x.toCss(W, dest);
+            try dest.writeStr(" center");
+        } else if (this.x == .length and this.y == .side and this.y.side.side != .top) {
+            try dest.writeStr("left ");
+            try this.x.length.toCss(W, dest);
+            try dest.writeStr(" ");
+            try this.y.toCss(W, dest);
+        } else if (this.x.isCenter() and this.y.isCenter()) {
+            // `center center` => 50%
+            try this.x.toCss(W, dest);
+        } else if (this.x == .length and this.y.isCenter()) {
+            // `center` is assumed if omitted.
+            try this.x.length.toCss(W, dest);
+        } else if (this.x == .side and this.x.side.offset == null and this.y.isCenter()) {
+            const p: LengthPercentage = this.x.side.side.intoLengthPercentage();
+            try p.toCss(W, dest);
+        } else if (this.y == .side and this.y.side.offset == null and this.x.isCenter()) {
+            try this.y.toCss(W, dest);
+        } else if (this.x == .side and this.x.side.offset == null and this.y == .side and this.y.side.offset == null) {
+            const x: LengthPercentage = this.x.side.side.intoLengthPercentage();
+            const y: LengthPercentage = this.y.side.side.intoLengthPercentage();
+            try x.toCss(W, dest);
+            try dest.writeStr(" ");
+            try y.toCss(W, dest);
+        } else {
+            const zero = LengthPercentage.zero();
+            const fifty = LengthPercentage{ .percentage = .{ .v = 0.5 } };
+            const x_len: ?*const LengthPercentage = x_len: {
+                switch (this.x) {
+                    .side => |side| {
+                        if (side.side == .left) {
+                            if (side.offset) |*offset| {
+                                if (offset.isZero()) {
+                                    break :x_len &zero;
+                                } else {
+                                    break :x_len offset;
+                                }
+                            } else {
+                                break :x_len &zero;
+                            }
+                        }
+                    },
+                    .length => |len| {
+                        if (len.isZero()) {
+                            break :x_len &zero;
+                        }
+                    },
+                    .center => break :x_len &fifty,
+                }
+                break :x_len null;
+            };
+
+            const y_len: ?*const LengthPercentage = y_len: {
+                switch (this.y) {
+                    .side => |side| {
+                        if (side.side == .top) {
+                            if (side.offset) |*offset| {
+                                if (offset.isZero()) {
+                                    break :y_len &zero;
+                                } else {
+                                    break :y_len offset;
+                                }
+                            } else {
+                                break :y_len &zero;
+                            }
+                        }
+                    },
+                    .length => |len| {
+                        if (len.isZero()) {
+                            break :y_len &zero;
+                        }
+                    },
+                    .center => break :y_len &fifty,
+                }
+                break :y_len null;
+            };
+
+            if (x_len != null and y_len != null) {
+                try x_len.?.toCss(W, dest);
+                try dest.writeStr(" ");
+                try y_len.?.toCss(W, dest);
+            } else {
+                try this.x.toCss(W, dest);
+                try dest.writeStr(" ");
+                try this.y.toCss(W, dest);
+            }
+        }
+    }
+
+    pub fn default() @This() {
+        return .{
+            .x = HorizontalPosition{ .length = LengthPercentage{ .percentage = .{ .v = 0.0 } } },
+            .y = VerticalPosition{ .length = LengthPercentage{ .percentage = .{ .v = 0.0 } } },
+        };
+    }
+
+    /// Returns whether both the x and y positions are centered.
+    pub fn isCenter(this: *const @This()) bool {
+        return this.x.isCenter() and this.y.isCenter();
+    }
+
+    pub fn center() Position {
+        return .{ .x = .center, .y = .center };
+    }
+
+    pub fn eql(this: *const Position, other: *const Position) bool {
+        return this.x.eql(&other.x) and this.y.eql(&other.y);
+    }
+
+    pub fn isZero(this: *const Position) bool {
+        return this.x.isZero() and this.y.isZero();
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+pub fn PositionComponent(comptime S: type) type {
+    return union(enum) {
+        /// The `center` keyword.
+        center,
+        /// A length or percentage from the top-left corner of the box.
+        length: LengthPercentage,
+        /// A side keyword with an optional offset.
+        side: struct {
+            /// A side keyword.
+            side: S,
+            /// Offset from the side.
+            offset: ?LengthPercentage,
+
+            pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+                return css.implementDeepClone(@This(), this, allocator);
+            }
+        },
+
+        const This = @This();
+
+        pub fn isZero(this: *const This) bool {
+            if (this.* == .length and this.length.isZero()) return true;
+            return false;
+        }
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+
+        pub fn eql(this: *const This, other: *const This) bool {
+            return switch (this.*) {
+                .center => switch (other.*) {
+                    .center => true,
+                    else => false,
+                },
+                .length => |*a| switch (other.*) {
+                    .length => a.eql(&other.length),
+                    else => false,
+                },
+                .side => |*a| switch (other.*) {
+                    .side => a.side.eql(&other.side.side) and css.generic.eql(?LengthPercentage, &a.offset, &other.side.offset),
+                    else => false,
+                },
+            };
+        }
+
+        pub fn parse(input: *css.Parser) Result(This) {
+            if (input.tryParse(
+                struct {
+                    fn parse(i: *css.Parser) Result(void) {
+                        return i.expectIdentMatching("center");
+                    }
+                }.parse,
+                .{},
+            ).isOk()) {
+                return .{ .result = .center };
+            }
+
+            if (input.tryParse(LengthPercentage.parse, .{}).asValue()) |lp| {
+                return .{ .result = .{ .length = lp } };
+            }
+
+            const side = switch (S.parse(input)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            };
+            const offset = input.tryParse(LengthPercentage.parse, .{}).asValue();
+            return .{ .result = .{ .side = .{ .side = side, .offset = offset } } };
+        }
+
+        pub fn toCss(this: *const @This(), comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+            switch (this.*) {
+                .center => {
+                    if (dest.minify) {
+                        try dest.writeStr("50%");
+                    } else {
+                        try dest.writeStr("center");
+                    }
+                },
+                .length => |*lp| try lp.toCss(W, dest),
+                .side => |*s| {
+                    try s.side.toCss(W, dest);
+                    if (s.offset) |lp| {
+                        try dest.writeStr(" ");
+                        try lp.toCss(W, dest);
+                    }
+                },
+            }
+        }
+
+        pub fn isCenter(this: *const This) bool {
+            switch (this.*) {
+                .center => return true,
+                .length => |*l| {
+                    if (l.* == .percentage) return l.percentage.v == 0.5;
+                },
+                else => {},
+            }
+            return false;
+        }
+    };
+}
+
+pub const HorizontalPositionKeyword = enum {
+    /// The `left` keyword.
+    left,
+    /// The `right` keyword.
+    right,
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) HorizontalPositionKeyword {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(this: *const HorizontalPositionKeyword, other: *const HorizontalPositionKeyword) bool {
+        return this.* == other.*;
+    }
+
+    pub fn asStr(this: *const @This()) []const u8 {
+        return css.enum_property_util.asStr(@This(), this);
+    }
+
+    pub fn parse(input: *css.Parser) Result(@This()) {
+        return css.enum_property_util.parse(@This(), input);
+    }
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+        return css.enum_property_util.toCss(@This(), this, W, dest);
+    }
+
+    pub fn intoLengthPercentage(this: *const @This()) LengthPercentage {
+        return switch (this.*) {
+            .left => LengthPercentage.zero(),
+            .right => .{ .percentage = .{ .v = 1.0 } },
+        };
+    }
+};
+
+pub const VerticalPositionKeyword = enum {
+    /// The `top` keyword.
+    top,
+    /// The `bottom` keyword.
+    bottom,
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn eql(this: *const VerticalPositionKeyword, other: *const VerticalPositionKeyword) bool {
+        return this.* == other.*;
+    }
+
+    pub fn asStr(this: *const @This()) []const u8 {
+        return css.enum_property_util.asStr(@This(), this);
+    }
+
+    pub fn parse(input: *css.Parser) Result(@This()) {
+        return css.enum_property_util.parse(@This(), input);
+    }
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+        return css.enum_property_util.toCss(@This(), this, W, dest);
+    }
+
+    pub fn intoLengthPercentage(this: *const @This()) LengthPercentage {
+        return switch (this.*) {
+            .top => LengthPercentage.zero(),
+            .bottom => LengthPercentage{ .percentage = Percentage{ .v = 1.0 } },
+        };
+    }
+};
+
+pub const HorizontalPosition = PositionComponent(HorizontalPositionKeyword);
+pub const VerticalPosition = PositionComponent(VerticalPositionKeyword);
diff --git a/src/css/values/ratio.zig b/src/css/values/ratio.zig
new file mode 100644
index 0000000000..8784f898fd
--- /dev/null
+++ b/src/css/values/ratio.zig
@@ -0,0 +1,75 @@
+const std = @import("std");
+const bun = @import("root").bun;
+pub const css = @import("../css_parser.zig");
+const Result = css.Result;
+const ArrayList = std.ArrayListUnmanaged;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const CSSNumber = css.css_values.number.CSSNumber;
+const CSSNumberFns = css.css_values.number.CSSNumberFns;
+const Calc = css.css_values.calc.Calc;
+const DimensionPercentage = css.css_values.percentage.DimensionPercentage;
+const LengthPercentage = css.css_values.length.LengthPercentage;
+const Length = css.css_values.length.Length;
+const Percentage = css.css_values.percentage.Percentage;
+const CssColor = css.css_values.color.CssColor;
+const Image = css.css_values.image.Image;
+const Url = css.css_values.url.Url;
+const CSSInteger = css.css_values.number.CSSInteger;
+const CSSIntegerFns = css.css_values.number.CSSIntegerFns;
+const Angle = css.css_values.angle.Angle;
+const Time = css.css_values.time.Time;
+const Resolution = css.css_values.resolution.Resolution;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CustomIdentFns = css.css_values.ident.CustomIdentFns;
+const Ident = css.css_values.ident.Ident;
+
+/// A CSS [`<ratio>`](https://www.w3.org/TR/css-values-4/#ratios) value,
+/// representing the ratio of two numeric values.
+pub const Ratio = struct {
+    numerator: CSSNumber,
+    denominator: CSSNumber,
+
+    pub fn parse(input: *css.Parser) Result(Ratio) {
+        const first = switch (CSSNumberFns.parse(input)) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+        const second = if (input.tryParse(css.Parser.expectDelim, .{'/'}).isOk()) switch (CSSNumberFns.parse(input)) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        } else 1.0;
+
+        return .{ .result = Ratio{ .numerator = first, .denominator = second } };
+    }
+
+    /// Parses a ratio where both operands are required.
+    pub fn parseRequired(input: *css.Parser) Result(Ratio) {
+        const first = switch (CSSNumberFns.parse(input)) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+        if (input.expectDelim('/').asErr()) |e| return .{ .err = e };
+        const second = switch (CSSNumberFns.parse(input)) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+        return .{ .result = Ratio{ .numerator = first, .denominator = second } };
+    }
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *Printer(W)) PrintErr!void {
+        try CSSNumberFns.toCss(&this.numerator, W, dest);
+        if (this.denominator != 1.0) {
+            try dest.delim('/', true);
+            try CSSNumberFns.toCss(&this.denominator, W, dest);
+        }
+    }
+
+    pub fn addF32(this: Ratio, _: std.mem.Allocator, other: f32) Ratio {
+        return .{ .numerator = this.numerator + other, .denominator = this.denominator };
+    }
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+};
diff --git a/src/css/values/rect.zig b/src/css/values/rect.zig
new file mode 100644
index 0000000000..28b281c6d7
--- /dev/null
+++ b/src/css/values/rect.zig
@@ -0,0 +1,155 @@
+const std = @import("std");
+const bun = @import("root").bun;
+pub const css = @import("../css_parser.zig");
+const Result = css.Result;
+const ArrayList = std.ArrayListUnmanaged;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const CSSNumber = css.css_values.number.CSSNumber;
+const CSSNumberFns = css.css_values.number.CSSNumberFns;
+const Calc = css.css_values.calc.Calc;
+const DimensionPercentage = css.css_values.percentage.DimensionPercentage;
+const LengthPercentage = css.css_values.length.LengthPercentage;
+const Length = css.css_values.length.Length;
+const LengthOrNumber = css.css_values.length.LengthOrNumber;
+const Percentage = css.css_values.percentage.Percentage;
+const CssColor = css.css_values.color.CssColor;
+const Image = css.css_values.image.Image;
+const Url = css.css_values.url.Url;
+const CSSInteger = css.css_values.number.CSSInteger;
+const CSSIntegerFns = css.css_values.number.CSSIntegerFns;
+const Angle = css.css_values.angle.Angle;
+const Time = css.css_values.time.Time;
+const Resolution = css.css_values.resolution.Resolution;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CustomIdentFns = css.css_values.ident.CustomIdentFns;
+const Ident = css.css_values.ident.Ident;
+
+fn needsDeinit(comptime T: type) bool {
+    return switch (T) {
+        f32, i32, u32, []const u8 => false,
+        LengthPercentage => true,
+        LengthOrNumber => true,
+        css.css_values.percentage.NumberOrPercentage => false,
+        css.css_properties.border_image.BorderImageSideWidth => true,
+        *const css.css_values.percentage.DimensionPercentage(css.css_values.length.LengthValue) => true,
+        CssColor => true,
+        css.css_properties.border.LineStyle => false,
+        css.css_properties.border.BorderSideWidth => true,
+        css.css_values.length.LengthPercentageOrAuto => true,
+        else => @compileError("Don't know if " ++ @typeName(T) ++ " needs deinit. Please add it to this switch statement."),
+    };
+}
+
+/// A generic value that represents a value for four sides of a box,
+/// e.g. border-width, margin, padding, etc.
+///
+/// When serialized, as few components as possible are written when
+/// there are duplicate values.
+pub fn Rect(comptime T: type) type {
+    const needs_deinit = needsDeinit(T);
+    return struct {
+        /// The top component.
+        top: T,
+        /// The right component.
+        right: T,
+        /// The bottom component.
+        bottom: T,
+        /// The left component.
+        left: T,
+
+        const This = @This();
+
+        pub fn eql(this: *const This, other: *const This) bool {
+            return css.generic.eql(T, &this.top, &other.top) and css.generic.eql(T, &this.right, &other.right) and css.generic.eql(T, &this.bottom, &other.bottom) and css.generic.eql(T, &this.left, &other.left);
+        }
+
+        pub fn deepClone(this: *const This, allocator: std.mem.Allocator) This {
+            if (comptime needs_deinit or T == *const css.css_values.percentage.DimensionPercentage(css.css_values.length.LengthValue)) {
+                return This{
+                    .top = this.top.deepClone(allocator),
+                    .right = this.right.deepClone(allocator),
+                    .bottom = this.bottom.deepClone(allocator),
+                    .left = this.left.deepClone(allocator),
+                };
+            }
+            return This{
+                .top = this.top,
+                .right = this.right,
+                .bottom = this.bottom,
+                .left = this.left,
+            };
+        }
+
+        pub fn all(val: T) This {
+            return This{
+                .top = val,
+                .right = val,
+                .bottom = val,
+                .left = val,
+            };
+        }
+
+        pub fn deinit(this: *const This, allocator: std.mem.Allocator) void {
+            if (comptime needs_deinit) {
+                this.top.deinit(allocator);
+                this.right.deinit(allocator);
+                this.bottom.deinit(allocator);
+                this.left.deinit(allocator);
+            }
+        }
+
+        pub fn parse(input: *css.Parser) Result(This) {
+            return This.parseWith(input, valParse);
+        }
+
+        pub fn parseWith(input: *css.Parser, comptime parse_fn: anytype) Result(This) {
+            const first = switch (parse_fn(input)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            };
+            const second = switch (input.tryParse(parse_fn, .{})) {
+                .result => |v| v,
+                // <first>
+                .err => return .{ .result = This{ .top = first, .right = first, .bottom = first, .left = first } },
+            };
+            const third = switch (input.tryParse(parse_fn, .{})) {
+                .result => |v| v,
+                // <first> <second>
+                .err => return .{ .result = This{ .top = first, .right = second, .bottom = first, .left = second } },
+            };
+            const fourth = switch (input.tryParse(parse_fn, .{})) {
+                .result => |v| v,
+                // <first> <second> <third>
+                .err => return .{ .result = This{ .top = first, .right = second, .bottom = third, .left = second } },
+            };
+            // <first> <second> <third> <fourth>
+            return .{ .result = This{ .top = first, .right = second, .bottom = third, .left = fourth } };
+        }
+
+        pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+            try css.generic.toCss(T, &this.top, W, dest);
+            const same_vertical = css.generic.eql(T, &this.top, &this.bottom);
+            const same_horizontal = css.generic.eql(T, &this.right, &this.left);
+            if (same_vertical and same_horizontal and css.generic.eql(T, &this.top, &this.right)) {
+                return;
+            }
+            try dest.writeStr(" ");
+            try css.generic.toCss(T, &this.right, W, dest);
+            if (same_vertical and same_horizontal) {
+                return;
+            }
+            try dest.writeStr(" ");
+            try css.generic.toCss(T, &this.bottom, W, dest);
+            if (same_horizontal) {
+                return;
+            }
+            try dest.writeStr(" ");
+            try css.generic.toCss(T, &this.left, W, dest);
+        }
+
+        pub fn valParse(i: *css.Parser) Result(T) {
+            return css.generic.parse(T, i);
+        }
+    };
+}
diff --git a/src/css/values/resolution.zig b/src/css/values/resolution.zig
new file mode 100644
index 0000000000..951b809b21
--- /dev/null
+++ b/src/css/values/resolution.zig
@@ -0,0 +1,119 @@
+const std = @import("std");
+const bun = @import("root").bun;
+pub const css = @import("../css_parser.zig");
+const Result = css.Result;
+const ArrayList = std.ArrayListUnmanaged;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const CSSNumber = css.css_values.number.CSSNumber;
+const CSSNumberFns = css.css_values.number.CSSNumberFns;
+const Calc = css.css_values.calc.Calc;
+const DimensionPercentage = css.css_values.percentage.DimensionPercentage;
+const LengthPercentage = css.css_values.length.LengthPercentage;
+const Length = css.css_values.length.Length;
+const Percentage = css.css_values.percentage.Percentage;
+const CssColor = css.css_values.color.CssColor;
+const Image = css.css_values.image.Image;
+const CSSInteger = css.css_values.number.CSSInteger;
+const CSSIntegerFns = css.css_values.number.CSSIntegerFns;
+const Angle = css.css_values.angle.Angle;
+const Time = css.css_values.time.Time;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CustomIdentFns = css.css_values.ident.CustomIdentFns;
+const Ident = css.css_values.ident.Ident;
+
+/// A CSS `<resolution>` value.
+pub const Resolution = union(enum) {
+    /// A resolution in dots per inch.
+    dpi: CSSNumber,
+    /// A resolution in dots per centimeter.
+    dpcm: CSSNumber,
+    /// A resolution in dots per px.
+    dppx: CSSNumber,
+
+    // ~toCssImpl
+    const This = @This();
+
+    pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+        return css.implementHash(@This(), this, hasher);
+    }
+
+    pub fn eql(this: *const Resolution, other: *const Resolution) bool {
+        return switch (this.*) {
+            .dpi => |*a| switch (other.*) {
+                .dpi => a.* == other.dpi,
+                else => false,
+            },
+            .dpcm => |*a| switch (other.*) {
+                .dpcm => a.* == other.dpcm,
+                else => false,
+            },
+            .dppx => |*a| switch (other.*) {
+                .dppx => a.* == other.dppx,
+                else => false,
+            },
+        };
+    }
+
+    pub fn parse(input: *css.Parser) Result(Resolution) {
+        // TODO: calc?
+        const location = input.currentSourceLocation();
+        const tok = switch (input.next()) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+        if (tok.* == .dimension) {
+            const value = tok.dimension.num.value;
+            const unit = tok.dimension.unit;
+            // css.todo_stuff.match_ignore_ascii_case
+            if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(unit, "dpi")) return .{ .result = .{ .dpi = value } };
+            if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(unit, "dpcm")) return .{ .result = .{ .dpcm = value } };
+            if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(unit, "dppx") or bun.strings.eqlCaseInsensitiveASCIIICheckLength(unit, "x")) return .{ .result = .{ .dppx = value } };
+            return .{ .err = location.newUnexpectedTokenError(.{ .ident = unit }) };
+        }
+        return .{ .err = location.newUnexpectedTokenError(tok.*) };
+    }
+
+    pub fn tryFromToken(token: *const css.Token) css.Maybe(Resolution, void) {
+        switch (token.*) {
+            .dimension => |dim| {
+                const value = dim.num.value;
+                const unit = dim.unit;
+                // todo_stuff.match_ignore_ascii_case
+                if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(unit, "dpi")) {
+                    return .{ .result = .{ .dpi = value } };
+                } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(unit, "dpcm")) {
+                    return .{ .result = .{ .dpcm = value } };
+                } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(unit, "dppx") or
+                    bun.strings.eqlCaseInsensitiveASCIIICheckLength(unit, "x"))
+                {
+                    return .{ .result = .{ .dppx = value } };
+                } else {
+                    return .{ .err = {} };
+                }
+            },
+            else => return .{ .err = {} },
+        }
+    }
+
+    pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        const value, const unit = switch (this.*) {
+            .dpi => |dpi| .{ dpi, "dpi" },
+            .dpcm => |dpcm| .{ dpcm, "dpcm" },
+            .dppx => |dppx| if (dest.targets.isCompatible(.x_resolution_unit))
+                .{ dppx, "x" }
+            else
+                .{ dppx, "dppx" },
+        };
+
+        return try css.serializer.serializeDimension(value, unit, W, dest);
+    }
+
+    pub fn addF32(this: This, _: std.mem.Allocator, other: f32) Resolution {
+        return switch (this) {
+            .dpi => |dpi| .{ .dpi = dpi + other },
+            .dpcm => |dpcm| .{ .dpcm = dpcm + other },
+            .dppx => |dppx| .{ .dppx = dppx + other },
+        };
+    }
+};
diff --git a/src/css/values/size.zig b/src/css/values/size.zig
new file mode 100644
index 0000000000..07aceaa9aa
--- /dev/null
+++ b/src/css/values/size.zig
@@ -0,0 +1,88 @@
+const std = @import("std");
+const bun = @import("root").bun;
+pub const css = @import("../css_parser.zig");
+const Result = css.Result;
+const ArrayList = std.ArrayListUnmanaged;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const CSSNumber = css.css_values.number.CSSNumber;
+const CSSNumberFns = css.css_values.number.CSSNumberFns;
+const Calc = css.css_values.calc.Calc;
+const DimensionPercentage = css.css_values.percentage.DimensionPercentage;
+const LengthPercentage = css.css_values.length.LengthPercentage;
+const Length = css.css_values.length.Length;
+const Percentage = css.css_values.percentage.Percentage;
+const CssColor = css.css_values.color.CssColor;
+const Image = css.css_values.image.Image;
+const Url = css.css_values.url.Url;
+const CSSInteger = css.css_values.number.CSSInteger;
+const CSSIntegerFns = css.css_values.number.CSSIntegerFns;
+const Angle = css.css_values.angle.Angle;
+const Time = css.css_values.time.Time;
+const Resolution = css.css_values.resolution.Resolution;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CustomIdentFns = css.css_values.ident.CustomIdentFns;
+const Ident = css.css_values.ident.Ident;
+
+/// A generic value that represents a value with two components, e.g. a border radius.
+///
+/// When serialized, only a single component will be written if both are equal.
+pub fn Size2D(comptime T: type) type {
+    return struct {
+        a: T,
+        b: T,
+
+        fn parseVal(input: *css.Parser) Result(T) {
+            return switch (T) {
+                f32 => return CSSNumberFns.parse(input),
+                LengthPercentage => return LengthPercentage.parse(input),
+                else => T.parse(input),
+            };
+        }
+
+        pub fn parse(input: *css.Parser) Result(Size2D(T)) {
+            const first = switch (parseVal(input)) {
+                .result => |vv| vv,
+                .err => |e| return .{ .err = e },
+            };
+            const second = input.tryParse(parseVal, .{}).unwrapOrNoOptmizations(first);
+            return .{ .result = Size2D(T){
+                .a = first,
+                .b = second,
+            } };
+        }
+
+        pub fn toCss(this: *const Size2D(T), comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+            try valToCss(&this.a, W, dest);
+            if (!valEql(&this.b, &this.a)) {
+                try dest.writeStr(" ");
+                try valToCss(&this.b, W, dest);
+            }
+        }
+
+        pub fn valToCss(val: *const T, comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+            return switch (T) {
+                f32 => CSSNumberFns.toCss(val, W, dest),
+                else => val.toCss(W, dest),
+            };
+        }
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+
+        pub inline fn valEql(lhs: *const T, rhs: *const T) bool {
+            return switch (T) {
+                f32 => lhs.* == rhs.*,
+                else => lhs.eql(rhs),
+            };
+        }
+
+        pub inline fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+            return switch (T) {
+                f32 => lhs.a == rhs.b,
+                else => lhs.a.eql(&rhs.b),
+            };
+        }
+    };
+}
diff --git a/src/css/values/syntax.zig b/src/css/values/syntax.zig
new file mode 100644
index 0000000000..5f8a743367
--- /dev/null
+++ b/src/css/values/syntax.zig
@@ -0,0 +1,525 @@
+const std = @import("std");
+const bun = @import("root").bun;
+pub const css = @import("../css_parser.zig");
+const Result = css.Result;
+const ArrayList = std.ArrayListUnmanaged;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const CSSNumber = css.css_values.number.CSSNumber;
+const CSSNumberFns = css.css_values.number.CSSNumberFns;
+const Calc = css.css_values.calc.Calc;
+const DimensionPercentage = css.css_values.percentage.DimensionPercentage;
+const LengthPercentage = css.css_values.length.LengthPercentage;
+const Length = css.css_values.length.Length;
+const Percentage = css.css_values.percentage.Percentage;
+const CssColor = css.css_values.color.CssColor;
+const Image = css.css_values.image.Image;
+const Url = css.css_values.url.Url;
+const CSSInteger = css.css_values.number.CSSInteger;
+const CSSIntegerFns = css.css_values.number.CSSIntegerFns;
+const Angle = css.css_values.angle.Angle;
+const Time = css.css_values.time.Time;
+const Resolution = css.css_values.resolution.Resolution;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CustomIdentFns = css.css_values.ident.CustomIdentFns;
+const Ident = css.css_values.ident.Ident;
+
+// https://drafts.csswg.org/css-syntax-3/#whitespace
+const SPACE_CHARACTERS: []const u8 = &.{ 0x20, 0x09 };
+
+/// A CSS [syntax string](https://drafts.css-houdini.org/css-properties-values-api/#syntax-strings)
+/// used to define the grammar for a registered custom property.
+pub const SyntaxString = union(enum) {
+    /// A list of syntax components.
+    components: ArrayList(SyntaxComponent),
+    /// The universal syntax definition.
+    universal,
+
+    const This = @This();
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        try dest.writeChar('"');
+        switch (this.*) {
+            .universal => try dest.writeChar('*'),
+            .components => |*components| {
+                var first = true;
+                for (components.items) |*component| {
+                    if (first) {
+                        first = false;
+                    } else {
+                        try dest.delim('|', true);
+                    }
+
+                    try component.toCss(W, dest);
+                }
+            },
+        }
+
+        return dest.writeChar('"');
+    }
+
+    pub fn parse(input: *css.Parser) Result(SyntaxString) {
+        const string = switch (input.expectString()) {
+            .result => |v| v,
+            .err => |e| return .{ .err = e },
+        };
+        const result = SyntaxString.parseString(input.allocator(), string);
+        if (result.isErr()) return .{ .err = input.newCustomError(css.ParserError.invalid_value) };
+        return .{ .result = result.result };
+    }
+
+    /// Parses a syntax string.
+    pub fn parseString(allocator: std.mem.Allocator, input: []const u8) css.Maybe(SyntaxString, void) {
+        // https://drafts.css-houdini.org/css-properties-values-api/#parsing-syntax
+        var trimmed_input = std.mem.trimLeft(u8, input, SPACE_CHARACTERS);
+        if (trimmed_input.len == 0) {
+            return .{ .err = {} };
+        }
+
+        if (bun.strings.eqlComptime(trimmed_input, "*")) {
+            return .{ .result = SyntaxString.universal };
+        }
+
+        var components = ArrayList(SyntaxComponent){};
+
+        // PERF(alloc): count first?
+        while (true) {
+            const component = switch (SyntaxComponent.parseString(trimmed_input)) {
+                .result => |v| v,
+                .err => |e| return .{ .err = e },
+            };
+            components.append(
+                allocator,
+                component,
+            ) catch bun.outOfMemory();
+
+            trimmed_input = std.mem.trimLeft(u8, trimmed_input, SPACE_CHARACTERS);
+            if (trimmed_input.len == 0) {
+                break;
+            }
+
+            if (bun.strings.startsWithChar(trimmed_input, '|')) {
+                trimmed_input = trimmed_input[1..];
+                continue;
+            }
+
+            return .{ .err = {} };
+        }
+
+        return .{ .result = SyntaxString{ .components = components } };
+    }
+
+    /// Parses a value according to the syntax grammar.
+    pub fn parseValue(this: *const SyntaxString, input: *css.Parser) Result(ParsedComponent) {
+        switch (this.*) {
+            .universal => return .{ .result = ParsedComponent{
+                .token_list = switch (css.css_properties.custom.TokenList.parse(
+                    input,
+                    &css.ParserOptions.default(input.allocator(), null),
+                    0,
+                )) {
+                    .result => |v| v,
+                    .err => |e| return .{ .err = e },
+                },
+            } },
+            .components => |components| {
+                // Loop through each component, and return the first one that parses successfully.
+                for (components.items) |component| {
+                    const state = input.state();
+                    // PERF: deinit this on error
+                    var parsed = ArrayList(ParsedComponent){};
+
+                    while (true) {
+                        const value_result = input.tryParse(struct {
+                            fn parse(
+                                i: *css.Parser,
+                                comp: SyntaxComponent,
+                            ) Result(ParsedComponent) {
+                                const value = switch (comp.kind) {
+                                    .length => ParsedComponent{ .length = switch (Length.parse(i)) {
+                                        .result => |vv| vv,
+                                        .err => |e| return .{ .err = e },
+                                    } },
+                                    .number => ParsedComponent{ .number = switch (CSSNumberFns.parse(i)) {
+                                        .result => |vv| vv,
+                                        .err => |e| return .{ .err = e },
+                                    } },
+                                    .percentage => ParsedComponent{ .percentage = switch (Percentage.parse(i)) {
+                                        .result => |vv| vv,
+                                        .err => |e| return .{ .err = e },
+                                    } },
+                                    .length_percentage => ParsedComponent{ .length_percentage = switch (LengthPercentage.parse(i)) {
+                                        .result => |vv| vv,
+                                        .err => |e| return .{ .err = e },
+                                    } },
+                                    .color => ParsedComponent{ .color = switch (CssColor.parse(i)) {
+                                        .result => |vv| vv,
+                                        .err => |e| return .{ .err = e },
+                                    } },
+                                    .image => ParsedComponent{ .image = switch (Image.parse(i)) {
+                                        .result => |vv| vv,
+                                        .err => |e| return .{ .err = e },
+                                    } },
+                                    .url => ParsedComponent{ .url = switch (Url.parse(i)) {
+                                        .result => |vv| vv,
+                                        .err => |e| return .{ .err = e },
+                                    } },
+                                    .integer => ParsedComponent{ .integer = switch (CSSIntegerFns.parse(i)) {
+                                        .result => |vv| vv,
+                                        .err => |e| return .{ .err = e },
+                                    } },
+                                    .angle => ParsedComponent{ .angle = switch (Angle.parse(i)) {
+                                        .result => |vv| vv,
+                                        .err => |e| return .{ .err = e },
+                                    } },
+                                    .time => ParsedComponent{ .time = switch (Time.parse(i)) {
+                                        .result => |vv| vv,
+                                        .err => |e| return .{ .err = e },
+                                    } },
+                                    .resolution => ParsedComponent{ .resolution = switch (Resolution.parse(i)) {
+                                        .result => |vv| vv,
+                                        .err => |e| return .{ .err = e },
+                                    } },
+                                    .transform_function => ParsedComponent{ .transform_function = switch (css.css_properties.transform.Transform.parse(i)) {
+                                        .result => |vv| vv,
+                                        .err => |e| return .{ .err = e },
+                                    } },
+                                    .transform_list => ParsedComponent{ .transform_list = switch (css.css_properties.transform.TransformList.parse(i)) {
+                                        .result => |vv| vv,
+                                        .err => |e| return .{ .err = e },
+                                    } },
+                                    .custom_ident => ParsedComponent{ .custom_ident = switch (CustomIdentFns.parse(i)) {
+                                        .result => |vv| vv,
+                                        .err => |e| return .{ .err = e },
+                                    } },
+                                    .literal => |value| blk: {
+                                        const location = i.currentSourceLocation();
+                                        const ident = switch (i.expectIdent()) {
+                                            .result => |v| v,
+                                            .err => |e| return .{ .err = e },
+                                        };
+                                        if (!bun.strings.eql(ident, value)) {
+                                            return .{ .err = location.newUnexpectedTokenError(.{ .ident = ident }) };
+                                        }
+                                        break :blk ParsedComponent{ .literal = .{ .v = ident } };
+                                    },
+                                };
+                                return .{ .result = value };
+                            }
+                        }.parse, .{component});
+
+                        if (value_result.asValue()) |value| {
+                            switch (component.multiplier) {
+                                .none => return .{ .result = value },
+                                .space => {
+                                    parsed.append(input.allocator(), value) catch bun.outOfMemory();
+                                    if (input.isExhausted()) {
+                                        return .{ .result = ParsedComponent{ .repeated = .{
+                                            .components = parsed,
+                                            .multiplier = component.multiplier,
+                                        } } };
+                                    }
+                                },
+                                .comma => {
+                                    parsed.append(input.allocator(), value) catch bun.outOfMemory();
+                                    if (input.next().asValue()) |token| {
+                                        if (token.* == .comma) continue;
+                                        break;
+                                    } else {
+                                        return .{ .result = ParsedComponent{ .repeated = .{
+                                            .components = parsed,
+                                            .multiplier = component.multiplier,
+                                        } } };
+                                    }
+                                },
+                            }
+                        } else {
+                            break;
+                        }
+                    }
+
+                    input.reset(&state);
+                }
+
+                return .{ .err = input.newErrorForNextToken() };
+            },
+        }
+    }
+};
+
+/// A [syntax component](https://drafts.css-houdini.org/css-properties-values-api/#syntax-component)
+/// within a [SyntaxString](SyntaxString).
+///
+/// A syntax component consists of a component kind an a multiplier, which indicates how the component
+/// may repeat during parsing.
+pub const SyntaxComponent = struct {
+    kind: SyntaxComponentKind,
+    multiplier: Multiplier,
+
+    pub fn parseString(input_: []const u8) css.Maybe(SyntaxComponent, void) {
+        var input = input_;
+        const kind = switch (SyntaxComponentKind.parseString(input)) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+
+        // Pre-multiplied types cannot have multipliers.
+        if (kind == .transform_list) {
+            return .{ .result = SyntaxComponent{
+                .kind = kind,
+                .multiplier = .none,
+            } };
+        }
+
+        var multiplier: Multiplier = .none;
+        if (bun.strings.startsWithChar(input, '+')) {
+            input = input[1..];
+            multiplier = .space;
+        } else if (bun.strings.startsWithChar(input, '#')) {
+            input = input[1..];
+            multiplier = .comma;
+        }
+
+        return .{ .result = SyntaxComponent{ .kind = kind, .multiplier = multiplier } };
+    }
+
+    pub fn toCss(this: *const SyntaxComponent, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        try this.kind.toCss(W, dest);
+        return switch (this.multiplier) {
+            .none => {},
+            .comma => dest.writeChar('#'),
+            .space => dest.writeChar('+'),
+        };
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A [syntax component component name](https://drafts.css-houdini.org/css-properties-values-api/#supported-names).
+pub const SyntaxComponentKind = union(enum) {
+    /// A `<length>` component.
+    length,
+    /// A `<number>` component.
+    number,
+    /// A `<percentage>` component.
+    percentage,
+    /// A `<length-percentage>` component.
+    length_percentage,
+    /// A `<color>` component.
+    color,
+    /// An `<image>` component.
+    image,
+    /// A `<url>` component.
+    url,
+    /// An `<integer>` component.
+    integer,
+    /// An `<angle>` component.
+    angle,
+    /// A `<time>` component.
+    time,
+    /// A `<resolution>` component.
+    resolution,
+    /// A `<transform-function>` component.
+    transform_function,
+    /// A `<transform-list>` component.
+    transform_list,
+    /// A `<custom-ident>` component.
+    custom_ident,
+    /// A literal component.
+    literal: []const u8,
+
+    pub fn parseString(input_: []const u8) css.Maybe(SyntaxComponentKind, void) {
+        // https://drafts.css-houdini.org/css-properties-values-api/#consume-syntax-component
+        var input = std.mem.trimLeft(u8, input_, SPACE_CHARACTERS);
+        if (bun.strings.startsWithChar(input, '<')) {
+            // https://drafts.css-houdini.org/css-properties-values-api/#consume-data-type-name
+            const end_idx = std.mem.indexOfScalar(u8, input, '>') orelse return .{ .err = {} };
+            const name = input[1..end_idx];
+            // todo_stuff.match_ignore_ascii_case
+            const component: SyntaxComponentKind = if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "length"))
+                .length
+            else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "number"))
+                .number
+            else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "percentage"))
+                .percentage
+            else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "length-percentage"))
+                .length_percentage
+            else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "color"))
+                .color
+            else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "image"))
+                .image
+            else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "url"))
+                .url
+            else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "integer"))
+                .integer
+            else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "angle"))
+                .angle
+            else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "time"))
+                .time
+            else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "resolution"))
+                .resolution
+            else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "transform-function"))
+                .transform_function
+            else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "transform-list"))
+                .transform_list
+            else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength(name, "custom-ident"))
+                .custom_ident
+            else
+                return .{ .err = {} };
+
+            input = input[end_idx + 1 ..];
+            return .{ .result = component };
+        } else if (input.len > 0 and isIdentStart(input[0])) {
+            // A literal.
+            var end_idx: usize = 0;
+            while (end_idx < input.len and
+                isNameCodePoint(input[end_idx])) : (end_idx +=
+                bun.strings.utf8ByteSequenceLengthUnsafe(input[end_idx]))
+            {}
+            const literal = input[0..end_idx];
+            input = input[end_idx..];
+            return .{ .result = SyntaxComponentKind{ .literal = literal } };
+        } else {
+            return .{ .err = {} };
+        }
+    }
+
+    pub fn toCss(this: *const SyntaxComponentKind, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        return switch (this.*) {
+            .length => try dest.writeStr("<length>"),
+            .number => try dest.writeStr("<number>"),
+            .percentage => try dest.writeStr("<percentage>"),
+            .length_percentage => try dest.writeStr("<length-percentage>"),
+            .color => try dest.writeStr("<color>"),
+            .image => try dest.writeStr("<image>"),
+            .url => try dest.writeStr("<url>"),
+            .integer => try dest.writeStr("<integer>"),
+            .angle => try dest.writeStr("<angle>"),
+            .time => try dest.writeStr("<time>"),
+            .resolution => try dest.writeStr("<resolution>"),
+            .transform_function => try dest.writeStr("<transform-function>"),
+            .transform_list => try dest.writeStr("<transform-list>"),
+            .custom_ident => try dest.writeStr("<custom-ident>"),
+            .literal => |l| try dest.writeStr(l),
+        };
+    }
+
+    fn isIdentStart(c: u8) bool {
+        // https://drafts.csswg.org/css-syntax-3/#ident-start-code-point
+        return c >= 'A' and c <= 'Z' or c >= 'a' and c <= 'z' or c >= 0x80 or c == '_';
+    }
+
+    fn isNameCodePoint(c: u8) bool {
+        // https://drafts.csswg.org/css-syntax-3/#ident-code-point
+        return isIdentStart(c) or c >= '0' and c <= '9' or c == '-';
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+pub const ParsedComponent = union(enum) {
+    /// A `<length>` value.
+    length: Length,
+    /// A `<number>` value.
+    number: CSSNumber,
+    /// A `<percentage>` value.
+    percentage: Percentage,
+    /// A `<length-percentage>` value.
+    length_percentage: LengthPercentage,
+    /// A `<color>` value.
+    color: CssColor,
+    /// An `<image>` value.
+    image: Image, // Zig doesn't have lifetimes, so 'i is omitted.
+    /// A `<url>` value.
+    url: Url, // Lifetimes are omitted in Zig.
+    /// An `<integer>` value.
+    integer: CSSInteger,
+    /// An `<angle>` value.
+    angle: Angle,
+    /// A `<time>` value.
+    time: Time,
+    /// A `<resolution>` value.
+    resolution: Resolution,
+    /// A `<transform-function>` value.
+    transform_function: css.css_properties.transform.Transform,
+    /// A `<transform-list>` value.
+    transform_list: css.css_properties.transform.TransformList,
+    /// A `<custom-ident>` value.
+    custom_ident: CustomIdent,
+    /// A literal value.
+    literal: Ident,
+    /// A repeated component value.
+    repeated: struct {
+        /// The components to repeat.
+        components: ArrayList(ParsedComponent),
+        /// A multiplier describing how the components repeat.
+        multiplier: Multiplier,
+
+        pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+            return css.implementDeepClone(@This(), this, allocator);
+        }
+    },
+    /// A raw token stream.
+    token_list: css.css_properties.custom.TokenList,
+
+    const This = @This();
+
+    pub fn toCss(this: *const This, comptime W: type, dest: *Printer(W)) PrintErr!void {
+        return switch (this.*) {
+            .length => |*v| try v.toCss(W, dest),
+            .number => |*v| try CSSNumberFns.toCss(v, W, dest),
+            .percentage => |*v| try v.toCss(W, dest),
+            .length_percentage => |*v| try v.toCss(W, dest),
+            .color => |*v| try v.toCss(W, dest),
+            .image => |*v| try v.toCss(W, dest),
+            .url => |*v| try v.toCss(W, dest),
+            .integer => |*v| try CSSIntegerFns.toCss(v, W, dest),
+            .angle => |*v| try v.toCss(W, dest),
+            .time => |*v| try v.toCss(W, dest),
+            .resolution => |*v| try v.toCss(W, dest),
+            .transform_function => |*v| try v.toCss(W, dest),
+            .transform_list => |*v| try v.toCss(W, dest),
+            .custom_ident => |*v| try CustomIdentFns.toCss(v, W, dest),
+            .literal => |*v| css.serializer.serializeIdentifier(v.v, dest) catch return dest.addFmtError(),
+            .repeated => |*r| {
+                var first = true;
+                for (r.components.items) |*component| {
+                    if (!first) {
+                        switch (r.multiplier) {
+                            .comma => try dest.delim(',', false),
+                            .space => try dest.writeChar(' '),
+                            .none => unreachable,
+                        }
+                    } else {
+                        first = false;
+                    }
+                    try component.toCss(W, dest);
+                }
+            },
+            .token_list => |*t| try t.toCss(W, dest, false),
+        };
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+};
+
+/// A [multiplier](https://drafts.css-houdini.org/css-properties-values-api/#multipliers) for a
+/// [SyntaxComponent](SyntaxComponent). Indicates whether and how the component may be repeated.
+pub const Multiplier = enum {
+    /// The component may not be repeated.
+    none,
+    /// The component may repeat one or more times, separated by spaces.
+    space,
+    /// The component may repeat one or more times, separated by commas.
+    comma,
+};
diff --git a/src/css/values/time.zig b/src/css/values/time.zig
new file mode 100644
index 0000000000..23ed5c9f86
--- /dev/null
+++ b/src/css/values/time.zig
@@ -0,0 +1,208 @@
+const std = @import("std");
+const bun = @import("root").bun;
+pub const css = @import("../css_parser.zig");
+const Result = css.Result;
+const ArrayList = std.ArrayListUnmanaged;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const CSSNumber = css.css_values.number.CSSNumber;
+const CSSNumberFns = css.css_values.number.CSSNumberFns;
+const Calc = css.css_values.calc.Calc;
+const DimensionPercentage = css.css_values.percentage.DimensionPercentage;
+const LengthPercentage = css.css_values.length.LengthPercentage;
+const Length = css.css_values.length.Length;
+const Percentage = css.css_values.percentage.Percentage;
+const CssColor = css.css_values.color.CssColor;
+const Image = css.css_values.image.Image;
+const Url = css.css_values.url.Url;
+const CSSInteger = css.css_values.number.CSSInteger;
+const CSSIntegerFns = css.css_values.number.CSSIntegerFns;
+const Angle = css.css_values.angle.Angle;
+const Resolution = css.css_values.resolution.Resolution;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CustomIdentFns = css.css_values.ident.CustomIdentFns;
+const Ident = css.css_values.ident.Ident;
+
+/// A CSS [`<time>`](https://www.w3.org/TR/css-values-4/#time) value, in either
+/// seconds or milliseconds.
+///
+/// Time values may be explicit or computed by `calc()`, but are always stored and serialized
+/// as their computed value.
+pub const Time = union(enum) {
+    /// A time in seconds.
+    seconds: CSSNumber,
+    /// A time in milliseconds.
+    milliseconds: CSSNumber,
+
+    const Tag = enum(u8) { seconds = 1, milliseconds = 2 };
+
+    pub fn eql(lhs: *const @This(), rhs: *const @This()) bool {
+        return css.implementEql(@This(), lhs, rhs);
+    }
+    pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+        return css.implementHash(@This(), this, hasher);
+    }
+
+    pub fn parse(input: *css.Parser) Result(Time) {
+        var calc_result = switch (input.tryParse(Calc(Time).parse, .{})) {
+            .result => |v| v,
+            .err => |e| return .{ .err = e },
+        };
+        switch (calc_result) {
+            .value => |v| {
+                const ret: Time = v.*;
+                // redundant allocation
+                calc_result.deinit(input.allocator());
+                return .{ .result = ret };
+            },
+            // Time is always compatible, so they will always compute to a value.
+            else => return .{ .err = input.newErrorForNextToken() },
+        }
+
+        const location = input.currentSourceLocation();
+        const token = switch (input.next()) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+        switch (token.*) {
+            .dimension => |*dim| {
+                if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("s", dim.unit)) {
+                    return .{ .result = .{ .seconds = dim.value } };
+                } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("ms", dim.unit)) {
+                    return .{ .result = .{ .milliseconds = dim.value } };
+                } else {
+                    return .{ .err = location.newUnexpectedTokenError(css.Token{ .ident = dim.unit }) };
+                }
+            },
+            else => return .{ .err = location.newUnexpectedTokenError(token) },
+        }
+    }
+
+    pub fn toCss(this: *const @This(), comptime W: type, dest: *css.Printer(W)) css.PrintErr!void {
+        // 0.1s is shorter than 100ms
+        // anything smaller is longer
+        switch (this.*) {
+            .seconds => |s| {
+                if (s > 0.0 and s < 0.1) {
+                    try CSSNumberFns.toCss(&(s * 1000.0), W, dest);
+                    try dest.writeStr("ms");
+                } else {
+                    try CSSNumberFns.toCss(&s, W, dest);
+                    try dest.writeStr("s");
+                }
+            },
+            .milliseconds => |ms| {
+                if (ms == 0.0 or ms >= 100.0) {
+                    try CSSNumberFns.toCss(&(ms / 1000.0), W, dest);
+                    try dest.writeStr("s");
+                } else {
+                    try CSSNumberFns.toCss(&ms, W, dest);
+                    try dest.writeStr("ms");
+                }
+            },
+        }
+    }
+
+    /// Returns the time in milliseconds.
+    pub fn toMs(this: *const Time) CSSNumber {
+        return switch (this.*) {
+            .seconds => |v| v * 1000.0,
+            .milliseconds => |v| v,
+        };
+    }
+
+    pub fn tryFromToken(token: *const css.Token) css.Maybe(Time, void) {
+        switch (token.*) {
+            .dimension => |*dim| {
+                // todo_stuff.match_ignore_ascii_case
+                if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("s", dim.unit)) {
+                    return .{ .result = .{ .seconds = dim.num.value } };
+                } else if (bun.strings.eqlCaseInsensitiveASCIIICheckLength("ms", dim.unit)) {
+                    return .{ .result = .{ .milliseconds = dim.num.value } };
+                }
+            },
+            else => {},
+        }
+
+        return .{ .err = {} };
+    }
+
+    pub fn tryFromAngle(_: css.css_values.angle.Angle) ?@This() {
+        return null;
+    }
+
+    pub fn mulF32(this: @This(), _: std.mem.Allocator, other: f32) Time {
+        return switch (this) {
+            .seconds => .{ .seconds = this.seconds * other },
+            .milliseconds => .{ .milliseconds = this.milliseconds * other },
+        };
+    }
+
+    pub fn add(this: @This(), _: std.mem.Allocator, other: @This()) Time {
+        return switch (this) {
+            .seconds => |v| .{ .seconds = v + other.seconds },
+            .milliseconds => |v| .{ .milliseconds = v + other.milliseconds },
+        };
+    }
+
+    pub fn partialCmp(this: *const Time, other: *const Time) ?std.math.Order {
+        return css.generic.partialCmpF32(&this.toMs(), &other.toMs());
+    }
+
+    pub fn map(this: *const @This(), comptime map_fn: *const fn (f32) f32) Time {
+        return switch (this.*) {
+            .seconds => Time{ .seconds = map_fn(this.seconds) },
+            .milliseconds => Time{ .milliseconds = map_fn(this.milliseconds) },
+        };
+    }
+
+    pub fn sign(this: *const Time) f32 {
+        return switch (this.*) {
+            .seconds => |v| CSSNumberFns.sign(&v),
+            .milliseconds => |v| CSSNumberFns.sign(&v),
+        };
+    }
+
+    pub fn op(
+        this: *const Time,
+        other: *const Time,
+        ctx: anytype,
+        comptime op_fn: *const fn (@TypeOf(ctx), a: f32, b: f32) f32,
+    ) Time {
+        const self_tag: u16 = @intFromEnum(this.*);
+        const other_tag: u16 = @intFromEnum(other.*);
+        const S: u16 = @intFromEnum(Tag.seconds);
+        const MS: u16 = @intFromEnum(Tag.milliseconds);
+
+        const switch_val: u16 = self_tag | (@as(u16, other_tag) << 8);
+        return switch (switch_val) {
+            S | (S << 8) => Time{ .seconds = op_fn(ctx, this.seconds, other.seconds) },
+            MS | (MS << 8) => Time{ .milliseconds = op_fn(ctx, this.milliseconds, other.milliseconds) },
+            S | (MS << 8) => Time{ .seconds = op_fn(ctx, this.seconds, other.milliseconds / 1000.0) },
+            MS | (S << 8) => Time{ .milliseconds = op_fn(ctx, this.milliseconds, other.seconds * 1000.0) },
+            else => unreachable,
+        };
+    }
+
+    pub fn opTo(
+        this: *const Time,
+        other: *const Time,
+        comptime R: type,
+        ctx: anytype,
+        comptime op_fn: *const fn (@TypeOf(ctx), a: f32, b: f32) R,
+    ) R {
+        const self_tag: u16 = @intFromEnum(this.*);
+        const other_tag: u16 = @intFromEnum(other.*);
+        const S: u16 = @intFromEnum(Tag.seconds);
+        const MS: u16 = @intFromEnum(Tag.milliseconds);
+
+        const switch_val: u16 = self_tag | (@as(u16, other_tag) << 8);
+        return switch (switch_val) {
+            S | (S << 8) => op_fn(ctx, this.seconds, other.seconds),
+            MS | (MS << 8) => op_fn(ctx, this.milliseconds, other.milliseconds),
+            S | (MS << 8) => op_fn(ctx, this.seconds, other.milliseconds / 1000.0),
+            MS | (S << 8) => op_fn(ctx, this.milliseconds, other.seconds * 1000.0),
+            else => unreachable,
+        };
+    }
+};
diff --git a/src/css/values/url.zig b/src/css/values/url.zig
new file mode 100644
index 0000000000..ffa9bea03d
--- /dev/null
+++ b/src/css/values/url.zig
@@ -0,0 +1,163 @@
+const std = @import("std");
+const bun = @import("root").bun;
+pub const css = @import("../css_parser.zig");
+const Result = css.Result;
+const ArrayList = std.ArrayListUnmanaged;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+const CSSNumber = css.css_values.number.CSSNumber;
+const CSSNumberFns = css.css_values.number.CSSNumberFns;
+const Calc = css.css_values.calc.Calc;
+const DimensionPercentage = css.css_values.percentage.DimensionPercentage;
+const LengthPercentage = css.css_values.length.LengthPercentage;
+const Length = css.css_values.length.Length;
+const Percentage = css.css_values.percentage.Percentage;
+const CssColor = css.css_values.color.CssColor;
+const Image = css.css_values.image.Image;
+const CSSInteger = css.css_values.number.CSSInteger;
+const CSSIntegerFns = css.css_values.number.CSSIntegerFns;
+const Angle = css.css_values.angle.Angle;
+const Time = css.css_values.time.Time;
+const Resolution = css.css_values.resolution.Resolution;
+const CustomIdent = css.css_values.ident.CustomIdent;
+const CustomIdentFns = css.css_values.ident.CustomIdentFns;
+const Ident = css.css_values.ident.Ident;
+const UrlDependency = css.dependencies.UrlDependency;
+
+/// A CSS [url()](https://www.w3.org/TR/css-values-4/#urls) value and its source location.
+pub const Url = struct {
+    /// The url string.
+    import_record_idx: u32,
+    /// The location where the `url()` was seen in the CSS source file.
+    loc: css.dependencies.Location,
+
+    const This = @This();
+
+    pub fn parse(input: *css.Parser) Result(Url) {
+        const start_pos = input.position();
+        const loc = input.currentSourceLocation();
+        const url = switch (input.expectUrl()) {
+            .result => |vv| vv,
+            .err => |e| return .{ .err = e },
+        };
+        const import_record_idx = switch (input.addImportRecordForUrl(url, start_pos)) {
+            .result => |idx| idx,
+            .err => |e| return .{ .err = e },
+        };
+        return .{ .result = Url{ .import_record_idx = import_record_idx, .loc = css.dependencies.Location.fromSourceLocation(loc) } };
+    }
+
+    /// Returns whether the URL is absolute, and not relative.
+    pub fn isAbsolute(this: *const This, import_records: *const bun.BabyList(bun.ImportRecord)) bool {
+        const url = import_records.at(this.import_record_idx).path.pretty;
+
+        // Quick checks. If the url starts with '.', it is relative.
+        if (bun.strings.startsWithChar(url, '.')) {
+            return false;
+        }
+
+        // If the url starts with '/' it is absolute.
+        if (bun.strings.startsWithChar(url, '/')) {
+            return true;
+        }
+
+        // If the url starts with '#' we have a fragment URL.
+        // These are resolved relative to the document rather than the CSS file.
+        // https://drafts.csswg.org/css-values-4/#local-urls
+        if (bun.strings.startsWithChar(url, '#')) {
+            return true;
+        }
+
+        // Otherwise, we might have a scheme. These must start with an ascii alpha character.
+        // https://url.spec.whatwg.org/#scheme-start-state
+        if (url.len == 0 or !std.ascii.isAlphabetic(url[0])) {
+            return false;
+        }
+
+        // https://url.spec.whatwg.org/#scheme-state
+        for (url) |c| {
+            switch (c) {
+                'a'...'z', 'A'...'Z', '0'...'9', '+', '-', '.' => {},
+                ':' => return true,
+                else => break,
+            }
+        }
+
+        return false;
+    }
+
+    pub fn toCss(
+        this: *const This,
+        comptime W: type,
+        dest: *Printer(W),
+    ) PrintErr!void {
+        const dep: ?UrlDependency = if (dest.dependencies != null)
+            UrlDependency.new(dest.allocator, this, dest.filename(), try dest.getImportRecords())
+        else
+            null;
+
+        // If adding dependencies, always write url() with quotes so that the placeholder can
+        // be replaced without escaping more easily. Quotes may be removed later during minification.
+        if (dep) |d| {
+            try dest.writeStr("url(");
+            css.serializer.serializeString(d.placeholder, dest) catch return dest.addFmtError();
+            try dest.writeChar(')');
+
+            if (dest.dependencies) |*dependencies| {
+                dependencies.append(dest.allocator, css.Dependency{ .url = d }) catch bun.outOfMemory();
+            }
+
+            return;
+        }
+
+        const import_record = try dest.importRecord(this.import_record_idx);
+        const url = import_record.path.text;
+
+        if (dest.minify and !import_record.is_internal) {
+            var buf = ArrayList(u8){};
+            // PERF(alloc) we could use stack fallback here?
+            var bufw = buf.writer(dest.allocator);
+            const BufW = @TypeOf(bufw);
+            _ = BufW; // autofix
+            defer buf.deinit(dest.allocator);
+            css.Token.toCssGeneric(&css.Token{ .unquoted_url = url }, &bufw) catch return dest.addFmtError();
+
+            // If the unquoted url is longer than it would be quoted (e.g. `url("...")`)
+            // then serialize as a string and choose the shorter version.
+            if (buf.items.len > url.len + 7) {
+                var buf2 = ArrayList(u8){};
+                defer buf2.deinit(dest.allocator);
+                // PERF(alloc) we could use stack fallback here?
+                bufw = buf2.writer(dest.allocator);
+                css.serializer.serializeString(url, &bufw) catch return dest.addFmtError();
+                if (buf2.items.len + 5 < buf.items.len) {
+                    try dest.writeStr("url(");
+                    try dest.writeStr(buf2.items);
+                    return dest.writeChar(')');
+                }
+            }
+
+            try dest.writeStr(buf.items);
+        } else {
+            try dest.writeStr("url(");
+            css.serializer.serializeString(import_record.path.text, dest) catch return dest.addFmtError();
+            try dest.writeChar(')');
+        }
+    }
+
+    pub fn deepClone(this: *const @This(), allocator: std.mem.Allocator) @This() {
+        return css.implementDeepClone(@This(), this, allocator);
+    }
+
+    // TODO: dedupe import records??
+    // This might not fucking work
+    pub fn eql(this: *const Url, other: *const Url) bool {
+        return this.import_record_idx == other.import_record_idx;
+    }
+
+    // TODO: dedupe import records??
+    // This might not fucking work
+    pub fn hash(this: *const @This(), hasher: *std.hash.Wyhash) void {
+        return css.implementHash(@This(), this, hasher);
+    }
+};
diff --git a/src/css/values/values.zig b/src/css/values/values.zig
new file mode 100644
index 0000000000..f500f14ae7
--- /dev/null
+++ b/src/css/values/values.zig
@@ -0,0 +1,42 @@
+const std = @import("std");
+const bun = @import("root").bun;
+pub const css = @import("../css_parser.zig");
+const Error = css.Error;
+const ArrayList = std.ArrayListUnmanaged;
+const Printer = css.Printer;
+const PrintErr = css.PrintErr;
+
+pub const css_modules = struct {
+    /// Defines where the class names referenced in the `composes` property are located.
+    ///
+    /// See [Composes](Composes).
+    pub const Specifier = union(enum) {
+        /// The referenced name is global.
+        global,
+        /// The referenced name comes from the specified file.
+        file: []const u8,
+        /// The referenced name comes from a source index (used during bundling).
+        source_index: u32,
+    };
+};
+
+pub const angle = @import("./angle.zig");
+pub const ident = @import("./ident.zig");
+pub const string = @import("./css_string.zig");
+pub const color = @import("./color.zig");
+pub const image = @import("./image.zig");
+pub const number = @import("./number.zig");
+pub const calc = @import("./calc.zig");
+pub const percentage = @import("./percentage.zig");
+pub const length = @import("./length.zig");
+pub const position = @import("./position.zig");
+pub const syntax = @import("./syntax.zig");
+pub const alpha = @import("./alpha.zig");
+pub const ratio = @import("./ratio.zig");
+pub const size = @import("./size.zig");
+pub const rect = @import("./rect.zig");
+pub const time = @import("./time.zig");
+pub const easing = @import("./easing.zig");
+pub const url = @import("./url.zig");
+pub const resolution = @import("./resolution.zig");
+pub const gradient = @import("./gradient.zig");
diff --git a/src/darwin_c.zig b/src/darwin_c.zig
index cfea6b1f38..2c0268058f 100644
--- a/src/darwin_c.zig
+++ b/src/darwin_c.zig
@@ -826,9 +826,9 @@ pub const sockaddr_dl = extern struct {
     sdl_slen: u8, // link layer selector length */
     sdl_data: [12]u8, // minimum work area, can be larger; contains both if name and ll address */
     //#ifndef __APPLE__
-    //	/* For TokenRing */
-    //	u_short sdl_rcf;        /* source routing control */
-    //	u_short sdl_route[16];  /* source routing information */
+    //    /* For TokenRing */
+    //    u_short sdl_rcf;        /* source routing control */
+    //    u_short sdl_route[16];  /* source routing information */
     //#endif
 };
 
@@ -888,3 +888,7 @@ pub const CLOCK_THREAD_CPUTIME_ID = 1;
 pub const netdb = @cImport({
     @cInclude("netdb.h");
 });
+
+pub extern fn memset_pattern4(buf: [*]u8, pattern: [*]const u8, len: usize) void;
+pub extern fn memset_pattern8(buf: [*]u8, pattern: [*]const u8, len: usize) void;
+pub extern fn memset_pattern16(buf: [*]u8, pattern: [*]const u8, len: usize) void;
diff --git a/src/defines.zig b/src/defines.zig
index 43cdd144b6..f038248505 100644
--- a/src/defines.zig
+++ b/src/defines.zig
@@ -53,6 +53,8 @@ pub const DefineData = struct {
     // have any observable side effects.
     call_can_be_unwrapped_if_unused: bool = false,
 
+    method_call_must_be_replaced_with_undefined: bool = false,
+
     pub fn isUndefined(self: *const DefineData) bool {
         return self.valueless;
     }
@@ -64,81 +66,99 @@ 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,
             .can_be_removed_if_unused = a.can_be_removed_if_unused,
             .call_can_be_unwrapped_if_unused = a.call_can_be_unwrapped_if_unused,
             .original_name = b.original_name,
+            .valueless = a.method_call_must_be_replaced_with_undefined or b.method_call_must_be_replaced_with_undefined,
+            .method_call_must_be_replaced_with_undefined = a.method_call_must_be_replaced_with_undefined or b.method_call_must_be_replaced_with_undefined,
         };
     }
 
-    pub fn fromMergeableInput(defines: RawDefines, user_defines: *UserDefines, log: *logger.Log, allocator: std.mem.Allocator) !void {
-        try user_defines.ensureUnusedCapacity(@truncate(defines.count()));
-        var iter = defines.iterator();
-        while (iter.next()) |entry| {
-            var keySplitter = std.mem.split(u8, entry.key_ptr.*, ".");
-            while (keySplitter.next()) |part| {
-                if (!js_lexer.isIdentifier(part)) {
-                    if (strings.eql(part, entry.key_ptr)) {
-                        try log.addErrorFmt(null, logger.Loc{}, allocator, "define key \"{s}\" must be a valid identifier", .{entry.key_ptr.*});
-                    } else {
-                        try log.addErrorFmt(null, logger.Loc{}, allocator, "define key \"{s}\" contains invalid identifier \"{s}\"", .{ part, entry.value_ptr.* });
-                    }
-                    break;
+    pub fn fromMergeableInputEntry(user_defines: *UserDefines, key: []const u8, value_str: []const u8, value_is_undefined: bool, method_call_must_be_replaced_with_undefined: bool, log: *logger.Log, allocator: std.mem.Allocator) !void {
+        var keySplitter = std.mem.split(u8, key, ".");
+        while (keySplitter.next()) |part| {
+            if (!js_lexer.isIdentifier(part)) {
+                if (strings.eql(part, key)) {
+                    try log.addErrorFmt(null, logger.Loc{}, allocator, "define key \"{s}\" must be a valid identifier", .{key});
+                } else {
+                    try log.addErrorFmt(null, logger.Loc{}, allocator, "define key \"{s}\" contains invalid identifier \"{s}\"", .{ part, value_str });
                 }
+                break;
             }
-
-            // check for nested identifiers
-            var valueSplitter = std.mem.split(u8, entry.value_ptr.*, ".");
-            var isIdent = true;
-
-            while (valueSplitter.next()) |part| {
-                if (!js_lexer.isIdentifier(part) or js_lexer.Keywords.has(part)) {
-                    isIdent = false;
-                    break;
-                }
-            }
-
-            if (isIdent) {
-                // Special-case undefined. it's not an identifier here
-                // https://github.com/evanw/esbuild/issues/1407
-                const value = if (strings.eqlComptime(entry.value_ptr.*, "undefined"))
-                    js_ast.Expr.Data{ .e_undefined = js_ast.E.Undefined{} }
-                else
-                    js_ast.Expr.Data{ .e_identifier = .{
-                        .ref = Ref.None,
-                        .can_be_removed_if_unused = true,
-                    } };
-
-                user_defines.putAssumeCapacity(
-                    entry.key_ptr.*,
-                    DefineData{
-                        .value = value,
-                        .original_name = entry.value_ptr.*,
-                        .can_be_removed_if_unused = true,
-                    },
-                );
-                continue;
-            }
-            const _log = log;
-            var source = logger.Source{
-                .contents = entry.value_ptr.*,
-                .path = defines_path,
-                .key_path = fs.Path.initWithNamespace("defines", "internal"),
-            };
-            const expr = try json_parser.ParseEnvJSON(&source, _log, allocator);
-            const cloned = try expr.data.deepClone(allocator);
-            user_defines.putAssumeCapacity(entry.key_ptr.*, DefineData{
-                .value = cloned,
-                .can_be_removed_if_unused = expr.isPrimitiveLiteral(),
-            });
         }
+
+        // check for nested identifiers
+        var valueSplitter = std.mem.split(u8, value_str, ".");
+        var isIdent = true;
+
+        while (valueSplitter.next()) |part| {
+            if (!js_lexer.isIdentifier(part) or js_lexer.Keywords.has(part)) {
+                isIdent = false;
+                break;
+            }
+        }
+
+        if (isIdent) {
+            // Special-case undefined. it's not an identifier here
+            // https://github.com/evanw/esbuild/issues/1407
+            const value = if (value_is_undefined or strings.eqlComptime(value_str, "undefined"))
+                js_ast.Expr.Data{ .e_undefined = js_ast.E.Undefined{} }
+            else
+                js_ast.Expr.Data{ .e_identifier = .{
+                    .ref = Ref.None,
+                    .can_be_removed_if_unused = true,
+                } };
+
+            user_defines.putAssumeCapacity(
+                key,
+                DefineData{
+                    .value = value,
+                    .original_name = value_str,
+                    .can_be_removed_if_unused = true,
+                    .valueless = value_is_undefined,
+                    .method_call_must_be_replaced_with_undefined = method_call_must_be_replaced_with_undefined,
+                },
+            );
+            return;
+        }
+        const _log = log;
+        var source = logger.Source{
+            .contents = value_str,
+            .path = defines_path,
+        };
+        const expr = try json_parser.parseEnvJSON(&source, _log, allocator);
+        const cloned = try expr.data.deepClone(allocator);
+        user_defines.putAssumeCapacity(key, DefineData{
+            .value = cloned,
+            .can_be_removed_if_unused = expr.isPrimitiveLiteral(),
+            .valueless = value_is_undefined,
+            .method_call_must_be_replaced_with_undefined = method_call_must_be_replaced_with_undefined,
+        });
     }
 
-    pub fn fromInput(defines: RawDefines, log: *logger.Log, allocator: std.mem.Allocator) !UserDefines {
+    pub fn fromInput(defines: RawDefines, drop: []const []const u8, log: *logger.Log, allocator: std.mem.Allocator) !UserDefines {
         var user_defines = UserDefines.init(allocator);
-        try fromMergeableInput(defines, &user_defines, log, allocator);
+        var iterator = defines.iterator();
+        try user_defines.ensureUnusedCapacity(@truncate(defines.count() + drop.len));
+        while (iterator.next()) |entry| {
+            try fromMergeableInputEntry(&user_defines, entry.key_ptr.*, entry.value_ptr.*, false, false, log, allocator);
+        }
+
+        for (drop) |drop_item| {
+            if (drop_item.len > 0) {
+                try fromMergeableInputEntry(&user_defines, drop_item, "", true, true, log, allocator);
+            }
+        }
 
         return user_defines;
     }
@@ -170,6 +190,7 @@ const inf_val = js_ast.E.Number{ .value = std.math.inf(f64) };
 pub const Define = struct {
     identifiers: bun.StringHashMap(IdentifierDefine),
     dots: bun.StringHashMap([]DotDefine),
+    drop_debugger: bool,
     allocator: std.mem.Allocator,
 
     pub const Data = DefineData;
@@ -236,11 +257,12 @@ pub const Define = struct {
         }
     }
 
-    pub fn init(allocator: std.mem.Allocator, _user_defines: ?UserDefines, string_defines: ?UserDefinesArray) std.mem.Allocator.Error!*@This() {
-        var define = try allocator.create(Define);
+    pub fn init(allocator: std.mem.Allocator, _user_defines: ?UserDefines, string_defines: ?UserDefinesArray, drop_debugger: bool) bun.OOM!*@This() {
+        const define = try allocator.create(Define);
         define.allocator = allocator;
         define.identifiers = bun.StringHashMap(IdentifierDefine).init(allocator);
         define.dots = bun.StringHashMap([]DotDefine).init(allocator);
+        define.drop_debugger = drop_debugger;
         try define.dots.ensureTotalCapacity(124);
 
         const value_define = DefineData{
diff --git a/src/deps/boringssl.translated.zig b/src/deps/boringssl.translated.zig
index ee25a0948d..6ee215f90e 100644
--- a/src/deps/boringssl.translated.zig
+++ b/src/deps/boringssl.translated.zig
@@ -30,6 +30,17 @@ const timercmp = C.timercmp;
 const doesnt_exist = C.doesnt_exist;
 const struct_tm = C.struct_tm;
 const enum_ssl_verify_result_t = C.enum_ssl_verify_result_t;
+/// `isize` alias. Kept for clarity.
+///
+/// Docs from OpenSSL:
+/// > ossl_ssize_t is a signed type which is large enough to fit the size of any
+/// > valid memory allocation. We prefer using |size_t|, but sometimes we need a
+/// > signed type for OpenSSL API compatibility. This type can be used in such
+/// > cases to avoid overflow.
+/// >
+/// > Not all |size_t| values fit in |ossl_ssize_t|, but all |size_t| values that
+/// > are sizes of or indices into C objects, can be converted without overflow.
+const ossl_ssize_t = isize;
 
 pub const CRYPTO_THREADID = c_int;
 pub const struct_asn1_null_st = opaque {};
@@ -1105,7 +1116,15 @@ pub extern fn BIO_hexdump(bio: [*c]BIO, data: [*c]const u8, len: usize, indent:
 pub extern fn ERR_print_errors(bio: [*c]BIO) void;
 pub extern fn BIO_read_asn1(bio: [*c]BIO, out: [*c][*c]u8, out_len: [*c]usize, max_len: usize) c_int;
 pub extern fn BIO_s_mem() ?*const BIO_METHOD;
-// pub extern fn BIO_new_mem_buf(buf: ?*const anyopaque, len: ossl_ssize_t) [*c]BIO;
+
+/// BIO_new_mem_buf creates read-only BIO that reads from |len| bytes at |buf|.
+/// It returns the BIO or NULL on error. This function does not copy or take
+/// ownership of |buf|. The caller must ensure the memory pointed to by |buf|
+/// outlives the |BIO|.
+///
+/// If |len| is negative, then |buf| is treated as a NUL-terminated string, but
+/// don't depend on this in new code.
+pub extern fn BIO_new_mem_buf(buf: ?*const anyopaque, len: ossl_ssize_t) [*c]BIO;
 // pub extern fn BIO_mem_contents(bio: [*c]const BIO, out_contents: [*c][*c]const u8, out_len: [*c]usize) c_int;
 pub extern fn BIO_get_mem_data(bio: [*c]BIO, contents: [*c][*c]u8) c_long;
 pub extern fn BIO_get_mem_ptr(bio: [*c]BIO, out: [*c][*c]BUF_MEM) c_int;
@@ -18778,6 +18797,22 @@ pub const struct_bio_st = extern struct {
         return BIO_new(BIO_s_mem()) orelse error.OutOfMemory;
     }
 
+    /// Create a read-only `BIO` using an existing buffer. `buffer` is not
+    /// copied, and ownership is not transfered.
+    ///
+    /// `buffer` must outlive the returned `BIO`.
+    ///
+    /// Returns an error if
+    /// - the buffer is empty
+    /// - BIO initialization fails (same as `.init()`).
+    pub fn initReadonlyView(buffer: []const u8) !*struct_bio_st {
+        // NOTE: not exposing len parameter. If we want to ignore their
+        // suggestion and pass a negative value to make it treat `buffer` as a
+        // null-terminated string, create a separate `initReadonlyViewZ`
+        // constructor.
+        return BIO_new_mem_buf(buffer.ptr, buffer.len);
+    }
+
     pub fn deinit(this: *struct_bio_st) void {
         _ = BIO_free(this);
     }
diff --git a/src/deps/brotli_decoder.zig b/src/deps/brotli_decoder.zig
index 2d4dad91a4..1634931b54 100644
--- a/src/deps/brotli_decoder.zig
+++ b/src/deps/brotli_decoder.zig
@@ -12,26 +12,28 @@ pub const BrotliSharedDictionaryType = enum_BrotliSharedDictionaryType;
 // pub extern fn BrotliSharedDictionaryCreateInstance(alloc_func: brotli_alloc_func, free_func: brotli_free_func, @"opaque": ?*anyopaque) ?*BrotliSharedDictionary;
 // pub extern fn BrotliSharedDictionaryDestroyInstance(dict: ?*BrotliSharedDictionary) void;
 // pub extern fn BrotliSharedDictionaryAttach(dict: ?*BrotliSharedDictionary, @"type": BrotliSharedDictionaryType, data_size: usize, data: [*]const u8) c_int;
+
+pub extern fn BrotliDecoderSetParameter(state: *BrotliDecoder, param: c_uint, value: u32) callconv(.C) c_int;
+pub extern fn BrotliDecoderAttachDictionary(state: *BrotliDecoder, @"type": BrotliSharedDictionaryType, data_size: usize, data: [*]const u8) callconv(.C) c_int;
+pub extern fn BrotliDecoderCreateInstance(alloc_func: brotli_alloc_func, free_func: brotli_free_func, @"opaque": ?*anyopaque) callconv(.C) ?*BrotliDecoder;
+pub extern fn BrotliDecoderDestroyInstance(state: *BrotliDecoder) callconv(.C) void;
+pub extern fn BrotliDecoderDecompress(encoded_size: usize, encoded_buffer: [*]const u8, decoded_size: *usize, decoded_buffer: [*]u8) callconv(.C) BrotliDecoderResult;
+pub extern fn BrotliDecoderDecompressStream(state: *BrotliDecoder, available_in: *usize, next_in: *?[*]const u8, available_out: *usize, next_out: *?[*]u8, total_out: ?*usize) callconv(.C) BrotliDecoderResult;
+pub extern fn BrotliDecoderHasMoreOutput(state: *const BrotliDecoder) callconv(.C) c_int;
+pub extern fn BrotliDecoderTakeOutput(state: *BrotliDecoder, size: *usize) callconv(.C) ?[*]const u8;
+pub extern fn BrotliDecoderIsUsed(state: *const BrotliDecoder) callconv(.C) c_int;
+pub extern fn BrotliDecoderIsFinished(state: *const BrotliDecoder) callconv(.C) c_int;
+pub extern fn BrotliDecoderGetErrorCode(state: *const BrotliDecoder) callconv(.C) BrotliDecoderErrorCode2;
+pub extern fn BrotliDecoderErrorString(c: BrotliDecoderErrorCode) callconv(.C) ?[*:0]const u8;
+pub extern fn BrotliDecoderVersion() callconv(.C) u32;
+
 pub const BrotliDecoder = opaque {
-    extern "C" fn BrotliDecoderSetParameter(state: *BrotliDecoder, param: BrotliDecoderParameter, value: u32) callconv(.C) c_int;
-    extern "C" fn BrotliDecoderAttachDictionary(state: *BrotliDecoder, @"type": BrotliSharedDictionaryType, data_size: usize, data: [*]const u8) callconv(.C) c_int;
-    extern "C" fn BrotliDecoderCreateInstance(alloc_func: brotli_alloc_func, free_func: brotli_free_func, @"opaque": ?*anyopaque) callconv(.C) ?*BrotliDecoder;
-    extern "C" fn BrotliDecoderDestroyInstance(state: *BrotliDecoder) callconv(.C) void;
-    extern "C" fn BrotliDecoderDecompress(encoded_size: usize, encoded_buffer: [*]const u8, decoded_size: *usize, decoded_buffer: [*]u8) callconv(.C) BrotliDecoderResult;
-    extern "C" fn BrotliDecoderDecompressStream(state: *BrotliDecoder, available_in: *usize, next_in: *?[*]const u8, available_out: *usize, next_out: *?[*]u8, total_out: ?*usize) callconv(.C) BrotliDecoderResult;
-    extern "C" fn BrotliDecoderHasMoreOutput(state: *const BrotliDecoder) callconv(.C) c_int;
-    extern "C" fn BrotliDecoderTakeOutput(state: *BrotliDecoder, size: *usize) callconv(.C) ?[*]const u8;
-    extern "C" fn BrotliDecoderIsUsed(state: *const BrotliDecoder) callconv(.C) c_int;
-    extern "C" fn BrotliDecoderIsFinished(state: *const BrotliDecoder) callconv(.C) c_int;
-    extern "C" fn BrotliDecoderGetErrorCode(state: *const BrotliDecoder) callconv(.C) BrotliDecoderErrorCode;
-    extern "C" fn BrotliDecoderErrorString(c: BrotliDecoderErrorCode) callconv(.C) ?[*:0]const u8;
-    extern "C" fn BrotliDecoderVersion() callconv(.C) u32;
     const BrotliDecoderSetMetadataCallbacks = fn (state: *BrotliDecoder, start_func: brotli_decoder_metadata_start_func, chunk_func: brotli_decoder_metadata_chunk_func, @"opaque": ?*anyopaque) callconv(.C) void;
     const brotli_decoder_metadata_start_func = ?*const fn (?*anyopaque, usize) callconv(.C) void;
     const brotli_decoder_metadata_chunk_func = ?*const fn (?*anyopaque, [*]const u8, usize) callconv(.C) void;
 
     pub fn setParameter(state: *BrotliDecoder, param: BrotliDecoderParameter, value: u32) callconv(.C) bool {
-        return BrotliDecoderSetParameter(state, param, value) > 0;
+        return BrotliDecoderSetParameter(state, @intFromEnum(param), value) > 0;
     }
 
     pub fn attachDictionary(state: *BrotliDecoder, @"type": BrotliSharedDictionaryType, data: []const u8) callconv(.C) c_int {
@@ -73,7 +75,7 @@ pub const BrotliDecoder = opaque {
     }
 
     pub fn getErrorCode(state: *const BrotliDecoder) callconv(.C) BrotliDecoderErrorCode {
-        return BrotliDecoderGetErrorCode(state);
+        return @enumFromInt(@intFromEnum(BrotliDecoderGetErrorCode(state)));
     }
 
     pub fn errorString(c: BrotliDecoderErrorCode) callconv(.C) [:0]const u8 {
@@ -152,6 +154,38 @@ pub const BrotliDecoderErrorCode = enum(c_int) {
     ALLOC_BLOCK_TYPE_TREES = -30,
     UNREACHABLE = -31,
 };
+pub const BrotliDecoderErrorCode2 = enum(c_int) {
+    NO_ERROR = 0,
+    SUCCESS = 1,
+    NEEDS_MORE_INPUT = 2,
+    NEEDS_MORE_OUTPUT = 3,
+    ERROR_FORMAT_EXUBERANT_NIBBLE = -1,
+    ERROR_FORMAT_RESERVED = -2,
+    ERROR_FORMAT_EXUBERANT_META_NIBBLE = -3,
+    ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET = -4,
+    ERROR_FORMAT_SIMPLE_HUFFMAN_SAME = -5,
+    ERROR_FORMAT_CL_SPACE = -6,
+    ERROR_FORMAT_HUFFMAN_SPACE = -7,
+    ERROR_FORMAT_CONTEXT_MAP_REPEAT = -8,
+    ERROR_FORMAT_BLOCK_LENGTH_1 = -9,
+    ERROR_FORMAT_BLOCK_LENGTH_2 = -10,
+    ERROR_FORMAT_TRANSFORM = -11,
+    ERROR_FORMAT_DICTIONARY = -12,
+    ERROR_FORMAT_WINDOW_BITS = -13,
+    ERROR_FORMAT_PADDING_1 = -14,
+    ERROR_FORMAT_PADDING_2 = -15,
+    ERROR_FORMAT_DISTANCE = -16,
+    ERROR_COMPOUND_DICTIONARY = -18,
+    ERROR_DICTIONARY_NOT_SET = -19,
+    ERROR_INVALID_ARGUMENTS = -20,
+    ERROR_ALLOC_CONTEXT_MODES = -21,
+    ERROR_ALLOC_TREE_GROUPS = -22,
+    ERROR_ALLOC_CONTEXT_MAP = -25,
+    ERROR_ALLOC_RING_BUFFER_1 = -26,
+    ERROR_ALLOC_RING_BUFFER_2 = -27,
+    ERROR_ALLOC_BLOCK_TYPE_TREES = -30,
+    ERROR_UNREACHABLE = -31,
+};
 pub const BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION: c_int = 0;
 pub const BROTLI_DECODER_PARAM_LARGE_WINDOW: c_int = 1;
 pub const BrotliDecoderParameter = enum(c_uint) {
diff --git a/src/deps/brotli_encoder.zig b/src/deps/brotli_encoder.zig
index 9bd8614205..5143169724 100644
--- a/src/deps/brotli_encoder.zig
+++ b/src/deps/brotli_encoder.zig
@@ -9,6 +9,8 @@ pub const BROTLI_SHARED_DICTIONARY_RAW: c_int = 0;
 pub const BROTLI_SHARED_DICTIONARY_SERIALIZED: c_int = 1;
 pub const enum_BrotliSharedDictionaryType = c_uint;
 pub const BrotliSharedDictionaryType = enum_BrotliSharedDictionaryType;
+pub const struct_BrotliEncoderPreparedDictionaryStruct = opaque {};
+pub const BrotliEncoderPreparedDictionary = struct_BrotliEncoderPreparedDictionaryStruct;
 extern fn BrotliSharedDictionaryCreateInstance(alloc_func: brotli_alloc_func, free_func: brotli_free_func, @"opaque": ?*anyopaque) ?*BrotliSharedDictionary;
 extern fn BrotliSharedDictionaryDestroyInstance(dict: ?*BrotliSharedDictionary) void;
 extern fn BrotliSharedDictionaryAttach(dict: ?*BrotliSharedDictionary, @"type": BrotliSharedDictionaryType, data_size: usize, data: [*c]const u8) c_int;
@@ -46,7 +48,25 @@ pub const BrotliEncoderParameter = enum(c_uint) {
     npostfix = 7,
     ndirect = 8,
     stream_offset = 9,
+    // update kMaxBrotliParam in src/js/node/zlib.ts if this list changes
 };
+
+pub extern fn BrotliEncoderSetParameter(state: *BrotliEncoder, param: c_uint, value: u32) c_int;
+pub extern fn BrotliEncoderCreateInstance(alloc_func: brotli_alloc_func, free_func: brotli_free_func, @"opaque": ?*anyopaque) ?*BrotliEncoder;
+pub extern fn BrotliEncoderDestroyInstance(state: *BrotliEncoder) void;
+pub extern fn BrotliEncoderPrepareDictionary(@"type": BrotliSharedDictionaryType, data_size: usize, data: [*c]const u8, quality: c_int, alloc_func: brotli_alloc_func, free_func: brotli_free_func, @"opaque": ?*anyopaque) *BrotliEncoderPreparedDictionary;
+pub extern fn BrotliEncoderDestroyPreparedDictionary(dictionary: *BrotliEncoderPreparedDictionary) void;
+pub extern fn BrotliEncoderAttachPreparedDictionary(state: *BrotliEncoder, dictionary: ?*const BrotliEncoderPreparedDictionary) c_int;
+pub extern fn BrotliEncoderMaxCompressedSize(input_size: usize) usize;
+pub extern fn BrotliEncoderCompress(quality: c_int, lgwin: c_int, mode: BrotliEncoderMode, input_size: usize, input_buffer: [*]const u8, encoded_size: *usize, encoded_buffer: [*]u8) c_int;
+pub extern fn BrotliEncoderCompressStream(state: *BrotliEncoder, op: BrotliEncoder.Operation, available_in: *usize, next_in: *?[*]const u8, available_out: *usize, next_in: ?*?[*]u8, total_out: ?*usize) c_int;
+pub extern fn BrotliEncoderIsFinished(state: *BrotliEncoder) c_int;
+pub extern fn BrotliEncoderHasMoreOutput(state: *BrotliEncoder) c_int;
+pub extern fn BrotliEncoderTakeOutput(state: *BrotliEncoder, size: *usize) ?[*]const u8;
+pub extern fn BrotliEncoderEstimatePeakMemoryUsage(quality: c_int, lgwin: c_int, input_size: usize) usize;
+pub extern fn BrotliEncoderGetPreparedDictionarySize(dictionary: ?*const BrotliEncoderPreparedDictionary) usize;
+pub extern fn BrotliEncoderVersion() u32;
+
 pub const BrotliEncoder = opaque {
     pub const Operation = enum(c_uint) {
         process = 0,
@@ -55,24 +75,6 @@ pub const BrotliEncoder = opaque {
         emit_metadata = 3,
     };
 
-    extern fn BrotliEncoderSetParameter(state: *BrotliEncoder, param: BrotliEncoderParameter, value: u32) c_int;
-    extern fn BrotliEncoderCreateInstance(alloc_func: brotli_alloc_func, free_func: brotli_free_func, @"opaque": ?*anyopaque) *BrotliEncoder;
-    extern fn BrotliEncoderDestroyInstance(state: *BrotliEncoder) void;
-    pub const struct_BrotliEncoderPreparedDictionaryStruct = opaque {};
-    pub const BrotliEncoderPreparedDictionary = struct_BrotliEncoderPreparedDictionaryStruct;
-    extern fn BrotliEncoderPrepareDictionary(@"type": BrotliSharedDictionaryType, data_size: usize, data: [*c]const u8, quality: c_int, alloc_func: brotli_alloc_func, free_func: brotli_free_func, @"opaque": ?*anyopaque) *BrotliEncoderPreparedDictionary;
-    extern fn BrotliEncoderDestroyPreparedDictionary(dictionary: *BrotliEncoderPreparedDictionary) void;
-    extern fn BrotliEncoderAttachPreparedDictionary(state: *BrotliEncoder, dictionary: ?*const BrotliEncoderPreparedDictionary) c_int;
-    extern fn BrotliEncoderMaxCompressedSize(input_size: usize) usize;
-    extern fn BrotliEncoderCompress(quality: c_int, lgwin: c_int, mode: BrotliEncoderMode, input_size: usize, input_buffer: [*]const u8, encoded_size: *usize, encoded_buffer: [*]u8) c_int;
-    extern fn BrotliEncoderCompressStream(state: *BrotliEncoder, op: Operation, available_in: *usize, next_in: *?[*]const u8, available_out: *usize, next_out: ?[*]u8, total_out: ?*usize) c_int;
-    extern fn BrotliEncoderIsFinished(state: *BrotliEncoder) c_int;
-    extern fn BrotliEncoderHasMoreOutput(state: *BrotliEncoder) c_int;
-    extern fn BrotliEncoderTakeOutput(state: *BrotliEncoder, size: *usize) ?[*]const u8;
-    extern fn BrotliEncoderEstimatePeakMemoryUsage(quality: c_int, lgwin: c_int, input_size: usize) usize;
-    extern fn BrotliEncoderGetPreparedDictionarySize(dictionary: ?*const BrotliEncoderPreparedDictionary) usize;
-    extern fn BrotliEncoderVersion() u32;
-
     pub fn createInstance(alloc_func: brotli_alloc_func, free_func: brotli_free_func, @"opaque": ?*anyopaque) callconv(.C) ?*BrotliEncoder {
         return BrotliEncoderCreateInstance(alloc_func, free_func, @"opaque");
     }
@@ -121,7 +123,7 @@ pub const BrotliEncoder = opaque {
     }
 
     pub fn setParameter(state: *BrotliEncoder, param: BrotliEncoderParameter, value: u32) bool {
-        return BrotliEncoderSetParameter(state, param, value) > 0;
+        return BrotliEncoderSetParameter(state, @intFromEnum(param), value) > 0;
     }
 };
 
diff --git a/src/deps/c_ares.zig b/src/deps/c_ares.zig
index 523907ae23..4ea5141427 100644
--- a/src/deps/c_ares.zig
+++ b/src/deps/c_ares.zig
@@ -1321,7 +1321,7 @@ pub const Error = enum(i32) {
         error_value.put(
             globalThis,
             JSC.ZigString.static("name"),
-            JSC.ZigString.init("DNSException").toJS(globalThis),
+            bun.String.static("DNSException").toJS(globalThis),
         );
         error_value.put(
             globalThis,
@@ -1554,18 +1554,17 @@ 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,
-    callframe: *JSC.CallFrame,
-) callconv(JSC.conv) JSC.JSValue {
+comptime {
+    const Bun__canonicalizeIP = JSC.toJSHostFunction(Bun__canonicalizeIP_);
+    @export(Bun__canonicalizeIP, .{ .name = "Bun__canonicalizeIP" });
+}
+pub fn Bun__canonicalizeIP_(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     JSC.markBinding(@src());
 
-    const globalThis = ctx.ptr();
-    const arguments = callframe.arguments(1);
+    const arguments = callframe.arguments_old(1);
 
     if (arguments.len == 0) {
-        globalThis.throwInvalidArguments("canonicalizeIP() expects a string but received no arguments.", .{});
-        return .zero;
+        return globalThis.throwInvalidArguments("canonicalizeIP() expects a string but received no arguments.", .{});
     }
     // windows uses 65 bytes for ipv6 addresses and linux/macos uses 46
     const INET6_ADDRSTRLEN = if (comptime bun.Environment.isWindows) 65 else 46;
@@ -1605,8 +1604,8 @@ pub export fn Bun__canonicalizeIP(
         return JSC.ZigString.init(ip_addr[0..size]).toJS(globalThis);
     } else {
         if (!globalThis.hasException())
-            globalThis.throwInvalidArguments("address must be a string", .{});
-        return .zero;
+            return globalThis.throwInvalidArguments("address must be a string", .{});
+        return error.JSError;
     }
 }
 
@@ -1655,9 +1654,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/libuwsockets.cpp b/src/deps/libuwsockets.cpp
index bc9ff248f8..b683362431 100644
--- a/src/deps/libuwsockets.cpp
+++ b/src/deps/libuwsockets.cpp
@@ -9,7 +9,14 @@
 extern "C" const char* ares_inet_ntop(int af, const char *src, char *dst, size_t size);
 
 #define uws_res_r uws_res_t* nonnull_arg 
+static inline std::string_view stringViewFromC(const char* message, size_t length) {
+  if(length) {
+    return std::string_view(message, length);
+  }
 
+  return std::string_view();
+  
+}
 extern "C"
 {
 
@@ -20,7 +27,7 @@ extern "C"
       uWS::SocketContextOptions socket_context_options;
       memcpy(&socket_context_options, &options,
              sizeof(uWS::SocketContextOptions));
-      return (uws_app_t *)new uWS::SSLApp(socket_context_options);
+      return (uws_app_t *)uWS::SSLApp::create(socket_context_options);
     }
 
     return (uws_app_t *)new uWS::App();
@@ -471,10 +478,10 @@ extern "C"
     if (ssl)
     {
       uWS::SSLApp *uwsApp = (uWS::SSLApp *)app;
-      return uwsApp->numSubscribers(std::string_view(topic, topic_length));
+      return uwsApp->numSubscribers(stringViewFromC(topic, topic_length));
     }
     uWS::App *uwsApp = (uWS::App *)app;
-    return uwsApp->numSubscribers(std::string_view(topic, topic_length));
+    return uwsApp->numSubscribers(stringViewFromC(topic, topic_length));
   }
   bool uws_publish(int ssl, uws_app_t *app, const char *topic,
                    size_t topic_length, const char *message,
@@ -483,13 +490,13 @@ extern "C"
     if (ssl)
     {
       uWS::SSLApp *uwsApp = (uWS::SSLApp *)app;
-      return uwsApp->publish(std::string_view(topic, topic_length),
-                             std::string_view(message, message_length),
+      return uwsApp->publish(stringViewFromC(topic, topic_length),
+                             stringViewFromC(message, message_length),
                              (uWS::OpCode)(unsigned char)opcode, compress);
     }
     uWS::App *uwsApp = (uWS::App *)app;
-    return uwsApp->publish(std::string_view(topic, topic_length),
-                           std::string_view(message, message_length),
+    return uwsApp->publish(stringViewFromC(topic, topic_length),
+                           stringViewFromC(message, message_length),
                            (uWS::OpCode)(unsigned char)opcode, compress);
   }
   void *uws_get_native_handle(int ssl, uws_app_t *app)
@@ -530,23 +537,25 @@ extern "C"
       uwsApp->addServerName(hostname_pattern);
     }
   }
-  void uws_add_server_name_with_options(
+  int uws_add_server_name_with_options(
       int ssl, uws_app_t *app, const char *hostname_pattern,
       struct us_bun_socket_context_options_t options)
   {
     uWS::SocketContextOptions sco;
     memcpy(&sco, &options, sizeof(uWS::SocketContextOptions));
+    bool success = false;
 
     if (ssl)
     {
       uWS::SSLApp *uwsApp = (uWS::SSLApp *)app;
-      uwsApp->addServerName(hostname_pattern, sco);
+      uwsApp->addServerName(hostname_pattern, sco, &success);
     }
     else
     {
       uWS::App *uwsApp = (uWS::App *)app;
-      uwsApp->addServerName(hostname_pattern, sco);
+      uwsApp->addServerName(hostname_pattern, sco, &success);
     }
+    return !success;
   }
 
   void uws_missing_server_name(int ssl, uws_app_t *app,
@@ -745,12 +754,12 @@ extern "C"
     {
       uWS::WebSocket<true, true, void *> *uws =
           (uWS::WebSocket<true, true, void *> *)ws;
-      return (uws_sendstatus_t)uws->send(std::string_view(message, length),
+      return (uws_sendstatus_t)uws->send(stringViewFromC(message, length),
                                          (uWS::OpCode)(unsigned char)opcode);
     }
     uWS::WebSocket<false, true, void *> *uws =
         (uWS::WebSocket<false, true, void *> *)ws;
-    return (uws_sendstatus_t)uws->send(std::string_view(message, length),
+    return (uws_sendstatus_t)uws->send(stringViewFromC(message, length),
                                        (uWS::OpCode)(unsigned char)opcode);
   }
 
@@ -763,7 +772,7 @@ extern "C"
     {
       uWS::WebSocket<true, true, void *> *uws =
           (uWS::WebSocket<true, true, void *> *)ws;
-      return (uws_sendstatus_t)uws->send(std::string_view(message, length),
+      return (uws_sendstatus_t)uws->send(stringViewFromC(message, length),
                                          (uWS::OpCode)(unsigned char)opcode,
                                          compress, fin);
     }
@@ -772,7 +781,7 @@ extern "C"
 
       uWS::WebSocket<false, true, void *> *uws =
           (uWS::WebSocket<false, true, void *> *)ws;
-      return (uws_sendstatus_t)uws->send(std::string_view(message, length),
+      return (uws_sendstatus_t)uws->send(stringViewFromC(message, length),
                                          (uWS::OpCode)(unsigned char)opcode,
                                          compress, fin);
     }
@@ -787,11 +796,11 @@ extern "C"
       uWS::WebSocket<true, true, void *> *uws =
           (uWS::WebSocket<true, true, void *> *)ws;
       return (uws_sendstatus_t)uws->sendFragment(
-          std::string_view(message, length), compress);
+          stringViewFromC(message, length), compress);
     }
     uWS::WebSocket<false, true, void *> *uws =
         (uWS::WebSocket<false, true, void *> *)ws;
-    return (uws_sendstatus_t)uws->sendFragment(std::string_view(message, length),
+    return (uws_sendstatus_t)uws->sendFragment(stringViewFromC(message, length),
                                                compress);
   }
   uws_sendstatus_t uws_ws_send_first_fragment(int ssl, uws_websocket_t *ws,
@@ -803,12 +812,12 @@ extern "C"
       uWS::WebSocket<true, true, void *> *uws =
           (uWS::WebSocket<true, true, void *> *)ws;
       return (uws_sendstatus_t)uws->sendFirstFragment(
-          std::string_view(message, length), uWS::OpCode::BINARY, compress);
+          stringViewFromC(message, length), uWS::OpCode::BINARY, compress);
     }
     uWS::WebSocket<false, true, void *> *uws =
         (uWS::WebSocket<false, true, void *> *)ws;
     return (uws_sendstatus_t)uws->sendFirstFragment(
-        std::string_view(message, length), uWS::OpCode::BINARY, compress);
+        stringViewFromC(message, length), uWS::OpCode::BINARY, compress);
   }
   uws_sendstatus_t
   uws_ws_send_first_fragment_with_opcode(int ssl, uws_websocket_t *ws,
@@ -820,13 +829,13 @@ extern "C"
       uWS::WebSocket<true, true, void *> *uws =
           (uWS::WebSocket<true, true, void *> *)ws;
       return (uws_sendstatus_t)uws->sendFirstFragment(
-          std::string_view(message, length), (uWS::OpCode)(unsigned char)opcode,
+          stringViewFromC(message, length), (uWS::OpCode)(unsigned char)opcode,
           compress);
     }
     uWS::WebSocket<false, true, void *> *uws =
         (uWS::WebSocket<false, true, void *> *)ws;
     return (uws_sendstatus_t)uws->sendFirstFragment(
-        std::string_view(message, length), (uWS::OpCode)(unsigned char)opcode,
+        stringViewFromC(message, length), (uWS::OpCode)(unsigned char)opcode,
         compress);
   }
   uws_sendstatus_t uws_ws_send_last_fragment(int ssl, uws_websocket_t *ws,
@@ -838,12 +847,12 @@ extern "C"
       uWS::WebSocket<true, true, void *> *uws =
           (uWS::WebSocket<true, true, void *> *)ws;
       return (uws_sendstatus_t)uws->sendLastFragment(
-          std::string_view(message, length), compress);
+          stringViewFromC(message, length), compress);
     }
     uWS::WebSocket<false, true, void *> *uws =
         (uWS::WebSocket<false, true, void *> *)ws;
     return (uws_sendstatus_t)uws->sendLastFragment(
-        std::string_view(message, length), compress);
+        stringViewFromC(message, length), compress);
   }
 
   void uws_ws_end(int ssl, uws_websocket_t *ws, int code, const char *message,
@@ -853,13 +862,13 @@ extern "C"
     {
       uWS::WebSocket<true, true, void *> *uws =
           (uWS::WebSocket<true, true, void *> *)ws;
-      uws->end(code, std::string_view(message, length));
+      uws->end(code, stringViewFromC(message, length));
     }
     else
     {
       uWS::WebSocket<false, true, void *> *uws =
           (uWS::WebSocket<false, true, void *> *)ws;
-      uws->end(code, std::string_view(message, length));
+      uws->end(code, stringViewFromC(message, length));
     }
   }
 
@@ -889,11 +898,11 @@ extern "C"
     {
       uWS::WebSocket<true, true, void *> *uws =
           (uWS::WebSocket<true, true, void *> *)ws;
-      return uws->subscribe(std::string_view(topic, length));
+      return uws->subscribe(stringViewFromC(topic, length));
     }
     uWS::WebSocket<false, true, void *> *uws =
         (uWS::WebSocket<false, true, void *> *)ws;
-    return uws->subscribe(std::string_view(topic, length));
+    return uws->subscribe(stringViewFromC(topic, length));
   }
   bool uws_ws_unsubscribe(int ssl, uws_websocket_t *ws, const char *topic,
                           size_t length)
@@ -902,11 +911,11 @@ extern "C"
     {
       uWS::WebSocket<true, true, void *> *uws =
           (uWS::WebSocket<true, true, void *> *)ws;
-      return uws->unsubscribe(std::string_view(topic, length));
+      return uws->unsubscribe(stringViewFromC(topic, length));
     }
     uWS::WebSocket<false, true, void *> *uws =
         (uWS::WebSocket<false, true, void *> *)ws;
-    return uws->unsubscribe(std::string_view(topic, length));
+    return uws->unsubscribe(stringViewFromC(topic, length));
   }
 
   bool uws_ws_is_subscribed(int ssl, uws_websocket_t *ws, const char *topic,
@@ -916,11 +925,11 @@ extern "C"
     {
       uWS::WebSocket<true, true, void *> *uws =
           (uWS::WebSocket<true, true, void *> *)ws;
-      return uws->isSubscribed(std::string_view(topic, length));
+      return uws->isSubscribed(stringViewFromC(topic, length));
     }
     uWS::WebSocket<false, true, void *> *uws =
         (uWS::WebSocket<false, true, void *> *)ws;
-    return uws->isSubscribed(std::string_view(topic, length));
+    return uws->isSubscribed(stringViewFromC(topic, length));
   }
   void uws_ws_iterate_topics(int ssl, uws_websocket_t *ws,
                              void (*callback)(const char *topic, size_t length,
@@ -952,13 +961,13 @@ extern "C"
     {
       uWS::WebSocket<true, true, void *> *uws =
           (uWS::WebSocket<true, true, void *> *)ws;
-      return uws->publish(std::string_view(topic, topic_length),
-                          std::string_view(message, message_length));
+      return uws->publish(stringViewFromC(topic, topic_length),
+                          stringViewFromC(message, message_length));
     }
     uWS::WebSocket<false, true, void *> *uws =
         (uWS::WebSocket<false, true, void *> *)ws;
-    return uws->publish(std::string_view(topic, topic_length),
-                        std::string_view(message, message_length));
+    return uws->publish(stringViewFromC(topic, topic_length),
+                        stringViewFromC(message, message_length));
   }
 
   bool uws_ws_publish_with_options(int ssl, uws_websocket_t *ws,
@@ -970,14 +979,14 @@ extern "C"
     {
       uWS::WebSocket<true, true, void *> *uws =
           (uWS::WebSocket<true, true, void *> *)ws;
-      return uws->publish(std::string_view(topic, topic_length),
-                          std::string_view(message, message_length),
+      return uws->publish(stringViewFromC(topic, topic_length),
+                          stringViewFromC(message, message_length),
                           (uWS::OpCode)(unsigned char)opcode, compress);
     }
     uWS::WebSocket<false, true, void *> *uws =
         (uWS::WebSocket<false, true, void *> *)ws;
-    return uws->publish(std::string_view(topic, topic_length),
-                        std::string_view(message, message_length),
+    return uws->publish(stringViewFromC(topic, topic_length),
+                        stringViewFromC(message, message_length),
                         (uWS::OpCode)(unsigned char)opcode, compress);
   }
 
@@ -1040,13 +1049,13 @@ extern "C"
     {
       uWS::HttpResponse<true> *uwsRes = (uWS::HttpResponse<true> *)res;
       uwsRes->clearOnWritableAndAborted();
-      uwsRes->end(std::string_view(data, length), close_connection);
+      uwsRes->end(stringViewFromC(data, length), close_connection);
     }
     else
     {
       uWS::HttpResponse<false> *uwsRes = (uWS::HttpResponse<false> *)res;
       uwsRes->clearOnWritableAndAborted();
-      uwsRes->end(std::string_view(data, length), close_connection);
+      uwsRes->end(stringViewFromC(data, length), close_connection);
     }
   }
 
@@ -1114,12 +1123,12 @@ extern "C"
     if (ssl)
     {
       uWS::HttpResponse<true> *uwsRes = (uWS::HttpResponse<true> *)res;
-      uwsRes->writeStatus(std::string_view(status, length));
+      uwsRes->writeStatus(stringViewFromC(status, length));
     }
     else
     {
       uWS::HttpResponse<false> *uwsRes = (uWS::HttpResponse<false> *)res;
-      uwsRes->writeStatus(std::string_view(status, length));
+      uwsRes->writeStatus(stringViewFromC(status, length));
     }
   }
 
@@ -1130,14 +1139,14 @@ extern "C"
     if (ssl)
     {
       uWS::HttpResponse<true> *uwsRes = (uWS::HttpResponse<true> *)res;
-      uwsRes->writeHeader(std::string_view(key, key_length),
-                          std::string_view(value, value_length));
+      uwsRes->writeHeader(stringViewFromC(key, key_length),
+                          stringViewFromC(value, value_length));
     }
     else
     {
       uWS::HttpResponse<false> *uwsRes = (uWS::HttpResponse<false> *)res;
-      uwsRes->writeHeader(std::string_view(key, key_length),
-                          std::string_view(value, value_length));
+      uwsRes->writeHeader(stringViewFromC(key, key_length),
+                          stringViewFromC(value, value_length));
     }
   }
   void uws_res_write_header_int(int ssl, uws_res_r res, const char *key,
@@ -1146,13 +1155,13 @@ extern "C"
     if (ssl)
     {
       uWS::HttpResponse<true> *uwsRes = (uWS::HttpResponse<true> *)res;
-      uwsRes->writeHeader(std::string_view(key, key_length), value);
+      uwsRes->writeHeader(stringViewFromC(key, key_length), value);
     }
     else
     {
 
       uWS::HttpResponse<false> *uwsRes = (uWS::HttpResponse<false> *)res;
-      uwsRes->writeHeader(std::string_view(key, key_length), value);
+      uwsRes->writeHeader(stringViewFromC(key, key_length), value);
     }
   }
   void uws_res_end_sendfile(int ssl, uws_res_r res, uint64_t offset, bool close_connection) 
@@ -1248,10 +1257,10 @@ extern "C"
     if (ssl)
     {
       uWS::HttpResponse<true> *uwsRes = (uWS::HttpResponse<true> *)res;
-      return uwsRes->write(std::string_view(data, length));
+      return uwsRes->write(stringViewFromC(data, length));
     }
     uWS::HttpResponse<false> *uwsRes = (uWS::HttpResponse<false> *)res;
-    return uwsRes->write(std::string_view(data, length));
+    return uwsRes->write(stringViewFromC(data, length));
   }
   uint64_t uws_res_get_write_offset(int ssl, uws_res_r res) nonnull_fn_decl;
   uint64_t uws_res_get_write_offset(int ssl, uws_res_r res)
@@ -1441,7 +1450,7 @@ size_t uws_req_get_header(uws_req_t *res, const char *lower_case_header,
     uWS::HttpRequest *uwsReq = (uWS::HttpRequest *)res;
 
     std::string_view value = uwsReq->getHeader(
-        std::string_view(lower_case_header, lower_case_header_length));
+        stringViewFromC(lower_case_header, lower_case_header_length));
     *dest = value.data();
     return value.length();
   }
@@ -1460,7 +1469,7 @@ size_t uws_req_get_header(uws_req_t *res, const char *lower_case_header,
   {
     uWS::HttpRequest *uwsReq = (uWS::HttpRequest *)res;
 
-    std::string_view value = uwsReq->getQuery(std::string_view(key, key_length));
+    std::string_view value = uwsReq->getQuery(stringViewFromC(key, key_length));
     *dest = value.data();
     return value.length();
   }
@@ -1488,9 +1497,9 @@ size_t uws_req_get_header(uws_req_t *res, const char *lower_case_header,
 
     uwsRes->template upgrade<void *>(
         data ? std::move(data) : NULL,
-        std::string_view(sec_web_socket_key, sec_web_socket_key_length),
-        std::string_view(sec_web_socket_protocol, sec_web_socket_protocol_length),
-        std::string_view(sec_web_socket_extensions,
+        stringViewFromC(sec_web_socket_key, sec_web_socket_key_length),
+        stringViewFromC(sec_web_socket_protocol, sec_web_socket_protocol_length),
+        stringViewFromC(sec_web_socket_extensions,
                          sec_web_socket_extensions_length),
         (struct us_socket_context_t *)ws);
     } else {
@@ -1498,9 +1507,9 @@ size_t uws_req_get_header(uws_req_t *res, const char *lower_case_header,
 
     uwsRes->template upgrade<void *>(
         data ? std::move(data) : NULL,
-        std::string_view(sec_web_socket_key, sec_web_socket_key_length),
-        std::string_view(sec_web_socket_protocol, sec_web_socket_protocol_length),
-        std::string_view(sec_web_socket_extensions,
+        stringViewFromC(sec_web_socket_key, sec_web_socket_key_length),
+        stringViewFromC(sec_web_socket_protocol, sec_web_socket_protocol_length),
+        stringViewFromC(sec_web_socket_extensions,
                          sec_web_socket_extensions_length),
         (struct us_socket_context_t *)ws);
     }
@@ -1558,8 +1567,8 @@ size_t uws_req_get_header(uws_req_t *res, const char *lower_case_header,
       uWS::HttpResponse<true> *uwsRes = (uWS::HttpResponse<true> *)res;
       for (size_t i = 0; i < count; i++)
       {
-        uwsRes->writeHeader(std::string_view(&buf[names[i].off], names[i].len),
-                            std::string_view(&buf[values[i].off], values[i].len));
+        uwsRes->writeHeader(stringViewFromC(&buf[names[i].off], names[i].len),
+                            stringViewFromC(&buf[values[i].off], values[i].len));
       }
     }
     else
@@ -1567,8 +1576,8 @@ size_t uws_req_get_header(uws_req_t *res, const char *lower_case_header,
       uWS::HttpResponse<false> *uwsRes = (uWS::HttpResponse<false> *)res;
       for (size_t i = 0; i < count; i++)
       {
-        uwsRes->writeHeader(std::string_view(&buf[names[i].off], names[i].len),
-                            std::string_view(&buf[values[i].off], values[i].len));
+        uwsRes->writeHeader(stringViewFromC(&buf[names[i].off], names[i].len),
+                            stringViewFromC(&buf[values[i].off], values[i].len));
       }
     }
   }
@@ -1658,7 +1667,7 @@ __attribute__((callback (corker, ctx)))
     if (ssl)
     {
       uWS::HttpResponse<true> *uwsRes = (uWS::HttpResponse<true> *)res;
-      auto pair = uwsRes->tryEnd(std::string_view(bytes, len), total_len, close);
+      auto pair = uwsRes->tryEnd(stringViewFromC(bytes, len), total_len, close);
       if (pair.first) {
         uwsRes->clearOnWritableAndAborted();
       }
@@ -1668,7 +1677,7 @@ __attribute__((callback (corker, ctx)))
     else
     {
       uWS::HttpResponse<false> *uwsRes = (uWS::HttpResponse<false> *)res;
-      auto pair = uwsRes->tryEnd(std::string_view(bytes, len), total_len, close);
+      auto pair = uwsRes->tryEnd(stringViewFromC(bytes, len), total_len, close);
       if (pair.first) {
           uwsRes->clearOnWritableAndAborted();
       }
diff --git a/src/deps/picohttp.zig b/src/deps/picohttp.zig
index 0f44ed7e72..9846f11640 100644
--- a/src/deps/picohttp.zig
+++ b/src/deps/picohttp.zig
@@ -6,6 +6,8 @@ const Match = ExactSizeMatcher(2);
 const Output = bun.Output;
 const Environment = bun.Environment;
 const StringBuilder = bun.StringBuilder;
+const string = bun.string;
+const strings = bun.strings;
 
 const fmt = std.fmt;
 
@@ -15,6 +17,34 @@ pub const Header = struct {
     name: []const u8,
     value: []const u8,
 
+    pub const List = struct {
+        list: []Header = &.{},
+
+        pub fn get(this: *const List, name: string) ?string {
+            for (this.list) |header| {
+                if (strings.eqlCaseInsensitiveASCII(header.name, name, true)) {
+                    return header.value;
+                }
+            }
+            return null;
+        }
+
+        pub fn getIfOtherIsAbsent(this: *const List, name: string, other: string) ?string {
+            var value: ?string = null;
+            for (this.list) |header| {
+                if (strings.eqlCaseInsensitiveASCII(header.name, other, true)) {
+                    return null;
+                }
+
+                if (value == null and strings.eqlCaseInsensitiveASCII(header.name, name, true)) {
+                    value = header.value;
+                }
+            }
+
+            return value;
+        }
+    };
+
     pub fn isMultiline(self: Header) bool {
         return @intFromPtr(self.name.ptr) == 0;
     }
@@ -214,9 +244,9 @@ const StatusCodeFormatter = struct {
 
 pub const Response = struct {
     minor_version: usize = 0,
-    status_code: usize = 0,
+    status_code: u32 = 0,
     status: []const u8 = "",
-    headers: []Header = &.{},
+    headers: Header.List = .{},
     bytes_read: c_int = 0,
 
     pub fn format(self: Response, comptime _: []const u8, _: fmt.FormatOptions, writer: anytype) !void {
@@ -234,7 +264,7 @@ pub const Response = struct {
                 self.status,
             },
         );
-        for (self.headers) |header| {
+        for (self.headers.list) |header| {
             if (Output.enable_ansi_colors_stderr) {
                 _ = try writer.write(Output.prettyFmt("<r><d>[fetch]<r> ", true));
             }
@@ -247,7 +277,7 @@ pub const Response = struct {
     pub fn count(this: *const Response, builder: *StringBuilder) void {
         builder.count(this.status);
 
-        for (this.headers) |header| {
+        for (this.headers.list) |header| {
             header.count(builder);
         }
     }
@@ -256,11 +286,11 @@ pub const Response = struct {
         var that = this.*;
         that.status = builder.append(this.status);
 
-        for (this.headers, 0..) |header, i| {
+        for (this.headers.list, 0..) |header, i| {
             headers[i] = header.clone(builder);
         }
 
-        that.headers = headers[0..this.headers.len];
+        that.headers.list = headers[0..this.headers.list.len];
 
         return that;
     }
@@ -295,9 +325,9 @@ pub const Response = struct {
             },
             else => Response{
                 .minor_version = @as(usize, @intCast(minor_version)),
-                .status_code = @as(usize, @intCast(status_code)),
+                .status_code = @as(u32, @intCast(status_code)),
                 .status = status,
-                .headers = src[0..@min(num_headers, src.len)],
+                .headers = .{ .list = src[0..@min(num_headers, src.len)] },
                 .bytes_read = rc,
             },
         };
diff --git a/src/deps/uws.zig b/src/deps/uws.zig
index 102858501a..183bbacfb1 100644
--- a/src/deps/uws.zig
+++ b/src/deps/uws.zig
@@ -9,7 +9,18 @@ pub const u_int32_t = c_uint;
 pub const u_int64_t = c_ulonglong;
 pub const LIBUS_LISTEN_DEFAULT: i32 = 0;
 pub const LIBUS_LISTEN_EXCLUSIVE_PORT: i32 = 1;
-pub const Socket = opaque {};
+pub const LIBUS_SOCKET_ALLOW_HALF_OPEN: i32 = 2;
+pub const LIBUS_SOCKET_REUSE_PORT: i32 = 4;
+pub const LIBUS_SOCKET_IPV6_ONLY: i32 = 8;
+
+pub const Socket = opaque {
+    pub fn write2(this: *Socket, first: []const u8, second: []const u8) i32 {
+        const rc = us_socket_write2(0, this, first.ptr, first.len, second.ptr, second.len);
+        debug("us_socket_write2({d}, {d}) = {d}", .{ first.len, second.len, rc });
+        return rc;
+    }
+    extern "C" fn us_socket_write2(ssl: i32, *Socket, header: ?[*]const u8, len: usize, payload: ?[*]const u8, usize) i32;
+};
 pub const ConnectingSocket = opaque {};
 const debug = bun.Output.scoped(.uws, false);
 const uws = @This();
@@ -55,6 +66,7 @@ pub const InternalLoopData = extern struct {
     parent_ptr: ?*anyopaque,
     parent_tag: c_char,
     iteration_nr: usize,
+    jsc_vm: ?*JSC.VM,
 
     pub fn recvSlice(this: *InternalLoopData) []u8 {
         return this.recv_buf[0..LIBUS_RECV_BUFFER_LENGTH];
@@ -210,11 +222,11 @@ pub const UpgradedDuplex = struct {
     fn onReceivedData(
         globalObject: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         log("onReceivedData", .{});
 
         const function = callframe.callee();
-        const args = callframe.arguments(1);
+        const args = callframe.arguments_old(1);
 
         if (JSC.getFunctionData(function)) |self| {
             const this = @as(*UpgradedDuplex, @ptrCast(@alignCast(self)));
@@ -260,7 +272,7 @@ pub const UpgradedDuplex = struct {
     fn onWritable(
         globalObject: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         log("onWritable", .{});
 
         _ = globalObject;
@@ -282,7 +294,7 @@ pub const UpgradedDuplex = struct {
     fn onCloseJS(
         globalObject: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         log("onCloseJS", .{});
 
         _ = globalObject;
@@ -735,6 +747,25 @@ pub const WindowsNamedPipe = if (Environment.isWindows) struct {
         this.callWriteOrEnd(encoded_data, true);
     }
 
+    pub fn resumeStream(this: *WindowsNamedPipe) bool {
+        const stream = this.writer.getStream() orelse {
+            return false;
+        };
+        const readStartResult = stream.readStart(this, onReadAlloc, onReadError, onRead);
+        if (readStartResult == .err) {
+            return false;
+        }
+        return true;
+    }
+
+    pub fn pauseStream(this: *WindowsNamedPipe) bool {
+        const pipe = this.pipe orelse {
+            return false;
+        };
+        pipe.readStop();
+        return true;
+    }
+
     pub fn flush(this: *WindowsNamedPipe) void {
         if (this.wrapper) |*wrapper| {
             _ = wrapper.flush();
@@ -1083,11 +1114,44 @@ pub const WindowsNamedPipe = if (Environment.isWindows) struct {
 } else void;
 
 pub const InternalSocket = union(enum) {
-    done: *Socket,
+    connected: *Socket,
     connecting: *ConnectingSocket,
     detached: void,
     upgradedDuplex: *UpgradedDuplex,
     pipe: *WindowsNamedPipe,
+
+    pub fn pauseResume(this: InternalSocket, comptime ssl: bool, comptime pause: bool) bool {
+        switch (this) {
+            .detached => return true,
+            .connected => |socket| {
+                if (pause) {
+                    // Pause
+                    us_socket_pause(@intFromBool(ssl), socket);
+                } else {
+                    // Resume
+                    us_socket_resume(@intFromBool(ssl), socket);
+                }
+                return true;
+            },
+            .connecting => |_| {
+                // always return false for connecting sockets
+                return false;
+            },
+            .upgradedDuplex => |_| {
+                // TODO: pause and resume upgraded duplex
+                return false;
+            },
+            .pipe => |pipe| {
+                if (Environment.isWindows) {
+                    if (pause) {
+                        return pipe.pauseStream();
+                    }
+                    return pipe.resumeStream();
+                }
+                return false;
+            },
+        }
+    }
     pub fn isDetached(this: InternalSocket) bool {
         return this == .detached;
     }
@@ -1097,10 +1161,29 @@ pub const InternalSocket = union(enum) {
     pub fn detach(this: *InternalSocket) void {
         this.* = .detached;
     }
+    pub fn setNoDelay(this: InternalSocket, enabled: bool) bool {
+        switch (this) {
+            .pipe, .upgradedDuplex, .connecting, .detached => return false,
+            .connected => |socket| {
+                // only supported by connected sockets
+                us_socket_nodelay(socket, @intFromBool(enabled));
+                return true;
+            },
+        }
+    }
+    pub fn setKeepAlive(this: InternalSocket, enabled: bool, delay: u32) bool {
+        switch (this) {
+            .pipe, .upgradedDuplex, .connecting, .detached => return false,
+            .connected => |socket| {
+                // only supported by connected sockets and can fail
+                return us_socket_keepalive(socket, @intFromBool(enabled), delay) == 0;
+            },
+        }
+    }
     pub fn close(this: InternalSocket, comptime is_ssl: bool, code: CloseCode) void {
         switch (this) {
             .detached => {},
-            .done => |socket| {
+            .connected => |socket| {
                 debug("us_socket_close({d})", .{@intFromPtr(socket)});
                 _ = us_socket_close(
                     comptime @intFromBool(is_ssl),
@@ -1127,7 +1210,7 @@ pub const InternalSocket = union(enum) {
 
     pub fn isClosed(this: InternalSocket, comptime is_ssl: bool) bool {
         return switch (this) {
-            .done => |socket| us_socket_is_closed(@intFromBool(is_ssl), socket) > 0,
+            .connected => |socket| us_socket_is_closed(@intFromBool(is_ssl), socket) > 0,
             .connecting => |socket| us_connecting_socket_is_closed(@intFromBool(is_ssl), socket) > 0,
             .detached => true,
             .upgradedDuplex => |socket| socket.isClosed(),
@@ -1137,7 +1220,7 @@ pub const InternalSocket = union(enum) {
 
     pub fn get(this: @This()) ?*Socket {
         return switch (this) {
-            .done => this.done,
+            .connected => this.connected,
             .connecting => null,
             .detached => null,
             .upgradedDuplex => null,
@@ -1147,25 +1230,25 @@ pub const InternalSocket = union(enum) {
 
     pub fn eq(this: @This(), other: @This()) bool {
         return switch (this) {
-            .done => switch (other) {
-                .done => this.done == other.done,
+            .connected => switch (other) {
+                .connected => this.connected == other.connected,
                 .upgradedDuplex, .connecting, .detached, .pipe => false,
             },
             .connecting => switch (other) {
-                .upgradedDuplex, .done, .detached, .pipe => false,
+                .upgradedDuplex, .connected, .detached, .pipe => false,
                 .connecting => this.connecting == other.connecting,
             },
             .detached => switch (other) {
                 .detached => true,
-                .upgradedDuplex, .done, .connecting, .pipe => false,
+                .upgradedDuplex, .connected, .connecting, .pipe => false,
             },
             .upgradedDuplex => switch (other) {
                 .upgradedDuplex => this.upgradedDuplex == other.upgradedDuplex,
-                .done, .connecting, .detached, .pipe => false,
+                .connected, .connecting, .detached, .pipe => false,
             },
             .pipe => switch (other) {
                 .pipe => if (Environment.isWindows) other.pipe == other.pipe else false,
-                .done, .connecting, .detached, .upgradedDuplex => false,
+                .connected, .connecting, .detached, .upgradedDuplex => false,
             },
         };
     }
@@ -1177,6 +1260,18 @@ pub fn NewSocketHandler(comptime is_ssl: bool) type {
         socket: InternalSocket,
         const ThisSocket = @This();
         pub const detached: NewSocketHandler(is_ssl) = NewSocketHandler(is_ssl){ .socket = .{ .detached = {} } };
+        pub fn setNoDelay(this: ThisSocket, enabled: bool) bool {
+            return this.socket.setNoDelay(enabled);
+        }
+        pub fn setKeepAlive(this: ThisSocket, enabled: bool, delay: u32) bool {
+            return this.socket.setKeepAlive(enabled, delay);
+        }
+        pub fn pauseStream(this: ThisSocket) bool {
+            return this.socket.pauseResume(is_ssl, true);
+        }
+        pub fn resumeStream(this: ThisSocket) bool {
+            return this.socket.pauseResume(is_ssl, false);
+        }
         pub fn detach(this: *ThisSocket) void {
             this.socket.detach();
         }
@@ -1188,7 +1283,7 @@ pub fn NewSocketHandler(comptime is_ssl: bool) type {
         }
         pub fn verifyError(this: ThisSocket) us_bun_verify_error_t {
             switch (this.socket) {
-                .done => |socket| return uws.us_socket_verify_error(comptime ssl_int, socket),
+                .connected => |socket| return uws.us_socket_verify_error(comptime ssl_int, socket),
                 .upgradedDuplex => |socket| return socket.sslError(),
                 .pipe => |pipe| if (Environment.isWindows) return pipe.sslError() else return std.mem.zeroes(us_bun_verify_error_t),
                 .connecting, .detached => return std.mem.zeroes(us_bun_verify_error_t),
@@ -1197,7 +1292,7 @@ pub fn NewSocketHandler(comptime is_ssl: bool) type {
 
         pub fn isEstablished(this: ThisSocket) bool {
             switch (this.socket) {
-                .done => |socket| return us_socket_is_established(comptime ssl_int, socket) > 0,
+                .connected => |socket| return us_socket_is_established(comptime ssl_int, socket) > 0,
                 .upgradedDuplex => |socket| return socket.isEstablished(),
                 .pipe => |pipe| if (Environment.isWindows) return pipe.isEstablished() else return false,
                 .connecting, .detached => return false,
@@ -1208,7 +1303,7 @@ pub fn NewSocketHandler(comptime is_ssl: bool) type {
             switch (this.socket) {
                 .upgradedDuplex => |socket| socket.setTimeout(seconds),
                 .pipe => |pipe| if (Environment.isWindows) pipe.setTimeout(seconds),
-                .done => |socket| us_socket_timeout(comptime ssl_int, socket, seconds),
+                .connected => |socket| us_socket_timeout(comptime ssl_int, socket, seconds),
                 .connecting => |socket| us_connecting_socket_timeout(comptime ssl_int, socket, seconds),
                 .detached => {},
             }
@@ -1216,7 +1311,7 @@ pub fn NewSocketHandler(comptime is_ssl: bool) type {
 
         pub fn setTimeout(this: ThisSocket, seconds: c_uint) void {
             switch (this.socket) {
-                .done => |socket| {
+                .connected => |socket| {
                     if (seconds > 240) {
                         us_socket_timeout(comptime ssl_int, socket, 0);
                         us_socket_long_timeout(comptime ssl_int, socket, seconds / 60);
@@ -1242,7 +1337,7 @@ pub fn NewSocketHandler(comptime is_ssl: bool) type {
 
         pub fn setTimeoutMinutes(this: ThisSocket, minutes: c_uint) void {
             switch (this.socket) {
-                .done => |socket| {
+                .connected => |socket| {
                     us_socket_timeout(comptime ssl_int, socket, 0);
                     us_socket_long_timeout(comptime ssl_int, socket, minutes);
                 },
@@ -1402,7 +1497,7 @@ pub fn NewSocketHandler(comptime is_ssl: bool) type {
 
         pub fn getNativeHandle(this: ThisSocket) ?*NativeSocketHandleType(is_ssl) {
             return @ptrCast(switch (this.socket) {
-                .done => |socket| us_socket_get_native_handle(comptime ssl_int, socket),
+                .connected => |socket| us_socket_get_native_handle(comptime ssl_int, socket),
                 .connecting => |socket| us_connecting_socket_get_native_handle(comptime ssl_int, socket),
                 .detached => null,
                 .upgradedDuplex => |socket| if (is_ssl) @as(*anyopaque, @ptrCast(socket.ssl() orelse return null)) else null,
@@ -1437,7 +1532,7 @@ pub fn NewSocketHandler(comptime is_ssl: bool) type {
                 std.meta.alignment(ContextType);
 
             const ptr = switch (this.socket) {
-                .done => |sock| us_socket_ext(comptime ssl_int, sock),
+                .connected => |sock| us_socket_ext(comptime ssl_int, sock),
                 .connecting => |sock| us_connecting_socket_ext(comptime ssl_int, sock),
                 .detached => return null,
                 .upgradedDuplex => return null,
@@ -1450,7 +1545,7 @@ pub fn NewSocketHandler(comptime is_ssl: bool) type {
         /// This can be null if the socket was closed.
         pub fn context(this: ThisSocket) ?*SocketContext {
             switch (this.socket) {
-                .done => |socket| return us_socket_context(comptime ssl_int, socket),
+                .connected => |socket| return us_socket_context(comptime ssl_int, socket),
                 .connecting => |socket| return us_connecting_socket_context(comptime ssl_int, socket),
                 .detached => return null,
                 .upgradedDuplex => return null,
@@ -1466,7 +1561,7 @@ pub fn NewSocketHandler(comptime is_ssl: bool) type {
                 .pipe => |pipe| {
                     return if (Environment.isWindows) pipe.flush() else return;
                 },
-                .done => |socket| {
+                .connected => |socket| {
                     return us_socket_flush(
                         comptime ssl_int,
                         socket,
@@ -1484,7 +1579,7 @@ pub fn NewSocketHandler(comptime is_ssl: bool) type {
                 .pipe => |pipe| {
                     return if (Environment.isWindows) pipe.encodeAndWrite(data, msg_more) else 0;
                 },
-                .done => |socket| {
+                .connected => |socket| {
                     const result = us_socket_write(
                         comptime ssl_int,
                         socket,
@@ -1506,7 +1601,7 @@ pub fn NewSocketHandler(comptime is_ssl: bool) type {
 
         pub fn rawWrite(this: ThisSocket, data: []const u8, msg_more: bool) i32 {
             switch (this.socket) {
-                .done => |socket| {
+                .connected => |socket| {
                     return us_socket_raw_write(
                         comptime ssl_int,
                         socket,
@@ -1528,7 +1623,7 @@ pub fn NewSocketHandler(comptime is_ssl: bool) type {
         pub fn shutdown(this: ThisSocket) void {
             // debug("us_socket_shutdown({d})", .{@intFromPtr(this.socket)});
             switch (this.socket) {
-                .done => |socket| {
+                .connected => |socket| {
                     return us_socket_shutdown(
                         comptime ssl_int,
                         socket,
@@ -1552,7 +1647,7 @@ pub fn NewSocketHandler(comptime is_ssl: bool) type {
 
         pub fn shutdownRead(this: ThisSocket) void {
             switch (this.socket) {
-                .done => |socket| {
+                .connected => |socket| {
                     // debug("us_socket_shutdown_read({d})", .{@intFromPtr(socket)});
                     return us_socket_shutdown_read(
                         comptime ssl_int,
@@ -1578,7 +1673,7 @@ pub fn NewSocketHandler(comptime is_ssl: bool) type {
 
         pub fn isShutdown(this: ThisSocket) bool {
             switch (this.socket) {
-                .done => |socket| {
+                .connected => |socket| {
                     return us_socket_is_shut_down(
                         comptime ssl_int,
                         socket,
@@ -1610,7 +1705,7 @@ pub fn NewSocketHandler(comptime is_ssl: bool) type {
 
         pub fn getError(this: ThisSocket) i32 {
             switch (this.socket) {
-                .done => |socket| {
+                .connected => |socket| {
                     return us_socket_get_error(
                         comptime ssl_int,
                         socket,
@@ -1641,7 +1736,7 @@ pub fn NewSocketHandler(comptime is_ssl: bool) type {
         }
         pub fn localPort(this: ThisSocket) i32 {
             switch (this.socket) {
-                .done => |socket| {
+                .connected => |socket| {
                     return us_socket_local_port(
                         comptime ssl_int,
                         socket,
@@ -1652,7 +1747,7 @@ pub fn NewSocketHandler(comptime is_ssl: bool) type {
         }
         pub fn remoteAddress(this: ThisSocket, buf: [*]u8, length: *i32) void {
             switch (this.socket) {
-                .done => |socket| {
+                .connected => |socket| {
                     return us_socket_remote_address(
                         comptime ssl_int,
                         socket,
@@ -1675,7 +1770,7 @@ pub fn NewSocketHandler(comptime is_ssl: bool) type {
         /// This function returns a slice of the buffer on success, or null on failure.
         pub fn localAddressBinary(this: ThisSocket, buf: []u8) ?[]const u8 {
             switch (this.socket) {
-                .done => |socket| {
+                .connected => |socket| {
                     var length: i32 = @intCast(buf.len);
                     us_socket_local_address(
                         comptime ssl_int,
@@ -1733,6 +1828,7 @@ pub fn NewSocketHandler(comptime is_ssl: bool) type {
             comptime Context: type,
             ctx: Context,
             comptime socket_field_name: []const u8,
+            allowHalfOpen: bool,
         ) ?*Context {
             debug("connect({s}, {d})", .{ host, port });
 
@@ -1749,10 +1845,10 @@ pub fn NewSocketHandler(comptime is_ssl: bool) type {
             defer allocator.free(host);
 
             var did_dns_resolve: i32 = 0;
-            const socket = us_socket_context_connect(comptime ssl_int, socket_ctx, host_, port, 0, @sizeOf(Context), &did_dns_resolve) orelse return null;
+            const socket = us_socket_context_connect(comptime ssl_int, socket_ctx, host_, port, if (allowHalfOpen) LIBUS_SOCKET_ALLOW_HALF_OPEN else 0, @sizeOf(Context), &did_dns_resolve) orelse return null;
             const socket_ = if (did_dns_resolve == 1)
                 ThisSocket{
-                    .socket = .{ .done = @ptrCast(socket) },
+                    .socket = .{ .connected = @ptrCast(socket) },
                 }
             else
                 ThisSocket{
@@ -1772,8 +1868,9 @@ pub fn NewSocketHandler(comptime is_ssl: bool) type {
             comptime Context: type,
             ctx: *Context,
             comptime socket_field_name: []const u8,
+            allowHalfOpen: bool,
         ) !*Context {
-            const this_socket = try connectAnon(host, port, socket_ctx, ctx);
+            const this_socket = try connectAnon(host, port, socket_ctx, ctx, allowHalfOpen);
             @field(ctx, socket_field_name) = this_socket;
             return ctx;
         }
@@ -1800,7 +1897,7 @@ pub fn NewSocketHandler(comptime is_ssl: bool) type {
             this: *This,
             comptime socket_field_name: ?[]const u8,
         ) ?ThisSocket {
-            const socket_ = ThisSocket{ .socket = .{ .done = us_socket_from_fd(ctx, @sizeOf(*anyopaque), bun.socketcast(handle)) orelse return null } };
+            const socket_ = ThisSocket{ .socket = .{ .connected = us_socket_from_fd(ctx, @sizeOf(*anyopaque), bun.socketcast(handle)) orelse return null } };
 
             if (socket_.ext(*anyopaque)) |holder| {
                 holder.* = this;
@@ -1829,6 +1926,7 @@ pub fn NewSocketHandler(comptime is_ssl: bool) type {
             path: []const u8,
             socket_ctx: *SocketContext,
             ctx: *anyopaque,
+            allowHalfOpen: bool,
         ) !ThisSocket {
             debug("connect(unix:{s})", .{path});
             var stack_fallback = std.heap.stackFallback(1024, bun.default_allocator);
@@ -1836,10 +1934,10 @@ pub fn NewSocketHandler(comptime is_ssl: bool) type {
             const path_ = allocator.dupeZ(u8, path) catch bun.outOfMemory();
             defer allocator.free(path_);
 
-            const socket = us_socket_context_connect_unix(comptime ssl_int, socket_ctx, path_, path_.len, 0, 8) orelse
+            const socket = us_socket_context_connect_unix(comptime ssl_int, socket_ctx, path_, path_.len, if (allowHalfOpen) LIBUS_SOCKET_ALLOW_HALF_OPEN else 0, 8) orelse
                 return error.FailedToOpenSocket;
 
-            const socket_ = ThisSocket{ .socket = .{ .done = socket } };
+            const socket_ = ThisSocket{ .socket = .{ .connected = socket } };
             if (socket_.ext(*anyopaque)) |holder| {
                 holder.* = ctx;
             }
@@ -1851,6 +1949,7 @@ pub fn NewSocketHandler(comptime is_ssl: bool) type {
             port: i32,
             socket_ctx: *SocketContext,
             ptr: *anyopaque,
+            allowHalfOpen: bool,
         ) !ThisSocket {
             debug("connect({s}, {d})", .{ raw_host, port });
             var stack_fallback = std.heap.stackFallback(1024, bun.default_allocator);
@@ -1871,13 +1970,13 @@ pub fn NewSocketHandler(comptime is_ssl: bool) type {
                 socket_ctx,
                 host.ptr,
                 port,
-                0,
+                if (allowHalfOpen) LIBUS_SOCKET_ALLOW_HALF_OPEN else 0,
                 @sizeOf(*anyopaque),
                 &did_dns_resolve,
             ) orelse return error.FailedToOpenSocket;
             const socket = if (did_dns_resolve == 1)
                 ThisSocket{
-                    .socket = .{ .done = @ptrCast(socket_ptr) },
+                    .socket = .{ .connected = @ptrCast(socket_ptr) },
                 }
             else
                 ThisSocket{
@@ -2172,7 +2271,7 @@ pub fn NewSocketHandler(comptime is_ssl: bool) type {
         }
 
         pub fn from(socket: *Socket) ThisSocket {
-            return ThisSocket{ .socket = .{ .done = socket } };
+            return ThisSocket{ .socket = .{ .connected = socket } };
         }
 
         pub fn fromConnecting(connecting: *ConnectingSocket) ThisSocket {
@@ -2213,7 +2312,7 @@ pub const Timer = opaque {
         // never fallthrough poll
         // the problem is uSockets hardcodes it on the other end
         // so we can never free non-fallthrough polls
-        return us_create_timer(loop, 0, @sizeOf(Type));
+        return us_create_timer(loop, 0, @sizeOf(Type)) orelse std.debug.panic("us_create_timer: returned null: {d}", .{std.c._errno().*});
     }
 
     pub fn createFallthrough(loop: *Loop, ptr: anytype) *Timer {
@@ -2222,7 +2321,7 @@ pub const Timer = opaque {
         // never fallthrough poll
         // the problem is uSockets hardcodes it on the other end
         // so we can never free non-fallthrough polls
-        return us_create_timer(loop, 1, @sizeOf(Type));
+        return us_create_timer(loop, 1, @sizeOf(Type)) orelse std.debug.panic("us_create_timer: returned null: {d}", .{std.c._errno().*});
     }
 
     pub fn set(this: *Timer, ptr: anytype, cb: ?*const fn (*Timer) callconv(.C) void, ms: i32, repeat_ms: i32) void {
@@ -2260,6 +2359,11 @@ pub const SocketContext = opaque {
         us_socket_context_free(@as(i32, 0), this);
     }
 
+    pub fn ref(this: *SocketContext, comptime ssl: bool) *SocketContext {
+        us_socket_context_ref(@intFromBool(ssl), this);
+        return this;
+    }
+
     pub fn cleanCallbacks(ctx: *SocketContext, is_ssl: bool) void {
         const ssl_int: i32 = @intFromBool(is_ssl);
         // replace callbacks with dummy ones
@@ -2502,7 +2606,7 @@ pub const PosixLoop = extern struct {
 
 extern fn uws_loop_defer(loop: *Loop, ctx: *anyopaque, cb: *const (fn (ctx: *anyopaque) callconv(.C) void)) void;
 
-extern fn us_create_timer(loop: ?*Loop, fallthrough: i32, ext_size: c_uint) *Timer;
+extern fn us_create_timer(loop: ?*Loop, fallthrough: i32, ext_size: c_uint) ?*Timer;
 extern fn us_timer_ext(timer: ?*Timer) *?*anyopaque;
 extern fn us_timer_close(timer: ?*Timer, fallthrough: i32) void;
 extern fn us_timer_set(timer: ?*Timer, cb: ?*const fn (*Timer) callconv(.C) void, ms: i32, repeat_ms: i32) void;
@@ -2539,10 +2643,41 @@ pub const us_bun_socket_context_options_t = extern struct {
 };
 pub extern fn create_ssl_context_from_bun_options(options: us_bun_socket_context_options_t) ?*BoringSSL.SSL_CTX;
 
+pub const create_bun_socket_error_t = enum(i32) {
+    none = 0,
+    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;
 
@@ -2568,7 +2703,7 @@ pub extern fn us_socket_context_remove_server_name(ssl: i32, context: ?*SocketCo
 extern fn us_socket_context_on_server_name(ssl: i32, context: ?*SocketContext, cb: ?*const fn (?*SocketContext, [*c]const u8) callconv(.C) void) void;
 extern fn us_socket_context_get_native_handle(ssl: i32, context: ?*SocketContext) ?*anyopaque;
 pub extern fn us_create_socket_context(ssl: i32, loop: ?*Loop, ext_size: i32, options: us_socket_context_options_t) ?*SocketContext;
-pub extern fn us_create_bun_socket_context(ssl: i32, loop: ?*Loop, ext_size: i32, options: us_bun_socket_context_options_t) ?*SocketContext;
+pub extern fn us_create_bun_socket_context(ssl: i32, loop: ?*Loop, ext_size: i32, options: us_bun_socket_context_options_t, err: *create_bun_socket_error_t) ?*SocketContext;
 pub extern fn us_bun_socket_context_add_server_name(ssl: i32, context: ?*SocketContext, hostname_pattern: [*c]const u8, options: us_bun_socket_context_options_t, ?*anyopaque) void;
 pub extern fn us_socket_context_free(ssl: i32, context: ?*SocketContext) void;
 pub extern fn us_socket_context_ref(ssl: i32, context: ?*SocketContext) void;
@@ -2587,8 +2722,8 @@ extern fn us_socket_context_on_socket_connect_error(ssl: i32, context: ?*SocketC
 extern fn us_socket_context_on_end(ssl: i32, context: ?*SocketContext, on_end: *const fn (*Socket) callconv(.C) ?*Socket) void;
 extern fn us_socket_context_ext(ssl: i32, context: ?*SocketContext) ?*anyopaque;
 
-pub extern fn us_socket_context_listen(ssl: i32, context: ?*SocketContext, host: ?[*:0]const u8, port: i32, options: i32, socket_ext_size: i32) ?*ListenSocket;
-pub extern fn us_socket_context_listen_unix(ssl: i32, context: ?*SocketContext, path: [*:0]const u8, pathlen: usize, options: i32, socket_ext_size: i32) ?*ListenSocket;
+pub extern fn us_socket_context_listen(ssl: i32, context: ?*SocketContext, host: ?[*:0]const u8, port: i32, options: i32, socket_ext_size: i32, err: *c_int) ?*ListenSocket;
+pub extern fn us_socket_context_listen_unix(ssl: i32, context: ?*SocketContext, path: [*:0]const u8, pathlen: usize, options: i32, socket_ext_size: i32, err: *c_int) ?*ListenSocket;
 pub extern fn us_socket_context_connect(ssl: i32, context: ?*SocketContext, host: [*:0]const u8, port: i32, options: i32, socket_ext_size: i32, has_dns_resolved: *i32) ?*anyopaque;
 pub extern fn us_socket_context_connect_unix(ssl: i32, context: ?*SocketContext, path: [*c]const u8, pathlen: usize, options: i32, socket_ext_size: i32) ?*Socket;
 pub extern fn us_socket_is_established(ssl: i32, s: ?*Socket) i32;
@@ -2699,6 +2834,11 @@ extern fn us_socket_is_shut_down(ssl: i32, s: ?*Socket) i32;
 extern fn us_socket_is_closed(ssl: i32, s: ?*Socket) i32;
 extern fn us_socket_close(ssl: i32, s: ?*Socket, code: CloseCode, reason: ?*anyopaque) ?*Socket;
 
+extern fn us_socket_nodelay(s: ?*Socket, enable: c_int) void;
+extern fn us_socket_keepalive(s: ?*Socket, enable: c_int, delay: c_uint) c_int;
+extern fn us_socket_pause(ssl: i32, s: ?*Socket) void;
+extern fn us_socket_resume(ssl: i32, s: ?*Socket) void;
+
 extern fn us_connecting_socket_timeout(ssl: i32, s: ?*ConnectingSocket, seconds: c_uint) void;
 extern fn us_connecting_socket_long_timeout(ssl: i32, s: ?*ConnectingSocket, seconds: c_uint) void;
 extern fn us_connecting_socket_ext(ssl: i32, s: ?*ConnectingSocket) *anyopaque;
@@ -3036,6 +3176,14 @@ pub const AnyResponse = union(enum) {
     SSL: *NewApp(true).Response,
     TCP: *NewApp(false).Response,
 
+    pub fn init(response: anytype) AnyResponse {
+        return switch (@TypeOf(response)) {
+            *NewApp(true).Response => .{ .SSL = response },
+            *NewApp(false).Response => .{ .TCP = response },
+            else => @compileError(unreachable),
+        };
+    }
+
     pub fn timeout(this: AnyResponse, seconds: u8) void {
         switch (this) {
             .SSL => |resp| resp.timeout(seconds),
@@ -3201,8 +3349,8 @@ pub fn NewApp(comptime ssl: bool) type {
             return uws_app_close(ssl_flag, @as(*uws_app_s, @ptrCast(this)));
         }
 
-        pub fn create(opts: us_bun_socket_context_options_t) *ThisApp {
-            return @as(*ThisApp, @ptrCast(uws_create_app(ssl_flag, opts)));
+        pub fn create(opts: us_bun_socket_context_options_t) ?*ThisApp {
+            return @ptrCast(uws_create_app(ssl_flag, opts));
         }
         pub fn destroy(app: *ThisApp) void {
             return uws_app_destroy(ssl_flag, @as(*uws_app_s, @ptrCast(app)));
@@ -3432,7 +3580,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 {
@@ -3447,8 +3595,10 @@ pub fn NewApp(comptime ssl: bool) type {
         pub fn addServerName(app: *ThisApp, hostname_pattern: [*:0]const u8) void {
             return uws_add_server_name(ssl_flag, @as(*uws_app_t, @ptrCast(app)), hostname_pattern);
         }
-        pub fn addServerNameWithOptions(app: *ThisApp, hostname_pattern: [*:0]const u8, opts: us_bun_socket_context_options_t) void {
-            return uws_add_server_name_with_options(ssl_flag, @as(*uws_app_t, @ptrCast(app)), hostname_pattern, opts);
+        pub fn addServerNameWithOptions(app: *ThisApp, hostname_pattern: [*:0]const u8, opts: us_bun_socket_context_options_t) !void {
+            if (uws_add_server_name_with_options(ssl_flag, @as(*uws_app_t, @ptrCast(app)), hostname_pattern, opts) != 0) {
+                return error.FailedToAddServerName;
+            }
         }
         pub fn missingServerName(app: *ThisApp, handler: uws_missing_server_handler, user_data: ?*anyopaque) void {
             return uws_missing_server_name(ssl_flag, @as(*uws_app_t, @ptrCast(app)), handler, user_data);
@@ -3547,11 +3697,6 @@ pub fn NewApp(comptime ssl: bool) type {
 
                 return bun.toFD(@as(i32, @intCast(@intFromPtr(uws_res_get_native_handle(ssl_flag, res.downcast())))));
             }
-            pub fn getRemoteAddress(res: *Response) ?[]const u8 {
-                var buf: [*]const u8 = undefined;
-                const size = uws_res_get_remote_address(ssl_flag, res.downcast(), &buf);
-                return if (size > 0) buf[0..size] else null;
-            }
             pub fn getRemoteAddressAsText(res: *Response) ?[]const u8 {
                 var buf: [*]const u8 = undefined;
                 const size = uws_res_get_remote_address_as_text(ssl_flag, res.downcast(), &buf);
@@ -3624,7 +3769,7 @@ pub fn NewApp(comptime ssl: bool) type {
                 const Wrapper = struct {
                     pub fn handle(this: *uws_res, user_data: ?*anyopaque) callconv(.C) void {
                         if (comptime UserDataType == void) {
-                            @call(bun.callmod_inline, handler, .{ {}, castRes(this), {} });
+                            @call(bun.callmod_inline, handler, .{ {}, castRes(this) });
                         } else {
                             @call(bun.callmod_inline, handler, .{ @as(UserDataType, @ptrCast(@alignCast(user_data.?))), castRes(this) });
                         }
@@ -3873,9 +4018,8 @@ pub fn NewApp(comptime ssl: bool) type {
 extern fn uws_res_end_stream(ssl: i32, res: *uws_res, close_connection: bool) void;
 extern fn uws_res_prepare_for_sendfile(ssl: i32, res: *uws_res) void;
 extern fn uws_res_get_native_handle(ssl: i32, res: *uws_res) *Socket;
-extern fn uws_res_get_remote_address(ssl: i32, res: *uws_res, dest: *[*]const u8) usize;
 extern fn uws_res_get_remote_address_as_text(ssl: i32, res: *uws_res, dest: *[*]const u8) usize;
-extern fn uws_create_app(ssl: i32, options: us_bun_socket_context_options_t) *uws_app_t;
+extern fn uws_create_app(ssl: i32, options: us_bun_socket_context_options_t) ?*uws_app_t;
 extern fn uws_app_destroy(ssl: i32, app: *uws_app_t) void;
 extern fn uws_app_get(ssl: i32, app: *uws_app_t, pattern: [*c]const u8, handler: uws_method_handler, user_data: ?*anyopaque) void;
 extern fn uws_app_post(ssl: i32, app: *uws_app_t, pattern: [*c]const u8, handler: uws_method_handler, user_data: ?*anyopaque) void;
@@ -3905,7 +4049,7 @@ extern fn uws_publish(ssl: i32, app: *uws_app_t, topic: [*c]const u8, topic_leng
 extern fn uws_get_native_handle(ssl: i32, app: *anyopaque) ?*anyopaque;
 extern fn uws_remove_server_name(ssl: i32, app: *uws_app_t, hostname_pattern: [*c]const u8) void;
 extern fn uws_add_server_name(ssl: i32, app: *uws_app_t, hostname_pattern: [*c]const u8) void;
-extern fn uws_add_server_name_with_options(ssl: i32, app: *uws_app_t, hostname_pattern: [*c]const u8, options: us_bun_socket_context_options_t) void;
+extern fn uws_add_server_name_with_options(ssl: i32, app: *uws_app_t, hostname_pattern: [*c]const u8, options: us_bun_socket_context_options_t) i32;
 extern fn uws_missing_server_name(ssl: i32, app: *uws_app_t, handler: uws_missing_server_handler, user_data: ?*anyopaque) void;
 extern fn uws_filter(ssl: i32, app: *uws_app_t, handler: uws_filter_handler, user_data: ?*anyopaque) void;
 extern fn uws_ws(ssl: i32, app: *uws_app_t, ctx: *anyopaque, pattern: [*]const u8, pattern_len: usize, id: usize, behavior: *const WebSocketBehavior) void;
@@ -4284,7 +4428,7 @@ pub const AnySocket = union(enum) {
 
     pub fn getNativeHandle(this: AnySocket) ?*anyopaque {
         return switch (this.socket()) {
-            .done => |sock| us_socket_get_native_handle(
+            .connected => |sock| us_socket_get_native_handle(
                 @intFromBool(this.isSSL()),
                 sock,
             ).?,
@@ -4411,3 +4555,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/dns.zig b/src/dns.zig
index 9490f7ba85..6601ee8eb3 100644
--- a/src/dns.zig
+++ b/src/dns.zig
@@ -74,23 +74,23 @@ pub const GetAddrInfo = struct {
             if (value.isObject()) {
                 var options = Options{};
 
-                if (value.getOwn(globalObject, "family")) |family| {
+                if (try value.get(globalObject, "family")) |family| {
                     options.family = try Family.fromJS(family, globalObject);
                 }
 
-                if (value.getOwn(globalObject, "socketType") orelse value.getOwn(globalObject, "socktype")) |socktype| {
+                if (try value.get(globalObject, "socketType") orelse try value.get(globalObject, "socktype")) |socktype| {
                     options.socktype = try SocketType.fromJS(socktype, globalObject);
                 }
 
-                if (value.getOwn(globalObject, "protocol")) |protocol| {
+                if (try value.get(globalObject, "protocol")) |protocol| {
                     options.protocol = try Protocol.fromJS(protocol, globalObject);
                 }
 
-                if (value.getOwn(globalObject, "backend")) |backend| {
+                if (try value.get(globalObject, "backend")) |backend| {
                     options.backend = try Backend.fromJS(backend, globalObject);
                 }
 
-                if (value.getOwn(globalObject, "flags")) |flags| {
+                if (try value.get(globalObject, "flags")) |flags| {
                     if (!flags.isNumber())
                         return error.InvalidFlags;
 
@@ -346,7 +346,10 @@ pub const GetAddrInfo = struct {
 
         pub fn toJS(this: *const Result, globalThis: *JSC.JSGlobalObject) JSValue {
             const obj = JSC.JSValue.createEmptyObject(globalThis, 3);
-            obj.put(globalThis, JSC.ZigString.static("address"), addressToJS(&this.address, globalThis));
+            obj.put(globalThis, JSC.ZigString.static("address"), addressToJS(&this.address, globalThis) catch |err| return switch (err) {
+                error.JSError => .zero,
+                error.OutOfMemory => globalThis.throwOutOfMemoryValue(),
+            });
             obj.put(globalThis, JSC.ZigString.static("family"), switch (this.address.any.family) {
                 std.posix.AF.INET => JSValue.jsNumber(4),
                 std.posix.AF.INET6 => JSValue.jsNumber(6),
@@ -359,9 +362,7 @@ pub const GetAddrInfo = struct {
 };
 const String = bun.String;
 const default_allocator = bun.default_allocator;
-pub fn addressToString(
-    address: *const std.net.Address,
-) !bun.String {
+pub fn addressToString(address: *const std.net.Address) bun.OOM!bun.String {
     switch (address.any.family) {
         std.posix.AF.INET => {
             var self = address.in;
@@ -394,16 +395,9 @@ pub fn addressToString(
     }
 }
 
-pub fn addressToJS(
-    address: *const std.net.Address,
-    globalThis: *JSC.JSGlobalObject,
-) JSC.JSValue {
-    const str = addressToString(address) catch {
-        globalThis.throwOutOfMemory();
-        return .zero;
-    };
-    defer str.deref();
-    return str.toJS(globalThis);
+pub fn addressToJS(address: *const std.net.Address, globalThis: *JSC.JSGlobalObject) bun.JSError!JSC.JSValue {
+    var str = addressToString(address) catch return globalThis.throwOutOfMemory();
+    return str.transferToJS(globalThis);
 }
 
 fn addrInfoCount(addrinfo: *std.c.addrinfo) u32 {
diff --git a/src/env.zig b/src/env.zig
index 2f6f528abc..bbc36aba6f 100644
--- a/src/env.zig
+++ b/src/env.zig
@@ -25,6 +25,7 @@ pub const isLinux = @import("builtin").target.os.tag == .linux;
 pub const isAarch64 = @import("builtin").target.cpu.arch.isAARCH64();
 pub const isX86 = @import("builtin").target.cpu.arch.isX86();
 pub const isX64 = @import("builtin").target.cpu.arch == .x86_64;
+pub const isMusl = builtin.target.abi.isMusl();
 pub const allow_assert = isDebug or isTest or std.builtin.Mode.ReleaseSafe == @import("builtin").mode;
 
 pub const build_options = @import("build_options");
@@ -41,10 +42,8 @@ pub const dump_source = isDebug and !isTest;
 pub const base_path = build_options.base_path;
 pub const enable_logs = build_options.enable_logs or isDebug;
 
-/// See -Dforce_embed_code
-pub const embed_code = build_options.embed_code;
-
 pub const codegen_path = build_options.codegen_path;
+pub const codegen_embed = build_options.codegen_embed;
 
 pub const version: std.SemanticVersion = build_options.version;
 pub const version_string = std.fmt.comptimePrint("{d}.{d}.{d}", .{ version.major, version.minor, version.patch });
diff --git a/src/env_loader.zig b/src/env_loader.zig
index 21f8d20878..77cc2aa7ec 100644
--- a/src/env_loader.zig
+++ b/src/env_loader.zig
@@ -37,7 +37,7 @@ pub const Loader = struct {
     @".env.test.local": ?logger.Source = null,
     @".env": ?logger.Source = null,
 
-    // only populated with files specified explicitely (e.g. --env-file arg)
+    // only populated with files specified explicitly (e.g. --env-file arg)
     custom_files_loaded: bun.StringArrayHashMap(logger.Source),
 
     quiet: bool = false,
@@ -291,7 +291,7 @@ pub const Loader = struct {
     /// **lower priority** so that users may override defaults. Unlike regular
     /// defines, environment variables are loaded as JavaScript string literals.
     ///
-    /// Empty enivronment variables become empty strings.
+    /// Empty environment variables become empty strings.
     pub fn copyForDefine(
         this: *Loader,
         comptime JSONStore: type,
@@ -1194,6 +1194,20 @@ pub const Map = struct {
         });
     }
 
+    pub fn ensureUnusedCapacity(this: *Map, additional_count: usize) !void {
+        return this.map.ensureUnusedCapacity(additional_count);
+    }
+
+    pub fn putAssumeCapacity(this: *Map, key: string, value: string) void {
+        if (Environment.isWindows and Environment.allow_assert) {
+            bun.assert(bun.strings.indexOfChar(key, '\x00') == null);
+        }
+        this.map.putAssumeCapacity(key, .{
+            .value = value,
+            .conditional = false,
+        });
+    }
+
     pub inline fn putAllocKeyAndValue(this: *Map, allocator: std.mem.Allocator, key: string, value: string) !void {
         const gop = try this.map.getOrPut(key);
         gop.value_ptr.* = .{
diff --git a/src/exact_size_matcher.zig b/src/exact_size_matcher.zig
index 1b780f54eb..f3a7d75c2c 100644
--- a/src/exact_size_matcher.zig
+++ b/src/exact_size_matcher.zig
@@ -5,7 +5,7 @@ pub fn ExactSizeMatcher(comptime max_bytes: usize) type {
     switch (max_bytes) {
         1, 2, 4, 8, 12, 16 => {},
         else => {
-            @compileError("max_bytes must be 1, 2, 4, 8, or 12.");
+            @compileError("max_bytes must be 1, 2, 4, 8, 12, or 16.");
         },
     }
 
diff --git a/src/fd.zig b/src/fd.zig
index 3bab075c3a..4a51880541 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) {
@@ -345,11 +343,10 @@ pub const FDImpl = packed struct {
     pub fn toJS(value: FDImpl, global: *JSC.JSGlobalObject) JSValue {
         const fd = value.makeLibUVOwned() catch {
             _ = value.close();
-            global.throwValue((JSC.SystemError{
+            return global.throwValue((JSC.SystemError{
                 .message = bun.String.static("EMFILE, too many open files"),
                 .code = bun.String.static("EMFILE"),
-            }).toErrorInstance(global));
-            return .zero;
+            }).toErrorInstance(global)) catch .zero;
         };
         return JSValue.jsNumberFromInt32(fd.uv());
     }
diff --git a/src/feature_flags.zig b/src/feature_flags.zig
index 0e93fb2a32..e0db115da5 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;
 
@@ -158,5 +155,12 @@ pub fn isLibdeflateEnabled() bool {
     return !bun.getRuntimeFeatureFlag("BUN_FEATURE_FLAG_NO_LIBDEFLATE");
 }
 
-/// Enable experimental bundler tools, codenamed "bun kit"
-pub const kit = env.is_canary or env.isDebug;
+/// Enable Bun Kit's experimental bundler tools.
+pub fn bake() bool {
+    // In canary or if an environment variable is specified.
+    return env.is_canary or env.isDebug or bun.getRuntimeFeatureFlag("BUN_FEATURE_FLAG_EXPERIMENTAL_BAKE");
+}
+
+/// Additional debugging features for Bake, such as the incremental visualizer.
+/// To use them, extra flags are passed in addition to this one.
+pub const bake_debugging_features = env.is_canary or env.isDebug;
diff --git a/src/fmt.zig b/src/fmt.zig
index f2b9ec6f63..c42dc178b1 100644
--- a/src/fmt.zig
+++ b/src/fmt.zig
@@ -7,55 +7,66 @@ const js_lexer = bun.js_lexer;
 const ComptimeStringMap = bun.ComptimeStringMap;
 const fmt = std.fmt;
 const Environment = bun.Environment;
+const sha = bun.sha;
 
 pub usingnamespace std.fmt;
 
+pub const TableSymbols = struct {
+    enable_ansi_colors: bool,
+
+    pub const unicode = TableSymbols{ .enable_ansi_colors = true };
+    pub const ascii = TableSymbols{ .enable_ansi_colors = false };
+
+    pub fn topLeftSep(comptime s: TableSymbols) []const u8 {
+        return if (s.enable_ansi_colors) "┌" else "|";
+    }
+    pub fn topRightSep(comptime s: TableSymbols) []const u8 {
+        return if (s.enable_ansi_colors) "┐" else "|";
+    }
+    pub fn topColumnSep(comptime s: TableSymbols) []const u8 {
+        return if (s.enable_ansi_colors) "┬" else "-";
+    }
+
+    pub fn bottomLeftSep(comptime s: TableSymbols) []const u8 {
+        return if (s.enable_ansi_colors) "└" else "|";
+    }
+    pub fn bottomRightSep(comptime s: TableSymbols) []const u8 {
+        return if (s.enable_ansi_colors) "┘" else "|";
+    }
+    pub fn bottomColumnSep(comptime s: TableSymbols) []const u8 {
+        return if (s.enable_ansi_colors) "┴" else "-";
+    }
+
+    pub fn middleLeftSep(comptime s: TableSymbols) []const u8 {
+        return if (s.enable_ansi_colors) "├" else "|";
+    }
+    pub fn middleRightSep(comptime s: TableSymbols) []const u8 {
+        return if (s.enable_ansi_colors) "┤" else "|";
+    }
+    pub fn middleColumnSep(comptime s: TableSymbols) []const u8 {
+        return if (s.enable_ansi_colors) "┼" else "|";
+    }
+
+    pub fn horizontalEdge(comptime s: TableSymbols) []const u8 {
+        return if (s.enable_ansi_colors) "─" else "-";
+    }
+    pub fn verticalEdge(comptime s: TableSymbols) []const u8 {
+        return if (s.enable_ansi_colors) "│" else "|";
+    }
+};
+
 pub fn Table(
     comptime column_color: []const u8,
     comptime column_left_pad: usize,
     comptime column_right_pad: usize,
     comptime enable_ansi_colors: bool,
 ) type {
+    const symbols = TableSymbols{ .enable_ansi_colors = enable_ansi_colors };
     return struct {
         column_names: []const []const u8,
         column_inside_lengths: []const usize,
 
-        pub fn topLeftSep(_: *const @This()) string {
-            return if (enable_ansi_colors) "┌" else "|";
-        }
-        pub fn topRightSep(_: *const @This()) string {
-            return if (enable_ansi_colors) "┐" else "|";
-        }
-        pub fn topColumnSep(_: *const @This()) string {
-            return if (enable_ansi_colors) "┬" else "-";
-        }
-
-        pub fn bottomLeftSep(_: *const @This()) string {
-            return if (enable_ansi_colors) "└" else "|";
-        }
-        pub fn bottomRightSep(_: *const @This()) string {
-            return if (enable_ansi_colors) "┘" else "|";
-        }
-        pub fn bottomColumnSep(_: *const @This()) string {
-            return if (enable_ansi_colors) "┴" else "-";
-        }
-
-        pub fn middleLeftSep(_: *const @This()) string {
-            return if (enable_ansi_colors) "├" else "|";
-        }
-        pub fn middleRightSep(_: *const @This()) string {
-            return if (enable_ansi_colors) "┤" else "|";
-        }
-        pub fn middleColumnSep(_: *const @This()) string {
-            return if (enable_ansi_colors) "┼" else "|";
-        }
-
-        pub fn horizontalEdge(_: *const @This()) string {
-            return if (enable_ansi_colors) "─" else "-";
-        }
-        pub fn verticalEdge(_: *const @This()) string {
-            return if (enable_ansi_colors) "│" else "|";
-        }
+        comptime symbols: TableSymbols = symbols,
 
         pub fn init(column_names_: []const []const u8, column_inside_lengths_: []const usize) @This() {
             return .{
@@ -65,15 +76,15 @@ pub fn Table(
         }
 
         pub fn printTopLineSeparator(this: *const @This()) void {
-            this.printLine(this.topLeftSep(), this.topRightSep(), this.topColumnSep());
+            this.printLine(symbols.topLeftSep(), symbols.topRightSep(), symbols.topColumnSep());
         }
 
         pub fn printBottomLineSeparator(this: *const @This()) void {
-            this.printLine(this.bottomLeftSep(), this.bottomRightSep(), this.bottomColumnSep());
+            this.printLine(symbols.bottomLeftSep(), symbols.bottomRightSep(), symbols.bottomColumnSep());
         }
 
         pub fn printLineSeparator(this: *const @This()) void {
-            this.printLine(this.middleLeftSep(), this.middleRightSep(), this.middleColumnSep());
+            this.printLine(symbols.middleLeftSep(), symbols.middleRightSep(), symbols.middleColumnSep());
         }
 
         pub fn printLine(this: *const @This(), left_edge_separator: string, right_edge_separator: string, column_separator: string) void {
@@ -84,7 +95,7 @@ pub fn Table(
                     Output.pretty("{s}", .{column_separator});
                 }
 
-                for (0..column_left_pad + column_inside_length + column_right_pad) |_| Output.pretty("{s}", .{this.horizontalEdge()});
+                for (0..column_left_pad + column_inside_length + column_right_pad) |_| Output.pretty("{s}", .{symbols.horizontalEdge()});
 
                 if (i == this.column_inside_lengths.len - 1) {
                     Output.pretty("{s}\n", .{right_edge_separator});
@@ -94,18 +105,150 @@ pub fn Table(
 
         pub fn printColumnNames(this: *const @This()) void {
             for (this.column_inside_lengths, 0..) |column_inside_length, i| {
-                Output.pretty("{s}", .{this.verticalEdge()});
+                Output.pretty("{s}", .{symbols.verticalEdge()});
                 for (0..column_left_pad) |_| Output.pretty(" ", .{});
                 Output.pretty("<b><" ++ column_color ++ ">{s}<r>", .{this.column_names[i]});
                 for (this.column_names[i].len..column_inside_length + column_right_pad) |_| Output.pretty(" ", .{});
                 if (i == this.column_inside_lengths.len - 1) {
-                    Output.pretty("{s}\n", .{this.verticalEdge()});
+                    Output.pretty("{s}\n", .{symbols.verticalEdge()});
                 }
             }
         }
     };
 }
 
+pub const RedactedNpmUrlFormatter = struct {
+    url: string,
+
+    pub fn format(this: @This(), comptime _: string, _: std.fmt.FormatOptions, writer: anytype) !void {
+        var i: usize = 0;
+        while (i < this.url.len) {
+            if (strings.startsWithUUID(this.url[i..])) {
+                try writer.writeAll("***");
+                i += 36;
+                continue;
+            }
+
+            const npm_secret_len = strings.startsWithNpmSecret(this.url[i..]);
+            if (npm_secret_len > 0) {
+                try writer.writeAll("***");
+                i += npm_secret_len;
+                continue;
+            }
+
+            // TODO: redact password from `https://username:password@registry.com/`
+
+            try writer.writeByte(this.url[i]);
+            i += 1;
+        }
+    }
+};
+
+pub fn redactedNpmUrl(str: string) RedactedNpmUrlFormatter {
+    return .{
+        .url = str,
+    };
+}
+
+pub const RedactedSourceFormatter = struct {
+    text: string,
+
+    pub fn format(this: @This(), comptime _: string, _: std.fmt.FormatOptions, writer: anytype) !void {
+        var i: usize = 0;
+        while (i < this.text.len) {
+            if (strings.startsWithSecret(this.text[i..])) |secret| {
+                const offset, const len = secret;
+                try writer.writeAll(this.text[i..][0..offset]);
+                try writer.writeByteNTimes('*', len);
+                i += offset + len;
+                continue;
+            }
+
+            try writer.writeByte(this.text[i]);
+            i += 1;
+        }
+    }
+};
+
+pub fn redactedSource(str: string) RedactedSourceFormatter {
+    return .{
+        .text = str,
+    };
+}
+
+// https://github.com/npm/cli/blob/63d6a732c3c0e9c19fd4d147eaa5cc27c29b168d/node_modules/npm-package-arg/lib/npa.js#L163
+pub const DependencyUrlFormatter = struct {
+    url: string,
+
+    pub fn format(this: @This(), comptime _: string, _: std.fmt.FormatOptions, writer: anytype) !void {
+        var remain = this.url;
+        while (strings.indexOfChar(remain, '/')) |slash| {
+            try writer.writeAll(remain[0..slash]);
+            try writer.writeAll("%2f");
+            remain = remain[slash + 1 ..];
+        }
+        try writer.writeAll(remain);
+    }
+};
+
+pub fn dependencyUrl(url: string) DependencyUrlFormatter {
+    return .{
+        .url = url,
+    };
+}
+
+const IntegrityFormatStyle = enum {
+    short,
+    full,
+};
+
+pub fn IntegrityFormatter(comptime style: IntegrityFormatStyle) type {
+    return struct {
+        bytes: [sha.SHA512.digest]u8,
+
+        pub fn format(this: @This(), comptime _: string, _: std.fmt.FormatOptions, writer: anytype) !void {
+            var buf: [std.base64.standard.Encoder.calcSize(sha.SHA512.digest)]u8 = undefined;
+            const count = bun.simdutf.base64.encode(this.bytes[0..sha.SHA512.digest], &buf, false);
+
+            const encoded = buf[0..count];
+
+            if (comptime style == .short)
+                try writer.print("sha512-{s}[...]{s}", .{ encoded[0..13], encoded[encoded.len - 15 ..] })
+            else
+                try writer.print("sha512-{s}", .{encoded});
+        }
+    };
+}
+
+pub fn integrity(bytes: [sha.SHA512.digest]u8, comptime style: IntegrityFormatStyle) IntegrityFormatter(style) {
+    return .{ .bytes = bytes };
+}
+
+const JSONFormatter = struct {
+    input: []const u8,
+
+    pub fn format(self: JSONFormatter, comptime _: []const u8, _: std.fmt.FormatOptions, writer: anytype) !void {
+        try bun.js_printer.writeJSONString(self.input, @TypeOf(writer), writer, .latin1);
+    }
+};
+
+const JSONFormatterUTF8 = struct {
+    input: []const u8,
+
+    pub fn format(self: JSONFormatterUTF8, comptime _: []const u8, _: std.fmt.FormatOptions, writer: anytype) !void {
+        try bun.js_printer.writeJSONString(self.input, @TypeOf(writer), writer, .utf8);
+    }
+};
+
+/// Expects latin1
+pub fn formatJSONString(text: []const u8) JSONFormatter {
+    return .{ .input = text };
+}
+
+pub fn formatJSONStringUTF8(text: []const u8) JSONFormatterUTF8 {
+    return .{ .input = text };
+}
+
 const SharedTempBuffer = [32 * 1024]u8;
 fn getSharedBuffer() []u8 {
     return std.mem.asBytes(shared_temp_buffer_ptr orelse brk: {
@@ -552,17 +695,29 @@ pub const QuotedFormatter = struct {
     }
 };
 
-pub fn fmtJavaScript(text: []const u8, enable_ansi_colors: bool) QuickAndDirtyJavaScriptSyntaxHighlighter {
+pub fn fmtJavaScript(text: []const u8, opts: QuickAndDirtyJavaScriptSyntaxHighlighter.Options) QuickAndDirtyJavaScriptSyntaxHighlighter {
     return QuickAndDirtyJavaScriptSyntaxHighlighter{
         .text = text,
-        .enable_colors = enable_ansi_colors,
+        .opts = opts,
     };
 }
 
 pub const QuickAndDirtyJavaScriptSyntaxHighlighter = struct {
     text: []const u8,
-    enable_colors: bool = false,
-    limited: bool = true,
+    opts: Options,
+
+    pub const Options = struct {
+        enable_colors: bool,
+        check_for_unhighlighted_write: bool = true,
+
+        redact_sensitive_information: bool = false,
+
+        pub const default: Options = .{
+            .enable_colors = Output.enable_ansi_colors,
+            .check_for_no_highlighting = true,
+            .redact_sensitive_information = false,
+        };
+    };
 
     const ColorCode = enum {
         magenta,
@@ -717,18 +872,33 @@ pub const QuickAndDirtyJavaScriptSyntaxHighlighter = struct {
 
     pub const Keywords = bun.ComptimeEnumMap(Keyword);
 
+    pub const RedactedKeyword = enum {
+        _auth,
+        _authToken,
+        token,
+        _password,
+        email,
+    };
+
+    pub const RedactedKeywords = bun.ComptimeEnumMap(RedactedKeyword);
+
     pub fn format(this: @This(), comptime unused_fmt: []const u8, _: fmt.FormatOptions, writer: anytype) !void {
         comptime bun.assert(unused_fmt.len == 0);
 
         var text = this.text;
-        if (this.limited) {
-            if (!this.enable_colors or text.len > 2048 or text.len == 0 or !strings.isAllASCII(text)) {
-                try writer.writeAll(text);
+        if (this.opts.check_for_unhighlighted_write) {
+            if (!this.opts.enable_colors or text.len > 2048 or text.len == 0 or !strings.isAllASCII(text)) {
+                if (this.opts.redact_sensitive_information) {
+                    try writer.print("{}", .{redactedSource(text)});
+                } else {
+                    try writer.writeAll(text);
+                }
                 return;
             }
         }
 
         var prev_keyword: ?Keyword = null;
+        var should_redact_value = false;
 
         outer: while (text.len > 0) {
             if (js_lexer.isIdentifierStart(text[0])) {
@@ -739,11 +909,13 @@ pub const QuickAndDirtyJavaScriptSyntaxHighlighter = struct {
                 }
 
                 if (Keywords.get(text[0..i])) |keyword| {
+                    should_redact_value = false;
                     if (keyword != .as)
                         prev_keyword = keyword;
                     const code = keyword.colorCode();
                     try writer.print(Output.prettyFmt("<r>{s}{s}<r>", true), .{ code.color(), text[0..i] });
                 } else {
+                    should_redact_value = this.opts.redact_sensitive_information and RedactedKeywords.has(text[0..i]);
                     write: {
                         if (prev_keyword) |prev| {
                             switch (prev) {
@@ -778,11 +950,45 @@ pub const QuickAndDirtyJavaScriptSyntaxHighlighter = struct {
                 }
                 text = text[i..];
             } else {
+                if (this.opts.redact_sensitive_information and should_redact_value) {
+                    while (text.len > 0 and std.ascii.isWhitespace(text[0])) {
+                        try writer.writeByte(text[0]);
+                        text = text[1..];
+                    }
+
+                    if (text.len > 0 and (text[0] == '=' or text[0] == ':')) {
+                        try writer.writeByte(text[0]);
+                        text = text[1..];
+                        while (text.len > 0 and std.ascii.isWhitespace(text[0])) {
+                            try writer.writeByte(text[0]);
+                            text = text[1..];
+                        }
+
+                        if (text.len == 0) return;
+                    }
+                }
+
                 switch (text[0]) {
-                    '0'...'9' => {
+                    '0'...'9' => |num| {
+                        if (this.opts.redact_sensitive_information) {
+                            if (should_redact_value) {
+                                should_redact_value = false;
+                                const end = strings.indexOfChar(text, '\n') orelse text.len;
+                                text = text[end..];
+                                try writer.writeAll(Output.prettyFmt("<r><yellow>***<r>", true));
+                                continue;
+                            }
+
+                            if (strings.startsWithUUID(text)) {
+                                text = text[36..];
+                                try writer.writeAll(Output.prettyFmt("<r><yellow>***<r>", true));
+                                continue;
+                            }
+                        }
+
                         prev_keyword = null;
                         var i: usize = 1;
-                        if (text.len > 1 and text[0] == '0' and text[1] == 'x') {
+                        if (text.len > 1 and num == '0' and text[1] == 'x') {
                             i += 1;
                             while (i < text.len and switch (text[i]) {
                                 '0'...'9', 'a'...'f', 'A'...'F' => true,
@@ -807,7 +1013,8 @@ pub const QuickAndDirtyJavaScriptSyntaxHighlighter = struct {
 
                         var i: usize = 1;
                         while (i < text.len and text[i] != char) {
-                            if (char == '`') {
+                            // if we're redacting, no need to syntax highlight contents
+                            if (!should_redact_value and char == '`') {
                                 if (text[i] == '$' and i + 1 < text.len and text[i + 1] == '{') {
                                     const curly_start = i;
                                     i += 2;
@@ -821,10 +1028,11 @@ pub const QuickAndDirtyJavaScriptSyntaxHighlighter = struct {
 
                                     try writer.print(Output.prettyFmt("<r><green>{s}<r>", true), .{text[0..curly_start]});
                                     try writer.writeAll("${");
+                                    var opts = this.opts;
+                                    opts.check_for_unhighlighted_write = false;
                                     const curly_remain = QuickAndDirtyJavaScriptSyntaxHighlighter{
                                         .text = text[curly_start + 2 .. i],
-                                        .enable_colors = this.enable_colors,
-                                        .limited = false,
+                                        .opts = opts,
                                     };
 
                                     if (curly_remain.text.len > 0) {
@@ -856,11 +1064,81 @@ pub const QuickAndDirtyJavaScriptSyntaxHighlighter = struct {
                         // Include the trailing quote, if any
                         i += @intFromBool(i < text.len);
 
+                        if (should_redact_value) {
+                            should_redact_value = false;
+                            if (i > 2 and text[i - 1] == char) {
+                                const len = text[0..i].len - 2;
+                                try writer.print(Output.prettyFmt("<r><green>{c}", true), .{char});
+                                try writer.writeByteNTimes('*', len);
+                                try writer.print(Output.prettyFmt("{c}<r>", true), .{char});
+                            } else {
+                                try writer.writeByteNTimes('*', text[0..i].len);
+                            }
+                            text = text[i..];
+                            continue;
+                        } else if (this.opts.redact_sensitive_information) {
+                            try_redact: {
+                                var inner = text[1..i];
+                                if (inner.len > 0 and inner[inner.len - 1] == char) {
+                                    inner = inner[0 .. inner.len - 1];
+                                }
+
+                                if (inner.len == 0) {
+                                    break :try_redact;
+                                }
+
+                                if (inner.len == 36 and strings.isUUID(inner)) {
+                                    try writer.print(Output.prettyFmt("<r><green>{c}", true), .{char});
+                                    try writer.writeByteNTimes('*', 36);
+                                    try writer.print(Output.prettyFmt("{c}<r>", true), .{char});
+                                    text = text[i..];
+                                    continue;
+                                }
+
+                                const npm_secret_len = strings.startsWithNpmSecret(inner);
+                                if (npm_secret_len != 0) {
+                                    try writer.print(Output.prettyFmt("<r><green>{c}", true), .{char});
+                                    try writer.writeByteNTimes('*', npm_secret_len);
+                                    try writer.print(Output.prettyFmt("{c}<r>", true), .{char});
+                                    text = text[i..];
+                                    continue;
+                                }
+
+                                if (strings.findUrlPassword(inner)) |url_pass| {
+                                    const offset, const len = url_pass;
+                                    try writer.print(Output.prettyFmt("<r><green>{c}{s}", true), .{
+                                        char,
+                                        inner[0..offset],
+                                    });
+                                    try writer.writeByteNTimes('*', len);
+                                    try writer.print(Output.prettyFmt("{s}{c}<r>", true), .{
+                                        inner[offset + len ..],
+                                        char,
+                                    });
+                                    text = text[i..];
+                                    continue;
+                                }
+                            }
+
+                            try writer.print(Output.prettyFmt("<r><green>{s}<r>", true), .{text[0..i]});
+                            text = text[i..];
+                            continue;
+                        }
+
                         try writer.print(Output.prettyFmt("<r><green>{s}<r>", true), .{text[0..i]});
                         text = text[i..];
                     },
                     '/' => {
                         prev_keyword = null;
+
+                        if (should_redact_value) {
+                            should_redact_value = false;
+                            const len = strings.indexOfChar(text, '\n') orelse text.len;
+                            try writer.writeByteNTimes('*', len);
+                            text = text[len..];
+                            continue;
+                        }
+
                         var i: usize = 1;
 
                         // the start of a line comment
@@ -878,7 +1156,11 @@ pub const QuickAndDirtyJavaScriptSyntaxHighlighter = struct {
                                 i += 1;
                             }
 
-                            try writer.print(Output.prettyFmt("<r><d>{s}<r>", true), .{remain_to_print});
+                            if (this.opts.redact_sensitive_information) {
+                                try writer.print(Output.prettyFmt("<r><d>{}<r>", true), .{redactedSource(remain_to_print)});
+                            } else {
+                                try writer.print(Output.prettyFmt("<r><d>{s}<r>", true), .{remain_to_print});
+                            }
                             text = text[i..];
                             continue;
                         }
@@ -898,7 +1180,11 @@ pub const QuickAndDirtyJavaScriptSyntaxHighlighter = struct {
                                     break :as_multiline_comment;
                                 }
 
-                                try writer.print(Output.prettyFmt("<r><d>{s}<r>", true), .{text[0..i]});
+                                if (this.opts.redact_sensitive_information) {
+                                    try writer.print(Output.prettyFmt("<r><d>{}<r>", true), .{redactedSource(text[0..i])});
+                                } else {
+                                    try writer.print(Output.prettyFmt("<r><d>{s}<r>", true), .{text[0..i]});
+                                }
                                 text = text[i..];
                                 continue;
                             }
@@ -907,27 +1193,58 @@ pub const QuickAndDirtyJavaScriptSyntaxHighlighter = struct {
                         try writer.writeAll(text[0..i]);
                         text = text[i..];
                     },
-                    '}', '{' => {
+                    '}', '{' => |brace| {
                         // support potentially highlighting "from" in an import statement
                         if ((prev_keyword orelse Keyword.@"continue") != .import) {
                             prev_keyword = null;
                         }
 
-                        try writer.writeAll(text[0..1]);
+                        if (should_redact_value) {
+                            should_redact_value = false;
+                            const len = strings.indexOfChar(text, '\n') orelse text.len;
+                            try writer.writeByteNTimes('*', len);
+                            text = text[len..];
+                            continue;
+                        }
+
+                        try writer.writeByte(brace);
                         text = text[1..];
                     },
-                    '[', ']' => {
+                    '[', ']' => |bracket| {
                         prev_keyword = null;
-                        try writer.writeAll(text[0..1]);
+                        if (should_redact_value) {
+                            should_redact_value = false;
+                            const len = strings.indexOfChar(text, '\n') orelse text.len;
+                            try writer.writeByteNTimes('*', len);
+                            text = text[len..];
+                            continue;
+                        }
+                        try writer.writeByte(bracket);
                         text = text[1..];
                     },
                     ';' => {
                         prev_keyword = null;
+                        if (should_redact_value) {
+                            should_redact_value = false;
+                            const len = strings.indexOfChar(text, '\n') orelse text.len;
+                            try writer.writeByteNTimes('*', len);
+                            text = text[len..];
+                            continue;
+                        }
                         try writer.print(Output.prettyFmt("<r><d>;<r>", true), .{});
                         text = text[1..];
                     },
                     '.' => {
                         prev_keyword = null;
+
+                        if (should_redact_value) {
+                            should_redact_value = false;
+                            const len = strings.indexOfChar(text, '\n') orelse text.len;
+                            try writer.writeByteNTimes('*', len);
+                            text = text[len..];
+                            continue;
+                        }
+
                         var i: usize = 1;
                         if (text.len > 1 and (js_lexer.isIdentifierStart(text[1]) or text[1] == '#')) {
                             i = 2;
@@ -944,11 +1261,18 @@ pub const QuickAndDirtyJavaScriptSyntaxHighlighter = struct {
                             i = 1;
                         }
 
-                        try writer.writeAll(text[0..1]);
+                        try writer.writeByte(text[0]);
                         text = text[1..];
                     },
 
                     '<' => {
+                        if (should_redact_value) {
+                            should_redact_value = false;
+                            const len = strings.indexOfChar(text, '\n') orelse text.len;
+                            try writer.writeByteNTimes('*', len);
+                            text = text[len..];
+                            continue;
+                        }
                         var i: usize = 1;
 
                         // JSX
@@ -988,8 +1312,15 @@ pub const QuickAndDirtyJavaScriptSyntaxHighlighter = struct {
                         text = text[i..];
                     },
 
-                    else => {
-                        try writer.writeAll(text[0..1]);
+                    else => |c| {
+                        if (should_redact_value) {
+                            should_redact_value = false;
+                            const len = strings.indexOfChar(text, '\n') orelse text.len;
+                            try writer.writeByteNTimes('*', len);
+                            text = text[len..];
+                            continue;
+                        }
+                        try writer.writeByte(c);
                         text = text[1..];
                     },
                 }
@@ -1393,14 +1724,13 @@ 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 {
-        const args = callframe.arguments(2);
+    pub fn jsFunctionStringFormatter(globalThis: *bun.JSC.JSGlobalObject, callframe: *bun.JSC.CallFrame) bun.JSError!bun.JSC.JSValue {
+        const args = callframe.arguments_old(2);
         if (args.len < 2) {
-            globalThis.throwNotEnoughArguments("code", 1, 0);
+            return globalThis.throwNotEnoughArguments("code", 1, 0);
         }
 
-        const code = args.ptr[0].toSliceOrNull(globalThis) orelse
-            return .zero;
+        const code = try args.ptr[0].toSliceOrNull(globalThis);
         defer code.deinit();
 
         var buffer = bun.MutableString.initEmpty(bun.default_allocator);
@@ -1410,24 +1740,23 @@ pub const fmt_js_test_bindings = struct {
         const formatter_id: Formatter = @enumFromInt(args.ptr[1].toInt32());
         switch (formatter_id) {
             .fmtJavaScript => {
-                var formatter = bun.fmt.fmtJavaScript(code.slice(), true);
-                formatter.limited = false;
+                const formatter = bun.fmt.fmtJavaScript(code.slice(), .{
+                    .enable_colors = true,
+                    .check_for_unhighlighted_write = false,
+                });
                 std.fmt.format(writer.writer(), "{}", .{formatter}) catch |err| {
-                    globalThis.throwError(err, "Error formatting");
-                    return .zero;
+                    return globalThis.throwError(err, "Error formatting");
                 };
             },
             .escapePowershell => {
                 std.fmt.format(writer.writer(), "{}", .{escapePowershell(code.slice())}) catch |err| {
-                    globalThis.throwError(err, "Error formatting");
-                    return .zero;
+                    return globalThis.throwError(err, "Error formatting");
                 };
             },
         }
 
         writer.flush() catch |err| {
-            globalThis.throwError(err, "Error formatting");
-            return .zero;
+            return globalThis.throwError(err, "Error formatting");
         };
 
         var str = bun.String.createUTF8(buffer.list.items);
@@ -1496,3 +1825,30 @@ pub const OutOfRangeOptions = struct {
 pub fn outOfRange(value: anytype, options: OutOfRangeOptions) OutOfRangeFormatter(@TypeOf(value)) {
     return .{ .value = value, .min = options.min, .max = options.max, .field_name = options.field_name };
 }
+
+/// esbuild has an 8 character truncation of a base32 encoded bytes. this
+/// is not exactly that, but it will appear as such. the character list
+/// chosen omits similar characters in the unlikely case someone is
+/// trying to memorize a hash.
+///
+/// this hash is used primarily for the hashes in bundler chunk file names. the
+/// output is all lowercase to avoid issues with case-insensitive filesystems.
+pub fn truncatedHash32(int: u64) std.fmt.Formatter(truncatedHash32Impl) {
+    return .{ .data = int };
+}
+
+fn truncatedHash32Impl(int: u64, comptime fmt_str: []const u8, _: std.fmt.FormatOptions, writer: anytype) !void {
+    comptime bun.assert(fmt_str.len == 0);
+    const in_bytes = std.mem.asBytes(&int);
+    const chars = "0123456789abcdefghjkmnpqrstvwxyz";
+    try writer.writeAll(&.{
+        chars[in_bytes[0] & 31],
+        chars[in_bytes[1] & 31],
+        chars[in_bytes[2] & 31],
+        chars[in_bytes[3] & 31],
+        chars[in_bytes[4] & 31],
+        chars[in_bytes[5] & 31],
+        chars[in_bytes[6] & 31],
+        chars[in_bytes[7] & 31],
+    });
+}
diff --git a/src/fs.zig b/src/fs.zig
index 20c9317d6f..eec9ef34a8 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(.{
@@ -788,7 +788,9 @@ pub const FileSystem = struct {
 
         pub const Limit = struct {
             pub var handles: usize = 0;
+            pub var handles_before = std.mem.zeroes(if (Environment.isPosix) std.posix.rlimit else struct {});
             pub var stack: usize = 0;
+            pub var stack_before = std.mem.zeroes(if (Environment.isPosix) std.posix.rlimit else struct {});
         };
 
         // Always try to max out how many files we can keep open
@@ -797,26 +799,37 @@ pub const FileSystem = struct {
                 return std.math.maxInt(usize);
             }
 
-            const LIMITS = [_]std.posix.rlimit_resource{ std.posix.rlimit_resource.STACK, std.posix.rlimit_resource.NOFILE };
-            inline for (LIMITS, 0..) |limit_type, i| {
-                const limit = try std.posix.getrlimit(limit_type);
-
+            blk: {
+                const resource = std.posix.rlimit_resource.STACK;
+                const limit = try std.posix.getrlimit(resource);
+                Limit.stack_before = limit;
                 if (limit.cur < limit.max) {
                     var new_limit = std.mem.zeroes(std.posix.rlimit);
                     new_limit.cur = limit.max;
                     new_limit.max = limit.max;
 
-                    if (std.posix.setrlimit(limit_type, new_limit)) {
-                        if (i == 1) {
-                            Limit.handles = limit.max;
-                        } else {
-                            Limit.stack = limit.max;
-                        }
-                    } else |_| {}
+                    std.posix.setrlimit(resource, new_limit) catch break :blk;
+                    Limit.stack = limit.max;
                 }
-
-                if (i == LIMITS.len - 1) return limit.max;
             }
+            var file_limit: usize = 0;
+            blk: {
+                const resource = std.posix.rlimit_resource.NOFILE;
+                const limit = try std.posix.getrlimit(resource);
+                Limit.handles_before = limit;
+                file_limit = limit.max;
+                Limit.handles = file_limit;
+                if (limit.cur < limit.max or limit.max < 163840) {
+                    var new_limit = std.mem.zeroes(std.posix.rlimit);
+                    new_limit.cur = @max(limit.max, 163840);
+                    new_limit.max = @max(limit.max, 163840);
+
+                    std.posix.setrlimit(resource, new_limit) catch break :blk;
+                    file_limit = new_limit.max;
+                    Limit.handles = file_limit;
+                }
+            }
+            return file_limit;
         }
 
         var _entries_option_map: *EntriesOption.Map = undefined;
@@ -1033,7 +1046,7 @@ pub const FileSystem = struct {
             comptime Iterator: type,
             iterator: Iterator,
         ) !*EntriesOption {
-            var dir = bun.strings.pathWithoutTrailingSlashOne(dir_maybe_trail_slash);
+            var dir = bun.strings.withoutTrailingSlashWindowsPath(dir_maybe_trail_slash);
 
             bun.resolver.Resolver.assertValidCacheKey(dir);
             var cache_result: ?allocators.Result = null;
@@ -1403,7 +1416,7 @@ pub const FileSystem = struct {
             return cache;
         }
 
-        //     	// Stores the file entries for directories we've listed before
+        //         // Stores the file entries for directories we've listed before
         // entries_mutex: std.Mutex
         // entries      map[string]entriesOrErr
 
@@ -1625,9 +1638,15 @@ threadlocal var normalize_buf: [1024]u8 = undefined;
 threadlocal var join_buf: [1024]u8 = undefined;
 
 pub const Path = struct {
+    /// The display path. In the bundler, this is relative to the current
+    /// working directory. Since it can be emitted in bundles (and used
+    /// for content hashes), this should contain forward slashes on Windows.
     pretty: string,
+    /// The location of this resource. For the `file` namespace, this is
+    /// an absolute path with native slashes.
     text: string,
-    namespace: string = "unspecified",
+    namespace: string,
+    // TODO(@paperdave): investigate removing or simplifying this property (it's 64 bytes)
     name: PathName,
     is_disabled: bool = false,
     is_symlink: bool = false,
@@ -1855,9 +1874,9 @@ pub const Path = struct {
         };
     }
 
-    pub fn initWithNamespaceVirtual(comptime text: string, comptime namespace: string, comptime package: string) Path {
-        return Path{
-            .pretty = comptime "node:" ++ package,
+    pub inline fn initWithNamespaceVirtual(comptime text: string, comptime namespace: string, comptime package: string) Path {
+        return comptime Path{
+            .pretty = namespace ++ ":" ++ package,
             .is_symlink = true,
             .text = text,
             .namespace = namespace,
@@ -1865,6 +1884,16 @@ pub const Path = struct {
         };
     }
 
+    pub inline fn initForKitBuiltIn(comptime namespace: string, comptime package: string) Path {
+        return comptime Path{
+            .pretty = namespace ++ ":" ++ package,
+            .is_symlink = true,
+            .text = "_bun/" ++ package,
+            .namespace = namespace,
+            .name = PathName.init(package),
+        };
+    }
+
     pub fn isBefore(a: *Path, b: Path) bool {
         return a.namespace > b.namespace ||
             (a.namespace == b.namespace and (a.text < b.text ||
@@ -1879,6 +1908,13 @@ pub const Path = struct {
     pub fn isJSXFile(this: *const Path) bool {
         return strings.hasSuffixComptime(this.name.filename, ".jsx") or strings.hasSuffixComptime(this.name.filename, ".tsx");
     }
+
+    pub fn keyForIncrementalGraph(path: *const Path) []const u8 {
+        return if (path.isFile())
+            path.text
+        else
+            path.pretty;
+    }
 };
 
 // pub fn customRealpath(allocator: std.mem.Allocator, path: string) !string {
diff --git a/src/http.zig b/src/http.zig
index 1cfb72daee..eeecb02ee8 100644
--- a/src/http.zig
+++ b/src/http.zig
@@ -69,7 +69,7 @@ var shared_request_headers_buf: [256]picohttp.Header = undefined;
 // this doesn't need to be stack memory because it is immediately cloned after use
 var shared_response_headers_buf: [256]picohttp.Header = undefined;
 
-const end_of_chunked_http1_1_encoding_response_body = "0\r\n\r\n";
+pub const end_of_chunked_http1_1_encoding_response_body = "0\r\n\r\n";
 
 pub const Signals = struct {
     header_progress: ?*std.atomic.Value(bool) = null,
@@ -118,11 +118,32 @@ pub const FetchRedirect = enum(u8) {
 pub const HTTPRequestBody = union(enum) {
     bytes: []const u8,
     sendfile: Sendfile,
+    stream: struct {
+        buffer: bun.io.StreamBuffer,
+        ended: bool,
+        has_backpressure: bool = false,
 
+        pub fn hasEnded(this: *@This()) bool {
+            return this.ended and this.buffer.isEmpty();
+        }
+    },
+
+    pub fn isStream(this: *const HTTPRequestBody) bool {
+        return this.* == .stream;
+    }
+
+    pub fn deinit(this: *HTTPRequestBody) void {
+        switch (this.*) {
+            .sendfile, .bytes => {},
+            .stream => |*stream| stream.buffer.deinit(),
+        }
+    }
     pub fn len(this: *const HTTPRequestBody) usize {
         return switch (this.*) {
             .bytes => this.bytes.len,
             .sendfile => this.sendfile.content_size,
+            // unknow amounts
+            .stream => std.math.maxInt(usize),
         };
     }
 };
@@ -516,6 +537,13 @@ pub const HTTPCertError = struct {
     reason: [:0]const u8 = "",
 };
 
+pub const InitError = error{
+    FailedToOpenSocket,
+    LoadCAFile,
+    InvalidCAFile,
+    InvalidCA,
+};
+
 fn NewHTTPContext(comptime ssl: bool) type {
     return struct {
         const pool_size = 64;
@@ -548,6 +576,13 @@ fn NewHTTPContext(comptime ssl: bool) type {
             return ActiveSocket.from(bun.cast(**anyopaque, ptr).*);
         }
 
+        pub fn getTaggedFromSocket(socket: HTTPSocket) ActiveSocket {
+            if (socket.ext(anyopaque)) |ctx| {
+                return getTagged(ctx);
+            }
+            return ActiveSocket.init(&dead_socket);
+        }
+
         pending_sockets: HiveArray(PooledSocket, pool_size) = HiveArray(PooledSocket, pool_size).init(),
         us_socket_context: *uws.SocketContext,
 
@@ -585,16 +620,30 @@ fn NewHTTPContext(comptime ssl: bool) type {
             bun.default_allocator.destroy(this);
         }
 
-        pub fn initWithClientConfig(this: *@This(), client: *HTTPClient) !void {
+        pub fn initWithClientConfig(this: *@This(), client: *HTTPClient) InitError!void {
             if (!comptime ssl) {
-                unreachable;
+                @compileError("ssl only");
             }
             var opts = client.tls_props.?.asUSockets();
             opts.request_cert = 1;
             opts.reject_unauthorized = 0;
-            const socket = uws.us_create_bun_socket_context(ssl_int, http_thread.loop.loop, @sizeOf(usize), opts);
+            try this.initWithOpts(&opts);
+        }
+
+        fn initWithOpts(this: *@This(), opts: *const uws.us_bun_socket_context_options_t) InitError!void {
+            if (!comptime ssl) {
+                @compileError("ssl only");
+            }
+
+            var err: uws.create_bun_socket_error_t = .none;
+            const socket = uws.us_create_bun_socket_context(ssl_int, http_thread.loop.loop, @sizeOf(usize), opts.*, &err);
             if (socket == null) {
-                return error.FailedToOpenSocket;
+                return switch (err) {
+                    .load_ca_file => error.LoadCAFile,
+                    .invalid_ca_file => error.InvalidCAFile,
+                    .invalid_ca => error.InvalidCA,
+                    else => error.FailedToOpenSocket,
+                };
             }
             this.us_socket_context = socket.?;
             this.sslCtx().setup();
@@ -607,7 +656,21 @@ fn NewHTTPContext(comptime ssl: bool) type {
             );
         }
 
-        pub fn init(this: *@This()) !void {
+        pub fn initWithThreadOpts(this: *@This(), init_opts: *const HTTPThread.InitOpts) InitError!void {
+            if (!comptime ssl) {
+                @compileError("ssl only");
+            }
+            var opts: uws.us_bun_socket_context_options_t = .{
+                .ca = if (init_opts.ca.len > 0) @ptrCast(init_opts.ca) else null,
+                .ca_count = @intCast(init_opts.ca.len),
+                .ca_file_name = if (init_opts.abs_ca_file_name.len > 0) init_opts.abs_ca_file_name else null,
+                .request_cert = 1,
+            };
+
+            try this.initWithOpts(&opts);
+        }
+
+        pub fn init(this: *@This()) void {
             if (comptime ssl) {
                 const opts: uws.us_bun_socket_context_options_t = .{
                     // we request the cert so we load root certs and can verify it
@@ -615,7 +678,8 @@ fn NewHTTPContext(comptime ssl: bool) type {
                     // we manually abort the connection if the hostname doesn't match
                     .reject_unauthorized = 0,
                 };
-                this.us_socket_context = uws.us_create_bun_socket_context(ssl_int, http_thread.loop.loop, @sizeOf(usize), opts).?;
+                var err: uws.create_bun_socket_error_t = .none;
+                this.us_socket_context = uws.us_create_bun_socket_context(ssl_int, http_thread.loop.loop, @sizeOf(usize), opts, &err).?;
 
                 this.sslCtx().setup();
             } else {
@@ -920,6 +984,7 @@ fn NewHTTPContext(comptime ssl: bool) type {
                 socket_path,
                 this.us_socket_context,
                 ActiveSocket.init(client).ptr(),
+                false, // dont allow half-open sockets
             );
             client.allow_retry = false;
             return socket;
@@ -953,6 +1018,7 @@ fn NewHTTPContext(comptime ssl: bool) type {
                 port,
                 this.us_socket_context,
                 ActiveSocket.init(client).ptr(),
+                false,
             );
             client.allow_retry = false;
             return socket;
@@ -963,6 +1029,7 @@ fn NewHTTPContext(comptime ssl: bool) type {
 const UnboundedQueue = @import("./bun.js/unbounded_queue.zig").UnboundedQueue;
 const Queue = UnboundedQueue(AsyncHTTP, .next);
 const ShutdownQueue = UnboundedQueue(AsyncHTTP, .next);
+const RequestWriteQueue = UnboundedQueue(AsyncHTTP, .next);
 
 pub const HTTPThread = struct {
     loop: *JSC.MiniEventLoop,
@@ -972,7 +1039,10 @@ pub const HTTPThread = struct {
     queued_tasks: Queue = Queue{},
 
     queued_shutdowns: std.ArrayListUnmanaged(ShutdownMessage) = std.ArrayListUnmanaged(ShutdownMessage){},
+    queued_writes: std.ArrayListUnmanaged(WriteMessage) = std.ArrayListUnmanaged(WriteMessage){},
+
     queued_shutdowns_lock: bun.Lock = .{},
+    queued_writes_lock: bun.Lock = .{},
 
     queued_proxy_deref: std.ArrayListUnmanaged(*ProxyTunnel) = std.ArrayListUnmanaged(*ProxyTunnel){},
 
@@ -982,7 +1052,14 @@ pub const HTTPThread = struct {
     lazy_libdeflater: ?*LibdeflateState = null,
 
     const threadlog = Output.scoped(.HTTPThread, true);
-
+    const WriteMessage = struct {
+        data: []const u8,
+        async_http_id: u32,
+        flags: packed struct {
+            is_tls: bool,
+            ended: bool,
+        },
+    };
     const ShutdownMessage = struct {
         async_http_id: u32,
         is_tls: bool,
@@ -1005,7 +1082,37 @@ pub const HTTPThread = struct {
         return this.lazy_libdeflater.?;
     }
 
-    fn initOnce() void {
+    fn onInitErrorNoop(err: InitError, opts: InitOpts) noreturn {
+        switch (err) {
+            error.LoadCAFile => {
+                if (!bun.sys.existsZ(opts.abs_ca_file_name)) {
+                    Output.err("HTTPThread", "failed to find CA file: '{s}'", .{opts.abs_ca_file_name});
+                } else {
+                    Output.err("HTTPThread", "failed to load CA file: '{s}'", .{opts.abs_ca_file_name});
+                }
+            },
+            error.InvalidCAFile => {
+                Output.err("HTTPThread", "the CA file is invalid: '{s}'", .{opts.abs_ca_file_name});
+            },
+            error.InvalidCA => {
+                Output.err("HTTPThread", "the provided CA is invalid", .{});
+            },
+            error.FailedToOpenSocket => {
+                Output.errGeneric("failed to start HTTP client thread", .{});
+            },
+        }
+        Global.crash();
+    }
+
+    pub const InitOpts = struct {
+        ca: []stringZ = &.{},
+        abs_ca_file_name: stringZ = &.{},
+        for_install: bool = false,
+
+        onInitError: *const fn (err: InitError, opts: InitOpts) noreturn = &onInitErrorNoop,
+    };
+
+    fn initOnce(opts: *const InitOpts) void {
         http_thread = .{
             .loop = undefined,
             .http_context = .{
@@ -1022,17 +1129,17 @@ pub const HTTPThread = struct {
                 .stack_size = bun.default_thread_stack_size,
             },
             onStart,
-            .{},
+            .{opts.*},
         ) catch |err| Output.panic("Failed to start HTTP Client thread: {s}", .{@errorName(err)});
         thread.detach();
     }
-    var init_once = std.once(initOnce);
+    var init_once = bun.once(initOnce);
 
-    pub fn init() void {
-        init_once.call();
+    pub fn init(opts: *const InitOpts) void {
+        init_once.call(.{opts});
     }
 
-    pub fn onStart() void {
+    pub fn onStart(opts: InitOpts) void {
         Output.Source.configureNamedThread("HTTP Client");
         default_arena = Arena.init() catch unreachable;
         default_allocator = default_arena.allocator();
@@ -1046,8 +1153,8 @@ pub const HTTPThread = struct {
         }
 
         http_thread.loop = loop;
-        http_thread.http_context.init() catch @panic("Failed to init http context");
-        http_thread.https_context.init() catch @panic("Failed to init https context");
+        http_thread.http_context.init();
+        http_thread.https_context.initWithThreadOpts(&opts) catch |err| opts.onInitError(err, opts);
         http_thread.has_awoken.store(true, .monotonic);
         http_thread.processEvents();
     }
@@ -1084,7 +1191,14 @@ pub const HTTPThread = struct {
                     requested_config.deinit();
                     bun.default_allocator.destroy(requested_config);
                     bun.default_allocator.destroy(custom_context);
-                    return err;
+
+                    // TODO: these error names reach js. figure out how they should be handled
+                    return switch (err) {
+                        error.FailedToOpenSocket => |e| e,
+                        error.InvalidCA => error.FailedToOpenSocket,
+                        error.InvalidCAFile => error.FailedToOpenSocket,
+                        error.LoadCAFile => error.FailedToOpenSocket,
+                    };
                 };
                 try custom_ssl_context_map.put(requested_config, custom_context);
                 // We might deinit the socket context, so we disable keepalive to make sure we don't
@@ -1132,6 +1246,65 @@ pub const HTTPThread = struct {
             }
             this.queued_shutdowns.clearRetainingCapacity();
         }
+        {
+            this.queued_writes_lock.lock();
+            defer this.queued_writes_lock.unlock();
+            for (this.queued_writes.items) |write| {
+                const ended = write.flags.ended;
+                defer if (!strings.eqlComptime(write.data, end_of_chunked_http1_1_encoding_response_body) and write.data.len > 0) {
+                    // "0\r\n\r\n" is always a static so no need to free
+                    bun.default_allocator.free(write.data);
+                };
+                if (socket_async_http_abort_tracker.get(write.async_http_id)) |socket_ptr| {
+                    if (write.flags.is_tls) {
+                        const socket = uws.SocketTLS.fromAny(socket_ptr);
+                        if (socket.isClosed() or socket.isShutdown()) {
+                            continue;
+                        }
+                        const tagged = NewHTTPContext(true).getTaggedFromSocket(socket);
+                        if (tagged.get(HTTPClient)) |client| {
+                            if (client.state.original_request_body == .stream) {
+                                var stream = &client.state.original_request_body.stream;
+                                if (write.data.len > 0) {
+                                    stream.buffer.write(write.data) catch {};
+                                }
+                                stream.ended = ended;
+                                if (!stream.has_backpressure) {
+                                    client.onWritable(
+                                        false,
+                                        true,
+                                        socket,
+                                    );
+                                }
+                            }
+                        }
+                    } else {
+                        const socket = uws.SocketTCP.fromAny(socket_ptr);
+                        if (socket.isClosed() or socket.isShutdown()) {
+                            continue;
+                        }
+                        const tagged = NewHTTPContext(false).getTaggedFromSocket(socket);
+                        if (tagged.get(HTTPClient)) |client| {
+                            if (client.state.original_request_body == .stream) {
+                                var stream = &client.state.original_request_body.stream;
+                                if (write.data.len > 0) {
+                                    stream.buffer.write(write.data) catch {};
+                                }
+                                stream.ended = ended;
+                                if (!stream.has_backpressure) {
+                                    client.onWritable(
+                                        false,
+                                        false,
+                                        socket,
+                                    );
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            this.queued_writes.clearRetainingCapacity();
+        }
 
         while (this.queued_proxy_deref.popOrNull()) |http| {
             http.deref();
@@ -1207,6 +1380,23 @@ pub const HTTPThread = struct {
             this.loop.loop.wakeup();
     }
 
+    pub fn scheduleRequestWrite(this: *@This(), http: *AsyncHTTP, data: []const u8, ended: bool) void {
+        {
+            this.queued_writes_lock.lock();
+            defer this.queued_writes_lock.unlock();
+            this.queued_writes.append(bun.default_allocator, .{
+                .async_http_id = http.async_http_id,
+                .data = data,
+                .flags = .{
+                    .is_tls = http.client.isHTTPS(),
+                    .ended = ended,
+                },
+            }) catch bun.outOfMemory();
+        }
+        if (this.has_awoken.load(.monotonic))
+            this.loop.loop.wakeup();
+    }
+
     pub fn scheduleProxyDeref(this: *@This(), proxy: *ProxyTunnel) void {
         // this is always called on the http thread
         {
@@ -1772,6 +1962,7 @@ pub const InternalState = struct {
             info.deinit(bun.default_allocator);
         }
 
+        this.original_request_body.deinit();
         this.* = .{
             .body_out_str = body_msg,
             .compressed_body = MutableString{ .allocator = default_allocator, .list = .{} },
@@ -1925,6 +2116,7 @@ pub const Flags = packed struct {
     proxy_tunneling: bool = false,
     reject_unauthorized: bool = true,
     is_preconnect_only: bool = false,
+    is_streaming_request_body: bool = false,
 };
 
 // TODO: reduce the size of this struct
@@ -2056,6 +2248,7 @@ pub const Encoding = enum {
 
 const host_header_name = "Host";
 const content_length_header_name = "Content-Length";
+const chunked_encoded_header = picohttp.Header{ .name = "Transfer-Encoding", .value = "chunked" };
 const connection_header = picohttp.Header{ .name = "Connection", .value = "keep-alive" };
 const connection_closing_header = picohttp.Header{ .name = "Connection", .value = "close" };
 const accept_header = picohttp.Header{ .name = "Accept", .value = "*/*" };
@@ -2372,11 +2565,33 @@ pub const AsyncHTTP = struct {
         return this;
     }
 
-    pub fn initSync(allocator: std.mem.Allocator, method: Method, url: URL, headers: Headers.Entries, headers_buf: string, response_buffer: *MutableString, request_body: []const u8, http_proxy: ?URL, hostname: ?[]u8, redirect_type: FetchRedirect) AsyncHTTP {
-        return @This().init(allocator, method, url, headers, headers_buf, response_buffer, request_body, undefined, redirect_type, .{
-            .http_proxy = http_proxy,
-            .hostname = hostname,
-        });
+    pub fn initSync(
+        allocator: std.mem.Allocator,
+        method: Method,
+        url: URL,
+        headers: Headers.Entries,
+        headers_buf: string,
+        response_buffer: *MutableString,
+        request_body: []const u8,
+        http_proxy: ?URL,
+        hostname: ?[]u8,
+        redirect_type: FetchRedirect,
+    ) AsyncHTTP {
+        return @This().init(
+            allocator,
+            method,
+            url,
+            headers,
+            headers_buf,
+            response_buffer,
+            request_body,
+            undefined,
+            redirect_type,
+            .{
+                .http_proxy = http_proxy,
+                .hostname = hostname,
+            },
+        );
     }
 
     fn reset(this: *AsyncHTTP) !void {
@@ -2456,8 +2671,8 @@ pub const AsyncHTTP = struct {
         this.channel.writeItem(result) catch unreachable;
     }
 
-    pub fn sendSync(this: *AsyncHTTP, comptime _: bool) anyerror!picohttp.Response {
-        HTTPThread.init();
+    pub fn sendSync(this: *AsyncHTTP) anyerror!picohttp.Response {
+        HTTPThread.init(&.{});
 
         var ctx = try bun.default_allocator.create(SingleHTTPChannel);
         ctx.* = SingleHTTPChannel.init();
@@ -2469,14 +2684,13 @@ pub const AsyncHTTP = struct {
         var batch = bun.ThreadPool.Batch{};
         this.schedule(bun.default_allocator, &batch);
         http_thread.schedule(batch);
-        while (true) {
-            const result: HTTPClientResult = ctx.channel.readItem() catch unreachable;
-            if (result.fail) |e| return e;
-            assert(result.metadata != null);
-            return result.metadata.?.response;
-        }
 
-        unreachable;
+        const result = ctx.channel.readItem() catch unreachable;
+        if (result.fail) |err| {
+            return err;
+        }
+        assert(result.metadata != null);
+        return result.metadata.?.response;
     }
 
     pub fn onAsyncHTTPCallback(this: *AsyncHTTP, async_http: *AsyncHTTP, result: HTTPClientResult) void {
@@ -2571,9 +2785,13 @@ pub fn buildRequest(this: *HTTPClient, body_len: usize) picohttp.Request {
         // Skip host and connection header
         // we manage those
         switch (hash) {
-            hashHeaderConst("Connection"),
             hashHeaderConst("Content-Length"),
             => continue,
+            hashHeaderConst("Connection") => {
+                if (!this.flags.disable_keepalive) {
+                    continue;
+                }
+            },
             hashHeaderConst("if-modified-since") => {
                 if (this.flags.force_last_modified and this.if_modified_since.len == 0) {
                     this.if_modified_since = this.headerStr(header_values[i]);
@@ -2615,8 +2833,10 @@ pub fn buildRequest(this: *HTTPClient, body_len: usize) picohttp.Request {
         header_count += 1;
     }
 
-    request_headers_buf[header_count] = connection_header;
-    header_count += 1;
+    if (!this.flags.disable_keepalive) {
+        request_headers_buf[header_count] = connection_header;
+        header_count += 1;
+    }
 
     if (!override_user_agent) {
         request_headers_buf[header_count] = user_agent_header;
@@ -2643,10 +2863,14 @@ pub fn buildRequest(this: *HTTPClient, body_len: usize) picohttp.Request {
     }
 
     if (body_len > 0 or this.method.hasRequestBody()) {
-        request_headers_buf[header_count] = .{
-            .name = content_length_header_name,
-            .value = std.fmt.bufPrint(&this.request_content_len_buf, "{d}", .{body_len}) catch "0",
-        };
+        if (this.flags.is_streaming_request_body) {
+            request_headers_buf[header_count] = chunked_encoded_header;
+        } else {
+            request_headers_buf[header_count] = .{
+                .name = content_length_header_name,
+                .value = std.fmt.bufPrint(&this.request_content_len_buf, "{d}", .{body_len}) catch "0",
+            };
+        }
         header_count += 1;
     }
 
@@ -2664,8 +2888,16 @@ pub fn doRedirect(
     ctx: *NewHTTPContext(is_ssl),
     socket: NewHTTPContext(is_ssl).HTTPSocket,
 ) void {
+    if (this.state.original_request_body == .stream) {
+        // we cannot follow redirect from a stream right now
+        // NOTE: we can use .tee(), reset the readable stream and cancel/wait pending write requests before redirecting. node.js just errors here so we just closeAndFail too.
+        this.closeAndFail(error.UnexpectedRedirect, is_ssl, socket);
+        return;
+    }
+
     this.unix_socket_path.deinit();
     this.unix_socket_path = JSC.ZigString.Slice.empty;
+    // TODO: what we do with stream body?
     const request_body = if (this.state.flags.resend_request_body_on_redirect and this.state.original_request_body == .bytes)
         this.state.original_request_body.bytes
     else
@@ -2769,10 +3001,10 @@ pub const HTTPResponseMetadata = struct {
     response: picohttp.Response = .{},
     pub fn deinit(this: *HTTPResponseMetadata, allocator: std.mem.Allocator) void {
         if (this.owned_buf.len > 0) allocator.free(this.owned_buf);
-        if (this.response.headers.len > 0) allocator.free(this.response.headers);
+        if (this.response.headers.list.len > 0) allocator.free(this.response.headers.list);
         this.owned_buf = &.{};
         this.url = "";
-        this.response.headers = &.{};
+        this.response.headers = .{};
         this.response.status = "";
     }
 };
@@ -2930,6 +3162,10 @@ pub fn onWritable(this: *HTTPClient, comptime is_first_call: bool, comptime is_s
                     this.state.request_stage = .proxy_handshake;
                 } else {
                     this.state.request_stage = .body;
+                    if (this.flags.is_streaming_request_body) {
+                        // lets signal to start streaming the body
+                        this.progressUpdate(is_ssl, if (is_ssl) &http_thread.https_context else &http_thread.http_context, socket);
+                    }
                 }
                 return;
             }
@@ -2939,11 +3175,15 @@ pub fn onWritable(this: *HTTPClient, comptime is_first_call: bool, comptime is_s
                     this.state.request_stage = .proxy_handshake;
                 } else {
                     this.state.request_stage = .body;
+                    if (this.flags.is_streaming_request_body) {
+                        // lets signal to start streaming the body
+                        this.progressUpdate(is_ssl, if (is_ssl) &http_thread.https_context else &http_thread.http_context, socket);
+                    }
                 }
                 assert(
-                    // we should have leftover data OR we use sendfile()
+                    // we should have leftover data OR we use sendfile/stream
                     (this.state.original_request_body == .bytes and this.state.request_body.len > 0) or
-                        this.state.original_request_body == .sendfile,
+                        this.state.original_request_body == .sendfile or this.state.original_request_body == .stream,
                 );
 
                 // we sent everything, but there's some body leftover
@@ -2974,6 +3214,32 @@ pub fn onWritable(this: *HTTPClient, comptime is_first_call: bool, comptime is_s
                         return;
                     }
                 },
+                .stream => {
+                    var stream = &this.state.original_request_body.stream;
+                    stream.has_backpressure = false;
+                    // to simplify things here the buffer contains the raw data we just need to flush to the socket it
+                    if (stream.buffer.isNotEmpty()) {
+                        const to_send = stream.buffer.slice();
+                        const amount = socket.write(to_send, true);
+                        if (amount < 0) {
+                            this.closeAndFail(error.WriteFailed, is_ssl, socket);
+                            return;
+                        }
+                        this.state.request_sent_len += @as(usize, @intCast(amount));
+                        stream.buffer.cursor += @intCast(amount);
+                        if (amount < to_send.len) {
+                            stream.has_backpressure = true;
+                        }
+                        if (stream.buffer.isEmpty()) {
+                            stream.buffer.reset();
+                        }
+                    }
+                    if (stream.hasEnded()) {
+                        this.state.request_stage = .done;
+                        stream.buffer.deinit();
+                        return;
+                    }
+                },
                 .sendfile => |*sendfile| {
                     if (comptime is_ssl) {
                         @panic("sendfile is only supported without SSL. This code should never have been reached!");
@@ -2996,21 +3262,48 @@ pub fn onWritable(this: *HTTPClient, comptime is_first_call: bool, comptime is_s
             }
         },
         .proxy_body => {
-            if (this.state.original_request_body != .bytes) {
-                @panic("sendfile is only supported without SSL. This code should never have been reached!");
-            }
             if (this.proxy_tunnel) |proxy| {
-                this.setTimeout(socket, 5);
+                switch (this.state.original_request_body) {
+                    .bytes => {
+                        this.setTimeout(socket, 5);
 
-                const to_send = this.state.request_body;
-                const amount = proxy.writeData(to_send) catch return; // just wait and retry when onWritable! if closed internally will call proxy.onClose
+                        const to_send = this.state.request_body;
+                        const amount = proxy.writeData(to_send) catch return; // just wait and retry when onWritable! if closed internally will call proxy.onClose
 
-                this.state.request_sent_len += @as(usize, @intCast(amount));
-                this.state.request_body = this.state.request_body[@as(usize, @intCast(amount))..];
+                        this.state.request_sent_len += @as(usize, @intCast(amount));
+                        this.state.request_body = this.state.request_body[@as(usize, @intCast(amount))..];
 
-                if (this.state.request_body.len == 0) {
-                    this.state.request_stage = .done;
-                    return;
+                        if (this.state.request_body.len == 0) {
+                            this.state.request_stage = .done;
+                            return;
+                        }
+                    },
+                    .stream => {
+                        var stream = &this.state.original_request_body.stream;
+                        stream.has_backpressure = false;
+
+                        // to simplify things here the buffer contains the raw data we just need to flush to the socket it
+                        if (stream.buffer.isNotEmpty()) {
+                            const to_send = stream.buffer.slice();
+                            const amount = proxy.writeData(to_send) catch return; // just wait and retry when onWritable! if closed internally will call proxy.onClose
+                            this.state.request_sent_len += amount;
+                            stream.buffer.cursor += @truncate(amount);
+                            if (amount < to_send.len) {
+                                stream.has_backpressure = true;
+                            }
+                            if (stream.buffer.isEmpty()) {
+                                stream.buffer.reset();
+                            }
+                        }
+                        if (stream.hasEnded()) {
+                            this.state.request_stage = .done;
+                            stream.buffer.deinit();
+                            return;
+                        }
+                    },
+                    .sendfile => {
+                        @panic("sendfile is only supported without SSL. This code should never have been reached!");
+                    },
                 }
             }
         },
@@ -3073,6 +3366,10 @@ pub fn onWritable(this: *HTTPClient, comptime is_first_call: bool, comptime is_s
 
                 if (has_sent_headers) {
                     this.state.request_stage = .proxy_body;
+                    if (this.flags.is_streaming_request_body) {
+                        // lets signal to start streaming the body
+                        this.progressUpdate(is_ssl, if (is_ssl) &http_thread.https_context else &http_thread.http_context, socket);
+                    }
                     assert(this.state.request_body.len > 0);
 
                     // we sent everything, but there's some body leftover
@@ -3183,11 +3480,11 @@ pub fn handleOnDataHeaders(
         return;
     };
 
-    if (this.state.content_encoding_i < response.headers.len and !this.state.flags.did_set_content_encoding) {
+    if (this.state.content_encoding_i < response.headers.list.len and !this.state.flags.did_set_content_encoding) {
         // if it compressed with this header, it is no longer because we will decompress it
-        const mutable_headers = std.ArrayListUnmanaged(picohttp.Header){ .items = response.headers, .capacity = response.headers.len };
+        const mutable_headers = std.ArrayListUnmanaged(picohttp.Header){ .items = response.headers.list, .capacity = response.headers.list.len };
         this.state.flags.did_set_content_encoding = true;
-        response.headers = mutable_headers.items;
+        response.headers = .{ .list = mutable_headers.items };
         this.state.content_encoding_i = std.math.maxInt(@TypeOf(this.state.content_encoding_i));
         // we need to reset the pending response because we removed a header
         this.state.pending_response = response;
@@ -3369,7 +3666,7 @@ fn cloneMetadata(this: *HTTPClient) void {
         builder.count(this.url.href);
         builder.allocate(this.allocator) catch unreachable;
         // headers_buf is owned by the cloned_response (aka cloned_response.headers)
-        const headers_buf = this.allocator.alloc(picohttp.Header, response.headers.len) catch unreachable;
+        const headers_buf = this.allocator.alloc(picohttp.Header, response.headers.list.len) catch unreachable;
         const cloned_response = response.clone(headers_buf, builder);
 
         // we clean the temporary response since cloned_metadata is now the owner
@@ -3456,6 +3753,7 @@ pub const HTTPClientResult = struct {
     body: ?*MutableString = null,
     has_more: bool = false,
     redirected: bool = false,
+    can_stream: bool = false,
 
     fail: ?anyerror = null,
 
@@ -3563,6 +3861,8 @@ pub fn toResult(this: *HTTPClient) HTTPClientResult {
         .has_more = certificate_info != null or (this.state.fail == null and !this.state.isDone()),
         .body_size = body_size,
         .certificate_info = certificate_info,
+        // we can stream the request_body at this stage
+        .can_stream = (this.state.request_stage == .body or this.state.request_stage == .proxy_body) and this.flags.is_streaming_request_body,
     };
 }
 
@@ -3695,11 +3995,6 @@ fn handleResponseBodyChunkedEncodingFromMultiplePackets(
         buffer.list.items.ptr + (buffer.list.items.len -| incoming_data.len),
         &bytes_decoded,
     );
-    if (comptime Environment.allow_assert) {
-        if (pret == -1) {
-            @breakpoint();
-        }
-    }
     buffer.list.items.len -|= incoming_data.len - bytes_decoded;
     this.state.total_body_received += bytes_decoded;
 
@@ -3836,7 +4131,7 @@ pub fn handleResponseMetadata(
     var location: string = "";
     var pretend_304 = false;
     var is_server_sent_events = false;
-    for (response.headers, 0..) |header, header_i| {
+    for (response.headers.list, 0..) |header, header_i| {
         switch (hashHeaderName(header.name)) {
             hashHeaderConst("Content-Length") => {
                 const content_length = std.fmt.parseInt(usize, header.value, 10) catch 0;
diff --git a/src/http/method.zig b/src/http/method.zig
index cba47679fb..67103c523e 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(.HEAD);
-        values.remove(.TRACE);
-        values.remove(.OPTIONS);
         values.remove(.GET);
+        values.remove(.HEAD);
+        values.remove(.OPTIONS);
+        values.remove(.TRACE);
         break :brk values;
     };
 
diff --git a/src/http/websocket_http_client.zig b/src/http/websocket_http_client.zig
index c2c78cc093..5918f68078 100644
--- a/src/http/websocket_http_client.zig
+++ b/src/http/websocket_http_client.zig
@@ -308,6 +308,7 @@ pub fn NewHTTPUpgradeClient(comptime ssl: bool) type {
                 HTTPClient,
                 client,
                 "tcp",
+                false,
             )) |out| {
                 // I don't think this case gets reached.
                 if (out.state == .failed) {
@@ -517,7 +518,7 @@ pub fn NewHTTPUpgradeClient(comptime ssl: bool) type {
                 return;
             }
 
-            for (response.headers) |header| {
+            for (response.headers.list) |header| {
                 switch (header.name.len) {
                     "Connection".len => {
                         if (connection_header.name.len == 0 and strings.eqlCaseInsensitiveASCII(header.name, "Connection", false)) {
diff --git a/src/import_record.zig b/src/import_record.zig
index c21e2223c8..87d1f93ac5 100644
--- a/src/import_record.zig
+++ b/src/import_record.zig
@@ -7,27 +7,20 @@ const Index = @import("ast/base.zig").Index;
 const Api = @import("./api/schema.zig").Api;
 
 pub const ImportKind = enum(u8) {
-    // An entry point provided by the user
+    /// An entry point provided by the user
     entry_point,
-
-    // An ES6 import or re-export statement
+    /// An ES6 import or re-export statement
     stmt,
-
-    // A call to "require()"
+    /// A call to "require()"
     require,
-
-    // An "import()" expression with a string argument
+    /// An "import()" expression with a string argument
     dynamic,
-
     /// A call to "require.resolve()"
     require_resolve,
-
     /// A CSS "@import" rule
     at,
-
     /// A CSS "@import" rule with import conditions
     at_conditional,
-
     /// A CSS "url(...)" token
     url,
 
@@ -103,9 +96,8 @@ pub const ImportKind = enum(u8) {
 pub const ImportRecord = struct {
     range: logger.Range,
     path: fs.Path,
-
-    /// 0 is invalid
-    module_id: u32 = 0,
+    kind: ImportKind,
+    tag: Tag = .none,
 
     source_index: Index = Index.invalid,
 
@@ -125,8 +117,6 @@ pub const ImportRecord = struct {
 
     is_internal: bool = false,
 
-    calls_runtime_require: bool = false,
-
     /// Sometimes the parser creates an import record and decides it isn't needed.
     /// For example, TypeScript code may have import statements that later turn
     /// out to be type-only imports after analyzing the whole file.
@@ -147,9 +137,6 @@ pub const ImportRecord = struct {
     /// calling the "__reExport()" helper function
     calls_runtime_re_export_fn: bool = false,
 
-    /// Tell the printer to use runtime code to resolve this import/export
-    do_commonjs_transform_in_printer: bool = false,
-
     /// True for require calls like this: "try { require() } catch {}". In this
     /// case we shouldn't generate an error if the path could not be resolved.
     is_inside_try_body: bool = false,
@@ -165,10 +152,6 @@ pub const ImportRecord = struct {
     /// If true, this import can be removed if it's unused
     is_external_without_side_effects: bool = false,
 
-    kind: ImportKind,
-
-    tag: Tag = Tag.none,
-
     /// Tell the printer to print the record as "foo:my-path" instead of "path"
     /// where "foo" is the namespace
     ///
@@ -185,31 +168,22 @@ pub const ImportRecord = struct {
     }
 
     pub const Tag = enum {
+        /// A normal import to a user's source file
         none,
-        /// JSX auto-import for React Fast Refresh
-        react_refresh,
-        /// JSX auto-import for jsxDEV or jsx
-        jsx_import,
-        /// JSX auto-import for Fragment or createElement
-        jsx_classic,
-        /// Uses the `bun` import specifier
-        ///     import {foo} from "bun";
+        /// An import to 'bun'
         bun,
-        /// Uses the `bun:test` import specifier
-        ///     import {expect} from "bun:test";
+        /// An import to 'bun:test'
         bun_test,
+        /// A builtin module, such as `node:fs` or `bun:sqlite`
+        builtin,
+        /// An import to the internal runtime
         runtime,
-        hardcoded,
-        /// A macro: import specifier OR a macro import
+        /// A 'macro:' import namespace or 'with { type: "macro" }'
         macro,
-        internal,
 
-        /// Referenced "use client"; at the start of the file
-        react_client_component,
-
-        /// A file starting with "use client"; imported a server entry point
-        /// We don't actually support this right now.
-        react_server_component,
+        /// For Bun Kit, if a module in the server graph should actually
+        /// crossover to the SSR graph. See bake.Framework.ServerComponents.separate_ssr_graph
+        bake_resolve_to_ssr_graph,
 
         with_type_sqlite,
         with_type_sqlite_embedded,
@@ -218,6 +192,8 @@ pub const ImportRecord = struct {
         with_type_toml,
         with_type_file,
 
+        tailwind,
+
         pub fn loader(this: Tag) ?bun.options.Loader {
             return switch (this) {
                 .with_type_sqlite => .sqlite,
@@ -239,14 +215,9 @@ pub const ImportRecord = struct {
 
         pub fn isSQLite(this: Tag) bool {
             return switch (this) {
-                .with_type_sqlite, .with_type_sqlite_embedded => true,
-                else => false,
-            };
-        }
-
-        pub fn isReactReference(this: Tag) bool {
-            return switch (this) {
-                .react_client_component, .react_server_component => true,
+                .with_type_sqlite,
+                .with_type_sqlite_embedded,
+                => true,
                 else => false,
             };
         }
@@ -258,14 +229,6 @@ pub const ImportRecord = struct {
         pub inline fn isInternal(this: Tag) bool {
             return @intFromEnum(this) >= @intFromEnum(Tag.runtime);
         }
-
-        pub fn useDirective(this: Tag) bun.JSAst.UseDirective {
-            return switch (this) {
-                .react_client_component => .@"use client",
-                .react_server_component => .@"use server",
-                else => .none,
-            };
-        }
     };
 
     pub const PrintMode = enum {
diff --git a/src/ini.zig b/src/ini.zig
index bcdb70e16b..1d1dd142d1 100644
--- a/src/ini.zig
+++ b/src/ini.zig
@@ -9,6 +9,7 @@ const Rope = js_ast.E.Object.Rope;
 const Output = bun.Output;
 const Global = bun.Global;
 const Registry = bun.install.Npm.Registry;
+const OOM = bun.OOM;
 
 pub const Parser = struct {
     opts: Options = .{},
@@ -39,10 +40,6 @@ pub const Parser = struct {
         this.arena.deinit();
     }
 
-    pub fn parse(this: *Parser, arena_allocator: Allocator) !void {
-        try this.parseImpl(arena_allocator);
-    }
-
     inline fn shouldSkipLine(line: []const u8) bool {
         if (line.len == 0 or
             // comments
@@ -60,7 +57,7 @@ pub const Parser = struct {
         return true;
     }
 
-    fn parseImpl(this: *Parser, arena_allocator: Allocator) !void {
+    fn parse(this: *Parser, arena_allocator: Allocator) OOM!void {
         var iter = std.mem.splitScalar(u8, this.src, '\n');
         var head: *E.Object = this.out.data.e_object;
 
@@ -91,7 +88,7 @@ pub const Parser = struct {
                 const section: *Rope = try this.prepareStr(arena_allocator, ropealloc, line[1..close_bracket_idx], @as(i32, @intCast(@intFromPtr(line.ptr) - @intFromPtr(this.src.ptr))) + 1, .section);
                 defer rope_stack.fixed_buffer_allocator.reset();
                 const parent_object = this.out.data.e_object.getOrPutObject(section, arena_allocator) catch |e| switch (e) {
-                    error.OutOfMemory => bun.outOfMemory(),
+                    error.OutOfMemory => |oom| return oom,
                     error.Clobber => {
                         // We're in here if key exists but it is not an object
                         //
@@ -161,7 +158,7 @@ pub const Parser = struct {
             else
                 key_raw;
 
-            if (bun.strings.eql(key, "__proto__")) continue;
+            if (bun.strings.eqlComptime(key, "__proto__")) continue;
 
             const value_raw: Expr = brk: {
                 if (maybe_eq_sign_idx) |eq_sign_idx| {
@@ -193,11 +190,11 @@ pub const Parser = struct {
                 if (head.get(key)) |val| {
                     if (val.data != .e_array) {
                         var arr = E.Array{};
-                        arr.push(arena_allocator, val) catch bun.outOfMemory();
-                        head.put(arena_allocator, key, Expr.init(E.Array, arr, Loc.Empty)) catch bun.outOfMemory();
+                        try arr.push(arena_allocator, val);
+                        try head.put(arena_allocator, key, Expr.init(E.Array, arr, Loc.Empty));
                     }
                 } else {
-                    head.put(arena_allocator, key, Expr.init(E.Array, E.Array{}, Loc.Empty)) catch bun.outOfMemory();
+                    try head.put(arena_allocator, key, Expr.init(E.Array, E.Array{}, Loc.Empty));
                 }
             }
 
@@ -207,12 +204,12 @@ pub const Parser = struct {
             if (head.get(key)) |val| {
                 if (val.data == .e_array) {
                     was_already_array = true;
-                    val.data.e_array.push(arena_allocator, value) catch bun.outOfMemory();
-                    head.put(arena_allocator, key, val) catch bun.outOfMemory();
+                    try val.data.e_array.push(arena_allocator, value);
+                    try head.put(arena_allocator, key, val);
                 }
             }
             if (!was_already_array) {
-                head.put(arena_allocator, key, value) catch bun.outOfMemory();
+                try head.put(arena_allocator, key, value);
             }
         }
     }
@@ -224,7 +221,7 @@ pub const Parser = struct {
         val_: []const u8,
         offset_: i32,
         comptime usage: enum { section, key, value },
-    ) !switch (usage) {
+    ) OOM!switch (usage) {
         .value => Expr,
         .section => *Rope,
         .key => []const u8,
@@ -242,7 +239,7 @@ pub const Parser = struct {
             var log = bun.logger.Log.init(arena_allocator);
             defer log.deinit();
             // Try to parse it and it if fails will just treat it as a string
-            const json_val: Expr = bun.JSON.ParseJSONUTF8Impl(&src, &log, arena_allocator, true) catch {
+            const json_val: Expr = bun.JSON.parseUTF8Impl(&src, &log, arena_allocator, true) catch {
                 break :out;
             };
 
@@ -268,10 +265,7 @@ pub const Parser = struct {
                     return "[Object object]";
                 },
                 else => {
-                    const str = std.fmt.allocPrint(arena_allocator, "{}", .{ToStringFormatter{ .d = json_val.data }}) catch |e| {
-                        this.logger.addErrorFmt(&this.source, Loc{ .start = offset }, arena_allocator, "failed to stringify value: {s}", .{@errorName(e)}) catch bun.outOfMemory();
-                        return error.ParserError;
-                    };
+                    const str = try std.fmt.allocPrint(arena_allocator, "{}", .{ToStringFormatter{ .d = json_val.data }});
                     if (comptime usage == .section) return singleStrRope(ropealloc, str);
                     return str;
                 },
@@ -292,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) {
@@ -330,7 +324,7 @@ pub const Parser = struct {
                         not_env_substitution: {
                             if (comptime usage != .value) break :not_env_substitution;
 
-                            if (this.parseEnvSubstitution(val, i, i, &unesc)) |new_i| {
+                            if (try this.parseEnvSubstitution(val, i, i, &unesc)) |new_i| {
                                 // set to true so we heap alloc
                                 did_any_escape = true;
                                 i = new_i;
@@ -348,7 +342,7 @@ pub const Parser = struct {
                     },
                     '.' => {
                         if (comptime usage == .section) {
-                            this.commitRopePart(arena_allocator, ropealloc, &unesc, &rope);
+                            try this.commitRopePart(arena_allocator, ropealloc, &unesc, &rope);
                         } else {
                             try unesc.append('.');
                         }
@@ -380,7 +374,7 @@ pub const Parser = struct {
 
             switch (usage) {
                 .section => {
-                    this.commitRopePart(arena_allocator, ropealloc, &unesc, &rope);
+                    try this.commitRopePart(arena_allocator, ropealloc, &unesc, &rope);
                     return rope.?;
                 },
                 .value => {
@@ -412,7 +406,7 @@ pub const Parser = struct {
     /// - `i` must be an index into `val` that points to a '$' char
     ///
     /// npm/ini uses a regex pattern that will select the inner most ${...}
-    fn parseEnvSubstitution(this: *Parser, val: []const u8, start: usize, i: usize, unesc: *std.ArrayList(u8)) ?usize {
+    fn parseEnvSubstitution(this: *Parser, val: []const u8, start: usize, i: usize, unesc: *std.ArrayList(u8)) OOM!?usize {
         bun.debugAssert(val[i] == '$');
         var esc = false;
         if (i + "{}".len < val.len and val[i + 1] == '{') {
@@ -435,24 +429,21 @@ pub const Parser = struct {
 
             if (start != i) {
                 const missed = val[start..i];
-                unesc.appendSlice(missed) catch bun.outOfMemory();
+                try unesc.appendSlice(missed);
             }
 
             const env_var = val[i + 2 .. j];
-            const expanded = this.expandEnvVar(env_var);
-            unesc.appendSlice(expanded) catch bun.outOfMemory();
+            // https://github.com/npm/cli/blob/534ad7789e5c61f579f44d782bdd18ea3ff1ee20/workspaces/config/lib/env-replace.js#L6
+            const expanded = this.env.get(env_var) orelse return null;
+            try unesc.appendSlice(expanded);
 
             return j;
         }
         return null;
     }
 
-    fn expandEnvVar(this: *Parser, name: []const u8) []const u8 {
-        return this.env.get(name) orelse "";
-    }
-
-    fn singleStrRope(ropealloc: Allocator, str: []const u8) *Rope {
-        const rope = ropealloc.create(Rope) catch bun.outOfMemory();
+    fn singleStrRope(ropealloc: Allocator, str: []const u8) OOM!*Rope {
+        const rope = try ropealloc.create(Rope);
         rope.* = .{
             .head = Expr.init(E.String, E.String.init(str), Loc.Empty),
         };
@@ -463,15 +454,15 @@ pub const Parser = struct {
         return std.mem.indexOfScalar(u8, key, '.');
     }
 
-    fn commitRopePart(this: *Parser, arena_allocator: Allocator, ropealloc: Allocator, unesc: *std.ArrayList(u8), existing_rope: *?*Rope) void {
+    fn commitRopePart(this: *Parser, arena_allocator: Allocator, ropealloc: Allocator, unesc: *std.ArrayList(u8), existing_rope: *?*Rope) OOM!void {
         _ = this; // autofix
-        const slice = arena_allocator.dupe(u8, unesc.items[0..]) catch bun.outOfMemory();
+        const slice = try arena_allocator.dupe(u8, unesc.items[0..]);
         const expr = Expr.init(E.String, E.String{ .data = slice }, Loc.Empty);
         if (existing_rope.*) |_r| {
             const r: *Rope = _r;
-            _ = r.append(expr, ropealloc) catch bun.outOfMemory();
+            _ = try r.append(expr, ropealloc);
         } else {
-            existing_rope.* = ropealloc.create(Rope) catch bun.outOfMemory();
+            existing_rope.* = try ropealloc.create(Rope);
             existing_rope.*.?.* = Rope{
                 .head = expr,
             };
@@ -479,15 +470,15 @@ pub const Parser = struct {
         unesc.clearRetainingCapacity();
     }
 
-    fn strToRope(ropealloc: Allocator, key: []const u8) *Rope {
+    fn strToRope(ropealloc: Allocator, key: []const u8) OOM!*Rope {
         var dot_idx = nextDot(key) orelse {
-            const rope = ropealloc.create(Rope) catch bun.outOfMemory();
+            const rope = try ropealloc.create(Rope);
             rope.* = .{
                 .head = Expr.init(E.String, E.String.init(key), Loc.Empty),
             };
             return rope;
         };
-        var rope = ropealloc.create(Rope) catch bun.outOfMemory();
+        var rope = try ropealloc.create(Rope);
         const head = rope;
         rope.* = .{
             .head = Expr.init(E.String, E.String.init(key[0..dot_idx]), Loc.Empty),
@@ -497,11 +488,11 @@ pub const Parser = struct {
         while (dot_idx + 1 < key.len) {
             const next_dot_idx = dot_idx + 1 + (nextDot(key[dot_idx + 1 ..]) orelse {
                 const rest = key[dot_idx + 1 ..];
-                rope = rope.append(Expr.init(E.String, E.String.init(rest), Loc.Empty), ropealloc) catch bun.outOfMemory();
+                rope = try rope.append(Expr.init(E.String, E.String.init(rest), Loc.Empty), ropealloc);
                 break;
             });
             const part = key[dot_idx + 1 .. next_dot_idx];
-            rope = rope.append(Expr.init(E.String, E.String.init(part), Loc.Empty), ropealloc) catch bun.outOfMemory();
+            rope = try rope.append(Expr.init(E.String, E.String.init(part), Loc.Empty), ropealloc);
             dot_idx = next_dot_idx;
         }
 
@@ -521,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();
@@ -545,45 +536,48 @@ pub const IniTestingAPIs = struct {
             }).init(globalThis, envjs);
             defer object_iter.deinit();
 
-            envmap.ensureTotalCapacity(object_iter.len) catch bun.outOfMemory();
+            try envmap.ensureTotalCapacity(object_iter.len);
 
             while (object_iter.next()) |key| {
-                const keyslice = key.toOwnedSlice(allocator) catch bun.outOfMemory();
+                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 bun.outOfMemory();
+                const slice = try value_str.toOwnedSlice(allocator);
 
                 envmap.put(keyslice, .{
                     .value = slice,
                     .conditional = false,
-                }) catch bun.outOfMemory();
+                }) catch return globalThis.throwOutOfMemoryValue();
             }
 
-            const map = allocator.create(bun.DotEnv.Map) catch bun.outOfMemory();
+            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 bun.outOfMemory();
+            const envstable = try allocator.create(bun.DotEnv.Loader);
             envstable.* = env;
             break :brk envstable;
         };
 
-        const install = allocator.create(bun.Schema.Api.BunInstall) catch bun.outOfMemory();
+        const install = try allocator.create(bun.Schema.Api.BunInstall);
         install.* = std.mem.zeroes(bun.Schema.Api.BunInstall);
-        loadNpmrc(allocator, install, env, false, &log, &source) catch {
+        var configs = std.ArrayList(ConfigIterator.Item).init(allocator);
+        defer configs.deinit();
+        loadNpmrc(allocator, install, env, ".npmrc", &log, &source, &configs) 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),
@@ -599,35 +593,16 @@ 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 {
-        const arguments_ = callframe.arguments(1);
+    pub fn parse(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+        const arguments_ = callframe.arguments_old(1);
         const arguments = arguments_.slice();
 
         const jsstr = arguments[0];
@@ -639,16 +614,10 @@ 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 |e| {
-            if (parser.logger.errors > 0) {
-                parser.logger.printForLogLevel(bun.Output.writer()) catch bun.outOfMemory();
-            } else globalThis.throwError(e, "failed to parse");
-            return .undefined;
-        };
+        try parser.parse(parser.arena.allocator());
 
-        return parser.out.toJS(bun.default_allocator, globalThis, .{ .decode_escape_sequences = true }) catch |e| {
-            globalThis.throwError(e, "failed to turn AST into JS");
-            return .undefined;
+        return parser.out.toJS(bun.default_allocator, globalThis) catch |e| {
+            return globalThis.throwError(e, "failed to turn AST into JS");
         };
     }
 };
@@ -670,7 +639,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)});
@@ -735,39 +703,56 @@ pub const ConfigIterator = struct {
             }
         };
 
+        /// Duplicate ConfigIterator.Item
+        pub fn dupe(this: *const Item, allocator: Allocator) OOM!?Item {
+            return .{
+                .registry_url = try allocator.dupe(u8, this.registry_url),
+                .optname = this.optname,
+                .value = try allocator.dupe(u8, this.value),
+                .loc = this.loc,
+            };
+        }
+
         /// Duplicate the value, decoding it if it is base64 encoded.
         pub fn dupeValueDecoded(
             this: *const Item,
             allocator: Allocator,
             log: *bun.logger.Log,
             source: *const bun.logger.Source,
-        ) ?[]const u8 {
+        ) OOM!?[]const u8 {
             if (this.optname.isBase64Encoded()) {
                 if (this.value.len == 0) return "";
                 const len = bun.base64.decodeLen(this.value);
-                var slice = allocator.alloc(u8, len) catch bun.outOfMemory();
+                var slice = try allocator.alloc(u8, len);
                 const result = bun.base64.decode(slice[0..], this.value);
                 if (result.status != .success) {
-                    log.addErrorFmt(
-                        source,
-                        this.loc,
+                    try log.addErrorFmtOpts(
                         allocator,
                         "{s} is not valid base64",
                         .{@tagName(this.optname)},
-                    ) catch bun.outOfMemory();
+                        .{
+                            .source = source,
+                            .loc = this.loc,
+                        },
+                    );
                     return null;
                 }
-                return allocator.dupe(u8, slice[0..result.count]) catch bun.outOfMemory();
+                return try allocator.dupe(u8, slice[0..result.count]);
             }
-            return allocator.dupe(u8, this.value) catch bun.outOfMemory();
+            return try allocator.dupe(u8, this.value);
         }
 
         pub fn format(this: *const @This(), comptime _: []const u8, _: std.fmt.FormatOptions, writer: anytype) !void {
             try writer.print("//{s}:{s}={s}", .{ this.registry_url, @tagName(this.optname), this.value });
         }
+
+        pub fn deinit(self: *const Item, allocator: Allocator) void {
+            allocator.free(self.registry_url);
+            allocator.free(self.value);
+        }
     };
 
-    pub fn next(this: *ConfigIterator) error{ParserError}!?Option(Item) {
+    pub fn next(this: *ConfigIterator) ?Option(Item) {
         if (this.prop_idx >= this.config.properties.len) return null;
         defer this.prop_idx += 1;
 
@@ -833,7 +818,7 @@ pub const ScopeIterator = struct {
 
     const Item = struct { scope: []const u8, registry: bun.Schema.Api.NpmRegistry };
 
-    pub fn next(this: *ScopeIterator) error{ParserError}!?Option(Item) {
+    pub fn next(this: *ScopeIterator) OOM!?Option(Item) {
         if (this.prop_idx >= this.config.properties.len) return null;
         defer this.prop_idx += 1;
 
@@ -854,10 +839,7 @@ pub const ScopeIterator = struct {
                                                 .source = this.source,
                                                 .allocator = this.allocator,
                                             };
-                                            break :brk parser.parseRegistryURLStringImpl(str) catch |e| {
-                                                if (e == error.OutOfMemory) bun.outOfMemory();
-                                                return error.ParserError;
-                                            };
+                                            break :brk try parser.parseRegistryURLStringImpl(str);
                                         }
                                     }
                                     return .none;
@@ -873,77 +855,63 @@ pub const ScopeIterator = struct {
     }
 };
 
-pub fn loadNpmrcFromFile(
+pub fn loadNpmrcConfig(
     allocator: std.mem.Allocator,
     install: *bun.Schema.Api.BunInstall,
     env: *bun.DotEnv.Loader,
     auto_loaded: bool,
+    npmrc_paths: []const [:0]const u8,
 ) void {
     var log = bun.logger.Log.init(allocator);
     defer log.deinit();
-    const npmrc_file = switch (bun.sys.openat(bun.FD.cwd(), ".npmrc", bun.O.RDONLY, 0)) {
-        .result => |fd| fd,
-        .err => |err| {
-            if (auto_loaded) return;
-            Output.prettyErrorln("{}\nwhile opening .npmrc \"{s}\"", .{
-                err,
-                ".npmrc",
-            });
-            Global.exit(1);
-        },
-    };
-    defer _ = bun.sys.close(npmrc_file);
 
-    const source = switch (bun.sys.File.toSource(".npmrc", allocator)) {
-        .result => |s| s,
-        .err => |e| {
-            Output.prettyErrorln("{}\nwhile reading .npmrc \"{s}\"", .{
-                e,
-                ".npmrc",
-            });
-            Global.exit(1);
-        },
-    };
-    defer allocator.free(source.contents);
+    // npmrc registry configurations are shared between all npmrc files
+    // so we need to collect them as we go for the final registry map
+    // to be created at the end.
+    var configs = std.ArrayList(ConfigIterator.Item).init(allocator);
+    defer {
+        for (configs.items) |item| {
+            item.deinit(allocator);
+        }
+        configs.deinit();
+    }
 
-    loadNpmrc(allocator, install, env, auto_loaded, &log, &source) catch {
-        if (log.errors == 1)
-            Output.warn("Encountered an error while reading <b>.npmrc<r>:\n", .{})
-        else
-            Output.warn("Encountered errors while reading <b>.npmrc<r>:\n", .{});
-    };
-    log.printForLogLevel(Output.errorWriter()) catch bun.outOfMemory();
+    for (npmrc_paths) |npmrc_path| {
+        const source = bun.sys.File.toSource(npmrc_path, allocator).unwrap() catch |err| {
+            if (auto_loaded) continue;
+            Output.err(err, "failed to read .npmrc: \"{s}\"", .{npmrc_path});
+            Global.crash();
+        };
+        defer allocator.free(source.contents);
+
+        loadNpmrc(allocator, install, env, npmrc_path, &log, &source, &configs) catch |err| {
+            switch (err) {
+                error.OutOfMemory => bun.outOfMemory(),
+            }
+        };
+        if (log.hasErrors()) {
+            if (log.errors == 1)
+                Output.warn("Encountered an error while reading <b>{s}<r>:\n\n", .{npmrc_path})
+            else
+                Output.warn("Encountered errors while reading <b>{s}<r>:\n\n", .{npmrc_path});
+            Output.flush();
+        }
+        log.print(Output.errorWriter()) catch {};
+    }
 }
 
 pub fn loadNpmrc(
     allocator: std.mem.Allocator,
     install: *bun.Schema.Api.BunInstall,
     env: *bun.DotEnv.Loader,
-    auto_loaded: bool,
+    npmrc_path: [:0]const u8,
     log: *bun.logger.Log,
     source: *const bun.logger.Source,
-) !void {
-    var parser = bun.ini.Parser.init(allocator, ".npmrc", source.contents, env);
+    configs: *std.ArrayList(ConfigIterator.Item),
+) OOM!void {
+    var parser = bun.ini.Parser.init(allocator, npmrc_path, source.contents, env);
     defer parser.deinit();
-    parser.parse(parser.arena.allocator()) catch |e| {
-        if (e == error.ParserError) {
-            parser.logger.printForLogLevel(Output.errorWriter()) catch unreachable;
-            return e;
-        }
-        if (auto_loaded) {
-            Output.warn("{}\nwhile reading .npmrc \"{s}\"", .{
-                e,
-                ".npmrc",
-            });
-            return;
-        }
-        Output.prettyErrorln("{}\nwhile reading .npmrc \"{s}\"", .{
-            e,
-            ".npmrc",
-        });
-        Global.exit(1);
-    };
-
+    try parser.parse(parser.arena.allocator());
     // Need to be very, very careful here with strings.
     // They are allocated in the Parser's arena, which of course gets
     // deinitialized at the end of the scope.
@@ -957,16 +925,13 @@ pub fn loadNpmrc(
                 .log = log,
                 .source = source,
             };
-            install.default_registry = p.parseRegistryURLStringImpl(allocator.dupe(u8, str) catch bun.outOfMemory()) catch |e| {
-                if (e == error.OutOfMemory) bun.outOfMemory();
-                return error.ParserError;
-            };
+            install.default_registry = try p.parseRegistryURLStringImpl(try allocator.dupe(u8, str));
         }
     }
 
     if (out.asProperty("cache")) |query| {
         if (query.expr.asUtf8StringLiteral()) |str| {
-            install.cache_directory = allocator.dupe(u8, str) catch bun.outOfMemory();
+            install.cache_directory = try allocator.dupe(u8, str);
         } else if (query.expr.asBool()) |b| {
             install.disable_cache = !b;
         }
@@ -980,6 +945,32 @@ pub fn loadNpmrc(
         }
     }
 
+    if (out.asProperty("ca")) |query| {
+        if (query.expr.asUtf8StringLiteral()) |str| {
+            install.ca = .{
+                .str = str,
+            };
+        } else if (query.expr.isArray()) {
+            const arr = query.expr.data.e_array;
+            var list = try allocator.alloc([]const u8, arr.items.len);
+            var i: usize = 0;
+            for (arr.items.slice()) |item| {
+                list[i] = try item.asStringCloned(allocator) orelse continue;
+                i += 1;
+            }
+
+            install.ca = .{
+                .list = list,
+            };
+        }
+    }
+
+    if (out.asProperty("cafile")) |query| {
+        if (try query.expr.asStringCloned(allocator)) |cafile| {
+            install.cafile = cafile;
+        }
+    }
+
     var registry_map = install.scoped orelse bun.Schema.Api.NpmRegistryMap{};
 
     // Process scopes
@@ -994,13 +985,7 @@ pub fn loadNpmrc(
 
         const scope_count = brk: {
             var count: usize = 0;
-            while (iter.next() catch {
-                const prop_idx = iter.prop_idx -| 1;
-                const prop = iter.config.properties.at(prop_idx);
-                const loc = prop.key.?.loc;
-                log.addErrorFmt(source, loc, parser.arena.allocator(), "Found an invalid registry option:", .{}) catch bun.outOfMemory();
-                return error.ParserError;
-            }) |o| {
+            while (try iter.next()) |o| {
                 if (o == .some) {
                     count += 1;
                 }
@@ -1009,19 +994,19 @@ pub fn loadNpmrc(
         };
 
         defer install.scoped = registry_map;
-        registry_map.scopes.ensureUnusedCapacity(allocator, scope_count) catch bun.outOfMemory();
+        try registry_map.scopes.ensureUnusedCapacity(allocator, scope_count);
 
         iter.prop_idx = 0;
         iter.count = false;
 
-        while (iter.next() catch unreachable) |val| {
+        while (try iter.next()) |val| {
             if (val.get()) |result| {
                 const registry = result.registry.dupe(allocator);
-                registry_map.scopes.put(
+                try registry_map.scopes.put(
                     allocator,
-                    allocator.dupe(u8, result.scope) catch bun.outOfMemory(),
+                    try allocator.dupe(u8, result.scope),
                     registry,
-                ) catch bun.outOfMemory();
+                );
             }
         }
     }
@@ -1029,7 +1014,7 @@ pub fn loadNpmrc(
     // Process registry configuration
     out: {
         const count = brk: {
-            var count: usize = 0;
+            var count: usize = configs.items.len;
             for (parser.out.data.e_object.properties.slice()) |prop| {
                 if (prop.key) |keyexpr| {
                     if (keyexpr.asUtf8StringLiteral()) |key| {
@@ -1068,11 +1053,11 @@ pub fn loadNpmrc(
         // The line that sets the username would apply to both @myorg and @another
         var url_map = url_map: {
             var url_map = bun.StringArrayHashMap(bun.URL).init(parser.arena.allocator());
-            url_map.ensureTotalCapacity(registry_map.scopes.keys().len) catch bun.outOfMemory();
+            try url_map.ensureTotalCapacity(registry_map.scopes.keys().len);
 
             for (registry_map.scopes.keys(), registry_map.scopes.values()) |*k, *v| {
                 const url = bun.URL.parse(v.url);
-                url_map.put(k.*, url) catch bun.outOfMemory();
+                try url_map.put(k.*, url);
             }
 
             break :url_map url_map;
@@ -1087,13 +1072,7 @@ pub fn loadNpmrc(
             .allocator = allocator,
         };
 
-        while (iter.next() catch {
-            const prop_idx = iter.prop_idx -| 1;
-            const prop = iter.config.properties.at(prop_idx);
-            const loc = prop.key.?.loc;
-            log.addErrorFmt(source, loc, parser.arena.allocator(), "Found an invalid registry option:", .{}) catch bun.outOfMemory();
-            return error.ParserError;
-        }) |val| {
+        while (iter.next()) |val| {
             if (val.get()) |conf_item_| {
                 // `conf_item` will look like:
                 //
@@ -1105,7 +1084,7 @@ pub fn loadNpmrc(
                 const conf_item: bun.ini.ConfigIterator.Item = conf_item_;
                 switch (conf_item.optname) {
                     .email, .certfile, .keyfile => {
-                        log.addWarningFmt(
+                        try log.addWarningFmt(
                             source,
                             iter.config.properties.at(iter.prop_idx - 1).key.?.loc,
                             allocator,
@@ -1114,94 +1093,78 @@ pub fn loadNpmrc(
                                 conf_item,
                                 @tagName(conf_item.optname),
                             },
-                        ) catch bun.outOfMemory();
+                        );
                         continue;
                     },
                     else => {},
                 }
-                const conf_item_url = bun.URL.parse(conf_item.registry_url);
+                if (try conf_item_.dupe(allocator)) |x| try configs.append(x);
+            }
+        }
 
-                if (std.mem.eql(u8, bun.strings.withoutTrailingSlash(default_registry_url.host), bun.strings.withoutTrailingSlash(conf_item_url.host))) {
-                    const v: *bun.Schema.Api.NpmRegistry = brk: {
-                        if (install.default_registry) |*r| break :brk r;
-                        install.default_registry = bun.Schema.Api.NpmRegistry{
-                            .password = "",
-                            .token = "",
-                            .username = "",
-                            .url = Registry.default_url,
-                        };
-                        break :brk &install.default_registry.?;
+        for (configs.items) |conf_item| {
+            const conf_item_url = bun.URL.parse(conf_item.registry_url);
+
+            if (std.mem.eql(u8, bun.strings.withoutTrailingSlash(default_registry_url.host), bun.strings.withoutTrailingSlash(conf_item_url.host))) {
+                const v: *bun.Schema.Api.NpmRegistry = brk: {
+                    if (install.default_registry) |*r| break :brk r;
+                    install.default_registry = bun.Schema.Api.NpmRegistry{
+                        .password = "",
+                        .token = "",
+                        .username = "",
+                        .url = Registry.default_url,
                     };
+                    break :brk &install.default_registry.?;
+                };
 
+                switch (conf_item.optname) {
+                    ._authToken => {
+                        if (try conf_item.dupeValueDecoded(allocator, log, source)) |x| v.token = x;
+                    },
+                    .username => {
+                        if (try conf_item.dupeValueDecoded(allocator, log, source)) |x| v.username = x;
+                    },
+                    ._password => {
+                        if (try conf_item.dupeValueDecoded(allocator, log, source)) |x| v.password = x;
+                    },
+                    ._auth => {
+                        try @"handle _auth"(allocator, v, &conf_item, log, source);
+                    },
+                    .email, .certfile, .keyfile => unreachable,
+                }
+                continue;
+            }
+
+            for (registry_map.scopes.keys(), registry_map.scopes.values()) |*k, *v| {
+                const url = url_map.get(k.*) orelse unreachable;
+
+                if (std.mem.eql(u8, bun.strings.withoutTrailingSlash(url.host), bun.strings.withoutTrailingSlash(conf_item_url.host))) {
+                    if (conf_item_url.hostname.len > 0) {
+                        if (!std.mem.eql(u8, bun.strings.withoutTrailingSlash(url.hostname), bun.strings.withoutTrailingSlash(conf_item_url.hostname))) {
+                            continue;
+                        }
+                    }
                     switch (conf_item.optname) {
                         ._authToken => {
-                            if (conf_item.dupeValueDecoded(allocator, log, source)) |x| v.token = x;
+                            if (try conf_item.dupeValueDecoded(allocator, log, source)) |x| v.token = x;
                         },
                         .username => {
-                            if (conf_item.dupeValueDecoded(allocator, log, source)) |x| v.username = x;
+                            if (try conf_item.dupeValueDecoded(allocator, log, source)) |x| v.username = x;
                         },
                         ._password => {
-                            if (conf_item.dupeValueDecoded(allocator, log, source)) |x| v.password = x;
+                            if (try conf_item.dupeValueDecoded(allocator, log, source)) |x| v.password = x;
                         },
                         ._auth => {
-                            _ = @"handle _auth"(allocator, v, &conf_item, log, source);
+                            try @"handle _auth"(allocator, v, &conf_item, log, source);
                         },
                         .email, .certfile, .keyfile => unreachable,
                     }
+                    // We have to keep going as it could match multiple scopes
                     continue;
                 }
-
-                var matched_at_least_one = false;
-                for (registry_map.scopes.keys(), registry_map.scopes.values()) |*k, *v| {
-                    const url = url_map.get(k.*) orelse unreachable;
-
-                    if (std.mem.eql(u8, bun.strings.withoutTrailingSlash(url.host), bun.strings.withoutTrailingSlash(conf_item_url.host))) {
-                        if (conf_item_url.hostname.len > 0) {
-                            if (!std.mem.eql(u8, bun.strings.withoutTrailingSlash(url.hostname), bun.strings.withoutTrailingSlash(conf_item_url.hostname))) {
-                                continue;
-                            }
-                        }
-                        matched_at_least_one = true;
-                        switch (conf_item.optname) {
-                            ._authToken => {
-                                if (conf_item.dupeValueDecoded(allocator, log, source)) |x| v.token = x;
-                            },
-                            .username => {
-                                if (conf_item.dupeValueDecoded(allocator, log, source)) |x| v.username = x;
-                            },
-                            ._password => {
-                                if (conf_item.dupeValueDecoded(allocator, log, source)) |x| v.password = x;
-                            },
-                            ._auth => {
-                                _ = @"handle _auth"(allocator, v, &conf_item, log, source);
-                            },
-                            .email, .certfile, .keyfile => unreachable,
-                        }
-                        // We have to keep going as it could match multiple scopes
-                        continue;
-                    }
-                }
-
-                if (!matched_at_least_one) {
-                    log.addWarningFmt(
-                        source,
-                        iter.config.properties.at(iter.prop_idx - 1).key.?.loc,
-                        allocator,
-                        "The following .npmrc registry option was not applied:\n\n  <b>{s}<r>\n\nBecause we couldn't find the registry: <b>{s}<r>.",
-                        .{
-                            conf_item,
-                            conf_item.registry_url,
-                        },
-                    ) catch bun.outOfMemory();
-                }
             }
         }
     }
-
-    const had_errors = log.hasErrors();
-    if (had_errors) {
-        return error.ParserError;
-    }
 }
 
 fn @"handle _auth"(
@@ -1210,35 +1173,57 @@ fn @"handle _auth"(
     conf_item: *const ConfigIterator.Item,
     log: *bun.logger.Log,
     source: *const bun.logger.Source,
-) void {
+) OOM!void {
     if (conf_item.value.len == 0) {
-        log.addErrorFmt(
-            source,
-            conf_item.loc,
-            allocator,
-            "invalid _auth value, expected it to be \"\\<username\\>:\\<password\\>\" encoded in base64, but got an empty string",
-            .{},
-        ) catch bun.outOfMemory();
+        try log.addErrorOpts(
+            "invalid _auth value, expected base64 encoded \"<username>:<password>\", received an empty string",
+            .{
+                .source = source,
+                .loc = conf_item.loc,
+                .redact_sensitive_information = true,
+            },
+        );
         return;
     }
     const decode_len = bun.base64.decodeLen(conf_item.value);
-    const decoded = allocator.alloc(u8, decode_len) catch bun.outOfMemory();
+    const decoded = try allocator.alloc(u8, decode_len);
     const result = bun.base64.decode(decoded[0..], conf_item.value);
     if (!result.isSuccessful()) {
         defer allocator.free(decoded);
-        log.addErrorFmt(source, conf_item.loc, allocator, "invalid base64", .{}) catch bun.outOfMemory();
+        try log.addErrorOpts(
+            "invalid _auth value, expected valid base64",
+            .{
+                .source = source,
+                .loc = conf_item.loc,
+                .redact_sensitive_information = true,
+            },
+        );
         return;
     }
     const @"username:password" = decoded[0..result.count];
     const colon_idx = std.mem.indexOfScalar(u8, @"username:password", ':') orelse {
-        defer allocator.free(decoded);
-        log.addErrorFmt(source, conf_item.loc, allocator, "invalid _auth value, expected it to be \"\\<username\\>:\\<password\\>\" encoded in base 64, but got:\n\n{s}", .{decoded}) catch bun.outOfMemory();
+        defer allocator.free(@"username:password");
+        try log.addErrorOpts(
+            "invalid _auth value, expected base64 encoded \"<username>:<password>\"",
+            .{
+                .source = source,
+                .loc = conf_item.loc,
+                .redact_sensitive_information = true,
+            },
+        );
         return;
     };
     const username = @"username:password"[0..colon_idx];
     if (colon_idx + 1 >= @"username:password".len) {
-        defer allocator.free(decoded);
-        log.addErrorFmt(source, conf_item.loc, allocator, "invalid _auth value, expected it to be \"\\<username\\>:\\<password\\>\" encoded in base64, but got:\n\n{s}", .{decoded}) catch bun.outOfMemory();
+        defer allocator.free(@"username:password");
+        try log.addErrorOpts(
+            "invalid _auth value, expected base64 encoded \"<username>:<password>\"",
+            .{
+                .source = source,
+                .loc = conf_item.loc,
+                .redact_sensitive_information = true,
+            },
+        );
         return;
     }
     const password = @"username:password"[colon_idx + 1 ..];
diff --git a/src/install/bin.zig b/src/install/bin.zig
index 8361b90bc9..1667455d26 100644
--- a/src/install/bin.zig
+++ b/src/install/bin.zig
@@ -195,7 +195,7 @@ pub const Bin = extern struct {
             if (this.done) return null;
             if (this.dir_iterator == null) {
                 var target = this.bin.value.dir.slice(this.string_buffer);
-                if (strings.hasPrefix(target, "./")) {
+                if (strings.hasPrefixComptime(target, "./") or strings.hasPrefixComptime(target, ".\\")) {
                     target = target[2..];
                 }
                 var parts = [_][]const u8{ this.package_name.slice(this.string_buffer), target };
@@ -229,7 +229,7 @@ pub const Bin = extern struct {
                     this.i += 1;
                     this.done = true;
                     const base = std.fs.path.basename(this.package_name.slice(this.string_buffer));
-                    if (strings.hasPrefix(base, "./"))
+                    if (strings.hasPrefixComptime(base, "./") or strings.hasPrefixComptime(base, ".\\"))
                         return strings.copy(&this.buf, base[2..]);
 
                     return strings.copy(&this.buf, base);
@@ -239,7 +239,7 @@ pub const Bin = extern struct {
                     this.i += 1;
                     this.done = true;
                     const base = std.fs.path.basename(this.bin.value.named_file[0].slice(this.string_buffer));
-                    if (strings.hasPrefix(base, "./"))
+                    if (strings.hasPrefixComptime(base, "./") or strings.hasPrefixComptime(base, ".\\"))
                         return strings.copy(&this.buf, base[2..]);
                     return strings.copy(&this.buf, base);
                 },
@@ -259,7 +259,7 @@ pub const Bin = extern struct {
                             this.string_buffer,
                         ),
                     );
-                    if (strings.hasPrefix(base, "./"))
+                    if (strings.hasPrefixComptime(base, "./") or strings.hasPrefixComptime(base, ".\\"))
                         return strings.copy(&this.buf, base[2..]);
                     return strings.copy(&this.buf, base);
                 },
@@ -305,7 +305,6 @@ pub const Bin = extern struct {
         /// Used for generating relative paths
         package_name: strings.StringOrTinyString,
 
-        global_bin_dir: std.fs.Dir,
         global_bin_path: stringZ = "",
 
         string_buf: []const u8,
@@ -345,8 +344,8 @@ pub const Bin = extern struct {
         }
 
         fn linkBinOrCreateShim(this: *Linker, abs_target: [:0]const u8, abs_dest: [:0]const u8, global: bool) void {
-            bun.assertWithLocation(std.fs.path.isAbsoluteZ(abs_target), @src());
-            bun.assertWithLocation(std.fs.path.isAbsoluteZ(abs_dest), @src());
+            bun.assertWithLocation(std.fs.path.isAbsolute(abs_target), @src());
+            bun.assertWithLocation(std.fs.path.isAbsolute(abs_dest), @src());
             bun.assertWithLocation(abs_target[abs_target.len - 1] != std.fs.path.sep, @src());
             bun.assertWithLocation(abs_dest[abs_dest.len - 1] != std.fs.path.sep, @src());
 
@@ -368,10 +367,19 @@ pub const Bin = extern struct {
 
             bun.Analytics.Features.binlinks += 1;
 
-            if (comptime Environment.isWindows)
-                this.createWindowsShim(abs_target, abs_dest, global)
-            else
-                this.createSymlink(abs_target, abs_dest, global);
+            if (comptime !Environment.isWindows)
+                this.createSymlink(abs_target, abs_dest, global)
+            else {
+                const target = bun.sys.openat(bun.invalid_fd, abs_target, bun.O.RDONLY, 0).unwrap() catch |err| {
+                    if (err != error.EISDIR) {
+                        // ignore directories, creating a shim for one won't do anything
+                        this.err = err;
+                    }
+                    return;
+                };
+                defer _ = bun.sys.close(target);
+                this.createWindowsShim(target, abs_target, abs_dest, global);
+            }
 
             if (this.err != null) {
                 // cleanup on error just in case
@@ -401,7 +409,7 @@ pub const Bin = extern struct {
             }
         }
 
-        fn createWindowsShim(this: *Linker, abs_target: [:0]const u8, abs_dest: [:0]const u8, global: bool) void {
+        fn createWindowsShim(this: *Linker, target: bun.FileDescriptor, abs_target: [:0]const u8, abs_dest: [:0]const u8, global: bool) void {
             const WinBinLinkingShim = @import("./windows-shim/BinLinkingShim.zig");
 
             var shim_buf: [65536]u8 = undefined;
@@ -435,13 +443,7 @@ pub const Bin = extern struct {
 
             const shebang = shebang: {
                 const first_content_chunk = contents: {
-                    const target = bun.openFileZ(abs_target, .{ .mode = .read_only }) catch |err| {
-                        // it should exist, this error is real
-                        this.err = err;
-                        return;
-                    };
-                    defer target.close();
-                    const reader = target.reader();
+                    const reader = target.asFile().reader();
                     const read = reader.read(&read_in_buf) catch break :contents null;
                     if (read == 0) break :contents null;
                     break :contents read_in_buf[0..read];
@@ -587,6 +589,8 @@ pub const Bin = extern struct {
             return remain;
         }
 
+        // target: what the symlink points to
+        // destination: where the symlink exists on disk
         pub fn link(this: *Linker, global: bool) void {
             const package_dir = this.buildTargetPackageDir();
             var abs_dest_buf_remain = this.buildDestinationDir(global);
diff --git a/src/install/dependency.zig b/src/install/dependency.zig
index d21b8be319..6f3667988e 100644
--- a/src/install/dependency.zig
+++ b/src/install/dependency.zig
@@ -78,11 +78,11 @@ pub fn count(this: *const Dependency, buf: []const u8, comptime StringBuilder: t
     this.countWithDifferentBuffers(buf, buf, StringBuilder, builder);
 }
 
-pub fn clone(this: *const Dependency, buf: []const u8, comptime StringBuilder: type, builder: StringBuilder) !Dependency {
-    return this.cloneWithDifferentBuffers(buf, buf, StringBuilder, builder);
+pub fn clone(this: *const Dependency, package_manager: *PackageManager, buf: []const u8, comptime StringBuilder: type, builder: StringBuilder) !Dependency {
+    return this.cloneWithDifferentBuffers(package_manager, buf, buf, StringBuilder, builder);
 }
 
-pub fn cloneWithDifferentBuffers(this: *const Dependency, name_buf: []const u8, version_buf: []const u8, comptime StringBuilder: type, builder: StringBuilder) !Dependency {
+pub fn cloneWithDifferentBuffers(this: *const Dependency, package_manager: *PackageManager, name_buf: []const u8, version_buf: []const u8, comptime StringBuilder: type, builder: StringBuilder) !Dependency {
     const out_slice = builder.lockfile.buffers.string_bytes.items;
     const new_literal = builder.append(String, this.version.literal.slice(version_buf));
     const sliced = new_literal.sliced(out_slice);
@@ -99,6 +99,7 @@ pub fn cloneWithDifferentBuffers(this: *const Dependency, name_buf: []const u8,
             this.version.tag,
             &sliced,
             null,
+            package_manager,
         ) orelse Dependency.Version{},
         .behavior = this.behavior,
     };
@@ -115,6 +116,7 @@ pub const Context = struct {
     allocator: std.mem.Allocator,
     log: *logger.Log,
     buffer: []const u8,
+    package_manager: ?*PackageManager,
 };
 
 /// Get the name of the package as it should appear in a remote registry.
@@ -284,12 +286,31 @@ pub fn unscopedPackageName(name: []const u8) []const u8 {
     return name_[(strings.indexOfChar(name_, '/') orelse return name) + 1 ..];
 }
 
+pub fn isScopedPackageName(name: string) error{InvalidPackageName}!bool {
+    if (name.len == 0) return error.InvalidPackageName;
+
+    if (name[0] != '@') return false;
+
+    if (strings.indexOfChar(name, '/')) |slash| {
+        if (slash != 1 and slash != name.len - 1) {
+            return true;
+        }
+    }
+
+    return error.InvalidPackageName;
+}
+
+/// assumes version is valid
+pub fn withoutBuildTag(version: string) string {
+    if (strings.indexOfChar(version, '+')) |plus| return version[0..plus] else return version;
+}
+
 pub const Version = struct {
     tag: Tag = .uninitialized,
     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));
 
@@ -313,15 +334,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 => {
@@ -342,8 +356,7 @@ pub const Version = struct {
                 }
             },
             else => {
-                globalThis.throwTODO("Unsupported dependency type");
-                return .zero;
+                return globalThis.throwTODO("Unsupported dependency type");
             },
         }
 
@@ -409,6 +422,7 @@ pub const Version = struct {
             tag,
             sliced,
             ctx.log,
+            ctx.package_manager,
         ) orelse Dependency.Version.zeroed;
     }
 
@@ -744,8 +758,8 @@ pub const Version = struct {
             return .npm;
         }
 
-        pub fn inferFromJS(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
-            const arguments = callframe.arguments(1).slice();
+        pub fn inferFromJS(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+            const arguments = callframe.arguments_old(1).slice();
             if (arguments.len == 0 or !arguments[0].isString()) {
                 return .undefined;
             }
@@ -834,9 +848,10 @@ pub inline fn parse(
     dependency: string,
     sliced: *const SlicedString,
     log: ?*logger.Log,
+    manager: ?*PackageManager,
 ) ?Version {
     const dep = std.mem.trimLeft(u8, dependency, " \t\n\r");
-    return parseWithTag(allocator, alias, alias_hash, dep, Version.Tag.infer(dep), sliced, log);
+    return parseWithTag(allocator, alias, alias_hash, dep, Version.Tag.infer(dep), sliced, log, manager);
 }
 
 pub fn parseWithOptionalTag(
@@ -847,6 +862,7 @@ pub fn parseWithOptionalTag(
     tag: ?Dependency.Version.Tag,
     sliced: *const SlicedString,
     log: ?*logger.Log,
+    package_manager: ?*PackageManager,
 ) ?Version {
     const dep = std.mem.trimLeft(u8, dependency, " \t\n\r");
     return parseWithTag(
@@ -857,6 +873,7 @@ pub fn parseWithOptionalTag(
         tag orelse Version.Tag.infer(dep),
         sliced,
         log,
+        package_manager,
     );
 }
 
@@ -868,6 +885,7 @@ pub fn parseWithTag(
     tag: Dependency.Version.Tag,
     sliced: *const SlicedString,
     log_: ?*logger.Log,
+    package_manager: ?*PackageManager,
 ) ?Version {
     switch (tag) {
         .npm => {
@@ -927,11 +945,13 @@ pub fn parseWithTag(
             };
 
             if (is_alias) {
-                PackageManager.instance.known_npm_aliases.put(
-                    allocator,
-                    alias_hash.?,
-                    result,
-                ) catch unreachable;
+                if (package_manager) |pm| {
+                    pm.known_npm_aliases.put(
+                        allocator,
+                        alias_hash.?,
+                        result,
+                    ) catch unreachable;
+                }
             }
 
             return result;
@@ -1215,10 +1235,10 @@ pub fn parseWithTag(
     }
 }
 
-pub fn fromJS(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
-    const arguments = callframe.arguments(2).slice();
+pub fn fromJS(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+    const arguments = callframe.arguments_old(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();
@@ -1256,18 +1276,16 @@ pub fn fromJS(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JS
     var log = logger.Log.init(allocator);
     const sliced = SlicedString.init(buf, name);
 
-    const dep: Version = Dependency.parse(allocator, SlicedString.init(buf, alias).value(), null, buf, &sliced, &log) orelse {
+    const dep: Version = Dependency.parse(allocator, SlicedString.init(buf, alias).value(), null, buf, &sliced, &log, null) orelse {
         if (log.msgs.items.len > 0) {
-            globalThis.throwValue(log.toJS(globalThis, bun.default_allocator, "Failed to parse dependency"));
-            return .zero;
+            return globalThis.throwValue(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.throwValue(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 da159b0d56..8ca72a1fc8 100644
--- a/src/install/extract_tarball.zig
+++ b/src/install/extract_tarball.zig
@@ -200,7 +200,7 @@ fn extract(this: *const ExtractTarball, tgz_bytes: []const u8) !Install.ExtractD
 
         defer extract_destination.close();
 
-        const Archive = @import("../libarchive/libarchive.zig").Archive;
+        const Archiver = bun.libarchive.Archiver;
         const Zlib = @import("../zlib.zig");
         var zlib_pool = Npm.Registry.BodyPool.get(default_allocator);
         zlib_pool.data.reset();
@@ -278,7 +278,7 @@ fn extract(this: *const ExtractTarball, tgz_bytes: []const u8) !Install.ExtractD
                 var dirname_reader = DirnameReader{ .outdirname = &resolved };
 
                 switch (PackageManager.verbose_install) {
-                    inline else => |log| _ = try Archive.extractToDir(
+                    inline else => |log| _ = try Archiver.extractToDir(
                         zlib_pool.data.list.items,
                         extract_destination,
                         null,
@@ -304,7 +304,7 @@ fn extract(this: *const ExtractTarball, tgz_bytes: []const u8) !Install.ExtractD
                 }
             },
             else => switch (PackageManager.verbose_install) {
-                inline else => |log| _ = try Archive.extractToDir(
+                inline else => |log| _ = try Archiver.extractToDir(
                     zlib_pool.data.list.items,
                     extract_destination,
                     null,
@@ -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 e49e57fcfa..4103056abc 100644
--- a/src/install/install.zig
+++ b/src/install/install.zig
@@ -1,3 +1,11 @@
+// Default to a maximum of 64 simultaneous HTTP requests for bun install if no proxy is specified
+// if a proxy IS specified, default to 64. We have different values because we might change this in the future.
+// https://github.com/npm/cli/issues/7072
+// https://pnpm.io/npmrc#network-concurrency (pnpm defaults to 16)
+// https://yarnpkg.com/configuration/yarnrc#networkConcurrency (defaults to 50)
+const default_max_simultaneous_requests_for_bun_install = 64;
+const default_max_simultaneous_requests_for_bun_install_for_proxies = 64;
+
 const bun = @import("root").bun;
 const FeatureFlags = bun.FeatureFlags;
 const string = bun.string;
@@ -18,7 +26,7 @@ const JSLexer = bun.js_lexer;
 const logger = bun.logger;
 
 const js_parser = bun.js_parser;
-const json_parser = bun.JSON;
+const JSON = bun.JSON;
 const JSPrinter = bun.js_printer;
 
 const linker = @import("../linker.zig");
@@ -266,6 +274,11 @@ const NetworkTask = struct {
         this.package_manager.async_network_task_queue.push(this);
     }
 
+    pub const Authorization = enum {
+        no_authorization,
+        allow_authorization,
+    };
+
     // We must use a less restrictive Accept header value
     // https://github.com/oven-sh/bun/issues/341
     // https://www.jfrog.com/jira/browse/RTFACT-18398
@@ -437,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,
             },
         };
@@ -467,6 +480,7 @@ const NetworkTask = struct {
         allocator: std.mem.Allocator,
         tarball_: *const ExtractTarball,
         scope: *const Npm.Registry.Scope,
+        authorization: NetworkTask.Authorization,
     ) !void {
         this.callback = .{ .extract = tarball_.* };
         const tarball = &this.callback.extract;
@@ -496,14 +510,18 @@ const NetworkTask = struct {
         this.allocator = allocator;
 
         var header_builder = HeaderBuilder{};
-
-        countAuth(&header_builder, scope);
-
         var header_buf: string = "";
+
+        if (authorization == .allow_authorization) {
+            countAuth(&header_builder, scope);
+        }
+
         if (header_builder.header_count > 0) {
             try header_builder.allocate(allocator);
 
-            appendAuth(&header_builder, scope);
+            if (authorization == .allow_authorization) {
+                appendAuth(&header_builder, scope);
+            }
 
             header_buf = header_builder.content.ptr.?[0..header_builder.content.len];
         }
@@ -678,7 +696,7 @@ pub const Task = struct {
                     if (pt.callback.apply.logger.errors > 0) {
                         defer pt.callback.apply.logger.deinit();
                         // this.log.addErrorFmt(null, logger.Loc.Empty, bun.default_allocator, "failed to apply patch: {}", .{e}) catch unreachable;
-                        pt.callback.apply.logger.printForLogLevel(Output.writer()) catch {};
+                        pt.callback.apply.logger.print(Output.writer()) catch {};
                     }
                 }
             }
@@ -1144,6 +1162,7 @@ pub fn NewPackageInstall(comptime kind: PkgInstallKind) type {
                 switch (resolution.tag) {
                 .git => this.verifyGitResolution(&resolution.value.git, buf, root_node_modules_dir),
                 .github => this.verifyGitResolution(&resolution.value.github, buf, root_node_modules_dir),
+                .root => this.verifyTransitiveSymlinkedFolder(root_node_modules_dir),
                 .folder => if (this.lockfile.isWorkspaceTreeId(this.node_modules.tree_id))
                     this.verifyPackageJSONNameAndVersion(root_node_modules_dir, resolution.tag)
                 else
@@ -1236,7 +1255,7 @@ pub fn NewPackageInstall(comptime kind: PkgInstallKind) type {
 
             initializeStore();
 
-            var package_json_checker = json_parser.PackageJSONVersionChecker.init(allocator, &source, &log) catch return false;
+            var package_json_checker = JSON.PackageJSONVersionChecker.init(allocator, &source, &log) catch return false;
             _ = package_json_checker.parseExpr() catch return false;
             if (log.errors > 0 or !package_json_checker.has_found_name) return false;
             // workspaces aren't required to have a version
@@ -1736,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;
             }
@@ -2123,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();
@@ -2164,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)) {
@@ -2191,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,
                 }
             }
         }
@@ -2322,13 +2339,29 @@ pub fn NewPackageInstall(comptime kind: PkgInstallKind) type {
                 supported_method;
         }
 
-        pub fn packageMissingFromCache(this: *@This(), manager: *PackageManager, package_id: PackageID) bool {
+        pub fn packageMissingFromCache(this: *@This(), manager: *PackageManager, package_id: PackageID, resolution_tag: Resolution.Tag) bool {
             const state = manager.getPreinstallState(package_id);
             return switch (state) {
                 .done => false,
                 else => brk: {
                     if (this.patch.isNull()) {
-                        const exists = Syscall.directoryExistsAt(this.cache_dir.fd, this.cache_dir_subpath).unwrap() catch false;
+                        const exists = switch (resolution_tag) {
+                            .npm => package_json_exists: {
+                                var buf = &PackageManager.cached_package_folder_name_buf;
+
+                                if (comptime Environment.isDebug) {
+                                    bun.assertWithLocation(bun.isSliceInBuffer(this.cache_dir_subpath, buf), @src());
+                                }
+
+                                const subpath_len = strings.withoutTrailingSlash(this.cache_dir_subpath).len;
+                                buf[subpath_len] = std.fs.path.sep;
+                                defer buf[subpath_len] = 0;
+                                @memcpy(buf[subpath_len + 1 ..][0.."package.json\x00".len], "package.json\x00");
+                                const subpath = buf[0 .. subpath_len + 1 + "package.json".len :0];
+                                break :package_json_exists Syscall.existsAt(bun.toFD(this.cache_dir.fd), subpath);
+                            },
+                            else => Syscall.directoryExistsAt(this.cache_dir.fd, this.cache_dir_subpath).unwrap() catch false,
+                        };
                         if (exists) manager.setPreinstallState(package_id, manager.lockfile, .done);
                         break :brk !exists;
                     }
@@ -2358,13 +2391,8 @@ pub fn NewPackageInstall(comptime kind: PkgInstallKind) type {
         }
 
         pub fn install(this: *@This(), skip_delete: bool, destination_dir: std.fs.Dir, resolution_tag: Resolution.Tag) Result {
-            // If this fails, we don't care.
-            // we'll catch it the next error
-            if (!skip_delete and !strings.eqlComptime(this.destination_dir_subpath, ".")) this.uninstallBeforeInstall(destination_dir);
-
-            if (comptime kind == .regular) return this.installImpl(skip_delete, destination_dir, this.getInstallMethod(), resolution_tag);
-
             const result = this.installImpl(skip_delete, destination_dir, this.getInstallMethod(), resolution_tag);
+            if (comptime kind == .regular) return result;
             if (result == .fail) return result;
             const fd = bun.toFD(destination_dir.fd);
             const subpath = bun.path.joinZ(&[_][]const u8{ this.destination_dir_subpath, ".bun-patch-tag" });
@@ -2377,36 +2405,10 @@ pub fn NewPackageInstall(comptime kind: PkgInstallKind) type {
             if (bun.sys.File.writeAll(.{ .handle = tag_fd }, this.package_version).asErr()) |e| return .{ .fail = .{ .err = bun.errnoToZigErr(e.getErrno()), .step = Step.patching } };
         }
 
-        pub fn installWithMethod(this: *@This(), skip_delete: bool, destination_dir: std.fs.Dir, method: Method, resolution_tag: Resolution.Tag) Result {
-            // If this fails, we don't care.
-            // we'll catch it the next error
-            if (!skip_delete and !strings.eqlComptime(this.destination_dir_subpath, ".")) this.uninstallBeforeInstall(destination_dir);
-
-            if (comptime kind == .regular) return this.installImpl(skip_delete, destination_dir, method, resolution_tag);
-
-            const result = this.installImpl(skip_delete, destination_dir, method, resolution_tag);
-            if (result == .fail) return result;
-            const fd = bun.toFD(destination_dir.fd);
-            const subpath = bun.path.joinZ(&[_][]const u8{ this.destination_dir_subpath, ".bun-patch-tag" }, .auto);
-            const tag_fd = switch (bun.sys.openat(fd, subpath, bun.O.CREAT | bun.O.WRONLY | bun.O.TRUNC, 0o666)) {
-                .err => |e| return .{ .fail = .{ .err = bun.errnoToZigErr(e.getErrno()), .step = Step.patching } },
-                .result => |f| f,
-            };
-            defer _ = bun.sys.close(tag_fd);
-            if (bun.sys.File.writeAll(.{ .handle = tag_fd }, this.package_version).asErr()) |e| return .{ .fail = .{ .err = bun.errnoToZigErr(e.getErrno()), .step = Step.patching } };
-            return result;
-        }
-
         pub fn installImpl(this: *@This(), skip_delete: bool, destination_dir: std.fs.Dir, method_: Method, resolution_tag: Resolution.Tag) Result {
             // If this fails, we don't care.
             // we'll catch it the next error
             if (!skip_delete and !strings.eqlComptime(this.destination_dir_subpath, ".")) this.uninstallBeforeInstall(destination_dir);
-            defer {
-                if (kind == .patch) {
-                    const fd = bun.toFD(destination_dir.fd);
-                    _ = fd; // autofix
-                }
-            }
 
             var supported_method_to_use = method_;
 
@@ -2507,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;
@@ -2527,28 +2529,47 @@ const PackageManifestMap = struct {
     };
     const HashMap = std.HashMapUnmanaged(PackageNameHash, Value, IdentityContext(PackageNameHash), 80);
 
-    pub fn byName(this: *PackageManifestMap, scope: *const Npm.Registry.Scope, name: []const u8) ?*Npm.PackageManifest {
-        return this.byNameHash(scope, String.Builder.stringHash(name));
+    pub fn byName(this: *PackageManifestMap, pm: *PackageManager, scope: *const Npm.Registry.Scope, name: []const u8, cache_behavior: CacheBehavior) ?*Npm.PackageManifest {
+        return this.byNameHash(pm, scope, String.Builder.stringHash(name), cache_behavior);
     }
 
     pub fn insert(this: *PackageManifestMap, name_hash: PackageNameHash, manifest: *const Npm.PackageManifest) !void {
         try this.hash_map.put(bun.default_allocator, name_hash, .{ .manifest = manifest.* });
     }
 
-    pub fn byNameHash(this: *PackageManifestMap, scope: *const Npm.Registry.Scope, name_hash: PackageNameHash) ?*Npm.PackageManifest {
-        return byNameHashAllowExpired(this, scope, name_hash, null);
+    pub fn byNameHash(this: *PackageManifestMap, pm: *PackageManager, scope: *const Npm.Registry.Scope, name_hash: PackageNameHash, cache_behavior: CacheBehavior) ?*Npm.PackageManifest {
+        return byNameHashAllowExpired(this, pm, scope, name_hash, null, cache_behavior);
     }
 
-    pub fn byNameAllowExpired(this: *PackageManifestMap, scope: *const Npm.Registry.Scope, name: string, is_expired: ?*bool) ?*Npm.PackageManifest {
-        return byNameHashAllowExpired(this, scope, String.Builder.stringHash(name), is_expired);
+    pub fn byNameAllowExpired(this: *PackageManifestMap, pm: *PackageManager, scope: *const Npm.Registry.Scope, name: string, is_expired: ?*bool, cache_behavior: CacheBehavior) ?*Npm.PackageManifest {
+        return byNameHashAllowExpired(this, pm, scope, String.Builder.stringHash(name), is_expired, cache_behavior);
     }
 
+    pub const CacheBehavior = enum {
+        load_from_memory,
+        load_from_memory_fallback_to_disk,
+    };
+
     pub fn byNameHashAllowExpired(
         this: *PackageManifestMap,
+        pm: *PackageManager,
         scope: *const Npm.Registry.Scope,
         name_hash: PackageNameHash,
         is_expired: ?*bool,
+        cache_behavior: CacheBehavior,
     ) ?*Npm.PackageManifest {
+        if (cache_behavior == .load_from_memory) {
+            const entry = this.hash_map.getPtr(name_hash) orelse return null;
+            return switch (entry.*) {
+                .manifest => &entry.manifest,
+                .expired => if (is_expired) |expiry| {
+                    expiry.* = true;
+                    return &entry.expired;
+                } else null,
+                .not_found => null,
+            };
+        }
+
         const entry = this.hash_map.getOrPut(bun.default_allocator, name_hash) catch bun.outOfMemory();
         if (entry.found_existing) {
             if (entry.value_ptr.* == .manifest) {
@@ -2565,14 +2586,14 @@ const PackageManifestMap = struct {
             return null;
         }
 
-        if (PackageManager.instance.options.enable.manifest_cache) {
+        if (pm.options.enable.manifest_cache) {
             if (Npm.PackageManifest.Serializer.loadByFileID(
-                PackageManager.instance.allocator,
+                pm.allocator,
                 scope,
-                PackageManager.instance.getCacheDirectory(),
+                pm.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 (pm.options.enable.manifest_cache_control and manifest.pkg.public_max_age > pm.timestamp_for_manifest_cache_control) {
                     entry.value_ptr.* = .{ .manifest = manifest };
                     return &entry.value_ptr.manifest;
                 } else {
@@ -2750,7 +2771,7 @@ pub const PackageManager = struct {
 
     pub fn crash(this: *PackageManager) noreturn {
         if (this.options.log_level != .silent) {
-            this.log.printForLogLevel(Output.errorWriter()) catch {};
+            this.log.print(Output.errorWriter()) catch {};
         }
         Global.crash();
     }
@@ -2776,7 +2797,6 @@ pub const PackageManager = struct {
 
         pub const GetJSONOptions = struct {
             init_reset_store: bool = true,
-            always_decode_escape_sequences: bool = true,
             guess_indentation: bool = false,
         };
 
@@ -2828,7 +2848,7 @@ pub const PackageManager = struct {
             if (comptime opts.init_reset_store)
                 initializeStore();
 
-            const json = json_parser.ParsePackageJSONUTF8WithOpts(
+            const json = JSON.parsePackageJSONUTF8WithOpts(
                 &source,
                 log,
                 allocator,
@@ -2836,7 +2856,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| {
@@ -2882,7 +2901,7 @@ pub const PackageManager = struct {
             if (comptime opts.init_reset_store)
                 initializeStore();
 
-            const json_result = json_parser.ParsePackageJSONUTF8WithOpts(
+            const json_result = JSON.parsePackageJSONUTF8WithOpts(
                 &source,
                 log,
                 allocator,
@@ -2890,7 +2909,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,
                 },
             );
@@ -2974,7 +2992,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;
@@ -3140,7 +3158,7 @@ pub const PackageManager = struct {
 
             builder.allocate() catch |err| return .{ .failure = err };
 
-            const dep = dummy.cloneWithDifferentBuffers(name, version_buf, @TypeOf(&builder), &builder) catch unreachable;
+            const dep = dummy.cloneWithDifferentBuffers(this, name, version_buf, @TypeOf(&builder), &builder) catch unreachable;
             builder.clamp();
             const index = this.lockfile.buffers.dependencies.items.len;
             this.lockfile.buffers.dependencies.append(this.allocator, dep) catch unreachable;
@@ -3175,7 +3193,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,
@@ -3194,7 +3212,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", .{closure.manager.pendingTaskCount()});
                                             }
                                         }
 
@@ -3271,14 +3289,14 @@ pub const PackageManager = struct {
                     // TODO:
                     return null;
 
-                // We skip this in CI because we don't want any performance impact in an environment you'll probably never use
-                // and it makes tests more consistent
-                if (this.isContinuousIntegration())
-                    return null;
+                const manifest = this.manifests.byNameHash(
+                    this,
+                    this.scopeForPackageName(package_name),
+                    name_hash,
+                    .load_from_memory,
+                ) orelse return null;
 
-                const manifest = this.manifests.byNameHash(this.scopeForPackageName(package_name), name_hash) orelse return null;
-
-                if (manifest.findByDistTag("latest")) |latest_version| {
+                if (manifest.findByDistTag("latest")) |*latest_version| {
                     if (latest_version.version.order(
                         resolution.value.npm.version,
                         manifest.string_buf,
@@ -3655,7 +3673,17 @@ 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();
@@ -3913,13 +3941,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;
         };
     }
@@ -4201,10 +4237,13 @@ pub const PackageManager = struct {
             };
         } else if (behavior.isPeer() and !install_peer) {
             return null;
+        } else if (behavior.isOptional() and !this.options.remote_package_features.optional_dependencies) {
+            return null;
         }
 
         // appendPackage sets the PackageID on the package
         const package = try this.lockfile.appendPackage(try Lockfile.Package.fromNPM(
+            this,
             this.allocator,
             this.lockfile,
             this.log,
@@ -4246,6 +4285,8 @@ pub const PackageManager = struct {
                         dependency_id,
                         package,
                         name_and_version_hash,
+                        // its npm.
+                        .allow_authorization,
                     ) orelse unreachable,
                 },
             },
@@ -4303,8 +4344,8 @@ pub const PackageManager = struct {
         is_required: bool,
         dependency_id: DependencyID,
         package: Lockfile.Package,
-        /// if patched then we need to do apply step after network task is done
         patch_name_and_version_hash: ?u64,
+        authorization: NetworkTask.Authorization,
     ) !?*NetworkTask {
         if (this.hasCreatedNetworkTask(task_id, is_required)) {
             return null;
@@ -4330,11 +4371,11 @@ pub const PackageManager = struct {
         try network_task.forTarball(
             this.allocator,
             &.{
-                .package_manager = &PackageManager.instance, // https://github.com/ziglang/zig/issues/14005
+                .package_manager = this,
                 .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(),
@@ -4344,10 +4385,11 @@ pub const PackageManager = struct {
                 .url = try strings.StringOrTinyString.initAppendIfNeeded(
                     url,
                     *FileSystem.FilenameStore,
-                    &FileSystem.FilenameStore.instance,
+                    FileSystem.FilenameStore.instance,
                 ),
             },
             scope,
+            authorization,
         );
 
         return network_task;
@@ -4561,7 +4603,12 @@ pub const PackageManager = struct {
 
                 // Resolve the version from the loaded NPM manifest
                 const name_str = this.lockfile.str(&name);
-                const manifest = this.manifests.byNameHash(this.scopeForPackageName(name_str), name_hash) orelse return null; // manifest might still be downloading. This feels unreliable.
+                const manifest = this.manifests.byNameHash(
+                    this,
+                    this.scopeForPackageName(name_str),
+                    name_hash,
+                    .load_from_memory_fallback_to_disk,
+                ) orelse return null; // manifest might still be downloading. This feels unreliable.
                 const find_result: Npm.PackageManifest.FindResult = switch (version.tag) {
                     .dist_tag => manifest.findByDistTag(this.lockfile.str(&version.value.dist_tag.tag)),
                     .npm => manifest.findBestVersion(version.value.npm.version, this.lockfile.buffers.string_bytes.items),
@@ -4742,7 +4789,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 = this,
             .log = logger.Log.init(this.allocator),
             .tag = Task.Tag.package_manifest,
             .request = .{
@@ -4764,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 = this,
             .log = logger.Log.init(this.allocator),
             .tag = Task.Tag.extract,
             .request = .{
@@ -4791,7 +4838,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 = this,
             .log = logger.Log.init(this.allocator),
             .tag = Task.Tag.git_clone,
             .request = .{
@@ -4799,12 +4846,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),
                 },
@@ -4839,7 +4886,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 = this,
             .log = logger.Log.init(this.allocator),
             .tag = Task.Tag.git_checkout,
             .request = .{
@@ -4850,17 +4897,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),
                 },
@@ -4892,17 +4939,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 = this,
             .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 = this,
                         .name = strings.StringOrTinyString.initAppendIfNeeded(
                             name,
                             *FileSystem.FilenameStore,
-                            &FileSystem.FilenameStore.instance,
+                            FileSystem.FilenameStore.instance,
                         ) catch unreachable,
                         .resolution = resolution,
                         .cache_dir = this.getCacheDirectory(),
@@ -4911,7 +4958,7 @@ pub const PackageManager = struct {
                         .url = strings.StringOrTinyString.initAppendIfNeeded(
                             path,
                             *FileSystem.FilenameStore,
-                            &FileSystem.FilenameStore.instance,
+                            FileSystem.FilenameStore.instance,
                         ) catch unreachable,
                     },
                 },
@@ -4941,7 +4988,6 @@ pub const PackageManager = struct {
         var printer = Lockfile.Printer{
             .lockfile = this.lockfile,
             .options = this.options,
-            .manager = this,
         };
 
         var tmpname_buf: [512]u8 = undefined;
@@ -5230,7 +5276,13 @@ pub const PackageManager = struct {
                                 if (!this.hasCreatedNetworkTask(task_id, dependency.behavior.isRequired())) {
                                     if (this.options.enable.manifest_cache) {
                                         var expired = false;
-                                        if (this.manifests.byNameHashAllowExpired(this.scopeForPackageName(name_str), name_hash, &expired)) |manifest| {
+                                        if (this.manifests.byNameHashAllowExpired(
+                                            this,
+                                            this.scopeForPackageName(name_str),
+                                            name_hash,
+                                            &expired,
+                                            .load_from_memory_fallback_to_disk,
+                                        )) |manifest| {
                                             loaded_manifest = manifest.*;
 
                                             // If it's an exact package version already living in the cache
@@ -5270,7 +5322,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 = this,
                                         .callback = undefined,
                                         .task_id = task_id,
                                         .allocator = this.allocator,
@@ -5455,6 +5507,7 @@ pub const PackageManager = struct {
                         .resolution = res,
                     },
                     null,
+                    .no_authorization,
                 )) |network_task| {
                     this.enqueueNetworkTask(network_task);
                 }
@@ -5656,6 +5709,7 @@ pub const PackageManager = struct {
                                 .resolution = res,
                             },
                             null,
+                            .no_authorization,
                         )) |network_task| {
                             this.enqueueNetworkTask(network_task);
                         }
@@ -5960,6 +6014,7 @@ pub const PackageManager = struct {
 
                         pkg.parse(
                             manager.lockfile,
+                            manager,
                             manager.allocator,
                             manager.log,
                             package_json_source,
@@ -6038,6 +6093,7 @@ pub const PackageManager = struct {
 
                 package.parse(
                     manager.lockfile,
+                    manager,
                     manager.allocator,
                     manager.log,
                     package_json_source,
@@ -6087,7 +6143,7 @@ pub const PackageManager = struct {
                     json.buf,
                 );
                 initializeStore();
-                const json_root = json_parser.ParsePackageJSONUTF8(
+                const json_root = JSON.parsePackageJSONUTF8(
                     &package_json_source,
                     manager.log,
                     manager.allocator,
@@ -6152,6 +6208,24 @@ pub const PackageManager = struct {
 
         var timestamp_this_tick: ?u32 = null;
 
+        defer {
+            manager.drainDependencyList();
+
+            if (comptime log_level.showProgress()) {
+                manager.startProgressBarIfNone();
+
+                if (@hasField(@TypeOf(callbacks), "progress_bar") and callbacks.progress_bar == true) {
+                    const completed_items = manager.total_tasks - manager.pendingTaskCount();
+                    if (completed_items != manager.downloads_node.?.unprotected_completed_items or has_updated_this_run) {
+                        manager.downloads_node.?.setCompletedItems(completed_items);
+                        manager.downloads_node.?.setEstimatedTotalItems(manager.total_tasks);
+                    }
+                }
+                manager.downloads_node.?.activate();
+                manager.progress.maybeRefresh();
+            }
+        }
+
         var patch_tasks_batch = manager.patch_task_queue.popBatch();
         var patch_tasks_iter = patch_tasks_batch.iterator();
         while (patch_tasks_iter.next()) |ptask| {
@@ -6569,11 +6643,7 @@ pub const PackageManager = struct {
             _ = manager.decrementPendingTasks();
 
             if (task.log.msgs.items.len > 0) {
-                switch (Output.enable_ansi_colors) {
-                    inline else => |enable_ansi_colors| {
-                        try task.log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), enable_ansi_colors);
-                    },
-                }
+                try task.log.print(Output.errorWriter());
             }
 
             switch (task.tag) {
@@ -6879,20 +6949,6 @@ pub const PackageManager = struct {
                 },
             }
         }
-
-        manager.drainDependencyList();
-
-        if (comptime log_level.showProgress()) {
-            if (@hasField(@TypeOf(callbacks), "progress_bar") and callbacks.progress_bar == true) {
-                const completed_items = manager.total_tasks - manager.pendingTaskCount();
-                if (completed_items != manager.downloads_node.?.unprotected_completed_items or has_updated_this_run) {
-                    manager.downloads_node.?.setCompletedItems(completed_items);
-                    manager.downloads_node.?.setEstimatedTotalItems(manager.total_tasks);
-                }
-            }
-            manager.downloads_node.?.activate();
-            manager.progress.maybeRefresh();
-        }
     }
 
     pub const Options = struct {
@@ -6941,6 +6997,40 @@ pub const PackageManager = struct {
 
         max_concurrent_lifecycle_scripts: usize,
 
+        publish_config: PublishConfig = .{},
+
+        ca: []const string = &.{},
+        ca_file_name: string = &.{},
+
+        pub const PublishConfig = struct {
+            access: ?Access = null,
+            tag: string = "",
+            otp: string = "",
+            auth_type: ?AuthType = null,
+        };
+
+        pub const Access = enum {
+            public,
+            restricted,
+
+            const map = bun.ComptimeEnumMap(Access);
+
+            pub fn fromStr(str: string) ?Access {
+                return map.get(str);
+            }
+        };
+
+        pub const AuthType = enum {
+            legacy,
+            web,
+
+            const map = bun.ComptimeEnumMap(AuthType);
+
+            pub fn fromStr(str: string) ?AuthType {
+                return map.get(str);
+            }
+        };
+
         pub fn shouldPrintCommandName(this: *const Options) bool {
             return this.log_level != .silent and this.do.summary;
         }
@@ -7046,18 +7136,18 @@ pub const PackageManager = struct {
             allocator: std.mem.Allocator,
             log: *logger.Log,
             env: *DotEnv.Loader,
-            cli_: ?CommandLineArguments,
+            maybe_cli: ?CommandLineArguments,
             bun_install_: ?*Api.BunInstall,
             subcommand: Subcommand,
-        ) !void {
+        ) bun.OOM!void {
             var base = Api.NpmRegistry{
                 .url = "",
                 .username = "",
                 .password = "",
                 .token = "",
             };
-            if (bun_install_) |bun_install| {
-                if (bun_install.default_registry) |registry| {
+            if (bun_install_) |config| {
+                if (config.default_registry) |registry| {
                     base = registry;
                 }
             }
@@ -7066,8 +7156,8 @@ pub const PackageManager = struct {
             defer {
                 this.did_override_default_scope = this.scope.url_hash != Npm.Registry.default_url_hash;
             }
-            if (bun_install_) |bun_install| {
-                if (bun_install.scoped) |scoped| {
+            if (bun_install_) |config| {
+                if (config.scoped) |scoped| {
                     for (scoped.scopes.keys(), scoped.scopes.values()) |name, *registry_| {
                         var registry = registry_.*;
                         if (registry.url.len == 0) registry.url = base.url;
@@ -7075,42 +7165,57 @@ pub const PackageManager = struct {
                     }
                 }
 
-                if (bun_install.disable_cache orelse false) {
+                if (config.ca) |ca| {
+                    switch (ca) {
+                        .list => |ca_list| {
+                            this.ca = ca_list;
+                        },
+                        .str => |ca_str| {
+                            this.ca = &.{ca_str};
+                        },
+                    }
+                }
+
+                if (config.cafile) |cafile| {
+                    this.ca_file_name = cafile;
+                }
+
+                if (config.disable_cache orelse false) {
                     this.enable.cache = false;
                 }
 
-                if (bun_install.disable_manifest_cache orelse false) {
+                if (config.disable_manifest_cache orelse false) {
                     this.enable.manifest_cache = false;
                 }
 
-                if (bun_install.force orelse false) {
+                if (config.force orelse false) {
                     this.enable.manifest_cache_control = false;
                     this.enable.force_install = true;
                 }
 
-                if (bun_install.save_yarn_lockfile orelse false) {
+                if (config.save_yarn_lockfile orelse false) {
                     this.do.save_yarn_lock = true;
                 }
 
-                if (bun_install.save_lockfile) |save_lockfile| {
+                if (config.save_lockfile) |save_lockfile| {
                     this.do.save_lockfile = save_lockfile;
                     this.enable.force_save_lockfile = true;
                 }
 
-                if (bun_install.save_dev) |save| {
+                if (config.save_dev) |save| {
                     this.local_package_features.dev_dependencies = save;
                 }
 
-                if (bun_install.save_peer) |save| {
+                if (config.save_peer) |save| {
                     this.do.install_peer_dependencies = save;
                     this.remote_package_features.peer_dependencies = save;
                 }
 
-                if (bun_install.exact) |exact| {
+                if (config.exact) |exact| {
                     this.enable.exact_versions = exact;
                 }
 
-                if (bun_install.production) |production| {
+                if (config.production) |production| {
                     if (production) {
                         this.local_package_features.dev_dependencies = false;
                         this.enable.fail_early = true;
@@ -7119,22 +7224,22 @@ pub const PackageManager = struct {
                     }
                 }
 
-                if (bun_install.frozen_lockfile) |frozen_lockfile| {
+                if (config.frozen_lockfile) |frozen_lockfile| {
                     if (frozen_lockfile) {
                         this.enable.frozen_lockfile = true;
                     }
                 }
 
-                if (bun_install.concurrent_scripts) |jobs| {
+                if (config.concurrent_scripts) |jobs| {
                     this.max_concurrent_lifecycle_scripts = jobs;
                 }
 
-                if (bun_install.save_optional) |save| {
+                if (config.save_optional) |save| {
                     this.remote_package_features.optional_dependencies = save;
                     this.local_package_features.optional_dependencies = save;
                 }
 
-                this.explicit_global_directory = bun_install.global_dir orelse this.explicit_global_directory;
+                this.explicit_global_directory = config.global_dir orelse this.explicit_global_directory;
             }
 
             const default_disable_progress_bar: bool = brk: {
@@ -7181,7 +7286,7 @@ pub const PackageManager = struct {
             {
                 const token_keys = [_]string{
                     "BUN_CONFIG_TOKEN",
-                    "NPM_CONFIG_token",
+                    "NPM_CONFIG_TOKEN",
                     "npm_config_token",
                 };
                 var did_set = false;
@@ -7200,20 +7305,6 @@ pub const PackageManager = struct {
                 }
             }
 
-            if (cli_) |cli| {
-                if (cli.registry.len > 0) {
-                    this.scope.url = URL.parse(cli.registry);
-                }
-
-                if (cli.exact) {
-                    this.enable.exact_versions = true;
-                }
-
-                if (cli.token.len > 0) {
-                    this.scope.token = cli.token;
-                }
-            }
-
             if (env.get("BUN_CONFIG_YARN_LOCKFILE") != null) {
                 this.do.save_yarn_lock = true;
             }
@@ -7246,7 +7337,19 @@ pub const PackageManager = struct {
                 this.enable.manifest_cache_control = false;
             }
 
-            if (cli_) |cli| {
+            if (maybe_cli) |cli| {
+                if (cli.registry.len > 0) {
+                    this.scope.url = URL.parse(cli.registry);
+                }
+
+                if (cli.exact) {
+                    this.enable.exact_versions = true;
+                }
+
+                if (cli.token.len > 0) {
+                    this.scope.token = cli.token;
+                }
+
                 if (cli.no_save) {
                     this.do.save_lockfile = false;
                     this.do.write_package_json = false;
@@ -7350,6 +7453,26 @@ pub const PackageManager = struct {
                         };
                     },
                 }
+
+                if (cli.publish_config.access) |cli_access| {
+                    this.publish_config.access = cli_access;
+                }
+                if (cli.publish_config.tag.len > 0) {
+                    this.publish_config.tag = cli.publish_config.tag;
+                }
+                if (cli.publish_config.otp.len > 0) {
+                    this.publish_config.otp = cli.publish_config.otp;
+                }
+                if (cli.publish_config.auth_type) |auth_type| {
+                    this.publish_config.auth_type = auth_type;
+                }
+
+                if (cli.ca.len > 0) {
+                    this.ca = cli.ca;
+                }
+                if (cli.ca_file_name.len > 0) {
+                    this.ca_file_name = cli.ca_file_name;
+                }
             } else {
                 this.log_level = if (default_disable_progress_bar) LogLevel.default_no_progress else LogLevel.default;
                 PackageManager.verbose_install = false;
@@ -7664,7 +7787,7 @@ pub const PackageManager = struct {
                                 const value = dep.value orelse continue;
                                 if (value.data != .e_string) continue;
 
-                                const version_literal = value.asStringCloned(allocator) orelse bun.outOfMemory();
+                                const version_literal = try value.asStringCloned(allocator) orelse bun.outOfMemory();
                                 var tag = Dependency.Version.Tag.infer(version_literal);
 
                                 // only updating dependencies with npm versions, and dist-tags if `--latest`.
@@ -7681,7 +7804,7 @@ pub const PackageManager = struct {
                                     }
                                 }
 
-                                const key_str = key.asStringCloned(allocator) orelse unreachable;
+                                const key_str = try key.asStringCloned(allocator) orelse unreachable;
                                 const entry = manager.updating_packages.getOrPut(allocator, key_str) catch bun.outOfMemory();
 
                                 // If a dependency is present in more than one dependency group, only one of it's versions
@@ -7861,11 +7984,11 @@ pub const PackageManager = struct {
 
                                 if (query.expr.asProperty(name)) |value| {
                                     if (value.expr.data == .e_string) {
-                                        if (!request.resolved_name.isEmpty() and strings.eqlLong(list, dependency_list, true)) {
+                                        if (request.package_id != invalid_package_id and strings.eqlLong(list, dependency_list, true)) {
                                             replacing += 1;
                                         } else {
                                             if (manager.subcommand == .update and options.before_install) add_packages_to_update: {
-                                                const version_literal = value.expr.asStringCloned(allocator) orelse break :add_packages_to_update;
+                                                const version_literal = try value.expr.asStringCloned(allocator) orelse break :add_packages_to_update;
                                                 var tag = Dependency.Version.Tag.infer(version_literal);
 
                                                 if (tag != .npm and tag != .dist_tag) break :add_packages_to_update;
@@ -7979,9 +8102,9 @@ pub const PackageManager = struct {
                     var k: usize = 0;
                     while (k < new_dependencies.len) : (k += 1) {
                         if (new_dependencies[k].key) |key| {
-                            if (!request.is_aliased and !request.resolved_name.isEmpty() and key.data.e_string.eql(
+                            if (!request.is_aliased and request.package_id != invalid_package_id and key.data.e_string.eql(
                                 string,
-                                request.resolved_name.slice(request.version_buf),
+                                manager.lockfile.packages.items(.name)[request.package_id].slice(request.version_buf),
                             )) {
                                 // This actually is a duplicate which we did not
                                 // pick up before dependency resolution.
@@ -8001,7 +8124,7 @@ pub const PackageManager = struct {
                                 else
                                     request.version.literal.slice(request.version_buf),
                             )) {
-                                if (request.resolved_name.isEmpty()) {
+                                if (request.package_id == invalid_package_id) {
                                     // This actually is a duplicate like "react"
                                     // appearing in both "dependencies" and "optionalDependencies".
                                     // For this case, we'll just swap remove it
@@ -8019,14 +8142,12 @@ pub const PackageManager = struct {
                         }
 
                         if (new_dependencies[k].key == null) {
-                            new_dependencies[k].key = JSAst.Expr.allocate(allocator, JSAst.E.String, .{
-                                .data = try allocator.dupe(u8, if (request.is_aliased)
-                                    request.name
-                                else if (request.resolved_name.isEmpty())
-                                    request.version.literal.slice(request.version_buf)
-                                else
-                                    request.resolved_name.slice(request.version_buf)),
-                            }, logger.Loc.Empty);
+                            new_dependencies[k].key = JSAst.Expr.allocate(
+                                allocator,
+                                JSAst.E.String,
+                                .{ .data = try allocator.dupe(u8, request.getResolvedName(manager.lockfile)) },
+                                logger.Loc.Empty,
+                            );
 
                             new_dependencies[k].value = JSAst.Expr.allocate(allocator, JSAst.E.String, .{
                                 // we set it later
@@ -8140,16 +8261,35 @@ pub const PackageManager = struct {
                 }
             }
 
+            const resolutions = if (!options.before_install) manager.lockfile.packages.items(.resolution) else &.{};
             for (updates) |*request| {
                 if (request.e_string) |e_string| {
-                    e_string.data = switch (request.resolution.tag) {
-                        .npm => brk: {
+                    if (request.package_id >= resolutions.len or resolutions[request.package_id].tag == .uninitialized) {
+                        e_string.data = uninitialized: {
+                            if (manager.subcommand == .update and manager.options.do.update_to_latest) {
+                                break :uninitialized try allocator.dupe(u8, "latest");
+                            }
+
+                            if (manager.subcommand != .update or !options.before_install or e_string.isBlank() or request.version.tag == .npm) {
+                                break :uninitialized switch (request.version.tag) {
+                                    .uninitialized => try allocator.dupe(u8, "latest"),
+                                    else => try allocator.dupe(u8, request.version.literal.slice(request.version_buf)),
+                                };
+                            } else {
+                                break :uninitialized e_string.data;
+                            }
+                        };
+
+                        continue;
+                    }
+                    e_string.data = switch (resolutions[request.package_id].tag) {
+                        .npm => npm: {
                             if (manager.subcommand == .update and (request.version.tag == .dist_tag or request.version.tag == .npm)) {
                                 if (manager.updating_packages.fetchSwapRemove(request.name)) |entry| {
                                     var alias_at_index: ?usize = null;
 
                                     const new_version = new_version: {
-                                        const version_fmt = request.resolution.value.npm.version.fmt(manager.lockfile.buffers.string_bytes.items);
+                                        const version_fmt = resolutions[request.package_id].value.npm.version.fmt(manager.lockfile.buffers.string_bytes.items);
                                         if (options.exact_versions) {
                                             break :new_version try std.fmt.allocPrint(allocator, "{}", .{version_fmt});
                                         }
@@ -8176,14 +8316,14 @@ pub const PackageManager = struct {
                                         const dep_literal = entry.value.original_version_literal;
 
                                         if (strings.lastIndexOfChar(dep_literal, '@')) |at_index| {
-                                            break :brk try std.fmt.allocPrint(allocator, "{s}@{s}", .{
+                                            break :npm try std.fmt.allocPrint(allocator, "{s}@{s}", .{
                                                 dep_literal[0..at_index],
                                                 new_version,
                                             });
                                         }
                                     }
 
-                                    break :brk new_version;
+                                    break :npm new_version;
                                 }
                             }
                             if (request.version.tag == .dist_tag or
@@ -8194,7 +8334,7 @@ pub const PackageManager = struct {
                                         allocator,
                                         if (comptime exact_versions) "{}" else "^{}",
                                         .{
-                                            request.resolution.value.npm.version.fmt(request.version_buf),
+                                            resolutions[request.package_id].value.npm.version.fmt(request.version_buf),
                                         },
                                     ),
                                 };
@@ -8202,31 +8342,17 @@ pub const PackageManager = struct {
                                 if (request.version.tag == .npm and request.version.value.npm.is_alias) {
                                     const dep_literal = request.version.literal.slice(request.version_buf);
                                     if (strings.indexOfChar(dep_literal, '@')) |at_index| {
-                                        break :brk try std.fmt.allocPrint(allocator, "{s}@{s}", .{
+                                        break :npm try std.fmt.allocPrint(allocator, "{s}@{s}", .{
                                             dep_literal[0..at_index],
                                             new_version,
                                         });
                                     }
                                 }
 
-                                break :brk new_version;
+                                break :npm new_version;
                             }
 
-                            break :brk try allocator.dupe(u8, request.version.literal.slice(request.version_buf));
-                        },
-                        .uninitialized => brk: {
-                            if (manager.subcommand == .update and manager.options.do.update_to_latest) {
-                                break :brk try allocator.dupe(u8, "latest");
-                            }
-
-                            if (manager.subcommand != .update or !options.before_install or e_string.isBlank() or request.version.tag == .npm) {
-                                break :brk switch (request.version.tag) {
-                                    .uninitialized => try allocator.dupe(u8, "latest"),
-                                    else => try allocator.dupe(u8, request.version.literal.slice(request.version_buf)),
-                                };
-                            } else {
-                                break :brk e_string.data;
-                            }
+                            break :npm try allocator.dupe(u8, request.version.literal.slice(request.version_buf));
                         },
 
                         .workspace => try allocator.dupe(u8, "workspace:*"),
@@ -8250,6 +8376,18 @@ pub const PackageManager = struct {
         @"patch-commit",
         outdated,
         pack,
+        publish,
+
+        // bin,
+        // hash,
+        // @"hash-print",
+        // @"hash-string",
+        // cache,
+        // @"default-trusted",
+        // untrusted,
+        // trust,
+        // ls,
+        // migrate,
 
         pub fn canGloballyInstallPackages(this: Subcommand) bool {
             return switch (this) {
@@ -8265,16 +8403,45 @@ pub const PackageManager = struct {
                 else => false,
             };
         }
+
+        // TODO: make all subcommands find root and chdir
+        pub fn shouldChdirToRoot(this: Subcommand) bool {
+            return switch (this) {
+                .link => false,
+                else => true,
+            };
+        }
     };
 
+    fn httpThreadOnInitError(err: HTTP.InitError, opts: HTTP.HTTPThread.InitOpts) noreturn {
+        switch (err) {
+            error.LoadCAFile => {
+                var normalizer: bun.path.PosixToWinNormalizer = .{};
+                const normalized = normalizer.resolveZ(FileSystem.instance.top_level_dir, opts.abs_ca_file_name);
+                if (!bun.sys.existsZ(normalized)) {
+                    Output.err("HTTPThread", "could not find CA file: '{s}'", .{opts.abs_ca_file_name});
+                } else {
+                    Output.err("HTTPThread", "invalid CA file: '{s}'", .{opts.abs_ca_file_name});
+                }
+            },
+            error.InvalidCAFile => {
+                Output.err("HTTPThread", "invalid CA file: '{s}'", .{opts.abs_ca_file_name});
+            },
+            error.InvalidCA => {
+                Output.err("HTTPThread", "the CA is invalid", .{});
+            },
+            error.FailedToOpenSocket => {
+                Output.errGeneric("failed to start HTTP client thread", .{});
+            },
+        }
+        Global.crash();
+    }
+
     pub fn init(
         ctx: Command.Context,
         cli: CommandLineArguments,
         subcommand: Subcommand,
     ) !struct { *PackageManager, string } {
-        // assume that spawning a thread will take a lil so we do that asap
-        HTTP.HTTPThread.init();
-
         if (cli.global) {
             var explicit_global_dir: string = "";
             if (ctx.install) |opts| {
@@ -8389,7 +8556,7 @@ pub const PackageManager = struct {
 
             // Check if this is a workspace; if so, use root package
             var found = false;
-            if (subcommand != .link) {
+            if (subcommand.shouldChdirToRoot()) {
                 if (!created_package_json) {
                     while (std.fs.path.dirname(this_cwd)) |parent| : (this_cwd = parent) {
                         const parent_without_trailing_slash = strings.withoutTrailingSlash(parent);
@@ -8412,7 +8579,7 @@ pub const PackageManager = struct {
                         const json_path = try bun.getFdPath(json_file.handle, &package_json_cwd_buf);
                         const json_source = logger.Source.initPathString(json_path, json_buf[0..json_len]);
                         initializeStore();
-                        const json = try json_parser.ParsePackageJSONUTF8(&json_source, ctx.log, ctx.allocator);
+                        const json = try JSON.parsePackageJSONUTF8(&json_source, ctx.log, ctx.allocator);
                         if (json.asProperty("workspaces")) |prop| {
                             const json_array = switch (prop.expr.data) {
                                 .e_array => |arr| arr,
@@ -8492,25 +8659,32 @@ pub const PackageManager = struct {
         try env.load(entries_option.entries, &[_][]u8{}, .production, false);
 
         initializeStore();
-        bun.ini.loadNpmrcFromFile(
-            ctx.allocator,
-            ctx.install orelse brk: {
+        if (bun.getenvZ("XDG_CONFIG_HOME") orelse bun.getenvZ(bun.DotEnv.home_env)) |data_dir| {
+            var buf: bun.PathBuffer = undefined;
+            var parts = [_]string{
+                "./.npmrc",
+            };
+
+            bun.ini.loadNpmrcConfig(ctx.allocator, ctx.install orelse brk: {
                 const install_ = ctx.allocator.create(Api.BunInstall) catch bun.outOfMemory();
                 install_.* = std.mem.zeroes(Api.BunInstall);
                 ctx.install = install_;
                 break :brk install_;
-            },
-            env,
-            true,
-        );
-
-        var cpu_count = @as(u32, @truncate(((try std.Thread.getCpuCount()) + 1)));
-
-        if (env.get("GOMAXPROCS")) |max_procs| {
-            if (std.fmt.parseInt(u32, max_procs, 10)) |cpu_count_| {
-                cpu_count = @min(cpu_count, cpu_count_);
-            } else |_| {}
+            }, env, true, &[_][:0]const u8{ Path.joinAbsStringBufZ(
+                data_dir,
+                &buf,
+                &parts,
+                .auto,
+            ), ".npmrc" });
+        } else {
+            bun.ini.loadNpmrcConfig(ctx.allocator, ctx.install orelse brk: {
+                const install_ = ctx.allocator.create(Api.BunInstall) catch bun.outOfMemory();
+                install_.* = std.mem.zeroes(Api.BunInstall);
+                ctx.install = install_;
+                break :brk install_;
+            }, env, true, &[_][:0]const u8{".npmrc"});
         }
+        const cpu_count = bun.getThreadCount();
 
         const options = Options{
             .global = cli.global,
@@ -8532,7 +8706,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{
@@ -8589,6 +8764,49 @@ pub const PackageManager = struct {
             subcommand,
         );
 
+        var ca: []stringZ = &.{};
+        if (manager.options.ca.len > 0) {
+            ca = try manager.allocator.alloc(stringZ, manager.options.ca.len);
+            for (ca, manager.options.ca) |*z, s| {
+                z.* = try manager.allocator.dupeZ(u8, s);
+            }
+        }
+
+        var abs_ca_file_name: stringZ = &.{};
+        if (manager.options.ca_file_name.len > 0) {
+            // resolve with original cwd
+            if (std.fs.path.isAbsolute(manager.options.ca_file_name)) {
+                abs_ca_file_name = try manager.allocator.dupeZ(u8, manager.options.ca_file_name);
+            } else {
+                var path_buf: bun.PathBuffer = undefined;
+                abs_ca_file_name = try manager.allocator.dupeZ(u8, bun.path.joinAbsStringBuf(
+                    original_cwd_clone,
+                    &path_buf,
+                    &.{manager.options.ca_file_name},
+                    .auto,
+                ));
+            }
+        }
+
+        AsyncHTTP.max_simultaneous_requests.store(brk: {
+            if (cli.network_concurrency) |network_concurrency| {
+                break :brk @max(network_concurrency, 1);
+            }
+
+            // If any HTTP proxy is set, use a diferent limit
+            if (env.has("http_proxy") or env.has("https_proxy") or env.has("HTTPS_PROXY") or env.has("HTTP_PROXY")) {
+                break :brk default_max_simultaneous_requests_for_bun_install_for_proxies;
+            }
+
+            break :brk default_max_simultaneous_requests_for_bun_install;
+        }, .monotonic);
+
+        HTTP.HTTPThread.init(&.{
+            .ca = ca,
+            .abs_ca_file_name = abs_ca_file_name,
+            .onInitError = &httpThreadOnInitError,
+        });
+
         manager.timestamp_for_manifest_cache_control = brk: {
             if (comptime bun.Environment.allow_assert) {
                 if (env.get("BUN_CONFIG_MANIFEST_CACHE_CONTROL_TIMESTAMP")) |cache_control| {
@@ -8612,26 +8830,43 @@ pub const PackageManager = struct {
         allocator: std.mem.Allocator,
         cli: CommandLineArguments,
         env: *DotEnv.Loader,
-    ) !*PackageManager {
+    ) *PackageManager {
+        init_with_runtime_once.call(.{
+            log,
+            bun_install,
+            allocator,
+            cli,
+            env,
+        });
+        return PackageManager.get();
+    }
+
+    var init_with_runtime_once = bun.once(initWithRuntimeOnce);
+
+    pub fn initWithRuntimeOnce(
+        log: *logger.Log,
+        bun_install: ?*Api.BunInstall,
+        allocator: std.mem.Allocator,
+        cli: CommandLineArguments,
+        env: *DotEnv.Loader,
+    ) void {
         if (env.get("BUN_INSTALL_VERBOSE") != null) {
             PackageManager.verbose_install = true;
         }
 
-        var cpu_count = @as(u32, @truncate(((try std.Thread.getCpuCount()) + 1)));
-
-        if (env.get("GOMAXPROCS")) |max_procs| {
-            if (std.fmt.parseInt(u32, max_procs, 10)) |cpu_count_| {
-                cpu_count = @min(cpu_count, cpu_count_);
-            } else |_| {}
-        }
-
-        var manager = &instance;
-        var root_dir = try Fs.FileSystem.instance.fs.readDirectory(
+        const cpu_count = bun.getThreadCount();
+        PackageManager.allocatePackageManager();
+        const manager = PackageManager.get();
+        var root_dir = Fs.FileSystem.instance.fs.readDirectory(
             Fs.FileSystem.instance.top_level_dir,
             null,
             0,
             true,
-        );
+        ) catch |err| {
+            Output.err(err, "failed to read root directory: '{s}'", .{Fs.FileSystem.instance.top_level_dir});
+            @panic("Failed to initialize package manager");
+        };
+
         // var progress = Progress{};
         // var node = progress.start(name: []const u8, estimated_total_items: usize)
         const top_level_dir_no_trailing_slash = strings.withoutTrailingSlash(Fs.FileSystem.instance.top_level_dir);
@@ -8660,7 +8895,7 @@ pub const PackageManager = struct {
             .original_package_json_path = original_package_json_path[0..original_package_json_path.len :0],
             .subcommand = .install,
         };
-        manager.lockfile = try allocator.create(Lockfile);
+        manager.lockfile = allocator.create(Lockfile) catch bun.outOfMemory();
 
         if (Output.enable_ansi_colors_stderr) {
             manager.progress = Progress{};
@@ -8688,14 +8923,18 @@ pub const PackageManager = struct {
             }
         }
 
-        try manager.options.load(
+        manager.options.load(
             allocator,
             log,
             env,
             cli,
             bun_install,
             .install,
-        );
+        ) catch |err| {
+            switch (err) {
+                error.OutOfMemory => bun.outOfMemory(),
+            }
+        };
 
         manager.timestamp_for_manifest_cache_control = @as(
             u32,
@@ -8737,8 +8976,6 @@ pub const PackageManager = struct {
         } else {
             manager.lockfile.initEmpty(allocator);
         }
-
-        return manager;
     }
 
     fn attemptToCreatePackageJSONAndOpen() !std.fs.File {
@@ -8790,7 +9027,7 @@ pub const PackageManager = struct {
                 error.InvalidPackageJSON,
                 => {
                     const log = &bun.CLI.Cli.log_;
-                    log.printForLogLevel(bun.Output.errorWriter()) catch {};
+                    log.print(bun.Output.errorWriter()) catch {};
                     bun.Global.exit(1);
                     return;
                 },
@@ -8812,7 +9049,7 @@ pub const PackageManager = struct {
         defer ctx.allocator.free(original_cwd);
 
         if (manager.options.shouldPrintCommandName()) {
-            Output.prettyErrorln("<r><b>bun link <r><d>v" ++ Global.package_json_version_with_sha ++ "<r>\n", .{});
+            Output.prettyln("<r><b>bun link <r><d>v" ++ Global.package_json_version_with_sha ++ "<r>\n", .{});
             Output.flush();
         }
 
@@ -8831,7 +9068,7 @@ pub const PackageManager = struct {
                 };
                 lockfile.initEmpty(ctx.allocator);
 
-                try package.parse(&lockfile, ctx.allocator, manager.log, package_json_source, void, {}, Features.folder);
+                try package.parse(&lockfile, manager, ctx.allocator, manager.log, package_json_source, void, {}, Features.folder);
                 name = lockfile.str(&package.name);
                 if (name.len == 0) {
                     if (manager.options.log_level != .silent) {
@@ -8933,7 +9170,6 @@ pub const PackageManager = struct {
                         Global.crash();
                     },
                     .global_bin_path = manager.options.bin_path,
-                    .global_bin_dir = manager.options.global_bin_dir,
 
                     // .destination_dir_subpath = destination_dir_subpath,
                     .package_name = strings.StringOrTinyString.init(name),
@@ -8995,7 +9231,7 @@ pub const PackageManager = struct {
         defer ctx.allocator.free(original_cwd);
 
         if (manager.options.shouldPrintCommandName()) {
-            Output.prettyErrorln("<r><b>bun unlink <r><d>v" ++ Global.package_json_version_with_sha ++ "<r>\n", .{});
+            Output.prettyln("<r><b>bun unlink <r><d>v" ++ Global.package_json_version_with_sha ++ "<r>\n", .{});
             Output.flush();
         }
 
@@ -9014,7 +9250,7 @@ pub const PackageManager = struct {
                 };
                 lockfile.initEmpty(ctx.allocator);
 
-                try package.parse(&lockfile, ctx.allocator, manager.log, package_json_source, void, {}, Features.folder);
+                try package.parse(&lockfile, manager, ctx.allocator, manager.log, package_json_source, void, {}, Features.folder);
                 name = lockfile.str(&package.name);
                 if (name.len == 0) {
                     if (manager.options.log_level != .silent) {
@@ -9080,7 +9316,6 @@ pub const PackageManager = struct {
                         Global.crash();
                     },
                     .global_bin_path = manager.options.bin_path,
-                    .global_bin_dir = manager.options.global_bin_dir,
                     .package_name = strings.StringOrTinyString.init(name),
                     .string_buf = lockfile.buffers.string_bytes.items,
                     .extern_string_buf = lockfile.buffers.extern_strings.items,
@@ -9113,12 +9348,14 @@ pub const PackageManager = struct {
     else
         "Possible values: \"hardlink\" (default), \"symlink\", \"copyfile\"";
 
-    const install_params_ = [_]ParamType{
+    const shared_params = [_]ParamType{
         clap.parseParam("-c, --config <STR>?                   Specify path to config file (bunfig.toml)") catch unreachable,
         clap.parseParam("-y, --yarn                            Write a yarn.lock file (yarn v1)") catch unreachable,
         clap.parseParam("-p, --production                      Don't install devDependencies") catch unreachable,
         clap.parseParam("--no-save                             Don't update package.json or save a lockfile") catch unreachable,
         clap.parseParam("--save                                Save to package.json (true by default)") catch unreachable,
+        clap.parseParam("--ca <STR>...                         Provide a Certificate Authority signing certificate") catch unreachable,
+        clap.parseParam("--cafile <STR>                        The same as `--ca`, but is a file path to the certificate") catch unreachable,
         clap.parseParam("--dry-run                             Don't install anything") catch unreachable,
         clap.parseParam("--frozen-lockfile                     Disallow changes to lockfile") catch unreachable,
         clap.parseParam("-f, --force                           Always request the latest versions from the registry & reinstall all dependencies") catch unreachable,
@@ -9136,10 +9373,11 @@ pub const PackageManager = struct {
         clap.parseParam("--backend <STR>                       Platform-specific optimizations for installing dependencies. " ++ platform_specific_backend_label) catch unreachable,
         clap.parseParam("--registry <STR>                      Use a specific registry by default, overriding .npmrc, bunfig.toml and environment variables") catch unreachable,
         clap.parseParam("--concurrent-scripts <NUM>            Maximum number of concurrent jobs for lifecycle scripts (default 5)") catch unreachable,
+        clap.parseParam("--network-concurrency <NUM>           Maximum number of concurrent network requests (default 48)") catch unreachable,
         clap.parseParam("-h, --help                            Print this help menu") catch unreachable,
     };
 
-    pub const install_params: []const ParamType = &(install_params_ ++ [_]ParamType{
+    pub const install_params: []const ParamType = &(shared_params ++ [_]ParamType{
         clap.parseParam("-d, --dev                 Add dependency to \"devDependencies\"") catch unreachable,
         clap.parseParam("-D, --development") catch unreachable,
         clap.parseParam("--optional                        Add dependency to \"optionalDependencies\"") catch unreachable,
@@ -9147,12 +9385,12 @@ pub const PackageManager = struct {
         clap.parseParam("<POS> ...                         ") catch unreachable,
     });
 
-    pub const update_params: []const ParamType = &(install_params_ ++ [_]ParamType{
+    pub const update_params: []const ParamType = &(shared_params ++ [_]ParamType{
         clap.parseParam("--latest                              Update packages to their latest versions") catch unreachable,
         clap.parseParam("<POS> ...                         \"name\" of packages to update") catch unreachable,
     });
 
-    pub const pm_params: []const ParamType = &(install_params_ ++ [_]ParamType{
+    pub const pm_params: []const ParamType = &(shared_params ++ [_]ParamType{
         clap.parseParam("-a, --all") catch unreachable,
         // clap.parseParam("--filter <STR>...                      Pack each matching workspace") catch unreachable,
         clap.parseParam("--destination <STR>                    The directory the tarball will be saved in") catch unreachable,
@@ -9160,7 +9398,7 @@ pub const PackageManager = struct {
         clap.parseParam("<POS> ...                         ") catch unreachable,
     });
 
-    pub const add_params: []const ParamType = &(install_params_ ++ [_]ParamType{
+    pub const add_params: []const ParamType = &(shared_params ++ [_]ParamType{
         clap.parseParam("-d, --dev                 Add dependency to \"devDependencies\"") catch unreachable,
         clap.parseParam("-D, --development") catch unreachable,
         clap.parseParam("--optional                        Add dependency to \"optionalDependencies\"") catch unreachable,
@@ -9168,49 +9406,58 @@ pub const PackageManager = struct {
         clap.parseParam("<POS> ...                         \"name\" or \"name@version\" of package(s) to install") catch unreachable,
     });
 
-    pub const remove_params: []const ParamType = &(install_params_ ++ [_]ParamType{
+    pub const remove_params: []const ParamType = &(shared_params ++ [_]ParamType{
         clap.parseParam("<POS> ...                         \"name\" of package(s) to remove from package.json") catch unreachable,
     });
 
-    pub const link_params: []const ParamType = &(install_params_ ++ [_]ParamType{
+    pub const link_params: []const ParamType = &(shared_params ++ [_]ParamType{
         clap.parseParam("<POS> ...                         \"name\" install package as a link") catch unreachable,
     });
 
-    pub const unlink_params: []const ParamType = &(install_params_ ++ [_]ParamType{
+    pub const unlink_params: []const ParamType = &(shared_params ++ [_]ParamType{
         clap.parseParam("<POS> ...                         \"name\" uninstall package as a link") catch unreachable,
     });
 
-    const patch_params: []const ParamType = &(install_params_ ++ [_]ParamType{
+    const patch_params: []const ParamType = &(shared_params ++ [_]ParamType{
         clap.parseParam("<POS> ...                         \"name\" of the package to patch") catch unreachable,
         clap.parseParam("--commit                         Install a package containing modifications in `dir`") catch unreachable,
         clap.parseParam("--patches-dir <dir>                    The directory to put the patch file in (only if --commit is used)") catch unreachable,
     });
 
-    const patch_commit_params: []const ParamType = &(install_params_ ++ [_]ParamType{
+    const patch_commit_params: []const ParamType = &(shared_params ++ [_]ParamType{
         clap.parseParam("<POS> ...                         \"dir\" containing changes to a package") catch unreachable,
         clap.parseParam("--patches-dir <dir>                    The directory to put the patch file") catch unreachable,
     });
 
-    const outdated_params: []const ParamType = &(install_params_ ++ [_]ParamType{
+    const outdated_params: []const ParamType = &(shared_params ++ [_]ParamType{
         // clap.parseParam("--json                                 Output outdated information in JSON format") catch unreachable,
         clap.parseParam("--filter <STR>...                            Display outdated dependencies for each matching workspace") catch unreachable,
         clap.parseParam("<POS> ...                              Package patterns to filter by") catch unreachable,
     });
 
-    const pack_params: []const ParamType = &(install_params_ ++ [_]ParamType{
+    const pack_params: []const ParamType = &(shared_params ++ [_]ParamType{
         // clap.parseParam("--filter <STR>...                      Pack each matching workspace") catch unreachable,
         clap.parseParam("--destination <STR>                    The directory the tarball will be saved in") catch unreachable,
         clap.parseParam("--gzip-level <STR>                     Specify a custom compression level for gzip. Default is 9.") catch unreachable,
         clap.parseParam("<POS> ...                              ") catch unreachable,
     });
 
+    const publish_params: []const ParamType = &(shared_params ++ [_]ParamType{
+        clap.parseParam("<POS> ...                              Package tarball to publish") catch unreachable,
+        clap.parseParam("--access <STR>                         Set access level for scoped packages") catch unreachable,
+        clap.parseParam("--tag <STR>                            Tag the release. Default is \"latest\"") catch unreachable,
+        clap.parseParam("--otp <STR>                            Provide a one-time password for authentication") catch unreachable,
+        clap.parseParam("--auth-type <STR>                      Specify the type of one-time password authentication (default is 'web')") catch unreachable,
+        clap.parseParam("--gzip-level <STR>                     Specify a custom compression level for gzip. Default is 9.") catch unreachable,
+    });
+
     pub const CommandLineArguments = struct {
         cache_dir: string = "",
         lockfile: string = "",
         token: string = "",
         global: bool = false,
         config: ?string = null,
-
+        network_concurrency: ?u16 = null,
         backend: ?PackageInstall.Method = null,
 
         positionals: []const string = &[_]string{},
@@ -9250,6 +9497,11 @@ pub const PackageManager = struct {
 
         registry: string = "",
 
+        publish_config: Options.PublishConfig = .{},
+
+        ca: []const string = &.{},
+        ca_file_name: string = "",
+
         const PatchOpts = union(enum) {
             nothing: struct {},
             patch: struct {},
@@ -9511,6 +9763,31 @@ pub const PackageManager = struct {
                     Output.pretty("\n\n" ++ outro_text ++ "\n", .{});
                     Output.flush();
                 },
+                .publish => {
+                    const intro_text =
+                        \\<b>Usage<r>: <b><green>bun publish<r> <cyan>[flags]<r>
+                    ;
+
+                    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>
+                        \\
+                        \\  <d>Publish the current package with public access.<r>
+                        \\  <b><green>bun publish --access public<r>
+                        \\
+                        \\  <d>Publish a pre-existing package tarball with tag 'next'.<r>
+                        \\  <b><green>bun publish ./path/to/tarball.tgz --tag next<r>
+                        \\
+                    ;
+
+                    Output.pretty("\n" ++ intro_text ++ "\n", .{});
+                    Output.flush();
+                    Output.pretty("\n<b>Flags:<r>", .{});
+                    clap.simpleHelp(PackageManager.publish_params);
+                    Output.pretty("\n\n" ++ outro_text ++ "\n", .{});
+                    Output.flush();
+                },
             }
         }
 
@@ -9529,6 +9806,7 @@ pub const PackageManager = struct {
                 .@"patch-commit" => patch_commit_params,
                 .outdated => outdated_params,
                 .pack => pack_params,
+                .publish => publish_params,
             };
 
             var diag = clap.Diagnostic{};
@@ -9563,6 +9841,18 @@ pub const PackageManager = struct {
             cli.ignore_scripts = args.flag("--ignore-scripts");
             cli.trusted = args.flag("--trust");
             cli.no_summary = args.flag("--no-summary");
+            cli.ca = args.options("--ca");
+
+            if (args.option("--cafile")) |ca_file_name| {
+                cli.ca_file_name = ca_file_name;
+            }
+
+            if (args.option("--network-concurrency")) |network_concurrency| {
+                cli.network_concurrency = std.fmt.parseInt(u16, network_concurrency, 10) catch {
+                    Output.errGeneric("Expected --network-concurrency to be a number between 0 and 65535: {s}", .{network_concurrency});
+                    Global.crash();
+                };
+            }
 
             // commands that support --filter
             if (comptime subcommand.supportsWorkspaceFiltering()) {
@@ -9575,9 +9865,11 @@ pub const PackageManager = struct {
                 // cli.json_output = args.flag("--json");
             }
 
-            if (comptime subcommand == .pack or subcommand == .pm) {
-                if (args.option("--destination")) |dest| {
-                    cli.pack_destination = dest;
+            if (comptime subcommand == .pack or subcommand == .pm or subcommand == .publish) {
+                if (comptime subcommand != .publish) {
+                    if (args.option("--destination")) |dest| {
+                        cli.pack_destination = dest;
+                    }
                 }
 
                 if (args.option("--gzip-level")) |level| {
@@ -9585,6 +9877,30 @@ pub const PackageManager = struct {
                 }
             }
 
+            if (comptime subcommand == .publish) {
+                if (args.option("--tag")) |tag| {
+                    cli.publish_config.tag = tag;
+                }
+
+                if (args.option("--access")) |access| {
+                    cli.publish_config.access = Options.Access.fromStr(access) orelse {
+                        Output.errGeneric("invalid `access` value: '{s}'", .{access});
+                        Global.crash();
+                    };
+                }
+
+                if (args.option("--otp")) |otp| {
+                    cli.publish_config.otp = otp;
+                }
+
+                if (args.option("--auth-type")) |auth_type| {
+                    cli.publish_config.auth_type = Options.AuthType.fromStr(auth_type) orelse {
+                        Output.errGeneric("invalid `auth-type` value: '{s}'", .{auth_type});
+                        Global.crash();
+                    };
+                }
+            }
+
             // link and unlink default to not saving, all others default to
             // saving.
             if (comptime subcommand == .link or subcommand == .unlink) {
@@ -9706,8 +10022,7 @@ pub const PackageManager = struct {
         name_hash: PackageNameHash = 0,
         version: Dependency.Version = .{},
         version_buf: []const u8 = "",
-        resolution: Resolution = .{},
-        resolved_name: String = .{},
+        package_id: PackageID = invalid_package_id,
         is_aliased: bool = false,
         failed: bool = false,
         // This must be cloned to handle when the AST store resets
@@ -9727,16 +10042,16 @@ pub const PackageManager = struct {
         ///
         /// `this` needs to be a pointer! If `this` is a copy and the name returned from
         /// resolved_name is inlined, you will return a pointer to stack memory.
-        pub fn getResolvedName(this: *UpdateRequest) string {
+        pub fn getResolvedName(this: *const UpdateRequest, lockfile: *const Lockfile) string {
             return if (this.is_aliased)
                 this.name
-            else if (this.resolved_name.isEmpty())
+            else if (this.package_id == invalid_package_id)
                 this.version.literal.slice(this.version_buf)
             else
-                this.resolved_name.slice(this.version_buf);
+                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());
@@ -9771,41 +10086,40 @@ 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;
+            const update_requests = parseWithError(allocator, null, &log, all_positionals.items, &array, .add, false) catch {
+                return globalThis.throwValue(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.throwValue(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.throw("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;
         }
 
         pub fn parse(
             allocator: std.mem.Allocator,
+            pm: ?*PackageManager,
             log: *logger.Log,
             positionals: []const string,
             update_requests: *Array,
             subcommand: Subcommand,
         ) []UpdateRequest {
-            return parseWithError(allocator, log, positionals, update_requests, subcommand, true) catch Global.crash();
+            return parseWithError(allocator, pm, log, positionals, update_requests, subcommand, true) catch Global.crash();
         }
 
         fn parseWithError(
             allocator: std.mem.Allocator,
+            pm: ?*PackageManager,
             log: *logger.Log,
             positionals: []const string,
             update_requests: *Array,
@@ -9856,6 +10170,7 @@ pub const PackageManager = struct {
                     null,
                     &SlicedString.init(input, value),
                     log,
+                    pm,
                 ) orelse {
                     if (fatal) {
                         Output.errGeneric("unrecognised dependency format: {s}", .{
@@ -9878,6 +10193,7 @@ pub const PackageManager = struct {
                         null,
                         &SlicedString.init(input, input),
                         log,
+                        pm,
                     )) |ver| {
                         alias = null;
                         version = ver;
@@ -9959,7 +10275,7 @@ pub const PackageManager = struct {
         defer ctx.allocator.free(original_cwd);
 
         if (manager.options.shouldPrintCommandName()) {
-            Output.prettyErrorln("<r><b>bun {s} <r><d>v" ++ Global.package_json_version_with_sha ++ "<r>\n", .{@tagName(subcommand)});
+            Output.prettyln("<r><b>bun {s} <r><d>v" ++ Global.package_json_version_with_sha ++ "<r>\n", .{@tagName(subcommand)});
             Output.flush();
         }
 
@@ -10131,7 +10447,7 @@ pub const PackageManager = struct {
         const updates: []UpdateRequest = if (manager.subcommand == .@"patch-commit" or manager.subcommand == .patch)
             &[_]UpdateRequest{}
         else
-            UpdateRequest.parse(ctx.allocator, ctx.log, manager.options.positionals[1..], &update_requests, manager.subcommand);
+            UpdateRequest.parse(ctx.allocator, manager, ctx.log, manager.options.positionals[1..], &update_requests, manager.subcommand);
         try manager.updatePackageJSONAndInstallWithManagerWithUpdates(
             ctx,
             updates,
@@ -10149,11 +10465,7 @@ pub const PackageManager = struct {
     ) !void {
         if (manager.log.errors > 0) {
             if (comptime log_level != .silent) {
-                switch (Output.enable_ansi_colors) {
-                    inline else => |enable_ansi_colors| {
-                        manager.log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), enable_ansi_colors) catch {};
-                    },
-                }
+                manager.log.print(Output.errorWriter()) catch {};
             }
             Global.crash();
         }
@@ -10163,16 +10475,11 @@ pub const PackageManager = struct {
             manager.log,
             manager.original_package_json_path,
             .{
-                .always_decode_escape_sequences = false,
                 .guess_indentation = true,
             },
         )) {
             .parse_err => |err| {
-                switch (Output.enable_ansi_colors) {
-                    inline else => |enable_ansi_colors| {
-                        manager.log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), enable_ansi_colors) catch {};
-                    },
-                }
+                manager.log.print(Output.errorWriter()) catch {};
                 Output.errGeneric("failed to parse package.json \"{s}\": {s}", .{
                     manager.original_package_json_path,
                     @errorName(err),
@@ -10372,11 +10679,7 @@ pub const PackageManager = struct {
                 },
             )) {
                 .parse_err => |err| {
-                    switch (Output.enable_ansi_colors) {
-                        inline else => |enable_ansi_colors| {
-                            manager.log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), enable_ansi_colors) catch {};
-                        },
-                    }
+                    manager.log.print(Output.errorWriter()) catch {};
                     Output.errGeneric("failed to parse package.json \"{s}\": {s}", .{
                         root_package_json_path,
                         @errorName(err),
@@ -10437,7 +10740,7 @@ pub const PackageManager = struct {
 
             // Now, we _re_ parse our in-memory edited package.json
             // so we can commit the version we changed from the lockfile
-            var new_package_json = json_parser.ParsePackageJSONUTF8(&source, manager.log, manager.allocator) catch |err| {
+            var new_package_json = JSON.parsePackageJSONUTF8(&source, manager.log, manager.allocator) catch |err| {
                 Output.prettyErrorln("package.json failed to parse due to error {s}", .{@errorName(err)});
                 Global.crash();
             };
@@ -10803,12 +11106,8 @@ pub const PackageManager = struct {
                 defer manager.allocator.free(package_json_source.contents);
 
                 initializeStore();
-                const json = json_parser.ParsePackageJSONUTF8AlwaysDecode(&package_json_source, manager.log, manager.allocator) catch |err| {
-                    switch (Output.enable_ansi_colors) {
-                        inline else => |enable_ansi_colors| {
-                            manager.log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), enable_ansi_colors) catch {};
-                        },
-                    }
+                const json = JSON.parsePackageJSONUTF8AlwaysDecode(&package_json_source, manager.log, manager.allocator) catch |err| {
+                    manager.log.print(Output.errorWriter()) catch {};
                     Output.prettyErrorln("<r><red>{s}<r> parsing package.json in <b>\"{s}\"<r>", .{ @errorName(err), package_json_source.path.prettyDir() });
                     Global.crash();
                 };
@@ -10825,7 +11124,7 @@ pub const PackageManager = struct {
                 };
 
                 var package = Lockfile.Package{};
-                try package.parseWithJSON(lockfile, manager.allocator, manager.log, package_json_source, json, void, {}, Features.folder);
+                try package.parseWithJSON(lockfile, manager, manager.allocator, manager.log, package_json_source, json, void, {}, Features.folder);
 
                 const name = lockfile.str(&package.name);
                 const actual_package = switch (lockfile.package_index.get(package.name_hash) orelse {
@@ -11220,12 +11519,8 @@ pub const PackageManager = struct {
                 defer manager.allocator.free(package_json_source.contents);
 
                 initializeStore();
-                const json = json_parser.ParsePackageJSONUTF8AlwaysDecode(&package_json_source, manager.log, manager.allocator) catch |err| {
-                    switch (Output.enable_ansi_colors) {
-                        inline else => |enable_ansi_colors| {
-                            manager.log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), enable_ansi_colors) catch {};
-                        },
-                    }
+                const json = JSON.parsePackageJSONUTF8AlwaysDecode(&package_json_source, manager.log, manager.allocator) catch |err| {
+                    manager.log.print(Output.errorWriter()) catch {};
                     Output.prettyErrorln("<r><red>{s}<r> parsing package.json in <b>\"{s}\"<r>", .{ @errorName(err), package_json_source.path.prettyDir() });
                     Global.crash();
                 };
@@ -11242,7 +11537,7 @@ pub const PackageManager = struct {
                 };
 
                 var package = Lockfile.Package{};
-                try package.parseWithJSON(lockfile, manager.allocator, manager.log, package_json_source, json, void, {}, Features.folder);
+                try package.parseWithJSON(lockfile, manager, manager.allocator, manager.log, package_json_source, json, void, {}, Features.folder);
 
                 const name = lockfile.str(&package.name);
                 const actual_package = switch (lockfile.package_index.get(package.name_hash) orelse {
@@ -11693,22 +11988,27 @@ pub const PackageManager = struct {
 
     pub fn install(ctx: Command.Context) !void {
         const cli = try CommandLineArguments.parse(ctx.allocator, .install);
+
+        const subcommand: Subcommand = if (cli.positionals.len > 1) .add else .install;
+
+        // TODO(dylan-conway): print `bun install <version>` or `bun add <version>` before logs from `init`.
+        // and cleanup install/add subcommand usage
         var manager, _ = try init(ctx, cli, .install);
 
         // switch to `bun add <package>`
-        if (manager.options.positionals.len > 1) {
+        if (subcommand == .add) {
+            manager.subcommand = .add;
             if (manager.options.shouldPrintCommandName()) {
-                Output.prettyErrorln("<r><b>bun add <r><d>v" ++ Global.package_json_version_with_sha ++ "<r>\n", .{});
+                Output.prettyln("<r><b>bun add <r><d>v" ++ Global.package_json_version_with_sha ++ "<r>\n", .{});
                 Output.flush();
             }
-            manager.subcommand = .add;
             return try switch (manager.options.log_level) {
                 inline else => |log_level| manager.updatePackageJSONAndInstallWithManager(ctx, log_level),
             };
         }
 
         if (manager.options.shouldPrintCommandName()) {
-            Output.prettyErrorln("<r><b>bun install <r><d>v" ++ Global.package_json_version_with_sha ++ "<r>\n", .{});
+            Output.prettyln("<r><b>bun install <r><d>v" ++ Global.package_json_version_with_sha ++ "<r>\n", .{});
             Output.flush();
         }
 
@@ -11783,6 +12083,8 @@ pub const PackageManager = struct {
         /// Number of installed dependencies. Could be successful or failure.
         install_count: usize = 0,
 
+        pub const Id = Lockfile.Tree.Id;
+
         pub fn deinit(this: *TreeContext, allocator: std.mem.Allocator) void {
             this.pending_installs.deinit(allocator);
             this.binaries.deinit();
@@ -11824,6 +12126,7 @@ pub const PackageManager = struct {
         pending_lifecycle_scripts: std.ArrayListUnmanaged(struct {
             list: Lockfile.Package.Scripts.List,
             tree_id: Lockfile.Tree.Id,
+            optional: bool,
         }) = .{},
 
         trusted_dependencies_from_update_requests: std.AutoArrayHashMapUnmanaged(TruncatedPackageNameHash, void),
@@ -11879,7 +12182,7 @@ pub const PackageManager = struct {
                     var link_target_buf: bun.PathBuffer = undefined;
                     var link_dest_buf: bun.PathBuffer = undefined;
                     var link_rel_buf: bun.PathBuffer = undefined;
-                    this.linkTreeBins(tree, destination_dir, &link_target_buf, &link_dest_buf, &link_rel_buf, log_level);
+                    this.linkTreeBins(tree, tree_id, destination_dir, &link_target_buf, &link_dest_buf, &link_rel_buf, log_level);
                 }
             }
 
@@ -11893,6 +12196,7 @@ pub const PackageManager = struct {
         pub fn linkTreeBins(
             this: *PackageInstaller,
             tree: *TreeContext,
+            tree_id: TreeContext.Id,
             destination_dir: std.fs.Dir,
             link_target_buf: []u8,
             link_dest_buf: []u8,
@@ -11913,7 +12217,6 @@ pub const PackageManager = struct {
                 var bin_linker: Bin.Linker = .{
                     .bin = bin,
                     .global_bin_path = this.options.bin_path,
-                    .global_bin_dir = this.options.global_bin_dir,
                     .package_name = strings.StringOrTinyString.init(alias),
                     .string_buf = string_buf,
                     .extern_string_buf = lockfile.buffers.extern_strings.items,
@@ -11925,13 +12228,31 @@ pub const PackageManager = struct {
                     .rel_buf = link_rel_buf,
                 };
 
-                bin_linker.link(this.manager.options.global);
+                // globally linked packages shouls always belong to the root
+                // tree (0).
+                const global = if (!this.manager.options.global)
+                    false
+                else if (tree_id != 0)
+                    false
+                else global: {
+                    for (this.manager.update_requests) |request| {
+                        if (request.package_id == package_id) {
+                            break :global true;
+                        }
+                    }
+
+                    break :global false;
+                };
+
+                bin_linker.link(global);
+
                 if (bin_linker.err) |err| {
                     if (log_level != .silent) {
-                        this.manager.log.addErrorFmtNoLoc(
+                        this.manager.log.addErrorFmtOpts(
                             this.manager.allocator,
                             "Failed to link <b>{s}<r>: {s}",
                             .{ alias, @errorName(err) },
+                            .{},
                         ) catch bun.outOfMemory();
                     }
 
@@ -11976,7 +12297,7 @@ pub const PackageManager = struct {
                     };
                     defer destination_dir.close();
 
-                    this.linkTreeBins(tree, destination_dir, &link_target_buf, &link_dest_buf, &link_rel_buf, log_level);
+                    this.linkTreeBins(tree, @intCast(tree_id), destination_dir, &link_target_buf, &link_dest_buf, &link_rel_buf, log_level);
                 }
             }
         }
@@ -11988,10 +12309,17 @@ pub const PackageManager = struct {
                 const entry = this.pending_lifecycle_scripts.items[i];
                 const name = entry.list.package_name;
                 const tree_id = entry.tree_id;
+                const optional = entry.optional;
                 if (this.canRunScripts(tree_id)) {
                     _ = this.pending_lifecycle_scripts.swapRemove(i);
                     const output_in_foreground = false;
-                    this.manager.spawnPackageLifecycleScripts(this.command_ctx, entry.list, log_level, output_in_foreground) catch |err| {
+                    this.manager.spawnPackageLifecycleScripts(
+                        this.command_ctx,
+                        entry.list,
+                        optional,
+                        log_level,
+                        output_in_foreground,
+                    ) catch |err| {
                         if (comptime log_level != .silent) {
                             const fmt = "\n<r><red>error:<r> failed to spawn life-cycle scripts for <b>{s}<r>: {s}\n";
                             const args = .{ name, @errorName(err) };
@@ -12071,11 +12399,12 @@ 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();
+                    this.manager.sleep();
                 }
 
+                const optional = entry.optional;
                 const output_in_foreground = false;
-                this.manager.spawnPackageLifecycleScripts(this.command_ctx, entry.list, log_level, output_in_foreground) catch |err| {
+                this.manager.spawnPackageLifecycleScripts(this.command_ctx, entry.list, optional, log_level, output_in_foreground) catch |err| {
                     if (comptime log_level != .silent) {
                         const fmt = "\n<r><red>error:<r> failed to spawn life-cycle scripts for <b>{s}<r>: {s}\n";
                         const args = .{ package_name, @errorName(err) };
@@ -12112,7 +12441,7 @@ pub const PackageManager = struct {
                     }
                 }
 
-                PackageManager.instance.sleep();
+                this.manager.sleep();
             }
         }
 
@@ -12156,6 +12485,16 @@ pub const PackageManager = struct {
             this.names = packages.items(.name);
             this.bins = packages.items(.bin);
             this.resolutions = packages.items(.resolution);
+
+            // fixes an assertion failure where a transitive dependency is a git dependency newly added to the lockfile after the list of dependencies has been resized
+            // this assertion failure would also only happen after the lockfile has been written to disk and the summary is being printed.
+            if (this.successfully_installed.bit_length < this.lockfile.packages.len) {
+                const new = Bitset.initEmpty(bun.default_allocator, this.lockfile.packages.len) catch bun.outOfMemory();
+                var old = this.successfully_installed;
+                defer old.deinit(bun.default_allocator);
+                old.copyInto(new);
+                this.successfully_installed = new;
+            }
         }
 
         /// Install versions of a package which are waiting on a network request
@@ -12246,6 +12585,7 @@ pub const PackageManager = struct {
         ) usize {
             if (comptime Environment.allow_assert) {
                 bun.assertWithLocation(resolution_tag != .root, @src());
+                bun.assertWithLocation(resolution_tag != .workspace, @src());
                 bun.assertWithLocation(package_id != 0, @src());
             }
             var count: usize = 0;
@@ -12393,7 +12733,6 @@ pub const PackageManager = struct {
             var installer = PackageInstall{
                 .progress = this.progress,
                 .cache_dir = undefined,
-                .cache_dir_subpath = undefined,
                 .destination_dir_subpath = destination_dir_subpath,
                 .destination_dir_subpath_buf = &this.destination_dir_subpath_buf,
                 .allocator = this.lockfile.allocator,
@@ -12468,6 +12807,10 @@ pub const PackageManager = struct {
                     }
                     installer.cache_dir = std.fs.cwd();
                 },
+                .root => {
+                    installer.cache_dir_subpath = ".";
+                    installer.cache_dir = std.fs.cwd();
+                },
                 .symlink => {
                     const directory = this.manager.globalLinkDir() catch |err| {
                         if (comptime log_level != .silent) {
@@ -12536,7 +12879,7 @@ pub const PackageManager = struct {
             this.summary.skipped += @intFromBool(!needs_install);
 
             if (needs_install) {
-                if (!remove_patch and resolution.tag.canEnqueueInstallTask() and installer.packageMissingFromCache(this.manager, package_id)) {
+                if (!remove_patch and resolution.tag.canEnqueueInstallTask() and installer.packageMissingFromCache(this.manager, package_id, resolution.tag)) {
                     if (comptime Environment.allow_assert) {
                         bun.assertWithLocation(resolution.canEnqueueInstallTask(), @src());
                     }
@@ -12666,7 +13009,7 @@ pub const PackageManager = struct {
                 const install_result = switch (resolution.tag) {
                     .symlink, .workspace => installer.installFromLink(this.skip_delete, destination_dir),
                     else => result: {
-                        if (resolution.tag == .folder and !this.lockfile.isWorkspaceTreeId(this.current_tree_id)) {
+                        if (resolution.tag == .root or (resolution.tag == .folder and !this.lockfile.isWorkspaceTreeId(this.current_tree_id))) {
                             // This is a transitive folder dependency. It is installed with a single symlink to the target folder/file,
                             // and is not hoisted.
                             const dirname = std.fs.path.dirname(this.node_modules.path.items) orelse this.node_modules.path.items;
@@ -12674,7 +13017,10 @@ pub const PackageManager = struct {
                             installer.cache_dir = this.root_node_modules_folder.openDir(dirname, .{ .iterate = true, .access_sub_paths = true }) catch |err|
                                 break :result PackageInstall.Result.fail(err, .opening_cache_dir);
 
-                            const result = installer.install(this.skip_delete, destination_dir, resolution.tag);
+                            const result = if (resolution.tag == .root)
+                                installer.installFromLink(this.skip_delete, destination_dir)
+                            else
+                                installer.install(this.skip_delete, destination_dir, resolution.tag);
 
                             if (result.isFail() and (result.fail.err == error.ENOENT or result.fail.err == error.FileNotFound))
                                 break :result PackageInstall.Result.success();
@@ -12700,19 +13046,21 @@ pub const PackageManager = struct {
                             this.trees[this.current_tree_id].binaries.add(dependency_id) catch bun.outOfMemory();
                         }
 
-                        const name_hash: TruncatedPackageNameHash = @truncate(this.lockfile.buffers.dependencies.items[dependency_id].name_hash);
+                        const dep = this.lockfile.buffers.dependencies.items[dependency_id];
+                        const name_hash: TruncatedPackageNameHash = @truncate(dep.name_hash);
                         const is_trusted, const is_trusted_through_update_request = brk: {
                             if (this.trusted_dependencies_from_update_requests.contains(name_hash)) break :brk .{ true, true };
                             if (this.lockfile.hasTrustedDependency(alias)) break :brk .{ true, false };
                             break :brk .{ false, false };
                         };
 
-                        if (resolution.tag == .workspace or is_trusted) {
+                        if (resolution.tag != .root and (resolution.tag == .workspace or is_trusted)) {
                             if (this.enqueueLifecycleScripts(
                                 alias,
                                 log_level,
                                 destination_dir,
                                 package_id,
+                                dep.behavior.optional,
                                 resolution,
                             )) {
                                 if (is_trusted_through_update_request) {
@@ -12727,23 +13075,27 @@ pub const PackageManager = struct {
                             }
                         }
 
-                        if (resolution.tag != .workspace and !is_trusted and this.lockfile.packages.items(.meta)[package_id].hasInstallScript()) {
-                            // Check if the package actually has scripts. `hasInstallScript` can be false positive if a package is published with
-                            // an auto binding.gyp rebuild script but binding.gyp is excluded from the published files.
-                            const count = this.getInstalledPackageScriptsCount(alias, package_id, resolution.tag, destination_dir, log_level);
-                            if (count > 0) {
-                                if (comptime log_level.isVerbose()) {
-                                    Output.prettyError("Blocked {d} scripts for: {s}@{}\n", .{
-                                        count,
-                                        alias,
-                                        resolution.fmt(this.lockfile.buffers.string_bytes.items, .posix),
-                                    });
+                        switch (resolution.tag) {
+                            .root, .workspace => {
+                                // these will never be blocked
+                            },
+                            else => if (!is_trusted and this.metas[package_id].hasInstallScript()) {
+                                // Check if the package actually has scripts. `hasInstallScript` can be false positive if a package is published with
+                                // an auto binding.gyp rebuild script but binding.gyp is excluded from the published files.
+                                const count = this.getInstalledPackageScriptsCount(alias, package_id, resolution.tag, destination_dir, log_level);
+                                if (count > 0) {
+                                    if (comptime log_level.isVerbose()) {
+                                        Output.prettyError("Blocked {d} scripts for: {s}@{}\n", .{
+                                            count,
+                                            alias,
+                                            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;
-                            }
+                            },
                         }
 
                         if (!pkg_has_patch) this.incrementTreeInstallCount(this.current_tree_id, destination_dir, !is_pending_package_install, log_level);
@@ -12836,7 +13188,8 @@ pub const PackageManager = struct {
 
                 defer if (!pkg_has_patch) this.incrementTreeInstallCount(this.current_tree_id, destination_dir, !is_pending_package_install, log_level);
 
-                const name_hash: TruncatedPackageNameHash = @truncate(this.lockfile.buffers.dependencies.items[dependency_id].name_hash);
+                const dep = this.lockfile.buffers.dependencies.items[dependency_id];
+                const name_hash: TruncatedPackageNameHash = @truncate(dep.name_hash);
                 const is_trusted, const is_trusted_through_update_request, const add_to_lockfile = brk: {
                     // trusted through a --trust dependency. need to enqueue scripts, write to package.json, and add to lockfile
                     if (this.trusted_dependencies_from_update_requests.contains(name_hash)) break :brk .{ true, true, true };
@@ -12848,12 +13201,13 @@ pub const PackageManager = struct {
                     break :brk .{ false, false, false };
                 };
 
-                if (is_trusted) {
+                if (resolution.tag != .root and is_trusted) {
                     if (this.enqueueLifecycleScripts(
                         alias,
                         log_level,
                         destination_dir,
                         package_id,
+                        dep.behavior.optional,
                         resolution,
                     )) {
                         if (is_trusted_through_update_request) {
@@ -12879,6 +13233,7 @@ pub const PackageManager = struct {
             comptime log_level: Options.LogLevel,
             node_modules_folder: std.fs.Dir,
             package_id: PackageID,
+            optional: bool,
             resolution: *const Resolution,
         ) bool {
             var scripts: Package.Scripts = this.lockfile.packages.items(.scripts)[package_id];
@@ -12930,6 +13285,7 @@ pub const PackageManager = struct {
                 this.pending_lifecycle_scripts.append(this.manager.allocator, .{
                     .list = scripts_list.?,
                     .tree_id = this.current_tree_id,
+                    .optional = optional,
                 }) catch bun.outOfMemory();
 
                 return true;
@@ -13067,6 +13423,7 @@ pub const PackageManager = struct {
             dependency_id,
             this.lockfile.packages.get(package_id),
             patch_name_and_version_hash,
+            .allow_authorization,
         ) catch unreachable) |task| {
             task.schedule(&this.network_tarball_batch);
             if (this.network_tarball_batch.len > 0) {
@@ -13103,6 +13460,7 @@ pub const PackageManager = struct {
             dependency_id,
             this.lockfile.packages.get(package_id),
             patch_name_and_version_hash,
+            .no_authorization,
         ) catch unreachable) |task| {
             task.schedule(&this.network_tarball_batch);
             if (this.network_tarball_batch.len > 0) {
@@ -13480,8 +13838,11 @@ 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 closure.manager.pendingTaskCount() > 0) {
+                            const pending_task_count = closure.manager.pendingTaskCount();
+                            if (pending_task_count > 0 and PackageManager.hasEnoughTimePassedBetweenWaitingMessages()) {
+                                Output.prettyErrorln("<d>[PackageManager]<r> waiting for {d} tasks\n", .{pending_task_count});
+                            }
                         }
 
                         return closure.manager.pendingTaskCount() == 0 and closure.manager.hasNoMorePendingLifecycleScripts();
@@ -13694,11 +14055,7 @@ pub const PackageManager = struct {
                     }
 
                     if (ctx.log.errors > 0) {
-                        switch (Output.enable_ansi_colors) {
-                            inline else => |enable_ansi_colors| {
-                                try manager.log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), enable_ansi_colors);
-                            },
-                        }
+                        try manager.log.print(Output.errorWriter());
                     }
                     Output.flush();
                 }
@@ -13762,6 +14119,7 @@ pub const PackageManager = struct {
 
                     try maybe_root.parse(
                         &lockfile,
+                        manager,
                         manager.allocator,
                         manager.log,
                         root_package_json_source,
@@ -13773,6 +14131,7 @@ pub const PackageManager = struct {
                     @memset(mapping, invalid_package_id);
 
                     manager.summary = try Package.Diff.generate(
+                        manager,
                         manager.allocator,
                         manager.log,
                         manager.lockfile,
@@ -13832,7 +14191,7 @@ pub const PackageManager = struct {
                             break :brk all_name_hashes;
                         };
 
-                        manager.lockfile.overrides = try lockfile.overrides.clone(&lockfile, manager.lockfile, builder);
+                        manager.lockfile.overrides = try lockfile.overrides.clone(manager, &lockfile, manager.lockfile, builder);
 
                         manager.lockfile.trusted_dependencies = if (lockfile.trusted_dependencies) |trusted_dependencies|
                             try trusted_dependencies.clone(manager.lockfile.allocator)
@@ -13855,7 +14214,7 @@ pub const PackageManager = struct {
                         manager.lockfile.buffers.resolutions.items = manager.lockfile.buffers.resolutions.items.ptr[0 .. off + len];
 
                         for (new_dependencies, 0..) |new_dep, i| {
-                            dependencies[i] = try new_dep.clone(lockfile.buffers.string_bytes.items, *Lockfile.StringBuilder, builder);
+                            dependencies[i] = try new_dep.clone(manager, lockfile.buffers.string_bytes.items, *Lockfile.StringBuilder, builder);
                             if (mapping[i] != invalid_package_id) {
                                 resolutions[i] = old_resolutions[mapping[i]];
                             }
@@ -13993,6 +14352,7 @@ pub const PackageManager = struct {
 
             try root.parse(
                 manager.lockfile,
+                manager,
                 manager.allocator,
                 manager.log,
                 root_package_json_source,
@@ -14127,7 +14487,7 @@ pub const PackageManager = struct {
         }
 
         const had_errors_before_cleaning_lockfile = manager.log.hasErrors();
-        try manager.log.printForLogLevel(Output.errorWriter());
+        try manager.log.print(Output.errorWriter());
         manager.log.reset();
 
         // This operation doesn't perform any I/O, so it should be relatively cheap.
@@ -14244,7 +14604,7 @@ pub const PackageManager = struct {
         }
 
         if (comptime log_level != .silent) {
-            try manager.log.printForLogLevel(Output.errorWriter());
+            try manager.log.print(Output.errorWriter());
         }
         if (had_errors_before_cleaning_lockfile or manager.log.hasErrors()) Global.crash();
 
@@ -14303,7 +14663,7 @@ pub const PackageManager = struct {
                 manager.progress.refresh();
             }
 
-            manager.lockfile.saveToDisk(manager.options.lockfile_path);
+            manager.lockfile.saveToDisk(manager.options.lockfile_path, manager.options.log_level.isVerbose());
 
             if (comptime Environment.allow_assert) {
                 if (manager.lockfile.hasMetaHashChanged(false, packages_len_before_install) catch false) {
@@ -14358,8 +14718,9 @@ pub const PackageManager = struct {
                 }
                 // root lifecycle scripts can run now that all dependencies are installed, dependency scripts
                 // have finished, and lockfiles have been saved
+                const optional = false;
                 const output_in_foreground = true;
-                try manager.spawnPackageLifecycleScripts(ctx, scripts, log_level, output_in_foreground);
+                try manager.spawnPackageLifecycleScripts(ctx, scripts, optional, log_level, output_in_foreground);
 
                 while (manager.pending_lifecycle_script_tasks.load(.monotonic) > 0) {
                     if (PackageManager.verbose_install) {
@@ -14379,12 +14740,11 @@ pub const PackageManager = struct {
                     .options = manager.options,
                     .updates = manager.update_requests,
                     .successfully_installed = install_summary.successfully_installed,
-                    .manager = manager,
                 };
 
                 switch (Output.enable_ansi_colors) {
                     inline else => |enable_ansi_colors| {
-                        try Lockfile.Printer.Tree.print(&printer, Output.WriterType, Output.writer(), enable_ansi_colors, log_level);
+                        try Lockfile.Printer.Tree.print(&printer, manager, Output.WriterType, Output.writer(), enable_ansi_colors, log_level);
                     },
                 }
 
@@ -14543,6 +14903,7 @@ pub const PackageManager = struct {
         this: *PackageManager,
         ctx: Command.Context,
         list: Lockfile.Package.Scripts.List,
+        optional: bool,
         comptime log_level: PackageManager.Options.LogLevel,
         comptime foreground: bool,
     ) !void {
@@ -14592,7 +14953,7 @@ pub const PackageManager = struct {
         try this_bundler.env.map.put("PATH", original_path);
         PATH.deinit();
 
-        try LifecycleScriptSubprocess.spawnPackageScripts(this, list, envp, log_level, foreground);
+        try LifecycleScriptSubprocess.spawnPackageScripts(this, list, envp, optional, log_level, foreground);
     }
 };
 
@@ -14622,33 +14983,34 @@ 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();
 
-        const args = callFrame.arguments(1).slice();
-        const cwd = args[0].toSliceOrNull(globalObject) orelse return .zero;
+        const args = callFrame.arguments_old(1).slice();
+        const cwd = try args[0].toSliceOrNull(globalObject);
         defer cwd.deinit();
 
         const lockfile_path = Path.joinAbsStringZ(cwd.slice(), &[_]string{"bun.lockb"}, .auto);
 
         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);
 
         switch (load_result) {
             .err => |err| {
-                globalObject.throw("failed to load lockfile: {s}, \"{s}\"", .{ @errorName(err.value), lockfile_path });
-                return .zero;
+                return globalObject.throw("failed to load lockfile: {s}, \"{s}\"", .{ @errorName(err.value), lockfile_path });
             },
             .not_found => {
-                globalObject.throw("lockfile not found: \"{s}\"", .{lockfile_path});
-                return .zero;
+                return globalObject.throw("lockfile not found: \"{s}\"", .{lockfile_path});
             },
             .ok => {},
         }
@@ -14667,13 +15029,11 @@ pub const bun_install_js_bindings = struct {
             },
             buffered_writer.writer(),
         ) catch |err| {
-            globalObject.throw("failed to print lockfile as JSON: {s}", .{@errorName(err)});
-            return .zero;
+            return globalObject.throw("failed to print lockfile as JSON: {s}", .{@errorName(err)});
         };
 
         buffered_writer.flush() catch |err| {
-            globalObject.throw("failed to print lockfile as JSON: {s}", .{@errorName(err)});
-            return .zero;
+            return globalObject.throw("failed to print lockfile as JSON: {s}", .{@errorName(err)});
         };
 
         var str = bun.String.createUTF8(buffer.list.items);
diff --git a/src/install/lifecycle_script_runner.zig b/src/install/lifecycle_script_runner.zig
index f9df8bfd63..3900e790e8 100644
--- a/src/install/lifecycle_script_runner.zig
+++ b/src/install/lifecycle_script_runner.zig
@@ -32,6 +32,7 @@ pub const LifecycleScriptSubprocess = struct {
     has_incremented_alive_count: bool = false,
 
     foreground: bool = false,
+    optional: bool = false,
 
     pub usingnamespace bun.New(@This());
 
@@ -301,6 +302,11 @@ pub const LifecycleScriptSubprocess = struct {
                 const maybe_duration = if (this.timer) |*t| t.read() else null;
 
                 if (exit.code > 0) {
+                    if (this.optional) {
+                        _ = this.manager.pending_lifecycle_script_tasks.fetchSub(1, .monotonic);
+                        this.deinitAndDeletePackage();
+                        return;
+                    }
                     this.printOutput();
                     Output.prettyErrorln("<r><red>error<r><d>:<r> <b>{s}<r> script from \"<b>{s}<r>\" exited with {d}<r>", .{
                         this.scriptName(),
@@ -364,6 +370,12 @@ pub const LifecycleScriptSubprocess = struct {
                 Global.raiseIgnoringPanicHandler(signal);
             },
             .err => |err| {
+                if (this.optional) {
+                    _ = this.manager.pending_lifecycle_script_tasks.fetchSub(1, .monotonic);
+                    this.deinitAndDeletePackage();
+                    return;
+                }
+
                 Output.prettyErrorln("<r><red>error<r>: Failed to run <b>{s}<r> script from \"<b>{s}<r>\" due to\n{}", .{
                     this.scriptName(),
                     this.package_name,
@@ -421,10 +433,28 @@ pub const LifecycleScriptSubprocess = struct {
         this.destroy();
     }
 
+    pub fn deinitAndDeletePackage(this: *LifecycleScriptSubprocess) void {
+        if (this.manager.options.log_level.isVerbose()) {
+            Output.warn("deleting optional dependency '{s}' due to failed '{s}' script", .{
+                this.package_name,
+                this.scriptName(),
+            });
+        }
+        try_delete_dir: {
+            const dirname = std.fs.path.dirname(this.scripts.cwd) orelse break :try_delete_dir;
+            const basename = std.fs.path.basename(this.scripts.cwd);
+            const dir = bun.openDirAbsolute(dirname) catch break :try_delete_dir;
+            dir.deleteTree(basename) catch break :try_delete_dir;
+        }
+
+        this.deinit();
+    }
+
     pub fn spawnPackageScripts(
         manager: *PackageManager,
         list: Lockfile.Package.Scripts.List,
         envp: [:null]?[*:0]u8,
+        optional: bool,
         comptime log_level: PackageManager.Options.LogLevel,
         comptime foreground: bool,
     ) !void {
@@ -434,6 +464,7 @@ pub const LifecycleScriptSubprocess = struct {
             .scripts = list,
             .package_name = list.package_name,
             .foreground = foreground,
+            .optional = optional,
         });
 
         if (comptime log_level.isVerbose()) {
diff --git a/src/install/lockfile.zig b/src/install/lockfile.zig
index 3e89da50b7..bf93c60932 100644
--- a/src/install/lockfile.zig
+++ b/src/install/lockfile.zig
@@ -18,7 +18,7 @@ const logger = bun.logger;
 
 const js_parser = bun.js_parser;
 const Expr = @import("../js_ast.zig").Expr;
-const json_parser = bun.JSON;
+const JSON = bun.JSON;
 const JSPrinter = bun.js_printer;
 
 const linker = @import("../linker.zig");
@@ -206,7 +206,7 @@ pub const Scripts = struct {
 };
 
 pub fn isEmpty(this: *const Lockfile) bool {
-    return this.packages.len == 0 or this.packages.len == 1 or this.packages.get(0).resolutions.len == 0;
+    return this.packages.len == 0 or (this.packages.len == 1 and this.packages.get(0).resolutions.len == 0);
 }
 
 pub const LoadFromDiskResult = union(enum) {
@@ -226,7 +226,7 @@ pub const LoadFromDiskResult = union(enum) {
 
 pub fn loadFromDisk(
     this: *Lockfile,
-    manager: *PackageManager,
+    manager: ?*PackageManager,
     allocator: Allocator,
     log: *logger.Log,
     filename: stringZ,
@@ -241,14 +241,16 @@ pub fn loadFromDisk(
         return switch (err) {
             error.EACCESS, error.EPERM, error.ENOENT => {
                 if (comptime attempt_loading_from_other_lockfile) {
-                    // Attempt to load from "package-lock.json", "yarn.lock", etc.
-                    return migration.detectAndLoadOtherLockfile(
-                        this,
-                        manager,
-                        allocator,
-                        log,
-                        filename,
-                    );
+                    if (manager) |pm| {
+                        // Attempt to load from "package-lock.json", "yarn.lock", etc.
+                        return migration.detectAndLoadOtherLockfile(
+                            this,
+                            pm,
+                            allocator,
+                            log,
+                            filename,
+                        );
+                    }
                 }
 
                 return LoadFromDiskResult{
@@ -260,10 +262,10 @@ pub fn loadFromDisk(
         };
     };
 
-    return this.loadFromBytes(buf, allocator, log);
+    return this.loadFromBytes(manager, buf, allocator, log);
 }
 
-pub fn loadFromBytes(this: *Lockfile, buf: []u8, allocator: Allocator, log: *logger.Log) LoadFromDiskResult {
+pub fn loadFromBytes(this: *Lockfile, pm: ?*PackageManager, buf: []u8, allocator: Allocator, log: *logger.Log) LoadFromDiskResult {
     var stream = Stream{ .buffer = buf, .pos = 0 };
 
     this.format = FormatVersion.current;
@@ -274,7 +276,7 @@ pub fn loadFromBytes(this: *Lockfile, buf: []u8, allocator: Allocator, log: *log
     this.overrides = .{};
     this.patched_dependencies = .{};
 
-    const load_result = Lockfile.Serializer.load(this, &stream, allocator, log) catch |err| {
+    const load_result = Lockfile.Serializer.load(this, &stream, allocator, log, pm) catch |err| {
         return LoadFromDiskResult{ .err = .{ .step = .parse_file, .value = err } };
     };
 
@@ -738,7 +740,7 @@ pub fn maybeCloneFilteringRootPackages(
     return try old.clean(manager, &.{}, exact_versions, log_level);
 }
 
-fn preprocessUpdateRequests(old: *Lockfile, updates: []PackageManager.UpdateRequest, exact_versions: bool) !void {
+fn preprocessUpdateRequests(old: *Lockfile, manager: *PackageManager, updates: []PackageManager.UpdateRequest, exact_versions: bool) !void {
     const root_deps_list: Lockfile.DependencySlice = old.packages.items(.dependencies)[0];
     if (@as(usize, root_deps_list.off) < old.buffers.dependencies.items.len) {
         var string_builder = old.stringBuilder();
@@ -799,6 +801,7 @@ fn preprocessUpdateRequests(old: *Lockfile, updates: []PackageManager.UpdateRequ
                                 sliced.slice,
                                 &sliced,
                                 null,
+                                manager,
                             ) orelse Dependency.Version{};
                         }
                     }
@@ -904,7 +907,7 @@ pub fn cleanWithLogger(
     @memset(preinstall_state.items, .unknown);
 
     if (updates.len > 0) {
-        try old.preprocessUpdateRequests(updates, exact_versions);
+        try old.preprocessUpdateRequests(manager, updates, exact_versions);
     }
 
     var new: *Lockfile = try old.allocator.create(Lockfile);
@@ -923,7 +926,7 @@ pub fn cleanWithLogger(
         var builder = new.stringBuilder();
         old.overrides.count(old, &builder);
         try builder.allocate();
-        new.overrides = try old.overrides.clone(old, new, &builder);
+        new.overrides = try old.overrides.clone(manager, old, new, &builder);
     }
 
     // Step 1. Recreate the lockfile with only the packages that are still alive
@@ -946,7 +949,7 @@ pub fn cleanWithLogger(
     };
 
     // try clone_queue.ensureUnusedCapacity(root.dependencies.len);
-    _ = try root.clone(old, new, package_id_mapping, &cloner);
+    _ = try root.clone(manager, old, new, package_id_mapping, &cloner);
 
     // Clone workspace_paths and workspace_versions at the end.
     if (old.workspace_paths.count() > 0 or old.workspace_versions.count() > 0) {
@@ -1033,8 +1036,6 @@ pub fn cleanWithLogger(
     if (updates.len > 0) {
         const string_buf = new.buffers.string_bytes.items;
         const slice = new.packages.slice();
-        const names = slice.items(.name);
-        const resolutions = slice.items(.resolution);
 
         // updates might be applied to the root package.json or one
         // of the workspace package.json files.
@@ -1046,14 +1047,13 @@ pub fn cleanWithLogger(
         const resolved_ids: []const PackageID = res_list.get(new.buffers.resolutions.items);
 
         request_updated: for (updates) |*update| {
-            if (update.resolution.tag == .uninitialized) {
+            if (update.package_id == invalid_package_id) {
                 for (resolved_ids, workspace_deps) |package_id, dep| {
                     if (update.matches(dep, string_buf)) {
                         if (package_id > new.packages.len) continue;
                         update.version_buf = string_buf;
                         update.version = dep.version;
-                        update.resolution = resolutions[package_id];
-                        update.resolved_name = names[package_id];
+                        update.package_id = package_id;
 
                         continue :request_updated;
                     }
@@ -1129,6 +1129,7 @@ const Cloner = struct {
             const old_package = this.old.packages.get(to_clone.old_resolution);
 
             this.lockfile.buffers.resolutions.items[to_clone.resolve_id] = try old_package.clone(
+                this.manager,
                 this.old,
                 this.lockfile,
                 this.mapping,
@@ -1195,8 +1196,6 @@ pub const Printer = struct {
     options: PackageManager.Options,
     successfully_installed: ?Bitset = null,
 
-    manager: ?*PackageManager,
-
     updates: []const PackageManager.UpdateRequest = &[_]PackageManager.UpdateRequest{},
 
     pub const Format = enum { yarn };
@@ -1236,10 +1235,7 @@ pub const Printer = struct {
 
         var lockfile = try allocator.create(Lockfile);
 
-        // TODO remove the need for manager when migrating from package-lock.json
-        const manager = &PackageManager.instance;
-
-        const load_from_disk = lockfile.loadFromDisk(manager, allocator, log, lockfile_path, false);
+        const load_from_disk = lockfile.loadFromDisk(null, allocator, log, lockfile_path, false);
         switch (load_from_disk) {
             .err => |cause| {
                 switch (cause.step) {
@@ -1257,11 +1253,7 @@ pub const Printer = struct {
                     }),
                 }
                 if (log.errors > 0) {
-                    switch (Output.enable_ansi_colors) {
-                        inline else => |enable_ansi_colors| {
-                            try log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), enable_ansi_colors);
-                        },
-                    }
+                    try log.print(Output.errorWriter());
                 }
                 Global.crash();
             },
@@ -1319,7 +1311,6 @@ pub const Printer = struct {
         var printer = Printer{
             .lockfile = lockfile,
             .options = options,
-            .manager = null,
         };
 
         switch (format) {
@@ -1332,6 +1323,7 @@ pub const Printer = struct {
     pub const Tree = struct {
         fn printInstalledWorkspaceSection(
             this: *const Printer,
+            manager: *PackageManager,
             comptime Writer: type,
             writer: Writer,
             comptime enable_ansi_colors: bool,
@@ -1355,7 +1347,7 @@ pub const Printer = struct {
 
             // find the updated packages
             for (resolutions_list[workspace_package_id].begin()..resolutions_list[workspace_package_id].end()) |dep_id| {
-                switch (shouldPrintPackageInstall(this, @intCast(dep_id), installed, id_map)) {
+                switch (shouldPrintPackageInstall(this, manager, @intCast(dep_id), installed, id_map)) {
                     .yes, .no, .@"return" => {},
                     .update => |update_info| {
                         printed_new_install.* = true;
@@ -1377,7 +1369,7 @@ pub const Printer = struct {
             }
 
             for (resolutions_list[workspace_package_id].begin()..resolutions_list[workspace_package_id].end()) |dep_id| {
-                switch (shouldPrintPackageInstall(this, @intCast(dep_id), installed, id_map)) {
+                switch (shouldPrintPackageInstall(this, manager, @intCast(dep_id), installed, id_map)) {
                     .@"return" => return,
                     .yes => {},
                     .no, .update => continue,
@@ -1402,7 +1394,7 @@ pub const Printer = struct {
                     printed_update = false;
                     try writer.writeAll("\n");
                 }
-                try printInstalledPackage(this, &dep, package_id, enable_ansi_colors, Writer, writer);
+                try printInstalledPackage(this, manager, &dep, package_id, enable_ansi_colors, Writer, writer);
             }
         }
 
@@ -1422,6 +1414,7 @@ pub const Printer = struct {
 
         fn shouldPrintPackageInstall(
             this: *const Printer,
+            manager: *PackageManager,
             dep_id: DependencyID,
             installed: *const Bitset,
             id_map: ?[]DependencyID,
@@ -1448,22 +1441,20 @@ pub const Printer = struct {
 
             if (!installed.isSet(package_id)) return .no;
 
-            if (this.manager) |manager| {
-                const resolution = this.lockfile.packages.items(.resolution)[package_id];
-                if (resolution.tag == .npm) {
-                    const name = dependency.name.slice(this.lockfile.buffers.string_bytes.items);
-                    if (manager.updating_packages.get(name)) |entry| {
-                        if (entry.original_version) |original_version| {
-                            if (!original_version.eql(resolution.value.npm.version)) {
-                                return .{
-                                    .update = .{
-                                        .version = original_version,
-                                        .version_buf = entry.original_version_string_buf,
-                                        .resolution = resolution,
-                                        .dependency_id = dep_id,
-                                    },
-                                };
-                            }
+            const resolution = this.lockfile.packages.items(.resolution)[package_id];
+            if (resolution.tag == .npm) {
+                const name = dependency.name.slice(this.lockfile.buffers.string_bytes.items);
+                if (manager.updating_packages.get(name)) |entry| {
+                    if (entry.original_version) |original_version| {
+                        if (!original_version.eql(resolution.value.npm.version)) {
+                            return .{
+                                .update = .{
+                                    .version = original_version,
+                                    .version_buf = entry.original_version_string_buf,
+                                    .resolution = resolution,
+                                    .dependency_id = dep_id,
+                                },
+                            };
                         }
                     }
                 }
@@ -1501,6 +1492,7 @@ pub const Printer = struct {
 
         fn printInstalledPackage(
             this: *const Printer,
+            manager: *PackageManager,
             dependency: *const Dependency,
             package_id: PackageID,
             comptime enable_ansi_colors: bool,
@@ -1512,27 +1504,25 @@ pub const Printer = struct {
             const resolution: Resolution = packages_slice.items(.resolution)[package_id];
             const name = dependency.name.slice(string_buf);
 
-            if (this.manager) |manager| {
-                const package_name = packages_slice.items(.name)[package_id].slice(string_buf);
-                if (manager.formatLaterVersionInCache(package_name, dependency.name_hash, resolution)) |later_version_fmt| {
-                    const fmt = comptime brk: {
-                        if (enable_ansi_colors) {
-                            break :brk Output.prettyFmt("<r><green>+<r> <b>{s}<r><d>@{}<r> <d>(<blue>v{} available<r><d>)<r>\n", enable_ansi_colors);
-                        } else {
-                            break :brk Output.prettyFmt("<r>+ {s}<r><d>@{}<r> <d>(v{} available)<r>\n", enable_ansi_colors);
-                        }
-                    };
-                    try writer.print(
-                        fmt,
-                        .{
-                            name,
-                            resolution.fmt(string_buf, .posix),
-                            later_version_fmt,
-                        },
-                    );
+            const package_name = packages_slice.items(.name)[package_id].slice(string_buf);
+            if (manager.formatLaterVersionInCache(package_name, dependency.name_hash, resolution)) |later_version_fmt| {
+                const fmt = comptime brk: {
+                    if (enable_ansi_colors) {
+                        break :brk Output.prettyFmt("<r><green>+<r> <b>{s}<r><d>@{}<r> <d>(<blue>v{} available<r><d>)<r>\n", enable_ansi_colors);
+                    } else {
+                        break :brk Output.prettyFmt("<r>+ {s}<r><d>@{}<r> <d>(v{} available)<r>\n", enable_ansi_colors);
+                    }
+                };
+                try writer.print(
+                    fmt,
+                    .{
+                        name,
+                        resolution.fmt(string_buf, .posix),
+                        later_version_fmt,
+                    },
+                );
 
-                    return;
-                }
+                return;
             }
 
             const fmt = comptime brk: {
@@ -1556,6 +1546,7 @@ pub const Printer = struct {
         /// - Prints a leading and trailing blank newline with diffs
         pub fn print(
             this: *const Printer,
+            manager: *PackageManager,
             comptime Writer: type,
             writer: Writer,
             comptime enable_ansi_colors: bool,
@@ -1595,7 +1586,7 @@ pub const Printer = struct {
                     for (workspaces_to_print.items) |workspace_dep_id| {
                         const workspace_package_id = resolutions_buffer[workspace_dep_id];
                         for (resolutions_list[workspace_package_id].begin()..resolutions_list[workspace_package_id].end()) |dep_id| {
-                            switch (shouldPrintPackageInstall(this, @intCast(dep_id), installed, id_map)) {
+                            switch (shouldPrintPackageInstall(this, manager, @intCast(dep_id), installed, id_map)) {
                                 .yes => found_workspace_to_print = true,
                                 else => {},
                             }
@@ -1604,6 +1595,7 @@ pub const Printer = struct {
 
                     try printInstalledWorkspaceSection(
                         this,
+                        manager,
                         Writer,
                         writer,
                         enable_ansi_colors,
@@ -1617,6 +1609,7 @@ pub const Printer = struct {
                     for (workspaces_to_print.items) |workspace_dep_id| {
                         try printInstalledWorkspaceSection(
                             this,
+                            manager,
                             Writer,
                             writer,
                             enable_ansi_colors,
@@ -1630,7 +1623,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 (manager.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) {
@@ -1642,6 +1635,7 @@ pub const Printer = struct {
 
                     try printInstalledWorkspaceSection(
                         this,
+                        manager,
                         Writer,
                         writer,
                         enable_ansi_colors,
@@ -1736,7 +1730,6 @@ pub const Printer = struct {
 
                         {
                             const fmt = comptime Output.prettyFmt("<r> <d>- <r><b>{s}<r>\n", enable_ansi_colors);
-                            var manager = &bun.PackageManager.instance;
 
                             if (manager.track_installed_bin == .pending) {
                                 if (iterator.next() catch null) |bin_name| {
@@ -1999,7 +1992,7 @@ pub fn verifyData(this: *const Lockfile) !void {
     }
 }
 
-pub fn saveToDisk(this: *Lockfile, filename: stringZ) void {
+pub fn saveToDisk(this: *Lockfile, filename: stringZ, verbose_log: bool) void {
     if (comptime Environment.allow_assert) {
         this.verifyData() catch |err| {
             Output.prettyErrorln("<r><red>error:<r> failed to verify lockfile: {s}", .{@errorName(err)});
@@ -2014,7 +2007,7 @@ pub fn saveToDisk(this: *Lockfile, filename: stringZ) void {
     {
         var total_size: usize = 0;
         var end_pos: usize = 0;
-        Lockfile.Serializer.save(this, &bytes, &total_size, &end_pos) catch |err| {
+        Lockfile.Serializer.save(this, verbose_log, &bytes, &total_size, &end_pos) catch |err| {
             Output.err(err, "failed to serialize lockfile", .{});
             Global.crash();
         };
@@ -2419,14 +2412,14 @@ pub const OverrideMap = struct {
         }
     }
 
-    pub fn clone(this: *OverrideMap, old_lockfile: *Lockfile, new_lockfile: *Lockfile, new_builder: *Lockfile.StringBuilder) !OverrideMap {
+    pub fn clone(this: *OverrideMap, pm: *PackageManager, old_lockfile: *Lockfile, new_lockfile: *Lockfile, new_builder: *Lockfile.StringBuilder) !OverrideMap {
         var new = OverrideMap{};
         try new.map.ensureTotalCapacity(new_lockfile.allocator, this.map.entries.len);
 
         for (this.map.keys(), this.map.values()) |k, v| {
             new.map.putAssumeCapacity(
                 k,
-                try v.clone(old_lockfile.buffers.string_bytes.items, @TypeOf(new_builder), new_builder),
+                try v.clone(pm, old_lockfile.buffers.string_bytes.items, @TypeOf(new_builder), new_builder),
             );
         }
 
@@ -2476,6 +2469,7 @@ pub const OverrideMap = struct {
     /// It is assumed the input map is uninitialized (zero entries)
     pub fn parseAppend(
         this: *OverrideMap,
+        pm: *PackageManager,
         lockfile: *Lockfile,
         root_package: *Lockfile.Package,
         log: *logger.Log,
@@ -2487,9 +2481,9 @@ pub const OverrideMap = struct {
             assert(this.map.entries.len == 0); // only call parse once
         }
         if (expr.asProperty("overrides")) |overrides| {
-            try this.parseFromOverrides(lockfile, root_package, json_source, log, overrides.expr, builder);
+            try this.parseFromOverrides(pm, lockfile, root_package, json_source, log, overrides.expr, builder);
         } else if (expr.asProperty("resolutions")) |resolutions| {
-            try this.parseFromResolutions(lockfile, root_package, json_source, log, resolutions.expr, builder);
+            try this.parseFromResolutions(pm, lockfile, root_package, json_source, log, resolutions.expr, builder);
         }
         debug("parsed {d} overrides", .{this.map.entries.len});
     }
@@ -2497,6 +2491,7 @@ pub const OverrideMap = struct {
     /// https://docs.npmjs.com/cli/v9/configuring-npm/package-json#overrides
     pub fn parseFromOverrides(
         this: *OverrideMap,
+        pm: *PackageManager,
         lockfile: *Lockfile,
         root_package: *Lockfile.Package,
         source: logger.Source,
@@ -2556,6 +2551,7 @@ pub const OverrideMap = struct {
             if (try parseOverrideValue(
                 "override",
                 lockfile,
+                pm,
                 root_package,
                 source,
                 value.loc,
@@ -2573,6 +2569,7 @@ pub const OverrideMap = struct {
     /// yarn berry: https://yarnpkg.com/configuration/manifest#resolutions
     pub fn parseFromResolutions(
         this: *OverrideMap,
+        pm: *PackageManager,
         lockfile: *Lockfile,
         root_package: *Lockfile.Package,
         source: logger.Source,
@@ -2626,6 +2623,7 @@ pub const OverrideMap = struct {
             if (try parseOverrideValue(
                 "resolution",
                 lockfile,
+                pm,
                 root_package,
                 source,
                 value.loc,
@@ -2643,6 +2641,7 @@ pub const OverrideMap = struct {
     pub fn parseOverrideValue(
         comptime field: []const u8,
         lockfile: *Lockfile,
+        package_manager: *PackageManager,
         root_package: *Lockfile.Package,
         source: logger.Source,
         loc: logger.Loc,
@@ -2690,6 +2689,7 @@ pub const OverrideMap = struct {
                 literalSliced.slice,
                 &literalSliced,
                 log,
+                package_manager,
             ) orelse {
                 try log.addWarningFmt(&source, loc, lockfile.allocator, "Invalid " ++ field ++ " value \"{s}\"", .{value});
                 return null;
@@ -3098,7 +3098,7 @@ pub const Package = extern struct {
                 };
 
                 initializeStore();
-                break :brk try json_parser.ParsePackageJSONUTF8(
+                break :brk try JSON.parsePackageJSONUTF8(
                     &json_src,
                     log,
                     allocator,
@@ -3181,6 +3181,7 @@ pub const Package = extern struct {
 
     pub fn clone(
         this: *const Lockfile.Package,
+        pm: *PackageManager,
         old: *Lockfile,
         new: *Lockfile,
         package_id_mapping: []PackageID,
@@ -3277,6 +3278,7 @@ pub const Package = extern struct {
 
         for (old_dependencies, dependencies) |old_dep, *new_dep| {
             new_dep.* = try old_dep.clone(
+                pm,
                 old_string_buf,
                 *Lockfile.StringBuilder,
                 builder,
@@ -3310,6 +3312,7 @@ pub const Package = extern struct {
 
     pub fn fromPackageJSON(
         lockfile: *Lockfile,
+        pm: *PackageManager,
         package_json: *PackageJSON,
         comptime features: Features,
     ) !Lockfile.Package {
@@ -3369,7 +3372,7 @@ pub const Package = extern struct {
             for (package_dependencies) |dep| {
                 if (!dep.behavior.isEnabled(features)) continue;
 
-                dependencies[0] = try dep.clone(source_buf, @TypeOf(&string_builder), &string_builder);
+                dependencies[0] = try dep.clone(pm, source_buf, @TypeOf(&string_builder), &string_builder);
                 dependencies = dependencies[1..];
                 if (dependencies.len == 0) break;
             }
@@ -3399,6 +3402,7 @@ pub const Package = extern struct {
     }
 
     pub fn fromNPM(
+        pm: *PackageManager,
         allocator: Allocator,
         lockfile: *Lockfile,
         log: *logger.Log,
@@ -3552,6 +3556,7 @@ pub const Package = extern struct {
                             sliced.slice,
                             &sliced,
                             log,
+                            pm,
                         ) orelse Dependency.Version{},
                     };
 
@@ -3641,6 +3646,7 @@ pub const Package = extern struct {
         };
 
         pub fn generate(
+            pm: *PackageManager,
             allocator: Allocator,
             log: *logger.Log,
             from_lockfile: *Lockfile,
@@ -3853,10 +3859,11 @@ 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 = pm.workspace_package_json_cache.getWithSource(bun.default_allocator, log, source, .{}).unwrap() catch break :brk false;
 
                                 try workspace.parseWithJSON(
                                     to_lockfile,
+                                    pm,
                                     allocator,
                                     log,
                                     source,
@@ -3870,6 +3877,7 @@ pub const Package = extern struct {
 
                                 var from_pkg = from_lockfile.packages.get(from_resolutions[i]);
                                 const diff = try generate(
+                                    pm,
                                     allocator,
                                     log,
                                     from_lockfile,
@@ -3937,6 +3945,7 @@ pub const Package = extern struct {
     pub fn parse(
         package: *Lockfile.Package,
         lockfile: *Lockfile,
+        pm: *PackageManager,
         allocator: Allocator,
         log: *logger.Log,
         source: logger.Source,
@@ -3945,18 +3954,15 @@ pub const Package = extern struct {
         comptime features: Features,
     ) !void {
         initializeStore();
-        const json = json_parser.ParsePackageJSONUTF8AlwaysDecode(&source, log, allocator) catch |err| {
-            switch (Output.enable_ansi_colors) {
-                inline else => |enable_ansi_colors| {
-                    log.printForLogLevelWithEnableAnsiColors(Output.errorWriter(), enable_ansi_colors) catch {};
-                },
-            }
+        const json = JSON.parsePackageJSONUTF8AlwaysDecode(&source, log, allocator) catch |err| {
+            log.print(Output.errorWriter()) catch {};
             Output.prettyErrorln("<r><red>{s}<r> parsing package.json in <b>\"{s}\"<r>", .{ @errorName(err), source.path.prettyDir() });
             Global.crash();
         };
 
         try package.parseWithJSON(
             lockfile,
+            pm,
             allocator,
             log,
             source,
@@ -3969,6 +3975,7 @@ pub const Package = extern struct {
 
     fn parseDependency(
         lockfile: *Lockfile,
+        pm: *PackageManager,
         allocator: Allocator,
         log: *logger.Log,
         source: logger.Source,
@@ -4018,6 +4025,7 @@ pub const Package = extern struct {
             tag,
             &sliced,
             log,
+            pm,
         ) orelse Dependency.Version{};
         var workspace_range: ?Semver.Query.Group = null;
         const name_hash = switch (dependency_version.tag) {
@@ -4088,6 +4096,7 @@ pub const Package = extern struct {
                             .workspace,
                             &path,
                             log,
+                            pm,
                         )) |dep| {
                             found_workspace = true;
                             dependency_version = dep;
@@ -4338,7 +4347,7 @@ pub const Package = extern struct {
         }).unwrap();
 
         const name_expr = workspace_json.root.get("name") orelse return error.MissingPackageName;
-        const name = name_expr.asStringCloned(allocator) orelse return error.MissingPackageName;
+        const name = try name_expr.asStringCloned(allocator) orelse return error.MissingPackageName;
 
         var entry = WorkspaceEntry{
             .name = name,
@@ -4346,7 +4355,7 @@ pub const Package = extern struct {
         };
         debug("processWorkspaceName({s}) = {s}", .{ abs_package_json_path, entry.name });
         if (workspace_json.root.get("version")) |version_expr| {
-            if (version_expr.asStringCloned(allocator)) |version| {
+            if (try version_expr.asStringCloned(allocator)) |version| {
                 entry.version = version;
             }
         }
@@ -4376,7 +4385,7 @@ pub const Package = extern struct {
 
         for (arr.slice()) |item| {
             // TODO: when does this get deallocated?
-            const input_path = item.asStringZ(allocator) orelse {
+            const input_path = try item.asStringZ(allocator) orelse {
                 log.addErrorFmt(source, item.loc, allocator,
                     \\Workspaces expects an array of strings, like:
                     \\  <r><green>"workspaces"<r>: [
@@ -4625,6 +4634,7 @@ pub const Package = extern struct {
     pub fn parseWithJSON(
         package: *Lockfile.Package,
         lockfile: *Lockfile,
+        pm: *PackageManager,
         allocator: Allocator,
         log: *logger.Log,
         source: logger.Source,
@@ -4804,7 +4814,7 @@ pub const Package = extern struct {
                         total_dependencies_count += try processWorkspaceNamesArray(
                             &workspace_names,
                             allocator,
-                            &PackageManager.instance.workspace_package_json_cache,
+                            &pm.workspace_package_json_cache,
                             log,
                             arr,
                             &source,
@@ -4828,7 +4838,7 @@ pub const Package = extern struct {
                                     total_dependencies_count += try processWorkspaceNamesArray(
                                         &workspace_names,
                                         allocator,
-                                        &PackageManager.instance.workspace_package_json_cache,
+                                        &pm.workspace_package_json_cache,
                                         log,
                                         packages_query.data.e_array,
                                         &source,
@@ -4980,6 +4990,21 @@ pub const Package = extern struct {
             };
         }
 
+        if (json.asProperty("patchedDependencies")) |patched_deps| {
+            const obj = patched_deps.expr.data.e_object;
+            lockfile.patched_dependencies.ensureTotalCapacity(allocator, obj.properties.len) catch unreachable;
+            for (obj.properties.slice()) |prop| {
+                const key = prop.key.?;
+                const value = prop.value.?;
+                if (key.isString() and value.isString()) {
+                    var sfb = std.heap.stackFallback(1024, allocator);
+                    const keyhash = try key.asStringHash(sfb.get(), String.Builder.stringHash) orelse unreachable;
+                    const patch_path = string_builder.append(String, value.asString(allocator).?);
+                    lockfile.patched_dependencies.put(allocator, keyhash, .{ .path = patch_path }) catch unreachable;
+                }
+            }
+        }
+
         bin: {
             if (json.asProperty("bin")) |bin| {
                 switch (bin.expr.data) {
@@ -5042,21 +5067,6 @@ pub const Package = extern struct {
                 }
             }
 
-            if (json.asProperty("patchedDependencies")) |patched_deps| {
-                const obj = patched_deps.expr.data.e_object;
-                lockfile.patched_dependencies.ensureTotalCapacity(allocator, obj.properties.len) catch unreachable;
-                for (obj.properties.slice()) |prop| {
-                    const key = prop.key.?;
-                    const value = prop.value.?;
-                    if (key.isString() and value.isString()) {
-                        var sfb = std.heap.stackFallback(1024, allocator);
-                        const keyhash = key.asStringHash(sfb.get(), String.Builder.stringHash) orelse unreachable;
-                        const patch_path = string_builder.append(String, value.asString(allocator).?);
-                        lockfile.patched_dependencies.put(allocator, keyhash, .{ .path = patch_path }) catch unreachable;
-                    }
-                }
-            }
-
             if (json.asProperty("directories")) |dirs| {
                 // https://docs.npmjs.com/cli/v8/configuring-npm/package-json#directoriesbin
                 // Because of the way the bin directive works,
@@ -5171,6 +5181,7 @@ pub const Package = extern struct {
 
                     if (try parseDependency(
                         lockfile,
+                        pm,
                         allocator,
                         log,
                         source,
@@ -5213,6 +5224,7 @@ pub const Package = extern struct {
 
                                 if (try parseDependency(
                                     lockfile,
+                                    pm,
                                     allocator,
                                     log,
                                     source,
@@ -5265,7 +5277,7 @@ pub const Package = extern struct {
 
         // This function depends on package.dependencies being set, so it is done at the very end.
         if (comptime features.is_main) {
-            try lockfile.overrides.parseAppend(lockfile, package, log, source, json, &string_builder);
+            try lockfile.overrides.parseAppend(pm, lockfile, package, log, source, json, &string_builder);
         }
 
         string_builder.clamp();
@@ -5712,6 +5724,7 @@ const Buffers = struct {
 
     pub fn save(
         lockfile: *Lockfile,
+        verbose_log: bool,
         allocator: Allocator,
         comptime StreamType: type,
         stream: StreamType,
@@ -5720,7 +5733,7 @@ const Buffers = struct {
     ) !void {
         const buffers = lockfile.buffers;
         inline for (sizes.names) |name| {
-            if (PackageManager.instance.options.log_level.isVerbose()) {
+            if (verbose_log) {
                 Output.prettyErrorln("Saving {d} {s}", .{ @field(buffers, name).items.len, name });
             }
 
@@ -5818,7 +5831,7 @@ const Buffers = struct {
         return error.@"Lockfile is missing resolution data";
     }
 
-    pub fn load(stream: *Stream, allocator: Allocator, log: *logger.Log) !Buffers {
+    pub fn load(stream: *Stream, allocator: Allocator, log: *logger.Log, pm_: ?*PackageManager) !Buffers {
         var this = Buffers{};
         var external_dependency_list_: std.ArrayListUnmanaged(Dependency.External) = std.ArrayListUnmanaged(Dependency.External){};
 
@@ -5832,9 +5845,10 @@ 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()) {
-                    Output.prettyErrorln("Loaded {d} {s}", .{ external_dependency_list_.items.len, name });
+                if (pm_) |pm| {
+                    if (pm.options.log_level.isVerbose()) {
+                        Output.prettyErrorln("Loaded {d} {s}", .{ external_dependency_list_.items.len, name });
+                    }
                 }
             } else if (comptime Type == @TypeOf(this.trees)) {
                 var tree_list = try readArray(stream, allocator, std.ArrayListUnmanaged(Tree.External));
@@ -5847,8 +5861,10 @@ const Buffers = struct {
                 }
             } else {
                 @field(this, name) = try readArray(stream, allocator, Type);
-                if (PackageManager.instance.options.log_level.isVerbose()) {
-                    Output.prettyErrorln("Loaded {d} {s}", .{ @field(this, name).items.len, name });
+                if (pm_) |pm| {
+                    if (pm.options.log_level.isVerbose()) {
+                        Output.prettyErrorln("Loaded {d} {s}", .{ @field(this, name).items.len, name });
+                    }
                 }
             }
 
@@ -5866,6 +5882,7 @@ const Buffers = struct {
             .log = log,
             .allocator = allocator,
             .buffer = string_buf,
+            .package_manager = pm_,
         };
 
         this.dependencies.expandToCapacity();
@@ -5913,7 +5930,7 @@ pub const Serializer = struct {
     const has_empty_trusted_dependencies_tag: u64 = @bitCast(@as([8]u8, "eMpTrUsT".*));
     const has_overrides_tag: u64 = @bitCast(@as([8]u8, "oVeRriDs".*));
 
-    pub fn save(this: *Lockfile, bytes: *std.ArrayList(u8), total_size: *usize, end_pos: *usize) !void {
+    pub fn save(this: *Lockfile, verbose_log: bool, bytes: *std.ArrayList(u8), total_size: *usize, end_pos: *usize) !void {
 
         // we clone packages with the z_allocator to make sure bytes are zeroed.
         // TODO: investigate if we still need this now that we have `padding_checker.zig`
@@ -5968,7 +5985,7 @@ pub const Serializer = struct {
         }
 
         try Lockfile.Package.Serializer.save(this.packages, StreamType, stream, @TypeOf(writer), writer);
-        try Lockfile.Buffers.save(this, z_allocator, StreamType, stream, @TypeOf(writer), writer);
+        try Lockfile.Buffers.save(this, verbose_log, z_allocator, StreamType, stream, @TypeOf(writer), writer);
         try writer.writeInt(u64, 0, .little);
 
         // < Bun v1.0.4 stopped right here when reading the lockfile
@@ -6096,6 +6113,7 @@ pub const Serializer = struct {
         stream: *Stream,
         allocator: Allocator,
         log: *logger.Log,
+        manager: ?*PackageManager,
     ) !SerializerLoadResult {
         var res = SerializerLoadResult{};
         var reader = stream.reader();
@@ -6130,7 +6148,12 @@ pub const Serializer = struct {
         lockfile.packages = packages_load_result.list;
         res.packages_need_update = packages_load_result.needs_update;
 
-        lockfile.buffers = try Lockfile.Buffers.load(stream, allocator, log);
+        lockfile.buffers = try Lockfile.Buffers.load(
+            stream,
+            allocator,
+            log,
+            manager,
+        );
         if ((try stream.reader().readInt(u64, .little)) != 0) {
             return error.@"Lockfile is malformed (expected 0 at the end)";
         }
@@ -6255,6 +6278,7 @@ pub const Serializer = struct {
                         .allocator = allocator,
                         .log = log,
                         .buffer = lockfile.buffers.string_bytes.items,
+                        .package_manager = manager,
                     };
                     for (overrides_name_hashes.items, override_versions_external.items) |name, value| {
                         map.putAssumeCapacity(name, Dependency.toDependency(value, context));
diff --git a/src/install/migration.zig b/src/install/migration.zig
index aa8043126e..87dfc373ca 100644
--- a/src/install/migration.zig
+++ b/src/install/migration.zig
@@ -77,7 +77,7 @@ pub fn detectAndLoadOtherLockfile(
                 bun.handleErrorReturnTrace(err, @errorReturnTrace());
 
                 Output.prettyErrorln("Error: {s}", .{@errorName(err)});
-                log.printForLogLevel(Output.errorWriter()) catch {};
+                log.print(Output.errorWriter()) catch {};
                 Output.prettyErrorln("Invalid NPM package-lock.json\nIn a release build, this would ignore and do a fresh install.\nAborting", .{});
                 Global.exit(1);
             }
@@ -137,7 +137,7 @@ pub fn migrateNPMLockfile(
     Install.initializeStore();
 
     const json_src = logger.Source.initPathString(abs_path, data);
-    const json = bun.JSON.ParseJSONUTF8(&json_src, log, allocator) catch return error.InvalidNPMLockfile;
+    const json = bun.JSON.parseUTF8(&json_src, log, allocator) catch return error.InvalidNPMLockfile;
 
     if (json.data != .e_object) {
         return error.InvalidNPMLockfile;
@@ -782,6 +782,7 @@ pub fn migrateNPMLockfile(
                         sliced.slice,
                         &sliced,
                         log,
+                        manager,
                     ) orelse {
                         return error.InvalidNPMLockfile;
                     };
diff --git a/src/install/npm.zig b/src/install/npm.zig
index 77b7f55aa2..4c5210f86d 100644
--- a/src/install/npm.zig
+++ b/src/install/npm.zig
@@ -19,7 +19,7 @@ const Bin = @import("./bin.zig").Bin;
 const Environment = bun.Environment;
 const Aligner = @import("./install.zig").Aligner;
 const HTTPClient = bun.http;
-const json_parser = bun.JSON;
+const JSON = bun.JSON;
 const default_allocator = bun.default_allocator;
 const IdentityContext = @import("../identity_context.zig").IdentityContext;
 const ArrayIdentityContext = @import("../identity_context.zig").ArrayIdentityContext;
@@ -31,9 +31,214 @@ const VersionSlice = @import("./install.zig").VersionSlice;
 const ObjectPool = @import("../pool.zig").ObjectPool;
 const Api = @import("../api/schema.zig").Api;
 const DotEnv = @import("../env_loader.zig");
+const http = bun.http;
+const OOM = bun.OOM;
+const Global = bun.Global;
+const PublishCommand = bun.CLI.PublishCommand;
+const File = bun.sys.File;
 
 const Npm = @This();
 
+const WhoamiError = OOM || error{
+    NeedAuth,
+    ProbablyInvalidAuth,
+};
+
+pub fn whoami(allocator: std.mem.Allocator, manager: *PackageManager) WhoamiError!string {
+    const registry = manager.options.scope;
+
+    if (registry.user.len > 0) {
+        const sep = strings.indexOfChar(registry.user, ':').?;
+        return registry.user[0..sep];
+    }
+
+    if (registry.url.username.len > 0) return registry.url.username;
+
+    if (registry.token.len == 0) {
+        return error.NeedAuth;
+    }
+
+    const auth_type = if (manager.options.publish_config.auth_type) |auth_type| @tagName(auth_type) else "web";
+    const ci_name = bun.detectCI();
+
+    var print_buf = std.ArrayList(u8).init(allocator);
+    defer print_buf.deinit();
+    var print_writer = print_buf.writer();
+
+    var headers: http.HeaderBuilder = .{};
+
+    {
+        headers.count("accept", "*/*");
+        headers.count("accept-encoding", "gzip,deflate");
+
+        try print_writer.print("Bearer {s}", .{registry.token});
+        headers.count("authorization", print_buf.items);
+        print_buf.clearRetainingCapacity();
+
+        // no otp needed, just use auth-type from options
+        headers.count("npm-auth-type", auth_type);
+        headers.count("npm-command", "whoami");
+
+        try print_writer.print("{s} {s} {s} workspaces/{}{s}{s}", .{
+            Global.user_agent,
+            Global.os_name,
+            Global.arch_name,
+            // TODO: figure out how npm determines workspaces=true
+            false,
+            if (ci_name != null) " ci/" else "",
+            ci_name orelse "",
+        });
+        headers.count("user-agent", print_buf.items);
+        print_buf.clearRetainingCapacity();
+
+        headers.count("Connection", "keep-alive");
+        headers.count("Host", registry.url.host);
+    }
+
+    try headers.allocate(allocator);
+
+    {
+        headers.append("accept", "*/*");
+        headers.append("accept-encoding", "gzip/deflate");
+
+        try print_writer.print("Bearer {s}", .{registry.token});
+        headers.append("authorization", print_buf.items);
+        print_buf.clearRetainingCapacity();
+
+        headers.append("npm-auth-type", auth_type);
+        headers.append("npm-command", "whoami");
+
+        try print_writer.print("{s} {s} {s} workspaces/{}{s}{s}", .{
+            Global.user_agent,
+            Global.os_name,
+            Global.arch_name,
+            false,
+            if (ci_name != null) " ci/" else "",
+            ci_name orelse "",
+        });
+        headers.append("user-agent", print_buf.items);
+        print_buf.clearRetainingCapacity();
+
+        headers.append("Connection", "keep-alive");
+        headers.append("Host", registry.url.host);
+    }
+
+    try print_writer.print("{s}/-/whoami", .{
+        strings.withoutTrailingSlash(registry.url.href),
+    });
+
+    var response_buf = try MutableString.init(allocator, 1024);
+
+    const url = URL.parse(print_buf.items);
+
+    var req = http.AsyncHTTP.initSync(
+        allocator,
+        .GET,
+        url,
+        headers.entries,
+        headers.content.ptr.?[0..headers.content.len],
+        &response_buf,
+        "",
+        null,
+        null,
+        .follow,
+    );
+
+    const res = req.sendSync() catch |err| {
+        switch (err) {
+            error.OutOfMemory => |oom| return oom,
+            else => {
+                Output.err(err, "whoami request failed to send", .{});
+                Global.crash();
+            },
+        }
+    };
+
+    if (res.status_code >= 400) {
+        const otp_response = false;
+        try responseError(
+            allocator,
+            &req,
+            &res,
+            null,
+            &response_buf,
+            otp_response,
+        );
+    }
+
+    if (res.headers.getIfOtherIsAbsent("npm-notice", "x-local-cache")) |notice| {
+        Output.printError("\n", .{});
+        Output.note("{s}", .{notice});
+        Output.flush();
+    }
+
+    var log = logger.Log.init(allocator);
+    const source = logger.Source.initPathString("???", response_buf.list.items);
+    const json = JSON.parseUTF8(&source, &log, allocator) catch |err| {
+        switch (err) {
+            error.OutOfMemory => |oom| return oom,
+            else => {
+                Output.err(err, "failed to parse '/-/whoami' response body as JSON", .{});
+                Global.crash();
+            },
+        }
+    };
+
+    const username, _ = try json.getString(allocator, "username") orelse {
+        // no username, invalid auth probably
+        return error.ProbablyInvalidAuth;
+    };
+    return username;
+}
+
+pub fn responseError(
+    allocator: std.mem.Allocator,
+    req: *const http.AsyncHTTP,
+    res: *const bun.picohttp.Response,
+    // `<name>@<version>`
+    pkg_id: ?struct { string, string },
+    response_body: *MutableString,
+    comptime otp_response: bool,
+) OOM!noreturn {
+    const message = message: {
+        var log = logger.Log.init(allocator);
+        const source = logger.Source.initPathString("???", response_body.list.items);
+        const json = JSON.parseUTF8(&source, &log, allocator) catch |err| {
+            switch (err) {
+                error.OutOfMemory => |oom| return oom,
+                else => break :message null,
+            }
+        };
+
+        const @"error", _ = try json.getString(allocator, "error") orelse break :message null;
+        break :message @"error";
+    };
+
+    Output.prettyErrorln("\n<red>{d}<r>{s}{s}: {s}\n", .{
+        res.status_code,
+        if (res.status.len > 0) " " else "",
+        res.status,
+        bun.fmt.redactedNpmUrl(req.url.href),
+    });
+
+    if (res.status_code == 404 and pkg_id != null) {
+        const package_name, const package_version = pkg_id.?;
+        Output.prettyErrorln("\n - '{s}@{s}' does not exist in this registry", .{ package_name, package_version });
+    } else {
+        if (message) |msg| {
+            if (comptime otp_response) {
+                if (res.status_code == 401 and strings.containsComptime(msg, "You must provide a one-time pass. Upgrade your client to npm@latest in order to use 2FA.")) {
+                    Output.prettyErrorln("\n - Received invalid OTP", .{});
+                    Global.crash();
+                }
+            }
+            Output.prettyErrorln("\n - {s}", .{msg});
+        }
+    }
+
+    Global.crash();
+}
+
 pub const Registry = struct {
     pub const default_url = "https://registry.npmjs.org/";
     pub const default_url_hash = bun.Wyhash11.hash(0, strings.withoutTrailingSlash(default_url));
@@ -53,6 +258,9 @@ pub const Registry = struct {
         url_hash: u64,
         token: string = "",
 
+        // username and password combo, `user:pass`
+        user: string = "",
+
         pub fn hash(str: string) u64 {
             return String.Builder.stringHash(str);
         }
@@ -67,7 +275,7 @@ pub const Registry = struct {
             return name[1..];
         }
 
-        pub fn fromAPI(name: string, registry_: Api.NpmRegistry, allocator: std.mem.Allocator, env: *DotEnv.Loader) !Scope {
+        pub fn fromAPI(name: string, registry_: Api.NpmRegistry, allocator: std.mem.Allocator, env: *DotEnv.Loader) OOM!Scope {
             var registry = registry_;
 
             // Support $ENV_VAR for registry URLs
@@ -82,6 +290,7 @@ pub const Registry = struct {
 
             var url = URL.parse(registry.url);
             var auth: string = "";
+            var user: []u8 = "";
             var needs_normalize = false;
 
             if (registry.token.len == 0) {
@@ -176,12 +385,12 @@ pub const Registry = struct {
 
                     if (registry.username.len > 0 and registry.password.len > 0 and auth.len == 0) {
                         var output_buf = try allocator.alloc(u8, registry.username.len + registry.password.len + 1 + std.base64.standard.Encoder.calcSize(registry.username.len + registry.password.len + 1));
-                        var input_buf = output_buf[0 .. registry.username.len + registry.password.len + 1];
-                        @memcpy(input_buf[0..registry.username.len], registry.username);
-                        input_buf[registry.username.len] = ':';
-                        @memcpy(input_buf[registry.username.len + 1 ..][0..registry.password.len], registry.password);
-                        output_buf = output_buf[input_buf.len..];
-                        auth = std.base64.standard.Encoder.encode(output_buf, input_buf);
+                        user = output_buf[0 .. registry.username.len + registry.password.len + 1];
+                        @memcpy(user[0..registry.username.len], registry.username);
+                        user[registry.username.len] = ':';
+                        @memcpy(user[registry.username.len + 1 ..][0..registry.password.len], registry.password);
+                        output_buf = output_buf[user.len..];
+                        auth = std.base64.standard.Encoder.encode(output_buf, user);
                         break :outer;
                     }
                 }
@@ -207,6 +416,7 @@ pub const Registry = struct {
                 .url_hash = url_hash,
                 .token = registry.token,
                 .auth = auth,
+                .user = user,
             };
         }
     };
@@ -249,7 +459,7 @@ pub const Registry = struct {
 
         var newly_last_modified: string = "";
         var new_etag: string = "";
-        for (response.headers) |header| {
+        for (response.headers.list) |header| {
             if (!(header.name.len == "last-modified".len or header.name.len == "etag".len)) continue;
 
             const hashed = HTTPClient.hashHeaderName(header.name);
@@ -442,8 +652,8 @@ pub const OperatingSystem = enum(u16) {
     }
 
     const JSC = bun.JSC;
-    pub fn jsFunctionOperatingSystemIsMatch(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
-        const args = callframe.arguments(1);
+    pub fn jsFunctionOperatingSystemIsMatch(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+        const args = callframe.arguments_old(1);
         var operating_system = negatable(.none);
         var iter = args.ptr[0].arrayIterator(globalObject);
         while (iter.next()) |item| {
@@ -484,8 +694,8 @@ 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 {
-        const args = callframe.arguments(1);
+    pub fn jsFunctionLibcIsMatch(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+        const args = callframe.arguments_old(1);
         var libc = negatable(.none);
         var iter = args.ptr[0].arrayIterator(globalObject);
         while (iter.next()) |item| {
@@ -559,8 +769,8 @@ pub const Architecture = enum(u16) {
     }
 
     const JSC = bun.JSC;
-    pub fn jsFunctionArchitectureIsMatch(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
-        const args = callframe.arguments(1);
+    pub fn jsFunctionArchitectureIsMatch(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+        const args = callframe.arguments_old(1);
         var architecture = negatable(.none);
         var iter = args.ptr[0].arrayIterator(globalObject);
         while (iter.next()) |item| {
@@ -821,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;
 
@@ -874,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;
@@ -962,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 {
@@ -992,28 +1202,35 @@ pub const PackageManifest = struct {
         pub fn loadByFileID(allocator: std.mem.Allocator, scope: *const Registry.Scope, cache_dir: std.fs.Dir, file_id: u64) !?PackageManifest {
             var file_path_buf: [512 + 64]u8 = undefined;
             const file_name = try manifestFileName(&file_path_buf, file_id, scope);
-            var cache_file = cache_dir.openFileZ(
-                file_name,
-                .{ .mode = .read_only },
-            ) catch return null;
+            const cache_file = File.openat(cache_dir, file_name, bun.O.RDONLY, 0).unwrap() catch return null;
             defer cache_file.close();
-            return loadByFile(allocator, scope, cache_file);
+
+            delete: {
+                return loadByFile(allocator, scope, cache_file) catch break :delete orelse break :delete;
+            }
+
+            // delete the outdated/invalid manifest
+            try bun.sys.unlinkat(bun.toFD(cache_dir), file_name).unwrap();
+            return null;
         }
 
-        pub fn loadByFile(allocator: std.mem.Allocator, scope: *const Registry.Scope, manifest_file: std.fs.File) !?PackageManifest {
-            const bytes = try manifest_file.readToEndAllocOptions(
-                allocator,
-                std.math.maxInt(u32),
-                manifest_file.getEndPos() catch null,
-                @alignOf(u8),
-                null,
-            );
-
+        pub fn loadByFile(allocator: std.mem.Allocator, scope: *const Registry.Scope, manifest_file: File) !?PackageManifest {
+            const bytes = try manifest_file.readToEnd(allocator).unwrap();
             errdefer allocator.free(bytes);
+
             if (bytes.len < header_bytes.len) {
                 return null;
             }
-            return try readAll(bytes, scope);
+
+            const manifest = try readAll(bytes, scope) orelse return null;
+
+            if (manifest.versions.len == 0) {
+                // it's impossible to publish a package with zero versions, bust
+                // invalid entry
+                return null;
+            }
+
+            return manifest;
         }
 
         fn readAll(bytes: []const u8, scope: *const Registry.Scope) !?PackageManifest {
@@ -1066,11 +1283,10 @@ pub const PackageManifest = struct {
             return obj;
         }
 
-        pub fn jsParseManifest(global: *JSGlobalObject, callFrame: *CallFrame) JSValue {
-            const args = callFrame.arguments(2).slice();
+        pub fn jsParseManifest(global: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
+            const args = callFrame.arguments_old(2).slice();
             if (args.len < 2 or !args[0].isString() or !args[1].isString()) {
-                global.throw("expected manifest filename and registry string arguments", .{});
-                return .zero;
+                return global.throw("expected manifest filename and registry string arguments", .{});
             }
 
             const manifest_filename_str = args[0].toBunString(global);
@@ -1086,8 +1302,7 @@ pub const PackageManifest = struct {
             defer registry.deinit();
 
             const manifest_file = std.fs.openFileAbsolute(manifest_filename.slice(), .{}) catch |err| {
-                global.throw("failed to open manifest file \"{s}\": {s}", .{ manifest_filename.slice(), @errorName(err) });
-                return .zero;
+                return global.throw("failed to open manifest file \"{s}\": {s}", .{ manifest_filename.slice(), @errorName(err) });
             };
             defer manifest_file.close();
 
@@ -1102,14 +1317,12 @@ pub const PackageManifest = struct {
                 },
             };
 
-            const maybe_package_manifest = Serializer.loadByFile(bun.default_allocator, &scope, manifest_file) catch |err| {
-                global.throw("failed to load manifest file: {s}", .{@errorName(err)});
-                return .zero;
+            const maybe_package_manifest = Serializer.loadByFile(bun.default_allocator, &scope, File.from(manifest_file)) catch |err| {
+                return global.throw("failed to load manifest file: {s}", .{@errorName(err)});
             };
 
             const package_manifest: PackageManifest = maybe_package_manifest orelse {
-                global.throw("manifest is invalid ", .{});
-                return .zero;
+                return global.throw("manifest is invalid ", .{});
             };
 
             var buf: std.ArrayListUnmanaged(u8) = .{};
@@ -1117,22 +1330,13 @@ pub const PackageManifest = struct {
 
             // TODO: we can add more information. for now just versions is fine
 
-            writer.print("{{\"name\":\"{s}\",\"versions\":[", .{package_manifest.name()}) catch {
-                global.throwOutOfMemory();
-                return .zero;
-            };
+            try writer.print("{{\"name\":\"{s}\",\"versions\":[", .{package_manifest.name()});
 
             for (package_manifest.versions, 0..) |version, i| {
                 if (i == package_manifest.versions.len - 1)
-                    writer.print("\"{}\"]}}", .{version.fmt(package_manifest.string_buf)}) catch {
-                        global.throwOutOfMemory();
-                        return .zero;
-                    }
+                    try writer.print("\"{}\"]}}", .{version.fmt(package_manifest.string_buf)})
                 else
-                    writer.print("\"{}\",", .{version.fmt(package_manifest.string_buf)}) catch {
-                        global.throwOutOfMemory();
-                        return .zero;
-                    };
+                    try writer.print("\"{}\",", .{version.fmt(package_manifest.string_buf)});
             }
 
             var result = bun.String.fromUTF8(buf.items);
@@ -1280,7 +1484,7 @@ pub const PackageManifest = struct {
         defer bun.JSAst.Stmt.Data.Store.memory_allocator.?.pop();
         var arena = bun.ArenaAllocator.init(allocator);
         defer arena.deinit();
-        const json = json_parser.ParseJSONUTF8(
+        const json = JSON.parseUTF8(
             &source,
             log,
             arena.allocator(),
diff --git a/src/install/patch_install.zig b/src/install/patch_install.zig
index 946bedb2d3..3005a0c548 100644
--- a/src/install/patch_install.zig
+++ b/src/install/patch_install.zig
@@ -158,7 +158,7 @@ pub const PatchTask = struct {
         if (this.callback.apply.logger.errors > 0) {
             defer this.callback.apply.logger.deinit();
             Output.errGeneric("failed to apply patchfile ({s})", .{this.callback.apply.patchfilepath});
-            this.callback.apply.logger.printForLogLevel(Output.errorWriter()) catch {};
+            this.callback.apply.logger.print(Output.errorWriter()) catch {};
         }
     }
 
@@ -183,7 +183,7 @@ pub const PatchTask = struct {
             }
             if (calc_hash.logger.errors > 0) {
                 Output.prettyErrorln("\n\n", .{});
-                calc_hash.logger.printForLogLevel(Output.errorWriter()) catch {};
+                calc_hash.logger.print(Output.errorWriter()) catch {};
             }
             Output.flush();
             Global.crash();
@@ -222,6 +222,10 @@ pub const PatchTask = struct {
                         dep_id,
                         pkg,
                         this.callback.calc_hash.name_and_version_hash,
+                        switch (pkg.resolution.tag) {
+                            .npm => .allow_authorization,
+                            else => .no_authorization,
+                        },
                     ) orelse unreachable;
                     if (manager.getPreinstallState(pkg.meta.id) == .extract) {
                         manager.setPreinstallState(pkg.meta.id, manager.lockfile, .extracting);
@@ -277,20 +281,22 @@ pub const PatchTask = struct {
         )) {
             .result => |txt| txt,
             .err => |e| {
-                try log.addErrorFmtNoLoc(
+                try log.addErrorFmtOpts(
                     this.manager.allocator,
                     "failed to read patchfile: {}",
                     .{e.toSystemError()},
+                    .{},
                 );
                 return;
             },
         };
         defer this.manager.allocator.free(patchfile_txt);
         var patchfile = bun.patch.parsePatchFile(patchfile_txt) catch |e| {
-            try log.addErrorFmtNoLoc(
+            try log.addErrorFmtOpts(
                 this.manager.allocator,
                 "failed to parse patchfile: {s}",
                 .{@errorName(e)},
+                .{},
             );
             return;
         };
@@ -329,27 +335,30 @@ pub const PatchTask = struct {
         switch (pkg_install.installImpl(true, system_tmpdir, .copyfile, this.callback.apply.resolution.tag)) {
             .success => {},
             .fail => |reason| {
-                return try log.addErrorFmtNoLoc(
+                return try log.addErrorFmtOpts(
                     this.manager.allocator,
                     "{s} while executing step: {s}",
                     .{ @errorName(reason.err), reason.step.name() },
+                    .{},
                 );
             },
         }
 
-        var patch_pkg_dir = system_tmpdir.openDir(tempdir_name, .{}) catch |e| return try log.addErrorFmtNoLoc(
+        var patch_pkg_dir = system_tmpdir.openDir(tempdir_name, .{}) catch |e| return try log.addErrorFmtOpts(
             this.manager.allocator,
             "failed trying to open temporary dir to apply patch to package: {s}",
             .{@errorName(e)},
+            .{},
         );
         defer patch_pkg_dir.close();
 
         // 4. apply patch
         if (patchfile.apply(this.manager.allocator, bun.toFD(patch_pkg_dir.fd))) |e| {
-            return try log.addErrorFmtNoLoc(
+            return try log.addErrorFmtOpts(
                 this.manager.allocator,
                 "failed applying patch file: {}",
                 .{e},
+                .{},
             );
         }
 
@@ -367,7 +376,12 @@ pub const PatchTask = struct {
         )) {
             .result => |fd| fd,
             .err => |e| {
-                return try log.addErrorFmtNoLoc(this.manager.allocator, "failed adding bun tag: {}", .{e.withPath(buntagbuf[0 .. bun_tag_prefix.len + hashlen :0])});
+                return try log.addErrorFmtOpts(
+                    this.manager.allocator,
+                    "failed adding bun tag: {}",
+                    .{e.withPath(buntagbuf[0 .. bun_tag_prefix.len + hashlen :0])},
+                    .{},
+                );
             },
         };
         _ = bun.sys.close(buntagfd);
@@ -387,7 +401,12 @@ pub const PatchTask = struct {
             bun.toFD(this.callback.apply.cache_dir.fd),
             this.callback.apply.cache_dir_subpath,
             .{ .move_fallback = true },
-        ).asErr()) |e| return try log.addErrorFmtNoLoc(this.manager.allocator, "renaming changes to cache dir: {}", .{e.withPath(this.callback.apply.cache_dir_subpath)});
+        ).asErr()) |e| return try log.addErrorFmtOpts(
+            this.manager.allocator,
+            "renaming changes to cache dir: {}",
+            .{e.withPath(this.callback.apply.cache_dir_subpath)},
+            .{},
+        );
     }
 
     pub fn calcHash(this: *PatchTask) ?u64 {
diff --git a/src/install/repository.zig b/src/install/repository.zig
index 2069d640c4..848731b7cb 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/resolvers/folder_resolver.zig b/src/install/resolvers/folder_resolver.zig
index 43ed4bc7a0..30ff41f9c3 100644
--- a/src/install/resolvers/folder_resolver.zig
+++ b/src/install/resolvers/folder_resolver.zig
@@ -177,6 +177,7 @@ pub const FolderResolution = union(Tag) {
 
             try package.parseWithJSON(
                 manager.lockfile,
+                manager,
                 manager.allocator,
                 manager.log,
                 json.source,
@@ -207,6 +208,7 @@ pub const FolderResolution = union(Tag) {
 
             try package.parse(
                 manager.lockfile,
+                manager,
                 manager.allocator,
                 manager.log,
                 source,
diff --git a/src/install/semver.zig b/src/install/semver.zig
index ef93a68be5..fc90129b67 100644
--- a/src/install/semver.zig
+++ b/src/install/semver.zig
@@ -2393,13 +2393,11 @@ pub const Query = struct {
         };
     };
 
-    const ParseError = error{OutOfMemory};
-
     pub fn parse(
         allocator: Allocator,
         input: string,
         sliced: SlicedString,
-    ) ParseError!Group {
+    ) bun.OOM!Group {
         var i: usize = 0;
         var list = Group{
             .allocator = allocator,
@@ -2651,16 +2649,15 @@ 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());
         const allocator = stack_fallback.get();
 
-        const arguments = callFrame.arguments(2).slice();
+        const arguments = callFrame.arguments_old(2).slice();
         if (arguments.len < 2) {
-            globalThis.throw("Expected two arguments", .{});
-            return .zero;
+            return globalThis.throw("Expected two arguments", .{});
         }
 
         const left_arg = arguments[0];
@@ -2681,13 +2678,11 @@ pub const SemverObject = struct {
         const right_result = Version.parse(SlicedString.init(right.slice(), right.slice()));
 
         if (!left_result.valid) {
-            globalThis.throw("Invalid SemVer: {s}\n", .{left.slice()});
-            return .zero;
+            return globalThis.throw("Invalid SemVer: {s}\n", .{left.slice()});
         }
 
         if (!right_result.valid) {
-            globalThis.throw("Invalid SemVer: {s}\n", .{right.slice()});
-            return .zero;
+            return globalThis.throw("Invalid SemVer: {s}\n", .{right.slice()});
         }
 
         const left_version = left_result.version.max();
@@ -2700,26 +2695,22 @@ pub const SemverObject = struct {
         };
     }
 
-    pub fn satisfies(
-        globalThis: *JSC.JSGlobalObject,
-        callFrame: *JSC.CallFrame,
-    ) JSC.JSValue {
+    pub fn satisfies(globalThis: *JSC.JSGlobalObject, callFrame: *JSC.CallFrame) 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());
         const allocator = stack_fallback.get();
 
-        const arguments = callFrame.arguments(2).slice();
+        const arguments = callFrame.arguments_old(2).slice();
         if (arguments.len < 2) {
-            globalThis.throw("Expected two arguments", .{});
-            return .zero;
+            return globalThis.throw("Expected two arguments", .{});
         }
 
         const left_arg = arguments[0];
         const right_arg = arguments[1];
 
-        const left_string = left_arg.toStringOrNull(globalThis) orelse return .false;
-        const right_string = right_arg.toStringOrNull(globalThis) orelse return .false;
+        const left_string = left_arg.toStringOrNull(globalThis) orelse return .zero;
+        const right_string = right_arg.toStringOrNull(globalThis) orelse return .zero;
 
         const left = left_string.toSlice(globalThis, allocator);
         defer left.deinit();
@@ -2736,18 +2727,11 @@ pub const SemverObject = struct {
 
         const left_version = left_result.version.min();
 
-        const right_group = Query.parse(
+        const right_group = try Query.parse(
             allocator,
             right.slice(),
             SlicedString.init(right.slice(), right.slice()),
-        ) catch |err| {
-            switch (err) {
-                error.OutOfMemory => {
-                    globalThis.throwOutOfMemory();
-                    return .zero;
-                },
-            }
-        };
+        );
         defer right_group.deinit();
 
         const right_version = right_group.getExactVersion();
diff --git a/src/io/io_darwin.cpp b/src/io/io_darwin.cpp
index 00cc31dd75..d3636801f9 100644
--- a/src/io/io_darwin.cpp
+++ b/src/io/io_darwin.cpp
@@ -10,120 +10,124 @@
 #include "wtf/Assertions.h"
 
 extern "C" mach_port_t io_darwin_create_machport(uint64_t wakeup, int32_t fd,
-                                                 void *wakeup_buffer_,
-                                                 size_t nbytes) {
+    void* wakeup_buffer_,
+    size_t nbytes)
+{
 
-  mach_port_t port;
-  mach_port_t self = mach_task_self();
-  kern_return_t kr = mach_port_allocate(self, MACH_PORT_RIGHT_RECEIVE, &port);
+    mach_port_t port;
+    mach_port_t self = mach_task_self();
+    kern_return_t kr = mach_port_allocate(self, MACH_PORT_RIGHT_RECEIVE, &port);
 
-  if (UNLIKELY(kr != KERN_SUCCESS)) {
-    return 0;
-  }
-
-  // Insert a send right into the port since we also use this to send
-  kr = mach_port_insert_right(self, port, port, MACH_MSG_TYPE_MAKE_SEND);
-  if (UNLIKELY(kr != KERN_SUCCESS)) {
-    return 0;
-  }
-
-  // Modify the port queue size to be 1 because we are only
-  // using it for notifications and not for any other purpose.
-  mach_port_limits_t limits = {.mpl_qlimit = 1};
-  kr = mach_port_set_attributes(self, port, MACH_PORT_LIMITS_INFO,
-                                (mach_port_info_t)&limits,
-                                MACH_PORT_LIMITS_INFO_COUNT);
-
-  if (UNLIKELY(kr != KERN_SUCCESS)) {
-    return 0;
-  }
-
-  // Configure the event to directly receive the Mach message as part of the
-  // kevent64() call.
-  kevent64_s event{};
-  event.ident = port;
-  event.filter = EVFILT_MACHPORT;
-  event.flags = EV_ADD | EV_ENABLE;
-  event.fflags = MACH_RCV_MSG | MACH_RCV_OVERWRITE;
-  event.ext[0] = reinterpret_cast<uint64_t>(wakeup_buffer_);
-  event.ext[1] = nbytes;
-
-  while (true) {
-    int rv = kevent64(fd, &event, 1, NULL, 0, 0, NULL);
-    if (rv == -1) {
-      if (errno == EINTR) {
-        continue;
-      }
-
-      return 0;
+    if (UNLIKELY(kr != KERN_SUCCESS)) {
+        return 0;
     }
 
-    return port;
-  }
+    // Insert a send right into the port since we also use this to send
+    kr = mach_port_insert_right(self, port, port, MACH_MSG_TYPE_MAKE_SEND);
+    if (UNLIKELY(kr != KERN_SUCCESS)) {
+        return 0;
+    }
+
+    // Modify the port queue size to be 1 because we are only
+    // using it for notifications and not for any other purpose.
+    mach_port_limits_t limits = { .mpl_qlimit = 1 };
+    kr = mach_port_set_attributes(self, port, MACH_PORT_LIMITS_INFO,
+        (mach_port_info_t)&limits,
+        MACH_PORT_LIMITS_INFO_COUNT);
+
+    if (UNLIKELY(kr != KERN_SUCCESS)) {
+        return 0;
+    }
+
+    // Configure the event to directly receive the Mach message as part of the
+    // kevent64() call.
+    kevent64_s event {};
+    event.ident = port;
+    event.filter = EVFILT_MACHPORT;
+    event.flags = EV_ADD | EV_ENABLE;
+    event.fflags = MACH_RCV_MSG | MACH_RCV_OVERWRITE;
+    event.ext[0] = reinterpret_cast<uint64_t>(wakeup_buffer_);
+    event.ext[1] = nbytes;
+
+    while (true) {
+        int rv = kevent64(fd, &event, 1, NULL, 0, 0, NULL);
+        if (rv == -1) {
+            if (errno == EINTR) {
+                continue;
+            }
+
+            return 0;
+        }
+
+        return port;
+    }
 }
 
 extern "C" bool getaddrinfo_send_reply(mach_port_t port,
-                                       void (*sendReply)(void *)) {
-  mach_msg_empty_rcv_t msg;
-  mach_msg_return_t status;
+    void (*sendReply)(void*))
+{
+    mach_msg_empty_rcv_t msg;
+    mach_msg_return_t status;
 
-  status = mach_msg(&msg.header, MACH_RCV_MSG, 0, sizeof(msg), port,
-                    MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
-  if (status != MACH_MSG_SUCCESS) {
-    return false;
-  }
-  sendReply(&msg);
-  return true;
+    status = mach_msg(&msg.header, MACH_RCV_MSG, 0, sizeof(msg), port,
+        MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
+    if (status != MACH_MSG_SUCCESS) {
+        return false;
+    }
+    sendReply(&msg);
+    return true;
 }
 
-extern "C" bool io_darwin_schedule_wakeup(mach_port_t waker) {
-  mach_msg_header_t msg = {
-      .msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0),
-      .msgh_size = sizeof(mach_msg_header_t),
-      .msgh_remote_port = waker,
-      .msgh_local_port = MACH_PORT_NULL,
-      .msgh_voucher_port = 0,
-      .msgh_id = 0,
-  };
+extern "C" bool io_darwin_schedule_wakeup(mach_port_t waker)
+{
+    mach_msg_header_t msg = {
+        .msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0),
+        .msgh_size = sizeof(mach_msg_header_t),
+        .msgh_remote_port = waker,
+        .msgh_local_port = MACH_PORT_NULL,
+        .msgh_voucher_port = 0,
+        .msgh_id = 0,
+    };
 
-  mach_msg_return_t kr = mach_msg(&msg, MACH_SEND_MSG | MACH_SEND_TIMEOUT,
-                                  msg.msgh_size, 0, MACH_PORT_NULL,
-                                  0, // Fail instantly if the port is full
-                                  MACH_PORT_NULL);
+    mach_msg_return_t kr = mach_msg(&msg, MACH_SEND_MSG | MACH_SEND_TIMEOUT,
+        msg.msgh_size, 0, MACH_PORT_NULL,
+        0, // Fail instantly if the port is full
+        MACH_PORT_NULL);
 
-  switch (kr) {
-  case MACH_MSG_SUCCESS: {
-    return true;
-  }
+    switch (kr) {
+    case MACH_MSG_SUCCESS: {
+        return true;
+    }
 
-  // This means that the send would've blocked because the
-  // queue is full. We assume success because the port is full.
-  case MACH_SEND_TIMED_OUT: {
-    return true;
-  }
+    // This means that the send would've blocked because the
+    // queue is full. We assume success because the port is full.
+    case MACH_SEND_TIMED_OUT: {
+        return true;
+    }
 
-  // No space means it will wake up.
-  case MACH_SEND_NO_BUFFER: {
-    return true;
-  }
+    // No space means it will wake up.
+    case MACH_SEND_NO_BUFFER: {
+        return true;
+    }
 
-  default: {
-    ASSERT_NOT_REACHED_WITH_MESSAGE("mach_msg failed with %x", kr);
-    return false;
-  }
-  }
+    default: {
+        ASSERT_NOT_REACHED_WITH_MESSAGE("mach_msg failed with %x", kr);
+        return false;
+    }
+    }
 }
 
 #else
 
 // stub out these symbols
 extern "C" int io_darwin_create_machport(unsigned long long wakeup, int fd,
-                                         void *wakeup_buffer_,
-                                         unsigned long long nbytes) {
-  return 0;
+    void* wakeup_buffer_,
+    unsigned long long nbytes)
+{
+    return 0;
 }
 
 // stub out these symbols
-extern "C" bool io_darwin_schedule_wakeup(void *waker) { return false; }
+extern "C" bool io_darwin_schedule_wakeup(void* waker) { return false; }
 
-#endif
\ No newline at end of file
+#endif
diff --git a/src/js/README.md b/src/js/README.md
index f6a1931ffe..5dbbcf0d1b 100644
--- a/src/js/README.md
+++ b/src/js/README.md
@@ -1,6 +1,6 @@
 # JS Modules
 
-**TLDR**: If anything here changes, re-run `make js`. If you add/remove files, `make regenerate-bindings`.
+**TLDR**: If anything here changes, re-run `bun run build`.
 
 - `./node` contains all `node:*` modules
 - `./bun` contains all `bun:*` modules
@@ -81,9 +81,9 @@ object->putDirectBuiltinFunction(
 
 ## Building
 
-Run `make js` to bundle all the builtins. The output is placed in `src/js/out/{modules,functions}/`, where these files are loaded dynamically by `bun-debug` (an exact filepath is inlined into the binary pointing at where you cloned bun, so moving the binary to another machine may not work). In a release build, these get minified and inlined into the binary (Please commit those generated headers).
+Run `bun run build` to bundle all the builtins. The output is placed in `build/debug/js`, where these files are loaded dynamically by `bun-debug` (an exact filepath is inlined into the binary pointing at where you cloned bun, so moving the binary to another machine may not work). In a release build, these get minified and inlined into the binary (Please commit those generated headers).
 
-If you change the list of files or functions, you will have to run `make regenerate-bindings`, but otherwise any change can be done with just `make js`.
+If you change the list of files or functions, you will have to run `bun run build`.
 
 ## Notes on how the build process works
 
diff --git a/src/js/builtins.d.ts b/src/js/builtins.d.ts
index 12d7d7e7f9..2c07c8aa0e 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. */
@@ -546,3 +549,16 @@ declare interface Error {
  */
 declare function $ERR_INVALID_ARG_TYPE(argName: string, expectedType: string, actualValue: string): TypeError;
 declare function $ERR_INVALID_ARG_TYPE(argName: string, expectedTypes: any[], actualValue: string): TypeError;
+/**
+ * Convert a function to a class-like object.
+ *
+ * This does:
+ * - Sets the name of the function to the given name
+ * - Sets .prototype to Object.create(base?.prototype, { constructor: { value: fn } })
+ * - Calls Object.setPrototypeOf(fn, base ?? Function.prototype)
+ *
+ * @param fn - The function to convert to a class
+ * @param name - The name of the class
+ * @param base - The base class to inherit from
+ */
+declare function $toClass(fn: Function, name: string, base?: Function | undefined | null);
diff --git a/src/js/builtins/Bake.ts b/src/js/builtins/Bake.ts
new file mode 100644
index 0000000000..9faf064bf8
--- /dev/null
+++ b/src/js/builtins/Bake.ts
@@ -0,0 +1,151 @@
+//! JS code for bake
+/// <reference path="../../bake/bake.d.ts" />
+import type { Bake } from "bun";
+
+type FrameworkPrerender = Bake.ServerEntryPoint["prerender"];
+type FrameworkGetParams = Bake.ServerEntryPoint["getParams"];
+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 renderRoutesForProdStatic(
+  outBase: string,
+  allServerFiles: string[],
+  // Indexed by router type index
+  renderStatic: FrameworkPrerender[],
+  getParams: FrameworkGetParams[],
+  clientEntryUrl: string[],
+  // Indexed by route index
+  patterns: string[],
+  files: FileIndex[][],
+  typeAndFlags: TypeAndFlags[],
+  sourceRouteFiles: string[],
+  paramInformation: Array<null | string[]>,
+  styles: string[][],
+): Promise<void> {
+  $debug({
+    outBase,
+    allServerFiles,
+    renderStatic,
+    clientEntryUrl,
+    patterns,
+    files,
+    typeAndFlags,
+    sourceRouteFiles,
+    paramInformation,
+    styles,
+  });
+  const { join: pathJoin } = require("node:path");
+
+  let loadedModules = new Array(allServerFiles.length);
+
+  async function doGenerateRoute(
+    type: number,
+    i: number,
+    layouts: any[],
+    pageModule: any,
+    params: Record<string, string> | null,
+  ) {
+    // Call the framework's rendering function
+    const callback = renderStatic[type];
+    $assert(callback != null && $isCallable(callback));
+    let client = clientEntryUrl[type];
+    const results = await callback({
+      modules: client ? [client] : [],
+      modulepreload: [],
+      styles: styles[i],
+      layouts,
+      pageModule,
+      params,
+    } 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]) => {
+        if (params != null) {
+          $assert(patterns[i].includes(`:`));
+          // replace the :paramName part of patterns[i] with the value of params[paramName]
+          // use a regex in replace with a callback
+          const newKey = patterns[i].replace(/:(\w+)/g, (_, p1) => params[p1]);
+          return Bun.write(pathJoin(outBase, newKey + key), value);
+        }
+        return Bun.write(pathJoin(outBase, patterns[i] + key), value);
+      }),
+    );
+  }
+
+  function callRouteGenerator(
+    type: number,
+    i: number,
+    layouts: any[],
+    pageModule: any,
+    params: Record<string, string>,
+  ) {
+    for (const param of paramInformation[i]!) {
+      if (!params[param]) {
+        throw new Error(`Missing param ${param} for route ${JSON.stringify(sourceRouteFiles[i])}`);
+      }
+    }
+    return doGenerateRoute(type, i, layouts, pageModule, params);
+  }
+
+  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[id]));
+        layouts = [];
+      }
+
+      if (paramInformation[i] != null) {
+        const getParam = getParams[type];
+        $assert(getParam != null && $isCallable(getParam));
+        const paramGetter: Bake.GetParamIterator = await getParam({
+          pageModule,
+          layouts,
+        });
+        if (paramGetter[Symbol.asyncIterator] != undefined) {
+          for await (const params of paramGetter) {
+            callRouteGenerator(type, i, layouts, pageModule, params);
+          }
+        } else if (paramGetter[Symbol.iterator] != undefined) {
+          for (const params of paramGetter) {
+            callRouteGenerator(type, i, layouts, pageModule, params);
+          }
+        } else {
+          await Promise.all(
+            paramGetter.pages.map(params => {
+              callRouteGenerator(type, i, layouts, pageModule, params);
+            }),
+          );
+        }
+      } else {
+        await doGenerateRoute(type, i, layouts, pageModule, null);
+      }
+    }),
+  );
+}
diff --git a/src/js/builtins/BunBuiltinNames.h b/src/js/builtins/BunBuiltinNames.h
index fbec2c56bd..0c04b13631 100644
--- a/src/js/builtins/BunBuiltinNames.h
+++ b/src/js/builtins/BunBuiltinNames.h
@@ -21,7 +21,6 @@ namespace WebCore {
 using namespace JSC;
 
 #define BUN_COMMON_PRIVATE_IDENTIFIERS_EACH_PROPERTY_NAME(macro) \
-    macro(__esModule) \
     macro(_events) \
     macro(abortAlgorithm) \
     macro(AbortSignal) \
@@ -82,7 +81,6 @@ using namespace JSC;
     macro(encoding) \
     macro(end) \
     macro(errno) \
-    macro(makeErrorWithCode) \
     macro(errorSteps) \
     macro(evaluateCommonJSModule) \
     macro(evaluated) \
@@ -135,6 +133,7 @@ using namespace JSC;
     macro(localStreams) \
     macro(main) \
     macro(makeDOMException) \
+    macro(makeErrorWithCode) \
     macro(makeGetterTypeError) \
     macro(makeThisTypeError) \
     macro(method) \
@@ -153,8 +152,8 @@ using namespace JSC;
     macro(password) \
     macro(patch) \
     macro(path) \
-    macro(paths) \
     macro(pathname) \
+    macro(paths) \
     macro(pause) \
     macro(pendingAbortRequest) \
     macro(pendingPullIntos) \
@@ -228,6 +227,7 @@ using namespace JSC;
     macro(textEncoderStreamEncoder) \
     macro(TextEncoderStreamEncoder) \
     macro(textEncoderStreamTransform) \
+    macro(toClass) \
     macro(toNamespacedPath) \
     macro(trace) \
     macro(transformAlgorithm) \
@@ -254,6 +254,7 @@ using namespace JSC;
     macro(writeRequests) \
     macro(writing) \
     macro(written) \
+    macro(napiDlopenHandle) \
     BUN_ADDITIONAL_BUILTIN_NAMES(macro)
 // --- END of BUN_COMMON_PRIVATE_IDENTIFIERS_EACH_PROPERTY_NAME ---
 
diff --git a/src/js/builtins/BundlerPlugin.ts b/src/js/builtins/BundlerPlugin.ts
index db78902f2d..ed2c5e653b 100644
--- a/src/js/builtins/BundlerPlugin.ts
+++ b/src/js/builtins/BundlerPlugin.ts
@@ -1,43 +1,42 @@
 import type {
-  AnyFunction,
   BuildConfig,
   BunPlugin,
   OnLoadCallback,
-  OnLoadResultObject,
-  OnLoadResultSourceCode,
   OnResolveCallback,
   PluginBuilder,
   PluginConstraints,
 } from "bun";
+type AnyFunction = (...args: any[]) => any;
 
-// This API expects 4 functions:
-// It should be generic enough to reuse for Bun.plugin() eventually, too.
 interface BundlerPlugin {
   onLoad: Map<string, [RegExp, OnLoadCallback][]>;
   onResolve: Map<string, [RegExp, OnResolveCallback][]>;
+  /** Binding to `JSBundlerPlugin__onLoadAsync` */
   onLoadAsync(
     internalID,
     sourceCode: string | Uint8Array | ArrayBuffer | DataView | null,
     loaderKey: number | null,
   ): void;
+  /** Binding to `JSBundlerPlugin__onResolveAsync` */
   onResolveAsync(internalID, a, b, c): void;
-  addError(internalID, error, number): void;
+  /** Binding to `JSBundlerPlugin__addError` */
+  addError(internalID: number, error: any, which: number): void;
   addFilter(filter, namespace, number): void;
+  generateDeferPromise(id: number): Promise<void>;
+  promises: Array<Promise<any>> | undefined;
 }
 
 // Extra types
 type Setup = BunPlugin["setup"];
 type MinifyObj = Exclude<BuildConfig["minify"], boolean>;
 interface BuildConfigExt extends BuildConfig {
-  // we support esbuild-style entryPoints
+  // we support esbuild-style 'entryPoints' capitalization
   entryPoints?: string[];
   // plugins is guaranteed to not be null
   plugins: BunPlugin[];
 }
 interface PluginBuilderExt extends PluginBuilder {
-  // these functions aren't implemented yet, so we dont publicly expose them
   resolve: AnyFunction;
-  onStart: AnyFunction;
   onEnd: AnyFunction;
   onDispose: AnyFunction;
   // we partially support initialOptions. it's read-only and a subset of
@@ -47,17 +46,44 @@ interface PluginBuilderExt extends PluginBuilder {
   esbuild: any;
 }
 
-export function runSetupFunction(this: BundlerPlugin, setup: Setup, config: BuildConfigExt) {
+type BeforeOnParseExternal = unknown;
+
+export function runSetupFunction(
+  this: BundlerPlugin,
+  setup: Setup,
+  config: BuildConfigExt,
+  promises: Array<Promise<any>> | undefined,
+  is_last: boolean,
+  isBake: boolean,
+) {
+  this.promises = promises;
   var onLoadPlugins = new Map<string, [RegExp, AnyFunction][]>();
   var onResolvePlugins = new Map<string, [RegExp, AnyFunction][]>();
+  var onBeforeParsePlugins = new Map<
+    string,
+    [RegExp, napiModule: unknown, symbol: string, external?: undefined | unknown][]
+  >();
 
-  function validate(filterObject: PluginConstraints, callback, map) {
+  function validate(filterObject: PluginConstraints, callback, map, symbol, external) {
     if (!filterObject || !$isObject(filterObject)) {
       throw new TypeError('Expected an object with "filter" RegExp');
     }
 
-    if (!callback || !$isCallable(callback)) {
-      throw new TypeError("callback must be a function");
+    let isOnBeforeParse = false;
+    if (map === onBeforeParsePlugins) {
+      isOnBeforeParse = true;
+      // TODO: how to check if it a napi module here?
+      if (!callback) {
+        throw new TypeError("onBeforeParse `napiModule` must be a Napi module");
+      }
+
+      if (typeof symbol !== "string") {
+        throw new TypeError("onBeforeParse `symbol` must be a string");
+      }
+    } else {
+      if (!callback || !$isCallable(callback)) {
+        throw new TypeError("lmao callback must be a function");
+      }
     }
 
     var { filter, namespace = "file" } = filterObject;
@@ -85,23 +111,49 @@ export function runSetupFunction(this: BundlerPlugin, setup: Setup, config: Buil
     var callbacks = map.$get(namespace);
 
     if (!callbacks) {
-      map.$set(namespace, [[filter, callback]]);
+      map.$set(namespace, [isOnBeforeParse ? [filter, callback, symbol, external] : [filter, callback]]);
     } else {
-      $arrayPush(callbacks, [filter, callback]);
+      $arrayPush(callbacks, isOnBeforeParse ? [filter, callback, symbol, external] : [filter, callback]);
     }
   }
 
   function onLoad(filterObject, callback) {
-    validate(filterObject, callback, onLoadPlugins);
+    validate(filterObject, callback, onLoadPlugins, undefined, undefined);
   }
 
   function onResolve(filterObject, callback) {
-    validate(filterObject, callback, onResolvePlugins);
+    validate(filterObject, callback, onResolvePlugins, undefined, undefined);
+  }
+
+  function onBeforeParse(
+    filterObject,
+    { napiModule, external, symbol }: { napiModule: unknown; symbol: string; external?: undefined | unknown },
+  ) {
+    validate(filterObject, napiModule, onBeforeParsePlugins, symbol, external);
+  }
+
+  const self = this;
+  function onStart(callback) {
+    if(isBake) {
+      throw new TypeError("onStart() is not supported in Bake yet");
+    }
+    if (!$isCallable(callback)) {
+      throw new TypeError("callback must be a function");
+    }
+
+    const ret = callback();
+    if ($isPromise(ret)) {
+      if (($getPromiseInternalField(ret, $promiseFieldFlags) & $promiseStateMask) != $promiseStateFulfilled) {
+        self.promises ??= [];
+        self.promises.push(ret);
+      }
+    }
   }
 
   const processSetupResult = () => {
     var anyOnLoad = false,
-      anyOnResolve = false;
+      anyOnResolve = false,
+      anyOnBeforeParse = false;
 
     for (var [namespace, callbacks] of onLoadPlugins.entries()) {
       for (var [filter] of callbacks) {
@@ -117,6 +169,13 @@ export function runSetupFunction(this: BundlerPlugin, setup: Setup, config: Buil
       }
     }
 
+    for (let [namespace, callbacks] of onBeforeParsePlugins.entries()) {
+      for (let [filter, addon, symbol, external] of callbacks) {
+        this.onBeforeParse(filter, namespace, addon, symbol, external);
+        anyOnBeforeParse = true;
+      }
+    }
+
     if (anyOnResolve) {
       var onResolveObject = this.onResolve;
       if (!onResolveObject) {
@@ -151,7 +210,11 @@ export function runSetupFunction(this: BundlerPlugin, setup: Setup, config: Buil
       }
     }
 
-    return anyOnLoad || anyOnResolve;
+    if (is_last) {
+      this.promises = undefined;
+    }
+
+    return this.promises;
   };
 
   var setupResult = setup({
@@ -160,7 +223,8 @@ export function runSetupFunction(this: BundlerPlugin, setup: Setup, config: Buil
     onEnd: notImplementedIssueFn(2771, "On-end callbacks"),
     onLoad,
     onResolve,
-    onStart: notImplementedIssueFn(2771, "On-start callbacks"),
+    onBeforeParse,
+    onStart,
     resolve: notImplementedIssueFn(2771, "build.resolve()"),
     module: () => {
       throw new TypeError("module() is not supported in Bun.build() yet. Only via Bun.plugin() at runtime");
@@ -184,10 +248,21 @@ export function runSetupFunction(this: BundlerPlugin, setup: Setup, config: Buil
     if ($getPromiseInternalField(setupResult, $promiseFieldFlags) & $promiseStateFulfilled) {
       setupResult = $getPromiseInternalField(setupResult, $promiseFieldReactionsOrResult);
     } else {
-      return setupResult.$then(processSetupResult);
+      return setupResult.$then(() => {
+        if (is_last && self.promises !== undefined && self.promises.length > 0) {
+          const awaitAll = Promise.all(self.promises);
+          return awaitAll.$then(processSetupResult);
+        }
+        return processSetupResult();
+      });
     }
   }
 
+  if (is_last && this.promises !== undefined && this.promises.length > 0) {
+    const awaitAll = Promise.all(this.promises);
+    return awaitAll.$then(processSetupResult);
+  }
+
   return processSetupResult();
 }
 
@@ -209,7 +284,7 @@ export function runOnResolvePlugins(this: BundlerPlugin, specifier, inputNamespa
           path: inputPath,
           importer,
           namespace: inputNamespace,
-          // resolveDir
+          resolveDir: inputNamespace === "file" ? require("node:path").dirname(importer) : undefined,
           kind,
           // pluginData
         });
@@ -295,11 +370,12 @@ export function runOnResolvePlugins(this: BundlerPlugin, specifier, inputNamespa
   }
 }
 
-export function runOnLoadPlugins(this: BundlerPlugin, internalID, path, namespace, defaultLoaderId) {
+export function runOnLoadPlugins(this: BundlerPlugin, internalID, path, namespace, defaultLoaderId, isServerSide: boolean) {
   const LOADERS_MAP = $LoaderLabelToId;
   const loaderName = $LoaderIdToLabel[defaultLoaderId];
 
-  var promiseResult = (async (internalID, path, namespace, defaultLoader) => {
+  const generateDefer = () => this.generateDeferPromise(internalID);
+  var promiseResult = (async (internalID, path, namespace, isServerSide, defaultLoader, generateDefer) => {
     var results = this.onLoad.$get(namespace);
     if (!results) {
       this.onLoadAsync(internalID, null, null);
@@ -314,6 +390,8 @@ export function runOnLoadPlugins(this: BundlerPlugin, internalID, path, namespac
           // suffix
           // pluginData
           loader: defaultLoader,
+          defer: generateDefer,
+          side: isServerSide ? "server" : "client",
         });
 
         while (
@@ -332,7 +410,19 @@ export function runOnLoadPlugins(this: BundlerPlugin, internalID, path, namespac
           continue;
         }
 
-        var { contents, loader = defaultLoader } = result as OnLoadResultSourceCode & OnLoadResultObject;
+        var { contents, loader = defaultLoader } = result as any;
+        if ((loader as any) === 'object') {
+          if (!('exports' in result)) {
+            throw new TypeError('onLoad plugin returning loader: "object" must have "exports" property');
+          }
+          try {
+            contents = JSON.stringify(result.exports);
+            loader = 'json';
+          } catch (e) {
+            throw new TypeError('When using Bun.build, onLoad plugin must return a JSON-serializable object: ' + e) ;
+          }
+        }
+
         if (!(typeof contents === "string") && !$isTypedArrayView(contents)) {
           throw new TypeError('onLoad plugins must return an object with "contents" as a string or Uint8Array');
         }
@@ -346,14 +436,14 @@ export function runOnLoadPlugins(this: BundlerPlugin, internalID, path, namespac
           throw new TypeError(`Loader ${loader} is not supported.`);
         }
 
-        this.onLoadAsync(internalID, contents, chosenLoader);
+        this.onLoadAsync(internalID, contents as any, chosenLoader);
         return null;
       }
     }
 
     this.onLoadAsync(internalID, null, null);
     return null;
-  })(internalID, path, namespace, loaderName);
+  })(internalID, path, namespace, isServerSide, loaderName, generateDefer);
 
   while (
     promiseResult &&
diff --git a/src/js/builtins/JSBufferConstructor.ts b/src/js/builtins/JSBufferConstructor.ts
index 69615d8dcc..2c0c09e982 100644
--- a/src/js/builtins/JSBufferConstructor.ts
+++ b/src/js/builtins/JSBufferConstructor.ts
@@ -29,6 +29,12 @@ export function from(items) {
       }
     }
   }
+  if (typeof items === "object") {
+    const data = items.data;
+    if (items.type === "Buffer" && Array.isArray(data)) {
+      return new $Buffer(data);
+    }
+  }
 
   var arrayLike = $toObject(
     items,
diff --git a/src/js/builtins/JSBufferPrototype.ts b/src/js/builtins/JSBufferPrototype.ts
index 986e0992ba..99ca59405a 100644
--- a/src/js/builtins/JSBufferPrototype.ts
+++ b/src/js/builtins/JSBufferPrototype.ts
@@ -175,48 +175,87 @@ export function readBigUInt64BE(this: BufferExt, offset) {
 }
 
 export function writeInt8(this: BufferExt, value, offset) {
-  (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength)).setInt8(offset, value);
+  (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength)).setInt8(
+    offset === undefined ? (offset = 0) : offset,
+    value,
+  );
   return offset + 1;
 }
 export function writeUInt8(this: BufferExt, value, offset) {
-  (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength)).setUint8(offset, value);
+  (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength)).setUint8(
+    offset === undefined ? (offset = 0) : offset,
+    value,
+  );
   return offset + 1;
 }
 export function writeInt16LE(this: BufferExt, value, offset) {
-  (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength)).setInt16(offset, value, true);
+  (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength)).setInt16(
+    offset === undefined ? (offset = 0) : offset,
+    value,
+    true,
+  );
   return offset + 2;
 }
 export function writeInt16BE(this: BufferExt, value, offset) {
-  (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength)).setInt16(offset, value, false);
+  (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength)).setInt16(
+    offset === undefined ? (offset = 0) : offset,
+    value,
+    false,
+  );
   return offset + 2;
 }
 export function writeUInt16LE(this: BufferExt, value, offset) {
-  (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength)).setUint16(offset, value, true);
+  (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength)).setUint16(
+    offset === undefined ? (offset = 0) : offset,
+    value,
+    true,
+  );
   return offset + 2;
 }
 export function writeUInt16BE(this: BufferExt, value, offset) {
-  (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength)).setUint16(offset, value, false);
+  (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength)).setUint16(
+    offset === undefined ? (offset = 0) : offset,
+    value,
+    false,
+  );
   return offset + 2;
 }
 export function writeInt32LE(this: BufferExt, value, offset) {
-  (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength)).setInt32(offset, value, true);
+  (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength)).setInt32(
+    offset === undefined ? (offset = 0) : offset,
+    value,
+    true,
+  );
   return offset + 4;
 }
 export function writeInt32BE(this: BufferExt, value, offset) {
-  (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength)).setInt32(offset, value, false);
+  (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength)).setInt32(
+    offset === undefined ? (offset = 0) : offset,
+    value,
+    false,
+  );
   return offset + 4;
 }
 export function writeUInt32LE(this: BufferExt, value, offset) {
-  (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength)).setUint32(offset, value, true);
+  (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength)).setUint32(
+    offset === undefined ? (offset = 0) : offset,
+    value,
+    true,
+  );
   return offset + 4;
 }
 export function writeUInt32BE(this: BufferExt, value, offset) {
-  (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength)).setUint32(offset, value, false);
+  (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength)).setUint32(
+    offset === undefined ? (offset = 0) : offset,
+    value,
+    false,
+  );
   return offset + 4;
 }
 
 export function writeIntLE(this: BufferExt, value, offset, byteLength) {
   const view = (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength));
+
   switch (byteLength) {
     case 1: {
       view.setInt8(offset, value);
@@ -253,6 +292,7 @@ export function writeIntLE(this: BufferExt, value, offset, byteLength) {
 }
 export function writeIntBE(this: BufferExt, value, offset, byteLength) {
   const view = (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength));
+
   switch (byteLength) {
     case 1: {
       view.setInt8(offset, value);
@@ -289,6 +329,7 @@ export function writeIntBE(this: BufferExt, value, offset, byteLength) {
 }
 export function writeUIntLE(this: BufferExt, value, offset, byteLength) {
   const view = (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength));
+
   switch (byteLength) {
     case 1: {
       view.setUint8(offset, value);
@@ -325,6 +366,7 @@ export function writeUIntLE(this: BufferExt, value, offset, byteLength) {
 }
 export function writeUIntBE(this: BufferExt, value, offset, byteLength) {
   const view = (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength));
+
   switch (byteLength) {
     case 1: {
       view.setUint8(offset, value);
@@ -361,42 +403,74 @@ export function writeUIntBE(this: BufferExt, value, offset, byteLength) {
 }
 
 export function writeFloatLE(this: BufferExt, value, offset) {
-  (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength)).setFloat32(offset, value, true);
+  (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength)).setFloat32(
+    offset === undefined ? (offset = 0) : offset,
+    value,
+    true,
+  );
   return offset + 4;
 }
 
 export function writeFloatBE(this: BufferExt, value, offset) {
-  (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength)).setFloat32(offset, value, false);
+  (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength)).setFloat32(
+    offset === undefined ? (offset = 0) : offset,
+    value,
+    false,
+  );
   return offset + 4;
 }
 
 export function writeDoubleLE(this: BufferExt, value, offset) {
-  (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength)).setFloat64(offset, value, true);
+  (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength)).setFloat64(
+    offset === undefined ? (offset = 0) : offset,
+    value,
+    true,
+  );
   return offset + 8;
 }
 
 export function writeDoubleBE(this: BufferExt, value, offset) {
-  (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength)).setFloat64(offset, value, false);
+  (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength)).setFloat64(
+    offset === undefined ? (offset = 0) : offset,
+    value,
+    false,
+  );
   return offset + 8;
 }
 
 export function writeBigInt64LE(this: BufferExt, value, offset) {
-  (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength)).setBigInt64(offset, value, true);
+  (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength)).setBigInt64(
+    offset === undefined ? (offset = 0) : offset,
+    value,
+    true,
+  );
   return offset + 8;
 }
 
 export function writeBigInt64BE(this: BufferExt, value, offset) {
-  (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength)).setBigInt64(offset, value, false);
+  (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength)).setBigInt64(
+    offset === undefined ? (offset = 0) : offset,
+    value,
+    false,
+  );
   return offset + 8;
 }
 
 export function writeBigUInt64LE(this: BufferExt, value, offset) {
-  (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength)).setBigUint64(offset, value, true);
+  (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength)).setBigUint64(
+    offset === undefined ? (offset = 0) : offset,
+    value,
+    true,
+  );
   return offset + 8;
 }
 
 export function writeBigUInt64BE(this: BufferExt, value, offset) {
-  (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength)).setBigUint64(offset, value, false);
+  (this.$dataView ||= new DataView(this.buffer, this.byteOffset, this.byteLength)).setBigUint64(
+    offset === undefined ? (offset = 0) : offset,
+    value,
+    false,
+  );
   return offset + 8;
 }
 
diff --git a/src/js/builtins/Module.ts b/src/js/builtins/Module.ts
index 0b528b6439..3030930313 100644
--- a/src/js/builtins/Module.ts
+++ b/src/js/builtins/Module.ts
@@ -76,9 +76,18 @@ export function overridableRequire(this: CommonJSModuleRecord, id: string) {
     // If we can pull out a ModuleNamespaceObject, let's do it.
     if (esm?.evaluated && (esm.state ?? 0) >= $ModuleReady) {
       const namespace = Loader.getModuleNamespaceObject(esm!.module);
-      return (mod.exports =
-        // if they choose a module
-        namespace.__esModule ? namespace : Object.create(namespace, { __esModule: { value: true } }));
+      // In Bun, when __esModule is not defined, it's a CustomAccessor on the prototype.
+      // Various libraries expect __esModule to be set when using ESM from require().
+      // We don't want to always inject the __esModule export into every module,
+      // And creating an Object wrapper causes the actual exports to not be own properties.
+      // So instead of either of those, we make it so that the __esModule property can be set at runtime.
+      // It only supports "true" and undefined. Anything non-truthy is treated as undefined.
+      // https://github.com/oven-sh/bun/issues/14411
+      if (namespace.__esModule === undefined) {
+        namespace.__esModule = true;
+      }
+
+      return (mod.exports = namespace);
     }
   }
 
diff --git a/src/js/builtins/ProcessObjectInternals.ts b/src/js/builtins/ProcessObjectInternals.ts
index ec6cae506f..506596a53f 100644
--- a/src/js/builtins/ProcessObjectInternals.ts
+++ b/src/js/builtins/ProcessObjectInternals.ts
@@ -195,6 +195,10 @@ export function getStdinStream(fd) {
         }
       }
     } catch (err) {
+      if (err?.code === "ERR_STREAM_RELEASE_LOCK") {
+        // Not a bug. Happens in unref().
+        return;
+      }
       stream.destroy(err);
     }
   }
@@ -212,6 +216,7 @@ export function getStdinStream(fd) {
     $debug('on("resume");');
     ref();
     stream._undestroy();
+    stream_destroyed = false;
   });
 
   stream._readableState.reading = false;
@@ -244,13 +249,7 @@ export function initializeNextTickQueue(process, nextTickQueue, drainMicrotasksF
   var drainMicrotasks = drainMicrotasksFn;
   var reportUncaughtException = reportUncaughtExceptionFn;
 
-  function validateFunction(cb) {
-    if (typeof cb !== "function") {
-      const err = new TypeError(`The "callback" argument must be of type "function". Received type ${typeof cb}`);
-      err.code = "ERR_INVALID_ARG_TYPE";
-      throw err;
-    }
-  }
+  const { validateFunction } = require("internal/validators");
 
   var setup;
   setup = () => {
@@ -306,7 +305,7 @@ export function initializeNextTickQueue(process, nextTickQueue, drainMicrotasksF
   };
 
   function nextTick(cb, args) {
-    validateFunction(cb);
+    validateFunction(cb, "callback");
     if (setup) {
       setup();
       process = globalThis.process;
diff --git a/src/js/builtins/ReadableStream.ts b/src/js/builtins/ReadableStream.ts
index ed45aaab37..6e7e2d5951 100644
--- a/src/js/builtins/ReadableStream.ts
+++ b/src/js/builtins/ReadableStream.ts
@@ -108,6 +108,7 @@ export function initializeReadableStream(
 
 $linkTimeConstant;
 export function readableStreamToArray(stream: ReadableStream): Promise<unknown[]> {
+  if (!$isReadableStream(stream)) throw $ERR_INVALID_ARG_TYPE("stream", "ReadableStream", typeof stream);
   // this is a direct stream
   var underlyingSource = $getByIdDirectPrivate(stream, "underlyingSource");
   if (underlyingSource !== undefined) {
@@ -119,6 +120,7 @@ export function readableStreamToArray(stream: ReadableStream): Promise<unknown[]
 
 $linkTimeConstant;
 export function readableStreamToText(stream: ReadableStream): Promise<string> {
+  if (!$isReadableStream(stream)) throw $ERR_INVALID_ARG_TYPE("stream", "ReadableStream", typeof stream);
   // this is a direct stream
   var underlyingSource = $getByIdDirectPrivate(stream, "underlyingSource");
   if (underlyingSource !== undefined) {
@@ -137,6 +139,7 @@ export function readableStreamToText(stream: ReadableStream): Promise<string> {
 
 $linkTimeConstant;
 export function readableStreamToArrayBuffer(stream: ReadableStream<ArrayBuffer>): Promise<ArrayBuffer> | ArrayBuffer {
+  if (!$isReadableStream(stream)) throw $ERR_INVALID_ARG_TYPE("stream", "ReadableStream", typeof stream);
   // this is a direct stream
   var underlyingSource = $getByIdDirectPrivate(stream, "underlyingSource");
   if (underlyingSource !== undefined) {
@@ -216,6 +219,7 @@ export function readableStreamToArrayBuffer(stream: ReadableStream<ArrayBuffer>)
 
 $linkTimeConstant;
 export function readableStreamToBytes(stream: ReadableStream<ArrayBuffer>): Promise<Uint8Array> | Uint8Array {
+  if (!$isReadableStream(stream)) throw $ERR_INVALID_ARG_TYPE("stream", "ReadableStream", typeof stream);
   // this is a direct stream
   var underlyingSource = $getByIdDirectPrivate(stream, "underlyingSource");
 
@@ -297,6 +301,7 @@ export function readableStreamToFormData(
   stream: ReadableStream<ArrayBuffer>,
   contentType: string | ArrayBuffer | ArrayBufferView,
 ): Promise<FormData> {
+  if (!$isReadableStream(stream)) throw $ERR_INVALID_ARG_TYPE("stream", "ReadableStream", typeof stream);
   if ($isReadableStreamLocked(stream)) return Promise.$reject($makeTypeError("ReadableStream is locked"));
   return Bun.readableStreamToBlob(stream).then(blob => {
     return FormData.from(blob, contentType);
@@ -305,6 +310,7 @@ export function readableStreamToFormData(
 
 $linkTimeConstant;
 export function readableStreamToJSON(stream: ReadableStream): unknown {
+  if (!$isReadableStream(stream)) throw $ERR_INVALID_ARG_TYPE("stream", "ReadableStream", typeof stream);
   if ($isReadableStreamLocked(stream)) return Promise.$reject($makeTypeError("ReadableStream is locked"));
   let result = $tryUseReadableStreamBufferedFastPath(stream, "json");
   if (result) {
@@ -326,6 +332,7 @@ export function readableStreamToJSON(stream: ReadableStream): unknown {
 
 $linkTimeConstant;
 export function readableStreamToBlob(stream: ReadableStream): Promise<Blob> {
+  if (!$isReadableStream(stream)) throw $ERR_INVALID_ARG_TYPE("stream", "ReadableStream", typeof stream);
   if ($isReadableStreamLocked(stream)) return Promise.$reject($makeTypeError("ReadableStream is locked"));
 
   return (
@@ -422,7 +429,15 @@ export function pipeThrough(this, streams, options) {
 
   if ($isWritableStreamLocked(internalWritable)) throw $makeTypeError("WritableStream is locked");
 
-  $readableStreamPipeToWritableStream(this, internalWritable, preventClose, preventAbort, preventCancel, signal);
+  const promise = $readableStreamPipeToWritableStream(
+    this,
+    internalWritable,
+    preventClose,
+    preventAbort,
+    preventCancel,
+    signal,
+  );
+  $markPromiseAsHandled(promise);
 
   return readable;
 }
diff --git a/src/js/builtins/ReadableStreamDefaultController.ts b/src/js/builtins/ReadableStreamDefaultController.ts
index 7c1c9ace77..6a04addc33 100644
--- a/src/js/builtins/ReadableStreamDefaultController.ts
+++ b/src/js/builtins/ReadableStreamDefaultController.ts
@@ -33,8 +33,9 @@ export function initializeReadableStreamDefaultController(this, stream, underlyi
 export function enqueue(this, chunk) {
   if (!$isReadableStreamDefaultController(this)) throw $makeThisTypeError("ReadableStreamDefaultController", "enqueue");
 
-  if (!$readableStreamDefaultControllerCanCloseOrEnqueue(this))
-    throw new TypeError("ReadableStreamDefaultController is not in a state where chunk can be enqueued");
+  if (!$readableStreamDefaultControllerCanCloseOrEnqueue(this)) {
+    throw $ERR_INVALID_STATE("ReadableStreamDefaultController is not in a state where chunk can be enqueued");
+  }
 
   return $readableStreamDefaultControllerEnqueue(this, chunk);
 }
diff --git a/src/js/builtins/ReadableStreamDefaultReader.ts b/src/js/builtins/ReadableStreamDefaultReader.ts
index 2ff8e385f0..9ddb3e3f38 100644
--- a/src/js/builtins/ReadableStreamDefaultReader.ts
+++ b/src/js/builtins/ReadableStreamDefaultReader.ts
@@ -172,10 +172,7 @@ export function releaseLock(this) {
 
   if (!$getByIdDirectPrivate(this, "ownerReadableStream")) return;
 
-  if ($getByIdDirectPrivate(this, "readRequests")?.isNotEmpty())
-    throw new TypeError("There are still pending read requests, cannot release the lock");
-
-  $readableStreamReaderGenericRelease(this);
+  $readableStreamDefaultReaderRelease(this);
 }
 
 $getter;
diff --git a/src/js/builtins/ReadableStreamInternals.ts b/src/js/builtins/ReadableStreamInternals.ts
index 7f95f39ee9..f81b71d6bd 100644
--- a/src/js/builtins/ReadableStreamInternals.ts
+++ b/src/js/builtins/ReadableStreamInternals.ts
@@ -331,7 +331,10 @@ export function pipeToDoReadWrite(pipeState) {
           pipeState.pendingReadPromiseCapability.resolve.$call(undefined, canWrite);
           if (!canWrite) return;
 
-          pipeState.pendingWritePromise = $writableStreamDefaultWriterWrite(pipeState.writer, result.value);
+          pipeState.pendingWritePromise = $writableStreamDefaultWriterWrite(pipeState.writer, result.value).$then(
+            undefined,
+            () => {},
+          );
         },
         e => {
           pipeState.pendingReadPromiseCapability.resolve.$call(undefined, false);
@@ -396,7 +399,7 @@ export function pipeToClosingMustBePropagatedForward(pipeState) {
     action();
     return;
   }
-  $getByIdDirectPrivate(pipeState.reader, "closedPromiseCapability").promise.$then(action, undefined);
+  $getByIdDirectPrivate(pipeState.reader, "closedPromiseCapability").promise.$then(action, () => {});
 }
 
 export function pipeToClosingMustBePropagatedBackward(pipeState) {
@@ -1367,20 +1370,18 @@ export function readableStreamError(stream, error) {
 
   if (!reader) return;
 
+  $getByIdDirectPrivate(reader, "closedPromiseCapability").reject.$call(undefined, error);
+  const promise = $getByIdDirectPrivate(reader, "closedPromiseCapability").promise;
+  $markPromiseAsHandled(promise);
+
   if ($isReadableStreamDefaultReader(reader)) {
-    const requests = $getByIdDirectPrivate(reader, "readRequests");
-    $putByIdDirectPrivate(reader, "readRequests", $createFIFO());
-    for (var request = requests.shift(); request; request = requests.shift()) $rejectPromise(request, error);
+    $readableStreamDefaultReaderErrorReadRequests(reader, error);
   } else {
     $assert($isReadableStreamBYOBReader(reader));
     const requests = $getByIdDirectPrivate(reader, "readIntoRequests");
     $putByIdDirectPrivate(reader, "readIntoRequests", $createFIFO());
     for (var request = requests.shift(); request; request = requests.shift()) $rejectPromise(request, error);
   }
-
-  $getByIdDirectPrivate(reader, "closedPromiseCapability").reject.$call(undefined, error);
-  const promise = $getByIdDirectPrivate(reader, "closedPromiseCapability").promise;
-  $markPromiseAsHandled(promise);
 }
 
 export function readableStreamDefaultControllerShouldCallPull(controller) {
@@ -1608,6 +1609,15 @@ export function isReadableStreamDisturbed(stream) {
   return stream.$disturbed;
 }
 
+$visibility = "Private";
+export function readableStreamDefaultReaderRelease(reader) {
+  $readableStreamReaderGenericRelease(reader);
+  $readableStreamDefaultReaderErrorReadRequests(
+    reader,
+    $ERR_STREAM_RELEASE_LOCK("Stream reader cancelled via releaseLock()"),
+  );
+}
+
 $visibility = "Private";
 export function readableStreamReaderGenericRelease(reader) {
   $assert(!!$getByIdDirectPrivate(reader, "ownerReadableStream"));
@@ -1616,11 +1626,11 @@ export function readableStreamReaderGenericRelease(reader) {
   if ($getByIdDirectPrivate($getByIdDirectPrivate(reader, "ownerReadableStream"), "state") === $streamReadable)
     $getByIdDirectPrivate(reader, "closedPromiseCapability").reject.$call(
       undefined,
-      $makeTypeError("releasing lock of reader whose stream is still in readable state"),
+      $ERR_STREAM_RELEASE_LOCK("Stream reader cancelled via releaseLock()"),
     );
   else
     $putByIdDirectPrivate(reader, "closedPromiseCapability", {
-      promise: $newHandledRejectedPromise($makeTypeError("reader released lock")),
+      promise: $newHandledRejectedPromise($ERR_STREAM_RELEASE_LOCK("Stream reader cancelled via releaseLock()")),
     });
 
   const promise = $getByIdDirectPrivate(reader, "closedPromiseCapability").promise;
@@ -1636,6 +1646,12 @@ export function readableStreamReaderGenericRelease(reader) {
   $putByIdDirectPrivate(reader, "ownerReadableStream", undefined);
 }
 
+export function readableStreamDefaultReaderErrorReadRequests(reader, error) {
+  const requests = $getByIdDirectPrivate(reader, "readRequests");
+  $putByIdDirectPrivate(reader, "readRequests", $createFIFO());
+  for (var request = requests.shift(); request; request = requests.shift()) $rejectPromise(request, error);
+}
+
 export function readableStreamDefaultControllerCanCloseOrEnqueue(controller) {
   if ($getByIdDirectPrivate(controller, "closeRequested")) {
     return false;
@@ -1703,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 7c1c275b44..f4f29f431f 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/bun/sqlite.ts b/src/js/bun/sqlite.ts
index 73bab306ed..964de1219c 100644
--- a/src/js/bun/sqlite.ts
+++ b/src/js/bun/sqlite.ts
@@ -103,6 +103,7 @@ class Statement {
       case 0: {
         this.get = this.#getNoArgs;
         this.all = this.#allNoArgs;
+        this.iterate = this.#iterateNoArgs;
         this.values = this.#valuesNoArgs;
         this.run = this.#runNoArgs;
         break;
@@ -110,6 +111,7 @@ class Statement {
       default: {
         this.get = this.#get;
         this.all = this.#all;
+        this.iterate = this.#iterate;
         this.values = this.#values;
         this.run = this.#run;
         break;
@@ -121,6 +123,7 @@ class Statement {
 
   get;
   all;
+  iterate;
   values;
   run;
   isFinalized = false;
@@ -154,6 +157,12 @@ class Statement {
     return this.#raw.all();
   }
 
+  *#iterateNoArgs() {
+    for (let res = this.#raw.iterate(); res; res = this.#raw.iterate()) {
+      yield res;
+    }
+  }
+
   #valuesNoArgs() {
     return this.#raw.values();
   }
@@ -203,6 +212,22 @@ class Statement {
       : this.#raw.all(...args);
   }
 
+  *#iterate(...args) {
+    if (args.length === 0) return yield* this.#iterateNoArgs();
+    var arg0 = args[0];
+    // ["foo"] => ["foo"]
+    // ("foo") => ["foo"]
+    // (Uint8Array(1024)) => [Uint8Array]
+    // (123) => [123]
+    let res =
+      !isArray(arg0) && (!arg0 || typeof arg0 !== "object" || isTypedArray(arg0))
+        ? this.#raw.iterate(args)
+        : this.#raw.iterate(...args);
+    for (; res; res = this.#raw.iterate()) {
+      yield res;
+    }
+  }
+
   #values(...args) {
     if (args.length === 0) return this.#valuesNoArgs();
     var arg0 = args[0];
@@ -242,6 +267,10 @@ class Statement {
     return this.#raw.finalize(...args);
   }
 
+  *[Symbol.iterator]() {
+    yield* this.#iterateNoArgs();
+  }
+
   [Symbol.dispose]() {
     if (!this.isFinalized) {
       this.finalize();
diff --git a/src/js/internal-for-testing.ts b/src/js/internal-for-testing.ts
index f18a435bc9..b21d2f330c 100644
--- a/src/js/internal-for-testing.ts
+++ b/src/js/internal-for-testing.ts
@@ -56,6 +56,13 @@ export const iniInternals = {
   loadNpmrc: $newZigFunction("ini.zig", "IniTestingAPIs.loadNpmrcFromJS", 2),
 };
 
+export const cssInternals = {
+  minifyTestWithOptions: $newZigFunction("css_internals.zig", "minifyTestWithOptions", 3),
+  testWithOptions: $newZigFunction("css_internals.zig", "testWithOptions", 3),
+  prefixTestWithOptions: $newZigFunction("css_internals.zig", "prefixTestWithOptions", 3),
+  attrTest: $newZigFunction("css_internals.zig", "attrTest", 3),
+};
+
 export const crash_handler = $zig("crash_handler.zig", "js_bindings.generate") as {
   getMachOImageZeroOffset: () => number;
   segfault: () => void;
@@ -106,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: (
@@ -128,3 +136,16 @@ export const isOperatingSystemMatch: (operatingSystem: string[]) => boolean = $n
 );
 
 export const createSocketPair: () => [number, number] = $newZigFunction("socket.zig", "jsCreateSocketPair", 0);
+
+export const isModuleResolveFilenameSlowPathEnabled: () => boolean = $newCppFunction(
+  "NodeModuleModule.cpp",
+  "jsFunctionIsModuleResolveFilenameSlowPathEnabled",
+  0,
+);
+
+export const frameworkRouterInternals = $zig("FrameworkRouter.zig", "JSFrameworkRouter.getBindings") as {
+  parseRoutePattern: (style: string, pattern: string) => null | { kind: string; pattern: string };
+  FrameworkRouter: {
+    new(opts: any): any;
+  };
+};
diff --git a/src/js/internal/cluster/RoundRobinHandle.ts b/src/js/internal/cluster/RoundRobinHandle.ts
index 2184cc0468..edcc00178e 100644
--- a/src/js/internal/cluster/RoundRobinHandle.ts
+++ b/src/js/internal/cluster/RoundRobinHandle.ts
@@ -1,7 +1,8 @@
-const net = require("node:net");
 const { append, init, isEmpty, peek, remove } = require("internal/linkedlist");
 const { kHandle } = require("internal/shared");
 
+let net;
+
 const sendHelper = $newZigFunction("node_cluster_binding.zig", "sendHelperPrimary", 4);
 
 const ArrayIsArray = Array.isArray;
@@ -20,6 +21,7 @@ export default class RoundRobinHandle {
   server;
 
   constructor(key, address, { port, fd, flags, backlog, readableAll, writableAll }) {
+    net ??= require("node:net");
     this.key = key;
     this.all = new Map();
     this.free = new Map();
@@ -92,7 +94,7 @@ export default class RoundRobinHandle {
       remove(handle);
     }
 
-    this.handle.close();
+    this.handle?.stop(false);
     this.handle = null;
     return true;
   }
diff --git a/src/js/internal/cluster/Worker.ts b/src/js/internal/cluster/Worker.ts
index 14ff825c4d..4249d1364c 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/cluster/primary.ts b/src/js/internal/cluster/primary.ts
index e3a0d4f844..315d13e0a6 100644
--- a/src/js/internal/cluster/primary.ts
+++ b/src/js/internal/cluster/primary.ts
@@ -1,5 +1,4 @@
 const EventEmitter = require("node:events");
-const child_process = require("node:child_process");
 const Worker = require("internal/cluster/Worker");
 const RoundRobinHandle = require("internal/cluster/RoundRobinHandle");
 const path = require("node:path");
@@ -8,6 +7,8 @@ const { throwNotImplemented, kHandle } = require("internal/shared");
 const sendHelper = $newZigFunction("node_cluster_binding.zig", "sendHelperPrimary", 4);
 const onInternalMessage = $newZigFunction("node_cluster_binding.zig", "onInternalMessagePrimary", 3);
 
+let child_process;
+
 const ArrayPrototypeSlice = Array.prototype.slice;
 const ObjectValues = Object.values;
 const ObjectKeys = Object.keys;
@@ -86,6 +87,7 @@ function createWorkerProcess(id, env) {
   //   ArrayPrototypePush(execArgv, `--inspect-port=${getInspectPort(cluster.settings.inspectPort)}`);
   // }
 
+  child_process ??= require("node:child_process");
   return child_process.fork(cluster.settings.exec, cluster.settings.args, {
     cwd: cluster.settings.cwd,
     env: workerEnv,
diff --git a/src/js/internal/debugger.ts b/src/js/internal/debugger.ts
index 567e2fa384..d8b0d0bf9e 100644
--- a/src/js/internal/debugger.ts
+++ b/src/js/internal/debugger.ts
@@ -1,16 +1,114 @@
-import type { ServerWebSocket, Socket, SocketHandler, WebSocketHandler, Server as WebSocketServer } from "bun";
+import type { Socket, ServerWebSocket, WebSocketHandler, Server as WebSocketServer } from "bun";
+const enum FramerState {
+  WaitingForLength,
+  WaitingForMessage,
+}
+
+let socketFramerMessageLengthBuffer: Buffer;
+class SocketFramer {
+  state: FramerState = FramerState.WaitingForLength;
+  pendingLength: number = 0;
+  sizeBuffer: Buffer = Buffer.alloc(4);
+  sizeBufferIndex: number = 0;
+  bufferedData: Buffer = Buffer.alloc(0);
+
+  constructor(private onMessage: (message: string | string[]) => void) {
+    if (!socketFramerMessageLengthBuffer) {
+      socketFramerMessageLengthBuffer = Buffer.alloc(4);
+    }
+    this.reset();
+  }
+
+  reset(): void {
+    this.state = FramerState.WaitingForLength;
+    this.bufferedData = Buffer.alloc(0);
+    this.sizeBufferIndex = 0;
+    this.sizeBuffer = Buffer.alloc(4);
+  }
+
+  send(socket: Socket<{ framer: SocketFramer; backend: Backend }>, data: string): void {
+    if (!!$debug) {
+      $debug("local:", data);
+    }
+
+    socketFramerMessageLengthBuffer.writeUInt32BE(data.length, 0);
+    socket.$write(socketFramerMessageLengthBuffer);
+    socket.$write(data);
+  }
+
+  onData(socket: Socket<{ framer: SocketFramer; backend: Writer }>, data: Buffer): void {
+    this.bufferedData = this.bufferedData.length > 0 ? Buffer.concat([this.bufferedData, data]) : data;
+
+    let messagesToDeliver: string[] = [];
+
+    while (this.bufferedData.length > 0) {
+      if (this.state === FramerState.WaitingForLength) {
+        if (this.sizeBufferIndex + this.bufferedData.length < 4) {
+          const remainingBytes = Math.min(4 - this.sizeBufferIndex, this.bufferedData.length);
+          this.bufferedData.copy(this.sizeBuffer, this.sizeBufferIndex, 0, remainingBytes);
+          this.sizeBufferIndex += remainingBytes;
+          this.bufferedData = this.bufferedData.slice(remainingBytes);
+          break;
+        }
+
+        const remainingBytes = 4 - this.sizeBufferIndex;
+        this.bufferedData.copy(this.sizeBuffer, this.sizeBufferIndex, 0, remainingBytes);
+        this.pendingLength = this.sizeBuffer.readUInt32BE(0);
+
+        this.state = FramerState.WaitingForMessage;
+        this.sizeBufferIndex = 0;
+        this.bufferedData = this.bufferedData.slice(remainingBytes);
+      }
+
+      if (this.bufferedData.length < this.pendingLength) {
+        break;
+      }
+
+      const message = this.bufferedData.toString("utf-8", 0, this.pendingLength);
+      this.bufferedData = this.bufferedData.slice(this.pendingLength);
+      this.state = FramerState.WaitingForLength;
+      this.pendingLength = 0;
+      this.sizeBufferIndex = 0;
+      messagesToDeliver.push(message);
+    }
+
+    if (!!$debug) {
+      $debug("remote:", messagesToDeliver);
+    }
+
+    if (messagesToDeliver.length === 1) {
+      this.onMessage(messagesToDeliver[0]);
+    } else if (messagesToDeliver.length > 1) {
+      this.onMessage(messagesToDeliver);
+    }
+  }
+}
+
+interface Backend {
+  write: (message: string | string[]) => boolean;
+  close: () => void;
+}
+
+type CreateBackendFn = (
+  executionContextId: number,
+  refEventLoop: boolean,
+  receive: (...messages: string[]) => void,
+) => unknown;
 
 export default function (
-  executionContextId: string,
+  executionContextId: number,
   url: string,
-  createBackend: (
-    executionContextId: string,
-    refEventLoop: boolean,
-    receive: (...messages: string[]) => void,
-  ) => unknown,
-  send: (message: string) => void,
+  createBackend: CreateBackendFn,
+  send: (message: string | string[]) => void,
   close: () => void,
+  isAutomatic: boolean,
+  urlIsServer: boolean,
 ): void {
+  if (urlIsServer) {
+    connectToUnixServer(executionContextId, url, createBackend, send, close);
+    return;
+  }
+
   let debug: Debugger | undefined;
   try {
     debug = new Debugger(executionContextId, url, createBackend, send, close);
@@ -18,18 +116,31 @@ export default function (
     exit("Failed to start inspector:\n", error);
   }
 
-  const { protocol, href, host, pathname } = debug.url;
-  if (!protocol.includes("unix")) {
-    Bun.write(Bun.stderr, dim("--------------------- Bun Inspector ---------------------") + reset() + "\n");
-    Bun.write(Bun.stderr, `Listening:\n  ${dim(href)}\n`);
-    if (protocol.includes("ws")) {
-      Bun.write(Bun.stderr, `Inspect in browser:\n  ${link(`https://debug.bun.sh/#${host}${pathname}`)}\n`);
+  // If the user types --inspect, we print the URL to the console.
+  // If the user is using an editor extension, don't print anything.
+  if (!isAutomatic) {
+    if (debug.url) {
+      const { protocol, href, host, pathname } = debug.url;
+      if (!protocol.includes("unix")) {
+        Bun.write(Bun.stderr, dim("--------------------- Bun Inspector ---------------------") + reset() + "\n");
+        Bun.write(Bun.stderr, `Listening:\n  ${dim(href)}\n`);
+        if (protocol.includes("ws")) {
+          Bun.write(Bun.stderr, `Inspect in browser:\n  ${link(`https://debug.bun.sh/#${host}${pathname}`)}\n`);
+        }
+        Bun.write(Bun.stderr, dim("--------------------- Bun Inspector ---------------------") + reset() + "\n");
+      }
+    } else {
+      Bun.write(Bun.stderr, dim("--------------------- Bun Inspector ---------------------") + reset() + "\n");
+      Bun.write(Bun.stderr, `Listening on ${dim(url)}\n`);
+      Bun.write(Bun.stderr, dim("--------------------- Bun Inspector ---------------------") + reset() + "\n");
     }
-    Bun.write(Bun.stderr, dim("--------------------- Bun Inspector ---------------------") + reset() + "\n");
   }
 
   const notifyUrl = process.env["BUN_INSPECT_NOTIFY"] || "";
   if (notifyUrl) {
+    // Only send this once.
+    process.env["BUN_INSPECT_NOTIFY"] = "";
+
     if (notifyUrl.startsWith("unix://")) {
       const path = require("node:path");
       notify({
@@ -46,41 +157,80 @@ export default function (
   }
 }
 
-class Debugger {
-  #url: URL;
-  #createBackend: (refEventLoop: boolean, receive: (...messages: string[]) => void) => Writer;
-
-  constructor(
-    executionContextId: string,
-    url: string,
-    createBackend: (
-      executionContextId: string,
-      refEventLoop: boolean,
-      receive: (...messages: string[]) => void,
-    ) => unknown,
-    send: (message: string) => void,
-    close: () => void,
-  ) {
-    this.#url = parseUrl(url);
-    this.#createBackend = (refEventLoop, receive) => {
-      const backend = createBackend(executionContextId, refEventLoop, receive);
-      return {
-        write: message => {
-          send.$call(backend, message);
-          return true;
-        },
-        close: () => close.$call(backend),
-      };
-    };
-    this.#listen();
+function unescapeUnixSocketUrl(href: string) {
+  if (href.startsWith("unix://%2F")) {
+    return decodeURIComponent(href.substring("unix://".length));
   }
 
-  get url(): URL {
+  return href;
+}
+
+class Debugger {
+  #url?: URL;
+  #createBackend: (refEventLoop: boolean, receive: (...messages: string[]) => void) => Backend;
+
+  constructor(
+    executionContextId: number,
+    url: string,
+    createBackend: CreateBackendFn,
+    send: (message: string | string[]) => void,
+    close: () => void,
+  ) {
+    try {
+      this.#createBackend = (refEventLoop, receive) => {
+        const backend = createBackend(executionContextId, refEventLoop, receive);
+        return {
+          write: (message: string | string[]) => {
+            send.$call(backend, message);
+            return true;
+          },
+          close: () => close.$call(backend),
+        };
+      };
+
+      if (url.startsWith("unix://")) {
+        this.#connectOverSocket({
+          unix: unescapeUnixSocketUrl(url),
+        });
+        return;
+      } else if (url.startsWith("fd://")) {
+        this.#connectOverSocket({
+          fd: Number(url.substring("fd://".length)),
+        });
+        return;
+      } else if (url.startsWith("fd:")) {
+        this.#connectOverSocket({
+          fd: Number(url.substring("fd:".length)),
+        });
+        return;
+      } else if (url.startsWith("unix:")) {
+        this.#connectOverSocket({
+          unix: url.substring("unix:".length),
+        });
+        return;
+      } else if (url.startsWith("tcp://")) {
+        const { hostname, port } = new URL(url);
+        this.#connectOverSocket({
+          hostname,
+          port: port && port !== "0" ? Number(port) : undefined,
+        });
+        return;
+      }
+
+      this.#url = parseUrl(url);
+      this.#listen();
+    } catch (error) {
+      console.error(error);
+      throw error;
+    }
+  }
+
+  get url(): URL | undefined {
     return this.#url;
   }
 
   #listen(): void {
-    const { protocol, hostname, port, pathname } = this.#url;
+    const { protocol, hostname, port, pathname } = this.#url!;
 
     if (protocol === "ws:" || protocol === "wss:" || protocol === "ws+tcp:") {
       const server = Bun.serve({
@@ -89,8 +239,9 @@ class Debugger {
         fetch: this.#fetch.bind(this),
         websocket: this.#websocket,
       });
-      this.#url.hostname = server.hostname;
-      this.#url.port = `${server.port}`;
+
+      this.#url!.hostname = server.hostname;
+      this.#url!.port = `${server.port}`;
       return;
     }
 
@@ -106,6 +257,56 @@ class Debugger {
     throw new TypeError(`Unsupported protocol: '${protocol}' (expected 'ws:' or 'ws+unix:')`);
   }
 
+  #connectOverSocket(networkOptions) {
+    let backend;
+    return Bun.connect<{ framer: SocketFramer; backend: Backend }>({
+      ...networkOptions,
+      socket: {
+        open: socket => {
+          let framer: SocketFramer;
+          const callback = (...messages: string[]) => {
+            for (const message of messages) {
+              framer.send(socket, message);
+            }
+          };
+
+          framer = new SocketFramer((message: string | string[]) => {
+            backend.write(message);
+          });
+          backend = this.#createBackend(false, callback);
+          socket.data = {
+            framer,
+            backend,
+          };
+          socket.ref();
+        },
+        data: (socket, bytes) => {
+          if (!socket.data) {
+            socket.terminate();
+            return;
+          }
+          socket.data.framer.onData(socket, bytes);
+        },
+        drain: socket => {},
+        close: socket => {
+          if (socket.data) {
+            const { backend, framer } = socket.data;
+            backend.close();
+            framer.reset();
+          }
+        },
+      },
+    }).catch(err => {
+      // Force us to send a disconnect message
+      if (!backend) {
+        backend = this.#createBackend(false, () => {});
+        backend.close();
+      }
+
+      $debug("error:", err);
+    });
+  }
+
   get #websocket(): WebSocketHandler<Connection> {
     return {
       idleTimeout: 0,
@@ -141,7 +342,7 @@ class Debugger {
       // TODO?
     }
 
-    if (!this.#url.protocol.includes("unix") && this.#url.pathname !== pathname) {
+    if (!this.#url!.protocol.includes("unix") && this.#url!.pathname !== pathname) {
       return new Response(null, {
         status: 404, // Not Found
       });
@@ -161,17 +362,6 @@ class Debugger {
     }
   }
 
-  get #socket(): SocketHandler<Connection> {
-    return {
-      open: socket => this.#open(socket, socketWriter(socket)),
-      data: (socket, message) => this.#message(socket, message.toString()),
-      drain: socket => this.#drain(socket),
-      close: socket => this.#close(socket),
-      error: (socket, error) => this.#error(socket, error),
-      connectError: (_, error) => exit("Failed to start inspector:\n", error),
-    };
-  }
-
   #open(connection: ConnectionOwner, writer: Writer): void {
     const { data } = connection;
     const { refEventLoop } = data;
@@ -190,6 +380,7 @@ class Debugger {
   #message(connection: ConnectionOwner, message: string): void {
     const { data } = connection;
     const { backend } = data;
+    $debug("remote:", message);
     backend?.write(message);
   }
 
@@ -213,6 +404,104 @@ class Debugger {
   }
 }
 
+async function connectToUnixServer(
+  executionContextId: number,
+  unix: string,
+  createBackend: CreateBackendFn,
+  send: (message: string) => void,
+  close: () => void,
+) {
+  // Windows uses TCP.
+  // POSIX uses Unix sockets.
+  //
+  // We use TCP on Windows because VSCode/Node doesn't seem to support Unix sockets very well.
+  //
+  // Unix sockets are preferred because there's less of a risk of conflicting
+  // with other tools or a port already being used + sometimes machines don't
+  // allow binding to TCP ports.
+  let connectionOptions;
+  if (unix.startsWith("unix:")) {
+    unix = unescapeUnixSocketUrl(unix);
+    if (unix.startsWith("unix://")) {
+      unix = unix.substring("unix://".length);
+    }
+    connectionOptions = { unix };
+  } else if (unix.startsWith("tcp:")) {
+    try {
+      const { hostname, port } = new URL(unix);
+      connectionOptions = {
+        hostname,
+        port: Number(port),
+      };
+    } catch (error) {
+      exit("Invalid tcp: URL:" + unix);
+      return;
+    }
+  } else if (unix.startsWith("/")) {
+    connectionOptions = { unix };
+  } else if (unix.startsWith("fd:")) {
+    connectionOptions = { fd: Number(unix.substring("fd:".length)) };
+  } else {
+    $debug("Invalid inspector URL:" + unix);
+    return;
+  }
+
+  const socket = await Bun.connect<{ framer: SocketFramer; backend: Backend }>({
+    ...connectionOptions,
+    socket: {
+      open: socket => {
+        const framer = new SocketFramer((message: string | string[]) => {
+          backend.write(message);
+        });
+
+        const backendRaw = createBackend(executionContextId, true, (...messages: string[]) => {
+          for (const message of messages) {
+            framer.send(socket, message);
+          }
+        });
+
+        const backend = {
+          write: message => {
+            send.$call(backendRaw, message);
+            return true;
+          },
+          close: () => close.$call(backendRaw),
+        };
+
+        socket.data = {
+          framer,
+          backend,
+        };
+
+        socket.ref();
+      },
+      data: (socket, bytes) => {
+        if (!socket.data) {
+          socket.terminate();
+          return;
+        }
+
+        socket.data.framer.onData(socket, bytes);
+      },
+      close: socket => {
+        if (socket.data) {
+          const { backend, framer } = socket.data;
+          backend.close();
+          framer.reset();
+        }
+      },
+    },
+  }).catch(error => {
+    // Force it to close
+    const backendRaw = createBackend(executionContextId, true, (...messages: string[]) => {});
+    close.$call(backendRaw);
+
+    $debug("error:", error);
+  });
+
+  return socket;
+}
+
 function versionInfo(): unknown {
   return {
     "Protocol-Version": "1.3",
@@ -231,13 +520,6 @@ function webSocketWriter(ws: ServerWebSocket<unknown>): Writer {
   };
 }
 
-function socketWriter(socket: Socket<unknown>): Writer {
-  return {
-    write: message => !!socket.write(message),
-    close: () => socket.end(),
-  };
-}
-
 function bufferedWriter(writer: Writer): Writer {
   let draining = false;
   let pendingMessages: string[] = [];
@@ -273,7 +555,7 @@ const defaultHostname = "localhost";
 const defaultPort = 6499;
 
 function parseUrl(input: string): URL {
-  if (input.startsWith("ws://") || input.startsWith("ws+unix://") || input.startsWith("unix://")) {
+  if (input.startsWith("ws://") || input.startsWith("ws+unix://")) {
     return new URL(input);
   }
   const url = new URL(`ws://${defaultHostname}:${defaultPort}/${randomId()}`);
@@ -339,7 +621,7 @@ function notify(options): void {
       },
       data: () => {}, // required or it errors
     },
-  }).finally(() => {
+  }).catch(() => {
     // Best-effort
   });
 }
@@ -356,7 +638,7 @@ type ConnectionOwner = {
 type Connection = {
   refEventLoop: boolean;
   client?: Writer;
-  backend?: Writer;
+  backend?: Backend;
 };
 
 type Writer = {
diff --git a/src/js/internal/errors.ts b/src/js/internal/errors.ts
index dedce8f38a..fd5036ec86 100644
--- a/src/js/internal/errors.ts
+++ b/src/js/internal/errors.ts
@@ -6,4 +6,8 @@ export default {
   ERR_IPC_CHANNEL_CLOSED: $newCppFunction("ErrorCode.cpp", "jsFunction_ERR_IPC_CHANNEL_CLOSED", 0),
   ERR_SOCKET_BAD_TYPE: $newCppFunction("ErrorCode.cpp", "jsFunction_ERR_SOCKET_BAD_TYPE", 0),
   ERR_INVALID_PROTOCOL: $newCppFunction("ErrorCode.cpp", "jsFunction_ERR_INVALID_PROTOCOL", 0),
+  ERR_BROTLI_INVALID_PARAM: $newCppFunction("ErrorCode.cpp", "jsFunction_ERR_BROTLI_INVALID_PARAM", 0),
+  ERR_BUFFER_TOO_LARGE: $newCppFunction("ErrorCode.cpp", "jsFunction_ERR_BUFFER_TOO_LARGE", 0),
+  ERR_ZLIB_INITIALIZATION_FAILED: $newCppFunction("ErrorCode.cpp", "jsFunction_ERR_ZLIB_INITIALIZATION_FAILED", 0),
+  ERR_BUFFER_OUT_OF_BOUNDS: $newCppFunction("ErrorCode.cpp", "jsFunction_ERR_BUFFER_OUT_OF_BOUNDS", 0),
 };
diff --git a/src/js/internal/primordials.js b/src/js/internal/primordials.js
index 95745088b5..e68d6d6fe3 100644
--- a/src/js/internal/primordials.js
+++ b/src/js/internal/primordials.js
@@ -83,11 +83,14 @@ function ErrorCaptureStackTrace(targetObject) {
 }
 
 const arrayProtoPush = Array.prototype.push;
-
+const ArrayPrototypeSymbolIterator = uncurryThis(Array.prototype[Symbol.iterator]);
+const ArrayIteratorPrototypeNext = uncurryThis(ArrayPrototypeSymbolIterator.next);
 export default {
   makeSafe, // exported for testing
   Array,
   ArrayFrom: Array.from,
+  ArrayIsArray: Array.isArray,
+  SafeArrayIterator: createSafeIterator(ArrayPrototypeSymbolIterator, ArrayIteratorPrototypeNext),
   ArrayPrototypeFlat: uncurryThis(Array.prototype.flat),
   ArrayPrototypeFilter: uncurryThis(Array.prototype.filter),
   ArrayPrototypeForEach,
@@ -169,6 +172,8 @@ export default {
       }
     },
   ),
+  DatePrototypeGetMilliseconds: uncurryThis(Date.prototype.getMilliseconds),
+  DatePrototypeToUTCString: uncurryThis(Date.prototype.toUTCString),
   SetPrototypeGetSize: getGetter(Set, "size"),
   SetPrototypeEntries: uncurryThis(Set.prototype.entries),
   SetPrototypeValues: uncurryThis(Set.prototype.values),
diff --git a/src/js/internal/promisify.ts b/src/js/internal/promisify.ts
index 76a6ecefc6..d9773bca57 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/internal/util/inspect.js b/src/js/internal/util/inspect.js
index f4b3a12282..5cdb40af5b 100644
--- a/src/js/internal/util/inspect.js
+++ b/src/js/internal/util/inspect.js
@@ -31,6 +31,7 @@
 // IN THE SOFTWARE.
 
 const { pathToFileURL } = require("node:url");
+let BufferModule;
 
 const primordials = require("internal/primordials");
 const {
@@ -2071,6 +2072,11 @@ function formatArray(ctx, value, recurseTimes) {
 }
 
 function formatTypedArray(value, length, ctx, ignored, recurseTimes) {
+  if (Buffer.isBuffer(value)) {
+    BufferModule ??= require("node:buffer");
+    const INSPECT_MAX_BYTES = $requireMap.$get("buffer")?.exports.INSPECT_MAX_BYTES ?? BufferModule.INSPECT_MAX_BYTES;
+    ctx.maxArrayLength = MathMin(ctx.maxArrayLength, INSPECT_MAX_BYTES);
+  }
   const maxLength = MathMin(MathMax(0, ctx.maxArrayLength), length);
   const remaining = value.length - maxLength;
   const output = new Array(maxLength);
diff --git a/src/js/internal/validators.ts b/src/js/internal/validators.ts
new file mode 100644
index 0000000000..a6612d6db0
--- /dev/null
+++ b/src/js/internal/validators.ts
@@ -0,0 +1,106 @@
+const { hideFromStack } = require("internal/shared");
+const { ArrayIsArray } = require("internal/primordials");
+const RegExpPrototypeExec = RegExp.prototype.exec;
+
+const tokenRegExp = /^[\^_`a-zA-Z\-0-9!#$%&'*+.|~]+$/;
+/**
+ * Verifies that the given val is a valid HTTP token
+ * per the rules defined in RFC 7230
+ * See https://tools.ietf.org/html/rfc7230#section-3.2.6
+ */
+function checkIsHttpToken(val) {
+  return RegExpPrototypeExec.$call(tokenRegExp, val) !== null;
+}
+
+/*
+  The rules for the Link header field are described here:
+  https://www.rfc-editor.org/rfc/rfc8288.html#section-3
+
+  This regex validates any string surrounded by angle brackets
+  (not necessarily a valid URI reference) followed by zero or more
+  link-params separated by semicolons.
+*/
+const linkValueRegExp = /^(?:<[^>]*>)(?:\s*;\s*[^;"\s]+(?:=(")?[^;"\s]*\1)?)*$/;
+function validateLinkHeaderFormat(value, name) {
+  if (typeof value === "undefined" || !RegExpPrototypeExec.$call(linkValueRegExp, value)) {
+    throw $ERR_INVALID_ARG_VALUE(
+      `The arguments ${name} is invalid must be an array or string of format "</styles.css>; rel=preload; as=style"`,
+    );
+  }
+}
+
+function validateLinkHeaderValue(hints) {
+  if (typeof hints === "string") {
+    validateLinkHeaderFormat(hints, "hints");
+    return hints;
+  } else if (ArrayIsArray(hints)) {
+    const hintsLength = hints.length;
+    let result = "";
+
+    if (hintsLength === 0) {
+      return result;
+    }
+
+    for (let i = 0; i < hintsLength; i++) {
+      const link = hints[i];
+      validateLinkHeaderFormat(link, "hints");
+      result += link;
+
+      if (i !== hintsLength - 1) {
+        result += ", ";
+      }
+    }
+
+    return result;
+  }
+
+  throw $ERR_INVALID_ARG_VALUE(
+    `The arguments hints is invalid must be an array or string of format "</styles.css>; rel=preload; as=style"`,
+  );
+}
+hideFromStack(validateLinkHeaderValue);
+// TODO: do it in NodeValidator.cpp
+function validateObject(value, name) {
+  if (typeof value !== "object" || value === null) throw $ERR_INVALID_ARG_TYPE(name, "object", value);
+}
+hideFromStack(validateObject);
+
+export default {
+  validateObject: validateObject,
+  validateLinkHeaderValue: validateLinkHeaderValue,
+  checkIsHttpToken: checkIsHttpToken,
+  /** `(value, name, min = NumberMIN_SAFE_INTEGER, max = NumberMAX_SAFE_INTEGER)` */
+  validateInteger: $newCppFunction("NodeValidator.cpp", "jsFunction_validateInteger", 0),
+  /** `(value, name, min = undefined, max)` */
+  validateNumber: $newCppFunction("NodeValidator.cpp", "jsFunction_validateNumber", 0),
+  /** `(value, name)` */
+  validateString: $newCppFunction("NodeValidator.cpp", "jsFunction_validateString", 0),
+  /** `(number, name)` */
+  validateFiniteNumber: $newCppFunction("NodeValidator.cpp", "jsFunction_validateFiniteNumber", 0),
+  /** `(number, name, lower, upper, def)` */
+  checkRangesOrGetDefault: $newCppFunction("NodeValidator.cpp", "jsFunction_checkRangesOrGetDefault", 0),
+  /** `(value, name)` */
+  validateFunction: $newCppFunction("NodeValidator.cpp", "jsFunction_validateFunction", 0),
+  /** `(value, name)` */
+  validateBoolean: $newCppFunction("NodeValidator.cpp", "jsFunction_validateBoolean", 0),
+  /** `(port, name = 'Port', allowZero = true)` */
+  validatePort: $newCppFunction("NodeValidator.cpp", "jsFunction_validatePort", 0),
+  /** `(signal, name)` */
+  validateAbortSignal: $newCppFunction("NodeValidator.cpp", "jsFunction_validateAbortSignal", 0),
+  /** `(value, name, minLength = 0)` */
+  validateArray: $newCppFunction("NodeValidator.cpp", "jsFunction_validateArray", 0),
+  /** `(value, name, min = -2147483648, max = 2147483647)` */
+  validateInt32: $newCppFunction("NodeValidator.cpp", "jsFunction_validateInt32", 0),
+  /** `(value, name, positive = false)` */
+  validateUint32: $newCppFunction("NodeValidator.cpp", "jsFunction_validateUint32", 0),
+  /** `(signal, name = 'signal')` */
+  validateSignalName: $newCppFunction("NodeValidator.cpp", "jsFunction_validateSignalName", 0),
+  /** `(data, encoding)` */
+  validateEncoding: $newCppFunction("NodeValidator.cpp", "jsFunction_validateEncoding", 0),
+  /** `(value, name)` */
+  validatePlainFunction: $newCppFunction("NodeValidator.cpp", "jsFunction_validatePlainFunction", 0),
+  /** `(value, name)` */
+  validateUndefined: $newCppFunction("NodeValidator.cpp", "jsFunction_validateUndefined", 0),
+  /** `(buffer, name = 'buffer')` */
+  validateBuffer: $newCppFunction("NodeValidator.cpp", "jsFunction_validateBuffer", 0),
+};
diff --git a/src/js/node/assert.ts b/src/js/node/assert.ts
index f2445c83da..e5343bd18e 100644
--- a/src/js/node/assert.ts
+++ b/src/js/node/assert.ts
@@ -655,7 +655,7 @@ var require_assertion_error = __commonJS({
       function AssertionError2(options) {
         var _this;
         if ((_classCallCheck(this, AssertionError2), _typeof(options) !== "object" || options === null))
-          throw new ERR_INVALID_ARG_TYPE("options", "Object", options);
+          throw new ERR_INVALID_ARG_TYPE("options", "object", options);
         var message = options.message,
           operator = options.operator,
           stackStartFn = options.stackStartFn,
@@ -1083,7 +1083,7 @@ var require_assert = __commonJS({
           : expected.$call({}, actual) === !0;
     }
     function getActual(fn) {
-      if (typeof fn != "function") throw new ERR_INVALID_ARG_TYPE("fn", "Function", fn);
+      if (typeof fn != "function") throw new ERR_INVALID_ARG_TYPE("fn", "function", fn);
       try {
         fn();
       } catch (e) {
diff --git a/src/js/node/async_hooks.ts b/src/js/node/async_hooks.ts
index e8814aa590..db0f0b8272 100644
--- a/src/js/node/async_hooks.ts
+++ b/src/js/node/async_hooks.ts
@@ -8,7 +8,7 @@
 // first element of this tuple. Inside of PromiseOperations.js, we "snapshot" the context (store it
 // in the promise reaction) and then just before we call .then, we restore it.
 //
-// This means context tracking is *kind-of* manual. If we recieve a callback in native code
+// This means context tracking is *kind-of* manual. If we receive a callback in native code
 // - In Zig, call jsValue.withAsyncContextIfNeeded(); which returns another JSValue. Store that and
 //   then run .$call() on it later.
 // - In C++, call AsyncContextFrame::withAsyncContextIfNeeded(jsValue). Then to call it,
@@ -136,7 +136,7 @@ class AsyncLocalStorage {
     return this.run(undefined, cb, ...args);
   }
 
-  // This function is literred with $asserts to ensure that everything that
+  // This function is litered with $asserts to ensure that everything that
   // is assumed to be true is *actually* true.
   run(store_value, callback, ...args) {
     $debug("run " + (this as any).__id__);
@@ -303,9 +303,9 @@ class AsyncResource {
 
 // The rest of async_hooks is not implemented and is stubbed with no-ops and warnings.
 
-function createWarning(message) {
+function createWarning(message, isCreateHook?: boolean) {
   let warned = false;
-  var wrapped = function () {
+  var wrapped = function (arg1?) {
     if (warned) return;
 
     const known_supported_modules = [
@@ -315,6 +315,19 @@ function createWarning(message) {
     ];
     const e = new Error().stack!;
     if (known_supported_modules.some(m => e.includes(m))) return;
+    if (isCreateHook && arg1) {
+      // this block is to specifically filter out react-server, which is often
+      // times bundled into a framework or application. Their use defines three
+      // handlers which are all TODO stubs. for more info see this comment:
+      // https://github.com/oven-sh/bun/issues/13866#issuecomment-2397896065
+      if (typeof arg1 === 'object') {
+        const { init, promiseResolve, destroy } = arg1;
+        if (init && promiseResolve && destroy) {
+          if (isEmptyFunction(init) && isEmptyFunction(destroy))
+            return;
+        }
+      }
+    }
 
     warned = true;
     console.warn("[bun] Warning:", message);
@@ -322,13 +335,21 @@ function createWarning(message) {
   return wrapped;
 }
 
+function isEmptyFunction(f: Function) {
+  let str = f.toString();
+  if(!str.startsWith('function()'))return false;
+  str = str.slice('function()'.length).trim();
+  return /^{\s*}$/.test(str);
+}
+
 const createHookNotImpl = createWarning(
   "async_hooks.createHook is not implemented in Bun. Hooks can still be created but will never be called.",
+  true,
 );
 
 function createHook(callbacks) {
   return {
-    enable: createHookNotImpl,
+    enable: () => createHookNotImpl(callbacks),
     disable: createHookNotImpl,
   };
 }
diff --git a/src/js/node/child_process.ts b/src/js/node/child_process.ts
index 655272b80e..44225330a0 100644
--- a/src/js/node/child_process.ts
+++ b/src/js/node/child_process.ts
@@ -4,6 +4,13 @@ const StreamModule = require("node:stream");
 const OsModule = require("node:os");
 const { ERR_INVALID_ARG_TYPE, ERR_IPC_DISCONNECTED } = require("internal/errors");
 const { kHandle } = require("internal/shared");
+const {
+  validateBoolean,
+  validateFunction,
+  validateString,
+  validateAbortSignal,
+  validateArray,
+} = require("internal/validators");
 
 var NetModule;
 
@@ -551,27 +558,39 @@ function spawnSync(file, args, options) {
     }
   }
 
-  const {
-    stdout = null,
-    stderr = null,
-    success,
-    exitCode,
-  } = Bun.spawnSync({
-    cmd: options.args,
-    env: options.env || undefined,
-    cwd: options.cwd || undefined,
-    stdio: bunStdio,
-    windowsVerbatimArguments: options.windowsVerbatimArguments,
-    windowsHide: options.windowsHide,
-  });
+  var error;
+  try {
+    var {
+      stdout = null,
+      stderr = null,
+      success,
+      exitCode,
+      signalCode,
+    } = Bun.spawnSync({
+      cmd: options.args,
+      env: options.env || undefined,
+      cwd: options.cwd || undefined,
+      stdio: bunStdio,
+      windowsVerbatimArguments: options.windowsVerbatimArguments,
+      windowsHide: options.windowsHide,
+    });
+  } catch (err) {
+    error = err;
+    stdout = null;
+    stderr = null;
+  }
 
   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],
   };
 
+  if (error) {
+    result.error = error;
+  }
+
   if (stdout && encoding && encoding !== "buffer") {
     result.output[1] = result.output[1]?.toString(encoding);
   }
@@ -583,8 +602,11 @@ function spawnSync(file, args, options) {
   result.stdout = result.output[1];
   result.stderr = result.output[2];
 
-  if (!success) {
+  if (!success && error == null) {
     result.error = new SystemError(result.output[2], options.file, "spawnSync", -1, result.status);
+  }
+
+  if (result.error) {
     result.error.spawnargs = ArrayPrototypeSlice.$call(options.args, 1);
   }
 
@@ -1114,8 +1136,6 @@ class ChildProcess extends EventEmitter {
             if (autoResume) pipe.resume();
             return pipe;
           }
-          case "inherit":
-            return process[fdToStdioName(i)] || null;
           case "destroyed":
             return new ShimmedStdioOutStream();
           default:
@@ -1293,7 +1313,7 @@ class ChildProcess extends EventEmitter {
       options = undefined;
     } else if (options !== undefined) {
       if (typeof options !== "object" || options === null) {
-        throw ERR_INVALID_ARG_TYPE("options", "Object", options);
+        throw ERR_INVALID_ARG_TYPE("options", "object", options);
       }
     }
 
@@ -1585,35 +1605,6 @@ function validateTimeout(timeout) {
   }
 }
 
-function validateBoolean(value, name) {
-  if (typeof value !== "boolean") throw ERR_INVALID_ARG_TYPE(name, "boolean", value);
-}
-
-/**
- * @callback validateFunction
- * @param {*} value
- * @param {string} name
- * @returns {asserts value is Function}
- */
-
-/** @type {validateFunction} */
-function validateFunction(value, name) {
-  if (typeof value !== "function") throw ERR_INVALID_ARG_TYPE(name, "Function", value);
-}
-
-/**
- * @callback validateAbortSignal
- * @param {*} signal
- * @param {string} name
- */
-
-/** @type {validateAbortSignal} */
-const validateAbortSignal = (signal, name) => {
-  if (signal !== undefined && (signal === null || typeof signal !== "object" || !("aborted" in signal))) {
-    throw ERR_INVALID_ARG_TYPE(name, "AbortSignal", signal);
-  }
-};
-
 /**
  * @callback validateOneOf
  * @template T
@@ -1661,38 +1652,6 @@ const validateObject = (value, name, options = null) => {
   }
 };
 
-/**
- * @callback validateArray
- * @param {*} value
- * @param {string} name
- * @param {number} [minLength]
- * @returns {asserts value is any[]}
- */
-
-/** @type {validateArray} */
-const validateArray = (value, name, minLength = 0) => {
-  // const validateArray = hideStackFrames((value, name, minLength = 0) => {
-  if (!$isJSArray(value)) {
-    throw ERR_INVALID_ARG_TYPE(name, "Array", value);
-  }
-  if (value.length < minLength) {
-    const reason = `must be longer than ${minLength}`;
-    throw ERR_INVALID_ARG_VALUE(name, value, reason);
-  }
-};
-
-/**
- * @callback validateString
- * @param {*} value
- * @param {string} name
- * @returns {asserts value is string}
- */
-
-/** @type {validateString} */
-function validateString(value, name) {
-  if (typeof value !== "string") throw ERR_INVALID_ARG_TYPE(name, "string", value);
-}
-
 function isInt32(value) {
   return value === (value | 0);
 }
@@ -1765,7 +1724,7 @@ class AbortError extends Error {
   name = "AbortError";
   constructor(message = "The operation was aborted", options = undefined) {
     if (options !== undefined && typeof options !== "object") {
-      throw ERR_INVALID_ARG_TYPE("options", "Object", options);
+      throw ERR_INVALID_ARG_TYPE("options", "object", options);
     }
     super(message, options);
   }
diff --git a/src/js/node/crypto.ts b/src/js/node/crypto.ts
index 41edf9d099..3d6da6f6d3 100644
--- a/src/js/node/crypto.ts
+++ b/src/js/node/crypto.ts
@@ -4,7 +4,7 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 const StreamModule = require("node:stream");
 const BufferModule = require("node:buffer");
 const StringDecoder = require("node:string_decoder").StringDecoder;
-
+const { CryptoHasher } = Bun;
 const {
   symmetricKeySize,
   asymmetricKeyDetails,
@@ -1194,7 +1194,7 @@ var require_browser2 = __commonJS({
     // does not become a node stream unless you create it into one
     const LazyHash = function Hash(algorithm, options) {
       this._options = options;
-      this._hasher = new CryptoHasher(algorithm, options);
+      this._hasher = new CryptoHasher(algorithm);
       this._finalized = false;
     };
     LazyHash.prototype = Object.create(StreamModule.Transform.prototype);
@@ -1203,7 +1203,7 @@ var require_browser2 = __commonJS({
       this._hasher.update(data, encoding);
       return this;
     };
-    LazyHash.prototype.digest = function update(data, encoding) {
+    LazyHash.prototype.digest = function digest(data, encoding) {
       this._checkFinalized();
       this._finalized = true;
       return this._hasher.digest(data, encoding);
@@ -1334,8 +1334,8 @@ var require_browser2 = __commonJS({
       });
     }
 
-    module.exports = function createHash(algorithm) {
-      return new LazyHash(algorithm);
+    module.exports = function createHash(algorithm, options) {
+      return new LazyHash(algorithm, options);
     };
 
     module.exports.createHash = module.exports;
@@ -11443,8 +11443,6 @@ var require_browser9 = __commonJS({
   },
 });
 
-const { CryptoHasher } = globalThis.Bun;
-
 // node_modules/randomfill/browser.js
 var require_browser11 = __commonJS({
   "node_modules/randomfill/browser.js"(exports) {
@@ -11560,8 +11558,7 @@ var require_crypto_browserify2 = __commonJS({
 // crypto.js
 var crypto_exports = require_crypto_browserify2();
 
-var DEFAULT_ENCODING = "buffer",
-  getRandomValues = array => crypto.getRandomValues(array),
+var getRandomValues = array => crypto.getRandomValues(array),
   randomUUID = () => crypto.randomUUID(),
   timingSafeEqual =
     "timingSafeEqual" in crypto
@@ -11578,7 +11575,7 @@ var DEFAULT_ENCODING = "buffer",
     "scryptSync" in crypto
       ? (password, salt, keylen, options) => {
           let res = crypto.scryptSync(password, salt, keylen, options);
-          return DEFAULT_ENCODING !== "buffer" ? new Buffer(res).toString(DEFAULT_ENCODING) : new Buffer(res);
+          return new Buffer(res);
         }
       : void 0,
   scrypt =
@@ -11592,11 +11589,7 @@ var DEFAULT_ENCODING = "buffer",
           }
           try {
             let result = crypto.scryptSync(password, salt, keylen, options);
-            process.nextTick(
-              callback,
-              null,
-              DEFAULT_ENCODING !== "buffer" ? new Buffer(result).toString(DEFAULT_ENCODING) : new Buffer(result),
-            );
+            process.nextTick(callback, null, new Buffer(result));
           } catch (err2) {
             throw err2;
           }
@@ -12040,18 +12033,23 @@ crypto_exports.publicDecrypt = function (key, message) {
   return doAsymmetricSign(key, message, publicDecrypt, true);
 };
 
-__export(crypto_exports, {
-  DEFAULT_ENCODING: () => DEFAULT_ENCODING,
-  getRandomValues: () => getRandomValues,
-  randomUUID: () => randomUUID,
-  randomInt: () => randomInt,
-  getCurves: () => getCurves,
-  scrypt: () => scrypt,
-  scryptSync: () => scryptSync,
-  timingSafeEqual: () => timingSafeEqual,
-  webcrypto: () => webcrypto,
-  subtle: () => _subtle,
-});
+crypto_exports.hash = function hash(algorithm, input, outputEncoding = "hex") {
+  return CryptoHasher.hash(algorithm, input, outputEncoding);
+};
+
+crypto_exports.getFips = function getFips() {
+  return 0;
+};
+
+crypto_exports.getRandomValues = getRandomValues;
+crypto_exports.randomUUID = randomUUID;
+crypto_exports.randomInt = randomInt;
+crypto_exports.getCurves = getCurves;
+crypto_exports.scrypt = scrypt;
+crypto_exports.scryptSync = scryptSync;
+crypto_exports.timingSafeEqual = timingSafeEqual;
+crypto_exports.webcrypto = webcrypto;
+crypto_exports.subtle = _subtle;
 
 export default crypto_exports;
 /*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
diff --git a/src/js/node/dgram.ts b/src/js/node/dgram.ts
index 4093197f11..b83c64bafd 100644
--- a/src/js/node/dgram.ts
+++ b/src/js/node/dgram.ts
@@ -35,6 +35,13 @@ const async_id_symbol = Symbol("async_id_symbol");
 
 const { hideFromStack, throwNotImplemented } = require("internal/shared");
 const { ERR_SOCKET_BAD_TYPE } = require("internal/errors");
+const {
+  validateString,
+  validateNumber,
+  validateFunction,
+  validatePort,
+  validateAbortSignal,
+} = require("internal/validators");
 
 const {
   FunctionPrototypeBind,
@@ -128,54 +135,6 @@ function isInt32(value) {
   return value === (value | 0);
 }
 
-function validateAbortSignal(signal, name) {
-  if (signal !== undefined && (signal === null || typeof signal !== "object" || !("aborted" in signal))) {
-    throw new ERR_INVALID_ARG_TYPE(name, "AbortSignal", signal);
-  }
-}
-hideFromStack(validateAbortSignal);
-
-function validateString(value, name) {
-  if (typeof value !== "string") throw new ERR_INVALID_ARG_TYPE(name, "string", value);
-}
-hideFromStack(validateString);
-
-function validateNumber(value, name, min?, max?) {
-  if (typeof value !== "number") throw new ERR_INVALID_ARG_TYPE(name, "number", value);
-
-  if (
-    (min != null && value < min) ||
-    (max != null && value > max) ||
-    ((min != null || max != null) && NumberIsNaN(value))
-  ) {
-    throw new ERR_OUT_OF_RANGE(
-      name,
-      `${min != null ? `>= ${min}` : ""}${min != null && max != null ? " && " : ""}${max != null ? `<= ${max}` : ""}`,
-      value,
-    );
-  }
-}
-hideFromStack(validateNumber);
-
-function validatePort(port, name = "Port", allowZero = true) {
-  if (
-    (typeof port !== "number" && typeof port !== "string") ||
-    (typeof port === "string" && StringPrototypeTrim(port).length === 0) ||
-    +port !== +port >>> 0 ||
-    port > 0xffff ||
-    (port === 0 && !allowZero)
-  ) {
-    throw new ERR_SOCKET_BAD_PORT(name, port, allowZero);
-  }
-  return port | 0;
-}
-hideFromStack(validatePort);
-
-function validateFunction(value, name) {
-  if (typeof value !== "function") throw new ERR_INVALID_ARG_TYPE(name, "Function", value);
-}
-hideFromStack(validateFunction);
-
 // placeholder
 function defaultTriggerAsyncIdScope(triggerAsyncId, block, ...args) {
   return block.$apply(null, args);
diff --git a/src/js/node/diagnostics_channel.ts b/src/js/node/diagnostics_channel.ts
index 0b6a0e39d7..57722725e7 100644
--- a/src/js/node/diagnostics_channel.ts
+++ b/src/js/node/diagnostics_channel.ts
@@ -1,5 +1,9 @@
 // Hardcoded module "node:diagnostics_channel"
 // Reference: https://github.com/nodejs/node/blob/fb47afc335ef78a8cef7eac52b8ee7f045300696/lib/diagnostics_channel.js
+
+const { validateFunction } = require("internal/validators");
+const { ERR_INVALID_ARG_TYPE } = require("internal/errors");
+
 const SafeMap = Map;
 const SafeFinalizationRegistry = FinalizationRegistry;
 
@@ -208,7 +212,7 @@ function channel(name) {
   if (channel) return channel;
 
   if (typeof name !== "string" && typeof name !== "symbol") {
-    throw new ERR_INVALID_ARG_TYPE("channel", ["string", "symbol"], name);
+    throw ERR_INVALID_ARG_TYPE("channel", "string or symbol", name);
   }
 
   return new Channel(name);
@@ -233,7 +237,7 @@ const traceEvents = ["start", "end", "asyncStart", "asyncEnd", "error"];
 
 function assertChannel(value, name) {
   if (!(value instanceof Channel)) {
-    throw new ERR_INVALID_ARG_TYPE(name, ["Channel"], value);
+    throw ERR_INVALID_ARG_TYPE(name, ["Channel"], value);
   }
 }
 
@@ -260,7 +264,7 @@ class TracingChannel {
       this.asyncEnd = asyncEnd;
       this.error = error;
     } else {
-      throw new ERR_INVALID_ARG_TYPE("nameOrChannels", ["string", "object", "Channel"], nameOrChannels);
+      throw ERR_INVALID_ARG_TYPE("nameOrChannels", ["string, object, or Channel"], nameOrChannels);
     }
   }
 
@@ -366,9 +370,7 @@ class TracingChannel {
     }
 
     const callback = ArrayPrototypeAt.$call(args, position);
-    if (typeof callback !== "function") {
-      throw new ERR_INVALID_ARG_TYPE("callback", ["function"], callback);
-    }
+    validateFunction(callback, "callback");
     ArrayPrototypeSplice.$call(args, position, 1, wrappedCallback);
 
     return start.runStores(context, () => {
@@ -389,21 +391,6 @@ function tracingChannel(nameOrChannels) {
   return new TracingChannel(nameOrChannels);
 }
 
-class ERR_INVALID_ARG_TYPE extends TypeError {
-  constructor(name, expected, actual) {
-    super(`The ${name} argument must be of type ${expected}. Received type ${typeof actual}`);
-    this.code = "ERR_INVALID_ARG_TYPE";
-  }
-}
-
-function validateFunction(callable, field) {
-  if (typeof callable !== "function") {
-    throw new ERR_INVALID_ARG_TYPE(field, "Function", callable);
-  }
-
-  return callable;
-}
-
 export default {
   channel,
   hasSubscribers,
diff --git a/src/js/node/events.ts b/src/js/node/events.ts
index ca9cce2d3b..2bdb3a4bd5 100644
--- a/src/js/node/events.ts
+++ b/src/js/node/events.ts
@@ -1,7 +1,36 @@
 // Reimplementation of https://nodejs.org/api/events.html
 
 // Reference: https://github.com/nodejs/node/blob/main/lib/events.js
-const { throwNotImplemented } = require("internal/shared");
+
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+const { ERR_INVALID_ARG_TYPE } = require("internal/errors");
+const {
+  validateObject,
+  validateInteger,
+  validateAbortSignal,
+  validateNumber,
+  validateBoolean,
+} = require("internal/validators");
 
 const SymbolFor = Symbol.for;
 
@@ -15,6 +44,9 @@ const kFirstEventParam = SymbolFor("nodejs.kFirstEventParam");
 const captureRejectionSymbol = SymbolFor("nodejs.rejection");
 const ArrayPrototypeSlice = Array.prototype.slice;
 
+let FixedQueue;
+const kEmptyObject = Object.freeze({ __proto__: null });
+
 var defaultMaxListeners = 10;
 
 // EventEmitter must be a standard function because some old code will do weird tricks like `EventEmitter.$apply(this)`.
@@ -29,6 +61,7 @@ const EventEmitter = function EventEmitter(opts) {
     this.emit = emitWithRejectionCapture;
   }
 };
+Object.defineProperty(EventEmitter, "name", { value: "EventEmitter", configurable: true });
 const EventEmitterPrototype = (EventEmitter.prototype = {});
 
 EventEmitterPrototype._events = undefined;
@@ -317,7 +350,8 @@ EventEmitterPrototype.eventNames = function eventNames() {
 
 EventEmitterPrototype[kCapture] = false;
 
-function once(emitter, type, options) {
+function once(emitter, type, options = kEmptyObject) {
+  validateObject(options, "options");
   var signal = options?.signal;
   validateAbortSignal(signal, "options.signal");
   if (signal?.aborted) {
@@ -358,70 +392,170 @@ function once(emitter, type, options) {
   return promise;
 }
 
-function on(emitter, event, options = {}) {
+const AsyncIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf(async function* () {}).prototype);
+function createIterResult(value, done) {
+  return { value, done };
+}
+function on(emitter, event, options = kEmptyObject) {
+  // Parameters validation
+  validateObject(options, "options");
   const signal = options.signal;
+  validateAbortSignal(signal, "options.signal");
+  if (signal?.aborted) throw new AbortError(undefined, { cause: signal?.reason });
+  // Support both highWaterMark and highWatermark for backward compatibility
+  const highWatermark = options.highWaterMark ?? options.highWatermark ?? Number.MAX_SAFE_INTEGER;
+  validateInteger(highWatermark, "options.highWaterMark", 1);
+  // Support both lowWaterMark and lowWatermark for backward compatibility
+  const lowWatermark = options.lowWaterMark ?? options.lowWatermark ?? 1;
+  validateInteger(lowWatermark, "options.lowWaterMark", 1);
 
-  const { FixedQueue } = require("internal/fixed_queue");
-  const unconsumedPromises = new FixedQueue();
+  // Preparing controlling queues and variables
+  FixedQueue ??= require("internal/fixed_queue").FixedQueue;
   const unconsumedEvents = new FixedQueue();
-  const unconsumedErrors = new FixedQueue();
-  let done = false;
+  const unconsumedPromises = new FixedQueue();
+  let paused = false;
+  let error = null;
+  let finished = false;
+  let size = 0;
 
-  const eventHandlerBody = ev => {
-    // If there is a pending Promise -> resolve with current event value.
-    if (!unconsumedPromises.isEmpty()) {
-      const { resolve } = unconsumedPromises.shift();
-      return resolve(ev);
+  const iterator = Object.setPrototypeOf(
+    {
+      next() {
+        // First, we consume all unread events
+        if (size) {
+          const value = unconsumedEvents.shift();
+          size--;
+          if (paused && size < lowWatermark) {
+            emitter.resume();
+            paused = false;
+          }
+          return Promise.resolve(createIterResult(value, false));
+        }
+
+        // Then we error, if an error happened
+        // This happens one time if at all, because after 'error'
+        // we stop listening
+        if (error) {
+          const p = Promise.reject(error);
+          // Only the first element errors
+          error = null;
+          return p;
+        }
+
+        // If the iterator is finished, resolve to done
+        if (finished) return closeHandler();
+
+        // Wait until an event happens
+        return new Promise(function (resolve, reject) {
+          unconsumedPromises.push({ resolve, reject });
+        });
+      },
+
+      return() {
+        return closeHandler();
+      },
+
+      throw(err) {
+        if (!err || !(err instanceof Error)) {
+          throw ERR_INVALID_ARG_TYPE("EventEmitter.AsyncIterator", "Error", err);
+        }
+        errorHandler(err);
+      },
+      [Symbol.asyncIterator]() {
+        return this;
+      },
+      [kWatermarkData]: {
+        get size() {
+          return size;
+        },
+        get low() {
+          return lowWatermark;
+        },
+        get high() {
+          return highWatermark;
+        },
+        get isPaused() {
+          return paused;
+        },
+      },
+    },
+    AsyncIteratorPrototype,
+  );
+
+  // Adding event handlers
+  const { addEventListener, removeAll } = listenersController();
+  addEventListener(
+    emitter,
+    event,
+    options[kFirstEventParam]
+      ? eventHandler
+      : function (...args) {
+          return eventHandler(args);
+        },
+  );
+  if (event !== "error" && typeof emitter.on === "function") {
+    addEventListener(emitter, "error", errorHandler);
+  }
+  const closeEvents = options?.close;
+  if (closeEvents?.length) {
+    for (let i = 0; i < closeEvents.length; i++) {
+      addEventListener(emitter, closeEvents[i], closeHandler);
     }
-    // Else: Add event value to queue so it can be consumed by a future Promise.
-    unconsumedEvents.push(ev);
-  };
-  const eventHandler = options[kFirstEventParam] ? eventHandlerBody : (...args) => eventHandlerBody(args);
-  emitter.on(event, eventHandler);
-
-  const errorHandler = ex => {
-    if (!unconsumedPromises.isEmpty()) {
-      const { reject } = unconsumedPromises.shift();
-      return reject(ex);
-    }
-    unconsumedErrors.push(ex);
-  };
-  emitter.on("error", errorHandler);
-
-  signal?.addEventListener("abort", () => {
-    emitter.emit("error", new AbortError(undefined, { cause: signal?.reason }));
-  });
-
-  // If any of the close events is emitted -> remove listeners
-  // and yield only the remaining queued-up values in iterator.
-  for (const evName of options?.close || []) {
-    emitter.on(evName, () => {
-      emitter.removeListener(event, eventHandler);
-      emitter.removeListener("error", errorHandler);
-      while (!unconsumedPromises.isEmpty()) {
-        unconsumedPromises.shift().resolve();
-      }
-      done = true;
-    });
   }
 
-  // Create AsyncGeneratorFunction which handles the Iterator logic
-  const iterator = async function* () {
-    while (!done || !unconsumedEvents.isEmpty() || !unconsumedErrors.isEmpty()) {
-      if (!unconsumedEvents.isEmpty()) {
-        yield Promise.$resolve(unconsumedEvents.shift());
-      } else if (!unconsumedErrors.isEmpty()) {
-        yield Promise.$reject(unconsumedErrors.shift());
-      } else {
-        const { promise, reject, resolve } = $newPromiseCapability(Promise);
-        unconsumedPromises.push({ reject, resolve });
-        yield promise;
-      }
-    }
-  };
+  const abortListenerDisposable = signal ? addAbortListener(signal, abortListener) : null;
 
-  // Return AsyncGenerator
-  return iterator();
+  return iterator;
+
+  function abortListener() {
+    errorHandler(new AbortError(undefined, { cause: signal?.reason }));
+  }
+
+  function eventHandler(value) {
+    if (unconsumedPromises.isEmpty()) {
+      size++;
+      if (!paused && size > highWatermark) {
+        paused = true;
+        emitter.pause();
+      }
+      unconsumedEvents.push(value);
+    } else unconsumedPromises.shift().resolve(createIterResult(value, false));
+  }
+
+  function errorHandler(err) {
+    if (unconsumedPromises.isEmpty()) error = err;
+    else unconsumedPromises.shift().reject(err);
+
+    closeHandler();
+  }
+
+  function closeHandler() {
+    abortListenerDisposable?.[Symbol.dispose]();
+    removeAll();
+    finished = true;
+    const doneResult = createIterResult(undefined, true);
+    while (!unconsumedPromises.isEmpty()) {
+      unconsumedPromises.shift().resolve(doneResult);
+    }
+
+    return Promise.resolve(doneResult);
+  }
+}
+function listenersController() {
+  const listeners = [];
+
+  return {
+    addEventListener(emitter, event, handler, flags) {
+      eventTargetAgnosticAddListener(emitter, event, handler, flags);
+      listeners.push([emitter, event, handler, flags]);
+    },
+    removeAll() {
+      while (listeners.length > 0) {
+        const [emitter, event, handler, flags] = listeners.pop();
+        eventTargetAgnosticRemoveListener(emitter, event, handler, flags);
+      }
+    },
+  };
 }
 
 const getEventListenersForEventTarget = $newCppFunction(
@@ -458,31 +592,48 @@ function setMaxListeners(n = defaultMaxListeners, ...eventTargets) {
   }
 }
 
+const jsEventTargetGetEventListenersCount = $newCppFunction(
+  "JSEventTarget.cpp",
+  "jsEventTargetGetEventListenersCount",
+  2,
+);
+
 function listenerCount(emitter, type) {
-  return emitter.listenerCount(type);
+  if ($isCallable(emitter.listenerCount)) {
+    return emitter.listenerCount(type);
+  }
+
+  return jsEventTargetGetEventListenersCount(emitter, type);
 }
 
-function eventTargetAgnosticRemoveListener(emitter, name, listener, flags?) {
+function eventTargetAgnosticRemoveListener(emitter, name, listener, flags) {
   if (typeof emitter.removeListener === "function") {
     emitter.removeListener(name, listener);
-  } else {
+  } else if (typeof emitter.removeEventListener === "function") {
     emitter.removeEventListener(name, listener, flags);
+  } else {
+    throw ERR_INVALID_ARG_TYPE("emitter", "EventEmitter", emitter);
   }
 }
 
 function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
   if (typeof emitter.on === "function") {
-    if (flags.once) emitter.once(name, listener);
-    else emitter.on(name, listener);
-  } else {
+    if (flags?.once) {
+      emitter.once(name, listener);
+    } else {
+      emitter.on(name, listener);
+    }
+  } else if (typeof emitter.addEventListener === "function") {
     emitter.addEventListener(name, listener, flags);
+  } else {
+    throw ERR_INVALID_ARG_TYPE("emitter", "EventEmitter", emitter);
   }
 }
 
 class AbortError extends Error {
   constructor(message = "The operation was aborted", options = undefined) {
     if (options !== undefined && typeof options !== "object") {
-      throw ERR_INVALID_ARG_TYPE("options", "Object", options);
+      throw ERR_INVALID_ARG_TYPE("options", "object", options);
     }
     super(message, options);
     this.code = "ABORT_ERR";
@@ -490,49 +641,18 @@ class AbortError extends Error {
   }
 }
 
-function ERR_INVALID_ARG_TYPE(name, type, value) {
-  const err = new TypeError(`The "${name}" argument must be of type ${type}. Received ${value}`);
-  err.code = "ERR_INVALID_ARG_TYPE";
-  return err;
-}
-
 function ERR_OUT_OF_RANGE(name, range, value) {
   const err = new RangeError(`The "${name}" argument is out of range. It must be ${range}. Received ${value}`);
   err.code = "ERR_OUT_OF_RANGE";
   return err;
 }
 
-function validateAbortSignal(signal, name) {
-  if (signal !== undefined && (signal === null || typeof signal !== "object" || !("aborted" in signal))) {
-    throw ERR_INVALID_ARG_TYPE(name, "AbortSignal", signal);
-  }
-}
-
-function validateNumber(value, name, min?: number, max?: number) {
-  if (typeof value !== "number") throw ERR_INVALID_ARG_TYPE(name, "number", value);
-  if (
-    (min != null && value < min) ||
-    (max != null && value > max) ||
-    ((min != null || max != null) && Number.isNaN(value))
-  ) {
-    throw ERR_OUT_OF_RANGE(
-      name,
-      `${min != null ? `>= ${min}` : ""}${min != null && max != null ? " && " : ""}${max != null ? `<= ${max}` : ""}`,
-      value,
-    );
-  }
-}
-
 function checkListener(listener) {
   if (typeof listener !== "function") {
     throw new TypeError("The listener must be a function");
   }
 }
 
-function validateBoolean(value, name) {
-  if (typeof value !== "boolean") throw ERR_INVALID_ARG_TYPE(name, "boolean", value);
-}
-
 let AsyncResource = null;
 
 const eventTargetMaxListenersSymbol = Symbol("EventTarget.maxListeners");
diff --git a/src/js/node/fs.ts b/src/js/node/fs.ts
index 3b6f205101..88b1b7aab3 100644
--- a/src/js/node/fs.ts
+++ b/src/js/node/fs.ts
@@ -5,6 +5,9 @@ const promises = require("node:fs/promises");
 const Stream = require("node:stream");
 const types = require("node:util/types");
 
+const { ERR_INVALID_ARG_TYPE, ERR_OUT_OF_RANGE } = require("internal/errors");
+const { validateInteger } = require("internal/validators");
+
 const NumberIsFinite = Number.isFinite;
 const DateNow = Date.now;
 const DatePrototypeGetTime = Date.prototype.getTime;
@@ -830,6 +833,18 @@ function ReadStream(this: typeof ReadStream, pathOrFd, options) {
 
   // Get the stream controller
   // We need the pointer to the underlying stream controller for the NativeReadable
+  if (start !== undefined) {
+    validateInteger(start, "start", 0);
+  }
+  if (end === undefined) {
+    end = Infinity;
+  } else if (end !== Infinity) {
+    validateInteger(end, "end", 0);
+    if (start !== undefined && start > end) {
+      throw new ERR_OUT_OF_RANGE("start", `<= "end" (here: ${end})`, start);
+    }
+  }
+
   const stream = blobToStreamWithOffset.$apply(fileRef, [start]);
   var ptr = stream.$bunNativePtr;
   if (!ptr) {
@@ -862,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) {
@@ -1068,6 +1083,11 @@ var WriteStreamClass = (WriteStream = function WriteStream(path, options = defau
     pos = defaultWriteStreamOptions.pos,
   } = options;
 
+  if (start !== undefined) {
+    validateInteger(start, "start", 0);
+    options.pos = start;
+  }
+
   var tempThis = {};
   var handle = null;
   if (fd != null) {
@@ -1165,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: {
@@ -1542,7 +1563,6 @@ setName(chown, "chown");
 setName(chownSync, "chownSync");
 setName(close, "close");
 setName(closeSync, "closeSync");
-setName(constants, "constants");
 setName(copyFile, "copyFile");
 setName(copyFileSync, "copyFileSync");
 setName(cp, "cp");
@@ -1579,7 +1599,6 @@ setName(mkdtemp, "mkdtemp");
 setName(mkdtempSync, "mkdtempSync");
 setName(open, "open");
 setName(openSync, "openSync");
-setName(promises, "promises");
 setName(read, "read");
 setName(readFile, "readFile");
 setName(readFileSync, "readFileSync");
diff --git a/src/js/node/http.ts b/src/js/node/http.ts
index 01fc370279..08cd434ade 100644
--- a/src/js/node/http.ts
+++ b/src/js/node/http.ts
@@ -6,6 +6,7 @@ const { ERR_INVALID_ARG_TYPE, ERR_INVALID_PROTOCOL } = require("internal/errors"
 const { isPrimary } = require("internal/cluster/isPrimary");
 const { kAutoDestroyed } = require("internal/shared");
 const { urlToHttpOptions } = require("internal/url");
+const { validateFunction, checkIsHttpToken } = require("internal/validators");
 
 const {
   getHeader,
@@ -58,8 +59,7 @@ function checkInvalidHeaderChar(val: string) {
 
 const validateHeaderName = (name, label) => {
   if (typeof name !== "string" || !name || !checkIsHttpToken(name)) {
-    // throw new ERR_INVALID_HTTP_TOKEN(label || "Header name", name);
-    throw new Error("ERR_INVALID_HTTP_TOKEN");
+    throw $ERR_INVALID_HTTP_TOKEN(`The arguments Header name is invalid. Received ${name}`);
   }
 };
 
@@ -131,13 +131,6 @@ function validateMsecs(numberlike: any, field: string) {
 
   return numberlike;
 }
-function validateFunction(callable: any, field: string) {
-  if (typeof callable !== "function") {
-    throw ERR_INVALID_ARG_TYPE(field, "Function", callable);
-  }
-
-  return callable;
-}
 
 type FakeSocket = InstanceType<typeof FakeSocket>;
 var FakeSocket = class Socket extends Duplex {
@@ -284,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 () {
@@ -784,6 +777,9 @@ function requestHasNoBody(method, req) {
   if ("GET" === method || "HEAD" === method || "TRACE" === method || "CONNECT" === method || "OPTIONS" === method)
     return true;
   const headers = req?.headers;
+  const encoding = headers?.["transfer-encoding"];
+  if (encoding?.indexOf?.("chunked") !== -1) return false;
+
   const contentLength = headers?.["content-length"];
   if (!parseInt(contentLength, 10)) return true;
 
@@ -845,12 +841,15 @@ IncomingMessage.prototype = {
       return;
     }
 
-    const contentLength = this.headers["content-length"];
-    const length = contentLength ? parseInt(contentLength, 10) : 0;
-    if (length === 0) {
-      this[noBodySymbol] = true;
-      callback();
-      return;
+    const encoding = this.headers["transfer-encoding"];
+    if (encoding?.indexOf?.("chunked") === -1) {
+      const contentLength = this.headers["content-length"];
+      const length = contentLength ? parseInt(contentLength, 10) : 0;
+      if (length === 0) {
+        this[noBodySymbol] = true;
+        callback();
+        return;
+      }
     }
 
     callback();
@@ -982,7 +981,6 @@ async function consumeStream(self, reader: ReadableStreamDefaultReader) {
       } else {
         ({ done, value } = result);
       }
-
       if (self.destroyed || (aborted = self[abortedSymbol])) {
         break;
       }
@@ -1486,6 +1484,9 @@ class ClientRequest extends OutgoingMessage {
   #socketPath;
 
   #bodyChunks: Buffer[] | null = null;
+  #stream: ReadableStream | null = null;
+  #controller: ReadableStream | null = null;
+
   #fetchRequest;
   #signal: AbortSignal | null = null;
   [kAbortController]: AbortController | null = null;
@@ -1519,24 +1520,93 @@ class ClientRequest extends OutgoingMessage {
     return this.#agent;
   }
 
+  #createStream() {
+    if (!this.#stream) {
+      var self = this;
+
+      this.#stream = new ReadableStream({
+        type: "direct",
+        pull(controller) {
+          self.#controller = controller;
+          for (let chunk of self.#bodyChunks) {
+            if (chunk === null) {
+              controller.close();
+            } else {
+              controller.write(chunk);
+            }
+          }
+          self.#bodyChunks = null;
+        },
+      });
+      this.#startStream();
+    }
+  }
+
   _write(chunk, encoding, callback) {
-    if (!this.#bodyChunks) {
-      this.#bodyChunks = [chunk];
-      callback();
+    if (this.#controller) {
+      if (typeof chunk === "string") {
+        this.#controller.write(Buffer.from(chunk, encoding));
+      } else {
+        this.#controller.write(chunk);
+      }
+      process.nextTick(callback);
       return;
     }
+    if (!this.#bodyChunks) {
+      this.#bodyChunks = [chunk];
+      process.nextTick(callback);
+      return;
+    }
+
     this.#bodyChunks.push(chunk);
-    callback();
+    this.#createStream();
+    process.nextTick(callback);
   }
 
   _writev(chunks, callback) {
-    if (!this.#bodyChunks) {
-      this.#bodyChunks = chunks;
-      callback();
+    if (this.#controller) {
+      const allBuffers = chunks.allBuffers;
+
+      if (allBuffers) {
+        for (let i = 0; i < chunks.length; i++) {
+          this.#controller.write(chunks[i].chunk);
+        }
+      } else {
+        for (let i = 0; i < chunks.length; i++) {
+          this.#controller.write(Buffer.from(chunks[i].chunk, chunks[i].encoding));
+        }
+      }
+      process.nextTick(callback);
       return;
     }
-    this.#bodyChunks.push(...chunks);
-    callback();
+    const allBuffers = chunks.allBuffers;
+    if (this.#bodyChunks) {
+      if (allBuffers) {
+        for (let i = 0; i < chunks.length; i++) {
+          this.#bodyChunks.push(chunks[i].chunk);
+        }
+      } else {
+        for (let i = 0; i < chunks.length; i++) {
+          this.#bodyChunks.push(Buffer.from(chunks[i].chunk, chunks[i].encoding));
+        }
+      }
+    } else {
+      this.#bodyChunks = new Array(chunks.length);
+
+      if (allBuffers) {
+        for (let i = 0; i < chunks.length; i++) {
+          this.#bodyChunks[i] = chunks[i].chunk;
+        }
+      } else {
+        for (let i = 0; i < chunks.length; i++) {
+          this.#bodyChunks[i] = Buffer.from(chunks[i].chunk, chunks[i].encoding);
+        }
+      }
+    }
+    if (this.#bodyChunks.length > 1) {
+      this.#createStream();
+    }
+    process.nextTick(callback);
   }
 
   _destroy(err, callback) {
@@ -1552,26 +1622,12 @@ class ClientRequest extends OutgoingMessage {
     return this.#tls;
   }
 
-  _final(callback) {
-    this.#finished = true;
-    this[kAbortController] = new AbortController();
-    this[kAbortController].signal.addEventListener(
-      "abort",
-      () => {
-        this[kClearTimeout]?.();
-        if (this.destroyed) return;
-        this.emit("abort");
-        this.destroy();
-      },
-      { once: true },
-    );
-    if (this.#signal?.aborted) {
-      this[kAbortController].abort();
-    }
+  #startStream() {
+    if (this.#fetchRequest) return;
 
     var method = this.#method,
-      body = this.#bodyChunks?.length === 1 ? this.#bodyChunks[0] : Buffer.concat(this.#bodyChunks || []);
-
+      body =
+        this.#stream || (this.#bodyChunks?.length === 1 ? this.#bodyChunks[0] : Buffer.concat(this.#bodyChunks || []));
     let url: string;
     let proxy: string | undefined;
     const protocol = this.#protocol;
@@ -1601,7 +1657,7 @@ class ClientRequest extends OutgoingMessage {
         method,
         headers: this.getHeaders(),
         redirect: "manual",
-        signal: this[kAbortController].signal,
+        signal: this[kAbortController]?.signal,
         // Timeouts are handled via this.setTimeout.
         timeout: false,
         // Disable auto gzip/deflate
@@ -1667,11 +1723,40 @@ class ClientRequest extends OutgoingMessage {
     } catch (err) {
       if (!!$debug) globalReportError(err);
       this.emit("error", err);
-    } finally {
-      callback();
     }
   }
 
+  _final(callback) {
+    this.#finished = true;
+    this[kAbortController] = new AbortController();
+    this[kAbortController].signal.addEventListener(
+      "abort",
+      () => {
+        this[kClearTimeout]?.();
+        if (this.destroyed) return;
+        this.emit("abort");
+        this.destroy();
+      },
+      { once: true },
+    );
+    if (this.#signal?.aborted) {
+      this[kAbortController].abort();
+    }
+
+    if (this.#controller) {
+      this.#controller.close();
+      callback();
+      return;
+    }
+    if (this.#bodyChunks?.length > 1) {
+      this.#bodyChunks?.push(null);
+    }
+
+    this.#startStream();
+
+    callback();
+  }
+
   get aborted() {
     return this[abortedSymbol] || this.#signal?.aborted || !!this[kAbortController]?.signal.aborted;
   }
@@ -1773,8 +1858,7 @@ class ClientRequest extends OutgoingMessage {
 
     if (methodIsString && method) {
       if (!checkIsHttpToken(method)) {
-        // throw new ERR_INVALID_HTTP_TOKEN("Method", method);
-        throw new Error("ERR_INVALID_HTTP_TOKEN: Method");
+        throw $ERR_INVALID_HTTP_TOKEN("Method");
       }
       method = this.#method = StringPrototypeToUpperCase.$call(method);
     } else {
@@ -2014,16 +2098,6 @@ function validateHost(host, name) {
   return host;
 }
 
-const tokenRegExp = /^[\^_`a-zA-Z\-0-9!#$%&'*+.|~]+$/;
-/**
- * Verifies that the given val is a valid HTTP token
- * per the rules defined in RFC 7230
- * See https://tools.ietf.org/html/rfc7230#section-3.2.6
- */
-function checkIsHttpToken(val) {
-  return RegExpPrototypeExec.$call(tokenRegExp, val) !== null;
-}
-
 // Copyright Joyent, Inc. and other Node contributors.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a
diff --git a/src/js/node/http2.ts b/src/js/node/http2.ts
index 8a17aa5fb2..bb7544bdbc 100644
--- a/src/js/node/http2.ts
+++ b/src/js/node/http2.ts
@@ -7,27 +7,844 @@ const { hideFromStack, throwNotImplemented } = require("internal/shared");
 
 const tls = require("node:tls");
 const net = require("node:net");
+const fs = require("node:fs");
 const bunTLSConnectOptions = Symbol.for("::buntlsconnectoptions::");
-type Http2ConnectOptions = { settings?: Settings; protocol?: "https:" | "http:"; createConnection?: Function };
+const bunSocketServerOptions = Symbol.for("::bunnetserveroptions::");
+const kInfoHeaders = Symbol("sent-info-headers");
+
+const Stream = require("node:stream");
+const { Readable } = Stream;
+type Http2ConnectOptions = {
+  settings?: Settings;
+  protocol?: "https:" | "http:";
+  createConnection?: Function;
+};
 const TLSSocket = tls.TLSSocket;
+const Socket = net.Socket;
 const EventEmitter = require("node:events");
 const { Duplex } = require("node:stream");
-const primordials = require("internal/primordials");
 
-const [H2FrameParser, getPackedSettings, getUnpackedSettings] = $zig("h2_frame_parser.zig", "createNodeHttp2Binding");
+const {
+  FunctionPrototypeBind,
+  StringPrototypeTrim,
+  ArrayPrototypePush,
+  ObjectAssign,
+  ArrayIsArray,
+  SafeArrayIterator,
+  StringPrototypeToLowerCase,
+  StringPrototypeIncludes,
+  ObjectKeys,
+  ObjectPrototypeHasOwnProperty,
+  SafeSet,
+  DatePrototypeToUTCString,
+  DatePrototypeGetMilliseconds,
+} = require("internal/primordials");
+const RegExpPrototypeExec = RegExp.prototype.exec;
+
+const [H2FrameParser, assertSettings, getPackedSettings, getUnpackedSettings] = $zig(
+  "h2_frame_parser.zig",
+  "createNodeHttp2Binding",
+);
 
 const sensitiveHeaders = Symbol.for("nodejs.http2.sensitiveHeaders");
 const bunHTTP2Native = Symbol.for("::bunhttp2native::");
-const bunHTTP2StreamResponded = Symbol.for("::bunhttp2hasResponded::");
 const bunHTTP2StreamReadQueue = Symbol.for("::bunhttp2ReadQueue::");
-const bunHTTP2Closed = Symbol.for("::bunhttp2closed::");
+
 const bunHTTP2Socket = Symbol.for("::bunhttp2socket::");
-const bunHTTP2WantTrailers = Symbol.for("::bunhttp2WantTrailers::");
+const bunHTTP2StreamFinal = Symbol.for("::bunHTTP2StreamFinal::");
+
+const bunHTTP2StreamStatus = Symbol.for("::bunhttp2StreamStatus::");
+
 const bunHTTP2Session = Symbol.for("::bunhttp2session::");
+const bunHTTP2Headers = Symbol.for("::bunhttp2headers::");
 
 const ReflectGetPrototypeOf = Reflect.getPrototypeOf;
-const FunctionPrototypeBind = primordials.FunctionPrototypeBind;
-const StringPrototypeSlice = String.prototype.slice;
+
+const kBeginSend = Symbol("begin-send");
+const kServer = Symbol("server");
+const kState = Symbol("state");
+const kStream = Symbol("stream");
+const kResponse = Symbol("response");
+const kHeaders = Symbol("headers");
+const kRawHeaders = Symbol("rawHeaders");
+const kTrailers = Symbol("trailers");
+const kRawTrailers = Symbol("rawTrailers");
+const kSetHeader = Symbol("setHeader");
+const kAppendHeader = Symbol("appendHeader");
+const kAborted = Symbol("aborted");
+const kRequest = Symbol("request");
+const {
+  validateInteger,
+  validateString,
+  validateObject,
+  validateFunction,
+  checkIsHttpToken,
+  validateLinkHeaderValue,
+} = require("internal/validators");
+
+let utcCache;
+
+function utcDate() {
+  if (!utcCache) cache();
+  return utcCache;
+}
+
+function cache() {
+  const d = new Date();
+  utcCache = DatePrototypeToUTCString(d);
+  setTimeout(resetCache, 1000 - DatePrototypeGetMilliseconds(d)).unref();
+}
+
+function resetCache() {
+  utcCache = undefined;
+}
+
+function getAuthority(headers) {
+  // For non-CONNECT requests, HTTP/2 allows either :authority
+  // or Host to be used equivalently. The first is preferred
+  // when making HTTP/2 requests, and the latter is preferred
+  // when converting from an HTTP/1 message.
+  if (headers[HTTP2_HEADER_AUTHORITY] !== undefined) return headers[HTTP2_HEADER_AUTHORITY];
+  if (headers[HTTP2_HEADER_HOST] !== undefined) return headers[HTTP2_HEADER_HOST];
+}
+function onStreamData(chunk) {
+  const request = this[kRequest];
+  if (request !== undefined && !request.push(chunk)) this.pause();
+}
+
+function onStreamTrailers(trailers, flags, rawTrailers) {
+  const request = this[kRequest];
+  if (request !== undefined) {
+    ObjectAssign(request[kTrailers], trailers);
+    ArrayPrototypePush(request[kRawTrailers], ...new SafeArrayIterator(rawTrailers));
+  }
+}
+
+function onStreamEnd() {
+  // Cause the request stream to end as well.
+  const request = this[kRequest];
+  if (request !== undefined) this[kRequest].push(null);
+}
+
+function onStreamError(error) {
+  // This is purposefully left blank
+  //
+  // errors in compatibility mode are
+  // not forwarded to the request
+  // and response objects.
+}
+
+function onRequestPause() {
+  this[kStream].pause();
+}
+
+function onRequestResume() {
+  this[kStream].resume();
+}
+
+function onStreamDrain() {
+  const response = this[kResponse];
+  if (response !== undefined) response.emit("drain");
+}
+
+function onStreamAbortedRequest() {
+  const request = this[kRequest];
+  if (request !== undefined && request[kState].closed === false) {
+    request[kAborted] = true;
+    request.emit("aborted");
+  }
+}
+
+function resumeStream(stream) {
+  stream.resume();
+}
+
+function onStreamTrailersReady() {
+  this.sendTrailers(this[kResponse][kTrailers]);
+}
+
+function onStreamCloseResponse() {
+  const res = this[kResponse];
+
+  if (res === undefined) return;
+
+  const state = res[kState];
+
+  if (this.headRequest !== state.headRequest) return;
+
+  state.closed = true;
+
+  this.removeListener("wantTrailers", onStreamTrailersReady);
+  this[kResponse] = undefined;
+  res.emit("finish");
+
+  res.emit("close");
+}
+function onStreamCloseRequest() {
+  const req = this[kRequest];
+
+  if (req === undefined) return;
+
+  const state = req[kState];
+  state.closed = true;
+
+  req.push(null);
+  // If the user didn't interact with incoming data and didn't pipe it,
+  // dump it for compatibility with http1
+  if (!state.didRead && !req._readableState.resumeScheduled) req.resume();
+
+  this[kRequest] = undefined;
+
+  req.emit("close");
+}
+
+function onStreamTimeout() {
+  this.emit("timeout");
+}
+
+function isPseudoHeader(name) {
+  switch (name) {
+    case HTTP2_HEADER_STATUS: // :status
+    case HTTP2_HEADER_METHOD: // :method
+    case HTTP2_HEADER_PATH: // :path
+    case HTTP2_HEADER_AUTHORITY: // :authority
+    case HTTP2_HEADER_SCHEME: // :scheme
+      return true;
+    default:
+      return false;
+  }
+}
+
+function isConnectionHeaderAllowed(name, value) {
+  return name !== HTTP2_HEADER_CONNECTION || value === "trailers";
+}
+let statusConnectionHeaderWarned = false;
+let statusMessageWarned = false;
+function statusMessageWarn() {
+  if (statusMessageWarned === false) {
+    process.emitWarning("Status message is not supported by HTTP/2 (RFC7540 8.1.2.4)", "UnsupportedWarning");
+    statusMessageWarned = true;
+  }
+}
+
+function connectionHeaderMessageWarn() {
+  if (statusConnectionHeaderWarned === false) {
+    process.emitWarning(
+      "The provided connection header is not valid, " +
+        "the value will be dropped from the header and " +
+        "will never be in use.",
+      "UnsupportedWarning",
+    );
+    statusConnectionHeaderWarned = true;
+  }
+}
+
+function assertValidHeader(name, value) {
+  if (name === "" || typeof name !== "string" || StringPrototypeIncludes(name, " ")) {
+    throw $ERR_INVALID_HTTP_TOKEN(`The arguments Header name is invalid. Received ${name}`);
+  }
+  if (isPseudoHeader(name)) {
+    throw $ERR_HTTP2_PSEUDOHEADER_NOT_ALLOWED("Cannot set HTTP/2 pseudo-headers");
+  }
+  if (value === undefined || value === null) {
+    throw $ERR_HTTP2_INVALID_HEADER_VALUE(`Invalid value "${value}" for header "${name}"`);
+  }
+  if (!isConnectionHeaderAllowed(name, value)) {
+    connectionHeaderMessageWarn();
+  }
+}
+
+hideFromStack(assertValidHeader);
+
+class Http2ServerRequest extends Readable {
+  constructor(stream, headers, options, rawHeaders) {
+    super({ autoDestroy: false, ...options });
+    this[kState] = {
+      closed: false,
+      didRead: false,
+    };
+    // Headers in HTTP/1 are not initialized using Object.create(null) which,
+    // although preferable, would simply break too much code. Ergo header
+    // initialization using Object.create(null) in HTTP/2 is intentional.
+    this[kHeaders] = headers;
+    this[kRawHeaders] = rawHeaders;
+    this[kTrailers] = {};
+    this[kRawTrailers] = [];
+    this[kStream] = stream;
+    this[kAborted] = false;
+    stream[kRequest] = this;
+
+    // Pause the stream..
+    stream.on("trailers", onStreamTrailers);
+    stream.on("end", onStreamEnd);
+    stream.on("error", onStreamError);
+    stream.on("aborted", onStreamAbortedRequest);
+    stream.on("close", onStreamCloseRequest);
+    stream.on("timeout", onStreamTimeout);
+    this.on("pause", onRequestPause);
+    this.on("resume", onRequestResume);
+  }
+
+  get aborted() {
+    return this[kAborted];
+  }
+
+  get complete() {
+    return this[kAborted] || this.readableEnded || this[kState].closed || this[kStream].destroyed;
+  }
+
+  get stream() {
+    return this[kStream];
+  }
+
+  get headers() {
+    return this[kHeaders];
+  }
+
+  get rawHeaders() {
+    return this[kRawHeaders];
+  }
+
+  get trailers() {
+    return this[kTrailers];
+  }
+
+  get rawTrailers() {
+    return this[kRawTrailers];
+  }
+
+  get httpVersionMajor() {
+    return 2;
+  }
+
+  get httpVersionMinor() {
+    return 0;
+  }
+
+  get httpVersion() {
+    return "2.0";
+  }
+
+  get socket() {
+    return this[kStream]?.[bunHTTP2Session]?.socket;
+  }
+
+  get connection() {
+    return this.socket;
+  }
+
+  _read(nread) {
+    const state = this[kState];
+    if (!state.didRead) {
+      state.didRead = true;
+      this[kStream].on("data", onStreamData);
+    } else {
+      process.nextTick(resumeStream, this[kStream]);
+    }
+  }
+
+  get method() {
+    return this[kHeaders][HTTP2_HEADER_METHOD];
+  }
+
+  set method(method) {
+    validateString(method, "method");
+    if (StringPrototypeTrim(method) === "")
+      throw $ERR_INVALID_ARG_VALUE(`The arguments method is invalid. Received ${method}`);
+
+    this[kHeaders][HTTP2_HEADER_METHOD] = method;
+  }
+
+  get authority() {
+    return getAuthority(this[kHeaders]);
+  }
+
+  get scheme() {
+    return this[kHeaders][HTTP2_HEADER_SCHEME];
+  }
+
+  get url() {
+    return this[kHeaders][HTTP2_HEADER_PATH];
+  }
+
+  set url(url) {
+    this[kHeaders][HTTP2_HEADER_PATH] = url;
+  }
+
+  setTimeout(msecs, callback) {
+    if (!this[kState].closed) this[kStream].setTimeout(msecs, callback);
+    return this;
+  }
+}
+class Http2ServerResponse extends Stream {
+  constructor(stream, options) {
+    super(options);
+    this[kState] = {
+      closed: false,
+      ending: false,
+      destroyed: false,
+      headRequest: false,
+      sendDate: true,
+      statusCode: HTTP_STATUS_OK,
+    };
+    this[kHeaders] = { __proto__: null };
+    this[kTrailers] = { __proto__: null };
+    this[kStream] = stream;
+    stream[kResponse] = this;
+    this.writable = true;
+    this.req = stream[kRequest];
+    stream.on("drain", onStreamDrain);
+    stream.on("close", onStreamCloseResponse);
+    stream.on("wantTrailers", onStreamTrailersReady);
+    stream.on("timeout", onStreamTimeout);
+  }
+
+  // User land modules such as finalhandler just check truthiness of this
+  // but if someone is actually trying to use this for more than that
+  // then we simply can't support such use cases
+  get _header() {
+    return this.headersSent;
+  }
+
+  get writableEnded() {
+    const state = this[kState];
+    return state.ending;
+  }
+
+  get finished() {
+    const state = this[kState];
+    return state.ending;
+  }
+
+  get socket() {
+    // This is compatible with http1 which removes socket reference
+    // only from ServerResponse but not IncomingMessage
+    if (this[kState].closed) return undefined;
+
+    return this[kStream]?.[bunHTTP2Session]?.socket;
+  }
+
+  get connection() {
+    return this.socket;
+  }
+
+  get stream() {
+    return this[kStream];
+  }
+
+  get headersSent() {
+    return this[kStream].headersSent;
+  }
+
+  get sendDate() {
+    return this[kState].sendDate;
+  }
+
+  set sendDate(bool) {
+    this[kState].sendDate = Boolean(bool);
+  }
+
+  get statusCode() {
+    return this[kState].statusCode;
+  }
+
+  get writableCorked() {
+    return this[kStream].writableCorked;
+  }
+
+  get writableHighWaterMark() {
+    return this[kStream].writableHighWaterMark;
+  }
+
+  get writableFinished() {
+    return this[kStream].writableFinished;
+  }
+
+  get writableLength() {
+    return this[kStream].writableLength;
+  }
+
+  set statusCode(code) {
+    code |= 0;
+    if (code >= 100 && code < 200)
+      throw $ERR_HTTP2_INFO_STATUS_NOT_ALLOWED("Informational status codes cannot be used");
+    if (code < 100 || code > 599) throw $ERR_HTTP2_STATUS_INVALID(`Invalid status code: ${code}`);
+    this[kState].statusCode = code;
+  }
+
+  setTrailer(name, value) {
+    validateString(name, "name");
+    name = StringPrototypeToLowerCase(StringPrototypeTrim(name));
+    assertValidHeader(name, value);
+    this[kTrailers][name] = value;
+  }
+
+  addTrailers(headers) {
+    const keys = ObjectKeys(headers);
+    let key = "";
+    for (let i = 0; i < keys.length; i++) {
+      key = keys[i];
+      this.setTrailer(key, headers[key]);
+    }
+  }
+
+  getHeader(name) {
+    validateString(name, "name");
+    name = StringPrototypeToLowerCase(StringPrototypeTrim(name));
+    return this[kHeaders][name];
+  }
+
+  getHeaderNames() {
+    return ObjectKeys(this[kHeaders]);
+  }
+
+  getHeaders() {
+    const headers = { __proto__: null };
+    return ObjectAssign(headers, this[kHeaders]);
+  }
+
+  hasHeader(name) {
+    validateString(name, "name");
+    name = StringPrototypeToLowerCase(StringPrototypeTrim(name));
+    return ObjectPrototypeHasOwnProperty(this[kHeaders], name);
+  }
+
+  removeHeader(name) {
+    validateString(name, "name");
+    if (this[kStream].headersSent) throw $ERR_HTTP2_HEADERS_SENT("Response has already been initiated");
+
+    name = StringPrototypeToLowerCase(StringPrototypeTrim(name));
+
+    if (name === "date") {
+      this[kState].sendDate = false;
+
+      return;
+    }
+
+    delete this[kHeaders][name];
+  }
+
+  setHeader(name, value) {
+    validateString(name, "name");
+    if (this[kStream].headersSent) throw $ERR_HTTP2_HEADERS_SENT("Response has already been initiated");
+
+    this[kSetHeader](name, value);
+  }
+
+  [kSetHeader](name, value) {
+    name = StringPrototypeToLowerCase(StringPrototypeTrim(name));
+    assertValidHeader(name, value);
+
+    if (!isConnectionHeaderAllowed(name, value)) {
+      return;
+    }
+
+    if (name[0] === ":") assertValidPseudoHeader(name);
+    else if (!checkIsHttpToken(name))
+      this.destroy($ERR_INVALID_HTTP_TOKEN(`The arguments Header name is invalid. Received ${name}`));
+
+    this[kHeaders][name] = value;
+  }
+
+  appendHeader(name, value) {
+    validateString(name, "name");
+    if (this[kStream].headersSent) throw $ERR_HTTP2_HEADERS_SENT("Response has already been initiated");
+
+    this[kAppendHeader](name, value);
+  }
+
+  [kAppendHeader](name, value) {
+    name = StringPrototypeToLowerCase(StringPrototypeTrim(name));
+    assertValidHeader(name, value);
+
+    if (!isConnectionHeaderAllowed(name, value)) {
+      return;
+    }
+
+    if (name[0] === ":") assertValidPseudoHeader(name);
+    else if (!checkIsHttpToken(name))
+      this.destroy($ERR_INVALID_HTTP_TOKEN(`The arguments Header name is invalid. Received ${name}`));
+
+    // Handle various possible cases the same as OutgoingMessage.appendHeader:
+    const headers = this[kHeaders];
+    if (headers === null || !headers[name]) {
+      return this.setHeader(name, value);
+    }
+
+    if (!ArrayIsArray(headers[name])) {
+      headers[name] = [headers[name]];
+    }
+
+    const existingValues = headers[name];
+    if (ArrayIsArray(value)) {
+      for (let i = 0, length = value.length; i < length; i++) {
+        existingValues.push(value[i]);
+      }
+    } else {
+      existingValues.push(value);
+    }
+  }
+
+  get statusMessage() {
+    statusMessageWarn();
+
+    return "";
+  }
+
+  set statusMessage(msg) {
+    statusMessageWarn();
+  }
+
+  flushHeaders() {
+    const state = this[kState];
+    if (!state.closed && !this[kStream].headersSent) this.writeHead(state.statusCode);
+  }
+
+  writeHead(statusCode, statusMessage, headers) {
+    const state = this[kState];
+
+    if (state.closed || this.stream.destroyed) return this;
+    if (this[kStream].headersSent) throw $ERR_HTTP2_HEADERS_SENT("Response has already been initiated");
+
+    if (typeof statusMessage === "string") statusMessageWarn();
+
+    if (headers === undefined && typeof statusMessage === "object") headers = statusMessage;
+
+    let i;
+    if (ArrayIsArray(headers)) {
+      if (this[kHeaders]) {
+        // Headers in obj should override previous headers but still
+        // allow explicit duplicates. To do so, we first remove any
+        // existing conflicts, then use appendHeader. This is the
+        // slow path, which only applies when you use setHeader and
+        // then pass headers in writeHead too.
+
+        // We need to handle both the tuple and flat array formats, just
+        // like the logic further below.
+        if (headers.length && ArrayIsArray(headers[0])) {
+          for (let n = 0; n < headers.length; n += 1) {
+            const key = headers[n + 0][0];
+            this.removeHeader(key);
+          }
+        } else {
+          for (let n = 0; n < headers.length; n += 2) {
+            const key = headers[n + 0];
+            this.removeHeader(key);
+          }
+        }
+      }
+
+      // Append all the headers provided in the array:
+      if (headers.length && ArrayIsArray(headers[0])) {
+        for (i = 0; i < headers.length; i++) {
+          const header = headers[i];
+          this[kAppendHeader](header[0], header[1]);
+        }
+      } else {
+        if (headers.length % 2 !== 0) {
+          throw $ERR_INVALID_ARG_VALUE(`The arguments headers is invalid.`);
+        }
+
+        for (i = 0; i < headers.length; i += 2) {
+          this[kAppendHeader](headers[i], headers[i + 1]);
+        }
+      }
+    } else if (typeof headers === "object") {
+      const keys = ObjectKeys(headers);
+      let key = "";
+      for (i = 0; i < keys.length; i++) {
+        key = keys[i];
+        this[kSetHeader](key, headers[key]);
+      }
+    }
+
+    state.statusCode = statusCode;
+    this[kBeginSend]();
+
+    return this;
+  }
+
+  cork() {
+    this[kStream].cork();
+  }
+
+  uncork() {
+    this[kStream].uncork();
+  }
+
+  write(chunk, encoding, cb) {
+    const state = this[kState];
+
+    if (typeof encoding === "function") {
+      cb = encoding;
+      encoding = "utf8";
+    }
+
+    let err;
+    if (state.ending) {
+      err = $ERR_STREAM_WRITE_AFTER_END(`The stream has ended`);
+    } else if (state.closed) {
+      err = $ERR_HTTP2_INVALID_STREAM(`The stream has been destroyed`);
+    } else if (state.destroyed) {
+      return false;
+    }
+
+    if (err) {
+      if (typeof cb === "function") process.nextTick(cb, err);
+      this.destroy(err);
+      return false;
+    }
+
+    const stream = this[kStream];
+    if (!stream.headersSent) this.writeHead(state.statusCode);
+    return stream.write(chunk, encoding, cb);
+  }
+
+  end(chunk, encoding, cb) {
+    const stream = this[kStream];
+    const state = this[kState];
+
+    if (typeof chunk === "function") {
+      cb = chunk;
+      chunk = null;
+    } else if (typeof encoding === "function") {
+      cb = encoding;
+      encoding = "utf8";
+    }
+
+    if ((state.closed || state.ending) && state.headRequest === stream.headRequest) {
+      if (typeof cb === "function") {
+        process.nextTick(cb);
+      }
+      return this;
+    }
+
+    if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);
+
+    state.headRequest = stream.headRequest;
+    state.ending = true;
+
+    if (typeof cb === "function") {
+      if (stream.writableEnded) this.once("finish", cb);
+      else stream.once("finish", cb);
+    }
+
+    if (!stream.headersSent) this.writeHead(this[kState].statusCode);
+
+    if (this[kState].closed || stream.destroyed) onStreamCloseResponse.$call(stream);
+    else stream.end();
+
+    return this;
+  }
+
+  destroy(err) {
+    if (this[kState].destroyed) return;
+
+    this[kState].destroyed = true;
+    this[kStream].destroy(err);
+  }
+
+  setTimeout(msecs, callback) {
+    if (this[kState].closed) return;
+    this[kStream].setTimeout(msecs, callback);
+  }
+
+  createPushResponse(headers, callback) {
+    validateFunction(callback, "callback");
+    if (this[kState].closed) {
+      const error = $ERR_HTTP2_INVALID_STREAM(`The stream has been destroyed`);
+      process.nextTick(callback, error);
+      return;
+    }
+    this[kStream].pushStream(headers, {}, (err, stream, headers, options) => {
+      if (err) {
+        callback(err);
+        return;
+      }
+      callback(null, new Http2ServerResponse(stream));
+    });
+  }
+
+  [kBeginSend]() {
+    const state = this[kState];
+    const headers = this[kHeaders];
+    headers[HTTP2_HEADER_STATUS] = state.statusCode;
+    const options = {
+      endStream: state.ending,
+      waitForTrailers: true,
+      sendDate: state.sendDate,
+    };
+    this[kStream].respond(headers, options);
+  }
+
+  // TODO doesn't support callbacks
+  writeContinue() {
+    const stream = this[kStream];
+    if (stream.headersSent || this[kState].closed) return false;
+    stream.additionalHeaders({
+      [HTTP2_HEADER_STATUS]: HTTP_STATUS_CONTINUE,
+    });
+    return true;
+  }
+
+  writeEarlyHints(hints) {
+    validateObject(hints, "hints");
+    const headers = { __proto__: null };
+    const linkHeaderValue = validateLinkHeaderValue(hints.link);
+    for (const key of ObjectKeys(hints)) {
+      if (key !== "link") {
+        headers[key] = hints[key];
+      }
+    }
+    if (linkHeaderValue.length === 0) {
+      return false;
+    }
+    const stream = this[kStream];
+    if (stream.headersSent || this[kState].closed) return false;
+    stream.additionalHeaders({
+      ...headers,
+      [HTTP2_HEADER_STATUS]: HTTP_STATUS_EARLY_HINTS,
+      "Link": linkHeaderValue,
+    });
+    return true;
+  }
+}
+
+function onServerStream(Http2ServerRequest, Http2ServerResponse, stream, headers, flags, rawHeaders) {
+  const server = this;
+  const request = new Http2ServerRequest(stream, headers, undefined, rawHeaders);
+  const response = new Http2ServerResponse(stream);
+
+  // Check for the CONNECT method
+  const method = headers[HTTP2_HEADER_METHOD];
+  if (method === "CONNECT") {
+    if (!server.emit("connect", request, response)) {
+      response.statusCode = HTTP_STATUS_METHOD_NOT_ALLOWED;
+      response.end();
+    }
+    return;
+  }
+
+  // Check for Expectations
+  if (headers.expect !== undefined) {
+    if (headers.expect === "100-continue") {
+      if (server.listenerCount("checkContinue")) {
+        server.emit("checkContinue", request, response);
+      } else {
+        response.writeContinue();
+        server.emit("request", request, response);
+      }
+    } else if (server.listenerCount("checkExpectation")) {
+      server.emit("checkExpectation", request, response);
+    } else {
+      response.statusCode = HTTP_STATUS_EXPECTATION_FAILED;
+      response.end();
+    }
+    return;
+  }
+
+  server.emit("request", request, response);
+}
 
 const proxySocketHandler = {
   get(session, prop) {
@@ -46,17 +863,13 @@ const proxySocketHandler = {
       case "setEncoding":
       case "setKeepAlive":
       case "setNoDelay":
-        const error = new Error(
-          "ERR_HTTP2_NO_SOCKET_MANIPULATION: HTTP/2 sockets should not be directly manipulated (e.g. read and written)",
+        throw $ERR_HTTP2_NO_SOCKET_MANIPULATION(
+          "HTTP/2 sockets should not be directly manipulated (e.g. read and written)",
         );
-        error.code = "ERR_HTTP2_NO_SOCKET_MANIPULATION";
-        throw error;
       default: {
         const socket = session[bunHTTP2Socket];
         if (!socket) {
-          const error = new Error("ERR_HTTP2_SOCKET_UNBOUND: The socket has been disconnected from the Http2Session");
-          error.code = "ERR_HTTP2_SOCKET_UNBOUND";
-          throw error;
+          throw $ERR_HTTP2_SOCKET_UNBOUND("The socket has been disconnected from the Http2Session");
         }
         const value = socket[prop];
         return typeof value === "function" ? FunctionPrototypeBind(value, socket) : value;
@@ -66,9 +879,7 @@ const proxySocketHandler = {
   getPrototypeOf(session) {
     const socket = session[bunHTTP2Socket];
     if (!socket) {
-      const error = new Error("ERR_HTTP2_SOCKET_UNBOUND: The socket has been disconnected from the Http2Session");
-      error.code = "ERR_HTTP2_SOCKET_UNBOUND";
-      throw error;
+      throw $ERR_HTTP2_SOCKET_UNBOUND("The socket has been disconnected from the Http2Session");
     }
     return ReflectGetPrototypeOf(socket);
   },
@@ -89,17 +900,13 @@ const proxySocketHandler = {
       case "setEncoding":
       case "setKeepAlive":
       case "setNoDelay":
-        const error = new Error(
-          "ERR_HTTP2_NO_SOCKET_MANIPULATION: HTTP/2 sockets should not be directly manipulated (e.g. read and written)",
+        throw $ERR_HTTP2_NO_SOCKET_MANIPULATION(
+          "HTTP/2 sockets should not be directly manipulated (e.g. read and written)",
         );
-        error.code = "ERR_HTTP2_NO_SOCKET_MANIPULATION";
-        throw error;
       default: {
         const socket = session[bunHTTP2Socket];
         if (!socket) {
-          const error = new Error("ERR_HTTP2_SOCKET_UNBOUND: The socket has been disconnected from the Http2Session");
-          error.code = "ERR_HTTP2_SOCKET_UNBOUND";
-          throw error;
+          throw $ERR_HTTP2_SOCKET_UNBOUND("The socket has been disconnected from the Http2Session");
         }
         socket[prop] = value;
         return true;
@@ -107,7 +914,22 @@ const proxySocketHandler = {
     }
   },
 };
-
+const nameForErrorCode = [
+  "NGHTTP2_NO_ERROR",
+  "NGHTTP2_PROTOCOL_ERROR",
+  "NGHTTP2_INTERNAL_ERROR",
+  "NGHTTP2_FLOW_CONTROL_ERROR",
+  "NGHTTP2_SETTINGS_TIMEOUT",
+  "NGHTTP2_STREAM_CLOSED",
+  "NGHTTP2_FRAME_SIZE_ERROR",
+  "NGHTTP2_REFUSED_STREAM",
+  "NGHTTP2_CANCEL",
+  "NGHTTP2_COMPRESSION_ERROR",
+  "NGHTTP2_CONNECT_ERROR",
+  "NGHTTP2_ENHANCE_YOUR_CALM",
+  "NGHTTP2_INADEQUATE_SECURITY",
+  "NGHTTP2_HTTP_1_1_REQUIRED",
+];
 const constants = {
   NGHTTP2_ERR_FRAME_SIZE_ERROR: -522,
   NGHTTP2_SESSION_SERVER: 0,
@@ -350,12 +1172,313 @@ const constants = {
   HTTP_STATUS_NOT_EXTENDED: 510,
   HTTP_STATUS_NETWORK_AUTHENTICATION_REQUIRED: 511,
 };
+const {
+  NGHTTP2_ERR_FRAME_SIZE_ERROR,
+  NGHTTP2_SESSION_SERVER,
+  NGHTTP2_SESSION_CLIENT,
+  NGHTTP2_STREAM_STATE_IDLE,
+  NGHTTP2_STREAM_STATE_OPEN,
+  NGHTTP2_STREAM_STATE_RESERVED_LOCAL,
+  NGHTTP2_STREAM_STATE_RESERVED_REMOTE,
+  NGHTTP2_STREAM_STATE_HALF_CLOSED_LOCAL,
+  NGHTTP2_STREAM_STATE_HALF_CLOSED_REMOTE,
+  NGHTTP2_STREAM_STATE_CLOSED,
+  NGHTTP2_FLAG_NONE,
+  NGHTTP2_FLAG_END_STREAM,
+  NGHTTP2_FLAG_END_HEADERS,
+  NGHTTP2_FLAG_ACK,
+  NGHTTP2_FLAG_PADDED,
+  NGHTTP2_FLAG_PRIORITY,
+  DEFAULT_SETTINGS_HEADER_TABLE_SIZE,
+  DEFAULT_SETTINGS_ENABLE_PUSH,
+  DEFAULT_SETTINGS_MAX_CONCURRENT_STREAMS,
+  DEFAULT_SETTINGS_INITIAL_WINDOW_SIZE,
+  DEFAULT_SETTINGS_MAX_FRAME_SIZE,
+  DEFAULT_SETTINGS_MAX_HEADER_LIST_SIZE,
+  DEFAULT_SETTINGS_ENABLE_CONNECT_PROTOCOL,
+  MAX_MAX_FRAME_SIZE,
+  MIN_MAX_FRAME_SIZE,
+  MAX_INITIAL_WINDOW_SIZE,
+  NGHTTP2_SETTINGS_HEADER_TABLE_SIZE,
+  NGHTTP2_SETTINGS_ENABLE_PUSH,
+  NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS,
+  NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE,
+  NGHTTP2_SETTINGS_MAX_FRAME_SIZE,
+  NGHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE,
+  NGHTTP2_SETTINGS_ENABLE_CONNECT_PROTOCOL,
+  PADDING_STRATEGY_NONE,
+  PADDING_STRATEGY_ALIGNED,
+  PADDING_STRATEGY_MAX,
+  PADDING_STRATEGY_CALLBACK,
+  NGHTTP2_NO_ERROR,
+  NGHTTP2_PROTOCOL_ERROR,
+  NGHTTP2_INTERNAL_ERROR,
+  NGHTTP2_FLOW_CONTROL_ERROR,
+  NGHTTP2_SETTINGS_TIMEOUT,
+  NGHTTP2_STREAM_CLOSED,
+  NGHTTP2_FRAME_SIZE_ERROR,
+  NGHTTP2_REFUSED_STREAM,
+  NGHTTP2_CANCEL,
+  NGHTTP2_COMPRESSION_ERROR,
+  NGHTTP2_CONNECT_ERROR,
+  NGHTTP2_ENHANCE_YOUR_CALM,
+  NGHTTP2_INADEQUATE_SECURITY,
+  NGHTTP2_HTTP_1_1_REQUIRED,
+  NGHTTP2_DEFAULT_WEIGHT,
+  HTTP2_HEADER_STATUS,
+  HTTP2_HEADER_METHOD,
+  HTTP2_HEADER_AUTHORITY,
+  HTTP2_HEADER_SCHEME,
+  HTTP2_HEADER_PATH,
+  HTTP2_HEADER_PROTOCOL,
+  HTTP2_HEADER_ACCEPT_ENCODING,
+  HTTP2_HEADER_ACCEPT_LANGUAGE,
+  HTTP2_HEADER_ACCEPT_RANGES,
+  HTTP2_HEADER_ACCEPT,
+  HTTP2_HEADER_ACCESS_CONTROL_ALLOW_CREDENTIALS,
+  HTTP2_HEADER_ACCESS_CONTROL_ALLOW_HEADERS,
+  HTTP2_HEADER_ACCESS_CONTROL_ALLOW_METHODS,
+  HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN,
+  HTTP2_HEADER_ACCESS_CONTROL_EXPOSE_HEADERS,
+  HTTP2_HEADER_ACCESS_CONTROL_REQUEST_HEADERS,
+  HTTP2_HEADER_ACCESS_CONTROL_REQUEST_METHOD,
+  HTTP2_HEADER_AGE,
+  HTTP2_HEADER_AUTHORIZATION,
+  HTTP2_HEADER_CACHE_CONTROL,
+  HTTP2_HEADER_CONNECTION,
+  HTTP2_HEADER_CONTENT_DISPOSITION,
+  HTTP2_HEADER_CONTENT_ENCODING,
+  HTTP2_HEADER_CONTENT_LENGTH,
+  HTTP2_HEADER_CONTENT_TYPE,
+  HTTP2_HEADER_COOKIE,
+  HTTP2_HEADER_DATE,
+  HTTP2_HEADER_ETAG,
+  HTTP2_HEADER_FORWARDED,
+  HTTP2_HEADER_HOST,
+  HTTP2_HEADER_IF_MODIFIED_SINCE,
+  HTTP2_HEADER_IF_NONE_MATCH,
+  HTTP2_HEADER_IF_RANGE,
+  HTTP2_HEADER_LAST_MODIFIED,
+  HTTP2_HEADER_LINK,
+  HTTP2_HEADER_LOCATION,
+  HTTP2_HEADER_RANGE,
+  HTTP2_HEADER_REFERER,
+  HTTP2_HEADER_SERVER,
+  HTTP2_HEADER_SET_COOKIE,
+  HTTP2_HEADER_STRICT_TRANSPORT_SECURITY,
+  HTTP2_HEADER_TRANSFER_ENCODING,
+  HTTP2_HEADER_TE,
+  HTTP2_HEADER_UPGRADE_INSECURE_REQUESTS,
+  HTTP2_HEADER_UPGRADE,
+  HTTP2_HEADER_USER_AGENT,
+  HTTP2_HEADER_VARY,
+  HTTP2_HEADER_X_CONTENT_TYPE_OPTIONS,
+  HTTP2_HEADER_X_FRAME_OPTIONS,
+  HTTP2_HEADER_KEEP_ALIVE,
+  HTTP2_HEADER_PROXY_CONNECTION,
+  HTTP2_HEADER_X_XSS_PROTECTION,
+  HTTP2_HEADER_ALT_SVC,
+  HTTP2_HEADER_CONTENT_SECURITY_POLICY,
+  HTTP2_HEADER_EARLY_DATA,
+  HTTP2_HEADER_EXPECT_CT,
+  HTTP2_HEADER_ORIGIN,
+  HTTP2_HEADER_PURPOSE,
+  HTTP2_HEADER_TIMING_ALLOW_ORIGIN,
+  HTTP2_HEADER_X_FORWARDED_FOR,
+  HTTP2_HEADER_PRIORITY,
+  HTTP2_HEADER_ACCEPT_CHARSET,
+  HTTP2_HEADER_ACCESS_CONTROL_MAX_AGE,
+  HTTP2_HEADER_ALLOW,
+  HTTP2_HEADER_CONTENT_LANGUAGE,
+  HTTP2_HEADER_CONTENT_LOCATION,
+  HTTP2_HEADER_CONTENT_MD5,
+  HTTP2_HEADER_CONTENT_RANGE,
+  HTTP2_HEADER_DNT,
+  HTTP2_HEADER_EXPECT,
+  HTTP2_HEADER_EXPIRES,
+  HTTP2_HEADER_FROM,
+  HTTP2_HEADER_IF_MATCH,
+  HTTP2_HEADER_IF_UNMODIFIED_SINCE,
+  HTTP2_HEADER_MAX_FORWARDS,
+  HTTP2_HEADER_PREFER,
+  HTTP2_HEADER_PROXY_AUTHENTICATE,
+  HTTP2_HEADER_PROXY_AUTHORIZATION,
+  HTTP2_HEADER_REFRESH,
+  HTTP2_HEADER_RETRY_AFTER,
+  HTTP2_HEADER_TRAILER,
+  HTTP2_HEADER_TK,
+  HTTP2_HEADER_VIA,
+  HTTP2_HEADER_WARNING,
+  HTTP2_HEADER_WWW_AUTHENTICATE,
+  HTTP2_HEADER_HTTP2_SETTINGS,
+  HTTP2_METHOD_ACL,
+  HTTP2_METHOD_BASELINE_CONTROL,
+  HTTP2_METHOD_BIND,
+  HTTP2_METHOD_CHECKIN,
+  HTTP2_METHOD_CHECKOUT,
+  HTTP2_METHOD_CONNECT,
+  HTTP2_METHOD_COPY,
+  HTTP2_METHOD_DELETE,
+  HTTP2_METHOD_GET,
+  HTTP2_METHOD_HEAD,
+  HTTP2_METHOD_LABEL,
+  HTTP2_METHOD_LINK,
+  HTTP2_METHOD_LOCK,
+  HTTP2_METHOD_MERGE,
+  HTTP2_METHOD_MKACTIVITY,
+  HTTP2_METHOD_MKCALENDAR,
+  HTTP2_METHOD_MKCOL,
+  HTTP2_METHOD_MKREDIRECTREF,
+  HTTP2_METHOD_MKWORKSPACE,
+  HTTP2_METHOD_MOVE,
+  HTTP2_METHOD_OPTIONS,
+  HTTP2_METHOD_ORDERPATCH,
+  HTTP2_METHOD_PATCH,
+  HTTP2_METHOD_POST,
+  HTTP2_METHOD_PRI,
+  HTTP2_METHOD_PROPFIND,
+  HTTP2_METHOD_PROPPATCH,
+  HTTP2_METHOD_PUT,
+  HTTP2_METHOD_REBIND,
+  HTTP2_METHOD_REPORT,
+  HTTP2_METHOD_SEARCH,
+  HTTP2_METHOD_TRACE,
+  HTTP2_METHOD_UNBIND,
+  HTTP2_METHOD_UNCHECKOUT,
+  HTTP2_METHOD_UNLINK,
+  HTTP2_METHOD_UNLOCK,
+  HTTP2_METHOD_UPDATE,
+  HTTP2_METHOD_UPDATEREDIRECTREF,
+  HTTP2_METHOD_VERSION_CONTROL,
+  HTTP_STATUS_CONTINUE,
+  HTTP_STATUS_SWITCHING_PROTOCOLS,
+  HTTP_STATUS_PROCESSING,
+  HTTP_STATUS_EARLY_HINTS,
+  HTTP_STATUS_OK,
+  HTTP_STATUS_CREATED,
+  HTTP_STATUS_ACCEPTED,
+  HTTP_STATUS_NON_AUTHORITATIVE_INFORMATION,
+  HTTP_STATUS_NO_CONTENT,
+  HTTP_STATUS_RESET_CONTENT,
+  HTTP_STATUS_PARTIAL_CONTENT,
+  HTTP_STATUS_MULTI_STATUS,
+  HTTP_STATUS_ALREADY_REPORTED,
+  HTTP_STATUS_IM_USED,
+  HTTP_STATUS_MULTIPLE_CHOICES,
+  HTTP_STATUS_MOVED_PERMANENTLY,
+  HTTP_STATUS_FOUND,
+  HTTP_STATUS_SEE_OTHER,
+  HTTP_STATUS_NOT_MODIFIED,
+  HTTP_STATUS_USE_PROXY,
+  HTTP_STATUS_TEMPORARY_REDIRECT,
+  HTTP_STATUS_PERMANENT_REDIRECT,
+  HTTP_STATUS_BAD_REQUEST,
+  HTTP_STATUS_UNAUTHORIZED,
+  HTTP_STATUS_PAYMENT_REQUIRED,
+  HTTP_STATUS_FORBIDDEN,
+  HTTP_STATUS_NOT_FOUND,
+  HTTP_STATUS_METHOD_NOT_ALLOWED,
+  HTTP_STATUS_NOT_ACCEPTABLE,
+  HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED,
+  HTTP_STATUS_REQUEST_TIMEOUT,
+  HTTP_STATUS_CONFLICT,
+  HTTP_STATUS_GONE,
+  HTTP_STATUS_LENGTH_REQUIRED,
+  HTTP_STATUS_PRECONDITION_FAILED,
+  HTTP_STATUS_PAYLOAD_TOO_LARGE,
+  HTTP_STATUS_URI_TOO_LONG,
+  HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE,
+  HTTP_STATUS_RANGE_NOT_SATISFIABLE,
+  HTTP_STATUS_EXPECTATION_FAILED,
+  HTTP_STATUS_TEAPOT,
+  HTTP_STATUS_MISDIRECTED_REQUEST,
+  HTTP_STATUS_UNPROCESSABLE_ENTITY,
+  HTTP_STATUS_LOCKED,
+  HTTP_STATUS_FAILED_DEPENDENCY,
+  HTTP_STATUS_TOO_EARLY,
+  HTTP_STATUS_UPGRADE_REQUIRED,
+  HTTP_STATUS_PRECONDITION_REQUIRED,
+  HTTP_STATUS_TOO_MANY_REQUESTS,
+  HTTP_STATUS_REQUEST_HEADER_FIELDS_TOO_LARGE,
+  HTTP_STATUS_UNAVAILABLE_FOR_LEGAL_REASONS,
+  HTTP_STATUS_INTERNAL_SERVER_ERROR,
+  HTTP_STATUS_NOT_IMPLEMENTED,
+  HTTP_STATUS_BAD_GATEWAY,
+  HTTP_STATUS_SERVICE_UNAVAILABLE,
+  HTTP_STATUS_GATEWAY_TIMEOUT,
+  HTTP_STATUS_HTTP_VERSION_NOT_SUPPORTED,
+  HTTP_STATUS_VARIANT_ALSO_NEGOTIATES,
+  HTTP_STATUS_INSUFFICIENT_STORAGE,
+  HTTP_STATUS_LOOP_DETECTED,
+  HTTP_STATUS_BANDWIDTH_LIMIT_EXCEEDED,
+  HTTP_STATUS_NOT_EXTENDED,
+  HTTP_STATUS_NETWORK_AUTHENTICATION_REQUIRED,
+} = constants;
 
-const NoPayloadMethods = new Set([
-  constants.HTTP2_METHOD_DELETE,
-  constants.HTTP2_METHOD_GET,
-  constants.HTTP2_METHOD_HEAD,
+//TODO: desconstruct used constants.
+
+// This set is defined strictly by the HTTP/2 specification. Only
+// :-prefixed headers defined by that specification may be added to
+// this set.
+const kValidPseudoHeaders = new SafeSet([
+  HTTP2_HEADER_STATUS,
+  HTTP2_HEADER_METHOD,
+  HTTP2_HEADER_AUTHORITY,
+  HTTP2_HEADER_SCHEME,
+  HTTP2_HEADER_PATH,
+  HTTP2_HEADER_PROTOCOL,
 ]);
+const kSingleValueHeaders = new SafeSet([
+  HTTP2_HEADER_STATUS,
+  HTTP2_HEADER_METHOD,
+  HTTP2_HEADER_AUTHORITY,
+  HTTP2_HEADER_SCHEME,
+  HTTP2_HEADER_PATH,
+  HTTP2_HEADER_PROTOCOL,
+  HTTP2_HEADER_ACCESS_CONTROL_ALLOW_CREDENTIALS,
+  HTTP2_HEADER_ACCESS_CONTROL_MAX_AGE,
+  HTTP2_HEADER_ACCESS_CONTROL_REQUEST_METHOD,
+  HTTP2_HEADER_AGE,
+  HTTP2_HEADER_AUTHORIZATION,
+  HTTP2_HEADER_CONTENT_ENCODING,
+  HTTP2_HEADER_CONTENT_LANGUAGE,
+  HTTP2_HEADER_CONTENT_LENGTH,
+  HTTP2_HEADER_CONTENT_LOCATION,
+  HTTP2_HEADER_CONTENT_MD5,
+  HTTP2_HEADER_CONTENT_RANGE,
+  HTTP2_HEADER_CONTENT_TYPE,
+  HTTP2_HEADER_DATE,
+  HTTP2_HEADER_DNT,
+  HTTP2_HEADER_ETAG,
+  HTTP2_HEADER_EXPIRES,
+  HTTP2_HEADER_FROM,
+  HTTP2_HEADER_HOST,
+  HTTP2_HEADER_IF_MATCH,
+  HTTP2_HEADER_IF_MODIFIED_SINCE,
+  HTTP2_HEADER_IF_NONE_MATCH,
+  HTTP2_HEADER_IF_RANGE,
+  HTTP2_HEADER_IF_UNMODIFIED_SINCE,
+  HTTP2_HEADER_LAST_MODIFIED,
+  HTTP2_HEADER_LOCATION,
+  HTTP2_HEADER_MAX_FORWARDS,
+  HTTP2_HEADER_PROXY_AUTHORIZATION,
+  HTTP2_HEADER_RANGE,
+  HTTP2_HEADER_REFERER,
+  HTTP2_HEADER_RETRY_AFTER,
+  HTTP2_HEADER_TK,
+  HTTP2_HEADER_UPGRADE_INSECURE_REQUESTS,
+  HTTP2_HEADER_USER_AGENT,
+  HTTP2_HEADER_X_CONTENT_TYPE_OPTIONS,
+]);
+
+function assertValidPseudoHeader(key) {
+  if (!kValidPseudoHeaders.has(key)) {
+    throw $ERR_HTTP2_INVALID_PSEUDOHEADER(`"${key}" is an invalid pseudoheader or is used incorrectly`);
+  }
+}
+hideFromStack(assertValidPseudoHeader);
+
+const NoPayloadMethods = new Set([HTTP2_METHOD_DELETE, HTTP2_METHOD_GET, HTTP2_METHOD_HEAD]);
 
 type Settings = {
   headerTableSize: number;
@@ -370,45 +1493,83 @@ type Settings = {
 class Http2Session extends EventEmitter {}
 
 function streamErrorFromCode(code: number) {
-  const error = new Error(`Stream closed with error code ${code}`);
-  error.code = "ERR_HTTP2_STREAM_ERROR";
-  error.errno = code;
-  return error;
+  return $ERR_HTTP2_STREAM_ERROR(`Stream closed with error code ${nameForErrorCode[code] || code}`);
 }
+hideFromStack(streamErrorFromCode);
 function sessionErrorFromCode(code: number) {
-  const error = new Error(`Session closed with error code ${code}`);
-  error.code = "ERR_HTTP2_SESSION_ERROR";
-  error.errno = code;
-  return error;
+  return $ERR_HTTP2_SESSION_ERROR(`Session closed with error code ${nameForErrorCode[code] || code}`);
 }
+hideFromStack(sessionErrorFromCode);
+
 function assertSession(session) {
   if (!session) {
-    const error = new Error(`ERR_HTTP2_INVALID_SESSION: The session has been destroyed`);
-    error.code = "ERR_HTTP2_INVALID_SESSION";
-    throw error;
+    throw $ERR_HTTP2_INVALID_SESSION(`The session has been destroyed`);
+  }
+}
+hideFromStack(assertSession);
+
+function pushToStream(stream, data) {
+  // if (stream.writableEnded) return;
+  const queue = stream[bunHTTP2StreamReadQueue];
+  if (queue.isEmpty()) {
+    if (stream.push(data)) return;
+  }
+  queue.push(data);
+}
+
+enum StreamState {
+  EndedCalled = 1 << 0, // 00001 = 1
+  WantTrailer = 1 << 1, // 00010 = 2
+  FinalCalled = 1 << 2, // 00100 = 4
+  Closed = 1 << 3, // 01000 = 8
+  StreamResponded = 1 << 4, // 10000 = 16
+  WritableClosed = 1 << 5, // 100000 = 32
+}
+function markWritableDone(stream: Http2Stream) {
+  const _final = stream[bunHTTP2StreamFinal];
+  if (typeof _final === "function") {
+    stream[bunHTTP2StreamFinal] = null;
+    _final();
+    stream[bunHTTP2StreamStatus] |= StreamState.WritableClosed | StreamState.FinalCalled;
+    return;
+  }
+  stream[bunHTTP2StreamStatus] |= StreamState.WritableClosed;
+}
+function markStreamClosed(stream: Http2Stream) {
+  const status = stream[bunHTTP2StreamStatus];
+
+  if ((status & StreamState.Closed) === 0) {
+    stream[bunHTTP2StreamStatus] = status | StreamState.Closed;
+
+    markWritableDone(stream);
   }
 }
 
-class ClientHttp2Stream extends Duplex {
+class Http2Stream extends Duplex {
   #id: number;
-  [bunHTTP2Session]: ClientHttp2Session | null = null;
-  #endStream: boolean = false;
-  [bunHTTP2WantTrailers]: boolean = false;
-  [bunHTTP2Closed]: boolean = false;
+  [bunHTTP2Session]: ClientHttp2Session | ServerHttp2Session | null = null;
+  [bunHTTP2StreamFinal]: VoidFunction | null = null;
+  [bunHTTP2StreamStatus]: number = 0;
+
   rstCode: number | undefined = undefined;
   [bunHTTP2StreamReadQueue]: Array<Buffer> = $createFIFO();
-  [bunHTTP2StreamResponded]: boolean = false;
-  #headers: any;
+  [bunHTTP2Headers]: any;
+  [kInfoHeaders]: any;
   #sentTrailers: any;
+  [kAborted]: boolean = false;
   constructor(streamId, session, headers) {
-    super();
+    super({
+      decodeStrings: false,
+    });
     this.#id = streamId;
     this[bunHTTP2Session] = session;
-    this.#headers = headers;
+    this[bunHTTP2Headers] = headers;
   }
 
   get scheme() {
-    return this.#headers[":scheme"] || "https";
+    const headers = this[bunHTTP2Headers];
+    if (headers) return headers[":scheme"] || "https";
+    return "https";
   }
 
   get id() {
@@ -422,57 +1583,61 @@ class ClientHttp2Stream extends Duplex {
   get bufferSize() {
     const session = this[bunHTTP2Session];
     if (!session) return 0;
-    return session[bunHTTP2Socket]?.bufferSize || 0;
+    // native queued + socket queued
+    return session.bufferSize() + (session[bunHTTP2Socket]?.bufferSize || 0);
   }
 
   get sentHeaders() {
-    return this.#headers;
+    return this[bunHTTP2Headers];
   }
 
   get sentInfoHeaders() {
-    // TODO CONTINUE frames here
-    return [];
+    return this[kInfoHeaders] || [];
   }
 
   get sentTrailers() {
     return this.#sentTrailers;
   }
 
-  sendTrailers(headers) {
+  static #rstStream() {
     const session = this[bunHTTP2Session];
     assertSession(session);
+    markStreamClosed(this);
+
+    session[bunHTTP2Native]?.rstStream(this.#id, this.rstCode);
+    this[bunHTTP2Session] = null;
+  }
+
+  sendTrailers(headers) {
+    const session = this[bunHTTP2Session];
 
     if (this.destroyed || this.closed) {
-      const error = new Error(`ERR_HTTP2_INVALID_STREAM: The stream has been destroyed`);
-      error.code = "ERR_HTTP2_INVALID_STREAM";
-      throw error;
+      throw $ERR_HTTP2_INVALID_STREAM(`The stream has been destroyed`);
     }
 
     if (this.#sentTrailers) {
-      const error = new Error(`ERR_HTTP2_TRAILERS_ALREADY_SENT: Trailing headers have already been sent`);
-      error.code = "ERR_HTTP2_TRAILERS_ALREADY_SENT";
-      throw error;
+      throw $ERR_HTTP2_TRAILERS_ALREADY_SENT(`Trailing headers have already been sent`);
     }
+    assertSession(session);
 
-    if (!this[bunHTTP2WantTrailers]) {
-      const error = new Error(
-        `ERR_HTTP2_TRAILERS_NOT_READY: Trailing headers cannot be sent until after the wantTrailers event is emitted`,
+    if ((this[bunHTTP2StreamStatus] & StreamState.WantTrailer) === 0) {
+      throw $ERR_HTTP2_TRAILERS_NOT_READY(
+        "Trailing headers cannot be sent until after the wantTrailers event is emitted",
       );
-      error.code = "ERR_HTTP2_TRAILERS_NOT_READY";
-      throw error;
     }
 
-    if (!$isObject(headers)) {
-      throw new Error("ERR_HTTP2_INVALID_HEADERS: headers must be an object");
+    if (headers == undefined) {
+      headers = {};
+    } else if (!$isObject(headers)) {
+      throw $ERR_HTTP2_INVALID_HEADERS("headers must be an object");
+    } else {
+      headers = { ...headers };
     }
-
     const sensitives = headers[sensitiveHeaders];
     const sensitiveNames = {};
     if (sensitives) {
       if (!$isJSArray(sensitives)) {
-        const error = new TypeError("ERR_INVALID_ARG_VALUE: The argument headers[http2.neverIndex] is invalid");
-        error.code = "ERR_INVALID_ARG_VALUE";
-        throw error;
+        throw $ERR_INVALID_ARG_VALUE("The arguments headers[http2.neverIndex] is invalid");
       }
       for (let i = 0; i < sensitives.length; i++) {
         sensitiveNames[sensitives[i]] = true;
@@ -484,14 +1649,13 @@ class ClientHttp2Stream extends Duplex {
   }
 
   setTimeout(timeout, callback) {
-    // per stream timeout not implemented yet
     const session = this[bunHTTP2Session];
-    assertSession(session);
+    if (!session) return;
     session.setTimeout(timeout, callback);
   }
 
   get closed() {
-    return this[bunHTTP2Closed];
+    return (this[bunHTTP2StreamStatus] & StreamState.Closed) !== 0;
   }
 
   get destroyed() {
@@ -515,12 +1679,6 @@ class ClientHttp2Stream extends Duplex {
     session[bunHTTP2Native]?.setStreamPriority(this.#id, options);
   }
 
-  set endAfterHeaders(value: boolean) {
-    const session = this[bunHTTP2Session];
-    assertSession(session);
-    session[bunHTTP2Native]?.setEndAfterHeaders(this.#id, value);
-  }
-
   get endAfterHeaders() {
     const session = this[bunHTTP2Session];
     if (session) {
@@ -530,11 +1688,7 @@ class ClientHttp2Stream extends Duplex {
   }
 
   get aborted() {
-    const session = this[bunHTTP2Session];
-    if (session) {
-      return session[bunHTTP2Native]?.isStreamAborted(this.#id) || false;
-    }
-    return false;
+    return this[kAborted] || false;
   }
 
   get session() {
@@ -545,53 +1699,77 @@ class ClientHttp2Stream extends Duplex {
     // not implemented yet aka server side
     return false;
   }
-
-  pushStream() {
-    // not implemented yet aka server side
-  }
-  respondWithFile() {
-    // not implemented yet aka server side
-  }
-  respondWithFd() {
-    // not implemented yet aka server side
-  }
-  respond() {
-    // not implemented yet aka server side
-  }
   close(code, callback) {
-    if (!this[bunHTTP2Closed]) {
+    if ((this[bunHTTP2StreamStatus] & StreamState.Closed) === 0) {
       const session = this[bunHTTP2Session];
       assertSession(session);
-
-      if (code < 0 || code > 13) {
-        throw new RangeError("Invalid error code");
-      }
-      this[bunHTTP2Closed] = true;
-      session[bunHTTP2Native]?.rstStream(this.#id, code || 0);
+      code = code || 0;
+      validateInteger(code, "code", 0, 13);
       this.rstCode = code;
+      markStreamClosed(this);
+
+      session[bunHTTP2Native]?.rstStream(this.#id, code);
     }
+
     if (typeof callback === "function") {
       this.once("close", callback);
     }
   }
   _destroy(err, callback) {
-    if (!this[bunHTTP2Closed]) {
-      this[bunHTTP2Closed] = true;
+    const { ending } = this._writableState;
 
-      const session = this[bunHTTP2Session];
-      assertSession(session);
+    if (!ending) {
+      // If the writable side of the Http2Stream is still open, emit the
+      // 'aborted' event and set the aborted flag.
+      if (!this.aborted) {
+        this[kAborted] = true;
+        this.emit("aborted");
+      }
+      // at this state destroyed will be true but we need to close the writable side
+      this._writableState.destroyed = false;
+      this.end();
+      // we now restore the destroyed flag
+      this._writableState.destroyed = true;
+    }
 
-      session[bunHTTP2Native]?.rstStream(this.#id, 0);
-      this.rstCode = 0;
+    const session = this[bunHTTP2Session];
+    assertSession(session);
+
+    let rstCode = this.rstCode;
+    if (!rstCode) {
+      if (err != null) {
+        if (err.code === "ABORT_ERR") {
+          // Enables using AbortController to cancel requests with RST code 8.
+          rstCode = NGHTTP2_CANCEL;
+        } else {
+          rstCode = NGHTTP2_INTERNAL_ERROR;
+        }
+      } else {
+        rstCode = this.rstCode = 0;
+      }
+    }
+
+    if (this.writableFinished) {
+      markStreamClosed(this);
+
+      session[bunHTTP2Native]?.rstStream(this.#id, rstCode);
       this[bunHTTP2Session] = null;
+    } else {
+      this.once("finish", Http2Stream.#rstStream);
     }
 
     callback(err);
   }
 
   _final(callback) {
-    this[bunHTTP2Closed] = true;
-    callback();
+    const status = this[bunHTTP2StreamStatus];
+
+    if ((status & StreamState.WritableClosed) !== 0 || (status & StreamState.Closed) !== 0) {
+      callback();
+      this[bunHTTP2StreamStatus] |= StreamState.FinalCalled;
+    } else {
+      this[bunHTTP2StreamFinal] = callback;
+    }
   }
 
   _read(size) {
@@ -607,22 +1785,345 @@ class ClientHttp2Stream extends Duplex {
   }
 
   end(chunk, encoding, callback) {
+    const status = this[bunHTTP2StreamStatus];
+
+    if ((status & StreamState.EndedCalled) !== 0) {
+      typeof callback == "function" && callback();
+      return;
+    }
     if (!chunk) {
       chunk = Buffer.alloc(0);
     }
-    this.#endStream = true;
+    this[bunHTTP2StreamStatus] = status | StreamState.EndedCalled;
     return super.end(chunk, encoding, callback);
   }
 
-  _write(chunk, encoding, callback) {
-    if (typeof chunk == "string" && encoding !== "ascii") chunk = Buffer.from(chunk, encoding);
+  _writev(data, callback) {
     const session = this[bunHTTP2Session];
     if (session) {
-      session[bunHTTP2Native]?.writeStream(this.#id, chunk, this.#endStream);
-      if (typeof callback == "function") {
-        callback();
+      const native = session[bunHTTP2Native];
+      if (native) {
+        const allBuffers = data.allBuffers;
+        let chunks;
+        chunks = data;
+        if (allBuffers) {
+          for (let i = 0; i < data.length; i++) {
+            data[i] = data[i].chunk;
+          }
+        } else {
+          for (let i = 0; i < data.length; i++) {
+            const { chunk, encoding } = data[i];
+            if (typeof chunk === "string") {
+              data[i] = Buffer.from(chunk, encoding);
+            } else {
+              data[i] = chunk;
+            }
+          }
+        }
+        const chunk = Buffer.concat(chunks || []);
+        native.writeStream(
+          this.#id,
+          chunk,
+          undefined,
+          (this[bunHTTP2StreamStatus] & StreamState.EndedCalled) !== 0,
+          callback,
+        );
+        return;
       }
     }
+    if (typeof callback == "function") {
+      callback();
+    }
+  }
+  _write(chunk, encoding, callback) {
+    const session = this[bunHTTP2Session];
+    if (session) {
+      const native = session[bunHTTP2Native];
+      if (native) {
+        native.writeStream(
+          this.#id,
+          chunk,
+          encoding,
+          (this[bunHTTP2StreamStatus] & StreamState.EndedCalled) !== 0,
+          callback,
+        );
+        return;
+      }
+    }
+    if (typeof callback == "function") {
+      callback();
+    }
+  }
+}
+class ClientHttp2Stream extends Http2Stream {
+  constructor(streamId, session, headers) {
+    super(streamId, session, headers);
+  }
+}
+function tryClose(fd) {
+  try {
+    fs.close(fd);
+  } catch {}
+}
+
+function doSendFileFD(options, fd, headers, err, stat) {
+  const onError = options.onError;
+  if (err) {
+    tryClose(fd);
+
+    if (onError) onError(err);
+    else this.destroy(err);
+    return;
+  }
+
+  if (!stat.isFile()) {
+    const isDirectory = stat.isDirectory();
+    if (
+      options.offset !== undefined ||
+      options.offset > 0 ||
+      options.length !== undefined ||
+      options.length >= 0 ||
+      isDirectory
+    ) {
+      const err = isDirectory
+        ? $ERR_HTTP2_SEND_FILE("Directories cannot be sent")
+        : $ERR_HTTP2_SEND_FILE_NOSEEK("Offset or length can only be specified for regular files");
+      tryClose(fd);
+      if (onError) onError(err);
+      else this.destroy(err);
+      return;
+    }
+
+    options.offset = -1;
+    options.length = -1;
+  }
+
+  if (this.destroyed || this.closed) {
+    tryClose(fd);
+    const error = $ERR_HTTP2_INVALID_STREAM(`The stream has been destroyed`);
+    this.destroy(error);
+    return;
+  }
+
+  const statOptions = {
+    offset: options.offset !== undefined ? options.offset : 0,
+    length: options.length !== undefined ? options.length : -1,
+  };
+
+  // options.statCheck is a user-provided function that can be used to
+  // verify stat values, override or set headers, or even cancel the
+  // response operation. If statCheck explicitly returns false, the
+  // response is canceled. The user code may also send a separate type
+  // of response so check again for the HEADERS_SENT flag
+  if (
+    (typeof options.statCheck === "function" && options.statCheck.$call(this, [stat, headers]) === false) ||
+    this.headersSent
+  ) {
+    tryClose(fd);
+    return;
+  }
+
+  if (stat.isFile()) {
+    statOptions.length =
+      statOptions.length < 0
+        ? stat.size - +statOptions.offset
+        : Math.min(stat.size - +statOptions.offset, statOptions.length);
+
+    headers[HTTP2_HEADER_CONTENT_LENGTH] = statOptions.length;
+  }
+  try {
+    this.respond(headers, options);
+    fs.createReadStream(null, {
+      fd: fd,
+      autoClose: true,
+      start: statOptions.offset,
+      end: statOptions.length,
+      emitClose: false,
+    }).pipe(this);
+  } catch (err) {
+    if (typeof onError === "function") {
+      onError(err);
+    } else {
+      this.destroy(err);
+    }
+  }
+}
+function afterOpen(options, headers, err, fd) {
+  const onError = options.onError;
+  if (err) {
+    tryClose(fd);
+    if (onError) onError(err);
+    else this.destroy(err);
+    return;
+  }
+  if (this.destroyed || this.closed) {
+    tryClose(fd);
+    return;
+  }
+
+  fs.fstat(fd, doSendFileFD.bind(this, options, fd, headers));
+}
+
+class ServerHttp2Stream extends Http2Stream {
+  headersSent = false;
+  constructor(streamId, session, headers) {
+    super(streamId, session, headers);
+  }
+  pushStream() {
+    throwNotImplemented("ServerHttp2Stream.prototype.pushStream()");
+  }
+
+  respondWithFile(path, headers, options) {
+    if (headers == undefined) {
+      headers = {};
+    } else if (!$isObject(headers)) {
+      throw $ERR_HTTP2_INVALID_HEADERS("headers must be an object");
+    } else {
+      headers = { ...headers };
+    }
+
+    if (headers[":status"] === undefined) {
+      headers[":status"] = 200;
+    }
+    const statusCode = (headers[":status"] |= 0);
+
+    // Payload/DATA frames are not permitted in these cases
+    if (
+      statusCode === HTTP_STATUS_NO_CONTENT ||
+      statusCode === HTTP_STATUS_RESET_CONTENT ||
+      statusCode === HTTP_STATUS_NOT_MODIFIED ||
+      this.headRequest
+    ) {
+      throw $ERR_HTTP2_PAYLOAD_FORBIDDEN(`Responses with ${statusCode} status must not have a payload`);
+    }
+
+    fs.open(path, "r", afterOpen.bind(this, options || {}, headers));
+  }
+  respondWithFD(fd, headers, options) {
+    // TODO: optimize this
+    let { statCheck, offset, length } = options || {};
+    if (headers == undefined) {
+      headers = {};
+    } else if (!$isObject(headers)) {
+      throw $ERR_HTTP2_INVALID_HEADERS("headers must be an object");
+    } else {
+      headers = { ...headers };
+    }
+
+    if (headers[":status"] === undefined) {
+      headers[":status"] = 200;
+    }
+    const statusCode = (headers[":status"] |= 0);
+
+    // Payload/DATA frames are not permitted in these cases
+    if (
+      statusCode === HTTP_STATUS_NO_CONTENT ||
+      statusCode === HTTP_STATUS_RESET_CONTENT ||
+      statusCode === HTTP_STATUS_NOT_MODIFIED ||
+      this.headRequest
+    ) {
+      throw $ERR_HTTP2_PAYLOAD_FORBIDDEN(`Responses with ${statusCode} status must not have a payload`);
+    }
+    fs.fstat(fd, doSendFileFD.bind(this, options, fd, headers));
+  }
+  additionalHeaders(headers) {
+    if (this.destroyed || this.closed) {
+      throw $ERR_HTTP2_INVALID_STREAM(`The stream has been destroyed`);
+    }
+
+    if (this.sentTrailers) {
+      throw $ERR_HTTP2_TRAILERS_ALREADY_SENT(`Trailing headers have already been sent`);
+    }
+    if (this.headersSent) throw $ERR_HTTP2_HEADERS_SENT("Response has already been initiated");
+
+    if (headers == undefined) {
+      headers = {};
+    } else if (!$isObject(headers)) {
+      throw $ERR_HTTP2_INVALID_HEADERS("headers must be an object");
+    } else {
+      headers = { ...headers };
+    }
+
+    const sensitives = headers[sensitiveHeaders];
+    const sensitiveNames = {};
+    if (sensitives) {
+      if (!$isArray(sensitives)) {
+        throw $ERR_INVALID_ARG_VALUE("The arguments headers[http2.neverIndex] is invalid.");
+      }
+      for (let i = 0; i < sensitives.length; i++) {
+        sensitiveNames[sensitives[i]] = true;
+      }
+    }
+    if (headers[":status"] === undefined) {
+      headers[":status"] = 200;
+    }
+    const statusCode = (headers[":status"] |= 0);
+
+    // Payload/DATA frames are not permitted in these cases
+    if (
+      statusCode === HTTP_STATUS_NO_CONTENT ||
+      statusCode === HTTP_STATUS_RESET_CONTENT ||
+      statusCode === HTTP_STATUS_NOT_MODIFIED ||
+      this.headRequest
+    ) {
+      throw $ERR_HTTP2_PAYLOAD_FORBIDDEN(`Responses with ${statusCode} status must not have a payload`);
+    }
+    const session = this[bunHTTP2Session];
+    assertSession(session);
+    if (!this[kInfoHeaders]) {
+      this[kInfoHeaders] = [headers];
+    } else {
+      ArrayPrototypePush(this[kInfoHeaders], headers);
+    }
+
+    session[bunHTTP2Native]?.request(this.id, undefined, headers, sensitiveNames);
+  }
+  respond(headers: any, options?: any) {
+    if (this.destroyed || this.closed) {
+      throw $ERR_HTTP2_INVALID_STREAM(`The stream has been destroyed`);
+    }
+    if (this.headersSent) throw $ERR_HTTP2_HEADERS_SENT("Response has already been initiated");
+    if (this.sentTrailers) {
+      throw $ERR_HTTP2_TRAILERS_ALREADY_SENT(`Trailing headers have already been sent`);
+    }
+
+    if (headers == undefined) {
+      headers = {};
+    } else if (!$isObject(headers)) {
+      throw $ERR_HTTP2_INVALID_HEADERS("headers must be an object");
+    } else {
+      headers = { ...headers };
+    }
+
+    const sensitives = headers[sensitiveHeaders];
+    const sensitiveNames = {};
+    if (sensitives) {
+      if (!$isArray(sensitives)) {
+        throw $ERR_INVALID_ARG_VALUE("The arguments headers[http2.neverIndex] is invalid.");
+      }
+      for (let i = 0; i < sensitives.length; i++) {
+        sensitiveNames[sensitives[i]] = true;
+      }
+    }
+    if (headers[":status"] === undefined) {
+      headers[":status"] = 200;
+    }
+    const session = this[bunHTTP2Session];
+    assertSession(session);
+    this.headersSent = true;
+    this[bunHTTP2Headers] = headers;
+    if (typeof options === "undefined") {
+      session[bunHTTP2Native]?.request(this.id, undefined, headers, sensitiveNames);
+    } else {
+      if (options.sendDate == null || options.sendDate) {
+        const current_date = headers["date"];
+        if (current_date === null || current_date === undefined) {
+          headers["date"] = utcDate();
+        }
+      }
+      session[bunHTTP2Native]?.request(this.id, undefined, headers, sensitiveNames, options);
+    }
+    return;
   }
 }
 
@@ -633,64 +2134,90 @@ function connectWithProtocol(protocol: string, options: Http2ConnectOptions | st
   return tls.connect(options, listener);
 }
 
-function emitWantTrailersNT(streams, streamId) {
-  const stream = streams.get(streamId);
-  if (stream) {
-    stream[bunHTTP2WantTrailers] = true;
-    stream.emit("wantTrailers");
-  }
-}
-
 function emitConnectNT(self, socket) {
   self.emit("connect", self, socket);
 }
 
-function emitStreamNT(self, streams, streamId) {
-  const stream = streams.get(streamId);
+function emitStreamErrorNT(self, stream, error, destroy, destroy_self) {
   if (stream) {
-    self.emit("stream", stream);
-  }
-}
-
-function emitStreamErrorNT(self, streams, streamId, error, destroy) {
-  const stream = streams.get(streamId);
-
-  if (stream) {
-    if (!stream[bunHTTP2Closed]) {
-      stream[bunHTTP2Closed] = true;
-    }
-    stream.rstCode = error;
-
-    const error_instance = streamErrorFromCode(error);
-    stream.emit("error", error_instance);
-    if (destroy) stream.destroy(error_instance, error);
-  }
-}
-
-function emitAbortedNT(self, streams, streamId, error) {
-  const stream = streams.get(streamId);
-  if (stream) {
-    if (!stream[bunHTTP2Closed]) {
-      stream[bunHTTP2Closed] = true;
+    let error_instance: Error | number | undefined = undefined;
+    if (typeof error === "number") {
+      stream.rstCode = error;
+      if (error != 0) {
+        error_instance = streamErrorFromCode(error);
+      }
+    } else {
+      error_instance = error;
     }
 
-    stream.rstCode = constants.NGHTTP2_CANCEL;
-    stream.emit("aborted");
+    if (stream.readable) {
+      stream.resume(); // we have a error we consume and close
+      pushToStream(stream, null);
+    }
+    markStreamClosed(stream);
+    if (destroy) stream.destroy(error_instance, stream.rstCode);
+    else if (error_instance) {
+      stream.emit("error", error_instance);
+    }
+
+    if (destroy_self) self.destroy();
   }
 }
-class ClientHttp2Session extends Http2Session {
+//TODO: do this in C++
+function toHeaderObject(headers, sensitiveHeadersValue) {
+  const obj = { __proto__: null, [sensitiveHeaders]: sensitiveHeadersValue };
+  for (let n = 0; n < headers.length; n += 2) {
+    const name = headers[n];
+    let value = headers[n + 1] || "";
+    if (name === HTTP2_HEADER_STATUS) value |= 0;
+    const existing = obj[name];
+    if (existing === undefined) {
+      obj[name] = name === HTTP2_HEADER_SET_COOKIE ? [value] : value;
+    } else if (!kSingleValueHeaders.has(name)) {
+      switch (name) {
+        case HTTP2_HEADER_COOKIE:
+          // https://tools.ietf.org/html/rfc7540#section-8.1.2.5
+          // "...If there are multiple Cookie header fields after decompression,
+          //  these MUST be concatenated into a single octet string using the
+          //  two-octet delimiter of 0x3B, 0x20 (the ASCII string "; ") before
+          //  being passed into a non-HTTP/2 context."
+          obj[name] = `${existing}; ${value}`;
+          break;
+        case HTTP2_HEADER_SET_COOKIE:
+          // https://tools.ietf.org/html/rfc7230#section-3.2.2
+          // "Note: In practice, the "Set-Cookie" header field ([RFC6265]) often
+          // appears multiple times in a response message and does not use the
+          // list syntax, violating the above requirements on multiple header
+          // fields with the same name.  Since it cannot be combined into a
+          // single field-value, recipients ought to handle "Set-Cookie" as a
+          // special case while processing header fields."
+          ArrayPrototypePush(existing, value);
+          break;
+        default:
+          // https://tools.ietf.org/html/rfc7230#section-3.2.2
+          // "A recipient MAY combine multiple header fields with the same field
+          // name into one "field-name: field-value" pair, without changing the
+          // semantics of the message, by appending each subsequent field value
+          // to the combined field value in order, separated by a comma."
+          obj[name] = `${existing}, ${value}`;
+          break;
+      }
+    }
+  }
+  return obj;
+}
+class ServerHttp2Session extends Http2Session {
+  [kServer]: Http2Server = null;
   /// close indicates that we called closed
   #closed: boolean = false;
   /// connected indicates that the connection/socket is connected
   #connected: boolean = false;
-  #queue: Array<Buffer> = [];
   #connections: number = 0;
   [bunHTTP2Socket]: TLSSocket | Socket | null;
   #socket_proxy: Proxy<TLSSocket | Socket>;
   #parser: typeof H2FrameParser | null;
   #url: URL;
   #originSet = new Set<string>();
-  #streams = new Map<number, any>();
   #isServer: boolean = false;
   #alpnProtocol: string | undefined = undefined;
   #localSettings: Settings | null = {
@@ -709,104 +2236,91 @@ class ClientHttp2Session extends Http2Session {
 
   static #Handlers = {
     binaryType: "buffer",
-    streamStart(self: ClientHttp2Session, streamId: number) {
+    streamStart(self: ServerHttp2Session, stream_id: number) {
       if (!self) return;
       self.#connections++;
-      process.nextTick(emitStreamNT, self, self.#streams, streamId);
+      const stream = new ServerHttp2Stream(stream_id, self, null);
+      self.#parser?.setStreamContext(stream_id, stream);
     },
-    streamError(self: ClientHttp2Session, streamId: number, error: number) {
-      if (!self) return;
-      var stream = self.#streams.get(streamId);
-      if (stream) {
-        const error_instance = streamErrorFromCode(error);
-        if (!stream[bunHTTP2Closed]) {
-          stream[bunHTTP2Closed] = true;
-        }
-        stream.rstCode = error;
-
-        stream.emit("error", error_instance);
-      } else {
-        process.nextTick(emitStreamErrorNT, self, self.#streams, streamId, error);
+    aborted(self: ServerHttp2Session, stream: ServerHttp2Stream, error: any, old_state: number) {
+      if (!self || typeof stream !== "object") return;
+      stream.rstCode = constants.NGHTTP2_CANCEL;
+      // if writable and not closed emit aborted
+      if (old_state != 5 && old_state != 7) {
+        stream[kAborted] = true;
+        stream.emit("aborted");
       }
+      self.#connections--;
+      process.nextTick(emitStreamErrorNT, self, stream, error, true, self.#connections === 0 && self.#closed);
     },
-    streamEnd(self: ClientHttp2Session, streamId: number) {
-      if (!self) return;
-      var stream = self.#streams.get(streamId);
-      if (stream) {
+    streamError(self: ServerHttp2Session, stream: ServerHttp2Stream, error: number) {
+      if (!self || typeof stream !== "object") return;
+      self.#connections--;
+      process.nextTick(emitStreamErrorNT, self, stream, error, true, self.#connections === 0 && self.#closed);
+    },
+    streamEnd(self: ServerHttp2Session, stream: ServerHttp2Stream, state: number) {
+      if (!self || typeof stream !== "object") return;
+      if (state == 6 || state == 7) {
+        if (stream.readable) {
+          stream.rstCode = 0;
+          // If the user hasn't tried to consume the stream (and this is a server
+          // session) then just dump the incoming data so that the stream can
+          // be destroyed.
+          if (stream.readableFlowing === null) {
+            stream.resume();
+          }
+          pushToStream(stream, null);
+        }
+      }
+      // 7 = closed, in this case we already send everything and received everything
+      if (state === 7) {
+        markStreamClosed(stream);
         self.#connections--;
-        self.#streams.delete(streamId);
-        stream[bunHTTP2Closed] = true;
-        stream[bunHTTP2Session] = null;
-        stream.rstCode = 0;
-        stream.emit("end");
-        stream.emit("close");
         stream.destroy();
-      }
-      if (self.#connections === 0 && self.#closed) {
-        self.destroy();
+        if (self.#connections === 0 && self.#closed) {
+          self.destroy();
+        }
+      } else if (state === 5) {
+        // 5 = local closed aka write is closed
+        markWritableDone(stream);
       }
     },
-    streamData(self: ClientHttp2Session, streamId: number, data: Buffer) {
-      if (!self) return;
-      var stream = self.#streams.get(streamId);
-      if (stream) {
-        const queue = stream[bunHTTP2StreamReadQueue];
-
-        if (queue.isEmpty()) {
-          if (stream.push(data)) return;
-        }
-        queue.push(data);
-      }
+    streamData(self: ServerHttp2Session, stream: ServerHttp2Stream, data: Buffer) {
+      if (!self || typeof stream !== "object" || !data) return;
+      pushToStream(stream, data);
     },
     streamHeaders(
-      self: ClientHttp2Session,
-      streamId: number,
-      headers: Record<string, string | string[]>,
+      self: ServerHttp2Session,
+      stream: ServerHttp2Stream,
+      rawheaders: string[],
+      sensitiveHeadersValue: string[] | undefined,
       flags: number,
     ) {
-      if (!self) return;
-      var stream = self.#streams.get(streamId);
-      if (!stream) return;
+      if (!self || typeof stream !== "object") return;
+      const headers = toHeaderObject(rawheaders, sensitiveHeadersValue || []);
 
-      let status: string | number = headers[":status"] as string;
-      if (status) {
-        // client status is always number
-        status = parseInt(status as string, 10);
-        (headers as Record<string, string | number>)[":status"] = status;
-      }
-
-      let set_cookies = headers["set-cookie"];
-      if (typeof set_cookies === "string") {
-        (headers as Record<string, string | string[]>)["set-cookie"] = [set_cookies];
-      }
-
-      let cookie = headers["cookie"];
-      if ($isArray(cookie)) {
-        headers["cookie"] = (headers["cookie"] as string[]).join(";");
-      }
-      if (stream[bunHTTP2StreamResponded]) {
-        try {
-          stream.emit("trailers", headers, flags);
-        } catch {
-          process.nextTick(emitStreamErrorNT, self, self.#streams, streamId, constants.NGHTTP2_PROTOCOL_ERROR, true);
-        }
+      const status = stream[bunHTTP2StreamStatus];
+      if ((status & StreamState.StreamResponded) !== 0) {
+        stream.emit("trailers", headers, flags, rawheaders);
       } else {
-        stream[bunHTTP2StreamResponded] = true;
-        stream.emit("response", headers, flags);
+        self[kServer].emit("stream", stream, headers, flags, rawheaders);
+
+        stream[bunHTTP2StreamStatus] = status | StreamState.StreamResponded;
+        self.emit("stream", stream, headers, flags, rawheaders);
       }
     },
-    localSettings(self: ClientHttp2Session, settings: Settings) {
+    localSettings(self: ServerHttp2Session, settings: Settings) {
       if (!self) return;
-      self.emit("localSettings", settings);
       self.#localSettings = settings;
       self.#pendingSettingsAck = false;
+      self.emit("localSettings", settings);
     },
-    remoteSettings(self: ClientHttp2Session, settings: Settings) {
+    remoteSettings(self: ServerHttp2Session, settings: Settings) {
       if (!self) return;
-      self.emit("remoteSettings", settings);
       self.#remoteSettings = settings;
+      self.emit("remoteSettings", settings);
     },
-    ping(self: ClientHttp2Session, payload: Buffer, isACK: boolean) {
+    ping(self: ServerHttp2Session, payload: Buffer, isACK: boolean) {
       if (!self) return;
       self.emit("ping", payload);
       if (isACK) {
@@ -820,68 +2334,44 @@ class ClientHttp2Session extends Http2Session {
         }
       }
     },
-    error(self: ClientHttp2Session, errorCode: number, lastStreamId: number, opaqueData: Buffer) {
+    error(self: ServerHttp2Session, errorCode: number, lastStreamId: number, opaqueData: Buffer) {
       if (!self) return;
-      self.emit("error", sessionErrorFromCode(errorCode));
-
-      self[bunHTTP2Socket]?.end();
-      self[bunHTTP2Socket] = null;
-      self.#parser = null;
+      const error_instance = sessionErrorFromCode(errorCode);
+      self.destroy(error_instance);
     },
-    aborted(self: ClientHttp2Session, streamId: number, error: any) {
-      if (!self) return;
-      var stream = self.#streams.get(streamId);
-      if (stream) {
-        if (!stream[bunHTTP2Closed]) {
-          stream[bunHTTP2Closed] = true;
-        }
+    wantTrailers(self: ServerHttp2Session, stream: ServerHttp2Stream) {
+      if (!self || typeof stream !== "object") return;
+      const status = stream[bunHTTP2StreamStatus];
+      if ((status & StreamState.WantTrailer) !== 0) return;
 
-        stream.rstCode = constants.NGHTTP2_CANCEL;
-        stream.emit("aborted");
+      stream[bunHTTP2StreamStatus] = status | StreamState.WantTrailer;
+
+      if (stream.listenerCount("wantTrailers") === 0) {
+        self[bunHTTP2Native]?.noTrailers(stream.id);
       } else {
-        process.nextTick(emitAbortedNT, self, self.#streams, streamId, error);
-      }
-    },
-    wantTrailers(self: ClientHttp2Session, streamId: number) {
-      if (!self) return;
-      var stream = self.#streams.get(streamId);
-      if (stream) {
-        stream[bunHTTP2WantTrailers] = true;
         stream.emit("wantTrailers");
-      } else {
-        process.nextTick(emitWantTrailersNT, self.#streams, streamId);
       }
     },
-    goaway(self: ClientHttp2Session, errorCode: number, lastStreamId: number, opaqueData?: Buffer) {
+    goaway(self: ServerHttp2Session, errorCode: number, lastStreamId: number, opaqueData: Buffer) {
       if (!self) return;
       self.emit("goaway", errorCode, lastStreamId, opaqueData || Buffer.allocUnsafe(0));
       if (errorCode !== 0) {
-        for (let [_, stream] of self.#streams) {
-          stream.rstCode = errorCode;
-          stream.destroy(sessionErrorFromCode(errorCode), errorCode);
-        }
+        self.#parser.emitErrorToAllStreams(errorCode);
       }
-      self[bunHTTP2Socket]?.end();
-      self[bunHTTP2Socket] = null;
-      self.#parser = null;
+      self.close();
     },
-    end(self: ClientHttp2Session, errorCode: number, lastStreamId: number, opaqueData: Buffer) {
+    end(self: ServerHttp2Session, errorCode: number, lastStreamId: number, opaqueData: Buffer) {
       if (!self) return;
-      self[bunHTTP2Socket]?.end();
-      self[bunHTTP2Socket] = null;
-      self.#parser = null;
+      self.destroy();
     },
-    write(self: ClientHttp2Session, buffer: Buffer) {
-      if (!self) return;
+    write(self: ServerHttp2Session, buffer: Buffer) {
+      if (!self) return -1;
       const socket = self[bunHTTP2Socket];
-      if (!socket) return;
-      if (self.#connected) {
+      if (socket && !socket.writableEnded && self.#connected) {
         // redirect writes to socket
-        socket.write(buffer);
-      } else {
-        //queue
-        self.#queue.push(buffer);
+        return socket.write(buffer) ? 1 : 0;
       }
+      return -1;
     },
   };
 
@@ -889,27 +2379,54 @@ class ClientHttp2Session extends Http2Session {
     this.#parser?.read(data);
   }
 
-  get originSet() {
-    if (this.encrypted) {
-      return Array.from(this.#originSet);
+  #onClose() {
+    const parser = this.#parser;
+    if (parser) {
+      parser.emitAbortToAllStreams();
+      parser.detach();
+      this.#parser = null;
+    }
+    this.close();
+  }
+
+  #onError(error: Error) {
+    this.destroy(error);
+  }
+
+  #onTimeout() {
+    const parser = this.#parser;
+    if (parser) {
+      for (const stream of parser.getAllStreams()) {
+        if (stream) {
+          stream.emit("timeout");
+        }
+      }
+    }
+    this.emit("timeout");
+    this.destroy();
+  }
+
+  #onDrain() {
+    const parser = this.#parser;
+    if (parser) {
+      parser.flush();
     }
   }
-  get alpnProtocol() {
-    return this.#alpnProtocol;
+
+  altsvc() {
+    // throwNotImplemented("ServerHttp2Stream.prototype.altsvc()");
   }
-  #onConnect() {
-    const socket = this[bunHTTP2Socket];
-    if (!socket) return;
+  origin() {
+    // throwNotImplemented("ServerHttp2Stream.prototype.origin()");
+  }
+
+  constructor(socket: TLSSocket | Socket, options?: Http2ConnectOptions, server: Http2Server) {
+    super();
+    this[kServer] = server;
     this.#connected = true;
-    // check if h2 is supported only for TLSSocket
     if (socket instanceof TLSSocket) {
-      if (socket.alpnProtocol !== "h2") {
-        socket.end();
-        const error = new Error("ERR_HTTP2_ERROR: h2 is not supported");
-        error.code = "ERR_HTTP2_ERROR";
-        this.emit("error", error);
-      }
-      this.#alpnProtocol = "h2";
+      // server will receive the preface to know if is or not h2
+      this.#alpnProtocol = socket.alpnProtocol || "h2";
 
       const origin = socket[bunTLSConnectOptions]?.serverName || socket.remoteAddress;
       this.#originSet.add(origin);
@@ -917,34 +2434,430 @@ class ClientHttp2Session extends Http2Session {
     } else {
       this.#alpnProtocol = "h2c";
     }
+    this[bunHTTP2Socket] = socket;
+    const nativeSocket = socket._handle;
+    this.#encrypted = socket instanceof TLSSocket;
 
-    // TODO: make a native bindings on data and write and fallback to non-native
+    this.#parser = new H2FrameParser({
+      native: nativeSocket,
+      context: this,
+      settings: options || {},
+      type: 0, // server type
+      handlers: ServerHttp2Session.#Handlers,
+    });
+    socket.on("close", this.#onClose.bind(this));
+    socket.on("error", this.#onError.bind(this));
+    socket.on("timeout", this.#onTimeout.bind(this));
     socket.on("data", this.#onRead.bind(this));
+    socket.on("drain", this.#onDrain.bind(this));
 
-    // redirect the queued buffers
-    const queue = this.#queue;
-    while (queue.length) {
-      socket.write(queue.shift());
-    }
     process.nextTick(emitConnectNT, this, socket);
   }
 
-  #onClose() {
-    this.#parser = null;
-    this[bunHTTP2Socket] = null;
-    this.emit("close");
-  }
-  #onError(error: Error) {
-    this.#parser = null;
-    this[bunHTTP2Socket] = null;
-    this.emit("error", error);
-  }
-  #onTimeout() {
-    for (let [_, stream] of this.#streams) {
-      stream.emit("timeout");
+  get originSet() {
+    if (this.encrypted) {
+      return Array.from(this.#originSet);
+    }
+  }
+
+  get alpnProtocol() {
+    return this.#alpnProtocol;
+  }
+  get connecting() {
+    const socket = this[bunHTTP2Socket];
+    if (!socket) {
+      return false;
+    }
+    return socket.connecting || false;
+  }
+  get connected() {
+    return this[bunHTTP2Socket]?.connecting === false;
+  }
+  get destroyed() {
+    return this[bunHTTP2Socket] === null;
+  }
+  get encrypted() {
+    return this.#encrypted;
+  }
+  get closed() {
+    return this.#closed;
+  }
+
+  get remoteSettings() {
+    return this.#remoteSettings;
+  }
+
+  get localSettings() {
+    return this.#localSettings;
+  }
+
+  get pendingSettingsAck() {
+    return this.#pendingSettingsAck;
+  }
+
+  get type() {
+    return 0;
+  }
+
+  get socket() {
+    if (this.#socket_proxy) return this.#socket_proxy;
+    const socket = this[bunHTTP2Socket];
+    if (!socket) return null;
+    this.#socket_proxy = new Proxy(this, proxySocketHandler);
+    return this.#socket_proxy;
+  }
+  get state() {
+    return this.#parser?.getCurrentState();
+  }
+
+  get [bunHTTP2Native]() {
+    return this.#parser;
+  }
+
+  unref() {
+    return this[bunHTTP2Socket]?.unref();
+  }
+  ref() {
+    return this[bunHTTP2Socket]?.ref();
+  }
+  setTimeout(msecs, callback) {
+    return this[bunHTTP2Socket]?.setTimeout(msecs, callback);
+  }
+
+  ping(payload, callback) {
+    if (typeof payload === "function") {
+      callback = payload;
+      payload = Buffer.alloc(8);
+    } else {
+      payload = payload || Buffer.alloc(8);
+    }
+    if (!(payload instanceof Buffer) && !isTypedArray(payload)) {
+      throw $ERR_INVALID_ARG_TYPE("payload must be a Buffer or TypedArray");
+    }
+    const parser = this.#parser;
+    if (!parser) return false;
+    if (!this[bunHTTP2Socket]) return false;
+
+    if (typeof callback === "function") {
+      if (payload.byteLength !== 8) {
+        const error = $ERR_HTTP2_PING_LENGTH("HTTP2 ping payload must be 8 bytes");
+        callback(error, 0, payload);
+        return;
+      }
+      if (this.#pingCallbacks) {
+        this.#pingCallbacks.push([callback, Date.now()]);
+      } else {
+        this.#pingCallbacks = [[callback, Date.now()]];
+      }
+    } else if (payload.byteLength !== 8) {
+      throw $ERR_HTTP2_PING_LENGTH("HTTP2 ping payload must be 8 bytes");
+    }
+
+    parser.ping(payload);
+    return true;
+  }
+  goaway(errorCode, lastStreamId, opaqueData) {
+    return this.#parser?.goaway(errorCode, lastStreamId, opaqueData);
+  }
+
+  setLocalWindowSize(windowSize) {
+    return this.#parser?.setLocalWindowSize(windowSize);
+  }
+
+  settings(settings: Settings, callback) {
+    this.#pendingSettingsAck = true;
+    this.#parser?.settings(settings);
+    if (typeof callback === "function") {
+      const start = Date.now();
+      this.once("localSettings", () => {
+        callback(null, this.#localSettings, Date.now() - start);
+      });
+    }
+  }
+
+  // Gracefully closes the Http2Session, allowing any existing streams to complete on their own and preventing new Http2Stream instances from being created. Once closed, http2session.destroy() might be called if there are no open Http2Stream instances.
+  // If specified, the callback function is registered as a handler for the 'close' event.
+  close(callback: Function) {
+    this.#closed = true;
+    if (typeof callback === "function") {
+      this.once("close", callback);
+    }
+    if (this.#connections === 0) {
+      this.destroy();
+    }
+  }
+
+  destroy(error?: Error, code?: number) {
+    const socket = this[bunHTTP2Socket];
+
+    this.#closed = true;
+    this.#connected = false;
+    if (socket) {
+      this.goaway(code || constants.NGHTTP2_NO_ERROR, 0, Buffer.alloc(0));
+      socket.end();
+    }
+    const parser = this.#parser;
+    if (parser) {
+      parser.emitErrorToAllStreams(code || constants.NGHTTP2_NO_ERROR);
+      parser.detach();
+      this.#parser = null;
+    }
+    this[bunHTTP2Socket] = null;
+
+    if (error) {
+      this.emit("error", error);
+    }
+
+    this.emit("close");
+  }
+}
+class ClientHttp2Session extends Http2Session {
+  /// close indicates that we called closed
+  #closed: boolean = false;
+  /// connected indicates that the connection/socket is connected
+  #connected: boolean = false;
+  #connections: number = 0;
+  [bunHTTP2Socket]: TLSSocket | Socket | null;
+  #socket_proxy: Proxy<TLSSocket | Socket>;
+  #parser: typeof H2FrameParser | null;
+  #url: URL;
+  #originSet = new Set<string>();
+  #alpnProtocol: string | undefined = undefined;
+  #localSettings: Settings | null = {
+    headerTableSize: 4096,
+    enablePush: true,
+    maxConcurrentStreams: 100,
+    initialWindowSize: 65535,
+    maxFrameSize: 16384,
+    maxHeaderListSize: 65535,
+    maxHeaderSize: 65535,
+  };
+  #encrypted: boolean = false;
+  #pendingSettingsAck: boolean = true;
+  #remoteSettings: Settings | null = null;
+  #pingCallbacks: Array<[Function, number]> | null = null;
+
+  static #Handlers = {
+    binaryType: "buffer",
+    streamStart(self: ClientHttp2Session, stream_id: number) {
+      if (!self) return;
+      self.#connections++;
+
+      if (stream_id % 2 === 0) {
+        // pushStream
+        const stream = new ClientHttp2Session(stream_id, self, null);
+        self.#parser?.setStreamContext(stream_id, stream);
+      }
+    },
+    aborted(self: ClientHttp2Session, stream: ClientHttp2Stream, error: any, old_state: number) {
+      if (!self || typeof stream !== "object") return;
+      stream.rstCode = constants.NGHTTP2_CANCEL;
+      // if writable and not closed emit aborted
+      if (old_state != 5 && old_state != 7) {
+        stream[kAborted] = true;
+        stream.emit("aborted");
+      }
+      self.#connections--;
+      process.nextTick(emitStreamErrorNT, self, stream, error, true, self.#connections === 0 && self.#closed);
+    },
+    streamError(self: ClientHttp2Session, stream: ClientHttp2Stream, error: number) {
+      if (!self || typeof stream !== "object") return;
+      self.#connections--;
+      process.nextTick(emitStreamErrorNT, self, stream, error, true, self.#connections === 0 && self.#closed);
+    },
+    streamEnd(self: ClientHttp2Session, stream: ClientHttp2Stream, state: number) {
+      if (!self || typeof stream !== "object") return;
+
+      if (state == 6 || state == 7) {
+        if (stream.readable) {
+          stream.rstCode = 0;
+          // Push a null so the stream can end whenever the client consumes
+          // it completely.
+          pushToStream(stream, null);
+          stream.read(0);
+        }
+      }
+
+      // 7 = closed, in this case we already send everything and received everything
+      if (state === 7) {
+        markStreamClosed(stream);
+        self.#connections--;
+        stream.destroy();
+        if (self.#connections === 0 && self.#closed) {
+          self.destroy();
+        }
+      } else if (state === 5) {
+        // 5 = local closed aka write is closed
+        markWritableDone(stream);
+      }
+    },
+    streamData(self: ClientHttp2Session, stream: ClientHttp2Stream, data: Buffer) {
+      if (!self || typeof stream !== "object" || !data) return;
+      pushToStream(stream, data);
+    },
+    streamHeaders(
+      self: ClientHttp2Session,
+      stream: ClientHttp2Stream,
+      rawheaders: string[],
+      sensitiveHeadersValue: string[] | undefined,
+      flags: number,
+    ) {
+      if (!self || typeof stream !== "object") return;
+      const headers = toHeaderObject(rawheaders, sensitiveHeadersValue || []);
+      const status = stream[bunHTTP2StreamStatus];
+      const header_status = headers[":status"];
+      if (header_status === HTTP_STATUS_CONTINUE) {
+        stream.emit("continue");
+      }
+
+      if ((status & StreamState.StreamResponded) !== 0) {
+        stream.emit("trailers", headers, flags, rawheaders);
+      } else {
+        if (header_status >= 100 && header_status < 200) {
+          self.emit("headers", stream, headers, flags, rawheaders);
+        } else {
+          stream[bunHTTP2StreamStatus] = status | StreamState.StreamResponded;
+          self.emit("stream", stream, headers, flags, rawheaders);
+          stream.emit("response", headers, flags, rawheaders);
+        }
+      }
+    },
+    localSettings(self: ClientHttp2Session, settings: Settings) {
+      if (!self) return;
+      self.#localSettings = settings;
+      self.#pendingSettingsAck = false;
+      self.emit("localSettings", settings);
+    },
+    remoteSettings(self: ClientHttp2Session, settings: Settings) {
+      if (!self) return;
+      self.#remoteSettings = settings;
+      self.emit("remoteSettings", settings);
+    },
+    ping(self: ClientHttp2Session, payload: Buffer, isACK: boolean) {
+      if (!self) return;
+      self.emit("ping", payload);
+      if (isACK) {
+        const callbacks = self.#pingCallbacks;
+        if (callbacks) {
+          const callbackInfo = callbacks.shift();
+          if (callbackInfo) {
+            const [callback, start] = callbackInfo;
+            callback(null, Date.now() - start, payload);
+          }
+        }
+      }
+    },
+    error(self: ClientHttp2Session, errorCode: number, lastStreamId: number, opaqueData: Buffer) {
+      if (!self) return;
+      const error_instance = sessionErrorFromCode(errorCode);
+      self.destroy(error_instance);
+    },
+
+    wantTrailers(self: ClientHttp2Session, stream: ClientHttp2Stream) {
+      if (!self || typeof stream !== "object") return;
+      const status = stream[bunHTTP2StreamStatus];
+      if ((status & StreamState.WantTrailer) !== 0) return;
+      stream[bunHTTP2StreamStatus] = status | StreamState.WantTrailer;
+      if (stream.listenerCount("wantTrailers") === 0) {
+        self[bunHTTP2Native]?.noTrailers(stream.id);
+      } else {
+        stream.emit("wantTrailers");
+      }
+    },
+    goaway(self: ClientHttp2Session, errorCode: number, lastStreamId: number, opaqueData: Buffer) {
+      if (!self) return;
+      self.emit("goaway", errorCode, lastStreamId, opaqueData || Buffer.allocUnsafe(0));
+      if (errorCode !== 0) {
+        self.#parser.emitErrorToAllStreams(errorCode);
+      }
+      self.close();
+    },
+    end(self: ClientHttp2Session, errorCode: number, lastStreamId: number, opaqueData: Buffer) {
+      if (!self) return;
+      self.destroy();
+    },
+    write(self: ClientHttp2Session, buffer: Buffer) {
+      if (!self) return -1;
+      const socket = self[bunHTTP2Socket];
+      if (socket && !socket.writableEnded && self.#connected) {
+        // redirect writes to socket
+        return socket.write(buffer) ? 1 : 0;
+      }
+      return -1;
+    },
+  };
+
+  #onRead(data: Buffer) {
+    this.#parser?.read(data);
+  }
+
+  get originSet() {
+    if (this.encrypted) {
+      return Array.from(this.#originSet);
+    }
+  }
+  get alpnProtocol() {
+    return this.#alpnProtocol;
+  }
+  #onConnect() {
+    const socket = this[bunHTTP2Socket];
+    if (!socket) return;
+    this.#connected = true;
+    // check if h2 is supported only for TLSSocket
+    if (socket instanceof TLSSocket) {
+      // client must check alpnProtocol
+      if (socket.alpnProtocol !== "h2") {
+        socket.end();
+        const error = $ERR_HTTP2_ERROR("h2 is not supported");
+        this.emit("error", error);
+      }
+      this.#alpnProtocol = "h2";
+
+      const origin = socket[bunTLSConnectOptions]?.serverName || socket.remoteAddress;
+      this.#originSet.add(origin);
+      this.emit("origin", this.originSet);
+    } else {
+      this.#alpnProtocol = "h2c";
+    }
+    const nativeSocket = socket._handle;
+    if (nativeSocket) {
+      this.#parser.setNativeSocket(nativeSocket);
+    }
+    process.nextTick(emitConnectNT, this, socket);
+    this.#parser.flush();
+  }
+
+  #onClose() {
+    const parser = this.#parser;
+    if (parser) {
+      parser.emitAbortToAllStreams();
+      parser.detach();
+      this.#parser = null;
+    }
+    this.close();
+    this[bunHTTP2Socket] = null;
+  }
+  #onError(error: Error) {
+    this[bunHTTP2Socket] = null;
+    this.destroy(error);
+  }
+  #onTimeout() {
+    const parser = this.#parser;
+    if (parser) {
+      for (const stream of parser.getAllStreams()) {
+        if (stream) {
+          stream.emit("timeout");
+        }
+      }
+    }
+    this.emit("timeout");
+    this.destroy();
+  }
+  #onDrain() {
+    const parser = this.#parser;
+    if (parser) {
+      parser.flush();
     }
-    this.emit("timeout");
-    this.destroy();
   }
   get connecting() {
     const socket = this[bunHTTP2Socket];
@@ -979,7 +2892,6 @@ class ClientHttp2Session extends Http2Session {
   }
 
   get type() {
-    if (this.#isServer) return 0;
     return 1;
   }
   unref() {
@@ -999,9 +2911,7 @@ class ClientHttp2Session extends Http2Session {
       payload = payload || Buffer.alloc(8);
     }
     if (!(payload instanceof Buffer) && !isTypedArray(payload)) {
-      const error = new TypeError("ERR_INVALID_ARG_TYPE: payload must be a Buffer or TypedArray");
-      error.code = "ERR_INVALID_ARG_TYPE";
-      throw error;
+      throw $ERR_INVALID_ARG_TYPE("payload must be a Buffer or TypedArray");
     }
     const parser = this.#parser;
     if (!parser) return false;
@@ -1009,8 +2919,7 @@ class ClientHttp2Session extends Http2Session {
 
     if (typeof callback === "function") {
       if (payload.byteLength !== 8) {
-        const error = new RangeError("ERR_HTTP2_PING_LENGTH: HTTP2 ping payload must be 8 bytes");
-        error.code = "ERR_HTTP2_PING_LENGTH";
+        const error = $ERR_HTTP2_PING_LENGTH("HTTP2 ping payload must be 8 bytes");
         callback(error, 0, payload);
         return;
       }
@@ -1020,9 +2929,7 @@ class ClientHttp2Session extends Http2Session {
         this.#pingCallbacks = [[callback, Date.now()]];
       }
     } else if (payload.byteLength !== 8) {
-      const error = new RangeError("ERR_HTTP2_PING_LENGTH: HTTP2 ping payload must be 8 bytes");
-      error.code = "ERR_HTTP2_PING_LENGTH";
-      throw error;
+      throw $ERR_HTTP2_PING_LENGTH("HTTP2 ping payload must be 8 bytes");
     }
 
     parser.ping(payload);
@@ -1036,9 +2943,10 @@ class ClientHttp2Session extends Http2Session {
     return this.#parser?.setLocalWindowSize(windowSize);
   }
   get socket() {
+    if (this.#socket_proxy) return this.#socket_proxy;
+
     const socket = this[bunHTTP2Socket];
     if (!socket) return null;
-    if (this.#socket_proxy) return this.#socket_proxy;
     this.#socket_proxy = new Proxy(this, proxySocketHandler);
     return this.#socket_proxy;
   }
@@ -1064,13 +2972,12 @@ class ClientHttp2Session extends Http2Session {
       url = new URL(url);
     }
     if (!(url instanceof URL)) {
-      throw new Error("ERR_HTTP2: Invalid URL");
+      throw $ERR_INVALID_ARG_TYPE("Invalid URL");
     }
     if (typeof options === "function") {
       listener = options;
       options = undefined;
     }
-    this.#isServer = true;
     this.#url = url;
 
     const protocol = url.protocol || options?.protocol || "https:";
@@ -1100,26 +3007,28 @@ class ClientHttp2Session extends Http2Session {
           ? {
               host: url.hostname,
               port,
-              ALPNProtocols: ["h2", "http/1.1"],
+              ALPNProtocols: ["h2"],
               ...options,
             }
           : {
               host: url.hostname,
               port,
-              ALPNProtocols: ["h2", "http/1.1"],
+              ALPNProtocols: ["h2"],
             },
         onConnect.bind(this),
       );
       this[bunHTTP2Socket] = socket;
     }
     this.#encrypted = socket instanceof TLSSocket;
-
+    const nativeSocket = socket._handle;
     this.#parser = new H2FrameParser({
+      native: nativeSocket,
       context: this,
       settings: options,
       handlers: ClientHttp2Session.#Handlers,
     });
-
+    socket.on("data", this.#onRead.bind(this));
+    socket.on("drain", this.#onDrain.bind(this));
     socket.on("close", this.#onClose.bind(this));
     socket.on("error", this.#onError.bind(this));
     socket.on("timeout", this.#onTimeout.bind(this));
@@ -1142,21 +3051,17 @@ class ClientHttp2Session extends Http2Session {
     const socket = this[bunHTTP2Socket];
     this.#closed = true;
     this.#connected = false;
-    code = code || constants.NGHTTP2_NO_ERROR;
     if (socket) {
-      this.goaway(code, 0, Buffer.alloc(0));
+      this.goaway(code || constants.NGHTTP2_NO_ERROR, 0, Buffer.alloc(0));
       socket.end();
     }
-    this[bunHTTP2Socket] = null;
-    // this should not be needed since RST + GOAWAY should be sent
-    for (let [_, stream] of this.#streams) {
-      if (error) {
-        stream.emit("error", error);
-      }
-      stream.destroy();
-      stream.rstCode = code;
-      stream.emit("close");
+    const parser = this.#parser;
+    if (parser) {
+      parser.emitErrorToAllStreams(code || constants.NGHTTP2_NO_ERROR);
+      parser.detach();
     }
+    this.#parser = null;
+    this[bunHTTP2Socket] = null;
 
     if (error) {
       this.emit("error", error);
@@ -1167,28 +3072,26 @@ class ClientHttp2Session extends Http2Session {
 
   request(headers: any, options?: any) {
     if (this.destroyed || this.closed) {
-      const error = new Error(`ERR_HTTP2_INVALID_STREAM: The stream has been destroyed`);
-      error.code = "ERR_HTTP2_INVALID_STREAM";
-      throw error;
+      throw $ERR_HTTP2_INVALID_STREAM(`The stream has been destroyed`);
     }
 
     if (this.sentTrailers) {
-      const error = new Error(`ERR_HTTP2_TRAILERS_ALREADY_SENT: Trailing headers have already been sent`);
-      error.code = "ERR_HTTP2_TRAILERS_ALREADY_SENT";
-      throw error;
+      throw $ERR_HTTP2_TRAILERS_ALREADY_SENT(`Trailing headers have already been sent`);
     }
 
-    if (!$isObject(headers)) {
-      throw new Error("ERR_HTTP2_INVALID_HEADERS: headers must be an object");
+    if (headers == undefined) {
+      headers = {};
+    } else if (!$isObject(headers)) {
+      throw $ERR_HTTP2_INVALID_HEADERS("headers must be an object");
+    } else {
+      headers = { ...headers };
     }
 
     const sensitives = headers[sensitiveHeaders];
     const sensitiveNames = {};
     if (sensitives) {
       if (!$isArray(sensitives)) {
-        const error = new TypeError("ERR_INVALID_ARG_VALUE: The arguments headers[http2.neverIndex] is invalid");
-        error.code = "ERR_INVALID_ARG_VALUE";
-        throw error;
+        throw $ERR_INVALID_ARG_VALUE("The arguments headers[http2.neverIndex] is invalid.");
       }
       for (let i = 0; i < sensitives.length; i++) {
         sensitiveNames[sensitives[i]] = true;
@@ -1222,29 +3125,30 @@ class ClientHttp2Session extends Http2Session {
       }
       headers[":scheme"] = scheme;
     }
+    if (headers[":path"] == undefined) {
+      headers[":path"] = "/";
+    }
 
     if (NoPayloadMethods.has(method.toUpperCase())) {
-      options = options || {};
-      options.endStream = true;
+      if (!options || !$isObject(options)) {
+        options = { endStream: true };
+      } else {
+        options = { ...options, endStream: true };
+      }
     }
-    let stream_id: number;
-    if (typeof options === "undefined") {
-      stream_id = this.#parser.request(headers, sensitiveNames);
-    } else {
-      stream_id = this.#parser.request(headers, sensitiveNames, options);
-    }
-
+    let stream_id: number = this.#parser.getNextStream();
+    const req = new ClientHttp2Stream(stream_id, this, headers);
+    req.authority = authority;
     if (stream_id < 0) {
-      const error = new Error(
-        "ERR_HTTP2_OUT_OF_STREAMS: No stream ID is available because maximum stream ID has been reached",
-      );
-      error.code = "ERR_HTTP2_OUT_OF_STREAMS";
+      const error = $ERR_HTTP2_OUT_OF_STREAMS("No stream ID is available because maximum stream ID has been reached");
       this.emit("error", error);
       return null;
     }
-    const req = new ClientHttp2Stream(stream_id, this, headers);
-    req.authority = authority;
-    this.#streams.set(stream_id, req);
+    if (typeof options === "undefined") {
+      this.#parser.request(stream_id, req, headers, sensitiveNames);
+    } else {
+      this.#parser.request(stream_id, req, headers, sensitiveNames, options);
+    }
     req.emit("ready");
     return req;
   }
@@ -1261,24 +3165,152 @@ function connect(url: string | URL, options?: Http2ConnectOptions, listener?: Fu
   return ClientHttp2Session.connect(url, options, listener);
 }
 
-function createServer() {
-  throwNotImplemented("node:http2 createServer", 8823);
+function setupCompat(ev) {
+  if (ev === "request") {
+    this.removeListener("newListener", setupCompat);
+    const options = this[bunSocketServerOptions];
+    const ServerRequest = options?.Http2ServerRequest || Http2ServerRequest;
+    const ServerResponse = options?.Http2ServerResponse || Http2ServerResponse;
+    this.on("stream", FunctionPrototypeBind(onServerStream, this, ServerRequest, ServerResponse));
+  }
 }
-function createSecureServer() {
-  throwNotImplemented("node:http2 createSecureServer", 8823);
+
+function sessionOnError(error) {
+  this[kServer]?.emit("sessionError", error, this);
+}
+function sessionOnTimeout() {
+  if (this.destroyed || this.closed) return;
+  const server = this[kServer];
+  if (!server.emit("timeout", this)) {
+    this.destroy();
+  }
+}
+function connectionListener(socket: Socket) {
+  const options = this[bunSocketServerOptions] || {};
+  if (socket.alpnProtocol === false || socket.alpnProtocol === "http/1.1") {
+    // TODO: Fallback to HTTP/1.1
+    // if (options.allowHTTP1 === true) {
+
+    // }
+    // Let event handler deal with the socket
+
+    if (!this.emit("unknownProtocol", socket)) {
+      // Install a timeout if the socket was not successfully closed, then
+      // destroy the socket to ensure that the underlying resources are
+      // released.
+      const timer = setTimeout(() => {
+        if (!socket.destroyed) {
+          socket.destroy();
+        }
+      }, options.unknownProtocolTimeout);
+      // Un-reference the timer to avoid blocking of application shutdown and
+      // clear the timeout if the socket was successfully closed.
+      timer.unref();
+
+      socket.once("close", () => clearTimeout(timer));
+
+      // We don't know what to do, so let's just tell the other side what's
+      // going on in a format that they *might* understand.
+      socket.end(
+        "HTTP/1.0 403 Forbidden\r\n" +
+          "Content-Type: text/plain\r\n\r\n" +
+          "Missing ALPN Protocol, expected `h2` to be available.\n" +
+          "If this is a HTTP request: The server was not " +
+          "configured with the `allowHTTP1` option or a " +
+          "listener for the `unknownProtocol` event.\n",
+      );
+    }
+  }
+
+  const session = new ServerHttp2Session(socket, options, this);
+  session.on("error", sessionOnError);
+  const timeout = this.timeout;
+  if (timeout) session.setTimeout(timeout, sessionOnTimeout);
+
+  this.emit("session", session);
+}
+class Http2Server extends net.Server {
+  timeout = 0;
+  constructor(options, onRequestHandler) {
+    if (typeof options === "function") {
+      onRequestHandler = options;
+      options = {};
+    } else if (options == null || typeof options == "object") {
+      options = { ...options };
+    } else {
+      throw $ERR_INVALID_ARG_TYPE("options must be an object");
+    }
+    super(options, connectionListener);
+    this.setMaxListeners(0);
+
+    this.on("newListener", setupCompat);
+    if (typeof onRequestHandler === "function") {
+      this.on("request", onRequestHandler);
+    }
+  }
+
+  setTimeout(ms, callback) {
+    this.timeout = ms;
+    if (typeof callback === "function") {
+      this.on("timeout", callback);
+    }
+  }
+  updateSettings(settings) {
+    assertSettings(settings);
+    const options = this[bunSocketServerOptions];
+    if (options) {
+      options.settings = { ...options.settings, ...settings };
+    }
+  }
+}
+
+function onErrorSecureServerSession(err, socket) {
+  if (!this.emit("clientError", err, socket)) socket.destroy(err);
+}
+class Http2SecureServer extends tls.Server {
+  timeout = 0;
+  constructor(options, onRequestHandler) {
+    //TODO: add 'http/1.1' on ALPNProtocols list after allowHTTP1 support
+    if (typeof options === "function") {
+      onRequestHandler = options;
+      options = { ALPNProtocols: ["h2"] };
+    } else if (options == null || typeof options == "object") {
+      options = { ...options, ALPNProtocols: ["h2"] };
+    } else {
+      throw $ERR_INVALID_ARG_TYPE("options must be an object");
+    }
+    super(options, connectionListener);
+    this.setMaxListeners(0);
+    this.on("newListener", setupCompat);
+    if (typeof onRequestHandler === "function") {
+      this.on("request", onRequestHandler);
+    }
+    this.on("tlsClientError", onErrorSecureServerSession);
+  }
+  setTimeout(ms, callback) {
+    this.timeout = ms;
+    if (typeof callback === "function") {
+      this.on("timeout", callback);
+    }
+  }
+  updateSettings(settings) {
+    assertSettings(settings);
+    const options = this[bunSocketServerOptions];
+    if (options) {
+      options.settings = { ...options.settings, ...settings };
+    }
+  }
+}
+function createServer(options, onRequestHandler) {
+  return new Http2Server(options, onRequestHandler);
+}
+function createSecureServer(options, onRequestHandler) {
+  return new Http2SecureServer(options, onRequestHandler);
 }
 function getDefaultSettings() {
   // return default settings
   return getUnpackedSettings();
 }
-function Http2ServerRequest() {
-  throwNotImplemented("node:http2 Http2ServerRequest", 8823);
-}
-Http2ServerRequest.prototype = {};
-function Http2ServerResponse() {
-  throwNotImplemented("node:http2 Http2ServerResponse", 8823);
-}
-Http2ServerResponse.prototype = {};
 
 export default {
   constants,
diff --git a/src/js/node/https.ts b/src/js/node/https.ts
index 9f6c66abbd..9752228462 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 408b38f4ec..c06c476816 100644
--- a/src/js/node/net.ts
+++ b/src/js/node/net.ts
@@ -18,6 +18,7 @@
 // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 const { Duplex } = require("node:stream");
 const EventEmitter = require("node:events");
@@ -70,18 +71,55 @@ const bunSocketServerHandlers = Symbol.for("::bunsocket_serverhandlers::");
 const bunSocketServerConnections = Symbol.for("::bunnetserverconnections::");
 const bunSocketServerOptions = Symbol.for("::bunnetserveroptions::");
 
-const bunSocketInternal = Symbol.for("::bunnetsocketinternal::");
 const kServerSocket = Symbol("kServerSocket");
+const kBytesWritten = Symbol("kBytesWritten");
 const bunTLSConnectOptions = Symbol.for("::buntlsconnectoptions::");
 
 const kRealListen = Symbol("kRealListen");
+const kSetNoDelay = Symbol("kSetNoDelay");
+const kSetKeepAlive = Symbol("kSetKeepAlive");
+const kSetKeepAliveInitialDelay = Symbol("kSetKeepAliveInitialDelay");
 
 function endNT(socket, callback, err) {
-  socket.end();
+  socket.$end();
   callback(err);
 }
-function closeNT(callback, err) {
-  callback(err);
+function emitCloseNT(self, hasError) {
+  if (hasError) {
+    self.emit("close", hasError);
+  } else {
+    self.emit("close");
+  }
+}
+function detachSocket(self) {
+  if (!self) self = this;
+  self._handle = null;
+}
+function finishSocket(hasError) {
+  detachSocket(this);
+  this.emit("close", hasError);
+}
+// Provide a better error message when we call end() as a result
+// of the other side sending a FIN.  The standard 'write after end'
+// is overly vague, and makes it seem like the user's code is to blame.
+function writeAfterFIN(chunk, encoding, cb) {
+  if (!this.writableEnded) {
+    return Duplex.prototype.write.$call(this, chunk, encoding, cb);
+  }
+
+  if (typeof encoding === "function") {
+    cb = encoding;
+    encoding = null;
+  }
+
+  const err = new Error("This socket has been ended by the other party");
+  err.code = "EPIPE";
+  if (typeof cb === "function") {
+    process.nextTick(cb, err);
+  }
+  this.destroy(err);
+
+  return false;
 }
 
 var SocketClass;
@@ -105,16 +143,14 @@ const Socket = (function (InternalSocket) {
   class Socket extends Duplex {
     static #Handlers = {
       close: Socket.#Close,
-      data({ data: self }, buffer) {
+      data(socket, buffer) {
+        const { data: self } = socket;
         if (!self) return;
 
         self.bytesRead += buffer.length;
-        const queue = self.#readQueue;
-
-        if (queue.isEmpty()) {
-          if (self.push(buffer)) return;
+        if (!self.push(buffer)) {
+          socket.pause();
         }
-        queue.push(buffer);
       },
       drain: Socket.#Drain,
       end: Socket.#End,
@@ -132,11 +168,10 @@ const Socket = (function (InternalSocket) {
       open(socket) {
         const self = socket.data;
         if (!self) return;
-
         socket.timeout(Math.ceil(self.timeout / 1000));
 
         if (self.#unrefOnConnected) socket.unref();
-        self[bunSocketInternal] = socket;
+        self._handle = socket;
         self.connecting = false;
         const options = self[bunTLSConnectOptions];
 
@@ -147,10 +182,20 @@ const Socket = (function (InternalSocket) {
           }
         }
 
+        if (self[kSetNoDelay]) {
+          socket.setNoDelay(true);
+        }
+
+        if (self[kSetKeepAlive]) {
+          socket.setKeepAlive(true, self[kSetKeepAliveInitialDelay]);
+        }
+
         if (!self.#upgraded) {
+          self[kBytesWritten] = socket.bytesWritten;
           // this is not actually emitted on nodejs when socket used on the connection
           // this is already emmited on non-TLS socket and on TLS socket is emmited secureConnect after handshake
           self.emit("connect", self);
+          self.emit("ready");
         }
 
         Socket.#Drain(socket);
@@ -164,7 +209,7 @@ const Socket = (function (InternalSocket) {
         self._secureEstablished = !!success;
 
         self.emit("secure", self);
-
+        self.alpnProtocol = socket.alpnProtocol;
         const { checkServerIdentity } = self[bunTLSConnectOptions];
         if (!verifyError && typeof checkServerIdentity === "function" && self.servername) {
           const cert = self.getPeerCertificate(true);
@@ -175,7 +220,6 @@ const Socket = (function (InternalSocket) {
             self.authorized = false;
             self.authorizationError = verifyError.code || verifyError.message;
             if (self._rejectUnauthorized) {
-              self.emit("error", verifyError);
               self.destroy(verifyError);
               return;
             }
@@ -199,68 +243,66 @@ const Socket = (function (InternalSocket) {
     static #End(socket) {
       const self = socket.data;
       if (!self) return;
-      self.#ended = true;
-      const queue = self.#readQueue;
-      if (queue.isEmpty()) {
-        if (self.push(null)) {
-          return;
-        }
-      }
-      queue.push(null);
+
+      // we just reuse the same code but we can push null or enqueue right away
+      Socket.#EmitEndNT(self);
     }
-    static #Close(socket) {
+    static #EmitEndNT(self, err) {
+      if (!self.#ended) {
+        if (!self.allowHalfOpen) {
+          self.write = writeAfterFIN;
+        }
+        self.#ended = true;
+        self.push(null);
+      }
+      // TODO: check how the best way to handle this
+      // if (err) {
+      //   self.destroy(err);
+      // }
+    }
+    static #Close(socket, err) {
       const self = socket.data;
       if (!self || self.#closed) return;
       self.#closed = true;
       //socket cannot be used after close
-      self[bunSocketInternal] = null;
-      const finalCallback = self.#final_callback;
-      if (finalCallback) {
-        self.#final_callback = null;
-        finalCallback();
-        return;
-      }
-      if (!self.#ended) {
-        const queue = self.#readQueue;
-        if (queue.isEmpty()) {
-          if (self.push(null)) return;
-        }
-        queue.push(null);
-      }
+      detachSocket(self);
+      Socket.#EmitEndNT(self, err);
+      self.data = null;
     }
 
     static #Drain(socket) {
       const self = socket.data;
       if (!self) return;
       const callback = self.#writeCallback;
+      self.connecting = false;
       if (callback) {
-        const chunk = self.#writeChunk;
-        const written = socket.write(chunk);
-
-        self.bytesWritten += written;
-        if (written < chunk.length) {
-          self.#writeChunk = chunk.slice(written);
-        } else {
-          self.#writeCallback = null;
-          self.#writeChunk = null;
+        const writeChunk = self._pendingData;
+        if (!writeChunk || socket.$write(writeChunk || "", self._pendingEncoding || "utf8")) {
+          self._pendingData = self.#writeCallback = null;
           callback(null);
+        } else {
+          self._pendingData = null;
         }
+
+        self[kBytesWritten] = socket.bytesWritten;
       }
     }
 
     static [bunSocketServerHandlers] = {
       data: Socket.#Handlers.data,
-      close(socket) {
-        Socket.#Handlers.close(socket);
-        this.data.server[bunSocketServerConnections]--;
-        this.data.server._emitCloseIfDrained();
+      close(socket, err) {
+        const data = this.data;
+        if (!data) return;
+        Socket.#Handlers.close(socket, err);
+        data.server[bunSocketServerConnections]--;
+        data.server._emitCloseIfDrained();
       },
       end(socket) {
         Socket.#Handlers.end(socket);
       },
       open(socket) {
         const self = this.data;
-        socket[kServerSocket] = self[bunSocketInternal];
+        socket[kServerSocket] = self._handle;
         const options = self[bunSocketServerOptions];
         const { pauseOnConnect, connectionListener, InternalSocketClass, requestCert, rejectUnauthorized } = options;
         const _socket = new InternalSocketClass({});
@@ -273,7 +315,7 @@ const Socket = (function (InternalSocket) {
         if (self.maxConnections && self[bunSocketServerConnections] >= self.maxConnections) {
           const data = {
             localAddress: _socket.localAddress,
-            localPort: _socket.localPort,
+            localPort: _socket.localPort || this.localPort,
             localFamily: _socket.localFamily,
             remoteAddress: _socket.remoteAddress,
             remotePort: _socket.remotePort,
@@ -291,13 +333,10 @@ const Socket = (function (InternalSocket) {
 
         self[bunSocketServerConnections]++;
 
-        if (typeof connectionListener == "function") {
+        if (typeof connectionListener === "function") {
           this.pauseOnConnect = pauseOnConnect;
-          if (isTLS) {
-            // add secureConnection event handler
-            self.once("secureConnection", () => connectionListener(_socket));
-          } else {
-            connectionListener(_socket);
+          if (!isTLS) {
+            connectionListener.$call(self, _socket);
           }
         }
         self.emit("connection", _socket);
@@ -314,6 +353,7 @@ const Socket = (function (InternalSocket) {
         self._secureEstablished = !!success;
         self.servername = socket.getServername();
         const server = self.server;
+        self.alpnProtocol = socket.alpnProtocol;
         if (self._requestCert || self._rejectUnauthorized) {
           if (verifyError) {
             self.authorized = false;
@@ -331,7 +371,11 @@ const Socket = (function (InternalSocket) {
         } else {
           self.authorized = true;
         }
-        self.server.emit("secureConnection", self);
+        const connectionListener = server[bunSocketServerOptions]?.connectionListener;
+        if (typeof connectionListener === "function") {
+          connectionListener.$call(server, self);
+        }
+        server.emit("secureConnection", self);
         // after secureConnection event we emmit secure and secureConnect
         self.emit("secure", self);
         self.emit("secureConnect", verifyError);
@@ -340,9 +384,11 @@ const Socket = (function (InternalSocket) {
         }
       },
       error(socket, error) {
+        const data = this.data;
+        if (!data) return;
         Socket.#Handlers.error(socket, error);
-        this.data.emit("error", error);
-        this.data.server.emit("clientError", error, this.data);
+        data.emit("error", error);
+        data.server.emit("clientError", error, data);
       },
       timeout: Socket.#Handlers.timeout,
       connectError: Socket.#Handlers.connectError,
@@ -351,23 +397,21 @@ const Socket = (function (InternalSocket) {
     };
 
     bytesRead = 0;
-    bytesWritten = 0;
+    [kBytesWritten] = undefined;
     #closed = false;
     #ended = false;
-    #final_callback = null;
     connecting = false;
     localAddress = "127.0.0.1";
-    #readQueue = $createFIFO();
     remotePort;
-    [bunSocketInternal] = null;
     [bunTLSConnectOptions] = null;
     timeout = 0;
     #writeCallback;
-    #writeChunk;
+    _pendingData;
+    _pendingEncoding; // for compatibility
     #pendingRead;
 
     isServer = false;
-    _handle;
+    _handle = null;
     _parent;
     _parentWrap;
     #socket;
@@ -376,20 +420,42 @@ const Socket = (function (InternalSocket) {
     #upgraded;
     #unrefOnConnected = false;
     #handlers = Socket.#Handlers;
-
+    [kSetNoDelay];
+    [kSetKeepAlive];
+    [kSetKeepAliveInitialDelay];
     constructor(options) {
-      const { socket, signal, write, read, allowHalfOpen = false, onread = null, ...opts } = options || {};
+      const {
+        socket,
+        signal,
+        write,
+        read,
+        allowHalfOpen = false,
+        onread = null,
+        noDelay = false,
+        keepAlive = false,
+        keepAliveInitialDelay = 0,
+        ...opts
+      } = options || {};
+
       super({
         ...opts,
         allowHalfOpen,
         readable: true,
         writable: true,
+        //For node.js compat do not emit close on destroy.
+        emitClose: false,
+        autoDestroy: true,
+        // Handle strings directly.
+        decodeStrings: false,
       });
-      this._handle = this;
       this._parent = this;
       this._parentWrap = this;
       this.#pendingRead = undefined;
       this.#upgraded = null;
+
+      this[kSetNoDelay] = Boolean(noDelay);
+      this[kSetKeepAlive] = Boolean(keepAlive);
+      this[kSetKeepAliveInitialDelay] = ~~(keepAliveInitialDelay / 1000);
       if (socket instanceof Socket) {
         this.#socket = socket;
       }
@@ -417,7 +483,6 @@ const Socket = (function (InternalSocket) {
       if (signal) {
         signal.addEventListener("abort", () => this.destroy());
       }
-      this.once("connect", () => this.emit("ready"));
     }
 
     address() {
@@ -432,24 +497,64 @@ const Socket = (function (InternalSocket) {
       return this.writableLength;
     }
 
+    get _bytesDispatched() {
+      return this[kBytesWritten] || 0;
+    }
+
+    get bytesWritten() {
+      let bytes = this[kBytesWritten] || 0;
+      const data = this._pendingData;
+      const writableBuffer = this.writableBuffer;
+      if (!writableBuffer) return undefined;
+
+      for (const el of writableBuffer) {
+        bytes += el.chunk instanceof Buffer ? el.chunk.length : Buffer.byteLength(el.chunk, el.encoding);
+      }
+
+      if ($isArray(data)) {
+        // Was a writev, iterate over chunks to get total length
+        for (let i = 0; i < data.length; i++) {
+          const chunk = data[i];
+
+          if (data.allBuffers || chunk instanceof Buffer) bytes += chunk.length;
+          else bytes += Buffer.byteLength(chunk.chunk, chunk.encoding);
+        }
+      } else if (data) {
+        bytes += data.byteLength;
+      }
+      return bytes;
+    }
+
     #attach(port, socket) {
       this.remotePort = port;
       socket.data = this;
       socket.timeout(Math.ceil(this.timeout / 1000));
       if (this.#unrefOnConnected) socket.unref();
-      this[bunSocketInternal] = socket;
+      this._handle = socket;
       this.connecting = false;
+
+      if (this[kSetNoDelay]) {
+        socket.setNoDelay(true);
+      }
+
+      if (this[kSetKeepAlive]) {
+        socket.setKeepAlive(true, self[kSetKeepAliveInitialDelay]);
+      }
+
       if (!this.#upgraded) {
+        this[kBytesWritten] = socket.bytesWritten;
         // this is not actually emitted on nodejs when socket used on the connection
         // this is already emmited on non-TLS socket and on TLS socket is emmited secureConnect after handshake
         this.emit("connect", this);
+        this.emit("ready");
       }
       Socket.#Drain(socket);
     }
 
     #closeRawConnection() {
       const connection = this.#upgraded;
-      connection[bunSocketInternal] = null;
+      connection.connecting = false;
+      connection._handle = null;
       connection.unref();
       connection.destroy();
     }
@@ -493,9 +598,12 @@ const Socket = (function (InternalSocket) {
           data: this,
           fd: fd,
           socket: this.#handlers,
+          allowHalfOpen: this.allowHalfOpen,
         }).catch(error => {
-          this.emit("error", error);
-          this.emit("close");
+          if (!this.destroyed) {
+            this.emit("error", error);
+            this.emit("close");
+          }
         });
       }
 
@@ -560,8 +668,14 @@ const Socket = (function (InternalSocket) {
 
       // start using existing connection
       try {
+        // reset the underlying writable object when establishing a new connection
+        // this is a function on `Duplex`, originally defined on `Writable`
+        // https://github.com/nodejs/node/blob/c5cfdd48497fe9bd8dbd55fd1fca84b321f48ec1/lib/net.js#L311
+        // https://github.com/nodejs/node/blob/c5cfdd48497fe9bd8dbd55fd1fca84b321f48ec1/lib/net.js#L1126
+        this._undestroy();
+
         if (connection) {
-          const socket = connection[bunSocketInternal];
+          const socket = connection._handle;
           if (!upgradeDuplex && socket) {
             // if is named pipe socket we can upgrade it using the same wrapper than we use for duplex
             upgradeDuplex = isNamedPipeSocket(socket);
@@ -580,7 +694,7 @@ const Socket = (function (InternalSocket) {
             connection.on("drain", events[2]);
             connection.on("close", events[3]);
 
-            this[bunSocketInternal] = result;
+            this._handle = result;
           } else {
             if (socket) {
               this.connecting = true;
@@ -593,18 +707,18 @@ const Socket = (function (InternalSocket) {
               if (result) {
                 const [raw, tls] = result;
                 // replace socket
-                connection[bunSocketInternal] = raw;
+                connection._handle = raw;
                 this.once("end", this.#closeRawConnection);
                 raw.connecting = false;
-                this[bunSocketInternal] = tls;
+                this._handle = tls;
               } else {
-                this[bunSocketInternal] = null;
+                this._handle = null;
                 throw new Error("Invalid socket");
               }
             } else {
               // wait to be connected
               connection.once("connect", () => {
-                const socket = connection[bunSocketInternal];
+                const socket = connection._handle;
                 if (!upgradeDuplex && socket) {
                   // if is named pipe socket we can upgrade it using the same wrapper than we use for duplex
                   upgradeDuplex = isNamedPipeSocket(socket);
@@ -624,7 +738,7 @@ const Socket = (function (InternalSocket) {
                   connection.on("drain", events[2]);
                   connection.on("close", events[3]);
 
-                  this[bunSocketInternal] = result;
+                  this._handle = result;
                 } else {
                   this.connecting = true;
                   this.#upgraded = connection;
@@ -637,12 +751,12 @@ const Socket = (function (InternalSocket) {
                   if (result) {
                     const [raw, tls] = result;
                     // replace socket
-                    connection[bunSocketInternal] = raw;
+                    connection._handle = raw;
                     this.once("end", this.#closeRawConnection);
                     raw.connecting = false;
-                    this[bunSocketInternal] = tls;
+                    this._handle = tls;
                   } else {
-                    this[bunSocketInternal] = null;
+                    this._handle = null;
                     throw new Error("Invalid socket");
                   }
                 }
@@ -656,9 +770,12 @@ const Socket = (function (InternalSocket) {
             unix: path,
             socket: this.#handlers,
             tls,
+            allowHalfOpen: this.allowHalfOpen,
           }).catch(error => {
-            this.emit("error", error);
-            this.emit("close");
+            if (!this.destroyed) {
+              this.emit("error", error);
+              this.emit("close");
+            }
           });
         } else {
           // default start
@@ -668,47 +785,59 @@ const Socket = (function (InternalSocket) {
             port: port,
             socket: this.#handlers,
             tls,
+            allowHalfOpen: this.allowHalfOpen,
           }).catch(error => {
-            this.emit("error", error);
-            this.emit("close");
+            if (!this.destroyed) {
+              this.emit("error", error);
+              this.emit("close");
+            }
           });
         }
       } catch (error) {
         process.nextTick(emitErrorAndCloseNextTick, this, error);
       }
-      // reset the underlying writable object when establishing a new connection
-      // this is a function on `Duplex`, originally defined on `Writable`
-      // https://github.com/nodejs/node/blob/c5cfdd48497fe9bd8dbd55fd1fca84b321f48ec1/lib/net.js#L311
-      // https://github.com/nodejs/node/blob/c5cfdd48497fe9bd8dbd55fd1fca84b321f48ec1/lib/net.js#L1126
-      this._undestroy();
       return this;
     }
 
-    _destroy(err, callback) {
-      const socket = this[bunSocketInternal];
-      if (socket) {
-        this[bunSocketInternal] = null;
-        // we still have a socket, call end before destroy
-        process.nextTick(endNT, socket, callback, err);
-        return;
+    end(...args) {
+      if (!this._readableState.endEmitted) {
+        this.secureConnecting = false;
       }
-      // no socket, just destroy
-      process.nextTick(closeNT, callback, err);
+      return super.end(...args);
+    }
+
+    _destroy(err, callback) {
+      this.connecting = false;
+      const { ending } = this._writableState;
+      if (!err && this.secureConnecting && !this.isServer) {
+        this.secureConnecting = false;
+        err = new ConnResetException("Client network socket disconnected before secure TLS connection was established");
+      }
+      // lets make sure that the writable side is closed
+      if (!ending) {
+        // at this state destroyed will be true but we need to close the writable side
+        this._writableState.destroyed = false;
+        this.end();
+        // we now restore the destroyed flag
+        this._writableState.destroyed = true;
+      }
+
+      detachSocket(self);
+      callback(err);
+      process.nextTick(emitCloseNT, this, !!err);
     }
 
     _final(callback) {
-      const socket = this[bunSocketInternal];
+      if (this.connecting) {
+        return this.once("connect", () => this._final(callback));
+      }
+      const socket = this._handle;
+
       // already closed call destroy
       if (!socket) return callback();
 
-      if (this.allowHalfOpen) {
-        // wait socket close event
-        this.#final_callback = callback;
-      } else {
-        // emit FIN not allowing half open
-        this[bunSocketInternal] = null;
-        process.nextTick(endNT, socket, callback);
-      }
+      // emit FIN allowHalfOpen only allow the readable side to close first
+      process.nextTick(endNT, socket, callback);
     }
 
     get localFamily() {
@@ -716,21 +845,41 @@ const Socket = (function (InternalSocket) {
     }
 
     get localPort() {
-      return this[bunSocketInternal]?.localPort;
+      return this._handle?.localPort;
     }
-
-    get pending() {
+    get _connecting() {
       return this.connecting;
     }
 
+    get pending() {
+      return !this._handle || this.connecting;
+    }
+
+    resume() {
+      if (!this.connecting) {
+        this._handle?.resume();
+      }
+      return super.resume();
+    }
+    pause() {
+      if (!this.destroyed) {
+        this._handle?.pause();
+      }
+      return super.pause();
+    }
+    read(size) {
+      if (!this.connecting) {
+        this._handle?.resume();
+      }
+      return super.read(size);
+    }
+
     _read(size) {
-      const queue = this.#readQueue;
-      let chunk;
-      while ((chunk = queue.peek())) {
-        const can_continue = !this.push(chunk);
-        // always remove from queue push will queue it internally if needed
-        queue.shift();
-        if (!can_continue) break;
+      const socket = this._handle;
+      if (this.connecting || !socket) {
+        this.once("connect", () => this._read(size));
+      } else {
+        socket?.resume();
       }
     }
 
@@ -744,7 +893,7 @@ const Socket = (function (InternalSocket) {
     }
 
     ref() {
-      const socket = this[bunSocketInternal];
+      const socket = this._handle;
       if (!socket) {
         this.#unrefOnConnected = false;
         return this;
@@ -754,7 +903,7 @@ const Socket = (function (InternalSocket) {
     }
 
     get remoteAddress() {
-      return this[bunSocketInternal]?.remoteAddress;
+      return this._handle?.remoteAddress;
     }
 
     get remoteFamily() {
@@ -762,30 +911,68 @@ const Socket = (function (InternalSocket) {
     }
 
     resetAndDestroy() {
-      this[bunSocketInternal]?.end();
+      if (this._handle) {
+        if (this.connecting) {
+          this.once("connect", () => this._handle?.terminate());
+        } else {
+          this._handle.terminate();
+        }
+      } else {
+        this.destroy($ERR_SOCKET_CLOSED_BEFORE_CONNECTION("ERR_SOCKET_CLOSED_BEFORE_CONNECTION"));
+      }
     }
 
-    setKeepAlive(enable = false, initialDelay = 0) {
-      // TODO
+    setKeepAlive(enable = false, initialDelayMsecs = 0) {
+      enable = Boolean(enable);
+      const initialDelay = ~~(initialDelayMsecs / 1000);
+
+      if (!this._handle) {
+        this[kSetKeepAlive] = enable;
+        this[kSetKeepAliveInitialDelay] = initialDelay;
+        return this;
+      }
+
+      if (!this._handle.setKeepAlive) {
+        return this;
+      }
+
+      if (enable !== this[kSetKeepAlive] || (enable && this[kSetKeepAliveInitialDelay] !== initialDelay)) {
+        this[kSetKeepAlive] = enable;
+        this[kSetKeepAliveInitialDelay] = initialDelay;
+        this._handle.setKeepAlive(enable, initialDelay);
+      }
+
       return this;
     }
 
-    setNoDelay(noDelay = true) {
-      // TODO
+    setNoDelay(enable = true) {
+      // Backwards compatibility: assume true when `enable` is omitted
+      enable = Boolean(enable === undefined ? true : enable);
+
+      if (!this._handle) {
+        this[kSetNoDelay] = enable;
+        return this;
+      }
+
+      if (this._handle.setNoDelay && enable !== this[kSetNoDelay]) {
+        this[kSetNoDelay] = enable;
+        this._handle.setNoDelay(enable);
+      }
       return this;
     }
 
     setTimeout(timeout, callback) {
       // internally or timeouts are in seconds
       // we use Math.ceil because 0 would disable the timeout and less than 1 second but greater than 1ms would be 1 second (the minimum)
-      this[bunSocketInternal]?.timeout(Math.ceil(timeout / 1000));
+      this._handle?.timeout(Math.ceil(timeout / 1000));
       this.timeout = timeout;
       if (callback) this.once("timeout", callback);
       return this;
     }
-
+    // for compatibility
+    _unrefTimer() {}
     unref() {
-      const socket = this[bunSocketInternal];
+      const socket = this._handle;
       if (!socket) {
         this.#unrefOnConnected = true;
         return this;
@@ -802,24 +989,69 @@ const Socket = (function (InternalSocket) {
       else this.once("finish", this.destroy);
     }
 
+    //TODO: migrate to native
+    _writev(data, callback) {
+      const allBuffers = data.allBuffers;
+      const chunks = data;
+      if (allBuffers) {
+        if (data.length === 1) {
+          return this._write(data[0], "buffer", callback);
+        }
+        for (let i = 0; i < data.length; i++) {
+          data[i] = data[i].chunk;
+        }
+      } else {
+        if (data.length === 1) {
+          const { chunk, encoding } = data[0];
+          return this._write(chunk, encoding, callback);
+        }
+        for (let i = 0; i < data.length; i++) {
+          const { chunk, encoding } = data[i];
+          if (typeof chunk === "string") {
+            data[i] = Buffer.from(chunk, encoding);
+          } else {
+            data[i] = chunk;
+          }
+        }
+      }
+      const chunk = Buffer.concat(chunks || []);
+      return this._write(chunk, "buffer", callback);
+    }
+
     _write(chunk, encoding, callback) {
-      if (typeof chunk == "string" && encoding !== "ascii") chunk = Buffer.from(chunk, encoding);
-      var written = this[bunSocketInternal]?.write(chunk);
-      if (written == chunk.length) {
+      // If we are still connecting, then buffer this for later.
+      // The Writable logic will buffer up any more writes while
+      // waiting for this one to be done.
+      if (this.connecting) {
+        this.#writeCallback = callback;
+        this._pendingData = chunk;
+        this._pendingEncoding = encoding;
+        function onClose() {
+          callback($ERR_SOCKET_CLOSED_BEFORE_CONNECTION("ERR_SOCKET_CLOSED_BEFORE_CONNECTION"));
+        }
+        this.once("connect", function connect() {
+          this.off("close", onClose);
+        });
+        this.once("close", onClose);
+        return;
+      }
+      this._pendingData = null;
+      this._pendingEncoding = "";
+      this.#writeCallback = null;
+      const socket = this._handle;
+      if (!socket) {
+        callback($ERR_SOCKET_CLOSED("Socket is closed"));
+        return false;
+      }
+
+      const success = socket.$write(chunk, encoding);
+      this[kBytesWritten] = socket.bytesWritten;
+      if (success) {
         callback();
       } else if (this.#writeCallback) {
         callback(new Error("overlapping _write()"));
       } else {
-        if (written > 0) {
-          if (typeof chunk == "string") {
-            chunk = chunk.slice(written);
-          } else {
-            chunk = chunk.subarray(written);
-          }
-        }
-
         this.#writeCallback = callback;
-        this.#writeChunk = chunk;
       }
     }
   },
@@ -837,10 +1069,10 @@ function createConnection(port, host, connectListener) {
 const connect = createConnection;
 
 class Server extends EventEmitter {
-  [bunSocketInternal] = null;
   [bunSocketServerConnections] = 0;
   [bunSocketServerOptions];
   maxConnections = 0;
+  _handle = null;
 
   constructor(options, connectionListener) {
     super();
@@ -853,7 +1085,6 @@ class Server extends EventEmitter {
     } else {
       throw new Error("bun-net-polyfill: invalid arguments");
     }
-
     const { maxConnections } = options;
     this.maxConnections = Number.isSafeInteger(maxConnections) && maxConnections > 0 ? maxConnections : 0;
 
@@ -862,33 +1093,33 @@ class Server extends EventEmitter {
   }
 
   get listening() {
-    return !!this[bunSocketInternal];
+    return !!this._handle;
   }
 
   ref() {
-    this[bunSocketInternal]?.ref();
+    this._handle?.ref();
     return this;
   }
 
   unref() {
-    this[bunSocketInternal]?.unref();
+    this._handle?.unref();
     return this;
   }
 
   close(callback) {
     if (typeof callback === "function") {
-      if (!this[bunSocketInternal]) {
+      if (!this._handle) {
         this.once("close", function close() {
-          callback(new ERR_SERVER_NOT_RUNNING());
+          callback(ERR_SERVER_NOT_RUNNING());
         });
       } else {
         this.once("close", callback);
       }
     }
 
-    if (this[bunSocketInternal]) {
-      this[bunSocketInternal].stop(false);
-      this[bunSocketInternal] = null;
+    if (this._handle) {
+      this._handle.stop(false);
+      this._handle = null;
     }
 
     this._emitCloseIfDrained();
@@ -906,7 +1137,7 @@ class Server extends EventEmitter {
   }
 
   _emitCloseIfDrained() {
-    if (this[bunSocketInternal] || this[bunSocketServerConnections] > 0) {
+    if (this._handle || this[bunSocketServerConnections] > 0) {
       return;
     }
     process.nextTick(() => {
@@ -915,7 +1146,7 @@ class Server extends EventEmitter {
   }
 
   address() {
-    const server = this[bunSocketInternal];
+    const server = this._handle;
     if (server) {
       const unix = server.unix;
       if (unix) {
@@ -950,7 +1181,7 @@ class Server extends EventEmitter {
       //in Bun case we will never error on getConnections
       //node only errors if in the middle of the couting the server got disconnected, what never happens in Bun
       //if disconnected will only pass null as well and 0 connected
-      callback(null, this[bunSocketInternal] ? this[bunSocketServerConnections] : 0);
+      callback(null, this._handle ? this[bunSocketServerConnections] : 0);
     }
     return this;
   }
@@ -959,6 +1190,9 @@ class Server extends EventEmitter {
     let backlog;
     let path;
     let exclusive = false;
+    let allowHalfOpen = false;
+    let reusePort = false;
+    let ipv6Only = false;
     //port is actually path
     if (typeof port === "string") {
       if (Number.isSafeInteger(hostname)) {
@@ -988,12 +1222,26 @@ class Server extends EventEmitter {
         options.signal?.addEventListener("abort", () => this.close());
 
         hostname = options.host;
-        exclusive = options.exclusive === true;
-        const path = options.path;
+        exclusive = options.exclusive;
+        path = options.path;
         port = options.port;
+        ipv6Only = options.ipv6Only;
+        allowHalfOpen = options.allowHalfOpen;
+        reusePort = options.reusePort;
+
+        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 {
@@ -1020,7 +1268,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;
       }
@@ -1053,6 +1301,9 @@ class Server extends EventEmitter {
         backlog,
         undefined,
         exclusive,
+        ipv6Only,
+        allowHalfOpen,
+        reusePort,
         undefined,
         undefined,
         path,
@@ -1067,29 +1318,37 @@ class Server extends EventEmitter {
     return this;
   }
 
-  [kRealListen](path, port, hostname, exclusive, tls, contexts, onListen) {
+  [kRealListen](path, port, hostname, exclusive, ipv6Only, allowHalfOpen, reusePort, tls, contexts, onListen) {
     if (path) {
-      this[bunSocketInternal] = Bun.listen({
+      this._handle = Bun.listen({
         unix: path,
         tls,
+        allowHalfOpen: allowHalfOpen || this[bunSocketServerOptions]?.allowHalfOpen || false,
+        reusePort: reusePort || this[bunSocketServerOptions]?.reusePort || false,
+        ipv6Only: ipv6Only || this[bunSocketServerOptions]?.ipv6Only || false,
+        exclusive: exclusive || this[bunSocketServerOptions]?.exclusive || false,
         socket: SocketClass[bunSocketServerHandlers],
       });
     } else {
-      this[bunSocketInternal] = Bun.listen({
+      this._handle = Bun.listen({
         exclusive,
         port,
         hostname,
         tls,
+        allowHalfOpen: allowHalfOpen || this[bunSocketServerOptions]?.allowHalfOpen || false,
+        reusePort: reusePort || this[bunSocketServerOptions]?.reusePort || false,
+        ipv6Only: ipv6Only || this[bunSocketServerOptions]?.ipv6Only || false,
+        exclusive: exclusive || this[bunSocketServerOptions]?.exclusive || false,
         socket: SocketClass[bunSocketServerHandlers],
       });
     }
 
     //make this instance available on handlers
-    this[bunSocketInternal].data = this;
+    this._handle.data = this;
 
     if (contexts) {
       for (const [name, context] of contexts) {
-        addServerName(this[bunSocketInternal], name, context);
+        addServerName(this._handle, name, context);
       }
     }
 
@@ -1103,13 +1362,6 @@ class Server extends EventEmitter {
     setTimeout(emitListeningNextTick, 1, this, onListen?.bind(this));
   }
 
-  get _handle() {
-    return this;
-  }
-  set _handle(new_handle) {
-    //nothing
-  }
-
   getsockname(out) {
     out.port = this.address().port;
     return out;
@@ -1124,6 +1376,16 @@ function emitErrorAndCloseNextTick(self, error) {
   self.emit("error", error);
   self.emit("close");
 }
+class ConnResetException extends Error {
+  constructor(msg) {
+    super(msg);
+    this.code = "ECONNRESET";
+  }
+
+  get ["constructor"]() {
+    return Error;
+  }
+}
 
 function emitListeningNextTick(self, onListen) {
   if (typeof onListen === "function") {
@@ -1145,6 +1407,9 @@ function listenInCluster(
   backlog,
   fd,
   exclusive,
+  ipv6Only,
+  allowHalfOpen,
+  reusePort,
   flags,
   options,
   path,
@@ -1158,7 +1423,7 @@ function listenInCluster(
   if (cluster === undefined) cluster = require("node:cluster");
 
   if (cluster.isPrimary || exclusive) {
-    server[kRealListen](path, port, hostname, exclusive, tls, contexts, onListen);
+    server[kRealListen](path, port, hostname, exclusive, ipv6Only, allowHalfOpen, reusePort, tls, contexts, onListen);
     return;
   }
 
@@ -1176,7 +1441,7 @@ function listenInCluster(
     if (err) {
       throw new ExceptionWithHostPort(err, "bind", address, port);
     }
-    server[kRealListen](path, port, hostname, exclusive, tls, contexts, onListen);
+    server[kRealListen](path, port, hostname, exclusive, ipv6Only, allowHalfOpen, reusePort, tls, contexts, onListen);
   });
 }
 
diff --git a/src/js/node/os.ts b/src/js/node/os.ts
index 87682a72a4..f962ed31e2 100644
--- a/src/js/node/os.ts
+++ b/src/js/node/os.ts
@@ -87,31 +87,40 @@ function lazyCpus({ cpus }) {
 // all logic based on `process.platform` and `process.arch` is inlined at bundle time
 function bound(obj) {
   return {
-    availableParallelism: () => navigator.hardwareConcurrency,
-    arch: () => process.arch,
+    availableParallelism: function () {
+      return navigator.hardwareConcurrency;
+    },
+    arch: function () {
+      return process.arch;
+    },
     cpus: lazyCpus(obj),
-    endianness: () => (process.arch === "arm64" || process.arch === "x64" ? "LE" : $bundleError("TODO: endianness")),
+    endianness: function () {
+      return process.arch === "arm64" || process.arch === "x64" ? "LE" : $bundleError("TODO: endianness");
+    },
     freemem: obj.freemem.bind(obj),
     getPriority: obj.getPriority.bind(obj),
     homedir: obj.homedir.bind(obj),
     hostname: obj.hostname.bind(obj),
     loadavg: obj.loadavg.bind(obj),
     networkInterfaces: obj.networkInterfaces.bind(obj),
-    platform: () => process.platform,
+    platform: function () {
+      return process.platform;
+    },
     release: obj.release.bind(obj),
     setPriority: obj.setPriority.bind(obj),
     get tmpdir() {
       return tmpdir;
     },
     totalmem: obj.totalmem.bind(obj),
-    type: () =>
-      process.platform === "win32"
+    type: function () {
+      return process.platform === "win32"
         ? "Windows_NT"
         : process.platform === "darwin"
           ? "Darwin"
           : process.platform === "linux"
             ? "Linux"
-            : $bundleError("TODO: type"),
+            : $bundleError("TODO: type");
+    },
     uptime: obj.uptime.bind(obj),
     userInfo: obj.userInfo.bind(obj),
     version: obj.version.bind(obj),
diff --git a/src/js/node/readline.ts b/src/js/node/readline.ts
index 0c9ae8b2d0..9db2708f43 100644
--- a/src/js/node/readline.ts
+++ b/src/js/node/readline.ts
@@ -27,7 +27,19 @@
 // ----------------------------------------------------------------------------
 const EventEmitter = require("node:events");
 const { StringDecoder } = require("node:string_decoder");
+
+const {
+  validateFunction,
+  validateAbortSignal,
+  validateArray,
+  validateString,
+  validateBoolean,
+  validateInteger,
+  validateUint32,
+} = require("internal/validators");
+
 const internalGetStringWidth = $newZigFunction("string.zig", "String.jsGetStringWidth", 1);
+
 const ObjectGetPrototypeOf = Object.getPrototypeOf;
 const ObjectGetOwnPropertyDescriptors = Object.getOwnPropertyDescriptors;
 const ObjectValues = Object.values;
@@ -298,129 +310,6 @@ class AbortError extends Error {
   }
 }
 
-// Validators
-
-/**
- * @callback validateFunction
- * @param {*} value
- * @param {string} name
- * @returns {asserts value is Function}
- */
-function validateFunction(value, name) {
-  if (typeof value !== "function") throw $ERR_INVALID_ARG_TYPE(name, "Function", value);
-}
-
-/**
- * @callback validateAbortSignal
- * @param {*} signal
- * @param {string} name
- */
-function validateAbortSignal(signal, name) {
-  if (signal !== undefined && (signal === null || typeof signal !== "object" || !("aborted" in signal))) {
-    throw $ERR_INVALID_ARG_TYPE(name, "AbortSignal", signal);
-  }
-}
-
-/**
- * @callback validateArray
- * @param {*} value
- * @param {string} name
- * @param {number} [minLength]
- * @returns {asserts value is any[]}
- */
-function validateArray(value, name, minLength = 0) {
-  // var validateArray = hideStackFrames((value, name, minLength = 0) => {
-  if (!$isJSArray(value)) {
-    throw $ERR_INVALID_ARG_TYPE(name, "Array", value);
-  }
-  if (value.length < minLength) {
-    var reason = `must be longer than ${minLength}`;
-    throw new ERR_INVALID_ARG_VALUE(name, value, reason);
-  }
-}
-
-/**
- * @callback validateString
- * @param {*} value
- * @param {string} name
- * @returns {asserts value is string}
- */
-function validateString(value, name) {
-  if (typeof value !== "string") throw $ERR_INVALID_ARG_TYPE(name, "string", value);
-}
-
-/**
- * @callback validateBoolean
- * @param {*} value
- * @param {string} name
- * @returns {asserts value is boolean}
- */
-function validateBoolean(value, name) {
-  if (typeof value !== "boolean") throw $ERR_INVALID_ARG_TYPE(name, "boolean", value);
-}
-
-/**
- * @callback validateObject
- * @param {*} value
- * @param {string} name
- * @param {{
- *   allowArray?: boolean,
- *   allowFunction?: boolean,
- *   nullable?: boolean
- * }} [options]
- */
-function validateObject(value, name, options = null) {
-  // var validateObject = hideStackFrames((value, name, options = null) => {
-  var allowArray = options?.allowArray ?? false;
-  var allowFunction = options?.allowFunction ?? false;
-  var nullable = options?.nullable ?? false;
-  if (
-    (!nullable && value === null) ||
-    (!allowArray && $isJSArray.$call(null, value)) ||
-    (typeof value !== "object" && (!allowFunction || typeof value !== "function"))
-  ) {
-    throw $ERR_INVALID_ARG_TYPE(name, "object", value);
-  }
-}
-
-/**
- * @callback validateInteger
- * @param {*} value
- * @param {string} name
- * @param {number} [min]
- * @param {number} [max]
- * @returns {asserts value is number}
- */
-function validateInteger(value, name, min = NumberMIN_SAFE_INTEGER, max = NumberMAX_SAFE_INTEGER) {
-  if (typeof value !== "number") throw $ERR_INVALID_ARG_TYPE(name, "number", value);
-  if (!NumberIsInteger(value)) throw new ERR_OUT_OF_RANGE(name, "an integer", value);
-  if (value < min || value > max) throw new ERR_OUT_OF_RANGE(name, `>= ${min} && <= ${max}`, value);
-}
-
-/**
- * @callback validateUint32
- * @param {*} value
- * @param {string} name
- * @param {number|boolean} [positive=false]
- * @returns {asserts value is number}
- */
-function validateUint32(value, name, positive = false) {
-  if (typeof value !== "number") {
-    throw $ERR_INVALID_ARG_TYPE(name, "number", value);
-  }
-
-  if (!NumberIsInteger(value)) {
-    throw new ERR_OUT_OF_RANGE(name, "an integer", value);
-  }
-
-  var min = positive ? 1 : 0; // 2 ** 32 === 4294967296
-  var max = 4_294_967_295;
-
-  if (value < min || value > max) {
-    throw new ERR_OUT_OF_RANGE(name, `>= ${min} && <= ${max}`, value);
-  }
-}
-
 // ----------------------------------------------------------------------------
 // Section: Utils
 // ----------------------------------------------------------------------------
diff --git a/src/js/node/stream.ts b/src/js/node/stream.ts
index ec669f047c..874031f49e 100644
--- a/src/js/node/stream.ts
+++ b/src/js/node/stream.ts
@@ -29,6 +29,23 @@ const kPaused = Symbol("kPaused");
 const StringDecoder = require("node:string_decoder").StringDecoder;
 const transferToNativeReadable = $newCppFunction("ReadableStream.cpp", "jsFunctionTransferToNativeReadableStream", 1);
 const { kAutoDestroyed } = require("internal/shared");
+const {
+  validateBoolean,
+  validateString,
+  validateNumber,
+  validateSignalName,
+  validateEncoding,
+  validatePort,
+  validateInteger,
+  validateInt32,
+  validateUint32,
+  validateArray,
+  validateBuffer,
+  validateAbortSignal,
+  validateFunction,
+  validatePlainFunction,
+  validateUndefined,
+} = require("internal/validators");
 
 const ObjectSetPrototypeOf = Object.setPrototypeOf;
 
@@ -47,49 +64,8 @@ function isReadableStream(value) {
   return typeof value === "object" && value !== null && value instanceof ReadableStream;
 }
 
-function validateBoolean(value, name) {
-  if (typeof value !== "boolean") throw ERR_INVALID_ARG_TYPE(name, "boolean", value);
-}
-
 $debug("node:stream loaded");
 
-/**
- * @callback validateObject
- * @param {*} value
- * @param {string} name
- * @param {{
- *   allowArray?: boolean,
- *   allowFunction?: boolean,
- *   nullable?: boolean
- * }} [options]
- */
-
-/** @type {validateObject} */
-const validateObject = (value, name, options = null) => {
-  const allowArray = options?.allowArray ?? false;
-  const allowFunction = options?.allowFunction ?? false;
-  const nullable = options?.nullable ?? false;
-  if (
-    (!nullable && value === null) ||
-    (!allowArray && $isJSArray(value)) ||
-    (typeof value !== "object" && (!allowFunction || typeof value !== "function"))
-  ) {
-    throw ERR_INVALID_ARG_TYPE(name, "Object", value);
-  }
-};
-
-/**
- * @callback validateString
- * @param {*} value
- * @param {string} name
- * @returns {asserts value is string}
- */
-
-/** @type {validateString} */
-function validateString(value, name) {
-  if (typeof value !== "string") throw ERR_INVALID_ARG_TYPE(name, "string", value);
-}
-
 //------------------------------------------------------------------------------
 // Node error polyfills
 //------------------------------------------------------------------------------
@@ -641,14 +617,9 @@ var require_validators = __commonJS({
       ArrayPrototypeIncludes,
       ArrayPrototypeJoin,
       ArrayPrototypeMap,
-      NumberIsInteger,
-      NumberMAX_SAFE_INTEGER,
-      NumberMIN_SAFE_INTEGER,
       NumberParseInt,
       RegExpPrototypeTest,
       String: String2,
-      StringPrototypeToUpperCase,
-      StringPrototypeTrim,
     } = require_primordials();
     var {
       hideStackFrames,
@@ -678,46 +649,6 @@ var require_validators = __commonJS({
       validateInt32(value, name, 0, 2 ** 32 - 1);
       return value;
     }
-    var validateInteger = hideStackFrames((value, name, min = NumberMIN_SAFE_INTEGER, max = NumberMAX_SAFE_INTEGER) => {
-      if (typeof value !== "number") throw new ERR_INVALID_ARG_TYPE(name, "number", value);
-      if (!NumberIsInteger(value)) throw new ERR_OUT_OF_RANGE(name, "an integer", value);
-      if (value < min || value > max) throw new ERR_OUT_OF_RANGE(name, `>= ${min} && <= ${max}`, value);
-    });
-    var validateInt32 = hideStackFrames((value, name, min = -2147483648, max = 2147483647) => {
-      if (typeof value !== "number") {
-        throw new ERR_INVALID_ARG_TYPE(name, "number", value);
-      }
-      if (!isInt32(value)) {
-        if (!NumberIsInteger(value)) {
-          throw new ERR_OUT_OF_RANGE(name, "an integer", value);
-        }
-        throw new ERR_OUT_OF_RANGE(name, `>= ${min} && <= ${max}`, value);
-      }
-      if (value < min || value > max) {
-        throw new ERR_OUT_OF_RANGE(name, `>= ${min} && <= ${max}`, value);
-      }
-    });
-    var validateUint32 = hideStackFrames((value, name, positive) => {
-      if (typeof value !== "number") {
-        throw new ERR_INVALID_ARG_TYPE(name, "number", value);
-      }
-      if (!isUint32(value)) {
-        if (!NumberIsInteger(value)) {
-          throw new ERR_OUT_OF_RANGE(name, "an integer", value);
-        }
-        const min = positive ? 1 : 0;
-        throw new ERR_OUT_OF_RANGE(name, `>= ${min} && < 4294967296`, value);
-      }
-      if (positive && value === 0) {
-        throw new ERR_OUT_OF_RANGE(name, ">= 1 && < 4294967296", value);
-      }
-    });
-    function validateString(value, name) {
-      if (typeof value !== "string") throw new ERR_INVALID_ARG_TYPE(name, "string", value);
-    }
-    function validateNumber(value, name) {
-      if (typeof value !== "number") throw new ERR_INVALID_ARG_TYPE(name, "number", value);
-    }
     var validateOneOf = hideStackFrames((value, name, oneOf) => {
       if (!ArrayPrototypeIncludes(oneOf, value)) {
         const allowed = ArrayPrototypeJoin(
@@ -728,9 +659,6 @@ var require_validators = __commonJS({
         throw new ERR_INVALID_ARG_VALUE(name, value, reason);
       }
     });
-    function validateBoolean(value, name) {
-      if (typeof value !== "boolean") throw new ERR_INVALID_ARG_TYPE(name, "boolean", value);
-    }
     var validateObject = hideStackFrames((value, name, options) => {
       const useDefaultOptions = options == null;
       const allowArray = useDefaultOptions ? false : options.allowArray;
@@ -744,84 +672,12 @@ var require_validators = __commonJS({
         throw new ERR_INVALID_ARG_TYPE(name, "Object", value);
       }
     });
-    var validateArray = hideStackFrames((value, name, minLength = 0) => {
-      if (!$isJSArray(value)) {
-        throw new ERR_INVALID_ARG_TYPE(name, "Array", value);
-      }
-      if (value.length < minLength) {
-        const reason = `must be longer than ${minLength}`;
-        throw new ERR_INVALID_ARG_VALUE(name, value, reason);
-      }
-    });
-    function validateSignalName(signal, name = "signal") {
-      validateString(signal, name);
-      if (signals[signal] === void 0) {
-        if (signals[StringPrototypeToUpperCase(signal)] !== void 0) {
-          throw new ERR_UNKNOWN_SIGNAL(signal + " (signals must use all capital letters)");
-        }
-        throw new ERR_UNKNOWN_SIGNAL(signal);
-      }
-    }
-    var validateBuffer = hideStackFrames((buffer, name = "buffer") => {
-      if (!isArrayBufferView(buffer)) {
-        throw new ERR_INVALID_ARG_TYPE(name, ["Buffer", "TypedArray", "DataView"], buffer);
-      }
-    });
-    function validateEncoding(data, encoding) {
-      const normalizedEncoding = normalizeEncoding(encoding);
-      const length = data.length;
-      if (normalizedEncoding === "hex" && length % 2 !== 0) {
-        throw new ERR_INVALID_ARG_VALUE("encoding", encoding, `is invalid for data of length ${length}`);
-      }
-    }
-    function validatePort(port, name = "Port", allowZero = true) {
-      if (
-        (typeof port !== "number" && typeof port !== "string") ||
-        (typeof port === "string" && StringPrototypeTrim(port).length === 0) ||
-        +port !== +port >>> 0 ||
-        port > 65535 ||
-        (port === 0 && !allowZero)
-      ) {
-        throw new ERR_SOCKET_BAD_PORT(name, port, allowZero);
-      }
-      return port | 0;
-    }
-    var validateAbortSignal = hideStackFrames((signal, name) => {
-      if (signal !== void 0 && (signal === null || typeof signal !== "object" || !("aborted" in signal))) {
-        throw new ERR_INVALID_ARG_TYPE(name, "AbortSignal", signal);
-      }
-    });
-    var validateFunction = hideStackFrames((value, name) => {
-      if (typeof value !== "function") throw new ERR_INVALID_ARG_TYPE(name, "Function", value);
-    });
-    var validatePlainFunction = hideStackFrames((value, name) => {
-      if (typeof value !== "function" || isAsyncFunction(value))
-        throw new ERR_INVALID_ARG_TYPE(name, "Function", value);
-    });
-    var validateUndefined = hideStackFrames((value, name) => {
-      if (value !== void 0) throw new ERR_INVALID_ARG_TYPE(name, "undefined", value);
-    });
     module.exports = {
       isInt32,
       isUint32,
       parseFileMode,
-      validateArray,
-      validateBoolean,
-      validateBuffer,
-      validateEncoding,
-      validateFunction,
-      validateInt32,
-      validateInteger,
-      validateNumber,
       validateObject,
       validateOneOf,
-      validatePlainFunction,
-      validatePort,
-      validateSignalName,
-      validateString,
-      validateUint32,
-      validateUndefined,
-      validateAbortSignal,
     };
   },
 });
@@ -1119,7 +975,7 @@ var require_end_of_stream = __commonJS({
     var { AbortError, codes } = require_errors();
     var { ERR_INVALID_ARG_TYPE, ERR_STREAM_PREMATURE_CLOSE } = codes;
     var { once } = require_util();
-    var { validateAbortSignal, validateFunction, validateObject } = require_validators();
+    var { validateObject } = require_validators();
     var { Promise: Promise2 } = require_primordials();
     var {
       isClosed,
@@ -1329,7 +1185,7 @@ var require_operators = __commonJS({
       codes: { ERR_INVALID_ARG_TYPE, ERR_MISSING_ARGS, ERR_OUT_OF_RANGE },
       AbortError,
     } = require_errors();
-    var { validateAbortSignal, validateInteger, validateObject } = require_validators();
+    var { validateObject } = require_validators();
     var kWeakHandler = require_primordials().Symbol("kWeak");
     var { finished } = require_end_of_stream();
     var {
@@ -2104,11 +1960,6 @@ var require_add_abort_signal = __commonJS({
     var { AbortError, codes } = require_errors();
     var eos = require_end_of_stream();
     var { ERR_INVALID_ARG_TYPE } = codes;
-    var validateAbortSignal = (signal, name) => {
-      if (typeof signal !== "object" || !("aborted" in signal)) {
-        throw new ERR_INVALID_ARG_TYPE(name, "AbortSignal", signal);
-      }
-    };
     function isNodeStream(obj) {
       return !!(obj && typeof obj.pipe === "function");
     }
@@ -2265,50 +2116,6 @@ var require_from = __commonJS({
   },
 });
 
-var require_state = __commonJS({
-  "node_modules/readable-stream/lib/internal/streams/state.js"(exports, module) {
-    "use strict";
-
-    const { MathFloor, NumberIsInteger } = require_primordials();
-    const { validateInteger } = require_validators();
-    const { ERR_INVALID_ARG_VALUE } = require_errors().codes;
-    let defaultHighWaterMarkBytes = 16 * 1024;
-    let defaultHighWaterMarkObjectMode = 16;
-    function highWaterMarkFrom(options, isDuplex, duplexKey) {
-      return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;
-    }
-    function getDefaultHighWaterMark(objectMode) {
-      return objectMode ? defaultHighWaterMarkObjectMode : defaultHighWaterMarkBytes;
-    }
-    function setDefaultHighWaterMark(objectMode, value) {
-      validateInteger(value, "value", 0);
-      if (objectMode) {
-        defaultHighWaterMarkObjectMode = value;
-      } else {
-        defaultHighWaterMarkBytes = value;
-      }
-    }
-    function getHighWaterMark(state, options, duplexKey, isDuplex) {
-      const hwm = highWaterMarkFrom(options, isDuplex, duplexKey);
-      if (hwm != null) {
-        if (!NumberIsInteger(hwm) || hwm < 0) {
-          const name = isDuplex ? `options.${duplexKey}` : "options.highWaterMark";
-          throw new ERR_INVALID_ARG_VALUE(name, hwm);
-        }
-        return MathFloor(hwm);
-      }
-
-      // Default value
-      return getDefaultHighWaterMark(state.objectMode);
-    }
-    module.exports = {
-      getHighWaterMark,
-      getDefaultHighWaterMark,
-      setDefaultHighWaterMark,
-    };
-  },
-});
-
 var _ReadableFromWeb;
 var _ReadableFromWebForUndici;
 
@@ -2336,8 +2143,6 @@ var require_readable = __commonJS({
 
     const BufferList = $cpp("JSBufferList.cpp", "getBufferList");
 
-    const { getHighWaterMark, getDefaultHighWaterMark } = require_state();
-
     const { AbortError } = require_errors();
 
     // TODO(benjamingr) it is likely slower to do it this way than with free functions
@@ -4152,7 +3957,7 @@ var require_writable = __commonJS({
       }
       return this;
     };
-    function needFinish(state, tag) {
+    function needFinish(state, tag?) {
       var needFinish =
         state.ending &&
         !state.destroyed &&
@@ -4955,7 +4760,6 @@ var require_pipeline = __commonJS({
       codes: { ERR_INVALID_ARG_TYPE, ERR_INVALID_RETURN_VALUE, ERR_MISSING_ARGS, ERR_STREAM_DESTROYED },
       AbortError,
     } = require_errors();
-    var { validateFunction, validateAbortSignal } = require_validators();
     var { isIterable, isReadable, isReadableNodeStream, isNodeStream } = require_utils();
     var PassThrough;
     function destroyer(stream, reading, writing) {
@@ -5637,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);
@@ -5853,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.promises.ts b/src/js/node/timers.promises.ts
index e9b8a290af..68ac1fa3f6 100644
--- a/src/js/node/timers.promises.ts
+++ b/src/js/node/timers.promises.ts
@@ -1,5 +1,8 @@
 // Hardcoded module "node:timers/promises"
 // https://github.com/niksy/isomorphic-timers-promises/blob/master/index.js
+
+const { validateBoolean, validateAbortSignal } = require("internal/validators");
+
 const symbolAsyncIterator = Symbol.asyncIterator;
 
 class ERR_INVALID_ARG_TYPE extends Error {
@@ -22,18 +25,6 @@ function validateObject(object, name) {
   }
 }
 
-function validateBoolean(value, name) {
-  if (typeof value !== "boolean") {
-    throw new ERR_INVALID_ARG_TYPE(name, "boolean", value);
-  }
-}
-
-function validateAbortSignal(signal, name) {
-  if (typeof signal !== "undefined" && (signal === null || typeof signal !== "object" || !("aborted" in signal))) {
-    throw new ERR_INVALID_ARG_TYPE(name, "AbortSignal", signal);
-  }
-}
-
 function asyncIterator({ next: nextFunction, return: returnFunction }) {
   const result = {};
   if (typeof nextFunction === "function") {
diff --git a/src/js/node/timers.ts b/src/js/node/timers.ts
index 91f8eb1609..9edcdc89c7 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/node/tls.ts b/src/js/node/tls.ts
index 1df7d858cf..46d0fa1113 100644
--- a/src/js/node/tls.ts
+++ b/src/js/node/tls.ts
@@ -2,9 +2,10 @@
 const { isArrayBufferView, isTypedArray } = require("node:util/types");
 const { addServerName } = require("../internal/net");
 const net = require("node:net");
+const { Duplex } = require("node:stream");
+
 const { Server: NetServer, [Symbol.for("::bunternal::")]: InternalTCPSocket } = net;
 
-const bunSocketInternal = Symbol.for("::bunnetsocketinternal::");
 const { rootCertificates, canonicalizeIP } = $cpp("NodeTLS.cpp", "createNodeTLSBinding");
 
 const SymbolReplace = Symbol.replace;
@@ -327,20 +328,22 @@ const TLSSocket = (function (InternalTLSSocket) {
   class TLSSocket extends InternalTCPSocket {
     #secureContext;
     ALPNProtocols;
-    #socket;
     #checkServerIdentity;
     #session;
+    alpnProtocol = null;
 
     constructor(socket, options) {
-      super(socket instanceof InternalTCPSocket ? options : options || socket);
+      super(socket instanceof InternalTCPSocket || socket instanceof Duplex ? options : options || socket);
       options = options || socket || {};
       if (typeof options === "object") {
         const { ALPNProtocols } = options;
         if (ALPNProtocols) {
           convertALPNProtocols(ALPNProtocols, this);
         }
-        if (socket instanceof InternalTCPSocket) {
-          this.#socket = socket;
+        if (socket instanceof InternalTCPSocket || socket instanceof Duplex) {
+          this._handle = socket;
+          // keep compatibility with http2-wrapper or other places that try to grab JSStreamSocket in node.js, with here is just the TLSSocket
+          this._handle._parentWrap = this;
         }
       }
 
@@ -373,31 +376,31 @@ const TLSSocket = (function (InternalTLSSocket) {
     }
 
     getSession() {
-      return this[bunSocketInternal]?.getSession();
+      return this._handle?.getSession?.();
     }
 
     getEphemeralKeyInfo() {
-      return this[bunSocketInternal]?.getEphemeralKeyInfo();
+      return this._handle?.getEphemeralKeyInfo?.();
     }
 
     getCipher() {
-      return this[bunSocketInternal]?.getCipher();
+      return this._handle?.getCipher?.();
     }
 
     getSharedSigalgs() {
-      return this[bunSocketInternal]?.getSharedSigalgs();
+      return this._handle?.getSharedSigalgs?.();
     }
 
     getProtocol() {
-      return this[bunSocketInternal]?.getTLSVersion();
+      return this._handle?.getTLSVersion?.();
     }
 
     getFinished() {
-      return this[bunSocketInternal]?.getTLSFinishedMessage() || undefined;
+      return this._handle?.getTLSFinishedMessage?.() || undefined;
     }
 
     getPeerFinished() {
-      return this[bunSocketInternal]?.getTLSPeerFinishedMessage() || undefined;
+      return this._handle?.getTLSPeerFinishedMessage?.() || undefined;
     }
     isSessionReused() {
       return !!this.#session;
@@ -412,7 +415,7 @@ const TLSSocket = (function (InternalTLSSocket) {
         return false;
       }
 
-      const socket = this[bunSocketInternal];
+      const socket = this._handle;
       // if the socket is detached we can't renegotiate, nodejs do a noop too (we should not return false or true here)
       if (!socket) return;
 
@@ -424,13 +427,13 @@ const TLSSocket = (function (InternalTLSSocket) {
         if (options.rejectUnauthorized !== undefined) rejectUnauthorized = !!options.rejectUnauthorized;
 
         if (requestCert !== this._requestCert || rejectUnauthorized !== this._rejectUnauthorized) {
-          socket.setVerifyMode(requestCert, rejectUnauthorized);
+          socket.setVerifyMode?.(requestCert, rejectUnauthorized);
           this._requestCert = requestCert;
           this._rejectUnauthorized = rejectUnauthorized;
         }
       }
       try {
-        socket.renegotiate();
+        socket.renegotiate?.();
         // if renegotiate is successful should emit secure event when done
         typeof callback === "function" && this.once("secure", () => callback(null));
         return true;
@@ -444,21 +447,21 @@ const TLSSocket = (function (InternalTLSSocket) {
     disableRenegotiation() {
       this.#renegotiationDisabled = true;
       // disable renegotiation on the socket
-      return this[bunSocketInternal]?.disableRenegotiation();
+      return this._handle?.disableRenegotiation?.();
     }
 
     getTLSTicket() {
-      return this[bunSocketInternal]?.getTLSTicket();
+      return this._handle?.getTLSTicket?.();
     }
     exportKeyingMaterial(length, label, context) {
       if (context) {
-        return this[bunSocketInternal]?.exportKeyingMaterial(length, label, context);
+        return this._handle?.exportKeyingMaterial?.(length, label, context);
       }
-      return this[bunSocketInternal]?.exportKeyingMaterial(length, label);
+      return this._handle?.exportKeyingMaterial?.(length, label);
     }
 
     setMaxSendFragment(size) {
-      return this[bunSocketInternal]?.setMaxSendFragment(size) || false;
+      return this._handle?.setMaxSendFragment?.(size) || false;
     }
 
     // only for debug purposes so we just mock for now
@@ -472,25 +475,23 @@ const TLSSocket = (function (InternalTLSSocket) {
       }
       // if the socket is detached we can't set the servername but we set this property so when open will auto set to it
       this.servername = name;
-      this[bunSocketInternal]?.setServername(name);
+      this._handle?.setServername?.(name);
     }
     setSession(session) {
       this.#session = session;
       if (typeof session === "string") session = Buffer.from(session, "latin1");
-      return this[bunSocketInternal]?.setSession(session);
+      return this._handle?.setSession?.(session);
     }
     getPeerCertificate(abbreviated) {
       const cert =
-        arguments.length < 1
-          ? this[bunSocketInternal]?.getPeerCertificate()
-          : this[bunSocketInternal]?.getPeerCertificate(abbreviated);
+        arguments.length < 1 ? this._handle?.getPeerCertificate?.() : this._handle?.getPeerCertificate?.(abbreviated);
       if (cert) {
         return translatePeerCertificate(cert);
       }
     }
     getCertificate() {
       // need to implement certificate on socket.zig
-      const cert = this[bunSocketInternal]?.getCertificate();
+      const cert = this._handle?.getCertificate?.();
       if (cert) {
         // It's not a peer cert, but the formatting is identical.
         return translatePeerCertificate(cert);
@@ -503,13 +504,9 @@ const TLSSocket = (function (InternalTLSSocket) {
       throw Error("Not implented in Bun yet");
     }
 
-    get alpnProtocol() {
-      return this[bunSocketInternal]?.alpnProtocol;
-    }
-
     [buntls](port, host) {
       return {
-        socket: this.#socket,
+        socket: this._handle,
         ALPNProtocols: this.ALPNProtocols,
         serverName: this.servername || host || "localhost",
         checkServerIdentity: this.#checkServerIdentity,
@@ -546,8 +543,8 @@ class Server extends NetServer {
     if (!(context instanceof InternalSecureContext)) {
       context = createSecureContext(context);
     }
-    if (this[bunSocketInternal]) {
-      addServerName(this[bunSocketInternal], hostname, context);
+    if (this._handle) {
+      addServerName(this._handle, hostname, context);
     } else {
       if (!this.#contexts) this.#contexts = new Map();
       this.#contexts.set(hostname, context as typeof InternalSecureContext);
diff --git a/src/js/node/trace_events.ts b/src/js/node/trace_events.ts
index e0cb82f344..762a565b78 100644
--- a/src/js/node/trace_events.ts
+++ b/src/js/node/trace_events.ts
@@ -14,7 +14,7 @@ function ERR_INVALID_ARG_TYPE(name, type, value) {
 function createTracing(opts) {
   if (typeof opts !== "object" || opts == null) {
     // @ts-ignore
-    throw new ERR_INVALID_ARG_TYPE("options", "Object", opts);
+    throw new ERR_INVALID_ARG_TYPE("options", "object", opts);
   }
 
   // TODO: validate categories
diff --git a/src/js/node/tty.ts b/src/js/node/tty.ts
index 62a3756493..6bd0611a32 100644
--- a/src/js/node/tty.ts
+++ b/src/js/node/tty.ts
@@ -4,6 +4,8 @@ const {
   getWindowSize: _getWindowSize,
 } = $cpp("ProcessBindingTTYWrap.cpp", "createBunTTYFunctions");
 
+const { validateInteger } = require("internal/validators");
+
 // primordials
 const NumberIsInteger = Number.isInteger;
 
@@ -321,12 +323,6 @@ Object.defineProperty(WriteStream, "prototype", {
   configurable: true,
 });
 
-var validateInteger = (value, name, min = Number.MIN_SAFE_INTEGER, max = Number.MAX_SAFE_INTEGER) => {
-  if (typeof value !== "number") throw ERR_INVALID_ARG_TYPE(name, "number", value);
-  if (!NumberIsInteger(value)) throw ERR_OUT_OF_RANGE(name, "an integer", value);
-  if (value < min || value > max) throw ERR_OUT_OF_RANGE(name, `>= ${min} && <= ${max}`, value);
-};
-
 export default { ReadStream, WriteStream, isatty };
 
 function ERR_INVALID_ARG_TYPE(name, type, value) {
diff --git a/src/js/node/util.ts b/src/js/node/util.ts
index 58fb2f9277..3541d1b806 100644
--- a/src/js/node/util.ts
+++ b/src/js/node/util.ts
@@ -137,15 +137,15 @@ var log = function log() {
 };
 var inherits = function inherits(ctor, superCtor) {
   if (ctor === undefined || ctor === null) {
-    throw ERR_INVALID_ARG_TYPE("ctor", "Function", ctor);
+    throw ERR_INVALID_ARG_TYPE("ctor", "function", ctor);
   }
 
   if (superCtor === undefined || superCtor === null) {
-    throw ERR_INVALID_ARG_TYPE("superCtor", "Function", superCtor);
+    throw ERR_INVALID_ARG_TYPE("superCtor", "function", superCtor);
   }
 
   if (superCtor.prototype === undefined) {
-    throw ERR_INVALID_ARG_TYPE("superCtor.prototype", "Object", superCtor.prototype);
+    throw ERR_INVALID_ARG_TYPE("superCtor.prototype", "object", superCtor.prototype);
   }
   ctor.super_ = superCtor;
   Object.setPrototypeOf(ctor.prototype, superCtor.prototype);
diff --git a/src/js/node/vm.ts b/src/js/node/vm.ts
index 6cf4a90cf0..fd447006ef 100644
--- a/src/js/node/vm.ts
+++ b/src/js/node/vm.ts
@@ -3,6 +3,8 @@ const { throwNotImplemented } = require("internal/shared");
 
 const vm = $cpp("NodeVM.cpp", "Bun::createNodeVMBinding");
 
+const ObjectFreeze = Object.freeze;
+
 const { createContext, isContext, Script, runInNewContext, runInThisContext } = vm;
 
 function runInContext(code, context, options) {
@@ -38,6 +40,12 @@ class SyntheticModule {
   }
 }
 
+const constants = {
+  __proto__: null,
+  USE_MAIN_CONTEXT_DEFAULT_LOADER: Symbol("vm_dynamic_import_main_context_default"),
+  DONT_CONTEXTIFY: Symbol("vm_context_no_contextify"),
+};
+
 export default {
   createContext,
   runInContext,
@@ -51,4 +59,5 @@ export default {
   SourceTextModule,
   SyntheticModule,
   createScript,
+  constants: ObjectFreeze(constants),
 };
diff --git a/src/js/node/zlib.ts b/src/js/node/zlib.ts
index 72f5e5ed70..77651013eb 100644
--- a/src/js/node/zlib.ts
+++ b/src/js/node/zlib.ts
@@ -1,340 +1,61 @@
 // Hardcoded module "node:zlib"
 
 const assert = require("node:assert");
-const stream = require("node:stream");
 const BufferModule = require("node:buffer");
-const { ERR_INVALID_ARG_TYPE } = require("internal/errors");
 
+const crc32 = $newZigFunction("node_zlib_binding.zig", "crc32", 1);
+const NativeZlib = $zig("node_zlib_binding.zig", "NativeZlib");
+const NativeBrotli = $zig("node_zlib_binding.zig", "NativeBrotli");
+
+const ObjectKeys = Object.keys;
+const ArrayPrototypePush = Array.prototype.push;
 const ObjectDefineProperty = Object.defineProperty;
+const ObjectDefineProperties = Object.defineProperties;
+const ObjectFreeze = Object.freeze;
+const StringPrototypeStartsWith = String.prototype.startsWith;
+const MathMax = Math.max;
+const ArrayPrototypeMap = Array.prototype.map;
+const TypedArrayPrototypeFill = Uint8Array.prototype.fill;
+const ArrayPrototypeForEach = Array.prototype.forEach;
+const NumberIsNaN = Number.isNaN;
 
-const createBrotliEncoder = $newZigFunction("node_zlib_binding.zig", "createBrotliEncoder", 3);
-const createBrotliDecoder = $newZigFunction("node_zlib_binding.zig", "createBrotliDecoder", 3);
-const createZlibEncoder = $newZigFunction("node_zlib_binding.zig", "createZlibEncoder", 3);
-const createZlibDecoder = $newZigFunction("node_zlib_binding.zig", "createZlibDecoder", 3);
+const ArrayBufferIsView = ArrayBuffer.isView;
+const isArrayBufferView = ArrayBufferIsView;
+const isAnyArrayBuffer = b => b instanceof ArrayBuffer || b instanceof SharedArrayBuffer;
+const kMaxLength = $requireMap.$get("buffer")?.exports.kMaxLength ?? BufferModule.kMaxLength;
 
-const maxOutputLengthDefault = $requireMap.$get("buffer")?.exports.kMaxLength ?? BufferModule.kMaxLength;
+const {
+  ERR_BROTLI_INVALID_PARAM,
+  ERR_BUFFER_TOO_LARGE,
+  ERR_INVALID_ARG_TYPE,
+  ERR_OUT_OF_RANGE,
+  ERR_ZLIB_INITIALIZATION_FAILED,
+} = require("internal/errors");
+const { Transform, finished } = require("node:stream");
+const owner_symbol = Symbol("owner_symbol");
+const {
+  checkRangesOrGetDefault,
+  validateFunction,
+  validateUint32,
+  validateFiniteNumber,
+} = require("internal/validators");
 
-//
-
-const kHandle = Symbol("kHandle");
 const kFlushFlag = Symbol("kFlushFlag");
-const kFlushBuffers: Buffer[] = [];
-{
-  const dummyArrayBuffer = new ArrayBuffer();
-  for (const flushFlag of [0, 1, 2, 3, 4, 5]) {
-    kFlushBuffers[flushFlag] = Buffer.from(dummyArrayBuffer);
-    kFlushBuffers[flushFlag][kFlushFlag] = flushFlag;
-  }
-}
+const kError = Symbol("kError");
 
-// TODO: this doesn't match node exactly so improve this more later
-const alias = function (proto, to, from) {
-  ObjectDefineProperty(proto, to, {
-    get: function () {
-      return this[kHandle][from];
-    },
-    set: function (v) {}, // changing these would be a bug
-    enumerable: true,
-  });
-};
-
-//
-
-function ZlibBase(options, method) {
-  if (options == null) options = {};
-  if ($isObject(options)) {
-    options.maxOutputLength ??= maxOutputLengthDefault;
-
-    if (options.encoding || options.objectMode || options.writableObjectMode) {
-      options = { ...options };
-      options.encoding = null;
-      options.objectMode = false;
-      options.writableObjectMode = false;
-    }
-  }
-  const [, , private_constructor] = methods[method];
-  this[kHandle] = private_constructor(options, {}, null, method);
-  stream.Transform.$call(this, options);
-}
-ZlibBase.prototype = Object.create(stream.Transform.prototype);
-ObjectDefineProperty(ZlibBase.prototype, "_handle", {
-  get: function () {
-    return this[kHandle];
-  },
-  set: function (newval) {
-    //noop
-  },
-});
-alias(ZlibBase.prototype, "bytesWritten", "bytesWritten");
-alias(ZlibBase.prototype, "bytesRead", "bytesRead");
-alias(ZlibBase.prototype, "_closed", "closed");
-alias(ZlibBase.prototype, "_chunkSize", "chunkSize");
-alias(ZlibBase.prototype, "_defaultFlushFlag", "flush");
-alias(ZlibBase.prototype, "_finishFlushFlag", "finishFlush");
-alias(ZlibBase.prototype, "_defaultFullFlushFlag", "fullFlush");
-alias(ZlibBase.prototype, "_maxOutputLength", "maxOutputLength");
-ZlibBase.prototype.flush = function (kind, callback) {
-  if (typeof kind === "function" || (kind === undefined && !callback)) {
-    callback = kind;
-    kind = this._defaultFullFlushFlag;
-  }
-  if (this.writableFinished) {
-    if (callback) process.nextTick(callback);
-  } else if (this.writableEnded) {
-    if (callback) this.once("end", callback);
-  } else {
-    this.write(kFlushBuffers[kind], "", callback);
-  }
-};
-ZlibBase.prototype.reset = function () {
-  assert(this[kHandle], "zlib binding closed");
-  return this[kHandle].reset();
-};
-ZlibBase.prototype.close = function (callback) {
-  if (callback) stream.finished(this, callback);
-  this.destroy();
-};
-ZlibBase.prototype._transform = function _transform(chunk, encoding, callback) {
-  try {
-    callback(undefined, this[kHandle].transformSync(chunk, encoding, false));
-  } catch (err) {
-    callback(err, undefined);
-  }
-};
-ZlibBase.prototype._flush = function _flush(callback) {
-  try {
-    callback(undefined, this[kHandle].transformSync("", undefined, true));
-  } catch (err) {
-    callback(err, undefined);
-  }
-};
-ZlibBase.prototype._final = function (callback) {
-  callback();
-};
-ZlibBase.prototype._processChunk = function (chunk, flushFlag, cb) {
-  // _processChunk() is left for backwards compatibility
-  if (typeof cb === "function") processChunk(this, chunk, flushFlag, cb);
-  else return processChunkSync(this, chunk, flushFlag);
-};
-
-function processChunkSync(self, chunk, flushFlag) {
-  return self[kHandle].transformSync(chunk, undefined, false, flushFlag);
-}
-
-function processChunk(self, chunk, flushFlag, cb) {
-  if (self._closed) return process.nextTick(cb);
-  self[kHandle].transformSync(chunk, undefined, false, flushFlag);
-}
-
-//
-
-function Zlib(options, method) {
-  ZlibBase.$call(this, options, method);
-}
-Zlib.prototype = Object.create(ZlibBase.prototype);
-alias(Zlib.prototype, "_level", "level");
-alias(Zlib.prototype, "_strategy", "strategy");
-Zlib.prototype.params = function (level, strategy, callback) {
-  return this[kHandle].params(level, strategy, callback);
-};
-Zlib.prototype._transform = function _transform(chunk, encoding, callback) {
-  try {
-    this[kHandle].transformWith(chunk, encoding, this, false);
-    callback();
-  } catch (err) {
-    callback(err, undefined);
-  }
-};
-
-//
-
-function BrotliCompress(opts) {
-  if (!(this instanceof BrotliCompress)) return new BrotliCompress(opts);
-  ZlibBase.$call(this, opts, BROTLI_ENCODE);
-}
-BrotliCompress.prototype = Object.create(ZlibBase.prototype);
-
-//
-
-function BrotliDecompress(opts) {
-  if (!(this instanceof BrotliDecompress)) return new BrotliDecompress(opts);
-  ZlibBase.$call(this, opts, BROTLI_DECODE);
-}
-BrotliDecompress.prototype = Object.create(ZlibBase.prototype);
-
-//
-
-function Deflate(opts) {
-  if (!(this instanceof Deflate)) return new Deflate(opts);
-  Zlib.$call(this, opts, DEFLATE);
-}
-Deflate.prototype = Object.create(Zlib.prototype);
-
-//
-
-function Inflate(opts) {
-  if (!(this instanceof Inflate)) return new Inflate(opts);
-  Zlib.$call(this, opts, INFLATE);
-}
-Inflate.prototype = Object.create(Zlib.prototype);
-
-//
-
-function DeflateRaw(opts) {
-  if (!(this instanceof DeflateRaw)) return new DeflateRaw(opts);
-  Zlib.$call(this, opts, DEFLATERAW);
-}
-DeflateRaw.prototype = Object.create(Zlib.prototype);
-
-//
-
-function InflateRaw(opts) {
-  if (!(this instanceof InflateRaw)) return new InflateRaw(opts);
-  Zlib.$call(this, opts, INFLATERAW);
-}
-InflateRaw.prototype = Object.create(Zlib.prototype);
-
-//
-
-function Gzip(opts) {
-  if (!(this instanceof Gzip)) return new Gzip(opts);
-  Zlib.$call(this, opts, GZIP);
-}
-Gzip.prototype = Object.create(Zlib.prototype);
-
-//
-
-function Gunzip(opts) {
-  if (!(this instanceof Gunzip)) return new Gunzip(opts);
-  Zlib.$call(this, opts, GUNZIP);
-}
-Gunzip.prototype = Object.create(Zlib.prototype);
-
-//
-
-function Unzip(opts) {
-  if (!(this instanceof Unzip)) return new Unzip(opts);
-  Zlib.$call(this, opts, UNZIP);
-}
-Unzip.prototype = Object.create(Zlib.prototype);
-
-//
-
-const constants = {
-  Z_NO_FLUSH: 0,
-  Z_PARTIAL_FLUSH: 1,
-  Z_SYNC_FLUSH: 2,
-  Z_FULL_FLUSH: 3,
-  Z_FINISH: 4,
-  Z_BLOCK: 5,
-  Z_TREES: 6,
-  Z_OK: 0,
-  Z_STREAM_END: 1,
-  Z_NEED_DICT: 2,
-  Z_ERRNO: -1,
-  Z_STREAM_ERROR: -2,
-  Z_DATA_ERROR: -3,
-  Z_MEM_ERROR: -4,
-  Z_BUF_ERROR: -5,
-  Z_VERSION_ERROR: -6,
-  Z_NO_COMPRESSION: 0,
-  Z_BEST_SPEED: 1,
-  Z_BEST_COMPRESSION: 9,
-  Z_DEFAULT_COMPRESSION: -1,
-  Z_FILTERED: 1,
-  Z_HUFFMAN_ONLY: 2,
-  Z_RLE: 3,
-  Z_FIXED: 4,
-  Z_DEFAULT_STRATEGY: 0,
-  Z_BINARY: 0,
-  Z_TEXT: 1,
-  Z_ASCII: 1,
-  Z_UNKNOWN: 2,
-  Z_DEFLATED: 8,
-  DEFLATE: 1,
-  INFLATE: 2,
-  GZIP: 3,
-  GUNZIP: 4,
-  DEFLATERAW: 5,
-  INFLATERAW: 6,
-  UNZIP: 7,
-  BROTLI_DECODE: 8,
-  BROTLI_ENCODE: 9,
-  Z_MIN_WINDOWBITS: 8,
-  Z_MAX_WINDOWBITS: 15,
-  Z_DEFAULT_WINDOWBITS: 15,
-  Z_MIN_CHUNK: 64,
-  Z_MAX_CHUNK: Infinity,
-  Z_DEFAULT_CHUNK: 16384,
-  Z_MIN_MEMLEVEL: 1,
-  Z_MAX_MEMLEVEL: 9,
-  Z_DEFAULT_MEMLEVEL: 8,
-  Z_MIN_LEVEL: -1,
-  Z_MAX_LEVEL: 9,
-  Z_DEFAULT_LEVEL: -1,
-  BROTLI_OPERATION_PROCESS: 0,
-  BROTLI_OPERATION_FLUSH: 1,
-  BROTLI_OPERATION_FINISH: 2,
-  BROTLI_OPERATION_EMIT_METADATA: 3,
-  BROTLI_PARAM_MODE: 0,
-  BROTLI_MODE_GENERIC: 0,
-  BROTLI_MODE_TEXT: 1,
-  BROTLI_MODE_FONT: 2,
-  BROTLI_DEFAULT_MODE: 0,
-  BROTLI_PARAM_QUALITY: 1,
-  BROTLI_MIN_QUALITY: 0,
-  BROTLI_MAX_QUALITY: 11,
-  BROTLI_DEFAULT_QUALITY: 11,
-  BROTLI_PARAM_LGWIN: 2,
-  BROTLI_MIN_WINDOW_BITS: 10,
-  BROTLI_MAX_WINDOW_BITS: 24,
-  BROTLI_LARGE_MAX_WINDOW_BITS: 30,
-  BROTLI_DEFAULT_WINDOW: 22,
-  BROTLI_PARAM_LGBLOCK: 3,
-  BROTLI_MIN_INPUT_BLOCK_BITS: 16,
-  BROTLI_MAX_INPUT_BLOCK_BITS: 24,
-  BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING: 4,
-  BROTLI_PARAM_SIZE_HINT: 5,
-  BROTLI_PARAM_LARGE_WINDOW: 6,
-  BROTLI_PARAM_NPOSTFIX: 7,
-  BROTLI_PARAM_NDIRECT: 8,
-  BROTLI_DECODER_RESULT_ERROR: 0,
-  BROTLI_DECODER_RESULT_SUCCESS: 1,
-  BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT: 2,
-  BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT: 3,
-  BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION: 0,
-  BROTLI_DECODER_PARAM_LARGE_WINDOW: 1,
-  BROTLI_DECODER_NO_ERROR: 0,
-  BROTLI_DECODER_SUCCESS: 1,
-  BROTLI_DECODER_NEEDS_MORE_INPUT: 2,
-  BROTLI_DECODER_NEEDS_MORE_OUTPUT: 3,
-  BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE: -1,
-  BROTLI_DECODER_ERROR_FORMAT_RESERVED: -2,
-  BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE: -3,
-  BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET: -4,
-  BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME: -5,
-  BROTLI_DECODER_ERROR_FORMAT_CL_SPACE: -6,
-  BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE: -7,
-  BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT: -8,
-  BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1: -9,
-  BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2: -10,
-  BROTLI_DECODER_ERROR_FORMAT_TRANSFORM: -11,
-  BROTLI_DECODER_ERROR_FORMAT_DICTIONARY: -12,
-  BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS: -13,
-  BROTLI_DECODER_ERROR_FORMAT_PADDING_1: -14,
-  BROTLI_DECODER_ERROR_FORMAT_PADDING_2: -15,
-  BROTLI_DECODER_ERROR_FORMAT_DISTANCE: -16,
-  BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET: -19,
-  BROTLI_DECODER_ERROR_INVALID_ARGUMENTS: -20,
-  BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES: -21,
-  BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS: -22,
-  BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP: -25,
-  BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1: -26,
-  BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2: -27,
-  BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES: -30,
-  BROTLI_DECODER_ERROR_UNREACHABLE: -31,
-};
-const { DEFLATE, INFLATE, GZIP, GUNZIP, DEFLATERAW, INFLATERAW, UNZIP, BROTLI_DECODE, BROTLI_ENCODE } = constants;
+const { zlib: constants } = process.binding("constants");
+// prettier-ignore
+const {
+  // Zlib flush levels
+  Z_NO_FLUSH, Z_BLOCK, Z_PARTIAL_FLUSH, Z_SYNC_FLUSH, Z_FULL_FLUSH, Z_FINISH,
+  // Zlib option values
+  Z_MIN_CHUNK, Z_MIN_WINDOWBITS, Z_MAX_WINDOWBITS, Z_MIN_LEVEL, Z_MAX_LEVEL, Z_MIN_MEMLEVEL, Z_MAX_MEMLEVEL,
+  Z_DEFAULT_CHUNK, Z_DEFAULT_COMPRESSION, Z_DEFAULT_STRATEGY, Z_DEFAULT_WINDOWBITS, Z_DEFAULT_MEMLEVEL, Z_FIXED,
+  // Node's compression stream modes (node_zlib_mode)
+  DEFLATE, DEFLATERAW, INFLATE, INFLATERAW, GZIP, GUNZIP, UNZIP, BROTLI_DECODE, BROTLI_ENCODE,
+  // Brotli operations (~flush levels)
+  BROTLI_OPERATION_PROCESS, BROTLI_OPERATION_FLUSH, BROTLI_OPERATION_FINISH, BROTLI_OPERATION_EMIT_METADATA,
+} = constants;
 
 // Translation table for return codes.
 const codes = {
@@ -348,96 +69,665 @@ const codes = {
   Z_BUF_ERROR: constants.Z_BUF_ERROR,
   Z_VERSION_ERROR: constants.Z_VERSION_ERROR,
 };
-
-for (const ckey of Object.keys(codes)) {
+for (const ckey of ObjectKeys(codes)) {
   codes[codes[ckey]] = ckey;
 }
 
-const methods = [
-  [],
-  [Deflate, true, createZlibEncoder],
-  [Inflate, false, createZlibDecoder],
-  [Gzip, true, createZlibEncoder],
-  [Gunzip, false, createZlibDecoder],
-  [DeflateRaw, true, createZlibEncoder],
-  [InflateRaw, false, createZlibDecoder],
-  [Unzip, false, createZlibDecoder],
-  [BrotliDecompress, false, createBrotliDecoder],
-  [BrotliCompress, true, createBrotliEncoder],
-] as const;
+function zlibBuffer(engine, buffer, callback) {
+  validateFunction(callback, "callback");
+  // Streams do not support non-Uint8Array ArrayBufferViews yet. Convert it to a Buffer without copying.
+  if (isArrayBufferView(buffer)) {
+    buffer = Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  } else if (isAnyArrayBuffer(buffer)) {
+    buffer = Buffer.from(buffer);
+  }
+  engine.buffers = null;
+  engine.nread = 0;
+  engine.cb = callback;
+  engine.on("data", zlibBufferOnData);
+  engine.on("error", zlibBufferOnError);
+  engine.on("end", zlibBufferOnEnd);
+  engine.end(buffer);
+}
 
-function createConvenienceMethod(method: number, is_sync: boolean) {
-  const [, , private_constructor] = methods[method];
-
-  switch (is_sync) {
-    case false:
-      return function (buffer, options, callback) {
-        if (typeof options === "function") {
-          callback = options;
-          options = {};
-        }
-        if (options == null) options = {};
-        if ($isObject(options)) options.maxOutputLength ??= maxOutputLengthDefault;
-        if (typeof callback !== "function") throw ERR_INVALID_ARG_TYPE("callback", "function", callback);
-        const coder = private_constructor(options, {}, callback, method);
-        coder.transform(buffer, undefined, true);
-      };
-    case true:
-      return function (buffer, options) {
-        if (options == null) options = {};
-        if ($isObject(options)) options.maxOutputLength ??= maxOutputLengthDefault;
-        const coder = private_constructor(options, {}, null, method);
-        return coder.transformSync(buffer, undefined, true);
-      };
+function zlibBufferOnData(chunk) {
+  if (!this.buffers) this.buffers = [chunk];
+  else ArrayPrototypePush.$call(this.buffers, chunk);
+  this.nread += chunk.length;
+  if (this.nread > this._maxOutputLength) {
+    this.close();
+    this.removeAllListeners("end");
+    this.cb(ERR_BUFFER_TOO_LARGE(this._maxOutputLength));
   }
 }
 
-function createCreator(method: number) {
-  const Constructor = methods[method][0];
-  return function (opts) {
-    return new Constructor(opts);
-  };
+function zlibBufferOnError(err) {
+  this.removeAllListeners("end");
+  this.cb(err);
 }
 
-const functions = {
-  crc32: $newZigFunction("node_zlib_binding.zig", "crc32", 1),
+function zlibBufferOnEnd() {
+  let buf;
+  if (this.nread === 0) {
+    buf = Buffer.alloc(0);
+  } else {
+    const bufs = this.buffers;
+    buf = bufs.length === 1 ? bufs[0] : Buffer.concat(bufs, this.nread);
+  }
+  this.close();
+  if (this._info) this.cb(null, { buffer: buf, engine: this });
+  else this.cb(null, buf);
+}
 
-  deflate: createConvenienceMethod(DEFLATE, false),
-  deflateSync: createConvenienceMethod(DEFLATE, true),
-  gzip: createConvenienceMethod(GZIP, false),
-  gzipSync: createConvenienceMethod(GZIP, true),
-  deflateRaw: createConvenienceMethod(DEFLATERAW, false),
-  deflateRawSync: createConvenienceMethod(DEFLATERAW, true),
-  unzip: createConvenienceMethod(UNZIP, false),
-  unzipSync: createConvenienceMethod(UNZIP, true),
-  inflate: createConvenienceMethod(INFLATE, false),
-  inflateSync: createConvenienceMethod(INFLATE, true),
-  gunzip: createConvenienceMethod(GUNZIP, false),
-  gunzipSync: createConvenienceMethod(GUNZIP, true),
-  inflateRaw: createConvenienceMethod(INFLATERAW, false),
-  inflateRawSync: createConvenienceMethod(INFLATERAW, true),
-  brotliCompress: createConvenienceMethod(BROTLI_ENCODE, false),
-  brotliCompressSync: createConvenienceMethod(BROTLI_ENCODE, true),
-  brotliDecompress: createConvenienceMethod(BROTLI_DECODE, false),
-  brotliDecompressSync: createConvenienceMethod(BROTLI_DECODE, true),
+function zlibBufferSync(engine, buffer) {
+  if (typeof buffer === "string") {
+    buffer = Buffer.from(buffer);
+  } else if (!isArrayBufferView(buffer)) {
+    if (isAnyArrayBuffer(buffer)) {
+      buffer = Buffer.from(buffer);
+    } else {
+      throw ERR_INVALID_ARG_TYPE("buffer", "string, Buffer, TypedArray, DataView, or ArrayBuffer", buffer);
+    }
+  }
+  buffer = processChunkSync(engine, buffer, engine._finishFlushFlag);
+  if (engine._info) return { buffer, engine };
+  return buffer;
+}
 
-  createDeflate: createCreator(DEFLATE),
-  createInflate: createCreator(INFLATE),
-  createDeflateRaw: createCreator(DEFLATERAW),
-  createInflateRaw: createCreator(INFLATERAW),
-  createGzip: createCreator(GZIP),
-  createGunzip: createCreator(GUNZIP),
-  createUnzip: createCreator(UNZIP),
-  createBrotliCompress: createCreator(BROTLI_ENCODE),
-  createBrotliDecompress: createCreator(BROTLI_DECODE),
+function zlibOnError(message, errno, code) {
+  const self = this[owner_symbol];
+  // There is no way to cleanly recover. Continuing only obscures problems.
+  const error = new Error(message);
+  error.errno = errno;
+  error.code = code;
+  self.destroy(error);
+  self[kError] = error;
+}
+
+const FLUSH_BOUND = [
+  [Z_NO_FLUSH, Z_BLOCK],
+  [BROTLI_OPERATION_PROCESS, BROTLI_OPERATION_EMIT_METADATA],
+];
+const FLUSH_BOUND_IDX_NORMAL = 0;
+const FLUSH_BOUND_IDX_BROTLI = 1;
+
+// The base class for all Zlib-style streams.
+function ZlibBase(opts, mode, handle, { flush, finishFlush, fullFlush }) {
+  let chunkSize = Z_DEFAULT_CHUNK;
+  let maxOutputLength = kMaxLength;
+  // The ZlibBase class is not exported to user land, the mode should only be passed in by us.
+  assert(typeof mode === "number");
+  assert(mode >= DEFLATE && mode <= BROTLI_ENCODE);
+
+  let flushBoundIdx;
+  if (mode !== BROTLI_ENCODE && mode !== BROTLI_DECODE) {
+    flushBoundIdx = FLUSH_BOUND_IDX_NORMAL;
+  } else {
+    flushBoundIdx = FLUSH_BOUND_IDX_BROTLI;
+  }
+
+  if (opts) {
+    chunkSize = opts.chunkSize;
+    if (!validateFiniteNumber(chunkSize, "options.chunkSize")) {
+      chunkSize = Z_DEFAULT_CHUNK;
+    } else if (chunkSize < Z_MIN_CHUNK) {
+      throw ERR_OUT_OF_RANGE("options.chunkSize", `>= ${Z_MIN_CHUNK}`, chunkSize);
+    }
+
+    // prettier-ignore
+    flush = checkRangesOrGetDefault(opts.flush, "options.flush", FLUSH_BOUND[flushBoundIdx][0], FLUSH_BOUND[flushBoundIdx][1], flush);
+    // prettier-ignore
+    finishFlush = checkRangesOrGetDefault(opts.finishFlush, "options.finishFlush", FLUSH_BOUND[flushBoundIdx][0], FLUSH_BOUND[flushBoundIdx][1], finishFlush);
+    // prettier-ignore
+    maxOutputLength = checkRangesOrGetDefault(opts.maxOutputLength, "options.maxOutputLength", 1, kMaxLength, kMaxLength);
+
+    if (opts.encoding || opts.objectMode || opts.writableObjectMode) {
+      opts = { ...opts };
+      opts.encoding = null;
+      opts.objectMode = false;
+      opts.writableObjectMode = false;
+    }
+  }
+
+  Transform.$apply(this, [{ autoDestroy: true, ...opts }]);
+  this[kError] = null;
+  this.bytesWritten = 0;
+  this._handle = handle;
+  handle[owner_symbol] = this;
+  // Used by processCallback() and zlibOnError()
+  handle.onerror = zlibOnError;
+  this._outBuffer = Buffer.allocUnsafe(chunkSize);
+  this._outOffset = 0;
+
+  this._chunkSize = chunkSize;
+  this._defaultFlushFlag = flush;
+  this._finishFlushFlag = finishFlush;
+  this._defaultFullFlushFlag = fullFlush;
+  this._info = opts && opts.info;
+  this._maxOutputLength = maxOutputLength;
+}
+$toClass(ZlibBase, "ZlibBase", Transform);
+
+ObjectDefineProperty(ZlibBase.prototype, "_closed", {
+  configurable: true,
+  enumerable: true,
+  get() {
+    return !this._handle;
+  },
+});
+
+// `bytesRead` made sense as a name when looking from the zlib engine's
+// perspective, but it is inconsistent with all other streams exposed by Node.js
+// that have this concept, where it stands for the number of bytes read
+// *from* the stream (that is, net.Socket/tls.Socket & file system streams).
+ObjectDefineProperty(ZlibBase.prototype, "bytesRead", {
+  configurable: true,
+  get: function () {
+    return this.bytesWritten;
+  },
+  set: function (value) {
+    this.bytesWritten = value;
+  },
+});
+
+ZlibBase.prototype.reset = function () {
+  assert(this._handle, "zlib binding closed");
+  return this._handle.reset();
 };
-for (const f in functions) {
-  Object.defineProperty(functions[f], "name", {
-    value: f,
-  });
+
+// This is the _flush function called by the transform class, internally, when the last chunk has been written.
+ZlibBase.prototype._flush = function (callback) {
+  this._transform(Buffer.alloc(0), "", callback);
+};
+
+// Force Transform compat behavior.
+ZlibBase.prototype._final = function (callback) {
+  callback();
+};
+
+// If a flush is scheduled while another flush is still pending, a way to figure out which one is the "stronger" flush is needed.
+// This is currently only used to figure out which flush flag to use for the last chunk.
+// Roughly, the following holds:
+// Z_NO_FLUSH (< Z_TREES) < Z_BLOCK < Z_PARTIAL_FLUSH < Z_SYNC_FLUSH < Z_FULL_FLUSH < Z_FINISH
+const flushiness: number[] = [];
+const kFlushFlagList = [Z_NO_FLUSH, Z_BLOCK, Z_PARTIAL_FLUSH, Z_SYNC_FLUSH, Z_FULL_FLUSH, Z_FINISH];
+for (let i = 0; i < kFlushFlagList.length; i++) {
+  flushiness[kFlushFlagList[i]] = i;
 }
 
+function maxFlush(a, b) {
+  return flushiness[a] > flushiness[b] ? a : b;
+}
+
+// Set up a list of 'special' buffers that can be written using .write()
+// from the .flush() code as a way of introducing flushing operations into the
+// write sequence.
+const kFlushBuffers: (typeof Buffer)[] = [];
+{
+  const dummyArrayBuffer = new ArrayBuffer();
+  for (const flushFlag of kFlushFlagList) {
+    kFlushBuffers[flushFlag] = Buffer.from(dummyArrayBuffer);
+    kFlushBuffers[flushFlag][kFlushFlag] = flushFlag;
+  }
+}
+
+ZlibBase.prototype.flush = function (kind, callback) {
+  if (typeof kind === "function" || (kind === undefined && !callback)) {
+    callback = kind;
+    kind = this._defaultFullFlushFlag;
+  }
+  if (this.writableFinished) {
+    if (callback) process.nextTick(callback);
+  } else if (this.writableEnded) {
+    if (callback) this.once("end", callback);
+  } else {
+    this.write(kFlushBuffers[kind], "", callback);
+  }
+};
+
+ZlibBase.prototype.close = function (callback) {
+  if (callback) finished(this, callback);
+  this.destroy();
+};
+
+ZlibBase.prototype._destroy = function (err, callback) {
+  _close(this);
+  callback(err);
+};
+
+ZlibBase.prototype._transform = function (chunk, encoding, cb) {
+  let flushFlag = this._defaultFlushFlag;
+  // We use a 'fake' zero-length chunk to carry information about flushes from the public API to the actual stream implementation.
+  if (typeof chunk[kFlushFlag] === "number") {
+    flushFlag = chunk[kFlushFlag];
+  }
+
+  // For the last chunk, also apply `_finishFlushFlag`.
+  if (this.writableEnded && this.writableLength === chunk.byteLength) {
+    flushFlag = maxFlush(flushFlag, this._finishFlushFlag);
+  }
+  processChunk(this, chunk, flushFlag, cb);
+};
+
+ZlibBase.prototype._processChunk = function (chunk, flushFlag, cb) {
+  // _processChunk() is left for backwards compatibility
+  if (typeof cb === "function") processChunk(this, chunk, flushFlag, cb);
+  else return processChunkSync(this, chunk, flushFlag);
+};
+
+function processChunkSync(self, chunk, flushFlag) {
+  let availInBefore = chunk.byteLength;
+  let availOutBefore = self._chunkSize - self._outOffset;
+  let inOff = 0;
+  let availOutAfter;
+  let availInAfter;
+
+  const buffers = [];
+  let nread = 0;
+  let inputRead = 0;
+  const state = self._writeState;
+  const handle = self._handle;
+  let buffer = self._outBuffer;
+  let offset = self._outOffset;
+  const chunkSize = self._chunkSize;
+
+  let error;
+  self.on("error", function onError(er) {
+    error = er;
+  });
+
+  while (true) {
+    handle.writeSync(
+      flushFlag,
+      chunk, // in
+      inOff, // in_off
+      availInBefore, // in_len
+      buffer, // out
+      offset, // out_off
+      availOutBefore, // out_len
+    );
+    if (error) throw error;
+    else if (self[kError]) throw self[kError];
+
+    availOutAfter = state[0];
+    availInAfter = state[1];
+
+    const inDelta = availInBefore - availInAfter;
+    inputRead += inDelta;
+
+    const have = availOutBefore - availOutAfter;
+    if (have > 0) {
+      const out = buffer.slice(offset, offset + have);
+      offset += have;
+      ArrayPrototypePush.$call(buffers, out);
+      nread += out.byteLength;
+
+      if (nread > self._maxOutputLength) {
+        _close(self);
+        throw ERR_BUFFER_TOO_LARGE(self._maxOutputLength);
+      }
+    } else {
+      assert(have === 0, "have should not go down");
+    }
+
+    // Exhausted the output buffer, or used all the input create a new one.
+    if (availOutAfter === 0 || offset >= chunkSize) {
+      availOutBefore = chunkSize;
+      offset = 0;
+      buffer = Buffer.allocUnsafe(chunkSize);
+    }
+
+    if (availOutAfter === 0) {
+      // Not actually done. Need to reprocess.
+      // Also, update the availInBefore to the availInAfter value,
+      // so that if we have to hit it a third (fourth, etc.) time,
+      // it'll have the correct byte counts.
+      inOff += inDelta;
+      availInBefore = availInAfter;
+    } else {
+      break;
+    }
+  }
+
+  self.bytesWritten = inputRead;
+  _close(self);
+
+  if (nread === 0) return Buffer.alloc(0);
+
+  return buffers.length === 1 ? buffers[0] : Buffer.concat(buffers, nread);
+}
+
+function processChunk(self, chunk, flushFlag, cb) {
+  const handle = self._handle;
+  if (!handle) return process.nextTick(cb);
+
+  handle.buffer = chunk;
+  handle.cb = cb;
+  handle.availOutBefore = self._chunkSize - self._outOffset;
+  handle.availInBefore = chunk.byteLength;
+  handle.inOff = 0;
+  handle.flushFlag = flushFlag;
+
+  handle.write(
+    flushFlag, // flush
+    chunk, // in
+    0, // in_off
+    handle.availInBefore, // in_len
+    self._outBuffer, // out
+    self._outOffset, // out_off
+    handle.availOutBefore, // out_len
+  );
+}
+
+function processCallback() {
+  // This callback's context (`this`) is the `_handle` (ZCtx) object. It is
+  // important to null out the values once they are no longer needed since
+  // `_handle` can stay in memory long after the buffer is needed.
+  const handle = this;
+  const self = this[owner_symbol];
+  const state = self._writeState;
+
+  if (self.destroyed) {
+    this.buffer = null;
+    this.cb();
+    return;
+  }
+
+  const availOutAfter = state[0];
+  const availInAfter = state[1];
+
+  const inDelta = handle.availInBefore - availInAfter;
+  self.bytesWritten += inDelta;
+
+  const have = handle.availOutBefore - availOutAfter;
+  let streamBufferIsFull = false;
+  if (have > 0) {
+    const out = self._outBuffer.slice(self._outOffset, self._outOffset + have);
+    self._outOffset += have;
+    streamBufferIsFull = !self.push(out);
+  } else {
+    assert(have === 0, "have should not go down");
+  }
+
+  if (self.destroyed) {
+    this.cb();
+    return;
+  }
+
+  // Exhausted the output buffer, or used all the input create a new one.
+  if (availOutAfter === 0 || self._outOffset >= self._chunkSize) {
+    handle.availOutBefore = self._chunkSize;
+    self._outOffset = 0;
+    self._outBuffer = Buffer.allocUnsafe(self._chunkSize);
+  }
+
+  if (availOutAfter === 0) {
+    // Not actually done. Need to reprocess.
+    // Also, update the availInBefore to the availInAfter value,
+    // so that if we have to hit it a third (fourth, etc.) time,
+    // it'll have the correct byte counts.
+    handle.inOff += inDelta;
+    handle.availInBefore = availInAfter;
+
+    if (!streamBufferIsFull) {
+      this.write(
+        handle.flushFlag, // flush
+        this.buffer, // in
+        handle.inOff, // in_off
+        handle.availInBefore, // in_len
+        self._outBuffer, // out
+        self._outOffset, // out_off
+        self._chunkSize, // out_len
+      );
+    } else {
+      const oldRead = self._read;
+      self._read = n => {
+        self._read = oldRead;
+        this.write(
+          handle.flushFlag, // flush
+          this.buffer, // in
+          handle.inOff, // in_off
+          handle.availInBefore, // in_len
+          self._outBuffer, // out
+          self._outOffset, // out_off
+          self._chunkSize, // out_len
+        );
+        self._read(n);
+      };
+    }
+    return;
+  }
+
+  if (availInAfter > 0) {
+    // If we have more input that should be written, but we also have output
+    // space available, that means that the compression library was not
+    // interested in receiving more data, and in particular that the input
+    // stream has ended early.
+    // This applies to streams where we don't check data past the end of
+    // what was consumed; that is, everything except Gunzip/Unzip.
+    self.push(null);
+  }
+
+  // Finished with the chunk.
+  this.buffer = null;
+  this.cb();
+}
+
+function _close(engine) {
+  // Caller may invoke .close after a zlib error (which will null _handle)
+  engine._handle?.close();
+  engine._handle = null;
+}
+
+const zlibDefaultOpts = {
+  flush: Z_NO_FLUSH,
+  finishFlush: Z_FINISH,
+  fullFlush: Z_FULL_FLUSH,
+};
+// Base class for all streams actually backed by zlib and using zlib-specific
+// parameters.
+function Zlib(opts, mode) {
+  let windowBits = Z_DEFAULT_WINDOWBITS;
+  let level = Z_DEFAULT_COMPRESSION;
+  let memLevel = Z_DEFAULT_MEMLEVEL;
+  let strategy = Z_DEFAULT_STRATEGY;
+  let dictionary;
+
+  if (opts) {
+    // windowBits is special. On the compression side, 0 is an invalid value.
+    // But on the decompression side, a value of 0 for windowBits tells zlib
+    // to use the window size in the zlib header of the compressed stream.
+    if ((opts.windowBits == null || opts.windowBits === 0) && (mode === INFLATE || mode === GUNZIP || mode === UNZIP)) {
+      windowBits = 0;
+    } else {
+      // `{ windowBits: 8 }` is valid for deflate but not gzip.
+      const min = Z_MIN_WINDOWBITS + (mode === GZIP ? 1 : 0);
+      windowBits = checkRangesOrGetDefault(
+        opts.windowBits,
+        "options.windowBits",
+        min,
+        Z_MAX_WINDOWBITS,
+        Z_DEFAULT_WINDOWBITS,
+      );
+    }
+
+    level = checkRangesOrGetDefault(opts.level, "options.level", Z_MIN_LEVEL, Z_MAX_LEVEL, Z_DEFAULT_COMPRESSION);
+    // prettier-ignore
+    memLevel = checkRangesOrGetDefault(opts.memLevel, "options.memLevel", Z_MIN_MEMLEVEL, Z_MAX_MEMLEVEL, Z_DEFAULT_MEMLEVEL);
+    // prettier-ignore
+    strategy = checkRangesOrGetDefault(opts.strategy, "options.strategy", Z_DEFAULT_STRATEGY, Z_FIXED, Z_DEFAULT_STRATEGY);
+
+    dictionary = opts.dictionary;
+    if (dictionary !== undefined && !isArrayBufferView(dictionary)) {
+      if (isAnyArrayBuffer(dictionary)) {
+        dictionary = Buffer.from(dictionary);
+      } else {
+        throw ERR_INVALID_ARG_TYPE("options.dictionary", "Buffer, TypedArray, DataView, or ArrayBuffer", dictionary);
+      }
+    }
+  }
+
+  const handle = new NativeZlib(mode);
+  this._writeState = new Uint32Array(2);
+  handle.init(windowBits, level, memLevel, strategy, this._writeState, processCallback, dictionary);
+
+  ZlibBase.$apply(this, [opts, mode, handle, zlibDefaultOpts]);
+
+  this._level = level;
+  this._strategy = strategy;
+}
+$toClass(Zlib, "Zlib", ZlibBase);
+
+// This callback is used by `.params()` to wait until a full flush happened before adjusting the parameters.
+// In particular, the call to the native `params()` function should not happen while a write is currently in progress on the threadpool.
+function paramsAfterFlushCallback(level, strategy, callback) {
+  assert(this._handle, "zlib binding closed");
+  this._handle.params(level, strategy);
+  if (!this.destroyed) {
+    this._level = level;
+    this._strategy = strategy;
+    if (callback) callback();
+  }
+}
+
+Zlib.prototype.params = function params(level, strategy, callback) {
+  checkRangesOrGetDefault(level, "level", Z_MIN_LEVEL, Z_MAX_LEVEL);
+  checkRangesOrGetDefault(strategy, "strategy", Z_DEFAULT_STRATEGY, Z_FIXED);
+
+  if (this._level !== level || this._strategy !== strategy) {
+    this.flush(Z_SYNC_FLUSH, paramsAfterFlushCallback.bind(this, level, strategy, callback));
+  } else {
+    process.nextTick(callback);
+  }
+};
+
+function Deflate(opts) {
+  if (!(this instanceof Deflate)) return new Deflate(opts);
+  Zlib.$apply(this, [opts, DEFLATE]);
+}
+$toClass(Deflate, "Deflate", Zlib);
+
+function Inflate(opts) {
+  if (!(this instanceof Inflate)) return new Inflate(opts);
+  Zlib.$apply(this, [opts, INFLATE]);
+}
+$toClass(Inflate, "Inflate", Zlib);
+
+function Gzip(opts) {
+  if (!(this instanceof Gzip)) return new Gzip(opts);
+  Zlib.$apply(this, [opts, GZIP]);
+}
+$toClass(Gzip, "Gzip", Zlib);
+
+function Gunzip(opts) {
+  if (!(this instanceof Gunzip)) return new Gunzip(opts);
+  Zlib.$apply(this, [opts, GUNZIP]);
+}
+$toClass(Gunzip, "Gunzip", Zlib);
+
+function DeflateRaw(opts) {
+  if (opts && opts.windowBits === 8) opts.windowBits = 9;
+  if (!(this instanceof DeflateRaw)) return new DeflateRaw(opts);
+  Zlib.$apply(this, [opts, DEFLATERAW]);
+}
+$toClass(DeflateRaw, "DeflateRaw", Zlib);
+
+function InflateRaw(opts) {
+  if (!(this instanceof InflateRaw)) return new InflateRaw(opts);
+  Zlib.$apply(this, [opts, INFLATERAW]);
+}
+$toClass(InflateRaw, "InflateRaw", Zlib);
+
+function Unzip(opts) {
+  if (!(this instanceof Unzip)) return new Unzip(opts);
+  Zlib.$apply(this, [opts, UNZIP]);
+}
+$toClass(Unzip, "Unzip", Zlib);
+
+function createConvenienceMethod(ctor, sync, methodName) {
+  if (sync) {
+    const fn = function (buffer, opts) {
+      return zlibBufferSync(new ctor(opts), buffer);
+    };
+    ObjectDefineProperty(fn, "name", { value: methodName });
+    return fn;
+  } else {
+    const fn = function (buffer, opts, callback) {
+      if (typeof opts === "function") {
+        callback = opts;
+        opts = {};
+      }
+      return zlibBuffer(new ctor(opts), buffer, callback);
+    };
+    ObjectDefineProperty(fn, "name", { value: methodName });
+    return fn;
+  }
+}
+
+const kMaxBrotliParam = 9;
+
+const brotliInitParamsArray = new Uint32Array(kMaxBrotliParam + 1);
+
+const brotliDefaultOpts = {
+  flush: BROTLI_OPERATION_PROCESS,
+  finishFlush: BROTLI_OPERATION_FINISH,
+  fullFlush: BROTLI_OPERATION_FLUSH,
+};
+function Brotli(opts, mode) {
+  assert(mode === BROTLI_DECODE || mode === BROTLI_ENCODE);
+
+  TypedArrayPrototypeFill.$call(brotliInitParamsArray, -1);
+  if (opts?.params) {
+    ArrayPrototypeForEach.$call(ObjectKeys(opts.params), origKey => {
+      const key = +origKey;
+      if (NumberIsNaN(key) || key < 0 || key > kMaxBrotliParam || (brotliInitParamsArray[key] | 0) !== -1) {
+        throw ERR_BROTLI_INVALID_PARAM(origKey);
+      }
+
+      const value = opts.params[origKey];
+      if (typeof value !== "number" && typeof value !== "boolean") {
+        throw ERR_INVALID_ARG_TYPE("options.params[key]", "number", opts.params[origKey]);
+      }
+      brotliInitParamsArray[key] = value;
+    });
+  }
+
+  const handle = new NativeBrotli(mode);
+
+  this._writeState = new Uint32Array(2);
+  if (!handle.init(brotliInitParamsArray, this._writeState, processCallback)) {
+    throw ERR_ZLIB_INITIALIZATION_FAILED();
+  }
+
+  ZlibBase.$apply(this, [opts, mode, handle, brotliDefaultOpts]);
+}
+$toClass(Brotli, "Brotli", Zlib);
+
+function BrotliCompress(opts) {
+  if (!(this instanceof BrotliCompress)) return new BrotliCompress(opts);
+  Brotli.$apply(this, [opts, BROTLI_ENCODE]);
+}
+$toClass(BrotliCompress, "BrotliCompress", Brotli);
+
+function BrotliDecompress(opts) {
+  if (!(this instanceof BrotliDecompress)) return new BrotliDecompress(opts);
+  Brotli.$apply(this, [opts, BROTLI_DECODE]);
+}
+$toClass(BrotliDecompress, "BrotliDecompress", Brotli);
+
+// Legacy alias on the C++ wrapper object.
+ObjectDefineProperty(NativeZlib.prototype, "jsref", {
+  __proto__: null,
+  get() {
+    return this[owner_symbol];
+  },
+  set(v) {
+    return (this[owner_symbol] = v);
+  },
+});
+
 const zlib = {
+  crc32,
   Deflate,
   Inflate,
   Gzip,
@@ -448,19 +738,114 @@ const zlib = {
   BrotliCompress,
   BrotliDecompress,
 
-  ...functions,
+  deflate: createConvenienceMethod(Deflate, false, "deflate"),
+  deflateSync: createConvenienceMethod(Deflate, true, "deflateSync"),
+  gzip: createConvenienceMethod(Gzip, false, "gzip"),
+  gzipSync: createConvenienceMethod(Gzip, true, "gzipSync"),
+  deflateRaw: createConvenienceMethod(DeflateRaw, false, "deflateRaw"),
+  deflateRawSync: createConvenienceMethod(DeflateRaw, true, "deflateRawSync"),
+  unzip: createConvenienceMethod(Unzip, false, "unzip"),
+  unzipSync: createConvenienceMethod(Unzip, true, "unzipSync"),
+  inflate: createConvenienceMethod(Inflate, false, "inflate"),
+  inflateSync: createConvenienceMethod(Inflate, true, "inflateSync"),
+  gunzip: createConvenienceMethod(Gunzip, false, "gunzip"),
+  gunzipSync: createConvenienceMethod(Gunzip, true, "gunzipSync"),
+  inflateRaw: createConvenienceMethod(InflateRaw, false, "inflateRaw"),
+  inflateRawSync: createConvenienceMethod(InflateRaw, true, "inflateRawSync"),
+  brotliCompress: createConvenienceMethod(BrotliCompress, false, "brotliCompress"),
+  brotliCompressSync: createConvenienceMethod(BrotliCompress, true, "brotliCompressSync"),
+  brotliDecompress: createConvenienceMethod(BrotliDecompress, false, "brotliDecompress"),
+  brotliDecompressSync: createConvenienceMethod(BrotliDecompress, true, "brotliDecompressSync"),
+
+  createDeflate: function (options) {
+    return new Deflate(options);
+  },
+  createInflate: function (options) {
+    return new Inflate(options);
+  },
+  createDeflateRaw: function (options) {
+    return new DeflateRaw(options);
+  },
+  createInflateRaw: function (options) {
+    return new InflateRaw(options);
+  },
+  createGzip: function (options) {
+    return new Gzip(options);
+  },
+  createGunzip: function (options) {
+    return new Gunzip(options);
+  },
+  createUnzip: function (options) {
+    return new Unzip(options);
+  },
+  createBrotliCompress: function (options) {
+    return new BrotliCompress(options);
+  },
+  createBrotliDecompress: function (options) {
+    return new BrotliDecompress(options);
+  },
 };
-Object.defineProperty(zlib, "constants", {
-  writable: false,
-  configurable: false,
-  enumerable: true,
-  value: Object.freeze(constants),
-});
-Object.defineProperty(zlib, "codes", {
-  writable: false,
-  configurable: false,
-  enumerable: true,
-  value: Object.freeze(codes),
+
+ObjectDefineProperties(zlib, {
+  constants: {
+    enumerable: true,
+    value: ObjectFreeze(constants),
+  },
+  codes: {
+    enumerable: true,
+    value: ObjectFreeze(codes),
+  },
 });
 
+// These should be considered deprecated
+// expose all the zlib constants
+{
+  // prettier-ignore
+  const { Z_OK, Z_STREAM_END, Z_NEED_DICT, Z_ERRNO, Z_STREAM_ERROR, Z_DATA_ERROR, Z_MEM_ERROR, Z_BUF_ERROR, Z_VERSION_ERROR, Z_NO_COMPRESSION, Z_BEST_SPEED, Z_BEST_COMPRESSION, Z_DEFAULT_COMPRESSION, Z_FILTERED, Z_HUFFMAN_ONLY, Z_RLE, ZLIB_VERNUM, Z_MAX_CHUNK, Z_DEFAULT_LEVEL } = constants;
+  ObjectDefineProperty(zlib, "Z_NO_FLUSH", { value: Z_NO_FLUSH });
+  ObjectDefineProperty(zlib, "Z_PARTIAL_FLUSH", { value: Z_PARTIAL_FLUSH });
+  ObjectDefineProperty(zlib, "Z_SYNC_FLUSH", { value: Z_SYNC_FLUSH });
+  ObjectDefineProperty(zlib, "Z_FULL_FLUSH", { value: Z_FULL_FLUSH });
+  ObjectDefineProperty(zlib, "Z_FINISH", { value: Z_FINISH });
+  ObjectDefineProperty(zlib, "Z_BLOCK", { value: Z_BLOCK });
+  ObjectDefineProperty(zlib, "Z_OK", { value: Z_OK });
+  ObjectDefineProperty(zlib, "Z_STREAM_END", { value: Z_STREAM_END });
+  ObjectDefineProperty(zlib, "Z_NEED_DICT", { value: Z_NEED_DICT });
+  ObjectDefineProperty(zlib, "Z_ERRNO", { value: Z_ERRNO });
+  ObjectDefineProperty(zlib, "Z_STREAM_ERROR", { value: Z_STREAM_ERROR });
+  ObjectDefineProperty(zlib, "Z_DATA_ERROR", { value: Z_DATA_ERROR });
+  ObjectDefineProperty(zlib, "Z_MEM_ERROR", { value: Z_MEM_ERROR });
+  ObjectDefineProperty(zlib, "Z_BUF_ERROR", { value: Z_BUF_ERROR });
+  ObjectDefineProperty(zlib, "Z_VERSION_ERROR", { value: Z_VERSION_ERROR });
+  ObjectDefineProperty(zlib, "Z_NO_COMPRESSION", { value: Z_NO_COMPRESSION });
+  ObjectDefineProperty(zlib, "Z_BEST_SPEED", { value: Z_BEST_SPEED });
+  ObjectDefineProperty(zlib, "Z_BEST_COMPRESSION", { value: Z_BEST_COMPRESSION });
+  ObjectDefineProperty(zlib, "Z_DEFAULT_COMPRESSION", { value: Z_DEFAULT_COMPRESSION });
+  ObjectDefineProperty(zlib, "Z_FILTERED", { value: Z_FILTERED });
+  ObjectDefineProperty(zlib, "Z_HUFFMAN_ONLY", { value: Z_HUFFMAN_ONLY });
+  ObjectDefineProperty(zlib, "Z_RLE", { value: Z_RLE });
+  ObjectDefineProperty(zlib, "Z_FIXED", { value: Z_FIXED });
+  ObjectDefineProperty(zlib, "Z_DEFAULT_STRATEGY", { value: Z_DEFAULT_STRATEGY });
+  ObjectDefineProperty(zlib, "ZLIB_VERNUM", { value: ZLIB_VERNUM });
+  ObjectDefineProperty(zlib, "DEFLATE", { value: DEFLATE });
+  ObjectDefineProperty(zlib, "INFLATE", { value: INFLATE });
+  ObjectDefineProperty(zlib, "GZIP", { value: GZIP });
+  ObjectDefineProperty(zlib, "GUNZIP", { value: GUNZIP });
+  ObjectDefineProperty(zlib, "DEFLATERAW", { value: DEFLATERAW });
+  ObjectDefineProperty(zlib, "INFLATERAW", { value: INFLATERAW });
+  ObjectDefineProperty(zlib, "UNZIP", { value: UNZIP });
+  ObjectDefineProperty(zlib, "Z_MIN_WINDOWBITS", { value: Z_MIN_WINDOWBITS });
+  ObjectDefineProperty(zlib, "Z_MAX_WINDOWBITS", { value: Z_MAX_WINDOWBITS });
+  ObjectDefineProperty(zlib, "Z_DEFAULT_WINDOWBITS", { value: Z_DEFAULT_WINDOWBITS });
+  ObjectDefineProperty(zlib, "Z_MIN_CHUNK", { value: Z_MIN_CHUNK });
+  ObjectDefineProperty(zlib, "Z_MAX_CHUNK", { value: Z_MAX_CHUNK });
+  ObjectDefineProperty(zlib, "Z_DEFAULT_CHUNK", { value: Z_DEFAULT_CHUNK });
+  ObjectDefineProperty(zlib, "Z_MIN_MEMLEVEL", { value: Z_MIN_MEMLEVEL });
+  ObjectDefineProperty(zlib, "Z_MAX_MEMLEVEL", { value: Z_MAX_MEMLEVEL });
+  ObjectDefineProperty(zlib, "Z_DEFAULT_MEMLEVEL", { value: Z_DEFAULT_MEMLEVEL });
+  ObjectDefineProperty(zlib, "Z_MIN_LEVEL", { value: Z_MIN_LEVEL });
+  ObjectDefineProperty(zlib, "Z_MAX_LEVEL", { value: Z_MAX_LEVEL });
+  ObjectDefineProperty(zlib, "Z_DEFAULT_LEVEL", { value: Z_DEFAULT_LEVEL });
+}
+
 export default zlib;
diff --git a/src/js/thirdparty/detect-libc.musl.js b/src/js/thirdparty/detect-libc.musl.js
new file mode 100644
index 0000000000..7ab932c539
--- /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/thirdparty/node-fetch.ts b/src/js/thirdparty/node-fetch.ts
index d2b5831690..d0676ee418 100644
--- a/src/js/thirdparty/node-fetch.ts
+++ b/src/js/thirdparty/node-fetch.ts
@@ -126,7 +126,7 @@ var ResponsePrototype = Response.prototype;
 const kUrl = Symbol("kUrl");
 
 class Request extends WebRequest {
-  [kUrl]: string;
+  [kUrl]?: string;
 
   constructor(input, init) {
     // node-fetch is relaxed with the URL, for example, it allows "/" as a valid URL.
@@ -137,12 +137,11 @@ class Request extends WebRequest {
       this[kUrl] = input;
     } else {
       super(input, init);
-      this[kUrl] = input.url;
     }
   }
 
   get url() {
-    return this[kUrl];
+    return this[kUrl] ?? super.url;
   }
 }
 
diff --git a/src/js/thirdparty/undici.js b/src/js/thirdparty/undici.js
index b194df4db5..2c9a5fbb62 100644
--- a/src/js/thirdparty/undici.js
+++ b/src/js/thirdparty/undici.js
@@ -16,15 +16,23 @@ const File = bindings[4];
 const URL = bindings[5];
 const AbortSignal = bindings[6];
 const URLSearchParams = bindings[7];
+const WebSocket = bindings[8];
+const CloseEvent = bindings[9];
+const ErrorEvent = bindings[10];
+const MessageEvent = bindings[11];
 
 class FileReader extends EventTarget {
   constructor() {
-    throw new Error("Not implemented yet!");
+    super();
   }
+
+  static EMPTY = 0;
+  static LOADING = 1;
+  static DONE = 2;
 }
 
 function notImplemented() {
-  throw new Error("Not implemented in bun");
+  throw new Error("This function is not yet implemented in Bun");
 }
 
 /**
@@ -230,102 +238,271 @@ async function request(
 }
 
 function stream() {
-  throw new Error("Not implemented in bun");
+  notImplemented();
 }
 function pipeline() {
-  throw new Error("Not implemented in bun");
+  notImplemented();
 }
 function connect() {
-  throw new Error("Not implemented in bun");
+  notImplemented();
 }
 function upgrade() {
-  throw new Error("Not implemented in bun");
+  notImplemented();
 }
 
 class MockClient {
-  constructor() {
-    throw new Error("Not implemented in bun");
-  }
+  constructor() {}
 }
 class MockPool {
-  constructor() {
-    throw new Error("Not implemented in bun");
-  }
+  constructor() {}
 }
 class MockAgent {
-  constructor() {
-    throw new Error("Not implemented in bun");
-  }
+  constructor() {}
 }
 
-function mockErrors() {
-  throw new Error("Not implemented in bun");
-}
-
-function Undici() {
-  throw new Error("Not implemented in bun");
-}
+function mockErrors() {}
 
 class Dispatcher extends EventEmitter {}
 class Agent extends Dispatcher {}
 class Pool extends Dispatcher {
-  request() {
-    throw new Error("Not implemented in bun");
-  }
+  request() {}
 }
 class BalancedPool extends Dispatcher {}
 class Client extends Dispatcher {
-  request() {
-    throw new Error("Not implemented in bun");
+  request() {}
+}
+
+class DispatcherBase extends EventEmitter {}
+
+class ProxyAgent extends DispatcherBase {
+  constructor() {
+    super();
   }
 }
 
-Undici.Dispatcher = Dispatcher;
-Undici.Pool = Pool;
-Undici.BalancedPool = BalancedPool;
-Undici.Client = Client;
-Undici.Agent = Agent;
+class EnvHttpProxyAgent extends DispatcherBase {
+  constructor() {
+    super();
+  }
+}
 
-Undici.buildConnector =
-  Undici.errors =
-  Undici.setGlobalDispatcher =
-  Undici.getGlobalDispatcher =
-  Undici.request =
-  Undici.stream =
-  Undici.pipeline =
-  Undici.connect =
-  Undici.upgrade =
-  Undici.MockClient =
-  Undici.MockPool =
-  Undici.MockAgent =
-  Undici.mockErrors =
-    notImplemented;
+class RetryAgent extends Dispatcher {
+  constructor() {
+    super();
+  }
+}
 
-Undici.fetch = fetch;
+class RetryHandler {
+  constructor() {}
+}
 
-export default {
+class DecoratorHandler {
+  constructor() {}
+}
+
+class RedirectHandler {
+  constructor() {}
+}
+
+function createRedirectInterceptor() {
+  return new RedirectHandler();
+}
+
+const interceptors = {
+  redirect: () => {},
+  retry: () => {},
+  dump: () => {},
+};
+
+// Error classes
+class UndiciError extends Error {}
+class AbortError extends UndiciError {}
+class HTTPParserError extends Error {}
+class HeadersTimeoutError extends UndiciError {}
+class HeadersOverflowError extends UndiciError {}
+class BodyTimeoutError extends UndiciError {}
+class RequestContentLengthMismatchError extends UndiciError {}
+class ConnectTimeoutError extends UndiciError {}
+class ResponseStatusCodeError extends UndiciError {}
+class InvalidArgumentError extends UndiciError {}
+class InvalidReturnValueError extends UndiciError {}
+class RequestAbortedError extends AbortError {}
+class ClientDestroyedError extends UndiciError {}
+class ClientClosedError extends UndiciError {}
+class InformationalError extends UndiciError {}
+class SocketError extends UndiciError {}
+class NotSupportedError extends UndiciError {}
+class ResponseContentLengthMismatchError extends UndiciError {}
+class BalancedPoolMissingUpstreamError extends UndiciError {}
+class ResponseExceededMaxSizeError extends UndiciError {}
+class RequestRetryError extends UndiciError {}
+class SecureProxyConnectionError extends UndiciError {}
+class MockNotMatchedError extends UndiciError {}
+
+const errors = {
+  AbortError,
+  HTTPParserError,
+  UndiciError,
+  HeadersTimeoutError,
+  HeadersOverflowError,
+  BodyTimeoutError,
+  RequestContentLengthMismatchError,
+  ConnectTimeoutError,
+  ResponseStatusCodeError,
+  InvalidArgumentError,
+  InvalidReturnValueError,
+  RequestAbortedError,
+  ClientDestroyedError,
+  ClientClosedError,
+  InformationalError,
+  SocketError,
+  NotSupportedError,
+  ResponseContentLengthMismatchError,
+  BalancedPoolMissingUpstreamError,
+  ResponseExceededMaxSizeError,
+  RequestRetryError,
+  SecureProxyConnectionError,
+};
+
+const util = {
+  parseHeaders: () => {
+    notImplemented();
+  },
+  headerNameToString: () => {
+    notImplemented();
+  },
+};
+
+class EventSource extends EventTarget {
+  static CONNECTING = 0;
+  static OPEN = 1;
+  static CLOSED = 2;
+
+  constructor() {
+    super();
+  }
+}
+
+// Add missing cookie functions
+function deleteCookie() {
+  notImplemented();
+}
+
+function getCookies() {
+  notImplemented();
+}
+
+function getSetCookies() {
+  notImplemented();
+}
+
+function setCookie() {
+  notImplemented();
+}
+
+// Add missing MIME type functions
+function parseMIMEType() {
+  notImplemented();
+}
+
+function serializeAMimeType() {
+  notImplemented();
+}
+
+let globalDispatcher;
+
+// Add missing dispatcher functions
+function setGlobalDispatcher(dispatcher) {
+  globalDispatcher = dispatcher;
+}
+
+function getGlobalDispatcher() {
+  return (globalDispatcher ??= new Dispatcher());
+}
+
+// Add missing origin functions
+function setGlobalOrigin() {}
+
+function getGlobalOrigin() {}
+
+// Create empty CacheStorage
+const caches = {};
+
+/**
+ * Builds a connector function for making network connections
+ * @param {Object} [options] Configuration options for the connector
+ * @param {boolean} [options.rejectUnauthorized] Whether to reject unauthorized SSL/TLS connections
+ * @param {number} [options.connectTimeout] Connection timeout in milliseconds
+ * @param {number} [options.maxCachedSessions] Maximum number of cached TLS sessions
+ * @param {boolean} [options.allowH2] Whether to allow HTTP/2 connections
+ * @returns {function} A connector function
+ */
+function buildConnector(options = {}) {
+  const { rejectUnauthorized = true, connectTimeout, maxCachedSessions = 100, allowH2 = false } = options;
+
+  /**
+   * @param {Object} options
+   * @param {string} options.hostname
+   * @param {number} options.port
+   * @param {string} [options.servername]
+   * @param {AbortSignal} [options.signal]
+   */
+  return function connect({ hostname, port, servername, signal }) {
+    notImplemented();
+  };
+}
+
+// Update the exports to match the exact structure
+const moduleExports = {
   Agent,
   BalancedPool,
+  buildConnector,
+  caches,
   Client,
+  CloseEvent,
   connect,
+  createRedirectInterceptor,
+  DecoratorHandler,
+  deleteCookie,
   Dispatcher,
+  EnvHttpProxyAgent,
+  ErrorEvent,
+  errors,
+  EventSource,
   fetch,
   File,
   FileReader,
   FormData,
+  getCookies,
+  getGlobalDispatcher,
+  getGlobalOrigin,
+  getSetCookies,
   Headers,
+  interceptors,
+  MessageEvent,
   MockAgent,
   MockClient,
   mockErrors,
   MockPool,
+  parseMIMEType,
   pipeline,
   Pool,
-  request,
+  ProxyAgent,
+  RedirectHandler,
   Request,
+  request,
   Response,
+  RetryAgent,
+  RetryHandler,
+  serializeAMimeType,
+  setCookie,
+  setGlobalDispatcher,
+  setGlobalOrigin,
   stream,
-  Undici,
   upgrade,
-  URL,
-  URLSearchParams,
+  util,
+  WebSocket,
 };
+
+moduleExports.default = moduleExports;
+export default moduleExports;
diff --git a/src/js/thirdparty/ws.js b/src/js/thirdparty/ws.js
index 64ea131afd..39143060e5 100644
--- a/src/js/thirdparty/ws.js
+++ b/src/js/thirdparty/ws.js
@@ -59,6 +59,7 @@ class BunWebSocket extends EventEmitter {
   #paused = false;
   #fragments = false;
   #binaryType = "nodebuffer";
+  static [Symbol.toStringTag] = "WebSocket";
 
   // Bitset to track whether event handlers are set.
   #eventId = 0;
@@ -69,9 +70,104 @@ class BunWebSocket extends EventEmitter {
     if (!WebSocket) {
       WebSocket = $cpp("JSWebSocket.cpp", "getWebSocketConstructor");
     }
-    let ws = (this.#ws = new WebSocket(url, protocols));
+
+    if (protocols === undefined) {
+      protocols = [];
+    } else if (!Array.isArray(protocols)) {
+      if (typeof protocols === "object" && protocols !== null) {
+        options = protocols;
+        protocols = [];
+      } else {
+        protocols = [protocols];
+      }
+    }
+
+    let headers;
+    let method = "GET";
+    // https://github.com/websockets/ws/blob/0d1b5e6c4acad16a6b1a1904426eb266a5ba2f72/lib/websocket.js#L741-L747
+    if ($isObject(options)) {
+      headers = options?.headers;
+    }
+
+    const finishRequest = options?.finishRequest;
+    if ($isCallable(finishRequest)) {
+      if (headers) {
+        headers = {
+          __proto__: null,
+          ...headers,
+        };
+      }
+      let lazyRawHeaders;
+      let didCallEnd = false;
+      const nodeHttpClientRequestSimulated = {
+        __proto__: Object.create(EventEmitter.prototype),
+        setHeader: function (name, value) {
+          if (!headers) headers = Object.create(null);
+          headers[name.toLowerCase()] = value;
+        },
+        getHeader: function (name) {
+          return headers ? headers[name.toLowerCase()] : undefined;
+        },
+        removeHeader: function (name) {
+          if (headers) delete headers[name.toLowerCase()];
+        },
+        getHeaders: function () {
+          return { ...headers };
+        },
+        hasHeader: function (name) {
+          return headers ? name.toLowerCase() in headers : false;
+        },
+        headersSent: false,
+        method: method,
+        path: url,
+        abort: function () {
+          // No-op for now, as we don't have a real request to abort
+        },
+        end: () => {
+          if (!didCallEnd) {
+            didCallEnd = true;
+            this.#createWebSocket(url, protocols, headers, method);
+          }
+        },
+        write() {},
+        writeHead() {},
+        [Symbol.toStringTag]: "ClientRequest",
+        get rawHeaders() {
+          if (lazyRawHeaders === undefined) {
+            lazyRawHeaders = [];
+            for (const key in headers) {
+              lazyRawHeaders.push(key, headers[key]);
+            }
+          }
+          return lazyRawHeaders;
+        },
+        set rawHeaders(value) {
+          lazyRawHeaders = value;
+        },
+        rawTrailers: [],
+        trailers: null,
+        finished: false,
+        socket: undefined,
+        _header: null,
+        _headerSent: false,
+        _last: null,
+      };
+      EventEmitter.$call(nodeHttpClientRequestSimulated);
+      finishRequest(nodeHttpClientRequestSimulated);
+      if (!didCallEnd) {
+        this.#createWebSocket(url, protocols, headers, method);
+      }
+      return;
+    }
+
+    this.#createWebSocket(url, protocols, headers, method);
+  }
+
+  #createWebSocket(url, protocols, headers, method) {
+    let ws = (this.#ws = new WebSocket(url, headers ? { headers, method, protocols } : protocols));
     ws.binaryType = "nodebuffer";
-    // TODO: options
+
+    return ws;
   }
 
   #onOrOnce(event, listener, once) {
diff --git a/src/js_ast.zig b/src/js_ast.zig
index bbd318cbe6..ce24d226f5 100644
--- a/src/js_ast.zig
+++ b/src/js_ast.zig
@@ -12,8 +12,8 @@ const MutableString = bun.MutableString;
 const stringZ = bun.stringZ;
 const default_allocator = bun.default_allocator;
 const C = bun.C;
-const Ref = @import("ast/base.zig").Ref;
-const Index = @import("ast/base.zig").Index;
+pub const Ref = @import("ast/base.zig").Ref;
+pub const Index = @import("ast/base.zig").Index;
 const RefHashCtx = @import("ast/base.zig").RefHashCtx;
 const ObjectPool = @import("./pool.zig").ObjectPool;
 const ImportRecord = @import("import_record.zig").ImportRecord;
@@ -28,6 +28,7 @@ const js_lexer = @import("./js_lexer.zig");
 const TypeScript = @import("./js_parser.zig").TypeScript;
 const ThreadlocalArena = @import("./mimalloc_arena.zig").Arena;
 const MimeType = bun.http.MimeType;
+const OOM = bun.OOM;
 
 /// This is the index to the automatically-generated part containing code that
 /// calls "__export(exports, { ... getters ... })". This is used to generate
@@ -552,7 +553,7 @@ pub const B = union(Binding.Tag) {
 };
 
 pub const ClauseItem = struct {
-    alias: string = "",
+    alias: string,
     alias_loc: logger.Loc = logger.Loc.Empty,
     name: LocRef,
 
@@ -838,16 +839,15 @@ pub const G = struct {
     };
 
     pub const Property = struct {
-
-        // This is used when parsing a pattern that uses default values:
-        //
-        //   [a = 1] = [];
-        //   ({a = 1} = {});
-        //
-        // It's also used for class fields:
-        //
-        //   class Foo { a = 1 }
-        //
+        /// This is used when parsing a pattern that uses default values:
+        ///
+        ///   [a = 1] = [];
+        ///   ({a = 1} = {});
+        ///
+        /// It's also used for class fields:
+        ///
+        ///   class Foo { a = 1 }
+        ///
         initializer: ?ExprNodeIndex = null,
         kind: Kind = .normal,
         flags: Flags.Property.Set = Flags.Property.None,
@@ -1153,55 +1153,53 @@ pub const Symbol = struct {
     }
 
     pub const Kind = enum {
-
-        // An unbound symbol is one that isn't declared in the file it's referenced
-        // in. For example, using "window" without declaring it will be unbound.
+        /// An unbound symbol is one that isn't declared in the file it's referenced
+        /// in. For example, using "window" without declaring it will be unbound.
         unbound,
 
-        // This has special merging behavior. You're allowed to re-declare these
-        // symbols more than once in the same scope. These symbols are also hoisted
-        // out of the scope they are declared in to the closest containing function
-        // or module scope. These are the symbols with this kind:
-        //
-        // - Function arguments
-        // - Function statements
-        // - Variables declared using "var"
-        //
+        /// This has special merging behavior. You're allowed to re-declare these
+        /// symbols more than once in the same scope. These symbols are also hoisted
+        /// out of the scope they are declared in to the closest containing function
+        /// or module scope. These are the symbols with this kind:
+        ///
+        /// - Function arguments
+        /// - Function statements
+        /// - Variables declared using "var"
         hoisted,
         hoisted_function,
 
-        // There's a weird special case where catch variables declared using a simple
-        // identifier (i.e. not a binding pattern) block hoisted variables instead of
-        // becoming an error:
-        //
-        //   var e = 0;
-        //   try { throw 1 } catch (e) {
-        //     print(e) // 1
-        //     var e = 2
-        //     print(e) // 2
-        //   }
-        //   print(e) // 0 (since the hoisting stops at the catch block boundary)
-        //
-        // However, other forms are still a syntax error:
-        //
-        //   try {} catch (e) { let e }
-        //   try {} catch ({e}) { var e }
-        //
-        // This symbol is for handling this weird special case.
+        /// There's a weird special case where catch variables declared using a simple
+        /// identifier (i.e. not a binding pattern) block hoisted variables instead of
+        /// becoming an error:
+        ///
+        ///   var e = 0;
+        ///   try { throw 1 } catch (e) {
+        ///     print(e) // 1
+        ///     var e = 2
+        ///     print(e) // 2
+        ///   }
+        ///   print(e) // 0 (since the hoisting stops at the catch block boundary)
+        ///
+        /// However, other forms are still a syntax error:
+        ///
+        ///   try {} catch (e) { let e }
+        ///   try {} catch ({e}) { var e }
+        ///
+        /// This symbol is for handling this weird special case.
         catch_identifier,
 
-        // Generator and async functions are not hoisted, but still have special
-        // properties such as being able to overwrite previous functions with the
-        // same name
+        /// Generator and async functions are not hoisted, but still have special
+        /// properties such as being able to overwrite previous functions with the
+        /// same name
         generator_or_async_function,
 
-        // This is the special "arguments" variable inside functions
+        /// This is the special "arguments" variable inside functions
         arguments,
 
-        // Classes can merge with TypeScript namespaces.
+        /// Classes can merge with TypeScript namespaces.
         class,
 
-        // A class-private identifier (i.e. "#foo").
+        /// A class-private identifier (i.e. "#foo").
         private_field,
         private_method,
         private_get,
@@ -1213,25 +1211,26 @@ pub const Symbol = struct {
         private_static_set,
         private_static_get_set_pair,
 
-        // Labels are in their own namespace
+        /// Labels are in their own namespace
         label,
 
-        // TypeScript enums can merge with TypeScript namespaces and other TypeScript
-        // enums.
+        /// TypeScript enums can merge with TypeScript namespaces and other TypeScript
+        /// enums.
         ts_enum,
 
-        // TypeScript namespaces can merge with classes, functions, TypeScript enums,
-        // and other TypeScript namespaces.
+        /// TypeScript namespaces can merge with classes, functions, TypeScript enums,
+        /// and other TypeScript namespaces.
         ts_namespace,
 
-        // In TypeScript, imports are allowed to silently collide with symbols within
-        // the module. Presumably this is because the imports may be type-only.
+        /// In TypeScript, imports are allowed to silently collide with symbols within
+        /// the module. Presumably this is because the imports may be type-only.
+        /// Import statement namespace references should NOT have this set.
         import,
 
-        // Assigning to a "const" symbol will throw a TypeError at runtime
+        /// Assigning to a "const" symbol will throw a TypeError at runtime
         constant,
 
-        // This annotates all other symbols that don't have special behavior.
+        /// This annotates all other symbols that don't have special behavior.
         other,
 
         pub fn jsonStringify(self: @This(), writer: anytype) !void {
@@ -1294,7 +1293,7 @@ pub const Symbol = struct {
         // single inner array, so you can join the maps together by just make a
         // single outer array containing all of the inner arrays. See the comment on
         // "Ref" for more detail.
-        symbols_for_source: NestedList = NestedList{},
+        symbols_for_source: NestedList = .{},
 
         pub fn dump(this: Map) void {
             defer Output.flush();
@@ -1428,21 +1427,6 @@ pub const Symbol = struct {
     pub inline fn isHoisted(self: *const Symbol) bool {
         return Symbol.isKindHoisted(self.kind);
     }
-
-    pub fn isReactComponentishName(symbol: *const Symbol) bool {
-        switch (symbol.kind) {
-            .hoisted, .hoisted_function, .constant, .class, .other => {
-                return switch (symbol.original_name[0]) {
-                    'A'...'Z' => true,
-                    else => false,
-                };
-            },
-
-            else => {
-                return false;
-            },
-        }
-    }
 };
 
 pub const OptionalChain = enum(u1) {
@@ -1459,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,
@@ -1519,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;
@@ -1548,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,
@@ -1566,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);
         }
     };
@@ -1925,7 +1901,6 @@ pub const E = struct {
         pub const Rope = struct {
             head: Expr,
             next: ?*Rope = null,
-            const OOM = error{OutOfMemory};
             pub fn append(this: *Rope, expr: Expr, allocator: std.mem.Allocator) OOM!*Rope {
                 if (this.next) |next| {
                     return try next.append(expr, allocator);
@@ -1938,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();
@@ -1978,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;
@@ -2268,6 +2217,7 @@ pub const E = struct {
     pub const String = struct {
         // A version of this where `utf8` and `value` are stored in a packed union, with len as a single u32 was attempted.
         // It did not improve benchmarks. Neither did converting this from a heap-allocated type to a stack-allocated type.
+        // TODO: change this to *const anyopaque and change all uses to either .slice8() or .slice16()
         data: []const u8 = "",
         prefer_template: bool = false,
 
@@ -2363,6 +2313,11 @@ pub const E = struct {
                 init(bun.strings.toUTF16AllocForReal(allocator, utf8, false, false) catch bun.outOfMemory());
         }
 
+        pub fn slice8(this: *const String) []const u8 {
+            bun.assert(!this.is_utf16);
+            return this.data;
+        }
+
         pub fn slice16(this: *const String) []const u16 {
             bun.assert(this.is_utf16);
             return @as([*]const u16, @ptrCast(@alignCast(this.data.ptr)))[0..this.data.len];
@@ -2415,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 {
@@ -2508,7 +2461,7 @@ pub const E = struct {
                 strings.eqlComptimeUTF16(s.slice16()[0..value.len], value);
         }
 
-        pub fn string(s: *const String, allocator: std.mem.Allocator) !bun.string {
+        pub fn string(s: *const String, allocator: std.mem.Allocator) OOM!bun.string {
             if (s.isUTF8()) {
                 return s.data;
             } else {
@@ -2516,7 +2469,7 @@ pub const E = struct {
             }
         }
 
-        pub fn stringZ(s: *const String, allocator: std.mem.Allocator) !bun.stringZ {
+        pub fn stringZ(s: *const String, allocator: std.mem.Allocator) OOM!bun.stringZ {
             if (s.isUTF8()) {
                 return allocator.dupeZ(u8, s.data);
             } else {
@@ -2524,20 +2477,14 @@ pub const E = struct {
             }
         }
 
-        pub fn stringCloned(s: *const String, allocator: std.mem.Allocator) !bun.string {
+        pub fn stringCloned(s: *const String, allocator: std.mem.Allocator) OOM!bun.string {
             if (s.isUTF8()) {
-                return try allocator.dupe(u8, s.data);
+                return allocator.dupe(u8, s.data);
             } else {
                 return strings.toUTF8Alloc(allocator, s.slice16());
             }
         }
 
-        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;
 
@@ -2550,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 {
@@ -3257,6 +3202,14 @@ pub const Stmt = struct {
         };
     };
 
+    pub fn StoredData(tag: Tag) type {
+        const T = std.meta.FieldType(Data, tag);
+        return switch (@typeInfo(T)) {
+            .Pointer => |ptr| ptr.child,
+            else => T,
+        };
+    }
+
     pub fn caresAboutScope(self: *Stmt) bool {
         return switch (self.data) {
             .s_block, .s_empty, .s_debugger, .s_expr, .s_if, .s_for, .s_for_in, .s_for_of, .s_do_while, .s_while, .s_with, .s_try, .s_switch, .s_return, .s_throw, .s_break, .s_continue, .s_directive => {
@@ -3352,7 +3305,7 @@ pub const Expr = struct {
 
         if (mime_type.category == .json) {
             var source = logger.Source.initPathString("fetch.json", bytes);
-            var out_expr = JSONParser.ParseJSONForMacro(&source, log, allocator) catch {
+            var out_expr = JSONParser.parseForMacro(&source, log, allocator) catch {
                 return error.MacroFailed;
             };
             out_expr.loc = loc;
@@ -3423,14 +3376,117 @@ 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 {
+        return this.data == .e_array;
+    }
+
+    pub inline fn isObject(this: *const Expr) bool {
+        return this.data == .e_object;
     }
 
     pub fn get(expr: *const Expr, name: string) ?Expr {
         return if (asProperty(expr, name)) |query| query.expr else null;
     }
 
+    /// Don't use this if you care about performance.
+    ///
+    /// Sets the value of a property, creating it if it doesn't exist.
+    /// `expr` must be an object.
+    pub fn set(expr: *Expr, allocator: std.mem.Allocator, name: string, value: Expr) OOM!void {
+        bun.assertWithLocation(expr.isObject(), @src());
+        for (0..expr.data.e_object.properties.len) |i| {
+            const prop = &expr.data.e_object.properties.ptr[i];
+            const key = prop.key orelse continue;
+            if (std.meta.activeTag(key.data) != .e_string) continue;
+            if (key.data.e_string.eql(string, name)) {
+                prop.value = value;
+                return;
+            }
+        }
+
+        var new_props = expr.data.e_object.properties.listManaged(allocator);
+        try new_props.append(.{
+            .key = Expr.init(E.String, .{ .data = name }, logger.Loc.Empty),
+            .value = value,
+        });
+
+        expr.data.e_object.properties = BabyList(G.Property).fromList(new_props);
+    }
+
+    /// Don't use this if you care about performance.
+    ///
+    /// Sets the value of a property to a string, creating it if it doesn't exist.
+    /// `expr` must be an object.
+    pub fn setString(expr: *Expr, allocator: std.mem.Allocator, name: string, value: string) OOM!void {
+        bun.assertWithLocation(expr.isObject(), @src());
+        for (0..expr.data.e_object.properties.len) |i| {
+            const prop = &expr.data.e_object.properties.ptr[i];
+            const key = prop.key orelse continue;
+            if (std.meta.activeTag(key.data) != .e_string) continue;
+            if (key.data.e_string.eql(string, name)) {
+                prop.value = Expr.init(E.String, .{ .data = value }, logger.Loc.Empty);
+                return;
+            }
+        }
+
+        var new_props = expr.data.e_object.properties.listManaged(allocator);
+        try new_props.append(.{
+            .key = Expr.init(E.String, .{ .data = name }, logger.Loc.Empty),
+            .value = Expr.init(E.String, .{ .data = value }, logger.Loc.Empty),
+        });
+
+        expr.data.e_object.properties = BabyList(G.Property).fromList(new_props);
+    }
+
+    pub fn getObject(expr: *const Expr, name: string) ?Expr {
+        if (expr.asProperty(name)) |query| {
+            if (query.expr.isObject()) {
+                return query.expr;
+            }
+        }
+        return null;
+    }
+
+    pub fn getString(expr: *const Expr, allocator: std.mem.Allocator, name: string) OOM!?struct { string, logger.Loc } {
+        if (asProperty(expr, name)) |q| {
+            if (q.expr.asString(allocator)) |str| {
+                return .{
+                    str,
+                    q.expr.loc,
+                };
+            }
+        }
+        return null;
+    }
+
+    pub fn getNumber(expr: *const Expr, name: string) ?struct { f64, logger.Loc } {
+        if (asProperty(expr, name)) |q| {
+            if (q.expr.asNumber()) |num| {
+                return .{
+                    num,
+                    q.expr.loc,
+                };
+            }
+        }
+        return null;
+    }
+
+    pub fn getStringCloned(expr: *const Expr, allocator: std.mem.Allocator, name: string) OOM!?string {
+        return if (asProperty(expr, name)) |q| q.expr.asStringCloned(allocator) else null;
+    }
+
+    pub fn getStringClonedZ(expr: *const Expr, allocator: std.mem.Allocator, name: string) OOM!?stringZ {
+        return if (asProperty(expr, name)) |q| q.expr.asStringZ(allocator) else null;
+    }
+
+    pub fn getArray(expr: *const Expr, name: string) ?ArrayIterator {
+        return if (asProperty(expr, name)) |q| q.expr.asArray() else null;
+    }
+
     pub fn getRope(self: *const Expr, rope: *const E.Object.Rope) ?E.Object.RopeQuery {
         if (self.get(rope.head.data.e_string.data)) |existing| {
             switch (existing.data) {
@@ -3477,6 +3533,39 @@ pub const Expr = struct {
         return obj.asProperty(name);
     }
 
+    pub fn asPropertyStringMap(expr: *const Expr, name: string, allocator: std.mem.Allocator) ?*bun.StringArrayHashMap(string) {
+        if (std.meta.activeTag(expr.data) != .e_object) return null;
+        const obj_ = expr.data.e_object;
+        if (@intFromPtr(obj_.properties.ptr) == 0) return null;
+        const query = obj_.asProperty(name) orelse return null;
+        if (query.expr.data != .e_object) return null;
+
+        const obj = query.expr.data.e_object;
+        var count: usize = 0;
+        for (obj.properties.slice()) |prop| {
+            const key = prop.key.?.asString(allocator) orelse continue;
+            const value = prop.value.?.asString(allocator) orelse continue;
+            count += @as(usize, @intFromBool(key.len > 0 and value.len > 0));
+        }
+
+        if (count == 0) return null;
+        var map = bun.StringArrayHashMap(string).init(allocator);
+        map.ensureUnusedCapacity(count) catch return null;
+
+        for (obj.properties.slice()) |prop| {
+            const key = prop.key.?.asString(allocator) orelse continue;
+            const value = prop.value.?.asString(allocator) orelse continue;
+
+            if (!(key.len > 0 and value.len > 0)) continue;
+
+            map.putAssumeCapacity(key, value);
+        }
+
+        const ptr = allocator.create(bun.StringArrayHashMap(string)) catch unreachable;
+        ptr.* = map;
+        return ptr;
+    }
+
     pub const ArrayIterator = struct {
         array: *const E.Array,
         index: u32,
@@ -3513,7 +3602,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,
         };
     }
@@ -3521,35 +3610,31 @@ 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,
         }
     }
-    pub inline fn asStringHash(expr: *const Expr, allocator: std.mem.Allocator, comptime hash_fn: *const fn (buf: []const u8) callconv(.Inline) u64) ?u64 {
+    pub inline fn asStringHash(expr: *const Expr, allocator: std.mem.Allocator, comptime hash_fn: *const fn (buf: []const u8) callconv(.Inline) u64) OOM!?u64 {
         switch (expr.data) {
             .e_string => |str| {
                 if (str.isUTF8()) return hash_fn(str.data);
-                const utf8_str = str.string(allocator) catch return null;
+                const utf8_str = try str.string(allocator);
                 defer allocator.free(utf8_str);
                 return hash_fn(utf8_str);
             },
-            .e_utf8_string => |str| return hash_fn(str.data),
             else => return null,
         }
     }
 
-    pub inline fn asStringCloned(expr: *const Expr, allocator: std.mem.Allocator) ?string {
+    pub inline fn asStringCloned(expr: *const Expr, allocator: std.mem.Allocator) OOM!?string {
         switch (expr.data) {
-            .e_string => |str| return str.stringCloned(allocator) catch bun.outOfMemory(),
-            .e_utf8_string => |str| return allocator.dupe(u8, str.data) catch bun.outOfMemory(),
+            .e_string => |str| return try str.stringCloned(allocator),
             else => return null,
         }
     }
 
-    pub inline fn asStringZ(expr: *const Expr, allocator: std.mem.Allocator) ?stringZ {
+    pub inline fn asStringZ(expr: *const Expr, allocator: std.mem.Allocator) OOM!?stringZ {
         switch (expr.data) {
-            .e_string => |str| return str.stringZ(allocator) catch bun.outOfMemory(),
-            .e_utf8_string => |str| return allocator.dupeZ(u8, str.data) catch bun.outOfMemory(),
+            .e_string => |str| return try str.stringZ(allocator),
             else => return null,
         }
     }
@@ -3562,6 +3647,12 @@ pub const Expr = struct {
         return expr.data.e_boolean.value;
     }
 
+    pub fn asNumber(expr: *const Expr) ?f64 {
+        if (expr.data != .e_number) return null;
+
+        return expr.data.e_number.value;
+    }
+
     pub const EFlags = enum { none, ts_decorator };
 
     const Serializable = struct {
@@ -3725,18 +3816,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,
@@ -4147,14 +4226,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,
@@ -4538,9 +4609,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) {
@@ -5234,7 +5302,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
@@ -5694,9 +5761,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,
@@ -5756,7 +5820,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,
@@ -5904,9 +5967,10 @@ pub const Expr = struct {
                 .e_undefined => std.math.nan(f64),
                 .e_string => |str| {
                     if (str.next != null) return null;
+                    if (!str.isUTF8()) return null;
 
                     // +'1' => 1
-                    return stringToEquivalentNumberValue(str.data);
+                    return stringToEquivalentNumberValue(str.slice8());
                 },
                 .e_boolean => @as(f64, if (data.e_boolean.value) 1.0 else 0.0),
                 .e_number => data.e_number.value,
@@ -5914,9 +5978,10 @@ pub const Expr = struct {
                     .e_number => |num| num.value,
                     .e_string => |str| {
                         if (str.next != null) return null;
+                        if (!str.isUTF8()) return null;
 
                         // +'1' => 1
-                        return stringToEquivalentNumberValue(str.data);
+                        return stringToEquivalentNumberValue(str.slice8());
                     },
                     else => null,
                 },
@@ -6156,12 +6221,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)
@@ -6171,7 +6235,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,
@@ -6217,7 +6281,6 @@ pub const Expr = struct {
                 E.Template,
                 E.TemplatePart,
                 E.Unary,
-                E.UTF8String,
                 E.Yield,
             }, 512);
 
@@ -6265,6 +6328,14 @@ pub const Expr = struct {
             return @as(Expr.Tag, self) == .e_string;
         }
     };
+
+    pub fn StoredData(tag: Tag) type {
+        const T = std.meta.FieldType(Data, tag);
+        return switch (@typeInfo(T)) {
+            .Pointer => |ptr| ptr.child,
+            else => T,
+        };
+    }
 };
 
 pub const EnumValue = struct {
@@ -6437,7 +6508,7 @@ pub const S = struct {
         // when converting this module to a CommonJS module.
         namespace_ref: Ref,
         default_name: ?LocRef = null,
-        items: []ClauseItem = &([_]ClauseItem{}),
+        items: []ClauseItem = &.{},
         star_name_loc: ?logger.Loc = null,
         import_record_index: u32,
         is_single_line: bool = false,
@@ -6806,7 +6877,6 @@ pub const Ast = struct {
 
     runtime_import_record_id: ?u32 = null,
     needs_runtime: bool = false,
-    externals: []u32 = &[_]u32{},
     // This is a list of CommonJS features. When a file uses CommonJS features,
     // it's not a candidate for "flat bundling" and must be wrapped in its own
     // closure.
@@ -6831,7 +6901,6 @@ pub const Ast = struct {
 
     hashbang: string = "",
     directive: ?string = null,
-    url_for_css: ?string = null,
     parts: Part.List = Part.List{},
     // This list may be mutated later, so we should store the capacity
     symbols: Symbol.List = Symbol.List{},
@@ -6847,11 +6916,11 @@ pub const Ast = struct {
     // These are used when bundling. They are filled in during the parser pass
     // since we already have to traverse the AST then anyway and the parser pass
     // is conveniently fully parallelized.
-    named_imports: NamedImports = NamedImports.init(bun.failing_allocator),
-    named_exports: NamedExports = NamedExports.init(bun.failing_allocator),
+    named_imports: NamedImports = .{},
+    named_exports: NamedExports = .{},
     export_star_import_records: []u32 = &([_]u32{}),
 
-    allocator: std.mem.Allocator,
+    // allocator: std.mem.Allocator,
     top_level_symbols_to_parts: TopLevelSymbolToParts = .{},
 
     commonjs_named_exports: CommonJSNamedExports = .{},
@@ -6875,15 +6944,14 @@ pub const Ast = struct {
     };
     pub const CommonJSNamedExports = bun.StringArrayHashMapUnmanaged(CommonJSNamedExport);
 
-    pub const NamedImports = std.ArrayHashMap(Ref, NamedImport, RefHashCtx, true);
-    pub const NamedExports = bun.StringArrayHashMap(NamedExport);
+    pub const NamedImports = std.ArrayHashMapUnmanaged(Ref, NamedImport, RefHashCtx, true);
+    pub const NamedExports = bun.StringArrayHashMapUnmanaged(NamedExport);
     pub const ConstValuesMap = std.ArrayHashMapUnmanaged(Ref, Expr, RefHashCtx, false);
     pub const TsEnumsMap = std.ArrayHashMapUnmanaged(Ref, bun.StringHashMapUnmanaged(InlinedEnumValue), RefHashCtx, false);
 
     pub fn fromParts(parts: []Part) Ast {
         return Ast{
             .parts = Part.List.init(parts),
-            .allocator = bun.default_allocator,
             .runtime_imports = .{},
         };
     }
@@ -6891,12 +6959,11 @@ pub const Ast = struct {
     pub fn initTest(parts: []Part) Ast {
         return Ast{
             .parts = Part.List.init(parts),
-            .allocator = bun.default_allocator,
             .runtime_imports = .{},
         };
     }
 
-    pub const empty = Ast{ .parts = Part.List{}, .runtime_imports = .{}, .allocator = bun.default_allocator };
+    pub const empty = Ast{ .parts = Part.List{}, .runtime_imports = .{} };
 
     pub fn toJSON(self: *const Ast, _: std.mem.Allocator, stream: anytype) !void {
         const opts = std.json.StringifyOptions{ .whitespace = std.json.StringifyOptions.Whitespace{
@@ -6909,12 +6976,18 @@ pub const Ast = struct {
     pub fn deinit(this: *Ast) void {
         // TODO: assert mimalloc-owned memory
         if (this.parts.len > 0) this.parts.deinitWithAllocator(bun.default_allocator);
-        if (this.externals.len > 0) bun.default_allocator.free(this.externals);
         if (this.symbols.len > 0) this.symbols.deinitWithAllocator(bun.default_allocator);
         if (this.import_records.len > 0) this.import_records.deinitWithAllocator(bun.default_allocator);
     }
 };
 
+/// TLA => Top Level Await
+pub const TlaCheck = struct {
+    depth: u32 = 0,
+    parent: Index.Int = Index.invalid.get(),
+    import_record_index: Index.Int = Index.invalid.get(),
+};
+
 /// Like Ast but slimmer and for bundling only.
 ///
 /// On Linux, the hottest function in the bundler is:
@@ -6924,43 +6997,44 @@ pub const Ast = struct {
 /// So we make a slimmer version of Ast for bundling that doesn't allocate as much memory
 pub const BundledAst = struct {
     approximate_newline_count: u32 = 0,
-    nested_scope_slot_counts: SlotCounts = SlotCounts{},
-    externals: []u32 = &[_]u32{},
+    nested_scope_slot_counts: SlotCounts = .{},
 
-    exports_kind: ExportsKind = ExportsKind.none,
+    exports_kind: ExportsKind = .none,
 
     /// These are stored at the AST level instead of on individual AST nodes so
     /// they can be manipulated efficiently without a full AST traversal
     import_records: ImportRecord.List = .{},
 
     hashbang: string = "",
-    directive: string = "",
-    url_for_css: string = "",
-    parts: Part.List = Part.List{},
-    // This list may be mutated later, so we should store the capacity
-    symbols: Symbol.List = Symbol.List{},
-    module_scope: Scope = Scope{},
+    parts: Part.List = .{},
+    css: ?*bun.css.BundlerStyleSheet = null,
+    url_for_css: ?[]const u8 = null,
+    symbols: Symbol.List = .{},
+    module_scope: Scope = .{},
     char_freq: CharFreq = undefined,
     exports_ref: Ref = Ref.None,
     module_ref: Ref = Ref.None,
     wrapper_ref: Ref = Ref.None,
     require_ref: Ref = Ref.None,
+    top_level_await_keyword: logger.Range,
+    tla_check: TlaCheck = .{},
 
     // These are used when bundling. They are filled in during the parser pass
     // since we already have to traverse the AST then anyway and the parser pass
     // is conveniently fully parallelized.
-    named_imports: NamedImports = NamedImports.init(bun.failing_allocator),
-    named_exports: NamedExports = NamedExports.init(bun.failing_allocator),
-    export_star_import_records: []u32 = &([_]u32{}),
+    named_imports: NamedImports = .{},
+    named_exports: NamedExports = .{},
+    export_star_import_records: []u32 = &.{},
 
-    allocator: std.mem.Allocator,
     top_level_symbols_to_parts: TopLevelSymbolToParts = .{},
 
     commonjs_named_exports: CommonJSNamedExports = .{},
 
     redirect_import_record_index: u32 = std.math.maxInt(u32),
 
-    /// Only populated when bundling
+    /// Only populated when bundling. When --server-components is passed, this
+    /// will be .browser when it is a client component, and the server's target
+    /// on the server.
     target: bun.options.Target = .browser,
 
     // const_values: ConstValuesMap = .{},
@@ -6986,8 +7060,7 @@ pub const BundledAst = struct {
         force_cjs_to_esm: bool = false,
         has_lazy_export: bool = false,
         commonjs_module_exports_assigned_deoptimized: bool = false,
-
-        _: u1 = 0,
+        has_explicit_use_strict_directive: bool = false,
     };
 
     pub const empty = BundledAst.init(Ast.empty);
@@ -6996,15 +7069,12 @@ pub const BundledAst = struct {
         return .{
             .approximate_newline_count = this.approximate_newline_count,
             .nested_scope_slot_counts = this.nested_scope_slot_counts,
-            .externals = this.externals,
 
             .exports_kind = this.exports_kind,
 
             .import_records = this.import_records,
 
             .hashbang = this.hashbang,
-            .directive = this.directive,
-            // .url_for_css = this.url_for_css,
             .parts = this.parts,
             // This list may be mutated later, so we should store the capacity
             .symbols = this.symbols,
@@ -7014,6 +7084,7 @@ pub const BundledAst = struct {
             .module_ref = this.module_ref,
             .wrapper_ref = this.wrapper_ref,
             .require_ref = this.require_ref,
+            .top_level_await_keyword = this.top_level_await_keyword,
 
             // These are used when bundling. They are filled in during the parser pass
             // since we already have to traverse the AST then anyway and the parser pass
@@ -7022,7 +7093,6 @@ pub const BundledAst = struct {
             .named_exports = this.named_exports,
             .export_star_import_records = this.export_star_import_records,
 
-            .allocator = this.allocator,
             .top_level_symbols_to_parts = this.top_level_symbols_to_parts,
 
             .commonjs_named_exports = this.commonjs_named_exports,
@@ -7041,6 +7111,7 @@ pub const BundledAst = struct {
             .force_cjs_to_esm = this.flags.force_cjs_to_esm,
             .has_lazy_export = this.flags.has_lazy_export,
             .commonjs_module_exports_assigned_deoptimized = this.flags.commonjs_module_exports_assigned_deoptimized,
+            .directive = if (this.flags.has_explicit_use_strict_directive) "use strict" else null,
         };
     }
 
@@ -7048,14 +7119,12 @@ pub const BundledAst = struct {
         return .{
             .approximate_newline_count = @as(u32, @truncate(ast.approximate_newline_count)),
             .nested_scope_slot_counts = ast.nested_scope_slot_counts,
-            .externals = ast.externals,
 
             .exports_kind = ast.exports_kind,
 
             .import_records = ast.import_records,
 
             .hashbang = ast.hashbang,
-            .directive = ast.directive orelse "",
             // .url_for_css = ast.url_for_css orelse "",
             .parts = ast.parts,
             // This list may be mutated later, so we should store the capacity
@@ -7066,7 +7135,7 @@ pub const BundledAst = struct {
             .module_ref = ast.module_ref,
             .wrapper_ref = ast.wrapper_ref,
             .require_ref = ast.require_ref,
-
+            .top_level_await_keyword = ast.top_level_await_keyword,
             // These are used when bundling. They are filled in during the parser pass
             // since we already have to traverse the AST then anyway and the parser pass
             // is conveniently fully parallelized.
@@ -7074,7 +7143,7 @@ pub const BundledAst = struct {
             .named_exports = ast.named_exports,
             .export_star_import_records = ast.export_star_import_records,
 
-            .allocator = ast.allocator,
+            // .allocator = ast.allocator,
             .top_level_symbols_to_parts = ast.top_level_symbols_to_parts,
 
             .commonjs_named_exports = ast.commonjs_named_exports,
@@ -7095,9 +7164,42 @@ pub const BundledAst = struct {
                 .force_cjs_to_esm = ast.force_cjs_to_esm,
                 .has_lazy_export = ast.has_lazy_export,
                 .commonjs_module_exports_assigned_deoptimized = ast.commonjs_module_exports_assigned_deoptimized,
+                .has_explicit_use_strict_directive = strings.eqlComptime(ast.directive orelse "", "use strict"),
             },
         };
     }
+
+    /// TODO: I don't like having to do this extra allocation. Is there a way to only do this if we know it is imported by a CSS file?
+    pub fn addUrlForCss(
+        this: *BundledAst,
+        allocator: std.mem.Allocator,
+        css_enabled: bool,
+        source: *const logger.Source,
+        mime_type_: ?[]const u8,
+        unique_key: ?[]const u8,
+    ) void {
+        if (css_enabled) {
+            const mime_type = if (mime_type_) |m| m else MimeType.byExtension(bun.strings.trimLeadingChar(std.fs.path.extension(source.path.text), '.')).value;
+            const contents = source.contents;
+            // TODO: make this configurable
+            const COPY_THRESHOLD = 128 * 1024; // 128kb
+            const should_copy = contents.len >= COPY_THRESHOLD and unique_key != null;
+            this.url_for_css = url_for_css: {
+                // Copy it
+                if (should_copy) break :url_for_css unique_key.?;
+
+                // Encode as base64
+                const encode_len = bun.base64.encodeLen(contents);
+                if (encode_len == 0) return;
+                const data_url_prefix_len = "data:".len + mime_type.len + ";base64,".len;
+                const total_buffer_len = data_url_prefix_len + encode_len;
+                var encoded = allocator.alloc(u8, total_buffer_len) catch bun.outOfMemory();
+                _ = std.fmt.bufPrint(encoded[0..data_url_prefix_len], "data:{s};base64,", .{mime_type}) catch unreachable;
+                const len = bun.base64.encode(encoded[data_url_prefix_len..], contents);
+                break :url_for_css encoded[0 .. data_url_prefix_len + len];
+            };
+        }
+    }
 };
 
 pub const Span = struct {
@@ -7110,27 +7212,27 @@ pub const Span = struct {
 /// block are merged into a single namespace while the non-exported code is
 /// still scoped to just within that block:
 ///
-///	let x = 1;
-///	namespace Foo {
-///	  let x = 2;
-///	  export let y = 3;
-///	}
-///	namespace Foo {
-///	  console.log(x); // 1
-///	  console.log(y); // 3
-///	}
+///    let x = 1;
+///    namespace Foo {
+///      let x = 2;
+///      export let y = 3;
+///    }
+///    namespace Foo {
+///      console.log(x); // 1
+///      console.log(y); // 3
+///    }
 ///
 /// Doing this also works inside an enum:
 ///
-///	enum Foo {
-///	  A = 3,
-///	  B = A + 1,
-///	}
-///	enum Foo {
-///	  C = A + 2,
-///	}
-///	console.log(Foo.B) // 4
-///	console.log(Foo.C) // 5
+///    enum Foo {
+///      A = 3,
+///      B = A + 1,
+///    }
+///    enum Foo {
+///      C = A + 2,
+///    }
+///    console.log(Foo.B) // 4
+///    console.log(Foo.C) // 5
 ///
 /// This is a form of identifier lookup that works differently than the
 /// hierarchical scope-based identifier lookup in JavaScript. Lookup now needs
@@ -7511,9 +7613,16 @@ pub const Part = struct {
 };
 
 pub const Result = union(enum) {
-    already_bundled: void,
+    already_bundled: AlreadyBundled,
     cached: void,
     ast: Ast,
+
+    pub const AlreadyBundled = enum {
+        bun,
+        bun_cjs,
+        bytecode,
+        bytecode_cjs,
+    };
 };
 
 pub const StmtOrExpr = union(enum) {
@@ -8087,14 +8196,13 @@ pub const Macro = struct {
                     .String => this.coerce(value, .String),
                     .Promise => this.coerce(value, .Promise),
                     else => brk: {
-                        var name = value.getClassInfoName() orelse bun.String.init("unknown");
-                        defer name.deref();
+                        const name = value.getClassInfoName() orelse "unknown";
 
                         this.log.addErrorFmt(
                             this.source,
                             this.caller.loc,
                             this.allocator,
-                            "cannot coerce {} ({s}) to Bun's AST. Please return a simpler type",
+                            "cannot coerce {s} ({s}) to Bun's AST. Please return a simpler type",
                             .{ name, @tagName(value.jsType()) },
                         ) catch unreachable;
                         break :brk error.MacroFailed;
@@ -8348,7 +8456,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();
                 }
 
@@ -8360,14 +8468,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
@@ -8386,7 +8493,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);
                 }
@@ -8468,14 +8575,21 @@ pub const ASTMemoryAllocator = struct {
     }
 };
 
-pub const UseDirective = enum {
+pub const UseDirective = enum(u2) {
+    // TODO: Remove this, and provide `UseDirective.Optional` instead
     none,
-    @"use client",
-    @"use server",
+    /// "use client"
+    client,
+    /// "use server"
+    server,
+
+    pub const Boundering = enum(u2) {
+        client = @intFromEnum(UseDirective.client),
+        server = @intFromEnum(UseDirective.server),
+    };
 
     pub const Flags = struct {
-        is_client: bool = false,
-        is_server: bool = false,
+        has_any_client: bool = false,
     };
 
     pub fn isBoundary(this: UseDirective, other: UseDirective) bool {
@@ -8485,22 +8599,13 @@ pub const UseDirective = enum {
         return true;
     }
 
-    pub fn boundering(this: UseDirective, other: UseDirective) ?UseDirective {
+    pub fn boundering(this: UseDirective, other: UseDirective) ?Boundering {
         if (this == other or other == .none)
             return null;
-
-        return other;
+        return @enumFromInt(@intFromEnum(other));
     }
 
-    pub const EntryPoint = struct {
-        source_index: Index.Int,
-        use_directive: UseDirective,
-    };
-
-    pub const List = std.MultiArrayList(UseDirective.EntryPoint);
-
-    // TODO: remove this, add an onModuleDirective() callback to the parser
-    pub fn parse(contents: []const u8) UseDirective {
+    pub fn parse(contents: []const u8) ?UseDirective {
         const truncated = std.mem.trimLeft(u8, contents, " \t\n\r;");
 
         if (truncated.len < "'use client';".len)
@@ -8515,30 +8620,132 @@ pub const UseDirective = enum {
 
         const unquoted = directive_string[1 .. directive_string.len - 2];
 
-        if (strings.eqlComptime(
-            unquoted,
-            "use client",
-        )) {
-            return .@"use client";
+        if (strings.eqlComptime(unquoted, "use client")) {
+            return .client;
         }
 
-        if (strings.eqlComptime(
-            unquoted,
-            "use server",
-        )) {
-            return .@"use server";
+        if (strings.eqlComptime(unquoted, "use server")) {
+            return .server;
         }
 
-        return .none;
+        return null;
     }
+};
 
-    pub fn target(this: UseDirective, default: bun.options.Target) bun.options.Target {
-        return switch (this) {
-            .none => default,
-            .@"use client" => .browser,
-            .@"use server" => .bun,
+/// Represents a boundary between client and server code. Every boundary
+/// gets bundled twice, once for the desired target, and once to generate
+/// a module of "references". Specifically, the generated file takes the
+/// canonical Ast as input to derive a wrapper. See `Framework.ServerComponents`
+/// for more details about this generated file.
+///
+/// This is sometimes abbreviated as SCB
+pub const ServerComponentBoundary = struct {
+    use_directive: UseDirective,
+
+    /// The index of the original file.
+    source_index: Index.Int,
+
+    /// Index to the file imported on the opposite platform, which is
+    /// generated by the bundler. For client components, this is the
+    /// server's code. For server actions, this is the client's code.
+    reference_source_index: Index.Int,
+
+    /// When `bake.Framework.ServerComponents.separate_ssr_graph` is enabled this
+    /// points to the separated module. When the SSR graph is not separate, this is
+    /// equal to `reference_source_index`
+    //
+    // TODO: Is this used for server actions.
+    ssr_source_index: Index.Int,
+
+    /// The requirements for this data structure is to have reasonable lookup
+    /// speed, but also being able to pull a `[]const Index.Int` of all
+    /// boundaries for iteration.
+    pub const List = struct {
+        list: std.MultiArrayList(ServerComponentBoundary) = .{},
+        /// Used to facilitate fast lookups into `items` by `.source_index`
+        map: Map = .{},
+
+        const Map = std.ArrayHashMapUnmanaged(void, void, struct {}, true);
+
+        /// Can only be called on the bundler thread.
+        pub fn put(
+            m: *List,
+            allocator: std.mem.Allocator,
+            source_index: Index.Int,
+            use_directive: UseDirective,
+            reference_source_index: Index.Int,
+            ssr_source_index: Index.Int,
+        ) !void {
+            try m.list.append(allocator, .{
+                .source_index = source_index,
+                .use_directive = use_directive,
+                .reference_source_index = reference_source_index,
+                .ssr_source_index = ssr_source_index,
+            });
+            const gop = try m.map.getOrPutAdapted(
+                allocator,
+                source_index,
+                Adapter{ .list = m.list.slice() },
+            );
+            bun.assert(!gop.found_existing);
+        }
+
+        /// Can only be called on the bundler thread.
+        pub fn getIndex(l: *const List, real_source_index: Index.Int) ?usize {
+            return l.map.getIndexAdapted(
+                real_source_index,
+                Adapter{ .list = l.list.slice() },
+            );
+        }
+
+        /// Use this to improve speed of accessing fields at the cost of
+        /// storing more pointers. Invalidated when input is mutated.
+        pub fn slice(l: List) Slice {
+            return .{ .list = l.list.slice(), .map = l.map };
+        }
+
+        pub const Slice = struct {
+            list: std.MultiArrayList(ServerComponentBoundary).Slice,
+            map: Map,
+
+            pub fn getIndex(l: *const Slice, real_source_index: Index.Int) ?usize {
+                return l.map.getIndexAdapted(
+                    real_source_index,
+                    Adapter{ .list = l.list },
+                ) orelse return null;
+            }
+
+            pub fn getReferenceSourceIndex(l: *const Slice, real_source_index: Index.Int) ?u32 {
+                const i = l.map.getIndexAdapted(
+                    real_source_index,
+                    Adapter{ .list = l.list },
+                ) orelse return null;
+                bun.unsafeAssert(l.list.capacity > 0); // optimize MultiArrayList.Slice.items
+                return l.list.items(.reference_source_index)[i];
+            }
+
+            pub fn bitSet(scbs: Slice, alloc: std.mem.Allocator, input_file_count: usize) !bun.bit_set.DynamicBitSetUnmanaged {
+                var scb_bitset = try bun.bit_set.DynamicBitSetUnmanaged.initEmpty(alloc, input_file_count);
+                for (scbs.list.items(.source_index)) |source_index| {
+                    scb_bitset.set(source_index);
+                }
+                return scb_bitset;
+            }
         };
-    }
+
+        pub const Adapter = struct {
+            list: std.MultiArrayList(ServerComponentBoundary).Slice,
+
+            pub fn hash(_: Adapter, key: Index.Int) u32 {
+                return std.hash.uint32(key);
+            }
+
+            pub fn eql(adapt: Adapter, a: Index.Int, _: void, b_index: usize) bool {
+                bun.unsafeAssert(adapt.list.capacity > 0); // optimize MultiArrayList.Slice.items
+                return a == adapt.list.items(.source_index)[b_index];
+            }
+        };
+    };
 };
 
 pub const GlobalStoreHandle = struct {
@@ -8773,18 +8980,4 @@ const ToJSError = error{
     OutOfMemory,
 };
 
-fn assertNoPointers(T: type) void {
-    switch (@typeInfo(T)) {
-        .Pointer => @compileError("no pointers!"),
-        .Struct => |s| for (s.fields) |field| {
-            assertNoPointers(field.type);
-        },
-        .Array => |a| assertNoPointers(a.child),
-        else => {},
-    }
-}
-
-inline fn writeAnyToHasher(hasher: anytype, thing: anytype) void {
-    comptime assertNoPointers(@TypeOf(thing)); // catch silly mistakes
-    hasher.update(std.mem.asBytes(&thing));
-}
+const writeAnyToHasher = bun.writeAnyToHasher;
diff --git a/src/js_lexer.zig b/src/js_lexer.zig
index 7e7a41298e..ca946482f3 100644
--- a/src/js_lexer.zig
+++ b/src/js_lexer.zig
@@ -29,7 +29,6 @@ pub const StrictModeReservedWords = tables.StrictModeReservedWords;
 pub const PropertyModifierKeyword = tables.PropertyModifierKeyword;
 pub const TypescriptStmtKeyword = tables.TypescriptStmtKeyword;
 pub const TypeScriptAccessibilityModifier = tables.TypeScriptAccessibilityModifier;
-pub const ChildlessJSXTags = tables.ChildlessJSXTags;
 
 fn notimpl() noreturn {
     Output.panic("not implemented yet!", .{});
@@ -75,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 {
@@ -104,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,
     );
 }
@@ -117,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{
@@ -128,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 {
@@ -172,7 +153,13 @@ fn NewLexer_(
         code_point: CodePoint = -1,
         identifier: []const u8 = "",
         jsx_pragma: JSXPragma = .{},
-        bun_pragma: bool = false,
+        bun_pragma: enum {
+            none,
+            bun,
+            bun_cjs,
+            bytecode,
+            bytecode_cjs,
+        } = .none,
         source_mapping_url: ?js_ast.Span = null,
         number: f64 = 0.0,
         rescan_close_brace_as_template_token: bool = false,
@@ -182,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.
@@ -205,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);
         }
@@ -251,7 +197,11 @@ fn NewLexer_(
         pub fn syntaxError(self: *LexerType) !void {
             @setCold(true);
 
-            self.addError(self.start, "Syntax Error!!", .{}, true);
+            // Only add this if there is not already an error.
+            // It is possible that there is a more descriptive error already emitted.
+            if (!self.log.hasErrors())
+                self.addError(self.start, "Syntax Error", .{}, true);
+
             return Error.SyntaxError;
         }
 
@@ -323,6 +273,25 @@ fn NewLexer_(
             // }
         }
 
+        pub fn restore(this: *LexerType, original: *const LexerType) void {
+            const all_comments = this.all_comments;
+            const comments_to_preserve_before = this.comments_to_preserve_before;
+            const temp_buffer_u16 = this.temp_buffer_u16;
+            this.* = original.*;
+
+            // make sure pointers are valid
+            this.all_comments = all_comments;
+            this.comments_to_preserve_before = comments_to_preserve_before;
+            this.temp_buffer_u16 = temp_buffer_u16;
+
+            bun.debugAssert(all_comments.items.len >= original.all_comments.items.len);
+            bun.debugAssert(comments_to_preserve_before.items.len >= original.comments_to_preserve_before.items.len);
+            bun.debugAssert(temp_buffer_u16.items.len == 0 and original.temp_buffer_u16.items.len == 0);
+
+            this.all_comments.items.len = original.all_comments.items.len;
+            this.comments_to_preserve_before.items.len = original.comments_to_preserve_before.items.len;
+        }
+
         /// Look ahead at the next n codepoints without advancing the iterator.
         /// If fewer than n codepoints are available, then return the remainder of the string.
         fn peek(it: *LexerType, n: usize) string {
@@ -344,6 +313,7 @@ fn NewLexer_(
         }
 
         pub fn deinit(this: *LexerType) void {
+            this.temp_buffer_u16.clearAndFree();
             this.all_comments.clearAndFree();
             this.comments_to_preserve_before.clearAndFree();
         }
@@ -427,7 +397,7 @@ fn NewLexer_(
                                 // 1-3 digit octal
                                 var is_bad = false;
                                 var value: i64 = c2 - '0';
-                                var restore = iter;
+                                var prev = iter;
 
                                 _ = iterator.next(&iter) or {
                                     if (value == 0) {
@@ -444,7 +414,7 @@ fn NewLexer_(
                                 switch (c3) {
                                     '0'...'7' => {
                                         value = value * 8 + c3 - '0';
-                                        restore = iter;
+                                        prev = iter;
                                         _ = iterator.next(&iter) or return lexer.syntaxError();
 
                                         const c4 = iter.c;
@@ -454,14 +424,14 @@ fn NewLexer_(
                                                 if (temp < 256) {
                                                     value = temp;
                                                 } else {
-                                                    iter = restore;
+                                                    iter = prev;
                                                 }
                                             },
                                             '8', '9' => {
                                                 is_bad = true;
                                             },
                                             else => {
-                                                iter = restore;
+                                                iter = prev;
                                             },
                                         }
                                     },
@@ -469,7 +439,7 @@ fn NewLexer_(
                                         is_bad = true;
                                     },
                                     else => {
-                                        iter = restore;
+                                        iter = prev;
                                     },
                                 }
 
@@ -684,20 +654,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
@@ -719,14 +684,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
@@ -745,7 +708,7 @@ fn NewLexer_(
                         }
 
                         // Template literals require newline normalization
-                        needs_slow_path = true;
+                        needs_decode = true;
                     },
 
                     '\n' => {
@@ -790,7 +753,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) {
@@ -811,9 +774,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 {
@@ -828,35 +789,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 {
@@ -884,7 +830,7 @@ fn NewLexer_(
             return code_point;
         }
 
-        fn step(lexer: *LexerType) void {
+        pub fn step(lexer: *LexerType) void {
             lexer.code_point = lexer.nextCodepoint();
 
             // Track the approximate number of newlines in the file so we can preallocate
@@ -919,7 +865,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,
@@ -939,8 +884,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.
@@ -1010,20 +953,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
@@ -1055,7 +990,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;
         }
 
@@ -2023,8 +1957,8 @@ fn NewLexer_(
                                         // }
                                     }
 
-                                    if (strings.hasPrefixWithWordBoundary(chunk, "bun")) {
-                                        lexer.bun_pragma = true;
+                                    if (lexer.bun_pragma == .none and strings.hasPrefixWithWordBoundary(chunk, "bun")) {
+                                        lexer.bun_pragma = .bun;
                                     } else if (strings.hasPrefixWithWordBoundary(chunk, "jsx")) {
                                         if (PragmaArg.scan(.skip_space_first, lexer.start + i + 1, "jsx", chunk)) |span| {
                                             lexer.jsx_pragma._jsx = span;
@@ -2045,6 +1979,10 @@ fn NewLexer_(
                                         if (PragmaArg.scan(.no_space_first, lexer.start + i + 1, " sourceMappingURL=", chunk)) |span| {
                                             lexer.source_mapping_url = span;
                                         }
+                                    } else if ((lexer.bun_pragma == .bun or lexer.bun_pragma == .bun_cjs) and strings.hasPrefixWithWordBoundary(chunk, "bytecode")) {
+                                        lexer.bun_pragma = if (lexer.bun_pragma == .bun) .bytecode else .bytecode_cjs;
+                                    } else if ((lexer.bun_pragma == .bytecode or lexer.bun_pragma == .bun) and strings.hasPrefixWithWordBoundary(chunk, "bun-cjs")) {
+                                        lexer.bun_pragma = if (lexer.bun_pragma == .bytecode) .bytecode_cjs else .bun_cjs;
                                     }
                                 },
                                 else => {},
@@ -2074,8 +2012,8 @@ fn NewLexer_(
                             }
                         }
 
-                        if (strings.hasPrefixWithWordBoundary(chunk, "bun")) {
-                            lexer.bun_pragma = true;
+                        if (lexer.bun_pragma == .none and strings.hasPrefixWithWordBoundary(chunk, "bun")) {
+                            lexer.bun_pragma = .bun;
                         } else if (strings.hasPrefixWithWordBoundary(chunk, "jsx")) {
                             if (PragmaArg.scan(.skip_space_first, lexer.start + i + 1, "jsx", chunk)) |span| {
                                 lexer.jsx_pragma._jsx = span;
@@ -2096,6 +2034,10 @@ fn NewLexer_(
                             if (PragmaArg.scan(.no_space_first, lexer.start + i + 1, " sourceMappingURL=", chunk)) |span| {
                                 lexer.source_mapping_url = span;
                             }
+                        } else if ((lexer.bun_pragma == .bun or lexer.bun_pragma == .bun_cjs) and strings.hasPrefixWithWordBoundary(chunk, "bytecode")) {
+                            lexer.bun_pragma = if (lexer.bun_pragma == .bun) .bytecode else .bytecode_cjs;
+                        } else if ((lexer.bun_pragma == .bytecode or lexer.bun_pragma == .bun) and strings.hasPrefixWithWordBoundary(chunk, "bun-cjs")) {
+                            lexer.bun_pragma = if (lexer.bun_pragma == .bytecode) .bytecode_cjs else .bun_cjs;
                         }
                     },
                     else => {},
@@ -2116,14 +2058,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),
@@ -2135,12 +2074,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),
@@ -2153,12 +2090,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),
@@ -2174,22 +2109,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 {
@@ -2259,32 +2212,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();
 
@@ -2491,13 +2421,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;
             }
         }
 
@@ -2557,18 +2493,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;
                         }
                     },
                 }
@@ -2577,21 +2518,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
@@ -2610,7 +2539,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
@@ -2634,10 +2563,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 {
@@ -2709,6 +2636,18 @@ fn NewLexer_(
 
             if (lexer.token != token) {
                 try lexer.expected(token);
+                return Error.SyntaxError;
+            }
+
+            try lexer.nextInsideJSXElement();
+        }
+
+        pub fn expectInsideJSXElementWithName(lexer: *LexerType, token: T, name: string) !void {
+            lexer.assertNotJSON();
+
+            if (lexer.token != token) {
+                try lexer.expectedString(name);
+                return Error.SyntaxError;
             }
 
             try lexer.nextInsideJSXElement();
diff --git a/src/js_lexer/identifier_cache.zig b/src/js_lexer/identifier_cache.zig
index 21511846fe..de1ea0e771 100644
--- a/src/js_lexer/identifier_cache.zig
+++ b/src/js_lexer/identifier_cache.zig
@@ -1,5 +1,6 @@
 const std = @import("std");
 const bun = @import("root").bun;
+const identifier_data = @import("./identifier_data.zig");
 
 pub const CachedBitset = extern struct {
     range: [2]i32,
@@ -15,16 +16,7 @@ pub fn setMasks(masks: [*:0]const u8, comptime MaskType: type, masky: MaskType)
     masky.masks = @as(masks, @bitCast(FieldInfo.type));
 }
 
-pub const id_start_meta = CachedBitset.fromFile("id_start_bitset.meta.blob");
-pub const id_continue_meta = CachedBitset.fromFile("id_continue_bitset.meta.blob");
-pub const id_start_masks = @embedFile("id_start_bitset.blob");
-pub const id_continue_masks = @embedFile("id_continue_bitset.blob");
-
-pub const IDStartType = bun.bit_set.ArrayBitSet(usize, id_start_meta.len);
-pub const IDContinueType = bun.bit_set.ArrayBitSet(usize, id_continue_meta.len);
-pub const id_start = IDStartType{
-    .masks = @as(std.meta.fieldInfo(IDStartType, .masks).type, @bitCast(@as(*const [id_start_masks.len]u8, @ptrCast(id_start_masks)).*)),
-};
-pub const id_continue = IDContinueType{
-    .masks = @as(std.meta.fieldInfo(IDContinueType, .masks).type, @bitCast(@as(*const [id_continue_masks.len]u8, @ptrCast(id_continue_masks)).*)),
-};
+pub const id_start_meta = identifier_data.id_start_cached;
+pub const id_continue_meta = identifier_data.id_continue_cached;
+pub const id_start = identifier_data.id_start;
+pub const id_continue = identifier_data.id_continue;
diff --git a/src/js_lexer/identifier_data.zig b/src/js_lexer/identifier_data.zig
index b9ce7afa2d..d82751e620 100644
--- a/src/js_lexer/identifier_data.zig
+++ b/src/js_lexer/identifier_data.zig
@@ -60,7 +60,7 @@ const id_end_count = id_end_range[1] - id_end_range[0] + 1;
 pub const IDStartType = std.bit_set.StaticBitSet(id_start_count + 1);
 pub const IDContinueType = std.bit_set.StaticBitSet(id_end_count + 1);
 
-const id_start: IDStartType = brk: {
+pub const id_start: IDStartType = brk: {
     var bits: IDStartType = IDStartType.initEmpty();
     var i: usize = 0;
 
@@ -76,7 +76,7 @@ const id_start: IDStartType = brk: {
     break :brk bits;
 };
 
-const id_continue: IDContinueType = brk: {
+pub const id_continue: IDContinueType = brk: {
     var bits: IDContinueType = IDContinueType.initEmpty();
     var i: usize = 0;
 
@@ -94,10 +94,10 @@ const id_continue: IDContinueType = brk: {
 
 const Cache = @import("./identifier_cache.zig");
 
-pub fn main() anyerror!void {
-    var id_start_cached = Cache.CachedBitset{ .range = id_start_range, .len = id_start_count + 1 };
-    var id_continue_cached = Cache.CachedBitset{ .range = id_end_range, .len = id_end_count + 1 };
+pub const id_start_cached = Cache.CachedBitset{ .range = id_start_range, .len = id_start_count + 1 };
+pub const id_continue_cached = Cache.CachedBitset{ .range = id_end_range, .len = id_end_count + 1 };
 
+fn main() anyerror!void {
     const id_continue_data = std.mem.asBytes(&id_continue.masks);
     const id_start_data = std.mem.asBytes(&id_start.masks);
 
diff --git a/src/js_lexer_tables.zig b/src/js_lexer_tables.zig
index bc87fb0e60..bb01d4112f 100644
--- a/src/js_lexer_tables.zig
+++ b/src/js_lexer_tables.zig
@@ -552,26 +552,6 @@ pub const TypescriptStmtKeyword = enum {
     });
 };
 
-//  Error: meta is a void element tag and must neither have `children` nor use `dangerouslySetInnerHTML`.
-pub const ChildlessJSXTags = ComptimeStringMap(void, .{
-    .{ "area", void },
-    .{ "base", void },
-    .{ "br", void },
-    .{ "col", void },
-    .{ "embed", void },
-    .{ "hr", void },
-    .{ "img", void },
-    .{ "input", void },
-    .{ "keygen", void },
-    .{ "link", void },
-    .{ "menuitem", void },
-    .{ "meta", void },
-    .{ "param", void },
-    .{ "source", void },
-    .{ "track", void },
-    .{ "wbr", void },
-});
-
 // In a microbenchmark, this outperforms
 pub const jsxEntity = ComptimeStringMap(CodePoint, .{
     .{ "Aacute", @as(CodePoint, 0x00C1) },
diff --git a/src/js_parser.zig b/src/js_parser.zig
index 6b03e651aa..e0fe7510c6 100644
--- a/src/js_parser.zig
+++ b/src/js_parser.zig
@@ -530,7 +530,8 @@ const JSXTag = struct {
     };
     data: Data,
     range: logger.Range,
-    name: string = "",
+    /// Empty string for fragments.
+    name: string,
 
     pub fn parse(comptime P: type, p: *P) anyerror!JSXTag {
         const loc = p.lexer.loc();
@@ -547,7 +548,7 @@ const JSXTag = struct {
         // The tag is an identifier
         var name = p.lexer.identifier;
         var tag_range = p.lexer.range();
-        try p.lexer.expectInsideJSXElement(.t_identifier);
+        try p.lexer.expectInsideJSXElementWithName(.t_identifier, "JSX element name");
 
         // Certain identifiers are strings
         // <div
@@ -559,6 +560,7 @@ const JSXTag = struct {
                     .data = name,
                 }, loc) },
                 .range = tag_range,
+                .name = name,
             };
         }
 
@@ -778,7 +780,7 @@ pub const TypeScript = struct {
     };
 
     pub fn isTSArrowFnJSX(p: anytype) !bool {
-        var oldLexer = std.mem.toBytes(p.lexer);
+        const old_lexer = p.lexer;
 
         try p.lexer.next();
         // Look ahead to see if this should be an arrow function instead
@@ -798,7 +800,7 @@ pub const TypeScript = struct {
         }
 
         // Restore the lexer
-        p.lexer = std.mem.bytesToValue(@TypeOf(p.lexer), &oldLexer);
+        p.lexer.restore(&old_lexer);
         return is_ts_arrow_fn;
     }
 
@@ -868,11 +870,13 @@ pub const TypeScript = struct {
     }
 
     fn lookAheadNextTokenIsOpenParenOrLessThanOrDot(p: anytype) bool {
-        var old_lexer = std.mem.toBytes(p.lexer);
+        const old_lexer = p.lexer;
         const old_log_disabled = p.lexer.is_log_disabled;
         p.lexer.is_log_disabled = true;
-        defer p.lexer.is_log_disabled = old_log_disabled;
-        defer p.lexer = std.mem.bytesToValue(@TypeOf(p.lexer), &old_lexer);
+        defer {
+            p.lexer.restore(&old_lexer);
+            p.lexer.is_log_disabled = old_log_disabled;
+        }
         p.lexer.next() catch {};
 
         return switch (p.lexer.token) {
@@ -1061,7 +1065,7 @@ pub const ImportScanner = struct {
         stmts: []Stmt,
         will_transform_to_common_js: bool,
         comptime hot_module_reloading_transformations: bool,
-        hot_module_reloading_context: if (hot_module_reloading_transformations) *P.ConvertESMExportsForHmr else void,
+        hot_module_reloading_context: if (hot_module_reloading_transformations) *ConvertESMExportsForHmr else void,
     ) !ImportScanner {
         var scanner = ImportScanner{};
         var stmts_end: usize = 0;
@@ -1071,13 +1075,11 @@ pub const ImportScanner = struct {
         for (stmts) |_stmt| {
             var stmt = _stmt; // copy
             switch (stmt.data) {
-                .s_import => |st__| {
-                    var st = st__.*;
-                    defer {
-                        st__.* = st;
-                    }
+                .s_import => |import_ptr| {
+                    var st = import_ptr.*;
+                    defer import_ptr.* = st;
 
-                    var record: *ImportRecord = &p.import_records.items[st.import_record_index];
+                    const record: *ImportRecord = &p.import_records.items[st.import_record_index];
 
                     if (record.path.isMacro()) {
                         record.is_unused = true;
@@ -1272,7 +1274,7 @@ pub const ImportScanner = struct {
                                 result.* = alias;
                             }
                             strings.sortDesc(sorted);
-                            p.named_imports.ensureUnusedCapacity(sorted.len) catch unreachable;
+                            p.named_imports.ensureUnusedCapacity(p.allocator, sorted.len) catch bun.outOfMemory();
 
                             // Create named imports for these property accesses. This will
                             // cause missing imports to generate useful warnings.
@@ -1283,6 +1285,7 @@ pub const ImportScanner = struct {
                             for (sorted) |alias| {
                                 const item = existing_items.get(alias).?;
                                 p.named_imports.put(
+                                    p.allocator,
                                     item.ref.?,
                                     js_ast.NamedImport{
                                         .alias = alias,
@@ -1290,7 +1293,7 @@ pub const ImportScanner = struct {
                                         .namespace_ref = namespace_ref,
                                         .import_record_index = st.import_record_index,
                                     },
-                                ) catch unreachable;
+                                ) catch bun.outOfMemory();
 
                                 const name: LocRef = item;
                                 const name_ref = name.ref.?;
@@ -1314,10 +1317,12 @@ pub const ImportScanner = struct {
                         }
 
                         p.named_imports.ensureUnusedCapacity(
+                            p.allocator,
                             st.items.len + @as(usize, @intFromBool(st.default_name != null)) + @as(usize, @intFromBool(st.star_name_loc != null)),
-                        ) catch unreachable;
+                        ) catch bun.outOfMemory();
 
                         if (st.star_name_loc) |loc| {
+                            record.contains_import_star = true;
                             p.named_imports.putAssumeCapacity(
                                 namespace_ref,
                                 js_ast.NamedImport{
@@ -1331,6 +1336,7 @@ pub const ImportScanner = struct {
                         }
 
                         if (st.default_name) |default| {
+                            record.contains_default_alias = true;
                             p.named_imports.putAssumeCapacity(
                                 default.ref.?,
                                 .{
@@ -1364,13 +1370,12 @@ pub const ImportScanner = struct {
                         // We do not know at this stage whether or not the import statement is bundled
                         // This keeps track of the `namespace_alias` incase, at printing time, we determine that we should print it with the namespace
                         for (st.items) |item| {
-                            const is_default = strings.eqlComptime(item.alias, "default");
-                            record.contains_default_alias = record.contains_default_alias or is_default;
+                            record.contains_default_alias = record.contains_default_alias or strings.eqlComptime(item.alias, "default");
 
                             const name: LocRef = item.name;
                             const name_ref = name.ref.?;
 
-                            try p.named_imports.put(name_ref, js_ast.NamedImport{
+                            try p.named_imports.put(p.allocator, name_ref, js_ast.NamedImport{
                                 .alias = item.alias,
                                 .alias_loc = name.loc,
                                 .namespace_ref = namespace_ref,
@@ -1486,9 +1491,9 @@ pub const ImportScanner = struct {
                     // Rewrite this export to be:
                     // exports.default =
                     // But only if it's anonymous
-                    if (!hot_module_reloading_transformations and will_transform_to_common_js) {
+                    if (!hot_module_reloading_transformations and will_transform_to_common_js and P != bun.bundle_v2.AstBuilder) {
                         const expr = st.value.toExpr();
-                        var export_default_args = p.allocator.alloc(Expr, 2) catch unreachable;
+                        var export_default_args = try p.allocator.alloc(Expr, 2);
                         export_default_args[0] = p.@"module.exports"(expr.loc);
                         export_default_args[1] = expr;
                         stmt = p.s(S.SExpr{ .value = p.callRuntime(expr.loc, "__exportDefault", export_default_args) }, expr.loc);
@@ -1504,7 +1509,7 @@ pub const ImportScanner = struct {
 
                     if (st.alias) |alias| {
                         // "export * as ns from 'path'"
-                        try p.named_imports.put(st.namespace_ref, js_ast.NamedImport{
+                        try p.named_imports.put(p.allocator, st.namespace_ref, js_ast.NamedImport{
                             .alias = null,
                             .alias_is_star = true,
                             .alias_loc = alias.loc,
@@ -1522,13 +1527,13 @@ pub const ImportScanner = struct {
                 },
                 .s_export_from => |st| {
                     try p.import_records_for_current_part.append(allocator, st.import_record_index);
-                    p.named_imports.ensureUnusedCapacity(st.items.len) catch unreachable;
+                    p.named_imports.ensureUnusedCapacity(p.allocator, st.items.len) catch unreachable;
                     for (st.items) |item| {
                         const ref = item.name.ref orelse p.panic("Expected export from item to have a name {any}", .{st});
                         // Note that the imported alias is not item.Alias, which is the
                         // exported alias. This is somewhat confusing because each
                         // SExportFrom statement is basically SImport + SExportClause in one.
-                        try p.named_imports.put(ref, js_ast.NamedImport{
+                        try p.named_imports.put(p.allocator, ref, js_ast.NamedImport{
                             .alias_is_star = false,
                             .alias = item.original_name,
                             .alias_loc = item.name.loc,
@@ -1571,26 +1576,15 @@ pub const ImportScanner = struct {
 /// one file, and user symbols from different files may collide with each
 /// other).
 ///
-/// The solution: For every generated symbol, we reserve two backup symbol names:
-/// - If any usages of `.primary`, fall back to `.backup`
-/// - If any usages of `.backup`, fall back to `.internal`
-/// - We *assume* the internal name is never used. In practice, it is possible. But, the
-///   internal names are so crazy long you'd have to be deliberately trying to use them.
-const StaticSymbolName = struct {
-    primary: string,
-    backup: string,
-    internal: string,
-
-    fn init(comptime basename: string) StaticSymbolName {
-        const hash_value = bun.hash(basename);
-        return comptime .{
-            .internal = std.fmt.comptimePrint("{s}_{}", .{ basename, bun.fmt.hexIntLower(hash_value) }),
-            .primary = basename,
-            .backup = "_" ++ basename ++ "$",
-        };
+/// This makes sure that there's the lowest possible chance of having a generated name
+/// collide with a user's name. This is the easiest way to do so
+pub inline fn generatedSymbolName(name: []const u8) []const u8 {
+    comptime {
+        const hash = std.hash.Wyhash.hash(0, name);
+        const hash_str = std.fmt.comptimePrint("_{}", .{bun.fmt.truncatedHash32(@intCast(hash))});
+        return name ++ hash_str;
     }
-};
-const GeneratedSymbol = @import("./runtime.zig").Runtime.GeneratedSymbol;
+}
 
 pub const SideEffects = enum(u1) {
     could_have_side_effects,
@@ -2506,12 +2500,8 @@ const ExprIn = struct {
     // Currently this is only used when unwrapping a call to `require()`
     // with `__toESM()`.
     is_immediately_assigned_to_decl: bool = false,
-};
 
-const ExprOut = struct {
-    // True if the child node is an optional chain node (EDot, EIndex, or ECall
-    // with an IsOptionalChain value of true)
-    child_contains_optional_chain: bool = false,
+    property_access_for_method_call_maybe_should_replace_with_undefined: bool = false,
 };
 
 const Tup = std.meta.Tuple;
@@ -2842,7 +2832,7 @@ pub const ScanPassResult = struct {
     pub fn init(allocator: Allocator) ScanPassResult {
         return .{
             .import_records = ListManaged(ImportRecord).init(allocator),
-            .named_imports = js_ast.Ast.NamedImports.init(allocator),
+            .named_imports = .{},
             .used_symbols = ParsePassSymbolUsageMap.init(allocator),
             .import_records_to_keep = ListManaged(u32).init(allocator),
             .approximate_newline_count = 0,
@@ -2882,7 +2872,7 @@ pub const Parser = struct {
         use_define_for_class_fields: bool = false,
         suppress_warnings_about_weird_code: bool = true,
         filepath_hash_for_hmr: u32 = 0,
-        features: RuntimeFeatures = RuntimeFeatures{},
+        features: RuntimeFeatures = .{},
 
         tree_shaking: bool = false,
         bundle: bool = false,
@@ -2893,6 +2883,7 @@ pub const Parser = struct {
         warn_about_unbundled_modules: bool = true,
 
         module_type: options.ModuleType = .unknown,
+        output_format: options.Format = .esm,
 
         transform_only: bool = false,
 
@@ -2900,6 +2891,10 @@ pub const Parser = struct {
         import_meta_main_value: ?bool = null,
         lower_import_meta_main_for_node_js: bool = false,
 
+        /// When using react fast refresh or server components, the framework is
+        /// able to customize what import sources are used.
+        framework: ?*bun.bake.Framework = null,
+
         pub fn hashForRuntimeTranspiler(this: *const Options, hasher: *std.hash.Wyhash, did_use_jsx: bool) void {
             bun.assert(!this.bundle);
 
@@ -2937,7 +2932,6 @@ pub const Parser = struct {
         pub fn init(jsx: options.JSX.Pragma, loader: options.Loader) Options {
             var opts = Options{
                 .ts = loader.isTypeScript(),
-
                 .jsx = jsx,
             };
             opts.jsx.parse = loader.isJSX();
@@ -3119,7 +3113,7 @@ pub const Parser = struct {
         const stmts = p.parseStmtsUpTo(js_lexer.T.t_end_of_file, &opts) catch |err| {
             if (comptime Environment.isWasm) {
                 Output.print("JSParser.parse: caught error {s} at location: {d}\n", .{ @errorName(err), p.lexer.loc().start });
-                p.log.printForLogLevel(Output.writer()) catch {};
+                p.log.print(Output.writer()) catch {};
             }
             return err;
         };
@@ -3224,9 +3218,15 @@ pub const Parser = struct {
         }
 
         // Detect a leading "// @bun" pragma
-        if (p.lexer.bun_pragma and p.options.features.dont_bundle_twice) {
+        if (p.lexer.bun_pragma != .none and p.options.features.dont_bundle_twice) {
             return js_ast.Result{
-                .already_bundled = {},
+                .already_bundled = switch (p.lexer.bun_pragma) {
+                    .bun => .bun,
+                    .bytecode => .bytecode,
+                    .bytecode_cjs => .bytecode_cjs,
+                    .bun_cjs => .bun_cjs,
+                    else => unreachable,
+                },
             };
         }
 
@@ -3441,28 +3441,6 @@ pub const Parser = struct {
                         try p.appendPart(parts_list, sliced.items);
                     },
 
-                    // Hoist functions to the top in the output
-                    // This is normally done by the JS parser, but we need to do it here
-                    // incase we have CommonJS exports converted to ESM exports there are assignments
-                    // to the exports object that need to be hoisted.
-                    .s_function => {
-                        var sliced = try ListManaged(Stmt).initCapacity(p.allocator, 1);
-                        sliced.items.len = 1;
-                        sliced.items[0] = stmt;
-                        // since we convert top-level function statements to look like this:
-                        //
-                        //   let foo = function () { ... }
-                        //
-                        // we have to hoist them to the top of the file, even when not bundling
-                        //
-                        // we might also need to do this for classes but i'm not sure yet.
-                        try p.appendPart(&parts, sliced.items);
-
-                        if (parts.items.len > 0) {
-                            before.append(parts.getLast()) catch unreachable;
-                            parts.items.len -= 1;
-                        }
-                    },
                     .s_class => |class| {
                         // Move class export statements to the top of the file if we can
                         // This automatically resolves some cyclical import issues
@@ -3538,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,
@@ -3550,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,
@@ -3653,8 +3631,7 @@ pub const Parser = struct {
             }
         }
 
-        if (p.options.bundle and parts.items.len < 4 and parts.items.len > 0) {
-
+        if (parts.items.len < 4 and parts.items.len > 0 and p.options.features.unwrap_commonjs_to_esm) {
             // Specially handle modules shaped like this:
             //
             //   CommonJS:
@@ -3715,7 +3692,6 @@ pub const Parser = struct {
                                     part.symbol_uses = .{};
                                     return js_ast.Result{
                                         .ast = js_ast.Ast{
-                                            .allocator = p.allocator,
                                             .import_records = ImportRecord.List.init(p.import_records.items),
                                             .redirect_import_record_index = id,
                                             .named_imports = p.named_imports,
@@ -3730,6 +3706,7 @@ pub const Parser = struct {
             }
 
             if (p.commonjs_named_exports_deoptimized and
+                p.options.features.unwrap_commonjs_to_esm and
                 p.unwrap_all_requires and
                 p.imports_to_convert_from_require.items.len == 1 and
                 p.import_records.items.len == 1 and
@@ -4195,8 +4172,39 @@ pub const Parser = struct {
             }
         }
 
+        if (p.server_components_wrap_ref.isValid()) {
+            const fw = p.options.framework orelse @panic("server components requires a framework configured, but none was set");
+            const sc = fw.server_components.?;
+            try p.generateReactRefreshImport(
+                &before,
+                sc.server_runtime_import,
+                &.{
+                    .{
+                        .name = sc.server_register_client_reference,
+                        .ref = p.server_components_wrap_ref,
+                        .enabled = true,
+                    },
+                },
+            );
+        }
+
         if (p.react_refresh.register_used or p.react_refresh.signature_used) {
-            try p.generateReactRefreshImport(&before);
+            try p.generateReactRefreshImport(
+                &before,
+                if (p.options.framework) |fw| fw.react_fast_refresh.?.import_source else "react-refresh/runtime",
+                &.{
+                    .{
+                        .name = "register",
+                        .enabled = p.react_refresh.register_used,
+                        .ref = p.react_refresh.register_ref,
+                    },
+                    .{
+                        .name = "createSignatureFunctionForTransform",
+                        .enabled = p.react_refresh.signature_used,
+                        .ref = p.react_refresh.create_signature_ref,
+                    },
+                },
+            );
         }
 
         var parts_slice: []js_ast.Part = &([_]js_ast.Part{});
@@ -4421,7 +4429,7 @@ const ParserFeatures = struct {
     scan_only: bool = false,
 };
 
-const ImportItemForNamespaceMap = bun.StringArrayHashMap(LocRef);
+pub const ImportItemForNamespaceMap = bun.StringArrayHashMap(LocRef);
 
 pub const KnownGlobal = enum {
     WeakSet,
@@ -4813,19 +4821,16 @@ fn NewParser_(
         // "visit" pass.
         enclosing_namespace_arg_ref: ?Ref = null,
 
-        // TODO: remove all these
-        jsx_runtime: GeneratedSymbol = GeneratedSymbol{ .ref = Ref.None, .primary = Ref.None, .backup = Ref.None },
-        jsx_factory: GeneratedSymbol = GeneratedSymbol{ .ref = Ref.None, .primary = Ref.None, .backup = Ref.None },
-        jsx_fragment: GeneratedSymbol = GeneratedSymbol{ .ref = Ref.None, .primary = Ref.None, .backup = Ref.None },
-        jsx_automatic: GeneratedSymbol = GeneratedSymbol{ .ref = Ref.None, .primary = Ref.None, .backup = Ref.None },
-        jsxs_runtime: GeneratedSymbol = GeneratedSymbol{ .ref = Ref.None, .primary = Ref.None, .backup = Ref.None },
-        jsx_classic: GeneratedSymbol = GeneratedSymbol{ .ref = Ref.None, .primary = Ref.None, .backup = Ref.None },
         jsx_imports: JSXImport.Symbols = .{},
 
-        // only applicable when `.options.features.react_fast_refresh` is set.
-        // populated before visit pass starts.
+        /// only applicable when `.options.features.react_fast_refresh` is set.
+        /// populated before visit pass starts.
         react_refresh: ReactRefresh = .{},
 
+        /// only applicable when `.options.features.server_components` is
+        /// configured to wrap exports. populated before visit pass starts.
+        server_components_wrap_ref: Ref = Ref.None,
+
         jest: Jest = .{},
 
         // Imports (both ES6 and CommonJS) are tracked at the top level
@@ -4884,6 +4889,8 @@ fn NewParser_(
         /// We must be careful to avoid revisiting nodes that have scopes.
         is_revisit_for_substitution: bool = false,
 
+        method_call_must_be_replaced_with_undefined: bool = false,
+
         // Inside a TypeScript namespace, an "export declare" statement can be used
         // to cause a namespace to be emitted even though it has no other observable
         // effect. This flag is used to implement this feature.
@@ -5272,7 +5279,7 @@ fn NewParser_(
 
                     // For unwrapping CommonJS into ESM to fully work
                     // we must also unwrap requires into imports.
-                    const should_unwrap_require = !p.options.features.hot_module_reloading and
+                    const should_unwrap_require = p.options.features.unwrap_commonjs_to_esm and
                         (p.unwrap_all_requires or
                         if (path.packageName()) |pkg| p.options.features.shouldUnwrapRequire(pkg) else false) and
                         // We cannot unwrap a require wrapped in a try/catch because
@@ -5335,9 +5342,8 @@ fn NewParser_(
             }
         }
 
-        pub fn shouldUnwrapCommonJSToESM(p: *P) bool {
-            // hot module loading opts out of this because we want to produce a cjs bundle at the end
-            return FeatureFlags.unwrap_commonjs_to_esm and !p.options.features.hot_module_reloading;
+        pub inline fn shouldUnwrapCommonJSToESM(p: *const P) bool {
+            return p.options.features.unwrap_commonjs_to_esm;
         }
 
         fn isBindingUsed(p: *P, binding: Binding, default_export_ref: Ref) bool {
@@ -5797,7 +5803,7 @@ fn NewParser_(
             }
         }
 
-        pub fn recordExport(p: *P, loc: logger.Loc, alias: string, ref: Ref) anyerror!void {
+        pub fn recordExport(p: *P, loc: logger.Loc, alias: string, ref: Ref) !void {
             if (p.named_exports.get(alias)) |name| {
                 // Duplicate exports are an error
                 var notes = try p.allocator.alloc(logger.Data, 1);
@@ -5814,7 +5820,7 @@ fn NewParser_(
                     .{std.mem.trim(u8, alias, "\"'")},
                 );
             } else if (!p.isDeoptimizedCommonJS()) {
-                try p.named_exports.put(alias, js_ast.NamedExport{ .alias_loc = loc, .ref = ref });
+                try p.named_exports.put(p.allocator, alias, js_ast.NamedExport{ .alias_loc = loc, .ref = ref });
             }
         }
 
@@ -5865,7 +5871,6 @@ fn NewParser_(
                 },
                 .e_private_identifier => |private| {
                     return p.loadNameFromRef(private.ref);
-                    // return p.loadNameFromRef()
                 },
                 else => {
                     return "property";
@@ -5929,10 +5934,9 @@ fn NewParser_(
                         }
                     }
 
-                    return p.newExpr(E.Dot{
-                        .target = p.newExpr(E.Identifier.init(ns_alias.namespace_ref), loc),
-                        .name = ns_alias.alias,
-                        .name_loc = loc,
+                    return p.newExpr(E.ImportIdentifier{
+                        .ref = ident.ref,
+                        .was_originally_identifier = true,
                     }, loc);
                 }
             }
@@ -6051,8 +6055,21 @@ fn NewParser_(
                     .name = LocRef{ .ref = ref, .loc = logger.Loc{} },
                 };
                 declared_symbols.appendAssumeCapacity(.{ .ref = ref, .is_top_level = true });
+
+                // ensure every e_import_identifier holds the namespace
+                if (p.options.features.hot_module_reloading) {
+                    const symbol = &p.symbols.items[ref.inner_index];
+                    if (symbol.namespace_alias == null) {
+                        symbol.namespace_alias = .{
+                            .namespace_ref = namespace_ref,
+                            .alias = alias_name,
+                            .import_record_index = import_record_i,
+                        };
+                    }
+                }
+
                 try p.is_import_item.put(allocator, ref, {});
-                try p.named_imports.put(ref, js_ast.NamedImport{
+                try p.named_imports.put(allocator, ref, js_ast.NamedImport{
                     .alias = alias_name,
                     .alias_loc = logger.Loc{},
                     .namespace_ref = namespace_ref,
@@ -6087,13 +6104,30 @@ fn NewParser_(
             }) catch unreachable;
         }
 
-        pub fn generateReactRefreshImport(p: *P, parts: *ListManaged(js_ast.Part)) !void {
+        pub fn generateReactRefreshImport(
+            p: *P,
+            parts: *ListManaged(js_ast.Part),
+            import_path: []const u8,
+            clauses: []const ReactRefreshImportClause,
+        ) !void {
             switch (p.options.features.hot_module_reloading) {
-                inline else => |hmr| try p.generateReactRefreshImportHmr(parts, hmr),
+                inline else => |hmr| try p.generateReactRefreshImportHmr(parts, import_path, clauses, hmr),
             }
         }
 
-        fn generateReactRefreshImportHmr(p: *P, parts: *ListManaged(js_ast.Part), comptime hot_module_reloading: bool) !void {
+        const ReactRefreshImportClause = struct {
+            name: []const u8,
+            enabled: bool,
+            ref: Ref,
+        };
+
+        fn generateReactRefreshImportHmr(
+            p: *P,
+            parts: *ListManaged(js_ast.Part),
+            import_path: []const u8,
+            clauses: []const ReactRefreshImportClause,
+            comptime hot_module_reloading: bool,
+        ) !void {
             // If `hot_module_reloading`, we are going to generate a require call:
             //
             //     const { $RefreshSig$, $RefreshReg$ } = require("react-refresh/runtime")`
@@ -6103,7 +6137,7 @@ fn NewParser_(
             // already a CommonJS module, and it will actually be more efficient
             // at runtime this way.
             const allocator = p.allocator;
-            const import_record_index = p.addImportRecordByRange(.stmt, logger.Range.None, "react-refresh/runtime");
+            const import_record_index = p.addImportRecordByRange(.stmt, logger.Range.None, import_path);
 
             const Item = if (hot_module_reloading) B.Object.Property else js_ast.ClauseItem;
 
@@ -6122,18 +6156,7 @@ fn NewParser_(
             });
             try p.module_scope.generated.push(allocator, namespace_ref);
 
-            inline for (.{
-                .{
-                    .name = "register",
-                    .enabled = p.react_refresh.register_used,
-                    .ref = p.react_refresh.register_ref,
-                },
-                .{
-                    .name = "createSignatureFunctionForTransform",
-                    .enabled = p.react_refresh.signature_used,
-                    .ref = p.react_refresh.create_signature_ref,
-                },
-            }) |entry| {
+            for (clauses) |entry| {
                 if (entry.enabled) {
                     items.appendAssumeCapacity(if (hot_module_reloading) .{
                         .key = p.newExpr(E.String{ .data = entry.name }, logger.Loc.Empty),
@@ -6147,7 +6170,7 @@ fn NewParser_(
                     declared_symbols.appendAssumeCapacity(.{ .ref = entry.ref, .is_top_level = true });
                     try p.module_scope.generated.push(allocator, entry.ref);
                     try p.is_import_item.put(allocator, entry.ref, {});
-                    try p.named_imports.put(entry.ref, .{
+                    try p.named_imports.put(allocator, entry.ref, .{
                         .alias = entry.name,
                         .alias_loc = logger.Loc.Empty,
                         .namespace_ref = namespace_ref,
@@ -6769,64 +6792,25 @@ fn NewParser_(
             }
 
             if (p.options.features.react_fast_refresh) {
-                // this is .. obviously.. not correct
-                p.react_refresh.create_signature_ref = (try p.declareGeneratedSymbol(.other, "$RefreshSig$")).primary;
-                p.react_refresh.register_ref = (try p.declareGeneratedSymbol(.other, "$RefreshReg$")).primary;
+                p.react_refresh.create_signature_ref = try p.declareGeneratedSymbol(.other, "$RefreshSig$");
+                p.react_refresh.register_ref = try p.declareGeneratedSymbol(.other, "$RefreshReg$");
             }
 
-            //  "React.createElement" and "createElement" become:
-            //      import { createElement } from 'react';
-            //  "Foo.Bar.createElement" becomes:
-            //      import { Bar } from 'foo';
-            //      Usages become Bar.createElement
-            switch (comptime jsx_transform_type) {
-                .react => {
-                    if (!p.options.bundle) {
-                        p.jsx_fragment = p.declareGeneratedSymbol(.other, "Fragment") catch unreachable;
-                        p.jsx_runtime = p.declareGeneratedSymbol(.other, "jsx") catch unreachable;
-                        if (comptime FeatureFlags.support_jsxs_in_jsx_transform)
-                            p.jsxs_runtime = p.declareGeneratedSymbol(.other, "jsxs") catch unreachable;
-                        p.jsx_factory = p.declareGeneratedSymbol(.other, "Factory") catch unreachable;
-
-                        if (p.options.jsx.factory.len > 1 or FeatureFlags.jsx_runtime_is_cjs) {
-                            p.jsx_classic = p.declareGeneratedSymbol(.other, "ClassicImportSource") catch unreachable;
-                        }
-
-                        p.jsx_automatic = p.declareGeneratedSymbol(.other, "ImportSource") catch unreachable;
-                    }
+            switch (p.options.features.server_components) {
+                .none, .client_side => {},
+                .wrap_exports_for_client_reference => {
+                    p.server_components_wrap_ref = try p.declareGeneratedSymbol(.other, "registerClientReference");
                 },
-
-                else => {},
-            }
-        }
-
-        // This won't work for adversarial cases
-        pub fn resolveGeneratedSymbol(p: *P, generated_symbol: *GeneratedSymbol) void {
-            if (generated_symbol.ref.isNull() or p.options.bundle) return;
-
-            if (p.symbols.items[generated_symbol.primary.innerIndex()].use_count_estimate == 0 and
-                p.symbols.items[generated_symbol.primary.innerIndex()].hasLink())
-            {
-                p.symbols.items[generated_symbol.ref.innerIndex()].original_name = p.symbols.items[generated_symbol.primary.innerIndex()].original_name;
-                return;
-            }
-
-            if (p.symbols.items[generated_symbol.backup.innerIndex()].use_count_estimate == 0 and
-                p.symbols.items[generated_symbol.backup.innerIndex()].hasLink())
-            {
-                p.symbols.items[generated_symbol.ref.innerIndex()].original_name = p.symbols.items[generated_symbol.backup.innerIndex()].original_name;
-                return;
+                // TODO: these wrapping modes.
+                .wrap_anon_server_functions => {},
+                .wrap_exports_for_server_reference => {},
             }
         }
 
         fn ensureRequireSymbol(p: *P) void {
             if (p.runtime_imports.__require != null) return;
-            const static_symbol = comptime StaticSymbolName.init("__require");
-            p.runtime_imports.__require = .{
-                .backup = declareSymbolMaybeGenerated(p, .other, logger.Loc.Empty, static_symbol.backup, true) catch bun.outOfMemory(),
-                .primary = p.require_ref,
-                .ref = declareSymbolMaybeGenerated(p, .other, logger.Loc.Empty, static_symbol.internal, true) catch bun.outOfMemory(),
-            };
+            const static_symbol = generatedSymbolName("__require");
+            p.runtime_imports.__require = declareSymbolMaybeGenerated(p, .other, logger.Loc.Empty, static_symbol, true) catch bun.outOfMemory();
             p.runtime_imports.put("__require", p.runtime_imports.__require.?);
         }
 
@@ -6834,39 +6818,9 @@ fn NewParser_(
             if (!p.options.features.allow_runtime)
                 return;
 
-            if (p.runtime_imports.__require) |*require| {
-                p.resolveGeneratedSymbol(require);
-            }
-
             p.ensureRequireSymbol();
         }
 
-        pub fn resolveBundlingSymbols(p: *P) void {
-            p.resolveGeneratedSymbol(&p.runtime_imports.__export.?);
-            p.resolveGeneratedSymbol(&p.runtime_imports.__exportValue.?);
-            p.resolveGeneratedSymbol(&p.runtime_imports.__exportDefault.?);
-        }
-
-        pub fn resolveStaticJSXSymbols(p: *P) void {
-            if (p.options.bundle)
-                return;
-
-            if (p.options.features.jsx_optimization_inline) {
-                if (p.runtime_imports.__merge) |*merge| {
-                    p.resolveGeneratedSymbol(merge);
-                }
-            }
-
-            p.resolveGeneratedSymbol(&p.jsx_runtime);
-            if (FeatureFlags.support_jsxs_in_jsx_transform)
-                p.resolveGeneratedSymbol(&p.jsxs_runtime);
-            p.resolveGeneratedSymbol(&p.jsx_factory);
-            p.resolveGeneratedSymbol(&p.jsx_fragment);
-            p.resolveGeneratedSymbol(&p.jsx_classic);
-            p.resolveGeneratedSymbol(&p.jsx_automatic);
-            // p.resolveGeneratedSymbol(&p.jsx_filename);
-        }
-
         fn willUseRenamer(p: *P) bool {
             return p.options.bundle or p.options.features.minify_identifiers;
         }
@@ -9034,64 +8988,62 @@ fn NewParser_(
             try p.is_import_item.ensureUnusedCapacity(p.allocator, count_excluding_namespace);
             var remap_count: u32 = 0;
             // Link the default item to the namespace
-            if (stmt.default_name) |*name_loc| {
-                outer: {
-                    const name = p.loadNameFromRef(name_loc.ref.?);
-                    const ref = try p.declareSymbol(.import, name_loc.loc, name);
-                    name_loc.ref = ref;
-                    try p.is_import_item.put(p.allocator, ref, {});
+            if (stmt.default_name) |*name_loc| outer: {
+                const name = p.loadNameFromRef(name_loc.ref.?);
+                const ref = try p.declareSymbol(.import, name_loc.loc, name);
+                name_loc.ref = ref;
+                try p.is_import_item.put(p.allocator, ref, {});
 
-                    // ensure every e_import_identifier holds the namespace
-                    if (p.options.features.hot_module_reloading) {
-                        const symbol = &p.symbols.items[ref.inner_index];
-                        if (symbol.namespace_alias == null) {
-                            symbol.namespace_alias = .{
-                                .namespace_ref = stmt.namespace_ref,
-                                .alias = "default",
-                                .import_record_index = stmt.import_record_index,
-                            };
-                        }
-                    }
-
-                    if (macro_remap) |*remap| {
-                        if (remap.get("default")) |remapped_path| {
-                            const new_import_id = p.addImportRecord(.stmt, path.loc, remapped_path);
-                            try p.macro.refs.put(ref, new_import_id);
-
-                            p.import_records.items[new_import_id].path.namespace = js_ast.Macro.namespace;
-                            p.import_records.items[new_import_id].is_unused = true;
-                            if (comptime only_scan_imports_and_do_not_visit) {
-                                p.import_records.items[new_import_id].is_internal = true;
-                                p.import_records.items[new_import_id].path.is_disabled = true;
-                            }
-                            stmt.default_name = null;
-                            remap_count += 1;
-                            break :outer;
-                        }
-                    }
-
-                    if (comptime track_symbol_usage_during_parse_pass) {
-                        p.parse_pass_symbol_uses.put(name, .{
-                            .ref = ref,
+                // ensure every e_import_identifier holds the namespace
+                if (p.options.features.hot_module_reloading) {
+                    const symbol = &p.symbols.items[ref.inner_index];
+                    if (symbol.namespace_alias == null) {
+                        symbol.namespace_alias = .{
+                            .namespace_ref = stmt.namespace_ref,
+                            .alias = "default",
                             .import_record_index = stmt.import_record_index,
-                        }) catch unreachable;
+                        };
                     }
+                }
 
-                    if (is_macro) {
-                        try p.macro.refs.put(ref, stmt.import_record_index);
+                if (macro_remap) |*remap| {
+                    if (remap.get("default")) |remapped_path| {
+                        const new_import_id = p.addImportRecord(.stmt, path.loc, remapped_path);
+                        try p.macro.refs.put(ref, new_import_id);
+
+                        p.import_records.items[new_import_id].path.namespace = js_ast.Macro.namespace;
+                        p.import_records.items[new_import_id].is_unused = true;
+                        if (comptime only_scan_imports_and_do_not_visit) {
+                            p.import_records.items[new_import_id].is_internal = true;
+                            p.import_records.items[new_import_id].path.is_disabled = true;
+                        }
                         stmt.default_name = null;
+                        remap_count += 1;
                         break :outer;
                     }
-
-                    if (comptime ParsePassSymbolUsageType != void) {
-                        p.parse_pass_symbol_uses.put(name, .{
-                            .ref = ref,
-                            .import_record_index = stmt.import_record_index,
-                        }) catch unreachable;
-                    }
-
-                    item_refs.putAssumeCapacity(name, name_loc.*);
                 }
+
+                if (comptime track_symbol_usage_during_parse_pass) {
+                    p.parse_pass_symbol_uses.put(name, .{
+                        .ref = ref,
+                        .import_record_index = stmt.import_record_index,
+                    }) catch unreachable;
+                }
+
+                if (is_macro) {
+                    try p.macro.refs.put(ref, stmt.import_record_index);
+                    stmt.default_name = null;
+                    break :outer;
+                }
+
+                if (comptime ParsePassSymbolUsageType != void) {
+                    p.parse_pass_symbol_uses.put(name, .{
+                        .ref = ref,
+                        .import_record_index = stmt.import_record_index,
+                    }) catch unreachable;
+                }
+
+                item_refs.putAssumeCapacity(name, name_loc.*);
             }
             var end: usize = 0;
 
@@ -9110,7 +9062,7 @@ fn NewParser_(
                     if (symbol.namespace_alias == null) {
                         symbol.namespace_alias = .{
                             .namespace_ref = stmt.namespace_ref,
-                            .alias = name,
+                            .alias = item.alias,
                             .import_record_index = stmt.import_record_index,
                         };
                     }
@@ -9200,6 +9152,8 @@ fn NewParser_(
                         }
                     }
                 }
+            } else if (import_tag == .bake_resolve_to_ssr_graph) {
+                p.import_records.items[stmt.import_record_index].tag = import_tag;
             }
         }
 
@@ -9630,7 +9584,6 @@ fn NewParser_(
                             if (p.lexer.isContextualKeyword("async")) {
                                 const async_range = p.lexer.range();
                                 try p.lexer.next();
-                                var defaultName: js_ast.LocRef = undefined;
                                 if (p.lexer.token == T.t_function and !p.lexer.has_newline_before) {
                                     try p.lexer.next();
                                     var stmtOpts = ParseStatementOptions{
@@ -9643,16 +9596,16 @@ fn NewParser_(
                                         return stmt;
                                     }
 
-                                    if (stmt.data.s_function.func.name) |name| {
-                                        defaultName = js_ast.LocRef{ .loc = name.loc, .ref = name.ref };
-                                    } else {
-                                        defaultName = try p.createDefaultName(defaultLoc);
-                                    }
+                                    const defaultName = if (stmt.data.s_function.func.name) |name|
+                                        js_ast.LocRef{ .loc = name.loc, .ref = name.ref }
+                                    else
+                                        try p.createDefaultName(defaultLoc);
+
                                     const value = js_ast.StmtOrExpr{ .stmt = stmt };
                                     return p.s(S.ExportDefault{ .default_name = defaultName, .value = value }, loc);
                                 }
 
-                                defaultName = try createDefaultName(p, loc);
+                                const defaultName = try createDefaultName(p, loc);
 
                                 const prefix_expr = try p.parseAsyncPrefixExpr(async_range, Level.comma);
                                 const expr = try p.parseSuffix(prefix_expr, Level.comma, null, Expr.EFlags.none);
@@ -9849,12 +9802,12 @@ fn NewParser_(
                                 const namespace_ref = p.storeNameInRef(
                                     std.fmt.allocPrint(
                                         p.allocator,
-                                        "import_{any}",
+                                        "import_{}",
                                         .{
                                             path_name.fmtIdentifier(),
                                         },
-                                    ) catch unreachable,
-                                ) catch unreachable;
+                                    ) catch bun.outOfMemory(),
+                                ) catch bun.outOfMemory();
 
                                 if (comptime track_symbol_usage_during_parse_pass) {
                                     // In the scan pass, we need _some_ way of knowing *not* to mark as unused
@@ -10206,7 +10159,7 @@ fn NewParser_(
                             isForAwait = false;
                         } else {
                             // TODO: improve error handling here
-                            //         		didGenerateError := p.markSyntaxFeature(compat.ForAwait, awaitRange)
+                            //                 didGenerateError := p.markSyntaxFeature(compat.ForAwait, awaitRange)
                             if (p.fn_or_arrow_data_parse.is_top_level) {
                                 p.top_level_await_keyword = await_range;
                                 // p.markSyntaxFeature(compat.TopLevelAwait, awaitRange)
@@ -11112,7 +11065,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) {
@@ -11150,16 +11103,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);
                 }
             }
@@ -11833,7 +11786,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;
@@ -12182,9 +12135,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,
             };
@@ -12209,6 +12163,7 @@ fn NewParser_(
                 const SupportedAttribute = enum {
                     type,
                     embed,
+                    bunBakeGraph,
                 };
 
                 var has_seen_embed_true = false;
@@ -12217,21 +12172,16 @@ fn NewParser_(
                     const supported_attribute: ?SupportedAttribute = brk: {
                         // Parse the key
                         if (p.lexer.isIdentifierOrKeyword()) {
-                            if (strings.eqlComptime(p.lexer.identifier, "type")) {
-                                break :brk .type;
-                            }
-
-                            if (strings.eqlComptime(p.lexer.identifier, "embed")) {
-                                break :brk .embed;
+                            inline for (comptime std.enums.values(SupportedAttribute)) |t| {
+                                if (strings.eqlComptime(p.lexer.identifier, @tagName(t))) {
+                                    break :brk t;
+                                }
                             }
                         } else if (p.lexer.token == .t_string_literal) {
-                            if (p.lexer.string_literal_is_ascii) {
-                                if (strings.eqlComptime(p.lexer.string_literal_slice, "type")) {
-                                    break :brk .type;
-                                }
-
-                                if (strings.eqlComptime(p.lexer.string_literal_slice, "embed")) {
-                                    break :brk .embed;
+                            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 {
@@ -12245,37 +12195,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;
+                    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;
                                     }
-                                },
-                                .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;
-                                        }
+                                } 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);
+                                }
+                            },
                         }
                     }
 
@@ -12451,8 +12407,7 @@ fn NewParser_(
         }
 
         pub inline fn isStrictModeOutputFormat(p: *P) bool {
-            // TODO: once CJS or IIFE is supported, this will need to be updated
-            return p.options.bundle;
+            return p.options.bundle and p.options.output_format.isESM();
         }
 
         pub fn declareCommonJSSymbol(p: *P, comptime kind: Symbol.Kind, comptime name: string) !Ref {
@@ -12499,22 +12454,13 @@ fn NewParser_(
             return ref;
         }
 
-        fn declareGeneratedSymbol(p: *P, kind: Symbol.Kind, comptime name: string) !GeneratedSymbol {
-            const static = comptime StaticSymbolName.init(name);
+        fn declareGeneratedSymbol(p: *P, kind: Symbol.Kind, comptime name: string) !Ref {
+            // The bundler runs the renamer, so it is ok to not append a hash
             if (p.options.bundle) {
-                const ref = try declareSymbolMaybeGenerated(p, .other, logger.Loc.Empty, static.primary, true);
-                return .{
-                    .backup = ref,
-                    .primary = ref,
-                    .ref = ref,
-                };
+                return try declareSymbolMaybeGenerated(p, kind, logger.Loc.Empty, name, true);
             }
 
-            return .{
-                .backup = try declareSymbolMaybeGenerated(p, .other, logger.Loc.Empty, static.backup, true),
-                .primary = try declareSymbolMaybeGenerated(p, .other, logger.Loc.Empty, static.primary, true),
-                .ref = try declareSymbolMaybeGenerated(p, kind, logger.Loc.Empty, static.internal, true),
-            };
+            return try declareSymbolMaybeGenerated(p, kind, logger.Loc.Empty, generatedSymbolName(name), true);
         }
 
         fn declareSymbol(p: *P, kind: Symbol.Kind, loc: logger.Loc, name: string) !Ref {
@@ -12523,7 +12469,6 @@ fn NewParser_(
 
         fn declareSymbolMaybeGenerated(p: *P, kind: Symbol.Kind, loc: logger.Loc, name: string, comptime is_generated: bool) !Ref {
             // p.checkForNonBMPCodePoint(loc, name)
-
             if (comptime !is_generated) {
                 // Forbid declaring a symbol with a reserved word in strict mode
                 if (p.isStrictMode() and name.ptr != arguments_str.ptr and js_lexer.StrictModeReservedWords.has(name)) {
@@ -12870,7 +12815,7 @@ fn NewParser_(
         pub const Backtracking = struct {
             pub inline fn lexerBacktracker(p: *P, func: anytype, comptime ReturnType: type) ReturnType {
                 p.markTypeScriptOnly();
-                var old_lexer = std.mem.toBytes(p.lexer);
+                const old_lexer = p.lexer;
                 const old_log_disabled = p.lexer.is_log_disabled;
                 p.lexer.is_log_disabled = true;
                 defer p.lexer.is_log_disabled = old_log_disabled;
@@ -12895,7 +12840,7 @@ fn NewParser_(
                 };
 
                 if (backtrack) {
-                    p.lexer = std.mem.bytesToValue(@TypeOf(p.lexer), &old_lexer);
+                    p.lexer.restore(&old_lexer);
 
                     if (comptime FnReturnType == anyerror!bool) {
                         return false;
@@ -12915,7 +12860,7 @@ fn NewParser_(
 
             pub inline fn lexerBacktrackerWithArgs(p: *P, func: anytype, args: anytype, comptime ReturnType: type) ReturnType {
                 p.markTypeScriptOnly();
-                var old_lexer = std.mem.toBytes(p.lexer);
+                const old_lexer = p.lexer;
                 const old_log_disabled = p.lexer.is_log_disabled;
                 p.lexer.is_log_disabled = true;
 
@@ -12936,7 +12881,7 @@ fn NewParser_(
                 };
 
                 if (backtrack) {
-                    p.lexer = std.mem.bytesToValue(@TypeOf(p.lexer), &old_lexer);
+                    p.lexer.restore(&old_lexer);
                     if (comptime FnReturnType == anyerror!bool) {
                         return false;
                     }
@@ -13838,7 +13783,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() };
                 };
 
@@ -13864,7 +13809,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);
@@ -14750,7 +14695,7 @@ fn NewParser_(
             }
 
             p.log.level = .verbose;
-            p.log.printForLogLevel(panic_stream.writer()) catch unreachable;
+            p.log.print(panic_stream.writer()) catch unreachable;
 
             Output.panic(fmt ++ "\n{s}", args ++ .{panic_buffer[0..panic_stream.pos]});
         }
@@ -14949,7 +14894,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);
 
@@ -15483,7 +15428,10 @@ fn NewParser_(
 
             p.lexer.preserve_all_comments_before = true;
             try p.lexer.expect(.t_open_paren);
-            const comments = try p.lexer.comments_to_preserve_before.toOwnedSlice();
+
+            // const comments = try p.lexer.comments_to_preserve_before.toOwnedSlice();
+            p.lexer.comments_to_preserve_before.clearRetainingCapacity();
+
             p.lexer.preserve_all_comments_before = false;
 
             const value = try p.parseExpr(.comma);
@@ -15521,7 +15469,7 @@ fn NewParser_(
                 }
             }
 
-            _ = comments; // TODO: leading_interior comments
+            // _ = comments; // TODO: leading_interior comments
 
             return p.newExpr(E.Import{
                 .expr = value,
@@ -15536,7 +15484,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;
@@ -15672,7 +15620,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 });
                                 },
@@ -15745,7 +15693,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 => {
@@ -15791,10 +15739,16 @@ fn NewParser_(
                         const end_tag = try JSXTag.parse(P, p);
 
                         if (!strings.eql(end_tag.name, tag.name)) {
-                            try p.log.addRangeErrorFmt(p.source, end_tag.range, p.allocator, "Expected closing tag \\</{s}> to match opening tag \\<{s}>", .{
-                                end_tag.name,
-                                tag.name,
-                            });
+                            try p.log.addRangeErrorFmtWithNote(
+                                p.source,
+                                end_tag.range,
+                                p.allocator,
+                                "Expected closing JSX tag to match opening tag \"\\<{s}\\>\"",
+                                .{tag.name},
+                                "Opening tag here:",
+                                .{},
+                                tag.range,
+                            );
                             return error.SyntaxError;
                         }
 
@@ -16225,10 +16179,10 @@ fn NewParser_(
                         return exp;
                     }
 
-                    //         		// Capture "this" inside arrow functions that will be lowered into normal
+                    //                 // Capture "this" inside arrow functions that will be lowered into normal
                     // // function expressions for older language environments
                     // if p.fnOrArrowDataVisit.isArrow && p.options.unsupportedJSFeatures.Has(compat.Arrow) && p.fnOnlyDataVisit.isThisNested {
-                    // 	return js_ast.Expr{Loc: expr.Loc, Data: &js_ast.EIdentifier{Ref: p.captureThis()}}, exprOut{}
+                    //     return js_ast.Expr{Loc: expr.Loc, Data: &js_ast.EIdentifier{Ref: p.captureThis()}}, exprOut{}
                     // }
                 },
                 .e_import_meta => {
@@ -16269,7 +16223,7 @@ fn NewParser_(
 
                     // Handle assigning to a constant
                     if (in.assign_target != .none) {
-                        if (p.symbols.items[result.ref.innerIndex()].kind == .constant) {
+                        if (p.symbols.items[result.ref.innerIndex()].kind == .constant) { // TODO: silence this for runtime transpiler
                             const r = js_lexer.rangeOfIdentifier(p.source, expr.loc);
                             var notes = p.allocator.alloc(logger.Data, 1) catch unreachable;
                             notes[0] = logger.Data{
@@ -16329,6 +16283,11 @@ fn NewParser_(
                             if (def.call_can_be_unwrapped_if_unused and !p.options.ignore_dce_annotations) {
                                 e_.call_can_be_unwrapped_if_unused = true;
                             }
+
+                            // If the user passed --drop=console, drop all property accesses to console.
+                            if (def.method_call_must_be_replaced_with_undefined and in.property_access_for_method_call_maybe_should_replace_with_undefined and in.assign_target == .none) {
+                                p.method_call_must_be_replaced_with_undefined = true;
+                            }
                         }
 
                         // Substitute uncalled "require" for the require target
@@ -16384,24 +16343,7 @@ fn NewParser_(
 
                             const runtime = if (p.options.jsx.runtime == .automatic) options.JSX.Runtime.automatic else options.JSX.Runtime.classic;
                             const is_key_after_spread = e_.flags.contains(.is_key_after_spread);
-                            var children_count = e_.children.len;
-
-                            const is_childless_tag = FeatureFlags.react_specific_warnings and children_count > 0 and
-                                tag.data == .e_string and tag.data.e_string.isUTF8() and js_lexer.ChildlessJSXTags.has(tag.data.e_string.slice(p.allocator));
-
-                            children_count = if (is_childless_tag) 0 else children_count;
-
-                            if (children_count != e_.children.len) {
-                                // Error: meta is a void element tag and must neither have `children` nor use `dangerouslySetInnerHTML`.
-                                // ^ from react-dom
-                                p.log.addWarningFmt(
-                                    p.source,
-                                    tag.loc,
-                                    p.allocator,
-                                    "\\<{s} /> is a void element and must not have \"children\"",
-                                    .{tag.data.e_string.slice(p.allocator)},
-                                ) catch {};
-                            }
+                            const children_count = e_.children.len;
 
                             // TODO: maybe we should split these into two different AST Nodes
                             // That would reduce the amount of allocations a little
@@ -16999,6 +16941,10 @@ fn NewParser_(
                                     if (!define.data.valueless) {
                                         return p.valueForDefine(expr.loc, in.assign_target, is_delete_target, &define.data);
                                     }
+
+                                    if (define.data.method_call_must_be_replaced_with_undefined and in.property_access_for_method_call_maybe_should_replace_with_undefined) {
+                                        p.method_call_must_be_replaced_with_undefined = true;
+                                    }
                                 }
 
                                 // Copy the side effect flags over in case this expression is unused
@@ -17030,7 +16976,9 @@ fn NewParser_(
                         }
                     }
 
-                    e_.target = p.visitExpr(e_.target);
+                    e_.target = p.visitExprInOut(e_.target, .{
+                        .property_access_for_method_call_maybe_should_replace_with_undefined = in.property_access_for_method_call_maybe_should_replace_with_undefined,
+                    });
 
                     // 'require.resolve' -> .e_require_resolve_call_target
                     if (e_.target.data == .e_require_call_target and
@@ -17302,6 +17250,7 @@ fn NewParser_(
                     const target_was_identifier_before_visit = e_.target.data == .e_identifier;
                     e_.target = p.visitExprInOut(e_.target, .{
                         .has_chain_parent = e_.optional_chain == .continuation,
+                        .property_access_for_method_call_maybe_should_replace_with_undefined = true,
                     });
 
                     // Copy the call side effect flag over if this is a known target
@@ -17357,6 +17306,7 @@ fn NewParser_(
                         defer p.options.ignore_dce_annotations = old_ce;
                         const old_should_fold_typescript_constant_expressions = p.should_fold_typescript_constant_expressions;
                         defer p.should_fold_typescript_constant_expressions = old_should_fold_typescript_constant_expressions;
+                        const old_is_control_flow_dead = p.is_control_flow_dead;
 
                         // We want to forcefully fold constants inside of
                         // certain calls even when minification is disabled, so
@@ -17373,9 +17323,29 @@ fn NewParser_(
                             p.should_fold_typescript_constant_expressions = true;
                         }
 
+                        var method_call_should_be_replaced_with_undefined = p.method_call_must_be_replaced_with_undefined;
+
+                        if (method_call_should_be_replaced_with_undefined) {
+                            p.method_call_must_be_replaced_with_undefined = false;
+                            switch (e_.target.data) {
+                                // If we're removing this call, don't count any arguments as symbol uses
+                                .e_index, .e_dot => {
+                                    p.is_control_flow_dead = true;
+                                },
+                                else => {
+                                    method_call_should_be_replaced_with_undefined = false;
+                                },
+                            }
+                        }
+
                         for (e_.args.slice()) |*arg| {
                             arg.* = p.visitExpr(arg.*);
                         }
+
+                        if (method_call_should_be_replaced_with_undefined) {
+                            p.is_control_flow_dead = old_is_control_flow_dead;
+                            return .{ .data = .{ .e_undefined = .{} }, .loc = expr.loc };
+                        }
                     }
 
                     if (e_.target.data == .e_require_call_target) {
@@ -17522,6 +17492,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_| {
@@ -17631,7 +17626,7 @@ fn NewParser_(
         /// If --target=bun, this does nothing.
         fn recordUsageOfRuntimeRequire(p: *P) void {
             // target bun does not have __require
-            if (!p.options.features.use_import_meta_require) {
+            if (p.options.features.auto_polyfill_require) {
                 bun.assert(p.options.features.allow_runtime);
 
                 p.ensureRequireSymbol();
@@ -17640,9 +17635,7 @@ fn NewParser_(
         }
 
         fn ignoreUsageOfRuntimeRequire(p: *P) void {
-            if (!p.options.features.use_import_meta_require and
-                p.options.features.allow_runtime)
-            {
+            if (p.options.features.auto_polyfill_require) {
                 bun.assert(p.runtime_imports.__require != null);
                 p.ignoreUsage(p.runtimeIdentifierRef(logger.Loc.Empty, "__require"));
                 p.symbols.items[p.require_ref.innerIndex()].use_count_estimate -|= 1;
@@ -18306,7 +18299,7 @@ fn NewParser_(
 
                             const loc_ref = LocRef{
                                 .loc = loc,
-                                .ref = p.newSymbol(.other, symbol_name) catch unreachable,
+                                .ref = (p.declareGeneratedSymbol(.other, symbol_name) catch unreachable),
                             };
 
                             p.module_scope.generated.push(p.allocator, loc_ref.ref.?) catch unreachable;
@@ -18713,12 +18706,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);
                             }
                         }
                     }
@@ -18961,7 +18953,13 @@ fn NewParser_(
 
             switch (stmt.data) {
                 // These don't contain anything to traverse
-                .s_debugger, .s_empty, .s_comment => {
+                .s_debugger => {
+                    p.current_scope.is_after_const_local_prefix = was_after_after_const_local_prefix;
+                    if (p.define.drop_debugger) {
+                        return;
+                    }
+                },
+                .s_empty, .s_comment => {
                     p.current_scope.is_after_const_local_prefix = was_after_after_const_local_prefix;
                 },
                 .s_type_script => {
@@ -19050,16 +19048,6 @@ fn NewParser_(
                     }
                 },
                 .s_export_from => |data| {
-                    // When HMR is enabled, we need to transform this into
-                    // import {foo} from "./foo";
-                    // export {foo};
-
-                    // From:
-                    // export {foo as default} from './foo';
-                    // To:
-                    // import {default as foo} from './foo';
-                    // export {foo};
-
                     // "export {foo} from 'path'"
                     const name = p.loadNameFromRef(data.namespace_ref);
 
@@ -19083,7 +19071,7 @@ fn NewParser_(
 
                             const _name = p.loadNameFromRef(old_ref);
 
-                            const ref = try p.newSymbol(.other, _name);
+                            const ref = try p.newSymbol(.import, _name);
                             try p.current_scope.generated.push(p.allocator, ref);
                             try p.recordDeclaredSymbol(ref);
                             data.items[j] = item;
@@ -19097,11 +19085,10 @@ fn NewParser_(
                             return;
                         }
                     } else {
-
                         // This is a re-export and the symbols created here are used to reference
                         for (data.items) |*item| {
                             const _name = p.loadNameFromRef(item.name.ref.?);
-                            const ref = try p.newSymbol(.other, _name);
+                            const ref = try p.newSymbol(.import, _name);
                             try p.current_scope.generated.push(p.allocator, ref);
                             try p.recordDeclaredSymbol(ref);
                             item.name.ref = ref;
@@ -19147,7 +19134,7 @@ fn NewParser_(
                     }
 
                     switch (data.value) {
-                        .expr => |expr| brk_expr: {
+                        .expr => |expr| {
                             const was_anonymous_named_expr = expr.isAnonymousNamed();
 
                             data.value.expr = p.visitExpr(expr);
@@ -19182,6 +19169,14 @@ fn NewParser_(
                                 }
                             }
 
+                            if (data.default_name.ref.?.isSourceContentsSlice()) {
+                                data.default_name = createDefaultName(p, data.value.expr.loc) catch unreachable;
+                            }
+
+                            if (p.options.features.server_components.wrapsExports()) {
+                                data.value.expr = p.wrapValueForServerComponentReference(data.value.expr, "default");
+                            }
+
                             // If there are lowered "using" declarations, change this into a "var"
                             if (p.current_scope.parent == null and p.will_wrap_module_in_try_catch_for_using) {
                                 try stmts.ensureUnusedCapacity(2);
@@ -19189,7 +19184,7 @@ fn NewParser_(
                                 const decls = p.allocator.alloc(G.Decl, 1) catch bun.outOfMemory();
                                 decls[0] = .{
                                     .binding = p.b(B.Identifier{ .ref = data.default_name.ref.? }, data.default_name.loc),
-                                    .value = expr,
+                                    .value = data.value.expr,
                                 };
                                 stmts.appendAssumeCapacity(p.s(S.Local{
                                     .decls = G.Decl.List.init(decls),
@@ -19203,7 +19198,6 @@ fn NewParser_(
                                 stmts.appendAssumeCapacity(p.s(S.ExportClause{
                                     .items = items,
                                 }, stmt.loc));
-                                break :brk_expr;
                             }
 
                             if (mark_for_replace) {
@@ -19215,10 +19209,6 @@ fn NewParser_(
                                     return;
                                 }
                             }
-
-                            if (data.default_name.ref.?.isSourceContentsSlice()) {
-                                data.default_name = createDefaultName(p, data.value.expr.loc) catch unreachable;
-                            }
                         },
 
                         .stmt => |s2| {
@@ -19268,6 +19258,10 @@ fn NewParser_(
                                         data.default_name = createDefaultName(p, stmt.loc) catch unreachable;
                                     }
 
+                                    if (p.options.features.server_components.wrapsExports()) {
+                                        data.value = .{ .expr = p.wrapValueForServerComponentReference(p.newExpr(E.Function{ .func = func.func }, stmt.loc), "default") };
+                                    }
+
                                     stmts.append(stmt.*) catch unreachable;
 
                                     // if (func.func.name != null and func.func.name.?.ref != null) {
@@ -19318,6 +19312,10 @@ fn NewParser_(
                                         stmts.append(stmt.*) catch {};
                                     }
 
+                                    if (p.options.features.server_components.wrapsExports()) {
+                                        data.value = .{ .expr = p.wrapValueForServerComponentReference(p.newExpr(class.class, stmt.loc), "default") };
+                                    }
+
                                     return;
                                 },
                                 else => {},
@@ -19444,8 +19442,25 @@ fn NewParser_(
                         }
                     }
 
+                    data.kind = kind;
                     try stmts.append(stmt.*);
 
+                    if (data.is_export and p.options.features.server_components.wrapsExports()) {
+                        for (data.decls.slice()) |*decl| try_annotate: {
+                            const val = decl.value orelse break :try_annotate;
+                            switch (val.data) {
+                                .e_arrow, .e_function => {},
+                                else => break :try_annotate,
+                            }
+                            const id = switch (decl.binding.data) {
+                                .b_identifier => |id| id.ref,
+                                else => break :try_annotate,
+                            };
+                            const original_name = p.symbols.items[id.innerIndex()].original_name;
+                            decl.value = p.wrapValueForServerComponentReference(val, original_name);
+                        }
+                    }
+
                     if (p.options.features.react_fast_refresh and p.current_scope == p.module_scope) {
                         for (data.decls.slice()) |decl| try_register: {
                             const val = decl.value orelse break :try_register;
@@ -19931,7 +19946,7 @@ fn NewParser_(
                                 data.cases[i].value = p.visitExpr(val);
                                 // TODO: error messages
                                 // Check("case", *c.Value, c.Value.Loc)
-                                // 				p.warnAboutTypeofAndString(s.Test, *c.Value)
+                                //                 p.warnAboutTypeofAndString(s.Test, *c.Value)
                             }
                             var _stmts = ListManaged(Stmt).fromOwnedSlice(p.allocator, case.body);
                             p.visitStmts(&_stmts, StmtsKind.none) catch unreachable;
@@ -19989,7 +20004,25 @@ fn NewParser_(
                             return;
                         }
 
-                        stmts.append(stmt.*) catch bun.outOfMemory();
+                        if (p.options.features.server_components.wrapsExports() and data.func.flags.contains(.is_export)) {
+                            // Convert this into `export var <name> = registerClientReference(<func>, ...);`
+                            const name = data.func.name.?;
+                            // From the inner scope, have code reference the wrapped function.
+                            data.func.name = null;
+                            try stmts.append(p.s(S.Local{
+                                .kind = .k_var,
+                                .is_export = true,
+                                .decls = try G.Decl.List.fromSlice(p.allocator, &.{.{
+                                    .binding = p.b(B.Identifier{ .ref = name_ref }, name.loc),
+                                    .value = p.wrapValueForServerComponentReference(
+                                        p.newExpr(E.Function{ .func = data.func }, stmt.loc),
+                                        original_name,
+                                    ),
+                                }}),
+                            }, stmt.loc));
+                        } else {
+                            stmts.append(stmt.*) catch bun.outOfMemory();
+                        }
                     } else if (mark_as_dead) {
                         if (p.options.features.replace_exports.getPtr(original_name)) |replacement| {
                             _ = p.injectReplacementExport(stmts, name_ref, data.func.name.?.loc, replacement);
@@ -20847,30 +20880,8 @@ fn NewParser_(
                         // TODO: prop.kind == .declare and prop.value == null
 
                         if (prop.ts_decorators.len > 0) {
-                            const loc = prop.key.?.loc;
-                            const _descriptor_key = switch (prop.key.?.data) {
-                                .e_identifier => |k| p.newExpr(E.Identifier{ .ref = k.ref }, loc),
-                                .e_number => |k| p.newExpr(E.Number{ .value = k.value }, loc),
-                                .e_string => |k| p.newExpr(E.String{ .data = k.data }, loc),
-                                .e_index => |k| p.newExpr(E.Index{ .target = k.target, .index = k.index }, loc),
-                                .e_private_identifier => |k| p.newExpr(E.PrivateIdentifier{ .ref = k.ref }, loc),
-
-                                // This should be unreachable. Due to zig bug using `unreachable` keyword or `noreturn` type will
-                                // result in a segfault at runtime with a release build. Minimum repro:
-                                //
-                                // class Foo {
-                                //   foo;
-                                // }
-                                //
-                                // Workaround: assign to null and say the orelse branch is unreachable. The cause
-                                // of this bug seems to be a combination of release build optimizations with switch expression
-                                // and unreachable or noreturn else.
-                                //
-                                // TODO: when zig is upgraded check if this workaround is still needed. The bug happens
-                                // on macos aarch64
-                                else => null,
-                            };
-                            const descriptor_key = _descriptor_key orelse unreachable;
+                            const descriptor_key = prop.key.?;
+                            const loc = descriptor_key.loc;
 
                             // TODO: when we have the `accessor` modifier, add `and !prop.flags.contains(.has_accessor_modifier)` to
                             // the if statement.
@@ -21813,8 +21824,9 @@ fn NewParser_(
                                 if (arg.is_typescript_ctor_field) {
                                     switch (arg.binding.data) {
                                         .b_identifier => |id| {
-                                            const name = p.symbols.items[id.ref.innerIndex()].original_name;
-                                            const ident = p.newExpr(E.Identifier{ .ref = id.ref }, arg.binding.loc);
+                                            const arg_symbol = p.symbols.items[id.ref.innerIndex()];
+                                            const name = arg_symbol.original_name;
+                                            const arg_ident = p.newExpr(E.Identifier{ .ref = id.ref }, arg.binding.loc);
 
                                             stmts.insert(if (super_index) |k| j + k + 1 else j, Stmt.assign(
                                                 p.newExpr(E.Dot{
@@ -21822,12 +21834,17 @@ fn NewParser_(
                                                     .name = name,
                                                     .name_loc = arg.binding.loc,
                                                 }, arg.binding.loc),
-                                                ident,
+                                                arg_ident,
                                             )) catch unreachable;
                                             // O(N)
                                             class_body.items.len += 1;
                                             bun.copy(G.Property, class_body.items[j + 1 ..], class_body.items[j .. class_body.items.len - 1]);
-                                            class_body.items[j] = G.Property{ .key = ident };
+                                            // Copy the argument name symbol to prevent the class field declaration from being renamed
+                                            // but not the constructor argument.
+                                            const field_symbol_ref = p.declareSymbol(.other, arg.binding.loc, name) catch id.ref;
+                                            field_symbol_ref.getSymbol(p.symbols.items).must_not_be_renamed = true;
+                                            const field_ident = p.newExpr(E.Identifier{ .ref = field_symbol_ref }, arg.binding.loc);
+                                            class_body.items[j] = G.Property{ .key = field_ident };
                                             j += 1;
                                         },
                                         else => {},
@@ -21877,17 +21894,16 @@ fn NewParser_(
                 if (!p.options.bundle) {
                     const generated_symbol = p.declareGeneratedSymbol(.other, name) catch unreachable;
                     p.runtime_imports.put(name, generated_symbol);
-                    return generated_symbol.ref;
+                    return generated_symbol;
                 } else {
                     const loc_ref = js_ast.LocRef{
                         .loc = loc,
                         .ref = p.newSymbol(.other, name) catch unreachable,
                     };
-                    p.runtime_imports.put(name, .{
-                        .primary = loc_ref.ref.?,
-                        .backup = loc_ref.ref.?,
-                        .ref = loc_ref.ref.?,
-                    });
+                    p.runtime_imports.put(
+                        name,
+                        loc_ref.ref.?,
+                    );
                     p.module_scope.generated.push(p.allocator, loc_ref.ref.?) catch unreachable;
                     return loc_ref.ref.?;
                 }
@@ -22191,29 +22207,37 @@ fn NewParser_(
                         switch (stmt.data) {
                             .s_empty, .s_comment, .s_directive, .s_debugger, .s_type_script => continue,
                             .s_local => |local| {
-                                if (!local.is_export and local.kind == .k_const and !local.was_commonjs_export) {
+                                if (!local.is_export and !local.was_commonjs_export) {
                                     var decls: []Decl = local.decls.slice();
                                     var end: usize = 0;
+                                    var any_decl_in_const_values = local.kind == .k_const;
                                     for (decls) |decl| {
                                         if (decl.binding.data == .b_identifier) {
-                                            const symbol = p.symbols.items[decl.binding.data.b_identifier.ref.innerIndex()];
-                                            if (p.const_values.contains(decl.binding.data.b_identifier.ref) and symbol.use_count_estimate == 0) {
-                                                continue;
+                                            if (p.const_values.contains(decl.binding.data.b_identifier.ref)) {
+                                                any_decl_in_const_values = true;
+                                                const symbol = p.symbols.items[decl.binding.data.b_identifier.ref.innerIndex()];
+                                                if (symbol.use_count_estimate == 0) {
+                                                    // Skip declarations that are constants with zero usage
+                                                    continue;
+                                                }
                                             }
                                         }
                                         decls[end] = decl;
                                         end += 1;
                                     }
                                     local.decls.len = @as(u32, @truncate(end));
-                                    if (end == 0) {
-                                        stmt.* = stmt.*.toEmpty();
+                                    if (any_decl_in_const_values) {
+                                        if (end == 0) {
+                                            stmt.* = stmt.*.toEmpty();
+                                        }
+                                        continue;
                                     }
-                                    continue;
                                 }
                             },
                             else => {},
                         }
 
+                        // Break after processing relevant statements
                         break;
                     }
                 }
@@ -22854,16 +22878,24 @@ fn NewParser_(
                 var end: u32 = 0;
                 for (stmts) |stmt| {
                     switch (stmt.data) {
-                        .s_directive,
-                        .s_import,
-                        .s_export_from,
-                        .s_export_star,
-                        => {
+                        .s_directive, .s_import, .s_export_from, .s_export_star => {
                             // These can't go in a try/catch block
                             result.append(stmt) catch bun.outOfMemory();
                             continue;
                         },
 
+                        .s_class => {
+                            if (stmt.data.s_class.is_export) {
+                                // can't go in try/catch; hoist out
+                                result.append(stmt) catch bun.outOfMemory();
+                                continue;
+                            }
+                        },
+
+                        .s_export_default => {
+                            continue; // this prevents re-exporting default since we already have it as an .s_export_clause
+                        },
+
                         .s_export_clause => |data| {
                             // Merge export clauses together
                             exports.appendSlice(data.items) catch bun.outOfMemory();
@@ -22906,7 +22938,6 @@ fn NewParser_(
                     end += 1;
                 }
 
-                // TODO(@paperdave): leak
                 const non_exported_statements = stmts[0..end];
 
                 const caught_ref = p.generateTempRef("_catch");
@@ -23084,6 +23115,35 @@ fn NewParser_(
             }
         }
 
+        pub fn wrapValueForServerComponentReference(p: *P, val: Expr, original_name: []const u8) Expr {
+            bun.assert(p.options.features.server_components.wrapsExports());
+            bun.assert(p.current_scope == p.module_scope);
+
+            if (p.options.features.server_components == .wrap_exports_for_server_reference)
+                bun.todoPanic(@src(), "registerServerReference", .{});
+
+            const module_path = p.newExpr(E.String{
+                .data = if (p.options.jsx.development)
+                    p.source.path.pretty
+                else
+                    bun.todoPanic(@src(), "TODO: unique_key here", .{}),
+            }, logger.Loc.Empty);
+
+            // registerClientReference(
+            //   Comp,
+            //   "src/filepath.tsx",
+            //   "Comp"
+            // );
+            return p.newExpr(E.Call{
+                .target = Expr.initIdentifier(p.server_components_wrap_ref, logger.Loc.Empty),
+                .args = js_ast.ExprNodeList.fromSlice(p.allocator, &.{
+                    val,
+                    module_path,
+                    p.newExpr(E.String{ .data = original_name }, logger.Loc.Empty),
+                }) catch bun.outOfMemory(),
+            }, logger.Loc.Empty);
+        }
+
         pub fn handleReactRefreshHookCall(p: *P, hook_call: *E.Call, original_name: []const u8) void {
             bun.assert(p.options.features.react_fast_refresh);
             bun.assert(ReactRefresh.isHookName(original_name));
@@ -23256,7 +23316,7 @@ fn NewParser_(
                 });
 
                 for (parts) |part| {
-                    // Kit does not care about 'import =', as it handles it on it's own
+                    // Bake does not care about 'import =', as it handles it on it's own
                     _ = try ImportScanner.scan(P, p, part.stmts, wrap_mode != .none, true, &hmr_transform_ctx);
                 }
 
@@ -23488,15 +23548,14 @@ fn NewParser_(
             parts_list.cap = @intCast(input_parts.len);
 
             return .{
-                .allocator = p.allocator,
                 .runtime_imports = p.runtime_imports,
                 .parts = parts_list,
                 .module_scope = p.module_scope.*,
-                .symbols = js_ast.Symbol.List.init(p.symbols.items),
+                .symbols = js_ast.Symbol.List.fromList(p.symbols),
                 .exports_ref = p.exports_ref,
                 .wrapper_ref = wrapper_ref,
                 .module_ref = p.module_ref,
-                .import_records = ImportRecord.List.init(p.import_records.items),
+                .import_records = ImportRecord.List.fromList(p.import_records),
                 .export_star_import_records = p.export_star_import_records.items,
                 .approximate_newline_count = p.lexer.approximate_newline_count,
                 .exports_kind = exports_kind,
@@ -23506,6 +23565,7 @@ fn NewParser_(
                 .export_keyword = p.esm_export_keyword,
                 .top_level_symbols_to_parts = top_level_symbols_to_parts,
                 .char_freq = p.computeCharacterFrequency(),
+                .directive = if (p.module_scope.strict_mode == .explicit_strict_mode) "use strict" else null,
 
                 // Assign slots to symbols in nested scopes. This is some precomputation for
                 // the symbol renaming pass that will happen later in the linker. It's done
@@ -23517,7 +23577,7 @@ fn NewParser_(
                     js_ast.SlotCounts{},
 
                 .require_ref = if (p.runtime_imports.__require != null)
-                    p.runtime_imports.__require.?.ref
+                    p.runtime_imports.__require.?
                 else
                     p.require_ref,
 
@@ -23525,9 +23585,9 @@ fn NewParser_(
                 .uses_module_ref = p.symbols.items[p.module_ref.inner_index].use_count_estimate > 0,
                 .uses_exports_ref = p.symbols.items[p.exports_ref.inner_index].use_count_estimate > 0,
                 .uses_require_ref = p.runtime_imports.__require != null and
-                    p.symbols.items[p.runtime_imports.__require.?.ref.inner_index].use_count_estimate > 0,
+                    p.symbols.items[p.runtime_imports.__require.?.inner_index].use_count_estimate > 0,
                 .commonjs_module_exports_assigned_deoptimized = p.commonjs_module_exports_assigned_deoptimized,
-                // .top_Level_await_keyword = p.top_level_await_keyword,
+                .top_level_await_keyword = p.top_level_await_keyword,
                 .commonjs_named_exports = p.commonjs_named_exports,
                 .has_commonjs_export_names = p.has_commonjs_export_names,
 
@@ -23588,317 +23648,6 @@ fn NewParser_(
             return false;
         }
 
-        const ConvertESMExportsForHmr = struct {
-            last_part: *js_ast.Part,
-            imports_seen: std.AutoArrayHashMapUnmanaged(u32, void) = .{},
-            export_props: std.ArrayListUnmanaged(G.Property) = .{},
-            stmts: std.ArrayListUnmanaged(Stmt) = .{},
-
-            fn convertStmt(ctx: *ConvertESMExportsForHmr, p: *P, stmt: Stmt) !void {
-                const new_stmt = switch (stmt.data) {
-                    else => stmt,
-                    .s_local => |st| stmt: {
-                        if (!st.is_export) break :stmt stmt;
-
-                        st.is_export = false;
-
-                        if (st.kind.isReassignable()) {
-                            for (st.decls.slice()) |decl| {
-                                try ctx.visitBindingForKitModuleExports(p, decl.binding, true);
-                            }
-                        } else {
-                            // TODO: remove this dupe
-                            var dupe_decls = try std.ArrayListUnmanaged(G.Decl).initCapacity(p.allocator, st.decls.len);
-
-                            for (st.decls.slice()) |decl| {
-                                bun.assert(decl.value != null); // const must be initialized
-
-                                switch (decl.binding.data) {
-                                    .b_missing => @panic("binding missing"),
-
-                                    .b_identifier => |id| {
-                                        const symbol = p.symbols.items[id.ref.inner_index];
-
-                                        // if the symbol is not used, we don't need to preserve
-                                        // a binding in this scope. we can move it to the exports object.
-                                        if (symbol.use_count_estimate != 0 or !decl.value.?.canBeMoved()) {
-                                            dupe_decls.appendAssumeCapacity(decl);
-                                        }
-
-                                        try ctx.export_props.append(p.allocator, .{
-                                            .key = Expr.init(E.String, .{ .data = symbol.original_name }, decl.binding.loc),
-                                            .value = decl.value,
-                                        });
-                                    },
-
-                                    else => {
-                                        dupe_decls.appendAssumeCapacity(decl);
-                                        try ctx.visitBindingForKitModuleExports(p, decl.binding, false);
-                                    },
-                                }
-                            }
-
-                            if (dupe_decls.items.len == 0) {
-                                return;
-                            }
-
-                            st.decls = G.Decl.List.fromList(dupe_decls);
-                        }
-
-                        break :stmt stmt;
-                    },
-                    .s_export_default => |st| stmt: {
-                        // Simple case: we can move this to the default property of the exports object
-                        if (st.canBeMoved()) {
-                            try ctx.export_props.append(p.allocator, .{
-                                .key = Expr.init(E.String, .{ .data = "default" }, stmt.loc),
-                                .value = st.value.toExpr(),
-                            });
-                            // no statement emitted
-                            return;
-                        }
-
-                        // Otherwise, we need a temporary
-                        const temp_id = p.generateTempRef("default_export");
-                        try ctx.last_part.declared_symbols.append(p.allocator, .{ .ref = temp_id, .is_top_level = true });
-                        try ctx.last_part.symbol_uses.putNoClobber(p.allocator, temp_id, .{ .count_estimate = 1 });
-                        try p.module_scope.generated.push(p.allocator, temp_id);
-
-                        try ctx.export_props.append(p.allocator, .{
-                            .key = Expr.init(E.String, .{ .data = "default" }, stmt.loc),
-                            .value = Expr.initIdentifier(temp_id, stmt.loc),
-                        });
-
-                        break :stmt Stmt.alloc(S.Local, .{
-                            .kind = .k_const,
-                            .decls = try G.Decl.List.fromSlice(p.allocator, &.{
-                                .{
-                                    .binding = Binding.alloc(p.allocator, B.Identifier{ .ref = temp_id }, stmt.loc),
-                                    .value = st.value.toExpr(),
-                                },
-                            }),
-                        }, stmt.loc);
-                    },
-                    .s_class => |st| stmt: {
-                        // Strip the "export" keyword
-                        if (!st.is_export) break :stmt stmt;
-
-                        // Export as CommonJS
-                        try ctx.export_props.append(p.allocator, .{
-                            .key = Expr.init(E.String, .{
-                                .data = p.symbols.items[st.class.class_name.?.ref.?.inner_index].original_name,
-                            }, stmt.loc),
-                            .value = Expr.initIdentifier(st.class.class_name.?.ref.?, stmt.loc),
-                        });
-
-                        st.is_export = false;
-
-                        break :stmt stmt;
-                    },
-                    .s_function => |st| stmt: {
-                        // Strip the "export" keyword
-                        if (!st.func.flags.contains(.is_export)) break :stmt stmt;
-
-                        st.func.flags.remove(.is_export);
-
-                        // Export as CommonJS
-                        try ctx.export_props.append(p.allocator, .{
-                            .key = Expr.init(E.String, .{
-                                .data = p.symbols.items[st.func.name.?.ref.?.inner_index].original_name,
-                            }, stmt.loc),
-                            .value = Expr.initIdentifier(st.func.name.?.ref.?, stmt.loc),
-                        });
-
-                        break :stmt stmt;
-                    },
-                    .s_export_clause => |st| {
-                        for (st.items) |item| {
-                            try ctx.export_props.append(p.allocator, .{
-                                .key = Expr.init(E.String, .{
-                                    .data = item.alias,
-                                }, stmt.loc),
-                                .value = Expr.initIdentifier(item.name.ref.?, item.name.loc),
-                            });
-                        }
-
-                        return; // do not emit a statement here
-                    },
-
-                    .s_export_from => |st| {
-                        _ = st; // autofix
-                        @panic("TODO s_export_from");
-                    },
-                    .s_export_star => |st| {
-                        _ = st; // autofix
-                        @panic("TODO s_export_star");
-                    },
-
-                    // De-duplicate import statements. It is okay to disregard
-                    // named/default imports here as we always rewrite them as
-                    // full qualified property accesses (need to so live-bindings)
-                    .s_import => |st| stmt: {
-                        const gop = try ctx.imports_seen.getOrPut(p.allocator, st.import_record_index);
-                        if (gop.found_existing) return;
-                        break :stmt stmt;
-                    },
-                };
-
-                try ctx.stmts.append(p.allocator, new_stmt);
-            }
-
-            fn visitBindingForKitModuleExports(
-                ctx: *ConvertESMExportsForHmr,
-                p: *P,
-                binding: Binding,
-                is_live_binding: bool,
-            ) !void {
-                switch (binding.data) {
-                    .b_missing => @panic("missing!"),
-                    .b_identifier => |id| {
-                        try ctx.visitRefForKitModuleExports(p, id.ref, binding.loc, is_live_binding);
-                    },
-                    .b_array => |array| {
-                        for (array.items) |item| {
-                            try ctx.visitBindingForKitModuleExports(p, item.binding, is_live_binding);
-                        }
-                    },
-                    .b_object => |object| {
-                        for (object.properties) |item| {
-                            try ctx.visitBindingForKitModuleExports(p, item.value, is_live_binding);
-                        }
-                    },
-                }
-            }
-
-            fn visitRefForKitModuleExports(
-                ctx: *ConvertESMExportsForHmr,
-                p: *P,
-                ref: Ref,
-                loc: logger.Loc,
-                is_live_binding: bool,
-            ) !void {
-                const symbol = p.symbols.items[ref.inner_index];
-                const id = Expr.initIdentifier(ref, loc);
-                if (is_live_binding) {
-                    const key = Expr.init(E.String, .{
-                        .data = symbol.original_name,
-                    }, loc);
-
-                    // This is technically incorrect in that we've marked this as a
-                    // top level symbol. but all we care about is preventing name
-                    // collisions, not necessarily the best minificaiton (dev only)
-                    const arg1 = p.generateTempRef(symbol.original_name);
-                    try ctx.last_part.declared_symbols.append(p.allocator, .{ .ref = arg1, .is_top_level = true });
-                    try ctx.last_part.symbol_uses.putNoClobber(p.allocator, arg1, .{ .count_estimate = 1 });
-                    try p.module_scope.generated.push(p.allocator, arg1);
-
-                    // Live bindings need to update the value internally and externally.
-                    // 'get abc() { return abc }'
-                    try ctx.export_props.append(p.allocator, .{
-                        .kind = .get,
-                        .key = key,
-                        .value = Expr.init(E.Function, .{ .func = .{
-                            .body = .{
-                                .stmts = try p.allocator.dupe(Stmt, &.{
-                                    Stmt.alloc(S.Return, .{ .value = id }, loc),
-                                }),
-                                .loc = loc,
-                            },
-                        } }, loc),
-                    });
-                    // 'set abc(abc2) { abc = abc2 }'
-                    try ctx.export_props.append(p.allocator, .{
-                        .kind = .set,
-                        .key = key,
-                        .value = Expr.init(E.Function, .{ .func = .{
-                            .args = try p.allocator.dupe(G.Arg, &.{.{
-                                .binding = Binding.alloc(p.allocator, B.Identifier{ .ref = arg1 }, loc),
-                            }}),
-                            .body = .{
-                                .stmts = try p.allocator.dupe(Stmt, &.{
-                                    Stmt.alloc(S.SExpr, .{
-                                        .value = Expr.assign(id, Expr.initIdentifier(arg1, loc)),
-                                    }, loc),
-                                }),
-                                .loc = loc,
-                            },
-                        } }, loc),
-                    });
-                } else {
-                    // 'abc,'
-                    try ctx.export_props.append(p.allocator, .{
-                        .key = Expr.init(E.String, .{
-                            .data = symbol.original_name,
-                        }, loc),
-                        .value = id,
-                    });
-                }
-            }
-
-            pub fn finalize(ctx: *ConvertESMExportsForHmr, p: *P, all_parts: []js_ast.Part) ![]js_ast.Part {
-                if (ctx.export_props.items.len > 0) {
-                    // add a marker for the client runtime to tell that this is an ES module
-                    try ctx.stmts.append(p.allocator, Stmt.alloc(S.SExpr, .{
-                        .value = Expr.assign(
-                            Expr.init(E.Dot, .{
-                                .target = Expr.initIdentifier(p.module_ref, logger.Loc.Empty),
-                                .name = "__esModule",
-                                .name_loc = logger.Loc.Empty,
-                            }, logger.Loc.Empty),
-                            Expr.init(E.Boolean, .{ .value = true }, logger.Loc.Empty),
-                        ),
-                    }, logger.Loc.Empty));
-
-                    try ctx.stmts.append(p.allocator, Stmt.alloc(S.SExpr, .{
-                        .value = Expr.assign(
-                            Expr.init(E.Dot, .{
-                                .target = Expr.initIdentifier(p.module_ref, logger.Loc.Empty),
-                                .name = "exports",
-                                .name_loc = logger.Loc.Empty,
-                            }, logger.Loc.Empty),
-                            Expr.init(E.Object, .{
-                                .properties = G.Property.List.fromList(ctx.export_props),
-                            }, logger.Loc.Empty),
-                        ),
-                    }, logger.Loc.Empty));
-
-                    // mark a dependency on module_ref so it is renamed
-                    try ctx.last_part.symbol_uses.put(p.allocator, p.module_ref, .{ .count_estimate = 1 });
-                    try ctx.last_part.declared_symbols.append(p.allocator, .{ .ref = p.module_ref, .is_top_level = true });
-                }
-
-                // TODO: this is a tiny mess. it is honestly trying to hard to merge all parts into one
-                for (all_parts[0 .. all_parts.len - 1]) |*part| {
-                    try ctx.last_part.declared_symbols.appendList(p.allocator, part.declared_symbols);
-                    try ctx.last_part.import_record_indices.append(p.allocator, part.import_record_indices.slice());
-                    for (part.symbol_uses.keys(), part.symbol_uses.values()) |k, v| {
-                        const gop = try ctx.last_part.symbol_uses.getOrPut(p.allocator, k);
-                        if (!gop.found_existing) {
-                            gop.value_ptr.* = v;
-                        } else {
-                            gop.value_ptr.count_estimate += v.count_estimate;
-                        }
-                    }
-                    part.stmts = &.{};
-                    part.declared_symbols.entries.len = 0;
-                    part.tag = .dead_due_to_inlining;
-                    part.dependencies.clearRetainingCapacity();
-                    try part.dependencies.push(p.allocator, .{
-                        .part_index = @intCast(all_parts.len - 1),
-                        .source_index = p.source.index,
-                    });
-                }
-
-                try ctx.last_part.import_record_indices.append(p.allocator, p.import_records_for_current_part.items);
-                try ctx.last_part.declared_symbols.appendList(p.allocator, p.declared_symbols);
-
-                ctx.last_part.stmts = ctx.stmts.items;
-                ctx.last_part.tag = .none;
-
-                return all_parts;
-            }
-        };
-
         pub fn init(
             allocator: Allocator,
             log: *logger.Log,
@@ -23933,7 +23682,7 @@ fn NewParser_(
                 .define = define,
                 .import_records = undefined,
                 .named_imports = undefined,
-                .named_exports = js_ast.Ast.NamedExports.init(allocator),
+                .named_exports = .{},
                 .log = log,
                 .allocator = allocator,
                 .options = opts,
@@ -23951,13 +23700,13 @@ fn NewParser_(
                 .needs_jsx_import = if (comptime only_scan_imports_and_do_not_visit) false else NeedsJSXType{},
                 .lexer = lexer,
 
-                // Only enable during bundling
-                .commonjs_named_exports_deoptimized = !opts.bundle,
+                // Only enable during bundling, when not bundling CJS
+                .commonjs_named_exports_deoptimized = if (opts.bundle) opts.output_format == .cjs else true,
             };
             this.lexer.track_comments = opts.features.minify_identifiers;
 
             this.unwrap_all_requires = brk: {
-                if (opts.bundle) {
+                if (opts.bundle and opts.output_format != .cjs) {
                     if (source.path.packageName()) |pkg| {
                         if (opts.features.shouldUnwrapRequire(pkg)) {
                             if (strings.eqlComptime(pkg, "react") or strings.eqlComptime(pkg, "react-dom")) {
@@ -23979,7 +23728,7 @@ fn NewParser_(
 
             if (comptime !only_scan_imports_and_do_not_visit) {
                 this.import_records = @TypeOf(this.import_records).init(allocator);
-                this.named_imports = NamedImportsType.init(allocator);
+                this.named_imports = .{};
             }
 
             this.to_expr_wrapper_namespace = Binding2ExprWrapper.Namespace.init(this);
@@ -24095,6 +23844,320 @@ const WrapMode = enum {
     bun_commonjs,
 };
 
+pub const ConvertESMExportsForHmr = struct {
+    last_part: *js_ast.Part,
+    imports_seen: std.AutoArrayHashMapUnmanaged(u32, void) = .{},
+    export_props: std.ArrayListUnmanaged(G.Property) = .{},
+    stmts: std.ArrayListUnmanaged(Stmt) = .{},
+
+    fn convertStmt(ctx: *ConvertESMExportsForHmr, p: anytype, stmt: Stmt) !void {
+        const new_stmt = switch (stmt.data) {
+            else => stmt,
+            .s_local => |st| stmt: {
+                if (!st.is_export) break :stmt stmt;
+
+                st.is_export = false;
+
+                if (st.kind.isReassignable()) {
+                    for (st.decls.slice()) |decl| {
+                        try ctx.visitBindingToExport(p, decl.binding, true);
+                    }
+                } else {
+                    // TODO: remove this dupe
+                    var dupe_decls = try std.ArrayListUnmanaged(G.Decl).initCapacity(p.allocator, st.decls.len);
+
+                    for (st.decls.slice()) |decl| {
+                        bun.assert(decl.value != null); // const must be initialized
+
+                        switch (decl.binding.data) {
+                            .b_missing => {},
+
+                            .b_identifier => |id| {
+                                const symbol = p.symbols.items[id.ref.inner_index];
+
+                                // if the symbol is not used, we don't need to preserve
+                                // a binding in this scope. we can move it to the exports object.
+                                if (symbol.use_count_estimate == 0 and decl.value.?.canBeMoved()) {
+                                    try ctx.export_props.append(p.allocator, .{
+                                        .key = Expr.init(E.String, .{ .data = symbol.original_name }, decl.binding.loc),
+                                        .value = decl.value,
+                                    });
+                                } else {
+                                    dupe_decls.appendAssumeCapacity(decl);
+                                    try ctx.visitBindingToExport(p, decl.binding, false);
+                                }
+                            },
+
+                            else => {
+                                dupe_decls.appendAssumeCapacity(decl);
+                                try ctx.visitBindingToExport(p, decl.binding, false);
+                            },
+                        }
+                    }
+
+                    if (dupe_decls.items.len == 0) {
+                        return;
+                    }
+
+                    st.decls = G.Decl.List.fromList(dupe_decls);
+                }
+
+                break :stmt stmt;
+            },
+            .s_export_default => |st| stmt: {
+                // Simple case: we can move this to the default property of the exports object
+                if (st.canBeMoved()) {
+                    try ctx.export_props.append(p.allocator, .{
+                        .key = Expr.init(E.String, .{ .data = "default" }, stmt.loc),
+                        .value = st.value.toExpr(),
+                    });
+                    // no statement emitted
+                    return;
+                }
+
+                // Otherwise, we need a temporary
+                const temp_id = p.generateTempRef("default_export");
+                try ctx.last_part.declared_symbols.append(p.allocator, .{ .ref = temp_id, .is_top_level = true });
+                try ctx.last_part.symbol_uses.putNoClobber(p.allocator, temp_id, .{ .count_estimate = 1 });
+                try p.current_scope.generated.push(p.allocator, temp_id);
+
+                try ctx.export_props.append(p.allocator, .{
+                    .key = Expr.init(E.String, .{ .data = "default" }, stmt.loc),
+                    .value = Expr.initIdentifier(temp_id, stmt.loc),
+                });
+
+                break :stmt Stmt.alloc(S.Local, .{
+                    .kind = .k_const,
+                    .decls = try G.Decl.List.fromSlice(p.allocator, &.{
+                        .{
+                            .binding = Binding.alloc(p.allocator, B.Identifier{ .ref = temp_id }, stmt.loc),
+                            .value = st.value.toExpr(),
+                        },
+                    }),
+                }, stmt.loc);
+            },
+            .s_class => |st| stmt: {
+                // Strip the "export" keyword
+                if (!st.is_export) break :stmt stmt;
+
+                // Export as CommonJS
+                try ctx.export_props.append(p.allocator, .{
+                    .key = Expr.init(E.String, .{
+                        .data = p.symbols.items[st.class.class_name.?.ref.?.inner_index].original_name,
+                    }, stmt.loc),
+                    .value = Expr.initIdentifier(st.class.class_name.?.ref.?, stmt.loc),
+                });
+
+                st.is_export = false;
+
+                break :stmt stmt;
+            },
+            .s_function => |st| stmt: {
+                // Strip the "export" keyword
+                if (!st.func.flags.contains(.is_export)) break :stmt stmt;
+
+                st.func.flags.remove(.is_export);
+
+                // Export as CommonJS
+                try ctx.export_props.append(p.allocator, .{
+                    .key = Expr.init(E.String, .{
+                        .data = p.symbols.items[st.func.name.?.ref.?.inner_index].original_name,
+                    }, stmt.loc),
+                    .value = Expr.initIdentifier(st.func.name.?.ref.?, stmt.loc),
+                });
+
+                break :stmt stmt;
+            },
+            .s_export_clause => |st| {
+                for (st.items) |item| {
+                    const ref = item.name.ref.?;
+                    try ctx.visitRefToExport(p, ref, item.alias, item.name.loc, false);
+                }
+
+                return; // do not emit a statement here
+            },
+            .s_export_from => |st| stmt: {
+                for (st.items) |*item| {
+                    const ref = item.name.ref.?;
+                    const symbol = &p.symbols.items[ref.innerIndex()];
+                    if (symbol.namespace_alias == null) {
+                        symbol.namespace_alias = .{
+                            .namespace_ref = st.namespace_ref,
+                            .alias = item.original_name,
+                            .import_record_index = st.import_record_index,
+                        };
+                    }
+                    try ctx.visitRefToExport(p, ref, item.alias, item.name.loc, true);
+
+                    // imports and export statements have their alias +
+                    // original_name swapped. this is likely a design bug in
+                    // the parser but since everything uses these
+                    // assumptions, this hack is simpler than making it
+                    // proper
+                    const alias = item.alias;
+                    item.alias = item.original_name;
+                    item.original_name = alias;
+                }
+
+                const gop = try ctx.imports_seen.getOrPut(p.allocator, st.import_record_index);
+                if (gop.found_existing) return;
+                break :stmt Stmt.alloc(S.Import, .{
+                    .import_record_index = st.import_record_index,
+                    .is_single_line = true,
+                    .default_name = null,
+                    .items = st.items,
+                    .namespace_ref = st.namespace_ref,
+                    .star_name_loc = null,
+                }, stmt.loc);
+            },
+            .s_export_star => {
+                bun.todoPanic(@src(), "hot-module-reloading instrumentation for 'export * from'", .{});
+            },
+            // De-duplicate import statements. It is okay to disregard
+            // named/default imports here as we always rewrite them as
+            // full qualified property accesses (need to so live-bindings)
+            .s_import => |st| stmt: {
+                const gop = try ctx.imports_seen.getOrPut(p.allocator, st.import_record_index);
+                if (gop.found_existing) return;
+                break :stmt stmt;
+            },
+        };
+
+        try ctx.stmts.append(p.allocator, new_stmt);
+    }
+
+    fn visitBindingToExport(
+        ctx: *ConvertESMExportsForHmr,
+        p: anytype,
+        binding: Binding,
+        is_live_binding: bool,
+    ) !void {
+        switch (binding.data) {
+            .b_missing => {},
+            .b_identifier => |id| {
+                try ctx.visitRefToExport(p, id.ref, null, binding.loc, is_live_binding);
+            },
+            .b_array => |array| {
+                for (array.items) |item| {
+                    try ctx.visitBindingToExport(p, item.binding, is_live_binding);
+                }
+            },
+            .b_object => |object| {
+                for (object.properties) |item| {
+                    try ctx.visitBindingToExport(p, item.value, is_live_binding);
+                }
+            },
+        }
+    }
+
+    fn visitRefToExport(
+        ctx: *ConvertESMExportsForHmr,
+        p: anytype,
+        ref: Ref,
+        export_symbol_name: ?[]const u8,
+        loc: logger.Loc,
+        is_live_binding_source: bool,
+    ) !void {
+        const symbol = p.symbols.items[ref.inner_index];
+        const id = if (symbol.kind == .import)
+            Expr.init(E.ImportIdentifier, .{ .ref = ref }, loc)
+        else
+            Expr.initIdentifier(ref, loc);
+        if (is_live_binding_source or symbol.kind == .import) {
+            // TODO: instead of requiring getters for live-bindings,
+            // a callback propagation system should be considered.
+            // mostly because here, these might not even be live
+            // bindings, and re-exports are so, so common.
+            const key = Expr.init(E.String, .{
+                .data = export_symbol_name orelse symbol.original_name,
+            }, loc);
+
+            // This is technically incorrect in that we've marked this as a
+            // top level symbol. but all we care about is preventing name
+            // collisions, not necessarily the best minificaiton (dev only)
+            const arg1 = p.generateTempRef(symbol.original_name);
+            try ctx.last_part.declared_symbols.append(p.allocator, .{ .ref = arg1, .is_top_level = true });
+            try ctx.last_part.symbol_uses.putNoClobber(p.allocator, arg1, .{ .count_estimate = 1 });
+            try p.current_scope.generated.push(p.allocator, arg1);
+
+            // Live bindings need to update the value internally and externally.
+            // 'get abc() { return abc }'
+            try ctx.export_props.append(p.allocator, .{
+                .kind = .get,
+                .key = key,
+                .value = Expr.init(E.Function, .{ .func = .{
+                    .body = .{
+                        .stmts = try p.allocator.dupe(Stmt, &.{
+                            Stmt.alloc(S.Return, .{ .value = id }, loc),
+                        }),
+                        .loc = loc,
+                    },
+                } }, loc),
+            });
+            // no setter is added since live bindings are read-only
+        } else {
+            // 'abc,'
+            try ctx.export_props.append(p.allocator, .{
+                .key = Expr.init(E.String, .{
+                    .data = export_symbol_name orelse symbol.original_name,
+                }, loc),
+                .value = id,
+            });
+        }
+    }
+
+    pub fn finalize(ctx: *ConvertESMExportsForHmr, p: anytype, all_parts: []js_ast.Part) ![]js_ast.Part {
+        if (ctx.export_props.items.len > 0) {
+            try ctx.stmts.append(p.allocator, Stmt.alloc(S.SExpr, .{
+                .value = Expr.assign(
+                    Expr.init(E.Dot, .{
+                        .target = Expr.initIdentifier(p.module_ref, logger.Loc.Empty),
+                        .name = "exports",
+                        .name_loc = logger.Loc.Empty,
+                    }, logger.Loc.Empty),
+                    Expr.init(E.Object, .{
+                        .properties = G.Property.List.fromList(ctx.export_props),
+                    }, logger.Loc.Empty),
+                ),
+            }, logger.Loc.Empty));
+
+            // mark a dependency on module_ref so it is renamed
+            try ctx.last_part.symbol_uses.put(p.allocator, p.module_ref, .{ .count_estimate = 1 });
+            try ctx.last_part.declared_symbols.append(p.allocator, .{ .ref = p.module_ref, .is_top_level = true });
+        }
+
+        // TODO: this is a tiny mess. it is honestly trying to hard to merge all parts into one
+        for (all_parts[0 .. all_parts.len - 1]) |*part| {
+            try ctx.last_part.declared_symbols.appendList(p.allocator, part.declared_symbols);
+            try ctx.last_part.import_record_indices.append(p.allocator, part.import_record_indices.slice());
+            for (part.symbol_uses.keys(), part.symbol_uses.values()) |k, v| {
+                const gop = try ctx.last_part.symbol_uses.getOrPut(p.allocator, k);
+                if (!gop.found_existing) {
+                    gop.value_ptr.* = v;
+                } else {
+                    gop.value_ptr.count_estimate += v.count_estimate;
+                }
+            }
+            part.stmts = &.{};
+            part.declared_symbols.entries.len = 0;
+            part.tag = .dead_due_to_inlining;
+            part.dependencies.clearRetainingCapacity();
+            try part.dependencies.push(p.allocator, .{
+                .part_index = @intCast(all_parts.len - 1),
+                .source_index = p.source.index,
+            });
+        }
+
+        try ctx.last_part.import_record_indices.append(p.allocator, p.import_records_for_current_part.items);
+        try ctx.last_part.declared_symbols.appendList(p.allocator, p.declared_symbols);
+
+        ctx.last_part.stmts = ctx.stmts.items;
+        ctx.last_part.tag = .none;
+
+        return all_parts;
+    }
+};
+
 /// Equivalent of esbuild's js_ast_helpers.ToInt32
 fn floatToInt32(f: f64) i32 {
     // Special-case non-finite numbers
diff --git a/src/js_printer.zig b/src/js_printer.zig
index 976a29ddd7..2963b96e65 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,110 +205,179 @@ 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;
+            },
+            '\'' => {
+                if (quote_char == '\'') {
+                    try writer.writeAll("\\'");
+                } else {
+                    try writer.writeAll("'");
+                }
+                i += 1;
+            },
+            '`' => {
+                if (quote_char == '`') {
+                    try writer.writeAll("\\`");
+                } else {
+                    try writer.writeAll("`");
+                }
+                i += 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 bytes.appendSlice("\\t");
+                try writer.writeAll("\\t");
                 i += 1;
             },
 
             else => {
                 i += @as(usize, width);
 
-                if (c < 0xFFFF) {
+                if (c <= 0xFF and !json) {
                     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{
+                    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{
                         '\\',
                         'u',
                         hex_chars[(k >> 12) & 0xF],
                         hex_chars[(k >> 8) & 0xF],
                         hex_chars[(k >> 4) & 0xF],
                         hex_chars[k & 0xF],
-                    };
+                    });
                 } 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{
+                    try writer.writeAll(&[_]u8{
                         '\\',
                         'u',
                         hex_chars[lo >> 12],
@@ -328,164 +390,24 @@ pub fn quoteForJSONBuffer(text: []const u8, bytes: *MutableString, comptime asci
                         hex_chars[(hi >> 8) & 15],
                         hex_chars[(hi >> 4) & 15],
                         hex_chars[hi & 15],
-                    };
+                    });
                 }
             },
         }
     }
+}
+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;
 }
 
-const JSONFormatter = struct {
-    input: []const u8,
-
-    pub fn format(self: JSONFormatter, comptime _: []const u8, _: std.fmt.FormatOptions, writer: anytype) !void {
-        try writeJSONString(self.input, @TypeOf(writer), writer, .latin1);
-    }
-};
-
-const JSONFormatterUTF8 = struct {
-    input: []const u8,
-
-    pub fn format(self: JSONFormatterUTF8, comptime _: []const u8, _: std.fmt.FormatOptions, writer: anytype) !void {
-        try writeJSONString(self.input, @TypeOf(writer), writer, .utf8);
-    }
-};
-
-/// Expects latin1
-pub fn formatJSONString(text: []const u8) JSONFormatter {
-    return .{ .input = text };
-}
-
-pub fn formatJSONStringUTF8(text: []const u8) JSONFormatterUTF8 {
-    return .{ .input = text };
-}
-
 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..];
-            },
-
-            '\t' => {
-                try writer.writeAll("\\t");
-                text = text[1..];
-            },
-
-            else => {
-                text = text[@as(usize, width)..];
-
-                if (c < 0xFFFF) {
-                    const k = @as(usize, @intCast(c));
-
-                    try writer.writeAll(&[_]u8{
-                        '\\',
-                        'u',
-                        hex_chars[(k >> 12) & 0xF],
-                        hex_chars[(k >> 8) & 0xF],
-                        hex_chars[(k >> 4) & 0xF],
-                        hex_chars[k & 0xF],
-                    });
-                } else {
-                    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)));
-
-                    try writer.writeAll(&[_]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 writePreQuotedString(input, Writer, writer, '"', false, true, encoding);
     try writer.writeAll("\"");
 }
 
@@ -518,7 +440,6 @@ pub const Options = struct {
     require_ref: ?Ref = null,
     import_meta_ref: Ref = Ref.None,
     indent: Indentation = .{},
-    externals: []u32 = &[_]u32{},
     runtime_imports: runtime.Runtime.Imports = runtime.Runtime.Imports{},
     module_hash: u32 = 0,
     source_path: ?fs.Path = null,
@@ -529,7 +450,7 @@ pub const Options = struct {
     target: options.Target = .browser,
 
     runtime_transpiler_cache: ?*bun.JSC.RuntimeTranspilerCache = null,
-    input_files_for_kit: ?[]logger.Source = null,
+    input_files_for_dev_server: ?[]logger.Source = null,
 
     commonjs_named_exports: js_ast.Ast.CommonJSNamedExports = .{},
     commonjs_named_exports_deoptimized: bool = false,
@@ -655,7 +576,7 @@ pub const PrintResult = union(enum) {
 // do not make this a packed struct
 // stage1 compiler bug:
 // > /optional-chain-with-function.js: Evaluation failed: TypeError: (intermediate value) is not a function
-// this test failure was caused by the packed structi mplementation
+// this test failure was caused by the packed struct implementation
 const ExprFlag = enum {
     forbid_call,
     forbid_in,
@@ -1092,11 +1013,6 @@ fn NewPrinter(
             printInternalBunImport(p, import, @TypeOf("globalThis.Bun"), "globalThis.Bun");
         }
 
-        fn printHardcodedImportStatement(p: *Printer, import: S.Import) void {
-            if (comptime !is_bun_platform) unreachable;
-            printInternalBunImport(p, import, void, {});
-        }
-
         fn printInternalBunImport(p: *Printer, import: S.Import, comptime Statement: type, statement: Statement) void {
             if (comptime !is_bun_platform) unreachable;
 
@@ -1458,7 +1374,7 @@ fn NewPrinter(
                 p.printSpaceBeforeIdentifier();
                 p.printIdentifier(alias);
             } else {
-                p.printQuotedUTF8(alias, false);
+                p.printStringLiteralUTF8(alias, false);
             }
         }
 
@@ -1672,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;
+        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);
 
-            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;
-                                    }
-
-                                    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 {
@@ -1915,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(
@@ -1945,6 +1658,7 @@ fn NewPrinter(
 
             assert(p.import_records.len > import_record_index);
             const record = p.importRecord(import_record_index);
+            const module_type = p.options.module_type;
 
             if (comptime is_bun_platform) {
                 // "bun" is not a real module. It's just globalThis.Bun.
@@ -1968,13 +1682,13 @@ fn NewPrinter(
                     },
                     .bun_test => {
                         if (record.kind == .dynamic) {
-                            if (p.options.module_type == .cjs) {
+                            if (module_type == .cjs) {
                                 p.print("Promise.resolve(globalThis.Bun.jest(__filename))");
                             } else {
                                 p.print("Promise.resolve(globalThis.Bun.jest(import.meta.path))");
                             }
                         } else if (record.kind == .require) {
-                            if (p.options.module_type == .cjs) {
+                            if (module_type == .cjs) {
                                 p.print("globalThis.Bun.jest(__filename)");
                             } else {
                                 p.print("globalThis.Bun.jest(import.meta.path)");
@@ -2032,14 +1746,14 @@ fn NewPrinter(
                     p.print("(");
                 }
 
-                if (p.options.input_files_for_kit) |input_files| {
-                    bun.assert(p.options.module_type == .internal_kit_dev);
+                if (p.options.input_files_for_dev_server) |input_files| {
+                    bun.assert(module_type == .internal_bake_dev);
                     p.printSpaceBeforeIdentifier();
                     p.printSymbol(p.options.commonjs_module_ref);
                     p.print(".require(");
                     {
                         const path = input_files[record.source_index.get()].path;
-                        p.printInlinedEnum(.{ .number = @floatFromInt(path.hashForKit()) }, path.pretty, level);
+                        p.printStringLiteralUTF8(path.pretty, false);
                     }
                     p.print(")");
                 } else if (!meta.was_unwrapped_require) {
@@ -2074,7 +1788,7 @@ fn NewPrinter(
                 }
 
                 if (wrap_with_to_esm) {
-                    if (p.options.module_type.isESM()) {
+                    if (module_type.isESM()) {
                         p.print(",");
                         p.printSpace();
                         p.print("1");
@@ -2085,18 +1799,12 @@ fn NewPrinter(
                 return;
             }
 
-            const is_external = std.mem.indexOfScalar(
-                u32,
-                p.options.externals,
-                import_record_index,
-            ) != null;
-
             // External "require()"
             if (record.kind != .dynamic) {
                 p.printSpaceBeforeIdentifier();
 
                 if (p.options.inline_require_and_import_errors) {
-                    if (record.path.is_disabled and record.handles_import_errors and !is_external) {
+                    if (record.path.is_disabled and record.handles_import_errors) {
                         p.printRequireError(record.path.text);
                         return;
                     }
@@ -2107,7 +1815,28 @@ fn NewPrinter(
                     }
                 }
 
-                if (p.options.module_type == .esm and is_bun_platform) {
+                const wrap_with_to_esm = record.wrap_with_to_esm;
+
+                if (module_type == .internal_bake_dev) {
+                    p.printSpaceBeforeIdentifier();
+                    p.printSymbol(p.options.commonjs_module_ref);
+                    if (record.tag == .builtin)
+                        p.print(".importBuiltin(")
+                    else
+                        p.print(".require(");
+                    {
+                        const path = record.path;
+                        p.printStringLiteralUTF8(path.pretty, false);
+                    }
+                    p.print(")");
+                    return;
+                } else if (wrap_with_to_esm) {
+                    p.printSpaceBeforeIdentifier();
+                    p.printSymbol(p.options.to_esm_ref);
+                    p.print("(");
+                }
+
+                if (module_type == .esm and is_bun_platform) {
                     p.print("import.meta.require");
                 } else if (p.options.require_ref) |ref| {
                     p.printSymbol(ref);
@@ -2118,6 +1847,10 @@ fn NewPrinter(
                 p.print("(");
                 p.printImportRecordPath(record);
                 p.print(")");
+
+                if (wrap_with_to_esm) {
+                    p.print(")");
+                }
                 return;
             }
 
@@ -2163,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);
         }
 
@@ -2186,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);
@@ -2215,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);
@@ -2328,7 +2060,7 @@ fn NewPrinter(
                 .e_import_meta => {
                     p.printSpaceBeforeIdentifier();
                     p.addSourceMapping(expr.loc);
-                    if (p.options.module_type == .internal_kit_dev) {
+                    if (p.options.module_type == .internal_bake_dev) {
                         p.printSymbol(p.options.commonjs_module_ref);
                         p.print(".importMeta()");
                     } else if (!p.options.import_meta_ref.isValid()) {
@@ -2359,7 +2091,7 @@ fn NewPrinter(
                         }
                         p.print("import.meta.main");
                     } else {
-                        bun.assert(p.options.module_type != .internal_kit_dev);
+                        bun.assert(p.options.module_type != .internal_bake_dev);
 
                         p.printSpaceBeforeIdentifier();
                         p.addSourceMapping(expr.loc);
@@ -2421,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 {
@@ -2609,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) {
@@ -2626,7 +2358,12 @@ fn NewPrinter(
 
                         p.printSpaceBeforeIdentifier();
                         p.addSourceMapping(expr.loc);
-                        p.print("import(");
+                        if (p.options.module_type == .internal_bake_dev) {
+                            p.printSymbol(p.options.commonjs_module_ref);
+                            p.print(".dynamicImport(");
+                        } else {
+                            p.print("import(");
+                        }
                         // TODO:
                         // if (e.leading_interior_comments.len > 0) {
                         //     p.printNewline();
@@ -2696,7 +2433,7 @@ fn NewPrinter(
                         flags,
                     );
 
-                    if (p.canPrintIdentifier(e.name)) {
+                    if (js_lexer.isIdentifier(e.name)) {
                         if (isOptionalChain) {
                             p.print("?.");
                         } else {
@@ -2717,10 +2454,7 @@ fn NewPrinter(
                             p.print("[");
                         }
 
-                        p.printPossiblyEscapedIdentifierString(
-                            e.name,
-                            true,
-                        );
+                        p.printStringLiteralUTF8(e.name, false);
 
                         p.print("]");
                     }
@@ -2955,7 +2689,7 @@ fn NewPrinter(
                             p.indent();
                         }
 
-                        if (e.is_single_line) {
+                        if (e.is_single_line and !is_json) {
                             p.printSpace();
                         } else {
                             p.printNewline();
@@ -2967,7 +2701,7 @@ fn NewPrinter(
                             for (props[1..]) |property| {
                                 p.print(",");
 
-                                if (e.is_single_line) {
+                                if (e.is_single_line and !is_json) {
                                     p.printSpace();
                                 } else {
                                     p.printNewline();
@@ -2977,12 +2711,12 @@ fn NewPrinter(
                             }
                         }
 
-                        if (!e.is_single_line) {
+                        if (e.is_single_line and !is_json) {
+                            p.printSpace();
+                        } else {
                             p.unindent();
                             p.printNewline();
                             p.printIndent();
-                        } else {
-                            p.printSpace();
                         }
                     }
                     if (e.close_brace_loc.start > expr.loc.start) {
@@ -3013,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| {
@@ -3049,7 +2775,7 @@ fn NewPrinter(
                         .cooked => |*cooked| {
                             if (cooked.isPresent()) {
                                 cooked.resolveRopeIfNeeded(p.options.allocator);
-                                p.printStringContent(cooked, '`');
+                                p.printStringCharactersEString(cooked, '`');
                             }
                         },
                     }
@@ -3063,7 +2789,7 @@ fn NewPrinter(
                             .cooked => |*cooked| {
                                 if (cooked.isPresent()) {
                                     cooked.resolveRopeIfNeeded(p.options.allocator);
-                                    p.printStringContent(cooked, '`');
+                                    p.printStringCharactersEString(cooked, '`');
                                 }
                             },
                         }
@@ -3104,12 +2830,16 @@ fn NewPrinter(
                     // Potentially use a property access instead of an identifier
                     var didPrint = false;
 
-                    const ref = if (p.options.module_type != .internal_kit_dev)
+                    const ref = if (p.options.module_type != .internal_bake_dev)
                         p.symbols().follow(e.ref)
                     else
                         e.ref;
                     const symbol = p.symbols().get(ref).?;
 
+                    // if (bun.strings.eql(symbol.original_name, "registerClientReference")) {
+                    //     @breakpoint();
+                    // }
+
                     if (symbol.import_item_status == .missing) {
                         p.printUndefined(expr.loc, level);
                         didPrint = true;
@@ -3164,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);
@@ -3172,7 +2902,7 @@ fn NewPrinter(
                                 p.print("[");
                                 // TODO: addSourceMappingForName
                                 // p.addSourceMappingForName(alias);
-                                p.printPossiblyEscapedIdentifierString(alias, true);
+                                p.printStringLiteralUTF8(alias, false);
                                 p.print("]");
                             }
 
@@ -3191,7 +2921,7 @@ fn NewPrinter(
                     // }
 
                     if (!didPrint) {
-                        // assert(p.options.module_type != .internal_kit_dev);
+                        // assert(p.options.module_type != .internal_bake_dev);
                         p.printSpaceBeforeIdentifier();
                         p.addSourceMapping(expr.loc);
                         p.printSymbol(e.ref);
@@ -3353,104 +3083,21 @@ 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);
+                p.printStringCharactersUTF8(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);
-            }
-        }
-
-        pub fn printNamespaceAlias(p: *Printer, import_record: ImportRecord, namespace: G.NamespaceAlias) void {
-            if (import_record.module_id > 0 and !import_record.contains_import_star) {
-                p.print("$");
-                p.printModuleId(import_record.module_id);
-            } else {
-                p.printSymbol(namespace.namespace_ref);
-            }
+        pub fn printNamespaceAlias(p: *Printer, _: ImportRecord, namespace: G.NamespaceAlias) void {
+            p.printSymbol(namespace.namespace_ref);
 
             // In the case of code like this:
             // module.exports = require("foo")
@@ -3459,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("]");
             }
         }
@@ -3690,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
@@ -3710,9 +3357,10 @@ fn NewPrinter(
                                         }
                                     }
                                 },
-                                // .e_import_identifier => |e| inner: {
-                                .e_import_identifier => |e| {
+                                .e_import_identifier => |e| inner: {
                                     const ref = p.symbols().follow(e.ref);
+                                    if (p.options.input_files_for_dev_server != null)
+                                        break :inner;
                                     // if (p.options.const_values.count() > 0 and p.options.const_values.contains(ref))
                                     //     break :inner;
 
@@ -3730,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;
 
@@ -3773,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);
                     }
                 },
@@ -3931,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
@@ -3945,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();
@@ -4345,62 +3993,6 @@ fn NewPrinter(
 
                     const import_record = p.importRecord(s.import_record_index);
 
-                    if (comptime is_bun_platform) {
-                        if (import_record.do_commonjs_transform_in_printer) {
-                            if (s.items.len == 0)
-                                return;
-                            p.print("var {");
-                            var symbol_counter: u32 = p.symbol_counter;
-
-                            for (s.items, 0..) |item, i| {
-                                if (i > 0) {
-                                    p.print(",");
-                                }
-
-                                p.print(item.original_name);
-                                assert(item.original_name.len > 0);
-                                p.print(":");
-                                // this is unsound
-                                // this is technical debt
-                                // we need to handle symbol collisions for this
-                                p.print("$eXp0rT_");
-                                var buf: [16]u8 = undefined;
-                                p.print(std.fmt.bufPrint(&buf, "{}", .{bun.fmt.hexIntLower(symbol_counter)}) catch unreachable);
-                                symbol_counter +|= 1;
-                            }
-
-                            p.print("}=import.meta.require(");
-                            p.printImportRecordPath(import_record);
-                            p.print(")");
-                            p.printSemicolonAfterStatement();
-                            p.printWhitespacer(ws("export {"));
-
-                            // reset symbol counter back
-                            symbol_counter = p.symbol_counter;
-
-                            for (s.items, 0..) |item, i| {
-                                if (i > 0) {
-                                    p.print(",");
-                                }
-
-                                // this is unsound
-                                // this is technical debt
-                                // we need to handle symbol collisions for this
-                                p.print("$eXp0rT_");
-                                var buf: [16]u8 = undefined;
-                                p.print(std.fmt.bufPrint(&buf, "{}", .{bun.fmt.hexIntLower(symbol_counter)}) catch unreachable);
-                                symbol_counter +|= 1;
-                                p.printWhitespacer(ws(" as "));
-                                p.print(item.alias);
-                            }
-
-                            p.print("}");
-                            p.printSemicolonAfterStatement();
-                            p.symbol_counter = symbol_counter;
-                            return;
-                        }
-                    }
-
                     p.printWhitespacer(ws("export {"));
 
                     if (!s.is_single_line) {
@@ -4691,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| {
@@ -4755,47 +4347,17 @@ fn NewPrinter(
                                 p.printGlobalBunImportStatement(s.*);
                                 return;
                             },
-                            // .hardcoded => {
-                            //     p.printHardcodedImportStatement(s.*);
-                            //     return;
-                            // },
                             else => {},
                         }
                     }
 
-                    if (record.do_commonjs_transform_in_printer or record.path.is_disabled) {
-                        const require_ref = p.options.require_ref;
-
-                        const module_id = record.module_id;
-
-                        if (!record.path.is_disabled and std.mem.indexOfScalar(u32, p.imported_module_ids.items, module_id) == null) {
-                            p.printWhitespacer(ws("import * as"));
-                            p.print(" ");
-                            p.printModuleId(module_id);
-                            p.print(" ");
-                            p.printWhitespacer(ws("from "));
-                            p.print("\"");
-                            p.print(record.path.text);
-                            p.print("\"");
-                            p.printSemicolonAfterStatement();
-                            try p.imported_module_ids.append(module_id);
-                        }
-
+                    if (record.path.is_disabled) {
                         if (record.contains_import_star) {
                             p.print("var ");
                             p.printSymbol(s.namespace_ref);
                             p.@"print = "();
-                            if (!record.path.is_disabled) {
-                                p.printSymbol(require_ref.?);
-                                p.print("(");
-                                p.printModuleId(module_id);
-
-                                p.print(");");
-                                p.printNewline();
-                            } else {
-                                p.printDisabledImport();
-                                p.printSemicolonAfterStatement();
-                            }
+                            p.printDisabledImport();
+                            p.printSemicolonAfterStatement();
                         }
 
                         if (s.items.len > 0 or s.default_name != null) {
@@ -4839,12 +4401,6 @@ fn NewPrinter(
                             if (record.contains_import_star) {
                                 p.printSymbol(s.namespace_ref);
                                 p.printSemicolonAfterStatement();
-                            } else if (!record.path.is_disabled) {
-                                p.printSymbol(require_ref.?);
-                                p.print("(");
-                                p.printModuleId(module_id);
-                                p.print(")");
-                                p.printSemicolonAfterStatement();
                             } else {
                                 p.printDisabledImport();
                                 p.printSemicolonAfterStatement();
@@ -4980,7 +4536,7 @@ fn NewPrinter(
 
                     p.printIndent();
                     p.printSpaceBeforeIdentifier();
-                    p.printQuotedUTF8(s.value, false);
+                    p.printStringLiteralUTF8(s.value, false);
                     p.printSemicolonAfterStatement();
                 },
                 .s_break => |s| {
@@ -5034,15 +4590,8 @@ fn NewPrinter(
                     p.printExpr(s.value, .lowest, ExprFlag.ExprResultIsUnused());
                     p.printSemicolonAfterStatement();
                 },
-                else => {
-                    var slice = p.writer.slice();
-                    const to_print: []const u8 = if (slice.len > 1024) slice[slice.len - 1024 ..] else slice;
-
-                    if (to_print.len > 0) {
-                        Output.panic("\n<r><red>voluntary crash<r> while printing:<r>\n{s}\n---This is a <b>bug<r>. Not your fault.\n", .{to_print});
-                    } else {
-                        Output.panic("\n<r><red>voluntary crash<r> while printing. This is a <b>bug<r>. Not your fault.\n", .{});
-                    }
+                else => |tag| {
+                    Output.panic("Unexpected tag in printStmt: .{s}", .{@tagName(tag)});
                 },
             }
         }
@@ -5056,21 +4605,15 @@ fn NewPrinter(
                 unreachable;
 
             const quote = bestQuoteCharForString(u8, import_record.path.text, false);
-            if (import_record.print_namespace_in_path and import_record.module_id != 0) {
+            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.printModuleIdAssumeEnabled(import_record.module_id);
-                p.print(quote);
-            } else if (import_record.print_namespace_in_path and !import_record.path.isFile()) {
-                p.print(quote);
-                p.print(import_record.path.namespace);
-                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);
             }
         }
@@ -5214,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);
@@ -5231,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})");
@@ -5484,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);
@@ -5719,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");
         }
@@ -5904,7 +5455,7 @@ const FileWriterInternal = struct {
         ctx: *FileWriterInternal,
     ) anyerror!void {
         defer buffer.reset();
-        const result_ = buffer.toOwnedSliceLeaky();
+        const result_ = buffer.slice();
         var result = result_;
 
         while (result.len > 0) {
@@ -5973,6 +5524,15 @@ pub const BufferWriter = struct {
             ) catch unreachable,
         };
     }
+
+    pub fn print(ctx: *BufferWriter, comptime fmt: string, args: anytype) anyerror!void {
+        try ctx.buffer.list.writer(ctx.buffer.allocator).print(fmt, args);
+    }
+
+    pub fn writeByteNTimes(ctx: *BufferWriter, byte: u8, n: usize) anyerror!void {
+        try ctx.buffer.appendCharNTimes(byte, n);
+    }
+
     pub fn writeByte(ctx: *BufferWriter, byte: u8) anyerror!usize {
         try ctx.buffer.appendChar(byte);
         ctx.approximate_newline_count += @intFromBool(byte == '\n');
@@ -6045,10 +5605,10 @@ pub const BufferWriter = struct {
         }
 
         if (ctx.append_null_byte) {
-            ctx.sentinel = ctx.buffer.toOwnedSentinelLeaky();
-            ctx.written = ctx.buffer.toOwnedSliceLeaky();
+            ctx.sentinel = ctx.buffer.sliceWithSentinel();
+            ctx.written = ctx.buffer.slice();
         } else {
-            ctx.written = ctx.buffer.toOwnedSliceLeaky();
+            ctx.written = ctx.buffer.slice();
         }
     }
 
@@ -6145,7 +5705,7 @@ pub fn printAst(
     var module_scope = tree.module_scope;
     if (opts.minify_identifiers) {
         const allocator = opts.allocator;
-        var reserved_names = try rename.computeInitialReservedNames(allocator);
+        var reserved_names = try rename.computeInitialReservedNames(allocator, opts.module_type);
         for (module_scope.children.slice()) |child| {
             child.parent = &module_scope;
         }
@@ -6430,12 +5990,34 @@ pub fn printWithWriterAndPlatform(
         imported_module_ids_list = printer.imported_module_ids;
     }
 
-    if (opts.module_type == .internal_kit_dev) {
+    if (opts.module_type == .internal_bake_dev) {
         printer.indent();
         printer.printIndent();
-        printer.fmt("{d}", .{source.path.hashForKit()}) catch bun.outOfMemory();
-        printer.print(": function");
-        printer.printFunc(parts[0].stmts[0].data.s_expr.value.data.e_function.func);
+        printer.printStringLiteralUTF8(source.path.pretty, false);
+        const func = parts[0].stmts[0].data.s_expr.value.data.e_function.func;
+        if (!(func.body.stmts.len == 1 and func.body.stmts[0].data == .s_lazy_export)) {
+            printer.printFunc(func);
+        } else {
+            // Special-case lazy-export AST
+            // @branchHint(.unlikely)
+            printer.printFnArgs(func.open_parens_loc, func.args, func.flags.contains(.has_rest_arg), false);
+            printer.printSpace();
+            printer.print("{\n");
+            if (func.body.stmts[0].data.s_lazy_export != .e_undefined) {
+                printer.indent();
+                printer.printIndent();
+                printer.printSymbol(printer.options.commonjs_module_ref);
+                printer.print(".exports = ");
+                printer.printExpr(.{
+                    .data = func.body.stmts[0].data.s_lazy_export,
+                    .loc = func.body.stmts[0].loc,
+                }, .comma, .{});
+                printer.print("; // bun .s_lazy_export\n");
+                printer.unindent();
+            }
+            printer.printIndent();
+            printer.print("}");
+        }
         printer.print(",\n");
     } else {
         // The IIFE wrapper is done in `postProcessJSChunk`, so we just manually
diff --git a/src/jsc.zig b/src/jsc.zig
index c49313cb80..7fa5521390 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;
@@ -49,10 +51,8 @@ pub const API = struct {
     pub const UDPSocket = @import("./bun.js/api/bun/udp_socket.zig").UDPSocket;
     pub const Listener = @import("./bun.js/api/bun/socket.zig").Listener;
     pub const H2FrameParser = @import("./bun.js/api/bun/h2_frame_parser.zig").H2FrameParser;
-    pub const BrotliEncoder = @import("./bun.js/api/js_brotli.zig").BrotliEncoder;
-    pub const BrotliDecoder = @import("./bun.js/api/js_brotli.zig").BrotliDecoder;
-    pub const ZlibEncoder = @import("./bun.js/api/js_zlib.zig").ZlibEncoder;
-    pub const ZlibDecoder = @import("./bun.js/api/js_zlib.zig").ZlibDecoder;
+    pub const NativeZlib = @import("./bun.js/node/node_zlib_binding.zig").SNativeZlib;
+    pub const NativeBrotli = @import("./bun.js/node/node_zlib_binding.zig").SNativeBrotli;
 };
 pub const Postgres = @import("./sql/postgres.zig");
 pub const DNS = @import("./bun.js/api/bun/dns_resolver.zig");
@@ -117,7 +117,6 @@ else
 
 pub const Error = @import("ErrorCode").Error;
 
-pub const MAX_SAFE_INTEGER = std.math.maxInt(i52);
-pub const MIN_SAFE_INTEGER = std.math.minInt(i52);
-pub const MAX_NUMBER = std.math.maxInt(f64);
-pub const MIN_NUMBER = std.math.minInt(f64);
+pub const MAX_SAFE_INTEGER = 9007199254740991;
+
+pub const MIN_SAFE_INTEGER = -9007199254740991;
diff --git a/src/json_parser.zig b/src/json_parser.zig
index bf46ea15ed..4d30b2d090 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);
@@ -710,10 +707,11 @@ var empty_array_data = Expr.Data{ .e_array = &empty_array };
 /// Parse JSON
 /// This leaves UTF-16 strings as UTF-16 strings
 /// The JavaScript Printer will handle escaping strings if necessary
-pub fn ParseJSON(
+pub fn parse(
     source: *const logger.Source,
     log: *logger.Log,
     allocator: std.mem.Allocator,
+    comptime force_utf8: bool,
 ) !Expr {
     var parser = try JSONParser.init(allocator, source.*, log);
     switch (source.contents.len) {
@@ -734,7 +732,7 @@ pub fn ParseJSON(
         else => {},
     }
 
-    return try parser.parseExpr(false, false);
+    return try parser.parseExpr(false, force_utf8);
 }
 
 /// Parse Package JSON
@@ -742,7 +740,7 @@ pub fn ParseJSON(
 /// This eagerly transcodes UTF-16 strings into UTF-8 strings
 /// Use this when the text may need to be reprinted to disk as JSON (and not as JavaScript)
 /// Eagerly converting UTF-8 to UTF-16 can cause a performance issue
-pub fn ParsePackageJSONUTF8(
+pub fn parsePackageJSONUTF8(
     source: *const logger.Source,
     log: *logger.Log,
     allocator: std.mem.Allocator,
@@ -769,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);
@@ -778,7 +775,7 @@ pub fn ParsePackageJSONUTF8(
     return try parser.parseExpr(false, true);
 }
 
-pub fn ParsePackageJSONUTF8AlwaysDecode(
+pub fn parsePackageJSONUTF8AlwaysDecode(
     source: *const logger.Source,
     log: *logger.Log,
     allocator: std.mem.Allocator,
@@ -805,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);
@@ -819,7 +815,7 @@ const JsonResult = struct {
     indentation: Indentation = .{},
 };
 
-pub fn ParsePackageJSONUTF8WithOpts(
+pub fn parsePackageJSONUTF8WithOpts(
     source: *const logger.Source,
     log: *logger.Log,
     allocator: std.mem.Allocator,
@@ -863,15 +859,15 @@ pub fn ParsePackageJSONUTF8WithOpts(
 /// This eagerly transcodes UTF-16 strings into UTF-8 strings
 /// Use this when the text may need to be reprinted to disk as JSON (and not as JavaScript)
 /// Eagerly converting UTF-8 to UTF-16 can cause a performance issue
-pub fn ParseJSONUTF8(
+pub fn parseUTF8(
     source: *const logger.Source,
     log: *logger.Log,
     allocator: std.mem.Allocator,
 ) !Expr {
-    return try ParseJSONUTF8Impl(source, log, allocator, false);
+    return try parseUTF8Impl(source, log, allocator, false);
 }
 
-pub fn ParseJSONUTF8Impl(
+pub fn parseUTF8Impl(
     source: *const logger.Source,
     log: *logger.Log,
     allocator: std.mem.Allocator,
@@ -908,7 +904,7 @@ pub fn ParseJSONUTF8Impl(
     }
     return result;
 }
-pub fn ParseJSONForMacro(source: *const logger.Source, log: *logger.Log, allocator: std.mem.Allocator) !Expr {
+pub fn parseForMacro(source: *const logger.Source, log: *logger.Log, allocator: std.mem.Allocator) !Expr {
     switch (source.contents.len) {
         // This is to be consisntent with how disabled JS files are handled
         0 => {
@@ -943,7 +939,7 @@ pub const JSONParseResult = struct {
     };
 };
 
-pub fn ParseJSONForBundling(source: *const logger.Source, log: *logger.Log, allocator: std.mem.Allocator) !JSONParseResult {
+pub fn parseForBundling(source: *const logger.Source, log: *logger.Log, allocator: std.mem.Allocator) !JSONParseResult {
     switch (source.contents.len) {
         // This is to be consisntent with how disabled JS files are handled
         0 => {
@@ -972,7 +968,7 @@ pub fn ParseJSONForBundling(source: *const logger.Source, log: *logger.Log, allo
 
 // threadlocal var env_json_auto_quote_buffer: MutableString = undefined;
 // threadlocal var env_json_auto_quote_buffer_loaded: bool = false;
-pub fn ParseEnvJSON(source: *const logger.Source, log: *logger.Log, allocator: std.mem.Allocator) !Expr {
+pub fn parseEnvJSON(source: *const logger.Source, log: *logger.Log, allocator: std.mem.Allocator) !Expr {
     switch (source.contents.len) {
         // This is to be consisntent with how disabled JS files are handled
         0 => {
@@ -1023,7 +1019,7 @@ pub fn ParseEnvJSON(source: *const logger.Source, log: *logger.Log, allocator: s
     }
 }
 
-pub fn ParseTSConfig(source: *const logger.Source, log: *logger.Log, allocator: std.mem.Allocator) !Expr {
+pub fn parseTSConfig(source: *const logger.Source, log: *logger.Log, allocator: std.mem.Allocator, comptime force_utf8: bool) !Expr {
     switch (source.contents.len) {
         // This is to be consisntent with how disabled JS files are handled
         0 => {
@@ -1044,7 +1040,7 @@ pub fn ParseTSConfig(source: *const logger.Source, log: *logger.Log, allocator:
 
     var parser = try TSConfigParser.init(allocator, source.*, log);
 
-    return parser.parseExpr(false, true);
+    return parser.parseExpr(false, force_utf8);
 }
 
 const duplicateKeyJson = "{ \"name\": \"valid\", \"name\": \"invalid\" }";
@@ -1072,7 +1068,7 @@ fn expectPrintedJSON(_contents: string, expected: string) !void {
         "source.json",
         contents,
     );
-    const expr = try ParseJSON(&source, &log, default_allocator);
+    const expr = try parse(&source, &log, default_allocator);
 
     if (log.msgs.items.len > 0) {
         Output.panic("--FAIL--\nExpr {s}\nLog: {s}\n--FAIL--", .{ expr, log.msgs.items[0].data.text });
diff --git a/src/kit/DevServer.zig b/src/kit/DevServer.zig
deleted file mode 100644
index 804a8803b4..0000000000
--- a/src/kit/DevServer.zig
+++ /dev/null
@@ -1,925 +0,0 @@
-//! Instance of the development server. Controls an event loop, web server,
-//! bundling threads, and JavaScript VM instance. All data is held in memory.
-//!
-//! Currently does not have a `deinit()`, as it is assumed to be alive for the
-//! remainder of this process' lifespan.
-pub const DevServer = @This();
-
-pub const Options = struct {
-    cwd: []u8,
-    routes: []Route,
-    listen_config: uws.AppListenConfig = .{ .port = 3000 },
-    dump_sources: ?[]const u8 = if (Environment.isDebug) ".kit-debug" else null,
-    verbose_watcher: bool = false,
-    // TODO: make it possible to inherit a js VM
-};
-
-/// Accepting a custom allocator for all of DevServer would be misleading
-/// as there are many functions which will use default_allocator.
-const default_allocator = bun.default_allocator;
-
-cwd: []const u8,
-dump_dir: ?std.fs.Dir,
-
-// UWS App
-app: *App,
-routes: []Route,
-address: struct {
-    port: u16,
-    hostname: [*:0]const u8,
-},
-listener: ?*App.ListenSocket,
-
-// Server Runtime
-server_global: *DevGlobalObject,
-vm: *VirtualMachine,
-
-// Bundling
-bundle_thread: BundleThread,
-
-// // Watch + HMR
-// bun_watcher: *HotReloader.Watcher,
-/// Required by `bun.JSC.NewHotReloader`
-bundler: Bundler,
-/// Required by `Bundler`
-log_do_not_use: Log,
-
-pub const internal_prefix = "/_bun";
-pub const client_prefix = internal_prefix ++ "/client";
-
-pub const Route = struct {
-    // Config
-    pattern: [:0]const u8,
-    entry_point: []const u8,
-
-    server_bundle: BundlePromise(ServerBundle) = .unqueued,
-    client_bundle: BundlePromise(ClientBundle) = .unqueued,
-
-    /// Assigned in DevServer.init
-    dev: *DevServer = undefined,
-    client_bundled_url: []u8 = undefined,
-
-    pub fn clientPublicPath(route: *const Route) []const u8 {
-        return route.client_bundled_url[0 .. route.client_bundled_url.len - "/client.js".len];
-    }
-};
-
-/// Prepared server-side bundle and loaded JavaScript module
-const ServerBundle = struct {
-    files: []OutputFile,
-    server_request_callback: JSC.JSValue,
-};
-
-/// Preparred client-side bundle.
-/// Namespaced to URL: `/_bun/client/:route_index/:file_path`
-const ClientBundle = struct {
-    files: []OutputFile,
-    /// Indexes into this are indexes into `files`.
-    /// This is case insensitive because URL paths should be case insensitive.
-    files_index: bun.CaseInsensitiveASCIIStringArrayHashMapUnmanaged(void),
-
-    pub fn getFile(bundle: *ClientBundle, filename: []const u8) ?*OutputFile {
-        return if (bundle.files_index.getIndex(filename)) |i|
-            &bundle.files[i]
-        else
-            null;
-    }
-};
-
-pub fn init(options: Options) *DevServer {
-    if (JSC.VirtualMachine.VMHolder.vm != null)
-        @panic("Cannot initialize kit.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(.{});
-
-    const dev = bun.new(DevServer, .{
-        .cwd = options.cwd,
-        .app = app,
-        .routes = options.routes,
-        .address = .{
-            .port = @intCast(options.listen_config.port),
-            .hostname = options.listen_config.host orelse "localhost",
-        },
-        .listener = null,
-        .bundle_thread = BundleThread.uninitialized,
-        .server_global = undefined,
-        .vm = undefined,
-        .dump_dir = dump_dir,
-        // .bun_watcher = undefined,
-        .bundler = undefined,
-        .log_do_not_use = Log.init(bun.failing_allocator),
-    });
-
-    dev.bundler = bun.Bundler.init(
-        default_allocator,
-        &dev.log_do_not_use,
-        std.mem.zeroes(bun.Schema.Api.TransformOptions),
-        null, // TODO:
-    ) catch bun.outOfMemory();
-
-    const loaders = bun.options.loadersFromTransformOptions(default_allocator, null, .bun) catch
-        bun.outOfMemory();
-
-    dev.bundler.options = .{
-        .entry_points = &.{},
-        .define = dev.bundler.options.define,
-        .loaders = loaders,
-        .log = &dev.log_do_not_use,
-        .output_dir = "", // this disables filesystem output
-        .output_format = .internal_kit_dev,
-        .out_extensions = bun.StringHashMap([]const u8).init(bun.failing_allocator),
-
-        // unused by all code
-        .resolve_mode = .dev,
-        // technically used (in macro) but should be removed
-        .transform_options = std.mem.zeroes(bun.Schema.Api.TransformOptions),
-    };
-    dev.bundler.configureLinker();
-    dev.bundler.resolver.opts = dev.bundler.options;
-
-    // const fs = bun.fs.FileSystem.init(options.cwd) catch @panic("Failed to init FileSystem");
-    // dev.bun_watcher = HotReloader.init(dev, fs, options.verbose_watcher, false);
-    // dev.bundler.resolver.watcher = dev.bun_watcher.getResolveWatcher();
-
-    dev.vm = VirtualMachine.initKit(.{
-        .allocator = default_allocator,
-        .args = std.mem.zeroes(bun.Schema.Api.TransformOptions),
-    }) catch |err|
-        Output.panic("Failed to create Global object: {}", .{err});
-    dev.server_global = c.KitCreateDevGlobal(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();
-
-    _ = JSC.WorkPool.get();
-    const thread = dev.bundle_thread.spawn() catch |err|
-        Output.panic("Failed to spawn bundler thread: {}", .{err});
-    thread.detach();
-
-    var has_fallback = false;
-
-    for (options.routes, 0..) |*route, i| {
-        app.any(route.pattern, *Route, route, onServerRequestInit);
-
-        route.dev = dev;
-        route.client_bundled_url = std.fmt.allocPrint(
-            default_allocator,
-            client_prefix ++ "/{d}/client.js",
-            .{i},
-        ) catch bun.outOfMemory();
-
-        if (bun.strings.eqlComptime(route.pattern, "/*"))
-            has_fallback = true;
-    }
-
-    app.get(client_prefix ++ "/:route/:asset", *DevServer, dev, onAssetRequestInit);
-
-    app.ws(
-        internal_prefix ++ "/hmr",
-        dev,
-        0,
-        uws.WebSocketBehavior.Wrap(DevServer, DevWebSocket, false).apply(.{}),
-    );
-
-    if (!has_fallback)
-        app.any("/*", void, {}, onFallbackRoute);
-
-    app.listenWithConfig(*DevServer, dev, onListen, options.listen_config);
-
-    return dev;
-}
-
-pub fn runLoopForever(dev: *DevServer) noreturn {
-    const lock = dev.vm.jsc.getAPILock();
-    defer lock.release();
-
-    while (true) {
-        dev.vm.tick();
-        dev.vm.eventLoop().autoTickActive();
-    }
-}
-
-// uws handlers
-
-fn onListen(ctx: *DevServer, maybe_listen: ?*App.ListenSocket) void {
-    const listen: *App.ListenSocket = maybe_listen orelse {
-        @panic("TODO: handle listen failure");
-    };
-
-    ctx.listener = listen;
-    ctx.address.port = @intCast(listen.getLocalPort());
-
-    Output.prettyErrorln("--\\> <magenta>http://{s}:{d}<r>\n", .{
-        bun.span(ctx.address.hostname),
-        ctx.address.port,
-    });
-    Output.flush();
-}
-
-fn onAssetRequestInit(dev: *DevServer, req: *Request, resp: *Response) void {
-    const route = route: {
-        const route_id = req.parameter(0);
-        const i = std.fmt.parseInt(u16, route_id, 10) catch
-            return req.setYield(true);
-        if (i >= dev.routes.len)
-            return req.setYield(true);
-        break :route &dev.routes[i];
-    };
-    const asset_name = req.parameter(1);
-    dev.getOrEnqueueBundle(resp, route, .client, .{ .file_name = asset_name });
-}
-
-fn onServerRequestInit(route: *Route, req: *Request, resp: *Response) void {
-    _ = req;
-    route.dev.getOrEnqueueBundle(resp, route, .server, .{});
-}
-
-// uws with bundle handlers
-
-fn onAssetRequestWithBundle(route: *Route, resp: *Response, ctx: BundleKind.client.Context(), bundle: *ClientBundle) void {
-    _ = route;
-
-    const file = bundle.getFile(ctx.file_name) orelse
-        return sendBuiltInNotFound(resp);
-
-    sendOutputFile(file, resp);
-}
-
-fn onServerRequestWithBundle(route: *Route, resp: *Response, ctx: BundleKind.server.Context(), bundle: *ServerBundle) void {
-    _ = ctx; // autofix
-    const dev = route.dev;
-    const global = dev.server_global.js();
-
-    const context = JSValue.createEmptyObject(global, 1);
-    context.put(
-        dev.server_global.js(),
-        bun.String.static("clientEntryPoint"),
-        bun.String.init(route.client_bundled_url).toJS(global),
-    );
-
-    const result = bundle.server_request_callback.call(
-        global,
-        .undefined,
-        &.{context},
-    ) catch |err| {
-        const exception = global.takeException(err);
-        const fail: Failure = .{ .request_handler = exception };
-        fail.printToConsole(route, .server);
-        fail.sendAsHttpResponse(resp, route, .server);
-        return;
-    };
-
-    // TODO: This interface and implementation is very poor. but fine until API
-    // considerations become important (as of writing, there are 3 dozen todo
-    // items before it)
-    //
-    // 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
-
-    const bun_string = result.toBunString(dev.server_global.js());
-    if (bun_string.tag == .Dead) @panic("TODO NOT STRING");
-    defer bun_string.deref();
-
-    const utf8 = bun_string.toUTF8(default_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)
-}
-
-fn onFallbackRoute(_: void, _: *Request, resp: *Response) void {
-    sendBuiltInNotFound(resp);
-}
-
-// http helper functions
-
-fn sendOutputFile(file: *const OutputFile, resp: *Response) void {
-    switch (file.value) {
-        .buffer => |buffer| {
-            if (buffer.bytes.len == 0) {
-                resp.writeStatus("202 No Content");
-                resp.writeHeaderInt("Content-Length", 0);
-                resp.end("", true);
-                return;
-            }
-
-            resp.writeStatus("200 OK");
-            // TODO: CSS, Sourcemap
-            resp.writeHeader("Content-Type", MimeType.javascript.value);
-            resp.end(buffer.bytes, true); // TODO: You should never call res.end(huge buffer)
-        },
-        else => |unhandled_tag| Output.panic("TODO: unhandled tag .{s}", .{@tagName(unhandled_tag)}),
-    }
-}
-
-fn sendBuiltInNotFound(resp: *Response) void {
-    const message = "404 Not Found";
-    resp.writeStatus("404 Not Found");
-    resp.end(message, true);
-}
-
-// bundling
-
-const BundleKind = enum {
-    client,
-    server,
-
-    fn Bundle(kind: BundleKind) type {
-        return switch (kind) {
-            .client => ClientBundle,
-            .server => ServerBundle,
-        };
-    }
-
-    /// Routing information from uws.Request is stack allocated.
-    /// This union has no type tag because it can be inferred from surrounding data.
-    fn Context(kind: BundleKind) type {
-        return switch (kind) {
-            .client => struct { file_name: []const u8 },
-            .server => struct {},
-        };
-    }
-
-    inline fn completionFunction(comptime kind: BundleKind) fn (*Route, *Response, kind.Context(), *kind.Bundle()) void {
-        return switch (kind) {
-            .client => onAssetRequestWithBundle,
-            .server => onServerRequestWithBundle,
-        };
-    }
-
-    const AnyContext: type = @Type(.{
-        .Union = .{
-            .layout = .auto,
-            .tag_type = null,
-            .fields = &fields: {
-                const values = std.enums.values(BundleKind);
-                var fields: [values.len]std.builtin.Type.UnionField = undefined;
-                for (&fields, values) |*field, kind| {
-                    field.* = .{
-                        .name = @tagName(kind),
-                        .type = kind.Context(),
-                        .alignment = @alignOf(kind.Context()),
-                    };
-                }
-                break :fields fields;
-            },
-            .decls = &.{},
-        },
-    });
-
-    inline fn initAnyContext(comptime kind: BundleKind, data: kind.Context()) AnyContext {
-        return @unionInit(AnyContext, @tagName(kind), data);
-    }
-};
-
-/// This will either immediately call `kind.completionFunction()`, or schedule a
-/// task to call it when the bundle is ready. The completion function is allowed
-/// to use yield.
-fn getOrEnqueueBundle(
-    dev: *DevServer,
-    resp: *Response,
-    route: *Route,
-    comptime kind: BundleKind,
-    ctx: kind.Context(),
-) void {
-    // const bundler = &dev.bundler;
-    const bundle = switch (kind) {
-        .client => &route.client_bundle,
-        .server => &route.server_bundle,
-    };
-
-    switch (bundle.*) {
-        .unqueued => {
-            // TODO: use an object pool for this. `bun.ObjectPool` needs a refactor before it can be used
-            const cb = BundleTask.DeferredRequest.newNode(resp, kind.initAnyContext(ctx));
-
-            const task = bun.new(BundleTask, .{
-                .owner = dev,
-                .route = route,
-                .kind = kind,
-                .plugins = null,
-                .handlers = .{ .first = cb },
-            });
-            bundle.* = .{ .pending = task };
-            dev.bundle_thread.enqueue(task);
-        },
-        .pending => |task| {
-            const cb = BundleTask.DeferredRequest.newNode(resp, kind.initAnyContext(ctx));
-            // This is not a data race, since this list is drained on
-            // the same thread as this function is called.
-            task.handlers.prepend(cb);
-        },
-        .failed => |fail| {
-            fail.sendAsHttpResponse(resp, route, kind);
-        },
-        .value => |*val| {
-            kind.completionFunction()(route, resp, ctx, val);
-        },
-    }
-}
-
-const BundleThread = bun.bundle_v2.BundleThread(BundleTask);
-
-/// A request to bundle something for development. Has one or more pending HTTP requests.
-pub const BundleTask = struct {
-    owner: *DevServer,
-    route: *Route,
-    kind: BundleKind,
-    // env: *bun.DotEnv.Loader, // TODO
-    plugins: ?*JSC.API.JSBundler.Plugin,
-    handlers: DeferredRequest.List,
-
-    next: ?*BundleTask = null,
-    result: BundleV2.Result = .{ .pending = {} },
-
-    // initialized in the task itself:
-    concurrent_task: JSC.EventLoopTask = undefined,
-    bundler: *BundleV2 = undefined,
-    log: Log = undefined,
-
-    /// There is no function pointer, route, or context on this struct as all of
-    /// this information is inferable from the associated BundleTask
-    const DeferredRequest = struct {
-        /// When cancelled, this is set to null
-        resp: ?*Response,
-        /// Only valid if req is non-null
-        ctx: BundleKind.AnyContext,
-
-        fn newNode(resp: *Response, ctx: BundleKind.AnyContext) *DeferredRequest.List.Node {
-            const node = bun.new(DeferredRequest.List.Node, .{
-                .data = .{
-                    .resp = resp,
-                    .ctx = ctx,
-                },
-            });
-            resp.onAborted(*DeferredRequest, onCancel, &node.data);
-            return node;
-        }
-
-        fn onCancel(node: *DeferredRequest, resp: *Response) void {
-            node.resp = null;
-            node.ctx = undefined;
-            _ = resp;
-        }
-
-        const List = std.SinglyLinkedList(DeferredRequest);
-    };
-
-    pub fn completeOnMainThread(task: *BundleTask) void {
-        switch (task.kind) {
-            inline else => |kind| task.completeOnMainThreadWithKind(kind),
-        }
-    }
-
-    fn completeOnMainThreadWithKind(task: *BundleTask, comptime kind: BundleKind) void {
-        const route = task.route;
-        const bundle = switch (kind) {
-            .client => &route.client_bundle,
-            .server => &route.server_bundle,
-        };
-
-        assert(bundle.* == .pending);
-
-        if (task.result == .err) {
-            const fail = Failure.fromLog(&task.log);
-            fail.printToConsole(route, kind);
-            task.finishHttpRequestsFailure(&fail);
-            bundle.* = .{ .failed = fail };
-            return;
-        }
-
-        if (task.log.hasAny()) {
-            Output.warn("Warnings {s} for {s}", .{
-                @tagName(task.kind),
-                route.pattern,
-            });
-            task.log.printForLogLevel(Output.errorWriter()) catch {};
-        }
-
-        const files = task.result.value.output_files.items;
-        bun.assert(files.len > 0);
-
-        const dev = route.dev;
-        if (dev.dump_dir) |dump_dir| {
-            dumpBundle(dump_dir, route, kind, files) catch |err| {
-                bun.handleErrorReturnTrace(err, @errorReturnTrace());
-                Output.warn("Could not dump bundle: {}", .{err});
-            };
-        }
-
-        switch (kind) {
-            .client => {
-                // Set the capacity to the exact size required to avoid over-allocation
-                var files_index: bun.CaseInsensitiveASCIIStringArrayHashMapUnmanaged(void) = .{};
-                files_index.entries.setCapacity(default_allocator, files.len) catch bun.outOfMemory();
-                files_index.entries.len = files.len;
-                for (files_index.keys(), files) |*index_key, file| {
-                    var dest_path = file.dest_path;
-                    if (bun.strings.hasPrefixComptime(dest_path, "./")) {
-                        dest_path = dest_path[2..];
-                    }
-                    index_key.* = dest_path;
-                }
-                files_index.reIndex(default_allocator) catch bun.outOfMemory();
-
-                bundle.* = .{ .value = .{
-                    .files = files,
-                    .files_index = files_index,
-                } };
-            },
-            .server => {
-                const entry_point = files[0];
-                const code = entry_point.value.buffer.bytes;
-
-                const server_code = c.KitLoadServerCode(dev.server_global, bun.String.createLatin1(code));
-                dev.vm.waitForPromise(.{ .internal = server_code.promise });
-
-                switch (server_code.promise.unwrap(dev.vm.jsc, .mark_handled)) {
-                    .pending => unreachable, // promise is settled
-                    .rejected => |err| {
-                        const fail = Failure.fromJSServerLoad(err, dev.server_global.js());
-                        fail.printToConsole(task.route, .server);
-                        task.finishHttpRequestsFailure(&fail);
-                        bundle.* = .{ .failed = fail };
-                        return;
-                    },
-                    .fulfilled => |v| bun.assert(v == .undefined),
-                }
-
-                const handler = c.KitGetRequestHandlerFromModule(dev.server_global, server_code.key);
-
-                if (!handler.isCallable(dev.vm.jsc)) {
-                    @panic("TODO: handle not callable");
-                }
-
-                bundle.* = .{ .value = .{
-                    .files = files,
-                    .server_request_callback = handler,
-                } };
-            },
-        }
-
-        task.finishHttpRequestsSuccess(kind, &bundle.value);
-    }
-
-    fn finishHttpRequestsSuccess(task: *BundleTask, comptime kind: BundleKind, bundle: *kind.Bundle()) void {
-        const func = comptime kind.completionFunction();
-
-        while (task.handlers.popFirst()) |node| {
-            defer bun.destroy(node);
-            if (node.data.resp) |resp| {
-                func(task.route, resp, @field(node.data.ctx, @tagName(kind)), bundle);
-            }
-        }
-    }
-
-    fn finishHttpRequestsFailure(task: *BundleTask, failure: *const Failure) void {
-        while (task.handlers.popFirst()) |node| {
-            defer bun.destroy(node);
-            if (node.data.resp) |resp| {
-                failure.sendAsHttpResponse(resp, task.route, task.kind);
-            }
-        }
-    }
-
-    pub fn configureBundler(task: *BundleTask, bundler: *Bundler, allocator: Allocator) !void {
-        const dev = task.route.dev;
-
-        bundler.* = try bun.Bundler.init(
-            allocator,
-            &task.log,
-            std.mem.zeroes(bun.Schema.Api.TransformOptions),
-            null, // TODO:
-        );
-
-        const define = bundler.options.define;
-        bundler.options = dev.bundler.options;
-
-        bundler.options.define = define;
-        bundler.options.entry_points = (&task.route.entry_point)[0..1];
-        bundler.options.log = &task.log;
-        bundler.options.output_dir = ""; // this disables filesystem outpu;
-        bundler.options.output_format = .internal_kit_dev;
-        bundler.options.out_extensions = bun.StringHashMap([]const u8).init(bundler.allocator);
-        bundler.options.react_fast_refresh = task.kind == .client;
-
-        bundler.options.public_path = switch (task.kind) {
-            .client => task.route.clientPublicPath(),
-            .server => task.route.dev.cwd,
-        };
-        bundler.options.target = switch (task.kind) {
-            .client => .browser,
-            .server => .bun,
-        };
-        bundler.options.entry_naming = switch (task.kind) {
-            // Always name it "client.{js/css}" so that the server can know
-            // the entry-point script without waiting on a client bundle.
-            .client => "client.[ext]",
-            // For uniformity
-            .server => "server.[ext]",
-        };
-        bundler.options.tree_shaking = false;
-        bundler.options.minify_syntax = true;
-
-        bundler.configureLinker();
-        try bundler.configureDefines();
-
-        // The following are from Vite: https://vitejs.dev/guide/env-and-mode
-        // TODO: MODE, BASE_URL
-        try bundler.options.define.insert(
-            allocator,
-            "import.meta.env.DEV",
-            Define.Data.initBoolean(true),
-        );
-        try bundler.options.define.insert(
-            allocator,
-            "import.meta.env.PROD",
-            Define.Data.initBoolean(false),
-        );
-        try bundler.options.define.insert(
-            allocator,
-            "import.meta.env.SSR",
-            Define.Data.initBoolean(task.kind == .server),
-        );
-
-        bundler.resolver.opts = bundler.options;
-        bundler.resolver.watcher = dev.bundler.resolver.watcher;
-    }
-
-    pub fn completeMini(task: *BundleTask, _: *void) void {
-        task.completeOnMainThread();
-    }
-
-    pub fn completeOnBundleThread(task: *BundleTask) void {
-        task.route.dev.vm.event_loop.enqueueTaskConcurrent(task.concurrent_task.js.from(task, .manual_deinit));
-    }
-};
-
-/// Bundling should be concurrent, deduplicated, and cached.
-/// This acts as a sort of "native promise"
-fn BundlePromise(T: type) type {
-    return union(enum) {
-        unqueued,
-        pending: *BundleTask,
-        failed: Failure,
-        value: T,
-    };
-}
-
-/// Represents an error from loading or server sided runtime. Information on
-/// what this error is from, such as the associated Route, is inferred from
-/// surrounding context.
-///
-/// In the case a route was not able to fully compile, the `Failure` is stored
-/// so that a browser refreshing the page can display this failure.
-const Failure = union(enum) {
-    /// Bundler and module resolution use `bun.logger` to report multiple errors at once.
-    bundler: std.ArrayList(bun.logger.Msg),
-    /// Thrown JavaScript exception while loading server code.
-    server_load: JSC.Strong,
-    /// Never stored; the current request handler threw an error.
-    request_handler: JSValue,
-
-    /// Consumes the Log data, resetting it.
-    pub fn fromLog(log: *Log) Failure {
-        const fail: Failure = .{ .bundler = log.msgs };
-        log.* = .{
-            .msgs = std.ArrayList(bun.logger.Msg).init(log.msgs.allocator),
-            .level = log.level,
-        };
-        return fail;
-    }
-
-    pub fn fromJSServerLoad(js: JSValue, global: *JSC.JSGlobalObject) Failure {
-        return .{ .server_load = JSC.Strong.create(js, global) };
-    }
-
-    // TODO: deduplicate the two methods here. that isnt trivial because one has to
-    // style with ansi codes, and the other has to style with HTML.
-
-    fn printToConsole(fail: *const Failure, route: *const Route, kind: BundleKind) void {
-        defer Output.flush();
-
-        Output.prettyErrorln("", .{});
-
-        switch (fail.*) {
-            .bundler => |msgs| {
-                Output.prettyErrorln("<red>Errors while bundling {s}-side for '{s}'<r>", .{
-                    @tagName(kind),
-                    route.pattern,
-                });
-                Output.flush();
-
-                var log: Log = .{ .msgs = msgs, .errors = 1, .level = .err };
-                log.printForLogLevelColorsRuntime(
-                    Output.errorWriter(),
-                    Output.enable_ansi_colors_stderr,
-                ) catch {};
-            },
-            .server_load => |strong| {
-                Output.prettyErrorln("<red>Server route handler for '{s}' threw while loading<r>", .{
-                    route.pattern,
-                });
-                Output.flush();
-
-                const err = strong.get() orelse unreachable;
-                route.dev.vm.printErrorLikeObjectToConsole(err);
-            },
-            .request_handler => |err| {
-                Output.prettyErrorln("<red>Request to handler '{s}' failed SSR<r>", .{
-                    route.pattern,
-                });
-                Output.flush();
-
-                route.dev.vm.printErrorLikeObjectToConsole(err);
-            },
-        }
-    }
-
-    fn sendAsHttpResponse(fail: *const Failure, resp: *Response, route: *const Route, kind: BundleKind) void {
-        resp.writeStatus("500 Internal Server Error");
-        var buffer: [32768]u8 = undefined;
-
-        const message = message: {
-            var fbs = std.io.fixedBufferStream(&buffer);
-            const writer = fbs.writer();
-
-            switch (fail.*) {
-                .bundler => |msgs| {
-                    writer.print("Errors while bundling {s}-side for '{s}'\n\n", .{
-                        @tagName(kind),
-                        route.pattern,
-                    }) catch break :message null;
-
-                    var log: Log = .{ .msgs = msgs, .errors = 1, .level = .err };
-                    log.printForLogLevelWithEnableAnsiColors(writer, false) catch
-                        break :message null;
-                },
-                .server_load => |strong| {
-                    writer.print("Server route handler for '{s}' threw while loading\n\n", .{
-                        route.pattern,
-                    }) catch break :message null;
-                    const err = strong.get() orelse unreachable;
-                    route.dev.vm.printErrorLikeObjectSimple(err, writer, false);
-                },
-                .request_handler => |err| {
-                    writer.print("Server route handler for '{s}' threw while loading\n\n", .{
-                        route.pattern,
-                    }) catch break :message null;
-                    route.dev.vm.printErrorLikeObjectSimple(err, writer, false);
-                },
-            }
-
-            break :message fbs.getWritten();
-        } orelse message: {
-            const suffix = "...truncated";
-            @memcpy(buffer[buffer.len - suffix.len ..], suffix);
-            break :message &buffer;
-        };
-        resp.end(message, true); // TODO: "You should never call res.end(huge buffer)"
-    }
-};
-
-// For debugging, it is helpful to be able to see bundles.
-fn dumpBundle(dump_dir: std.fs.Dir, route: *Route, kind: BundleKind, files: []OutputFile) !void {
-    for (files) |file| {
-        const name = bun.path.joinAbsString("/", &.{
-            route.pattern,
-            @tagName(kind),
-            file.dest_path,
-        }, .auto)[1..];
-        var inner_dir = try dump_dir.makeOpenPath(bun.Dirname.dirname(u8, name).?, .{});
-        defer inner_dir.close();
-
-        switch (file.value) {
-            .buffer => |buf| {
-                try inner_dir.writeFile(.{ .data = buf.bytes, .sub_path = bun.path.basename(name) });
-            },
-            else => |t| Output.panic("TODO: implement dumping .{s}", .{@tagName(t)}),
-        }
-    }
-}
-
-/// This function is required by `HotReloader`
-pub fn eventLoop(dev: *DevServer) *JSC.EventLoop {
-    return dev.vm.eventLoop();
-}
-
-pub fn onWebSocketUpgrade(
-    dev: *DevServer,
-    res: *Response,
-    req: *Request,
-    upgrade_ctx: *uws.uws_socket_context_t,
-    id: usize,
-) void {
-    assert(id == 0);
-
-    const dw = bun.new(DevWebSocket, .{ .dev = dev });
-    res.upgrade(
-        *DevWebSocket,
-        dw,
-        req.header("sec-websocket-key") orelse "",
-        req.header("sec-websocket-protocol") orelse "",
-        req.header("sec-websocket-extension") orelse "",
-        upgrade_ctx,
-    );
-}
-
-const DevWebSocket = struct {
-    dev: *DevServer,
-
-    pub fn onOpen(dw: *DevWebSocket, ws: AnyWebSocket) void {
-        _ = ws.send("bun!", .binary, false, false);
-        std.debug.print("open {*} {}\n", .{ dw, ws });
-    }
-
-    pub fn onMessage(dw: *DevWebSocket, ws: AnyWebSocket, msg: []const u8, opcode: uws.Opcode) void {
-        std.debug.print("message {*} {} {} '{s}'\n", .{ dw, ws, opcode, msg });
-    }
-
-    pub fn onClose(dw: *DevWebSocket, ws: AnyWebSocket, exit_code: i32, message: []const u8) void {
-        defer bun.destroy(dw);
-
-        std.debug.print("close {*} {} {} '{s}'\n", .{ dw, ws, exit_code, message });
-    }
-};
-
-/// Kit 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();
-    }
-};
-
-pub const KitSourceProvider = opaque {};
-
-pub const c = struct {
-    // KitDevGlobalObject.cpp
-    extern fn KitCreateDevGlobal(owner: *DevServer, console: *JSC.ConsoleObject) *DevGlobalObject;
-
-    // KitSourceProvider.cpp
-    const LoadServerCodeResult = extern struct { promise: *JSInternalPromise, key: *JSC.JSString };
-    extern fn KitLoadServerCode(global: *DevGlobalObject, code: bun.String) LoadServerCodeResult;
-    extern fn KitGetRequestHandlerFromModule(global: *DevGlobalObject, module: *JSC.JSString) JSValue;
-};
-
-pub fn reload(dev: *DevServer) void {
-    // TODO: given no arguments, this method is absolutely useless. The watcher
-    // must be augmented with more information.
-    _ = dev;
-    Output.warn("TODO: initiate hot reload", .{});
-}
-
-const std = @import("std");
-const Allocator = std.mem.Allocator;
-
-const bun = @import("root").bun;
-const Environment = bun.Environment;
-const assert = bun.assert;
-
-const Log = bun.logger.Log;
-
-const Bundler = bun.bundler.Bundler;
-const BundleV2 = bun.bundle_v2.BundleV2;
-const Define = bun.options.Define;
-const OutputFile = bun.options.OutputFile;
-
-// TODO: consider if using system output is not fit
-const Output = bun.Output;
-
-const uws = bun.uws;
-const App = uws.NewApp(false);
-const AnyWebSocket = uws.AnyWebSocket;
-const Request = uws.Request;
-const Response = App.Response;
-
-const MimeType = bun.http.MimeType;
-
-const JSC = bun.JSC;
-const JSValue = JSC.JSValue;
-const VirtualMachine = JSC.VirtualMachine;
-const JSModuleLoader = JSC.JSModuleLoader;
-const EventLoopHandle = JSC.EventLoopHandle;
-const JSInternalPromise = JSC.JSInternalPromise;
-
-pub const HotReloader = JSC.NewHotReloader(DevServer, JSC.EventLoop, false);
-pub const HotReloadTask = HotReloader.HotReloadTask;
diff --git a/src/kit/KitDevGlobalObject.cpp b/src/kit/KitDevGlobalObject.cpp
deleted file mode 100644
index 7e3aee0977..0000000000
--- a/src/kit/KitDevGlobalObject.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-#include "KitDevGlobalObject.h"
-#include "JSNextTickQueue.h"
-#include "JavaScriptCore/GlobalObjectMethodTable.h"
-#include "headers-handwritten.h"
-
-namespace Kit {
-
-#define INHERIT_HOOK_METHOD(name)                                              \
-  Zig::GlobalObject::s_globalObjectMethodTable.name
-
-const JSC::GlobalObjectMethodTable DevGlobalObject::s_globalObjectMethodTable =
-    {
-        INHERIT_HOOK_METHOD(supportsRichSourceInfo),
-        INHERIT_HOOK_METHOD(shouldInterruptScript),
-        INHERIT_HOOK_METHOD(javaScriptRuntimeFlags),
-        INHERIT_HOOK_METHOD(queueMicrotaskToEventLoop),
-        INHERIT_HOOK_METHOD(shouldInterruptScriptBeforeTimeout),
-        INHERIT_HOOK_METHOD(moduleLoaderImportModule),
-        INHERIT_HOOK_METHOD(moduleLoaderResolve),
-        INHERIT_HOOK_METHOD(moduleLoaderFetch),
-        INHERIT_HOOK_METHOD(moduleLoaderCreateImportMetaProperties),
-        INHERIT_HOOK_METHOD(moduleLoaderEvaluate),
-        INHERIT_HOOK_METHOD(promiseRejectionTracker),
-        INHERIT_HOOK_METHOD(reportUncaughtExceptionAtEventLoop),
-        INHERIT_HOOK_METHOD(currentScriptExecutionOwner),
-        INHERIT_HOOK_METHOD(scriptExecutionStatus),
-        INHERIT_HOOK_METHOD(reportViolationForUnsafeEval),
-        INHERIT_HOOK_METHOD(defaultLanguage),
-        INHERIT_HOOK_METHOD(compileStreaming),
-        INHERIT_HOOK_METHOD(instantiateStreaming),
-        INHERIT_HOOK_METHOD(deriveShadowRealmGlobalObject),
-        INHERIT_HOOK_METHOD(codeForEval),
-        INHERIT_HOOK_METHOD(canCompileStrings),
-};
-
-DevGlobalObject *
-DevGlobalObject::create(JSC::VM &vm, JSC::Structure *structure,
-                        const JSC::GlobalObjectMethodTable *methodTable) {
-  DevGlobalObject *ptr = new (NotNull, JSC::allocateCell<DevGlobalObject>(vm))
-      DevGlobalObject(vm, structure, methodTable);
-  ptr->finishCreation(vm);
-  return ptr;
-}
-
-void DevGlobalObject::finishCreation(JSC::VM &vm) {
-  Base::finishCreation(vm);
-  ASSERT(inherits(info()));
-}
-
-extern "C" BunVirtualMachine *Bun__getVM();
-
-// A lot of this function is taken from 'Zig__GlobalObject__create'
-extern "C" DevGlobalObject *KitCreateDevGlobal(DevServer *owner,
-                                               void *console) {
-  JSC::VM &vm = JSC::VM::create(JSC::HeapType::Large).leakRef();
-  vm.heap.acquireAccess();
-  JSC::JSLockHolder locker(vm);
-  BunVirtualMachine *bunVM = Bun__getVM();
-  WebCore::JSVMClientData::create(&vm, bunVM);
-
-  JSC::Structure *structure = DevGlobalObject::createStructure(vm);
-  DevGlobalObject *global = DevGlobalObject::create(
-      vm, structure, &DevGlobalObject::s_globalObjectMethodTable);
-  if (!global)
-    BUN_PANIC("Failed to create DevGlobalObject");
-
-  global->m_devServer = owner;
-  global->m_bunVM = bunVM;
-
-  JSC::gcProtect(global);
-
-  global->setConsole(console);
-  global->setStackTraceLimit(10); // Node.js defaults to 10
-
-  // vm.setOnComputeErrorInfo(computeErrorInfoWrapper);
-  vm.setOnEachMicrotaskTick([global](JSC::VM &vm) -> void {
-    if (auto nextTickQueue = global->m_nextTickQueue.get()) {
-      global->resetOnEachMicrotaskTick();
-      Bun::JSNextTickQueue *queue =
-          jsCast<Bun::JSNextTickQueue *>(nextTickQueue);
-      queue->drain(vm, global);
-      return;
-    }
-  });
-
-  return global;
-}
-
-}; // namespace Kit
diff --git a/src/kit/KitDevGlobalObject.h b/src/kit/KitDevGlobalObject.h
deleted file mode 100644
index 07126aca3a..0000000000
--- a/src/kit/KitDevGlobalObject.h
+++ /dev/null
@@ -1,42 +0,0 @@
-#pragma once
-#include "root.h"
-#include "ZigGlobalObject.h"
-
-namespace Kit {
-
-struct DevServer; // DevServer.zig
-struct Route; // DevServer.zig
-struct BunVirtualMachine;
-
-class DevGlobalObject : public Zig::GlobalObject {
-public:
-    using Base = Zig::GlobalObject;
-
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<DevGlobalObject, WebCore::UseCustomHeapCellType::Yes>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForKitGlobalScope.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForKitGlobalScope = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForKitGlobalScope.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForKitGlobalScope = std::forward<decltype(space)>(space); },
-            [](auto& server) -> JSC::HeapCellType& { return server.m_heapCellTypeForJSWorkerGlobalScope; });
-    }
-
-    static const JSC::GlobalObjectMethodTable s_globalObjectMethodTable;
-    static DevGlobalObject* create(JSC::VM& vm, JSC::Structure* structure, const JSC::GlobalObjectMethodTable* methodTable);
-
-    DevServer* m_devServer;
-
-    void finishCreation(JSC::VM& vm);
-
-    DevGlobalObject(JSC::VM& vm, JSC::Structure* structure, const JSC::GlobalObjectMethodTable* methodTable) 
-        : Zig::GlobalObject(vm, structure, methodTable) { }
-};
-
-// Zig API
-extern "C" DevGlobalObject* KitCreateDevGlobal(DevServer* owner, void* console);
-
-}; // namespace Kit
diff --git a/src/kit/KitSourceProvider.cpp b/src/kit/KitSourceProvider.cpp
deleted file mode 100644
index e28e1c4fd1..0000000000
--- a/src/kit/KitSourceProvider.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-// clang-format off
-#include "KitSourceProvider.h"
-#include "JavaScriptCore/Completion.h"
-#include "JavaScriptCore/Identifier.h"
-#include "JavaScriptCore/JSCJSValue.h"
-#include "JavaScriptCore/JSCast.h"
-#include "JavaScriptCore/JSLock.h"
-#include "JavaScriptCore/JSMap.h"
-#include "JavaScriptCore/JSModuleLoader.h"
-#include "JavaScriptCore/JSString.h"
-#include "JavaScriptCore/JSModuleNamespaceObject.h"
-#include "KitDevGlobalObject.h"
-
-namespace Kit {
-
-
-extern "C" LoadServerCodeResult KitLoadServerCode(DevGlobalObject* global, BunString source) {
-  String string = "kit://server/0/index.js"_s;
-  JSC::SourceOrigin origin = JSC::SourceOrigin(WTF::URL(string));
-  JSC::SourceCode sourceCode = JSC::SourceCode(KitSourceProvider::create(
-    source.toWTFString(),
-    origin,
-    WTFMove(string),
-    WTF::TextPosition(),
-    JSC::SourceProviderSourceType::Module
-  ));
-
-  JSC::JSString* key = JSC::jsString(global->vm(), string);
-  global->moduleLoader()->provideFetch(global, key, sourceCode);
-  
-  return {
-     global->moduleLoader()->loadAndEvaluateModule(global, key, JSC::jsUndefined(), JSC::jsUndefined()),
-     key
-  };
-}
-
-extern "C" JSC::EncodedJSValue KitGetRequestHandlerFromModule(
-  DevGlobalObject* global,
-  JSC::JSString* key
-) {
-  JSC::VM&vm = global->vm();
-  JSC::JSMap* map = JSC::jsCast<JSC::JSMap*>(
-    global->moduleLoader()->getDirect(
-      vm, JSC::Identifier::fromString(global->vm(), "registry"_s)
-    ));
-  JSC::JSValue entry = map->get(global, key);
-  ASSERT(entry.isObject()); // should have called KitLoadServerCode and wait for that promise
-  JSC::JSValue module = entry.getObject()->get(global, JSC::Identifier::fromString(global->vm(), "module"_s));
-  ASSERT(module.isCell());
-  JSC::JSModuleNamespaceObject* namespaceObject = global->moduleLoader()->getModuleNamespaceObject(global, module);
-  ASSERT(namespaceObject);
-  return JSC::JSValue::encode(namespaceObject->get(global, vm.propertyNames->defaultKeyword));
-}
-
-} // namespace Kit
diff --git a/src/kit/KitSourceProvider.h b/src/kit/KitSourceProvider.h
deleted file mode 100644
index 1aacb369c7..0000000000
--- a/src/kit/KitSourceProvider.h
+++ /dev/null
@@ -1,47 +0,0 @@
-#pragma once
-#include "root.h"
-#include "headers-handwritten.h"
-#include "KitDevGlobalObject.h"
-#include "JavaScriptCore/SourceOrigin.h"
-
-namespace Kit {
-
-struct LoadServerCodeResult {
-  JSC::JSInternalPromise* promise;
-  JSC::JSString* key;
-};
-
-class KitSourceProvider final : public JSC::StringSourceProvider {
-public:
-    static Ref<KitSourceProvider> create(
-      const String& source,
-      const JSC::SourceOrigin& sourceOrigin,
-      String&& sourceURL,
-      const TextPosition& startPosition,
-      JSC::SourceProviderSourceType sourceType
-    ) {
-        return adoptRef(*new KitSourceProvider(source, sourceOrigin, WTFMove(sourceURL), startPosition, sourceType));
-    }
-
-private:
-  KitSourceProvider(
-    const String& source,
-    const JSC::SourceOrigin& sourceOrigin,
-    String&& sourceURL,
-    const TextPosition& startPosition,
-    JSC::SourceProviderSourceType sourceType
-  ) : StringSourceProvider(
-    source, 
-    sourceOrigin, 
-    JSC::SourceTaintedOrigin::Untainted,
-    WTFMove(sourceURL),
-    startPosition,
-    sourceType
-  ) {}
-};
-
-// Zig API
-extern "C" LoadServerCodeResult KitLoadServerCode(DevGlobalObject* global, BunString source);
-extern "C" JSC::EncodedJSValue KitGetRequestHandlerFromModule(DevGlobalObject* global, JSC::JSString* encodedModule);
-
-} // namespace Kit
diff --git a/src/kit/client/overlay.css b/src/kit/client/overlay.css
deleted file mode 100644
index 6f4cc360ab..0000000000
--- a/src/kit/client/overlay.css
+++ /dev/null
@@ -1,18 +0,0 @@
-/*
- * This file is mounted within Shadow DOM so interference with
- * the user's application causes no issue. This sheet is used to
- * style error popups and other elements provided by DevServer.
- */
-
-* {
-  box-sizing: border-box;
-}
-
-main {
-  font-family: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;
-}
-
-.error {
-  padding: 1rem;
-  background-color: rgba(255, 0, 0, 0.2);
-}
\ No newline at end of file
diff --git a/src/kit/client/overlay.ts b/src/kit/client/overlay.ts
deleted file mode 100644
index d90319e583..0000000000
--- a/src/kit/client/overlay.ts
+++ /dev/null
@@ -1,30 +0,0 @@
-import { css } from "../macros" with { type: "macro" };
-
-// Create a root element to contain all our our DOM nodes.
-var root!: HTMLElement;
-var mount;
-
-if (mode === "client") {
-  mount = function mount() {
-    const wrap = document.createElement("bun-hmr");
-    wrap.setAttribute(
-      "style",
-      "position:absolute;display:block;top:0;left:0;width:100%;height:100%;background:transparent",
-    );
-    const shadow = wrap.attachShadow({ mode: "open" });
-
-    const sheet = new CSSStyleSheet();
-    sheet.replace(css("client/overlay.css", IS_BUN_DEVELOPMENT));
-    shadow.adoptedStyleSheets = [sheet];
-
-    root = document.createElement("main");
-    shadow.appendChild(root);
-    document.body.appendChild(wrap);
-  };
-}
-
-export function showErrorOverlay(e) {
-  mount();
-  console.error(e);
-  root.innerHTML = `<div class='error'><h1>oh no, a client side error happened:</h1><pre><code>${e?.message ? `${e?.name ?? e?.constructor?.name ?? "Error"}: ${e.message}\n` : JSON.stringify(e)}${e?.message ? e?.stack : ""}</code></pre></div>`;
-}
diff --git a/src/kit/hmr-module.ts b/src/kit/hmr-module.ts
deleted file mode 100644
index e21e80688c..0000000000
--- a/src/kit/hmr-module.ts
+++ /dev/null
@@ -1,65 +0,0 @@
-import * as runtimeHelpers from "../runtime.bun.js";
-
-const registry = new Map<Id, HotModule>();
-
-export type ModuleLoadFunction = (module: HotModule) => void;
-export type ExportsCallbackFunction = (new_exports: any) => void;
-
-/**
- * This object is passed as the CommonJS "module", but has a bunch of
- * non-standard properties that are used for implementing hot-module
- * reloading. It is unacceptable to depend
- */
-export class HotModule {
-  exports: any = {};
-
-  _ext_exports = undefined;
-  __esModule = false;
-  _import_meta?: ImportMeta;
-
-  constructor(public id: Id) {}
-
-  require(id: Id, onReload: null | ExportsCallbackFunction) {
-    return loadModule(id).exports;
-  }
-
-  importSync(id: Id, onReload: null | ExportsCallbackFunction) {
-    const module = loadModule(id);
-    const { exports, __esModule } = module;
-    return __esModule ? exports : (module._ext_exports ??= { ...exports, default: exports });
-  }
-
-  importMeta() {
-    return (this._import_meta ??= initImportMeta(this));
-  }
-}
-
-function initImportMeta(m: HotModule): ImportMeta {
-  throw new Error("TODO: import meta object");
-}
-
-// {
-//   const runtime = new HotModule(0);
-//   runtime.exports = runtimeHelpers;
-//   runtime.__esModule = true;
-//   registry.set(0, runtime);
-// }
-
-export function loadModule(key: Id): HotModule {
-  let module = registry.get(key);
-  if (module) return module;
-  module = new HotModule(key);
-  registry.set(key, module);
-  const load = input_graph[key];
-  if (!load) {
-    throw new Error(
-      `Failed to load bundled module '${key}'. This is not a dynamic import, and therefore is a bug in Bun`,
-    );
-  }
-  load(module);
-  return module;
-}
-
-runtimeHelpers.__name(HotModule.prototype.importSync, "<HMR runtime> importSync");
-runtimeHelpers.__name(HotModule.prototype.require, "<HMR runtime> require");
-runtimeHelpers.__name(loadModule, "<HMR runtime> loadModule");
diff --git a/src/kit/hmr-runtime-types.d.ts b/src/kit/hmr-runtime-types.d.ts
deleted file mode 100644
index f80f1d3cde..0000000000
--- a/src/kit/hmr-runtime-types.d.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * A module id is an unsigned 52-bit numeric hash of the filepath.
- *
- * TODO: how resistant to hash collision is this? if it is not, an alternate approach must be taken.
- */
-type Id = number;
-
-interface Config {
-  main: Id;
-  /** If available, this is the Id of `react-refresh/runtime` */
-  refresh: Id;
-}
-
-/**
- * All modules for the initial bundle.
- */
-declare const input_graph: Record<string, ModuleLoadFunction>;
-
-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
- * a window to visually display errors with.
- */
-declare const mode: "client" | "server";
-
-/* What should be `export default`'d */
-declare var server_fetch_function: any;
-
-/*
- * If you are running a debug build of Bun. These debug builds should provide
- * helpful information to someone working on the bundler itself.
- */
-declare const IS_BUN_DEVELOPMENT: any;
diff --git a/src/kit/hmr-runtime.ts b/src/kit/hmr-runtime.ts
deleted file mode 100644
index 2b6b4f8d76..0000000000
--- a/src/kit/hmr-runtime.ts
+++ /dev/null
@@ -1,47 +0,0 @@
-// This file is the entrypoint to the hot-module-reloading runtime
-// In the browser, this uses a WebSocket to communicate with the bundler.
-// On the server, communication is facilitated using a secret global.
-import { showErrorOverlay } from "./client/overlay";
-import { loadModule } from "./hmr-module";
-
-if (typeof IS_BUN_DEVELOPMENT !== "boolean") {
-  throw new Error("DCE is configured incorrectly");
-}
-
-// Initialize client-side features.
-if (mode === "client") {
-  const { refresh } = config;
-  if (refresh) {
-    const runtime = loadModule(refresh).exports;
-    runtime.injectIntoGlobalHook(window);
-  }
-}
-
-// Load the entry point module
-try {
-  const main = loadModule(config.main);
-
-  // export it on the server side
-  if (mode === "server") server_fetch_function = main.exports.default;
-
-  if (mode === "client") {
-    const ws = new WebSocket("/_bun/hmr");
-    ws.onopen = ev => {
-      console.log(ev);
-    };
-    ws.onmessage = ev => {
-      console.log(ev);
-    };
-    ws.onclose = ev => {
-      console.log(ev);
-    };
-    ws.onerror = ev => {
-      console.log(ev);
-    };
-  }
-} catch (e) {
-  if (mode !== "client") throw e;
-  showErrorOverlay(e);
-}
-
-export {};
diff --git a/src/kit/kit.zig b/src/kit/kit.zig
deleted file mode 100644
index 1ab5e7b4f6..0000000000
--- a/src/kit/kit.zig
+++ /dev/null
@@ -1,109 +0,0 @@
-//! Kit is the code name for the work-in-progress "Framework API [SOON]" for Bun.
-
-/// Temporary function to invoke dev server via JavaScript. Will be
-/// replaced with a user-facing API. Refs the event loop forever.
-///
-/// Requires one argument object for configuration. Very little is
-/// exposed over the JS api as it is not intended to be used for
-/// real applications yet.
-/// ```ts
-/// interface WipDevServerOptions {
-///     routes: WipDevServerRoute[]
-/// }
-/// interface WipDevServerRoute {
-///     pattern: string;
-///     entrypoint: string;
-/// }
-/// ```
-pub fn jsWipDevServer(global: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
-    if (!bun.FeatureFlags.kit) return .undefined;
-
-    bun.Output.warn(
-        \\Be advised that Kit is highly experimental, and its API is subject to change
-    , .{});
-    bun.Output.flush();
-
-    const options = devServerOptionsFromJs(global, callframe.argument(0)) catch {
-        if (!global.hasException())
-            global.throwInvalidArguments("invalid arguments", .{});
-        return .zero;
-    };
-
-    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);
-    }
-}
-
-// TODO: this function leaks memory and bad error handling, but that is OK since
-// this API is not finalized.
-fn devServerOptionsFromJs(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();
-        // 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,
-        };
-    }
-
-    return .{
-        .cwd = bun.getcwdAlloc(bun.default_allocator) catch bun.outOfMemory(),
-        .routes = routes,
-    };
-}
-
-export fn Bun__getTemporaryDevServer(global: *JSC.JSGlobalObject) JSValue {
-    if (!bun.FeatureFlags.kit) 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);
-    dev.runLoopForever();
-}
-
-pub fn getHmrRuntime(mode: enum { server, client }) []const u8 {
-    return if (Environment.embed_code)
-        switch (mode) {
-            .client => @embedFile("kit-codegen/kit.client.js"),
-            .server => @embedFile("kit-codegen/kit.server.js"),
-        }
-    else switch (mode) {
-        inline else => |m| bun.runtimeEmbedFile(.codegen, "kit." ++ @tagName(m) ++ ".js"),
-    };
-}
-
-pub const DevServer = @import("./DevServer.zig");
-
-const std = @import("std");
-
-const bun = @import("root").bun;
-const Environment = bun.Environment;
-
-const JSC = bun.JSC;
-const JSValue = JSC.JSValue;
diff --git a/src/kit/macros.ts b/src/kit/macros.ts
deleted file mode 100644
index 13299608a7..0000000000
--- a/src/kit/macros.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
-
-export function css(file: string, is_development: boolean): string {
-  const contents = readFileSync(resolve(import.meta.dir, file), "utf-8");
-  if (!is_development) {
-    // TODO: minify
-    return contents;
-  }
-  return contents;
-}
diff --git a/src/kit/tsconfig.json b/src/kit/tsconfig.json
deleted file mode 100644
index 36e3ffb7e8..0000000000
--- a/src/kit/tsconfig.json
+++ /dev/null
@@ -1,18 +0,0 @@
-{
-  "compilerOptions": {
-    "lib": ["DOM", "ESNext"],
-    "module": "esnext",
-    "target": "esnext",
-    "moduleResolution": "Bundler",
-    "allowImportingTsExtensions": true,
-    "noEmit": true,
-    "strict": true,
-    "noImplicitAny": false,
-    "allowJs": true,
-    "downlevelIteration": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "jsx": "react-jsx",
-  },
-  "include": ["./hmr-runtime-types.d.ts", "*.ts"]
-}
\ No newline at end of file
diff --git a/src/libarchive/libarchive-bindings.zig b/src/libarchive/libarchive-bindings.zig
index 924cd7b031..d9bd69630a 100644
--- a/src/libarchive/libarchive-bindings.zig
+++ b/src/libarchive/libarchive-bindings.zig
@@ -1,14 +1,16 @@
+const std = @import("std");
 const bun = @import("root").bun;
-pub const wchar_t = u16;
-pub const la_int64_t = i64;
-pub const la_ssize_t = isize;
-pub const struct_archive = opaque {};
-pub const struct_archive_entry = opaque {};
-pub const archive_entry = struct_archive_entry;
+const wchar_t = u16;
+const la_int64_t = i64;
+const la_ssize_t = isize;
+const struct_archive = opaque {};
+const struct_archive_entry = opaque {};
+const archive_entry = struct_archive_entry;
 const mode_t = bun.Mode;
 const FILE = @import("std").c.FILE;
 // const time_t = @import("std").c.time_t;
 const dev_t = @import("std").c.dev_t;
+const OOM = bun.OOM;
 
 pub const FileType = enum(mode_t) {
     regular = 0o100000,
@@ -25,111 +27,267 @@ pub const SymlinkType = enum(c_int) {
     file = 1,
     directory = 2,
 };
-pub const time_t = isize;
 
-pub const ARCHIVE_VERSION_ONLY_STRING = "3.5.3dev";
-pub const ARCHIVE_VERSION_STRING = "libarchive " ++ ARCHIVE_VERSION_ONLY_STRING;
-pub const ARCHIVE_EOF = @as(c_int, 1);
-pub const ARCHIVE_OK = @as(c_int, 0);
-pub const ARCHIVE_RETRY = -@as(c_int, 10);
-pub const ARCHIVE_WARN = -@as(c_int, 20);
-pub const ARCHIVE_FAILED = -@as(c_int, 25);
-pub const ARCHIVE_FATAL = -@as(c_int, 30);
-pub const ARCHIVE_FILTER_NONE = @as(c_int, 0);
-pub const ARCHIVE_FILTER_GZIP = @as(c_int, 1);
-pub const ARCHIVE_FILTER_BZIP2 = @as(c_int, 2);
-pub const ARCHIVE_FILTER_COMPRESS = @as(c_int, 3);
-pub const ARCHIVE_FILTER_PROGRAM = @as(c_int, 4);
-pub const ARCHIVE_FILTER_LZMA = @as(c_int, 5);
-pub const ARCHIVE_FILTER_XZ = @as(c_int, 6);
-pub const ARCHIVE_FILTER_UU = @as(c_int, 7);
-pub const ARCHIVE_FILTER_RPM = @as(c_int, 8);
-pub const ARCHIVE_FILTER_LZIP = @as(c_int, 9);
-pub const ARCHIVE_FILTER_LRZIP = @as(c_int, 10);
-pub const ARCHIVE_FILTER_LZOP = @as(c_int, 11);
-pub const ARCHIVE_FILTER_GRZIP = @as(c_int, 12);
-pub const ARCHIVE_FILTER_LZ4 = @as(c_int, 13);
-pub const ARCHIVE_FILTER_ZSTD = @as(c_int, 14);
-pub const ARCHIVE_COMPRESSION_NONE = ARCHIVE_FILTER_NONE;
-pub const ARCHIVE_COMPRESSION_GZIP = ARCHIVE_FILTER_GZIP;
-pub const ARCHIVE_COMPRESSION_BZIP2 = ARCHIVE_FILTER_BZIP2;
-pub const ARCHIVE_COMPRESSION_COMPRESS = ARCHIVE_FILTER_COMPRESS;
-pub const ARCHIVE_COMPRESSION_PROGRAM = ARCHIVE_FILTER_PROGRAM;
-pub const ARCHIVE_COMPRESSION_LZMA = ARCHIVE_FILTER_LZMA;
-pub const ARCHIVE_COMPRESSION_XZ = ARCHIVE_FILTER_XZ;
-pub const ARCHIVE_COMPRESSION_UU = ARCHIVE_FILTER_UU;
-pub const ARCHIVE_COMPRESSION_RPM = ARCHIVE_FILTER_RPM;
-pub const ARCHIVE_COMPRESSION_LZIP = ARCHIVE_FILTER_LZIP;
-pub const ARCHIVE_COMPRESSION_LRZIP = ARCHIVE_FILTER_LRZIP;
-pub const ARCHIVE_FORMAT_BASE_MASK = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xff0000, .hexadecimal);
-pub const ARCHIVE_FORMAT_CPIO = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x10000, .hexadecimal);
-pub const ARCHIVE_FORMAT_CPIO_POSIX = ARCHIVE_FORMAT_CPIO | @as(c_int, 1);
-pub const ARCHIVE_FORMAT_CPIO_BIN_LE = ARCHIVE_FORMAT_CPIO | @as(c_int, 2);
-pub const ARCHIVE_FORMAT_CPIO_BIN_BE = ARCHIVE_FORMAT_CPIO | @as(c_int, 3);
-pub const ARCHIVE_FORMAT_CPIO_SVR4_NOCRC = ARCHIVE_FORMAT_CPIO | @as(c_int, 4);
-pub const ARCHIVE_FORMAT_CPIO_SVR4_CRC = ARCHIVE_FORMAT_CPIO | @as(c_int, 5);
-pub const ARCHIVE_FORMAT_CPIO_AFIO_LARGE = ARCHIVE_FORMAT_CPIO | @as(c_int, 6);
-pub const ARCHIVE_FORMAT_CPIO_PWB = ARCHIVE_FORMAT_CPIO | @as(c_int, 7);
-pub const ARCHIVE_FORMAT_SHAR = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x20000, .hexadecimal);
-pub const ARCHIVE_FORMAT_SHAR_BASE = ARCHIVE_FORMAT_SHAR | @as(c_int, 1);
-pub const ARCHIVE_FORMAT_SHAR_DUMP = ARCHIVE_FORMAT_SHAR | @as(c_int, 2);
-pub const ARCHIVE_FORMAT_TAR = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x30000, .hexadecimal);
-pub const ARCHIVE_FORMAT_TAR_USTAR = ARCHIVE_FORMAT_TAR | @as(c_int, 1);
-pub const ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE = ARCHIVE_FORMAT_TAR | @as(c_int, 2);
-pub const ARCHIVE_FORMAT_TAR_PAX_RESTRICTED = ARCHIVE_FORMAT_TAR | @as(c_int, 3);
-pub const ARCHIVE_FORMAT_TAR_GNUTAR = ARCHIVE_FORMAT_TAR | @as(c_int, 4);
-pub const ARCHIVE_FORMAT_ISO9660 = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x40000, .hexadecimal);
-pub const ARCHIVE_FORMAT_ISO9660_ROCKRIDGE = ARCHIVE_FORMAT_ISO9660 | @as(c_int, 1);
-pub const ARCHIVE_FORMAT_ZIP = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x50000, .hexadecimal);
-pub const ARCHIVE_FORMAT_EMPTY = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x60000, .hexadecimal);
-pub const ARCHIVE_FORMAT_AR = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x70000, .hexadecimal);
-pub const ARCHIVE_FORMAT_AR_GNU = ARCHIVE_FORMAT_AR | @as(c_int, 1);
-pub const ARCHIVE_FORMAT_AR_BSD = ARCHIVE_FORMAT_AR | @as(c_int, 2);
-pub const ARCHIVE_FORMAT_MTREE = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x80000, .hexadecimal);
-pub const ARCHIVE_FORMAT_RAW = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x90000, .hexadecimal);
-pub const ARCHIVE_FORMAT_XAR = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xA0000, .hexadecimal);
-pub const ARCHIVE_FORMAT_LHA = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xB0000, .hexadecimal);
-pub const ARCHIVE_FORMAT_CAB = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xC0000, .hexadecimal);
-pub const ARCHIVE_FORMAT_RAR = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xD0000, .hexadecimal);
-pub const ARCHIVE_FORMAT_7ZIP = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xE0000, .hexadecimal);
-pub const ARCHIVE_FORMAT_WARC = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xF0000, .hexadecimal);
-pub const ARCHIVE_FORMAT_RAR_V5 = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x100000, .hexadecimal);
-pub const ARCHIVE_READ_FORMAT_CAPS_NONE = @as(c_int, 0);
-pub const ARCHIVE_READ_FORMAT_CAPS_ENCRYPT_DATA = @as(c_int, 1) << @as(c_int, 0);
-pub const ARCHIVE_READ_FORMAT_CAPS_ENCRYPT_METADATA = @as(c_int, 1) << @as(c_int, 1);
-pub const ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED = -@as(c_int, 2);
-pub const ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW = -@as(c_int, 1);
-pub const ARCHIVE_EXTRACT_OWNER = @as(c_int, 0x0001);
-pub const ARCHIVE_EXTRACT_PERM = @as(c_int, 0x0002);
-pub const ARCHIVE_EXTRACT_TIME = @as(c_int, 0x0004);
-pub const ARCHIVE_EXTRACT_NO_OVERWRITE = @as(c_int, 0x0008);
-pub const ARCHIVE_EXTRACT_UNLINK = @as(c_int, 0x0010);
-pub const ARCHIVE_EXTRACT_ACL = @as(c_int, 0x0020);
-pub const ARCHIVE_EXTRACT_FFLAGS = @as(c_int, 0x0040);
-pub const ARCHIVE_EXTRACT_XATTR = @as(c_int, 0x0080);
-pub const ARCHIVE_EXTRACT_SECURE_SYMLINKS = @as(c_int, 0x0100);
-pub const ARCHIVE_EXTRACT_SECURE_NODOTDOT = @as(c_int, 0x0200);
-pub const ARCHIVE_EXTRACT_NO_AUTODIR = @as(c_int, 0x0400);
-pub const ARCHIVE_EXTRACT_NO_OVERWRITE_NEWER = @as(c_int, 0x0800);
-pub const ARCHIVE_EXTRACT_SPARSE = @as(c_int, 0x1000);
-pub const ARCHIVE_EXTRACT_MAC_METADATA = @as(c_int, 0x2000);
-pub const ARCHIVE_EXTRACT_NO_HFS_COMPRESSION = @as(c_int, 0x4000);
-pub const ARCHIVE_EXTRACT_HFS_COMPRESSION_FORCED = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8000, .hexadecimal);
-pub const ARCHIVE_EXTRACT_SECURE_NOABSOLUTEPATHS = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x10000, .hexadecimal);
-pub const ARCHIVE_EXTRACT_CLEAR_NOCHANGE_FFLAGS = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x20000, .hexadecimal);
-pub const ARCHIVE_EXTRACT_SAFE_WRITES = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x40000, .hexadecimal);
-pub const ARCHIVE_READDISK_RESTORE_ATIME = @as(c_int, 0x0001);
-pub const ARCHIVE_READDISK_HONOR_NODUMP = @as(c_int, 0x0002);
-pub const ARCHIVE_READDISK_MAC_COPYFILE = @as(c_int, 0x0004);
-pub const ARCHIVE_READDISK_NO_TRAVERSE_MOUNTS = @as(c_int, 0x0008);
-pub const ARCHIVE_READDISK_NO_XATTR = @as(c_int, 0x0010);
-pub const ARCHIVE_READDISK_NO_ACL = @as(c_int, 0x0020);
-pub const ARCHIVE_READDISK_NO_FFLAGS = @as(c_int, 0x0040);
-pub const ARCHIVE_MATCH_MTIME = @as(c_int, 0x0100);
-pub const ARCHIVE_MATCH_CTIME = @as(c_int, 0x0200);
-pub const ARCHIVE_MATCH_NEWER = @as(c_int, 0x0001);
-pub const ARCHIVE_MATCH_OLDER = @as(c_int, 0x0002);
-pub const ARCHIVE_MATCH_EQUAL = @as(c_int, 0x0010);
+const time_t = isize;
+
+pub const Flags = struct {
+    pub const Extract = enum(c_int) {
+        owner = ARCHIVE_EXTRACT_OWNER,
+        perm = ARCHIVE_EXTRACT_PERM,
+        time = ARCHIVE_EXTRACT_TIME,
+        no_overwrite = ARCHIVE_EXTRACT_NO_OVERWRITE,
+        unlink = ARCHIVE_EXTRACT_UNLINK,
+        acl = ARCHIVE_EXTRACT_ACL,
+        fflags = ARCHIVE_EXTRACT_FFLAGS,
+        xattr = ARCHIVE_EXTRACT_XATTR,
+        secure_symlinks = ARCHIVE_EXTRACT_SECURE_SYMLINKS,
+        secure_nodotdot = ARCHIVE_EXTRACT_SECURE_NODOTDOT,
+        no_autodir = ARCHIVE_EXTRACT_NO_AUTODIR,
+        no_overwrite_newer = ARCHIVE_EXTRACT_NO_OVERWRITE_NEWER,
+        sparse = ARCHIVE_EXTRACT_SPARSE,
+        mac_metadata = ARCHIVE_EXTRACT_MAC_METADATA,
+        no_hfs_compression = ARCHIVE_EXTRACT_NO_HFS_COMPRESSION,
+        hfs_compression_forced = ARCHIVE_EXTRACT_HFS_COMPRESSION_FORCED,
+        secure_noabsolutepaths = ARCHIVE_EXTRACT_SECURE_NOABSOLUTEPATHS,
+        clear_nochange_fflags = ARCHIVE_EXTRACT_CLEAR_NOCHANGE_FFLAGS,
+        safe_writes = ARCHIVE_EXTRACT_SAFE_WRITES,
+    };
+
+    // Deprecated
+    // pub const Compression = enum(c_int) {
+    //     none = ARCHIVE_COMPRESSION_NONE,
+    //     gzip = ARCHIVE_COMPRESSION_GZIP,
+    //     bzip2 = ARCHIVE_COMPRESSION_BZIP2,
+    //     compress = ARCHIVE_COMPRESSION_COMPRESS,
+    //     program = ARCHIVE_COMPRESSION_PROGRAM,
+    //     lzma = ARCHIVE_COMPRESSION_LZMA,
+    //     xz = ARCHIVE_COMPRESSION_XZ,
+    //     uu = ARCHIVE_COMPRESSION_UU,
+    //     rpm = ARCHIVE_COMPRESSION_RPM,
+    //     lzip = ARCHIVE_COMPRESSION_LZIP,
+    //     lrzip = ARCHIVE_COMPRESSION_LRZIP,
+    // };
+
+    pub const Format = enum(c_int) {
+        base_mask = ARCHIVE_FORMAT_BASE_MASK,
+        cpio = ARCHIVE_FORMAT_CPIO,
+        cpio_posix = ARCHIVE_FORMAT_CPIO_POSIX,
+        cpio_bin_le = ARCHIVE_FORMAT_CPIO_BIN_LE,
+        cpio_bin_be = ARCHIVE_FORMAT_CPIO_BIN_BE,
+        cpio_svr4_nocrc = ARCHIVE_FORMAT_CPIO_SVR4_NOCRC,
+        cpio_svr4_crc = ARCHIVE_FORMAT_CPIO_SVR4_CRC,
+        cpio_afio_large = ARCHIVE_FORMAT_CPIO_AFIO_LARGE,
+        cpio_pwb = ARCHIVE_FORMAT_CPIO_PWB,
+        shar = ARCHIVE_FORMAT_SHAR,
+        shar_base = ARCHIVE_FORMAT_SHAR_BASE,
+        shar_dump = ARCHIVE_FORMAT_SHAR_DUMP,
+        tar = ARCHIVE_FORMAT_TAR,
+        tar_ustar = ARCHIVE_FORMAT_TAR_USTAR,
+        tar_pax_interchange = ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE,
+        tar_pax_restricted = ARCHIVE_FORMAT_TAR_PAX_RESTRICTED,
+        tar_gnutar = ARCHIVE_FORMAT_TAR_GNUTAR,
+        iso9660 = ARCHIVE_FORMAT_ISO9660,
+        iso9660_rockridge = ARCHIVE_FORMAT_ISO9660_ROCKRIDGE,
+        zip = ARCHIVE_FORMAT_ZIP,
+        empty = ARCHIVE_FORMAT_EMPTY,
+        ar = ARCHIVE_FORMAT_AR,
+        ar_gnu = ARCHIVE_FORMAT_AR_GNU,
+        ar_bsd = ARCHIVE_FORMAT_AR_BSD,
+        mtree = ARCHIVE_FORMAT_MTREE,
+        raw = ARCHIVE_FORMAT_RAW,
+        xar = ARCHIVE_FORMAT_XAR,
+        lha = ARCHIVE_FORMAT_LHA,
+        cab = ARCHIVE_FORMAT_CAB,
+        rar = ARCHIVE_FORMAT_RAR,
+        @"7zip" = ARCHIVE_FORMAT_7ZIP,
+        warc = ARCHIVE_FORMAT_WARC,
+        rar_v5 = ARCHIVE_FORMAT_RAR_V5,
+    };
+
+    pub const Filter = enum(c_int) {
+        none = ARCHIVE_FILTER_NONE,
+        gzip = ARCHIVE_FILTER_GZIP,
+        bzip2 = ARCHIVE_FILTER_BZIP2,
+        compress = ARCHIVE_FILTER_COMPRESS,
+        program = ARCHIVE_FILTER_PROGRAM,
+        lzma = ARCHIVE_FILTER_LZMA,
+        xz = ARCHIVE_FILTER_XZ,
+        uu = ARCHIVE_FILTER_UU,
+        rpm = ARCHIVE_FILTER_RPM,
+        lzip = ARCHIVE_FILTER_LZIP,
+        lrzip = ARCHIVE_FILTER_LRZIP,
+        lzop = ARCHIVE_FILTER_LZOP,
+        grzip = ARCHIVE_FILTER_GRZIP,
+        lz4 = ARCHIVE_FILTER_LZ4,
+        zstd = ARCHIVE_FILTER_ZSTD,
+    };
+
+    pub const EntryDigest = enum(c_int) {
+        md5 = ARCHIVE_ENTRY_DIGEST_MD5,
+        rmd160 = ARCHIVE_ENTRY_DIGEST_RMD160,
+        sha1 = ARCHIVE_ENTRY_DIGEST_SHA1,
+        sha256 = ARCHIVE_ENTRY_DIGEST_SHA256,
+        sha384 = ARCHIVE_ENTRY_DIGEST_SHA384,
+        sha512 = ARCHIVE_ENTRY_DIGEST_SHA512,
+    };
+
+    pub const EntryACL = enum(c_int) {
+        entry_acl_execute = ARCHIVE_ENTRY_ACL_EXECUTE,
+        write = ARCHIVE_ENTRY_ACL_WRITE,
+        read = ARCHIVE_ENTRY_ACL_READ,
+        read_data = ARCHIVE_ENTRY_ACL_READ_DATA,
+        list_directory = ARCHIVE_ENTRY_ACL_LIST_DIRECTORY,
+        write_data = ARCHIVE_ENTRY_ACL_WRITE_DATA,
+        add_file = ARCHIVE_ENTRY_ACL_ADD_FILE,
+        append_data = ARCHIVE_ENTRY_ACL_APPEND_DATA,
+        add_subdirectory = ARCHIVE_ENTRY_ACL_ADD_SUBDIRECTORY,
+        read_named_attrs = ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS,
+        write_named_attrs = ARCHIVE_ENTRY_ACL_WRITE_NAMED_ATTRS,
+        delete_child = ARCHIVE_ENTRY_ACL_DELETE_CHILD,
+        read_attributes = ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES,
+        write_attributes = ARCHIVE_ENTRY_ACL_WRITE_ATTRIBUTES,
+        delete = ARCHIVE_ENTRY_ACL_DELETE,
+        read_acl = ARCHIVE_ENTRY_ACL_READ_ACL,
+        write_acl = ARCHIVE_ENTRY_ACL_WRITE_ACL,
+        write_owner = ARCHIVE_ENTRY_ACL_WRITE_OWNER,
+        synchronize = ARCHIVE_ENTRY_ACL_SYNCHRONIZE,
+        perms_posix1_e = ARCHIVE_ENTRY_ACL_PERMS_POSIX1E,
+        perms_nfs4 = ARCHIVE_ENTRY_ACL_PERMS_NFS4,
+        entry_inherited = ARCHIVE_ENTRY_ACL_ENTRY_INHERITED,
+        entry_file_inherit = ARCHIVE_ENTRY_ACL_ENTRY_FILE_INHERIT,
+        entry_directory_inherit = ARCHIVE_ENTRY_ACL_ENTRY_DIRECTORY_INHERIT,
+        entry_no_propagate_inherit = ARCHIVE_ENTRY_ACL_ENTRY_NO_PROPAGATE_INHERIT,
+        entry_inherit_only = ARCHIVE_ENTRY_ACL_ENTRY_INHERIT_ONLY,
+        entry_successful_access = ARCHIVE_ENTRY_ACL_ENTRY_SUCCESSFUL_ACCESS,
+        entry_failed_access = ARCHIVE_ENTRY_ACL_ENTRY_FAILED_ACCESS,
+        inheritance_nfs4 = ARCHIVE_ENTRY_ACL_INHERITANCE_NFS4,
+        type_access = ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
+        type_default = ARCHIVE_ENTRY_ACL_TYPE_DEFAULT,
+        type_allow = ARCHIVE_ENTRY_ACL_TYPE_ALLOW,
+        type_deny = ARCHIVE_ENTRY_ACL_TYPE_DENY,
+        type_audit = ARCHIVE_ENTRY_ACL_TYPE_AUDIT,
+        type_alarm = ARCHIVE_ENTRY_ACL_TYPE_ALARM,
+        type_posix1_e = ARCHIVE_ENTRY_ACL_TYPE_POSIX1E,
+        type_nfs4 = ARCHIVE_ENTRY_ACL_TYPE_NFS4,
+        user = ARCHIVE_ENTRY_ACL_USER,
+        user_obj = ARCHIVE_ENTRY_ACL_USER_OBJ,
+        group = ARCHIVE_ENTRY_ACL_GROUP,
+        group_obj = ARCHIVE_ENTRY_ACL_GROUP_OBJ,
+        mask = ARCHIVE_ENTRY_ACL_MASK,
+        other = ARCHIVE_ENTRY_ACL_OTHER,
+        everyone = ARCHIVE_ENTRY_ACL_EVERYONE,
+        style_extra_id = ARCHIVE_ENTRY_ACL_STYLE_EXTRA_ID,
+        style_mark_default = ARCHIVE_ENTRY_ACL_STYLE_MARK_DEFAULT,
+        style_solaris = ARCHIVE_ENTRY_ACL_STYLE_SOLARIS,
+        style_separator_comma = ARCHIVE_ENTRY_ACL_STYLE_SEPARATOR_COMMA,
+        style_compact = ARCHIVE_ENTRY_ACL_STYLE_COMPACT,
+    };
+};
+
+const ARCHIVE_VERSION_ONLY_STRING = "3.5.3dev";
+const ARCHIVE_VERSION_STRING = "libarchive " ++ ARCHIVE_VERSION_ONLY_STRING;
+const ARCHIVE_EOF = @as(c_int, 1);
+const ARCHIVE_OK = @as(c_int, 0);
+const ARCHIVE_RETRY = -@as(c_int, 10);
+const ARCHIVE_WARN = -@as(c_int, 20);
+const ARCHIVE_FAILED = -@as(c_int, 25);
+const ARCHIVE_FATAL = -@as(c_int, 30);
+const ARCHIVE_FILTER_NONE = @as(c_int, 0);
+const ARCHIVE_FILTER_GZIP = @as(c_int, 1);
+const ARCHIVE_FILTER_BZIP2 = @as(c_int, 2);
+const ARCHIVE_FILTER_COMPRESS = @as(c_int, 3);
+const ARCHIVE_FILTER_PROGRAM = @as(c_int, 4);
+const ARCHIVE_FILTER_LZMA = @as(c_int, 5);
+const ARCHIVE_FILTER_XZ = @as(c_int, 6);
+const ARCHIVE_FILTER_UU = @as(c_int, 7);
+const ARCHIVE_FILTER_RPM = @as(c_int, 8);
+const ARCHIVE_FILTER_LZIP = @as(c_int, 9);
+const ARCHIVE_FILTER_LRZIP = @as(c_int, 10);
+const ARCHIVE_FILTER_LZOP = @as(c_int, 11);
+const ARCHIVE_FILTER_GRZIP = @as(c_int, 12);
+const ARCHIVE_FILTER_LZ4 = @as(c_int, 13);
+const ARCHIVE_FILTER_ZSTD = @as(c_int, 14);
+// Deprecated
+// pub const ARCHIVE_COMPRESSION_NONE = ARCHIVE_FILTER_NONE;
+// pub const ARCHIVE_COMPRESSION_GZIP = ARCHIVE_FILTER_GZIP;
+// pub const ARCHIVE_COMPRESSION_BZIP2 = ARCHIVE_FILTER_BZIP2;
+// pub const ARCHIVE_COMPRESSION_COMPRESS = ARCHIVE_FILTER_COMPRESS;
+// pub const ARCHIVE_COMPRESSION_PROGRAM = ARCHIVE_FILTER_PROGRAM;
+// pub const ARCHIVE_COMPRESSION_LZMA = ARCHIVE_FILTER_LZMA;
+// pub const ARCHIVE_COMPRESSION_XZ = ARCHIVE_FILTER_XZ;
+// pub const ARCHIVE_COMPRESSION_UU = ARCHIVE_FILTER_UU;
+// pub const ARCHIVE_COMPRESSION_RPM = ARCHIVE_FILTER_RPM;
+// pub const ARCHIVE_COMPRESSION_LZIP = ARCHIVE_FILTER_LZIP;
+// pub const ARCHIVE_COMPRESSION_LRZIP = ARCHIVE_FILTER_LRZIP;
+const ARCHIVE_FORMAT_BASE_MASK = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xff0000, .hexadecimal);
+const ARCHIVE_FORMAT_CPIO = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x10000, .hexadecimal);
+const ARCHIVE_FORMAT_CPIO_POSIX = ARCHIVE_FORMAT_CPIO | @as(c_int, 1);
+const ARCHIVE_FORMAT_CPIO_BIN_LE = ARCHIVE_FORMAT_CPIO | @as(c_int, 2);
+const ARCHIVE_FORMAT_CPIO_BIN_BE = ARCHIVE_FORMAT_CPIO | @as(c_int, 3);
+const ARCHIVE_FORMAT_CPIO_SVR4_NOCRC = ARCHIVE_FORMAT_CPIO | @as(c_int, 4);
+const ARCHIVE_FORMAT_CPIO_SVR4_CRC = ARCHIVE_FORMAT_CPIO | @as(c_int, 5);
+const ARCHIVE_FORMAT_CPIO_AFIO_LARGE = ARCHIVE_FORMAT_CPIO | @as(c_int, 6);
+const ARCHIVE_FORMAT_CPIO_PWB = ARCHIVE_FORMAT_CPIO | @as(c_int, 7);
+const ARCHIVE_FORMAT_SHAR = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x20000, .hexadecimal);
+const ARCHIVE_FORMAT_SHAR_BASE = ARCHIVE_FORMAT_SHAR | @as(c_int, 1);
+const ARCHIVE_FORMAT_SHAR_DUMP = ARCHIVE_FORMAT_SHAR | @as(c_int, 2);
+const ARCHIVE_FORMAT_TAR = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x30000, .hexadecimal);
+const ARCHIVE_FORMAT_TAR_USTAR = ARCHIVE_FORMAT_TAR | @as(c_int, 1);
+const ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE = ARCHIVE_FORMAT_TAR | @as(c_int, 2);
+const ARCHIVE_FORMAT_TAR_PAX_RESTRICTED = ARCHIVE_FORMAT_TAR | @as(c_int, 3);
+const ARCHIVE_FORMAT_TAR_GNUTAR = ARCHIVE_FORMAT_TAR | @as(c_int, 4);
+const ARCHIVE_FORMAT_ISO9660 = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x40000, .hexadecimal);
+const ARCHIVE_FORMAT_ISO9660_ROCKRIDGE = ARCHIVE_FORMAT_ISO9660 | @as(c_int, 1);
+const ARCHIVE_FORMAT_ZIP = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x50000, .hexadecimal);
+const ARCHIVE_FORMAT_EMPTY = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x60000, .hexadecimal);
+const ARCHIVE_FORMAT_AR = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x70000, .hexadecimal);
+const ARCHIVE_FORMAT_AR_GNU = ARCHIVE_FORMAT_AR | @as(c_int, 1);
+const ARCHIVE_FORMAT_AR_BSD = ARCHIVE_FORMAT_AR | @as(c_int, 2);
+const ARCHIVE_FORMAT_MTREE = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x80000, .hexadecimal);
+const ARCHIVE_FORMAT_RAW = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x90000, .hexadecimal);
+const ARCHIVE_FORMAT_XAR = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xA0000, .hexadecimal);
+const ARCHIVE_FORMAT_LHA = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xB0000, .hexadecimal);
+const ARCHIVE_FORMAT_CAB = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xC0000, .hexadecimal);
+const ARCHIVE_FORMAT_RAR = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xD0000, .hexadecimal);
+const ARCHIVE_FORMAT_7ZIP = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xE0000, .hexadecimal);
+const ARCHIVE_FORMAT_WARC = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xF0000, .hexadecimal);
+const ARCHIVE_FORMAT_RAR_V5 = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x100000, .hexadecimal);
+const ARCHIVE_READ_FORMAT_CAPS_NONE = @as(c_int, 0);
+const ARCHIVE_READ_FORMAT_CAPS_ENCRYPT_DATA = @as(c_int, 1) << @as(c_int, 0);
+const ARCHIVE_READ_FORMAT_CAPS_ENCRYPT_METADATA = @as(c_int, 1) << @as(c_int, 1);
+const ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED = -@as(c_int, 2);
+const ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW = -@as(c_int, 1);
+const ARCHIVE_EXTRACT_OWNER = @as(c_int, 0x0001);
+const ARCHIVE_EXTRACT_PERM = @as(c_int, 0x0002);
+const ARCHIVE_EXTRACT_TIME = @as(c_int, 0x0004);
+const ARCHIVE_EXTRACT_NO_OVERWRITE = @as(c_int, 0x0008);
+const ARCHIVE_EXTRACT_UNLINK = @as(c_int, 0x0010);
+const ARCHIVE_EXTRACT_ACL = @as(c_int, 0x0020);
+const ARCHIVE_EXTRACT_FFLAGS = @as(c_int, 0x0040);
+const ARCHIVE_EXTRACT_XATTR = @as(c_int, 0x0080);
+const ARCHIVE_EXTRACT_SECURE_SYMLINKS = @as(c_int, 0x0100);
+const ARCHIVE_EXTRACT_SECURE_NODOTDOT = @as(c_int, 0x0200);
+const ARCHIVE_EXTRACT_NO_AUTODIR = @as(c_int, 0x0400);
+const ARCHIVE_EXTRACT_NO_OVERWRITE_NEWER = @as(c_int, 0x0800);
+const ARCHIVE_EXTRACT_SPARSE = @as(c_int, 0x1000);
+const ARCHIVE_EXTRACT_MAC_METADATA = @as(c_int, 0x2000);
+const ARCHIVE_EXTRACT_NO_HFS_COMPRESSION = @as(c_int, 0x4000);
+const ARCHIVE_EXTRACT_HFS_COMPRESSION_FORCED = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8000, .hexadecimal);
+const ARCHIVE_EXTRACT_SECURE_NOABSOLUTEPATHS = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x10000, .hexadecimal);
+const ARCHIVE_EXTRACT_CLEAR_NOCHANGE_FFLAGS = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x20000, .hexadecimal);
+const ARCHIVE_EXTRACT_SAFE_WRITES = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x40000, .hexadecimal);
+const ARCHIVE_READDISK_RESTORE_ATIME = @as(c_int, 0x0001);
+const ARCHIVE_READDISK_HONOR_NODUMP = @as(c_int, 0x0002);
+const ARCHIVE_READDISK_MAC_COPYFILE = @as(c_int, 0x0004);
+const ARCHIVE_READDISK_NO_TRAVERSE_MOUNTS = @as(c_int, 0x0008);
+const ARCHIVE_READDISK_NO_XATTR = @as(c_int, 0x0010);
+const ARCHIVE_READDISK_NO_ACL = @as(c_int, 0x0020);
+const ARCHIVE_READDISK_NO_FFLAGS = @as(c_int, 0x0040);
+const ARCHIVE_MATCH_MTIME = @as(c_int, 0x0100);
+const ARCHIVE_MATCH_CTIME = @as(c_int, 0x0200);
+const ARCHIVE_MATCH_NEWER = @as(c_int, 0x0001);
+const ARCHIVE_MATCH_OLDER = @as(c_int, 0x0002);
+const ARCHIVE_MATCH_EQUAL = @as(c_int, 0x0010);
 
 pub const Archive = opaque {
     pub const Result = enum(i32) {
@@ -176,7 +334,9 @@ pub const Archive = opaque {
 
     extern fn archive_error_string(*Archive) [*c]const u8;
     pub fn errorString(archive: *Archive) []const u8 {
-        return bun.sliceTo(archive_error_string(archive), 0);
+        const err_str = archive_error_string(archive);
+        if (err_str == null) return "";
+        return bun.sliceTo(err_str, 0);
     }
 
     extern fn archive_write_new() *Archive;
@@ -189,7 +349,7 @@ pub const Archive = opaque {
         return archive_write_close(archive);
     }
 
-    pub extern fn archive_write_finish(*Archive) Result;
+    extern fn archive_write_finish(*Archive) Result;
     pub fn writeFinish(archive: *Archive) Result {
         return archive_write_finish(archive);
     }
@@ -199,7 +359,7 @@ pub const Archive = opaque {
         return archive_free(archive);
     }
 
-    pub extern fn archive_write_set_options(_a: *Archive, opts: [*c]const u8) Result;
+    extern fn archive_write_set_options(_a: *Archive, opts: [*c]const u8) Result;
     pub fn writeSetOptions(archive: *Archive, opts: [:0]const u8) Result {
         return archive_write_set_options(archive, opts);
     }
@@ -209,46 +369,114 @@ pub const Archive = opaque {
         return archive_write_set_format_pax_restricted(archive);
     }
 
-    pub extern fn archive_write_set_format_gnutar(*Archive) Result;
+    extern fn archive_write_set_format_gnutar(*Archive) Result;
     pub fn writeSetFormatGnutar(archive: *Archive) Result {
         return archive_write_set_format_gnutar(archive);
     }
 
-    pub extern fn archive_write_set_format_7zip(*Archive) Result;
+    extern fn archive_write_set_format_7zip(*Archive) Result;
     pub fn writeSetFormat7zip(archive: *Archive) Result {
         return archive_write_set_format_7zip(archive);
     }
 
-    pub extern fn archive_write_set_format_pax(*Archive) Result;
+    extern fn archive_write_set_format_pax(*Archive) Result;
     pub fn writeSetFormatPax(archive: *Archive) Result {
         return archive_write_set_format_pax(archive);
     }
 
-    pub extern fn archive_write_set_format_ustar(*Archive) Result;
+    extern fn archive_write_set_format_ustar(*Archive) Result;
     pub fn writeSetFormatUstar(archive: *Archive) Result {
         return archive_write_set_format_ustar(archive);
     }
 
-    pub extern fn archive_write_set_format_zip(*Archive) Result;
+    extern fn archive_write_set_format_zip(*Archive) Result;
     pub fn writeSetFormatZip(archive: *Archive) Result {
         return archive_write_set_format_zip(archive);
     }
 
-    pub extern fn archive_write_set_format_shar(*Archive) Result;
+    extern fn archive_write_set_format_shar(*Archive) Result;
     pub fn writeSetFormatShar(archive: *Archive) Result {
         return archive_write_set_format_shar(archive);
     }
 
-    extern fn archive_write_set_compression_gzip(*Archive) Result;
-    pub fn writeSetCompressionGzip(archive: *Archive) Result {
-        return archive_write_set_compression_gzip(archive);
+    extern fn archive_write_set_format(*struct_archive, format_code: i32) Result;
+    pub fn writeSetFormat(archive: *Archive, format: Flags.Format) Result {
+        return archive_write_set_format(archive, @intFromEnum(format));
     }
 
+    // deprecated
+    //
+    // extern fn archive_write_set_compression_gzip(*Archive) Result;
+    // pub fn writeSetCompressionGzip(archive: *Archive) Result {
+    //     return archive_write_set_compression_gzip(archive);
+    // }
+
     extern fn archive_write_add_filter_gzip(*Archive) Result;
     pub fn writeAddFilterGzip(archive: *Archive) Result {
         return archive_write_add_filter_gzip(archive);
     }
 
+    extern fn archive_write_add_filter(*Archive, filter_code: i32) Result;
+    pub fn writeAddFilter(archive: *Archive, filter: Flags.Filter) Result {
+        return archive_write_add_filter(archive, @intFromEnum(filter));
+    }
+    extern fn archive_write_add_filter_by_name(*Archive, name: [*c]const u8) Result;
+    pub fn writeAddFilterByName(archive: *Archive, name: [:0]const u8) Result {
+        return archive_write_add_filter_by_name(archive, name.ptr);
+    }
+    extern fn archive_write_add_filter_b64encode(*Archive) Result;
+    pub fn writeAddFilterB64encode(archive: *Archive) Result {
+        return archive_write_add_filter_b64encode(archive);
+    }
+    // extern fn archive_write_add_filter_bzip2(*Archive) Result;
+    // pub fn writeAddFilterBzip2(archive: *Archive) Result {
+    //     return archive_write_add_filter_bzip2(archive);
+    // }
+    extern fn archive_write_add_filter_compress(*Archive) Result;
+    pub fn writeAddFilterCompress(archive: *Archive) Result {
+        return archive_write_add_filter_compress(archive);
+    }
+    extern fn archive_write_add_filter_grzip(*Archive) Result;
+    pub fn writeAddFilterGrzip(archive: *Archive) Result {
+        return archive_write_add_filter_grzip(archive);
+    }
+    extern fn archive_write_add_filter_lrzip(*Archive) Result;
+    pub fn writeAddFilterLrzip(archive: *Archive) Result {
+        return archive_write_add_filter_lrzip(archive);
+    }
+    extern fn archive_write_add_filter_lz4(*Archive) Result;
+    pub fn writeAddFilterLz4(archive: *Archive) Result {
+        return archive_write_add_filter_lz4(archive);
+    }
+    extern fn archive_write_add_filter_lzip(*Archive) Result;
+    pub fn writeAddFilterLzip(archive: *Archive) Result {
+        return archive_write_add_filter_lzip(archive);
+    }
+    extern fn archive_write_add_filter_lzma(*Archive) Result;
+    pub fn writeAddFilterLzma(archive: *Archive) Result {
+        return archive_write_add_filter_lzma(archive);
+    }
+    extern fn archive_write_add_filter_lzop(*Archive) Result;
+    pub fn writeAddFilterLzop(archive: *Archive) Result {
+        return archive_write_add_filter_lzop(archive);
+    }
+    extern fn archive_write_add_filter_none(*Archive) Result;
+    pub fn writeAddFilterNone(archive: *Archive) Result {
+        return archive_write_add_filter_none(archive);
+    }
+    extern fn archive_write_add_filter_uuencode(*Archive) Result;
+    pub fn writeAddFilterUuencode(archive: *Archive) Result {
+        return archive_write_add_filter_uuencode(archive);
+    }
+    extern fn archive_write_add_filter_xz(*Archive) Result;
+    pub fn writeAddFilterXz(archive: *Archive) Result {
+        return archive_write_add_filter_xz(archive);
+    }
+    extern fn archive_write_add_filter_zstd(*Archive) Result;
+    pub fn writeAddFilterZstd(archive: *Archive) Result {
+        return archive_write_add_filter_zstd(archive);
+    }
+
     extern fn archive_write_set_filter_option(*Archive, [*c]const u8, [*c]const u8, [*c]const u8) Result;
     pub fn writeSetFilterOption(archive: *Archive, m: ?[:0]const u8, o: [:0]const u8, v: [:0]const u8) Result {
         return archive_write_set_filter_option(archive, m orelse null, o, v);
@@ -259,12 +487,12 @@ pub const Archive = opaque {
         return archive_write_open_filename(archive, filename);
     }
 
-    pub extern fn archive_write_open_fd(*Archive, _fd: c_int) Result;
+    extern fn archive_write_open_fd(*Archive, _fd: c_int) Result;
     pub fn writeOpenFd(archive: *Archive, fd: bun.FileDescriptor) Result {
         return archive_write_open_fd(archive, fd.cast());
     }
 
-    pub extern fn archive_write_open_memory(*Archive, _buffer: ?*anyopaque, _buffSize: usize, _used: [*c]usize) Result;
+    extern fn archive_write_open_memory(*Archive, _buffer: ?*anyopaque, _buffSize: usize, _used: [*c]usize) Result;
     pub fn writeOpenMemory(archive: *Archive, buf: ?*anyopaque, buf_size: usize, used: *usize) Result {
         return archive_write_open_memory(archive, buf, buf_size, used);
     }
@@ -279,23 +507,260 @@ pub const Archive = opaque {
         return archive_write_data(archive, data.ptr, data.len);
     }
 
-    pub extern fn archive_write_finish_entry(*Archive) Result;
+    extern fn archive_write_finish_entry(*Archive) Result;
     pub fn writeFinishEntry(archive: *Archive) Result {
         return archive_write_finish_entry(archive);
     }
 
-    pub extern fn archive_write_free(*Archive) Result;
+    extern fn archive_write_free(*Archive) Result;
     pub fn writeFree(archive: *Archive) Result {
         return archive_write_free(archive);
     }
 
+    extern fn archive_read_new() *Archive;
+    pub fn readNew() *Archive {
+        return archive_read_new();
+    }
+
+    extern fn archive_read_close(*Archive) Result;
+    pub fn readClose(archive: *Archive) Result {
+        return archive_read_close(archive);
+    }
+
+    pub extern fn archive_read_free(*Archive) Result;
+    pub fn readFree(archive: *Archive) Result {
+        return archive_read_free(archive);
+    }
+
+    pub extern fn archive_read_finish(*Archive) Result;
+    pub fn readFinish(archive: *Archive) Result {
+        return archive_read_finish(archive);
+    }
+
+    // these are deprecated
+    //
+    // extern fn archive_read_support_compression_all(*Archive) Result;
+    // pub fn readSupportCompressionAll(archive: *Archive) Result {
+    //     return archive_read_support_compression_all(archive);
+    // }
+    // extern fn archive_read_support_compression_bzip2(*Archive) Result;
+    // pub fn readSupportCompressionBzip2(archive: *Archive) Result {
+    //     return archive_read_support_compression_bzip2(archive);
+    // }
+    // extern fn archive_read_support_compression_compress(*Archive) Result;
+    // pub fn readSupportCompressionCompress(archive: *Archive) Result {
+    //     return archive_read_support_compression_compress(archive);
+    // }
+    // extern fn archive_read_support_compression_gzip(*Archive) Result;
+    // pub fn readSupportCompressionGzip(archive: *Archive) Result {
+    //     return archive_read_support_compression_gzip(archive);
+    // }
+    // extern fn archive_read_support_compression_lzip(*Archive) Result;
+    // pub fn readSupportCompressionLzip(archive: *Archive) Result {
+    //     return archive_read_support_compression_lzip(archive);
+    // }
+    // extern fn archive_read_support_compression_lzma(*Archive) Result;
+    // pub fn readSupportCompressionLzma(archive: *Archive) Result {
+    //     return archive_read_support_compression_lzma(archive);
+    // }
+    // extern fn archive_read_support_compression_none(*Archive) Result;
+    // pub fn readSupportCompressionNone(archive: *Archive) Result {
+    //     return archive_read_support_compression_none(archive);
+    // }
+    // extern fn archive_read_support_compression_rpm(*Archive) Result;
+    // pub fn readSupportCompressionRpm(archive: *Archive) Result {
+    //     return archive_read_support_compression_rpm(archive);
+    // }
+    // extern fn archive_read_support_compression_uu(*Archive) Result;
+    // pub fn readSupportCompressionUu(archive: *Archive) Result {
+    //     return archive_read_support_compression_uu(archive);
+    // }
+    // extern fn archive_read_support_compression_xz(*Archive) Result;
+    // pub fn readSupportCompressionXz(archive: *Archive) Result {
+    //     return archive_read_support_compression_xz(archive);
+    // }
+
+    extern fn archive_read_support_format_7zip(*Archive) Result;
+    pub fn readSupportFormat7zip(archive: *Archive) Result {
+        return archive_read_support_format_7zip(archive);
+    }
+    extern fn archive_read_support_format_all(*Archive) Result;
+    pub fn readSupportFormatAll(archive: *Archive) Result {
+        return archive_read_support_format_all(archive);
+    }
+    extern fn archive_read_support_format_ar(*Archive) Result;
+    pub fn readSupportFormatAr(archive: *Archive) Result {
+        return archive_read_support_format_ar(archive);
+    }
+    extern fn archive_read_support_format_by_code(*Archive, c_int) Result;
+    pub fn readSupportFormatByCode(archive: *Archive, code: i32) Result {
+        return archive_read_support_format_by_code(archive, code);
+    }
+    extern fn archive_read_support_format_cab(*Archive) Result;
+    pub fn readSupportFormatCab(archive: *Archive) Result {
+        return archive_read_support_format_cab(archive);
+    }
+    extern fn archive_read_support_format_cpio(*Archive) Result;
+    pub fn readSupportFormatCpio(archive: *Archive) Result {
+        return archive_read_support_format_cpio(archive);
+    }
+    extern fn archive_read_support_format_empty(*Archive) Result;
+    pub fn readSupportFormatEmpty(archive: *Archive) Result {
+        return archive_read_support_format_empty(archive);
+    }
+    extern fn archive_read_support_format_gnutar(*Archive) Result;
+    pub fn readSupportFormatGnutar(archive: *Archive) Result {
+        return archive_read_support_format_gnutar(archive);
+    }
+    extern fn archive_read_support_format_iso9660(*Archive) Result;
+    pub fn readSupportFormatIso9660(archive: *Archive) Result {
+        return archive_read_support_format_iso9660(archive);
+    }
+    extern fn archive_read_support_format_lha(*Archive) Result;
+    pub fn readSupportFormatLha(archive: *Archive) Result {
+        return archive_read_support_format_lha(archive);
+    }
+    extern fn archive_read_support_format_mtree(*Archive) Result;
+    pub fn readSupportFormatMtree(archive: *Archive) Result {
+        return archive_read_support_format_mtree(archive);
+    }
+    extern fn archive_read_support_format_rar(*Archive) Result;
+    pub fn readSupportFormatRar(archive: *Archive) Result {
+        return archive_read_support_format_rar(archive);
+    }
+    extern fn archive_read_support_format_rar5(*Archive) Result;
+    pub fn readSupportFormatRar5(archive: *Archive) Result {
+        return archive_read_support_format_rar5(archive);
+    }
+    extern fn archive_read_support_format_raw(*Archive) Result;
+    pub fn readSupportFormatRaw(archive: *Archive) Result {
+        return archive_read_support_format_raw(archive);
+    }
+    extern fn archive_read_support_format_tar(*Archive) Result;
+    pub fn readSupportFormatTar(archive: *Archive) Result {
+        return archive_read_support_format_tar(archive);
+    }
+    extern fn archive_read_support_format_warc(*Archive) Result;
+    pub fn readSupportFormatWarc(archive: *Archive) Result {
+        return archive_read_support_format_warc(archive);
+    }
+    extern fn archive_read_support_format_xar(*Archive) Result;
+    pub fn readSupportFormatXar(archive: *Archive) Result {
+        return archive_read_support_format_xar(archive);
+    }
+    extern fn archive_read_support_format_zip(*Archive) Result;
+    pub fn readSupportFormatZip(archive: *Archive) Result {
+        return archive_read_support_format_zip(archive);
+    }
+    extern fn archive_read_support_format_zip_streamable(*Archive) Result;
+    pub fn readSupportFormatZipStreamable(archive: *Archive) Result {
+        return archive_read_support_format_zip_streamable(archive);
+    }
+    extern fn archive_read_support_format_zip_seekable(*Archive) Result;
+    pub fn readSupportFormatZipSeekable(archive: *Archive) Result {
+        return archive_read_support_format_zip_seekable(archive);
+    }
+
+    extern fn archive_read_set_options(*Archive, [*c]const u8) Result;
+    pub fn readSetOptions(archive: *Archive, opts: [:0]const u8) Result {
+        return archive_read_set_options(archive, opts.ptr);
+    }
+
+    extern fn archive_read_open_memory(*Archive, ?*const anyopaque, usize) Result;
+    pub fn readOpenMemory(archive: *Archive, buf: []const u8) Result {
+        return archive_read_open_memory(archive, buf.ptr, buf.len);
+    }
+
+    extern fn archive_read_next_header(*Archive, **Entry) Result;
+    pub fn readNextHeader(archive: *Archive, entry: **Entry) Result {
+        return archive_read_next_header(archive, entry);
+    }
+    extern fn archive_read_next_header2(*Archive, *Entry) Result;
+    pub fn readNextHeader2(archive: *Archive, entry: *Entry) Result {
+        return archive_read_next_header2(archive, entry);
+    }
+
+    extern fn archive_read_data(*Archive, ?*anyopaque, usize) isize;
+    pub fn readData(archive: *Archive, buf: []u8) isize {
+        return archive_read_data(archive, buf.ptr, buf.len);
+    }
+    extern fn archive_read_data_into_fd(*Archive, fd: c_int) Result;
+    pub fn readDataIntoFd(archive: *Archive, fd: c_int) Result {
+        return archive_read_data_into_fd(archive, fd);
+    }
+
+    extern fn archive_read_support_filter_all(*Archive) Result;
+    pub fn readSupportFilterAll(archive: *Archive) Result {
+        return archive_read_support_filter_all(archive);
+    }
+    extern fn archive_read_support_filter_by_code(*Archive, c_int) Result;
+    pub fn readSupportFilterByCode(archive: *Archive, code: i32) Result {
+        return archive_read_support_filter_by_code(archive, code);
+    }
+    // extern fn archive_read_support_filter_bzip2(*Archive) Result;
+    // pub fn readSupportFilterbZip2(archive: *Archive) Result {
+    //     return archive_read_support_filter_bzip2(archive);
+    // }
+    extern fn archive_read_support_filter_compress(*Archive) Result;
+    pub fn readSupportFilterCompress(archive: *Archive) Result {
+        return archive_read_support_filter_compress(archive);
+    }
+    extern fn archive_read_support_filter_gzip(*Archive) Result;
+    pub fn readSupportFilterGzip(archive: *Archive) Result {
+        return archive_read_support_filter_gzip(archive);
+    }
+    extern fn archive_read_support_filter_grzip(*Archive) Result;
+    pub fn readSupportFilterGrzip(archive: *Archive) Result {
+        return archive_read_support_filter_grzip(archive);
+    }
+    extern fn archive_read_support_filter_lrzip(*Archive) Result;
+    pub fn readSupportFilterLrzip(archive: *Archive) Result {
+        return archive_read_support_filter_lrzip(archive);
+    }
+    extern fn archive_read_support_filter_lz4(*Archive) Result;
+    pub fn readSupportFilterLz4(archive: *Archive) Result {
+        return archive_read_support_filter_lz4(archive);
+    }
+    extern fn archive_read_support_filter_lzip(*Archive) Result;
+    pub fn readSupportFilterLzip(archive: *Archive) Result {
+        return archive_read_support_filter_lzip(archive);
+    }
+    extern fn archive_read_support_filter_lzma(*Archive) Result;
+    pub fn readSupportFilterLzma(archive: *Archive) Result {
+        return archive_read_support_filter_lzma(archive);
+    }
+    extern fn archive_read_support_filter_lzop(*Archive) Result;
+    pub fn readSupportFilterLzop(archive: *Archive) Result {
+        return archive_read_support_filter_lzop(archive);
+    }
+    extern fn archive_read_support_filter_none(*Archive) Result;
+    pub fn readSupportFilterNone(archive: *Archive) Result {
+        return archive_read_support_filter_none(archive);
+    }
+    extern fn archive_read_support_filter_rpm(*Archive) Result;
+    pub fn readSupportFilterRpm(archive: *Archive) Result {
+        return archive_read_support_filter_rpm(archive);
+    }
+    extern fn archive_read_support_filter_uu(*Archive) Result;
+    pub fn readSupportFilterUu(archive: *Archive) Result {
+        return archive_read_support_filter_uu(archive);
+    }
+    extern fn archive_read_support_filter_xz(*Archive) Result;
+    pub fn readSupportFilterXz(archive: *Archive) Result {
+        return archive_read_support_filter_xz(archive);
+    }
+    extern fn archive_read_support_filter_zstd(*Archive) Result;
+    pub fn readSupportFilterZstd(archive: *Archive) Result {
+        return archive_read_support_filter_zstd(archive);
+    }
+
     pub const Entry = opaque {
         extern fn archive_entry_new() *Entry;
         pub fn new() *Entry {
             return archive_entry_new();
         }
 
-        pub extern fn archive_entry_new2(*Archive) *Entry;
+        extern fn archive_entry_new2(*Archive) *Entry;
         pub fn new2(archive: *Archive) *Entry {
             return archive_entry_new2(archive);
         }
@@ -306,41 +771,41 @@ pub const Archive = opaque {
         }
 
         extern fn archive_entry_set_pathname(*Entry, [*c]const u8) void;
-        pub fn setPathname(entry: *Entry, pathname: [:0]const u8) void {
-            archive_entry_set_pathname(entry, pathname);
+        pub fn setPathname(entry: *Entry, name: [:0]const u8) void {
+            archive_entry_set_pathname(entry, name);
         }
 
         extern fn archive_entry_set_pathname_utf8(*Entry, [*c]const u8) void;
-        pub fn setPathnameUtf8(entry: *Entry, pathname: [:0]const u8) void {
-            archive_entry_set_pathname_utf8(entry, pathname);
+        pub fn setPathnameUtf8(entry: *Entry, name: [:0]const u8) void {
+            archive_entry_set_pathname_utf8(entry, name);
         }
 
         extern fn archive_entry_copy_pathname(*Entry, [*c]const u8) void;
-        pub fn copyPathname(entry: *Entry, pathname: [:0]const u8) void {
-            return archive_entry_copy_pathname(entry, pathname);
+        pub fn copyPathname(entry: *Entry, name: [:0]const u8) void {
+            return archive_entry_copy_pathname(entry, name);
         }
 
-        pub extern fn archive_entry_copy_pathname_w(*Entry, [*c]const u16) void;
-        pub fn copyPathnameW(entry: *Entry, pathname: [:0]const u16) void {
-            return archive_entry_copy_pathname_w(entry, pathname);
+        extern fn archive_entry_copy_pathname_w(*Entry, [*c]const u16) void;
+        pub fn copyPathnameW(entry: *Entry, name: [:0]const u16) void {
+            return archive_entry_copy_pathname_w(entry, name);
         }
 
         extern fn archive_entry_set_size(*Entry, i64) void;
-        pub fn setSize(entry: *Entry, size: i64) void {
-            archive_entry_set_size(entry, size);
+        pub fn setSize(entry: *Entry, s: i64) void {
+            archive_entry_set_size(entry, s);
         }
 
         extern fn archive_entry_set_filetype(*Entry, c_uint) void;
-        pub fn setFiletype(entry: *Entry, filetype: u32) void {
-            archive_entry_set_filetype(entry, filetype);
+        pub fn setFiletype(entry: *Entry, @"type": u32) void {
+            archive_entry_set_filetype(entry, @"type");
         }
 
         extern fn archive_entry_set_perm(*Entry, bun.Mode) void;
-        pub fn setPerm(entry: *Entry, perm: bun.Mode) void {
-            archive_entry_set_perm(entry, perm);
+        pub fn setPerm(entry: *Entry, p: bun.Mode) void {
+            archive_entry_set_perm(entry, p);
         }
 
-        pub extern fn archive_entry_set_mode(*Entry, bun.Mode) void;
+        extern fn archive_entry_set_mode(*Entry, bun.Mode) void;
         pub fn setMode(entry: *Entry, mode: bun.Mode) void {
             archive_entry_set_mode(entry, mode);
         }
@@ -354,6 +819,175 @@ pub const Archive = opaque {
         pub fn clear(entry: *Entry) *Entry {
             return archive_entry_clear(entry);
         }
+
+        extern fn archive_entry_pathname(*Entry) [*c]const u8;
+        pub fn pathname(entry: *Entry) [:0]const u8 {
+            return bun.sliceTo(archive_entry_pathname(entry), 0);
+        }
+        extern fn archive_entry_pathname_utf8(*Entry) [*c]const u8;
+        pub fn pathnameUtf8(entry: *Entry) [:0]const u8 {
+            return bun.sliceTo(archive_entry_pathname_utf8(entry), 0);
+        }
+        extern fn archive_entry_pathname_w(*Entry) [*c]const u16;
+        pub fn pathnameW(entry: *Entry) [:0]const u16 {
+            return bun.sliceTo(archive_entry_pathname_w(entry), 0);
+        }
+        extern fn archive_entry_filetype(*Entry) bun.Mode;
+        pub fn filetype(entry: *Entry) bun.Mode {
+            return archive_entry_filetype(entry);
+        }
+        extern fn archive_entry_perm(*Entry) bun.Mode;
+        pub fn perm(entry: *Entry) bun.Mode {
+            return archive_entry_perm(entry);
+        }
+        extern fn archive_entry_size(*Entry) i64;
+        pub fn size(entry: *Entry) i64 {
+            return archive_entry_size(entry);
+        }
+        extern fn archive_entry_symlink(*Entry) [*c]const u8;
+        pub fn symlink(entry: *Entry) [:0]const u8 {
+            return bun.sliceTo(archive_entry_symlink(entry), 0);
+        }
+        pub extern fn archive_entry_symlink_utf8(*Entry) [*c]const u8;
+        pub fn symlinkUtf8(entry: *Entry) [:0]const u8 {
+            return bun.sliceTo(archive_entry_symlink_utf8(entry), 0);
+        }
+        pub extern fn archive_entry_symlink_type(*Entry) SymlinkType;
+        pub fn symlinkType(entry: *Entry) SymlinkType {
+            return archive_entry_symlink_type(entry);
+        }
+        pub extern fn archive_entry_symlink_w(*Entry) [*c]const u16;
+        pub fn symlinkW(entry: *Entry) [:0]const u16 {
+            return bun.sliceTo(archive_entry_symlink_w(entry), 0);
+        }
+    };
+
+    pub const Iterator = struct {
+        archive: *Archive,
+        filter: std.EnumSet(std.fs.File.Kind),
+
+        fn Result(comptime T: type) type {
+            return union(enum) {
+                err: struct {
+                    archive: *Archive,
+                    message: []const u8,
+                },
+                result: T,
+
+                pub fn err(arch: *Archive, msg: []const u8) @This() {
+                    return .{ .err = .{ .message = msg, .archive = arch } };
+                }
+
+                pub fn res(value: T) @This() {
+                    return .{ .result = value };
+                }
+            };
+        }
+
+        pub fn init(tarball_bytes: []const u8) Iterator.Result(@This()) {
+            const Return = Iterator.Result(@This());
+
+            const archive = Archive.readNew();
+
+            switch (archive.readSupportFormatTar()) {
+                .failed, .fatal, .warn => {
+                    return Return.err(archive, "failed to enable tar format support");
+                },
+                else => {},
+            }
+            switch (archive.readSupportFormatGnutar()) {
+                .failed, .fatal, .warn => {
+                    return Return.err(archive, "failed to enable gnutar format support");
+                },
+                else => {},
+            }
+            switch (archive.readSupportFilterGzip()) {
+                .failed, .fatal, .warn => {
+                    return Return.err(archive, "failed to enable support for gzip compression");
+                },
+                else => {},
+            }
+
+            switch (archive.readSetOptions("read_concatenated_archives")) {
+                .failed, .fatal, .warn => {
+                    return Return.err(archive, "failed to set option `read_concatenated_archives`");
+                },
+                else => {},
+            }
+
+            switch (archive.readOpenMemory(tarball_bytes)) {
+                .failed, .fatal, .warn => {
+                    return Return.err(archive, "failed to read tarball");
+                },
+                else => {},
+            }
+
+            return Return.res(.{
+                .archive = archive,
+                .filter = std.EnumSet(std.fs.File.Kind).initEmpty(),
+            });
+        }
+
+        const NextEntry = struct {
+            entry: *Archive.Entry,
+            kind: std.fs.File.Kind,
+
+            pub fn readEntryData(this: *const @This(), allocator: std.mem.Allocator, archive: *Archive) OOM!Iterator.Result([]const u8) {
+                const Return = Iterator.Result([]const u8);
+                const size = this.entry.size();
+                if (size < 0) return Return.err(archive, "invalid archive entry size");
+
+                const buf = try allocator.alloc(u8, @intCast(size));
+
+                const read = archive.readData(buf);
+                if (read < 0) {
+                    return Return.err(archive, "failed to read archive data");
+                }
+                return Return.res(buf[0..@intCast(read)]);
+            }
+        };
+
+        pub fn next(this: *@This()) Iterator.Result(?NextEntry) {
+            const Return = Iterator.Result(?NextEntry);
+
+            var entry: *Archive.Entry = undefined;
+            while (true) {
+                return switch (this.archive.readNextHeader(&entry)) {
+                    .retry => continue,
+                    .eof => Return.res(null),
+                    .ok => {
+                        const kind = bun.C.kindFromMode(entry.filetype());
+
+                        if (this.filter.contains(kind)) continue;
+
+                        return Return.res(.{
+                            .entry = entry,
+                            .kind = kind,
+                        });
+                    },
+                    else => Return.err(this.archive, "failed to read archive header"),
+                };
+            }
+        }
+
+        pub fn deinit(this: *@This()) Iterator.Result(void) {
+            const Return = Iterator.Result(void);
+
+            switch (this.archive.readClose()) {
+                .failed, .fatal, .warn => {
+                    return Return.err(this.archive, "failed to close archive read");
+                },
+                else => {},
+            }
+            switch (this.archive.readFree()) {
+                .failed, .fatal, .warn => {
+                    return Return.err(this.archive, "failed to free archive read");
+                },
+                else => {},
+            }
+
+            return Return.res({});
+        }
     };
 };
 
@@ -366,57 +1000,10 @@ pub const archive_close_callback = *const fn (*struct_archive, *anyopaque) callc
 pub const archive_free_callback = *const fn (*struct_archive, *anyopaque) callconv(.C) c_int;
 pub const archive_switch_callback = *const fn (*struct_archive, *anyopaque, ?*anyopaque) callconv(.C) c_int;
 pub const archive_passphrase_callback = *const fn (*struct_archive, *anyopaque) callconv(.C) [*c]const u8;
-pub extern fn archive_read_new() *struct_archive;
-pub extern fn archive_read_support_compression_all(*struct_archive) c_int;
-pub extern fn archive_read_support_compression_bzip2(*struct_archive) c_int;
-pub extern fn archive_read_support_compression_compress(*struct_archive) c_int;
-pub extern fn archive_read_support_compression_gzip(*struct_archive) c_int;
-pub extern fn archive_read_support_compression_lzip(*struct_archive) c_int;
-pub extern fn archive_read_support_compression_lzma(*struct_archive) c_int;
-pub extern fn archive_read_support_compression_none(*struct_archive) c_int;
 pub extern fn archive_read_support_compression_program(*struct_archive, command: [*c]const u8) c_int;
 pub extern fn archive_read_support_compression_program_signature(*struct_archive, [*c]const u8, ?*const anyopaque, usize) c_int;
-pub extern fn archive_read_support_compression_rpm(*struct_archive) c_int;
-pub extern fn archive_read_support_compression_uu(*struct_archive) c_int;
-pub extern fn archive_read_support_compression_xz(*struct_archive) c_int;
-pub extern fn archive_read_support_filter_all(*struct_archive) c_int;
-pub extern fn archive_read_support_filter_by_code(*struct_archive, c_int) c_int;
-pub extern fn archive_read_support_filter_bzip2(*struct_archive) c_int;
-pub extern fn archive_read_support_filter_compress(*struct_archive) c_int;
-pub extern fn archive_read_support_filter_gzip(*struct_archive) c_int;
-pub extern fn archive_read_support_filter_grzip(*struct_archive) c_int;
-pub extern fn archive_read_support_filter_lrzip(*struct_archive) c_int;
-pub extern fn archive_read_support_filter_lz4(*struct_archive) c_int;
-pub extern fn archive_read_support_filter_lzip(*struct_archive) c_int;
-pub extern fn archive_read_support_filter_lzma(*struct_archive) c_int;
-pub extern fn archive_read_support_filter_lzop(*struct_archive) c_int;
-pub extern fn archive_read_support_filter_none(*struct_archive) c_int;
 pub extern fn archive_read_support_filter_program(*struct_archive, command: [*c]const u8) c_int;
 pub extern fn archive_read_support_filter_program_signature(*struct_archive, [*c]const u8, ?*const anyopaque, usize) c_int;
-pub extern fn archive_read_support_filter_rpm(*struct_archive) c_int;
-pub extern fn archive_read_support_filter_uu(*struct_archive) c_int;
-pub extern fn archive_read_support_filter_xz(*struct_archive) c_int;
-pub extern fn archive_read_support_filter_zstd(*struct_archive) c_int;
-pub extern fn archive_read_support_format_7zip(*struct_archive) c_int;
-pub extern fn archive_read_support_format_all(*struct_archive) c_int;
-pub extern fn archive_read_support_format_ar(*struct_archive) c_int;
-pub extern fn archive_read_support_format_by_code(*struct_archive, c_int) c_int;
-pub extern fn archive_read_support_format_cab(*struct_archive) c_int;
-pub extern fn archive_read_support_format_cpio(*struct_archive) c_int;
-pub extern fn archive_read_support_format_empty(*struct_archive) c_int;
-pub extern fn archive_read_support_format_gnutar(*struct_archive) c_int;
-pub extern fn archive_read_support_format_iso9660(*struct_archive) c_int;
-pub extern fn archive_read_support_format_lha(*struct_archive) c_int;
-pub extern fn archive_read_support_format_mtree(*struct_archive) c_int;
-pub extern fn archive_read_support_format_rar(*struct_archive) c_int;
-pub extern fn archive_read_support_format_rar5(*struct_archive) c_int;
-pub extern fn archive_read_support_format_raw(*struct_archive) c_int;
-pub extern fn archive_read_support_format_tar(*struct_archive) c_int;
-pub extern fn archive_read_support_format_warc(*struct_archive) c_int;
-pub extern fn archive_read_support_format_xar(*struct_archive) c_int;
-pub extern fn archive_read_support_format_zip(*struct_archive) c_int;
-pub extern fn archive_read_support_format_zip_streamable(*struct_archive) c_int;
-pub extern fn archive_read_support_format_zip_seekable(*struct_archive) c_int;
 pub extern fn archive_read_set_format(*struct_archive, c_int) c_int;
 pub extern fn archive_read_append_filter(*struct_archive, c_int) c_int;
 pub extern fn archive_read_append_filter_program(*struct_archive, [*c]const u8) c_int;
@@ -439,62 +1026,36 @@ pub extern fn archive_read_open_filename(*struct_archive, _filename: [*c]const u
 pub extern fn archive_read_open_filenames(*struct_archive, _filenames: [*c][*c]const u8, _block_size: usize) c_int;
 pub extern fn archive_read_open_filename_w(*struct_archive, _filename: [*c]const wchar_t, _block_size: usize) c_int;
 pub extern fn archive_read_open_file(*struct_archive, _filename: [*c]const u8, _block_size: usize) c_int;
-pub extern fn archive_read_open_memory(*struct_archive, buff: ?*const anyopaque, size: usize) c_int;
 pub extern fn archive_read_open_memory2(a: *struct_archive, buff: ?*const anyopaque, size: usize, read_size: usize) c_int;
 pub extern fn archive_read_open_fd(*struct_archive, _fd: c_int, _block_size: usize) c_int;
 pub extern fn archive_read_open_FILE(*struct_archive, _file: [*c]FILE) c_int;
-pub extern fn archive_read_next_header(*struct_archive, [*c]*struct_archive_entry) c_int;
-pub extern fn archive_read_next_header2(*struct_archive, *struct_archive_entry) c_int;
 pub extern fn archive_read_header_position(*struct_archive) la_int64_t;
 pub extern fn archive_read_has_encrypted_entries(*struct_archive) c_int;
 pub extern fn archive_read_format_capabilities(*struct_archive) c_int;
-pub extern fn archive_read_data(*struct_archive, ?*anyopaque, usize) la_ssize_t;
 pub extern fn archive_seek_data(*struct_archive, la_int64_t, c_int) la_int64_t;
 pub extern fn archive_read_data_block(a: *struct_archive, buff: [*c]*const anyopaque, size: [*c]usize, offset: [*c]la_int64_t) c_int;
 pub extern fn archive_read_data_skip(*struct_archive) c_int;
-pub extern fn archive_read_data_into_fd(*struct_archive, fd: c_int) c_int;
 pub extern fn archive_read_set_format_option(_a: *struct_archive, m: [*c]const u8, o: [*c]const u8, v: [*c]const u8) c_int;
 pub extern fn archive_read_set_filter_option(_a: *struct_archive, m: [*c]const u8, o: [*c]const u8, v: [*c]const u8) c_int;
-pub extern fn archive_read_set_option(_a: *struct_archive, m: [*c]const u8, o: [*c]const u8, v: [*c]const u8) c_int;
-pub extern fn archive_read_set_options(_a: *struct_archive, opts: [*c]const u8) c_int;
 pub extern fn archive_read_add_passphrase(*struct_archive, [*c]const u8) c_int;
 pub extern fn archive_read_set_passphrase_callback(*struct_archive, client_data: ?*anyopaque, ?archive_passphrase_callback) c_int;
 pub extern fn archive_read_extract(*struct_archive, *struct_archive_entry, flags: c_int) c_int;
 pub extern fn archive_read_extract2(*struct_archive, *struct_archive_entry, *struct_archive) c_int;
 pub extern fn archive_read_extract_set_progress_callback(*struct_archive, _progress_func: ?*const fn (?*anyopaque) callconv(.C) void, _user_data: ?*anyopaque) void;
 pub extern fn archive_read_extract_set_skip_file(*struct_archive, la_int64_t, la_int64_t) void;
-pub extern fn archive_read_close(*struct_archive) c_int;
-pub extern fn archive_read_free(*struct_archive) c_int;
-pub extern fn archive_read_finish(*struct_archive) c_int;
 pub extern fn archive_write_set_bytes_per_block(*struct_archive, bytes_per_block: c_int) c_int;
 pub extern fn archive_write_get_bytes_per_block(*struct_archive) c_int;
 pub extern fn archive_write_set_bytes_in_last_block(*struct_archive, bytes_in_last_block: c_int) c_int;
 pub extern fn archive_write_get_bytes_in_last_block(*struct_archive) c_int;
 pub extern fn archive_write_set_skip_file(*struct_archive, la_int64_t, la_int64_t) c_int;
-pub extern fn archive_write_set_compression_bzip2(*struct_archive) c_int;
-pub extern fn archive_write_set_compression_compress(*struct_archive) c_int;
-pub extern fn archive_write_set_compression_lzip(*struct_archive) c_int;
-pub extern fn archive_write_set_compression_lzma(*struct_archive) c_int;
-pub extern fn archive_write_set_compression_none(*struct_archive) c_int;
-pub extern fn archive_write_set_compression_program(*struct_archive, cmd: [*c]const u8) c_int;
-pub extern fn archive_write_set_compression_xz(*struct_archive) c_int;
-pub extern fn archive_write_add_filter(*struct_archive, filter_code: c_int) c_int;
-pub extern fn archive_write_add_filter_by_name(*struct_archive, name: [*c]const u8) c_int;
-pub extern fn archive_write_add_filter_b64encode(*struct_archive) c_int;
-pub extern fn archive_write_add_filter_bzip2(*struct_archive) c_int;
-pub extern fn archive_write_add_filter_compress(*struct_archive) c_int;
-pub extern fn archive_write_add_filter_grzip(*struct_archive) c_int;
-pub extern fn archive_write_add_filter_lrzip(*struct_archive) c_int;
-pub extern fn archive_write_add_filter_lz4(*struct_archive) c_int;
-pub extern fn archive_write_add_filter_lzip(*struct_archive) c_int;
-pub extern fn archive_write_add_filter_lzma(*struct_archive) c_int;
-pub extern fn archive_write_add_filter_lzop(*struct_archive) c_int;
-pub extern fn archive_write_add_filter_none(*struct_archive) c_int;
-pub extern fn archive_write_add_filter_program(*struct_archive, cmd: [*c]const u8) c_int;
-pub extern fn archive_write_add_filter_uuencode(*struct_archive) c_int;
-pub extern fn archive_write_add_filter_xz(*struct_archive) c_int;
-pub extern fn archive_write_add_filter_zstd(*struct_archive) c_int;
-pub extern fn archive_write_set_format(*struct_archive, format_code: c_int) c_int;
+// Deprecated
+// pub extern fn archive_write_set_compression_bzip2(*struct_archive) c_int;
+// pub extern fn archive_write_set_compression_compress(*struct_archive) c_int;
+// pub extern fn archive_write_set_compression_lzip(*struct_archive) c_int;
+// pub extern fn archive_write_set_compression_lzma(*struct_archive) c_int;
+// pub extern fn archive_write_set_compression_none(*struct_archive) c_int;
+// pub extern fn archive_write_set_compression_program(*struct_archive, cmd: [*c]const u8) c_int;
+// pub extern fn archive_write_set_compression_xz(*struct_archive) c_int;
 pub extern fn archive_write_set_format_by_name(*struct_archive, name: [*c]const u8) c_int;
 pub extern fn archive_write_set_format_ar_bsd(*struct_archive) c_int;
 pub extern fn archive_write_set_format_ar_svr4(*struct_archive) c_int;
@@ -616,7 +1177,6 @@ pub extern fn archive_entry_dev(*struct_archive_entry) dev_t;
 pub extern fn archive_entry_dev_is_set(*struct_archive_entry) c_int;
 pub extern fn archive_entry_devmajor(*struct_archive_entry) dev_t;
 pub extern fn archive_entry_devminor(*struct_archive_entry) dev_t;
-pub extern fn archive_entry_filetype(*struct_archive_entry) mode_t;
 pub extern fn archive_entry_fflags(*struct_archive_entry, [*c]u64, [*c]u64) void;
 pub extern fn archive_entry_fflags_text(*struct_archive_entry) [*c]const u8;
 pub extern fn archive_entry_gid(*struct_archive_entry) la_int64_t;
@@ -634,22 +1194,13 @@ pub extern fn archive_entry_mtime(*struct_archive_entry) time_t;
 pub extern fn archive_entry_mtime_nsec(*struct_archive_entry) c_long;
 pub extern fn archive_entry_mtime_is_set(*struct_archive_entry) c_int;
 pub extern fn archive_entry_nlink(*struct_archive_entry) c_uint;
-pub extern fn archive_entry_pathname(*struct_archive_entry) [*c]const u8;
-pub extern fn archive_entry_pathname_utf8(*struct_archive_entry) [*c]const u8;
-pub extern fn archive_entry_pathname_w(*struct_archive_entry) [*c]const wchar_t;
-pub extern fn archive_entry_perm(*struct_archive_entry) mode_t;
 pub extern fn archive_entry_rdev(*struct_archive_entry) dev_t;
 pub extern fn archive_entry_rdevmajor(*struct_archive_entry) dev_t;
 pub extern fn archive_entry_rdevminor(*struct_archive_entry) dev_t;
 pub extern fn archive_entry_sourcepath(*struct_archive_entry) [*c]const u8;
 pub extern fn archive_entry_sourcepath_w(*struct_archive_entry) [*c]const wchar_t;
-pub extern fn archive_entry_size(*struct_archive_entry) la_int64_t;
 pub extern fn archive_entry_size_is_set(*struct_archive_entry) c_int;
 pub extern fn archive_entry_strmode(*struct_archive_entry) [*c]const u8;
-pub extern fn archive_entry_symlink(*struct_archive_entry) [*c]const u8;
-pub extern fn archive_entry_symlink_utf8(*struct_archive_entry) [*c]const u8;
-pub extern fn archive_entry_symlink_type(*struct_archive_entry) SymlinkType;
-pub extern fn archive_entry_symlink_w(*struct_archive_entry) [*c]const wchar_t;
 pub extern fn archive_entry_uid(*struct_archive_entry) la_int64_t;
 pub extern fn archive_entry_uname(*struct_archive_entry) [*c]const u8;
 pub extern fn archive_entry_uname_utf8(*struct_archive_entry) [*c]const u8;
diff --git a/src/libarchive/libarchive.zig b/src/libarchive/libarchive.zig
index 5443964f95..09f5c49554 100644
--- a/src/libarchive/libarchive.zig
+++ b/src/libarchive/libarchive.zig
@@ -13,7 +13,7 @@ const stringZ = bun.stringZ;
 const default_allocator = bun.default_allocator;
 const C = bun.C;
 const std = @import("std");
-const struct_archive = lib.struct_archive;
+const Archive = lib.Archive;
 const JSC = bun.JSC;
 pub const Seek = enum(c_int) {
     set = std.posix.SEEK_SET,
@@ -21,168 +21,6 @@ pub const Seek = enum(c_int) {
     end = std.posix.SEEK_END,
 };
 
-pub const Flags = struct {
-    pub const Extract = enum(c_int) {
-        owner = lib.ARCHIVE_EXTRACT_OWNER,
-        perm = lib.ARCHIVE_EXTRACT_PERM,
-        time = lib.ARCHIVE_EXTRACT_TIME,
-        no_overwrite = lib.ARCHIVE_EXTRACT_NO_OVERWRITE,
-        unlink = lib.ARCHIVE_EXTRACT_UNLINK,
-        acl = lib.ARCHIVE_EXTRACT_ACL,
-        fflags = lib.ARCHIVE_EXTRACT_FFLAGS,
-        xattr = lib.ARCHIVE_EXTRACT_XATTR,
-        secure_symlinks = lib.ARCHIVE_EXTRACT_SECURE_SYMLINKS,
-        secure_nodotdot = lib.ARCHIVE_EXTRACT_SECURE_NODOTDOT,
-        no_autodir = lib.ARCHIVE_EXTRACT_NO_AUTODIR,
-        no_overwrite_newer = lib.ARCHIVE_EXTRACT_NO_OVERWRITE_NEWER,
-        sparse = lib.ARCHIVE_EXTRACT_SPARSE,
-        mac_metadata = lib.ARCHIVE_EXTRACT_MAC_METADATA,
-        no_hfs_compression = lib.ARCHIVE_EXTRACT_NO_HFS_COMPRESSION,
-        hfs_compression_forced = lib.ARCHIVE_EXTRACT_HFS_COMPRESSION_FORCED,
-        secure_noabsolutepaths = lib.ARCHIVE_EXTRACT_SECURE_NOABSOLUTEPATHS,
-        clear_nochange_fflags = lib.ARCHIVE_EXTRACT_CLEAR_NOCHANGE_FFLAGS,
-        safe_writes = lib.ARCHIVE_EXTRACT_SAFE_WRITES,
-    };
-
-    pub const Compression = enum(c_int) {
-        none = lib.ARCHIVE_COMPRESSION_NONE,
-        gzip = lib.ARCHIVE_COMPRESSION_GZIP,
-        bzip2 = lib.ARCHIVE_COMPRESSION_BZIP2,
-        compress = lib.ARCHIVE_COMPRESSION_COMPRESS,
-        program = lib.ARCHIVE_COMPRESSION_PROGRAM,
-        lzma = lib.ARCHIVE_COMPRESSION_LZMA,
-        xz = lib.ARCHIVE_COMPRESSION_XZ,
-        uu = lib.ARCHIVE_COMPRESSION_UU,
-        rpm = lib.ARCHIVE_COMPRESSION_RPM,
-        lzip = lib.ARCHIVE_COMPRESSION_LZIP,
-        lrzip = lib.ARCHIVE_COMPRESSION_LRZIP,
-    };
-
-    pub const Format = enum(c_int) {
-        base_mask = lib.ARCHIVE_FORMAT_BASE_MASK,
-        cpio = lib.ARCHIVE_FORMAT_CPIO,
-        cpio_posix = lib.ARCHIVE_FORMAT_CPIO_POSIX,
-        cpio_bin_le = lib.ARCHIVE_FORMAT_CPIO_BIN_LE,
-        cpio_bin_be = lib.ARCHIVE_FORMAT_CPIO_BIN_BE,
-        cpio_svr4_nocrc = lib.ARCHIVE_FORMAT_CPIO_SVR4_NOCRC,
-        cpio_svr4_crc = lib.ARCHIVE_FORMAT_CPIO_SVR4_CRC,
-        cpio_afio_large = lib.ARCHIVE_FORMAT_CPIO_AFIO_LARGE,
-        cpio_pwb = lib.ARCHIVE_FORMAT_CPIO_PWB,
-        shar = lib.ARCHIVE_FORMAT_SHAR,
-        shar_base = lib.ARCHIVE_FORMAT_SHAR_BASE,
-        shar_dump = lib.ARCHIVE_FORMAT_SHAR_DUMP,
-        tar = lib.ARCHIVE_FORMAT_TAR,
-        tar_ustar = lib.ARCHIVE_FORMAT_TAR_USTAR,
-        tar_pax_interchange = lib.ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE,
-        tar_pax_restricted = lib.ARCHIVE_FORMAT_TAR_PAX_RESTRICTED,
-        tar_gnutar = lib.ARCHIVE_FORMAT_TAR_GNUTAR,
-        iso9660 = lib.ARCHIVE_FORMAT_ISO9660,
-        iso9660_rockridge = lib.ARCHIVE_FORMAT_ISO9660_ROCKRIDGE,
-        zip = lib.ARCHIVE_FORMAT_ZIP,
-        empty = lib.ARCHIVE_FORMAT_EMPTY,
-        ar = lib.ARCHIVE_FORMAT_AR,
-        ar_gnu = lib.ARCHIVE_FORMAT_AR_GNU,
-        ar_bsd = lib.ARCHIVE_FORMAT_AR_BSD,
-        mtree = lib.ARCHIVE_FORMAT_MTREE,
-        raw = lib.ARCHIVE_FORMAT_RAW,
-        xar = lib.ARCHIVE_FORMAT_XAR,
-        lha = lib.ARCHIVE_FORMAT_LHA,
-        cab = lib.ARCHIVE_FORMAT_CAB,
-        rar = lib.ARCHIVE_FORMAT_RAR,
-        @"7zip" = lib.ARCHIVE_FORMAT_7ZIP,
-        warc = lib.ARCHIVE_FORMAT_WARC,
-        rar_v5 = lib.ARCHIVE_FORMAT_RAR_V5,
-    };
-
-    pub const Filter = enum(c_int) {
-        none = lib.ARCHIVE_FILTER_NONE,
-        gzip = lib.ARCHIVE_FILTER_GZIP,
-        bzip2 = lib.ARCHIVE_FILTER_BZIP2,
-        compress = lib.ARCHIVE_FILTER_COMPRESS,
-        program = lib.ARCHIVE_FILTER_PROGRAM,
-        lzma = lib.ARCHIVE_FILTER_LZMA,
-        xz = lib.ARCHIVE_FILTER_XZ,
-        uu = lib.ARCHIVE_FILTER_UU,
-        rpm = lib.ARCHIVE_FILTER_RPM,
-        lzip = lib.ARCHIVE_FILTER_LZIP,
-        lrzip = lib.ARCHIVE_FILTER_LRZIP,
-        lzop = lib.ARCHIVE_FILTER_LZOP,
-        grzip = lib.ARCHIVE_FILTER_GRZIP,
-        lz4 = lib.ARCHIVE_FILTER_LZ4,
-        zstd = lib.ARCHIVE_FILTER_ZSTD,
-    };
-
-    pub const EntryDigest = enum(c_int) {
-        md5 = lib.ARCHIVE_ENTRY_DIGEST_MD5,
-        rmd160 = lib.ARCHIVE_ENTRY_DIGEST_RMD160,
-        sha1 = lib.ARCHIVE_ENTRY_DIGEST_SHA1,
-        sha256 = lib.ARCHIVE_ENTRY_DIGEST_SHA256,
-        sha384 = lib.ARCHIVE_ENTRY_DIGEST_SHA384,
-        sha512 = lib.ARCHIVE_ENTRY_DIGEST_SHA512,
-    };
-
-    pub const EntryACL = enum(c_int) {
-        entry_acl_execute = lib.ARCHIVE_ENTRY_ACL_EXECUTE,
-        write = lib.ARCHIVE_ENTRY_ACL_WRITE,
-        read = lib.ARCHIVE_ENTRY_ACL_READ,
-        read_data = lib.ARCHIVE_ENTRY_ACL_READ_DATA,
-        list_directory = lib.ARCHIVE_ENTRY_ACL_LIST_DIRECTORY,
-        write_data = lib.ARCHIVE_ENTRY_ACL_WRITE_DATA,
-        add_file = lib.ARCHIVE_ENTRY_ACL_ADD_FILE,
-        append_data = lib.ARCHIVE_ENTRY_ACL_APPEND_DATA,
-        add_subdirectory = lib.ARCHIVE_ENTRY_ACL_ADD_SUBDIRECTORY,
-        read_named_attrs = lib.ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS,
-        write_named_attrs = lib.ARCHIVE_ENTRY_ACL_WRITE_NAMED_ATTRS,
-        delete_child = lib.ARCHIVE_ENTRY_ACL_DELETE_CHILD,
-        read_attributes = lib.ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES,
-        write_attributes = lib.ARCHIVE_ENTRY_ACL_WRITE_ATTRIBUTES,
-        delete = lib.ARCHIVE_ENTRY_ACL_DELETE,
-        read_acl = lib.ARCHIVE_ENTRY_ACL_READ_ACL,
-        write_acl = lib.ARCHIVE_ENTRY_ACL_WRITE_ACL,
-        write_owner = lib.ARCHIVE_ENTRY_ACL_WRITE_OWNER,
-        synchronize = lib.ARCHIVE_ENTRY_ACL_SYNCHRONIZE,
-        perms_posix1_e = lib.ARCHIVE_ENTRY_ACL_PERMS_POSIX1E,
-        perms_nfs4 = lib.ARCHIVE_ENTRY_ACL_PERMS_NFS4,
-        entry_inherited = lib.ARCHIVE_ENTRY_ACL_ENTRY_INHERITED,
-        entry_file_inherit = lib.ARCHIVE_ENTRY_ACL_ENTRY_FILE_INHERIT,
-        entry_directory_inherit = lib.ARCHIVE_ENTRY_ACL_ENTRY_DIRECTORY_INHERIT,
-        entry_no_propagate_inherit = lib.ARCHIVE_ENTRY_ACL_ENTRY_NO_PROPAGATE_INHERIT,
-        entry_inherit_only = lib.ARCHIVE_ENTRY_ACL_ENTRY_INHERIT_ONLY,
-        entry_successful_access = lib.ARCHIVE_ENTRY_ACL_ENTRY_SUCCESSFUL_ACCESS,
-        entry_failed_access = lib.ARCHIVE_ENTRY_ACL_ENTRY_FAILED_ACCESS,
-        inheritance_nfs4 = lib.ARCHIVE_ENTRY_ACL_INHERITANCE_NFS4,
-        type_access = lib.ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
-        type_default = lib.ARCHIVE_ENTRY_ACL_TYPE_DEFAULT,
-        type_allow = lib.ARCHIVE_ENTRY_ACL_TYPE_ALLOW,
-        type_deny = lib.ARCHIVE_ENTRY_ACL_TYPE_DENY,
-        type_audit = lib.ARCHIVE_ENTRY_ACL_TYPE_AUDIT,
-        type_alarm = lib.ARCHIVE_ENTRY_ACL_TYPE_ALARM,
-        type_posix1_e = lib.ARCHIVE_ENTRY_ACL_TYPE_POSIX1E,
-        type_nfs4 = lib.ARCHIVE_ENTRY_ACL_TYPE_NFS4,
-        user = lib.ARCHIVE_ENTRY_ACL_USER,
-        user_obj = lib.ARCHIVE_ENTRY_ACL_USER_OBJ,
-        group = lib.ARCHIVE_ENTRY_ACL_GROUP,
-        group_obj = lib.ARCHIVE_ENTRY_ACL_GROUP_OBJ,
-        mask = lib.ARCHIVE_ENTRY_ACL_MASK,
-        other = lib.ARCHIVE_ENTRY_ACL_OTHER,
-        everyone = lib.ARCHIVE_ENTRY_ACL_EVERYONE,
-        style_extra_id = lib.ARCHIVE_ENTRY_ACL_STYLE_EXTRA_ID,
-        style_mark_default = lib.ARCHIVE_ENTRY_ACL_STYLE_MARK_DEFAULT,
-        style_solaris = lib.ARCHIVE_ENTRY_ACL_STYLE_SOLARIS,
-        style_separator_comma = lib.ARCHIVE_ENTRY_ACL_STYLE_SEPARATOR_COMMA,
-        style_compact = lib.ARCHIVE_ENTRY_ACL_STYLE_COMPACT,
-    };
-};
-
-pub const Status = enum(c_int) {
-    eof = lib.ARCHIVE_EOF,
-    ok = lib.ARCHIVE_OK,
-    retry = lib.ARCHIVE_RETRY,
-    warn = lib.ARCHIVE_WARN,
-    failed = lib.ARCHIVE_FAILED,
-    fatal = lib.ARCHIVE_FATAL,
-};
-
 pub const BufferReadStream = struct {
     const Stream = @This();
     buf: []const u8,
@@ -190,27 +28,27 @@ pub const BufferReadStream = struct {
 
     block_size: usize = 16384,
 
-    archive: *struct_archive,
+    archive: *Archive,
     reading: bool = false,
 
     pub fn init(this: *BufferReadStream, buf: []const u8) void {
         this.* = BufferReadStream{
             .buf = buf,
             .pos = 0,
-            .archive = lib.archive_read_new(),
+            .archive = Archive.readNew(),
             .reading = false,
         };
     }
 
     pub fn deinit(this: *BufferReadStream) void {
-        _ = lib.archive_read_close(this.archive);
+        _ = this.archive.readClose();
         // don't free it if we never actually read it
         // if (this.reading) {
         //     _ = lib.archive_read_free(this.archive);
         // }
     }
 
-    pub fn openRead(this: *BufferReadStream) c_int {
+    pub fn openRead(this: *BufferReadStream) Archive.Result {
         // lib.archive_read_set_open_callback(this.archive, this.);
         // _ = lib.archive_read_set_read_callback(this.archive, archive_read_callback);
         // _ = lib.archive_read_set_seek_callback(this.archive, archive_seek_callback);
@@ -219,21 +57,21 @@ pub const BufferReadStream = struct {
         // // lib.archive_read_set_switch_callback(this.archive, this.archive_s);
         // _ = lib.archive_read_set_callback_data(this.archive, this);
 
-        _ = lib.archive_read_support_format_tar(this.archive);
-        _ = lib.archive_read_support_format_gnutar(this.archive);
-        _ = lib.archive_read_support_compression_gzip(this.archive);
+        _ = this.archive.readSupportFormatTar();
+        _ = this.archive.readSupportFormatGnutar();
+        _ = this.archive.readSupportFilterGzip();
 
         // Ignore zeroed blocks in the archive, which occurs when multiple tar archives
         // have been concatenated together.
         // Without this option, only the contents of
         // the first concatenated archive would be read.
-        _ = lib.archive_read_set_options(this.archive, "read_concatenated_archives");
+        _ = this.archive.readSetOptions("read_concatenated_archives");
 
         // _ = lib.archive_read_support_filter_none(this.archive);
 
-        const rc = lib.archive_read_open_memory(this.archive, this.buf.ptr, this.buf.len);
+        const rc = this.archive.readOpenMemory(this.buf);
 
-        this.reading = rc > -1;
+        this.reading = @intFromEnum(rc) > -1;
 
         // _ = lib.archive_read_support_compression_all(this.archive);
 
@@ -249,14 +87,14 @@ pub const BufferReadStream = struct {
     }
 
     pub fn archive_close_callback(
-        _: *struct_archive,
+        _: *Archive,
         _: *anyopaque,
     ) callconv(.C) c_int {
         return 0;
     }
 
     pub fn archive_read_callback(
-        _: *struct_archive,
+        _: *Archive,
         ctx_: *anyopaque,
         buffer: [*c]*const anyopaque,
     ) callconv(.C) lib.la_ssize_t {
@@ -271,7 +109,7 @@ pub const BufferReadStream = struct {
     }
 
     pub fn archive_skip_callback(
-        _: *struct_archive,
+        _: *Archive,
         ctx_: *anyopaque,
         offset: lib.la_int64_t,
     ) callconv(.C) lib.la_int64_t {
@@ -287,7 +125,7 @@ pub const BufferReadStream = struct {
     }
 
     pub fn archive_seek_callback(
-        _: *struct_archive,
+        _: *Archive,
         ctx_: *anyopaque,
         offset: lib.la_int64_t,
         whence: c_int,
@@ -317,7 +155,7 @@ pub const BufferReadStream = struct {
     }
 
     // pub fn archive_write_callback(
-    //     archive: *struct_archive,
+    //     archive: *Archive,
     //     ctx_: *anyopaque,
     //     buffer: *const anyopaque,
     //     len: usize,
@@ -326,20 +164,20 @@ pub const BufferReadStream = struct {
     // }
 
     // pub fn archive_close_callback(
-    //     archive: *struct_archive,
+    //     archive: *Archive,
     //     ctx_: *anyopaque,
     // ) callconv(.C) c_int {
     //     var this = fromCtx(ctx_);
     // }
     // pub fn archive_free_callback(
-    //     archive: *struct_archive,
+    //     archive: *Archive,
     //     ctx_: *anyopaque,
     // ) callconv(.C) c_int {
     //     var this = fromCtx(ctx_);
     // }
 
     // pub fn archive_switch_callback(
-    //     archive: *struct_archive,
+    //     archive: *Archive,
     //     ctx1: *anyopaque,
     //     ctx2: *anyopaque,
     // ) callconv(.C) c_int {
@@ -350,7 +188,7 @@ pub const BufferReadStream = struct {
 
 const Kind = std.fs.File.Kind;
 
-pub const Archive = struct {
+pub const Archiver = struct {
     // impl: *lib.archive = undefined,
     // buf: []const u8 = undefined,
     // dir: FileDescriptorType = 0,
@@ -389,12 +227,12 @@ pub const Archive = struct {
     pub fn getOverwritingFileList(
         file_buffer: []const u8,
         root: []const u8,
-        ctx: *Archive.Context,
+        ctx: *Archiver.Context,
         comptime FilePathAppender: type,
         appender: FilePathAppender,
         comptime depth_to_skip: usize,
     ) !void {
-        var entry: *lib.archive_entry = undefined;
+        var entry: *Archive.Entry = undefined;
 
         var stream: BufferReadStream = undefined;
         stream.init(file_buffer);
@@ -413,17 +251,17 @@ pub const Archive = struct {
         };
 
         loop: while (true) {
-            const r = @as(Status, @enumFromInt(lib.archive_read_next_header(archive, &entry)));
+            const r = archive.readNextHeader(&entry);
 
             switch (r) {
-                Status.eof => break :loop,
-                Status.retry => continue :loop,
-                Status.failed, Status.fatal => return error.Fail,
+                .eof => break :loop,
+                .retry => continue :loop,
+                .failed, .fatal => return error.Fail,
                 else => {
                     // do not use the utf8 name there
                     // it will require us to pull in libiconv
                     // though we should probably validate the utf8 here nonetheless
-                    var pathname: [:0]const u8 = std.mem.sliceTo(lib.archive_entry_pathname(entry).?, 0);
+                    var pathname = entry.pathname();
                     var tokenizer = std.mem.tokenize(u8, bun.asByteSlice(pathname), std.fs.path.sep_str);
                     comptime var depth_i: usize = 0;
                     inline while (depth_i < depth_to_skip) : (depth_i += 1) {
@@ -434,7 +272,7 @@ pub const Archive = struct {
                     pathname = std.mem.sliceTo(pathname_.ptr[0..pathname_.len :0], 0);
                     const dirname = std.mem.trim(u8, std.fs.path.dirname(bun.asByteSlice(pathname)) orelse "", std.fs.path.sep_str);
 
-                    const size = @as(usize, @intCast(@max(lib.archive_entry_size(entry), 0)));
+                    const size: usize = @intCast(@max(entry.size(), 0));
                     if (size > 0) {
                         var opened = dir.openFileZ(pathname, .{ .mode = .write_only }) catch continue :loop;
                         defer opened.close();
@@ -479,12 +317,12 @@ pub const Archive = struct {
     pub fn extractToDir(
         file_buffer: []const u8,
         dir: std.fs.Dir,
-        ctx: ?*Archive.Context,
+        ctx: ?*Archiver.Context,
         comptime ContextType: type,
         appender: ContextType,
         options: ExtractOptions,
     ) !u32 {
-        var entry: *lib.archive_entry = undefined;
+        var entry: *Archive.Entry = undefined;
 
         var stream: BufferReadStream = undefined;
         stream.init(file_buffer);
@@ -497,12 +335,12 @@ pub const Archive = struct {
         var normalized_buf: bun.OSPathBuffer = undefined;
 
         loop: while (true) {
-            const r: Status = @enumFromInt(lib.archive_read_next_header(archive, &entry));
+            const r = archive.readNextHeader(&entry);
 
             switch (r) {
-                Status.eof => break :loop,
-                Status.retry => continue :loop,
-                Status.failed, Status.fatal => return error.Fail,
+                .eof => break :loop,
+                .retry => continue :loop,
+                .failed, .fatal => return error.Fail,
                 else => {
                     // TODO:
                     // Due to path separator replacement and other copies that happen internally, libarchive changes the
@@ -513,9 +351,9 @@ pub const Archive = struct {
                     // Ideally, we find a way to tell libarchive to not convert the strings to wide characters and also to not
                     // replace path separators. We can do both of these with our own normalization and utf8/utf16 string conversion code.
                     var pathname: bun.OSPathSliceZ = if (comptime Environment.isWindows)
-                        std.mem.sliceTo(lib.archive_entry_pathname_w(entry), 0)
+                        entry.pathnameW()
                     else
-                        std.mem.sliceTo(lib.archive_entry_pathname(entry), 0);
+                        entry.pathname();
 
                     if (comptime ContextType != void and @hasDecl(std.meta.Child(ContextType), "onFirstDirectoryName")) {
                         if (appender.needs_first_dirname) {
@@ -531,7 +369,7 @@ pub const Archive = struct {
                         }
                     }
 
-                    const kind = C.kindFromMode(lib.archive_entry_filetype(entry));
+                    const kind = C.kindFromMode(entry.filetype());
 
                     if (options.npm) {
                         // - ignore entries other than files (`true` can only be returned if type is file)
@@ -584,8 +422,8 @@ pub const Archive = struct {
                     count += 1;
 
                     switch (kind) {
-                        Kind.directory => {
-                            var mode = @as(i32, @intCast(lib.archive_entry_perm(entry)));
+                        .directory => {
+                            var mode = @as(i32, @intCast(entry.perm()));
 
                             // if dirs are readable, then they should be listable
                             // https://github.com/npm/node-tar/blob/main/lib/mode-fix.js
@@ -609,24 +447,28 @@ pub const Archive = struct {
                                 };
                             }
                         },
-                        Kind.sym_link => {
-                            const link_target = lib.archive_entry_symlink(entry).?;
+                        .sym_link => {
+                            const link_target = entry.symlink();
                             if (Environment.isPosix) {
-                                std.posix.symlinkatZ(link_target, dir_fd, path) catch |err| brk: {
+                                bun.sys.symlinkat(link_target, bun.toFD(dir_fd), path).unwrap() catch |err| brk: {
                                     switch (err) {
-                                        error.AccessDenied, error.FileNotFound => {
+                                        error.EPERM, error.ENOENT => {
                                             dir.makePath(std.fs.path.dirname(path_slice) orelse return err) catch {};
-                                            break :brk try std.posix.symlinkatZ(link_target, dir_fd, path);
-                                        },
-                                        else => {
-                                            return err;
+                                            break :brk try bun.sys.symlinkat(link_target, bun.toFD(dir_fd), path).unwrap();
                                         },
+                                        else => return err,
                                     }
                                 };
                             }
                         },
-                        Kind.file => {
-                            const mode: bun.Mode = if (comptime Environment.isWindows) 0 else @intCast(lib.archive_entry_perm(entry));
+                        .file => {
+                            // first https://github.com/npm/cli/blob/feb54f7e9a39bd52519221bae4fafc8bc70f235e/node_modules/pacote/lib/fetcher.js#L65-L66
+                            // this.fmode = opts.fmode || 0o666
+                            //
+                            // then https://github.com/npm/cli/blob/feb54f7e9a39bd52519221bae4fafc8bc70f235e/node_modules/pacote/lib/fetcher.js#L402-L411
+                            //
+                            // we simplify and turn it into `entry.mode || 0o666` because we aren't accepting a umask or fmask option.
+                            const mode: bun.Mode = if (comptime Environment.isWindows) 0 else @intCast(entry.perm() | 0o666);
 
                             const file_handle_native = brk: {
                                 if (Environment.isWindows) {
@@ -683,8 +525,7 @@ pub const Archive = struct {
                                 _ = bun.sys.close(file_handle);
                             };
 
-                            const entry_size = @max(lib.archive_entry_size(entry), 0);
-                            const size = @as(usize, @intCast(entry_size));
+                            const size: usize = @intCast(@max(entry.size(), 0));
                             if (size > 0) {
                                 if (ctx) |ctx_| {
                                     const hash: u64 = if (ctx_.pluckers.len > 0)
@@ -703,7 +544,7 @@ pub const Archive = struct {
                                         if (plucker_.filename_hash == hash) {
                                             try plucker_.contents.inflate(size);
                                             plucker_.contents.list.expandToCapacity();
-                                            const read = lib.archive_read_data(archive, plucker_.contents.list.items.ptr, size);
+                                            const read = archive.readData(plucker_.contents.list.items);
                                             try plucker_.contents.inflate(@as(usize, @intCast(read)));
                                             plucker_.found = read > 0;
                                             plucker_.fd = file_handle;
@@ -713,23 +554,23 @@ pub const Archive = struct {
                                     }
                                 }
                                 // archive_read_data_into_fd reads in chunks of 1 MB
-                                // #define	MAX_WRITE	(1024 * 1024)
+                                // #define    MAX_WRITE    (1024 * 1024)
                                 if (comptime Environment.isLinux) {
                                     if (size > 1_000_000) {
                                         C.preallocate_file(
                                             file_handle.cast(),
                                             0,
-                                            entry_size,
+                                            @intCast(size),
                                         ) catch {};
                                     }
                                 }
 
                                 var retries_remaining: u8 = 5;
                                 possibly_retry: while (retries_remaining != 0) : (retries_remaining -= 1) {
-                                    switch (lib.archive_read_data_into_fd(archive, bun.uvfdcast(file_handle))) {
-                                        lib.ARCHIVE_EOF => break :loop,
-                                        lib.ARCHIVE_OK => break :possibly_retry,
-                                        lib.ARCHIVE_RETRY => {
+                                    switch (archive.readDataIntoFd(bun.uvfdcast(file_handle))) {
+                                        .eof => break :loop,
+                                        .ok => break :possibly_retry,
+                                        .retry => {
                                             if (options.log) {
                                                 Output.err("libarchive error", "extracting {}, retry {d} / {d}", .{
                                                     bun.fmt.fmtOSPath(path_slice, .{}),
@@ -764,7 +605,7 @@ pub const Archive = struct {
     pub fn extractToDisk(
         file_buffer: []const u8,
         root: []const u8,
-        ctx: ?*Archive.Context,
+        ctx: ?*Archiver.Context,
         comptime FilePathAppender: type,
         appender: FilePathAppender,
         comptime options: ExtractOptions,
diff --git a/src/linker.lds b/src/linker.lds
index 6914b11cd4..56fafdd2c0 100644
--- a/src/linker.lds
+++ b/src/linker.lds
@@ -10,7 +10,6 @@ BUN_1.1 {
 	extern "C++" {
 		v8::*;
 		node::*;
-		JSC::CallFrame::describeFrame;
 	};
     local:
 	*;
diff --git a/src/linker.zig b/src/linker.zig
index 074ab79dfb..f0136706d5 100644
--- a/src/linker.zig
+++ b/src/linker.zig
@@ -63,8 +63,6 @@ pub const Linker = struct {
 
     plugin_runner: ?*PluginRunner = null,
 
-    onImportCSS: ?OnImportCallback = null,
-
     pub const runtime_source_path = "bun:wrap";
 
     pub const TaggedResolution = struct {
@@ -291,7 +289,7 @@ pub const Linker = struct {
 
                     if (linker.plugin_runner) |runner| {
                         if (PluginRunner.couldBePlugin(import_record.path.text)) {
-                            if (runner.onResolve(
+                            if (try runner.onResolve(
                                 import_record.path.text,
                                 file_path.text,
                                 linker.log,
@@ -599,7 +597,7 @@ pub const Linker = struct {
             else => {},
         }
         if (had_resolve_errors) return error.ResolveMessage;
-        result.ast.externals = try externals.toOwnedSlice();
+        externals.clearAndFree();
     }
 
     fn whenModuleNotFound(
@@ -621,7 +619,7 @@ pub const Linker = struct {
         }
 
         if (import_record.path.text.len > 0 and Resolver.isPackagePath(import_record.path.text)) {
-            if (linker.options.target.isWebLike() and Options.ExternalModules.isNodeBuiltin(import_record.path.text)) {
+            if (linker.options.target == .browser and Options.ExternalModules.isNodeBuiltin(import_record.path.text)) {
                 try linker.log.addResolveError(
                     &result.source,
                     import_record.range,
@@ -746,25 +744,12 @@ pub const Linker = struct {
                     if (use_hashed_name) {
                         const basepath = Fs.Path.init(source_path);
 
-                        if (linker.options.serve) {
-                            var hash_buf: [64]u8 = undefined;
-                            const modkey = try linker.getModKey(basepath, null);
-                            return Fs.Path.init(try origin.joinAlloc(
-                                linker.allocator,
-                                std.fmt.bufPrint(&hash_buf, "hash:{any}/", .{bun.fmt.hexIntLower(modkey.hash())}) catch unreachable,
-                                dirname,
-                                basename,
-                                absolute_pathname.ext,
-                                source_path,
-                            ));
-                        }
-
                         basename = try linker.getHashedFilename(basepath, null);
                     }
 
                     return Fs.Path.init(try origin.joinAlloc(
                         linker.allocator,
-                        linker.options.routes.asset_prefix_path,
+                        "",
                         dirname,
                         basename,
                         absolute_pathname.ext,
@@ -792,7 +777,7 @@ pub const Linker = struct {
 
         import_record.path = try linker.generateImportPath(
             source_dir,
-            if (path.is_symlink and import_path_format == .absolute_url and linker.options.target.isNotBun()) path.pretty else path.text,
+            if (path.is_symlink and import_path_format == .absolute_url and !linker.options.target.isBun()) path.pretty else path.text,
             loader == .file or loader == .wasm,
             path.namespace,
             origin,
@@ -804,9 +789,6 @@ pub const Linker = struct {
                 if (!linker.options.target.isBun())
                     _ = try linker.enqueueResolveResult(resolve_result);
 
-                if (linker.onImportCSS) |callback| {
-                    callback(resolve_result, import_record, origin);
-                }
                 // This saves us a less reliable string check
                 import_record.print_mode = .css;
             },
@@ -820,7 +802,7 @@ pub const Linker = struct {
                 // if we're building for bun
                 // it's more complicated
                 // loader plugins could be executed between when this is called and the import is evaluated
-                // but we want to preserve the semantics of "file" returning import paths for compatibiltiy with frontend frameworkss
+                // but we want to preserve the semantics of "file" returning import paths for compatibility with frontend frameworkss
                 if (!linker.options.target.isBun()) {
                     import_record.print_mode = .import_path;
                 }
diff --git a/src/linux_c.zig b/src/linux_c.zig
index 64b46ea178..32292c6426 100644
--- a/src/linux_c.zig
+++ b/src/linux_c.zig
@@ -771,3 +771,17 @@ pub extern "C" fn memrchr(ptr: [*]const u8, val: c_int, len: usize) ?[*]const u8
 pub const netdb = @cImport({
     @cInclude("netdb.h");
 });
+
+export fn sys_epoll_pwait2(epfd: i32, events: ?[*]std.os.linux.epoll_event, maxevents: i32, timeout: ?*const std.os.linux.timespec, sigmask: ?*const std.os.linux.sigset_t) isize {
+    return @bitCast(
+        std.os.linux.syscall6(
+            .epoll_pwait2,
+            @bitCast(@as(isize, @intCast(epfd))),
+            @intFromPtr(events),
+            @bitCast(@as(isize, @intCast(maxevents))),
+            @intFromPtr(timeout),
+            @intFromPtr(sigmask),
+            8,
+        ),
+    );
+}
diff --git a/src/lock.zig b/src/lock.zig
index 43e9763bb3..4334986ade 100644
--- a/src/lock.zig
+++ b/src/lock.zig
@@ -1,3 +1,6 @@
+// Note(2024-10-01): there is little reason to use this over std.Thread.Mutex,
+// as we have dropped old macOS versions it didnt support. Additionally, the
+// Zig Standard Library has deadlock protections in debug builds.
 const std = @import("std");
 const Atomic = std.atomic.Value;
 const Futex = @import("./futex.zig");
diff --git a/src/logger.zig b/src/logger.zig
index 0824f0e6a1..516dd70ed8 100644
--- a/src/logger.zig
+++ b/src/logger.zig
@@ -18,15 +18,17 @@ const unicode = std.unicode;
 const Ref = @import("./ast/base.zig").Ref;
 const expect = std.testing.expect;
 const assert = bun.assert;
-const ArrayList = std.ArrayList;
 const StringBuilder = @import("./string_builder.zig");
 const Index = @import("./ast/base.zig").Index;
-pub const Kind = enum(i8) {
-    err,
-    warn,
-    note,
-    debug,
-    verbose,
+const OOM = bun.OOM;
+const JSError = bun.JSError;
+
+pub const Kind = enum(u8) {
+    err = 0,
+    warn = 1,
+    note = 2,
+    debug = 3,
+    verbose = 4,
 
     pub inline fn shouldPrint(this: Kind, other: Log.Level) bool {
         return switch (other) {
@@ -94,13 +96,24 @@ pub const Loc = struct {
 };
 
 pub const Location = struct {
-    file: string = "",
+    file: string,
     namespace: string = "file",
-    line: i32 = 1, // 1-based
-    column: i32 = 0, // 0-based, in bytes
-    length: usize = 0, // in bytes
+    /// 1-based line number.
+    /// Line <= 0 means there is no line and column information.
+    // TODO: move to `bun.Ordinal`
+    line: i32,
+    // TODO: figure out how this is interpreted, convert to `bun.Ordinal`
+    // original docs: 0-based, in bytes.
+    // but there is a place where this is emitted in output, implying one based character offset
+    column: i32,
+    /// Number of bytes this location should highlight.
+    /// 0 to just point at a single character
+    length: usize = 0,
+    /// Text on the line, avoiding the need to refetch the source code
     line_text: ?string = null,
+    // TODO: remove this unused field
     suggestion: ?string = null,
+    // TODO: document or remove
     offset: usize = 0,
 
     pub fn count(this: Location, builder: *StringBuilder) void {
@@ -209,7 +222,7 @@ pub const Data = struct {
         allocator.free(d.text);
     }
 
-    pub fn cloneLineText(this: Data, should: bool, allocator: std.mem.Allocator) !Data {
+    pub fn cloneLineText(this: Data, should: bool, allocator: std.mem.Allocator) OOM!Data {
         if (!should or this.location == null or this.location.?.line_text == null)
             return this;
 
@@ -222,7 +235,7 @@ pub const Data = struct {
         };
     }
 
-    pub fn clone(this: Data, allocator: std.mem.Allocator) !Data {
+    pub fn clone(this: Data, allocator: std.mem.Allocator) OOM!Data {
         return Data{
             .text = if (this.text.len > 0) try allocator.dupe(u8, this.text) else "",
             .location = if (this.location != null) try this.location.?.clone(allocator) else null,
@@ -252,6 +265,7 @@ pub const Data = struct {
         this: *const Data,
         to: anytype,
         kind: Kind,
+        redact_sensitive_information: bool,
         comptime enable_ansi_colors: bool,
     ) !void {
         if (this.text.len == 0) return;
@@ -292,7 +306,10 @@ pub const Data = struct {
                         line_offset_for_second_line += std.fmt.count("{d} | ", .{location.line});
                     }
 
-                    try to.print("{}\n", .{bun.fmt.fmtJavaScript(line_text, enable_ansi_colors)});
+                    try to.print("{}\n", .{bun.fmt.fmtJavaScript(line_text, .{
+                        .enable_colors = enable_ansi_colors,
+                        .redact_sensitive_information = redact_sensitive_information,
+                    })});
 
                     try to.writeByteNTimes(' ', line_offset_for_second_line);
                     if ((comptime enable_ansi_colors) and message_color.len > 0) {
@@ -334,7 +351,7 @@ pub const Data = struct {
                     location.file,
                 });
 
-                if (location.line > -1 and location.column > -1) {
+                if (location.line > 0 and location.column > -1) {
                     try to.print(comptime Output.prettyFmt("<d>:<r><yellow>{d}<r><d>:<r><yellow>{d}<r>", enable_ansi_colors), .{
                         location.line,
                         location.column,
@@ -378,10 +395,11 @@ pub const BabyString = packed struct {
 pub const Msg = struct {
     kind: Kind = Kind.err,
     data: Data,
-    metadata: Metadata = .{ .build = 0 },
-    notes: ?[]Data = null,
+    metadata: Metadata = .build,
+    notes: []Data = &.{},
+    redact_sensitive_information: bool = false,
 
-    pub fn fromJS(allocator: std.mem.Allocator, globalObject: *bun.JSC.JSGlobalObject, file: string, err: bun.JSC.JSValue) !Msg {
+    pub fn fromJS(allocator: std.mem.Allocator, globalObject: *bun.JSC.JSGlobalObject, file: string, err: bun.JSC.JSValue) OOM!Msg {
         var zig_exception_holder: bun.JSC.ZigException.Holder = bun.JSC.ZigException.Holder.init();
         if (err.toError()) |value| {
             value.toZigException(globalObject, zig_exception_holder.zigException());
@@ -394,6 +412,8 @@ pub const Msg = struct {
                 .text = try zig_exception_holder.zigException().message.toOwnedSlice(allocator),
                 .location = Location{
                     .file = file,
+                    .line = 0,
+                    .column = 0,
                 },
             },
         };
@@ -408,22 +428,17 @@ pub const Msg = struct {
 
     pub fn count(this: *const Msg, builder: *StringBuilder) void {
         this.data.count(builder);
-        if (this.notes) |notes| {
-            for (notes) |note| {
-                note.count(builder);
-            }
+        for (this.notes) |note| {
+            note.count(builder);
         }
     }
 
-    pub fn clone(this: *const Msg, allocator: std.mem.Allocator) !Msg {
+    pub fn clone(this: *const Msg, allocator: std.mem.Allocator) OOM!Msg {
         return Msg{
             .kind = this.kind,
             .data = try this.data.clone(allocator),
             .metadata = this.metadata,
-            .notes = if (this.notes != null and this.notes.?.len > 0)
-                try bun.clone(this.notes.?, allocator)
-            else
-                null,
+            .notes = try bun.clone(this.notes, allocator),
         };
     }
 
@@ -432,22 +447,18 @@ pub const Msg = struct {
             .kind = this.kind,
             .data = this.data.cloneWithBuilder(builder),
             .metadata = this.metadata,
-            .notes = if (this.notes != null and this.notes.?.len > 0) brk: {
-                for (this.notes.?, 0..) |note, i| {
+            .notes = if (this.notes.len > 0) brk: {
+                for (this.notes, 0..) |note, i| {
                     notes[i] = note.cloneWithBuilder(builder);
                 }
-                break :brk notes[0..this.notes.?.len];
-            } else null,
+                break :brk notes[0..this.notes.len];
+            } else &.{},
         };
     }
 
-    pub const Metadata = union(Tag) {
-        build: u0,
+    pub const Metadata = union(enum) {
+        build,
         resolve: Resolve,
-        pub const Tag = enum(u8) {
-            build = 1,
-            resolve = 2,
-        };
 
         pub const Resolve = struct {
             specifier: BabyString,
@@ -456,34 +467,29 @@ pub const Msg = struct {
         };
     };
 
-    pub fn toAPI(this: *const Msg, allocator: std.mem.Allocator) !Api.Message {
-        const notes_len = if (this.notes != null) this.notes.?.len else 0;
-        var _notes = try allocator.alloc(
+    pub fn toAPI(this: *const Msg, allocator: std.mem.Allocator) OOM!Api.Message {
+        var notes = try allocator.alloc(
             Api.MessageData,
-            notes_len,
+            this.notes.len,
         );
         const msg = Api.Message{
             .level = this.kind.toAPI(),
             .data = this.data.toAPI(),
-            .notes = _notes,
+            .notes = notes,
             .on = Api.MessageMeta{
                 .resolve = if (this.metadata == .resolve) this.metadata.resolve.specifier.slice(this.data.text) else "",
                 .build = this.metadata == .build,
             },
         };
 
-        if (this.notes) |notes| {
-            if (notes.len > 0) {
-                for (notes, 0..) |note, i| {
-                    _notes[i] = note.toAPI();
-                }
-            }
+        for (this.notes, 0..) |note, i| {
+            notes[i] = note.toAPI();
         }
 
         return msg;
     }
 
-    pub fn toAPIFromList(comptime ListType: type, list: ListType, allocator: std.mem.Allocator) ![]Api.Message {
+    pub fn toAPIFromList(comptime ListType: type, list: ListType, allocator: std.mem.Allocator) OOM![]Api.Message {
         var out_list = try allocator.alloc(Api.Message, list.items.len);
         for (list.items, 0..) |item, i| {
             out_list[i] = try item.toAPI(allocator);
@@ -494,15 +500,13 @@ pub const Msg = struct {
 
     pub fn deinit(msg: *Msg, allocator: std.mem.Allocator) void {
         msg.data.deinit(allocator);
-        if (msg.notes) |notes| {
-            for (notes) |*note| {
-                note.deinit(allocator);
-            }
-
-            allocator.free(notes);
+        for (msg.notes) |*note| {
+            note.deinit(allocator);
         }
 
-        msg.notes = null;
+        allocator.free(msg.notes);
+
+        msg.notes = &.{};
     }
 
     pub fn writeFormat(
@@ -510,18 +514,16 @@ pub const Msg = struct {
         to: anytype,
         comptime enable_ansi_colors: bool,
     ) !void {
-        try msg.data.writeFormat(to, msg.kind, enable_ansi_colors);
+        try msg.data.writeFormat(to, msg.kind, msg.redact_sensitive_information, enable_ansi_colors);
 
-        if (msg.notes) |notes| {
-            if (notes.len > 0) {
-                try to.writeAll("\n");
-            }
+        if (msg.notes.len > 0) {
+            try to.writeAll("\n");
+        }
 
-            for (notes) |note| {
-                try to.writeAll("\n");
+        for (msg.notes) |note| {
+            try to.writeAll("\n");
 
-                try note.writeFormat(to, .note, enable_ansi_colors);
-            }
+            try note.writeFormat(to, .note, msg.redact_sensitive_information, enable_ansi_colors);
         }
     }
 
@@ -568,7 +570,9 @@ pub const Range = struct {
     loc: Loc = Loc.Empty,
     len: i32 = 0,
 
-    pub const None = Range{ .loc = Loc.Empty, .len = 0 };
+    /// Deprecated: use .none
+    pub const None = none;
+    pub const none = Range{ .loc = Loc.Empty, .len = 0 };
 
     pub fn in(this: Range, buf: []const u8) []const u8 {
         if (this.loc.start < 0 or this.len <= 0) return "";
@@ -597,10 +601,9 @@ pub const Range = struct {
 };
 
 pub const Log = struct {
-    debug: bool = false,
-    warnings: usize = 0,
-    errors: usize = 0,
-    msgs: ArrayList(Msg),
+    warnings: u32 = 0,
+    errors: u32 = 0,
+    msgs: std.ArrayList(Msg),
     level: Level = if (Environment.isDebug) Level.info else Level.warn,
 
     clone_line_text: bool = false,
@@ -664,14 +667,13 @@ pub const Log = struct {
             .{ "error", Level.err },
         });
 
-        pub fn fromJS(globalThis: *JSC.JSGlobalObject, value: JSC.JSValue) !?Level {
+        pub fn fromJS(globalThis: *JSC.JSGlobalObject, value: JSC.JSValue) JSError!?Level {
             if (value == .zero or value == .undefined) {
                 return null;
             }
 
             if (!value.isString()) {
-                globalThis.throwInvalidArguments("Expected logLevel to be a string", .{});
-                return error.JSError;
+                return globalThis.throwInvalidArguments("Expected logLevel to be a string", .{});
             }
 
             return Map.fromJS(globalThis, value);
@@ -680,28 +682,28 @@ pub const Log = struct {
 
     pub fn init(allocator: std.mem.Allocator) Log {
         return Log{
-            .msgs = ArrayList(Msg).init(allocator),
+            .msgs = std.ArrayList(Msg).init(allocator),
             .level = default_log_level,
         };
     }
 
     pub fn initComptime(allocator: std.mem.Allocator) Log {
         return Log{
-            .msgs = ArrayList(Msg).init(allocator),
+            .msgs = std.ArrayList(Msg).init(allocator),
         };
     }
 
-    pub fn addDebugFmt(log: *Log, source: ?*const Source, l: Loc, allocator: std.mem.Allocator, comptime text: string, args: anytype) !void {
+    pub fn addDebugFmt(log: *Log, source: ?*const Source, l: Loc, allocator: std.mem.Allocator, comptime text: string, args: anytype) OOM!void {
         if (!Kind.shouldPrint(.debug, log.level)) return;
 
         @setCold(true);
         try log.addMsg(.{
             .kind = .debug,
-            .data = try rangeData(source, Range{ .loc = l }, allocPrint(allocator, text, args) catch unreachable).cloneLineText(log.clone_line_text, log.msgs.allocator),
+            .data = try rangeData(source, Range{ .loc = l }, try allocPrint(allocator, text, args)).cloneLineText(log.clone_line_text, log.msgs.allocator),
         });
     }
 
-    pub fn addVerbose(log: *Log, source: ?*const Source, loc: Loc, text: string) !void {
+    pub fn addVerbose(log: *Log, source: ?*const Source, loc: Loc, text: string) OOM!void {
         if (!Kind.shouldPrint(.verbose, log.level)) return;
 
         @setCold(true);
@@ -711,7 +713,7 @@ pub const Log = struct {
         });
     }
 
-    pub fn toJS(this: Log, global: *JSC.JSGlobalObject, allocator: std.mem.Allocator, fmt: string) JSC.JSValue {
+    pub fn toJS(this: Log, global: *JSC.JSGlobalObject, allocator: std.mem.Allocator, message: string) JSC.JSValue {
         const msgs: []const Msg = this.msgs.items;
         var errors_stack: [256]JSC.JSValue = undefined;
 
@@ -732,13 +734,35 @@ pub const Log = struct {
                         .resolve => JSC.ResolveMessage.create(global, allocator, msg, ""),
                     };
                 }
-                const out = JSC.ZigString.init(fmt);
+                const out = JSC.ZigString.init(message);
                 const agg = global.createAggregateError(errors_stack[0..count], &out);
                 return agg;
             },
         }
     }
 
+    /// unlike toJS, this always produces an AggregateError object
+    pub fn toJSAggregateError(this: Log, global: *JSC.JSGlobalObject, message: []const u8) JSC.JSValue {
+        const msgs: []const Msg = this.msgs.items;
+
+        // TODO: remove arbitrary upper limit. cannot use the heap because
+        // values could be GC'd. to do this correctly, expose a binding that
+        // allows creating an AggregateError using an array
+        var errors_stack: [256]JSC.JSValue = undefined;
+
+        const count = @min(msgs.len, errors_stack.len);
+
+        for (msgs[0..count], 0..) |msg, i| {
+            errors_stack[i] = switch (msg.metadata) {
+                .build => JSC.BuildMessage.create(global, bun.default_allocator, msg),
+                .resolve => JSC.ResolveMessage.create(global, bun.default_allocator, msg, ""),
+            };
+        }
+
+        const out = JSC.ZigString.init(message);
+        return global.createAggregateError(errors_stack[0..count], &out);
+    }
+
     pub fn toJSArray(this: Log, global: *JSC.JSGlobalObject, allocator: std.mem.Allocator) JSC.JSValue {
         const msgs: []const Msg = this.msgs.items;
         const errors_stack: [256]*anyopaque = undefined;
@@ -753,15 +777,13 @@ pub const Log = struct {
         return arr;
     }
 
-    pub fn cloneTo(self: *Log, other: *Log) !void {
+    pub fn cloneTo(self: *Log, other: *Log) OOM!void {
         var notes_count: usize = 0;
 
         for (self.msgs.items) |msg_| {
             const msg: Msg = msg_;
-            if (msg.notes) |notes| {
-                for (notes) |note| {
-                    notes_count += @as(usize, @intCast(@intFromBool(note.text.len > 0)));
-                }
+            for (msg.notes) |note| {
+                notes_count += @as(usize, @intCast(@intFromBool(note.text.len > 0)));
             }
         }
 
@@ -769,14 +791,12 @@ pub const Log = struct {
             var notes = try other.msgs.allocator.alloc(Data, notes_count);
             var note_i: usize = 0;
             for (self.msgs.items) |*msg| {
-                if (msg.notes) |current_notes| {
-                    const start_note_i: usize = note_i;
-                    for (current_notes) |note| {
-                        notes[note_i] = note;
-                        note_i += 1;
-                    }
-                    msg.notes = notes[start_note_i..note_i];
+                const start_note_i: usize = note_i;
+                for (msg.notes) |note| {
+                    notes[note_i] = note;
+                    note_i += 1;
                 }
+                msg.notes = notes[start_note_i..note_i];
             }
         }
 
@@ -785,12 +805,12 @@ pub const Log = struct {
         other.errors += self.errors;
     }
 
-    pub fn appendTo(self: *Log, other: *Log) !void {
+    pub fn appendTo(self: *Log, other: *Log) OOM!void {
         try self.cloneTo(other);
         self.msgs.clearAndFree();
     }
 
-    pub fn cloneToWithRecycled(self: *Log, other: *Log, recycled: bool) !void {
+    pub fn cloneToWithRecycled(self: *Log, other: *Log, recycled: bool) OOM!void {
         try other.msgs.appendSlice(self.msgs.items);
         other.warnings += self.warnings;
         other.errors += self.errors;
@@ -802,9 +822,7 @@ pub const Log = struct {
                 for (self.msgs.items) |msg| {
                     msg.count(&string_builder);
 
-                    if (msg.notes) |notes| {
-                        notes_count += notes.len;
-                    }
+                    notes_count += msg.notes.len;
                 }
             }
 
@@ -815,18 +833,18 @@ pub const Log = struct {
             {
                 for (self.msgs.items, (other.msgs.items.len - self.msgs.items.len)..) |msg, j| {
                     other.msgs.items[j] = msg.cloneWithBuilder(notes_buf[note_i..], &string_builder);
-                    note_i += (msg.notes orelse &[_]Data{}).len;
+                    note_i += msg.notes.len;
                 }
             }
         }
     }
 
-    pub fn appendToWithRecycled(self: *Log, other: *Log, recycled: bool) !void {
+    pub fn appendToWithRecycled(self: *Log, other: *Log, recycled: bool) OOM!void {
         try self.cloneToWithRecycled(other, recycled);
         self.msgs.clearAndFree();
     }
 
-    pub fn appendToMaybeRecycled(self: *Log, other: *Log, source: *const Source) !void {
+    pub fn appendToMaybeRecycled(self: *Log, other: *Log, source: *const Source) OOM!void {
         return self.appendToWithRecycled(other, source.contents_is_recycled);
     }
 
@@ -834,7 +852,10 @@ pub const Log = struct {
         self.msgs.clearAndFree();
     }
 
-    pub fn addVerboseWithNotes(log: *Log, source: ?*const Source, loc: Loc, text: string, notes: []Data) !void {
+    // TODO: remove `deinit` because it does not de-initialize the log; it clears it
+    pub const clearAndFree = deinit;
+
+    pub fn addVerboseWithNotes(log: *Log, source: ?*const Source, loc: Loc, text: string, notes: []Data) OOM!void {
         @setCold(true);
         if (!Kind.shouldPrint(.verbose, log.level)) return;
 
@@ -845,13 +866,13 @@ pub const Log = struct {
         });
     }
 
-    inline fn allocPrint(allocator: std.mem.Allocator, comptime fmt: string, args: anytype) !string {
+    inline fn allocPrint(allocator: std.mem.Allocator, comptime fmt: string, args: anytype) OOM!string {
         return try switch (Output.enable_ansi_colors) {
             inline else => |enable_ansi_colors| std.fmt.allocPrint(allocator, Output.prettyFmt(fmt, enable_ansi_colors), args),
         };
     }
 
-    inline fn _addResolveErrorWithLevel(
+    inline fn addResolveErrorWithLevel(
         log: *Log,
         source: ?*const Source,
         r: Range,
@@ -860,13 +881,13 @@ pub const Log = struct {
         args: anytype,
         import_kind: ImportKind,
         comptime dupe_text: bool,
-        comptime is_error: bool,
+        comptime kind: enum { err, warn },
         err: anyerror,
-    ) !void {
+    ) OOM!void {
         const text = try allocPrint(allocator, fmt, args);
         // TODO: fix this. this is stupid, it should be returned in allocPrint.
         const specifier = BabyString.in(text, args.@"0");
-        if (comptime is_error) {
+        if (comptime kind == .err) {
             log.errors += 1;
         } else {
             log.warnings += 1;
@@ -880,7 +901,7 @@ pub const Log = struct {
             );
             if (_data.location != null) {
                 if (_data.location.?.line_text) |line| {
-                    _data.location.?.line_text = allocator.dupe(u8, line) catch unreachable;
+                    _data.location.?.line_text = try allocator.dupe(u8, line);
                 }
             }
             break :brk _data;
@@ -891,7 +912,8 @@ pub const Log = struct {
         );
 
         const msg = Msg{
-            .kind = if (comptime is_error) Kind.err else Kind.warn,
+            // .kind = if (comptime error_type == .err) Kind.err else Kind.warn,
+            .kind = @field(Kind, @tagName(kind)),
             .data = data,
             .metadata = .{ .resolve = Msg.Metadata.Resolve{
                 .specifier = specifier,
@@ -903,34 +925,6 @@ pub const Log = struct {
         try log.addMsg(msg);
     }
 
-    inline fn _addResolveError(
-        log: *Log,
-        source: ?*const Source,
-        r: Range,
-        allocator: std.mem.Allocator,
-        comptime fmt: string,
-        args: anytype,
-        import_kind: ImportKind,
-        comptime dupe_text: bool,
-        err: anyerror,
-    ) !void {
-        return _addResolveErrorWithLevel(log, source, r, allocator, fmt, args, import_kind, dupe_text, true, err);
-    }
-
-    inline fn _addResolveWarn(
-        log: *Log,
-        source: ?*const Source,
-        r: Range,
-        allocator: std.mem.Allocator,
-        comptime fmt: string,
-        args: anytype,
-        import_kind: ImportKind,
-        comptime dupe_text: bool,
-        err: anyerror,
-    ) !void {
-        return _addResolveErrorWithLevel(log, source, r, allocator, fmt, args, import_kind, dupe_text, false, err);
-    }
-
     pub fn addResolveError(
         log: *Log,
         source: ?*const Source,
@@ -940,9 +934,9 @@ pub const Log = struct {
         args: anytype,
         import_kind: ImportKind,
         err: anyerror,
-    ) !void {
+    ) OOM!void {
         @setCold(true);
-        return try _addResolveError(log, source, r, allocator, fmt, args, import_kind, false, err);
+        return try addResolveErrorWithLevel(log, source, r, allocator, fmt, args, import_kind, false, .err, err);
     }
 
     pub fn addResolveErrorWithTextDupe(
@@ -953,30 +947,12 @@ pub const Log = struct {
         comptime fmt: string,
         args: anytype,
         import_kind: ImportKind,
-    ) !void {
+    ) OOM!void {
         @setCold(true);
-        return try _addResolveError(log, source, r, allocator, fmt, args, import_kind, true, error.ModuleNotFound);
+        return try addResolveErrorWithLevel(log, source, r, allocator, fmt, args, import_kind, true, .err, error.ModuleNotFound);
     }
 
-    pub fn addResolveErrorWithTextDupeMaybeWarn(
-        log: *Log,
-        source: ?*const Source,
-        r: Range,
-        allocator: std.mem.Allocator,
-        comptime fmt: string,
-        args: anytype,
-        import_kind: ImportKind,
-        warn: bool,
-    ) !void {
-        @setCold(true);
-        if (warn) {
-            return try _addResolveError(log, source, r, allocator, fmt, args, import_kind, true, error.ModuleNotFound);
-        } else {
-            return try _addResolveWarn(log, source, r, allocator, fmt, args, import_kind, true, error.ModuleNotFound);
-        }
-    }
-
-    pub fn addRangeError(log: *Log, source: ?*const Source, r: Range, text: string) !void {
+    pub fn addRangeError(log: *Log, source: ?*const Source, r: Range, text: string) OOM!void {
         @setCold(true);
         log.errors += 1;
         try log.addMsg(.{
@@ -985,44 +961,55 @@ pub const Log = struct {
         });
     }
 
-    pub fn addRangeErrorFmt(log: *Log, source: ?*const Source, r: Range, allocator: std.mem.Allocator, comptime text: string, args: anytype) !void {
+    pub fn addRangeErrorFmt(log: *Log, source: ?*const Source, r: Range, allocator: std.mem.Allocator, comptime text: string, args: anytype) OOM!void {
         @setCold(true);
         log.errors += 1;
         try log.addMsg(.{
             .kind = .err,
-            .data = try rangeData(source, r, allocPrint(allocator, text, args) catch unreachable).cloneLineText(log.clone_line_text, log.msgs.allocator),
+            .data = try rangeData(source, r, try allocPrint(allocator, text, args)).cloneLineText(log.clone_line_text, log.msgs.allocator),
         });
     }
 
-    pub fn addRangeErrorFmtWithNotes(log: *Log, source: ?*const Source, r: Range, allocator: std.mem.Allocator, notes: []Data, comptime fmt: string, args: anytype) !void {
+    pub fn addRangeErrorFmtWithNotes(log: *Log, source: ?*const Source, r: Range, allocator: std.mem.Allocator, notes: []Data, comptime fmt: string, args: anytype) OOM!void {
         @setCold(true);
         log.errors += 1;
         try log.addMsg(.{
             .kind = .err,
-            .data = try rangeData(source, r, allocPrint(allocator, fmt, args) catch unreachable).cloneLineText(log.clone_line_text, log.msgs.allocator),
+            .data = try rangeData(source, r, try allocPrint(allocator, fmt, args)).cloneLineText(log.clone_line_text, log.msgs.allocator),
             .notes = notes,
         });
     }
 
-    pub fn addErrorFmtNoLoc(log: *Log, allocator: std.mem.Allocator, comptime text: string, args: anytype) !void {
-        try log.addErrorFmt(null, Loc.Empty, allocator, text, args);
-    }
-
-    pub fn addErrorFmt(log: *Log, source: ?*const Source, l: Loc, allocator: std.mem.Allocator, comptime text: string, args: anytype) !void {
+    pub fn addErrorFmt(log: *Log, source: ?*const Source, l: Loc, allocator: std.mem.Allocator, comptime text: string, args: anytype) OOM!void {
         @setCold(true);
         log.errors += 1;
         try log.addMsg(.{
             .kind = .err,
-            .data = try rangeData(source, Range{ .loc = l }, allocPrint(allocator, text, args) catch unreachable).cloneLineText(log.clone_line_text, log.msgs.allocator),
+            .data = try rangeData(source, .{ .loc = l }, try allocPrint(allocator, text, args)).cloneLineText(log.clone_line_text, log.msgs.allocator),
         });
     }
 
-    pub fn addZigErrorWithNote(log: *Log, allocator: std.mem.Allocator, err: anyerror, comptime noteFmt: string, args: anytype) !void {
+    // TODO(dylan-conway): rename and replace `addErrorFmt`
+    pub fn addErrorFmtOpts(log: *Log, allocator: std.mem.Allocator, comptime fmt: string, args: anytype, opts: AddErrorOptions) OOM!void {
+        @setCold(true);
+        log.errors += 1;
+        try log.addMsg(.{
+            .kind = .err,
+            .data = try rangeData(
+                opts.source,
+                .{ .loc = opts.loc, .len = opts.len },
+                try allocPrint(allocator, fmt, args),
+            ).cloneLineText(log.clone_line_text, log.msgs.allocator),
+            .redact_sensitive_information = opts.redact_sensitive_information,
+        });
+    }
+
+    pub fn addZigErrorWithNote(log: *Log, allocator: std.mem.Allocator, err: anyerror, comptime noteFmt: string, args: anytype) OOM!void {
         @setCold(true);
         log.errors += 1;
 
         var notes = try allocator.alloc(Data, 1);
-        notes[0] = rangeData(null, Range.None, allocPrint(allocator, noteFmt, args) catch unreachable);
+        notes[0] = rangeData(null, Range.None, try allocPrint(allocator, noteFmt, args));
 
         try log.addMsg(.{
             .kind = .err,
@@ -1031,7 +1018,7 @@ pub const Log = struct {
         });
     }
 
-    pub fn addRangeWarning(log: *Log, source: ?*const Source, r: Range, text: string) !void {
+    pub fn addRangeWarning(log: *Log, source: ?*const Source, r: Range, text: string) OOM!void {
         @setCold(true);
         if (!Kind.shouldPrint(.warn, log.level)) return;
         log.warnings += 1;
@@ -1041,23 +1028,43 @@ pub const Log = struct {
         });
     }
 
-    pub fn addWarningFmt(log: *Log, source: ?*const Source, l: Loc, allocator: std.mem.Allocator, comptime text: string, args: anytype) !void {
+    pub fn addWarningFmt(log: *Log, source: ?*const Source, l: Loc, allocator: std.mem.Allocator, comptime text: string, args: anytype) OOM!void {
         @setCold(true);
         if (!Kind.shouldPrint(.warn, log.level)) return;
         log.warnings += 1;
         try log.addMsg(.{
             .kind = .warn,
-            .data = try rangeData(source, Range{ .loc = l }, allocPrint(allocator, text, args) catch unreachable).cloneLineText(log.clone_line_text, log.msgs.allocator),
+            .data = try rangeData(source, Range{ .loc = l }, try allocPrint(allocator, text, args)).cloneLineText(log.clone_line_text, log.msgs.allocator),
         });
     }
 
-    pub fn addRangeWarningFmt(log: *Log, source: ?*const Source, r: Range, allocator: std.mem.Allocator, comptime text: string, args: anytype) !void {
+    pub fn addWarningFmtLineCol(log: *Log, filepath: []const u8, line: u32, col: u32, allocator: std.mem.Allocator, comptime text: string, args: anytype) OOM!void {
+        @setCold(true);
+        if (!Kind.shouldPrint(.warn, log.level)) return;
+        log.warnings += 1;
+
+        // TODO: do this properly
+
+        try log.addMsg(.{
+            .kind = .warn,
+            .data = try Data.cloneLineText(Data{
+                .text = try allocPrint(allocator, text, args),
+                .location = Location{
+                    .file = filepath,
+                    .line = @intCast(line),
+                    .column = @intCast(col),
+                },
+            }, log.clone_line_text, allocator),
+        });
+    }
+
+    pub fn addRangeWarningFmt(log: *Log, source: ?*const Source, r: Range, allocator: std.mem.Allocator, comptime text: string, args: anytype) OOM!void {
         @setCold(true);
         if (!Kind.shouldPrint(.warn, log.level)) return;
         log.warnings += 1;
         try log.addMsg(.{
             .kind = .warn,
-            .data = try rangeData(source, r, allocPrint(allocator, text, args) catch unreachable).cloneLineText(log.clone_line_text, log.msgs.allocator),
+            .data = try rangeData(source, r, try allocPrint(allocator, text, args)).cloneLineText(log.clone_line_text, log.msgs.allocator),
         });
     }
 
@@ -1071,27 +1078,27 @@ pub const Log = struct {
         comptime note_fmt: string,
         note_args: anytype,
         note_range: Range,
-    ) !void {
+    ) OOM!void {
         @setCold(true);
         if (!Kind.shouldPrint(.warn, log.level)) return;
         log.warnings += 1;
 
         var notes = try allocator.alloc(Data, 1);
-        notes[0] = rangeData(source, note_range, allocPrint(allocator, note_fmt, note_args) catch unreachable);
+        notes[0] = rangeData(source, note_range, try allocPrint(allocator, note_fmt, note_args));
 
         try log.addMsg(.{
             .kind = .warn,
-            .data = rangeData(source, r, allocPrint(allocator, fmt, args) catch unreachable),
+            .data = rangeData(source, r, try allocPrint(allocator, fmt, args)),
             .notes = notes,
         });
     }
 
-    pub fn addRangeWarningFmtWithNotes(log: *Log, source: ?*const Source, r: Range, allocator: std.mem.Allocator, notes: []Data, comptime fmt: string, args: anytype) !void {
+    pub fn addRangeWarningFmtWithNotes(log: *Log, source: ?*const Source, r: Range, allocator: std.mem.Allocator, notes: []Data, comptime fmt: string, args: anytype) OOM!void {
         @setCold(true);
         log.warnings += 1;
         try log.addMsg(.{
             .kind = .warn,
-            .data = try rangeData(source, r, allocPrint(allocator, fmt, args) catch unreachable).cloneLineText(log.clone_line_text, log.msgs.allocator),
+            .data = try rangeData(source, r, try allocPrint(allocator, fmt, args)).cloneLineText(log.clone_line_text, log.msgs.allocator),
             .notes = notes,
         });
     }
@@ -1106,22 +1113,22 @@ pub const Log = struct {
         comptime note_fmt: string,
         note_args: anytype,
         note_range: Range,
-    ) !void {
+    ) OOM!void {
         @setCold(true);
         if (!Kind.shouldPrint(.err, log.level)) return;
         log.errors += 1;
 
         var notes = try allocator.alloc(Data, 1);
-        notes[0] = rangeData(source, note_range, allocPrint(allocator, note_fmt, note_args) catch unreachable);
+        notes[0] = rangeData(source, note_range, try allocPrint(allocator, note_fmt, note_args));
 
         try log.addMsg(.{
             .kind = .err,
-            .data = rangeData(source, r, allocPrint(allocator, fmt, args) catch unreachable),
+            .data = rangeData(source, r, try allocPrint(allocator, fmt, args)),
             .notes = notes,
         });
     }
 
-    pub fn addWarning(log: *Log, source: ?*const Source, l: Loc, text: string) !void {
+    pub fn addWarning(log: *Log, source: ?*const Source, l: Loc, text: string) OOM!void {
         @setCold(true);
         if (!Kind.shouldPrint(.warn, log.level)) return;
         log.warnings += 1;
@@ -1131,13 +1138,13 @@ pub const Log = struct {
         });
     }
 
-    pub fn addWarningWithNote(log: *Log, source: ?*const Source, l: Loc, allocator: std.mem.Allocator, warn: string, comptime note_fmt: string, note_args: anytype) !void {
+    pub fn addWarningWithNote(log: *Log, source: ?*const Source, l: Loc, allocator: std.mem.Allocator, warn: string, comptime note_fmt: string, note_args: anytype) OOM!void {
         @setCold(true);
         if (!Kind.shouldPrint(.warn, log.level)) return;
         log.warnings += 1;
 
         var notes = try allocator.alloc(Data, 1);
-        notes[0] = rangeData(source, Range{ .loc = l }, allocPrint(allocator, note_fmt, note_args) catch unreachable);
+        notes[0] = rangeData(source, Range{ .loc = l }, try allocPrint(allocator, note_fmt, note_args));
 
         try log.addMsg(.{
             .kind = .warn,
@@ -1146,7 +1153,7 @@ pub const Log = struct {
         });
     }
 
-    pub fn addRangeDebug(log: *Log, source: ?*const Source, r: Range, text: string) !void {
+    pub fn addRangeDebug(log: *Log, source: ?*const Source, r: Range, text: string) OOM!void {
         @setCold(true);
         if (!Kind.shouldPrint(.debug, log.level)) return;
         try log.addMsg(.{
@@ -1155,7 +1162,7 @@ pub const Log = struct {
         });
     }
 
-    pub fn addRangeDebugWithNotes(log: *Log, source: ?*const Source, r: Range, text: string, notes: []Data) !void {
+    pub fn addRangeDebugWithNotes(log: *Log, source: ?*const Source, r: Range, text: string, notes: []Data) OOM!void {
         @setCold(true);
         if (!Kind.shouldPrint(.debug, log.level)) return;
         // log.de += 1;
@@ -1166,7 +1173,7 @@ pub const Log = struct {
         });
     }
 
-    pub fn addRangeErrorWithNotes(log: *Log, source: ?*const Source, r: Range, text: string, notes: []Data) !void {
+    pub fn addRangeErrorWithNotes(log: *Log, source: ?*const Source, r: Range, text: string, notes: []Data) OOM!void {
         @setCold(true);
         log.errors += 1;
         try log.addMsg(.{
@@ -1176,7 +1183,7 @@ pub const Log = struct {
         });
     }
 
-    pub fn addRangeWarningWithNotes(log: *Log, source: ?*const Source, r: Range, text: string, notes: []Data) !void {
+    pub fn addRangeWarningWithNotes(log: *Log, source: ?*const Source, r: Range, text: string, notes: []Data) OOM!void {
         @setCold(true);
         if (!Kind.shouldPrint(.warn, log.level)) return;
         log.warnings += 1;
@@ -1187,17 +1194,35 @@ pub const Log = struct {
         });
     }
 
-    pub inline fn addMsg(self: *Log, msg: Msg) !void {
+    pub fn addMsg(self: *Log, msg: Msg) OOM!void {
         try self.msgs.append(msg);
     }
 
-    pub fn addError(self: *Log, _source: ?*const Source, loc: Loc, text: string) !void {
+    pub fn addError(self: *Log, _source: ?*const Source, loc: Loc, text: string) OOM!void {
         @setCold(true);
         self.errors += 1;
         try self.addMsg(.{ .kind = .err, .data = rangeData(_source, Range{ .loc = loc }, text) });
     }
 
-    pub fn addSymbolAlreadyDeclaredError(self: *Log, allocator: std.mem.Allocator, source: *const Source, name: string, new_loc: Loc, old_loc: Loc) !void {
+    const AddErrorOptions = struct {
+        source: ?*const Source = null,
+        loc: Loc = Loc.Empty,
+        len: i32 = 0,
+        redact_sensitive_information: bool = false,
+    };
+
+    // TODO(dylan-conway): rename and replace `addError`
+    pub fn addErrorOpts(self: *Log, text: string, opts: AddErrorOptions) OOM!void {
+        @setCold(true);
+        self.errors += 1;
+        try self.addMsg(.{
+            .kind = .err,
+            .data = rangeData(opts.source, .{ .loc = opts.loc, .len = opts.len }, text),
+            .redact_sensitive_information = opts.redact_sensitive_information,
+        });
+    }
+
+    pub fn addSymbolAlreadyDeclaredError(self: *Log, allocator: std.mem.Allocator, source: *const Source, name: string, new_loc: Loc, old_loc: Loc) OOM!void {
         var notes = try allocator.alloc(Data, 1);
         notes[0] = rangeData(
             source,
@@ -1215,13 +1240,13 @@ pub const Log = struct {
         );
     }
 
-    pub fn printForLogLevel(self: *Log, to: anytype) !void {
+    pub fn print(self: *const Log, to: anytype) !void {
         return switch (Output.enable_ansi_colors) {
-            inline else => |enable_ansi_colors| self.printForLogLevelWithEnableAnsiColors(to, enable_ansi_colors),
+            inline else => |enable_ansi_colors| self.printWithEnableAnsiColors(to, enable_ansi_colors),
         };
     }
 
-    pub fn printForLogLevelWithEnableAnsiColors(self: *const Log, to: anytype, comptime enable_ansi_colors: bool) !void {
+    pub fn printWithEnableAnsiColors(self: *const Log, to: anytype, comptime enable_ansi_colors: bool) !void {
         var needs_newline = false;
         if (self.warnings > 0 and self.errors > 0) {
             // Print warnings at the top
@@ -1261,14 +1286,6 @@ pub const Log = struct {
         if (needs_newline) _ = try to.write("\n");
     }
 
-    pub fn printForLogLevelColorsRuntime(self: *Log, to: anytype, enable_ansi_colors: bool) !void {
-        if (enable_ansi_colors) {
-            return self.printForLogLevelWithEnableAnsiColors(to, true);
-        } else {
-            return self.printForLogLevelWithEnableAnsiColors(to, false);
-        }
-    }
-
     pub fn toZigException(this: *const Log, allocator: std.mem.Allocator) *js.ZigException.Holder {
         var holder = try allocator.create(js.ZigException.Holder);
         holder.* = js.ZigException.Holder.init();
@@ -1285,7 +1302,6 @@ pub inline fn usize2Loc(loc: usize) Loc {
 
 pub const Source = struct {
     path: fs.Path,
-    key_path: fs.Path,
 
     contents: string,
     contents_is_recycled: bool = false,
@@ -1332,13 +1348,12 @@ pub const Source = struct {
 
     pub fn initEmptyFile(filepath: string) Source {
         const path = fs.Path.init(filepath);
-        return Source{ .path = path, .key_path = path, .contents = "" };
+        return Source{ .path = path, .contents = "" };
     }
 
     pub fn initFile(file: fs.PathContentsPair, _: std.mem.Allocator) !Source {
         var source = Source{
             .path = file.path,
-            .key_path = fs.Path.init(file.path.text),
             .contents = file.contents,
         };
         source.path.namespace = "file";
@@ -1348,7 +1363,6 @@ pub const Source = struct {
     pub fn initRecycledFile(file: fs.PathContentsPair, _: std.mem.Allocator) !Source {
         var source = Source{
             .path = file.path,
-            .key_path = fs.Path.init(file.path.text),
             .contents = file.contents,
             .contents_is_recycled = true,
         };
@@ -1359,7 +1373,7 @@ pub const Source = struct {
 
     pub fn initPathString(pathString: string, contents: string) Source {
         const path = fs.Path.init(pathString);
-        return Source{ .key_path = path, .path = path, .contents = contents };
+        return Source{ .path = path, .contents = contents };
     }
 
     pub fn textForRange(self: *const Source, r: Range) string {
@@ -1491,6 +1505,48 @@ pub const Source = struct {
             .column_count = column_number,
         };
     }
+    pub fn lineColToByteOffset(source_contents: []const u8, start_line: usize, start_col: usize, line: usize, col: usize) ?usize {
+        var iter_ = strings.CodepointIterator{
+            .bytes = source_contents,
+            .i = 0,
+        };
+        var iter = strings.CodepointIterator.Cursor{};
+
+        var line_count: usize = start_line;
+        var column_number: usize = start_col;
+
+        _ = iter_.next(&iter);
+        while (true) {
+            const c = iter.c;
+            if (!iter_.next(&iter)) break;
+            switch (c) {
+                '\n' => {
+                    column_number = 1;
+                    line_count += 1;
+                },
+
+                '\r' => {
+                    column_number = 1;
+                    line_count += 1;
+                    if (iter.c == '\n') {
+                        _ = iter_.next(&iter);
+                    }
+                },
+
+                0x2028, 0x2029 => {
+                    line_count += 1;
+                    column_number = 1;
+                },
+                else => {
+                    column_number += 1;
+                },
+            }
+
+            if (line_count == line and column_number == col) return iter.i;
+            if (line_count > line) return null;
+        }
+        return null;
+    }
 };
 
 pub fn rangeData(source: ?*const Source, r: Range, text: string) Data {
diff --git a/src/main_wasm.zig b/src/main_wasm.zig
index d4d0c43dca..3a1cfc5c83 100644
--- a/src/main_wasm.zig
+++ b/src/main_wasm.zig
@@ -483,7 +483,7 @@ export fn getTests(opts_array: u64) u64 {
 
         Output.print("Error: {s}\n", .{@errorName(err)});
 
-        log_.printForLogLevel(Output.writer()) catch unreachable;
+        log_.print(Output.writer()) catch unreachable;
         return 0;
     };
 
diff --git a/src/meta.zig b/src/meta.zig
index 24d3d0ed64..d70ee0af27 100644
--- a/src/meta.zig
+++ b/src/meta.zig
@@ -3,6 +3,49 @@ const bun = @import("root").bun;
 
 pub usingnamespace std.meta;
 
+pub fn OptionalChild(comptime T: type) type {
+    const tyinfo = @typeInfo(T);
+    if (tyinfo != .Pointer) @compileError("OptionalChild(T) requires that T be a pointer to an optional type.");
+    const child = @typeInfo(tyinfo.Pointer.child);
+    if (child != .Optional) @compileError("OptionalChild(T) requires that T be a pointer to an optional type.");
+    return child.Optional.child;
+}
+
+pub fn EnumFields(comptime T: type) []const std.builtin.Type.EnumField {
+    const tyinfo = @typeInfo(T);
+    return switch (tyinfo) {
+        .Union => std.meta.fields(tyinfo.Union.tag_type.?),
+        .Enum => tyinfo.Enum.fields,
+        else => {
+            @compileError("Used `EnumFields(T)` on a type that is not an `enum` or a `union(enum)`");
+        },
+    };
+}
+
+pub fn ReturnOfMaybe(comptime function: anytype) type {
+    const Func = @TypeOf(function);
+    const typeinfo: std.builtin.Type.Fn = @typeInfo(Func).Fn;
+    const MaybeType = typeinfo.return_type orelse @compileError("Expected the function to have a return type");
+    return MaybeResult(MaybeType);
+}
+
+pub fn MaybeResult(comptime MaybeType: type) type {
+    const maybe_ty_info = @typeInfo(MaybeType);
+
+    const maybe = maybe_ty_info.Union;
+    if (maybe.fields.len != 2) @compileError("Expected the Maybe type to be a union(enum) with two variants");
+
+    if (!std.mem.eql(u8, maybe.fields[0].name, "err")) {
+        @compileError("Expected the first field of the Maybe type to be \"err\", got: " ++ maybe.fields[0].name);
+    }
+
+    if (!std.mem.eql(u8, maybe.fields[1].name, "result")) {
+        @compileError("Expected the second field of the Maybe type to be \"result\"" ++ maybe.fields[1].name);
+    }
+
+    return maybe.fields[1].type;
+}
+
 pub fn ReturnOf(comptime function: anytype) type {
     return ReturnOfType(@TypeOf(function));
 }
@@ -17,8 +60,8 @@ pub fn typeName(comptime Type: type) []const u8 {
     return typeBaseName(name);
 }
 
-// partially emulates behaviour of @typeName in previous Zig versions,
-// converting "some.namespace.MyType" to "MyType"
+/// partially emulates behaviour of @typeName in previous Zig versions,
+/// converting "some.namespace.MyType" to "MyType"
 pub fn typeBaseName(comptime fullname: [:0]const u8) [:0]const u8 {
     // leave type name like "namespace.WrapperType(namespace.MyType)" as it is
     const baseidx = comptime std.mem.indexOf(u8, fullname, "(");
@@ -74,3 +117,208 @@ pub fn Item(comptime T: type) type {
         else => return std.meta.Child(T),
     }
 }
+
+/// Returns .{a, ...args_}
+pub fn ConcatArgs1(
+    comptime func: anytype,
+    a: anytype,
+    args_: anytype,
+) std.meta.ArgsTuple(@TypeOf(func)) {
+    var args: std.meta.ArgsTuple(@TypeOf(func)) = undefined;
+    args[0] = a;
+
+    inline for (args_, 1..) |arg, i| {
+        args[i] = arg;
+    }
+
+    return args;
+}
+
+/// Returns .{a, b, ...args_}
+pub inline fn ConcatArgs2(
+    comptime func: anytype,
+    a: anytype,
+    b: anytype,
+    args_: anytype,
+) std.meta.ArgsTuple(@TypeOf(func)) {
+    var args: std.meta.ArgsTuple(@TypeOf(func)) = undefined;
+    args[0] = a;
+    args[1] = b;
+
+    inline for (args_, 2..) |arg, i| {
+        args[i] = arg;
+    }
+
+    return args;
+}
+
+/// Returns .{a, b, c, d, ...args_}
+pub inline fn ConcatArgs4(
+    comptime func: anytype,
+    a: anytype,
+    b: anytype,
+    c: anytype,
+    d: anytype,
+    args_: anytype,
+) std.meta.ArgsTuple(@TypeOf(func)) {
+    var args: std.meta.ArgsTuple(@TypeOf(func)) = undefined;
+    args[0] = a;
+    args[1] = b;
+    args[2] = c;
+    args[3] = d;
+
+    inline for (args_, 4..) |arg, i| {
+        args[i] = arg;
+    }
+
+    return args;
+}
+
+// Copied from std.meta
+fn CreateUniqueTuple(comptime N: comptime_int, comptime types: [N]type) type {
+    var tuple_fields: [types.len]std.builtin.Type.StructField = undefined;
+    inline for (types, 0..) |T, i| {
+        @setEvalBranchQuota(10_000);
+        var num_buf: [128]u8 = undefined;
+        tuple_fields[i] = .{
+            .name = std.fmt.bufPrintZ(&num_buf, "{d}", .{i}) catch unreachable,
+            .type = T,
+            .default_value = null,
+            .is_comptime = false,
+            .alignment = if (@sizeOf(T) > 0) @alignOf(T) else 0,
+        };
+    }
+
+    return @Type(.{
+        .Struct = .{
+            .is_tuple = true,
+            .layout = .auto,
+            .decls = &.{},
+            .fields = &tuple_fields,
+        },
+    });
+}
+
+pub fn hasStableMemoryLayout(comptime T: type) bool {
+    const tyinfo = @typeInfo(T);
+    return switch (tyinfo) {
+        .Type => true,
+        .Void => true,
+        .Bool => true,
+        .Int => true,
+        .Float => true,
+        .Enum => {
+            // not supporting this rn
+            if (tyinfo.Enum.is_exhaustive) return false;
+            return hasStableMemoryLayout(tyinfo.Enum.tag_type);
+        },
+        .Struct => switch (tyinfo.Struct.layout) {
+            .auto => {
+                inline for (tyinfo.Struct.fields) |field| {
+                    if (!hasStableMemoryLayout(field.field_type)) return false;
+                }
+                return true;
+            },
+            .@"extern" => true,
+            .@"packed" => false,
+        },
+        .Union => switch (tyinfo.Union.layout) {
+            .auto => {
+                if (tyinfo.Union.tag_type == null or !hasStableMemoryLayout(tyinfo.Union.tag_type.?)) return false;
+
+                inline for (tyinfo.Union.fields) |field| {
+                    if (!hasStableMemoryLayout(field.type)) return false;
+                }
+
+                return true;
+            },
+            .@"extern" => true,
+            .@"packed" => false,
+        },
+        else => true,
+    };
+}
+
+pub fn isSimpleCopyType(comptime T: type) bool {
+    const tyinfo = @typeInfo(T);
+    return switch (tyinfo) {
+        .Void => true,
+        .Bool => true,
+        .Int => true,
+        .Float => true,
+        .Enum => true,
+        .Struct => {
+            inline for (tyinfo.Struct.fields) |field| {
+                if (!isSimpleCopyType(field.type)) return false;
+            }
+            return true;
+        },
+        .Union => {
+            inline for (tyinfo.Union.fields) |field| {
+                if (!isSimpleCopyType(field.type)) return false;
+            }
+            return true;
+        },
+        .Optional => return isSimpleCopyType(tyinfo.Optional.child),
+        else => false,
+    };
+}
+
+pub fn isScalar(comptime T: type) bool {
+    return switch (T) {
+        i32, u32, i64, u64, f32, f64, bool => true,
+        else => {
+            const tyinfo = @typeInfo(T);
+            if (tyinfo == .Enum) return true;
+            return false;
+        },
+    };
+}
+
+pub fn isSimpleEqlType(comptime T: type) bool {
+    const tyinfo = @typeInfo(T);
+    return switch (tyinfo) {
+        .Type => true,
+        .Void => true,
+        .Bool => true,
+        .Int => true,
+        .Float => true,
+        .Enum => true,
+        else => false,
+    };
+}
+
+pub const ListContainerType = enum {
+    array_list,
+    baby_list,
+    small_list,
+};
+pub fn looksLikeListContainerType(comptime T: type) ?struct { list: ListContainerType, child: type } {
+    const tyinfo = @typeInfo(T);
+    if (tyinfo == .Struct) {
+        // Looks like array list
+        if (tyinfo.Struct.fields.len == 2 and
+            std.mem.eql(u8, tyinfo.Struct.fields[0].name, "items") and
+            std.mem.eql(u8, tyinfo.Struct.fields[1].name, "capacity"))
+            return .{ .list = .array_list, .child = std.meta.Child(tyinfo.Struct.fields[0].type) };
+
+        // Looks like babylist
+        if (tyinfo.Struct.fields.len == 3 and
+            std.mem.eql(u8, tyinfo.Struct.fields[0].name, "ptr") and
+            std.mem.eql(u8, tyinfo.Struct.fields[1].name, "len") and
+            std.mem.eql(u8, tyinfo.Struct.fields[2].name, "cap"))
+            return .{ .list = .baby_list, .child = std.meta.Child(tyinfo.Struct.fields[0].type) };
+
+        // Looks like SmallList
+        if (tyinfo.Struct.fields.len == 2 and
+            std.mem.eql(u8, tyinfo.Struct.fields[0].name, "capacity") and
+            std.mem.eql(u8, tyinfo.Struct.fields[1].name, "data")) return .{
+            .list = .small_list,
+            .child = std.meta.Child(
+                @typeInfo(tyinfo.Struct.fields[1].type).Union.fields[0].type,
+            ),
+        };
+    }
+
+    return null;
+}
diff --git a/src/mimalloc_arena.zig b/src/mimalloc_arena.zig
index 1c2db8c09d..d44ba21b76 100644
--- a/src/mimalloc_arena.zig
+++ b/src/mimalloc_arena.zig
@@ -150,9 +150,9 @@ pub const Arena = struct {
     }
 
     pub fn deinit(this: *Arena) void {
-        if (comptime Environment.isDebug) {
-            ArenaRegistry.unregister(this.*);
-        }
+        // if (comptime Environment.isDebug) {
+        //     ArenaRegistry.unregister(this.*);
+        // }
         mimalloc.mi_heap_destroy(this.heap.?);
 
         this.heap = null;
@@ -187,9 +187,9 @@ pub const Arena = struct {
 
     pub fn init() !Arena {
         const arena = Arena{ .heap = mimalloc.mi_heap_new() orelse return error.OutOfMemory };
-        if (comptime Environment.isDebug) {
-            ArenaRegistry.register(arena);
-        }
+        // if (comptime Environment.isDebug) {
+        //     ArenaRegistry.register(arena);
+        // }
         return arena;
     }
 
@@ -197,6 +197,13 @@ pub const Arena = struct {
         mimalloc.mi_heap_collect(this.heap orelse return, force);
     }
 
+    pub inline fn helpCatchMemoryIssues(this: Arena) void {
+        if (comptime FeatureFlags.help_catch_memory_issues) {
+            this.gc(true);
+            bun.Mimalloc.mi_collect(true);
+        }
+    }
+
     pub fn ownsPtr(this: Arena, ptr: *const anyopaque) bool {
         return mimalloc.mi_heap_check_owned(this.heap.?, ptr);
     }
diff --git a/src/napi/napi.zig b/src/napi/napi.zig
index 96d1fe096d..c8d735d0b2 100644
--- a/src/napi/napi.zig
+++ b/src/napi/napi.zig
@@ -65,25 +65,35 @@ pub const Ref = opaque {
     extern fn napi_set_ref(ref: *Ref, value: JSC.JSValue) void;
 };
 pub const NapiHandleScope = opaque {
-    pub extern fn NapiHandleScope__push(globalObject: *JSC.JSGlobalObject, escapable: bool) ?*NapiHandleScope;
-    pub extern fn NapiHandleScope__pop(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;
+    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: JSValue) void;
+    extern fn NapiHandleScope__escape(handleScope: *NapiHandleScope, value: JSValue) bool;
 
-    pub fn push(env: napi_env, escapable: bool) ?*NapiHandleScope {
-        return NapiHandleScope__push(env, escapable);
+    /// Create a new handle scope in the given environment, or return null if creating one now is
+    /// unsafe (i.e. inside a finalizer)
+    pub fn open(env: napi_env, escapable: bool) ?*NapiHandleScope {
+        return NapiHandleScope__open(env, escapable);
     }
 
-    pub fn pop(self: ?*NapiHandleScope, env: napi_env) void {
-        NapiHandleScope__pop(env, self);
+    /// Closes the given handle scope, releasing all values inside it, if it is safe to do so.
+    /// Asserts that self is the current handle scope in env.
+    pub fn close(self: ?*NapiHandleScope, env: napi_env) void {
+        NapiHandleScope__close(env, self);
     }
 
+    /// Place a value in the handle scope. Must be done while returning any JS value into NAPI
+    /// 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;
         }
     }
@@ -96,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(
@@ -118,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,
@@ -235,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,
 };
@@ -286,29 +278,17 @@ pub export fn napi_create_array(env: napi_env, result_: ?*napi_value) napi_statu
     result.set(env, JSValue.createEmptyArray(env, 0));
     return .ok;
 }
-const prefilled_undefined_args_array: [128]JSC.JSValue = brk: {
-    var args: [128]JSC.JSValue = undefined;
-    for (args, 0..) |_, i| {
-        args[i] = JSValue.jsUndefined();
-    }
-    break :brk args;
-};
 pub export fn napi_create_array_with_length(env: napi_env, length: usize, result_: ?*napi_value) napi_status {
     log("napi_create_array_with_length", .{});
     const result = result_ orelse {
         return invalidArg();
     };
 
-    const len = @as(u32, @intCast(length));
+    // JSC createEmptyArray takes u32
+    // Node and V8 convert out-of-bounds array sizes to 0
+    const len = std.math.cast(u32, length) orelse 0;
 
     const array = JSC.JSValue.createEmptyArray(env, len);
-    array.ensureStillAlive();
-
-    var i: u32 = 0;
-    while (i < len) : (i += 1) {
-        array.putIndex(env, i, JSValue.jsUndefined());
-    }
-
     array.ensureStillAlive();
     result.set(env, array);
     return .ok;
@@ -438,42 +418,9 @@ pub extern fn napi_create_type_error(env: napi_env, code: napi_value, msg: napi_
 pub extern fn napi_create_range_error(env: napi_env, code: napi_value, msg: napi_value, result: *napi_value) napi_status;
 pub extern fn napi_typeof(env: napi_env, value: napi_value, result: *napi_valuetype) napi_status;
 pub extern fn napi_get_value_double(env: napi_env, value: napi_value, result: *f64) napi_status;
-pub export fn napi_get_value_int32(_: napi_env, value_: napi_value, result_: ?*i32) napi_status {
-    log("napi_get_value_int32", .{});
-    const result = result_ orelse {
-        return invalidArg();
-    };
-    const value = value_.get();
-    if (!value.isNumber()) {
-        return .number_expected;
-    }
-    result.* = value.to(i32);
-    return .ok;
-}
-pub export fn napi_get_value_uint32(_: napi_env, value_: napi_value, result_: ?*u32) napi_status {
-    log("napi_get_value_uint32", .{});
-    const result = result_ orelse {
-        return invalidArg();
-    };
-    const value = value_.get();
-    if (!value.isNumber()) {
-        return .number_expected;
-    }
-    result.* = value.to(u32);
-    return .ok;
-}
-pub export fn napi_get_value_int64(_: napi_env, value_: napi_value, result_: ?*i64) napi_status {
-    log("napi_get_value_int64", .{});
-    const result = result_ orelse {
-        return invalidArg();
-    };
-    const value = value_.get();
-    if (!value.isNumber()) {
-        return .number_expected;
-    }
-    result.* = value.to(i64);
-    return .ok;
-}
+pub extern fn napi_get_value_int32(_: napi_env, value_: napi_value, result: ?*i32) napi_status;
+pub extern fn napi_get_value_uint32(_: napi_env, value_: napi_value, result_: ?*u32) napi_status;
+pub extern fn napi_get_value_int64(_: napi_env, value_: napi_value, result_: ?*i64) napi_status;
 pub export fn napi_get_value_bool(_: napi_env, value_: napi_value, result_: ?*bool) napi_status {
     log("napi_get_value_bool", .{});
     const result = result_ orelse {
@@ -652,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;
@@ -749,14 +696,14 @@ pub export fn napi_open_handle_scope(env: napi_env, result_: ?*napi_handle_scope
     const result = result_ orelse {
         return invalidArg();
     };
-    result.* = NapiHandleScope.push(env, false);
+    result.* = NapiHandleScope.open(env, false);
     return .ok;
 }
 
 pub export fn napi_close_handle_scope(env: napi_env, handle_scope: napi_handle_scope) napi_status {
     log("napi_close_handle_scope", .{});
     if (handle_scope) |scope| {
-        scope.pop(env);
+        scope.close(env);
     }
 
     return .ok;
@@ -812,7 +759,7 @@ pub export fn napi_make_callback(env: napi_env, _: *anyopaque, recv_: napi_value
 // We don't want to fail to load the library because of that
 // so we instead return an error and warn the user
 fn notImplementedYet(comptime name: []const u8) void {
-    bun.once(
+    bun.onceUnsafe(
         struct {
             pub fn warn() void {
                 if (JSC.VirtualMachine.get().log.level.atLeast(.warn)) {
@@ -830,13 +777,13 @@ pub export fn napi_open_escapable_handle_scope(env: napi_env, result_: ?*napi_es
     const result = result_ orelse {
         return invalidArg();
     };
-    result.* = NapiHandleScope.push(env, true);
+    result.* = NapiHandleScope.open(env, true);
     return .ok;
 }
 pub export fn napi_close_escapable_handle_scope(env: napi_env, scope: napi_escapable_handle_scope) napi_status {
     log("napi_close_escapable_handle_scope", .{});
     if (scope) |s| {
-        s.pop(env);
+        s.close(env);
     }
     return .ok;
 }
@@ -852,16 +799,8 @@ pub export fn napi_escape_handle(_: napi_env, scope_: napi_escapable_handle_scop
     result.* = escapee;
     return .ok;
 }
-pub export fn napi_type_tag_object(_: napi_env, _: napi_value, _: [*c]const napi_type_tag) napi_status {
-    log("napi_type_tag_object", .{});
-    notImplementedYet("napi_type_tag_object");
-    return genericFailure();
-}
-pub export fn napi_check_object_type_tag(_: napi_env, _: napi_value, _: [*c]const napi_type_tag, _: *bool) napi_status {
-    log("napi_check_object_type_tag", .{});
-    notImplementedYet("napi_check_object_type_tag");
-    return genericFailure();
-}
+pub extern fn napi_type_tag_object(_: napi_env, _: napi_value, _: [*c]const napi_type_tag) napi_status;
+pub extern fn napi_check_object_type_tag(_: napi_env, _: napi_value, _: [*c]const napi_type_tag, _: *bool) napi_status;
 
 // do nothing for both of these
 pub export fn napi_open_callback_scope(_: napi_env, _: napi_value, _: *anyopaque, _: *anyopaque) napi_status {
@@ -1047,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();
     }
 
@@ -1202,9 +1141,9 @@ pub const napi_async_work = struct {
         this.wait_for_deinit = true;
     }
 
-    pub fn runFromJS(this: *napi_async_work) void {
-        const handle_scope = NapiHandleScope.push(this.global, false);
-        defer if (handle_scope) |scope| scope.pop(this.global);
+    fn runFromJSWithError(this: *napi_async_work) bun.JSError!void {
+        const handle_scope = NapiHandleScope.open(this.global, false);
+        defer if (handle_scope) |scope| scope.close(this.global);
         this.complete.?(
             this.global,
             if (this.status.load(.seq_cst) == @intFromEnum(Status.cancelled))
@@ -1213,6 +1152,15 @@ pub const napi_async_work = struct {
                 napi_status.ok,
             this.ctx.?,
         );
+        if (this.global.hasException()) {
+            return error.JSError;
+        }
+    }
+
+    pub fn runFromJS(this: *napi_async_work) void {
+        this.runFromJSWithError() catch |e| {
+            this.global.reportActiveExceptionAsUnhandled(e);
+        };
     }
 };
 pub const napi_threadsafe_function = *ThreadSafeFunction;
@@ -1460,11 +1408,19 @@ pub const Finalizer = struct {
 // TODO: generate comptime version of this instead of runtime checking
 pub const ThreadSafeFunction = struct {
     pub const Callback = union(enum) {
-        js: JSValue,
+        js: JSC.Strong,
         c: struct {
-            js: JSValue,
+            js: JSC.Strong,
             napi_threadsafe_function_call_js: napi_threadsafe_function_call_js,
         },
+
+        pub fn deinit(this: *Callback) void {
+            if (this.* == .js) {
+                this.js.deinit();
+            } else if (this.* == .c) {
+                this.c.js.deinit();
+            }
+        }
     };
     /// thread-safe functions can be "referenced" and "unreferenced". A
     /// "referenced" thread-safe function will cause the event loop on the thread
@@ -1478,148 +1434,244 @@ pub const ThreadSafeFunction = struct {
     /// prevent it from being destroyed.
     poll_ref: Async.KeepAlive,
 
-    thread_count: usize = 0,
-    owning_thread_lock: Lock = .{},
+    // User implementation error can cause this number to go negative.
+    thread_count: std.atomic.Value(i64) = std.atomic.Value(i64).init(0),
+    lock: std.Thread.Mutex = .{},
     event_loop: *JSC.EventLoop,
     tracker: JSC.AsyncTaskTracker,
 
     env: napi_env,
 
     finalizer: Finalizer = Finalizer{ .fun = null, .data = null },
-    channel: Queue,
+    has_queued_finalizer: bool = false,
+    queue: Queue = .{
+        .data = std.fifo.LinearFifo(?*anyopaque, .Dynamic).init(bun.default_allocator),
+        .max_queue_size = 0,
+    },
 
     ctx: ?*anyopaque = null,
 
     callback: Callback = undefined,
+    dispatch_state: DispatchState.Atomic = DispatchState.Atomic.init(.idle),
+    blocking_condvar: std.Thread.Condition = .{},
+    closing: std.atomic.Value(ClosingState) = std.atomic.Value(ClosingState).init(.not_closing),
+    aborted: std.atomic.Value(bool) = std.atomic.Value(bool).init(true),
 
-    const ThreadSafeFunctionTask = JSC.AnyTask.New(@This(), call);
-    pub const Queue = union(enum) {
-        sized: Channel(?*anyopaque, .Slice),
-        unsized: Channel(?*anyopaque, .Dynamic),
+    pub usingnamespace bun.New(ThreadSafeFunction);
 
-        pub fn isClosed(this: *const @This()) bool {
-            return @atomicLoad(
-                bool,
-                switch (this.*) {
-                    .sized => &this.sized.is_closed,
-                    .unsized => &this.unsized.is_closed,
-                },
-                .seq_cst,
-            );
+    const ClosingState = enum(u8) {
+        not_closing,
+        closing,
+        closed,
+    };
+
+    pub const DispatchState = enum(u8) {
+        idle,
+        running,
+        pending,
+
+        pub const Atomic = std.atomic.Value(DispatchState);
+    };
+
+    pub const Queue = struct {
+        data: std.fifo.LinearFifo(?*anyopaque, .Dynamic),
+
+        /// This value will never change after initialization. Zero means the size is unlimited.
+        max_queue_size: usize,
+
+        count: std.atomic.Value(u32) = std.atomic.Value(u32).init(0),
+
+        pub fn init(max_queue_size: usize, allocator: std.mem.Allocator) Queue {
+            return .{ .data = std.fifo.LinearFifo(?*anyopaque, .Dynamic).init(allocator), .max_queue_size = max_queue_size };
         }
 
-        pub fn close(this: *@This()) void {
-            switch (this.*) {
-                .sized => this.sized.close(),
-                .unsized => this.unsized.close(),
-            }
+        pub fn deinit(this: *Queue) void {
+            this.data.deinit();
         }
 
-        pub fn init(size: usize, allocator: std.mem.Allocator) @This() {
-            switch (size) {
-                0 => {
-                    return .{
-                        .unsized = Channel(?*anyopaque, .Dynamic).init(allocator),
-                    };
-                },
-                else => {
-                    const slice = allocator.alloc(?*anyopaque, size) catch unreachable;
-                    return .{
-                        .sized = Channel(?*anyopaque, .Slice).init(slice),
-                    };
-                },
-            }
-        }
-
-        pub fn writeItem(this: *@This(), value: ?*anyopaque) !void {
-            switch (this.*) {
-                .sized => try this.sized.writeItem(value),
-                .unsized => try this.unsized.writeItem(value),
-            }
-        }
-
-        pub fn readItem(this: *@This()) !?*anyopaque {
-            return switch (this.*) {
-                .sized => try this.sized.readItem(),
-                .unsized => try this.unsized.readItem(),
-            };
-        }
-
-        pub fn tryWriteItem(this: *@This(), value: ?*anyopaque) !bool {
-            return switch (this.*) {
-                .sized => try this.sized.tryWriteItem(value),
-                .unsized => try this.unsized.tryWriteItem(value),
-            };
-        }
-
-        pub fn tryReadItem(this: *@This()) !??*anyopaque {
-            return switch (this.*) {
-                .sized => try this.sized.tryReadItem(),
-                .unsized => try this.unsized.tryReadItem(),
-            };
+        pub fn isBlocked(this: *const Queue) bool {
+            return this.max_queue_size > 0 and this.count.load(.seq_cst) >= this.max_queue_size;
         }
     };
 
-    pub fn call(this: *ThreadSafeFunction) void {
-        const task = this.channel.tryReadItem() catch null orelse return;
+    // This has two states:
+    // 1. We need to run potentially multiple tasks.
+    // 2. We need to finalize the ThreadSafeFunction.
+    pub fn onDispatch(this: *ThreadSafeFunction) void {
+        if (this.closing.load(.seq_cst) == .closed) {
+            // Finalize the ThreadSafeFunction.
+            this.deinit();
+            return;
+        }
+
+        var is_first = true;
+
+        // Run the tasks.
+        while (true) {
+            this.dispatch_state.store(.running, .seq_cst);
+            if (this.dispatchOne(is_first)) {
+                is_first = false;
+                this.dispatch_state.store(.pending, .seq_cst);
+            } else {
+                // We're done running tasks, for now.
+                this.dispatch_state.store(.idle, .seq_cst);
+                break;
+            }
+        }
+
+        // Node sets a maximum number of runs per ThreadSafeFunction to 1,000.
+        // We don't set a max. I would like to see an issue caused by not
+        // setting a max before we do set a max. It is better for performance to
+        // not add unnecessary event loop ticks.
+    }
+
+    pub fn isClosing(this: *const ThreadSafeFunction) bool {
+        return this.closing.load(.seq_cst) != .not_closing;
+    }
+
+    fn maybeQueueFinalizer(this: *ThreadSafeFunction) void {
+        switch (this.closing.swap(.closed, .seq_cst)) {
+            .closing, .not_closing => {
+                // TODO: is this boolean necessary? Can we rely just on the closing value?
+                if (!this.has_queued_finalizer) {
+                    this.has_queued_finalizer = true;
+                    this.callback.deinit();
+                    this.poll_ref.disable();
+                    this.event_loop.enqueueTask(JSC.Task.init(this));
+                }
+            },
+            .closed => {
+                // already scheduled.
+            },
+        }
+    }
+
+    pub fn dispatchOne(this: *ThreadSafeFunction, is_first: bool) bool {
+        var queue_finalizer_after_call = false;
+        const has_more, const task = brk: {
+            this.lock.lock();
+            defer this.lock.unlock();
+            const was_blocked = this.queue.isBlocked();
+            const t = this.queue.data.readItem() orelse {
+                // When there are no tasks and the number of threads that have
+                // references reaches zero, we prepare to finalize the
+                // ThreadSafeFunction.
+                if (this.thread_count.load(.seq_cst) == 0) {
+                    if (this.queue.max_queue_size > 0) {
+                        this.blocking_condvar.signal();
+                    }
+                    this.maybeQueueFinalizer();
+                }
+                return false;
+            };
+
+            if (this.queue.count.fetchSub(1, .seq_cst) == 1 and this.thread_count.load(.seq_cst) == 0) {
+                this.closing.store(.closing, .seq_cst);
+                if (this.queue.max_queue_size > 0) {
+                    this.blocking_condvar.signal();
+                }
+                queue_finalizer_after_call = true;
+            } else if (was_blocked and !this.queue.isBlocked()) {
+                this.blocking_condvar.signal();
+            }
+
+            break :brk .{ !this.isClosing(), t };
+        };
+
+        this.call(task, !is_first);
+
+        if (queue_finalizer_after_call) {
+            this.maybeQueueFinalizer();
+        }
+
+        return has_more;
+    }
+
+    /// This function can be called multiple times in one tick of the event loop.
+    /// See: https://github.com/nodejs/node/pull/38506
+    /// In that case, we need to drain microtasks.
+    fn call(this: *ThreadSafeFunction, task: ?*anyopaque, is_first: bool) void {
         const globalObject = this.env;
+        if (!is_first) {
+            this.event_loop.drainMicrotasks();
+        }
 
         this.tracker.willDispatch(globalObject);
         defer this.tracker.didDispatch(globalObject);
 
         switch (this.callback) {
-            .js => |js_function| {
-                if (js_function.isEmptyOrUndefinedOrNull()) {
+            .js => |strong| {
+                const js = strong.get() orelse .undefined;
+                if (js.isEmptyOrUndefinedOrNull()) {
                     return;
                 }
 
-                _ = js_function.call(globalObject, .undefined, &.{}) catch |err|
+                _ = js.call(globalObject, .undefined, &.{}) catch |err|
                     globalObject.reportActiveExceptionAsUnhandled(err);
             },
             .c => |cb| {
-                if (comptime bun.Environment.isDebug) {
-                    const str = cb.js.toBunString(globalObject);
-                    defer str.deref();
-                    log("call() {}", .{str});
-                }
+                const js = cb.js.get() orelse .undefined;
 
-                const handle_scope = NapiHandleScope.push(globalObject, false);
-                defer if (handle_scope) |scope| scope.pop(globalObject);
-                cb.napi_threadsafe_function_call_js(globalObject, napi_value.create(globalObject, cb.js), this.ctx, task);
+                const handle_scope = NapiHandleScope.open(globalObject, false);
+                defer if (handle_scope) |scope| scope.close(globalObject);
+                cb.napi_threadsafe_function_call_js(globalObject, napi_value.create(globalObject, js), this.ctx, task);
             },
         }
     }
 
-    pub fn enqueue(this: *ThreadSafeFunction, ctx: ?*anyopaque, block: bool) !void {
+    pub fn enqueue(this: *ThreadSafeFunction, ctx: ?*anyopaque, block: bool) napi_status {
+        this.lock.lock();
+        defer this.lock.unlock();
         if (block) {
-            try this.channel.writeItem(ctx);
+            while (this.queue.isBlocked()) {
+                this.blocking_condvar.wait(&this.lock);
+            }
         } else {
-            if (!try this.channel.tryWriteItem(ctx)) {
-                return error.WouldBlock;
+            if (this.queue.isBlocked()) {
+                return .queue_full;
             }
         }
 
-        this.event_loop.enqueueTaskConcurrent(JSC.ConcurrentTask.createFrom(this));
+        if (this.isClosing()) {
+            if (this.thread_count.load(.seq_cst) <= 0) {
+                return .invalid_arg;
+            }
+            _ = this.release(.release, true);
+            return .closing;
+        }
+
+        _ = this.queue.count.fetchAdd(1, .seq_cst);
+        this.queue.data.writeItem(ctx) catch bun.outOfMemory();
+        this.scheduleDispatch();
+        return .ok;
     }
 
-    pub fn finalize(opaq: *anyopaque) void {
-        var this = bun.cast(*ThreadSafeFunction, opaq);
+    fn scheduleDispatch(this: *ThreadSafeFunction) void {
+        switch (this.dispatch_state.swap(.pending, .seq_cst)) {
+            .idle => {
+                this.event_loop.enqueueTaskConcurrent(JSC.ConcurrentTask.createFrom(this));
+            },
+            .running => {
+                // it will check if it has more work to do
+            },
+            .pending => {
+                // we've already scheduled it to run
+            },
+        }
+    }
+
+    pub fn deinit(this: *ThreadSafeFunction) void {
         this.unref();
 
         if (this.finalizer.fun) |fun| {
+            const handle_scope = NapiHandleScope.open(this.env, false);
+            defer if (handle_scope) |scope| scope.close(this.env);
             fun(this.event_loop.global, this.finalizer.data, this.ctx);
         }
 
-        if (this.callback == .js) {
-            if (!this.callback.js.isEmptyOrUndefinedOrNull()) {
-                this.callback.js.unprotect();
-            }
-        } else if (this.callback == .c) {
-            if (!this.callback.c.js.isEmptyOrUndefinedOrNull()) {
-                this.callback.c.js.unprotect();
-            }
-        }
-        bun.default_allocator.destroy(this);
+        this.callback.deinit();
+        this.queue.deinit();
+        this.destroy();
     }
 
     pub fn ref(this: *ThreadSafeFunction) void {
@@ -1630,34 +1682,37 @@ pub const ThreadSafeFunction = struct {
         this.poll_ref.unrefConcurrentlyFromEventLoop(this.event_loop);
     }
 
-    pub fn acquire(this: *ThreadSafeFunction) !void {
-        this.owning_thread_lock.lock();
-        defer this.owning_thread_lock.unlock();
-        if (this.channel.isClosed())
-            return error.Closed;
-        this.thread_count += 1;
+    pub fn acquire(this: *ThreadSafeFunction) napi_status {
+        this.lock.lock();
+        defer this.lock.unlock();
+        if (this.isClosing()) {
+            return .closing;
+        }
+        _ = this.thread_count.fetchAdd(1, .seq_cst);
+        return .ok;
     }
 
-    pub fn release(this: *ThreadSafeFunction, mode: napi_threadsafe_function_release_mode) napi_status {
-        this.owning_thread_lock.lock();
-        defer this.owning_thread_lock.unlock();
+    pub fn release(this: *ThreadSafeFunction, mode: napi_threadsafe_function_release_mode, already_locked: bool) napi_status {
+        if (!already_locked) this.lock.lock();
+        defer if (!already_locked) this.lock.unlock();
 
-        if (this.thread_count == 0) {
-            return invalidArg();
+        if (this.thread_count.load(.seq_cst) < 0) {
+            return .invalid_arg;
         }
 
-        this.thread_count -= 1;
+        const prev_remaining = this.thread_count.fetchSub(1, .seq_cst);
 
-        if (this.channel.isClosed()) {
-            return .ok;
-        }
-
-        if (mode == .abort) {
-            this.channel.close();
-        }
-
-        if (mode == .abort or this.thread_count == 0) {
-            this.event_loop.enqueueTaskConcurrent(JSC.ConcurrentTask.fromCallback(this, finalize));
+        if (mode == .abort or prev_remaining == 1) {
+            if (!this.isClosing()) {
+                if (mode == .abort) {
+                    this.closing.store(.closing, .seq_cst);
+                    this.aborted.store(true, .seq_cst);
+                    if (this.queue.max_queue_size > 0) {
+                        this.blocking_condvar.signal();
+                    }
+                }
+                this.scheduleDispatch();
+            }
         }
 
         return .ok;
@@ -1687,29 +1742,24 @@ pub export fn napi_create_threadsafe_function(
         return napi_status.function_expected;
     }
 
-    if (!func.isEmptyOrUndefinedOrNull()) {
-        func.protect();
-    }
-
     const vm = env.bunVM();
-    var function = bun.default_allocator.create(ThreadSafeFunction) catch return genericFailure();
-    function.* = .{
+    var function = ThreadSafeFunction.new(.{
         .event_loop = vm.eventLoop(),
         .env = env,
         .callback = if (call_js_cb) |c| .{
             .c = .{
                 .napi_threadsafe_function_call_js = c,
-                .js = if (func == .zero) .undefined else func.withAsyncContextIfNeeded(env),
+                .js = if (func == .zero) .{} else JSC.Strong.create(func.withAsyncContextIfNeeded(env), vm.global),
             },
         } else .{
-            .js = if (func == .zero) .undefined else func.withAsyncContextIfNeeded(env),
+            .js = if (func == .zero) .{} else JSC.Strong.create(func.withAsyncContextIfNeeded(env), vm.global),
         },
         .ctx = context,
-        .channel = ThreadSafeFunction.Queue.init(max_queue_size, bun.default_allocator),
-        .thread_count = initial_thread_count,
+        .queue = ThreadSafeFunction.Queue.init(max_queue_size, bun.default_allocator),
+        .thread_count = .{ .raw = @intCast(initial_thread_count) },
         .poll_ref = Async.KeepAlive.init(),
         .tracker = JSC.AsyncTaskTracker.init(vm),
-    };
+    });
 
     function.finalizer = .{ .data = thread_finalize_data, .fun = thread_finalize_cb };
     // nodejs by default keeps the event loop alive until the thread-safe function is unref'd
@@ -1726,25 +1776,15 @@ pub export fn napi_get_threadsafe_function_context(func: napi_threadsafe_functio
 }
 pub export fn napi_call_threadsafe_function(func: napi_threadsafe_function, data: ?*anyopaque, is_blocking: napi_threadsafe_function_call_mode) napi_status {
     log("napi_call_threadsafe_function", .{});
-    func.enqueue(data, is_blocking == napi_tsfn_blocking) catch |err| {
-        switch (err) {
-            error.WouldBlock => {
-                return napi_status.queue_full;
-            },
-
-            else => return .closing,
-        }
-    };
-    return .ok;
+    return func.enqueue(data, is_blocking == napi_tsfn_blocking);
 }
 pub export fn napi_acquire_threadsafe_function(func: napi_threadsafe_function) napi_status {
     log("napi_acquire_threadsafe_function", .{});
-    func.acquire() catch return .closing;
-    return .ok;
+    return func.acquire();
 }
 pub export fn napi_release_threadsafe_function(func: napi_threadsafe_function, mode: napi_threadsafe_function_release_mode) napi_status {
     log("napi_release_threadsafe_function", .{});
-    return func.release(mode);
+    return func.release(mode, false);
 }
 pub export fn napi_unref_threadsafe_function(env: napi_env, func: napi_threadsafe_function) napi_status {
     log("napi_unref_threadsafe_function", .{});
@@ -1770,11 +1810,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
 ///
@@ -1845,6 +1883,9 @@ const V8API = if (!bun.Environment.isWindows) struct {
     pub extern fn _ZNK2v86String19ContainsOnlyOneByteEv() *anyopaque;
     pub extern fn _ZN2v812api_internal18GlobalizeReferenceEPNS_8internal7IsolateEm() *anyopaque;
     pub extern fn _ZN2v812api_internal13DisposeGlobalEPm() *anyopaque;
+    pub extern fn _ZNK2v88Function7GetNameEv() *anyopaque;
+    pub extern fn _ZNK2v85Value10IsFunctionEv() *anyopaque;
+    pub extern fn _ZN2v812api_internal17FromJustIsNothingEv() *anyopaque;
     pub extern fn uv_os_getpid() *anyopaque;
     pub extern fn uv_os_getppid() *anyopaque;
 } else struct {
@@ -1913,15 +1954,161 @@ const V8API = if (!bun.Environment.isWindows) struct {
     pub extern fn @"?ContainsOnlyOneByte@String@v8@@QEBA_NXZ"() *anyopaque;
     pub extern fn @"?GlobalizeReference@api_internal@v8@@YAPEA_KPEAVIsolate@internal@2@_K@Z"() *anyopaque;
     pub extern fn @"?DisposeGlobal@api_internal@v8@@YAXPEA_K@Z"() *anyopaque;
+    pub extern fn @"?GetName@Function@v8@@QEBA?AV?$Local@VValue@v8@@@2@XZ"() *anyopaque;
+    pub extern fn @"?IsFunction@Value@v8@@QEBA_NXZ"() *anyopaque;
+    pub extern fn @"?FromJustIsNothing@api_internal@v8@@YAXXZ"() *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/node-fallbacks/README.md b/src/node-fallbacks/README.md
new file mode 100644
index 0000000000..d2c492a04a
--- /dev/null
+++ b/src/node-fallbacks/README.md
@@ -0,0 +1,11 @@
+# Browser polyfills for `bun build --target=browser`
+
+When using `bun build --target=browser`, if you attempt to import a Node.js module, Bun will load a polyfill for that module in an attempt to let your code still work even though it's not running in Node.js or a server.
+
+For example, if you import `zlib`, the `node-fallbacks/zlib.js` file will be loaded.
+
+## Not used by Bun's runtime
+
+These files are _not_ used by Bun's runtime. They are only used for the `bun build --target=browser` command.
+
+If you're interested in contributing to Bun's Node.js compatibility, please see the [`src/js` directory](https://github.com/oven-sh/bun/tree/main/src/js).
diff --git a/src/node-fallbacks/assert.js b/src/node-fallbacks/assert.js
index 3636f90e31..1e2e54d9da 100644
--- a/src/node-fallbacks/assert.js
+++ b/src/node-fallbacks/assert.js
@@ -1 +1,6 @@
+/**
+ * Browser polyfill for the `"assert"` module.
+ *
+ * Imported on usage in `bun build --target=browser`
+ */
 export * from "assert";
diff --git a/src/node-fallbacks/buffer.js b/src/node-fallbacks/buffer.js
index aa00653982..3de63bc9e9 100644
--- a/src/node-fallbacks/buffer.js
+++ b/src/node-fallbacks/buffer.js
@@ -1,2 +1,35 @@
-export * from "buffer";
-export { Buffer as default } from "buffer";
+/**
+ * Browser polyfill for the `"buffer"` module.
+ *
+ * Imported on usage in `bun build --target=browser`
+ */
+export * from "./node_modules/buffer";
+export { Buffer as default } from "./node_modules/buffer";
+export { Buffer } from "./node_modules/buffer";
+export var kStringMaxLength = 2 ** 32 - 1;
+export var { Blob, File, atob, btoa } = globalThis;
+export var { createObjectURL } = URL;
+export var isAscii = buf => {
+  if (ArrayBuffer.isView(buf)) {
+    return buf.every(byte => byte < 128);
+  } else {
+    return buf.split("").every(char => char.charCodeAt(0) < 128);
+  }
+};
+export var isUtf8 = buf => {
+  throw new Error("Not implemented");
+};
+export var constants = {
+  __proto__: null,
+  MAX_LENGTH: kStringMaxLength,
+  MAX_STRING_LENGTH: kStringMaxLength,
+  BYTES_PER_ELEMENT: 1,
+};
+
+export function resolveObjectURL(url) {
+  throw new Error("Not implemented");
+}
+
+export function transcode(buf, from, to) {
+  throw new Error("Not implemented");
+}
diff --git a/src/node-fallbacks/console.js b/src/node-fallbacks/console.js
index 34cc54b565..f988876f1a 100644
--- a/src/node-fallbacks/console.js
+++ b/src/node-fallbacks/console.js
@@ -1 +1,6 @@
+/**
+ * Browser polyfill for the `"console"` module.
+ *
+ * Imported on usage in `bun build --target=browser`
+ */
 export default console;
diff --git a/src/node-fallbacks/constants.js b/src/node-fallbacks/constants.js
index 5811eebd4e..2b1bbddf52 100644
--- a/src/node-fallbacks/constants.js
+++ b/src/node-fallbacks/constants.js
@@ -1 +1,7 @@
+/**
+ * Browser polyfill for the `"constants"` module.
+ *
+ * Imported on usage in `bun build --target=browser`
+ */
+
 export * from "constants-browserify";
diff --git a/src/node-fallbacks/crypto.js b/src/node-fallbacks/crypto.js
index 65ae2f5b3a..650a945cec 100644
--- a/src/node-fallbacks/crypto.js
+++ b/src/node-fallbacks/crypto.js
@@ -1,3 +1,9 @@
+/**
+ * Browser polyfill for the `"crypto"` module.
+ *
+ * Imported on usage in `bun build --target=browser`
+ */
+
 export * from "crypto-browserify";
 import * as cryptoBrowserify from "crypto-browserify";
 
diff --git a/src/node-fallbacks/domain.js b/src/node-fallbacks/domain.js
index af37e70595..58eef6aecc 100644
--- a/src/node-fallbacks/domain.js
+++ b/src/node-fallbacks/domain.js
@@ -1,3 +1,8 @@
+/**
+ * Browser polyfill for the `"domain"` module.
+ *
+ * Imported on usage in `bun build --target=browser`
+ */
 import domain from "domain-browser";
 export default domain;
 export var { create, createDomain } = domain;
diff --git a/src/node-fallbacks/events.js b/src/node-fallbacks/events.js
index 321f14c204..165fc3d6b4 100644
--- a/src/node-fallbacks/events.js
+++ b/src/node-fallbacks/events.js
@@ -1,3 +1,8 @@
+/**
+ * Browser polyfill for the `"events"` module.
+ *
+ * Imported on usage in `bun build --target=browser`
+ */
 // Copyright Joyent, Inc. and other Node contributors.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a
diff --git a/src/node-fallbacks/http.js b/src/node-fallbacks/http.js
index ab56f34ebe..46c23595c2 100644
--- a/src/node-fallbacks/http.js
+++ b/src/node-fallbacks/http.js
@@ -1,3 +1,8 @@
+/**
+ * Browser polyfill for the `"http"` module.
+ *
+ * Imported on usage in `bun build --target=browser`
+ */
 import http from "stream-http";
 export default http;
 export var {
diff --git a/src/node-fallbacks/https.js b/src/node-fallbacks/https.js
index d1de96beb4..228e9dd686 100644
--- a/src/node-fallbacks/https.js
+++ b/src/node-fallbacks/https.js
@@ -1,2 +1,7 @@
+/**
+ * Browser polyfill for the `"https"` module.
+ *
+ * Imported on usage in `bun build --target=browser`
+ */
 export * from "https-browserify";
 export * as default from "https-browserify";
diff --git a/src/node-fallbacks/net.js b/src/node-fallbacks/net.js
index d8dc432571..03221037fa 100644
--- a/src/node-fallbacks/net.js
+++ b/src/node-fallbacks/net.js
@@ -1,3 +1,9 @@
+/**
+ * Browser polyfill for the `"net"` module.
+ *
+ * Imported on usage in `bun build --target=browser`
+ */
+// -----------------------------------------------------------------------------
 // Copyright Joyent, Inc. and other Node contributors.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a
diff --git a/src/node-fallbacks/os.js b/src/node-fallbacks/os.js
index df0a41fd2b..ec627a9540 100644
--- a/src/node-fallbacks/os.js
+++ b/src/node-fallbacks/os.js
@@ -1,3 +1,9 @@
+/**
+ * Browser polyfill for the `"os"` module.
+ *
+ * Imported on usage in `bun build --target=browser`
+ */
+
 import os from "os-browserify/browser";
 export default os;
 export var {
diff --git a/src/node-fallbacks/path.js b/src/node-fallbacks/path.js
index a582c6d0f9..66e4d05ea2 100644
--- a/src/node-fallbacks/path.js
+++ b/src/node-fallbacks/path.js
@@ -1,2 +1,66 @@
-export * from "path-browserify";
-export * as default from "path-browserify";
+/**
+ * Browser polyfill for the `"path"` module.
+ *
+ * Imported on usage in `bun build --target=browser`
+ */
+import * as PathModule from "path-browserify";
+
+const bindingPosix = PathModule;
+const bindingWin32 = PathModule;
+
+// path-browserify doesn't implement toNamespacedPath
+const toNamespacedPathPosix = function (a) {
+  return a;
+};
+// path-browserify doesn't implement parse
+const parseFn = function () {
+  throw new Error("Not implemented");
+};
+
+bindingPosix.parse ??= parseFn;
+bindingWin32.parse ??= parseFn;
+
+export const posix = {
+  resolve: bindingPosix.resolve.bind(bindingPosix),
+  normalize: bindingPosix.normalize.bind(bindingPosix),
+  isAbsolute: bindingPosix.isAbsolute.bind(bindingPosix),
+  join: bindingPosix.join.bind(bindingPosix),
+  relative: bindingPosix.relative.bind(bindingPosix),
+  toNamespacedPath: toNamespacedPathPosix,
+  dirname: bindingPosix.dirname.bind(bindingPosix),
+  basename: bindingPosix.basename.bind(bindingPosix),
+  extname: bindingPosix.extname.bind(bindingPosix),
+  format: bindingPosix.format.bind(bindingPosix),
+  parse: bindingPosix.parse.bind(bindingPosix),
+  sep: "/",
+  delimiter: ":",
+  win32: undefined,
+  posix: undefined,
+  _makeLong: toNamespacedPathPosix,
+};
+export const win32 = {
+  sep: "\\",
+  delimiter: ";",
+  win32: undefined,
+  ...posix,
+  posix,
+};
+posix.win32 = win32.win32 = win32;
+posix.posix = posix;
+
+export default posix;
+export const {
+  resolve,
+  normalize,
+  isAbsolute,
+  join,
+  relative,
+  toNamespacedPath,
+  dirname,
+  basename,
+  extname,
+  format,
+  parse,
+  sep,
+  delimiter,
+} = posix;
diff --git a/src/node-fallbacks/process.js b/src/node-fallbacks/process.js
index fec4e652fb..17ebdf5381 100644
--- a/src/node-fallbacks/process.js
+++ b/src/node-fallbacks/process.js
@@ -1,2 +1,7 @@
+/**
+ * Browser polyfill for the `"process"` module.
+ *
+ * Imported on usage in `bun build --target=browser`
+ */
 export * from "process/browser";
 export * as default from "process/browser";
diff --git a/src/node-fallbacks/punycode.js b/src/node-fallbacks/punycode.js
index ef8f0464f7..31a3dabf76 100644
--- a/src/node-fallbacks/punycode.js
+++ b/src/node-fallbacks/punycode.js
@@ -1 +1,6 @@
+/**
+ * Browser polyfill for the `"punycode"` module.
+ *
+ * Imported on usage in `bun build --target=browser`
+ */
 export * from "punycode";
diff --git a/src/node-fallbacks/querystring.js b/src/node-fallbacks/querystring.js
index 8c71d38b8a..b58917f2e1 100644
--- a/src/node-fallbacks/querystring.js
+++ b/src/node-fallbacks/querystring.js
@@ -1 +1,6 @@
+/**
+ * Browser polyfill for the `"querystring"` module.
+ *
+ * Imported on usage in `bun build --target=browser`
+ */
 export { decode, default, encode, escape, parse, stringify, unescape, unescapeBuffer } from "querystring-es3";
diff --git a/src/node-fallbacks/stream.js b/src/node-fallbacks/stream.js
index bee941be19..65abe0ba41 100644
--- a/src/node-fallbacks/stream.js
+++ b/src/node-fallbacks/stream.js
@@ -1,2 +1,7 @@
+/**
+ * Browser polyfill for the `"stream"` module.
+ *
+ * Imported on usage in `bun build --target=browser`
+ */
 export * from "readable-stream";
 export * as default from "readable-stream";
diff --git a/src/node-fallbacks/string_decoder.js b/src/node-fallbacks/string_decoder.js
index 0def823f82..25ec353409 100644
--- a/src/node-fallbacks/string_decoder.js
+++ b/src/node-fallbacks/string_decoder.js
@@ -1 +1,6 @@
+/**
+ * Browser polyfill for the `"string_decoder"` module.
+ *
+ * Imported on usage in `bun build --target=browser`
+ */
 export { StringDecoder, StringDecoder as default } from "string_decoder";
diff --git a/src/node-fallbacks/sys.js b/src/node-fallbacks/sys.js
index 99f15c638b..228f88ec5a 100644
--- a/src/node-fallbacks/sys.js
+++ b/src/node-fallbacks/sys.js
@@ -1,2 +1,7 @@
+/**
+ * Browser polyfill for the `"sys"` module.
+ *
+ * Imported on usage in `bun build --target=browser`
+ */
 export * from "util";
 export * as default from "util";
diff --git a/src/node-fallbacks/timers.js b/src/node-fallbacks/timers.js
index c69274eef9..12cbf9b3bf 100644
--- a/src/node-fallbacks/timers.js
+++ b/src/node-fallbacks/timers.js
@@ -1,2 +1,7 @@
+/**
+ * Browser polyfill for the `"timers"` module.
+ *
+ * Imported on usage in `bun build --target=browser`
+ */
 export * from "timers-browserify";
 export * as default from "timers-browserify";
diff --git a/src/node-fallbacks/tty.js b/src/node-fallbacks/tty.js
index 3844312ca4..d0958436cc 100644
--- a/src/node-fallbacks/tty.js
+++ b/src/node-fallbacks/tty.js
@@ -1,3 +1,8 @@
+/**
+ * Browser polyfill for the `"tty"` module.
+ *
+ * Imported on usage in `bun build --target=browser`
+ */
 let isatty = () => false;
 function WriteStream() {
   throw new Error("tty.WriteStream is not implemented for browsers");
diff --git a/src/node-fallbacks/url.js b/src/node-fallbacks/url.js
index 571d30b934..f33990435e 100644
--- a/src/node-fallbacks/url.js
+++ b/src/node-fallbacks/url.js
@@ -1,3 +1,9 @@
+/**
+ * Browser polyfill for the `"url"` module.
+ *
+ * Imported on usage in `bun build --target=browser`
+ */
+// -----------------------------------------------------------------------------
 // Copyright Joyent, Inc. and other Node contributors.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a
diff --git a/src/node-fallbacks/util.js b/src/node-fallbacks/util.js
index 5973068686..c81d2bd7d4 100644
--- a/src/node-fallbacks/util.js
+++ b/src/node-fallbacks/util.js
@@ -1,3 +1,8 @@
+/**
+ * Browser polyfill for the `"util"` module.
+ *
+ * Imported on usage in `bun build --target=browser`
+ */
 export * from "util";
 
 const TextEncoder = globalThis.TextEncoder;
diff --git a/src/node-fallbacks/zlib.js b/src/node-fallbacks/zlib.js
index 093367e295..7904d47136 100644
--- a/src/node-fallbacks/zlib.js
+++ b/src/node-fallbacks/zlib.js
@@ -1,2 +1,7 @@
+/**
+ * Browser polyfill for the `"zlib"` module.
+ *
+ * Imported on usage in `bun build --target=browser`
+ */
 export * from "browserify-zlib";
 export * as default from "browserify-zlib";
diff --git a/src/node_fallbacks.zig b/src/node_fallbacks.zig
index 1bb9a91ae9..89998d3a13 100644
--- a/src/node_fallbacks.zig
+++ b/src/node_fallbacks.zig
@@ -4,433 +4,78 @@ const PackageJSON = @import("./resolver/package_json.zig").PackageJSON;
 const logger = bun.logger;
 const Fs = @import("./fs.zig");
 const bun = @import("root").bun;
+const Environment = bun.Environment;
 
-const assert_code: string = @embedFile("./node-fallbacks/out/assert.js");
-const buffer_code: string = @embedFile("./node-fallbacks/out/buffer.js");
-const console_code: string = @embedFile("./node-fallbacks/out/console.js");
-const constants_code: string = @embedFile("./node-fallbacks/out/constants.js");
-const crypto_code: string = @embedFile("./node-fallbacks/out/crypto.js");
-const domain_code: string = @embedFile("./node-fallbacks/out/domain.js");
-const events_code: string = @embedFile("./node-fallbacks/out/events.js");
-const http_code: string = @embedFile("./node-fallbacks/out/http.js");
-const https_code: string = @embedFile("./node-fallbacks/out/https.js");
-const net_code: string = @embedFile("./node-fallbacks/out/net.js");
-const os_code: string = @embedFile("./node-fallbacks/out/os.js");
-const path_code: string = @embedFile("./node-fallbacks/out/path.js");
-const process_code: string = @embedFile("./node-fallbacks/out/process.js");
-const punycode_code: string = @embedFile("./node-fallbacks/out/punycode.js");
-const querystring_code: string = @embedFile("./node-fallbacks/out/querystring.js");
-const stream_code: string = @embedFile("./node-fallbacks/out/stream.js");
-const string_decoder_code: string = @embedFile("./node-fallbacks/out/string_decoder.js");
-const sys_code: string = @embedFile("./node-fallbacks/out/sys.js");
-const timers_code: string = @embedFile("./node-fallbacks/out/timers.js");
-const tty_code: string = @embedFile("./node-fallbacks/out/tty.js");
-const url_code: string = @embedFile("./node-fallbacks/out/url.js");
-const util_code: string = @embedFile("./node-fallbacks/out/util.js");
-const zlib_code: string = @embedFile("./node-fallbacks/out/zlib.js");
+pub const import_path = "/bun-vfs$$/node_modules/";
 
-const assert_import_path = "/bun-vfs/node_modules/assert/index.js";
-const buffer_import_path = "/bun-vfs/node_modules/buffer/index.js";
-const console_import_path = "/bun-vfs/node_modules/console/index.js";
-const constants_import_path = "/bun-vfs/node_modules/constants/index.js";
-const crypto_import_path = "/bun-vfs/node_modules/crypto/index.js";
-const domain_import_path = "/bun-vfs/node_modules/domain/index.js";
-const events_import_path = "/bun-vfs/node_modules/events/index.js";
-const http_import_path = "/bun-vfs/node_modules/http/index.js";
-const https_import_path = "/bun-vfs/node_modules/https/index.js";
-const net_import_path = "/bun-vfs/node_modules/net/index.js";
-const os_import_path = "/bun-vfs/node_modules/os/index.js";
-const path_import_path = "/bun-vfs/node_modules/path/index.js";
-const process_import_path = "/bun-vfs/node_modules/process/index.js";
-const punycode_import_path = "/bun-vfs/node_modules/punycode/index.js";
-const querystring_import_path = "/bun-vfs/node_modules/querystring/index.js";
-const stream_import_path = "/bun-vfs/node_modules/stream/index.js";
-const string_decoder_import_path = "/bun-vfs/node_modules/string_decoder/index.js";
-const sys_import_path = "/bun-vfs/node_modules/sys/index.js";
-const timers_import_path = "/bun-vfs/node_modules/timers/index.js";
-const tty_import_path = "/bun-vfs/node_modules/tty/index.js";
-const url_import_path = "/bun-vfs/node_modules/url/index.js";
-const util_import_path = "/bun-vfs/node_modules/util/index.js";
-const zlib_import_path = "/bun-vfs/node_modules/zlib/index.js";
-
-const assert_package_json = PackageJSON{
-    .name = "assert",
-    .version = "0.0.0-polyfill",
-    .module_type = .esm,
-    .hash = @as(u32, @truncate(bun.hash("assert@0.0.0-polyfill"))),
-    .main_fields = undefined,
-    .browser_map = undefined,
-    .source = logger.Source.initPathString("/bun-vfs/node_modules/assert/package.json", ""),
-};
-const buffer_package_json = PackageJSON{
-    .name = "buffer",
-    .version = "0.0.0-polyfill",
-    .module_type = .esm,
-    .hash = @as(u32, @truncate(bun.hash("buffer@0.0.0-polyfill"))),
-    .main_fields = undefined,
-    .browser_map = undefined,
-    .source = logger.Source.initPathString("/bun-vfs/node_modules/buffer/package.json", ""),
-};
-const console_package_json = PackageJSON{
-    .name = "console",
-    .version = "0.0.0-polyfill",
-    .module_type = .esm,
-    .hash = @as(u32, @truncate(bun.hash("console@0.0.0-polyfill"))),
-    .main_fields = undefined,
-    .browser_map = undefined,
-    .source = logger.Source.initPathString("/bun-vfs/node_modules/console/package.json", ""),
-};
-const constants_package_json = PackageJSON{
-    .name = "constants",
-    .version = "0.0.0-polyfill",
-    .module_type = .esm,
-    .hash = @as(u32, @truncate(bun.hash("constants@0.0.0-polyfill"))),
-    .main_fields = undefined,
-    .browser_map = undefined,
-    .source = logger.Source.initPathString("/bun-vfs/node_modules/constants/package.json", ""),
-};
-const crypto_package_json = PackageJSON{
-    .name = "crypto",
-    .version = "0.0.0-polyfill",
-    .module_type = .esm,
-    .hash = @as(u32, @truncate(bun.hash("crypto@0.0.0-polyfill"))),
-    .main_fields = undefined,
-    .browser_map = undefined,
-    .source = logger.Source.initPathString("/bun-vfs/node_modules/crypto/package.json", ""),
-};
-const domain_package_json = PackageJSON{
-    .name = "domain",
-    .version = "0.0.0-polyfill",
-    .module_type = .esm,
-    .hash = @as(u32, @truncate(bun.hash("domain@0.0.0-polyfill"))),
-    .main_fields = undefined,
-    .browser_map = undefined,
-    .source = logger.Source.initPathString("/bun-vfs/node_modules/domain/package.json", ""),
-};
-const events_package_json = PackageJSON{
-    .name = "events",
-    .version = "0.0.0-polyfill",
-    .module_type = .esm,
-    .hash = @as(u32, @truncate(bun.hash("events@0.0.0-polyfill"))),
-    .main_fields = undefined,
-    .browser_map = undefined,
-    .source = logger.Source.initPathString("/bun-vfs/node_modules/events/package.json", ""),
-};
-const http_package_json = PackageJSON{
-    .name = "http",
-    .version = "0.0.0-polyfill",
-    .module_type = .esm,
-    .hash = @as(u32, @truncate(bun.hash("http@0.0.0-polyfill"))),
-    .main_fields = undefined,
-    .browser_map = undefined,
-    .source = logger.Source.initPathString("/bun-vfs/node_modules/http/package.json", ""),
-};
-const https_package_json = PackageJSON{
-    .name = "https",
-    .version = "0.0.0-polyfill",
-    .module_type = .esm,
-    .hash = @as(u32, @truncate(bun.hash("https@0.0.0-polyfill"))),
-    .main_fields = undefined,
-    .browser_map = undefined,
-    .source = logger.Source.initPathString("/bun-vfs/node_modules/https/package.json", ""),
-};
-const net_package_json = PackageJSON{
-    .name = "net",
-    .version = "0.0.0-polyfill",
-    .module_type = .esm,
-    .hash = @as(u32, @truncate(bun.hash("net@0.0.0-polyfill"))),
-    .main_fields = undefined,
-    .browser_map = undefined,
-    .source = logger.Source.initPathString("/bun-vfs/node_modules/net/package.json", ""),
-};
-const os_package_json = PackageJSON{
-    .name = "os",
-    .version = "0.0.0-polyfill",
-    .module_type = .esm,
-    .hash = @as(u32, @truncate(bun.hash("os@0.0.0-polyfill"))),
-    .main_fields = undefined,
-    .browser_map = undefined,
-    .source = logger.Source.initPathString("/bun-vfs/node_modules/os/package.json", ""),
-};
-const path_package_json = PackageJSON{
-    .name = "path",
-    .version = "0.0.0-polyfill",
-    .module_type = .esm,
-    .hash = @as(u32, @truncate(bun.hash("path@0.0.0-polyfill"))),
-    .main_fields = undefined,
-    .browser_map = undefined,
-    .source = logger.Source.initPathString("/bun-vfs/node_modules/path/package.json", ""),
-};
-const process_package_json = PackageJSON{
-    .name = "process",
-    .version = "0.0.0-polyfill",
-    .module_type = .esm,
-    .hash = @as(u32, @truncate(bun.hash("process@0.0.0-polyfill"))),
-    .main_fields = undefined,
-    .browser_map = undefined,
-    .source = logger.Source.initPathString("/bun-vfs/node_modules/process/package.json", ""),
-};
-const punycode_package_json = PackageJSON{
-    .name = "punycode",
-    .version = "0.0.0-polyfill",
-    .module_type = .esm,
-    .hash = @as(u32, @truncate(bun.hash("punycode@0.0.0-polyfill"))),
-    .main_fields = undefined,
-    .browser_map = undefined,
-    .source = logger.Source.initPathString("/bun-vfs/node_modules/punycode/package.json", ""),
-};
-const querystring_package_json = PackageJSON{
-    .name = "querystring",
-    .version = "0.0.0-polyfill",
-    .module_type = .esm,
-    .hash = @as(u32, @truncate(bun.hash("querystring@0.0.0-polyfill"))),
-    .main_fields = undefined,
-    .browser_map = undefined,
-    .source = logger.Source.initPathString("/bun-vfs/node_modules/querystring/package.json", ""),
-};
-const stream_package_json = PackageJSON{
-    .name = "stream",
-    .version = "0.0.0-polyfill",
-    .module_type = .esm,
-    .hash = @as(u32, @truncate(bun.hash("stream@0.0.0-polyfill"))),
-    .main_fields = undefined,
-    .browser_map = undefined,
-    .source = logger.Source.initPathString("/bun-vfs/node_modules/stream/package.json", ""),
-};
-const string_decoder_package_json = PackageJSON{
-    .name = "string_decoder",
-    .version = "0.0.0-polyfill",
-    .module_type = .esm,
-    .hash = brk: {
-        @setEvalBranchQuota(9999);
-        break :brk @as(u32, @truncate(bun.hash("string_decoder@0.0.0-polyfill")));
-    },
-
-    .main_fields = undefined,
-    .browser_map = undefined,
-    .source = logger.Source.initPathString("/bun-vfs/node_modules/string_decoder/package.json", ""),
-};
-
-const sys_package_json = PackageJSON{
-    .name = "sys",
-    .version = "0.0.0-polyfill",
-    .module_type = .esm,
-    .hash = @as(u32, @truncate(bun.hash("sys@0.0.0-polyfill"))),
-    .main_fields = undefined,
-    .browser_map = undefined,
-    .source = logger.Source.initPathString("/bun-vfs/node_modules/sys/package.json", ""),
-};
-const timers_package_json = PackageJSON{
-    .name = "timers",
-    .version = "0.0.0-polyfill",
-    .module_type = .esm,
-    .hash = @as(u32, @truncate(bun.hash("timers@0.0.0-polyfill"))),
-    .main_fields = undefined,
-    .browser_map = undefined,
-    .source = logger.Source.initPathString("/bun-vfs/node_modules/timers/package.json", ""),
-};
-const tty_package_json = PackageJSON{
-    .name = "tty",
-    .version = "0.0.0-polyfill",
-    .module_type = .esm,
-    .hash = @as(u32, @truncate(bun.hash("tty@0.0.0-polyfill"))),
-    .main_fields = undefined,
-    .browser_map = undefined,
-    .source = logger.Source.initPathString("/bun-vfs/node_modules/tty/package.json", ""),
-};
-const url_package_json = PackageJSON{
-    .name = "url",
-    .version = "0.0.0-polyfill",
-    .module_type = .esm,
-    .hash = @as(u32, @truncate(bun.hash("url@0.0.0-polyfill"))),
-    .main_fields = undefined,
-    .browser_map = undefined,
-    .source = logger.Source.initPathString("/bun-vfs/node_modules/url/package.json", ""),
-};
-const util_package_json = PackageJSON{
-    .name = "util",
-    .version = "0.0.0-polyfill",
-    .module_type = .esm,
-    .hash = @as(u32, @truncate(bun.hash("util@0.0.0-polyfill"))),
-    .main_fields = undefined,
-    .browser_map = undefined,
-    .source = logger.Source.initPathString("/bun-vfs/node_modules/util/package.json", ""),
-};
-const zlib_package_json = PackageJSON{
-    .name = "zlib",
-    .version = "0.0.0-polyfill",
-    .module_type = .esm,
-    .hash = @as(u32, @truncate(bun.hash("zlib@0.0.0-polyfill"))),
-    .main_fields = undefined,
-    .browser_map = undefined,
-    .source = logger.Source.initPathString("/bun-vfs/node_modules/zlib/package.json", ""),
-};
+comptime {
+    // Ensure that checking for the prefix should be a cheap lookup (bun.strings.hasPrefixComptime)
+    // because 24 bytes == 8 * 3 --> read and compare three u64s
+    bun.assert(import_path.len % 8 == 0);
+}
 
 pub const FallbackModule = struct {
     path: Fs.Path,
-    code: string,
     package_json: *const PackageJSON,
+    code: string,
 
-    pub const assert = FallbackModule{
-        .path = Fs.Path.initWithNamespaceVirtual(assert_import_path, "node", "assert"),
-        .code = assert_code,
-        .package_json = &assert_package_json,
-    };
-    pub const buffer = FallbackModule{
-        .path = Fs.Path.initWithNamespaceVirtual(buffer_import_path, "node", "buffer"),
-        .code = buffer_code,
-        .package_json = &buffer_package_json,
-    };
-    pub const console = FallbackModule{
-        .path = Fs.Path.initWithNamespaceVirtual(console_import_path, "node", "console"),
-        .code = console_code,
-        .package_json = &console_package_json,
-    };
-    pub const constants = FallbackModule{
-        .path = Fs.Path.initWithNamespaceVirtual(constants_import_path, "node", "constants"),
-        .code = constants_code,
-        .package_json = &constants_package_json,
-    };
-    pub const crypto = FallbackModule{
-        .path = Fs.Path.initWithNamespaceVirtual(crypto_import_path, "node", "crypto"),
-        .code = crypto_code,
-        .package_json = &crypto_package_json,
-    };
-    pub const domain = FallbackModule{
-        .path = Fs.Path.initWithNamespaceVirtual(domain_import_path, "node", "domain"),
-        .code = domain_code,
-        .package_json = &domain_package_json,
-    };
-    pub const events = FallbackModule{
-        .path = Fs.Path.initWithNamespaceVirtual(events_import_path, "node", "events"),
-        .code = events_code,
-        .package_json = &events_package_json,
-    };
-    pub const http = FallbackModule{
-        .path = Fs.Path.initWithNamespaceVirtual(http_import_path, "node", "http"),
-        .code = http_code,
-        .package_json = &http_package_json,
-    };
-    pub const https = FallbackModule{
-        .path = Fs.Path.initWithNamespaceVirtual(https_import_path, "node", "https"),
-        .code = https_code,
-        .package_json = &https_package_json,
-    };
-    pub const net = FallbackModule{
-        .path = Fs.Path.initWithNamespaceVirtual(net_import_path, "node", "net"),
-        .code = net_code,
-        .package_json = &net_package_json,
-    };
-    pub const os = FallbackModule{
-        .path = Fs.Path.initWithNamespaceVirtual(os_import_path, "node", "os"),
-        .code = os_code,
-        .package_json = &os_package_json,
-    };
-    pub const path = FallbackModule{
-        .path = Fs.Path.initWithNamespaceVirtual(path_import_path, "node", "path"),
-        .code = path_code,
-        .package_json = &path_package_json,
-    };
-    pub const process = FallbackModule{
-        .path = Fs.Path.initWithNamespaceVirtual(process_import_path, "node", "process"),
-        .code = process_code,
-        .package_json = &process_package_json,
-    };
-    pub const punycode = FallbackModule{
-        .path = Fs.Path.initWithNamespaceVirtual(punycode_import_path, "node", "punycode"),
-        .code = punycode_code,
-        .package_json = &punycode_package_json,
-    };
-    pub const querystring = FallbackModule{
-        .path = Fs.Path.initWithNamespaceVirtual(querystring_import_path, "node", "querystring"),
-        .code = querystring_code,
-        .package_json = &querystring_package_json,
-    };
-    pub const stream = FallbackModule{
-        .path = Fs.Path.initWithNamespaceVirtual(stream_import_path, "node", "stream"),
-        .code = stream_code,
-        .package_json = &stream_package_json,
-    };
-    pub const string_decoder = FallbackModule{
-        .path = Fs.Path.initWithNamespaceVirtual(string_decoder_import_path, "node", "string_decoder"),
-        .code = string_decoder_code,
-        .package_json = &string_decoder_package_json,
-    };
-    pub const sys = FallbackModule{
-        .path = Fs.Path.initWithNamespaceVirtual(sys_import_path, "node", "sys"),
-        .code = sys_code,
-        .package_json = &sys_package_json,
-    };
-    pub const timers = FallbackModule{
-        .path = Fs.Path.initWithNamespaceVirtual(timers_import_path, "node", "timers"),
-        .code = timers_code,
-        .package_json = &timers_package_json,
-    };
-    pub const tty = FallbackModule{
-        .path = Fs.Path.initWithNamespaceVirtual(tty_import_path, "node", "tty"),
-        .code = tty_code,
-        .package_json = &tty_package_json,
-    };
-    pub const url = FallbackModule{
-        .path = Fs.Path.initWithNamespaceVirtual(url_import_path, "node", "url"),
-        .code = url_code,
-        .package_json = &url_package_json,
-    };
-    pub const util = FallbackModule{
-        .path = Fs.Path.initWithNamespaceVirtual(util_import_path, "node", "util"),
-        .code = util_code,
-        .package_json = &util_package_json,
-    };
-    pub const zlib = FallbackModule{
-        .path = Fs.Path.initWithNamespaceVirtual(zlib_import_path, "node", "zlib"),
-        .code = zlib_code,
-        .package_json = &zlib_package_json,
-    };
+    pub fn init(comptime name: string) FallbackModule {
+        @setEvalBranchQuota(99999);
+        const version = "0.0.0-polyfill";
+        const code_path = "node-fallbacks/" ++ name ++ ".js";
+        return .{
+            .path = Fs.Path.initWithNamespaceVirtual(import_path ++ name ++ "/index.js", "node", name),
+            .package_json = &PackageJSON{
+                .name = name,
+                .version = version,
+                .module_type = .esm,
+                .hash = @as(u32, @truncate(bun.hash(name ++ "@" ++ version))),
+                .main_fields = undefined,
+                .browser_map = undefined,
+                .source = logger.Source.initPathString(import_path ++ name ++ "/package.json", ""),
+                .side_effects = .false,
+            },
+            .code = @embedFile(code_path),
+        };
+    }
 };
 
 pub const Map = bun.ComptimeStringMap(FallbackModule, .{
-    .{ "assert", FallbackModule.assert },
-    .{ "buffer", FallbackModule.buffer },
-    .{ "console", FallbackModule.console },
-    .{ "constants", FallbackModule.constants },
-    .{ "crypto", FallbackModule.crypto },
-    .{ "domain", FallbackModule.domain },
-    .{ "events", FallbackModule.events },
-    .{ "http", FallbackModule.http },
-    .{ "https", FallbackModule.https },
-    .{ "net", FallbackModule.net },
-    .{ "os", FallbackModule.os },
-    .{ "path", FallbackModule.path },
-    .{ "process", FallbackModule.process },
-    .{ "punycode", FallbackModule.punycode },
-    .{ "querystring", FallbackModule.querystring },
-    .{ "stream", FallbackModule.stream },
-    .{ "string_decoder", FallbackModule.string_decoder },
-    .{ "sys", FallbackModule.sys },
-    .{ "timers", FallbackModule.timers },
-    .{ "tty", FallbackModule.tty },
-    .{ "url", FallbackModule.url },
-    .{ "util", FallbackModule.util },
-    .{ "zlib", FallbackModule.zlib },
+    .{ "assert", FallbackModule.init("assert") },
+    .{ "buffer", FallbackModule.init("buffer") },
+    .{ "console", FallbackModule.init("console") },
+    .{ "constants", FallbackModule.init("constants") },
+    .{ "crypto", FallbackModule.init("crypto") },
+    .{ "domain", FallbackModule.init("domain") },
+    .{ "events", FallbackModule.init("events") },
+    .{ "http", FallbackModule.init("http") },
+    .{ "https", FallbackModule.init("https") },
+    .{ "net", FallbackModule.init("net") },
+    .{ "os", FallbackModule.init("os") },
+    .{ "path", FallbackModule.init("path") },
+    .{ "process", FallbackModule.init("process") },
+    .{ "punycode", FallbackModule.init("punycode") },
+    .{ "querystring", FallbackModule.init("querystring") },
+    .{ "stream", FallbackModule.init("stream") },
+    .{ "string_decoder", FallbackModule.init("string_decoder") },
+    .{ "sys", FallbackModule.init("sys") },
+    .{ "timers", FallbackModule.init("timers") },
+    .{ "tty", FallbackModule.init("tty") },
+    .{ "url", FallbackModule.init("url") },
+    .{ "util", FallbackModule.init("util") },
+    .{ "zlib", FallbackModule.init("zlib") },
 });
 
 pub fn contentsFromPath(path: string) ?string {
-    @setCold(true);
-    var module_name = path["/bun-vfs/node_modules/".len..];
+    if (Environment.allow_assert)
+        bun.assert(bun.strings.hasPrefixComptime(path, import_path));
 
-    if (module_name[0] == '@') {
-        var end = std.mem.indexOfScalar(u8, module_name, '/').? + 1;
-        end += std.mem.indexOfScalar(u8, module_name[end..], '/').?;
-
-        module_name = module_name[0..end];
-    } else {
-        module_name = module_name[0..std.mem.indexOfScalar(u8, module_name, '/').?];
-    }
+    var module_name = path[import_path.len..];
+    module_name = module_name[0 .. std.mem.indexOfScalar(u8, module_name, '/') orelse module_name.len];
 
     if (Map.get(module_name)) |mod| {
         return mod.code;
     }
+
     return null;
 }
-
-pub const buffer_fallback_import_name: string = "node:buffer";
diff --git a/src/open.zig b/src/open.zig
index bb83d9b60d..c14c2895c9 100644
--- a/src/open.zig
+++ b/src/open.zig
@@ -11,7 +11,7 @@ const C = bun.C;
 const std = @import("std");
 const DotEnv = @import("env_loader.zig");
 
-const opener = switch (@import("builtin").target.os.tag) {
+pub const opener = switch (@import("builtin").target.os.tag) {
     .macos => "/usr/bin/open",
     .windows => "start",
     else => "xdg-open",
diff --git a/src/options.zig b/src/options.zig
index 280d4e0311..4bccea93e6 100644
--- a/src/options.zig
+++ b/src/options.zig
@@ -7,7 +7,6 @@ const Fs = @import("fs.zig");
 const resolver = @import("./resolver/resolver.zig");
 const api = @import("./api/schema.zig");
 const Api = api.Api;
-const defines = @import("./defines.zig");
 const resolve_path = @import("./resolver/resolve_path.zig");
 const URL = @import("./url.zig").URL;
 const ConditionsMap = @import("./resolver/package_json.zig").ESModule.ConditionsMap;
@@ -29,6 +28,7 @@ const Analytics = @import("./analytics/analytics_thread.zig");
 const MacroRemap = @import("./resolver/package_json.zig").MacroMap;
 const DotEnv = @import("./env_loader.zig");
 
+pub const defines = @import("./defines.zig");
 pub const Define = defines.Define;
 
 const assert = bun.assert;
@@ -384,19 +384,20 @@ pub const Target = enum {
     bun_macro,
     node,
 
+    /// This is used by bake.Framework.ServerComponents.separate_ssr_graph
+    bake_server_components_ssr,
+
     pub const Map = bun.ComptimeStringMap(Target, .{
-        .{ "browser", Target.browser },
-        .{ "bun", Target.bun },
-        .{ "bun_macro", Target.bun_macro },
-        .{ "macro", Target.bun_macro },
-        .{ "node", Target.node },
+        .{ "browser", .browser },
+        .{ "bun", .bun },
+        .{ "bun_macro", .bun_macro },
+        .{ "macro", .bun_macro },
+        .{ "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.throwInvalidArguments("target must be a string", .{});
         }
         return Map.fromJS(global, value);
     }
@@ -405,39 +406,25 @@ pub const Target = enum {
         return switch (this) {
             .node => .node,
             .browser => .browser,
-            .bun => .bun,
+            .bun, .bake_server_components_ssr => .bun,
             .bun_macro => .bun_macro,
         };
     }
 
     pub inline fn isServerSide(this: Target) bool {
         return switch (this) {
-            .bun_macro, .node, .bun => true,
+            .bun_macro, .node, .bun, .bake_server_components_ssr => true,
             else => false,
         };
     }
 
     pub inline fn isBun(this: Target) bool {
         return switch (this) {
-            .bun_macro, .bun => true,
+            .bun_macro, .bun, .bake_server_components_ssr => true,
             else => false,
         };
     }
 
-    pub inline fn isNotBun(this: Target) bool {
-        return switch (this) {
-            .bun_macro, .bun => false,
-            else => true,
-        };
-    }
-
-    pub inline fn isClient(this: Target) bool {
-        return switch (this) {
-            .bun_macro, .bun => false,
-            else => true,
-        };
-    }
-
     pub inline fn isNode(this: Target) bool {
         return switch (this) {
             .node => true,
@@ -445,60 +432,38 @@ pub const Target = enum {
         };
     }
 
-    pub inline fn supportsBrowserField(this: Target) bool {
-        return switch (this) {
-            .browser => true,
-            else => false,
-        };
-    }
-
-    const browser_define_value_true = "true";
-    const browser_define_value_false = "false";
-
     pub inline fn processBrowserDefineValue(this: Target) ?string {
         return switch (this) {
-            .browser => browser_define_value_true,
-            .bun_macro, .bun, .node => browser_define_value_false,
+            .browser => "true",
+            else => "false",
         };
     }
 
-    pub inline fn isWebLike(target: Target) bool {
+    pub fn bakeGraph(target: Target) bun.bake.Graph {
         return switch (target) {
-            .browser => true,
-            else => false,
+            .browser => .client,
+            .bake_server_components_ssr => .ssr,
+            .bun_macro, .bun, .node => .server,
         };
     }
 
-    pub const Extensions = struct {
-        pub const In = struct {
-            pub const JavaScript = [_]string{ ".js", ".cjs", ".mts", ".cts", ".ts", ".tsx", ".jsx", ".json" };
-        };
-        pub const Out = struct {
-            pub const JavaScript = [_]string{
-                ".js",
-                ".mjs",
-            };
-        };
-    };
-
     pub fn outExtensions(target: Target, allocator: std.mem.Allocator) bun.StringHashMap(string) {
         var exts = bun.StringHashMap(string).init(allocator);
 
-        const js = Extensions.Out.JavaScript[0];
-        const mjs = Extensions.Out.JavaScript[1];
+        const out_extensions_list = [_][]const u8{ ".js", ".cjs", ".mts", ".cts", ".ts", ".tsx", ".jsx", ".json" };
 
         if (target == .node) {
-            exts.ensureTotalCapacity(Extensions.In.JavaScript.len * 2) catch unreachable;
-            for (Extensions.In.JavaScript) |ext| {
-                exts.put(ext, mjs) catch unreachable;
+            exts.ensureTotalCapacity(out_extensions_list.len * 2) catch unreachable;
+            for (out_extensions_list) |ext| {
+                exts.put(ext, ".mjs") catch unreachable;
             }
         } else {
-            exts.ensureTotalCapacity(Extensions.In.JavaScript.len + 1) catch unreachable;
-            exts.put(mjs, js) catch unreachable;
+            exts.ensureTotalCapacity(out_extensions_list.len + 1) catch unreachable;
+            exts.put(".mjs", ".js") catch unreachable;
         }
 
-        for (Extensions.In.JavaScript) |ext| {
-            exts.put(ext, js) catch unreachable;
+        for (out_extensions_list) |ext| {
+            exts.put(ext, ".js") catch unreachable;
         }
 
         return exts;
@@ -556,6 +521,7 @@ pub const Target = enum {
         array.set(Target.browser, &listc);
         array.set(Target.bun, &listd);
         array.set(Target.bun_macro, &listd);
+        array.set(Target.bake_server_components_ssr, &listd);
 
         // Original comment:
         // The neutral target is for people that don't want esbuild to try to
@@ -566,21 +532,25 @@ pub const Target = enum {
         break :brk array;
     };
 
-    pub const DefaultConditions: std.EnumArray(Target, []const string) = brk: {
+    pub const default_conditions: std.EnumArray(Target, []const string) = brk: {
         var array = std.EnumArray(Target, []const string).initUndefined();
 
-        array.set(Target.node, &[_]string{
+        array.set(Target.node, &.{
             "node",
         });
-        array.set(Target.browser, &[_]string{
+        array.set(Target.browser, &.{
             "browser",
             "module",
         });
-        array.set(Target.bun, &[_]string{
+        array.set(Target.bun, &.{
             "bun",
             "node",
         });
-        array.set(Target.bun_macro, &[_]string{
+        array.set(Target.bake_server_components_ssr, &.{
+            "bun",
+            "node",
+        });
+        array.set(Target.bun_macro, &.{
             "macro",
             "bun",
             "node",
@@ -588,6 +558,10 @@ pub const Target = enum {
 
         break :brk array;
     };
+
+    pub fn defaultConditions(t: Target) []const []const u8 {
+        return default_conditions.get(t);
+    }
 };
 
 pub const Format = enum {
@@ -604,16 +578,16 @@ pub const Format = enum {
     /// CommonJS
     cjs,
 
-    /// Kit's uses a special module format for Hot-module-reloading. It includes a
-    /// runtime payload, sourced from src/kit/hmr-runtime.ts.
+    /// Bake uses a special module format for Hot-module-reloading. It includes a
+    /// runtime payload, sourced from src/bake/hmr-runtime-{side}.ts.
     ///
-    /// ((input_graph, entry_point_key) => {
+    /// ((input_graph, config) => {
     ///   ... runtime code ...
-    /// })([
-    ///   "module1.ts"(require, module) { ... },
-    ///   "module2.ts"(require, module) { ... },
-    /// ], "module1.ts");
-    internal_kit_dev,
+    /// })({
+    ///   "module1.ts"(module) { ... },
+    ///   "module2.ts"(module) { ... },
+    /// }, { metadata });
+    internal_bake_dev,
 
     pub fn keepES6ImportExportSyntax(this: Format) bool {
         return this == .esm;
@@ -623,26 +597,28 @@ pub const Format = enum {
         return this == .esm;
     }
 
+    pub inline fn isAlwaysStrictMode(this: Format) bool {
+        return this == .esm;
+    }
+
     pub const Map = bun.ComptimeStringMap(Format, .{
         .{ "esm", .esm },
         .{ "cjs", .cjs },
         .{ "iife", .iife },
 
         // TODO: Disable this outside of debug builds
-        .{ "internal_kit_dev", .internal_kit_dev },
+        .{ "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.throwInvalidArguments("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.throwInvalidArguments("Invalid format - must be esm, cjs, or iife", .{});
         };
     }
 
@@ -676,10 +652,21 @@ pub const Loader = enum(u8) {
         };
     }
 
-    pub fn shouldCopyForBundling(this: Loader) bool {
+    pub fn shouldCopyForBundling(this: Loader, experimental_css: bool) bool {
+        if (experimental_css) {
+            return switch (this) {
+                .file,
+                .napi,
+                .sqlite,
+                .sqlite_embedded,
+                // TODO: loader for reading bytes and creating module or instance
+                .wasm,
+                => true,
+                else => false,
+            };
+        }
         return switch (this) {
             .file,
-            // TODO: CSS
             .css,
             .napi,
             .sqlite,
@@ -739,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.throwInvalidArguments("loader must be a string", .{});
         }
 
         var zig_str = JSC.ZigString.init("");
@@ -752,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.throwInvalidArguments("invalid loader - must be js, jsx, tsx, ts, css, file, toml, wasm, bunsh, or json", .{});
         };
     }
 
@@ -985,7 +970,7 @@ pub const JSX = struct {
         // these need to be arrays
         factory: []const string = Defaults.Factory,
         fragment: []const string = Defaults.Fragment,
-        runtime: JSX.Runtime = JSX.Runtime.automatic,
+        runtime: JSX.Runtime = .automatic,
         import_source: ImportSource = .{},
 
         /// Facilitates automatic JSX importing
@@ -993,10 +978,6 @@ pub const JSX = struct {
         /// /** @jsxImportSource @emotion/core */
         classic_import_source: string = "react",
         package_name: []const u8 = "react",
-        // https://github.com/facebook/react/commit/2f26eb85d657a08c21edbac1e00f9626d68f84ae
-        refresh_runtime: string = "react-refresh/runtime",
-        supports_fast_refresh: bool = true,
-        use_embedded_refresh_runtime: bool = false,
 
         development: bool = true,
         parse: bool = true,
@@ -1042,7 +1023,9 @@ pub const JSX = struct {
         }
 
         pub fn isReactLike(pragma: *const Pragma) bool {
-            return strings.eqlComptime(pragma.package_name, "react") or strings.eqlComptime(pragma.package_name, "@emotion/jsx") or strings.eqlComptime(pragma.package_name, "@emotion/react");
+            return strings.eqlComptime(pragma.package_name, "react") or
+                strings.eqlComptime(pragma.package_name, "@emotion/jsx") or
+                strings.eqlComptime(pragma.package_name, "@emotion/react");
         }
 
         pub fn setImportSource(pragma: *Pragma, allocator: std.mem.Allocator) void {
@@ -1143,7 +1126,6 @@ pub const JSX = struct {
                 pragma.classic_import_source = pragma.package_name;
             }
 
-            pragma.supports_fast_refresh = if (pragma.runtime == .solid) false else pragma.supports_fast_refresh;
             pragma.development = jsx.development;
             pragma.parse = true;
             return pragma;
@@ -1153,18 +1135,6 @@ pub const JSX = struct {
     pub const Runtime = api.Api.JsxRuntime;
 };
 
-const TypeScript = struct {
-    parse: bool = false,
-};
-
-pub const Timings = struct {
-    resolver: i128 = 0,
-    parse: i128 = 0,
-    print: i128 = 0,
-    http: i128 = 0,
-    read_file: i128 = 0,
-};
-
 pub const DefaultUserDefines = struct {
     // This must be globally scoped so it doesn't disappear
     pub const NodeEnv = struct {
@@ -1185,6 +1155,7 @@ pub fn definesFromTransformOptions(
     env_loader: ?*DotEnv.Loader,
     framework_env: ?*const Env,
     NODE_ENV: ?string,
+    drop: []const []const u8,
 ) !*defines.Define {
     const input_user_define = maybe_input_define orelse std.mem.zeroes(Api.StringMap);
 
@@ -1275,12 +1246,17 @@ pub fn definesFromTransformOptions(
         }
     }
 
-    const resolved_defines = try defines.DefineData.fromInput(user_defines, log, allocator);
+    const resolved_defines = try defines.DefineData.fromInput(user_defines, drop, log, allocator);
+
+    const drop_debugger = for (drop) |item| {
+        if (strings.eqlComptime(item, "debugger")) break true;
+    } else false;
 
     return try defines.Define.init(
         allocator,
         resolved_defines,
         environment_defines,
+        drop_debugger,
     );
 }
 
@@ -1443,6 +1419,7 @@ pub const BundleOptions = struct {
     footer: string = "",
     banner: string = "",
     define: *defines.Define,
+    drop: []const []const u8 = &.{},
     loaders: Loader.HashTable,
     resolve_dir: string = "/",
     jsx: JSX.Pragma = JSX.Pragma{},
@@ -1452,8 +1429,7 @@ pub const BundleOptions = struct {
 
     trim_unused_imports: ?bool = null,
     mark_builtins_as_external: bool = false,
-    react_server_components: bool = false,
-    react_server_components_boundary: string = "",
+    server_components: bool = false,
     hot_module_reloading: bool = false,
     react_fast_refresh: bool = false,
     inject: ?[]string = null,
@@ -1468,19 +1444,17 @@ pub const BundleOptions = struct {
     write: bool = false,
     preserve_symlinks: bool = false,
     preserve_extensions: bool = false,
-    timings: Timings = Timings{},
     production: bool = false,
-    serve: bool = false,
 
     // only used by bundle_v2
     output_format: Format = .esm,
 
     append_package_version_in_query_string: bool = false,
 
-    resolve_mode: api.Api.ResolveMode,
     tsconfig_override: ?string = null,
     target: Target = Target.browser,
     main_fields: []const string = Target.DefaultMainFields.get(Target.browser),
+    /// TODO: remove this in favor accessing bundler.log
     log: *logger.Log,
     external: ExternalModules = ExternalModules{},
     entry_points: []const string,
@@ -1492,8 +1466,6 @@ pub const BundleOptions = struct {
     main_field_extension_order: []const string = &Defaults.MainFieldExtensionOrder,
     out_extensions: bun.StringHashMap(string),
     import_path_format: ImportPathFormat = ImportPathFormat.relative,
-    framework: ?Framework = null,
-    routes: RouteConfig = RouteConfig.zero(),
     defines_loaded: bool = false,
     env: Env = Env{},
     transform_options: Api.TransformOptions,
@@ -1526,14 +1498,23 @@ pub const BundleOptions = struct {
     minify_identifiers: bool = false,
     dead_code_elimination: bool = true,
 
+    experimental_css: bool,
+    css_chunking: bool,
+
     ignore_dce_annotations: bool = false,
     emit_dce_annotations: bool = false,
+    bytecode: bool = false,
 
     code_coverage: bool = false,
     debugger: bool = false,
 
     compile: bool = false,
 
+    /// Set when bake.DevServer is bundling.
+    dev_server: ?*bun.bake.DevServer = null,
+    /// Set when Bake is bundling. Affects module resolution.
+    framework: ?*bun.bake.Framework = null,
+
     /// This is a list of packages which even when require() is used, we will
     /// instead convert to ESM import statements.
     ///
@@ -1542,6 +1523,8 @@ pub const BundleOptions = struct {
     /// So we have a list of packages which we know are safe to do this with.
     unwrap_commonjs_packages: []const string = &default_unwrap_commonjs_packages,
 
+    supports_multiple_outputs: bool = true,
+
     pub fn isTest(this: *const BundleOptions) bool {
         return this.rewrite_jest_for_tests;
     }
@@ -1564,10 +1547,6 @@ pub const BundleOptions = struct {
     pub inline fn cssImportBehavior(this: *const BundleOptions) Api.CssInJsBehavior {
         switch (this.target) {
             .browser => {
-                if (this.framework) |framework| {
-                    return framework.client_css_in_js;
-                }
-
                 return .auto_onimportcss;
             },
             else => return .facade,
@@ -1603,6 +1582,7 @@ pub const BundleOptions = struct {
 
                 break :node_env "\"development\"";
             },
+            this.drop,
         );
         this.defines_loaded = true;
     }
@@ -1611,11 +1591,6 @@ pub const BundleOptions = struct {
         return this.loaders.get(ext) orelse .file;
     }
 
-    pub fn isFrontendFrameworkEnabled(this: *const BundleOptions) bool {
-        const framework: *const Framework = &(this.framework orelse return false);
-        return framework.resolved and (framework.client.isEnabled() or framework.fallback.isEnabled());
-    }
-
     pub const ImportPathFormat = enum {
         relative,
         absolute_url,
@@ -1698,7 +1673,6 @@ pub const BundleOptions = struct {
     ) !BundleOptions {
         var opts: BundleOptions = BundleOptions{
             .log = log,
-            .resolve_mode = transform.resolve orelse .dev,
             .define = undefined,
             .loaders = try loadersFromTransformOptions(allocator, transform.loaders, Target.from(transform.target)),
             .output_dir = transform.output_dir orelse "out",
@@ -1709,6 +1683,9 @@ pub const BundleOptions = struct {
             .out_extensions = undefined,
             .env = Env.init(allocator),
             .transform_options = transform,
+            .experimental_css = false,
+            .css_chunking = false,
+            .drop = transform.drop,
         };
 
         Analytics.Features.define += @as(usize, @intFromBool(transform.define != null));
@@ -1735,7 +1712,12 @@ pub const BundleOptions = struct {
             opts.main_fields = Target.DefaultMainFields.get(opts.target);
         }
 
-        opts.conditions = try ESMConditions.init(allocator, Target.DefaultConditions.get(opts.target));
+        opts.conditions = try ESMConditions.init(allocator, opts.target.defaultConditions());
+
+        if (bun.FeatureFlags.breaking_changes_1_2) {
+            // This is currently done in DevServer by default, but not in Bun.build
+            @compileError("if (!production) { add \"development\" condition }");
+        }
 
         if (transform.conditions.len > 0) {
             opts.conditions.appendSlice(transform.conditions) catch bun.outOfMemory();
@@ -1759,14 +1741,6 @@ pub const BundleOptions = struct {
             else => {},
         }
 
-        if (transform.framework) |_framework| {
-            opts.framework = try Framework.fromApi(_framework, allocator);
-        }
-
-        if (transform.router) |routes| {
-            opts.routes = try RouteConfig.fromApi(routes, allocator);
-        }
-
         if (transform.main_fields.len > 0) {
             opts.main_fields = transform.main_fields;
         }
@@ -1794,7 +1768,6 @@ pub const BundleOptions = struct {
 
         opts.polyfill_node_globals = opts.target == .browser;
 
-        Analytics.Features.filesystem_router += @as(usize, @intFromBool(opts.routes.routes_enabled));
         Analytics.Features.macros += @as(usize, @intFromBool(opts.target == .bun_macro));
         Analytics.Features.external += @as(usize, @intFromBool(transform.external.len > 0));
         return opts;
@@ -1880,12 +1853,20 @@ pub const OutputFile = struct {
     value: Value,
     size: usize = 0,
     size_without_sourcemap: usize = 0,
-    mtime: ?i128 = null,
     hash: u64 = 0,
     is_executable: bool = false,
     source_map_index: u32 = std.math.maxInt(u32),
-    output_kind: JSC.API.BuildArtifact.OutputKind = .chunk,
+    bytecode_index: u32 = std.math.maxInt(u32),
+    output_kind: JSC.API.BuildArtifact.OutputKind,
+    /// Relative
     dest_path: []const u8 = "",
+    side: ?bun.bake.Side,
+    /// This is only set for the JS bundle, and not files associated with an
+    /// entrypoint like sourcemaps and bytecode
+    entry_point_index: ?u32,
+    referenced_css_files: []const Index = &.{},
+
+    pub const Index = bun.GenericIndex(u32, OutputFile);
 
     // Depending on:
     // - The target
@@ -1927,6 +1908,33 @@ pub const OutputFile = struct {
         },
         pending: resolver.Result,
         saved: SavedFile,
+
+        pub fn toBunString(v: Value) bun.String {
+            return switch (v) {
+                .noop => bun.String.empty,
+                .buffer => |buf| {
+                    // Use ExternalStringImpl to avoid cloning the string, at
+                    // the cost of allocating space to remember the allocator.
+                    const FreeContext = struct {
+                        allocator: std.mem.Allocator,
+
+                        fn onFree(uncast_ctx: *anyopaque, buffer: *anyopaque, len: u32) callconv(.C) void {
+                            const ctx: *@This() = @alignCast(@ptrCast(uncast_ctx));
+                            ctx.allocator.free(@as([*]u8, @ptrCast(buffer))[0..len]);
+                            bun.destroy(ctx);
+                        }
+                    };
+                    return bun.String.createExternal(
+                        buf.bytes,
+                        true,
+                        bun.new(FreeContext, .{ .allocator = buf.allocator }),
+                        FreeContext.onFree,
+                    );
+                },
+                .pending => unreachable,
+                else => |tag| bun.todoPanic(@src(), "handle .{s}", .{@tagName(tag)}),
+            };
+        }
     };
 
     pub const SavedFile = struct {
@@ -1988,12 +1996,13 @@ pub const OutputFile = struct {
         input_loader: Loader,
         hash: ?u64 = null,
         source_map_index: ?u32 = null,
+        bytecode_index: ?u32 = null,
         output_path: string,
         size: ?usize = null,
         input_path: []const u8 = "",
         display_size: u32 = 0,
-        output_kind: JSC.API.BuildArtifact.OutputKind = .chunk,
-        is_executable: bool = false,
+        output_kind: JSC.API.BuildArtifact.OutputKind,
+        is_executable: bool,
         data: union(enum) {
             buffer: struct {
                 allocator: std.mem.Allocator,
@@ -2006,10 +2015,13 @@ pub const OutputFile = struct {
             },
             saved: usize,
         },
+        side: ?bun.bake.Side,
+        entry_point_index: ?u32,
+        referenced_css_files: []const Index = &.{},
     };
 
     pub fn init(options: Options) OutputFile {
-        return OutputFile{
+        return .{
             .loader = options.loader,
             .input_loader = options.input_loader,
             .src_path = Fs.Path.init(options.input_path),
@@ -2022,6 +2034,7 @@ pub const OutputFile = struct {
             .size_without_sourcemap = options.display_size,
             .hash = options.hash orelse 0,
             .output_kind = options.output_kind,
+            .bytecode_index = options.bytecode_index orelse std.math.maxInt(u32),
             .source_map_index = options.source_map_index orelse std.math.maxInt(u32),
             .is_executable = options.is_executable,
             .value = switch (options.data) {
@@ -2035,6 +2048,9 @@ pub const OutputFile = struct {
                 },
                 .saved => Value{ .saved = .{} },
             },
+            .side = options.side,
+            .entry_point_index = options.entry_point_index,
+            .referenced_css_files = options.referenced_css_files,
         };
     }
 
@@ -2054,6 +2070,95 @@ pub const OutputFile = struct {
         };
     }
 
+    /// Given the `--outdir` as root_dir, this will return the relative path to display in terminal
+    pub fn writeToDisk(f: OutputFile, root_dir: std.fs.Dir, longest_common_path: []const u8) ![]const u8 {
+        switch (f.value) {
+            .saved => {
+                var rel_path = f.dest_path;
+                if (f.dest_path.len > longest_common_path.len) {
+                    rel_path = resolve_path.relative(longest_common_path, f.dest_path);
+                }
+                return rel_path;
+            },
+            .buffer => |value| {
+                var rel_path = f.dest_path;
+
+                if (f.dest_path.len > longest_common_path.len) {
+                    rel_path = resolve_path.relative(longest_common_path, f.dest_path);
+                    if (std.fs.path.dirname(rel_path)) |parent| {
+                        if (parent.len > longest_common_path.len) {
+                            try root_dir.makePath(parent);
+                        }
+                    }
+                }
+
+                var handled_file_not_found = false;
+                while (true) {
+                    var path_buf: bun.PathBuffer = undefined;
+                    JSC.Node.NodeFS.writeFileWithPathBuffer(&path_buf, .{
+                        .data = .{ .buffer = .{
+                            .buffer = .{
+                                .ptr = @constCast(value.bytes.ptr),
+                                .len = value.bytes.len,
+                                .byte_len = value.bytes.len,
+                            },
+                        } },
+                        .encoding = .buffer,
+                        .mode = if (f.is_executable) 0o755 else 0o644,
+                        .dirfd = bun.toFD(root_dir.fd),
+                        .file = .{ .path = .{
+                            .string = JSC.PathString.init(rel_path),
+                        } },
+                    }).unwrap() catch |err| switch (err) {
+                        error.FileNotFound, error.ENOENT => {
+                            if (handled_file_not_found) return err;
+                            handled_file_not_found = true;
+                            try root_dir.makePath(
+                                std.fs.path.dirname(rel_path) orelse
+                                    return err,
+                            );
+                            continue;
+                        },
+                        else => return err,
+                    };
+                    break;
+                }
+
+                return rel_path;
+            },
+            .move => |value| {
+                _ = value;
+                // var filepath_buf: bun.PathBuffer = undefined;
+                // filepath_buf[0] = '.';
+                // filepath_buf[1] = '/';
+                // const primary = f.dest_path[root_dir_path.len..];
+                // bun.copy(u8, filepath_buf[2..], primary);
+                // var rel_path: []const u8 = filepath_buf[0 .. primary.len + 2];
+                // rel_path = value.pathname;
+
+                // try f.moveTo(root_path, @constCast(rel_path), bun.toFD(root_dir.fd));
+                {
+                    @panic("TODO: Regressed behavior");
+                }
+
+                // return primary;
+            },
+            .copy => |value| {
+                _ = value;
+                // rel_path = value.pathname;
+
+                // try f.copyTo(root_path, @constCast(rel_path), bun.toFD(root_dir.fd));
+                {
+                    @panic("TODO: Regressed behavior");
+                }
+            },
+            .noop => {
+                return f.dest_path;
+            },
+            .pending => unreachable,
+        }
+    }
+
     pub fn moveTo(file: *const OutputFile, _: string, rel_path: []u8, dir: FileDescriptorType) !void {
         try bun.C.moveFileZ(file.value.move.dir, bun.sliceTo(&(try std.posix.toPosixPath(file.value.move.getPathname())), 0), dir, bun.sliceTo(&(try std.posix.toPosixPath(rel_path)), 0));
     }
@@ -2389,127 +2494,6 @@ pub const EntryPoint = struct {
     }
 };
 
-pub const Framework = struct {
-    client: EntryPoint = EntryPoint{},
-    server: EntryPoint = EntryPoint{},
-    fallback: EntryPoint = EntryPoint{},
-
-    display_name: string = "",
-    /// "version" field in package.json
-    version: string = "",
-    /// "name" field in package.json
-    package: string = "",
-    development: bool = true,
-    resolved: bool = false,
-    from_bundle: bool = false,
-
-    resolved_dir: string = "",
-    override_modules: Api.StringMap,
-    override_modules_hashes: []u64 = &[_]u64{},
-
-    client_css_in_js: Api.CssInJsBehavior = .auto_onimportcss,
-
-    pub const fallback_html: string = @embedFile("./fallback.html");
-
-    pub fn platformEntryPoint(this: *const Framework, target: Target) ?*const EntryPoint {
-        const entry: *const EntryPoint = switch (target) {
-            .browser => &this.client,
-            .bun => &this.server,
-            .node => return null,
-        };
-
-        if (entry.kind == .disabled) return null;
-        return entry;
-    }
-
-    pub fn fromLoadedFramework(loaded: Api.LoadedFramework, allocator: std.mem.Allocator) !Framework {
-        var framework = Framework{
-            .package = loaded.package,
-            .development = loaded.development,
-            .from_bundle = true,
-            .client_css_in_js = loaded.client_css_in_js,
-            .display_name = loaded.display_name,
-            .override_modules = loaded.override_modules,
-        };
-
-        if (loaded.entry_points.fallback) |fallback| {
-            try framework.fallback.fromLoaded(fallback, allocator, .fallback);
-        }
-
-        if (loaded.entry_points.client) |client| {
-            try framework.client.fromLoaded(client, allocator, .client);
-        }
-
-        if (loaded.entry_points.server) |server| {
-            try framework.server.fromLoaded(server, allocator, .server);
-        }
-
-        return framework;
-    }
-
-    pub fn toAPI(
-        this: *const Framework,
-        allocator: std.mem.Allocator,
-        toplevel_path: string,
-    ) !?Api.LoadedFramework {
-        if (this.client.kind == .disabled and this.server.kind == .disabled and this.fallback.kind == .disabled) return null;
-
-        return Api.LoadedFramework{
-            .package = this.package,
-            .development = this.development,
-            .display_name = this.display_name,
-            .entry_points = .{
-                .client = try this.client.toAPI(allocator, toplevel_path, .client),
-                .fallback = try this.fallback.toAPI(allocator, toplevel_path, .fallback),
-                .server = try this.server.toAPI(allocator, toplevel_path, .server),
-            },
-            .client_css_in_js = this.client_css_in_js,
-            .override_modules = this.override_modules,
-        };
-    }
-
-    pub fn needsResolveFromPackage(this: *const Framework) bool {
-        return !this.resolved and this.package.len > 0;
-    }
-
-    pub fn fromApi(
-        transform: Api.FrameworkConfig,
-        allocator: std.mem.Allocator,
-    ) !Framework {
-        var client = EntryPoint{};
-        var server = EntryPoint{};
-        var fallback = EntryPoint{};
-
-        if (transform.client) |_client| {
-            try client.fromAPI(_client, allocator, .client);
-        }
-
-        if (transform.server) |_server| {
-            try server.fromAPI(_server, allocator, .server);
-        }
-
-        if (transform.fallback) |_fallback| {
-            try fallback.fromAPI(_fallback, allocator, .fallback);
-        }
-
-        return Framework{
-            .client = client,
-            .server = server,
-            .fallback = fallback,
-            .package = transform.package orelse "",
-            .display_name = transform.display_name orelse "",
-            .development = transform.development orelse true,
-            .override_modules = transform.override_modules orelse .{ .keys = &.{}, .values = &.{} },
-            .resolved = false,
-            .client_css_in_js = switch (transform.client_css_in_js orelse .auto_onimportcss) {
-                .facade_onimportcss => .facade_onimportcss,
-                .facade => .facade,
-                else => .auto_onimportcss,
-            },
-        };
-    }
-};
-
 pub const RouteConfig = struct {
     dir: string = "",
     possible_dirs: []const string = &[_]string{},
@@ -2695,7 +2679,7 @@ pub const PathTemplate = struct {
                 .ext => try writeReplacingSlashesOnWindows(writer, self.placeholder.ext),
                 .hash => {
                     if (self.placeholder.hash) |hash| {
-                        try writer.print("{any}", .{(hashFormatter(hash))});
+                        try writer.print("{any}", .{bun.fmt.truncatedHash32(hash)});
                     }
                 },
             }
@@ -2705,34 +2689,6 @@ pub const PathTemplate = struct {
         try writeReplacingSlashesOnWindows(writer, remain);
     }
 
-    pub fn hashFormatter(int: u64) std.fmt.Formatter(hashFormatterImpl) {
-        return .{ .data = int };
-    }
-
-    fn hashFormatterImpl(int: u64, comptime fmt: []const u8, _: std.fmt.FormatOptions, writer: anytype) !void {
-        // esbuild has an 8 character truncation of a base32 encoded bytes. this
-        // is not exactly that, but it will appear as such. the character list
-        // chosen omits similar characters in the unlikely case someone is
-        // trying to memorize a hash.
-        //
-        // reminder: this cannot be base64 or any encoding which is case
-        // sensitive as these hashes are often used in file paths, in which
-        // Windows and some macOS systems treat as case-insensitive.
-        comptime assert(fmt.len == 0);
-        const in_bytes = std.mem.asBytes(&int);
-        const chars = "0123456789abcdefghjkmnpqrstvwxyz";
-        try writer.writeAll(&.{
-            chars[in_bytes[0] & 31],
-            chars[in_bytes[1] & 31],
-            chars[in_bytes[2] & 31],
-            chars[in_bytes[3] & 31],
-            chars[in_bytes[4] & 31],
-            chars[in_bytes[5] & 31],
-            chars[in_bytes[6] & 31],
-            chars[in_bytes[7] & 31],
-        });
-    }
-
     pub const Placeholder = struct {
         dir: []const u8 = "",
         name: []const u8 = "",
diff --git a/src/output.zig b/src/output.zig
index 73683d04cd..aa25b45301 100644
--- a/src/output.zig
+++ b/src/output.zig
@@ -1,4 +1,3 @@
-const Output = @This();
 const bun = @import("root").bun;
 const std = @import("std");
 const Environment = @import("./env.zig");
@@ -103,26 +102,32 @@ pub const Source = struct {
         return no_color.len != 0;
     }
 
-    pub fn isForceColor() bool {
-        const force_color = bun.getenvZ("FORCE_COLOR") orelse return false;
+    pub fn getForceColorDepth() ?ColorDepth {
+        const force_color = bun.getenvZ("FORCE_COLOR") orelse return null;
         // Supported by Node.js, if set will ignore NO_COLOR.
+        // - "0" to indicate no color support
         // - "1", "true", or "" to indicate 16-color support
         // - "2" to indicate 256-color support
         // - "3" to indicate 16 million-color support
-        return force_color.len == 0 or
-            strings.eqlComptime(force_color, "1") or
-            strings.eqlComptime(force_color, "true") or
-            strings.eqlComptime(force_color, "2") or
-            strings.eqlComptime(force_color, "3");
+        if (strings.eqlComptime(force_color, "1") or strings.eqlComptime(force_color, "true") or strings.eqlComptime(force_color, "")) {
+            return ColorDepth.@"16";
+        }
+
+        if (strings.eqlComptime(force_color, "2")) {
+            return ColorDepth.@"256";
+        }
+        if (strings.eqlComptime(force_color, "3")) {
+            return ColorDepth.@"16m";
+        }
+
+        return ColorDepth.none;
+    }
+
+    pub fn isForceColor() bool {
+        return (getForceColorDepth() orelse ColorDepth.none) != .none;
     }
 
     pub fn isColorTerminal() bool {
-        if (bun.getenvZ("COLORTERM")) |color_term| {
-            return !strings.eqlComptime(color_term, "0");
-        }
-        if (bun.getenvZ("TERM")) |term| {
-            return !strings.eqlComptime(term, "dumb");
-        }
         if (Environment.isWindows) {
             // https://github.com/chalk/supports-color/blob/d4f413efaf8da045c5ab440ed418ef02dbb28bf1/index.js#L100C11-L112
             // Windows 10 build 10586 is the first Windows release that supports 256 colors.
@@ -130,7 +135,8 @@ pub const Source = struct {
             // Every other version supports 16 colors.
             return true;
         }
-        return false;
+
+        return colorDepth() != .none;
     }
 
     export var bun_stdio_tty: [3]i32 = .{ 0, 0, 0 };
@@ -245,7 +251,7 @@ pub const Source = struct {
             const stdout = bun.sys.File.from(std.io.getStdOut());
             const stderr = bun.sys.File.from(std.io.getStdErr());
 
-            Output.Source.init(stdout, stderr)
+            Source.init(stdout, stderr)
                 .set();
 
             if (comptime Environment.isDebug or Environment.enable_logs) {
@@ -262,6 +268,131 @@ pub const Source = struct {
         }
     };
 
+    pub const ColorDepth = enum {
+        none,
+        @"16",
+        @"256",
+        @"16m",
+    };
+    var lazy_color_depth: ColorDepth = .none;
+    var color_depth_once = std.once(getColorDepthOnce);
+    fn getColorDepthOnce() void {
+        if (getForceColorDepth()) |depth| {
+            lazy_color_depth = depth;
+            return;
+        }
+
+        if (isNoColor()) {
+            return;
+        }
+
+        const term = bun.getenvZ("TERM") orelse "";
+        if (strings.eqlComptime(term, "dumb")) {
+            return;
+        }
+
+        if (bun.getenvZ("TMUX") != null) {
+            lazy_color_depth = .@"256";
+            return;
+        }
+
+        if (bun.getenvZ("CI")) |ci| {
+            inline for (.{ "APPVEYOR", "BUILDKITE", "CIRCLECI", "DRONE", "GITHUB_ACTIONS", "GITLAB_CI", "TRAVIS" }) |ci_env| {
+                if (strings.eqlComptime(ci, ci_env)) {
+                    lazy_color_depth = .@"256";
+                    return;
+                }
+            }
+
+            lazy_color_depth = .@"16";
+            return;
+        }
+
+        if (bun.getenvZ("TERM_PROGRAM")) |term_program| {
+            if (strings.eqlComptime(term_program, "iTerm.app")) {
+                lazy_color_depth = .@"16m";
+                return;
+            }
+
+            if (strings.eqlComptime(term_program, "WezTerm")) {
+                lazy_color_depth = .@"16m";
+                return;
+            }
+
+            if (strings.eqlComptime(term_program, "ghostty")) {
+                lazy_color_depth = .@"16m";
+                return;
+            }
+        }
+
+        var has_color_term_set = false;
+
+        if (bun.getenvZ("COLORTERM")) |color_term| {
+            if (strings.eqlComptime(color_term, "truecolor") or strings.eqlComptime(color_term, "24bit")) {
+                lazy_color_depth = .@"16m";
+                return;
+            }
+            has_color_term_set = true;
+        }
+
+        if (term.len > 0) {
+            if (strings.hasPrefixComptime(term, "xterm-256")) {
+                lazy_color_depth = .@"256";
+                return;
+            }
+            const pairs = .{
+                .{ "st", ColorDepth.@"16" },
+                .{ "hurd", ColorDepth.@"16" },
+                .{ "eterm", ColorDepth.@"16" },
+                .{ "gnome", ColorDepth.@"16" },
+                .{ "kterm", ColorDepth.@"16" },
+                .{ "mosh", ColorDepth.@"16m" },
+                .{ "putty", ColorDepth.@"16" },
+                .{ "cons25", ColorDepth.@"16" },
+                .{ "cygwin", ColorDepth.@"16" },
+                .{ "dtterm", ColorDepth.@"16" },
+                .{ "mlterm", ColorDepth.@"16" },
+                .{ "console", ColorDepth.@"16" },
+                .{ "jfbterm", ColorDepth.@"16" },
+                .{ "konsole", ColorDepth.@"16" },
+                .{ "terminator", ColorDepth.@"16m" },
+                .{ "xterm-ghostty", ColorDepth.@"16m" },
+                .{ "rxvt-unicode-24bit", ColorDepth.@"16m" },
+            };
+
+            inline for (pairs) |pair| {
+                if (strings.eqlComptime(term, pair[0])) {
+                    lazy_color_depth = pair[1];
+                    return;
+                }
+            }
+
+            if (strings.includes(term, "con") or
+                strings.includes(term, "ansi") or
+                strings.includes(term, "rxvt") or
+                strings.includes(term, "color") or
+                strings.includes(term, "linux") or
+                strings.includes(term, "vt100") or
+                strings.includes(term, "xterm") or
+                strings.includes(term, "screen"))
+            {
+                lazy_color_depth = .@"16";
+                return;
+            }
+        }
+
+        if (has_color_term_set) {
+            lazy_color_depth = .@"16";
+            return;
+        }
+
+        lazy_color_depth = .none;
+    }
+    pub fn colorDepth() ColorDepth {
+        color_depth_once.call();
+        return lazy_color_depth;
+    }
+
     pub fn set(new_source: *const Source) void {
         source = new_source.*;
 
@@ -269,13 +400,6 @@ pub const Source = struct {
         if (!stdout_stream_set) {
             stdout_stream_set = true;
             if (comptime Environment.isNative) {
-                var enable_color: ?bool = null;
-                if (isForceColor()) {
-                    enable_color = true;
-                } else if (isNoColor() or !isColorTerminal()) {
-                    enable_color = false;
-                }
-
                 const is_stdout_tty = bun_stdio_tty[1] != 0;
                 if (is_stdout_tty) {
                     stdout_descriptor_type = OutputStreamDescriptor.terminal;
@@ -286,6 +410,15 @@ pub const Source = struct {
                     stderr_descriptor_type = OutputStreamDescriptor.terminal;
                 }
 
+                var enable_color: ?bool = null;
+                if (isForceColor()) {
+                    enable_color = true;
+                } else if (isNoColor()) {
+                    enable_color = false;
+                } else if (isColorTerminal() and (is_stdout_tty or is_stderr_tty)) {
+                    enable_color = true;
+                }
+
                 enable_ansi_colors_stdout = enable_color orelse is_stdout_tty;
                 enable_ansi_colors_stderr = enable_color orelse is_stderr_tty;
                 enable_ansi_colors = enable_ansi_colors_stdout or enable_ansi_colors_stderr;
@@ -335,42 +468,49 @@ pub fn isVerbose() bool {
     return false;
 }
 
-var _source_for_test: if (Environment.isTest) Output.Source else void = undefined;
+var _source_for_test: if (Environment.isTest) Source else void = undefined;
 var _source_for_test_set = false;
 pub fn initTest() void {
     if (_source_for_test_set) return;
     _source_for_test_set = true;
     const in = std.io.getStdErr();
     const out = std.io.getStdOut();
-    _source_for_test = Output.Source.init(File.from(out), File.from(in));
-    Output.Source.set(&_source_for_test);
+    _source_for_test = Source.init(File.from(out), File.from(in));
+    Source.set(&_source_for_test);
 }
 pub fn enableBuffering() void {
     if (comptime Environment.isNative) enable_buffering = true;
 }
 
 pub fn disableBuffering() void {
-    Output.flush();
+    flush();
     if (comptime Environment.isNative) enable_buffering = false;
 }
 
 pub fn panic(comptime fmt: string, args: anytype) noreturn {
     @setCold(true);
 
-    if (Output.isEmojiEnabled()) {
-        std.debug.panic(comptime Output.prettyFmt(fmt, true), args);
+    if (isEmojiEnabled()) {
+        std.debug.panic(comptime prettyFmt(fmt, true), args);
     } else {
-        std.debug.panic(comptime Output.prettyFmt(fmt, false), args);
+        std.debug.panic(comptime prettyFmt(fmt, false), args);
     }
 }
 
 pub const WriterType: type = @TypeOf(Source.StreamType.quietWriter(undefined));
 
+// TODO: investigate migrating this to the buffered one.
 pub fn errorWriter() WriterType {
     bun.debugAssert(source_set);
     return source.error_stream.quietWriter();
 }
 
+pub fn errorWriterBuffered() Source.BufferedStream.Writer {
+    bun.debugAssert(source_set);
+    return source.buffered_error_stream.writer();
+}
+
+// TODO: investigate returning the buffered_error_stream
 pub fn errorStream() Source.StreamType {
     bun.debugAssert(source_set);
     return source.error_stream;
@@ -471,11 +611,11 @@ pub noinline fn printElapsedTo(elapsed: f64, comptime printerFn: anytype, ctx: a
 }
 
 pub fn printElapsed(elapsed: f64) void {
-    printElapsedToWithCtx(elapsed, Output.prettyError, false, {});
+    printElapsedToWithCtx(elapsed, prettyError, false, {});
 }
 
 pub fn printElapsedStdout(elapsed: f64) void {
-    printElapsedToWithCtx(elapsed, Output.pretty, false, {});
+    printElapsedToWithCtx(elapsed, pretty, false, {});
 }
 
 pub fn printElapsedStdoutTrim(elapsed: f64) void {
@@ -569,19 +709,31 @@ pub noinline fn print(comptime fmt: string, args: anytype) callconv(std.builtin.
 ///   BUN_DEBUG_foo=1
 /// To enable all logs, set the environment variable
 ///   BUN_DEBUG_ALL=1
-const LogFunction = fn (comptime fmt: string, args: anytype) void;
+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 fn isVisible() bool {
+            pub inline fn isVisible() bool {
                 return false;
             }
-            pub fn log(comptime _: string, _: anytype) void {}
+            pub inline fn log(comptime _: string, _: anytype) void {}
         };
     }
 
@@ -598,12 +750,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;
@@ -645,7 +807,7 @@ pub fn Scoped(comptime tag: anytype, comptime disabled: bool) type {
             lock.lock();
             defer lock.unlock();
 
-            if (Output.enable_ansi_colors_stdout and source_set and buffered_writer.unbuffered_writer.context.handle == writer().context.handle) {
+            if (enable_ansi_colors_stdout and source_set and buffered_writer.unbuffered_writer.context.handle == writer().context.handle) {
                 out.print(comptime prettyFmt("<r><d>[" ++ tagname ++ "]<r> " ++ fmt, true), args) catch {
                     really_disable = true;
                     return;
@@ -669,7 +831,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":
@@ -870,17 +1035,17 @@ pub const DebugTimer = struct {
     }
 };
 
-/// Print a blue note message
+/// Print a blue note message to stderr
 pub inline fn note(comptime fmt: []const u8, args: anytype) void {
     prettyErrorln("<blue>note<r><d>:<r> " ++ fmt, args);
 }
 
-/// Print a yellow warning message
+/// Print a yellow warning message to stderr
 pub inline fn warn(comptime fmt: []const u8, args: anytype) void {
     prettyErrorln("<yellow>warn<r><d>:<r> " ++ fmt, args);
 }
 
-const debugWarnScope = Scoped("debug warn", false);
+const debugWarnScope = Scoped("debug_warn", false);
 
 /// Print a yellow warning message, only in debug mode
 pub inline fn debugWarn(comptime fmt: []const u8, args: anytype) void {
@@ -991,7 +1156,7 @@ pub fn initScopedDebugWriterAtStartup() void {
             const fd = std.fs.cwd().createFile(path_fmt, .{
                 .mode = if (Environment.isPosix) 0o644 else 0,
             }) catch |open_err| {
-                Output.panic("Failed to open file for debug output: {s} ({s})", .{ @errorName(open_err), path });
+                panic("Failed to open file for debug output: {s} ({s})", .{ @errorName(open_err), path });
             };
             _ = bun.sys.ftruncate(bun.toFD(fd), 0); // windows
             ScopedDebugWriter.scoped_file_writer = File.from(fd).quietWriter();
diff --git a/src/patch.zig b/src/patch.zig
index be170ab084..55b5780a3b 100644
--- a/src/patch.zig
+++ b/src/patch.zig
@@ -1094,20 +1094,18 @@ const PatchLinesParser = struct {
 };
 
 pub const TestingAPIs = struct {
-    pub fn makeDiff(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
-        const arguments_ = callframe.arguments(2);
+    pub fn makeDiff(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+        const arguments_ = callframe.arguments_old(2);
         var arguments = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments_.slice());
 
         const old_folder_jsval = arguments.nextEat() orelse {
-            globalThis.throw("expected 2 strings", .{});
-            return .undefined;
+            return globalThis.throw("expected 2 strings", .{});
         };
         const old_folder_bunstr = old_folder_jsval.toBunString(globalThis);
         defer old_folder_bunstr.deref();
 
         const new_folder_jsval = arguments.nextEat() orelse {
-            globalThis.throw("expected 2 strings", .{});
-            return .undefined;
+            return globalThis.throw("expected 2 strings", .{});
         };
         const new_folder_bunstr = new_folder_jsval.toBunString(globalThis);
         defer new_folder_bunstr.deref();
@@ -1119,8 +1117,7 @@ pub const TestingAPIs = struct {
         defer new_folder.deinit();
 
         return switch (gitDiffInternal(bun.default_allocator, old_folder.slice(), new_folder.slice()) catch |e| {
-            globalThis.throwError(e, "failed to make diff");
-            return .undefined;
+            return globalThis.throwError(e, "failed to make diff");
         }) {
             .result => |s| {
                 defer s.deinit();
@@ -1128,8 +1125,7 @@ pub const TestingAPIs = struct {
             },
             .err => |e| {
                 defer e.deinit();
-                globalThis.throw("failed to make diff: {s}", .{e.items});
-                return .undefined;
+                return globalThis.throw("failed to make diff: {s}", .{e.items});
             },
         };
     }
@@ -1146,7 +1142,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,
@@ -1154,47 +1150,42 @@ pub const TestingAPIs = struct {
         defer args.deinit();
 
         if (args.patchfile.apply(bun.default_allocator, args.dirfd)) |err| {
-            globalThis.throwValue(err.toErrorInstance(globalThis));
-            return .undefined;
+            return globalThis.throwValue(err.toErrorInstance(globalThis));
         }
 
         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 {
-        const arguments_ = callframe.arguments(2);
+    pub fn parse(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+        const arguments_ = callframe.arguments_old(2);
         var arguments = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments_.slice());
 
         const patchfile_src_js = arguments.nextEat() orelse {
-            globalThis.throw("TestingAPIs.parse: expected at least 1 argument, got 0", .{});
-            return .undefined;
+            return globalThis.throw("TestingAPIs.parse: expected at least 1 argument, got 0", .{});
         };
         const patchfile_src_bunstr = patchfile_src_js.toBunString(globalThis);
         const patchfile_src = patchfile_src_bunstr.toUTF8(bun.default_allocator);
 
         var patchfile = parsePatchFile(patchfile_src.slice()) catch |e| {
             if (e == error.hunk_header_integrity_check_failed) {
-                globalThis.throwError(e, "this indicates either that the supplied patch file was incorrect, or there is a bug in Bun. Please check your .patch file, or open a GitHub issue :)");
-            } else globalThis.throwError(e, "failed to parse patch file");
-
-            return .undefined;
+                return globalThis.throwError(e, "this indicates either that the supplied patch file was incorrect, or there is a bug in Bun. Please check your .patch file, or open a GitHub issue :)");
+            } else {
+                return globalThis.throwError(e, "failed to parse patch file");
+            }
         };
         defer patchfile.deinit(bun.default_allocator);
 
-        const str = std.json.stringifyAlloc(bun.default_allocator, patchfile, .{}) catch {
-            globalThis.throwOutOfMemory();
-            return .undefined;
-        };
+        const str = try std.json.stringifyAlloc(bun.default_allocator, patchfile, .{});
         const outstr = bun.String.fromUTF8(str);
         return outstr.toJS(globalThis);
     }
 
     pub fn parseApplyArgs(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSC.Node.Maybe(ApplyArgs, JSC.JSValue) {
-        const arguments_ = callframe.arguments(2);
+        const arguments_ = callframe.arguments_old(2);
         var arguments = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments_.slice());
 
         const patchfile_js = arguments.nextEat() orelse {
-            globalThis.throw("apply: expected at least 1 argument, got 0", .{});
+            globalThis.throw("apply: expected at least 1 argument, got 0", .{}) catch {};
             return .{ .err = .undefined };
         };
 
@@ -1206,7 +1197,7 @@ pub const TestingAPIs = struct {
 
             break :brk switch (bun.sys.open(path, bun.O.DIRECTORY | bun.O.RDONLY, 0)) {
                 .err => |e| {
-                    globalThis.throwValue(e.withPath(path).toJSC(globalThis));
+                    globalThis.throwValue(e.withPath(path).toJSC(globalThis)) catch {};
                     return .{ .err = .undefined };
                 },
                 .result => |fd| fd,
@@ -1223,7 +1214,7 @@ pub const TestingAPIs = struct {
             }
 
             patchfile_src.deinit();
-            globalThis.throwError(e, "failed to parse patchfile");
+            globalThis.throwError(e, "failed to parse patchfile") catch {};
             return .{ .err = .undefined };
         };
 
diff --git a/src/renamer.zig b/src/renamer.zig
index 30c6a21ecf..c41e4ca66c 100644
--- a/src/renamer.zig
+++ b/src/renamer.zig
@@ -751,9 +751,9 @@ pub const NumberRenamer = struct {
                     mutable_name.appendSlice(prefix) catch unreachable;
                     mutable_name.appendInt(tries) catch unreachable;
 
-                    switch (NameUse.find(this, mutable_name.toOwnedSliceLeaky())) {
+                    switch (NameUse.find(this, mutable_name.slice())) {
                         .unused => {
-                            name = mutable_name.toOwnedSliceLeaky();
+                            name = mutable_name.slice();
 
                             if (use == .same_scope) {
                                 const existing = this.name_counts.getOrPut(allocator, prefix) catch unreachable;
@@ -775,7 +775,7 @@ pub const NumberRenamer = struct {
 
                                 tries += 1;
 
-                                switch (NameUse.find(this, mutable_name.toOwnedSliceLeaky())) {
+                                switch (NameUse.find(this, mutable_name.slice())) {
                                     .unused => {
                                         if (cur_use == .same_scope) {
                                             const existing = this.name_counts.getOrPut(allocator, prefix) catch unreachable;
@@ -790,7 +790,7 @@ pub const NumberRenamer = struct {
                                             existing.value_ptr.* = tries;
                                         }
 
-                                        name = mutable_name.toOwnedSliceLeaky();
+                                        name = mutable_name.slice();
                                         break;
                                     },
                                     else => {},
@@ -847,7 +847,7 @@ pub const ExportRenamer = struct {
                 var writer = this.string_buffer.writer();
                 writer.print("{s}{d}", .{ input, tries }) catch unreachable;
                 tries += 1;
-                const attempt = this.string_buffer.toOwnedSliceLeaky();
+                const attempt = this.string_buffer.slice();
                 entry = this.used.getOrPut(attempt) catch unreachable;
                 if (!entry.found_existing) {
                     const to_use = this.string_buffer.allocator.dupe(u8, attempt) catch unreachable;
@@ -875,6 +875,7 @@ pub const ExportRenamer = struct {
 
 pub fn computeInitialReservedNames(
     allocator: std.mem.Allocator,
+    output_format: bun.options.Format,
 ) !bun.StringHashMapUnmanaged(u32) {
     if (comptime bun.Environment.isWasm) {
         unreachable;
@@ -887,9 +888,17 @@ pub fn computeInitialReservedNames(
         "Require",
     };
 
+    const cjs_names = .{
+        "exports",
+        "module",
+    };
+
+    const cjs_names_len: u32 = if (output_format == .cjs) cjs_names.len else 0;
+
     try names.ensureTotalCapacityContext(
         allocator,
-        @as(u32, @truncate(JSLexer.Keywords.keys().len + JSLexer.StrictModeReservedWords.keys().len + 1 + extras.len)),
+        cjs_names_len +
+            @as(u32, @truncate(JSLexer.Keywords.keys().len + JSLexer.StrictModeReservedWords.keys().len + 1 + extras.len)),
         bun.StringHashMapContext{},
     );
 
@@ -901,6 +910,19 @@ pub fn computeInitialReservedNames(
         names.putAssumeCapacity(keyword, 1);
     }
 
+    // Node contains code that scans CommonJS modules in an attempt to statically
+    // detect the set of export names that a module will use. However, it doesn't
+    // do any scope analysis so it can be fooled by local variables with the same
+    // name as the CommonJS module-scope variables "exports" and "module". Avoid
+    // using these names in this case even if there is not a risk of a name
+    // collision because there is still a risk of node incorrectly detecting
+    // something in a nested scope as an top-level export.
+    if (output_format == .cjs) {
+        inline for (cjs_names) |name| {
+            names.putAssumeCapacity(name, 1);
+        }
+    }
+
     inline for (comptime extras) |extra| {
         names.putAssumeCapacity(extra, 1);
     }
diff --git a/src/resolver/package_json.zig b/src/resolver/package_json.zig
index baa90d2f52..b801b6c11c 100644
--- a/src/resolver/package_json.zig
+++ b/src/resolver/package_json.zig
@@ -106,6 +106,7 @@ pub const PackageJSON = struct {
     hash: u32 = 0xDEADBEEF,
 
     scripts: ?*ScriptsMap = null,
+    config: ?*bun.StringArrayHashMap(string) = null,
 
     arch: Architecture = Architecture.all,
     os: OperatingSystem = OperatingSystem.all,
@@ -148,9 +149,9 @@ pub const PackageJSON = struct {
     pub const SideEffects = union(enum) {
         /// either `package.json` is missing "sideEffects", it is true, or some
         /// other unsupported value. Treat all files as side effects
-        unspecified: void,
+        unspecified,
         /// "sideEffects": false
-        false: void,
+        false,
         /// "sideEffects": ["file.js", "other.js"]
         map: Map,
         // /// "sideEffects": ["side_effects/*.js"]
@@ -641,7 +642,7 @@ pub const PackageJSON = struct {
         var json_source = logger.Source.initPathString(key_path.text, entry.contents);
         json_source.path.pretty = r.prettyPath(json_source.path);
 
-        const json: js_ast.Expr = (r.caches.json.parsePackageJSON(r.log, json_source, allocator) catch |err| {
+        const json: js_ast.Expr = (r.caches.json.parsePackageJSON(r.log, json_source, allocator, true) catch |err| {
             if (Environment.isDebug) {
                 Output.printError("{s}: JSON parse error: {s}", .{ package_json_path, @errorName(err) });
             }
@@ -727,7 +728,7 @@ pub const PackageJSON = struct {
             }
 
             // Read the "browser" property, but only when targeting the browser
-            if (r.opts.target.supportsBrowserField()) {
+            if (r.opts.target == .browser) {
                 // We both want the ability to have the option of CJS vs. ESM and the
                 // option of having node vs. browser. The way to do this is to use the
                 // object literal form of the "browser" field like this:
@@ -860,6 +861,7 @@ pub const PackageJSON = struct {
                                 .npm,
                                 &sliced,
                                 r.log,
+                                pm,
                             )) |dependency_version| {
                                 if (dependency_version.value.npm.version.isExact()) {
                                     if (pm.lockfile.resolve(package_json.name, dependency_version)) |resolved| {
@@ -981,6 +983,7 @@ pub const PackageJSON = struct {
                                         version_str,
                                         &sliced_str,
                                         r.log,
+                                        r.package_manager,
                                     )) |dependency_version| {
                                         const dependency = Dependency{
                                             .name = name,
@@ -1004,36 +1007,11 @@ pub const PackageJSON = struct {
 
         // used by `bun run`
         if (include_scripts) {
-            read_scripts: {
-                if (json.asProperty("scripts")) |scripts_prop| {
-                    if (scripts_prop.expr.data == .e_object) {
-                        const scripts_obj = scripts_prop.expr.data.e_object;
-
-                        var count: usize = 0;
-                        for (scripts_obj.properties.slice()) |prop| {
-                            const key = prop.key.?.asString(allocator) orelse continue;
-                            const value = prop.value.?.asString(allocator) orelse continue;
-
-                            count += @as(usize, @intFromBool(key.len > 0 and value.len > 0));
-                        }
-
-                        if (count == 0) break :read_scripts;
-                        var scripts = ScriptsMap.init(allocator);
-                        scripts.ensureUnusedCapacity(count) catch break :read_scripts;
-
-                        for (scripts_obj.properties.slice()) |prop| {
-                            const key = prop.key.?.asString(allocator) orelse continue;
-                            const value = prop.value.?.asString(allocator) orelse continue;
-
-                            if (!(key.len > 0 and value.len > 0)) continue;
-
-                            scripts.putAssumeCapacity(key, value);
-                        }
-
-                        package_json.scripts = allocator.create(ScriptsMap) catch unreachable;
-                        package_json.scripts.?.* = scripts;
-                    }
-                }
+            if (json.asPropertyStringMap("scripts", allocator)) |scripts| {
+                package_json.scripts = scripts;
+            }
+            if (json.asPropertyStringMap("config", allocator)) |config| {
+                package_json.config = config;
             }
         }
 
diff --git a/src/resolver/resolve_path.zig b/src/resolver/resolve_path.zig
index 6a9f7fb992..e493bcd998 100644
--- a/src/resolver/resolve_path.zig
+++ b/src/resolver/resolve_path.zig
@@ -613,6 +613,8 @@ fn windowsVolumeNameLenT(comptime T: type, path: []const T) struct { usize, usiz
                     }
                 }
             }
+
+            return .{ path.len, 0 };
         } else {
             if (bun.strings.indexAnyComptimeT(T, path[3..], strings.literal(T, "/\\"))) |idx| {
                 // TODO: handle input "//abc//def" should be picked up as a unc path
@@ -624,6 +626,7 @@ fn windowsVolumeNameLenT(comptime T: type, path: []const T) struct { usize, usiz
                     }
                 }
             }
+            return .{ path.len, 0 };
         }
     }
     return .{ 0, 0 };
@@ -678,6 +681,7 @@ pub fn windowsFilesystemRootT(comptime T: type, path: []const T) []const T {
                 return path[0..2];
         }
     }
+
     // UNC
     if (path.len >= 5 and
         Platform.windows.isSeparatorT(T, path[0]) and
@@ -685,13 +689,14 @@ pub fn windowsFilesystemRootT(comptime T: type, path: []const T) []const T {
         !Platform.windows.isSeparatorT(T, path[2]) and
         path[2] != '.')
     {
-        if (bun.strings.indexAnyComptimeT(T, path[3..], "/\\")) |idx| {
-            if (bun.strings.indexAnyComptimeT(T, path[4 + idx ..], "/\\")) |idx_second| {
+        if (bun.strings.indexOfAnyT(T, path[3..], "/\\")) |idx| {
+            if (bun.strings.indexOfAnyT(T, path[4 + idx ..], "/\\")) |idx_second| {
                 return path[0 .. idx + idx_second + 4 + 1]; // +1 to skip second separator
             }
-            return path[0..];
         }
+        return path[0..];
     }
+
     if (isSepAnyT(T, path[0])) return path[0..1];
     return path[0..0];
 }
@@ -793,12 +798,18 @@ pub fn normalizeStringGenericTZ(
                 } else {
                     @memcpy(buf[buf_i .. buf_i + 2], strings.literal(T, sep_str ++ sep_str));
                 }
-                @memcpy(buf[buf_i + 2 .. buf_i + indexOfThirdUNCSlash + 1], path_[2 .. indexOfThirdUNCSlash + 1]);
-                buf[buf_i + indexOfThirdUNCSlash] = options.separator;
-                @memcpy(
-                    buf[buf_i + indexOfThirdUNCSlash + 1 .. buf_i + volLen],
-                    path_[indexOfThirdUNCSlash + 1 .. volLen],
-                );
+                if (indexOfThirdUNCSlash > 0) {
+                    // we have the ending slash
+                    @memcpy(buf[buf_i + 2 .. buf_i + indexOfThirdUNCSlash + 1], path_[2 .. indexOfThirdUNCSlash + 1]);
+                    buf[buf_i + indexOfThirdUNCSlash] = options.separator;
+                    @memcpy(
+                        buf[buf_i + indexOfThirdUNCSlash + 1 .. buf_i + volLen],
+                        path_[indexOfThirdUNCSlash + 1 .. volLen],
+                    );
+                } else {
+                    // we dont have the ending slash
+                    @memcpy(buf[buf_i + 2 .. buf_i + volLen], path_[2..volLen]);
+                }
                 buf[buf_i + volLen] = options.separator;
                 buf_i += volLen + 1;
                 path_begin = volLen + 1;
@@ -904,7 +915,7 @@ pub fn normalizeStringGenericTZ(
 
         // real path element.
         // add slash if needed
-        if (buf_i != buf_start and !options.isSeparator(buf[buf_i - 1])) {
+        if (buf_i != buf_start and buf_i > 0 and !options.isSeparator(buf[buf_i - 1])) {
             buf[buf_i] = options.separator;
             buf_i += 1;
         }
@@ -1147,6 +1158,12 @@ pub fn normalizeBuf(str: []const u8, buf: []u8, comptime _platform: Platform) []
     return normalizeBufT(u8, str, buf, _platform);
 }
 
+pub fn normalizeBufZ(str: []const u8, buf: []u8, comptime _platform: Platform) [:0]u8 {
+    const norm = normalizeBufT(u8, str, buf, _platform);
+    buf[norm.len] = 0;
+    return buf[0..norm.len :0];
+}
+
 pub fn normalizeBufT(comptime T: type, str: []const T, buf: []T, comptime _platform: Platform) []T {
     if (str.len == 0) {
         buf[0] = '.';
@@ -1231,12 +1248,8 @@ pub fn joinAbs2(_cwd: []const u8, comptime _platform: Platform, part: anytype, p
     return slice;
 }
 
-pub fn joinAbs(_cwd: []const u8, comptime _platform: Platform, part: anytype) []const u8 {
-    const parts = [_][]const u8{
-        part,
-    };
-    const slice = joinAbsString(_cwd, &parts, _platform);
-    return slice;
+pub fn joinAbs(cwd: []const u8, comptime _platform: Platform, part: []const u8) []const u8 {
+    return joinAbsString(cwd, &.{part}, _platform);
 }
 
 // Convert parts of potentially invalid file paths into a single valid filpeath
@@ -1889,6 +1902,14 @@ pub const PosixToWinNormalizer = struct {
         return resolveWithExternalBuf(&this._raw_bytes, source_dir, maybe_posix_path);
     }
 
+    pub inline fn resolveZ(
+        this: *PosixToWinNormalizer,
+        source_dir: []const u8,
+        maybe_posix_path: [:0]const u8,
+    ) [:0]const u8 {
+        return resolveWithExternalBufZ(&this._raw_bytes, source_dir, maybe_posix_path);
+    }
+
     pub inline fn resolveCWD(
         this: *PosixToWinNormalizer,
         maybe_posix_path: []const u8,
@@ -1921,9 +1942,37 @@ pub const PosixToWinNormalizer = struct {
                     @memcpy(buf[source_root.len..][0 .. maybe_posix_path.len - 1], maybe_posix_path[1..]);
                     const res = buf[0 .. source_root.len + maybe_posix_path.len - 1];
                     assert(!bun.strings.isWindowsAbsolutePathMissingDriveLetter(u8, res));
+                    assert(std.fs.path.isAbsoluteWindows(res));
                     return res;
                 }
             }
+            assert(!bun.strings.isWindowsAbsolutePathMissingDriveLetter(u8, maybe_posix_path));
+        }
+        return maybe_posix_path;
+    }
+
+    fn resolveWithExternalBufZ(
+        buf: *Buf,
+        source_dir: []const u8,
+        maybe_posix_path: [:0]const u8,
+    ) [:0]const u8 {
+        assert(std.fs.path.isAbsoluteWindows(maybe_posix_path));
+        if (bun.Environment.isWindows) {
+            const root = windowsFilesystemRoot(maybe_posix_path);
+            if (root.len == 1) {
+                assert(isSepAny(root[0]));
+                if (bun.strings.isWindowsAbsolutePathMissingDriveLetter(u8, maybe_posix_path)) {
+                    const source_root = windowsFilesystemRoot(source_dir);
+                    @memcpy(buf[0..source_root.len], source_root);
+                    @memcpy(buf[source_root.len..][0 .. maybe_posix_path.len - 1], maybe_posix_path[1..]);
+                    buf[source_root.len + maybe_posix_path.len - 1] = 0;
+                    const res = buf[0 .. source_root.len + maybe_posix_path.len - 1 :0];
+                    assert(!bun.strings.isWindowsAbsolutePathMissingDriveLetter(u8, res));
+                    assert(std.fs.path.isAbsoluteWindows(res));
+                    return res;
+                }
+            }
+            assert(!bun.strings.isWindowsAbsolutePathMissingDriveLetter(u8, maybe_posix_path));
         }
         return maybe_posix_path;
     }
@@ -1946,9 +1995,11 @@ pub const PosixToWinNormalizer = struct {
                     @memcpy(buf[source_root.len..][0 .. maybe_posix_path.len - 1], maybe_posix_path[1..]);
                     const res = buf[0 .. source_root.len + maybe_posix_path.len - 1];
                     assert(!bun.strings.isWindowsAbsolutePathMissingDriveLetter(u8, res));
+                    assert(std.fs.path.isAbsoluteWindows(res));
                     return res;
                 }
             }
+            assert(!bun.strings.isWindowsAbsolutePathMissingDriveLetter(u8, maybe_posix_path));
         }
 
         return maybe_posix_path;
@@ -1973,9 +2024,12 @@ pub const PosixToWinNormalizer = struct {
                     buf[source_root.len + maybe_posix_path.len - 1] = 0;
                     const res = buf[0 .. source_root.len + maybe_posix_path.len - 1 :0];
                     assert(!bun.strings.isWindowsAbsolutePathMissingDriveLetter(u8, res));
+                    assert(std.fs.path.isAbsoluteWindows(res));
                     return res;
                 }
             }
+
+            assert(!bun.strings.isWindowsAbsolutePathMissingDriveLetter(u8, maybe_posix_path));
         }
 
         @memcpy(buf.ptr, maybe_posix_path);
diff --git a/src/resolver/resolver.zig b/src/resolver/resolver.zig
index 11052982e7..c765c9f79b 100644
--- a/src/resolver/resolver.zig
+++ b/src/resolver/resolver.zig
@@ -155,7 +155,6 @@ pub const PathPair = struct {
     }
 };
 
-// this is ripped from esbuild, comments included
 pub const SideEffects = enum {
     /// The default value conservatively considers all files to have side effects.
     has_side_effects,
@@ -564,7 +563,7 @@ pub const Resolver = struct {
 
     pub fn getPackageManager(this: *Resolver) *PackageManager {
         return this.package_manager orelse brk: {
-            bun.HTTPThread.init();
+            bun.HTTPThread.init(&.{});
             const pm = PackageManager.initWithRuntime(
                 this.log,
                 this.opts.install,
@@ -574,7 +573,7 @@ pub const Resolver = struct {
 
                 .{},
                 this.env_loader.?,
-            ) catch @panic("Failed to initialize package manager");
+            );
             pm.onWake = this.onWakePackageManager;
             this.package_manager = pm;
             break :brk pm;
@@ -621,7 +620,7 @@ pub const Resolver = struct {
             .fs = _fs,
             .log = log,
             .extension_order = opts.extension_order.default.default,
-            .care_about_browser_field = opts.target.isWebLike(),
+            .care_about_browser_field = opts.target == .browser,
         };
     }
 
@@ -652,144 +651,8 @@ pub const Resolver = struct {
             }
         }
     }
+
     var tracing_start: i128 = if (FeatureFlags.tracing) 0 else undefined;
-
-    pub const bunFrameworkPackagePrefix = "bun-framework-";
-    pub fn resolveFramework(
-        r: *ThisResolver,
-        package: string,
-        pair: *PackageJSON.FrameworkRouterPair,
-        comptime preference: PackageJSON.LoadFramework,
-        comptime load_defines: bool,
-    ) !void {
-        // We want to enable developers to integrate frameworks without waiting on official support.
-        // But, we still want the command to do the actual framework integration to be succinct
-        // This lets users type "--use next" instead of "--use bun-framework-next"
-        // If they're using a local file path, we skip this.
-        if (isPackagePath(package)) {
-            var prefixed_package_buf: [512]u8 = undefined;
-            // Prevent the extra lookup if the package is already prefixed, i.e. avoid "bun-framework-next-bun-framework-next"
-            if (strings.startsWith(package, bunFrameworkPackagePrefix) or package.len + bunFrameworkPackagePrefix.len >= prefixed_package_buf.len) {
-                return r._resolveFramework(package, pair, preference, load_defines) catch |err| {
-                    switch (err) {
-                        error.ModuleNotFound => {
-                            Output.prettyErrorln("<r><red>ResolveError<r> can't find framework: <b>\"{s}\"<r>.\n\nMaybe it's not installed? Try running this:\n\n   <b>bun add -d {s}<r>\n   <b>bun bun --use {s}<r>", .{ package, package, package });
-                            Global.exit(1);
-                        },
-                        else => {
-                            return err;
-                        },
-                    }
-                };
-            }
-
-            prefixed_package_buf[0..bunFrameworkPackagePrefix.len].* = bunFrameworkPackagePrefix.*;
-            bun.copy(u8, prefixed_package_buf[bunFrameworkPackagePrefix.len..], package);
-            const prefixed_name = prefixed_package_buf[0 .. bunFrameworkPackagePrefix.len + package.len];
-            return r._resolveFramework(prefixed_name, pair, preference, load_defines) catch |err| {
-                switch (err) {
-                    error.ModuleNotFound => {
-                        return r._resolveFramework(package, pair, preference, load_defines) catch |err2| {
-                            switch (err2) {
-                                error.ModuleNotFound => {
-                                    Output.prettyErrorln("<r><red>ResolveError<r> can't find framework: <b>\"{s}\"<r>.\n\nMaybe it's not installed? Try running this:\n\n   <b>bun add -d {s}\n   <b>bun bun --use {s}<r>", .{ package, prefixed_name, package });
-                                    Global.exit(1);
-                                },
-                                else => {
-                                    return err;
-                                },
-                            }
-                        };
-                    },
-                    else => {
-                        return err;
-                    },
-                }
-            };
-        }
-
-        return r._resolveFramework(package, pair, preference, load_defines) catch |err| {
-            switch (err) {
-                error.ModuleNotFound => {
-                    Output.prettyError("<r><red>ResolveError<r> can't find local framework: <b>\"{s}\"<r>.", .{package});
-                    Global.exit(1);
-                },
-                else => {
-                    return err;
-                },
-            }
-        };
-    }
-
-    fn _resolveFramework(
-        r: *ThisResolver,
-        package: string,
-        pair: *PackageJSON.FrameworkRouterPair,
-        comptime preference: PackageJSON.LoadFramework,
-        comptime load_defines: bool,
-    ) !void {
-
-        // TODO: make this only parse package.json once
-        var result = try r.resolve(r.fs.top_level_dir, package, .internal);
-        // support passing a package.json or path to a package
-        const pkg: *const PackageJSON = result.package_json orelse r.packageJSONForResolvedNodeModuleWithIgnoreMissingName(&result, true) orelse return error.MissingPackageJSON;
-
-        const json = (try r.caches.json.parsePackageJSON(r.log, pkg.source, r.allocator)) orelse return error.JSONParseError;
-
-        pkg.loadFrameworkWithPreference(pair, json, r.allocator, load_defines, preference);
-        const dir = pkg.source.path.sourceDir();
-
-        var buf: bun.PathBuffer = undefined;
-
-        pair.framework.resolved_dir = pkg.source.path.sourceDir();
-
-        if (pair.framework.client.isEnabled()) {
-            var parts = [_]string{ dir, pair.framework.client.path };
-            const abs = r.fs.abs(&parts);
-            pair.framework.client.path = try r.allocator.dupe(u8, abs);
-            pair.framework.resolved = true;
-        }
-
-        if (pair.framework.server.isEnabled()) {
-            var parts = [_]string{ dir, pair.framework.server.path };
-            const abs = r.fs.abs(&parts);
-            pair.framework.server.path = try r.allocator.dupe(u8, abs);
-            pair.framework.resolved = true;
-        }
-
-        if (pair.framework.fallback.isEnabled()) {
-            var parts = [_]string{ dir, pair.framework.fallback.path };
-            const abs = r.fs.abs(&parts);
-            pair.framework.fallback.path = try r.allocator.dupe(u8, abs);
-            pair.framework.resolved = true;
-        }
-
-        if (pair.loaded_routes) {
-            const chosen_dir: string = brk: {
-                if (pair.router.possible_dirs.len > 0) {
-                    for (pair.router.possible_dirs) |route_dir| {
-                        var parts = [_]string{ r.fs.top_level_dir, std.fs.path.sep_str, route_dir };
-                        const abs = r.fs.join(&parts);
-                        // must end in trailing slash
-                        break :brk (std.posix.realpath(abs, &buf) catch continue);
-                    }
-                    return error.MissingRouteDir;
-                } else {
-                    var parts = [_]string{ r.fs.top_level_dir, std.fs.path.sep_str, pair.router.dir };
-                    const abs = r.fs.join(&parts);
-                    // must end in trailing slash
-                    break :brk std.posix.realpath(abs, &buf) catch return error.MissingRouteDir;
-                }
-            };
-
-            var out = try r.allocator.alloc(u8, chosen_dir.len + 1);
-            bun.copy(u8, out, chosen_dir);
-            out[out.len - 1] = '/';
-            pair.router.dir = out;
-            pair.router.routes_enabled = true;
-        }
-    }
-
     pub fn resolveAndAutoInstall(
         r: *ThisResolver,
         source_dir: string,
@@ -894,7 +757,7 @@ pub const Resolver = struct {
                         .primary = Path.init(import_path),
                     },
                     .is_external = true,
-                    .module_type = .esm,
+                    .module_type = if (!kind.isFromCSS()) .esm else .unknown,
                 },
             };
         }
@@ -1048,6 +911,29 @@ pub const Resolver = struct {
         }
     }
 
+    /// Runs a resolution but also checking if a Bun Bake framework has an
+    /// override. This is used in one place in the bundler.
+    pub fn resolveWithFramework(r: *ThisResolver, source_dir: string, import_path: string, kind: ast.ImportKind) !Result {
+        if (r.opts.framework) |f| {
+            if (f.built_in_modules.get(import_path)) |mod| {
+                switch (mod) {
+                    .code => {
+                        return .{
+                            .import_kind = kind,
+                            .path_pair = .{ .primary = Fs.Path.initWithNamespace(import_path, "node") },
+                            .is_external = false,
+                            .module_type = .esm,
+                            .primary_side_effects_data = .no_side_effects__pure_data,
+                        };
+                    },
+                    .import => |path| return r.resolve(r.fs.top_level_dir, path, .entry_point),
+                }
+                return .{};
+            }
+        }
+        return r.resolve(source_dir, import_path, kind);
+    }
+
     const ModuleTypeMap = bun.ComptimeStringMap(options.ModuleType, .{
         .{ ".mjs", options.ModuleType.esm },
         .{ ".mts", options.ModuleType.esm },
@@ -1664,8 +1550,8 @@ pub const Resolver = struct {
     /// But drive roots MUST have a trailing slash ('/' and 'C:\')
     /// UNC paths, even if the root, must not have the trailing slash.
     ///
-    /// The helper function bun.strings.pathWithoutTrailingSlashOne can be used to remove
-    /// the trailing slash from a path, but also note it will only remove a SINGLE slash.
+    /// The helper function bun.strings.withoutTrailingSlashWindowsPath can be used
+    /// to remove the trailing slash from a path
     pub fn assertValidCacheKey(path: []const u8) void {
         if (Environment.allow_assert) {
             if (path.len > 1 and strings.charIsAnySlash(path[path.len - 1]) and !if (Environment.isWindows)
@@ -1688,6 +1574,21 @@ pub const Resolver = struct {
         return first_bust or second_bust;
     }
 
+    /// bust both the named file and a parent directory, because `./hello` can resolve
+    /// to `./hello.js` or `./hello/index.js`
+    pub fn bustDirCacheFromSpecifier(r: *ThisResolver, import_source: []const u8, specifier: []const u8) bool {
+        if (!(bun.strings.startsWith(specifier, "./") or
+            bun.strings.startsWith(specifier, "../"))) return false;
+        if (!std.fs.path.isAbsolute(import_source)) return false;
+
+        const joined = bun.path.joinAbs(import_source, .auto, specifier);
+        const dir = bun.path.dirname(joined, .auto);
+
+        const a = r.bustDirCache(dir);
+        const b = r.bustDirCache(joined);
+        return a or b;
+    }
+
     pub fn loadNodeModules(
         r: *ThisResolver,
         import_path: string,
@@ -1731,18 +1632,32 @@ pub const Resolver = struct {
             }
         }
 
+        var is_self_reference = false;
+
         // Find the parent directory with the "package.json" file
         var dir_info_package_json: ?*DirInfo = dir_info;
         while (dir_info_package_json != null and dir_info_package_json.?.package_json == null)
             dir_info_package_json = dir_info_package_json.?.getParent();
 
         // Check for subpath imports: https://nodejs.org/api/packages.html#subpath-imports
-        if (dir_info_package_json != null and
-            strings.hasPrefixComptime(import_path, "#") and
-            !forbid_imports and
-            dir_info_package_json.?.package_json.?.imports != null)
-        {
-            return r.loadPackageImports(import_path, dir_info_package_json.?, kind, global_cache);
+        if (dir_info_package_json) |_dir_info_package_json| {
+            const package_json = _dir_info_package_json.package_json.?;
+
+            if (strings.hasPrefixComptime(import_path, "#") and !forbid_imports and package_json.imports != null) {
+                return r.loadPackageImports(import_path, _dir_info_package_json, kind, global_cache);
+            }
+
+            // https://nodejs.org/api/packages.html#packages_self_referencing_a_package_using_its_name
+            const package_name = ESModule.Package.parseName(import_path);
+            if (package_name) |_package_name| {
+                if (strings.eql(_package_name, package_json.name) and package_json.exports != null) {
+                    if (r.debug_logs) |*debug| {
+                        debug.addNoteFmt("\"{s}\" is a self-reference", .{import_path});
+                    }
+                    dir_info = _dir_info_package_json;
+                    is_self_reference = true;
+                }
+            }
         }
 
         const esm_ = ESModule.Package.parse(import_path, bufs(.esm_subpath));
@@ -1752,21 +1667,28 @@ pub const Resolver = struct {
         const use_node_module_resolver = global_cache != .force;
 
         // Then check for the package in any enclosing "node_modules" directories
+        // or in the package root directory if it's a self-reference
         while (use_node_module_resolver) {
             // Skip directories that are themselves called "node_modules", since we
             // don't ever want to search for "node_modules/node_modules"
-            if (dir_info.hasNodeModules()) {
+            if (dir_info.hasNodeModules() or is_self_reference) {
                 any_node_modules_folder = true;
-                var _paths = [_]string{ dir_info.abs_path, "node_modules", import_path };
-                const abs_path = r.fs.absBuf(&_paths, bufs(.node_modules_check));
+                const abs_path = if (is_self_reference)
+                    dir_info.abs_path
+                else brk: {
+                    var _parts = [_]string{ dir_info.abs_path, "node_modules", import_path };
+                    break :brk r.fs.absBuf(&_parts, bufs(.node_modules_check));
+                };
                 if (r.debug_logs) |*debug| {
                     debug.addNoteFmt("Checking for a package in the directory \"{s}\"", .{abs_path});
                 }
+
                 const prev_extension_order = r.extension_order;
                 defer r.extension_order = prev_extension_order;
 
                 if (esm_) |esm| {
                     const abs_package_path = brk: {
+                        if (is_self_reference) break :brk dir_info.abs_path;
                         var parts = [_]string{ dir_info.abs_path, "node_modules", esm.name };
                         break :brk r.fs.absBuf(&parts, bufs(.esm_absolute_package_path));
                     };
@@ -1873,7 +1795,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;
@@ -1951,6 +1873,7 @@ pub const Resolver = struct {
                                 esm.version,
                                 &sliced_string,
                                 r.log,
+                                manager,
                             ) orelse break :load_module_from_cache;
                         }
 
@@ -2147,7 +2070,7 @@ pub const Resolver = struct {
     ) !?*DirInfo {
         assert(r.package_manager != null);
 
-        const dir_path = strings.pathWithoutTrailingSlashOne(dir_path_maybe_trail_slash);
+        const dir_path = strings.withoutTrailingSlashWindowsPath(dir_path_maybe_trail_slash);
 
         assertValidCacheKey(dir_path);
         var dir_cache_info_result = r.dir_cache.getOrPut(dir_path) catch bun.outOfMemory();
@@ -2275,6 +2198,7 @@ pub const Resolver = struct {
             if (package_json_) |package_json| {
                 package = Package.fromPackageJSON(
                     pm.lockfile,
+                    pm,
                     package_json,
                     Install.Features{
                         .dev_dependencies = true,
@@ -2582,25 +2506,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;
     }
 
@@ -2644,7 +2558,7 @@ pub const Resolver = struct {
 
         assert(std.fs.path.isAbsolute(input_path));
 
-        const path_without_trailing_slash = strings.pathWithoutTrailingSlashOne(input_path);
+        const path_without_trailing_slash = strings.withoutTrailingSlashWindowsPath(input_path);
         assertValidCacheKey(path_without_trailing_slash);
         const top_result = try r.dir_cache.getOrPut(path_without_trailing_slash);
         if (top_result.status != .unknown) {
@@ -2666,7 +2580,7 @@ pub const Resolver = struct {
             .status = .not_found,
         };
         const root_path = if (Environment.isWindows)
-            bun.strings.pathWithoutTrailingSlashOne(ResolvePath.windowsFilesystemRoot(path))
+            bun.strings.withoutTrailingSlashWindowsPath(ResolvePath.windowsFilesystemRoot(path))
         else
             // we cannot just use "/"
             // we will write to the buffer past the ptr len so it must be a non-const buffer
@@ -2750,7 +2664,7 @@ pub const Resolver = struct {
 
         // We want to walk in a straight line from the topmost directory to the desired directory
         // For each directory we visit, we get the entries, but not traverse into child directories
-        // (unless those child directores are in the queue)
+        // (unless those child directories are in the queue)
         // We go top-down instead of bottom-up to increase odds of reusing previously open file handles
         // "/home/jarred/Code/node_modules/react/cjs/react.development.js"
         //       ^
@@ -3075,7 +2989,7 @@ pub const Resolver = struct {
     pub fn loadPackageImports(r: *ThisResolver, import_path: string, dir_info: *DirInfo, kind: ast.ImportKind, global_cache: GlobalCache) MatchResult.Union {
         const package_json = dir_info.package_json.?;
         if (r.debug_logs) |*debug| {
-            debug.addNoteFmt("Looking for {s} in \"imports\" map in {s}", .{ import_path, package_json.source.key_path.text });
+            debug.addNoteFmt("Looking for {s} in \"imports\" map in {s}", .{ import_path, package_json.source.path.text });
             debug.increaseIndent();
             defer debug.decreaseIndent();
         }
@@ -3379,13 +3293,16 @@ 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()) {
-            globalThis.throwInvalidArgumentType("nodeModulePaths", "path", "string");
-            return .zero;
+        if (argument == .zero or !argument.isString()) {
+            return globalThis.throwInvalidArgumentType("nodeModulePaths", "path", "string");
         }
 
         const in_str = argument.toBunString(globalThis);
@@ -3701,7 +3618,7 @@ pub const Resolver = struct {
                             // If it doesn't exist, the "module" field will be used.
                             if (r.prefer_module_field and kind != ast.ImportKind.require) {
                                 if (r.debug_logs) |*debug| {
-                                    debug.addNoteFmt("Resolved to \"{s}\" using the \"module\" field in \"{s}\"", .{ auto_main_result.path_pair.primary.text, pkg_json.source.key_path.text });
+                                    debug.addNoteFmt("Resolved to \"{s}\" using the \"module\" field in \"{s}\"", .{ auto_main_result.path_pair.primary.text, pkg_json.source.path.text });
 
                                     debug.addNoteFmt("The fallback path in case of \"require\" is {s}", .{auto_main_result.path_pair.primary.text});
                                 }
@@ -3721,7 +3638,7 @@ pub const Resolver = struct {
                                     debug.addNoteFmt("Resolved to \"{s}\" using the \"{s}\" field in \"{s}\"", .{
                                         auto_main_result.path_pair.primary.text,
                                         key,
-                                        pkg_json.source.key_path.text,
+                                        pkg_json.source.path.text,
                                     });
                                 }
                                 var _auto_main_result = auto_main_result;
@@ -3760,7 +3677,8 @@ pub const Resolver = struct {
             }
         }
 
-        const dir_path = bun.strings.pathWithoutTrailingSlashOne(Dirname.dirname(path));
+        const dir_path = bun.strings.withoutTrailingSlashWindowsPath(Dirname.dirname(path));
+        bun.strings.assertIsValidWindowsPath(u8, dir_path);
 
         const dir_entry: *Fs.FileSystem.RealFS.EntriesOption = rfs.readDirectory(
             dir_path,
@@ -4215,7 +4133,11 @@ pub const Dirname = struct {
             if (Environment.isWindows) {
                 const root = ResolvePath.windowsFilesystemRoot(path);
                 assert(root.len > 0);
-                break :brk root;
+
+                // Preserve the trailing slash for UNC paths.
+                // Going from `\\server\share\folder` should end up
+                // at `\\server\share\`, not `\\server\share`
+                break :brk if (root.len >= 5 and path.len > root.len) path[0 .. root.len + 1] else root;
             }
             break :brk "/";
         };
@@ -4298,7 +4220,6 @@ pub const GlobalCache = enum {
 
 comptime {
     if (!bun.JSC.is_bindgen) {
-        _ = Resolver.Resolver__nodeModulePathsForJS;
         _ = Resolver.Resolver__propForRequireMainPaths;
     }
 }
diff --git a/src/resolver/tsconfig_json.zig b/src/resolver/tsconfig_json.zig
index 22dd62cdc6..e203a2f5b4 100644
--- a/src/resolver/tsconfig_json.zig
+++ b/src/resolver/tsconfig_json.zig
@@ -101,6 +101,51 @@ pub const TSConfigJSON = struct {
         return out;
     }
 
+    /// Support ${configDir}, but avoid allocating when possible.
+    ///
+    /// https://github.com/microsoft/TypeScript/issues/57485
+    ///
+    /// https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-5.html#the-configdir-template-variable-for-configuration-files
+    ///
+    /// https://github.com/oven-sh/bun/issues/11752
+    ///
+    // Note that the way tsc does this is slightly different. They replace
+    // "${configDir}" with "./" and then convert it to an absolute path sometimes.
+    // We convert it to an absolute path during module resolution, so we shouldn't need to do that here.
+    // https://github.com/microsoft/TypeScript/blob/ef802b1e4ddaf8d6e61d6005614dd796520448f8/src/compiler/commandLineParser.ts#L3243-L3245
+    fn strReplacingTemplates(allocator: std.mem.Allocator, input: string, source: *const logger.Source) bun.OOM!string {
+        var remaining = input;
+        var string_builder = bun.StringBuilder{};
+        const configDir = source.path.sourceDir();
+
+        // There's only one template variable we support, so we can keep this simple for now.
+        while (strings.indexOf(remaining, "${configDir}")) |index| {
+            string_builder.count(remaining[0..index]);
+            string_builder.count(configDir);
+            remaining = remaining[index + "${configDir}".len ..];
+        }
+
+        // If we didn't find any template variables, return the original string without allocating.
+        if (remaining.len == input.len) {
+            return input;
+        }
+
+        string_builder.countZ(remaining);
+        try string_builder.allocate(allocator);
+
+        remaining = input;
+        while (strings.indexOf(remaining, "${configDir}")) |index| {
+            _ = string_builder.append(remaining[0..index]);
+            _ = string_builder.append(configDir);
+            remaining = remaining[index + "${configDir}".len ..];
+        }
+
+        // The extra null-byte here is unnecessary. But it's kind of nice in the debugger sometimes.
+        _ = string_builder.appendZ(remaining);
+
+        return string_builder.allocatedSlice()[0 .. string_builder.len - 1];
+    }
+
     pub fn parse(
         allocator: std.mem.Allocator,
         log: *logger.Log,
@@ -119,7 +164,7 @@ pub const TSConfigJSON = struct {
 
         bun.Analytics.Features.tsconfig += 1;
 
-        var result: TSConfigJSON = TSConfigJSON{ .abs_path = source.key_path.text, .paths = PathsMap.init(allocator) };
+        var result: TSConfigJSON = TSConfigJSON{ .abs_path = source.path.text, .paths = PathsMap.init(allocator) };
         errdefer allocator.free(result.paths);
         if (json.asProperty("extends")) |extends_value| {
             if (!source.path.isNodeModule()) {
@@ -136,7 +181,7 @@ pub const TSConfigJSON = struct {
             // Parse "baseUrl"
             if (compiler_opts.expr.asProperty("baseUrl")) |base_url_prop| {
                 if ((base_url_prop.expr.asString(allocator))) |base_url| {
-                    result.base_url = base_url;
+                    result.base_url = strReplacingTemplates(allocator, base_url, &source) catch return null;
                     has_base_url = true;
                 }
             }
@@ -274,7 +319,9 @@ pub const TSConfigJSON = struct {
                                         errdefer allocator.free(values);
                                         var count: usize = 0;
                                         for (array) |expr| {
-                                            if ((expr.asString(allocator))) |str| {
+                                            if ((expr.asString(allocator))) |str_| {
+                                                const str = strReplacingTemplates(allocator, str_, &source) catch return null;
+                                                errdefer allocator.free(str);
                                                 if (TSConfigJSON.isValidTSConfigPathPattern(
                                                     str,
                                                     log,
diff --git a/src/router.zig b/src/router.zig
index 1d903befbd..23f61bf315 100644
--- a/src/router.zig
+++ b/src/router.zig
@@ -90,7 +90,7 @@ pub fn getNames(this: *const Router) ![]const string {
     return this.routes.list.items(.name);
 }
 
-const banned_dirs = [_]string{
+pub const banned_dirs = [_]string{
     "node_modules",
 };
 
@@ -993,11 +993,10 @@ pub const Test = struct {
         const Resolver = @import("./resolver/resolver.zig").Resolver;
         var logger = Logger.Log.init(default_allocator);
         errdefer {
-            logger.printForLogLevel(Output.errorWriter()) catch {};
+            logger.print(Output.errorWriter()) catch {};
         }
 
         const opts = Options.BundleOptions{
-            .resolve_mode = .lazy,
             .target = .browser,
             .loaders = undefined,
             .define = undefined,
@@ -1050,11 +1049,10 @@ pub const Test = struct {
         const Resolver = @import("./resolver/resolver.zig").Resolver;
         var logger = Logger.Log.init(default_allocator);
         errdefer {
-            logger.printForLogLevel(Output.errorWriter()) catch {};
+            logger.print(Output.errorWriter()) catch {};
         }
 
         const opts = Options.BundleOptions{
-            .resolve_mode = .lazy,
             .target = .browser,
             .loaders = undefined,
             .define = undefined,
diff --git a/src/runtime.zig b/src/runtime.zig
index d42d657c7d..c7309a280e 100644
--- a/src/runtime.zig
+++ b/src/runtime.zig
@@ -16,8 +16,6 @@ const Schema = @import("./api/schema.zig");
 const Ref = @import("ast/base.zig").Ref;
 const JSAst = bun.JSAst;
 const content = @import("root").content;
-// packages/bun-cli-*/bun
-const BUN_ROOT = "../../";
 
 const Api = Schema.Api;
 fn embedDebugFallback(comptime msg: []const u8, comptime code: []const u8) []const u8 {
@@ -31,50 +29,8 @@ fn embedDebugFallback(comptime msg: []const u8, comptime code: []const u8) []con
 
     return code;
 }
-pub const ErrorCSS = struct {
-    pub inline fn sourceContent() string {
-        if (comptime Environment.isDebug) {
-            var out_buffer: bun.PathBuffer = undefined;
-            const dirname = std.fs.selfExeDirPath(&out_buffer) catch unreachable;
-            var paths = [_]string{ dirname, BUN_ROOT, content.error_css_path };
-            const file = std.fs.cwd().openFile(
-                resolve_path.joinAbsString(dirname, &paths, .auto),
-                .{ .mode = .read_only },
-            ) catch return embedDebugFallback(
-                "Missing packages/bun-error/bun-error.css. Please run \"make bun_error\"",
-                content.error_css,
-            );
-            defer file.close();
-            return file.readToEndAlloc(default_allocator, file.getEndPos() catch 0) catch unreachable;
-        } else {
-            return content.error_css;
-        }
-    }
-};
-
-pub const ErrorJS = struct {
-    pub inline fn sourceContent() string {
-        if (comptime Environment.isDebug) {
-            var out_buffer: bun.PathBuffer = undefined;
-            const dirname = std.fs.selfExeDirPath(&out_buffer) catch unreachable;
-            var paths = [_]string{ dirname, BUN_ROOT, content.error_js_path };
-            const file = std.fs.cwd().openFile(
-                resolve_path.joinAbsString(dirname, &paths, .auto),
-                .{ .mode = .read_only },
-            ) catch return embedDebugFallback(
-                "Missing " ++ content.error_js_path ++ ". Please run \"make bun_error\"",
-                content.error_js,
-            );
-            defer file.close();
-            return file.readToEndAlloc(default_allocator, file.getEndPos() catch 0) catch unreachable;
-        } else {
-            return content.error_js;
-        }
-    }
-};
 
 pub const Fallback = struct {
-    pub const ProdSourceContent = @embedFile("./fallback.out.js");
     pub const HTMLTemplate = @embedFile("./fallback.html");
     pub const HTMLBackendTemplate = @embedFile("./fallback-backend.html");
 
@@ -113,29 +69,27 @@ pub const Fallback = struct {
         };
     };
 
-    pub inline fn scriptContent() string {
-        if (comptime Environment.isDebug) {
-            const dirpath = comptime bun.Environment.base_path ++ "/" ++ (bun.Dirname.dirname(u8, @src().file) orelse "");
-            var buf: bun.PathBuffer = undefined;
-            const user = bun.getUserName(&buf) orelse "";
-            const dir = std.mem.replaceOwned(
-                u8,
-                default_allocator,
-                dirpath,
-                "jarred",
-                user,
-            ) catch unreachable;
-            const runtime_path = std.fs.path.join(default_allocator, &[_]string{ dir, "fallback.out.js" }) catch unreachable;
-            const file = std.fs.openFileAbsolute(runtime_path, .{}) catch return embedDebugFallback(
-                "Missing bun/src/fallback.out.js. " ++ "Please run \"make fallback_decoder\"",
-                ProdSourceContent,
-            );
-            defer file.close();
-            return file.readToEndAlloc(default_allocator, file.getEndPos() catch 0) catch unreachable;
-        } else {
-            return ProdSourceContent;
-        }
+    pub inline fn errorJS() string {
+        return if (Environment.codegen_embed)
+            @embedFile("bun-error/index.js")
+        else
+            bun.runtimeEmbedFile(.codegen, "bun-error/index.js");
     }
+
+    pub inline fn errorCSS() string {
+        return if (Environment.codegen_embed)
+            @embedFile("bun-error/bun-error.css")
+        else
+            bun.runtimeEmbedFile(.codegen, "bun-error/bun-error.css");
+    }
+
+    pub inline fn fallbackDecoderJS() string {
+        return if (Environment.codegen_embed)
+            @embedFile("fallback-decoder.js")
+        else
+            bun.runtimeEmbedFile(.codegen, "fallback-decoder.js");
+    }
+
     pub const version_hash = @import("build_options").fallback_html_version;
     var version_hash_int: u32 = 0;
     pub fn versionHash() u32 {
@@ -166,7 +120,7 @@ pub const Fallback = struct {
         try writer.print(HTMLTemplate, PrintArgs{
             .blob = Base64FallbackMessage{ .msg = msg, .allocator = allocator },
             .preload = preload,
-            .fallback = scriptContent(),
+            .fallback = fallbackDecoderJS(),
             .entry_point = entry_point,
         });
     }
@@ -186,17 +140,16 @@ pub const Fallback = struct {
         };
         try writer.print(HTMLBackendTemplate, PrintArgs{
             .blob = Base64FallbackMessage{ .msg = msg, .allocator = allocator },
-            .bun_error_css = ErrorCSS.sourceContent(),
-            .bun_error = ErrorJS.sourceContent(),
+            .bun_error_css = errorCSS(),
+            .bun_error = errorJS(),
             .bun_error_page_css = "",
-            .fallback = scriptContent(),
+            .fallback = fallbackDecoderJS(),
         });
     }
 };
 
 pub const Runtime = struct {
-    pub const source_code = @embedFile("./runtime.out.js");
-
+    pub const source_code = @embedFile("runtime.out.js");
     pub const hash = brk: {
         @setEvalBranchQuota(source_code.len * 50);
         break :brk bun.Wyhash11.hash(0, source_code);
@@ -209,13 +162,14 @@ pub const Runtime = struct {
         /// Enable the React Fast Refresh transform. What this does exactly
         /// is documented in js_parser, search for `const ReactRefresh`
         react_fast_refresh: bool = false,
-
-        /// `hot_module_reloading` is specific to if we are using bun.kit.DevServer.
-        /// It can be enabled on the command line with --format=internal_kit_dev
+        /// `hot_module_reloading` is specific to if we are using bun.bake.DevServer.
+        /// It can be enabled on the command line with --format=internal_bake_dev
         ///
         /// Standalone usage of this flag / usage of this flag
         /// without '--format' set is an unsupported use case.
         hot_module_reloading: bool = false,
+        /// Control how the parser handles server components and server functions.
+        server_components: ServerComponentsMode = .none,
 
         is_macro_runtime: bool = false,
         top_level_await: bool = false,
@@ -241,6 +195,9 @@ pub const Runtime = struct {
         /// This is only supported with --target=bun
         use_import_meta_require: bool = false,
 
+        /// Allow runtime usage of require(), converting `require` into `__require`
+        auto_polyfill_require: bool = false,
+
         replace_exports: ReplaceableExport.Map = .{},
 
         /// Scan for '// @bun' at the top of this file, halting a parse if it is
@@ -259,6 +216,7 @@ pub const Runtime = struct {
         unwrap_commonjs_packages: []const string = &.{},
 
         commonjs_at_runtime: bool = false,
+        unwrap_commonjs_to_esm: bool = false,
 
         emit_decorator_metadata: bool = false,
 
@@ -316,38 +274,57 @@ pub const Runtime = struct {
 
             pub const Map = bun.StringArrayHashMapUnmanaged(ReplaceableExport);
         };
+
+        pub const ServerComponentsMode = enum {
+            /// Server components is disabled, strings "use client" and "use server" mean nothing.
+            none,
+            /// This is a server-side file outside of the SSR graph, but not a "use server" file.
+            /// - Handle functions with "use server", creating secret exports for them.
+            wrap_anon_server_functions,
+            /// This is a "use client" file on the server, and separate_ssr_graph is off.
+            /// - Wrap all exports in a call to `registerClientReference`
+            /// - Ban "use server" functions???
+            wrap_exports_for_client_reference,
+            /// This is a "use server" file on the server
+            /// - Wrap all exports in a call to `registerServerReference`
+            /// - Ban "use server" functions, since this directive is already applied.
+            wrap_exports_for_server_reference,
+            /// This is a client side file.
+            /// - Ban "use server" functions since it is on the client-side
+            client_side,
+
+            pub fn wrapsExports(mode: ServerComponentsMode) bool {
+                return switch (mode) {
+                    .wrap_exports_for_client_reference,
+                    .wrap_exports_for_server_reference,
+                    => true,
+                    else => false,
+                };
+            }
+        };
     };
 
     pub const Names = struct {
         pub const ActivateFunction = "activate";
     };
 
-    /// See js_parser.StaticSymbolName
-    pub const GeneratedSymbol = struct {
-        primary: Ref,
-        backup: Ref,
-        ref: Ref,
-
-        pub const empty: GeneratedSymbol = .{ .ref = Ref.None, .primary = Ref.None, .backup = Ref.None };
-    };
-
     // If you change this, remember to update "runtime.js"
     pub const Imports = struct {
-        __name: ?GeneratedSymbol = null,
-        __require: ?GeneratedSymbol = null,
-        __export: ?GeneratedSymbol = null,
-        __reExport: ?GeneratedSymbol = null,
-        __exportValue: ?GeneratedSymbol = null,
-        __exportDefault: ?GeneratedSymbol = null,
+        __name: ?Ref = null,
+        __require: ?Ref = null,
+        __export: ?Ref = null,
+        __reExport: ?Ref = null,
+        __exportValue: ?Ref = null,
+        __exportDefault: ?Ref = null,
         // __refreshRuntime: ?GeneratedSymbol = null,
         // __refreshSig: ?GeneratedSymbol = null, // $RefreshSig$
-        __merge: ?GeneratedSymbol = null,
-        __legacyDecorateClassTS: ?GeneratedSymbol = null,
-        __legacyDecorateParamTS: ?GeneratedSymbol = null,
-        __legacyMetadataTS: ?GeneratedSymbol = null,
-        @"$$typeof": ?GeneratedSymbol = null,
-        __using: ?GeneratedSymbol = null,
-        __callDispose: ?GeneratedSymbol = null,
+        __merge: ?Ref = null,
+        __legacyDecorateClassTS: ?Ref = null,
+        __legacyDecorateParamTS: ?Ref = null,
+        __legacyMetadataTS: ?Ref = null,
+        @"$$typeof": ?Ref = null,
+        __using: ?Ref = null,
+        __callDispose: ?Ref = null,
 
         pub const all = [_][]const u8{
             "__name",
@@ -412,7 +389,7 @@ pub const Runtime = struct {
                     switch (this.i) {
                         inline 0...all.len - 1 => |t| {
                             if (@field(this.runtime_imports, all[t])) |val| {
-                                return Entry{ .key = t, .value = val.ref };
+                                return Entry{ .key = t, .value = val };
                             }
                         },
                         else => {
@@ -443,15 +420,15 @@ pub const Runtime = struct {
             return false;
         }
 
-        pub fn put(imports: *Imports, comptime key: string, generated_symbol: GeneratedSymbol) void {
-            @field(imports, key) = generated_symbol;
+        pub fn put(imports: *Imports, comptime key: string, ref: Ref) void {
+            @field(imports, key) = ref;
         }
 
         pub fn at(
             imports: *Imports,
             comptime key: string,
         ) ?Ref {
-            return (@field(imports, key) orelse return null).ref;
+            return (@field(imports, key) orelse return null);
         }
 
         pub fn get(
@@ -459,7 +436,7 @@ pub const Runtime = struct {
             key: anytype,
         ) ?Ref {
             return switch (key) {
-                inline 0...all.len - 1 => |t| (@field(imports, all[t]) orelse return null).ref,
+                inline 0...all.len - 1 => |t| (@field(imports, all[t]) orelse return null),
                 else => null,
             };
         }
diff --git a/src/runtime/errors.ts b/src/runtime/errors.ts
deleted file mode 100644
index 830ed3881d..0000000000
--- a/src/runtime/errors.ts
+++ /dev/null
@@ -1,79 +0,0 @@
-// @ts-nocheck
-var __BuildLog;
-var __ResolveLog;
-var __ImportKind;
-{
-  enum ImportKind {
-    entry_point = 0,
-    stmt = 1,
-    require = 2,
-    dynamic = 3,
-    require_resolve = 4,
-    at = 5,
-    at_conditional = 6,
-    url = 7,
-  }
-
-  type ErrorPosition = {
-    file: string;
-    namespace: string;
-    line: number; // 1-based
-    column: number; // 0-based, byte offset relative to lineText
-    length: number; // in bytes
-    /** line of text, possibly empty */
-    lineText: string;
-    /** byte offset relative to the start of the file */
-    offset: number;
-  };
-
-  interface BuildErrorImplementation {
-    position: ErrorPosition;
-    name: string;
-    message: string;
-  }
-
-  interface ResolveErrorImplementation extends BuildErrorImplementation {
-    specifier: string;
-    importKind: ImportKind;
-  }
-
-  class BuildMessage extends Error {
-    constructor(data: BuildErrorImplementation) {
-      super(data.message);
-      this.name = data.name;
-      this.data = data;
-    }
-    data: BuildLogImplementation;
-
-    get position() {
-      return this.data.position;
-    }
-
-    get [Symbol.toStringTag]() {
-      return `${this.name}: ${this.message}`;
-    }
-  }
-
-  class ResolveMessage extends BuildMessage {
-    constructor(data: ResolveErrorImplementation) {
-      super(data);
-      this.name = data.name;
-      this.data = data;
-    }
-    data: ResolveErrorImplementation;
-
-    get importKind() {
-      return this.data.importKind;
-    }
-
-    get specifier() {
-      return this.data.specifier || "";
-    }
-  }
-
-  __ResolveLog = ResolveMessage;
-  __BuildLog = BuildMessage;
-  __ImportKind = ImportKind;
-}
-
-export { __BuildLog as BuildMessage, __ImportKind as ImportKind, __ResolveLog as ResolveMessage };
diff --git a/src/runtime/hmr.ts b/src/runtime/hmr.ts
deleted file mode 100644
index 61dc9a93a5..0000000000
--- a/src/runtime/hmr.ts
+++ /dev/null
@@ -1,1672 +0,0 @@
-// @ts-nocheck
-import { ByteBuffer } from "peechy";
-import * as API from "../api/schema";
-
-var __HMRModule, __FastRefreshModule, __HMRClient, __injectFastRefresh;
-if (typeof window !== "undefined") {
-  var textEncoder: TextEncoder;
-  // We add a scope here to minimize chances of namespace collisions
-  var runOnce = false;
-  var clientStartTime = 0;
-  var empty: Uint8Array;
-
-  function formatDuration(duration: number) {
-    return Math.round(duration * 1000) / 1000;
-  }
-
-  enum CSSImportState {
-    Pending,
-    Loading,
-    Loaded,
-  }
-  var registryMap = new Map();
-  type HTMLStylableElement = HTMLLinkElement | HTMLStyleElement;
-  type CSSHMRInsertionPoint = {
-    id: number;
-    node?: HTMLStylableElement;
-    file: string;
-    bundle_id: number;
-    sheet: CSSStyleSheet;
-  };
-
-  enum CSSUpdateMethod {
-    // CSS OM allows synchronous style updates
-    cssObjectModel,
-    // Blob URLs allow us to skip converting to JavaScript strings
-    // However, they run asynchronously. Frequent updates cause FOUC
-    blobURL,
-  }
-
-  enum ReloadBehavior {
-    fullReload,
-    hotReload,
-    ignore,
-  }
-
-  const FastRefreshLoader = {
-    RefreshRuntime: null,
-    isUpdateInProgress: false,
-    hasInjectedFastRefresh: false,
-
-    performFullRefresh() {
-      HMRClient.client.performFullReload();
-    },
-
-    async hotReload() {
-      if (FastRefreshLoader.isUpdateInProgress) return;
-
-      try {
-        FastRefreshLoader.isUpdateInProgress = true;
-      } finally {
-        FastRefreshLoader.isUpdateInProgress = false;
-      }
-    },
-  };
-
-  const BUN_ERROR_FAVICON =
-    "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAIwAAACMCAMAAACZHrEMAAAAnFBMVEUAAAD////////////////////////////////////////////////////////////////////////////////////vjo798/Psdnb2wMD62dn3wMDrdnb3wcHjNzf4zc3mUFD////+8vL85ubugoLqaWnxm5vkRET1tLT75ubtgoLlQ0Pwj4/zp6foXV3vj4/zqKjsdXXnUFD62tqV2W1BAAAAFnRSTlMAYN8gEEDvv6B/gHAwz59Qr4+Qb7DQOIES+QAABFRJREFUeF7smNluwjAQRYEskJKwiPfxlg3o3v//t0owTlMV2+LBNw/lfMHRoHtIMvv3PHiQlFmWJbPpyYplrq5Um+2UJmnBIpZ8k0yuMmYanXKhbpKv8S4H5WSfgl0K5aFKp3PRRyGEdthAXUzb0AVZCzWwxLmUPyoNjZC9shSwTQ87eu/oN7VWTIb+kWr6gzS2xxiXRDFvRB4bTG5W7NLSTRobvxR4GEMOXtjmCSBTsUxDDs6aT5NEd5mzS09OatbdRJexs5bkRoDmffAehmkwHU74MEYSTX6a1ZAYL5JlFtBZh+a9BhympgBnHb18Gbt8UZDWUT7srJmzseXD9S5cvh38MPh5F45/61D5gL0Ln2YLnHW4fCmwd+F5Aw+DL9+WXQTR/afZA2YdxrBNAuodft5p4DDh8kF6hz/NMOuO7qVnmzlq1t3r6dQ4PKW25YP0rmuvOeklpHw732GkUZbaXz7ArNnF/ZL5bMsXv3e1GiG8umX0wwg1pos8b/sYo2/3Tqsxjb98sXvHFrm68OEtXxX7MebIGeHL+Mu3jtA7r0yEebsOE5aJWL6lLUhAhvkMfsyK+hgjHDIRPmY5eueXiTTvb2bNbidhIIjClkJBEUGDUH5k+2NLAQUj7/9uXnCx6elCppOdkXNPcjKzc2b3o7YwRDMEmCWJqSowI1aaV8g7nhmEWVKYCs3kJJglh6m+wYwQzHom8buSYgaTjz/WR7oZQ4RZUphqBmZIMEsKU+1JZnC8mZjqZ9PCzEIAZkHe0c1UZJglQ2NiMMOGWfy8w8pjT/njzS8MmiklYFaPjqmOYIYMsyQwVQJmfMMszDu6mU8GsfHJ7w50M5h8Apgqgwel39KEUSssX+HSpsMs//S5IAwTGWbx8w4vEWcGxveO5S9fFGWlf4wfwAImaVsUvyQbCLPIYy0ihFkSWF6EVXfFC4PJR8s7ndKMSFheWgiz+GONiHyx25kKdgFjvLl5h29K3B/85ENMtW7j5WzXwfzIKU3oYaxxGdDPGsIsb3mXpDWdWOPtqzBx3YzxlHxhh30MrXIPyQd5J24GYRZzrFF7fpsQZvHzDu/jzF9nztJ0I1ZhEKO13a+lc6ACwPJkHZapVdz615lroKbYc7qbCr4nZ5QGNlQEPW+jpFpm6W41g/htVZqeg2xuN9oyzXkaQ5f0NGsuqCHAHj3FzRP8JHTbJPOdzl2YSQhmtCszuoszUzRTL/jvaZo2c2aub+bDASQiWE1qsgls1Qf2IC28ldd20xDgg5Zy19buAoZWLkzgfsCdVBMvd1+Ce/Aq1NA2vwb3JupukjP84QP4V7NTRZ7CiYGBumiZKLTI3uSdj+03yxPMZyLqZL2ylN82CSfKKjOmkpGpfQDUCa/gxUmqK/SCnVLWe3iLA3dUvbzdBvbhQM9KH1iI006kZYWk8WAkfGwnw+5fO3BsAgAAwkAwgukC7r+tM1jY/ekgnvrhtK4AAMACYkDwBoJSQAkAAAAASUVORK5CYII=";
-  const BunError = {
-    module: null,
-    prom: null,
-    cancel: false,
-    lastError: null,
-    previousFavicon: "",
-    setErrorFavicon() {
-      if (typeof document === "undefined" || BunError.previousFavicon) return;
-
-      // we wrap this in a try / catch because if for some reason an error occurs because of this
-      // we don't want it to break the rest of the error handling code
-      // if they set a CSP header, that could cause this to fail
-      try {
-        let linkTag = document.querySelector("link[rel='icon']");
-        BunError.previousFavicon = (linkTag && linkTag.getAttribute("href")) || "/favicon.ico";
-        if (!linkTag) {
-          linkTag = document.createElement("link");
-          linkTag.setAttribute("rel", "icon");
-          linkTag.setAttribute("href", BUN_ERROR_FAVICON);
-          document.head.appendChild(linkTag);
-          return;
-        }
-
-        linkTag.setAttribute("href", BUN_ERROR_FAVICON);
-      } catch (e) {}
-    },
-
-    clearErrorFavicon() {
-      if (typeof document === "undefined") return;
-      if (BunError.previousFavicon) {
-        try {
-          const linkTag = document.querySelector("link[rel='icon']");
-          if (linkTag) {
-            linkTag.setAttribute("href", BunError.previousFavicon);
-          }
-
-          BunError.previousFavicon = "";
-        } catch (exception) {}
-      }
-    },
-
-    render(error, cwd) {
-      BunError.setErrorFavicon();
-      if ("__BunRenderBuildError" in globalThis) {
-        globalThis.__BunRenderBuildError(error, cwd);
-        return;
-      }
-
-      BunError.lastError = [error, cwd];
-      BunError.cancel = false;
-
-      if (!BunError.module) {
-        if (BunError.prom) return;
-        BunError.prom = import("/bun:error.js").then(mod => {
-          BunError.module = mod;
-          !BunError.cancel && BunError.render(BunError.lastError[0], BunError.lastError[1]);
-        });
-        return;
-      }
-
-      const { renderBuildFailure, renderRuntimeError } = BunError.module;
-      if (typeof BunError.lastError[0] === "string" || BunError.lastError[0] instanceof Error) {
-        renderRuntimeError(BunError.lastError[0], BunError.lastError[1]);
-      } else {
-        renderBuildFailure(BunError.lastError[0], BunError.lastError[1]);
-      }
-    },
-
-    clear() {
-      BunError.lastError = null;
-      BunError.cancel = true;
-      BunError.clearErrorFavicon();
-
-      if (BunError.module) {
-        const { clearBuildFailure } = BunError.module;
-        clearBuildFailure();
-      } else if ("__BunClearBuildFailure" in globalThis) {
-        globalThis.__BunClearBuildFailure();
-      }
-    },
-  };
-
-  class CSSLoader {
-    hmr: HMRClient;
-    private static cssLoadId: CSSHMRInsertionPoint = {
-      id: 0,
-      bundle_id: 0,
-      node: null,
-      file: "",
-      sheet: null,
-    };
-
-    updateMethod: CSSUpdateMethod;
-    decoder: TextDecoder;
-
-    constructor() {
-      if ("replaceSync" in CSSStyleSheet.prototype) {
-        this.updateMethod = CSSUpdateMethod.cssObjectModel;
-      } else {
-        this.updateMethod = CSSUpdateMethod.blobURL;
-      }
-    }
-
-    // This is a separate function because calling a small function 2000 times is more likely to cause it to be JIT'd
-    // We want it to be JIT'd
-    // It's possible that returning null may be a de-opt though.
-    private findMatchingSupportsRule(
-      rule: CSSSupportsRule,
-      id: number,
-      sheet: CSSStyleSheet,
-    ): CSSHMRInsertionPoint | null {
-      switch (rule.type) {
-        // 12 is result.SUPPORTS_RULE
-        case 12: {
-          if (!rule.conditionText.startsWith("(hmr-wid:")) {
-            return null;
-          }
-
-          const startIndex = "hmr-wid:".length + 1;
-          const endIDRegion = rule.conditionText.indexOf(")", startIndex);
-          if (endIDRegion === -1) return null;
-
-          const int = parseInt(rule.conditionText.substring(startIndex, endIDRegion), 10);
-
-          if (int !== id) {
-            return null;
-          }
-
-          let startFileRegion = rule.conditionText.indexOf('(hmr-file:"', endIDRegion);
-          if (startFileRegion === -1) return null;
-          startFileRegion += '(hmr-file:"'.length + 1;
-
-          const endFileRegion = rule.conditionText.indexOf('"', startFileRegion);
-          if (endFileRegion === -1) return null;
-          // Empty file strings are invalid
-          if (endFileRegion - startFileRegion <= 0) return null;
-
-          CSSLoader.cssLoadId.id = int;
-          CSSLoader.cssLoadId.node = sheet.ownerNode as HTMLStylableElement;
-          CSSLoader.cssLoadId.sheet = sheet;
-          CSSLoader.cssLoadId.file = rule.conditionText.substring(startFileRegion - 1, endFileRegion);
-
-          return CSSLoader.cssLoadId;
-        }
-        default: {
-          return null;
-        }
-      }
-    }
-
-    bundleId(): number {
-      return CSSLoader.cssLoadId.bundle_id;
-    }
-
-    findCSSLinkTag(id: number): CSSHMRInsertionPoint | null {
-      let count = 0;
-      let match: CSSHMRInsertionPoint = null;
-
-      const adoptedStyles = document.adoptedStyleSheets;
-
-      if (this.updateMethod === CSSUpdateMethod.cssObjectModel) {
-        if (adoptedStyles.length > 0) {
-          count = adoptedStyles.length;
-
-          for (let i = 0; i < count && match === null; i++) {
-            let cssRules: CSSRuleList;
-            let sheet: CSSStyleSheet;
-            let ruleCount = 0;
-            // Non-same origin stylesheets will potentially throw "Security error"
-            // We will ignore those stylesheets and look at others.
-            try {
-              sheet = adoptedStyles[i];
-              cssRules = sheet.rules;
-              ruleCount = sheet.rules.length;
-            } catch (exception) {
-              continue;
-            }
-
-            if (sheet.disabled || sheet.rules.length === 0) {
-              continue;
-            }
-
-            const bundleIdRule = cssRules[0] as CSSSupportsRule;
-            if (bundleIdRule.type !== 12 || !bundleIdRule.conditionText.startsWith("(hmr-bid:")) {
-              continue;
-            }
-
-            const bundleIdEnd = bundleIdRule.conditionText.indexOf(")", "(hmr-bid:".length + 1);
-            if (bundleIdEnd === -1) continue;
-
-            CSSLoader.cssLoadId.bundle_id = parseInt(
-              bundleIdRule.conditionText.substring("(hmr-bid:".length, bundleIdEnd),
-              10,
-            );
-
-            for (let j = 1; j < ruleCount && match === null; j++) {
-              match = this.findMatchingSupportsRule(cssRules[j] as CSSSupportsRule, id, sheet);
-            }
-          }
-        }
-      }
-
-      count = document.styleSheets.length;
-
-      for (let i = 0; i < count && match === null; i++) {
-        let cssRules: CSSRuleList;
-        let sheet: CSSStyleSheet;
-        let ruleCount = 0;
-        // Non-same origin stylesheets will potentially throw "Security error"
-        // We will ignore those stylesheets and look at others.
-        try {
-          sheet = document.styleSheets.item(i);
-          cssRules = sheet.rules;
-          ruleCount = sheet.rules.length;
-        } catch (exception) {
-          continue;
-        }
-
-        if (sheet.disabled || sheet.rules.length === 0) {
-          continue;
-        }
-
-        const bundleIdRule = cssRules[0] as CSSSupportsRule;
-        if (bundleIdRule.type !== 12 || !bundleIdRule.conditionText.startsWith("(hmr-bid:")) {
-          continue;
-        }
-
-        const bundleIdEnd = bundleIdRule.conditionText.indexOf(")", "(hmr-bid:".length + 1);
-        if (bundleIdEnd === -1) continue;
-
-        CSSLoader.cssLoadId.bundle_id = parseInt(
-          bundleIdRule.conditionText.substring("(hmr-bid:".length, bundleIdEnd),
-          10,
-        );
-
-        for (let j = 1; j < ruleCount && match === null; j++) {
-          match = this.findMatchingSupportsRule(cssRules[j] as CSSSupportsRule, id, sheet);
-        }
-      }
-
-      // Ensure we don't leak the HTMLLinkElement
-      if (match === null) {
-        CSSLoader.cssLoadId.file = "";
-        CSSLoader.cssLoadId.bundle_id = CSSLoader.cssLoadId.id = 0;
-        CSSLoader.cssLoadId.node = null;
-        CSSLoader.cssLoadId.sheet = null;
-      }
-
-      return match;
-    }
-
-    handleBuildSuccess(bytes: Uint8Array, build: API.WebsocketMessageBuildSuccess, timestamp: number) {
-      const start = performance.now();
-      var update = this.findCSSLinkTag(build.id);
-      // The last 4 bytes of the build message are the hash of the module
-      // Currently, this hash is only used for ensuring we reload the source-map
-
-      if (update === null) {
-        __hmrlog.debug("Skipping unused CSS.");
-        return;
-      }
-
-      if (bytes.length === 0) {
-        __hmrlog.debug("Skipping empty file");
-        return;
-      }
-
-      let filepath = update.file;
-      // We cannot safely do this because the hash would change on the server
-      if (filepath.startsWith(this.hmr.cwd)) {
-        filepath = filepath.substring(this.hmr.cwd.length);
-      }
-      const _timestamp = timestamp;
-      const from_timestamp = build.from_timestamp;
-      function onLoadHandler() {
-        const localDuration = formatDuration(performance.now() - start);
-        const fsDuration = _timestamp - from_timestamp;
-        __hmrlog.log("Reloaded in", `${localDuration + fsDuration}ms`, "-", filepath);
-
-        update = null;
-        filepath = null;
-      }
-
-      // Whenever
-      switch (this.updateMethod) {
-        case CSSUpdateMethod.blobURL: {
-          let blob = new Blob([bytes], { type: "text/css" });
-
-          const blobURL = URL.createObjectURL(blob);
-          // onLoad doesn't fire in Chrome.
-          // I'm not sure why.
-          // Guessing it only triggers when an element is added/removed, not when the href just changes
-          // So we say on the next tick, we're loaded.
-          setTimeout(onLoadHandler.bind(update.node), 0);
-          update.node.setAttribute("href", blobURL);
-          blob = null;
-          URL.revokeObjectURL(blobURL);
-          break;
-        }
-        case CSSUpdateMethod.cssObjectModel: {
-          if (!this.decoder) {
-            this.decoder = new TextDecoder("UTF8");
-          }
-
-          // This is an adoptedStyleSheet, call replaceSync and be done with it.
-          if (!update.node || update.node.tagName === "HTML") {
-            update.sheet.replaceSync(this.decoder.decode(bytes));
-          } else if (update.node.tagName === "LINK" || update.node.tagName === "STYLE") {
-            // This might cause CSS specifity issues....
-            // I'm not 100% sure this is a safe operation
-            const sheet = new CSSStyleSheet();
-            const decoded = this.decoder.decode(bytes);
-
-            sheet.replaceSync(decoded);
-            update.node.remove();
-
-            document.adoptedStyleSheets = [...document.adoptedStyleSheets, sheet];
-          }
-          break;
-        }
-      }
-
-      bytes = null;
-    }
-
-    filePath(file_change_notification: API.WebsocketMessageFileChangeNotification): string | null {
-      if (file_change_notification.loader !== API.Loader.css) return null;
-      const tag = this.findCSSLinkTag(file_change_notification.id);
-
-      if (!tag) {
-        return null;
-      }
-
-      return tag.file;
-    }
-  }
-
-  class HMRClient {
-    static client: HMRClient;
-    socket: WebSocket;
-    hasWelcomed: boolean = false;
-    reconnect: number = 0;
-    // Server timestamps are relative to the time the server's HTTP server launched
-    // This so we can send timestamps as uint32 instead of 128-bit integers
-    epoch: number = 0;
-    javascriptReloader: API.Reloader = API.Reloader.disable;
-    loaders = {
-      css: new CSSLoader(),
-    };
-    assetPrefixPath: string = "";
-
-    sessionId: number;
-
-    get dependencies() {
-      return HMRModule.dependencies;
-    }
-
-    start() {
-      if (runOnce) {
-        __hmrlog.warn("Attempted to start HMR client multiple times. This may be a bug.");
-        return;
-      }
-
-      this.loaders.css.hmr = this;
-      runOnce = true;
-      this.connect();
-
-      // Explicitly send a socket close event so the thread doesn't have to wait for a timeout
-      var origUnload = globalThis.onbeforeunload;
-      globalThis.onbeforeunload = (ev: Event) => {
-        this.disableReconnect = true;
-
-        if (this.socket && this.socket.readyState === this.socket.OPEN) {
-          this.socket.close(4990, "unload");
-        }
-        origUnload && origUnload.call(globalThis, [ev]);
-      };
-    }
-
-    nextReconnectAttempt = 0;
-    reconnectDelay = 16;
-    debouncedReconnect = () => {
-      if (
-        this.socket &&
-        (this.socket.readyState == this.socket.OPEN || this.socket.readyState == this.socket.CONNECTING)
-      )
-        return;
-
-      this.nextReconnectAttempt = setTimeout(this.attemptReconnect, this.reconnectDelay);
-    };
-
-    attemptReconnect = () => {
-      globalThis.clearTimeout(this.nextReconnectAttempt);
-      if (
-        this.socket &&
-        (this.socket.readyState == this.socket.OPEN || this.socket.readyState == this.socket.CONNECTING)
-      )
-        return;
-      this.connect();
-      this.reconnectDelay += Math.floor(Math.random() * 128);
-    };
-
-    connect() {
-      if (
-        this.socket &&
-        (this.socket.readyState == this.socket.OPEN || this.socket.readyState == this.socket.CONNECTING)
-      )
-        return;
-
-      clientStartTime = performance.now();
-
-      const baseURL = new URL(location.origin + "/bun:_api.hmr");
-      baseURL.protocol = location.protocol === "https:" ? "wss" : "ws";
-      this.socket = new WebSocket(baseURL.toString(), ["bun-hmr"]);
-      this.socket.binaryType = "arraybuffer";
-      this.socket.onclose = this.handleClose;
-      this.socket.onerror = this.handleError;
-      this.socket.onopen = this.handleOpen;
-      this.socket.onmessage = this.handleMessage;
-    }
-
-    // key: module id
-    // value: server-timestamp
-    builds = new Map<number, number>();
-    cwd: string;
-
-    indexOfModuleId(id: number): number {
-      return HMRModule.dependencies.graph.indexOf(id);
-    }
-
-    static cssQueue = [];
-    static cssState = CSSImportState.Pending;
-    static cssAutoFOUC = false;
-
-    static processPendingCSSImports() {
-      const pending = HMRClient.cssQueue.slice();
-      HMRClient.cssQueue.length = 0;
-      return Promise.all(pending).then(() => {
-        if (HMRClient.cssQueue.length > 0) {
-          const _pending = HMRClient.cssQueue.slice();
-          HMRClient.cssQueue.length = 0;
-          return Promise.all(_pending).then(HMRClient.processPendingCSSImports);
-        } else {
-          return true;
-        }
-      });
-    }
-
-    static importCSS(promise: Promise<unknown>) {
-      switch (HMRClient.cssState) {
-        case CSSImportState.Pending: {
-          this.cssState = CSSImportState.Loading;
-          // This means we can import without risk of FOUC
-          if (document.documentElement.innerText === "" && !HMRClient.cssAutoFOUC) {
-            if (document.body) document.body.style.visibility = "hidden";
-            HMRClient.cssAutoFOUC = true;
-          }
-
-          promise.then(this.processPendingCSSImports).finally(() => {
-            if (HMRClient.cssAutoFOUC) {
-              // "delete" doesn't work here. Not sure why.
-              if (document.body) {
-                // Force layout
-                window.getComputedStyle(document.body);
-
-                document.body.style.visibility = "visible";
-              }
-              HMRClient.cssAutoFOUC = false;
-            }
-            this.cssState = CSSImportState.Loaded;
-          });
-          break;
-        }
-        case CSSImportState.Loaded: {
-          promise.then(
-            () => {},
-            () => {},
-          );
-          break;
-        }
-        case CSSImportState.Loading: {
-          this.cssQueue.push(promise);
-          break;
-        }
-      }
-    }
-
-    static allImportedStyles = new Set();
-    static onCSSImport(event) {
-      HMRClient.allImportedStyles.add(event.detail);
-
-      if (globalThis["Bun_disableCSSImports"]) {
-        return;
-      }
-
-      const url = event.detail;
-
-      if (typeof url !== "string" || url.length === 0) {
-        console.warn("[CSS Importer] Received invalid CSS import", url);
-        return;
-      }
-
-      const thisURL = new URL(url, location.origin);
-
-      for (let i = 0; i < document.styleSheets.length; i++) {
-        const sheet = document.styleSheets[i];
-        if (!sheet.href) continue;
-
-        if (sheet.href === url) {
-          // Already imported
-          return;
-        }
-
-        try {
-          const _url1 = new URL(sheet.href, location.origin);
-
-          if (_url1.pathname === thisURL.pathname) {
-            // Already imported
-            return;
-          }
-        } catch (e) {}
-      }
-
-      const urlString = thisURL.toString();
-      HMRClient.importCSS(
-        new Promise((resolve, reject) => {
-          if (globalThis["Bun_disableCSSImports"]) {
-            return;
-          }
-
-          var link = document.createElement("link");
-          link.rel = "stylesheet";
-          link.href = urlString;
-          link.onload = () => {
-            resolve();
-          };
-
-          link.onerror = evt => {
-            console.error(`[CSS Importer] Error loading CSS file: ${urlString}\n`, evt.toString());
-            reject();
-          };
-          document.head.appendChild(link);
-        }).then(() => Promise.resolve()),
-      );
-    }
-    static onError(event: ErrorEvent) {
-      if ("error" in event && !!event.error) {
-        BunError.render(event.error, HMRClient.client ? HMRClient.client.cwd : "");
-      }
-    }
-
-    static activate(verboseOrFastRefresh: boolean = false) {
-      // Support browser-like envirnments where location and WebSocket exist
-      // Maybe it'll work in Deno! Who knows.
-      if (this.client || !("location" in globalThis) || !("WebSocket" in globalThis)) {
-        return;
-      }
-
-      globalThis.addEventListener("error", HMRClient.onError);
-      this.client = new HMRClient();
-      // if (
-      //   "sessionStorage" in globalThis &&
-      //   globalThis.sessionStorage.getItem("bun-hmr-session-id")
-      // ) {
-      //   this.client.sessionId = parseInt(
-      //     globalThis.sessionStorage.getItem("bun-hmr-session-id"),
-      //     16
-      //   );
-      // } else {
-      //   this.client.sessionId = Math.floor(Math.random() * 65534);
-      //   if ("sessionStorage" in globalThis) {
-      //     try {
-      //       globalThis.sessionStorage.setItem(
-      //         "bun-hmr-session-id",
-      //         this.client.sessionId.toString(16)
-      //       );
-      //     } catch (exception) {}
-      //   }
-      // }
-      this.client.verbose = verboseOrFastRefresh;
-      this.client.start();
-      globalThis["__BUN_HMR"] = this.client;
-    }
-
-    handleBuildFailure(buffer: ByteBuffer, timestamp: number) {
-      const build = API.decodeWebsocketMessageBuildFailure(buffer);
-      const id = build.id;
-
-      // const index = this.indexOfModuleId(id);
-      // // Ignore build failures of modules that are not loaded
-      // if (index === -1) {
-      //   this.maybeReportBuildFailure(build);
-      //   return;
-      // }
-
-      // // Build failed for a module we didn't request?
-      // const minTimestamp = this.builds.get(index);
-      // if (!minTimestamp) {
-      //   return;
-      // }
-      // const fail = API.decodeWebsocketMessageBuildFailure(buffer);
-
-      this.reportBuildFailure(build);
-    }
-
-    maybeReportBuildFailure(failure: API.WebsocketMessageBuildFailure) {
-      BunError.render(failure, this.cwd);
-    }
-
-    needsConsoleClear = false;
-
-    reportBuildFailure(failure: API.WebsocketMessageBuildFailure) {
-      BunError.render(failure, this.cwd);
-
-      console.group(`Build failed: ${failure.module_path} (${failure.log.errors} errors)`);
-      this.needsConsoleClear = true;
-      for (let msg of failure.log.msgs) {
-        var logFunction;
-        switch (msg.level) {
-          case API.MessageLevel.err: {
-            logFunction = console.error;
-            break;
-          }
-          case API.MessageLevel.warn: {
-            logFunction = console.warn;
-            break;
-          }
-          default: {
-            logFunction = console.info;
-            break;
-          }
-        }
-
-        const { text, location } = msg.data;
-        var output = "";
-
-        if (location) {
-          if (location.line > -1 && location.column > -1) {
-            output += `${location.file}:${location.line}:${location.column}`;
-          } else if (location.line > -1) {
-            output += `${location.file}:${location.line}`;
-          } else if (location.file.length > 0) {
-            output += `${location.file}`;
-          }
-        }
-        if (location && location.line_text) {
-          output = output.trimRight() + "\n" + location.line_text.trim();
-        }
-
-        output = output.trimRight() + "\n " + text;
-
-        logFunction(output.trim());
-      }
-      console.groupEnd();
-    }
-
-    verbose = false;
-
-    handleError = (error: ErrorEvent) => {
-      __hmrlog.error("Websocket error", error.error);
-      if (this.reconnect !== 0) {
-        return;
-      }
-      this.debouncedReconnect();
-    };
-
-    handleBuildSuccess(buffer: ByteBuffer, timestamp: number) {
-      const build = API.decodeWebsocketMessageBuildSuccess(buffer);
-
-      // Ignore builds of modules we expect a later version of
-      const currentVersion = this.builds.get(build.id) || -Infinity;
-
-      // allow 4ms of leeway
-      if (currentVersion > build.from_timestamp + 4) {
-        if (this.verbose) {
-          __hmrlog.debug(
-            `Ignoring outdated update for "${build.module_path}".\n  Expected: >=`,
-            currentVersion,
-            `\n   Received:`,
-            build.from_timestamp,
-          );
-        }
-        return;
-      }
-      var bytes =
-        buffer.data.byteOffset + buffer.index + build.blob_length <= buffer.data.buffer.byteLength
-          ? new Uint8Array(buffer.data.buffer, buffer.data.byteOffset + buffer.index, build.blob_length)
-          : (empty ||= new Uint8Array(0));
-
-      if (build.loader === API.Loader.css) {
-        BunError.clear();
-        if (this.needsConsoleClear) {
-          console.clear();
-          this.needsConsoleClear = false;
-        }
-        return this.loaders.css.handleBuildSuccess(bytes, build, timestamp);
-      }
-
-      const id = build.id;
-      const index = this.indexOfModuleId(id);
-      // Ignore builds of modules that are not loaded
-      if (index === -1) {
-        if (this.verbose) {
-          __hmrlog.debug(`Skipping reload for unknown module id:`, id);
-        }
-
-        return;
-      }
-
-      if (this.verbose) {
-        var filepath = HMRModule.dependencies.modules[index].file_path;
-        if (filepath.startsWith(this.cwd)) {
-          filepath = filepath.substring(this.cwd.length);
-        }
-        __hmrlog.debug("Preparing to reload", filepath);
-      }
-
-      // The last 4 bytes of the build message are the hash of the module
-      // Currently, this hash is only used for ensuring we reload the source-map
-      var end = buffer.index + build.blob_length;
-      var hash = 0;
-      if (end > buffer.data.length && end > 4) {
-        end = buffer.data.length - 4;
-      }
-
-      if (end > 4 && buffer.data.length >= end + 4) {
-        new Uint8Array(this.hashBuffer.buffer).set(buffer.data.subarray(end, end + 4));
-        hash = this.hashBuffer[0];
-      }
-
-      // These are the bytes!!
-
-      var reload = new HotReload(build.id, index, build, bytes, ReloadBehavior.hotReload, hash || 0);
-      bytes = null;
-      reload.timings.notify = timestamp - build.from_timestamp;
-
-      BunError.clear();
-
-      reload.run().then(
-        ([module, timings]) => {
-          var filepath = module.file_path;
-
-          if (filepath.startsWith(this.cwd)) {
-            filepath = filepath.substring(this.cwd.length);
-          }
-
-          if (this.needsConsoleClear) {
-            console.clear();
-            this.needsConsoleClear = false;
-          }
-
-          __hmrlog.log(`[${formatDuration(timings.total)}ms] Reloaded`, filepath);
-        },
-        err => {
-          if (typeof err === "object" && err && err instanceof ThrottleModuleUpdateError) {
-            return;
-          }
-          __hmrlog.error("Hot Module Reload failed!", err);
-          debugger;
-        },
-      );
-    }
-
-    performFullReload() {
-      if (typeof location !== "undefined") {
-        if (this.socket.readyState === this.socket.OPEN) {
-          // Disable reconnecting
-          this.reconnect = 1;
-          this.socket.close();
-        }
-        location.reload();
-      }
-    }
-
-    handleFileChangeNotification(buffer: ByteBuffer, timestamp: number, copy_file_path: boolean) {
-      const notification = API.decodeWebsocketMessageFileChangeNotification(buffer);
-      let file_path = "";
-      switch (notification.loader) {
-        case API.Loader.css: {
-          file_path = this.loaders.css.filePath(notification);
-          break;
-        }
-
-        case API.Loader.js:
-        case API.Loader.jsx:
-        case API.Loader.tsx:
-        case API.Loader.ts:
-        case API.Loader.json: {
-          const index = HMRModule.dependencies.graph
-            .subarray(0, HMRModule.dependencies.graph_used)
-            .indexOf(notification.id);
-
-          if (index > -1) {
-            file_path = HMRModule.dependencies.modules[index].file_path;
-          }
-          break;
-        }
-
-        default: {
-          return;
-        }
-      }
-
-      return this.handleFileChangeNotificationBase(timestamp, notification, file_path, copy_file_path);
-    }
-
-    private handleFileChangeNotificationBase(
-      timestamp: number,
-      notification: API.WebsocketMessageFileChangeNotification,
-      file_path: string,
-      copy_file_path: boolean,
-    ) {
-      const accept = file_path && file_path.length > 0;
-
-      if (!accept) {
-        if (this.verbose) {
-          __hmrlog.debug("Unknown module changed, skipping");
-        }
-        return;
-      }
-
-      if ((this.builds.get(notification.id) || -Infinity) > timestamp) {
-        __hmrlog.debug(`Received stale update for ${file_path}`);
-        return;
-      }
-
-      let reloadBehavior = ReloadBehavior.ignore;
-
-      switch (notification.loader) {
-        // CSS always supports hot reloading
-        case API.Loader.css: {
-          this.builds.set(notification.id, timestamp);
-          // When we're dealing with CSS, even though the watch event happened for a file in the bundle
-          // We want it to regenerate the entire bundle
-          // So we must swap out the ID we send for the ID of the corresponding bundle.
-          notification.id = this.loaders.css.bundleId();
-          this.builds.set(notification.id, timestamp);
-          reloadBehavior = ReloadBehavior.hotReload;
-          break;
-        }
-        // The backend will detect if they have react-refresh in their bundle
-        // If so, it will use it.
-        // Else, it will fall back to live reloading.
-        case API.Loader.js:
-        case API.Loader.jsx:
-        case API.Loader.json:
-        case API.Loader.ts:
-        case API.Loader.tsx: {
-          switch (this.javascriptReloader) {
-            case API.Reloader.disable: {
-              break;
-            }
-            case API.Reloader.fast_refresh: {
-              this.builds.set(notification.id, timestamp);
-              reloadBehavior = ReloadBehavior.hotReload;
-              break;
-            }
-            case API.Reloader.live: {
-              reloadBehavior = ReloadBehavior.fullReload;
-              break;
-            }
-          }
-          break;
-        }
-      }
-
-      switch (reloadBehavior) {
-        // This is the same command/logic for both JS and CSS hot reloading.
-        case ReloadBehavior.hotReload: {
-          if (copy_file_path && !this.buildCommandBufWithFilePath) {
-            // on Linux, max file path length is 4096 bytes
-            // on macOS & Windows, max file path length is 1024 bytes
-            // 256 is extra breathing room
-            this.buildCommandBufWithFilePath = new Uint8Array(4096 + 256);
-          }
-
-          const writeBuffer = !copy_file_path ? this.buildCommandBuf : this.buildCommandBufWithFilePath;
-          writeBuffer[0] = !copy_file_path
-            ? API.WebsocketCommandKind.build
-            : API.WebsocketCommandKind.build_with_file_path;
-          this.buildCommandUArray[0] = timestamp;
-          writeBuffer.set(this.buildCommandUArrayEight, 1);
-          this.buildCommandUArray[0] = notification.id;
-          writeBuffer.set(this.buildCommandUArrayEight, 5);
-
-          if (copy_file_path) {
-            if (!textEncoder) {
-              textEncoder = new TextEncoder();
-            }
-
-            this.buildCommandUArray[0] = file_path.length;
-            writeBuffer.set(this.buildCommandUArrayEight, 9);
-
-            const out = textEncoder.encodeInto(file_path, writeBuffer.subarray(13));
-            this.socket.send(this.buildCommandBufWithFilePath.subarray(0, 13 + out.written));
-          } else {
-            this.socket.send(this.buildCommandBuf);
-          }
-
-          if (this.verbose) {
-            __hmrlog.debug(`Requesting update for ${file_path}`);
-          }
-          break;
-        }
-
-        case ReloadBehavior.fullReload: {
-          this.performFullReload();
-          break;
-        }
-      }
-    }
-
-    buildCommandBuf = new Uint8Array(9);
-    buildCommandUArray = new Uint32Array(1);
-    buildCommandUArrayEight = new Uint8Array(this.buildCommandUArray.buffer);
-    hashBuffer = new Uint32Array(1);
-
-    // lazily allocate because it's going to be much larger than 9 bytes
-    buildCommandBufWithFilePath: Uint8Array;
-
-    // On open, reset the delay for reconnecting
-    handleOpen = (event: Event) => {
-      globalThis.clearTimeout(this.nextReconnectAttempt);
-      setTimeout(() => {
-        if (this.socket && this.socket.readyState == this.socket.OPEN) {
-          globalThis.clearTimeout(this.nextReconnectAttempt);
-          this.reconnectDelay = 16;
-        }
-      }, 16);
-    };
-
-    handleMessage = (event: MessageEvent) => {
-      const data = new Uint8Array(event.data);
-      const message_header_byte_buffer = new ByteBuffer(data);
-      const header = API.decodeWebsocketMessage(message_header_byte_buffer);
-      const buffer = new ByteBuffer(data.subarray(message_header_byte_buffer.index));
-
-      switch (header.kind) {
-        case API.WebsocketMessageKind.build_fail: {
-          this.handleBuildFailure(buffer, header.timestamp);
-          break;
-        }
-        case API.WebsocketMessageKind.build_success: {
-          this.handleBuildSuccess(buffer, header.timestamp);
-          break;
-        }
-
-        case API.WebsocketMessageKind.resolve_file: {
-          const { id } = API.decodeWebsocketMessageResolveID(buffer);
-          const timestamp = this.builds.get(id) || 0;
-
-          if (timestamp == 0 && HotReload.VERBOSE) {
-            __hmrlog.debug(`Unknown module? ${id}`);
-            return;
-          }
-
-          const index = HMRModule.dependencies.graph.subarray(0, HMRModule.dependencies.graph_used).indexOf(id);
-          var file_path: string = "";
-          var loader = API.Loader.js;
-          if (index > -1) {
-            file_path = HMRModule.dependencies.modules[index].file_path;
-          } else {
-            const tag = this.loaders.css.findCSSLinkTag(id);
-            if (tag && tag.file.length) {
-              file_path = tag.file;
-            }
-          }
-
-          if (!file_path || file_path.length === 0) {
-            if (HotReload.VERBOSE) {
-              __hmrlog.debug(`Unknown module? ${id}`);
-            }
-            return;
-          }
-
-          switch (file_path.substring(file_path.lastIndexOf("."))) {
-            case ".css": {
-              loader = API.Loader.css;
-              break;
-            }
-
-            case ".mjs":
-            case ".cjs":
-            case ".js": {
-              loader = API.Loader.js;
-              break;
-            }
-
-            case ".json": {
-              loader = API.Loader.json;
-              break;
-            }
-
-            case ".cts":
-            case ".mts":
-            case ".ts": {
-              loader = API.Loader.ts;
-              break;
-            }
-
-            case ".tsx": {
-              loader = API.Loader.tsx;
-              break;
-            }
-
-            case ".jsx": {
-              loader = API.Loader.jsx;
-              break;
-            }
-
-            default: {
-              loader = API.Loader.file;
-              break;
-            }
-          }
-
-          this.handleFileChangeNotificationBase(timestamp, { id, loader }, file_path, true);
-          break;
-        }
-        case API.WebsocketMessageKind.file_change_notification: {
-          this.handleFileChangeNotification(buffer, header.timestamp, false);
-          break;
-        }
-        case API.WebsocketMessageKind.file_change_notification_with_hint: {
-          this.handleFileChangeNotification(buffer, header.timestamp, true);
-          break;
-        }
-        case API.WebsocketMessageKind.welcome: {
-          const now = performance.now();
-
-          this.hasWelcomed = true;
-          const welcome = API.decodeWebsocketMessageWelcome(buffer);
-          this.epoch = welcome.epoch;
-          this.javascriptReloader = welcome.javascriptReloader;
-          this.cwd = welcome.cwd;
-          this.assetPrefixPath = welcome.assetPrefix;
-
-          switch (this.javascriptReloader) {
-            case API.Reloader.fast_refresh: {
-              __hmrlog.log("HMR connected in", formatDuration(now - clientStartTime), "ms");
-              break;
-            }
-            case API.Reloader.live: {
-              __hmrlog.log("Live reload connected in", formatDuration(now - clientStartTime), "ms");
-              break;
-            }
-            default: {
-              __hmrlog.log("Bun connected in", formatDuration(now - clientStartTime), "ms");
-              break;
-            }
-          }
-          clientStartTime = now;
-          if (!this.epoch) {
-            __hmrlog.warn("Internal HMR error");
-          }
-          break;
-        }
-      }
-    };
-
-    disableReconnect = false;
-
-    handleClose = (event: CloseEvent) => {
-      if (this.reconnect !== 0 || this.disableReconnect) {
-        return;
-      }
-
-      this.debouncedReconnect();
-    };
-  }
-  let pendingUpdateCount = 0;
-
-  class ThrottleModuleUpdateError extends Error {
-    constructor(message) {
-      super(message);
-    }
-  }
-
-  class HotReload {
-    module_id: number = 0;
-    module_index: number = 0;
-    build: API.WebsocketMessageBuildSuccess;
-    hash: number = 0 | 0;
-
-    timings = {
-      notify: 0,
-      decode: 0,
-      import: 0,
-      callbacks: 0,
-      total: 0,
-      start: 0,
-    };
-    static VERBOSE = false;
-    bytes: Uint8Array;
-    reloader: ReloadBehavior;
-
-    constructor(
-      module_id: HotReload["module_id"],
-      module_index: HotReload["module_index"],
-      build: HotReload["build"],
-      bytes: Uint8Array,
-      reloader: ReloadBehavior,
-      hash: number,
-    ) {
-      this.module_id = module_id;
-      this.module_index = module_index;
-      this.build = build;
-      this.bytes = bytes;
-      this.reloader = reloader;
-      this.hash = hash;
-    }
-
-    async run() {
-      pendingUpdateCount++;
-      let result: [HMRModule, HotReload["timings"]];
-      try {
-        result = await this._run();
-      } finally {
-        pendingUpdateCount--;
-      }
-
-      return result;
-    }
-
-    private async _run(): Promise<[HMRModule, HotReload["timings"]]> {
-      const currentPendingUpdateCount = pendingUpdateCount;
-
-      const importStart = performance.now();
-      let orig_deps = HMRModule.dependencies;
-      // we must preserve the updater since that holds references to the real exports.
-      // this is a fundamental limitation of using esmodules for HMR.
-      // we cannot export new modules. we can only mutate existing ones.
-
-      const oldGraphUsed = HMRModule.dependencies.graph_used;
-      var oldModule =
-        HMRModule.dependencies.modules.length > this.module_index && HMRModule.dependencies.modules[this.module_index];
-      HMRModule.dependencies = orig_deps.fork(this.module_index);
-      var blobURL = "";
-
-      // We inject the source map URL into the end of the file.
-      // We do that here for a few reasons:
-      // 1. It is hard to correctly set the path in here to what the browser expects.
-      // 2.
-      const modulePathWithoutLeadingSlash =
-        this.build.module_path.length > 0 && this.build.module_path[0] === "/"
-          ? this.build.module_path.substring(1)
-          : this.build.module_path;
-      const sourceMapURL =
-        this.hash > 0 && this.build.module_path.length > 0
-          ? `\n//# sourceMappingURL=${
-              // location.origin does not have a trailing slash
-              globalThis.location.origin
-            }/${modulePathWithoutLeadingSlash}.map?b=${this.hash.toString(16)}`
-          : "";
-
-      try {
-        const blob = new Blob(sourceMapURL.length > 0 ? [this.bytes, sourceMapURL] : [this.bytes], {
-          type: "text/javascript",
-        });
-        blobURL = URL.createObjectURL(blob);
-        HMRModule.dependencies.blobToID.set(blobURL, this.module_id);
-        await import(blobURL);
-        this.bytes = null;
-        URL.revokeObjectURL(blobURL);
-        this.timings.import = performance.now() - importStart;
-      } catch (exception) {
-        HMRModule.dependencies = orig_deps;
-        URL.revokeObjectURL(blobURL);
-        // Ensure we don't keep the bytes around longer than necessary
-        this.bytes = null;
-
-        if ("__BunRenderHMRError" in globalThis) {
-          globalThis.__BunRenderHMRError(exception, oldModule.file_path, oldModule.id);
-        }
-
-        oldModule = null;
-        throw exception;
-      }
-
-      // We didn't import any new modules, so we resume as before.
-      if (HMRModule.dependencies.graph_used === this.module_index) {
-        HMRModule.dependencies.graph_used = oldGraphUsed;
-      } else {
-        // If we do import a new module, we have to do a full page reload for now
-      }
-
-      blobURL = "";
-      // Ensure we don't keep the bytes around longer than necessary
-      this.bytes = null;
-
-      if (HotReload.VERBOSE) {
-        __hmrlog.debug(
-          "Re-imported",
-          HMRModule.dependencies.modules[this.module_index].file_path,
-          "in",
-          formatDuration(this.timings.import),
-          ". Running callbacks",
-        );
-      }
-
-      const callbacksStart = performance.now();
-      const origUpdaters = oldModule
-        ? new Set<CallableFunction>(oldModule.additional_updaters)
-        : new Set<CallableFunction>();
-      try {
-        switch (this.reloader) {
-          case ReloadBehavior.hotReload: {
-            let foundBoundary = false;
-
-            const isOldModuleDead =
-              oldModule &&
-              oldModule.previousVersion &&
-              oldModule.previousVersion.id === oldModule.id &&
-              oldModule.hasSameExports(oldModule.previousVersion);
-
-            var thisMod = HMRModule.dependencies.modules[this.module_index];
-            if (oldModule && oldModule._update !== thisMod._update) {
-              // ESM-based HMR has a disadvantage against CommonJS HMR
-              // ES Namespace objects are not [[Configurable]]
-              // That means we have to loop through all previous versions of updated modules that that have unique export names
-              // and updates those exports specifically
-              // Otherwise, changes will not be reflected properly
-              // However, we only need to loop through modules that add or remove exports, i.e. those are ones which have "real" exports
-              if (!isOldModuleDead) {
-                oldModule.boundUpdate ||= oldModule.update.bind(oldModule);
-
-                if (thisMod.additional_updaters) thisMod.additional_updaters.add(oldModule.boundUpdate);
-                else thisMod.additional_updaters = new Set([oldModule.boundUpdate]);
-
-                thisMod.previousVersion = oldModule;
-              } else {
-                if (oldModule.previousVersion) thisMod.previousVersion = oldModule.previousVersion;
-
-                thisMod.additional_updaters = origUpdaters;
-              }
-            }
-
-            const end = Math.min(this.module_index + 1, HMRModule.dependencies.graph_used);
-            // -- For generic hot reloading --
-            // ES Modules delay execution until all imports are parsed
-            // They execute depth-first
-            // If you load N modules and append each module ID to the array, 0 is the *last* unique module imported.
-            // modules.length - 1 is the first.
-            // Therefore, to reload all the modules in the correct order, we traverse the graph backwards
-            // This only works when the graph is up to date.
-            // If the import order changes, we need to regenerate the entire graph
-            // Which sounds expensive, until you realize that we are mostly talking about an array that will be typically less than 1024 elements
-            // Computers can create an array of < 1024 pointer-sized elements in < 1ms easy!
-            // --
-
-            // -- For React Fast Refresh --
-            // We must find a React Refresh boundary. This is a module that only exports React components.
-            // If we do not find a React Refresh boundary, we must instead perform a full page reload.
-            for (
-              let i = 0;
-              i <= end;
-              i++ // let i = HMRModule.dependencies.graph_used - 1; // i > this.module_index; // i--
-            ) {
-              const mod = HMRModule.dependencies.modules[i];
-              if (!mod) continue; // this array is holey sometimes
-              let handled = false;
-
-              if (!mod.exports.__hmrDisable) {
-                if (typeof mod.dispose === "function") {
-                  mod.dispose();
-                  handled = true;
-                }
-                if (typeof mod.accept === "function") {
-                  mod.accept();
-                  handled = true;
-                }
-
-                // If we don't find a boundary, we will need to do a full page load
-                if ((mod as FastRefreshModule).isRefreshBoundary) {
-                  foundBoundary = true;
-                }
-
-                // Automatically re-initialize the dependency
-                if (!handled) {
-                  mod.update();
-                }
-              }
-            }
-
-            // By the time we get here, it's entirely possible that another update is waiting
-            // Instead of scheduling it, we are going to just ignore this update.
-            // But we still need to re-initialize modules regardless because otherwise a dependency may not reload properly
-            if (pendingUpdateCount === currentPendingUpdateCount && foundBoundary) {
-              FastRefreshLoader.RefreshRuntime.performReactRefresh();
-              // Remove potential memory leak
-              if (isOldModuleDead) oldModule.previousVersion = null;
-            } else if (pendingUpdateCount === currentPendingUpdateCount) {
-              FastRefreshLoader.performFullRefresh();
-            } else {
-              return Promise.reject(
-                new ThrottleModuleUpdateError(
-                  `Expected pendingUpdateCount: ${currentPendingUpdateCount} but received: ${pendingUpdateCount}`,
-                ),
-              );
-            }
-
-            break;
-          }
-        }
-      } catch (exception) {
-        HMRModule.dependencies = orig_deps;
-        HMRModule.dependencies.modules[this.module_index].additional_updaters = origUpdaters;
-        throw exception;
-      }
-      this.timings.callbacks = performance.now() - callbacksStart;
-
-      if (HotReload.VERBOSE) {
-        __hmrlog.debug(
-          "Ran callbacks",
-          HMRModule.dependencies.modules[this.module_index].file_path,
-          "in",
-          formatDuration(this.timings.callbacks),
-          "ms",
-        );
-      }
-
-      orig_deps = null;
-      this.timings.total = this.timings.import + this.timings.callbacks + this.timings.notify;
-      return Promise.resolve([HMRModule.dependencies.modules[this.module_index], this.timings]);
-    }
-  }
-
-  type AnyHMRModule = HMRModule | FastRefreshModule;
-  class DependencyGraph {
-    modules: AnyHMRModule[];
-    graph: Uint32Array;
-    graph_used = 0;
-    blobToID = new Map<string, number>();
-
-    getModuleByBlobURL(url: string): AnyHMRModule | null {
-      const id = this.blobToID.get(url);
-      return Number.isFinite(id) && this.getModuleByID(id);
-    }
-
-    getFilePathFromBlob(url: string): string | null {
-      const module = this.getModuleByBlobURL(url);
-      if (!module) return null;
-
-      let filepath = module.file_path;
-      // We cannot safely do this because the hash would change on the server
-      if (filepath.startsWith(HMRClient.client.cwd)) {
-        filepath = filepath.substring(HMRClient.client.cwd.length);
-      }
-
-      return filepath;
-    }
-
-    getModuleByID(id: number): AnyHMRModule | null {
-      const index = this.graph.indexOf(id);
-      return index > -1 ? this.modules[index] : null;
-    }
-
-    loadDefaults() {
-      this.modules = new Array<AnyHMRModule>(32);
-      this.graph = new Uint32Array(32);
-      this.graph_used = 0;
-    }
-
-    static loadWithDefaults() {
-      const graph = new DependencyGraph();
-      graph.loadDefaults();
-      return graph;
-    }
-
-    fork(offset: number) {
-      const graph = new DependencyGraph();
-      graph.modules = this.modules.slice();
-      graph.graph_used = offset;
-      graph.graph = this.graph.slice();
-      return graph;
-    }
-  }
-
-  class HMRModule {
-    constructor(id: number, file_path: string) {
-      this.id = id;
-      this.file_path = file_path;
-
-      Object.defineProperty(this, "name", {
-        get() {
-          return this.file_path;
-        },
-        configurable: false,
-        enumerable: false,
-      });
-
-      if (!HMRModule.dependencies) {
-        HMRModule.dependencies = HMRModule._dependencies;
-      }
-
-      this.graph_index = HMRModule.dependencies.graph_used++;
-
-      // Grow the dependencies graph
-      if (HMRModule.dependencies.graph.length <= this.graph_index) {
-        const new_graph = new Uint32Array(HMRModule.dependencies.graph.length * 4);
-        new_graph.set(HMRModule.dependencies.graph);
-        HMRModule.dependencies.graph = new_graph;
-
-        // In-place grow. This creates a holey array, which is bad, but less bad than pushing potentially 1000 times
-        HMRModule.dependencies.modules.length = new_graph.length;
-      }
-
-      HMRModule.dependencies.modules[this.graph_index] = this;
-      HMRModule.dependencies.graph[this.graph_index] = this.id;
-    }
-
-    previousVersion = null;
-
-    hasSameExports(that: AnyHMRModule) {
-      const thisKeys = Object.keys(this.exports);
-      const thatKeys = Object.keys(that.exports);
-      if (thisKeys.length !== thatKeys.length) {
-        return false;
-      }
-
-      for (let i = 0; i < thisKeys.length; i++) {
-        if (thisKeys[i] !== thatKeys[i]) {
-          return false;
-        }
-      }
-
-      return true;
-    }
-    #updateFunction;
-    get _update() {
-      return this.#updateFunction;
-    }
-    set _update(value) {
-      this.#updateFunction = value;
-      var existing = registryMap.get(this.file_path);
-    }
-    boundUpdate;
-    update() {
-      var updaters = registryMap.get(this.id);
-      if (updaters?.length) {
-        for (let update of updaters) {
-          update(this.exports);
-        }
-      }
-
-      this._update(this.exports);
-    }
-
-    static _dependencies = DependencyGraph.loadWithDefaults();
-    exportAll(object: Object) {
-      // object[alias] must be a function
-      for (let alias in object) {
-        this._exports[alias] = object[alias];
-        Object.defineProperty(this.exports, alias, {
-          get: this._exports[alias],
-          configurable: true,
-          enumerable: true,
-        });
-      }
-    }
-
-    static dependencies: DependencyGraph;
-    file_path: string;
-    _load = function () {};
-    id = 0;
-    graph_index = 0;
-    _exports = {};
-    exports = {};
-  }
-
-  function injectFastRefresh(RefreshRuntime) {
-    if (!FastRefreshLoader.hasInjectedFastRefresh) {
-      RefreshRuntime.injectIntoGlobalHook(globalThis);
-      FastRefreshLoader.hasInjectedFastRefresh = true;
-    }
-  }
-
-  class FastRefreshModule extends HMRModule {
-    constructor(id: number, file_path: string, RefreshRuntime: any) {
-      super(id, file_path);
-
-      // 4,000,000,000 in base36 occupies 7 characters
-      // file path is probably longer
-      // small strings are better strings
-      this.refreshRuntimeBaseID = (this.file_path.length > 7 ? this.id.toString(36) : this.file_path) + "/";
-      FastRefreshLoader.RefreshRuntime = FastRefreshLoader.RefreshRuntime || RefreshRuntime;
-
-      if (!FastRefreshLoader.hasInjectedFastRefresh) {
-        RefreshRuntime.injectIntoGlobalHook(globalThis);
-        FastRefreshLoader.hasInjectedFastRefresh = true;
-      }
-    }
-
-    refreshRuntimeBaseID: string;
-    isRefreshBoundary = false;
-
-    // $RefreshReg$
-    $r_(Component: any, id: string) {
-      FastRefreshLoader.RefreshRuntime.register(Component, this.refreshRuntimeBaseID + id);
-    }
-    // $RefreshReg$(Component, Component.name || Component.displayName)
-    $r(Component: any) {
-      if (!FastRefreshLoader.RefreshRuntime.isLikelyComponentType(Component)) {
-        return;
-      }
-
-      this.$r_(Component, Component.name || Component.displayName);
-    }
-
-    // Auto-register exported React components so we only have to manually register the non-exported ones
-    // This is what Metro does: https://github.com/facebook/metro/blob/9f2b1210a0f66378dd93e5fcaabc464c86c9e236/packages/metro-runtime/src/polyfills/require.js#L905
-    exportAll(object: any) {
-      super.exportAll(object);
-
-      // One thing I'm unsure of:
-      //   Do we need to register the exports object iself? Is it important for some namespacing thing?
-      //   Metro seems to do that. However, that might be an artifact of CommonJS modules. People do module.exports = SomeReactComponent.
-      var hasExports = false;
-      var onlyExportsComponents = true;
-      for (const key in object) {
-        if (key === "__esModule") {
-          continue;
-        }
-
-        hasExports = true;
-
-        // Everything in here should always be a function
-        // exportAll({blah: () => blah})
-        // If you see exception right here, please file an issue and include the source file in the issue.
-        const Component = object[key]();
-
-        // Ensure exported React components always have names
-        // This is for simpler debugging
-        if (Component && typeof Component === "function" && !("name" in Component) && Object.isExtensible(Component)) {
-          const named = {
-            get() {
-              return key;
-            },
-            enumerable: false,
-            configurable: true,
-          };
-          // Ignore any errors if it turns out this was already set as not configurable
-          try {
-            // "name" is the official JavaScript way
-            // "displayName" is the legacy React way
-            Object.defineProperties(Component, {
-              name: named,
-              displayName: named,
-            });
-          } catch (exception) {}
-        }
-
-        if (!FastRefreshLoader.RefreshRuntime.isLikelyComponentType(Component)) {
-          onlyExportsComponents = false;
-          // We can't stop here because we may have other exports which are components that need to be registered.
-          continue;
-        }
-
-        this.$r_(Component, key);
-      }
-
-      this.isRefreshBoundary = hasExports && onlyExportsComponents;
-    }
-
-    loaded(_onUpdate) {
-      this._update = _onUpdate;
-    }
-  }
-
-  var __hmrlog = {
-    debug(...args) {
-      // console.debug("[bun]", ...args);
-      console.debug(...args);
-    },
-    error(...args) {
-      // console.error("[bun]", ...args);
-      console.error(...args);
-    },
-    log(...args) {
-      // console.log("[bun]", ...args);
-      console.log(...args);
-    },
-    warn(...args) {
-      // console.warn("[bun]", ...args);
-      console.warn(...args);
-    },
-  };
-
-  // __HMRModule = FastRefreshModule;
-  __HMRModule = HMRModule;
-  __FastRefreshModule = FastRefreshModule;
-  __HMRClient = HMRClient;
-  __injectFastRefresh = injectFastRefresh;
-  if ("document" in globalThis) {
-    document.addEventListener("onimportcss", HMRClient.onCSSImport, {
-      passive: true,
-    });
-
-    // window.addEventListener("error", HMRClient.onError, { passive: true });
-  }
-  globalThis["__BUN"] = HMRClient;
-  globalThis["__BUN_ERROR"] = BunError;
-}
-
-export { __FastRefreshModule, __HMRClient, __HMRModule, __injectFastRefresh };
diff --git a/src/runtime/index-with-refresh.ts b/src/runtime/index-with-refresh.ts
deleted file mode 100644
index 670caa8bf1..0000000000
--- a/src/runtime/index-with-refresh.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-// @ts-nocheck
-export * as __FastRefreshRuntime from "../react-refresh";
-export * from "./errors";
-export * from "./hmr";
-export * from "./index-without-hmr";
-
-globalThis.process ||= {
-  env: {},
-  cwd() {
-    return "/bun-fake-dir/";
-  },
-} as any;
diff --git a/src/runtime/index-without-hmr.ts b/src/runtime/index-without-hmr.ts
deleted file mode 100644
index 514d6a23a0..0000000000
--- a/src/runtime/index-without-hmr.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-// @ts-nocheck
-export * from "../runtime.js";
-// export { default as regeneratorRuntime } from "./regenerator";
diff --git a/src/runtime/index.ts b/src/runtime/index.ts
deleted file mode 100644
index 313abe8f5b..0000000000
--- a/src/runtime/index.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-// @ts-nocheck
-export * from "./errors";
-export * from "./hmr";
-export * from "./index-without-hmr";
-
-globalThis.process ||= {
-  env: {},
-  cwd() {
-    return "/bun-fake-dir/";
-  },
-};
diff --git a/src/runtime/regenerator.ts b/src/runtime/regenerator.ts
deleted file mode 100644
index a3a7ba75ed..0000000000
--- a/src/runtime/regenerator.ts
+++ /dev/null
@@ -1,741 +0,0 @@
-// @ts-nocheck
-/**
- * Copyright (c) 2014-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-var runtime = (function (exports) {
-  "use strict";
-
-  var Op = Object.prototype;
-  var hasOwn = Op.hasOwnProperty;
-  var undefined; // More compressible than void 0.
-  var $Symbol = typeof Symbol === "function" ? Symbol : {};
-  var iteratorSymbol = $Symbol.iterator || "@@iterator";
-  var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
-  var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
-
-  function define(obj, key, value) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true,
-    });
-    return obj[key];
-  }
-  try {
-    // IE 8 has a broken Object.defineProperty that only works on DOM objects.
-    define({}, "");
-  } catch (err) {
-    define = function (obj, key, value) {
-      return (obj[key] = value);
-    };
-  }
-
-  function wrap(innerFn, outerFn, self, tryLocsList) {
-    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
-    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
-    var generator = Object.create(protoGenerator.prototype);
-    var context = new Context(tryLocsList || []);
-
-    // The ._invoke method unifies the implementations of the .next,
-    // .throw, and .return methods.
-    generator._invoke = makeInvokeMethod(innerFn, self, context);
-
-    return generator;
-  }
-  exports.wrap = wrap;
-
-  // Try/catch helper to minimize deoptimizations. Returns a completion
-  // record like context.tryEntries[i].completion. This interface could
-  // have been (and was previously) designed to take a closure to be
-  // invoked without arguments, but in all the cases we care about we
-  // already have an existing method we want to call, so there's no need
-  // to create a new function object. We can even get away with assuming
-  // the method takes exactly one argument, since that happens to be true
-  // in every case, so we don't have to touch the arguments object. The
-  // only additional allocation required is the completion record, which
-  // has a stable shape and so hopefully should be cheap to allocate.
-  function tryCatch(fn, obj, arg) {
-    try {
-      return { type: "normal", arg: fn.call(obj, arg) };
-    } catch (err) {
-      return { type: "throw", arg: err };
-    }
-  }
-
-  var GenStateSuspendedStart = "suspendedStart";
-  var GenStateSuspendedYield = "suspendedYield";
-  var GenStateExecuting = "executing";
-  var GenStateCompleted = "completed";
-
-  // Returning this object from the innerFn has the same effect as
-  // breaking out of the dispatch switch statement.
-  var ContinueSentinel = {};
-
-  // Dummy constructor functions that we use as the .constructor and
-  // .constructor.prototype properties for functions that return Generator
-  // objects. For full spec compliance, you may wish to configure your
-  // minifier not to mangle the names of these two functions.
-  function Generator() {}
-  function GeneratorFunction() {}
-  function GeneratorFunctionPrototype() {}
-
-  // This is a polyfill for %IteratorPrototype% for environments that
-  // don't natively support it.
-  var IteratorPrototype = {};
-  define(IteratorPrototype, iteratorSymbol, function () {
-    return this;
-  });
-
-  var getProto = Object.getPrototypeOf;
-  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
-  if (
-    NativeIteratorPrototype &&
-    NativeIteratorPrototype !== Op &&
-    hasOwn.call(NativeIteratorPrototype, iteratorSymbol)
-  ) {
-    // This environment has a native %IteratorPrototype%; use it instead
-    // of the polyfill.
-    IteratorPrototype = NativeIteratorPrototype;
-  }
-
-  var Gp = (GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype));
-  GeneratorFunction.prototype = GeneratorFunctionPrototype;
-  define(Gp, "constructor", GeneratorFunctionPrototype);
-  define(GeneratorFunctionPrototype, "constructor", GeneratorFunction);
-  GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction");
-
-  // Helper for defining the .next, .throw, and .return methods of the
-  // Iterator interface in terms of a single ._invoke method.
-  function defineIteratorMethods(prototype) {
-    ["next", "throw", "return"].forEach(function (method) {
-      define(prototype, method, function (arg) {
-        return this._invoke(method, arg);
-      });
-    });
-  }
-
-  exports.isGeneratorFunction = function (genFun) {
-    var ctor = typeof genFun === "function" && genFun.constructor;
-    return ctor
-      ? ctor === GeneratorFunction ||
-          // For the native GeneratorFunction constructor, the best we can
-          // do is to check its .name property.
-          (ctor.displayName || ctor.name) === "GeneratorFunction"
-      : false;
-  };
-
-  exports.mark = function (genFun) {
-    if (Object.setPrototypeOf) {
-      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
-    } else {
-      genFun.__proto__ = GeneratorFunctionPrototype;
-      define(genFun, toStringTagSymbol, "GeneratorFunction");
-    }
-    genFun.prototype = Object.create(Gp);
-    return genFun;
-  };
-
-  // Within the body of any async function, `await x` is transformed to
-  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
-  // `hasOwn.call(value, "__await")` to determine if the yielded value is
-  // meant to be awaited.
-  exports.awrap = function (arg) {
-    return { __await: arg };
-  };
-
-  function AsyncIterator(generator, PromiseImpl) {
-    function invoke(method, arg, resolve, reject) {
-      var record = tryCatch(generator[method], generator, arg);
-      if (record.type === "throw") {
-        reject(record.arg);
-      } else {
-        var result = record.arg;
-        var value = result.value;
-        if (value && typeof value === "object" && hasOwn.call(value, "__await")) {
-          return PromiseImpl.resolve(value.__await).then(
-            function (value) {
-              invoke("next", value, resolve, reject);
-            },
-            function (err) {
-              invoke("throw", err, resolve, reject);
-            },
-          );
-        }
-
-        return PromiseImpl.resolve(value).then(
-          function (unwrapped) {
-            // When a yielded Promise is resolved, its final value becomes
-            // the .value of the Promise<{value,done}> result for the
-            // current iteration.
-            result.value = unwrapped;
-            resolve(result);
-          },
-          function (error) {
-            // If a rejected Promise was yielded, throw the rejection back
-            // into the async generator function so it can be handled there.
-            return invoke("throw", error, resolve, reject);
-          },
-        );
-      }
-    }
-
-    var previousPromise;
-
-    function enqueue(method, arg) {
-      function callInvokeWithMethodAndArg() {
-        return new PromiseImpl(function (resolve, reject) {
-          invoke(method, arg, resolve, reject);
-        });
-      }
-
-      return (previousPromise =
-        // If enqueue has been called before, then we want to wait until
-        // all previous Promises have been resolved before calling invoke,
-        // so that results are always delivered in the correct order. If
-        // enqueue has not been called before, then it is important to
-        // call invoke immediately, without waiting on a callback to fire,
-        // so that the async generator function has the opportunity to do
-        // any necessary setup in a predictable way. This predictability
-        // is why the Promise constructor synchronously invokes its
-        // executor callback, and why async functions synchronously
-        // execute code before the first await. Since we implement simple
-        // async functions in terms of async generators, it is especially
-        // important to get this right, even though it requires care.
-        previousPromise
-          ? previousPromise.then(
-              callInvokeWithMethodAndArg,
-              // Avoid propagating failures to Promises returned by later
-              // invocations of the iterator.
-              callInvokeWithMethodAndArg,
-            )
-          : callInvokeWithMethodAndArg());
-    }
-
-    // Define the unified helper method that is used to implement .next,
-    // .throw, and .return (see defineIteratorMethods).
-    this._invoke = enqueue;
-  }
-
-  defineIteratorMethods(AsyncIterator.prototype);
-  define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
-    return this;
-  });
-  exports.AsyncIterator = AsyncIterator;
-
-  // Note that simple async functions are implemented on top of
-  // AsyncIterator objects; they just return a Promise for the value of
-  // the final result produced by the iterator.
-  exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
-    if (PromiseImpl === void 0) PromiseImpl = Promise;
-
-    var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
-
-    return exports.isGeneratorFunction(outerFn)
-      ? iter // If outerFn is a generator, return the full iterator.
-      : iter.next().then(function (result) {
-          return result.done ? result.value : iter.next();
-        });
-  };
-
-  function makeInvokeMethod(innerFn, self, context) {
-    var state = GenStateSuspendedStart;
-
-    return function invoke(method, arg) {
-      if (state === GenStateExecuting) {
-        throw new Error("Generator is already running");
-      }
-
-      if (state === GenStateCompleted) {
-        if (method === "throw") {
-          throw arg;
-        }
-
-        // Be forgiving, per 25.3.3.3.3 of the spec:
-        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
-        return doneResult();
-      }
-
-      context.method = method;
-      context.arg = arg;
-
-      while (true) {
-        var delegate = context.delegate;
-        if (delegate) {
-          var delegateResult = maybeInvokeDelegate(delegate, context);
-          if (delegateResult) {
-            if (delegateResult === ContinueSentinel) continue;
-            return delegateResult;
-          }
-        }
-
-        if (context.method === "next") {
-          // Setting context._sent for legacy support of Babel's
-          // function.sent implementation.
-          context.sent = context._sent = context.arg;
-        } else if (context.method === "throw") {
-          if (state === GenStateSuspendedStart) {
-            state = GenStateCompleted;
-            throw context.arg;
-          }
-
-          context.dispatchException(context.arg);
-        } else if (context.method === "return") {
-          context.abrupt("return", context.arg);
-        }
-
-        state = GenStateExecuting;
-
-        var record = tryCatch(innerFn, self, context);
-        if (record.type === "normal") {
-          // If an exception is thrown from innerFn, we leave state ===
-          // GenStateExecuting and loop back for another invocation.
-          state = context.done ? GenStateCompleted : GenStateSuspendedYield;
-
-          if (record.arg === ContinueSentinel) {
-            continue;
-          }
-
-          return {
-            value: record.arg,
-            done: context.done,
-          };
-        } else if (record.type === "throw") {
-          state = GenStateCompleted;
-          // Dispatch the exception by looping back around to the
-          // context.dispatchException(context.arg) call above.
-          context.method = "throw";
-          context.arg = record.arg;
-        }
-      }
-    };
-  }
-
-  // Call delegate.iterator[context.method](context.arg) and handle the
-  // result, either by returning a { value, done } result from the
-  // delegate iterator, or by modifying context.method and context.arg,
-  // setting context.delegate to null, and returning the ContinueSentinel.
-  function maybeInvokeDelegate(delegate, context) {
-    var method = delegate.iterator[context.method];
-    if (method === undefined) {
-      // A .throw or .return when the delegate iterator has no .throw
-      // method always terminates the yield* loop.
-      context.delegate = null;
-
-      if (context.method === "throw") {
-        // Note: ["return"] must be used for ES3 parsing compatibility.
-        if (delegate.iterator["return"]) {
-          // If the delegate iterator has a return method, give it a
-          // chance to clean up.
-          context.method = "return";
-          context.arg = undefined;
-          maybeInvokeDelegate(delegate, context);
-
-          if (context.method === "throw") {
-            // If maybeInvokeDelegate(context) changed context.method from
-            // "return" to "throw", let that override the TypeError below.
-            return ContinueSentinel;
-          }
-        }
-
-        context.method = "throw";
-        context.arg = new TypeError("The iterator does not provide a 'throw' method");
-      }
-
-      return ContinueSentinel;
-    }
-
-    var record = tryCatch(method, delegate.iterator, context.arg);
-
-    if (record.type === "throw") {
-      context.method = "throw";
-      context.arg = record.arg;
-      context.delegate = null;
-      return ContinueSentinel;
-    }
-
-    var info = record.arg;
-
-    if (!info) {
-      context.method = "throw";
-      context.arg = new TypeError("iterator result is not an object");
-      context.delegate = null;
-      return ContinueSentinel;
-    }
-
-    if (info.done) {
-      // Assign the result of the finished delegate to the temporary
-      // variable specified by delegate.resultName (see delegateYield).
-      context[delegate.resultName] = info.value;
-
-      // Resume execution at the desired location (see delegateYield).
-      context.next = delegate.nextLoc;
-
-      // If context.method was "throw" but the delegate handled the
-      // exception, let the outer generator proceed normally. If
-      // context.method was "next", forget context.arg since it has been
-      // "consumed" by the delegate iterator. If context.method was
-      // "return", allow the original .return call to continue in the
-      // outer generator.
-      if (context.method !== "return") {
-        context.method = "next";
-        context.arg = undefined;
-      }
-    } else {
-      // Re-yield the result returned by the delegate method.
-      return info;
-    }
-
-    // The delegate iterator is finished, so forget it and continue with
-    // the outer generator.
-    context.delegate = null;
-    return ContinueSentinel;
-  }
-
-  // Define Generator.prototype.{next,throw,return} in terms of the
-  // unified ._invoke helper method.
-  defineIteratorMethods(Gp);
-
-  define(Gp, toStringTagSymbol, "Generator");
-
-  // A Generator should always return itself as the iterator object when the
-  // @@iterator function is called on it. Some browsers' implementations of the
-  // iterator prototype chain incorrectly implement this, causing the Generator
-  // object to not be returned from this call. This ensures that doesn't happen.
-  // See https://github.com/facebook/regenerator/issues/274 for more details.
-  define(Gp, iteratorSymbol, function () {
-    return this;
-  });
-
-  define(Gp, "toString", function () {
-    return "[object Generator]";
-  });
-
-  function pushTryEntry(locs) {
-    var entry = { tryLoc: locs[0] };
-
-    if (1 in locs) {
-      entry.catchLoc = locs[1];
-    }
-
-    if (2 in locs) {
-      entry.finallyLoc = locs[2];
-      entry.afterLoc = locs[3];
-    }
-
-    this.tryEntries.push(entry);
-  }
-
-  function resetTryEntry(entry) {
-    var record = entry.completion || {};
-    record.type = "normal";
-    delete record.arg;
-    entry.completion = record;
-  }
-
-  function Context(tryLocsList) {
-    // The root entry object (effectively a try statement without a catch
-    // or a finally block) gives us a place to store values thrown from
-    // locations where there is no enclosing try statement.
-    this.tryEntries = [{ tryLoc: "root" }];
-    tryLocsList.forEach(pushTryEntry, this);
-    this.reset(true);
-  }
-
-  exports.keys = function (object) {
-    var keys = [];
-    for (var key in object) {
-      keys.push(key);
-    }
-    keys.reverse();
-
-    // Rather than returning an object with a next method, we keep
-    // things simple and return the next function itself.
-    return function next() {
-      while (keys.length) {
-        var key = keys.pop();
-        if (key in object) {
-          next.value = key;
-          next.done = false;
-          return next;
-        }
-      }
-
-      // To avoid creating an additional object, we just hang the .value
-      // and .done properties off the next function object itself. This
-      // also ensures that the minifier will not anonymize the function.
-      next.done = true;
-      return next;
-    };
-  };
-
-  function values(iterable) {
-    if (iterable) {
-      var iteratorMethod = iterable[iteratorSymbol];
-      if (iteratorMethod) {
-        return iteratorMethod.call(iterable);
-      }
-
-      if (typeof iterable.next === "function") {
-        return iterable;
-      }
-
-      if (!isNaN(iterable.length)) {
-        var i = -1,
-          next = function next() {
-            while (++i < iterable.length) {
-              if (hasOwn.call(iterable, i)) {
-                next.value = iterable[i];
-                next.done = false;
-                return next;
-              }
-            }
-
-            next.value = undefined;
-            next.done = true;
-
-            return next;
-          };
-
-        return (next.next = next);
-      }
-    }
-
-    // Return an iterator with no values.
-    return { next: doneResult };
-  }
-  exports.values = values;
-
-  function doneResult() {
-    return { value: undefined, done: true };
-  }
-
-  Context.prototype = {
-    constructor: Context,
-
-    reset: function (skipTempReset) {
-      this.prev = 0;
-      this.next = 0;
-      // Resetting context._sent for legacy support of Babel's
-      // function.sent implementation.
-      this.sent = this._sent = undefined;
-      this.done = false;
-      this.delegate = null;
-
-      this.method = "next";
-      this.arg = undefined;
-
-      this.tryEntries.forEach(resetTryEntry);
-
-      if (!skipTempReset) {
-        for (var name in this) {
-          // Not sure about the optimal order of these conditions:
-          if (name.charAt(0) === "t" && hasOwn.call(this, name) && !isNaN(+name.slice(1))) {
-            this[name] = undefined;
-          }
-        }
-      }
-    },
-
-    stop: function () {
-      this.done = true;
-
-      var rootEntry = this.tryEntries[0];
-      var rootRecord = rootEntry.completion;
-      if (rootRecord.type === "throw") {
-        throw rootRecord.arg;
-      }
-
-      return this.rval;
-    },
-
-    dispatchException: function (exception) {
-      if (this.done) {
-        throw exception;
-      }
-
-      var context = this;
-      function handle(loc, caught) {
-        record.type = "throw";
-        record.arg = exception;
-        context.next = loc;
-
-        if (caught) {
-          // If the dispatched exception was caught by a catch block,
-          // then let that catch block handle the exception normally.
-          context.method = "next";
-          context.arg = undefined;
-        }
-
-        return !!caught;
-      }
-
-      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-        var entry = this.tryEntries[i];
-        var record = entry.completion;
-
-        if (entry.tryLoc === "root") {
-          // Exception thrown outside of any try block that could handle
-          // it, so set the completion value of the entire function to
-          // throw the exception.
-          return handle("end");
-        }
-
-        if (entry.tryLoc <= this.prev) {
-          var hasCatch = hasOwn.call(entry, "catchLoc");
-          var hasFinally = hasOwn.call(entry, "finallyLoc");
-
-          if (hasCatch && hasFinally) {
-            if (this.prev < entry.catchLoc) {
-              return handle(entry.catchLoc, true);
-            } else if (this.prev < entry.finallyLoc) {
-              return handle(entry.finallyLoc);
-            }
-          } else if (hasCatch) {
-            if (this.prev < entry.catchLoc) {
-              return handle(entry.catchLoc, true);
-            }
-          } else if (hasFinally) {
-            if (this.prev < entry.finallyLoc) {
-              return handle(entry.finallyLoc);
-            }
-          } else {
-            throw new Error("try statement without catch or finally");
-          }
-        }
-      }
-    },
-
-    abrupt: function (type, arg) {
-      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-        var entry = this.tryEntries[i];
-        if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
-          var finallyEntry = entry;
-          break;
-        }
-      }
-
-      if (
-        finallyEntry &&
-        (type === "break" || type === "continue") &&
-        finallyEntry.tryLoc <= arg &&
-        arg <= finallyEntry.finallyLoc
-      ) {
-        // Ignore the finally entry if control is not jumping to a
-        // location outside the try/catch block.
-        finallyEntry = null;
-      }
-
-      var record = finallyEntry ? finallyEntry.completion : {};
-      record.type = type;
-      record.arg = arg;
-
-      if (finallyEntry) {
-        this.method = "next";
-        this.next = finallyEntry.finallyLoc;
-        return ContinueSentinel;
-      }
-
-      return this.complete(record);
-    },
-
-    complete: function (record, afterLoc) {
-      if (record.type === "throw") {
-        throw record.arg;
-      }
-
-      if (record.type === "break" || record.type === "continue") {
-        this.next = record.arg;
-      } else if (record.type === "return") {
-        this.rval = this.arg = record.arg;
-        this.method = "return";
-        this.next = "end";
-      } else if (record.type === "normal" && afterLoc) {
-        this.next = afterLoc;
-      }
-
-      return ContinueSentinel;
-    },
-
-    finish: function (finallyLoc) {
-      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-        var entry = this.tryEntries[i];
-        if (entry.finallyLoc === finallyLoc) {
-          this.complete(entry.completion, entry.afterLoc);
-          resetTryEntry(entry);
-          return ContinueSentinel;
-        }
-      }
-    },
-
-    catch: function (tryLoc) {
-      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-        var entry = this.tryEntries[i];
-        if (entry.tryLoc === tryLoc) {
-          var record = entry.completion;
-          if (record.type === "throw") {
-            var thrown = record.arg;
-            resetTryEntry(entry);
-          }
-          return thrown;
-        }
-      }
-
-      // The context.catch method must only be called with a location
-      // argument that corresponds to a known catch block.
-      throw new Error("illegal catch attempt");
-    },
-
-    delegateYield: function (iterable, resultName, nextLoc) {
-      this.delegate = {
-        iterator: values(iterable),
-        resultName: resultName,
-        nextLoc: nextLoc,
-      };
-
-      if (this.method === "next") {
-        // Deliberately forget the last sent value so that we don't
-        // accidentally pass it on to the delegate.
-        this.arg = undefined;
-      }
-
-      return ContinueSentinel;
-    },
-  };
-
-  // Regardless of whether this script is executing as a CommonJS module
-  // or not, return the runtime object so that we can declare the variable
-  // regeneratorRuntime in the outer scope, which allows this module to be
-  // injected easily by `bin/regenerator --include-runtime script.js`.
-  return exports;
-})(
-  // If this script is executing as a CommonJS module, use module.exports
-  // as the regeneratorRuntime namespace. Otherwise create a new empty
-  // object. Either way, the resulting object will be used to initialize
-  // the regeneratorRuntime variable at the top of this file.
-  typeof module === "object" ? module.exports : {},
-);
-
-try {
-  regeneratorRuntime = runtime;
-} catch (accidentalStrictMode) {
-  // This module should not be running in strict mode, so the above
-  // assignment should always work unless something is misconfigured. Just
-  // in case runtime.js accidentally runs in strict mode, in modern engines
-  // we can explicitly access globalThis. In older engines we can escape
-  // strict mode using a global Function call. This could conceivably fail
-  // if a Content Security Policy forbids using Function, but in that case
-  // the proper solution is to fix the accidental strict mode problem. If
-  // you've misconfigured your bundler to force strict mode and applied a
-  // CSP to forbid Function, and you're not willing to fix either of those
-  // problems, please detail your unique predicament in a GitHub issue.
-  if (typeof globalThis === "object") {
-    globalThis.regeneratorRuntime = runtime;
-  } else {
-    Function("r", "regeneratorRuntime = r")(runtime);
-  }
-}
diff --git a/src/shell/braces.zig b/src/shell/braces.zig
index e8da1aa7bd..26ccec354f 100644
--- a/src/shell/braces.zig
+++ b/src/shell/braces.zig
@@ -159,7 +159,7 @@ pub fn expand(
     tokens: []Token,
     out: []std.ArrayList(u8),
     contains_nested: bool,
-) !void {
+) (error{ StackFull, StackEmpty } || ParserError)!void {
     var out_key_counter: u16 = 1;
     if (!contains_nested) {
         var expansions_table = try buildExpansionTableAlloc(allocator, tokens);
@@ -325,7 +325,7 @@ pub fn calculateVariantsAmount(tokens: []const Token) u32 {
     return count;
 }
 
-const ParserError = error{
+const ParserError = bun.OOM || error{
     UnexpectedToken,
 };
 
@@ -361,7 +361,7 @@ pub const Parser = struct {
         }
     }
 
-    fn parseAtom(self: *Parser) anyerror!?AST.Atom {
+    fn parseAtom(self: *Parser) ParserError!?AST.Atom {
         switch (self.advance()) {
             .open => {
                 const expansion_ptr = try self.parseExpansion();
diff --git a/src/shell/interpreter.zig b/src/shell/interpreter.zig
index dcf6ccb95f..ec729b3da6 100644
--- a/src/shell/interpreter.zig
+++ b/src/shell/interpreter.zig
@@ -703,25 +703,24 @@ pub const ParsedShellScript = struct {
         bun.destroy(this);
     }
 
-    pub fn setCwd(this: *ParsedShellScript, globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
-        const arguments_ = callframe.arguments(2);
+    pub fn setCwd(this: *ParsedShellScript, globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+        const arguments_ = callframe.arguments_old(2);
         var arguments = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments_.slice());
         const str_js = arguments.nextEat() orelse {
-            globalThis.throw("$`...`.cwd(): expected a string argument", .{});
-            return .undefined;
+            return globalThis.throw("$`...`.cwd(): expected a string argument", .{});
         };
         const str = bun.String.fromJS(str_js, globalThis);
         this.cwd = str;
         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: {
@@ -732,8 +731,7 @@ pub const ParsedShellScript = struct {
 
         const value1 = callframe.argument(0);
         if (!value1.isObject()) {
-            globalThis.throwInvalidArguments("env must be an object", .{});
-            return .undefined;
+            return globalThis.throwInvalidArguments("env must be an object", .{});
         }
 
         var object_iter = JSC.JSPropertyIterator(.{
@@ -765,27 +763,20 @@ 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_ = callframe.arguments_old(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];
         var template_args = template_args_js.arrayIterator(globalThis);
 
         var stack_alloc = std.heap.stackFallback(@sizeOf(bun.String) * 4, shargs.arena_allocator());
-        var jsstrings = std.ArrayList(bun.String).initCapacity(stack_alloc.get(), 4) catch {
-            globalThis.throwOutOfMemory();
-            return .undefined;
-        };
+        var jsstrings = try std.ArrayList(bun.String).initCapacity(stack_alloc.get(), 4);
         defer {
             for (jsstrings.items[0..]) |bunstr| {
                 bunstr.deref();
@@ -794,12 +785,7 @@ pub const ParsedShellScript = struct {
         }
         var jsobjs = std.ArrayList(JSValue).init(shargs.arena_allocator());
         var script = std.ArrayList(u8).init(shargs.arena_allocator());
-        if (!(bun.shell.shellCmdFromJS(globalThis, string_args, &template_args, &jsobjs, &jsstrings, &script) catch {
-            globalThis.throwOutOfMemory();
-            return .undefined;
-        })) {
-            return .undefined;
-        }
+        try bun.shell.shellCmdFromJS(globalThis, string_args, &template_args, &jsobjs, &jsstrings, &script);
 
         var parser: ?bun.shell.Parser = null;
         var lex_result: ?shell.LexResult = null;
@@ -814,8 +800,7 @@ pub const ParsedShellScript = struct {
             if (err == shell.ParseError.Lex) {
                 assert(lex_result != null);
                 const str = lex_result.?.combineErrors(shargs.arena_allocator());
-                globalThis.throwPretty("{s}", .{str});
-                return .undefined;
+                return globalThis.throwPretty("{s}", .{str});
             }
 
             if (parser) |*p| {
@@ -823,12 +808,10 @@ pub const ParsedShellScript = struct {
                     assert(p.errors.items.len > 0);
                 }
                 const errstr = p.combineErrors();
-                globalThis.throwPretty("{s}", .{errstr});
-                return .undefined;
+                return globalThis.throwPretty("{s}", .{errstr});
             }
 
-            globalThis.throwError(err, "failed to lex/parse shell");
-            return .undefined;
+            return globalThis.throwError(err, "failed to lex/parse shell");
         };
 
         shargs.script_ast = script_ast;
@@ -1185,33 +1168,18 @@ pub const Interpreter = struct {
         }
     };
 
-    pub fn createShellInterpreter(
-        globalThis: *JSC.JSGlobalObject,
-        callframe: *JSC.CallFrame,
-    ) JSValue {
+    pub fn createShellInterpreter(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
         const allocator = bun.default_allocator;
-        const arguments_ = callframe.arguments(3);
+        const arguments_ = callframe.arguments_old(3);
         var arguments = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments_.slice());
 
-        const resolve = arguments.nextEat() orelse {
-            globalThis.throw("shell: expected 3 arguments, got 0", .{});
-            return .undefined;
-        };
+        const resolve = arguments.nextEat() orelse return globalThis.throw("shell: expected 3 arguments, got 0", .{});
 
-        const reject = arguments.nextEat() orelse {
-            globalThis.throw("shell: expected 3 arguments, got 0", .{});
-            return .undefined;
-        };
+        const reject = arguments.nextEat() orelse return globalThis.throw("shell: expected 3 arguments, got 0", .{});
 
-        const parsed_shell_script_js = arguments.nextEat() orelse {
-            globalThis.throw("shell: expected 3 arguments, got 0", .{});
-            return .undefined;
-        };
+        const parsed_shell_script_js = arguments.nextEat() orelse return globalThis.throw("shell: expected 3 arguments, got 0", .{});
 
-        const parsed_shell_script = parsed_shell_script_js.as(ParsedShellScript) orelse {
-            globalThis.throw("shell: expected a ParsedShellScript", .{});
-            return .undefined;
-        };
+        const parsed_shell_script = parsed_shell_script_js.as(ParsedShellScript) orelse return globalThis.throw("shell: expected a ParsedShellScript", .{});
 
         var shargs: *ShellArgs = undefined;
         var jsobjs: std.ArrayList(JSValue) = std.ArrayList(JSValue).init(allocator);
@@ -1219,10 +1187,7 @@ pub const Interpreter = struct {
         var cwd: ?bun.String = null;
         var export_env: ?EnvMap = null;
 
-        if (parsed_shell_script.args == null) {
-            globalThis.throw("shell: shell args is null, this is a bug in Bun. Please file a GitHub issue.", .{});
-            return .undefined;
-        }
+        if (parsed_shell_script.args == null) return globalThis.throw("shell: shell args is null, this is a bug in Bun. Please file a GitHub issue.", .{});
 
         parsed_shell_script.take(
             globalThis,
@@ -1253,8 +1218,7 @@ pub const Interpreter = struct {
                 if (export_env) |*ee| ee.deinit();
                 if (cwd) |*cc| cc.deref();
                 shargs.deinit();
-                throwShellErr(e, .{ .js = globalThis.bunVM().event_loop });
-                return .zero;
+                return try throwShellErr(e, .{ .js = globalThis.bunVM().event_loop });
             },
         };
 
@@ -1264,7 +1228,7 @@ pub const Interpreter = struct {
             if (cwd) |*cc| cc.deref();
             shargs.deinit();
             interpreter.finalize();
-            return .zero;
+            return error.JSError;
         }
 
         interpreter.flags.quiet = quiet;
@@ -1477,8 +1441,7 @@ pub const Interpreter = struct {
             null,
         )) {
             .err => |*e| {
-                throwShellErr(e, .{ .mini = mini });
-                return 1;
+                e.throwMini();
             },
             .result => |i| i,
         };
@@ -1547,8 +1510,7 @@ pub const Interpreter = struct {
             null,
         )) {
             .err => |*e| {
-                throwShellErr(e, .{ .mini = mini });
-                return 1;
+                e.throwMini();
             },
             .result => |i| i,
         };
@@ -1642,20 +1604,20 @@ 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| {
             defer this.deinitEverything();
             const shellerr = bun.shell.ShellErr.newSys(e);
-            throwShellErr(&shellerr, .{ .js = globalThis.bunVM().event_loop });
-            return .undefined;
+            return try throwShellErr(&shellerr, .{ .js = globalThis.bunVM().event_loop });
         }
         incrPendingActivityFlag(&this.has_pending_activity);
 
         var root = Script.init(this, &this.root_shell, &this.args.script_ast, Script.ParentPtr.init(this), this.root_io.copy());
         this.started.store(true, .seq_cst);
         root.start();
+        if (globalThis.hasException()) return error.JSError;
 
         return .undefined;
     }
@@ -1786,13 +1748,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);
 
@@ -1800,19 +1762,17 @@ pub const Interpreter = struct {
         defer slice.deinit();
         switch (this.root_shell.changeCwd(this, slice.slice())) {
             .err => |e| {
-                globalThis.throwValue(e.toJSC(globalThis));
-                return .undefined;
+                return globalThis.throwValue(e.toJSC(globalThis));
             },
             .result => {},
         }
         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", .{});
-            return .undefined;
+            return globalThis.throwInvalidArguments("env must be an object", .{});
         }
 
         var object_iter = JSC.JSPropertyIterator(.{
@@ -1849,7 +1809,7 @@ pub const Interpreter = struct {
         this: *ThisInterpreter,
         globalThis: *JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         _ = globalThis; // autofix
         _ = callframe; // autofix
 
@@ -1860,7 +1820,7 @@ pub const Interpreter = struct {
         this: *ThisInterpreter,
         globalThis: *JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         _ = globalThis; // autofix
         _ = callframe; // autofix
 
@@ -2771,7 +2731,7 @@ pub const Interpreter = struct {
         }
 
         pub fn throw(this: *const State, err: *const bun.shell.ShellErr) void {
-            throwShellErr(err, this.eventLoop());
+            throwShellErr(err, this.eventLoop()) catch {}; //TODO:
         }
 
         pub fn rootIO(this: *const State) *const IO {
@@ -4987,23 +4947,11 @@ pub const Interpreter = struct {
                         } else if (this.base.interpreter.jsobjs[val.idx].as(JSC.WebCore.Blob)) |blob__| {
                             const blob = blob__.dupe();
                             if (this.node.redirect.stdin) {
-                                if (!spawn_args.stdio[stdin_no].extractBlob(global, .{
-                                    .Blob = blob,
-                                }, stdin_no)) {
-                                    return;
-                                }
+                                spawn_args.stdio[stdin_no].extractBlob(global, .{ .Blob = blob }, stdin_no) catch return;
                             } else if (this.node.redirect.stdout) {
-                                if (!spawn_args.stdio[stdin_no].extractBlob(global, .{
-                                    .Blob = blob,
-                                }, stdout_no)) {
-                                    return;
-                                }
+                                spawn_args.stdio[stdin_no].extractBlob(global, .{ .Blob = blob }, stdout_no) catch return;
                             } else if (this.node.redirect.stderr) {
-                                if (!spawn_args.stdio[stdin_no].extractBlob(global, .{
-                                    .Blob = blob,
-                                }, stderr_no)) {
-                                    return;
-                                }
+                                spawn_args.stdio[stdin_no].extractBlob(global, .{ .Blob = blob }, stderr_no) catch return;
                             }
                         } else if (JSC.WebCore.ReadableStream.fromJS(this.base.interpreter.jsobjs[val.idx], global)) |rstream| {
                             _ = rstream;
@@ -5011,26 +4959,17 @@ pub const Interpreter = struct {
                         } else if (this.base.interpreter.jsobjs[val.idx].as(JSC.WebCore.Response)) |req| {
                             req.getBodyValue().toBlobIfPossible();
                             if (this.node.redirect.stdin) {
-                                if (!spawn_args.stdio[stdin_no].extractBlob(global, req.getBodyValue().useAsAnyBlob(), stdin_no)) {
-                                    return;
-                                }
+                                spawn_args.stdio[stdin_no].extractBlob(global, req.getBodyValue().useAsAnyBlob(), stdin_no) catch return;
                             }
                             if (this.node.redirect.stdout) {
-                                if (!spawn_args.stdio[stdout_no].extractBlob(global, req.getBodyValue().useAsAnyBlob(), stdout_no)) {
-                                    return;
-                                }
+                                spawn_args.stdio[stdout_no].extractBlob(global, req.getBodyValue().useAsAnyBlob(), stdout_no) catch return;
                             }
                             if (this.node.redirect.stderr) {
-                                if (!spawn_args.stdio[stderr_no].extractBlob(global, req.getBodyValue().useAsAnyBlob(), stderr_no)) {
-                                    return;
-                                }
+                                spawn_args.stdio[stderr_no].extractBlob(global, req.getBodyValue().useAsAnyBlob(), stderr_no) catch return;
                             }
                         } else {
                             const jsval = this.base.interpreter.jsobjs[val.idx];
-                            global.throw(
-                                "Unknown JS value used in shell: {}",
-                                .{jsval.fmtString(global)},
-                            );
+                            global.throw("Unknown JS value used in shell: {}", .{jsval.fmtString(global)}) catch {}; // TODO: propagate
                             return;
                         }
                     },
@@ -5679,7 +5618,7 @@ pub const Interpreter = struct {
                         } else if (interpreter.jsobjs[file.jsbuf.idx].as(JSC.WebCore.Body.Value)) |body| {
                             if ((node.redirect.stdout or node.redirect.stderr) and !(body.* == .Blob and !body.Blob.needsToReadFile())) {
                                 // TODO: Locked->stream -> file -> blob conversion via .toBlobIfPossible() except we want to avoid modifying the Response/Request if unnecessary.
-                                cmd.base.interpreter.event_loop.js.global.throw("Cannot redirect stdout/stderr to an immutable blob. Expected a file", .{});
+                                cmd.base.interpreter.event_loop.js.global.throw("Cannot redirect stdout/stderr to an immutable blob. Expected a file", .{}) catch {};
                                 return .yield;
                             }
 
@@ -5707,7 +5646,7 @@ pub const Interpreter = struct {
                         } else if (interpreter.jsobjs[file.jsbuf.idx].as(JSC.WebCore.Blob)) |blob| {
                             if ((node.redirect.stdout or node.redirect.stderr) and !blob.needsToReadFile()) {
                                 // TODO: Locked->stream -> file -> blob conversion via .toBlobIfPossible() except we want to avoid modifying the Response/Request if unnecessary.
-                                cmd.base.interpreter.event_loop.js.global.throw("Cannot redirect stdout/stderr to an immutable blob. Expected a file", .{});
+                                cmd.base.interpreter.event_loop.js.global.throw("Cannot redirect stdout/stderr to an immutable blob. Expected a file", .{}) catch {};
                                 return .yield;
                             }
 
@@ -5725,7 +5664,7 @@ pub const Interpreter = struct {
                             }
                         } else {
                             const jsval = cmd.base.interpreter.jsobjs[val.idx];
-                            cmd.base.interpreter.event_loop.js.global.throw("Unknown JS value used in shell: {}", .{jsval.fmtString(globalObject)});
+                            cmd.base.interpreter.event_loop.js.global.throw("Unknown JS value used in shell: {}", .{jsval.fmtString(globalObject)}) catch {};
                             return .yield;
                         }
                     },
@@ -5750,7 +5689,7 @@ pub const Interpreter = struct {
         }
 
         pub inline fn throw(this: *const Builtin, err: *const bun.shell.ShellErr) void {
-            this.parentCmd().base.throw(err);
+            this.parentCmd().base.throw(err) catch {};
         }
 
         pub inline fn parentCmd(this: *const Builtin) *const Cmd {
@@ -12156,7 +12095,7 @@ pub fn ShellTask(
     /// Function that is called on the main thread, once the event loop
     /// processes that the task is done
     comptime runFromMainThread_: fn (*Ctx) void,
-    comptime debug: fn (comptime fmt: []const u8, args: anytype) void,
+    comptime debug: bun.Output.LogFunction,
 ) type {
     return struct {
         task: WorkPoolTask = .{ .callback = &runFromThreadPool },
@@ -12221,11 +12160,13 @@ inline fn fastMod(val: anytype, comptime rhs: comptime_int) @TypeOf(val) {
     return val & (rhs - 1);
 }
 
-fn throwShellErr(e: *const bun.shell.ShellErr, event_loop: JSC.EventLoopHandle) void {
-    switch (event_loop) {
+/// 'js' event loop will always return JSError
+/// 'mini' event loop will always return noreturn and exit 1
+fn throwShellErr(e: *const bun.shell.ShellErr, event_loop: JSC.EventLoopHandle) bun.JSError!noreturn {
+    return switch (event_loop) {
         .mini => e.throwMini(),
         .js => e.throwJS(event_loop.js.global),
-    }
+    };
 }
 
 pub const ReadChunkAction = enum {
diff --git a/src/shell/shell.zig b/src/shell/shell.zig
index 71ce407d9e..a475cdd763 100644
--- a/src/shell/shell.zig
+++ b/src/shell/shell.zig
@@ -83,30 +83,30 @@ pub const ShellErr = union(enum) {
         }
     }
 
-    pub fn throwJS(this: *const @This(), globalThis: *JSC.JSGlobalObject) void {
+    pub fn throwJS(this: *const @This(), globalThis: *JSC.JSGlobalObject) bun.JSError {
         defer this.deinit(bun.default_allocator);
         switch (this.*) {
             .sys => {
                 const err = this.sys.toErrorInstance(globalThis);
-                globalThis.throwValue(err);
+                return globalThis.throwValue(err);
             },
             .custom => {
                 var str = JSC.ZigString.init(this.custom);
                 str.markUTF8();
                 const err_value = str.toErrorInstance(globalThis);
-                globalThis.throwValue(err_value);
+                return globalThis.throwValue(err_value);
                 // this.bunVM().allocator.free(JSC.ZigString.untagged(str._unsafe_ptr_do_not_use)[0..str.len]);
             },
             .invalid_arguments => {
-                globalThis.throwInvalidArguments("{s}", .{this.invalid_arguments.val});
+                return globalThis.throwInvalidArguments("{s}", .{this.invalid_arguments.val});
             },
             .todo => {
-                globalThis.throwTODO(this.todo);
+                return globalThis.throwTODO(this.todo);
             },
         }
     }
 
-    pub fn throwMini(this: @This()) void {
+    pub fn throwMini(this: @This()) noreturn {
         defer this.deinit(bun.default_allocator);
         switch (this) {
             .sys => |err| {
@@ -3747,7 +3747,7 @@ pub fn shellCmdFromJS(
     out_jsobjs: *std.ArrayList(JSValue),
     jsstrings: *std.ArrayList(bun.String),
     out_script: *std.ArrayList(u8),
-) !bool {
+) bun.JSError!void {
     var builder = ShellSrcBuilder.init(globalThis, out_script, jsstrings);
     var jsobjref_buf: [128]u8 = [_]u8{0} ** 128;
 
@@ -3757,20 +3757,18 @@ pub fn shellCmdFromJS(
     while (string_iter.next()) |js_value| {
         defer i += 1;
         if (!try builder.appendJSValueStr(js_value, false)) {
-            globalThis.throw("Shell script string contains invalid UTF-16", .{});
-            return false;
+            return globalThis.throw("Shell script string contains invalid UTF-16", .{});
         }
         // const str = js_value.getZigString(globalThis);
         // try script.appendSlice(str.full());
         if (i < last) {
             const template_value = template_args.next() orelse {
-                globalThis.throw("Shell script is missing JSValue arg", .{});
-                return false;
+                return globalThis.throw("Shell script is missing JSValue arg", .{});
             };
-            if (!(try handleTemplateValue(globalThis, template_value, out_jsobjs, out_script, jsstrings, jsobjref_buf[0..]))) return false;
+            try handleTemplateValue(globalThis, template_value, out_jsobjs, out_script, jsstrings, jsobjref_buf[0..]);
         }
     }
-    return true;
+    return;
 }
 
 pub fn handleTemplateValue(
@@ -3780,17 +3778,17 @@ pub fn handleTemplateValue(
     out_script: *std.ArrayList(u8),
     jsstrings: *std.ArrayList(bun.String),
     jsobjref_buf: []u8,
-) !bool {
+) bun.JSError!void {
     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;
             template_value.protect();
             try out_jsobjs.append(template_value);
-            const slice = try std.fmt.bufPrint(jsobjref_buf[0..], "{s}{d}", .{ LEX_JS_OBJREF_PREFIX, idx });
+            const slice = std.fmt.bufPrint(jsobjref_buf[0..], "{s}{d}", .{ LEX_JS_OBJREF_PREFIX, idx }) catch return globalThis.throwOutOfMemory();
             try out_script.appendSlice(slice);
-            return true;
+            return;
         }
 
         if (template_value.as(JSC.WebCore.Blob)) |blob| {
@@ -3799,10 +3797,9 @@ pub fn handleTemplateValue(
                     if (store.data.file.pathlike == .path) {
                         const path = store.data.file.pathlike.path.slice();
                         if (!try builder.appendUTF8(path, true)) {
-                            globalThis.throw("Shell script string contains invalid UTF-16", .{});
-                            return false;
+                            return globalThis.throw("Shell script string contains invalid UTF-16", .{});
                         }
-                        return true;
+                        return;
                     }
                 }
             }
@@ -3810,9 +3807,9 @@ pub fn handleTemplateValue(
             const idx = out_jsobjs.items.len;
             template_value.protect();
             try out_jsobjs.append(template_value);
-            const slice = try std.fmt.bufPrint(jsobjref_buf[0..], "{s}{d}", .{ LEX_JS_OBJREF_PREFIX, idx });
+            const slice = std.fmt.bufPrint(jsobjref_buf[0..], "{s}{d}", .{ LEX_JS_OBJREF_PREFIX, idx }) catch return globalThis.throwOutOfMemory();
             try out_script.appendSlice(slice);
-            return true;
+            return;
         }
 
         if (JSC.WebCore.ReadableStream.fromJS(template_value, globalThis)) |rstream| {
@@ -3821,9 +3818,9 @@ pub fn handleTemplateValue(
             const idx = out_jsobjs.items.len;
             template_value.protect();
             try out_jsobjs.append(template_value);
-            const slice = try std.fmt.bufPrint(jsobjref_buf[0..], "{s}{d}", .{ LEX_JS_OBJREF_PREFIX, idx });
+            const slice = std.fmt.bufPrint(jsobjref_buf[0..], "{s}{d}", .{ LEX_JS_OBJREF_PREFIX, idx }) catch return globalThis.throwOutOfMemory();
             try out_script.appendSlice(slice);
-            return true;
+            return;
         }
 
         if (template_value.as(JSC.WebCore.Response)) |req| {
@@ -3832,17 +3829,16 @@ pub fn handleTemplateValue(
             const idx = out_jsobjs.items.len;
             template_value.protect();
             try out_jsobjs.append(template_value);
-            const slice = try std.fmt.bufPrint(jsobjref_buf[0..], "{s}{d}", .{ LEX_JS_OBJREF_PREFIX, idx });
+            const slice = std.fmt.bufPrint(jsobjref_buf[0..], "{s}{d}", .{ LEX_JS_OBJREF_PREFIX, idx }) catch return globalThis.throwOutOfMemory();
             try out_script.appendSlice(slice);
-            return true;
+            return;
         }
 
         if (template_value.isString()) {
             if (!try builder.appendJSValueStr(template_value, true)) {
-                globalThis.throw("Shell script string contains invalid UTF-16", .{});
-                return false;
+                return globalThis.throw("Shell script string contains invalid UTF-16", .{});
             }
-            return true;
+            return;
         }
 
         if (template_value.jsType().isArray()) {
@@ -3850,13 +3846,15 @@ pub fn handleTemplateValue(
             const last = array.len -| 1;
             var i: u32 = 0;
             while (array.next()) |arr| : (i += 1) {
-                if (!(try handleTemplateValue(globalThis, arr, out_jsobjs, out_script, jsstrings, jsobjref_buf))) return false;
+                try handleTemplateValue(globalThis, arr, out_jsobjs, out_script, jsstrings, jsobjref_buf);
                 if (i < last) {
                     const str = bun.String.static(" ");
-                    if (!try builder.appendBunStr(str, false)) return false;
+                    if (!try builder.appendBunStr(str, false)) {
+                        return globalThis.throw("Shell script string contains invalid UTF-16", .{});
+                    }
                 }
             }
-            return true;
+            return;
         }
 
         if (template_value.isObject()) {
@@ -3864,34 +3862,30 @@ pub fn handleTemplateValue(
                 const bunstr = maybe_str.toBunString(globalThis);
                 defer bunstr.deref();
                 if (!try builder.appendBunStr(bunstr, false)) {
-                    globalThis.throw("Shell script string contains invalid UTF-16", .{});
-                    return false;
+                    return globalThis.throw("Shell script string contains invalid UTF-16", .{});
                 }
-                return true;
+                return;
             }
         }
 
         if (template_value.isPrimitive()) {
             if (!try builder.appendJSValueStr(template_value, true)) {
-                globalThis.throw("Shell script string contains invalid UTF-16", .{});
-                return false;
+                return globalThis.throw("Shell script string contains invalid UTF-16", .{});
             }
-            return true;
+            return;
         }
 
         if (template_value.implementsToString(globalThis)) {
             if (!try builder.appendJSValueStr(template_value, true)) {
-                globalThis.throw("Shell script string contains invalid UTF-16", .{});
-                return false;
+                return globalThis.throw("Shell script string contains invalid UTF-16", .{});
             }
-            return true;
+            return;
         }
 
-        globalThis.throw("Invalid JS object used in shell: {}, you might need to call `.toString()` on it", .{template_value.fmtString(globalThis)});
-        return false;
+        return globalThis.throw("Invalid JS object used in shell: {}, you might need to call `.toString()` on it", .{template_value.fmtString(globalThis)});
     }
 
-    return true;
+    return;
 }
 
 pub const ShellSrcBuilder = struct {
@@ -3912,7 +3906,7 @@ pub const ShellSrcBuilder = struct {
         };
     }
 
-    pub fn appendJSValueStr(this: *ShellSrcBuilder, jsval: JSValue, comptime allow_escape: bool) !bool {
+    pub fn appendJSValueStr(this: *ShellSrcBuilder, jsval: JSValue, comptime allow_escape: bool) bun.OOM!bool {
         const bunstr = jsval.toBunString(this.globalThis);
         defer bunstr.deref();
 
@@ -3923,7 +3917,7 @@ pub const ShellSrcBuilder = struct {
         this: *ShellSrcBuilder,
         bunstr: bun.String,
         comptime allow_escape: bool,
-    ) !bool {
+    ) bun.OOM!bool {
         const invalid = (bunstr.isUTF16() and !bun.simdutf.validate.utf16le(bunstr.utf16())) or (bunstr.isUTF8() and !bun.simdutf.validate.utf8(bunstr.byteSlice()));
         if (invalid) return false;
         if (allow_escape) {
@@ -3980,7 +3974,7 @@ pub const ShellSrcBuilder = struct {
         this.outbuf.* = try bun.strings.allocateLatin1IntoUTF8WithList(this.outbuf.*, this.outbuf.items.len, []const u8, latin1);
     }
 
-    pub fn appendJSStrRef(this: *ShellSrcBuilder, bunstr: bun.String) !void {
+    pub fn appendJSStrRef(this: *ShellSrcBuilder, bunstr: bun.String) bun.OOM!void {
         const idx = this.jsstrs_to_escape.items.len;
         const str = std.fmt.bufPrint(this.jsstr_ref_buf[0..], "{s}{d}", .{ LEX_JS_STRING_PREFIX, idx }) catch {
             @panic("Impossible");
@@ -4007,20 +4001,17 @@ pub fn assertSpecialChar(c: u8) void {
 /// Characters that need to be backslashed inside double quotes
 const BACKSLASHABLE_CHARS = [_]u8{ '$', '`', '"', '\\' };
 
-pub fn escapeBunStr(bunstr: bun.String, outbuf: *std.ArrayList(u8), comptime add_quotes: bool) !bool {
+pub fn escapeBunStr(bunstr: bun.String, outbuf: *std.ArrayList(u8), comptime add_quotes: bool) bun.OOM!bool {
     if (bunstr.isUTF16()) {
-        return try escapeUtf16(bunstr.utf16(), outbuf, add_quotes);
+        const res = try escapeUtf16(bunstr.utf16(), outbuf, add_quotes);
+        return !res.is_invalid;
     }
-    if (bunstr.isUTF8()) {
-        try escapeWTF8(bunstr.byteSlice(), outbuf, add_quotes);
-        return true;
-    }
-    // otherwise should be latin-1 or ascii
+    // otherwise should be utf-8, latin-1, or ascii
     try escape8Bit(bunstr.byteSlice(), outbuf, add_quotes);
     return true;
 }
 
-/// works for latin-1 and ascii
+/// works for utf-8, latin-1, and ascii
 pub fn escape8Bit(str: []const u8, outbuf: *std.ArrayList(u8), comptime add_quotes: bool) !void {
     try outbuf.ensureUnusedCapacity(str.len);
 
@@ -4042,37 +4033,6 @@ pub fn escape8Bit(str: []const u8, outbuf: *std.ArrayList(u8), comptime add_quot
     if (add_quotes) try outbuf.append('\"');
 }
 
-pub fn escapeWTF8(str: []const u8, outbuf: *std.ArrayList(u8), comptime add_quotes: bool) !void {
-    try outbuf.ensureUnusedCapacity(str.len);
-
-    var bytes: [8]u8 = undefined;
-    var n: u3 = if (add_quotes) bun.strings.encodeWTF8Rune(bytes[0..4], '"') else 0;
-    if (add_quotes) try outbuf.appendSlice(bytes[0..n]);
-
-    loop: for (str) |c| {
-        inline for (BACKSLASHABLE_CHARS) |spc| {
-            if (spc == c) {
-                n = bun.strings.encodeWTF8Rune(bytes[0..4], '\\');
-                var next: [4]u8 = bytes[n..][0..4].*;
-                n += bun.strings.encodeWTF8Rune(&next, @intCast(c));
-                try outbuf.appendSlice(bytes[0..n]);
-                // try outbuf.appendSlice(&.{
-                //     '\\',
-                //     c,
-                // });
-                continue :loop;
-            }
-        }
-        n = bun.strings.encodeWTF8Rune(bytes[0..4], @intCast(c));
-        try outbuf.appendSlice(bytes[0..n]);
-    }
-
-    if (add_quotes) {
-        n = bun.strings.encodeWTF8Rune(bytes[0..4], '"');
-        try outbuf.appendSlice(bytes[0..n]);
-    }
-}
-
 pub fn escapeUtf16(str: []const u16, outbuf: *std.ArrayList(u8), comptime add_quotes: bool) !struct { is_invalid: bool = false } {
     if (add_quotes) try outbuf.append('"');
 
@@ -4347,14 +4307,13 @@ 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);
+        const arguments_ = callframe.arguments_old(1);
         var arguments = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments_.slice());
         const string = arguments.nextEat() orelse {
-            globalThis.throw("shellInternals.disabledOnPosix: expected 1 arguments, got 0", .{});
-            return .undefined;
+            return globalThis.throw("shellInternals.disabledOnPosix: expected 1 arguments, got 0", .{});
         };
 
         const bunstr = string.toBunString(globalThis);
@@ -4373,27 +4332,22 @@ pub const TestingAPIs = struct {
     pub fn shellLex(
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
-        const arguments_ = callframe.arguments(2);
+    ) bun.JSError!JSC.JSValue {
+        const arguments_ = callframe.arguments_old(2);
         var arguments = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments_.slice());
         const string_args = arguments.nextEat() orelse {
-            globalThis.throw("shell_parse: expected 2 arguments, got 0", .{});
-            return .undefined;
+            return globalThis.throw("shell_parse: expected 2 arguments, got 0", .{});
         };
 
         var arena = std.heap.ArenaAllocator.init(bun.default_allocator);
         defer arena.deinit();
 
         const template_args_js = arguments.nextEat() orelse {
-            globalThis.throw("shell: expected 2 arguments, got 0", .{});
-            return .undefined;
+            return globalThis.throw("shell: expected 2 arguments, got 0", .{});
         };
         var template_args = template_args_js.arrayIterator(globalThis);
         var stack_alloc = std.heap.stackFallback(@sizeOf(bun.String) * 4, arena.allocator());
-        var jsstrings = std.ArrayList(bun.String).initCapacity(stack_alloc.get(), 4) catch {
-            globalThis.throwOutOfMemory();
-            return .undefined;
-        };
+        var jsstrings = try std.ArrayList(bun.String).initCapacity(stack_alloc.get(), 4);
         defer {
             for (jsstrings.items[0..]) |bunstr| {
                 bunstr.deref();
@@ -4408,52 +4362,35 @@ pub const TestingAPIs = struct {
         }
 
         var script = std.ArrayList(u8).init(arena.allocator());
-        if (!(shellCmdFromJS(globalThis, string_args, &template_args, &jsobjs, &jsstrings, &script) catch {
-            globalThis.throwOutOfMemory();
-            return JSValue.undefined;
-        })) {
-            return .undefined;
-        }
+        try shellCmdFromJS(globalThis, string_args, &template_args, &jsobjs, &jsstrings, &script);
 
         const lex_result = brk: {
             if (bun.strings.isAllASCII(script.items[0..])) {
                 var lexer = LexerAscii.new(arena.allocator(), script.items[0..], jsstrings.items[0..]);
                 lexer.lex() catch |err| {
-                    globalThis.throwError(err, "failed to lex shell");
-                    return JSValue.undefined;
+                    return globalThis.throwError(err, "failed to lex shell");
                 };
                 break :brk lexer.get_result();
             }
             var lexer = LexerUnicode.new(arena.allocator(), script.items[0..], jsstrings.items[0..]);
             lexer.lex() catch |err| {
-                globalThis.throwError(err, "failed to lex shell");
-                return JSValue.undefined;
+                return globalThis.throwError(err, "failed to lex shell");
             };
             break :brk lexer.get_result();
         };
 
         if (lex_result.errors.len > 0) {
             const str = lex_result.combineErrors(arena.allocator());
-            globalThis.throwPretty("{s}", .{str});
-            return .undefined;
+            return globalThis.throwPretty("{s}", .{str});
         }
 
-        var test_tokens = std.ArrayList(Test.TestToken).initCapacity(arena.allocator(), lex_result.tokens.len) catch {
-            globalThis.throwOutOfMemory();
-            return JSValue.undefined;
-        };
+        var test_tokens = try std.ArrayList(Test.TestToken).initCapacity(arena.allocator(), lex_result.tokens.len);
         for (lex_result.tokens) |tok| {
             const test_tok = Test.TestToken.from_real(tok, lex_result.strpool);
-            test_tokens.append(test_tok) catch {
-                globalThis.throwOutOfMemory();
-                return JSValue.undefined;
-            };
+            try test_tokens.append(test_tok);
         }
 
-        const str = std.json.stringifyAlloc(globalThis.bunVM().allocator, test_tokens.items[0..], .{}) catch {
-            globalThis.throwOutOfMemory();
-            return JSValue.undefined;
-        };
+        const str = try std.json.stringifyAlloc(globalThis.bunVM().allocator, test_tokens.items[0..], .{});
 
         defer globalThis.bunVM().allocator.free(str);
         var bun_str = bun.String.fromBytes(str);
@@ -4463,27 +4400,22 @@ pub const TestingAPIs = struct {
     pub fn shellParse(
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
-        const arguments_ = callframe.arguments(2);
+    ) bun.JSError!JSC.JSValue {
+        const arguments_ = callframe.arguments_old(2);
         var arguments = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments_.slice());
         const string_args = arguments.nextEat() orelse {
-            globalThis.throw("shell_parse: expected 2 arguments, got 0", .{});
-            return .undefined;
+            return globalThis.throw("shell_parse: expected 2 arguments, got 0", .{});
         };
 
         var arena = bun.ArenaAllocator.init(bun.default_allocator);
         defer arena.deinit();
 
         const template_args_js = arguments.nextEat() orelse {
-            globalThis.throw("shell: expected 2 arguments, got 0", .{});
-            return .undefined;
+            return globalThis.throw("shell: expected 2 arguments, got 0", .{});
         };
         var template_args = template_args_js.arrayIterator(globalThis);
         var stack_alloc = std.heap.stackFallback(@sizeOf(bun.String) * 4, arena.allocator());
-        var jsstrings = std.ArrayList(bun.String).initCapacity(stack_alloc.get(), 4) catch {
-            globalThis.throwOutOfMemory();
-            return .undefined;
-        };
+        var jsstrings = try std.ArrayList(bun.String).initCapacity(stack_alloc.get(), 4);
         defer {
             for (jsstrings.items[0..]) |bunstr| {
                 bunstr.deref();
@@ -4497,12 +4429,7 @@ pub const TestingAPIs = struct {
             }
         }
         var script = std.ArrayList(u8).init(arena.allocator());
-        if (!(shellCmdFromJS(globalThis, string_args, &template_args, &jsobjs, &jsstrings, &script) catch {
-            globalThis.throwOutOfMemory();
-            return JSValue.undefined;
-        })) {
-            return .undefined;
-        }
+        try shellCmdFromJS(globalThis, string_args, &template_args, &jsobjs, &jsstrings, &script);
 
         var out_parser: ?Parser = null;
         var out_lex_result: ?LexResult = null;
@@ -4511,24 +4438,18 @@ pub const TestingAPIs = struct {
             if (err == ParseError.Lex) {
                 if (bun.Environment.allow_assert) assert(out_lex_result != null);
                 const str = out_lex_result.?.combineErrors(arena.allocator());
-                globalThis.throwPretty("{s}", .{str});
-                return .undefined;
+                return globalThis.throwPretty("{s}", .{str});
             }
 
             if (out_parser) |*p| {
                 const errstr = p.combineErrors();
-                globalThis.throwPretty("{s}", .{errstr});
-                return .undefined;
+                return globalThis.throwPretty("{s}", .{errstr});
             }
 
-            globalThis.throwError(err, "failed to lex/parse shell");
-            return .undefined;
+            return globalThis.throwError(err, "failed to lex/parse shell");
         };
 
-        const str = std.json.stringifyAlloc(globalThis.bunVM().allocator, script_ast, .{}) catch {
-            globalThis.throwOutOfMemory();
-            return JSValue.undefined;
-        };
+        const str = try std.json.stringifyAlloc(globalThis.bunVM().allocator, script_ast, .{});
 
         defer globalThis.bunVM().allocator.free(str);
         var bun_str = bun.String.fromBytes(str);
diff --git a/src/sourcemap/CodeCoverage.zig b/src/sourcemap/CodeCoverage.zig
index eb3b4e0343..eeb3411285 100644
--- a/src/sourcemap/CodeCoverage.zig
+++ b/src/sourcemap/CodeCoverage.zig
@@ -673,8 +673,7 @@ pub const ByteRangeMapping = struct {
         var url_slice = source_url.toUTF8(bun.default_allocator);
         defer url_slice.deinit();
         var report = this.generateReportFromBlocks(bun.default_allocator, url_slice, blocks, function_blocks, ignore_sourcemap) catch {
-            globalThis.throwOutOfMemory();
-            return .zero;
+            return globalThis.throwOutOfMemoryValue();
         };
         defer report.deinit(bun.default_allocator);
 
@@ -686,18 +685,15 @@ pub const ByteRangeMapping = struct {
         var writer = buffered_writer.writer();
 
         CodeCoverageReport.Text.writeFormat(&report, source_url.utf8ByteLength(), &coverage_fraction, "", &writer, false) catch {
-            globalThis.throwOutOfMemory();
-            return .zero;
+            return globalThis.throwOutOfMemoryValue();
         };
 
         buffered_writer.flush() catch {
-            globalThis.throwOutOfMemory();
-            return .zero;
+            return globalThis.throwOutOfMemoryValue();
         };
 
-        var str = bun.String.createUTF8(mutable_str.toOwnedSliceLeaky());
-        defer str.deref();
-        return str.toJS(globalThis);
+        var str = bun.String.createUTF8(mutable_str.slice());
+        return str.transferToJS(globalThis);
     }
 
     pub fn compute(source_contents: []const u8, source_id: i32, source_url: bun.JSC.ZigString.Slice) ByteRangeMapping {
diff --git a/src/sourcemap/sourcemap.zig b/src/sourcemap/sourcemap.zig
index 8277ae948e..41ddfd67f1 100644
--- a/src/sourcemap/sourcemap.zig
+++ b/src/sourcemap/sourcemap.zig
@@ -132,7 +132,7 @@ pub fn parseJSON(
         bun.JSAst.Stmt.Data.Store.reset();
     }
     debug("parse (JSON, {d} bytes)", .{source.len});
-    var json = bun.JSON.ParseJSON(&json_src, &log, arena) catch {
+    var json = bun.JSON.parse(&json_src, &log, arena, false) catch {
         return error.InvalidJSON;
     };
 
@@ -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 .{
@@ -614,6 +607,9 @@ pub const ParseResult = union(enum) {
                 .location = Logger.Location{
                     .file = path,
                     .offset = this.loc.toUsize(),
+                    // TODO: populate correct line and column information
+                    .line = -1,
+                    .column = -1,
                 },
                 .text = this.msg,
             };
diff --git a/src/sql/postgres.zig b/src/sql/postgres.zig
index 009146cdf9..026706100e 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");
 
-const Data = union(enum) {
+pub const SSLMode = enum(u8) {
+    disable = 0,
+    prefer = 1,
+    require = 2,
+    verify_ca = 3,
+    verify_full = 4,
+};
+
+pub const Data = union(enum) {
     owned: bun.ByteList,
     temporary: []const u8,
     empty: void,
@@ -72,1913 +83,80 @@ const Data = union(enum) {
         };
     }
 };
-
-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 };
-
-        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.parseJSON(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 };
-
-        pub fn toJS(
-            globalObject: *JSC.JSGlobalObject,
-            value: *Data,
-        ) anyerror!JSValue {
-            defer value.deinit();
-            return JSValue.fromDateString(globalObject, value.sliceZ().ptr);
-        }
-    };
-
-    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);
-        }
-    };
-};
+pub const protocol = @import("./postgres/postgres_protocol.zig");
+pub const types = @import("./postgres/postgres_types.zig");
 
 const Socket = uws.AnySocket;
 const PreparedStatementsMap = std.HashMapUnmanaged(u64, *PostgresSQLStatement, bun.IdentityContext(u64), 80);
 
+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 {};
+        }
+
+        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});
+            }
+        }
+    };
+
+    const DebugSocketMonitorReader = struct {
+        var file: std.fs.File = undefined;
+        var enabled = false;
+        var check = std.once(load);
+
+        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 fn write(data: []const u8) void {
+            file.writeAll(data) catch {};
+        }
+    };
+
+    pub fn write(data: []const u8) void {
+        if (comptime bun.Environment.isDebug) {
+            DebugSocketMonitorWriter.check.call();
+            if (DebugSocketMonitorWriter.enabled) {
+                DebugSocketMonitorWriter.write(data);
+            }
+        }
+    }
+
+    pub fn read(data: []const u8) void {
+        if (comptime bun.Environment.isDebug) {
+            DebugSocketMonitorReader.check.call();
+            if (DebugSocketMonitorReader.enabled) {
+                DebugSocketMonitorReader.write(data);
+            }
+        }
+    }
+};
+
 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.throw("PostgresSQLQuery cannot be constructed directly", .{});
     }
 
     pub fn estimatedSize(this: *PostgresSQLQuery) usize {
@@ -2247,31 +423,26 @@ 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_old(4).slice();
         const query = arguments[0];
         const values = arguments[1];
+        const columns = arguments[3];
 
         if (!query.isString()) {
-            globalThis.throw("query must be a string", .{});
-            return .zero;
+            return globalThis.throw("query must be a string", .{});
         }
 
         if (values.jsType() != .Array) {
-            globalThis.throw("values must be an array", .{});
-            return .zero;
+            return globalThis.throw("values must be an array", .{});
         }
 
         const pending_value = arguments[2];
         if (!pending_value.jsType().isArrayLike()) {
-            globalThis.throwInvalidArgumentType("query", "pendingValue", "Array");
-            return .zero;
+            return globalThis.throwInvalidArgumentType("query", "pendingValue", "Array");
         }
 
-        var ptr = bun.default_allocator.create(PostgresSQLQuery) catch |err| {
-            globalThis.throwError(err, "failed to allocate query");
-            return .zero;
-        };
+        var ptr = try bun.default_allocator.create(PostgresSQLQuery);
 
         const this_value = ptr.toJS(globalThis);
         this_value.ensureStillAlive();
@@ -2284,6 +455,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,42 +468,41 @@ 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 {
-        var arguments_ = callframe.arguments(2);
+    pub fn doRun(this: *PostgresSQLQuery, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
+        var arguments_ = callframe.arguments_old(2);
         const arguments = arguments_.slice();
         var connection = arguments[0].as(PostgresSQLConnection) orelse {
-            globalObject.throw("connection must be a PostgresSQLConnection", .{});
-            return .zero;
+            return globalObject.throw("connection must be a PostgresSQLConnection", .{});
         };
         var query = arguments[1];
 
         if (!query.isObject()) {
-            globalObject.throwInvalidArgumentType("run", "query", "Query");
-            return .zero;
+            return globalObject.throwInvalidArgumentType("run", "query", "Query");
         }
 
         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())
+                return globalObject.throwError(err, "failed to generate signature");
+            return error.JSError;
         };
 
         var writer = connection.writer();
 
         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 globalObject.throwError(err, "failed to allocate statement");
         };
 
         const has_params = signature.fields.len > 0;
@@ -2346,10 +519,10 @@ 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");
-
-                        return .zero;
+                    PostgresRequest.bindAndExecute(globalObject, this.statement.?, binding_value, columns_value, PostgresSQLConnection.Writer, writer) catch |err| {
+                        if (!globalObject.hasException())
+                            return globalObject.throwError(err, "failed to bind and execute query");
+                        return error.JSError;
                     };
                     did_write = true;
                 }
@@ -2360,28 +533,30 @@ 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");
                     signature.deinit();
-                    return .zero;
+                    if (!globalObject.hasException())
+                        return globalObject.throwError(err, "failed to prepare and query");
+                    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");
                     signature.deinit();
-                    return .zero;
+                    if (!globalObject.hasException())
+                        return globalObject.throwError(err, "failed to write query");
+                    return error.JSError;
                 };
                 writer.write(&protocol.Sync) catch |err| {
-                    globalObject.throwError(err, "failed to flush");
                     signature.deinit();
-                    return .zero;
+                    if (!globalObject.hasException())
+                        return globalObject.throwError(err, "failed to flush");
+                    return error.JSError;
                 };
             }
 
             {
                 const stmt = bun.default_allocator.create(PostgresSQLStatement) catch |err| {
-                    globalObject.throwError(err, "failed to allocate statement");
-                    return .zero;
+                    return globalObject.throwError(err, "failed to allocate statement");
                 };
 
                 stmt.* = .{ .signature = signature, .ref_count = 2, .status = PostgresSQLStatement.Status.parsing };
@@ -2400,7 +575,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 +585,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 +597,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 +609,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 +617,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 +651,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);
+        try writer.short(len);
 
-        iter = JSC.JSArrayIterator.init(values_array, globalObject);
-
-        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 +666,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 +686,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 +720,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 +792,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 +804,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 +835,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 +858,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 +923,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 +1041,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 +1119,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 +1349,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.throw("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_old(10).slice();
         const hostname_str = arguments[0].toBunString(globalObject);
         defer hostname_str.deref();
         const port = arguments[1].coerce(i32, globalObject);
@@ -3030,13 +1374,64 @@ 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 {
+                return globalObject.throwInvalidArguments("tls must be a boolean or an object", .{});
+            };
+
+            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) {
+                    return globalObject.throw("failed to create TLS context", .{});
+                } else {
+                    return globalObject.throwValue(err.toJS(globalObject));
+                }
+            };
+
+            if (err != .none) {
+                tls_config.deinit();
+                if (tls_ctx) |ctx| {
+                    ctx.deinit(true);
+                }
+                return globalObject.throwValue(err.toJS(globalObject));
+            }
+
+            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,12 +1458,10 @@ pub const PostgresSQLConnection = struct {
             break :brk b.allocatedSlice();
         };
 
-        const on_connect = arguments[7];
-        const on_close = arguments[8];
-        var ptr = bun.default_allocator.create(PostgresSQLConnection) catch |err| {
-            globalObject.throwError(err, "failed to allocate connection");
-            return .zero;
-        };
+        const on_connect = arguments[8];
+        const on_close = arguments[9];
+
+        var ptr = try bun.default_allocator.create(PostgresSQLConnection);
 
         ptr.* = PostgresSQLConnection{
             .globalObject = globalObject,
@@ -3082,6 +1475,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,26 +1490,24 @@ 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: {
-                    const ctx_ = uws.us_create_bun_socket_context(0, vm.uwsLoop(), @sizeOf(*PostgresSQLConnection), uws.us_bun_socket_context_options_t{}).?;
-                    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) 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| {
+                    tls_config.deinit();
+                    if (tls_ctx) |tls| {
+                        tls.deinit(true);
+                    }
+                    ptr.deinit();
+                    return globalObject.throwError(err, "failed to connect to postgresql");
+                },
+            };
         }
 
         return js_value;
@@ -3132,6 +1527,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();
@@ -3169,13 +1570,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;
@@ -3191,7 +1592,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);
@@ -3212,6 +1613,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);
     }
 
@@ -3319,10 +1721,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 {
@@ -3333,6 +1736,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,
@@ -3476,12 +1880,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) {
@@ -3514,13 +1930,13 @@ pub const PostgresSQLConnection = struct {
             }
         }
 
-        // #define pg_hton16(x)		(x)
-        // #define pg_hton32(x)		(x)
-        // #define pg_hton64(x)		(x)
+        // #define pg_hton16(x)        (x)
+        // #define pg_hton32(x)        (x)
+        // #define pg_hton64(x)        (x)
 
-        // #define pg_ntoh16(x)		(x)
-        // #define pg_ntoh32(x)		(x)
-        // #define pg_ntoh64(x)		(x)
+        // #define pg_ntoh16(x)        (x)
+        // #define pg_ntoh32(x)        (x)
+        // #define pg_ntoh64(x)        (x)
 
         fn pg_ntoT(comptime IntSize: usize, i: anytype) std.meta.Int(.unsigned, IntSize) {
             @setRuntimeSafety(false);
@@ -3654,7 +2070,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);
@@ -3923,6 +2340,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))});
                     },
@@ -4038,7 +2467,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;
@@ -4046,7 +2475,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;
@@ -4127,6 +2556,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())
+                        return globalObject.throw("Expected a row to be returned at index {d}", .{row_i}) catch null;
+                    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())
+                    return globalObject.throw("Expected a column at index {d} in row {d}", .{ cell_i, row_i }) catch null;
+                this.any_failed = true;
+                return null;
+            }
+
+            const value = this.current_row.getOwnByValue(globalObject, property);
+            if (value == .zero or value == .undefined) {
+                if (!globalObject.hasException())
+                    return globalObject.throw("Expected a value at index {d} in row {d}", .{ cell_i, row_i }) catch null;
+                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,
@@ -4145,7 +2692,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);
 
@@ -4156,17 +2703,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"),
@@ -4180,10 +2727,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 0000000000..4aee1791f9
--- /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 0000000000..498b7f1d0a
--- /dev/null
+++ b/src/sql/postgres/postgres_types.zig
@@ -0,0 +1,558 @@
+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()) {
+            return globalObject.throwValue(parse_result);
+        }
+
+        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 63db7a55ec..3b2dab9fcb 100644
--- a/src/string.zig
+++ b/src/string.zig
@@ -341,7 +341,7 @@ pub const String = extern struct {
         return bytes;
     }
 
-    pub fn toOwnedSliceReturningAllASCII(this: String, allocator: std.mem.Allocator) !struct { []u8, bool } {
+    pub fn toOwnedSliceReturningAllASCII(this: String, allocator: std.mem.Allocator) OOM!struct { []u8, bool } {
         switch (this.tag) {
             .ZigString => return .{ try this.value.ZigString.toOwnedSlice(allocator), true },
             .WTFStringImpl => {
@@ -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,32 @@ 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)) {
+            if (comptime bun.Environment.isDebug) {
+                bun.assert(out.tag != .Dead);
+            }
+            return out;
+        } else {
+            if (comptime bun.Environment.isDebug) {
+                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;
+            if (comptime bun.Environment.isDebug) {
+                bun.assert(globalObject.hasException());
+            }
+            return error.JSError;
         }
     }
 
@@ -720,7 +739,7 @@ pub const String = extern struct {
         if (BunString__fromJS(globalObject, value, &out)) {
             return out;
         } else {
-            return null;
+            return null; //TODO: return error.JSError
         }
     }
 
@@ -742,6 +761,7 @@ pub const String = extern struct {
         len: usize,
     ) JSC.JSValue;
 
+    /// calls toJS on all elements of `array`.
     pub fn toJSArray(globalObject: *bun.JSC.JSGlobalObject, array: []const bun.String) JSC.JSValue {
         JSC.markBinding(@src());
 
@@ -881,7 +901,7 @@ pub const String = extern struct {
     }
 
     pub fn encode(self: String, enc: JSC.Node.Encoding) []u8 {
-        return self.toZigString().encode(enc);
+        return self.toZigString().encodeWithAllocator(bun.default_allocator, enc);
     }
 
     pub inline fn utf8(self: String) []const u8 {
@@ -1313,8 +1333,8 @@ 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 {
-        const args = callFrame.arguments(1).slice();
+    pub fn jsGetStringWidth(globalObject: *JSC.JSGlobalObject, callFrame: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+        const args = callFrame.arguments_old(1).slice();
 
         if (args.len == 0 or !args.ptr[0].isString()) {
             return JSC.jsNumber(@as(i32, 0));
@@ -1330,6 +1350,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 3fd2aa4728..2703a74e24 100644
--- a/src/string_immutable.zig
+++ b/src/string_immutable.zig
@@ -85,9 +85,6 @@ fn literalLength(comptime T: type, comptime str: string) usize {
     };
 }
 
-// TODO: remove this
-pub const toUTF16LiteralZ = toUTF16Literal;
-
 pub const OptionalUsize = std.meta.Int(.unsigned, @bitSizeOf(usize) - 1);
 pub fn indexOfAny(slice: string, comptime str: []const u8) ?OptionalUsize {
     switch (comptime str.len) {
@@ -135,6 +132,7 @@ pub fn indexOfAny16(self: []const u16, comptime str: anytype) ?OptionalUsize {
 
 pub fn indexOfAnyT(comptime T: type, str: []const T, comptime chars: anytype) ?OptionalUsize {
     if (T == u8) return indexOfAny(str, chars);
+
     for (str, 0..) |c, i| {
         inline for (chars) |a| {
             if (c == a) {
@@ -216,6 +214,210 @@ pub fn isNPMPackageName(target: string) bool {
     return !scoped or slash_index > 0 and slash_index + 1 < target.len;
 }
 
+pub fn isUUID(str: string) bool {
+    if (str.len != uuid_len) return false;
+    for (0..8) |i| {
+        switch (str[i]) {
+            '0'...'9', 'a'...'f', 'A'...'F' => {},
+            else => return false,
+        }
+    }
+    if (str[8] != '-') return false;
+    for (9..13) |i| {
+        switch (str[i]) {
+            '0'...'9', 'a'...'f', 'A'...'F' => {},
+            else => return false,
+        }
+    }
+    if (str[13] != '-') return false;
+    for (14..18) |i| {
+        switch (str[i]) {
+            '0'...'9', 'a'...'f', 'A'...'F' => {},
+            else => return false,
+        }
+    }
+    if (str[18] != '-') return false;
+    for (19..23) |i| {
+        switch (str[i]) {
+            '0'...'9', 'a'...'f', 'A'...'F' => {},
+            else => return false,
+        }
+    }
+    if (str[23] != '-') return false;
+    for (24..36) |i| {
+        switch (str[i]) {
+            '0'...'9', 'a'...'f', 'A'...'F' => {},
+            else => return false,
+        }
+    }
+    return true;
+}
+
+pub const uuid_len = 36;
+
+pub fn startsWithUUID(str: string) bool {
+    return isUUID(str[0..@min(str.len, uuid_len)]);
+}
+
+/// https://github.com/npm/cli/blob/63d6a732c3c0e9c19fd4d147eaa5cc27c29b168d/node_modules/%40npmcli/redact/lib/matchers.js#L7
+/// /\b(npms?_)[a-zA-Z0-9]{36,48}\b/gi
+/// Returns the length of the secret if one exist.
+pub fn startsWithNpmSecret(str: string) u8 {
+    if (str.len < "npm_".len + 36) return 0;
+
+    if (!strings.hasPrefixCaseInsensitive(str, "npm")) return 0;
+
+    var i: u8 = "npm".len;
+
+    if (str[i] == '_') {
+        i += 1;
+    } else if (str[i] == 's' or str[i] == 'S') {
+        i += 1;
+        if (str[i] != '_') return 0;
+        i += 1;
+    } else {
+        return 0;
+    }
+
+    const min_len = i + 36;
+    const max_len = i + 48;
+
+    while (i < max_len) : (i += 1) {
+        if (i == str.len) {
+            return if (i >= min_len) i else 0;
+        }
+
+        switch (str[i]) {
+            '0'...'9', 'a'...'z', 'A'...'Z' => {},
+            else => return if (i >= min_len) i else 0,
+        }
+    }
+
+    return i;
+}
+
+fn startsWithRedactedItem(text: string, comptime item: string) ?struct { usize, usize } {
+    if (!strings.hasPrefixComptime(text, item)) return null;
+
+    var whitespace = false;
+    var offset: usize = item.len;
+    while (offset < text.len and std.ascii.isWhitespace(text[offset])) {
+        offset += 1;
+        whitespace = true;
+    }
+    if (offset == text.len) return null;
+    const cont = js_lexer.isIdentifierContinue(text[offset]);
+
+    // must be another identifier
+    if (!whitespace and cont) return null;
+
+    // `null` is not returned after this point. Redact to the next
+    // newline if anything is unexpected
+    if (cont) return .{ offset, indexOfChar(text[offset..], '\n') orelse text[offset..].len };
+    offset += 1;
+
+    var end = offset;
+    while (end < text.len and std.ascii.isWhitespace(text[end])) {
+        end += 1;
+    }
+
+    if (end == text.len) {
+        return .{ offset, text[offset..].len };
+    }
+
+    switch (text[end]) {
+        inline '\'', '"', '`' => |q| {
+            // attempt to find closing
+            const opening = end;
+            end += 1;
+            while (end < text.len) {
+                switch (text[end]) {
+                    '\\' => {
+                        // skip
+                        end += 1;
+                        end += 1;
+                    },
+                    q => {
+                        // closing
+                        return .{ opening + 1, (end - 1) - opening };
+                    },
+                    else => {
+                        end += 1;
+                    },
+                }
+            }
+
+            const len = strings.indexOfChar(text[offset..], '\n') orelse text[offset..].len;
+            return .{ offset, len };
+        },
+        else => {
+            const len = strings.indexOfChar(text[offset..], '\n') orelse text[offset..].len;
+            return .{ offset, len };
+        },
+    }
+}
+
+/// Returns offset and length of first secret found.
+pub fn startsWithSecret(str: string) ?struct { usize, usize } {
+    if (startsWithRedactedItem(str, "_auth")) |auth| {
+        const offset, const len = auth;
+        return .{ offset, len };
+    }
+    if (startsWithRedactedItem(str, "_authToken")) |auth_token| {
+        const offset, const len = auth_token;
+        return .{ offset, len };
+    }
+    if (startsWithRedactedItem(str, "email")) |email| {
+        const offset, const len = email;
+        return .{ offset, len };
+    }
+    if (startsWithRedactedItem(str, "_password")) |password| {
+        const offset, const len = password;
+        return .{ offset, len };
+    }
+    if (startsWithRedactedItem(str, "token")) |token| {
+        const offset, const len = token;
+        return .{ offset, len };
+    }
+
+    if (startsWithUUID(str)) {
+        return .{ 0, 36 };
+    }
+
+    const npm_secret_len = startsWithNpmSecret(str);
+    if (npm_secret_len > 0) {
+        return .{ 0, npm_secret_len };
+    }
+
+    if (findUrlPassword(str)) |url_pass| {
+        const offset, const len = url_pass;
+        return .{ offset, len };
+    }
+
+    return null;
+}
+
+pub fn findUrlPassword(text: string) ?struct { usize, usize } {
+    if (!strings.hasPrefixComptime(text, "http")) return null;
+    var offset: usize = "http".len;
+    if (hasPrefixComptime(text[offset..], "://")) {
+        offset += "://".len;
+    } else if (hasPrefixComptime(text[offset..], "s://")) {
+        offset += "s://".len;
+    } else {
+        return null;
+    }
+    var remain = text[offset..];
+    const end = indexOfChar(remain, '\n') orelse remain.len;
+    remain = remain[0..end];
+    const at = indexOfChar(remain, '@') orelse return null;
+    const colon = indexOfCharNeg(remain[0..at], ':');
+    if (colon == -1 or colon == at - 1) return null;
+    offset += @intCast(colon + 1);
+    const len: usize = at - @as(usize, @intCast(colon + 1));
+    return .{ offset, len };
+}
+
 pub fn indexAnyComptime(target: string, comptime chars: string) ?usize {
     for (target, 0..) |parent, i| {
         inline for (chars) |char| {
@@ -589,6 +791,41 @@ pub fn startsWith(self: string, str: string) bool {
     return eqlLong(self[0..str.len], str, false);
 }
 
+/// Transliterated from:
+/// https://github.com/rust-lang/rust/blob/91376f416222a238227c84a848d168835ede2cc3/library/core/src/str/mod.rs#L188
+pub fn isOnCharBoundary(self: string, idx: usize) bool {
+    // 0 is always ok.
+    // Test for 0 explicitly so that it can optimize out the check
+    // easily and skip reading string data for that case.
+    // Note that optimizing `self.get(..idx)` relies on this.
+    if (idx == 0) {
+        return true;
+    }
+
+    // For `idx >= self.len` we have two options:
+    //
+    // - idx == self.len
+    //   Empty strings are valid, so return true
+    // - idx > self.len
+    //   In this case return false
+    //
+    // The check is placed exactly here, because it improves generated
+    // code on higher opt-levels. See PR #84751 for more details.
+    // TODO(zack) this code is optimized for Rust's `self.as_bytes().get(idx)` function, don'
+    if (idx >= self.len) return idx == self.len;
+
+    return isUtf8CharBoundary(self[idx]);
+}
+
+pub fn isUtf8CharBoundary(c: u8) bool {
+    // This is bit magic equivalent to: b < 128 || b >= 192
+    return @as(i8, @intCast(c)) >= -0x40;
+}
+
+pub fn startsWithCaseInsensitiveAscii(self: string, prefix: string) bool {
+    return self.len >= prefix.len and eqlCaseInsensitiveASCII(self[0..prefix.len], prefix, false);
+}
+
 pub fn startsWithGeneric(comptime T: type, self: []const T, str: []const T) bool {
     if (str.len > self.len) {
         return false;
@@ -629,34 +866,24 @@ pub fn withoutTrailingSlash(this: string) []const u8 {
     return href;
 }
 
-/// Does not strip the C:\
-pub fn withoutTrailingSlashWindowsPath(this: string) []const u8 {
-    if (this.len < 3 or
-        this[1] != ':') return withoutTrailingSlash(this);
+/// Does not strip the device root (C:\ or \\Server\Share\ portion off of the path)
+pub fn withoutTrailingSlashWindowsPath(input: string) []const u8 {
+    if (Environment.isPosix or input.len < 3 or input[1] != ':')
+        return withoutTrailingSlash(input);
 
-    var href = this;
-    while (href.len > 3 and (switch (href[href.len - 1]) {
+    const root_len = bun.path.windowsFilesystemRoot(input).len + 1;
+
+    var path = input;
+    while (path.len > root_len and (switch (path[path.len - 1]) {
         '/', '\\' => true,
         else => false,
     })) {
-        href.len -= 1;
+        path.len -= 1;
     }
 
-    return href;
-}
+    bun.assert(!isWindowsAbsolutePathMissingDriveLetter(u8, path));
 
-/// This will remove ONE trailing slash at the end of a string,
-/// but on Windows it will not remove the \ in "C:\"
-pub fn pathWithoutTrailingSlashOne(str: []const u8) []const u8 {
-    return if (str.len > 0 and charIsAnySlash(str[str.len - 1]))
-        if (Environment.isWindows and str.len == 3 and str[1] == ':')
-            // Preserve "C:\"
-            str
-        else
-            // Remove one slash
-            str[0 .. str.len - 1]
-    else
-        str;
+    return path;
 }
 
 pub fn withoutLeadingSlash(this: string) []const u8 {
@@ -884,6 +1111,31 @@ pub fn eqlCaseInsensitiveASCII(a: string, b: string, comptime check_len: bool) b
     return bun.C.strncasecmp(a.ptr, b.ptr, a.len) == 0;
 }
 
+pub fn eqlCaseInsensitiveT(comptime T: type, a: []const T, b: []const u8) bool {
+    if (a.len != b.len or a.len == 0) return false;
+    if (comptime T == u8) return eqlCaseInsensitiveASCIIIgnoreLength(a, b);
+
+    for (a, b) |c, d| {
+        switch (c) {
+            'a'...'z' => if (c != d and c & 0b11011111 != d) return false,
+            'A'...'Z' => if (c != d and c | 0b00100000 != d) return false,
+            else => if (c != d) return false,
+        }
+    }
+
+    return true;
+}
+
+pub fn hasPrefixCaseInsensitiveT(comptime T: type, str: []const T, prefix: []const u8) bool {
+    if (str.len < prefix.len) return false;
+
+    return eqlCaseInsensitiveT(T, str[0..prefix.len], prefix);
+}
+
+pub fn hasPrefixCaseInsensitive(str: []const u8, prefix: []const u8) bool {
+    return hasPrefixCaseInsensitiveT(u8, str, prefix);
+}
+
 pub fn eqlLong(a_str: string, b_str: string, comptime check_len: bool) bool {
     const len = b_str.len;
 
@@ -1691,25 +1943,21 @@ pub fn utf16Codepoint(comptime Type: type, input: Type) UTF16Replacement {
     }
 }
 
-/// Checks if a path is missing a windows drive letter. Not a perfect check,
-/// but it is good enough for most cases. For windows APIs, this is used for
-/// an assertion, and PosixToWinNormalizer can help make an absolute path
-/// contain a drive letter.
+/// Checks if a path is missing a windows drive letter. For windows APIs,
+/// this is used for an assertion, and PosixToWinNormalizer can help make
+/// an absolute path contain a drive letter.
 pub fn isWindowsAbsolutePathMissingDriveLetter(comptime T: type, chars: []const T) bool {
     bun.unsafeAssert(bun.path.Platform.windows.isAbsoluteT(T, chars));
     bun.unsafeAssert(chars.len > 0);
 
     // 'C:\hello' -> false
+    // This is the most common situation, so we check it first
     if (!(chars[0] == '/' or chars[0] == '\\')) {
         bun.unsafeAssert(chars.len > 2);
         bun.unsafeAssert(chars[1] == ':');
         return false;
     }
 
-    // '\\hello' -> false (probably a UNC path)
-    if (chars.len > 1 and
-        (chars[1] == '/' or chars[1] == '\\')) return false;
-
     if (chars.len > 4) {
         // '\??\hello' -> false (has the NT object prefix)
         if (chars[1] == '?' and
@@ -1724,9 +1972,13 @@ pub fn isWindowsAbsolutePathMissingDriveLetter(comptime T: type, chars: []const
             return false;
     }
 
-    // oh no, '/hello/world'
-    // where is the drive letter!
-    return true;
+    // A path starting with `/` can be a UNC path with forward slashes,
+    // or actually just a posix path.
+    //
+    // '\\Server\Share' -> false (unc)
+    // '\\Server\\Share' -> true (not unc because extra slashes)
+    // '\Server\Share' -> true (posix path)
+    return bun.path.windowsFilesystemRootT(T, chars).len == 1;
 }
 
 pub fn fromWPath(buf: []u8, utf16: []const u16) [:0]const u8 {
@@ -1841,13 +2093,19 @@ pub fn toWPath(wbuf: []u16, utf8: []const u8) [:0]const u16 {
 pub fn toWDirPath(wbuf: []u16, utf8: []const u8) [:0]const u16 {
     return toWPathMaybeDir(wbuf, utf8, true);
 }
-
+fn isUNCPath(comptime T: type, path: []const T) bool {
+    return path.len >= 3 and
+        bun.path.Platform.windows.isSeparatorT(T, path[0]) and
+        bun.path.Platform.windows.isSeparatorT(T, path[1]) and
+        !bun.path.Platform.windows.isSeparatorT(T, path[2]) and
+        path[2] != '.';
+}
 pub fn assertIsValidWindowsPath(comptime T: type, path: []const T) void {
     if (Environment.allow_assert and Environment.isWindows) {
         if (bun.path.Platform.windows.isAbsoluteT(T, path) and
             isWindowsAbsolutePathMissingDriveLetter(T, path) and
             // is it a null device path? that's not an error. it's just a weird file path.
-            !eqlComptimeT(T, path, "\\\\.\\NUL") and !eqlComptimeT(T, path, "\\\\.\\nul") and !eqlComptimeT(T, path, "\\nul") and !eqlComptimeT(T, path, "\\NUL"))
+            !eqlComptimeT(T, path, "\\\\.\\NUL") and !eqlComptimeT(T, path, "\\\\.\\nul") and !eqlComptimeT(T, path, "\\nul") and !eqlComptimeT(T, path, "\\NUL") and !isUNCPath(T, path))
         {
             std.debug.panic("Internal Error: Do not pass posix paths to Windows APIs, was given '{s}'" ++ if (Environment.isDebug) " (missing a root like 'C:\\', see PosixToWinNormalizer for why this is an assertion)" else ". Please open an issue on GitHub with a reproduction.", .{
                 if (T == u8) path else bun.fmt.utf16(path),
@@ -1894,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,
@@ -1909,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);
@@ -3409,6 +3695,39 @@ pub fn utf16EqlString(text: []const u16, str: string) bool {
     return j == str.len;
 }
 
+pub fn encodeUTF8Comptime(comptime cp: u32) []const u8 {
+    const HEADER_CONT_BYTE: u8 = 0b10000000;
+    const HEADER_2BYTE: u8 = 0b11000000;
+    const HEADER_3BYTE: u8 = 0b11100000;
+    const HEADER_4BYTE: u8 = 0b11100000;
+
+    return switch (cp) {
+        0x0...0x7F => return &[_]u8{@intCast(cp)},
+        0x80...0x7FF => {
+            return &[_]u8{
+                HEADER_2BYTE | @as(u8, cp >> 6),
+                HEADER_CONT_BYTE | @as(u8, cp & 0b00111111),
+            };
+        },
+        0x800...0xFFFF => {
+            return &[_]u8{
+                HEADER_3BYTE | @as(u8, cp >> 12),
+                HEADER_CONT_BYTE | @as(u8, (cp >> 6) & 0b00111111),
+                HEADER_CONT_BYTE | @as(u8, cp & 0b00111111),
+            };
+        },
+        0x10000...0x10FFFF => {
+            return &[_]u8{
+                HEADER_4BYTE | @as(u8, cp >> 18),
+                HEADER_CONT_BYTE | @as(u8, (cp >> 12) & 0b00111111),
+                HEADER_CONT_BYTE | @as(u8, (cp >> 6) & 0b00111111),
+                HEADER_CONT_BYTE | @as(u8, cp & 0b00111111),
+            };
+        },
+        else => @compileError("Invalid UTF-8 codepoint!"),
+    };
+}
+
 // This is a clone of golang's "utf8.EncodeRune" that has been modified to encode using
 // WTF-8 instead. See https://simonsapin.github.io/wtf-8/ for more info.
 pub fn encodeWTF8Rune(p: *[4]u8, r: i32) u3 {
@@ -3939,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));
@@ -3968,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)));
         }
     }
@@ -4008,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);
 }
@@ -4222,6 +4571,24 @@ pub fn trimLeadingChar(slice: []const u8, char: u8) []const u8 {
     return "";
 }
 
+/// Trim leading pattern of 2 bytes
+///
+/// e.g.
+/// `trimLeadingPattern2("abcdef", 'a', 'b') == "cdef"`
+pub fn trimLeadingPattern2(slice_: []const u8, comptime byte1: u8, comptime byte2: u8) []const u8 {
+    const pattern: u16 = comptime @as(u16, byte2) << 8 | @as(u16, byte1);
+    var slice = slice_;
+    while (slice.len >= 2) {
+        const sliceu16: [*]const u16 = @ptrCast(@alignCast(slice.ptr));
+        if (sliceu16[0] == pattern) {
+            slice = slice[2..];
+        } else {
+            break;
+        }
+    }
+    return slice;
+}
+
 /// Get the line number and the byte offsets of `line_range_count` above the desired line number
 /// The final element is the end index of the desired line
 const LineRange = struct {
@@ -4563,6 +4930,12 @@ pub fn trim(slice: anytype, comptime values_to_strip: []const u8) @TypeOf(slice)
     return slice[begin..end];
 }
 
+pub fn isAllWhitespace(slice: []const u8) bool {
+    var begin: usize = 0;
+    while (begin < slice.len and std.mem.indexOfScalar(u8, &whitespace_chars, slice[begin]) != null) : (begin += 1) {}
+    return begin == slice.len;
+}
+
 pub const whitespace_chars = [_]u8{ ' ', '\t', '\n', '\r', std.ascii.control_code.vt, std.ascii.control_code.ff };
 
 pub fn lengthOfLeadingWhitespaceASCII(slice: string) usize {
@@ -4671,6 +5044,19 @@ pub inline fn utf8ByteSequenceLength(first_byte: u8) u3 {
     };
 }
 
+/// Same as `utf8ByteSequenceLength`, but assumes the byte is valid UTF-8.
+///
+/// You should only use this function if you know the string you are getting the byte from is valid UTF-8.
+pub inline fn utf8ByteSequenceLengthUnsafe(first_byte: u8) u3 {
+    return switch (first_byte) {
+        0b0000_0000...0b0111_1111 => 1,
+        0b1100_0000...0b1101_1111 => 2,
+        0b1110_0000...0b1110_1111 => 3,
+        0b1111_0000...0b1111_0111 => 4,
+        else => unreachable,
+    };
+}
+
 pub const PackedCodepointIterator = struct {
     const Iterator = @This();
     const CodePointType = u32;
@@ -5330,9 +5716,6 @@ pub fn isZeroWidthCodepointType(comptime T: type, cp: T) bool {
         // Combining Diacritical Marks
         return true;
     }
-    if (cp >= 0x300 and cp <= 0x36f)
-        // Combining Diacritical Marks
-        return true;
 
     if (cp >= 0x200b and cp <= 0x200f) {
         // Modifying Invisible Characters
@@ -6133,24 +6516,25 @@ pub const visible = struct {
     };
 };
 
-pub const QuoteEscapeFormat = struct {
-    data: []const u8,
-
-    pub fn format(self: QuoteEscapeFormat, comptime _: []const u8, _: std.fmt.FormatOptions, writer: anytype) !void {
-        var i: usize = 0;
-        while (std.mem.indexOfAnyPos(u8, self.data, i, "\"\n\\")) |j| : (i = j + 1) {
-            try writer.writeAll(self.data[i..j]);
-            try writer.writeAll(switch (self.data[j]) {
-                '"' => "\\\"",
-                '\n' => "\\n",
-                '\\' => "\\\\",
-                else => unreachable,
-            });
-        }
-        if (i == self.data.len) return;
-        try writer.writeAll(self.data[i..]);
-    }
+pub const QuoteEscapeFormatFlags = struct {
+    quote_char: u8,
+    ascii_only: bool = false,
+    json: bool = false,
+    str_encoding: Encoding = .utf8,
 };
+/// usage: print(" string: '{'}' ", .{formatEscapesJS("hello'world!")});
+pub fn formatEscapes(str: []const u8, comptime flags: QuoteEscapeFormatFlags) QuoteEscapeFormat(flags) {
+    return .{ .data = str };
+}
+fn QuoteEscapeFormat(comptime flags: QuoteEscapeFormatFlags) type {
+    return struct {
+        data: []const u8,
+
+        pub fn format(self: @This(), comptime _: []const u8, _: std.fmt.FormatOptions, writer: anytype) !void {
+            try bun.js_printer.writePreQuotedString(self.data, @TypeOf(writer), writer, flags.quote_char, false, flags.json, flags.str_encoding);
+        }
+    };
+}
 
 /// Generic. Works on []const u8, []const u16, etc
 pub inline fn indexOfScalar(input: anytype, scalar: std.meta.Child(@TypeOf(input))) ?usize {
@@ -6180,6 +6564,13 @@ pub fn withoutPrefixComptime(input: []const u8, comptime prefix: []const u8) []c
     return input;
 }
 
+pub fn withoutPrefixComptimeZ(input: [:0]const u8, comptime prefix: []const u8) [:0]const u8 {
+    if (hasPrefixComptime(input, prefix)) {
+        return input[prefix.len..];
+    }
+    return input;
+}
+
 pub fn withoutPrefixIfPossibleComptime(input: string, comptime prefix: string) ?string {
     if (hasPrefixComptime(input, prefix)) {
         return input[prefix.len..];
@@ -6191,3 +6582,21 @@ pub fn withoutPrefixIfPossibleComptime(input: string, comptime prefix: string) ?
 extern fn icu_hasBinaryProperty(c: u32, which: c_uint) bool;
 
 const assert = bun.assert;
+
+/// Returns the first byte of the string and the rest of the string excluding the first byte
+pub fn splitFirst(self: string) ?struct { first: u8, rest: []const u8 } {
+    if (self.len == 0) {
+        return null;
+    }
+
+    const first = self[0];
+    return .{ .first = first, .rest = self[1..] };
+}
+
+/// Returns the first byte of the string which matches the expected byte and the rest of the string excluding the first byte
+pub fn splitFirstWithExpected(self: string, comptime expected: u8) ?[]const u8 {
+    if (self.len > 0 and self[0] == expected) {
+        return self[1..];
+    }
+    return null;
+}
diff --git a/src/string_mutable.zig b/src/string_mutable.zig
index c894eaf2e9..042184d501 100644
--- a/src/string_mutable.zig
+++ b/src/string_mutable.zig
@@ -9,6 +9,7 @@ const js_lexer = bun.js_lexer;
 const string = bun.string;
 const stringZ = bun.stringZ;
 const CodePoint = bun.CodePoint;
+const OOM = bun.OOM;
 
 pub const MutableString = struct {
     allocator: std.mem.Allocator,
@@ -18,7 +19,7 @@ pub const MutableString = struct {
         return MutableString.init(allocator, 2048);
     }
 
-    pub const Writer = std.io.Writer(*@This(), anyerror, MutableString.writeAll);
+    pub const Writer = std.io.Writer(*@This(), OOM, MutableString.writeAll);
     pub fn writer(self: *MutableString) Writer {
         return Writer{
             .context = self,
@@ -36,15 +37,15 @@ pub const MutableString = struct {
         }
     }
 
-    pub fn owns(this: *const MutableString, slice: []const u8) bool {
-        return bun.isSliceInBuffer(slice, this.list.items.ptr[0..this.list.capacity]);
+    pub fn owns(this: *const MutableString, items: []const u8) bool {
+        return bun.isSliceInBuffer(items, this.list.items.ptr[0..this.list.capacity]);
     }
 
-    pub fn growIfNeeded(self: *MutableString, amount: usize) !void {
+    pub fn growIfNeeded(self: *MutableString, amount: usize) OOM!void {
         try self.list.ensureUnusedCapacity(self.allocator, amount);
     }
 
-    pub fn write(self: *MutableString, bytes: anytype) !usize {
+    pub fn write(self: *MutableString, bytes: anytype) OOM!usize {
         bun.debugAssert(bytes.len == 0 or !bun.isSliceInBuffer(bytes, self.list.allocatedSlice()));
         try self.list.appendSlice(self.allocator, bytes);
         return bytes.len;
@@ -54,7 +55,7 @@ pub const MutableString = struct {
         return BufferedWriter{ .context = self };
     }
 
-    pub fn init(allocator: std.mem.Allocator, capacity: usize) std.mem.Allocator.Error!MutableString {
+    pub fn init(allocator: std.mem.Allocator, capacity: usize) OOM!MutableString {
         return MutableString{ .allocator = allocator, .list = if (capacity > 0)
             try std.ArrayListUnmanaged(u8).initCapacity(allocator, capacity)
         else
@@ -67,7 +68,7 @@ pub const MutableString = struct {
 
     pub const ensureUnusedCapacity = growIfNeeded;
 
-    pub fn initCopy(allocator: std.mem.Allocator, str: anytype) !MutableString {
+    pub fn initCopy(allocator: std.mem.Allocator, str: anytype) OOM!MutableString {
         var mutable = try MutableString.init(allocator, str.len);
         try mutable.copy(str);
         return mutable;
@@ -118,8 +119,8 @@ pub const MutableString = struct {
                 str[0..start_i]);
             needs_gap = false;
 
-            var slice = str[start_i..];
-            iterator = strings.CodepointIterator.init(slice);
+            var items = str[start_i..];
+            iterator = strings.CodepointIterator.init(items);
             cursor = strings.CodepointIterator.Cursor{};
 
             while (iterator.next(&cursor)) {
@@ -129,7 +130,7 @@ pub const MutableString = struct {
                         needs_gap = false;
                         has_needed_gap = true;
                     }
-                    try mutable.append(slice[cursor.i .. cursor.i + @as(u32, cursor.width)]);
+                    try mutable.append(items[cursor.i .. cursor.i + @as(u32, cursor.width)]);
                 } else if (!needs_gap) {
                     needs_gap = true;
                     // skip the code point, replace it with a single _
@@ -171,17 +172,16 @@ pub const MutableString = struct {
         try self.list.ensureUnusedCapacity(self.allocator, amount);
     }
 
-    pub inline fn appendSlice(self: *MutableString, slice: []const u8) !void {
-        try self.list.appendSlice(self.allocator, slice);
+    pub inline fn appendSlice(self: *MutableString, items: []const u8) !void {
+        try self.list.appendSlice(self.allocator, items);
     }
 
-    pub inline fn appendSliceExact(self: *MutableString, slice: []const u8) !void {
-        if (slice.len == 0) return;
-
-        try self.list.ensureTotalCapacityPrecise(self.allocator, self.list.items.len + slice.len);
+    pub inline fn appendSliceExact(self: *MutableString, items: []const u8) !void {
+        if (items.len == 0) return;
+        try self.list.ensureTotalCapacityPrecise(self.allocator, self.list.items.len + items.len);
         var end = self.list.items.ptr + self.list.items.len;
-        self.list.items.len += slice.len;
-        @memcpy(end[0..slice.len], slice);
+        self.list.items.len += items.len;
+        @memcpy(end[0..items.len], items);
     }
 
     pub inline fn reset(
@@ -202,6 +202,10 @@ pub const MutableString = struct {
         try self.list.resize(self.allocator, amount);
     }
 
+    pub inline fn appendCharNTimes(self: *MutableString, char: u8, n: usize) !void {
+        try self.list.appendNTimes(self.allocator, char, n);
+    }
+
     pub inline fn appendChar(self: *MutableString, char: u8) !void {
         try self.list.append(self.allocator, char);
     }
@@ -232,7 +236,7 @@ pub const MutableString = struct {
         return self.list.toOwnedSlice(self.allocator) catch bun.outOfMemory(); // TODO
     }
 
-    pub fn toOwnedSliceLeaky(self: *MutableString) []u8 {
+    pub fn slice(self: *MutableString) []u8 {
         return self.list.items;
     }
 
@@ -243,7 +247,8 @@ pub const MutableString = struct {
         return out;
     }
 
-    pub fn toOwnedSentinelLeaky(self: *MutableString) [:0]u8 {
+    /// Appends `0` if needed
+    pub fn sliceWithSentinel(self: *MutableString) [:0]u8 {
         if (self.list.items.len > 0 and self.list.items[self.list.items.len - 1] != 0) {
             self.list.append(
                 self.allocator,
@@ -259,10 +264,6 @@ pub const MutableString = struct {
         return self.list.toOwnedSlice(self.allocator) catch bun.outOfMemory(); // TODO
     }
 
-    // pub fn deleteAt(self: *MutableString, i: usize)  {
-    //     self.list.swapRemove(i);
-    // }
-
     pub fn containsChar(self: *const MutableString, char: u8) bool {
         return self.indexOfChar(char) != null;
     }
@@ -394,46 +395,46 @@ pub const MutableString = struct {
         }
 
         pub fn writeHTMLAttributeValue(this: *BufferedWriter, bytes: []const u8) anyerror!void {
-            var slice = bytes;
-            while (slice.len > 0) {
+            var items = bytes;
+            while (items.len > 0) {
                 // TODO: SIMD
-                if (strings.indexOfAny(slice, "\"<>")) |j| {
-                    _ = try this.writeAll(slice[0..j]);
-                    _ = switch (slice[j]) {
+                if (strings.indexOfAny(items, "\"<>")) |j| {
+                    _ = try this.writeAll(items[0..j]);
+                    _ = switch (items[j]) {
                         '"' => try this.writeAll("&quot;"),
                         '<' => try this.writeAll("&lt;"),
                         '>' => try this.writeAll("&gt;"),
                         else => unreachable,
                     };
 
-                    slice = slice[j + 1 ..];
+                    items = items[j + 1 ..];
                     continue;
                 }
 
-                _ = try this.writeAll(slice);
+                _ = try this.writeAll(items);
                 break;
             }
         }
 
         pub fn writeHTMLAttributeValue16(this: *BufferedWriter, bytes: []const u16) anyerror!void {
-            var slice = bytes;
-            while (slice.len > 0) {
-                if (strings.indexOfAny16(slice, "\"<>")) |j| {
+            var items = bytes;
+            while (items.len > 0) {
+                if (strings.indexOfAny16(items, "\"<>")) |j| {
                     // this won't handle strings larger than 4 GB
                     // that's fine though, 4 GB of SSR'd HTML is quite a lot...
-                    _ = try this.writeAll16(slice[0..j]);
-                    _ = switch (slice[j]) {
+                    _ = try this.writeAll16(items[0..j]);
+                    _ = switch (items[j]) {
                         '"' => try this.writeAll("&quot;"),
                         '<' => try this.writeAll("&lt;"),
                         '>' => try this.writeAll("&gt;"),
                         else => unreachable,
                     };
 
-                    slice = slice[j + 1 ..];
+                    items = items[j + 1 ..];
                     continue;
                 }
 
-                _ = try this.writeAll16(slice);
+                _ = try this.writeAll16(items);
                 break;
             }
         }
@@ -443,7 +444,7 @@ pub const MutableString = struct {
         }
     };
 
-    pub fn writeAll(self: *MutableString, bytes: string) std.mem.Allocator.Error!usize {
+    pub fn writeAll(self: *MutableString, bytes: string) OOM!usize {
         try self.list.appendSlice(self.allocator, bytes);
         return bytes.len;
     }
diff --git a/src/symbols.def b/src/symbols.def
index 71f031ae9b..38a1355b7d 100644
--- a/src/symbols.def
+++ b/src/symbols.def
@@ -626,3 +626,6 @@ EXPORTS
   ?ContainsOnlyOneByte@String@v8@@QEBA_NXZ
   ?GlobalizeReference@api_internal@v8@@YAPEA_KPEAVIsolate@internal@2@_K@Z
   ?DisposeGlobal@api_internal@v8@@YAXPEA_K@Z
+  ?GetName@Function@v8@@QEBA?AV?$Local@VValue@v8@@@2@XZ
+  ?IsFunction@Value@v8@@QEBA_NXZ
+  ?FromJustIsNothing@api_internal@v8@@YAXXZ
diff --git a/src/symbols.dyn b/src/symbols.dyn
index 32e163fa5a..6fc7fd75dd 100644
--- a/src/symbols.dyn
+++ b/src/symbols.dyn
@@ -213,6 +213,9 @@
     __ZNK2v86String19ContainsOnlyOneByteEv;
     __ZN2v812api_internal18GlobalizeReferenceEPNS_8internal7IsolateEm;
     __ZN2v812api_internal13DisposeGlobalEPm;
+    __ZNK2v88Function7GetNameEv;
+    __ZNK2v85Value10IsFunctionEv;
+    __ZN2v812api_internal17FromJustIsNothingEv;
     _uv_os_getpid;
     _uv_os_getppid;
 };
diff --git a/src/symbols.txt b/src/symbols.txt
index 7935b0c106..cba22cc90e 100644
--- a/src/symbols.txt
+++ b/src/symbols.txt
@@ -212,5 +212,8 @@ __ZNK2v86String9IsOneByteEv
 __ZNK2v86String19ContainsOnlyOneByteEv
 __ZN2v812api_internal18GlobalizeReferenceEPNS_8internal7IsolateEm
 __ZN2v812api_internal13DisposeGlobalEPm
+__ZNK2v88Function7GetNameEv
+__ZNK2v85Value10IsFunctionEv
+__ZN2v812api_internal17FromJustIsNothingEv
 _uv_os_getpid
 _uv_os_getppid
diff --git a/src/sys.zig b/src/sys.zig
index ad887dc605..de27a70a0a 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;
     }
 
@@ -594,7 +598,7 @@ pub fn lstat(path: [:0]const u8) Maybe(bun.Stat) {
         return sys_uv.lstat(path);
     } else {
         var stat_ = mem.zeroes(bun.Stat);
-        if (Maybe(bun.Stat).errnoSys(C.lstat64(path, &stat_), .lstat)) |err| return err;
+        if (Maybe(bun.Stat).errnoSys(C.lstat(path, &stat_), .lstat)) |err| return err;
         return Maybe(bun.Stat){ .result = stat_ };
     }
 }
@@ -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,
@@ -729,7 +733,6 @@ pub fn mkdirOSPath(file_path: bun.OSPathSliceZ, flags: bun.Mode) Maybe(void) {
     return switch (Environment.os) {
         else => mkdir(file_path, flags),
         .windows => {
-            assertIsValidWindowsPath(bun.OSPathChar, file_path);
             const rc = kernel32.CreateDirectoryW(file_path, null);
 
             if (Maybe(void).errnoSys(
@@ -959,6 +962,11 @@ fn openDirAtWindowsT(
         .result => |norm| norm,
     };
 
+    if (comptime T == u8) {
+        log("openDirAtWindows({s}) = {s}", .{ path, bun.fmt.utf16(norm) });
+    } else {
+        log("openDirAtWindowsT({s}) = {s}", .{ bun.fmt.utf16(path), bun.fmt.utf16(norm) });
+    }
     return openDirAtWindowsNtPath(dirFd, norm, options);
 }
 
@@ -1250,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 });
 
@@ -1260,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)) {
@@ -1278,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);
@@ -1360,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| {
@@ -1371,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| {
@@ -1550,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)
-    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);
@@ -1604,10 +1612,10 @@ pub fn pread(fd: bun.FileDescriptor, buf: []u8, offset: i64) Maybe(usize) {
     }
 }
 
-const pwrite_sym = if (builtin.os.tag == .linux and builtin.link_libc)
-    sys.pwrite64
+const pwrite_sym = if (builtin.os.tag == .linux and builtin.link_libc and !bun.Environment.isMusl)
+    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) {
@@ -1640,19 +1648,19 @@ 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);
-
-            log("read({}, {d}) = {d} ({any})", .{ fd, adjusted_len, rc, debug_timer });
+            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 });
                 return err;
             }
+            log("read({}, {d}) = {d} ({any})", .{ fd, adjusted_len, rc, debug_timer });
 
             return Maybe(usize){ .result = @as(usize, @intCast(rc)) };
         },
         .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| {
@@ -1706,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 });
@@ -1737,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() });
@@ -1763,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;
@@ -1780,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] };
     }
 }
 
@@ -1803,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;
         }
@@ -1813,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;
         }
@@ -1959,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()) });
@@ -1983,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;
         }
@@ -1993,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;
         }
@@ -2116,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;
         }
@@ -2139,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;
         }
@@ -2167,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()) });
@@ -2185,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()) });
@@ -2212,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;
@@ -2289,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;
 }
@@ -2452,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) {
@@ -2470,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) {
@@ -2480,6 +2500,16 @@ pub fn exists(path: []const u8) bool {
     @compileError("TODO: existsOSPath");
 }
 
+pub fn existsZ(path: [:0]const u8) bool {
+    if (comptime Environment.isPosix) {
+        return syscall.access(path, 0) == 0;
+    }
+
+    if (comptime Environment.isWindows) {
+        return getFileAttributes(path) != null;
+    }
+}
+
 pub fn faccessat(dir_: anytype, subpath: anytype) JSC.Maybe(bool) {
     const has_sentinel = std.meta.sentinel(@TypeOf(subpath)) != null;
     const dir_fd = bun.toFD(dir_);
@@ -2736,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,
@@ -2779,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){
@@ -3004,14 +3034,14 @@ pub const File = struct {
     // "handle" matches std.fs.File
     handle: bun.FileDescriptor,
 
-    pub fn openat(other: anytype, path: anytype, flags: bun.Mode, mode: bun.Mode) Maybe(File) {
+    pub fn openat(other: anytype, path: [:0]const u8, flags: bun.Mode, mode: bun.Mode) Maybe(File) {
         return switch (This.openat(bun.toFD(other), path, flags, mode)) {
             .result => |fd| .{ .result = .{ .handle = fd } },
             .err => |err| .{ .err = err },
         };
     }
 
-    pub fn open(path: anytype, flags: bun.Mode, mode: bun.Mode) Maybe(File) {
+    pub fn open(path: [:0]const u8, flags: bun.Mode, mode: bun.Mode) Maybe(File) {
         return File.openat(bun.FD.cwd(), path, flags, mode);
     }
 
@@ -3380,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) {
@@ -3396,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 b9d93991a5..5984f33d26 100644
--- a/src/toml/toml_lexer.zig
+++ b/src/toml/toml_lexer.zig
@@ -70,6 +70,8 @@ pub const Lexer = struct {
 
     has_newline_before: bool = false,
 
+    should_redact_logs: bool,
+
     pub inline fn loc(self: *const Lexer) logger.Loc {
         return logger.usize2Loc(self.start);
     }
@@ -77,11 +79,15 @@ pub const Lexer = struct {
     pub fn syntaxError(self: *Lexer) !void {
         @setCold(true);
 
-        self.addError(self.start, "Syntax Error!!", .{}, true);
+        // Only add this if there is not already an error.
+        // It is possible that there is a more descriptive error already emitted.
+        if (!self.log.hasErrors())
+            self.addError(self.start, "Syntax Error", .{});
+
         return Error.SyntaxError;
     }
 
-    pub fn addError(self: *Lexer, _loc: usize, comptime format: []const u8, args: anytype, _: bool) void {
+    pub fn addError(self: *Lexer, _loc: usize, comptime format: []const u8, args: anytype) void {
         @setCold(true);
 
         var __loc = logger.usize2Loc(_loc);
@@ -89,24 +95,33 @@ pub const Lexer = struct {
             return;
         }
 
-        self.log.addErrorFmt(&self.source, __loc, self.log.msgs.allocator, format, args) catch unreachable;
+        self.log.addErrorFmtOpts(
+            self.log.msgs.allocator,
+            format,
+            args,
+            .{
+                .source = &self.source,
+                .loc = __loc,
+                .redact_sensitive_information = self.should_redact_logs,
+            },
+        ) catch unreachable;
         self.prev_error_loc = __loc;
     }
 
     pub fn addDefaultError(self: *Lexer, msg: []const u8) !void {
         @setCold(true);
 
-        self.addError(self.start, "{s}", .{msg}, true);
+        self.addError(self.start, "{s}", .{msg});
         return Error.SyntaxError;
     }
 
     pub fn addSyntaxError(self: *Lexer, _loc: usize, comptime fmt: []const u8, args: anytype) !void {
         @setCold(true);
-        self.addError(_loc, fmt, args, false);
+        self.addError(_loc, fmt, args);
         return Error.SyntaxError;
     }
 
-    pub fn addRangeError(self: *Lexer, r: logger.Range, comptime format: []const u8, args: anytype, _: bool) !void {
+    pub fn addRangeError(self: *Lexer, r: logger.Range, comptime format: []const u8, args: anytype) !void {
         @setCold(true);
 
         if (self.prev_error_loc.eql(r.loc)) {
@@ -114,12 +129,13 @@ pub const Lexer = struct {
         }
 
         const errorMessage = std.fmt.allocPrint(self.log.msgs.allocator, format, args) catch unreachable;
-        try self.log.addRangeError(&self.source, r, errorMessage);
+        try self.log.addErrorOpts(errorMessage, .{
+            .source = &self.source,
+            .loc = r.loc,
+            .len = r.len,
+            .redact_sensitive_information = self.should_redact_logs,
+        });
         self.prev_error_loc = r.loc;
-
-        // if (panic) {
-        //     return Error.ParserError;
-        // }
     }
 
     /// Look ahead at the next n codepoints without advancing the iterator.
@@ -920,7 +936,6 @@ pub const Lexer = struct {
                                     logger.Range{ .loc = .{ .start = @as(i32, @intCast(octal_start)) }, .len = @as(i32, @intCast(iter.i - octal_start)) },
                                     "Invalid legacy octal literal",
                                     .{},
-                                    false,
                                 ) catch unreachable;
                             }
                         },
@@ -1032,7 +1047,6 @@ pub const Lexer = struct {
                                         .{ .loc = .{ .start = @as(i32, @intCast(start + hex_start)) }, .len = @as(i32, @intCast((iter.i - hex_start))) },
                                         "Unicode escape sequence is out of range",
                                         .{},
-                                        true,
                                     );
                                     return;
                                 }
@@ -1128,7 +1142,7 @@ pub const Lexer = struct {
             }
         };
 
-        try lexer.addRangeError(lexer.range(), "Unexpected {s}", .{found}, true);
+        try lexer.addRangeError(lexer.range(), "Unexpected {s}", .{found});
     }
 
     pub fn expectedString(self: *Lexer, text: string) !void {
@@ -1140,7 +1154,7 @@ pub const Lexer = struct {
             }
         };
 
-        try self.addRangeError(self.range(), "Expected {s} but found {s}", .{ text, found }, true);
+        try self.addRangeError(self.range(), "Expected {s} but found {s}", .{ text, found });
     }
 
     pub fn range(self: *Lexer) logger.Range {
@@ -1150,12 +1164,13 @@ pub const Lexer = struct {
         };
     }
 
-    pub fn init(log: *logger.Log, source: logger.Source, allocator: std.mem.Allocator) !Lexer {
+    pub fn init(log: *logger.Log, source: logger.Source, allocator: std.mem.Allocator, redact_logs: bool) !Lexer {
         var lex = Lexer{
             .log = log,
             .source = source,
             .prev_error_loc = logger.Loc.Empty,
             .allocator = allocator,
+            .should_redact_logs = redact_logs,
         };
         lex.step();
         try lex.next();
@@ -1169,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/toml/toml_parser.zig b/src/toml/toml_parser.zig
index 25d760526a..b569be7495 100644
--- a/src/toml/toml_parser.zig
+++ b/src/toml/toml_parser.zig
@@ -81,9 +81,9 @@ pub const TOML = struct {
     log: *logger.Log,
     allocator: std.mem.Allocator,
 
-    pub fn init(allocator: std.mem.Allocator, source_: logger.Source, log: *logger.Log) !TOML {
+    pub fn init(allocator: std.mem.Allocator, source_: logger.Source, log: *logger.Log, redact_logs: bool) !TOML {
         return TOML{
-            .lexer = try Lexer.init(log, source_, allocator),
+            .lexer = try Lexer.init(log, source_, allocator, redact_logs),
             .allocator = allocator,
             .log = log,
         };
@@ -166,7 +166,7 @@ pub const TOML = struct {
         return head;
     }
 
-    pub fn parse(source_: *const logger.Source, log: *logger.Log, allocator: std.mem.Allocator) !Expr {
+    pub fn parse(source_: *const logger.Source, log: *logger.Log, allocator: std.mem.Allocator, redact_logs: bool) !Expr {
         switch (source_.contents.len) {
             // This is to be consisntent with how disabled JS files are handled
             0 => {
@@ -175,7 +175,7 @@ pub const TOML = struct {
             else => {},
         }
 
-        var parser = try TOML.init(allocator, source_.*, log);
+        var parser = try TOML.init(allocator, source_.*, log, redact_logs);
 
         return try parser.runParser();
     }
diff --git a/src/url.zig b/src/url.zig
index 38e3b6aab1..3e7260aa8a 100644
--- a/src/url.zig
+++ b/src/url.zig
@@ -977,13 +977,13 @@ 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);
+        const args_ = callframe.arguments_old(2);
 
         const args = args_.ptr[0..2];
 
@@ -997,8 +997,7 @@ pub const FormData = struct {
         };
 
         if (input_value.isEmptyOrUndefinedOrNull()) {
-            globalThis.throwInvalidArguments("input must not be empty", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("input must not be empty", .{});
         }
 
         if (!boundary_value.isEmptyOrUndefinedOrNull()) {
@@ -1006,13 +1005,12 @@ pub const FormData = struct {
                 if (array_buffer.byteSlice().len > 0)
                     encoding = .{ .Multipart = array_buffer.byteSlice() };
             } else if (boundary_value.isString()) {
-                boundary_slice = boundary_value.toSliceOrNull(globalThis) orelse return .zero;
+                boundary_slice = try boundary_value.toSliceOrNull(globalThis);
                 if (boundary_slice.len > 0) {
                     encoding = .{ .Multipart = boundary_slice.slice() };
                 }
             } else {
-                globalThis.throwInvalidArguments("boundary must be a string or ArrayBufferView", .{});
-                return .zero;
+                return globalThis.throwInvalidArguments("boundary must be a string or ArrayBufferView", .{});
             }
         }
         var input_slice = JSC.ZigString.Slice{};
@@ -1022,22 +1020,19 @@ pub const FormData = struct {
         if (input_value.asArrayBuffer(globalThis)) |array_buffer| {
             input = array_buffer.byteSlice();
         } else if (input_value.isString()) {
-            input_slice = input_value.toSliceOrNull(globalThis) orelse return .zero;
+            input_slice = try input_value.toSliceOrNull(globalThis);
             input = input_slice.slice();
         } else if (input_value.as(JSC.WebCore.Blob)) |blob| {
             input = blob.sharedView();
         } else {
-            globalThis.throwInvalidArguments("input must be a string or ArrayBufferView", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments("input must be a string or ArrayBufferView", .{});
         }
 
-        return FormData.toJS(globalThis, input, encoding) catch |err| {
-            globalThis.throwError(err, "while parsing FormData");
-            return .zero;
-        };
+        return FormData.toJS(globalThis, input, encoding) catch |err| return globalThis.throwError(err, "while parsing FormData");
     }
 
     comptime {
+        const jsFunctionFromMultipartData = JSC.toJSHostFunction(fromMultipartData);
         if (!JSC.is_bindgen)
             @export(jsFunctionFromMultipartData, .{ .name = "FormData__jsFunctionFromMultipartData" });
     }
diff --git a/src/watcher.zig b/src/watcher.zig
index b8bfbc2574..1a412eb7ef 100644
--- a/src/watcher.zig
+++ b/src/watcher.zig
@@ -510,6 +510,31 @@ pub const WatchEvent = struct {
         rename: bool = false,
         write: bool = false,
         move_to: bool = false,
+
+        pub fn merge(before: Op, after: Op) Op {
+            return .{
+                .delete = before.delete or after.delete,
+                .write = before.write or after.write,
+                .metadata = before.metadata or after.metadata,
+                .rename = before.rename or after.rename,
+                .move_to = before.move_to or after.move_to,
+            };
+        }
+
+        pub fn format(op: Op, comptime _: []const u8, _: std.fmt.FormatOptions, w: anytype) !void {
+            try w.writeAll("{");
+            var first = true;
+            inline for (comptime std.meta.fieldNames(Op)) |name| {
+                if (@field(op, name)) {
+                    if (!first) {
+                        try w.writeAll(",");
+                    }
+                    first = false;
+                    try w.writeAll(name);
+                }
+            }
+            try w.writeAll("}");
+        }
     };
 };
 
@@ -535,12 +560,17 @@ pub fn getHash(filepath: string) HashType {
     return @as(HashType, @truncate(bun.hash(filepath)));
 }
 
-// TODO: this should not be a function with a generic context. every function
-// besides `watchLoop` does not refer to context.
-pub fn NewWatcher(comptime ContextType: type) type {
-    return struct {
+// TODO: Rename to `Watcher` and make a top-level struct.
+// `if(true)` is to reduce git diff from when it was changed
+// from a comptime function to a basic struct.
+pub const NewWatcher = if (true)
+    struct {
         const Watcher = @This();
 
+        pub const Event = WatchEvent;
+        pub const Item = WatchItem;
+        pub const ItemList = WatchList;
+
         watchlist: WatchList,
         watched_count: usize = 0,
         mutex: Mutex,
@@ -551,7 +581,10 @@ pub fn NewWatcher(comptime ContextType: type) type {
         watch_events: [128]WatchEvent = undefined,
         changed_filepaths: [128]?[:0]u8 = [_]?[:0]u8{null} ** 128,
 
-        ctx: ContextType,
+        ctx: *anyopaque,
+        onFileUpdate: *const fn (this: *anyopaque, events: []WatchEvent, changed_files: []?[:0]u8, watchlist: WatchList) void,
+        onError: *const fn (this: *anyopaque, err: bun.sys.Error) void,
+
         fs: *bun.fs.FileSystem,
         allocator: std.mem.Allocator,
         watchloop_handle: ?std.Thread.Id = null,
@@ -563,9 +596,24 @@ pub fn NewWatcher(comptime ContextType: type) type {
         evict_list: [WATCHER_MAX_LIST]WatchItemIndex = undefined,
         evict_list_i: WatchItemIndex = 0,
 
+        thread_lock: bun.DebugThreadLock = bun.DebugThreadLock.unlocked,
+
         const no_watch_item: WatchItemIndex = std.math.maxInt(WatchItemIndex);
 
-        pub fn init(ctx: ContextType, fs: *bun.fs.FileSystem, allocator: std.mem.Allocator) !*Watcher {
+        pub fn init(comptime T: type, ctx: *T, fs: *bun.fs.FileSystem, allocator: std.mem.Allocator) !*Watcher {
+            const wrapped = struct {
+                fn onFileUpdateWrapped(ctx_opaque: *anyopaque, events: []WatchEvent, changed_files: []?[:0]u8, watchlist: WatchList) void {
+                    T.onFileUpdate(@alignCast(@ptrCast(ctx_opaque)), events, changed_files, watchlist);
+                }
+                fn onErrorWrapped(ctx_opaque: *anyopaque, err: bun.sys.Error) void {
+                    if (@hasDecl(T, "onWatchError")) {
+                        T.onWatchError(@alignCast(@ptrCast(ctx_opaque)), err);
+                    } else {
+                        T.onError(@alignCast(@ptrCast(ctx_opaque)), err);
+                    }
+                }
+            };
+
             const watcher = try allocator.create(Watcher);
             errdefer allocator.destroy(watcher);
 
@@ -573,10 +621,13 @@ pub fn NewWatcher(comptime ContextType: type) type {
                 .fs = fs,
                 .allocator = allocator,
                 .watched_count = 0,
-                .ctx = ctx,
                 .watchlist = WatchList{},
                 .mutex = .{},
                 .cwd = fs.top_level_dir,
+
+                .ctx = ctx,
+                .onFileUpdate = &wrapped.onFileUpdateWrapped,
+                .onError = &wrapped.onErrorWrapped,
             };
 
             try PlatformWatcher.init(&watcher.platform, fs.top_level_dir);
@@ -614,6 +665,7 @@ pub fn NewWatcher(comptime ContextType: type) type {
         // This must only be called from the watcher thread
         pub fn watchLoop(this: *Watcher) !void {
             this.watchloop_handle = std.Thread.getCurrentId();
+            this.thread_lock.lock();
             Output.Source.configureNamedThread("File Watcher");
 
             defer Output.flush();
@@ -624,7 +676,7 @@ pub fn NewWatcher(comptime ContextType: type) type {
                     this.watchloop_handle = null;
                     this.platform.stop();
                     if (this.running) {
-                        this.ctx.onError(err);
+                        this.onError(this.ctx, err);
                     }
                 },
                 .result => {},
@@ -745,7 +797,7 @@ pub fn NewWatcher(comptime ContextType: type) type {
                     this.mutex.lock();
                     defer this.mutex.unlock();
                     if (this.running) {
-                        this.ctx.onFileUpdate(watchevents, this.changed_filepaths[0..watchevents.len], this.watchlist);
+                        this.onFileUpdate(this.ctx, watchevents, this.changed_filepaths[0..watchevents.len], this.watchlist);
                     } else {
                         break;
                     }
@@ -821,7 +873,7 @@ pub fn NewWatcher(comptime ContextType: type) type {
                         this.mutex.lock();
                         defer this.mutex.unlock();
                         if (this.running) {
-                            this.ctx.onFileUpdate(all_events[0 .. last_event_index + 1], this.changed_filepaths[0 .. name_off + 1], this.watchlist);
+                            this.onFileUpdate(this.ctx, all_events[0 .. last_event_index + 1], this.changed_filepaths[0 .. name_off + 1], this.watchlist);
                         } else {
                             break;
                         }
@@ -917,7 +969,7 @@ pub fn NewWatcher(comptime ContextType: type) type {
 
                     log("calling onFileUpdate (all_events.len = {d})", .{all_events.len});
 
-                    this.ctx.onFileUpdate(all_events, this.changed_filepaths[0 .. last_event_index + 1], this.watchlist);
+                    this.onFileUpdate(this.ctx, all_events, this.changed_filepaths[0 .. last_event_index + 1], this.watchlist);
                 }
             }
 
@@ -1202,20 +1254,17 @@ pub fn NewWatcher(comptime ContextType: type) type {
             file_path: string,
             hash: HashType,
             comptime copy_file_path: bool,
-        ) bun.JSC.Maybe(void) {
+        ) bun.JSC.Maybe(WatchItemIndex) {
             this.mutex.lock();
             defer this.mutex.unlock();
 
-            if (this.indexOf(hash) != null) {
-                return .{ .result = {} };
+            if (this.indexOf(hash)) |idx| {
+                return .{ .result = @truncate(idx) };
             }
 
             this.watchlist.ensureUnusedCapacity(this.allocator, 1) catch bun.outOfMemory();
 
-            return switch (this.appendDirectoryAssumeCapacity(fd, file_path, hash, copy_file_path)) {
-                .err => |err| .{ .err = err },
-                .result => .{ .result = {} },
-            };
+            return this.appendDirectoryAssumeCapacity(fd, file_path, hash, copy_file_path);
         }
 
         pub fn addFile(
@@ -1280,7 +1329,15 @@ pub fn NewWatcher(comptime ContextType: type) type {
         }
 
         pub fn getResolveWatcher(watcher: *Watcher) bun.resolver.AnyResolveWatcher {
-            return bun.resolver.ResolveWatcher(*@This(), @typeInfo(ContextType).Pointer.child.onMaybeWatchDirectory).init(watcher);
+            return bun.resolver.ResolveWatcher(*@This(), onMaybeWatchDirectory).init(watcher);
+        }
+
+        pub fn onMaybeWatchDirectory(watch: *Watcher, file_path: string, dir_fd: bun.StoredFileDescriptorType) void {
+            // We don't want to watch:
+            // - Directories outside the root directory
+            // - Directories inside node_modules
+            if (std.mem.indexOf(u8, file_path, "node_modules") == null and std.mem.indexOf(u8, file_path, watch.fs.top_level_dir) != null) {
+                _ = watch.addDirectory(dir_fd, file_path, getHash(file_path), false);
+            }
         }
     };
-}
diff --git a/src/windows.zig b/src/windows.zig
index 08573d4b30..e0e31a1fc9 100644
--- a/src/windows.zig
+++ b/src/windows.zig
@@ -3387,8 +3387,8 @@ pub fn winSockErrorToZigError(err: std.os.windows.ws2_32.WinsockError) !void {
     };
 }
 
-pub fn WSAGetLastError() !void {
-    return winSockErrorToZigError(std.os.windows.ws2_32.WSAGetLastError());
+pub fn WSAGetLastError() ?SystemErrno {
+    return SystemErrno.init(@intFromEnum(std.os.windows.ws2_32.WSAGetLastError()));
 }
 
 // BOOL CreateDirectoryExW(
diff --git a/src/windows_c.zig b/src/windows_c.zig
index 9bc134f091..7c0c5d0d9e 100644
--- a/src/windows_c.zig
+++ b/src/windows_c.zig
@@ -690,8 +690,9 @@ pub const SystemErrno = enum(u16) {
     }
 
     pub fn init(code: anytype) ?SystemErrno {
-        if (comptime @TypeOf(code) == u16) {
-            if (code <= 3950) {
+        if (@TypeOf(code) == u16 or (@TypeOf(code) == c_int and code > 0)) {
+            // Win32Error and WSA Error codes
+            if (code <= @intFromEnum(Win32Error.IO_REISSUE_AS_CACHED) or (code >= @intFromEnum(Win32Error.WSAEINTR) and code <= @intFromEnum(Win32Error.WSA_QOS_RESERVED_PETYPE))) {
                 return init(@as(Win32Error, @enumFromInt(code)));
             } else {
                 if (comptime bun.Environment.allow_assert)
@@ -1319,6 +1320,9 @@ pub fn getErrno(_: anytype) E {
         return sys.toE();
     }
 
+    if (bun.windows.WSAGetLastError()) |wsa| {
+        return wsa.toE();
+    }
     return .SUCCESS;
 }
 
diff --git a/src/work_pool.zig b/src/work_pool.zig
index b9e1bd1573..380dfacfd8 100644
--- a/src/work_pool.zig
+++ b/src/work_pool.zig
@@ -14,14 +14,7 @@ pub fn NewWorkPool(comptime max_threads: ?usize) type {
             @setCold(true);
 
             pool = ThreadPool.init(.{
-                .max_threads = max_threads orelse @max(2, max_threads: {
-                    if (bun.getenvZ("GOMAXPROCS")) |max_procs| try_override: {
-                        break :max_threads std.fmt.parseInt(u32, max_procs, 10) catch
-                            break :try_override;
-                    }
-
-                    break :max_threads @as(u32, @truncate(std.Thread.getCpuCount() catch 0));
-                }),
+                .max_threads = max_threads orelse bun.getThreadCount(),
                 .stack_size = ThreadPool.default_thread_stack_size,
             });
             return &pool;
diff --git a/src/zlib.zig b/src/zlib.zig
index b141b9137b..537d047709 100644
--- a/src/zlib.zig
+++ b/src/zlib.zig
@@ -66,7 +66,7 @@ pub const z_streamp = @import("zlib-internal").z_streamp;
 // } z_stream;
 
 const DataType = @import("zlib-internal").DataType;
-const FlushValue = @import("zlib-internal").FlushValue;
+pub const FlushValue = @import("zlib-internal").FlushValue;
 pub const ReturnCode = @import("zlib-internal").ReturnCode;
 
 // ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm));
@@ -659,7 +659,7 @@ pub extern fn deflate(strm: z_streamp, flush: FlushValue) ReturnCode;
 ///   deallocated).
 pub extern fn deflateEnd(stream: z_streamp) ReturnCode;
 
-pub extern fn deflateReset(stream: z_streamp) c_int;
+pub extern fn deflateReset(stream: z_streamp) ReturnCode;
 
 //   deflateBound() returns an upper bound on the compressed size after
 //  deflation of sourceLen bytes.  It must be called after deflateInit() or
@@ -940,280 +940,3 @@ pub const ZlibCompressorArrayList = struct {
         }
     }
 };
-
-const CHUNK = 1024 * 64;
-
-pub const ZlibCompressorStreaming = struct {
-    mode: NodeMode,
-    state: z_stream = std.mem.zeroes(z_stream),
-    chunkSize: c_uint,
-    flush: FlushValue = .NoFlush,
-    finishFlush: FlushValue = .Finish,
-    fullFlush: FlushValue = .FullFlush,
-    level: c_int,
-    windowBits: c_int,
-    memLevel: c_int,
-    strategy: c_int,
-    dictionary: []const u8,
-    err: ReturnCode = .Ok,
-    err_msg: ?[*:0]const u8 = null,
-
-    pub fn init(this: *ZlibCompressorStreaming) !void {
-        const ret_code = deflateInit2_(&this.state, this.level, 8, this.windowBits, this.memLevel, this.strategy, zlibVersion(), @sizeOf(z_stream));
-        if (ret_code != .Ok) return error.ZlibError9;
-
-        this.setDictionary() catch {};
-        this.err_msg = null;
-        return;
-    }
-
-    fn setDictionary(this: *ZlibCompressorStreaming) !void {
-        switch (this.mode) {
-            .DEFLATE, .DEFLATERAW => {
-                this.err = deflateSetDictionary(&this.state, this.dictionary.ptr, @intCast(this.dictionary.len));
-            },
-            .INFLATERAW => {
-                this.err = inflateSetDictionary(&this.state, this.dictionary.ptr, @intCast(this.dictionary.len));
-            },
-            else => {},
-        }
-        if (this.err != .Ok) {
-            return error.ZlibFailedSetDictionary;
-        }
-    }
-
-    pub fn params(this: *ZlibCompressorStreaming, level: c_int, strategy: c_int) void {
-        const err = deflateParams(&this.state, level, strategy);
-        bun.debugAssert(err == .Ok);
-        this.level = level;
-        this.strategy = strategy;
-    }
-
-    pub fn write(this: *ZlibCompressorStreaming, bytes: []const u8, output: *std.ArrayListUnmanaged(u8), process_all_input: bool) !void {
-        const state = &this.state;
-        state.next_in = bytes.ptr;
-        state.avail_in = @intCast(bytes.len);
-        if (state.avail_in == 0) state.next_in = null;
-
-        if (!process_all_input) return;
-        while (true) {
-            if (try this.doWork(output, this.flush)) {
-                break;
-            }
-        }
-        // bun.assert(state.avail_in == 0);
-    }
-
-    pub fn doWork(this: *ZlibCompressorStreaming, output: *std.ArrayListUnmanaged(u8), flush: FlushValue) !bool {
-        const state = &this.state;
-        var out: [CHUNK]u8 = undefined;
-        state.avail_out = CHUNK;
-        state.next_out = &out;
-
-        this.err = deflate(state, flush);
-        bun.assert(this.err != .StreamError);
-        const have = CHUNK - state.avail_out;
-        try output.appendSlice(bun.default_allocator, out[0..have]);
-        if (state.avail_out == 0) return false;
-        return true;
-    }
-
-    pub fn end(this: *ZlibCompressorStreaming, output: *std.ArrayListUnmanaged(u8)) !void {
-        const state = &this.state;
-        state.next_in = null;
-        state.avail_in = 0;
-
-        const done = try this.doWork(output, this.finishFlush);
-        bun.assert(done);
-        // bun.assert(state.avail_in == 0);
-
-        const ret = deflateEnd(&this.state);
-        bun.assert(ret == .Ok or ret == .StreamEnd);
-        if (this.err != .StreamEnd and this.finishFlush == .Finish) return error.ZlibError10;
-    }
-};
-
-pub const ZlibDecompressorStreaming = struct {
-    mode: NodeMode,
-    state: z_stream = std.mem.zeroes(z_stream),
-    chunkSize: c_uint,
-    next_expected_header_byte: ?[*]const u8 = null,
-    gzip_id_bytes_read: u16 = 0,
-    flush: FlushValue = .NoFlush,
-    finishFlush: FlushValue = .Finish,
-    fullFlush: FlushValue = .FullFlush,
-    windowBits: c_int,
-    dictionary: []const u8,
-    err: ReturnCode = .Ok,
-    err_msg: ?[*:0]const u8 = null,
-    do_inflate_loop: bool = true,
-
-    pub fn init(this: *ZlibDecompressorStreaming) !void {
-        const ret_code = inflateInit2_(&this.state, this.windowBits, zlibVersion(), @sizeOf(z_stream));
-        if (ret_code != .Ok) return error.ZlibError1;
-
-        this.setDictionary() catch {};
-        this.err_msg = null;
-        return;
-    }
-
-    fn setDictionary(this: *ZlibDecompressorStreaming) !void {
-        this.err = .Ok;
-        const dictionary = this.dictionary;
-        switch (this.mode) {
-            .DEFLATE, .DEFLATERAW => {
-                if (dictionary.len > 0) this.err = deflateSetDictionary(&this.state, dictionary.ptr, @intCast(dictionary.len));
-            },
-            .INFLATERAW => {
-                if (dictionary.len > 0) this.err = inflateSetDictionary(&this.state, dictionary.ptr, @intCast(dictionary.len));
-            },
-            else => {},
-        }
-        if (this.err != .Ok) {
-            return this.error_for_message("Failed to set dictionary");
-        }
-    }
-
-    fn error_for_message(this: *ZlibDecompressorStreaming, default: [*:0]const u8) error{ZlibError} {
-        var message = default;
-        if (this.state.err_msg) |msg| message = msg;
-        this.err_msg = message;
-        return error.ZlibError;
-    }
-
-    pub fn writeAll(this: *ZlibDecompressorStreaming, bytes: []const u8, output: *std.ArrayListUnmanaged(u8), process_all_input: bool) !void {
-        var index: usize = 0;
-        while (index != bytes.len) {
-            index += try this.write(bytes[index..], output, process_all_input);
-        }
-    }
-
-    fn write(this: *ZlibDecompressorStreaming, bytes: []const u8, output: *std.ArrayListUnmanaged(u8), process_all_input: bool) !usize {
-        const state = &this.state;
-        state.next_in = bytes.ptr;
-        state.avail_in = @intCast(bytes.len);
-        if (state.avail_in == 0) state.next_in = null;
-
-        // UNZIP mode allows the input to be either gzip or deflate data and we do a two-byte header detection in order to disambiguate.
-        // the ordering of this logic is a bit abstract because we dont know ahead of time how large 'bytes' will be.
-        // additionally, if the first byte is "correct" but the second is not, we don't want to lose it from it being consumed.
-        // Ref: https://github.com/nodejs/node/blob/v22.8.0/src/node_zlib.cc#L777
-        if (this.mode == .UNZIP) {
-            var redd: usize = 0;
-            this.do_inflate_loop = false;
-
-            if (bytes.len > 0) {
-                this.next_expected_header_byte = state.next_in;
-            }
-            if (this.gzip_id_bytes_read == 0) {
-                if (this.next_expected_header_byte == null) {
-                    return 0;
-                }
-
-                if (this.next_expected_header_byte.?[redd] == GZIP_HEADER_ID1) {
-                    this.gzip_id_bytes_read += 1;
-                    redd += 1;
-                    // next_expected_header_byte++;
-
-                    if (bytes.len == 1) {
-                        // The only available byte was already read.
-                        return 1;
-                    }
-                } else {
-                    // the stream did not match the gzip header, bail.
-                    this.mode = .INFLATE;
-                    return 0;
-                }
-            }
-            if (this.gzip_id_bytes_read == 1) {
-                if (this.next_expected_header_byte == null) {
-                    return 0;
-                }
-
-                if (this.next_expected_header_byte.?[redd] == GZIP_HEADER_ID2) {
-                    this.gzip_id_bytes_read += 1;
-                    redd += 1;
-                    // next_expected_header_byte++;
-
-                    // the gzip header was found. send the header to inflate() and tell writeAll how much we read to do this detection
-                    // if we continued to doWork right now GZIP_HEADER_ID2 might get processed twice.
-                    this.mode = .GUNZIP;
-                    {
-                        const header = &[_]u8{ GZIP_HEADER_ID1, GZIP_HEADER_ID2 };
-                        state.next_in = header.ptr;
-                        state.avail_in = @intCast(header.len);
-                        var out: [1]u8 = .{0};
-                        state.avail_out = 0;
-                        state.next_out = &out; // passing a null pointer here causes it to return Z_STREAM_ERROR so we send zero-length instead.
-                        const ret = inflate(state, this.flush);
-                        bun.assert(ret == .Ok);
-                    }
-                } else {
-                    // There is no actual difference between INFLATE and INFLATERAW (after initialization).
-                    // the stream only partially matched the gzip header, bail.
-                    this.mode = .INFLATE;
-                }
-                return redd;
-            }
-
-            bun.assert(false); // invalid number of gzip magic number bytes read
-        }
-
-        // we're passed the header or there was no header. it is now safe to send everying to inflate().
-        this.do_inflate_loop = true;
-        if (!process_all_input) return bytes.len;
-        while (true) {
-            if (try this.doWork(output, this.flush)) {
-                break;
-            }
-        }
-        // bun.assert(state.avail_in == 0);
-
-        return bytes.len;
-    }
-
-    pub fn doWork(this: *ZlibDecompressorStreaming, output: *std.ArrayListUnmanaged(u8), flush: FlushValue) !bool {
-        const state = &this.state;
-        var out: [CHUNK]u8 = undefined;
-        const len = @min(CHUNK, this.chunkSize);
-        state.avail_out = len;
-        state.next_out = &out;
-
-        this.err = inflate(state, flush);
-        const ret = this.err;
-        bun.assert(ret != .StreamError);
-        if (ret == .NeedDict) return this.error_for_message((if (this.dictionary.len == 0) "Missing dictionary" else "Bad dictionary").ptr);
-        if (ret == .DataError) return this.error_for_message("Zlib error");
-        if (ret == .MemError) return error.ZlibError4;
-        const have = len - state.avail_out;
-        try output.appendSlice(bun.default_allocator, out[0..have]);
-        if (ret == .StreamEnd and this.mode == .GUNZIP and state.avail_in > 0 and state.next_in.?[0] != 0) {
-            _ = inflateReset(state);
-            return false;
-        }
-        if (ret == .StreamEnd) return true;
-        if (state.avail_out == 0) return false;
-        if (ret == .BufError and flush == .Finish) return this.error_for_message("unexpected end of file");
-        return true;
-    }
-
-    pub fn end(this: *ZlibDecompressorStreaming, output: *std.ArrayListUnmanaged(u8)) !void {
-        const state = &this.state;
-        state.next_in = null;
-        state.avail_in = 0;
-
-        const done = try this.doWork(output, this.finishFlush);
-        bun.assert(done);
-        // bun.assert(state.avail_in == 0);
-
-        const ret = inflateEnd(&this.state);
-        bun.assert(ret == .Ok or ret == .StreamEnd);
-        if (this.err != .StreamEnd and this.finishFlush == .Finish) return error.ZlibError8;
-    }
-};
-
-//
-//
-
-const GZIP_HEADER_ID1: u8 = 0x1f;
-const GZIP_HEADER_ID2: u8 = 0x8b;
diff --git a/test/bake/dev-server-harness.ts b/test/bake/dev-server-harness.ts
new file mode 100644
index 0000000000..49cf8f572e
--- /dev/null
+++ b/test/bake/dev-server-harness.ts
@@ -0,0 +1,422 @@
+/// <reference path="../../src/bake/bake.d.ts" />
+import { Bake, Subprocess } from "bun";
+import fs from "node:fs";
+import path, { resolve } from "node:path";
+import os from "node:os";
+import assert from "node:assert";
+import { test } from "bun:test";
+import { EventEmitter } from "node:events";
+// @ts-ignore
+import { dedent } from "../bundler/expectBundled.ts";
+import { bunEnv, isWindows, mergeWindowEnvs } from "harness";
+import { expect } from "bun:test";
+
+/** For testing bundler related bugs in the DevServer */
+export const minimalFramework: Bake.Framework = {
+  fileSystemRouterTypes: [
+    {
+      root: "routes",
+      style: "nextjs-pages",
+      serverEntryPoint: require.resolve("./minimal.server.ts"),
+    },
+  ],
+  serverComponents: {
+    separateSSRGraph: false,
+    serverRuntimeImportSource: require.resolve("./minimal.server.ts"),
+    serverRegisterClientReferenceExport: "registerClientReference",
+  },
+};
+
+export type DevServerTest = ({
+  /** Starting files */
+  files: FileObject;
+  /**
+   * Framework to use. Consider `minimalFramework` if possible.
+   * Provide this object or `files['bun.app.ts']` for a dynamic one.
+   */
+  framework?: Bake.Framework | "react";
+  /**
+   * Source code for a TSX file that `export default`s an array of BunPlugin,
+   * combined with the `framework` option.
+   */
+  pluginFile?: string;
+} | {
+  /** 
+   * Copy all files from test/bake/fixtures/<name>
+   * This directory must contain `bun.app.ts` to allow hacking on fixtures manually via `bun run .`
+   */
+  fixture: string;
+}) & {
+  test: (dev: Dev) => Promise<void>;
+}
+
+type FileObject = Record<string, string | Buffer>;
+
+export class Dev {
+  rootDir: string;
+  port: number;
+  baseUrl: string;
+  panicked = false;
+
+  // These properties are not owned by this class
+  devProcess: Subprocess<"pipe", "pipe", "pipe">;
+  output: OutputLineStream;
+
+  constructor(root: string, port: number, process: Subprocess<"pipe", "pipe", "pipe">, stream: OutputLineStream) {
+    this.rootDir = root;
+    this.port = port;
+    this.baseUrl = `http://localhost:${port}`;
+    this.devProcess = process;
+    this.output = stream;
+    this.output.on("panic", () => {
+      this.panicked = true;
+    });
+  }
+
+  fetch(url: string, init?: RequestInit) {
+    return new DevFetchPromise((resolve, reject) =>
+      fetch(new URL(url, this.baseUrl).toString(), init).then(resolve, reject),
+      this
+    );
+  }
+
+  fetchJSON(url: string, object: any) {
+    return this.fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(object),
+    });
+  }
+
+  write(file: string, contents: string) {
+    const wait = this.waitForHotReload();
+    // TODO: consider using IncomingMessageId.virtual_file_change to reduce theoretical flakiness.
+    fs.writeFileSync(this.join(file), contents);
+    return wait;
+  }
+
+  patch(file: string, { find, replace }: { find: string; replace: string }) {
+    const wait = this.waitForHotReload();
+    const filename = this.join(file);
+    const source = fs.readFileSync(filename, "utf8");
+    const contents = source.replace(find, replace);
+    if (contents === source) {
+      throw new Error(`Couldn't find and replace ${JSON.stringify(find)} in ${file}`);
+    }
+    // TODO: consider using IncomingMessageId.virtual_file_change to reduce theoretical flakiness.
+    fs.writeFileSync(filename, contents);
+    return wait;
+  }
+
+  join(file: string) {
+    return path.join(this.rootDir, file);
+  }
+
+  async waitForHotReload() {
+    const err = this.output.waitForLine(/error/i);
+    const success = this.output.waitForLine(/bundled route|reloaded/i);
+    await Promise.race([
+      // On failure, give a little time in case a partial write caused a
+      // bundling error, and a success came in.
+      err.then(() => Bun.sleep(500), () => {}), 
+      success,
+    ]);
+  }
+
+  async [Symbol.asyncDispose]() {}
+}
+
+type StepFn = (dev: Dev) => Promise<void>;
+
+export interface Step {
+  run: StepFn;
+  caller: string;
+  name?: string;
+}
+
+class DevFetchPromise extends Promise<Response> {
+  dev: Dev;
+  constructor(executor: (resolve: (value: Response | PromiseLike<Response>) => void, reject: (reason?: any) => void) => void, dev: Dev) {
+    super(executor);
+    this.dev = dev;
+  }
+
+  expect(result: any) {
+    if (typeof result !== "string") {
+      result = JSON.stringify(result);
+    }
+    return withAnnotatedStack(snapshotCallerLocation(), async () => {
+      try {
+        const res = await this;
+        if (!res.ok) {
+          throw new Error(`Expected response to be ok, but got ${res.status} ${res.statusText}`);
+        }
+        const text = (await res.text()).trim();
+        expect(text).toBe(result.trim());
+      } catch (err) {
+        if (this.dev.panicked) {
+          throw new Error("DevServer crashed");
+        }
+        throw err;
+      }
+    });
+  }
+  expectNoSpaces(result: string) {
+    expect(result).not.toMatch(/\s/);
+    return withAnnotatedStack(snapshotCallerLocation(), async () => {
+      const res = await this;
+      if (!res.ok) {
+        throw new Error(`Expected response to be ok, but got ${res.status} ${res.statusText}`);
+      }
+      const text = (await res.text()).replace(/\s/g, "");
+      expect(text).toBe(result.trim());
+    });
+  }
+  async text() {
+    return (await this).text();
+  }
+  async json() {
+    return (await this).json();
+  }
+}
+
+function snapshotCallerLocation(): string {
+  const stack = new Error().stack!;
+  const lines = stack.split("\n");
+  let i = 1;
+  for (; i < lines.length; i++) {
+    if (!lines[i].includes(import.meta.filename)) {
+      return lines[i];
+    }
+  }
+  throw new Error("Couldn't find caller location in stack trace");
+}
+
+function stackTraceFileName(line: string): string {
+  return / \(((?:[A-Za-z]:)?.*?)[:)]/.exec(line)![1].replaceAll("\\", "/");
+}
+
+async function withAnnotatedStack<T>(stackLine: string, cb: () => Promise<T>): Promise<T> {
+  try {
+    return await cb();
+  } catch (err: any) {
+    console.log();
+    const oldStack = err.stack;
+    const newError = new Error(err?.message ?? oldStack.slice(0, oldStack.indexOf("\n    at ")));
+    newError.stack = `${newError.message}\n${stackLine}\n    at \x1b[1moriginal stack:\x1b[0m ()\n${oldStack}`;
+    throw newError;
+  }
+}
+
+const tempDir = fs.mkdtempSync(
+  path.join(process.platform === "darwin" && !process.env.CI ? "/tmp" : os.tmpdir(), "bun-dev-test-"),
+);
+const devTestRoot = path.join(import.meta.dir, "dev").replaceAll("\\", "/");
+const counts: Record<string, number> = {};
+
+console.log("Dev server testing directory:", tempDir);
+
+function writeAll(root: string, files: FileObject) {
+  for (const [file, contents] of Object.entries(files)) {
+    const filename = path.join(root, file);
+    fs.mkdirSync(path.dirname(filename), { recursive: true });
+    const formattedContents =
+      typeof contents === "string" ? dedent(contents).replaceAll("{{root}}", root.replaceAll("\\", "\\\\")) : contents;
+    fs.writeFileSync(filename, formattedContents as string);
+  }
+}
+
+class OutputLineStream extends EventEmitter {
+  reader1: ReadableStreamDefaultReader;
+  reader2: ReadableStreamDefaultReader;
+
+  lines: string[] = [];
+  cursor: number = 0;
+  disposed = false;
+  closes = 0;
+
+  constructor(readable1: ReadableStream, readable2: ReadableStream) {
+    super();
+
+    // @ts-ignore TODO: fix broken type definitions in @types/bun
+    const reader1 = (this.reader1 = readable1.getReader());
+    // @ts-ignore TODO: fix broken type definitions in @types/bun
+    const reader2 = (this.reader2 = readable2.getReader());
+
+    for (const reader of [reader1, reader2]) {
+      (async () => {
+        const td = new TextDecoder();
+        let last = "";
+        while (true) {
+          const { done, value } = (await reader.read()) as { done: boolean; value: Uint8Array };
+          if (done) break;
+          const clearScreenCode = "\x1B[2J\x1B[3J\x1B[H";
+          const text = last + td.decode(value, { stream: true }).replace(clearScreenCode, "");
+          const lines = text.split("\n");
+          last = lines.pop()!;
+          for (const line of lines) {
+            this.lines.push(line);
+            if (line.includes("============================================================")) {
+              this.emit("panic");
+            }
+            console.log("\x1b[0;30mdev|\x1b[0m", line);
+            this.emit("line", line);
+          }
+        }
+
+        this.closes++;
+        if (this.closes === 2) {
+          this.emit("close");
+        }
+        return;
+      })();
+    }
+  }
+
+  waitForLine(regex: RegExp, timeout = 1000): Promise<RegExpMatchArray> {
+    return new Promise((resolve, reject) => {
+      let ran = false;
+      let timer: any;
+      const reset = () => {
+        this.off("close", onClose);
+        this.off("line", onLine);
+        ran = true;
+        clearTimeout(timer);
+        timer = null!;
+      };
+      const onLine = (line: string) => {
+        let match;
+        if ((match = line.match(regex))) {
+          reset();
+          resolve(match);
+        }
+      };
+      const onClose = () => {
+        reset();
+        reject(new Error("Process exited before line " + JSON.stringify(regex.toString()) + " was found"));
+      };
+      this.on("line", onLine);
+      this.on("close", onClose);
+      timer = setTimeout(() => {
+        if (!ran) {
+          reset();
+          reject(new Error("Timeout waiting for line " + JSON.stringify(regex.toString())));
+        }
+      }, timeout);
+    });
+  }
+
+  [Symbol.dispose]() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.reader1.cancel();
+    this.reader2.cancel();
+    this.emit("close");
+  }
+}
+
+export function devTest<T extends DevServerTest>(description: string, options: T): T {
+  // Capture the caller name as part of the test tempdir
+  const callerLocation = snapshotCallerLocation();
+  const caller = stackTraceFileName(callerLocation);
+  const jest = (Bun as any).jest(caller);
+  assert(caller.startsWith(devTestRoot), "dev server tests must be in test/bake/dev, not " + caller);
+  const basename = path.basename(caller, ".test" + path.extname(caller));
+  const count = (counts[basename] = (counts[basename] ?? 0) + 1);
+
+  // TODO: Tests are too flaky on Windows. Cannot reproduce locally.
+  if (isWindows) {
+    jest.test.todo(`DevServer > ${basename}.${count}: ${description}`);
+    return options;
+  }
+
+  jest.test(`DevServer > ${basename}.${count}: ${description}`, async () => {
+    const root = path.join(tempDir, basename + count);
+    if ('files' in options) {
+      writeAll(root, options.files);
+      if (options.files["bun.app.ts"] == undefined) {
+        if (!options.framework) {
+          throw new Error("Must specify a options.framework or provide a bun.app.ts file");
+        }
+        if (options.pluginFile) {
+          fs.writeFileSync(path.join(root, "pluginFile.ts"), dedent(options.pluginFile));
+        }
+        fs.writeFileSync(
+          path.join(root, "bun.app.ts"),
+          dedent`
+            ${options.pluginFile ? 
+              `import plugins from './pluginFile.ts';` : "let plugins = undefined;"
+            }
+            export default {
+              app: {
+                framework: ${JSON.stringify(options.framework)},
+                plugins,
+              },
+            };
+          `,
+        );
+      } else {
+        if (options.pluginFile) {
+          throw new Error("Cannot provide both bun.app.ts and pluginFile");
+        }
+      }
+    } else {
+      if (!options.fixture) {
+        throw new Error("Must provide either `fixture` or `files`");
+      }
+      const fixture = path.join(devTestRoot, "../fixtures", options.fixture);
+      fs.cpSync(fixture, root, { recursive: true });
+
+      if(!fs.existsSync(path.join(root, "bun.app.ts"))) {
+        throw new Error(`Fixture ${fixture} must contain a bun.app.ts file.`); 
+      }
+      if (!fs.existsSync(path.join(root, "node_modules"))) {
+        // link the node_modules directory from test/node_modules to the temp directory
+        fs.symlinkSync(path.join(devTestRoot, "../../node_modules"), path.join(root, "node_modules"), "junction");
+      }
+    }
+    fs.writeFileSync(
+      path.join(root, "harness_start.ts"),
+      dedent`
+        import appConfig from "./bun.app.ts";
+        export default {
+          ...appConfig,
+          port: 0,
+        };
+      `,
+    );
+
+    await using devProcess = Bun.spawn({
+      cwd: root,
+      cmd: [process.execPath, "./harness_start.ts"],
+      env: mergeWindowEnvs([
+        bunEnv,
+        {
+          FORCE_COLOR: "1",
+          BUN_DEV_SERVER_TEST_RUNNER: "1",
+          BUN_DUMP_STATE_ON_CRASH: "1",
+        },
+      ]),
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    using stream = new OutputLineStream(devProcess.stdout, devProcess.stderr);
+    const port = parseInt((await stream.waitForLine(/localhost:(\d+)/))[1], 10);
+    await using dev = new Dev(root, port, devProcess, stream);
+
+    try {
+      await options.test(dev);
+    } catch (err: any) {
+      // const oldStack = err.stack;
+      // const editedCallerStep = callerLocation.replace(/\w*at.*?\(/, "at test defined at (");
+      // const main = dev.panicked
+      // ? `caused a DevServer crash`
+      // : `failed: ${oldStack.slice(0, oldStack.indexOf("\n    at "))}`;
+      // const newError = new Error(`Step ${n} ${main}`);
+      // newError.stack = `${newError.message}\n${editedCallerStep}\n    at \x1b[1moriginal stack:\x1b[0m ()\n${oldStack}`;
+      throw err;
+    }
+  });
+  return options;
+}
diff --git a/test/bake/dev/bundle.test.ts b/test/bake/dev/bundle.test.ts
new file mode 100644
index 0000000000..fe470080d8
--- /dev/null
+++ b/test/bake/dev/bundle.test.ts
@@ -0,0 +1,77 @@
+// Bundle tests are tests concerning bundling bugs that only occur in DevServer.
+import { devTest, minimalFramework } from "../dev-server-harness";
+
+devTest("import identifier doesnt get renamed", {
+  framework: minimalFramework,
+  files: {
+    "db.ts": `export const abc = "123";`,
+    "routes/index.ts": `
+      import { abc } from '../db';
+      export default function (req, meta) {
+        let v1 = "";
+        const v2 = v1
+          ? abc.toFixed(2)
+          : abc.toString();
+        return new Response('Hello, ' + v2 + '!');
+      }
+    `,
+  },
+  async test(dev) {
+    await dev.fetch("/").expect("Hello, 123!");
+    await dev.write("db.ts", `export const abc = "456";`);
+    await dev.fetch("/").expect("Hello, 456!");
+    await dev.patch("routes/index.ts", {
+      find: "Hello",
+      replace: "Bun",
+    });
+    await dev.fetch("/").expect("Bun, 456!");
+  },
+});
+devTest("symbol collision with import identifier", {
+  framework: minimalFramework,
+  files: {
+    "db.ts": `export const abc = "123";`,
+    "routes/index.ts": `
+      let import_db = 987;
+      import { abc } from '../db';
+      export default function (req, meta) {
+        let v1 = "";
+        const v2 = v1
+          ? abc.toFixed(2)
+          : abc.toString();
+        return new Response('Hello, ' + v2 + ', ' + import_db + '!');
+      }
+    `,
+  },
+  async test(dev) {
+    await dev.fetch("/").expect("Hello, 123, 987!");
+    await dev.write("db.ts", `export const abc = "456";`);
+    await dev.fetch("/").expect("Hello, 456, 987!");
+  },
+});
+devTest("uses \"development\" condition", {
+  framework: minimalFramework,
+  files: {
+    "node_modules/example/package.json": JSON.stringify({
+      name: "example",
+      version: "1.0.0",
+      exports: {
+        ".": {
+          development: "./development.js",
+          default: "./production.js",
+        },
+      },
+    }),
+    "node_modules/example/development.js": `export default "development";`,
+    "node_modules/example/production.js": `export default "production";`,
+    "routes/index.ts": `
+      import environment from 'example';
+      export default function (req, meta) {
+        return new Response('Environment: ' + environment);
+      }
+    `,
+  },
+  async test(dev) {
+    await dev.fetch("/").expect("Environment: development");
+  },
+});
diff --git a/test/bake/dev/css.test.ts b/test/bake/dev/css.test.ts
new file mode 100644
index 0000000000..205f014709
--- /dev/null
+++ b/test/bake/dev/css.test.ts
@@ -0,0 +1,72 @@
+// CSS tests concern bundling bugs with CSS files
+import { devTest, minimalFramework } from "../dev-server-harness";
+
+// devTest("css file with syntax error does not kill old styles", {
+//   framework: minimalFramework,
+//   files: {
+//     "routes/styles.css": `
+//       body {
+//         color: red;
+//       }
+//     `,
+//     "routes/index.ts": `
+//       import { expect } from 'bun:test';
+//       import './styles.css';
+
+//       export default function (req, meta) {
+//         expect(meta.styles).toHaveLength(1);
+//         return new Response(meta.styles[0]);
+//       }
+//     `,
+//   },
+//   async test(dev) {
+//     let css_url = await dev.fetch("/").text();
+//     await dev.fetch(css_url).expectNoSpaces("/*routes/styles.css*/body{color:red;}");
+//     await dev.write(
+//       "routes/styles.css",
+//       `
+//         body {
+//           color: red;
+//           background-color
+//         }
+//       `,
+//     );
+//     await dev.fetch(css_url).expectNoSpaces("/*routes/styles.css*/body{color:red;}");
+//     await dev.fetch("/").expect(css_url);
+//     await dev.write(
+//       "routes/styles.css",
+//       `
+//         body {
+//           color: red;
+//           background-color: blue;
+//         }
+//       `,
+//     );
+//     await dev.fetch(css_url).expectNoSpaces("/*routes/styles.css*/body{color:red;background-color:#00f;}");
+//     await dev.fetch("/").expect(css_url);
+//     await dev.write("routes/styles.css", ` `);
+//     await dev.fetch(css_url).expectNoSpaces("/*routes/styles.css*/");
+//     await dev.fetch("/").expect(css_url);
+//   },
+// });
+// devTest('css file with initial syntax error gets recovered', {
+//   framework: minimalFramework,
+//   files: {
+//     'routes/styles.css': `
+//       body {
+//         color: red;
+//     `,
+//     'routes/index.ts': `
+//       import { expect } from 'bun:test';
+//       import './styles.css';
+//       export default function (req, meta) {
+//         const input = req.json();
+//         expect(meta.styles).toHaveLength(input.len);
+//         return new Response('' + meta.styles[0]);
+//       }
+//     `,
+//   },
+//   async test(dev) {
+//     await dev.fetchJSON('/', { len: 1 }).expect('undefined');
+//   },
+// });
diff --git a/test/bake/dev/dev-plugins.test.ts b/test/bake/dev/dev-plugins.test.ts
new file mode 100644
index 0000000000..c448cf8402
--- /dev/null
+++ b/test/bake/dev/dev-plugins.test.ts
@@ -0,0 +1,149 @@
+// CSS tests concern bundling bugs with CSS files
+import { devTest, minimalFramework } from "../dev-server-harness";
+
+// Note: more in depth testing of plugins is done in test/bundler/bundler_plugin.test.ts
+devTest("onResolve", {
+  framework: minimalFramework,
+  pluginFile: `
+    import * as path from 'path';
+    export default [
+      {
+        name: 'a',
+        setup(build) {
+          build.onResolve({ filter: /trigger/ }, (args) => {
+            return { path: path.join(import.meta.dirname, '/file.ts') };
+          });
+        },
+      }
+    ];
+  `,
+  files: {
+    "file.ts": `
+      export const value = 1;
+    `,
+    "routes/index.ts": `
+      import { value } from 'trigger';
+
+      export default function (req, meta) {
+        return new Response('value: ' + value);
+      }
+    `,
+  },
+  async test(dev) {
+    await dev.fetch("/").expect('value: 1');
+  },
+});
+devTest("onLoad", {
+  framework: minimalFramework,
+  pluginFile: `
+    import * as path from 'path';
+    export default [
+      {
+        name: 'a',
+        setup(build) {
+          build.onLoad({ filter: /trigger/ }, (args) => {
+            return { contents: 'export const value = 1;', loader: 'ts' };
+          });
+        },
+      }
+    ];
+  `,
+  files: {
+    "trigger.ts": `
+      throw new Error('should not be loaded');
+    `,
+    "routes/index.ts": `
+      import { value } from '../trigger.ts';
+
+      export default function (req, meta) {
+        return new Response('value: ' + value);
+      }
+    `,
+  },
+  async test(dev) {
+    await dev.fetch("/").expect('value: 1');
+    await dev.fetch("/").expect('value: 1');
+    await dev.fetch("/").expect('value: 1');
+  },
+});
+devTest("onResolve + onLoad virtual file", {
+  framework: minimalFramework,
+  pluginFile: `
+    import * as path from 'path';
+    export default [
+      {
+        name: 'a',
+        setup(build) {
+          build.onResolve({ filter: /^trigger$/ }, (args) => {
+            return { path: "hello.ts", namespace: "virtual" };
+          });
+          build.onLoad({ filter: /.*/, namespace: "virtual" }, (args) => {
+            return { contents: 'export default ' + JSON.stringify(args) + ';', loader: 'ts' };
+          });
+        },
+      }
+    ];
+  `,
+  files: {
+    // this file must not collide with the virtual file
+    "hello.ts": `
+      export default "file-on-disk";
+    `,
+    "routes/index.ts": `
+      import disk from '../hello';
+      import virtual from 'trigger';
+
+      export default function (req, meta) {
+        return Response.json([virtual, disk]);
+      }
+    `,
+  },
+  async test(dev) {
+    await dev.fetch("/").expect([
+      {
+        path: "hello.ts",
+        namespace: "virtual",
+        loader: "ts",
+        side: "server",
+      },
+      "file-on-disk",
+    ]);
+  },
+});
+// devTest("onLoad with watchFile", {
+//   framework: minimalFramework,
+//   pluginFile: `
+//     import * as path from 'path';
+//     export default [
+//       {
+//         name: 'a',
+//         setup(build) {
+//           let a = 0;
+//           build.onLoad({ filter: /trigger/ }, (args) => {
+//             a += 1;
+//             return { contents: 'export const value = ' + a + ';', loader: 'ts' };
+//           });
+//         },
+//       }
+//     ];
+//   `,
+//   files: {
+//     "trigger.ts": `
+//       throw new Error('should not be loaded');
+//     `,
+//     "routes/index.ts": `
+//       import { value } from '../trigger.ts';
+
+//       export default function (req, meta) {
+//         return new Response('value: ' + value);
+//       }
+//     `,
+//   },
+//   async test(dev) {
+//     await dev.fetch("/").expect('value: 1');
+//     await dev.fetch("/").expect('value: 1');
+//     await dev.write("trigger.ts", "throw new Error('should not be loaded 2');");
+//     await dev.fetch("/").expect('value: 2');
+//     await dev.fetch("/").expect('value: 2');
+//   },
+// });
diff --git a/test/bake/dev/ecosystem.test.ts b/test/bake/dev/ecosystem.test.ts
new file mode 100644
index 0000000000..bb0e58d89e
--- /dev/null
+++ b/test/bake/dev/ecosystem.test.ts
@@ -0,0 +1,23 @@
+// these tests involve ensuring certain libraries are working correctly.  it
+// should be preferred to write specific tests for the bugs that these libraries
+// discovered, but it easy and still a reasonable idea to just test the library
+// entirely.
+import { expect } from "bun:test";
+import { devTest } from "../dev-server-harness";
+
+// Bugs discovered thanks to Svelte:
+// - Circular import situations
+// - export { live_binding }
+// - export { x as y }
+devTest('svelte component islands example', {
+  fixture: 'svelte-component-islands',
+  async test(dev) {
+    const html = await dev.fetch('/').text()
+    if (html.includes('Bun__renderFallbackError')) throw new Error('failed');
+    expect(html).toContain('self.$islands={\"pages/_Counter.svelte\":[[0,\"default\",{initial:5}]]}');
+    expect(html).toContain(`<p>This is my svelte server component (non-interactive)</p> <p>Bun v${Bun.version}</p>`);
+    expect(html).toContain(`>This is a client component (interactive island)</p>`);
+    // TODO: puppeteer test for client-side interactivity, hmr.
+    // care must be taken to implement this in a way that is not flaky.
+  },
+});
diff --git a/test/bake/dev/esm.test.ts b/test/bake/dev/esm.test.ts
new file mode 100644
index 0000000000..b08fcf1418
--- /dev/null
+++ b/test/bake/dev/esm.test.ts
@@ -0,0 +1,207 @@
+// Bundle tests are tests concerning bundling bugs that only occur in DevServer.
+import { devTest, minimalFramework } from "../dev-server-harness";
+
+const liveBindingTest = devTest("live bindings with `var`", {
+  framework: minimalFramework,
+  files: {
+    "state.ts": `
+      export var value = 0;
+      export function increment() {
+        value++;
+      }
+    `,
+    "routes/index.ts": `
+      import { value, increment } from '../state';
+      export default function(req, meta) {
+        increment();
+        return new Response('State: ' + value);
+      }
+    `,
+  },
+  async test(dev) {
+    await dev.fetch("/").expect("State: 1");
+    await dev.fetch("/").expect("State: 2");
+    await dev.fetch("/").expect("State: 3");
+    await dev.patch("routes/index.ts", {
+      find: "State",
+      replace: "Value",
+    });
+    await dev.fetch("/").expect("Value: 4");
+    await dev.fetch("/").expect("Value: 5");
+    await dev.write(
+      "state.ts",
+      `
+        export var value = 0;
+        export function increment() {
+          value--;
+        }
+      `,
+    );
+    await dev.fetch("/").expect("Value: -1");
+    await dev.fetch("/").expect("Value: -2");
+  },
+});
+devTest("live bindings through export clause", {
+  framework: minimalFramework,
+  files: {
+    "state.ts": `
+      export var value = 0;
+      export function increment() {
+        value++;
+      }
+    `,
+    "proxy.ts": `
+      import { value } from './state';
+      export { value as live };
+    `,
+    "routes/index.ts": `
+      import { increment } from '../state';
+      import { live } from '../proxy';
+      export default function(req, meta) {
+        increment();
+        return new Response('State: ' + live);
+      }
+    `,
+  },
+  test: liveBindingTest.test,
+});
+devTest("live bindings through export from", {
+  framework: minimalFramework,
+  files: {
+    "state.ts": `
+      export var value = 0;
+      export function increment() {
+        value++;
+      }
+    `,
+    "proxy.ts": `
+      export { value as live } from './state';
+    `,
+    "routes/index.ts": `
+      import { increment } from '../state';
+      import { live } from '../proxy';
+      export default function(req, meta) {
+        increment();
+        return new Response('State: ' + live);
+      }
+    `,
+  },
+  test: liveBindingTest.test,
+});
+// devTest("live bindings through export star", {
+//   framework: minimalFramework,
+//   files: {
+//     "state.ts": `
+//       export var value = 0;
+//       export function increment() {
+//         value++;
+//       }
+//     `,
+//     "proxy.ts": `
+//       export * from './state';
+//     `,
+//     "routes/index.ts": `
+//       import { increment } from '../state';
+//       import { live } from '../proxy';
+//       export default function(req, meta) {
+//         increment();
+//         return new Response('State: ' + live);
+//       }
+//     `,
+//   },
+//   test: liveBindingTest.test,
+// });
+devTest("export { x as y }", {
+  framework: minimalFramework,
+  files: {
+    "module.ts": `
+      function x(value) {
+        return value + 1;
+      } 
+      export { x as y };
+    `,
+    "routes/index.ts": `
+      import { y } from '../module';
+      export default function(req, meta) {
+        return new Response('Value: ' + y(1));
+      }
+    `,
+  },
+  async test(dev) {
+    await dev.fetch("/").expect("Value: 2");
+    await dev.patch("module.ts", {
+      find: "1",
+      replace: "2",
+    });
+    await dev.fetch("/").expect("Value: 3");
+  }
+});
+devTest("import { x as y }", {
+  framework: minimalFramework,
+  files: {
+    "module.ts": `
+      export const x = 1;
+    `,
+    "routes/index.ts": `
+      import { x as y } from '../module';
+      export default function(req, meta) {
+        return new Response('Value: ' + y);
+      }
+    `,
+  },
+  async test(dev) {
+    await dev.fetch("/").expect("Value: 1");
+    await dev.patch("module.ts", {
+      find: "1",
+      replace: "2",
+    });
+    await dev.fetch("/").expect("Value: 2");
+  }
+});
+devTest("import { default as y }", {
+  framework: minimalFramework,
+  files: {
+    "module.ts": `
+      export default 1;
+    `,
+    "routes/index.ts": `
+      import { default as y } from '../module';
+      export default function(req, meta) {
+        return new Response('Value: ' + y);
+      }
+    `,
+  },
+  async test(dev) {
+    await dev.fetch("/").expect("Value: 1");
+    await dev.patch("module.ts", {
+      find: "1",
+      replace: "2",
+    });
+    await dev.fetch("/").expect("Value: 2");
+  }
+});
+devTest("export { default as y }", {
+  framework: minimalFramework,
+  files: {
+    "module.ts": `
+      export default 1;
+    `,
+    "middle.ts": `
+      export { default as y } from './module';
+    `,
+    "routes/index.ts": `
+      import { y } from '../middle';
+      export default function(req, meta) {
+        return new Response('Value: ' + y);
+      }
+    `,
+  },
+  async test(dev) {
+    await dev.fetch("/").expect("Value: 1");
+    await dev.patch("module.ts", {
+      find: "1",
+      replace: "2",
+    });
+    await dev.fetch("/").expect("Value: 2");
+  }
+});
diff --git a/test/bake/fixtures/svelte-component-islands/bun.app.ts b/test/bake/fixtures/svelte-component-islands/bun.app.ts
new file mode 100644
index 0000000000..9813768a22
--- /dev/null
+++ b/test/bake/fixtures/svelte-component-islands/bun.app.ts
@@ -0,0 +1,8 @@
+import svelte from "./framework";
+
+export default {
+  port: 3000,
+  app: {
+    framework: svelte(),
+  },
+};
diff --git a/test/bake/fixtures/svelte-component-islands/framework/client.ts b/test/bake/fixtures/svelte-component-islands/framework/client.ts
new file mode 100644
index 0000000000..aca37275e0
--- /dev/null
+++ b/test/bake/fixtures/svelte-component-islands/framework/client.ts
@@ -0,0 +1,14 @@
+import type { IslandMap } from "./server";
+import { hydrate } from 'svelte';
+
+declare var $islands: IslandMap;
+Object.entries($islands).forEach(async([moduleId, islands]) => {
+    const mod = await import(moduleId);
+    for(const [islandId, exportId, props] of islands) {
+        const elem = document.getElementById(`I:${islandId}`)!;
+        hydrate(mod[exportId], {
+            target: elem,
+            props,
+        });
+    }
+});
diff --git a/test/bake/fixtures/svelte-component-islands/framework/index.ts b/test/bake/fixtures/svelte-component-islands/framework/index.ts
new file mode 100644
index 0000000000..7cecf75358
--- /dev/null
+++ b/test/bake/fixtures/svelte-component-islands/framework/index.ts
@@ -0,0 +1,68 @@
+import type { Bake } from "bun";
+import * as path from "node:path";
+import * as fs from "node:fs/promises";
+import * as svelte from "svelte/compiler";
+
+export default function (): Bake.Framework {
+  return {
+    serverComponents: {
+      separateSSRGraph: false,
+      serverRuntimeImportSource: "./framework/server.ts",
+    },
+    fileSystemRouterTypes: [
+      {
+        root: "pages",
+        serverEntryPoint: "./framework/server.ts",
+        clientEntryPoint: "./framework/client.ts",
+        style: "nextjs-pages", // later, this will be fully programmable
+        extensions: [".svelte"],
+      },
+    ],
+    plugins: [
+      {
+        // This is missing a lot of code that a plugin like `esbuild-svelte`
+        // handles, but this is only an examplea of how such a plugin could
+        // have server-components at a minimal level.
+        name: "svelte-server-components",
+        setup(b) {
+          const cssMap = new Map<string, string>();
+          b.onLoad({ filter: /.svelte$/ }, async (args) => {
+            const contents = await fs.readFile(args.path, "utf-8");
+            const result = svelte.compile(contents, {
+              filename: args.path,
+              css: "external",
+              cssOutputFilename: path.basename(args.path, ".svelte") + ".css",
+              hmr: true,
+              dev: true,
+              generate: args.side,
+            });
+            // If CSS is specified, add a CSS import
+            let jsCode = result.js.code;
+            if (result.css) {
+              cssMap.set(args.path, result.css.code);
+              jsCode = `import ${JSON.stringify("svelte-css:" + args.path)};` + jsCode;
+            }
+            // Extract a "use client" directive from the file.
+            const header = contents.match(/^\s*<script.*?>\s*("[^"\n]*"|'[^'\n]*')/)?.[1];
+            if (header) {
+              jsCode = header + ';' + jsCode;
+            }
+            return {
+              contents: jsCode,
+              loader: "js",
+              watchFiles: [args.path],
+            };
+          });
+
+          // Resolve CSS files
+          b.onResolve({ filter: /^svelte-css:/ }, async (args) => {
+            return { path: args.path.replace(/^svelte-css:/, ""), namespace: "svelte-css" };
+          });
+          b.onLoad({ filter: /./, namespace: "svelte-css" }, async (args) => {
+            return { contents: cssMap.get(args.path) ?? "", loader: "css" };
+          });
+        },
+      },
+    ],
+  };
+}
diff --git a/test/bake/fixtures/svelte-component-islands/framework/server.ts b/test/bake/fixtures/svelte-component-islands/framework/server.ts
new file mode 100644
index 0000000000..29253245f8
--- /dev/null
+++ b/test/bake/fixtures/svelte-component-islands/framework/server.ts
@@ -0,0 +1,71 @@
+/// <reference path="../../../../../src/bake/bake.d.ts" />
+import type { Bake } from "bun";
+import * as svelte from "svelte/server";
+import { uneval } from "devalue";
+
+export function render(req: Request, meta: Bake.RouteMetadata) {
+  isInsideIsland = false;
+  islands = {};
+  const { body, head } = svelte.render(meta.pageModule.default, {
+    props: {
+      params: meta.params,
+    },
+  });
+
+  // Add stylesheets and preloaded modules to the head
+  const extraHead = meta.styles.map((style) => `<link rel="stylesheet" href="${style}">`).join("")
+    + meta.modulepreload.map((style) => `<link rel="modulepreload" href="${style}">`).join("");
+  // Script tags
+  const scripts = nextIslandId > 0
+    ? `<script>self.$islands=${uneval(islands)}</script>` +
+      meta.modules.map((module) => `<script type="module" src="${module}"></script>`).join("")
+    : ""; // If no islands, no JavaScript
+
+  return new Response(
+    "<!DOCTYPE html><html><head>" + head + extraHead + "</head><body>"
+      + body + "</body>" + scripts + "</html>",
+    { headers: { "content-type": "text/html" } },
+  );
+}
+
+// To allow static site generation, frameworks can specify a prerender function
+export function prerender(meta: Bake.RouteMetadata) {
+  return {
+    files: {
+      '/index.html': render(null!, meta),
+    },
+  };
+}
+
+let isInsideIsland = false;
+let nextIslandId = 0;
+let islands: IslandMap;
+export type IslandMap = Record<string, Island[]>;
+export type Island = [islandId: number, exportId: string, props: any];
+
+/**
+ * @param component The original export value, as is.
+ * @param clientModuleId A string that the browser will pass to `import()`.
+ * @param clientExportId The export ID from the imported module.
+ * @returns A wrapped value for the export.
+ */
+export function registerClientReference(
+  component: Function,
+  clientModuleId: string,
+  clientExportId: string,
+) {
+  return function Island(...args: any[]) {
+    if (isInsideIsland) {
+      return component(...args);
+    }
+    isInsideIsland = true;
+    const [payload, props] = args;
+    const islandId = nextIslandId++;
+    payload.out += `<bake-island id="I:${islandId}">`;
+    const file = (islands[clientModuleId] ??= []);
+    file.push([islandId, clientExportId, props]);
+    component(...args);
+    payload.out += `</bake-island>`;
+    isInsideIsland = false;
+  };
+}
diff --git a/test/bake/fixtures/svelte-component-islands/pages/_Counter.svelte b/test/bake/fixtures/svelte-component-islands/pages/_Counter.svelte
new file mode 100644
index 0000000000..7c4a618edb
--- /dev/null
+++ b/test/bake/fixtures/svelte-component-islands/pages/_Counter.svelte
@@ -0,0 +1,24 @@
+<script>
+    "use client";
+    let { initial } = $props();
+    let count = $state(initial);
+    function increment() {
+        count += 1;
+    }
+</script>
+
+<div>
+    <p>This is a client component (interactive island)</p>
+    <button onclick={increment}>
+        Clicked {count} {count === 1 ? 'time' : 'times'}
+    </button>
+</div>
+<style>
+    div {
+        border: 1px solid red;
+        padding: 1rem;
+        p {
+            color: red;
+        }
+    }
+</style>
diff --git a/test/bake/fixtures/svelte-component-islands/pages/index.svelte b/test/bake/fixtures/svelte-component-islands/pages/index.svelte
new file mode 100644
index 0000000000..f5b8c0728c
--- /dev/null
+++ b/test/bake/fixtures/svelte-component-islands/pages/index.svelte
@@ -0,0 +1,18 @@
+<script>
+    import Counter from "./_Counter.svelte";
+</script>
+<main>
+    <h1>hello</h1>
+    <p>This is my svelte server component (non-interactive)</p>
+    <p>Bun v{Bun.version}</p>
+    <Counter initial={5} />
+</main>
+<style>
+    main {
+        border: 1px solid blue;
+        padding: 1rem;
+        h1 {
+            color: blue;
+        }
+    }
+</style>
\ No newline at end of file
diff --git a/test/bake/framework-router.test.ts b/test/bake/framework-router.test.ts
new file mode 100644
index 0000000000..e30729515a
--- /dev/null
+++ b/test/bake/framework-router.test.ts
@@ -0,0 +1,136 @@
+import { describe, test } from "bun:test";
+import { frameworkRouterInternals } from "bun:internal-for-testing";
+import { expect } from "bun:test";
+import path from "path";
+import { tempDirWithFiles } from "harness";
+
+const { parseRoutePattern, FrameworkRouter } = 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}] pass: ${JSON.stringify(pattern)}`, () => {
+      const result = parseRoutePattern(style, pattern);
+      if (result === null) {
+        throw new Error("Parser said this file is not a route");
+      }
+      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}] error: ${JSON.stringify(pattern)}`, () => {
+      expect(() => parseRoutePattern(style, pattern)).toThrow(msg);
+    });
+  };
+  fn.isNull = (pattern: string) => {
+    test(`[${style}] ignore: ${JSON.stringify(pattern)}`, () => {
+      expect(parseRoutePattern(style, pattern)).toBeNull();
+    });
+  };
+  return fn;
+};
+
+describe("pattern parse", () => {
+  const testPages = testRoutePattern("nextjs-pages");
+  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");
+  testApp.isNull("/route/_layout.tsx");
+});
+
+test("discovers from filesystem paths", () => {
+  const dir = tempDirWithFiles("fsr", {
+    "hello.tsx": "1",
+    "meow/_layout.tsx": "1",
+    "meow/bark/[param]/hello.tsx": "1",
+    "[world].tsx": "1",
+  });
+  const router = new FrameworkRouter({ root: dir, style: "nextjs-pages" });
+  expect(router.toJSON()).toEqual({
+    part: "/",
+    page: null,
+    layout: null,
+    children: [
+      {
+        part: "/:world",
+        page: path.join(dir, "[world].tsx"),
+        layout: null,
+        children: [],
+      },
+      {
+        part: "/meow",
+        page: null,
+        layout: path.join(dir, "meow/_layout.tsx"),
+        children: [
+          {
+            part: "/bark",
+            page: null,
+            layout: null,
+            children: [
+              {
+                part: "/:param",
+                page: null,
+                layout: null,
+                children: [
+                  {
+                    part: "/hello",
+                    page: path.join(dir, "meow/bark/[param]/hello.tsx"),
+                    layout: null,
+                    children: [],
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+      {
+        part: "/hello",
+        page: path.join(dir, "hello.tsx"),
+        layout: null,
+        children: [],
+      },
+    ],
+  });
+});
diff --git a/test/bake/minimal.server.ts b/test/bake/minimal.server.ts
new file mode 100644
index 0000000000..f88ae146d2
--- /dev/null
+++ b/test/bake/minimal.server.ts
@@ -0,0 +1,17 @@
+import { Bake } from "bun";
+
+export function render(req: Request, meta: Bake.RouteMetadata) {
+  if (typeof meta.pageModule.default !== "function") {
+    console.log("pageModule === ", meta.pageModule);
+    throw new Error("Expected default export to be a function");
+  }
+  return meta.pageModule.default(req, meta);
+}
+
+export function registerClientReference(value: any, file: any, uid: any) {
+  return {
+    value,
+    file,
+    uid,
+  };
+}
diff --git a/test/bun.lockb b/test/bun.lockb
index 30b73a146f..592e2bd028 100755
Binary files a/test/bun.lockb and b/test/bun.lockb differ
diff --git a/test/bundler/__snapshots__/bun-build-api.test.ts.snap b/test/bundler/__snapshots__/bun-build-api.test.ts.snap
index ee8156b900..3f625ec089 100644
--- a/test/bundler/__snapshots__/bun-build-api.test.ts.snap
+++ b/test/bundler/__snapshots__/bun-build-api.test.ts.snap
@@ -58,486 +58,11 @@ NS.then(({ fn: fn2 }) => {
 "
 `;
 
-exports[`Bun.build BuildArtifact properties: hash 1`] = `"r6c8x1cc"`;
+exports[`Bun.build BuildArtifact properties: hash 1`] = `"d1c7nm6t"`;
 
-exports[`Bun.build BuildArtifact properties + entry.naming: hash 1`] = `"vanwb97w"`;
+exports[`Bun.build BuildArtifact properties + entry.naming: hash 1`] = `"rm7e36cf"`;
 
-exports[`Bun.build BuildArtifact properties sourcemap: hash index.js 1`] = `"r6c8x1cc"`;
-
-exports[`Bun.build BuildArtifact properties sourcemap: hash index.js.map 1`] = `"00000000"`;
-
-exports[`Bun.build new Response(BuildArtifact) sets content type: response text 1`] = `
-"var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-
-// test/bundler/fixtures/trivial/fn.js
-var exports_fn = {};
-__export(exports_fn, {
-  fn: () => fn
-});
-function fn(a) {
-  return a + 42;
-}
-
-// test/bundler/fixtures/trivial/index.js
-var NS = Promise.resolve().then(() => exports_fn);
-NS.then(({ fn: fn2 }) => {
-  console.log(fn2(42));
-});
-"
-`;
-
-exports[`Bun.build Bun.write(BuildArtifact) 1`] = `
-"var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-
-// test/bundler/fixtures/trivial/fn.js
-var exports_fn = {};
-__export(exports_fn, {
-  fn: () => fn
-});
-function fn(a) {
-  return a + 42;
-}
-
-// test/bundler/fixtures/trivial/index.js
-var NS = Promise.resolve().then(() => exports_fn);
-NS.then(({ fn: fn2 }) => {
-  console.log(fn2(42));
-});
-"
-`;
-
-exports[`Bun.build outdir + reading out blobs works 1`] = `
-"var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-
-// test/bundler/fixtures/trivial/fn.js
-var exports_fn = {};
-__export(exports_fn, {
-  fn: () => fn
-});
-function fn(a) {
-  return a + 42;
-}
-
-// test/bundler/fixtures/trivial/index.js
-var NS = Promise.resolve().then(() => exports_fn);
-NS.then(({ fn: fn2 }) => {
-  console.log(fn2(42));
-});
-"
-`;
-
-exports[`Bun.build BuildArtifact properties: hash 1`] = `"r6c8x1cc"`;
-
-exports[`Bun.build BuildArtifact properties + entry.naming: hash 1`] = `"vanwb97w"`;
-
-exports[`Bun.build BuildArtifact properties sourcemap: hash index.js 1`] = `"r6c8x1cc"`;
-
-exports[`Bun.build BuildArtifact properties sourcemap: hash index.js.map 1`] = `"00000000"`;
-
-exports[`Bun.build new Response(BuildArtifact) sets content type: response text 1`] = `
-"var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-
-// test/bundler/fixtures/trivial/fn.js
-var exports_fn = {};
-__export(exports_fn, {
-  fn: () => fn
-});
-function fn(a) {
-  return a + 42;
-}
-
-// test/bundler/fixtures/trivial/index.js
-var NS = Promise.resolve().then(() => exports_fn);
-NS.then(({ fn: fn2 }) => {
-  console.log(fn2(42));
-});
-"
-`;
-
-exports[`Bun.build Bun.write(BuildArtifact) 1`] = `
-"var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-
-// test/bundler/fixtures/trivial/fn.js
-var exports_fn = {};
-__export(exports_fn, {
-  fn: () => fn
-});
-function fn(a) {
-  return a + 42;
-}
-
-// test/bundler/fixtures/trivial/index.js
-var NS = Promise.resolve().then(() => exports_fn);
-NS.then(({ fn: fn2 }) => {
-  console.log(fn2(42));
-});
-"
-`;
-
-exports[`Bun.build outdir + reading out blobs works 1`] = `
-"var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-
-// test/bundler/fixtures/trivial/fn.js
-var exports_fn = {};
-__export(exports_fn, {
-  fn: () => fn
-});
-function fn(a) {
-  return a + 42;
-}
-
-// test/bundler/fixtures/trivial/index.js
-var NS = Promise.resolve().then(() => exports_fn);
-NS.then(({ fn: fn2 }) => {
-  console.log(fn2(42));
-});
-"
-`;
-
-exports[`Bun.build BuildArtifact properties: hash 1`] = `"5909xc4p"`;
-
-exports[`Bun.build BuildArtifact properties + entry.naming: hash 1`] = `"e1cnkf2m"`;
-
-exports[`Bun.build BuildArtifact properties sourcemap: hash index.js 1`] = `"5909xc4p"`;
-
-exports[`Bun.build BuildArtifact properties sourcemap: hash index.js.map 1`] = `"00000000"`;
-
-exports[`Bun.build new Response(BuildArtifact) sets content type: response text 1`] = `
-"var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-
-// test/bundler/fixtures/trivial/fn.js
-var exports_fn = {};
-__export(exports_fn, {
-  fn: () => fn
-});
-function fn(a) {
-  return a + 42;
-}
-
-// test/bundler/fixtures/trivial/index.js
-var NS = Promise.resolve().then(() => exports_fn);
-NS.then(({ fn: fn2 }) => {
-  console.log(fn2(42));
-});
-"
-`;
-
-exports[`Bun.build Bun.write(BuildArtifact) 1`] = `
-"var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-
-// test/bundler/fixtures/trivial/fn.js
-var exports_fn = {};
-__export(exports_fn, {
-  fn: () => fn
-});
-function fn(a) {
-  return a + 42;
-}
-
-// test/bundler/fixtures/trivial/index.js
-var NS = Promise.resolve().then(() => exports_fn);
-NS.then(({ fn: fn2 }) => {
-  console.log(fn2(42));
-});
-"
-`;
-
-exports[`Bun.build outdir + reading out blobs works 1`] = `
-"var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-
-// test/bundler/fixtures/trivial/fn.js
-var exports_fn = {};
-__export(exports_fn, {
-  fn: () => fn
-});
-function fn(a) {
-  return a + 42;
-}
-
-// test/bundler/fixtures/trivial/index.js
-var NS = Promise.resolve().then(() => exports_fn);
-NS.then(({ fn: fn2 }) => {
-  console.log(fn2(42));
-});
-"
-`;
-
-exports[`Bun.build BuildArtifact properties: hash 1`] = `"5909xc4p"`;
-
-exports[`Bun.build BuildArtifact properties + entry.naming: hash 1`] = `"e1cnkf2m"`;
-
-exports[`Bun.build BuildArtifact properties sourcemap: hash index.js 1`] = `"5909xc4p"`;
-
-exports[`Bun.build BuildArtifact properties sourcemap: hash index.js.map 1`] = `"00000000"`;
-
-exports[`Bun.build new Response(BuildArtifact) sets content type: response text 1`] = `
-"var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-
-// test/bundler/fixtures/trivial/fn.js
-var exports_fn = {};
-__export(exports_fn, {
-  fn: () => fn
-});
-function fn(a) {
-  return a + 42;
-}
-
-// test/bundler/fixtures/trivial/index.js
-var NS = Promise.resolve().then(() => exports_fn);
-NS.then(({ fn: fn2 }) => {
-  console.log(fn2(42));
-});
-"
-`;
-
-exports[`Bun.build Bun.write(BuildArtifact) 1`] = `
-"var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-
-// test/bundler/fixtures/trivial/fn.js
-var exports_fn = {};
-__export(exports_fn, {
-  fn: () => fn
-});
-function fn(a) {
-  return a + 42;
-}
-
-// test/bundler/fixtures/trivial/index.js
-var NS = Promise.resolve().then(() => exports_fn);
-NS.then(({ fn: fn2 }) => {
-  console.log(fn2(42));
-});
-"
-`;
-
-exports[`Bun.build outdir + reading out blobs works 1`] = `
-"var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-
-// test/bundler/fixtures/trivial/fn.js
-var exports_fn = {};
-__export(exports_fn, {
-  fn: () => fn
-});
-function fn(a) {
-  return a + 42;
-}
-
-// test/bundler/fixtures/trivial/index.js
-var NS = Promise.resolve().then(() => exports_fn);
-NS.then(({ fn: fn2 }) => {
-  console.log(fn2(42));
-});
-"
-`;
-
-exports[`Bun.build BuildArtifact properties: hash 1`] = `"5909xc4p"`;
-
-exports[`Bun.build BuildArtifact properties + entry.naming: hash 1`] = `"e1cnkf2m"`;
-
-exports[`Bun.build BuildArtifact properties sourcemap: hash index.js 1`] = `"5909xc4p"`;
-
-exports[`Bun.build BuildArtifact properties sourcemap: hash index.js.map 1`] = `"00000000"`;
-
-exports[`Bun.build new Response(BuildArtifact) sets content type: response text 1`] = `
-"var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-
-// test/bundler/fixtures/trivial/fn.js
-var exports_fn = {};
-__export(exports_fn, {
-  fn: () => fn
-});
-function fn(a) {
-  return a + 42;
-}
-
-// test/bundler/fixtures/trivial/index.js
-var NS = Promise.resolve().then(() => exports_fn);
-NS.then(({ fn: fn2 }) => {
-  console.log(fn2(42));
-});
-"
-`;
-
-exports[`Bun.build Bun.write(BuildArtifact) 1`] = `
-"var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-
-// test/bundler/fixtures/trivial/fn.js
-var exports_fn = {};
-__export(exports_fn, {
-  fn: () => fn
-});
-function fn(a) {
-  return a + 42;
-}
-
-// test/bundler/fixtures/trivial/index.js
-var NS = Promise.resolve().then(() => exports_fn);
-NS.then(({ fn: fn2 }) => {
-  console.log(fn2(42));
-});
-"
-`;
-
-exports[`Bun.build outdir + reading out blobs works 1`] = `
-"var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-
-// test/bundler/fixtures/trivial/fn.js
-var exports_fn = {};
-__export(exports_fn, {
-  fn: () => fn
-});
-function fn(a) {
-  return a + 42;
-}
-
-// test/bundler/fixtures/trivial/index.js
-var NS = Promise.resolve().then(() => exports_fn);
-NS.then(({ fn: fn2 }) => {
-  console.log(fn2(42));
-});
-"
-`;
-
-exports[`Bun.build BuildArtifact properties: hash 1`] = `"5909xc4p"`;
-
-exports[`Bun.build BuildArtifact properties + entry.naming: hash 1`] = `"e1cnkf2m"`;
-
-exports[`Bun.build BuildArtifact properties sourcemap: hash index.js 1`] = `"5909xc4p"`;
+exports[`Bun.build BuildArtifact properties sourcemap: hash index.js 1`] = `"d1c7nm6t"`;
 
 exports[`Bun.build BuildArtifact properties sourcemap: hash index.js.map 1`] = `"00000000"`;
 
diff --git a/test/bundler/bun-build-api.test.ts b/test/bundler/bun-build-api.test.ts
index 3ad22e8dad..df1624622e 100644
--- a/test/bundler/bun-build-api.test.ts
+++ b/test/bundler/bun-build-api.test.ts
@@ -4,6 +4,88 @@ import { bunEnv, bunExe, tempDirWithFiles } from "harness";
 import path, { join } from "path";
 
 describe("Bun.build", () => {
+  test("experimentalCss = true works", async () => {
+    const dir = tempDirWithFiles("bun-build-api-experimental-css", {
+      "a.css": `
+        @import "./b.css";
+
+        .hi {
+          color: red;
+        }
+      `,
+      "b.css": `
+        .hello {
+          color: blue;
+        }
+      `,
+    });
+
+    const build = await Bun.build({
+      entrypoints: [join(dir, "a.css")],
+      experimentalCss: true,
+      minify: true,
+    });
+
+    expect(build.outputs).toHaveLength(1);
+    expect(build.outputs[0].kind).toBe("asset");
+    expect(await build.outputs[0].text()).toEqualIgnoringWhitespace(".hello{color:#00f}.hi{color:red}\n");
+  });
+
+  test("experimentalCss = false works", async () => {
+    const dir = tempDirWithFiles("bun-build-api-experimental-css", {
+      "a.css": `
+        @import "./b.css";
+
+        .hi {
+          color: red;
+        }
+      `,
+      "b.css": `
+        .hello {
+          color: blue;
+        }
+      `,
+    });
+
+    const build = await Bun.build({
+      entrypoints: [join(dir, "a.css")],
+      outdir: join(dir, "out"),
+      minify: true,
+    });
+
+    expect(build.outputs).toHaveLength(2);
+    expect(build.outputs[0].kind).toBe("entry-point");
+    expect(await build.outputs[0].text()).not.toEqualIgnoringWhitespace(".hello{color:#00f}.hi{color:red}\n");
+  });
+
+  test("bytecode works", async () => {
+    const dir = tempDirWithFiles("bun-build-api-bytecode", {
+      "package.json": `{}`,
+      "index.ts": `
+        export function hello() {
+          return "world";
+        }
+
+        console.log(hello());
+      `,
+      out: {
+        "hmm.js": "hmm",
+      },
+    });
+
+    const build = await Bun.build({
+      entrypoints: [join(dir, "index.ts")],
+      outdir: join(dir, "out"),
+      target: "bun",
+      bytecode: true,
+    });
+
+    expect(build.outputs).toHaveLength(2);
+    expect(build.outputs[0].kind).toBe("entry-point");
+    expect(build.outputs[1].kind).toBe("bytecode");
+    expect([build.outputs[0].path]).toRun("world\n");
+  });
+
   test("passing undefined doesnt segfault", () => {
     try {
       // @ts-ignore
diff --git a/test/bundler/bundler_bake_dev.test.ts b/test/bundler/bundler_bake_dev.test.ts
new file mode 100644
index 0000000000..a2ecedfca6
--- /dev/null
+++ b/test/bundler/bundler_bake_dev.test.ts
@@ -0,0 +1,42 @@
+import { describe } from "bun:test";
+import { itBundled } from "./expectBundled";
+
+describe("bundler", async () => {
+  itBundled("bake_dev/HelloWorld", {
+    todo: true,
+    files: {
+      "/a.js": `console.log("Hello, world!")`,
+    },
+    format: "internal_bake_dev",
+    target: "bun",
+    run: { stdout: "Hello, world!" },
+    onAfterBundle(api) {
+      // `importSync` is one of the functions the runtime includes.
+      // it is on a property access so it will not be mangled
+      api.expectFile("out.js").toContain("importSync");
+    },
+  });
+  itBundled("bake_dev/SimpleCommonJS", {
+    todo: true,
+    files: {
+      "/a.js": `console.log(require('./b').message)`,
+      "/b.js": `module.exports = { message: "Hello, world!" }`,
+    },
+    format: "internal_bake_dev",
+    target: "bun",
+    run: { stdout: "Hello, world!" },
+  });
+  itBundled("bake_dev/SimpleESM", {
+    todo: true,
+    files: {
+      "/a.js": `
+        import message from './b';
+        console.log(message);
+      `,
+      "/b.js": `export default "Hello, world!"`,
+    },
+    format: "internal_bake_dev",
+    target: "bun",
+    run: { stdout: "Hello, world!" },
+  });
+});
diff --git a/test/bundler/bundler_banner.test.ts b/test/bundler/bundler_banner.test.ts
new file mode 100644
index 0000000000..8a783b66fc
--- /dev/null
+++ b/test/bundler/bundler_banner.test.ts
@@ -0,0 +1,36 @@
+import { describe } from "bun:test";
+import { itBundled } from "./expectBundled";
+
+describe("bundler", () => {
+  itBundled("banner/CommentBanner", {
+    banner: "// developed with love in SF",
+    files: {
+      "/a.js": `console.log("Hello, world!")`,
+    },
+    onAfterBundle(api) {
+      api.expectFile("out.js").toContain("// developed with love in SF");
+    },
+  });
+  itBundled("banner/MultilineBanner", {
+    banner: `"use client";
+// This is a multiline banner
+// It can contain multiple lines of comments or code`,
+    files: {
+      /* js*/ "index.js": `console.log("Hello, world!")`,
+    },
+    onAfterBundle(api) {
+      api.expectFile("out.js").toContain(`"use client";
+// This is a multiline banner
+// It can contain multiple lines of comments or code`);
+    },
+  });
+  itBundled("banner/UseClientBanner", {
+    banner: '"use client";',
+    files: {
+      /* js*/ "index.js": `console.log("Hello, world!")`,
+    },
+    onAfterBundle(api) {
+      api.expectFile("out.js").toContain('"use client";');
+    },
+  });
+});
diff --git a/test/bundler/bundler_browser.test.ts b/test/bundler/bundler_browser.test.ts
index 40ddd09226..d437447d7f 100644
--- a/test/bundler/bundler_browser.test.ts
+++ b/test/bundler/bundler_browser.test.ts
@@ -40,6 +40,31 @@ describe("bundler", () => {
     "vm": "no-op",
     "zlib": "polyfill",
   };
+
+  itBundled("browser/NodeBuffer#12272", {
+    files: {
+      "/entry.js": /* js */ `
+        import * as buffer from "node:buffer";
+        import { Buffer } from "buffer";
+        import Buffer2 from "buffer";
+        import { Blob, File } from "buffer";
+        if (Buffer !== Buffer2) throw new Error("Buffer is not the same");
+        if (Blob !== globalThis.Blob) throw new Error("Blob is not the same");
+        if (File !== globalThis.File) throw new Error("File is not the same");
+        if (Buffer.from("foo").toString("hex") !== "666f6f") throw new Error("Buffer.from is broken");
+        if (buffer.isAscii("foo") !== true) throw new Error("Buffer.isAscii is broken");
+        if (Buffer2.alloc(10, 'b').toString("hex") !== "62626262626262626262") throw new Error("Buffer.alloc is broken");
+        console.log("Success!");
+      `,
+    },
+    target: "browser",
+    run: {
+      stdout: "Success!",
+    },
+    onAfterBundle(api) {
+      api.expectFile("out.js").not.toInclude("import ");
+    },
+  });
   itBundled("browser/NodeFS", {
     files: {
       "/entry.js": /* js */ `
@@ -55,6 +80,9 @@ describe("bundler", () => {
     run: {
       stdout: "function\nfunction\nundefined",
     },
+    onAfterBundle(api) {
+      api.expectFile("out.js").not.toInclude("import ");
+    },
   });
   itBundled("browser/NodeTTY", {
     files: {
@@ -69,6 +97,9 @@ describe("bundler", () => {
     run: {
       stdout: "function\nfunction\nfalse",
     },
+    onAfterBundle(api) {
+      api.expectFile("out.js").not.toInclude("import ");
+    },
   });
   // TODO: use nodePolyfillList to generate the code in here.
   const NodePolyfills = itBundled("browser/NodePolyfills", {
diff --git a/test/bundler/bundler_bun.test.ts b/test/bundler/bundler_bun.test.ts
index 63820dd4c3..43b29c517e 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_compile.test.ts b/test/bundler/bundler_compile.test.ts
index 078f9bb3c2..d4c3610527 100644
--- a/test/bundler/bundler_compile.test.ts
+++ b/test/bundler/bundler_compile.test.ts
@@ -2,8 +2,9 @@ import { Database } from "bun:sqlite";
 import { describe, expect } from "bun:test";
 import { rmSync } from "fs";
 import { itBundled } from "./expectBundled";
+import { isFlaky, isWindows } from "harness";
 
-describe("bundler", () => {
+describe.todoIf(isFlaky && isWindows)("bundler", () => {
   itBundled("compile/HelloWorld", {
     compile: true,
     files: {
@@ -13,6 +14,42 @@ describe("bundler", () => {
     },
     run: { stdout: "Hello, world!" },
   });
+  itBundled("compile/HelloWorldWithProcessVersionsBun", {
+    compile: true,
+    files: {
+      [`/${process.platform}-${process.arch}.js`]: "module.exports = process.versions.bun;",
+      "/entry.ts": /* js */ `
+        process.exitCode = 1;
+        process.versions.bun = "bun!";
+        if (process.versions.bun === "bun!") throw new Error("fail");
+        if (require("./${process.platform}-${process.arch}.js") === "${Bun.version.replaceAll("-debug", "")}") {
+          process.exitCode = 0;
+        }
+      `,
+    },
+    run: { exitCode: 0 },
+  });
+  itBundled("compile/HelloWorldBytecode", {
+    compile: true,
+    bytecode: true,
+    files: {
+      "/entry.ts": /* js */ `
+        console.log("Hello, world!");
+      `,
+    },
+    run: {
+      stdout: "Hello, world!",
+      stderr: [
+        "[Disk Cache] Cache hit for sourceCode",
+
+        // TODO: remove this line once bun:main is removed.
+        "[Disk Cache] Cache miss for sourceCode",
+      ].join("\n"),
+      env: {
+        BUN_JSC_verboseDiskCache: "1",
+      },
+    },
+  });
   // https://github.com/oven-sh/bun/issues/8697
   itBundled("compile/EmbeddedFileOutfile", {
     compile: true,
@@ -66,6 +103,43 @@ describe("bundler", () => {
     outfile: "dist/out",
     run: { stdout: "Hello, world!\nWorker loaded!\n", file: "dist/out", setCwd: true },
   });
+  itBundled("compile/WorkerRelativePathTSExtensionBytecode", {
+    compile: true,
+    bytecode: true,
+    files: {
+      "/entry.ts": /* js */ `
+        import {rmSync} from 'fs';
+        // Verify we're not just importing from the filesystem
+        rmSync("./worker.ts", {force: true});
+        console.log("Hello, world!");
+        new Worker("./worker.ts");
+      `,
+      "/worker.ts": /* js */ `
+        console.log("Worker loaded!");
+    `.trim(),
+    },
+    entryPointsRaw: ["./entry.ts", "./worker.ts"],
+    outfile: "dist/out",
+    run: {
+      stdout: "Hello, world!\nWorker loaded!\n",
+      file: "dist/out",
+      setCwd: true,
+      stderr: [
+        "[Disk Cache] Cache hit for sourceCode",
+
+        // TODO: remove this line once bun:main is removed.
+        "[Disk Cache] Cache miss for sourceCode",
+
+        "[Disk Cache] Cache hit for sourceCode",
+
+        // TODO: remove this line once bun:main is removed.
+        "[Disk Cache] Cache miss for sourceCode",
+      ].join("\n"),
+      env: {
+        BUN_JSC_verboseDiskCache: "1",
+      },
+    },
+  });
   itBundled("compile/Bun.embeddedFiles", {
     compile: true,
     // TODO: this shouldn't be necessary, or we should add a map aliasing files.
@@ -155,7 +229,7 @@ describe("bundler", () => {
     },
   });
   itBundled("compile/VariousBunAPIs", {
-    todo: process.platform === "win32", // TODO(@paperdave)
+    todo: isWindows, // TODO(@paperdave)
     compile: true,
     files: {
       "/entry.ts": `
@@ -188,10 +262,25 @@ describe("bundler", () => {
     },
     run: { stdout: "ok" },
   });
-  itBundled("compile/ReactSSR", {
-    install: ["react@next", "react-dom@next"],
-    files: {
-      "/entry.tsx": /* tsx */ `
+
+  for (const additionalOptions of [
+    { bytecode: true, minify: true, format: "cjs" },
+    { format: "cjs" },
+    { format: "cjs", minify: true },
+    { format: "esm" },
+    { format: "esm", minify: true },
+  ]) {
+    const { bytecode = false, format, minify = false } = additionalOptions;
+    const NODE_ENV = minify ? "'production'" : undefined;
+    itBundled("compile/ReactSSR" + (bytecode ? "+bytecode" : "") + "+" + format + (minify ? "+minify" : ""), {
+      install: ["react@next", "react-dom@next"],
+      format,
+      minifySyntax: minify,
+      minifyIdentifiers: minify,
+      minifyWhitespace: minify,
+      define: NODE_ENV ? { "process.env.NODE_ENV": NODE_ENV } : undefined,
+      files: {
+        "/entry.tsx": /* tsx */ `
         import React from "react";
         import { renderToReadableStream } from "react-dom/server";
 
@@ -210,23 +299,37 @@ describe("bundler", () => {
           </html>
         );
 
-        const port = 0;
-        using server = Bun.serve({
-          port,
-          async fetch(req) {
-            return new Response(await renderToReadableStream(<App />), headers);
-          },
-        });
-        const res = await fetch(server.url);
-        if (res.status !== 200) throw "status error";
-        console.log(await res.text());
+        async function main() {
+          const port = 0;
+          using server = Bun.serve({
+            port,
+            async fetch(req) {
+              return new Response(await renderToReadableStream(<App />), headers);
+            },
+          });
+          const res = await fetch(server.url);
+          if (res.status !== 200) throw "status error";
+          console.log(await res.text());
+        }
+
+        main();
       `,
-    },
-    run: {
-      stdout: "<!DOCTYPE html><html><head></head><body><h1>Hello World</h1><p>This is an example.</p></body></html>",
-    },
-    compile: true,
-  });
+      },
+      run: {
+        stdout: "<!DOCTYPE html><html><head></head><body><h1>Hello World</h1><p>This is an example.</p></body></html>",
+        stderr: bytecode
+          ? "[Disk Cache] Cache hit for sourceCode\n[Disk Cache] Cache miss for sourceCode\n"
+          : undefined,
+        env: bytecode
+          ? {
+              BUN_JSC_verboseDiskCache: "1",
+            }
+          : undefined,
+      },
+      compile: true,
+      bytecode,
+    });
+  }
   itBundled("compile/DynamicRequire", {
     files: {
       "/entry.tsx": /* tsx */ `
diff --git a/test/bundler/bundler_defer.test.ts b/test/bundler/bundler_defer.test.ts
new file mode 100644
index 0000000000..c3becd5ac4
--- /dev/null
+++ b/test/bundler/bundler_defer.test.ts
@@ -0,0 +1,631 @@
+import { describe, expect, test } from "bun:test";
+import { itBundled } from './expectBundled';
+import { bunExe, bunEnv, tempDirWithFiles } from 'harness';
+import * as path from 'node:path';
+
+describe("defer", () => {
+  {
+    let state: string = "Should not see this!";
+
+    itBundled("works", {
+      experimentalCss: true,
+      minifyWhitespace: true,
+      files: {
+        "/entry.css": /* css */ `
+      body {
+        background: white;
+        color: blue; }
+    `,
+      },
+      plugins: [
+        {
+          name: "demo",
+          setup(build) {
+            build.onStart(() => {
+              state = "red";
+            });
+
+            build.onLoad({ filter: /\.css/ }, async ({ path }) => {
+              console.log("[plugin] Path", path);
+              return {
+                contents: `body { color: ${state} }`,
+                loader: "css",
+              };
+            });
+          },
+        },
+      ],
+      outfile: "/out.js",
+      onAfterBundle(api) {
+        api.expectFile("/out.js").toEqualIgnoringWhitespace(`body{color:${state}}`);
+      },
+    });
+  }
+
+  {
+    type Action = "onLoad" | "onStart";
+    let actions: Action[] = [];
+
+    itBundled("executes before everything", {
+      experimentalCss: true,
+      minifyWhitespace: true,
+      files: {
+        "/entry.css": /* css */ `
+      body {
+        background: white;
+        color: blue; }
+    `,
+      },
+      plugins: [
+        {
+          name: "demo",
+          setup(build) {
+            build.onLoad({ filter: /\.css/ }, async ({ path }) => {
+              actions.push("onLoad");
+              return {
+                contents: `body { color: red }`,
+                loader: "css",
+              };
+            });
+
+            build.onStart(() => {
+              actions.push("onStart");
+            });
+          },
+        },
+      ],
+      outfile: "/out.js",
+      onAfterBundle(api) {
+        api.expectFile("/out.js").toEqualIgnoringWhitespace(`body{ color: red }`);
+
+        expect(actions).toStrictEqual(["onStart", "onLoad"]);
+      },
+    });
+  }
+
+  {
+    let action: string[] = [];
+    itBundled("executes after all plugins have been setup", {
+      experimentalCss: true,
+      minifyWhitespace: true,
+      files: {
+        "/entry.css": /* css */ `
+      body {
+        background: white;
+        color: blue; }
+    `,
+      },
+      plugins: [
+        {
+          name: "onStart 1",
+          setup(build) {
+            build.onStart(async () => {
+              action.push("onStart 1 setup");
+              await Bun.sleep(1000);
+              action.push("onStart 1 complete");
+            });
+          },
+        },
+        {
+          name: "onStart 2",
+          setup(build) {
+            build.onStart(async () => {
+              action.push("onStart 2 setup");
+              await Bun.sleep(1000);
+              action.push("onStart 2 complete");
+            });
+          },
+        },
+        {
+          name: "onStart 3",
+          setup(build) {
+            build.onStart(async () => {
+              action.push("onStart 3 setup");
+              await Bun.sleep(1000);
+              action.push("onStart 3 complete");
+            });
+          },
+        },
+      ],
+      outfile: "/out.js",
+      onAfterBundle(api) {
+        expect(action.slice(0, 3)).toStrictEqual(["onStart 1 setup", "onStart 2 setup", "onStart 3 setup"]);
+        expect(new Set(action.slice(3))).toStrictEqual(
+          new Set(["onStart 1 complete", "onStart 2 complete", "onStart 3 complete"]),
+        );
+      },
+    });
+  }
+
+  {
+    let action: string[] = [];
+    test("onstart throwing an error works", async () => {
+      const folder = tempDirWithFiles("plugin", {
+        "index.ts": "export const foo = {}",
+      });
+      try {
+        const result = await Bun.build({
+          entrypoints: [path.join(folder, "index.ts")],
+          experimentalCss: true,
+          minify: true,
+          plugins: [
+            {
+              name: "onStart 1",
+              setup(build) {
+                build.onStart(async () => {
+                  action.push("onStart 1 setup");
+                  throw new Error("WOOPS");
+                });
+              },
+            },
+            {
+              name: "onStart 2",
+              setup(build) {
+                build.onStart(async () => {
+                  action.push("onStart 2 setup");
+                  await Bun.sleep(1000);
+                  action.push("onStart 2 complete");
+                });
+              },
+            },
+            {
+              name: "onStart 3",
+              setup(build) {
+                build.onStart(async () => {
+                  action.push("onStart 3 setup");
+                  await Bun.sleep(1000);
+                  action.push("onStart 3 complete");
+                });
+              },
+            },
+          ],
+        });
+        console.log(result);
+      } catch (err) {
+        expect(err).toBeDefined();
+        return;
+      }
+      throw new Error("DIDNT GET ERROR!");
+    });
+  }
+});
+
+describe("defer", () => {
+  {
+    type Action = {
+      type: "load" | "defer";
+      path: string;
+    };
+    let actions: Action[] = [];
+    function logLoad(path: string) {
+      actions.push({ type: "load", path: path.replaceAll("\\", "/") });
+    }
+    function logDefer(path: string) {
+      actions.push({ type: "defer", path: path.replaceAll("\\", "/") });
+    }
+
+    itBundled("basic", {
+      experimentalCss: true,
+      files: {
+        "/index.ts": /* ts */ `
+          import { lmao } from "./lmao.ts";
+          import foo from "./a.css";
+
+          console.log("Foo", foo, lmao);
+            `,
+                  "/lmao.ts": `
+          import { foo } from "./foo.ts";
+          export const lmao = "lolss";
+          console.log(foo);
+            `,
+                  "/foo.ts": `
+            export const foo = 'lkdfjlsdf';
+            console.log('hi')`,
+                  "/a.css": `
+            h1 {
+              color: blue;
+            }
+        `,
+      },
+      entryPoints: ["index.ts"],
+      plugins: [
+        {
+          name: "demo",
+          setup(build) {
+            build.onLoad({ filter: /\.(ts)/ }, async ({ defer, path }) => {
+              // console.log("Running on load plugin", path);
+              if (path.includes("index.ts")) {
+                logLoad(path);
+                return undefined;
+              }
+              logDefer(path);
+              await defer();
+              logLoad(path);
+              return undefined;
+            });
+          },
+        },
+      ],
+      outdir: "/out",
+      onAfterBundle(api) {
+        const expected_actions: Action[] = [
+          {
+            type: "load",
+            path: "index.ts",
+          },
+          {
+            type: "defer",
+            path: "lmao.ts",
+          },
+          {
+            type: "load",
+            path: "lmao.ts",
+          },
+          {
+            type: "defer",
+            path: "foo.ts",
+          },
+          {
+            type: "load",
+            path: "foo.ts",
+          },
+        ];
+
+        expect(actions.length).toBe(expected_actions.length);
+        for (let i = 0; i < expected_actions.length; i++) {
+          const expected = expected_actions[i];
+          const action = actions[i];
+          const filename = action.path.split("/").pop();
+
+          expect(action.type).toEqual(expected.type);
+          expect(filename).toEqual(expected.path);
+        }
+      },
+    });
+  }
+
+  itBundled("edgecase", {
+    experimentalCss: true,
+    minifyWhitespace: true,
+    files: {
+      "/entry.css": /* css */ `
+      body {
+        background: white;
+        color: black }
+    `,
+    },
+    plugins: [
+      {
+        name: "demo",
+        setup(build) {
+          build.onLoad({ filter: /\.css/ }, async ({ path }) => {
+            console.log("[plugin] Path", path);
+            return {
+              contents: 'h1 [this_worked="nice!"] { color: red; }',
+              loader: "css",
+            };
+          });
+        },
+      },
+    ],
+    outfile: "/out.js",
+    onAfterBundle(api) {
+      api.expectFile("/out.js").toContain(`h1 [this_worked=nice\\!]{color:red}
+`);
+    },
+  });
+
+  // encountered double free when CSS build has error
+  itBundled("shouldn't crash on CSS parse error", {
+    experimentalCss: true,
+    files: {
+      "/index.ts": /* ts */ `
+import { lmao } from "./lmao.ts";
+import foo from "./a.css";
+
+console.log("Foo", foo, lmao);
+    `,
+      "/lmao.ts": `
+import { foo } from "./foo.ts";
+export const lmao = "lolss";
+console.log(foo);
+    `,
+      "/foo.ts": `
+export const foo = "LOL bro";
+console.log("FOOOO", foo);
+    `,
+      "/a.css": `
+    /* helllooo friends */
+          `,
+    },
+    entryPoints: ["index.ts"],
+    plugins: [
+      {
+        name: "demo",
+        setup(build) {
+          build.onLoad({ filter: /\.css/ }, async ({ path }) => {
+            console.log("[plugin] CSS path", path);
+            return {
+              // this fails, because it causes a Build error I think?
+              contents: `hello friends`,
+              loader: "css",
+            };
+          });
+
+          build.onLoad({ filter: /\.(ts)/ }, async ({ defer, path }) => {
+            // console.log("Running on load plugin", path);
+            if (path.includes("index.ts")) {
+              console.log("[plugin] Path", path);
+              return undefined;
+            }
+            await defer();
+            return undefined;
+          });
+        },
+      },
+    ],
+    outdir: "/out",
+    bundleErrors: {
+      "/a.css": ["Unexpected end of input"],
+    },
+  });
+
+  itBundled("works as expected when onLoad error occurs after defer", {
+    experimentalCss: true,
+    files: {
+      "/index.ts": /* ts */ `
+import { lmao } from "./lmao.ts";
+import foo from "./a.css";
+
+console.log("Foo", foo, lmao);
+    `,
+      "/lmao.ts": `
+import { foo } from "./foo.ts";
+export const lmao = "lolss";
+console.log(foo);
+    `,
+      "/foo.ts": `
+export const foo = "LOL bro";
+console.log("FOOOO", foo);
+    `,
+      "/a.css": `
+    /* helllooo friends */
+          `,
+    },
+    entryPoints: ["index.ts"],
+    plugins: [
+      {
+        name: "demo",
+        setup(build) {
+          build.onLoad({ filter: /\.css/ }, async ({ path }) => {
+            return {
+              // this fails, because it causes a Build error I think?
+              contents: `hello friends`,
+              loader: "css",
+            };
+          });
+
+          build.onLoad({ filter: /\.(ts)/ }, async ({ defer, path }) => {
+            if (path.includes("index.ts")) {
+              return undefined;
+            }
+            await defer();
+            throw new Error("woopsie");
+          });
+        },
+      },
+    ],
+    outdir: "/out",
+    bundleErrors: {
+      "/a.css": ["Unexpected end of input"],
+      "/lmao.ts": ["woopsie"],
+    },
+  });
+
+  itBundled("calling defer more than once errors", {
+    experimentalCss: true,
+    files: {
+      "/index.ts": /* ts */ `
+import { lmao } from "./lmao.ts";
+import foo from "./a.css";
+
+console.log("Foo", foo, lmao);
+    `,
+      "/lmao.ts": `
+import { foo } from "./foo.ts";
+export const lmao = "lolss";
+console.log(foo);
+    `,
+      "/foo.ts": `
+export const foo = "LOL bro";
+console.log("FOOOO", foo);
+    `,
+      "/a.css": `
+    /* helllooo friends */
+          `,
+    },
+    entryPoints: ["index.ts"],
+    plugins: [
+      {
+        name: "demo",
+        setup(build) {
+          build.onLoad({ filter: /\.css/ }, async ({ path }) => {
+            return {
+              // this fails, because it causes a Build error I think?
+              contents: `hello friends`,
+              loader: "css",
+            };
+          });
+
+          build.onLoad({ filter: /\.(ts)/ }, async ({ defer, path }) => {
+            if (path.includes("index.ts")) {
+              return undefined;
+            }
+            await defer();
+            await defer();
+          });
+        },
+      },
+    ],
+    outdir: "/out",
+    bundleErrors: {
+      "/a.css": ["Unexpected end of input"],
+      "/lmao.ts": ["Can't call .defer() more than once within an onLoad plugin"],
+    },
+  });
+
+  test("integration", async () => {
+    const folder = tempDirWithFiles("integration", {
+      "module_data.json": "{}",
+      "package.json": `{
+    "name": "integration-test",
+    "version": "1.0.0",
+    "private": true,
+    "type": "module",
+    "dependencies": {
+    }
+  }`,
+      "src/index.ts": `
+import { greet } from "./utils/greetings";
+import { formatDate } from "./utils/dates";
+import { calculateTotal } from "./math/calculations";
+import { logger } from "./services/logger";
+import moduleData from "../module_data.json";
+import path from "path";
+
+
+await Bun.write(path.join(import.meta.dirname, 'output.json'), JSON.stringify(moduleData))
+
+function main() {
+const today = new Date();
+logger.info("Application started");
+
+const total = calculateTotal([10, 20, 30, 40]);
+console.log(greet("World"));
+console.log(\`Today is \${formatDate(today)}\`);
+console.log(\`Total: \${total}\`);
+}
+`,
+      "src/utils/greetings.ts": `
+export function greet(name: string): string {
+return \`Hello \${name}!\`;
+}
+`,
+      "src/utils/dates.ts": `
+export function formatDate(date: Date): string {
+return date.toLocaleDateString("en-US", {
+weekday: "long",
+year: "numeric", 
+month: "long",
+day: "numeric"
+});
+}
+`,
+      "src/math/calculations.ts": `
+export function calculateTotal(numbers: number[]): number {
+return numbers.reduce((sum, num) => sum + num, 0);
+}
+
+export function multiply(a: number, b: number): number {
+return a * b;
+}
+`,
+      "src/services/logger.ts": `
+export const logger = {
+info: (msg: string) => console.log(\`[INFO] \${msg}\`),
+error: (msg: string) => console.error(\`[ERROR] \${msg}\`),
+warn: (msg: string) => console.warn(\`[WARN] \${msg}\`)
+};
+`,
+    });
+
+    const entrypoint = path.join(folder, "src", "index.ts");
+    await Bun.$`${bunExe()} install`.env(bunEnv).cwd(folder);
+
+    const outdir = path.join(folder, "dist");
+
+    const result = await Bun.build({
+      entrypoints: [entrypoint],
+      outdir,
+      plugins: [
+        {
+          name: "xXx123_import_checker_321xXx",
+          setup(build) {
+            type Import = {
+              imported: string[];
+              dep: string;
+            };
+            type Export = {
+              ident: string;
+            };
+            let imports_and_exports: Record<string, { imports: Array<Import>; exports: Array<Export> }> = {};
+
+            build.onLoad({ filter: /\.ts/ }, async ({ path }) => {
+              const contents = await Bun.$`cat ${path}`.quiet().text();
+
+              const import_regex = /import\s+(?:([\s\S]*?)\s+from\s+)?['"]([^'"]+)['"];/g;
+              const imports: Array<Import> = [...contents.toString().matchAll(import_regex)].map(m => ({
+                imported: m
+                  .slice(1, m.length - 1)
+                  .map(match => (match[0] === "{" ? match.slice(2, match.length - 2) : match)),
+                dep: m[m.length - 1],
+              }));
+
+              const export_regex =
+                /export\s+(?:default\s+|const\s+|let\s+|var\s+|function\s+|class\s+|enum\s+|type\s+|interface\s+)?([\w$]+)?(?:\s*=\s*|(?:\s*{[^}]*})?)?[^;]*;/g;
+              const exports: Array<Export> = [...contents.matchAll(export_regex)].map(m => ({
+                ident: m[1],
+              }));
+
+              imports_and_exports[path.replaceAll("\\", "/").split("/").pop()!] = { imports, exports };
+              return undefined;
+            });
+
+            build.onLoad({ filter: /module_data\.json/ }, async ({ defer }) => {
+              await defer();
+              const contents = JSON.stringify(imports_and_exports);
+
+              return {
+                contents,
+                loader: "json",
+              };
+            });
+          },
+        },
+      ],
+    });
+
+    expect(result.success).toBeTrue();
+    await Bun.$`${bunExe()} run ${result.outputs[0].path}`;
+    const output = await Bun.$`cat ${path.join(folder, "dist", "output.json")}`.json();
+    expect(output).toStrictEqual({
+      "index.ts": {
+        "imports": [
+          { "imported": ["greet"], "dep": "./utils/greetings" },
+          { "imported": ["formatDate"], "dep": "./utils/dates" },
+          { "imported": ["calculateTotal"], "dep": "./math/calculations" },
+          { "imported": ["logger"], "dep": "./services/logger" },
+          { "imported": ["moduleData"], "dep": "../module_data.json" },
+          { "imported": ["path"], "dep": "path" },
+        ],
+        "exports": [],
+      },
+      "greetings.ts": {
+        "imports": [],
+        "exports": [{ "ident": "greet" }],
+      },
+      "dates.ts": {
+        "imports": [],
+        "exports": [{ "ident": "formatDate" }],
+      },
+      "calculations.ts": {
+        "imports": [],
+        "exports": [{ "ident": "calculateTotal" }, { "ident": "multiply" }],
+      },
+      "logger.ts": {
+        "imports": [],
+        "exports": [{ "ident": "logger" }],
+      },
+    });
+  });
+});
diff --git a/test/bundler/bundler_drop.test.ts b/test/bundler/bundler_drop.test.ts
new file mode 100644
index 0000000000..a50bda9f58
--- /dev/null
+++ b/test/bundler/bundler_drop.test.ts
@@ -0,0 +1,109 @@
+import { describe } from 'bun:test';
+import { itBundled } from "./expectBundled";
+
+describe("bundler", () => {
+  itBundled("drop/FunctionCall", {
+    files: {
+      "/a.js": `console.log("hello");`,
+    },
+    run: { stdout: "" },
+    drop: ["console"],
+    backend: "api",
+  });
+  itBundled("drop/DebuggerStmt", {
+    files: {
+      "/a.js": `if(true){debugger;debugger;};debugger;function y(){ debugger; }y()`,
+    },
+    drop: ["debugger"],
+    backend: "api",
+    onAfterBundle(api) {
+      api.expectFile("out.js").not.toInclude("debugger");
+    },
+  });
+  itBundled("drop/NoDisableDebugger", {
+    files: {
+      "/a.js": `if(true){debugger;debugger;};debugger;function y(){ debugger; }y();`,
+    },
+    backend: "api",
+    onAfterBundle(api) {
+      api.expectFile("out.js").toIncludeRepeated("debugger", 4);
+    },
+  });
+  itBundled("drop/RemovesSideEffects", {
+    files: {
+      "/a.js": `console.log(alert());`,
+    },
+    run: { stdout: "" },
+    drop: ["console"],
+    backend: "api",
+  });
+  itBundled("drop/ReassignKeepsOutput", {
+    files: {
+      "/a.js": `var call = console.log; call("hello");`,
+    },
+    run: { stdout: "hello" },
+    drop: ["console"],
+    backend: "api",
+  });
+  itBundled("drop/AssignKeepsOutput", {
+    files: {
+      "/a.js": `var call = console.log("a"); globalThis.console.log(call);`,
+    },
+    run: { stdout: "undefined" },
+    drop: ["console"],
+    backend: "api",
+  });
+  itBundled("drop/UnaryExpression", {
+    files: {
+      "/a.js": `Bun.inspect(); console.log("hello");`,
+    },
+    run: { stdout: "" },
+    drop: ["console"],
+    backend: "api",
+  });
+  itBundled("drop/0Args", {
+    files: {
+      "/a.js": `console.log();`,
+    },
+    run: { stdout: "" },
+    drop: ["console"],
+  });
+  itBundled("drop/BecomesUndefined", {
+    files: {
+      "/a.js": `console.log(Bun.inspect.table());`,
+    },
+    run: { stdout: "undefined" },
+    drop: ["Bun.inspect.table"],
+  });
+  itBundled("drop/BecomesUndefinedNested1", {
+    files: {
+      "/a.js": `console.log(Bun.inspect.table());`,
+    },
+    run: { stdout: "undefined" },
+    drop: ["Bun.inspect"],
+  });
+  itBundled("drop/BecomesUndefinedNested2", {
+    files: {
+      "/a.js": `console.log(Bun.inspect.table());`,
+    },
+    run: { stdout: "undefined" },
+    drop: ["Bun"],
+  });
+  itBundled("drop/AssignTarget", {
+    files: {
+      "/a.js": `console.log(
+      (
+      Bun.inspect.table = (() => 123) 
+    )());`,
+    },
+    run: { stdout: "123" },
+    drop: ["Bun"],
+  });
+  itBundled("drop/DeleteAssignTarget", {
+    files: {
+      "/a.js": `console.log((delete Bun.inspect()));`,
+    },
+    run: { stdout: "true" },
+    drop: ["Bun"],
+  });
+});
diff --git a/test/bundler/bundler_edgecase.test.ts b/test/bundler/bundler_edgecase.test.ts
index 866c98d0ea..9d46ebf0b3 100644
--- a/test/bundler/bundler_edgecase.test.ts
+++ b/test/bundler/bundler_edgecase.test.ts
@@ -1,6 +1,7 @@
 import { describe, expect } from "bun:test";
 import { join } from "node:path";
 import { itBundled } from "./expectBundled";
+import { isBroken, isWindows } from "harness";
 
 describe("bundler", () => {
   itBundled("edgecase/EmptyFile", {
@@ -484,6 +485,7 @@ describe("bundler", () => {
       stdout: "success",
     },
   });
+
   itBundled("edgecase/StaticClassNameIssue2806", {
     files: {
       "/entry.ts": /* ts */ `
@@ -1121,7 +1123,7 @@ describe("bundler", () => {
     snapshotSourceMap: {
       "entry.js.map": {
         files: ["../node_modules/react/index.js", "../entry.js"],
-        mappingsExactMatch: "uYACA,WAAW,IAAQ,EAAE,ICDrB,eACA,QAAQ,IAAI,CAAK",
+        mappingsExactMatch: "qYACA,WAAW,IAAQ,EAAE,ICDrB,eACA,QAAQ,IAAI,CAAK",
       },
     },
   });
@@ -1344,6 +1346,8 @@ describe("bundler", () => {
     },
     target: "bun",
     run: true,
+    todo: isBroken && isWindows,
+    debugTimeoutScale: 5,
   });
   itBundled("edgecase/PackageExternalDoNotBundleNodeModules", {
     files: {
@@ -1831,6 +1835,246 @@ describe("bundler", () => {
     },
     run: { stdout: "1\n2" },
   });
+  itBundled("edgecase/Latin1StringInImportedJSON", {
+    files: {
+      "/entry.ts": `
+        import x from './second.json';
+        console.log(x + 'a');
+      `,
+      "/second.json": `
+        "测试"
+      `,
+    },
+    target: "bun",
+    run: { stdout: `测试a` },
+  });
+  itBundled("edgecase/Latin1StringInImportedJSONBrowser", {
+    files: {
+      "/entry.ts": `
+        import x from './second.json';
+        console.log(x + 'a');
+      `,
+      "/second.json": `
+        "测试"
+      `,
+    },
+    target: "browser",
+    run: { stdout: `测试a` },
+  });
+  itBundled("edgecase/Latin1StringKey", {
+    files: {
+      "/entry.ts": `
+        import x from './second.json';
+        console.log(x["测试" + "a"]);
+      `,
+      "/second.json": `
+        {"测试a" : 123}
+      `,
+    },
+    target: "bun",
+    run: { stdout: `123` },
+  });
+  itBundled("edgecase/Latin1StringKeyBrowser", {
+    files: {
+      "/entry.ts": `
+        import x from './second.json';
+        console.log(x["测试" + "a"]);
+      `,
+      "/second.json": `
+        {"测试a" : 123}
+      `,
+    },
+    target: "browser",
+    run: { stdout: `123` },
+  });
+
+  itBundled("edgecase/UninitializedVariablesMoved", {
+    files: {
+      "/entry.ts": `
+        await import('./b.js');
+      `,
+      "/b.js": `
+        export var a = 32;
+        export var b;
+        (function (c) {
+            c.d = 1;
+        })(b ?? {});
+        +a;
+      `,
+    },
+    minifySyntax: true,
+    run: true, // pass if no thrown error
+  });
+
+  itBundled("edgecase/UsingExportDefault", {
+    files: {
+      "/entry.ts": `
+        import module from "./module.ts";
+        console.log(module.x);
+      `,
+      "/module.ts": `
+        using a = {
+          [Symbol.dispose]: () => {
+            console.log("Disposing");
+          }
+        };
+        export default {x: 1};
+      `,
+    },
+    run: {
+      stdout: "Disposing\n1",
+    },
+  });
+
+  itBundled("edgecase/UsingExportClass", {
+    files: {
+      "/entry.ts": `
+        export class A {
+          [Symbol.dispose](){
+            console.info("Disposing");
+          }
+        }
+        using a = new A();
+      `,
+    },
+    run: {
+      stdout: "Disposing",
+    },
+  });
+
+  itBundled("edgecase/UsingExportDefaultThrows", {
+    files: {
+      "/entry.ts": `
+        import("./module.ts").catch(error => {
+          console.log("Caught error:", error.message);
+        });
+      `,
+      "/module.ts": `
+        function somethingThatThrows() {
+          throw new Error("This function throws");
+        }
+
+        using disposable = {
+          [Symbol.dispose]: () => {
+            console.log("Disposing");
+          }
+        };
+
+        export default somethingThatThrows();
+      `,
+    },
+    run: {
+      stdout: "Disposing\nCaught error: This function throws",
+    },
+  });
+
+  itBundled("edgecase/UsingExportDefaultAsync", {
+    files: {
+      "/entry.ts": `
+        const result = await import("./importer.ts");
+        console.log(await result.default);
+      `,
+      "/importer.ts": `
+        async function main() {
+          using disposable = {
+            [Symbol.dispose]: () => {
+              console.log("Disposing");
+            }
+          };
+          return "Success";
+        }
+        export default main();
+      `,
+    },
+    run: {
+      stdout: "Disposing\nSuccess",
+    },
+  });
+
+  itBundled("edgecase/UsingDisposeThrowDoesntMask", {
+    files: {
+      "/entry.ts": `
+        using a = {
+          [Symbol.dispose]: () => {
+            throw new Error("Error");
+          }
+        };
+        using b = {
+          [Symbol.dispose]: () => {
+            console.log("Disposing");
+          }
+        }
+      `,
+    },
+    run: {
+      error: "error: Error",
+      stdout: "Disposing",
+    },
+  });
+
+  itBundled("edgecase/UsingExportFails", {
+    files: {
+      "/entry.ts": `
+        import a from "./import.ts";
+        console.log(a.ok);
+      `,
+      "/import.ts": `
+        using a = {
+          [Symbol.dispose]: () => {
+            console.log("Disposing");
+          },
+          ok: true,
+        };
+        export default a;
+      `,
+    },
+    run: {
+      stdout: "Disposing\ntrue",
+    },
+  });
+
+  itBundled("edgecase/NoOutWithTwoFiles", {
+    files: {
+      "/entry.ts": `
+        import index from './index.html'
+        console.log(index);
+      `,
+      "/index.html": `
+        <head></head>
+      `,
+    },
+    generateOutput: false,
+    backend: "api",
+    onAfterApiBundle: async build => {
+      expect(build.success).toEqual(true);
+      expect(build.outputs).toBeArrayOfSize(2);
+
+      expect(build.outputs[0].path).toEqual("./entry.js");
+      expect(build.outputs[0].loader).toEqual("ts");
+      expect(build.outputs[0].kind).toEqual("entry-point");
+
+      expect(build.outputs[1].loader).toEqual("file");
+      expect(build.outputs[1].kind).toEqual("asset");
+      expect(await build.outputs[1].text()).toEqual("<head></head>");
+    },
+  });
+
+  itBundled("edgecase/OutWithTwoFiles", {
+    files: {
+      "/entry.ts": `
+        import index from './index.html'
+        console.log(index);
+      `,
+      "/index.html": `
+        <head></head>
+      `,
+    },
+    generateOutput: true,
+    bundleErrors: {
+      "<bun>": ["cannot write multiple output files without an output directory"],
+    },
+    run: true,
+  });
 
   // TODO(@paperdave): test every case of this. I had already tested it manually, but it may break later
   const requireTranspilationListESM = [
@@ -1840,5 +2084,194 @@ describe("bundler", () => {
     ["typeof require", "import.meta.require", "typeof __require"],
   ];
 
-  // itBundled('edgecase/RequireTranspilation')
+  // // itBundled('edgecase/RequireTranspilation')
+
+  itBundled("edgecase/TSConfigPathsConfigDir", {
+    files: {
+      "/src/entry.ts": /* ts */ `
+        import { value } from "alias/foo";
+        import { other } from "@scope/bar";
+        import { nested } from "deep/path";
+        import { absolute } from "abs/path";
+        console.log(value, other, nested, absolute);
+      `,
+      "/src/actual/foo.ts": `export const value = "foo";`,
+      "/src/lib/bar.ts": `export const other = "bar";`,
+      "/src/nested/deep/file.ts": `export const nested = "nested";`,
+      "/src/absolute.ts": `export const absolute = "absolute";`,
+      "/src/tsconfig.json": /* json */ `{
+        "compilerOptions": {
+          "baseUrl": "\${configDir}",
+          "paths": {
+            "alias/*": ["actual/*"],
+            "@scope/*": ["lib/*"],
+            "deep/path": ["nested/deep/file.ts"],
+            "abs/*": ["\${configDir}/absolute.ts"]
+          }
+        }
+      }`,
+    },
+    run: {
+      stdout: "foo bar nested absolute",
+    },
+  });
+
+  itBundled("edgecase/TSConfigBaseUrlConfigDir", {
+    files: {
+      "/entry.ts": /* ts */ `
+        import { value } from "./src/subdir/module";
+        console.log(value);
+      `,
+      "/src/lib/module.ts": `export const value = "found";`,
+      "/src/subdir/module.ts": `
+        import { value } from "absolute";
+        export { value };
+      `,
+      "tsconfig.json": /* json */ `{
+        "compilerOptions": {
+          "baseUrl": "\${configDir}/src/lib",
+          "paths": {
+            "absolute": ["./module.ts"]
+          }
+        }
+      }`,
+    },
+    run: {
+      stdout: "found",
+    },
+  });
+
+  itBundled("edgecase/TSConfigPathsConfigDirWildcard", {
+    files: {
+      "/src/entry.ts": /* ts */ `
+        import { one } from "prefix/one";
+        import { two } from "prefix/two";
+        import { three } from "other/three";
+        console.log(one, two, three);
+      `,
+      "/src/modules/one.ts": `export const one = "one";`,
+      "/src/modules/two.ts": `export const two = "two";`,
+      "/src/alternate/three.ts": `export const three = "three";`,
+      "/src/tsconfig.json": /* json */ `{
+        "compilerOptions": {
+          "baseUrl": "\${configDir}",
+          "paths": {
+            "prefix/*": ["modules/*"],
+            "other/*": ["\${configDir}/alternate/*"]
+          }
+        }
+      }`,
+    },
+    run: {
+      stdout: "one two three",
+    },
+  });
+
+  itBundled("edgecase/TSConfigPathsConfigDirNested", {
+    files: {
+      "/deeply/nested/src/entry.ts": /* ts */ `
+        import { value } from "alias/module";
+        console.log(value);
+      `,
+      "/deeply/nested/src/actual/module.ts": `export const value = "nested";`,
+      "/deeply/nested/src/tsconfig.json": /* json */ `{
+        "compilerOptions": {
+          "baseUrl": "\${configDir}",
+          "paths": {
+            "alias/*": ["actual/*"]
+          }
+        }
+      }`,
+    },
+    run: {
+      stdout: "nested",
+    },
+  });
+
+  itBundled("edgecase/TSConfigPathsConfigDirMultiple", {
+    files: {
+      "/src/entry.ts": /* ts */ `
+        import { value } from "multi/module";
+        console.log(value);
+      `,
+      "/src/fallback/module.ts": `export const value = "fallback";`,
+      "/src/primary/module.ts": `export const value = "primary";`,
+      "/src/tsconfig.json": /* json */ `{
+        "compilerOptions": {
+          "baseUrl": "\${configDir}",
+          "paths": {
+            "multi/*": [
+              "\${configDir}/primary/*",
+              "\${configDir}/fallback/*"
+            ]
+          }
+        }
+      }`,
+    },
+    run: {
+      stdout: "primary",
+    },
+  });
+
+  itBundled("edgecase/TSConfigPathsConfigDirInvalid", {
+    files: {
+      "/entry.ts": /* ts */ `
+        import { value } from "invalid/module";
+        console.log(value);
+      `,
+      "/tsconfig.json": /* json */ `{
+        "compilerOptions": {
+          "baseUrl": "\${configDir}",
+          "paths": {
+            "invalid/*": ["\${configDir}/\${configDir}/*"]
+          }
+        }
+      }`,
+    },
+    bundleErrors: {
+      "/entry.ts": ['Could not resolve: "invalid/module". Maybe you need to "bun install"?'],
+    },
+  });
+
+  itBundled("edgecase/TSConfigPathsConfigDirBackslash", {
+    files: {
+      "/entry.ts": /* ts */ `
+        import { value } from "windows/style";
+        console.log(value);
+      `,
+      "/win/style.ts": `export const value = "windows";`,
+      "/tsconfig.json": /* json */ `{
+        "compilerOptions": {
+          "baseUrl": "\${configDir}",
+          "paths": {
+            "windows/*": ["win\\\\*"]
+          }
+        }
+      }`,
+    },
+    run: {
+      stdout: "windows",
+    },
+  });
+
+  itBundled("edgecase/TSPublicFieldMinification", {
+    files: {
+      "/entry.ts": /* ts */ `
+        export class Foo {
+          constructor(public name: string) {}
+        }
+
+        const keys = Object.keys(new Foo('test'))
+        if (keys.length !== 1) throw new Error('Keys length is not 1')
+        if (keys[0] !== 'name') throw new Error('keys[0] is not "name"')
+        console.log('success')
+      `,
+    },
+    minifySyntax: true,
+    minifyIdentifiers: true,
+    target: "bun",
+    run: {
+      stdout: "success",
+    },
+  });
 });
diff --git a/test/bundler/bundler_footer.test.ts b/test/bundler/bundler_footer.test.ts
new file mode 100644
index 0000000000..3f79d46fe5
--- /dev/null
+++ b/test/bundler/bundler_footer.test.ts
@@ -0,0 +1,29 @@
+import { describe } from "bun:test";
+import { itBundled } from "./expectBundled";
+
+describe("bundler", () => {
+  itBundled("footer/CommentFooter", {
+    footer: "// developed with love in SF",
+    files: {
+      "/a.js": `console.log("Hello, world!")`,
+    },
+    onAfterBundle(api) {
+      api.expectFile("out.js").toEndWith('// developed with love in SF"\n');
+    },
+  });
+  itBundled("footer/MultilineFooter", {
+    footer: `/**
+ * This is copyright of [...] ${new Date().getFullYear()}
+ * do not redistribute without consent of [...]
+*/`,
+    files: {
+      "index.js": `console.log("Hello, world!")`,
+    },
+    onAfterBundle(api) {
+      api.expectFile("out.js").toEndWith(`/**
+ * This is copyright of [...] ${new Date().getFullYear()}
+ * do not redistribute without consent of [...]
+*/\"\n`);
+    },
+  });
+});
diff --git a/test/bundler/bundler_kit_dev.test.ts b/test/bundler/bundler_kit_dev.test.ts
deleted file mode 100644
index 7a978eb4c3..0000000000
--- a/test/bundler/bundler_kit_dev.test.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-import { describe } from "bun:test";
-import { itBundled } from "./expectBundled";
-
-describe("bundler", async () => {
-  itBundled("kit_dev/HelloWorld", {
-    files: {
-      "/a.js": `console.log("Hello, world!")`,
-    },
-    format: "internal_kit_dev",
-    target: "bun",
-    run: { stdout: "Hello, world!" },
-    onAfterBundle(api) {
-      // `importSync` is one of the functions the runtime includes.
-      // it is on a property access so it will not be mangled
-      api.expectFile("out.js").toContain("importSync");
-    },
-  });
-  itBundled("kit_dev/SimpleCommonJS", {
-    files: {
-      "/a.js": `console.log(require('./b').message)`,
-      "/b.js": `module.exports = { message: "Hello, world!" }`,
-    },
-    format: "internal_kit_dev",
-    target: "bun",
-    run: { stdout: "Hello, world!" },
-  });
-  itBundled("kit_dev/SimpleESM", {
-    files: {
-      "/a.js": `
-        import message from './b';
-        console.log(message);
-      `,
-      "/b.js": `export default "Hello, world!"`,
-    },
-    format: "internal_kit_dev",
-    target: "bun",
-    run: { stdout: "Hello, world!" },
-  });
-});
diff --git a/test/bundler/bundler_loader.test.ts b/test/bundler/bundler_loader.test.ts
index c6f1e3ce3c..3611d9c3b9 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 97c4107bb0..8d07f3727c 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",
@@ -467,4 +474,32 @@ describe("bundler", () => {
       api.expectFile("/out.js").not.toContain("module");
     },
   });
+  itBundled("minify/ConstantFoldingUnaryPlusString", {
+    files: {
+      "/entry.ts": `
+        // supported
+        capture(+'1.0');
+        capture(+'-123.567');
+        capture(+'8.325');
+        capture(+'100000000');
+        capture(+'\\u0030\\u002e\\u0031');
+        capture(+'\\x30\\x2e\\x31');
+        capture(+'NotANumber');
+        // not supported
+        capture(+'æ');
+      `,
+    },
+    minifySyntax: true,
+    capture: [
+      "1",
+      "-123.567",
+      "8.325",
+      "1e8",
+      "0.1",
+      "0.1",
+      "NaN",
+      // untouched
+      '+"æ"',
+    ],
+  });
 });
diff --git a/test/bundler/bundler_npm.test.ts b/test/bundler/bundler_npm.test.ts
index b765e58598..58eb0aa8f2 100644
--- a/test/bundler/bundler_npm.test.ts
+++ b/test/bundler/bundler_npm.test.ts
@@ -57,17 +57,17 @@ describe("bundler", () => {
           "../entry.tsx",
         ],
         mappings: [
-          ["react.development.js:524:'getContextName'", "1:5428:Y1"],
-          ["react.development.js:2495:'actScopeDepth'", "1:26053:GJ++"],
-          ["react.development.js:696:''Component'", '1:7490:\'Component "%s"'],
-          ["entry.tsx:6:'\"Content-Type\"'", '1:221655:"Content-Type"'],
-          ["entry.tsx:11:'<html>'", "1:221911:void"],
-          ["entry.tsx:23:'await'", "1:222013:await"],
+          ["react.development.js:524:'getContextName'", "1:5426:Y1"],
+          ["react.development.js:2495:'actScopeDepth'", "23:4092:GJ++"],
+          ["react.development.js:696:''Component'", '1:7488:\'Component "%s"'],
+          ["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": 222283,
+      "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_plugin.test.ts b/test/bundler/bundler_plugin.test.ts
index 0918ff33a9..bd264f17dc 100644
--- a/test/bundler/bundler_plugin.test.ts
+++ b/test/bundler/bundler_plugin.test.ts
@@ -1,6 +1,8 @@
 import { describe, expect } from "bun:test";
-import { dirname, join, resolve } from "node:path";
+import path, { dirname, join, resolve } from "node:path";
 import { itBundled } from "./expectBundled";
+import { tempDirWithFiles } from "harness";
+import { test } from "bun:test";
 
 describe("bundler", () => {
   const loadFixture = {
@@ -687,6 +689,7 @@ describe("bundler", () => {
         expect(resolveCount).toBe(5050);
         expect(loadCount).toBe(101);
       },
+      debugTimeoutScale: 3,
     };
   });
   // itBundled("plugin/ManyPlugins", ({ root }) => {
@@ -829,3 +832,4 @@ describe("bundler", () => {
     };
   });
 });
+
diff --git a/test/bundler/bundler_string.test.ts b/test/bundler/bundler_string.test.ts
index 2b5901d782..88efba7780 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 4830840f38..070c6cea98 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/css/wpt/background-computed.test.ts b/test/bundler/css/wpt/background-computed.test.ts
new file mode 100644
index 0000000000..4a5c479df6
--- /dev/null
+++ b/test/bundler/css/wpt/background-computed.test.ts
@@ -0,0 +1,65 @@
+import { describe } from "bun:test";
+import { itBundled } from "../../expectBundled";
+
+const runTest = (property: string, input: string, expected: string) => {
+  const testTitle = `${property}: ${input}`;
+  itBundled(testTitle, {
+    experimentalCss: true,
+    files: {
+      "/a.css": /* css */ `
+h1 {
+    ${property}: ${input}
+}
+      `,
+    },
+    outfile: "out.css",
+
+    onAfterBundle(api) {
+      api.expectFile("/out.css").toEqualIgnoringWhitespace(`
+/* a.css */
+h1 {
+    ${property}: ${expected};
+}
+`);
+    },
+  });
+};
+
+describe("background-computed", () => {
+  runTest("background-attachment", "local", "local");
+  runTest("background-attachment", "scroll, fixed", "scroll, fixed");
+  runTest("background-attachment", "local, fixed, scroll", "local, fixed, scroll");
+  runTest("background-attachment", "local, fixed, scroll, fixed", "local, fixed, scroll, fixed");
+  runTest("background-clip", "border-box", "border-box");
+  runTest("background-clip", "content-box, border-box", "content-box, border-box");
+  runTest("background-clip", "border-box, padding-box, content-box", "border-box, padding-box, content-box");
+  runTest(
+    "background-clip",
+    "content-box, border-box, padding-box, content-box",
+    "content-box, border-box, padding-box, content-box",
+  );
+  runTest("background-clip", "content-box, border-box, padding-box", "content-box, border-box, padding-box");
+  runTest("background-clip", "content-box, border-box, border-area", "content-box, border-box, border-area");
+  runTest("background-color", "rgb(255, 0, 0)", "red");
+  runTest("background-origin", "border-box", "border-box");
+  runTest("background-origin", "content-box, border-box", "content-box, border-box");
+  runTest("background-origin", "border-box, padding-box, content-box", "border-box, padding-box, content-box");
+  runTest(
+    "background-origin",
+    "content-box, border-box, padding-box, content-box",
+    "content-box, border-box, padding-box, content-box",
+  );
+  runTest("background-position", "50% 6px", "50% 6px");
+  runTest("background-position", "12px 13px, 50% 6px", "12px 13px, 50% 6px");
+  runTest("background-position", "12px 13px, 50% 6px, 30px -10px", "12px 13px, 50% 6px, 30px -10px");
+  runTest(
+    "background-position",
+    "12px 13px, 50% 6px, 30px -10px, -7px 8px",
+    "12px 13px, 50% 6px, 30px -10px, -7px 8px",
+  );
+  runTest("background-position-x", "0.5em", ".5em");
+  runTest("background-position-x", "-20%, 10px", "-20%, 10px");
+  runTest("background-position-x", "center, left, right", "center, left, right");
+  runTest("background-position-x", "calc(10px - 0.5em), -20%, right, 15%", "calc(10px - .5em), -20%, right, 15%");
+  runTest("background-position-y", "0.5em", ".5em");
+});
diff --git a/test/bundler/css/wpt/color-computed-rgb.test.ts b/test/bundler/css/wpt/color-computed-rgb.test.ts
new file mode 100644
index 0000000000..e29ff07e54
--- /dev/null
+++ b/test/bundler/css/wpt/color-computed-rgb.test.ts
@@ -0,0 +1,202 @@
+import { describe } from "bun:test";
+import { itBundled } from "../../expectBundled";
+
+const runTest = (testTitle: string, input: string, expected: string) => {
+  testTitle = testTitle.length === 0 ? input : testTitle;
+  itBundled(testTitle, {
+    experimentalCss: true,
+    files: {
+      "/a.css": /* css */ `
+h1 {
+  color: ${input}
+}
+      `,
+    },
+    outfile: "out.css",
+
+    onAfterBundle(api) {
+      api.expectFile("/out.css").toEqualIgnoringWhitespace(`
+/* a.css */
+h1 {
+    color: ${expected};
+}
+`);
+    },
+  });
+};
+
+describe("color-computed-rgb", () => {
+  runTest("", "rgb(none none none)", "#000");
+  runTest("", "rgb(none none none / none)", "#0000");
+  runTest("", "rgb(128 none none)", "maroon");
+  runTest("", "rgb(128 none none / none)", "#80000000");
+  runTest("", "rgb(none none none / .5)", "#00000080");
+  runTest("", "rgb(20% none none)", "#300");
+  runTest("", "rgb(20% none none / none)", "#3000");
+  runTest("", "rgb(none none none / 50%)", "#00000080");
+  runTest("", "rgba(none none none)", "#000");
+  runTest("", "rgba(none none none / none)", "#0000");
+  runTest("", "rgba(128 none none)", "maroon");
+  runTest("", "rgba(128 none none / none)", "#80000000");
+  runTest("", "rgba(none none none / .5)", "#00000080");
+  runTest("", "rgba(20% none none)", "#300");
+  runTest("", "rgba(20% none none / none)", "#3000");
+  runTest("", "rgba(none none none / 50%)", "#00000080");
+  runTest("Tests that RGB channels are rounded appropriately", "rgb(2.5, 3.4, 4.6)", "#030305");
+  runTest("Valid numbers should be parsed", "rgb(00, 51, 102)", "#036");
+  runTest("Correct escape sequences should still parse", "r\\gb(00, 51, 102)", "#036");
+  runTest("Correct escape sequences should still parse", "r\\67 b(00, 51, 102)", "#036");
+  runTest("Capitalization should not affect parsing", "RGB(153, 204, 255)", "#9cf");
+  runTest("Capitalization should not affect parsing", "rgB(0, 0, 0)", "#000");
+  runTest("Capitalization should not affect parsing", "rgB(0, 51, 255)", "#03f");
+  runTest("Lack of whitespace should not affect parsing", "rgb(0,51,255)", "#03f");
+  runTest("Whitespace should not affect parsing", "rgb(0 ,  51 ,255)", "#03f");
+  runTest("Comments should be allowed within function", "rgb(/* R */0, /* G */51, /* B */255)", "#03f");
+  runTest("Invalid values should be clamped to 0 and 255 respectively", "rgb(-51, 306, 0)", "#0f0");
+  runTest("Valid percentages should be parsed", "rgb(42%, 3%, 50%)", "#6b0880");
+  runTest("Capitalization should not affect parsing", "RGB(100%, 100%, 100%)", "#fff");
+  runTest("Capitalization should not affect parsing", "rgB(0%, 0%, 0%)", "#000");
+  runTest("Capitalization should not affect parsing", "rgB(10%, 20%, 30%)", "#1a334d");
+  runTest("Whitespace should not affect parsing", "rgb(10%,20%,30%)", "#1a334d");
+  runTest("Whitespace should not affect parsing", "rgb(10%       ,  20% ,30%)", "#1a334d");
+  runTest("Comments should not affect parsing", "rgb(/* R */ 10%, /* G */ 20%, /* B */ 30%)", "#1a334d");
+  runTest("Invalid values should be clamped to 0 and 255 respectively", "rgb(-12%, 110%, 1400%)", "#0ff");
+  runTest("RGB and RGBA are synonyms", "rgb(0, 0, 0, 0)", "#0000");
+  runTest("RGB and RGBA are synonyms", "rgb(0%, 0%, 0%, 0%)", "#0000");
+  runTest("RGB and RGBA are synonyms", "rgb(0%, 0%, 0%, 0)", "#0000");
+  runTest("Valid numbers should be parsed", "rgba(0, 0, 0, 0)", "#0000");
+  runTest("Valid numbers should be parsed", "rgba(204, 0, 102, 0.3)", "#cc00664d");
+  runTest("Capitalization should not affect parsing", "RGBA(255, 255, 255, 0)", "#fff0");
+  runTest("Capitalization should not affect parsing", "rgBA(0, 51, 255, 1)", "#03f");
+  runTest("Invalid alpha values should be clamped to 0 and 1 respectively", "rgba(0, 51, 255, 1.1)", "#03f");
+  runTest("Invalid alpha values should be clamped to 0 and 1 respectively", "rgba(0, 51, 255, 37)", "#03f");
+  runTest("Valid numbers should be parsed", "rgba(0, 51, 255, 0.42)", "#0033ff6b");
+  runTest("Valid numbers should be parsed", "rgba(0, 51, 255, 0)", "#03f0");
+  runTest("Invalid alpha values should be clamped to 0 and 1 respectively", "rgba(0, 51, 255, -0.1)", "#03f0");
+  runTest("Invalid alpha values should be clamped to 0 and 1 respectively", "rgba(0, 51, 255, -139)", "#03f0");
+  runTest("Capitalization should not affect parsing", "RGBA(100%, 100%, 100%, 0)", "#fff0");
+  runTest("Valid percentages should be parsed", "rgba(42%, 3%, 50%, 0.3)", "#6b08804d");
+  runTest("Capitalization should not affect parsing", "rgBA(0%, 20%, 100%, 1)", "#03f");
+  runTest("Invalid alpha values should be clamped to 0 and 1 respectively", "rgba(0%, 20%, 100%, 1.1)", "#03f");
+  runTest("Invalid alpha values should be clamped to 0 and 1 respectively", "rgba(0%, 20%, 100%, 37)", "#03f");
+  runTest("Valid percentages should be parsed", "rgba(0%, 20%, 100%, 0.42)", "#0033ff6b");
+  runTest("Valid percentages should be parsed", "rgba(0%, 20%, 100%, 0)", "#03f0");
+  runTest("Invalid alpha values should be clamped to 0 and 1 respectively", "rgba(0%, 20%, 100%, -0.1)", "#03f0");
+  runTest("Invalid alpha values should be clamped to 0 and 1 respectively", "rgba(0%, 20%, 100%, -139)", "#03f0");
+  runTest("Percent alpha values are accepted in rgb/rgba", "rgba(255, 255, 255, 0%)", "#fff0");
+  runTest("Percent alpha values are accepted in rgb/rgba", "rgba(0%, 0%, 0%, 0%)", "#0000");
+  runTest("RGB and RGBA are synonyms", "rgba(0%, 0%, 0%)", "#000");
+  runTest("RGB and RGBA are synonyms", "rgba(0, 0, 0)", "#000");
+  runTest("Red channel resolves positive infinity to 255", "rgb(calc(infinity), 0, 0)", "red");
+  runTest("Green channel resolves positive infinity to 255", "rgb(0, calc(infinity), 0)", "#0f0");
+  runTest("Blue channel resolves positive infinity to 255", "rgb(0, 0, calc(infinity))", "#00f");
+  runTest("Alpha channel resolves positive infinity to fully opaque", "rgba(0, 0, 0, calc(infinity))", "#000");
+  runTest("Red channel resolves negative infinity to zero", "rgb(calc(-infinity), 0, 0)", "#000");
+  runTest("Green channel resolves negative infinity to zero", "rgb(0, calc(-infinity), 0)", "#000");
+  runTest("Blue channel resolves negative infinity to zero", "rgb(0, 0, calc(-infinity))", "#000");
+  runTest("Alpha channel resolves negative infinity to fully transparent", "rgba(0, 0, 0, calc(-infinity))", "#0000");
+  runTest("Red channel resolves NaN to zero", "rgb(calc(NaN), 0, 0)", "rgb(calc(NaN), 0, 0)");
+  runTest("Green channel resolves NaN to zero", "rgb(0, calc(NaN), 0)", "rgb(0, calc(NaN), 0)");
+  runTest("Blue channel resolves NaN to zero", "rgb(0, 0, calc(NaN))", "rgb(0, 0, calc(NaN))");
+  runTest("Alpha channel resolves NaN to zero", "rgba(0, 0, 0, calc(NaN))", "#0000");
+  runTest(
+    "Red channel resolves NaN equivalent calc statements to zero",
+    "rgb(calc(0 / 0), 0, 0)",
+    "rgb(calc(0 / 0), 0, 0)",
+  );
+  runTest(
+    "Green channel resolves NaN equivalent calc statements to zero",
+    "rgb(0, calc(0 / 0), 0)",
+    "rgb(0, calc(0 / 0), 0)",
+  );
+  runTest(
+    "Blue channel resolves NaN equivalent calc statements to zero",
+    "rgb(0, 0, calc(0 / 0))",
+    "rgb(0, 0, calc(0 / 0))",
+  );
+  runTest("Alpha channel resolves NaN equivalent calc statements to zero", "rgba(0, 0, 0, calc(0 / 0))", "#0000");
+  runTest("Variables above 255 get clamped to 255.", "rgb(var(--high), 0, 0)", "rgb(var(--high), 0, 0)");
+  runTest("Variables below 0 get clamped to 0.", "rgb(var(--negative), 64, 128)", "rgb(var(--negative), 64, 128)");
+  runTest(
+    "",
+    "rgb(calc(50% + (sign(1em - 10px) * 10%)), 0%, 0%, 50%)",
+    "rgb(calc(50% + (sign(1em - 10px) * 10%)), 0%, 0%, 50%)",
+  );
+  runTest(
+    "",
+    "rgba(calc(50% + (sign(1em - 10px) * 10%)), 0%, 0%, 50%)",
+    "rgba(calc(50% + (sign(1em - 10px) * 10%)), 0%, 0%, 50%)",
+  );
+  runTest(
+    "",
+    "rgb(calc(50 + (sign(1em - 10px) * 10)), 0, 0, 0.5)",
+    "rgb(calc(50 + (sign(1em - 10px) * 10)), 0, 0, .5)",
+  );
+  runTest(
+    "",
+    "rgba(calc(50 + (sign(1em - 10px) * 10)), 0, 0, 0.5)",
+    "rgba(calc(50 + (sign(1em - 10px) * 10)), 0, 0, .5)",
+  );
+  runTest(
+    "",
+    "rgb(0%, 0%, 0%, calc(50% + (sign(1em - 10px) * 10%)))",
+    "rgb(0%, 0%, 0%, calc(50% + (sign(1em - 10px) * 10%)))",
+  );
+  runTest(
+    "",
+    "rgba(0%, 0%, 0%, calc(50% + (sign(1em - 10px) * 10%)))",
+    "rgba(0%, 0%, 0%, calc(50% + (sign(1em - 10px) * 10%)))",
+  );
+  runTest(
+    "",
+    "rgb(0, 0, 0, calc(0.75 + (sign(1em - 10px) * 0.1)))",
+    "rgb(0, 0, 0, calc(.75 + (sign(1em - 10px) * .1)))",
+  );
+  runTest(
+    "",
+    "rgba(0, 0, 0, calc(0.75 + (sign(1em - 10px) * 0.1)))",
+    "rgba(0, 0, 0, calc(.75 + (sign(1em - 10px) * .1)))",
+  );
+  runTest(
+    "",
+    "rgb(calc(50% + (sign(1em - 10px) * 10%)) 0% 0% / 50%)",
+    "rgb(calc(50% + (sign(1em - 10px) * 10%)) 0% 0% / 50%)",
+  );
+  runTest(
+    "",
+    "rgba(calc(50% + (sign(1em - 10px) * 10%)) 0% 0% / 50%)",
+    "rgba(calc(50% + (sign(1em - 10px) * 10%)) 0% 0% / 50%)",
+  );
+  runTest("", "rgb(calc(50 + (sign(1em - 10px) * 10)) 0 0 / 0.5)", "rgb(calc(50 + (sign(1em - 10px) * 10)) 0 0 / .5)");
+  runTest(
+    "",
+    "rgba(calc(50 + (sign(1em - 10px) * 10)) 0 0 / 0.5)",
+    "rgba(calc(50 + (sign(1em - 10px) * 10)) 0 0 / .5)",
+  );
+  runTest(
+    "",
+    "rgb(0% 0% 0% / calc(50% + (sign(1em - 10px) * 10%)))",
+    "rgb(0 0 0 / calc(50% + (sign(1em - 10px) * 10%)))",
+  );
+  runTest(
+    "",
+    "rgba(0% 0% 0% / calc(50% + (sign(1em - 10px) * 10%)))",
+    "rgba(0% 0% 0% / calc(50% + (sign(1em - 10px) * 10%)))",
+  );
+  runTest("", "rgb(0 0 0 / calc(0.75 + (sign(1em - 10px) * 0.1)))", "rgb(0 0 0 / calc(.75 + (sign(1em - 10px) * .1)))");
+  runTest(
+    "",
+    "rgba(0 0 0 / calc(0.75 + (sign(1em - 10px) * 0.1)))",
+    "rgba(0 0 0 / calc(.75 + (sign(1em - 10px) * .1)))",
+  );
+  runTest(
+    "",
+    "rgba(calc(50% + (sign(1em - 10px) * 10%)) 0 0% / 0.5)",
+    "rgba(calc(50% + (sign(1em - 10px) * 10%)) 0 0% / .5)",
+  );
+  runTest(
+    "",
+    "rgba(0% 0 0% / calc(0.75 + (sign(1em - 10px) * 0.1)))",
+    "rgba(0% 0 0% / calc(.75 + (sign(1em - 10px) * .1)))",
+  );
+});
diff --git a/test/bundler/css/wpt/color-computed.test.ts b/test/bundler/css/wpt/color-computed.test.ts
new file mode 100644
index 0000000000..bbfe477c17
--- /dev/null
+++ b/test/bundler/css/wpt/color-computed.test.ts
@@ -0,0 +1,42 @@
+import { describe } from "bun:test";
+import { itBundled } from "../../expectBundled";
+
+const runTest = (input: string, expected: string) => {
+  itBundled(input, {
+    experimentalCss: true,
+    files: {
+      "/a.css": /* css */ `
+h1 {
+  color: ${input}
+}
+      `,
+    },
+    outfile: "out.css",
+
+    onAfterBundle(api) {
+      api.expectFile("/out.css").toEqualIgnoringWhitespace(`
+/* a.css */
+h1 {
+    color: ${expected};
+}
+`);
+    },
+  });
+};
+
+describe("color-computed", () => {
+  runTest("currentcolor", "currentColor");
+  runTest("transparent", "#0000");
+  runTest("red", "red");
+  runTest("magenta", "#f0f");
+  runTest("#234", "#234");
+  runTest("#FEDCBA", "#fedcba");
+  runTest("rgb(100%, 0%, 0%)", "red");
+  runTest("rgba(2, 3, 4, 50%)", "#02030480");
+  runTest("hsl(120, 100%, 50%)", "#0f0");
+  runTest("hsla(120, 100%, 50%, 0.25)", "#00ff0040");
+  runTest("rgb(-2, 3, 4)", "#000304");
+  runTest("rgb(100, 200, 300)", "#64c8ff");
+  runTest("rgb(20, 10, 0, -10)", "#140a0000");
+  runTest("rgb(100%, 200%, 300%)", "#fff");
+});
diff --git a/test/bundler/css/wpt/relative_color_out_of_gamut.test.ts b/test/bundler/css/wpt/relative_color_out_of_gamut.test.ts
new file mode 100644
index 0000000000..8664d4bbfb
--- /dev/null
+++ b/test/bundler/css/wpt/relative_color_out_of_gamut.test.ts
@@ -0,0 +1,573 @@
+import { describe } from "bun:test";
+import { itBundled } from "../../expectBundled";
+
+let i = 0;
+const testname = () => `test-${i++}`;
+describe("relative_color_out_of_gamut", () => {
+  itBundled(testname(), {
+    experimentalCss: true,
+    files: {
+      "/a.css": /* css */ `
+h1 {
+  color: rgb(from color(display-p3 0 1 0) r g b / alpha);
+}
+      `,
+    },
+    outfile: "out.css",
+
+    onAfterBundle(api) {
+      api.expectFile("/out.css").toEqualIgnoringWhitespace(`
+/* a.css */
+h1 {
+    color: #00f942;
+}
+`);
+    },
+  });
+
+  itBundled(testname(), {
+    experimentalCss: true,
+    files: {
+      "/a.css": /* css */ `
+  h1 {
+    color: rgb(from lab(100 104.3 -50.9) r g b);
+  }
+        `,
+    },
+    outfile: "/out.css",
+
+    onAfterBundle(api) {
+      api.expectFile("/out.css").toEqualIgnoringWhitespace(`
+  /* a.css */
+  h1 {
+      color: rgb(from lab(100 104.3 -50.9) r g b);
+  }
+  `);
+    },
+  });
+
+  itBundled(testname(), {
+    experimentalCss: true,
+    files: {
+      "/a.css": /* css */ `
+  h1 {
+    color: rgb(from lab(0 104.3 -50.9) r g b);
+  }
+        `,
+    },
+    outfile: "/out.css",
+
+    onAfterBundle(api) {
+      api.expectFile("/out.css").toEqualIgnoringWhitespace(`
+  /* a.css */
+  h1 {
+      color: rgb(from lab(0 104.3 -50.9) r g b);
+  }
+  `);
+    },
+  });
+
+  itBundled(testname(), {
+    experimentalCss: true,
+    files: {
+      "/a.css": /* css */ `
+  h1 {
+    color: rgb(from lch(100 116 334) r g b);
+  }
+        `,
+    },
+    outfile: "/out.css",
+
+    onAfterBundle(api) {
+      api.expectFile("/out.css").toEqualIgnoringWhitespace(`
+  /* a.css */
+  h1 {
+      color: rgb(from lch(100 116 334) r g b);
+  }
+  `);
+    },
+  });
+
+  itBundled(testname(), {
+    experimentalCss: true,
+    files: {
+      "/a.css": /* css */ `
+  h1 {
+    color: rgb(from lch(0 116 334) r g b);
+  }
+        `,
+    },
+    outfile: "/out.css",
+
+    onAfterBundle(api) {
+      api.expectFile("/out.css").toEqualIgnoringWhitespace(`
+  /* a.css */
+  h1 {
+      color: rgb(from lch(0 116 334) r g b);
+  }
+  `);
+    },
+  });
+
+  itBundled(testname(), {
+    experimentalCss: true,
+    files: {
+      "/a.css": /* css */ `
+  h1 {
+    color: rgb(from oklab(1 0.365 -0.16) r g b);
+  }
+        `,
+    },
+    outfile: "/out.css",
+
+    onAfterBundle(api) {
+      api.expectFile("/out.css").toEqualIgnoringWhitespace(`
+  /* a.css */
+  h1 {
+      color: rgb(from oklab(1 .365 -.16) r g b);
+  }
+  `);
+    },
+  });
+
+  itBundled(testname(), {
+    experimentalCss: true,
+    files: {
+      "/a.css": /* css */ `
+  h1 {
+    color: rgb(from oklab(0 0.365 -0.16) r g b);
+  }
+        `,
+    },
+    outfile: "/out.css",
+
+    onAfterBundle(api) {
+      api.expectFile("/out.css").toEqualIgnoringWhitespace(`
+  /* a.css */
+  h1 {
+      color: rgb(from oklab(0 .365 -.16) r g b);
+  }
+  `);
+    },
+  });
+
+  itBundled(testname(), {
+    experimentalCss: true,
+    files: {
+      "/a.css": /* css */ `
+  h1 {
+    color: rgb(from oklch(1 0.399 336.3) r g b);
+  }
+        `,
+    },
+    outfile: "/out.css",
+
+    onAfterBundle(api) {
+      api.expectFile("/out.css").toEqualIgnoringWhitespace(`
+  /* a.css */
+  h1 {
+      color: rgb(from oklch(1 .399 336.3) r g b);
+  }
+  `);
+    },
+  });
+
+  itBundled(testname(), {
+    experimentalCss: true,
+    files: {
+      "/a.css": /* css */ `
+  h1 {
+    color: rgb(from oklch(0 0.399 336.3) r g b);
+  }
+        `,
+    },
+    outfile: "/out.css",
+
+    onAfterBundle(api) {
+      api.expectFile("/out.css").toEqualIgnoringWhitespace(`
+  /* a.css */
+  h1 {
+      color: rgb(from oklch(0 .399 336.3) r g b);
+  }
+  `);
+    },
+  });
+
+  itBundled(testname(), {
+    experimentalCss: true,
+    files: {
+      "/a.css": /* css */ `
+  h1 {
+    color: hsl(from color(display-p3 0 1 0) h s l / alpha);
+  }
+        `,
+    },
+    outfile: "/out.css",
+
+    onAfterBundle(api) {
+      api.expectFile("/out.css").toEqualIgnoringWhitespace(`
+  /* a.css */
+  h1 {
+      color: #00f942;
+  }
+  `);
+    },
+  });
+
+  itBundled(testname(), {
+    experimentalCss: true,
+    files: {
+      "/a.css": /* css */ `
+  h1 {
+    color: hsl(from lab(100 104.3 -50.9) h s l);
+  }
+        `,
+    },
+    outfile: "/out.css",
+
+    onAfterBundle(api) {
+      api.expectFile("/out.css").toEqualIgnoringWhitespace(`
+  /* a.css */
+  h1 {
+      color: hsl(from lab(100 104.3 -50.9) h s l);
+  }
+  `);
+    },
+  });
+
+  itBundled(testname(), {
+    experimentalCss: true,
+    files: {
+      "/a.css": /* css */ `
+  h1 {
+    color: hsl(from lab(0 104.3 -50.9) h s l);
+  }
+        `,
+    },
+    outfile: "/out.css",
+
+    onAfterBundle(api) {
+      api.expectFile("/out.css").toEqualIgnoringWhitespace(`
+  /* a.css */
+  h1 {
+      color: hsl(from lab(0 104.3 -50.9) h s l);
+  }
+  `);
+    },
+  });
+
+  itBundled(testname(), {
+    experimentalCss: true,
+    files: {
+      "/a.css": /* css */ `
+  h1 {
+    color: hsl(from lch(100 116 334) h s l);
+  }
+        `,
+    },
+    outfile: "/out.css",
+
+    onAfterBundle(api) {
+      api.expectFile("/out.css").toEqualIgnoringWhitespace(`
+  /* a.css */
+  h1 {
+      color: hsl(from lch(100 116 334) h s l);
+  }
+  `);
+    },
+  });
+
+  itBundled(testname(), {
+    experimentalCss: true,
+    files: {
+      "/a.css": /* css */ `
+  h1 {
+    color: hsl(from lch(0 116 334) h s l);
+  }
+        `,
+    },
+    outfile: "/out.css",
+
+    onAfterBundle(api) {
+      api.expectFile("/out.css").toEqualIgnoringWhitespace(`
+  /* a.css */
+  h1 {
+      color: hsl(from lch(0 116 334) h s l);
+  }
+  `);
+    },
+  });
+
+  itBundled(testname(), {
+    experimentalCss: true,
+    files: {
+      "/a.css": /* css */ `
+  h1 {
+    color: hsl(from oklab(1 0.365 -0.16) h s l);
+  }
+        `,
+    },
+    outfile: "/out.css",
+
+    onAfterBundle(api) {
+      api.expectFile("/out.css").toEqualIgnoringWhitespace(`
+  /* a.css */
+  h1 {
+      color: hsl(from oklab(1 .365 -.16) h s l);
+  }
+  `);
+    },
+  });
+
+  itBundled(testname(), {
+    experimentalCss: true,
+    files: {
+      "/a.css": /* css */ `
+  h1 {
+    color: hsl(from oklab(0 0.365 -0.16) h s l);
+  }
+        `,
+    },
+    outfile: "/out.css",
+
+    onAfterBundle(api) {
+      api.expectFile("/out.css").toEqualIgnoringWhitespace(`
+  /* a.css */
+  h1 {
+      color: hsl(from oklab(0 .365 -.16) h s l);
+  }
+  `);
+    },
+  });
+
+  itBundled(testname(), {
+    experimentalCss: true,
+    files: {
+      "/a.css": /* css */ `
+  h1 {
+    color: hsl(from oklch(1 0.399 336.3) h s l);
+  }
+        `,
+    },
+    outfile: "/out.css",
+
+    onAfterBundle(api) {
+      api.expectFile("/out.css").toEqualIgnoringWhitespace(`
+  /* a.css */
+  h1 {
+      color: hsl(from oklch(1 .399 336.3) h s l);
+  }
+  `);
+    },
+  });
+
+  itBundled(testname(), {
+    experimentalCss: true,
+    files: {
+      "/a.css": /* css */ `
+  h1 {
+    color: hsl(from oklch(0 0.399 336.3) h s l);
+  }
+        `,
+    },
+    outfile: "/out.css",
+
+    onAfterBundle(api) {
+      api.expectFile("/out.css").toEqualIgnoringWhitespace(`
+  /* a.css */
+  h1 {
+      color: hsl(from oklch(0 .399 336.3) h s l);
+  }
+  `);
+    },
+  });
+
+  itBundled(testname(), {
+    experimentalCss: true,
+    files: {
+      "/a.css": /* css */ `
+  h1 {
+    color: hwb(from color(display-p3 0 1 0) h w b / alpha);
+  }
+        `,
+    },
+    outfile: "/out.css",
+
+    onAfterBundle(api) {
+      api.expectFile("/out.css").toEqualIgnoringWhitespace(`
+  /* a.css */
+  h1 {
+      color: #00f942;
+  }
+  `);
+    },
+  });
+
+  itBundled(testname(), {
+    experimentalCss: true,
+    files: {
+      "/a.css": /* css */ `
+  h1 {
+    color: hwb(from lab(100 104.3 -50.9) h w b);
+  }
+        `,
+    },
+    outfile: "/out.css",
+
+    onAfterBundle(api) {
+      api.expectFile("/out.css").toEqualIgnoringWhitespace(`
+  /* a.css */
+  h1 {
+      color: hwb(from lab(100 104.3 -50.9) h w b);
+  }
+  `);
+    },
+  });
+
+  itBundled(testname(), {
+    experimentalCss: true,
+    files: {
+      "/a.css": /* css */ `
+  h1 {
+    color: hwb(from lab(0 104.3 -50.9) h w b);
+  }
+        `,
+    },
+    outfile: "/out.css",
+
+    onAfterBundle(api) {
+      api.expectFile("/out.css").toEqualIgnoringWhitespace(`
+  /* a.css */
+  h1 {
+      color: hwb(from lab(0 104.3 -50.9) h w b);
+  }
+  `);
+    },
+  });
+
+  itBundled(testname(), {
+    experimentalCss: true,
+    files: {
+      "/a.css": /* css */ `
+  h1 {
+    color: hwb(from lch(100 116 334) h w b);
+  }
+        `,
+    },
+    outfile: "/out.css",
+
+    onAfterBundle(api) {
+      api.expectFile("/out.css").toEqualIgnoringWhitespace(`
+  /* a.css */
+  h1 {
+      color: hwb(from lch(100 116 334) h w b);
+  }
+  `);
+    },
+  });
+
+  itBundled(testname(), {
+    experimentalCss: true,
+    files: {
+      "/a.css": /* css */ `
+  h1 {
+    color: hwb(from lch(0 116 334) h w b);
+  }
+        `,
+    },
+    outfile: "/out.css",
+
+    onAfterBundle(api) {
+      api.expectFile("/out.css").toEqualIgnoringWhitespace(`
+  /* a.css */
+  h1 {
+      color: hwb(from lch(0 116 334) h w b);
+  }
+  `);
+    },
+  });
+
+  itBundled(testname(), {
+    experimentalCss: true,
+    files: {
+      "/a.css": /* css */ `
+  h1 {
+    color: hwb(from oklab(1 0.365 -0.16) h w b);
+  }
+        `,
+    },
+    outfile: "/out.css",
+
+    onAfterBundle(api) {
+      api.expectFile("/out.css").toEqualIgnoringWhitespace(`
+  /* a.css */
+  h1 {
+      color: hwb(from oklab(1 .365 -.16) h w b);
+  }
+  `);
+    },
+  });
+
+  itBundled(testname(), {
+    experimentalCss: true,
+    files: {
+      "/a.css": /* css */ `
+  h1 {
+    color: hwb(from oklab(0 0.365 -0.16) h w b);
+  }
+        `,
+    },
+    outfile: "/out.css",
+
+    onAfterBundle(api) {
+      api.expectFile("/out.css").toEqualIgnoringWhitespace(`
+  /* a.css */
+  h1 {
+      color: hwb(from oklab(0 .365 -.16) h w b);
+  }
+  `);
+    },
+  });
+
+  itBundled(testname(), {
+    experimentalCss: true,
+    files: {
+      "/a.css": /* css */ `
+  h1 {
+    color: hwb(from oklch(1 0.399 336.3) h w b);
+  }
+        `,
+    },
+    outfile: "/out.css",
+
+    onAfterBundle(api) {
+      api.expectFile("/out.css").toEqualIgnoringWhitespace(`
+  /* a.css */
+  h1 {
+      color: hwb(from oklch(1 .399 336.3) h w b);
+  }
+  `);
+    },
+  });
+
+  itBundled(testname(), {
+    experimentalCss: true,
+    files: {
+      "/a.css": /* css */ `
+  h1 {
+    color: hwb(from oklch(0 0.399 336.3) h w b);
+  }
+        `,
+    },
+    outfile: "/out.css",
+
+    onAfterBundle(api) {
+      api.expectFile("/out.css").toEqualIgnoringWhitespace(`
+  /* a.css */
+  h1 {
+      color: hwb(from oklch(0 .399 336.3) h w b);
+  }
+  `);
+    },
+  });
+});
diff --git a/test/bundler/esbuild/css.test.ts b/test/bundler/esbuild/css.test.ts
index ee52bbe2c2..2666a81c42 100644
--- a/test/bundler/esbuild/css.test.ts
+++ b/test/bundler/esbuild/css.test.ts
@@ -6,6 +6,184 @@ import { itBundled } from "../expectBundled";
 
 // For debug, all files are written to $TEMP/bun-bundle-tests/css
 
+describe("bundler", () => {
+  itBundled("css/CSSEntryPoint", {
+    experimentalCss: true,
+    files: {
+      "/entry.css": /* css */ `
+        body {
+          background: white;
+          color: black }
+      `,
+    },
+    outfile: "/out.js",
+    onAfterBundle(api) {
+      api.expectFile("/out.js").toEqualIgnoringWhitespace(`
+/* entry.css */
+body {
+        color: #000;
+        background: #fff;
+}`);
+    },
+  });
+
+  itBundled("css/CSSEntryPointEmpty", {
+    experimentalCss: true,
+    files: {
+      "/entry.css": /* css */ `\n`,
+    },
+    outfile: "/out.js",
+    onAfterBundle(api) {
+      api.expectFile("/out.js").toEqualIgnoringWhitespace(`
+/* entry.css */`);
+    },
+  });
+
+  itBundled("css/CSSNesting", {
+    experimentalCss: true,
+    files: {
+      "/entry.css": /* css */ `
+body {
+	h1 {
+		color: white;
+	}
+}`,
+    },
+    outfile: "/out.js",
+    onAfterBundle(api) {
+      api.expectFile("/out.js").toEqualIgnoringWhitespace(`
+/* entry.css */
+body {
+	&h1 {
+		color: #fff;
+	}
+}
+`);
+    },
+  });
+
+  itBundled("css/CSSAtImportMissing", {
+    experimentalCss: true,
+    files: {
+      "/entry.css": `@import "./missing.css";`,
+    },
+    bundleErrors: {
+      "/entry.css": ['Could not resolve: "./missing.css"'],
+    },
+  });
+
+  itBundled("css/CSSAtImportSimple", {
+    experimentalCss: true,
+    // GENERATED
+    files: {
+      "/entry.css": /* css */ `
+        @import "./internal.css";
+      `,
+      "/internal.css": /* css */ `
+        .before { color: red }
+      `,
+    },
+    outfile: "/out.css",
+    onAfterBundle(api) {
+      api.expectFile("/out.css").toEqualIgnoringWhitespace(`
+/* internal.css */
+.before {
+  color: red;
+}
+/* entry.css */
+`);
+    },
+  });
+
+  itBundled("css/CSSAtImportDiamond", {
+    experimentalCss: true,
+    // GENERATED
+    files: {
+      "/a.css": /* css */ `
+        @import "./b.css";
+        @import "./c.css";
+        .last { color: red }
+      `,
+      "/b.css": /* css */ `
+        @import "./d.css";
+        .first { color: red }
+      `,
+      "/c.css": /* css */ `
+        @import "./d.css";
+        .third { color: red }
+      `,
+      "/d.css": /* css */ `
+        .second { color: red }
+      `,
+    },
+    outfile: "/out.css",
+    onAfterBundle(api) {
+      api.expectFile("/out.css").toEqualIgnoringWhitespace(`
+/* b.css */
+.first {
+  color: red;
+}
+/* d.css */
+.second {
+  color: red;
+}
+/* c.css */
+.third {
+  color: red;
+}
+/* a.css */
+.last {
+  color: red;
+}
+`);
+    },
+  });
+
+  itBundled("css/CSSAtImportCycle", {
+    experimentalCss: true,
+    files: {
+      "/a.css": /* css */ `
+        @import "./a.css";
+        .hehe { color: red }
+      `,
+    },
+    outfile: "/out.css",
+    onAfterBundle(api) {
+      api.expectFile("/out.css").toEqualIgnoringWhitespace(`
+/* a.css */
+.hehe {
+  color: red;
+}
+`);
+    },
+  });
+
+  itBundled("css/CSSUrlImport", {
+    experimentalCss: true,
+    files: {
+      "/a.css": /* css */ `
+        .hello {
+          background-image: url(./hi.svg)
+        }
+      `,
+      "/hi.svg": /* svg */ `
+<svg width="100" height="100" xmlns="http://www.w3.org/2000/svg">
+  <circle cx="50" cy="50" r="40" fill="blue" />
+</svg>
+      `,
+    },
+    outdir: "/out",
+    onAfterBundle(api) {
+      api.expectFile("/out/a.css").toEqualIgnoringWhitespace(`
+/* a.css */
+.hello {
+  background-image: url("data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTAwIiBoZWlnaHQ9IjEwMCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICA8Y2lyY2xlIGN4PSI1MCIgY3k9IjUwIiByPSI0MCIgZmlsbD0iYmx1ZSIgLz4KPC9zdmc+");
+}
+`);
+    },
+  });
+});
+
 describe.todo("bundler", () => {
   itBundled("css/CSSEntryPoint", {
     // GENERATED
diff --git a/test/bundler/esbuild/dce.test.ts b/test/bundler/esbuild/dce.test.ts
index f718bd9670..75ccbbc22c 100644
--- a/test/bundler/esbuild/dce.test.ts
+++ b/test/bundler/esbuild/dce.test.ts
@@ -1446,6 +1446,7 @@ describe("bundler", () => {
     format: "cjs",
     treeShaking: true,
     bundling: false,
+    todo: true,
   });
   itBundled("dce/TreeShakingNoBundleIIFE", {
     files: {
@@ -1459,6 +1460,7 @@ describe("bundler", () => {
     format: "iife",
     treeShaking: true,
     bundling: false,
+    todo: true,
   });
   itBundled("dce/TreeShakingInESMWrapper", {
     files: {
@@ -1687,6 +1689,7 @@ describe("bundler", () => {
       `,
     },
     format: "iife",
+    todo: true,
     dce: true,
   });
   itBundled("dce/RemoveUnusedImports", {
diff --git a/test/bundler/esbuild/default.test.ts b/test/bundler/esbuild/default.test.ts
index 7c60b5d447..39847ec22a 100644
--- a/test/bundler/esbuild/default.test.ts
+++ b/test/bundler/esbuild/default.test.ts
@@ -193,6 +193,7 @@ describe("bundler", () => {
     format: "iife",
     globalName: "globalName",
     run: true,
+    todo: true,
     onAfterBundle(api) {
       api.appendFile(
         "/out.js",
@@ -1318,7 +1319,7 @@ describe("bundler", () => {
         console.log('writeFileSync' in fs, readFileSync, 'writeFileSync' in defaultValue)
       `,
     },
-    target: "node",
+    target: "bun",
     format: "cjs",
     run: {
       stdout: "true [Function: readFileSync] true",
@@ -2580,6 +2581,7 @@ describe("bundler", () => {
     minifySyntax: true,
     minifyWhitespace: true,
     bundling: false,
+    todo: true,
     onAfterBundle(api) {
       assert(api.readFile("/out.js").includes('"use strict";'), '"use strict"; was emitted');
     },
@@ -2797,14 +2799,16 @@ describe("bundler", () => {
   });
   itBundled("default/ImportMetaCommonJS", {
     files: {
-      "/entry.js": `console.log(import.meta.url, import.meta.path)`,
+      "/entry.js": `
+      import fs from "fs";
+      import { fileURLToPath } from "url";
+      console.log(fs.existsSync(fileURLToPath(import.meta.url)), fs.existsSync(import.meta.path));
+      `,
     },
     format: "cjs",
-    bundleWarnings: {
-      "/entry.js": [`"import.meta" is not available with the "cjs" output format and will be empty`],
-    },
+    target: "node",
     run: {
-      stdout: "undefined undefined",
+      stdout: "true true",
     },
   });
   itBundled("default/ImportMetaES6", {
@@ -3431,6 +3435,7 @@ describe("bundler", () => {
       `,
     },
     format: "iife",
+    todo: true,
     bundleErrors: {
       "/entry.js": ['Top-level await is currently not supported with the "iife" output format'],
     },
@@ -3453,6 +3458,7 @@ describe("bundler", () => {
       `,
     },
     format: "cjs",
+    todo: true,
     bundleErrors: {
       "/entry.js": ['Top-level await is currently not supported with the "cjs" output format'],
     },
@@ -3495,7 +3501,6 @@ describe("bundler", () => {
     bundling: false,
   });
   itBundled("default/TopLevelAwaitForbiddenRequire", {
-    todo: true,
     files: {
       "/entry.js": /* js */ `
         require('./a')
@@ -3513,12 +3518,12 @@ describe("bundler", () => {
       "/entry.js": [
         'This require call is not allowed because the transitive dependency "c.js" contains a top-level await',
         'This require call is not allowed because the transitive dependency "c.js" contains a top-level await',
-        'This require call is not allowed because the transitive dependency "entry.js" contains a top-level await',
+        'This require call is not allowed because the transitive dependency "c.js" contains a top-level await',
+        'This require call is not allowed because the imported file "entry.js" contains a top-level await',
       ],
     },
   });
   itBundled("default/TopLevelAwaitAllowedImportWithoutSplitting", {
-    todo: true,
     files: {
       "/entry.js": /* js */ `
         import('./a')
@@ -3536,6 +3541,131 @@ describe("bundler", () => {
       stdout: "0\n1",
     },
   });
+  itBundled("default/TopLevelAwaitImport", {
+    files: {
+      "/entry.js": /* js */ `
+        const { a } = await import('./a.js');
+        console.log(a);
+      `,
+      "/a.js": /* js */ `
+        async function five() {
+          return 5;
+        }
+
+        export const a = await five();
+      `,
+    },
+    format: "esm",
+    run: {
+      stdout: "5",
+    },
+  });
+  itBundled("default/TopLevelAwaitWithStaticImport", {
+    // Test static import of a module that uses top-level await
+    files: {
+      "/entry.js": `
+        import { a } from './a.js';
+        console.log('Entry', a);
+      `,
+      "/a.js": `
+        async function getValue() {
+          return await Promise.resolve('value from a');
+        }
+        export const a = await getValue();
+        console.log('a.js loaded');
+      `,
+    },
+    format: "esm",
+    run: {
+      stdout: "a.js loaded\nEntry value from a",
+    },
+  });
+  itBundled("default/TopLevelAwaitWithNestedDynamicImport", {
+    // Test nested dynamic imports with top-level await
+    files: {
+      "/entry.js": `
+        console.log('Start Entry');
+        const res = await import('./a.js');
+        console.log('Entry', res.a);
+      `,
+      "/a.js": `
+        console.log('Start a.js');
+        const { b } = await import('./b.js');
+        export const a = 'a.js plus ' + b;
+      `,
+      "/b.js": `
+        console.log('Start b.js');
+        export const b = 'value from b.js';
+      `,
+    },
+    format: "esm",
+    run: {
+      stdout: `Start Entry
+  Start a.js
+  Start b.js
+  Entry a.js plus value from b.js`,
+    },
+  });
+  itBundled("default/TopLevelAwaitWithNestedRequire", {
+    // Test nested dynamic imports with top-level await
+    files: {
+      "/entry.js": `
+        console.log('Start Entry');
+        const res = await import('./a.js');
+        console.log('Entry', res.a);
+      `,
+      "/a.js": `
+        console.log('Start a.js');
+        const { b } = require('./b.js');
+        export const a = 'a.js plus ' + b;
+      `,
+      "/b.js": `
+        console.log('Start b.js');
+        export const b = 'value from b.js';
+      `,
+    },
+    format: "esm",
+    run: {
+      stdout: `Start Entry
+  Start a.js
+  Start b.js
+  Entry a.js plus value from b.js`,
+    },
+  });
+  itBundled("default/TopLevelAwaitWithNestedImportAndRequire", {
+    // Test nested dynamic imports with top-level await
+    files: {
+      "/entry.js": `
+        console.log('Start Entry');
+        const res = await import('./a.js');
+        console.log('Entry', res.a);
+      `,
+      "/a.js": `
+        console.log('Start a.js');
+        const { b } = require('./b.js');
+        async function getValue() {
+          return 'value from a.js plus ' + b;
+        }
+        export const a = await getValue();
+      `,
+      "/b.js": `
+        console.log('Start b.js');
+        import { c } from './c.js';
+        export const b = 'value from b.js plus ' + c;
+      `,
+      "/c.js": `
+        console.log('Start c.js');
+        async function getValue() {
+          return 'value from c.js';
+        }
+        export const c = await getValue();
+      `,
+    },
+    format: "esm",
+    bundleErrors: {
+      "/a.js": ['This require call is not allowed because the transitive dependency "c.js" contains a top-level await'],
+    },
+  });
   itBundled("default/TopLevelAwaitAllowedImportWithSplitting", {
     files: {
       "/entry.js": /* js */ `
@@ -3784,6 +3914,13 @@ describe("bundler", () => {
     },
     target: "node",
     format: "cjs",
+    bundleErrors: {
+      "/entry.js": [
+        'Could not resolve: "./missing-file"',
+        'Could not resolve: "missing-pkg"',
+        'Could not resolve: "@scope/missing-pkg"',
+      ],
+    },
     external: ["external-pkg", "@scope/external-pkg", "{{root}}/external-file"],
   });
   itBundled("default/InjectMissing", {
@@ -4630,20 +4767,18 @@ describe("bundler", () => {
       assert([...code.matchAll(/let/g)].length === 3, "should have 3 let statements");
     },
   });
-  // TODO: this is hard to test since bun runtime doesn't support require.main and require.cache
-  // i'm not even sure what we want our behavior to be for this case.
-  // itBundled("default/RequireMainCacheCommonJS", {
-  //   files: {
-  //     "/entry.js": /* js */ `
-  //       console.log('is main:', require.main === module)
-  //       console.log(require('./is-main'))
-  //       console.log('cache:', require.cache);
-  //     `,
-  //     "/is-main.js": `module.exports = require.main === module`,
-  //   },
-  //   format: "cjs",
-  //   platform: "node",
-  // });
+  itBundled("default/RequireMainCacheCommonJS", {
+    files: {
+      "/entry.js": /* js */ `
+        console.log('is main:', require.main === module)
+        console.log(require('./is-main'))
+        console.log('cache:', require.cache);
+      `,
+      "/is-main.js": `module.exports = require.main === module`,
+    },
+    format: "cjs",
+    platform: "node",
+  });
   itBundled("default/ExternalES6ConvertedToCommonJS", {
     todo: true,
     files: {
diff --git a/test/bundler/esbuild/extra.test.ts b/test/bundler/esbuild/extra.test.ts
index fae84dd219..da25b13476 100644
--- a/test/bundler/esbuild/extra.test.ts
+++ b/test/bundler/esbuild/extra.test.ts
@@ -432,7 +432,6 @@ describe("bundler", () => {
 
   // Use "eval" to access CommonJS variables
   itBundled("extra/CJSEval1", {
-    todo: true,
     files: {
       "in.js": `if (require('./eval').foo !== 123) throw 'fail'`,
       "eval.js": `exports.foo=234;eval('exports.foo = 123')`,
@@ -440,7 +439,6 @@ describe("bundler", () => {
     run: true,
   });
   itBundled("extra/CJSEval2", {
-    todo: true,
     files: {
       "in.js": `if (require('./eval').foo !== 123) throw 'fail'`,
       "eval.js": `module.exports={foo:234};eval('module.exports = {foo: 123}')`,
diff --git a/test/bundler/esbuild/importstar.test.ts b/test/bundler/esbuild/importstar.test.ts
index 3cec66e2b8..8743b1df9a 100644
--- a/test/bundler/esbuild/importstar.test.ts
+++ b/test/bundler/esbuild/importstar.test.ts
@@ -561,6 +561,7 @@ describe("bundler", () => {
     format: "iife",
   });
   itBundled("importstar/ExportSelfIIFEWithName", {
+    todo: true,
     files: {
       "/entry.js": /* js */ `
         export const foo = 123
@@ -603,6 +604,7 @@ describe("bundler", () => {
       `,
     },
     format: "cjs",
+
     runtimeFiles: {
       "/test.js": /* js */ `
         console.log(JSON.stringify(require("./out.js")));
@@ -622,6 +624,7 @@ describe("bundler", () => {
     },
     minifyIdentifiers: true,
     format: "cjs",
+
     run: {
       stdout: '{"foo":123}',
     },
@@ -635,6 +638,7 @@ describe("bundler", () => {
       `,
     },
     format: "cjs",
+
     runtimeFiles: {
       "/test.js": /* js */ `
         console.log('2', JSON.stringify(require("./out.js")));
@@ -776,6 +780,7 @@ describe("bundler", () => {
       `,
     },
     format: "cjs",
+
     runtimeFiles: {
       "/test.js": /* js */ `
         const foo = require('./out.js')
@@ -795,6 +800,7 @@ describe("bundler", () => {
       `,
     },
     format: "cjs",
+
     run: {
       stdout: '{"foo":123}',
     },
@@ -808,6 +814,7 @@ describe("bundler", () => {
       `,
     },
     format: "cjs",
+
     run: {
       stdout: '{"foo":123}',
     },
@@ -818,6 +825,7 @@ describe("bundler", () => {
       "/foo.js": `exports.foo = 123`,
     },
     format: "cjs",
+
     runtimeFiles: {
       "/test.js": /* js */ `
         const foo = require('./out.js')
@@ -860,6 +868,7 @@ describe("bundler", () => {
       "/foo.js": `exports.foo = 123`,
     },
     format: "cjs",
+
     runtimeFiles: {
       "/test.js": /* js */ `
         const foo = require('./out.js')
@@ -879,6 +888,7 @@ describe("bundler", () => {
       "/foo.js": `exports.foo = 123`,
     },
     format: "cjs",
+
     runtimeFiles: {
       "/test.js": /* js */ `
         const foo = require('./out.js')
@@ -1025,6 +1035,7 @@ describe("bundler", () => {
       `,
     },
     format: "cjs",
+
     dce: true,
     runtimeFiles: {
       "/test.js": /* js */ `
@@ -1052,6 +1063,7 @@ describe("bundler", () => {
     },
   });
   itBundled("importstar/ReExportStarExternalIIFE", {
+    todo: true,
     files: {
       "/entry.js": `export * from "foo"`,
     },
@@ -1098,6 +1110,7 @@ describe("bundler", () => {
     },
     external: ["foo"],
     format: "cjs",
+
     runtimeFiles: {
       "/node_modules/foo/index.js": /* js */ `
         module.exports = { bar: 'bar', foo: 'foo' }
@@ -1361,7 +1374,7 @@ describe("bundler", () => {
       ],
     },
   });
-  itBundled("importstar/ReExportStarEntryPointAndInnerFile", {
+  itBundled("importstar/ReExportStarEntryPointAndInnerFileExternal", {
     files: {
       "/entry.js": /* js */ `
         export * from 'a'
@@ -1373,13 +1386,38 @@ describe("bundler", () => {
     format: "cjs",
     external: ["a", "b"],
     runtimeFiles: {
+      "/test.js": /* js */ `
+      console.log(JSON.stringify(require('./out.js')))
+      `,
       "/node_modules/a/index.js": /* js */ `
-        export const a = 123;
-      `,
+       export const a = 123;
+     `,
       "/node_modules/b/index.js": /* js */ `
-        export const b = 456;
+       export const b = 456;
+     `,
+    },
+    run: {
+      file: "/test.js",
+      stdout: '{"inner":{"b":456},"a":123,"b":456}',
+    },
+  });
+  itBundled("importstar/ReExportStarEntryPointAndInnerFile", {
+    files: {
+      "/entry.js": /* js */ `
+        export * from 'a'
+        import * as inner from './inner.js'
+        export { inner }
       `,
-
+      "/inner.js": `export * from 'b'`,
+      "/node_modules/a/index.js": /* js */ `
+      export const a = 123;
+    `,
+      "/node_modules/b/index.js": /* js */ `
+      export const b = 456;
+    `,
+    },
+    format: "cjs",
+    runtimeFiles: {
       "/test.js": /* js */ `
         console.log(JSON.stringify(require('./out.js')))
       `,
diff --git a/test/bundler/esbuild/tsconfig.test.ts b/test/bundler/esbuild/tsconfig.test.ts
index b62a6d7694..0b108dfc9c 100644
--- a/test/bundler/esbuild/tsconfig.test.ts
+++ b/test/bundler/esbuild/tsconfig.test.ts
@@ -367,7 +367,6 @@ describe("bundler", () => {
     },
   });
   itBundled("tsconfig/JSX", {
-    // GENERATED
     files: {
       "/Users/user/project/entry.tsx": `console.log(<><div/><div/></>)`,
       "/Users/user/project/node_modules/react/jsx-dev-runtime.ts": `
@@ -399,7 +398,6 @@ describe("bundler", () => {
     },
   });
   itBundled("tsconfig/ReactJSXNotReact", {
-    // GENERATED
     files: {
       "/Users/user/project/entry.tsx": `console.log(<><div/><div/></>)`,
       "/Users/user/project/node_modules/notreact/jsx-runtime.ts": `
@@ -428,7 +426,6 @@ describe("bundler", () => {
     },
   });
   itBundled("tsconfig/ReactJSXNotReactScoped", {
-    // GENERATED
     files: {
       "/Users/user/project/entry.tsx": `console.log(<><div/><div/></>)`,
       "/Users/user/project/node_modules/@notreact/jsx/jsx-runtime.ts": `
@@ -457,7 +454,6 @@ describe("bundler", () => {
     },
   });
   itBundled("tsconfig/ReactJSXDevNotReact", {
-    // GENERATED
     files: {
       "/Users/user/project/entry.tsx": `console.log(<><div/><div/></>)`,
       "/Users/user/project/node_modules/notreact/jsx-dev-runtime.ts": `
@@ -484,7 +480,6 @@ describe("bundler", () => {
     },
   });
   itBundled("tsconfig/ReactJSXDev", {
-    // GENERATED
     files: {
       "/Users/user/project/entry.tsx": `console.log(<><div/><div/></>)`,
       "/Users/user/project/node_modules/react/jsx-dev-runtime.ts": `
@@ -510,7 +505,6 @@ describe("bundler", () => {
     },
   });
   itBundled("tsconfig/ReactJSXDevTSConfigProduction", {
-    // GENERATED
     files: {
       "/Users/user/project/entry.tsx": `console.log(<><div/><div/></>)`,
       "/Users/user/project/node_modules/react/jsx-dev-runtime.ts": `
@@ -539,7 +533,6 @@ describe("bundler", () => {
     },
   });
   itBundled("tsconfig/ReactJSX", {
-    // GENERATED
     files: {
       "/Users/user/project/entry.tsx": `console.log(<><div/><div/></>)`,
       "/Users/user/project/node_modules/react/jsx-runtime.ts": `
@@ -562,7 +555,6 @@ describe("bundler", () => {
   });
 
   itBundled("tsconfig/ReactJSXClassic", {
-    // GENERATED
     files: {
       "/Users/user/project/entry.tsx": `console.log(<><div/><div/></>)`,
       "/Users/user/project/node_modules/react/jsx-dev-runtime.ts": `
@@ -589,7 +581,6 @@ describe("bundler", () => {
     },
   });
   itBundled("tsconfig/ReactJSXClassicWithNODE_ENV=Production", {
-    // GENERATED
     files: {
       "/Users/user/project/entry.tsx": `console.log(<><div/><div/></>)`,
       "/Users/user/project/node_modules/react/jsx-dev-runtime.ts": `
@@ -620,7 +611,6 @@ describe("bundler", () => {
   });
 
   itBundled("tsconfig/ReactJSXClassicWithNODE_ENV=Development", {
-    // GENERATED
     files: {
       "/Users/user/project/entry.tsx": `console.log(<><div/><div/></>)`,
       "/Users/user/project/node_modules/react/jsx-dev-runtime.ts": `
diff --git a/test/bundler/expectBundled.ts b/test/bundler/expectBundled.ts
index d1177a8102..240b7205e6 100644
--- a/test/bundler/expectBundled.ts
+++ b/test/bundler/expectBundled.ts
@@ -1,7 +1,7 @@
 /**
  * See `./expectBundled.md` for how this works.
  */
-import { BuildConfig, BunPlugin, fileURLToPath, PluginBuilder } from "bun";
+import { BuildConfig, BuildOutput, BunPlugin, fileURLToPath, PluginBuilder } from "bun";
 import { callerSourceOrigin } from "bun:jsc";
 import type { Matchers } from "bun:test";
 import * as esbuild from "esbuild";
@@ -10,6 +10,7 @@ import { bunEnv, bunExe, isDebug } from "harness";
 import { tmpdir } from "os";
 import path from "path";
 import { SourceMapConsumer } from "source-map";
+import filenamify from "filenamify";
 
 /** Dedent module does a bit too much with their stuff. we will be much simpler */
 export function dedent(str: string | TemplateStringsArray, ...args: any[]) {
@@ -146,7 +147,9 @@ export interface BundlerTestInput {
   alias?: Record<string, string>;
   assetNaming?: string;
   banner?: string;
+  footer?: string;
   define?: Record<string, string | number>;
+  drop?: string[];
 
   /** Use for resolve custom conditions */
   conditions?: string[];
@@ -161,9 +164,10 @@ export interface BundlerTestInput {
   /** Defaults to "bundle" */
   packages?: "bundle" | "external";
   /** Defaults to "esm" */
-  format?: "esm" | "cjs" | "iife" | "internal_kit_dev";
+  format?: "esm" | "cjs" | "iife" | "internal_bake_dev";
   globalName?: string;
   ignoreDCEAnnotations?: boolean;
+  bytecode?: boolean;
   emitDCEAnnotations?: boolean;
   inject?: string[];
   jsx?: {
@@ -189,6 +193,7 @@ export interface BundlerTestInput {
   metafile?: boolean | string;
   minifyIdentifiers?: boolean;
   minifySyntax?: boolean;
+  experimentalCss?: boolean;
   targetFromAPI?: "TargetWasConfigured";
   minifyWhitespace?: boolean;
   splitting?: boolean;
@@ -269,6 +274,17 @@ export interface BundlerTestInput {
   snapshotSourceMap?: Record<string, SourceMapTests>;
 
   expectExactFilesize?: Record<string, number>;
+
+  /** Multiplier for test timeout */
+  timeoutScale?: number;
+  /** Multiplier for test timeout when using bun-debug. Debug builds already have a higher timeout. */
+  debugTimeoutScale?: number;
+
+  /* determines whether or not anything should be passed to outfile, outdir, etc. */
+  generateOutput?: boolean;
+
+  /** Run after the bun.build function is called with its output */
+  onAfterApiBundle?(build: BuildOutput): Promise<void> | void;
 }
 
 export interface SourceMapTests {
@@ -326,6 +342,7 @@ export interface BundlerTestRunOptions {
   bunArgs?: string[];
   /** match exact stdout */
   stdout?: string | RegExp;
+  stderr?: string;
   /** partial match stdout (toContain()) */
   partialStdout?: string;
   /** match exact error message, example "ReferenceError: Can't find variable: bar" */
@@ -364,7 +381,7 @@ export interface BundlerTestRef {
   options: BundlerTestInput;
 }
 
-interface ErrorMeta {
+export interface ErrorMeta {
   file: string;
   error: string;
   line?: string;
@@ -383,6 +400,10 @@ function expectBundled(
   dryRun = false,
   ignoreFilter = false,
 ): Promise<BundlerTestRef> | BundlerTestRef {
+  if (!new Error().stack!.includes('test/bundler/')) {
+    throw new Error(`All bundler tests must be placed in ./test/bundler/ so that regressions can be quickly detected locally via the 'bun test bundler' command`);
+  }
+
   var { expect, it, test } = testForFile(currentFile ?? callerSourceOrigin());
   if (!ignoreFilter && FILTER && !filterMatches(id)) return testRef(id, opts);
 
@@ -408,7 +429,9 @@ function expectBundled(
     env,
     external,
     packages,
+    drop = [],
     files,
+    footer,
     format,
     globalName,
     inject,
@@ -423,6 +446,7 @@ function expectBundled(
     minifyIdentifiers,
     minifySyntax,
     minifyWhitespace,
+    experimentalCss,
     onAfterBundle,
     outdir,
     outfile,
@@ -444,10 +468,13 @@ function expectBundled(
     unsupportedJSFeatures,
     useDefineForClassFields,
     ignoreDCEAnnotations,
+    bytecode = false,
     emitDCEAnnotations,
     // @ts-expect-error
     _referenceFn,
     expectExactFilesize,
+    generateOutput = true,
+    onAfterApiBundle,
     ...unknownProps
   } = opts;
 
@@ -467,21 +494,26 @@ function expectBundled(
 
   // Resolve defaults for options and some related things
   bundling ??= true;
-  target ??= "browser";
+
+  if (bytecode) {
+    format ??= "cjs";
+    target ??= "bun";
+  }
+
   format ??= "esm";
+  target ??= "browser";
+
   entryPoints ??= entryPointsRaw ? [] : [Object.keys(files)[0]];
   if (run === true) run = {};
   if (metafile === true) metafile = "/metafile.json";
   if (bundleErrors === true) bundleErrors = {};
   if (bundleWarnings === true) bundleWarnings = {};
-  const useOutFile = outfile ? true : outdir ? false : entryPoints.length === 1;
+  const useOutFile = generateOutput == false ? false : outfile ? true : outdir ? false : entryPoints.length === 1;
 
   if (bundling === false && entryPoints.length > 1) {
     throw new Error("bundling:false only supports a single entry point");
   }
-  if (!ESBUILD && (format === "cjs" || format === "iife")) {
-    throw new Error(`format ${format} not implemented in bun build`);
-  }
+
   if (!ESBUILD && metafile) {
     throw new Error("metafile not implemented in bun build");
   }
@@ -500,9 +532,6 @@ function expectBundled(
   if (!ESBUILD && mainFields) {
     throw new Error("mainFields not implemented in bun build");
   }
-  if (!ESBUILD && banner) {
-    throw new Error("banner not implemented in bun build");
-  }
   if (!ESBUILD && inject) {
     throw new Error("inject not implemented in bun build");
   }
@@ -514,6 +543,9 @@ function expectBundled(
       throw new Error(`loader '${unsupportedLoaderTypes.join("', '")}' not implemented in bun build`);
     }
   }
+  if (ESBUILD && bytecode) {
+    throw new Error("bytecode not implemented in esbuild");
+  }
   if (ESBUILD && skipOnEsbuild) {
     return testRef(id, opts);
   }
@@ -526,7 +558,20 @@ function expectBundled(
       backend = plugins !== undefined ? "api" : "cli";
     }
 
-    let root = path.join(tempDirectory, id);
+    let root = path.join(
+      tempDirectory,
+      id
+        .replaceAll("\\", "/")
+        .replaceAll(":", "-")
+        .replaceAll(" ", "-")
+        .replaceAll("\r\n", "-")
+        .replaceAll("\n", "-")
+        .replaceAll(".", "-")
+        .split("/")
+        .map(a => filenamify(a))
+        .join("/"),
+    );
+
     mkdirSync(root, { recursive: true });
     root = realpathSync(root);
     if (DEBUG) console.log("root:", root);
@@ -534,11 +579,15 @@ 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 = [];
+
     outfile = useOutFile ? path.join(root, outfile ?? (compile ? "/out" : "/out.js")) : undefined;
-    outdir = !useOutFile ? path.join(root, outdir ?? "/out") : undefined;
+    outdir = !useOutFile && generateOutput ? path.join(root, outdir ?? "/out") : undefined;
     metafile = metafile ? path.join(root, metafile) : undefined;
     outputPaths = (
       outputPaths
@@ -583,7 +632,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);
     }
 
@@ -637,6 +688,8 @@ function expectBundled(
               minifyIdentifiers && `--minify-identifiers`,
               minifySyntax && `--minify-syntax`,
               minifyWhitespace && `--minify-whitespace`,
+              drop?.length && drop.map(x => ["--drop=" + x]),
+              experimentalCss && "--experimental-css",
               globalName && `--global-name=${globalName}`,
               jsx.runtime && ["--jsx-runtime", jsx.runtime],
               jsx.factory && ["--jsx-factory", jsx.factory],
@@ -650,6 +703,8 @@ function expectBundled(
               splitting && `--splitting`,
               serverComponents && "--server-components",
               outbase && `--root=${outbase}`,
+              banner && `--banner="${banner}"`, // TODO: --banner-css=*
+              footer && `--footer="${footer}"`,
               ignoreDCEAnnotations && `--ignore-dce-annotations`,
               emitDCEAnnotations && `--emit-dce-annotations`,
               // inject && inject.map(x => ["--inject", path.join(root, x)]),
@@ -660,6 +715,7 @@ function expectBundled(
               // mainFields && `--main-fields=${mainFields}`,
               loader && Object.entries(loader).map(([k, v]) => ["--loader", `${k}:${v}`]),
               publicPath && `--public-path=${publicPath}`,
+              bytecode && "--bytecode",
             ]
           : [
               ESBUILD_PATH,
@@ -671,6 +727,7 @@ function expectBundled(
               minifySyntax && `--minify-syntax`,
               minifyWhitespace && `--minify-whitespace`,
               globalName && `--global-name=${globalName}`,
+              experimentalCss && "--experimental-css",
               external && external.map(x => `--external:${x}`),
               packages && ["--packages", packages],
               conditions && `--conditions=${conditions.join(",")}`,
@@ -693,6 +750,7 @@ function expectBundled(
               metafile && `--metafile=${metafile}`,
               sourceMap && `--sourcemap=${sourceMap}`,
               banner && `--banner:js=${banner}`,
+              footer && `--footer:js=${footer}`,
               legalComments && `--legal-comments=${legalComments}`,
               ignoreDCEAnnotations && `--ignore-annotations`,
               splitting && `--splitting`,
@@ -769,6 +827,7 @@ function expectBundled(
           delete bundlerEnv[key];
         }
       }
+
       const { stdout, stderr, success, exitCode } = Bun.spawnSync({
         cmd,
         cwd: root,
@@ -959,13 +1018,16 @@ function expectBundled(
           },
           plugins: pluginArray,
           treeShaking,
-          outdir: buildOutDir,
+          outdir: generateOutput ? buildOutDir : undefined,
           sourcemap: sourceMap,
           splitting,
           target,
+          bytecode,
           publicPath,
           emitDCEAnnotations,
           ignoreDCEAnnotations,
+          experimentalCss,
+          drop,
         } as BuildConfig;
 
         if (conditions?.length) {
@@ -997,11 +1059,11 @@ for (const [key, blob] of build.outputs) {
 
         configRef = buildConfig;
         const build = await Bun.build(buildConfig);
+        if (onAfterApiBundle) await onAfterApiBundle(build);
         configRef = null!;
         Bun.gc(true);
 
         const buildLogs = build.logs.filter(x => x.level === "error");
-
         if (buildLogs.length) {
           const allErrors: ErrorMeta[] = [];
           for (const error of buildLogs) {
@@ -1080,6 +1142,7 @@ for (const [key, blob] of build.outputs) {
 
             return testRef(id, opts);
           }
+
           throw new Error("Bundle Failed\n" + [...allErrors].map(formatError).join("\n"));
         } else if (expectedErrors && expectedErrors.length > 0) {
           throw new Error("Errors were expected while bundling:\n" + expectedErrors.map(formatError).join("\n"));
@@ -1296,7 +1359,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);
     }
 
@@ -1419,7 +1484,6 @@ for (const [key, blob] of build.outputs) {
         } else {
           throw new Error(prefix + "run.file is required when there is more than one entrypoint.");
         }
-
         const args = [
           ...(compile ? [] : [(run.runtime ?? "bun") === "bun" ? bunExe() : "node"]),
           ...(run.bunArgs ?? []),
@@ -1431,6 +1495,7 @@ for (const [key, blob] of build.outputs) {
           cmd: args,
           env: {
             ...bunEnv,
+            ...(run.env || {}),
             FORCE_COLOR: "0",
             IS_TEST_RUNNER: "1",
           },
@@ -1504,28 +1569,35 @@ for (const [key, blob] of build.outputs) {
           run.validate({ stderr: stderr.toUnixString(), stdout: stdout.toUnixString() });
         }
 
-        if (run.stdout !== undefined) {
-          const result = stdout!.toUnixString().trim();
-          if (typeof run.stdout === "string") {
-            const expected = dedent(run.stdout).trim();
+        for (let [name, expected, out] of [
+          ["stdout", run.stdout, stdout],
+          ["stderr", run.stderr, stderr],
+        ].filter(([, v]) => v !== undefined)) {
+          let result = out!.toUnixString().trim();
+
+          // no idea why this logs. ¯\_(ツ)_/¯
+          result = result.replace(/\[Event_?Loop\] enqueueTaskConcurrent\(RuntimeTranspilerStore\)\n/gi, "");
+
+          if (typeof expected === "string") {
+            expected = dedent(expected).trim();
             if (expected !== result) {
               console.log(`runtime failed file: ${file}`);
-              console.log(`reference stdout:`);
+              console.log(`${name} output:`);
               console.log(result);
               console.log(`---`);
-              console.log(`expected stdout:`);
+              console.log(`expected ${name}:`);
               console.log(expected);
               console.log(`---`);
             }
             expect(result).toBe(expected);
           } else {
-            if (!run.stdout.test(result)) {
+            if (!expected.test(result)) {
               console.log(`runtime failed file: ${file}`);
-              console.log(`reference stdout:`);
+              console.log(`${name} output:`);
               console.log(result);
               console.log(`---`);
             }
-            expect(result).toMatch(run.stdout);
+            expect(result).toMatch(expected);
           }
         }
 
@@ -1579,11 +1651,24 @@ export function itBundled(
       id,
       () => expectBundled(id, opts as any),
       // sourcemap code is slow
-      isDebug ? Infinity : opts.snapshotSourceMap ? 30_000 : undefined,
+      (opts.snapshotSourceMap ? (isDebug ? Infinity : 30_000) : isDebug ? 15_000 : 5_000) *
+        ((isDebug ? opts.debugTimeoutScale : opts.timeoutScale) ?? 1),
     );
   }
   return ref;
 }
+itBundled.only = (id: string, opts: BundlerTestInput) => {
+  const { it } = testForFile(currentFile ?? callerSourceOrigin());
+
+  it.only(
+    id,
+    () => expectBundled(id, opts as any),
+    // sourcemap code is slow
+    (opts.snapshotSourceMap ? (isDebug ? Infinity : 30_000) : isDebug ? 15_000 : 5_000) *
+      ((isDebug ? opts.debugTimeoutScale : opts.timeoutScale) ?? 1),
+  );
+};
+
 itBundled.skip = (id: string, opts: BundlerTestInput) => {
   if (FILTER && !filterMatches(id)) {
     return testRef(id, opts);
@@ -1601,12 +1686,6 @@ function filterMatches(id: string) {
   return FILTER === id || FILTER + "Dev" === id || FILTER + "Prod" === id;
 }
 
-interface SourceMapDecodedLocation {
-  line: number;
-  column: number;
-  source: string;
-}
-
 interface SourceMap {
   sourcesContent: string[];
   sources: string[];
diff --git a/test/bundler/native-plugin.test.ts b/test/bundler/native-plugin.test.ts
new file mode 100644
index 0000000000..83ef6acaaf
--- /dev/null
+++ b/test/bundler/native-plugin.test.ts
@@ -0,0 +1,624 @@
+import { BunFile, Loader, plugin } from "bun";
+import { afterEach, beforeAll, beforeEach, describe, expect, it } from "bun:test";
+import path, { dirname, join, resolve } from "path";
+import source from "./native_plugin.cc" with { type: "file" };
+import bundlerPluginHeader from "../../packages/bun-native-bundler-plugin-api/bundler_plugin.h" with { type: "file" };
+import { bunEnv, bunExe, tempDirWithFiles } from "harness";
+import { itBundled } from "bundler/expectBundled";
+
+describe("native-plugins", async () => {
+  const cwd = process.cwd();
+  let tempdir: string = "";
+  let outdir: string = "";
+
+  beforeAll(async () => {
+    const files = {
+      "bun-native-bundler-plugin-api/bundler_plugin.h": await Bun.file(bundlerPluginHeader).text(),
+      "plugin.cc": await Bun.file(source).text(),
+      "package.json": JSON.stringify({
+        "name": "fake-plugin",
+        "module": "index.ts",
+        "type": "module",
+        "devDependencies": {
+          "@types/bun": "latest",
+        },
+        "peerDependencies": {
+          "typescript": "^5.0.0",
+        },
+        "scripts": {
+          "build:napi": "node-gyp configure && node-gyp build",
+        },
+        "dependencies": {
+          "node-gyp": "10.2.0",
+        },
+      }),
+
+      "index.ts": /* ts */ `import values from "./stuff.ts";
+import json from "./lmao.json";
+const many_foo = ["foo","foo","foo","foo","foo","foo","foo"]
+const many_bar = ["bar","bar","bar","bar","bar","bar","bar"]
+const many_baz = ["baz","baz","baz","baz","baz","baz","baz"]
+console.log(JSON.stringify(json));
+values;`,
+      "stuff.ts": `export default { foo: "bar", baz: "baz" }`,
+      "lmao.json": ``,
+      "binding.gyp": /* gyp */ `{
+        "targets": [
+          {
+            "target_name": "xXx123_foo_counter_321xXx",
+            "sources": [ "plugin.cc" ],
+            "include_dirs": [ "." ]
+          }
+        ]
+      }`,
+    };
+
+    tempdir = tempDirWithFiles("native-plugins", files);
+    outdir = path.join(tempdir, "dist");
+
+    console.log("tempdir", tempdir);
+
+    process.chdir(tempdir);
+
+    await Bun.$`${bunExe()} i && ${bunExe()} build:napi`.env(bunEnv).cwd(tempdir);
+  });
+
+  afterEach(async () => {
+    await Bun.$`rm -rf ${outdir}`;
+    process.chdir(cwd);
+  });
+
+  it("works in a basic case", async () => {
+    await Bun.$`${bunExe()} i && ${bunExe()} build:napi`.env(bunEnv).cwd(tempdir);
+
+    const napiModule = require(path.join(tempdir, "build/Release/xXx123_foo_counter_321xXx.node"));
+    const external = napiModule.createExternal();
+
+    const result = await Bun.build({
+      outdir,
+      entrypoints: [path.join(tempdir, "index.ts")],
+      plugins: [
+        {
+          name: "xXx123_foo_counter_321xXx",
+          setup(build) {
+            build.onBeforeParse({ filter: /\.ts/ }, { napiModule, symbol: "plugin_impl", external });
+
+            build.onLoad({ filter: /lmao\.json/ }, async ({ defer }) => {
+              await defer();
+              const count = napiModule.getFooCount(external);
+              return {
+                contents: JSON.stringify({ fooCount: count }),
+                loader: "json",
+              };
+            });
+          },
+        },
+      ],
+    });
+
+    if (!result.success) console.log(result);
+    expect(result.success).toBeTrue();
+    const output = await Bun.$`${bunExe()} run dist/index.js`.cwd(tempdir).json();
+    expect(output).toStrictEqual({ fooCount: 9 });
+
+    const compilationCtxFreedCount = await napiModule.getCompilationCtxFreedCount(external);
+    expect(compilationCtxFreedCount).toBe(2);
+  });
+
+  it("doesn't explode when there are a lot of concurrent files", async () => {
+    // Generate 100 json files
+    const files: [filepath: string, var_name: string][] = await Promise.all(
+      Array.from({ length: 100 }, async (_, i) => {
+        await Bun.write(path.join(tempdir, "json_files", `lmao${i}.json`), `{}`);
+        return [`import json${i} from "./json_files/lmao${i}.json"`, `json${i}`];
+      }),
+    );
+
+    // Append the imports to index.ts
+    const prelude = /* ts */ `import values from "./stuff.ts"
+  const many_foo = ["foo","foo","foo","foo","foo","foo","foo"]
+      `;
+    await Bun.$`echo ${prelude} > index.ts`;
+    await Bun.$`echo ${files.map(([fp]) => fp).join("\n")} >> index.ts`;
+    await Bun.$`echo ${files.map(([, varname]) => `console.log(JSON.stringify(${varname}))`).join("\n")} >> index.ts`;
+
+    const napiModule = require(path.join(tempdir, "build/Release/xXx123_foo_counter_321xXx.node"));
+    const external = napiModule.createExternal();
+
+    const result = await Bun.build({
+      outdir,
+      entrypoints: [path.join(tempdir, "index.ts")],
+      plugins: [
+        {
+          name: "xXx123_foo_counter_321xXx",
+          setup(build) {
+            build.onBeforeParse({ filter: /\.ts/ }, { napiModule, symbol: "plugin_impl", external });
+
+            build.onLoad({ filter: /\.json/ }, async ({ defer, path }) => {
+              await defer();
+              const count = napiModule.getFooCount(external);
+              return {
+                contents: JSON.stringify({ fooCount: count }),
+                loader: "json",
+              };
+            });
+          },
+        },
+      ],
+    });
+
+    if (!result.success) console.log(result);
+    console.log(result);
+    expect(result.success).toBeTrue();
+    const output = await Bun.$`${bunExe()} run dist/index.js`.cwd(tempdir).text();
+    const outputJsons = output
+      .trim()
+      .split("\n")
+      .map(s => JSON.parse(s));
+    for (const json of outputJsons) {
+      expect(json).toStrictEqual({ fooCount: 9 });
+    }
+
+    const compilationCtxFreedCount = await napiModule.getCompilationCtxFreedCount(external);
+    expect(compilationCtxFreedCount).toBe(2);
+  });
+
+  // We clone the RegExp object in the C++ code so this test ensures that there
+  // is no funny business regarding the filter regular expression and multiple
+  // threads
+  it("doesn't explode when there are a lot of concurrent files AND the filter regex is used on the JS thread", async () => {
+    const filter = /\.ts/;
+    // Generate 100 json files
+    const files: [filepath: string, var_name: string][] = await Promise.all(
+      Array.from({ length: 100 }, async (_, i) => {
+        await Bun.write(path.join(tempdir, "json_files", `lmao${i}.json`), `{}`);
+        return [`import json${i} from "./json_files/lmao${i}.json"`, `json${i}`];
+      }),
+    );
+
+    // Append the imports to index.ts
+    const prelude = /* ts */ `import values from "./stuff.ts"
+const many_foo = ["foo","foo","foo","foo","foo","foo","foo"]
+    `;
+    await Bun.$`echo ${prelude} > index.ts`;
+    await Bun.$`echo ${files.map(([fp]) => fp).join("\n")} >> index.ts`;
+    await Bun.$`echo ${files.map(([, varname]) => `console.log(JSON.stringify(${varname}))`).join("\n")} >> index.ts`;
+    await Bun.$`echo '(() => values)();' >> index.ts`;
+
+    const napiModule = require(path.join(tempdir, "build/Release/xXx123_foo_counter_321xXx.node"));
+    const external = napiModule.createExternal();
+
+    const resultPromise = Bun.build({
+      outdir,
+      entrypoints: [path.join(tempdir, "index.ts")],
+      plugins: [
+        {
+          name: "xXx123_foo_counter_321xXx",
+          setup(build) {
+            build.onBeforeParse({ filter }, { napiModule, symbol: "plugin_impl", external });
+
+            build.onLoad({ filter: /\.json/ }, async ({ defer, path }) => {
+              await defer();
+              const count = napiModule.getFooCount(external);
+              return {
+                contents: JSON.stringify({ fooCount: count }),
+                loader: "json",
+              };
+            });
+          },
+        },
+      ],
+    });
+
+    // Now saturate this thread with uses of the filter regex to test that nothing bad happens
+    // when the JS thread and the bundler thread use regexes concurrently
+    let dummy = 0;
+    for (let i = 0; i < 10000; i++) {
+      // Match the filter regex on some dummy string
+      dummy += filter.test("foo") ? 1 : 0;
+    }
+
+    const result = await resultPromise;
+
+    if (!result.success) console.log(result);
+    expect(result.success).toBeTrue();
+    const output = await Bun.$`${bunExe()} run dist/index.js`.cwd(tempdir).text();
+    const outputJsons = output
+      .trim()
+      .split("\n")
+      .map(s => JSON.parse(s));
+    for (const json of outputJsons) {
+      expect(json).toStrictEqual({ fooCount: 9 });
+    }
+
+    const compilationCtxFreedCount = await napiModule.getCompilationCtxFreedCount(external);
+    expect(compilationCtxFreedCount).toBe(2);
+  });
+
+  it("doesn't explode when passing invalid external", async () => {
+    const filter = /\.ts/;
+    // Generate 100 json files
+    const files: [filepath: string, var_name: string][] = await Promise.all(
+      Array.from({ length: 100 }, async (_, i) => {
+        await Bun.write(path.join(tempdir, "json_files", `lmao${i}.json`), `{}`);
+        return [`import json${i} from "./json_files/lmao${i}.json"`, `json${i}`];
+      }),
+    );
+
+    // Append the imports to index.ts
+    const prelude = /* ts */ `import values from "./stuff.ts"
+const many_foo = ["foo","foo","foo","foo","foo","foo","foo"]
+    `;
+    await Bun.$`echo ${prelude} > index.ts`;
+    await Bun.$`echo ${files.map(([fp]) => fp).join("\n")} >> index.ts`;
+    await Bun.$`echo ${files.map(([, varname]) => `console.log(JSON.stringify(${varname}))`).join("\n")} >> index.ts`;
+
+    const resultPromise = Bun.build({
+      outdir,
+      entrypoints: [path.join(tempdir, "index.ts")],
+      plugins: [
+        {
+          name: "xXx123_foo_counter_321xXx",
+          setup(build) {
+            const napiModule = require(path.join(tempdir, "build/Release/xXx123_foo_counter_321xXx.node"));
+            const external = undefined;
+
+            build.onBeforeParse({ filter }, { napiModule, symbol: "plugin_impl", external });
+
+            build.onLoad({ filter: /\.json/ }, async ({ defer, path }) => {
+              await defer();
+              let count = 0;
+              try {
+                count = napiModule.getFooCount(external);
+              } catch (e) {}
+              return {
+                contents: JSON.stringify({ fooCount: count }),
+                loader: "json",
+              };
+            });
+          },
+        },
+      ],
+    });
+
+    const result = await resultPromise;
+
+    if (!result.success) console.log(result);
+    expect(result.success).toBeTrue();
+    const output = await Bun.$`${bunExe()} run dist/index.js`.cwd(tempdir).text();
+    const outputJsons = output
+      .trim()
+      .split("\n")
+      .map(s => JSON.parse(s));
+    for (const json of outputJsons) {
+      expect(json).toStrictEqual({ fooCount: 0 });
+    }
+  });
+
+  it("works when logging an error", async () => {
+    const filter = /\.ts/;
+
+    const prelude = /* ts */ `import values from "./stuff.ts"
+  const many_foo = ["foo","foo","foo","foo","foo","foo","foo"]
+      `;
+    await Bun.$`echo ${prelude} > index.ts`;
+
+    const napiModule = require(path.join(tempdir, "build/Release/xXx123_foo_counter_321xXx.node"));
+    const external = napiModule.createExternal();
+
+    const resultPromise = Bun.build({
+      outdir,
+      entrypoints: [path.join(tempdir, "index.ts")],
+      plugins: [
+        {
+          name: "xXx123_foo_counter_321xXx",
+          setup(build) {
+            napiModule.setThrowsErrors(external, true);
+
+            build.onBeforeParse({ filter }, { napiModule, symbol: "plugin_impl", external });
+
+            build.onLoad({ filter: /\.json/ }, async ({ defer, path }) => {
+              await defer();
+              let count = 0;
+              try {
+                count = napiModule.getFooCount(external);
+              } catch (e) {}
+              return {
+                contents: JSON.stringify({ fooCount: count }),
+                loader: "json",
+              };
+            });
+          },
+        },
+      ],
+    });
+
+    const result = await resultPromise;
+
+    if (result.success) console.log(result);
+    expect(result.success).toBeFalse();
+    const log = result.logs[0];
+    expect(log.message).toContain("Throwing an error");
+    expect(log.level).toBe("error");
+
+    const compilationCtxFreedCount = await napiModule.getCompilationCtxFreedCount(external);
+    expect(compilationCtxFreedCount).toBe(0);
+  });
+
+  it("works with versioning", async () => {
+    const filter = /\.ts/;
+
+    const prelude = /* ts */ `import values from "./stuff.ts"
+  const many_foo = ["foo","foo","foo","foo","foo","foo","foo"]
+      `;
+    await Bun.$`echo ${prelude} > index.ts`;
+
+    const napiModule = require(path.join(tempdir, "build/Release/xXx123_foo_counter_321xXx.node"));
+    const external = napiModule.createExternal();
+
+    const resultPromise = Bun.build({
+      outdir,
+      entrypoints: [path.join(tempdir, "index.ts")],
+      plugins: [
+        {
+          name: "xXx123_foo_counter_321xXx",
+          setup(build) {
+            build.onBeforeParse({ filter }, { napiModule, symbol: "incompatible_version_plugin_impl", external });
+
+            build.onLoad({ filter: /\.json/ }, async ({ defer, path }) => {
+              await defer();
+              let count = 0;
+              try {
+                count = napiModule.getFooCount(external);
+              } catch (e) {}
+              return {
+                contents: JSON.stringify({ fooCount: count }),
+                loader: "json",
+              };
+            });
+          },
+        },
+      ],
+    });
+
+    const result = await resultPromise;
+
+    if (result.success) console.log(result);
+    expect(result.success).toBeFalse();
+    const log = result.logs[0];
+    expect(log.message).toContain("This plugin is built for a newer version of Bun than the one currently running.");
+    expect(log.level).toBe("error");
+
+    const compilationCtxFreedCount = await napiModule.getCompilationCtxFreedCount(external);
+    expect(compilationCtxFreedCount).toBe(0);
+  });
+
+  // don't know how to reliably test this on windows
+  it.skipIf(process.platform === "win32")("prints name when plugin crashes", async () => {
+    const prelude = /* ts */ `import values from "./stuff.ts"
+  const many_foo = ["foo","foo","foo","foo","foo","foo","foo"]
+      `;
+    await Bun.$`echo ${prelude} > index.ts`;
+
+    const build_code = /* ts */ `
+    import * as path from "path";
+    const tempdir = process.env.BUN_TEST_TEMP_DIR;
+    const filter = /\.ts/;
+    const resultPromise = await Bun.build({
+      outdir: "dist",
+      entrypoints: [path.join(tempdir, "index.ts")],
+      plugins: [
+        {
+          name: "xXx123_foo_counter_321xXx",
+          setup(build) {
+    const napiModule = require(path.join(tempdir, "build/Release/xXx123_foo_counter_321xXx.node"));
+    const external = napiModule.createExternal();
+            napiModule.setWillCrash(external, true);
+
+            build.onBeforeParse({ filter }, { napiModule, symbol: "plugin_impl", external });
+
+            build.onLoad({ filter: /\.json/ }, async ({ defer, path }) => {
+              await defer();
+              let count = 0;
+              try {
+                count = napiModule.getFooCount(external);
+              } catch (e) {}
+              return {
+                contents: JSON.stringify({ fooCount: count }),
+                loader: "json",
+              };
+            });
+          },
+        },
+      ],
+    });
+    console.log(resultPromise);
+    `;
+
+    await Bun.$`echo ${build_code} > build.ts`;
+    const { stdout, stderr } = await Bun.$`BUN_TEST_TEMP_DIR=${tempdir} ${bunExe()} run build.ts`.throws(false);
+    const errorString = stderr.toString();
+    expect(errorString).toContain('\x1b[31m\x1b[2m"native_plugin_test"\x1b[0m');
+  });
+
+  it("detects when plugin sets function pointer but does not user context pointer", async () => {
+    const filter = /\.ts/;
+
+    const prelude = /* ts */ `import values from "./stuff.ts"
+  const many_foo = ["foo","foo","foo","foo","foo","foo","foo"]
+      `;
+    await Bun.$`echo ${prelude} > index.ts`;
+
+    const napiModule = require(path.join(tempdir, "build/Release/xXx123_foo_counter_321xXx.node"));
+    const external = napiModule.createExternal();
+
+    const resultPromise = Bun.build({
+      outdir,
+      entrypoints: [path.join(tempdir, "index.ts")],
+      plugins: [
+        {
+          name: "xXx123_foo_counter_321xXx",
+          setup(build) {
+            build.onBeforeParse({ filter }, { napiModule, symbol: "plugin_impl_bad_free_function_pointer", external });
+
+            build.onLoad({ filter: /\.json/ }, async ({ defer, path }) => {
+              await defer();
+              let count = 0;
+              try {
+                count = napiModule.getFooCount(external);
+              } catch (e) {}
+              return {
+                contents: JSON.stringify({ fooCount: count }),
+                loader: "json",
+              };
+            });
+          },
+        },
+      ],
+    });
+
+    const result = await resultPromise;
+
+    if (result.success) console.log(result);
+    expect(result.success).toBeFalse();
+    const log = result.logs[0];
+    expect(log.message).toContain(
+      "Native plugin set the `free_plugin_source_code_context` field without setting the `plugin_source_code_context` field.",
+    );
+    expect(log.level).toBe("error");
+
+    const compilationCtxFreedCount = await napiModule.getCompilationCtxFreedCount(external);
+    expect(compilationCtxFreedCount).toBe(0);
+  });
+
+  it("should use result of the first plugin that runs and doesn't execute the others", async () => {
+    const filter = /\.ts/;
+
+    const prelude = /* ts */ `import values from "./stuff.ts"
+import json from "./lmao.json";
+  const many_foo = ["foo","foo","foo","foo","foo","foo","foo"]
+  const many_bar = ["bar","bar","bar","bar","bar","bar","bar"]
+  const many_baz = ["baz","baz","baz","baz","baz","baz","baz"]
+console.log(JSON.stringify(json))
+      `;
+    await Bun.$`echo ${prelude} > index.ts`;
+
+    const napiModule = require(path.join(tempdir, "build/Release/xXx123_foo_counter_321xXx.node"));
+    const external = napiModule.createExternal();
+
+    const resultPromise = Bun.build({
+      outdir,
+      entrypoints: [path.join(tempdir, "index.ts")],
+      plugins: [
+        {
+          name: "xXx123_foo_counter_321xXx",
+          setup(build) {
+            build.onBeforeParse({ filter }, { napiModule, symbol: "plugin_impl", external });
+            build.onBeforeParse({ filter }, { napiModule, symbol: "plugin_impl_bar", external });
+            build.onBeforeParse({ filter }, { napiModule, symbol: "plugin_impl_baz", external });
+
+            build.onLoad({ filter: /\.json/ }, async ({ defer, path }) => {
+              await defer();
+              let fooCount = 0;
+              let barCount = 0;
+              let bazCount = 0;
+              try {
+                fooCount = napiModule.getFooCount(external);
+                barCount = napiModule.getBarCount(external);
+                bazCount = napiModule.getBazCount(external);
+              } catch (e) {}
+              return {
+                contents: JSON.stringify({ fooCount, barCount, bazCount }),
+                loader: "json",
+              };
+            });
+          },
+        },
+      ],
+    });
+
+    const result = await resultPromise;
+
+    if (result.success) console.log(result);
+    expect(result.success).toBeTrue();
+
+    const output = await Bun.$`${bunExe()} run dist/index.js`.cwd(tempdir).json();
+
+    expect(output).toStrictEqual({ fooCount: 9, barCount: 0, bazCount: 0 });
+
+    const compilationCtxFreedCount = await napiModule.getCompilationCtxFreedCount(external);
+    expect(compilationCtxFreedCount).toBe(2);
+  });
+
+  type AdditionalFile = {
+    name: string;
+    contents: BunFile | string;
+    loader: Loader;
+  };
+  const additional_files: AdditionalFile[] = [
+    {
+      name: "bun.png",
+      contents: await Bun.file(path.join(import.meta.dir, "../integration/sharp/bun.png")),
+      loader: "file",
+    },
+    {
+      name: "index.js",
+      contents: /* ts */ `console.log('HELLO FRIENDS')`,
+      loader: "js",
+    },
+    {
+      name: "index.ts",
+      contents: /* ts */ `console.log('HELLO FRIENDS')`,
+      loader: "ts",
+    },
+    {
+      name: "lmao.jsx",
+      contents: /* ts */ `console.log('HELLO FRIENDS')`,
+      loader: "jsx",
+    },
+    {
+      name: "lmao.tsx",
+      contents: /* ts */ `console.log('HELLO FRIENDS')`,
+      loader: "tsx",
+    },
+    {
+      name: "lmao.toml",
+      contents: /* toml */ `foo = "bar"`,
+      loader: "toml",
+    },
+    {
+      name: "lmao.text",
+      contents: "HELLO FRIENDS",
+      loader: "text",
+    },
+  ];
+
+  for (const { name, contents, loader } of additional_files) {
+    it(`works with ${loader} loader`, async () => {
+      await Bun.$`echo ${contents} > ${name}`;
+      const source = /* ts */ `import foo from "./${name}";
+      console.log(foo);`;
+      await Bun.$`echo ${source} > index.ts`;
+
+      const result = await Bun.build({
+        outdir,
+        entrypoints: [path.join(tempdir, "index.ts")],
+        plugins: [
+          {
+            name: "test",
+            setup(build) {
+              const ext = name.split(".").pop()!;
+              const napiModule = require(path.join(tempdir, "build/Release/xXx123_foo_counter_321xXx.node"));
+
+              // Construct regexp to match the file extension
+              const filter = new RegExp(`\\.${ext}$`);
+              build.onBeforeParse({ filter }, { napiModule, symbol: "plugin_impl" });
+            },
+          },
+        ],
+      });
+
+      expect(result.success).toBeTrue();
+    });
+  }
+});
diff --git a/test/bundler/native_plugin.cc b/test/bundler/native_plugin.cc
new file mode 100644
index 0000000000..b48eec7dac
--- /dev/null
+++ b/test/bundler/native_plugin.cc
@@ -0,0 +1,651 @@
+/*
+  Dummy plugin which counts the occurences of the word "foo" in the source code,
+  replacing it with "boo".
+
+  It stores the number of occurences in the External struct.
+*/
+#include <atomic>
+#include <bun-native-bundler-plugin-api/bundler_plugin.h>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <node_api.h>
+
+#ifdef _WIN32
+#define BUN_PLUGIN_EXPORT __declspec(dllexport)
+#else
+#define BUN_PLUGIN_EXPORT
+#include <signal.h>
+#include <unistd.h>
+#endif
+
+BUN_PLUGIN_EXPORT const char *BUN_PLUGIN_NAME = "native_plugin_test";
+
+struct External {
+  std::atomic<size_t> foo_count;
+  std::atomic<size_t> bar_count;
+  std::atomic<size_t> baz_count;
+
+  // For testing logging error logic
+  std::atomic<bool> throws_an_error;
+  // For testing crash reporting
+  std::atomic<bool> simulate_crash;
+
+  std::atomic<size_t> compilation_ctx_freed_count;
+};
+
+struct CompilationCtx {
+  const char *source_ptr;
+  size_t source_len;
+  std::atomic<size_t> *free_counter;
+};
+
+CompilationCtx *compilation_ctx_new(const char *source_ptr, size_t source_len,
+                                    std::atomic<size_t> *free_counter) {
+  CompilationCtx *ctx = new CompilationCtx;
+  ctx->source_ptr = source_ptr;
+  ctx->source_len = source_len;
+  ctx->free_counter = free_counter;
+  return ctx;
+}
+
+void compilation_ctx_free(CompilationCtx *ctx) {
+  printf("Freed compilation ctx!\n");
+  if (ctx->free_counter != nullptr) {
+    ctx->free_counter->fetch_add(1);
+  }
+  free((void *)ctx->source_ptr);
+  delete ctx;
+}
+
+void log_error(const OnBeforeParseArguments *args,
+               const OnBeforeParseResult *result, BunLogLevel level,
+               const char *message, size_t message_len) {
+  BunLogOptions options;
+  options.message_ptr = (uint8_t *)message;
+  options.message_len = message_len;
+  options.path_ptr = args->path_ptr;
+  options.path_len = args->path_len;
+  options.source_line_text_ptr = nullptr;
+  options.source_line_text_len = 0;
+  options.level = (int8_t)level;
+  options.line = 0;
+  options.lineEnd = 0;
+  options.column = 0;
+  options.columnEnd = 0;
+  (result->log)(args, &options);
+}
+
+extern "C" BUN_PLUGIN_EXPORT void
+plugin_impl_with_needle(const OnBeforeParseArguments *args,
+                        OnBeforeParseResult *result, const char *needle) {
+  // if (args->__struct_size < sizeof(OnBeforeParseArguments)) {
+  //     log_error(args, result, BUN_LOG_LEVEL_ERROR, "Invalid
+  //     OnBeforeParseArguments struct size", sizeof("Invalid
+  //     OnBeforeParseArguments struct size") - 1); return;
+  // }
+
+  if (args->external) {
+    External *external = (External *)args->external;
+    if (external->throws_an_error.load()) {
+      log_error(args, result, BUN_LOG_LEVEL_ERROR, "Throwing an error",
+                sizeof("Throwing an error") - 1);
+      return;
+    } else if (external->simulate_crash.load()) {
+#ifndef _WIN32
+      raise(SIGSEGV);
+#endif
+    }
+  }
+
+  int fetch_result = result->fetchSourceCode(args, result);
+  if (fetch_result != 0) {
+    printf("FUCK\n");
+    exit(1);
+  }
+
+  size_t needle_len = strlen(needle);
+
+  int needle_count = 0;
+
+  const char *end = (const char *)result->source_ptr + result->source_len;
+
+  char *cursor = (char *)strstr((const char *)result->source_ptr, needle);
+  while (cursor != nullptr) {
+    needle_count++;
+    cursor += needle_len;
+    if (cursor + needle_len < end) {
+      cursor = (char *)strstr((const char *)cursor, needle);
+    } else
+      break;
+  }
+
+  if (needle_count > 0) {
+    char *new_source = (char *)malloc(result->source_len);
+    if (new_source == nullptr) {
+      printf("FUCK\n");
+      exit(1);
+    }
+    memcpy(new_source, result->source_ptr, result->source_len);
+    cursor = strstr(new_source, needle);
+    while (cursor != nullptr) {
+      cursor[0] = 'q';
+      cursor += 3;
+      if (cursor + 3 < end) {
+        cursor = (char *)strstr((const char *)cursor, needle);
+      } else
+        break;
+    }
+    std::atomic<size_t> *free_counter = nullptr;
+    if (args->external) {
+      External *external = (External *)args->external;
+      std::atomic<size_t> *needle_atomic_value = nullptr;
+      if (strcmp(needle, "foo") == 0) {
+        needle_atomic_value = &external->foo_count;
+      } else if (strcmp(needle, "bar") == 0) {
+        needle_atomic_value = &external->bar_count;
+      } else if (strcmp(needle, "baz") == 0) {
+        needle_atomic_value = &external->baz_count;
+      }
+      printf("FUCK: %d %s\n", needle_count, needle);
+      needle_atomic_value->fetch_add(needle_count);
+      free_counter = &external->compilation_ctx_freed_count;
+    }
+    result->source_ptr = (uint8_t *)new_source;
+    result->source_len = result->source_len;
+    result->plugin_source_code_context =
+        compilation_ctx_new(new_source, result->source_len, free_counter);
+    result->free_plugin_source_code_context =
+        (void (*)(void *))compilation_ctx_free;
+  } else {
+    result->source_ptr = nullptr;
+    result->source_len = 0;
+    result->loader = 0;
+  }
+}
+
+extern "C" BUN_PLUGIN_EXPORT void
+plugin_impl(const OnBeforeParseArguments *args, OnBeforeParseResult *result) {
+  plugin_impl_with_needle(args, result, "foo");
+}
+
+extern "C" BUN_PLUGIN_EXPORT void
+plugin_impl_bar(const OnBeforeParseArguments *args,
+                OnBeforeParseResult *result) {
+  plugin_impl_with_needle(args, result, "bar");
+}
+
+extern "C" BUN_PLUGIN_EXPORT void
+plugin_impl_baz(const OnBeforeParseArguments *args,
+                OnBeforeParseResult *result) {
+  plugin_impl_with_needle(args, result, "baz");
+}
+
+extern "C" void finalizer(napi_env env, void *data, void *hint) {
+  External *external = (External *)data;
+  if (external != nullptr) {
+    delete external;
+  }
+}
+
+napi_value create_external(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  // Allocate the External struct
+  External *external = new External();
+  if (external == nullptr) {
+    napi_throw_error(env, nullptr, "Failed to allocate memory");
+    return nullptr;
+  }
+
+  external->foo_count = 0;
+  external->compilation_ctx_freed_count = 0;
+
+  // Create the external wrapper
+  napi_value result;
+  status = napi_create_external(env, external, finalizer, nullptr, &result);
+  if (status != napi_ok) {
+    delete external;
+    napi_throw_error(env, nullptr, "Failed to create external");
+    return nullptr;
+  }
+
+  return result;
+}
+
+napi_value set_will_crash(napi_env env, napi_callback_info info) {
+  napi_status status;
+  External *external;
+
+  size_t argc = 1;
+  napi_value args[1];
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
+  if (status != napi_ok) {
+    napi_throw_error(env, nullptr, "Failed to parse arguments");
+    return nullptr;
+  }
+
+  if (argc < 1) {
+    napi_throw_error(env, nullptr, "Wrong number of arguments");
+    return nullptr;
+  }
+
+  status = napi_get_value_external(env, args[0], (void **)&external);
+  if (status != napi_ok) {
+    napi_throw_error(env, nullptr, "Failed to get external");
+    return nullptr;
+  }
+
+  bool throws;
+  status = napi_get_value_bool(env, args[0], &throws);
+  if (status != napi_ok) {
+    napi_throw_error(env, nullptr, "Failed to get boolean value");
+    return nullptr;
+  }
+
+  external->simulate_crash.store(throws);
+
+  return nullptr;
+}
+
+napi_value set_throws_errors(napi_env env, napi_callback_info info) {
+  napi_status status;
+  External *external;
+
+  size_t argc = 1;
+  napi_value args[1];
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
+  if (status != napi_ok) {
+    napi_throw_error(env, nullptr, "Failed to parse arguments");
+    return nullptr;
+  }
+
+  if (argc < 1) {
+    napi_throw_error(env, nullptr, "Wrong number of arguments");
+    return nullptr;
+  }
+
+  status = napi_get_value_external(env, args[0], (void **)&external);
+  if (status != napi_ok) {
+    napi_throw_error(env, nullptr, "Failed to get external");
+    return nullptr;
+  }
+
+  bool throws;
+  status = napi_get_value_bool(env, args[0], &throws);
+  if (status != napi_ok) {
+    napi_throw_error(env, nullptr, "Failed to get boolean value");
+    return nullptr;
+  }
+
+  external->throws_an_error.store(throws);
+
+  return nullptr;
+}
+
+napi_value get_compilation_ctx_freed_count(napi_env env,
+                                           napi_callback_info info) {
+  napi_status status;
+  External *external;
+
+  size_t argc = 1;
+  napi_value args[1];
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
+  if (status != napi_ok) {
+    napi_throw_error(env, nullptr, "Failed to parse arguments");
+    return nullptr;
+  }
+
+  if (argc < 1) {
+    napi_throw_error(env, nullptr, "Wrong number of arguments");
+    return nullptr;
+  }
+
+  status = napi_get_value_external(env, args[0], (void **)&external);
+  if (status != napi_ok) {
+    napi_throw_error(env, nullptr, "Failed to get external");
+    return nullptr;
+  }
+
+  napi_value result;
+  status = napi_create_int32(env, external->compilation_ctx_freed_count.load(),
+                             &result);
+  if (status != napi_ok) {
+    napi_throw_error(env, nullptr, "Failed to create array");
+    return nullptr;
+  }
+
+  return result;
+}
+
+napi_value get_foo_count(napi_env env, napi_callback_info info) {
+  napi_status status;
+  External *external;
+
+  size_t argc = 1;
+  napi_value args[1];
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
+  if (status != napi_ok) {
+    napi_throw_error(env, nullptr, "Failed to parse arguments");
+    return nullptr;
+  }
+
+  if (argc < 1) {
+    napi_throw_error(env, nullptr, "Wrong number of arguments");
+    return nullptr;
+  }
+
+  status = napi_get_value_external(env, args[0], (void **)&external);
+  if (status != napi_ok) {
+    napi_throw_error(env, nullptr, "Failed to get external");
+    return nullptr;
+  }
+
+  size_t foo_count = external->foo_count.load();
+  if (foo_count > INT32_MAX) {
+    napi_throw_error(env, nullptr,
+                     "Too many foos! This probably means undefined memory or "
+                     "heap corruption.");
+    return nullptr;
+  }
+
+  napi_value result;
+  status = napi_create_int32(env, foo_count, &result);
+  if (status != napi_ok) {
+    napi_throw_error(env, nullptr, "Failed to create array");
+    return nullptr;
+  }
+
+  return result;
+}
+
+napi_value get_bar_count(napi_env env, napi_callback_info info) {
+  napi_status status;
+  External *external;
+
+  size_t argc = 1;
+  napi_value args[1];
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
+  if (status != napi_ok) {
+    napi_throw_error(env, nullptr, "Failed to parse arguments");
+    return nullptr;
+  }
+
+  if (argc < 1) {
+    napi_throw_error(env, nullptr, "Wrong number of arguments");
+    return nullptr;
+  }
+
+  status = napi_get_value_external(env, args[0], (void **)&external);
+  if (status != napi_ok) {
+    napi_throw_error(env, nullptr, "Failed to get external");
+    return nullptr;
+  }
+
+  size_t bar_count = external->bar_count.load();
+  if (bar_count > INT32_MAX) {
+    napi_throw_error(env, nullptr,
+                     "Too many bars! This probably means undefined memory or "
+                     "heap corruption.");
+    return nullptr;
+  }
+
+  napi_value result;
+  status = napi_create_int32(env, bar_count, &result);
+  if (status != napi_ok) {
+    napi_throw_error(env, nullptr, "Failed to create array");
+    return nullptr;
+  }
+
+  return result;
+}
+
+napi_value get_baz_count(napi_env env, napi_callback_info info) {
+  napi_status status;
+  External *external;
+
+  size_t argc = 1;
+  napi_value args[1];
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
+  if (status != napi_ok) {
+    napi_throw_error(env, nullptr, "Failed to parse arguments");
+    return nullptr;
+  }
+
+  if (argc < 1) {
+    napi_throw_error(env, nullptr, "Wrong number of arguments");
+    return nullptr;
+  }
+
+  status = napi_get_value_external(env, args[0], (void **)&external);
+  if (status != napi_ok) {
+    napi_throw_error(env, nullptr, "Failed to get external");
+    return nullptr;
+  }
+
+  size_t baz_count = external->baz_count.load();
+  if (baz_count > INT32_MAX) {
+    napi_throw_error(env, nullptr,
+                     "Too many bazs! This probably means undefined memory or "
+                     "heap corruption.");
+    return nullptr;
+  }
+
+  napi_value result;
+  status = napi_create_int32(env, baz_count, &result);
+  if (status != napi_ok) {
+    napi_throw_error(env, nullptr, "Failed to create array");
+    return nullptr;
+  }
+
+  return result;
+}
+
+napi_value Init(napi_env env, napi_value exports) {
+  napi_status status;
+  napi_value fn_get_foo_count;
+  napi_value fn_get_bar_count;
+  napi_value fn_get_baz_count;
+
+  napi_value fn_get_compilation_ctx_freed_count;
+  napi_value fn_create_external;
+  napi_value fn_set_throws_errors;
+  napi_value fn_set_will_crash;
+
+  // Register get_foo_count function
+  status = napi_create_function(env, nullptr, 0, get_foo_count, nullptr,
+                                &fn_get_foo_count);
+  if (status != napi_ok) {
+    napi_throw_error(env, nullptr, "Failed to create get_names function");
+    return nullptr;
+  }
+  status =
+      napi_set_named_property(env, exports, "getFooCount", fn_get_foo_count);
+  if (status != napi_ok) {
+    napi_throw_error(env, nullptr,
+                     "Failed to add get_names function to exports");
+    return nullptr;
+  }
+
+  // Register get_bar_count function
+  status = napi_create_function(env, nullptr, 0, get_bar_count, nullptr,
+                                &fn_get_bar_count);
+  if (status != napi_ok) {
+    napi_throw_error(env, nullptr, "Failed to create get_names function");
+    return nullptr;
+  }
+  status =
+      napi_set_named_property(env, exports, "getBarCount", fn_get_bar_count);
+  if (status != napi_ok) {
+    napi_throw_error(env, nullptr,
+                     "Failed to add get_names function to exports");
+    return nullptr;
+  }
+
+  // Register get_baz_count function
+  status = napi_create_function(env, nullptr, 0, get_baz_count, nullptr,
+                                &fn_get_baz_count);
+  if (status != napi_ok) {
+    napi_throw_error(env, nullptr, "Failed to create get_names function");
+    return nullptr;
+  }
+  status =
+      napi_set_named_property(env, exports, "getBazCount", fn_get_baz_count);
+  if (status != napi_ok) {
+    napi_throw_error(env, nullptr,
+                     "Failed to add get_names function to exports");
+    return nullptr;
+  }
+
+  // Register get_compilation_ctx_freed_count function
+  status =
+      napi_create_function(env, nullptr, 0, get_compilation_ctx_freed_count,
+                           nullptr, &fn_get_compilation_ctx_freed_count);
+  if (status != napi_ok) {
+    napi_throw_error(
+        env, nullptr,
+        "Failed to create get_compilation_ctx_freed_count function");
+    return nullptr;
+  }
+  status = napi_set_named_property(env, exports, "getCompilationCtxFreedCount",
+                                   fn_get_compilation_ctx_freed_count);
+  if (status != napi_ok) {
+    napi_throw_error(
+        env, nullptr,
+        "Failed to add get_compilation_ctx_freed_count function to exports");
+    return nullptr;
+  }
+
+  // Register set_throws_errors function
+  status = napi_create_function(env, nullptr, 0, set_throws_errors, nullptr,
+                                &fn_set_throws_errors);
+  if (status != napi_ok) {
+    napi_throw_error(env, nullptr,
+                     "Failed to create set_throws_errors function");
+    return nullptr;
+  }
+  status = napi_set_named_property(env, exports, "setThrowsErrors",
+                                   fn_set_throws_errors);
+  if (status != napi_ok) {
+    napi_throw_error(env, nullptr,
+                     "Failed to add set_throws_errors function to exports");
+    return nullptr;
+  }
+
+  // Register set_will_crash function
+  status = napi_create_function(env, nullptr, 0, set_will_crash, nullptr,
+                                &fn_set_will_crash);
+  if (status != napi_ok) {
+    napi_throw_error(env, nullptr, "Failed to create set_will_crash function");
+    return nullptr;
+  }
+  status =
+      napi_set_named_property(env, exports, "setWillCrash", fn_set_will_crash);
+  if (status != napi_ok) {
+    napi_throw_error(env, nullptr,
+                     "Failed to add set_will_crash function to exports");
+    return nullptr;
+  }
+
+  // Register create_external function
+  status = napi_create_function(env, nullptr, 0, create_external, nullptr,
+                                &fn_create_external);
+  if (status != napi_ok) {
+    napi_throw_error(env, nullptr, "Failed to create create_external function");
+    return nullptr;
+  }
+  status = napi_set_named_property(env, exports, "createExternal",
+                                   fn_create_external);
+  if (status != napi_ok) {
+    napi_throw_error(env, nullptr,
+                     "Failed to add create_external function to exports");
+    return nullptr;
+  }
+
+  return exports;
+}
+
+struct NewOnBeforeParseArguments {
+  size_t __struct_size;
+  void *bun;
+  const uint8_t *path_ptr;
+  size_t path_len;
+  const uint8_t *namespace_ptr;
+  size_t namespace_len;
+  uint8_t default_loader;
+  void *external;
+  size_t new_field_one;
+  size_t new_field_two;
+  size_t new_field_three;
+};
+
+struct NewOnBeforeParseResult {
+  size_t __struct_size;
+  uint8_t *source_ptr;
+  size_t source_len;
+  uint8_t loader;
+  int (*fetchSourceCode)(const NewOnBeforeParseArguments *args,
+                         struct NewOnBeforeParseResult *result);
+  void *plugin_source_code_context;
+  void (*free_plugin_source_code_context)(void *ctx);
+  void (*log)(const NewOnBeforeParseArguments *args, BunLogOptions *options);
+  size_t new_field_one;
+  size_t new_field_two;
+  size_t new_field_three;
+};
+
+void new_log_error(const NewOnBeforeParseArguments *args,
+                   const NewOnBeforeParseResult *result, BunLogLevel level,
+                   const char *message, size_t message_len) {
+  BunLogOptions options;
+  options.message_ptr = (uint8_t *)message;
+  options.message_len = message_len;
+  options.path_ptr = args->path_ptr;
+  options.path_len = args->path_len;
+  options.source_line_text_ptr = nullptr;
+  options.source_line_text_len = 0;
+  options.level = (int8_t)level;
+  options.line = 0;
+  options.lineEnd = 0;
+  options.column = 0;
+  options.columnEnd = 0;
+  (result->log)(args, &options);
+}
+
+extern "C" BUN_PLUGIN_EXPORT void
+incompatible_version_plugin_impl(const NewOnBeforeParseArguments *args,
+                                 NewOnBeforeParseResult *result) {
+  if (args->__struct_size < sizeof(NewOnBeforeParseArguments)) {
+    const char *msg = "This plugin is built for a newer version of Bun than "
+                      "the one currently running.";
+    new_log_error(args, result, BUN_LOG_LEVEL_ERROR, msg, strlen(msg));
+    return;
+  }
+
+  if (result->__struct_size < sizeof(NewOnBeforeParseResult)) {
+    const char *msg = "This plugin is built for a newer version of Bun than "
+                      "the one currently running.";
+    new_log_error(args, result, BUN_LOG_LEVEL_ERROR, msg, strlen(msg));
+    return;
+  }
+}
+
+struct RandomUserContext {
+  const char *foo;
+  size_t bar;
+};
+
+extern "C" BUN_PLUGIN_EXPORT void random_user_context_free(void *ptr) {
+  free(ptr);
+}
+
+extern "C" BUN_PLUGIN_EXPORT void
+plugin_impl_bad_free_function_pointer(const OnBeforeParseArguments *args,
+                                      OnBeforeParseResult *result) {
+
+  // Intentionally not setting the context here:
+  // result->plugin_source_code_context = ctx;
+  result->free_plugin_source_code_context = random_user_context_free;
+}
+
+NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)
diff --git a/test/bundler/transpiler/__snapshots__/transpiler.test.js.snap b/test/bundler/transpiler/__snapshots__/transpiler.test.js.snap
index 50a51491f4..8e21dd38d1 100644
--- a/test/bundler/transpiler/__snapshots__/transpiler.test.js.snap
+++ b/test/bundler/transpiler/__snapshots__/transpiler.test.js.snap
@@ -143,561 +143,6 @@ __bun_temp_ref_6$ && await __bun_temp_ref_6$;
 }"
 `;
 
-exports[`Bun.Transpiler using top level 1`] = `
-"import {
-__callDispose as __callDispose,
-__using as __using
-} from "bun:wrap";
-export function c(e) {
-  let __bun_temp_ref_1$ = [];
-  try {
-    const f = __using(__bun_temp_ref_1$, g(a), 0);
-    return f.h;
-  } catch (__bun_temp_ref_2$) {
-    var __bun_temp_ref_3$ = __bun_temp_ref_2$, __bun_temp_ref_4$ = 1;
-  } finally {
-    __callDispose(__bun_temp_ref_1$, __bun_temp_ref_3$, __bun_temp_ref_4$);
-  }
-}
-import {using} from "n";
-let __bun_temp_ref_5$ = [];
-try {
-  var a = __using(__bun_temp_ref_5$, b, 0);
-  var j = __using(__bun_temp_ref_5$, c(i), 1);
-  var k = __using(__bun_temp_ref_5$, l(m), 0);
-  var o = __using(__bun_temp_ref_5$, using, 0);
-  var p = __using(__bun_temp_ref_5$, await using, 1);
-  var q = r;
-} catch (__bun_temp_ref_6$) {
-  var __bun_temp_ref_7$ = __bun_temp_ref_6$, __bun_temp_ref_8$ = 1;
-} finally {
-  var __bun_temp_ref_9$ = __callDispose(__bun_temp_ref_5$, __bun_temp_ref_7$, __bun_temp_ref_8$);
-  __bun_temp_ref_9$ && await __bun_temp_ref_9$;
-}
-
-export {
-  k,
-  q
-};
-"
-`;
-
-exports[`Bun.Transpiler using statements work right 1`] = `
-"let __bun_temp_ref_1$ = [];
-try {
-const x = __using(__bun_temp_ref_1$, a, 0);
-} catch (__bun_temp_ref_2$) {
-var __bun_temp_ref_3$ = __bun_temp_ref_2$, __bun_temp_ref_4$ = 1;
-} finally {
-__callDispose(__bun_temp_ref_1$, __bun_temp_ref_3$, __bun_temp_ref_4$);
-}"
-`;
-
-exports[`Bun.Transpiler using statements work right 2`] = `
-"let __bun_temp_ref_1$ = [];
-try {
-const x = __using(__bun_temp_ref_1$, a, 1);
-} catch (__bun_temp_ref_2$) {
-var __bun_temp_ref_3$ = __bun_temp_ref_2$, __bun_temp_ref_4$ = 1;
-} finally {
-var __bun_temp_ref_5$ = __callDispose(__bun_temp_ref_1$, __bun_temp_ref_3$, __bun_temp_ref_4$);
-__bun_temp_ref_5$ && await __bun_temp_ref_5$;
-}"
-`;
-
-exports[`Bun.Transpiler using statements work right 3`] = `
-"for (const __bun_temp_ref_1$ of b) {
-let __bun_temp_ref_2$ = [];
-try {
-const a = __using(__bun_temp_ref_2$, __bun_temp_ref_1$, 0);
-c(a);
-} catch (__bun_temp_ref_3$) {
-var __bun_temp_ref_4$ = __bun_temp_ref_3$, __bun_temp_ref_5$ = 1;
-} finally {
-__callDispose(__bun_temp_ref_2$, __bun_temp_ref_4$, __bun_temp_ref_5$);
-}
-}"
-`;
-
-exports[`Bun.Transpiler using statements work right 4`] = `
-"for await (const __bun_temp_ref_1$ of b) {
-let __bun_temp_ref_2$ = [];
-try {
-const a = __using(__bun_temp_ref_2$, __bun_temp_ref_1$, 0);
-c(a);
-} catch (__bun_temp_ref_3$) {
-var __bun_temp_ref_4$ = __bun_temp_ref_3$, __bun_temp_ref_5$ = 1;
-} finally {
-__callDispose(__bun_temp_ref_2$, __bun_temp_ref_4$, __bun_temp_ref_5$);
-}
-}"
-`;
-
-exports[`Bun.Transpiler using statements work right 5`] = `
-"for (const __bun_temp_ref_1$ of b) {
-let __bun_temp_ref_2$ = [];
-try {
-const a = __using(__bun_temp_ref_2$, __bun_temp_ref_1$, 1);
-c(a);
-} catch (__bun_temp_ref_3$) {
-var __bun_temp_ref_4$ = __bun_temp_ref_3$, __bun_temp_ref_5$ = 1;
-} finally {
-var __bun_temp_ref_6$ = __callDispose(__bun_temp_ref_2$, __bun_temp_ref_4$, __bun_temp_ref_5$);
-__bun_temp_ref_6$ && await __bun_temp_ref_6$;
-}
-}"
-`;
-
-exports[`Bun.Transpiler using statements work right 6`] = `
-"for await (const __bun_temp_ref_1$ of b) {
-let __bun_temp_ref_2$ = [];
-try {
-const a = __using(__bun_temp_ref_2$, __bun_temp_ref_1$, 1);
-c(a);
-} catch (__bun_temp_ref_3$) {
-var __bun_temp_ref_4$ = __bun_temp_ref_3$, __bun_temp_ref_5$ = 1;
-} finally {
-var __bun_temp_ref_6$ = __callDispose(__bun_temp_ref_2$, __bun_temp_ref_4$, __bun_temp_ref_5$);
-__bun_temp_ref_6$ && await __bun_temp_ref_6$;
-}
-}"
-`;
-
-exports[`Bun.Transpiler using statements work right 7`] = `
-"for (const __bun_temp_ref_1$ of b) {
-let __bun_temp_ref_2$ = [];
-try {
-const a = __using(__bun_temp_ref_2$, __bun_temp_ref_1$, 0);
-c(a);
-a(c);
-} catch (__bun_temp_ref_3$) {
-var __bun_temp_ref_4$ = __bun_temp_ref_3$, __bun_temp_ref_5$ = 1;
-} finally {
-__callDispose(__bun_temp_ref_2$, __bun_temp_ref_4$, __bun_temp_ref_5$);
-}
-}"
-`;
-
-exports[`Bun.Transpiler using statements work right 8`] = `
-"for await (const __bun_temp_ref_1$ of b) {
-let __bun_temp_ref_2$ = [];
-try {
-const a = __using(__bun_temp_ref_2$, __bun_temp_ref_1$, 0);
-c(a);
-a(c);
-} catch (__bun_temp_ref_3$) {
-var __bun_temp_ref_4$ = __bun_temp_ref_3$, __bun_temp_ref_5$ = 1;
-} finally {
-__callDispose(__bun_temp_ref_2$, __bun_temp_ref_4$, __bun_temp_ref_5$);
-}
-}"
-`;
-
-exports[`Bun.Transpiler using statements work right 9`] = `
-"for (const __bun_temp_ref_1$ of b) {
-let __bun_temp_ref_2$ = [];
-try {
-const a = __using(__bun_temp_ref_2$, __bun_temp_ref_1$, 1);
-c(a);
-a(c);
-} catch (__bun_temp_ref_3$) {
-var __bun_temp_ref_4$ = __bun_temp_ref_3$, __bun_temp_ref_5$ = 1;
-} finally {
-var __bun_temp_ref_6$ = __callDispose(__bun_temp_ref_2$, __bun_temp_ref_4$, __bun_temp_ref_5$);
-__bun_temp_ref_6$ && await __bun_temp_ref_6$;
-}
-}"
-`;
-
-exports[`Bun.Transpiler using statements work right 10`] = `
-"for await (const __bun_temp_ref_1$ of b) {
-let __bun_temp_ref_2$ = [];
-try {
-const a = __using(__bun_temp_ref_2$, __bun_temp_ref_1$, 1);
-c(a);
-a(c);
-} catch (__bun_temp_ref_3$) {
-var __bun_temp_ref_4$ = __bun_temp_ref_3$, __bun_temp_ref_5$ = 1;
-} finally {
-var __bun_temp_ref_6$ = __callDispose(__bun_temp_ref_2$, __bun_temp_ref_4$, __bun_temp_ref_5$);
-__bun_temp_ref_6$ && await __bun_temp_ref_6$;
-}
-}"
-`;
-
-exports[`Bun.Transpiler using top level 1`] = `
-"import {
-__callDispose as __callDispose,
-__using as __using
-} from "bun:wrap";
-export function c(e) {
-  let __bun_temp_ref_1$ = [];
-  try {
-    const f = __using(__bun_temp_ref_1$, g(a), 0);
-    return f.h;
-  } catch (__bun_temp_ref_2$) {
-    var __bun_temp_ref_3$ = __bun_temp_ref_2$, __bun_temp_ref_4$ = 1;
-  } finally {
-    __callDispose(__bun_temp_ref_1$, __bun_temp_ref_3$, __bun_temp_ref_4$);
-  }
-}
-import {using} from "n";
-let __bun_temp_ref_5$ = [];
-try {
-  var a = __using(__bun_temp_ref_5$, b, 0);
-  var j = __using(__bun_temp_ref_5$, c(i), 1);
-  var k = __using(__bun_temp_ref_5$, l(m), 0);
-  var o = __using(__bun_temp_ref_5$, using, 0);
-  var p = __using(__bun_temp_ref_5$, await using, 1);
-  var q = r;
-} catch (__bun_temp_ref_6$) {
-  var __bun_temp_ref_7$ = __bun_temp_ref_6$, __bun_temp_ref_8$ = 1;
-} finally {
-  var __bun_temp_ref_9$ = __callDispose(__bun_temp_ref_5$, __bun_temp_ref_7$, __bun_temp_ref_8$);
-  __bun_temp_ref_9$ && await __bun_temp_ref_9$;
-}
-
-export {
-  k,
-  q
-};
-"
-`;
-
-exports[`Bun.Transpiler using statements work right 1`] = `
-"let __bun_temp_ref_1$ = [];
-try {
-const x = __using(__bun_temp_ref_1$, a, 0);
-} catch (__bun_temp_ref_2$) {
-var __bun_temp_ref_3$ = __bun_temp_ref_2$,
-__bun_temp_ref_4$ = 1;
-} finally {
-__callDispose(__bun_temp_ref_1$, __bun_temp_ref_3$, __bun_temp_ref_4$);
-}"
-`;
-
-exports[`Bun.Transpiler using statements work right 2`] = `
-"let __bun_temp_ref_1$ = [];
-try {
-const x = __using(__bun_temp_ref_1$, a, 1);
-} catch (__bun_temp_ref_2$) {
-var __bun_temp_ref_3$ = __bun_temp_ref_2$,
-__bun_temp_ref_4$ = 1;
-} finally {
-var __bun_temp_ref_5$ = __callDispose(__bun_temp_ref_1$, __bun_temp_ref_3$, __bun_temp_ref_4$);
-__bun_temp_ref_5$ && await __bun_temp_ref_5$;
-}"
-`;
-
-exports[`Bun.Transpiler using statements work right 3`] = `
-"for (const __bun_temp_ref_1$ of b) {
-let __bun_temp_ref_2$ = [];
-try {
-const a = __using(__bun_temp_ref_2$, __bun_temp_ref_1$, 0);
-c(a);
-} catch (__bun_temp_ref_3$) {
-var __bun_temp_ref_4$ = __bun_temp_ref_3$,
-__bun_temp_ref_5$ = 1;
-} finally {
-__callDispose(__bun_temp_ref_2$, __bun_temp_ref_4$, __bun_temp_ref_5$);
-}
-}"
-`;
-
-exports[`Bun.Transpiler using statements work right 4`] = `
-"for await (const __bun_temp_ref_1$ of b) {
-let __bun_temp_ref_2$ = [];
-try {
-const a = __using(__bun_temp_ref_2$, __bun_temp_ref_1$, 0);
-c(a);
-} catch (__bun_temp_ref_3$) {
-var __bun_temp_ref_4$ = __bun_temp_ref_3$,
-__bun_temp_ref_5$ = 1;
-} finally {
-__callDispose(__bun_temp_ref_2$, __bun_temp_ref_4$, __bun_temp_ref_5$);
-}
-}"
-`;
-
-exports[`Bun.Transpiler using statements work right 5`] = `
-"for (const __bun_temp_ref_1$ of b) {
-let __bun_temp_ref_2$ = [];
-try {
-const a = __using(__bun_temp_ref_2$, __bun_temp_ref_1$, 1);
-c(a);
-} catch (__bun_temp_ref_3$) {
-var __bun_temp_ref_4$ = __bun_temp_ref_3$,
-__bun_temp_ref_5$ = 1;
-} finally {
-var __bun_temp_ref_6$ = __callDispose(__bun_temp_ref_2$, __bun_temp_ref_4$, __bun_temp_ref_5$);
-__bun_temp_ref_6$ && await __bun_temp_ref_6$;
-}
-}"
-`;
-
-exports[`Bun.Transpiler using statements work right 6`] = `
-"for await (const __bun_temp_ref_1$ of b) {
-let __bun_temp_ref_2$ = [];
-try {
-const a = __using(__bun_temp_ref_2$, __bun_temp_ref_1$, 1);
-c(a);
-} catch (__bun_temp_ref_3$) {
-var __bun_temp_ref_4$ = __bun_temp_ref_3$,
-__bun_temp_ref_5$ = 1;
-} finally {
-var __bun_temp_ref_6$ = __callDispose(__bun_temp_ref_2$, __bun_temp_ref_4$, __bun_temp_ref_5$);
-__bun_temp_ref_6$ && await __bun_temp_ref_6$;
-}
-}"
-`;
-
-exports[`Bun.Transpiler using statements work right 7`] = `
-"for (const __bun_temp_ref_1$ of b) {
-let __bun_temp_ref_2$ = [];
-try {
-const a = __using(__bun_temp_ref_2$, __bun_temp_ref_1$, 0);
-c(a);
-a(c);
-} catch (__bun_temp_ref_3$) {
-var __bun_temp_ref_4$ = __bun_temp_ref_3$,
-__bun_temp_ref_5$ = 1;
-} finally {
-__callDispose(__bun_temp_ref_2$, __bun_temp_ref_4$, __bun_temp_ref_5$);
-}
-}"
-`;
-
-exports[`Bun.Transpiler using statements work right 8`] = `
-"for await (const __bun_temp_ref_1$ of b) {
-let __bun_temp_ref_2$ = [];
-try {
-const a = __using(__bun_temp_ref_2$, __bun_temp_ref_1$, 0);
-c(a);
-a(c);
-} catch (__bun_temp_ref_3$) {
-var __bun_temp_ref_4$ = __bun_temp_ref_3$,
-__bun_temp_ref_5$ = 1;
-} finally {
-__callDispose(__bun_temp_ref_2$, __bun_temp_ref_4$, __bun_temp_ref_5$);
-}
-}"
-`;
-
-exports[`Bun.Transpiler using statements work right 9`] = `
-"for (const __bun_temp_ref_1$ of b) {
-let __bun_temp_ref_2$ = [];
-try {
-const a = __using(__bun_temp_ref_2$, __bun_temp_ref_1$, 1);
-c(a);
-a(c);
-} catch (__bun_temp_ref_3$) {
-var __bun_temp_ref_4$ = __bun_temp_ref_3$,
-__bun_temp_ref_5$ = 1;
-} finally {
-var __bun_temp_ref_6$ = __callDispose(__bun_temp_ref_2$, __bun_temp_ref_4$, __bun_temp_ref_5$);
-__bun_temp_ref_6$ && await __bun_temp_ref_6$;
-}
-}"
-`;
-
-exports[`Bun.Transpiler using statements work right 10`] = `
-"for await (const __bun_temp_ref_1$ of b) {
-let __bun_temp_ref_2$ = [];
-try {
-const a = __using(__bun_temp_ref_2$, __bun_temp_ref_1$, 1);
-c(a);
-a(c);
-} catch (__bun_temp_ref_3$) {
-var __bun_temp_ref_4$ = __bun_temp_ref_3$,
-__bun_temp_ref_5$ = 1;
-} finally {
-var __bun_temp_ref_6$ = __callDispose(__bun_temp_ref_2$, __bun_temp_ref_4$, __bun_temp_ref_5$);
-__bun_temp_ref_6$ && await __bun_temp_ref_6$;
-}
-}"
-`;
-
-exports[`Bun.Transpiler using top level 1`] = `
-"import { __callDispose as __callDispose, __using as __using } from "bun:wrap";
-export function c(e) {
-  let __bun_temp_ref_1$ = [];
-  try {
-    const f = __using(__bun_temp_ref_1$, g(a), 0);
-    return f.h;
-  } catch (__bun_temp_ref_2$) {
-    var __bun_temp_ref_3$ = __bun_temp_ref_2$,
-      __bun_temp_ref_4$ = 1;
-  } finally {
-    __callDispose(__bun_temp_ref_1$, __bun_temp_ref_3$, __bun_temp_ref_4$);
-  }
-}
-import { using } from "n";
-let __bun_temp_ref_5$ = [];
-try {
-  var a = __using(__bun_temp_ref_5$, b, 0);
-  var j = __using(__bun_temp_ref_5$, c(i), 1);
-  var k = __using(__bun_temp_ref_5$, l(m), 0);
-  var o = __using(__bun_temp_ref_5$, using, 0);
-  var p = __using(__bun_temp_ref_5$, await using, 1);
-  var q = r;
-} catch (__bun_temp_ref_6$) {
-  var __bun_temp_ref_7$ = __bun_temp_ref_6$,
-    __bun_temp_ref_8$ = 1;
-} finally {
-  var __bun_temp_ref_9$ = __callDispose(__bun_temp_ref_5$, __bun_temp_ref_7$, __bun_temp_ref_8$);
-  __bun_temp_ref_9$ && await __bun_temp_ref_9$;
-}
-
-export {
-  k,
-  q
-};
-"
-`;
-
-exports[`Bun.Transpiler using statements work right 1`] = `
-"let __bun_temp_ref_1$ = [];
-try {
-const x = __using(__bun_temp_ref_1$, a, 0);
-} catch (__bun_temp_ref_2$) {
-var __bun_temp_ref_3$ = __bun_temp_ref_2$, __bun_temp_ref_4$ = 1;
-} finally {
-__callDispose(__bun_temp_ref_1$, __bun_temp_ref_3$, __bun_temp_ref_4$);
-}"
-`;
-
-exports[`Bun.Transpiler using statements work right 2`] = `
-"let __bun_temp_ref_1$ = [];
-try {
-const x = __using(__bun_temp_ref_1$, a, 1);
-} catch (__bun_temp_ref_2$) {
-var __bun_temp_ref_3$ = __bun_temp_ref_2$, __bun_temp_ref_4$ = 1;
-} finally {
-var __bun_temp_ref_5$ = __callDispose(__bun_temp_ref_1$, __bun_temp_ref_3$, __bun_temp_ref_4$);
-__bun_temp_ref_5$ && await __bun_temp_ref_5$;
-}"
-`;
-
-exports[`Bun.Transpiler using statements work right 3`] = `
-"for (const __bun_temp_ref_1$ of b) {
-let __bun_temp_ref_2$ = [];
-try {
-const a = __using(__bun_temp_ref_2$, __bun_temp_ref_1$, 0);
-c(a);
-} catch (__bun_temp_ref_3$) {
-var __bun_temp_ref_4$ = __bun_temp_ref_3$, __bun_temp_ref_5$ = 1;
-} finally {
-__callDispose(__bun_temp_ref_2$, __bun_temp_ref_4$, __bun_temp_ref_5$);
-}
-}"
-`;
-
-exports[`Bun.Transpiler using statements work right 4`] = `
-"for await (const __bun_temp_ref_1$ of b) {
-let __bun_temp_ref_2$ = [];
-try {
-const a = __using(__bun_temp_ref_2$, __bun_temp_ref_1$, 0);
-c(a);
-} catch (__bun_temp_ref_3$) {
-var __bun_temp_ref_4$ = __bun_temp_ref_3$, __bun_temp_ref_5$ = 1;
-} finally {
-__callDispose(__bun_temp_ref_2$, __bun_temp_ref_4$, __bun_temp_ref_5$);
-}
-}"
-`;
-
-exports[`Bun.Transpiler using statements work right 5`] = `
-"for (const __bun_temp_ref_1$ of b) {
-let __bun_temp_ref_2$ = [];
-try {
-const a = __using(__bun_temp_ref_2$, __bun_temp_ref_1$, 1);
-c(a);
-} catch (__bun_temp_ref_3$) {
-var __bun_temp_ref_4$ = __bun_temp_ref_3$, __bun_temp_ref_5$ = 1;
-} finally {
-var __bun_temp_ref_6$ = __callDispose(__bun_temp_ref_2$, __bun_temp_ref_4$, __bun_temp_ref_5$);
-__bun_temp_ref_6$ && await __bun_temp_ref_6$;
-}
-}"
-`;
-
-exports[`Bun.Transpiler using statements work right 6`] = `
-"for await (const __bun_temp_ref_1$ of b) {
-let __bun_temp_ref_2$ = [];
-try {
-const a = __using(__bun_temp_ref_2$, __bun_temp_ref_1$, 1);
-c(a);
-} catch (__bun_temp_ref_3$) {
-var __bun_temp_ref_4$ = __bun_temp_ref_3$, __bun_temp_ref_5$ = 1;
-} finally {
-var __bun_temp_ref_6$ = __callDispose(__bun_temp_ref_2$, __bun_temp_ref_4$, __bun_temp_ref_5$);
-__bun_temp_ref_6$ && await __bun_temp_ref_6$;
-}
-}"
-`;
-
-exports[`Bun.Transpiler using statements work right 7`] = `
-"for (const __bun_temp_ref_1$ of b) {
-let __bun_temp_ref_2$ = [];
-try {
-const a = __using(__bun_temp_ref_2$, __bun_temp_ref_1$, 0);
-c(a);
-a(c);
-} catch (__bun_temp_ref_3$) {
-var __bun_temp_ref_4$ = __bun_temp_ref_3$, __bun_temp_ref_5$ = 1;
-} finally {
-__callDispose(__bun_temp_ref_2$, __bun_temp_ref_4$, __bun_temp_ref_5$);
-}
-}"
-`;
-
-exports[`Bun.Transpiler using statements work right 8`] = `
-"for await (const __bun_temp_ref_1$ of b) {
-let __bun_temp_ref_2$ = [];
-try {
-const a = __using(__bun_temp_ref_2$, __bun_temp_ref_1$, 0);
-c(a);
-a(c);
-} catch (__bun_temp_ref_3$) {
-var __bun_temp_ref_4$ = __bun_temp_ref_3$, __bun_temp_ref_5$ = 1;
-} finally {
-__callDispose(__bun_temp_ref_2$, __bun_temp_ref_4$, __bun_temp_ref_5$);
-}
-}"
-`;
-
-exports[`Bun.Transpiler using statements work right 9`] = `
-"for (const __bun_temp_ref_1$ of b) {
-let __bun_temp_ref_2$ = [];
-try {
-const a = __using(__bun_temp_ref_2$, __bun_temp_ref_1$, 1);
-c(a);
-a(c);
-} catch (__bun_temp_ref_3$) {
-var __bun_temp_ref_4$ = __bun_temp_ref_3$, __bun_temp_ref_5$ = 1;
-} finally {
-var __bun_temp_ref_6$ = __callDispose(__bun_temp_ref_2$, __bun_temp_ref_4$, __bun_temp_ref_5$);
-__bun_temp_ref_6$ && await __bun_temp_ref_6$;
-}
-}"
-`;
-
-exports[`Bun.Transpiler using statements work right 10`] = `
-"for await (const __bun_temp_ref_1$ of b) {
-let __bun_temp_ref_2$ = [];
-try {
-const a = __using(__bun_temp_ref_2$, __bun_temp_ref_1$, 1);
-c(a);
-a(c);
-} catch (__bun_temp_ref_3$) {
-var __bun_temp_ref_4$ = __bun_temp_ref_3$, __bun_temp_ref_5$ = 1;
-} finally {
-var __bun_temp_ref_6$ = __callDispose(__bun_temp_ref_2$, __bun_temp_ref_4$, __bun_temp_ref_5$);
-__bun_temp_ref_6$ && await __bun_temp_ref_6$;
-}
-}"
-`;
-
 exports[`Bun.Transpiler using top level 1`] = `
 "import { __callDispose as __callDispose, __using as __using } from "bun:wrap";
 export function c(e) {
diff --git a/test/bundler/transpiler/fixtures/9-comments.ts b/test/bundler/transpiler/fixtures/9-comments.ts
new file mode 100644
index 0000000000..b730d705fc
--- /dev/null
+++ b/test/bundler/transpiler/fixtures/9-comments.ts
@@ -0,0 +1,10 @@
+var a = 0;
+// 1
+// 2
+// 3
+// 4
+// 5
+// 6
+// 7
+// 8
+if (a < 9 /* 9 */) console.log("success!");
diff --git a/test/bundler/transpiler/transpiler.test.js b/test/bundler/transpiler/transpiler.test.js
index 33d91f5794..8757b968ae 100644
--- a/test/bundler/transpiler/transpiler.test.js
+++ b/test/bundler/transpiler/transpiler.test.js
@@ -1,5 +1,6 @@
 import { describe, expect, it } from "bun:test";
-import { hideFromStackTrace } from "harness";
+import { hideFromStackTrace, bunExe, bunEnv } from "harness";
+import { join } from "path";
 
 describe("Bun.Transpiler", () => {
   const transpiler = new Bun.Transpiler({
@@ -1237,7 +1238,7 @@ export default <>hi</>
     });
 
     expect(bun.transformSync("console.log(<div key={() => {}} points={() => {}}></div>);")).toBe(
-      `console.log(jsxDEV("div", {
+      `console.log(jsxDEV_7x81h0kn("div", {
   points: () => {
   }
 }, () => {
@@ -1246,7 +1247,7 @@ export default <>hi</>
     );
 
     expect(bun.transformSync("console.log(<div points={() => {}} key={() => {}}></div>);")).toBe(
-      `console.log(jsxDEV("div", {
+      `console.log(jsxDEV_7x81h0kn("div", {
   points: () => {
   }
 }, () => {
@@ -1255,23 +1256,23 @@ export default <>hi</>
     );
 
     expect(bun.transformSync("console.log(<div key={() => {}} key={() => {}}></div>);")).toBe(
-      'console.log(jsxDEV("div", {\n  key: () => {\n  }\n}, () => {\n}, false, undefined, this));\n',
+      'console.log(jsxDEV_7x81h0kn("div", {\n  key: () => {\n  }\n}, () => {\n}, false, undefined, this));\n',
     );
 
     expect(bun.transformSync("console.log(<div key={() => {}}></div>, () => {});")).toBe(
-      'console.log(jsxDEV("div", {}, () => {\n}, false, undefined, this), () => {\n});\n',
+      'console.log(jsxDEV_7x81h0kn("div", {}, () => {\n}, false, undefined, this), () => {\n});\n',
     );
 
     expect(bun.transformSync("console.log(<div key={() => {}} a={() => {}} key={() => {}}></div>, () => {});")).toBe(
-      'console.log(jsxDEV("div", {\n  key: () => {\n  },\n  a: () => {\n  }\n}, () => {\n}, false, undefined, this), () => {\n});\n',
+      'console.log(jsxDEV_7x81h0kn("div", {\n  key: () => {\n  },\n  a: () => {\n  }\n}, () => {\n}, false, undefined, this), () => {\n});\n',
     );
 
     expect(bun.transformSync("console.log(<div key={() => {}} key={() => {}} a={() => {}}></div>, () => {});")).toBe(
-      'console.log(jsxDEV("div", {\n  key: () => {\n  },\n  a: () => {\n  }\n}, () => {\n}, false, undefined, this), () => {\n});\n',
+      'console.log(jsxDEV_7x81h0kn("div", {\n  key: () => {\n  },\n  a: () => {\n  }\n}, () => {\n}, false, undefined, this), () => {\n});\n',
     );
 
     expect(bun.transformSync("console.log(<div points={() => {}} key={() => {}}></div>);")).toBe(
-      `console.log(jsxDEV("div", {
+      `console.log(jsxDEV_7x81h0kn("div", {
   points: () => {
   }
 }, () => {
@@ -1280,31 +1281,31 @@ export default <>hi</>
     );
 
     expect(bun.transformSync("console.log(<div key={() => {}}></div>);")).toBe(
-      `console.log(jsxDEV("div", {}, () => {
+      `console.log(jsxDEV_7x81h0kn("div", {}, () => {
 }, false, undefined, this));
 `,
     );
 
     expect(bun.transformSync("console.log(<div></div>);")).toBe(
-      `console.log(jsxDEV("div", {}, undefined, false, undefined, this));
+      `console.log(jsxDEV_7x81h0kn("div", {}, undefined, false, undefined, this));
 `,
     );
 
     // key after spread props
     // https://github.com/oven-sh/bun/issues/7328
     expect(bun.transformSync(`console.log(<div {...obj} key="after" />, <div key="before" {...obj} />);`)).toBe(
-      `console.log(createElement(\"div\", {\n  ...obj,\n  key: \"after\"\n}), jsxDEV(\"div\", {\n  ...obj\n}, \"before\", false, undefined, this));
+      `console.log(createElement_mvmpqhxp(\"div\", {\n  ...obj,\n  key: \"after\"\n}), jsxDEV_7x81h0kn(\"div\", {\n  ...obj\n}, \"before\", false, undefined, this));
 `,
     );
     expect(bun.transformSync(`console.log(<div {...obj} key="after" {...obj2} />);`)).toBe(
-      `console.log(createElement(\"div\", {\n  ...obj,\n  key: \"after\",\n  ...obj2\n}));
+      `console.log(createElement_mvmpqhxp(\"div\", {\n  ...obj,\n  key: \"after\",\n  ...obj2\n}));
 `,
     );
     expect(
       bun.transformSync(`// @jsx foo;
 console.log(<div {...obj} key="after" />);`),
     ).toBe(
-      `console.log(createElement(\"div\", {\n  ...obj,\n  key: \"after\"\n}));
+      `console.log(createElement_mvmpqhxp(\"div\", {\n  ...obj,\n  key: \"after\"\n}));
 `,
     );
   });
@@ -1317,44 +1318,44 @@ console.log(<div {...obj} key="after" />);`),
       },
     });
     expect(bun.transformSync("export var foo = <div foo />")).toBe(
-      `export var foo = jsxDEV("div", {
+      `export var foo = jsxDEV_7x81h0kn("div", {
   foo: true
 }, undefined, false, undefined, this);
 `,
     );
     expect(bun.transformSync("export var foo = <div foo={foo} />")).toBe(
-      `export var foo = jsxDEV("div", {
+      `export var foo = jsxDEV_7x81h0kn("div", {
   foo
 }, undefined, false, undefined, this);
 `,
     );
     expect(bun.transformSync("export var foo = <div {...foo} />")).toBe(
-      `export var foo = jsxDEV("div", {
+      `export var foo = jsxDEV_7x81h0kn("div", {
   ...foo
 }, undefined, false, undefined, this);
 `,
     );
 
     expect(bun.transformSync("export var hi = <div {foo} />")).toBe(
-      `export var hi = jsxDEV("div", {
+      `export var hi = jsxDEV_7x81h0kn("div", {
   foo
 }, undefined, false, undefined, this);
 `,
     );
     expect(bun.transformSync("export var hi = <div {foo.bar.baz} />")).toBe(
-      `export var hi = jsxDEV("div", {
+      `export var hi = jsxDEV_7x81h0kn("div", {
   baz: foo.bar.baz
 }, undefined, false, undefined, this);
 `,
     );
     expect(bun.transformSync("export var hi = <div {foo?.bar?.baz} />")).toBe(
-      `export var hi = jsxDEV("div", {
+      `export var hi = jsxDEV_7x81h0kn("div", {
   baz: foo?.bar?.baz
 }, undefined, false, undefined, this);
 `,
     );
     expect(bun.transformSync("export var hi = <div {foo['baz'].bar?.baz} />")).toBe(
-      `export var hi = jsxDEV("div", {
+      `export var hi = jsxDEV_7x81h0kn("div", {
   baz: foo["baz"].bar?.baz
 }, undefined, false, undefined, this);
 `,
@@ -1362,20 +1363,20 @@ console.log(<div {...obj} key="after" />);`),
 
     // cursed
     expect(bun.transformSync("export var hi = <div {foo[() => true].hi} />")).toBe(
-      `export var hi = jsxDEV("div", {
+      `export var hi = jsxDEV_7x81h0kn("div", {
   hi: foo[() => true].hi
 }, undefined, false, undefined, this);
 `,
     );
     expect(bun.transformSync("export var hi = <Foo {process.env.NODE_ENV} />")).toBe(
-      `export var hi = jsxDEV(Foo, {
+      `export var hi = jsxDEV_7x81h0kn(Foo, {
       NODE_ENV: "development"
     }, undefined, false, undefined, this);
     `,
     );
 
     expect(bun.transformSync("export var hi = <div {foo['baz'].bar?.baz} />")).toBe(
-      `export var hi = jsxDEV("div", {
+      `export var hi = jsxDEV_7x81h0kn("div", {
   baz: foo["baz"].bar?.baz
 }, undefined, false, undefined, this);
 `,
@@ -1388,22 +1389,22 @@ console.log(<div {...obj} key="after" />);`),
     }
 
     expect(bun.transformSync("export var hi = <div {Foo}><Foo></Foo></div>")).toBe(
-      `export var hi = jsxDEV("div", {
+      `export var hi = jsxDEV_7x81h0kn("div", {
   Foo,
-  children: jsxDEV(Foo, {}, undefined, false, undefined, this)
+  children: jsxDEV_7x81h0kn(Foo, {}, undefined, false, undefined, this)
 }, undefined, false, undefined, this);
 `,
     );
     expect(bun.transformSync("export var hi = <div {Foo}><Foo></Foo></div>")).toBe(
-      `export var hi = jsxDEV("div", {
+      `export var hi = jsxDEV_7x81h0kn("div", {
   Foo,
-  children: jsxDEV(Foo, {}, undefined, false, undefined, this)
+  children: jsxDEV_7x81h0kn(Foo, {}, undefined, false, undefined, this)
 }, undefined, false, undefined, this);
 `,
     );
 
     expect(bun.transformSync("export var hi = <div>{123}}</div>").trim()).toBe(
-      `export var hi = jsxDEV("div", {
+      `export var hi = jsxDEV_7x81h0kn("div", {
   children: [
     123,
     "}"
@@ -1421,7 +1422,7 @@ console.log(<div {...obj} key="after" />);`),
       },
     });
     expect(bun.transformSync("export var foo = <div>{...a}b</div>")).toBe(
-      `export var foo = jsxDEV("div", {
+      `export var foo = jsxDEV_7x81h0kn("div", {
   children: [
     ...a,
     "b"
@@ -1431,7 +1432,7 @@ console.log(<div {...obj} key="after" />);`),
     );
 
     expect(bun.transformSync("export var foo = <div>{...a}</div>")).toBe(
-      `export var foo = jsxDEV("div", {
+      `export var foo = jsxDEV_7x81h0kn("div", {
   children: [...a]
 }, undefined, true, undefined, this);
 `,
@@ -1668,8 +1669,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 +1836,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 +1845,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", () => {
@@ -3399,3 +3427,17 @@ describe("await can only be used inside an async function message", () => {
     assertError(`const foo = () => await bar();`, false);
   });
 });
+
+it("does not crash with 9 comments and typescript type skipping", () => {
+  const cmd = [bunExe(), "build", "--minify-identifiers", join(import.meta.dir, "fixtures", "9-comments.ts")];
+  const { stdout, stderr, exitCode } = Bun.spawnSync({
+    cmd,
+    stdout: "pipe",
+    stderr: "pipe",
+    env: bunEnv,
+  });
+
+  expect(stderr.toString()).toBe("");
+  expect(stdout.toString()).toContain("success!");
+  expect(exitCode).toBe(0);
+});
diff --git a/test/cli/hot/hot.test.ts b/test/cli/hot/hot.test.ts
index b819cdff2f..9b53bb733c 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/hot/watch.test.ts b/test/cli/hot/watch.test.ts
index 65c336c57d..ca757cf46c 100644
--- a/test/cli/hot/watch.test.ts
+++ b/test/cli/hot/watch.test.ts
@@ -1,10 +1,10 @@
 import { spawn } from "bun";
 import { describe, expect, test } from "bun:test";
-import { bunEnv, bunExe, forEachLine, tempDirWithFiles } from "harness";
+import { bunEnv, bunExe, forEachLine, isBroken, isWindows, tempDirWithFiles } from "harness";
 import { writeFile } from "node:fs/promises";
 import { join } from "node:path";
 
-describe("--watch works", async () => {
+describe.todoIf(isBroken && isWindows)("--watch works", async () => {
   for (const watchedFile of ["entry.js", "tmp.js"]) {
     test(`with ${watchedFile}`, async () => {
       const tmpdir_ = tempDirWithFiles("watch-fixture", {
diff --git a/test/cli/inspect/__snapshots__/inspect.test.ts.snap b/test/cli/inspect/__snapshots__/inspect.test.ts.snap
new file mode 100644
index 0000000000..1b8aaf67ee
--- /dev/null
+++ b/test/cli/inspect/__snapshots__/inspect.test.ts.snap
@@ -0,0 +1,22 @@
+// Bun Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`junit reporter 1`] = `
+"<?xml version="1.0" encoding="UTF-8"?>
+<testsuites>
+  <testsuite name="<dir>/a.test.js" tests="2" failures="1" errors="0" skipped="0" timestamp="2024-12-17T15:37:38.935Z">
+    <testcase classname="<dir>/a.test.js" name="fail"       <failure message="Test failed" type="AssertionError">
+        Error: expect(received).toBe(expected)
+
+Expected: 2
+Received: 1
+
+
+  at <dir>/a.test.js:4:19
+
+
+      </failure>
+    </testcase>
+    <testcase classname="<dir>/a.test.js" name="success"     </testcase>
+  </testsuite>
+</testsuites>"
+`;
diff --git a/test/cli/inspect/inspect.test.ts b/test/cli/inspect/inspect.test.ts
index e648ad8c8a..ce16df2320 100644
--- a/test/cli/inspect/inspect.test.ts
+++ b/test/cli/inspect/inspect.test.ts
@@ -1,289 +1,429 @@
 import { Subprocess, spawn } from "bun";
-import { afterEach, expect, test } from "bun:test";
-import { bunEnv, bunExe, randomPort } from "harness";
+import { afterEach, expect, test, describe } from "bun:test";
+import { bunEnv, bunExe, isPosix, randomPort, tempDirWithFiles } from "harness";
 import { WebSocket } from "ws";
-
+import { join } from "node:path";
 let inspectee: Subprocess;
-
+import { SocketFramer } from "./socket-framer";
+import { JUnitReporter, InspectorSession, connect } from "./junit-reporter";
+import stripAnsi from "strip-ansi";
 const anyPort = expect.stringMatching(/^\d+$/);
 const anyPathname = expect.stringMatching(/^\/[a-z0-9]+$/);
-const tests = [
-  {
-    args: ["--inspect"],
-    url: {
-      protocol: "ws:",
-      hostname: "localhost",
-      port: "6499",
-      pathname: anyPathname,
-    },
-  },
-  {
-    args: ["--inspect=0"],
-    url: {
-      protocol: "ws:",
-      hostname: "localhost",
-      port: anyPort,
-      pathname: anyPathname,
-    },
-  },
-  {
-    args: [`--inspect=${randomPort()}`],
-    url: {
-      protocol: "ws:",
-      hostname: "localhost",
-      port: anyPort,
-      pathname: anyPathname,
-    },
-  },
-  {
-    args: ["--inspect=localhost"],
-    url: {
-      protocol: "ws:",
-      hostname: "localhost",
-      port: "6499",
-      pathname: anyPathname,
-    },
-  },
-  {
-    args: ["--inspect=localhost/"],
-    url: {
-      protocol: "ws:",
-      hostname: "localhost",
-      port: "6499",
-      pathname: "/",
-    },
-  },
-  {
-    args: ["--inspect=localhost:0"],
-    url: {
-      protocol: "ws:",
-      hostname: "localhost",
-      port: anyPort,
-      pathname: anyPathname,
-    },
-  },
-  {
-    args: ["--inspect=localhost:0/"],
-    url: {
-      protocol: "ws:",
-      hostname: "localhost",
-      port: anyPort,
-      pathname: "/",
-    },
-  },
-  {
-    args: ["--inspect=localhost/foo/bar"],
-    url: {
-      protocol: "ws:",
-      hostname: "localhost",
-      port: "6499",
-      pathname: "/foo/bar",
-    },
-  },
-  {
-    args: ["--inspect=127.0.0.1"],
-    url: {
-      protocol: "ws:",
-      hostname: "127.0.0.1",
-      port: "6499",
-      pathname: anyPathname,
-    },
-  },
-  {
-    args: ["--inspect=127.0.0.1/"],
-    url: {
-      protocol: "ws:",
-      hostname: "127.0.0.1",
-      port: "6499",
-      pathname: "/",
-    },
-  },
-  {
-    args: ["--inspect=127.0.0.1:0/"],
-    url: {
-      protocol: "ws:",
-      hostname: "127.0.0.1",
-      port: anyPort,
-      pathname: "/",
-    },
-  },
-  {
-    args: ["--inspect=[::1]"],
-    url: {
-      protocol: "ws:",
-      hostname: "[::1]",
-      port: "6499",
-      pathname: anyPathname,
-    },
-  },
-  {
-    args: ["--inspect=[::1]:0"],
-    url: {
-      protocol: "ws:",
-      hostname: "[::1]",
-      port: anyPort,
-      pathname: anyPathname,
-    },
-  },
-  {
-    args: ["--inspect=[::1]:0/"],
-    url: {
-      protocol: "ws:",
-      hostname: "[::1]",
-      port: anyPort,
-      pathname: "/",
-    },
-  },
-  {
-    args: ["--inspect=/"],
-    url: {
-      protocol: "ws:",
-      hostname: "localhost",
-      port: "6499",
-      pathname: "/",
-    },
-  },
-  {
-    args: ["--inspect=/foo"],
-    url: {
-      protocol: "ws:",
-      hostname: "localhost",
-      port: "6499",
-      pathname: "/foo",
-    },
-  },
-  {
-    args: ["--inspect=/foo/baz/"],
-    url: {
-      protocol: "ws:",
-      hostname: "localhost",
-      port: "6499",
-      pathname: "/foo/baz/",
-    },
-  },
-  {
-    args: ["--inspect=:0"],
-    url: {
-      protocol: "ws:",
-      hostname: "localhost",
-      port: anyPort,
-      pathname: anyPathname,
-    },
-  },
-  {
-    args: ["--inspect=:0/"],
-    url: {
-      protocol: "ws:",
-      hostname: "localhost",
-      port: anyPort,
-      pathname: "/",
-    },
-  },
-  {
-    args: ["--inspect=ws://localhost/"],
-    url: {
-      protocol: "ws:",
-      hostname: "localhost",
-      port: anyPort,
-      pathname: "/",
-    },
-  },
-  {
-    args: ["--inspect=ws://localhost:0/"],
-    url: {
-      protocol: "ws:",
-      hostname: "localhost",
-      port: anyPort,
-      pathname: "/",
-    },
-  },
-  {
-    args: ["--inspect=ws://localhost:6499/foo/bar"],
-    url: {
-      protocol: "ws:",
-      hostname: "localhost",
-      port: "6499",
-      pathname: "/foo/bar",
-    },
-  },
-];
 
-for (const { args, url: expected } of tests) {
-  test(`bun ${args.join(" ")}`, async () => {
-    inspectee = spawn({
-      cwd: import.meta.dir,
-      cmd: [bunExe(), ...args, "inspectee.js"],
-      env: bunEnv,
-      stdout: "ignore",
-      stderr: "pipe",
-    });
+describe("websocket", () => {
+  const tests = [
+    {
+      args: ["--inspect"],
+      url: {
+        protocol: "ws:",
+        hostname: "localhost",
+        port: "6499",
+        pathname: anyPathname,
+      },
+    },
+    {
+      args: ["--inspect=0"],
+      url: {
+        protocol: "ws:",
+        hostname: "localhost",
+        port: anyPort,
+        pathname: anyPathname,
+      },
+    },
+    {
+      args: [`--inspect=${randomPort()}`],
+      url: {
+        protocol: "ws:",
+        hostname: "localhost",
+        port: anyPort,
+        pathname: anyPathname,
+      },
+    },
+    {
+      args: ["--inspect=localhost"],
+      url: {
+        protocol: "ws:",
+        hostname: "localhost",
+        port: "6499",
+        pathname: anyPathname,
+      },
+    },
+    {
+      args: ["--inspect=localhost/"],
+      url: {
+        protocol: "ws:",
+        hostname: "localhost",
+        port: "6499",
+        pathname: "/",
+      },
+    },
+    {
+      args: ["--inspect=localhost:0"],
+      url: {
+        protocol: "ws:",
+        hostname: "localhost",
+        port: anyPort,
+        pathname: anyPathname,
+      },
+    },
+    {
+      args: ["--inspect=localhost:0/"],
+      url: {
+        protocol: "ws:",
+        hostname: "localhost",
+        port: anyPort,
+        pathname: "/",
+      },
+    },
+    {
+      args: ["--inspect=localhost/foo/bar"],
+      url: {
+        protocol: "ws:",
+        hostname: "localhost",
+        port: "6499",
+        pathname: "/foo/bar",
+      },
+    },
+    {
+      args: ["--inspect=127.0.0.1"],
+      url: {
+        protocol: "ws:",
+        hostname: "127.0.0.1",
+        port: "6499",
+        pathname: anyPathname,
+      },
+    },
+    {
+      args: ["--inspect=127.0.0.1/"],
+      url: {
+        protocol: "ws:",
+        hostname: "127.0.0.1",
+        port: "6499",
+        pathname: "/",
+      },
+    },
+    {
+      args: ["--inspect=127.0.0.1:0/"],
+      url: {
+        protocol: "ws:",
+        hostname: "127.0.0.1",
+        port: anyPort,
+        pathname: "/",
+      },
+    },
+    {
+      args: ["--inspect=[::1]"],
+      url: {
+        protocol: "ws:",
+        hostname: "[::1]",
+        port: "6499",
+        pathname: anyPathname,
+      },
+    },
+    {
+      args: ["--inspect=[::1]:0"],
+      url: {
+        protocol: "ws:",
+        hostname: "[::1]",
+        port: anyPort,
+        pathname: anyPathname,
+      },
+    },
+    {
+      args: ["--inspect=[::1]:0/"],
+      url: {
+        protocol: "ws:",
+        hostname: "[::1]",
+        port: anyPort,
+        pathname: "/",
+      },
+    },
+    {
+      args: ["--inspect=/"],
+      url: {
+        protocol: "ws:",
+        hostname: "localhost",
+        port: "6499",
+        pathname: "/",
+      },
+    },
+    {
+      args: ["--inspect=/foo"],
+      url: {
+        protocol: "ws:",
+        hostname: "localhost",
+        port: "6499",
+        pathname: "/foo",
+      },
+    },
+    {
+      args: ["--inspect=/foo/baz/"],
+      url: {
+        protocol: "ws:",
+        hostname: "localhost",
+        port: "6499",
+        pathname: "/foo/baz/",
+      },
+    },
+    {
+      args: ["--inspect=:0"],
+      url: {
+        protocol: "ws:",
+        hostname: "localhost",
+        port: anyPort,
+        pathname: anyPathname,
+      },
+    },
+    {
+      args: ["--inspect=:0/"],
+      url: {
+        protocol: "ws:",
+        hostname: "localhost",
+        port: anyPort,
+        pathname: "/",
+      },
+    },
+    {
+      args: ["--inspect=ws://localhost/"],
+      url: {
+        protocol: "ws:",
+        hostname: "localhost",
+        port: anyPort,
+        pathname: "/",
+      },
+    },
+    {
+      args: ["--inspect=ws://localhost:0/"],
+      url: {
+        protocol: "ws:",
+        hostname: "localhost",
+        port: anyPort,
+        pathname: "/",
+      },
+    },
+    {
+      args: ["--inspect=ws://localhost:6499/foo/bar"],
+      url: {
+        protocol: "ws:",
+        hostname: "localhost",
+        port: "6499",
+        pathname: "/foo/bar",
+      },
+    },
+  ];
 
-    let url: URL | undefined;
-    let stderr = "";
-    const decoder = new TextDecoder();
-    for await (const chunk of inspectee.stderr as ReadableStream) {
-      stderr += decoder.decode(chunk);
-      for (const line of stderr.split("\n")) {
-        try {
-          url = new URL(line);
-        } catch {
-          // Ignore
+  for (const { args, url: expected } of tests) {
+    test(`bun ${args.join(" ")}`, async () => {
+      inspectee = spawn({
+        cwd: import.meta.dir,
+        cmd: [bunExe(), ...args, "inspectee.js"],
+        env: bunEnv,
+        stdout: "ignore",
+        stderr: "pipe",
+      });
+
+      let url: URL | undefined;
+      let stderr = "";
+      const decoder = new TextDecoder();
+      for await (const chunk of inspectee.stderr as ReadableStream) {
+        stderr += decoder.decode(chunk);
+        for (const line of stderr.split("\n")) {
+          try {
+            url = new URL(line);
+          } catch {
+            // Ignore
+          }
+          if (url?.protocol.includes("ws")) {
+            break;
+          }
         }
-        if (url?.protocol.includes("ws")) {
+        if (stderr.includes("Listening:")) {
           break;
         }
       }
-      if (stderr.includes("Listening:")) {
-        break;
+
+      if (!url) {
+        process.stderr.write(stderr);
+        throw new Error("Unable to find listening URL");
       }
-    }
 
-    if (!url) {
-      process.stderr.write(stderr);
-      throw new Error("Unable to find listening URL");
-    }
+      const { protocol, hostname, port, pathname } = url;
+      expect({
+        protocol,
+        hostname,
+        port,
+        pathname,
+      }).toMatchObject(expected);
 
-    const { protocol, hostname, port, pathname } = url;
-    expect({
-      protocol,
-      hostname,
-      port,
-      pathname,
-    }).toMatchObject(expected);
+      const webSocket = new WebSocket(url);
+      expect(
+        new Promise<void>((resolve, reject) => {
+          webSocket.addEventListener("open", () => resolve());
+          webSocket.addEventListener("error", cause => reject(new Error("WebSocket error", { cause })));
+          webSocket.addEventListener("close", cause => reject(new Error("WebSocket closed", { cause })));
+        }),
+      ).resolves.toBeUndefined();
 
-    const webSocket = new WebSocket(url);
-    expect(
-      new Promise<void>((resolve, reject) => {
-        webSocket.addEventListener("open", () => resolve());
-        webSocket.addEventListener("error", cause => reject(new Error("WebSocket error", { cause })));
-        webSocket.addEventListener("close", cause => reject(new Error("WebSocket closed", { cause })));
-      }),
-    ).resolves.toBeUndefined();
-
-    webSocket.send(JSON.stringify({ id: 1, method: "Runtime.evaluate", params: { expression: "1 + 1" } }));
-    expect(
-      new Promise(resolve => {
-        webSocket.addEventListener("message", ({ data }) => {
-          resolve(JSON.parse(data.toString()));
-        });
-      }),
-    ).resolves.toMatchObject({
-      id: 1,
-      result: {
+      webSocket.send(JSON.stringify({ id: 1, method: "Runtime.evaluate", params: { expression: "1 + 1" } }));
+      expect(
+        new Promise(resolve => {
+          webSocket.addEventListener("message", ({ data }) => {
+            resolve(JSON.parse(data.toString()));
+          });
+        }),
+      ).resolves.toMatchObject({
+        id: 1,
         result: {
-          type: "number",
-          value: 2,
+          result: {
+            type: "number",
+            value: 2,
+          },
         },
-      },
+      });
+
+      webSocket.close();
+    });
+  }
+
+  // FIXME: Depends on https://github.com/oven-sh/bun/pull/4649
+  test.todo("bun --inspect=ws+unix:///tmp/inspect.sock");
+
+  afterEach(() => {
+    inspectee?.kill();
+  });
+});
+
+describe("unix domain socket without websocket", () => {
+  if (isPosix) {
+    async function runTest(path: string, args: string[], env = bunEnv) {
+      let { promise, resolve, reject } = Promise.withResolvers();
+
+      const framer = new SocketFramer(message => {
+        resolve(JSON.parse(message));
+      });
+
+      let sock;
+
+      using listener = Bun.listen({
+        unix: path,
+        socket: {
+          open: socket => {
+            sock = socket;
+            framer.send(socket, JSON.stringify({ id: 1, method: "Runtime.evaluate", params: { expression: "1 + 1" } }));
+          },
+          data: (socket, bytes) => {
+            framer.onData(socket, bytes);
+          },
+          error: reject,
+        },
+      });
+
+      const inspectee = spawn({
+        cmd: [bunExe(), ...args, join(import.meta.dir, "inspectee.js")],
+        env,
+        stdout: "inherit",
+        stderr: "inherit",
+        stdin: "inherit",
+      });
+      const message = await promise;
+      expect(message).toMatchObject({
+        id: 1,
+        result: {
+          result: { type: "number", value: 2 },
+        },
+      });
+      inspectee.kill();
+      sock?.end?.();
+    }
+
+    test("bun --inspect=unix://", async () => {
+      const path = Math.random().toString(36).substring(2, 15) + ".sock";
+      const url = new URL(`unix://${path}`);
+      await runTest(path, ["--inspect=" + url.href]);
     });
 
-    webSocket.close();
-  });
-}
+    test("bun --inspect=unix:", async () => {
+      const path = Math.random().toString(36).substring(2, 15) + ".sock";
+      await runTest(path, ["--inspect=unix:" + path]);
+    });
 
-// FIXME: Depends on https://github.com/oven-sh/bun/pull/4649
-test.todo("bun --inspect=ws+unix:///tmp/inspect.sock");
+    test("BUN_INSPECT=' unix://' bun --inspect", async () => {
+      const path = Math.random().toString(36).substring(2, 15) + ".sock";
+      await runTest(path, [], { ...bunEnv, BUN_INSPECT: "unix://" + path });
+    });
 
-afterEach(() => {
-  inspectee?.kill();
+    test("BUN_INSPECT='unix:' bun --inspect", async () => {
+      const path = Math.random().toString(36).substring(2, 15) + ".sock";
+      await runTest(path, [], { ...bunEnv, BUN_INSPECT: "unix:" + path });
+    });
+  }
+});
+
+/// TODO: this test is flaky because the inspect may not send all messages before the process exit
+/// we need to implement a way/option so we wait every message from the inspector before exiting
+test.todo("junit reporter", async () => {
+  const path = Math.random().toString(36).substring(2, 15) + ".sock";
+  let reporter: JUnitReporter;
+  let session: InspectorSession;
+
+  const tempdir = tempDirWithFiles("junit-reporter", {
+    "package.json": `
+      {
+        "type": "module",
+        "scripts": {
+          "test": "bun a.test.js"
+        }
+      }
+    `,
+    "a.test.js": `
+      import { test, expect } from "bun:test";
+      test("fail", () => {
+        expect(1).toBe(2);
+      });
+
+      test("success", () => {
+        expect(1).toBe(1);
+      });
+    `,
+  });
+  let { resolve, reject, promise } = Promise.withResolvers();
+  const [socket, subprocess] = await Promise.all([
+    connect(`unix://${path}`, resolve),
+    spawn({
+      cmd: [bunExe(), "--inspect-wait=unix:" + path, "test", join(tempdir, "a.test.js")],
+      env: bunEnv,
+      stdout: "inherit",
+      stderr: "inherit",
+      stdin: "inherit",
+    }),
+  ]);
+
+  const framer = new SocketFramer((message: string) => {
+    session.onMessage(message);
+  });
+
+  session = new InspectorSession();
+  session.socket = socket;
+  session.framer = framer;
+  socket.data = {
+    onData: framer.onData.bind(framer),
+  };
+
+  reporter = new JUnitReporter(session);
+
+  await Promise.all([subprocess.exited, promise]);
+
+  for (const [file, suite] of reporter.testSuites.entries()) {
+    suite.time = 1000 * 5;
+    suite.timestamp = new Date(2024, 11, 17, 15, 37, 38, 935).toISOString();
+  }
+
+  const report = reporter
+    .generateReport()
+    .replaceAll("\r\n", "\n")
+    .replaceAll("\\", "/")
+    .replaceAll(tempdir.replaceAll("\\", "/"), "<dir>")
+    .replaceAll(process.cwd().replaceAll("\\", "/"), "<cwd>")
+    .trim();
+  expect(stripAnsi(report)).toMatchSnapshot();
 });
diff --git a/test/cli/inspect/junit-reporter.ts b/test/cli/inspect/junit-reporter.ts
new file mode 100644
index 0000000000..adf28cf845
--- /dev/null
+++ b/test/cli/inspect/junit-reporter.ts
@@ -0,0 +1,359 @@
+// This is a test app for:
+// - TestReporter.enable
+// - TestReporter.found
+// - TestReporter.start
+// - TestReporter.end
+// - Console.messageAdded
+// - LifecycleReporter.enable
+// - LifecycleReporter.error
+
+const debug = false;
+import { listen, type Socket } from "bun";
+
+import { SocketFramer } from "./socket-framer.ts";
+import type { JSC } from "../../../packages/bun-inspector-protocol/src/protocol/jsc";
+
+interface Message {
+  id?: number;
+  method?: string;
+  params?: any;
+  result?: any;
+}
+
+export class InspectorSession {
+  private messageCallbacks: Map<number, (result: any) => void>;
+  private eventListeners: Map<string, ((params: any) => void)[]>;
+  private nextId: number;
+  framer?: SocketFramer;
+  socket?: Socket<{ onData: (socket: Socket<any>, data: Buffer) => void }>;
+
+  constructor() {
+    this.messageCallbacks = new Map();
+    this.eventListeners = new Map();
+    this.nextId = 1;
+  }
+
+  onMessage(data: string) {
+    if (debug) console.log(data);
+    const message: Message = JSON.parse(data);
+
+    if (message.id && this.messageCallbacks.has(message.id)) {
+      const callback = this.messageCallbacks.get(message.id)!;
+      callback(message.result);
+      this.messageCallbacks.delete(message.id);
+    } else if (message.method && this.eventListeners.has(message.method)) {
+      if (debug) console.log("event", message.method, message.params);
+      const listeners = this.eventListeners.get(message.method)!;
+      for (const listener of listeners) {
+        listener(message.params);
+      }
+    }
+  }
+
+  send(method: string, params: any = {}) {
+    if (!this.framer) throw new Error("Socket not connected");
+    const id = this.nextId++;
+    const message = { id, method, params };
+    this.framer.send(this.socket as any, JSON.stringify(message));
+  }
+
+  addEventListener(method: string, callback: (params: any) => void) {
+    if (!this.eventListeners.has(method)) {
+      this.eventListeners.set(method, []);
+    }
+    this.eventListeners.get(method)!.push(callback);
+  }
+}
+
+interface JUnitTestCase {
+  name: string;
+  classname: string;
+  time: number;
+  failure?: {
+    message: string;
+    type: string;
+    content: string;
+  };
+  systemOut?: string;
+  systemErr?: string;
+}
+
+interface JUnitTestSuite {
+  name: string;
+  tests: number;
+  failures: number;
+  errors: number;
+  skipped: number;
+  time: number;
+  timestamp: string;
+  testCases: JUnitTestCase[];
+}
+
+interface TestInfo {
+  id: number;
+  name: string;
+  file: string;
+  startTime?: number;
+  stdout: string[];
+  stderr: string[];
+}
+
+export class JUnitReporter {
+  private session: InspectorSession;
+  testSuites: Map<string, JUnitTestSuite>;
+  private tests: Map<number, TestInfo>;
+  private currentTest: TestInfo | null = null;
+
+  constructor(session: InspectorSession) {
+    this.session = session;
+    this.testSuites = new Map();
+    this.tests = new Map();
+
+    this.enableDomains();
+    this.setupEventListeners();
+  }
+
+  private async enableDomains() {
+    this.session.send("Inspector.enable");
+    this.session.send("TestReporter.enable");
+    this.session.send("LifecycleReporter.enable");
+    this.session.send("Console.enable");
+    this.session.send("Runtime.enable");
+  }
+
+  private setupEventListeners() {
+    this.session.addEventListener("TestReporter.found", this.handleTestFound.bind(this));
+    this.session.addEventListener("TestReporter.start", this.handleTestStart.bind(this));
+    this.session.addEventListener("TestReporter.end", this.handleTestEnd.bind(this));
+    this.session.addEventListener("Console.messageAdded", this.handleConsoleMessage.bind(this));
+    this.session.addEventListener("LifecycleReporter.error", this.handleException.bind(this));
+  }
+
+  private getOrCreateTestSuite(file: string): JUnitTestSuite {
+    if (!this.testSuites.has(file)) {
+      this.testSuites.set(file, {
+        name: file,
+        tests: 0,
+        failures: 0,
+        errors: 0,
+        skipped: 0,
+        time: 0,
+        timestamp: new Date().toISOString(),
+        testCases: [],
+      });
+    }
+    return this.testSuites.get(file)!;
+  }
+
+  private handleTestFound(params: JSC.TestReporter.FoundEvent) {
+    const file = params.url || "unknown";
+    const suite = this.getOrCreateTestSuite(file);
+    suite.tests++;
+
+    const test: TestInfo = {
+      id: params.id,
+      name: params.name || `Test ${params.id}`,
+      file,
+      stdout: [],
+      stderr: [],
+    };
+    this.tests.set(params.id, test);
+  }
+
+  private handleTestStart(params: JSC.TestReporter.StartEvent) {
+    const test = this.tests.get(params.id);
+    if (test) {
+      test.startTime = Date.now();
+      this.currentTest = test;
+    }
+  }
+
+  private handleTestEnd(params: JSC.TestReporter.EndEvent) {
+    const test = this.tests.get(params.id);
+    if (!test || !test.startTime) return;
+
+    const suite = this.getOrCreateTestSuite(test.file);
+    const testCase: JUnitTestCase = {
+      name: test.name,
+      classname: test.file,
+      time: (Date.now() - test.startTime) / 1000,
+    };
+
+    if (test.stdout.length > 0) {
+      testCase.systemOut = test.stdout.join("\n");
+    }
+
+    if (params.status === "fail") {
+      suite.failures++;
+      testCase.failure = {
+        message: "Test failed",
+        type: "AssertionError",
+        content: test.stderr.join("\n") || "No error details available",
+      };
+      test.stderr = [];
+    } else if (params.status === "skip" || params.status === "todo") {
+      suite.skipped++;
+    }
+
+    if (test.stderr.length > 0) {
+      testCase.systemErr = test.stderr.join("\n");
+    }
+
+    suite.testCases.push(testCase);
+    this.currentTest = null;
+  }
+
+  private handleConsoleMessage(params: any) {
+    if (!this.currentTest) return;
+
+    const message = params.message;
+    const text = message.text || "";
+
+    if (message.level === "error" || message.level === "warning") {
+      this.currentTest.stderr.push(text);
+    } else {
+      this.currentTest.stdout.push(text);
+    }
+  }
+
+  private handleException(params: JSC.LifecycleReporter.ErrorEvent) {
+    if (!this.currentTest) return;
+
+    const error = params;
+    let stackTrace = "";
+    for (let i = 0; i < error.urls.length; i++) {
+      let url = error.urls[i];
+      let line = Number(error.lineColumns[i * 2]);
+      let column = Number(error.lineColumns[i * 2 + 1]);
+
+      if (column > 0 && line > 0) {
+        stackTrace += `  at ${url}:${line}:${column}\n`;
+      } else if (line > 0) {
+        stackTrace += `  at ${url}:${line}\n`;
+      } else {
+        stackTrace += `  at ${url}\n`;
+      }
+    }
+
+    this.currentTest.stderr.push(`${error.name || "Error"}: ${error.message || "Unknown error"}`, "");
+    if (stackTrace) {
+      this.currentTest.stderr.push(stackTrace);
+      this.currentTest.stderr.push("");
+    }
+  }
+
+  generateReport(): string {
+    let xml = '<?xml version="1.0" encoding="UTF-8"?>\n';
+    xml += "<testsuites>\n";
+
+    for (const suite of this.testSuites.values()) {
+      xml += `  <testsuite name="${escapeXml(suite.name)}" `;
+      xml += `tests="${suite.tests}" `;
+      xml += `failures="${suite.failures}" `;
+      xml += `errors="${suite.errors}" `;
+      xml += `skipped="${suite.skipped}" `;
+
+      xml += `timestamp="${suite.timestamp}">\n`;
+
+      for (const testCase of suite.testCases) {
+        xml += `    <testcase classname="${escapeXml(testCase.classname)}" `;
+        xml += `name="${escapeXml(testCase.name)}" `;
+
+        if (testCase.failure) {
+          xml += `      <failure message="${escapeXml(testCase.failure.message)}" `;
+          xml += `type="${escapeXml(testCase.failure.type)}">\n`;
+          xml += `        ${escapeXml(testCase.failure.content)}\n`;
+          xml += "      </failure>\n";
+        }
+
+        if (testCase.systemOut) {
+          xml += `      <system-out>${escapeXml(testCase.systemOut)}</system-out>\n`;
+        }
+
+        if (testCase.systemErr) {
+          xml += `      <system-err>${escapeXml(testCase.systemErr)}</system-err>\n`;
+        }
+
+        xml += "    </testcase>\n";
+      }
+
+      xml += "  </testsuite>\n";
+    }
+
+    xml += "</testsuites>";
+    return xml;
+  }
+}
+
+function escapeXml(str: string): string {
+  return str
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+}
+
+export async function connect(
+  address: string,
+  onClose?: () => void,
+): Promise<Socket<{ onData: (socket: Socket<any>, data: Buffer) => void }>> {
+  const { promise, resolve } = Promise.withResolvers<Socket<{ onData: (socket: Socket<any>, data: Buffer) => void }>>();
+
+  var listener = listen<{ onData: (socket: Socket<any>, data: Buffer) => void }>({
+    unix: address.slice("unix://".length),
+    socket: {
+      open: socket => {
+        listener.stop();
+        socket.ref();
+        resolve(socket);
+      },
+      data(socket, data: Buffer) {
+        socket.data?.onData(socket, data);
+      },
+      error(socket, error) {
+        console.error(error);
+      },
+      close(socket) {
+        if (onClose) {
+          onClose();
+        }
+      },
+    },
+  });
+
+  return await promise;
+}
+
+if (import.meta.main) {
+  // Main execution
+  const address = process.argv[2];
+  if (!address) {
+    throw new Error("Please provide the inspector address as an argument");
+  }
+
+  let reporter: JUnitReporter;
+  let session: InspectorSession;
+
+  const socket = await connect(address);
+  const framer = new SocketFramer((message: string) => {
+    session.onMessage(message);
+  });
+
+  session = new InspectorSession();
+  session.socket = socket;
+  session.framer = framer;
+  socket.data = {
+    onData: framer.onData.bind(framer),
+  };
+
+  reporter = new JUnitReporter(session);
+
+  // Handle process exit
+  process.on("exit", () => {
+    if (reporter) {
+      const report = reporter.generateReport();
+      console.log(report);
+    }
+  });
+}
diff --git a/test/cli/inspect/socket-framer.ts b/test/cli/inspect/socket-framer.ts
new file mode 100644
index 0000000000..fea0908cc5
--- /dev/null
+++ b/test/cli/inspect/socket-framer.ts
@@ -0,0 +1,79 @@
+interface Socket<T = any> {
+  data: T;
+  write(data: string | Buffer): void;
+}
+
+const enum FramerState {
+  WaitingForLength,
+  WaitingForMessage,
+}
+
+let socketFramerMessageLengthBuffer: Buffer;
+export class SocketFramer {
+  private state: FramerState = FramerState.WaitingForLength;
+  private pendingLength: number = 0;
+  private sizeBuffer: Buffer = Buffer.alloc(0);
+  private sizeBufferIndex: number = 0;
+  private bufferedData: Buffer = Buffer.alloc(0);
+
+  constructor(private onMessage: (message: string) => void) {
+    if (!socketFramerMessageLengthBuffer) {
+      socketFramerMessageLengthBuffer = Buffer.alloc(4);
+    }
+    this.reset();
+  }
+
+  reset(): void {
+    this.state = FramerState.WaitingForLength;
+    this.bufferedData = Buffer.alloc(0);
+    this.sizeBufferIndex = 0;
+    this.sizeBuffer = Buffer.alloc(4);
+  }
+
+  send(socket: Socket, data: string): void {
+    socketFramerMessageLengthBuffer.writeUInt32BE(data.length, 0);
+    socket.write(socketFramerMessageLengthBuffer);
+    socket.write(data);
+  }
+
+  onData(socket: Socket, data: Buffer): void {
+    this.bufferedData = this.bufferedData.length > 0 ? Buffer.concat([this.bufferedData, data]) : data;
+
+    let messagesToDeliver: string[] = [];
+
+    while (this.bufferedData.length > 0) {
+      if (this.state === FramerState.WaitingForLength) {
+        if (this.sizeBufferIndex + this.bufferedData.length < 4) {
+          const remainingBytes = Math.min(4 - this.sizeBufferIndex, this.bufferedData.length);
+          this.bufferedData.copy(this.sizeBuffer, this.sizeBufferIndex, 0, remainingBytes);
+          this.sizeBufferIndex += remainingBytes;
+          this.bufferedData = this.bufferedData.slice(remainingBytes);
+          break;
+        }
+
+        const remainingBytes = 4 - this.sizeBufferIndex;
+        this.bufferedData.copy(this.sizeBuffer, this.sizeBufferIndex, 0, remainingBytes);
+        this.pendingLength = this.sizeBuffer.readUInt32BE(0);
+
+        this.state = FramerState.WaitingForMessage;
+        this.sizeBufferIndex = 0;
+        this.bufferedData = this.bufferedData.slice(remainingBytes);
+      }
+
+      if (this.bufferedData.length < this.pendingLength) {
+        break;
+      }
+
+      const message = this.bufferedData.toString("utf-8", 0, this.pendingLength);
+      this.bufferedData = this.bufferedData.slice(this.pendingLength);
+      this.state = FramerState.WaitingForLength;
+      this.pendingLength = 0;
+      this.sizeBufferIndex = 0;
+      messagesToDeliver.push(message);
+    }
+
+    for (const message of messagesToDeliver) {
+      this.onMessage(message);
+    }
+  }
+}
diff --git a/test/cli/install/__snapshots__/bun-install.test.ts.snap b/test/cli/install/__snapshots__/bun-install.test.ts.snap
index 90a7a79e08..bd375763ac 100644
--- a/test/cli/install/__snapshots__/bun-install.test.ts.snap
+++ b/test/cli/install/__snapshots__/bun-install.test.ts.snap
@@ -1,8 +1,7 @@
 // Bun Snapshot v1, https://goo.gl/fbAQLP
 
 exports[`should report error on invalid format for package.json 1`] = `
-"bun install
-1 | foo
+"1 | foo
     ^
 error: Unexpected foo
     at [dir]/package.json:1:1
@@ -11,8 +10,7 @@ ParserError parsing package.json in "[dir]/"
 `;
 
 exports[`should report error on invalid format for dependencies 1`] = `
-"bun install
-1 | {"name":"foo","version":"0.0.1","dependencies":[]}
+"1 | {"name":"foo","version":"0.0.1","dependencies":[]}
                                     ^
 error: dependencies expects a map of specifiers, e.g.
   "dependencies": {
@@ -23,8 +21,7 @@ error: dependencies expects a map of specifiers, e.g.
 `;
 
 exports[`should report error on invalid format for optionalDependencies 1`] = `
-"bun install
-1 | {"name":"foo","version":"0.0.1","optionalDependencies":"bar"}
+"1 | {"name":"foo","version":"0.0.1","optionalDependencies":"bar"}
                                     ^
 error: optionalDependencies expects a map of specifiers, e.g.
   "optionalDependencies": {
@@ -35,8 +32,7 @@ error: optionalDependencies expects a map of specifiers, e.g.
 `;
 
 exports[`should report error on invalid format for workspaces 1`] = `
-"bun install
-1 | {"name":"foo","version":"0.0.1","workspaces":{"packages":{"bar":true}}}
+"1 | {"name":"foo","version":"0.0.1","workspaces":{"packages":{"bar":true}}}
                                     ^
 error: Workspaces expects an array of strings, e.g.
   "workspaces": [
@@ -47,8 +43,7 @@ error: Workspaces expects an array of strings, e.g.
 `;
 
 exports[`should report error on duplicated workspace packages 1`] = `
-"bun install
-1 | {"name":"moo","version":"0.0.3"}
+"1 | {"name":"moo","version":"0.0.3"}
             ^
 error: Workspace name "moo" already exists
     at [dir]/baz/package.json:1:9
diff --git a/test/cli/install/bun-add.test.ts b/test/cli/install/bun-add.test.ts
index 385a14f283..f670bc6827 100644
--- a/test/cli/install/bun-add.test.ts
+++ b/test/cli/install/bun-add.test.ts
@@ -2,8 +2,9 @@ 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,
   dummyAfterEach,
   dummyBeforeAll,
@@ -67,10 +68,10 @@ it("should add existing package", async () => {
   });
   const err = await new Response(stderr).text();
   expect(err).not.toContain("error:");
-  expect(err).toContain("bun add");
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun add v1."),
     "",
     `installed foo@${add_path.replace(/\\/g, "/")}`,
     "",
@@ -111,12 +112,11 @@ it("should reject missing package", async () => {
     env,
   });
   const err = await new Response(stderr).text();
-  expect(err).toContain("bun add");
   expect(err).toContain("error: MissingPackageJSON");
   expect(err).toContain(`note: error occured while resolving file:${add_path}`);
 
   const out = await new Response(stdout).text();
-  expect(out).toBe("");
+  expect(out).toEqual(expect.stringContaining("bun add v1."));
   expect(await exited).toBe(1);
   expect(await file(join(package_dir, "package.json")).text()).toEqual(
     JSON.stringify({
@@ -164,6 +164,7 @@ for (const pathType of ["absolute", "relative"]) {
       expect(err).toContain("Saved lockfile");
       const out = await new Response(stdout).text();
       expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun add v1."),
         "",
         `installed foo@${add_path_rel.replace(/\\/g, "/")}`,
         "",
@@ -201,11 +202,10 @@ it.each(["fileblah://"])("should reject invalid path without segfault: %s", asyn
     env,
   });
   const err = await new Response(stderr).text();
-  expect(err).toContain("bun add");
   expect(err).toContain(`error: unrecognised dependency format: ${dep}`);
 
   const out = await new Response(stdout).text();
-  expect(out).toBe("");
+  expect(out).toEqual(expect.stringContaining("bun add v1."));
   expect(await exited).toBe(1);
   expect(await file(join(package_dir, "package.json")).text()).toEqual(
     JSON.stringify({
@@ -244,7 +244,7 @@ it("should handle semver-like names", async () => {
   });
   const err = await new Response(stderr).text();
   expect(err.split(/\r?\n/)).toContain(`error: GET http://localhost:${port}/1.2.3 - 404`);
-  expect(await new Response(stdout).text()).toBe("");
+  expect(await new Response(stdout).text()).toEqual(expect.stringContaining("bun add v1."));
   expect(await exited).toBe(1);
   expect(urls.sort()).toEqual([`${root_url}/1.2.3`]);
   expect(requested).toBe(1);
@@ -285,7 +285,7 @@ it("should handle @scoped names", async () => {
   });
   const err = await new Response(stderr).text();
   expect(err.split(/\r?\n/)).toContain(`error: GET http://localhost:${port}/@bar%2fbaz - 404`);
-  expect(await new Response(stdout).text()).toBe("");
+  expect(await new Response(stdout).text()).toEqual(expect.stringContaining("bun add v1."));
   expect(await exited).toBe(1);
   expect(urls.sort()).toEqual([`${root_url}/@bar%2fbaz`]);
   expect(requested).toBe(1);
@@ -320,6 +320,7 @@ it("should add dependency with capital letters", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun add v1."),
     "",
     "installed BaR@0.0.2",
     "",
@@ -373,6 +374,7 @@ it("should add exact version with --exact", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun add v1."),
     "",
     "installed BaR@0.0.2",
     "",
@@ -427,6 +429,7 @@ it("should add exact version with install.exact", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun add v1."),
     "",
     "installed BaR@0.0.2",
     "",
@@ -479,6 +482,7 @@ it("should add exact version with -E", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun add v1."),
     "",
     "installed BaR@0.0.2",
     "",
@@ -509,6 +513,93 @@ it("should add exact version with -E", async () => {
   await access(join(package_dir, "bun.lockb"));
 });
 
+it("should add dependency with package.json in it and http tarball", async () => {
+  check_npm_auth_type.check = false;
+  using server = Bun.serve({
+    port: 0,
+    fetch(req) {
+      if (req.headers.get("Authorization")) {
+        return new Response("bad request", { status: 400 });
+      }
+
+      return new Response(Bun.file(join(__dirname, "baz-0.0.3.tgz")));
+    },
+  });
+  const urls: string[] = [];
+  setHandler(
+    dummyRegistry(urls, {
+      "0.0.3": {
+        bin: {
+          "baz-run": "index.js",
+        },
+      },
+      "0.0.5": {
+        bin: {
+          "baz-run": "index.js",
+        },
+      },
+    }),
+  );
+  await writeFile(
+    join(package_dir, "package.json"),
+    JSON.stringify({
+      name: "foo",
+      version: "0.0.1",
+
+      dependencies: {
+        booop: `${server.url.href}/booop-0.0.1.tgz`,
+      },
+    }),
+  );
+  const { stdout, stderr, exited } = spawn({
+    cmd: [bunExe(), "add", "bap@npm:baz@0.0.5"],
+    cwd: package_dir,
+    stdout: "pipe",
+    stdin: "pipe",
+    stderr: "pipe",
+    env: {
+      ...env,
+      "BUN_CONFIG_TOKEN": "npm_******",
+    },
+  });
+  const err = await new Response(stderr).text();
+  expect(err).not.toContain("error:");
+  expect(err).toContain("Saved lockfile");
+  const out = await new Response(stdout).text();
+  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun add v1."),
+    "",
+    expect.stringContaining("+ booop@http://"),
+    "",
+    "installed bap@0.0.5 with binaries:",
+    " - baz-run",
+    "",
+    "2 packages installed",
+  ]);
+  expect(await exited).toBe(0);
+  expect(urls.sort()).toEqual([`${root_url}/baz`, `${root_url}/baz-0.0.5.tgz`]);
+  expect(requested).toBe(2);
+  expect(await readdirSorted(join(package_dir, "node_modules"))).toEqual([".bin", ".cache", "bap", "booop"]);
+  expect(await readdirSorted(join(package_dir, "node_modules", ".bin"))).toHaveBins(["baz-run"]);
+  expect(await readdirSorted(join(package_dir, "node_modules", "bap"))).toEqual(["index.js", "package.json"]);
+  expect(await file(join(package_dir, "node_modules", "bap", "package.json")).json()).toEqual({
+    name: "baz",
+    version: "0.0.5",
+    bin: {
+      "baz-exec": "index.js",
+    },
+  });
+  expect(await file(join(package_dir, "package.json")).json()).toStrictEqual({
+    name: "foo",
+    version: "0.0.1",
+    dependencies: {
+      bap: "npm:baz@0.0.5",
+      booop: `${server.url.href}/booop-0.0.1.tgz`,
+    },
+  });
+  await access(join(package_dir, "bun.lockb"));
+});
+
 it("should add dependency with specified semver", async () => {
   const urls: string[] = [];
   setHandler(
@@ -540,6 +631,7 @@ it("should add dependency with specified semver", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun add v1."),
     "",
     "installed baz@0.0.3 with binaries:",
     " - baz-run",
@@ -599,6 +691,7 @@ it("should add dependency (GitHub)", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun add v1."),
     "",
     "installed uglify-js@github:mishoo/UglifyJS#e219a9a with binaries:",
     " - uglifyjs",
@@ -684,6 +777,7 @@ it("should add dependency alongside workspaces", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun add v1."),
     "",
     "installed baz@0.0.3 with binaries:",
     " - baz-run",
@@ -754,6 +848,7 @@ it("should add aliased dependency (npm)", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun add v1."),
     "",
     "installed bar@0.0.3 with binaries:",
     " - baz-run",
@@ -813,6 +908,7 @@ it("should add aliased dependency (GitHub)", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun add v1."),
     "",
     "installed uglify@github:mishoo/UglifyJS#e219a9a with binaries:",
     " - uglifyjs",
@@ -831,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",
@@ -961,6 +1057,7 @@ it("should let you add the same package twice", async () => {
   expect(err1).toContain("Saved lockfile");
   const out1 = await new Response(stdout1).text();
   expect(out1.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun add v1."),
     "",
     "installed baz@0.0.3",
     "",
@@ -977,7 +1074,6 @@ it("should let you add the same package twice", async () => {
       "baz-run": "index.js",
     },
   });
-  //TODO: fix JSON formatting
   expect(await file(join(package_dir, "package.json")).text()).toEqual(
     JSON.stringify(
       {
@@ -989,7 +1085,7 @@ it("should let you add the same package twice", async () => {
       },
       null,
       2,
-    ).replace(/\r?\n\s*/g, " "),
+    ),
   );
   await access(join(package_dir, "bun.lockb"));
   // re-add as dev
@@ -1010,7 +1106,14 @@ it("should let you add the same package twice", async () => {
   expect(err2).not.toContain("error:");
   expect(err2).toContain("Saved lockfile");
   const out2 = await new Response(stdout2).text();
-  expect(out2.replace(/\[[0-9\.]+m?s\]/, "[]").split(/\r?\n/)).toEqual(["", "installed baz@0.0.3", "", "[] done", ""]);
+  expect(out2.replace(/\[[0-9\.]+m?s\]/, "[]").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun add v1."),
+    "",
+    "installed baz@0.0.3",
+    "",
+    "[] done",
+    "",
+  ]);
   expect(await exited2).toBe(0);
   expect(urls.sort()).toEqual([`${root_url}/baz`]);
   expect(requested).toBe(3);
@@ -1022,7 +1125,6 @@ it("should let you add the same package twice", async () => {
       "baz-run": "index.js",
     },
   });
-  //TODO: fix JSON formatting
   expect(await file(join(package_dir, "package.json")).text()).toEqual(
     JSON.stringify(
       {
@@ -1034,7 +1136,7 @@ it("should let you add the same package twice", async () => {
       },
       null,
       2,
-    ).replace(/\r?\n\s*/g, " "),
+    ),
   );
   await access(join(package_dir, "bun.lockb"));
 });
@@ -1074,6 +1176,7 @@ it("should install version tagged with `latest` by default", async () => {
   expect(err1).not.toContain("error:");
   expect(err1).toContain("Saved lockfile");
   expect(out1.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun add v1."),
     "",
     "installed baz@0.0.3",
     "",
@@ -1124,6 +1227,7 @@ it("should install version tagged with `latest` by default", async () => {
   expect(err2).toContain("Saved lockfile");
   const out2 = await new Response(stdout2).text();
   expect(out2.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ baz@0.0.3",
     "",
@@ -1185,6 +1289,7 @@ it("should handle Git URL in dependencies (SCP-style)", async () => {
   out1 = out1.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "");
   out1 = out1.replace(/(\.git)#[a-f0-9]+/, "$1");
   expect(out1.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun add v1."),
     "",
     "installed uglify-js@git+ssh://bun@github.com:mishoo/UglifyJS.git with binaries:",
     " - uglifyjs",
@@ -1247,6 +1352,7 @@ it("should handle Git URL in dependencies (SCP-style)", async () => {
   expect(err2).not.toContain("Saved lockfile");
   const out2 = await new Response(stdout2).text();
   expect(out2.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "Checked 1 install across 2 packages (no changes)",
   ]);
@@ -1327,6 +1433,7 @@ it("should prefer optionalDependencies over dependencies of the same name", asyn
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun add v1."),
     "",
     "installed bar@0.0.2",
     "",
@@ -1385,6 +1492,7 @@ it("should prefer dependencies over peerDependencies of the same name", async ()
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun add v1."),
     "",
     "installed bar@0.0.2",
     "",
@@ -1441,6 +1549,7 @@ it("should add dependency without duplication", async () => {
   expect(err1).toContain("Saved lockfile");
   const out1 = await new Response(stdout1).text();
   expect(out1.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun add v1."),
     "",
     "installed bar@0.0.2",
     "",
@@ -1492,7 +1601,11 @@ it("should add dependency without duplication", async () => {
   // The meta-hash didn't change, but we do save everytime you do "bun add <package>".
   expect(err2).toContain("Saved lockfile");
 
-  expect(out2.replace(/\s*\[[0-9\.]+m?s\] done\s*$/, "").split(/\r?\n/)).toEqual(["", "installed bar@0.0.2"]);
+  expect(out2.replace(/\s*\[[0-9\.]+m?s\] done\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun add v1."),
+    "",
+    "installed bar@0.0.2",
+  ]);
   expect(await exited2).toBe(0);
   expect(urls.sort()).toBeEmpty();
   expect(requested).toBe(2);
@@ -1543,6 +1656,7 @@ it("should add dependency without duplication (GitHub)", async () => {
   expect(err1).toContain("Saved lockfile");
   const out1 = await new Response(stdout1).text();
   expect(out1.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun add v1."),
     "",
     "installed uglify-js@github:mishoo/UglifyJS#e219a9a with binaries:",
     " - uglifyjs",
@@ -1605,6 +1719,7 @@ it("should add dependency without duplication (GitHub)", async () => {
 
   const out2 = await new Response(stdout2).text();
   expect(out2.replace(/\s*\[[0-9\.]+m?s\] done\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun add v1."),
     "",
     "installed uglify-js@github:mishoo/UglifyJS#e219a9a with binaries:",
     " - uglifyjs",
@@ -1683,6 +1798,7 @@ it("should add dependencies to workspaces directly", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun add v1."),
     "",
     `installed foo@${relative(package_dir, add_dir).replace(/\\/g, "/")}`,
     "",
@@ -1747,10 +1863,10 @@ async function installRedirectsToAdd(saveFlagFirst: boolean) {
   });
   const err = await new Response(stderr).text();
   expect(err).not.toContain("error:");
-  expect(err).toContain("bun add");
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun add v1."),
     "",
     `installed foo@${add_path.replace(/\\/g, "/")}`,
     "",
@@ -1785,6 +1901,7 @@ it("should add dependency alongside peerDependencies", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun add v1."),
     "",
     "installed bar@0.0.2",
     "",
@@ -1833,6 +1950,7 @@ it("should add local tarball dependency", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun add v1."),
     "",
     "installed baz@baz-0.0.3.tgz with binaries:",
     " - baz-run",
diff --git a/test/cli/install/bun-install-retry.test.ts b/test/cli/install/bun-install-retry.test.ts
index 27f3f70522..842691bb0b 100644
--- a/test/cli/install/bun-install-retry.test.ts
+++ b/test/cli/install/bun-install-retry.test.ts
@@ -63,6 +63,7 @@ it("retries on 500", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun add v1."),
     "",
     "installed BaR@0.0.2",
     "",
diff --git a/test/cli/install/bun-install.test.ts b/test/cli/install/bun-install.test.ts
index 591f03fc5c..b6470eba7f 100644
--- a/test/cli/install/bun-install.test.ts
+++ b/test/cli/install/bun-install.test.ts
@@ -11,9 +11,19 @@ import {
   setDefaultTimeout,
   test,
 } from "bun:test";
-import { access, mkdir, readlink, rm, writeFile } from "fs/promises";
-import { bunEnv, bunExe, bunEnv as env, tempDirWithFiles, toBeValidBin, toBeWorkspaceLink, toHaveBins } from "harness";
-import { join, sep } from "path";
+import { access, mkdir, readlink, rm, writeFile, cp, stat } from "fs/promises";
+import {
+  bunEnv,
+  bunExe,
+  bunEnv as env,
+  tempDirWithFiles,
+  toBeValidBin,
+  toBeWorkspaceLink,
+  toHaveBins,
+  runBunInstall,
+  isWindows,
+} from "harness";
+import { join, sep, resolve } from "path";
 import {
   dummyAfterAll,
   dummyAfterEach,
@@ -32,7 +42,6 @@ expect.extend({
   toBeValidBin,
   toHaveBins,
   toHaveWorkspaceLink: async function (package_dir: string, [link, real]: [string, string]) {
-    const isWindows = process.platform === "win32";
     if (!isWindows) {
       return expect(await readlink(join(package_dir, "node_modules", link))).toBeWorkspaceLink(join("..", real));
     } else {
@@ -40,7 +49,6 @@ expect.extend({
     }
   },
   toHaveWorkspaceLink2: async function (package_dir: string, [link, realPosix, realWin]: [string, string, string]) {
-    const isWindows = process.platform === "win32";
     if (!isWindows) {
       return expect(await readlink(join(package_dir, "node_modules", link))).toBeWorkspaceLink(join("..", realPosix));
     } else {
@@ -59,6 +67,136 @@ afterAll(dummyAfterAll);
 beforeEach(dummyBeforeEach);
 afterEach(dummyAfterEach);
 
+for (let input of ["abcdef", "65537", "-1"]) {
+  it(`bun install --network-concurrency=${input} fails`, async () => {
+    const urls: string[] = [];
+    setHandler(dummyRegistry(urls));
+    await writeFile(
+      join(package_dir, "package.json"),
+      `
+{
+  "name": "foo",
+  "version": "0.0.1",
+  "dependencies": {
+    "bar": "^1"
+  }
+}`,
+    );
+    const { stderr, exited } = spawn({
+      cmd: [bunExe(), "install", "--network-concurrency", "abcdef"],
+      cwd: package_dir,
+      stdout: "inherit",
+      stdin: "inherit",
+      stderr: "pipe",
+      env,
+    });
+    const err = await new Response(stderr).text();
+    expect(err).toContain("Expected --network-concurrency to be a number between 0 and 65535");
+    expect(await exited).toBe(1);
+    expect(urls).toBeEmpty();
+  });
+}
+
+it("bun install --network-concurrency=5 doesnt go over 5 concurrent requests", async () => {
+  const urls: string[] = [];
+  let maxConcurrentRequests = 0;
+  let concurrentRequestCounter = 0;
+  let totalRequests = 0;
+  setHandler(async function (request) {
+    concurrentRequestCounter++;
+    totalRequests++;
+    try {
+      await Bun.sleep(10);
+      maxConcurrentRequests = Math.max(maxConcurrentRequests, concurrentRequestCounter);
+
+      if (concurrentRequestCounter > 20) {
+        throw new Error("Too many concurrent requests");
+      }
+    } finally {
+      concurrentRequestCounter--;
+    }
+
+    return new Response("404", { status: 404 });
+  });
+  await writeFile(
+    join(package_dir, "package.json"),
+    `
+{
+  "name": "foo",
+  "version": "0.0.1",
+  "dependencies": {
+    "bar1": "^1",
+    "bar2": "^1",
+    "bar3": "^1",
+    "bar4": "^1",
+    "bar5": "^1",
+    "bar6": "^1",
+    "bar7": "^1",
+    "bar8": "^1",
+    "bar9": "^1",
+    "bar10": "^1",
+    "bar11": "^1",
+    "bar12": "^1",
+    "bar13": "^1",
+    "bar14": "^1",
+    "bar15": "^1",
+    "bar16": "^1",
+    "bar17": "^1",
+    "bar18": "^1",
+    "bar19": "^1",
+    "bar20": "^1",
+    "bar21": "^1",
+    "bar22": "^1",
+    "bar23": "^1",
+    "bar24": "^1",
+    "bar25": "^1",
+    "bar26": "^1",
+    "bar27": "^1",
+    "bar28": "^1",
+    "bar29": "^1",
+    "bar30": "^1",
+    "bar31": "^1",
+    "bar32": "^1",
+    "bar33": "^1",
+    "bar34": "^1",
+    "bar35": "^1",
+    "bar36": "^1",
+    "bar37": "^1",
+    "bar38": "^1",
+    "bar39": "^1",
+    "bar40": "^1",
+    "bar41": "^1",
+    "bar42": "^1",
+    "bar43": "^1",
+    "bar44": "^1",
+    "bar45": "^1",
+    "bar46": "^1",
+    "bar47": "^1",
+    "bar48": "^1",
+    "bar49": "^1",
+    "bar50": "^1",
+    "bar51": "^1",
+  }
+}`,
+  );
+  const { stdout, stderr, exited } = spawn({
+    cmd: [bunExe(), "install", "--network-concurrency", "5"],
+    cwd: package_dir,
+    stdout: "pipe",
+    stdin: "pipe",
+    stderr: "pipe",
+    env,
+  });
+  const err = await new Response(stderr).text();
+  expect(await exited).toBe(1);
+  expect(urls).toBeEmpty();
+  expect(maxConcurrentRequests).toBeLessThanOrEqual(5);
+  expect(totalRequests).toBe(51);
+
+  expect(err).toContain("failed to resolve");
+  expect(await new Response(stdout).text()).toEqual(expect.stringContaining("bun install v1."));
+});
+
 it("should not error when package.json has comments and trailing commas", async () => {
   const urls: string[] = [];
   setHandler(dummyRegistry(urls));
@@ -66,9 +204,7 @@ it("should not error when package.json has comments and trailing commas", async
     join(package_dir, "package.json"),
     `
     {
-      // such comment!
       "name": "foo",
-      /** even multi-line comment!! */
       "version": "0.0.1",
       "dependencies": {
         "bar": "^1",
@@ -86,7 +222,7 @@ it("should not error when package.json has comments and trailing commas", async
   });
   const err = await new Response(stderr).text();
   expect(err).toContain('error: No version matching "^1" found for specifier "bar" (but package exists)');
-  expect(await new Response(stdout).text()).toBeEmpty();
+  expect(await new Response(stdout).text()).toEqual(expect.stringContaining("bun install v1."));
   expect(await exited).toBe(1);
   expect(urls.sort()).toEqual([`${root_url}/bar`]);
   expect(requested).toBe(1);
@@ -145,6 +281,7 @@ describe("chooses", () => {
     expect(err).toContain("Saved lockfile");
     const out = await new Response(stdout).text();
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       `+ baz@${chosen}`,
       "",
@@ -233,7 +370,7 @@ registry = "http://${server.hostname}:${server.port}/"
   });
   const err = await new Response(stderr).text();
   expect(err).toMatch(/error: (ConnectionRefused|ConnectionClosed) downloading package manifest bar/gm);
-  expect(await new Response(stdout).text()).toBeEmpty();
+  expect(await new Response(stdout).text()).toEqual(expect.stringContaining("bun install v1."));
   expect(await exited).toBe(1);
   try {
     await access(join(package_dir, "bun.lockb"));
@@ -292,7 +429,7 @@ registry = "https://badssl.com:bad"
   });
   const err = await new Response(stderr).text();
   expect(err).toMatch(/error: (ConnectionRefused|ConnectionClosed) downloading package manifest bar/gm);
-  expect(await new Response(stdout).text()).toBeEmpty();
+  expect(await new Response(stdout).text()).toEqual(expect.stringContaining("bun install v1."));
   expect(await exited).toBe(1);
   try {
     await access(join(package_dir, "bun.lockb"));
@@ -475,7 +612,7 @@ it("should handle missing package", async () => {
   });
   const err = await new Response(stderr).text();
   expect(err.split(/\r?\n/)).toContain(`error: GET http://localhost:${new URL(root_url).port}/foo - 404`);
-  expect(await new Response(stdout).text()).toBeEmpty();
+  expect(await new Response(stdout).text()).toEqual(expect.stringContaining("bun add v1."));
   expect(await exited).toBe(1);
   expect(urls.sort()).toEqual([`${root_url}/foo`]);
   expect(requested).toBe(1);
@@ -525,7 +662,7 @@ foo = { token = "bar" }
   });
   const err = await new Response(stderr).text();
   expect(err.split(/\r?\n/)).toContain(`error: GET ${url} - 422`);
-  expect(await new Response(stdout).text()).toBeEmpty();
+  expect(await new Response(stdout).text()).toEqual(expect.stringContaining("bun add v1."));
   expect(await exited).toBe(1);
   expect(urls.sort()).toEqual([url]);
   expect(seen_token).toBe(true);
@@ -563,6 +700,7 @@ it("should handle empty string in dependencies", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ bar@0.0.2",
     "",
@@ -640,7 +778,11 @@ it("should handle workspaces", async () => {
   const err1 = await new Response(stderr1).text();
   expect(err1).toContain("Saved lockfile");
   const out1 = await new Response(stdout1).text();
-  expect(out1.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "4 packages installed"]);
+  expect(out1.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
+    "",
+    "4 packages installed",
+  ]);
   expect(await exited1).toBe(0);
   expect(requested).toBe(0);
   expect(await readdirSorted(join(package_dir, "node_modules"))).toEqual([
@@ -674,7 +816,11 @@ it("should handle workspaces", async () => {
   const err2 = await new Response(stderr2).text();
   expect(err2).not.toContain("Saved lockfile");
   const out2 = await new Response(stdout2).text();
-  expect(out2.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "4 packages installed"]);
+  expect(out2.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
+    "",
+    "4 packages installed",
+  ]);
   expect(await exited2).toBe(0);
   expect(requested).toBe(0);
   expect(await readdirSorted(join(package_dir, "node_modules"))).toEqual([
@@ -726,6 +872,7 @@ it("should handle `workspace:` specifier", async () => {
   expect(err1).toContain("Saved lockfile");
   const out1 = await new Response(stdout1).text();
   expect(out1.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     `+ Bar@workspace:path/to/bar`,
     "",
@@ -754,6 +901,7 @@ it("should handle `workspace:` specifier", async () => {
   expect(err2).not.toContain("Saved lockfile");
   const out2 = await new Response(stdout2).text();
   expect(out2.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     `+ Bar@workspace:path/to/bar`,
     "",
@@ -796,7 +944,11 @@ it("should handle workspaces with packages array", async () => {
 
   const out = await new Response(stdout).text();
 
-  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "1 package installed"]);
+  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
+    "",
+    "1 package installed",
+  ]);
   expect(await exited).toBe(0);
   expect(requested).toBe(0);
   expect(await readdirSorted(join(package_dir, "node_modules"))).toEqual([".cache", "Bar"]);
@@ -846,7 +998,11 @@ it("should handle inter-dependency between workspaces", async () => {
   const err = await new Response(stderr).text();
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
-  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "2 packages installed"]);
+  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
+    "",
+    "2 packages installed",
+  ]);
   expect(await exited).toBe(0);
   expect(requested).toBe(0);
   expect(await readdirSorted(join(package_dir, "node_modules"))).toEqual([".cache", "Bar", "Baz"]);
@@ -897,7 +1053,11 @@ it("should handle inter-dependency between workspaces (devDependencies)", async
   const err = await new Response(stderr).text();
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
-  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "2 packages installed"]);
+  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
+    "",
+    "2 packages installed",
+  ]);
   expect(await exited).toBe(0);
   expect(requested).toBe(0);
   expect(await readdirSorted(join(package_dir, "node_modules"))).toEqual([".cache", "Bar", "Baz"]);
@@ -948,7 +1108,11 @@ it("should handle inter-dependency between workspaces (optionalDependencies)", a
   const err = await new Response(stderr).text();
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
-  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "2 packages installed"]);
+  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
+    "",
+    "2 packages installed",
+  ]);
   expect(await exited).toBe(0);
   expect(requested).toBe(0);
   expect(await readdirSorted(join(package_dir, "node_modules"))).toEqual([".cache", "Bar", "Baz"]);
@@ -998,7 +1162,11 @@ it("should ignore peerDependencies within workspaces", async () => {
   const err = await new Response(stderr).text();
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
-  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "1 package installed"]);
+  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
+    "",
+    "1 package installed",
+  ]);
   expect(await exited).toBe(0);
   expect(requested).toBe(0);
   expect(await readdirSorted(join(package_dir, "node_modules"))).toEqual(["Baz"]);
@@ -1036,6 +1204,7 @@ it("should handle installing the same peerDependency with different versions", a
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ peer@0.0.2",
     "+ boba@0.0.2",
@@ -1075,6 +1244,7 @@ it("should handle installing the same peerDependency with the same version", asy
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ boba@0.0.2",
     "",
@@ -1121,7 +1291,11 @@ it("should handle life-cycle scripts within workspaces", async () => {
     env,
   });
   const out = await new Response(stdout).text();
-  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "1 package installed"]);
+  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
+    "",
+    "1 package installed",
+  ]);
   expect(await exited).toBe(0);
   expect(requested).toBe(0);
   expect(await readdirSorted(join(package_dir, "node_modules"))).toEqual([".cache", "Bar"]);
@@ -1181,6 +1355,7 @@ it("should handle life-cycle scripts during re-installation", async () => {
   expect(err1).toContain("Saved lockfile");
   const out1 = await new Response(stdout1).text();
   expect(out1.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ qux@0.0.2",
     "",
@@ -1212,6 +1387,7 @@ it("should handle life-cycle scripts during re-installation", async () => {
   expect(err2).not.toContain("Saved lockfile");
   const out2 = await new Response(stdout2).text();
   expect(out2.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ qux@0.0.2",
     "",
@@ -1243,6 +1419,7 @@ it("should handle life-cycle scripts during re-installation", async () => {
   expect(err3).not.toContain("Saved lockfile");
   const out3 = await new Response(stdout3).text();
   expect(out3.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ qux@0.0.2",
     "",
@@ -1299,7 +1476,11 @@ it("should use updated life-cycle scripts in root during re-installation", async
   expect(err1).not.toContain("error:");
   expect(err1).toContain("Saved lockfile");
   const out1 = await new Response(stdout1).text();
-  expect(out1.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "1 package installed"]);
+  expect(out1.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
+    "",
+    "1 package installed",
+  ]);
   expect(await exited1).toBe(0);
   expect(requested).toBe(0);
   expect(await readdirSorted(join(package_dir, "node_modules"))).toEqual([".cache", "Bar"]);
@@ -1342,7 +1523,11 @@ it("should use updated life-cycle scripts in root during re-installation", async
   expect(err2).not.toContain("error:");
   expect(err2).toContain("Saved lockfile");
   const out2 = await new Response(stdout2).text();
-  expect(out2.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "1 package installed"]);
+  expect(out2.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
+    "",
+    "1 package installed",
+  ]);
   expect(await exited2).toBe(0);
   expect(requested).toBe(0);
   expect(await readdirSorted(join(package_dir, "node_modules"))).toEqual([".cache", "Bar"]);
@@ -1372,7 +1557,11 @@ it("should use updated life-cycle scripts in root during re-installation", async
   expect(err3).not.toContain("Saved lockfile");
 
   const out3 = await new Response(stdout3).text();
-  expect(out3.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "1 package installed"]);
+  expect(out3.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
+    "",
+    "1 package installed",
+  ]);
   expect(await exited3).toBe(0);
   expect(requested).toBe(0);
   expect(await readdirSorted(join(package_dir, "node_modules"))).toEqual([".cache", "Bar"]);
@@ -1425,7 +1614,11 @@ it("should use updated life-cycle scripts in dependency during re-installation",
   expect(err1).not.toContain("error:");
   expect(err1).toContain("Saved lockfile");
   const out1 = await new Response(stdout1).text();
-  expect(out1.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "1 package installed"]);
+  expect(out1.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
+    "",
+    "1 package installed",
+  ]);
   expect(await exited1).toBe(0);
   expect(requested).toBe(0);
   expect(await readdirSorted(join(package_dir, "node_modules"))).toEqual([".cache", "Bar"]);
@@ -1471,7 +1664,11 @@ it("should use updated life-cycle scripts in dependency during re-installation",
   expect(err2).not.toContain("error:");
   expect(err2).toContain("Saved lockfile");
   const out2 = await new Response(stdout2).text();
-  expect(out2.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "1 package installed"]);
+  expect(out2.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
+    "",
+    "1 package installed",
+  ]);
   expect(await exited2).toBe(0);
   expect(requested).toBe(0);
   expect(await readdirSorted(join(package_dir, "node_modules"))).toEqual([".cache", "Bar"]);
@@ -1503,7 +1700,11 @@ it("should use updated life-cycle scripts in dependency during re-installation",
   expect(err3).not.toContain("error:");
   expect(err3).not.toContain("Saved lockfile");
   const out3 = await new Response(stdout3).text();
-  expect(out3.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "1 package installed"]);
+  expect(out3.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
+    "",
+    "1 package installed",
+  ]);
   expect(await exited3).toBe(0);
   expect(requested).toBe(0);
   expect(await readdirSorted(join(package_dir, "node_modules"))).toEqual([".cache", "Bar"]);
@@ -1543,7 +1744,11 @@ it("should ignore workspaces within workspaces", async () => {
   const err = await new Response(stderr).text();
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
-  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "1 package installed"]);
+  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
+    "",
+    "1 package installed",
+  ]);
   expect(await exited).toBe(0);
   expect(requested).toBe(0);
   expect(await readdirSorted(join(package_dir, "node_modules"))).toEqual([".cache", "bar"]);
@@ -1576,6 +1781,7 @@ it("should handle ^0 in dependencies", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ bar@0.0.2",
     "",
@@ -1616,7 +1822,7 @@ it("should handle ^1 in dependencies", async () => {
   });
   const err = await new Response(stderr).text();
   expect(err).toContain('error: No version matching "^1" found for specifier "bar" (but package exists)');
-  expect(await new Response(stdout).text()).toBeEmpty();
+  expect(await new Response(stdout).text()).toEqual(expect.stringContaining("bun install v1."));
   expect(await exited).toBe(1);
   expect(urls.sort()).toEqual([`${root_url}/bar`]);
   expect(requested).toBe(1);
@@ -1653,6 +1859,7 @@ it("should handle ^0.0 in dependencies", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ bar@0.0.2",
     "",
@@ -1693,7 +1900,7 @@ it("should handle ^0.1 in dependencies", async () => {
   });
   const err = await new Response(stderr).text();
   expect(err).toContain('error: No version matching "^0.1" found for specifier "bar" (but package exists)');
-  expect(await new Response(stdout).text()).toBeEmpty();
+  expect(await new Response(stdout).text()).toEqual(expect.stringContaining("bun install v1."));
   expect(await exited).toBe(1);
   expect(urls.sort()).toEqual([`${root_url}/bar`]);
   expect(requested).toBe(1);
@@ -1728,7 +1935,7 @@ it("should handle ^0.0.0 in dependencies", async () => {
   });
   const err = await new Response(stderr).text();
   expect(err).toContain('error: No version matching "^0.0.0" found for specifier "bar" (but package exists)');
-  expect(await new Response(stdout).text()).toBeEmpty();
+  expect(await new Response(stdout).text()).toEqual(expect.stringContaining("bun install v1."));
   expect(await exited).toBe(1);
   expect(urls.sort()).toEqual([`${root_url}/bar`]);
   expect(requested).toBe(1);
@@ -1766,6 +1973,7 @@ it("should handle ^0.0.2 in dependencies", async () => {
   expect(err).not.toContain("error:");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ bar@0.0.2",
     "",
@@ -1831,7 +2039,11 @@ it("should handle matching workspaces from dependencies", async () => {
   expect(err).not.toContain("error:");
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
-  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "3 packages installed"]);
+  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
+    "",
+    "3 packages installed",
+  ]);
   expect(await exited).toBe(0);
   await access(join(package_dir, "bun.lockb"));
 });
@@ -1953,6 +2165,7 @@ it("should handle ^0.0.2-rc in dependencies", async () => {
   expect(err).not.toContain("error:");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ bar@0.0.2-rc",
     "",
@@ -1996,6 +2209,7 @@ it("should handle ^0.0.2-alpha.3+b4d in dependencies", async () => {
   expect(err).not.toContain("error:");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ bar@0.0.2-alpha.3",
     "",
@@ -2039,6 +2253,7 @@ it("should choose the right version with prereleases", async () => {
   expect(err).not.toContain("error:");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ bar@0.0.2-alpha.3",
     "",
@@ -2082,6 +2297,7 @@ it("should handle ^0.0.2rc1 in dependencies", async () => {
   expect(err).not.toContain("error:");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ bar@0.0.2-rc1",
     "",
@@ -2125,8 +2341,9 @@ it("should handle caret range in dependencies when the registry has prereleased
   expect(err).not.toContain("error:");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
-    "+ bar@6.3.0",
+    expect.stringContaining("+ bar@6.3.0"),
     "",
     "1 package installed",
   ]);
@@ -2181,6 +2398,7 @@ it("should prefer latest-tagged dependency", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ baz@0.0.3",
     "",
@@ -2232,6 +2450,7 @@ it("should install latest with prereleases", async () => {
   expect(err).toContain("Saved lockfile");
   var out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\n/)).toEqual([
+    expect.stringContaining("bun add v1."),
     "",
     "installed baz@1.0.0-0",
     "",
@@ -2263,6 +2482,7 @@ it("should install latest with prereleases", async () => {
   expect(err).toContain("Saved lockfile");
   out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ baz@1.0.0-0",
     "",
@@ -2293,6 +2513,7 @@ it("should install latest with prereleases", async () => {
   expect(err).toContain("Saved lockfile");
   out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ baz@1.0.0-8",
     "",
@@ -2324,6 +2545,7 @@ it("should install latest with prereleases", async () => {
   expect(err).toContain("Saved lockfile");
   out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ baz@1.0.0-0",
     "",
@@ -2366,6 +2588,7 @@ it("should handle dependency aliasing", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ Bar@0.0.3",
     "",
@@ -2421,6 +2644,7 @@ it("should handle dependency aliasing (versioned)", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ Bar@0.0.3",
     "",
@@ -2476,6 +2700,7 @@ it("should handle dependency aliasing (dist-tagged)", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ Bar@0.0.3",
     "",
@@ -2535,6 +2760,7 @@ it("should not reinstall aliased dependencies", async () => {
   expect(err1).toContain("Saved lockfile");
   const out1 = await new Response(stdout1).text();
   expect(out1.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ Bar@0.0.3",
     "",
@@ -2573,6 +2799,7 @@ it("should not reinstall aliased dependencies", async () => {
   expect(err2).not.toContain("Saved lockfile");
   const out2 = await new Response(stdout2).text();
   expect(out2.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "Checked 1 install across 2 packages (no changes)",
   ]);
@@ -2638,6 +2865,7 @@ it("should handle aliased & direct dependency references", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ baz@0.0.3",
     "",
@@ -2716,6 +2944,7 @@ it("should not hoist if name collides with alias", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ bar@0.0.3",
     "",
@@ -2793,6 +3022,7 @@ it("should get npm alias with matching version", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ boba@0.0.5",
     "",
@@ -2845,6 +3075,7 @@ it("should not apply overrides to package name of aliased package", async () =>
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ bar@0.0.3",
     "",
@@ -2889,6 +3120,7 @@ it("should handle unscoped alias on scoped dependency", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ @barn/moo@0.1.0",
     "+ moo@0.1.0",
@@ -2948,6 +3180,7 @@ it("should handle scoped alias on unscoped dependency", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ @baz/bar@0.0.2",
     "+ bar@0.0.2",
@@ -3017,6 +3250,7 @@ it("should handle aliased dependency with existing lockfile", async () => {
   expect(err1).toContain("Saved lockfile");
   const out1 = await new Response(stdout1).text();
   expect(out1.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ moz@0.1.0",
     "",
@@ -3077,6 +3311,7 @@ it("should handle aliased dependency with existing lockfile", async () => {
   expect(err2).not.toContain("Saved lockfile");
   const out2 = await new Response(stdout2).text();
   expect(out2.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ moz@0.1.0",
     "",
@@ -3143,7 +3378,13 @@ it("should handle GitHub URL in dependencies (user/repo)", async () => {
   let out = await new Response(stdout).text();
   out = out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "");
   out = out.replace(/(github:[^#]+)#[a-f0-9]+/, "$1");
-  expect(out.split(/\r?\n/)).toEqual(["", "+ uglify@github:mishoo/UglifyJS", "", "1 package installed"]);
+  expect(out.split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
+    "",
+    "+ uglify@github:mishoo/UglifyJS",
+    "",
+    "1 package installed",
+  ]);
   expect(await exited).toBe(0);
   expect(urls.sort()).toBeEmpty();
   expect(requested).toBe(0);
@@ -3193,6 +3434,7 @@ it("should handle GitHub URL in dependencies (user/repo#commit-id)", async () =>
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ uglify@github:mishoo/UglifyJS#e219a9a",
     "",
@@ -3210,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",
@@ -3258,6 +3500,7 @@ it("should handle GitHub URL in dependencies (user/repo#tag)", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ uglify@github:mishoo/UglifyJS#e219a9a",
     "",
@@ -3275,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",
@@ -3331,6 +3574,7 @@ it("should handle bitbucket git dependencies", async () => {
     expect(err).toContain("Saved lockfile");
     const out = await new Response(stdout).text();
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       `+ public-install-test@git+ssh://${dep}#79265e2d9754c60b60f97cc8d859fb6da073b5d2`,
       "",
@@ -3366,6 +3610,7 @@ it("should handle bitbucket git dependencies", async () => {
     expect(err).toContain("Saved lockfile");
     const out = await new Response(stdout).text();
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun add v1."),
       "",
       `installed publicinstalltest@git+ssh://${dep}#79265e2d9754c60b60f97cc8d859fb6da073b5d2`,
       "",
@@ -3406,6 +3651,7 @@ it("should handle gitlab git dependencies", async () => {
     expect(err).toContain("Saved lockfile");
     const out = await new Response(stdout).text();
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       `+ public-install-test@git+ssh://${dep}#93f3aa4ec9ca8a0bacc010776db48bfcd915c44c`,
       "",
@@ -3441,6 +3687,7 @@ it("should handle gitlab git dependencies", async () => {
     expect(err).toContain("Saved lockfile");
     const out = await new Response(stdout).text();
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun add v1."),
       "",
       `installed public-install-test@git+ssh://${dep}#93f3aa4ec9ca8a0bacc010776db48bfcd915c44c`,
       "",
@@ -3478,6 +3725,7 @@ it("should handle GitHub URL in dependencies (github:user/repo#tag)", async () =
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ uglify@github:mishoo/UglifyJS#e219a9a",
     "",
@@ -3496,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",
@@ -3545,7 +3793,13 @@ it("should handle GitHub URL in dependencies (https://github.com/user/repo.git)"
   let out = await new Response(stdout).text();
   out = out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "");
   out = out.replace(/(github:[^#]+)#[a-f0-9]+/, "$1");
-  expect(out.split(/\r?\n/)).toEqual(["", "+ uglify@github:mishoo/UglifyJS", "", "1 package installed"]);
+  expect(out.split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
+    "",
+    "+ uglify@github:mishoo/UglifyJS",
+    "",
+    "1 package installed",
+  ]);
   expect(await exited).toBe(0);
   expect(urls.sort()).toBeEmpty();
   expect(requested).toBe(0);
@@ -3595,6 +3849,7 @@ it("should handle GitHub URL in dependencies (git://github.com/user/repo.git#com
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ uglify@github:mishoo/UglifyJS#e219a9a",
     "",
@@ -3613,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",
@@ -3662,7 +3917,13 @@ it("should handle GitHub URL in dependencies (git+https://github.com/user/repo.g
   let out = await new Response(stdout).text();
   out = out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "");
   out = out.replace(/(github:[^#]+)#[a-f0-9]+/, "$1");
-  expect(out.split(/\r?\n/)).toEqual(["", "+ uglify@github:mishoo/UglifyJS", "", "1 package installed"]);
+  expect(out.split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
+    "",
+    "+ uglify@github:mishoo/UglifyJS",
+    "",
+    "1 package installed",
+  ]);
   expect(await exited).toBe(0);
   expect(urls.sort()).toBeEmpty();
   expect(requested).toBe(0);
@@ -3714,6 +3975,7 @@ it("should handle GitHub tarball URL in dependencies (https://github.com/user/re
   out = out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "");
   out = out.replace(/(github:[^#]+)#[a-f0-9]+/, "$1");
   expect(out.split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ when@https://github.com/cujojs/when/tarball/1.0.2",
     "",
@@ -3772,6 +4034,7 @@ it("should handle GitHub tarball URL in dependencies (https://github.com/user/re
   out = out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "");
   out = out.replace(/(github:[^#]+)#[a-f0-9]+/, "$1");
   expect(out.split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ when@https://github.com/cujojs/when/tarball/1.0.2",
     "",
@@ -3832,6 +4095,7 @@ it("should treat non-GitHub http(s) URLs as tarballs (https://some.url/path?stuf
   out = out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "");
   out = out.replace(/(github:[^#]+)#[a-f0-9]+/, "$1");
   expect(out.split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ @vercel/turbopack-node@https://gitpkg-fork.vercel.sh/vercel/turbo/crates/turbopack-node/js?turbopack-230922.2",
     "",
@@ -3886,6 +4150,7 @@ cache = false
   expect(err1).toContain("Saved lockfile");
   const out1 = await new Response(stdout1).text();
   expect(out1.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ html-minifier@github:kangax/html-minifier#4beb325",
     "",
@@ -3942,6 +4207,7 @@ cache = false
   expect(err2).not.toContain("Saved lockfile");
   const out2 = await new Response(stdout2).text();
   expect(out2.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ html-minifier@github:kangax/html-minifier#4beb325",
     "",
@@ -4042,6 +4308,7 @@ it("should consider peerDependencies during hoisting", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ baz@0.0.5",
     "",
@@ -4139,6 +4406,7 @@ it("should install peerDependencies when needed", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ baz@0.0.5",
     "",
@@ -4201,6 +4469,7 @@ it("should not regard peerDependencies declarations as duplicates", async () =>
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ bar@0.0.2",
     "",
@@ -4229,9 +4498,9 @@ it("should report error on invalid format for package.json", async () => {
     env,
   });
   const err = await new Response(stderr).text();
-  expect(err.replace(/^bun install v.+\n/, "bun install\n").replaceAll(package_dir + sep, "[dir]/")).toMatchSnapshot();
+  expect(err.replaceAll(package_dir + sep, "[dir]/")).toMatchSnapshot();
   const out = await new Response(stdout).text();
-  expect(out).toEqual("");
+  expect(out).toEqual(expect.stringContaining("bun install v1."));
   expect(await exited).toBe(1);
 });
 
@@ -4253,9 +4522,9 @@ it("should report error on invalid format for dependencies", async () => {
     env,
   });
   const err = await new Response(stderr).text();
-  expect(err.replace(/^bun install v.+\n/, "bun install\n").replaceAll(package_dir + sep, "[dir]/")).toMatchSnapshot();
+  expect(err.replaceAll(package_dir + sep, "[dir]/")).toMatchSnapshot();
   const out = await new Response(stdout).text();
-  expect(out).toEqual("");
+  expect(out).toEqual(expect.stringContaining("bun install v1."));
   expect(await exited).toBe(1);
 });
 
@@ -4278,10 +4547,9 @@ it("should report error on invalid format for optionalDependencies", async () =>
   });
 
   let err = await new Response(stderr).text();
-  err = err.replace(/^bun install v.+\n/, "bun install\n").replaceAll(package_dir + sep, "[dir]/");
+  err = err.replaceAll(package_dir + sep, "[dir]/");
   err = err.substring(0, err.indexOf("\n", err.lastIndexOf("[dir]/package.json:"))).trim();
   expect(err.split("\n")).toEqual([
-    `bun install`,
     `1 | {"name":"foo","version":"0.0.1","optionalDependencies":"bar"}`,
     `                                    ^`,
     `error: optionalDependencies expects a map of specifiers, e.g.`,
@@ -4291,7 +4559,7 @@ it("should report error on invalid format for optionalDependencies", async () =>
     `    at [dir]/package.json:1:33`,
   ]);
   const out = await new Response(stdout).text();
-  expect(out).toEqual("");
+  expect(out).toEqual(expect.stringContaining("bun install v1."));
   expect(await exited).toBe(1);
 });
 
@@ -4315,9 +4583,9 @@ it("should report error on invalid format for workspaces", async () => {
     env,
   });
   const err = await new Response(stderr).text();
-  expect(err.replace(/^bun install v.+\n/, "bun install\n").replaceAll(package_dir + sep, "[dir]/")).toMatchSnapshot();
+  expect(err.replaceAll(package_dir + sep, "[dir]/")).toMatchSnapshot();
   const out = await new Response(stdout).text();
-  expect(out).toEqual("");
+  expect(out).toEqual(expect.stringContaining("bun install v1."));
   expect(await exited).toBe(1);
 });
 
@@ -4355,11 +4623,9 @@ it("should report error on duplicated workspace packages", async () => {
     env,
   });
   let err = await new Response(stderr).text();
-  err = err.replace(/^bun install v.+\n/, "bun install\n");
   err = err.replaceAll(package_dir, "[dir]");
   err = err.replaceAll(sep, "/");
   expect(err.trim().split("\n")).toEqual([
-    `bun install`,
     `1 | {"name":"moo","version":"0.0.3"}`,
     `            ^`,
     `error: Workspace name "moo" already exists`,
@@ -4371,7 +4637,7 @@ it("should report error on duplicated workspace packages", async () => {
     `   at [dir]/bar/package.json:1:9`,
   ]);
   const out = await new Response(stdout).text();
-  expect(out).toEqual("");
+  expect(out).toEqual(expect.stringContaining("bun install v1."));
   expect(await exited).toBe(1);
 });
 
@@ -4402,6 +4668,7 @@ it("should handle Git URL in dependencies", async () => {
   out = out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "");
   out = out.replace(/(\.git)#[a-f0-9]+/, "$1");
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ uglify-js@git+https://git@github.com/mishoo/UglifyJS.git",
     "",
@@ -4462,6 +4729,7 @@ it("should handle Git URL in dependencies (SCP-style)", async () => {
   out = out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "");
   out = out.replace(/(\.git)#[a-f0-9]+/, "$1");
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ uglify@git+ssh://github.com:mishoo/UglifyJS.git",
     "",
@@ -4518,6 +4786,7 @@ it("should handle Git URL with committish in dependencies", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ uglify@git+https://git@github.com/mishoo/UglifyJS.git#e219a9a78a0d2251e4dcbd4bb9034207eb484fe8",
     "",
@@ -4577,7 +4846,7 @@ it("should fail on invalid Git URL", async () => {
   const err = await new Response(stderr).text();
   expect(err.split(/\r?\n/)).toContain('error: "git clone" for "uglify" failed');
   const out = await new Response(stdout).text();
-  expect(out).toBeEmpty();
+  expect(out).toEqual(expect.stringContaining("bun install v1."));
   expect(await exited).toBe(1);
   expect(urls.sort()).toBeEmpty();
   expect(requested).toBe(0);
@@ -4613,7 +4882,7 @@ it("should fail on ssh Git URL if invalid credentials", async () => {
   const err = await new Response(stderr).text();
   expect(err.split(/\r?\n/)).toContain('error: "git clone" for "private-install" failed');
   const out = await new Response(stdout).text();
-  expect(out).toBeEmpty();
+  expect(out).toEqual(expect.stringContaining("bun install v1."));
   expect(await exited).toBe(1);
   expect(urls.sort()).toBeEmpty();
   expect(requested).toBe(0);
@@ -4651,7 +4920,7 @@ it("should fail on Git URL with invalid committish", async () => {
     'error: no commit matching "404-no_such_tag" found for "uglify" (but repository exists)',
   );
   const out = await new Response(stdout).text();
-  expect(out).toBeEmpty();
+  expect(out).toEqual(expect.stringContaining("bun install v1."));
   expect(await exited).toBe(1);
   expect(urls.sort()).toBeEmpty();
   expect(requested).toBe(0);
@@ -4689,6 +4958,7 @@ it("should de-duplicate committish in Git URLs", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ uglify-hash@git+https://git@github.com/mishoo/UglifyJS.git#e219a9a78a0d2251e4dcbd4bb9034207eb484fe8",
     "+ uglify-ver@git+https://git@github.com/mishoo/UglifyJS.git#e219a9a78a0d2251e4dcbd4bb9034207eb484fe8",
@@ -4785,6 +5055,7 @@ cache = false
   expect(err1).toContain("Saved lockfile");
   const out1 = await new Response(stdout1).text();
   expect(out1.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ html-minifier@git+https://git@github.com/kangax/html-minifier#4beb325eb01154a40c0cbebff2e5737bbd7071ab",
     "",
@@ -4841,6 +5112,7 @@ cache = false
   expect(err2).not.toContain("Saved lockfile");
   const out2 = await new Response(stdout2).text();
   expect(out2.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ html-minifier@git+https://git@github.com/kangax/html-minifier#4beb325eb01154a40c0cbebff2e5737bbd7071ab",
     "",
@@ -4914,6 +5186,7 @@ cache = false
   expect(err3).not.toContain("Saved lockfile");
   const out3 = await new Response(stdout3).text();
   expect(out3.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ html-minifier@git+https://git@github.com/kangax/html-minifier#4beb325eb01154a40c0cbebff2e5737bbd7071ab",
     "",
@@ -4986,8 +5259,9 @@ it("should prefer optionalDependencies over dependencies of the same name", asyn
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
-    "+ baz@0.0.3",
+    expect.stringContaining("+ baz@0.0.3"),
     "",
     "1 package installed",
   ]);
@@ -5038,6 +5312,7 @@ it("should prefer dependencies over peerDependencies of the same name", async ()
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ baz@0.0.5",
     "",
@@ -5082,6 +5357,7 @@ it("should handle tarball URL", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     `+ baz@${root_url}/baz-0.0.3.tgz`,
     "",
@@ -5129,6 +5405,7 @@ it("should handle tarball path", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     `+ baz@${join(import.meta.dir, "baz-0.0.3.tgz").replace(/\\/g, "/")}`,
     "",
@@ -5175,6 +5452,7 @@ it("should handle tarball URL with aliasing", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     `+ bar@${root_url}/baz-0.0.3.tgz`,
     "",
@@ -5222,6 +5500,7 @@ it("should handle tarball path with aliasing", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     `+ bar@${join(import.meta.dir, "baz-0.0.3.tgz").replace(/\\/g, "/")}`,
     "",
@@ -5278,9 +5557,10 @@ it("should de-duplicate dependencies alongside tarball URL", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     `+ @barn/moo@${root_url}/moo-0.1.0.tgz`,
-    "+ bar@0.0.2",
+    expect.stringContaining("+ bar@0.0.2"),
     "",
     "3 packages installed",
   ]);
@@ -5360,6 +5640,7 @@ it("should handle tarball URL with existing lockfile", async () => {
   expect(err1).toContain("Saved lockfile");
   const out1 = await new Response(stdout1).text();
   expect(out1.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     `+ @barn/moo@${root_url}/moo-0.1.0.tgz`,
     "",
@@ -5420,6 +5701,7 @@ it("should handle tarball URL with existing lockfile", async () => {
   expect(err2).not.toContain("Saved lockfile");
   const out2 = await new Response(stdout2).text();
   expect(out2.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     `+ @barn/moo@${root_url}/moo-0.1.0.tgz`,
     "",
@@ -5501,6 +5783,7 @@ it("should handle tarball path with existing lockfile", async () => {
   expect(err1).toContain("Saved lockfile");
   const out1 = await new Response(stdout1).text();
   expect(out1.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     `+ @barn/moo@${join(import.meta.dir, "moo-0.1.0.tgz").replace(/\\/g, "/")}`,
     "",
@@ -5560,6 +5843,7 @@ it("should handle tarball path with existing lockfile", async () => {
   expect(err2).not.toContain("Saved lockfile");
   const out2 = await new Response(stdout2).text();
   expect(out2.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     `+ @barn/moo@${join(import.meta.dir, "moo-0.1.0.tgz").replace(/\\/g, "/")}`,
     "",
@@ -5636,6 +5920,7 @@ it("should handle devDependencies from folder", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ moo@moo",
     "",
@@ -5690,6 +5975,7 @@ it("should deduplicate devDependencies from folder", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ bar@0.0.2",
     "+ moo@moo",
@@ -5742,6 +6028,7 @@ it("should install dependencies in root package of workspace", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ bar@0.0.2",
     "",
@@ -5793,6 +6080,7 @@ it("should install dependencies in root package of workspace (*)", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ bar@0.0.2",
     "",
@@ -5843,6 +6131,7 @@ it("should ignore invalid workspaces from parent directory", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ bar@0.0.2",
     "",
@@ -5898,6 +6187,7 @@ it("should handle --cwd", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ bar@0.0.2",
     "",
@@ -6057,13 +6347,14 @@ cache = false
   expect(err1).toContain("Saved lockfile");
   const out1 = await new Response(stdout1).text();
   expect(out1.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    `bun install ${Bun.version_with_sha}`,
     "",
-    "+ conditional-type-checks@1.0.6",
-    "+ prettier@2.8.8",
-    "+ tsd@0.22.0",
-    "+ typescript@5.0.4",
+    expect.stringContaining("+ conditional-type-checks@1.0.6"),
+    expect.stringContaining("+ prettier@2.8.8"),
+    expect.stringContaining("+ tsd@0.22.0"),
+    expect.stringContaining("+ typescript@5.0.4"),
     "",
-    "120 packages installed",
+    "112 packages installed",
   ]);
   expect(await exited1).toBe(0);
   expect(await readdirSorted(package_dir)).toEqual(["bun.lockb", "bunfig.toml", "node_modules", "package.json"]);
@@ -6092,7 +6383,6 @@ cache = false
     "dir-glob",
     "emoji-regex",
     "error-ex",
-    "escape-string-regexp",
     "eslint-formatter-pretty",
     "eslint-rule-docs",
     "fast-glob",
@@ -6197,7 +6487,12 @@ cache = false
   expect(err2).not.toContain("Saved lockfile");
   expect(err2).not.toContain("error:");
   const out2 = await new Response(stdout2).text();
-  expect(out2.replace(/\[[0-9\.]+m?s\]/, "[]").split(/\r?\n/)).toEqual(["", "[] done", ""]);
+  expect(out2.replace(/\[[0-9\.]+m?s\]/, "[]").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
+    "",
+    "[] done",
+    "",
+  ]);
   expect(await exited2).toBe(0);
   expect(await readdirSorted(package_dir)).toEqual(["bun.lockb", "bunfig.toml", "node_modules", "package.json"]);
   expect(await file(join(package_dir, "package.json")).text()).toEqual(foo_package);
@@ -6253,12 +6548,13 @@ it("should handle trustedDependencies", async () => {
   expect(err).not.toContain("error:");
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
-  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+  expect(out.replace(/\s*\[[0-9\.]+m?s\]$/m, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ bar@bar",
     "+ moo@moo",
     "",
-    expect.stringContaining("2 packages installed"),
+    "2 packages installed",
     "",
     "Blocked 3 postinstalls. Run `bun pm untrusted` for details.",
     "",
@@ -6305,6 +6601,7 @@ it("should handle `workspaces:*` and `workspace:*` gracefully", async () => {
   expect(err1).toContain("Saved lockfile");
   const out1 = await new Response(stdout1).text();
   expect(out1.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ bar@workspace:bar",
     "",
@@ -6334,6 +6631,7 @@ it("should handle `workspaces:*` and `workspace:*` gracefully", async () => {
   expect(err2).not.toContain("Saved lockfile");
   const out2 = await new Response(stdout2).text();
   expect(out2.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ bar@workspace:bar",
     "",
@@ -6376,6 +6674,7 @@ it("should handle `workspaces:bar` and `workspace:*` gracefully", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ bar@workspace:bar",
     "",
@@ -6418,6 +6717,7 @@ it("should handle `workspaces:*` and `workspace:bar` gracefully", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ bar@workspace:bar",
     "",
@@ -6460,6 +6760,7 @@ it("should handle `workspaces:bar` and `workspace:bar` gracefully", async () =>
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ bar@workspace:bar",
     "",
@@ -6513,6 +6814,7 @@ it("should handle installing packages from inside a workspace with `*`", async (
   expect(err1).toContain("Saved lockfile");
   const out1 = await new Response(stdout1).text();
   expect(out1.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     `+ swag@workspace:packages/swag`,
     "",
@@ -6591,6 +6893,7 @@ it("should handle installing packages from inside a workspace without prefix", a
   expect(err1).toContain("Saved lockfile");
   const out1 = await new Response(stdout1).text();
   expect(out1.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     `+ p2@workspace:packages/p2`,
     "",
@@ -6674,9 +6977,8 @@ it("should handle installing workspaces with more complicated globs", async () =
     stdout
       .toString()
       .replace(/\s*\[[0-9\.]+m?s\]\s*$/, "")
-      .split(/\r?\n/)
-      .sort(),
-  ).toEqual(["", "4 packages installed"].sort());
+      .split(/\r?\n/),
+  ).toEqual([expect.stringContaining("bun install v1."), "", "4 packages installed"]);
 });
 
 it("should handle installing workspaces with multiple glob patterns", async () => {
@@ -6738,9 +7040,8 @@ it("should handle installing workspaces with multiple glob patterns", async () =
     stdout
       .toString()
       .replace(/\s*\[[0-9\.]+m?s\]\s*$/, "")
-      .split(/\r?\n/)
-      .sort(),
-  ).toEqual(["", "4 packages installed"].sort());
+      .split(/\r?\n/),
+  ).toEqual([expect.stringContaining("bun install v1."), "", "4 packages installed"]);
 });
 
 it.todo("should handle installing workspaces with absolute glob patterns", async () => {
@@ -6798,9 +7099,8 @@ it.todo("should handle installing workspaces with absolute glob patterns", async
     stdout
       .toString()
       .replace(/\s*\[[0-9\.]+m?s\]\s*$/, "")
-      .split(/\r?\n/)
-      .sort(),
-  ).toEqual(["", "4 packages installed"].sort());
+      .split(/\r?\n/),
+  ).toEqual([expect.stringContaining("bun install v1."), "", "4 packages installed"]);
 });
 
 it("should handle installing packages inside workspaces with difference versions", async () => {
@@ -6941,6 +7241,7 @@ it("should handle installing packages inside workspaces with difference versions
     expect(err1).toContain("Saved lockfile");
     const out1 = await new Response(stdout1).text();
     expect(out1.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       `+ package1@workspace:packages/package1`,
       "",
@@ -6991,6 +7292,7 @@ it("should handle installing packages inside workspaces with difference versions
     expect(err2).toContain("Saved lockfile");
     const out2 = await new Response(stdout2).text();
     expect(out2.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       `+ package1@workspace:packages/package1`,
       "",
@@ -7036,6 +7338,7 @@ it("should handle installing packages inside workspaces with difference versions
     expect(err3).toContain("Saved lockfile");
     const out3 = await new Response(stdout3).text();
     expect(out3.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       `+ package1@workspace:packages/package1`,
       "",
@@ -7081,6 +7384,7 @@ it("should handle installing packages inside workspaces with difference versions
     expect(err4).toContain("Saved lockfile");
     const out4 = await new Response(stdout4).text();
     expect(out4.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       `+ package1@workspace:packages/package1`,
       "",
@@ -7126,7 +7430,11 @@ it("should handle installing packages inside workspaces with difference versions
     const err5 = await new Response(stderr5).text();
     expect(err5).toContain("Saved lockfile");
     const out5 = await new Response(stdout5).text();
-    expect(out5.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "6 packages installed"]);
+    expect(out5.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
+      "",
+      "6 packages installed",
+    ]);
     expect(await exited5).toBe(0);
 
     const {
@@ -7185,6 +7493,7 @@ it("should override npm dependency by matching workspace", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ bar@workspace:bar",
     "",
@@ -7230,6 +7539,7 @@ it("should not override npm dependency by workspace with mismatched version", as
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ bar@0.0.2",
     "",
@@ -7271,6 +7581,7 @@ it("should override @scoped npm dependency by matching workspace", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     `+ @bar/baz@workspace:packages/bar-baz`,
     "",
@@ -7319,6 +7630,7 @@ it("should override aliased npm dependency by matching workspace", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ bar@workspace:baz",
     "",
@@ -7371,7 +7683,11 @@ it("should override child npm dependency by matching workspace", async () => {
   const err = await new Response(stderr).text();
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
-  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "2 packages installed"]);
+  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
+    "",
+    "2 packages installed",
+  ]);
   expect(await exited).toBe(0);
   expect(urls.sort()).toBeEmpty();
   expect(requested).toBe(0);
@@ -7421,7 +7737,11 @@ it("should not override child npm dependency by workspace with mismatched versio
   const err = await new Response(stderr).text();
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
-  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "3 packages installed"]);
+  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
+    "",
+    "3 packages installed",
+  ]);
   expect(await exited).toBe(0);
   expect(urls.sort()).toEqual([`${root_url}/bar`, `${root_url}/bar-0.0.2.tgz`]);
   expect(requested).toBe(2);
@@ -7477,7 +7797,11 @@ it("should override @scoped child npm dependency by matching workspace", async (
   const err = await new Response(stderr).text();
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
-  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "2 packages installed"]);
+  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
+    "",
+    "2 packages installed",
+  ]);
   expect(await exited).toBe(0);
   expect(urls.sort()).toBeEmpty();
   expect(requested).toBe(0);
@@ -7532,7 +7856,11 @@ it("should override aliased child npm dependency by matching workspace", async (
   const err = await new Response(stderr).text();
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
-  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "2 packages installed"]);
+  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
+    "",
+    "2 packages installed",
+  ]);
   expect(await exited).toBe(0);
   expect(urls.sort()).toBeEmpty();
   expect(requested).toBe(0);
@@ -7586,7 +7914,11 @@ it("should handle `workspace:` with semver range", async () => {
   const err = await new Response(stderr).text();
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
-  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "2 packages installed"]);
+  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
+    "",
+    "2 packages installed",
+  ]);
   expect(await exited).toBe(0);
   expect(urls.sort()).toBeEmpty();
   expect(requested).toBe(0);
@@ -7635,7 +7967,11 @@ it("should handle `workspace:` with alias & @scope", async () => {
   const err = await new Response(stderr).text();
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
-  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "2 packages installed"]);
+  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
+    "",
+    "2 packages installed",
+  ]);
   expect(await exited).toBe(0);
   expect(urls.sort()).toBeEmpty();
   expect(requested).toBe(0);
@@ -7701,6 +8037,7 @@ it("should handle `workspace:*` on both root & child", async () => {
   expect(err1).toContain("Saved lockfile");
   const out1 = await new Response(stdout1).text();
   expect(out1.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     `+ bar@workspace:packages/bar`,
     "",
@@ -7736,6 +8073,7 @@ it("should handle `workspace:*` on both root & child", async () => {
   expect(err2).not.toContain("Saved lockfile");
   const out2 = await new Response(stdout2).text();
   expect(out2.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     `+ bar@workspace:packages/bar`,
     "",
@@ -7778,6 +8116,7 @@ it("should install peer dependencies from root package", async () => {
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ bar@0.0.2",
     "",
@@ -7822,8 +8161,9 @@ it("should install correct version of peer dependency from root package", async
   expect(err).toContain("Saved lockfile");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
-    "+ baz@0.0.3",
+    expect.stringContaining("+ baz@0.0.3"),
     "",
     "1 package installed",
   ]);
@@ -7889,7 +8229,7 @@ describe("Registry URLs", () => {
           stderr: "pipe",
           env,
         });
-        expect(await new Response(stdout).text()).toBeEmpty();
+        expect(await new Response(stdout).text()).toEqual(expect.stringContaining("bun install v1."));
 
         const err = await new Response(stderr).text();
 
@@ -7980,6 +8320,27 @@ describe("Registry URLs", () => {
   });
 });
 
+it("should ensure read permissions of all extracted files", async () => {
+  await Promise.all([
+    cp(join(import.meta.dir, "pkg-only-owner-2.2.2.tgz"), join(package_dir, "pkg-only-owner-2.2.2.tgz")),
+    writeFile(
+      join(package_dir, "package.json"),
+      JSON.stringify({
+        name: "foo",
+        version: "0.0.1",
+        dependencies: {
+          "pkg-only-owner": "file:pkg-only-owner-2.2.2.tgz",
+        },
+      }),
+    ),
+  ]);
+
+  await runBunInstall(env, package_dir);
+
+  expect((await stat(join(package_dir, "node_modules", "pkg-only-owner", "package.json"))).mode & 0o444).toBe(0o444);
+  expect((await stat(join(package_dir, "node_modules", "pkg-only-owner", "src", "index.js"))).mode & 0o444).toBe(0o444);
+});
+
 it("should handle @scoped name that contains tilde, issue#7045", async () => {
   await writeFile(
     join(package_dir, "bunfig.toml"),
diff --git a/test/cli/install/bun-link.test.ts b/test/cli/install/bun-link.test.ts
index 713088fe04..8cdeaa4413 100644
--- a/test/cli/install/bun-link.test.ts
+++ b/test/cli/install/bun-link.test.ts
@@ -56,8 +56,12 @@ it("should link and unlink workspace package", async () => {
     }),
   );
   let { out, err } = await runBunInstall(env, link_dir);
-  expect(err.replace(/^(.*?) v[^\n]+/, "$1").split(/\r?\n/)).toEqual(["bun install", "Saved lockfile", ""]);
-  expect(out.replace(/\s*\[[0-9\.]+ms\]\s*$/, "").split(/\r?\n/)).toEqual(["", "2 packages installed"]);
+  expect(err.split(/\r?\n/)).toEqual(["Saved lockfile", ""]);
+  expect(out.replace(/\s*\[[0-9\.]+ms\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
+    "",
+    "2 packages installed",
+  ]);
 
   let { stdout, stderr, exited } = spawn({
     cmd: [bunExe(), "link"],
@@ -69,7 +73,7 @@ it("should link and unlink workspace package", async () => {
   });
 
   err = await new Response(stderr).text();
-  expect(err.replace(/^(.*?) v[^\n]+/, "$1").split(/\r?\n/)).toEqual(["bun link", ""]);
+  expect(err.split(/\r?\n/)).toEqual([""]);
   expect(await new Response(stdout).text()).toContain(`Success! Registered "moo"`);
   expect(await exited).toBe(0);
 
@@ -83,8 +87,9 @@ it("should link and unlink workspace package", async () => {
   }));
 
   err = await new Response(stderr).text();
-  expect(err.replace(/^(.*?) v[^\n]+/, "$1").split(/\r?\n/)).toEqual(["bun link", ""]);
+  expect(err.split(/\r?\n/)).toEqual([""]);
   expect((await new Response(stdout).text()).replace(/\s*\[[0-9\.]+ms\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun link v1."),
     "",
     `installed moo@link:moo`,
     "",
@@ -106,7 +111,7 @@ it("should link and unlink workspace package", async () => {
   }));
 
   err = await new Response(stderr).text();
-  expect(err.replace(/^(.*?) v[^\n]+/, "$1").split(/\r?\n/)).toEqual(["bun unlink", ""]);
+  expect(err.split(/\r?\n/)).toEqual([""]);
   expect(await new Response(stdout).text()).toContain(`success: unlinked package "moo"`);
   expect(await exited).toBe(0);
 
@@ -121,7 +126,7 @@ it("should link and unlink workspace package", async () => {
   }));
 
   err = await new Response(stderr).text();
-  expect(err.replace(/^(.*?) v[^\n]+/, "$1").split(/\r?\n/)).toEqual(["bun link", ""]);
+  expect(err.split(/\r?\n/)).toEqual([""]);
   expect(await new Response(stdout).text()).toContain(`Success! Registered "foo"`);
   expect(await exited).toBe(0);
 
@@ -135,8 +140,9 @@ it("should link and unlink workspace package", async () => {
   }));
 
   err = await new Response(stderr).text();
-  expect(err.replace(/^(.*?) v[^\n]+/, "$1").split(/\r?\n/)).toEqual(["bun link", ""]);
+  expect(err.split(/\r?\n/)).toEqual([""]);
   expect((await new Response(stdout).text()).replace(/\s*\[[0-9\.]+ms\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun link v1."),
     "",
     `installed foo@link:foo`,
     "",
@@ -159,7 +165,7 @@ it("should link and unlink workspace package", async () => {
   }));
 
   err = await new Response(stderr).text();
-  expect(err.replace(/^(.*?) v[^\n]+/, "$1").split(/\r?\n/)).toEqual(["bun unlink", ""]);
+  expect(err.split(/\r?\n/)).toEqual([""]);
   expect(await new Response(stdout).text()).toContain(`success: unlinked package "foo"`);
   expect(await exited).toBe(0);
 });
@@ -194,7 +200,7 @@ it("should link package", async () => {
     env,
   });
   const err1 = await new Response(stderr1).text();
-  expect(err1.replace(/^(.*?) v[^\n]+/, "$1").split(/\r?\n/)).toEqual(["bun link", ""]);
+  expect(err1.split(/\r?\n/)).toEqual([""]);
   expect(await new Response(stdout1).text()).toContain(`Success! Registered "${link_name}"`);
   expect(await exited1).toBe(0);
 
@@ -211,9 +217,10 @@ it("should link package", async () => {
     env,
   });
   const err2 = await new Response(stderr2).text();
-  expect(err2.replace(/^(.*?) v[^\n]+/, "$1").split(/\r?\n/)).toEqual(["bun link", ""]);
+  expect(err2.split(/\r?\n/)).toEqual([""]);
   const out2 = await new Response(stdout2).text();
   expect(out2.replace(/\s*\[[0-9\.]+ms\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun link v1."),
     "",
     `installed ${link_name}@link:${link_name}`,
     "",
@@ -234,7 +241,7 @@ it("should link package", async () => {
     env,
   });
   const err3 = await new Response(stderr3).text();
-  expect(err3.replace(/^(.*?) v[^\n]+/, "$1").split(/\r?\n/)).toEqual(["bun unlink", ""]);
+  expect(err3.split(/\r?\n/)).toEqual([""]);
   expect(await new Response(stdout3).text()).toContain(`success: unlinked package "${link_name}"`);
   expect(await exited3).toBe(0);
 
@@ -252,7 +259,7 @@ it("should link package", async () => {
   });
   const err4 = await new Response(stderr4).text();
   expect(err4).toContain(`error: Package "${link_name}" is not linked`);
-  expect(await new Response(stdout4).text()).toBe("");
+  expect(await new Response(stdout4).text()).toEqual(expect.stringContaining("bun link v1."));
   expect(await exited4).toBe(1);
 });
 
@@ -286,7 +293,7 @@ it("should link scoped package", async () => {
     env,
   });
   const err1 = await new Response(stderr1).text();
-  expect(err1.replace(/^(.*?) v[^\n]+/, "$1").split(/\r?\n/)).toEqual(["bun link", ""]);
+  expect(err1.split(/\r?\n/)).toEqual([""]);
   expect(await new Response(stdout1).text()).toContain(`Success! Registered "${link_name}"`);
   expect(await exited1).toBe(0);
 
@@ -303,9 +310,10 @@ it("should link scoped package", async () => {
     env,
   });
   const err2 = await new Response(stderr2).text();
-  expect(err2.replace(/^(.*?) v[^\n]+/, "$1").split(/\r?\n/)).toEqual(["bun link", ""]);
+  expect(err2.split(/\r?\n/)).toEqual([""]);
   const out2 = await new Response(stdout2).text();
   expect(out2.replace(/\s*\[[0-9\.]+ms\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun link v1."),
     "",
     `installed ${link_name}@link:${link_name}`,
     "",
@@ -326,7 +334,7 @@ it("should link scoped package", async () => {
     env,
   });
   const err3 = await new Response(stderr3).text();
-  expect(err3.replace(/^(.*?) v[^\n]+/, "$1").split(/\r?\n/)).toEqual(["bun unlink", ""]);
+  expect(err3.split(/\r?\n/)).toEqual([""]);
   expect(await new Response(stdout3).text()).toContain(`success: unlinked package "${link_name}"`);
   expect(await exited3).toBe(0);
 
@@ -344,7 +352,7 @@ it("should link scoped package", async () => {
   });
   const err4 = await new Response(stderr4).text();
   expect(err4).toContain(`error: Package "${link_name}" is not linked`);
-  expect(await new Response(stdout4).text()).toBe("");
+  expect((await new Response(stdout4).text()).split(/\r?\n/)).toEqual([expect.stringContaining("bun link v1."), ""]);
   expect(await exited4).toBe(1);
 });
 
@@ -385,26 +393,16 @@ it("should link dependency without crashing", async () => {
     env,
   });
   const err1 = await new Response(stderr1).text();
-  expect(err1.replace(/^(.*?) v[^\n]+/, "$1").split(/\r?\n/)).toEqual(["bun link", ""]);
+  expect(err1.split(/\r?\n/)).toEqual([""]);
   expect(await new Response(stdout1).text()).toContain(`Success! Registered "${link_name}"`);
   expect(await exited1).toBe(0);
 
-  const {
-    stdout: stdout2,
-    stderr: stderr2,
-    exited: exited2,
-  } = spawn({
-    cmd: [bunExe(), "install"],
-    cwd: package_dir,
-    stdout: "pipe",
-    stdin: "pipe",
-    stderr: "pipe",
-    env,
-  });
+  const { out: stdout2, err: stderr2, exited: exited2 } = await runBunInstall(env, package_dir);
   const err2 = await new Response(stderr2).text();
-  expect(err2.replace(/^(.*?) v[^\n]+/, "$1").split(/\r?\n/)).toEqual(["bun install", "Saved lockfile", ""]);
+  expect(err2.split(/\r?\n/)).toEqual(["Saved lockfile", ""]);
   const out2 = await new Response(stdout2).text();
   expect(out2.replace(/\s*\[[0-9\.]+ms\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     `+ ${link_name}@link:${link_name}`,
     "",
@@ -432,7 +430,7 @@ it("should link dependency without crashing", async () => {
     env,
   });
   const err3 = await new Response(stderr3).text();
-  expect(err3.replace(/^(.*?) v[^\n]+/, "$1").split(/\r?\n/)).toEqual(["bun unlink", ""]);
+  expect(err3.split(/\r?\n/)).toEqual([""]);
   expect(await new Response(stdout3).text()).toContain(`success: unlinked package "${link_name}"`);
   expect(await exited3).toBe(0);
 
@@ -452,6 +450,7 @@ it("should link dependency without crashing", async () => {
   expect(err4).toContain(`error: FileNotFound installing ${link_name}`);
   const out4 = await new Response(stdout4).text();
   expect(out4.replace(/\[[0-9\.]+m?s\]/, "[]").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "Failed to install 1 package",
     "[] done",
diff --git a/test/cli/install/bun-pack.test.ts b/test/cli/install/bun-pack.test.ts
index f9aa414179..37b3d09563 100644
--- a/test/cli/install/bun-pack.test.ts
+++ b/test/cli/install/bun-pack.test.ts
@@ -2,7 +2,7 @@ import { file, spawn, write } from "bun";
 import { readTarball } from "bun:internal-for-testing";
 import { beforeEach, describe, expect, test } from "bun:test";
 import { exists, mkdir, rm } from "fs/promises";
-import { bunEnv, bunExe, isWindows, runBunInstall, tmpdirSync } from "harness";
+import { bunEnv, bunExe, runBunInstall, tmpdirSync, pack } from "harness";
 import { join } from "path";
 
 var packageDir: string;
@@ -11,30 +11,6 @@ beforeEach(() => {
   packageDir = tmpdirSync();
 });
 
-async function pack(cwd: string, env: NodeJS.ProcessEnv, ...args: string[]) {
-  const { stdout, stderr, exited } = spawn({
-    cmd: [bunExe(), "pm", "pack", ...args],
-    cwd,
-    stdout: "pipe",
-    stderr: "pipe",
-    stdin: "ignore",
-    env,
-  });
-
-  const err = await Bun.readableStreamToText(stderr);
-  expect(err).not.toContain("error:");
-  expect(err).not.toContain("warning:");
-  expect(err).not.toContain("failed");
-  expect(err).not.toContain("panic:");
-
-  const out = await Bun.readableStreamToText(stdout);
-
-  const exitCode = await exited;
-  expect(exitCode).toBe(0);
-
-  return { out, err };
-}
-
 async function packExpectError(cwd: string, env: NodeJS.ProcessEnv, ...args: string[]) {
   const { stdout, stderr, exited } = spawn({
     cmd: [bunExe(), "pm", "pack", ...args],
@@ -534,7 +510,6 @@ describe("workspaces", () => {
       'error: Failed to resolve workspace version for "pkg1" in `dependencies`. Run `bun install` and try again.',
     );
 
-    await rm(join(packageDir, "pack-workspace-protocol-fail-2.2.3.tgz"));
     await runBunInstall(bunEnv, packageDir);
     await pack(packageDir, bunEnv);
     const tarball = readTarball(join(packageDir, "pack-workspace-protocol-fail-2.2.3.tgz"));
@@ -974,11 +949,7 @@ describe("bins", () => {
     ]);
 
     expect(tarball.entries[0].perm & 0o644).toBe(0o644);
-    if (isWindows) {
-      expect(tarball.entries[1].perm & 0o111).toBe(0);
-    } else {
-      expect(tarball.entries[1].perm & (0o644 | 0o111)).toBe(0o644 | 0o111);
-    }
+    expect(tarball.entries[1].perm & (0o644 | 0o111)).toBe(0o644 | 0o111);
   });
 
   test("directory", async () => {
@@ -1013,13 +984,8 @@ describe("bins", () => {
     ]);
 
     expect(tarball.entries[0].perm & 0o644).toBe(0o644);
-    if (isWindows) {
-      expect(tarball.entries[1].perm & 0o111).toBe(0);
-      expect(tarball.entries[2].perm & 0o111).toBe(0);
-    } else {
-      expect(tarball.entries[1].perm & (0o644 | 0o111)).toBe(0o644 | 0o111);
-      expect(tarball.entries[2].perm & (0o644 | 0o111)).toBe(0o644 | 0o111);
-    }
+    expect(tarball.entries[1].perm & (0o644 | 0o111)).toBe(0o644 | 0o111);
+    expect(tarball.entries[2].perm & (0o644 | 0o111)).toBe(0o644 | 0o111);
   });
 });
 
@@ -1039,3 +1005,65 @@ test("unicode", async () => {
   const tarball = readTarball(join(packageDir, "pack-unicode-1.1.1.tgz"));
   expect(tarball.entries).toMatchObject([{ "pathname": "package/package.json" }, { "pathname": "package/äöüščří.js" }]);
 });
+
+test("$npm_command is accurate", async () => {
+  await write(
+    join(packageDir, "package.json"),
+    JSON.stringify({
+      name: "pack-command",
+      version: "1.1.1",
+      scripts: {
+        postpack: "echo $npm_command",
+      },
+    }),
+  );
+  const p = await pack(packageDir, bunEnv);
+  expect(p.out.split("\n")).toEqual([
+    `bun pack ${Bun.version_with_sha}`,
+    ``,
+    `packed 94B package.json`,
+    ``,
+    `pack-command-1.1.1.tgz`,
+    ``,
+    `Total files: 1`,
+    expect.stringContaining(`Shasum: `),
+    expect.stringContaining(`Integrity: sha512-`),
+    `Unpacked size: 94B`,
+    expect.stringContaining(`Packed size: `),
+    ``,
+    `pack`,
+    ``,
+  ]);
+  expect(p.err).toEqual(`$ echo $npm_command\n`);
+});
+
+test("$npm_lifecycle_event is accurate", async () => {
+  await write(
+    join(packageDir, "package.json"),
+    JSON.stringify({
+      name: "pack-lifecycle",
+      version: "1.1.1",
+      scripts: {
+        postpack: "echo $npm_lifecycle_event",
+      },
+    }),
+  );
+  const p = await pack(packageDir, bunEnv);
+  expect(p.out.split("\n")).toEqual([
+    `bun pack ${Bun.version_with_sha}`,
+    ``,
+    `packed 104B package.json`,
+    ``,
+    `pack-lifecycle-1.1.1.tgz`,
+    ``,
+    `Total files: 1`,
+    expect.stringContaining(`Shasum: `),
+    expect.stringContaining(`Integrity: sha512-`),
+    `Unpacked size: 104B`,
+    expect.stringContaining(`Packed size: `),
+    ``,
+    `postpack`,
+    ``,
+  ]);
+  expect(p.err).toEqual(`$ echo $npm_lifecycle_event\n`);
+});
diff --git a/test/cli/install/bun-remove.test.ts b/test/cli/install/bun-remove.test.ts
index c7ae73618d..c6e272cd1e 100644
--- a/test/cli/install/bun-remove.test.ts
+++ b/test/cli/install/bun-remove.test.ts
@@ -98,6 +98,7 @@ it("should remove existing package", async () => {
   const err1 = await new Response(stderr1).text();
 
   expect(out1.replace(/\s*\[[0-9\.]+m?s\]/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun remove v1."),
     "",
     `+ pkg2@${pkg2_path.replace(/\\/g, "/")}`,
     "",
@@ -105,7 +106,7 @@ it("should remove existing package", async () => {
     "Removed: 1",
     "",
   ]);
-  expect(err1.replace(/^(.*?) v[^\n]+/, "$1").split(/\r?\n/)).toEqual(["bun remove", "Saved lockfile", ""]);
+  expect(err1.split(/\r?\n/)).toEqual(["Saved lockfile", ""]);
   expect(await file(join(package_dir, "package.json")).text()).toEqual(
     JSON.stringify(
       {
@@ -136,13 +137,14 @@ it("should remove existing package", async () => {
   const out2 = await new Response(stdout2).text();
   const err2 = await new Response(stderr2).text();
 
-  expect(out2.replace(/\s*\[[0-9\.]+m?s\]/, "").split(/\r?\n/)).toEqual(["", "- pkg2", "1 package removed", ""]);
-  expect(err2.replace(/^(.*?) v[^\n]+/, "$1").split(/\r?\n/)).toEqual([
-    "bun remove",
+  expect(out2.replace(/ \[[0-9\.]+m?s\]/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun remove v1."),
     "",
-    "package.json has no dependencies! Deleted empty lockfile",
+    "- pkg2",
+    "1 package removed",
     "",
   ]);
+  expect(err2.split(/\r?\n/)).toEqual(["", "package.json has no dependencies! Deleted empty lockfile", ""]);
   expect(await file(join(package_dir, "package.json")).text()).toEqual(
     JSON.stringify(
       {
@@ -211,10 +213,9 @@ it("should not affect if package is not installed", async () => {
   });
   expect(await exited).toBe(0);
   const out = await new Response(stdout).text();
-  expect(out).toEqual("");
+  expect(out.split("\n")).toEqual([expect.stringContaining("bun remove v1."), ""]);
   const err = await new Response(stderr).text();
-  expect(err.replace(/^(.*?) v[^\n]+/, "$1").split(/\r?\n/)).toEqual([
-    "bun remove",
+  expect(err.replace(/ \[[0-9\.]+m?s\]/, "").split(/\r?\n/)).toEqual([
     "package.json doesn't have dependencies, there's nothing to remove!",
     "",
   ]);
@@ -306,7 +307,12 @@ it("should remove peerDependencies", async () => {
   const err = await new Response(stderr).text();
   expect(err).not.toContain("error:");
   const out = await new Response(stdout).text();
-  expect(out.replace(/\s*\[[0-9\.]+m?s\]/, "").split(/\r?\n/)).toEqual([" done", ""]);
+  expect(out.replace(/\[[0-9\.]+m?s\]/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun remove v1."),
+    "",
+    " done",
+    "",
+  ]);
   expect(await exited).toBe(0);
   expect(await file(join(package_dir, "package.json")).json()).toEqual({
     name: "foo",
diff --git a/test/cli/install/bun-run.test.ts b/test/cli/install/bun-run.test.ts
index e20c2efda2..dc1866ec4b 100644
--- a/test/cli/install/bun-run.test.ts
+++ b/test/cli/install/bun-run.test.ts
@@ -1,7 +1,7 @@
 import { file, spawn, spawnSync } from "bun";
 import { beforeEach, describe, expect, it } from "bun:test";
 import { exists, mkdir, rm, writeFile } from "fs/promises";
-import { bunEnv, bunExe, bunEnv as env, isWindows, tempDirWithFiles, tmpdirSync } from "harness";
+import { bunEnv, bunExe, bunEnv as env, isWindows, tempDirWithFiles, tmpdirSync, stderrForInstall } from "harness";
 import { join } from "path";
 import { readdirSorted } from "./dummy.registry";
 
@@ -300,7 +300,7 @@ console.log(minify("print(6 * 7)").code);
       BUN_INSTALL_CACHE_DIR: join(run_dir, ".cache"),
     },
   });
-  const err2 = await new Response(stderr2).text();
+  const err2 = stderrForInstall(await new Response(stderr2).text());
   expect(err2).toBe("");
   expect(await readdirSorted(run_dir)).toEqual([".cache", "test.js"]);
   expect(await readdirSorted(join(run_dir, ".cache"))).toContain("uglify-js");
@@ -475,3 +475,138 @@ it("--ignore-dce-annotations ignores DCE annotations", () => {
   expect(stderr.toString()).toBe("");
   expect(stdout.toString()).toBe("Hello, world!\n");
 });
+
+it("$npm_command is accurate", async () => {
+  await writeFile(
+    join(run_dir, "package.json"),
+    `{
+      "scripts": {
+        "sample": "echo $npm_command",
+      },
+    }
+    `,
+  );
+  const p = spawn({
+    cmd: [bunExe(), "run", "sample"],
+    cwd: run_dir,
+    stdio: ["ignore", "pipe", "pipe"],
+    env: bunEnv,
+  });
+  expect(await p.exited).toBe(0);
+  expect(await new Response(p.stderr).text()).toBe(`$ echo $npm_command\n`);
+  expect(await new Response(p.stdout).text()).toBe(`run-script\n`);
+});
+
+it("$npm_lifecycle_event is accurate", async () => {
+  await writeFile(
+    join(run_dir, "package.json"),
+    `{
+      "scripts": {
+        "presample": "echo $npm_lifecycle_event",
+        "sample": "echo $npm_lifecycle_event",
+        "postsample": "echo $npm_lifecycle_event",
+      },
+    }
+    `,
+  );
+  const p = spawn({
+    cmd: [bunExe(), "run", "sample"],
+    cwd: run_dir,
+    stdio: ["ignore", "pipe", "pipe"],
+    env: bunEnv,
+  });
+  expect(await p.exited).toBe(0);
+  // prettier-ignore
+  expect(await new Response(p.stderr).text()).toBe(`$ echo $npm_lifecycle_event\n$ echo $npm_lifecycle_event\n$ echo $npm_lifecycle_event\n`,);
+  expect(await new Response(p.stdout).text()).toBe(`presample\nsample\npostsample\n`);
+});
+
+it("$npm_package_config_* works", async () => {
+  await writeFile(
+    join(run_dir, "package.json"),
+    `{
+      "config": {
+        "foo": "bar"
+      },
+      "scripts": {
+        "sample": "echo $npm_package_config_foo",
+      },
+    }
+    `,
+  );
+  const p = spawn({
+    cmd: [bunExe(), "run", "sample"],
+    cwd: run_dir,
+    stdio: ["ignore", "pipe", "pipe"],
+    env: bunEnv,
+  });
+  expect(await p.exited).toBe(0);
+  expect(await new Response(p.stderr).text()).toBe(`$ echo $npm_package_config_foo\n`);
+  expect(await new Response(p.stdout).text()).toBe(`bar\n`);
+});
+
+it("should pass arguments correctly in scripts", async () => {
+  const dir = tempDirWithFiles("test", {
+    "package.json": JSON.stringify({
+      workspaces: ["a", "b"],
+      scripts: { "root_script": "bun index.ts" },
+    }),
+    "index.ts": `for(const arg of Bun.argv) console.log(arg);`,
+    "a/package.json": JSON.stringify({ name: "a", scripts: { echo2: "echo" } }),
+    "b/package.json": JSON.stringify({ name: "b", scripts: { echo2: "npm run echo3", echo3: "echo" } }),
+  });
+
+  {
+    const { stdout, stderr, exitCode } = spawnSync({
+      cmd: [bunExe(), "run", "root_script", "$HOME (!)", "argument two"].filter(Boolean),
+      cwd: dir,
+      env: bunEnv,
+    });
+
+    expect(stderr.toString()).toBe('$ bun index.ts "\\$HOME (!)" "argument two"\n');
+    expect(stdout.toString()).toEndWith("\n$HOME (!)\nargument two\n");
+    expect(exitCode).toBe(0);
+  }
+  {
+    const { stdout, stderr, exitCode } = spawnSync({
+      cmd: [bunExe(), "--filter", "*", "echo2", "$HOME (!)", "argument two"].filter(Boolean),
+      cwd: dir,
+      env: bunEnv,
+    });
+
+    expect(stderr.toString()).toBe("");
+    expect(stdout.toString().split("\n").sort().join("\n")).toBe(
+      [
+        "a echo2: $HOME (!) argument two",
+        "a echo2: Exited with code 0",
+        'b echo2: $ echo "\\$HOME (!)" "argument two"',
+        "b echo2: $HOME (!) argument two",
+        "b echo2: Exited with code 0",
+        "",
+      ]
+        .sort()
+        .join("\n"),
+    );
+    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/bun-update.test.ts b/test/cli/install/bun-update.test.ts
index 9b6575a73b..2ecbbb9daa 100644
--- a/test/cli/install/bun-update.test.ts
+++ b/test/cli/install/bun-update.test.ts
@@ -70,6 +70,7 @@ for (const { input } of [{ input: { baz: "~0.0.3", moo: "~0.1.0" } }, { input: {
     expect(err1).toContain("Saved lockfile");
     const out1 = await new Response(stdout1).text();
     expect(out1.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       "+ baz@0.0.3",
       "",
@@ -112,6 +113,7 @@ for (const { input } of [{ input: { baz: "~0.0.3", moo: "~0.1.0" } }, { input: {
     expect(err2).toContain("Saved lockfile");
     const out2 = await new Response(stdout2).text();
     expect(out2.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun update v1."),
       "",
       `installed baz@${tilde ? "0.0.5" : "0.0.3"} with binaries:`,
       ` - ${tilde ? "baz-exec" : "baz-run"}`,
@@ -188,9 +190,10 @@ for (const { input } of [{ input: { baz: "~0.0.3", moo: "~0.1.0" } }, { input: {
     expect(err1).toContain("Saved lockfile");
     const out1 = await new Response(stdout1).text();
     expect(out1.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       "+ @barn/moo@0.1.0",
-      "+ baz@0.0.3",
+      expect.stringContaining("+ baz@0.0.3"),
       "",
       "2 packages installed",
     ]);
@@ -239,6 +242,7 @@ for (const { input } of [{ input: { baz: "~0.0.3", moo: "~0.1.0" } }, { input: {
     const out2 = await new Response(stdout2).text();
     if (tilde) {
       expect(out2.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun update v1."),
         "",
         "^ baz 0.0.3 -> 0.0.5",
         "",
@@ -248,9 +252,10 @@ for (const { input } of [{ input: { baz: "~0.0.3", moo: "~0.1.0" } }, { input: {
       ]);
     } else {
       expect(out2.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun update v1."),
         "",
-        "+ @barn/moo@0.1.0",
-        "+ baz@0.0.3",
+        expect.stringContaining("+ @barn/moo@0.1.0"),
+        expect.stringContaining("+ baz@0.0.3"),
         "",
         "2 packages installed",
       ]);
@@ -324,6 +329,7 @@ it("lockfile should not be modified when there are no version changes, issue#588
   expect(err1).toContain("Saved lockfile");
   const out1 = await new Response(stdout).text();
   expect(out1.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ baz@0.0.3",
     "",
diff --git a/test/cli/install/bun-workspaces.test.ts b/test/cli/install/bun-workspaces.test.ts
index c5e8804d77..7cf4d49d37 100644
--- a/test/cli/install/bun-workspaces.test.ts
+++ b/test/cli/install/bun-workspaces.test.ts
@@ -83,7 +83,11 @@ test("dependency on workspace without version in package.json", async () => {
     const lockfile = parseLockfile(packageDir);
     expect(lockfile).toMatchNodeModulesAt(packageDir);
     expect(lockfile).toMatchSnapshot(`version: ${version}`);
-    expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "2 packages installed"]);
+    expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
+      "",
+      "2 packages installed",
+    ]);
     rmSync(join(packageDir, "node_modules"), { recursive: true, force: true });
     rmSync(join(packageDir, "bun.lockb"), { recursive: true, force: true });
   }
@@ -106,7 +110,11 @@ test("dependency on workspace without version in package.json", async () => {
     const lockfile = parseLockfile(packageDir);
     expect(lockfile).toMatchNodeModulesAt(packageDir);
     expect(lockfile).toMatchSnapshot(`version: ${version}`);
-    expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "3 packages installed"]);
+    expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
+      "",
+      "3 packages installed",
+    ]);
     rmSync(join(packageDir, "node_modules"), { recursive: true, force: true });
     rmSync(join(packageDir, "packages", "bar", "node_modules"), { recursive: true, force: true });
     rmSync(join(packageDir, "bun.lockb"), { recursive: true, force: true });
@@ -147,7 +155,11 @@ test("dependency on same name as workspace and dist-tag", async () => {
   const lockfile = parseLockfile(packageDir);
   expect(lockfile).toMatchSnapshot("with version");
   expect(lockfile).toMatchNodeModulesAt(packageDir);
-  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "3 packages installed"]);
+  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
+    "",
+    "3 packages installed",
+  ]);
 });
 
 test("successfully installs workspace when path already exists in node_modules", async () => {
@@ -218,6 +230,7 @@ test("adding workspace in workspace edits package.json with correct version (wor
   const out = await Bun.readableStreamToText(stdout);
 
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun add v1."),
     "",
     "installed pkg2@workspace:apps/pkg2",
     "",
@@ -588,3 +601,60 @@ describe("relative tarballs", async () => {
     });
   });
 });
+
+test("$npm_package_config_ works in root", async () => {
+  await write(
+    join(packageDir, "package.json"),
+    JSON.stringify({
+      name: "foo",
+      workspaces: ["pkgs/*"],
+      config: { foo: "bar" },
+      scripts: { sample: "echo $npm_package_config_foo $npm_package_config_qux" },
+    }),
+  );
+  await write(
+    join(packageDir, "pkgs", "pkg1", "package.json"),
+    JSON.stringify({
+      name: "pkg1",
+      config: { qux: "tab" },
+      scripts: { sample: "echo $npm_package_config_foo $npm_package_config_qux" },
+    }),
+  );
+  const p = Bun.spawn({
+    cmd: [bunExe(), "run", "sample"],
+    cwd: packageDir,
+    stdio: ["ignore", "pipe", "pipe"],
+    env,
+  });
+  expect(await p.exited).toBe(0);
+  expect(await new Response(p.stderr).text()).toBe(`$ echo $npm_package_config_foo $npm_package_config_qux\n`);
+  expect(await new Response(p.stdout).text()).toBe(`bar\n`);
+});
+test("$npm_package_config_ works in root in subpackage", async () => {
+  await write(
+    join(packageDir, "package.json"),
+    JSON.stringify({
+      name: "foo",
+      workspaces: ["pkgs/*"],
+      config: { foo: "bar" },
+      scripts: { sample: "echo $npm_package_config_foo $npm_package_config_qux" },
+    }),
+  );
+  await write(
+    join(packageDir, "pkgs", "pkg1", "package.json"),
+    JSON.stringify({
+      name: "pkg1",
+      config: { qux: "tab" },
+      scripts: { sample: "echo $npm_package_config_foo $npm_package_config_qux" },
+    }),
+  );
+  const p = Bun.spawn({
+    cmd: [bunExe(), "run", "sample"],
+    cwd: join(packageDir, "pkgs", "pkg1"),
+    stdio: ["ignore", "pipe", "pipe"],
+    env,
+  });
+  expect(await p.exited).toBe(0);
+  expect(await new Response(p.stderr).text()).toBe(`$ echo $npm_package_config_foo $npm_package_config_qux\n`);
+  expect(await new Response(p.stdout).text()).toBe(`tab\n`);
+});
diff --git a/test/cli/install/dummy.registry.ts b/test/cli/install/dummy.registry.ts
index 65b7db7c41..474511d489 100644
--- a/test/cli/install/dummy.registry.ts
+++ b/test/cli/install/dummy.registry.ts
@@ -24,6 +24,7 @@ let server: Server;
 export let package_dir: string;
 export let requested: number;
 export let root_url: string;
+export let check_npm_auth_type = { check: true };
 export function dummyRegistry(urls: string[], info: any = { "0.0.2": {} }, numberOfTimesTo500PerURL = 0) {
   let retryCountsByURL = new Map<string, number>();
   const _handler: Handler = async request => {
@@ -50,7 +51,9 @@ export function dummyRegistry(urls: string[], info: any = { "0.0.2": {} }, numbe
     expect(request.headers.get("accept")).toBe(
       "application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*",
     );
-    expect(request.headers.get("npm-auth-type")).toBe(null);
+    if (check_npm_auth_type.check) {
+      expect(request.headers.get("npm-auth-type")).toBe(null);
+    }
     expect(await request.text()).toBe("");
 
     const name = url.slice(url.indexOf("/", root_url.length) + 1);
diff --git a/test/cli/install/migration/migrate-package-with-dependency-on-root/.gitignore b/test/cli/install/migration/migrate-package-with-dependency-on-root/.gitignore
new file mode 100644
index 0000000000..2fe28d55d5
--- /dev/null
+++ b/test/cli/install/migration/migrate-package-with-dependency-on-root/.gitignore
@@ -0,0 +1 @@
+!package-lock.json
\ No newline at end of file
diff --git a/test/cli/install/migration/migrate-package-with-dependency-on-root/package-lock.json b/test/cli/install/migration/migrate-package-with-dependency-on-root/package-lock.json
new file mode 100644
index 0000000000..5aa31687fb
--- /dev/null
+++ b/test/cli/install/migration/migrate-package-with-dependency-on-root/package-lock.json
@@ -0,0 +1,20 @@
+{
+  "name": "test-pkg",
+  "version": "2.2.2",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "test-pkg",
+      "version": "2.2.2",
+      "hasInstallScript": true,
+      "dependencies": {
+        "test-pkg": "."
+      }
+    },
+    "node_modules/test-pkg": {
+      "resolved": "",
+      "link": true
+    }
+  }
+}
diff --git a/test/cli/install/migration/migrate-package-with-dependency-on-root/package.json b/test/cli/install/migration/migrate-package-with-dependency-on-root/package.json
new file mode 100644
index 0000000000..6440372a55
--- /dev/null
+++ b/test/cli/install/migration/migrate-package-with-dependency-on-root/package.json
@@ -0,0 +1,10 @@
+{
+  "name": "test-pkg",
+  "version": "2.2.2",
+  "scripts": {
+    "postinstall": "echo success!"
+  },
+  "dependencies": {
+    "test-pkg": "."
+  }
+}
diff --git a/test/cli/install/migration/migrate.test.ts b/test/cli/install/migration/migrate.test.ts
index bd5d19b5fd..ccd379af61 100644
--- a/test/cli/install/migration/migrate.test.ts
+++ b/test/cli/install/migration/migrate.test.ts
@@ -63,6 +63,21 @@ test.todo("migrate workspace from npm during `bun add`", async () => {
   expect(svelte_version).toBe("3.0.0");
 });
 
+test("migrate package with dependency on root package", async () => {
+  const testDir = tmpdirSync();
+
+  fs.cpSync(join(import.meta.dir, "migrate-package-with-dependency-on-root"), testDir, { recursive: true });
+
+  const { stdout } = Bun.spawnSync([bunExe(), "install"], {
+    env: bunEnv,
+    cwd: join(testDir),
+    stdout: "pipe",
+  });
+
+  expect(stdout.toString()).toContain("success!");
+  expect(fs.existsSync(join(testDir, "node_modules", "test-pkg", "package.json"))).toBeTrue();
+});
+
 test("migrate from npm lockfile that is missing `resolved` properties", async () => {
   const testDir = tmpdirSync();
 
diff --git a/test/cli/install/pkg-only-owner-2.2.2.tgz b/test/cli/install/pkg-only-owner-2.2.2.tgz
new file mode 100644
index 0000000000..c45ba36ad0
Binary files /dev/null and b/test/cli/install/pkg-only-owner-2.2.2.tgz differ
diff --git a/test/cli/install/redacted-config-logs.test.ts b/test/cli/install/redacted-config-logs.test.ts
new file mode 100644
index 0000000000..68d9a70c5b
--- /dev/null
+++ b/test/cli/install/redacted-config-logs.test.ts
@@ -0,0 +1,102 @@
+import { bunExe, bunEnv, tmpdirSync } from "harness";
+import { write, spawnSync } from "bun";
+import { describe, test, expect } from "bun:test";
+import { join } from "path";
+
+describe("redact", async () => {
+  const tests = [
+    {
+      title: "url password",
+      bunfig: `install.registry = "https://user:pass@registry.org`,
+      expected: `"https://user:****@registry.org`,
+    },
+    {
+      title: "empty url password",
+      bunfig: `install.registry = "https://user:@registry.org`,
+      expected: `"https://user:@registry.org`,
+    },
+    {
+      title: "small string",
+      bunfig: `l;token = "1"`,
+      expected: `"*"`,
+    },
+    {
+      title: "random UUID",
+      bunfig: 'unre;lated = "f1b0b6b4-4b1b-4b1b-8b1b-4b1b4b1b4b1b"',
+      expected: '"************************************"',
+    },
+    {
+      title: "random npm_ secret",
+      bunfig: 'the;secret = "npm_1234567890abcdefghijklmnopqrstuvwxyz"',
+      expected: '"****************************************"',
+    },
+    {
+      title: "random npms_ secret",
+      bunfig: 'the;secret = "npms_1234567890abcdefghijklmnopqrstuvwxyz"',
+      expected: "*****************************************",
+    },
+    {
+      title: "zero length unterminated string",
+      bunfig: '_authToken = "',
+      expected: "*",
+    },
+    {
+      title: "invalid _auth",
+      npmrc: "//registry.npmjs.org/:_auth = does-not-decode",
+      expected: "****************",
+    },
+    {
+      title: "unexpected _auth",
+      npmrc: "//registry.npmjs.org/:_auth=:secret",
+      expected: "*******",
+    },
+    {
+      title: "_auth zero length",
+      npmrc: "//registry.npmjs.org/:_auth=",
+      expected: "received an empty string",
+    },
+    {
+      title: "_auth one length",
+      npmrc: "//registry.npmjs.org/:_auth=1",
+      expected: "*",
+    },
+  ];
+
+  for (const { title, bunfig, npmrc, expected } of tests) {
+    test(title + (bunfig ? " (bunfig)" : " (npmrc)"), async () => {
+      const testDir = tmpdirSync();
+      await Promise.all([
+        write(join(testDir, bunfig ? "bunfig.toml" : ".npmrc"), (bunfig || npmrc)!),
+        write(join(testDir, "package.json"), "{}"),
+      ]);
+
+      // once without color
+      let proc = spawnSync({
+        cmd: [bunExe(), "install"],
+        cwd: testDir,
+        env: { ...bunEnv, NO_COLOR: "1" },
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+
+      let out = proc.stdout.toString();
+      let err = proc.stderr.toString();
+      expect(proc.exitCode).toBe(+!!bunfig);
+      expect(err).toContain(expected || "*");
+
+      // once with color
+      proc = spawnSync({
+        cmd: [bunExe(), "install"],
+        cwd: testDir,
+        env: { ...bunEnv, NO_COLOR: undefined, FORCE_COLOR: "1" },
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+
+      out = proc.stdout.toString();
+      err = proc.stderr.toString();
+      expect(proc.exitCode).toBe(+!!bunfig);
+      expect(err).toContain(expected || "*");
+    });
+  }
+});
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 0f33e6cd4f..f21ad002a6 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 e33965d1a6..12b8a5ff19 100644
--- a/test/cli/install/registry/bun-install-registry.test.ts
+++ b/test/cli/install/registry/bun-install-registry.test.ts
@@ -14,12 +14,17 @@ import {
   randomPort,
   runBunInstall,
   runBunUpdate,
+  pack,
   tempDirWithFiles,
   tmpdirSync,
   toBeValidBin,
   toHaveBins,
   toMatchNodeModulesAt,
   writeShebangScript,
+  stderrForInstall,
+  tls,
+  isFlaky,
+  isMacOS,
 } from "harness";
 import { join, resolve, sep } from "path";
 import { readdirSorted } from "../dummy.registry";
@@ -36,6 +41,8 @@ expect.extend({
 var verdaccioServer: ChildProcess;
 var port: number = randomPort();
 var packageDir: string;
+/** packageJson = join(packageDir, "package.json"); */
+var packageJson: string;
 
 let users: Record<string, string> = {};
 
@@ -85,6 +92,7 @@ afterAll(async () => {
 
 beforeEach(async () => {
   packageDir = tmpdirSync();
+  packageJson = join(packageDir, "package.json");
   await Bun.$`rm -f ${import.meta.dir}/htpasswd`.throws(false);
   await Bun.$`rm -rf ${import.meta.dir}/packages/private-pkg-dont-touch`.throws(false);
   users = {};
@@ -108,7 +116,6 @@ function registryUrl() {
  * Returns auth token
  */
 async function generateRegistryUser(username: string, password: string): Promise<string> {
-  console.log("GENERATE REGISTRY USER");
   if (users[username]) {
     throw new Error("that user already exists");
   } else users[username] = password;
@@ -130,7 +137,6 @@ async function generateRegistryUser(username: string, password: string): Promise
 
   if (response.ok) {
     const data = await response.json();
-    console.log(`Token: ${data.token}`);
     return data.token;
   } else {
     throw new Error("Failed to create user:", response.statusText);
@@ -189,6 +195,97 @@ registry = http://localhost:${port}/
     await Bun.$`${bunExe()} install`.cwd(packageDir).throws(true);
   });
 
+  it("works with home config", async () => {
+    console.log("package dir", packageDir);
+    await Bun.$`rm -rf ${packageDir}/bunfig.toml`;
+
+    const homeDir = `${packageDir}/home_dir`;
+    await Bun.$`mkdir -p ${homeDir}`;
+    console.log("home dir", homeDir);
+
+    const ini = /* ini */ `
+  registry=http://localhost:${port}/
+  `;
+
+    await Bun.$`echo ${ini} > ${homeDir}/.npmrc`;
+    await Bun.$`echo ${JSON.stringify({
+      name: "foo",
+      dependencies: {
+        "no-deps": "1.0.0",
+      },
+    })} > package.json`.cwd(packageDir);
+    await Bun.$`${bunExe()} install`
+      .env({
+        ...process.env,
+        XDG_CONFIG_HOME: `${homeDir}`,
+      })
+      .cwd(packageDir)
+      .throws(true);
+  });
+
+  it("works with two configs", async () => {
+    await Bun.$`rm -rf ${packageDir}/bunfig.toml`;
+
+    console.log("package dir", packageDir);
+    const packageIni = /* ini */ `
+  @types:registry=http://localhost:${port}/
+  `;
+    await Bun.$`echo ${packageIni} > ${packageDir}/.npmrc`;
+
+    const homeDir = `${packageDir}/home_dir`;
+    await Bun.$`mkdir -p ${homeDir}`;
+    console.log("home dir", homeDir);
+    const homeIni = /* ini */ `
+    registry = http://localhost:${port}/
+    `;
+    await Bun.$`echo ${homeIni} > ${homeDir}/.npmrc`;
+
+    await Bun.$`echo ${JSON.stringify({
+      name: "foo",
+      dependencies: {
+        "no-deps": "1.0.0",
+        "@types/no-deps": "1.0.0",
+      },
+    })} > package.json`.cwd(packageDir);
+    await Bun.$`${bunExe()} install`
+      .env({
+        ...process.env,
+        XDG_CONFIG_HOME: `${homeDir}`,
+      })
+      .cwd(packageDir)
+      .throws(true);
+  });
+
+  it("package config overrides home config", async () => {
+    await Bun.$`rm -rf ${packageDir}/bunfig.toml`;
+
+    console.log("package dir", packageDir);
+    const packageIni = /* ini */ `
+  @types:registry=http://localhost:${port}/
+  `;
+    await Bun.$`echo ${packageIni} > ${packageDir}/.npmrc`;
+
+    const homeDir = `${packageDir}/home_dir`;
+    await Bun.$`mkdir -p ${homeDir}`;
+    console.log("home dir", homeDir);
+    const homeIni = /* ini */ "@types:registry=https://registry.npmjs.org/";
+    await Bun.$`echo ${homeIni} > ${homeDir}/.npmrc`;
+
+    await Bun.$`echo ${JSON.stringify({
+      name: "foo",
+      dependencies: {
+        "@types/no-deps": "1.0.0",
+      },
+    })} > package.json`.cwd(packageDir);
+    await Bun.$`${bunExe()} install`
+      .env({
+        ...process.env,
+        XDG_CONFIG_HOME: `${homeDir}`,
+      })
+      .cwd(packageDir)
+      .throws(true);
+  });
+
   it("default registry from env variable", async () => {
     const ini = /* ini */ `
 registry=\${LOL}
@@ -325,7 +422,7 @@ registry = http://localhost:${port}/
             .join("\n")
         : "";
 
-      const ini = /* ini */ `
+      const ini = `
 registry = http://localhost:${port}/
 ${Object.keys(opts)
   .map(
@@ -418,16 +515,1139 @@ ${Object.keys(opts)
       dotEnv: { SECRET_AUTH: "" },
     },
     (stdout: string, stderr: string) => {
-      expect(stderr).toContain("got an empty string");
+      expect(stderr).toContain("received an empty string");
     },
   );
 });
 
+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) {
+      if (req.url.includes("no-deps")) {
+        return new Response(Bun.file(join(import.meta.dir, "packages", "no-deps", "no-deps-1.0.0.tgz")));
+      }
+      return new Response("OK", { status: 200 });
+    };
+  };
+  test("valid --cafile", async () => {
+    using server = Bun.serve({
+      port: 0,
+      fetch: mockRegistryFetch(),
+      ...tls,
+    });
+    await Promise.all([
+      write(
+        packageJson,
+        JSON.stringify({
+          name: "foo",
+          version: "1.1.1",
+          dependencies: {
+            "no-deps": `https://localhost:${server.port}/no-deps-1.0.0.tgz`,
+          },
+        }),
+      ),
+      write(
+        join(packageDir, "bunfig.toml"),
+        `
+    [install]
+    cache = false
+    registry = "https://localhost:${server.port}/"`,
+      ),
+      write(join(packageDir, "cafile"), tls.cert),
+    ]);
+
+    const { stdout, stderr, exited } = spawn({
+      cmd: [bunExe(), "install", "--cafile", "cafile"],
+      cwd: packageDir,
+      stderr: "pipe",
+      stdout: "pipe",
+      env,
+    });
+    const out = await Bun.readableStreamToText(stdout);
+    expect(out).toContain("+ no-deps@");
+    const err = await Bun.readableStreamToText(stderr);
+    expect(err).not.toContain("ConnectionClosed");
+    expect(err).not.toContain("error:");
+    expect(err).not.toContain("DEPTH_ZERO_SELF_SIGNED_CERT");
+    expect(await exited).toBe(0);
+  });
+  test("valid --ca", async () => {
+    using server = Bun.serve({
+      port: 0,
+      fetch: mockRegistryFetch(),
+      ...tls,
+    });
+    await Promise.all([
+      write(
+        packageJson,
+        JSON.stringify({
+          name: "foo",
+          version: "1.1.1",
+          dependencies: {
+            "no-deps": `https://localhost:${server.port}/no-deps-1.0.0.tgz`,
+          },
+        }),
+      ),
+      write(
+        join(packageDir, "bunfig.toml"),
+        `
+        [install]
+        cache = false
+        registry = "https://localhost:${server.port}/"`,
+      ),
+    ]);
+
+    // first without ca, should fail
+    let { stdout, stderr, exited } = spawn({
+      cmd: [bunExe(), "install"],
+      cwd: packageDir,
+      stderr: "pipe",
+      stdout: "pipe",
+      env,
+    });
+    let out = await Bun.readableStreamToText(stdout);
+    let err = stderrForInstall(await Bun.readableStreamToText(stderr));
+    expect(err).toContain("DEPTH_ZERO_SELF_SIGNED_CERT");
+    expect(await exited).toBe(1);
+
+    // now with a valid ca
+    ({ stdout, stderr, exited } = spawn({
+      cmd: [bunExe(), "install", "--ca", tls.cert],
+      cwd: packageDir,
+      stderr: "pipe",
+      stdout: "pipe",
+      env,
+    }));
+    out = await Bun.readableStreamToText(stdout);
+    expect(out).toContain("+ no-deps@");
+    err = await Bun.readableStreamToText(stderr);
+    expect(err).not.toContain("DEPTH_ZERO_SELF_SIGNED_CERT");
+    expect(err).not.toContain("error:");
+    expect(await exited).toBe(0);
+  });
+  test(`non-existent --cafile`, async () => {
+    await write(packageJson, JSON.stringify({ name: "foo", version: "1.0.0", "dependencies": { "no-deps": "1.1.1" } }));
+
+    const { stdout, stderr, exited } = spawn({
+      cmd: [bunExe(), "install", "--cafile", "does-not-exist"],
+      cwd: packageDir,
+      stderr: "pipe",
+      stdout: "pipe",
+      env,
+    });
+    const out = await Bun.readableStreamToText(stdout);
+    expect(out).not.toContain("no-deps");
+    const err = await Bun.readableStreamToText(stderr);
+    expect(err).toContain(`HTTPThread: could not find CA file: '${join(packageDir, "does-not-exist")}'`);
+    expect(await exited).toBe(1);
+  });
+
+  test("non-existent --cafile (absolute path)", async () => {
+    await write(packageJson, JSON.stringify({ name: "foo", version: "1.0.0", "dependencies": { "no-deps": "1.1.1" } }));
+    const { stdout, stderr, exited } = spawn({
+      cmd: [bunExe(), "install", "--cafile", "/does/not/exist"],
+      cwd: packageDir,
+      stderr: "pipe",
+      stdout: "pipe",
+      env,
+    });
+    const out = await Bun.readableStreamToText(stdout);
+    expect(out).not.toContain("no-deps");
+    const err = await Bun.readableStreamToText(stderr);
+    expect(err).toContain(`HTTPThread: could not find CA file: '/does/not/exist'`);
+    expect(await exited).toBe(1);
+  });
+
+  test("cafile from bunfig does not exist", async () => {
+    await Promise.all([
+      write(
+        packageJson,
+        JSON.stringify({
+          name: "foo",
+          version: "1.0.0",
+          dependencies: {
+            "no-deps": "1.1.1",
+          },
+        }),
+      ),
+      write(
+        join(packageDir, "bunfig.toml"),
+        `
+      [install]
+      cache = false
+      registry = "http://localhost:${port}/"
+      cafile = "does-not-exist"`,
+      ),
+    ]);
+
+    const { stdout, stderr, exited } = spawn({
+      cmd: [bunExe(), "install"],
+      cwd: packageDir,
+      stderr: "pipe",
+      stdout: "pipe",
+      env,
+    });
+
+    const out = await Bun.readableStreamToText(stdout);
+    expect(out).not.toContain("no-deps");
+    const err = await Bun.readableStreamToText(stderr);
+    expect(err).toContain(`HTTPThread: could not find CA file: '${join(packageDir, "does-not-exist")}'`);
+    expect(await exited).toBe(1);
+  });
+  test("invalid cafile", async () => {
+    await Promise.all([
+      write(
+        packageJson,
+        JSON.stringify({
+          name: "foo",
+          version: "1.0.0",
+          dependencies: {
+            "no-deps": "1.1.1",
+          },
+        }),
+      ),
+      write(
+        join(packageDir, "invalid-cafile"),
+        `-----BEGIN CERTIFICATE-----
+jlwkjekfjwlejlgldjfljlkwjef
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+ljelkjwelkgjw;lekj;lkejflkj
+-----END CERTIFICATE-----`,
+      ),
+    ]);
+
+    const { stdout, stderr, exited } = spawn({
+      cmd: [bunExe(), "install", "--cafile", join(packageDir, "invalid-cafile")],
+      cwd: packageDir,
+      stderr: "pipe",
+      stdout: "pipe",
+      env,
+    });
+
+    const out = await Bun.readableStreamToText(stdout);
+    expect(out).not.toContain("no-deps");
+    const err = await Bun.readableStreamToText(stderr);
+    expect(err).toContain(`HTTPThread: invalid CA file: '${join(packageDir, "invalid-cafile")}'`);
+    expect(await exited).toBe(1);
+  });
+  test("invalid --ca", async () => {
+    await write(
+      packageJson,
+      JSON.stringify({
+        name: "foo",
+        version: "1.0.0",
+        dependencies: {
+          "no-deps": "1.1.1",
+        },
+      }),
+    );
+    const { stdout, stderr, exited } = spawn({
+      cmd: [bunExe(), "install", "--ca", "not-valid"],
+      cwd: packageDir,
+      stderr: "pipe",
+      stdout: "pipe",
+      env,
+    });
+
+    const out = await Bun.readableStreamToText(stdout);
+    expect(out).not.toContain("no-deps");
+    const err = await Bun.readableStreamToText(stderr);
+    expect(err).toContain("HTTPThread: the CA is invalid");
+    expect(await exited).toBe(1);
+  });
+});
+
+export async function publish(
+  env: any,
+  cwd: string,
+  ...args: string[]
+): Promise<{ out: string; err: string; exitCode: number }> {
+  const { stdout, stderr, exited } = spawn({
+    cmd: [bunExe(), "publish", ...args],
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+    env,
+  });
+
+  const out = await Bun.readableStreamToText(stdout);
+  const err = stderrForInstall(await Bun.readableStreamToText(stderr));
+  const exitCode = await exited;
+  return { out, err, exitCode };
+}
+
+async function authBunfig(user: string) {
+  const authToken = await generateRegistryUser(user, user);
+  return `
+        [install]
+        cache = false
+        registry = { url = "http://localhost:${port}/", token = "${authToken}" }
+        `;
+}
+
+describe("whoami", async () => {
+  test("can get username", async () => {
+    const bunfig = await authBunfig("whoami");
+    await Promise.all([
+      write(
+        packageJson,
+        JSON.stringify({
+          name: "whoami-pkg",
+          version: "1.1.1",
+        }),
+      ),
+      write(join(packageDir, "bunfig.toml"), bunfig),
+    ]);
+
+    const { stdout, stderr, exited } = spawn({
+      cmd: [bunExe(), "pm", "whoami"],
+      cwd: packageDir,
+      stdout: "pipe",
+      stderr: "pipe",
+      env,
+    });
+
+    const out = await Bun.readableStreamToText(stdout);
+    expect(out).toBe("whoami\n");
+    const err = await Bun.readableStreamToText(stderr);
+    expect(err).not.toContain("error:");
+    expect(await exited).toBe(0);
+  });
+  test("username from .npmrc", async () => {
+    // It should report the username from npmrc, even without an account
+    const bunfig = `
+    [install]
+    cache = false
+    registry = "http://localhost:${port}/"`;
+    const npmrc = `
+    //localhost:${port}/:username=whoami-npmrc
+    //localhost:${port}/:_password=123456
+    `;
+    await Promise.all([
+      write(packageJson, JSON.stringify({ name: "whoami-pkg", version: "1.1.1" })),
+      write(join(packageDir, "bunfig.toml"), bunfig),
+      write(join(packageDir, ".npmrc"), npmrc),
+    ]);
+
+    const { stdout, stderr, exited } = spawn({
+      cmd: [bunExe(), "pm", "whoami"],
+      cwd: packageDir,
+      stdout: "pipe",
+      stderr: "pipe",
+      env,
+    });
+
+    const out = await Bun.readableStreamToText(stdout);
+    expect(out).toBe("whoami-npmrc\n");
+    const err = await Bun.readableStreamToText(stderr);
+    expect(err).not.toContain("error:");
+    expect(await exited).toBe(0);
+  });
+  test("only .npmrc", async () => {
+    const token = await generateRegistryUser("whoami-npmrc", "whoami-npmrc");
+    const npmrc = `
+    //localhost:${port}/:_authToken=${token}
+    registry=http://localhost:${port}/`;
+    await Promise.all([
+      write(packageJson, JSON.stringify({ name: "whoami-pkg", version: "1.1.1" })),
+      write(join(packageDir, ".npmrc"), npmrc),
+    ]);
+    const { stdout, stderr, exited } = spawn({
+      cmd: [bunExe(), "pm", "whoami"],
+      cwd: packageDir,
+      stdout: "pipe",
+      stderr: "pipe",
+      env,
+    });
+    const out = await Bun.readableStreamToText(stdout);
+    expect(out).toBe("whoami-npmrc\n");
+    const err = await Bun.readableStreamToText(stderr);
+    expect(err).not.toContain("error:");
+    expect(await exited).toBe(0);
+  });
+    test("two .npmrc", async () => {
+    const token = await generateRegistryUser("whoami-two-npmrc", "whoami-two-npmrc");
+    const packageNpmrc = `registry=http://localhost:${port}/`;
+    const homeNpmrc = `//localhost:${port}/:_authToken=${token}`;
+    const homeDir = `${packageDir}/home_dir`;
+    await Bun.$`mkdir -p ${homeDir}`;
+    await Promise.all([
+      write(packageJson, JSON.stringify({ name: "whoami-pkg", version: "1.1.1" })),
+      write(join(packageDir, ".npmrc"), packageNpmrc),
+      write(join(homeDir, ".npmrc"), homeNpmrc),
+    ]);
+    const { stdout, stderr, exited } = spawn({
+      cmd: [bunExe(), "pm", "whoami"],
+      cwd: packageDir,
+      stdout: "pipe",
+      stderr: "pipe",
+      env: {
+        ...env,
+        XDG_CONFIG_HOME: `${homeDir}`,
+      },
+    });
+    const out = await Bun.readableStreamToText(stdout);
+    expect(out).toBe("whoami-two-npmrc\n");
+    const err = await Bun.readableStreamToText(stderr);
+    expect(err).not.toContain("error:");
+    expect(await exited).toBe(0);
+  });
+  test("not logged in", async () => {
+    await write(packageJson, JSON.stringify({ name: "whoami-pkg", version: "1.1.1" }));
+    const { stdout, stderr, exited } = spawn({
+      cmd: [bunExe(), "pm", "whoami"],
+      cwd: packageDir,
+      env,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const out = await Bun.readableStreamToText(stdout);
+    expect(out).toBeEmpty();
+    const err = await Bun.readableStreamToText(stderr);
+    expect(err).toBe("error: missing authentication (run `bunx npm login`)\n");
+    expect(await exited).toBe(1);
+  });
+  test("invalid token", async () => {
+    // create the user and provide an invalid token
+    const token = await generateRegistryUser("invalid-token", "invalid-token");
+    const bunfig = `
+    [install]
+    cache = false
+    registry = { url = "http://localhost:${port}/", token = "1234567" }`;
+    await Promise.all([
+      write(packageJson, JSON.stringify({ name: "whoami-pkg", version: "1.1.1" })),
+      write(join(packageDir, "bunfig.toml"), bunfig),
+    ]);
+    const { stdout, stderr, exited } = spawn({
+      cmd: [bunExe(), "pm", "whoami"],
+      cwd: packageDir,
+      env,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const out = await Bun.readableStreamToText(stdout);
+    expect(out).toBeEmpty();
+    const err = await Bun.readableStreamToText(stderr);
+    expect(err).toBe(`error: failed to authenticate with registry 'http://localhost:${port}/'\n`);
+    expect(await exited).toBe(1);
+  });
+});
+
+describe("publish", async () => {
+  describe("otp", async () => {
+    const mockRegistryFetch = function (opts: {
+      token: string;
+      setAuthHeader?: boolean;
+      otpFail?: boolean;
+      npmNotice?: boolean;
+      xLocalCache?: boolean;
+      expectedCI?: string;
+    }) {
+      return async function (req: Request) {
+        const { token, setAuthHeader = true, otpFail = false, npmNotice = false, xLocalCache = false } = opts;
+        if (req.url.includes("otp-pkg")) {
+          if (opts.expectedCI) {
+            expect(req.headers.get("user-agent")).toContain("ci/" + opts.expectedCI);
+          }
+          if (req.headers.get("npm-otp") === token) {
+            if (otpFail) {
+              return new Response(
+                JSON.stringify({
+                  error: "You must provide a one-time pass. Upgrade your client to npm@latest in order to use 2FA.",
+                }),
+                { status: 401 },
+              );
+            } else {
+              return new Response("OK", { status: 200 });
+            }
+          } else {
+            const headers = new Headers();
+            if (setAuthHeader) headers.set("www-authenticate", "OTP");
+
+            // `bun publish` won't request a url from a message in the npm-notice header, but we
+            // can test that it's displayed
+            if (npmNotice) headers.set("npm-notice", `visit http://localhost:${this.port}/auth to login`);
+
+            // npm-notice will be ignored
+            if (xLocalCache) headers.set("x-local-cache", "true");
+
+            return new Response(
+              JSON.stringify({
+                // this isn't accurate, but we just want to check that finding this string works
+                mock: setAuthHeader ? "" : "one-time password",
+
+                authUrl: `http://localhost:${this.port}/auth`,
+                doneUrl: `http://localhost:${this.port}/done`,
+              }),
+              {
+                status: 401,
+                headers,
+              },
+            );
+          }
+        } else if (req.url.endsWith("auth")) {
+          expect.unreachable("url given to user, bun publish should not request");
+        } else if (req.url.endsWith("done")) {
+          // send a fake response saying the user has authenticated successfully with the auth url
+          return new Response(JSON.stringify({ token: token }), { status: 200 });
+        }
+
+        expect.unreachable("unexpected url");
+      };
+    };
+
+    for (const setAuthHeader of [true, false]) {
+      test("mock web login" + (setAuthHeader ? "" : " (without auth header)"), async () => {
+        const token = await generateRegistryUser("otp" + (setAuthHeader ? "" : "noheader"), "otp");
+
+        using mockRegistry = Bun.serve({
+          port: 0,
+          fetch: mockRegistryFetch({ token }),
+        });
+
+        const bunfig = `
+      [install]
+      cache = false
+      registry = { url = "http://localhost:${mockRegistry.port}", token = "${token}" }`;
+        await Promise.all([
+          rm(join(import.meta.dir, "packages", "otp-pkg-1"), { recursive: true, force: true }),
+          write(join(packageDir, "bunfig.toml"), bunfig),
+          write(
+            packageJson,
+            JSON.stringify({
+              name: "otp-pkg-1",
+              version: "2.2.2",
+              dependencies: {
+                "otp-pkg-1": "2.2.2",
+              },
+            }),
+          ),
+        ]);
+
+        const { out, err, exitCode } = await publish(env, packageDir);
+        expect(exitCode).toBe(0);
+      });
+    }
+
+    test("otp failure", async () => {
+      const token = await generateRegistryUser("otp-fail", "otp");
+      using mockRegistry = Bun.serve({
+        port: 0,
+        fetch: mockRegistryFetch({ token, otpFail: true }),
+      });
+
+      const bunfig = `
+      [install]
+      cache = false
+      registry = { url = "http://localhost:${mockRegistry.port}", token = "${token}" }`;
+
+      await Promise.all([
+        rm(join(import.meta.dir, "packages", "otp-pkg-2"), { recursive: true, force: true }),
+        write(join(packageDir, "bunfig.toml"), bunfig),
+        write(
+          packageJson,
+          JSON.stringify({
+            name: "otp-pkg-2",
+            version: "1.1.1",
+            dependencies: {
+              "otp-pkg-2": "1.1.1",
+            },
+          }),
+        ),
+      ]);
+
+      const { out, err, exitCode } = await publish(env, packageDir);
+      expect(exitCode).toBe(1);
+      expect(err).toContain(" - Received invalid OTP");
+    });
+
+    for (const shouldIgnoreNotice of [false, true]) {
+      test(`npm-notice with login url${shouldIgnoreNotice ? " (ignored)" : ""}`, async () => {
+        // Situation: user has 2FA enabled account with faceid sign-in.
+        // They run `bun publish` with --auth-type=legacy, prompting them
+        // to enter their OTP. Because they have faceid sign-in, they don't
+        // have a code to enter, so npm sends a message in the npm-notice
+        // header with a url for logging in.
+        const token = await generateRegistryUser(`otp-notice${shouldIgnoreNotice ? "-ignore" : ""}`, "otp");
+        using mockRegistry = Bun.serve({
+          port: 0,
+          fetch: mockRegistryFetch({ token, npmNotice: true, xLocalCache: shouldIgnoreNotice }),
+        });
+
+        const bunfig = `
+        [install]
+        cache = false
+        registry = { url = "http://localhost:${mockRegistry.port}", token = "${token}" }`;
+
+        await Promise.all([
+          rm(join(import.meta.dir, "packages", "otp-pkg-3"), { recursive: true, force: true }),
+          write(join(packageDir, "bunfig.toml"), bunfig),
+          write(
+            packageJson,
+            JSON.stringify({
+              name: "otp-pkg-3",
+              version: "3.3.3",
+              dependencies: {
+                "otp-pkg-3": "3.3.3",
+              },
+            }),
+          ),
+        ]);
+
+        const { out, err, exitCode } = await publish(env, packageDir);
+        expect(exitCode).toBe(0);
+        if (shouldIgnoreNotice) {
+          expect(err).not.toContain(`note: visit http://localhost:${mockRegistry.port}/auth to login`);
+        } else {
+          expect(err).toContain(`note: visit http://localhost:${mockRegistry.port}/auth to login`);
+        }
+      });
+    }
+
+    const fakeCIEnvs = [
+      { ci: "expo-application-services", envs: { EAS_BUILD: "hi" } },
+      { ci: "codemagic", envs: { CM_BUILD_ID: "hi" } },
+      { ci: "vercel", envs: { "NOW_BUILDER": "hi" } },
+    ];
+    for (const envInfo of fakeCIEnvs) {
+      test(`CI user agent name: ${envInfo.ci}`, async () => {
+        const token = await generateRegistryUser(`otp-${envInfo.ci}`, "otp");
+        using mockRegistry = Bun.serve({
+          port: 0,
+          fetch: mockRegistryFetch({ token, expectedCI: envInfo.ci }),
+        });
+
+        const bunfig = `
+        [install]
+        cache = false
+        registry = { url = "http://localhost:${mockRegistry.port}", token = "${token}" }`;
+
+        await Promise.all([
+          rm(join(import.meta.dir, "packages", "otp-pkg-4"), { recursive: true, force: true }),
+          write(join(packageDir, "bunfig.toml"), bunfig),
+          write(
+            packageJson,
+            JSON.stringify({
+              name: "otp-pkg-4",
+              version: "4.4.4",
+              dependencies: {
+                "otp-pkg-4": "4.4.4",
+              },
+            }),
+          ),
+        ]);
+
+        const { out, err, exitCode } = await publish(
+          { ...env, ...envInfo.envs, ...{ BUILDKITE: undefined, GITHUB_ACTIONS: undefined } },
+          packageDir,
+        );
+        expect(exitCode).toBe(0);
+      });
+    }
+  });
+
+  test("can publish a package then install it", async () => {
+    const bunfig = await authBunfig("basic");
+    await Promise.all([
+      rm(join(import.meta.dir, "packages", "publish-pkg-1"), { recursive: true, force: true }),
+      write(
+        packageJson,
+        JSON.stringify({
+          name: "publish-pkg-1",
+          version: "1.1.1",
+          dependencies: {
+            "publish-pkg-1": "1.1.1",
+          },
+        }),
+      ),
+      write(join(packageDir, "bunfig.toml"), bunfig),
+    ]);
+
+    const { out, err, exitCode } = await publish(env, packageDir);
+    expect(err).not.toContain("error:");
+    expect(err).not.toContain("warn:");
+    expect(exitCode).toBe(0);
+
+    await runBunInstall(env, packageDir);
+    expect(await exists(join(packageDir, "node_modules", "publish-pkg-1", "package.json"))).toBeTrue();
+  });
+  test("can publish from a tarball", async () => {
+    const bunfig = await authBunfig("tarball");
+    const json = {
+      name: "publish-pkg-2",
+      version: "2.2.2",
+      dependencies: {
+        "publish-pkg-2": "2.2.2",
+      },
+    };
+    await Promise.all([
+      rm(join(import.meta.dir, "packages", "publish-pkg-2"), { recursive: true, force: true }),
+      write(packageJson, JSON.stringify(json)),
+      write(join(packageDir, "bunfig.toml"), bunfig),
+    ]);
+
+    await pack(packageDir, env);
+
+    let { out, err, exitCode } = await publish(env, packageDir, "./publish-pkg-2-2.2.2.tgz");
+    expect(err).not.toContain("error:");
+    expect(err).not.toContain("warn:");
+    expect(exitCode).toBe(0);
+
+    await runBunInstall(env, packageDir);
+    expect(await exists(join(packageDir, "node_modules", "publish-pkg-2", "package.json"))).toBeTrue();
+
+    await Promise.all([
+      rm(join(import.meta.dir, "packages", "publish-pkg-2"), { recursive: true, force: true }),
+      rm(join(packageDir, "bun.lockb"), { recursive: true, force: true }),
+      rm(join(packageDir, "node_modules"), { recursive: true, force: true }),
+    ]);
+
+    // now with an absoute path
+    ({ out, err, exitCode } = await publish(env, packageDir, join(packageDir, "publish-pkg-2-2.2.2.tgz")));
+    expect(err).not.toContain("error:");
+    expect(err).not.toContain("warn:");
+    expect(exitCode).toBe(0);
+
+    await runBunInstall(env, packageDir);
+    expect(await file(join(packageDir, "node_modules", "publish-pkg-2", "package.json")).json()).toEqual(json);
+  });
+
+  for (const info of [
+    { user: "bin1", bin: "bin1.js" },
+    { user: "bin2", bin: { bin1: "bin1.js", bin2: "bin2.js" } },
+    { user: "bin3", directories: { bin: "bins" } },
+  ]) {
+    test(`can publish and install binaries with ${JSON.stringify(info)}`, async () => {
+      const publishDir = tmpdirSync();
+      const bunfig = await authBunfig("binaries-" + info.user);
+      console.log({ packageDir, publishDir });
+
+      await Promise.all([
+        rm(join(import.meta.dir, "packages", "publish-pkg-bins"), { recursive: true, force: true }),
+        write(
+          join(publishDir, "package.json"),
+          JSON.stringify({
+            name: "publish-pkg-bins",
+            version: "1.1.1",
+            ...info,
+          }),
+        ),
+        write(join(publishDir, "bunfig.toml"), bunfig),
+        write(join(publishDir, "bin1.js"), `#!/usr/bin/env bun\nconsole.log("bin1!")`),
+        write(join(publishDir, "bin2.js"), `#!/usr/bin/env bun\nconsole.log("bin2!")`),
+        write(join(publishDir, "bins", "bin3.js"), `#!/usr/bin/env bun\nconsole.log("bin3!")`),
+        write(join(publishDir, "bins", "moredir", "bin4.js"), `#!/usr/bin/env bun\nconsole.log("bin4!")`),
+
+        write(
+          packageJson,
+          JSON.stringify({
+            name: "foo",
+            dependencies: {
+              "publish-pkg-bins": "1.1.1",
+            },
+          }),
+        ),
+      ]);
+
+      const { out, err, exitCode } = await publish(env, publishDir);
+      expect(err).not.toContain("error:");
+      expect(err).not.toContain("warn:");
+      expect(out).toContain("+ publish-pkg-bins@1.1.1");
+      expect(exitCode).toBe(0);
+
+      await runBunInstall(env, packageDir);
+
+      const results = await Promise.all([
+        exists(join(packageDir, "node_modules", ".bin", isWindows ? "bin1.bunx" : "bin1")),
+        exists(join(packageDir, "node_modules", ".bin", isWindows ? "bin2.bunx" : "bin2")),
+        exists(join(packageDir, "node_modules", ".bin", isWindows ? "bin3.js.bunx" : "bin3.js")),
+        exists(join(packageDir, "node_modules", ".bin", isWindows ? "bin4.js.bunx" : "bin4.js")),
+        exists(join(packageDir, "node_modules", ".bin", isWindows ? "moredir" : "moredir/bin4.js")),
+        exists(join(packageDir, "node_modules", ".bin", isWindows ? "publish-pkg-bins.bunx" : "publish-pkg-bins")),
+      ]);
+
+      switch (info.user) {
+        case "bin1": {
+          expect(results).toEqual([false, false, false, false, false, true]);
+          break;
+        }
+        case "bin2": {
+          expect(results).toEqual([true, true, false, false, false, false]);
+          break;
+        }
+        case "bin3": {
+          expect(results).toEqual([false, false, true, true, !isWindows, false]);
+          break;
+        }
+      }
+    });
+  }
+
+  test("dependencies are installed", async () => {
+    const publishDir = tmpdirSync();
+    const bunfig = await authBunfig("manydeps");
+    await Promise.all([
+      rm(join(import.meta.dir, "packages", "publish-pkg-deps"), { recursive: true, force: true }),
+      write(
+        join(publishDir, "package.json"),
+        JSON.stringify(
+          {
+            name: "publish-pkg-deps",
+            version: "1.1.1",
+            dependencies: {
+              "no-deps": "1.0.0",
+            },
+            peerDependencies: {
+              "a-dep": "1.0.1",
+            },
+            optionalDependencies: {
+              "basic-1": "1.0.0",
+            },
+          },
+          null,
+          2,
+        ),
+      ),
+      write(join(publishDir, "bunfig.toml"), bunfig),
+      write(
+        packageJson,
+        JSON.stringify({
+          name: "foo",
+          dependencies: {
+            "publish-pkg-deps": "1.1.1",
+          },
+        }),
+      ),
+    ]);
+
+    let { out, err, exitCode } = await publish(env, publishDir);
+    expect(err).not.toContain("error:");
+    expect(err).not.toContain("warn:");
+    expect(out).toContain("+ publish-pkg-deps@1.1.1");
+    expect(exitCode).toBe(0);
+
+    await runBunInstall(env, packageDir);
+
+    const results = await Promise.all([
+      exists(join(packageDir, "node_modules", "no-deps", "package.json")),
+      exists(join(packageDir, "node_modules", "a-dep", "package.json")),
+      exists(join(packageDir, "node_modules", "basic-1", "package.json")),
+    ]);
+
+    expect(results).toEqual([true, true, true]);
+  });
+
+  test("can publish workspace package", async () => {
+    const bunfig = await authBunfig("workspace");
+    const pkgJson = {
+      name: "publish-pkg-3",
+      version: "3.3.3",
+      dependencies: {
+        "publish-pkg-3": "3.3.3",
+      },
+    };
+    await Promise.all([
+      rm(join(import.meta.dir, "packages", "publish-pkg-3"), { recursive: true, force: true }),
+      write(join(packageDir, "bunfig.toml"), bunfig),
+      write(
+        packageJson,
+        JSON.stringify({
+          name: "root",
+          workspaces: ["packages/*"],
+        }),
+      ),
+      write(join(packageDir, "packages", "publish-pkg-3", "package.json"), JSON.stringify(pkgJson)),
+    ]);
+
+    await publish(env, join(packageDir, "packages", "publish-pkg-3"));
+
+    await write(packageJson, JSON.stringify({ name: "root", "dependencies": { "publish-pkg-3": "3.3.3" } }));
+
+    await runBunInstall(env, packageDir);
+
+    expect(await file(join(packageDir, "node_modules", "publish-pkg-3", "package.json")).json()).toEqual(pkgJson);
+  });
+
+  describe("--dry-run", async () => {
+    test("does not publish", async () => {
+      const bunfig = await authBunfig("dryrun");
+      await Promise.all([
+        rm(join(import.meta.dir, "packages", "dry-run-1"), { recursive: true, force: true }),
+        write(join(packageDir, "bunfig.toml"), bunfig),
+        write(
+          packageJson,
+          JSON.stringify({
+            name: "dry-run-1",
+            version: "1.1.1",
+            dependencies: {
+              "dry-run-1": "1.1.1",
+            },
+          }),
+        ),
+      ]);
+
+      const { out, err, exitCode } = await publish(env, packageDir, "--dry-run");
+      expect(exitCode).toBe(0);
+
+      expect(await exists(join(import.meta.dir, "packages", "dry-run-1"))).toBeFalse();
+    });
+    test("does not publish from tarball path", async () => {
+      const bunfig = await authBunfig("dryruntarball");
+      await Promise.all([
+        rm(join(import.meta.dir, "packages", "dry-run-2"), { recursive: true, force: true }),
+        write(join(packageDir, "bunfig.toml"), bunfig),
+        write(
+          packageJson,
+          JSON.stringify({
+            name: "dry-run-2",
+            version: "2.2.2",
+            dependencies: {
+              "dry-run-2": "2.2.2",
+            },
+          }),
+        ),
+      ]);
+
+      await pack(packageDir, env);
+
+      const { out, err, exitCode } = await publish(env, packageDir, "./dry-run-2-2.2.2.tgz", "--dry-run");
+      expect(exitCode).toBe(0);
+
+      expect(await exists(join(import.meta.dir, "packages", "dry-run-2"))).toBeFalse();
+    });
+  });
+
+  describe("lifecycle scripts", async () => {
+    const script = `const fs = require("fs");
+    fs.writeFileSync(process.argv[2] + ".txt", \`
+prepublishOnly: \${fs.existsSync("prepublishOnly.txt")}
+publish: \${fs.existsSync("publish.txt")}
+postpublish: \${fs.existsSync("postpublish.txt")}
+prepack: \${fs.existsSync("prepack.txt")}
+prepare: \${fs.existsSync("prepare.txt")}
+postpack: \${fs.existsSync("postpack.txt")}\`)`;
+    const json = {
+      name: "publish-pkg-4",
+      version: "4.4.4",
+      scripts: {
+        // should happen in this order
+        "prepublishOnly": `${bunExe()} script.js prepublishOnly`,
+        "prepack": `${bunExe()} script.js prepack`,
+        "prepare": `${bunExe()} script.js prepare`,
+        "postpack": `${bunExe()} script.js postpack`,
+        "publish": `${bunExe()} script.js publish`,
+        "postpublish": `${bunExe()} script.js postpublish`,
+      },
+      dependencies: {
+        "publish-pkg-4": "4.4.4",
+      },
+    };
+
+    for (const arg of ["", "--dry-run"]) {
+      test(`should run in order${arg ? " (--dry-run)" : ""}`, async () => {
+        const bunfig = await authBunfig("lifecycle" + (arg ? "dry" : ""));
+        await Promise.all([
+          rm(join(import.meta.dir, "packages", "publish-pkg-4"), { recursive: true, force: true }),
+          write(packageJson, JSON.stringify(json)),
+          write(join(packageDir, "script.js"), script),
+          write(join(packageDir, "bunfig.toml"), bunfig),
+        ]);
+
+        const { out, err, exitCode } = await publish(env, packageDir, arg);
+        expect(exitCode).toBe(0);
+
+        const results = await Promise.all([
+          file(join(packageDir, "prepublishOnly.txt")).text(),
+          file(join(packageDir, "prepack.txt")).text(),
+          file(join(packageDir, "prepare.txt")).text(),
+          file(join(packageDir, "postpack.txt")).text(),
+          file(join(packageDir, "publish.txt")).text(),
+          file(join(packageDir, "postpublish.txt")).text(),
+        ]);
+
+        expect(results).toEqual([
+          "\nprepublishOnly: false\npublish: false\npostpublish: false\nprepack: false\nprepare: false\npostpack: false",
+          "\nprepublishOnly: true\npublish: false\npostpublish: false\nprepack: false\nprepare: false\npostpack: false",
+          "\nprepublishOnly: true\npublish: false\npostpublish: false\nprepack: true\nprepare: false\npostpack: false",
+          "\nprepublishOnly: true\npublish: false\npostpublish: false\nprepack: true\nprepare: true\npostpack: false",
+          "\nprepublishOnly: true\npublish: false\npostpublish: false\nprepack: true\nprepare: true\npostpack: true",
+          "\nprepublishOnly: true\npublish: true\npostpublish: false\nprepack: true\nprepare: true\npostpack: true",
+        ]);
+      });
+    }
+
+    test("--ignore-scripts", async () => {
+      const bunfig = await authBunfig("ignorescripts");
+      await Promise.all([
+        rm(join(import.meta.dir, "packages", "publish-pkg-5"), { recursive: true, force: true }),
+        write(packageJson, JSON.stringify(json)),
+        write(join(packageDir, "script.js"), script),
+        write(join(packageDir, "bunfig.toml"), bunfig),
+      ]);
+
+      const { out, err, exitCode } = await publish(env, packageDir, "--ignore-scripts");
+      expect(exitCode).toBe(0);
+
+      const results = await Promise.all([
+        exists(join(packageDir, "prepublishOnly.txt")),
+        exists(join(packageDir, "prepack.txt")),
+        exists(join(packageDir, "prepare.txt")),
+        exists(join(packageDir, "postpack.txt")),
+        exists(join(packageDir, "publish.txt")),
+        exists(join(packageDir, "postpublish.txt")),
+      ]);
+
+      expect(results).toEqual([false, false, false, false, false, false]);
+    });
+  });
+
+  test("attempting to publish a private package should fail", async () => {
+    const bunfig = await authBunfig("privatepackage");
+    await Promise.all([
+      rm(join(import.meta.dir, "packages", "publish-pkg-6"), { recursive: true, force: true }),
+      write(
+        packageJson,
+        JSON.stringify({
+          name: "publish-pkg-6",
+          version: "6.6.6",
+          private: true,
+          dependencies: {
+            "publish-pkg-6": "6.6.6",
+          },
+        }),
+      ),
+      write(join(packageDir, "bunfig.toml"), bunfig),
+    ]);
+
+    // should fail
+    let { out, err, exitCode } = await publish(env, packageDir);
+    expect(exitCode).toBe(1);
+    expect(err).toContain("error: attempted to publish a private package");
+    expect(await exists(join(import.meta.dir, "packages", "publish-pkg-6-6.6.6.tgz"))).toBeFalse();
+
+    // try tarball
+    await pack(packageDir, env);
+    ({ out, err, exitCode } = await publish(env, packageDir, "./publish-pkg-6-6.6.6.tgz"));
+    expect(exitCode).toBe(1);
+    expect(err).toContain("error: attempted to publish a private package");
+    expect(await exists(join(packageDir, "publish-pkg-6-6.6.6.tgz"))).toBeTrue();
+  });
+
+  describe("access", async () => {
+    test("--access", async () => {
+      const bunfig = await authBunfig("accessflag");
+      await Promise.all([
+        rm(join(import.meta.dir, "packages", "publish-pkg-7"), { recursive: true, force: true }),
+        write(join(packageDir, "bunfig.toml"), bunfig),
+        write(
+          packageJson,
+          JSON.stringify({
+            name: "publish-pkg-7",
+            version: "7.7.7",
+          }),
+        ),
+      ]);
+
+      // should fail
+      let { out, err, exitCode } = await publish(env, packageDir, "--access", "restricted");
+      expect(exitCode).toBe(1);
+      expect(err).toContain("error: unable to restrict access to unscoped package");
+
+      ({ out, err, exitCode } = await publish(env, packageDir, "--access", "public"));
+      expect(exitCode).toBe(0);
+
+      expect(await exists(join(import.meta.dir, "packages", "publish-pkg-7"))).toBeTrue();
+    });
+
+    for (const access of ["restricted", "public"]) {
+      test(`access ${access}`, async () => {
+        const bunfig = await authBunfig("access" + access);
+
+        const pkgJson = {
+          name: "@secret/publish-pkg-8",
+          version: "8.8.8",
+          dependencies: {
+            "@secret/publish-pkg-8": "8.8.8",
+          },
+          publishConfig: {
+            access,
+          },
+        };
+
+        await Promise.all([
+          rm(join(import.meta.dir, "packages", "@secret", "publish-pkg-8"), { recursive: true, force: true }),
+          write(join(packageDir, "bunfig.toml"), bunfig),
+          write(packageJson, JSON.stringify(pkgJson)),
+        ]);
+
+        let { out, err, exitCode } = await publish(env, packageDir);
+        expect(exitCode).toBe(0);
+
+        await runBunInstall(env, packageDir);
+
+        expect(await file(join(packageDir, "node_modules", "@secret", "publish-pkg-8", "package.json")).json()).toEqual(
+          pkgJson,
+        );
+      });
+    }
+  });
+
+  describe("tag", async () => {
+    test("can publish with a tag", async () => {
+      const bunfig = await authBunfig("simpletag");
+      const pkgJson = {
+        name: "publish-pkg-9",
+        version: "9.9.9",
+        dependencies: {
+          "publish-pkg-9": "simpletag",
+        },
+      };
+      await Promise.all([
+        rm(join(import.meta.dir, "packages", "publish-pkg-9"), { recursive: true, force: true }),
+        write(join(packageDir, "bunfig.toml"), bunfig),
+        write(packageJson, JSON.stringify(pkgJson)),
+      ]);
+
+      let { out, err, exitCode } = await publish(env, packageDir, "--tag", "simpletag");
+      expect(exitCode).toBe(0);
+
+      await runBunInstall(env, packageDir);
+      expect(await file(join(packageDir, "node_modules", "publish-pkg-9", "package.json")).json()).toEqual(pkgJson);
+    });
+  });
+});
+
 describe("package.json indentation", async () => {
   test("works for root and workspace packages", async () => {
     await Promise.all([
       // 5 space indentation
-      write(join(packageDir, "package.json"), `\n{\n\n     "name": "foo",\n"workspaces": ["packages/*"]\n}`),
+      write(packageJson, `\n{\n\n     "name": "foo",\n"workspaces": ["packages/*"]\n}`),
       // 1 tab indentation
       write(join(packageDir, "packages", "bar", "package.json"), `\n{\n\n\t"name": "bar",\n}`),
     ]);
@@ -443,7 +1663,7 @@ describe("package.json indentation", async () => {
     expect(await exited).toBe(0);
     assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-    const rootPackageJson = await file(join(packageDir, "package.json")).text();
+    const rootPackageJson = await file(packageJson).text();
 
     expect(rootPackageJson).toBe(
       `{\n     "name": "foo",\n     "workspaces": ["packages/*"],\n     "dependencies": {\n          "no-deps": "^2.0.0"\n     }\n}`,
@@ -461,17 +1681,30 @@ describe("package.json indentation", async () => {
     expect(await exited).toBe(0);
     assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-    expect(await file(join(packageDir, "package.json")).text()).toBe(rootPackageJson);
+    expect(await file(packageJson).text()).toBe(rootPackageJson);
     const workspacePackageJson = await file(join(packageDir, "packages", "bar", "package.json")).text();
     expect(workspacePackageJson).toBe(`{\n\t"name": "bar",\n\t"dependencies": {\n\t\t"no-deps": "^2.0.0"\n\t}\n}`);
   });
+
+  test("install maintains indentation", async () => {
+    await write(packageJson, `{\n  "dependencies": {}\n  }\n`);
+    let { exited } = spawn({
+      cmd: [bunExe(), "add", "no-deps"],
+      cwd: packageDir,
+      stdout: "ignore",
+      stderr: "ignore",
+      env,
+    });
+    expect(await exited).toBe(0);
+    expect(await file(packageJson).text()).toBe(`{\n  "dependencies": {\n    "no-deps": "^2.0.0"\n  }\n}\n`);
+  });
 });
 
 describe("optionalDependencies", () => {
   for (const optional of [true, false]) {
     test(`exit code is ${optional ? 0 : 1} when ${optional ? "optional" : ""} dependency tarball is missing`, async () => {
       await write(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           [optional ? "optionalDependencies" : "dependencies"]: {
@@ -500,7 +1733,7 @@ describe("optionalDependencies", () => {
   for (const rootOptional of [true, false]) {
     test(`exit code is 0 when ${rootOptional ? "root" : ""} optional dependency does not exist in registry`, async () => {
       await write(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           [rootOptional ? "optionalDependencies" : "dependencies"]: {
@@ -518,11 +1751,92 @@ describe("optionalDependencies", () => {
       expect(err).toMatch(`warn: GET http://localhost:${port}/this-package-does-not-exist-in-the-registry - 404`);
     });
   }
+  test("should not install optional deps if false in bunfig", async () => {
+    await writeFile(
+      join(packageDir, "bunfig.toml"),
+      `
+  [install]
+  cache = "${join(packageDir, ".bun-cache")}"
+  optional = false
+  registry = "http://localhost:${port}/"
+  `,
+    );
+    await writeFile(
+      packageJson,
+      JSON.stringify(
+        {
+          name: "publish-pkg-deps",
+          version: "1.1.1",
+          dependencies: {
+            "no-deps": "1.0.0",
+          },
+          optionalDependencies: {
+            "basic-1": "1.0.0",
+          },
+        },
+        null,
+        2,
+      ),
+    );
+
+    const { stdout, stderr, exited } = spawn({
+      cmd: [bunExe(), "install"],
+      cwd: packageDir,
+      stdout: "pipe",
+      stdin: "pipe",
+      stderr: "pipe",
+      env,
+    });
+
+    const err = await new Response(stderr).text();
+    const out = await new Response(stdout).text();
+    expect(err).toContain("Saved lockfile");
+    expect(err).not.toContain("not found");
+    expect(err).not.toContain("error:");
+    expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
+      "",
+      expect.stringContaining("+ no-deps@1.0.0"),
+      "",
+      "1 package installed",
+    ]);
+    expect(await readdirSorted(join(packageDir, "node_modules"))).toEqual(["no-deps"]);
+    expect(await exited).toBe(0);
+    assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
+  });
+
+  test("lifecycle scripts failures from transitive dependencies are ignored", async () => {
+    // Dependency with a transitive optional dependency that fails during its preinstall script.
+    await write(
+      packageJson,
+      JSON.stringify({
+        name: "foo",
+        version: "2.2.2",
+        dependencies: {
+          "optional-lifecycle-fail": "1.1.1",
+        },
+        trustedDependencies: ["lifecycle-fail"],
+      }),
+    );
+
+    const { err, exited } = await runBunInstall(env, packageDir);
+    expect(err).not.toContain("error:");
+    expect(err).not.toContain("warn:");
+    expect(await exited).toBe(0);
+    assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
+
+    expect(
+      await Promise.all([
+        exists(join(packageDir, "node_modules", "optional-lifecycle-fail", "package.json")),
+        exists(join(packageDir, "node_modules", "lifecycle-fail", "package.json")),
+      ]),
+    ).toEqual([true, false]);
+  });
 });
 
 test("tarball override does not crash", async () => {
   await write(
-    join(packageDir, "package.json"),
+    packageJson,
     JSON.stringify({
       name: "foo",
       dependencies: {
@@ -553,7 +1867,7 @@ describe.each(["--production", "without --production"])("%s", flag => {
   if (prod) {
     test("modifying package.json with --production should not save lockfile", async () => {
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.0.0",
@@ -650,7 +1964,7 @@ describe.each(["--production", "without --production"])("%s", flag => {
 
   test(`should prefer ${order[+prod % 2]} over ${order[1 - (+prod % 2)]}`, async () => {
     await writeFile(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "foo",
         version: "1.0.0",
@@ -754,7 +2068,7 @@ test("hardlinks on windows dont fail with long paths", async () => {
   );
 
   await writeFile(
-    join(packageDir, "package.json"),
+    packageJson,
     JSON.stringify({
       name: "foo",
       version: "1.2.3",
@@ -780,6 +2094,7 @@ test("hardlinks on windows dont fail with long paths", async () => {
   expect(err).not.toContain("not found");
   expect(err).not.toContain("error:");
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa@a-package",
     "",
@@ -791,7 +2106,7 @@ test("hardlinks on windows dont fail with long paths", async () => {
 
 test("basic 1", async () => {
   await writeFile(
-    join(packageDir, "package.json"),
+    packageJson,
     JSON.stringify({
       name: "foo",
       version: "1.0.0",
@@ -814,6 +2129,7 @@ test("basic 1", async () => {
   expect(err).not.toContain("not found");
   expect(err).not.toContain("error:");
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ basic-1@1.0.0",
     "",
@@ -844,6 +2160,7 @@ test("basic 1", async () => {
   expect(err).not.toContain("not found");
   expect(err).not.toContain("error:");
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ basic-1@1.0.0",
     "",
@@ -865,7 +2182,7 @@ registry = "http://localhost:${port}"
       `,
     ),
     write(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "foo",
         dependencies: {
@@ -910,7 +2227,7 @@ cache = "${cacheDir}"
 
 test("dependency from root satisfies range from dependency", async () => {
   await writeFile(
-    join(packageDir, "package.json"),
+    packageJson,
     JSON.stringify({
       name: "foo",
       version: "1.0.0",
@@ -936,8 +2253,9 @@ test("dependency from root satisfies range from dependency", async () => {
   expect(err).not.toContain("not found");
   expect(err).not.toContain("error:");
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
-    "+ no-deps@1.0.0",
+    expect.stringContaining("+ no-deps@1.0.0"),
     "+ one-range-dep@1.0.0",
     "",
     "2 packages installed",
@@ -966,8 +2284,9 @@ test("dependency from root satisfies range from dependency", async () => {
   expect(err).not.toContain("not found");
   expect(err).not.toContain("error:");
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
-    "+ no-deps@1.0.0",
+    expect.stringContaining("+ no-deps@1.0.0"),
     "+ one-range-dep@1.0.0",
     "",
     "2 packages installed",
@@ -996,7 +2315,7 @@ test("duplicate names and versions in a manifest do not install incorrect packag
    * (`a-dep@1.0.1` would become `no-deps@1.0.1`)
    */
   await write(
-    join(packageDir, "package.json"),
+    packageJson,
     JSON.stringify({
       name: "foo",
       dependencies: {
@@ -1039,7 +2358,7 @@ describe("peerDependency index out of bounds", async () => {
       if (firstDep === secondDep) continue;
       test(`replacing ${firstDep} with ${secondDep}`, async () => {
         await write(
-          join(packageDir, "package.json"),
+          packageJson,
           JSON.stringify({
             name: "foo",
             dependencies: {
@@ -1069,7 +2388,7 @@ describe("peerDependency index out of bounds", async () => {
           rm(join(packageDir, "node_modules"), { recursive: true, force: true }),
           rm(join(packageDir, ".bun-cache"), { recursive: true, force: true }),
           write(
-            join(packageDir, "package.json"),
+            packageJson,
             JSON.stringify({
               name: "foo",
               dependencies: {
@@ -1106,7 +2425,7 @@ describe("peerDependency index out of bounds", async () => {
   // task is created for it.
   test("optional", async () => {
     await write(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "foo",
         dependencies: {
@@ -1122,7 +2441,7 @@ describe("peerDependency index out of bounds", async () => {
     // update version and delete node_modules and cache
     await Promise.all([
       write(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           dependencies: {
@@ -1146,7 +2465,7 @@ describe("peerDependency index out of bounds", async () => {
 
 test("peerDependency in child npm dependency should not maintain old version when package is upgraded", async () => {
   await writeFile(
-    join(packageDir, "package.json"),
+    packageJson,
     JSON.stringify({
       name: "foo",
       version: "1.0.0",
@@ -1172,8 +2491,9 @@ test("peerDependency in child npm dependency should not maintain old version whe
   expect(err).not.toContain("not found");
   expect(err).not.toContain("error:");
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
-    "+ no-deps@1.0.0",
+    expect.stringContaining("+ no-deps@1.0.0"),
     "+ peer-deps-fixed@1.0.0",
     "",
     "2 packages installed",
@@ -1186,7 +2506,7 @@ test("peerDependency in child npm dependency should not maintain old version whe
   assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
   await writeFile(
-    join(packageDir, "package.json"),
+    packageJson,
     JSON.stringify({
       name: "foo",
       version: "1.0.0",
@@ -1216,8 +2536,9 @@ test("peerDependency in child npm dependency should not maintain old version whe
   } as any);
   expect(await exists(join(packageDir, "node_modules", "peer-deps-fixed", "node_modules"))).toBeFalse();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
-    "+ no-deps@1.0.1",
+    expect.stringContaining("+ no-deps@1.0.1"),
     "",
     "1 package installed",
   ]);
@@ -1227,7 +2548,7 @@ test("peerDependency in child npm dependency should not maintain old version whe
 
 test("package added after install", async () => {
   await writeFile(
-    join(packageDir, "package.json"),
+    packageJson,
     JSON.stringify({
       name: "foo",
       version: "1.0.0",
@@ -1252,6 +2573,7 @@ test("package added after install", async () => {
   expect(err).not.toContain("not found");
   expect(err).not.toContain("error:");
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ one-range-dep@1.0.0",
     "",
@@ -1267,7 +2589,7 @@ test("package added after install", async () => {
   // add `no-deps` to root package.json with a smaller but still compatible
   // version for `one-range-dep`.
   await writeFile(
-    join(packageDir, "package.json"),
+    packageJson,
     JSON.stringify({
       name: "foo",
       version: "1.0.0",
@@ -1293,8 +2615,9 @@ test("package added after install", async () => {
   expect(err).not.toContain("not found");
   expect(err).not.toContain("error:");
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
-    "+ no-deps@1.0.0",
+    expect.stringContaining("+ no-deps@1.0.0"),
     "",
     "2 packages installed",
   ]);
@@ -1328,8 +2651,9 @@ test("package added after install", async () => {
   expect(err).not.toContain("not found");
   expect(err).not.toContain("error:");
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
-    "+ no-deps@1.0.0",
+    expect.stringContaining("+ no-deps@1.0.0"),
     "+ one-range-dep@1.0.0",
     "",
     "3 packages installed",
@@ -1341,7 +2665,7 @@ test("package added after install", async () => {
 test("--production excludes devDependencies in workspaces", async () => {
   await Promise.all([
     write(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "foo",
         workspaces: ["packages/*"],
@@ -1388,8 +2712,9 @@ test("--production excludes devDependencies in workspaces", async () => {
   assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
-    "+ no-deps@1.0.0",
+    expect.stringContaining("+ no-deps@1.0.0"),
     "",
     "4 packages installed",
   ]);
@@ -1407,9 +2732,10 @@ test("--production excludes devDependencies in workspaces", async () => {
   assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ a1@1.0.0",
-    "+ no-deps@1.0.0",
+    expect.stringContaining("+ no-deps@1.0.0"),
     "",
     "7 packages installed",
   ]);
@@ -1418,8 +2744,9 @@ test("--production excludes devDependencies in workspaces", async () => {
   assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
-    "+ no-deps@1.0.0",
+    expect.stringContaining("+ no-deps@1.0.0"),
     "",
     "4 packages installed",
   ]);
@@ -1433,7 +2760,7 @@ test("--production excludes devDependencies in workspaces", async () => {
 
 test("--production without a lockfile will install and not save lockfile", async () => {
   await writeFile(
-    join(packageDir, "package.json"),
+    packageJson,
     JSON.stringify({
       name: "foo",
       version: "1.2.3",
@@ -1458,8 +2785,9 @@ test("--production without a lockfile will install and not save lockfile", async
   expect(err).not.toContain("not found");
   expect(err).not.toContain("error:");
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
-    "+ no-deps@1.0.0",
+    expect.stringContaining("+ no-deps@1.0.0"),
     "",
     "1 package installed",
   ]);
@@ -1475,7 +2803,7 @@ describe("binaries", () => {
       test("existing non-symlink", async () => {
         await Promise.all([
           write(
-            join(packageDir, "package.json"),
+            packageJson,
             JSON.stringify({
               name: "foo",
               dependencies: {
@@ -1504,7 +2832,7 @@ describe("binaries", () => {
         "uses-what-bin": "1.5.0",
       },
     };
-    await writeFile(join(packageDir, "package.json"), JSON.stringify(json));
+    await writeFile(packageJson, JSON.stringify(json));
 
     var { stdout, stderr, exited } = spawn({
       cmd: [bunExe(), "install"],
@@ -1520,12 +2848,13 @@ describe("binaries", () => {
     expect(err).toContain("Saved lockfile");
     expect(err).not.toContain("not found");
     expect(err).not.toContain("error:");
-    expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect(out.replace(/\s*\[[0-9\.]+m?s\]$/m, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
-      "+ uses-what-bin@1.5.0",
-      "+ what-bin@1.0.0",
+      expect.stringContaining("+ uses-what-bin@1.5.0"),
+      expect.stringContaining("+ what-bin@1.0.0"),
       "",
-      expect.stringContaining("3 packages installed"),
+      "3 packages installed",
       "",
       "Blocked 1 postinstall. Run `bun pm untrusted` for details.",
       "",
@@ -1549,12 +2878,13 @@ describe("binaries", () => {
     expect(err).not.toContain("Saved lockfile");
     expect(err).not.toContain("not found");
     expect(err).not.toContain("error:");
-    expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect(out.replace(/\s*\[[0-9\.]+m?s\]$/m, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
-      "+ uses-what-bin@1.5.0",
-      "+ what-bin@1.0.0",
+      expect.stringContaining("+ uses-what-bin@1.5.0"),
+      expect.stringContaining("+ what-bin@1.0.0"),
       "",
-      expect.stringContaining("3 packages installed"),
+      "3 packages installed",
       "",
       "Blocked 1 postinstall. Run `bun pm untrusted` for details.",
       "",
@@ -1566,7 +2896,7 @@ describe("binaries", () => {
   test("will link binaries for packages installed multiple times", async () => {
     await Promise.all([
       write(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.0.0",
@@ -1615,7 +2945,7 @@ describe("binaries", () => {
 
   test("it should re-symlink binaries that become invalid when updating package versions", async () => {
     await writeFile(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "foo",
         version: "1.0.0",
@@ -1643,8 +2973,9 @@ describe("binaries", () => {
     expect(err).not.toContain("not found");
     expect(err).not.toContain("error:");
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
-      "+ bin-change-dir@1.0.0",
+      expect.stringContaining("+ bin-change-dir@1.0.0"),
       "",
       "1 package installed",
     ]);
@@ -1655,7 +2986,7 @@ describe("binaries", () => {
     expect(await exists(join(packageDir, "bin-1.0.1.txt"))).toBeFalse();
 
     await writeFile(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "foo",
         version: "1.0.0",
@@ -1683,8 +3014,9 @@ describe("binaries", () => {
     expect(err).not.toContain("not found");
     expect(err).not.toContain("error:");
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
-      "+ bin-change-dir@1.0.1",
+      expect.stringContaining("+ bin-change-dir@1.0.1"),
       "",
       "1 package installed",
     ]);
@@ -1694,6 +3026,65 @@ describe("binaries", () => {
     expect(await file(join(packageDir, "bin-1.0.0.txt")).text()).toEqual("success!");
     expect(await file(join(packageDir, "bin-1.0.1.txt")).text()).toEqual("success!");
   });
+
+  test("will only link global binaries for requested packages", async () => {
+    await Promise.all([
+      write(
+        join(packageDir, "bunfig.toml"),
+        `
+      [install]
+      cache = false
+      registry = "http://localhost:${port}/"
+      globalBinDir = "${join(packageDir, "global-bin-dir").replace(/\\/g, "\\\\")}"
+      `,
+      ),
+      ,
+    ]);
+
+    let { stdout, stderr, exited } = spawn({
+      cmd: [bunExe(), "i", "-g", `--config=${join(packageDir, "bunfig.toml")}`, "uses-what-bin"],
+      cwd: packageDir,
+      stdout: "pipe",
+      stderr: "pipe",
+      env: { ...env, BUN_INSTALL: join(packageDir, "global-install-dir") },
+    });
+
+    let err = await Bun.readableStreamToText(stderr);
+    expect(err).not.toContain("error:");
+    let out = await Bun.readableStreamToText(stdout);
+    expect(out).toContain("uses-what-bin@1.5.0");
+    expect(await exited).toBe(0);
+
+    expect(await exists(join(packageDir, "global-bin-dir", "what-bin"))).toBeFalse();
+
+    ({ stdout, stderr, exited } = spawn({
+      cmd: [bunExe(), "i", "-g", `--config=${join(packageDir, "bunfig.toml")}`, "what-bin"],
+      cwd: packageDir,
+      stdout: "pipe",
+      stderr: "pipe",
+      env: { ...env, BUN_INSTALL: join(packageDir, "global-install-dir") },
+    }));
+
+    err = await Bun.readableStreamToText(stderr);
+    expect(err).not.toContain("error:");
+    out = await Bun.readableStreamToText(stdout);
+
+    expect(out).toContain("what-bin@1.5.0");
+    expect(await exited).toBe(0);
+
+    // now `what-bin` should be installed in the global bin directory
+    if (isWindows) {
+      expect(
+        await Promise.all([
+          exists(join(packageDir, "global-bin-dir", "what-bin.exe")),
+          exists(join(packageDir, "global-bin-dir", "what-bin.bunx")),
+        ]),
+      ).toEqual([true, true]);
+    } else {
+      expect(await exists(join(packageDir, "global-bin-dir", "what-bin"))).toBeTrue();
+    }
+  });
+
   for (const global of [false, true]) {
     test(`bin types${global ? " (global)" : ""}`, async () => {
       if (global) {
@@ -1708,7 +3099,7 @@ describe("binaries", () => {
         );
       } else {
         await write(
-          join(packageDir, "package.json"),
+          packageJson,
           JSON.stringify({
             name: "foo",
           }),
@@ -1768,7 +3159,7 @@ describe("binaries", () => {
   test("it will skip (without errors) if a folder from `directories.bin` does not exist", async () => {
     await Promise.all([
       write(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           dependencies: {
@@ -1792,10 +3183,128 @@ describe("binaries", () => {
   });
 });
 
+test("--config cli flag works", async () => {
+  await Promise.all([
+    write(
+      join(packageDir, "package.json"),
+      JSON.stringify({
+        name: "foo",
+        dependencies: {
+          "no-deps": "1.0.0",
+        },
+        devDependencies: {
+          "a-dep": "1.0.1",
+        },
+      }),
+    ),
+    write(
+      join(packageDir, "bunfig2.toml"),
+      `
+[install]
+cache = "${join(packageDir, ".bun-cache")}"
+registry = "http://localhost:${port}/"
+dev = false
+`,
+    ),
+  ]);
+
+  // should install dev dependencies
+  let { exited } = spawn({
+    cmd: [bunExe(), "i"],
+    cwd: packageDir,
+    stdout: "pipe",
+    stderr: "pipe",
+    env,
+  });
+
+  expect(await exited).toBe(0);
+  expect(await file(join(packageDir, "node_modules", "a-dep", "package.json")).json()).toEqual({
+    name: "a-dep",
+    version: "1.0.1",
+  });
+
+  await rm(join(packageDir, "node_modules"), { recursive: true, force: true });
+
+  // should not install dev dependencies
+  ({ exited } = spawn({
+    cmd: [bunExe(), "i", "--config=bunfig2.toml"],
+    cwd: packageDir,
+    stdout: "pipe",
+    stderr: "pipe",
+    env,
+  }));
+
+  expect(await exited).toBe(0);
+  expect(await exists(join(packageDir, "node_modules", "a-dep"))).toBeFalse();
+});
+
+test("it should invalid cached package if package.json is missing", async () => {
+  await Promise.all([
+    write(
+      packageJson,
+      JSON.stringify({
+        name: "foo",
+        dependencies: {
+          "no-deps": "2.0.0",
+        },
+      }),
+    ),
+  ]);
+
+  let { out } = await runBunInstall(env, packageDir);
+  expect(out).toContain("+ no-deps@2.0.0");
+
+  // node_modules and cache should be populated
+  expect(
+    await Promise.all([
+      readdirSorted(join(packageDir, "node_modules", "no-deps")),
+      readdirSorted(join(packageDir, ".bun-cache", "no-deps@2.0.0@@localhost@@@1")),
+    ]),
+  ).toEqual([
+    ["index.js", "package.json"],
+    ["index.js", "package.json"],
+  ]);
+
+  // with node_modules package.json deleted, the package should be reinstalled
+  await rm(join(packageDir, "node_modules", "no-deps", "package.json"));
+  ({ out } = await runBunInstall(env, packageDir, { savesLockfile: false }));
+  expect(out).toContain("+ no-deps@2.0.0");
+
+  // another install is a no-op
+  ({ out } = await runBunInstall(env, packageDir, { savesLockfile: false }));
+  expect(out).not.toContain("+ no-deps@2.0.0");
+
+  // with cache package.json deleted, install is a no-op and cache is untouched
+  await rm(join(packageDir, ".bun-cache", "no-deps@2.0.0@@localhost@@@1", "package.json"));
+  ({ out } = await runBunInstall(env, packageDir, { savesLockfile: false }));
+  expect(out).not.toContain("+ no-deps@2.0.0");
+  expect(
+    await Promise.all([
+      readdirSorted(join(packageDir, "node_modules", "no-deps")),
+      readdirSorted(join(packageDir, ".bun-cache", "no-deps@2.0.0@@localhost@@@1")),
+    ]),
+  ).toEqual([["index.js", "package.json"], ["index.js"]]);
+
+  // now with node_modules package.json deleted, the package AND the cache should
+  // be repopulated
+  await rm(join(packageDir, "node_modules", "no-deps", "package.json"));
+  ({ out } = await runBunInstall(env, packageDir, { savesLockfile: false }));
+  expect(out).toContain("+ no-deps@2.0.0");
+  expect(
+    await Promise.all([
+      readdirSorted(join(packageDir, "node_modules", "no-deps")),
+      readdirSorted(join(packageDir, ".bun-cache", "no-deps@2.0.0@@localhost@@@1")),
+    ]),
+  ).toEqual([
+    ["index.js", "package.json"],
+    ["index.js", "package.json"],
+  ]);
+});
+
 test("it should install with missing bun.lockb, node_modules, and/or cache", async () => {
   // first clean install
   await writeFile(
-    join(packageDir, "package.json"),
+    packageJson,
     JSON.stringify({
       name: "foo",
       version: "1.0.0",
@@ -1830,22 +3339,23 @@ test("it should install with missing bun.lockb, node_modules, and/or cache", asy
   expect(err).toContain("Saved lockfile");
   expect(err).not.toContain("not found");
   expect(err).not.toContain("error:");
-  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+  expect(out.replace(/\s*\[[0-9\.]+m?s\]$/m, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ dep-loop-entry@1.0.0",
-    "+ dep-with-tags@3.0.0",
+    expect.stringContaining("+ dep-with-tags@3.0.0"),
     "+ dev-deps@1.0.0",
     "+ left-pad@1.0.0",
     "+ native@1.0.0",
     "+ no-deps-bins@2.0.0",
-    "+ one-fixed-dep@2.0.0",
+    expect.stringContaining("+ one-fixed-dep@2.0.0"),
     "+ optional-native@1.0.0",
     "+ peer-deps-too@1.0.0",
     "+ two-range-deps@1.0.0",
-    "+ uses-what-bin@1.5.0",
-    "+ what-bin@1.0.0",
+    expect.stringContaining("+ uses-what-bin@1.5.0"),
+    expect.stringContaining("+ what-bin@1.0.0"),
     "",
-    expect.stringContaining("19 packages installed"),
+    "19 packages installed",
     "",
     "Blocked 1 postinstall. Run `bun pm untrusted` for details.",
     "",
@@ -1873,10 +3383,11 @@ test("it should install with missing bun.lockb, node_modules, and/or cache", asy
   expect(err).not.toContain("Saved lockfile");
   expect(err).not.toContain("not found");
   expect(err).not.toContain("error:");
-  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+  expect(out.replace(/\s*\[[0-9\.]+m?s\]$/m, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ dep-loop-entry@1.0.0",
-    "+ dep-with-tags@3.0.0",
+    expect.stringContaining("+ dep-with-tags@3.0.0"),
     "+ dev-deps@1.0.0",
     "+ left-pad@1.0.0",
     "+ native@1.0.0",
@@ -1885,10 +3396,10 @@ test("it should install with missing bun.lockb, node_modules, and/or cache", asy
     "+ optional-native@1.0.0",
     "+ peer-deps-too@1.0.0",
     "+ two-range-deps@1.0.0",
-    "+ uses-what-bin@1.5.0",
-    "+ what-bin@1.0.0",
+    expect.stringContaining("+ uses-what-bin@1.5.0"),
+    expect.stringContaining("+ what-bin@1.0.0"),
     "",
-    expect.stringContaining("19 packages installed"),
+    "19 packages installed",
     "",
     "Blocked 1 postinstall. Run `bun pm untrusted` for details.",
     "",
@@ -1930,6 +3441,7 @@ test("it should install with missing bun.lockb, node_modules, and/or cache", asy
     expect(err).not.toContain("not found");
     expect(err).not.toContain("error:");
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       expect.stringContaining("Checked 19 installs across 23 packages (no changes)"),
     ]);
@@ -1956,6 +3468,7 @@ test("it should install with missing bun.lockb, node_modules, and/or cache", asy
   expect(err).not.toContain("not found");
   expect(err).not.toContain("error:");
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     expect.stringContaining("Checked 19 installs across 23 packages (no changes)"),
   ]);
@@ -1984,6 +3497,7 @@ test("it should install with missing bun.lockb, node_modules, and/or cache", asy
   expect(err).not.toContain("not found");
   expect(err).not.toContain("error:");
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     expect.stringContaining("Checked 19 installs across 23 packages (no changes)"),
   ]);
@@ -2072,7 +3586,7 @@ describe("hoisting", async () => {
   for (const { dependencies, expected, situation } of tests) {
     test(`it should hoist ${expected} when ${situation}`, async () => {
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           dependencies,
@@ -2230,90 +3744,93 @@ describe("hoisting", async () => {
       },
     ];
     for (const { dependencies, expected, situation } of peerTests) {
-      test(`it should hoist ${expected} when ${situation}`, async () => {
-        await writeFile(
-          join(packageDir, "package.json"),
-          JSON.stringify({
-            name: "foo",
-            dependencies,
-          }),
-        );
+      test.todoIf(isFlaky && isMacOS && situation === "peer ^1.0.2")(
+        `it should hoist ${expected} when ${situation}`,
+        async () => {
+          await writeFile(
+            packageJson,
+            JSON.stringify({
+              name: "foo",
+              dependencies,
+            }),
+          );
 
-        var { stdout, stderr, exited } = spawn({
-          cmd: [bunExe(), "install"],
-          cwd: packageDir,
-          stdout: "pipe",
-          stdin: "pipe",
-          stderr: "pipe",
-          env,
-        });
+          var { stdout, stderr, exited } = spawn({
+            cmd: [bunExe(), "install"],
+            cwd: packageDir,
+            stdout: "pipe",
+            stdin: "pipe",
+            stderr: "pipe",
+            env,
+          });
 
-        var err = await new Response(stderr).text();
-        var out = await new Response(stdout).text();
-        expect(err).toContain("Saved lockfile");
-        expect(err).not.toContain("not found");
-        expect(err).not.toContain("error:");
-        for (const dep of Object.keys(dependencies)) {
-          expect(out).toContain(`+ ${dep}@${dependencies[dep]}`);
-        }
-        expect(await exited).toBe(0);
-        assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
+          var err = await new Response(stderr).text();
+          var out = await new Response(stdout).text();
+          expect(err).toContain("Saved lockfile");
+          expect(err).not.toContain("not found");
+          expect(err).not.toContain("error:");
+          for (const dep of Object.keys(dependencies)) {
+            expect(out).toContain(`+ ${dep}@${dependencies[dep]}`);
+          }
+          expect(await exited).toBe(0);
+          assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-        expect(await file(join(packageDir, "node_modules", "a-dep", "package.json")).text()).toContain(expected);
+          expect(await file(join(packageDir, "node_modules", "a-dep", "package.json")).text()).toContain(expected);
 
-        await rm(join(packageDir, "bun.lockb"));
+          await rm(join(packageDir, "bun.lockb"));
 
-        ({ stdout, stderr, exited } = spawn({
-          cmd: [bunExe(), "install"],
-          cwd: packageDir,
-          stdout: "pipe",
-          stdin: "pipe",
-          stderr: "pipe",
-          env,
-        }));
+          ({ stdout, stderr, exited } = spawn({
+            cmd: [bunExe(), "install"],
+            cwd: packageDir,
+            stdout: "pipe",
+            stdin: "pipe",
+            stderr: "pipe",
+            env,
+          }));
 
-        err = await new Response(stderr).text();
-        out = await new Response(stdout).text();
-        expect(err).toContain("Saved lockfile");
-        expect(err).not.toContain("not found");
-        expect(err).not.toContain("error:");
-        if (out.includes("installed")) {
-          console.log("stdout:", out);
-        }
-        expect(out).not.toContain("package installed");
-        expect(await exited).toBe(0);
-        assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
+          err = await new Response(stderr).text();
+          out = await new Response(stdout).text();
+          expect(err).toContain("Saved lockfile");
+          expect(err).not.toContain("not found");
+          expect(err).not.toContain("error:");
+          if (out.includes("installed")) {
+            console.log("stdout:", out);
+          }
+          expect(out).not.toContain("package installed");
+          expect(await exited).toBe(0);
+          assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-        expect(await file(join(packageDir, "node_modules", "a-dep", "package.json")).text()).toContain(expected);
+          expect(await file(join(packageDir, "node_modules", "a-dep", "package.json")).text()).toContain(expected);
 
-        await rm(join(packageDir, "node_modules"), { recursive: true, force: true });
+          await rm(join(packageDir, "node_modules"), { recursive: true, force: true });
 
-        ({ stdout, stderr, exited } = spawn({
-          cmd: [bunExe(), "install"],
-          cwd: packageDir,
-          stdout: "pipe",
-          stdin: "pipe",
-          stderr: "pipe",
-          env,
-        }));
+          ({ stdout, stderr, exited } = spawn({
+            cmd: [bunExe(), "install"],
+            cwd: packageDir,
+            stdout: "pipe",
+            stdin: "pipe",
+            stderr: "pipe",
+            env,
+          }));
 
-        err = await new Response(stderr).text();
-        out = await new Response(stdout).text();
-        expect(err).not.toContain("Saved lockfile");
-        expect(err).not.toContain("not found");
-        expect(err).not.toContain("error:");
-        expect(out).not.toContain("package installed");
-        expect(await exited).toBe(0);
-        assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
+          err = await new Response(stderr).text();
+          out = await new Response(stdout).text();
+          expect(err).not.toContain("Saved lockfile");
+          expect(err).not.toContain("not found");
+          expect(err).not.toContain("error:");
+          expect(out).not.toContain("package installed");
+          expect(await exited).toBe(0);
+          assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-        expect(await file(join(packageDir, "node_modules", "a-dep", "package.json")).text()).toContain(expected);
-      });
+          expect(await file(join(packageDir, "node_modules", "a-dep", "package.json")).text()).toContain(expected);
+        },
+      );
     }
   });
 
   test("hoisting/using incorrect peer dep after install", async () => {
     await writeFile(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "foo",
         dependencies: {
@@ -2340,8 +3857,9 @@ describe("hoisting", async () => {
     expect(err).not.toContain("incorrect peer dependency");
 
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
-      "+ no-deps@1.0.0",
+      expect.stringContaining("+ no-deps@1.0.0"),
       "+ peer-deps-fixed@1.0.0",
       "",
       "2 packages installed",
@@ -2364,7 +3882,7 @@ describe("hoisting", async () => {
     expect(await exists(join(packageDir, "node_modules", "peer-deps-fixed", "node_modules"))).toBeFalse();
 
     await writeFile(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "foo",
         dependencies: {
@@ -2390,6 +3908,7 @@ describe("hoisting", async () => {
     expect(err).not.toContain("error:");
 
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       "+ no-deps@2.0.0",
       "",
@@ -2416,7 +3935,7 @@ describe("hoisting", async () => {
   test("root workspace (other than root) dependency will not hoist incorrect peer", async () => {
     await Promise.all([
       write(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           workspaces: ["bar"],
@@ -2443,7 +3962,11 @@ describe("hoisting", async () => {
     });
 
     let out = await Bun.readableStreamToText(stdout);
-    expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "3 packages installed"]);
+    expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
+      "",
+      "3 packages installed",
+    ]);
     expect(await exited).toBe(0);
 
     // now run the install again but from the workspace and with `no-deps@2.0.0`
@@ -2468,6 +3991,7 @@ describe("hoisting", async () => {
 
     out = await Bun.readableStreamToText(stdout);
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       "+ no-deps@2.0.0",
       "",
@@ -2482,7 +4006,7 @@ describe("hoisting", async () => {
 
   test("hoisting/using incorrect peer dep on initial install", async () => {
     await writeFile(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "foo",
         dependencies: {
@@ -2509,6 +4033,7 @@ describe("hoisting", async () => {
     expect(err).toContain("incorrect peer dependency");
 
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       "+ no-deps@2.0.0",
       "+ peer-deps-fixed@1.0.0",
@@ -2533,7 +4058,7 @@ describe("hoisting", async () => {
     expect(await exists(join(packageDir, "node_modules", "peer-deps-fixed", "node_modules"))).toBeFalse();
 
     await writeFile(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "foo",
         dependencies: {
@@ -2559,8 +4084,9 @@ describe("hoisting", async () => {
     expect(err).not.toContain("error:");
 
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
-      "+ no-deps@1.0.0",
+      expect.stringContaining("+ no-deps@1.0.0"),
       "",
       "1 package installed",
     ]);
@@ -2589,7 +4115,7 @@ describe("hoisting", async () => {
       // `normal-dep-and-dev-dep` should install `no-deps@1.0.0` and `normal-dep@1.0.1`.
       // It should not hoist (skip) `no-deps` for `normal-dep-and-dev-dep`.
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.0.0",
@@ -2636,7 +4162,7 @@ describe("hoisting", async () => {
 
     test("from workspace", async () => {
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.0.0",
@@ -2697,7 +4223,7 @@ describe("hoisting", async () => {
 
     test("from linked package", async () => {
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.0.0",
@@ -2765,7 +4291,7 @@ describe("hoisting", async () => {
 
     test("dependency with normal dependency same as root", async () => {
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.0.0",
@@ -2812,7 +4338,7 @@ describe("hoisting", async () => {
 describe("workspaces", async () => {
   test("adding packages in a subdirectory of a workspace", async () => {
     await writeFile(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "root",
         workspaces: ["foo"],
@@ -2838,6 +4364,7 @@ describe("workspaces", async () => {
     });
     let out = await Bun.readableStreamToText(stdout);
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun add v1."),
       "",
       "installed no-deps@2.0.0",
       "",
@@ -2846,7 +4373,7 @@ describe("workspaces", async () => {
     expect(await exited).toBe(0);
     assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-    expect(await file(join(packageDir, "package.json")).json()).toEqual({
+    expect(await file(packageJson).json()).toEqual({
       name: "root",
       workspaces: ["foo"],
       dependencies: {
@@ -2864,6 +4391,7 @@ describe("workspaces", async () => {
     }));
     out = await Bun.readableStreamToText(stdout);
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun add v1."),
       "",
       "installed what-bin@1.5.0 with binaries:",
       " - what-bin",
@@ -2893,6 +4421,7 @@ describe("workspaces", async () => {
     }));
     out = await Bun.readableStreamToText(stdout);
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       "+ no-deps@2.0.0",
       "",
@@ -2915,6 +4444,7 @@ describe("workspaces", async () => {
     }));
     out = await Bun.readableStreamToText(stdout);
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       "+ what-bin@1.5.0",
       "",
@@ -2927,7 +4457,7 @@ describe("workspaces", async () => {
   });
   test("adding packages in workspaces", async () => {
     await writeFile(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "foo",
         workspaces: ["packages/*"],
@@ -2967,6 +4497,7 @@ describe("workspaces", async () => {
 
     let out = await Bun.readableStreamToText(stdout);
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       "+ bar@workspace:packages/bar",
       "",
@@ -2990,6 +4521,7 @@ describe("workspaces", async () => {
 
     out = await Bun.readableStreamToText(stdout);
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun add v1."),
       "",
       "installed no-deps@2.0.0",
       "",
@@ -2998,7 +4530,7 @@ describe("workspaces", async () => {
     expect(await exited).toBe(0);
     assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-    expect(await file(join(packageDir, "package.json")).json()).toEqual({
+    expect(await file(packageJson).json()).toEqual({
       name: "foo",
       workspaces: ["packages/*"],
       dependencies: {
@@ -3018,6 +4550,7 @@ describe("workspaces", async () => {
 
     out = await Bun.readableStreamToText(stdout);
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun add v1."),
       "",
       "installed two-range-deps@1.0.0",
       "",
@@ -3054,6 +4587,7 @@ describe("workspaces", async () => {
 
     out = await Bun.readableStreamToText(stdout);
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun add v1."),
       "",
       "installed bar@0.0.7",
       "",
@@ -3087,7 +4621,7 @@ describe("workspaces", async () => {
   });
   test("it should detect duplicate workspace dependencies", async () => {
     await writeFile(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "foo",
         workspaces: ["packages/*"],
@@ -3135,7 +4669,7 @@ describe("workspaces", async () => {
     for (const packageVersion of versions) {
       test(`it should allow duplicates, root@${rootVersion}, package@${packageVersion}`, async () => {
         await writeFile(
-          join(packageDir, "package.json"),
+          packageJson,
           JSON.stringify({
             name: "foo",
             version: "1.0.0",
@@ -3179,6 +4713,7 @@ describe("workspaces", async () => {
         expect(err).not.toContain("not found");
         expect(err).not.toContain("error:");
         expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+          expect.stringContaining("bun install v1."),
           "",
           `+ pkg2@workspace:packages/pkg2`,
           "",
@@ -3202,6 +4737,7 @@ describe("workspaces", async () => {
         expect(err).not.toContain("not found");
         expect(err).not.toContain("error:");
         expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+          expect.stringContaining("bun install v1."),
           "",
           "Checked 2 installs across 3 packages (no changes)",
         ]);
@@ -3226,6 +4762,7 @@ describe("workspaces", async () => {
         expect(err).not.toContain("not found");
         expect(err).not.toContain("error:");
         expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+          expect.stringContaining("bun install v1."),
           "",
           `+ pkg2@workspace:packages/pkg2`,
           "",
@@ -3249,6 +4786,7 @@ describe("workspaces", async () => {
         expect(err).not.toContain("not found");
         expect(err).not.toContain("error:");
         expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+          expect.stringContaining("bun install v1."),
           "",
           "Checked 2 installs across 3 packages (no changes)",
         ]);
@@ -3261,7 +4799,7 @@ describe("workspaces", async () => {
   for (const version of versions) {
     test(`it should allow listing workspace as dependency of the root package version ${version}`, async () => {
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           workspaces: ["packages/*"],
@@ -3298,6 +4836,7 @@ describe("workspaces", async () => {
       expect(err).not.toContain('workspace dependency "workspace-1" not found');
       expect(err).not.toContain("error:");
       expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "",
         `+ workspace-1@workspace:packages/workspace-1`,
         "",
@@ -3329,6 +4868,7 @@ describe("workspaces", async () => {
       expect(err).not.toContain('workspace dependency "workspace-1" not found');
       expect(err).not.toContain("error:");
       expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "",
         "Checked 1 install across 2 packages (no changes)",
       ]);
@@ -3361,7 +4901,11 @@ describe("workspaces", async () => {
       expect(err).not.toContain("Duplicate dependency");
       expect(err).not.toContain('workspace dependency "workspace-1" not found');
       expect(err).not.toContain("error:");
-      expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "1 package installed"]);
+      expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
+        "",
+        "1 package installed",
+      ]);
       expect(await exited).toBe(0);
       expect(await file(join(packageDir, "node_modules", "workspace-1", "package.json")).json()).toEqual({
         name: "workspace-1",
@@ -3386,6 +4930,7 @@ describe("workspaces", async () => {
       expect(err).not.toContain('workspace dependency "workspace-1" not found');
       expect(err).not.toContain("error:");
       expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "",
         "Checked 1 install across 2 packages (no changes)",
       ]);
@@ -3516,7 +5061,7 @@ describe("transitive file dependencies", () => {
   test("from hoisted workspace dependencies", async () => {
     await Promise.all([
       write(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           workspaces: ["pkg1"],
@@ -3549,7 +5094,11 @@ describe("transitive file dependencies", () => {
     var { out } = await runBunInstall(env, packageDir);
     assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-    expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "14 packages installed"]);
+    expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
+      "",
+      "14 packages installed",
+    ]);
 
     await checkHoistedFiles();
     expect(await exists(join(packageDir, "pkg1", "node_modules"))).toBeFalse();
@@ -3560,14 +5109,22 @@ describe("transitive file dependencies", () => {
     ({ out } = await runBunInstall(env, packageDir, { savesLockfile: false }));
     assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-    expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "14 packages installed"]);
+    expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
+      "",
+      "14 packages installed",
+    ]);
 
     await checkHoistedFiles();
 
     ({ out } = await runBunInstall(env, packageDir, { savesLockfile: false }));
     assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-    expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "1 package installed"]);
+    expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
+      "",
+      "1 package installed",
+    ]);
 
     await checkHoistedFiles();
 
@@ -3579,12 +5136,13 @@ describe("transitive file dependencies", () => {
     assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       "+ @another-scope/file-dep@1.0.0",
       "+ @scoped/file-dep@1.0.0",
       "+ aliased-file-dep@1.0.1",
       "+ dep-file-dep@1.0.0",
-      "+ file-dep@1.0.0",
+      expect.stringContaining("+ file-dep@1.0.0"),
       "+ missing-file-dep@1.0.0",
       "+ self-file-dep@1.0.0",
       "",
@@ -3597,7 +5155,11 @@ describe("transitive file dependencies", () => {
     ({ out } = await runBunInstall(env, join(packageDir, "pkg1"), { savesLockfile: false }));
     assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-    expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "1 package installed"]);
+    expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
+      "",
+      "1 package installed",
+    ]);
 
     await rm(join(packageDir, "node_modules"), { recursive: true, force: true });
 
@@ -3605,12 +5167,13 @@ describe("transitive file dependencies", () => {
     assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       "+ @another-scope/file-dep@1.0.0",
       "+ @scoped/file-dep@1.0.0",
       "+ aliased-file-dep@1.0.1",
       "+ dep-file-dep@1.0.0",
-      "+ file-dep@1.0.0",
+      expect.stringContaining("+ file-dep@1.0.0"),
       "+ missing-file-dep@1.0.0",
       "+ self-file-dep@1.0.0",
       "",
@@ -3621,7 +5184,7 @@ describe("transitive file dependencies", () => {
   test("from non-hoisted workspace dependencies", async () => {
     await Promise.all([
       write(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           workspaces: ["pkg1"],
@@ -3666,12 +5229,13 @@ describe("transitive file dependencies", () => {
     assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       "+ @another-scope/file-dep@1.0.1",
       "+ @scoped/file-dep@1.0.1",
       "+ aliased-file-dep@1.0.1",
       "+ dep-file-dep@1.0.1",
-      "+ file-dep@1.0.1",
+      expect.stringContaining("+ file-dep@1.0.1"),
       "+ missing-file-dep@1.0.1",
       "+ self-file-dep@1.0.1",
       "",
@@ -3688,12 +5252,13 @@ describe("transitive file dependencies", () => {
     assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       "+ @another-scope/file-dep@1.0.1",
       "+ @scoped/file-dep@1.0.1",
       "+ aliased-file-dep@1.0.1",
       "+ dep-file-dep@1.0.1",
-      "+ file-dep@1.0.1",
+      expect.stringContaining("+ file-dep@1.0.1"),
       "+ missing-file-dep@1.0.1",
       "+ self-file-dep@1.0.1",
       "",
@@ -3705,7 +5270,11 @@ describe("transitive file dependencies", () => {
     ({ out } = await runBunInstall(env, packageDir, { savesLockfile: false }));
     assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-    expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "1 package installed"]);
+    expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
+      "",
+      "1 package installed",
+    ]);
 
     await checkUnhoistedFiles();
 
@@ -3718,12 +5287,13 @@ describe("transitive file dependencies", () => {
     assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       "+ @another-scope/file-dep@1.0.0",
       "+ @scoped/file-dep@1.0.0",
       "+ aliased-file-dep@1.0.1",
       "+ dep-file-dep@1.0.0",
-      "+ file-dep@1.0.0",
+      expect.stringContaining("+ file-dep@1.0.0"),
       "+ missing-file-dep@1.0.0",
       "+ self-file-dep@1.0.0",
       "",
@@ -3735,7 +5305,11 @@ describe("transitive file dependencies", () => {
     ({ out } = await runBunInstall(env, join(packageDir, "pkg1"), { savesLockfile: false }));
     assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-    expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "1 package installed"]);
+    expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
+      "",
+      "1 package installed",
+    ]);
 
     await rm(join(packageDir, "node_modules"), { recursive: true, force: true });
     await rm(join(packageDir, "pkg1", "node_modules"), { recursive: true, force: true });
@@ -3744,12 +5318,13 @@ describe("transitive file dependencies", () => {
     assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       "+ @another-scope/file-dep@1.0.0",
       "+ @scoped/file-dep@1.0.0",
       "+ aliased-file-dep@1.0.1",
       "+ dep-file-dep@1.0.0",
-      "+ file-dep@1.0.0",
+      expect.stringContaining("+ file-dep@1.0.0"),
       "+ missing-file-dep@1.0.0",
       "+ self-file-dep@1.0.0",
       "",
@@ -3759,7 +5334,7 @@ describe("transitive file dependencies", () => {
 
   test("from root dependencies", async () => {
     await writeFile(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "foo",
         version: "1.0.0",
@@ -3798,12 +5373,13 @@ describe("transitive file dependencies", () => {
     expect(err).not.toContain("error:");
     expect(err).not.toContain("panic:");
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       "+ @another-scope/file-dep@1.0.0",
       "+ @scoped/file-dep@1.0.0",
       "+ aliased-file-dep@1.0.1",
       "+ dep-file-dep@1.0.0",
-      "+ file-dep@1.0.0",
+      expect.stringContaining("+ file-dep@1.0.0"),
       "+ missing-file-dep@1.0.0",
       "+ self-file-dep@1.0.0",
       "",
@@ -3839,7 +5415,11 @@ describe("transitive file dependencies", () => {
     expect(err).not.toContain("not found");
     expect(err).not.toContain("error:");
     expect(err).not.toContain("panic:");
-    expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "1 package installed"]);
+    expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
+      "",
+      "1 package installed",
+    ]);
     expect(await exited).toBe(0);
     assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
@@ -3894,7 +5474,7 @@ describe("transitive file dependencies", () => {
     await writePackages(2);
 
     await writeFile(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "foo",
         version: "1.0.0",
@@ -3922,6 +5502,7 @@ describe("transitive file dependencies", () => {
     expect(err).not.toContain("error:");
     expect(err).not.toContain("panic:");
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       "+ pkg0@pkg0",
       "+ pkg1@pkg1",
@@ -3945,7 +5526,7 @@ describe("transitive file dependencies", () => {
 
 test("name from manifest is scoped and url encoded", async () => {
   await write(
-    join(packageDir, "package.json"),
+    packageJson,
     JSON.stringify({
       name: "foo",
       dependencies: {
@@ -3974,7 +5555,7 @@ test("name from manifest is scoped and url encoded", async () => {
 describe("update", () => {
   test("duplicate peer dependency (one package is invalid_package_id)", async () => {
     await write(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "foo",
         dependencies: {
@@ -3989,7 +5570,7 @@ describe("update", () => {
     await runBunUpdate(env, packageDir);
     assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-    expect(await file(join(packageDir, "package.json")).json()).toEqual({
+    expect(await file(packageJson).json()).toEqual({
       name: "foo",
       dependencies: {
         "no-deps": "^1.1.0",
@@ -4005,7 +5586,7 @@ describe("update", () => {
   });
   test("dist-tags", async () => {
     await write(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "foo",
         dependencies: {
@@ -4026,7 +5607,7 @@ describe("update", () => {
     await runBunUpdate(env, packageDir);
     assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-    expect(await file(join(packageDir, "package.json")).json()).toEqual({
+    expect(await file(packageJson).json()).toEqual({
       name: "foo",
       dependencies: {
         "a-dep": "latest",
@@ -4037,7 +5618,7 @@ describe("update", () => {
     await runBunUpdate(env, packageDir, ["a-dep"]);
     assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-    expect(await file(join(packageDir, "package.json")).json()).toEqual({
+    expect(await file(packageJson).json()).toEqual({
       name: "foo",
       dependencies: {
         "a-dep": "^1.0.10",
@@ -4046,7 +5627,7 @@ describe("update", () => {
     await runBunUpdate(env, packageDir, ["--latest"]);
     assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-    expect(await file(join(packageDir, "package.json")).json()).toEqual({
+    expect(await file(packageJson).json()).toEqual({
       name: "foo",
       dependencies: {
         "a-dep": "^1.0.10",
@@ -4060,7 +5641,7 @@ describe("update", () => {
     ];
     for (const { version, dependency } of runs) {
       await write(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           dependencies: {
@@ -4076,7 +5657,7 @@ describe("update", () => {
           version: version.replace(/.*@/, ""),
         });
 
-        expect(await file(join(packageDir, "package.json")).json()).toMatchObject({
+        expect(await file(packageJson).json()).toMatchObject({
           dependencies: {
             [dependency]: version,
           },
@@ -4102,7 +5683,7 @@ describe("update", () => {
   describe("tilde", () => {
     test("without args", async () => {
       await write(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           dependencies: {
@@ -4122,8 +5703,12 @@ describe("update", () => {
       let { out } = await runBunUpdate(env, packageDir);
       assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-      expect(out).toEqual(["", "Checked 1 install across 2 packages (no changes)"]);
-      expect(await file(join(packageDir, "package.json")).json()).toEqual({
+      expect(out).toEqual([
+        expect.stringContaining("bun update v1."),
+        "",
+        "Checked 1 install across 2 packages (no changes)",
+      ]);
+      expect(await file(packageJson).json()).toEqual({
         name: "foo",
         dependencies: {
           "no-deps": "~1.0.1",
@@ -4134,8 +5719,12 @@ describe("update", () => {
       ({ out } = await runBunUpdate(env, packageDir));
       assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-      expect(out).toEqual(["", "Checked 1 install across 2 packages (no changes)"]);
-      expect(await file(join(packageDir, "package.json")).json()).toEqual({
+      expect(out).toEqual([
+        expect.stringContaining("bun update v1."),
+        "",
+        "Checked 1 install across 2 packages (no changes)",
+      ]);
+      expect(await file(packageJson).json()).toEqual({
         name: "foo",
         dependencies: {
           "no-deps": "~1.0.1",
@@ -4146,7 +5735,7 @@ describe("update", () => {
     for (const latest of [true, false]) {
       test(`update no args${latest ? " --latest" : ""}`, async () => {
         await write(
-          join(packageDir, "package.json"),
+          packageJson,
           JSON.stringify({
             name: "foo",
             dependencies: {
@@ -4173,7 +5762,7 @@ describe("update", () => {
           await runBunUpdate(env, packageDir, ["--latest"]);
           assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-          expect(await file(join(packageDir, "package.json")).json()).toEqual({
+          expect(await file(packageJson).json()).toEqual({
             name: "foo",
             dependencies: {
               "a1": "npm:no-deps@^2.0.0",
@@ -4197,7 +5786,7 @@ describe("update", () => {
           await runBunUpdate(env, packageDir);
           assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-          expect(await file(join(packageDir, "package.json")).json()).toEqual({
+          expect(await file(packageJson).json()).toEqual({
             name: "foo",
             dependencies: {
               "a1": "npm:no-deps@^1.1.0",
@@ -4251,7 +5840,7 @@ describe("update", () => {
 
     test("with package name in args", async () => {
       await write(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           dependencies: {
@@ -4272,8 +5861,15 @@ describe("update", () => {
       let { out } = await runBunUpdate(env, packageDir, ["no-deps"]);
       assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-      expect(out).toEqual(["", "installed no-deps@1.0.1", "", expect.stringContaining("done"), ""]);
-      expect(await file(join(packageDir, "package.json")).json()).toEqual({
+      expect(out).toEqual([
+        expect.stringContaining("bun update v1."),
+        "",
+        "installed no-deps@1.0.1",
+        "",
+        expect.stringContaining("done"),
+        "",
+      ]);
+      expect(await file(packageJson).json()).toEqual({
         name: "foo",
         dependencies: {
           "a-dep": "1.0.3",
@@ -4285,8 +5881,14 @@ describe("update", () => {
       ({ out } = await runBunUpdate(env, packageDir, ["no-deps", "--latest"]));
       assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-      expect(out).toEqual(["", "installed no-deps@2.0.0", "", "1 package installed"]);
-      expect(await file(join(packageDir, "package.json")).json()).toEqual({
+      expect(out).toEqual([
+        expect.stringContaining("bun update v1."),
+        "",
+        "installed no-deps@2.0.0",
+        "",
+        "1 package installed",
+      ]);
+      expect(await file(packageJson).json()).toEqual({
         name: "foo",
         dependencies: {
           "a-dep": "1.0.3",
@@ -4298,7 +5900,7 @@ describe("update", () => {
   describe("alises", () => {
     test("update all", async () => {
       await write(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           dependencies: {
@@ -4310,7 +5912,7 @@ describe("update", () => {
       await runBunUpdate(env, packageDir);
       assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-      expect(await file(join(packageDir, "package.json")).json()).toEqual({
+      expect(await file(packageJson).json()).toEqual({
         name: "foo",
         dependencies: {
           "aliased-dep": "npm:no-deps@^1.1.0",
@@ -4323,7 +5925,7 @@ describe("update", () => {
     });
     test("update specific aliased package", async () => {
       await write(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           dependencies: {
@@ -4335,7 +5937,7 @@ describe("update", () => {
       await runBunUpdate(env, packageDir, ["aliased-dep"]);
       assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-      expect(await file(join(packageDir, "package.json")).json()).toEqual({
+      expect(await file(packageJson).json()).toEqual({
         name: "foo",
         dependencies: {
           "aliased-dep": "npm:no-deps@^1.1.0",
@@ -4348,7 +5950,7 @@ describe("update", () => {
     });
     test("with pre and build tags", async () => {
       await write(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           dependencies: {
@@ -4360,7 +5962,7 @@ describe("update", () => {
       await runBunUpdate(env, packageDir);
       assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-      expect(await file(join(packageDir, "package.json")).json()).toMatchObject({
+      expect(await file(packageJson).json()).toMatchObject({
         name: "foo",
         dependencies: {
           "aliased-dep": "npm:prereleases-3@5.0.0-alpha.150",
@@ -4375,8 +5977,14 @@ describe("update", () => {
       const { out } = await runBunUpdate(env, packageDir, ["--latest"]);
       assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-      expect(out).toEqual(["", "^ aliased-dep 5.0.0-alpha.150 -> 5.0.0-alpha.153", "", "1 package installed"]);
-      expect(await file(join(packageDir, "package.json")).json()).toMatchObject({
+      expect(out).toEqual([
+        expect.stringContaining("bun update v1."),
+        "",
+        "^ aliased-dep 5.0.0-alpha.150 -> 5.0.0-alpha.153",
+        "",
+        "1 package installed",
+      ]);
+      expect(await file(packageJson).json()).toMatchObject({
         name: "foo",
         dependencies: {
           "aliased-dep": "npm:prereleases-3@5.0.0-alpha.153",
@@ -4386,7 +5994,7 @@ describe("update", () => {
   });
   test("--no-save will update packages in node_modules and not save to package.json", async () => {
     await write(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "foo",
         dependencies: {
@@ -4398,8 +6006,14 @@ describe("update", () => {
     let { out } = await runBunUpdate(env, packageDir, ["--no-save"]);
     assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-    expect(out).toEqual(["", "+ a-dep@1.0.1", "", "1 package installed"]);
-    expect(await file(join(packageDir, "package.json")).json()).toEqual({
+    expect(out).toEqual([
+      expect.stringContaining("bun update v1."),
+      "",
+      expect.stringContaining("+ a-dep@1.0.1"),
+      "",
+      "1 package installed",
+    ]);
+    expect(await file(packageJson).json()).toEqual({
       name: "foo",
       dependencies: {
         "a-dep": "1.0.1",
@@ -4407,7 +6021,7 @@ describe("update", () => {
     });
 
     await write(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "foo",
         dependencies: {
@@ -4419,8 +6033,14 @@ describe("update", () => {
     ({ out } = await runBunUpdate(env, packageDir, ["--no-save"]));
     assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-    expect(out).toEqual(["", "+ a-dep@1.0.10", "", "1 package installed"]);
-    expect(await file(join(packageDir, "package.json")).json()).toEqual({
+    expect(out).toEqual([
+      expect.stringContaining("bun update v1."),
+      "",
+      expect.stringContaining("+ a-dep@1.0.10"),
+      "",
+      "1 package installed",
+    ]);
+    expect(await file(packageJson).json()).toEqual({
       name: "foo",
       dependencies: {
         "a-dep": "^1.0.1",
@@ -4431,8 +6051,12 @@ describe("update", () => {
     ({ out } = await runBunUpdate(env, packageDir));
     assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-    expect(out).toEqual(["", "Checked 1 install across 2 packages (no changes)"]);
-    expect(await file(join(packageDir, "package.json")).json()).toEqual({
+    expect(out).toEqual([
+      expect.stringContaining("bun update v1."),
+      "",
+      "Checked 1 install across 2 packages (no changes)",
+    ]);
+    expect(await file(packageJson).json()).toEqual({
       name: "foo",
       dependencies: {
         "a-dep": "^1.0.10",
@@ -4441,7 +6065,7 @@ describe("update", () => {
   });
   test("update won't update beyond version range unless the specified version allows it", async () => {
     await write(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "foo",
         dependencies: {
@@ -4453,7 +6077,7 @@ describe("update", () => {
     await runBunUpdate(env, packageDir);
     assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-    expect(await file(join(packageDir, "package.json")).json()).toEqual({
+    expect(await file(packageJson).json()).toEqual({
       name: "foo",
       dependencies: {
         "dep-with-tags": "^1.0.1",
@@ -4466,7 +6090,7 @@ describe("update", () => {
     await runBunUpdate(env, packageDir, ["dep-with-tags"]);
     assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-    expect(await file(join(packageDir, "package.json")).json()).toEqual({
+    expect(await file(packageJson).json()).toEqual({
       name: "foo",
       dependencies: {
         "dep-with-tags": "^1.0.1",
@@ -4480,7 +6104,7 @@ describe("update", () => {
     await runBunUpdate(env, packageDir, ["dep-with-tags@^2.0.0"]);
     assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-    expect(await file(join(packageDir, "package.json")).json()).toEqual({
+    expect(await file(packageJson).json()).toEqual({
       name: "foo",
       dependencies: {
         "dep-with-tags": "^2.0.1",
@@ -4492,7 +6116,7 @@ describe("update", () => {
   });
   test("update should update all packages in the current workspace", async () => {
     await write(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "foo",
         workspaces: ["packages/*"],
@@ -4541,20 +6165,21 @@ describe("update", () => {
     assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
     expect(out).toEqual([
+      expect.stringContaining("bun update v1."),
       "",
       "+ a-dep@1.0.10",
       "+ dep-loop-entry@1.0.0",
-      "+ dep-with-tags@2.0.1",
+      expect.stringContaining("+ dep-with-tags@2.0.1"),
       "+ dev-deps@1.0.0",
       "+ left-pad@1.0.0",
       "+ native@1.0.0",
       "+ no-deps-bins@2.0.0",
-      "+ one-fixed-dep@1.0.0",
+      expect.stringContaining("+ one-fixed-dep@1.0.0"),
       "+ optional-native@1.0.0",
       "+ peer-deps-too@1.0.0",
       "+ two-range-deps@1.0.0",
-      "+ uses-what-bin@1.5.0",
-      "+ what-bin@1.5.0",
+      expect.stringContaining("+ uses-what-bin@1.5.0"),
+      expect.stringContaining("+ what-bin@1.5.0"),
       "",
       // Due to optional-native dependency, this can be either 20 or 19 packages
       expect.stringMatching(/(?:20|19) packages installed/),
@@ -4566,7 +6191,7 @@ describe("update", () => {
     let lockfile = parseLockfile(packageDir);
     // make sure this is valid
     expect(lockfile).toMatchNodeModulesAt(packageDir);
-    expect(await file(join(packageDir, "package.json")).json()).toEqual({
+    expect(await file(packageJson).json()).toEqual({
       name: "foo",
       workspaces: ["packages/*"],
       dependencies: {
@@ -4597,6 +6222,7 @@ describe("update", () => {
     assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
     expect(out).toEqual([
+      expect.stringContaining("bun update v1."),
       "",
       "installed what-bin@1.5.0 with binaries:",
       " - what-bin",
@@ -4642,7 +6268,14 @@ describe("update", () => {
     ({ out } = await runBunUpdate(env, join(packageDir, "packages", "pkg1"), ["a-dep@^1.0.5"]));
     assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-    expect(out).toEqual(["", "installed a-dep@1.0.10", "", expect.stringMatching(/(\[\d+\.\d+m?s\])/), ""]);
+    expect(out).toEqual([
+      expect.stringContaining("bun update v1."),
+      "",
+      "installed a-dep@1.0.10",
+      "",
+      expect.stringMatching(/(\[\d+\.\d+m?s\])/),
+      "",
+    ]);
     expect(await file(join(packageDir, "node_modules", "a-dep", "package.json")).json()).toMatchObject({
       name: "a-dep",
       version: "1.0.10",
@@ -4669,7 +6302,7 @@ describe("update", () => {
     for (const args of [true, false]) {
       for (const group of ["dependencies", "devDependencies", "optionalDependencies", "peerDependencies"]) {
         await write(
-          join(packageDir, "package.json"),
+          packageJson,
           JSON.stringify({
             name: "foo",
             [group]: {
@@ -4681,8 +6314,14 @@ describe("update", () => {
         const { out } = args ? await runBunUpdate(env, packageDir, ["a-dep"]) : await runBunUpdate(env, packageDir);
         assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-        expect(out).toEqual(["", args ? "installed a-dep@1.0.10" : "+ a-dep@1.0.10", "", "1 package installed"]);
-        expect(await file(join(packageDir, "package.json")).json()).toEqual({
+        expect(out).toEqual([
+          expect.stringContaining("bun update v1."),
+          "",
+          args ? "installed a-dep@1.0.10" : expect.stringContaining("+ a-dep@1.0.10"),
+          "",
+          "1 package installed",
+        ]);
+        expect(await file(packageJson).json()).toEqual({
           name: "foo",
           [group]: {
             "a-dep": "^1.0.10",
@@ -4696,7 +6335,7 @@ describe("update", () => {
   });
   test("it should update packages from update requests", async () => {
     await write(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "foo",
         dependencies: {
@@ -4745,7 +6384,14 @@ describe("update", () => {
     let { out } = await runBunUpdate(env, packageDir, ["no-deps"]);
     assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-    expect(out).toEqual(["", "installed no-deps@1.0.0", "", expect.stringMatching(/(\[\d+\.\d+m?s\])/), ""]);
+    expect(out).toEqual([
+      expect.stringContaining("bun update v1."),
+      "",
+      "installed no-deps@1.0.0",
+      "",
+      expect.stringMatching(/(\[\d+\.\d+m?s\])/),
+      "",
+    ]);
     expect(await file(join(packageDir, "node_modules", "no-deps", "package.json")).json()).toMatchObject({
       version: "1.0.0",
     });
@@ -4754,7 +6400,13 @@ describe("update", () => {
     ({ out } = await runBunUpdate(env, join(packageDir, "packages", "pkg1"), ["no-deps"]));
     assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-    expect(out).toEqual(["", "installed no-deps@2.0.0", "", "1 package installed"]);
+    expect(out).toEqual([
+      expect.stringContaining("bun update v1."),
+      "",
+      "installed no-deps@2.0.0",
+      "",
+      "1 package installed",
+    ]);
     expect(await file(join(packageDir, "node_modules", "no-deps", "package.json")).json()).toMatchObject({
       version: "1.0.0",
     });
@@ -4769,7 +6421,7 @@ describe("update", () => {
 
     // update root package.json no-deps to ^1.0.0 and update it
     await write(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "foo",
         dependencies: {
@@ -4782,7 +6434,13 @@ describe("update", () => {
     ({ out } = await runBunUpdate(env, packageDir, ["no-deps"]));
     assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-    expect(out).toEqual(["", "installed no-deps@1.1.0", "", "1 package installed"]);
+    expect(out).toEqual([
+      expect.stringContaining("bun update v1."),
+      "",
+      "installed no-deps@1.1.0",
+      "",
+      "1 package installed",
+    ]);
     expect(await file(join(packageDir, "node_modules", "no-deps", "package.json")).json()).toMatchObject({
       version: "1.1.0",
     });
@@ -4790,7 +6448,7 @@ describe("update", () => {
 
   test("--latest works with packages from arguments", async () => {
     await write(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "foo",
         dependencies: {
@@ -4804,7 +6462,7 @@ describe("update", () => {
 
     const files = await Promise.all([
       file(join(packageDir, "node_modules", "no-deps", "package.json")).json(),
-      file(join(packageDir, "package.json")).json(),
+      file(packageJson).json(),
     ]);
 
     expect(files).toMatchObject([{ version: "2.0.0" }, { dependencies: { "no-deps": "2.0.0" } }]);
@@ -4813,7 +6471,7 @@ describe("update", () => {
 
 test("packages dependening on each other with aliases does not infinitely loop", async () => {
   await write(
-    join(packageDir, "package.json"),
+    packageJson,
     JSON.stringify({
       name: "foo",
       dependencies: {
@@ -4842,7 +6500,7 @@ test("packages dependening on each other with aliases does not infinitely loop",
 
 test("it should re-populate .bin folder if package is reinstalled", async () => {
   await writeFile(
-    join(packageDir, "package.json"),
+    packageJson,
     JSON.stringify({
       name: "foo",
       dependencies: {
@@ -4866,6 +6524,7 @@ test("it should re-populate .bin folder if package is reinstalled", async () =>
   expect(err).not.toContain("not found");
   expect(err).not.toContain("error:");
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ what-bin@1.5.0",
     "",
@@ -4902,10 +6561,11 @@ test("it should re-populate .bin folder if package is reinstalled", async () =>
   expect(err).not.toContain("not found");
   expect(err).not.toContain("error:");
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ what-bin@1.5.0",
     "",
-    expect.stringContaining("1 package installed"),
+    "1 package installed",
   ]);
   expect(await exited).toBe(0);
   assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
@@ -4922,7 +6582,7 @@ test("it should re-populate .bin folder if package is reinstalled", async () =>
 
 test("one version with binary map", async () => {
   await writeFile(
-    join(packageDir, "package.json"),
+    packageJson,
     JSON.stringify({
       name: "foo",
       dependencies: {
@@ -4945,6 +6605,7 @@ test("one version with binary map", async () => {
   expect(err).not.toContain("not found");
   expect(err).not.toContain("error:");
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ map-bin@1.0.2",
     "",
@@ -4960,7 +6621,7 @@ test("one version with binary map", async () => {
 
 test("multiple versions with binary map", async () => {
   await writeFile(
-    join(packageDir, "package.json"),
+    packageJson,
     JSON.stringify({
       name: "foo",
       version: "1.2.3",
@@ -4984,6 +6645,7 @@ test("multiple versions with binary map", async () => {
   expect(err).not.toContain("not found");
   expect(err).not.toContain("error:");
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ map-bin-multiple@1.0.2",
     "",
@@ -5003,7 +6665,7 @@ test("multiple versions with binary map", async () => {
 
 test("duplicate dependency in optionalDependencies maintains sort order", async () => {
   await write(
-    join(packageDir, "package.json"),
+    packageJson,
     JSON.stringify({
       name: "foo",
       dependencies: {
@@ -5040,7 +6702,7 @@ test("duplicate dependency in optionalDependencies maintains sort order", async
 
 test("missing package on reinstall, some with binaries", async () => {
   await writeFile(
-    join(packageDir, "package.json"),
+    packageJson,
     JSON.stringify({
       name: "fooooo",
       dependencies: {
@@ -5074,10 +6736,11 @@ test("missing package on reinstall, some with binaries", async () => {
   expect(err).toContain("Saved lockfile");
   expect(err).not.toContain("not found");
   expect(err).not.toContain("error:");
-  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+  expect(out.replace(/\s*\[[0-9\.]+m?s\]$/m, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ dep-loop-entry@1.0.0",
-    "+ dep-with-tags@3.0.0",
+    expect.stringContaining("+ dep-with-tags@3.0.0"),
     "+ dev-deps@1.0.0",
     "+ left-pad@1.0.0",
     "+ native@1.0.0",
@@ -5086,10 +6749,10 @@ test("missing package on reinstall, some with binaries", async () => {
     "+ optional-native@1.0.0",
     "+ peer-deps-too@1.0.0",
     "+ two-range-deps@1.0.0",
-    "+ uses-what-bin@1.5.0",
-    "+ what-bin@1.0.0",
+    expect.stringContaining("+ uses-what-bin@1.5.0"),
+    expect.stringContaining("+ what-bin@1.0.0"),
     "",
-    expect.stringContaining("19 packages installed"),
+    "19 packages installed",
     "",
     "Blocked 1 postinstall. Run `bun pm untrusted` for details.",
     "",
@@ -5128,6 +6791,7 @@ test("missing package on reinstall, some with binaries", async () => {
   expect(err).not.toContain("not found");
   expect(err).not.toContain("error:");
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ dep-loop-entry@1.0.0",
     "+ left-pad@1.0.0",
@@ -5135,7 +6799,7 @@ test("missing package on reinstall, some with binaries", async () => {
     "+ one-fixed-dep@2.0.0",
     "+ peer-deps-too@1.0.0",
     "",
-    expect.stringContaining("7 packages installed"),
+    "7 packages installed",
   ]);
   expect(await exited).toBe(0);
   assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
@@ -5181,7 +6845,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       };
 
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.0.0",
@@ -5233,7 +6897,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
 
       // add a dependency with all lifecycle scripts
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.0.0",
@@ -5267,10 +6931,11 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       expect(err).not.toContain("not found");
       expect(err).not.toContain("error:");
       expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "",
         "+ all-lifecycle-scripts@1.0.0",
         "",
-        expect.stringContaining("1 package installed"),
+        "1 package installed",
       ]);
       expect(await exited).toBe(0);
       assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
@@ -5323,10 +6988,11 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       expect(err).not.toContain("not found");
       expect(err).not.toContain("error:");
       expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "",
         "+ all-lifecycle-scripts@1.0.0",
         "",
-        expect.stringContaining("1 package installed"),
+        "1 package installed",
       ]);
 
       expect(await file(join(packageDir, "preinstall.txt")).text()).toBe("preinstall!");
@@ -5346,7 +7012,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       const testEnv = forceWaiterThread ? { ...env, BUN_FEATURE_FLAG_FORCE_WAITER_THREAD: "1" } : env;
 
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.0.0",
@@ -5410,7 +7076,11 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       expect(err).not.toContain("error:");
       expect(err).toContain("Saved lockfile");
       var out = await new Response(stdout).text();
-      expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "2 packages installed"]);
+      expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
+        "",
+        "2 packages installed",
+      ]);
       expect(await exited).toBe(0);
       assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
@@ -5439,7 +7109,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
 
       const script = '[[ -f "./node_modules/uses-what-bin-slow/what-bin.txt" ]]';
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.0.0",
@@ -5483,7 +7153,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       const testEnv = forceWaiterThread ? { ...env, BUN_FEATURE_FLAG_FORCE_WAITER_THREAD: "1" } : env;
 
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.0.0",
@@ -5508,11 +7178,12 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       expect(err).toContain("Saved lockfile");
       expect(err).not.toContain("not found");
       expect(err).not.toContain("error:");
-      expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect(out.replace(/\s*\[[0-9\.]+m?s\]$/m, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "",
         "+ all-lifecycle-scripts@1.0.0",
         "",
-        expect.stringContaining("1 package installed"),
+        "1 package installed",
         "",
         "Blocked 3 postinstalls. Run `bun pm untrusted` for details.",
         "",
@@ -5531,7 +7202,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
 
       // add to trusted dependencies
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.0.0",
@@ -5557,6 +7228,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       expect(err).not.toContain("not found");
       expect(err).not.toContain("error:");
       expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "",
         expect.stringContaining("Checked 1 install across 2 packages (no changes)"),
       ]);
@@ -5575,7 +7247,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       const testEnv = forceWaiterThread ? { ...env, BUN_FEATURE_FLAG_FORCE_WAITER_THREAD: "1" } : env;
 
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.0.0",
@@ -5601,8 +7273,9 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       expect(err).not.toContain("not found");
       expect(err).not.toContain("error:");
       expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "",
-        "+ what-bin@1.0.0",
+        expect.stringContaining("+ what-bin@1.0.0"),
         "",
         "1 package installed",
       ]);
@@ -5610,7 +7283,6 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
       expect(await readdirSorted(join(packageDir, "node_modules"))).toEqual([".bin", "what-bin"]);
-      const isWindows = process.platform === "win32";
       const what_bin_bins = !isWindows ? ["what-bin"] : ["what-bin.bunx", "what-bin.exe"];
       // prettier-ignore
       expect(await readdirSorted(join(packageDir, "node_modules", ".bin"))).toEqual(what_bin_bins);
@@ -5630,6 +7302,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       expect(err).not.toContain("not found");
       expect(err).not.toContain("error:");
       expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "",
         "Checked 1 install across 2 packages (no changes)",
       ]);
@@ -5640,7 +7313,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       await rm(join(packageDir, "bun.lockb"));
 
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.0.0",
@@ -5663,8 +7336,9 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       expect(err).not.toContain("not found");
       expect(err).not.toContain("error:");
       expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "",
-        "+ what-bin@1.0.0",
+        expect.stringContaining("+ what-bin@1.0.0"),
         "",
         "1 package installed",
       ]);
@@ -5689,6 +7363,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       expect(err).not.toContain("not found");
       expect(err).not.toContain("error:");
       expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "",
         "Checked 1 install across 2 packages (no changes)",
       ]);
@@ -5700,7 +7375,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
 
       // add it to trusted dependencies
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.0.0",
@@ -5726,6 +7401,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       expect(err).not.toContain("not found");
       expect(err).not.toContain("error:");
       expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "",
         "Checked 1 install across 2 packages (no changes)",
       ]);
@@ -5740,7 +7416,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       const testEnv = forceWaiterThread ? { ...env, BUN_FEATURE_FLAG_FORCE_WAITER_THREAD: "1" } : env;
 
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.0.0",
@@ -5761,11 +7437,12 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       var err = await new Response(stderr).text();
       var out = await new Response(stdout).text();
       expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "",
         "+ lifecycle-postinstall@1.0.0",
         "",
         // @ts-ignore
-        expect.stringContaining("1 package installed"),
+        "1 package installed",
       ]);
       expect(err).toContain("Saved lockfile");
       expect(err).not.toContain("not found");
@@ -5787,10 +7464,11 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       err = await new Response(stderr).text();
       out = await new Response(stdout).text();
       expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "",
         "+ lifecycle-postinstall@1.0.0",
         "",
-        expect.stringContaining("1 package installed"),
+        "1 package installed",
       ]);
       expect(err).not.toContain("Saved lockfile");
       expect(err).not.toContain("not found");
@@ -5804,7 +7482,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       const testEnv = forceWaiterThread ? { ...env, BUN_FEATURE_FLAG_FORCE_WAITER_THREAD: "1" } : env;
 
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.0.0",
@@ -5847,11 +7525,12 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       expect(err).not.toContain("not found");
       expect(err).not.toContain("error:");
       expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "",
         "+ another-init-cwd@1.0.0",
         "+ lifecycle-init-cwd@1.0.0",
         "",
-        expect.stringContaining("1 package installed"),
+        "1 package installed",
       ]);
       expect(await exited).toBe(0);
       assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
@@ -5865,7 +7544,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       const testEnv = forceWaiterThread ? { ...env, BUN_FEATURE_FLAG_FORCE_WAITER_THREAD: "1" } : env;
 
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.0.0",
@@ -5891,14 +7570,14 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
       const out = await new Response(stdout).text();
-      expect(out).toBeEmpty();
+      expect(out).toEqual(expect.stringContaining("bun install v1."));
     });
 
     test("failing root lifecycle script should print output correctly", async () => {
       const testEnv = forceWaiterThread ? { ...env, BUN_FEATURE_FLAG_FORCE_WAITER_THREAD: "1" } : env;
 
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "fooooooooo",
           version: "1.0.0",
@@ -5919,7 +7598,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       expect(await exited).toBe(1);
       assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-      expect(await Bun.readableStreamToText(stdout)).toBeEmpty();
+      expect(await Bun.readableStreamToText(stdout)).toEqual(expect.stringContaining("bun install v1."));
       const err = await Bun.readableStreamToText(stderr);
       expect(err).toContain("error: Oops!");
       expect(err).toContain('error: preinstall script from "fooooooooo" exited with 1');
@@ -5929,7 +7608,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       const testEnv = forceWaiterThread ? { ...env, BUN_FEATURE_FLAG_FORCE_WAITER_THREAD: "1" } : env;
 
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.0.0",
@@ -5956,6 +7635,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       expect(err).not.toContain("error:");
       const out = await new Response(stdout).text();
       expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "",
         expect.stringContaining("done"),
         "",
@@ -5968,7 +7648,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       const testEnv = forceWaiterThread ? { ...env, BUN_FEATURE_FLAG_FORCE_WAITER_THREAD: "1" } : env;
 
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           dependencies: {
@@ -5994,6 +7674,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       expect(err).not.toContain("hello");
       const out = await new Response(stdout).text();
       expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "",
         "+ lifecycle-failing-postinstall@1.0.0",
         "",
@@ -6007,7 +7688,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       const testEnv = forceWaiterThread ? { ...env, BUN_FEATURE_FLAG_FORCE_WAITER_THREAD: "1" } : env;
 
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.0.0",
@@ -6033,10 +7714,11 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       expect(err).not.toContain("error:");
       const out = await new Response(stdout).text();
       expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "",
         "+ binding-gyp-scripts@1.5.0",
         "",
-        expect.stringContaining("2 packages installed"),
+        "2 packages installed",
       ]);
       expect(await exited).toBe(0);
       assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
@@ -6054,7 +7736,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
           "binding-gyp-scripts": "1.5.0",
         },
       };
-      await writeFile(join(packageDir, "package.json"), JSON.stringify(packageJSON));
+      await writeFile(packageJson, JSON.stringify(packageJSON));
 
       var { stdout, stderr, exited } = spawn({
         cmd: [bunExe(), "install"],
@@ -6070,11 +7752,12 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       expect(err).not.toContain("not found");
       expect(err).not.toContain("error:");
       const out = await new Response(stdout).text();
-      expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect(out.replace(/\s*\[[0-9\.]+m?s\]$/m, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "",
         "+ binding-gyp-scripts@1.5.0",
         "",
-        expect.stringContaining("2 packages installed"),
+        "2 packages installed",
         "",
         "Blocked 1 postinstall. Run `bun pm untrusted` for details.",
         "",
@@ -6085,7 +7768,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       expect(await exists(join(packageDir, "node_modules", "binding-gyp-scripts", "build.node"))).toBeFalse();
 
       packageJSON.trustedDependencies = ["binding-gyp-scripts"];
-      await writeFile(join(packageDir, "package.json"), JSON.stringify(packageJSON));
+      await writeFile(packageJson, JSON.stringify(packageJSON));
 
       ({ stdout, stderr, exited } = spawn({
         cmd: [bunExe(), "install"],
@@ -6096,7 +7779,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
         env: testEnv,
       }));
 
-      err = await Bun.readableStreamToText(stderr);
+      err = stderrForInstall(await Bun.readableStreamToText(stderr));
       expect(err).toContain("Saved lockfile");
       expect(err).not.toContain("not found");
       expect(err).not.toContain("error:");
@@ -6112,7 +7795,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       const testEnv = forceWaiterThread ? { ...env, BUN_FEATURE_FLAG_FORCE_WAITER_THREAD: "1" } : env;
 
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.0.0",
@@ -6139,10 +7822,11 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       expect(err).not.toContain("error:");
       const out = await new Response(stdout).text();
       expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "",
         "+ node-gyp@1.5.0",
         "",
-        expect.stringContaining("1 package installed"),
+        "1 package installed",
       ]);
       expect(await exited).toBe(0);
       assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
@@ -6170,7 +7854,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       const testEnv = forceWaiterThread ? { ...env, BUN_FEATURE_FLAG_FORCE_WAITER_THREAD: "1" } : env;
 
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.0.0",
@@ -6202,10 +7886,11 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       expect(err).not.toContain("error:");
       const out = await new Response(stdout).text();
       expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "",
         "+ node-gyp@1.5.0",
         "",
-        expect.stringContaining("1 package installed"),
+        "1 package installed",
       ]);
       expect(await exited).toBe(0);
       assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
@@ -6227,7 +7912,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
             [script]: "exit 0",
           },
         };
-        await writeFile(join(packageDir, "package.json"), JSON.stringify(packageJSON));
+        await writeFile(packageJson, JSON.stringify(packageJSON));
         await writeFile(join(packageDir, "binding.gyp"), "");
 
         const { stdout, stderr, exited } = spawn({
@@ -6245,10 +7930,11 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
         expect(err).not.toContain("error:");
         const out = await new Response(stdout).text();
         expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+          expect.stringContaining("bun install v1."),
           "",
           "+ node-gyp@1.5.0",
           "",
-          expect.stringContaining("1 package installed"),
+          "1 package installed",
         ]);
         expect(await exited).toBe(0);
         assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
@@ -6261,7 +7947,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       const testEnv = forceWaiterThread ? { ...env, BUN_FEATURE_FLAG_FORCE_WAITER_THREAD: "1" } : env;
 
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.0.0",
@@ -6285,11 +7971,12 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       expect(err).not.toContain("not found");
       expect(err).not.toContain("error:");
       const out = await new Response(stdout).text();
-      expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect(out.replace(/\s*\[[0-9\.]+m?s\]$/m, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "",
         "+ lifecycle-install-test@github:dylan-conway/lifecycle-install-test#3ba6af5",
         "",
-        expect.stringContaining("1 package installed"),
+        "1 package installed",
         "",
         "Blocked 6 postinstalls. Run `bun pm untrusted` for details.",
         "",
@@ -6305,7 +7992,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       expect(await exists(join(packageDir, "node_modules", "lifecycle-install-test", "postinstall.txt"))).toBeFalse();
 
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.0.0",
@@ -6325,7 +8012,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
         env: testEnv,
       }));
 
-      err = await Bun.readableStreamToText(stderr);
+      err = stderrForInstall(await Bun.readableStreamToText(stderr));
       expect(err).toContain("Saved lockfile");
       expect(err).not.toContain("not found");
       expect(err).not.toContain("error:");
@@ -6346,7 +8033,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       const testEnv = forceWaiterThread ? { ...env, BUN_FEATURE_FLAG_FORCE_WAITER_THREAD: "1" } : env;
 
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.0.0",
@@ -6380,6 +8067,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       expect(err).not.toContain("error:");
       const out = await new Response(stdout).text();
       expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "",
         "+ uses-what-bin-slow@1.0.0",
         "",
@@ -6416,7 +8104,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       }
 
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "stress-test",
           version: "1.0.0",
@@ -6453,6 +8141,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       const out = await Bun.readableStreamToText(stdout);
       expect(out).not.toContain("Blocked");
       expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "",
         ...dependenciesList.map(dep => `+ ${dep}@${dep}`),
         "",
@@ -6486,6 +8175,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       const out = await Bun.readableStreamToText(stdout);
       expect(out).not.toContain("Blocked");
       expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "",
         ...dependenciesList.map(dep => `+ ${dep}@${dep}`).sort((a, b) => a.localeCompare(b)),
         "",
@@ -6505,7 +8195,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       // - node_modules/uses-what-bin/node_modules/.bin/what-bin@1.0.0
 
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.0.0",
@@ -6530,12 +8220,13 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       expect(err).not.toContain("not found");
       expect(err).not.toContain("error:");
       var out = await new Response(stdout).text();
-      expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect(out.replace(/\s*\[[0-9\.]+m?s\]$/m, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "",
-        "+ uses-what-bin@1.0.0",
+        expect.stringContaining("+ uses-what-bin@1.0.0"),
         "+ what-bin@1.5.0",
         "",
-        expect.stringContaining("3 packages installed"),
+        "3 packages installed",
         "",
         "Blocked 1 postinstall. Run `bun pm untrusted` for details.",
         "",
@@ -6554,7 +8245,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       await rm(join(packageDir, "bun.lockb"));
 
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.0.0",
@@ -6578,7 +8269,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
         env: testEnv,
       }));
 
-      err = await Bun.readableStreamToText(stderr);
+      err = stderrForInstall(await Bun.readableStreamToText(stderr));
       expect(err).toContain("Saved lockfile");
       expect(err).not.toContain("not found");
       expect(err).not.toContain("error:");
@@ -6611,11 +8302,12 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       expect(err).not.toContain("not found");
       expect(err).not.toContain("error:");
       expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "",
-        "+ uses-what-bin@1.5.0",
-        "+ what-bin@1.0.0",
+        expect.stringContaining("+ uses-what-bin@1.5.0"),
+        expect.stringContaining("+ what-bin@1.0.0"),
         "",
-        expect.stringContaining("3 packages installed"),
+        "3 packages installed",
       ]);
       expect(await exited).toBe(0);
       assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
@@ -6625,7 +8317,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       const testEnv = forceWaiterThread ? { ...env, BUN_FEATURE_FLAG_FORCE_WAITER_THREAD: "1" } : env;
 
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.0.0",
@@ -6660,7 +8352,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       const testEnv = forceWaiterThread ? { ...env, BUN_FEATURE_FLAG_FORCE_WAITER_THREAD: "1" } : env;
 
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.2.3",
@@ -6685,10 +8377,11 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       expect(err).not.toContain("error:");
       const out = await new Response(stdout).text();
       expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "",
         "+ electron@1.0.0",
         "",
-        expect.stringContaining("1 package installed"),
+        "1 package installed",
       ]);
       expect(out).not.toContain("Blocked");
       expect(await exists(join(packageDir, "node_modules", "electron", "preinstall.txt"))).toBeTrue();
@@ -6700,7 +8393,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       const testEnv = forceWaiterThread ? { ...env, BUN_FEATURE_FLAG_FORCE_WAITER_THREAD: "1" } : env;
 
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.2.3",
@@ -6727,12 +8420,13 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       expect(err).not.toContain("not found");
       expect(err).not.toContain("error:");
       var out = await new Response(stdout).text();
-      expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect(out.replace(/\s*\[[0-9\.]+m?s\]$/m, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "",
         "+ electron@1.0.0",
-        "+ uses-what-bin@1.0.0",
+        expect.stringContaining("+ uses-what-bin@1.0.0"),
         "",
-        expect.stringContaining("3 packages installed"),
+        "3 packages installed",
         "",
         "Blocked 1 postinstall. Run `bun pm untrusted` for details.",
         "",
@@ -6748,7 +8442,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       await rm(join(packageDir, "bun.lockb"));
 
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.2.3",
@@ -6776,12 +8470,13 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       expect(err).not.toContain("not found");
       expect(err).not.toContain("error:");
       out = await Bun.readableStreamToText(stdout);
-      expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect(out.replace(/\s*\[[0-9\.]+m?s\]$/m, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "",
         "+ electron@1.0.0",
-        "+ uses-what-bin@1.0.0",
+        expect.stringContaining("+ uses-what-bin@1.0.0"),
         "",
-        expect.stringContaining("3 packages installed"),
+        "3 packages installed",
         "",
         "Blocked 1 postinstall. Run `bun pm untrusted` for details.",
         "",
@@ -6797,7 +8492,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       const testEnv = forceWaiterThread ? { ...env, BUN_FEATURE_FLAG_FORCE_WAITER_THREAD: "1" } : env;
 
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.2.3",
@@ -6823,12 +8518,13 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       expect(err).toContain("Saved lockfile");
       expect(err).not.toContain("not found");
       expect(err).not.toContain("error:");
-      expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect(out.replace(/\s*\[[0-9\.]+m?s\]$/m, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "",
         "+ electron@1.0.0",
-        "+ uses-what-bin@1.0.0",
+        expect.stringContaining("+ uses-what-bin@1.0.0"),
         "",
-        expect.stringContaining("3 packages installed"),
+        "3 packages installed",
         "",
         "Blocked 2 postinstalls. Run `bun pm untrusted` for details.",
         "",
@@ -6844,7 +8540,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       const testEnv = forceWaiterThread ? { ...env, BUN_FEATURE_FLAG_FORCE_WAITER_THREAD: "1" } : env;
 
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.2.3",
@@ -6871,11 +8567,12 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       expect(err).not.toContain("not found");
       expect(err).not.toContain("error:");
       var out = await Bun.readableStreamToText(stdout);
-      expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect(out.replace(/\s*\[[0-9\.]+m?s\]$/m, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "",
         "+ electron@1.0.0",
         "",
-        expect.stringContaining("1 package installed"),
+        "1 package installed",
         "",
         "Blocked 1 postinstall. Run `bun pm untrusted` for details.",
         "",
@@ -6886,7 +8583,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       expect(await exists(join(packageDir, "node_modules", "electron", "preinstall.txt"))).toBeFalse();
 
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.2.3",
@@ -6913,6 +8610,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       expect(err).not.toContain("error:");
       out = await Bun.readableStreamToText(stdout);
       expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "",
         "Checked 1 install across 2 packages (no changes)",
       ]);
@@ -6928,7 +8626,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
 
         await Promise.all([
           write(
-            join(packageDir, "package.json"),
+            packageJson,
             JSON.stringify({
               name: "foo",
               dependencies: {
@@ -7054,13 +8752,14 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
             env: testEnv,
           });
 
-          let err = await Bun.readableStreamToText(stderr);
+          let err = stderrForInstall(await Bun.readableStreamToText(stderr));
           expect(err).toContain("Saved lockfile");
           expect(err).not.toContain("not found");
           expect(err).not.toContain("error:");
           expect(err).not.toContain("warn:");
           let out = await Bun.readableStreamToText(stdout);
           expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+            expect.stringContaining("bun add v1."),
             "",
             "installed uses-what-bin@1.0.0",
             "",
@@ -7086,13 +8785,14 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
             env: testEnv,
           }));
 
-          err = await Bun.readableStreamToText(stderr);
+          err = stderrForInstall(await Bun.readableStreamToText(stderr));
           expect(err).not.toContain("Saved lockfile");
           expect(err).not.toContain("not found");
           expect(err).not.toContain("error:");
           expect(err).not.toContain("warn:");
           out = await Bun.readableStreamToText(stdout);
           expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+            expect.stringContaining("bun install v1."),
             "",
             "Checked 2 installs across 3 packages (no changes)",
           ]);
@@ -7104,7 +8804,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
           const testEnv = forceWaiterThread ? { ...env, BUN_FEATURE_FLAG_FORCE_WAITER_THREAD: "1" } : env;
 
           await writeFile(
-            join(packageDir, "package.json"),
+            packageJson,
             JSON.stringify({
               name: "foo",
             }),
@@ -7119,21 +8819,22 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
             env: testEnv,
           });
 
-          const err = await Bun.readableStreamToText(stderr);
+          const err = stderrForInstall(await Bun.readableStreamToText(stderr));
           expect(err).toContain("Saved lockfile");
           expect(err).not.toContain("not found");
           expect(err).not.toContain("error:");
           expect(err).not.toContain("warn:");
           const out = await Bun.readableStreamToText(stdout);
           expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+            expect.stringContaining("bun add v1."),
             "",
             "installed no-deps@1.0.0",
             "",
-            expect.stringContaining("1 package installed"),
+            "1 package installed",
           ]);
           expect(await exited).toBe(0);
           expect(await exists(join(packageDir, "node_modules", "no-deps"))).toBeTrue();
-          expect(await file(join(packageDir, "package.json")).json()).toEqual({
+          expect(await file(packageJson).json()).toEqual({
             name: "foo",
             dependencies: {
               "no-deps": "1.0.0",
@@ -7144,7 +8845,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
           const testEnv = forceWaiterThread ? { ...env, BUN_FEATURE_FLAG_FORCE_WAITER_THREAD: "1" } : env;
 
           await writeFile(
-            join(packageDir, "package.json"),
+            packageJson,
             JSON.stringify({
               name: "foo",
             }),
@@ -7158,21 +8859,22 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
             env: testEnv,
           });
 
-          let err = await Bun.readableStreamToText(stderr);
+          let err = stderrForInstall(await Bun.readableStreamToText(stderr));
           expect(err).toContain("Saved lockfile");
           expect(err).not.toContain("not found");
           expect(err).not.toContain("error:");
           expect(err).not.toContain("warn:");
           let out = await Bun.readableStreamToText(stdout);
           expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+            expect.stringContaining("bun add v1."),
             "",
             "installed no-deps@2.0.0",
             "",
-            expect.stringContaining("1 package installed"),
+            "1 package installed",
           ]);
           expect(await exited).toBe(0);
           expect(await exists(join(packageDir, "node_modules", "no-deps"))).toBeTrue();
-          expect(await file(join(packageDir, "package.json")).json()).toEqual({
+          expect(await file(packageJson).json()).toEqual({
             name: "foo",
             dependencies: {
               "no-deps": "^2.0.0",
@@ -7201,6 +8903,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
           expect(err).not.toContain("error:");
           out = await Bun.readableStreamToText(stdout);
           expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+            expect.stringContaining("bun add v1."),
             "",
             "installed no-deps@2.0.0",
             "",
@@ -7209,7 +8912,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
           ]);
           expect(await exited).toBe(0);
           expect(await exists(join(packageDir, "node_modules", "no-deps"))).toBeTrue();
-          expect(await file(join(packageDir, "package.json")).json()).toEqual({
+          expect(await file(packageJson).json()).toEqual({
             name: "foo",
             dependencies: {
               "no-deps": "^2.0.0",
@@ -7224,7 +8927,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
         const testEnv = forceWaiterThread ? { ...env, BUN_FEATURE_FLAG_FORCE_WAITER_THREAD: "1" } : env;
 
         await writeFile(
-          join(packageDir, "package.json"),
+          packageJson,
           JSON.stringify({
             name: "foo",
             trustedDependencies: ["uses-what-bin"],
@@ -7243,23 +8946,24 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
           env: testEnv,
         });
 
-        let err = await Bun.readableStreamToText(stderr);
+        let err = stderrForInstall(await Bun.readableStreamToText(stderr));
         expect(err).toContain("Saved lockfile");
         expect(err).not.toContain("not found");
         expect(err).not.toContain("error:");
         expect(err).not.toContain("warn:");
         let out = await Bun.readableStreamToText(stdout);
         expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+          expect.stringContaining("bun install v1."),
           "",
-          "+ uses-what-bin@1.0.0",
+          expect.stringContaining("+ uses-what-bin@1.0.0"),
           "",
-          expect.stringContaining("2 packages installed"),
+          "2 packages installed",
         ]);
         expect(await exited).toBe(0);
         assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
         expect(await exists(join(packageDir, "node_modules", "uses-what-bin", "what-bin.txt"))).toBeTrue();
-        expect(await file(join(packageDir, "package.json")).json()).toEqual({
+        expect(await file(packageJson).json()).toEqual({
           name: "foo",
           dependencies: {
             "uses-what-bin": "1.0.0",
@@ -7277,13 +8981,14 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
           env: testEnv,
         }));
 
-        err = await Bun.readableStreamToText(stderr);
+        err = stderrForInstall(await Bun.readableStreamToText(stderr));
         expect(err).not.toContain("Saved lockfile");
         expect(err).not.toContain("not found");
         expect(err).not.toContain("error:");
         expect(err).not.toContain("warn:");
         out = await Bun.readableStreamToText(stdout);
         expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+          expect.stringContaining("bun install v1."),
           "",
           "Checked 2 installs across 3 packages (no changes)",
         ]);
@@ -7295,7 +9000,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
         const testEnv = forceWaiterThread ? { ...env, BUN_FEATURE_FLAG_FORCE_WAITER_THREAD: "1" } : env;
 
         await writeFile(
-          join(packageDir, "package.json"),
+          packageJson,
           JSON.stringify({
             name: "foo",
             trustedDependencies: ["uses-what-bin"],
@@ -7314,23 +9019,24 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
           env: testEnv,
         });
 
-        let err = await Bun.readableStreamToText(stderr);
+        let err = stderrForInstall(await Bun.readableStreamToText(stderr));
         expect(err).toContain("Saved lockfile");
         expect(err).not.toContain("not found");
         expect(err).not.toContain("error:");
         expect(err).not.toContain("warn:");
         let out = await Bun.readableStreamToText(stdout);
         expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+          expect.stringContaining("bun install v1."),
           "",
-          "+ uses-what-bin@1.0.0",
+          expect.stringContaining("+ uses-what-bin@1.0.0"),
           "",
-          expect.stringContaining("2 packages installed"),
+          "2 packages installed",
         ]);
         expect(await exited).toBe(0);
         assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
         expect(await exists(join(packageDir, "node_modules", "uses-what-bin", "what-bin.txt"))).toBeTrue();
-        expect(await file(join(packageDir, "package.json")).json()).toEqual({
+        expect(await file(packageJson).json()).toEqual({
           name: "foo",
           dependencies: {
             "uses-what-bin": "1.0.0",
@@ -7339,7 +9045,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
         });
 
         await writeFile(
-          join(packageDir, "package.json"),
+          packageJson,
           JSON.stringify({
             name: "foo",
             dependencies: {
@@ -7360,20 +9066,21 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
           env: testEnv,
         }));
 
-        err = await Bun.readableStreamToText(stderr);
+        err = stderrForInstall(await Bun.readableStreamToText(stderr));
         expect(err).toContain("Saved lockfile");
         expect(err).not.toContain("not found");
         expect(err).not.toContain("error:");
         expect(err).not.toContain("warn:");
         out = await Bun.readableStreamToText(stdout);
         expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+          expect.stringContaining("bun install v1."),
           "",
           "Checked 2 installs across 3 packages (no changes)",
         ]);
         expect(await exited).toBe(0);
         assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-        expect(await file(join(packageDir, "package.json")).json()).toEqual({
+        expect(await file(packageJson).json()).toEqual({
           name: "foo",
           dependencies: {
             "uses-what-bin": "1.0.0",
@@ -7386,7 +9093,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
         const testEnv = forceWaiterThread ? { ...env, BUN_FEATURE_FLAG_FORCE_WAITER_THREAD: "1" } : env;
 
         await writeFile(
-          join(packageDir, "package.json"),
+          packageJson,
           JSON.stringify({
             name: "foo",
             dependencies: {
@@ -7404,23 +9111,24 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
           env: testEnv,
         });
 
-        let err = await Bun.readableStreamToText(stderr);
+        let err = stderrForInstall(await Bun.readableStreamToText(stderr));
         expect(err).toContain("Saved lockfile");
         expect(err).not.toContain("not found");
         expect(err).not.toContain("error:");
         expect(err).not.toContain("warn:");
         let out = await Bun.readableStreamToText(stdout);
         expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+          expect.stringContaining("bun install v1."),
           "",
           "+ electron@1.0.0",
           "",
-          expect.stringContaining("1 package installed"),
+          "1 package installed",
         ]);
         expect(await exited).toBe(0);
         assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
         expect(await exists(join(packageDir, "node_modules", "electron", "preinstall.txt"))).toBeTrue();
-        expect(await file(join(packageDir, "package.json")).json()).toEqual({
+        expect(await file(packageJson).json()).toEqual({
           name: "foo",
           dependencies: {
             "electron": "1.0.0",
@@ -7428,7 +9136,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
         });
 
         await writeFile(
-          join(packageDir, "package.json"),
+          packageJson,
           JSON.stringify({
             name: "foo",
             trustedDependencies: ["electron"],
@@ -7452,13 +9160,14 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
           env: testEnv,
         }));
 
-        err = await Bun.readableStreamToText(stderr);
+        err = stderrForInstall(await Bun.readableStreamToText(stderr));
         expect(err).toContain("Saved lockfile");
         expect(err).not.toContain("not found");
         expect(err).not.toContain("error:");
         expect(err).not.toContain("warn:");
         out = await Bun.readableStreamToText(stdout);
         expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+          expect.stringContaining("bun install v1."),
           "",
           "Checked 1 install across 2 packages (no changes)",
         ]);
@@ -7473,7 +9182,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       const testEnv = forceWaiterThread ? { ...env, BUN_FEATURE_FLAG_FORCE_WAITER_THREAD: "1" } : env;
 
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.0.0",
@@ -7497,7 +9206,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
 
       env.PATH = originalPath;
 
-      let err = await Bun.readableStreamToText(stderr);
+      let err = stderrForInstall(await Bun.readableStreamToText(stderr));
       expect(err).toContain("No packages! Deleted empty lockfile");
       expect(err).not.toContain("not found");
       expect(err).not.toContain("error:");
@@ -7512,7 +9221,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       const testEnv = forceWaiterThread ? { ...env, BUN_FEATURE_FLAG_FORCE_WAITER_THREAD: "1" } : env;
 
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.0.0",
@@ -7536,7 +9245,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
 
       env.PATH = originalPath;
 
-      let err = await Bun.readableStreamToText(stderr);
+      let err = stderrForInstall(await Bun.readableStreamToText(stderr));
       expect(err).toContain("No packages! Deleted empty lockfile");
       expect(err).not.toContain("not found");
       expect(err).not.toContain("error:");
@@ -7549,7 +9258,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       const testEnv = forceWaiterThread ? { ...env, BUN_FEATURE_FLAG_FORCE_WAITER_THREAD: "1" } : env;
 
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           dependencies: {
@@ -7566,16 +9275,17 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
         env: testEnv,
       });
 
-      let err = await Bun.readableStreamToText(stderr);
+      let err = stderrForInstall(await Bun.readableStreamToText(stderr));
       expect(err).toContain("Saved lockfile");
       expect(err).not.toContain("error:");
       expect(err).not.toContain("warn:");
       let out = await Bun.readableStreamToText(stdout);
-      expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect(out.replace(/\s*\[[0-9\.]+m?s\]$/m, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "",
-        "+ uses-what-bin@1.5.0",
+        expect.stringContaining("+ uses-what-bin@1.5.0"),
         "",
-        expect.stringContaining("2 packages installed"),
+        "2 packages installed",
         "",
         "Blocked 1 postinstall. Run `bun pm untrusted` for details.",
         "",
@@ -7595,7 +9305,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
         env: testEnv,
       }));
 
-      err = await Bun.readableStreamToText(stderr);
+      err = stderrForInstall(await Bun.readableStreamToText(stderr));
       expect(err).toContain("bun pm untrusted");
       expect(err).not.toContain("error:");
       expect(err).not.toContain("warn:");
@@ -7627,7 +9337,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
           const testEnv = forceWaiterThread ? { ...env, BUN_FEATURE_FLAG_FORCE_WAITER_THREAD: "1" } : env;
 
           await writeFile(
-            join(packageDir, "package.json"),
+            packageJson,
             JSON.stringify({
               name: "foo",
               dependencies: {
@@ -7645,18 +9355,19 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
             env: testEnv,
           });
 
-          let err = await Bun.readableStreamToText(stderr);
+          let err = stderrForInstall(await Bun.readableStreamToText(stderr));
           expect(err).toContain("Saved lockfile");
           expect(err).not.toContain("not found");
           expect(err).not.toContain("error:");
           expect(err).not.toContain("warn:");
           let out = await Bun.readableStreamToText(stdout);
-          expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+          expect(out.replace(/\s*\[[0-9\.]+m?s\]$/m, "").split(/\r?\n/)).toEqual([
+            expect.stringContaining("bun install v1."),
             "",
-            "+ no-deps@1.0.0",
-            "+ uses-what-bin@1.0.0",
+            expect.stringContaining("+ no-deps@1.0.0"),
+            expect.stringContaining("+ uses-what-bin@1.0.0"),
             "",
-            expect.stringContaining("3 packages installed"),
+            "3 packages installed",
             "",
             "Blocked 1 postinstall. Run `bun pm untrusted` for details.",
             "",
@@ -7674,7 +9385,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
             env: testEnv,
           }));
 
-          err = await Bun.readableStreamToText(stderr);
+          err = stderrForInstall(await Bun.readableStreamToText(stderr));
           expect(err).not.toContain("error:");
           expect(err).not.toContain("warn:");
           out = await Bun.readableStreamToText(stdout);
@@ -7682,7 +9393,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
           expect(await exited).toBe(0);
 
           expect(await exists(join(packageDir, "node_modules", "uses-what-bin", "what-bin.txt"))).toBeTrue();
-          expect(await file(join(packageDir, "package.json")).json()).toEqual({
+          expect(await file(packageJson).json()).toEqual({
             name: "foo",
             dependencies: {
               "no-deps": "1.0.0",
@@ -7701,7 +9412,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
               env: testEnv,
             }));
 
-            err = await Bun.readableStreamToText(stderr);
+            err = stderrForInstall(await Bun.readableStreamToText(stderr));
             expect(err).toContain("Saved lockfile");
             expect(err).not.toContain("not found");
             expect(err).not.toContain("error:");
@@ -7712,7 +9423,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
             expect(await exited).toBe(0);
           }
           await writeFile(
-            join(packageDir, "package.json"),
+            packageJson,
             JSON.stringify({
               name: "foo",
               dependencies: {
@@ -7729,7 +9440,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
             env: testEnv,
           }));
 
-          err = await Bun.readableStreamToText(stderr);
+          err = stderrForInstall(await Bun.readableStreamToText(stderr));
           expect(err).toContain("Saved lockfile");
           expect(err).not.toContain("not found");
           expect(err).not.toContain("error:");
@@ -7738,6 +9449,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
           let expected = withRm
             ? ["", "Checked 1 install across 2 packages (no changes)"]
             : ["", expect.stringContaining("1 package removed")];
+          expected = [expect.stringContaining("bun install v1."), ...expected];
           expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(expected);
           expect(await exited).toBe(0);
           expect(await exists(join(packageDir, "node_modules", "uses-what-bin"))).toBe(!withRm);
@@ -7745,7 +9457,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
           // add again, bun pm untrusted should report it as untrusted
 
           await writeFile(
-            join(packageDir, "package.json"),
+            packageJson,
             JSON.stringify({
               name: "foo",
               dependencies: {
@@ -7763,7 +9475,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
             env: testEnv,
           }));
 
-          err = await Bun.readableStreamToText(stderr);
+          err = stderrForInstall(await Bun.readableStreamToText(stderr));
           expect(err).toContain("Saved lockfile");
           expect(err).not.toContain("not found");
           expect(err).not.toContain("error:");
@@ -7772,15 +9484,16 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
           expected = withRm
             ? [
                 "",
-                "+ uses-what-bin@1.0.0",
+                expect.stringContaining("+ uses-what-bin@1.0.0"),
                 "",
-                expect.stringContaining("1 package installed"),
+                "1 package installed",
                 "",
                 "Blocked 1 postinstall. Run `bun pm untrusted` for details.",
                 "",
               ]
-            : ["", expect.stringContaining("Checked 3 installs across 4 packages (no changes)")];
-          expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(expected);
+            : ["", expect.stringContaining("Checked 3 installs across 4 packages (no changes)"), ""];
+          expected = [expect.stringContaining("bun install v1."), ...expected];
+          expect(out.replace(/\s*\[[0-9\.]+m?s\]$/m, "").split(/\r?\n/)).toEqual(expected);
 
           ({ stdout, stderr, exited } = spawn({
             cmd: [bunExe(), "pm", "untrusted"],
@@ -7790,7 +9503,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
             env: testEnv,
           }));
 
-          err = await Bun.readableStreamToText(stderr);
+          err = stderrForInstall(await Bun.readableStreamToText(stderr));
           expect(err).not.toContain("error:");
           expect(err).not.toContain("warn:");
           out = await Bun.readableStreamToText(stdout);
@@ -7805,7 +9518,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
         const testEnv = forceWaiterThread ? { ...env, BUN_FEATURE_FLAG_FORCE_WAITER_THREAD: "1" } : env;
 
         await writeFile(
-          join(packageDir, "package.json"),
+          packageJson,
           JSON.stringify({
             name: "foo",
             version: "1.0.0",
@@ -7836,7 +9549,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
 
         const dep = isWindows ? "uses-what-bin-slow-window" : "uses-what-bin-slow";
         await writeFile(
-          join(packageDir, "package.json"),
+          packageJson,
           JSON.stringify({
             name: "foo",
             version: "1.0.0",
@@ -7882,7 +9595,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
 
       const exe = bunExe().replace(/\\/g, "\\\\");
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.2.3",
@@ -7902,11 +9615,10 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
         env: testEnv,
       });
 
-      const err = await Bun.readableStreamToText(stderr);
+      const err = stderrForInstall(await Bun.readableStreamToText(stderr));
       expect(err).not.toContain("error:");
       expect(err).not.toContain("warn:");
       expect(err.split(/\r?\n/)).toEqual([
-        expect.stringContaining("bun install"),
         "No packages! Deleted empty lockfile",
         "",
         `$ ${exe} -e 'process.stderr.write("preinstall stderr 🍦\\n")'`,
@@ -7917,6 +9629,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
       ]);
       const out = await Bun.readableStreamToText(stdout);
       expect(out.split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "install stdout 🚀",
         "prepare stdout done ✅",
         "",
@@ -7932,7 +9645,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
 
       const exe = bunExe().replace(/\\/g, "\\\\");
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.2.3",
@@ -7955,11 +9668,10 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
         env: testEnv,
       });
 
-      const err = await Bun.readableStreamToText(stderr);
+      const err = stderrForInstall(await Bun.readableStreamToText(stderr));
       expect(err).not.toContain("error:");
       expect(err).not.toContain("warn:");
       expect(err.split(/\r?\n/)).toEqual([
-        expect.stringContaining("bun install"),
         "Resolving dependencies",
         expect.stringContaining("Resolved, downloaded and extracted "),
         "Saved lockfile",
@@ -7971,14 +9683,14 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
         "",
       ]);
       const out = await Bun.readableStreamToText(stdout);
-      expect(out.split(/\r?\n/)).toEqual([
+      expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "install stdout 🚀",
         "prepare stdout done ✅",
         "",
-        "+ no-deps@1.0.0",
-        "",
-        expect.stringContaining("1 package installed"),
+        expect.stringContaining("+ no-deps@1.0.0"),
         "",
+        "1 package installed",
       ]);
       expect(await exited).toBe(0);
       assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
@@ -7989,7 +9701,7 @@ for (const forceWaiterThread of isLinux ? [false, true] : [false]) {
 describe("pm trust", async () => {
   test("--default", async () => {
     await writeFile(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "foo",
       }),
@@ -8003,7 +9715,7 @@ describe("pm trust", async () => {
       env,
     });
 
-    let err = await Bun.readableStreamToText(stderr);
+    let err = stderrForInstall(await Bun.readableStreamToText(stderr));
     expect(err).not.toContain("Saved lockfile");
     expect(err).not.toContain("not found");
     expect(err).not.toContain("error:");
@@ -8016,7 +9728,7 @@ describe("pm trust", async () => {
   describe("--all", async () => {
     test("no dependencies", async () => {
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
         }),
@@ -8030,7 +9742,7 @@ describe("pm trust", async () => {
         env,
       });
 
-      let err = await Bun.readableStreamToText(stderr);
+      let err = stderrForInstall(await Bun.readableStreamToText(stderr));
       expect(err).toContain("error: Lockfile not found");
       let out = await Bun.readableStreamToText(stdout);
       expect(out).toBeEmpty();
@@ -8039,7 +9751,7 @@ describe("pm trust", async () => {
 
     test("some dependencies, non with scripts", async () => {
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           dependencies: {
@@ -8056,16 +9768,17 @@ describe("pm trust", async () => {
         env,
       });
 
-      let err = await Bun.readableStreamToText(stderr);
+      let err = stderrForInstall(await Bun.readableStreamToText(stderr));
       expect(err).not.toContain("not found");
       expect(err).not.toContain("error:");
       expect(err).not.toContain("warn:");
       let out = await Bun.readableStreamToText(stdout);
-      expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect(out.replace(/\s*\[[0-9\.]+m?s\]$/m, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "",
-        "+ uses-what-bin@1.0.0",
+        expect.stringContaining("+ uses-what-bin@1.0.0"),
         "",
-        expect.stringContaining("2 packages installed"),
+        "2 packages installed",
         "",
         "Blocked 1 postinstall. Run `bun pm untrusted` for details.",
         "",
@@ -8082,7 +9795,7 @@ describe("pm trust", async () => {
         env,
       }));
 
-      err = await Bun.readableStreamToText(stderr);
+      err = stderrForInstall(await Bun.readableStreamToText(stderr));
       expect(err).not.toContain("not found");
       expect(err).not.toContain("error:");
       expect(err).not.toContain("warn:");
@@ -8136,10 +9849,11 @@ test("it should be able to find binary in node_modules/.bin from parent director
   expect(err).not.toContain("error:");
   const out = await new Response(stdout).text();
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
-    "+ what-bin@1.0.0",
+    expect.stringContaining("+ what-bin@1.0.0"),
     "",
-    expect.stringContaining("1 package installed"),
+    "1 package installed",
   ]);
   expect(await exited).toBe(0);
   assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
@@ -8249,7 +9963,7 @@ describe("semver", () => {
   for (const { title, depVersion, expected } of taggedVersionTests) {
     test(title, async () => {
       await writeFile(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           version: "1.0.0",
@@ -8274,8 +9988,9 @@ describe("semver", () => {
       expect(err).not.toContain("not found");
       expect(err).not.toContain("error:");
       expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+        expect.stringContaining("bun install v1."),
         "",
-        `+ dep-with-tags@${expected}`,
+        expect.stringContaining(`+ dep-with-tags@${expected}`),
         "",
         "1 package installed",
       ]);
@@ -8286,7 +10001,7 @@ describe("semver", () => {
 
   test.todo("only tagged versions in range errors", async () => {
     await writeFile(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "foo",
         version: "1.0.0",
@@ -8311,7 +10026,7 @@ describe("semver", () => {
     expect(await exited).toBe(1);
     assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
 
-    expect(out).toBeEmpty();
+    expect(out).toEqual(expect.stringContaining("bun install v1."));
   });
 });
 
@@ -8474,7 +10189,7 @@ for (let i = 0; i < prereleaseTests.length; i++) {
     for (const { title, depVersion, expected } of tests) {
       test(title, async () => {
         await writeFile(
-          join(packageDir, "package.json"),
+          packageJson,
           JSON.stringify({
             name: "foo",
             version: "1.0.0",
@@ -8499,6 +10214,7 @@ for (let i = 0; i < prereleaseTests.length; i++) {
         expect(err).not.toContain("not found");
         expect(err).not.toContain("error:");
         expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+          expect.stringContaining("bun install v1."),
           "",
           `+ ${depName}@${expected}`,
           "",
@@ -8619,7 +10335,7 @@ for (let i = 0; i < prereleaseFailTests.length; i++) {
     for (const { title, depVersion } of tests) {
       test(title, async () => {
         await writeFile(
-          join(packageDir, "package.json"),
+          packageJson,
           JSON.stringify({
             name: "foo",
             version: "1.0.0",
@@ -8640,7 +10356,7 @@ for (let i = 0; i < prereleaseFailTests.length; i++) {
 
         const err = await new Response(stderr).text();
         const out = await new Response(stdout).text();
-        expect(out).toBeEmpty();
+        expect(out).toEqual(expect.stringContaining("bun install v1."));
         expect(err).toContain(`No version matching "${depVersion}" found for specifier "${depName}"`);
         expect(await exited).toBe(1);
         assertManifestsPopulated(join(packageDir, ".bun-cache"), registryUrl());
@@ -8652,7 +10368,7 @@ for (let i = 0; i < prereleaseFailTests.length; i++) {
 describe("yarn tests", () => {
   test("dragon test 1", async () => {
     await writeFile(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "dragon-test-1",
         version: "1.0.0",
@@ -8678,6 +10394,7 @@ describe("yarn tests", () => {
     expect(err).not.toContain("not found");
     expect(err).not.toContain("error:");
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       "+ dragon-test-1-d@1.0.0",
       "+ dragon-test-1-e@1.0.0",
@@ -8715,7 +10432,7 @@ describe("yarn tests", () => {
 
   test("dragon test 2", async () => {
     await writeFile(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "dragon-test-2",
         version: "1.0.0",
@@ -8767,6 +10484,7 @@ describe("yarn tests", () => {
     expect(err).not.toContain("not found");
     expect(err).not.toContain("error:");
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       "+ dragon-test-2-a@workspace:dragon-test-2-a",
       "",
@@ -8788,7 +10506,7 @@ describe("yarn tests", () => {
 
   test("dragon test 3", async () => {
     await writeFile(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "dragon-test-3",
         version: "1.0.0",
@@ -8813,6 +10531,7 @@ describe("yarn tests", () => {
     expect(err).not.toContain("not found");
     expect(err).not.toContain("error:");
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       "+ dragon-test-3-a@1.0.0",
       "",
@@ -8839,7 +10558,7 @@ describe("yarn tests", () => {
 
   test("dragon test 4", async () => {
     await writeFile(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         "name": "dragon-test-4",
         "version": "1.0.0",
@@ -8878,7 +10597,11 @@ describe("yarn tests", () => {
     expect(err).toContain("Saved lockfile");
     expect(err).not.toContain("not found");
     expect(err).not.toContain("error:");
-    expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "3 packages installed"]);
+    expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
+      "",
+      "3 packages installed",
+    ]);
     expect(await readdirSorted(join(packageDir, "node_modules"))).toEqual(["my-workspace", "no-deps", "peer-deps"]);
     expect(await file(join(packageDir, "node_modules", "no-deps", "package.json")).json()).toEqual({
       name: "no-deps",
@@ -8897,7 +10620,7 @@ describe("yarn tests", () => {
 
   test("dragon test 5", async () => {
     await writeFile(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         "name": "dragon-test-5",
         "version": "1.0.0",
@@ -8947,7 +10670,11 @@ describe("yarn tests", () => {
     expect(err).toContain("Saved lockfile");
     expect(err).not.toContain("not found");
     expect(err).not.toContain("error:");
-    expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "5 packages installed"]);
+    expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
+      "",
+      "5 packages installed",
+    ]);
     expect(await readdirSorted(join(packageDir, "node_modules"))).toEqual([
       "a",
       "b",
@@ -8976,7 +10703,7 @@ describe("yarn tests", () => {
 
   test.todo("dragon test 6", async () => {
     await writeFile(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         "name": "dragon-test-6",
         "version": "1.0.0",
@@ -9075,6 +10802,7 @@ describe("yarn tests", () => {
     expect(err).not.toContain("not found");
     expect(err).not.toContain("error:");
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       "+ a@workspace:packages/a",
       "+ b@workspace:packages/b",
@@ -9092,7 +10820,7 @@ describe("yarn tests", () => {
 
   test.todo("dragon test 7", async () => {
     await writeFile(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         "name": "dragon-test-7",
         "version": "1.0.0",
@@ -9120,6 +10848,7 @@ describe("yarn tests", () => {
     expect(err).not.toContain("not found");
     expect(err).not.toContain("error:");
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       "+ dragon-test-7-a@1.0.0",
       "+ dragon-test-7-b@2.0.0",
@@ -9174,7 +10903,7 @@ describe("yarn tests", () => {
 
   test("dragon test 8", async () => {
     await writeFile(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         "name": "dragon-test-8",
         version: "1.0.0",
@@ -9202,6 +10931,7 @@ describe("yarn tests", () => {
     expect(err).not.toContain("not found");
     expect(err).not.toContain("error:");
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       "+ dragon-test-8-a@1.0.0",
       "+ dragon-test-8-b@1.0.0",
@@ -9216,7 +10946,7 @@ describe("yarn tests", () => {
 
   test("dragon test 9", async () => {
     await writeFile(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "dragon-test-9",
         version: "1.0.0",
@@ -9242,9 +10972,10 @@ describe("yarn tests", () => {
     expect(err).not.toContain("not found");
     expect(err).not.toContain("error:");
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       "+ first@1.0.0",
-      "+ no-deps@1.0.0",
+      expect.stringContaining("+ no-deps@1.0.0"),
       "+ second@1.0.0",
       "",
       "2 packages installed",
@@ -9258,7 +10989,7 @@ describe("yarn tests", () => {
 
   test.todo("dragon test 10", async () => {
     await writeFile(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "dragon-test-10",
         version: "1.0.0",
@@ -9319,6 +11050,7 @@ describe("yarn tests", () => {
     expect(err).not.toContain("error:");
     expect(err).not.toContain("not found");
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       "+ a@workspace:packages/a",
       "+ b@workspace:packages/b",
@@ -9332,7 +11064,7 @@ describe("yarn tests", () => {
 
   test("dragon test 12", async () => {
     await writeFile(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "dragon-test-12",
         version: "1.0.0",
@@ -9380,7 +11112,11 @@ describe("yarn tests", () => {
     expect(err).toContain("Saved lockfile");
     expect(err).not.toContain("error:");
     expect(err).not.toContain("not found");
-    expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual(["", "4 packages installed"]);
+    expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
+      "",
+      "4 packages installed",
+    ]);
     expect(await readdirSorted(join(packageDir, "node_modules"))).toEqual([
       "fake-peer-deps",
       "no-deps",
@@ -9401,7 +11137,7 @@ describe("yarn tests", () => {
 
   test("it should not warn when the peer dependency resolution is compatible", async () => {
     await writeFile(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "compatible-peer-deps",
         version: "1.0.0",
@@ -9428,8 +11164,9 @@ describe("yarn tests", () => {
     expect(err).not.toContain("not found");
     expect(err).not.toContain("incorrect peer dependency");
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
-      "+ no-deps@1.0.0",
+      expect.stringContaining("+ no-deps@1.0.0"),
       "+ peer-deps-fixed@1.0.0",
       "",
       "2 packages installed",
@@ -9441,7 +11178,7 @@ describe("yarn tests", () => {
 
   test("it should warn when the peer dependency resolution is incompatible", async () => {
     await writeFile(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "incompatible-peer-deps",
         version: "1.0.0",
@@ -9468,6 +11205,7 @@ describe("yarn tests", () => {
     expect(err).not.toContain("not found");
     expect(err).toContain("incorrect peer dependency");
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       "+ no-deps@2.0.0",
       "+ peer-deps-fixed@1.0.0",
@@ -9481,7 +11219,7 @@ describe("yarn tests", () => {
 
   test("it should install in such a way that two identical packages with different peer dependencies are different instances", async () => {
     await writeFile(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "foo",
         version: "1.0.0",
@@ -9508,6 +11246,7 @@ describe("yarn tests", () => {
     expect(err).not.toContain("not found");
     expect(err).not.toContain("incorrect peer dependency");
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       "+ provides-peer-deps-1-0-0@1.0.0",
       "+ provides-peer-deps-2-0-0@1.0.0",
@@ -9588,7 +11327,7 @@ describe("yarn tests", () => {
 
   test("it should install in such a way that two identical packages with the same peer dependencies are the same instances (simple)", async () => {
     await writeFile(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "foo",
         version: "1.0.0",
@@ -9615,6 +11354,7 @@ describe("yarn tests", () => {
     expect(err).not.toContain("not found");
     expect(err).not.toContain("incorrect peer dependency");
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       "+ provides-peer-deps-1-0-0@1.0.0",
       "+ provides-peer-deps-1-0-0-too@1.0.0",
@@ -9651,7 +11391,7 @@ describe("yarn tests", () => {
 
   test("it should install in such a way that two identical packages with the same peer dependencies are the same instances (complex)", async () => {
     await writeFile(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "foo",
         version: "1.0.0",
@@ -9679,10 +11419,11 @@ describe("yarn tests", () => {
     expect(err).not.toContain("not found");
     expect(err).not.toContain("incorrect peer dependency");
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       "+ forward-peer-deps@1.0.0",
       "+ forward-peer-deps-too@1.0.0",
-      "+ no-deps@1.0.0",
+      expect.stringContaining("+ no-deps@1.0.0"),
       "",
       "4 packages installed",
     ]);
@@ -9716,7 +11457,7 @@ describe("yarn tests", () => {
 
   test("it shouldn't deduplicate two packages with similar peer dependencies but different names", async () => {
     await writeFile(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "foo",
         version: "1.0.0",
@@ -9744,8 +11485,9 @@ describe("yarn tests", () => {
     expect(err).not.toContain("not found");
     expect(err).not.toContain("incorrect peer dependency");
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
-      "+ no-deps@1.0.0",
+      expect.stringContaining("+ no-deps@1.0.0"),
       "+ peer-deps@1.0.0",
       "+ peer-deps-too@1.0.0",
       "",
@@ -9775,7 +11517,7 @@ describe("yarn tests", () => {
 
   test("it should reinstall and rebuild dependencies deleted by the user on the next install", async () => {
     await writeFile(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "foo",
         version: "1.0.0",
@@ -9802,11 +11544,12 @@ describe("yarn tests", () => {
     expect(err).not.toContain("error:");
     expect(err).not.toContain("not found");
     expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+      expect.stringContaining("bun install v1."),
       "",
       "+ no-deps-scripted@1.0.0",
       "+ one-dep-scripted@1.5.0",
       "",
-      expect.stringContaining("4 packages installed"),
+      "4 packages installed",
     ]);
     expect(await exists(join(packageDir, "node_modules/one-dep-scripted/success.txt"))).toBeTrue();
     expect(await exited).toBe(0);
@@ -9836,7 +11579,7 @@ describe("yarn tests", () => {
 
 test("tarball `./` prefix, duplicate directory with file, and empty directory", async () => {
   await write(
-    join(packageDir, "package.json"),
+    packageJson,
     JSON.stringify({
       name: "foo",
       dependencies: {
@@ -9999,13 +11742,17 @@ describe("outdated", () => {
       expect(err).not.toContain("error:");
       expect(err).not.toContain("panic:");
       const out = await Bun.readableStreamToText(stdout);
-      expect(out).toMatchSnapshot();
+      const first = out.slice(0, out.indexOf("\n"));
+      expect(first).toEqual(expect.stringContaining("bun outdated "));
+      expect(first).toEqual(expect.stringContaining("v1."));
+      const rest = out.slice(out.indexOf("\n") + 1);
+      expect(rest).toMatchSnapshot();
     });
   }
   test("in workspace", async () => {
     await Promise.all([
       write(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           workspaces: ["pkg1"],
@@ -10062,7 +11809,7 @@ describe("outdated", () => {
 
   test("NO_COLOR works", async () => {
     await write(
-      join(packageDir, "package.json"),
+      packageJson,
       JSON.stringify({
         name: "foo",
         dependencies: {
@@ -10088,7 +11835,11 @@ describe("outdated", () => {
 
     const out = await Bun.readableStreamToText(stdout);
     expect(out).toContain("a-dep");
-    expect(out).toMatchSnapshot();
+    const first = out.slice(0, out.indexOf("\n"));
+    expect(first).toEqual(expect.stringContaining("bun outdated "));
+    expect(first).toEqual(expect.stringContaining("v1."));
+    const rest = out.slice(out.indexOf("\n") + 1);
+    expect(rest).toMatchSnapshot();
 
     expect(await exited).toBe(0);
   });
@@ -10096,7 +11847,7 @@ describe("outdated", () => {
   async function setupWorkspace() {
     await Promise.all([
       write(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "foo",
           workspaces: ["packages/*"],
@@ -10193,7 +11944,7 @@ describe("outdated", () => {
   test("scoped workspace names", async () => {
     await Promise.all([
       write(
-        join(packageDir, "package.json"),
+        packageJson,
         JSON.stringify({
           name: "@foo/bar",
           workspaces: ["packages/*"],
@@ -10276,10 +12027,11 @@ registry = "http://localhost:${port}/"
   expect(err).not.toContain("panic:");
   expect(err).not.toContain("not found");
   expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    expect.stringContaining("bun install v1."),
     "",
     "+ bunx-bins@1.0.0",
     "",
-    expect.stringContaining("1 package installed"),
+    "1 package installed",
   ]);
   expect(await exited).toBe(0);
 
@@ -10385,3 +12137,79 @@ registry = "http://localhost:${port}/"
     });
   }
 });
+
+it("$npm_command is accurate during publish", async () => {
+  await write(
+    packageJson,
+    JSON.stringify({
+      name: "publish-pkg-10",
+      version: "1.0.0",
+      scripts: {
+        publish: "echo $npm_command",
+      },
+    }),
+  );
+  await write(join(packageDir, "bunfig.toml"), await authBunfig("npm_command"));
+  await rm(join(import.meta.dir, "packages", "publish-pkg-10"), { recursive: true, force: true });
+  let { out, err, exitCode } = await publish(env, packageDir, "--tag", "simpletag");
+  expect(err).toBe(`$ echo $npm_command\n`);
+  expect(out.split("\n")).toEqual([
+    `bun publish ${Bun.version_with_sha}`,
+    ``,
+    `packed 95B package.json`,
+    ``,
+    `Total files: 1`,
+    expect.stringContaining(`Shasum: `),
+    expect.stringContaining(`Integrity: sha512-`),
+    `Unpacked size: 95B`,
+    expect.stringContaining(`Packed size: `),
+    `Tag: simpletag`,
+    `Access: default`,
+    `Registry: http://localhost:${port}/`,
+    ``,
+    ` + publish-pkg-10@1.0.0`,
+    `publish`,
+    ``,
+  ]);
+  expect(exitCode).toBe(0);
+});
+
+it("$npm_lifecycle_event is accurate during publish", async () => {
+  await write(
+    packageJson,
+    `{
+      "name": "publish-pkg-11",
+      "version": "1.0.0",
+      "scripts": {
+        "prepublish": "echo 1 $npm_lifecycle_event",
+        "publish": "echo 2 $npm_lifecycle_event",
+        "postpublish": "echo 3 $npm_lifecycle_event",
+      },
+    }
+    `,
+  );
+  await write(join(packageDir, "bunfig.toml"), await authBunfig("npm_lifecycle_event"));
+  await rm(join(import.meta.dir, "packages", "publish-pkg-11"), { recursive: true, force: true });
+  let { out, err, exitCode } = await publish(env, packageDir, "--tag", "simpletag");
+  expect(err).toBe(`$ echo 2 $npm_lifecycle_event\n$ echo 3 $npm_lifecycle_event\n`);
+  expect(out.split("\n")).toEqual([
+    `bun publish ${Bun.version_with_sha}`,
+    ``,
+    `packed 256B package.json`,
+    ``,
+    `Total files: 1`,
+    expect.stringContaining(`Shasum: `),
+    expect.stringContaining(`Integrity: sha512-`),
+    `Unpacked size: 256B`,
+    expect.stringContaining(`Packed size: `),
+    `Tag: simpletag`,
+    `Access: default`,
+    `Registry: http://localhost:${port}/`,
+    ``,
+    ` + publish-pkg-11@1.0.0`,
+    `2 publish`,
+    `3 postpublish`,
+    ``,
+  ]);
+  expect(exitCode).toBe(0);
+});
diff --git a/test/cli/install/registry/packages/lifecycle-fail/lifecycle-fail-1.1.1.tgz b/test/cli/install/registry/packages/lifecycle-fail/lifecycle-fail-1.1.1.tgz
new file mode 100644
index 0000000000..2783b58675
Binary files /dev/null and b/test/cli/install/registry/packages/lifecycle-fail/lifecycle-fail-1.1.1.tgz differ
diff --git a/test/cli/install/registry/packages/lifecycle-fail/package.json b/test/cli/install/registry/packages/lifecycle-fail/package.json
new file mode 100644
index 0000000000..15797c7f68
--- /dev/null
+++ b/test/cli/install/registry/packages/lifecycle-fail/package.json
@@ -0,0 +1,45 @@
+{
+	"name": "lifecycle-fail",
+	"versions": {
+		"1.1.1": {
+			"name": "lifecycle-fail",
+			"version": "1.1.1",
+			"scripts": {
+				"preinstall": "bun fail.js",
+				"postinstall": "bun create.js"
+			},
+			"_id": "lifecycle-fail@1.1.1",
+			"_integrity": "sha512-tqxnPDUZAsW0sy8JUO3LuzuyS7MkvRjGvnnkvbzv1Oo3sRZHMA2yhWDEQ9Bjo0ozxhU+H6vrW2q8EKDAXwnlQw==",
+			"_nodeVersion": "22.6.0",
+			"_npmVersion": "10.8.3",
+			"integrity": "sha512-tqxnPDUZAsW0sy8JUO3LuzuyS7MkvRjGvnnkvbzv1Oo3sRZHMA2yhWDEQ9Bjo0ozxhU+H6vrW2q8EKDAXwnlQw==",
+			"shasum": "455d2b86cb654b846325e808804573bf56c5f1a4",
+			"dist": {
+				"integrity": "sha512-tqxnPDUZAsW0sy8JUO3LuzuyS7MkvRjGvnnkvbzv1Oo3sRZHMA2yhWDEQ9Bjo0ozxhU+H6vrW2q8EKDAXwnlQw==",
+				"shasum": "455d2b86cb654b846325e808804573bf56c5f1a4",
+				"tarball": "http://http://localhost:4873/lifecycle-fail/-/lifecycle-fail-1.1.1.tgz"
+			},
+			"contributors": []
+		}
+	},
+	"time": {
+		"modified": "2024-10-24T03:03:12.460Z",
+		"created": "2024-10-24T03:03:12.460Z",
+		"1.1.1": "2024-10-24T03:03:12.460Z"
+	},
+	"users": {},
+	"dist-tags": {
+		"latest": "1.1.1"
+	},
+	"_uplinks": {},
+	"_distfiles": {},
+	"_attachments": {
+		"lifecycle-fail-1.1.1.tgz": {
+			"shasum": "455d2b86cb654b846325e808804573bf56c5f1a4",
+			"version": "1.1.1"
+		}
+	},
+	"_rev": "",
+	"_id": "lifecycle-fail",
+	"readme": ""
+}
\ No newline at end of file
diff --git a/test/cli/install/registry/packages/optional-lifecycle-fail/optional-lifecycle-fail-1.1.1.tgz b/test/cli/install/registry/packages/optional-lifecycle-fail/optional-lifecycle-fail-1.1.1.tgz
new file mode 100644
index 0000000000..c7e44ed80d
Binary files /dev/null and b/test/cli/install/registry/packages/optional-lifecycle-fail/optional-lifecycle-fail-1.1.1.tgz differ
diff --git a/test/cli/install/registry/packages/optional-lifecycle-fail/package.json b/test/cli/install/registry/packages/optional-lifecycle-fail/package.json
new file mode 100644
index 0000000000..9f9dbb25d6
--- /dev/null
+++ b/test/cli/install/registry/packages/optional-lifecycle-fail/package.json
@@ -0,0 +1,44 @@
+{
+	"name": "optional-lifecycle-fail",
+	"versions": {
+		"1.1.1": {
+			"name": "optional-lifecycle-fail",
+			"version": "1.1.1",
+			"optionalDependencies": {
+				"lifecycle-fail": "1.1.1"
+			},
+			"_id": "optional-lifecycle-fail@1.1.1",
+			"_integrity": "sha512-1nfxe/RpzOaJm7RVSeIux8UMUvrbVDgCCN9lJ1IlnOzd4B6oy9BoKjM4Ij+d9Cmjy+WvhaDKd6AndadHZw5aRw==",
+			"_nodeVersion": "22.6.0",
+			"_npmVersion": "10.8.3",
+			"integrity": "sha512-1nfxe/RpzOaJm7RVSeIux8UMUvrbVDgCCN9lJ1IlnOzd4B6oy9BoKjM4Ij+d9Cmjy+WvhaDKd6AndadHZw5aRw==",
+			"shasum": "3b030a54938f24912a19b4a865210fcac6172350",
+			"dist": {
+				"integrity": "sha512-1nfxe/RpzOaJm7RVSeIux8UMUvrbVDgCCN9lJ1IlnOzd4B6oy9BoKjM4Ij+d9Cmjy+WvhaDKd6AndadHZw5aRw==",
+				"shasum": "3b030a54938f24912a19b4a865210fcac6172350",
+				"tarball": "http://http://localhost:4873/optional-lifecycle-fail/-/optional-lifecycle-fail-1.1.1.tgz"
+			},
+			"contributors": []
+		}
+	},
+	"time": {
+		"modified": "2024-10-24T03:05:13.038Z",
+		"created": "2024-10-24T03:05:13.038Z",
+		"1.1.1": "2024-10-24T03:05:13.038Z"
+	},
+	"users": {},
+	"dist-tags": {
+		"latest": "1.1.1"
+	},
+	"_uplinks": {},
+	"_distfiles": {},
+	"_attachments": {
+		"optional-lifecycle-fail-1.1.1.tgz": {
+			"shasum": "3b030a54938f24912a19b4a865210fcac6172350",
+			"version": "1.1.1"
+		}
+	},
+	"_rev": "",
+	"_id": "optional-lifecycle-fail",
+	"readme": ""
+}
\ No newline at end of file
diff --git a/test/cli/install/registry/verdaccio.yaml b/test/cli/install/registry/verdaccio.yaml
index e46176c27a..6d12f17444 100644
--- a/test/cli/install/registry/verdaccio.yaml
+++ b/test/cli/install/registry/verdaccio.yaml
@@ -75,6 +75,11 @@ packages:
     publish: $authenticated
     unpublish: $authenticated
 
+  "@secret/*":
+    access: $authenticated
+    publish: $authenticated
+    unpublish: $authenticated
+
   "@*/*":
     # scoped packages
     access: $all
@@ -92,7 +97,7 @@ packages:
 
     # allow all known users to publish/publish packages
     # (anyone can register by default, remember?)
-    publish: $authenticated
+    publish: $all
     unpublish: $all
 
     # if package is not available locally, proxy requests to 'npmjs' registry
diff --git a/test/cli/run/env.test.ts b/test/cli/run/env.test.ts
index 18dd4122ff..2bf13d3a9f 100644
--- a/test/cli/run/env.test.ts
+++ b/test/cli/run/env.test.ts
@@ -104,7 +104,7 @@ describe(".env file is loaded", () => {
       "index.test.ts": "console.log(process.env.A,process.env.B,process.env.C,process.env.FAIL);",
     });
     const { stdout } = bunTest(`${dir}/index.test.ts`, {});
-    expect(stdout).toBe("a b c undefined");
+    expect(stdout).toBe(`bun test ${Bun.version_with_sha}\n` + "a b c undefined");
   });
   test(".env.local ignored when bun test", () => {
     const dir = tempDirWithFiles("dotenv", {
@@ -113,7 +113,7 @@ describe(".env file is loaded", () => {
       "index.test.ts": "console.log(process.env.FAILED);",
     });
     const { stdout } = bunTest(`${dir}/index.test.ts`, {});
-    expect(stdout).toBe("false");
+    expect(stdout).toBe(`bun test ${Bun.version_with_sha}\n` + "false");
   });
   test(".env.development and .env.production ignored when bun test", () => {
     const dir = tempDirWithFiles("dotenv", {
@@ -125,14 +125,14 @@ describe(".env file is loaded", () => {
       "index.test.ts": "console.log(process.env.FAILED);",
     });
     const { stdout } = bunTest(`${dir}/index.test.ts`);
-    expect(stdout).toBe("false");
+    expect(stdout).toBe(`bun test ${Bun.version_with_sha}\n` + "false");
   });
   test("NODE_ENV is automatically set to test within bun test", () => {
     const dir = tempDirWithFiles("dotenv", {
       "index.test.ts": "console.log(process.env.NODE_ENV);",
     });
     const { stdout } = bunTest(`${dir}/index.test.ts`);
-    expect(stdout).toBe("test");
+    expect(stdout).toBe(`bun test ${Bun.version_with_sha}\n` + "test");
   });
 });
 describe("dotenv priority", () => {
@@ -153,7 +153,7 @@ describe("dotenv priority", () => {
     expect(stdout).toBe("override");
 
     const { stdout: stdout2 } = bunTest(`${dir}/index.test.ts`, { FOO: "override" });
-    expect(stdout2).toBe("override");
+    expect(stdout2).toBe(`bun test ${Bun.version_with_sha}\n` + "override");
   });
   test(".env.{NODE_ENV}.local overrides .env.local", () => {
     const dir = tempDirWithFiles("dotenv", {
@@ -173,7 +173,7 @@ describe("dotenv priority", () => {
     const { stdout: stdout_prod } = bunRun(`${dir}/index.ts`, { NODE_ENV: "production" });
     expect(stdout_prod).toBe(".env.production.local");
     const { stdout: stdout_test } = bunTest(`${dir}/index.test.ts`, {});
-    expect(stdout_test).toBe(".env.test.local");
+    expect(stdout_test).toBe(`bun test ${Bun.version_with_sha}\n` + ".env.test.local");
   });
   test(".env.local overrides .env.{NODE_ENV}", () => {
     const dir = tempDirWithFiles("dotenv", {
@@ -191,7 +191,7 @@ describe("dotenv priority", () => {
     expect(stdout_prod).toBe(".env.local");
     // .env.local is "not checked when `NODE_ENV` is `test`"
     const { stdout: stdout_test } = bunTest(`${dir}/index.test.ts`, {});
-    expect(stdout_test).toBe(".env.test");
+    expect(stdout_test).toBe(`bun test ${Bun.version_with_sha}\n` + ".env.test");
   });
   test(".env.{NODE_ENV} overrides .env", () => {
     const dir = tempDirWithFiles("dotenv", {
@@ -207,7 +207,7 @@ describe("dotenv priority", () => {
     const { stdout: stdout_prod } = bunRun(`${dir}/index.ts`, { NODE_ENV: "production" });
     expect(stdout_prod).toBe(".env.production");
     const { stdout: stdout_test } = bunTest(`${dir}/index.test.ts`, {});
-    expect(stdout_test).toBe(".env.test");
+    expect(stdout_test).toBe(`bun test ${Bun.version_with_sha}\n` + ".env.test");
   });
 });
 
@@ -643,7 +643,7 @@ console.log(process.env.NODE_ENV, process.env.YOLO);`,
       bunTest(path.join(tmp, "index.test.ts"), {
         YOLO: "boo",
       }).stdout,
-    ).toBe("test\ndevelopment woo!");
+    ).toBe(`bun test ${Bun.version_with_sha}\n` + "test\ndevelopment woo!");
   });
   test("in bun test with explicit setting", () => {
     const tmp = tempDirWithFiles("env-inlining", {
@@ -659,7 +659,7 @@ console.log(process.env.NODE_ENV, process.env.YOLO);`,
         YOLO: "boo",
         NODE_ENV: "production",
       }).stdout,
-    ).toBe("production\ndevelopment woo!");
+    ).toBe(`bun test ${Bun.version_with_sha}\n` + "production\ndevelopment woo!");
   });
   test("in bun test with dynamic access", () => {
     const tmp = tempDirWithFiles("env-inlining", {
@@ -670,7 +670,9 @@ test("my test", () => {
   console.log(dynamic().NODE_ENV);
 });`,
     });
-    expect(bunTest(path.join(tmp, "index.test.ts"), {}).stdout).toBe("test\nproduction");
+    expect(bunTest(path.join(tmp, "index.test.ts"), {}).stdout).toBe(
+      `bun test ${Bun.version_with_sha}\n` + "test\nproduction",
+    );
   });
   test("in bun test with dynamic access + explicit set", () => {
     const tmp = tempDirWithFiles("env-inlining", {
@@ -682,7 +684,7 @@ test("my test", () => {
 });`,
     });
     expect(bunTest(path.join(tmp, "index.test.ts"), { NODE_ENV: "development" }).stdout).toBe(
-      "development\nproduction",
+      `bun test ${Bun.version_with_sha}\n` + "development\nproduction",
     );
   });
 });
@@ -702,7 +704,7 @@ console.log(dynamic().NODE_ENV);
 test("NODE_ENV default is not propogated in bun run", () => {
   const getenv =
     process.platform !== "win32"
-      ? "env | grep NODE_ENV && exit 1 || true"
+      ? "env | grep -v npm_lifecycle_script | grep NODE_ENV && exit 1 || true"
       : "node -e 'if(process.env.NODE_ENV)throw(1)'";
   const tmp = tempDirWithFiles("default-node-env", {
     "package.json": '{"scripts":{"show-env":' + JSON.stringify(getenv) + "}}",
diff --git a/test/cli/run/esm-defineProperty.test.ts b/test/cli/run/esm-defineProperty.test.ts
index d6289b49cc..b8053b18a7 100644
--- a/test/cli/run/esm-defineProperty.test.ts
+++ b/test/cli/run/esm-defineProperty.test.ts
@@ -10,15 +10,24 @@ test("defineProperty", () => {
 
   expect(Bun.inspect(CJS.default)).toBe(`{\n  a: 1,\n  b: 2,\n  c: [Getter],\n}`);
 });
+import * as Self from "./esm-defineProperty.test.ts";
+export const __esModule = true;
+test("shows __esModule if it was exported", () => {
+  expect(Bun.inspect(Self)).toBe(`Module {
+  __esModule: true,
+}`);
+  expect(Object.getOwnPropertyNames(Self)).toContain("__esModule");
+});
 
 test("arraylike", () => {
-  console.log(globalThis);
   expect(CJSArrayLike[0]).toBe(0);
   expect(CJSArrayLike[1]).toBe(1);
   expect(CJSArrayLike[2]).toBe(3);
   expect(CJSArrayLike[3]).toBe(4);
   expect(CJSArrayLike[4]).toBe(undefined);
   expect(CJSArrayLike).toHaveProperty("4");
+  expect(Object.getOwnPropertyNames(CJSArrayLike)).not.toContain("__esModule");
+  expect(Object.getOwnPropertyNames(CJSArrayLike.default)).not.toContain("__esModule");
   expect(Bun.inspect(CJSArrayLike)).toBe(`Module {
   "0": 0,
   "1": 1,
diff --git a/test/cli/run/fragment.tsx b/test/cli/run/fragment.tsx
new file mode 100644
index 0000000000..178877c522
--- /dev/null
+++ b/test/cli/run/fragment.tsx
@@ -0,0 +1 @@
+export const Fragment = () => {};
diff --git a/test/cli/run/jsx-collision.tsx b/test/cli/run/jsx-collision.tsx
new file mode 100644
index 0000000000..07930dd136
--- /dev/null
+++ b/test/cli/run/jsx-collision.tsx
@@ -0,0 +1,3 @@
+import { Fragment } from "./fragment.tsx";
+
+console.log(Fragment);
diff --git a/test/cli/run/jsx-symbol-collision.test.ts b/test/cli/run/jsx-symbol-collision.test.ts
new file mode 100644
index 0000000000..572396b387
--- /dev/null
+++ b/test/cli/run/jsx-symbol-collision.test.ts
@@ -0,0 +1,15 @@
+import { expect, it } from "bun:test";
+import { bunEnv, bunExe } from "harness";
+import { join } from "path";
+
+it("should not have a symbol collision with jsx imports", () => {
+  const { stdout, stderr, exitCode } = Bun.spawnSync({
+    cmd: [bunExe(), "run", "--bun", join(import.meta.dir, "jsx-collision.tsx")],
+    env: bunEnv,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  expect(stdout.toString()).toBe("[Function: Fragment]\n");
+  expect(stderr.toString()).toBeEmpty();
+  expect(exitCode).toBe(0);
+});
diff --git a/test/cli/run/log-test.test.ts b/test/cli/run/log-test.test.ts
index dd684b8e28..c23fb2c1ed 100644
--- a/test/cli/run/log-test.test.ts
+++ b/test/cli/run/log-test.test.ts
@@ -2,7 +2,7 @@ import { spawnSync } from "bun";
 import { expect, it } from "bun:test";
 import * as fs from "fs";
 import { bunEnv, bunExe } from "harness";
-import { dirname, join } from "path";
+import { dirname, join, resolve } from "path";
 
 it("should not log .env when quiet", async () => {
   writeDirectoryTree("/tmp/log-test-silent", {
@@ -36,6 +36,7 @@ it("should log .env by default", async () => {
 });
 
 function writeDirectoryTree(base: string, paths: Record<string, any>) {
+  base = resolve(base);
   for (const path of Object.keys(paths)) {
     const content = paths[path];
     const joined = join(base, path);
diff --git a/test/cli/run/self-reference.test.ts b/test/cli/run/self-reference.test.ts
new file mode 100644
index 0000000000..fe272caae1
--- /dev/null
+++ b/test/cli/run/self-reference.test.ts
@@ -0,0 +1,68 @@
+import { describe, expect, test } from "bun:test";
+import { spawn } from "bun";
+import { bunExe, tmpdirSync } from "harness";
+import { join } from "path";
+import { writeFile } from "fs/promises";
+
+const testWord = "bunny";
+const testString = `${testWord} ${testWord}`;
+
+describe("bun", () => {
+  test("should resolve self-imports by name", async () => {
+    const tempDir = tmpdirSync();
+
+    for (const packageName of ["pkg", "@scope/pkg"]) {
+      // general check without exports
+      await writeFile(
+        join(tempDir, "package.json"),
+        JSON.stringify({
+          name: packageName,
+        }),
+      );
+      await writeFile(join(tempDir, "index.js"), `module.exports.testWord = "${testWord}";`);
+      await writeFile(
+        join(tempDir, "other.js"),
+        `const pkg = require("${packageName}");\nimport pkg2 from "${packageName}"\nconsole.log(pkg.testWord,pkg2.testWord);`,
+      );
+
+      let subprocess = spawn({
+        cmd: [bunExe(), "run", "other.js"],
+        cwd: tempDir,
+        stdout: "pipe",
+      });
+      let out = await new Response(subprocess.stdout).text();
+      expect(out).not.toContain(testString);
+
+      // should not resolve not exported files
+      await writeFile(
+        join(tempDir, "package.json"),
+        JSON.stringify({
+          name: packageName,
+          exports: { "./index.js": "./index.js" },
+        }),
+      );
+
+      subprocess = spawn({
+        cmd: [bunExe(), "run", "other.js"],
+        cwd: tempDir,
+        stdout: "pipe",
+      });
+      out = await new Response(subprocess.stdout).text();
+      expect(out).not.toContain(testString);
+
+      // should resolve exported files
+      await writeFile(
+        join(tempDir, "other.js"),
+        `const pkg = require("${packageName}/index.js");\nimport pkg2 from "${packageName}/index.js"\nconsole.log(pkg.testWord,pkg2.testWord);`,
+      );
+
+      subprocess = spawn({
+        cmd: [bunExe(), "run", "other.js"],
+        cwd: tempDir,
+        stdout: "pipe",
+      });
+      out = await new Response(subprocess.stdout).text();
+      expect(out).toContain(testString);
+    }
+  });
+});
diff --git a/test/cli/test/bun-test.test.ts b/test/cli/test/bun-test.test.ts
index 71400823a9..d4d2e83a19 100644
--- a/test/cli/test/bun-test.test.ts
+++ b/test/cli/test/bun-test.test.ts
@@ -5,6 +5,16 @@ import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 
 describe("bun test", () => {
+  test("running a non-existent absolute file path is a 1 exit code", () => {
+    const spawn = Bun.spawnSync({
+      cmd: [bunExe(), "test", join(import.meta.dirname, "non-existent.test.ts")],
+      env: bunEnv,
+      stdin: "ignore",
+      stdout: "inherit",
+      stderr: "inherit",
+    });
+    expect(spawn.exitCode).toBe(1);
+  });
   test("can provide no arguments", () => {
     const stderr = runTest({
       args: [],
diff --git a/test/cli/test/process-kill-fixture-sync.ts b/test/cli/test/process-kill-fixture-sync.ts
new file mode 100644
index 0000000000..ffd0aadb2a
--- /dev/null
+++ b/test/cli/test/process-kill-fixture-sync.ts
@@ -0,0 +1,17 @@
+import { expect, test } from "bun:test";
+import { bunEnv, bunExe } from "harness";
+
+test("test timeout kills dangling processes", async () => {
+  Bun.spawnSync({
+    cmd: [bunExe(), "--eval", "Bun.sleepSync(500); console.log('This should not be printed!');"],
+    stdout: "inherit",
+    stderr: "inherit",
+    stdin: "inherit",
+    env: bunEnv,
+  });
+}, 10);
+
+test("slow test after test timeout", async () => {
+  await Bun.sleep(100);
+  console.log("Ran slow test");
+}, 200);
diff --git a/test/cli/test/process-kill-fixture.ts b/test/cli/test/process-kill-fixture.ts
new file mode 100644
index 0000000000..ee1a5569e6
--- /dev/null
+++ b/test/cli/test/process-kill-fixture.ts
@@ -0,0 +1,18 @@
+import { expect, test } from "bun:test";
+import { bunEnv, bunExe } from "harness";
+
+test("test timeout kills dangling processes", async () => {
+  Bun.spawn({
+    cmd: [bunExe(), "--eval", "Bun.sleepSync(50); console.log('This should not be printed!');"],
+    stdout: "inherit",
+    stderr: "inherit",
+    stdin: "inherit",
+    env: bunEnv,
+  });
+  await Bun.sleep(5);
+}, 1);
+
+test("slow test after test timeout", async () => {
+  await Bun.sleep(100);
+  console.log("Ran slow test");
+}, 200);
diff --git a/test/cli/test/test-timeout-behavior.test.ts b/test/cli/test/test-timeout-behavior.test.ts
new file mode 100644
index 0000000000..30547a67c7
--- /dev/null
+++ b/test/cli/test/test-timeout-behavior.test.ts
@@ -0,0 +1,28 @@
+import { test, expect } from "bun:test";
+import { bunEnv, bunExe, isFlaky, isLinux } from "harness";
+import path from "path";
+
+if (isFlaky && isLinux) {
+  test.todo("processes get killed");
+} else {
+  test.each([true, false])("processes get killed", async sync => {
+    const { exited, stdout, stderr } = Bun.spawn({
+      cmd: [
+        bunExe(),
+        "test",
+        path.join(import.meta.dir, sync ? "process-kill-fixture-sync.ts" : "process-kill-fixture.ts"),
+      ],
+      stdout: "pipe",
+      stderr: "pipe",
+      stdin: "inherit",
+      env: bunEnv,
+    });
+    const [out, err, exitCode] = await Promise.all([new Response(stdout).text(), new Response(stderr).text(), exited]);
+    console.log(out);
+    console.log(err);
+    // TODO: figure out how to handle terminatio nexception from spawn sync properly.
+    expect(exitCode).not.toBe(0);
+    expect(out).not.toContain("This should not be printed!");
+    expect(err).toContain("killed 1 dangling process");
+  });
+}
diff --git a/test/cli/watch/watch.test.ts b/test/cli/watch/watch.test.ts
index b30dfd1436..a2ecb7c255 100644
--- a/test/cli/watch/watch.test.ts
+++ b/test/cli/watch/watch.test.ts
@@ -1,42 +1,46 @@
 import type { Subprocess } from "bun";
 import { spawn } from "bun";
 import { afterEach, expect, it } from "bun:test";
-import { bunEnv, bunExe, tmpdirSync } from "harness";
+import { bunEnv, bunExe, isBroken, isWindows, tmpdirSync } from "harness";
 import { rmSync } from "node:fs";
 import { join } from "node:path";
 
 let watchee: Subprocess;
 
 for (const dir of ["dir", "©️"]) {
-  it(`should watch files ${dir === "dir" ? "" : "(non-ascii path)"}`, async () => {
-    const cwd = join(tmpdirSync(), dir);
-    const path = join(cwd, "watchee.js");
+  it.todoIf(isBroken && isWindows)(
+    `should watch files ${dir === "dir" ? "" : "(non-ascii path)"}`,
+    async () => {
+      const cwd = join(tmpdirSync(), dir);
+      const path = join(cwd, "watchee.js");
 
-    const updateFile = async (i: number) => {
-      await Bun.write(path, `console.log(${i}, __dirname);`);
-    };
+      const updateFile = async (i: number) => {
+        await Bun.write(path, `console.log(${i}, __dirname);`);
+      };
 
-    let i = 0;
-    await updateFile(i);
-    await Bun.sleep(1000);
-    watchee = spawn({
-      cwd,
-      cmd: [bunExe(), "--watch", "watchee.js"],
-      env: bunEnv,
-      stdout: "pipe",
-      stderr: "inherit",
-      stdin: "ignore",
-    });
-
-    for await (const line of watchee.stdout) {
-      if (i == 10) break;
-      var str = new TextDecoder().decode(line);
-      expect(str).toContain(`${i} ${cwd}`);
-      i++;
+      let i = 0;
       await updateFile(i);
-    }
-    rmSync(path);
-  }, 10000);
+      await Bun.sleep(1000);
+      watchee = spawn({
+        cwd,
+        cmd: [bunExe(), "--watch", "watchee.js"],
+        env: bunEnv,
+        stdout: "pipe",
+        stderr: "inherit",
+        stdin: "ignore",
+      });
+
+      for await (const line of watchee.stdout) {
+        if (i == 10) break;
+        var str = new TextDecoder().decode(line);
+        expect(str).toContain(`${i} ${cwd}`);
+        i++;
+        await updateFile(i);
+      }
+      rmSync(path);
+    },
+    10000,
+  );
 }
 
 afterEach(() => {
diff --git a/test/harness.ts b/test/harness.ts
index d28882adfb..0921b1dcc0 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 detectLibc from "detect-libc";
 
 type Awaitable<T> = T | Promise<T>;
 
@@ -18,6 +19,15 @@ 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 libcFamily = detectLibc.familySync() as "glibc" | "musl";
+export const isVerbose = process.env.DEBUG === "1";
+
+// Use these to mark a test as flaky or broken.
+// This will help us keep track of these tests.
+//
+// test.todoIf(isFlaky && isMacOS)("this test is flaky");
+export const isFlaky = isCI;
+export const isBroken = isCI;
 
 export const bunEnv: NodeJS.ProcessEnv = {
   ...process.env,
@@ -30,6 +40,7 @@ export const bunEnv: NodeJS.ProcessEnv = {
   BUN_RUNTIME_TRANSPILER_CACHE_PATH: "0",
   BUN_FEATURE_FLAG_INTERNAL_FOR_TESTING: "1",
   BUN_GARBAGE_COLLECTOR_LEVEL: process.env.BUN_GARBAGE_COLLECTOR_LEVEL || "0",
+  BUN_FEATURE_FLAG_EXPERIMENTAL_BAKE: "1",
 };
 
 if (isWindows) {
@@ -133,7 +144,7 @@ export function hideFromStackTrace(block: CallableFunction) {
   });
 }
 
-type DirectoryTree = {
+export type DirectoryTree = {
   [name: string]:
     | string
     | Buffer
@@ -300,137 +311,174 @@ const binaryTypes = {
   "float32array": Float32Array,
   "float64array": Float64Array,
 } as const;
-
-expect.extend({
-  toHaveTestTimedOutAfter(actual: any, expected: number) {
-    if (typeof actual !== "string") {
-      return {
-        pass: false,
-        message: () => `Expected ${actual} to be a string`,
-      };
-    }
-
-    const preStartI = actual.indexOf("timed out after ");
-    if (preStartI === -1) {
-      return {
-        pass: false,
-        message: () => `Expected ${actual} to contain "timed out after "`,
-      };
-    }
-    const startI = preStartI + "timed out after ".length;
-    const endI = actual.indexOf("ms", startI);
-    if (endI === -1) {
-      return {
-        pass: false,
-        message: () => `Expected ${actual} to contain "ms" after "timed out after "`,
-      };
-    }
-    const int = parseInt(actual.slice(startI, endI));
-    if (!Number.isSafeInteger(int)) {
-      return {
-        pass: false,
-        message: () => `Expected ${int} to be a safe integer`,
-      };
-    }
-
-    return {
-      pass: int >= expected,
-      message: () => `Expected ${int} to be >= ${expected}`,
-    };
-  },
-  toBeBinaryType(actual: any, expected: keyof typeof binaryTypes) {
-    switch (expected) {
-      case "buffer":
+if (expect.extend)
+  expect.extend({
+    toHaveTestTimedOutAfter(actual: any, expected: number) {
+      if (typeof actual !== "string") {
         return {
-          pass: Buffer.isBuffer(actual),
-          message: () => `Expected ${actual} to be buffer`,
+          pass: false,
+          message: () => `Expected ${actual} to be a string`,
         };
-      case "arraybuffer":
+      }
+
+      const preStartI = actual.indexOf("timed out after ");
+      if (preStartI === -1) {
         return {
-          pass: actual instanceof ArrayBuffer,
-          message: () => `Expected ${actual} to be ArrayBuffer`,
+          pass: false,
+          message: () => `Expected ${actual} to contain "timed out after "`,
         };
-      default: {
-        const ctor = binaryTypes[expected];
-        if (!ctor) {
+      }
+      const startI = preStartI + "timed out after ".length;
+      const endI = actual.indexOf("ms", startI);
+      if (endI === -1) {
+        return {
+          pass: false,
+          message: () => `Expected ${actual} to contain "ms" after "timed out after "`,
+        };
+      }
+      const int = parseInt(actual.slice(startI, endI));
+      if (!Number.isSafeInteger(int)) {
+        return {
+          pass: false,
+          message: () => `Expected ${int} to be a safe integer`,
+        };
+      }
+
+      return {
+        pass: int >= expected,
+        message: () => `Expected ${int} to be >= ${expected}`,
+      };
+    },
+    toBeBinaryType(actual: any, expected: keyof typeof binaryTypes) {
+      switch (expected) {
+        case "buffer":
           return {
-            pass: false,
-            message: () => `Expected ${expected} to be a binary type`,
+            pass: Buffer.isBuffer(actual),
+            message: () => `Expected ${actual} to be buffer`,
+          };
+        case "arraybuffer":
+          return {
+            pass: actual instanceof ArrayBuffer,
+            message: () => `Expected ${actual} to be ArrayBuffer`,
+          };
+        default: {
+          const ctor = binaryTypes[expected];
+          if (!ctor) {
+            return {
+              pass: false,
+              message: () => `Expected ${expected} to be a binary type`,
+            };
+          }
+
+          return {
+            pass: actual instanceof ctor,
+            message: () => `Expected ${actual} to be ${expected}`,
           };
         }
-
-        return {
-          pass: actual instanceof ctor,
-          message: () => `Expected ${actual} to be ${expected}`,
-        };
       }
-    }
-  },
-  toRun(cmds: string[], optionalStdout?: string, expectedCode: number = 0) {
-    const result = Bun.spawnSync({
-      cmd: [bunExe(), ...cmds],
-      env: bunEnv,
-      stdio: ["inherit", "pipe", "inherit"],
-    });
+    },
+    toRun(cmds: string[], optionalStdout?: string, expectedCode: number = 0) {
+      const result = Bun.spawnSync({
+        cmd: [bunExe(), ...cmds],
+        env: bunEnv,
+        stdio: ["inherit", "pipe", "inherit"],
+      });
 
-    if (result.exitCode !== expectedCode) {
-      return {
-        pass: false,
-        message: () => `Command ${cmds.join(" ")} failed:` + "\n" + result.stdout.toString("utf-8"),
-      };
-    }
-
-    if (optionalStdout != null) {
-      return {
-        pass: result.stdout.toString("utf-8") === optionalStdout,
-        message: () =>
-          `Expected ${cmds.join(" ")} to output ${optionalStdout} but got ${result.stdout.toString("utf-8")}`,
-      };
-    }
-
-    return {
-      pass: true,
-      message: () => `Expected ${cmds.join(" ")} to fail`,
-    };
-  },
-  toThrowWithCode(fn: CallableFunction, cls: CallableFunction, code: string) {
-    try {
-      fn();
-      return {
-        pass: false,
-        message: () => `Received function did not throw`,
-      };
-    } catch (e) {
-      // expect(e).toBeInstanceOf(cls);
-      if (!(e instanceof cls)) {
+      if (result.exitCode !== expectedCode) {
         return {
           pass: false,
-          message: () => `Expected error to be instanceof ${cls.name}; got ${e.__proto__.constructor.name}`,
+          message: () => `Command ${cmds.join(" ")} failed:` + "\n" + result.stdout.toString("utf-8"),
         };
       }
 
-      // expect(e).toHaveProperty("code");
-      if (!("code" in e)) {
+      if (optionalStdout != null) {
         return {
-          pass: false,
-          message: () => `Expected error to have property 'code'; got ${e}`,
-        };
-      }
-
-      // expect(e.code).toEqual(code);
-      if (e.code !== code) {
-        return {
-          pass: false,
-          message: () => `Expected error to have code '${code}'; got ${e.code}`,
+          pass: result.stdout.toString("utf-8") === optionalStdout,
+          message: () =>
+            `Expected ${cmds.join(" ")} to output ${optionalStdout} but got ${result.stdout.toString("utf-8")}`,
         };
       }
 
       return {
         pass: true,
+        message: () => `Expected ${cmds.join(" ")} to fail`,
       };
-    }
-  },
-});
+    },
+    toThrowWithCode(fn: CallableFunction, cls: CallableFunction, code: string) {
+      try {
+        fn();
+        return {
+          pass: false,
+          message: () => `Received function did not throw`,
+        };
+      } catch (e) {
+        // expect(e).toBeInstanceOf(cls);
+        if (!(e instanceof cls)) {
+          return {
+            pass: false,
+            message: () => `Expected error to be instanceof ${cls.name}; got ${e.__proto__.constructor.name}`,
+          };
+        }
+
+        // expect(e).toHaveProperty("code");
+        if (!("code" in e)) {
+          return {
+            pass: false,
+            message: () => `Expected error to have property 'code'; got ${e}`,
+          };
+        }
+
+        // expect(e.code).toEqual(code);
+        if (e.code !== code) {
+          return {
+            pass: false,
+            message: () => `Expected error to have code '${code}'; got ${e.code}`,
+          };
+        }
+
+        return {
+          pass: true,
+        };
+      }
+    },
+    async toThrowWithCodeAsync(fn: CallableFunction, cls: CallableFunction, code: string) {
+      try {
+        await fn();
+        return {
+          pass: false,
+          message: () => `Received function did not throw`,
+        };
+      } catch (e) {
+        // expect(e).toBeInstanceOf(cls);
+        if (!(e instanceof cls)) {
+          return {
+            pass: false,
+            message: () => `Expected error to be instanceof ${cls.name}; got ${e.__proto__.constructor.name}`,
+          };
+        }
+
+        // expect(e).toHaveProperty("code");
+        if (!("code" in e)) {
+          return {
+            pass: false,
+            message: () => `Expected error to have property 'code'; got ${e}`,
+          };
+        }
+
+        // expect(e.code).toEqual(code);
+        if (e.code !== code) {
+          return {
+            pass: false,
+            message: () => `Expected error to have code '${code}'; got ${e.code}`,
+          };
+        }
+
+        return {
+          pass: true,
+        };
+      }
+    },
+  });
 
 export function ospath(path: string) {
   if (isWindows) {
@@ -969,7 +1017,7 @@ export async function runBunInstall(
   });
   expect(stdout).toBeDefined();
   expect(stderr).toBeDefined();
-  let err = (await new Response(stderr).text()).replace(/warn: Slow filesystem.*/g, "");
+  let err = stderrForInstall(await new Response(stderr).text());
   expect(err).not.toContain("panic:");
   if (!options?.allowErrors) {
     expect(err).not.toContain("error:");
@@ -985,6 +1033,11 @@ export async function runBunInstall(
   return { out, err, exited };
 }
 
+// stderr with `slow filesystem` warning removed
+export function stderrForInstall(err: string) {
+  return err.replace(/warn: Slow filesystem.*/g, "");
+}
+
 export async function runBunUpdate(
   env: NodeJS.ProcessEnv,
   cwd: string,
@@ -1011,6 +1064,30 @@ export async function runBunUpdate(
   return { out: out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/), err, exitCode };
 }
 
+export async function pack(cwd: string, env: NodeJS.ProcessEnv, ...args: string[]) {
+  const { stdout, stderr, exited } = Bun.spawn({
+    cmd: [bunExe(), "pm", "pack", ...args],
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+    stdin: "ignore",
+    env,
+  });
+
+  const err = await Bun.readableStreamToText(stderr);
+  expect(err).not.toContain("error:");
+  expect(err).not.toContain("warning:");
+  expect(err).not.toContain("failed");
+  expect(err).not.toContain("panic:");
+
+  const out = await Bun.readableStreamToText(stdout);
+
+  const exitCode = await exited;
+  expect(exitCode).toBe(0);
+
+  return { out, err };
+}
+
 // If you need to modify, clone it
 export const expiredTls = Object.freeze({
   cert: "-----BEGIN CERTIFICATE-----\nMIIDXTCCAkWgAwIBAgIJAKLdQVPy90jjMA0GCSqGSIb3DQEBCwUAMEUxCzAJBgNV\nBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBX\naWRnaXRzIFB0eSBMdGQwHhcNMTkwMjAzMTQ0OTM1WhcNMjAwMjAzMTQ0OTM1WjBF\nMQswCQYDVQQGEwJBVTETMBEGA1UECAwKU29tZS1TdGF0ZTEhMB8GA1UECgwYSW50\nZXJuZXQgV2lkZ2l0cyBQdHkgTHRkMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB\nCgKCAQEA7i7IIEdICTiSTVx+ma6xHxOtcbd6wGW3nkxlCkJ1UuV8NmY5ovMsGnGD\nhJJtUQ2j5ig5BcJUf3tezqCNW4tKnSOgSISfEAKvpn2BPvaFq3yx2Yjz0ruvcGKp\nDMZBXmB/AAtGyN/UFXzkrcfppmLHJTaBYGG6KnmU43gPkSDy4iw46CJFUOupc51A\nFIz7RsE7mbT1plCM8e75gfqaZSn2k+Wmy+8n1HGyYHhVISRVvPqkS7gVLSVEdTea\nUtKP1Vx/818/HDWk3oIvDVWI9CFH73elNxBkMH5zArSNIBTehdnehyAevjY4RaC/\nkK8rslO3e4EtJ9SnA4swOjCiqAIQEwIDAQABo1AwTjAdBgNVHQ4EFgQUv5rc9Smm\n9c4YnNf3hR49t4rH4yswHwYDVR0jBBgwFoAUv5rc9Smm9c4YnNf3hR49t4rH4ysw\nDAYDVR0TBAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAQEATcL9CAAXg0u//eYUAlQa\nL+l8yKHS1rsq1sdmx7pvsmfZ2g8ONQGfSF3TkzkI2OOnCBokeqAYuyT8awfdNUtE\nEHOihv4ZzhK2YZVuy0fHX2d4cCFeQpdxno7aN6B37qtsLIRZxkD8PU60Dfu9ea5F\nDDynnD0TUabna6a0iGn77yD8GPhjaJMOz3gMYjQFqsKL252isDVHEDbpVxIzxPmN\nw1+WK8zRNdunAcHikeoKCuAPvlZ83gDQHp07dYdbuZvHwGj0nfxBLc9qt90XsBtC\n4IYR7c/bcLMmKXYf0qoQ4OzngsnPI5M+v9QEHvYWaKVwFY4CTcSNJEwfXw+BAeO5\nOA==\n-----END CERTIFICATE-----",
@@ -1042,34 +1119,35 @@ String.prototype.isUTF16 = function () {
   return require("bun:internal-for-testing").jscInternals.isUTF16String(this);
 };
 
-expect.extend({
-  toBeLatin1String(actual: unknown) {
-    if ((actual as string).isLatin1()) {
+if (expect.extend)
+  expect.extend({
+    toBeLatin1String(actual: unknown) {
+      if ((actual as string).isLatin1()) {
+        return {
+          pass: true,
+          message: () => `Expected ${actual} to be a Latin1 string`,
+        };
+      }
+
       return {
-        pass: true,
+        pass: false,
         message: () => `Expected ${actual} to be a Latin1 string`,
       };
-    }
+    },
+    toBeUTF16String(actual: unknown) {
+      if ((actual as string).isUTF16()) {
+        return {
+          pass: true,
+          message: () => `Expected ${actual} to be a UTF16 string`,
+        };
+      }
 
-    return {
-      pass: false,
-      message: () => `Expected ${actual} to be a Latin1 string`,
-    };
-  },
-  toBeUTF16String(actual: unknown) {
-    if ((actual as string).isUTF16()) {
       return {
-        pass: true,
+        pass: false,
         message: () => `Expected ${actual} to be a UTF16 string`,
       };
-    }
-
-    return {
-      pass: false,
-      message: () => `Expected ${actual} to be a UTF16 string`,
-    };
-  },
-});
+    },
+  });
 
 interface BunHarnessTestMatchers {
   toBeLatin1String(): void;
@@ -1078,6 +1156,7 @@ interface BunHarnessTestMatchers {
   toBeBinaryType(expected: keyof typeof binaryTypes): void;
   toRun(optionalStdout?: string, expectedCode?: number): void;
   toThrowWithCode(cls: CallableFunction, code: string): void;
+  toThrowWithCodeAsync(cls: CallableFunction, code: string): void;
 }
 
 declare module "bun:test" {
@@ -1290,3 +1369,37 @@ export function waitForFileToExist(path: string, interval: number) {
     sleepSync(interval);
   }
 }
+
+export function libcPathForDlopen() {
+  switch (process.platform) {
+    case "linux":
+      switch (libcFamily) {
+        case "glibc":
+          return "libc.so.6";
+        case "musl":
+          return "/usr/lib/libc.so";
+      }
+    case "darwin":
+      return "libc.dylib";
+    default:
+      throw new Error("TODO");
+  }
+}
+
+export function cwdScope(cwd: string) {
+  const original = process.cwd();
+  process.chdir(cwd);
+  return {
+    [Symbol.dispose]() {
+      process.chdir(original);
+    },
+  };
+}
+
+export function rmScope(path: string) {
+  return {
+    [Symbol.dispose]() {
+      fs.rmSync(path, { recursive: true, force: true });
+    },
+  };
+}
diff --git a/test/integration/next-pages/test/dev-server-puppeteer.ts b/test/integration/next-pages/test/dev-server-puppeteer.ts
index 8fbe192450..06bf56b425 100644
--- a/test/integration/next-pages/test/dev-server-puppeteer.ts
+++ b/test/integration/next-pages/test/dev-server-puppeteer.ts
@@ -1,8 +1,9 @@
 import assert from "assert";
 import { copyFileSync } from "fs";
 import { join } from "path";
-import { ConsoleMessage, Page, launch } from "puppeteer";
-
+import type { ConsoleMessage, Page } from "puppeteer";
+import { launch } from "puppeteer";
+import { which } from "bun";
 const root = join(import.meta.dir, "../");
 
 copyFileSync(join(root, "src/Counter1.txt"), join(root, "src/Counter.tsx"));
@@ -12,31 +13,52 @@ if (process.argv.length > 2) {
   url = process.argv[2];
 }
 
+const browserPath = which("chromium-browser") || which("chromium") || which("chrome") || undefined;
+if (!browserPath) {
+  console.warn("Since a Chromium browser was not found, it will be downloaded by Puppeteer.");
+}
+
 const b = await launch({
-  // While puppeteer is migrating to their new headless: `true` mode,
-  // this causes strange issues on macOS in the cloud (AWS and MacStadium).
-  //
-  // There is a GitHub issue, but the discussion is unhelpful:
-  // https://github.com/puppeteer/puppeteer/issues/10153
-  //
-  // Fixes: 'TargetCloseError: Protocol error (Target.setAutoAttach): Target closed'
-  headless: "shell",
+  // On macOS, there are issues using the new headless mode.
+  // "TargetCloseError: Protocol error (Target.setAutoAttach): Target closed"
+  headless: process.platform === "darwin" ? "shell" : true,
+  // Inherit the stdout and stderr of the browser process.
   dumpio: true,
+  // Prefer to use a pipe to connect to the browser, instead of a WebSocket.
   pipe: true,
+  // Disable timeouts.
+  timeout: 0,
+  protocolTimeout: 0,
+  // Specify that chrome should be used, for consistent test results.
+  // If a browser path is not found, it will be downloaded.
+  browser: "chrome",
+  executablePath: browserPath,
   args: [
-    // Fixes: 'dock_plist is not an NSDictionary'
+    // On Linux, there are issues with the sandbox, so disable it.
+    // On macOS, this fixes: "dock_plist is not an NSDictionary"
     "--no-sandbox",
-    "--single-process",
     "--disable-setuid-sandbox",
+
+    // On Docker, the default /dev/shm is too small for Chrome, which causes
+    // crashes when rendering large pages, so disable it.
     "--disable-dev-shm-usage",
-    // Fixes: 'Navigating frame was detached'
+
+    // Fixes: "Navigating frame was detached"
     "--disable-features=site-per-process",
-    // Uncomment if you want debug logs from Chromium:
-    // "--enable-logging=stderr",
-    // "--v=1",
   ],
 });
 
+process.on("beforeExit", async reason => {
+  await b?.close?.();
+});
+
+process.once("SIGTERM", () => {
+  b?.close?.();
+  setTimeout(() => {
+    process.exit(0);
+  }, 100);
+});
+
 async function main() {
   const p = await b.newPage();
   console.error("Loaded puppeteer");
diff --git a/test/integration/next-pages/test/dev-server.test.ts b/test/integration/next-pages/test/dev-server.test.ts
index ae7fadb38d..6a3c553c6e 100644
--- a/test/integration/next-pages/test/dev-server.test.ts
+++ b/test/integration/next-pages/test/dev-server.test.ts
@@ -79,7 +79,7 @@ async function getDevServerURL() {
   readStream()
     .catch(e => reject(e))
     .finally(() => {
-      dev_server.unref?.();
+      dev_server?.unref?.();
     });
   await promise;
   return baseUrl;
diff --git a/test/integration/next-pages/test/next-build.test.ts b/test/integration/next-pages/test/next-build.test.ts
index a94e50dc5c..c7c1f048b5 100644
--- a/test/integration/next-pages/test/next-build.test.ts
+++ b/test/integration/next-pages/test/next-build.test.ts
@@ -11,7 +11,10 @@ expect.extend({ toMatchNodeModulesAt });
 const root = join(import.meta.dir, "../");
 
 async function tempDirToBuildIn() {
-  const dir = tmpdirSync();
+  const dir = tmpdirSync(
+    "next-" + Math.ceil(performance.now() * 1000).toString(36) + Math.random().toString(36).substring(2, 8),
+  );
+  console.log("Temp dir: " + dir);
   const copy = [
     ".eslintrc.json",
     "bun.lockb",
@@ -42,30 +45,37 @@ async function tempDirToBuildIn() {
   return dir;
 }
 
+async function hashFile(file: string, path: string, hashes: Record<string, string>) {
+  try {
+    const contents = await fs.readFile(path);
+    hashes[file] = Bun.CryptoHasher.hash("sha256", contents, "hex");
+  } catch (error) {
+    console.error("error", error, "in", path);
+    throw error;
+  }
+}
+
 async function hashAllFiles(dir: string) {
-  console.log("Hashing");
-  const files = (await fs.readdir(dir, { recursive: true, withFileTypes: true })).sort();
-  const hashes: Record<string, string> = {};
-  const promises = new Array(files.length);
-  for (let i = 0; i < promises.length; i++) {
-    if (!(files[i].isFile() || files[i].isSymbolicLink())) {
-      i--;
-      promises.length--;
-      continue;
+  console.time("Hashing");
+  try {
+    const files = (await fs.readdir(dir, { recursive: true, withFileTypes: true }))
+      .filter(x => x.isFile() || x.isSymbolicLink())
+      .sort((a, b) => {
+        return a.name.localeCompare(b.name);
+      });
+
+    const hashes: Record<string, string> = {};
+    const batchSize = 4;
+
+    while (files.length > 0) {
+      const batch = files.splice(0, batchSize);
+      await Promise.all(batch.map(file => hashFile(file.name, join(file.parentPath, file.name), hashes)));
     }
 
-    promises[i] = (async function (file, path) {
-      try {
-        const contents = await fs.readFile(path);
-        hashes[file] = Bun.CryptoHasher.hash("sha256", contents, "hex");
-      } catch (error) {
-        console.error("error", error, "in", path);
-        throw error;
-      }
-    })(files[i].name, join(dir, files[i].name));
+    return hashes;
+  } finally {
+    console.timeEnd("Hashing");
   }
-  await Promise.all(promises);
-  return hashes;
 }
 
 function normalizeOutput(stdout: string) {
@@ -103,21 +113,33 @@ test(
     console.log("Node Dir: " + nodeDir);
 
     const nextPath = "node_modules/next/dist/bin/next";
-
+    const tmp1 = tmpdirSync();
     console.time("[bun] next build");
     const bunBuild = Bun.spawn([bunExe(), "--bun", nextPath, "build"], {
       cwd: bunDir,
       stdio: ["ignore", "pipe", "inherit"],
       env: {
         ...bunEnv,
+        NODE_NO_WARNINGS: "1",
         NODE_ENV: "production",
+        TMPDIR: tmp1,
+        TEMP: tmp1,
+        TMP: tmp1,
       },
     });
 
+    const tmp2 = tmpdirSync();
     console.time("[node] next build");
     const nodeBuild = Bun.spawn(["node", nextPath, "build"], {
       cwd: nodeDir,
-      env: { ...bunEnv, NODE_NO_WARNINGS: "1", NODE_ENV: "production" },
+      env: {
+        ...bunEnv,
+        NODE_NO_WARNINGS: "1",
+        NODE_ENV: "production",
+        TMPDIR: tmp2,
+        TEMP: tmp2,
+        TMP: tmp2,
+      },
       stdio: ["ignore", "pipe", "inherit"],
     });
     await Promise.all([
diff --git a/test/integration/sass/__snapshots__/sass.test.ts.snap b/test/integration/sass/__snapshots__/sass.test.ts.snap
new file mode 100644
index 0000000000..5160965305
--- /dev/null
+++ b/test/integration/sass/__snapshots__/sass.test.ts.snap
@@ -0,0 +1,40 @@
+// Bun Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`sass source maps 1`] = `
+{
+  "css": 
+".ruleGroup {
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+  padding: 0.5rem;
+  border-width: 1px;
+}"
+,
+  "loadedUrls": [],
+}
+`;
+
+exports[`sass source maps 2`] = `
+{
+  "css": 
+".ruleGroup {
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+  padding: 0.5rem;
+  border-width: 1px;
+}"
+,
+  "loadedUrls": [],
+  "sourceMap": {
+    "mappings": "AAAA;EACI;EACA;EACA;EACA;EACA",
+    "names": [],
+    "sourceRoot": "",
+    "sources": [
+      "data:;charset=utf-8,.ruleGroup%20%7B%0A%20%20%20%20display:%20flex;%0A%20%20%20%20flex-direction:%20column;%0A%20%20%20%20gap:%200.5rem;%0A%20%20%20%20padding:%200.5rem;%0A%20%20%20%20border-width:%201px;%0A%20%20%7D%0A%20%20",
+    ],
+    "version": 3,
+  },
+}
+`;
diff --git a/test/integration/sass/sass.test.ts b/test/integration/sass/sass.test.ts
new file mode 100644
index 0000000000..f5520a6f22
--- /dev/null
+++ b/test/integration/sass/sass.test.ts
@@ -0,0 +1,15 @@
+import { compileString } from "sass";
+
+test("sass source maps", () => {
+  const scssString = `.ruleGroup {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+    padding: 0.5rem;
+    border-width: 1px;
+  }
+  `;
+
+  expect(compileString(scssString, { sourceMap: false })).toMatchSnapshot();
+  expect(compileString(scssString, { sourceMap: true })).toMatchSnapshot();
+});
diff --git a/test/js/bun/console/__snapshots__/bun-inspect-table.test.ts.snap b/test/js/bun/console/__snapshots__/bun-inspect-table.test.ts.snap
new file mode 100644
index 0000000000..0dbd06b2d1
--- /dev/null
+++ b/test/js/bun/console/__snapshots__/bun-inspect-table.test.ts.snap
@@ -0,0 +1,289 @@
+// Bun Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`inspect.table { a: 1, b: 2 } 1`] = `
+"┌───┬────────┐
+│   │ Values │
+├───┼────────┤
+│ a │ 1      │
+│ b │ 2      │
+└───┴────────┘
+"
+`;
+
+exports[`inspect.table { a: 1, b: 2, c: 3 } 1`] = `
+"┌───┬────────┐
+│   │ Values │
+├───┼────────┤
+│ a │ 1      │
+│ b │ 2      │
+│ c │ 3      │
+└───┴────────┘
+"
+`;
+
+exports[`inspect.table { a: 1, b: 2, c: 3, d: 4 } 1`] = `
+"┌───┬────────┐
+│   │ Values │
+├───┼────────┤
+│ a │ 1      │
+│ b │ 2      │
+│ c │ 3      │
+│ d │ 4      │
+└───┴────────┘
+"
+`;
+
+exports[`inspect.table Map(2) { "a": 1, "b": 2 } 1`] = `
+"┌───┬─────┬────────┐
+│   │ Key │ Values │
+├───┼─────┼────────┤
+│ 0 │ a   │ 1      │
+│ 1 │ b   │ 2      │
+└───┴─────┴────────┘
+"
+`;
+
+exports[`inspect.table [ [ "a", 1 ], [ "b", 2 ] ] 1`] = `
+"┌───┬───┬───┐
+│   │ 0 │ 1 │
+├───┼───┼───┤
+│ 0 │ a │ 1 │
+│ 1 │ b │ 2 │
+└───┴───┴───┘
+"
+`;
+
+exports[`inspect.table Set(3) { 1, 2, 3 } 1`] = `
+"┌───┬────────┐
+│   │ Values │
+├───┼────────┤
+│ 0 │ 1      │
+│ 1 │ 2      │
+│ 2 │ 3      │
+└───┴────────┘
+"
+`;
+
+exports[`inspect.table { "0": 1, "1": 2, "2": 3 } 1`] = `
+"┌───┬────────┐
+│   │ Values │
+├───┼────────┤
+│ 0 │ 1      │
+│ 1 │ 2      │
+│ 2 │ 3      │
+└───┴────────┘
+"
+`;
+
+exports[`inspect.table [ 1, 2, 3 ] 1`] = `
+"┌───┬────────┐
+│   │ Values │
+├───┼────────┤
+│ 0 │ 1      │
+│ 1 │ 2      │
+│ 2 │ 3      │
+└───┴────────┘
+"
+`;
+
+exports[`inspect.table [ "a", 1, "b", 2, "c", 3 ] 1`] = `
+"┌───┬────────┐
+│   │ Values │
+├───┼────────┤
+│ 0 │ a      │
+│ 1 │ 1      │
+│ 2 │ b      │
+│ 3 │ 2      │
+│ 4 │ c      │
+│ 5 │ 3      │
+└───┴────────┘
+"
+`;
+
+exports[`inspect.table [ /a/, 1, /b/, 2, /c/, 3 ] 1`] = `
+"┌───┬────────┐
+│   │ Values │
+├───┼────────┤
+│ 0 │        │
+│ 1 │ 1      │
+│ 2 │        │
+│ 3 │ 2      │
+│ 4 │        │
+│ 5 │ 3      │
+└───┴────────┘
+"
+`;
+
+exports[`inspect.table (ansi) { a: 1, b: 2 } 1`] = `
+"┌───┬────────┐
+│   │ Values │
+├───┼────────┤
+│ a │ 1      │
+│ b │ 2      │
+└───┴────────┘
+"
+`;
+
+exports[`inspect.table (ansi) { a: 1, b: 2, c: 3 } 1`] = `
+"┌───┬────────┐
+│   │ Values │
+├───┼────────┤
+│ a │ 1      │
+│ b │ 2      │
+│ c │ 3      │
+└───┴────────┘
+"
+`;
+
+exports[`inspect.table (ansi) { a: 1, b: 2, c: 3, d: 4 } 1`] = `
+"┌───┬────────┐
+│   │ Values │
+├───┼────────┤
+│ a │ 1      │
+│ b │ 2      │
+│ c │ 3      │
+│ d │ 4      │
+└───┴────────┘
+"
+`;
+
+exports[`inspect.table (ansi) Map(2) { "a": 1, "b": 2 } 1`] = `
+"┌───┬─────┬────────┐
+│   │ Key │ Values │
+├───┼─────┼────────┤
+│ 0 │ a   │ 1      │
+│ 1 │ b   │ 2      │
+└───┴─────┴────────┘
+"
+`;
+
+exports[`inspect.table (ansi) [ [ "a", 1 ], [ "b", 2 ] ] 1`] = `
+"┌───┬───┬───┐
+│   │ 0 │ 1 │
+├───┼───┼───┤
+│ 0 │ a │ 1 │
+│ 1 │ b │ 2 │
+└───┴───┴───┘
+"
+`;
+
+exports[`inspect.table (ansi) Set(3) { 1, 2, 3 } 1`] = `
+"┌───┬────────┐
+│   │ Values │
+├───┼────────┤
+│ 0 │ 1      │
+│ 1 │ 2      │
+│ 2 │ 3      │
+└───┴────────┘
+"
+`;
+
+exports[`inspect.table (ansi) { "0": 1, "1": 2, "2": 3 } 1`] = `
+"┌───┬────────┐
+│   │ Values │
+├───┼────────┤
+│ 0 │ 1      │
+│ 1 │ 2      │
+│ 2 │ 3      │
+└───┴────────┘
+"
+`;
+
+exports[`inspect.table (ansi) [ 1, 2, 3 ] 1`] = `
+"┌───┬────────┐
+│   │ Values │
+├───┼────────┤
+│ 0 │ 1      │
+│ 1 │ 2      │
+│ 2 │ 3      │
+└───┴────────┘
+"
+`;
+
+exports[`inspect.table (ansi) [ "a", 1, "b", 2, "c", 3 ] 1`] = `
+"┌───┬────────┐
+│   │ Values │
+├───┼────────┤
+│ 0 │ a      │
+│ 1 │ 1      │
+│ 2 │ b      │
+│ 3 │ 2      │
+│ 4 │ c      │
+│ 5 │ 3      │
+└───┴────────┘
+"
+`;
+
+exports[`inspect.table (ansi) [ /a/, 1, /b/, 2, /c/, 3 ] 1`] = `
+"┌───┬────────┐
+│   │ Values │
+├───┼────────┤
+│ 0 │        │
+│ 1 │ 1      │
+│ 2 │        │
+│ 3 │ 2      │
+│ 4 │        │
+│ 5 │ 3      │
+└───┴────────┘
+"
+`;
+
+exports[`inspect.table (with properties) { a: 1, b: 2 } 1`] = `
+"┌───┬───┐
+│   │ b │
+├───┼───┤
+│ a │   │
+│ b │   │
+└───┴───┘
+"
+`;
+
+exports[`inspect.table (with properties) { a: 1, b: 2 } 2`] = `
+"┌───┬───┐
+│   │ a │
+├───┼───┤
+│ a │   │
+│ b │   │
+└───┴───┘
+"
+`;
+
+exports[`inspect.table (with properties and colors) { a: 1, b: 2 } 1`] = `
+"┌───┬───┐
+│   │ b │
+├───┼───┤
+│ a │   │
+│ b │   │
+└───┴───┘
+"
+`;
+
+exports[`inspect.table (with properties and colors) { a: 1, b: 2 } 2`] = `
+"┌───┬───┐
+│   │ a │
+├───┼───┤
+│ a │   │
+│ b │   │
+└───┴───┘
+"
+`;
+
+exports[`inspect.table (with colors in 2nd position) { a: 1, b: 2 } 1`] = `
+"┌───┬────────┐
+│   │ Values │
+├───┼────────┤
+│ a │ 1      │
+│ b │ 2      │
+└───┴────────┘
+"
+`;
+
+exports[`inspect.table (with colors in 2nd position) { a: 1, b: 2 } 2`] = `
+"┌───┬────────┐
+│   │ Values │
+├───┼────────┤
+│ a │ 1      │
+│ b │ 2      │
+└───┴────────┘
+"
+`;
diff --git a/test/js/bun/console/__snapshots__/console-table.test.ts.snap b/test/js/bun/console/__snapshots__/console-table.test.ts.snap
index 83bf72ab2b..28d4755f7e 100644
--- a/test/js/bun/console/__snapshots__/console-table.test.ts.snap
+++ b/test/js/bun/console/__snapshots__/console-table.test.ts.snap
@@ -194,3 +194,12 @@ exports[`console.table expected output for: properties - interesting character 1
 └───┴────────┘
 "
 `;
+
+exports[`console.table expected output for: number keys 1`] = `
+"┌──────┬─────┬─────┐
+│      │ 10  │ 100 │
+├──────┼─────┼─────┤
+│ test │ 123 │ 154 │
+└──────┴─────┴─────┘
+"
+`;
diff --git a/test/js/bun/console/bun-inspect-table.test.ts b/test/js/bun/console/bun-inspect-table.test.ts
new file mode 100644
index 0000000000..3736701a4f
--- /dev/null
+++ b/test/js/bun/console/bun-inspect-table.test.ts
@@ -0,0 +1,66 @@
+import { inspect } from "bun";
+import { test, expect, describe } from "bun:test";
+
+const inputs = [
+  { a: 1, b: 2 },
+  { a: 1, b: 2, c: 3 },
+  { a: 1, b: 2, c: 3, d: 4 },
+  new Map([
+    ["a", 1],
+    ["b", 2],
+  ]),
+  [
+    ["a", 1],
+    ["b", 2],
+  ],
+  new Set([1, 2, 3]),
+  { 0: 1, 1: 2, 2: 3 },
+  [1, 2, 3],
+  ["a", 1, "b", 2, "c", 3],
+  [/a/, 1, /b/, 2, /c/, 3],
+];
+
+describe("inspect.table", () => {
+  inputs.forEach(input => {
+    test(Bun.inspect(input, { colors: false, sorted: true, compact: true }), () => {
+      expect(inspect.table(input, { colors: false, sorted: true })).toMatchSnapshot();
+    });
+  });
+});
+
+describe("inspect.table (ansi)", () => {
+  inputs.forEach(input => {
+    test(Bun.inspect(input, { colors: false, sorted: true, compact: true }), () => {
+      expect(inspect.table(input, { colors: true, sorted: true })).toMatchSnapshot();
+    });
+  });
+});
+
+const withProperties = [
+  [{ a: 1, b: 2 }, ["b"]],
+  [{ a: 1, b: 2 }, ["a"]],
+];
+
+describe("inspect.table (with properties)", () => {
+  withProperties.forEach(([input, properties]) => {
+    test(Bun.inspect(input, { colors: false, sorted: true, compact: true }), () => {
+      expect(inspect.table(input, properties, { colors: false, sorted: true })).toMatchSnapshot();
+    });
+  });
+});
+
+describe("inspect.table (with properties and colors)", () => {
+  withProperties.forEach(([input, properties]) => {
+    test(Bun.inspect(input, { colors: false, sorted: true, compact: true }), () => {
+      expect(inspect.table(input, properties, { colors: true, sorted: true })).toMatchSnapshot();
+    });
+  });
+});
+
+describe("inspect.table (with colors in 2nd position)", () => {
+  withProperties.forEach(([input, properties]) => {
+    test(Bun.inspect(input, { colors: false, sorted: true, compact: true }), () => {
+      expect(inspect.table(input, { colors: true, sorted: true })).toMatchSnapshot();
+    });
+  });
+});
diff --git a/test/js/bun/console/console-table.test.ts b/test/js/bun/console/console-table.test.ts
index 22d780ac82..24b5848c13 100644
--- a/test/js/bun/console/console-table.test.ts
+++ b/test/js/bun/console/console-table.test.ts
@@ -134,6 +134,14 @@ describe("console.table", () => {
         ],
       },
     ],
+    [
+      "number keys",
+      {
+        args: () => [
+          {test: {"10": 123, "100": 154}},
+        ],
+      },
+    ],
   ])("expected output for: %s", (label, { args }) => {
     const { stdout } = spawnSync({
       cmd: [bunExe(), `${import.meta.dir}/console-table-run.ts`, args.toString()],
diff --git a/test/js/bun/css/__snapshots__/color.test.ts.snap b/test/js/bun/css/__snapshots__/color.test.ts.snap
new file mode 100644
index 0000000000..babe2806e5
Binary files /dev/null and b/test/js/bun/css/__snapshots__/color.test.ts.snap differ
diff --git a/test/js/bun/css/color.test.ts b/test/js/bun/css/color.test.ts
new file mode 100644
index 0000000000..1d0ec0f292
--- /dev/null
+++ b/test/js/bun/css/color.test.ts
@@ -0,0 +1,220 @@
+import { describe, expect, test } from "bun:test";
+import { color } from "bun";
+import { withoutAggressiveGC } from "harness";
+
+const namedColors = ["red", "green", "blue", "yellow", "purple", "orange", "pink", "brown", "gray"];
+
+const hexColors = [
+  "#FF0000",
+  "#00FF00",
+  "#0000FF",
+  "#FFFF00",
+  "#FF00FF",
+  "#00FFFF",
+  "#FFA500",
+  "#800080",
+  "#FFC0CB",
+  "#808080",
+  "#000000",
+  "#FFFFFF",
+];
+
+const hexLowercase = hexColors.map(color => color.toLowerCase());
+const hexUppercase = hexColors.map(color => color.toUpperCase());
+
+const rgbColors = [
+  "rgb(255, 0, 0)",
+  "rgb(0, 255, 0)",
+  "rgb(0, 0, 255)",
+  "rgb(255, 255, 0)",
+  "rgb(255, 0, 255)",
+  "rgb(0, 255, 255)",
+  "rgb(255, 165, 0)",
+  "rgb(128, 0, 128)",
+  "rgb(255, 204, 204)",
+  "rgb(128, 128, 128)",
+  "rgb(0, 0, 0)",
+  "rgb(255, 255, 255)",
+];
+
+const rgbaColors = [
+  "rgba(255, 0, 0, 1)",
+  "rgba(0, 255, 0, 1)",
+  "rgba(0, 0, 255, 1)",
+  "rgba(255, 255, 0, 1)",
+  "rgba(255, 0, 255, 1)",
+  "rgba(0, 255, 255, 1)",
+  "rgba(255, 165, 0, 1)",
+  "rgba(128, 0, 128, 1)",
+  "rgba(255, 204, 204, 1)",
+  "rgba(128, 128, 128, 1)",
+  "rgba(0, 0, 0, 1)",
+  "rgba(255, 255, 255, 1)",
+];
+
+const rgbObjectColors = [
+  { r: 255, g: 0, b: 0 },
+  { r: 0, g: 255, b: 0 },
+  { r: 0, g: 0, b: 255 },
+  { r: 255, g: 255, b: 0 },
+  { r: 255, g: 0, b: 255 },
+  { r: 0, g: 255, b: 255 },
+  { r: 255, g: 165, b: 0 },
+  { r: 128, g: 0, b: 128 },
+  { r: 255, g: 204, b: 204 },
+  { r: 128, g: 128, b: 128 },
+  { r: 0, g: 0, b: 0 },
+  { r: 255, g: 255, b: 255 },
+];
+
+const hslColors = [
+  "hsl(0, 100%, 50%)",
+  "hsl(120, 100%, 50%)",
+  "hsl(240, 100%, 50%)",
+  "hsl(60, 100%, 50%)",
+  "hsl(300, 100%, 50%)",
+  "hsl(180, 100%, 50%)",
+  "hsl(300, 100%, 50%)",
+  "hsl(120, 100%, 50%)",
+  "hsl(240, 100%, 50%)",
+];
+
+const labColors = [
+  "lab(50%, 50%, 50%)",
+  "lab(100%, 100%, 100%)",
+  "lab(0%, 0%, 0%)",
+  "lab(100%, 0%, 0%)",
+  "lab(0%, 100%, 0%)",
+  "lab(0%, 0%, 100%)",
+];
+
+const formatted = {
+  "{rgb}": rgbObjectColors,
+  "{rgba}": rgbObjectColors.map(color => ({ ...color, a: 1 })),
+  "[rgb]": rgbObjectColors.map(color => [color.r, color.g, color.b]),
+  "[rgba]": rgbObjectColors.map(color => [color.r, color.g, color.b, 255]),
+  rgb: rgbColors,
+  rgba: rgbaColors,
+  hex: hexLowercase,
+  HEX: hexUppercase,
+  // hsl: hslColors,
+  // lab: labColors,
+  number: hexLowercase.map(color => parseInt(color.slice(1), 16)),
+};
+
+for (const format in formatted) {
+  for (const input of formatted[format]) {
+    test(`console.log(color(${JSON.stringify(input)}, "ansi-24bit"))`, () => {
+      console.log(color(input, "ansi-24bit") + input);
+    });
+
+    test(`console.log(color(${JSON.stringify(input)}, "ansi-256"))`, () => {
+      console.log(color(input, "ansi-256") + input);
+    });
+    test(`console.log(color(${JSON.stringify(input)}, "ansi-16"))`, () => {
+      console.log(color(input, "ansi-16") + input);
+    });
+
+    test(`color(${JSON.stringify(input)}, "${format}") = ${JSON.stringify(input)}`, () => {
+      expect(color(input, format)).toEqual(input);
+    });
+
+    test(`color(${JSON.stringify(input)}, "ansi-24bit")`, () => {
+      expect(color(input, "ansi-24bit")).toMatchSnapshot();
+    });
+
+    test(`color(${JSON.stringify(input)}, "ansi-16")`, () => {
+      expect(color(input, "ansi-16")).toMatchSnapshot();
+    });
+
+    test(`color(${JSON.stringify(input)}, "ansi256")`, () => {
+      expect(color(input, "ansi256")).toMatchSnapshot();
+    });
+  }
+
+  for (const input of formatted[format]) {
+    test(`color(${JSON.stringify(input)}, "css")`, () => {
+      expect(color(input, "css")).toMatchSnapshot();
+    });
+  }
+}
+
+for (const input of formatted.hex) {
+  test(`color(${JSON.stringify(input)}, "HEX")`, () => {
+    expect(color(input, "HEX")).toEqual(input.toUpperCase());
+  });
+}
+
+for (const input of formatted.HEX) {
+  test(`color(${JSON.stringify(input)}, "hex")`, () => {
+    expect(color(input, "hex")).toEqual(input.toLowerCase());
+  });
+}
+
+const bad = [
+  "rg(255, 255, 255)",
+  "bad color input",
+  "#0129301293",
+  "lab(101%, 100%, 100%)",
+  "lch(100%, 100%, 100%)",
+  "color(red)",
+  "calc(1px + 1px)",
+  "var(--bad)",
+  "url(#bad)",
+  "attr(id)",
+  "calc(1px + 1px)",
+  "calc(1px + 1px)",
+  "calc(1px + 1px)",
+  "calc(1px + 1px)",
+  "calc(1px + 1px)",
+  "calc(1px + 1px)",
+  "0123456",
+  "123456",
+  "23456",
+  "3456",
+  "456",
+  "56",
+  "6",
+  "#-fff",
+  "0xfff",
+];
+test.each(bad)("color(%s, 'css') === null", input => {
+  expect(color(input, "css")).toBeNull();
+  expect(color(input)).toBeNull();
+});
+
+const weird = [
+  ["rgb(-255, 0, 0)", "#000"],
+  ["rgb(256, 0, 0)", "red"],
+];
+describe("weird", () => {
+  test.each(weird)("color(%s, 'css') === %s", (input, expected) => {
+    expect(color(input, "css")).toEqual(expected);
+    expect(color(input)).toEqual(expected);
+  });
+});
+
+test("0 args", () => {
+  expect(() => color()).toThrow(
+    expect.objectContaining({
+      code: "ERR_INVALID_ARG_TYPE",
+    }),
+  );
+});
+
+test("fuzz ansi256", () => {
+  withoutAggressiveGC(() => {
+    for (let i = 0; i < 256; i++) {
+      const iShifted = i << 16;
+      for (let j = 0; j < 256; j++) {
+        const jShifted = j << 8;
+        for (let k = 0; k < 256; k++) {
+          const int = iShifted | jShifted | k;
+          if (color(int, "ansi256") === null) {
+            throw new Error(`color(${i}, ${j}, ${k}, "ansi256") is null`);
+          }
+        }
+      }
+    }
+  });
+});
diff --git a/test/js/bun/css/css-fuzz.test.ts b/test/js/bun/css/css-fuzz.test.ts
new file mode 100644
index 0000000000..6a46bfc16b
--- /dev/null
+++ b/test/js/bun/css/css-fuzz.test.ts
@@ -0,0 +1,254 @@
+import { test, expect } from "bun:test";
+import { isCI } from "harness";
+
+interface InvalidFuzzOptions {
+  maxLength: number;
+  strategy: "syntax" | "structure" | "encoding" | "memory" | "all";
+  iterations: number;
+}
+
+// Collection of invalid CSS generation strategies
+const invalidGenerators = {
+  // Syntax errors
+  syntax: {
+    unclosedRules: () => `
+      .test { color: red
+      .another { padding: 10px }`,
+    invalidSelectors: () => [
+      "}{color:red}",
+      "&*#@.class{color:red}",
+      "..double.dot{color:red}",
+      ".{color:red}",
+      "#{color:red}",
+    ],
+    malformedProperties: () => [
+      ".test{color:}",
+      ".test{:red}",
+      ".test{color::red}",
+      ".test{;color:red}",
+      ".test{color:red;;;}",
+    ],
+    unclosedComments: () => [
+      "/* unclosed comment .test{color:red}",
+      ".test{color:red} /* unclosed",
+      "/**//**//* .test{color:red}",
+    ],
+  } as const,
+
+  // Structural errors
+  structure: {
+    nestedRules: () => [
+      ".outer { .inner { color: red } }", // Invalid nesting without @rules
+      "@media screen { @media print { } ", // Unclosed nested at-rule
+      "@keyframes { @keyframes { } }", // Invalid nesting of @keyframes
+    ],
+    malformedAtRules: () => ["@media ;", "@import url('test.css'", "@{color:red}", "@media screen and and {color:red}"],
+    invalidImports: () => ["@import 'file' 'screen';", "@import url(;", "@import url('test.css') print"],
+  } as const,
+
+  // Encoding and character issues
+  encoding: {
+    invalidUTF8: () => [
+      `.test{content:"${Buffer.from([0xc0, 0x80]).toString()}"}`,
+      `.test{content:"${Buffer.from([0xe0, 0x80, 0x80]).toString()}"}`,
+      `.test{content:"${Buffer.from([0xf0, 0x80, 0x80, 0x80]).toString()}"}`,
+    ],
+    nullBytes: () => [`.test{color:red${"\0"};}`, `.te${"\0"}st{color:red}`, `${"\0"}.test{color:red}`],
+    controlCharacters: () => {
+      const controls = Array.from({ length: 32 }, (_, i) => String.fromCharCode(i));
+      return controls.map(char => `.test{color:${char}red}`);
+    },
+  } as const,
+
+  // Memory and resource stress
+  memory: {
+    deepNesting: (depth: number = 1000) => {
+      let css = "";
+      for (let i = 0; i < depth; i++) {
+        css += "@media screen {";
+      }
+      css += ".test{color:red}";
+      for (let i = 0; i < depth; i++) {
+        css += "}";
+      }
+      return css;
+    },
+    longSelectors: (length: number = 100000) => {
+      const selector = ".test".repeat(length);
+      return `${selector}{color:red}`;
+    },
+    manyProperties: (count: number = 10000) => {
+      const properties = Array(count).fill("color:red;").join("\n");
+      return `.test{${properties}}`;
+    },
+  } as const,
+} as const;
+
+// Helper to randomly corrupt CSS
+function corruptCSS(css: string): string {
+  const corruptions = [
+    (s: string) => (s + "").replace(/{/g, "}"),
+    (s: string) => (s + "").replace(/}/g, "{"),
+    (s: string) => (s + "").replace(/:/g, ";"),
+    (s: string) => (s + "").replace(/;/g, ":"),
+    (s: string) => (s + "").slice(Math.floor(Math.random() * (s + "").length)),
+    (s: string) => s + "" + "}}".repeat(Math.floor(Math.random() * 5)),
+    (s: string) => (s + "").split("").reverse().join(""),
+    (s: string) => (s + "").replace(/[a-z]/g, c => String.fromCharCode(97 + Math.floor(Math.random() * 26))),
+  ];
+
+  const numCorruptions = Math.floor(Math.random() * 3) + 1;
+  let corrupted = css;
+
+  for (let i = 0; i < numCorruptions; i++) {
+    const corruption = corruptions[Math.floor(Math.random() * corruptions.length)];
+    corrupted = corruption(corrupted);
+  }
+
+  return corrupted;
+}
+
+// TODO:
+if (!isCI) {
+  // Main fuzzing test suite for invalid inputs
+  test.each([
+    ["syntax", 1000],
+    ["structure", 1000],
+    ["encoding", 500],
+    ["memory", 100],
+  ])("CSS Parser Invalid Input Fuzzing - %s (%d iterations)", async (strategy, iterations) => {
+    const options: InvalidFuzzOptions = {
+      maxLength: 10000,
+      strategy: strategy as any,
+      iterations,
+    };
+
+    let crashCount = 0;
+    let errorCount = 0;
+    const startTime = performance.now();
+
+    for (let i = 0; i < options.iterations; i++) {
+      let invalidCSS = "";
+
+      switch (strategy) {
+        case "syntax":
+          invalidCSS =
+            invalidGenerators.syntax[
+              Object.keys(invalidGenerators.syntax)[
+                Math.floor(Math.random() * Object.keys(invalidGenerators.syntax).length)
+              ]
+            ]()[Math.floor(Math.random() * 5)];
+          break;
+
+        case "structure":
+          invalidCSS =
+            invalidGenerators.structure[
+              Object.keys(invalidGenerators.structure)[
+                Math.floor(Math.random() * Object.keys(invalidGenerators.structure).length)
+              ]
+            ]()[Math.floor(Math.random() * 3)];
+          break;
+
+        case "encoding":
+          invalidCSS =
+            invalidGenerators.encoding[
+              Object.keys(invalidGenerators.encoding)[
+                Math.floor(Math.random() * Object.keys(invalidGenerators.encoding).length)
+              ]
+            ]()[0];
+          break;
+
+        case "memory":
+          const memoryFuncs = Object.keys(invalidGenerators.memory);
+          const selectedFunc = memoryFuncs[Math.floor(Math.random() * memoryFuncs.length)];
+          invalidCSS = invalidGenerators.memory[selectedFunc](1000);
+          break;
+      }
+
+      // Further corrupt the CSS randomly
+      if (Math.random() < 0.3) {
+        invalidCSS = corruptCSS(invalidCSS);
+      }
+
+      console.log("--- CSS Fuzz ---");
+      invalidCSS = invalidCSS + "";
+      console.log(JSON.stringify(invalidCSS, null, 2));
+      await Bun.write("invalid.css", invalidCSS);
+
+      try {
+        const result = await Bun.build({
+          entrypoints: ["invalid.css"],
+          experimentalCss: true,
+        });
+
+        if (result.logs.length > 0) {
+          throw new AggregateError("CSS parser returned logs", result.logs);
+        }
+
+        // We expect the parser to either throw an error or return a valid result
+        // If it returns undefined/null, that's a potential issue
+        if (result === undefined || result === null) {
+          crashCount++;
+          console.error(`Parser returned ${result} for input:\n${invalidCSS.slice(0, 100)}...`);
+        }
+      } catch (error) {
+        // Expected behavior for invalid CSS
+        errorCount++;
+
+        // Check for specific error types we want to track
+        if (error instanceof RangeError || error instanceof TypeError) {
+          console.warn(`Unexpected error type: ${error.constructor.name} for input:\n${invalidCSS.slice(0, 100)}...`);
+        }
+      }
+
+      // Memory check every 100 iterations
+      if (i % 100 === 0) {
+        const heapUsed = process.memoryUsage().heapUsed / 1024 / 1024;
+        expect(heapUsed).toBeLessThan(500); // Alert if memory usage exceeds 500MB
+      }
+    }
+
+    const endTime = performance.now();
+    const duration = endTime - startTime;
+
+    console.log(`
+    Strategy: ${strategy}
+    Total iterations: ${iterations}
+    Crashes: ${crashCount}
+    Expected errors: ${errorCount}
+    Duration: ${duration.toFixed(2)}ms
+    Average time per test: ${(duration / iterations).toFixed(2)}ms
+  `);
+
+    // We expect some errors for invalid input, but no crashes
+    expect(crashCount).toBe(0);
+    expect(errorCount).toBeGreaterThan(0);
+  });
+
+  // Additional test for mixed valid/invalid input
+  test("CSS Parser Mixed Input Fuzzing", async () => {
+    const validCSS = ".test{color:red}";
+
+    for (let i = 0; i < 100; i++) {
+      const mixedCSS = `
+      ${validCSS}
+      ${corruptCSS(validCSS)}
+      ${validCSS}
+    `;
+
+      console.log("--- Mixed CSS ---");
+      console.log(JSON.stringify(mixedCSS, null, 2));
+      await Bun.write("invalid.css", mixedCSS);
+
+      try {
+        await Bun.build({
+          entrypoints: ["invalid.css"],
+          experimentalCss: true,
+        });
+      } catch (error) {
+        // Expected to throw, but shouldn't crash
+        expect(error).toBeDefined();
+      }
+    }
+  });
+}
diff --git a/test/js/bun/css/css.test.ts b/test/js/bun/css/css.test.ts
new file mode 100644
index 0000000000..842160c315
--- /dev/null
+++ b/test/js/bun/css/css.test.ts
@@ -0,0 +1,3257 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import { describe, expect, test } from "bun:test";
+import "harness";
+import path from "path";
+import { attrTest, cssTest, indoc, indoc, minify_test, minifyTest, prefix_test } from "./util";
+
+describe("css tests", () => {
+  describe("border_spacing", () => {
+    minifyTest(
+      `
+      .foo {
+        border-spacing: 0px;
+      }`,
+      indoc`.foo{border-spacing:0}`,
+    );
+
+    minify_test(
+      `
+      .foo {
+        border-spacing: 0px 0px;
+      }
+    `,
+      indoc`.foo{border-spacing:0}`,
+    );
+
+    minify_test(
+      `
+      .foo {
+        border-spacing: 12px   0px;
+      }
+    `,
+      indoc`.foo{border-spacing:12px 0}`,
+    );
+
+    minify_test(
+      `
+      .foo {
+        border-spacing: calc(3px * 2) calc(5px * 0);
+      }
+    `,
+      indoc`.foo{border-spacing:6px 0}`,
+    );
+
+    minify_test(
+      `
+      .foo {
+        border-spacing: calc(3px * 2) max(0px, 8px);
+      }
+    `,
+      indoc`.foo{border-spacing:6px 8px}`,
+    );
+
+    // TODO: The `<length>` in border-spacing cannot have a negative value,
+    // we may need to implement NonNegativeLength like Servo does.
+    // Servo Code: https://github.com/servo/servo/blob/08bc2d53579c9ab85415d4363888881b91df073b/components/style/values/specified/length.rs#L875
+    // CSSWG issue: https://lists.w3.org/Archives/Public/www-style/2008Sep/0161.html
+    // `border-spacing = <length> <length>?`
+    minify_test(
+      `
+      .foo {
+        border-spacing: -20px;
+      }
+    `,
+      indoc`.foo{border-spacing:-20px}`,
+    );
+  });
+
+  describe("border", () => {
+    // cssTest(
+    //   `
+    //   .foo {
+    //     border-left: 2px solid red;
+    //     border-right: 2px solid red;
+    //     border-bottom: 2px solid red;
+    //     border-top: 2px solid red;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border: 2px solid red;
+    //   }
+    // `,
+    // );
+    // TODO: this
+    // cssTest(
+    //   `
+    //   .foo {
+    //     border-left-color: red;
+    //     border-right-color: red;
+    //     border-bottom-color: red;
+    //     border-top-color: red;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border-color: red;
+    //   }
+    // `,
+    // );
+    // cssTest(
+    //   `
+    //   .foo {
+    //     border-left-width: thin;
+    //     border-right-width: thin;
+    //     border-bottom-width: thin;
+    //     border-top-width: thin;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border-width: thin;
+    //   }
+    // `,
+    // );
+    // cssTest(
+    //   `
+    //   .foo {
+    //     border-left-style: dotted;
+    //     border-right-style: dotted;
+    //     border-bottom-style: dotted;
+    //     border-top-style: dotted;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border-style: dotted;
+    //   }
+    // `,
+    // );
+    // cssTest(
+    //   `
+    //   .foo {
+    //     border-left-width: thin;
+    //     border-left-style: dotted;
+    //     border-left-color: red;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border-left: thin dotted red;
+    //   }
+    // `,
+    // );
+    // cssTest(
+    //   `
+    //   .foo {
+    //     border-left-width: thick;
+    //     border-left: thin dotted red;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border-left: thin dotted red;
+    //   }
+    // `,
+    // );
+    // cssTest(
+    //   `
+    //   .foo {
+    //     border-left-width: thick;
+    //     border: thin dotted red;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border: thin dotted red;
+    //   }
+    // `,
+    // );
+    // cssTest(
+    //   `
+    //   .foo {
+    //     border: thin dotted red;
+    //     border-right-width: thick;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border: thin dotted red;
+    //     border-right-width: thick;
+    //   }
+    // `,
+    // );
+    // cssTest(
+    //   `
+    //   .foo {
+    //     border: thin dotted red;
+    //     border-right: thick dotted red;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border: thin dotted red;
+    //     border-right-width: thick;
+    //   }
+    // `,
+    // );
+    // cssTest(
+    //   `
+    //   .foo {
+    //     border: thin dotted red;
+    //     border-right-width: thick;
+    //     border-right-style: solid;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border: thin dotted red;
+    //     border-right: thick solid red;
+    //   }
+    // `,
+    // );
+    // cssTest(
+    //   `
+    //   .foo {
+    //     border-top: thin dotted red;
+    //     border-block-start: thick solid green;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border-top: thin dotted red;
+    //     border-block-start: thick solid green;
+    //   }
+    // `,
+    // );
+    // cssTest(
+    //   `
+    //   .foo {
+    //     border: thin dotted red;
+    //     border-block-start-width: thick;
+    //     border-left-width: medium;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border: thin dotted red;
+    //     border-block-start-width: thick;
+    //     border-left-width: medium;
+    //   }
+    // `,
+    // );
+    // cssTest(
+    //   `
+    //   .foo {
+    //     border-block-start: thin dotted red;
+    //     border-inline-end: thin dotted red;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border-block-start: thin dotted red;
+    //     border-inline-end: thin dotted red;
+    //   }
+    // `,
+    // );
+    // cssTest(
+    //   `
+    //   .foo {
+    //     border-block-start-width: thin;
+    //     border-block-start-style: dotted;
+    //     border-block-start-color: red;
+    //     border-inline-end: thin dotted red;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border-block-start: thin dotted red;
+    //     border-inline-end: thin dotted red;
+    //   }
+    // `,
+    // );
+    // cssTest(
+    //   `
+    //   .foo {
+    //     border-block-start: thin dotted red;
+    //     border-block-end: thin dotted red;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border-block: thin dotted red;
+    //   }
+    // `,
+    // );
+    // minifyTest(
+    //   `
+    //   .foo {
+    //     border: none;
+    //   }
+    // `,
+    //   `.foo{border:none}`,
+    // );
+    // minifyTest(".foo { border-width: 0 0 1px; }", ".foo{border-width:0 0 1px}");
+    // cssTest(
+    //   `
+    //   .foo {
+    //     border-block-width: 1px;
+    //     border-inline-width: 1px;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border-width: 1px;
+    //   }
+    // `,
+    // );
+    // cssTest(
+    //   `
+    //   .foo {
+    //     border-block-start-width: 1px;
+    //     border-block-end-width: 1px;
+    //     border-inline-start-width: 1px;
+    //     border-inline-end-width: 1px;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border-width: 1px;
+    //   }
+    // `,
+    // );
+    // cssTest(
+    //   `
+    //   .foo {
+    //     border-block-start-width: 1px;
+    //     border-block-end-width: 1px;
+    //     border-inline-start-width: 2px;
+    //     border-inline-end-width: 2px;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border-block-width: 1px;
+    //     border-inline-width: 2px;
+    //   }
+    // `,
+    // );
+    // cssTest(
+    //   `
+    //   .foo {
+    //     border-block-start-width: 1px;
+    //     border-block-end-width: 1px;
+    //     border-inline-start-width: 2px;
+    //     border-inline-end-width: 3px;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border-block-width: 1px;
+    //     border-inline-width: 2px 3px;
+    //   }
+    // `,
+    // );
+    // minifyTest(
+    //   ".foo { border-bottom: 1px solid var(--spectrum-global-color-gray-200)}",
+    //   ".foo{border-bottom:1px solid var(--spectrum-global-color-gray-200)}",
+    // );
+    // cssTest(
+    //   `
+    //   .foo {
+    //     border-width: 0;
+    //     border-bottom: var(--test, 1px) solid;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border-width: 0;
+    //     border-bottom: var(--test, 1px) solid;
+    //   }
+    // `,
+    // );
+    // cssTest(
+    //   `
+    //   .foo {
+    //     border: 1px solid black;
+    //     border-width: 1px 1px 0 0;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border: 1px solid #000;
+    //     border-width: 1px 1px 0 0;
+    //   }
+    // `,
+    // );
+    // cssTest(
+    //   `
+    //   .foo {
+    //     border-top: 1px solid black;
+    //     border-bottom: 1px solid black;
+    //     border-left: 2px solid black;
+    //     border-right: 2px solid black;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border: 1px solid #000;
+    //     border-width: 1px 2px;
+    //   }
+    // `,
+    // );
+    // cssTest(
+    //   `
+    //   .foo {
+    //     border-top: 1px solid black;
+    //     border-bottom: 1px solid black;
+    //     border-left: 2px solid black;
+    //     border-right: 1px solid black;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border: 1px solid #000;
+    //     border-left-width: 2px;
+    //   }
+    // `,
+    // );
+    // cssTest(
+    //   `
+    //   .foo {
+    //     border-top: 1px solid black;
+    //     border-bottom: 1px solid black;
+    //     border-left: 1px solid red;
+    //     border-right: 1px solid red;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border: 1px solid #000;
+    //     border-color: #000 red;
+    //   }
+    // `,
+    // );
+    // cssTest(
+    //   `
+    //   .foo {
+    //     border-block-start: 1px solid black;
+    //     border-block-end: 1px solid black;
+    //     border-inline-start: 1px solid red;
+    //     border-inline-end: 1px solid red;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border: 1px solid #000;
+    //     border-inline-color: red;
+    //   }
+    // `,
+    // );
+    // cssTest(
+    //   `
+    //   .foo {
+    //     border-block-start: 1px solid black;
+    //     border-block-end: 1px solid black;
+    //     border-inline-start: 2px solid black;
+    //     border-inline-end: 2px solid black;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border: 1px solid #000;
+    //     border-inline-width: 2px;
+    //   }
+    // `,
+    // );
+    // cssTest(
+    //   `
+    //   .foo {
+    //     border-block-start: 1px solid black;
+    //     border-block-end: 1px solid black;
+    //     border-inline-start: 2px solid red;
+    //     border-inline-end: 2px solid red;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border: 1px solid #000;
+    //     border-inline: 2px solid red;
+    //   }
+    // `,
+    // );
+    // cssTest(
+    //   `
+    //   .foo {
+    //     border-block-start: 1px solid black;
+    //     border-block-end: 1px solid black;
+    //     border-inline-start: 2px solid red;
+    //     border-inline-end: 3px solid red;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border: 1px solid #000;
+    //     border-inline-start: 2px solid red;
+    //     border-inline-end: 3px solid red;
+    //   }
+    // `,
+    // );
+    // cssTest(
+    //   `
+    //   .foo {
+    //     border-block-start: 2px solid black;
+    //     border-block-end: 1px solid black;
+    //     border-inline-start: 2px solid red;
+    //     border-inline-end: 2px solid red;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border: 2px solid red;
+    //     border-block-start-color: #000;
+    //     border-block-end: 1px solid #000;
+    //   }
+    // `,
+    // );
+    // cssTest(
+    //   `
+    //   .foo {
+    //     border-block-start: 2px solid red;
+    //     border-block-end: 1px solid red;
+    //     border-inline-start: 2px solid red;
+    //     border-inline-end: 2px solid red;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border: 2px solid red;
+    //     border-block-end-width: 1px;
+    //   }
+    // `,
+    // );
+    // cssTest(
+    //   `
+    //   .foo {
+    //     border-block-start: 2px solid red;
+    //     border-block-end: 2px solid red;
+    //     border-inline-start: 2px solid red;
+    //     border-inline-end: 1px solid red;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border: 2px solid red;
+    //     border-inline-end-width: 1px;
+    //   }
+    // `,
+    // );
+    // cssTest(
+    //   `
+    //   .foo {
+    //     border: 1px solid currentColor;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border: 1px solid;
+    //   }
+    // `,
+    // );
+    // minifyTest(
+    //   `
+    //   .foo {
+    //     border: 1px solid currentColor;
+    //   }
+    // `,
+    //   ".foo{border:1px solid}",
+    // );
+    // prefix_test(
+    //   `
+    //   .foo {
+    //     border-block: 2px solid red;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border-top: 2px solid red;
+    //     border-bottom: 2px solid red;
+    //   }
+    // `,
+    //   {
+    //     safari: 8 << 16,
+    //   },
+    // );
+    // prefix_test(
+    //   `
+    //   .foo {
+    //     border-block-start: 2px solid red;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border-top: 2px solid red;
+    //   }
+    // `,
+    //   {
+    //     safari: 8 << 16,
+    //   },
+    // );
+    // prefix_test(
+    //   `
+    //   .foo {
+    //     border-block-end: 2px solid red;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border-bottom: 2px solid red;
+    //   }
+    // `,
+    //   {
+    //     safari: 8 << 16,
+    //   },
+    // );
+    // prefix_test(
+    //   `
+    //   .foo {
+    //     border-inline: 2px solid red;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border-left: 2px solid red;
+    //     border-right: 2px solid red;
+    //   }
+    // `,
+    //   {
+    //     safari: 8 << 16,
+    //   },
+    // );
+    // prefix_test(
+    //   `
+    //   .foo {
+    //     border-block-width: 2px;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border-block-start-width: 2px;
+    //     border-block-end-width: 2px;
+    //   }
+    // `,
+    //   {
+    //     safari: 13 << 16,
+    //   },
+    // );
+    // prefix_test(
+    //   `
+    //   .foo {
+    //     border-block-width: 2px;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border-block-width: 2px;
+    //   }
+    // `,
+    //   {
+    //     safari: 15 << 16,
+    //   },
+    // );
+    // prefix_test(
+    //   `
+    //   .foo {
+    //     border-inline-start: 2px solid red;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo:not(:-webkit-any(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi))) {
+    //     border-left: 2px solid red;
+    //   }
+    //   .foo:not(:is(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi))) {
+    //     border-left: 2px solid red;
+    //   }
+    //   .foo:-webkit-any(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi)) {
+    //     border-right: 2px solid red;
+    //   }
+    //   .foo:is(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi)) {
+    //     border-right: 2px solid red;
+    //   }
+    // `,
+    //   {
+    //     safari: 8 << 16,
+    //   },
+    // );
+    // prefix_test(
+    //   `
+    //   .foo {
+    //     border-inline-start-width: 2px;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo:not(:-webkit-any(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi))) {
+    //     border-left-width: 2px;
+    //   }
+    //   .foo:not(:is(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi))) {
+    //     border-left-width: 2px;
+    //   }
+    //   .foo:-webkit-any(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi)) {
+    //     border-right-width: 2px;
+    //   }
+    //   .foo:is(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi)) {
+    //     border-right-width: 2px;
+    //   }
+    // `,
+    //   {
+    //     safari: 8 << 16,
+    //   },
+    // );
+    // prefix_test(
+    //   `
+    //   .foo {
+    //     border-inline-end: 2px solid red;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo:not(:-webkit-any(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi))) {
+    //     border-right: 2px solid red;
+    //   }
+    //   .foo:not(:is(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi))) {
+    //     border-right: 2px solid red;
+    //   }
+    //   .foo:-webkit-any(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi)) {
+    //     border-left: 2px solid red;
+    //   }
+    //   .foo:is(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi)) {
+    //     border-left: 2px solid red;
+    //   }
+    // `,
+    //   {
+    //     safari: 8 << 16,
+    //   },
+    // );
+    // prefix_test(
+    //   `
+    //   .foo {
+    //     border-inline-start: 2px solid red;
+    //     border-inline-end: 5px solid green;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo:not(:-webkit-any(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi))) {
+    //     border-left: 2px solid red;
+    //     border-right: 5px solid green;
+    //   }
+    //   .foo:not(:is(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi))) {
+    //     border-left: 2px solid red;
+    //     border-right: 5px solid green;
+    //   }
+    //   .foo:-webkit-any(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi)) {
+    //     border-left: 5px solid green;
+    //     border-right: 2px solid red;
+    //   }
+    //   .foo:is(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi)) {
+    //     border-left: 5px solid green;
+    //     border-right: 2px solid red;
+    //   }
+    // `,
+    //   {
+    //     safari: 8 << 16,
+    //   },
+    // );
+    // prefix_test(
+    //   `
+    //   .foo {
+    //     border-inline-start: 2px solid red;
+    //     border-inline-end: 5px solid green;
+    //   }
+    //   .bar {
+    //     border-inline-start: 1px dotted gray;
+    //     border-inline-end: 1px solid black;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo:not(:-webkit-any(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi))) {
+    //     border-left: 2px solid red;
+    //     border-right: 5px solid green;
+    //   }
+    //   .foo:not(:is(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi))) {
+    //     border-left: 2px solid red;
+    //     border-right: 5px solid green;
+    //   }
+    //   .foo:-webkit-any(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi)) {
+    //     border-left: 5px solid green;
+    //     border-right: 2px solid red;
+    //   }
+    //   .foo:is(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi)) {
+    //     border-left: 5px solid green;
+    //     border-right: 2px solid red;
+    //   }
+    //   .bar:not(:-webkit-any(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi))) {
+    //     border-left: 1px dotted gray;
+    //     border-right: 1px solid #000;
+    //   }
+    //   .bar:not(:is(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi))) {
+    //     border-left: 1px dotted gray;
+    //     border-right: 1px solid #000;
+    //   }
+    //   .bar:-webkit-any(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi)) {
+    //     border-left: 1px solid #000;
+    //     border-right: 1px dotted gray;
+    //   }
+    //   .bar:is(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi)) {
+    //     border-left: 1px solid #000;
+    //     border-right: 1px dotted gray;
+    //   }
+    // `,
+    //   {
+    //     safari: 8 << 16,
+    //   },
+    // );
+    // prefix_test(
+    //   `
+    //   .foo {
+    //     border-inline-width: 2px;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border-left-width: 2px;
+    //     border-right-width: 2px;
+    //   }
+    // `,
+    //   {
+    //     safari: 8 << 16,
+    //   },
+    // );
+    // prefix_test(
+    //   `
+    //   .foo {
+    //     border-inline-width: 2px;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border-left-width: 2px;
+    //     border-right-width: 2px;
+    //   }
+    // `,
+    //   {
+    //     safari: 8 << 16,
+    //   },
+    // );
+    // prefix_test(
+    //   `
+    //   .foo {
+    //     border-inline-style: solid;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border-left-style: solid;
+    //     border-right-style: solid;
+    //   }
+    // `,
+    //   {
+    //     safari: 8 << 16,
+    //   },
+    // );
+    // prefix_test(
+    //   `
+    //   .foo {
+    //     border-inline-color: red;
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     border-left-color: red;
+    //     border-right-color: red;
+    //   }
+    // `,
+    //   {
+    //     safari: 8 << 16,
+    //   },
+    // );
+    // prefix_test(
+    //   `
+    //   .foo {
+    //     border-inline-end: var(--test);
+    //   }
+    // `,
+    //   indoc`
+    //   .foo:not(:-webkit-any(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi))) {
+    //     border-right: var(--test);
+    //   }
+    //   .foo:not(:is(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi))) {
+    //     border-right: var(--test);
+    //   }
+    //   .foo:-webkit-any(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi)) {
+    //     border-left: var(--test);
+    //   }
+    //   .foo:is(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi)) {
+    //     border-left: var(--test);
+    //   }
+    // `,
+    //   {
+    //     safari: 8 << 16,
+    //   },
+    // );
+    // prefix_test(
+    //   `
+    //   .foo {
+    //     border-inline-start: var(--start);
+    //     border-inline-end: var(--end);
+    //   }
+    // `,
+    //   indoc`
+    //   .foo:not(:-webkit-any(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi))) {
+    //     border-left: var(--start);
+    //     border-right: var(--end);
+    //   }
+    //   .foo:not(:is(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi))) {
+    //     border-left: var(--start);
+    //     border-right: var(--end);
+    //   }
+    //   .foo:-webkit-any(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi)) {
+    //     border-right: var(--start);
+    //     border-left: var(--end);
+    //   }
+    //   .foo:is(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi)) {
+    //     border-right: var(--start);
+    //     border-left: var(--end);
+    //   }
+    // `,
+    //   {
+    //     safari: 8 << 16,
+    //   },
+    // );
+    // for (const prop of [
+    //   "border-inline-start-color",
+    //   "border-inline-end-color",
+    //   "border-block-start-color",
+    //   "border-block-end-color",
+    //   "border-top-color",
+    //   "border-bottom-color",
+    //   "border-left-color",
+    //   "border-right-color",
+    //   "border-color",
+    //   "border-block-color",
+    //   "border-inline-color",
+    // ]) {
+    //   prefix_test(
+    //     `
+    //     .foo {
+    //       ${prop}: lab(40% 56.6 39);
+    //     }
+    //   `,
+    //     indoc`
+    //     .foo {
+    //       ${prop}: #b32323;
+    //       ${prop}: lab(40% 56.6 39);
+    //     }
+    //   `,
+    //     {
+    //       chrome: 90 << 16,
+    //     },
+    //   );
+    // }
+    // for (const prop of [
+    //   "border",
+    //   "border-inline",
+    //   "border-block",
+    //   "border-left",
+    //   "border-right",
+    //   "border-top",
+    //   "border-bottom",
+    //   "border-block-start",
+    //   "border-block-end",
+    //   "border-inline-start",
+    //   "border-inline-end",
+    // ]) {
+    //   prefix_test(
+    //     `
+    //     .foo {
+    //       ${prop}: 2px solid lab(40% 56.6 39);
+    //     }
+    //   `,
+    //     indoc`
+    //     .foo {
+    //       ${prop}: 2px solid #b32323;
+    //       ${prop}: 2px solid lab(40% 56.6 39);
+    //     }
+    //   `,
+    //     {
+    //       chrome: 90 << 16,
+    //     },
+    //   );
+    // }
+    // for (const prop of [
+    //   "border",
+    //   "border-inline",
+    //   "border-block",
+    //   "border-left",
+    //   "border-right",
+    //   "border-top",
+    //   "border-bottom",
+    //   "border-block-start",
+    //   "border-block-end",
+    //   "border-inline-start",
+    //   "border-inline-end",
+    // ]) {
+    //   prefix_test(
+    //     `
+    //     .foo {
+    //       ${prop}: var(--border-width) solid lab(40% 56.6 39);
+    //     }
+    //   `,
+    //     indoc`
+    //     .foo {
+    //       ${prop}: var(--border-width) solid #b32323;
+    //     }
+    //     @supports (color: lab(0% 0 0)) {
+    //       .foo {
+    //         ${prop}: var(--border-width) solid lab(40% 56.6 39);
+    //       }
+    //     }
+    //   `,
+    //     {
+    //       chrome: 90 << 16,
+    //     },
+    //   );
+    // }
+    // prefix_test(
+    //   `
+    //   .foo {
+    //     border-inline-start-color: lab(40% 56.6 39);
+    //   }
+    // `,
+    //   indoc`
+    //   .foo:not(:-webkit-any(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi))) {
+    //     border-left-color: #b32323;
+    //     border-left-color: lab(40% 56.6 39);
+    //   }
+    //   .foo:not(:is(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi))) {
+    //     border-left-color: #b32323;
+    //     border-left-color: lab(40% 56.6 39);
+    //   }
+    //   .foo:-webkit-any(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi)) {
+    //     border-right-color: #b32323;
+    //     border-right-color: lab(40% 56.6 39);
+    //   }
+    //   .foo:is(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi)) {
+    //     border-right-color: #b32323;
+    //     border-right-color: lab(40% 56.6 39);
+    //   }
+    // `,
+    //   {
+    //     safari: 8 << 16,
+    //   },
+    // );
+    // prefix_test(
+    //   `
+    //   .foo {
+    //     border-inline-end-color: lab(40% 56.6 39);
+    //   }
+    // `,
+    //   indoc`
+    //   .foo:not(:-webkit-any(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi))) {
+    //     border-right-color: #b32323;
+    //     border-right-color: lab(40% 56.6 39);
+    //   }
+    //   .foo:not(:is(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi))) {
+    //     border-right-color: #b32323;
+    //     border-right-color: lab(40% 56.6 39);
+    //   }
+    //   .foo:-webkit-any(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi)) {
+    //     border-left-color: #b32323;
+    //     border-left-color: lab(40% 56.6 39);
+    //   }
+    //   .foo:is(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi)) {
+    //     border-left-color: #b32323;
+    //     border-left-color: lab(40% 56.6 39);
+    //   }
+    // `,
+    //   {
+    //     safari: 8 << 16,
+    //   },
+    // );
+    // prefix_test(
+    //   `
+    //   .foo {
+    //     border-inline-start-color: lab(40% 56.6 39);
+    //     border-inline-end-color: lch(50.998% 135.363 338);
+    //   }
+    // `,
+    //   indoc`
+    //   .foo:not(:-webkit-any(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi))) {
+    //     border-left-color: #b32323;
+    //     border-left-color: lab(40% 56.6 39);
+    //     border-right-color: #ee00be;
+    //     border-right-color: lch(50.998% 135.363 338);
+    //   }`,
+    //   {
+    //     chrome: 8 << 16,
+    //     safari: 14 << 16,
+    //   },
+    // );
+  });
+
+  describe("color", () => {
+    minifyTest(".foo { color: yellow }", ".foo{color:#ff0}");
+    minifyTest(".foo { color: rgb(255, 255, 0) }", ".foo{color:#ff0}");
+    minifyTest(".foo { color: rgba(255, 255, 0, 1) }", ".foo{color:#ff0}");
+    minifyTest(".foo { color: rgba(255, 255, 0, 0.8) }", ".foo{color:#ff0c}");
+    minifyTest(".foo { color: rgb(128, 128, 128) }", ".foo{color:gray}");
+    minifyTest(".foo { color: rgb(123, 255, 255) }", ".foo{color:#7bffff}");
+    minifyTest(".foo { color: rgba(123, 255, 255, 0.5) }", ".foo{color:#7bffff80}");
+    minifyTest(".foo { color: rgb(123 255 255) }", ".foo{color:#7bffff}");
+    minifyTest(".foo { color: rgb(123 255 255 / .5) }", ".foo{color:#7bffff80}");
+    minifyTest(".foo { color: rgb(123 255 255 / 50%) }", ".foo{color:#7bffff80}");
+    minifyTest(".foo { color: rgb(48% 100% 100% / 50%) }", ".foo{color:#7affff80}");
+    minifyTest(".foo { color: hsl(100deg, 100%, 50%) }", ".foo{color:#5f0}");
+    minifyTest(".foo { color: hsl(100, 100%, 50%) }", ".foo{color:#5f0}");
+    minifyTest(".foo { color: hsl(100 100% 50%) }", ".foo{color:#5f0}");
+    minifyTest(".foo { color: hsl(100, 100%, 50%, .8) }", ".foo{color:#5f0c}");
+    minifyTest(".foo { color: hsl(100 100% 50% / .8) }", ".foo{color:#5f0c}");
+    minifyTest(".foo { color: hsla(100, 100%, 50%, .8) }", ".foo{color:#5f0c}");
+    minifyTest(".foo { color: hsla(100 100% 50% / .8) }", ".foo{color:#5f0c}");
+    minifyTest(".foo { color: transparent }", ".foo{color:#0000}");
+    minifyTest(".foo { color: currentColor }", ".foo{color:currentColor}");
+    minifyTest(".foo { color: ButtonBorder }", ".foo{color:buttonborder}");
+    minifyTest(".foo { color: hwb(194 0% 0%) }", ".foo{color:#00c4ff}");
+    minifyTest(".foo { color: hwb(194 0% 0% / 50%) }", ".foo{color:#00c4ff80}");
+    minifyTest(".foo { color: hwb(194 0% 50%) }", ".foo{color:#006280}");
+    minifyTest(".foo { color: hwb(194 50% 0%) }", ".foo{color:#80e1ff}");
+    minifyTest(".foo { color: hwb(194 50% 50%) }", ".foo{color:gray}");
+    minifyTest(".foo { color: lab(29.2345% 39.3825 20.0664); }", ".foo{color:lab(29.2345% 39.3825 20.0664)}");
+    minifyTest(".foo { color: lab(29.2345% 39.3825 20.0664 / 100%); }", ".foo{color:lab(29.2345% 39.3825 20.0664)}");
+    minifyTest(".foo { color: lab(29.2345% 39.3825 20.0664 / 50%); }", ".foo{color:lab(29.2345% 39.3825 20.0664/.5)}");
+    minifyTest(".foo { color: lch(29.2345% 44.2 27); }", ".foo{color:lch(29.2345% 44.2 27)}");
+    minifyTest(".foo { color: lch(29.2345% 44.2 45deg); }", ".foo{color:lch(29.2345% 44.2 45)}");
+    minifyTest(".foo { color: lch(29.2345% 44.2 .5turn); }", ".foo{color:lch(29.2345% 44.2 180)}");
+    minifyTest(".foo { color: lch(29.2345% 44.2 27 / 100%); }", ".foo{color:lch(29.2345% 44.2 27)}");
+    minifyTest(".foo { color: lch(29.2345% 44.2 27 / 50%); }", ".foo{color:lch(29.2345% 44.2 27/.5)}");
+    minifyTest(".foo { color: oklab(40.101% 0.1147 0.0453); }", ".foo{color:oklab(40.101% .1147 .0453)}");
+    minifyTest(".foo { color: oklch(40.101% 0.12332 21.555); }", ".foo{color:oklch(40.101% .12332 21.555)}");
+    minifyTest(".foo { color: oklch(40.101% 0.12332 .5turn); }", ".foo{color:oklch(40.101% .12332 180)}");
+    minifyTest(".foo { color: color(display-p3 1 0.5 0); }", ".foo{color:color(display-p3 1 .5 0)}");
+    minifyTest(".foo { color: color(display-p3 100% 50% 0%); }", ".foo{color:color(display-p3 1 .5 0)}");
+    minifyTest(
+      ".foo { color: color(xyz-d50 0.2005 0.14089 0.4472); }",
+      ".foo{color:color(xyz-d50 .2005 .14089 .4472)}",
+    );
+    minifyTest(
+      ".foo { color: color(xyz-d50 20.05% 14.089% 44.72%); }",
+      ".foo{color:color(xyz-d50 .2005 .14089 .4472)}",
+    );
+    minifyTest(".foo { color: color(xyz-d65 0.2005 0.14089 0.4472); }", ".foo{color:color(xyz .2005 .14089 .4472)}");
+    minifyTest(".foo { color: color(xyz-d65 20.05% 14.089% 44.72%); }", ".foo{color:color(xyz .2005 .14089 .4472)}");
+    minifyTest(".foo { color: color(xyz 0.2005 0.14089 0.4472); }", ".foo{color:color(xyz .2005 .14089 .4472)}");
+    minifyTest(".foo { color: color(xyz 20.05% 14.089% 44.72%); }", ".foo{color:color(xyz .2005 .14089 .4472)}");
+    minifyTest(".foo { color: color(xyz 0.2005 0 0); }", ".foo{color:color(xyz .2005 0 0)}");
+    minifyTest(".foo { color: color(xyz 0 0 0); }", ".foo{color:color(xyz 0 0 0)}");
+    minifyTest(".foo { color: color(xyz 0 1 0); }", ".foo{color:color(xyz 0 1 0)}");
+    minifyTest(".foo { color: color(xyz 0 1 0 / 20%); }", ".foo{color:color(xyz 0 1 0/.2)}");
+    minifyTest(".foo { color: color(xyz 0 0 0 / 20%); }", ".foo{color:color(xyz 0 0 0/.2)}");
+    minifyTest(".foo { color: color(display-p3 100% 50% 0 / 20%); }", ".foo{color:color(display-p3 1 .5 0/.2)}");
+    minifyTest(".foo { color: color(display-p3 100% 0 0 / 20%); }", ".foo{color:color(display-p3 1 0 0/.2)}");
+    minifyTest(".foo { color: hsl(none none none) }", ".foo{color:#000}");
+    minifyTest(".foo { color: hwb(none none none) }", ".foo{color:red}");
+    minifyTest(".foo { color: rgb(none none none) }", ".foo{color:#000}");
+
+    // If the browser doesn't support `#rrggbbaa` color syntax, it is converted to `transparent`.
+    attrTest("color: rgba(0, 0, 0, 0)", indoc`color:transparent`, true, {
+      chrome: 61 << 16,
+    });
+
+    // prefix_test(
+    //   ".foo { color: #0000 }",
+    //   indoc`
+    //   .foo {
+    //     color: transparent;
+    //   }`,
+    //   {
+    //     chrome: 61 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   ".foo { color: transparent }",
+    //   indoc`
+    //   .foo {
+    //     color: transparent;
+    //   }`,
+    //   {
+    //     chrome: 61 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   ".foo { color: rgba(0, 0, 0, 0) }",
+    //   indoc`
+    //   .foo {
+    //     color: rgba(0, 0, 0, 0);
+    //   }`,
+    //   {
+    //     chrome: 61 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   ".foo { color: rgba(255, 0, 0, 0) }",
+    //   indoc`
+    //   .foo {
+    //     color: rgba(255,0,0,0);
+    //   }`,
+    //   {
+    //     chrome: 61 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   ".foo { color: rgba(255, 0, 0, 0) }",
+    //   indoc`
+    //   .foo {
+    //     color: #f000;
+    //   }`,
+    //   {
+    //     chrome: 62 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   ".foo { color: rgba(123, 456, 789, 0.5) }",
+    //   indoc`
+    //   .foo {
+    //     color: #7bffff80;
+    //   }`,
+    //   {
+    //     chrome: 95 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   ".foo { color: rgba(123, 255, 255, 0.5) }",
+    //   indoc`
+    //   .foo {
+    //     color: rgba(123, 255, 255, .5);
+    //   }`,
+    //   {
+    //     ie: 11 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   ".foo { color: #7bffff80 }",
+    //   indoc`
+    //   .foo {
+    //     color: rgba(123, 255, 255, .5);
+    //   }`,
+    //   {
+    //     ie: 11 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   ".foo { color: rgba(123, 456, 789, 0.5) }",
+    //   indoc`
+    //   .foo {
+    //     color: rgba(123, 255, 255, .5);
+    //   }`,
+    //   {
+    //     firefox: 48 << 16,
+    //     safari: 10 << 16,
+    //     ios_saf: 9 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   ".foo { color: rgba(123, 456, 789, 0.5) }",
+    //   indoc`
+    //   .foo {
+    //     color: #7bffff80;
+    //   }`,
+    //   {
+    //     firefox: 49 << 16,
+    //     safari: 10 << 16,
+    //     ios_saf: 10 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   ".foo { background-color: lab(40% 56.6 39) }",
+    //   indoc`
+    //   .foo {
+    //     background-color: #b32323;
+    //     background-color: lab(40% 56.6 39);
+    //   }`,
+    //   {
+    //     chrome: 90 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   ".foo { background-color: lch(40% 68.735435 34.568626) }",
+    //   indoc`
+    //   .foo {
+    //     background-color: #b32323;
+    //     background-color: lch(40% 68.7354 34.5686);
+    //   }`,
+    //   {
+    //     chrome: 90 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   ".foo { background-color: oklab(59.686% 0.1009 0.1192); }",
+    //   indoc`
+    //   .foo {
+    //     background-color: #c65d07;
+    //     background-color: lab(52.2319% 40.1449 59.9171);
+    //   }`,
+    //   {
+    //     chrome: 90 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   ".foo { background-color: oklch(40% 0.1268735435 34.568626) }",
+    //   indoc`
+    //   .foo {
+    //     background-color: #7e250f;
+    //     background-color: lab(29.2661% 38.2437 35.3889);
+    //   }`,
+    //   {
+    //     chrome: 90 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   ".foo { background-color: lab(40% 56.6 39) }",
+    //   indoc`
+    //   .foo {
+    //     background-color: lab(40% 56.6 39);
+    //   }`,
+    //   {
+    //     safari: 15 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   ".foo { background-color: oklab(59.686% 0.1009 0.1192); }",
+    //   indoc`
+    //   .foo {
+    //     background-color: #c65d07;
+    //     background-color: lab(52.2319% 40.1449 59.9171);
+    //   }`,
+    //   {
+    //     chrome: 90 << 16,
+    //     safari: 15 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   ".foo { background-color: oklab(59.686% 0.1009 0.1192); }",
+    //   indoc`
+    //   .foo {
+    //     background-color: #c65d07;
+    //     background-color: color(display-p3 .724144 .386777 .148795);
+    //     background-color: lab(52.2319% 40.1449 59.9171);
+    //   }`,
+    //   {
+    //     chrome: 90 << 16,
+    //     safari: 14 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   ".foo { background-color: lab(40% 56.6 39) }",
+    //   indoc`
+    //   .foo {
+    //     background-color: #b32323;
+    //     background-color: color(display-p3 .643308 .192455 .167712);
+    //     background-color: lab(40% 56.6 39);
+    //   }`,
+    //   {
+    //     chrome: 90 << 16,
+    //     safari: 14 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   ".foo { background-color: oklch(59.686% 0.15619 49.7694); }",
+    //   indoc`
+    //   .foo {
+    //     background-color: #c65d06;
+    //     background-color: lab(52.2321% 40.1417 59.9527);
+    //   }`,
+    //   {
+    //     chrome: 90 << 16,
+    //     safari: 15 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   ".foo { background-color: color(sRGB 0.41587 0.503670 0.36664); }",
+    //   indoc`
+    //   .foo {
+    //     background-color: #6a805d;
+    //     background-color: color(srgb .41587 .50367 .36664);
+    //   }`,
+    //   {
+    //     chrome: 90 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   ".foo { background-color: color(display-p3 0.43313 0.50108 0.37950); }",
+    //   indoc`
+    //   .foo {
+    //     background-color: #6a805d;
+    //     background-color: color(display-p3 .43313 .50108 .3795);
+    //   }`,
+    //   {
+    //     chrome: 90 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   ".foo { background-color: color(display-p3 0.43313 0.50108 0.37950); }",
+    //   indoc`
+    //   .foo {
+    //     background-color: #6a805d;
+    //     background-color: color(display-p3 .43313 .50108 .3795);
+    //   }`,
+    //   {
+    //     chrome: 90 << 16,
+    //     safari: 14 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   ".foo { background-color: color(display-p3 0.43313 0.50108 0.37950); }",
+    //   indoc`
+    //   .foo {
+    //     background-color: color(display-p3 .43313 .50108 .3795);
+    //   }`,
+    //   {
+    //     safari: 14 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   ".foo { background-color: color(display-p3 0.43313 0.50108 0.37950); }",
+    //   indoc`
+    //   .foo {
+    //     background-color: #6a805d;
+    //     background-color: color(display-p3 .43313 .50108 .3795);
+    //   }`,
+    //   {
+    //     chrome: 90 << 16,
+    //     safari: 15 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   ".foo { background-color: color(display-p3 0.43313 0.50108 0.37950); }",
+    //   indoc`
+    //   .foo {
+    //     background-color: #6a805d;
+    //     background-color: color(display-p3 .43313 .50108 .3795);
+    //   }`,
+    //   {
+    //     chrome: 90 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   ".foo { background-color: color(a98-rgb 0.44091 0.49971 0.37408); }",
+    //   indoc`
+    //   .foo {
+    //     background-color: #6a805d;
+    //     background-color: color(a98-rgb .44091 .49971 .37408);
+    //   }`,
+    //   {
+    //     chrome: 90 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   ".foo { background-color: color(a98-rgb 0.44091 0.49971 0.37408); }",
+    //   indoc`
+    //   .foo {
+    //     background-color: color(a98-rgb .44091 .49971 .37408);
+    //   }`,
+    //   {
+    //     safari: 15 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   ".foo { background-color: color(prophoto-rgb 0.36589 0.41717 0.31333); }",
+    //   indoc`
+    //   .foo {
+    //     background-color: #6a805d;
+    //     background-color: color(prophoto-rgb .36589 .41717 .31333);
+    //   }`,
+    //   {
+    //     chrome: 90 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   ".foo { background-color: color(rec2020 0.42210 0.47580 0.35605); }",
+    //   indoc`
+    //   .foo {
+    //     background-color: #728765;
+    //     background-color: color(rec2020 .4221 .4758 .35605);
+    //   }`,
+    //   {
+    //     chrome: 90 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   ".foo { background-color: color(xyz-d50 0.2005 0.14089 0.4472); }",
+    //   indoc`
+    //   .foo {
+    //     background-color: #7654cd;
+    //     background-color: color(xyz-d50 .2005 .14089 .4472);
+    //   }`,
+    //   {
+    //     chrome: 90 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   ".foo { background-color: color(xyz-d65 0.21661 0.14602 0.59452); }",
+    //   indoc`
+    //   .foo {
+    //     background-color: #7654cd;
+    //     background-color: color(xyz .21661 .14602 .59452);
+    //   }`,
+    //   {
+    //     chrome: 90 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   ".foo { background-color: lch(50.998% 135.363 338) }",
+    //   indoc`
+    //   .foo {
+    //     background-color: #ee00be;
+    //     background-color: color(display-p3 .972962 -.362078 .804206);
+    //     background-color: lch(50.998% 135.363 338);
+    //   }`,
+    //   {
+    //     chrome: 90 << 16,
+    //     safari: 14 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   ".foo { color: lch(50.998% 135.363 338) }",
+    //   indoc`
+    //   .foo {
+    //     color: #ee00be;
+    //     color: color(display-p3 .972962 -.362078 .804206);
+    //     color: lch(50.998% 135.363 338);
+    //   }`,
+    //   {
+    //     chrome: 90 << 16,
+    //     safari: 14 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   ".foo { background: var(--image) lch(40% 68.735435 34.568626) }",
+    //   indoc`
+    //   .foo {
+    //     background: var(--image) #b32323;
+    //   }
+
+    //   @supports (color: lab(0% 0 0)) {
+    //     .foo {
+    //       background: var(--image) lab(40% 56.6 39);
+    //     }
+    //   }`,
+    //   {
+    //     chrome: 90 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   `
+    //   .foo {
+    //     color: red;
+    //     color: lab(40% 56.6 39);
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     color: red;
+    //     color: lab(40% 56.6 39);
+    //   }`,
+    //   {
+    //     safari: 14 << 16,
+    //   },
+    // );
+    // prefix_test(
+    //   `
+    //   .foo {
+    //     color: red;
+    //     color: lab(40% 56.6 39);
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     color: lab(40% 56.6 39);
+    //   }`,
+    //   {
+    //     safari: 16 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   `
+    //   .foo {
+    //     color: var(--fallback);
+    //     color: lab(40% 56.6 39);
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     color: var(--fallback);
+    //     color: lab(40% 56.6 39);
+    //   }`,
+    //   {
+    //     safari: 14 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   `
+    //   .foo {
+    //     color: var(--fallback);
+    //     color: lab(40% 56.6 39);
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     color: lab(40% 56.6 39);
+    //   }`,
+    //   {
+    //     safari: 16 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   `
+    //   .foo {
+    //     color: red;
+    //     color: var(--foo, lab(40% 56.6 39));
+    //   }
+    // `,
+    //   indoc`
+    //   .foo {
+    //     color: var(--foo, color(display-p3 .643308 .192455 .167712));
+    //   }
+
+    //   @supports (color: lab(0% 0 0)) {
+    //     .foo {
+    //       color: var(--foo, lab(40% 56.6 39));
+    //     }
+    //   }`,
+    //   {
+    //     safari: 14 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   `
+    //   .foo {
+    //     --a: rgb(0 0 0 / var(--alpha));
+    //     --b: rgb(50% 50% 50% / var(--alpha));
+    //     --c: rgb(var(--x) 0 0);
+    //     --d: rgb(0 var(--x) 0);
+    //     --e: rgb(0 0 var(--x));
+    //     --f: rgb(var(--x) 0 0 / var(--alpha));
+    //     --g: rgb(0 var(--x) 0 / var(--alpha));
+    //     --h: rgb(0 0 var(--x) / var(--alpha));
+    //     --i: rgb(none 0 0 / var(--alpha));
+    //     --j: rgb(from yellow r g b / var(--alpha));
+    //   }
+    //   `,
+    //   indoc`
+    //   .foo {
+    //     --a: rgba(0, 0, 0, var(--alpha));
+    //     --b: rgba(128, 128, 128, var(--alpha));
+    //     --c: rgb(var(--x) 0 0);
+    //     --d: rgb(0 var(--x) 0);
+    //     --e: rgb(0 0 var(--x));
+    //     --f: rgb(var(--x) 0 0 / var(--alpha));
+    //     --g: rgb(0 var(--x) 0 / var(--alpha));
+    //     --h: rgb(0 0 var(--x) / var(--alpha));
+    //     --i: rgb(none 0 0 / var(--alpha));
+    //     --j: rgba(255, 255, 0, var(--alpha));
+    //   }`,
+    //   {
+    //     safari: 11 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   `
+    //   .foo {
+    //     --a: rgb(0 0 0 / var(--alpha));
+    //     --b: rgb(50% 50% 50% / var(--alpha));
+    //     --c: rgb(var(--x) 0 0);
+    //     --d: rgb(0 var(--x) 0);
+    //     --e: rgb(0 0 var(--x));
+    //     --f: rgb(var(--x) 0 0 / var(--alpha));
+    //     --g: rgb(0 var(--x) 0 / var(--alpha));
+    //     --h: rgb(0 0 var(--x) / var(--alpha));
+    //     --i: rgb(none 0 0 / var(--alpha));
+    //     --j: rgb(from yellow r g b / var(--alpha));
+    //   }
+    //   `,
+    //   indoc`
+    //   .foo {
+    //     --a: rgb(0 0 0 / var(--alpha));
+    //     --b: rgb(128 128 128 / var(--alpha));
+    //     --c: rgb(var(--x) 0 0);
+    //     --d: rgb(0 var(--x) 0);
+    //     --e: rgb(0 0 var(--x));
+    //     --f: rgb(var(--x) 0 0 / var(--alpha));
+    //     --g: rgb(0 var(--x) 0 / var(--alpha));
+    //     --h: rgb(0 0 var(--x) / var(--alpha));
+    //     --i: rgb(none 0 0 / var(--alpha));
+    //     --j: rgb(255 255 0 / var(--alpha));
+    //   }`,
+    //   {
+    //     safari: 13 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   `
+    //   .foo {
+    //     --a: hsl(270 100% 50% / var(--alpha));
+    //     --b: hsl(var(--x) 0 0);
+    //     --c: hsl(0 var(--x) 0);
+    //     --d: hsl(0 0 var(--x));
+    //     --e: hsl(var(--x) 0 0 / var(--alpha));
+    //     --f: hsl(0 var(--x) 0 / var(--alpha));
+    //     --g: hsl(0 0 var(--x) / var(--alpha));
+    //     --h: hsl(270 100% 50% / calc(var(--alpha) / 2));
+    //     --i: hsl(none 100% 50% / var(--alpha));
+    //     --j: hsl(from yellow h s l / var(--alpha));
+    //   }
+    //   `,
+    //   indoc`
+    //   .foo {
+    //     --a: hsla(270, 100%, 50%, var(--alpha));
+    //     --b: hsl(var(--x) 0 0);
+    //     --c: hsl(0 var(--x) 0);
+    //     --d: hsl(0 0 var(--x));
+    //     --e: hsl(var(--x) 0 0 / var(--alpha));
+    //     --f: hsl(0 var(--x) 0 / var(--alpha));
+    //     --g: hsl(0 0 var(--x) / var(--alpha));
+    //     --h: hsla(270, 100%, 50%, calc(var(--alpha) / 2));
+    //     --i: hsl(none 100% 50% / var(--alpha));
+    //     --j: hsla(60, 100%, 50%, var(--alpha));
+    //   }`,
+    //   {
+    //     safari: 11 << 16,
+    //   },
+    // );
+
+    // prefix_test(
+    //   `
+    //   .foo {
+    //     --a: hsl(270 100% 50% / var(--alpha));
+    //     --b: hsl(var(--x) 0 0);
+    //     --c: hsl(0 var(--x) 0);
+    //     --d: hsl(0 0 var(--x));
+    //     --e: hsl(var(--x) 0 0 / var(--alpha));
+    //     --f: hsl(0 var(--x) 0 / var(--alpha));
+    //     --g: hsl(0 0 var(--x) / var(--alpha));
+    //     --h: hsl(270 100% 50% / calc(var(--alpha) / 2));
+    //     --i: hsl(none 100% 50% / var(--alpha));
+    //   }
+    //   `,
+    //   indoc`
+    //     .foo {
+    //       --a: hsl(270 100% 50% / var(--alpha));
+    //       --b: hsl(var(--x) 0 0);
+    //       --c: hsl(0 var(--x) 0);
+    //       --d: hsl(0 0 var(--x));
+    //       --e: hsl(var(--x) 0 0 / var(--alpha));
+    //       --f: hsl(0 var(--x) 0 / var(--alpha));
+    //       --g: hsl(0 0 var(--x) / var(--alpha));
+    //       --h: hsl(270 100% 50% / calc(var(--alpha) / 2));
+    //       --i: hsl(none 100% 50% / var(--alpha));
+    //     }
+    //   `,
+    //   {
+    //     safari: 13 << 16,
+    //   },
+    // );
+
+    // minifyTest(
+    //   `
+    //   .foo {
+    //     --a: rgb(50% 50% 50% / calc(100% / 2));
+    //     --b: hsl(calc(360deg / 2) 50% 50%);
+    //     --c: oklab(40.101% calc(0.1 + 0.2) 0.0453);
+    //     --d: color(display-p3 0.43313 0.50108 calc(0.1 + 0.2));
+    //     --e: rgb(calc(255 / 2), calc(255 / 2), calc(255 / 2));
+    //   }
+    //   `,
+    //   indoc`
+    //     .foo {
+    //       --a: #80808080;
+    //       --b: #40bfbf;
+    //       --c: oklab(40.101% .3 .0453);
+    //       --d: color(display-p3 .43313 .50108 .3);
+    //       --e: gray;
+    //     }
+    //   `,
+    // );
+  });
+
+  describe("margin", () => {
+    cssTest(
+      `
+      .foo {
+        margin-left: 10px;
+        margin-right: 10px;
+        margin-top: 20px;
+        margin-bottom: 20px;
+      }`,
+      indoc`
+      .foo {
+        margin: 20px 10px;
+      }
+`,
+    );
+
+    cssTest(
+      `
+      .foo {
+        margin-block-start: 15px;
+        margin-block-end: 15px;
+      }`,
+      indoc`
+      .foo {
+        margin-block: 15px;
+      }
+`,
+    );
+
+    cssTest(
+      `
+      .foo {
+        margin-left: 10px;
+        margin-right: 10px;
+        margin-inline-start: 15px;
+        margin-inline-end: 15px;
+        margin-top: 20px;
+        margin-bottom: 20px;
+      }`,
+      indoc`
+      .foo {
+        margin-left: 10px;
+        margin-right: 10px;
+        margin-inline: 15px;
+        margin-top: 20px;
+        margin-bottom: 20px;
+      }
+`,
+    );
+
+    cssTest(
+      `
+      .foo {
+        margin: 10px;
+        margin-top: 20px;
+      }`,
+      indoc`
+      .foo {
+        margin: 20px 10px 10px;
+      }
+`,
+    );
+
+    cssTest(
+      `
+      .foo {
+        margin: 10px;
+        margin-top: var(--top);
+      }`,
+      indoc`
+      .foo {
+        margin: 10px;
+        margin-top: var(--top);
+      }
+`,
+    );
+
+    prefix_test(
+      `
+      .foo {
+        margin-inline-start: 2px;
+      }
+    `,
+      indoc`
+      .foo:not(:-webkit-any(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi))) {
+        margin-left: 2px;
+      }
+
+      .foo:not(:is(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi))) {
+        margin-left: 2px;
+      }
+
+      .foo:-webkit-any(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi)) {
+        margin-right: 2px;
+      }
+
+      .foo:is(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi)) {
+        margin-right: 2px;
+      }
+    `,
+      {
+        safari: 8 << 16,
+      },
+    );
+
+    prefix_test(
+      `
+      .foo {
+        margin-inline-start: 2px;
+        margin-inline-end: 4px;
+      }
+    `,
+      indoc`
+      .foo:not(:-webkit-any(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi))) {
+        margin-left: 2px;
+        margin-right: 4px;
+      }
+
+      .foo:not(:is(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi))) {
+        margin-left: 2px;
+        margin-right: 4px;
+      }
+
+      .foo:-webkit-any(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi)) {
+        margin-left: 4px;
+        margin-right: 2px;
+      }
+
+      .foo:is(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi)) {
+        margin-left: 4px;
+        margin-right: 2px;
+      }
+    `,
+      {
+        safari: 8 << 16,
+      },
+    );
+
+    prefix_test(
+      `
+      .foo {
+        margin-inline: 2px;
+      }
+    `,
+      indoc`
+      .foo {
+        margin-left: 2px;
+        margin-right: 2px;
+      }
+    `,
+      {
+        safari: 8 << 16,
+      },
+    );
+
+    prefix_test(
+      `
+      .foo {
+        margin-block-start: 2px;
+      }
+    `,
+      indoc`
+      .foo {
+        margin-top: 2px;
+      }
+    `,
+      {
+        safari: 8 << 16,
+      },
+    );
+
+    prefix_test(
+      `
+      .foo {
+        margin-block-end: 2px;
+      }
+    `,
+      indoc`
+      .foo {
+        margin-bottom: 2px;
+      }
+    `,
+      {
+        safari: 8 << 16,
+      },
+    );
+
+    prefix_test(
+      `
+      .foo {
+        margin-inline-start: 2px;
+        margin-inline-end: 2px;
+      }
+    `,
+      indoc`
+      .foo {
+        margin-inline-start: 2px;
+        margin-inline-end: 2px;
+      }
+    `,
+      {
+        safari: 13 << 16,
+      },
+    );
+
+    prefix_test(
+      `
+      .foo {
+        margin-inline: 2px;
+      }
+    `,
+      indoc`
+      .foo {
+        margin-inline-start: 2px;
+        margin-inline-end: 2px;
+      }
+    `,
+      {
+        safari: 13 << 16,
+      },
+    );
+
+    prefix_test(
+      `
+      .foo {
+        margin-inline-start: 2px;
+        margin-inline-end: 2px;
+      }
+    `,
+      indoc`
+      .foo {
+        margin-inline: 2px;
+      }
+    `,
+      {
+        safari: 15 << 16,
+      },
+    );
+
+    prefix_test(
+      `
+      .foo {
+        margin-inline: 2px;
+      }
+    `,
+      indoc`
+      .foo {
+        margin-inline: 2px;
+      }
+    `,
+      {
+        safari: 15 << 16,
+      },
+    );
+  });
+
+  describe("length", () => {
+    const properties = [
+      "margin-right",
+      "margin",
+      "padding-right",
+      "padding",
+      "width",
+      "height",
+      "min-height",
+      "max-height",
+      // "line-height",
+      // "border-radius",
+    ];
+
+    for (const prop of properties) {
+      prefix_test(
+        `
+        .foo {
+          ${prop}: 22px;
+          ${prop}: max(4%, 22px);
+        }
+      `,
+        indoc`
+        .foo {
+          ${prop}: 22px;
+          ${prop}: max(4%, 22px);
+        }
+      `,
+        {
+          safari: 10 << 16,
+        },
+      );
+
+      prefix_test(
+        `
+        .foo {
+          ${prop}: 22px;
+          ${prop}: max(4%, 22px);
+        }
+      `,
+        indoc`
+        .foo {
+          ${prop}: max(4%, 22px);
+        }
+      `,
+        {
+          safari: 14 << 16,
+        },
+      );
+
+      prefix_test(
+        `
+        .foo {
+          ${prop}: 22px;
+          ${prop}: max(2cqw, 22px);
+        }
+      `,
+        indoc`
+        .foo {
+          ${prop}: 22px;
+          ${prop}: max(2cqw, 22px);
+        }
+      `,
+        {
+          safari: 14 << 16,
+        },
+      );
+
+      prefix_test(
+        `
+        .foo {
+          ${prop}: 22px;
+          ${prop}: max(2cqw, 22px);
+        }
+      `,
+        indoc`
+        .foo {
+          ${prop}: max(2cqw, 22px);
+        }
+      `,
+        {
+          safari: 16 << 16,
+        },
+      );
+    }
+  });
+
+  describe("padding", () => {
+    cssTest(
+      `
+      .foo {
+        padding-left: 10px;
+        padding-right: 10px;
+        padding-top: 20px;
+        padding-bottom: 20px;
+      }
+    `,
+      indoc`
+      .foo {
+        padding: 20px 10px;
+      }
+    `,
+    );
+
+    cssTest(
+      `
+      .foo {
+        padding-block-start: 15px;
+        padding-block-end: 15px;
+      }
+    `,
+      indoc`
+      .foo {
+        padding-block: 15px;
+      }
+    `,
+    );
+
+    cssTest(
+      `
+      .foo {
+        padding-left: 10px;
+        padding-right: 10px;
+        padding-inline-start: 15px;
+        padding-inline-end: 15px;
+        padding-top: 20px;
+        padding-bottom: 20px;
+      }
+    `,
+      indoc`
+      .foo {
+        padding-left: 10px;
+        padding-right: 10px;
+        padding-inline: 15px;
+        padding-top: 20px;
+        padding-bottom: 20px;
+      }
+    `,
+    );
+
+    prefix_test(
+      `
+      .foo {
+        padding-inline-start: 2px;
+      }
+    `,
+      indoc`
+      .foo:not(:-webkit-any(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi))) {
+        padding-left: 2px;
+      }
+
+      .foo:not(:is(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi))) {
+        padding-left: 2px;
+      }
+
+      .foo:-webkit-any(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi)) {
+        padding-right: 2px;
+      }
+
+      .foo:is(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi)) {
+        padding-right: 2px;
+      }
+    `,
+      {
+        safari: 8 << 16,
+      },
+    );
+
+    prefix_test(
+      `
+      .foo {
+        padding-inline-start: 2px;
+        padding-inline-end: 4px;
+      }
+    `,
+      indoc`
+      .foo:not(:-webkit-any(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi))) {
+        padding-left: 2px;
+        padding-right: 4px;
+      }
+
+      .foo:not(:is(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi))) {
+        padding-left: 2px;
+        padding-right: 4px;
+      }
+
+      .foo:-webkit-any(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi)) {
+        padding-left: 4px;
+        padding-right: 2px;
+      }
+
+      .foo:is(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi)) {
+        padding-left: 4px;
+        padding-right: 2px;
+      }
+    `,
+      {
+        safari: 8 << 16,
+      },
+    );
+
+    prefix_test(
+      `
+      .foo {
+        padding-inline-start: var(--padding);
+      }
+    `,
+      indoc`
+      .foo:not(:-webkit-any(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi))) {
+        padding-left: var(--padding);
+      }
+
+      .foo:not(:is(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi))) {
+        padding-left: var(--padding);
+      }
+
+      .foo:-webkit-any(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi)) {
+        padding-right: var(--padding);
+      }
+
+      .foo:is(:lang(ae), :lang(ar), :lang(arc), :lang(bcc), :lang(bqi), :lang(ckb), :lang(dv), :lang(fa), :lang(glk), :lang(he), :lang(ku), :lang(mzn), :lang(nqo), :lang(pnb), :lang(ps), :lang(sd), :lang(ug), :lang(ur), :lang(yi)) {
+        padding-right: var(--padding);
+      }
+    `,
+      {
+        safari: 8 << 16,
+      },
+    );
+
+    prefix_test(
+      `
+      .foo {
+        padding-inline: 2px;
+      }
+    `,
+      indoc`
+      .foo {
+        padding-left: 2px;
+        padding-right: 2px;
+      }
+    `,
+      {
+        safari: 8 << 16,
+      },
+    );
+
+    prefix_test(
+      `
+      .foo {
+        padding-block-start: 2px;
+      }
+    `,
+      indoc`
+      .foo {
+        padding-top: 2px;
+      }
+    `,
+      {
+        safari: 8 << 16,
+      },
+    );
+
+    prefix_test(
+      `
+      .foo {
+        padding-block-end: 2px;
+      }
+    `,
+      indoc`
+      .foo {
+        padding-bottom: 2px;
+      }
+    `,
+      {
+        safari: 8 << 16,
+      },
+    );
+
+    prefix_test(
+      `
+      .foo {
+        padding-top: 1px;
+        padding-left: 2px;
+        padding-bottom: 3px;
+        padding-right: 4px;
+      }
+    `,
+      indoc`
+      .foo {
+        padding: 1px 4px 3px 2px;
+      }
+    `,
+      {
+        safari: 8 << 16,
+      },
+    );
+
+    prefix_test(
+      `
+      .foo {
+        padding-inline-start: 2px;
+        padding-inline-end: 2px;
+      }
+    `,
+      indoc`
+      .foo {
+        padding-inline-start: 2px;
+        padding-inline-end: 2px;
+      }
+    `,
+      {
+        safari: 13 << 16,
+      },
+    );
+
+    prefix_test(
+      `
+      .foo {
+        padding-inline-start: 2px;
+        padding-inline-end: 2px;
+      }
+    `,
+      indoc`
+      .foo {
+        padding-inline: 2px;
+      }
+    `,
+      {
+        safari: 15 << 16,
+      },
+    );
+  });
+
+  describe("scroll-paddding", () => {
+    prefix_test(
+      `
+      .foo {
+        scroll-padding-inline: 2px;
+      }
+    `,
+      indoc`
+      .foo {
+        scroll-padding-inline: 2px;
+      }
+    `,
+      {
+        safari: 8 << 16,
+      },
+    );
+  });
+
+  describe("size", () => {
+    prefix_test(
+      `
+      .foo {
+        block-size: 25px;
+        inline-size: 25px;
+        min-block-size: 25px;
+        min-inline-size: 25px;
+      }
+    `,
+      indoc`
+      .foo {
+        height: 25px;
+        min-height: 25px;
+        width: 25px;
+        min-width: 25px;
+      }
+    `,
+      {
+        safari: 8 << 16,
+      },
+    );
+
+    prefix_test(
+      `
+      .foo {
+        block-size: 25px;
+        min-block-size: 25px;
+        inline-size: 25px;
+        min-inline-size: 25px;
+      }
+    `,
+      indoc`
+      .foo {
+        block-size: 25px;
+        min-block-size: 25px;
+        inline-size: 25px;
+        min-inline-size: 25px;
+      }
+    `,
+      {
+        safari: 14 << 16,
+      },
+    );
+
+    prefix_test(
+      `
+      .foo {
+        block-size: var(--size);
+        min-block-size: var(--size);
+        inline-size: var(--size);
+        min-inline-size: var(--size);
+      }
+    `,
+      indoc`
+      .foo {
+        height: var(--size);
+        min-height: var(--size);
+        width: var(--size);
+        min-width: var(--size);
+      }
+    `,
+      {
+        safari: 8 << 16,
+      },
+    );
+
+    const sizeProps = [
+      ["width", "width"],
+      ["height", "height"],
+      ["block-size", "height"],
+      ["inline-size", "width"],
+      ["min-width", "min-width"],
+      ["min-height", "min-height"],
+      ["min-block-size", "min-height"],
+      ["min-inline-size", "min-width"],
+      ["max-width", "max-width"],
+      ["max-height", "max-height"],
+      ["max-block-size", "max-height"],
+      ["max-inline-size", "max-width"],
+    ];
+
+    for (const [inProp, outProp] of sizeProps) {
+      prefix_test(
+        `
+        .foo {
+          ${inProp}: stretch;
+        }
+      `,
+        indoc`
+        .foo {
+          ${outProp}: -webkit-fill-available;
+          ${outProp}: -moz-available;
+          ${outProp}: stretch;
+        }
+      `,
+        {
+          safari: 8 << 16,
+          firefox: 4 << 16,
+        },
+      );
+
+      prefix_test(
+        `
+        .foo {
+          ${inProp}: -webkit-fill-available;
+        }
+      `,
+        indoc`
+        .foo {
+          ${outProp}: -webkit-fill-available;
+        }
+      `,
+        {
+          safari: 8 << 16,
+          firefox: 4 << 16,
+        },
+      );
+
+      prefix_test(
+        `
+        .foo {
+          ${inProp}: 100vw;
+          ${inProp}: -webkit-fill-available;
+        }
+      `,
+        indoc`
+        .foo {
+          ${outProp}: 100vw;
+          ${outProp}: -webkit-fill-available;
+        }
+      `,
+        {
+          safari: 8 << 16,
+          firefox: 4 << 16,
+        },
+      );
+
+      prefix_test(
+        `
+        .foo {
+          ${inProp}: fit-content;
+        }
+      `,
+        indoc`
+        .foo {
+          ${outProp}: -webkit-fit-content;
+          ${outProp}: -moz-fit-content;
+          ${outProp}: fit-content;
+        }
+      `,
+        {
+          safari: 8 << 16,
+          firefox: 4 << 16,
+        },
+      );
+
+      prefix_test(
+        `
+        .foo {
+          ${inProp}: fit-content(50%);
+        }
+      `,
+        indoc`
+        .foo {
+          ${outProp}: fit-content(50%);
+        }
+      `,
+        {
+          safari: 8 << 16,
+          firefox: 4 << 16,
+        },
+      );
+
+      prefix_test(
+        `
+        .foo {
+          ${inProp}: min-content;
+        }
+      `,
+        indoc`
+        .foo {
+          ${outProp}: -webkit-min-content;
+          ${outProp}: -moz-min-content;
+          ${outProp}: min-content;
+        }
+      `,
+        {
+          safari: 8 << 16,
+          firefox: 4 << 16,
+        },
+      );
+
+      prefix_test(
+        `
+        .foo {
+          ${inProp}: max-content;
+        }
+      `,
+        indoc`
+        .foo {
+          ${outProp}: -webkit-max-content;
+          ${outProp}: -moz-max-content;
+          ${outProp}: max-content;
+        }
+      `,
+        {
+          safari: 8 << 16,
+          firefox: 4 << 16,
+        },
+      );
+
+      prefix_test(
+        `
+        .foo {
+          ${inProp}: 100%;
+          ${inProp}: max-content;
+        }
+      `,
+        indoc`
+        .foo {
+          ${outProp}: 100%;
+          ${outProp}: max-content;
+        }
+      `,
+        {
+          safari: 8 << 16,
+          firefox: 4 << 16,
+        },
+      );
+
+      prefix_test(
+        `
+        .foo {
+          ${inProp}: var(--fallback);
+          ${inProp}: max-content;
+        }
+      `,
+        indoc`
+        .foo {
+          ${outProp}: var(--fallback);
+          ${outProp}: max-content;
+        }
+      `,
+        {
+          safari: 8 << 16,
+          firefox: 4 << 16,
+        },
+      );
+    }
+
+    minifyTest(".foo { aspect-ratio: auto }", ".foo{aspect-ratio:auto}");
+    minifyTest(".foo { aspect-ratio: 2 / 3 }", ".foo{aspect-ratio:2/3}");
+    minifyTest(".foo { aspect-ratio: auto 2 / 3 }", ".foo{aspect-ratio:auto 2/3}");
+    minifyTest(".foo { aspect-ratio: 2 / 3 auto }", ".foo{aspect-ratio:auto 2/3}");
+  });
+
+  describe("background", () => {
+    cssTest(
+      `
+      .foo {
+        background: url(img.png);
+        background-position-x: 20px;
+        background-position-y: 10px;
+        background-size: 50px 100px;
+        background-repeat: repeat no-repeat;
+      }
+    `,
+      indoc`
+      .foo {
+        background: url("img.png") 20px 10px / 50px 100px repeat-x;
+      }
+    `,
+    );
+
+    cssTest(
+      `
+      .foo {
+        background-color: red;
+        background-position: 0% 0%;
+        background-size: auto;
+        background-repeat: repeat;
+        background-clip: border-box;
+        background-origin: padding-box;
+        background-attachment: scroll;
+        background-image: none
+      }
+    `,
+      indoc`
+      .foo {
+        background: red;
+      }
+    `,
+    );
+
+    cssTest(
+      `
+      .foo {
+        background-color: gray;
+        background-position: 40% 50%;
+        background-size: 10em auto;
+        background-repeat: round;
+        background-clip: border-box;
+        background-origin: border-box;
+        background-attachment: fixed;
+        background-image: url('chess.png');
+      }
+    `,
+      indoc`
+      .foo {
+        background: gray url("chess.png") 40% / 10em round fixed border-box;
+      }
+    `,
+    );
+
+    cssTest(
+      `
+      .foo {
+        background: url(img.png), url(test.jpg) gray;
+        background-position-x: right 20px, 10px;
+        background-position-y: top 20px, 15px;
+        background-size: 50px 50px, auto;
+        background-repeat: repeat no-repeat, no-repeat;
+      }
+    `,
+      indoc`
+      .foo {
+        background: url("img.png") right 20px top 20px / 50px 50px repeat-x, gray url("test.jpg") 10px 15px no-repeat;
+      }
+    `,
+    );
+
+    minify_test(
+      `
+      .foo {
+        background-position: center center;
+      }
+    `,
+      indoc`.foo{background-position:50%}`,
+    );
+
+    cssTest(
+      `
+      .foo {
+        background: url(img.png) gray;
+        background-clip: content-box;
+        -webkit-background-clip: text;
+      }
+    `,
+      indoc`
+      .foo {
+        background: gray url("img.png") padding-box content-box;
+        -webkit-background-clip: text;
+      }
+    `,
+    );
+
+    cssTest(
+      `
+      .foo {
+        background: url(img.png) gray;
+        -webkit-background-clip: text;
+        background-clip: content-box;
+      }
+    `,
+      indoc`
+      .foo {
+        background: gray url("img.png");
+        -webkit-background-clip: text;
+        background-clip: content-box;
+      }
+    `,
+    );
+
+    cssTest(
+      `
+      .foo {
+        background: url(img.png) gray;
+        background-position: var(--pos);
+      }
+    `,
+      indoc`
+      .foo {
+        background: gray url("img.png");
+        background-position: var(--pos);
+      }
+    `,
+    );
+
+    minify_test(".foo { background-position: bottom left }", ".foo{background-position:0 100%}");
+    minify_test(".foo { background-position: left 10px center }", ".foo{background-position:10px 50%}");
+    minify_test(".foo { background-position: right 10px center }", ".foo{background-position:right 10px center}");
+    minify_test(".foo { background-position: right 10px top 20px }", ".foo{background-position:right 10px top 20px}");
+    minify_test(".foo { background-position: left 10px top 20px }", ".foo{background-position:10px 20px}");
+    minify_test(
+      ".foo { background-position: left 10px bottom 20px }",
+      ".foo{background-position:left 10px bottom 20px}",
+    );
+    minify_test(".foo { background-position: left 10px top }", ".foo{background-position:10px 0}");
+    minify_test(".foo { background-position: bottom right }", ".foo{background-position:100% 100%}");
+
+    minify_test(
+      ".foo { background: url('img-sprite.png') no-repeat bottom right }",
+      ".foo{background:url(img-sprite.png) 100% 100% no-repeat}",
+    );
+    minify_test(".foo { background: transparent }", ".foo{background:0 0}");
+
+    minify_test(
+      ".foo { background: url(\"data:image/svg+xml,%3Csvg width='168' height='24' xmlns='http://www.w3.org/2000/svg'%3E%3C/svg%3E\") }",
+      ".foo{background:url(\"data:image/svg+xml,%3Csvg width='168' height='24' xmlns='http://www.w3.org/2000/svg'%3E%3C/svg%3E\")}",
+    );
+
+    cssTest(
+      `
+      .foo {
+        background: url(img.png);
+        background-clip: text;
+      }
+    `,
+      indoc`
+      .foo {
+        background: url("img.png") text;
+      }
+    `,
+    );
+
+    prefix_test(
+      `
+        .foo {
+          background: url(img.png);
+          background-clip: text;
+        }
+      `,
+      indoc`
+        .foo {
+          background: url("img.png");
+          -webkit-background-clip: text;
+          background-clip: text;
+        }
+      `,
+      {
+        safari: 8 << 16,
+      },
+    );
+
+    prefix_test(
+      `
+        .foo {
+          background: url(img.png);
+          background-clip: text;
+        }
+      `,
+      indoc`
+        .foo {
+          background: url("img.png") text;
+        }
+      `,
+      {
+        safari: 14 << 16,
+      },
+    );
+
+    prefix_test(
+      `
+        .foo {
+          background: url(img.png) text;
+        }
+      `,
+      indoc`
+        .foo {
+          background: url("img.png");
+          -webkit-background-clip: text;
+          background-clip: text;
+        }
+      `,
+      {
+        chrome: 45 << 16,
+      },
+    );
+
+    prefix_test(
+      `
+        .foo {
+          background: url(img.png);
+          -webkit-background-clip: text;
+        }
+      `,
+      indoc`
+        .foo {
+          background: url("img.png");
+          -webkit-background-clip: text;
+        }
+      `,
+      {
+        chrome: 45 << 16,
+      },
+    );
+
+    prefix_test(
+      `
+        .foo {
+          background: url(img.png);
+          background-clip: text;
+        }
+      `,
+      indoc`
+        .foo {
+          background: url("img.png");
+          -webkit-background-clip: text;
+          background-clip: text;
+        }
+      `,
+      {
+        safari: 14 << 16,
+        chrome: 95 << 16,
+      },
+    );
+
+    prefix_test(
+      `
+        .foo {
+          background-image: url(img.png);
+          background-clip: text;
+        }
+      `,
+      indoc`
+        .foo {
+          background-image: url("img.png");
+          -webkit-background-clip: text;
+          background-clip: text;
+        }
+      `,
+      {
+        safari: 8 << 16,
+      },
+    );
+
+    prefix_test(
+      `
+        .foo {
+          -webkit-background-clip: text;
+          background-clip: text;
+        }
+      `,
+      indoc`
+        .foo {
+          -webkit-background-clip: text;
+          background-clip: text;
+        }
+      `,
+      {
+        chrome: 45 << 16,
+      },
+    );
+
+    prefix_test(
+      `
+        .foo {
+          background-image: url(img.png);
+          background-clip: text;
+        }
+      `,
+      indoc`
+        .foo {
+          background-image: url("img.png");
+          background-clip: text;
+        }
+      `,
+      {
+        safari: 14 << 16,
+      },
+    );
+
+    minify_test(".foo { background: none center }", ".foo{background:50%}");
+    minify_test(".foo { background: none }", ".foo{background:0 0}");
+
+    prefix_test(
+      `
+        .foo {
+          background: lab(51.5117% 43.3777 -29.0443);
+        }
+      `,
+      indoc`
+        .foo {
+          background: #af5cae;
+          background: lab(51.5117% 43.3777 -29.0443);
+        }
+      `,
+      {
+        chrome: 95 << 16,
+        safari: 15 << 16,
+      },
+    );
+
+    prefix_test(
+      `
+        .foo {
+          background: lab(51.5117% 43.3777 -29.0443) url(foo.png);
+        }
+      `,
+      indoc`
+        .foo {
+          background: #af5cae url("foo.png");
+          background: lab(51.5117% 43.3777 -29.0443) url("foo.png");
+        }
+      `,
+      {
+        chrome: 95 << 16,
+        safari: 15 << 16,
+      },
+    );
+
+    prefix_test(
+      `
+        .foo {
+          background: lab(51.5117% 43.3777 -29.0443) linear-gradient(lab(52.2319% 40.1449 59.9171), lab(47.7776% -34.2947 -7.65904));
+        }
+      `,
+      indoc`
+        .foo {
+          background: #af5cae linear-gradient(#c65d07, #00807c);
+          background: lab(51.5117% 43.3777 -29.0443) linear-gradient(lab(52.2319% 40.1449 59.9171), lab(47.7776% -34.2947 -7.65904));
+        }
+      `,
+      {
+        chrome: 95 << 16,
+        safari: 15 << 16,
+      },
+    );
+
+    cssTest(
+      ".foo { background: calc(var(--v) / 0.3)",
+      indoc`
+        .foo {
+          background: calc(var(--v) / .3);
+        }
+      `,
+    );
+
+    prefix_test(
+      `
+        .foo {
+          background-color: #4263eb;
+          background-color: color(display-p3 0 .5 1);
+        }
+      `,
+      indoc`
+        .foo {
+          background-color: #4263eb;
+          background-color: color(display-p3 0 .5 1);
+        }
+      `,
+      {
+        chrome: 99 << 16,
+      },
+    );
+    prefix_test(
+      `
+        .foo {
+          background-color: #4263eb;
+          background-color: color(display-p3 0 .5 1);
+        }
+      `,
+      indoc`
+        .foo {
+          background-color: color(display-p3 0 .5 1);
+        }
+      `,
+      {
+        safari: 16 << 16,
+      },
+    );
+    prefix_test(
+      `
+        .foo {
+          background-image: linear-gradient(red, green);
+          background-image: linear-gradient(lch(50% 132 50), lch(50% 130 150));
+        }
+      `,
+      indoc`
+        .foo {
+          background-image: linear-gradient(red, green);
+          background-image: linear-gradient(lch(50% 132 50), lch(50% 130 150));
+        }
+      `,
+      {
+        chrome: 99 << 16,
+      },
+    );
+    prefix_test(
+      `
+        .foo {
+          background-image: linear-gradient(red, green);
+          background-image: linear-gradient(lch(50% 132 50), lch(50% 130 150));
+        }
+      `,
+      indoc`
+        .foo {
+          background-image: linear-gradient(lch(50% 132 50), lch(50% 130 150));
+        }
+      `,
+      {
+        safari: 16 << 16,
+      },
+    );
+    prefix_test(
+      `
+        .foo {
+          background: #4263eb;
+          background: color(display-p3 0 .5 1);
+        }
+      `,
+      indoc`
+        .foo {
+          background: #4263eb;
+          background: color(display-p3 0 .5 1);
+        }
+      `,
+      {
+        chrome: 99 << 16,
+      },
+    );
+    prefix_test(
+      `
+        .foo {
+          background: #4263eb;
+          background: color(display-p3 0 .5 1);
+        }
+      `,
+      indoc`
+        .foo {
+          background: color(display-p3 0 .5 1);
+        }
+      `,
+      {
+        safari: 16 << 16,
+      },
+    );
+    prefix_test(
+      `
+        .foo {
+          background: linear-gradient(red, green);
+          background: linear-gradient(lch(50% 132 50), lch(50% 130 150));
+        }
+      `,
+      indoc`
+        .foo {
+          background: linear-gradient(red, green);
+          background: linear-gradient(lch(50% 132 50), lch(50% 130 150));
+        }
+      `,
+      {
+        chrome: 99 << 16,
+      },
+    );
+    prefix_test(
+      `
+        .foo {
+          background: red;
+          background: linear-gradient(lch(50% 132 50), lch(50% 130 150));
+        }
+      `,
+      indoc`
+        .foo {
+          background: red;
+          background: linear-gradient(lch(50% 132 50), lch(50% 130 150));
+        }
+      `,
+      {
+        chrome: 99 << 16,
+      },
+    );
+    prefix_test(
+      `
+        .foo {
+          background: linear-gradient(red, green);
+          background: linear-gradient(lch(50% 132 50), lch(50% 130 150));
+        }
+      `,
+      indoc`
+        .foo {
+          background: linear-gradient(lch(50% 132 50), lch(50% 130 150));
+        }
+      `,
+      {
+        safari: 16 << 16,
+      },
+    );
+    prefix_test(
+      `
+        .foo {
+          background: var(--fallback);
+          background: linear-gradient(lch(50% 132 50), lch(50% 130 150));
+        }
+      `,
+      indoc`
+        .foo {
+          background: var(--fallback);
+          background: linear-gradient(lch(50% 132 50), lch(50% 130 150));
+        }
+      `,
+      {
+        chrome: 99 << 16,
+      },
+    );
+    prefix_test(
+      `
+        .foo {
+          background: red url(foo.png);
+          background: lch(50% 132 50) url(foo.png);
+        }
+      `,
+      indoc`
+        .foo {
+          background: red url("foo.png");
+          background: lch(50% 132 50) url("foo.png");
+        }
+      `,
+      {
+        chrome: 99 << 16,
+      },
+    );
+  });
+});
diff --git a/test/js/bun/css/dedent.ts b/test/js/bun/css/dedent.ts
new file mode 100644
index 0000000000..ca17af0957
--- /dev/null
+++ b/test/js/bun/css/dedent.ts
@@ -0,0 +1,85 @@
+/// Copied from https://github.com/dmnd/dedent/blob/main/src/dedent.ts
+export interface DedentOptions {
+  escapeSpecialCharacters?: boolean;
+}
+
+export interface Dedent {
+  (literals: string): string;
+  (strings: TemplateStringsArray, ...values: unknown[]): string;
+  withOptions: CreateDedent;
+}
+
+export type CreateDedent = (options: DedentOptions) => Dedent;
+
+const dedent: Dedent = createDedent({});
+
+export default dedent;
+
+function createDedent(options: DedentOptions) {
+  dedent.withOptions = (newOptions: DedentOptions): Dedent => createDedent({ ...options, ...newOptions });
+
+  return dedent;
+
+  function dedent(literals: string): string;
+  function dedent(strings: TemplateStringsArray, ...values: unknown[]): string;
+  function dedent(strings: TemplateStringsArray | string, ...values: unknown[]) {
+    const raw = typeof strings === "string" ? [strings] : strings.raw;
+    const { escapeSpecialCharacters = Array.isArray(strings) } = options;
+
+    // first, perform interpolation
+    let result = "";
+    for (let i = 0; i < raw.length; i++) {
+      let next = raw[i];
+
+      if (escapeSpecialCharacters) {
+        // handle escaped newlines, backticks, and interpolation characters
+        next = next
+          .replace(/\\\n[ \t]*/g, "")
+          .replace(/\\`/g, "`")
+          .replace(/\\\$/g, "$")
+          .replace(/\\\{/g, "{");
+      }
+
+      result += next;
+
+      if (i < values.length) {
+        // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
+        result += values[i];
+      }
+    }
+
+    // now strip indentation
+    const lines = result.split("\n");
+    let mindent: null | number = null;
+    for (const l of lines) {
+      const m = l.match(/^(\s+)\S+/);
+      if (m) {
+        const indent = m[1].length;
+        if (!mindent) {
+          // this is the first indented line
+          mindent = indent;
+        } else {
+          mindent = Math.min(mindent, indent);
+        }
+      }
+    }
+
+    if (mindent !== null) {
+      const m = mindent; // appease TypeScript
+      result = lines
+        // https://github.com/typescript-eslint/typescript-eslint/issues/7140
+        // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
+        .map(l => (l[0] === " " || l[0] === "\t" ? l.slice(m) : l))
+        .join("\n");
+    }
+
+    // dedent eats leading and trailing whitespace too
+    result = result.trim();
+    if (escapeSpecialCharacters) {
+      // handle escaped newlines at the end to ensure they don't get stripped too
+      result = result.replace(/\\n/g, "\n");
+    }
+
+    return result;
+  }
+}
diff --git a/test/js/bun/css/doesnt_crash.test.ts b/test/js/bun/css/doesnt_crash.test.ts
new file mode 100644
index 0000000000..c418f74e22
--- /dev/null
+++ b/test/js/bun/css/doesnt_crash.test.ts
@@ -0,0 +1,61 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import { describe, expect, test } from "bun:test";
+import { readdirSync } from "fs";
+import "harness";
+import { bunEnv, bunExe, tmpdirSync } from "harness";
+import path from "path";
+describe("doesnt_crash", async () => {
+  let files: string[] = [];
+  let temp_dir: string = tmpdirSync();
+  const files_dir = path.join(import.meta.dir, "files");
+  temp_dir = tmpdirSync();
+  files = readdirSync(files_dir).map(file => path.join(files_dir, file));
+  console.log("Tempdir", temp_dir);
+
+  files.map(absolute => {
+    absolute = absolute.replaceAll("\\", "/");
+    const file = path.basename(absolute);
+    const outfile1 = path.join(temp_dir, "file-1" + file).replaceAll("\\", "/");
+    const outfile2 = path.join(temp_dir, "file-2" + file).replaceAll("\\", "/");
+    const outfile3 = path.join(temp_dir, "file-3" + file).replaceAll("\\", "/");
+    const outfile4 = path.join(temp_dir, "file-4" + file).replaceAll("\\", "/");
+
+    test(file, async () => {
+      {
+        const { stdout, stderr, exitCode } =
+          await Bun.$`${bunExe()} build --experimental-css ${absolute} --outfile=${outfile1}`.quiet().env(bunEnv);
+        expect(exitCode).toBe(0);
+        expect(stdout.toString()).not.toContain("error");
+        expect(stderr.toString()).toBeEmpty();
+      }
+
+      const { stdout, stderr, exitCode } =
+        await Bun.$`${bunExe()} build --experimental-css ${outfile1} --outfile=${outfile2}`.quiet().env(bunEnv);
+      expect(exitCode).toBe(0);
+      expect(stdout.toString()).not.toContain("error");
+      expect(stderr.toString()).toBeEmpty();
+    });
+
+    test(`(minify) ${file}`, async () => {
+      {
+        const { stdout, stderr, exitCode } =
+          await Bun.$`${bunExe()} build --experimental-css ${absolute} --minify --outfile=${outfile3}`
+            .quiet()
+            .env(bunEnv);
+        expect(exitCode).toBe(0);
+        expect(stdout.toString()).not.toContain("error");
+        expect(stderr.toString()).toBeEmpty();
+      }
+      const { stdout, stderr, exitCode } =
+        await Bun.$`${bunExe()} build --experimental-css ${outfile3} --minify --outfile=${outfile4}`
+          .quiet()
+          .env(bunEnv);
+      expect(exitCode).toBe(0);
+      expect(stdout.toString()).not.toContain("error");
+      expect(stderr.toString()).toBeEmpty();
+    });
+  });
+});
diff --git a/test/js/bun/css/files/animate.css b/test/js/bun/css/files/animate.css
new file mode 100644
index 0000000000..42dc0a7e1d
--- /dev/null
+++ b/test/js/bun/css/files/animate.css
@@ -0,0 +1,4074 @@
+
+@charset "UTF-8";
+/*!
+ * animate.css - https://animate.style/
+ * Version - 4.1.1
+ * Licensed under the Hippocratic License 2.1 - http://firstdonoharm.dev
+ *
+ * Copyright (c) 2022 Animate.css
+ */
+:root {
+  --animate-duration: 1s;
+  --animate-delay: 1s;
+  --animate-repeat: 1;
+}
+.animate__animated {
+  -webkit-animation-duration: 1s;
+  animation-duration: 1s;
+  -webkit-animation-duration: var(--animate-duration);
+  animation-duration: var(--animate-duration);
+  -webkit-animation-fill-mode: both;
+  animation-fill-mode: both;
+}
+.animate__animated.animate__infinite {
+  -webkit-animation-iteration-count: infinite;
+  animation-iteration-count: infinite;
+}
+.animate__animated.animate__repeat-1 {
+  -webkit-animation-iteration-count: 1;
+  animation-iteration-count: 1;
+  -webkit-animation-iteration-count: var(--animate-repeat);
+  animation-iteration-count: var(--animate-repeat);
+}
+.animate__animated.animate__repeat-2 {
+  -webkit-animation-iteration-count: calc(1 * 2);
+  animation-iteration-count: calc(1 * 2);
+  -webkit-animation-iteration-count: calc(var(--animate-repeat) * 2);
+  animation-iteration-count: calc(var(--animate-repeat) * 2);
+}
+.animate__animated.animate__repeat-3 {
+  -webkit-animation-iteration-count: calc(1 * 3);
+  animation-iteration-count: calc(1 * 3);
+  -webkit-animation-iteration-count: calc(var(--animate-repeat) * 3);
+  animation-iteration-count: calc(var(--animate-repeat) * 3);
+}
+.animate__animated.animate__delay-1s {
+  -webkit-animation-delay: 1s;
+  animation-delay: 1s;
+  -webkit-animation-delay: var(--animate-delay);
+  animation-delay: var(--animate-delay);
+}
+.animate__animated.animate__delay-2s {
+  -webkit-animation-delay: calc(1s * 2);
+  animation-delay: calc(1s * 2);
+  -webkit-animation-delay: calc(var(--animate-delay) * 2);
+  animation-delay: calc(var(--animate-delay) * 2);
+}
+.animate__animated.animate__delay-3s {
+  -webkit-animation-delay: calc(1s * 3);
+  animation-delay: calc(1s * 3);
+  -webkit-animation-delay: calc(var(--animate-delay) * 3);
+  animation-delay: calc(var(--animate-delay) * 3);
+}
+.animate__animated.animate__delay-4s {
+  -webkit-animation-delay: calc(1s * 4);
+  animation-delay: calc(1s * 4);
+  -webkit-animation-delay: calc(var(--animate-delay) * 4);
+  animation-delay: calc(var(--animate-delay) * 4);
+}
+.animate__animated.animate__delay-5s {
+  -webkit-animation-delay: calc(1s * 5);
+  animation-delay: calc(1s * 5);
+  -webkit-animation-delay: calc(var(--animate-delay) * 5);
+  animation-delay: calc(var(--animate-delay) * 5);
+}
+.animate__animated.animate__faster {
+  -webkit-animation-duration: calc(1s / 2);
+  animation-duration: calc(1s / 2);
+  -webkit-animation-duration: calc(var(--animate-duration) / 2);
+  animation-duration: calc(var(--animate-duration) / 2);
+}
+.animate__animated.animate__fast {
+  -webkit-animation-duration: calc(1s * 0.8);
+  animation-duration: calc(1s * 0.8);
+  -webkit-animation-duration: calc(var(--animate-duration) * 0.8);
+  animation-duration: calc(var(--animate-duration) * 0.8);
+}
+.animate__animated.animate__slow {
+  -webkit-animation-duration: calc(1s * 2);
+  animation-duration: calc(1s * 2);
+  -webkit-animation-duration: calc(var(--animate-duration) * 2);
+  animation-duration: calc(var(--animate-duration) * 2);
+}
+.animate__animated.animate__slower {
+  -webkit-animation-duration: calc(1s * 3);
+  animation-duration: calc(1s * 3);
+  -webkit-animation-duration: calc(var(--animate-duration) * 3);
+  animation-duration: calc(var(--animate-duration) * 3);
+}
+@media print, (prefers-reduced-motion: reduce) {
+  .animate__animated {
+    -webkit-animation-duration: 1ms !important;
+    animation-duration: 1ms !important;
+    -webkit-transition-duration: 1ms !important;
+    transition-duration: 1ms !important;
+    -webkit-animation-iteration-count: 1 !important;
+    animation-iteration-count: 1 !important;
+  }
+
+  .animate__animated[class*='Out'] {
+    opacity: 0;
+  }
+}
+/* Attention seekers  */
+@-webkit-keyframes bounce {
+  from,
+  20%,
+  53%,
+  to {
+    -webkit-animation-timing-function: cubic-bezier(0.215, 0.61, 0.355, 1);
+    animation-timing-function: cubic-bezier(0.215, 0.61, 0.355, 1);
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+
+  40%,
+  43% {
+    -webkit-animation-timing-function: cubic-bezier(0.755, 0.05, 0.855, 0.06);
+    animation-timing-function: cubic-bezier(0.755, 0.05, 0.855, 0.06);
+    -webkit-transform: translate3d(0, -30px, 0) scaleY(1.1);
+    transform: translate3d(0, -30px, 0) scaleY(1.1);
+  }
+
+  70% {
+    -webkit-animation-timing-function: cubic-bezier(0.755, 0.05, 0.855, 0.06);
+    animation-timing-function: cubic-bezier(0.755, 0.05, 0.855, 0.06);
+    -webkit-transform: translate3d(0, -15px, 0) scaleY(1.05);
+    transform: translate3d(0, -15px, 0) scaleY(1.05);
+  }
+
+  80% {
+    -webkit-transition-timing-function: cubic-bezier(0.215, 0.61, 0.355, 1);
+    transition-timing-function: cubic-bezier(0.215, 0.61, 0.355, 1);
+    -webkit-transform: translate3d(0, 0, 0) scaleY(0.95);
+    transform: translate3d(0, 0, 0) scaleY(0.95);
+  }
+
+  90% {
+    -webkit-transform: translate3d(0, -4px, 0) scaleY(1.02);
+    transform: translate3d(0, -4px, 0) scaleY(1.02);
+  }
+}
+@keyframes bounce {
+  from,
+  20%,
+  53%,
+  to {
+    -webkit-animation-timing-function: cubic-bezier(0.215, 0.61, 0.355, 1);
+    animation-timing-function: cubic-bezier(0.215, 0.61, 0.355, 1);
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+
+  40%,
+  43% {
+    -webkit-animation-timing-function: cubic-bezier(0.755, 0.05, 0.855, 0.06);
+    animation-timing-function: cubic-bezier(0.755, 0.05, 0.855, 0.06);
+    -webkit-transform: translate3d(0, -30px, 0) scaleY(1.1);
+    transform: translate3d(0, -30px, 0) scaleY(1.1);
+  }
+
+  70% {
+    -webkit-animation-timing-function: cubic-bezier(0.755, 0.05, 0.855, 0.06);
+    animation-timing-function: cubic-bezier(0.755, 0.05, 0.855, 0.06);
+    -webkit-transform: translate3d(0, -15px, 0) scaleY(1.05);
+    transform: translate3d(0, -15px, 0) scaleY(1.05);
+  }
+
+  80% {
+    -webkit-transition-timing-function: cubic-bezier(0.215, 0.61, 0.355, 1);
+    transition-timing-function: cubic-bezier(0.215, 0.61, 0.355, 1);
+    -webkit-transform: translate3d(0, 0, 0) scaleY(0.95);
+    transform: translate3d(0, 0, 0) scaleY(0.95);
+  }
+
+  90% {
+    -webkit-transform: translate3d(0, -4px, 0) scaleY(1.02);
+    transform: translate3d(0, -4px, 0) scaleY(1.02);
+  }
+}
+.animate__bounce {
+  -webkit-animation-name: bounce;
+  animation-name: bounce;
+  -webkit-transform-origin: center bottom;
+  transform-origin: center bottom;
+}
+@-webkit-keyframes flash {
+  from,
+  50%,
+  to {
+    opacity: 1;
+  }
+
+  25%,
+  75% {
+    opacity: 0;
+  }
+}
+@keyframes flash {
+  from,
+  50%,
+  to {
+    opacity: 1;
+  }
+
+  25%,
+  75% {
+    opacity: 0;
+  }
+}
+.animate__flash {
+  -webkit-animation-name: flash;
+  animation-name: flash;
+}
+/* originally authored by Nick Pettit - https://github.com/nickpettit/glide */
+@-webkit-keyframes pulse {
+  from {
+    -webkit-transform: scale3d(1, 1, 1);
+    transform: scale3d(1, 1, 1);
+  }
+
+  50% {
+    -webkit-transform: scale3d(1.05, 1.05, 1.05);
+    transform: scale3d(1.05, 1.05, 1.05);
+  }
+
+  to {
+    -webkit-transform: scale3d(1, 1, 1);
+    transform: scale3d(1, 1, 1);
+  }
+}
+@keyframes pulse {
+  from {
+    -webkit-transform: scale3d(1, 1, 1);
+    transform: scale3d(1, 1, 1);
+  }
+
+  50% {
+    -webkit-transform: scale3d(1.05, 1.05, 1.05);
+    transform: scale3d(1.05, 1.05, 1.05);
+  }
+
+  to {
+    -webkit-transform: scale3d(1, 1, 1);
+    transform: scale3d(1, 1, 1);
+  }
+}
+.animate__pulse {
+  -webkit-animation-name: pulse;
+  animation-name: pulse;
+  -webkit-animation-timing-function: ease-in-out;
+  animation-timing-function: ease-in-out;
+}
+@-webkit-keyframes rubberBand {
+  from {
+    -webkit-transform: scale3d(1, 1, 1);
+    transform: scale3d(1, 1, 1);
+  }
+
+  30% {
+    -webkit-transform: scale3d(1.25, 0.75, 1);
+    transform: scale3d(1.25, 0.75, 1);
+  }
+
+  40% {
+    -webkit-transform: scale3d(0.75, 1.25, 1);
+    transform: scale3d(0.75, 1.25, 1);
+  }
+
+  50% {
+    -webkit-transform: scale3d(1.15, 0.85, 1);
+    transform: scale3d(1.15, 0.85, 1);
+  }
+
+  65% {
+    -webkit-transform: scale3d(0.95, 1.05, 1);
+    transform: scale3d(0.95, 1.05, 1);
+  }
+
+  75% {
+    -webkit-transform: scale3d(1.05, 0.95, 1);
+    transform: scale3d(1.05, 0.95, 1);
+  }
+
+  to {
+    -webkit-transform: scale3d(1, 1, 1);
+    transform: scale3d(1, 1, 1);
+  }
+}
+@keyframes rubberBand {
+  from {
+    -webkit-transform: scale3d(1, 1, 1);
+    transform: scale3d(1, 1, 1);
+  }
+
+  30% {
+    -webkit-transform: scale3d(1.25, 0.75, 1);
+    transform: scale3d(1.25, 0.75, 1);
+  }
+
+  40% {
+    -webkit-transform: scale3d(0.75, 1.25, 1);
+    transform: scale3d(0.75, 1.25, 1);
+  }
+
+  50% {
+    -webkit-transform: scale3d(1.15, 0.85, 1);
+    transform: scale3d(1.15, 0.85, 1);
+  }
+
+  65% {
+    -webkit-transform: scale3d(0.95, 1.05, 1);
+    transform: scale3d(0.95, 1.05, 1);
+  }
+
+  75% {
+    -webkit-transform: scale3d(1.05, 0.95, 1);
+    transform: scale3d(1.05, 0.95, 1);
+  }
+
+  to {
+    -webkit-transform: scale3d(1, 1, 1);
+    transform: scale3d(1, 1, 1);
+  }
+}
+.animate__rubberBand {
+  -webkit-animation-name: rubberBand;
+  animation-name: rubberBand;
+}
+@-webkit-keyframes shakeX {
+  from,
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+
+  10%,
+  30%,
+  50%,
+  70%,
+  90% {
+    -webkit-transform: translate3d(-10px, 0, 0);
+    transform: translate3d(-10px, 0, 0);
+  }
+
+  20%,
+  40%,
+  60%,
+  80% {
+    -webkit-transform: translate3d(10px, 0, 0);
+    transform: translate3d(10px, 0, 0);
+  }
+}
+@keyframes shakeX {
+  from,
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+
+  10%,
+  30%,
+  50%,
+  70%,
+  90% {
+    -webkit-transform: translate3d(-10px, 0, 0);
+    transform: translate3d(-10px, 0, 0);
+  }
+
+  20%,
+  40%,
+  60%,
+  80% {
+    -webkit-transform: translate3d(10px, 0, 0);
+    transform: translate3d(10px, 0, 0);
+  }
+}
+.animate__shakeX {
+  -webkit-animation-name: shakeX;
+  animation-name: shakeX;
+}
+@-webkit-keyframes shakeY {
+  from,
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+
+  10%,
+  30%,
+  50%,
+  70%,
+  90% {
+    -webkit-transform: translate3d(0, -10px, 0);
+    transform: translate3d(0, -10px, 0);
+  }
+
+  20%,
+  40%,
+  60%,
+  80% {
+    -webkit-transform: translate3d(0, 10px, 0);
+    transform: translate3d(0, 10px, 0);
+  }
+}
+@keyframes shakeY {
+  from,
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+
+  10%,
+  30%,
+  50%,
+  70%,
+  90% {
+    -webkit-transform: translate3d(0, -10px, 0);
+    transform: translate3d(0, -10px, 0);
+  }
+
+  20%,
+  40%,
+  60%,
+  80% {
+    -webkit-transform: translate3d(0, 10px, 0);
+    transform: translate3d(0, 10px, 0);
+  }
+}
+.animate__shakeY {
+  -webkit-animation-name: shakeY;
+  animation-name: shakeY;
+}
+@-webkit-keyframes headShake {
+  0% {
+    -webkit-transform: translateX(0);
+    transform: translateX(0);
+  }
+
+  6.5% {
+    -webkit-transform: translateX(-6px) rotateY(-9deg);
+    transform: translateX(-6px) rotateY(-9deg);
+  }
+
+  18.5% {
+    -webkit-transform: translateX(5px) rotateY(7deg);
+    transform: translateX(5px) rotateY(7deg);
+  }
+
+  31.5% {
+    -webkit-transform: translateX(-3px) rotateY(-5deg);
+    transform: translateX(-3px) rotateY(-5deg);
+  }
+
+  43.5% {
+    -webkit-transform: translateX(2px) rotateY(3deg);
+    transform: translateX(2px) rotateY(3deg);
+  }
+
+  50% {
+    -webkit-transform: translateX(0);
+    transform: translateX(0);
+  }
+}
+@keyframes headShake {
+  0% {
+    -webkit-transform: translateX(0);
+    transform: translateX(0);
+  }
+
+  6.5% {
+    -webkit-transform: translateX(-6px) rotateY(-9deg);
+    transform: translateX(-6px) rotateY(-9deg);
+  }
+
+  18.5% {
+    -webkit-transform: translateX(5px) rotateY(7deg);
+    transform: translateX(5px) rotateY(7deg);
+  }
+
+  31.5% {
+    -webkit-transform: translateX(-3px) rotateY(-5deg);
+    transform: translateX(-3px) rotateY(-5deg);
+  }
+
+  43.5% {
+    -webkit-transform: translateX(2px) rotateY(3deg);
+    transform: translateX(2px) rotateY(3deg);
+  }
+
+  50% {
+    -webkit-transform: translateX(0);
+    transform: translateX(0);
+  }
+}
+.animate__headShake {
+  -webkit-animation-timing-function: ease-in-out;
+  animation-timing-function: ease-in-out;
+  -webkit-animation-name: headShake;
+  animation-name: headShake;
+}
+@-webkit-keyframes swing {
+  20% {
+    -webkit-transform: rotate3d(0, 0, 1, 15deg);
+    transform: rotate3d(0, 0, 1, 15deg);
+  }
+
+  40% {
+    -webkit-transform: rotate3d(0, 0, 1, -10deg);
+    transform: rotate3d(0, 0, 1, -10deg);
+  }
+
+  60% {
+    -webkit-transform: rotate3d(0, 0, 1, 5deg);
+    transform: rotate3d(0, 0, 1, 5deg);
+  }
+
+  80% {
+    -webkit-transform: rotate3d(0, 0, 1, -5deg);
+    transform: rotate3d(0, 0, 1, -5deg);
+  }
+
+  to {
+    -webkit-transform: rotate3d(0, 0, 1, 0deg);
+    transform: rotate3d(0, 0, 1, 0deg);
+  }
+}
+@keyframes swing {
+  20% {
+    -webkit-transform: rotate3d(0, 0, 1, 15deg);
+    transform: rotate3d(0, 0, 1, 15deg);
+  }
+
+  40% {
+    -webkit-transform: rotate3d(0, 0, 1, -10deg);
+    transform: rotate3d(0, 0, 1, -10deg);
+  }
+
+  60% {
+    -webkit-transform: rotate3d(0, 0, 1, 5deg);
+    transform: rotate3d(0, 0, 1, 5deg);
+  }
+
+  80% {
+    -webkit-transform: rotate3d(0, 0, 1, -5deg);
+    transform: rotate3d(0, 0, 1, -5deg);
+  }
+
+  to {
+    -webkit-transform: rotate3d(0, 0, 1, 0deg);
+    transform: rotate3d(0, 0, 1, 0deg);
+  }
+}
+.animate__swing {
+  -webkit-transform-origin: top center;
+  transform-origin: top center;
+  -webkit-animation-name: swing;
+  animation-name: swing;
+}
+@-webkit-keyframes tada {
+  from {
+    -webkit-transform: scale3d(1, 1, 1);
+    transform: scale3d(1, 1, 1);
+  }
+
+  10%,
+  20% {
+    -webkit-transform: scale3d(0.9, 0.9, 0.9) rotate3d(0, 0, 1, -3deg);
+    transform: scale3d(0.9, 0.9, 0.9) rotate3d(0, 0, 1, -3deg);
+  }
+
+  30%,
+  50%,
+  70%,
+  90% {
+    -webkit-transform: scale3d(1.1, 1.1, 1.1) rotate3d(0, 0, 1, 3deg);
+    transform: scale3d(1.1, 1.1, 1.1) rotate3d(0, 0, 1, 3deg);
+  }
+
+  40%,
+  60%,
+  80% {
+    -webkit-transform: scale3d(1.1, 1.1, 1.1) rotate3d(0, 0, 1, -3deg);
+    transform: scale3d(1.1, 1.1, 1.1) rotate3d(0, 0, 1, -3deg);
+  }
+
+  to {
+    -webkit-transform: scale3d(1, 1, 1);
+    transform: scale3d(1, 1, 1);
+  }
+}
+@keyframes tada {
+  from {
+    -webkit-transform: scale3d(1, 1, 1);
+    transform: scale3d(1, 1, 1);
+  }
+
+  10%,
+  20% {
+    -webkit-transform: scale3d(0.9, 0.9, 0.9) rotate3d(0, 0, 1, -3deg);
+    transform: scale3d(0.9, 0.9, 0.9) rotate3d(0, 0, 1, -3deg);
+  }
+
+  30%,
+  50%,
+  70%,
+  90% {
+    -webkit-transform: scale3d(1.1, 1.1, 1.1) rotate3d(0, 0, 1, 3deg);
+    transform: scale3d(1.1, 1.1, 1.1) rotate3d(0, 0, 1, 3deg);
+  }
+
+  40%,
+  60%,
+  80% {
+    -webkit-transform: scale3d(1.1, 1.1, 1.1) rotate3d(0, 0, 1, -3deg);
+    transform: scale3d(1.1, 1.1, 1.1) rotate3d(0, 0, 1, -3deg);
+  }
+
+  to {
+    -webkit-transform: scale3d(1, 1, 1);
+    transform: scale3d(1, 1, 1);
+  }
+}
+.animate__tada {
+  -webkit-animation-name: tada;
+  animation-name: tada;
+}
+/* originally authored by Nick Pettit - https://github.com/nickpettit/glide */
+@-webkit-keyframes wobble {
+  from {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+
+  15% {
+    -webkit-transform: translate3d(-25%, 0, 0) rotate3d(0, 0, 1, -5deg);
+    transform: translate3d(-25%, 0, 0) rotate3d(0, 0, 1, -5deg);
+  }
+
+  30% {
+    -webkit-transform: translate3d(20%, 0, 0) rotate3d(0, 0, 1, 3deg);
+    transform: translate3d(20%, 0, 0) rotate3d(0, 0, 1, 3deg);
+  }
+
+  45% {
+    -webkit-transform: translate3d(-15%, 0, 0) rotate3d(0, 0, 1, -3deg);
+    transform: translate3d(-15%, 0, 0) rotate3d(0, 0, 1, -3deg);
+  }
+
+  60% {
+    -webkit-transform: translate3d(10%, 0, 0) rotate3d(0, 0, 1, 2deg);
+    transform: translate3d(10%, 0, 0) rotate3d(0, 0, 1, 2deg);
+  }
+
+  75% {
+    -webkit-transform: translate3d(-5%, 0, 0) rotate3d(0, 0, 1, -1deg);
+    transform: translate3d(-5%, 0, 0) rotate3d(0, 0, 1, -1deg);
+  }
+
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+@keyframes wobble {
+  from {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+
+  15% {
+    -webkit-transform: translate3d(-25%, 0, 0) rotate3d(0, 0, 1, -5deg);
+    transform: translate3d(-25%, 0, 0) rotate3d(0, 0, 1, -5deg);
+  }
+
+  30% {
+    -webkit-transform: translate3d(20%, 0, 0) rotate3d(0, 0, 1, 3deg);
+    transform: translate3d(20%, 0, 0) rotate3d(0, 0, 1, 3deg);
+  }
+
+  45% {
+    -webkit-transform: translate3d(-15%, 0, 0) rotate3d(0, 0, 1, -3deg);
+    transform: translate3d(-15%, 0, 0) rotate3d(0, 0, 1, -3deg);
+  }
+
+  60% {
+    -webkit-transform: translate3d(10%, 0, 0) rotate3d(0, 0, 1, 2deg);
+    transform: translate3d(10%, 0, 0) rotate3d(0, 0, 1, 2deg);
+  }
+
+  75% {
+    -webkit-transform: translate3d(-5%, 0, 0) rotate3d(0, 0, 1, -1deg);
+    transform: translate3d(-5%, 0, 0) rotate3d(0, 0, 1, -1deg);
+  }
+
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+.animate__wobble {
+  -webkit-animation-name: wobble;
+  animation-name: wobble;
+}
+@-webkit-keyframes jello {
+  from,
+  11.1%,
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+
+  22.2% {
+    -webkit-transform: skewX(-12.5deg) skewY(-12.5deg);
+    transform: skewX(-12.5deg) skewY(-12.5deg);
+  }
+
+  33.3% {
+    -webkit-transform: skewX(6.25deg) skewY(6.25deg);
+    transform: skewX(6.25deg) skewY(6.25deg);
+  }
+
+  44.4% {
+    -webkit-transform: skewX(-3.125deg) skewY(-3.125deg);
+    transform: skewX(-3.125deg) skewY(-3.125deg);
+  }
+
+  55.5% {
+    -webkit-transform: skewX(1.5625deg) skewY(1.5625deg);
+    transform: skewX(1.5625deg) skewY(1.5625deg);
+  }
+
+  66.6% {
+    -webkit-transform: skewX(-0.78125deg) skewY(-0.78125deg);
+    transform: skewX(-0.78125deg) skewY(-0.78125deg);
+  }
+
+  77.7% {
+    -webkit-transform: skewX(0.390625deg) skewY(0.390625deg);
+    transform: skewX(0.390625deg) skewY(0.390625deg);
+  }
+
+  88.8% {
+    -webkit-transform: skewX(-0.1953125deg) skewY(-0.1953125deg);
+    transform: skewX(-0.1953125deg) skewY(-0.1953125deg);
+  }
+}
+@keyframes jello {
+  from,
+  11.1%,
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+
+  22.2% {
+    -webkit-transform: skewX(-12.5deg) skewY(-12.5deg);
+    transform: skewX(-12.5deg) skewY(-12.5deg);
+  }
+
+  33.3% {
+    -webkit-transform: skewX(6.25deg) skewY(6.25deg);
+    transform: skewX(6.25deg) skewY(6.25deg);
+  }
+
+  44.4% {
+    -webkit-transform: skewX(-3.125deg) skewY(-3.125deg);
+    transform: skewX(-3.125deg) skewY(-3.125deg);
+  }
+
+  55.5% {
+    -webkit-transform: skewX(1.5625deg) skewY(1.5625deg);
+    transform: skewX(1.5625deg) skewY(1.5625deg);
+  }
+
+  66.6% {
+    -webkit-transform: skewX(-0.78125deg) skewY(-0.78125deg);
+    transform: skewX(-0.78125deg) skewY(-0.78125deg);
+  }
+
+  77.7% {
+    -webkit-transform: skewX(0.390625deg) skewY(0.390625deg);
+    transform: skewX(0.390625deg) skewY(0.390625deg);
+  }
+
+  88.8% {
+    -webkit-transform: skewX(-0.1953125deg) skewY(-0.1953125deg);
+    transform: skewX(-0.1953125deg) skewY(-0.1953125deg);
+  }
+}
+.animate__jello {
+  -webkit-animation-name: jello;
+  animation-name: jello;
+  -webkit-transform-origin: center;
+  transform-origin: center;
+}
+@-webkit-keyframes heartBeat {
+  0% {
+    -webkit-transform: scale(1);
+    transform: scale(1);
+  }
+
+  14% {
+    -webkit-transform: scale(1.3);
+    transform: scale(1.3);
+  }
+
+  28% {
+    -webkit-transform: scale(1);
+    transform: scale(1);
+  }
+
+  42% {
+    -webkit-transform: scale(1.3);
+    transform: scale(1.3);
+  }
+
+  70% {
+    -webkit-transform: scale(1);
+    transform: scale(1);
+  }
+}
+@keyframes heartBeat {
+  0% {
+    -webkit-transform: scale(1);
+    transform: scale(1);
+  }
+
+  14% {
+    -webkit-transform: scale(1.3);
+    transform: scale(1.3);
+  }
+
+  28% {
+    -webkit-transform: scale(1);
+    transform: scale(1);
+  }
+
+  42% {
+    -webkit-transform: scale(1.3);
+    transform: scale(1.3);
+  }
+
+  70% {
+    -webkit-transform: scale(1);
+    transform: scale(1);
+  }
+}
+.animate__heartBeat {
+  -webkit-animation-name: heartBeat;
+  animation-name: heartBeat;
+  -webkit-animation-duration: calc(1s * 1.3);
+  animation-duration: calc(1s * 1.3);
+  -webkit-animation-duration: calc(var(--animate-duration) * 1.3);
+  animation-duration: calc(var(--animate-duration) * 1.3);
+  -webkit-animation-timing-function: ease-in-out;
+  animation-timing-function: ease-in-out;
+}
+/* Back entrances */
+@-webkit-keyframes backInDown {
+  0% {
+    -webkit-transform: translateY(-1200px) scale(0.7);
+    transform: translateY(-1200px) scale(0.7);
+    opacity: 0.7;
+  }
+
+  80% {
+    -webkit-transform: translateY(0px) scale(0.7);
+    transform: translateY(0px) scale(0.7);
+    opacity: 0.7;
+  }
+
+  100% {
+    -webkit-transform: scale(1);
+    transform: scale(1);
+    opacity: 1;
+  }
+}
+@keyframes backInDown {
+  0% {
+    -webkit-transform: translateY(-1200px) scale(0.7);
+    transform: translateY(-1200px) scale(0.7);
+    opacity: 0.7;
+  }
+
+  80% {
+    -webkit-transform: translateY(0px) scale(0.7);
+    transform: translateY(0px) scale(0.7);
+    opacity: 0.7;
+  }
+
+  100% {
+    -webkit-transform: scale(1);
+    transform: scale(1);
+    opacity: 1;
+  }
+}
+.animate__backInDown {
+  -webkit-animation-name: backInDown;
+  animation-name: backInDown;
+}
+@-webkit-keyframes backInLeft {
+  0% {
+    -webkit-transform: translateX(-2000px) scale(0.7);
+    transform: translateX(-2000px) scale(0.7);
+    opacity: 0.7;
+  }
+
+  80% {
+    -webkit-transform: translateX(0px) scale(0.7);
+    transform: translateX(0px) scale(0.7);
+    opacity: 0.7;
+  }
+
+  100% {
+    -webkit-transform: scale(1);
+    transform: scale(1);
+    opacity: 1;
+  }
+}
+@keyframes backInLeft {
+  0% {
+    -webkit-transform: translateX(-2000px) scale(0.7);
+    transform: translateX(-2000px) scale(0.7);
+    opacity: 0.7;
+  }
+
+  80% {
+    -webkit-transform: translateX(0px) scale(0.7);
+    transform: translateX(0px) scale(0.7);
+    opacity: 0.7;
+  }
+
+  100% {
+    -webkit-transform: scale(1);
+    transform: scale(1);
+    opacity: 1;
+  }
+}
+.animate__backInLeft {
+  -webkit-animation-name: backInLeft;
+  animation-name: backInLeft;
+}
+@-webkit-keyframes backInRight {
+  0% {
+    -webkit-transform: translateX(2000px) scale(0.7);
+    transform: translateX(2000px) scale(0.7);
+    opacity: 0.7;
+  }
+
+  80% {
+    -webkit-transform: translateX(0px) scale(0.7);
+    transform: translateX(0px) scale(0.7);
+    opacity: 0.7;
+  }
+
+  100% {
+    -webkit-transform: scale(1);
+    transform: scale(1);
+    opacity: 1;
+  }
+}
+@keyframes backInRight {
+  0% {
+    -webkit-transform: translateX(2000px) scale(0.7);
+    transform: translateX(2000px) scale(0.7);
+    opacity: 0.7;
+  }
+
+  80% {
+    -webkit-transform: translateX(0px) scale(0.7);
+    transform: translateX(0px) scale(0.7);
+    opacity: 0.7;
+  }
+
+  100% {
+    -webkit-transform: scale(1);
+    transform: scale(1);
+    opacity: 1;
+  }
+}
+.animate__backInRight {
+  -webkit-animation-name: backInRight;
+  animation-name: backInRight;
+}
+@-webkit-keyframes backInUp {
+  0% {
+    -webkit-transform: translateY(1200px) scale(0.7);
+    transform: translateY(1200px) scale(0.7);
+    opacity: 0.7;
+  }
+
+  80% {
+    -webkit-transform: translateY(0px) scale(0.7);
+    transform: translateY(0px) scale(0.7);
+    opacity: 0.7;
+  }
+
+  100% {
+    -webkit-transform: scale(1);
+    transform: scale(1);
+    opacity: 1;
+  }
+}
+@keyframes backInUp {
+  0% {
+    -webkit-transform: translateY(1200px) scale(0.7);
+    transform: translateY(1200px) scale(0.7);
+    opacity: 0.7;
+  }
+
+  80% {
+    -webkit-transform: translateY(0px) scale(0.7);
+    transform: translateY(0px) scale(0.7);
+    opacity: 0.7;
+  }
+
+  100% {
+    -webkit-transform: scale(1);
+    transform: scale(1);
+    opacity: 1;
+  }
+}
+.animate__backInUp {
+  -webkit-animation-name: backInUp;
+  animation-name: backInUp;
+}
+/* Back exits */
+@-webkit-keyframes backOutDown {
+  0% {
+    -webkit-transform: scale(1);
+    transform: scale(1);
+    opacity: 1;
+  }
+
+  20% {
+    -webkit-transform: translateY(0px) scale(0.7);
+    transform: translateY(0px) scale(0.7);
+    opacity: 0.7;
+  }
+
+  100% {
+    -webkit-transform: translateY(700px) scale(0.7);
+    transform: translateY(700px) scale(0.7);
+    opacity: 0.7;
+  }
+}
+@keyframes backOutDown {
+  0% {
+    -webkit-transform: scale(1);
+    transform: scale(1);
+    opacity: 1;
+  }
+
+  20% {
+    -webkit-transform: translateY(0px) scale(0.7);
+    transform: translateY(0px) scale(0.7);
+    opacity: 0.7;
+  }
+
+  100% {
+    -webkit-transform: translateY(700px) scale(0.7);
+    transform: translateY(700px) scale(0.7);
+    opacity: 0.7;
+  }
+}
+.animate__backOutDown {
+  -webkit-animation-name: backOutDown;
+  animation-name: backOutDown;
+}
+@-webkit-keyframes backOutLeft {
+  0% {
+    -webkit-transform: scale(1);
+    transform: scale(1);
+    opacity: 1;
+  }
+
+  20% {
+    -webkit-transform: translateX(0px) scale(0.7);
+    transform: translateX(0px) scale(0.7);
+    opacity: 0.7;
+  }
+
+  100% {
+    -webkit-transform: translateX(-2000px) scale(0.7);
+    transform: translateX(-2000px) scale(0.7);
+    opacity: 0.7;
+  }
+}
+@keyframes backOutLeft {
+  0% {
+    -webkit-transform: scale(1);
+    transform: scale(1);
+    opacity: 1;
+  }
+
+  20% {
+    -webkit-transform: translateX(0px) scale(0.7);
+    transform: translateX(0px) scale(0.7);
+    opacity: 0.7;
+  }
+
+  100% {
+    -webkit-transform: translateX(-2000px) scale(0.7);
+    transform: translateX(-2000px) scale(0.7);
+    opacity: 0.7;
+  }
+}
+.animate__backOutLeft {
+  -webkit-animation-name: backOutLeft;
+  animation-name: backOutLeft;
+}
+@-webkit-keyframes backOutRight {
+  0% {
+    -webkit-transform: scale(1);
+    transform: scale(1);
+    opacity: 1;
+  }
+
+  20% {
+    -webkit-transform: translateX(0px) scale(0.7);
+    transform: translateX(0px) scale(0.7);
+    opacity: 0.7;
+  }
+
+  100% {
+    -webkit-transform: translateX(2000px) scale(0.7);
+    transform: translateX(2000px) scale(0.7);
+    opacity: 0.7;
+  }
+}
+@keyframes backOutRight {
+  0% {
+    -webkit-transform: scale(1);
+    transform: scale(1);
+    opacity: 1;
+  }
+
+  20% {
+    -webkit-transform: translateX(0px) scale(0.7);
+    transform: translateX(0px) scale(0.7);
+    opacity: 0.7;
+  }
+
+  100% {
+    -webkit-transform: translateX(2000px) scale(0.7);
+    transform: translateX(2000px) scale(0.7);
+    opacity: 0.7;
+  }
+}
+.animate__backOutRight {
+  -webkit-animation-name: backOutRight;
+  animation-name: backOutRight;
+}
+@-webkit-keyframes backOutUp {
+  0% {
+    -webkit-transform: scale(1);
+    transform: scale(1);
+    opacity: 1;
+  }
+
+  20% {
+    -webkit-transform: translateY(0px) scale(0.7);
+    transform: translateY(0px) scale(0.7);
+    opacity: 0.7;
+  }
+
+  100% {
+    -webkit-transform: translateY(-700px) scale(0.7);
+    transform: translateY(-700px) scale(0.7);
+    opacity: 0.7;
+  }
+}
+@keyframes backOutUp {
+  0% {
+    -webkit-transform: scale(1);
+    transform: scale(1);
+    opacity: 1;
+  }
+
+  20% {
+    -webkit-transform: translateY(0px) scale(0.7);
+    transform: translateY(0px) scale(0.7);
+    opacity: 0.7;
+  }
+
+  100% {
+    -webkit-transform: translateY(-700px) scale(0.7);
+    transform: translateY(-700px) scale(0.7);
+    opacity: 0.7;
+  }
+}
+.animate__backOutUp {
+  -webkit-animation-name: backOutUp;
+  animation-name: backOutUp;
+}
+/* Bouncing entrances  */
+@-webkit-keyframes bounceIn {
+  from,
+  20%,
+  40%,
+  60%,
+  80%,
+  to {
+    -webkit-animation-timing-function: cubic-bezier(0.215, 0.61, 0.355, 1);
+    animation-timing-function: cubic-bezier(0.215, 0.61, 0.355, 1);
+  }
+
+  0% {
+    opacity: 0;
+    -webkit-transform: scale3d(0.3, 0.3, 0.3);
+    transform: scale3d(0.3, 0.3, 0.3);
+  }
+
+  20% {
+    -webkit-transform: scale3d(1.1, 1.1, 1.1);
+    transform: scale3d(1.1, 1.1, 1.1);
+  }
+
+  40% {
+    -webkit-transform: scale3d(0.9, 0.9, 0.9);
+    transform: scale3d(0.9, 0.9, 0.9);
+  }
+
+  60% {
+    opacity: 1;
+    -webkit-transform: scale3d(1.03, 1.03, 1.03);
+    transform: scale3d(1.03, 1.03, 1.03);
+  }
+
+  80% {
+    -webkit-transform: scale3d(0.97, 0.97, 0.97);
+    transform: scale3d(0.97, 0.97, 0.97);
+  }
+
+  to {
+    opacity: 1;
+    -webkit-transform: scale3d(1, 1, 1);
+    transform: scale3d(1, 1, 1);
+  }
+}
+@keyframes bounceIn {
+  from,
+  20%,
+  40%,
+  60%,
+  80%,
+  to {
+    -webkit-animation-timing-function: cubic-bezier(0.215, 0.61, 0.355, 1);
+    animation-timing-function: cubic-bezier(0.215, 0.61, 0.355, 1);
+  }
+
+  0% {
+    opacity: 0;
+    -webkit-transform: scale3d(0.3, 0.3, 0.3);
+    transform: scale3d(0.3, 0.3, 0.3);
+  }
+
+  20% {
+    -webkit-transform: scale3d(1.1, 1.1, 1.1);
+    transform: scale3d(1.1, 1.1, 1.1);
+  }
+
+  40% {
+    -webkit-transform: scale3d(0.9, 0.9, 0.9);
+    transform: scale3d(0.9, 0.9, 0.9);
+  }
+
+  60% {
+    opacity: 1;
+    -webkit-transform: scale3d(1.03, 1.03, 1.03);
+    transform: scale3d(1.03, 1.03, 1.03);
+  }
+
+  80% {
+    -webkit-transform: scale3d(0.97, 0.97, 0.97);
+    transform: scale3d(0.97, 0.97, 0.97);
+  }
+
+  to {
+    opacity: 1;
+    -webkit-transform: scale3d(1, 1, 1);
+    transform: scale3d(1, 1, 1);
+  }
+}
+.animate__bounceIn {
+  -webkit-animation-duration: calc(1s * 0.75);
+  animation-duration: calc(1s * 0.75);
+  -webkit-animation-duration: calc(var(--animate-duration) * 0.75);
+  animation-duration: calc(var(--animate-duration) * 0.75);
+  -webkit-animation-name: bounceIn;
+  animation-name: bounceIn;
+}
+@-webkit-keyframes bounceInDown {
+  from,
+  60%,
+  75%,
+  90%,
+  to {
+    -webkit-animation-timing-function: cubic-bezier(0.215, 0.61, 0.355, 1);
+    animation-timing-function: cubic-bezier(0.215, 0.61, 0.355, 1);
+  }
+
+  0% {
+    opacity: 0;
+    -webkit-transform: translate3d(0, -3000px, 0) scaleY(3);
+    transform: translate3d(0, -3000px, 0) scaleY(3);
+  }
+
+  60% {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 25px, 0) scaleY(0.9);
+    transform: translate3d(0, 25px, 0) scaleY(0.9);
+  }
+
+  75% {
+    -webkit-transform: translate3d(0, -10px, 0) scaleY(0.95);
+    transform: translate3d(0, -10px, 0) scaleY(0.95);
+  }
+
+  90% {
+    -webkit-transform: translate3d(0, 5px, 0) scaleY(0.985);
+    transform: translate3d(0, 5px, 0) scaleY(0.985);
+  }
+
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+@keyframes bounceInDown {
+  from,
+  60%,
+  75%,
+  90%,
+  to {
+    -webkit-animation-timing-function: cubic-bezier(0.215, 0.61, 0.355, 1);
+    animation-timing-function: cubic-bezier(0.215, 0.61, 0.355, 1);
+  }
+
+  0% {
+    opacity: 0;
+    -webkit-transform: translate3d(0, -3000px, 0) scaleY(3);
+    transform: translate3d(0, -3000px, 0) scaleY(3);
+  }
+
+  60% {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 25px, 0) scaleY(0.9);
+    transform: translate3d(0, 25px, 0) scaleY(0.9);
+  }
+
+  75% {
+    -webkit-transform: translate3d(0, -10px, 0) scaleY(0.95);
+    transform: translate3d(0, -10px, 0) scaleY(0.95);
+  }
+
+  90% {
+    -webkit-transform: translate3d(0, 5px, 0) scaleY(0.985);
+    transform: translate3d(0, 5px, 0) scaleY(0.985);
+  }
+
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+.animate__bounceInDown {
+  -webkit-animation-name: bounceInDown;
+  animation-name: bounceInDown;
+}
+@-webkit-keyframes bounceInLeft {
+  from,
+  60%,
+  75%,
+  90%,
+  to {
+    -webkit-animation-timing-function: cubic-bezier(0.215, 0.61, 0.355, 1);
+    animation-timing-function: cubic-bezier(0.215, 0.61, 0.355, 1);
+  }
+
+  0% {
+    opacity: 0;
+    -webkit-transform: translate3d(-3000px, 0, 0) scaleX(3);
+    transform: translate3d(-3000px, 0, 0) scaleX(3);
+  }
+
+  60% {
+    opacity: 1;
+    -webkit-transform: translate3d(25px, 0, 0) scaleX(1);
+    transform: translate3d(25px, 0, 0) scaleX(1);
+  }
+
+  75% {
+    -webkit-transform: translate3d(-10px, 0, 0) scaleX(0.98);
+    transform: translate3d(-10px, 0, 0) scaleX(0.98);
+  }
+
+  90% {
+    -webkit-transform: translate3d(5px, 0, 0) scaleX(0.995);
+    transform: translate3d(5px, 0, 0) scaleX(0.995);
+  }
+
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+@keyframes bounceInLeft {
+  from,
+  60%,
+  75%,
+  90%,
+  to {
+    -webkit-animation-timing-function: cubic-bezier(0.215, 0.61, 0.355, 1);
+    animation-timing-function: cubic-bezier(0.215, 0.61, 0.355, 1);
+  }
+
+  0% {
+    opacity: 0;
+    -webkit-transform: translate3d(-3000px, 0, 0) scaleX(3);
+    transform: translate3d(-3000px, 0, 0) scaleX(3);
+  }
+
+  60% {
+    opacity: 1;
+    -webkit-transform: translate3d(25px, 0, 0) scaleX(1);
+    transform: translate3d(25px, 0, 0) scaleX(1);
+  }
+
+  75% {
+    -webkit-transform: translate3d(-10px, 0, 0) scaleX(0.98);
+    transform: translate3d(-10px, 0, 0) scaleX(0.98);
+  }
+
+  90% {
+    -webkit-transform: translate3d(5px, 0, 0) scaleX(0.995);
+    transform: translate3d(5px, 0, 0) scaleX(0.995);
+  }
+
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+.animate__bounceInLeft {
+  -webkit-animation-name: bounceInLeft;
+  animation-name: bounceInLeft;
+}
+@-webkit-keyframes bounceInRight {
+  from,
+  60%,
+  75%,
+  90%,
+  to {
+    -webkit-animation-timing-function: cubic-bezier(0.215, 0.61, 0.355, 1);
+    animation-timing-function: cubic-bezier(0.215, 0.61, 0.355, 1);
+  }
+
+  from {
+    opacity: 0;
+    -webkit-transform: translate3d(3000px, 0, 0) scaleX(3);
+    transform: translate3d(3000px, 0, 0) scaleX(3);
+  }
+
+  60% {
+    opacity: 1;
+    -webkit-transform: translate3d(-25px, 0, 0) scaleX(1);
+    transform: translate3d(-25px, 0, 0) scaleX(1);
+  }
+
+  75% {
+    -webkit-transform: translate3d(10px, 0, 0) scaleX(0.98);
+    transform: translate3d(10px, 0, 0) scaleX(0.98);
+  }
+
+  90% {
+    -webkit-transform: translate3d(-5px, 0, 0) scaleX(0.995);
+    transform: translate3d(-5px, 0, 0) scaleX(0.995);
+  }
+
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+@keyframes bounceInRight {
+  from,
+  60%,
+  75%,
+  90%,
+  to {
+    -webkit-animation-timing-function: cubic-bezier(0.215, 0.61, 0.355, 1);
+    animation-timing-function: cubic-bezier(0.215, 0.61, 0.355, 1);
+  }
+
+  from {
+    opacity: 0;
+    -webkit-transform: translate3d(3000px, 0, 0) scaleX(3);
+    transform: translate3d(3000px, 0, 0) scaleX(3);
+  }
+
+  60% {
+    opacity: 1;
+    -webkit-transform: translate3d(-25px, 0, 0) scaleX(1);
+    transform: translate3d(-25px, 0, 0) scaleX(1);
+  }
+
+  75% {
+    -webkit-transform: translate3d(10px, 0, 0) scaleX(0.98);
+    transform: translate3d(10px, 0, 0) scaleX(0.98);
+  }
+
+  90% {
+    -webkit-transform: translate3d(-5px, 0, 0) scaleX(0.995);
+    transform: translate3d(-5px, 0, 0) scaleX(0.995);
+  }
+
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+.animate__bounceInRight {
+  -webkit-animation-name: bounceInRight;
+  animation-name: bounceInRight;
+}
+@-webkit-keyframes bounceInUp {
+  from,
+  60%,
+  75%,
+  90%,
+  to {
+    -webkit-animation-timing-function: cubic-bezier(0.215, 0.61, 0.355, 1);
+    animation-timing-function: cubic-bezier(0.215, 0.61, 0.355, 1);
+  }
+
+  from {
+    opacity: 0;
+    -webkit-transform: translate3d(0, 3000px, 0) scaleY(5);
+    transform: translate3d(0, 3000px, 0) scaleY(5);
+  }
+
+  60% {
+    opacity: 1;
+    -webkit-transform: translate3d(0, -20px, 0) scaleY(0.9);
+    transform: translate3d(0, -20px, 0) scaleY(0.9);
+  }
+
+  75% {
+    -webkit-transform: translate3d(0, 10px, 0) scaleY(0.95);
+    transform: translate3d(0, 10px, 0) scaleY(0.95);
+  }
+
+  90% {
+    -webkit-transform: translate3d(0, -5px, 0) scaleY(0.985);
+    transform: translate3d(0, -5px, 0) scaleY(0.985);
+  }
+
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+@keyframes bounceInUp {
+  from,
+  60%,
+  75%,
+  90%,
+  to {
+    -webkit-animation-timing-function: cubic-bezier(0.215, 0.61, 0.355, 1);
+    animation-timing-function: cubic-bezier(0.215, 0.61, 0.355, 1);
+  }
+
+  from {
+    opacity: 0;
+    -webkit-transform: translate3d(0, 3000px, 0) scaleY(5);
+    transform: translate3d(0, 3000px, 0) scaleY(5);
+  }
+
+  60% {
+    opacity: 1;
+    -webkit-transform: translate3d(0, -20px, 0) scaleY(0.9);
+    transform: translate3d(0, -20px, 0) scaleY(0.9);
+  }
+
+  75% {
+    -webkit-transform: translate3d(0, 10px, 0) scaleY(0.95);
+    transform: translate3d(0, 10px, 0) scaleY(0.95);
+  }
+
+  90% {
+    -webkit-transform: translate3d(0, -5px, 0) scaleY(0.985);
+    transform: translate3d(0, -5px, 0) scaleY(0.985);
+  }
+
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+.animate__bounceInUp {
+  -webkit-animation-name: bounceInUp;
+  animation-name: bounceInUp;
+}
+/* Bouncing exits  */
+@-webkit-keyframes bounceOut {
+  20% {
+    -webkit-transform: scale3d(0.9, 0.9, 0.9);
+    transform: scale3d(0.9, 0.9, 0.9);
+  }
+
+  50%,
+  55% {
+    opacity: 1;
+    -webkit-transform: scale3d(1.1, 1.1, 1.1);
+    transform: scale3d(1.1, 1.1, 1.1);
+  }
+
+  to {
+    opacity: 0;
+    -webkit-transform: scale3d(0.3, 0.3, 0.3);
+    transform: scale3d(0.3, 0.3, 0.3);
+  }
+}
+@keyframes bounceOut {
+  20% {
+    -webkit-transform: scale3d(0.9, 0.9, 0.9);
+    transform: scale3d(0.9, 0.9, 0.9);
+  }
+
+  50%,
+  55% {
+    opacity: 1;
+    -webkit-transform: scale3d(1.1, 1.1, 1.1);
+    transform: scale3d(1.1, 1.1, 1.1);
+  }
+
+  to {
+    opacity: 0;
+    -webkit-transform: scale3d(0.3, 0.3, 0.3);
+    transform: scale3d(0.3, 0.3, 0.3);
+  }
+}
+.animate__bounceOut {
+  -webkit-animation-duration: calc(1s * 0.75);
+  animation-duration: calc(1s * 0.75);
+  -webkit-animation-duration: calc(var(--animate-duration) * 0.75);
+  animation-duration: calc(var(--animate-duration) * 0.75);
+  -webkit-animation-name: bounceOut;
+  animation-name: bounceOut;
+}
+@-webkit-keyframes bounceOutDown {
+  20% {
+    -webkit-transform: translate3d(0, 10px, 0) scaleY(0.985);
+    transform: translate3d(0, 10px, 0) scaleY(0.985);
+  }
+
+  40%,
+  45% {
+    opacity: 1;
+    -webkit-transform: translate3d(0, -20px, 0) scaleY(0.9);
+    transform: translate3d(0, -20px, 0) scaleY(0.9);
+  }
+
+  to {
+    opacity: 0;
+    -webkit-transform: translate3d(0, 2000px, 0) scaleY(3);
+    transform: translate3d(0, 2000px, 0) scaleY(3);
+  }
+}
+@keyframes bounceOutDown {
+  20% {
+    -webkit-transform: translate3d(0, 10px, 0) scaleY(0.985);
+    transform: translate3d(0, 10px, 0) scaleY(0.985);
+  }
+
+  40%,
+  45% {
+    opacity: 1;
+    -webkit-transform: translate3d(0, -20px, 0) scaleY(0.9);
+    transform: translate3d(0, -20px, 0) scaleY(0.9);
+  }
+
+  to {
+    opacity: 0;
+    -webkit-transform: translate3d(0, 2000px, 0) scaleY(3);
+    transform: translate3d(0, 2000px, 0) scaleY(3);
+  }
+}
+.animate__bounceOutDown {
+  -webkit-animation-name: bounceOutDown;
+  animation-name: bounceOutDown;
+}
+@-webkit-keyframes bounceOutLeft {
+  20% {
+    opacity: 1;
+    -webkit-transform: translate3d(20px, 0, 0) scaleX(0.9);
+    transform: translate3d(20px, 0, 0) scaleX(0.9);
+  }
+
+  to {
+    opacity: 0;
+    -webkit-transform: translate3d(-2000px, 0, 0) scaleX(2);
+    transform: translate3d(-2000px, 0, 0) scaleX(2);
+  }
+}
+@keyframes bounceOutLeft {
+  20% {
+    opacity: 1;
+    -webkit-transform: translate3d(20px, 0, 0) scaleX(0.9);
+    transform: translate3d(20px, 0, 0) scaleX(0.9);
+  }
+
+  to {
+    opacity: 0;
+    -webkit-transform: translate3d(-2000px, 0, 0) scaleX(2);
+    transform: translate3d(-2000px, 0, 0) scaleX(2);
+  }
+}
+.animate__bounceOutLeft {
+  -webkit-animation-name: bounceOutLeft;
+  animation-name: bounceOutLeft;
+}
+@-webkit-keyframes bounceOutRight {
+  20% {
+    opacity: 1;
+    -webkit-transform: translate3d(-20px, 0, 0) scaleX(0.9);
+    transform: translate3d(-20px, 0, 0) scaleX(0.9);
+  }
+
+  to {
+    opacity: 0;
+    -webkit-transform: translate3d(2000px, 0, 0) scaleX(2);
+    transform: translate3d(2000px, 0, 0) scaleX(2);
+  }
+}
+@keyframes bounceOutRight {
+  20% {
+    opacity: 1;
+    -webkit-transform: translate3d(-20px, 0, 0) scaleX(0.9);
+    transform: translate3d(-20px, 0, 0) scaleX(0.9);
+  }
+
+  to {
+    opacity: 0;
+    -webkit-transform: translate3d(2000px, 0, 0) scaleX(2);
+    transform: translate3d(2000px, 0, 0) scaleX(2);
+  }
+}
+.animate__bounceOutRight {
+  -webkit-animation-name: bounceOutRight;
+  animation-name: bounceOutRight;
+}
+@-webkit-keyframes bounceOutUp {
+  20% {
+    -webkit-transform: translate3d(0, -10px, 0) scaleY(0.985);
+    transform: translate3d(0, -10px, 0) scaleY(0.985);
+  }
+
+  40%,
+  45% {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 20px, 0) scaleY(0.9);
+    transform: translate3d(0, 20px, 0) scaleY(0.9);
+  }
+
+  to {
+    opacity: 0;
+    -webkit-transform: translate3d(0, -2000px, 0) scaleY(3);
+    transform: translate3d(0, -2000px, 0) scaleY(3);
+  }
+}
+@keyframes bounceOutUp {
+  20% {
+    -webkit-transform: translate3d(0, -10px, 0) scaleY(0.985);
+    transform: translate3d(0, -10px, 0) scaleY(0.985);
+  }
+
+  40%,
+  45% {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 20px, 0) scaleY(0.9);
+    transform: translate3d(0, 20px, 0) scaleY(0.9);
+  }
+
+  to {
+    opacity: 0;
+    -webkit-transform: translate3d(0, -2000px, 0) scaleY(3);
+    transform: translate3d(0, -2000px, 0) scaleY(3);
+  }
+}
+.animate__bounceOutUp {
+  -webkit-animation-name: bounceOutUp;
+  animation-name: bounceOutUp;
+}
+/* Fading entrances  */
+@-webkit-keyframes fadeIn {
+  from {
+    opacity: 0;
+  }
+
+  to {
+    opacity: 1;
+  }
+}
+@keyframes fadeIn {
+  from {
+    opacity: 0;
+  }
+
+  to {
+    opacity: 1;
+  }
+}
+.animate__fadeIn {
+  -webkit-animation-name: fadeIn;
+  animation-name: fadeIn;
+}
+@-webkit-keyframes fadeInDown {
+  from {
+    opacity: 0;
+    -webkit-transform: translate3d(0, -100%, 0);
+    transform: translate3d(0, -100%, 0);
+  }
+
+  to {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+@keyframes fadeInDown {
+  from {
+    opacity: 0;
+    -webkit-transform: translate3d(0, -100%, 0);
+    transform: translate3d(0, -100%, 0);
+  }
+
+  to {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+.animate__fadeInDown {
+  -webkit-animation-name: fadeInDown;
+  animation-name: fadeInDown;
+}
+@-webkit-keyframes fadeInDownBig {
+  from {
+    opacity: 0;
+    -webkit-transform: translate3d(0, -2000px, 0);
+    transform: translate3d(0, -2000px, 0);
+  }
+
+  to {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+@keyframes fadeInDownBig {
+  from {
+    opacity: 0;
+    -webkit-transform: translate3d(0, -2000px, 0);
+    transform: translate3d(0, -2000px, 0);
+  }
+
+  to {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+.animate__fadeInDownBig {
+  -webkit-animation-name: fadeInDownBig;
+  animation-name: fadeInDownBig;
+}
+@-webkit-keyframes fadeInLeft {
+  from {
+    opacity: 0;
+    -webkit-transform: translate3d(-100%, 0, 0);
+    transform: translate3d(-100%, 0, 0);
+  }
+
+  to {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+@keyframes fadeInLeft {
+  from {
+    opacity: 0;
+    -webkit-transform: translate3d(-100%, 0, 0);
+    transform: translate3d(-100%, 0, 0);
+  }
+
+  to {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+.animate__fadeInLeft {
+  -webkit-animation-name: fadeInLeft;
+  animation-name: fadeInLeft;
+}
+@-webkit-keyframes fadeInLeftBig {
+  from {
+    opacity: 0;
+    -webkit-transform: translate3d(-2000px, 0, 0);
+    transform: translate3d(-2000px, 0, 0);
+  }
+
+  to {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+@keyframes fadeInLeftBig {
+  from {
+    opacity: 0;
+    -webkit-transform: translate3d(-2000px, 0, 0);
+    transform: translate3d(-2000px, 0, 0);
+  }
+
+  to {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+.animate__fadeInLeftBig {
+  -webkit-animation-name: fadeInLeftBig;
+  animation-name: fadeInLeftBig;
+}
+@-webkit-keyframes fadeInRight {
+  from {
+    opacity: 0;
+    -webkit-transform: translate3d(100%, 0, 0);
+    transform: translate3d(100%, 0, 0);
+  }
+
+  to {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+@keyframes fadeInRight {
+  from {
+    opacity: 0;
+    -webkit-transform: translate3d(100%, 0, 0);
+    transform: translate3d(100%, 0, 0);
+  }
+
+  to {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+.animate__fadeInRight {
+  -webkit-animation-name: fadeInRight;
+  animation-name: fadeInRight;
+}
+@-webkit-keyframes fadeInRightBig {
+  from {
+    opacity: 0;
+    -webkit-transform: translate3d(2000px, 0, 0);
+    transform: translate3d(2000px, 0, 0);
+  }
+
+  to {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+@keyframes fadeInRightBig {
+  from {
+    opacity: 0;
+    -webkit-transform: translate3d(2000px, 0, 0);
+    transform: translate3d(2000px, 0, 0);
+  }
+
+  to {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+.animate__fadeInRightBig {
+  -webkit-animation-name: fadeInRightBig;
+  animation-name: fadeInRightBig;
+}
+@-webkit-keyframes fadeInUp {
+  from {
+    opacity: 0;
+    -webkit-transform: translate3d(0, 100%, 0);
+    transform: translate3d(0, 100%, 0);
+  }
+
+  to {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+@keyframes fadeInUp {
+  from {
+    opacity: 0;
+    -webkit-transform: translate3d(0, 100%, 0);
+    transform: translate3d(0, 100%, 0);
+  }
+
+  to {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+.animate__fadeInUp {
+  -webkit-animation-name: fadeInUp;
+  animation-name: fadeInUp;
+}
+@-webkit-keyframes fadeInUpBig {
+  from {
+    opacity: 0;
+    -webkit-transform: translate3d(0, 2000px, 0);
+    transform: translate3d(0, 2000px, 0);
+  }
+
+  to {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+@keyframes fadeInUpBig {
+  from {
+    opacity: 0;
+    -webkit-transform: translate3d(0, 2000px, 0);
+    transform: translate3d(0, 2000px, 0);
+  }
+
+  to {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+.animate__fadeInUpBig {
+  -webkit-animation-name: fadeInUpBig;
+  animation-name: fadeInUpBig;
+}
+@-webkit-keyframes fadeInTopLeft {
+  from {
+    opacity: 0;
+    -webkit-transform: translate3d(-100%, -100%, 0);
+    transform: translate3d(-100%, -100%, 0);
+  }
+  to {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+@keyframes fadeInTopLeft {
+  from {
+    opacity: 0;
+    -webkit-transform: translate3d(-100%, -100%, 0);
+    transform: translate3d(-100%, -100%, 0);
+  }
+  to {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+.animate__fadeInTopLeft {
+  -webkit-animation-name: fadeInTopLeft;
+  animation-name: fadeInTopLeft;
+}
+@-webkit-keyframes fadeInTopRight {
+  from {
+    opacity: 0;
+    -webkit-transform: translate3d(100%, -100%, 0);
+    transform: translate3d(100%, -100%, 0);
+  }
+  to {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+@keyframes fadeInTopRight {
+  from {
+    opacity: 0;
+    -webkit-transform: translate3d(100%, -100%, 0);
+    transform: translate3d(100%, -100%, 0);
+  }
+  to {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+.animate__fadeInTopRight {
+  -webkit-animation-name: fadeInTopRight;
+  animation-name: fadeInTopRight;
+}
+@-webkit-keyframes fadeInBottomLeft {
+  from {
+    opacity: 0;
+    -webkit-transform: translate3d(-100%, 100%, 0);
+    transform: translate3d(-100%, 100%, 0);
+  }
+  to {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+@keyframes fadeInBottomLeft {
+  from {
+    opacity: 0;
+    -webkit-transform: translate3d(-100%, 100%, 0);
+    transform: translate3d(-100%, 100%, 0);
+  }
+  to {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+.animate__fadeInBottomLeft {
+  -webkit-animation-name: fadeInBottomLeft;
+  animation-name: fadeInBottomLeft;
+}
+@-webkit-keyframes fadeInBottomRight {
+  from {
+    opacity: 0;
+    -webkit-transform: translate3d(100%, 100%, 0);
+    transform: translate3d(100%, 100%, 0);
+  }
+  to {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+@keyframes fadeInBottomRight {
+  from {
+    opacity: 0;
+    -webkit-transform: translate3d(100%, 100%, 0);
+    transform: translate3d(100%, 100%, 0);
+  }
+  to {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+.animate__fadeInBottomRight {
+  -webkit-animation-name: fadeInBottomRight;
+  animation-name: fadeInBottomRight;
+}
+/* Fading exits */
+@-webkit-keyframes fadeOut {
+  from {
+    opacity: 1;
+  }
+
+  to {
+    opacity: 0;
+  }
+}
+@keyframes fadeOut {
+  from {
+    opacity: 1;
+  }
+
+  to {
+    opacity: 0;
+  }
+}
+.animate__fadeOut {
+  -webkit-animation-name: fadeOut;
+  animation-name: fadeOut;
+}
+@-webkit-keyframes fadeOutDown {
+  from {
+    opacity: 1;
+  }
+
+  to {
+    opacity: 0;
+    -webkit-transform: translate3d(0, 100%, 0);
+    transform: translate3d(0, 100%, 0);
+  }
+}
+@keyframes fadeOutDown {
+  from {
+    opacity: 1;
+  }
+
+  to {
+    opacity: 0;
+    -webkit-transform: translate3d(0, 100%, 0);
+    transform: translate3d(0, 100%, 0);
+  }
+}
+.animate__fadeOutDown {
+  -webkit-animation-name: fadeOutDown;
+  animation-name: fadeOutDown;
+}
+@-webkit-keyframes fadeOutDownBig {
+  from {
+    opacity: 1;
+  }
+
+  to {
+    opacity: 0;
+    -webkit-transform: translate3d(0, 2000px, 0);
+    transform: translate3d(0, 2000px, 0);
+  }
+}
+@keyframes fadeOutDownBig {
+  from {
+    opacity: 1;
+  }
+
+  to {
+    opacity: 0;
+    -webkit-transform: translate3d(0, 2000px, 0);
+    transform: translate3d(0, 2000px, 0);
+  }
+}
+.animate__fadeOutDownBig {
+  -webkit-animation-name: fadeOutDownBig;
+  animation-name: fadeOutDownBig;
+}
+@-webkit-keyframes fadeOutLeft {
+  from {
+    opacity: 1;
+  }
+
+  to {
+    opacity: 0;
+    -webkit-transform: translate3d(-100%, 0, 0);
+    transform: translate3d(-100%, 0, 0);
+  }
+}
+@keyframes fadeOutLeft {
+  from {
+    opacity: 1;
+  }
+
+  to {
+    opacity: 0;
+    -webkit-transform: translate3d(-100%, 0, 0);
+    transform: translate3d(-100%, 0, 0);
+  }
+}
+.animate__fadeOutLeft {
+  -webkit-animation-name: fadeOutLeft;
+  animation-name: fadeOutLeft;
+}
+@-webkit-keyframes fadeOutLeftBig {
+  from {
+    opacity: 1;
+  }
+
+  to {
+    opacity: 0;
+    -webkit-transform: translate3d(-2000px, 0, 0);
+    transform: translate3d(-2000px, 0, 0);
+  }
+}
+@keyframes fadeOutLeftBig {
+  from {
+    opacity: 1;
+  }
+
+  to {
+    opacity: 0;
+    -webkit-transform: translate3d(-2000px, 0, 0);
+    transform: translate3d(-2000px, 0, 0);
+  }
+}
+.animate__fadeOutLeftBig {
+  -webkit-animation-name: fadeOutLeftBig;
+  animation-name: fadeOutLeftBig;
+}
+@-webkit-keyframes fadeOutRight {
+  from {
+    opacity: 1;
+  }
+
+  to {
+    opacity: 0;
+    -webkit-transform: translate3d(100%, 0, 0);
+    transform: translate3d(100%, 0, 0);
+  }
+}
+@keyframes fadeOutRight {
+  from {
+    opacity: 1;
+  }
+
+  to {
+    opacity: 0;
+    -webkit-transform: translate3d(100%, 0, 0);
+    transform: translate3d(100%, 0, 0);
+  }
+}
+.animate__fadeOutRight {
+  -webkit-animation-name: fadeOutRight;
+  animation-name: fadeOutRight;
+}
+@-webkit-keyframes fadeOutRightBig {
+  from {
+    opacity: 1;
+  }
+
+  to {
+    opacity: 0;
+    -webkit-transform: translate3d(2000px, 0, 0);
+    transform: translate3d(2000px, 0, 0);
+  }
+}
+@keyframes fadeOutRightBig {
+  from {
+    opacity: 1;
+  }
+
+  to {
+    opacity: 0;
+    -webkit-transform: translate3d(2000px, 0, 0);
+    transform: translate3d(2000px, 0, 0);
+  }
+}
+.animate__fadeOutRightBig {
+  -webkit-animation-name: fadeOutRightBig;
+  animation-name: fadeOutRightBig;
+}
+@-webkit-keyframes fadeOutUp {
+  from {
+    opacity: 1;
+  }
+
+  to {
+    opacity: 0;
+    -webkit-transform: translate3d(0, -100%, 0);
+    transform: translate3d(0, -100%, 0);
+  }
+}
+@keyframes fadeOutUp {
+  from {
+    opacity: 1;
+  }
+
+  to {
+    opacity: 0;
+    -webkit-transform: translate3d(0, -100%, 0);
+    transform: translate3d(0, -100%, 0);
+  }
+}
+.animate__fadeOutUp {
+  -webkit-animation-name: fadeOutUp;
+  animation-name: fadeOutUp;
+}
+@-webkit-keyframes fadeOutUpBig {
+  from {
+    opacity: 1;
+  }
+
+  to {
+    opacity: 0;
+    -webkit-transform: translate3d(0, -2000px, 0);
+    transform: translate3d(0, -2000px, 0);
+  }
+}
+@keyframes fadeOutUpBig {
+  from {
+    opacity: 1;
+  }
+
+  to {
+    opacity: 0;
+    -webkit-transform: translate3d(0, -2000px, 0);
+    transform: translate3d(0, -2000px, 0);
+  }
+}
+.animate__fadeOutUpBig {
+  -webkit-animation-name: fadeOutUpBig;
+  animation-name: fadeOutUpBig;
+}
+@-webkit-keyframes fadeOutTopLeft {
+  from {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+  to {
+    opacity: 0;
+    -webkit-transform: translate3d(-100%, -100%, 0);
+    transform: translate3d(-100%, -100%, 0);
+  }
+}
+@keyframes fadeOutTopLeft {
+  from {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+  to {
+    opacity: 0;
+    -webkit-transform: translate3d(-100%, -100%, 0);
+    transform: translate3d(-100%, -100%, 0);
+  }
+}
+.animate__fadeOutTopLeft {
+  -webkit-animation-name: fadeOutTopLeft;
+  animation-name: fadeOutTopLeft;
+}
+@-webkit-keyframes fadeOutTopRight {
+  from {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+  to {
+    opacity: 0;
+    -webkit-transform: translate3d(100%, -100%, 0);
+    transform: translate3d(100%, -100%, 0);
+  }
+}
+@keyframes fadeOutTopRight {
+  from {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+  to {
+    opacity: 0;
+    -webkit-transform: translate3d(100%, -100%, 0);
+    transform: translate3d(100%, -100%, 0);
+  }
+}
+.animate__fadeOutTopRight {
+  -webkit-animation-name: fadeOutTopRight;
+  animation-name: fadeOutTopRight;
+}
+@-webkit-keyframes fadeOutBottomRight {
+  from {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+  to {
+    opacity: 0;
+    -webkit-transform: translate3d(100%, 100%, 0);
+    transform: translate3d(100%, 100%, 0);
+  }
+}
+@keyframes fadeOutBottomRight {
+  from {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+  to {
+    opacity: 0;
+    -webkit-transform: translate3d(100%, 100%, 0);
+    transform: translate3d(100%, 100%, 0);
+  }
+}
+.animate__fadeOutBottomRight {
+  -webkit-animation-name: fadeOutBottomRight;
+  animation-name: fadeOutBottomRight;
+}
+@-webkit-keyframes fadeOutBottomLeft {
+  from {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+  to {
+    opacity: 0;
+    -webkit-transform: translate3d(-100%, 100%, 0);
+    transform: translate3d(-100%, 100%, 0);
+  }
+}
+@keyframes fadeOutBottomLeft {
+  from {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+  to {
+    opacity: 0;
+    -webkit-transform: translate3d(-100%, 100%, 0);
+    transform: translate3d(-100%, 100%, 0);
+  }
+}
+.animate__fadeOutBottomLeft {
+  -webkit-animation-name: fadeOutBottomLeft;
+  animation-name: fadeOutBottomLeft;
+}
+/* Flippers */
+@-webkit-keyframes flip {
+  from {
+    -webkit-transform: perspective(400px) scale3d(1, 1, 1) translate3d(0, 0, 0) rotate3d(0, 1, 0, -360deg);
+    transform: perspective(400px) scale3d(1, 1, 1) translate3d(0, 0, 0) rotate3d(0, 1, 0, -360deg);
+    -webkit-animation-timing-function: ease-out;
+    animation-timing-function: ease-out;
+  }
+
+  40% {
+    -webkit-transform: perspective(400px) scale3d(1, 1, 1) translate3d(0, 0, 150px)
+      rotate3d(0, 1, 0, -190deg);
+    transform: perspective(400px) scale3d(1, 1, 1) translate3d(0, 0, 150px)
+      rotate3d(0, 1, 0, -190deg);
+    -webkit-animation-timing-function: ease-out;
+    animation-timing-function: ease-out;
+  }
+
+  50% {
+    -webkit-transform: perspective(400px) scale3d(1, 1, 1) translate3d(0, 0, 150px)
+      rotate3d(0, 1, 0, -170deg);
+    transform: perspective(400px) scale3d(1, 1, 1) translate3d(0, 0, 150px)
+      rotate3d(0, 1, 0, -170deg);
+    -webkit-animation-timing-function: ease-in;
+    animation-timing-function: ease-in;
+  }
+
+  80% {
+    -webkit-transform: perspective(400px) scale3d(0.95, 0.95, 0.95) translate3d(0, 0, 0)
+      rotate3d(0, 1, 0, 0deg);
+    transform: perspective(400px) scale3d(0.95, 0.95, 0.95) translate3d(0, 0, 0)
+      rotate3d(0, 1, 0, 0deg);
+    -webkit-animation-timing-function: ease-in;
+    animation-timing-function: ease-in;
+  }
+
+  to {
+    -webkit-transform: perspective(400px) scale3d(1, 1, 1) translate3d(0, 0, 0) rotate3d(0, 1, 0, 0deg);
+    transform: perspective(400px) scale3d(1, 1, 1) translate3d(0, 0, 0) rotate3d(0, 1, 0, 0deg);
+    -webkit-animation-timing-function: ease-in;
+    animation-timing-function: ease-in;
+  }
+}
+@keyframes flip {
+  from {
+    -webkit-transform: perspective(400px) scale3d(1, 1, 1) translate3d(0, 0, 0) rotate3d(0, 1, 0, -360deg);
+    transform: perspective(400px) scale3d(1, 1, 1) translate3d(0, 0, 0) rotate3d(0, 1, 0, -360deg);
+    -webkit-animation-timing-function: ease-out;
+    animation-timing-function: ease-out;
+  }
+
+  40% {
+    -webkit-transform: perspective(400px) scale3d(1, 1, 1) translate3d(0, 0, 150px)
+      rotate3d(0, 1, 0, -190deg);
+    transform: perspective(400px) scale3d(1, 1, 1) translate3d(0, 0, 150px)
+      rotate3d(0, 1, 0, -190deg);
+    -webkit-animation-timing-function: ease-out;
+    animation-timing-function: ease-out;
+  }
+
+  50% {
+    -webkit-transform: perspective(400px) scale3d(1, 1, 1) translate3d(0, 0, 150px)
+      rotate3d(0, 1, 0, -170deg);
+    transform: perspective(400px) scale3d(1, 1, 1) translate3d(0, 0, 150px)
+      rotate3d(0, 1, 0, -170deg);
+    -webkit-animation-timing-function: ease-in;
+    animation-timing-function: ease-in;
+  }
+
+  80% {
+    -webkit-transform: perspective(400px) scale3d(0.95, 0.95, 0.95) translate3d(0, 0, 0)
+      rotate3d(0, 1, 0, 0deg);
+    transform: perspective(400px) scale3d(0.95, 0.95, 0.95) translate3d(0, 0, 0)
+      rotate3d(0, 1, 0, 0deg);
+    -webkit-animation-timing-function: ease-in;
+    animation-timing-function: ease-in;
+  }
+
+  to {
+    -webkit-transform: perspective(400px) scale3d(1, 1, 1) translate3d(0, 0, 0) rotate3d(0, 1, 0, 0deg);
+    transform: perspective(400px) scale3d(1, 1, 1) translate3d(0, 0, 0) rotate3d(0, 1, 0, 0deg);
+    -webkit-animation-timing-function: ease-in;
+    animation-timing-function: ease-in;
+  }
+}
+.animate__animated.animate__flip {
+  -webkit-backface-visibility: visible;
+  backface-visibility: visible;
+  -webkit-animation-name: flip;
+  animation-name: flip;
+}
+@-webkit-keyframes flipInX {
+  from {
+    -webkit-transform: perspective(400px) rotate3d(1, 0, 0, 90deg);
+    transform: perspective(400px) rotate3d(1, 0, 0, 90deg);
+    -webkit-animation-timing-function: ease-in;
+    animation-timing-function: ease-in;
+    opacity: 0;
+  }
+
+  40% {
+    -webkit-transform: perspective(400px) rotate3d(1, 0, 0, -20deg);
+    transform: perspective(400px) rotate3d(1, 0, 0, -20deg);
+    -webkit-animation-timing-function: ease-in;
+    animation-timing-function: ease-in;
+  }
+
+  60% {
+    -webkit-transform: perspective(400px) rotate3d(1, 0, 0, 10deg);
+    transform: perspective(400px) rotate3d(1, 0, 0, 10deg);
+    opacity: 1;
+  }
+
+  80% {
+    -webkit-transform: perspective(400px) rotate3d(1, 0, 0, -5deg);
+    transform: perspective(400px) rotate3d(1, 0, 0, -5deg);
+  }
+
+  to {
+    -webkit-transform: perspective(400px);
+    transform: perspective(400px);
+  }
+}
+@keyframes flipInX {
+  from {
+    -webkit-transform: perspective(400px) rotate3d(1, 0, 0, 90deg);
+    transform: perspective(400px) rotate3d(1, 0, 0, 90deg);
+    -webkit-animation-timing-function: ease-in;
+    animation-timing-function: ease-in;
+    opacity: 0;
+  }
+
+  40% {
+    -webkit-transform: perspective(400px) rotate3d(1, 0, 0, -20deg);
+    transform: perspective(400px) rotate3d(1, 0, 0, -20deg);
+    -webkit-animation-timing-function: ease-in;
+    animation-timing-function: ease-in;
+  }
+
+  60% {
+    -webkit-transform: perspective(400px) rotate3d(1, 0, 0, 10deg);
+    transform: perspective(400px) rotate3d(1, 0, 0, 10deg);
+    opacity: 1;
+  }
+
+  80% {
+    -webkit-transform: perspective(400px) rotate3d(1, 0, 0, -5deg);
+    transform: perspective(400px) rotate3d(1, 0, 0, -5deg);
+  }
+
+  to {
+    -webkit-transform: perspective(400px);
+    transform: perspective(400px);
+  }
+}
+.animate__flipInX {
+  -webkit-backface-visibility: visible !important;
+  backface-visibility: visible !important;
+  -webkit-animation-name: flipInX;
+  animation-name: flipInX;
+}
+@-webkit-keyframes flipInY {
+  from {
+    -webkit-transform: perspective(400px) rotate3d(0, 1, 0, 90deg);
+    transform: perspective(400px) rotate3d(0, 1, 0, 90deg);
+    -webkit-animation-timing-function: ease-in;
+    animation-timing-function: ease-in;
+    opacity: 0;
+  }
+
+  40% {
+    -webkit-transform: perspective(400px) rotate3d(0, 1, 0, -20deg);
+    transform: perspective(400px) rotate3d(0, 1, 0, -20deg);
+    -webkit-animation-timing-function: ease-in;
+    animation-timing-function: ease-in;
+  }
+
+  60% {
+    -webkit-transform: perspective(400px) rotate3d(0, 1, 0, 10deg);
+    transform: perspective(400px) rotate3d(0, 1, 0, 10deg);
+    opacity: 1;
+  }
+
+  80% {
+    -webkit-transform: perspective(400px) rotate3d(0, 1, 0, -5deg);
+    transform: perspective(400px) rotate3d(0, 1, 0, -5deg);
+  }
+
+  to {
+    -webkit-transform: perspective(400px);
+    transform: perspective(400px);
+  }
+}
+@keyframes flipInY {
+  from {
+    -webkit-transform: perspective(400px) rotate3d(0, 1, 0, 90deg);
+    transform: perspective(400px) rotate3d(0, 1, 0, 90deg);
+    -webkit-animation-timing-function: ease-in;
+    animation-timing-function: ease-in;
+    opacity: 0;
+  }
+
+  40% {
+    -webkit-transform: perspective(400px) rotate3d(0, 1, 0, -20deg);
+    transform: perspective(400px) rotate3d(0, 1, 0, -20deg);
+    -webkit-animation-timing-function: ease-in;
+    animation-timing-function: ease-in;
+  }
+
+  60% {
+    -webkit-transform: perspective(400px) rotate3d(0, 1, 0, 10deg);
+    transform: perspective(400px) rotate3d(0, 1, 0, 10deg);
+    opacity: 1;
+  }
+
+  80% {
+    -webkit-transform: perspective(400px) rotate3d(0, 1, 0, -5deg);
+    transform: perspective(400px) rotate3d(0, 1, 0, -5deg);
+  }
+
+  to {
+    -webkit-transform: perspective(400px);
+    transform: perspective(400px);
+  }
+}
+.animate__flipInY {
+  -webkit-backface-visibility: visible !important;
+  backface-visibility: visible !important;
+  -webkit-animation-name: flipInY;
+  animation-name: flipInY;
+}
+@-webkit-keyframes flipOutX {
+  from {
+    -webkit-transform: perspective(400px);
+    transform: perspective(400px);
+  }
+
+  30% {
+    -webkit-transform: perspective(400px) rotate3d(1, 0, 0, -20deg);
+    transform: perspective(400px) rotate3d(1, 0, 0, -20deg);
+    opacity: 1;
+  }
+
+  to {
+    -webkit-transform: perspective(400px) rotate3d(1, 0, 0, 90deg);
+    transform: perspective(400px) rotate3d(1, 0, 0, 90deg);
+    opacity: 0;
+  }
+}
+@keyframes flipOutX {
+  from {
+    -webkit-transform: perspective(400px);
+    transform: perspective(400px);
+  }
+
+  30% {
+    -webkit-transform: perspective(400px) rotate3d(1, 0, 0, -20deg);
+    transform: perspective(400px) rotate3d(1, 0, 0, -20deg);
+    opacity: 1;
+  }
+
+  to {
+    -webkit-transform: perspective(400px) rotate3d(1, 0, 0, 90deg);
+    transform: perspective(400px) rotate3d(1, 0, 0, 90deg);
+    opacity: 0;
+  }
+}
+.animate__flipOutX {
+  -webkit-animation-duration: calc(1s * 0.75);
+  animation-duration: calc(1s * 0.75);
+  -webkit-animation-duration: calc(var(--animate-duration) * 0.75);
+  animation-duration: calc(var(--animate-duration) * 0.75);
+  -webkit-animation-name: flipOutX;
+  animation-name: flipOutX;
+  -webkit-backface-visibility: visible !important;
+  backface-visibility: visible !important;
+}
+@-webkit-keyframes flipOutY {
+  from {
+    -webkit-transform: perspective(400px);
+    transform: perspective(400px);
+  }
+
+  30% {
+    -webkit-transform: perspective(400px) rotate3d(0, 1, 0, -15deg);
+    transform: perspective(400px) rotate3d(0, 1, 0, -15deg);
+    opacity: 1;
+  }
+
+  to {
+    -webkit-transform: perspective(400px) rotate3d(0, 1, 0, 90deg);
+    transform: perspective(400px) rotate3d(0, 1, 0, 90deg);
+    opacity: 0;
+  }
+}
+@keyframes flipOutY {
+  from {
+    -webkit-transform: perspective(400px);
+    transform: perspective(400px);
+  }
+
+  30% {
+    -webkit-transform: perspective(400px) rotate3d(0, 1, 0, -15deg);
+    transform: perspective(400px) rotate3d(0, 1, 0, -15deg);
+    opacity: 1;
+  }
+
+  to {
+    -webkit-transform: perspective(400px) rotate3d(0, 1, 0, 90deg);
+    transform: perspective(400px) rotate3d(0, 1, 0, 90deg);
+    opacity: 0;
+  }
+}
+.animate__flipOutY {
+  -webkit-animation-duration: calc(1s * 0.75);
+  animation-duration: calc(1s * 0.75);
+  -webkit-animation-duration: calc(var(--animate-duration) * 0.75);
+  animation-duration: calc(var(--animate-duration) * 0.75);
+  -webkit-backface-visibility: visible !important;
+  backface-visibility: visible !important;
+  -webkit-animation-name: flipOutY;
+  animation-name: flipOutY;
+}
+/* Lightspeed */
+@-webkit-keyframes lightSpeedInRight {
+  from {
+    -webkit-transform: translate3d(100%, 0, 0) skewX(-30deg);
+    transform: translate3d(100%, 0, 0) skewX(-30deg);
+    opacity: 0;
+  }
+
+  60% {
+    -webkit-transform: skewX(20deg);
+    transform: skewX(20deg);
+    opacity: 1;
+  }
+
+  80% {
+    -webkit-transform: skewX(-5deg);
+    transform: skewX(-5deg);
+  }
+
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+@keyframes lightSpeedInRight {
+  from {
+    -webkit-transform: translate3d(100%, 0, 0) skewX(-30deg);
+    transform: translate3d(100%, 0, 0) skewX(-30deg);
+    opacity: 0;
+  }
+
+  60% {
+    -webkit-transform: skewX(20deg);
+    transform: skewX(20deg);
+    opacity: 1;
+  }
+
+  80% {
+    -webkit-transform: skewX(-5deg);
+    transform: skewX(-5deg);
+  }
+
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+.animate__lightSpeedInRight {
+  -webkit-animation-name: lightSpeedInRight;
+  animation-name: lightSpeedInRight;
+  -webkit-animation-timing-function: ease-out;
+  animation-timing-function: ease-out;
+}
+@-webkit-keyframes lightSpeedInLeft {
+  from {
+    -webkit-transform: translate3d(-100%, 0, 0) skewX(30deg);
+    transform: translate3d(-100%, 0, 0) skewX(30deg);
+    opacity: 0;
+  }
+
+  60% {
+    -webkit-transform: skewX(-20deg);
+    transform: skewX(-20deg);
+    opacity: 1;
+  }
+
+  80% {
+    -webkit-transform: skewX(5deg);
+    transform: skewX(5deg);
+  }
+
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+@keyframes lightSpeedInLeft {
+  from {
+    -webkit-transform: translate3d(-100%, 0, 0) skewX(30deg);
+    transform: translate3d(-100%, 0, 0) skewX(30deg);
+    opacity: 0;
+  }
+
+  60% {
+    -webkit-transform: skewX(-20deg);
+    transform: skewX(-20deg);
+    opacity: 1;
+  }
+
+  80% {
+    -webkit-transform: skewX(5deg);
+    transform: skewX(5deg);
+  }
+
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+.animate__lightSpeedInLeft {
+  -webkit-animation-name: lightSpeedInLeft;
+  animation-name: lightSpeedInLeft;
+  -webkit-animation-timing-function: ease-out;
+  animation-timing-function: ease-out;
+}
+@-webkit-keyframes lightSpeedOutRight {
+  from {
+    opacity: 1;
+  }
+
+  to {
+    -webkit-transform: translate3d(100%, 0, 0) skewX(30deg);
+    transform: translate3d(100%, 0, 0) skewX(30deg);
+    opacity: 0;
+  }
+}
+@keyframes lightSpeedOutRight {
+  from {
+    opacity: 1;
+  }
+
+  to {
+    -webkit-transform: translate3d(100%, 0, 0) skewX(30deg);
+    transform: translate3d(100%, 0, 0) skewX(30deg);
+    opacity: 0;
+  }
+}
+.animate__lightSpeedOutRight {
+  -webkit-animation-name: lightSpeedOutRight;
+  animation-name: lightSpeedOutRight;
+  -webkit-animation-timing-function: ease-in;
+  animation-timing-function: ease-in;
+}
+@-webkit-keyframes lightSpeedOutLeft {
+  from {
+    opacity: 1;
+  }
+
+  to {
+    -webkit-transform: translate3d(-100%, 0, 0) skewX(-30deg);
+    transform: translate3d(-100%, 0, 0) skewX(-30deg);
+    opacity: 0;
+  }
+}
+@keyframes lightSpeedOutLeft {
+  from {
+    opacity: 1;
+  }
+
+  to {
+    -webkit-transform: translate3d(-100%, 0, 0) skewX(-30deg);
+    transform: translate3d(-100%, 0, 0) skewX(-30deg);
+    opacity: 0;
+  }
+}
+.animate__lightSpeedOutLeft {
+  -webkit-animation-name: lightSpeedOutLeft;
+  animation-name: lightSpeedOutLeft;
+  -webkit-animation-timing-function: ease-in;
+  animation-timing-function: ease-in;
+}
+/* Rotating entrances */
+@-webkit-keyframes rotateIn {
+  from {
+    -webkit-transform: rotate3d(0, 0, 1, -200deg);
+    transform: rotate3d(0, 0, 1, -200deg);
+    opacity: 0;
+  }
+
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+    opacity: 1;
+  }
+}
+@keyframes rotateIn {
+  from {
+    -webkit-transform: rotate3d(0, 0, 1, -200deg);
+    transform: rotate3d(0, 0, 1, -200deg);
+    opacity: 0;
+  }
+
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+    opacity: 1;
+  }
+}
+.animate__rotateIn {
+  -webkit-animation-name: rotateIn;
+  animation-name: rotateIn;
+  -webkit-transform-origin: center;
+  transform-origin: center;
+}
+@-webkit-keyframes rotateInDownLeft {
+  from {
+    -webkit-transform: rotate3d(0, 0, 1, -45deg);
+    transform: rotate3d(0, 0, 1, -45deg);
+    opacity: 0;
+  }
+
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+    opacity: 1;
+  }
+}
+@keyframes rotateInDownLeft {
+  from {
+    -webkit-transform: rotate3d(0, 0, 1, -45deg);
+    transform: rotate3d(0, 0, 1, -45deg);
+    opacity: 0;
+  }
+
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+    opacity: 1;
+  }
+}
+.animate__rotateInDownLeft {
+  -webkit-animation-name: rotateInDownLeft;
+  animation-name: rotateInDownLeft;
+  -webkit-transform-origin: left bottom;
+  transform-origin: left bottom;
+}
+@-webkit-keyframes rotateInDownRight {
+  from {
+    -webkit-transform: rotate3d(0, 0, 1, 45deg);
+    transform: rotate3d(0, 0, 1, 45deg);
+    opacity: 0;
+  }
+
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+    opacity: 1;
+  }
+}
+@keyframes rotateInDownRight {
+  from {
+    -webkit-transform: rotate3d(0, 0, 1, 45deg);
+    transform: rotate3d(0, 0, 1, 45deg);
+    opacity: 0;
+  }
+
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+    opacity: 1;
+  }
+}
+.animate__rotateInDownRight {
+  -webkit-animation-name: rotateInDownRight;
+  animation-name: rotateInDownRight;
+  -webkit-transform-origin: right bottom;
+  transform-origin: right bottom;
+}
+@-webkit-keyframes rotateInUpLeft {
+  from {
+    -webkit-transform: rotate3d(0, 0, 1, 45deg);
+    transform: rotate3d(0, 0, 1, 45deg);
+    opacity: 0;
+  }
+
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+    opacity: 1;
+  }
+}
+@keyframes rotateInUpLeft {
+  from {
+    -webkit-transform: rotate3d(0, 0, 1, 45deg);
+    transform: rotate3d(0, 0, 1, 45deg);
+    opacity: 0;
+  }
+
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+    opacity: 1;
+  }
+}
+.animate__rotateInUpLeft {
+  -webkit-animation-name: rotateInUpLeft;
+  animation-name: rotateInUpLeft;
+  -webkit-transform-origin: left bottom;
+  transform-origin: left bottom;
+}
+@-webkit-keyframes rotateInUpRight {
+  from {
+    -webkit-transform: rotate3d(0, 0, 1, -90deg);
+    transform: rotate3d(0, 0, 1, -90deg);
+    opacity: 0;
+  }
+
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+    opacity: 1;
+  }
+}
+@keyframes rotateInUpRight {
+  from {
+    -webkit-transform: rotate3d(0, 0, 1, -90deg);
+    transform: rotate3d(0, 0, 1, -90deg);
+    opacity: 0;
+  }
+
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+    opacity: 1;
+  }
+}
+.animate__rotateInUpRight {
+  -webkit-animation-name: rotateInUpRight;
+  animation-name: rotateInUpRight;
+  -webkit-transform-origin: right bottom;
+  transform-origin: right bottom;
+}
+/* Rotating exits */
+@-webkit-keyframes rotateOut {
+  from {
+    opacity: 1;
+  }
+
+  to {
+    -webkit-transform: rotate3d(0, 0, 1, 200deg);
+    transform: rotate3d(0, 0, 1, 200deg);
+    opacity: 0;
+  }
+}
+@keyframes rotateOut {
+  from {
+    opacity: 1;
+  }
+
+  to {
+    -webkit-transform: rotate3d(0, 0, 1, 200deg);
+    transform: rotate3d(0, 0, 1, 200deg);
+    opacity: 0;
+  }
+}
+.animate__rotateOut {
+  -webkit-animation-name: rotateOut;
+  animation-name: rotateOut;
+  -webkit-transform-origin: center;
+  transform-origin: center;
+}
+@-webkit-keyframes rotateOutDownLeft {
+  from {
+    opacity: 1;
+  }
+
+  to {
+    -webkit-transform: rotate3d(0, 0, 1, 45deg);
+    transform: rotate3d(0, 0, 1, 45deg);
+    opacity: 0;
+  }
+}
+@keyframes rotateOutDownLeft {
+  from {
+    opacity: 1;
+  }
+
+  to {
+    -webkit-transform: rotate3d(0, 0, 1, 45deg);
+    transform: rotate3d(0, 0, 1, 45deg);
+    opacity: 0;
+  }
+}
+.animate__rotateOutDownLeft {
+  -webkit-animation-name: rotateOutDownLeft;
+  animation-name: rotateOutDownLeft;
+  -webkit-transform-origin: left bottom;
+  transform-origin: left bottom;
+}
+@-webkit-keyframes rotateOutDownRight {
+  from {
+    opacity: 1;
+  }
+
+  to {
+    -webkit-transform: rotate3d(0, 0, 1, -45deg);
+    transform: rotate3d(0, 0, 1, -45deg);
+    opacity: 0;
+  }
+}
+@keyframes rotateOutDownRight {
+  from {
+    opacity: 1;
+  }
+
+  to {
+    -webkit-transform: rotate3d(0, 0, 1, -45deg);
+    transform: rotate3d(0, 0, 1, -45deg);
+    opacity: 0;
+  }
+}
+.animate__rotateOutDownRight {
+  -webkit-animation-name: rotateOutDownRight;
+  animation-name: rotateOutDownRight;
+  -webkit-transform-origin: right bottom;
+  transform-origin: right bottom;
+}
+@-webkit-keyframes rotateOutUpLeft {
+  from {
+    opacity: 1;
+  }
+
+  to {
+    -webkit-transform: rotate3d(0, 0, 1, -45deg);
+    transform: rotate3d(0, 0, 1, -45deg);
+    opacity: 0;
+  }
+}
+@keyframes rotateOutUpLeft {
+  from {
+    opacity: 1;
+  }
+
+  to {
+    -webkit-transform: rotate3d(0, 0, 1, -45deg);
+    transform: rotate3d(0, 0, 1, -45deg);
+    opacity: 0;
+  }
+}
+.animate__rotateOutUpLeft {
+  -webkit-animation-name: rotateOutUpLeft;
+  animation-name: rotateOutUpLeft;
+  -webkit-transform-origin: left bottom;
+  transform-origin: left bottom;
+}
+@-webkit-keyframes rotateOutUpRight {
+  from {
+    opacity: 1;
+  }
+
+  to {
+    -webkit-transform: rotate3d(0, 0, 1, 90deg);
+    transform: rotate3d(0, 0, 1, 90deg);
+    opacity: 0;
+  }
+}
+@keyframes rotateOutUpRight {
+  from {
+    opacity: 1;
+  }
+
+  to {
+    -webkit-transform: rotate3d(0, 0, 1, 90deg);
+    transform: rotate3d(0, 0, 1, 90deg);
+    opacity: 0;
+  }
+}
+.animate__rotateOutUpRight {
+  -webkit-animation-name: rotateOutUpRight;
+  animation-name: rotateOutUpRight;
+  -webkit-transform-origin: right bottom;
+  transform-origin: right bottom;
+}
+/* Specials */
+@-webkit-keyframes hinge {
+  0% {
+    -webkit-animation-timing-function: ease-in-out;
+    animation-timing-function: ease-in-out;
+  }
+
+  20%,
+  60% {
+    -webkit-transform: rotate3d(0, 0, 1, 80deg);
+    transform: rotate3d(0, 0, 1, 80deg);
+    -webkit-animation-timing-function: ease-in-out;
+    animation-timing-function: ease-in-out;
+  }
+
+  40%,
+  80% {
+    -webkit-transform: rotate3d(0, 0, 1, 60deg);
+    transform: rotate3d(0, 0, 1, 60deg);
+    -webkit-animation-timing-function: ease-in-out;
+    animation-timing-function: ease-in-out;
+    opacity: 1;
+  }
+
+  to {
+    -webkit-transform: translate3d(0, 700px, 0);
+    transform: translate3d(0, 700px, 0);
+    opacity: 0;
+  }
+}
+@keyframes hinge {
+  0% {
+    -webkit-animation-timing-function: ease-in-out;
+    animation-timing-function: ease-in-out;
+  }
+
+  20%,
+  60% {
+    -webkit-transform: rotate3d(0, 0, 1, 80deg);
+    transform: rotate3d(0, 0, 1, 80deg);
+    -webkit-animation-timing-function: ease-in-out;
+    animation-timing-function: ease-in-out;
+  }
+
+  40%,
+  80% {
+    -webkit-transform: rotate3d(0, 0, 1, 60deg);
+    transform: rotate3d(0, 0, 1, 60deg);
+    -webkit-animation-timing-function: ease-in-out;
+    animation-timing-function: ease-in-out;
+    opacity: 1;
+  }
+
+  to {
+    -webkit-transform: translate3d(0, 700px, 0);
+    transform: translate3d(0, 700px, 0);
+    opacity: 0;
+  }
+}
+.animate__hinge {
+  -webkit-animation-duration: calc(1s * 2);
+  animation-duration: calc(1s * 2);
+  -webkit-animation-duration: calc(var(--animate-duration) * 2);
+  animation-duration: calc(var(--animate-duration) * 2);
+  -webkit-animation-name: hinge;
+  animation-name: hinge;
+  -webkit-transform-origin: top left;
+  transform-origin: top left;
+}
+@-webkit-keyframes jackInTheBox {
+  from {
+    opacity: 0;
+    -webkit-transform: scale(0.1) rotate(30deg);
+    transform: scale(0.1) rotate(30deg);
+    -webkit-transform-origin: center bottom;
+    transform-origin: center bottom;
+  }
+
+  50% {
+    -webkit-transform: rotate(-10deg);
+    transform: rotate(-10deg);
+  }
+
+  70% {
+    -webkit-transform: rotate(3deg);
+    transform: rotate(3deg);
+  }
+
+  to {
+    opacity: 1;
+    -webkit-transform: scale(1);
+    transform: scale(1);
+  }
+}
+@keyframes jackInTheBox {
+  from {
+    opacity: 0;
+    -webkit-transform: scale(0.1) rotate(30deg);
+    transform: scale(0.1) rotate(30deg);
+    -webkit-transform-origin: center bottom;
+    transform-origin: center bottom;
+  }
+
+  50% {
+    -webkit-transform: rotate(-10deg);
+    transform: rotate(-10deg);
+  }
+
+  70% {
+    -webkit-transform: rotate(3deg);
+    transform: rotate(3deg);
+  }
+
+  to {
+    opacity: 1;
+    -webkit-transform: scale(1);
+    transform: scale(1);
+  }
+}
+.animate__jackInTheBox {
+  -webkit-animation-name: jackInTheBox;
+  animation-name: jackInTheBox;
+}
+/* originally authored by Nick Pettit - https://github.com/nickpettit/glide */
+@-webkit-keyframes rollIn {
+  from {
+    opacity: 0;
+    -webkit-transform: translate3d(-100%, 0, 0) rotate3d(0, 0, 1, -120deg);
+    transform: translate3d(-100%, 0, 0) rotate3d(0, 0, 1, -120deg);
+  }
+
+  to {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+@keyframes rollIn {
+  from {
+    opacity: 0;
+    -webkit-transform: translate3d(-100%, 0, 0) rotate3d(0, 0, 1, -120deg);
+    transform: translate3d(-100%, 0, 0) rotate3d(0, 0, 1, -120deg);
+  }
+
+  to {
+    opacity: 1;
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+.animate__rollIn {
+  -webkit-animation-name: rollIn;
+  animation-name: rollIn;
+}
+/* originally authored by Nick Pettit - https://github.com/nickpettit/glide */
+@-webkit-keyframes rollOut {
+  from {
+    opacity: 1;
+  }
+
+  to {
+    opacity: 0;
+    -webkit-transform: translate3d(100%, 0, 0) rotate3d(0, 0, 1, 120deg);
+    transform: translate3d(100%, 0, 0) rotate3d(0, 0, 1, 120deg);
+  }
+}
+@keyframes rollOut {
+  from {
+    opacity: 1;
+  }
+
+  to {
+    opacity: 0;
+    -webkit-transform: translate3d(100%, 0, 0) rotate3d(0, 0, 1, 120deg);
+    transform: translate3d(100%, 0, 0) rotate3d(0, 0, 1, 120deg);
+  }
+}
+.animate__rollOut {
+  -webkit-animation-name: rollOut;
+  animation-name: rollOut;
+}
+/* Zooming entrances */
+@-webkit-keyframes zoomIn {
+  from {
+    opacity: 0;
+    -webkit-transform: scale3d(0.3, 0.3, 0.3);
+    transform: scale3d(0.3, 0.3, 0.3);
+  }
+
+  50% {
+    opacity: 1;
+  }
+}
+@keyframes zoomIn {
+  from {
+    opacity: 0;
+    -webkit-transform: scale3d(0.3, 0.3, 0.3);
+    transform: scale3d(0.3, 0.3, 0.3);
+  }
+
+  50% {
+    opacity: 1;
+  }
+}
+.animate__zoomIn {
+  -webkit-animation-name: zoomIn;
+  animation-name: zoomIn;
+}
+@-webkit-keyframes zoomInDown {
+  from {
+    opacity: 0;
+    -webkit-transform: scale3d(0.1, 0.1, 0.1) translate3d(0, -1000px, 0);
+    transform: scale3d(0.1, 0.1, 0.1) translate3d(0, -1000px, 0);
+    -webkit-animation-timing-function: cubic-bezier(0.55, 0.055, 0.675, 0.19);
+    animation-timing-function: cubic-bezier(0.55, 0.055, 0.675, 0.19);
+  }
+
+  60% {
+    opacity: 1;
+    -webkit-transform: scale3d(0.475, 0.475, 0.475) translate3d(0, 60px, 0);
+    transform: scale3d(0.475, 0.475, 0.475) translate3d(0, 60px, 0);
+    -webkit-animation-timing-function: cubic-bezier(0.175, 0.885, 0.32, 1);
+    animation-timing-function: cubic-bezier(0.175, 0.885, 0.32, 1);
+  }
+}
+@keyframes zoomInDown {
+  from {
+    opacity: 0;
+    -webkit-transform: scale3d(0.1, 0.1, 0.1) translate3d(0, -1000px, 0);
+    transform: scale3d(0.1, 0.1, 0.1) translate3d(0, -1000px, 0);
+    -webkit-animation-timing-function: cubic-bezier(0.55, 0.055, 0.675, 0.19);
+    animation-timing-function: cubic-bezier(0.55, 0.055, 0.675, 0.19);
+  }
+
+  60% {
+    opacity: 1;
+    -webkit-transform: scale3d(0.475, 0.475, 0.475) translate3d(0, 60px, 0);
+    transform: scale3d(0.475, 0.475, 0.475) translate3d(0, 60px, 0);
+    -webkit-animation-timing-function: cubic-bezier(0.175, 0.885, 0.32, 1);
+    animation-timing-function: cubic-bezier(0.175, 0.885, 0.32, 1);
+  }
+}
+.animate__zoomInDown {
+  -webkit-animation-name: zoomInDown;
+  animation-name: zoomInDown;
+}
+@-webkit-keyframes zoomInLeft {
+  from {
+    opacity: 0;
+    -webkit-transform: scale3d(0.1, 0.1, 0.1) translate3d(-1000px, 0, 0);
+    transform: scale3d(0.1, 0.1, 0.1) translate3d(-1000px, 0, 0);
+    -webkit-animation-timing-function: cubic-bezier(0.55, 0.055, 0.675, 0.19);
+    animation-timing-function: cubic-bezier(0.55, 0.055, 0.675, 0.19);
+  }
+
+  60% {
+    opacity: 1;
+    -webkit-transform: scale3d(0.475, 0.475, 0.475) translate3d(10px, 0, 0);
+    transform: scale3d(0.475, 0.475, 0.475) translate3d(10px, 0, 0);
+    -webkit-animation-timing-function: cubic-bezier(0.175, 0.885, 0.32, 1);
+    animation-timing-function: cubic-bezier(0.175, 0.885, 0.32, 1);
+  }
+}
+@keyframes zoomInLeft {
+  from {
+    opacity: 0;
+    -webkit-transform: scale3d(0.1, 0.1, 0.1) translate3d(-1000px, 0, 0);
+    transform: scale3d(0.1, 0.1, 0.1) translate3d(-1000px, 0, 0);
+    -webkit-animation-timing-function: cubic-bezier(0.55, 0.055, 0.675, 0.19);
+    animation-timing-function: cubic-bezier(0.55, 0.055, 0.675, 0.19);
+  }
+
+  60% {
+    opacity: 1;
+    -webkit-transform: scale3d(0.475, 0.475, 0.475) translate3d(10px, 0, 0);
+    transform: scale3d(0.475, 0.475, 0.475) translate3d(10px, 0, 0);
+    -webkit-animation-timing-function: cubic-bezier(0.175, 0.885, 0.32, 1);
+    animation-timing-function: cubic-bezier(0.175, 0.885, 0.32, 1);
+  }
+}
+.animate__zoomInLeft {
+  -webkit-animation-name: zoomInLeft;
+  animation-name: zoomInLeft;
+}
+@-webkit-keyframes zoomInRight {
+  from {
+    opacity: 0;
+    -webkit-transform: scale3d(0.1, 0.1, 0.1) translate3d(1000px, 0, 0);
+    transform: scale3d(0.1, 0.1, 0.1) translate3d(1000px, 0, 0);
+    -webkit-animation-timing-function: cubic-bezier(0.55, 0.055, 0.675, 0.19);
+    animation-timing-function: cubic-bezier(0.55, 0.055, 0.675, 0.19);
+  }
+
+  60% {
+    opacity: 1;
+    -webkit-transform: scale3d(0.475, 0.475, 0.475) translate3d(-10px, 0, 0);
+    transform: scale3d(0.475, 0.475, 0.475) translate3d(-10px, 0, 0);
+    -webkit-animation-timing-function: cubic-bezier(0.175, 0.885, 0.32, 1);
+    animation-timing-function: cubic-bezier(0.175, 0.885, 0.32, 1);
+  }
+}
+@keyframes zoomInRight {
+  from {
+    opacity: 0;
+    -webkit-transform: scale3d(0.1, 0.1, 0.1) translate3d(1000px, 0, 0);
+    transform: scale3d(0.1, 0.1, 0.1) translate3d(1000px, 0, 0);
+    -webkit-animation-timing-function: cubic-bezier(0.55, 0.055, 0.675, 0.19);
+    animation-timing-function: cubic-bezier(0.55, 0.055, 0.675, 0.19);
+  }
+
+  60% {
+    opacity: 1;
+    -webkit-transform: scale3d(0.475, 0.475, 0.475) translate3d(-10px, 0, 0);
+    transform: scale3d(0.475, 0.475, 0.475) translate3d(-10px, 0, 0);
+    -webkit-animation-timing-function: cubic-bezier(0.175, 0.885, 0.32, 1);
+    animation-timing-function: cubic-bezier(0.175, 0.885, 0.32, 1);
+  }
+}
+.animate__zoomInRight {
+  -webkit-animation-name: zoomInRight;
+  animation-name: zoomInRight;
+}
+@-webkit-keyframes zoomInUp {
+  from {
+    opacity: 0;
+    -webkit-transform: scale3d(0.1, 0.1, 0.1) translate3d(0, 1000px, 0);
+    transform: scale3d(0.1, 0.1, 0.1) translate3d(0, 1000px, 0);
+    -webkit-animation-timing-function: cubic-bezier(0.55, 0.055, 0.675, 0.19);
+    animation-timing-function: cubic-bezier(0.55, 0.055, 0.675, 0.19);
+  }
+
+  60% {
+    opacity: 1;
+    -webkit-transform: scale3d(0.475, 0.475, 0.475) translate3d(0, -60px, 0);
+    transform: scale3d(0.475, 0.475, 0.475) translate3d(0, -60px, 0);
+    -webkit-animation-timing-function: cubic-bezier(0.175, 0.885, 0.32, 1);
+    animation-timing-function: cubic-bezier(0.175, 0.885, 0.32, 1);
+  }
+}
+@keyframes zoomInUp {
+  from {
+    opacity: 0;
+    -webkit-transform: scale3d(0.1, 0.1, 0.1) translate3d(0, 1000px, 0);
+    transform: scale3d(0.1, 0.1, 0.1) translate3d(0, 1000px, 0);
+    -webkit-animation-timing-function: cubic-bezier(0.55, 0.055, 0.675, 0.19);
+    animation-timing-function: cubic-bezier(0.55, 0.055, 0.675, 0.19);
+  }
+
+  60% {
+    opacity: 1;
+    -webkit-transform: scale3d(0.475, 0.475, 0.475) translate3d(0, -60px, 0);
+    transform: scale3d(0.475, 0.475, 0.475) translate3d(0, -60px, 0);
+    -webkit-animation-timing-function: cubic-bezier(0.175, 0.885, 0.32, 1);
+    animation-timing-function: cubic-bezier(0.175, 0.885, 0.32, 1);
+  }
+}
+.animate__zoomInUp {
+  -webkit-animation-name: zoomInUp;
+  animation-name: zoomInUp;
+}
+/* Zooming exits */
+@-webkit-keyframes zoomOut {
+  from {
+    opacity: 1;
+  }
+
+  50% {
+    opacity: 0;
+    -webkit-transform: scale3d(0.3, 0.3, 0.3);
+    transform: scale3d(0.3, 0.3, 0.3);
+  }
+
+  to {
+    opacity: 0;
+  }
+}
+@keyframes zoomOut {
+  from {
+    opacity: 1;
+  }
+
+  50% {
+    opacity: 0;
+    -webkit-transform: scale3d(0.3, 0.3, 0.3);
+    transform: scale3d(0.3, 0.3, 0.3);
+  }
+
+  to {
+    opacity: 0;
+  }
+}
+.animate__zoomOut {
+  -webkit-animation-name: zoomOut;
+  animation-name: zoomOut;
+}
+@-webkit-keyframes zoomOutDown {
+  40% {
+    opacity: 1;
+    -webkit-transform: scale3d(0.475, 0.475, 0.475) translate3d(0, -60px, 0);
+    transform: scale3d(0.475, 0.475, 0.475) translate3d(0, -60px, 0);
+    -webkit-animation-timing-function: cubic-bezier(0.55, 0.055, 0.675, 0.19);
+    animation-timing-function: cubic-bezier(0.55, 0.055, 0.675, 0.19);
+  }
+
+  to {
+    opacity: 0;
+    -webkit-transform: scale3d(0.1, 0.1, 0.1) translate3d(0, 2000px, 0);
+    transform: scale3d(0.1, 0.1, 0.1) translate3d(0, 2000px, 0);
+    -webkit-animation-timing-function: cubic-bezier(0.175, 0.885, 0.32, 1);
+    animation-timing-function: cubic-bezier(0.175, 0.885, 0.32, 1);
+  }
+}
+@keyframes zoomOutDown {
+  40% {
+    opacity: 1;
+    -webkit-transform: scale3d(0.475, 0.475, 0.475) translate3d(0, -60px, 0);
+    transform: scale3d(0.475, 0.475, 0.475) translate3d(0, -60px, 0);
+    -webkit-animation-timing-function: cubic-bezier(0.55, 0.055, 0.675, 0.19);
+    animation-timing-function: cubic-bezier(0.55, 0.055, 0.675, 0.19);
+  }
+
+  to {
+    opacity: 0;
+    -webkit-transform: scale3d(0.1, 0.1, 0.1) translate3d(0, 2000px, 0);
+    transform: scale3d(0.1, 0.1, 0.1) translate3d(0, 2000px, 0);
+    -webkit-animation-timing-function: cubic-bezier(0.175, 0.885, 0.32, 1);
+    animation-timing-function: cubic-bezier(0.175, 0.885, 0.32, 1);
+  }
+}
+.animate__zoomOutDown {
+  -webkit-animation-name: zoomOutDown;
+  animation-name: zoomOutDown;
+  -webkit-transform-origin: center bottom;
+  transform-origin: center bottom;
+}
+@-webkit-keyframes zoomOutLeft {
+  40% {
+    opacity: 1;
+    -webkit-transform: scale3d(0.475, 0.475, 0.475) translate3d(42px, 0, 0);
+    transform: scale3d(0.475, 0.475, 0.475) translate3d(42px, 0, 0);
+  }
+
+  to {
+    opacity: 0;
+    -webkit-transform: scale(0.1) translate3d(-2000px, 0, 0);
+    transform: scale(0.1) translate3d(-2000px, 0, 0);
+  }
+}
+@keyframes zoomOutLeft {
+  40% {
+    opacity: 1;
+    -webkit-transform: scale3d(0.475, 0.475, 0.475) translate3d(42px, 0, 0);
+    transform: scale3d(0.475, 0.475, 0.475) translate3d(42px, 0, 0);
+  }
+
+  to {
+    opacity: 0;
+    -webkit-transform: scale(0.1) translate3d(-2000px, 0, 0);
+    transform: scale(0.1) translate3d(-2000px, 0, 0);
+  }
+}
+.animate__zoomOutLeft {
+  -webkit-animation-name: zoomOutLeft;
+  animation-name: zoomOutLeft;
+  -webkit-transform-origin: left center;
+  transform-origin: left center;
+}
+@-webkit-keyframes zoomOutRight {
+  40% {
+    opacity: 1;
+    -webkit-transform: scale3d(0.475, 0.475, 0.475) translate3d(-42px, 0, 0);
+    transform: scale3d(0.475, 0.475, 0.475) translate3d(-42px, 0, 0);
+  }
+
+  to {
+    opacity: 0;
+    -webkit-transform: scale(0.1) translate3d(2000px, 0, 0);
+    transform: scale(0.1) translate3d(2000px, 0, 0);
+  }
+}
+@keyframes zoomOutRight {
+  40% {
+    opacity: 1;
+    -webkit-transform: scale3d(0.475, 0.475, 0.475) translate3d(-42px, 0, 0);
+    transform: scale3d(0.475, 0.475, 0.475) translate3d(-42px, 0, 0);
+  }
+
+  to {
+    opacity: 0;
+    -webkit-transform: scale(0.1) translate3d(2000px, 0, 0);
+    transform: scale(0.1) translate3d(2000px, 0, 0);
+  }
+}
+.animate__zoomOutRight {
+  -webkit-animation-name: zoomOutRight;
+  animation-name: zoomOutRight;
+  -webkit-transform-origin: right center;
+  transform-origin: right center;
+}
+@-webkit-keyframes zoomOutUp {
+  40% {
+    opacity: 1;
+    -webkit-transform: scale3d(0.475, 0.475, 0.475) translate3d(0, 60px, 0);
+    transform: scale3d(0.475, 0.475, 0.475) translate3d(0, 60px, 0);
+    -webkit-animation-timing-function: cubic-bezier(0.55, 0.055, 0.675, 0.19);
+    animation-timing-function: cubic-bezier(0.55, 0.055, 0.675, 0.19);
+  }
+
+  to {
+    opacity: 0;
+    -webkit-transform: scale3d(0.1, 0.1, 0.1) translate3d(0, -2000px, 0);
+    transform: scale3d(0.1, 0.1, 0.1) translate3d(0, -2000px, 0);
+    -webkit-animation-timing-function: cubic-bezier(0.175, 0.885, 0.32, 1);
+    animation-timing-function: cubic-bezier(0.175, 0.885, 0.32, 1);
+  }
+}
+@keyframes zoomOutUp {
+  40% {
+    opacity: 1;
+    -webkit-transform: scale3d(0.475, 0.475, 0.475) translate3d(0, 60px, 0);
+    transform: scale3d(0.475, 0.475, 0.475) translate3d(0, 60px, 0);
+    -webkit-animation-timing-function: cubic-bezier(0.55, 0.055, 0.675, 0.19);
+    animation-timing-function: cubic-bezier(0.55, 0.055, 0.675, 0.19);
+  }
+
+  to {
+    opacity: 0;
+    -webkit-transform: scale3d(0.1, 0.1, 0.1) translate3d(0, -2000px, 0);
+    transform: scale3d(0.1, 0.1, 0.1) translate3d(0, -2000px, 0);
+    -webkit-animation-timing-function: cubic-bezier(0.175, 0.885, 0.32, 1);
+    animation-timing-function: cubic-bezier(0.175, 0.885, 0.32, 1);
+  }
+}
+.animate__zoomOutUp {
+  -webkit-animation-name: zoomOutUp;
+  animation-name: zoomOutUp;
+  -webkit-transform-origin: center bottom;
+  transform-origin: center bottom;
+}
+/* Sliding entrances */
+@-webkit-keyframes slideInDown {
+  from {
+    -webkit-transform: translate3d(0, -100%, 0);
+    transform: translate3d(0, -100%, 0);
+    visibility: visible;
+  }
+
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+@keyframes slideInDown {
+  from {
+    -webkit-transform: translate3d(0, -100%, 0);
+    transform: translate3d(0, -100%, 0);
+    visibility: visible;
+  }
+
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+.animate__slideInDown {
+  -webkit-animation-name: slideInDown;
+  animation-name: slideInDown;
+}
+@-webkit-keyframes slideInLeft {
+  from {
+    -webkit-transform: translate3d(-100%, 0, 0);
+    transform: translate3d(-100%, 0, 0);
+    visibility: visible;
+  }
+
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+@keyframes slideInLeft {
+  from {
+    -webkit-transform: translate3d(-100%, 0, 0);
+    transform: translate3d(-100%, 0, 0);
+    visibility: visible;
+  }
+
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+.animate__slideInLeft {
+  -webkit-animation-name: slideInLeft;
+  animation-name: slideInLeft;
+}
+@-webkit-keyframes slideInRight {
+  from {
+    -webkit-transform: translate3d(100%, 0, 0);
+    transform: translate3d(100%, 0, 0);
+    visibility: visible;
+  }
+
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+@keyframes slideInRight {
+  from {
+    -webkit-transform: translate3d(100%, 0, 0);
+    transform: translate3d(100%, 0, 0);
+    visibility: visible;
+  }
+
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+.animate__slideInRight {
+  -webkit-animation-name: slideInRight;
+  animation-name: slideInRight;
+}
+@-webkit-keyframes slideInUp {
+  from {
+    -webkit-transform: translate3d(0, 100%, 0);
+    transform: translate3d(0, 100%, 0);
+    visibility: visible;
+  }
+
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+@keyframes slideInUp {
+  from {
+    -webkit-transform: translate3d(0, 100%, 0);
+    transform: translate3d(0, 100%, 0);
+    visibility: visible;
+  }
+
+  to {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+}
+.animate__slideInUp {
+  -webkit-animation-name: slideInUp;
+  animation-name: slideInUp;
+}
+/* Sliding exits */
+@-webkit-keyframes slideOutDown {
+  from {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+
+  to {
+    visibility: hidden;
+    -webkit-transform: translate3d(0, 100%, 0);
+    transform: translate3d(0, 100%, 0);
+  }
+}
+@keyframes slideOutDown {
+  from {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+
+  to {
+    visibility: hidden;
+    -webkit-transform: translate3d(0, 100%, 0);
+    transform: translate3d(0, 100%, 0);
+  }
+}
+.animate__slideOutDown {
+  -webkit-animation-name: slideOutDown;
+  animation-name: slideOutDown;
+}
+@-webkit-keyframes slideOutLeft {
+  from {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+
+  to {
+    visibility: hidden;
+    -webkit-transform: translate3d(-100%, 0, 0);
+    transform: translate3d(-100%, 0, 0);
+  }
+}
+@keyframes slideOutLeft {
+  from {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+
+  to {
+    visibility: hidden;
+    -webkit-transform: translate3d(-100%, 0, 0);
+    transform: translate3d(-100%, 0, 0);
+  }
+}
+.animate__slideOutLeft {
+  -webkit-animation-name: slideOutLeft;
+  animation-name: slideOutLeft;
+}
+@-webkit-keyframes slideOutRight {
+  from {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+
+  to {
+    visibility: hidden;
+    -webkit-transform: translate3d(100%, 0, 0);
+    transform: translate3d(100%, 0, 0);
+  }
+}
+@keyframes slideOutRight {
+  from {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+
+  to {
+    visibility: hidden;
+    -webkit-transform: translate3d(100%, 0, 0);
+    transform: translate3d(100%, 0, 0);
+  }
+}
+.animate__slideOutRight {
+  -webkit-animation-name: slideOutRight;
+  animation-name: slideOutRight;
+}
+@-webkit-keyframes slideOutUp {
+  from {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+
+  to {
+    visibility: hidden;
+    -webkit-transform: translate3d(0, -100%, 0);
+    transform: translate3d(0, -100%, 0);
+  }
+}
+@keyframes slideOutUp {
+  from {
+    -webkit-transform: translate3d(0, 0, 0);
+    transform: translate3d(0, 0, 0);
+  }
+
+  to {
+    visibility: hidden;
+    -webkit-transform: translate3d(0, -100%, 0);
+    transform: translate3d(0, -100%, 0);
+  }
+}
+.animate__slideOutUp {
+  -webkit-animation-name: slideOutUp;
+  animation-name: slideOutUp;
+}
\ No newline at end of file
diff --git a/test/js/bun/css/files/bootstrap-4.css b/test/js/bun/css/files/bootstrap-4.css
new file mode 100644
index 0000000000..3ac15f025b
--- /dev/null
+++ b/test/js/bun/css/files/bootstrap-4.css
@@ -0,0 +1,7 @@
+/*!
+ * Bootstrap v4.6.1 (https://getbootstrap.com/)
+ * Copyright 2011-2021 The Bootstrap Authors
+ * Copyright 2011-2021 Twitter, Inc.
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ */
+:root{--blue:#007bff;--indigo:#6610f2;--purple:#6f42c1;--pink:#e83e8c;--red:#dc3545;--orange:#fd7e14;--yellow:#ffc107;--green:#28a745;--teal:#20c997;--cyan:#17a2b8;--white:#fff;--gray:#6c757d;--gray-dark:#343a40;--primary:#007bff;--secondary:#6c757d;--success:#28a745;--info:#17a2b8;--warning:#ffc107;--danger:#dc3545;--light:#f8f9fa;--dark:#343a40;--breakpoint-xs:0;--breakpoint-sm:576px;--breakpoint-md:768px;--breakpoint-lg:992px;--breakpoint-xl:1200px;--font-family-sans-serif:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Arial,"Noto Sans","Liberation Sans",sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol","Noto Color Emoji";--font-family-monospace:SFMono-Regular,Menlo,Monaco,Consolas,"Liberation Mono","Courier New",monospace}*,:before,:after{box-sizing:border-box}html{-webkit-text-size-adjust:100%;-webkit-tap-highlight-color:#0000;font-family:sans-serif;line-height:1.15}article,aside,figcaption,figure,footer,header,hgroup,main,nav,section{display:block}body{color:#212529;text-align:left;background-color:#fff;margin:0;font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Helvetica Neue,Arial,Noto Sans,Liberation Sans,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol,Noto Color Emoji;font-size:1rem;font-weight:400;line-height:1.5}[tabindex="-1"]:focus:not(:focus-visible){outline:0!important}hr{box-sizing:content-box;height:0;overflow:visible}h1,h2,h3,h4,h5,h6{margin-top:0;margin-bottom:.5rem}p{margin-top:0;margin-bottom:1rem}abbr[title],abbr[data-original-title]{text-decoration:underline;cursor:help;-webkit-text-decoration-skip-ink:none;text-decoration-skip-ink:none;border-bottom:0;text-decoration:underline dotted}address{font-style:normal;line-height:inherit;margin-bottom:1rem}ol,ul,dl{margin-top:0;margin-bottom:1rem}ol ol,ul ul,ol ul,ul ol{margin-bottom:0}dt{font-weight:700}dd{margin-bottom:.5rem;margin-left:0}blockquote{margin:0 0 1rem}b,strong{font-weight:bolder}small{font-size:80%}sub,sup{vertical-align:baseline;font-size:75%;line-height:0;position:relative}sub{bottom:-.25em}sup{top:-.5em}a{color:#007bff;background-color:#0000;text-decoration:none}a:hover{color:#0056b3;text-decoration:underline}a:not([href]):not([class]),a:not([href]):not([class]):hover{color:inherit;text-decoration:none}pre,code,kbd,samp{font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,monospace;font-size:1em}pre{-ms-overflow-style:scrollbar;margin-top:0;margin-bottom:1rem;overflow:auto}figure{margin:0 0 1rem}img{vertical-align:middle;border-style:none}svg{vertical-align:middle;overflow:hidden}table{border-collapse:collapse}caption{color:#6c757d;text-align:left;caption-side:bottom;padding-top:.75rem;padding-bottom:.75rem}th{text-align:inherit;text-align:-webkit-match-parent}label{margin-bottom:.5rem;display:inline-block}button{border-radius:0}button:focus:not(:focus-visible){outline:0}input,button,select,optgroup,textarea{font-family:inherit;font-size:inherit;line-height:inherit;margin:0}button,input{overflow:visible}button,select{text-transform:none}[role=button]{cursor:pointer}select{word-wrap:normal}button,[type=button],[type=reset],[type=submit]{-webkit-appearance:button}button:not(:disabled),[type=button]:not(:disabled),[type=reset]:not(:disabled),[type=submit]:not(:disabled){cursor:pointer}button::-moz-focus-inner,[type=button]::-moz-focus-inner,[type=reset]::-moz-focus-inner,[type=submit]::-moz-focus-inner{border-style:none;padding:0}input[type=radio],input[type=checkbox]{box-sizing:border-box;padding:0}textarea{resize:vertical;overflow:auto}fieldset{border:0;min-width:0;margin:0;padding:0}legend{font-size:1.5rem;line-height:inherit;color:inherit;white-space:normal;width:100%;max-width:100%;margin-bottom:.5rem;padding:0;display:block}progress{vertical-align:baseline}[type=number]::-webkit-inner-spin-button,[type=number]::-webkit-outer-spin-button{height:auto}[type=search]{outline-offset:-2px;-webkit-appearance:none}[type=search]::-webkit-search-decoration{-webkit-appearance:none}::-webkit-file-upload-button{font:inherit;-webkit-appearance:button}output{display:inline-block}summary{cursor:pointer;display:list-item}template{display:none}[hidden]{display:none!important}h1,h2,h3,h4,h5,h6,.h1,.h2,.h3,.h4,.h5,.h6{margin-bottom:.5rem;font-weight:500;line-height:1.2}h1,.h1{font-size:2.5rem}h2,.h2{font-size:2rem}h3,.h3{font-size:1.75rem}h4,.h4{font-size:1.5rem}h5,.h5{font-size:1.25rem}h6,.h6{font-size:1rem}.lead{font-size:1.25rem;font-weight:300}.display-1{font-size:6rem;font-weight:300;line-height:1.2}.display-2{font-size:5.5rem;font-weight:300;line-height:1.2}.display-3{font-size:4.5rem;font-weight:300;line-height:1.2}.display-4{font-size:3.5rem;font-weight:300;line-height:1.2}hr{border:0;border-top:1px solid #0000001a;margin-top:1rem;margin-bottom:1rem}small,.small{font-size:80%;font-weight:400}mark,.mark{background-color:#fcf8e3;padding:.2em}.list-unstyled,.list-inline{padding-left:0;list-style:none}.list-inline-item{display:inline-block}.list-inline-item:not(:last-child){margin-right:.5rem}.initialism{text-transform:uppercase;font-size:90%}.blockquote{margin-bottom:1rem;font-size:1.25rem}.blockquote-footer{color:#6c757d;font-size:80%;display:block}.blockquote-footer:before{content:"— "}.img-fluid{max-width:100%;height:auto}.img-thumbnail{background-color:#fff;border:1px solid #dee2e6;border-radius:.25rem;max-width:100%;height:auto;padding:.25rem}.figure{display:inline-block}.figure-img{margin-bottom:.5rem;line-height:1}.figure-caption{color:#6c757d;font-size:90%}code{color:#e83e8c;word-wrap:break-word;font-size:87.5%}a>code{color:inherit}kbd{color:#fff;background-color:#212529;border-radius:.2rem;padding:.2rem .4rem;font-size:87.5%}kbd kbd{padding:0;font-size:100%;font-weight:700}pre{color:#212529;font-size:87.5%;display:block}pre code{font-size:inherit;color:inherit;word-break:normal}.pre-scrollable{max-height:340px;overflow-y:scroll}.container,.container-fluid,.container-sm,.container-md,.container-lg,.container-xl{width:100%;margin-left:auto;margin-right:auto;padding-left:15px;padding-right:15px}@media (width>=576px){.container,.container-sm{max-width:540px}}@media (width>=768px){.container,.container-sm,.container-md{max-width:720px}}@media (width>=992px){.container,.container-sm,.container-md,.container-lg{max-width:960px}}@media (width>=1200px){.container,.container-sm,.container-md,.container-lg,.container-xl{max-width:1140px}}.row{-ms-flex-wrap:wrap;flex-wrap:wrap;margin-left:-15px;margin-right:-15px;display:-ms-flexbox;display:flex}.no-gutters{margin-left:0;margin-right:0}.no-gutters>.col,.no-gutters>[class*=col-]{padding-left:0;padding-right:0}.col-1,.col-2,.col-3,.col-4,.col-5,.col-6,.col-7,.col-8,.col-9,.col-10,.col-11,.col-12,.col,.col-auto,.col-sm-1,.col-sm-2,.col-sm-3,.col-sm-4,.col-sm-5,.col-sm-6,.col-sm-7,.col-sm-8,.col-sm-9,.col-sm-10,.col-sm-11,.col-sm-12,.col-sm,.col-sm-auto,.col-md-1,.col-md-2,.col-md-3,.col-md-4,.col-md-5,.col-md-6,.col-md-7,.col-md-8,.col-md-9,.col-md-10,.col-md-11,.col-md-12,.col-md,.col-md-auto,.col-lg-1,.col-lg-2,.col-lg-3,.col-lg-4,.col-lg-5,.col-lg-6,.col-lg-7,.col-lg-8,.col-lg-9,.col-lg-10,.col-lg-11,.col-lg-12,.col-lg,.col-lg-auto,.col-xl-1,.col-xl-2,.col-xl-3,.col-xl-4,.col-xl-5,.col-xl-6,.col-xl-7,.col-xl-8,.col-xl-9,.col-xl-10,.col-xl-11,.col-xl-12,.col-xl,.col-xl-auto{width:100%;padding-left:15px;padding-right:15px;position:relative}.col{-ms-flex-positive:1;-ms-flex-preferred-size:0;flex-grow:1;flex-basis:0;max-width:100%}.row-cols-1>*{-ms-flex:0 0 100%;flex:0 0 100%;max-width:100%}.row-cols-2>*{-ms-flex:0 0 50%;flex:0 0 50%;max-width:50%}.row-cols-3>*{-ms-flex:0 0 33.3333%;flex:0 0 33.3333%;max-width:33.3333%}.row-cols-4>*{-ms-flex:0 0 25%;flex:0 0 25%;max-width:25%}.row-cols-5>*{-ms-flex:0 0 20%;flex:0 0 20%;max-width:20%}.row-cols-6>*{-ms-flex:0 0 16.6667%;flex:0 0 16.6667%;max-width:16.6667%}.col-auto{-ms-flex:none;flex:none;width:auto;max-width:100%}.col-1{-ms-flex:0 0 8.33333%;flex:0 0 8.33333%;max-width:8.33333%}.col-2{-ms-flex:0 0 16.6667%;flex:0 0 16.6667%;max-width:16.6667%}.col-3{-ms-flex:0 0 25%;flex:0 0 25%;max-width:25%}.col-4{-ms-flex:0 0 33.3333%;flex:0 0 33.3333%;max-width:33.3333%}.col-5{-ms-flex:0 0 41.6667%;flex:0 0 41.6667%;max-width:41.6667%}.col-6{-ms-flex:0 0 50%;flex:0 0 50%;max-width:50%}.col-7{-ms-flex:0 0 58.3333%;flex:0 0 58.3333%;max-width:58.3333%}.col-8{-ms-flex:0 0 66.6667%;flex:0 0 66.6667%;max-width:66.6667%}.col-9{-ms-flex:0 0 75%;flex:0 0 75%;max-width:75%}.col-10{-ms-flex:0 0 83.3333%;flex:0 0 83.3333%;max-width:83.3333%}.col-11{-ms-flex:0 0 91.6667%;flex:0 0 91.6667%;max-width:91.6667%}.col-12{-ms-flex:0 0 100%;flex:0 0 100%;max-width:100%}.order-first{-ms-flex-order:-1;order:-1}.order-last{-ms-flex-order:13;order:13}.order-0{-ms-flex-order:0;order:0}.order-1{-ms-flex-order:1;order:1}.order-2{-ms-flex-order:2;order:2}.order-3{-ms-flex-order:3;order:3}.order-4{-ms-flex-order:4;order:4}.order-5{-ms-flex-order:5;order:5}.order-6{-ms-flex-order:6;order:6}.order-7{-ms-flex-order:7;order:7}.order-8{-ms-flex-order:8;order:8}.order-9{-ms-flex-order:9;order:9}.order-10{-ms-flex-order:10;order:10}.order-11{-ms-flex-order:11;order:11}.order-12{-ms-flex-order:12;order:12}.offset-1{margin-left:8.33333%}.offset-2{margin-left:16.6667%}.offset-3{margin-left:25%}.offset-4{margin-left:33.3333%}.offset-5{margin-left:41.6667%}.offset-6{margin-left:50%}.offset-7{margin-left:58.3333%}.offset-8{margin-left:66.6667%}.offset-9{margin-left:75%}.offset-10{margin-left:83.3333%}.offset-11{margin-left:91.6667%}@media (width>=576px){.col-sm{-ms-flex-positive:1;-ms-flex-preferred-size:0;flex-grow:1;flex-basis:0;max-width:100%}.row-cols-sm-1>*{-ms-flex:0 0 100%;flex:0 0 100%;max-width:100%}.row-cols-sm-2>*{-ms-flex:0 0 50%;flex:0 0 50%;max-width:50%}.row-cols-sm-3>*{-ms-flex:0 0 33.3333%;flex:0 0 33.3333%;max-width:33.3333%}.row-cols-sm-4>*{-ms-flex:0 0 25%;flex:0 0 25%;max-width:25%}.row-cols-sm-5>*{-ms-flex:0 0 20%;flex:0 0 20%;max-width:20%}.row-cols-sm-6>*{-ms-flex:0 0 16.6667%;flex:0 0 16.6667%;max-width:16.6667%}.col-sm-auto{-ms-flex:none;flex:none;width:auto;max-width:100%}.col-sm-1{-ms-flex:0 0 8.33333%;flex:0 0 8.33333%;max-width:8.33333%}.col-sm-2{-ms-flex:0 0 16.6667%;flex:0 0 16.6667%;max-width:16.6667%}.col-sm-3{-ms-flex:0 0 25%;flex:0 0 25%;max-width:25%}.col-sm-4{-ms-flex:0 0 33.3333%;flex:0 0 33.3333%;max-width:33.3333%}.col-sm-5{-ms-flex:0 0 41.6667%;flex:0 0 41.6667%;max-width:41.6667%}.col-sm-6{-ms-flex:0 0 50%;flex:0 0 50%;max-width:50%}.col-sm-7{-ms-flex:0 0 58.3333%;flex:0 0 58.3333%;max-width:58.3333%}.col-sm-8{-ms-flex:0 0 66.6667%;flex:0 0 66.6667%;max-width:66.6667%}.col-sm-9{-ms-flex:0 0 75%;flex:0 0 75%;max-width:75%}.col-sm-10{-ms-flex:0 0 83.3333%;flex:0 0 83.3333%;max-width:83.3333%}.col-sm-11{-ms-flex:0 0 91.6667%;flex:0 0 91.6667%;max-width:91.6667%}.col-sm-12{-ms-flex:0 0 100%;flex:0 0 100%;max-width:100%}.order-sm-first{-ms-flex-order:-1;order:-1}.order-sm-last{-ms-flex-order:13;order:13}.order-sm-0{-ms-flex-order:0;order:0}.order-sm-1{-ms-flex-order:1;order:1}.order-sm-2{-ms-flex-order:2;order:2}.order-sm-3{-ms-flex-order:3;order:3}.order-sm-4{-ms-flex-order:4;order:4}.order-sm-5{-ms-flex-order:5;order:5}.order-sm-6{-ms-flex-order:6;order:6}.order-sm-7{-ms-flex-order:7;order:7}.order-sm-8{-ms-flex-order:8;order:8}.order-sm-9{-ms-flex-order:9;order:9}.order-sm-10{-ms-flex-order:10;order:10}.order-sm-11{-ms-flex-order:11;order:11}.order-sm-12{-ms-flex-order:12;order:12}.offset-sm-0{margin-left:0}.offset-sm-1{margin-left:8.33333%}.offset-sm-2{margin-left:16.6667%}.offset-sm-3{margin-left:25%}.offset-sm-4{margin-left:33.3333%}.offset-sm-5{margin-left:41.6667%}.offset-sm-6{margin-left:50%}.offset-sm-7{margin-left:58.3333%}.offset-sm-8{margin-left:66.6667%}.offset-sm-9{margin-left:75%}.offset-sm-10{margin-left:83.3333%}.offset-sm-11{margin-left:91.6667%}}@media (width>=768px){.col-md{-ms-flex-positive:1;-ms-flex-preferred-size:0;flex-grow:1;flex-basis:0;max-width:100%}.row-cols-md-1>*{-ms-flex:0 0 100%;flex:0 0 100%;max-width:100%}.row-cols-md-2>*{-ms-flex:0 0 50%;flex:0 0 50%;max-width:50%}.row-cols-md-3>*{-ms-flex:0 0 33.3333%;flex:0 0 33.3333%;max-width:33.3333%}.row-cols-md-4>*{-ms-flex:0 0 25%;flex:0 0 25%;max-width:25%}.row-cols-md-5>*{-ms-flex:0 0 20%;flex:0 0 20%;max-width:20%}.row-cols-md-6>*{-ms-flex:0 0 16.6667%;flex:0 0 16.6667%;max-width:16.6667%}.col-md-auto{-ms-flex:none;flex:none;width:auto;max-width:100%}.col-md-1{-ms-flex:0 0 8.33333%;flex:0 0 8.33333%;max-width:8.33333%}.col-md-2{-ms-flex:0 0 16.6667%;flex:0 0 16.6667%;max-width:16.6667%}.col-md-3{-ms-flex:0 0 25%;flex:0 0 25%;max-width:25%}.col-md-4{-ms-flex:0 0 33.3333%;flex:0 0 33.3333%;max-width:33.3333%}.col-md-5{-ms-flex:0 0 41.6667%;flex:0 0 41.6667%;max-width:41.6667%}.col-md-6{-ms-flex:0 0 50%;flex:0 0 50%;max-width:50%}.col-md-7{-ms-flex:0 0 58.3333%;flex:0 0 58.3333%;max-width:58.3333%}.col-md-8{-ms-flex:0 0 66.6667%;flex:0 0 66.6667%;max-width:66.6667%}.col-md-9{-ms-flex:0 0 75%;flex:0 0 75%;max-width:75%}.col-md-10{-ms-flex:0 0 83.3333%;flex:0 0 83.3333%;max-width:83.3333%}.col-md-11{-ms-flex:0 0 91.6667%;flex:0 0 91.6667%;max-width:91.6667%}.col-md-12{-ms-flex:0 0 100%;flex:0 0 100%;max-width:100%}.order-md-first{-ms-flex-order:-1;order:-1}.order-md-last{-ms-flex-order:13;order:13}.order-md-0{-ms-flex-order:0;order:0}.order-md-1{-ms-flex-order:1;order:1}.order-md-2{-ms-flex-order:2;order:2}.order-md-3{-ms-flex-order:3;order:3}.order-md-4{-ms-flex-order:4;order:4}.order-md-5{-ms-flex-order:5;order:5}.order-md-6{-ms-flex-order:6;order:6}.order-md-7{-ms-flex-order:7;order:7}.order-md-8{-ms-flex-order:8;order:8}.order-md-9{-ms-flex-order:9;order:9}.order-md-10{-ms-flex-order:10;order:10}.order-md-11{-ms-flex-order:11;order:11}.order-md-12{-ms-flex-order:12;order:12}.offset-md-0{margin-left:0}.offset-md-1{margin-left:8.33333%}.offset-md-2{margin-left:16.6667%}.offset-md-3{margin-left:25%}.offset-md-4{margin-left:33.3333%}.offset-md-5{margin-left:41.6667%}.offset-md-6{margin-left:50%}.offset-md-7{margin-left:58.3333%}.offset-md-8{margin-left:66.6667%}.offset-md-9{margin-left:75%}.offset-md-10{margin-left:83.3333%}.offset-md-11{margin-left:91.6667%}}@media (width>=992px){.col-lg{-ms-flex-positive:1;-ms-flex-preferred-size:0;flex-grow:1;flex-basis:0;max-width:100%}.row-cols-lg-1>*{-ms-flex:0 0 100%;flex:0 0 100%;max-width:100%}.row-cols-lg-2>*{-ms-flex:0 0 50%;flex:0 0 50%;max-width:50%}.row-cols-lg-3>*{-ms-flex:0 0 33.3333%;flex:0 0 33.3333%;max-width:33.3333%}.row-cols-lg-4>*{-ms-flex:0 0 25%;flex:0 0 25%;max-width:25%}.row-cols-lg-5>*{-ms-flex:0 0 20%;flex:0 0 20%;max-width:20%}.row-cols-lg-6>*{-ms-flex:0 0 16.6667%;flex:0 0 16.6667%;max-width:16.6667%}.col-lg-auto{-ms-flex:none;flex:none;width:auto;max-width:100%}.col-lg-1{-ms-flex:0 0 8.33333%;flex:0 0 8.33333%;max-width:8.33333%}.col-lg-2{-ms-flex:0 0 16.6667%;flex:0 0 16.6667%;max-width:16.6667%}.col-lg-3{-ms-flex:0 0 25%;flex:0 0 25%;max-width:25%}.col-lg-4{-ms-flex:0 0 33.3333%;flex:0 0 33.3333%;max-width:33.3333%}.col-lg-5{-ms-flex:0 0 41.6667%;flex:0 0 41.6667%;max-width:41.6667%}.col-lg-6{-ms-flex:0 0 50%;flex:0 0 50%;max-width:50%}.col-lg-7{-ms-flex:0 0 58.3333%;flex:0 0 58.3333%;max-width:58.3333%}.col-lg-8{-ms-flex:0 0 66.6667%;flex:0 0 66.6667%;max-width:66.6667%}.col-lg-9{-ms-flex:0 0 75%;flex:0 0 75%;max-width:75%}.col-lg-10{-ms-flex:0 0 83.3333%;flex:0 0 83.3333%;max-width:83.3333%}.col-lg-11{-ms-flex:0 0 91.6667%;flex:0 0 91.6667%;max-width:91.6667%}.col-lg-12{-ms-flex:0 0 100%;flex:0 0 100%;max-width:100%}.order-lg-first{-ms-flex-order:-1;order:-1}.order-lg-last{-ms-flex-order:13;order:13}.order-lg-0{-ms-flex-order:0;order:0}.order-lg-1{-ms-flex-order:1;order:1}.order-lg-2{-ms-flex-order:2;order:2}.order-lg-3{-ms-flex-order:3;order:3}.order-lg-4{-ms-flex-order:4;order:4}.order-lg-5{-ms-flex-order:5;order:5}.order-lg-6{-ms-flex-order:6;order:6}.order-lg-7{-ms-flex-order:7;order:7}.order-lg-8{-ms-flex-order:8;order:8}.order-lg-9{-ms-flex-order:9;order:9}.order-lg-10{-ms-flex-order:10;order:10}.order-lg-11{-ms-flex-order:11;order:11}.order-lg-12{-ms-flex-order:12;order:12}.offset-lg-0{margin-left:0}.offset-lg-1{margin-left:8.33333%}.offset-lg-2{margin-left:16.6667%}.offset-lg-3{margin-left:25%}.offset-lg-4{margin-left:33.3333%}.offset-lg-5{margin-left:41.6667%}.offset-lg-6{margin-left:50%}.offset-lg-7{margin-left:58.3333%}.offset-lg-8{margin-left:66.6667%}.offset-lg-9{margin-left:75%}.offset-lg-10{margin-left:83.3333%}.offset-lg-11{margin-left:91.6667%}}@media (width>=1200px){.col-xl{-ms-flex-positive:1;-ms-flex-preferred-size:0;flex-grow:1;flex-basis:0;max-width:100%}.row-cols-xl-1>*{-ms-flex:0 0 100%;flex:0 0 100%;max-width:100%}.row-cols-xl-2>*{-ms-flex:0 0 50%;flex:0 0 50%;max-width:50%}.row-cols-xl-3>*{-ms-flex:0 0 33.3333%;flex:0 0 33.3333%;max-width:33.3333%}.row-cols-xl-4>*{-ms-flex:0 0 25%;flex:0 0 25%;max-width:25%}.row-cols-xl-5>*{-ms-flex:0 0 20%;flex:0 0 20%;max-width:20%}.row-cols-xl-6>*{-ms-flex:0 0 16.6667%;flex:0 0 16.6667%;max-width:16.6667%}.col-xl-auto{-ms-flex:none;flex:none;width:auto;max-width:100%}.col-xl-1{-ms-flex:0 0 8.33333%;flex:0 0 8.33333%;max-width:8.33333%}.col-xl-2{-ms-flex:0 0 16.6667%;flex:0 0 16.6667%;max-width:16.6667%}.col-xl-3{-ms-flex:0 0 25%;flex:0 0 25%;max-width:25%}.col-xl-4{-ms-flex:0 0 33.3333%;flex:0 0 33.3333%;max-width:33.3333%}.col-xl-5{-ms-flex:0 0 41.6667%;flex:0 0 41.6667%;max-width:41.6667%}.col-xl-6{-ms-flex:0 0 50%;flex:0 0 50%;max-width:50%}.col-xl-7{-ms-flex:0 0 58.3333%;flex:0 0 58.3333%;max-width:58.3333%}.col-xl-8{-ms-flex:0 0 66.6667%;flex:0 0 66.6667%;max-width:66.6667%}.col-xl-9{-ms-flex:0 0 75%;flex:0 0 75%;max-width:75%}.col-xl-10{-ms-flex:0 0 83.3333%;flex:0 0 83.3333%;max-width:83.3333%}.col-xl-11{-ms-flex:0 0 91.6667%;flex:0 0 91.6667%;max-width:91.6667%}.col-xl-12{-ms-flex:0 0 100%;flex:0 0 100%;max-width:100%}.order-xl-first{-ms-flex-order:-1;order:-1}.order-xl-last{-ms-flex-order:13;order:13}.order-xl-0{-ms-flex-order:0;order:0}.order-xl-1{-ms-flex-order:1;order:1}.order-xl-2{-ms-flex-order:2;order:2}.order-xl-3{-ms-flex-order:3;order:3}.order-xl-4{-ms-flex-order:4;order:4}.order-xl-5{-ms-flex-order:5;order:5}.order-xl-6{-ms-flex-order:6;order:6}.order-xl-7{-ms-flex-order:7;order:7}.order-xl-8{-ms-flex-order:8;order:8}.order-xl-9{-ms-flex-order:9;order:9}.order-xl-10{-ms-flex-order:10;order:10}.order-xl-11{-ms-flex-order:11;order:11}.order-xl-12{-ms-flex-order:12;order:12}.offset-xl-0{margin-left:0}.offset-xl-1{margin-left:8.33333%}.offset-xl-2{margin-left:16.6667%}.offset-xl-3{margin-left:25%}.offset-xl-4{margin-left:33.3333%}.offset-xl-5{margin-left:41.6667%}.offset-xl-6{margin-left:50%}.offset-xl-7{margin-left:58.3333%}.offset-xl-8{margin-left:66.6667%}.offset-xl-9{margin-left:75%}.offset-xl-10{margin-left:83.3333%}.offset-xl-11{margin-left:91.6667%}}.table{color:#212529;width:100%;margin-bottom:1rem}.table th,.table td{vertical-align:top;border-top:1px solid #dee2e6;padding:.75rem}.table thead th{vertical-align:bottom;border-bottom:2px solid #dee2e6}.table tbody+tbody{border-top:2px solid #dee2e6}.table-sm th,.table-sm td{padding:.3rem}.table-bordered,.table-bordered th,.table-bordered td{border:1px solid #dee2e6}.table-bordered thead th,.table-bordered thead td{border-bottom-width:2px}.table-borderless th,.table-borderless td,.table-borderless thead th,.table-borderless tbody+tbody{border:0}.table-striped tbody tr:nth-of-type(odd){background-color:#0000000d}.table-hover tbody tr:hover{color:#212529;background-color:#00000013}.table-primary,.table-primary>th,.table-primary>td{background-color:#b8daff}.table-primary th,.table-primary td,.table-primary thead th,.table-primary tbody+tbody{border-color:#7abaff}.table-hover .table-primary:hover,.table-hover .table-primary:hover>td,.table-hover .table-primary:hover>th{background-color:#9fcdff}.table-secondary,.table-secondary>th,.table-secondary>td{background-color:#d6d8db}.table-secondary th,.table-secondary td,.table-secondary thead th,.table-secondary tbody+tbody{border-color:#b3b7bb}.table-hover .table-secondary:hover,.table-hover .table-secondary:hover>td,.table-hover .table-secondary:hover>th{background-color:#c8cbcf}.table-success,.table-success>th,.table-success>td{background-color:#c3e6cb}.table-success th,.table-success td,.table-success thead th,.table-success tbody+tbody{border-color:#8fd19e}.table-hover .table-success:hover,.table-hover .table-success:hover>td,.table-hover .table-success:hover>th{background-color:#b1dfbb}.table-info,.table-info>th,.table-info>td{background-color:#bee5eb}.table-info th,.table-info td,.table-info thead th,.table-info tbody+tbody{border-color:#86cfda}.table-hover .table-info:hover,.table-hover .table-info:hover>td,.table-hover .table-info:hover>th{background-color:#abdde5}.table-warning,.table-warning>th,.table-warning>td{background-color:#ffeeba}.table-warning th,.table-warning td,.table-warning thead th,.table-warning tbody+tbody{border-color:#ffdf7e}.table-hover .table-warning:hover,.table-hover .table-warning:hover>td,.table-hover .table-warning:hover>th{background-color:#ffe8a1}.table-danger,.table-danger>th,.table-danger>td{background-color:#f5c6cb}.table-danger th,.table-danger td,.table-danger thead th,.table-danger tbody+tbody{border-color:#ed969e}.table-hover .table-danger:hover,.table-hover .table-danger:hover>td,.table-hover .table-danger:hover>th{background-color:#f1b0b7}.table-light,.table-light>th,.table-light>td{background-color:#fdfdfe}.table-light th,.table-light td,.table-light thead th,.table-light tbody+tbody{border-color:#fbfcfc}.table-hover .table-light:hover,.table-hover .table-light:hover>td,.table-hover .table-light:hover>th{background-color:#ececf6}.table-dark,.table-dark>th,.table-dark>td{background-color:#c6c8ca}.table-dark th,.table-dark td,.table-dark thead th,.table-dark tbody+tbody{border-color:#95999c}.table-hover .table-dark:hover,.table-hover .table-dark:hover>td,.table-hover .table-dark:hover>th{background-color:#b9bbbe}.table-active,.table-active>th,.table-active>td,.table-hover .table-active:hover,.table-hover .table-active:hover>td,.table-hover .table-active:hover>th{background-color:#00000013}.table .thead-dark th{color:#fff;background-color:#343a40;border-color:#454d55}.table .thead-light th{color:#495057;background-color:#e9ecef;border-color:#dee2e6}.table-dark{color:#fff;background-color:#343a40}.table-dark th,.table-dark td,.table-dark thead th{border-color:#454d55}.table-dark.table-bordered{border:0}.table-dark.table-striped tbody tr:nth-of-type(odd){background-color:#ffffff0d}.table-dark.table-hover tbody tr:hover{color:#fff;background-color:#ffffff13}@media (width<=575.98px){.table-responsive-sm{-webkit-overflow-scrolling:touch;width:100%;display:block;overflow-x:auto}.table-responsive-sm>.table-bordered{border:0}}@media (width<=767.98px){.table-responsive-md{-webkit-overflow-scrolling:touch;width:100%;display:block;overflow-x:auto}.table-responsive-md>.table-bordered{border:0}}@media (width<=991.98px){.table-responsive-lg{-webkit-overflow-scrolling:touch;width:100%;display:block;overflow-x:auto}.table-responsive-lg>.table-bordered{border:0}}@media (width<=1199.98px){.table-responsive-xl{-webkit-overflow-scrolling:touch;width:100%;display:block;overflow-x:auto}.table-responsive-xl>.table-bordered{border:0}}.table-responsive{-webkit-overflow-scrolling:touch;width:100%;display:block;overflow-x:auto}.table-responsive>.table-bordered{border:0}.form-control{color:#495057;background-color:#fff;background-clip:padding-box;border:1px solid #ced4da;border-radius:.25rem;width:100%;height:calc(1.5em + .75rem + 2px);padding:.375rem .75rem;font-size:1rem;font-weight:400;line-height:1.5;transition:border-color .15s ease-in-out,box-shadow .15s ease-in-out;display:block}@media (prefers-reduced-motion:reduce){.form-control{transition:none}}.form-control::-ms-expand{background-color:#0000;border:0}.form-control:focus{color:#495057;background-color:#fff;border-color:#80bdff;outline:0;box-shadow:0 0 0 .2rem #007bff40}.form-control::-webkit-input-placeholder{color:#6c757d;opacity:1}.form-control::placeholder{color:#6c757d;opacity:1}.form-control:-ms-input-placeholder{color:#6c757d;opacity:1}.form-control::-moz-placeholder{color:#6c757d;opacity:1}.form-control::placeholder{color:#6c757d;opacity:1}.form-control:disabled,.form-control[readonly]{opacity:1;background-color:#e9ecef}input[type=date].form-control,input[type=time].form-control,input[type=datetime-local].form-control,input[type=month].form-control{-webkit-appearance:none;-moz-appearance:none;appearance:none}select.form-control:-moz-focusring{color:#0000;text-shadow:0 0 #495057}select.form-control:focus::-ms-value{color:#495057;background-color:#fff}.form-control-file,.form-control-range{width:100%;display:block}.col-form-label{font-size:inherit;margin-bottom:0;padding-top:calc(.375rem + 1px);padding-bottom:calc(.375rem + 1px);line-height:1.5}.col-form-label-lg{padding-top:calc(.5rem + 1px);padding-bottom:calc(.5rem + 1px);font-size:1.25rem;line-height:1.5}.col-form-label-sm{padding-top:calc(.25rem + 1px);padding-bottom:calc(.25rem + 1px);font-size:.875rem;line-height:1.5}.form-control-plaintext{color:#212529;background-color:#0000;border:1px solid #0000;border-width:1px 0;width:100%;margin-bottom:0;padding:.375rem 0;font-size:1rem;line-height:1.5;display:block}.form-control-plaintext.form-control-sm,.form-control-plaintext.form-control-lg{padding-left:0;padding-right:0}.form-control-sm{border-radius:.2rem;height:calc(1.5em + .5rem + 2px);padding:.25rem .5rem;font-size:.875rem;line-height:1.5}.form-control-lg{border-radius:.3rem;height:calc(1.5em + 1rem + 2px);padding:.5rem 1rem;font-size:1.25rem;line-height:1.5}select.form-control[size],select.form-control[multiple],textarea.form-control{height:auto}.form-group{margin-bottom:1rem}.form-text{margin-top:.25rem;display:block}.form-row{-ms-flex-wrap:wrap;flex-wrap:wrap;margin-left:-5px;margin-right:-5px;display:-ms-flexbox;display:flex}.form-row>.col,.form-row>[class*=col-]{padding-left:5px;padding-right:5px}.form-check{padding-left:1.25rem;display:block;position:relative}.form-check-input{margin-top:.3rem;margin-left:-1.25rem;position:absolute}.form-check-input[disabled]~.form-check-label,.form-check-input:disabled~.form-check-label{color:#6c757d}.form-check-label{margin-bottom:0}.form-check-inline{align-items:center;margin-right:.75rem;padding-left:0;display:-ms-inline-flexbox;display:inline-flex}.form-check-inline .form-check-input{margin-top:0;margin-left:0;margin-right:.3125rem;position:static}.valid-feedback{color:#28a745;width:100%;margin-top:.25rem;font-size:80%;display:none}.valid-tooltip{z-index:5;color:#fff;background-color:#28a745e6;border-radius:.25rem;max-width:100%;margin-top:.1rem;padding:.25rem .5rem;font-size:.875rem;line-height:1.5;display:none;position:absolute;top:100%;left:0}.form-row>.col>.valid-tooltip,.form-row>[class*=col-]>.valid-tooltip{left:5px}.was-validated :valid~.valid-feedback,.was-validated :valid~.valid-tooltip,.is-valid~.valid-feedback,.is-valid~.valid-tooltip{display:block}.was-validated .form-control:valid,.form-control.is-valid{background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' width='8' height='8' viewBox='0 0 8 8'%3e%3cpath fill='%2328a745' d='M2.3 6.73L.6 4.53c-.4-1.04.46-1.4 1.1-.8l1.1 1.4 3.4-3.8c.6-.63 1.6-.27 1.2.7l-4 4.6c-.43.5-.8.4-1.1.1z'/%3e%3c/svg%3e");background-position:right calc(.375em + .1875rem) center;background-repeat:no-repeat;background-size:calc(.75em + .375rem) calc(.75em + .375rem);border-color:#28a745;padding-right:calc(1.5em + .75rem)!important}.was-validated .form-control:valid:focus,.form-control.is-valid:focus{border-color:#28a745;box-shadow:0 0 0 .2rem #28a74540}.was-validated select.form-control:valid,select.form-control.is-valid{background-position:right 1.5rem center;padding-right:3rem!important}.was-validated textarea.form-control:valid,textarea.form-control.is-valid{background-position:right calc(.375em + .1875rem) top calc(.375em + .1875rem);padding-right:calc(1.5em + .75rem)}.was-validated .custom-select:valid,.custom-select.is-valid{background:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' width='4' height='5' viewBox='0 0 4 5'%3e%3cpath fill='%23343a40' d='M2 0L0 2h4zm0 5L0 3h4z'/%3e%3c/svg%3e") right .75rem center/8px 10px no-repeat,#fff url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' width='8' height='8' viewBox='0 0 8 8'%3e%3cpath fill='%2328a745' d='M2.3 6.73L.6 4.53c-.4-1.04.46-1.4 1.1-.8l1.1 1.4 3.4-3.8c.6-.63 1.6-.27 1.2.7l-4 4.6c-.43.5-.8.4-1.1.1z'/%3e%3c/svg%3e") right 1.75rem center/calc(.75em + .375rem) calc(.75em + .375rem) no-repeat;border-color:#28a745;padding-right:calc(.75em + 2.3125rem)!important}.was-validated .custom-select:valid:focus,.custom-select.is-valid:focus{border-color:#28a745;box-shadow:0 0 0 .2rem #28a74540}.was-validated .form-check-input:valid~.form-check-label,.form-check-input.is-valid~.form-check-label{color:#28a745}.was-validated .form-check-input:valid~.valid-feedback,.was-validated .form-check-input:valid~.valid-tooltip,.form-check-input.is-valid~.valid-feedback,.form-check-input.is-valid~.valid-tooltip{display:block}.was-validated .custom-control-input:valid~.custom-control-label,.custom-control-input.is-valid~.custom-control-label{color:#28a745}.was-validated .custom-control-input:valid~.custom-control-label:before,.custom-control-input.is-valid~.custom-control-label:before{border-color:#28a745}.was-validated .custom-control-input:valid:checked~.custom-control-label:before,.custom-control-input.is-valid:checked~.custom-control-label:before{background-color:#34ce57;border-color:#34ce57}.was-validated .custom-control-input:valid:focus~.custom-control-label:before,.custom-control-input.is-valid:focus~.custom-control-label:before{box-shadow:0 0 0 .2rem #28a74540}.was-validated .custom-control-input:valid:focus:not(:checked)~.custom-control-label:before,.custom-control-input.is-valid:focus:not(:checked)~.custom-control-label:before,.was-validated .custom-file-input:valid~.custom-file-label,.custom-file-input.is-valid~.custom-file-label{border-color:#28a745}.was-validated .custom-file-input:valid:focus~.custom-file-label,.custom-file-input.is-valid:focus~.custom-file-label{border-color:#28a745;box-shadow:0 0 0 .2rem #28a74540}.invalid-feedback{color:#dc3545;width:100%;margin-top:.25rem;font-size:80%;display:none}.invalid-tooltip{z-index:5;color:#fff;background-color:#dc3545e6;border-radius:.25rem;max-width:100%;margin-top:.1rem;padding:.25rem .5rem;font-size:.875rem;line-height:1.5;display:none;position:absolute;top:100%;left:0}.form-row>.col>.invalid-tooltip,.form-row>[class*=col-]>.invalid-tooltip{left:5px}.was-validated :invalid~.invalid-feedback,.was-validated :invalid~.invalid-tooltip,.is-invalid~.invalid-feedback,.is-invalid~.invalid-tooltip{display:block}.was-validated .form-control:invalid,.form-control.is-invalid{background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' fill='none' stroke='%23dc3545' viewBox='0 0 12 12'%3e%3ccircle cx='6' cy='6' r='4.5'/%3e%3cpath stroke-linejoin='round' d='M5.8 3.6h.4L6 6.5z'/%3e%3ccircle cx='6' cy='8.2' r='.6' fill='%23dc3545' stroke='none'/%3e%3c/svg%3e");background-position:right calc(.375em + .1875rem) center;background-repeat:no-repeat;background-size:calc(.75em + .375rem) calc(.75em + .375rem);border-color:#dc3545;padding-right:calc(1.5em + .75rem)!important}.was-validated .form-control:invalid:focus,.form-control.is-invalid:focus{border-color:#dc3545;box-shadow:0 0 0 .2rem #dc354540}.was-validated select.form-control:invalid,select.form-control.is-invalid{background-position:right 1.5rem center;padding-right:3rem!important}.was-validated textarea.form-control:invalid,textarea.form-control.is-invalid{background-position:right calc(.375em + .1875rem) top calc(.375em + .1875rem);padding-right:calc(1.5em + .75rem)}.was-validated .custom-select:invalid,.custom-select.is-invalid{background:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' width='4' height='5' viewBox='0 0 4 5'%3e%3cpath fill='%23343a40' d='M2 0L0 2h4zm0 5L0 3h4z'/%3e%3c/svg%3e") right .75rem center/8px 10px no-repeat,#fff url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' fill='none' stroke='%23dc3545' viewBox='0 0 12 12'%3e%3ccircle cx='6' cy='6' r='4.5'/%3e%3cpath stroke-linejoin='round' d='M5.8 3.6h.4L6 6.5z'/%3e%3ccircle cx='6' cy='8.2' r='.6' fill='%23dc3545' stroke='none'/%3e%3c/svg%3e") right 1.75rem center/calc(.75em + .375rem) calc(.75em + .375rem) no-repeat;border-color:#dc3545;padding-right:calc(.75em + 2.3125rem)!important}.was-validated .custom-select:invalid:focus,.custom-select.is-invalid:focus{border-color:#dc3545;box-shadow:0 0 0 .2rem #dc354540}.was-validated .form-check-input:invalid~.form-check-label,.form-check-input.is-invalid~.form-check-label{color:#dc3545}.was-validated .form-check-input:invalid~.invalid-feedback,.was-validated .form-check-input:invalid~.invalid-tooltip,.form-check-input.is-invalid~.invalid-feedback,.form-check-input.is-invalid~.invalid-tooltip{display:block}.was-validated .custom-control-input:invalid~.custom-control-label,.custom-control-input.is-invalid~.custom-control-label{color:#dc3545}.was-validated .custom-control-input:invalid~.custom-control-label:before,.custom-control-input.is-invalid~.custom-control-label:before{border-color:#dc3545}.was-validated .custom-control-input:invalid:checked~.custom-control-label:before,.custom-control-input.is-invalid:checked~.custom-control-label:before{background-color:#e4606d;border-color:#e4606d}.was-validated .custom-control-input:invalid:focus~.custom-control-label:before,.custom-control-input.is-invalid:focus~.custom-control-label:before{box-shadow:0 0 0 .2rem #dc354540}.was-validated .custom-control-input:invalid:focus:not(:checked)~.custom-control-label:before,.custom-control-input.is-invalid:focus:not(:checked)~.custom-control-label:before,.was-validated .custom-file-input:invalid~.custom-file-label,.custom-file-input.is-invalid~.custom-file-label{border-color:#dc3545}.was-validated .custom-file-input:invalid:focus~.custom-file-label,.custom-file-input.is-invalid:focus~.custom-file-label{border-color:#dc3545;box-shadow:0 0 0 .2rem #dc354540}.form-inline{-ms-flex-flow:wrap;flex-flow:wrap;align-items:center;display:-ms-flexbox;display:flex}.form-inline .form-check{width:100%}@media (width>=576px){.form-inline label{justify-content:center;align-items:center;margin-bottom:0;display:-ms-flexbox;display:flex}.form-inline .form-group{-ms-flex-flow:wrap;flex-flow:wrap;-ms-flex:none;flex:none;align-items:center;margin-bottom:0;display:-ms-flexbox;display:flex}.form-inline .form-control{vertical-align:middle;width:auto;display:inline-block}.form-inline .form-control-plaintext{display:inline-block}.form-inline .input-group,.form-inline .custom-select{width:auto}.form-inline .form-check{justify-content:center;align-items:center;width:auto;padding-left:0;display:-ms-flexbox;display:flex}.form-inline .form-check-input{-ms-flex-negative:0;flex-shrink:0;margin-top:0;margin-left:0;margin-right:.25rem;position:relative}.form-inline .custom-control{justify-content:center;align-items:center}.form-inline .custom-control-label{margin-bottom:0}}.btn{color:#212529;text-align:center;vertical-align:middle;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;background-color:#0000;border:1px solid #0000;border-radius:.25rem;padding:.375rem .75rem;font-size:1rem;font-weight:400;line-height:1.5;transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;display:inline-block}@media (prefers-reduced-motion:reduce){.btn{transition:none}}.btn:hover{color:#212529;text-decoration:none}.btn:focus,.btn.focus{outline:0;box-shadow:0 0 0 .2rem #007bff40}.btn.disabled,.btn:disabled{opacity:.65}.btn:not(:disabled):not(.disabled){cursor:pointer}a.btn.disabled,fieldset:disabled a.btn{pointer-events:none}.btn-primary{color:#fff;background-color:#007bff;border-color:#007bff}.btn-primary:hover{color:#fff;background-color:#0069d9;border-color:#0062cc}.btn-primary:focus,.btn-primary.focus{color:#fff;background-color:#0069d9;border-color:#0062cc;box-shadow:0 0 0 .2rem #268fff80}.btn-primary.disabled,.btn-primary:disabled{color:#fff;background-color:#007bff;border-color:#007bff}.btn-primary:not(:disabled):not(.disabled):active,.btn-primary:not(:disabled):not(.disabled).active,.show>.btn-primary.dropdown-toggle{color:#fff;background-color:#0062cc;border-color:#005cbf}.btn-primary:not(:disabled):not(.disabled):active:focus,.btn-primary:not(:disabled):not(.disabled).active:focus,.show>.btn-primary.dropdown-toggle:focus{box-shadow:0 0 0 .2rem #268fff80}.btn-secondary{color:#fff;background-color:#6c757d;border-color:#6c757d}.btn-secondary:hover{color:#fff;background-color:#5a6268;border-color:#545b62}.btn-secondary:focus,.btn-secondary.focus{color:#fff;background-color:#5a6268;border-color:#545b62;box-shadow:0 0 0 .2rem #828a9180}.btn-secondary.disabled,.btn-secondary:disabled{color:#fff;background-color:#6c757d;border-color:#6c757d}.btn-secondary:not(:disabled):not(.disabled):active,.btn-secondary:not(:disabled):not(.disabled).active,.show>.btn-secondary.dropdown-toggle{color:#fff;background-color:#545b62;border-color:#4e555b}.btn-secondary:not(:disabled):not(.disabled):active:focus,.btn-secondary:not(:disabled):not(.disabled).active:focus,.show>.btn-secondary.dropdown-toggle:focus{box-shadow:0 0 0 .2rem #828a9180}.btn-success{color:#fff;background-color:#28a745;border-color:#28a745}.btn-success:hover{color:#fff;background-color:#218838;border-color:#1e7e34}.btn-success:focus,.btn-success.focus{color:#fff;background-color:#218838;border-color:#1e7e34;box-shadow:0 0 0 .2rem #48b46180}.btn-success.disabled,.btn-success:disabled{color:#fff;background-color:#28a745;border-color:#28a745}.btn-success:not(:disabled):not(.disabled):active,.btn-success:not(:disabled):not(.disabled).active,.show>.btn-success.dropdown-toggle{color:#fff;background-color:#1e7e34;border-color:#1c7430}.btn-success:not(:disabled):not(.disabled):active:focus,.btn-success:not(:disabled):not(.disabled).active:focus,.show>.btn-success.dropdown-toggle:focus{box-shadow:0 0 0 .2rem #48b46180}.btn-info{color:#fff;background-color:#17a2b8;border-color:#17a2b8}.btn-info:hover{color:#fff;background-color:#138496;border-color:#117a8b}.btn-info:focus,.btn-info.focus{color:#fff;background-color:#138496;border-color:#117a8b;box-shadow:0 0 0 .2rem #3ab0c380}.btn-info.disabled,.btn-info:disabled{color:#fff;background-color:#17a2b8;border-color:#17a2b8}.btn-info:not(:disabled):not(.disabled):active,.btn-info:not(:disabled):not(.disabled).active,.show>.btn-info.dropdown-toggle{color:#fff;background-color:#117a8b;border-color:#10707f}.btn-info:not(:disabled):not(.disabled):active:focus,.btn-info:not(:disabled):not(.disabled).active:focus,.show>.btn-info.dropdown-toggle:focus{box-shadow:0 0 0 .2rem #3ab0c380}.btn-warning{color:#212529;background-color:#ffc107;border-color:#ffc107}.btn-warning:hover{color:#212529;background-color:#e0a800;border-color:#d39e00}.btn-warning:focus,.btn-warning.focus{color:#212529;background-color:#e0a800;border-color:#d39e00;box-shadow:0 0 0 .2rem #deaa0c80}.btn-warning.disabled,.btn-warning:disabled{color:#212529;background-color:#ffc107;border-color:#ffc107}.btn-warning:not(:disabled):not(.disabled):active,.btn-warning:not(:disabled):not(.disabled).active,.show>.btn-warning.dropdown-toggle{color:#212529;background-color:#d39e00;border-color:#c69500}.btn-warning:not(:disabled):not(.disabled):active:focus,.btn-warning:not(:disabled):not(.disabled).active:focus,.show>.btn-warning.dropdown-toggle:focus{box-shadow:0 0 0 .2rem #deaa0c80}.btn-danger{color:#fff;background-color:#dc3545;border-color:#dc3545}.btn-danger:hover{color:#fff;background-color:#c82333;border-color:#bd2130}.btn-danger:focus,.btn-danger.focus{color:#fff;background-color:#c82333;border-color:#bd2130;box-shadow:0 0 0 .2rem #e1536180}.btn-danger.disabled,.btn-danger:disabled{color:#fff;background-color:#dc3545;border-color:#dc3545}.btn-danger:not(:disabled):not(.disabled):active,.btn-danger:not(:disabled):not(.disabled).active,.show>.btn-danger.dropdown-toggle{color:#fff;background-color:#bd2130;border-color:#b21f2d}.btn-danger:not(:disabled):not(.disabled):active:focus,.btn-danger:not(:disabled):not(.disabled).active:focus,.show>.btn-danger.dropdown-toggle:focus{box-shadow:0 0 0 .2rem #e1536180}.btn-light{color:#212529;background-color:#f8f9fa;border-color:#f8f9fa}.btn-light:hover{color:#212529;background-color:#e2e6ea;border-color:#dae0e5}.btn-light:focus,.btn-light.focus{color:#212529;background-color:#e2e6ea;border-color:#dae0e5;box-shadow:0 0 0 .2rem #d8d9db80}.btn-light.disabled,.btn-light:disabled{color:#212529;background-color:#f8f9fa;border-color:#f8f9fa}.btn-light:not(:disabled):not(.disabled):active,.btn-light:not(:disabled):not(.disabled).active,.show>.btn-light.dropdown-toggle{color:#212529;background-color:#dae0e5;border-color:#d3d9df}.btn-light:not(:disabled):not(.disabled):active:focus,.btn-light:not(:disabled):not(.disabled).active:focus,.show>.btn-light.dropdown-toggle:focus{box-shadow:0 0 0 .2rem #d8d9db80}.btn-dark{color:#fff;background-color:#343a40;border-color:#343a40}.btn-dark:hover{color:#fff;background-color:#23272b;border-color:#1d2124}.btn-dark:focus,.btn-dark.focus{color:#fff;background-color:#23272b;border-color:#1d2124;box-shadow:0 0 0 .2rem #52585d80}.btn-dark.disabled,.btn-dark:disabled{color:#fff;background-color:#343a40;border-color:#343a40}.btn-dark:not(:disabled):not(.disabled):active,.btn-dark:not(:disabled):not(.disabled).active,.show>.btn-dark.dropdown-toggle{color:#fff;background-color:#1d2124;border-color:#171a1d}.btn-dark:not(:disabled):not(.disabled):active:focus,.btn-dark:not(:disabled):not(.disabled).active:focus,.show>.btn-dark.dropdown-toggle:focus{box-shadow:0 0 0 .2rem #52585d80}.btn-outline-primary{color:#007bff;border-color:#007bff}.btn-outline-primary:hover{color:#fff;background-color:#007bff;border-color:#007bff}.btn-outline-primary:focus,.btn-outline-primary.focus{box-shadow:0 0 0 .2rem #007bff80}.btn-outline-primary.disabled,.btn-outline-primary:disabled{color:#007bff;background-color:#0000}.btn-outline-primary:not(:disabled):not(.disabled):active,.btn-outline-primary:not(:disabled):not(.disabled).active,.show>.btn-outline-primary.dropdown-toggle{color:#fff;background-color:#007bff;border-color:#007bff}.btn-outline-primary:not(:disabled):not(.disabled):active:focus,.btn-outline-primary:not(:disabled):not(.disabled).active:focus,.show>.btn-outline-primary.dropdown-toggle:focus{box-shadow:0 0 0 .2rem #007bff80}.btn-outline-secondary{color:#6c757d;border-color:#6c757d}.btn-outline-secondary:hover{color:#fff;background-color:#6c757d;border-color:#6c757d}.btn-outline-secondary:focus,.btn-outline-secondary.focus{box-shadow:0 0 0 .2rem #6c757d80}.btn-outline-secondary.disabled,.btn-outline-secondary:disabled{color:#6c757d;background-color:#0000}.btn-outline-secondary:not(:disabled):not(.disabled):active,.btn-outline-secondary:not(:disabled):not(.disabled).active,.show>.btn-outline-secondary.dropdown-toggle{color:#fff;background-color:#6c757d;border-color:#6c757d}.btn-outline-secondary:not(:disabled):not(.disabled):active:focus,.btn-outline-secondary:not(:disabled):not(.disabled).active:focus,.show>.btn-outline-secondary.dropdown-toggle:focus{box-shadow:0 0 0 .2rem #6c757d80}.btn-outline-success{color:#28a745;border-color:#28a745}.btn-outline-success:hover{color:#fff;background-color:#28a745;border-color:#28a745}.btn-outline-success:focus,.btn-outline-success.focus{box-shadow:0 0 0 .2rem #28a74580}.btn-outline-success.disabled,.btn-outline-success:disabled{color:#28a745;background-color:#0000}.btn-outline-success:not(:disabled):not(.disabled):active,.btn-outline-success:not(:disabled):not(.disabled).active,.show>.btn-outline-success.dropdown-toggle{color:#fff;background-color:#28a745;border-color:#28a745}.btn-outline-success:not(:disabled):not(.disabled):active:focus,.btn-outline-success:not(:disabled):not(.disabled).active:focus,.show>.btn-outline-success.dropdown-toggle:focus{box-shadow:0 0 0 .2rem #28a74580}.btn-outline-info{color:#17a2b8;border-color:#17a2b8}.btn-outline-info:hover{color:#fff;background-color:#17a2b8;border-color:#17a2b8}.btn-outline-info:focus,.btn-outline-info.focus{box-shadow:0 0 0 .2rem #17a2b880}.btn-outline-info.disabled,.btn-outline-info:disabled{color:#17a2b8;background-color:#0000}.btn-outline-info:not(:disabled):not(.disabled):active,.btn-outline-info:not(:disabled):not(.disabled).active,.show>.btn-outline-info.dropdown-toggle{color:#fff;background-color:#17a2b8;border-color:#17a2b8}.btn-outline-info:not(:disabled):not(.disabled):active:focus,.btn-outline-info:not(:disabled):not(.disabled).active:focus,.show>.btn-outline-info.dropdown-toggle:focus{box-shadow:0 0 0 .2rem #17a2b880}.btn-outline-warning{color:#ffc107;border-color:#ffc107}.btn-outline-warning:hover{color:#212529;background-color:#ffc107;border-color:#ffc107}.btn-outline-warning:focus,.btn-outline-warning.focus{box-shadow:0 0 0 .2rem #ffc10780}.btn-outline-warning.disabled,.btn-outline-warning:disabled{color:#ffc107;background-color:#0000}.btn-outline-warning:not(:disabled):not(.disabled):active,.btn-outline-warning:not(:disabled):not(.disabled).active,.show>.btn-outline-warning.dropdown-toggle{color:#212529;background-color:#ffc107;border-color:#ffc107}.btn-outline-warning:not(:disabled):not(.disabled):active:focus,.btn-outline-warning:not(:disabled):not(.disabled).active:focus,.show>.btn-outline-warning.dropdown-toggle:focus{box-shadow:0 0 0 .2rem #ffc10780}.btn-outline-danger{color:#dc3545;border-color:#dc3545}.btn-outline-danger:hover{color:#fff;background-color:#dc3545;border-color:#dc3545}.btn-outline-danger:focus,.btn-outline-danger.focus{box-shadow:0 0 0 .2rem #dc354580}.btn-outline-danger.disabled,.btn-outline-danger:disabled{color:#dc3545;background-color:#0000}.btn-outline-danger:not(:disabled):not(.disabled):active,.btn-outline-danger:not(:disabled):not(.disabled).active,.show>.btn-outline-danger.dropdown-toggle{color:#fff;background-color:#dc3545;border-color:#dc3545}.btn-outline-danger:not(:disabled):not(.disabled):active:focus,.btn-outline-danger:not(:disabled):not(.disabled).active:focus,.show>.btn-outline-danger.dropdown-toggle:focus{box-shadow:0 0 0 .2rem #dc354580}.btn-outline-light{color:#f8f9fa;border-color:#f8f9fa}.btn-outline-light:hover{color:#212529;background-color:#f8f9fa;border-color:#f8f9fa}.btn-outline-light:focus,.btn-outline-light.focus{box-shadow:0 0 0 .2rem #f8f9fa80}.btn-outline-light.disabled,.btn-outline-light:disabled{color:#f8f9fa;background-color:#0000}.btn-outline-light:not(:disabled):not(.disabled):active,.btn-outline-light:not(:disabled):not(.disabled).active,.show>.btn-outline-light.dropdown-toggle{color:#212529;background-color:#f8f9fa;border-color:#f8f9fa}.btn-outline-light:not(:disabled):not(.disabled):active:focus,.btn-outline-light:not(:disabled):not(.disabled).active:focus,.show>.btn-outline-light.dropdown-toggle:focus{box-shadow:0 0 0 .2rem #f8f9fa80}.btn-outline-dark{color:#343a40;border-color:#343a40}.btn-outline-dark:hover{color:#fff;background-color:#343a40;border-color:#343a40}.btn-outline-dark:focus,.btn-outline-dark.focus{box-shadow:0 0 0 .2rem #343a4080}.btn-outline-dark.disabled,.btn-outline-dark:disabled{color:#343a40;background-color:#0000}.btn-outline-dark:not(:disabled):not(.disabled):active,.btn-outline-dark:not(:disabled):not(.disabled).active,.show>.btn-outline-dark.dropdown-toggle{color:#fff;background-color:#343a40;border-color:#343a40}.btn-outline-dark:not(:disabled):not(.disabled):active:focus,.btn-outline-dark:not(:disabled):not(.disabled).active:focus,.show>.btn-outline-dark.dropdown-toggle:focus{box-shadow:0 0 0 .2rem #343a4080}.btn-link{color:#007bff;font-weight:400;text-decoration:none}.btn-link:hover{color:#0056b3;text-decoration:underline}.btn-link:focus,.btn-link.focus{text-decoration:underline}.btn-link:disabled,.btn-link.disabled{color:#6c757d;pointer-events:none}.btn-lg,.btn-group-lg>.btn{border-radius:.3rem;padding:.5rem 1rem;font-size:1.25rem;line-height:1.5}.btn-sm,.btn-group-sm>.btn{border-radius:.2rem;padding:.25rem .5rem;font-size:.875rem;line-height:1.5}.btn-block{width:100%;display:block}.btn-block+.btn-block{margin-top:.5rem}input[type=submit].btn-block,input[type=reset].btn-block,input[type=button].btn-block{width:100%}.fade{transition:opacity .15s linear}@media (prefers-reduced-motion:reduce){.fade{transition:none}}.fade:not(.show){opacity:0}.collapse:not(.show){display:none}.collapsing{height:0;transition:height .35s;position:relative;overflow:hidden}@media (prefers-reduced-motion:reduce){.collapsing{transition:none}}.dropup,.dropright,.dropdown,.dropleft{position:relative}.dropdown-toggle{white-space:nowrap}.dropdown-toggle:after{vertical-align:.255em;content:"";border:.3em solid #0000;border-top-color:currentColor;border-bottom:0;margin-left:.255em;display:inline-block}.dropdown-toggle:empty:after{margin-left:0}.dropdown-menu{z-index:1000;float:left;color:#212529;text-align:left;background-color:#fff;background-clip:padding-box;border:1px solid #00000026;border-radius:.25rem;min-width:10rem;margin:.125rem 0 0;padding:.5rem 0;font-size:1rem;list-style:none;display:none;position:absolute;top:100%;left:0}.dropdown-menu-left{left:0;right:auto}.dropdown-menu-right{left:auto;right:0}@media (width>=576px){.dropdown-menu-sm-left{left:0;right:auto}.dropdown-menu-sm-right{left:auto;right:0}}@media (width>=768px){.dropdown-menu-md-left{left:0;right:auto}.dropdown-menu-md-right{left:auto;right:0}}@media (width>=992px){.dropdown-menu-lg-left{left:0;right:auto}.dropdown-menu-lg-right{left:auto;right:0}}@media (width>=1200px){.dropdown-menu-xl-left{left:0;right:auto}.dropdown-menu-xl-right{left:auto;right:0}}.dropup .dropdown-menu{margin-top:0;margin-bottom:.125rem;top:auto;bottom:100%}.dropup .dropdown-toggle:after{vertical-align:.255em;content:"";border:.3em solid #0000;border-top:0;border-bottom-color:currentColor;margin-left:.255em;display:inline-block}.dropup .dropdown-toggle:empty:after{margin-left:0}.dropright .dropdown-menu{margin-top:0;margin-left:.125rem;top:0;left:100%;right:auto}.dropright .dropdown-toggle:after{vertical-align:.255em;content:"";border:.3em solid #0000;border-left-color:currentColor;border-right:0;margin-left:.255em;display:inline-block}.dropright .dropdown-toggle:empty:after{margin-left:0}.dropright .dropdown-toggle:after{vertical-align:0}.dropleft .dropdown-menu{margin-top:0;margin-right:.125rem;top:0;left:auto;right:100%}.dropleft .dropdown-toggle:after{vertical-align:.255em;content:"";margin-left:.255em;display:none}.dropleft .dropdown-toggle:before{vertical-align:.255em;content:"";border-top:.3em solid #0000;border-bottom:.3em solid #0000;border-right:.3em solid;margin-right:.255em;display:inline-block}.dropleft .dropdown-toggle:empty:after{margin-left:0}.dropleft .dropdown-toggle:before{vertical-align:0}.dropdown-menu[x-placement^=top],.dropdown-menu[x-placement^=right],.dropdown-menu[x-placement^=bottom],.dropdown-menu[x-placement^=left]{bottom:auto;right:auto}.dropdown-divider{border-top:1px solid #e9ecef;height:0;margin:.5rem 0;overflow:hidden}.dropdown-item{clear:both;color:#212529;text-align:inherit;white-space:nowrap;background-color:#0000;border:0;width:100%;padding:.25rem 1.5rem;font-weight:400;display:block}.dropdown-item:hover,.dropdown-item:focus{color:#16181b;background-color:#e9ecef;text-decoration:none}.dropdown-item.active,.dropdown-item:active{color:#fff;background-color:#007bff;text-decoration:none}.dropdown-item.disabled,.dropdown-item:disabled{color:#adb5bd;pointer-events:none;background-color:#0000}.dropdown-menu.show{display:block}.dropdown-header{color:#6c757d;white-space:nowrap;margin-bottom:0;padding:.5rem 1.5rem;font-size:.875rem;display:block}.dropdown-item-text{color:#212529;padding:.25rem 1.5rem;display:block}.btn-group,.btn-group-vertical{vertical-align:middle;display:-ms-inline-flexbox;display:inline-flex;position:relative}.btn-group>.btn,.btn-group-vertical>.btn{-ms-flex:auto;flex:auto;position:relative}.btn-group>.btn:hover,.btn-group-vertical>.btn:hover,.btn-group>.btn:focus,.btn-group>.btn:active,.btn-group>.btn.active,.btn-group-vertical>.btn:focus,.btn-group-vertical>.btn:active,.btn-group-vertical>.btn.active{z-index:1}.btn-toolbar{-ms-flex-wrap:wrap;flex-wrap:wrap;justify-content:flex-start;display:-ms-flexbox;display:flex}.btn-toolbar .input-group{width:auto}.btn-group>.btn:not(:first-child),.btn-group>.btn-group:not(:first-child){margin-left:-1px}.btn-group>.btn:not(:last-child):not(.dropdown-toggle),.btn-group>.btn-group:not(:last-child)>.btn{border-top-right-radius:0;border-bottom-right-radius:0}.btn-group>.btn:not(:first-child),.btn-group>.btn-group:not(:first-child)>.btn{border-top-left-radius:0;border-bottom-left-radius:0}.dropdown-toggle-split{padding-left:.5625rem;padding-right:.5625rem}.dropdown-toggle-split:after,.dropup .dropdown-toggle-split:after,.dropright .dropdown-toggle-split:after{margin-left:0}.dropleft .dropdown-toggle-split:before{margin-right:0}.btn-sm+.dropdown-toggle-split,.btn-group-sm>.btn+.dropdown-toggle-split{padding-left:.375rem;padding-right:.375rem}.btn-lg+.dropdown-toggle-split,.btn-group-lg>.btn+.dropdown-toggle-split{padding-left:.75rem;padding-right:.75rem}.btn-group-vertical{-ms-flex-direction:column;flex-direction:column;justify-content:center;align-items:flex-start}.btn-group-vertical>.btn,.btn-group-vertical>.btn-group{width:100%}.btn-group-vertical>.btn:not(:first-child),.btn-group-vertical>.btn-group:not(:first-child){margin-top:-1px}.btn-group-vertical>.btn:not(:last-child):not(.dropdown-toggle),.btn-group-vertical>.btn-group:not(:last-child)>.btn{border-bottom-right-radius:0;border-bottom-left-radius:0}.btn-group-vertical>.btn:not(:first-child),.btn-group-vertical>.btn-group:not(:first-child)>.btn{border-top-left-radius:0;border-top-right-radius:0}.btn-group-toggle>.btn,.btn-group-toggle>.btn-group>.btn{margin-bottom:0}.btn-group-toggle>.btn input[type=radio],.btn-group-toggle>.btn input[type=checkbox],.btn-group-toggle>.btn-group>.btn input[type=radio],.btn-group-toggle>.btn-group>.btn input[type=checkbox]{clip:rect(0,0,0,0);pointer-events:none;position:absolute}.input-group{-ms-flex-wrap:wrap;flex-wrap:wrap;align-items:stretch;width:100%;display:-ms-flexbox;display:flex;position:relative}.input-group>.form-control,.input-group>.form-control-plaintext,.input-group>.custom-select,.input-group>.custom-file{-ms-flex:auto;flex:auto;width:1%;min-width:0;margin-bottom:0;position:relative}.input-group>.form-control+.form-control,.input-group>.form-control+.custom-select,.input-group>.form-control+.custom-file,.input-group>.form-control-plaintext+.form-control,.input-group>.form-control-plaintext+.custom-select,.input-group>.form-control-plaintext+.custom-file,.input-group>.custom-select+.form-control,.input-group>.custom-select+.custom-select,.input-group>.custom-select+.custom-file,.input-group>.custom-file+.form-control,.input-group>.custom-file+.custom-select,.input-group>.custom-file+.custom-file{margin-left:-1px}.input-group>.form-control:focus,.input-group>.custom-select:focus,.input-group>.custom-file .custom-file-input:focus~.custom-file-label{z-index:3}.input-group>.custom-file .custom-file-input:focus{z-index:4}.input-group>.form-control:not(:first-child),.input-group>.custom-select:not(:first-child){border-top-left-radius:0;border-bottom-left-radius:0}.input-group>.custom-file{align-items:center;display:-ms-flexbox;display:flex}.input-group>.custom-file:not(:last-child) .custom-file-label,.input-group>.custom-file:not(:last-child) .custom-file-label:after{border-top-right-radius:0;border-bottom-right-radius:0}.input-group>.custom-file:not(:first-child) .custom-file-label{border-top-left-radius:0;border-bottom-left-radius:0}.input-group:not(.has-validation)>.form-control:not(:last-child),.input-group:not(.has-validation)>.custom-select:not(:last-child),.input-group:not(.has-validation)>.custom-file:not(:last-child) .custom-file-label,.input-group:not(.has-validation)>.custom-file:not(:last-child) .custom-file-label:after,.input-group.has-validation>.form-control:nth-last-child(n+3),.input-group.has-validation>.custom-select:nth-last-child(n+3),.input-group.has-validation>.custom-file:nth-last-child(n+3) .custom-file-label,.input-group.has-validation>.custom-file:nth-last-child(n+3) .custom-file-label:after{border-top-right-radius:0;border-bottom-right-radius:0}.input-group-prepend,.input-group-append{display:-ms-flexbox;display:flex}.input-group-prepend .btn,.input-group-append .btn{z-index:2;position:relative}.input-group-prepend .btn:focus,.input-group-append .btn:focus{z-index:3}.input-group-prepend .btn+.btn,.input-group-prepend .btn+.input-group-text,.input-group-prepend .input-group-text+.input-group-text,.input-group-prepend .input-group-text+.btn,.input-group-append .btn+.btn,.input-group-append .btn+.input-group-text,.input-group-append .input-group-text+.input-group-text,.input-group-append .input-group-text+.btn{margin-left:-1px}.input-group-prepend{margin-right:-1px}.input-group-append{margin-left:-1px}.input-group-text{color:#495057;text-align:center;white-space:nowrap;background-color:#e9ecef;border:1px solid #ced4da;border-radius:.25rem;align-items:center;margin-bottom:0;padding:.375rem .75rem;font-size:1rem;font-weight:400;line-height:1.5;display:-ms-flexbox;display:flex}.input-group-text input[type=radio],.input-group-text input[type=checkbox]{margin-top:0}.input-group-lg>.form-control:not(textarea),.input-group-lg>.custom-select{height:calc(1.5em + 1rem + 2px)}.input-group-lg>.form-control,.input-group-lg>.custom-select,.input-group-lg>.input-group-prepend>.input-group-text,.input-group-lg>.input-group-append>.input-group-text,.input-group-lg>.input-group-prepend>.btn,.input-group-lg>.input-group-append>.btn{border-radius:.3rem;padding:.5rem 1rem;font-size:1.25rem;line-height:1.5}.input-group-sm>.form-control:not(textarea),.input-group-sm>.custom-select{height:calc(1.5em + .5rem + 2px)}.input-group-sm>.form-control,.input-group-sm>.custom-select,.input-group-sm>.input-group-prepend>.input-group-text,.input-group-sm>.input-group-append>.input-group-text,.input-group-sm>.input-group-prepend>.btn,.input-group-sm>.input-group-append>.btn{border-radius:.2rem;padding:.25rem .5rem;font-size:.875rem;line-height:1.5}.input-group-lg>.custom-select,.input-group-sm>.custom-select{padding-right:1.75rem}.input-group>.input-group-prepend>.btn,.input-group>.input-group-prepend>.input-group-text,.input-group:not(.has-validation)>.input-group-append:not(:last-child)>.btn,.input-group:not(.has-validation)>.input-group-append:not(:last-child)>.input-group-text,.input-group.has-validation>.input-group-append:nth-last-child(n+3)>.btn,.input-group.has-validation>.input-group-append:nth-last-child(n+3)>.input-group-text,.input-group>.input-group-append:last-child>.btn:not(:last-child):not(.dropdown-toggle),.input-group>.input-group-append:last-child>.input-group-text:not(:last-child){border-top-right-radius:0;border-bottom-right-radius:0}.input-group>.input-group-append>.btn,.input-group>.input-group-append>.input-group-text,.input-group>.input-group-prepend:not(:first-child)>.btn,.input-group>.input-group-prepend:not(:first-child)>.input-group-text,.input-group>.input-group-prepend:first-child>.btn:not(:first-child),.input-group>.input-group-prepend:first-child>.input-group-text:not(:first-child){border-top-left-radius:0;border-bottom-left-radius:0}.custom-control{z-index:1;-webkit-print-color-adjust:exact;color-adjust:exact;min-height:1.5rem;padding-left:1.5rem;display:block;position:relative}.custom-control-inline{margin-right:1rem;display:-ms-inline-flexbox;display:inline-flex}.custom-control-input{z-index:-1;opacity:0;width:1rem;height:1.25rem;position:absolute;left:0}.custom-control-input:checked~.custom-control-label:before{color:#fff;background-color:#007bff;border-color:#007bff}.custom-control-input:focus~.custom-control-label:before{box-shadow:0 0 0 .2rem #007bff40}.custom-control-input:focus:not(:checked)~.custom-control-label:before{border-color:#80bdff}.custom-control-input:not(:disabled):active~.custom-control-label:before{color:#fff;background-color:#b3d7ff;border-color:#b3d7ff}.custom-control-input[disabled]~.custom-control-label,.custom-control-input:disabled~.custom-control-label{color:#6c757d}.custom-control-input[disabled]~.custom-control-label:before,.custom-control-input:disabled~.custom-control-label:before{background-color:#e9ecef}.custom-control-label{vertical-align:top;margin-bottom:0;position:relative}.custom-control-label:before{pointer-events:none;content:"";background-color:#fff;border:1px solid #adb5bd;width:1rem;height:1rem;display:block;position:absolute;top:.25rem;left:-1.5rem}.custom-control-label:after{content:"";background:50%/50% 50% no-repeat;width:1rem;height:1rem;display:block;position:absolute;top:.25rem;left:-1.5rem}.custom-checkbox .custom-control-label:before{border-radius:.25rem}.custom-checkbox .custom-control-input:checked~.custom-control-label:after{background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' width='8' height='8' viewBox='0 0 8 8'%3e%3cpath fill='%23fff' d='M6.564.75l-3.59 3.612-1.538-1.55L0 4.26l2.974 2.99L8 2.193z'/%3e%3c/svg%3e")}.custom-checkbox .custom-control-input:indeterminate~.custom-control-label:before{background-color:#007bff;border-color:#007bff}.custom-checkbox .custom-control-input:indeterminate~.custom-control-label:after{background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' width='4' height='4' viewBox='0 0 4 4'%3e%3cpath stroke='%23fff' d='M0 2h4'/%3e%3c/svg%3e")}.custom-checkbox .custom-control-input:disabled:checked~.custom-control-label:before,.custom-checkbox .custom-control-input:disabled:indeterminate~.custom-control-label:before{background-color:#007bff80}.custom-radio .custom-control-label:before{border-radius:50%}.custom-radio .custom-control-input:checked~.custom-control-label:after{background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' viewBox='-4 -4 8 8'%3e%3ccircle r='3' fill='%23fff'/%3e%3c/svg%3e")}.custom-radio .custom-control-input:disabled:checked~.custom-control-label:before{background-color:#007bff80}.custom-switch{padding-left:2.25rem}.custom-switch .custom-control-label:before{pointer-events:all;border-radius:.5rem;width:1.75rem;left:-2.25rem}.custom-switch .custom-control-label:after{background-color:#adb5bd;border-radius:.5rem;width:calc(1rem - 4px);height:calc(1rem - 4px);transition:transform .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out,-webkit-transform .15s ease-in-out;top:calc(.25rem + 2px);left:calc(2px - 2.25rem)}@media (prefers-reduced-motion:reduce){.custom-switch .custom-control-label:after{transition:none}}.custom-switch .custom-control-input:checked~.custom-control-label:after{background-color:#fff;-webkit-transform:translate(.75rem);transform:translate(.75rem)}.custom-switch .custom-control-input:disabled:checked~.custom-control-label:before{background-color:#007bff80}.custom-select{color:#495057;vertical-align:middle;-webkit-appearance:none;-moz-appearance:none;appearance:none;background:#fff url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' width='4' height='5' viewBox='0 0 4 5'%3e%3cpath fill='%23343a40' d='M2 0L0 2h4zm0 5L0 3h4z'/%3e%3c/svg%3e") right .75rem center/8px 10px no-repeat;border:1px solid #ced4da;border-radius:.25rem;width:100%;height:calc(1.5em + .75rem + 2px);padding:.375rem 1.75rem .375rem .75rem;font-size:1rem;font-weight:400;line-height:1.5;display:inline-block}.custom-select:focus{border-color:#80bdff;outline:0;box-shadow:0 0 0 .2rem #007bff40}.custom-select:focus::-ms-value{color:#495057;background-color:#fff}.custom-select[multiple],.custom-select[size]:not([size="1"]){background-image:none;height:auto;padding-right:.75rem}.custom-select:disabled{color:#6c757d;background-color:#e9ecef}.custom-select::-ms-expand{display:none}.custom-select:-moz-focusring{color:#0000;text-shadow:0 0 #495057}.custom-select-sm{height:calc(1.5em + .5rem + 2px);padding-top:.25rem;padding-bottom:.25rem;padding-left:.5rem;font-size:.875rem}.custom-select-lg{height:calc(1.5em + 1rem + 2px);padding-top:.5rem;padding-bottom:.5rem;padding-left:1rem;font-size:1.25rem}.custom-file{width:100%;height:calc(1.5em + .75rem + 2px);margin-bottom:0;display:inline-block;position:relative}.custom-file-input{z-index:2;opacity:0;width:100%;height:calc(1.5em + .75rem + 2px);margin:0;position:relative;overflow:hidden}.custom-file-input:focus~.custom-file-label{border-color:#80bdff;box-shadow:0 0 0 .2rem #007bff40}.custom-file-input[disabled]~.custom-file-label,.custom-file-input:disabled~.custom-file-label{background-color:#e9ecef}.custom-file-input:lang(en)~.custom-file-label:after{content:"Browse"}.custom-file-input~.custom-file-label[data-browse]:after{content:attr(data-browse)}.custom-file-label{z-index:1;color:#495057;background-color:#fff;border:1px solid #ced4da;border-radius:.25rem;height:calc(1.5em + .75rem + 2px);padding:.375rem .75rem;font-weight:400;line-height:1.5;position:absolute;top:0;left:0;right:0;overflow:hidden}.custom-file-label:after{z-index:3;color:#495057;content:"Browse";border-left:inherit;background-color:#e9ecef;border-radius:0 .25rem .25rem 0;height:calc(1.5em + .75rem);padding:.375rem .75rem;line-height:1.5;display:block;position:absolute;top:0;bottom:0;right:0}.custom-range{-webkit-appearance:none;-moz-appearance:none;appearance:none;background-color:#0000;width:100%;height:1.4rem;padding:0}.custom-range:focus{outline:0}.custom-range:focus::-webkit-slider-thumb{box-shadow:0 0 0 1px #fff,0 0 0 .2rem #007bff40}.custom-range:focus::-moz-range-thumb{box-shadow:0 0 0 1px #fff,0 0 0 .2rem #007bff40}.custom-range:focus::-ms-thumb{box-shadow:0 0 0 1px #fff,0 0 0 .2rem #007bff40}.custom-range::-moz-focus-outer{border:0}.custom-range::-webkit-slider-thumb{-webkit-appearance:none;appearance:none;background-color:#007bff;border:0;border-radius:1rem;width:1rem;height:1rem;margin-top:-.25rem;-webkit-transition:background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;transition:background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out}@media (prefers-reduced-motion:reduce){.custom-range::-webkit-slider-thumb{-webkit-transition:none;transition:none}}.custom-range::-webkit-slider-thumb:active{background-color:#b3d7ff}.custom-range::-webkit-slider-runnable-track{color:#0000;cursor:pointer;background-color:#dee2e6;border-color:#0000;border-radius:1rem;width:100%;height:.5rem}.custom-range::-moz-range-thumb{-moz-appearance:none;appearance:none;background-color:#007bff;border:0;border-radius:1rem;width:1rem;height:1rem;-moz-transition:background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;transition:background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out}@media (prefers-reduced-motion:reduce){.custom-range::-moz-range-thumb{-moz-transition:none;transition:none}}.custom-range::-moz-range-thumb:active{background-color:#b3d7ff}.custom-range::-moz-range-track{color:#0000;cursor:pointer;background-color:#dee2e6;border-color:#0000;border-radius:1rem;width:100%;height:.5rem}.custom-range::-ms-thumb{appearance:none;background-color:#007bff;border:0;border-radius:1rem;width:1rem;height:1rem;margin-top:0;margin-left:.2rem;margin-right:.2rem;-ms-transition:background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;transition:background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out}@media (prefers-reduced-motion:reduce){.custom-range::-ms-thumb{-ms-transition:none;transition:none}}.custom-range::-ms-thumb:active{background-color:#b3d7ff}.custom-range::-ms-track{color:#0000;cursor:pointer;background-color:#0000;border-width:.5rem;border-color:#0000;width:100%;height:.5rem}.custom-range::-ms-fill-lower{background-color:#dee2e6;border-radius:1rem}.custom-range::-ms-fill-upper{background-color:#dee2e6;border-radius:1rem;margin-right:15px}.custom-range:disabled::-webkit-slider-thumb{background-color:#adb5bd}.custom-range:disabled::-webkit-slider-runnable-track{cursor:default}.custom-range:disabled::-moz-range-thumb{background-color:#adb5bd}.custom-range:disabled::-moz-range-track{cursor:default}.custom-range:disabled::-ms-thumb{background-color:#adb5bd}.custom-control-label:before,.custom-file-label,.custom-select{transition:background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out}@media (prefers-reduced-motion:reduce){.custom-control-label:before,.custom-file-label,.custom-select{transition:none}}.nav{-ms-flex-wrap:wrap;flex-wrap:wrap;margin-bottom:0;padding-left:0;list-style:none;display:-ms-flexbox;display:flex}.nav-link{padding:.5rem 1rem;display:block}.nav-link:hover,.nav-link:focus{text-decoration:none}.nav-link.disabled{color:#6c757d;pointer-events:none;cursor:default}.nav-tabs{border-bottom:1px solid #dee2e6}.nav-tabs .nav-link{border:1px solid #0000;border-top-left-radius:.25rem;border-top-right-radius:.25rem;margin-bottom:-1px}.nav-tabs .nav-link:hover,.nav-tabs .nav-link:focus{border-color:#e9ecef #e9ecef #dee2e6}.nav-tabs .nav-link.disabled{color:#6c757d;background-color:#0000;border-color:#0000}.nav-tabs .nav-link.active,.nav-tabs .nav-item.show .nav-link{color:#495057;background-color:#fff;border-color:#dee2e6 #dee2e6 #fff}.nav-tabs .dropdown-menu{border-top-left-radius:0;border-top-right-radius:0;margin-top:-1px}.nav-pills .nav-link{border-radius:.25rem}.nav-pills .nav-link.active,.nav-pills .show>.nav-link{color:#fff;background-color:#007bff}.nav-fill>.nav-link,.nav-fill .nav-item{text-align:center;-ms-flex:auto;flex:auto}.nav-justified>.nav-link,.nav-justified .nav-item{text-align:center;-ms-flex-positive:1;-ms-flex-preferred-size:0;flex-grow:1;flex-basis:0}.tab-content>.tab-pane{display:none}.tab-content>.active{display:block}.navbar{-ms-flex-wrap:wrap;flex-wrap:wrap;justify-content:space-between;align-items:center;padding:.5rem 1rem;display:-ms-flexbox;display:flex;position:relative}.navbar .container,.navbar .container-fluid,.navbar .container-sm,.navbar .container-md,.navbar .container-lg,.navbar .container-xl{-ms-flex-wrap:wrap;flex-wrap:wrap;justify-content:space-between;align-items:center;display:-ms-flexbox;display:flex}.navbar-brand{font-size:1.25rem;line-height:inherit;white-space:nowrap;margin-right:1rem;padding-top:.3125rem;padding-bottom:.3125rem;display:inline-block}.navbar-brand:hover,.navbar-brand:focus{text-decoration:none}.navbar-nav{-ms-flex-direction:column;flex-direction:column;margin-bottom:0;padding-left:0;list-style:none;display:-ms-flexbox;display:flex}.navbar-nav .nav-link{padding-left:0;padding-right:0}.navbar-nav .dropdown-menu{float:none;position:static}.navbar-text{padding-top:.5rem;padding-bottom:.5rem;display:inline-block}.navbar-collapse{-ms-flex-positive:1;-ms-flex-preferred-size:100%;flex-grow:1;flex-basis:100%;align-items:center}.navbar-toggler{background-color:#0000;border:1px solid #0000;border-radius:.25rem;padding:.25rem .75rem;font-size:1.25rem;line-height:1}.navbar-toggler:hover,.navbar-toggler:focus{text-decoration:none}.navbar-toggler-icon{vertical-align:middle;content:"";background:50%/100% 100% no-repeat;width:1.5em;height:1.5em;display:inline-block}.navbar-nav-scroll{max-height:75vh;overflow-y:auto}@media (width<=575.98px){.navbar-expand-sm>.container,.navbar-expand-sm>.container-fluid,.navbar-expand-sm>.container-sm,.navbar-expand-sm>.container-md,.navbar-expand-sm>.container-lg,.navbar-expand-sm>.container-xl{padding-left:0;padding-right:0}}@media (width>=576px){.navbar-expand-sm{-ms-flex-flow:row;flex-flow:row;justify-content:flex-start}.navbar-expand-sm .navbar-nav{-ms-flex-direction:row;flex-direction:row}.navbar-expand-sm .navbar-nav .dropdown-menu{position:absolute}.navbar-expand-sm .navbar-nav .nav-link{padding-left:.5rem;padding-right:.5rem}.navbar-expand-sm>.container,.navbar-expand-sm>.container-fluid,.navbar-expand-sm>.container-sm,.navbar-expand-sm>.container-md,.navbar-expand-sm>.container-lg,.navbar-expand-sm>.container-xl{-ms-flex-wrap:nowrap;flex-wrap:nowrap}.navbar-expand-sm .navbar-nav-scroll{overflow:visible}.navbar-expand-sm .navbar-collapse{-ms-flex-preferred-size:auto;flex-basis:auto;display:-ms-flexbox!important;display:flex!important}.navbar-expand-sm .navbar-toggler{display:none}}@media (width<=767.98px){.navbar-expand-md>.container,.navbar-expand-md>.container-fluid,.navbar-expand-md>.container-sm,.navbar-expand-md>.container-md,.navbar-expand-md>.container-lg,.navbar-expand-md>.container-xl{padding-left:0;padding-right:0}}@media (width>=768px){.navbar-expand-md{-ms-flex-flow:row;flex-flow:row;justify-content:flex-start}.navbar-expand-md .navbar-nav{-ms-flex-direction:row;flex-direction:row}.navbar-expand-md .navbar-nav .dropdown-menu{position:absolute}.navbar-expand-md .navbar-nav .nav-link{padding-left:.5rem;padding-right:.5rem}.navbar-expand-md>.container,.navbar-expand-md>.container-fluid,.navbar-expand-md>.container-sm,.navbar-expand-md>.container-md,.navbar-expand-md>.container-lg,.navbar-expand-md>.container-xl{-ms-flex-wrap:nowrap;flex-wrap:nowrap}.navbar-expand-md .navbar-nav-scroll{overflow:visible}.navbar-expand-md .navbar-collapse{-ms-flex-preferred-size:auto;flex-basis:auto;display:-ms-flexbox!important;display:flex!important}.navbar-expand-md .navbar-toggler{display:none}}@media (width<=991.98px){.navbar-expand-lg>.container,.navbar-expand-lg>.container-fluid,.navbar-expand-lg>.container-sm,.navbar-expand-lg>.container-md,.navbar-expand-lg>.container-lg,.navbar-expand-lg>.container-xl{padding-left:0;padding-right:0}}@media (width>=992px){.navbar-expand-lg{-ms-flex-flow:row;flex-flow:row;justify-content:flex-start}.navbar-expand-lg .navbar-nav{-ms-flex-direction:row;flex-direction:row}.navbar-expand-lg .navbar-nav .dropdown-menu{position:absolute}.navbar-expand-lg .navbar-nav .nav-link{padding-left:.5rem;padding-right:.5rem}.navbar-expand-lg>.container,.navbar-expand-lg>.container-fluid,.navbar-expand-lg>.container-sm,.navbar-expand-lg>.container-md,.navbar-expand-lg>.container-lg,.navbar-expand-lg>.container-xl{-ms-flex-wrap:nowrap;flex-wrap:nowrap}.navbar-expand-lg .navbar-nav-scroll{overflow:visible}.navbar-expand-lg .navbar-collapse{-ms-flex-preferred-size:auto;flex-basis:auto;display:-ms-flexbox!important;display:flex!important}.navbar-expand-lg .navbar-toggler{display:none}}@media (width<=1199.98px){.navbar-expand-xl>.container,.navbar-expand-xl>.container-fluid,.navbar-expand-xl>.container-sm,.navbar-expand-xl>.container-md,.navbar-expand-xl>.container-lg,.navbar-expand-xl>.container-xl{padding-left:0;padding-right:0}}@media (width>=1200px){.navbar-expand-xl{-ms-flex-flow:row;flex-flow:row;justify-content:flex-start}.navbar-expand-xl .navbar-nav{-ms-flex-direction:row;flex-direction:row}.navbar-expand-xl .navbar-nav .dropdown-menu{position:absolute}.navbar-expand-xl .navbar-nav .nav-link{padding-left:.5rem;padding-right:.5rem}.navbar-expand-xl>.container,.navbar-expand-xl>.container-fluid,.navbar-expand-xl>.container-sm,.navbar-expand-xl>.container-md,.navbar-expand-xl>.container-lg,.navbar-expand-xl>.container-xl{-ms-flex-wrap:nowrap;flex-wrap:nowrap}.navbar-expand-xl .navbar-nav-scroll{overflow:visible}.navbar-expand-xl .navbar-collapse{-ms-flex-preferred-size:auto;flex-basis:auto;display:-ms-flexbox!important;display:flex!important}.navbar-expand-xl .navbar-toggler{display:none}}.navbar-expand{-ms-flex-flow:row;flex-flow:row;justify-content:flex-start}.navbar-expand>.container,.navbar-expand>.container-fluid,.navbar-expand>.container-sm,.navbar-expand>.container-md,.navbar-expand>.container-lg,.navbar-expand>.container-xl{padding-left:0;padding-right:0}.navbar-expand .navbar-nav{-ms-flex-direction:row;flex-direction:row}.navbar-expand .navbar-nav .dropdown-menu{position:absolute}.navbar-expand .navbar-nav .nav-link{padding-left:.5rem;padding-right:.5rem}.navbar-expand>.container,.navbar-expand>.container-fluid,.navbar-expand>.container-sm,.navbar-expand>.container-md,.navbar-expand>.container-lg,.navbar-expand>.container-xl{-ms-flex-wrap:nowrap;flex-wrap:nowrap}.navbar-expand .navbar-nav-scroll{overflow:visible}.navbar-expand .navbar-collapse{-ms-flex-preferred-size:auto;flex-basis:auto;display:-ms-flexbox!important;display:flex!important}.navbar-expand .navbar-toggler{display:none}.navbar-light .navbar-brand,.navbar-light .navbar-brand:hover,.navbar-light .navbar-brand:focus{color:#000000e6}.navbar-light .navbar-nav .nav-link{color:#00000080}.navbar-light .navbar-nav .nav-link:hover,.navbar-light .navbar-nav .nav-link:focus{color:#000000b3}.navbar-light .navbar-nav .nav-link.disabled{color:#0000004d}.navbar-light .navbar-nav .show>.nav-link,.navbar-light .navbar-nav .active>.nav-link,.navbar-light .navbar-nav .nav-link.show,.navbar-light .navbar-nav .nav-link.active{color:#000000e6}.navbar-light .navbar-toggler{color:#00000080;border-color:#0000001a}.navbar-light .navbar-toggler-icon{background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' width='30' height='30' viewBox='0 0 30 30'%3e%3cpath stroke='rgba%280, 0, 0, 0.5%29' stroke-linecap='round' stroke-miterlimit='10' stroke-width='2' d='M4 7h22M4 15h22M4 23h22'/%3e%3c/svg%3e")}.navbar-light .navbar-text{color:#00000080}.navbar-light .navbar-text a,.navbar-light .navbar-text a:hover,.navbar-light .navbar-text a:focus{color:#000000e6}.navbar-dark .navbar-brand,.navbar-dark .navbar-brand:hover,.navbar-dark .navbar-brand:focus{color:#fff}.navbar-dark .navbar-nav .nav-link{color:#ffffff80}.navbar-dark .navbar-nav .nav-link:hover,.navbar-dark .navbar-nav .nav-link:focus{color:#ffffffbf}.navbar-dark .navbar-nav .nav-link.disabled{color:#ffffff40}.navbar-dark .navbar-nav .show>.nav-link,.navbar-dark .navbar-nav .active>.nav-link,.navbar-dark .navbar-nav .nav-link.show,.navbar-dark .navbar-nav .nav-link.active{color:#fff}.navbar-dark .navbar-toggler{color:#ffffff80;border-color:#ffffff1a}.navbar-dark .navbar-toggler-icon{background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' width='30' height='30' viewBox='0 0 30 30'%3e%3cpath stroke='rgba%28255, 255, 255, 0.5%29' stroke-linecap='round' stroke-miterlimit='10' stroke-width='2' d='M4 7h22M4 15h22M4 23h22'/%3e%3c/svg%3e")}.navbar-dark .navbar-text{color:#ffffff80}.navbar-dark .navbar-text a,.navbar-dark .navbar-text a:hover,.navbar-dark .navbar-text a:focus{color:#fff}.card{word-wrap:break-word;background-color:#fff;background-clip:border-box;border:1px solid #00000020;border-radius:.25rem;-ms-flex-direction:column;flex-direction:column;min-width:0;display:-ms-flexbox;display:flex;position:relative}.card>hr{margin-left:0;margin-right:0}.card>.list-group{border-top:inherit;border-bottom:inherit}.card>.list-group:first-child{border-top-width:0;border-top-left-radius:calc(.25rem - 1px);border-top-right-radius:calc(.25rem - 1px)}.card>.list-group:last-child{border-bottom-width:0;border-bottom-right-radius:calc(.25rem - 1px);border-bottom-left-radius:calc(.25rem - 1px)}.card>.card-header+.list-group,.card>.list-group+.card-footer{border-top:0}.card-body{-ms-flex:auto;flex:auto;min-height:1px;padding:1.25rem}.card-title{margin-bottom:.75rem}.card-subtitle{margin-top:-.375rem;margin-bottom:0}.card-text:last-child{margin-bottom:0}.card-link:hover{text-decoration:none}.card-link+.card-link{margin-left:1.25rem}.card-header{background-color:#00000008;border-bottom:1px solid #00000020;margin-bottom:0;padding:.75rem 1.25rem}.card-header:first-child{border-radius:calc(.25rem - 1px) calc(.25rem - 1px) 0 0}.card-footer{background-color:#00000008;border-top:1px solid #00000020;padding:.75rem 1.25rem}.card-footer:last-child{border-radius:0 0 calc(.25rem - 1px) calc(.25rem - 1px)}.card-header-tabs{border-bottom:0;margin-bottom:-.75rem;margin-left:-.625rem;margin-right:-.625rem}.card-header-pills{margin-left:-.625rem;margin-right:-.625rem}.card-img-overlay{border-radius:calc(.25rem - 1px);padding:1.25rem;position:absolute;inset:0}.card-img,.card-img-top,.card-img-bottom{-ms-flex-negative:0;flex-shrink:0;width:100%}.card-img,.card-img-top{border-top-left-radius:calc(.25rem - 1px);border-top-right-radius:calc(.25rem - 1px)}.card-img,.card-img-bottom{border-bottom-right-radius:calc(.25rem - 1px);border-bottom-left-radius:calc(.25rem - 1px)}.card-deck .card{margin-bottom:15px}@media (width>=576px){.card-deck{-ms-flex-flow:wrap;flex-flow:wrap;margin-left:-15px;margin-right:-15px;display:-ms-flexbox;display:flex}.card-deck .card{-ms-flex:1 0;flex:1 0;margin-bottom:0;margin-left:15px;margin-right:15px}}.card-group>.card{margin-bottom:15px}@media (width>=576px){.card-group{-ms-flex-flow:wrap;flex-flow:wrap;display:-ms-flexbox;display:flex}.card-group>.card{-ms-flex:1 0;flex:1 0;margin-bottom:0}.card-group>.card+.card{border-left:0;margin-left:0}.card-group>.card:not(:last-child){border-top-right-radius:0;border-bottom-right-radius:0}.card-group>.card:not(:last-child) .card-img-top,.card-group>.card:not(:last-child) .card-header{border-top-right-radius:0}.card-group>.card:not(:last-child) .card-img-bottom,.card-group>.card:not(:last-child) .card-footer{border-bottom-right-radius:0}.card-group>.card:not(:first-child){border-top-left-radius:0;border-bottom-left-radius:0}.card-group>.card:not(:first-child) .card-img-top,.card-group>.card:not(:first-child) .card-header{border-top-left-radius:0}.card-group>.card:not(:first-child) .card-img-bottom,.card-group>.card:not(:first-child) .card-footer{border-bottom-left-radius:0}}.card-columns .card{margin-bottom:.75rem}@media (width>=576px){.card-columns{-webkit-column-count:3;-moz-column-count:3;column-count:3;-webkit-column-gap:1.25rem;-moz-column-gap:1.25rem;orphans:1;widows:1;column-gap:1.25rem}.card-columns .card{width:100%;display:inline-block}}.accordion{overflow-anchor:none}.accordion>.card{overflow:hidden}.accordion>.card:not(:last-of-type){border-bottom:0;border-bottom-right-radius:0;border-bottom-left-radius:0}.accordion>.card:not(:first-of-type){border-top-left-radius:0;border-top-right-radius:0}.accordion>.card>.card-header{border-radius:0;margin-bottom:-1px}.breadcrumb{background-color:#e9ecef;border-radius:.25rem;-ms-flex-wrap:wrap;flex-wrap:wrap;margin-bottom:1rem;padding:.75rem 1rem;list-style:none;display:-ms-flexbox;display:flex}.breadcrumb-item+.breadcrumb-item{padding-left:.5rem}.breadcrumb-item+.breadcrumb-item:before{float:left;color:#6c757d;content:"/";padding-right:.5rem}.breadcrumb-item+.breadcrumb-item:hover:before{text-decoration:none}.breadcrumb-item.active{color:#6c757d}.pagination{border-radius:.25rem;padding-left:0;list-style:none;display:-ms-flexbox;display:flex}.page-link{color:#007bff;background-color:#fff;border:1px solid #dee2e6;margin-left:-1px;padding:.5rem .75rem;line-height:1.25;display:block;position:relative}.page-link:hover{z-index:2;color:#0056b3;background-color:#e9ecef;border-color:#dee2e6;text-decoration:none}.page-link:focus{z-index:3;outline:0;box-shadow:0 0 0 .2rem #007bff40}.page-item:first-child .page-link{border-top-left-radius:.25rem;border-bottom-left-radius:.25rem;margin-left:0}.page-item:last-child .page-link{border-top-right-radius:.25rem;border-bottom-right-radius:.25rem}.page-item.active .page-link{z-index:3;color:#fff;background-color:#007bff;border-color:#007bff}.page-item.disabled .page-link{color:#6c757d;pointer-events:none;cursor:auto;background-color:#fff;border-color:#dee2e6}.pagination-lg .page-link{padding:.75rem 1.5rem;font-size:1.25rem;line-height:1.5}.pagination-lg .page-item:first-child .page-link{border-top-left-radius:.3rem;border-bottom-left-radius:.3rem}.pagination-lg .page-item:last-child .page-link{border-top-right-radius:.3rem;border-bottom-right-radius:.3rem}.pagination-sm .page-link{padding:.25rem .5rem;font-size:.875rem;line-height:1.5}.pagination-sm .page-item:first-child .page-link{border-top-left-radius:.2rem;border-bottom-left-radius:.2rem}.pagination-sm .page-item:last-child .page-link{border-top-right-radius:.2rem;border-bottom-right-radius:.2rem}.badge{text-align:center;white-space:nowrap;vertical-align:baseline;border-radius:.25rem;padding:.25em .4em;font-size:75%;font-weight:700;line-height:1;transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;display:inline-block}@media (prefers-reduced-motion:reduce){.badge{transition:none}}a.badge:hover,a.badge:focus{text-decoration:none}.badge:empty{display:none}.btn .badge{position:relative;top:-1px}.badge-pill{border-radius:10rem;padding-left:.6em;padding-right:.6em}.badge-primary{color:#fff;background-color:#007bff}a.badge-primary:hover,a.badge-primary:focus{color:#fff;background-color:#0062cc}a.badge-primary:focus,a.badge-primary.focus{outline:0;box-shadow:0 0 0 .2rem #007bff80}.badge-secondary{color:#fff;background-color:#6c757d}a.badge-secondary:hover,a.badge-secondary:focus{color:#fff;background-color:#545b62}a.badge-secondary:focus,a.badge-secondary.focus{outline:0;box-shadow:0 0 0 .2rem #6c757d80}.badge-success{color:#fff;background-color:#28a745}a.badge-success:hover,a.badge-success:focus{color:#fff;background-color:#1e7e34}a.badge-success:focus,a.badge-success.focus{outline:0;box-shadow:0 0 0 .2rem #28a74580}.badge-info{color:#fff;background-color:#17a2b8}a.badge-info:hover,a.badge-info:focus{color:#fff;background-color:#117a8b}a.badge-info:focus,a.badge-info.focus{outline:0;box-shadow:0 0 0 .2rem #17a2b880}.badge-warning{color:#212529;background-color:#ffc107}a.badge-warning:hover,a.badge-warning:focus{color:#212529;background-color:#d39e00}a.badge-warning:focus,a.badge-warning.focus{outline:0;box-shadow:0 0 0 .2rem #ffc10780}.badge-danger{color:#fff;background-color:#dc3545}a.badge-danger:hover,a.badge-danger:focus{color:#fff;background-color:#bd2130}a.badge-danger:focus,a.badge-danger.focus{outline:0;box-shadow:0 0 0 .2rem #dc354580}.badge-light{color:#212529;background-color:#f8f9fa}a.badge-light:hover,a.badge-light:focus{color:#212529;background-color:#dae0e5}a.badge-light:focus,a.badge-light.focus{outline:0;box-shadow:0 0 0 .2rem #f8f9fa80}.badge-dark{color:#fff;background-color:#343a40}a.badge-dark:hover,a.badge-dark:focus{color:#fff;background-color:#1d2124}a.badge-dark:focus,a.badge-dark.focus{outline:0;box-shadow:0 0 0 .2rem #343a4080}.jumbotron{background-color:#e9ecef;border-radius:.3rem;margin-bottom:2rem;padding:2rem 1rem}@media (width>=576px){.jumbotron{padding:4rem 2rem}}.jumbotron-fluid{border-radius:0;padding-left:0;padding-right:0}.alert{border:1px solid #0000;border-radius:.25rem;margin-bottom:1rem;padding:.75rem 1.25rem;position:relative}.alert-heading{color:inherit}.alert-link{font-weight:700}.alert-dismissible{padding-right:4rem}.alert-dismissible .close{z-index:2;color:inherit;padding:.75rem 1.25rem;position:absolute;top:0;right:0}.alert-primary{color:#004085;background-color:#cce5ff;border-color:#b8daff}.alert-primary hr{border-top-color:#9fcdff}.alert-primary .alert-link{color:#002752}.alert-secondary{color:#383d41;background-color:#e2e3e5;border-color:#d6d8db}.alert-secondary hr{border-top-color:#c8cbcf}.alert-secondary .alert-link{color:#202326}.alert-success{color:#155724;background-color:#d4edda;border-color:#c3e6cb}.alert-success hr{border-top-color:#b1dfbb}.alert-success .alert-link{color:#0b2e13}.alert-info{color:#0c5460;background-color:#d1ecf1;border-color:#bee5eb}.alert-info hr{border-top-color:#abdde5}.alert-info .alert-link{color:#062c33}.alert-warning{color:#856404;background-color:#fff3cd;border-color:#ffeeba}.alert-warning hr{border-top-color:#ffe8a1}.alert-warning .alert-link{color:#533f03}.alert-danger{color:#721c24;background-color:#f8d7da;border-color:#f5c6cb}.alert-danger hr{border-top-color:#f1b0b7}.alert-danger .alert-link{color:#491217}.alert-light{color:#818182;background-color:#fefefe;border-color:#fdfdfe}.alert-light hr{border-top-color:#ececf6}.alert-light .alert-link{color:#686868}.alert-dark{color:#1b1e21;background-color:#d6d8d9;border-color:#c6c8ca}.alert-dark hr{border-top-color:#b9bbbe}.alert-dark .alert-link{color:#040505}@-webkit-keyframes progress-bar-stripes{0%{background-position:1rem 0}to{background-position:0 0}}@keyframes progress-bar-stripes{0%{background-position:1rem 0}to{background-position:0 0}}.progress{background-color:#e9ecef;border-radius:.25rem;height:1rem;font-size:.75rem;line-height:0;display:-ms-flexbox;display:flex;overflow:hidden}.progress-bar{color:#fff;text-align:center;white-space:nowrap;background-color:#007bff;-ms-flex-direction:column;flex-direction:column;justify-content:center;transition:width .6s;display:-ms-flexbox;display:flex;overflow:hidden}@media (prefers-reduced-motion:reduce){.progress-bar{transition:none}}.progress-bar-striped{background-image:linear-gradient(45deg,#ffffff26 25%,#0000 25% 50%,#ffffff26 50% 75%,#0000 75%,#0000);background-size:1rem 1rem}.progress-bar-animated{-webkit-animation:1s linear infinite progress-bar-stripes;animation:1s linear infinite progress-bar-stripes}@media (prefers-reduced-motion:reduce){.progress-bar-animated{-webkit-animation:none;animation:none}}.media{align-items:flex-start;display:-ms-flexbox;display:flex}.media-body{-ms-flex:1;flex:1}.list-group{border-radius:.25rem;-ms-flex-direction:column;flex-direction:column;margin-bottom:0;padding-left:0;display:-ms-flexbox;display:flex}.list-group-item-action{color:#495057;text-align:inherit;width:100%}.list-group-item-action:hover,.list-group-item-action:focus{z-index:1;color:#495057;background-color:#f8f9fa;text-decoration:none}.list-group-item-action:active{color:#212529;background-color:#e9ecef}.list-group-item{background-color:#fff;border:1px solid #00000020;padding:.75rem 1.25rem;display:block;position:relative}.list-group-item:first-child{border-top-left-radius:inherit;border-top-right-radius:inherit}.list-group-item:last-child{border-bottom-right-radius:inherit;border-bottom-left-radius:inherit}.list-group-item.disabled,.list-group-item:disabled{color:#6c757d;pointer-events:none;background-color:#fff}.list-group-item.active{z-index:2;color:#fff;background-color:#007bff;border-color:#007bff}.list-group-item+.list-group-item{border-top-width:0}.list-group-item+.list-group-item.active{border-top-width:1px;margin-top:-1px}.list-group-horizontal{-ms-flex-direction:row;flex-direction:row}.list-group-horizontal>.list-group-item:first-child{border-top-right-radius:0;border-bottom-left-radius:.25rem}.list-group-horizontal>.list-group-item:last-child{border-top-right-radius:.25rem;border-bottom-left-radius:0}.list-group-horizontal>.list-group-item.active{margin-top:0}.list-group-horizontal>.list-group-item+.list-group-item{border-top-width:1px;border-left-width:0}.list-group-horizontal>.list-group-item+.list-group-item.active{border-left-width:1px;margin-left:-1px}@media (width>=576px){.list-group-horizontal-sm{-ms-flex-direction:row;flex-direction:row}.list-group-horizontal-sm>.list-group-item:first-child{border-top-right-radius:0;border-bottom-left-radius:.25rem}.list-group-horizontal-sm>.list-group-item:last-child{border-top-right-radius:.25rem;border-bottom-left-radius:0}.list-group-horizontal-sm>.list-group-item.active{margin-top:0}.list-group-horizontal-sm>.list-group-item+.list-group-item{border-top-width:1px;border-left-width:0}.list-group-horizontal-sm>.list-group-item+.list-group-item.active{border-left-width:1px;margin-left:-1px}}@media (width>=768px){.list-group-horizontal-md{-ms-flex-direction:row;flex-direction:row}.list-group-horizontal-md>.list-group-item:first-child{border-top-right-radius:0;border-bottom-left-radius:.25rem}.list-group-horizontal-md>.list-group-item:last-child{border-top-right-radius:.25rem;border-bottom-left-radius:0}.list-group-horizontal-md>.list-group-item.active{margin-top:0}.list-group-horizontal-md>.list-group-item+.list-group-item{border-top-width:1px;border-left-width:0}.list-group-horizontal-md>.list-group-item+.list-group-item.active{border-left-width:1px;margin-left:-1px}}@media (width>=992px){.list-group-horizontal-lg{-ms-flex-direction:row;flex-direction:row}.list-group-horizontal-lg>.list-group-item:first-child{border-top-right-radius:0;border-bottom-left-radius:.25rem}.list-group-horizontal-lg>.list-group-item:last-child{border-top-right-radius:.25rem;border-bottom-left-radius:0}.list-group-horizontal-lg>.list-group-item.active{margin-top:0}.list-group-horizontal-lg>.list-group-item+.list-group-item{border-top-width:1px;border-left-width:0}.list-group-horizontal-lg>.list-group-item+.list-group-item.active{border-left-width:1px;margin-left:-1px}}@media (width>=1200px){.list-group-horizontal-xl{-ms-flex-direction:row;flex-direction:row}.list-group-horizontal-xl>.list-group-item:first-child{border-top-right-radius:0;border-bottom-left-radius:.25rem}.list-group-horizontal-xl>.list-group-item:last-child{border-top-right-radius:.25rem;border-bottom-left-radius:0}.list-group-horizontal-xl>.list-group-item.active{margin-top:0}.list-group-horizontal-xl>.list-group-item+.list-group-item{border-top-width:1px;border-left-width:0}.list-group-horizontal-xl>.list-group-item+.list-group-item.active{border-left-width:1px;margin-left:-1px}}.list-group-flush{border-radius:0}.list-group-flush>.list-group-item{border-width:0 0 1px}.list-group-flush>.list-group-item:last-child{border-bottom-width:0}.list-group-item-primary{color:#004085;background-color:#b8daff}.list-group-item-primary.list-group-item-action:hover,.list-group-item-primary.list-group-item-action:focus{color:#004085;background-color:#9fcdff}.list-group-item-primary.list-group-item-action.active{color:#fff;background-color:#004085;border-color:#004085}.list-group-item-secondary{color:#383d41;background-color:#d6d8db}.list-group-item-secondary.list-group-item-action:hover,.list-group-item-secondary.list-group-item-action:focus{color:#383d41;background-color:#c8cbcf}.list-group-item-secondary.list-group-item-action.active{color:#fff;background-color:#383d41;border-color:#383d41}.list-group-item-success{color:#155724;background-color:#c3e6cb}.list-group-item-success.list-group-item-action:hover,.list-group-item-success.list-group-item-action:focus{color:#155724;background-color:#b1dfbb}.list-group-item-success.list-group-item-action.active{color:#fff;background-color:#155724;border-color:#155724}.list-group-item-info{color:#0c5460;background-color:#bee5eb}.list-group-item-info.list-group-item-action:hover,.list-group-item-info.list-group-item-action:focus{color:#0c5460;background-color:#abdde5}.list-group-item-info.list-group-item-action.active{color:#fff;background-color:#0c5460;border-color:#0c5460}.list-group-item-warning{color:#856404;background-color:#ffeeba}.list-group-item-warning.list-group-item-action:hover,.list-group-item-warning.list-group-item-action:focus{color:#856404;background-color:#ffe8a1}.list-group-item-warning.list-group-item-action.active{color:#fff;background-color:#856404;border-color:#856404}.list-group-item-danger{color:#721c24;background-color:#f5c6cb}.list-group-item-danger.list-group-item-action:hover,.list-group-item-danger.list-group-item-action:focus{color:#721c24;background-color:#f1b0b7}.list-group-item-danger.list-group-item-action.active{color:#fff;background-color:#721c24;border-color:#721c24}.list-group-item-light{color:#818182;background-color:#fdfdfe}.list-group-item-light.list-group-item-action:hover,.list-group-item-light.list-group-item-action:focus{color:#818182;background-color:#ececf6}.list-group-item-light.list-group-item-action.active{color:#fff;background-color:#818182;border-color:#818182}.list-group-item-dark{color:#1b1e21;background-color:#c6c8ca}.list-group-item-dark.list-group-item-action:hover,.list-group-item-dark.list-group-item-action:focus{color:#1b1e21;background-color:#b9bbbe}.list-group-item-dark.list-group-item-action.active{color:#fff;background-color:#1b1e21;border-color:#1b1e21}.close{float:right;color:#000;text-shadow:0 1px #fff;opacity:.5;font-size:1.5rem;font-weight:700;line-height:1}.close:hover{color:#000;text-decoration:none}.close:not(:disabled):not(.disabled):hover,.close:not(:disabled):not(.disabled):focus{opacity:.75}button.close{background-color:#0000;border:0;padding:0}a.close.disabled{pointer-events:none}.toast{opacity:0;background-color:#ffffffd9;background-clip:padding-box;border:1px solid #0000001a;border-radius:.25rem;-ms-flex-preferred-size:350px;flex-basis:350px;max-width:350px;font-size:.875rem;box-shadow:0 .25rem .75rem #0000001a}.toast:not(:last-child){margin-bottom:.75rem}.toast.showing{opacity:1}.toast.show{opacity:1;display:block}.toast.hide{display:none}.toast-header{color:#6c757d;background-color:#ffffffd9;background-clip:padding-box;border-bottom:1px solid #0000000d;border-top-left-radius:calc(.25rem - 1px);border-top-right-radius:calc(.25rem - 1px);align-items:center;padding:.25rem .75rem;display:-ms-flexbox;display:flex}.toast-body{padding:.75rem}.modal-open{overflow:hidden}.modal-open .modal{overflow:hidden auto}.modal{z-index:1050;outline:0;width:100%;height:100%;display:none;position:fixed;top:0;left:0;overflow:hidden}.modal-dialog{pointer-events:none;width:auto;margin:.5rem;position:relative}.modal.fade .modal-dialog{transition:transform .3s ease-out,-webkit-transform .3s ease-out;-webkit-transform:translateY(-50px);transform:translateY(-50px)}@media (prefers-reduced-motion:reduce){.modal.fade .modal-dialog{transition:none}}.modal.show .modal-dialog{-webkit-transform:none;transform:none}.modal.modal-static .modal-dialog{-webkit-transform:scale(1.02);transform:scale(1.02)}.modal-dialog-scrollable{max-height:calc(100% - 1rem);display:-ms-flexbox;display:flex}.modal-dialog-scrollable .modal-content{max-height:calc(100vh - 1rem);overflow:hidden}.modal-dialog-scrollable .modal-header,.modal-dialog-scrollable .modal-footer{-ms-flex-negative:0;flex-shrink:0}.modal-dialog-scrollable .modal-body{overflow-y:auto}.modal-dialog-centered{align-items:center;min-height:calc(100% - 1rem);display:-ms-flexbox;display:flex}.modal-dialog-centered:before{content:"";height:min-content;display:block}.modal-dialog-centered.modal-dialog-scrollable{-ms-flex-direction:column;flex-direction:column;justify-content:center;height:100%}.modal-dialog-centered.modal-dialog-scrollable .modal-content{max-height:none}.modal-dialog-centered.modal-dialog-scrollable:before{content:none}.modal-content{pointer-events:auto;background-color:#fff;background-clip:padding-box;border:1px solid #0003;border-radius:.3rem;outline:0;-ms-flex-direction:column;flex-direction:column;width:100%;display:-ms-flexbox;display:flex;position:relative}.modal-backdrop{z-index:1040;background-color:#000;width:100vw;height:100vh;position:fixed;top:0;left:0}.modal-backdrop.fade{opacity:0}.modal-backdrop.show{opacity:.5}.modal-header{border-bottom:1px solid #dee2e6;border-top-left-radius:calc(.3rem - 1px);border-top-right-radius:calc(.3rem - 1px);justify-content:space-between;align-items:flex-start;padding:1rem;display:-ms-flexbox;display:flex}.modal-header .close{margin:-1rem -1rem -1rem auto;padding:1rem}.modal-title{margin-bottom:0;line-height:1.5}.modal-body{-ms-flex:auto;flex:auto;padding:1rem;position:relative}.modal-footer{border-top:1px solid #dee2e6;border-bottom-right-radius:calc(.3rem - 1px);border-bottom-left-radius:calc(.3rem - 1px);-ms-flex-wrap:wrap;flex-wrap:wrap;justify-content:flex-end;align-items:center;padding:.75rem;display:-ms-flexbox;display:flex}.modal-footer>*{margin:.25rem}.modal-scrollbar-measure{width:50px;height:50px;position:absolute;top:-9999px;overflow:scroll}@media (width>=576px){.modal-dialog{max-width:500px;margin:1.75rem auto}.modal-dialog-scrollable{max-height:calc(100% - 3.5rem)}.modal-dialog-scrollable .modal-content{max-height:calc(100vh - 3.5rem)}.modal-dialog-centered{min-height:calc(100% - 3.5rem)}.modal-dialog-centered:before{height:min-content}.modal-sm{max-width:300px}}@media (width>=992px){.modal-lg,.modal-xl{max-width:800px}}@media (width>=1200px){.modal-xl{max-width:1140px}}.tooltip{z-index:1070;text-align:left;text-align:start;text-shadow:none;text-transform:none;letter-spacing:normal;word-break:normal;word-spacing:normal;white-space:normal;line-break:auto;word-wrap:break-word;opacity:0;margin:0;font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Helvetica Neue,Arial,Noto Sans,Liberation Sans,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol,Noto Color Emoji;font-size:.875rem;font-style:normal;font-weight:400;line-height:1.5;text-decoration:none;display:block;position:absolute}.tooltip.show{opacity:.9}.tooltip .arrow{width:.8rem;height:.4rem;display:block;position:absolute}.tooltip .arrow:before{content:"";border-style:solid;border-color:#0000;position:absolute}.bs-tooltip-top,.bs-tooltip-auto[x-placement^=top]{padding:.4rem 0}.bs-tooltip-top .arrow,.bs-tooltip-auto[x-placement^=top] .arrow{bottom:0}.bs-tooltip-top .arrow:before,.bs-tooltip-auto[x-placement^=top] .arrow:before{border-width:.4rem .4rem 0;border-top-color:#000;top:0}.bs-tooltip-right,.bs-tooltip-auto[x-placement^=right]{padding:0 .4rem}.bs-tooltip-right .arrow,.bs-tooltip-auto[x-placement^=right] .arrow{width:.4rem;height:.8rem;left:0}.bs-tooltip-right .arrow:before,.bs-tooltip-auto[x-placement^=right] .arrow:before{border-width:.4rem .4rem .4rem 0;border-right-color:#000;right:0}.bs-tooltip-bottom,.bs-tooltip-auto[x-placement^=bottom]{padding:.4rem 0}.bs-tooltip-bottom .arrow,.bs-tooltip-auto[x-placement^=bottom] .arrow{top:0}.bs-tooltip-bottom .arrow:before,.bs-tooltip-auto[x-placement^=bottom] .arrow:before{border-width:0 .4rem .4rem;border-bottom-color:#000;bottom:0}.bs-tooltip-left,.bs-tooltip-auto[x-placement^=left]{padding:0 .4rem}.bs-tooltip-left .arrow,.bs-tooltip-auto[x-placement^=left] .arrow{width:.4rem;height:.8rem;right:0}.bs-tooltip-left .arrow:before,.bs-tooltip-auto[x-placement^=left] .arrow:before{border-width:.4rem 0 .4rem .4rem;border-left-color:#000;left:0}.tooltip-inner{color:#fff;text-align:center;background-color:#000;border-radius:.25rem;max-width:200px;padding:.25rem .5rem}.popover{z-index:1060;text-align:left;text-align:start;text-shadow:none;text-transform:none;letter-spacing:normal;word-break:normal;word-spacing:normal;white-space:normal;line-break:auto;word-wrap:break-word;background-color:#fff;background-clip:padding-box;border:1px solid #0003;border-radius:.3rem;max-width:276px;font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Helvetica Neue,Arial,Noto Sans,Liberation Sans,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol,Noto Color Emoji;font-size:.875rem;font-style:normal;font-weight:400;line-height:1.5;text-decoration:none;display:block;position:absolute;top:0;left:0}.popover .arrow{width:1rem;height:.5rem;margin:0 .3rem;display:block;position:absolute}.popover .arrow:before,.popover .arrow:after{content:"";border-style:solid;border-color:#0000;display:block;position:absolute}.bs-popover-top,.bs-popover-auto[x-placement^=top]{margin-bottom:.5rem}.bs-popover-top>.arrow,.bs-popover-auto[x-placement^=top]>.arrow{bottom:calc(-.5rem - 1px)}.bs-popover-top>.arrow:before,.bs-popover-auto[x-placement^=top]>.arrow:before{border-width:.5rem .5rem 0;border-top-color:#00000040;bottom:0}.bs-popover-top>.arrow:after,.bs-popover-auto[x-placement^=top]>.arrow:after{border-width:.5rem .5rem 0;border-top-color:#fff;bottom:1px}.bs-popover-right,.bs-popover-auto[x-placement^=right]{margin-left:.5rem}.bs-popover-right>.arrow,.bs-popover-auto[x-placement^=right]>.arrow{width:.5rem;height:1rem;margin:.3rem 0;left:calc(-.5rem - 1px)}.bs-popover-right>.arrow:before,.bs-popover-auto[x-placement^=right]>.arrow:before{border-width:.5rem .5rem .5rem 0;border-right-color:#00000040;left:0}.bs-popover-right>.arrow:after,.bs-popover-auto[x-placement^=right]>.arrow:after{border-width:.5rem .5rem .5rem 0;border-right-color:#fff;left:1px}.bs-popover-bottom,.bs-popover-auto[x-placement^=bottom]{margin-top:.5rem}.bs-popover-bottom>.arrow,.bs-popover-auto[x-placement^=bottom]>.arrow{top:calc(-.5rem - 1px)}.bs-popover-bottom>.arrow:before,.bs-popover-auto[x-placement^=bottom]>.arrow:before{border-width:0 .5rem .5rem;border-bottom-color:#00000040;top:0}.bs-popover-bottom>.arrow:after,.bs-popover-auto[x-placement^=bottom]>.arrow:after{border-width:0 .5rem .5rem;border-bottom-color:#fff;top:1px}.bs-popover-bottom .popover-header:before,.bs-popover-auto[x-placement^=bottom] .popover-header:before{content:"";border-bottom:1px solid #f7f7f7;width:1rem;margin-left:-.5rem;display:block;position:absolute;top:0;left:50%}.bs-popover-left,.bs-popover-auto[x-placement^=left]{margin-right:.5rem}.bs-popover-left>.arrow,.bs-popover-auto[x-placement^=left]>.arrow{width:.5rem;height:1rem;margin:.3rem 0;right:calc(-.5rem - 1px)}.bs-popover-left>.arrow:before,.bs-popover-auto[x-placement^=left]>.arrow:before{border-width:.5rem 0 .5rem .5rem;border-left-color:#00000040;right:0}.bs-popover-left>.arrow:after,.bs-popover-auto[x-placement^=left]>.arrow:after{border-width:.5rem 0 .5rem .5rem;border-left-color:#fff;right:1px}.popover-header{background-color:#f7f7f7;border-bottom:1px solid #ebebeb;border-top-left-radius:calc(.3rem - 1px);border-top-right-radius:calc(.3rem - 1px);margin-bottom:0;padding:.5rem .75rem;font-size:1rem}.popover-header:empty{display:none}.popover-body{color:#212529;padding:.5rem .75rem}.carousel{position:relative}.carousel.pointer-event{-ms-touch-action:pan-y;touch-action:pan-y}.carousel-inner{width:100%;position:relative;overflow:hidden}.carousel-inner:after{clear:both;content:"";display:block}.carousel-item{float:left;-webkit-backface-visibility:hidden;backface-visibility:hidden;width:100%;margin-right:-100%;transition:transform .6s ease-in-out,-webkit-transform .6s ease-in-out;display:none;position:relative}@media (prefers-reduced-motion:reduce){.carousel-item{transition:none}}.carousel-item.active,.carousel-item-next,.carousel-item-prev{display:block}.carousel-item-next:not(.carousel-item-left),.active.carousel-item-right{-webkit-transform:translate(100%);transform:translate(100%)}.carousel-item-prev:not(.carousel-item-right),.active.carousel-item-left{-webkit-transform:translate(-100%);transform:translate(-100%)}.carousel-fade .carousel-item{opacity:0;transition-property:opacity;-webkit-transform:none;transform:none}.carousel-fade .carousel-item.active,.carousel-fade .carousel-item-next.carousel-item-left,.carousel-fade .carousel-item-prev.carousel-item-right{z-index:1;opacity:1}.carousel-fade .active.carousel-item-left,.carousel-fade .active.carousel-item-right{z-index:0;opacity:0;transition:opacity 0s .6s}@media (prefers-reduced-motion:reduce){.carousel-fade .active.carousel-item-left,.carousel-fade .active.carousel-item-right{transition:none}}.carousel-control-prev,.carousel-control-next{z-index:1;color:#fff;text-align:center;opacity:.5;background:0 0;border:0;justify-content:center;align-items:center;width:15%;padding:0;transition:opacity .15s;display:-ms-flexbox;display:flex;position:absolute;top:0;bottom:0}@media (prefers-reduced-motion:reduce){.carousel-control-prev,.carousel-control-next{transition:none}}.carousel-control-prev:hover,.carousel-control-prev:focus,.carousel-control-next:hover,.carousel-control-next:focus{color:#fff;opacity:.9;outline:0;text-decoration:none}.carousel-control-prev{left:0}.carousel-control-next{right:0}.carousel-control-prev-icon,.carousel-control-next-icon{background:50%/100% 100% no-repeat;width:20px;height:20px;display:inline-block}.carousel-control-prev-icon{background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' fill='%23fff' width='8' height='8' viewBox='0 0 8 8'%3e%3cpath d='M5.25 0l-4 4 4 4 1.5-1.5L4.25 4l2.5-2.5L5.25 0z'/%3e%3c/svg%3e")}.carousel-control-next-icon{background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' fill='%23fff' width='8' height='8' viewBox='0 0 8 8'%3e%3cpath d='M2.75 0l-1.5 1.5L3.75 4l-2.5 2.5L2.75 8l4-4-4-4z'/%3e%3c/svg%3e")}.carousel-indicators{z-index:15;justify-content:center;margin-left:15%;margin-right:15%;padding-left:0;list-style:none;display:-ms-flexbox;display:flex;position:absolute;bottom:0;left:0;right:0}.carousel-indicators li{box-sizing:content-box;text-indent:-999px;cursor:pointer;opacity:.5;background-color:#fff;background-clip:padding-box;border-top:10px solid #0000;border-bottom:10px solid #0000;-ms-flex:0 auto;flex:0 auto;width:30px;height:3px;margin-left:3px;margin-right:3px;transition:opacity .6s}@media (prefers-reduced-motion:reduce){.carousel-indicators li{transition:none}}.carousel-indicators .active{opacity:1}.carousel-caption{z-index:10;color:#fff;text-align:center;padding-top:20px;padding-bottom:20px;position:absolute;bottom:20px;left:15%;right:15%}@-webkit-keyframes spinner-border{to{-webkit-transform:rotate(360deg);transform:rotate(360deg)}}@keyframes spinner-border{to{-webkit-transform:rotate(360deg);transform:rotate(360deg)}}.spinner-border{vertical-align:-.125em;border:.25em solid;border-right-color:#0000;border-radius:50%;width:2rem;height:2rem;-webkit-animation:.75s linear infinite spinner-border;animation:.75s linear infinite spinner-border;display:inline-block}.spinner-border-sm{border-width:.2em;width:1rem;height:1rem}@-webkit-keyframes spinner-grow{0%{-webkit-transform:scale(0);transform:scale(0)}50%{opacity:1;-webkit-transform:none;transform:none}}@keyframes spinner-grow{0%{-webkit-transform:scale(0);transform:scale(0)}50%{opacity:1;-webkit-transform:none;transform:none}}.spinner-grow{vertical-align:-.125em;opacity:0;background-color:currentColor;border-radius:50%;width:2rem;height:2rem;-webkit-animation:.75s linear infinite spinner-grow;animation:.75s linear infinite spinner-grow;display:inline-block}.spinner-grow-sm{width:1rem;height:1rem}@media (prefers-reduced-motion:reduce){.spinner-border,.spinner-grow{-webkit-animation-duration:1.5s;animation-duration:1.5s}}.align-baseline{vertical-align:baseline!important}.align-top{vertical-align:top!important}.align-middle{vertical-align:middle!important}.align-bottom{vertical-align:bottom!important}.align-text-bottom{vertical-align:text-bottom!important}.align-text-top{vertical-align:text-top!important}.bg-primary{background-color:#007bff!important}a.bg-primary:hover,a.bg-primary:focus,button.bg-primary:hover,button.bg-primary:focus{background-color:#0062cc!important}.bg-secondary{background-color:#6c757d!important}a.bg-secondary:hover,a.bg-secondary:focus,button.bg-secondary:hover,button.bg-secondary:focus{background-color:#545b62!important}.bg-success{background-color:#28a745!important}a.bg-success:hover,a.bg-success:focus,button.bg-success:hover,button.bg-success:focus{background-color:#1e7e34!important}.bg-info{background-color:#17a2b8!important}a.bg-info:hover,a.bg-info:focus,button.bg-info:hover,button.bg-info:focus{background-color:#117a8b!important}.bg-warning{background-color:#ffc107!important}a.bg-warning:hover,a.bg-warning:focus,button.bg-warning:hover,button.bg-warning:focus{background-color:#d39e00!important}.bg-danger{background-color:#dc3545!important}a.bg-danger:hover,a.bg-danger:focus,button.bg-danger:hover,button.bg-danger:focus{background-color:#bd2130!important}.bg-light{background-color:#f8f9fa!important}a.bg-light:hover,a.bg-light:focus,button.bg-light:hover,button.bg-light:focus{background-color:#dae0e5!important}.bg-dark{background-color:#343a40!important}a.bg-dark:hover,a.bg-dark:focus,button.bg-dark:hover,button.bg-dark:focus{background-color:#1d2124!important}.bg-white{background-color:#fff!important}.bg-transparent{background-color:#0000!important}.border{border:1px solid #dee2e6!important}.border-top{border-top:1px solid #dee2e6!important}.border-right{border-right:1px solid #dee2e6!important}.border-bottom{border-bottom:1px solid #dee2e6!important}.border-left{border-left:1px solid #dee2e6!important}.border-0{border:0!important}.border-top-0{border-top:0!important}.border-right-0{border-right:0!important}.border-bottom-0{border-bottom:0!important}.border-left-0{border-left:0!important}.border-primary{border-color:#007bff!important}.border-secondary{border-color:#6c757d!important}.border-success{border-color:#28a745!important}.border-info{border-color:#17a2b8!important}.border-warning{border-color:#ffc107!important}.border-danger{border-color:#dc3545!important}.border-light{border-color:#f8f9fa!important}.border-dark{border-color:#343a40!important}.border-white{border-color:#fff!important}.rounded-sm{border-radius:.2rem!important}.rounded{border-radius:.25rem!important}.rounded-top{border-top-left-radius:.25rem!important;border-top-right-radius:.25rem!important}.rounded-right{border-top-right-radius:.25rem!important;border-bottom-right-radius:.25rem!important}.rounded-bottom{border-bottom-right-radius:.25rem!important;border-bottom-left-radius:.25rem!important}.rounded-left{border-top-left-radius:.25rem!important;border-bottom-left-radius:.25rem!important}.rounded-lg{border-radius:.3rem!important}.rounded-circle{border-radius:50%!important}.rounded-pill{border-radius:50rem!important}.rounded-0{border-radius:0!important}.clearfix:after{clear:both;content:"";display:block}.d-none{display:none!important}.d-inline{display:inline!important}.d-inline-block{display:inline-block!important}.d-block{display:block!important}.d-table{display:table!important}.d-table-row{display:table-row!important}.d-table-cell{display:table-cell!important}.d-flex{display:-ms-flexbox!important;display:flex!important}.d-inline-flex{display:-ms-inline-flexbox!important;display:inline-flex!important}@media (width>=576px){.d-sm-none{display:none!important}.d-sm-inline{display:inline!important}.d-sm-inline-block{display:inline-block!important}.d-sm-block{display:block!important}.d-sm-table{display:table!important}.d-sm-table-row{display:table-row!important}.d-sm-table-cell{display:table-cell!important}.d-sm-flex{display:-ms-flexbox!important;display:flex!important}.d-sm-inline-flex{display:-ms-inline-flexbox!important;display:inline-flex!important}}@media (width>=768px){.d-md-none{display:none!important}.d-md-inline{display:inline!important}.d-md-inline-block{display:inline-block!important}.d-md-block{display:block!important}.d-md-table{display:table!important}.d-md-table-row{display:table-row!important}.d-md-table-cell{display:table-cell!important}.d-md-flex{display:-ms-flexbox!important;display:flex!important}.d-md-inline-flex{display:-ms-inline-flexbox!important;display:inline-flex!important}}@media (width>=992px){.d-lg-none{display:none!important}.d-lg-inline{display:inline!important}.d-lg-inline-block{display:inline-block!important}.d-lg-block{display:block!important}.d-lg-table{display:table!important}.d-lg-table-row{display:table-row!important}.d-lg-table-cell{display:table-cell!important}.d-lg-flex{display:-ms-flexbox!important;display:flex!important}.d-lg-inline-flex{display:-ms-inline-flexbox!important;display:inline-flex!important}}@media (width>=1200px){.d-xl-none{display:none!important}.d-xl-inline{display:inline!important}.d-xl-inline-block{display:inline-block!important}.d-xl-block{display:block!important}.d-xl-table{display:table!important}.d-xl-table-row{display:table-row!important}.d-xl-table-cell{display:table-cell!important}.d-xl-flex{display:-ms-flexbox!important;display:flex!important}.d-xl-inline-flex{display:-ms-inline-flexbox!important;display:inline-flex!important}}@media print{.d-print-none{display:none!important}.d-print-inline{display:inline!important}.d-print-inline-block{display:inline-block!important}.d-print-block{display:block!important}.d-print-table{display:table!important}.d-print-table-row{display:table-row!important}.d-print-table-cell{display:table-cell!important}.d-print-flex{display:-ms-flexbox!important;display:flex!important}.d-print-inline-flex{display:-ms-inline-flexbox!important;display:inline-flex!important}}.embed-responsive{width:100%;padding:0;display:block;position:relative;overflow:hidden}.embed-responsive:before{content:"";display:block}.embed-responsive .embed-responsive-item,.embed-responsive iframe,.embed-responsive embed,.embed-responsive object,.embed-responsive video{border:0;width:100%;height:100%;position:absolute;top:0;bottom:0;left:0}.embed-responsive-21by9:before{padding-top:42.8571%}.embed-responsive-16by9:before{padding-top:56.25%}.embed-responsive-4by3:before{padding-top:75%}.embed-responsive-1by1:before{padding-top:100%}.flex-row{-ms-flex-direction:row!important;flex-direction:row!important}.flex-column{-ms-flex-direction:column!important;flex-direction:column!important}.flex-row-reverse{-ms-flex-direction:row-reverse!important;flex-direction:row-reverse!important}.flex-column-reverse{-ms-flex-direction:column-reverse!important;flex-direction:column-reverse!important}.flex-wrap{-ms-flex-wrap:wrap!important;flex-wrap:wrap!important}.flex-nowrap{-ms-flex-wrap:nowrap!important;flex-wrap:nowrap!important}.flex-wrap-reverse{-ms-flex-wrap:wrap-reverse!important;flex-wrap:wrap-reverse!important}.flex-fill{-ms-flex:auto!important;flex:auto!important}.flex-grow-0{-ms-flex-positive:0!important;flex-grow:0!important}.flex-grow-1{-ms-flex-positive:1!important;flex-grow:1!important}.flex-shrink-0{-ms-flex-negative:0!important;flex-shrink:0!important}.flex-shrink-1{-ms-flex-negative:1!important;flex-shrink:1!important}.justify-content-start{justify-content:flex-start!important}.justify-content-end{justify-content:flex-end!important}.justify-content-center{justify-content:center!important}.justify-content-between{justify-content:space-between!important}.justify-content-around{justify-content:space-around!important}.align-items-start{align-items:flex-start!important}.align-items-end{align-items:flex-end!important}.align-items-center{align-items:center!important}.align-items-baseline{align-items:baseline!important}.align-items-stretch{align-items:stretch!important}.align-content-start{align-content:flex-start!important}.align-content-end{align-content:flex-end!important}.align-content-center{align-content:center!important}.align-content-between{align-content:space-between!important}.align-content-around{align-content:space-around!important}.align-content-stretch{align-content:stretch!important}.align-self-auto{align-self:auto!important}.align-self-start{align-self:flex-start!important}.align-self-end{align-self:flex-end!important}.align-self-center{align-self:center!important}.align-self-baseline{align-self:baseline!important}.align-self-stretch{align-self:stretch!important}@media (width>=576px){.flex-sm-row{-ms-flex-direction:row!important;flex-direction:row!important}.flex-sm-column{-ms-flex-direction:column!important;flex-direction:column!important}.flex-sm-row-reverse{-ms-flex-direction:row-reverse!important;flex-direction:row-reverse!important}.flex-sm-column-reverse{-ms-flex-direction:column-reverse!important;flex-direction:column-reverse!important}.flex-sm-wrap{-ms-flex-wrap:wrap!important;flex-wrap:wrap!important}.flex-sm-nowrap{-ms-flex-wrap:nowrap!important;flex-wrap:nowrap!important}.flex-sm-wrap-reverse{-ms-flex-wrap:wrap-reverse!important;flex-wrap:wrap-reverse!important}.flex-sm-fill{-ms-flex:auto!important;flex:auto!important}.flex-sm-grow-0{-ms-flex-positive:0!important;flex-grow:0!important}.flex-sm-grow-1{-ms-flex-positive:1!important;flex-grow:1!important}.flex-sm-shrink-0{-ms-flex-negative:0!important;flex-shrink:0!important}.flex-sm-shrink-1{-ms-flex-negative:1!important;flex-shrink:1!important}.justify-content-sm-start{justify-content:flex-start!important}.justify-content-sm-end{justify-content:flex-end!important}.justify-content-sm-center{justify-content:center!important}.justify-content-sm-between{justify-content:space-between!important}.justify-content-sm-around{justify-content:space-around!important}.align-items-sm-start{align-items:flex-start!important}.align-items-sm-end{align-items:flex-end!important}.align-items-sm-center{align-items:center!important}.align-items-sm-baseline{align-items:baseline!important}.align-items-sm-stretch{align-items:stretch!important}.align-content-sm-start{align-content:flex-start!important}.align-content-sm-end{align-content:flex-end!important}.align-content-sm-center{align-content:center!important}.align-content-sm-between{align-content:space-between!important}.align-content-sm-around{align-content:space-around!important}.align-content-sm-stretch{align-content:stretch!important}.align-self-sm-auto{align-self:auto!important}.align-self-sm-start{align-self:flex-start!important}.align-self-sm-end{align-self:flex-end!important}.align-self-sm-center{align-self:center!important}.align-self-sm-baseline{align-self:baseline!important}.align-self-sm-stretch{align-self:stretch!important}}@media (width>=768px){.flex-md-row{-ms-flex-direction:row!important;flex-direction:row!important}.flex-md-column{-ms-flex-direction:column!important;flex-direction:column!important}.flex-md-row-reverse{-ms-flex-direction:row-reverse!important;flex-direction:row-reverse!important}.flex-md-column-reverse{-ms-flex-direction:column-reverse!important;flex-direction:column-reverse!important}.flex-md-wrap{-ms-flex-wrap:wrap!important;flex-wrap:wrap!important}.flex-md-nowrap{-ms-flex-wrap:nowrap!important;flex-wrap:nowrap!important}.flex-md-wrap-reverse{-ms-flex-wrap:wrap-reverse!important;flex-wrap:wrap-reverse!important}.flex-md-fill{-ms-flex:auto!important;flex:auto!important}.flex-md-grow-0{-ms-flex-positive:0!important;flex-grow:0!important}.flex-md-grow-1{-ms-flex-positive:1!important;flex-grow:1!important}.flex-md-shrink-0{-ms-flex-negative:0!important;flex-shrink:0!important}.flex-md-shrink-1{-ms-flex-negative:1!important;flex-shrink:1!important}.justify-content-md-start{justify-content:flex-start!important}.justify-content-md-end{justify-content:flex-end!important}.justify-content-md-center{justify-content:center!important}.justify-content-md-between{justify-content:space-between!important}.justify-content-md-around{justify-content:space-around!important}.align-items-md-start{align-items:flex-start!important}.align-items-md-end{align-items:flex-end!important}.align-items-md-center{align-items:center!important}.align-items-md-baseline{align-items:baseline!important}.align-items-md-stretch{align-items:stretch!important}.align-content-md-start{align-content:flex-start!important}.align-content-md-end{align-content:flex-end!important}.align-content-md-center{align-content:center!important}.align-content-md-between{align-content:space-between!important}.align-content-md-around{align-content:space-around!important}.align-content-md-stretch{align-content:stretch!important}.align-self-md-auto{align-self:auto!important}.align-self-md-start{align-self:flex-start!important}.align-self-md-end{align-self:flex-end!important}.align-self-md-center{align-self:center!important}.align-self-md-baseline{align-self:baseline!important}.align-self-md-stretch{align-self:stretch!important}}@media (width>=992px){.flex-lg-row{-ms-flex-direction:row!important;flex-direction:row!important}.flex-lg-column{-ms-flex-direction:column!important;flex-direction:column!important}.flex-lg-row-reverse{-ms-flex-direction:row-reverse!important;flex-direction:row-reverse!important}.flex-lg-column-reverse{-ms-flex-direction:column-reverse!important;flex-direction:column-reverse!important}.flex-lg-wrap{-ms-flex-wrap:wrap!important;flex-wrap:wrap!important}.flex-lg-nowrap{-ms-flex-wrap:nowrap!important;flex-wrap:nowrap!important}.flex-lg-wrap-reverse{-ms-flex-wrap:wrap-reverse!important;flex-wrap:wrap-reverse!important}.flex-lg-fill{-ms-flex:auto!important;flex:auto!important}.flex-lg-grow-0{-ms-flex-positive:0!important;flex-grow:0!important}.flex-lg-grow-1{-ms-flex-positive:1!important;flex-grow:1!important}.flex-lg-shrink-0{-ms-flex-negative:0!important;flex-shrink:0!important}.flex-lg-shrink-1{-ms-flex-negative:1!important;flex-shrink:1!important}.justify-content-lg-start{justify-content:flex-start!important}.justify-content-lg-end{justify-content:flex-end!important}.justify-content-lg-center{justify-content:center!important}.justify-content-lg-between{justify-content:space-between!important}.justify-content-lg-around{justify-content:space-around!important}.align-items-lg-start{align-items:flex-start!important}.align-items-lg-end{align-items:flex-end!important}.align-items-lg-center{align-items:center!important}.align-items-lg-baseline{align-items:baseline!important}.align-items-lg-stretch{align-items:stretch!important}.align-content-lg-start{align-content:flex-start!important}.align-content-lg-end{align-content:flex-end!important}.align-content-lg-center{align-content:center!important}.align-content-lg-between{align-content:space-between!important}.align-content-lg-around{align-content:space-around!important}.align-content-lg-stretch{align-content:stretch!important}.align-self-lg-auto{align-self:auto!important}.align-self-lg-start{align-self:flex-start!important}.align-self-lg-end{align-self:flex-end!important}.align-self-lg-center{align-self:center!important}.align-self-lg-baseline{align-self:baseline!important}.align-self-lg-stretch{align-self:stretch!important}}@media (width>=1200px){.flex-xl-row{-ms-flex-direction:row!important;flex-direction:row!important}.flex-xl-column{-ms-flex-direction:column!important;flex-direction:column!important}.flex-xl-row-reverse{-ms-flex-direction:row-reverse!important;flex-direction:row-reverse!important}.flex-xl-column-reverse{-ms-flex-direction:column-reverse!important;flex-direction:column-reverse!important}.flex-xl-wrap{-ms-flex-wrap:wrap!important;flex-wrap:wrap!important}.flex-xl-nowrap{-ms-flex-wrap:nowrap!important;flex-wrap:nowrap!important}.flex-xl-wrap-reverse{-ms-flex-wrap:wrap-reverse!important;flex-wrap:wrap-reverse!important}.flex-xl-fill{-ms-flex:auto!important;flex:auto!important}.flex-xl-grow-0{-ms-flex-positive:0!important;flex-grow:0!important}.flex-xl-grow-1{-ms-flex-positive:1!important;flex-grow:1!important}.flex-xl-shrink-0{-ms-flex-negative:0!important;flex-shrink:0!important}.flex-xl-shrink-1{-ms-flex-negative:1!important;flex-shrink:1!important}.justify-content-xl-start{justify-content:flex-start!important}.justify-content-xl-end{justify-content:flex-end!important}.justify-content-xl-center{justify-content:center!important}.justify-content-xl-between{justify-content:space-between!important}.justify-content-xl-around{justify-content:space-around!important}.align-items-xl-start{align-items:flex-start!important}.align-items-xl-end{align-items:flex-end!important}.align-items-xl-center{align-items:center!important}.align-items-xl-baseline{align-items:baseline!important}.align-items-xl-stretch{align-items:stretch!important}.align-content-xl-start{align-content:flex-start!important}.align-content-xl-end{align-content:flex-end!important}.align-content-xl-center{align-content:center!important}.align-content-xl-between{align-content:space-between!important}.align-content-xl-around{align-content:space-around!important}.align-content-xl-stretch{align-content:stretch!important}.align-self-xl-auto{align-self:auto!important}.align-self-xl-start{align-self:flex-start!important}.align-self-xl-end{align-self:flex-end!important}.align-self-xl-center{align-self:center!important}.align-self-xl-baseline{align-self:baseline!important}.align-self-xl-stretch{align-self:stretch!important}}.float-left{float:left!important}.float-right{float:right!important}.float-none{float:none!important}@media (width>=576px){.float-sm-left{float:left!important}.float-sm-right{float:right!important}.float-sm-none{float:none!important}}@media (width>=768px){.float-md-left{float:left!important}.float-md-right{float:right!important}.float-md-none{float:none!important}}@media (width>=992px){.float-lg-left{float:left!important}.float-lg-right{float:right!important}.float-lg-none{float:none!important}}@media (width>=1200px){.float-xl-left{float:left!important}.float-xl-right{float:right!important}.float-xl-none{float:none!important}}.user-select-all{-webkit-user-select:all!important;-moz-user-select:all!important;user-select:all!important}.user-select-auto{-webkit-user-select:auto!important;-moz-user-select:auto!important;-ms-user-select:auto!important;user-select:auto!important}.user-select-none{-webkit-user-select:none!important;-moz-user-select:none!important;-ms-user-select:none!important;user-select:none!important}.overflow-auto{overflow:auto!important}.overflow-hidden{overflow:hidden!important}.position-static{position:static!important}.position-relative{position:relative!important}.position-absolute{position:absolute!important}.position-fixed{position:fixed!important}.position-sticky{position:-webkit-sticky!important;position:sticky!important}.fixed-top{z-index:1030;position:fixed;top:0;left:0;right:0}.fixed-bottom{z-index:1030;position:fixed;bottom:0;left:0;right:0}@supports (position:-webkit-sticky) or (position:sticky){.sticky-top{z-index:1020;position:-webkit-sticky;position:sticky;top:0}}.sr-only{clip:rect(0,0,0,0);white-space:nowrap;border:0;width:1px;height:1px;margin:-1px;padding:0;position:absolute;overflow:hidden}.sr-only-focusable:active,.sr-only-focusable:focus{clip:auto;white-space:normal;width:auto;height:auto;position:static;overflow:visible}.shadow-sm{box-shadow:0 .125rem .25rem #00000013!important}.shadow{box-shadow:0 .5rem 1rem #00000026!important}.shadow-lg{box-shadow:0 1rem 3rem #0000002d!important}.shadow-none{box-shadow:none!important}.w-25{width:25%!important}.w-50{width:50%!important}.w-75{width:75%!important}.w-100{width:100%!important}.w-auto{width:auto!important}.h-25{height:25%!important}.h-50{height:50%!important}.h-75{height:75%!important}.h-100{height:100%!important}.h-auto{height:auto!important}.mw-100{max-width:100%!important}.mh-100{max-height:100%!important}.min-vw-100{min-width:100vw!important}.min-vh-100{min-height:100vh!important}.vw-100{width:100vw!important}.vh-100{height:100vh!important}.m-0{margin:0!important}.mt-0,.my-0{margin-top:0!important}.mr-0,.mx-0{margin-right:0!important}.mb-0,.my-0{margin-bottom:0!important}.ml-0,.mx-0{margin-left:0!important}.m-1{margin:.25rem!important}.mt-1,.my-1{margin-top:.25rem!important}.mr-1,.mx-1{margin-right:.25rem!important}.mb-1,.my-1{margin-bottom:.25rem!important}.ml-1,.mx-1{margin-left:.25rem!important}.m-2{margin:.5rem!important}.mt-2,.my-2{margin-top:.5rem!important}.mr-2,.mx-2{margin-right:.5rem!important}.mb-2,.my-2{margin-bottom:.5rem!important}.ml-2,.mx-2{margin-left:.5rem!important}.m-3{margin:1rem!important}.mt-3,.my-3{margin-top:1rem!important}.mr-3,.mx-3{margin-right:1rem!important}.mb-3,.my-3{margin-bottom:1rem!important}.ml-3,.mx-3{margin-left:1rem!important}.m-4{margin:1.5rem!important}.mt-4,.my-4{margin-top:1.5rem!important}.mr-4,.mx-4{margin-right:1.5rem!important}.mb-4,.my-4{margin-bottom:1.5rem!important}.ml-4,.mx-4{margin-left:1.5rem!important}.m-5{margin:3rem!important}.mt-5,.my-5{margin-top:3rem!important}.mr-5,.mx-5{margin-right:3rem!important}.mb-5,.my-5{margin-bottom:3rem!important}.ml-5,.mx-5{margin-left:3rem!important}.p-0{padding:0!important}.pt-0,.py-0{padding-top:0!important}.pr-0,.px-0{padding-right:0!important}.pb-0,.py-0{padding-bottom:0!important}.pl-0,.px-0{padding-left:0!important}.p-1{padding:.25rem!important}.pt-1,.py-1{padding-top:.25rem!important}.pr-1,.px-1{padding-right:.25rem!important}.pb-1,.py-1{padding-bottom:.25rem!important}.pl-1,.px-1{padding-left:.25rem!important}.p-2{padding:.5rem!important}.pt-2,.py-2{padding-top:.5rem!important}.pr-2,.px-2{padding-right:.5rem!important}.pb-2,.py-2{padding-bottom:.5rem!important}.pl-2,.px-2{padding-left:.5rem!important}.p-3{padding:1rem!important}.pt-3,.py-3{padding-top:1rem!important}.pr-3,.px-3{padding-right:1rem!important}.pb-3,.py-3{padding-bottom:1rem!important}.pl-3,.px-3{padding-left:1rem!important}.p-4{padding:1.5rem!important}.pt-4,.py-4{padding-top:1.5rem!important}.pr-4,.px-4{padding-right:1.5rem!important}.pb-4,.py-4{padding-bottom:1.5rem!important}.pl-4,.px-4{padding-left:1.5rem!important}.p-5{padding:3rem!important}.pt-5,.py-5{padding-top:3rem!important}.pr-5,.px-5{padding-right:3rem!important}.pb-5,.py-5{padding-bottom:3rem!important}.pl-5,.px-5{padding-left:3rem!important}.m-n1{margin:-.25rem!important}.mt-n1,.my-n1{margin-top:-.25rem!important}.mr-n1,.mx-n1{margin-right:-.25rem!important}.mb-n1,.my-n1{margin-bottom:-.25rem!important}.ml-n1,.mx-n1{margin-left:-.25rem!important}.m-n2{margin:-.5rem!important}.mt-n2,.my-n2{margin-top:-.5rem!important}.mr-n2,.mx-n2{margin-right:-.5rem!important}.mb-n2,.my-n2{margin-bottom:-.5rem!important}.ml-n2,.mx-n2{margin-left:-.5rem!important}.m-n3{margin:-1rem!important}.mt-n3,.my-n3{margin-top:-1rem!important}.mr-n3,.mx-n3{margin-right:-1rem!important}.mb-n3,.my-n3{margin-bottom:-1rem!important}.ml-n3,.mx-n3{margin-left:-1rem!important}.m-n4{margin:-1.5rem!important}.mt-n4,.my-n4{margin-top:-1.5rem!important}.mr-n4,.mx-n4{margin-right:-1.5rem!important}.mb-n4,.my-n4{margin-bottom:-1.5rem!important}.ml-n4,.mx-n4{margin-left:-1.5rem!important}.m-n5{margin:-3rem!important}.mt-n5,.my-n5{margin-top:-3rem!important}.mr-n5,.mx-n5{margin-right:-3rem!important}.mb-n5,.my-n5{margin-bottom:-3rem!important}.ml-n5,.mx-n5{margin-left:-3rem!important}.m-auto{margin:auto!important}.mt-auto,.my-auto{margin-top:auto!important}.mr-auto,.mx-auto{margin-right:auto!important}.mb-auto,.my-auto{margin-bottom:auto!important}.ml-auto,.mx-auto{margin-left:auto!important}@media (width>=576px){.m-sm-0{margin:0!important}.mt-sm-0,.my-sm-0{margin-top:0!important}.mr-sm-0,.mx-sm-0{margin-right:0!important}.mb-sm-0,.my-sm-0{margin-bottom:0!important}.ml-sm-0,.mx-sm-0{margin-left:0!important}.m-sm-1{margin:.25rem!important}.mt-sm-1,.my-sm-1{margin-top:.25rem!important}.mr-sm-1,.mx-sm-1{margin-right:.25rem!important}.mb-sm-1,.my-sm-1{margin-bottom:.25rem!important}.ml-sm-1,.mx-sm-1{margin-left:.25rem!important}.m-sm-2{margin:.5rem!important}.mt-sm-2,.my-sm-2{margin-top:.5rem!important}.mr-sm-2,.mx-sm-2{margin-right:.5rem!important}.mb-sm-2,.my-sm-2{margin-bottom:.5rem!important}.ml-sm-2,.mx-sm-2{margin-left:.5rem!important}.m-sm-3{margin:1rem!important}.mt-sm-3,.my-sm-3{margin-top:1rem!important}.mr-sm-3,.mx-sm-3{margin-right:1rem!important}.mb-sm-3,.my-sm-3{margin-bottom:1rem!important}.ml-sm-3,.mx-sm-3{margin-left:1rem!important}.m-sm-4{margin:1.5rem!important}.mt-sm-4,.my-sm-4{margin-top:1.5rem!important}.mr-sm-4,.mx-sm-4{margin-right:1.5rem!important}.mb-sm-4,.my-sm-4{margin-bottom:1.5rem!important}.ml-sm-4,.mx-sm-4{margin-left:1.5rem!important}.m-sm-5{margin:3rem!important}.mt-sm-5,.my-sm-5{margin-top:3rem!important}.mr-sm-5,.mx-sm-5{margin-right:3rem!important}.mb-sm-5,.my-sm-5{margin-bottom:3rem!important}.ml-sm-5,.mx-sm-5{margin-left:3rem!important}.p-sm-0{padding:0!important}.pt-sm-0,.py-sm-0{padding-top:0!important}.pr-sm-0,.px-sm-0{padding-right:0!important}.pb-sm-0,.py-sm-0{padding-bottom:0!important}.pl-sm-0,.px-sm-0{padding-left:0!important}.p-sm-1{padding:.25rem!important}.pt-sm-1,.py-sm-1{padding-top:.25rem!important}.pr-sm-1,.px-sm-1{padding-right:.25rem!important}.pb-sm-1,.py-sm-1{padding-bottom:.25rem!important}.pl-sm-1,.px-sm-1{padding-left:.25rem!important}.p-sm-2{padding:.5rem!important}.pt-sm-2,.py-sm-2{padding-top:.5rem!important}.pr-sm-2,.px-sm-2{padding-right:.5rem!important}.pb-sm-2,.py-sm-2{padding-bottom:.5rem!important}.pl-sm-2,.px-sm-2{padding-left:.5rem!important}.p-sm-3{padding:1rem!important}.pt-sm-3,.py-sm-3{padding-top:1rem!important}.pr-sm-3,.px-sm-3{padding-right:1rem!important}.pb-sm-3,.py-sm-3{padding-bottom:1rem!important}.pl-sm-3,.px-sm-3{padding-left:1rem!important}.p-sm-4{padding:1.5rem!important}.pt-sm-4,.py-sm-4{padding-top:1.5rem!important}.pr-sm-4,.px-sm-4{padding-right:1.5rem!important}.pb-sm-4,.py-sm-4{padding-bottom:1.5rem!important}.pl-sm-4,.px-sm-4{padding-left:1.5rem!important}.p-sm-5{padding:3rem!important}.pt-sm-5,.py-sm-5{padding-top:3rem!important}.pr-sm-5,.px-sm-5{padding-right:3rem!important}.pb-sm-5,.py-sm-5{padding-bottom:3rem!important}.pl-sm-5,.px-sm-5{padding-left:3rem!important}.m-sm-n1{margin:-.25rem!important}.mt-sm-n1,.my-sm-n1{margin-top:-.25rem!important}.mr-sm-n1,.mx-sm-n1{margin-right:-.25rem!important}.mb-sm-n1,.my-sm-n1{margin-bottom:-.25rem!important}.ml-sm-n1,.mx-sm-n1{margin-left:-.25rem!important}.m-sm-n2{margin:-.5rem!important}.mt-sm-n2,.my-sm-n2{margin-top:-.5rem!important}.mr-sm-n2,.mx-sm-n2{margin-right:-.5rem!important}.mb-sm-n2,.my-sm-n2{margin-bottom:-.5rem!important}.ml-sm-n2,.mx-sm-n2{margin-left:-.5rem!important}.m-sm-n3{margin:-1rem!important}.mt-sm-n3,.my-sm-n3{margin-top:-1rem!important}.mr-sm-n3,.mx-sm-n3{margin-right:-1rem!important}.mb-sm-n3,.my-sm-n3{margin-bottom:-1rem!important}.ml-sm-n3,.mx-sm-n3{margin-left:-1rem!important}.m-sm-n4{margin:-1.5rem!important}.mt-sm-n4,.my-sm-n4{margin-top:-1.5rem!important}.mr-sm-n4,.mx-sm-n4{margin-right:-1.5rem!important}.mb-sm-n4,.my-sm-n4{margin-bottom:-1.5rem!important}.ml-sm-n4,.mx-sm-n4{margin-left:-1.5rem!important}.m-sm-n5{margin:-3rem!important}.mt-sm-n5,.my-sm-n5{margin-top:-3rem!important}.mr-sm-n5,.mx-sm-n5{margin-right:-3rem!important}.mb-sm-n5,.my-sm-n5{margin-bottom:-3rem!important}.ml-sm-n5,.mx-sm-n5{margin-left:-3rem!important}.m-sm-auto{margin:auto!important}.mt-sm-auto,.my-sm-auto{margin-top:auto!important}.mr-sm-auto,.mx-sm-auto{margin-right:auto!important}.mb-sm-auto,.my-sm-auto{margin-bottom:auto!important}.ml-sm-auto,.mx-sm-auto{margin-left:auto!important}}@media (width>=768px){.m-md-0{margin:0!important}.mt-md-0,.my-md-0{margin-top:0!important}.mr-md-0,.mx-md-0{margin-right:0!important}.mb-md-0,.my-md-0{margin-bottom:0!important}.ml-md-0,.mx-md-0{margin-left:0!important}.m-md-1{margin:.25rem!important}.mt-md-1,.my-md-1{margin-top:.25rem!important}.mr-md-1,.mx-md-1{margin-right:.25rem!important}.mb-md-1,.my-md-1{margin-bottom:.25rem!important}.ml-md-1,.mx-md-1{margin-left:.25rem!important}.m-md-2{margin:.5rem!important}.mt-md-2,.my-md-2{margin-top:.5rem!important}.mr-md-2,.mx-md-2{margin-right:.5rem!important}.mb-md-2,.my-md-2{margin-bottom:.5rem!important}.ml-md-2,.mx-md-2{margin-left:.5rem!important}.m-md-3{margin:1rem!important}.mt-md-3,.my-md-3{margin-top:1rem!important}.mr-md-3,.mx-md-3{margin-right:1rem!important}.mb-md-3,.my-md-3{margin-bottom:1rem!important}.ml-md-3,.mx-md-3{margin-left:1rem!important}.m-md-4{margin:1.5rem!important}.mt-md-4,.my-md-4{margin-top:1.5rem!important}.mr-md-4,.mx-md-4{margin-right:1.5rem!important}.mb-md-4,.my-md-4{margin-bottom:1.5rem!important}.ml-md-4,.mx-md-4{margin-left:1.5rem!important}.m-md-5{margin:3rem!important}.mt-md-5,.my-md-5{margin-top:3rem!important}.mr-md-5,.mx-md-5{margin-right:3rem!important}.mb-md-5,.my-md-5{margin-bottom:3rem!important}.ml-md-5,.mx-md-5{margin-left:3rem!important}.p-md-0{padding:0!important}.pt-md-0,.py-md-0{padding-top:0!important}.pr-md-0,.px-md-0{padding-right:0!important}.pb-md-0,.py-md-0{padding-bottom:0!important}.pl-md-0,.px-md-0{padding-left:0!important}.p-md-1{padding:.25rem!important}.pt-md-1,.py-md-1{padding-top:.25rem!important}.pr-md-1,.px-md-1{padding-right:.25rem!important}.pb-md-1,.py-md-1{padding-bottom:.25rem!important}.pl-md-1,.px-md-1{padding-left:.25rem!important}.p-md-2{padding:.5rem!important}.pt-md-2,.py-md-2{padding-top:.5rem!important}.pr-md-2,.px-md-2{padding-right:.5rem!important}.pb-md-2,.py-md-2{padding-bottom:.5rem!important}.pl-md-2,.px-md-2{padding-left:.5rem!important}.p-md-3{padding:1rem!important}.pt-md-3,.py-md-3{padding-top:1rem!important}.pr-md-3,.px-md-3{padding-right:1rem!important}.pb-md-3,.py-md-3{padding-bottom:1rem!important}.pl-md-3,.px-md-3{padding-left:1rem!important}.p-md-4{padding:1.5rem!important}.pt-md-4,.py-md-4{padding-top:1.5rem!important}.pr-md-4,.px-md-4{padding-right:1.5rem!important}.pb-md-4,.py-md-4{padding-bottom:1.5rem!important}.pl-md-4,.px-md-4{padding-left:1.5rem!important}.p-md-5{padding:3rem!important}.pt-md-5,.py-md-5{padding-top:3rem!important}.pr-md-5,.px-md-5{padding-right:3rem!important}.pb-md-5,.py-md-5{padding-bottom:3rem!important}.pl-md-5,.px-md-5{padding-left:3rem!important}.m-md-n1{margin:-.25rem!important}.mt-md-n1,.my-md-n1{margin-top:-.25rem!important}.mr-md-n1,.mx-md-n1{margin-right:-.25rem!important}.mb-md-n1,.my-md-n1{margin-bottom:-.25rem!important}.ml-md-n1,.mx-md-n1{margin-left:-.25rem!important}.m-md-n2{margin:-.5rem!important}.mt-md-n2,.my-md-n2{margin-top:-.5rem!important}.mr-md-n2,.mx-md-n2{margin-right:-.5rem!important}.mb-md-n2,.my-md-n2{margin-bottom:-.5rem!important}.ml-md-n2,.mx-md-n2{margin-left:-.5rem!important}.m-md-n3{margin:-1rem!important}.mt-md-n3,.my-md-n3{margin-top:-1rem!important}.mr-md-n3,.mx-md-n3{margin-right:-1rem!important}.mb-md-n3,.my-md-n3{margin-bottom:-1rem!important}.ml-md-n3,.mx-md-n3{margin-left:-1rem!important}.m-md-n4{margin:-1.5rem!important}.mt-md-n4,.my-md-n4{margin-top:-1.5rem!important}.mr-md-n4,.mx-md-n4{margin-right:-1.5rem!important}.mb-md-n4,.my-md-n4{margin-bottom:-1.5rem!important}.ml-md-n4,.mx-md-n4{margin-left:-1.5rem!important}.m-md-n5{margin:-3rem!important}.mt-md-n5,.my-md-n5{margin-top:-3rem!important}.mr-md-n5,.mx-md-n5{margin-right:-3rem!important}.mb-md-n5,.my-md-n5{margin-bottom:-3rem!important}.ml-md-n5,.mx-md-n5{margin-left:-3rem!important}.m-md-auto{margin:auto!important}.mt-md-auto,.my-md-auto{margin-top:auto!important}.mr-md-auto,.mx-md-auto{margin-right:auto!important}.mb-md-auto,.my-md-auto{margin-bottom:auto!important}.ml-md-auto,.mx-md-auto{margin-left:auto!important}}@media (width>=992px){.m-lg-0{margin:0!important}.mt-lg-0,.my-lg-0{margin-top:0!important}.mr-lg-0,.mx-lg-0{margin-right:0!important}.mb-lg-0,.my-lg-0{margin-bottom:0!important}.ml-lg-0,.mx-lg-0{margin-left:0!important}.m-lg-1{margin:.25rem!important}.mt-lg-1,.my-lg-1{margin-top:.25rem!important}.mr-lg-1,.mx-lg-1{margin-right:.25rem!important}.mb-lg-1,.my-lg-1{margin-bottom:.25rem!important}.ml-lg-1,.mx-lg-1{margin-left:.25rem!important}.m-lg-2{margin:.5rem!important}.mt-lg-2,.my-lg-2{margin-top:.5rem!important}.mr-lg-2,.mx-lg-2{margin-right:.5rem!important}.mb-lg-2,.my-lg-2{margin-bottom:.5rem!important}.ml-lg-2,.mx-lg-2{margin-left:.5rem!important}.m-lg-3{margin:1rem!important}.mt-lg-3,.my-lg-3{margin-top:1rem!important}.mr-lg-3,.mx-lg-3{margin-right:1rem!important}.mb-lg-3,.my-lg-3{margin-bottom:1rem!important}.ml-lg-3,.mx-lg-3{margin-left:1rem!important}.m-lg-4{margin:1.5rem!important}.mt-lg-4,.my-lg-4{margin-top:1.5rem!important}.mr-lg-4,.mx-lg-4{margin-right:1.5rem!important}.mb-lg-4,.my-lg-4{margin-bottom:1.5rem!important}.ml-lg-4,.mx-lg-4{margin-left:1.5rem!important}.m-lg-5{margin:3rem!important}.mt-lg-5,.my-lg-5{margin-top:3rem!important}.mr-lg-5,.mx-lg-5{margin-right:3rem!important}.mb-lg-5,.my-lg-5{margin-bottom:3rem!important}.ml-lg-5,.mx-lg-5{margin-left:3rem!important}.p-lg-0{padding:0!important}.pt-lg-0,.py-lg-0{padding-top:0!important}.pr-lg-0,.px-lg-0{padding-right:0!important}.pb-lg-0,.py-lg-0{padding-bottom:0!important}.pl-lg-0,.px-lg-0{padding-left:0!important}.p-lg-1{padding:.25rem!important}.pt-lg-1,.py-lg-1{padding-top:.25rem!important}.pr-lg-1,.px-lg-1{padding-right:.25rem!important}.pb-lg-1,.py-lg-1{padding-bottom:.25rem!important}.pl-lg-1,.px-lg-1{padding-left:.25rem!important}.p-lg-2{padding:.5rem!important}.pt-lg-2,.py-lg-2{padding-top:.5rem!important}.pr-lg-2,.px-lg-2{padding-right:.5rem!important}.pb-lg-2,.py-lg-2{padding-bottom:.5rem!important}.pl-lg-2,.px-lg-2{padding-left:.5rem!important}.p-lg-3{padding:1rem!important}.pt-lg-3,.py-lg-3{padding-top:1rem!important}.pr-lg-3,.px-lg-3{padding-right:1rem!important}.pb-lg-3,.py-lg-3{padding-bottom:1rem!important}.pl-lg-3,.px-lg-3{padding-left:1rem!important}.p-lg-4{padding:1.5rem!important}.pt-lg-4,.py-lg-4{padding-top:1.5rem!important}.pr-lg-4,.px-lg-4{padding-right:1.5rem!important}.pb-lg-4,.py-lg-4{padding-bottom:1.5rem!important}.pl-lg-4,.px-lg-4{padding-left:1.5rem!important}.p-lg-5{padding:3rem!important}.pt-lg-5,.py-lg-5{padding-top:3rem!important}.pr-lg-5,.px-lg-5{padding-right:3rem!important}.pb-lg-5,.py-lg-5{padding-bottom:3rem!important}.pl-lg-5,.px-lg-5{padding-left:3rem!important}.m-lg-n1{margin:-.25rem!important}.mt-lg-n1,.my-lg-n1{margin-top:-.25rem!important}.mr-lg-n1,.mx-lg-n1{margin-right:-.25rem!important}.mb-lg-n1,.my-lg-n1{margin-bottom:-.25rem!important}.ml-lg-n1,.mx-lg-n1{margin-left:-.25rem!important}.m-lg-n2{margin:-.5rem!important}.mt-lg-n2,.my-lg-n2{margin-top:-.5rem!important}.mr-lg-n2,.mx-lg-n2{margin-right:-.5rem!important}.mb-lg-n2,.my-lg-n2{margin-bottom:-.5rem!important}.ml-lg-n2,.mx-lg-n2{margin-left:-.5rem!important}.m-lg-n3{margin:-1rem!important}.mt-lg-n3,.my-lg-n3{margin-top:-1rem!important}.mr-lg-n3,.mx-lg-n3{margin-right:-1rem!important}.mb-lg-n3,.my-lg-n3{margin-bottom:-1rem!important}.ml-lg-n3,.mx-lg-n3{margin-left:-1rem!important}.m-lg-n4{margin:-1.5rem!important}.mt-lg-n4,.my-lg-n4{margin-top:-1.5rem!important}.mr-lg-n4,.mx-lg-n4{margin-right:-1.5rem!important}.mb-lg-n4,.my-lg-n4{margin-bottom:-1.5rem!important}.ml-lg-n4,.mx-lg-n4{margin-left:-1.5rem!important}.m-lg-n5{margin:-3rem!important}.mt-lg-n5,.my-lg-n5{margin-top:-3rem!important}.mr-lg-n5,.mx-lg-n5{margin-right:-3rem!important}.mb-lg-n5,.my-lg-n5{margin-bottom:-3rem!important}.ml-lg-n5,.mx-lg-n5{margin-left:-3rem!important}.m-lg-auto{margin:auto!important}.mt-lg-auto,.my-lg-auto{margin-top:auto!important}.mr-lg-auto,.mx-lg-auto{margin-right:auto!important}.mb-lg-auto,.my-lg-auto{margin-bottom:auto!important}.ml-lg-auto,.mx-lg-auto{margin-left:auto!important}}@media (width>=1200px){.m-xl-0{margin:0!important}.mt-xl-0,.my-xl-0{margin-top:0!important}.mr-xl-0,.mx-xl-0{margin-right:0!important}.mb-xl-0,.my-xl-0{margin-bottom:0!important}.ml-xl-0,.mx-xl-0{margin-left:0!important}.m-xl-1{margin:.25rem!important}.mt-xl-1,.my-xl-1{margin-top:.25rem!important}.mr-xl-1,.mx-xl-1{margin-right:.25rem!important}.mb-xl-1,.my-xl-1{margin-bottom:.25rem!important}.ml-xl-1,.mx-xl-1{margin-left:.25rem!important}.m-xl-2{margin:.5rem!important}.mt-xl-2,.my-xl-2{margin-top:.5rem!important}.mr-xl-2,.mx-xl-2{margin-right:.5rem!important}.mb-xl-2,.my-xl-2{margin-bottom:.5rem!important}.ml-xl-2,.mx-xl-2{margin-left:.5rem!important}.m-xl-3{margin:1rem!important}.mt-xl-3,.my-xl-3{margin-top:1rem!important}.mr-xl-3,.mx-xl-3{margin-right:1rem!important}.mb-xl-3,.my-xl-3{margin-bottom:1rem!important}.ml-xl-3,.mx-xl-3{margin-left:1rem!important}.m-xl-4{margin:1.5rem!important}.mt-xl-4,.my-xl-4{margin-top:1.5rem!important}.mr-xl-4,.mx-xl-4{margin-right:1.5rem!important}.mb-xl-4,.my-xl-4{margin-bottom:1.5rem!important}.ml-xl-4,.mx-xl-4{margin-left:1.5rem!important}.m-xl-5{margin:3rem!important}.mt-xl-5,.my-xl-5{margin-top:3rem!important}.mr-xl-5,.mx-xl-5{margin-right:3rem!important}.mb-xl-5,.my-xl-5{margin-bottom:3rem!important}.ml-xl-5,.mx-xl-5{margin-left:3rem!important}.p-xl-0{padding:0!important}.pt-xl-0,.py-xl-0{padding-top:0!important}.pr-xl-0,.px-xl-0{padding-right:0!important}.pb-xl-0,.py-xl-0{padding-bottom:0!important}.pl-xl-0,.px-xl-0{padding-left:0!important}.p-xl-1{padding:.25rem!important}.pt-xl-1,.py-xl-1{padding-top:.25rem!important}.pr-xl-1,.px-xl-1{padding-right:.25rem!important}.pb-xl-1,.py-xl-1{padding-bottom:.25rem!important}.pl-xl-1,.px-xl-1{padding-left:.25rem!important}.p-xl-2{padding:.5rem!important}.pt-xl-2,.py-xl-2{padding-top:.5rem!important}.pr-xl-2,.px-xl-2{padding-right:.5rem!important}.pb-xl-2,.py-xl-2{padding-bottom:.5rem!important}.pl-xl-2,.px-xl-2{padding-left:.5rem!important}.p-xl-3{padding:1rem!important}.pt-xl-3,.py-xl-3{padding-top:1rem!important}.pr-xl-3,.px-xl-3{padding-right:1rem!important}.pb-xl-3,.py-xl-3{padding-bottom:1rem!important}.pl-xl-3,.px-xl-3{padding-left:1rem!important}.p-xl-4{padding:1.5rem!important}.pt-xl-4,.py-xl-4{padding-top:1.5rem!important}.pr-xl-4,.px-xl-4{padding-right:1.5rem!important}.pb-xl-4,.py-xl-4{padding-bottom:1.5rem!important}.pl-xl-4,.px-xl-4{padding-left:1.5rem!important}.p-xl-5{padding:3rem!important}.pt-xl-5,.py-xl-5{padding-top:3rem!important}.pr-xl-5,.px-xl-5{padding-right:3rem!important}.pb-xl-5,.py-xl-5{padding-bottom:3rem!important}.pl-xl-5,.px-xl-5{padding-left:3rem!important}.m-xl-n1{margin:-.25rem!important}.mt-xl-n1,.my-xl-n1{margin-top:-.25rem!important}.mr-xl-n1,.mx-xl-n1{margin-right:-.25rem!important}.mb-xl-n1,.my-xl-n1{margin-bottom:-.25rem!important}.ml-xl-n1,.mx-xl-n1{margin-left:-.25rem!important}.m-xl-n2{margin:-.5rem!important}.mt-xl-n2,.my-xl-n2{margin-top:-.5rem!important}.mr-xl-n2,.mx-xl-n2{margin-right:-.5rem!important}.mb-xl-n2,.my-xl-n2{margin-bottom:-.5rem!important}.ml-xl-n2,.mx-xl-n2{margin-left:-.5rem!important}.m-xl-n3{margin:-1rem!important}.mt-xl-n3,.my-xl-n3{margin-top:-1rem!important}.mr-xl-n3,.mx-xl-n3{margin-right:-1rem!important}.mb-xl-n3,.my-xl-n3{margin-bottom:-1rem!important}.ml-xl-n3,.mx-xl-n3{margin-left:-1rem!important}.m-xl-n4{margin:-1.5rem!important}.mt-xl-n4,.my-xl-n4{margin-top:-1.5rem!important}.mr-xl-n4,.mx-xl-n4{margin-right:-1.5rem!important}.mb-xl-n4,.my-xl-n4{margin-bottom:-1.5rem!important}.ml-xl-n4,.mx-xl-n4{margin-left:-1.5rem!important}.m-xl-n5{margin:-3rem!important}.mt-xl-n5,.my-xl-n5{margin-top:-3rem!important}.mr-xl-n5,.mx-xl-n5{margin-right:-3rem!important}.mb-xl-n5,.my-xl-n5{margin-bottom:-3rem!important}.ml-xl-n5,.mx-xl-n5{margin-left:-3rem!important}.m-xl-auto{margin:auto!important}.mt-xl-auto,.my-xl-auto{margin-top:auto!important}.mr-xl-auto,.mx-xl-auto{margin-right:auto!important}.mb-xl-auto,.my-xl-auto{margin-bottom:auto!important}.ml-xl-auto,.mx-xl-auto{margin-left:auto!important}}.stretched-link:after{z-index:1;pointer-events:auto;content:"";background-color:#0000;position:absolute;inset:0}.text-monospace{font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,monospace!important}.text-justify{text-align:justify!important}.text-wrap{white-space:normal!important}.text-nowrap{white-space:nowrap!important}.text-truncate{text-overflow:ellipsis;white-space:nowrap;overflow:hidden}.text-left{text-align:left!important}.text-right{text-align:right!important}.text-center{text-align:center!important}@media (width>=576px){.text-sm-left{text-align:left!important}.text-sm-right{text-align:right!important}.text-sm-center{text-align:center!important}}@media (width>=768px){.text-md-left{text-align:left!important}.text-md-right{text-align:right!important}.text-md-center{text-align:center!important}}@media (width>=992px){.text-lg-left{text-align:left!important}.text-lg-right{text-align:right!important}.text-lg-center{text-align:center!important}}@media (width>=1200px){.text-xl-left{text-align:left!important}.text-xl-right{text-align:right!important}.text-xl-center{text-align:center!important}}.text-lowercase{text-transform:lowercase!important}.text-uppercase{text-transform:uppercase!important}.text-capitalize{text-transform:capitalize!important}.font-weight-light{font-weight:300!important}.font-weight-lighter{font-weight:lighter!important}.font-weight-normal{font-weight:400!important}.font-weight-bold{font-weight:700!important}.font-weight-bolder{font-weight:bolder!important}.font-italic{font-style:italic!important}.text-white{color:#fff!important}.text-primary{color:#007bff!important}a.text-primary:hover,a.text-primary:focus{color:#0056b3!important}.text-secondary{color:#6c757d!important}a.text-secondary:hover,a.text-secondary:focus{color:#494f54!important}.text-success{color:#28a745!important}a.text-success:hover,a.text-success:focus{color:#19692c!important}.text-info{color:#17a2b8!important}a.text-info:hover,a.text-info:focus{color:#0f6674!important}.text-warning{color:#ffc107!important}a.text-warning:hover,a.text-warning:focus{color:#ba8b00!important}.text-danger{color:#dc3545!important}a.text-danger:hover,a.text-danger:focus{color:#a71d2a!important}.text-light{color:#f8f9fa!important}a.text-light:hover,a.text-light:focus{color:#cbd3da!important}.text-dark{color:#343a40!important}a.text-dark:hover,a.text-dark:focus{color:#121416!important}.text-body{color:#212529!important}.text-muted{color:#6c757d!important}.text-black-50{color:#00000080!important}.text-white-50{color:#ffffff80!important}.text-hide{font:0/0 a;color:#0000;text-shadow:none;background-color:#0000;border:0}.text-decoration-none{text-decoration:none!important}.text-break{word-break:break-word!important;word-wrap:break-word!important}.text-reset{color:inherit!important}.visible{visibility:visible!important}.invisible{visibility:hidden!important}@media print{*,:before,:after{text-shadow:none!important;box-shadow:none!important}a:not(.btn){text-decoration:underline}abbr[title]:after{content:" (" attr(title)")"}pre{white-space:pre-wrap!important}pre,blockquote{page-break-inside:avoid;border:1px solid #adb5bd}tr,img{page-break-inside:avoid}p,h2,h3{orphans:3;widows:3}h2,h3{page-break-after:avoid}@page{size:a3}body,.container{min-width:992px!important}.navbar{display:none}.badge{border:1px solid #000}.table{border-collapse:collapse!important}.table td,.table th{background-color:#fff!important}.table-bordered th,.table-bordered td{border:1px solid #dee2e6!important}.table-dark{color:inherit}.table-dark th,.table-dark td,.table-dark thead th,.table-dark tbody+tbody{border-color:#dee2e6}.table .thead-dark th{color:inherit;border-color:#dee2e6}}
\ No newline at end of file
diff --git a/test/js/bun/css/files/bulma.css b/test/js/bun/css/files/bulma.css
new file mode 100644
index 0000000000..06db48afa7
--- /dev/null
+++ b/test/js/bun/css/files/bulma.css
@@ -0,0 +1,21551 @@
+@charset "UTF-8";
+/*! bulma.io v1.0.2 | MIT License | github.com/jgthms/bulma */
+/* Bulma Utilities */
+:root {
+  --bulma-control-radius: var(--bulma-radius);
+  --bulma-control-radius-small: var(--bulma-radius-small);
+  --bulma-control-border-width: 1px;
+  --bulma-control-height: 2.5em;
+  --bulma-control-line-height: 1.5;
+  --bulma-control-padding-vertical: calc(0.5em - 1px);
+  --bulma-control-padding-horizontal: calc(0.75em - 1px);
+  --bulma-control-size: var(--bulma-size-normal);
+  --bulma-control-focus-shadow-l: 50%;
+}
+
+/* Bulma Themes */
+:root {
+  --bulma-scheme-h: 221;
+  --bulma-scheme-s: 14%;
+  --bulma-light-l: 90%;
+  --bulma-light-invert-l: 20%;
+  --bulma-dark-l: 20%;
+  --bulma-dark-invert-l: 90%;
+  --bulma-soft-l: 90%;
+  --bulma-bold-l: 20%;
+  --bulma-soft-invert-l: 20%;
+  --bulma-bold-invert-l: 90%;
+  --bulma-hover-background-l-delta: -5%;
+  --bulma-active-background-l-delta: -10%;
+  --bulma-hover-border-l-delta: -10%;
+  --bulma-active-border-l-delta: -20%;
+  --bulma-hover-color-l-delta: -5%;
+  --bulma-active-color-l-delta: -10%;
+  --bulma-hover-shadow-a-delta: -0.05;
+  --bulma-active-shadow-a-delta: -0.1;
+  --bulma-scheme-brightness: light;
+  --bulma-scheme-main-l: 100%;
+  --bulma-scheme-main-bis-l: 98%;
+  --bulma-scheme-main-ter-l: 96%;
+  --bulma-background-l: 96%;
+  --bulma-border-weak-l: 93%;
+  --bulma-border-l: 86%;
+  --bulma-text-weak-l: 48%;
+  --bulma-text-l: 29%;
+  --bulma-text-strong-l: 21%;
+  --bulma-text-title-l: 14%;
+  --bulma-scheme-invert-ter-l: 14%;
+  --bulma-scheme-invert-bis-l: 7%;
+  --bulma-scheme-invert-l: 4%;
+  --bulma-family-primary: Inter, SF Pro, Segoe UI, Roboto, Oxygen, Ubuntu, Helvetica Neue, Helvetica, Arial, sans-serif;
+  --bulma-family-secondary: Inter, SF Pro, Segoe UI, Roboto, Oxygen, Ubuntu, Helvetica Neue, Helvetica, Arial, sans-serif;
+  --bulma-family-code: Inconsolata, Hack, SF Mono, Roboto Mono, Source Code Pro, Ubuntu Mono, monospace;
+  --bulma-size-small: 0.75rem;
+  --bulma-size-normal: 1rem;
+  --bulma-size-medium: 1.25rem;
+  --bulma-size-large: 1.5rem;
+  --bulma-weight-light: 300;
+  --bulma-weight-normal: 400;
+  --bulma-weight-medium: 500;
+  --bulma-weight-semibold: 600;
+  --bulma-weight-bold: 700;
+  --bulma-weight-extrabold: 800;
+  --bulma-block-spacing: 1.5rem;
+  --bulma-duration: 294ms;
+  --bulma-easing: ease-out;
+  --bulma-radius-small: 0.25rem;
+  --bulma-radius: 0.375rem;
+  --bulma-radius-medium: 0.5em;
+  --bulma-radius-large: 0.75rem;
+  --bulma-radius-rounded: 9999px;
+  --bulma-speed: 86ms;
+  --bulma-arrow-color: var(--bulma-link);
+  --bulma-loading-color: var(--bulma-border);
+  --bulma-burger-h: var(--bulma-link-h);
+  --bulma-burger-s: var(--bulma-link-s);
+  --bulma-burger-l: var(--bulma-link-l);
+  --bulma-burger-border-radius: 0.5em;
+  --bulma-burger-gap: 5px;
+  --bulma-burger-item-height: 2px;
+  --bulma-burger-item-width: 20px;
+  --bulma-white: hsla(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-l), 1);
+  --bulma-white-base: hsla(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-l), 1);
+  --bulma-white-rgb: 255, 255, 255;
+  --bulma-white-h: 221deg;
+  --bulma-white-s: 14%;
+  --bulma-white-l: 100%;
+  --bulma-white-invert-l: 4%;
+  --bulma-white-invert: hsl(221, 14%, 4%);
+  --bulma-white-on-scheme-l: 35%;
+  --bulma-white-on-scheme: hsla(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-on-scheme-l), 1);
+  --bulma-black: hsla(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-l), 1);
+  --bulma-black-base: hsla(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-l), 1);
+  --bulma-black-rgb: 9, 10, 12;
+  --bulma-black-h: 221deg;
+  --bulma-black-s: 14%;
+  --bulma-black-l: 4%;
+  --bulma-black-invert-l: 100%;
+  --bulma-black-invert: hsl(221, 14%, 100%);
+  --bulma-black-on-scheme-l: 4%;
+  --bulma-black-on-scheme: hsla(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-on-scheme-l), 1);
+  --bulma-light: hsla(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-l), 1);
+  --bulma-light-base: hsla(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-l), 1);
+  --bulma-light-rgb: 243, 244, 246;
+  --bulma-light-h: 221deg;
+  --bulma-light-s: 14%;
+  --bulma-light-l: 96%;
+  --bulma-light-invert-l: 21%;
+  --bulma-light-invert: hsl(221, 14%, 21%);
+  --bulma-light-on-scheme-l: 36%;
+  --bulma-light-on-scheme: hsla(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-on-scheme-l), 1);
+  --bulma-dark: hsla(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-l), 1);
+  --bulma-dark-base: hsla(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-l), 1);
+  --bulma-dark-rgb: 46, 51, 61;
+  --bulma-dark-h: 221deg;
+  --bulma-dark-s: 14%;
+  --bulma-dark-l: 21%;
+  --bulma-dark-invert-l: 96%;
+  --bulma-dark-invert: hsl(221, 14%, 96%);
+  --bulma-dark-on-scheme-l: 21%;
+  --bulma-dark-on-scheme: hsla(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-on-scheme-l), 1);
+  --bulma-text: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-l), 1);
+  --bulma-text-base: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-l), 1);
+  --bulma-text-rgb: 64, 70, 84;
+  --bulma-text-h: 221deg;
+  --bulma-text-s: 14%;
+  --bulma-text-l: 29%;
+  --bulma-text-00-l: 0%;
+  --bulma-text-05-l: 4%;
+  --bulma-text-10-l: 9%;
+  --bulma-text-15-l: 14%;
+  --bulma-text-20-l: 19%;
+  --bulma-text-25-l: 24%;
+  --bulma-text-30-l: 29%;
+  --bulma-text-35-l: 34%;
+  --bulma-text-40-l: 39%;
+  --bulma-text-45-l: 44%;
+  --bulma-text-50-l: 49%;
+  --bulma-text-55-l: 54%;
+  --bulma-text-60-l: 59%;
+  --bulma-text-65-l: 64%;
+  --bulma-text-70-l: 69%;
+  --bulma-text-75-l: 74%;
+  --bulma-text-80-l: 79%;
+  --bulma-text-85-l: 84%;
+  --bulma-text-90-l: 89%;
+  --bulma-text-95-l: 94%;
+  --bulma-text-100-l: 99%;
+  --bulma-text-00: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-00-l), 1);
+  --bulma-text-00-invert-l: var(--bulma-text-60-l);
+  --bulma-text-00-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-00-invert-l), 1);
+  --bulma-text-05: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-05-l), 1);
+  --bulma-text-05-invert-l: var(--bulma-text-60-l);
+  --bulma-text-05-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-05-invert-l), 1);
+  --bulma-text-10: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-10-l), 1);
+  --bulma-text-10-invert-l: var(--bulma-text-70-l);
+  --bulma-text-10-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-10-invert-l), 1);
+  --bulma-text-15: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-15-l), 1);
+  --bulma-text-15-invert-l: var(--bulma-text-75-l);
+  --bulma-text-15-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-15-invert-l), 1);
+  --bulma-text-20: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-20-l), 1);
+  --bulma-text-20-invert-l: var(--bulma-text-85-l);
+  --bulma-text-20-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-20-invert-l), 1);
+  --bulma-text-25: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-25-l), 1);
+  --bulma-text-25-invert-l: var(--bulma-text-95-l);
+  --bulma-text-25-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-25-invert-l), 1);
+  --bulma-text-30: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-30-l), 1);
+  --bulma-text-30-invert-l: var(--bulma-text-100-l);
+  --bulma-text-30-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-30-invert-l), 1);
+  --bulma-text-35: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-35-l), 1);
+  --bulma-text-35-invert-l: var(--bulma-text-100-l);
+  --bulma-text-35-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-35-invert-l), 1);
+  --bulma-text-40: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-40-l), 1);
+  --bulma-text-40-invert-l: var(--bulma-text-100-l);
+  --bulma-text-40-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-40-invert-l), 1);
+  --bulma-text-45: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-45-l), 1);
+  --bulma-text-45-invert-l: var(--bulma-text-100-l);
+  --bulma-text-45-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-45-invert-l), 1);
+  --bulma-text-50: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-50-l), 1);
+  --bulma-text-50-invert-l: var(--bulma-text-100-l);
+  --bulma-text-50-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-50-invert-l), 1);
+  --bulma-text-55: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-55-l), 1);
+  --bulma-text-55-invert-l: var(--bulma-text-100-l);
+  --bulma-text-55-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-55-invert-l), 1);
+  --bulma-text-60: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-60-l), 1);
+  --bulma-text-60-invert-l: var(--bulma-text-05-l);
+  --bulma-text-60-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-60-invert-l), 1);
+  --bulma-text-65: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-65-l), 1);
+  --bulma-text-65-invert-l: var(--bulma-text-05-l);
+  --bulma-text-65-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-65-invert-l), 1);
+  --bulma-text-70: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-70-l), 1);
+  --bulma-text-70-invert-l: var(--bulma-text-10-l);
+  --bulma-text-70-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-70-invert-l), 1);
+  --bulma-text-75: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-75-l), 1);
+  --bulma-text-75-invert-l: var(--bulma-text-15-l);
+  --bulma-text-75-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-75-invert-l), 1);
+  --bulma-text-80: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-80-l), 1);
+  --bulma-text-80-invert-l: var(--bulma-text-15-l);
+  --bulma-text-80-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-80-invert-l), 1);
+  --bulma-text-85: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-85-l), 1);
+  --bulma-text-85-invert-l: var(--bulma-text-20-l);
+  --bulma-text-85-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-85-invert-l), 1);
+  --bulma-text-90: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-90-l), 1);
+  --bulma-text-90-invert-l: var(--bulma-text-20-l);
+  --bulma-text-90-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-90-invert-l), 1);
+  --bulma-text-95: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-95-l), 1);
+  --bulma-text-95-invert-l: var(--bulma-text-25-l);
+  --bulma-text-95-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-95-invert-l), 1);
+  --bulma-text-100: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-100-l), 1);
+  --bulma-text-100-invert-l: var(--bulma-text-25-l);
+  --bulma-text-100-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-100-invert-l), 1);
+  --bulma-text-invert-l: var(--bulma-text-100-l);
+  --bulma-text-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-invert-l), 1);
+  --bulma-text-light-l: var(--bulma-text-90-l);
+  --bulma-text-light: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-light-l), 1);
+  --bulma-text-light-invert-l: var(--bulma-text-20-l);
+  --bulma-text-light-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-light-invert-l), 1);
+  --bulma-text-dark-l: var(--bulma-text-10-l);
+  --bulma-text-dark: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-dark-l), 1);
+  --bulma-text-dark-invert-l: var(--bulma-text-70-l);
+  --bulma-text-dark-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-dark-invert-l), 1);
+  --bulma-text-soft: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-soft-l), 1);
+  --bulma-text-bold: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-bold-l), 1);
+  --bulma-text-soft-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-soft-invert-l), 1);
+  --bulma-text-bold-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-bold-invert-l), 1);
+  --bulma-text-on-scheme-l: 29%;
+  --bulma-text-on-scheme: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-on-scheme-l), 1);
+  --bulma-primary: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-l), 1);
+  --bulma-primary-base: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-l), 1);
+  --bulma-primary-rgb: 0, 209, 178;
+  --bulma-primary-h: 171deg;
+  --bulma-primary-s: 100%;
+  --bulma-primary-l: 41%;
+  --bulma-primary-00-l: 1%;
+  --bulma-primary-05-l: 6%;
+  --bulma-primary-10-l: 11%;
+  --bulma-primary-15-l: 16%;
+  --bulma-primary-20-l: 21%;
+  --bulma-primary-25-l: 26%;
+  --bulma-primary-30-l: 31%;
+  --bulma-primary-35-l: 36%;
+  --bulma-primary-40-l: 41%;
+  --bulma-primary-45-l: 46%;
+  --bulma-primary-50-l: 51%;
+  --bulma-primary-55-l: 56%;
+  --bulma-primary-60-l: 61%;
+  --bulma-primary-65-l: 66%;
+  --bulma-primary-70-l: 71%;
+  --bulma-primary-75-l: 76%;
+  --bulma-primary-80-l: 81%;
+  --bulma-primary-85-l: 86%;
+  --bulma-primary-90-l: 91%;
+  --bulma-primary-95-l: 96%;
+  --bulma-primary-100-l: 100%;
+  --bulma-primary-00: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-00-l), 1);
+  --bulma-primary-00-invert-l: var(--bulma-primary-30-l);
+  --bulma-primary-00-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-00-invert-l), 1);
+  --bulma-primary-05: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-05-l), 1);
+  --bulma-primary-05-invert-l: var(--bulma-primary-40-l);
+  --bulma-primary-05-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-05-invert-l), 1);
+  --bulma-primary-10: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-10-l), 1);
+  --bulma-primary-10-invert-l: var(--bulma-primary-50-l);
+  --bulma-primary-10-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-10-invert-l), 1);
+  --bulma-primary-15: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-15-l), 1);
+  --bulma-primary-15-invert-l: var(--bulma-primary-100-l);
+  --bulma-primary-15-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-15-invert-l), 1);
+  --bulma-primary-20: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-20-l), 1);
+  --bulma-primary-20-invert-l: var(--bulma-primary-100-l);
+  --bulma-primary-20-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-20-invert-l), 1);
+  --bulma-primary-25: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-25-l), 1);
+  --bulma-primary-25-invert-l: var(--bulma-primary-100-l);
+  --bulma-primary-25-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-25-invert-l), 1);
+  --bulma-primary-30: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-30-l), 1);
+  --bulma-primary-30-invert-l: var(--bulma-primary-00-l);
+  --bulma-primary-30-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-30-invert-l), 1);
+  --bulma-primary-35: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-35-l), 1);
+  --bulma-primary-35-invert-l: var(--bulma-primary-00-l);
+  --bulma-primary-35-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-35-invert-l), 1);
+  --bulma-primary-40: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-40-l), 1);
+  --bulma-primary-40-invert-l: var(--bulma-primary-05-l);
+  --bulma-primary-40-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-40-invert-l), 1);
+  --bulma-primary-45: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-45-l), 1);
+  --bulma-primary-45-invert-l: var(--bulma-primary-05-l);
+  --bulma-primary-45-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-45-invert-l), 1);
+  --bulma-primary-50: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-50-l), 1);
+  --bulma-primary-50-invert-l: var(--bulma-primary-10-l);
+  --bulma-primary-50-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-50-invert-l), 1);
+  --bulma-primary-55: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-55-l), 1);
+  --bulma-primary-55-invert-l: var(--bulma-primary-10-l);
+  --bulma-primary-55-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-55-invert-l), 1);
+  --bulma-primary-60: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-60-l), 1);
+  --bulma-primary-60-invert-l: var(--bulma-primary-10-l);
+  --bulma-primary-60-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-60-invert-l), 1);
+  --bulma-primary-65: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-65-l), 1);
+  --bulma-primary-65-invert-l: var(--bulma-primary-10-l);
+  --bulma-primary-65-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-65-invert-l), 1);
+  --bulma-primary-70: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-70-l), 1);
+  --bulma-primary-70-invert-l: var(--bulma-primary-10-l);
+  --bulma-primary-70-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-70-invert-l), 1);
+  --bulma-primary-75: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-75-l), 1);
+  --bulma-primary-75-invert-l: var(--bulma-primary-10-l);
+  --bulma-primary-75-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-75-invert-l), 1);
+  --bulma-primary-80: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-80-l), 1);
+  --bulma-primary-80-invert-l: var(--bulma-primary-10-l);
+  --bulma-primary-80-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-80-invert-l), 1);
+  --bulma-primary-85: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-85-l), 1);
+  --bulma-primary-85-invert-l: var(--bulma-primary-10-l);
+  --bulma-primary-85-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-85-invert-l), 1);
+  --bulma-primary-90: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-90-l), 1);
+  --bulma-primary-90-invert-l: var(--bulma-primary-10-l);
+  --bulma-primary-90-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-90-invert-l), 1);
+  --bulma-primary-95: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-95-l), 1);
+  --bulma-primary-95-invert-l: var(--bulma-primary-10-l);
+  --bulma-primary-95-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-95-invert-l), 1);
+  --bulma-primary-100: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-100-l), 1);
+  --bulma-primary-100-invert-l: var(--bulma-primary-15-l);
+  --bulma-primary-100-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-100-invert-l), 1);
+  --bulma-primary-invert-l: var(--bulma-primary-05-l);
+  --bulma-primary-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-invert-l), 1);
+  --bulma-primary-light-l: var(--bulma-primary-90-l);
+  --bulma-primary-light: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-light-l), 1);
+  --bulma-primary-light-invert-l: var(--bulma-primary-10-l);
+  --bulma-primary-light-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-light-invert-l), 1);
+  --bulma-primary-dark-l: var(--bulma-primary-10-l);
+  --bulma-primary-dark: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-dark-l), 1);
+  --bulma-primary-dark-invert-l: var(--bulma-primary-50-l);
+  --bulma-primary-dark-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-dark-invert-l), 1);
+  --bulma-primary-soft: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-soft-l), 1);
+  --bulma-primary-bold: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-bold-l), 1);
+  --bulma-primary-soft-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-soft-invert-l), 1);
+  --bulma-primary-bold-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-bold-invert-l), 1);
+  --bulma-primary-on-scheme-l: 21%;
+  --bulma-primary-on-scheme: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-on-scheme-l), 1);
+  --bulma-link: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-l), 1);
+  --bulma-link-base: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-l), 1);
+  --bulma-link-rgb: 66, 88, 255;
+  --bulma-link-h: 233deg;
+  --bulma-link-s: 100%;
+  --bulma-link-l: 63%;
+  --bulma-link-00-l: 0%;
+  --bulma-link-05-l: 3%;
+  --bulma-link-10-l: 8%;
+  --bulma-link-15-l: 13%;
+  --bulma-link-20-l: 18%;
+  --bulma-link-25-l: 23%;
+  --bulma-link-30-l: 28%;
+  --bulma-link-35-l: 33%;
+  --bulma-link-40-l: 38%;
+  --bulma-link-45-l: 43%;
+  --bulma-link-50-l: 48%;
+  --bulma-link-55-l: 53%;
+  --bulma-link-60-l: 58%;
+  --bulma-link-65-l: 63%;
+  --bulma-link-70-l: 68%;
+  --bulma-link-75-l: 73%;
+  --bulma-link-80-l: 78%;
+  --bulma-link-85-l: 83%;
+  --bulma-link-90-l: 88%;
+  --bulma-link-95-l: 93%;
+  --bulma-link-100-l: 98%;
+  --bulma-link-00: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-00-l), 1);
+  --bulma-link-00-invert-l: var(--bulma-link-75-l);
+  --bulma-link-00-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-00-invert-l), 1);
+  --bulma-link-05: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-05-l), 1);
+  --bulma-link-05-invert-l: var(--bulma-link-75-l);
+  --bulma-link-05-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-05-invert-l), 1);
+  --bulma-link-10: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-10-l), 1);
+  --bulma-link-10-invert-l: var(--bulma-link-75-l);
+  --bulma-link-10-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-10-invert-l), 1);
+  --bulma-link-15: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-15-l), 1);
+  --bulma-link-15-invert-l: var(--bulma-link-80-l);
+  --bulma-link-15-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-15-invert-l), 1);
+  --bulma-link-20: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-20-l), 1);
+  --bulma-link-20-invert-l: var(--bulma-link-80-l);
+  --bulma-link-20-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-20-invert-l), 1);
+  --bulma-link-25: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-25-l), 1);
+  --bulma-link-25-invert-l: var(--bulma-link-85-l);
+  --bulma-link-25-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-25-invert-l), 1);
+  --bulma-link-30: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-30-l), 1);
+  --bulma-link-30-invert-l: var(--bulma-link-90-l);
+  --bulma-link-30-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-30-invert-l), 1);
+  --bulma-link-35: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-35-l), 1);
+  --bulma-link-35-invert-l: var(--bulma-link-90-l);
+  --bulma-link-35-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-35-invert-l), 1);
+  --bulma-link-40: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-40-l), 1);
+  --bulma-link-40-invert-l: var(--bulma-link-95-l);
+  --bulma-link-40-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-40-invert-l), 1);
+  --bulma-link-45: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-45-l), 1);
+  --bulma-link-45-invert-l: var(--bulma-link-100-l);
+  --bulma-link-45-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-45-invert-l), 1);
+  --bulma-link-50: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-50-l), 1);
+  --bulma-link-50-invert-l: var(--bulma-link-100-l);
+  --bulma-link-50-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-50-invert-l), 1);
+  --bulma-link-55: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-55-l), 1);
+  --bulma-link-55-invert-l: var(--bulma-link-100-l);
+  --bulma-link-55-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-55-invert-l), 1);
+  --bulma-link-60: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-60-l), 1);
+  --bulma-link-60-invert-l: var(--bulma-link-100-l);
+  --bulma-link-60-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-60-invert-l), 1);
+  --bulma-link-65: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-65-l), 1);
+  --bulma-link-65-invert-l: var(--bulma-link-100-l);
+  --bulma-link-65-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-65-invert-l), 1);
+  --bulma-link-70: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-70-l), 1);
+  --bulma-link-70-invert-l: var(--bulma-link-100-l);
+  --bulma-link-70-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-70-invert-l), 1);
+  --bulma-link-75: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-75-l), 1);
+  --bulma-link-75-invert-l: var(--bulma-link-10-l);
+  --bulma-link-75-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-75-invert-l), 1);
+  --bulma-link-80: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-80-l), 1);
+  --bulma-link-80-invert-l: var(--bulma-link-20-l);
+  --bulma-link-80-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-80-invert-l), 1);
+  --bulma-link-85: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-85-l), 1);
+  --bulma-link-85-invert-l: var(--bulma-link-25-l);
+  --bulma-link-85-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-85-invert-l), 1);
+  --bulma-link-90: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-90-l), 1);
+  --bulma-link-90-invert-l: var(--bulma-link-35-l);
+  --bulma-link-90-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-90-invert-l), 1);
+  --bulma-link-95: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-95-l), 1);
+  --bulma-link-95-invert-l: var(--bulma-link-40-l);
+  --bulma-link-95-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-95-invert-l), 1);
+  --bulma-link-100: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-100-l), 1);
+  --bulma-link-100-invert-l: var(--bulma-link-50-l);
+  --bulma-link-100-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-100-invert-l), 1);
+  --bulma-link-invert-l: var(--bulma-link-100-l);
+  --bulma-link-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-invert-l), 1);
+  --bulma-link-light-l: var(--bulma-link-90-l);
+  --bulma-link-light: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-light-l), 1);
+  --bulma-link-light-invert-l: var(--bulma-link-35-l);
+  --bulma-link-light-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-light-invert-l), 1);
+  --bulma-link-dark-l: var(--bulma-link-10-l);
+  --bulma-link-dark: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-dark-l), 1);
+  --bulma-link-dark-invert-l: var(--bulma-link-75-l);
+  --bulma-link-dark-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-dark-invert-l), 1);
+  --bulma-link-soft: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-soft-l), 1);
+  --bulma-link-bold: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-bold-l), 1);
+  --bulma-link-soft-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-soft-invert-l), 1);
+  --bulma-link-bold-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-bold-invert-l), 1);
+  --bulma-link-on-scheme-l: 58%;
+  --bulma-link-on-scheme: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-on-scheme-l), 1);
+  --bulma-info: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-l), 1);
+  --bulma-info-base: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-l), 1);
+  --bulma-info-rgb: 102, 209, 255;
+  --bulma-info-h: 198deg;
+  --bulma-info-s: 100%;
+  --bulma-info-l: 70%;
+  --bulma-info-00-l: 0%;
+  --bulma-info-05-l: 5%;
+  --bulma-info-10-l: 10%;
+  --bulma-info-15-l: 15%;
+  --bulma-info-20-l: 20%;
+  --bulma-info-25-l: 25%;
+  --bulma-info-30-l: 30%;
+  --bulma-info-35-l: 35%;
+  --bulma-info-40-l: 40%;
+  --bulma-info-45-l: 45%;
+  --bulma-info-50-l: 50%;
+  --bulma-info-55-l: 55%;
+  --bulma-info-60-l: 60%;
+  --bulma-info-65-l: 65%;
+  --bulma-info-70-l: 70%;
+  --bulma-info-75-l: 75%;
+  --bulma-info-80-l: 80%;
+  --bulma-info-85-l: 85%;
+  --bulma-info-90-l: 90%;
+  --bulma-info-95-l: 95%;
+  --bulma-info-100-l: 100%;
+  --bulma-info-00: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-00-l), 1);
+  --bulma-info-00-invert-l: var(--bulma-info-45-l);
+  --bulma-info-00-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-00-invert-l), 1);
+  --bulma-info-05: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-05-l), 1);
+  --bulma-info-05-invert-l: var(--bulma-info-50-l);
+  --bulma-info-05-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-05-invert-l), 1);
+  --bulma-info-10: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-10-l), 1);
+  --bulma-info-10-invert-l: var(--bulma-info-60-l);
+  --bulma-info-10-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-10-invert-l), 1);
+  --bulma-info-15: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-15-l), 1);
+  --bulma-info-15-invert-l: var(--bulma-info-80-l);
+  --bulma-info-15-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-15-invert-l), 1);
+  --bulma-info-20: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-20-l), 1);
+  --bulma-info-20-invert-l: var(--bulma-info-95-l);
+  --bulma-info-20-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-20-invert-l), 1);
+  --bulma-info-25: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-25-l), 1);
+  --bulma-info-25-invert-l: var(--bulma-info-100-l);
+  --bulma-info-25-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-25-invert-l), 1);
+  --bulma-info-30: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-30-l), 1);
+  --bulma-info-30-invert-l: var(--bulma-info-100-l);
+  --bulma-info-30-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-30-invert-l), 1);
+  --bulma-info-35: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-35-l), 1);
+  --bulma-info-35-invert-l: var(--bulma-info-100-l);
+  --bulma-info-35-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-35-invert-l), 1);
+  --bulma-info-40: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-40-l), 1);
+  --bulma-info-40-invert-l: var(--bulma-info-100-l);
+  --bulma-info-40-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-40-invert-l), 1);
+  --bulma-info-45: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-45-l), 1);
+  --bulma-info-45-invert-l: var(--bulma-info-00-l);
+  --bulma-info-45-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-45-invert-l), 1);
+  --bulma-info-50: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-50-l), 1);
+  --bulma-info-50-invert-l: var(--bulma-info-05-l);
+  --bulma-info-50-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-50-invert-l), 1);
+  --bulma-info-55: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-55-l), 1);
+  --bulma-info-55-invert-l: var(--bulma-info-05-l);
+  --bulma-info-55-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-55-invert-l), 1);
+  --bulma-info-60: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-60-l), 1);
+  --bulma-info-60-invert-l: var(--bulma-info-10-l);
+  --bulma-info-60-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-60-invert-l), 1);
+  --bulma-info-65: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-65-l), 1);
+  --bulma-info-65-invert-l: var(--bulma-info-10-l);
+  --bulma-info-65-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-65-invert-l), 1);
+  --bulma-info-70: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-70-l), 1);
+  --bulma-info-70-invert-l: var(--bulma-info-10-l);
+  --bulma-info-70-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-70-invert-l), 1);
+  --bulma-info-75: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-75-l), 1);
+  --bulma-info-75-invert-l: var(--bulma-info-10-l);
+  --bulma-info-75-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-75-invert-l), 1);
+  --bulma-info-80: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-80-l), 1);
+  --bulma-info-80-invert-l: var(--bulma-info-15-l);
+  --bulma-info-80-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-80-invert-l), 1);
+  --bulma-info-85: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-85-l), 1);
+  --bulma-info-85-invert-l: var(--bulma-info-15-l);
+  --bulma-info-85-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-85-invert-l), 1);
+  --bulma-info-90: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-90-l), 1);
+  --bulma-info-90-invert-l: var(--bulma-info-15-l);
+  --bulma-info-90-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-90-invert-l), 1);
+  --bulma-info-95: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-95-l), 1);
+  --bulma-info-95-invert-l: var(--bulma-info-20-l);
+  --bulma-info-95-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-95-invert-l), 1);
+  --bulma-info-100: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-100-l), 1);
+  --bulma-info-100-invert-l: var(--bulma-info-20-l);
+  --bulma-info-100-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-100-invert-l), 1);
+  --bulma-info-invert-l: var(--bulma-info-10-l);
+  --bulma-info-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-invert-l), 1);
+  --bulma-info-light-l: var(--bulma-info-90-l);
+  --bulma-info-light: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-light-l), 1);
+  --bulma-info-light-invert-l: var(--bulma-info-15-l);
+  --bulma-info-light-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-light-invert-l), 1);
+  --bulma-info-dark-l: var(--bulma-info-10-l);
+  --bulma-info-dark: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-dark-l), 1);
+  --bulma-info-dark-invert-l: var(--bulma-info-60-l);
+  --bulma-info-dark-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-dark-invert-l), 1);
+  --bulma-info-soft: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-soft-l), 1);
+  --bulma-info-bold: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-bold-l), 1);
+  --bulma-info-soft-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-soft-invert-l), 1);
+  --bulma-info-bold-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-bold-invert-l), 1);
+  --bulma-info-on-scheme-l: 25%;
+  --bulma-info-on-scheme: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-on-scheme-l), 1);
+  --bulma-success: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-l), 1);
+  --bulma-success-base: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-l), 1);
+  --bulma-success-rgb: 72, 199, 142;
+  --bulma-success-h: 153deg;
+  --bulma-success-s: 53%;
+  --bulma-success-l: 53%;
+  --bulma-success-00-l: 0%;
+  --bulma-success-05-l: 3%;
+  --bulma-success-10-l: 8%;
+  --bulma-success-15-l: 13%;
+  --bulma-success-20-l: 18%;
+  --bulma-success-25-l: 23%;
+  --bulma-success-30-l: 28%;
+  --bulma-success-35-l: 33%;
+  --bulma-success-40-l: 38%;
+  --bulma-success-45-l: 43%;
+  --bulma-success-50-l: 48%;
+  --bulma-success-55-l: 53%;
+  --bulma-success-60-l: 58%;
+  --bulma-success-65-l: 63%;
+  --bulma-success-70-l: 68%;
+  --bulma-success-75-l: 73%;
+  --bulma-success-80-l: 78%;
+  --bulma-success-85-l: 83%;
+  --bulma-success-90-l: 88%;
+  --bulma-success-95-l: 93%;
+  --bulma-success-100-l: 98%;
+  --bulma-success-00: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-00-l), 1);
+  --bulma-success-00-invert-l: var(--bulma-success-45-l);
+  --bulma-success-00-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-00-invert-l), 1);
+  --bulma-success-05: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-05-l), 1);
+  --bulma-success-05-invert-l: var(--bulma-success-45-l);
+  --bulma-success-05-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-05-invert-l), 1);
+  --bulma-success-10: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-10-l), 1);
+  --bulma-success-10-invert-l: var(--bulma-success-55-l);
+  --bulma-success-10-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-10-invert-l), 1);
+  --bulma-success-15: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-15-l), 1);
+  --bulma-success-15-invert-l: var(--bulma-success-75-l);
+  --bulma-success-15-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-15-invert-l), 1);
+  --bulma-success-20: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-20-l), 1);
+  --bulma-success-20-invert-l: var(--bulma-success-90-l);
+  --bulma-success-20-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-20-invert-l), 1);
+  --bulma-success-25: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-25-l), 1);
+  --bulma-success-25-invert-l: var(--bulma-success-100-l);
+  --bulma-success-25-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-25-invert-l), 1);
+  --bulma-success-30: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-30-l), 1);
+  --bulma-success-30-invert-l: var(--bulma-success-100-l);
+  --bulma-success-30-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-30-invert-l), 1);
+  --bulma-success-35: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-35-l), 1);
+  --bulma-success-35-invert-l: var(--bulma-success-100-l);
+  --bulma-success-35-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-35-invert-l), 1);
+  --bulma-success-40: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-40-l), 1);
+  --bulma-success-40-invert-l: var(--bulma-success-100-l);
+  --bulma-success-40-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-40-invert-l), 1);
+  --bulma-success-45: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-45-l), 1);
+  --bulma-success-45-invert-l: var(--bulma-success-05-l);
+  --bulma-success-45-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-45-invert-l), 1);
+  --bulma-success-50: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-50-l), 1);
+  --bulma-success-50-invert-l: var(--bulma-success-05-l);
+  --bulma-success-50-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-50-invert-l), 1);
+  --bulma-success-55: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-55-l), 1);
+  --bulma-success-55-invert-l: var(--bulma-success-10-l);
+  --bulma-success-55-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-55-invert-l), 1);
+  --bulma-success-60: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-60-l), 1);
+  --bulma-success-60-invert-l: var(--bulma-success-10-l);
+  --bulma-success-60-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-60-invert-l), 1);
+  --bulma-success-65: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-65-l), 1);
+  --bulma-success-65-invert-l: var(--bulma-success-10-l);
+  --bulma-success-65-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-65-invert-l), 1);
+  --bulma-success-70: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-70-l), 1);
+  --bulma-success-70-invert-l: var(--bulma-success-10-l);
+  --bulma-success-70-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-70-invert-l), 1);
+  --bulma-success-75: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-75-l), 1);
+  --bulma-success-75-invert-l: var(--bulma-success-15-l);
+  --bulma-success-75-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-75-invert-l), 1);
+  --bulma-success-80: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-80-l), 1);
+  --bulma-success-80-invert-l: var(--bulma-success-15-l);
+  --bulma-success-80-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-80-invert-l), 1);
+  --bulma-success-85: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-85-l), 1);
+  --bulma-success-85-invert-l: var(--bulma-success-15-l);
+  --bulma-success-85-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-85-invert-l), 1);
+  --bulma-success-90: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-90-l), 1);
+  --bulma-success-90-invert-l: var(--bulma-success-20-l);
+  --bulma-success-90-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-90-invert-l), 1);
+  --bulma-success-95: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-95-l), 1);
+  --bulma-success-95-invert-l: var(--bulma-success-20-l);
+  --bulma-success-95-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-95-invert-l), 1);
+  --bulma-success-100: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-100-l), 1);
+  --bulma-success-100-invert-l: var(--bulma-success-20-l);
+  --bulma-success-100-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-100-invert-l), 1);
+  --bulma-success-invert-l: var(--bulma-success-10-l);
+  --bulma-success-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-invert-l), 1);
+  --bulma-success-light-l: var(--bulma-success-90-l);
+  --bulma-success-light: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-light-l), 1);
+  --bulma-success-light-invert-l: var(--bulma-success-20-l);
+  --bulma-success-light-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-light-invert-l), 1);
+  --bulma-success-dark-l: var(--bulma-success-10-l);
+  --bulma-success-dark: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-dark-l), 1);
+  --bulma-success-dark-invert-l: var(--bulma-success-55-l);
+  --bulma-success-dark-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-dark-invert-l), 1);
+  --bulma-success-soft: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-soft-l), 1);
+  --bulma-success-bold: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-bold-l), 1);
+  --bulma-success-soft-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-soft-invert-l), 1);
+  --bulma-success-bold-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-bold-invert-l), 1);
+  --bulma-success-on-scheme-l: 23%;
+  --bulma-success-on-scheme: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-on-scheme-l), 1);
+  --bulma-warning: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-l), 1);
+  --bulma-warning-base: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-l), 1);
+  --bulma-warning-rgb: 255, 183, 15;
+  --bulma-warning-h: 42deg;
+  --bulma-warning-s: 100%;
+  --bulma-warning-l: 53%;
+  --bulma-warning-00-l: 0%;
+  --bulma-warning-05-l: 3%;
+  --bulma-warning-10-l: 8%;
+  --bulma-warning-15-l: 13%;
+  --bulma-warning-20-l: 18%;
+  --bulma-warning-25-l: 23%;
+  --bulma-warning-30-l: 28%;
+  --bulma-warning-35-l: 33%;
+  --bulma-warning-40-l: 38%;
+  --bulma-warning-45-l: 43%;
+  --bulma-warning-50-l: 48%;
+  --bulma-warning-55-l: 53%;
+  --bulma-warning-60-l: 58%;
+  --bulma-warning-65-l: 63%;
+  --bulma-warning-70-l: 68%;
+  --bulma-warning-75-l: 73%;
+  --bulma-warning-80-l: 78%;
+  --bulma-warning-85-l: 83%;
+  --bulma-warning-90-l: 88%;
+  --bulma-warning-95-l: 93%;
+  --bulma-warning-100-l: 98%;
+  --bulma-warning-00: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-00-l), 1);
+  --bulma-warning-00-invert-l: var(--bulma-warning-40-l);
+  --bulma-warning-00-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-00-invert-l), 1);
+  --bulma-warning-05: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-05-l), 1);
+  --bulma-warning-05-invert-l: var(--bulma-warning-45-l);
+  --bulma-warning-05-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-05-invert-l), 1);
+  --bulma-warning-10: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-10-l), 1);
+  --bulma-warning-10-invert-l: var(--bulma-warning-50-l);
+  --bulma-warning-10-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-10-invert-l), 1);
+  --bulma-warning-15: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-15-l), 1);
+  --bulma-warning-15-invert-l: var(--bulma-warning-70-l);
+  --bulma-warning-15-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-15-invert-l), 1);
+  --bulma-warning-20: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-20-l), 1);
+  --bulma-warning-20-invert-l: var(--bulma-warning-100-l);
+  --bulma-warning-20-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-20-invert-l), 1);
+  --bulma-warning-25: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-25-l), 1);
+  --bulma-warning-25-invert-l: var(--bulma-warning-100-l);
+  --bulma-warning-25-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-25-invert-l), 1);
+  --bulma-warning-30: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-30-l), 1);
+  --bulma-warning-30-invert-l: var(--bulma-warning-100-l);
+  --bulma-warning-30-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-30-invert-l), 1);
+  --bulma-warning-35: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-35-l), 1);
+  --bulma-warning-35-invert-l: var(--bulma-warning-100-l);
+  --bulma-warning-35-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-35-invert-l), 1);
+  --bulma-warning-40: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-40-l), 1);
+  --bulma-warning-40-invert-l: var(--bulma-warning-00-l);
+  --bulma-warning-40-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-40-invert-l), 1);
+  --bulma-warning-45: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-45-l), 1);
+  --bulma-warning-45-invert-l: var(--bulma-warning-05-l);
+  --bulma-warning-45-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-45-invert-l), 1);
+  --bulma-warning-50: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-50-l), 1);
+  --bulma-warning-50-invert-l: var(--bulma-warning-10-l);
+  --bulma-warning-50-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-50-invert-l), 1);
+  --bulma-warning-55: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-55-l), 1);
+  --bulma-warning-55-invert-l: var(--bulma-warning-10-l);
+  --bulma-warning-55-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-55-invert-l), 1);
+  --bulma-warning-60: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-60-l), 1);
+  --bulma-warning-60-invert-l: var(--bulma-warning-10-l);
+  --bulma-warning-60-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-60-invert-l), 1);
+  --bulma-warning-65: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-65-l), 1);
+  --bulma-warning-65-invert-l: var(--bulma-warning-10-l);
+  --bulma-warning-65-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-65-invert-l), 1);
+  --bulma-warning-70: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-70-l), 1);
+  --bulma-warning-70-invert-l: var(--bulma-warning-15-l);
+  --bulma-warning-70-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-70-invert-l), 1);
+  --bulma-warning-75: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-75-l), 1);
+  --bulma-warning-75-invert-l: var(--bulma-warning-15-l);
+  --bulma-warning-75-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-75-invert-l), 1);
+  --bulma-warning-80: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-80-l), 1);
+  --bulma-warning-80-invert-l: var(--bulma-warning-15-l);
+  --bulma-warning-80-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-80-invert-l), 1);
+  --bulma-warning-85: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-85-l), 1);
+  --bulma-warning-85-invert-l: var(--bulma-warning-15-l);
+  --bulma-warning-85-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-85-invert-l), 1);
+  --bulma-warning-90: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-90-l), 1);
+  --bulma-warning-90-invert-l: var(--bulma-warning-15-l);
+  --bulma-warning-90-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-90-invert-l), 1);
+  --bulma-warning-95: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-95-l), 1);
+  --bulma-warning-95-invert-l: var(--bulma-warning-15-l);
+  --bulma-warning-95-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-95-invert-l), 1);
+  --bulma-warning-100: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-100-l), 1);
+  --bulma-warning-100-invert-l: var(--bulma-warning-20-l);
+  --bulma-warning-100-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-100-invert-l), 1);
+  --bulma-warning-invert-l: var(--bulma-warning-10-l);
+  --bulma-warning-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-invert-l), 1);
+  --bulma-warning-light-l: var(--bulma-warning-90-l);
+  --bulma-warning-light: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-light-l), 1);
+  --bulma-warning-light-invert-l: var(--bulma-warning-15-l);
+  --bulma-warning-light-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-light-invert-l), 1);
+  --bulma-warning-dark-l: var(--bulma-warning-10-l);
+  --bulma-warning-dark: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-dark-l), 1);
+  --bulma-warning-dark-invert-l: var(--bulma-warning-50-l);
+  --bulma-warning-dark-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-dark-invert-l), 1);
+  --bulma-warning-soft: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-soft-l), 1);
+  --bulma-warning-bold: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-bold-l), 1);
+  --bulma-warning-soft-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-soft-invert-l), 1);
+  --bulma-warning-bold-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-bold-invert-l), 1);
+  --bulma-warning-on-scheme-l: 23%;
+  --bulma-warning-on-scheme: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-on-scheme-l), 1);
+  --bulma-danger: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-l), 1);
+  --bulma-danger-base: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-l), 1);
+  --bulma-danger-rgb: 255, 102, 133;
+  --bulma-danger-h: 348deg;
+  --bulma-danger-s: 100%;
+  --bulma-danger-l: 70%;
+  --bulma-danger-00-l: 0%;
+  --bulma-danger-05-l: 5%;
+  --bulma-danger-10-l: 10%;
+  --bulma-danger-15-l: 15%;
+  --bulma-danger-20-l: 20%;
+  --bulma-danger-25-l: 25%;
+  --bulma-danger-30-l: 30%;
+  --bulma-danger-35-l: 35%;
+  --bulma-danger-40-l: 40%;
+  --bulma-danger-45-l: 45%;
+  --bulma-danger-50-l: 50%;
+  --bulma-danger-55-l: 55%;
+  --bulma-danger-60-l: 60%;
+  --bulma-danger-65-l: 65%;
+  --bulma-danger-70-l: 70%;
+  --bulma-danger-75-l: 75%;
+  --bulma-danger-80-l: 80%;
+  --bulma-danger-85-l: 85%;
+  --bulma-danger-90-l: 90%;
+  --bulma-danger-95-l: 95%;
+  --bulma-danger-100-l: 100%;
+  --bulma-danger-00: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-00-l), 1);
+  --bulma-danger-00-invert-l: var(--bulma-danger-65-l);
+  --bulma-danger-00-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-00-invert-l), 1);
+  --bulma-danger-05: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-05-l), 1);
+  --bulma-danger-05-invert-l: var(--bulma-danger-70-l);
+  --bulma-danger-05-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-05-invert-l), 1);
+  --bulma-danger-10: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-10-l), 1);
+  --bulma-danger-10-invert-l: var(--bulma-danger-75-l);
+  --bulma-danger-10-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-10-invert-l), 1);
+  --bulma-danger-15: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-15-l), 1);
+  --bulma-danger-15-invert-l: var(--bulma-danger-80-l);
+  --bulma-danger-15-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-15-invert-l), 1);
+  --bulma-danger-20: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-20-l), 1);
+  --bulma-danger-20-invert-l: var(--bulma-danger-85-l);
+  --bulma-danger-20-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-20-invert-l), 1);
+  --bulma-danger-25: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-25-l), 1);
+  --bulma-danger-25-invert-l: var(--bulma-danger-90-l);
+  --bulma-danger-25-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-25-invert-l), 1);
+  --bulma-danger-30: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-30-l), 1);
+  --bulma-danger-30-invert-l: var(--bulma-danger-100-l);
+  --bulma-danger-30-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-30-invert-l), 1);
+  --bulma-danger-35: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-35-l), 1);
+  --bulma-danger-35-invert-l: var(--bulma-danger-100-l);
+  --bulma-danger-35-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-35-invert-l), 1);
+  --bulma-danger-40: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-40-l), 1);
+  --bulma-danger-40-invert-l: var(--bulma-danger-100-l);
+  --bulma-danger-40-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-40-invert-l), 1);
+  --bulma-danger-45: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-45-l), 1);
+  --bulma-danger-45-invert-l: var(--bulma-danger-100-l);
+  --bulma-danger-45-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-45-invert-l), 1);
+  --bulma-danger-50: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-50-l), 1);
+  --bulma-danger-50-invert-l: var(--bulma-danger-100-l);
+  --bulma-danger-50-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-50-invert-l), 1);
+  --bulma-danger-55: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-55-l), 1);
+  --bulma-danger-55-invert-l: var(--bulma-danger-100-l);
+  --bulma-danger-55-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-55-invert-l), 1);
+  --bulma-danger-60: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-60-l), 1);
+  --bulma-danger-60-invert-l: var(--bulma-danger-100-l);
+  --bulma-danger-60-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-60-invert-l), 1);
+  --bulma-danger-65: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-65-l), 1);
+  --bulma-danger-65-invert-l: var(--bulma-danger-00-l);
+  --bulma-danger-65-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-65-invert-l), 1);
+  --bulma-danger-70: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-70-l), 1);
+  --bulma-danger-70-invert-l: var(--bulma-danger-05-l);
+  --bulma-danger-70-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-70-invert-l), 1);
+  --bulma-danger-75: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-75-l), 1);
+  --bulma-danger-75-invert-l: var(--bulma-danger-10-l);
+  --bulma-danger-75-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-75-invert-l), 1);
+  --bulma-danger-80: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-80-l), 1);
+  --bulma-danger-80-invert-l: var(--bulma-danger-15-l);
+  --bulma-danger-80-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-80-invert-l), 1);
+  --bulma-danger-85: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-85-l), 1);
+  --bulma-danger-85-invert-l: var(--bulma-danger-20-l);
+  --bulma-danger-85-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-85-invert-l), 1);
+  --bulma-danger-90: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-90-l), 1);
+  --bulma-danger-90-invert-l: var(--bulma-danger-25-l);
+  --bulma-danger-90-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-90-invert-l), 1);
+  --bulma-danger-95: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-95-l), 1);
+  --bulma-danger-95-invert-l: var(--bulma-danger-25-l);
+  --bulma-danger-95-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-95-invert-l), 1);
+  --bulma-danger-100: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-100-l), 1);
+  --bulma-danger-100-invert-l: var(--bulma-danger-30-l);
+  --bulma-danger-100-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-100-invert-l), 1);
+  --bulma-danger-invert-l: var(--bulma-danger-05-l);
+  --bulma-danger-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-invert-l), 1);
+  --bulma-danger-light-l: var(--bulma-danger-90-l);
+  --bulma-danger-light: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-light-l), 1);
+  --bulma-danger-light-invert-l: var(--bulma-danger-25-l);
+  --bulma-danger-light-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-light-invert-l), 1);
+  --bulma-danger-dark-l: var(--bulma-danger-10-l);
+  --bulma-danger-dark: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-dark-l), 1);
+  --bulma-danger-dark-invert-l: var(--bulma-danger-75-l);
+  --bulma-danger-dark-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-dark-invert-l), 1);
+  --bulma-danger-soft: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-soft-l), 1);
+  --bulma-danger-bold: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-bold-l), 1);
+  --bulma-danger-soft-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-soft-invert-l), 1);
+  --bulma-danger-bold-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-bold-invert-l), 1);
+  --bulma-danger-on-scheme-l: 40%;
+  --bulma-danger-on-scheme: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-on-scheme-l), 1);
+  --bulma-black-bis: hsl(221, 14%, 9%);
+  --bulma-black-ter: hsl(221, 14%, 14%);
+  --bulma-grey-darker: hsl(221, 14%, 21%);
+  --bulma-grey-dark: hsl(221, 14%, 29%);
+  --bulma-grey: hsl(221, 14%, 48%);
+  --bulma-grey-light: hsl(221, 14%, 71%);
+  --bulma-grey-lighter: hsl(221, 14%, 86%);
+  --bulma-white-ter: hsl(221, 14%, 96%);
+  --bulma-white-bis: hsl(221, 14%, 98%);
+  --bulma-shadow-h: 221deg;
+  --bulma-shadow-s: 14%;
+  --bulma-shadow-l: 4%;
+  --bulma-size-1: 3rem;
+  --bulma-size-2: 2.5rem;
+  --bulma-size-3: 2rem;
+  --bulma-size-4: 1.5rem;
+  --bulma-size-5: 1.25rem;
+  --bulma-size-6: 1rem;
+  --bulma-size-7: 0.75rem;
+  --bulma-scheme-main: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-scheme-main-l));
+  --bulma-scheme-main-bis: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-scheme-main-bis-l));
+  --bulma-scheme-main-ter: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-scheme-main-ter-l));
+  --bulma-background: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-background-l));
+  --bulma-background-hover: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), calc(var(--bulma-background-l) + var(--bulma-hover-background-l-delta)));
+  --bulma-background-active: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), calc(var(--bulma-background-l) + var(--bulma-active-background-l-delta)));
+  --bulma-border-weak: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-border-weak-l));
+  --bulma-border: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-border-l));
+  --bulma-border-hover: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), calc(var(--bulma-border-l) + var(--bulma-hover-border-l-delta)));
+  --bulma-border-active: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), calc(var(--bulma-border-l) + var(--bulma-active-border-l-delta)));
+  --bulma-text-weak: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-weak-l));
+  --bulma-text: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-l));
+  --bulma-text-strong: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-strong-l));
+  --bulma-scheme-invert-ter: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-scheme-invert-ter-l));
+  --bulma-scheme-invert-bis: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-scheme-invert-bis-l));
+  --bulma-scheme-invert: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-scheme-invert-l));
+  --bulma-link: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-l));
+  --bulma-link-text: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-on-scheme-l));
+  --bulma-link-text-hover: hsl(var(--bulma-link-h), var(--bulma-link-s), calc(var(--bulma-link-on-scheme-l) + var(--bulma-hover-color-l-delta)));
+  --bulma-link-text-active: hsl(var(--bulma-link-h), var(--bulma-link-s), calc(var(--bulma-link-on-scheme-l) + var(--bulma-active-color-l-delta)));
+  --bulma-focus-h: var(--bulma-link-h);
+  --bulma-focus-s: var(--bulma-link-s);
+  --bulma-focus-l: var(--bulma-link-l);
+  --bulma-focus-offset: 1px;
+  --bulma-focus-style: solid;
+  --bulma-focus-width: 2px;
+  --bulma-focus-shadow-size: 0 0 0 0.1875em;
+  --bulma-focus-shadow-alpha: 0.25;
+  --bulma-code: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-on-scheme-l));
+  --bulma-code-background: var(--bulma-background);
+  --bulma-pre: var(--bulma-text);
+  --bulma-pre-background: var(--bulma-background);
+  --bulma-shadow: 0 0.5em 1em -0.125em hsla(var(--bulma-shadow-h), var(--bulma-shadow-s), var(--bulma-shadow-l), 0.1), 0 0px 0 1px hsla(var(--bulma-shadow-h), var(--bulma-shadow-s), var(--bulma-shadow-l), 0.02);
+}
+
+@media (prefers-color-scheme: light) {
+  :root {
+    --bulma-scheme-h: 221;
+    --bulma-scheme-s: 14%;
+    --bulma-light-l: 90%;
+    --bulma-light-invert-l: 20%;
+    --bulma-dark-l: 20%;
+    --bulma-dark-invert-l: 90%;
+    --bulma-soft-l: 90%;
+    --bulma-bold-l: 20%;
+    --bulma-soft-invert-l: 20%;
+    --bulma-bold-invert-l: 90%;
+    --bulma-hover-background-l-delta: -5%;
+    --bulma-active-background-l-delta: -10%;
+    --bulma-hover-border-l-delta: -10%;
+    --bulma-active-border-l-delta: -20%;
+    --bulma-hover-color-l-delta: -5%;
+    --bulma-active-color-l-delta: -10%;
+    --bulma-hover-shadow-a-delta: -0.05;
+    --bulma-active-shadow-a-delta: -0.1;
+    --bulma-scheme-brightness: light;
+    --bulma-scheme-main-l: 100%;
+    --bulma-scheme-main-bis-l: 98%;
+    --bulma-scheme-main-ter-l: 96%;
+    --bulma-background-l: 96%;
+    --bulma-border-weak-l: 93%;
+    --bulma-border-l: 86%;
+    --bulma-text-weak-l: 48%;
+    --bulma-text-l: 29%;
+    --bulma-text-strong-l: 21%;
+    --bulma-text-title-l: 14%;
+    --bulma-scheme-invert-ter-l: 14%;
+    --bulma-scheme-invert-bis-l: 7%;
+    --bulma-scheme-invert-l: 4%;
+    --bulma-family-primary: Inter, SF Pro, Segoe UI, Roboto, Oxygen, Ubuntu, Helvetica Neue, Helvetica, Arial, sans-serif;
+    --bulma-family-secondary: Inter, SF Pro, Segoe UI, Roboto, Oxygen, Ubuntu, Helvetica Neue, Helvetica, Arial, sans-serif;
+    --bulma-family-code: Inconsolata, Hack, SF Mono, Roboto Mono, Source Code Pro, Ubuntu Mono, monospace;
+    --bulma-size-small: 0.75rem;
+    --bulma-size-normal: 1rem;
+    --bulma-size-medium: 1.25rem;
+    --bulma-size-large: 1.5rem;
+    --bulma-weight-light: 300;
+    --bulma-weight-normal: 400;
+    --bulma-weight-medium: 500;
+    --bulma-weight-semibold: 600;
+    --bulma-weight-bold: 700;
+    --bulma-weight-extrabold: 800;
+    --bulma-block-spacing: 1.5rem;
+    --bulma-duration: 294ms;
+    --bulma-easing: ease-out;
+    --bulma-radius-small: 0.25rem;
+    --bulma-radius: 0.375rem;
+    --bulma-radius-medium: 0.5em;
+    --bulma-radius-large: 0.75rem;
+    --bulma-radius-rounded: 9999px;
+    --bulma-speed: 86ms;
+    --bulma-arrow-color: var(--bulma-link);
+    --bulma-loading-color: var(--bulma-border);
+    --bulma-burger-h: var(--bulma-link-h);
+    --bulma-burger-s: var(--bulma-link-s);
+    --bulma-burger-l: var(--bulma-link-l);
+    --bulma-burger-border-radius: 0.5em;
+    --bulma-burger-gap: 5px;
+    --bulma-burger-item-height: 2px;
+    --bulma-burger-item-width: 20px;
+    --bulma-white: hsla(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-l), 1);
+    --bulma-white-base: hsla(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-l), 1);
+    --bulma-white-rgb: 255, 255, 255;
+    --bulma-white-h: 221deg;
+    --bulma-white-s: 14%;
+    --bulma-white-l: 100%;
+    --bulma-white-invert-l: 4%;
+    --bulma-white-invert: hsl(221, 14%, 4%);
+    --bulma-white-on-scheme-l: 35%;
+    --bulma-white-on-scheme: hsla(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-on-scheme-l), 1);
+    --bulma-black: hsla(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-l), 1);
+    --bulma-black-base: hsla(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-l), 1);
+    --bulma-black-rgb: 9, 10, 12;
+    --bulma-black-h: 221deg;
+    --bulma-black-s: 14%;
+    --bulma-black-l: 4%;
+    --bulma-black-invert-l: 100%;
+    --bulma-black-invert: hsl(221, 14%, 100%);
+    --bulma-black-on-scheme-l: 4%;
+    --bulma-black-on-scheme: hsla(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-on-scheme-l), 1);
+    --bulma-light: hsla(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-l), 1);
+    --bulma-light-base: hsla(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-l), 1);
+    --bulma-light-rgb: 243, 244, 246;
+    --bulma-light-h: 221deg;
+    --bulma-light-s: 14%;
+    --bulma-light-l: 96%;
+    --bulma-light-invert-l: 21%;
+    --bulma-light-invert: hsl(221, 14%, 21%);
+    --bulma-light-on-scheme-l: 36%;
+    --bulma-light-on-scheme: hsla(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-on-scheme-l), 1);
+    --bulma-dark: hsla(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-l), 1);
+    --bulma-dark-base: hsla(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-l), 1);
+    --bulma-dark-rgb: 46, 51, 61;
+    --bulma-dark-h: 221deg;
+    --bulma-dark-s: 14%;
+    --bulma-dark-l: 21%;
+    --bulma-dark-invert-l: 96%;
+    --bulma-dark-invert: hsl(221, 14%, 96%);
+    --bulma-dark-on-scheme-l: 21%;
+    --bulma-dark-on-scheme: hsla(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-on-scheme-l), 1);
+    --bulma-text: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-l), 1);
+    --bulma-text-base: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-l), 1);
+    --bulma-text-rgb: 64, 70, 84;
+    --bulma-text-h: 221deg;
+    --bulma-text-s: 14%;
+    --bulma-text-l: 29%;
+    --bulma-text-00-l: 0%;
+    --bulma-text-05-l: 4%;
+    --bulma-text-10-l: 9%;
+    --bulma-text-15-l: 14%;
+    --bulma-text-20-l: 19%;
+    --bulma-text-25-l: 24%;
+    --bulma-text-30-l: 29%;
+    --bulma-text-35-l: 34%;
+    --bulma-text-40-l: 39%;
+    --bulma-text-45-l: 44%;
+    --bulma-text-50-l: 49%;
+    --bulma-text-55-l: 54%;
+    --bulma-text-60-l: 59%;
+    --bulma-text-65-l: 64%;
+    --bulma-text-70-l: 69%;
+    --bulma-text-75-l: 74%;
+    --bulma-text-80-l: 79%;
+    --bulma-text-85-l: 84%;
+    --bulma-text-90-l: 89%;
+    --bulma-text-95-l: 94%;
+    --bulma-text-100-l: 99%;
+    --bulma-text-00: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-00-l), 1);
+    --bulma-text-00-invert-l: var(--bulma-text-60-l);
+    --bulma-text-00-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-00-invert-l), 1);
+    --bulma-text-05: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-05-l), 1);
+    --bulma-text-05-invert-l: var(--bulma-text-60-l);
+    --bulma-text-05-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-05-invert-l), 1);
+    --bulma-text-10: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-10-l), 1);
+    --bulma-text-10-invert-l: var(--bulma-text-70-l);
+    --bulma-text-10-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-10-invert-l), 1);
+    --bulma-text-15: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-15-l), 1);
+    --bulma-text-15-invert-l: var(--bulma-text-75-l);
+    --bulma-text-15-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-15-invert-l), 1);
+    --bulma-text-20: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-20-l), 1);
+    --bulma-text-20-invert-l: var(--bulma-text-85-l);
+    --bulma-text-20-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-20-invert-l), 1);
+    --bulma-text-25: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-25-l), 1);
+    --bulma-text-25-invert-l: var(--bulma-text-95-l);
+    --bulma-text-25-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-25-invert-l), 1);
+    --bulma-text-30: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-30-l), 1);
+    --bulma-text-30-invert-l: var(--bulma-text-100-l);
+    --bulma-text-30-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-30-invert-l), 1);
+    --bulma-text-35: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-35-l), 1);
+    --bulma-text-35-invert-l: var(--bulma-text-100-l);
+    --bulma-text-35-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-35-invert-l), 1);
+    --bulma-text-40: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-40-l), 1);
+    --bulma-text-40-invert-l: var(--bulma-text-100-l);
+    --bulma-text-40-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-40-invert-l), 1);
+    --bulma-text-45: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-45-l), 1);
+    --bulma-text-45-invert-l: var(--bulma-text-100-l);
+    --bulma-text-45-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-45-invert-l), 1);
+    --bulma-text-50: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-50-l), 1);
+    --bulma-text-50-invert-l: var(--bulma-text-100-l);
+    --bulma-text-50-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-50-invert-l), 1);
+    --bulma-text-55: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-55-l), 1);
+    --bulma-text-55-invert-l: var(--bulma-text-100-l);
+    --bulma-text-55-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-55-invert-l), 1);
+    --bulma-text-60: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-60-l), 1);
+    --bulma-text-60-invert-l: var(--bulma-text-05-l);
+    --bulma-text-60-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-60-invert-l), 1);
+    --bulma-text-65: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-65-l), 1);
+    --bulma-text-65-invert-l: var(--bulma-text-05-l);
+    --bulma-text-65-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-65-invert-l), 1);
+    --bulma-text-70: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-70-l), 1);
+    --bulma-text-70-invert-l: var(--bulma-text-10-l);
+    --bulma-text-70-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-70-invert-l), 1);
+    --bulma-text-75: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-75-l), 1);
+    --bulma-text-75-invert-l: var(--bulma-text-15-l);
+    --bulma-text-75-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-75-invert-l), 1);
+    --bulma-text-80: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-80-l), 1);
+    --bulma-text-80-invert-l: var(--bulma-text-15-l);
+    --bulma-text-80-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-80-invert-l), 1);
+    --bulma-text-85: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-85-l), 1);
+    --bulma-text-85-invert-l: var(--bulma-text-20-l);
+    --bulma-text-85-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-85-invert-l), 1);
+    --bulma-text-90: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-90-l), 1);
+    --bulma-text-90-invert-l: var(--bulma-text-20-l);
+    --bulma-text-90-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-90-invert-l), 1);
+    --bulma-text-95: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-95-l), 1);
+    --bulma-text-95-invert-l: var(--bulma-text-25-l);
+    --bulma-text-95-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-95-invert-l), 1);
+    --bulma-text-100: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-100-l), 1);
+    --bulma-text-100-invert-l: var(--bulma-text-25-l);
+    --bulma-text-100-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-100-invert-l), 1);
+    --bulma-text-invert-l: var(--bulma-text-100-l);
+    --bulma-text-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-invert-l), 1);
+    --bulma-text-light-l: var(--bulma-text-90-l);
+    --bulma-text-light: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-light-l), 1);
+    --bulma-text-light-invert-l: var(--bulma-text-20-l);
+    --bulma-text-light-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-light-invert-l), 1);
+    --bulma-text-dark-l: var(--bulma-text-10-l);
+    --bulma-text-dark: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-dark-l), 1);
+    --bulma-text-dark-invert-l: var(--bulma-text-70-l);
+    --bulma-text-dark-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-dark-invert-l), 1);
+    --bulma-text-soft: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-soft-l), 1);
+    --bulma-text-bold: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-bold-l), 1);
+    --bulma-text-soft-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-soft-invert-l), 1);
+    --bulma-text-bold-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-bold-invert-l), 1);
+    --bulma-text-on-scheme-l: 29%;
+    --bulma-text-on-scheme: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-on-scheme-l), 1);
+    --bulma-primary: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-l), 1);
+    --bulma-primary-base: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-l), 1);
+    --bulma-primary-rgb: 0, 209, 178;
+    --bulma-primary-h: 171deg;
+    --bulma-primary-s: 100%;
+    --bulma-primary-l: 41%;
+    --bulma-primary-00-l: 1%;
+    --bulma-primary-05-l: 6%;
+    --bulma-primary-10-l: 11%;
+    --bulma-primary-15-l: 16%;
+    --bulma-primary-20-l: 21%;
+    --bulma-primary-25-l: 26%;
+    --bulma-primary-30-l: 31%;
+    --bulma-primary-35-l: 36%;
+    --bulma-primary-40-l: 41%;
+    --bulma-primary-45-l: 46%;
+    --bulma-primary-50-l: 51%;
+    --bulma-primary-55-l: 56%;
+    --bulma-primary-60-l: 61%;
+    --bulma-primary-65-l: 66%;
+    --bulma-primary-70-l: 71%;
+    --bulma-primary-75-l: 76%;
+    --bulma-primary-80-l: 81%;
+    --bulma-primary-85-l: 86%;
+    --bulma-primary-90-l: 91%;
+    --bulma-primary-95-l: 96%;
+    --bulma-primary-100-l: 100%;
+    --bulma-primary-00: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-00-l), 1);
+    --bulma-primary-00-invert-l: var(--bulma-primary-30-l);
+    --bulma-primary-00-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-00-invert-l), 1);
+    --bulma-primary-05: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-05-l), 1);
+    --bulma-primary-05-invert-l: var(--bulma-primary-40-l);
+    --bulma-primary-05-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-05-invert-l), 1);
+    --bulma-primary-10: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-10-l), 1);
+    --bulma-primary-10-invert-l: var(--bulma-primary-50-l);
+    --bulma-primary-10-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-10-invert-l), 1);
+    --bulma-primary-15: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-15-l), 1);
+    --bulma-primary-15-invert-l: var(--bulma-primary-100-l);
+    --bulma-primary-15-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-15-invert-l), 1);
+    --bulma-primary-20: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-20-l), 1);
+    --bulma-primary-20-invert-l: var(--bulma-primary-100-l);
+    --bulma-primary-20-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-20-invert-l), 1);
+    --bulma-primary-25: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-25-l), 1);
+    --bulma-primary-25-invert-l: var(--bulma-primary-100-l);
+    --bulma-primary-25-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-25-invert-l), 1);
+    --bulma-primary-30: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-30-l), 1);
+    --bulma-primary-30-invert-l: var(--bulma-primary-00-l);
+    --bulma-primary-30-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-30-invert-l), 1);
+    --bulma-primary-35: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-35-l), 1);
+    --bulma-primary-35-invert-l: var(--bulma-primary-00-l);
+    --bulma-primary-35-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-35-invert-l), 1);
+    --bulma-primary-40: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-40-l), 1);
+    --bulma-primary-40-invert-l: var(--bulma-primary-05-l);
+    --bulma-primary-40-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-40-invert-l), 1);
+    --bulma-primary-45: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-45-l), 1);
+    --bulma-primary-45-invert-l: var(--bulma-primary-05-l);
+    --bulma-primary-45-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-45-invert-l), 1);
+    --bulma-primary-50: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-50-l), 1);
+    --bulma-primary-50-invert-l: var(--bulma-primary-10-l);
+    --bulma-primary-50-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-50-invert-l), 1);
+    --bulma-primary-55: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-55-l), 1);
+    --bulma-primary-55-invert-l: var(--bulma-primary-10-l);
+    --bulma-primary-55-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-55-invert-l), 1);
+    --bulma-primary-60: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-60-l), 1);
+    --bulma-primary-60-invert-l: var(--bulma-primary-10-l);
+    --bulma-primary-60-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-60-invert-l), 1);
+    --bulma-primary-65: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-65-l), 1);
+    --bulma-primary-65-invert-l: var(--bulma-primary-10-l);
+    --bulma-primary-65-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-65-invert-l), 1);
+    --bulma-primary-70: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-70-l), 1);
+    --bulma-primary-70-invert-l: var(--bulma-primary-10-l);
+    --bulma-primary-70-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-70-invert-l), 1);
+    --bulma-primary-75: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-75-l), 1);
+    --bulma-primary-75-invert-l: var(--bulma-primary-10-l);
+    --bulma-primary-75-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-75-invert-l), 1);
+    --bulma-primary-80: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-80-l), 1);
+    --bulma-primary-80-invert-l: var(--bulma-primary-10-l);
+    --bulma-primary-80-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-80-invert-l), 1);
+    --bulma-primary-85: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-85-l), 1);
+    --bulma-primary-85-invert-l: var(--bulma-primary-10-l);
+    --bulma-primary-85-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-85-invert-l), 1);
+    --bulma-primary-90: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-90-l), 1);
+    --bulma-primary-90-invert-l: var(--bulma-primary-10-l);
+    --bulma-primary-90-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-90-invert-l), 1);
+    --bulma-primary-95: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-95-l), 1);
+    --bulma-primary-95-invert-l: var(--bulma-primary-10-l);
+    --bulma-primary-95-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-95-invert-l), 1);
+    --bulma-primary-100: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-100-l), 1);
+    --bulma-primary-100-invert-l: var(--bulma-primary-15-l);
+    --bulma-primary-100-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-100-invert-l), 1);
+    --bulma-primary-invert-l: var(--bulma-primary-05-l);
+    --bulma-primary-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-invert-l), 1);
+    --bulma-primary-light-l: var(--bulma-primary-90-l);
+    --bulma-primary-light: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-light-l), 1);
+    --bulma-primary-light-invert-l: var(--bulma-primary-10-l);
+    --bulma-primary-light-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-light-invert-l), 1);
+    --bulma-primary-dark-l: var(--bulma-primary-10-l);
+    --bulma-primary-dark: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-dark-l), 1);
+    --bulma-primary-dark-invert-l: var(--bulma-primary-50-l);
+    --bulma-primary-dark-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-dark-invert-l), 1);
+    --bulma-primary-soft: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-soft-l), 1);
+    --bulma-primary-bold: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-bold-l), 1);
+    --bulma-primary-soft-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-soft-invert-l), 1);
+    --bulma-primary-bold-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-bold-invert-l), 1);
+    --bulma-primary-on-scheme-l: 21%;
+    --bulma-primary-on-scheme: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-on-scheme-l), 1);
+    --bulma-link: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-l), 1);
+    --bulma-link-base: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-l), 1);
+    --bulma-link-rgb: 66, 88, 255;
+    --bulma-link-h: 233deg;
+    --bulma-link-s: 100%;
+    --bulma-link-l: 63%;
+    --bulma-link-00-l: 0%;
+    --bulma-link-05-l: 3%;
+    --bulma-link-10-l: 8%;
+    --bulma-link-15-l: 13%;
+    --bulma-link-20-l: 18%;
+    --bulma-link-25-l: 23%;
+    --bulma-link-30-l: 28%;
+    --bulma-link-35-l: 33%;
+    --bulma-link-40-l: 38%;
+    --bulma-link-45-l: 43%;
+    --bulma-link-50-l: 48%;
+    --bulma-link-55-l: 53%;
+    --bulma-link-60-l: 58%;
+    --bulma-link-65-l: 63%;
+    --bulma-link-70-l: 68%;
+    --bulma-link-75-l: 73%;
+    --bulma-link-80-l: 78%;
+    --bulma-link-85-l: 83%;
+    --bulma-link-90-l: 88%;
+    --bulma-link-95-l: 93%;
+    --bulma-link-100-l: 98%;
+    --bulma-link-00: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-00-l), 1);
+    --bulma-link-00-invert-l: var(--bulma-link-75-l);
+    --bulma-link-00-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-00-invert-l), 1);
+    --bulma-link-05: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-05-l), 1);
+    --bulma-link-05-invert-l: var(--bulma-link-75-l);
+    --bulma-link-05-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-05-invert-l), 1);
+    --bulma-link-10: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-10-l), 1);
+    --bulma-link-10-invert-l: var(--bulma-link-75-l);
+    --bulma-link-10-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-10-invert-l), 1);
+    --bulma-link-15: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-15-l), 1);
+    --bulma-link-15-invert-l: var(--bulma-link-80-l);
+    --bulma-link-15-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-15-invert-l), 1);
+    --bulma-link-20: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-20-l), 1);
+    --bulma-link-20-invert-l: var(--bulma-link-80-l);
+    --bulma-link-20-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-20-invert-l), 1);
+    --bulma-link-25: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-25-l), 1);
+    --bulma-link-25-invert-l: var(--bulma-link-85-l);
+    --bulma-link-25-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-25-invert-l), 1);
+    --bulma-link-30: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-30-l), 1);
+    --bulma-link-30-invert-l: var(--bulma-link-90-l);
+    --bulma-link-30-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-30-invert-l), 1);
+    --bulma-link-35: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-35-l), 1);
+    --bulma-link-35-invert-l: var(--bulma-link-90-l);
+    --bulma-link-35-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-35-invert-l), 1);
+    --bulma-link-40: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-40-l), 1);
+    --bulma-link-40-invert-l: var(--bulma-link-95-l);
+    --bulma-link-40-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-40-invert-l), 1);
+    --bulma-link-45: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-45-l), 1);
+    --bulma-link-45-invert-l: var(--bulma-link-100-l);
+    --bulma-link-45-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-45-invert-l), 1);
+    --bulma-link-50: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-50-l), 1);
+    --bulma-link-50-invert-l: var(--bulma-link-100-l);
+    --bulma-link-50-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-50-invert-l), 1);
+    --bulma-link-55: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-55-l), 1);
+    --bulma-link-55-invert-l: var(--bulma-link-100-l);
+    --bulma-link-55-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-55-invert-l), 1);
+    --bulma-link-60: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-60-l), 1);
+    --bulma-link-60-invert-l: var(--bulma-link-100-l);
+    --bulma-link-60-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-60-invert-l), 1);
+    --bulma-link-65: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-65-l), 1);
+    --bulma-link-65-invert-l: var(--bulma-link-100-l);
+    --bulma-link-65-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-65-invert-l), 1);
+    --bulma-link-70: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-70-l), 1);
+    --bulma-link-70-invert-l: var(--bulma-link-100-l);
+    --bulma-link-70-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-70-invert-l), 1);
+    --bulma-link-75: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-75-l), 1);
+    --bulma-link-75-invert-l: var(--bulma-link-10-l);
+    --bulma-link-75-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-75-invert-l), 1);
+    --bulma-link-80: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-80-l), 1);
+    --bulma-link-80-invert-l: var(--bulma-link-20-l);
+    --bulma-link-80-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-80-invert-l), 1);
+    --bulma-link-85: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-85-l), 1);
+    --bulma-link-85-invert-l: var(--bulma-link-25-l);
+    --bulma-link-85-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-85-invert-l), 1);
+    --bulma-link-90: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-90-l), 1);
+    --bulma-link-90-invert-l: var(--bulma-link-35-l);
+    --bulma-link-90-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-90-invert-l), 1);
+    --bulma-link-95: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-95-l), 1);
+    --bulma-link-95-invert-l: var(--bulma-link-40-l);
+    --bulma-link-95-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-95-invert-l), 1);
+    --bulma-link-100: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-100-l), 1);
+    --bulma-link-100-invert-l: var(--bulma-link-50-l);
+    --bulma-link-100-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-100-invert-l), 1);
+    --bulma-link-invert-l: var(--bulma-link-100-l);
+    --bulma-link-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-invert-l), 1);
+    --bulma-link-light-l: var(--bulma-link-90-l);
+    --bulma-link-light: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-light-l), 1);
+    --bulma-link-light-invert-l: var(--bulma-link-35-l);
+    --bulma-link-light-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-light-invert-l), 1);
+    --bulma-link-dark-l: var(--bulma-link-10-l);
+    --bulma-link-dark: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-dark-l), 1);
+    --bulma-link-dark-invert-l: var(--bulma-link-75-l);
+    --bulma-link-dark-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-dark-invert-l), 1);
+    --bulma-link-soft: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-soft-l), 1);
+    --bulma-link-bold: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-bold-l), 1);
+    --bulma-link-soft-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-soft-invert-l), 1);
+    --bulma-link-bold-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-bold-invert-l), 1);
+    --bulma-link-on-scheme-l: 58%;
+    --bulma-link-on-scheme: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-on-scheme-l), 1);
+    --bulma-info: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-l), 1);
+    --bulma-info-base: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-l), 1);
+    --bulma-info-rgb: 102, 209, 255;
+    --bulma-info-h: 198deg;
+    --bulma-info-s: 100%;
+    --bulma-info-l: 70%;
+    --bulma-info-00-l: 0%;
+    --bulma-info-05-l: 5%;
+    --bulma-info-10-l: 10%;
+    --bulma-info-15-l: 15%;
+    --bulma-info-20-l: 20%;
+    --bulma-info-25-l: 25%;
+    --bulma-info-30-l: 30%;
+    --bulma-info-35-l: 35%;
+    --bulma-info-40-l: 40%;
+    --bulma-info-45-l: 45%;
+    --bulma-info-50-l: 50%;
+    --bulma-info-55-l: 55%;
+    --bulma-info-60-l: 60%;
+    --bulma-info-65-l: 65%;
+    --bulma-info-70-l: 70%;
+    --bulma-info-75-l: 75%;
+    --bulma-info-80-l: 80%;
+    --bulma-info-85-l: 85%;
+    --bulma-info-90-l: 90%;
+    --bulma-info-95-l: 95%;
+    --bulma-info-100-l: 100%;
+    --bulma-info-00: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-00-l), 1);
+    --bulma-info-00-invert-l: var(--bulma-info-45-l);
+    --bulma-info-00-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-00-invert-l), 1);
+    --bulma-info-05: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-05-l), 1);
+    --bulma-info-05-invert-l: var(--bulma-info-50-l);
+    --bulma-info-05-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-05-invert-l), 1);
+    --bulma-info-10: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-10-l), 1);
+    --bulma-info-10-invert-l: var(--bulma-info-60-l);
+    --bulma-info-10-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-10-invert-l), 1);
+    --bulma-info-15: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-15-l), 1);
+    --bulma-info-15-invert-l: var(--bulma-info-80-l);
+    --bulma-info-15-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-15-invert-l), 1);
+    --bulma-info-20: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-20-l), 1);
+    --bulma-info-20-invert-l: var(--bulma-info-95-l);
+    --bulma-info-20-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-20-invert-l), 1);
+    --bulma-info-25: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-25-l), 1);
+    --bulma-info-25-invert-l: var(--bulma-info-100-l);
+    --bulma-info-25-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-25-invert-l), 1);
+    --bulma-info-30: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-30-l), 1);
+    --bulma-info-30-invert-l: var(--bulma-info-100-l);
+    --bulma-info-30-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-30-invert-l), 1);
+    --bulma-info-35: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-35-l), 1);
+    --bulma-info-35-invert-l: var(--bulma-info-100-l);
+    --bulma-info-35-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-35-invert-l), 1);
+    --bulma-info-40: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-40-l), 1);
+    --bulma-info-40-invert-l: var(--bulma-info-100-l);
+    --bulma-info-40-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-40-invert-l), 1);
+    --bulma-info-45: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-45-l), 1);
+    --bulma-info-45-invert-l: var(--bulma-info-00-l);
+    --bulma-info-45-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-45-invert-l), 1);
+    --bulma-info-50: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-50-l), 1);
+    --bulma-info-50-invert-l: var(--bulma-info-05-l);
+    --bulma-info-50-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-50-invert-l), 1);
+    --bulma-info-55: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-55-l), 1);
+    --bulma-info-55-invert-l: var(--bulma-info-05-l);
+    --bulma-info-55-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-55-invert-l), 1);
+    --bulma-info-60: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-60-l), 1);
+    --bulma-info-60-invert-l: var(--bulma-info-10-l);
+    --bulma-info-60-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-60-invert-l), 1);
+    --bulma-info-65: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-65-l), 1);
+    --bulma-info-65-invert-l: var(--bulma-info-10-l);
+    --bulma-info-65-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-65-invert-l), 1);
+    --bulma-info-70: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-70-l), 1);
+    --bulma-info-70-invert-l: var(--bulma-info-10-l);
+    --bulma-info-70-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-70-invert-l), 1);
+    --bulma-info-75: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-75-l), 1);
+    --bulma-info-75-invert-l: var(--bulma-info-10-l);
+    --bulma-info-75-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-75-invert-l), 1);
+    --bulma-info-80: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-80-l), 1);
+    --bulma-info-80-invert-l: var(--bulma-info-15-l);
+    --bulma-info-80-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-80-invert-l), 1);
+    --bulma-info-85: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-85-l), 1);
+    --bulma-info-85-invert-l: var(--bulma-info-15-l);
+    --bulma-info-85-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-85-invert-l), 1);
+    --bulma-info-90: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-90-l), 1);
+    --bulma-info-90-invert-l: var(--bulma-info-15-l);
+    --bulma-info-90-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-90-invert-l), 1);
+    --bulma-info-95: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-95-l), 1);
+    --bulma-info-95-invert-l: var(--bulma-info-20-l);
+    --bulma-info-95-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-95-invert-l), 1);
+    --bulma-info-100: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-100-l), 1);
+    --bulma-info-100-invert-l: var(--bulma-info-20-l);
+    --bulma-info-100-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-100-invert-l), 1);
+    --bulma-info-invert-l: var(--bulma-info-10-l);
+    --bulma-info-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-invert-l), 1);
+    --bulma-info-light-l: var(--bulma-info-90-l);
+    --bulma-info-light: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-light-l), 1);
+    --bulma-info-light-invert-l: var(--bulma-info-15-l);
+    --bulma-info-light-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-light-invert-l), 1);
+    --bulma-info-dark-l: var(--bulma-info-10-l);
+    --bulma-info-dark: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-dark-l), 1);
+    --bulma-info-dark-invert-l: var(--bulma-info-60-l);
+    --bulma-info-dark-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-dark-invert-l), 1);
+    --bulma-info-soft: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-soft-l), 1);
+    --bulma-info-bold: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-bold-l), 1);
+    --bulma-info-soft-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-soft-invert-l), 1);
+    --bulma-info-bold-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-bold-invert-l), 1);
+    --bulma-info-on-scheme-l: 25%;
+    --bulma-info-on-scheme: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-on-scheme-l), 1);
+    --bulma-success: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-l), 1);
+    --bulma-success-base: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-l), 1);
+    --bulma-success-rgb: 72, 199, 142;
+    --bulma-success-h: 153deg;
+    --bulma-success-s: 53%;
+    --bulma-success-l: 53%;
+    --bulma-success-00-l: 0%;
+    --bulma-success-05-l: 3%;
+    --bulma-success-10-l: 8%;
+    --bulma-success-15-l: 13%;
+    --bulma-success-20-l: 18%;
+    --bulma-success-25-l: 23%;
+    --bulma-success-30-l: 28%;
+    --bulma-success-35-l: 33%;
+    --bulma-success-40-l: 38%;
+    --bulma-success-45-l: 43%;
+    --bulma-success-50-l: 48%;
+    --bulma-success-55-l: 53%;
+    --bulma-success-60-l: 58%;
+    --bulma-success-65-l: 63%;
+    --bulma-success-70-l: 68%;
+    --bulma-success-75-l: 73%;
+    --bulma-success-80-l: 78%;
+    --bulma-success-85-l: 83%;
+    --bulma-success-90-l: 88%;
+    --bulma-success-95-l: 93%;
+    --bulma-success-100-l: 98%;
+    --bulma-success-00: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-00-l), 1);
+    --bulma-success-00-invert-l: var(--bulma-success-45-l);
+    --bulma-success-00-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-00-invert-l), 1);
+    --bulma-success-05: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-05-l), 1);
+    --bulma-success-05-invert-l: var(--bulma-success-45-l);
+    --bulma-success-05-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-05-invert-l), 1);
+    --bulma-success-10: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-10-l), 1);
+    --bulma-success-10-invert-l: var(--bulma-success-55-l);
+    --bulma-success-10-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-10-invert-l), 1);
+    --bulma-success-15: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-15-l), 1);
+    --bulma-success-15-invert-l: var(--bulma-success-75-l);
+    --bulma-success-15-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-15-invert-l), 1);
+    --bulma-success-20: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-20-l), 1);
+    --bulma-success-20-invert-l: var(--bulma-success-90-l);
+    --bulma-success-20-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-20-invert-l), 1);
+    --bulma-success-25: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-25-l), 1);
+    --bulma-success-25-invert-l: var(--bulma-success-100-l);
+    --bulma-success-25-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-25-invert-l), 1);
+    --bulma-success-30: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-30-l), 1);
+    --bulma-success-30-invert-l: var(--bulma-success-100-l);
+    --bulma-success-30-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-30-invert-l), 1);
+    --bulma-success-35: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-35-l), 1);
+    --bulma-success-35-invert-l: var(--bulma-success-100-l);
+    --bulma-success-35-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-35-invert-l), 1);
+    --bulma-success-40: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-40-l), 1);
+    --bulma-success-40-invert-l: var(--bulma-success-100-l);
+    --bulma-success-40-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-40-invert-l), 1);
+    --bulma-success-45: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-45-l), 1);
+    --bulma-success-45-invert-l: var(--bulma-success-05-l);
+    --bulma-success-45-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-45-invert-l), 1);
+    --bulma-success-50: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-50-l), 1);
+    --bulma-success-50-invert-l: var(--bulma-success-05-l);
+    --bulma-success-50-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-50-invert-l), 1);
+    --bulma-success-55: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-55-l), 1);
+    --bulma-success-55-invert-l: var(--bulma-success-10-l);
+    --bulma-success-55-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-55-invert-l), 1);
+    --bulma-success-60: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-60-l), 1);
+    --bulma-success-60-invert-l: var(--bulma-success-10-l);
+    --bulma-success-60-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-60-invert-l), 1);
+    --bulma-success-65: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-65-l), 1);
+    --bulma-success-65-invert-l: var(--bulma-success-10-l);
+    --bulma-success-65-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-65-invert-l), 1);
+    --bulma-success-70: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-70-l), 1);
+    --bulma-success-70-invert-l: var(--bulma-success-10-l);
+    --bulma-success-70-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-70-invert-l), 1);
+    --bulma-success-75: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-75-l), 1);
+    --bulma-success-75-invert-l: var(--bulma-success-15-l);
+    --bulma-success-75-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-75-invert-l), 1);
+    --bulma-success-80: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-80-l), 1);
+    --bulma-success-80-invert-l: var(--bulma-success-15-l);
+    --bulma-success-80-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-80-invert-l), 1);
+    --bulma-success-85: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-85-l), 1);
+    --bulma-success-85-invert-l: var(--bulma-success-15-l);
+    --bulma-success-85-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-85-invert-l), 1);
+    --bulma-success-90: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-90-l), 1);
+    --bulma-success-90-invert-l: var(--bulma-success-20-l);
+    --bulma-success-90-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-90-invert-l), 1);
+    --bulma-success-95: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-95-l), 1);
+    --bulma-success-95-invert-l: var(--bulma-success-20-l);
+    --bulma-success-95-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-95-invert-l), 1);
+    --bulma-success-100: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-100-l), 1);
+    --bulma-success-100-invert-l: var(--bulma-success-20-l);
+    --bulma-success-100-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-100-invert-l), 1);
+    --bulma-success-invert-l: var(--bulma-success-10-l);
+    --bulma-success-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-invert-l), 1);
+    --bulma-success-light-l: var(--bulma-success-90-l);
+    --bulma-success-light: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-light-l), 1);
+    --bulma-success-light-invert-l: var(--bulma-success-20-l);
+    --bulma-success-light-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-light-invert-l), 1);
+    --bulma-success-dark-l: var(--bulma-success-10-l);
+    --bulma-success-dark: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-dark-l), 1);
+    --bulma-success-dark-invert-l: var(--bulma-success-55-l);
+    --bulma-success-dark-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-dark-invert-l), 1);
+    --bulma-success-soft: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-soft-l), 1);
+    --bulma-success-bold: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-bold-l), 1);
+    --bulma-success-soft-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-soft-invert-l), 1);
+    --bulma-success-bold-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-bold-invert-l), 1);
+    --bulma-success-on-scheme-l: 23%;
+    --bulma-success-on-scheme: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-on-scheme-l), 1);
+    --bulma-warning: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-l), 1);
+    --bulma-warning-base: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-l), 1);
+    --bulma-warning-rgb: 255, 183, 15;
+    --bulma-warning-h: 42deg;
+    --bulma-warning-s: 100%;
+    --bulma-warning-l: 53%;
+    --bulma-warning-00-l: 0%;
+    --bulma-warning-05-l: 3%;
+    --bulma-warning-10-l: 8%;
+    --bulma-warning-15-l: 13%;
+    --bulma-warning-20-l: 18%;
+    --bulma-warning-25-l: 23%;
+    --bulma-warning-30-l: 28%;
+    --bulma-warning-35-l: 33%;
+    --bulma-warning-40-l: 38%;
+    --bulma-warning-45-l: 43%;
+    --bulma-warning-50-l: 48%;
+    --bulma-warning-55-l: 53%;
+    --bulma-warning-60-l: 58%;
+    --bulma-warning-65-l: 63%;
+    --bulma-warning-70-l: 68%;
+    --bulma-warning-75-l: 73%;
+    --bulma-warning-80-l: 78%;
+    --bulma-warning-85-l: 83%;
+    --bulma-warning-90-l: 88%;
+    --bulma-warning-95-l: 93%;
+    --bulma-warning-100-l: 98%;
+    --bulma-warning-00: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-00-l), 1);
+    --bulma-warning-00-invert-l: var(--bulma-warning-40-l);
+    --bulma-warning-00-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-00-invert-l), 1);
+    --bulma-warning-05: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-05-l), 1);
+    --bulma-warning-05-invert-l: var(--bulma-warning-45-l);
+    --bulma-warning-05-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-05-invert-l), 1);
+    --bulma-warning-10: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-10-l), 1);
+    --bulma-warning-10-invert-l: var(--bulma-warning-50-l);
+    --bulma-warning-10-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-10-invert-l), 1);
+    --bulma-warning-15: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-15-l), 1);
+    --bulma-warning-15-invert-l: var(--bulma-warning-70-l);
+    --bulma-warning-15-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-15-invert-l), 1);
+    --bulma-warning-20: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-20-l), 1);
+    --bulma-warning-20-invert-l: var(--bulma-warning-100-l);
+    --bulma-warning-20-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-20-invert-l), 1);
+    --bulma-warning-25: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-25-l), 1);
+    --bulma-warning-25-invert-l: var(--bulma-warning-100-l);
+    --bulma-warning-25-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-25-invert-l), 1);
+    --bulma-warning-30: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-30-l), 1);
+    --bulma-warning-30-invert-l: var(--bulma-warning-100-l);
+    --bulma-warning-30-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-30-invert-l), 1);
+    --bulma-warning-35: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-35-l), 1);
+    --bulma-warning-35-invert-l: var(--bulma-warning-100-l);
+    --bulma-warning-35-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-35-invert-l), 1);
+    --bulma-warning-40: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-40-l), 1);
+    --bulma-warning-40-invert-l: var(--bulma-warning-00-l);
+    --bulma-warning-40-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-40-invert-l), 1);
+    --bulma-warning-45: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-45-l), 1);
+    --bulma-warning-45-invert-l: var(--bulma-warning-05-l);
+    --bulma-warning-45-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-45-invert-l), 1);
+    --bulma-warning-50: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-50-l), 1);
+    --bulma-warning-50-invert-l: var(--bulma-warning-10-l);
+    --bulma-warning-50-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-50-invert-l), 1);
+    --bulma-warning-55: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-55-l), 1);
+    --bulma-warning-55-invert-l: var(--bulma-warning-10-l);
+    --bulma-warning-55-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-55-invert-l), 1);
+    --bulma-warning-60: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-60-l), 1);
+    --bulma-warning-60-invert-l: var(--bulma-warning-10-l);
+    --bulma-warning-60-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-60-invert-l), 1);
+    --bulma-warning-65: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-65-l), 1);
+    --bulma-warning-65-invert-l: var(--bulma-warning-10-l);
+    --bulma-warning-65-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-65-invert-l), 1);
+    --bulma-warning-70: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-70-l), 1);
+    --bulma-warning-70-invert-l: var(--bulma-warning-15-l);
+    --bulma-warning-70-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-70-invert-l), 1);
+    --bulma-warning-75: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-75-l), 1);
+    --bulma-warning-75-invert-l: var(--bulma-warning-15-l);
+    --bulma-warning-75-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-75-invert-l), 1);
+    --bulma-warning-80: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-80-l), 1);
+    --bulma-warning-80-invert-l: var(--bulma-warning-15-l);
+    --bulma-warning-80-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-80-invert-l), 1);
+    --bulma-warning-85: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-85-l), 1);
+    --bulma-warning-85-invert-l: var(--bulma-warning-15-l);
+    --bulma-warning-85-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-85-invert-l), 1);
+    --bulma-warning-90: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-90-l), 1);
+    --bulma-warning-90-invert-l: var(--bulma-warning-15-l);
+    --bulma-warning-90-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-90-invert-l), 1);
+    --bulma-warning-95: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-95-l), 1);
+    --bulma-warning-95-invert-l: var(--bulma-warning-15-l);
+    --bulma-warning-95-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-95-invert-l), 1);
+    --bulma-warning-100: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-100-l), 1);
+    --bulma-warning-100-invert-l: var(--bulma-warning-20-l);
+    --bulma-warning-100-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-100-invert-l), 1);
+    --bulma-warning-invert-l: var(--bulma-warning-10-l);
+    --bulma-warning-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-invert-l), 1);
+    --bulma-warning-light-l: var(--bulma-warning-90-l);
+    --bulma-warning-light: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-light-l), 1);
+    --bulma-warning-light-invert-l: var(--bulma-warning-15-l);
+    --bulma-warning-light-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-light-invert-l), 1);
+    --bulma-warning-dark-l: var(--bulma-warning-10-l);
+    --bulma-warning-dark: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-dark-l), 1);
+    --bulma-warning-dark-invert-l: var(--bulma-warning-50-l);
+    --bulma-warning-dark-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-dark-invert-l), 1);
+    --bulma-warning-soft: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-soft-l), 1);
+    --bulma-warning-bold: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-bold-l), 1);
+    --bulma-warning-soft-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-soft-invert-l), 1);
+    --bulma-warning-bold-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-bold-invert-l), 1);
+    --bulma-warning-on-scheme-l: 23%;
+    --bulma-warning-on-scheme: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-on-scheme-l), 1);
+    --bulma-danger: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-l), 1);
+    --bulma-danger-base: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-l), 1);
+    --bulma-danger-rgb: 255, 102, 133;
+    --bulma-danger-h: 348deg;
+    --bulma-danger-s: 100%;
+    --bulma-danger-l: 70%;
+    --bulma-danger-00-l: 0%;
+    --bulma-danger-05-l: 5%;
+    --bulma-danger-10-l: 10%;
+    --bulma-danger-15-l: 15%;
+    --bulma-danger-20-l: 20%;
+    --bulma-danger-25-l: 25%;
+    --bulma-danger-30-l: 30%;
+    --bulma-danger-35-l: 35%;
+    --bulma-danger-40-l: 40%;
+    --bulma-danger-45-l: 45%;
+    --bulma-danger-50-l: 50%;
+    --bulma-danger-55-l: 55%;
+    --bulma-danger-60-l: 60%;
+    --bulma-danger-65-l: 65%;
+    --bulma-danger-70-l: 70%;
+    --bulma-danger-75-l: 75%;
+    --bulma-danger-80-l: 80%;
+    --bulma-danger-85-l: 85%;
+    --bulma-danger-90-l: 90%;
+    --bulma-danger-95-l: 95%;
+    --bulma-danger-100-l: 100%;
+    --bulma-danger-00: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-00-l), 1);
+    --bulma-danger-00-invert-l: var(--bulma-danger-65-l);
+    --bulma-danger-00-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-00-invert-l), 1);
+    --bulma-danger-05: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-05-l), 1);
+    --bulma-danger-05-invert-l: var(--bulma-danger-70-l);
+    --bulma-danger-05-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-05-invert-l), 1);
+    --bulma-danger-10: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-10-l), 1);
+    --bulma-danger-10-invert-l: var(--bulma-danger-75-l);
+    --bulma-danger-10-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-10-invert-l), 1);
+    --bulma-danger-15: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-15-l), 1);
+    --bulma-danger-15-invert-l: var(--bulma-danger-80-l);
+    --bulma-danger-15-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-15-invert-l), 1);
+    --bulma-danger-20: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-20-l), 1);
+    --bulma-danger-20-invert-l: var(--bulma-danger-85-l);
+    --bulma-danger-20-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-20-invert-l), 1);
+    --bulma-danger-25: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-25-l), 1);
+    --bulma-danger-25-invert-l: var(--bulma-danger-90-l);
+    --bulma-danger-25-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-25-invert-l), 1);
+    --bulma-danger-30: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-30-l), 1);
+    --bulma-danger-30-invert-l: var(--bulma-danger-100-l);
+    --bulma-danger-30-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-30-invert-l), 1);
+    --bulma-danger-35: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-35-l), 1);
+    --bulma-danger-35-invert-l: var(--bulma-danger-100-l);
+    --bulma-danger-35-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-35-invert-l), 1);
+    --bulma-danger-40: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-40-l), 1);
+    --bulma-danger-40-invert-l: var(--bulma-danger-100-l);
+    --bulma-danger-40-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-40-invert-l), 1);
+    --bulma-danger-45: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-45-l), 1);
+    --bulma-danger-45-invert-l: var(--bulma-danger-100-l);
+    --bulma-danger-45-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-45-invert-l), 1);
+    --bulma-danger-50: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-50-l), 1);
+    --bulma-danger-50-invert-l: var(--bulma-danger-100-l);
+    --bulma-danger-50-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-50-invert-l), 1);
+    --bulma-danger-55: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-55-l), 1);
+    --bulma-danger-55-invert-l: var(--bulma-danger-100-l);
+    --bulma-danger-55-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-55-invert-l), 1);
+    --bulma-danger-60: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-60-l), 1);
+    --bulma-danger-60-invert-l: var(--bulma-danger-100-l);
+    --bulma-danger-60-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-60-invert-l), 1);
+    --bulma-danger-65: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-65-l), 1);
+    --bulma-danger-65-invert-l: var(--bulma-danger-00-l);
+    --bulma-danger-65-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-65-invert-l), 1);
+    --bulma-danger-70: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-70-l), 1);
+    --bulma-danger-70-invert-l: var(--bulma-danger-05-l);
+    --bulma-danger-70-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-70-invert-l), 1);
+    --bulma-danger-75: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-75-l), 1);
+    --bulma-danger-75-invert-l: var(--bulma-danger-10-l);
+    --bulma-danger-75-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-75-invert-l), 1);
+    --bulma-danger-80: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-80-l), 1);
+    --bulma-danger-80-invert-l: var(--bulma-danger-15-l);
+    --bulma-danger-80-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-80-invert-l), 1);
+    --bulma-danger-85: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-85-l), 1);
+    --bulma-danger-85-invert-l: var(--bulma-danger-20-l);
+    --bulma-danger-85-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-85-invert-l), 1);
+    --bulma-danger-90: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-90-l), 1);
+    --bulma-danger-90-invert-l: var(--bulma-danger-25-l);
+    --bulma-danger-90-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-90-invert-l), 1);
+    --bulma-danger-95: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-95-l), 1);
+    --bulma-danger-95-invert-l: var(--bulma-danger-25-l);
+    --bulma-danger-95-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-95-invert-l), 1);
+    --bulma-danger-100: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-100-l), 1);
+    --bulma-danger-100-invert-l: var(--bulma-danger-30-l);
+    --bulma-danger-100-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-100-invert-l), 1);
+    --bulma-danger-invert-l: var(--bulma-danger-05-l);
+    --bulma-danger-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-invert-l), 1);
+    --bulma-danger-light-l: var(--bulma-danger-90-l);
+    --bulma-danger-light: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-light-l), 1);
+    --bulma-danger-light-invert-l: var(--bulma-danger-25-l);
+    --bulma-danger-light-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-light-invert-l), 1);
+    --bulma-danger-dark-l: var(--bulma-danger-10-l);
+    --bulma-danger-dark: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-dark-l), 1);
+    --bulma-danger-dark-invert-l: var(--bulma-danger-75-l);
+    --bulma-danger-dark-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-dark-invert-l), 1);
+    --bulma-danger-soft: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-soft-l), 1);
+    --bulma-danger-bold: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-bold-l), 1);
+    --bulma-danger-soft-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-soft-invert-l), 1);
+    --bulma-danger-bold-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-bold-invert-l), 1);
+    --bulma-danger-on-scheme-l: 40%;
+    --bulma-danger-on-scheme: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-on-scheme-l), 1);
+    --bulma-black-bis: hsl(221, 14%, 9%);
+    --bulma-black-ter: hsl(221, 14%, 14%);
+    --bulma-grey-darker: hsl(221, 14%, 21%);
+    --bulma-grey-dark: hsl(221, 14%, 29%);
+    --bulma-grey: hsl(221, 14%, 48%);
+    --bulma-grey-light: hsl(221, 14%, 71%);
+    --bulma-grey-lighter: hsl(221, 14%, 86%);
+    --bulma-white-ter: hsl(221, 14%, 96%);
+    --bulma-white-bis: hsl(221, 14%, 98%);
+    --bulma-shadow-h: 221deg;
+    --bulma-shadow-s: 14%;
+    --bulma-shadow-l: 4%;
+    --bulma-size-1: 3rem;
+    --bulma-size-2: 2.5rem;
+    --bulma-size-3: 2rem;
+    --bulma-size-4: 1.5rem;
+    --bulma-size-5: 1.25rem;
+    --bulma-size-6: 1rem;
+    --bulma-size-7: 0.75rem;
+  }
+}
+@media (prefers-color-scheme: dark) {
+  :root {
+    --bulma-white-on-scheme-l: 100%;
+    --bulma-white-on-scheme: hsla(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-on-scheme-l), 1);
+    --bulma-black-on-scheme-l: 0%;
+    --bulma-black-on-scheme: hsla(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-on-scheme-l), 1);
+    --bulma-light-on-scheme-l: 96%;
+    --bulma-light-on-scheme: hsla(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-on-scheme-l), 1);
+    --bulma-dark-on-scheme-l: 56%;
+    --bulma-dark-on-scheme: hsla(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-on-scheme-l), 1);
+    --bulma-text-on-scheme-l: 54%;
+    --bulma-text-on-scheme: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-on-scheme-l), 1);
+    --bulma-primary-on-scheme-l: 41%;
+    --bulma-primary-on-scheme: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-on-scheme-l), 1);
+    --bulma-link-on-scheme-l: 73%;
+    --bulma-link-on-scheme: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-on-scheme-l), 1);
+    --bulma-info-on-scheme-l: 70%;
+    --bulma-info-on-scheme: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-on-scheme-l), 1);
+    --bulma-success-on-scheme-l: 53%;
+    --bulma-success-on-scheme: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-on-scheme-l), 1);
+    --bulma-warning-on-scheme-l: 53%;
+    --bulma-warning-on-scheme: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-on-scheme-l), 1);
+    --bulma-danger-on-scheme-l: 70%;
+    --bulma-danger-on-scheme: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-on-scheme-l), 1);
+    --bulma-scheme-brightness: dark;
+    --bulma-scheme-main-l: 9%;
+    --bulma-scheme-main-bis-l: 11%;
+    --bulma-scheme-main-ter-l: 13%;
+    --bulma-soft-l: 20%;
+    --bulma-bold-l: 90%;
+    --bulma-soft-invert-l: 90%;
+    --bulma-bold-invert-l: 20%;
+    --bulma-background-l: 14%;
+    --bulma-border-weak-l: 21%;
+    --bulma-border-l: 24%;
+    --bulma-text-weak-l: 53%;
+    --bulma-text-l: 71%;
+    --bulma-text-strong-l: 93%;
+    --bulma-text-title-l: 100%;
+    --bulma-hover-background-l-delta: 5%;
+    --bulma-active-background-l-delta: 10%;
+    --bulma-hover-border-l-delta: 10%;
+    --bulma-active-border-l-delta: 20%;
+    --bulma-hover-color-l-delta: 5%;
+    --bulma-active-color-l-delta: 10%;
+    --bulma-shadow-h: 0deg;
+    --bulma-shadow-s: 0%;
+    --bulma-shadow-l: 100%;
+  }
+}
+[data-theme=light],
+.theme-light {
+  --bulma-scheme-h: 221;
+  --bulma-scheme-s: 14%;
+  --bulma-light-l: 90%;
+  --bulma-light-invert-l: 20%;
+  --bulma-dark-l: 20%;
+  --bulma-dark-invert-l: 90%;
+  --bulma-soft-l: 90%;
+  --bulma-bold-l: 20%;
+  --bulma-soft-invert-l: 20%;
+  --bulma-bold-invert-l: 90%;
+  --bulma-hover-background-l-delta: -5%;
+  --bulma-active-background-l-delta: -10%;
+  --bulma-hover-border-l-delta: -10%;
+  --bulma-active-border-l-delta: -20%;
+  --bulma-hover-color-l-delta: -5%;
+  --bulma-active-color-l-delta: -10%;
+  --bulma-hover-shadow-a-delta: -0.05;
+  --bulma-active-shadow-a-delta: -0.1;
+  --bulma-scheme-brightness: light;
+  --bulma-scheme-main-l: 100%;
+  --bulma-scheme-main-bis-l: 98%;
+  --bulma-scheme-main-ter-l: 96%;
+  --bulma-background-l: 96%;
+  --bulma-border-weak-l: 93%;
+  --bulma-border-l: 86%;
+  --bulma-text-weak-l: 48%;
+  --bulma-text-l: 29%;
+  --bulma-text-strong-l: 21%;
+  --bulma-text-title-l: 14%;
+  --bulma-scheme-invert-ter-l: 14%;
+  --bulma-scheme-invert-bis-l: 7%;
+  --bulma-scheme-invert-l: 4%;
+  --bulma-family-primary: Inter, SF Pro, Segoe UI, Roboto, Oxygen, Ubuntu, Helvetica Neue, Helvetica, Arial, sans-serif;
+  --bulma-family-secondary: Inter, SF Pro, Segoe UI, Roboto, Oxygen, Ubuntu, Helvetica Neue, Helvetica, Arial, sans-serif;
+  --bulma-family-code: Inconsolata, Hack, SF Mono, Roboto Mono, Source Code Pro, Ubuntu Mono, monospace;
+  --bulma-size-small: 0.75rem;
+  --bulma-size-normal: 1rem;
+  --bulma-size-medium: 1.25rem;
+  --bulma-size-large: 1.5rem;
+  --bulma-weight-light: 300;
+  --bulma-weight-normal: 400;
+  --bulma-weight-medium: 500;
+  --bulma-weight-semibold: 600;
+  --bulma-weight-bold: 700;
+  --bulma-weight-extrabold: 800;
+  --bulma-block-spacing: 1.5rem;
+  --bulma-duration: 294ms;
+  --bulma-easing: ease-out;
+  --bulma-radius-small: 0.25rem;
+  --bulma-radius: 0.375rem;
+  --bulma-radius-medium: 0.5em;
+  --bulma-radius-large: 0.75rem;
+  --bulma-radius-rounded: 9999px;
+  --bulma-speed: 86ms;
+  --bulma-arrow-color: var(--bulma-link);
+  --bulma-loading-color: var(--bulma-border);
+  --bulma-burger-h: var(--bulma-link-h);
+  --bulma-burger-s: var(--bulma-link-s);
+  --bulma-burger-l: var(--bulma-link-l);
+  --bulma-burger-border-radius: 0.5em;
+  --bulma-burger-gap: 5px;
+  --bulma-burger-item-height: 2px;
+  --bulma-burger-item-width: 20px;
+  --bulma-white: hsla(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-l), 1);
+  --bulma-white-base: hsla(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-l), 1);
+  --bulma-white-rgb: 255, 255, 255;
+  --bulma-white-h: 221deg;
+  --bulma-white-s: 14%;
+  --bulma-white-l: 100%;
+  --bulma-white-invert-l: 4%;
+  --bulma-white-invert: hsl(221, 14%, 4%);
+  --bulma-white-on-scheme-l: 35%;
+  --bulma-white-on-scheme: hsla(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-on-scheme-l), 1);
+  --bulma-black: hsla(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-l), 1);
+  --bulma-black-base: hsla(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-l), 1);
+  --bulma-black-rgb: 9, 10, 12;
+  --bulma-black-h: 221deg;
+  --bulma-black-s: 14%;
+  --bulma-black-l: 4%;
+  --bulma-black-invert-l: 100%;
+  --bulma-black-invert: hsl(221, 14%, 100%);
+  --bulma-black-on-scheme-l: 4%;
+  --bulma-black-on-scheme: hsla(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-on-scheme-l), 1);
+  --bulma-light: hsla(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-l), 1);
+  --bulma-light-base: hsla(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-l), 1);
+  --bulma-light-rgb: 243, 244, 246;
+  --bulma-light-h: 221deg;
+  --bulma-light-s: 14%;
+  --bulma-light-l: 96%;
+  --bulma-light-invert-l: 21%;
+  --bulma-light-invert: hsl(221, 14%, 21%);
+  --bulma-light-on-scheme-l: 36%;
+  --bulma-light-on-scheme: hsla(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-on-scheme-l), 1);
+  --bulma-dark: hsla(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-l), 1);
+  --bulma-dark-base: hsla(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-l), 1);
+  --bulma-dark-rgb: 46, 51, 61;
+  --bulma-dark-h: 221deg;
+  --bulma-dark-s: 14%;
+  --bulma-dark-l: 21%;
+  --bulma-dark-invert-l: 96%;
+  --bulma-dark-invert: hsl(221, 14%, 96%);
+  --bulma-dark-on-scheme-l: 21%;
+  --bulma-dark-on-scheme: hsla(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-on-scheme-l), 1);
+  --bulma-text: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-l), 1);
+  --bulma-text-base: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-l), 1);
+  --bulma-text-rgb: 64, 70, 84;
+  --bulma-text-h: 221deg;
+  --bulma-text-s: 14%;
+  --bulma-text-l: 29%;
+  --bulma-text-00-l: 0%;
+  --bulma-text-05-l: 4%;
+  --bulma-text-10-l: 9%;
+  --bulma-text-15-l: 14%;
+  --bulma-text-20-l: 19%;
+  --bulma-text-25-l: 24%;
+  --bulma-text-30-l: 29%;
+  --bulma-text-35-l: 34%;
+  --bulma-text-40-l: 39%;
+  --bulma-text-45-l: 44%;
+  --bulma-text-50-l: 49%;
+  --bulma-text-55-l: 54%;
+  --bulma-text-60-l: 59%;
+  --bulma-text-65-l: 64%;
+  --bulma-text-70-l: 69%;
+  --bulma-text-75-l: 74%;
+  --bulma-text-80-l: 79%;
+  --bulma-text-85-l: 84%;
+  --bulma-text-90-l: 89%;
+  --bulma-text-95-l: 94%;
+  --bulma-text-100-l: 99%;
+  --bulma-text-00: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-00-l), 1);
+  --bulma-text-00-invert-l: var(--bulma-text-60-l);
+  --bulma-text-00-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-00-invert-l), 1);
+  --bulma-text-05: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-05-l), 1);
+  --bulma-text-05-invert-l: var(--bulma-text-60-l);
+  --bulma-text-05-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-05-invert-l), 1);
+  --bulma-text-10: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-10-l), 1);
+  --bulma-text-10-invert-l: var(--bulma-text-70-l);
+  --bulma-text-10-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-10-invert-l), 1);
+  --bulma-text-15: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-15-l), 1);
+  --bulma-text-15-invert-l: var(--bulma-text-75-l);
+  --bulma-text-15-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-15-invert-l), 1);
+  --bulma-text-20: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-20-l), 1);
+  --bulma-text-20-invert-l: var(--bulma-text-85-l);
+  --bulma-text-20-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-20-invert-l), 1);
+  --bulma-text-25: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-25-l), 1);
+  --bulma-text-25-invert-l: var(--bulma-text-95-l);
+  --bulma-text-25-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-25-invert-l), 1);
+  --bulma-text-30: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-30-l), 1);
+  --bulma-text-30-invert-l: var(--bulma-text-100-l);
+  --bulma-text-30-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-30-invert-l), 1);
+  --bulma-text-35: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-35-l), 1);
+  --bulma-text-35-invert-l: var(--bulma-text-100-l);
+  --bulma-text-35-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-35-invert-l), 1);
+  --bulma-text-40: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-40-l), 1);
+  --bulma-text-40-invert-l: var(--bulma-text-100-l);
+  --bulma-text-40-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-40-invert-l), 1);
+  --bulma-text-45: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-45-l), 1);
+  --bulma-text-45-invert-l: var(--bulma-text-100-l);
+  --bulma-text-45-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-45-invert-l), 1);
+  --bulma-text-50: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-50-l), 1);
+  --bulma-text-50-invert-l: var(--bulma-text-100-l);
+  --bulma-text-50-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-50-invert-l), 1);
+  --bulma-text-55: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-55-l), 1);
+  --bulma-text-55-invert-l: var(--bulma-text-100-l);
+  --bulma-text-55-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-55-invert-l), 1);
+  --bulma-text-60: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-60-l), 1);
+  --bulma-text-60-invert-l: var(--bulma-text-05-l);
+  --bulma-text-60-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-60-invert-l), 1);
+  --bulma-text-65: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-65-l), 1);
+  --bulma-text-65-invert-l: var(--bulma-text-05-l);
+  --bulma-text-65-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-65-invert-l), 1);
+  --bulma-text-70: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-70-l), 1);
+  --bulma-text-70-invert-l: var(--bulma-text-10-l);
+  --bulma-text-70-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-70-invert-l), 1);
+  --bulma-text-75: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-75-l), 1);
+  --bulma-text-75-invert-l: var(--bulma-text-15-l);
+  --bulma-text-75-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-75-invert-l), 1);
+  --bulma-text-80: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-80-l), 1);
+  --bulma-text-80-invert-l: var(--bulma-text-15-l);
+  --bulma-text-80-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-80-invert-l), 1);
+  --bulma-text-85: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-85-l), 1);
+  --bulma-text-85-invert-l: var(--bulma-text-20-l);
+  --bulma-text-85-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-85-invert-l), 1);
+  --bulma-text-90: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-90-l), 1);
+  --bulma-text-90-invert-l: var(--bulma-text-20-l);
+  --bulma-text-90-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-90-invert-l), 1);
+  --bulma-text-95: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-95-l), 1);
+  --bulma-text-95-invert-l: var(--bulma-text-25-l);
+  --bulma-text-95-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-95-invert-l), 1);
+  --bulma-text-100: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-100-l), 1);
+  --bulma-text-100-invert-l: var(--bulma-text-25-l);
+  --bulma-text-100-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-100-invert-l), 1);
+  --bulma-text-invert-l: var(--bulma-text-100-l);
+  --bulma-text-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-invert-l), 1);
+  --bulma-text-light-l: var(--bulma-text-90-l);
+  --bulma-text-light: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-light-l), 1);
+  --bulma-text-light-invert-l: var(--bulma-text-20-l);
+  --bulma-text-light-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-light-invert-l), 1);
+  --bulma-text-dark-l: var(--bulma-text-10-l);
+  --bulma-text-dark: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-dark-l), 1);
+  --bulma-text-dark-invert-l: var(--bulma-text-70-l);
+  --bulma-text-dark-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-dark-invert-l), 1);
+  --bulma-text-soft: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-soft-l), 1);
+  --bulma-text-bold: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-bold-l), 1);
+  --bulma-text-soft-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-soft-invert-l), 1);
+  --bulma-text-bold-invert: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-bold-invert-l), 1);
+  --bulma-text-on-scheme-l: 29%;
+  --bulma-text-on-scheme: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-on-scheme-l), 1);
+  --bulma-primary: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-l), 1);
+  --bulma-primary-base: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-l), 1);
+  --bulma-primary-rgb: 0, 209, 178;
+  --bulma-primary-h: 171deg;
+  --bulma-primary-s: 100%;
+  --bulma-primary-l: 41%;
+  --bulma-primary-00-l: 1%;
+  --bulma-primary-05-l: 6%;
+  --bulma-primary-10-l: 11%;
+  --bulma-primary-15-l: 16%;
+  --bulma-primary-20-l: 21%;
+  --bulma-primary-25-l: 26%;
+  --bulma-primary-30-l: 31%;
+  --bulma-primary-35-l: 36%;
+  --bulma-primary-40-l: 41%;
+  --bulma-primary-45-l: 46%;
+  --bulma-primary-50-l: 51%;
+  --bulma-primary-55-l: 56%;
+  --bulma-primary-60-l: 61%;
+  --bulma-primary-65-l: 66%;
+  --bulma-primary-70-l: 71%;
+  --bulma-primary-75-l: 76%;
+  --bulma-primary-80-l: 81%;
+  --bulma-primary-85-l: 86%;
+  --bulma-primary-90-l: 91%;
+  --bulma-primary-95-l: 96%;
+  --bulma-primary-100-l: 100%;
+  --bulma-primary-00: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-00-l), 1);
+  --bulma-primary-00-invert-l: var(--bulma-primary-30-l);
+  --bulma-primary-00-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-00-invert-l), 1);
+  --bulma-primary-05: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-05-l), 1);
+  --bulma-primary-05-invert-l: var(--bulma-primary-40-l);
+  --bulma-primary-05-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-05-invert-l), 1);
+  --bulma-primary-10: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-10-l), 1);
+  --bulma-primary-10-invert-l: var(--bulma-primary-50-l);
+  --bulma-primary-10-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-10-invert-l), 1);
+  --bulma-primary-15: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-15-l), 1);
+  --bulma-primary-15-invert-l: var(--bulma-primary-100-l);
+  --bulma-primary-15-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-15-invert-l), 1);
+  --bulma-primary-20: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-20-l), 1);
+  --bulma-primary-20-invert-l: var(--bulma-primary-100-l);
+  --bulma-primary-20-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-20-invert-l), 1);
+  --bulma-primary-25: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-25-l), 1);
+  --bulma-primary-25-invert-l: var(--bulma-primary-100-l);
+  --bulma-primary-25-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-25-invert-l), 1);
+  --bulma-primary-30: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-30-l), 1);
+  --bulma-primary-30-invert-l: var(--bulma-primary-00-l);
+  --bulma-primary-30-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-30-invert-l), 1);
+  --bulma-primary-35: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-35-l), 1);
+  --bulma-primary-35-invert-l: var(--bulma-primary-00-l);
+  --bulma-primary-35-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-35-invert-l), 1);
+  --bulma-primary-40: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-40-l), 1);
+  --bulma-primary-40-invert-l: var(--bulma-primary-05-l);
+  --bulma-primary-40-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-40-invert-l), 1);
+  --bulma-primary-45: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-45-l), 1);
+  --bulma-primary-45-invert-l: var(--bulma-primary-05-l);
+  --bulma-primary-45-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-45-invert-l), 1);
+  --bulma-primary-50: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-50-l), 1);
+  --bulma-primary-50-invert-l: var(--bulma-primary-10-l);
+  --bulma-primary-50-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-50-invert-l), 1);
+  --bulma-primary-55: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-55-l), 1);
+  --bulma-primary-55-invert-l: var(--bulma-primary-10-l);
+  --bulma-primary-55-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-55-invert-l), 1);
+  --bulma-primary-60: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-60-l), 1);
+  --bulma-primary-60-invert-l: var(--bulma-primary-10-l);
+  --bulma-primary-60-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-60-invert-l), 1);
+  --bulma-primary-65: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-65-l), 1);
+  --bulma-primary-65-invert-l: var(--bulma-primary-10-l);
+  --bulma-primary-65-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-65-invert-l), 1);
+  --bulma-primary-70: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-70-l), 1);
+  --bulma-primary-70-invert-l: var(--bulma-primary-10-l);
+  --bulma-primary-70-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-70-invert-l), 1);
+  --bulma-primary-75: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-75-l), 1);
+  --bulma-primary-75-invert-l: var(--bulma-primary-10-l);
+  --bulma-primary-75-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-75-invert-l), 1);
+  --bulma-primary-80: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-80-l), 1);
+  --bulma-primary-80-invert-l: var(--bulma-primary-10-l);
+  --bulma-primary-80-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-80-invert-l), 1);
+  --bulma-primary-85: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-85-l), 1);
+  --bulma-primary-85-invert-l: var(--bulma-primary-10-l);
+  --bulma-primary-85-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-85-invert-l), 1);
+  --bulma-primary-90: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-90-l), 1);
+  --bulma-primary-90-invert-l: var(--bulma-primary-10-l);
+  --bulma-primary-90-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-90-invert-l), 1);
+  --bulma-primary-95: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-95-l), 1);
+  --bulma-primary-95-invert-l: var(--bulma-primary-10-l);
+  --bulma-primary-95-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-95-invert-l), 1);
+  --bulma-primary-100: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-100-l), 1);
+  --bulma-primary-100-invert-l: var(--bulma-primary-15-l);
+  --bulma-primary-100-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-100-invert-l), 1);
+  --bulma-primary-invert-l: var(--bulma-primary-05-l);
+  --bulma-primary-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-invert-l), 1);
+  --bulma-primary-light-l: var(--bulma-primary-90-l);
+  --bulma-primary-light: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-light-l), 1);
+  --bulma-primary-light-invert-l: var(--bulma-primary-10-l);
+  --bulma-primary-light-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-light-invert-l), 1);
+  --bulma-primary-dark-l: var(--bulma-primary-10-l);
+  --bulma-primary-dark: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-dark-l), 1);
+  --bulma-primary-dark-invert-l: var(--bulma-primary-50-l);
+  --bulma-primary-dark-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-dark-invert-l), 1);
+  --bulma-primary-soft: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-soft-l), 1);
+  --bulma-primary-bold: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-bold-l), 1);
+  --bulma-primary-soft-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-soft-invert-l), 1);
+  --bulma-primary-bold-invert: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-bold-invert-l), 1);
+  --bulma-primary-on-scheme-l: 21%;
+  --bulma-primary-on-scheme: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-on-scheme-l), 1);
+  --bulma-link: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-l), 1);
+  --bulma-link-base: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-l), 1);
+  --bulma-link-rgb: 66, 88, 255;
+  --bulma-link-h: 233deg;
+  --bulma-link-s: 100%;
+  --bulma-link-l: 63%;
+  --bulma-link-00-l: 0%;
+  --bulma-link-05-l: 3%;
+  --bulma-link-10-l: 8%;
+  --bulma-link-15-l: 13%;
+  --bulma-link-20-l: 18%;
+  --bulma-link-25-l: 23%;
+  --bulma-link-30-l: 28%;
+  --bulma-link-35-l: 33%;
+  --bulma-link-40-l: 38%;
+  --bulma-link-45-l: 43%;
+  --bulma-link-50-l: 48%;
+  --bulma-link-55-l: 53%;
+  --bulma-link-60-l: 58%;
+  --bulma-link-65-l: 63%;
+  --bulma-link-70-l: 68%;
+  --bulma-link-75-l: 73%;
+  --bulma-link-80-l: 78%;
+  --bulma-link-85-l: 83%;
+  --bulma-link-90-l: 88%;
+  --bulma-link-95-l: 93%;
+  --bulma-link-100-l: 98%;
+  --bulma-link-00: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-00-l), 1);
+  --bulma-link-00-invert-l: var(--bulma-link-75-l);
+  --bulma-link-00-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-00-invert-l), 1);
+  --bulma-link-05: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-05-l), 1);
+  --bulma-link-05-invert-l: var(--bulma-link-75-l);
+  --bulma-link-05-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-05-invert-l), 1);
+  --bulma-link-10: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-10-l), 1);
+  --bulma-link-10-invert-l: var(--bulma-link-75-l);
+  --bulma-link-10-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-10-invert-l), 1);
+  --bulma-link-15: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-15-l), 1);
+  --bulma-link-15-invert-l: var(--bulma-link-80-l);
+  --bulma-link-15-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-15-invert-l), 1);
+  --bulma-link-20: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-20-l), 1);
+  --bulma-link-20-invert-l: var(--bulma-link-80-l);
+  --bulma-link-20-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-20-invert-l), 1);
+  --bulma-link-25: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-25-l), 1);
+  --bulma-link-25-invert-l: var(--bulma-link-85-l);
+  --bulma-link-25-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-25-invert-l), 1);
+  --bulma-link-30: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-30-l), 1);
+  --bulma-link-30-invert-l: var(--bulma-link-90-l);
+  --bulma-link-30-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-30-invert-l), 1);
+  --bulma-link-35: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-35-l), 1);
+  --bulma-link-35-invert-l: var(--bulma-link-90-l);
+  --bulma-link-35-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-35-invert-l), 1);
+  --bulma-link-40: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-40-l), 1);
+  --bulma-link-40-invert-l: var(--bulma-link-95-l);
+  --bulma-link-40-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-40-invert-l), 1);
+  --bulma-link-45: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-45-l), 1);
+  --bulma-link-45-invert-l: var(--bulma-link-100-l);
+  --bulma-link-45-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-45-invert-l), 1);
+  --bulma-link-50: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-50-l), 1);
+  --bulma-link-50-invert-l: var(--bulma-link-100-l);
+  --bulma-link-50-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-50-invert-l), 1);
+  --bulma-link-55: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-55-l), 1);
+  --bulma-link-55-invert-l: var(--bulma-link-100-l);
+  --bulma-link-55-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-55-invert-l), 1);
+  --bulma-link-60: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-60-l), 1);
+  --bulma-link-60-invert-l: var(--bulma-link-100-l);
+  --bulma-link-60-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-60-invert-l), 1);
+  --bulma-link-65: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-65-l), 1);
+  --bulma-link-65-invert-l: var(--bulma-link-100-l);
+  --bulma-link-65-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-65-invert-l), 1);
+  --bulma-link-70: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-70-l), 1);
+  --bulma-link-70-invert-l: var(--bulma-link-100-l);
+  --bulma-link-70-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-70-invert-l), 1);
+  --bulma-link-75: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-75-l), 1);
+  --bulma-link-75-invert-l: var(--bulma-link-10-l);
+  --bulma-link-75-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-75-invert-l), 1);
+  --bulma-link-80: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-80-l), 1);
+  --bulma-link-80-invert-l: var(--bulma-link-20-l);
+  --bulma-link-80-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-80-invert-l), 1);
+  --bulma-link-85: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-85-l), 1);
+  --bulma-link-85-invert-l: var(--bulma-link-25-l);
+  --bulma-link-85-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-85-invert-l), 1);
+  --bulma-link-90: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-90-l), 1);
+  --bulma-link-90-invert-l: var(--bulma-link-35-l);
+  --bulma-link-90-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-90-invert-l), 1);
+  --bulma-link-95: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-95-l), 1);
+  --bulma-link-95-invert-l: var(--bulma-link-40-l);
+  --bulma-link-95-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-95-invert-l), 1);
+  --bulma-link-100: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-100-l), 1);
+  --bulma-link-100-invert-l: var(--bulma-link-50-l);
+  --bulma-link-100-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-100-invert-l), 1);
+  --bulma-link-invert-l: var(--bulma-link-100-l);
+  --bulma-link-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-invert-l), 1);
+  --bulma-link-light-l: var(--bulma-link-90-l);
+  --bulma-link-light: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-light-l), 1);
+  --bulma-link-light-invert-l: var(--bulma-link-35-l);
+  --bulma-link-light-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-light-invert-l), 1);
+  --bulma-link-dark-l: var(--bulma-link-10-l);
+  --bulma-link-dark: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-dark-l), 1);
+  --bulma-link-dark-invert-l: var(--bulma-link-75-l);
+  --bulma-link-dark-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-dark-invert-l), 1);
+  --bulma-link-soft: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-soft-l), 1);
+  --bulma-link-bold: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-bold-l), 1);
+  --bulma-link-soft-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-soft-invert-l), 1);
+  --bulma-link-bold-invert: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-bold-invert-l), 1);
+  --bulma-link-on-scheme-l: 58%;
+  --bulma-link-on-scheme: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-on-scheme-l), 1);
+  --bulma-info: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-l), 1);
+  --bulma-info-base: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-l), 1);
+  --bulma-info-rgb: 102, 209, 255;
+  --bulma-info-h: 198deg;
+  --bulma-info-s: 100%;
+  --bulma-info-l: 70%;
+  --bulma-info-00-l: 0%;
+  --bulma-info-05-l: 5%;
+  --bulma-info-10-l: 10%;
+  --bulma-info-15-l: 15%;
+  --bulma-info-20-l: 20%;
+  --bulma-info-25-l: 25%;
+  --bulma-info-30-l: 30%;
+  --bulma-info-35-l: 35%;
+  --bulma-info-40-l: 40%;
+  --bulma-info-45-l: 45%;
+  --bulma-info-50-l: 50%;
+  --bulma-info-55-l: 55%;
+  --bulma-info-60-l: 60%;
+  --bulma-info-65-l: 65%;
+  --bulma-info-70-l: 70%;
+  --bulma-info-75-l: 75%;
+  --bulma-info-80-l: 80%;
+  --bulma-info-85-l: 85%;
+  --bulma-info-90-l: 90%;
+  --bulma-info-95-l: 95%;
+  --bulma-info-100-l: 100%;
+  --bulma-info-00: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-00-l), 1);
+  --bulma-info-00-invert-l: var(--bulma-info-45-l);
+  --bulma-info-00-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-00-invert-l), 1);
+  --bulma-info-05: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-05-l), 1);
+  --bulma-info-05-invert-l: var(--bulma-info-50-l);
+  --bulma-info-05-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-05-invert-l), 1);
+  --bulma-info-10: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-10-l), 1);
+  --bulma-info-10-invert-l: var(--bulma-info-60-l);
+  --bulma-info-10-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-10-invert-l), 1);
+  --bulma-info-15: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-15-l), 1);
+  --bulma-info-15-invert-l: var(--bulma-info-80-l);
+  --bulma-info-15-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-15-invert-l), 1);
+  --bulma-info-20: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-20-l), 1);
+  --bulma-info-20-invert-l: var(--bulma-info-95-l);
+  --bulma-info-20-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-20-invert-l), 1);
+  --bulma-info-25: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-25-l), 1);
+  --bulma-info-25-invert-l: var(--bulma-info-100-l);
+  --bulma-info-25-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-25-invert-l), 1);
+  --bulma-info-30: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-30-l), 1);
+  --bulma-info-30-invert-l: var(--bulma-info-100-l);
+  --bulma-info-30-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-30-invert-l), 1);
+  --bulma-info-35: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-35-l), 1);
+  --bulma-info-35-invert-l: var(--bulma-info-100-l);
+  --bulma-info-35-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-35-invert-l), 1);
+  --bulma-info-40: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-40-l), 1);
+  --bulma-info-40-invert-l: var(--bulma-info-100-l);
+  --bulma-info-40-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-40-invert-l), 1);
+  --bulma-info-45: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-45-l), 1);
+  --bulma-info-45-invert-l: var(--bulma-info-00-l);
+  --bulma-info-45-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-45-invert-l), 1);
+  --bulma-info-50: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-50-l), 1);
+  --bulma-info-50-invert-l: var(--bulma-info-05-l);
+  --bulma-info-50-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-50-invert-l), 1);
+  --bulma-info-55: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-55-l), 1);
+  --bulma-info-55-invert-l: var(--bulma-info-05-l);
+  --bulma-info-55-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-55-invert-l), 1);
+  --bulma-info-60: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-60-l), 1);
+  --bulma-info-60-invert-l: var(--bulma-info-10-l);
+  --bulma-info-60-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-60-invert-l), 1);
+  --bulma-info-65: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-65-l), 1);
+  --bulma-info-65-invert-l: var(--bulma-info-10-l);
+  --bulma-info-65-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-65-invert-l), 1);
+  --bulma-info-70: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-70-l), 1);
+  --bulma-info-70-invert-l: var(--bulma-info-10-l);
+  --bulma-info-70-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-70-invert-l), 1);
+  --bulma-info-75: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-75-l), 1);
+  --bulma-info-75-invert-l: var(--bulma-info-10-l);
+  --bulma-info-75-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-75-invert-l), 1);
+  --bulma-info-80: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-80-l), 1);
+  --bulma-info-80-invert-l: var(--bulma-info-15-l);
+  --bulma-info-80-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-80-invert-l), 1);
+  --bulma-info-85: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-85-l), 1);
+  --bulma-info-85-invert-l: var(--bulma-info-15-l);
+  --bulma-info-85-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-85-invert-l), 1);
+  --bulma-info-90: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-90-l), 1);
+  --bulma-info-90-invert-l: var(--bulma-info-15-l);
+  --bulma-info-90-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-90-invert-l), 1);
+  --bulma-info-95: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-95-l), 1);
+  --bulma-info-95-invert-l: var(--bulma-info-20-l);
+  --bulma-info-95-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-95-invert-l), 1);
+  --bulma-info-100: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-100-l), 1);
+  --bulma-info-100-invert-l: var(--bulma-info-20-l);
+  --bulma-info-100-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-100-invert-l), 1);
+  --bulma-info-invert-l: var(--bulma-info-10-l);
+  --bulma-info-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-invert-l), 1);
+  --bulma-info-light-l: var(--bulma-info-90-l);
+  --bulma-info-light: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-light-l), 1);
+  --bulma-info-light-invert-l: var(--bulma-info-15-l);
+  --bulma-info-light-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-light-invert-l), 1);
+  --bulma-info-dark-l: var(--bulma-info-10-l);
+  --bulma-info-dark: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-dark-l), 1);
+  --bulma-info-dark-invert-l: var(--bulma-info-60-l);
+  --bulma-info-dark-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-dark-invert-l), 1);
+  --bulma-info-soft: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-soft-l), 1);
+  --bulma-info-bold: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-bold-l), 1);
+  --bulma-info-soft-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-soft-invert-l), 1);
+  --bulma-info-bold-invert: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-bold-invert-l), 1);
+  --bulma-info-on-scheme-l: 25%;
+  --bulma-info-on-scheme: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-on-scheme-l), 1);
+  --bulma-success: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-l), 1);
+  --bulma-success-base: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-l), 1);
+  --bulma-success-rgb: 72, 199, 142;
+  --bulma-success-h: 153deg;
+  --bulma-success-s: 53%;
+  --bulma-success-l: 53%;
+  --bulma-success-00-l: 0%;
+  --bulma-success-05-l: 3%;
+  --bulma-success-10-l: 8%;
+  --bulma-success-15-l: 13%;
+  --bulma-success-20-l: 18%;
+  --bulma-success-25-l: 23%;
+  --bulma-success-30-l: 28%;
+  --bulma-success-35-l: 33%;
+  --bulma-success-40-l: 38%;
+  --bulma-success-45-l: 43%;
+  --bulma-success-50-l: 48%;
+  --bulma-success-55-l: 53%;
+  --bulma-success-60-l: 58%;
+  --bulma-success-65-l: 63%;
+  --bulma-success-70-l: 68%;
+  --bulma-success-75-l: 73%;
+  --bulma-success-80-l: 78%;
+  --bulma-success-85-l: 83%;
+  --bulma-success-90-l: 88%;
+  --bulma-success-95-l: 93%;
+  --bulma-success-100-l: 98%;
+  --bulma-success-00: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-00-l), 1);
+  --bulma-success-00-invert-l: var(--bulma-success-45-l);
+  --bulma-success-00-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-00-invert-l), 1);
+  --bulma-success-05: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-05-l), 1);
+  --bulma-success-05-invert-l: var(--bulma-success-45-l);
+  --bulma-success-05-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-05-invert-l), 1);
+  --bulma-success-10: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-10-l), 1);
+  --bulma-success-10-invert-l: var(--bulma-success-55-l);
+  --bulma-success-10-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-10-invert-l), 1);
+  --bulma-success-15: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-15-l), 1);
+  --bulma-success-15-invert-l: var(--bulma-success-75-l);
+  --bulma-success-15-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-15-invert-l), 1);
+  --bulma-success-20: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-20-l), 1);
+  --bulma-success-20-invert-l: var(--bulma-success-90-l);
+  --bulma-success-20-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-20-invert-l), 1);
+  --bulma-success-25: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-25-l), 1);
+  --bulma-success-25-invert-l: var(--bulma-success-100-l);
+  --bulma-success-25-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-25-invert-l), 1);
+  --bulma-success-30: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-30-l), 1);
+  --bulma-success-30-invert-l: var(--bulma-success-100-l);
+  --bulma-success-30-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-30-invert-l), 1);
+  --bulma-success-35: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-35-l), 1);
+  --bulma-success-35-invert-l: var(--bulma-success-100-l);
+  --bulma-success-35-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-35-invert-l), 1);
+  --bulma-success-40: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-40-l), 1);
+  --bulma-success-40-invert-l: var(--bulma-success-100-l);
+  --bulma-success-40-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-40-invert-l), 1);
+  --bulma-success-45: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-45-l), 1);
+  --bulma-success-45-invert-l: var(--bulma-success-05-l);
+  --bulma-success-45-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-45-invert-l), 1);
+  --bulma-success-50: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-50-l), 1);
+  --bulma-success-50-invert-l: var(--bulma-success-05-l);
+  --bulma-success-50-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-50-invert-l), 1);
+  --bulma-success-55: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-55-l), 1);
+  --bulma-success-55-invert-l: var(--bulma-success-10-l);
+  --bulma-success-55-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-55-invert-l), 1);
+  --bulma-success-60: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-60-l), 1);
+  --bulma-success-60-invert-l: var(--bulma-success-10-l);
+  --bulma-success-60-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-60-invert-l), 1);
+  --bulma-success-65: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-65-l), 1);
+  --bulma-success-65-invert-l: var(--bulma-success-10-l);
+  --bulma-success-65-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-65-invert-l), 1);
+  --bulma-success-70: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-70-l), 1);
+  --bulma-success-70-invert-l: var(--bulma-success-10-l);
+  --bulma-success-70-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-70-invert-l), 1);
+  --bulma-success-75: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-75-l), 1);
+  --bulma-success-75-invert-l: var(--bulma-success-15-l);
+  --bulma-success-75-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-75-invert-l), 1);
+  --bulma-success-80: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-80-l), 1);
+  --bulma-success-80-invert-l: var(--bulma-success-15-l);
+  --bulma-success-80-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-80-invert-l), 1);
+  --bulma-success-85: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-85-l), 1);
+  --bulma-success-85-invert-l: var(--bulma-success-15-l);
+  --bulma-success-85-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-85-invert-l), 1);
+  --bulma-success-90: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-90-l), 1);
+  --bulma-success-90-invert-l: var(--bulma-success-20-l);
+  --bulma-success-90-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-90-invert-l), 1);
+  --bulma-success-95: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-95-l), 1);
+  --bulma-success-95-invert-l: var(--bulma-success-20-l);
+  --bulma-success-95-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-95-invert-l), 1);
+  --bulma-success-100: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-100-l), 1);
+  --bulma-success-100-invert-l: var(--bulma-success-20-l);
+  --bulma-success-100-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-100-invert-l), 1);
+  --bulma-success-invert-l: var(--bulma-success-10-l);
+  --bulma-success-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-invert-l), 1);
+  --bulma-success-light-l: var(--bulma-success-90-l);
+  --bulma-success-light: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-light-l), 1);
+  --bulma-success-light-invert-l: var(--bulma-success-20-l);
+  --bulma-success-light-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-light-invert-l), 1);
+  --bulma-success-dark-l: var(--bulma-success-10-l);
+  --bulma-success-dark: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-dark-l), 1);
+  --bulma-success-dark-invert-l: var(--bulma-success-55-l);
+  --bulma-success-dark-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-dark-invert-l), 1);
+  --bulma-success-soft: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-soft-l), 1);
+  --bulma-success-bold: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-bold-l), 1);
+  --bulma-success-soft-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-soft-invert-l), 1);
+  --bulma-success-bold-invert: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-bold-invert-l), 1);
+  --bulma-success-on-scheme-l: 23%;
+  --bulma-success-on-scheme: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-on-scheme-l), 1);
+  --bulma-warning: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-l), 1);
+  --bulma-warning-base: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-l), 1);
+  --bulma-warning-rgb: 255, 183, 15;
+  --bulma-warning-h: 42deg;
+  --bulma-warning-s: 100%;
+  --bulma-warning-l: 53%;
+  --bulma-warning-00-l: 0%;
+  --bulma-warning-05-l: 3%;
+  --bulma-warning-10-l: 8%;
+  --bulma-warning-15-l: 13%;
+  --bulma-warning-20-l: 18%;
+  --bulma-warning-25-l: 23%;
+  --bulma-warning-30-l: 28%;
+  --bulma-warning-35-l: 33%;
+  --bulma-warning-40-l: 38%;
+  --bulma-warning-45-l: 43%;
+  --bulma-warning-50-l: 48%;
+  --bulma-warning-55-l: 53%;
+  --bulma-warning-60-l: 58%;
+  --bulma-warning-65-l: 63%;
+  --bulma-warning-70-l: 68%;
+  --bulma-warning-75-l: 73%;
+  --bulma-warning-80-l: 78%;
+  --bulma-warning-85-l: 83%;
+  --bulma-warning-90-l: 88%;
+  --bulma-warning-95-l: 93%;
+  --bulma-warning-100-l: 98%;
+  --bulma-warning-00: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-00-l), 1);
+  --bulma-warning-00-invert-l: var(--bulma-warning-40-l);
+  --bulma-warning-00-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-00-invert-l), 1);
+  --bulma-warning-05: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-05-l), 1);
+  --bulma-warning-05-invert-l: var(--bulma-warning-45-l);
+  --bulma-warning-05-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-05-invert-l), 1);
+  --bulma-warning-10: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-10-l), 1);
+  --bulma-warning-10-invert-l: var(--bulma-warning-50-l);
+  --bulma-warning-10-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-10-invert-l), 1);
+  --bulma-warning-15: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-15-l), 1);
+  --bulma-warning-15-invert-l: var(--bulma-warning-70-l);
+  --bulma-warning-15-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-15-invert-l), 1);
+  --bulma-warning-20: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-20-l), 1);
+  --bulma-warning-20-invert-l: var(--bulma-warning-100-l);
+  --bulma-warning-20-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-20-invert-l), 1);
+  --bulma-warning-25: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-25-l), 1);
+  --bulma-warning-25-invert-l: var(--bulma-warning-100-l);
+  --bulma-warning-25-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-25-invert-l), 1);
+  --bulma-warning-30: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-30-l), 1);
+  --bulma-warning-30-invert-l: var(--bulma-warning-100-l);
+  --bulma-warning-30-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-30-invert-l), 1);
+  --bulma-warning-35: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-35-l), 1);
+  --bulma-warning-35-invert-l: var(--bulma-warning-100-l);
+  --bulma-warning-35-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-35-invert-l), 1);
+  --bulma-warning-40: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-40-l), 1);
+  --bulma-warning-40-invert-l: var(--bulma-warning-00-l);
+  --bulma-warning-40-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-40-invert-l), 1);
+  --bulma-warning-45: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-45-l), 1);
+  --bulma-warning-45-invert-l: var(--bulma-warning-05-l);
+  --bulma-warning-45-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-45-invert-l), 1);
+  --bulma-warning-50: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-50-l), 1);
+  --bulma-warning-50-invert-l: var(--bulma-warning-10-l);
+  --bulma-warning-50-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-50-invert-l), 1);
+  --bulma-warning-55: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-55-l), 1);
+  --bulma-warning-55-invert-l: var(--bulma-warning-10-l);
+  --bulma-warning-55-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-55-invert-l), 1);
+  --bulma-warning-60: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-60-l), 1);
+  --bulma-warning-60-invert-l: var(--bulma-warning-10-l);
+  --bulma-warning-60-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-60-invert-l), 1);
+  --bulma-warning-65: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-65-l), 1);
+  --bulma-warning-65-invert-l: var(--bulma-warning-10-l);
+  --bulma-warning-65-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-65-invert-l), 1);
+  --bulma-warning-70: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-70-l), 1);
+  --bulma-warning-70-invert-l: var(--bulma-warning-15-l);
+  --bulma-warning-70-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-70-invert-l), 1);
+  --bulma-warning-75: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-75-l), 1);
+  --bulma-warning-75-invert-l: var(--bulma-warning-15-l);
+  --bulma-warning-75-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-75-invert-l), 1);
+  --bulma-warning-80: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-80-l), 1);
+  --bulma-warning-80-invert-l: var(--bulma-warning-15-l);
+  --bulma-warning-80-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-80-invert-l), 1);
+  --bulma-warning-85: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-85-l), 1);
+  --bulma-warning-85-invert-l: var(--bulma-warning-15-l);
+  --bulma-warning-85-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-85-invert-l), 1);
+  --bulma-warning-90: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-90-l), 1);
+  --bulma-warning-90-invert-l: var(--bulma-warning-15-l);
+  --bulma-warning-90-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-90-invert-l), 1);
+  --bulma-warning-95: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-95-l), 1);
+  --bulma-warning-95-invert-l: var(--bulma-warning-15-l);
+  --bulma-warning-95-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-95-invert-l), 1);
+  --bulma-warning-100: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-100-l), 1);
+  --bulma-warning-100-invert-l: var(--bulma-warning-20-l);
+  --bulma-warning-100-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-100-invert-l), 1);
+  --bulma-warning-invert-l: var(--bulma-warning-10-l);
+  --bulma-warning-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-invert-l), 1);
+  --bulma-warning-light-l: var(--bulma-warning-90-l);
+  --bulma-warning-light: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-light-l), 1);
+  --bulma-warning-light-invert-l: var(--bulma-warning-15-l);
+  --bulma-warning-light-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-light-invert-l), 1);
+  --bulma-warning-dark-l: var(--bulma-warning-10-l);
+  --bulma-warning-dark: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-dark-l), 1);
+  --bulma-warning-dark-invert-l: var(--bulma-warning-50-l);
+  --bulma-warning-dark-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-dark-invert-l), 1);
+  --bulma-warning-soft: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-soft-l), 1);
+  --bulma-warning-bold: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-bold-l), 1);
+  --bulma-warning-soft-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-soft-invert-l), 1);
+  --bulma-warning-bold-invert: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-bold-invert-l), 1);
+  --bulma-warning-on-scheme-l: 23%;
+  --bulma-warning-on-scheme: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-on-scheme-l), 1);
+  --bulma-danger: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-l), 1);
+  --bulma-danger-base: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-l), 1);
+  --bulma-danger-rgb: 255, 102, 133;
+  --bulma-danger-h: 348deg;
+  --bulma-danger-s: 100%;
+  --bulma-danger-l: 70%;
+  --bulma-danger-00-l: 0%;
+  --bulma-danger-05-l: 5%;
+  --bulma-danger-10-l: 10%;
+  --bulma-danger-15-l: 15%;
+  --bulma-danger-20-l: 20%;
+  --bulma-danger-25-l: 25%;
+  --bulma-danger-30-l: 30%;
+  --bulma-danger-35-l: 35%;
+  --bulma-danger-40-l: 40%;
+  --bulma-danger-45-l: 45%;
+  --bulma-danger-50-l: 50%;
+  --bulma-danger-55-l: 55%;
+  --bulma-danger-60-l: 60%;
+  --bulma-danger-65-l: 65%;
+  --bulma-danger-70-l: 70%;
+  --bulma-danger-75-l: 75%;
+  --bulma-danger-80-l: 80%;
+  --bulma-danger-85-l: 85%;
+  --bulma-danger-90-l: 90%;
+  --bulma-danger-95-l: 95%;
+  --bulma-danger-100-l: 100%;
+  --bulma-danger-00: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-00-l), 1);
+  --bulma-danger-00-invert-l: var(--bulma-danger-65-l);
+  --bulma-danger-00-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-00-invert-l), 1);
+  --bulma-danger-05: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-05-l), 1);
+  --bulma-danger-05-invert-l: var(--bulma-danger-70-l);
+  --bulma-danger-05-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-05-invert-l), 1);
+  --bulma-danger-10: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-10-l), 1);
+  --bulma-danger-10-invert-l: var(--bulma-danger-75-l);
+  --bulma-danger-10-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-10-invert-l), 1);
+  --bulma-danger-15: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-15-l), 1);
+  --bulma-danger-15-invert-l: var(--bulma-danger-80-l);
+  --bulma-danger-15-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-15-invert-l), 1);
+  --bulma-danger-20: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-20-l), 1);
+  --bulma-danger-20-invert-l: var(--bulma-danger-85-l);
+  --bulma-danger-20-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-20-invert-l), 1);
+  --bulma-danger-25: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-25-l), 1);
+  --bulma-danger-25-invert-l: var(--bulma-danger-90-l);
+  --bulma-danger-25-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-25-invert-l), 1);
+  --bulma-danger-30: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-30-l), 1);
+  --bulma-danger-30-invert-l: var(--bulma-danger-100-l);
+  --bulma-danger-30-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-30-invert-l), 1);
+  --bulma-danger-35: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-35-l), 1);
+  --bulma-danger-35-invert-l: var(--bulma-danger-100-l);
+  --bulma-danger-35-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-35-invert-l), 1);
+  --bulma-danger-40: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-40-l), 1);
+  --bulma-danger-40-invert-l: var(--bulma-danger-100-l);
+  --bulma-danger-40-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-40-invert-l), 1);
+  --bulma-danger-45: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-45-l), 1);
+  --bulma-danger-45-invert-l: var(--bulma-danger-100-l);
+  --bulma-danger-45-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-45-invert-l), 1);
+  --bulma-danger-50: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-50-l), 1);
+  --bulma-danger-50-invert-l: var(--bulma-danger-100-l);
+  --bulma-danger-50-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-50-invert-l), 1);
+  --bulma-danger-55: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-55-l), 1);
+  --bulma-danger-55-invert-l: var(--bulma-danger-100-l);
+  --bulma-danger-55-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-55-invert-l), 1);
+  --bulma-danger-60: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-60-l), 1);
+  --bulma-danger-60-invert-l: var(--bulma-danger-100-l);
+  --bulma-danger-60-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-60-invert-l), 1);
+  --bulma-danger-65: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-65-l), 1);
+  --bulma-danger-65-invert-l: var(--bulma-danger-00-l);
+  --bulma-danger-65-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-65-invert-l), 1);
+  --bulma-danger-70: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-70-l), 1);
+  --bulma-danger-70-invert-l: var(--bulma-danger-05-l);
+  --bulma-danger-70-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-70-invert-l), 1);
+  --bulma-danger-75: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-75-l), 1);
+  --bulma-danger-75-invert-l: var(--bulma-danger-10-l);
+  --bulma-danger-75-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-75-invert-l), 1);
+  --bulma-danger-80: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-80-l), 1);
+  --bulma-danger-80-invert-l: var(--bulma-danger-15-l);
+  --bulma-danger-80-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-80-invert-l), 1);
+  --bulma-danger-85: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-85-l), 1);
+  --bulma-danger-85-invert-l: var(--bulma-danger-20-l);
+  --bulma-danger-85-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-85-invert-l), 1);
+  --bulma-danger-90: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-90-l), 1);
+  --bulma-danger-90-invert-l: var(--bulma-danger-25-l);
+  --bulma-danger-90-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-90-invert-l), 1);
+  --bulma-danger-95: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-95-l), 1);
+  --bulma-danger-95-invert-l: var(--bulma-danger-25-l);
+  --bulma-danger-95-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-95-invert-l), 1);
+  --bulma-danger-100: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-100-l), 1);
+  --bulma-danger-100-invert-l: var(--bulma-danger-30-l);
+  --bulma-danger-100-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-100-invert-l), 1);
+  --bulma-danger-invert-l: var(--bulma-danger-05-l);
+  --bulma-danger-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-invert-l), 1);
+  --bulma-danger-light-l: var(--bulma-danger-90-l);
+  --bulma-danger-light: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-light-l), 1);
+  --bulma-danger-light-invert-l: var(--bulma-danger-25-l);
+  --bulma-danger-light-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-light-invert-l), 1);
+  --bulma-danger-dark-l: var(--bulma-danger-10-l);
+  --bulma-danger-dark: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-dark-l), 1);
+  --bulma-danger-dark-invert-l: var(--bulma-danger-75-l);
+  --bulma-danger-dark-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-dark-invert-l), 1);
+  --bulma-danger-soft: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-soft-l), 1);
+  --bulma-danger-bold: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-bold-l), 1);
+  --bulma-danger-soft-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-soft-invert-l), 1);
+  --bulma-danger-bold-invert: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-bold-invert-l), 1);
+  --bulma-danger-on-scheme-l: 40%;
+  --bulma-danger-on-scheme: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-on-scheme-l), 1);
+  --bulma-black-bis: hsl(221, 14%, 9%);
+  --bulma-black-ter: hsl(221, 14%, 14%);
+  --bulma-grey-darker: hsl(221, 14%, 21%);
+  --bulma-grey-dark: hsl(221, 14%, 29%);
+  --bulma-grey: hsl(221, 14%, 48%);
+  --bulma-grey-light: hsl(221, 14%, 71%);
+  --bulma-grey-lighter: hsl(221, 14%, 86%);
+  --bulma-white-ter: hsl(221, 14%, 96%);
+  --bulma-white-bis: hsl(221, 14%, 98%);
+  --bulma-shadow-h: 221deg;
+  --bulma-shadow-s: 14%;
+  --bulma-shadow-l: 4%;
+  --bulma-size-1: 3rem;
+  --bulma-size-2: 2.5rem;
+  --bulma-size-3: 2rem;
+  --bulma-size-4: 1.5rem;
+  --bulma-size-5: 1.25rem;
+  --bulma-size-6: 1rem;
+  --bulma-size-7: 0.75rem;
+  --bulma-scheme-main: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-scheme-main-l));
+  --bulma-scheme-main-bis: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-scheme-main-bis-l));
+  --bulma-scheme-main-ter: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-scheme-main-ter-l));
+  --bulma-background: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-background-l));
+  --bulma-background-hover: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), calc(var(--bulma-background-l) + var(--bulma-hover-background-l-delta)));
+  --bulma-background-active: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), calc(var(--bulma-background-l) + var(--bulma-active-background-l-delta)));
+  --bulma-border-weak: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-border-weak-l));
+  --bulma-border: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-border-l));
+  --bulma-border-hover: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), calc(var(--bulma-border-l) + var(--bulma-hover-border-l-delta)));
+  --bulma-border-active: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), calc(var(--bulma-border-l) + var(--bulma-active-border-l-delta)));
+  --bulma-text-weak: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-weak-l));
+  --bulma-text: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-l));
+  --bulma-text-strong: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-strong-l));
+  --bulma-scheme-invert-ter: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-scheme-invert-ter-l));
+  --bulma-scheme-invert-bis: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-scheme-invert-bis-l));
+  --bulma-scheme-invert: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-scheme-invert-l));
+  --bulma-link: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-l));
+  --bulma-link-text: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-on-scheme-l));
+  --bulma-link-text-hover: hsl(var(--bulma-link-h), var(--bulma-link-s), calc(var(--bulma-link-on-scheme-l) + var(--bulma-hover-color-l-delta)));
+  --bulma-link-text-active: hsl(var(--bulma-link-h), var(--bulma-link-s), calc(var(--bulma-link-on-scheme-l) + var(--bulma-active-color-l-delta)));
+  --bulma-focus-h: var(--bulma-link-h);
+  --bulma-focus-s: var(--bulma-link-s);
+  --bulma-focus-l: var(--bulma-link-l);
+  --bulma-focus-offset: 1px;
+  --bulma-focus-style: solid;
+  --bulma-focus-width: 2px;
+  --bulma-focus-shadow-size: 0 0 0 0.1875em;
+  --bulma-focus-shadow-alpha: 0.25;
+  --bulma-code: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-on-scheme-l));
+  --bulma-code-background: var(--bulma-background);
+  --bulma-pre: var(--bulma-text);
+  --bulma-pre-background: var(--bulma-background);
+  --bulma-shadow: 0 0.5em 1em -0.125em hsla(var(--bulma-shadow-h), var(--bulma-shadow-s), var(--bulma-shadow-l), 0.1), 0 0px 0 1px hsla(var(--bulma-shadow-h), var(--bulma-shadow-s), var(--bulma-shadow-l), 0.02);
+}
+
+[data-theme=dark],
+.theme-dark {
+  --bulma-white-on-scheme-l: 100%;
+  --bulma-white-on-scheme: hsla(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-on-scheme-l), 1);
+  --bulma-black-on-scheme-l: 0%;
+  --bulma-black-on-scheme: hsla(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-on-scheme-l), 1);
+  --bulma-light-on-scheme-l: 96%;
+  --bulma-light-on-scheme: hsla(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-on-scheme-l), 1);
+  --bulma-dark-on-scheme-l: 56%;
+  --bulma-dark-on-scheme: hsla(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-on-scheme-l), 1);
+  --bulma-text-on-scheme-l: 54%;
+  --bulma-text-on-scheme: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-on-scheme-l), 1);
+  --bulma-primary-on-scheme-l: 41%;
+  --bulma-primary-on-scheme: hsla(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-on-scheme-l), 1);
+  --bulma-link-on-scheme-l: 73%;
+  --bulma-link-on-scheme: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-on-scheme-l), 1);
+  --bulma-info-on-scheme-l: 70%;
+  --bulma-info-on-scheme: hsla(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-on-scheme-l), 1);
+  --bulma-success-on-scheme-l: 53%;
+  --bulma-success-on-scheme: hsla(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-on-scheme-l), 1);
+  --bulma-warning-on-scheme-l: 53%;
+  --bulma-warning-on-scheme: hsla(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-on-scheme-l), 1);
+  --bulma-danger-on-scheme-l: 70%;
+  --bulma-danger-on-scheme: hsla(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-on-scheme-l), 1);
+  --bulma-scheme-brightness: dark;
+  --bulma-scheme-main-l: 9%;
+  --bulma-scheme-main-bis-l: 11%;
+  --bulma-scheme-main-ter-l: 13%;
+  --bulma-soft-l: 20%;
+  --bulma-bold-l: 90%;
+  --bulma-soft-invert-l: 90%;
+  --bulma-bold-invert-l: 20%;
+  --bulma-background-l: 14%;
+  --bulma-border-weak-l: 21%;
+  --bulma-border-l: 24%;
+  --bulma-text-weak-l: 53%;
+  --bulma-text-l: 71%;
+  --bulma-text-strong-l: 93%;
+  --bulma-text-title-l: 100%;
+  --bulma-hover-background-l-delta: 5%;
+  --bulma-active-background-l-delta: 10%;
+  --bulma-hover-border-l-delta: 10%;
+  --bulma-active-border-l-delta: 20%;
+  --bulma-hover-color-l-delta: 5%;
+  --bulma-active-color-l-delta: 10%;
+  --bulma-shadow-h: 0deg;
+  --bulma-shadow-s: 0%;
+  --bulma-shadow-l: 100%;
+  --bulma-scheme-main: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-scheme-main-l));
+  --bulma-scheme-main-bis: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-scheme-main-bis-l));
+  --bulma-scheme-main-ter: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-scheme-main-ter-l));
+  --bulma-background: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-background-l));
+  --bulma-background-hover: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), calc(var(--bulma-background-l) + var(--bulma-hover-background-l-delta)));
+  --bulma-background-active: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), calc(var(--bulma-background-l) + var(--bulma-active-background-l-delta)));
+  --bulma-border-weak: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-border-weak-l));
+  --bulma-border: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-border-l));
+  --bulma-border-hover: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), calc(var(--bulma-border-l) + var(--bulma-hover-border-l-delta)));
+  --bulma-border-active: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), calc(var(--bulma-border-l) + var(--bulma-active-border-l-delta)));
+  --bulma-text-weak: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-weak-l));
+  --bulma-text: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-l));
+  --bulma-text-strong: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-strong-l));
+  --bulma-scheme-invert-ter: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-scheme-invert-ter-l));
+  --bulma-scheme-invert-bis: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-scheme-invert-bis-l));
+  --bulma-scheme-invert: hsl(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-scheme-invert-l));
+  --bulma-link: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-l));
+  --bulma-link-text: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-on-scheme-l));
+  --bulma-link-text-hover: hsl(var(--bulma-link-h), var(--bulma-link-s), calc(var(--bulma-link-on-scheme-l) + var(--bulma-hover-color-l-delta)));
+  --bulma-link-text-active: hsl(var(--bulma-link-h), var(--bulma-link-s), calc(var(--bulma-link-on-scheme-l) + var(--bulma-active-color-l-delta)));
+  --bulma-focus-h: var(--bulma-link-h);
+  --bulma-focus-s: var(--bulma-link-s);
+  --bulma-focus-l: var(--bulma-link-l);
+  --bulma-focus-offset: 1px;
+  --bulma-focus-style: solid;
+  --bulma-focus-width: 2px;
+  --bulma-focus-shadow-size: 0 0 0 0.1875em;
+  --bulma-focus-shadow-alpha: 0.25;
+  --bulma-code: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-on-scheme-l));
+  --bulma-code-background: var(--bulma-background);
+  --bulma-pre: var(--bulma-text);
+  --bulma-pre-background: var(--bulma-background);
+  --bulma-shadow: 0 0.5em 1em -0.125em hsla(var(--bulma-shadow-h), var(--bulma-shadow-s), var(--bulma-shadow-l), 0.1), 0 0px 0 1px hsla(var(--bulma-shadow-h), var(--bulma-shadow-s), var(--bulma-shadow-l), 0.02);
+}
+
+/* Bulma Base */
+/*! minireset.css v0.0.6 | MIT License | github.com/jgthms/minireset.css */
+html,
+body,
+p,
+ol,
+ul,
+li,
+dl,
+dt,
+dd,
+blockquote,
+figure,
+fieldset,
+legend,
+textarea,
+pre,
+iframe,
+hr,
+h1,
+h2,
+h3,
+h4,
+h5,
+h6 {
+  margin: 0;
+  padding: 0;
+}
+
+h1,
+h2,
+h3,
+h4,
+h5,
+h6 {
+  font-size: 100%;
+  font-weight: normal;
+}
+
+ul {
+  list-style: none;
+}
+
+button,
+input,
+select,
+textarea {
+  margin: 0;
+}
+
+html {
+  box-sizing: border-box;
+}
+
+*, *::before, *::after {
+  box-sizing: inherit;
+}
+
+img,
+video {
+  height: auto;
+  max-width: 100%;
+}
+
+iframe {
+  border: 0;
+}
+
+table {
+  border-collapse: collapse;
+  border-spacing: 0;
+}
+
+td,
+th {
+  padding: 0;
+}
+td:not([align]),
+th:not([align]) {
+  text-align: inherit;
+}
+
+:root {
+  --bulma-body-background-color: var(--bulma-scheme-main);
+  --bulma-body-size: 1em;
+  --bulma-body-min-width: 300px;
+  --bulma-body-rendering: optimizeLegibility;
+  --bulma-body-family: var(--bulma-family-primary);
+  --bulma-body-overflow-x: hidden;
+  --bulma-body-overflow-y: scroll;
+  --bulma-body-color: var(--bulma-text);
+  --bulma-body-font-size: 1em;
+  --bulma-body-weight: var(--bulma-weight-normal);
+  --bulma-body-line-height: 1.5;
+  --bulma-code-family: var(--bulma-family-code);
+  --bulma-code-padding: 0.25em 0.5em 0.25em;
+  --bulma-code-weight: normal;
+  --bulma-code-size: 0.875em;
+  --bulma-small-font-size: 0.875em;
+  --bulma-hr-background-color: var(--bulma-background);
+  --bulma-hr-height: 2px;
+  --bulma-hr-margin: 1.5rem 0;
+  --bulma-strong-color: var(--bulma-text-strong);
+  --bulma-strong-weight: var(--bulma-weight-semibold);
+  --bulma-pre-font-size: 0.875em;
+  --bulma-pre-padding: 1.25rem 1.5rem;
+  --bulma-pre-code-font-size: 1em;
+}
+
+html {
+  background-color: var(--bulma-body-background-color);
+  font-size: var(--bulma-body-size);
+  -moz-osx-font-smoothing: grayscale;
+  -webkit-font-smoothing: antialiased;
+  min-width: var(--bulma-body-min-width);
+  overflow-x: var(--bulma-body-overflow-x);
+  overflow-y: var(--bulma-body-overflow-y);
+  text-rendering: var(--bulma-body-rendering);
+  text-size-adjust: 100%;
+}
+
+article,
+aside,
+figure,
+footer,
+header,
+hgroup,
+section {
+  display: block;
+}
+
+body,
+button,
+input,
+optgroup,
+select,
+textarea {
+  font-family: var(--bulma-body-family);
+}
+
+code,
+pre {
+  -moz-osx-font-smoothing: auto;
+  -webkit-font-smoothing: auto;
+  font-family: var(--bulma-code-family);
+}
+
+body {
+  color: var(--bulma-body-color);
+  font-size: var(--bulma-body-font-size);
+  font-weight: var(--bulma-body-weight);
+  line-height: var(--bulma-body-line-height);
+}
+
+a,
+button {
+  cursor: pointer;
+}
+a:focus-visible,
+button:focus-visible {
+  outline-color: hsl(var(--bulma-focus-h), var(--bulma-focus-s), var(--bulma-focus-l));
+  outline-offset: var(--bulma-focus-offset);
+  outline-style: var(--bulma-focus-style);
+  outline-width: var(--bulma-focus-width);
+}
+a:focus-visible:active,
+button:focus-visible:active {
+  outline-width: 1px;
+}
+a:active,
+button:active {
+  outline-width: 1px;
+}
+
+a {
+  color: var(--bulma-link-text);
+  cursor: pointer;
+  text-decoration: none;
+  transition-duration: var(--bulma-duration);
+  transition-property: background-color, border-color, color;
+}
+a strong {
+  color: currentColor;
+}
+
+button {
+  appearance: none;
+  background: none;
+  border: none;
+  color: inherit;
+  font-family: inherit;
+  font-size: 1em;
+  margin: 0;
+  padding: 0;
+  transition-duration: var(--bulma-duration);
+  transition-property: background-color, border-color, color;
+}
+
+code {
+  background-color: var(--bulma-code-background);
+  border-radius: 0.5em;
+  color: var(--bulma-code);
+  font-size: var(--bulma-code-size);
+  font-weight: var(--bulma-code-weight);
+  padding: var(--bulma-code-padding);
+}
+
+hr {
+  background-color: var(--bulma-hr-background-color);
+  border: none;
+  display: block;
+  height: var(--bulma-hr-height);
+  margin: var(--bulma-hr-margin);
+}
+
+img {
+  height: auto;
+  max-width: 100%;
+}
+
+input[type=checkbox],
+input[type=radio] {
+  vertical-align: baseline;
+}
+
+small {
+  font-size: var(--bulma-small-font-size);
+}
+
+span {
+  font-style: inherit;
+  font-weight: inherit;
+}
+
+strong {
+  color: var(--bulma-strong-color);
+  font-weight: var(--bulma-strong-weight);
+}
+
+svg {
+  height: auto;
+  width: auto;
+}
+
+fieldset {
+  border: none;
+}
+
+pre {
+  -webkit-overflow-scrolling: touch;
+  background-color: var(--bulma-pre-background);
+  color: var(--bulma-pre);
+  font-size: var(--bulma-pre-font-size);
+  overflow-x: auto;
+  padding: var(--bulma-pre-padding);
+  white-space: pre;
+  word-wrap: normal;
+}
+pre code {
+  background-color: transparent;
+  color: currentColor;
+  font-size: var(--bulma-pre-code-font-size);
+  padding: 0;
+}
+
+table td,
+table th {
+  vertical-align: top;
+}
+table td:not([align]),
+table th:not([align]) {
+  text-align: inherit;
+}
+table th {
+  color: var(--bulma-text-strong);
+}
+
+@keyframes spinAround {
+  from {
+    transform: rotate(0deg);
+  }
+  to {
+    transform: rotate(359deg);
+  }
+}
+@keyframes pulsate {
+  50% {
+    opacity: 0.5;
+  }
+}
+/* Bulma Elements */
+.navbar-link:not(.is-arrowless)::after, .select:not(.is-multiple):not(.is-loading)::after {
+  border: 0.125em solid var(--bulma-arrow-color);
+  border-right: 0;
+  border-top: 0;
+  content: " ";
+  display: block;
+  height: 0.625em;
+  margin-top: -0.4375em;
+  pointer-events: none;
+  position: absolute;
+  top: 50%;
+  transform: rotate(-45deg);
+  transform-origin: center;
+  transition-duration: var(--bulma-duration);
+  transition-property: border-color;
+  width: 0.625em;
+}
+
+.skeleton-block:not(:last-child), .media:not(:last-child), .level:not(:last-child), .fixed-grid:not(:last-child), .grid:not(:last-child), .tabs:not(:last-child), .pagination:not(:last-child), .message:not(:last-child), .card:not(:last-child), .breadcrumb:not(:last-child), .field:not(:last-child), .file:not(:last-child), .title:not(:last-child),
+.subtitle:not(:last-child), .tags:not(:last-child), .table:not(:last-child), .table-container:not(:last-child), .progress:not(:last-child), .notification:not(:last-child), .content:not(:last-child), .buttons:not(:last-child), .box:not(:last-child), .block:not(:last-child) {
+  margin-bottom: var(--bulma-block-spacing);
+}
+
+.pagination-previous,
+.pagination-next,
+.pagination-link,
+.pagination-ellipsis, .file-cta,
+.file-name, .select select, .input, .textarea, .button {
+  align-items: center;
+  appearance: none;
+  border-color: transparent;
+  border-style: solid;
+  border-width: var(--bulma-control-border-width);
+  border-radius: var(--bulma-control-radius);
+  box-shadow: none;
+  display: inline-flex;
+  font-size: var(--bulma-control-size);
+  height: var(--bulma-control-height);
+  justify-content: flex-start;
+  line-height: var(--bulma-control-line-height);
+  padding-bottom: var(--bulma-control-padding-vertical);
+  padding-left: var(--bulma-control-padding-horizontal);
+  padding-right: var(--bulma-control-padding-horizontal);
+  padding-top: var(--bulma-control-padding-vertical);
+  position: relative;
+  transition-duration: var(--bulma-duration);
+  transition-property: background-color, border-color, box-shadow, color;
+  vertical-align: top;
+}
+.pagination-previous:focus,
+.pagination-next:focus,
+.pagination-link:focus,
+.pagination-ellipsis:focus, .file-cta:focus,
+.file-name:focus, .select select:focus, .input:focus, .textarea:focus, .button:focus, .pagination-previous:focus-visible,
+.pagination-next:focus-visible,
+.pagination-link:focus-visible,
+.pagination-ellipsis:focus-visible, .file-cta:focus-visible,
+.file-name:focus-visible, .select select:focus-visible, .input:focus-visible, .textarea:focus-visible, .button:focus-visible, .pagination-previous:focus-within,
+.pagination-next:focus-within,
+.pagination-link:focus-within,
+.pagination-ellipsis:focus-within, .file-cta:focus-within,
+.file-name:focus-within, .select select:focus-within, .input:focus-within, .textarea:focus-within, .button:focus-within, .is-focused.pagination-previous,
+.is-focused.pagination-next,
+.is-focused.pagination-link,
+.is-focused.pagination-ellipsis, .is-focused.file-cta,
+.is-focused.file-name, .select select.is-focused, .is-focused.input, .is-focused.textarea, .is-focused.button, .pagination-previous:active,
+.pagination-next:active,
+.pagination-link:active,
+.pagination-ellipsis:active, .file-cta:active,
+.file-name:active, .select select:active, .input:active, .textarea:active, .button:active, .is-active.pagination-previous,
+.is-active.pagination-next,
+.is-active.pagination-link,
+.is-active.pagination-ellipsis, .is-active.file-cta,
+.is-active.file-name, .select select.is-active, .is-active.input, .is-active.textarea, .is-active.button {
+  outline: none;
+}
+[disabled].pagination-previous,
+[disabled].pagination-next,
+[disabled].pagination-link,
+[disabled].pagination-ellipsis, [disabled].file-cta,
+[disabled].file-name, .select select[disabled], [disabled].input, [disabled].textarea, [disabled].button, fieldset[disabled] .pagination-previous,
+fieldset[disabled] .pagination-next,
+fieldset[disabled] .pagination-link,
+fieldset[disabled] .pagination-ellipsis, fieldset[disabled] .file-cta,
+fieldset[disabled] .file-name, fieldset[disabled] .select select, .select fieldset[disabled] select, fieldset[disabled] .input, fieldset[disabled] .textarea, fieldset[disabled] .button {
+  cursor: not-allowed;
+}
+
+.modal-close {
+  --bulma-delete-dimensions: 1.25rem;
+  --bulma-delete-background-l: 0%;
+  --bulma-delete-background-alpha: 0.5;
+  --bulma-delete-color: var(--bulma-white);
+  appearance: none;
+  background-color: hsla(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-delete-background-l), var(--bulma-delete-background-alpha));
+  border: none;
+  border-radius: var(--bulma-radius-rounded);
+  cursor: pointer;
+  pointer-events: auto;
+  display: inline-flex;
+  flex-grow: 0;
+  flex-shrink: 0;
+  font-size: 1em;
+  height: var(--bulma-delete-dimensions);
+  max-height: var(--bulma-delete-dimensions);
+  max-width: var(--bulma-delete-dimensions);
+  min-height: var(--bulma-delete-dimensions);
+  min-width: var(--bulma-delete-dimensions);
+  outline: none;
+  position: relative;
+  vertical-align: top;
+  width: var(--bulma-delete-dimensions);
+}
+.modal-close::before, .modal-close::after {
+  background-color: var(--bulma-delete-color);
+  content: "";
+  display: block;
+  left: 50%;
+  position: absolute;
+  top: 50%;
+  transform: translateX(-50%) translateY(-50%) rotate(45deg);
+  transform-origin: center center;
+}
+.modal-close::before {
+  height: 2px;
+  width: 50%;
+}
+.modal-close::after {
+  height: 50%;
+  width: 2px;
+}
+.modal-close:hover, .modal-close:focus {
+  --bulma-delete-background-alpha: 0.4;
+}
+.modal-close:active {
+  --bulma-delete-background-alpha: 0.5;
+}
+.is-small.modal-close {
+  --bulma-delete-dimensions: 1rem;
+}
+.is-medium.modal-close {
+  --bulma-delete-dimensions: 1.5rem;
+}
+.is-large.modal-close {
+  --bulma-delete-dimensions: 2rem;
+}
+
+.control.is-loading::after, .select.is-loading::after, .button.is-loading::after {
+  animation: spinAround 500ms infinite linear;
+  border: 2px solid var(--bulma-loading-color);
+  border-radius: var(--bulma-radius-rounded);
+  border-right-color: transparent;
+  border-top-color: transparent;
+  content: "";
+  display: block;
+  height: 1em;
+  position: relative;
+  width: 1em;
+}
+
+.is-overlay, .hero-video, .modal, .modal-background {
+  bottom: 0;
+  left: 0;
+  position: absolute;
+  right: 0;
+  top: 0;
+}
+
+.navbar-burger, .menu-list a,
+.menu-list button,
+.menu-list .menu-item {
+  appearance: none;
+  background: none;
+  border: none;
+  color: inherit;
+  font-family: inherit;
+  font-size: 1em;
+  margin: 0;
+  padding: 0;
+}
+
+.is-unselectable, .tabs, .pagination-previous,
+.pagination-next,
+.pagination-link,
+.pagination-ellipsis, .breadcrumb, .file, .button {
+  -webkit-touch-callout: none;
+  -webkit-user-select: none;
+  -moz-user-select: none;
+  -ms-user-select: none;
+  user-select: none;
+}
+
+.box {
+  --bulma-box-background-color: var(--bulma-scheme-main);
+  --bulma-box-color: var(--bulma-text);
+  --bulma-box-radius: var(--bulma-radius-large);
+  --bulma-box-shadow: var(--bulma-shadow);
+  --bulma-box-padding: 1.25rem;
+  --bulma-box-link-hover-shadow: 0 0.5em 1em -0.125em hsla(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-scheme-invert-l), 0.1), 0 0 0 1px var(--bulma-link);
+  --bulma-box-link-active-shadow: inset 0 1px 2px hsla(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-scheme-invert-l), 0.2), 0 0 0 1px var(--bulma-link);
+}
+
+.box {
+  background-color: var(--bulma-box-background-color);
+  border-radius: var(--bulma-box-radius);
+  box-shadow: var(--bulma-box-shadow);
+  color: var(--bulma-box-color);
+  display: block;
+  padding: var(--bulma-box-padding);
+}
+
+a.box:hover, a.box:focus {
+  box-shadow: var(--bulma-box-link-hover-shadow);
+}
+a.box:active {
+  box-shadow: var(--bulma-box-link-active-shadow);
+}
+
+.button {
+  --bulma-button-family: false;
+  --bulma-button-weight: var(--bulma-weight-medium);
+  --bulma-button-border-color: var(--bulma-border);
+  --bulma-button-border-style: solid;
+  --bulma-button-border-width: var(--bulma-control-border-width);
+  --bulma-button-padding-vertical: 0.5em;
+  --bulma-button-padding-horizontal: 1em;
+  --bulma-button-focus-border-color: var(--bulma-link-focus-border);
+  --bulma-button-focus-box-shadow-size: 0 0 0 0.125em;
+  --bulma-button-focus-box-shadow-color: hsla(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-on-scheme-l), 0.25);
+  --bulma-button-active-color: var(--bulma-link-active);
+  --bulma-button-active-border-color: var(--bulma-link-active-border);
+  --bulma-button-text-color: var(--bulma-text);
+  --bulma-button-text-decoration: underline;
+  --bulma-button-text-hover-background-color: var(--bulma-background);
+  --bulma-button-text-hover-color: var(--bulma-text-strong);
+  --bulma-button-ghost-background: none;
+  --bulma-button-ghost-border-color: transparent;
+  --bulma-button-ghost-color: var(--bulma-link-text);
+  --bulma-button-ghost-decoration: none;
+  --bulma-button-ghost-hover-color: var(--bulma-link);
+  --bulma-button-ghost-hover-decoration: underline;
+  --bulma-button-disabled-background-color: var(--bulma-scheme-main);
+  --bulma-button-disabled-border-color: var(--bulma-border);
+  --bulma-button-disabled-shadow: none;
+  --bulma-button-disabled-opacity: 0.5;
+  --bulma-button-static-color: var(--bulma-text-weak);
+  --bulma-button-static-background-color: var(--bulma-scheme-main-ter);
+  --bulma-button-static-border-color: var(--bulma-border);
+}
+
+.button {
+  --bulma-button-h: var(--bulma-scheme-h);
+  --bulma-button-s: var(--bulma-scheme-s);
+  --bulma-button-l: var(--bulma-scheme-main-l);
+  --bulma-button-background-l: var(--bulma-scheme-main-l);
+  --bulma-button-background-l-delta: 0%;
+  --bulma-button-hover-background-l-delta: var(--bulma-hover-background-l-delta);
+  --bulma-button-active-background-l-delta: var(--bulma-active-background-l-delta);
+  --bulma-button-color-l: var(--bulma-text-strong-l);
+  --bulma-button-border-l: var(--bulma-border-l);
+  --bulma-button-border-l-delta: 0%;
+  --bulma-button-hover-border-l-delta: var(--bulma-hover-border-l-delta);
+  --bulma-button-active-border-l-delta: var(--bulma-active-border-l-delta);
+  --bulma-button-focus-border-l-delta: var(--bulma-focus-border-l-delta);
+  --bulma-button-outer-shadow-h: 0;
+  --bulma-button-outer-shadow-s: 0%;
+  --bulma-button-outer-shadow-l: 20%;
+  --bulma-button-outer-shadow-a: 0.05;
+  --bulma-loading-color: hsl(var(--bulma-button-h), var(--bulma-button-s), var(--bulma-button-color-l));
+  background-color: hsl(var(--bulma-button-h), var(--bulma-button-s), calc(var(--bulma-button-background-l) + var(--bulma-button-background-l-delta)));
+  border-color: hsl(var(--bulma-button-h), var(--bulma-button-s), calc(var(--bulma-button-border-l) + var(--bulma-button-border-l-delta)));
+  border-style: var(--bulma-button-border-style);
+  border-width: var(--bulma-button-border-width);
+  box-shadow: 0px 0.0625em 0.125em hsla(var(--bulma-button-outer-shadow-h), var(--bulma-button-outer-shadow-s), var(--bulma-button-outer-shadow-l), var(--bulma-button-outer-shadow-a)), 0px 0.125em 0.25em hsla(var(--bulma-button-outer-shadow-h), var(--bulma-button-outer-shadow-s), var(--bulma-button-outer-shadow-l), var(--bulma-button-outer-shadow-a));
+  color: hsl(var(--bulma-button-h), var(--bulma-button-s), var(--bulma-button-color-l));
+  cursor: pointer;
+  font-weight: var(--bulma-button-weight);
+  height: auto;
+  justify-content: center;
+  padding-bottom: calc(var(--bulma-button-padding-vertical) - var(--bulma-button-border-width));
+  padding-left: calc(var(--bulma-button-padding-horizontal) - var(--bulma-button-border-width));
+  padding-right: calc(var(--bulma-button-padding-horizontal) - var(--bulma-button-border-width));
+  padding-top: calc(var(--bulma-button-padding-vertical) - var(--bulma-button-border-width));
+  text-align: center;
+  white-space: nowrap;
+}
+.button strong {
+  color: inherit;
+}
+.button .icon, .button .icon.is-small, .button .icon.is-medium, .button .icon.is-large {
+  height: 1.5em;
+  width: 1.5em;
+}
+.button .icon:first-child:not(:last-child) {
+  margin-inline-start: calc(-0.5 * var(--bulma-button-padding-horizontal));
+  margin-inline-end: calc(var(--bulma-button-padding-horizontal) * 0.25);
+}
+.button .icon:last-child:not(:first-child) {
+  margin-inline-start: calc(var(--bulma-button-padding-horizontal) * 0.25);
+  margin-inline-end: calc(-0.5 * var(--bulma-button-padding-horizontal));
+}
+.button .icon:first-child:last-child {
+  margin-inline-start: calc(-0.5 * var(--bulma-button-padding-horizontal));
+  margin-inline-end: calc(-0.5 * var(--bulma-button-padding-horizontal));
+}
+.button:hover, .button.is-hovered {
+  --bulma-button-background-l-delta: var(--bulma-button-hover-background-l-delta);
+  --bulma-button-border-l-delta: var(--bulma-button-hover-border-l-delta);
+}
+.button:focus-visible, .button.is-focused {
+  --bulma-button-border-width: 1px;
+  border-color: hsl(var(--bulma-focus-h), var(--bulma-focus-s), var(--bulma-focus-l));
+  box-shadow: var(--bulma-focus-shadow-size) hsla(var(--bulma-focus-h), var(--bulma-focus-s), var(--bulma-focus-l), var(--bulma-focus-shadow-alpha));
+}
+.button:active, .button.is-active {
+  --bulma-button-background-l-delta: var(--bulma-button-active-background-l-delta);
+  --bulma-button-border-l-delta: var(--bulma-button-active-border-l-delta);
+  --bulma-button-outer-shadow-a: 0;
+}
+.button[disabled], fieldset[disabled] .button {
+  background-color: var(--bulma-button-disabled-background-color);
+  border-color: var(--bulma-button-disabled-border-color);
+  box-shadow: var(--bulma-button-disabled-shadow);
+  opacity: var(--bulma-button-disabled-opacity);
+}
+.button.is-white {
+  --bulma-button-h: var(--bulma-white-h);
+  --bulma-button-s: var(--bulma-white-s);
+  --bulma-button-l: var(--bulma-white-l);
+  --bulma-button-background-l: var(--bulma-white-l);
+  --bulma-button-border-l: var(--bulma-white-l);
+  --bulma-button-border-width: 0px;
+  --bulma-button-color-l: var(--bulma-white-invert-l);
+  --bulma-button-outer-shadow-a: 0;
+}
+.button.is-white:focus-visible, .button.is-white.is-focused {
+  --bulma-button-border-width: 1px;
+}
+.button.is-white.is-soft {
+  --bulma-button-background-l: var(--bulma-soft-l);
+  --bulma-button-color-l: var(--bulma-soft-invert-l);
+}
+.button.is-white.is-bold {
+  --bulma-button-background-l: var(--bulma-bold-l);
+  --bulma-button-color-l: var(--bulma-bold-invert-l);
+}
+.button.is-white[disabled], fieldset[disabled] .button.is-white {
+  background-color: var(--bulma-white);
+  border-color: var(--bulma-white);
+  box-shadow: none;
+}
+.button.is-black {
+  --bulma-button-h: var(--bulma-black-h);
+  --bulma-button-s: var(--bulma-black-s);
+  --bulma-button-l: var(--bulma-black-l);
+  --bulma-button-background-l: var(--bulma-black-l);
+  --bulma-button-border-l: var(--bulma-black-l);
+  --bulma-button-border-width: 0px;
+  --bulma-button-color-l: var(--bulma-black-invert-l);
+  --bulma-button-outer-shadow-a: 0;
+}
+.button.is-black:focus-visible, .button.is-black.is-focused {
+  --bulma-button-border-width: 1px;
+}
+.button.is-black.is-soft {
+  --bulma-button-background-l: var(--bulma-soft-l);
+  --bulma-button-color-l: var(--bulma-soft-invert-l);
+}
+.button.is-black.is-bold {
+  --bulma-button-background-l: var(--bulma-bold-l);
+  --bulma-button-color-l: var(--bulma-bold-invert-l);
+}
+.button.is-black[disabled], fieldset[disabled] .button.is-black {
+  background-color: var(--bulma-black);
+  border-color: var(--bulma-black);
+  box-shadow: none;
+}
+.button.is-light {
+  --bulma-button-h: var(--bulma-light-h);
+  --bulma-button-s: var(--bulma-light-s);
+  --bulma-button-l: var(--bulma-light-l);
+  --bulma-button-background-l: var(--bulma-light-l);
+  --bulma-button-border-l: var(--bulma-light-l);
+  --bulma-button-border-width: 0px;
+  --bulma-button-color-l: var(--bulma-light-invert-l);
+  --bulma-button-outer-shadow-a: 0;
+}
+.button.is-light:focus-visible, .button.is-light.is-focused {
+  --bulma-button-border-width: 1px;
+}
+.button.is-light.is-soft {
+  --bulma-button-background-l: var(--bulma-soft-l);
+  --bulma-button-color-l: var(--bulma-soft-invert-l);
+}
+.button.is-light.is-bold {
+  --bulma-button-background-l: var(--bulma-bold-l);
+  --bulma-button-color-l: var(--bulma-bold-invert-l);
+}
+.button.is-light[disabled], fieldset[disabled] .button.is-light {
+  background-color: var(--bulma-light);
+  border-color: var(--bulma-light);
+  box-shadow: none;
+}
+.button.is-dark {
+  --bulma-button-h: var(--bulma-dark-h);
+  --bulma-button-s: var(--bulma-dark-s);
+  --bulma-button-l: var(--bulma-dark-l);
+  --bulma-button-background-l: var(--bulma-dark-l);
+  --bulma-button-border-l: var(--bulma-dark-l);
+  --bulma-button-border-width: 0px;
+  --bulma-button-color-l: var(--bulma-dark-invert-l);
+  --bulma-button-outer-shadow-a: 0;
+}
+.button.is-dark:focus-visible, .button.is-dark.is-focused {
+  --bulma-button-border-width: 1px;
+}
+.button.is-dark.is-soft {
+  --bulma-button-background-l: var(--bulma-soft-l);
+  --bulma-button-color-l: var(--bulma-soft-invert-l);
+}
+.button.is-dark.is-bold {
+  --bulma-button-background-l: var(--bulma-bold-l);
+  --bulma-button-color-l: var(--bulma-bold-invert-l);
+}
+.button.is-dark[disabled], fieldset[disabled] .button.is-dark {
+  background-color: var(--bulma-dark);
+  border-color: var(--bulma-dark);
+  box-shadow: none;
+}
+.button.is-text {
+  --bulma-button-h: var(--bulma-text-h);
+  --bulma-button-s: var(--bulma-text-s);
+  --bulma-button-l: var(--bulma-text-l);
+  --bulma-button-background-l: var(--bulma-text-l);
+  --bulma-button-border-l: var(--bulma-text-l);
+  --bulma-button-border-width: 0px;
+  --bulma-button-color-l: var(--bulma-text-invert-l);
+  --bulma-button-outer-shadow-a: 0;
+}
+.button.is-text:focus-visible, .button.is-text.is-focused {
+  --bulma-button-border-width: 1px;
+}
+.button.is-text.is-light {
+  --bulma-button-background-l: var(--bulma-light-l);
+  --bulma-button-color-l: var(--bulma-text-light-invert-l);
+}
+.button.is-text.is-dark {
+  --bulma-button-background-l: var(--bulma-dark-l);
+  --bulma-button-color-l: var(--bulma-text-dark-invert-l);
+}
+.button.is-text.is-soft {
+  --bulma-button-background-l: var(--bulma-soft-l);
+  --bulma-button-color-l: var(--bulma-soft-invert-l);
+}
+.button.is-text.is-bold {
+  --bulma-button-background-l: var(--bulma-bold-l);
+  --bulma-button-color-l: var(--bulma-bold-invert-l);
+}
+.button.is-text[disabled], fieldset[disabled] .button.is-text {
+  background-color: var(--bulma-text);
+  border-color: var(--bulma-text);
+  box-shadow: none;
+}
+.button.is-primary {
+  --bulma-button-h: var(--bulma-primary-h);
+  --bulma-button-s: var(--bulma-primary-s);
+  --bulma-button-l: var(--bulma-primary-l);
+  --bulma-button-background-l: var(--bulma-primary-l);
+  --bulma-button-border-l: var(--bulma-primary-l);
+  --bulma-button-border-width: 0px;
+  --bulma-button-color-l: var(--bulma-primary-invert-l);
+  --bulma-button-outer-shadow-a: 0;
+}
+.button.is-primary:focus-visible, .button.is-primary.is-focused {
+  --bulma-button-border-width: 1px;
+}
+.button.is-primary.is-light {
+  --bulma-button-background-l: var(--bulma-light-l);
+  --bulma-button-color-l: var(--bulma-primary-light-invert-l);
+}
+.button.is-primary.is-dark {
+  --bulma-button-background-l: var(--bulma-dark-l);
+  --bulma-button-color-l: var(--bulma-primary-dark-invert-l);
+}
+.button.is-primary.is-soft {
+  --bulma-button-background-l: var(--bulma-soft-l);
+  --bulma-button-color-l: var(--bulma-soft-invert-l);
+}
+.button.is-primary.is-bold {
+  --bulma-button-background-l: var(--bulma-bold-l);
+  --bulma-button-color-l: var(--bulma-bold-invert-l);
+}
+.button.is-primary[disabled], fieldset[disabled] .button.is-primary {
+  background-color: var(--bulma-primary);
+  border-color: var(--bulma-primary);
+  box-shadow: none;
+}
+.button.is-link {
+  --bulma-button-h: var(--bulma-link-h);
+  --bulma-button-s: var(--bulma-link-s);
+  --bulma-button-l: var(--bulma-link-l);
+  --bulma-button-background-l: var(--bulma-link-l);
+  --bulma-button-border-l: var(--bulma-link-l);
+  --bulma-button-border-width: 0px;
+  --bulma-button-color-l: var(--bulma-link-invert-l);
+  --bulma-button-outer-shadow-a: 0;
+}
+.button.is-link:focus-visible, .button.is-link.is-focused {
+  --bulma-button-border-width: 1px;
+}
+.button.is-link.is-light {
+  --bulma-button-background-l: var(--bulma-light-l);
+  --bulma-button-color-l: var(--bulma-link-light-invert-l);
+}
+.button.is-link.is-dark {
+  --bulma-button-background-l: var(--bulma-dark-l);
+  --bulma-button-color-l: var(--bulma-link-dark-invert-l);
+}
+.button.is-link.is-soft {
+  --bulma-button-background-l: var(--bulma-soft-l);
+  --bulma-button-color-l: var(--bulma-soft-invert-l);
+}
+.button.is-link.is-bold {
+  --bulma-button-background-l: var(--bulma-bold-l);
+  --bulma-button-color-l: var(--bulma-bold-invert-l);
+}
+.button.is-link[disabled], fieldset[disabled] .button.is-link {
+  background-color: var(--bulma-link);
+  border-color: var(--bulma-link);
+  box-shadow: none;
+}
+.button.is-info {
+  --bulma-button-h: var(--bulma-info-h);
+  --bulma-button-s: var(--bulma-info-s);
+  --bulma-button-l: var(--bulma-info-l);
+  --bulma-button-background-l: var(--bulma-info-l);
+  --bulma-button-border-l: var(--bulma-info-l);
+  --bulma-button-border-width: 0px;
+  --bulma-button-color-l: var(--bulma-info-invert-l);
+  --bulma-button-outer-shadow-a: 0;
+}
+.button.is-info:focus-visible, .button.is-info.is-focused {
+  --bulma-button-border-width: 1px;
+}
+.button.is-info.is-light {
+  --bulma-button-background-l: var(--bulma-light-l);
+  --bulma-button-color-l: var(--bulma-info-light-invert-l);
+}
+.button.is-info.is-dark {
+  --bulma-button-background-l: var(--bulma-dark-l);
+  --bulma-button-color-l: var(--bulma-info-dark-invert-l);
+}
+.button.is-info.is-soft {
+  --bulma-button-background-l: var(--bulma-soft-l);
+  --bulma-button-color-l: var(--bulma-soft-invert-l);
+}
+.button.is-info.is-bold {
+  --bulma-button-background-l: var(--bulma-bold-l);
+  --bulma-button-color-l: var(--bulma-bold-invert-l);
+}
+.button.is-info[disabled], fieldset[disabled] .button.is-info {
+  background-color: var(--bulma-info);
+  border-color: var(--bulma-info);
+  box-shadow: none;
+}
+.button.is-success {
+  --bulma-button-h: var(--bulma-success-h);
+  --bulma-button-s: var(--bulma-success-s);
+  --bulma-button-l: var(--bulma-success-l);
+  --bulma-button-background-l: var(--bulma-success-l);
+  --bulma-button-border-l: var(--bulma-success-l);
+  --bulma-button-border-width: 0px;
+  --bulma-button-color-l: var(--bulma-success-invert-l);
+  --bulma-button-outer-shadow-a: 0;
+}
+.button.is-success:focus-visible, .button.is-success.is-focused {
+  --bulma-button-border-width: 1px;
+}
+.button.is-success.is-light {
+  --bulma-button-background-l: var(--bulma-light-l);
+  --bulma-button-color-l: var(--bulma-success-light-invert-l);
+}
+.button.is-success.is-dark {
+  --bulma-button-background-l: var(--bulma-dark-l);
+  --bulma-button-color-l: var(--bulma-success-dark-invert-l);
+}
+.button.is-success.is-soft {
+  --bulma-button-background-l: var(--bulma-soft-l);
+  --bulma-button-color-l: var(--bulma-soft-invert-l);
+}
+.button.is-success.is-bold {
+  --bulma-button-background-l: var(--bulma-bold-l);
+  --bulma-button-color-l: var(--bulma-bold-invert-l);
+}
+.button.is-success[disabled], fieldset[disabled] .button.is-success {
+  background-color: var(--bulma-success);
+  border-color: var(--bulma-success);
+  box-shadow: none;
+}
+.button.is-warning {
+  --bulma-button-h: var(--bulma-warning-h);
+  --bulma-button-s: var(--bulma-warning-s);
+  --bulma-button-l: var(--bulma-warning-l);
+  --bulma-button-background-l: var(--bulma-warning-l);
+  --bulma-button-border-l: var(--bulma-warning-l);
+  --bulma-button-border-width: 0px;
+  --bulma-button-color-l: var(--bulma-warning-invert-l);
+  --bulma-button-outer-shadow-a: 0;
+}
+.button.is-warning:focus-visible, .button.is-warning.is-focused {
+  --bulma-button-border-width: 1px;
+}
+.button.is-warning.is-light {
+  --bulma-button-background-l: var(--bulma-light-l);
+  --bulma-button-color-l: var(--bulma-warning-light-invert-l);
+}
+.button.is-warning.is-dark {
+  --bulma-button-background-l: var(--bulma-dark-l);
+  --bulma-button-color-l: var(--bulma-warning-dark-invert-l);
+}
+.button.is-warning.is-soft {
+  --bulma-button-background-l: var(--bulma-soft-l);
+  --bulma-button-color-l: var(--bulma-soft-invert-l);
+}
+.button.is-warning.is-bold {
+  --bulma-button-background-l: var(--bulma-bold-l);
+  --bulma-button-color-l: var(--bulma-bold-invert-l);
+}
+.button.is-warning[disabled], fieldset[disabled] .button.is-warning {
+  background-color: var(--bulma-warning);
+  border-color: var(--bulma-warning);
+  box-shadow: none;
+}
+.button.is-danger {
+  --bulma-button-h: var(--bulma-danger-h);
+  --bulma-button-s: var(--bulma-danger-s);
+  --bulma-button-l: var(--bulma-danger-l);
+  --bulma-button-background-l: var(--bulma-danger-l);
+  --bulma-button-border-l: var(--bulma-danger-l);
+  --bulma-button-border-width: 0px;
+  --bulma-button-color-l: var(--bulma-danger-invert-l);
+  --bulma-button-outer-shadow-a: 0;
+}
+.button.is-danger:focus-visible, .button.is-danger.is-focused {
+  --bulma-button-border-width: 1px;
+}
+.button.is-danger.is-light {
+  --bulma-button-background-l: var(--bulma-light-l);
+  --bulma-button-color-l: var(--bulma-danger-light-invert-l);
+}
+.button.is-danger.is-dark {
+  --bulma-button-background-l: var(--bulma-dark-l);
+  --bulma-button-color-l: var(--bulma-danger-dark-invert-l);
+}
+.button.is-danger.is-soft {
+  --bulma-button-background-l: var(--bulma-soft-l);
+  --bulma-button-color-l: var(--bulma-soft-invert-l);
+}
+.button.is-danger.is-bold {
+  --bulma-button-background-l: var(--bulma-bold-l);
+  --bulma-button-color-l: var(--bulma-bold-invert-l);
+}
+.button.is-danger[disabled], fieldset[disabled] .button.is-danger {
+  background-color: var(--bulma-danger);
+  border-color: var(--bulma-danger);
+  box-shadow: none;
+}
+.button.is-outlined {
+  --bulma-button-border-width: max(1px, 0.0625em);
+  background-color: transparent;
+  border-color: hsl(var(--bulma-button-h), var(--bulma-button-s), var(--bulma-button-l));
+  color: hsl(var(--bulma-button-h), var(--bulma-button-s), var(--bulma-button-l));
+}
+.button.is-outlined:hover {
+  --bulma-button-border-width: max(2px, 0.125em);
+  --bulma-button-outer-shadow-alpha: 1;
+}
+.button.is-inverted {
+  background-color: hsl(var(--bulma-button-h), var(--bulma-button-s), calc(var(--bulma-button-color-l) + var(--bulma-button-background-l-delta)));
+  color: hsl(var(--bulma-button-h), var(--bulma-button-s), var(--bulma-button-background-l));
+}
+.button.is-text {
+  background-color: transparent;
+  border-color: transparent;
+  color: var(--bulma-button-text-color);
+  text-decoration: var(--bulma-button-text-decoration);
+}
+.button.is-text:hover, .button.is-text.is-hovered {
+  background-color: var(--bulma-button-text-hover-background-color);
+  color: var(--bulma-button-text-hover-color);
+}
+.button.is-text:active, .button.is-text.is-active {
+  color: var(--bulma-button-text-hover-color);
+}
+.button.is-text[disabled], fieldset[disabled] .button.is-text {
+  background-color: transparent;
+  border-color: transparent;
+  box-shadow: none;
+}
+.button.is-ghost {
+  background: var(--bulma-button-ghost-background);
+  border-color: var(--bulma-button-ghost-border-color);
+  box-shadow: none;
+  color: var(--bulma-button-ghost-color);
+  text-decoration: var(--bulma-button-ghost-decoration);
+}
+.button.is-ghost:hover, .button.is-ghost.is-hovered {
+  color: var(--bulma-button-ghost-hover-color);
+  text-decoration: var(--bulma-button-ghost-hover-decoration);
+}
+.button.is-small {
+  --bulma-control-size: var(--bulma-size-small);
+  --bulma-control-radius: var(--bulma-radius-small);
+}
+.button.is-normal {
+  --bulma-control-size: var(--bulma-size-normal);
+  --bulma-control-radius: var(--bulma-radius);
+}
+.button.is-medium {
+  --bulma-control-size: var(--bulma-size-medium);
+  --bulma-control-radius: var(--bulma-radius-medium);
+}
+.button.is-large {
+  --bulma-control-size: var(--bulma-size-large);
+  --bulma-control-radius: var(--bulma-radius-medium);
+}
+.button.is-fullwidth {
+  display: flex;
+  width: 100%;
+}
+.button.is-loading {
+  box-shadow: none;
+  color: transparent !important;
+  pointer-events: none;
+}
+.button.is-loading::after {
+  position: absolute;
+  left: calc(50% - 1em * 0.5);
+  top: calc(50% - 1em * 0.5);
+  position: absolute !important;
+}
+.button.is-static {
+  background-color: var(--bulma-button-static-background-color);
+  border-color: var(--bulma-button-static-border-color);
+  color: var(--bulma-button-static-color);
+  box-shadow: none;
+  pointer-events: none;
+}
+.button.is-rounded {
+  border-radius: var(--bulma-radius-rounded);
+  padding-left: calc(var(--bulma-button-padding-horizontal) + 0.25em - var(--bulma-button-border-width));
+  padding-right: calc(var(--bulma-button-padding-horizontal) + 0.25em - var(--bulma-button-border-width));
+}
+
+.buttons {
+  align-items: center;
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.75rem;
+  justify-content: flex-start;
+}
+.buttons.are-small {
+  --bulma-control-size: var(--bulma-size-small);
+  --bulma-control-radius: var(--bulma-radius-small);
+}
+.buttons.are-medium {
+  --bulma-control-size: var(--bulma-size-medium);
+  --bulma-control-radius: var(--bulma-radius-medium);
+}
+.buttons.are-large {
+  --bulma-control-size: var(--bulma-size-large);
+  --bulma-control-radius: var(--bulma-radius-large);
+}
+.buttons.has-addons {
+  gap: 0;
+}
+.buttons.has-addons .button:not(:first-child) {
+  border-end-start-radius: 0;
+  border-start-start-radius: 0;
+}
+.buttons.has-addons .button:not(:last-child) {
+  border-end-end-radius: 0;
+  border-start-end-radius: 0;
+  margin-inline-end: -1px;
+}
+.buttons.has-addons .button:hover, .buttons.has-addons .button.is-hovered {
+  z-index: 2;
+}
+.buttons.has-addons .button:focus, .buttons.has-addons .button.is-focused, .buttons.has-addons .button:active, .buttons.has-addons .button.is-active, .buttons.has-addons .button.is-selected {
+  z-index: 3;
+}
+.buttons.has-addons .button:focus:hover, .buttons.has-addons .button.is-focused:hover, .buttons.has-addons .button:active:hover, .buttons.has-addons .button.is-active:hover, .buttons.has-addons .button.is-selected:hover {
+  z-index: 4;
+}
+.buttons.has-addons .button.is-expanded {
+  flex-grow: 1;
+  flex-shrink: 1;
+}
+.buttons.is-centered {
+  justify-content: center;
+}
+.buttons.is-right {
+  justify-content: flex-end;
+}
+
+@media screen and (max-width: 768px) {
+  .button.is-responsive.is-small {
+    font-size: calc(var(--bulma-size-small) * 0.75);
+  }
+  .button.is-responsive,
+  .button.is-responsive.is-normal {
+    font-size: calc(var(--bulma-size-small) * 0.875);
+  }
+  .button.is-responsive.is-medium {
+    font-size: var(--bulma-size-small);
+  }
+  .button.is-responsive.is-large {
+    font-size: var(--bulma-size-normal);
+  }
+}
+@media screen and (min-width: 769px) and (max-width: 1023px) {
+  .button.is-responsive.is-small {
+    font-size: calc(var(--bulma-size-small) * 0.875);
+  }
+  .button.is-responsive,
+  .button.is-responsive.is-normal {
+    font-size: var(--bulma-size-small);
+  }
+  .button.is-responsive.is-medium {
+    font-size: var(--bulma-size-normal);
+  }
+  .button.is-responsive.is-large {
+    font-size: var(--bulma-size-medium);
+  }
+}
+.content {
+  --bulma-content-heading-color: var(--bulma-text-strong);
+  --bulma-content-heading-weight: var(--bulma-weight-extrabold);
+  --bulma-content-heading-line-height: 1.125;
+  --bulma-content-block-margin-bottom: 1em;
+  --bulma-content-blockquote-background-color: var(--bulma-background);
+  --bulma-content-blockquote-border-left: 5px solid var(--bulma-border);
+  --bulma-content-blockquote-padding: 1.25em 1.5em;
+  --bulma-content-pre-padding: 1.25em 1.5em;
+  --bulma-content-table-cell-border: 1px solid var(--bulma-border);
+  --bulma-content-table-cell-border-width: 0 0 1px;
+  --bulma-content-table-cell-padding: 0.5em 0.75em;
+  --bulma-content-table-cell-heading-color: var(--bulma-text-strong);
+  --bulma-content-table-head-cell-border-width: 0 0 2px;
+  --bulma-content-table-head-cell-color: var(--bulma-text-strong);
+  --bulma-content-table-body-last-row-cell-border-bottom-width: 0;
+  --bulma-content-table-foot-cell-border-width: 2px 0 0;
+  --bulma-content-table-foot-cell-color: var(--bulma-text-strong);
+}
+
+.content li + li {
+  margin-top: 0.25em;
+}
+.content p:not(:last-child),
+.content dl:not(:last-child),
+.content ol:not(:last-child),
+.content ul:not(:last-child),
+.content blockquote:not(:last-child),
+.content pre:not(:last-child),
+.content table:not(:last-child) {
+  margin-bottom: var(--bulma-content-block-margin-bottom);
+}
+.content h1,
+.content h2,
+.content h3,
+.content h4,
+.content h5,
+.content h6 {
+  color: var(--bulma-content-heading-color);
+  font-weight: var(--bulma-content-heading-weight);
+  line-height: var(--bulma-content-heading-line-height);
+}
+.content h1 {
+  font-size: 2em;
+  margin-bottom: 0.5em;
+}
+.content h1:not(:first-child) {
+  margin-top: 1em;
+}
+.content h2 {
+  font-size: 1.75em;
+  margin-bottom: 0.5714em;
+}
+.content h2:not(:first-child) {
+  margin-top: 1.1428em;
+}
+.content h3 {
+  font-size: 1.5em;
+  margin-bottom: 0.6666em;
+}
+.content h3:not(:first-child) {
+  margin-top: 1.3333em;
+}
+.content h4 {
+  font-size: 1.25em;
+  margin-bottom: 0.8em;
+}
+.content h5 {
+  font-size: 1.125em;
+  margin-bottom: 0.8888em;
+}
+.content h6 {
+  font-size: 1em;
+  margin-bottom: 1em;
+}
+.content blockquote {
+  background-color: var(--bulma-content-blockquote-background-color);
+  border-inline-start: var(--bulma-content-blockquote-border-left);
+  padding: var(--bulma-content-blockquote-padding);
+}
+.content ol {
+  list-style-position: outside;
+  margin-inline-start: 2em;
+}
+.content ol:not(:first-child) {
+  margin-top: 1em;
+}
+.content ol:not([type]) {
+  list-style-type: decimal;
+}
+.content ol:not([type]).is-lower-alpha {
+  list-style-type: lower-alpha;
+}
+.content ol:not([type]).is-lower-roman {
+  list-style-type: lower-roman;
+}
+.content ol:not([type]).is-upper-alpha {
+  list-style-type: upper-alpha;
+}
+.content ol:not([type]).is-upper-roman {
+  list-style-type: upper-roman;
+}
+.content ul {
+  list-style: disc outside;
+  margin-inline-start: 2em;
+}
+.content ul:not(:first-child) {
+  margin-top: 1em;
+}
+.content ul ul {
+  list-style-type: circle;
+  margin-bottom: 0.25em;
+  margin-top: 0.25em;
+}
+.content ul ul ul {
+  list-style-type: square;
+}
+.content dd {
+  margin-inline-start: 2em;
+}
+.content figure:not([class]) {
+  margin-left: 2em;
+  margin-right: 2em;
+  text-align: center;
+}
+.content figure:not([class]):not(:first-child) {
+  margin-top: 2em;
+}
+.content figure:not([class]):not(:last-child) {
+  margin-bottom: 2em;
+}
+.content figure:not([class]) img {
+  display: inline-block;
+}
+.content figure:not([class]) figcaption {
+  font-style: italic;
+}
+.content pre {
+  -webkit-overflow-scrolling: touch;
+  overflow-x: auto;
+  padding: var(--bulma-content-pre-padding);
+  white-space: pre;
+  word-wrap: normal;
+}
+.content sup,
+.content sub {
+  font-size: 75%;
+}
+.content table td,
+.content table th {
+  border: var(--bulma-content-table-cell-border);
+  border-width: var(--bulma-content-table-cell-border-width);
+  padding: var(--bulma-content-table-cell-padding);
+  vertical-align: top;
+}
+.content table th {
+  color: var(--bulma-content-table-cell-heading-color);
+}
+.content table th:not([align]) {
+  text-align: inherit;
+}
+.content table thead td,
+.content table thead th {
+  border-width: var(--bulma-content-table-head-cell-border-width);
+  color: var(--bulma-content-table-head-cell-color);
+}
+.content table tfoot td,
+.content table tfoot th {
+  border-width: var(--bulma-content-table-foot-cell-border-width);
+  color: var(--bulma-content-table-foot-cell-color);
+}
+.content table tbody tr:last-child td,
+.content table tbody tr:last-child th {
+  border-bottom-width: var(--bulma-content-table-body-last-row-cell-border-bottom-width);
+}
+.content .tabs li + li {
+  margin-top: 0;
+}
+.content.is-small {
+  font-size: var(--bulma-size-small);
+}
+.content.is-normal {
+  font-size: var(--bulma-size-normal);
+}
+.content.is-medium {
+  font-size: var(--bulma-size-medium);
+}
+.content.is-large {
+  font-size: var(--bulma-size-large);
+}
+
+.delete {
+  --bulma-delete-dimensions: 1.25rem;
+  --bulma-delete-background-l: 0%;
+  --bulma-delete-background-alpha: 0.5;
+  --bulma-delete-color: var(--bulma-white);
+  appearance: none;
+  background-color: hsla(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-delete-background-l), var(--bulma-delete-background-alpha));
+  border: none;
+  border-radius: var(--bulma-radius-rounded);
+  cursor: pointer;
+  pointer-events: auto;
+  display: inline-flex;
+  flex-grow: 0;
+  flex-shrink: 0;
+  font-size: 1em;
+  height: var(--bulma-delete-dimensions);
+  max-height: var(--bulma-delete-dimensions);
+  max-width: var(--bulma-delete-dimensions);
+  min-height: var(--bulma-delete-dimensions);
+  min-width: var(--bulma-delete-dimensions);
+  outline: none;
+  position: relative;
+  vertical-align: top;
+  width: var(--bulma-delete-dimensions);
+}
+.delete::before, .delete::after {
+  background-color: var(--bulma-delete-color);
+  content: "";
+  display: block;
+  left: 50%;
+  position: absolute;
+  top: 50%;
+  transform: translateX(-50%) translateY(-50%) rotate(45deg);
+  transform-origin: center center;
+}
+.delete::before {
+  height: 2px;
+  width: 50%;
+}
+.delete::after {
+  height: 50%;
+  width: 2px;
+}
+.delete:hover, .delete:focus {
+  --bulma-delete-background-alpha: 0.4;
+}
+.delete:active {
+  --bulma-delete-background-alpha: 0.5;
+}
+.delete.is-small {
+  --bulma-delete-dimensions: 1rem;
+}
+.delete.is-medium {
+  --bulma-delete-dimensions: 1.5rem;
+}
+.delete.is-large {
+  --bulma-delete-dimensions: 2rem;
+}
+
+.icon,
+.icon-text {
+  --bulma-icon-dimensions: 1.5rem;
+  --bulma-icon-dimensions-small: 1rem;
+  --bulma-icon-dimensions-medium: 2rem;
+  --bulma-icon-dimensions-large: 3rem;
+  --bulma-icon-text-spacing: 0.25em;
+}
+
+.icon {
+  align-items: center;
+  display: inline-flex;
+  flex-shrink: 0;
+  justify-content: center;
+  height: var(--bulma-icon-dimensions);
+  transition-duration: var(--bulma-duration);
+  transition-property: color;
+  width: var(--bulma-icon-dimensions);
+}
+.icon.is-small {
+  height: var(--bulma-icon-dimensions-small);
+  width: var(--bulma-icon-dimensions-small);
+}
+.icon.is-medium {
+  height: var(--bulma-icon-dimensions-medium);
+  width: var(--bulma-icon-dimensions-medium);
+}
+.icon.is-large {
+  height: var(--bulma-icon-dimensions-large);
+  width: var(--bulma-icon-dimensions-large);
+}
+
+.icon-text {
+  align-items: flex-start;
+  color: inherit;
+  display: inline-flex;
+  flex-wrap: wrap;
+  gap: var(--bulma-icon-text-spacing);
+  line-height: var(--bulma-icon-dimensions);
+  vertical-align: top;
+}
+.icon-text .icon {
+  flex-grow: 0;
+  flex-shrink: 0;
+}
+
+div.icon-text {
+  display: flex;
+}
+
+.image {
+  display: block;
+  position: relative;
+}
+.image img {
+  display: block;
+  height: auto;
+  width: 100%;
+}
+.image img.is-rounded {
+  border-radius: var(--bulma-radius-rounded);
+}
+.image.is-fullwidth {
+  width: 100%;
+}
+.image.is-square img,
+.image.is-square .has-ratio {
+  bottom: 0;
+  left: 0;
+  position: absolute;
+  right: 0;
+  top: 0;
+  height: 100%;
+  width: 100%;
+}
+.image.is-square {
+  aspect-ratio: 1;
+}
+.image.is-1by1 {
+  aspect-ratio: 1/1;
+}
+.image.is-1by1 img,
+.image.is-1by1 .has-ratio {
+  bottom: 0;
+  left: 0;
+  position: absolute;
+  right: 0;
+  top: 0;
+  height: 100%;
+  width: 100%;
+}
+.image.is-5by4 {
+  aspect-ratio: 5/4;
+}
+.image.is-5by4 img,
+.image.is-5by4 .has-ratio {
+  bottom: 0;
+  left: 0;
+  position: absolute;
+  right: 0;
+  top: 0;
+  height: 100%;
+  width: 100%;
+}
+.image.is-4by3 {
+  aspect-ratio: 4/3;
+}
+.image.is-4by3 img,
+.image.is-4by3 .has-ratio {
+  bottom: 0;
+  left: 0;
+  position: absolute;
+  right: 0;
+  top: 0;
+  height: 100%;
+  width: 100%;
+}
+.image.is-3by2 {
+  aspect-ratio: 3/2;
+}
+.image.is-3by2 img,
+.image.is-3by2 .has-ratio {
+  bottom: 0;
+  left: 0;
+  position: absolute;
+  right: 0;
+  top: 0;
+  height: 100%;
+  width: 100%;
+}
+.image.is-5by3 {
+  aspect-ratio: 5/3;
+}
+.image.is-5by3 img,
+.image.is-5by3 .has-ratio {
+  bottom: 0;
+  left: 0;
+  position: absolute;
+  right: 0;
+  top: 0;
+  height: 100%;
+  width: 100%;
+}
+.image.is-16by9 {
+  aspect-ratio: 16/9;
+}
+.image.is-16by9 img,
+.image.is-16by9 .has-ratio {
+  bottom: 0;
+  left: 0;
+  position: absolute;
+  right: 0;
+  top: 0;
+  height: 100%;
+  width: 100%;
+}
+.image.is-2by1 {
+  aspect-ratio: 2/1;
+}
+.image.is-2by1 img,
+.image.is-2by1 .has-ratio {
+  bottom: 0;
+  left: 0;
+  position: absolute;
+  right: 0;
+  top: 0;
+  height: 100%;
+  width: 100%;
+}
+.image.is-3by1 {
+  aspect-ratio: 3/1;
+}
+.image.is-3by1 img,
+.image.is-3by1 .has-ratio {
+  bottom: 0;
+  left: 0;
+  position: absolute;
+  right: 0;
+  top: 0;
+  height: 100%;
+  width: 100%;
+}
+.image.is-4by5 {
+  aspect-ratio: 4/5;
+}
+.image.is-4by5 img,
+.image.is-4by5 .has-ratio {
+  bottom: 0;
+  left: 0;
+  position: absolute;
+  right: 0;
+  top: 0;
+  height: 100%;
+  width: 100%;
+}
+.image.is-3by4 {
+  aspect-ratio: 3/4;
+}
+.image.is-3by4 img,
+.image.is-3by4 .has-ratio {
+  bottom: 0;
+  left: 0;
+  position: absolute;
+  right: 0;
+  top: 0;
+  height: 100%;
+  width: 100%;
+}
+.image.is-2by3 {
+  aspect-ratio: 2/3;
+}
+.image.is-2by3 img,
+.image.is-2by3 .has-ratio {
+  bottom: 0;
+  left: 0;
+  position: absolute;
+  right: 0;
+  top: 0;
+  height: 100%;
+  width: 100%;
+}
+.image.is-3by5 {
+  aspect-ratio: 3/5;
+}
+.image.is-3by5 img,
+.image.is-3by5 .has-ratio {
+  bottom: 0;
+  left: 0;
+  position: absolute;
+  right: 0;
+  top: 0;
+  height: 100%;
+  width: 100%;
+}
+.image.is-9by16 {
+  aspect-ratio: 9/16;
+}
+.image.is-9by16 img,
+.image.is-9by16 .has-ratio {
+  bottom: 0;
+  left: 0;
+  position: absolute;
+  right: 0;
+  top: 0;
+  height: 100%;
+  width: 100%;
+}
+.image.is-1by2 {
+  aspect-ratio: 1/2;
+}
+.image.is-1by2 img,
+.image.is-1by2 .has-ratio {
+  bottom: 0;
+  left: 0;
+  position: absolute;
+  right: 0;
+  top: 0;
+  height: 100%;
+  width: 100%;
+}
+.image.is-1by3 {
+  aspect-ratio: 1/3;
+}
+.image.is-1by3 img,
+.image.is-1by3 .has-ratio {
+  bottom: 0;
+  left: 0;
+  position: absolute;
+  right: 0;
+  top: 0;
+  height: 100%;
+  width: 100%;
+}
+.image.is-16x16 {
+  height: 16px;
+  width: 16px;
+}
+.image.is-24x24 {
+  height: 24px;
+  width: 24px;
+}
+.image.is-32x32 {
+  height: 32px;
+  width: 32px;
+}
+.image.is-48x48 {
+  height: 48px;
+  width: 48px;
+}
+.image.is-64x64 {
+  height: 64px;
+  width: 64px;
+}
+.image.is-96x96 {
+  height: 96px;
+  width: 96px;
+}
+.image.is-128x128 {
+  height: 128px;
+  width: 128px;
+}
+
+.loader {
+  animation: spinAround 500ms infinite linear;
+  border: 2px solid var(--bulma-border);
+  border-radius: var(--bulma-radius-rounded);
+  border-right-color: transparent;
+  border-top-color: transparent;
+  content: "";
+  display: block;
+  height: 1em;
+  position: relative;
+  width: 1em;
+}
+
+.notification {
+  --bulma-notification-h: var(--bulma-scheme-h);
+  --bulma-notification-s: var(--bulma-scheme-s);
+  --bulma-notification-background-l: var(--bulma-background-l);
+  --bulma-notification-color-l: var(--bulma-text-strong-l);
+  --bulma-notification-code-background-color: var(--bulma-scheme-main);
+  --bulma-notification-radius: var(--bulma-radius);
+  --bulma-notification-padding: 1.375em 1.5em;
+}
+
+.notification {
+  background-color: hsl(var(--bulma-notification-h), var(--bulma-notification-s), var(--bulma-notification-background-l));
+  border-radius: var(--bulma-notification-radius);
+  color: hsl(var(--bulma-notification-h), var(--bulma-notification-s), var(--bulma-notification-color-l));
+  padding: var(--bulma-notification-padding);
+  position: relative;
+}
+.notification a:not(.button):not(.dropdown-item) {
+  color: currentColor;
+  text-decoration: underline;
+}
+.notification strong {
+  color: currentColor;
+}
+.notification code,
+.notification pre {
+  background: var(--bulma-notification-code-background-color);
+}
+.notification pre code {
+  background: transparent;
+}
+.notification > .delete {
+  position: absolute;
+  inset-inline-end: 1rem;
+  top: 1rem;
+}
+.notification .title,
+.notification .subtitle,
+.notification .content {
+  color: currentColor;
+}
+.notification.is-white {
+  --bulma-notification-h: var(--bulma-white-h);
+  --bulma-notification-s: var(--bulma-white-s);
+  --bulma-notification-background-l: var(--bulma-white-l);
+  --bulma-notification-color-l: var(--bulma-white-invert-l);
+}
+.notification.is-white.is-light {
+  --bulma-notification-background-l: 90%;
+  --bulma-notification-color-l: var(--bulma-white-light-invert-l);
+}
+.notification.is-white.is-dark {
+  --bulma-notification-background-l: 20%;
+  --bulma-notification-color-l: var(--bulma-white-dark-invert-l);
+}
+.notification.is-black {
+  --bulma-notification-h: var(--bulma-black-h);
+  --bulma-notification-s: var(--bulma-black-s);
+  --bulma-notification-background-l: var(--bulma-black-l);
+  --bulma-notification-color-l: var(--bulma-black-invert-l);
+}
+.notification.is-black.is-light {
+  --bulma-notification-background-l: 90%;
+  --bulma-notification-color-l: var(--bulma-black-light-invert-l);
+}
+.notification.is-black.is-dark {
+  --bulma-notification-background-l: 20%;
+  --bulma-notification-color-l: var(--bulma-black-dark-invert-l);
+}
+.notification.is-light {
+  --bulma-notification-h: var(--bulma-light-h);
+  --bulma-notification-s: var(--bulma-light-s);
+  --bulma-notification-background-l: var(--bulma-light-l);
+  --bulma-notification-color-l: var(--bulma-light-invert-l);
+}
+.notification.is-light.is-light {
+  --bulma-notification-background-l: 90%;
+  --bulma-notification-color-l: var(--bulma-light-light-invert-l);
+}
+.notification.is-light.is-dark {
+  --bulma-notification-background-l: 20%;
+  --bulma-notification-color-l: var(--bulma-light-dark-invert-l);
+}
+.notification.is-dark {
+  --bulma-notification-h: var(--bulma-dark-h);
+  --bulma-notification-s: var(--bulma-dark-s);
+  --bulma-notification-background-l: var(--bulma-dark-l);
+  --bulma-notification-color-l: var(--bulma-dark-invert-l);
+}
+.notification.is-dark.is-light {
+  --bulma-notification-background-l: 90%;
+  --bulma-notification-color-l: var(--bulma-dark-light-invert-l);
+}
+.notification.is-dark.is-dark {
+  --bulma-notification-background-l: 20%;
+  --bulma-notification-color-l: var(--bulma-dark-dark-invert-l);
+}
+.notification.is-text {
+  --bulma-notification-h: var(--bulma-text-h);
+  --bulma-notification-s: var(--bulma-text-s);
+  --bulma-notification-background-l: var(--bulma-text-l);
+  --bulma-notification-color-l: var(--bulma-text-invert-l);
+}
+.notification.is-text.is-light {
+  --bulma-notification-background-l: 90%;
+  --bulma-notification-color-l: var(--bulma-text-light-invert-l);
+}
+.notification.is-text.is-dark {
+  --bulma-notification-background-l: 20%;
+  --bulma-notification-color-l: var(--bulma-text-dark-invert-l);
+}
+.notification.is-primary {
+  --bulma-notification-h: var(--bulma-primary-h);
+  --bulma-notification-s: var(--bulma-primary-s);
+  --bulma-notification-background-l: var(--bulma-primary-l);
+  --bulma-notification-color-l: var(--bulma-primary-invert-l);
+}
+.notification.is-primary.is-light {
+  --bulma-notification-background-l: 90%;
+  --bulma-notification-color-l: var(--bulma-primary-light-invert-l);
+}
+.notification.is-primary.is-dark {
+  --bulma-notification-background-l: 20%;
+  --bulma-notification-color-l: var(--bulma-primary-dark-invert-l);
+}
+.notification.is-link {
+  --bulma-notification-h: var(--bulma-link-h);
+  --bulma-notification-s: var(--bulma-link-s);
+  --bulma-notification-background-l: var(--bulma-link-l);
+  --bulma-notification-color-l: var(--bulma-link-invert-l);
+}
+.notification.is-link.is-light {
+  --bulma-notification-background-l: 90%;
+  --bulma-notification-color-l: var(--bulma-link-light-invert-l);
+}
+.notification.is-link.is-dark {
+  --bulma-notification-background-l: 20%;
+  --bulma-notification-color-l: var(--bulma-link-dark-invert-l);
+}
+.notification.is-info {
+  --bulma-notification-h: var(--bulma-info-h);
+  --bulma-notification-s: var(--bulma-info-s);
+  --bulma-notification-background-l: var(--bulma-info-l);
+  --bulma-notification-color-l: var(--bulma-info-invert-l);
+}
+.notification.is-info.is-light {
+  --bulma-notification-background-l: 90%;
+  --bulma-notification-color-l: var(--bulma-info-light-invert-l);
+}
+.notification.is-info.is-dark {
+  --bulma-notification-background-l: 20%;
+  --bulma-notification-color-l: var(--bulma-info-dark-invert-l);
+}
+.notification.is-success {
+  --bulma-notification-h: var(--bulma-success-h);
+  --bulma-notification-s: var(--bulma-success-s);
+  --bulma-notification-background-l: var(--bulma-success-l);
+  --bulma-notification-color-l: var(--bulma-success-invert-l);
+}
+.notification.is-success.is-light {
+  --bulma-notification-background-l: 90%;
+  --bulma-notification-color-l: var(--bulma-success-light-invert-l);
+}
+.notification.is-success.is-dark {
+  --bulma-notification-background-l: 20%;
+  --bulma-notification-color-l: var(--bulma-success-dark-invert-l);
+}
+.notification.is-warning {
+  --bulma-notification-h: var(--bulma-warning-h);
+  --bulma-notification-s: var(--bulma-warning-s);
+  --bulma-notification-background-l: var(--bulma-warning-l);
+  --bulma-notification-color-l: var(--bulma-warning-invert-l);
+}
+.notification.is-warning.is-light {
+  --bulma-notification-background-l: 90%;
+  --bulma-notification-color-l: var(--bulma-warning-light-invert-l);
+}
+.notification.is-warning.is-dark {
+  --bulma-notification-background-l: 20%;
+  --bulma-notification-color-l: var(--bulma-warning-dark-invert-l);
+}
+.notification.is-danger {
+  --bulma-notification-h: var(--bulma-danger-h);
+  --bulma-notification-s: var(--bulma-danger-s);
+  --bulma-notification-background-l: var(--bulma-danger-l);
+  --bulma-notification-color-l: var(--bulma-danger-invert-l);
+}
+.notification.is-danger.is-light {
+  --bulma-notification-background-l: 90%;
+  --bulma-notification-color-l: var(--bulma-danger-light-invert-l);
+}
+.notification.is-danger.is-dark {
+  --bulma-notification-background-l: 20%;
+  --bulma-notification-color-l: var(--bulma-danger-dark-invert-l);
+}
+
+.progress {
+  --bulma-progress-border-radius: var(--bulma-radius-rounded);
+  --bulma-progress-bar-background-color: var(--bulma-border-weak);
+  --bulma-progress-value-background-color: var(--bulma-text);
+  --bulma-progress-indeterminate-duration: 1.5s;
+}
+
+.progress {
+  appearance: none;
+  border: none;
+  border-radius: var(--bulma-progress-border-radius);
+  display: block;
+  height: var(--bulma-size-normal);
+  overflow: hidden;
+  padding: 0;
+  width: 100%;
+}
+.progress::-webkit-progress-bar {
+  background-color: var(--bulma-progress-bar-background-color);
+}
+.progress::-webkit-progress-value {
+  background-color: var(--bulma-progress-value-background-color);
+}
+.progress::-moz-progress-bar {
+  background-color: var(--bulma-progress-value-background-color);
+}
+.progress::-ms-fill {
+  background-color: var(--bulma-progress-value-background-color);
+  border: none;
+}
+.progress.is-white {
+  --bulma-progress-value-background-color: var(--bulma-white);
+}
+.progress.is-black {
+  --bulma-progress-value-background-color: var(--bulma-black);
+}
+.progress.is-light {
+  --bulma-progress-value-background-color: var(--bulma-light);
+}
+.progress.is-dark {
+  --bulma-progress-value-background-color: var(--bulma-dark);
+}
+.progress.is-text {
+  --bulma-progress-value-background-color: var(--bulma-text);
+}
+.progress.is-primary {
+  --bulma-progress-value-background-color: var(--bulma-primary);
+}
+.progress.is-link {
+  --bulma-progress-value-background-color: var(--bulma-link);
+}
+.progress.is-info {
+  --bulma-progress-value-background-color: var(--bulma-info);
+}
+.progress.is-success {
+  --bulma-progress-value-background-color: var(--bulma-success);
+}
+.progress.is-warning {
+  --bulma-progress-value-background-color: var(--bulma-warning);
+}
+.progress.is-danger {
+  --bulma-progress-value-background-color: var(--bulma-danger);
+}
+.progress:indeterminate {
+  animation-duration: var(--bulma-progress-indeterminate-duration);
+  animation-iteration-count: infinite;
+  animation-name: moveIndeterminate;
+  animation-timing-function: linear;
+  background-color: var(--bulma-progress-bar-background-color);
+  background-image: linear-gradient(to right, var(--bulma-progress-value-background-color) 30%, var(--bulma-progress-bar-background-color) 30%);
+  background-position: top left;
+  background-repeat: no-repeat;
+  background-size: 150% 150%;
+}
+.progress:indeterminate::-webkit-progress-bar {
+  background-color: transparent;
+}
+.progress:indeterminate::-moz-progress-bar {
+  background-color: transparent;
+}
+.progress:indeterminate::-ms-fill {
+  animation-name: none;
+}
+.progress.is-small {
+  height: var(--bulma-size-small);
+}
+.progress.is-medium {
+  height: var(--bulma-size-medium);
+}
+.progress.is-large {
+  height: var(--bulma-size-large);
+}
+
+@keyframes moveIndeterminate {
+  from {
+    background-position: 200% 0;
+  }
+  to {
+    background-position: -200% 0;
+  }
+}
+.table {
+  --bulma-table-color: var(--bulma-text-strong);
+  --bulma-table-background-color: var(--bulma-scheme-main);
+  --bulma-table-cell-border-color: var(--bulma-border);
+  --bulma-table-cell-border-style: solid;
+  --bulma-table-cell-border-width: 0 0 1px;
+  --bulma-table-cell-padding: 0.5em 0.75em;
+  --bulma-table-cell-heading-color: var(--bulma-text-strong);
+  --bulma-table-cell-text-align: left;
+  --bulma-table-head-cell-border-width: 0 0 2px;
+  --bulma-table-head-cell-color: var(--bulma-text-strong);
+  --bulma-table-foot-cell-border-width: 2px 0 0;
+  --bulma-table-foot-cell-color: var(--bulma-text-strong);
+  --bulma-table-head-background-color: transparent;
+  --bulma-table-body-background-color: transparent;
+  --bulma-table-foot-background-color: transparent;
+  --bulma-table-row-hover-background-color: var(--bulma-scheme-main-bis);
+  --bulma-table-row-active-background-color: var(--bulma-primary);
+  --bulma-table-row-active-color: var(--bulma-primary-invert);
+  --bulma-table-striped-row-even-background-color: var(--bulma-scheme-main-bis);
+  --bulma-table-striped-row-even-hover-background-color: var(--bulma-scheme-main-ter);
+}
+
+.table {
+  background-color: var(--bulma-table-background-color);
+  color: var(--bulma-table-color);
+}
+.table td,
+.table th {
+  background-color: var(--bulma-table-cell-background-color);
+  border-color: var(--bulma-table-cell-border-color);
+  border-style: var(--bulma-table-cell-border-style);
+  border-width: var(--bulma-table-cell-border-width);
+  color: var(--bulma-table-color);
+  padding: var(--bulma-table-cell-padding);
+  vertical-align: top;
+}
+.table td.is-white,
+.table th.is-white {
+  --bulma-table-color: var(--bulma-white-invert);
+  --bulma-table-cell-heading-color: var(--bulma-white-invert);
+  --bulma-table-cell-background-color: var(--bulma-white);
+  --bulma-table-cell-border-color: var(--bulma-white);
+}
+.table td.is-black,
+.table th.is-black {
+  --bulma-table-color: var(--bulma-black-invert);
+  --bulma-table-cell-heading-color: var(--bulma-black-invert);
+  --bulma-table-cell-background-color: var(--bulma-black);
+  --bulma-table-cell-border-color: var(--bulma-black);
+}
+.table td.is-light,
+.table th.is-light {
+  --bulma-table-color: var(--bulma-light-invert);
+  --bulma-table-cell-heading-color: var(--bulma-light-invert);
+  --bulma-table-cell-background-color: var(--bulma-light);
+  --bulma-table-cell-border-color: var(--bulma-light);
+}
+.table td.is-dark,
+.table th.is-dark {
+  --bulma-table-color: var(--bulma-dark-invert);
+  --bulma-table-cell-heading-color: var(--bulma-dark-invert);
+  --bulma-table-cell-background-color: var(--bulma-dark);
+  --bulma-table-cell-border-color: var(--bulma-dark);
+}
+.table td.is-text,
+.table th.is-text {
+  --bulma-table-color: var(--bulma-text-invert);
+  --bulma-table-cell-heading-color: var(--bulma-text-invert);
+  --bulma-table-cell-background-color: var(--bulma-text);
+  --bulma-table-cell-border-color: var(--bulma-text);
+}
+.table td.is-primary,
+.table th.is-primary {
+  --bulma-table-color: var(--bulma-primary-invert);
+  --bulma-table-cell-heading-color: var(--bulma-primary-invert);
+  --bulma-table-cell-background-color: var(--bulma-primary);
+  --bulma-table-cell-border-color: var(--bulma-primary);
+}
+.table td.is-link,
+.table th.is-link {
+  --bulma-table-color: var(--bulma-link-invert);
+  --bulma-table-cell-heading-color: var(--bulma-link-invert);
+  --bulma-table-cell-background-color: var(--bulma-link);
+  --bulma-table-cell-border-color: var(--bulma-link);
+}
+.table td.is-info,
+.table th.is-info {
+  --bulma-table-color: var(--bulma-info-invert);
+  --bulma-table-cell-heading-color: var(--bulma-info-invert);
+  --bulma-table-cell-background-color: var(--bulma-info);
+  --bulma-table-cell-border-color: var(--bulma-info);
+}
+.table td.is-success,
+.table th.is-success {
+  --bulma-table-color: var(--bulma-success-invert);
+  --bulma-table-cell-heading-color: var(--bulma-success-invert);
+  --bulma-table-cell-background-color: var(--bulma-success);
+  --bulma-table-cell-border-color: var(--bulma-success);
+}
+.table td.is-warning,
+.table th.is-warning {
+  --bulma-table-color: var(--bulma-warning-invert);
+  --bulma-table-cell-heading-color: var(--bulma-warning-invert);
+  --bulma-table-cell-background-color: var(--bulma-warning);
+  --bulma-table-cell-border-color: var(--bulma-warning);
+}
+.table td.is-danger,
+.table th.is-danger {
+  --bulma-table-color: var(--bulma-danger-invert);
+  --bulma-table-cell-heading-color: var(--bulma-danger-invert);
+  --bulma-table-cell-background-color: var(--bulma-danger);
+  --bulma-table-cell-border-color: var(--bulma-danger);
+}
+.table td.is-narrow,
+.table th.is-narrow {
+  white-space: nowrap;
+  width: 1%;
+}
+.table td.is-selected,
+.table th.is-selected {
+  background-color: var(--bulma-table-row-active-background-color);
+  color: var(--bulma-table-row-active-color);
+}
+.table td.is-selected a,
+.table td.is-selected strong,
+.table th.is-selected a,
+.table th.is-selected strong {
+  color: currentColor;
+}
+.table td.is-vcentered,
+.table th.is-vcentered {
+  vertical-align: middle;
+}
+.table th {
+  color: var(--bulma-table-cell-heading-color);
+}
+.table th:not([align]) {
+  text-align: var(--bulma-table-cell-text-align);
+}
+.table tr.is-selected {
+  background-color: var(--bulma-table-row-active-background-color);
+  color: var(--bulma-table-row-active-color);
+}
+.table tr.is-selected a,
+.table tr.is-selected strong {
+  color: currentColor;
+}
+.table tr.is-selected td,
+.table tr.is-selected th {
+  border-color: var(--bulma-table-row-active-color);
+  color: currentColor;
+}
+.table tr.is-white {
+  --bulma-table-color: var(--bulma-white-invert);
+  --bulma-table-cell-heading-color: var(--bulma-white-invert);
+  --bulma-table-cell-background-color: var(--bulma-white);
+  --bulma-table-cell-border-color: var(--bulma-white);
+}
+.table tr.is-black {
+  --bulma-table-color: var(--bulma-black-invert);
+  --bulma-table-cell-heading-color: var(--bulma-black-invert);
+  --bulma-table-cell-background-color: var(--bulma-black);
+  --bulma-table-cell-border-color: var(--bulma-black);
+}
+.table tr.is-light {
+  --bulma-table-color: var(--bulma-light-invert);
+  --bulma-table-cell-heading-color: var(--bulma-light-invert);
+  --bulma-table-cell-background-color: var(--bulma-light);
+  --bulma-table-cell-border-color: var(--bulma-light);
+}
+.table tr.is-dark {
+  --bulma-table-color: var(--bulma-dark-invert);
+  --bulma-table-cell-heading-color: var(--bulma-dark-invert);
+  --bulma-table-cell-background-color: var(--bulma-dark);
+  --bulma-table-cell-border-color: var(--bulma-dark);
+}
+.table tr.is-text {
+  --bulma-table-color: var(--bulma-text-invert);
+  --bulma-table-cell-heading-color: var(--bulma-text-invert);
+  --bulma-table-cell-background-color: var(--bulma-text);
+  --bulma-table-cell-border-color: var(--bulma-text);
+}
+.table tr.is-primary {
+  --bulma-table-color: var(--bulma-primary-invert);
+  --bulma-table-cell-heading-color: var(--bulma-primary-invert);
+  --bulma-table-cell-background-color: var(--bulma-primary);
+  --bulma-table-cell-border-color: var(--bulma-primary);
+}
+.table tr.is-link {
+  --bulma-table-color: var(--bulma-link-invert);
+  --bulma-table-cell-heading-color: var(--bulma-link-invert);
+  --bulma-table-cell-background-color: var(--bulma-link);
+  --bulma-table-cell-border-color: var(--bulma-link);
+}
+.table tr.is-info {
+  --bulma-table-color: var(--bulma-info-invert);
+  --bulma-table-cell-heading-color: var(--bulma-info-invert);
+  --bulma-table-cell-background-color: var(--bulma-info);
+  --bulma-table-cell-border-color: var(--bulma-info);
+}
+.table tr.is-success {
+  --bulma-table-color: var(--bulma-success-invert);
+  --bulma-table-cell-heading-color: var(--bulma-success-invert);
+  --bulma-table-cell-background-color: var(--bulma-success);
+  --bulma-table-cell-border-color: var(--bulma-success);
+}
+.table tr.is-warning {
+  --bulma-table-color: var(--bulma-warning-invert);
+  --bulma-table-cell-heading-color: var(--bulma-warning-invert);
+  --bulma-table-cell-background-color: var(--bulma-warning);
+  --bulma-table-cell-border-color: var(--bulma-warning);
+}
+.table tr.is-danger {
+  --bulma-table-color: var(--bulma-danger-invert);
+  --bulma-table-cell-heading-color: var(--bulma-danger-invert);
+  --bulma-table-cell-background-color: var(--bulma-danger);
+  --bulma-table-cell-border-color: var(--bulma-danger);
+}
+.table thead {
+  background-color: var(--bulma-table-head-background-color);
+}
+.table thead td,
+.table thead th {
+  border-width: var(--bulma-table-head-cell-border-width);
+  color: var(--bulma-table-head-cell-color);
+}
+.table tfoot {
+  background-color: var(--bulma-table-foot-background-color);
+}
+.table tfoot td,
+.table tfoot th {
+  border-width: var(--bulma-table-foot-cell-border-width);
+  color: var(--bulma-table-foot-cell-color);
+}
+.table tbody {
+  background-color: var(--bulma-table-body-background-color);
+}
+.table tbody tr:last-child td,
+.table tbody tr:last-child th {
+  border-bottom-width: 0;
+}
+.table.is-bordered td,
+.table.is-bordered th {
+  border-width: 1px;
+}
+.table.is-bordered tr:last-child td,
+.table.is-bordered tr:last-child th {
+  border-bottom-width: 1px;
+}
+.table.is-fullwidth {
+  width: 100%;
+}
+.table.is-hoverable tbody tr:not(.is-selected):hover {
+  background-color: var(--bulma-table-row-hover-background-color);
+}
+.table.is-hoverable.is-striped tbody tr:not(.is-selected):hover {
+  background-color: var(--bulma-table-row-hover-background-color);
+}
+.table.is-hoverable.is-striped tbody tr:not(.is-selected):hover:nth-child(even) {
+  background-color: var(--bulma-table-striped-row-even-hover-background-color);
+}
+.table.is-narrow td,
+.table.is-narrow th {
+  padding: 0.25em 0.5em;
+}
+.table.is-striped tbody tr:not(.is-selected):nth-child(even) {
+  background-color: var(--bulma-table-striped-row-even-background-color);
+}
+
+.table-container {
+  -webkit-overflow-scrolling: touch;
+  overflow: auto;
+  overflow-y: hidden;
+  max-width: 100%;
+}
+
+.tags {
+  align-items: center;
+  color: hsl(var(--bulma-tag-h), var(--bulma-tag-s), var(--bulma-tag-color-l));
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.5rem;
+  justify-content: flex-start;
+}
+.tags.are-medium .tag:not(.is-normal):not(.is-large) {
+  font-size: var(--bulma-size-normal);
+}
+.tags.are-large .tag:not(.is-normal):not(.is-medium) {
+  font-size: var(--bulma-size-medium);
+}
+.tags.is-centered {
+  gap: 0.25rem;
+  justify-content: center;
+}
+.tags.is-right {
+  justify-content: flex-end;
+}
+.tags.has-addons {
+  gap: 0;
+}
+.tags.has-addons .tag:not(:first-child) {
+  border-start-start-radius: 0;
+  border-end-start-radius: 0;
+}
+.tags.has-addons .tag:not(:last-child) {
+  border-start-end-radius: 0;
+  border-end-end-radius: 0;
+}
+
+.tag {
+  --bulma-tag-h: var(--bulma-scheme-h);
+  --bulma-tag-s: var(--bulma-scheme-s);
+  --bulma-tag-background-l: var(--bulma-background-l);
+  --bulma-tag-background-l-delta: 0%;
+  --bulma-tag-hover-background-l-delta: var(--bulma-hover-background-l-delta);
+  --bulma-tag-active-background-l-delta: var(--bulma-active-background-l-delta);
+  --bulma-tag-color-l: var(--bulma-text-l);
+  --bulma-tag-radius: var(--bulma-radius);
+  --bulma-tag-delete-margin: 1px;
+  align-items: center;
+  background-color: hsl(var(--bulma-tag-h), var(--bulma-tag-s), calc(var(--bulma-tag-background-l) + var(--bulma-tag-background-l-delta)));
+  border-radius: var(--bulma-radius);
+  color: hsl(var(--bulma-tag-h), var(--bulma-tag-s), var(--bulma-tag-color-l));
+  display: inline-flex;
+  font-size: var(--bulma-size-small);
+  height: 2em;
+  justify-content: center;
+  line-height: 1.5;
+  padding-left: 0.75em;
+  padding-right: 0.75em;
+  white-space: nowrap;
+}
+.tag .delete {
+  margin-inline-start: 0.25rem;
+  margin-inline-end: -0.375rem;
+}
+.tag.is-white {
+  --bulma-tag-h: var(--bulma-white-h);
+  --bulma-tag-s: var(--bulma-white-s);
+  --bulma-tag-background-l: var(--bulma-white-l);
+  --bulma-tag-color-l: var(--bulma-white-invert-l);
+}
+.tag.is-white.is-light {
+  --bulma-tag-background-l: var(--bulma-light-l);
+  --bulma-tag-color-l: var(--bulma-white-light-invert-l);
+}
+.tag.is-black {
+  --bulma-tag-h: var(--bulma-black-h);
+  --bulma-tag-s: var(--bulma-black-s);
+  --bulma-tag-background-l: var(--bulma-black-l);
+  --bulma-tag-color-l: var(--bulma-black-invert-l);
+}
+.tag.is-black.is-light {
+  --bulma-tag-background-l: var(--bulma-light-l);
+  --bulma-tag-color-l: var(--bulma-black-light-invert-l);
+}
+.tag.is-light {
+  --bulma-tag-h: var(--bulma-light-h);
+  --bulma-tag-s: var(--bulma-light-s);
+  --bulma-tag-background-l: var(--bulma-light-l);
+  --bulma-tag-color-l: var(--bulma-light-invert-l);
+}
+.tag.is-light.is-light {
+  --bulma-tag-background-l: var(--bulma-light-l);
+  --bulma-tag-color-l: var(--bulma-light-light-invert-l);
+}
+.tag.is-dark {
+  --bulma-tag-h: var(--bulma-dark-h);
+  --bulma-tag-s: var(--bulma-dark-s);
+  --bulma-tag-background-l: var(--bulma-dark-l);
+  --bulma-tag-color-l: var(--bulma-dark-invert-l);
+}
+.tag.is-dark.is-light {
+  --bulma-tag-background-l: var(--bulma-light-l);
+  --bulma-tag-color-l: var(--bulma-dark-light-invert-l);
+}
+.tag.is-text {
+  --bulma-tag-h: var(--bulma-text-h);
+  --bulma-tag-s: var(--bulma-text-s);
+  --bulma-tag-background-l: var(--bulma-text-l);
+  --bulma-tag-color-l: var(--bulma-text-invert-l);
+}
+.tag.is-text.is-light {
+  --bulma-tag-background-l: var(--bulma-light-l);
+  --bulma-tag-color-l: var(--bulma-text-light-invert-l);
+}
+.tag.is-primary {
+  --bulma-tag-h: var(--bulma-primary-h);
+  --bulma-tag-s: var(--bulma-primary-s);
+  --bulma-tag-background-l: var(--bulma-primary-l);
+  --bulma-tag-color-l: var(--bulma-primary-invert-l);
+}
+.tag.is-primary.is-light {
+  --bulma-tag-background-l: var(--bulma-light-l);
+  --bulma-tag-color-l: var(--bulma-primary-light-invert-l);
+}
+.tag.is-link {
+  --bulma-tag-h: var(--bulma-link-h);
+  --bulma-tag-s: var(--bulma-link-s);
+  --bulma-tag-background-l: var(--bulma-link-l);
+  --bulma-tag-color-l: var(--bulma-link-invert-l);
+}
+.tag.is-link.is-light {
+  --bulma-tag-background-l: var(--bulma-light-l);
+  --bulma-tag-color-l: var(--bulma-link-light-invert-l);
+}
+.tag.is-info {
+  --bulma-tag-h: var(--bulma-info-h);
+  --bulma-tag-s: var(--bulma-info-s);
+  --bulma-tag-background-l: var(--bulma-info-l);
+  --bulma-tag-color-l: var(--bulma-info-invert-l);
+}
+.tag.is-info.is-light {
+  --bulma-tag-background-l: var(--bulma-light-l);
+  --bulma-tag-color-l: var(--bulma-info-light-invert-l);
+}
+.tag.is-success {
+  --bulma-tag-h: var(--bulma-success-h);
+  --bulma-tag-s: var(--bulma-success-s);
+  --bulma-tag-background-l: var(--bulma-success-l);
+  --bulma-tag-color-l: var(--bulma-success-invert-l);
+}
+.tag.is-success.is-light {
+  --bulma-tag-background-l: var(--bulma-light-l);
+  --bulma-tag-color-l: var(--bulma-success-light-invert-l);
+}
+.tag.is-warning {
+  --bulma-tag-h: var(--bulma-warning-h);
+  --bulma-tag-s: var(--bulma-warning-s);
+  --bulma-tag-background-l: var(--bulma-warning-l);
+  --bulma-tag-color-l: var(--bulma-warning-invert-l);
+}
+.tag.is-warning.is-light {
+  --bulma-tag-background-l: var(--bulma-light-l);
+  --bulma-tag-color-l: var(--bulma-warning-light-invert-l);
+}
+.tag.is-danger {
+  --bulma-tag-h: var(--bulma-danger-h);
+  --bulma-tag-s: var(--bulma-danger-s);
+  --bulma-tag-background-l: var(--bulma-danger-l);
+  --bulma-tag-color-l: var(--bulma-danger-invert-l);
+}
+.tag.is-danger.is-light {
+  --bulma-tag-background-l: var(--bulma-light-l);
+  --bulma-tag-color-l: var(--bulma-danger-light-invert-l);
+}
+.tag.is-normal {
+  font-size: var(--bulma-size-small);
+}
+.tag.is-medium {
+  font-size: var(--bulma-size-normal);
+}
+.tag.is-large {
+  font-size: var(--bulma-size-medium);
+}
+.tag .icon:first-child:not(:last-child) {
+  margin-inline-start: -0.375em;
+  margin-inline-end: 0.1875em;
+}
+.tag .icon:last-child:not(:first-child) {
+  margin-inline-start: 0.1875em;
+  margin-inline-end: -0.375em;
+}
+.tag .icon:first-child:last-child {
+  margin-inline-start: -0.375em;
+  margin-inline-end: -0.375em;
+}
+.tag.is-delete {
+  margin-inline-start: var(--bulma-tag-delete-margin);
+  padding: 0;
+  position: relative;
+  width: 2em;
+}
+.tag.is-delete::before, .tag.is-delete::after {
+  background-color: currentColor;
+  content: "";
+  display: block;
+  left: 50%;
+  position: absolute;
+  top: 50%;
+  transform: translateX(-50%) translateY(-50%) rotate(45deg);
+  transform-origin: center center;
+}
+.tag.is-delete::before {
+  height: 1px;
+  width: 50%;
+}
+.tag.is-delete::after {
+  height: 50%;
+  width: 1px;
+}
+.tag.is-rounded {
+  border-radius: var(--bulma-radius-rounded);
+}
+
+a.tag,
+button.tag,
+.tag.is-hoverable {
+  cursor: pointer;
+}
+a.tag:hover,
+button.tag:hover,
+.tag.is-hoverable:hover {
+  --bulma-tag-background-l-delta: var(--bulma-tag-hover-background-l-delta);
+}
+a.tag:active,
+button.tag:active,
+.tag.is-hoverable:active {
+  --bulma-tag-background-l-delta: var(--bulma-tag-active-background-l-delta);
+}
+
+.title,
+.subtitle {
+  --bulma-title-color: var(--bulma-text-strong);
+  --bulma-title-family: false;
+  --bulma-title-size: var(--bulma-size-3);
+  --bulma-title-weight: var(--bulma-weight-extrabold);
+  --bulma-title-line-height: 1.125;
+  --bulma-title-strong-color: inherit;
+  --bulma-title-strong-weight: inherit;
+  --bulma-title-sub-size: 0.75em;
+  --bulma-title-sup-size: 0.75em;
+  --bulma-subtitle-color: var(--bulma-text);
+  --bulma-subtitle-family: false;
+  --bulma-subtitle-size: var(--bulma-size-5);
+  --bulma-subtitle-weight: var(--bulma-weight-normal);
+  --bulma-subtitle-line-height: 1.25;
+  --bulma-subtitle-strong-color: var(--bulma-text-strong);
+  --bulma-subtitle-strong-weight: var(--bulma-weight-semibold);
+}
+
+.title,
+.subtitle {
+  word-break: break-word;
+}
+.title em,
+.title span,
+.subtitle em,
+.subtitle span {
+  font-weight: inherit;
+}
+.title sub,
+.subtitle sub {
+  font-size: var(--bulma-title-sub-size);
+}
+.title sup,
+.subtitle sup {
+  font-size: var(--bulma-title-sup-size);
+}
+.title .tag,
+.subtitle .tag {
+  vertical-align: middle;
+}
+
+.title {
+  color: var(--bulma-title-color);
+  font-size: var(--bulma-title-size);
+  font-weight: var(--bulma-title-weight);
+  line-height: var(--bulma-title-line-height);
+}
+.title strong {
+  color: var(--bulma-title-strong-color);
+  font-weight: var(--bulma-title-strong-weight);
+}
+.title:not(.is-spaced):has(+ .subtitle) {
+  margin-bottom: 0;
+}
+.title.is-1 {
+  font-size: 3rem;
+}
+.title.is-2 {
+  font-size: 2.5rem;
+}
+.title.is-3 {
+  font-size: 2rem;
+}
+.title.is-4 {
+  font-size: 1.5rem;
+}
+.title.is-5 {
+  font-size: 1.25rem;
+}
+.title.is-6 {
+  font-size: 1rem;
+}
+.title.is-7 {
+  font-size: 0.75rem;
+}
+
+.subtitle {
+  color: var(--bulma-subtitle-color);
+  font-size: var(--bulma-subtitle-size);
+  font-weight: var(--bulma-subtitle-weight);
+  line-height: var(--bulma-subtitle-line-height);
+}
+.subtitle strong {
+  color: var(--bulma-subtitle-strong-color);
+  font-weight: var(--bulma-subtitle-strong-weight);
+}
+.subtitle:not(.is-spaced):has(+ .title) {
+  margin-bottom: 0;
+}
+.subtitle.is-1 {
+  font-size: 3rem;
+}
+.subtitle.is-2 {
+  font-size: 2.5rem;
+}
+.subtitle.is-3 {
+  font-size: 2rem;
+}
+.subtitle.is-4 {
+  font-size: 1.5rem;
+}
+.subtitle.is-5 {
+  font-size: 1.25rem;
+}
+.subtitle.is-6 {
+  font-size: 1rem;
+}
+.subtitle.is-7 {
+  font-size: 0.75rem;
+}
+
+/* Bulma Form */
+.control,
+.input,
+.textarea,
+.select {
+  --bulma-input-h: var(--bulma-scheme-h);
+  --bulma-input-s: var(--bulma-scheme-s);
+  --bulma-input-l: var(--bulma-scheme-main-l);
+  --bulma-input-border-style: solid;
+  --bulma-input-border-width: var(--bulma-control-border-width);
+  --bulma-input-border-l: var(--bulma-border-l);
+  --bulma-input-border-l-delta: 0%;
+  --bulma-input-hover-border-l-delta: var(--bulma-hover-border-l-delta);
+  --bulma-input-active-border-l-delta: var(--bulma-active-border-l-delta);
+  --bulma-input-focus-h: var(--bulma-focus-h);
+  --bulma-input-focus-s: var(--bulma-focus-s);
+  --bulma-input-focus-l: var(--bulma-focus-l);
+  --bulma-input-focus-shadow-size: var(--bulma-focus-shadow-size);
+  --bulma-input-focus-shadow-alpha: var(--bulma-focus-shadow-alpha);
+  --bulma-input-color-l: var(--bulma-text-strong-l);
+  --bulma-input-background-l: var(--bulma-scheme-main-l);
+  --bulma-input-background-l-delta: 0%;
+  --bulma-input-height: var(--bulma-control-height);
+  --bulma-input-shadow: inset 0 0.0625em 0.125em hsla(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-scheme-invert-l), 0.05);
+  --bulma-input-placeholder-color: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-strong-l), 0.3);
+  --bulma-input-disabled-color: var(--bulma-text-weak);
+  --bulma-input-disabled-background-color: var(--bulma-background);
+  --bulma-input-disabled-border-color: var(--bulma-background);
+  --bulma-input-disabled-placeholder-color: hsla(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-weak-l), 0.3);
+  --bulma-input-arrow: var(--bulma-link);
+  --bulma-input-icon-color: var(--bulma-text-light);
+  --bulma-input-icon-hover-color: var(--bulma-text-weak);
+  --bulma-input-icon-focus-color: var(--bulma-link);
+  --bulma-input-radius: var(--bulma-radius);
+}
+
+.select select, .input, .textarea {
+  background-color: hsl(var(--bulma-input-h), var(--bulma-input-s), calc(var(--bulma-input-background-l) + var(--bulma-input-background-l-delta)));
+  border-color: hsl(var(--bulma-input-h), var(--bulma-input-s), calc(var(--bulma-input-border-l) + var(--bulma-input-border-l-delta)));
+  border-radius: var(--bulma-input-radius);
+  color: hsl(var(--bulma-input-h), var(--bulma-input-s), var(--bulma-input-color-l));
+}
+.select select::-moz-placeholder, .input::-moz-placeholder, .textarea::-moz-placeholder {
+  color: var(--bulma-input-placeholder-color);
+}
+.select select::-webkit-input-placeholder, .input::-webkit-input-placeholder, .textarea::-webkit-input-placeholder {
+  color: var(--bulma-input-placeholder-color);
+}
+.select select:-moz-placeholder, .input:-moz-placeholder, .textarea:-moz-placeholder {
+  color: var(--bulma-input-placeholder-color);
+}
+.select select:-ms-input-placeholder, .input:-ms-input-placeholder, .textarea:-ms-input-placeholder {
+  color: var(--bulma-input-placeholder-color);
+}
+.select select:hover, .input:hover, .textarea:hover, .select select.is-hovered, .is-hovered.input, .is-hovered.textarea {
+  --bulma-input-border-l-delta: var(--bulma-input-hover-border-l-delta);
+}
+.select select:active, .input:active, .textarea:active, .select select.is-active, .is-active.input, .is-active.textarea {
+  --bulma-input-border-l-delta: var(--bulma-input-active-border-l-delta);
+}
+.select select:focus, .input:focus, .textarea:focus, .select select:focus-within, .input:focus-within, .textarea:focus-within, .select select.is-focused, .is-focused.input, .is-focused.textarea {
+  border-color: hsl(var(--bulma-input-focus-h), var(--bulma-input-focus-s), var(--bulma-input-focus-l));
+  box-shadow: var(--bulma-input-focus-shadow-size) hsla(var(--bulma-input-focus-h), var(--bulma-input-focus-s), var(--bulma-input-focus-l), var(--bulma-input-focus-shadow-alpha));
+}
+.select select[disabled], [disabled].input, [disabled].textarea, fieldset[disabled] .select select, .select fieldset[disabled] select, fieldset[disabled] .input, fieldset[disabled] .textarea {
+  background-color: var(--bulma-input-disabled-background-color);
+  border-color: var(--bulma-input-disabled-border-color);
+  box-shadow: none;
+  color: var(--bulma-input-disabled-color);
+}
+.select select[disabled]::-moz-placeholder, [disabled].input::-moz-placeholder, [disabled].textarea::-moz-placeholder, fieldset[disabled] .select select::-moz-placeholder, .select fieldset[disabled] select::-moz-placeholder, fieldset[disabled] .input::-moz-placeholder, fieldset[disabled] .textarea::-moz-placeholder {
+  color: var(--bulma-input-disabled-placeholder-color);
+}
+.select select[disabled]::-webkit-input-placeholder, [disabled].input::-webkit-input-placeholder, [disabled].textarea::-webkit-input-placeholder, fieldset[disabled] .select select::-webkit-input-placeholder, .select fieldset[disabled] select::-webkit-input-placeholder, fieldset[disabled] .input::-webkit-input-placeholder, fieldset[disabled] .textarea::-webkit-input-placeholder {
+  color: var(--bulma-input-disabled-placeholder-color);
+}
+.select select[disabled]:-moz-placeholder, [disabled].input:-moz-placeholder, [disabled].textarea:-moz-placeholder, fieldset[disabled] .select select:-moz-placeholder, .select fieldset[disabled] select:-moz-placeholder, fieldset[disabled] .input:-moz-placeholder, fieldset[disabled] .textarea:-moz-placeholder {
+  color: var(--bulma-input-disabled-placeholder-color);
+}
+.select select[disabled]:-ms-input-placeholder, [disabled].input:-ms-input-placeholder, [disabled].textarea:-ms-input-placeholder, fieldset[disabled] .select select:-ms-input-placeholder, .select fieldset[disabled] select:-ms-input-placeholder, fieldset[disabled] .input:-ms-input-placeholder, fieldset[disabled] .textarea:-ms-input-placeholder {
+  color: var(--bulma-input-disabled-placeholder-color);
+}
+
+/* Bulma Form */
+.textarea, .input {
+  box-shadow: inset 0 0.0625em 0.125em hsla(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-scheme-invert-l), 0.05);
+  max-width: 100%;
+  width: 100%;
+}
+[readonly].textarea, [readonly].input {
+  box-shadow: none;
+}
+.is-white.textarea, .is-white.input {
+  --bulma-input-h: var(--bulma-white-h);
+  --bulma-input-s: var(--bulma-white-s);
+  --bulma-input-l: var(--bulma-white-l);
+  --bulma-input-focus-h: var(--bulma-white-h);
+  --bulma-input-focus-s: var(--bulma-white-s);
+  --bulma-input-focus-l: var(--bulma-white-l);
+  --bulma-input-border-l: var(--bulma-white-l);
+}
+.is-black.textarea, .is-black.input {
+  --bulma-input-h: var(--bulma-black-h);
+  --bulma-input-s: var(--bulma-black-s);
+  --bulma-input-l: var(--bulma-black-l);
+  --bulma-input-focus-h: var(--bulma-black-h);
+  --bulma-input-focus-s: var(--bulma-black-s);
+  --bulma-input-focus-l: var(--bulma-black-l);
+  --bulma-input-border-l: var(--bulma-black-l);
+}
+.is-light.textarea, .is-light.input {
+  --bulma-input-h: var(--bulma-light-h);
+  --bulma-input-s: var(--bulma-light-s);
+  --bulma-input-l: var(--bulma-light-l);
+  --bulma-input-focus-h: var(--bulma-light-h);
+  --bulma-input-focus-s: var(--bulma-light-s);
+  --bulma-input-focus-l: var(--bulma-light-l);
+  --bulma-input-border-l: var(--bulma-light-l);
+}
+.is-dark.textarea, .is-dark.input {
+  --bulma-input-h: var(--bulma-dark-h);
+  --bulma-input-s: var(--bulma-dark-s);
+  --bulma-input-l: var(--bulma-dark-l);
+  --bulma-input-focus-h: var(--bulma-dark-h);
+  --bulma-input-focus-s: var(--bulma-dark-s);
+  --bulma-input-focus-l: var(--bulma-dark-l);
+  --bulma-input-border-l: var(--bulma-dark-l);
+}
+.is-text.textarea, .is-text.input {
+  --bulma-input-h: var(--bulma-text-h);
+  --bulma-input-s: var(--bulma-text-s);
+  --bulma-input-l: var(--bulma-text-l);
+  --bulma-input-focus-h: var(--bulma-text-h);
+  --bulma-input-focus-s: var(--bulma-text-s);
+  --bulma-input-focus-l: var(--bulma-text-l);
+  --bulma-input-border-l: var(--bulma-text-l);
+}
+.is-primary.textarea, .is-primary.input {
+  --bulma-input-h: var(--bulma-primary-h);
+  --bulma-input-s: var(--bulma-primary-s);
+  --bulma-input-l: var(--bulma-primary-l);
+  --bulma-input-focus-h: var(--bulma-primary-h);
+  --bulma-input-focus-s: var(--bulma-primary-s);
+  --bulma-input-focus-l: var(--bulma-primary-l);
+  --bulma-input-border-l: var(--bulma-primary-l);
+}
+.is-link.textarea, .is-link.input {
+  --bulma-input-h: var(--bulma-link-h);
+  --bulma-input-s: var(--bulma-link-s);
+  --bulma-input-l: var(--bulma-link-l);
+  --bulma-input-focus-h: var(--bulma-link-h);
+  --bulma-input-focus-s: var(--bulma-link-s);
+  --bulma-input-focus-l: var(--bulma-link-l);
+  --bulma-input-border-l: var(--bulma-link-l);
+}
+.is-info.textarea, .is-info.input {
+  --bulma-input-h: var(--bulma-info-h);
+  --bulma-input-s: var(--bulma-info-s);
+  --bulma-input-l: var(--bulma-info-l);
+  --bulma-input-focus-h: var(--bulma-info-h);
+  --bulma-input-focus-s: var(--bulma-info-s);
+  --bulma-input-focus-l: var(--bulma-info-l);
+  --bulma-input-border-l: var(--bulma-info-l);
+}
+.is-success.textarea, .is-success.input {
+  --bulma-input-h: var(--bulma-success-h);
+  --bulma-input-s: var(--bulma-success-s);
+  --bulma-input-l: var(--bulma-success-l);
+  --bulma-input-focus-h: var(--bulma-success-h);
+  --bulma-input-focus-s: var(--bulma-success-s);
+  --bulma-input-focus-l: var(--bulma-success-l);
+  --bulma-input-border-l: var(--bulma-success-l);
+}
+.is-warning.textarea, .is-warning.input {
+  --bulma-input-h: var(--bulma-warning-h);
+  --bulma-input-s: var(--bulma-warning-s);
+  --bulma-input-l: var(--bulma-warning-l);
+  --bulma-input-focus-h: var(--bulma-warning-h);
+  --bulma-input-focus-s: var(--bulma-warning-s);
+  --bulma-input-focus-l: var(--bulma-warning-l);
+  --bulma-input-border-l: var(--bulma-warning-l);
+}
+.is-danger.textarea, .is-danger.input {
+  --bulma-input-h: var(--bulma-danger-h);
+  --bulma-input-s: var(--bulma-danger-s);
+  --bulma-input-l: var(--bulma-danger-l);
+  --bulma-input-focus-h: var(--bulma-danger-h);
+  --bulma-input-focus-s: var(--bulma-danger-s);
+  --bulma-input-focus-l: var(--bulma-danger-l);
+  --bulma-input-border-l: var(--bulma-danger-l);
+}
+.is-small.textarea, .is-small.input {
+  border-radius: var(--bulma-radius-small);
+  font-size: var(--bulma-size-small);
+}
+.is-medium.textarea, .is-medium.input {
+  font-size: var(--bulma-size-medium);
+}
+.is-large.textarea, .is-large.input {
+  font-size: var(--bulma-size-large);
+}
+.is-fullwidth.textarea, .is-fullwidth.input {
+  display: block;
+  width: 100%;
+}
+.is-inline.textarea, .is-inline.input {
+  display: inline;
+  width: auto;
+}
+
+.input.is-rounded {
+  border-radius: var(--bulma-radius-rounded);
+  padding-left: calc(calc(0.75em - 1px) + 0.375em);
+  padding-right: calc(calc(0.75em - 1px) + 0.375em);
+}
+.input.is-static {
+  background-color: transparent;
+  border-color: transparent;
+  box-shadow: none;
+  padding-left: 0;
+  padding-right: 0;
+}
+
+.textarea {
+  --bulma-textarea-padding: var(--bulma-control-padding-horizontal);
+  --bulma-textarea-max-height: 40em;
+  --bulma-textarea-min-height: 8em;
+  display: block;
+  max-width: 100%;
+  min-width: 100%;
+  padding: var(--bulma-textarea-padding);
+  resize: vertical;
+}
+.textarea:not([rows]) {
+  max-height: var(--bulma-textarea-max-height);
+  min-height: var(--bulma-textarea-min-height);
+}
+.textarea[rows] {
+  height: initial;
+}
+.textarea.has-fixed-size {
+  resize: none;
+}
+
+/* Bulma Form */
+.radio, .checkbox {
+  cursor: pointer;
+  display: inline-block;
+  line-height: 1.25;
+  position: relative;
+}
+.radio input, .checkbox input {
+  cursor: pointer;
+}
+[disabled].radio, [disabled].checkbox, fieldset[disabled] .radio, fieldset[disabled] .checkbox,
+.radio input[disabled],
+.checkbox input[disabled] {
+  color: var(--bulma-text-weak);
+  cursor: not-allowed;
+}
+
+.checkboxes,
+.radios {
+  display: flex;
+  flex-wrap: wrap;
+  column-gap: 1em;
+  row-gap: 0.5em;
+}
+
+/* Bulma Form */
+.select {
+  --bulma-input-h: var(--bulma-scheme-h);
+  --bulma-input-s: var(--bulma-scheme-s);
+  --bulma-input-border-style: solid;
+  --bulma-input-border-width: 1px;
+  --bulma-input-border-l: var(--bulma-border-l);
+  display: inline-block;
+  max-width: 100%;
+  position: relative;
+  vertical-align: top;
+}
+.select:not(.is-multiple) {
+  height: var(--bulma-control-height);
+}
+.select:not(.is-multiple):not(.is-loading)::after {
+  inset-inline-end: 1.125em;
+  z-index: 4;
+}
+.select.is-rounded select {
+  border-radius: var(--bulma-radius-rounded);
+  padding-inline-start: 1em;
+}
+.select select {
+  cursor: pointer;
+  display: block;
+  font-size: 1em;
+  max-width: 100%;
+  outline: none;
+}
+.select select::-ms-expand {
+  display: none;
+}
+.select select[disabled]:hover, fieldset[disabled] .select select:hover {
+  border-color: var(--bulma-background);
+}
+.select select:not([multiple]) {
+  padding-inline-end: 2.5em;
+}
+.select select[multiple] {
+  height: auto;
+  padding: 0;
+}
+.select select[multiple] option {
+  padding: 0.5em 1em;
+}
+.select.is-white {
+  --bulma-input-h: var(--bulma-white-h);
+  --bulma-input-s: var(--bulma-white-s);
+  --bulma-input-l: var(--bulma-white-l);
+  --bulma-input-focus-h: var(--bulma-white-h);
+  --bulma-input-focus-s: var(--bulma-white-s);
+  --bulma-input-focus-l: var(--bulma-white-l);
+  --bulma-input-border-l: var(--bulma-white-l);
+  --bulma-arrow-color: var(--bulma-white);
+}
+.select.is-black {
+  --bulma-input-h: var(--bulma-black-h);
+  --bulma-input-s: var(--bulma-black-s);
+  --bulma-input-l: var(--bulma-black-l);
+  --bulma-input-focus-h: var(--bulma-black-h);
+  --bulma-input-focus-s: var(--bulma-black-s);
+  --bulma-input-focus-l: var(--bulma-black-l);
+  --bulma-input-border-l: var(--bulma-black-l);
+  --bulma-arrow-color: var(--bulma-black);
+}
+.select.is-light {
+  --bulma-input-h: var(--bulma-light-h);
+  --bulma-input-s: var(--bulma-light-s);
+  --bulma-input-l: var(--bulma-light-l);
+  --bulma-input-focus-h: var(--bulma-light-h);
+  --bulma-input-focus-s: var(--bulma-light-s);
+  --bulma-input-focus-l: var(--bulma-light-l);
+  --bulma-input-border-l: var(--bulma-light-l);
+  --bulma-arrow-color: var(--bulma-light);
+}
+.select.is-dark {
+  --bulma-input-h: var(--bulma-dark-h);
+  --bulma-input-s: var(--bulma-dark-s);
+  --bulma-input-l: var(--bulma-dark-l);
+  --bulma-input-focus-h: var(--bulma-dark-h);
+  --bulma-input-focus-s: var(--bulma-dark-s);
+  --bulma-input-focus-l: var(--bulma-dark-l);
+  --bulma-input-border-l: var(--bulma-dark-l);
+  --bulma-arrow-color: var(--bulma-dark);
+}
+.select.is-text {
+  --bulma-input-h: var(--bulma-text-h);
+  --bulma-input-s: var(--bulma-text-s);
+  --bulma-input-l: var(--bulma-text-l);
+  --bulma-input-focus-h: var(--bulma-text-h);
+  --bulma-input-focus-s: var(--bulma-text-s);
+  --bulma-input-focus-l: var(--bulma-text-l);
+  --bulma-input-border-l: var(--bulma-text-l);
+  --bulma-arrow-color: var(--bulma-text);
+}
+.select.is-primary {
+  --bulma-input-h: var(--bulma-primary-h);
+  --bulma-input-s: var(--bulma-primary-s);
+  --bulma-input-l: var(--bulma-primary-l);
+  --bulma-input-focus-h: var(--bulma-primary-h);
+  --bulma-input-focus-s: var(--bulma-primary-s);
+  --bulma-input-focus-l: var(--bulma-primary-l);
+  --bulma-input-border-l: var(--bulma-primary-l);
+  --bulma-arrow-color: var(--bulma-primary);
+}
+.select.is-link {
+  --bulma-input-h: var(--bulma-link-h);
+  --bulma-input-s: var(--bulma-link-s);
+  --bulma-input-l: var(--bulma-link-l);
+  --bulma-input-focus-h: var(--bulma-link-h);
+  --bulma-input-focus-s: var(--bulma-link-s);
+  --bulma-input-focus-l: var(--bulma-link-l);
+  --bulma-input-border-l: var(--bulma-link-l);
+  --bulma-arrow-color: var(--bulma-link);
+}
+.select.is-info {
+  --bulma-input-h: var(--bulma-info-h);
+  --bulma-input-s: var(--bulma-info-s);
+  --bulma-input-l: var(--bulma-info-l);
+  --bulma-input-focus-h: var(--bulma-info-h);
+  --bulma-input-focus-s: var(--bulma-info-s);
+  --bulma-input-focus-l: var(--bulma-info-l);
+  --bulma-input-border-l: var(--bulma-info-l);
+  --bulma-arrow-color: var(--bulma-info);
+}
+.select.is-success {
+  --bulma-input-h: var(--bulma-success-h);
+  --bulma-input-s: var(--bulma-success-s);
+  --bulma-input-l: var(--bulma-success-l);
+  --bulma-input-focus-h: var(--bulma-success-h);
+  --bulma-input-focus-s: var(--bulma-success-s);
+  --bulma-input-focus-l: var(--bulma-success-l);
+  --bulma-input-border-l: var(--bulma-success-l);
+  --bulma-arrow-color: var(--bulma-success);
+}
+.select.is-warning {
+  --bulma-input-h: var(--bulma-warning-h);
+  --bulma-input-s: var(--bulma-warning-s);
+  --bulma-input-l: var(--bulma-warning-l);
+  --bulma-input-focus-h: var(--bulma-warning-h);
+  --bulma-input-focus-s: var(--bulma-warning-s);
+  --bulma-input-focus-l: var(--bulma-warning-l);
+  --bulma-input-border-l: var(--bulma-warning-l);
+  --bulma-arrow-color: var(--bulma-warning);
+}
+.select.is-danger {
+  --bulma-input-h: var(--bulma-danger-h);
+  --bulma-input-s: var(--bulma-danger-s);
+  --bulma-input-l: var(--bulma-danger-l);
+  --bulma-input-focus-h: var(--bulma-danger-h);
+  --bulma-input-focus-s: var(--bulma-danger-s);
+  --bulma-input-focus-l: var(--bulma-danger-l);
+  --bulma-input-border-l: var(--bulma-danger-l);
+  --bulma-arrow-color: var(--bulma-danger);
+}
+.select.is-small {
+  border-radius: var(--bulma-radius-small);
+  font-size: var(--bulma-size-small);
+}
+.select.is-medium {
+  font-size: var(--bulma-size-medium);
+}
+.select.is-large {
+  font-size: var(--bulma-size-large);
+}
+.select.is-disabled::after {
+  border-color: var(--bulma-text-weak) !important;
+  opacity: 0.5;
+}
+.select.is-fullwidth {
+  width: 100%;
+}
+.select.is-fullwidth select {
+  width: 100%;
+}
+.select.is-loading::after {
+  inset-inline-end: 0.625em;
+  margin-top: 0;
+  position: absolute;
+  top: 0.625em;
+  transform: none;
+}
+.select.is-loading.is-small:after {
+  font-size: var(--bulma-size-small);
+}
+.select.is-loading.is-medium:after {
+  font-size: var(--bulma-size-medium);
+}
+.select.is-loading.is-large:after {
+  font-size: var(--bulma-size-large);
+}
+
+/* Bulma Form */
+.file {
+  --bulma-file-radius: var(--bulma-radius);
+  --bulma-file-name-border-color: var(--bulma-border);
+  --bulma-file-name-border-style: solid;
+  --bulma-file-name-border-width: 1px 1px 1px 0;
+  --bulma-file-name-max-width: 16em;
+  --bulma-file-h: var(--bulma-scheme-h);
+  --bulma-file-s: var(--bulma-scheme-s);
+  --bulma-file-background-l: var(--bulma-scheme-main-ter-l);
+  --bulma-file-background-l-delta: 0%;
+  --bulma-file-hover-background-l-delta: -5%;
+  --bulma-file-active-background-l-delta: -10%;
+  --bulma-file-border-l: var(--bulma-border-l);
+  --bulma-file-border-l-delta: 0%;
+  --bulma-file-hover-border-l-delta: -10%;
+  --bulma-file-active-border-l-delta: -20%;
+  --bulma-file-cta-color-l: var(--bulma-text-strong-l);
+  --bulma-file-name-color-l: var(--bulma-text-strong-l);
+  --bulma-file-color-l-delta: 0%;
+  --bulma-file-hover-color-l-delta: -5%;
+  --bulma-file-active-color-l-delta: -10%;
+  align-items: stretch;
+  display: flex;
+  justify-content: flex-start;
+  position: relative;
+}
+.file.is-white {
+  --bulma-file-h: var(--bulma-white-h);
+  --bulma-file-s: var(--bulma-white-s);
+  --bulma-file-background-l: var(--bulma-white-l);
+  --bulma-file-border-l: var(--bulma-white-l);
+  --bulma-file-cta-color-l: var(--bulma-white-invert-l);
+  --bulma-file-name-color-l: var(--bulma-white-on-scheme-l);
+}
+.file.is-black {
+  --bulma-file-h: var(--bulma-black-h);
+  --bulma-file-s: var(--bulma-black-s);
+  --bulma-file-background-l: var(--bulma-black-l);
+  --bulma-file-border-l: var(--bulma-black-l);
+  --bulma-file-cta-color-l: var(--bulma-black-invert-l);
+  --bulma-file-name-color-l: var(--bulma-black-on-scheme-l);
+}
+.file.is-light {
+  --bulma-file-h: var(--bulma-light-h);
+  --bulma-file-s: var(--bulma-light-s);
+  --bulma-file-background-l: var(--bulma-light-l);
+  --bulma-file-border-l: var(--bulma-light-l);
+  --bulma-file-cta-color-l: var(--bulma-light-invert-l);
+  --bulma-file-name-color-l: var(--bulma-light-on-scheme-l);
+}
+.file.is-dark {
+  --bulma-file-h: var(--bulma-dark-h);
+  --bulma-file-s: var(--bulma-dark-s);
+  --bulma-file-background-l: var(--bulma-dark-l);
+  --bulma-file-border-l: var(--bulma-dark-l);
+  --bulma-file-cta-color-l: var(--bulma-dark-invert-l);
+  --bulma-file-name-color-l: var(--bulma-dark-on-scheme-l);
+}
+.file.is-text {
+  --bulma-file-h: var(--bulma-text-h);
+  --bulma-file-s: var(--bulma-text-s);
+  --bulma-file-background-l: var(--bulma-text-l);
+  --bulma-file-border-l: var(--bulma-text-l);
+  --bulma-file-cta-color-l: var(--bulma-text-invert-l);
+  --bulma-file-name-color-l: var(--bulma-text-on-scheme-l);
+}
+.file.is-primary {
+  --bulma-file-h: var(--bulma-primary-h);
+  --bulma-file-s: var(--bulma-primary-s);
+  --bulma-file-background-l: var(--bulma-primary-l);
+  --bulma-file-border-l: var(--bulma-primary-l);
+  --bulma-file-cta-color-l: var(--bulma-primary-invert-l);
+  --bulma-file-name-color-l: var(--bulma-primary-on-scheme-l);
+}
+.file.is-link {
+  --bulma-file-h: var(--bulma-link-h);
+  --bulma-file-s: var(--bulma-link-s);
+  --bulma-file-background-l: var(--bulma-link-l);
+  --bulma-file-border-l: var(--bulma-link-l);
+  --bulma-file-cta-color-l: var(--bulma-link-invert-l);
+  --bulma-file-name-color-l: var(--bulma-link-on-scheme-l);
+}
+.file.is-info {
+  --bulma-file-h: var(--bulma-info-h);
+  --bulma-file-s: var(--bulma-info-s);
+  --bulma-file-background-l: var(--bulma-info-l);
+  --bulma-file-border-l: var(--bulma-info-l);
+  --bulma-file-cta-color-l: var(--bulma-info-invert-l);
+  --bulma-file-name-color-l: var(--bulma-info-on-scheme-l);
+}
+.file.is-success {
+  --bulma-file-h: var(--bulma-success-h);
+  --bulma-file-s: var(--bulma-success-s);
+  --bulma-file-background-l: var(--bulma-success-l);
+  --bulma-file-border-l: var(--bulma-success-l);
+  --bulma-file-cta-color-l: var(--bulma-success-invert-l);
+  --bulma-file-name-color-l: var(--bulma-success-on-scheme-l);
+}
+.file.is-warning {
+  --bulma-file-h: var(--bulma-warning-h);
+  --bulma-file-s: var(--bulma-warning-s);
+  --bulma-file-background-l: var(--bulma-warning-l);
+  --bulma-file-border-l: var(--bulma-warning-l);
+  --bulma-file-cta-color-l: var(--bulma-warning-invert-l);
+  --bulma-file-name-color-l: var(--bulma-warning-on-scheme-l);
+}
+.file.is-danger {
+  --bulma-file-h: var(--bulma-danger-h);
+  --bulma-file-s: var(--bulma-danger-s);
+  --bulma-file-background-l: var(--bulma-danger-l);
+  --bulma-file-border-l: var(--bulma-danger-l);
+  --bulma-file-cta-color-l: var(--bulma-danger-invert-l);
+  --bulma-file-name-color-l: var(--bulma-danger-on-scheme-l);
+}
+.file.is-small {
+  font-size: var(--bulma-size-small);
+}
+.file.is-normal {
+  font-size: var(--bulma-size-normal);
+}
+.file.is-medium {
+  font-size: var(--bulma-size-medium);
+}
+.file.is-medium .file-icon .fa {
+  font-size: 1.5rem;
+}
+.file.is-large {
+  font-size: var(--bulma-size-large);
+}
+.file.is-large .file-icon .fa {
+  font-size: 2rem;
+}
+.file.has-name .file-cta {
+  border-end-end-radius: 0;
+  border-start-end-radius: 0;
+}
+.file.has-name .file-name {
+  border-end-start-radius: 0;
+  border-start-start-radius: 0;
+}
+.file.has-name.is-empty .file-cta {
+  border-radius: var(--bulma-file-radius);
+}
+.file.has-name.is-empty .file-name {
+  display: none;
+}
+.file.is-boxed .file-label {
+  flex-direction: column;
+}
+.file.is-boxed .file-cta {
+  flex-direction: column;
+  height: auto;
+  padding: 1em 3em;
+}
+.file.is-boxed .file-name {
+  border-width: 0 1px 1px;
+}
+.file.is-boxed .file-icon {
+  height: 1.5em;
+  width: 1.5em;
+}
+.file.is-boxed .file-icon .fa {
+  font-size: 1.5rem;
+}
+.file.is-boxed.is-small .file-icon .fa {
+  font-size: 1rem;
+}
+.file.is-boxed.is-medium .file-icon .fa {
+  font-size: 2rem;
+}
+.file.is-boxed.is-large .file-icon .fa {
+  font-size: 2.5rem;
+}
+.file.is-boxed.has-name .file-cta {
+  border-end-end-radius: 0;
+  border-end-start-radius: 0;
+  border-start-end-radius: var(--bulma-file-radius);
+  border-start-start-radius: var(--bulma-file-radius);
+}
+.file.is-boxed.has-name .file-name {
+  border-end-end-radius: var(--bulma-file-radius);
+  border-end-start-radius: var(--bulma-file-radius);
+  border-start-end-radius: 0;
+  border-start-start-radius: 0;
+  border-width: 0 1px 1px;
+}
+.file.is-centered {
+  justify-content: center;
+}
+.file.is-fullwidth .file-label {
+  width: 100%;
+}
+.file.is-fullwidth .file-name {
+  flex-grow: 1;
+  max-width: none;
+}
+.file.is-right {
+  justify-content: flex-end;
+}
+.file.is-right .file-cta {
+  border-radius: 0 var(--bulma-file-radius) var(--bulma-file-radius) 0;
+}
+.file.is-right .file-name {
+  border-radius: var(--bulma-file-radius) 0 0 var(--bulma-file-radius);
+  border-width: 1px 0 1px 1px;
+  order: -1;
+}
+
+.file-label {
+  align-items: stretch;
+  display: flex;
+  cursor: pointer;
+  justify-content: flex-start;
+  overflow: hidden;
+  position: relative;
+}
+.file-label:hover {
+  --bulma-file-background-l-delta: var(--bulma-file-hover-background-l-delta);
+  --bulma-file-border-l-delta: var(--bulma-file-hover-border-l-delta);
+  --bulma-file-color-l-delta: var(--bulma-file-hover-color-l-delta);
+}
+.file-label:active {
+  --bulma-file-background-l-delta: var(--bulma-file-active-background-l-delta);
+  --bulma-file-border-l-delta: var(--bulma-file-active-border-l-delta);
+  --bulma-file-color-l-delta: var(--bulma-file-active-color-l-delta);
+}
+
+.file-input {
+  height: 100%;
+  left: 0;
+  opacity: 0;
+  outline: none;
+  position: absolute;
+  top: 0;
+  width: 100%;
+}
+
+.file-cta,
+.file-name {
+  border-color: hsl(var(--bulma-file-h), var(--bulma-file-s), calc(var(--bulma-file-border-l) + var(--bulma-file-border-l-delta)));
+  border-radius: var(--bulma-file-radius);
+  font-size: 1em;
+  padding-left: 1em;
+  padding-right: 1em;
+  white-space: nowrap;
+}
+
+.file-cta {
+  background-color: hsl(var(--bulma-file-h), var(--bulma-file-s), calc(var(--bulma-file-background-l) + var(--bulma-file-background-l-delta)));
+  color: hsl(var(--bulma-file-h), var(--bulma-file-s), calc(var(--bulma-file-cta-color-l) + var(--bulma-file-color-l-delta)));
+}
+
+.file-name {
+  border-color: hsl(var(--bulma-file-h), var(--bulma-file-s), calc(var(--bulma-file-border-l) + var(--bulma-file-color-l-delta)));
+  border-style: var(--bulma-file-name-border-style);
+  border-width: var(--bulma-file-name-border-width);
+  color: hsl(var(--bulma-file-h), var(--bulma-file-s), calc(var(--bulma-file-name-color-l) + var(--bulma-file-color-l-delta)));
+  display: block;
+  max-width: var(--bulma-file-name-max-width);
+  overflow: hidden;
+  text-align: inherit;
+  text-overflow: ellipsis;
+}
+
+.file-icon {
+  align-items: center;
+  display: flex;
+  height: 1em;
+  justify-content: center;
+  margin-inline-end: 0.5em;
+  width: 1em;
+}
+.file-icon .fa {
+  font-size: 1rem;
+}
+
+/* Bulma Form */
+:root {
+  --bulma-label-color: var(--bulma-text-strong);
+  --bulma-label-spacing: 0.5em;
+  --bulma-label-weight: var(--bulma-weight-semibold);
+  --bulma-help-size: var(--bulma-size-small);
+  --bulma-field-block-spacing: 0.75rem;
+}
+
+.label {
+  color: var(--bulma-label-color);
+  display: block;
+  font-size: var(--bulma-size-normal);
+  font-weight: var(--bulma-weight-semibold);
+}
+.label:not(:last-child) {
+  margin-bottom: var(--bulma-label-spacing);
+}
+.label.is-small {
+  font-size: var(--bulma-size-small);
+}
+.label.is-medium {
+  font-size: var(--bulma-size-medium);
+}
+.label.is-large {
+  font-size: var(--bulma-size-large);
+}
+
+.help {
+  display: block;
+  font-size: var(--bulma-help-size);
+  margin-top: 0.25rem;
+}
+.help.is-white {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-on-scheme-l));
+}
+.help.is-black {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-on-scheme-l));
+}
+.help.is-light {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-on-scheme-l));
+}
+.help.is-dark {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-on-scheme-l));
+}
+.help.is-text {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-on-scheme-l));
+}
+.help.is-primary {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-on-scheme-l));
+}
+.help.is-link {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-on-scheme-l));
+}
+.help.is-info {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-on-scheme-l));
+}
+.help.is-success {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-on-scheme-l));
+}
+.help.is-warning {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-on-scheme-l));
+}
+.help.is-danger {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-on-scheme-l));
+}
+
+.field {
+  --bulma-block-spacing: var(--bulma-field-block-spacing);
+}
+.field.has-addons {
+  display: flex;
+  justify-content: flex-start;
+}
+.field.has-addons .control:not(:last-child) {
+  margin-inline-end: -1px;
+}
+.field.has-addons .control:not(:first-child):not(:last-child) .button,
+.field.has-addons .control:not(:first-child):not(:last-child) .input,
+.field.has-addons .control:not(:first-child):not(:last-child) .select select {
+  border-radius: 0;
+}
+.field.has-addons .control:first-child:not(:only-child) .button,
+.field.has-addons .control:first-child:not(:only-child) .input,
+.field.has-addons .control:first-child:not(:only-child) .select select {
+  border-start-end-radius: 0;
+  border-end-end-radius: 0;
+}
+.field.has-addons .control:last-child:not(:only-child) .button,
+.field.has-addons .control:last-child:not(:only-child) .input,
+.field.has-addons .control:last-child:not(:only-child) .select select {
+  border-start-start-radius: 0;
+  border-end-start-radius: 0;
+}
+.field.has-addons .control .button:not([disabled]):hover, .field.has-addons .control .button:not([disabled]).is-hovered,
+.field.has-addons .control .input:not([disabled]):hover,
+.field.has-addons .control .input:not([disabled]).is-hovered,
+.field.has-addons .control .select select:not([disabled]):hover,
+.field.has-addons .control .select select:not([disabled]).is-hovered {
+  z-index: 2;
+}
+.field.has-addons .control .button:not([disabled]):focus, .field.has-addons .control .button:not([disabled]).is-focused, .field.has-addons .control .button:not([disabled]):active, .field.has-addons .control .button:not([disabled]).is-active,
+.field.has-addons .control .input:not([disabled]):focus,
+.field.has-addons .control .input:not([disabled]).is-focused,
+.field.has-addons .control .input:not([disabled]):active,
+.field.has-addons .control .input:not([disabled]).is-active,
+.field.has-addons .control .select select:not([disabled]):focus,
+.field.has-addons .control .select select:not([disabled]).is-focused,
+.field.has-addons .control .select select:not([disabled]):active,
+.field.has-addons .control .select select:not([disabled]).is-active {
+  z-index: 3;
+}
+.field.has-addons .control .button:not([disabled]):focus:hover, .field.has-addons .control .button:not([disabled]).is-focused:hover, .field.has-addons .control .button:not([disabled]):active:hover, .field.has-addons .control .button:not([disabled]).is-active:hover,
+.field.has-addons .control .input:not([disabled]):focus:hover,
+.field.has-addons .control .input:not([disabled]).is-focused:hover,
+.field.has-addons .control .input:not([disabled]):active:hover,
+.field.has-addons .control .input:not([disabled]).is-active:hover,
+.field.has-addons .control .select select:not([disabled]):focus:hover,
+.field.has-addons .control .select select:not([disabled]).is-focused:hover,
+.field.has-addons .control .select select:not([disabled]):active:hover,
+.field.has-addons .control .select select:not([disabled]).is-active:hover {
+  z-index: 4;
+}
+.field.has-addons .control.is-expanded {
+  flex-grow: 1;
+  flex-shrink: 1;
+}
+.field.has-addons.has-addons-centered {
+  justify-content: center;
+}
+.field.has-addons.has-addons-right {
+  justify-content: flex-end;
+}
+.field.has-addons.has-addons-fullwidth .control {
+  flex-grow: 1;
+  flex-shrink: 0;
+}
+.field.is-grouped {
+  display: flex;
+  gap: 0.75rem;
+  justify-content: flex-start;
+}
+.field.is-grouped > .control {
+  flex-shrink: 0;
+}
+.field.is-grouped > .control.is-expanded {
+  flex-grow: 1;
+  flex-shrink: 1;
+}
+.field.is-grouped.is-grouped-centered {
+  justify-content: center;
+}
+.field.is-grouped.is-grouped-right {
+  justify-content: flex-end;
+}
+.field.is-grouped.is-grouped-multiline {
+  flex-wrap: wrap;
+}
+@media screen and (min-width: 769px), print {
+  .field.is-horizontal {
+    display: flex;
+  }
+}
+
+.field-label .label {
+  font-size: inherit;
+}
+@media screen and (max-width: 768px) {
+  .field-label {
+    margin-bottom: 0.5rem;
+  }
+}
+@media screen and (min-width: 769px), print {
+  .field-label {
+    flex-basis: 0;
+    flex-grow: 1;
+    flex-shrink: 0;
+    margin-inline-end: 1.5rem;
+    text-align: right;
+  }
+  .field-label.is-small {
+    font-size: var(--bulma-size-small);
+    padding-top: 0.375em;
+  }
+  .field-label.is-normal {
+    padding-top: 0.375em;
+  }
+  .field-label.is-medium {
+    font-size: var(--bulma-size-medium);
+    padding-top: 0.375em;
+  }
+  .field-label.is-large {
+    font-size: var(--bulma-size-large);
+    padding-top: 0.375em;
+  }
+}
+
+.field-body .field .field {
+  margin-bottom: 0;
+}
+@media screen and (min-width: 769px), print {
+  .field-body {
+    display: flex;
+    flex-basis: 0;
+    flex-grow: 5;
+    flex-shrink: 1;
+  }
+  .field-body .field {
+    margin-bottom: 0;
+  }
+  .field-body > .field {
+    flex-shrink: 1;
+  }
+  .field-body > .field:not(.is-narrow) {
+    flex-grow: 1;
+  }
+  .field-body > .field:not(:last-child) {
+    margin-inline-end: 0.75rem;
+  }
+}
+
+.control {
+  box-sizing: border-box;
+  clear: both;
+  font-size: var(--bulma-size-normal);
+  position: relative;
+  text-align: inherit;
+}
+.control.has-icons-left .input:hover ~ .icon,
+.control.has-icons-left .select:hover ~ .icon, .control.has-icons-right .input:hover ~ .icon,
+.control.has-icons-right .select:hover ~ .icon {
+  color: var(--bulma-input-icon-hover-color);
+}
+.control.has-icons-left .input:focus ~ .icon,
+.control.has-icons-left .select:focus ~ .icon, .control.has-icons-right .input:focus ~ .icon,
+.control.has-icons-right .select:focus ~ .icon {
+  color: var(--bulma-input-icon-focus-color);
+}
+.control.has-icons-left .input.is-small ~ .icon,
+.control.has-icons-left .select.is-small ~ .icon, .control.has-icons-right .input.is-small ~ .icon,
+.control.has-icons-right .select.is-small ~ .icon {
+  font-size: var(--bulma-size-small);
+}
+.control.has-icons-left .input.is-medium ~ .icon,
+.control.has-icons-left .select.is-medium ~ .icon, .control.has-icons-right .input.is-medium ~ .icon,
+.control.has-icons-right .select.is-medium ~ .icon {
+  font-size: var(--bulma-size-medium);
+}
+.control.has-icons-left .input.is-large ~ .icon,
+.control.has-icons-left .select.is-large ~ .icon, .control.has-icons-right .input.is-large ~ .icon,
+.control.has-icons-right .select.is-large ~ .icon {
+  font-size: var(--bulma-size-large);
+}
+.control.has-icons-left .icon, .control.has-icons-right .icon {
+  color: var(--bulma-input-icon-color);
+  height: var(--bulma-input-height);
+  pointer-events: none;
+  position: absolute;
+  top: 0;
+  width: var(--bulma-input-height);
+  z-index: 4;
+}
+.control.has-icons-left .input,
+.control.has-icons-left .select select {
+  padding-left: var(--bulma-input-height);
+}
+.control.has-icons-left .icon.is-left {
+  left: 0;
+}
+.control.has-icons-right .input,
+.control.has-icons-right .select select {
+  padding-right: var(--bulma-input-height);
+}
+.control.has-icons-right .icon.is-right {
+  right: 0;
+}
+.control.is-loading::after {
+  inset-inline-end: 0.75em;
+  position: absolute !important;
+  top: 0.75em;
+  z-index: 4;
+}
+.control.is-loading.is-small:after {
+  font-size: var(--bulma-size-small);
+}
+.control.is-loading.is-medium:after {
+  font-size: var(--bulma-size-medium);
+}
+.control.is-loading.is-large:after {
+  font-size: var(--bulma-size-large);
+}
+
+/* Bulma Components */
+.breadcrumb {
+  --bulma-breadcrumb-item-color: var(--bulma-link-text);
+  --bulma-breadcrumb-item-hover-color: var(--bulma-link-text-hover);
+  --bulma-breadcrumb-item-active-color: var(--bulma-link-text-active);
+  --bulma-breadcrumb-item-padding-vertical: 0;
+  --bulma-breadcrumb-item-padding-horizontal: 0.75em;
+  --bulma-breadcrumb-item-separator-color: var(--bulma-border);
+}
+
+.breadcrumb {
+  font-size: var(--bulma-size-normal);
+  white-space: nowrap;
+}
+.breadcrumb a {
+  align-items: center;
+  color: var(--bulma-breadcrumb-item-color);
+  display: flex;
+  justify-content: center;
+  padding: var(--bulma-breadcrumb-item-padding-vertical) var(--bulma-breadcrumb-item-padding-horizontal);
+}
+.breadcrumb a:hover {
+  color: var(--bulma-breadcrumb-item-hover-color);
+}
+.breadcrumb li {
+  align-items: center;
+  display: flex;
+}
+.breadcrumb li:first-child a {
+  padding-inline-start: 0;
+}
+.breadcrumb li.is-active a {
+  color: var(--bulma-breadcrumb-item-active-color);
+  cursor: default;
+  pointer-events: none;
+}
+.breadcrumb li + li::before {
+  color: var(--bulma-breadcrumb-item-separator-color);
+  content: "/";
+}
+.breadcrumb ul,
+.breadcrumb ol {
+  align-items: flex-start;
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: flex-start;
+}
+.breadcrumb .icon:first-child {
+  margin-inline-end: 0.5em;
+}
+.breadcrumb .icon:last-child {
+  margin-inline-start: 0.5em;
+}
+.breadcrumb.is-centered ol,
+.breadcrumb.is-centered ul {
+  justify-content: center;
+}
+.breadcrumb.is-right ol,
+.breadcrumb.is-right ul {
+  justify-content: flex-end;
+}
+.breadcrumb.is-small {
+  font-size: var(--bulma-size-small);
+}
+.breadcrumb.is-medium {
+  font-size: var(--bulma-size-medium);
+}
+.breadcrumb.is-large {
+  font-size: var(--bulma-size-large);
+}
+.breadcrumb.has-arrow-separator li + li::before {
+  content: "→";
+}
+.breadcrumb.has-bullet-separator li + li::before {
+  content: "•";
+}
+.breadcrumb.has-dot-separator li + li::before {
+  content: "·";
+}
+.breadcrumb.has-succeeds-separator li + li::before {
+  content: "≻";
+}
+
+.card {
+  --bulma-card-color: var(--bulma-text);
+  --bulma-card-background-color: var(--bulma-scheme-main);
+  --bulma-card-shadow: var(--bulma-shadow);
+  --bulma-card-radius: 0.75rem;
+  --bulma-card-header-background-color: transparent;
+  --bulma-card-header-color: var(--bulma-text-strong);
+  --bulma-card-header-padding: 0.75rem 1rem;
+  --bulma-card-header-shadow: 0 0.125em 0.25em hsla(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-scheme-invert-l), 0.1);
+  --bulma-card-header-weight: var(--bulma-weight-bold);
+  --bulma-card-content-background-color: transparent;
+  --bulma-card-content-padding: 1.5rem;
+  --bulma-card-footer-background-color: transparent;
+  --bulma-card-footer-border-top: 1px solid var(--bulma-border-weak);
+  --bulma-card-footer-padding: 0.75rem;
+  --bulma-card-media-margin: var(--bulma-block-spacing);
+}
+
+.card {
+  background-color: var(--bulma-card-background-color);
+  border-radius: var(--bulma-card-radius);
+  box-shadow: var(--bulma-card-shadow);
+  color: var(--bulma-card-color);
+  max-width: 100%;
+  position: relative;
+}
+
+.card-footer:first-child, .card-content:first-child, .card-header:first-child {
+  border-start-start-radius: var(--bulma-card-radius);
+  border-start-end-radius: var(--bulma-card-radius);
+}
+.card-footer:last-child, .card-content:last-child, .card-header:last-child {
+  border-end-start-radius: var(--bulma-card-radius);
+  border-end-end-radius: var(--bulma-card-radius);
+}
+
+.card-header {
+  background-color: var(--bulma-card-header-background-color);
+  align-items: stretch;
+  box-shadow: var(--bulma-card-header-shadow);
+  display: flex;
+}
+
+.card-header-title {
+  align-items: center;
+  color: var(--bulma-card-header-color);
+  display: flex;
+  flex-grow: 1;
+  font-weight: var(--bulma-card-header-weight);
+  padding: var(--bulma-card-header-padding);
+}
+.card-header-title.is-centered {
+  justify-content: center;
+}
+
+.card-header-icon {
+  appearance: none;
+  background: none;
+  border: none;
+  color: inherit;
+  font-family: inherit;
+  font-size: 1em;
+  margin: 0;
+  padding: 0;
+  align-items: center;
+  cursor: pointer;
+  display: flex;
+  justify-content: center;
+  padding: var(--bulma-card-header-padding);
+}
+
+.card-image {
+  display: block;
+  position: relative;
+}
+.card-image:first-child img {
+  border-start-start-radius: var(--bulma-card-radius);
+  border-start-end-radius: var(--bulma-card-radius);
+}
+.card-image:last-child img {
+  border-end-start-radius: var(--bulma-card-radius);
+  border-end-end-radius: var(--bulma-card-radius);
+}
+
+.card-content {
+  background-color: var(--bulma-card-content-background-color);
+  padding: var(--bulma-card-content-padding);
+}
+
+.card-footer {
+  background-color: var(--bulma-card-footer-background-color);
+  border-top: var(--bulma-card-footer-border-top);
+  align-items: stretch;
+  display: flex;
+}
+
+.card-footer-item {
+  align-items: center;
+  display: flex;
+  flex-basis: 0;
+  flex-grow: 1;
+  flex-shrink: 0;
+  justify-content: center;
+  padding: var(--bulma-card-footer-padding);
+}
+.card-footer-item:not(:last-child) {
+  border-inline-end: var(--bulma-card-footer-border-top);
+}
+
+.card .media:not(:last-child) {
+  margin-bottom: var(--bulma-card-media-margin);
+}
+
+.dropdown {
+  --bulma-dropdown-menu-min-width: 12rem;
+  --bulma-dropdown-content-background-color: var(--bulma-scheme-main);
+  --bulma-dropdown-content-offset: 0.25rem;
+  --bulma-dropdown-content-padding-bottom: 0.5rem;
+  --bulma-dropdown-content-padding-top: 0.5rem;
+  --bulma-dropdown-content-radius: var(--bulma-radius);
+  --bulma-dropdown-content-shadow: var(--bulma-shadow);
+  --bulma-dropdown-content-z: 20;
+  --bulma-dropdown-item-h: var(--bulma-scheme-h);
+  --bulma-dropdown-item-s: var(--bulma-scheme-s);
+  --bulma-dropdown-item-l: var(--bulma-scheme-main-l);
+  --bulma-dropdown-item-background-l: var(--bulma-scheme-main-l);
+  --bulma-dropdown-item-background-l-delta: 0%;
+  --bulma-dropdown-item-hover-background-l-delta: var(--bulma-hover-background-l-delta);
+  --bulma-dropdown-item-active-background-l-delta: var(--bulma-active-background-l-delta);
+  --bulma-dropdown-item-color-l: var(--bulma-text-strong-l);
+  --bulma-dropdown-item-selected-h: var(--bulma-link-h);
+  --bulma-dropdown-item-selected-s: var(--bulma-link-s);
+  --bulma-dropdown-item-selected-l: var(--bulma-link-l);
+  --bulma-dropdown-item-selected-background-l: var(--bulma-link-l);
+  --bulma-dropdown-item-selected-color-l: var(--bulma-link-invert-l);
+  --bulma-dropdown-divider-background-color: var(--bulma-border-weak);
+}
+
+.dropdown {
+  display: inline-flex;
+  position: relative;
+  vertical-align: top;
+}
+.dropdown.is-active .dropdown-menu, .dropdown.is-hoverable:hover .dropdown-menu {
+  display: block;
+}
+.dropdown.is-right .dropdown-menu {
+  left: auto;
+  right: 0;
+}
+.dropdown.is-up .dropdown-menu {
+  bottom: 100%;
+  padding-bottom: var(--bulma-dropdown-content-offset);
+  padding-top: initial;
+  top: auto;
+}
+
+.dropdown-menu {
+  display: none;
+  left: 0;
+  min-width: var(--bulma-dropdown-menu-min-width);
+  padding-top: var(--bulma-dropdown-content-offset);
+  position: absolute;
+  top: 100%;
+  z-index: var(--bulma-dropdown-content-z);
+}
+
+.dropdown-content {
+  background-color: var(--bulma-dropdown-content-background-color);
+  border-radius: var(--bulma-dropdown-content-radius);
+  box-shadow: var(--bulma-dropdown-content-shadow);
+  padding-bottom: var(--bulma-dropdown-content-padding-bottom);
+  padding-top: var(--bulma-dropdown-content-padding-top);
+}
+
+.dropdown-item {
+  color: hsl(var(--bulma-dropdown-item-h), var(--bulma-dropdown-item-s), var(--bulma-dropdown-item-color-l));
+  display: block;
+  font-size: 0.875rem;
+  line-height: 1.5;
+  padding: 0.375rem 1rem;
+}
+
+a.dropdown-item,
+button.dropdown-item {
+  background-color: hsl(var(--bulma-dropdown-item-h), var(--bulma-dropdown-item-s), calc(var(--bulma-dropdown-item-background-l) + var(--bulma-dropdown-item-background-l-delta)));
+  padding-inline-end: 3rem;
+  text-align: inherit;
+  white-space: nowrap;
+  width: 100%;
+}
+a.dropdown-item:hover,
+button.dropdown-item:hover {
+  --bulma-dropdown-item-background-l-delta: var(--bulma-dropdown-item-hover-background-l-delta);
+  --bulma-dropdown-item-border-l-delta: var(--bulma-dropdown-item-hover-border-l-delta);
+}
+a.dropdown-item:active,
+button.dropdown-item:active {
+  --bulma-dropdown-item-background-l-delta: var(--bulma-dropdown-item-active-background-l-delta);
+  --bulma-dropdown-item-border-l-delta: var(--bulma-dropdown-item-active-border-l-delta);
+}
+a.dropdown-item.is-active, a.dropdown-item.is-selected,
+button.dropdown-item.is-active,
+button.dropdown-item.is-selected {
+  --bulma-dropdown-item-h: var(--bulma-dropdown-item-selected-h);
+  --bulma-dropdown-item-s: var(--bulma-dropdown-item-selected-s);
+  --bulma-dropdown-item-l: var(--bulma-dropdown-item-selected-l);
+  --bulma-dropdown-item-background-l: var(--bulma-dropdown-item-selected-background-l);
+  --bulma-dropdown-item-color-l: var(--bulma-dropdown-item-selected-color-l);
+}
+
+.dropdown-divider {
+  background-color: var(--bulma-dropdown-divider-background-color);
+  border: none;
+  display: block;
+  height: 1px;
+  margin: 0.5rem 0;
+}
+
+.menu {
+  --bulma-menu-item-h: var(--bulma-scheme-h);
+  --bulma-menu-item-s: var(--bulma-scheme-s);
+  --bulma-menu-item-l: var(--bulma-scheme-main-l);
+  --bulma-menu-item-background-l: var(--bulma-scheme-main-l);
+  --bulma-menu-item-background-l-delta: 0%;
+  --bulma-menu-item-hover-background-l-delta: var(--bulma-hover-background-l-delta);
+  --bulma-menu-item-active-background-l-delta: var(--bulma-active-background-l-delta);
+  --bulma-menu-item-color-l: var(--bulma-text-l);
+  --bulma-menu-item-radius: var(--bulma-radius-small);
+  --bulma-menu-item-selected-h: var(--bulma-link-h);
+  --bulma-menu-item-selected-s: var(--bulma-link-s);
+  --bulma-menu-item-selected-l: var(--bulma-link-l);
+  --bulma-menu-item-selected-background-l: var(--bulma-link-l);
+  --bulma-menu-item-selected-color-l: var(--bulma-link-invert-l);
+  --bulma-menu-list-border-left: 1px solid var(--bulma-border);
+  --bulma-menu-list-line-height: 1.25;
+  --bulma-menu-list-link-padding: 0.5em 0.75em;
+  --bulma-menu-nested-list-margin: 0.75em;
+  --bulma-menu-nested-list-padding-left: 0.75em;
+  --bulma-menu-label-color: var(--bulma-text-weak);
+  --bulma-menu-label-font-size: 0.75em;
+  --bulma-menu-label-letter-spacing: 0.1em;
+  --bulma-menu-label-spacing: 1em;
+}
+
+.menu {
+  font-size: var(--bulma-size-normal);
+}
+.menu.is-small {
+  font-size: var(--bulma-size-small);
+}
+.menu.is-medium {
+  font-size: var(--bulma-size-medium);
+}
+.menu.is-large {
+  font-size: var(--bulma-size-large);
+}
+
+.menu-list {
+  line-height: var(--bulma-menu-list-line-height);
+}
+.menu-list a,
+.menu-list button,
+.menu-list .menu-item {
+  background-color: hsl(var(--bulma-menu-item-h), var(--bulma-menu-item-s), calc(var(--bulma-menu-item-background-l) + var(--bulma-menu-item-background-l-delta)));
+  border-radius: var(--bulma-menu-item-radius);
+  color: hsl(var(--bulma-menu-item-h), var(--bulma-menu-item-s), var(--bulma-menu-item-color-l));
+  display: block;
+  padding: var(--bulma-menu-list-link-padding);
+  text-align: left;
+  width: 100%;
+}
+.menu-list a:hover,
+.menu-list button:hover,
+.menu-list .menu-item:hover {
+  --bulma-menu-item-background-l-delta: var(--bulma-menu-item-hover-background-l-delta);
+}
+.menu-list a:active,
+.menu-list button:active,
+.menu-list .menu-item:active {
+  --bulma-menu-item-background-l-delta: var(--bulma-menu-item-active-background-l-delta);
+}
+.menu-list a.is-active, .menu-list a.is-selected,
+.menu-list button.is-active,
+.menu-list button.is-selected,
+.menu-list .menu-item.is-active,
+.menu-list .menu-item.is-selected {
+  --bulma-menu-item-h: var(--bulma-menu-item-selected-h);
+  --bulma-menu-item-s: var(--bulma-menu-item-selected-s);
+  --bulma-menu-item-l: var(--bulma-menu-item-selected-l);
+  --bulma-menu-item-background-l: var(--bulma-menu-item-selected-background-l);
+  --bulma-menu-item-color-l: var(--bulma-menu-item-selected-color-l);
+}
+.menu-list li ul {
+  border-inline-start: var(--bulma-menu-list-border-left);
+  margin: var(--bulma-menu-nested-list-margin);
+  padding-inline-start: var(--bulma-menu-nested-list-padding-left);
+}
+
+.menu-label {
+  color: var(--bulma-menu-label-color);
+  font-size: var(--bulma-menu-label-font-size);
+  letter-spacing: var(--bulma-menu-label-letter-spacing);
+  text-transform: uppercase;
+}
+.menu-label:not(:first-child) {
+  margin-top: var(--bulma-menu-label-spacing);
+}
+.menu-label:not(:last-child) {
+  margin-bottom: var(--bulma-menu-label-spacing);
+}
+
+.message {
+  --bulma-message-border-l-delta: -20%;
+  --bulma-message-radius: var(--bulma-radius);
+  --bulma-message-header-weight: var(--bulma-weight-semibold);
+  --bulma-message-header-padding: 1em 1.25em;
+  --bulma-message-header-radius: var(--bulma-radius);
+  --bulma-message-body-border-width: 0 0 0 4px;
+  --bulma-message-body-color: var(--bulma-text);
+  --bulma-message-body-padding: 1.25em 1.5em;
+  --bulma-message-body-radius: var(--bulma-radius-small);
+  --bulma-message-body-pre-code-background-color: transparent;
+  --bulma-message-header-body-border-width: 0;
+  --bulma-message-h: var(--bulma-scheme-h);
+  --bulma-message-s: var(--bulma-scheme-s);
+  --bulma-message-background-l: var(--bulma-background-l);
+  --bulma-message-border-l: var(--bulma-border-l);
+  --bulma-message-border-style: solid;
+  --bulma-message-border-width: 0.25em;
+  --bulma-message-color-l: var(--bulma-text-l);
+  --bulma-message-header-background-l: var(--bulma-dark-l);
+  --bulma-message-header-color-l: var(--bulma-text-dark-invert-l);
+}
+
+.message {
+  border-radius: var(--bulma-message-radius);
+  color: hsl(var(--bulma-message-h), var(--bulma-message-s), var(--bulma-message-color-l));
+  font-size: var(--bulma-size-normal);
+}
+.message strong {
+  color: currentColor;
+}
+.message a:not(.button):not(.tag):not(.dropdown-item) {
+  color: currentColor;
+  text-decoration: underline;
+}
+.message.is-small {
+  font-size: var(--bulma-size-small);
+}
+.message.is-medium {
+  font-size: var(--bulma-size-medium);
+}
+.message.is-large {
+  font-size: var(--bulma-size-large);
+}
+.message.is-white {
+  --bulma-message-h: var(--bulma-white-h);
+  --bulma-message-s: var(--bulma-white-s);
+  --bulma-message-border-l: calc(var(--bulma-white-l) + var(--bulma-message-border-l-delta));
+  --bulma-message-color-l: var(--bulma-white-on-scheme-l);
+  --bulma-message-header-background-l: var(--bulma-white-l);
+  --bulma-message-header-color-l: var(--bulma-white-invert-l);
+}
+.message.is-black {
+  --bulma-message-h: var(--bulma-black-h);
+  --bulma-message-s: var(--bulma-black-s);
+  --bulma-message-border-l: calc(var(--bulma-black-l) + var(--bulma-message-border-l-delta));
+  --bulma-message-color-l: var(--bulma-black-on-scheme-l);
+  --bulma-message-header-background-l: var(--bulma-black-l);
+  --bulma-message-header-color-l: var(--bulma-black-invert-l);
+}
+.message.is-light {
+  --bulma-message-h: var(--bulma-light-h);
+  --bulma-message-s: var(--bulma-light-s);
+  --bulma-message-border-l: calc(var(--bulma-light-l) + var(--bulma-message-border-l-delta));
+  --bulma-message-color-l: var(--bulma-light-on-scheme-l);
+  --bulma-message-header-background-l: var(--bulma-light-l);
+  --bulma-message-header-color-l: var(--bulma-light-invert-l);
+}
+.message.is-dark {
+  --bulma-message-h: var(--bulma-dark-h);
+  --bulma-message-s: var(--bulma-dark-s);
+  --bulma-message-border-l: calc(var(--bulma-dark-l) + var(--bulma-message-border-l-delta));
+  --bulma-message-color-l: var(--bulma-dark-on-scheme-l);
+  --bulma-message-header-background-l: var(--bulma-dark-l);
+  --bulma-message-header-color-l: var(--bulma-dark-invert-l);
+}
+.message.is-text {
+  --bulma-message-h: var(--bulma-text-h);
+  --bulma-message-s: var(--bulma-text-s);
+  --bulma-message-border-l: calc(var(--bulma-text-l) + var(--bulma-message-border-l-delta));
+  --bulma-message-color-l: var(--bulma-text-on-scheme-l);
+  --bulma-message-header-background-l: var(--bulma-text-l);
+  --bulma-message-header-color-l: var(--bulma-text-invert-l);
+}
+.message.is-primary {
+  --bulma-message-h: var(--bulma-primary-h);
+  --bulma-message-s: var(--bulma-primary-s);
+  --bulma-message-border-l: calc(var(--bulma-primary-l) + var(--bulma-message-border-l-delta));
+  --bulma-message-color-l: var(--bulma-primary-on-scheme-l);
+  --bulma-message-header-background-l: var(--bulma-primary-l);
+  --bulma-message-header-color-l: var(--bulma-primary-invert-l);
+}
+.message.is-link {
+  --bulma-message-h: var(--bulma-link-h);
+  --bulma-message-s: var(--bulma-link-s);
+  --bulma-message-border-l: calc(var(--bulma-link-l) + var(--bulma-message-border-l-delta));
+  --bulma-message-color-l: var(--bulma-link-on-scheme-l);
+  --bulma-message-header-background-l: var(--bulma-link-l);
+  --bulma-message-header-color-l: var(--bulma-link-invert-l);
+}
+.message.is-info {
+  --bulma-message-h: var(--bulma-info-h);
+  --bulma-message-s: var(--bulma-info-s);
+  --bulma-message-border-l: calc(var(--bulma-info-l) + var(--bulma-message-border-l-delta));
+  --bulma-message-color-l: var(--bulma-info-on-scheme-l);
+  --bulma-message-header-background-l: var(--bulma-info-l);
+  --bulma-message-header-color-l: var(--bulma-info-invert-l);
+}
+.message.is-success {
+  --bulma-message-h: var(--bulma-success-h);
+  --bulma-message-s: var(--bulma-success-s);
+  --bulma-message-border-l: calc(var(--bulma-success-l) + var(--bulma-message-border-l-delta));
+  --bulma-message-color-l: var(--bulma-success-on-scheme-l);
+  --bulma-message-header-background-l: var(--bulma-success-l);
+  --bulma-message-header-color-l: var(--bulma-success-invert-l);
+}
+.message.is-warning {
+  --bulma-message-h: var(--bulma-warning-h);
+  --bulma-message-s: var(--bulma-warning-s);
+  --bulma-message-border-l: calc(var(--bulma-warning-l) + var(--bulma-message-border-l-delta));
+  --bulma-message-color-l: var(--bulma-warning-on-scheme-l);
+  --bulma-message-header-background-l: var(--bulma-warning-l);
+  --bulma-message-header-color-l: var(--bulma-warning-invert-l);
+}
+.message.is-danger {
+  --bulma-message-h: var(--bulma-danger-h);
+  --bulma-message-s: var(--bulma-danger-s);
+  --bulma-message-border-l: calc(var(--bulma-danger-l) + var(--bulma-message-border-l-delta));
+  --bulma-message-color-l: var(--bulma-danger-on-scheme-l);
+  --bulma-message-header-background-l: var(--bulma-danger-l);
+  --bulma-message-header-color-l: var(--bulma-danger-invert-l);
+}
+
+.message-header {
+  align-items: center;
+  background-color: hsl(var(--bulma-message-h), var(--bulma-message-s), var(--bulma-message-header-background-l));
+  border-start-start-radius: var(--bulma-message-header-radius);
+  border-start-end-radius: var(--bulma-message-header-radius);
+  color: hsl(var(--bulma-message-h), var(--bulma-message-s), var(--bulma-message-header-color-l));
+  display: flex;
+  font-weight: var(--bulma-message-header-weight);
+  justify-content: space-between;
+  line-height: 1.25;
+  padding: var(--bulma-message-header-padding);
+  position: relative;
+}
+.message-header .delete {
+  flex-grow: 0;
+  flex-shrink: 0;
+  margin-inline-start: 0.75em;
+}
+.message-header + .message-body {
+  border-width: var(--bulma-message-header-body-border-width);
+  border-start-start-radius: 0;
+  border-start-end-radius: 0;
+}
+
+.message-body {
+  background-color: hsl(var(--bulma-message-h), var(--bulma-message-s), var(--bulma-message-background-l));
+  border-inline-start-color: hsl(var(--bulma-message-h), var(--bulma-message-s), var(--bulma-message-border-l));
+  border-inline-start-style: var(--bulma-message-border-style);
+  border-inline-start-width: var(--bulma-message-border-width);
+  border-radius: var(--bulma-message-body-radius);
+  padding: var(--bulma-message-body-padding);
+}
+.message-body code,
+.message-body pre {
+  background-color: hsl(var(--bulma-message-h), var(--bulma-message-s), var(--bulma-message-header-color-l));
+  color: hsl(var(--bulma-message-h), var(--bulma-message-s), var(--bulma-message-header-background-l));
+}
+.message-body pre code {
+  background-color: var(--bulma-message-body-pre-code-background-color);
+}
+
+.modal {
+  --bulma-modal-z: 40;
+  --bulma-modal-background-background-color: hsla(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-scheme-invert-l), 0.86);
+  --bulma-modal-content-width: 40rem;
+  --bulma-modal-content-margin-mobile: 1.25rem;
+  --bulma-modal-content-spacing-mobile: 10rem;
+  --bulma-modal-content-spacing-tablet: 2.5rem;
+  --bulma-modal-close-dimensions: 2.5rem;
+  --bulma-modal-close-right: 1.25rem;
+  --bulma-modal-close-top: 1.25rem;
+  --bulma-modal-card-spacing: 2.5rem;
+  --bulma-modal-card-head-background-color: var(--bulma-scheme-main);
+  --bulma-modal-card-head-padding: 2rem;
+  --bulma-modal-card-head-radius: var(--bulma-radius-large);
+  --bulma-modal-card-title-color: var(--bulma-text-strong);
+  --bulma-modal-card-title-line-height: 1;
+  --bulma-modal-card-title-size: var(--bulma-size-4);
+  --bulma-modal-card-foot-background-color: var(--bulma-scheme-main-bis);
+  --bulma-modal-card-foot-radius: var(--bulma-radius-large);
+  --bulma-modal-card-body-background-color: var(--bulma-scheme-main);
+  --bulma-modal-card-body-padding: 2rem;
+}
+
+.modal {
+  align-items: center;
+  display: none;
+  flex-direction: column;
+  justify-content: center;
+  overflow: hidden;
+  position: fixed;
+  z-index: var(--bulma-modal-z);
+}
+.modal.is-active {
+  display: flex;
+}
+
+.modal-background {
+  background-color: var(--bulma-modal-background-background-color);
+}
+
+.modal-content,
+.modal-card {
+  margin: 0 var(--bulma-modal-content-margin-mobile);
+  max-height: calc(100vh - var(--bulma-modal-content-spacing-mobile));
+  overflow: auto;
+  position: relative;
+  width: 100%;
+}
+@media screen and (min-width: 769px) {
+  .modal-content,
+  .modal-card {
+    margin: 0 auto;
+    max-height: calc(100vh - var(--bulma-modal-content-spacing-tablet));
+    width: var(--bulma-modal-content-width);
+  }
+}
+
+.modal-close {
+  background: none;
+  height: var(--bulma-modal-close-dimensions);
+  inset-inline-end: var(--bulma-modal-close-right);
+  position: fixed;
+  top: var(--bulma-modal-close-top);
+  width: var(--bulma-modal-close-dimensions);
+}
+
+.modal-card {
+  display: flex;
+  flex-direction: column;
+  max-height: calc(100vh - var(--bulma-modal-card-spacing));
+  overflow: hidden;
+  overflow-y: visible;
+}
+
+.modal-card-head,
+.modal-card-foot {
+  align-items: center;
+  display: flex;
+  flex-shrink: 0;
+  justify-content: flex-start;
+  padding: var(--bulma-modal-card-head-padding);
+  position: relative;
+}
+
+.modal-card-head {
+  background-color: var(--bulma-modal-card-head-background-color);
+  border-start-start-radius: var(--bulma-modal-card-head-radius);
+  border-start-end-radius: var(--bulma-modal-card-head-radius);
+  box-shadow: var(--bulma-shadow);
+}
+
+.modal-card-title {
+  color: var(--bulma-modal-card-title-color);
+  flex-grow: 1;
+  flex-shrink: 0;
+  font-size: var(--bulma-modal-card-title-size);
+  line-height: var(--bulma-modal-card-title-line-height);
+}
+
+.modal-card-foot {
+  background-color: var(--bulma-modal-card-foot-background-color);
+  border-end-start-radius: var(--bulma-modal-card-foot-radius);
+  border-end-end-radius: var(--bulma-modal-card-foot-radius);
+}
+
+.modal-card-body {
+  -webkit-overflow-scrolling: touch;
+  background-color: var(--bulma-modal-card-body-background-color);
+  flex-grow: 1;
+  flex-shrink: 1;
+  overflow: auto;
+  padding: var(--bulma-modal-card-body-padding);
+}
+
+:root {
+  --bulma-navbar-height: 3.25rem;
+}
+
+.navbar {
+  --bulma-navbar-h: var(--bulma-scheme-h);
+  --bulma-navbar-s: var(--bulma-scheme-s);
+  --bulma-navbar-l: var(--bulma-scheme-main-l);
+  --bulma-navbar-background-color: var(--bulma-scheme-main);
+  --bulma-navbar-box-shadow-size: 0 0.125em 0 0;
+  --bulma-navbar-box-shadow-color: var(--bulma-background);
+  --bulma-navbar-padding-vertical: 1rem;
+  --bulma-navbar-padding-horizontal: 2rem;
+  --bulma-navbar-z: 30;
+  --bulma-navbar-fixed-z: 30;
+  --bulma-navbar-item-background-a: 0;
+  --bulma-navbar-item-background-l: var(--bulma-scheme-main-l);
+  --bulma-navbar-item-background-l-delta: 0%;
+  --bulma-navbar-item-hover-background-l-delta: var(--bulma-hover-background-l-delta);
+  --bulma-navbar-item-active-background-l-delta: var(--bulma-active-background-l-delta);
+  --bulma-navbar-item-color-l: var(--bulma-text-l);
+  --bulma-navbar-item-color: hsl(var(--bulma-navbar-h), var(--bulma-navbar-s), var(--bulma-navbar-item-color-l));
+  --bulma-navbar-item-selected-h: var(--bulma-link-h);
+  --bulma-navbar-item-selected-s: var(--bulma-link-s);
+  --bulma-navbar-item-selected-l: var(--bulma-link-l);
+  --bulma-navbar-item-selected-background-l: var(--bulma-link-l);
+  --bulma-navbar-item-selected-color-l: var(--bulma-link-invert-l);
+  --bulma-navbar-item-img-max-height: 1.75rem;
+  --bulma-navbar-burger-color: var(--bulma-link);
+  --bulma-navbar-tab-hover-background-color: transparent;
+  --bulma-navbar-tab-hover-border-bottom-color: var(--bulma-link);
+  --bulma-navbar-tab-active-color: var(--bulma-link);
+  --bulma-navbar-tab-active-background-color: transparent;
+  --bulma-navbar-tab-active-border-bottom-color: var(--bulma-link);
+  --bulma-navbar-tab-active-border-bottom-style: solid;
+  --bulma-navbar-tab-active-border-bottom-width: 0.1875em;
+  --bulma-navbar-dropdown-background-color: var(--bulma-scheme-main);
+  --bulma-navbar-dropdown-border-l: var(--bulma-border-l);
+  --bulma-navbar-dropdown-border-color: hsl(var(--bulma-navbar-h), var(--bulma-navbar-s), var(--bulma-navbar-dropdown-border-l));
+  --bulma-navbar-dropdown-border-style: solid;
+  --bulma-navbar-dropdown-border-width: 0.125em;
+  --bulma-navbar-dropdown-offset: -0.25em;
+  --bulma-navbar-dropdown-arrow: var(--bulma-link);
+  --bulma-navbar-dropdown-radius: var(--bulma-radius-large);
+  --bulma-navbar-dropdown-z: 20;
+  --bulma-navbar-dropdown-boxed-radius: var(--bulma-radius-large);
+  --bulma-navbar-dropdown-boxed-shadow: 0 0.5em 0.5em hsla(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-scheme-invert-l), 0.1), 0 0 0 1px hsla(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-scheme-invert-l), 0.1);
+  --bulma-navbar-dropdown-item-h: var(--bulma-scheme-h);
+  --bulma-navbar-dropdown-item-s: var(--bulma-scheme-s);
+  --bulma-navbar-dropdown-item-l: var(--bulma-scheme-main-l);
+  --bulma-navbar-dropdown-item-background-l: var(--bulma-scheme-main-l);
+  --bulma-navbar-dropdown-item-color-l: var(--bulma-text-l);
+  --bulma-navbar-divider-background-l: var(--bulma-background-l);
+  --bulma-navbar-divider-height: 0.125em;
+  --bulma-navbar-bottom-box-shadow-size: 0 -0.125em 0 0;
+}
+
+.navbar {
+  background-color: var(--bulma-navbar-background-color);
+  min-height: var(--bulma-navbar-height);
+  position: relative;
+  z-index: var(--bulma-navbar-z);
+}
+.navbar.is-white {
+  --bulma-navbar-h: var(--bulma-white-h);
+  --bulma-navbar-s: var(--bulma-white-s);
+  --bulma-navbar-l: var(--bulma-white-l);
+  --bulma-burger-h: var(--bulma-white-h);
+  --bulma-burger-s: var(--bulma-white-s);
+  --bulma-burger-l: var(--bulma-white-invert-l);
+  --bulma-navbar-background-color: var(--bulma-white);
+  --bulma-navbar-item-background-l: var(--bulma-white-l);
+  --bulma-navbar-item-color-l: var(--bulma-white-invert-l);
+  --bulma-navbar-item-selected-h: var(--bulma-white-h);
+  --bulma-navbar-item-selected-s: var(--bulma-white-s);
+  --bulma-navbar-item-selected-l: var(--bulma-white-l);
+  --bulma-navbar-item-selected-background-l: var(--bulma-white-l);
+  --bulma-navbar-item-selected-color-l: var(--bulma-white-invert-l);
+  --bulma-navbar-dropdown-arrow: var(--bulma-white-invert-l);
+  --bulma-navbar-dropdown-background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-navbar-dropdown-item-background-l));
+  --bulma-navbar-dropdown-item-h: var(--bulma-white-h);
+  --bulma-navbar-dropdown-item-s: var(--bulma-white-s);
+}
+.navbar.is-black {
+  --bulma-navbar-h: var(--bulma-black-h);
+  --bulma-navbar-s: var(--bulma-black-s);
+  --bulma-navbar-l: var(--bulma-black-l);
+  --bulma-burger-h: var(--bulma-black-h);
+  --bulma-burger-s: var(--bulma-black-s);
+  --bulma-burger-l: var(--bulma-black-invert-l);
+  --bulma-navbar-background-color: var(--bulma-black);
+  --bulma-navbar-item-background-l: var(--bulma-black-l);
+  --bulma-navbar-item-color-l: var(--bulma-black-invert-l);
+  --bulma-navbar-item-selected-h: var(--bulma-black-h);
+  --bulma-navbar-item-selected-s: var(--bulma-black-s);
+  --bulma-navbar-item-selected-l: var(--bulma-black-l);
+  --bulma-navbar-item-selected-background-l: var(--bulma-black-l);
+  --bulma-navbar-item-selected-color-l: var(--bulma-black-invert-l);
+  --bulma-navbar-dropdown-arrow: var(--bulma-black-invert-l);
+  --bulma-navbar-dropdown-background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-navbar-dropdown-item-background-l));
+  --bulma-navbar-dropdown-item-h: var(--bulma-black-h);
+  --bulma-navbar-dropdown-item-s: var(--bulma-black-s);
+}
+.navbar.is-light {
+  --bulma-navbar-h: var(--bulma-light-h);
+  --bulma-navbar-s: var(--bulma-light-s);
+  --bulma-navbar-l: var(--bulma-light-l);
+  --bulma-burger-h: var(--bulma-light-h);
+  --bulma-burger-s: var(--bulma-light-s);
+  --bulma-burger-l: var(--bulma-light-invert-l);
+  --bulma-navbar-background-color: var(--bulma-light);
+  --bulma-navbar-item-background-l: var(--bulma-light-l);
+  --bulma-navbar-item-color-l: var(--bulma-light-invert-l);
+  --bulma-navbar-item-selected-h: var(--bulma-light-h);
+  --bulma-navbar-item-selected-s: var(--bulma-light-s);
+  --bulma-navbar-item-selected-l: var(--bulma-light-l);
+  --bulma-navbar-item-selected-background-l: var(--bulma-light-l);
+  --bulma-navbar-item-selected-color-l: var(--bulma-light-invert-l);
+  --bulma-navbar-dropdown-arrow: var(--bulma-light-invert-l);
+  --bulma-navbar-dropdown-background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-navbar-dropdown-item-background-l));
+  --bulma-navbar-dropdown-item-h: var(--bulma-light-h);
+  --bulma-navbar-dropdown-item-s: var(--bulma-light-s);
+}
+.navbar.is-dark {
+  --bulma-navbar-h: var(--bulma-dark-h);
+  --bulma-navbar-s: var(--bulma-dark-s);
+  --bulma-navbar-l: var(--bulma-dark-l);
+  --bulma-burger-h: var(--bulma-dark-h);
+  --bulma-burger-s: var(--bulma-dark-s);
+  --bulma-burger-l: var(--bulma-dark-invert-l);
+  --bulma-navbar-background-color: var(--bulma-dark);
+  --bulma-navbar-item-background-l: var(--bulma-dark-l);
+  --bulma-navbar-item-color-l: var(--bulma-dark-invert-l);
+  --bulma-navbar-item-selected-h: var(--bulma-dark-h);
+  --bulma-navbar-item-selected-s: var(--bulma-dark-s);
+  --bulma-navbar-item-selected-l: var(--bulma-dark-l);
+  --bulma-navbar-item-selected-background-l: var(--bulma-dark-l);
+  --bulma-navbar-item-selected-color-l: var(--bulma-dark-invert-l);
+  --bulma-navbar-dropdown-arrow: var(--bulma-dark-invert-l);
+  --bulma-navbar-dropdown-background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-navbar-dropdown-item-background-l));
+  --bulma-navbar-dropdown-item-h: var(--bulma-dark-h);
+  --bulma-navbar-dropdown-item-s: var(--bulma-dark-s);
+}
+.navbar.is-text {
+  --bulma-navbar-h: var(--bulma-text-h);
+  --bulma-navbar-s: var(--bulma-text-s);
+  --bulma-navbar-l: var(--bulma-text-l);
+  --bulma-burger-h: var(--bulma-text-h);
+  --bulma-burger-s: var(--bulma-text-s);
+  --bulma-burger-l: var(--bulma-text-invert-l);
+  --bulma-navbar-background-color: var(--bulma-text);
+  --bulma-navbar-item-background-l: var(--bulma-text-l);
+  --bulma-navbar-item-color-l: var(--bulma-text-invert-l);
+  --bulma-navbar-item-selected-h: var(--bulma-text-h);
+  --bulma-navbar-item-selected-s: var(--bulma-text-s);
+  --bulma-navbar-item-selected-l: var(--bulma-text-l);
+  --bulma-navbar-item-selected-background-l: var(--bulma-text-l);
+  --bulma-navbar-item-selected-color-l: var(--bulma-text-invert-l);
+  --bulma-navbar-dropdown-arrow: var(--bulma-text-invert-l);
+  --bulma-navbar-dropdown-background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-navbar-dropdown-item-background-l));
+  --bulma-navbar-dropdown-item-h: var(--bulma-text-h);
+  --bulma-navbar-dropdown-item-s: var(--bulma-text-s);
+}
+.navbar.is-primary {
+  --bulma-navbar-h: var(--bulma-primary-h);
+  --bulma-navbar-s: var(--bulma-primary-s);
+  --bulma-navbar-l: var(--bulma-primary-l);
+  --bulma-burger-h: var(--bulma-primary-h);
+  --bulma-burger-s: var(--bulma-primary-s);
+  --bulma-burger-l: var(--bulma-primary-invert-l);
+  --bulma-navbar-background-color: var(--bulma-primary);
+  --bulma-navbar-item-background-l: var(--bulma-primary-l);
+  --bulma-navbar-item-color-l: var(--bulma-primary-invert-l);
+  --bulma-navbar-item-selected-h: var(--bulma-primary-h);
+  --bulma-navbar-item-selected-s: var(--bulma-primary-s);
+  --bulma-navbar-item-selected-l: var(--bulma-primary-l);
+  --bulma-navbar-item-selected-background-l: var(--bulma-primary-l);
+  --bulma-navbar-item-selected-color-l: var(--bulma-primary-invert-l);
+  --bulma-navbar-dropdown-arrow: var(--bulma-primary-invert-l);
+  --bulma-navbar-dropdown-background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-navbar-dropdown-item-background-l));
+  --bulma-navbar-dropdown-item-h: var(--bulma-primary-h);
+  --bulma-navbar-dropdown-item-s: var(--bulma-primary-s);
+}
+.navbar.is-link {
+  --bulma-navbar-h: var(--bulma-link-h);
+  --bulma-navbar-s: var(--bulma-link-s);
+  --bulma-navbar-l: var(--bulma-link-l);
+  --bulma-burger-h: var(--bulma-link-h);
+  --bulma-burger-s: var(--bulma-link-s);
+  --bulma-burger-l: var(--bulma-link-invert-l);
+  --bulma-navbar-background-color: var(--bulma-link);
+  --bulma-navbar-item-background-l: var(--bulma-link-l);
+  --bulma-navbar-item-color-l: var(--bulma-link-invert-l);
+  --bulma-navbar-item-selected-h: var(--bulma-link-h);
+  --bulma-navbar-item-selected-s: var(--bulma-link-s);
+  --bulma-navbar-item-selected-l: var(--bulma-link-l);
+  --bulma-navbar-item-selected-background-l: var(--bulma-link-l);
+  --bulma-navbar-item-selected-color-l: var(--bulma-link-invert-l);
+  --bulma-navbar-dropdown-arrow: var(--bulma-link-invert-l);
+  --bulma-navbar-dropdown-background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-navbar-dropdown-item-background-l));
+  --bulma-navbar-dropdown-item-h: var(--bulma-link-h);
+  --bulma-navbar-dropdown-item-s: var(--bulma-link-s);
+}
+.navbar.is-info {
+  --bulma-navbar-h: var(--bulma-info-h);
+  --bulma-navbar-s: var(--bulma-info-s);
+  --bulma-navbar-l: var(--bulma-info-l);
+  --bulma-burger-h: var(--bulma-info-h);
+  --bulma-burger-s: var(--bulma-info-s);
+  --bulma-burger-l: var(--bulma-info-invert-l);
+  --bulma-navbar-background-color: var(--bulma-info);
+  --bulma-navbar-item-background-l: var(--bulma-info-l);
+  --bulma-navbar-item-color-l: var(--bulma-info-invert-l);
+  --bulma-navbar-item-selected-h: var(--bulma-info-h);
+  --bulma-navbar-item-selected-s: var(--bulma-info-s);
+  --bulma-navbar-item-selected-l: var(--bulma-info-l);
+  --bulma-navbar-item-selected-background-l: var(--bulma-info-l);
+  --bulma-navbar-item-selected-color-l: var(--bulma-info-invert-l);
+  --bulma-navbar-dropdown-arrow: var(--bulma-info-invert-l);
+  --bulma-navbar-dropdown-background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-navbar-dropdown-item-background-l));
+  --bulma-navbar-dropdown-item-h: var(--bulma-info-h);
+  --bulma-navbar-dropdown-item-s: var(--bulma-info-s);
+}
+.navbar.is-success {
+  --bulma-navbar-h: var(--bulma-success-h);
+  --bulma-navbar-s: var(--bulma-success-s);
+  --bulma-navbar-l: var(--bulma-success-l);
+  --bulma-burger-h: var(--bulma-success-h);
+  --bulma-burger-s: var(--bulma-success-s);
+  --bulma-burger-l: var(--bulma-success-invert-l);
+  --bulma-navbar-background-color: var(--bulma-success);
+  --bulma-navbar-item-background-l: var(--bulma-success-l);
+  --bulma-navbar-item-color-l: var(--bulma-success-invert-l);
+  --bulma-navbar-item-selected-h: var(--bulma-success-h);
+  --bulma-navbar-item-selected-s: var(--bulma-success-s);
+  --bulma-navbar-item-selected-l: var(--bulma-success-l);
+  --bulma-navbar-item-selected-background-l: var(--bulma-success-l);
+  --bulma-navbar-item-selected-color-l: var(--bulma-success-invert-l);
+  --bulma-navbar-dropdown-arrow: var(--bulma-success-invert-l);
+  --bulma-navbar-dropdown-background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-navbar-dropdown-item-background-l));
+  --bulma-navbar-dropdown-item-h: var(--bulma-success-h);
+  --bulma-navbar-dropdown-item-s: var(--bulma-success-s);
+}
+.navbar.is-warning {
+  --bulma-navbar-h: var(--bulma-warning-h);
+  --bulma-navbar-s: var(--bulma-warning-s);
+  --bulma-navbar-l: var(--bulma-warning-l);
+  --bulma-burger-h: var(--bulma-warning-h);
+  --bulma-burger-s: var(--bulma-warning-s);
+  --bulma-burger-l: var(--bulma-warning-invert-l);
+  --bulma-navbar-background-color: var(--bulma-warning);
+  --bulma-navbar-item-background-l: var(--bulma-warning-l);
+  --bulma-navbar-item-color-l: var(--bulma-warning-invert-l);
+  --bulma-navbar-item-selected-h: var(--bulma-warning-h);
+  --bulma-navbar-item-selected-s: var(--bulma-warning-s);
+  --bulma-navbar-item-selected-l: var(--bulma-warning-l);
+  --bulma-navbar-item-selected-background-l: var(--bulma-warning-l);
+  --bulma-navbar-item-selected-color-l: var(--bulma-warning-invert-l);
+  --bulma-navbar-dropdown-arrow: var(--bulma-warning-invert-l);
+  --bulma-navbar-dropdown-background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-navbar-dropdown-item-background-l));
+  --bulma-navbar-dropdown-item-h: var(--bulma-warning-h);
+  --bulma-navbar-dropdown-item-s: var(--bulma-warning-s);
+}
+.navbar.is-danger {
+  --bulma-navbar-h: var(--bulma-danger-h);
+  --bulma-navbar-s: var(--bulma-danger-s);
+  --bulma-navbar-l: var(--bulma-danger-l);
+  --bulma-burger-h: var(--bulma-danger-h);
+  --bulma-burger-s: var(--bulma-danger-s);
+  --bulma-burger-l: var(--bulma-danger-invert-l);
+  --bulma-navbar-background-color: var(--bulma-danger);
+  --bulma-navbar-item-background-l: var(--bulma-danger-l);
+  --bulma-navbar-item-color-l: var(--bulma-danger-invert-l);
+  --bulma-navbar-item-selected-h: var(--bulma-danger-h);
+  --bulma-navbar-item-selected-s: var(--bulma-danger-s);
+  --bulma-navbar-item-selected-l: var(--bulma-danger-l);
+  --bulma-navbar-item-selected-background-l: var(--bulma-danger-l);
+  --bulma-navbar-item-selected-color-l: var(--bulma-danger-invert-l);
+  --bulma-navbar-dropdown-arrow: var(--bulma-danger-invert-l);
+  --bulma-navbar-dropdown-background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-navbar-dropdown-item-background-l));
+  --bulma-navbar-dropdown-item-h: var(--bulma-danger-h);
+  --bulma-navbar-dropdown-item-s: var(--bulma-danger-s);
+}
+.navbar > .container {
+  align-items: stretch;
+  display: flex;
+  min-height: var(--bulma-navbar-height);
+  width: 100%;
+}
+.navbar.has-shadow {
+  box-shadow: var(--bulma-navbar-box-shadow-size) var(--bulma-navbar-box-shadow-color);
+}
+.navbar.is-fixed-bottom, .navbar.is-fixed-top {
+  left: 0;
+  position: fixed;
+  right: 0;
+  z-index: var(--bulma-navbar-fixed-z);
+}
+.navbar.is-fixed-bottom {
+  bottom: 0;
+}
+.navbar.is-fixed-bottom.has-shadow {
+  box-shadow: var(--bulma-navbar-bottom-box-shadow-size) var(--bulma-navbar-box-shadow-color);
+}
+.navbar.is-fixed-top {
+  top: 0;
+}
+
+html.has-navbar-fixed-top,
+body.has-navbar-fixed-top {
+  padding-top: var(--bulma-navbar-height);
+}
+html.has-navbar-fixed-bottom,
+body.has-navbar-fixed-bottom {
+  padding-bottom: var(--bulma-navbar-height);
+}
+
+.navbar-brand,
+.navbar-tabs {
+  align-items: stretch;
+  display: flex;
+  flex-shrink: 0;
+  min-height: var(--bulma-navbar-height);
+}
+
+.navbar-tabs {
+  -webkit-overflow-scrolling: touch;
+  max-width: 100vw;
+  overflow-x: auto;
+  overflow-y: hidden;
+}
+
+.navbar-burger {
+  align-items: center;
+  appearance: none;
+  background: none;
+  border: none;
+  border-radius: var(--bulma-burger-border-radius);
+  color: hsl(var(--bulma-burger-h), var(--bulma-burger-s), var(--bulma-burger-l));
+  cursor: pointer;
+  display: inline-flex;
+  flex-direction: column;
+  flex-shrink: 0;
+  height: 2.5rem;
+  justify-content: center;
+  position: relative;
+  vertical-align: top;
+  width: 2.5rem;
+}
+.navbar-burger span {
+  background-color: currentColor;
+  display: block;
+  height: var(--bulma-burger-item-height);
+  left: calc(50% - (var(--bulma-burger-item-width)) / 2);
+  position: absolute;
+  transform-origin: center;
+  transition-duration: var(--bulma-duration);
+  transition-property: background-color, color, opacity, transform;
+  transition-timing-function: var(--bulma-easing);
+  width: var(--bulma-burger-item-width);
+}
+.navbar-burger span:nth-child(1), .navbar-burger span:nth-child(2) {
+  top: calc(50% - (var(--bulma-burger-item-height)) / 2);
+}
+.navbar-burger span:nth-child(3) {
+  bottom: calc(50% + var(--bulma-burger-gap));
+}
+.navbar-burger span:nth-child(4) {
+  top: calc(50% + var(--bulma-burger-gap));
+}
+.navbar-burger:hover {
+  background-color: hsla(var(--bulma-burger-h), var(--bulma-burger-s), var(--bulma-burger-l), 0.1);
+}
+.navbar-burger:active {
+  background-color: hsla(var(--bulma-burger-h), var(--bulma-burger-s), var(--bulma-burger-l), 0.2);
+}
+.navbar-burger.is-active span:nth-child(1) {
+  transform: rotate(-45deg);
+}
+.navbar-burger.is-active span:nth-child(2) {
+  transform: rotate(45deg);
+}
+.navbar-burger.is-active span:nth-child(3), .navbar-burger.is-active span:nth-child(4) {
+  opacity: 0;
+}
+.navbar-burger {
+  align-self: center;
+  color: var(--bulma-navbar-burger-color);
+  margin-inline-start: auto;
+  margin-inline-end: 0.375rem;
+}
+
+.navbar-menu {
+  display: none;
+}
+
+.navbar-item,
+.navbar-link {
+  color: var(--bulma-navbar-item-color);
+  display: block;
+  gap: 0.75rem;
+  line-height: 1.5;
+  padding: 0.5rem 0.75rem;
+  position: relative;
+}
+.navbar-item .icon:only-child,
+.navbar-link .icon:only-child {
+  margin-left: -0.25rem;
+  margin-right: -0.25rem;
+}
+
+a.navbar-item,
+.navbar-link {
+  background-color: hsla(var(--bulma-navbar-h), var(--bulma-navbar-s), calc(var(--bulma-navbar-item-background-l) + var(--bulma-navbar-item-background-l-delta)), var(--bulma-navbar-item-background-a));
+  cursor: pointer;
+}
+a.navbar-item:focus, a.navbar-item:focus-within, a.navbar-item:hover,
+.navbar-link:focus,
+.navbar-link:focus-within,
+.navbar-link:hover {
+  --bulma-navbar-item-background-l-delta: var(--bulma-navbar-item-hover-background-l-delta);
+  --bulma-navbar-item-background-a: 1;
+}
+a.navbar-item:active,
+.navbar-link:active {
+  --bulma-navbar-item-background-l-delta: var(--bulma-navbar-item-active-background-l-delta);
+  --bulma-navbar-item-background-a: 1;
+}
+a.navbar-item.is-active, a.navbar-item.is-selected,
+.navbar-link.is-active,
+.navbar-link.is-selected {
+  --bulma-navbar-h: var(--bulma-navbar-item-selected-h);
+  --bulma-navbar-s: var(--bulma-navbar-item-selected-s);
+  --bulma-navbar-l: var(--bulma-navbar-item-selected-l);
+  --bulma-navbar-item-background-l: var(--bulma-navbar-item-selected-background-l);
+  --bulma-navbar-item-background-a: 1;
+  --bulma-navbar-item-color-l: var(--bulma-navbar-item-selected-color-l);
+}
+
+.navbar-item {
+  flex-grow: 0;
+  flex-shrink: 0;
+}
+.navbar-item img,
+.navbar-item svg {
+  max-height: var(--bulma-navbar-item-img-max-height);
+}
+.navbar-item.has-dropdown {
+  padding: 0;
+}
+.navbar-item.is-expanded {
+  flex-grow: 1;
+  flex-shrink: 1;
+}
+.navbar-item.is-tab {
+  border-bottom: 1px solid transparent;
+  min-height: var(--bulma-navbar-height);
+  padding-bottom: calc(0.5rem - 1px);
+}
+.navbar-item.is-tab:focus, .navbar-item.is-tab:hover {
+  background-color: var(--bulma-navbar-tab-hover-background-color);
+  border-bottom-color: var(--bulma-navbar-tab-hover-border-bottom-color);
+}
+.navbar-item.is-tab.is-active {
+  background-color: var(--bulma-navbar-tab-active-background-color);
+  border-bottom-color: var(--bulma-navbar-tab-active-border-bottom-color);
+  border-bottom-style: var(--bulma-navbar-tab-active-border-bottom-style);
+  border-bottom-width: var(--bulma-navbar-tab-active-border-bottom-width);
+  color: var(--bulma-navbar-tab-active-color);
+  padding-bottom: calc(0.5rem - var(--bulma-navbar-tab-active-border-bottom-width));
+}
+
+.navbar-content {
+  flex-grow: 1;
+  flex-shrink: 1;
+}
+
+.navbar-link:not(.is-arrowless) {
+  padding-inline-end: 2.5em;
+}
+.navbar-link:not(.is-arrowless)::after {
+  border-color: var(--bulma-navbar-dropdown-arrow);
+  margin-top: -0.375em;
+  inset-inline-end: 1.125em;
+}
+
+.navbar-dropdown {
+  font-size: 0.875rem;
+  padding-bottom: 0.75rem;
+  padding-top: 0.5rem;
+}
+.navbar-dropdown .navbar-item {
+  padding-left: 1.5rem;
+  padding-right: 1.5rem;
+}
+.navbar-dropdown .navbar-item:not(.is-active, .is-selected) {
+  background-color: hsl(var(--bulma-navbar-dropdown-item-h), var(--bulma-navbar-dropdown-item-s), calc(var(--bulma-navbar-dropdown-item-background-l) + var(--bulma-navbar-item-background-l-delta)));
+  color: hsl(var(--bulma-navbar-dropdown-item-h), var(--bulma-navbar-dropdown-item-s), var(--bulma-navbar-dropdown-item-color-l));
+}
+
+.navbar-divider {
+  background-color: hsl(var(--bulma-navbar-h), var(--bulma-navbar-s), var(--bulma-navbar-divider-background-l));
+  border: none;
+  display: none;
+  height: var(--bulma-navbar-divider-height);
+  margin: 0.5rem 0;
+}
+
+@media screen and (max-width: 1023px) {
+  .navbar > .container {
+    display: block;
+  }
+  .navbar-brand .navbar-item,
+  .navbar-tabs .navbar-item {
+    align-items: center;
+    display: flex;
+  }
+  .navbar-link::after {
+    display: none;
+  }
+  .navbar-menu {
+    background-color: var(--bulma-navbar-background-color);
+    box-shadow: 0 0.5em 1em hsla(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-scheme-invert-l), 0.1);
+    padding: 0.5rem 0;
+  }
+  .navbar-menu.is-active {
+    display: block;
+  }
+  .navbar.is-fixed-bottom-touch, .navbar.is-fixed-top-touch {
+    left: 0;
+    position: fixed;
+    right: 0;
+    z-index: var(--bulma-navbar-fixed-z);
+  }
+  .navbar.is-fixed-bottom-touch {
+    bottom: 0;
+  }
+  .navbar.is-fixed-bottom-touch.has-shadow {
+    box-shadow: 0 -0.125em 0.1875em hsla(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-scheme-invert-l), 0.1);
+  }
+  .navbar.is-fixed-top-touch {
+    top: 0;
+  }
+  .navbar.is-fixed-top .navbar-menu, .navbar.is-fixed-top-touch .navbar-menu {
+    -webkit-overflow-scrolling: touch;
+    max-height: calc(100vh - var(--bulma-navbar-height));
+    overflow: auto;
+  }
+  html.has-navbar-fixed-top-touch,
+  body.has-navbar-fixed-top-touch {
+    padding-top: var(--bulma-navbar-height);
+  }
+  html.has-navbar-fixed-bottom-touch,
+  body.has-navbar-fixed-bottom-touch {
+    padding-bottom: var(--bulma-navbar-height);
+  }
+}
+@media screen and (min-width: 1024px) {
+  .navbar,
+  .navbar-menu,
+  .navbar-start,
+  .navbar-end {
+    align-items: stretch;
+    display: flex;
+  }
+  .navbar {
+    min-height: var(--bulma-navbar-height);
+  }
+  .navbar.is-spaced {
+    padding: var(--bulma-navbar-padding-vertical) var(--bulma-navbar-padding-horizontal);
+  }
+  .navbar.is-spaced .navbar-start,
+  .navbar.is-spaced .navbar-end {
+    align-items: center;
+  }
+  .navbar.is-spaced a.navbar-item,
+  .navbar.is-spaced .navbar-link {
+    border-radius: var(--bulma-radius);
+  }
+  .navbar.is-transparent {
+    --bulma-navbar-item-background-a: 0;
+  }
+  .navbar.is-transparent .navbar-dropdown a.navbar-item {
+    background-color: hsl(var(--bulma-navbar-h), var(--bulma-navbar-s), calc(var(--bulma-navbar-item-background-l) + var(--bulma-navbar-item-background-l-delta)));
+  }
+  .navbar.is-transparent .navbar-dropdown a.navbar-item.is-active, .navbar.is-transparent .navbar-dropdown a.navbar-item.is-selected {
+    --bulma-navbar-h: var(--bulma-navbar-item-selected-h);
+    --bulma-navbar-s: var(--bulma-navbar-item-selected-s);
+    --bulma-navbar-l: var(--bulma-navbar-item-selected-l);
+    --bulma-navbar-item-background-l: var(--bulma-navbar-item-selected-background-l);
+    --bulma-navbar-item-color-l: var(--bulma-navbar-item-selected-color-l);
+  }
+  .navbar-burger {
+    display: none;
+  }
+  .navbar-item,
+  .navbar-link {
+    align-items: center;
+    display: flex;
+  }
+  .navbar-item.has-dropdown {
+    align-items: stretch;
+  }
+  .navbar-item.has-dropdown-up .navbar-link::after {
+    transform: rotate(135deg) translate(0.25em, -0.25em);
+  }
+  .navbar-item.has-dropdown-up .navbar-dropdown {
+    border-bottom-color: var(--bulma-navbar-dropdown-border-color);
+    border-bottom-style: var(--bulma-navbar-dropdown-border-style);
+    border-bottom-width: var(--bulma-navbar-dropdown-border-width);
+    border-radius: var(--bulma-navbar-dropdown-radius) var(--bulma-navbar-dropdown-radius) 0 0;
+    border-top: none;
+    bottom: 100%;
+    box-shadow: 0 -0.5em 0.5em hsla(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-scheme-invert-l), 0.1);
+    top: auto;
+  }
+  .navbar-item.is-active .navbar-dropdown, .navbar-item.is-hoverable:focus .navbar-dropdown, .navbar-item.is-hoverable:focus-within .navbar-dropdown, .navbar-item.is-hoverable:hover .navbar-dropdown {
+    display: block;
+  }
+  .navbar.is-spaced .navbar-item.is-active .navbar-dropdown, .navbar-item.is-active .navbar-dropdown.is-boxed, .navbar.is-spaced .navbar-item.is-hoverable:focus .navbar-dropdown, .navbar-item.is-hoverable:focus .navbar-dropdown.is-boxed, .navbar.is-spaced .navbar-item.is-hoverable:focus-within .navbar-dropdown, .navbar-item.is-hoverable:focus-within .navbar-dropdown.is-boxed, .navbar.is-spaced .navbar-item.is-hoverable:hover .navbar-dropdown, .navbar-item.is-hoverable:hover .navbar-dropdown.is-boxed {
+    opacity: 1;
+    pointer-events: auto;
+    transform: translateY(0);
+  }
+  .navbar-menu {
+    flex-grow: 1;
+    flex-shrink: 0;
+  }
+  .navbar-start {
+    justify-content: flex-start;
+    margin-inline-end: auto;
+  }
+  .navbar-end {
+    justify-content: flex-end;
+    margin-inline-start: auto;
+  }
+  .navbar-dropdown {
+    background-color: var(--bulma-navbar-dropdown-background-color);
+    border-end-start-radius: var(--bulma-navbar-dropdown-radius);
+    border-end-end-radius: var(--bulma-navbar-dropdown-radius);
+    border-top-color: var(--bulma-navbar-dropdown-border-color);
+    border-top-style: var(--bulma-navbar-dropdown-border-style);
+    border-top-width: var(--bulma-navbar-dropdown-border-width);
+    box-shadow: 0 0.5em 0.5em hsla(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-scheme-invert-l), 0.1);
+    display: none;
+    font-size: 0.875rem;
+    inset-inline-start: 0;
+    min-width: 100%;
+    position: absolute;
+    top: 100%;
+    z-index: var(--bulma-navbar-dropdown-z);
+  }
+  .navbar-dropdown .navbar-item {
+    padding: 0.375rem 1rem;
+    white-space: nowrap;
+  }
+  .navbar-dropdown a.navbar-item {
+    padding-inline-end: 3rem;
+  }
+  .navbar-dropdown a.navbar-item:not(.is-active, .is-selected) {
+    background-color: hsl(var(--bulma-navbar-dropdown-item-h), var(--bulma-navbar-dropdown-item-s), calc(var(--bulma-navbar-dropdown-item-background-l) + var(--bulma-navbar-item-background-l-delta)));
+    color: hsl(var(--bulma-navbar-dropdown-item-h), var(--bulma-navbar-dropdown-item-s), var(--bulma-navbar-dropdown-item-color-l));
+  }
+  .navbar.is-spaced .navbar-dropdown, .navbar-dropdown.is-boxed {
+    border-radius: var(--bulma-navbar-dropdown-boxed-radius);
+    border-top: none;
+    box-shadow: var(--bulma-navbar-dropdown-boxed-shadow);
+    display: block;
+    opacity: 0;
+    pointer-events: none;
+    top: calc(100% + (var(--bulma-navbar-dropdown-offset)));
+    transform: translateY(-5px);
+    transition-duration: var(--bulma-duration);
+    transition-property: opacity, transform;
+  }
+  .navbar-dropdown.is-right {
+    left: auto;
+    right: 0;
+  }
+  .navbar-divider {
+    display: block;
+  }
+  .navbar > .container .navbar-brand,
+  .container > .navbar .navbar-brand {
+    margin-inline-start: -0.75rem;
+  }
+  .navbar > .container .navbar-menu,
+  .container > .navbar .navbar-menu {
+    margin-inline-end: -0.75rem;
+  }
+  .navbar.is-fixed-bottom-desktop, .navbar.is-fixed-top-desktop {
+    left: 0;
+    position: fixed;
+    right: 0;
+    z-index: var(--bulma-navbar-fixed-z);
+  }
+  .navbar.is-fixed-bottom-desktop {
+    bottom: 0;
+  }
+  .navbar.is-fixed-bottom-desktop.has-shadow {
+    box-shadow: 0 -0.125em 0.1875em hsla(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-scheme-invert-l), 0.1);
+  }
+  .navbar.is-fixed-top-desktop {
+    top: 0;
+  }
+  html.has-navbar-fixed-top-desktop,
+  body.has-navbar-fixed-top-desktop {
+    padding-top: var(--bulma-navbar-height);
+  }
+  html.has-navbar-fixed-bottom-desktop,
+  body.has-navbar-fixed-bottom-desktop {
+    padding-bottom: var(--bulma-navbar-height);
+  }
+  html.has-spaced-navbar-fixed-top,
+  body.has-spaced-navbar-fixed-top {
+    padding-top: calc(var(--bulma-navbar-height) + var(--bulma-navbar-padding-vertical) * 2);
+  }
+  html.has-spaced-navbar-fixed-bottom,
+  body.has-spaced-navbar-fixed-bottom {
+    padding-bottom: calc(var(--bulma-navbar-height) + var(--bulma-navbar-padding-vertical) * 2);
+  }
+}
+.hero.is-fullheight-with-navbar {
+  min-height: calc(100vh - var(--bulma-navbar-height));
+}
+
+.pagination {
+  --bulma-pagination-margin: -0.25rem;
+  --bulma-pagination-min-width: var(--bulma-control-height);
+  --bulma-pagination-item-h: var(--bulma-scheme-h);
+  --bulma-pagination-item-s: var(--bulma-scheme-s);
+  --bulma-pagination-item-l: var(--bulma-scheme-main-l);
+  --bulma-pagination-item-background-l-delta: 0%;
+  --bulma-pagination-item-hover-background-l-delta: var(--bulma-hover-background-l-delta);
+  --bulma-pagination-item-active-background-l-delta: var(--bulma-active-background-l-delta);
+  --bulma-pagination-item-border-style: solid;
+  --bulma-pagination-item-border-width: var(--bulma-control-border-width);
+  --bulma-pagination-item-border-l: var(--bulma-border-l);
+  --bulma-pagination-item-border-l-delta: 0%;
+  --bulma-pagination-item-hover-border-l-delta: var(--bulma-hover-border-l-delta);
+  --bulma-pagination-item-active-border-l-delta: var(--bulma-active-border-l-delta);
+  --bulma-pagination-item-focus-border-l-delta: var(--bulma-focus-border-l-delta);
+  --bulma-pagination-item-color-l: var(--bulma-text-strong-l);
+  --bulma-pagination-item-font-size: 1em;
+  --bulma-pagination-item-margin: 0.25rem;
+  --bulma-pagination-item-padding-left: 0.5em;
+  --bulma-pagination-item-padding-right: 0.5em;
+  --bulma-pagination-item-outer-shadow-h: 0;
+  --bulma-pagination-item-outer-shadow-s: 0%;
+  --bulma-pagination-item-outer-shadow-l: 20%;
+  --bulma-pagination-item-outer-shadow-a: 0.05;
+  --bulma-pagination-nav-padding-left: 0.75em;
+  --bulma-pagination-nav-padding-right: 0.75em;
+  --bulma-pagination-disabled-color: var(--bulma-text-weak);
+  --bulma-pagination-disabled-background-color: var(--bulma-border);
+  --bulma-pagination-disabled-border-color: var(--bulma-border);
+  --bulma-pagination-current-color: var(--bulma-link-invert);
+  --bulma-pagination-current-background-color: var(--bulma-link);
+  --bulma-pagination-current-border-color: var(--bulma-link);
+  --bulma-pagination-ellipsis-color: var(--bulma-text-weak);
+  --bulma-pagination-shadow-inset: inset 0 0.0625em 0.125em hsla(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-scheme-invert-l), 0.2);
+  --bulma-pagination-selected-item-h: var(--bulma-link-h);
+  --bulma-pagination-selected-item-s: var(--bulma-link-s);
+  --bulma-pagination-selected-item-l: var(--bulma-link-l);
+  --bulma-pagination-selected-item-background-l: var(--bulma-link-l);
+  --bulma-pagination-selected-item-border-l: var(--bulma-link-l);
+  --bulma-pagination-selected-item-color-l: var(--bulma-link-invert-l);
+}
+
+.pagination {
+  font-size: var(--bulma-size-normal);
+  margin: var(--bulma-pagination-margin);
+}
+.pagination.is-small {
+  font-size: var(--bulma-size-small);
+}
+.pagination.is-medium {
+  font-size: var(--bulma-size-medium);
+}
+.pagination.is-large {
+  font-size: var(--bulma-size-large);
+}
+.pagination.is-rounded .pagination-previous,
+.pagination.is-rounded .pagination-next {
+  padding-left: 1em;
+  padding-right: 1em;
+  border-radius: var(--bulma-radius-rounded);
+}
+.pagination.is-rounded .pagination-link {
+  border-radius: var(--bulma-radius-rounded);
+}
+
+.pagination,
+.pagination-list {
+  align-items: center;
+  display: flex;
+  justify-content: center;
+  text-align: center;
+}
+
+.pagination-previous,
+.pagination-next,
+.pagination-link,
+.pagination-ellipsis {
+  color: hsl(var(--bulma-pagination-item-h), var(--bulma-pagination-item-s), var(--bulma-pagination-item-color-l));
+  font-size: var(--bulma-pagination-item-font-size);
+  justify-content: center;
+  margin: var(--bulma-pagination-item-margin);
+  padding-left: var(--bulma-pagination-item-padding-left);
+  padding-right: var(--bulma-pagination-item-padding-right);
+  text-align: center;
+}
+
+.pagination-previous,
+.pagination-next,
+.pagination-link {
+  background-color: hsl(var(--bulma-pagination-item-h), var(--bulma-pagination-item-s), calc(var(--bulma-pagination-item-background-l) + var(--bulma-pagination-item-background-l-delta)));
+  border-color: hsl(var(--bulma-pagination-item-h), var(--bulma-pagination-item-s), calc(var(--bulma-pagination-item-border-l) + var(--bulma-pagination-item-border-l-delta)));
+  border-style: var(--bulma-pagination-item-border-style);
+  border-width: var(--bulma-pagination-item-border-width);
+  box-shadow: 0px 0.0625em 0.125em hsla(var(--bulma-pagination-item-outer-shadow-h), var(--bulma-pagination-item-outer-shadow-s), var(--bulma-pagination-item-outer-shadow-l), var(--bulma-pagination-item-outer-shadow-a)), 0px 0.125em 0.25em hsla(var(--bulma-pagination-item-outer-shadow-h), var(--bulma-pagination-item-outer-shadow-s), var(--bulma-pagination-item-outer-shadow-l), var(--bulma-pagination-item-outer-shadow-a));
+  color: hsl(var(--bulma-pagination-item-h), var(--bulma-pagination-item-s), var(--bulma-pagination-item-color-l));
+  min-width: var(--bulma-pagination-min-width);
+  transition-duration: var(--bulma-duration);
+  transition-property: background-color, border-color, box-shadow, color;
+}
+.pagination-previous:hover,
+.pagination-next:hover,
+.pagination-link:hover {
+  --bulma-pagination-item-background-l-delta: var(--bulma-pagination-item-hover-background-l-delta);
+  --bulma-pagination-item-border-l-delta: var(--bulma-pagination-item-hover-border-l-delta);
+}
+.pagination-previous:focus,
+.pagination-next:focus,
+.pagination-link:focus {
+  --bulma-pagination-item-background-l-delta: var(--bulma-pagination-item-hover-background-l-delta);
+  --bulma-pagination-item-border-l-delta: var(--bulma-pagination-item-hover-border-l-delta);
+}
+.pagination-previous:active,
+.pagination-next:active,
+.pagination-link:active {
+  box-shadow: var(--bulma-pagination-shadow-inset);
+}
+.pagination-previous[disabled], .pagination-previous.is-disabled,
+.pagination-next[disabled],
+.pagination-next.is-disabled,
+.pagination-link[disabled],
+.pagination-link.is-disabled {
+  background-color: var(--bulma-pagination-disabled-background-color);
+  border-color: var(--bulma-pagination-disabled-border-color);
+  box-shadow: none;
+  color: var(--bulma-pagination-disabled-color);
+  opacity: 0.5;
+}
+
+.pagination-previous,
+.pagination-next {
+  padding-left: var(--bulma-pagination-nav-padding-left);
+  padding-right: var(--bulma-pagination-nav-padding-right);
+  white-space: nowrap;
+}
+
+.pagination-link.is-current, .pagination-link.is-selected {
+  --bulma-pagination-item-h: var(--bulma-pagination-selected-item-h);
+  --bulma-pagination-item-s: var(--bulma-pagination-selected-item-s);
+  --bulma-pagination-item-l: var(--bulma-pagination-selected-item-l);
+  --bulma-pagination-item-background-l: var(--bulma-pagination-selected-item-background-l);
+  --bulma-pagination-item-border-l: var(--bulma-pagination-selected-item-border-l);
+  --bulma-pagination-item-color-l: var(--bulma-pagination-selected-item-color-l);
+}
+
+.pagination-ellipsis {
+  color: var(--bulma-pagination-ellipsis-color);
+  pointer-events: none;
+}
+
+.pagination-list {
+  flex-wrap: wrap;
+}
+.pagination-list li {
+  list-style: none;
+}
+
+@media screen and (max-width: 768px) {
+  .pagination {
+    flex-wrap: wrap;
+  }
+  .pagination-previous,
+  .pagination-next {
+    flex-grow: 1;
+    flex-shrink: 1;
+  }
+  .pagination-list li {
+    flex-grow: 1;
+    flex-shrink: 1;
+  }
+}
+@media screen and (min-width: 769px), print {
+  .pagination-list {
+    flex-grow: 1;
+    flex-shrink: 1;
+    justify-content: flex-start;
+    order: 1;
+  }
+  .pagination-previous,
+  .pagination-next,
+  .pagination-link,
+  .pagination-ellipsis {
+    margin-bottom: 0;
+    margin-top: 0;
+  }
+  .pagination-previous {
+    order: 2;
+  }
+  .pagination-next {
+    order: 3;
+  }
+  .pagination {
+    justify-content: space-between;
+    margin-bottom: 0;
+    margin-top: 0;
+  }
+  .pagination.is-centered .pagination-previous {
+    order: 1;
+  }
+  .pagination.is-centered .pagination-list {
+    justify-content: center;
+    order: 2;
+  }
+  .pagination.is-centered .pagination-next {
+    order: 3;
+  }
+  .pagination.is-right .pagination-previous {
+    order: 1;
+  }
+  .pagination.is-right .pagination-next {
+    order: 2;
+  }
+  .pagination.is-right .pagination-list {
+    justify-content: flex-end;
+    order: 3;
+  }
+}
+.panel {
+  --bulma-panel-margin: var(--bulma-block-spacing);
+  --bulma-panel-item-border: 1px solid var(--bulma-border-weak);
+  --bulma-panel-radius: var(--bulma-radius-large);
+  --bulma-panel-shadow: var(--bulma-shadow);
+  --bulma-panel-heading-line-height: 1.25;
+  --bulma-panel-heading-padding: 1em 1.25em;
+  --bulma-panel-heading-radius: var(--bulma-radius);
+  --bulma-panel-heading-size: 1.25em;
+  --bulma-panel-heading-weight: var(--bulma-weight-bold);
+  --bulma-panel-tabs-font-size: 1em;
+  --bulma-panel-tab-border-bottom-color: var(--bulma-border);
+  --bulma-panel-tab-border-bottom-style: solid;
+  --bulma-panel-tab-border-bottom-width: 1px;
+  --bulma-panel-tab-active-color: var(--bulma-link-active);
+  --bulma-panel-list-item-color: var(--bulma-text);
+  --bulma-panel-list-item-hover-color: var(--bulma-link);
+  --bulma-panel-block-color: var(--bulma-text-strong);
+  --bulma-panel-block-hover-background-color: var(--bulma-background);
+  --bulma-panel-block-active-border-left-color: var(--bulma-link);
+  --bulma-panel-block-active-color: var(--bulma-link-active);
+  --bulma-panel-block-active-icon-color: var(--bulma-link);
+  --bulma-panel-icon-color: var(--bulma-text-weak);
+}
+
+.panel {
+  --bulma-panel-h: var(--bulma-scheme-h);
+  --bulma-panel-s: var(--bulma-scheme-s);
+  --bulma-panel-color-l: var(--bulma-text-l);
+  --bulma-panel-heading-background-l: var(--bulma-text-l);
+  --bulma-panel-heading-color-l: var(--bulma-text-invert-l);
+  border-radius: var(--bulma-panel-radius);
+  box-shadow: var(--bulma-panel-shadow);
+  font-size: var(--bulma-size-normal);
+}
+.panel:not(:last-child) {
+  margin-bottom: var(--bulma-panel-margin);
+}
+.panel.is-white {
+  --bulma-panel-h: var(--bulma-white-h);
+  --bulma-panel-s: var(--bulma-white-s);
+  --bulma-panel-color-l: var(--bulma-white-l);
+  --bulma-panel-heading-background-l: var(--bulma-white-l);
+  --bulma-panel-heading-color-l: var(--bulma-white-invert-l);
+}
+.panel.is-black {
+  --bulma-panel-h: var(--bulma-black-h);
+  --bulma-panel-s: var(--bulma-black-s);
+  --bulma-panel-color-l: var(--bulma-black-l);
+  --bulma-panel-heading-background-l: var(--bulma-black-l);
+  --bulma-panel-heading-color-l: var(--bulma-black-invert-l);
+}
+.panel.is-light {
+  --bulma-panel-h: var(--bulma-light-h);
+  --bulma-panel-s: var(--bulma-light-s);
+  --bulma-panel-color-l: var(--bulma-light-l);
+  --bulma-panel-heading-background-l: var(--bulma-light-l);
+  --bulma-panel-heading-color-l: var(--bulma-light-invert-l);
+}
+.panel.is-dark {
+  --bulma-panel-h: var(--bulma-dark-h);
+  --bulma-panel-s: var(--bulma-dark-s);
+  --bulma-panel-color-l: var(--bulma-dark-l);
+  --bulma-panel-heading-background-l: var(--bulma-dark-l);
+  --bulma-panel-heading-color-l: var(--bulma-dark-invert-l);
+}
+.panel.is-text {
+  --bulma-panel-h: var(--bulma-text-h);
+  --bulma-panel-s: var(--bulma-text-s);
+  --bulma-panel-color-l: var(--bulma-text-l);
+  --bulma-panel-heading-background-l: var(--bulma-text-l);
+  --bulma-panel-heading-color-l: var(--bulma-text-invert-l);
+}
+.panel.is-primary {
+  --bulma-panel-h: var(--bulma-primary-h);
+  --bulma-panel-s: var(--bulma-primary-s);
+  --bulma-panel-color-l: var(--bulma-primary-l);
+  --bulma-panel-heading-background-l: var(--bulma-primary-l);
+  --bulma-panel-heading-color-l: var(--bulma-primary-invert-l);
+}
+.panel.is-link {
+  --bulma-panel-h: var(--bulma-link-h);
+  --bulma-panel-s: var(--bulma-link-s);
+  --bulma-panel-color-l: var(--bulma-link-l);
+  --bulma-panel-heading-background-l: var(--bulma-link-l);
+  --bulma-panel-heading-color-l: var(--bulma-link-invert-l);
+}
+.panel.is-info {
+  --bulma-panel-h: var(--bulma-info-h);
+  --bulma-panel-s: var(--bulma-info-s);
+  --bulma-panel-color-l: var(--bulma-info-l);
+  --bulma-panel-heading-background-l: var(--bulma-info-l);
+  --bulma-panel-heading-color-l: var(--bulma-info-invert-l);
+}
+.panel.is-success {
+  --bulma-panel-h: var(--bulma-success-h);
+  --bulma-panel-s: var(--bulma-success-s);
+  --bulma-panel-color-l: var(--bulma-success-l);
+  --bulma-panel-heading-background-l: var(--bulma-success-l);
+  --bulma-panel-heading-color-l: var(--bulma-success-invert-l);
+}
+.panel.is-warning {
+  --bulma-panel-h: var(--bulma-warning-h);
+  --bulma-panel-s: var(--bulma-warning-s);
+  --bulma-panel-color-l: var(--bulma-warning-l);
+  --bulma-panel-heading-background-l: var(--bulma-warning-l);
+  --bulma-panel-heading-color-l: var(--bulma-warning-invert-l);
+}
+.panel.is-danger {
+  --bulma-panel-h: var(--bulma-danger-h);
+  --bulma-panel-s: var(--bulma-danger-s);
+  --bulma-panel-color-l: var(--bulma-danger-l);
+  --bulma-panel-heading-background-l: var(--bulma-danger-l);
+  --bulma-panel-heading-color-l: var(--bulma-danger-invert-l);
+}
+
+.panel-tabs:not(:last-child),
+.panel-block:not(:last-child) {
+  border-bottom: var(--bulma-panel-item-border);
+}
+
+.panel-heading {
+  background-color: hsl(var(--bulma-panel-h), var(--bulma-panel-s), var(--bulma-panel-heading-background-l));
+  border-radius: var(--bulma-panel-radius) var(--bulma-panel-radius) 0 0;
+  color: hsl(var(--bulma-panel-h), var(--bulma-panel-s), var(--bulma-panel-heading-color-l));
+  font-size: var(--bulma-panel-heading-size);
+  font-weight: var(--bulma-panel-heading-weight);
+  line-height: var(--bulma-panel-heading-line-height);
+  padding: var(--bulma-panel-heading-padding);
+}
+
+.panel-tabs {
+  align-items: flex-end;
+  display: flex;
+  font-size: var(--bulma-panel-tabs-font-size);
+  justify-content: center;
+}
+.panel-tabs a {
+  border-bottom-color: var(--bulma-panel-tab-border-bottom-color);
+  border-bottom-style: var(--bulma-panel-tab-border-bottom-style);
+  border-bottom-width: var(--bulma-panel-tab-border-bottom-width);
+  margin-bottom: calc(-1 * 1px);
+  padding: 0.75em;
+}
+.panel-tabs a.is-active {
+  border-bottom-color: hsl(var(--bulma-panel-h), var(--bulma-panel-s), var(--bulma-panel-color-l));
+  color: var(--bulma-panel-tab-active-color);
+}
+
+.panel-list a {
+  color: var(--bulma-panel-list-item-color);
+}
+.panel-list a:hover {
+  color: var(--bulma-panel-list-item-hover-color);
+}
+
+.panel-block {
+  align-items: center;
+  color: var(--bulma-panel-block-color);
+  display: flex;
+  justify-content: flex-start;
+  padding: 0.75em 1em;
+}
+.panel-block input[type=checkbox] {
+  margin-inline-end: 0.75em;
+}
+.panel-block > .control {
+  flex-grow: 1;
+  flex-shrink: 1;
+  width: 100%;
+}
+.panel-block.is-wrapped {
+  flex-wrap: wrap;
+}
+.panel-block.is-active {
+  border-left-color: var(--bulma-panel-block-active-border-left-color);
+  color: var(--bulma-panel-block-active-color);
+}
+.panel-block.is-active .panel-icon {
+  color: hsl(var(--bulma-panel-h), var(--bulma-panel-s), var(--bulma-panel-color-l));
+}
+.panel-block:last-child {
+  border-end-start-radius: var(--bulma-panel-radius);
+  border-end-end-radius: var(--bulma-panel-radius);
+}
+
+a.panel-block,
+label.panel-block {
+  cursor: pointer;
+}
+a.panel-block:hover,
+label.panel-block:hover {
+  background-color: var(--bulma-panel-block-hover-background-color);
+}
+
+.panel-icon {
+  display: inline-block;
+  font-size: 1em;
+  height: 1em;
+  line-height: 1em;
+  text-align: center;
+  vertical-align: top;
+  width: 1em;
+  color: var(--bulma-panel-icon-color);
+  margin-inline-end: 0.75em;
+}
+.panel-icon .fa {
+  font-size: inherit;
+  line-height: inherit;
+}
+
+.tabs {
+  --bulma-tabs-border-bottom-color: var(--bulma-border);
+  --bulma-tabs-border-bottom-style: solid;
+  --bulma-tabs-border-bottom-width: 1px;
+  --bulma-tabs-link-color: var(--bulma-text);
+  --bulma-tabs-link-hover-border-bottom-color: var(--bulma-text-strong);
+  --bulma-tabs-link-hover-color: var(--bulma-text-strong);
+  --bulma-tabs-link-active-border-bottom-color: var(--bulma-link-text);
+  --bulma-tabs-link-active-color: var(--bulma-link-text);
+  --bulma-tabs-link-padding: 0.5em 1em;
+  --bulma-tabs-boxed-link-radius: var(--bulma-radius);
+  --bulma-tabs-boxed-link-hover-background-color: var(--bulma-background);
+  --bulma-tabs-boxed-link-hover-border-bottom-color: var(--bulma-border);
+  --bulma-tabs-boxed-link-active-background-color: var(--bulma-scheme-main);
+  --bulma-tabs-boxed-link-active-border-color: var(--bulma-border);
+  --bulma-tabs-boxed-link-active-border-bottom-color: transparent;
+  --bulma-tabs-toggle-link-border-color: var(--bulma-border);
+  --bulma-tabs-toggle-link-border-style: solid;
+  --bulma-tabs-toggle-link-border-width: 1px;
+  --bulma-tabs-toggle-link-hover-background-color: var(--bulma-background);
+  --bulma-tabs-toggle-link-hover-border-color: var(--bulma-border-hover);
+  --bulma-tabs-toggle-link-radius: var(--bulma-radius);
+  --bulma-tabs-toggle-link-active-background-color: var(--bulma-link);
+  --bulma-tabs-toggle-link-active-border-color: var(--bulma-link);
+  --bulma-tabs-toggle-link-active-color: var(--bulma-link-invert);
+}
+
+.tabs {
+  -webkit-overflow-scrolling: touch;
+  align-items: stretch;
+  display: flex;
+  font-size: var(--bulma-size-normal);
+  justify-content: space-between;
+  overflow: hidden;
+  overflow-x: auto;
+  white-space: nowrap;
+}
+.tabs a {
+  align-items: center;
+  border-bottom-color: var(--bulma-tabs-border-bottom-color);
+  border-bottom-style: var(--bulma-tabs-border-bottom-style);
+  border-bottom-width: var(--bulma-tabs-border-bottom-width);
+  color: var(--bulma-tabs-link-color);
+  display: flex;
+  justify-content: center;
+  margin-bottom: calc(-1 * var(--bulma-tabs-border-bottom-width));
+  padding: var(--bulma-tabs-link-padding);
+  transition-duration: var(--bulma-duration);
+  transition-property: background-color, border-color, color;
+  vertical-align: top;
+}
+.tabs a:hover {
+  border-bottom-color: var(--bulma-tabs-link-hover-border-bottom-color);
+  color: var(--bulma-tabs-link-hover-color);
+}
+.tabs li {
+  display: block;
+}
+.tabs li.is-active a {
+  border-bottom-color: var(--bulma-tabs-link-active-border-bottom-color);
+  color: var(--bulma-tabs-link-active-color);
+}
+.tabs ul {
+  align-items: center;
+  border-bottom-color: var(--bulma-tabs-border-bottom-color);
+  border-bottom-style: var(--bulma-tabs-border-bottom-style);
+  border-bottom-width: var(--bulma-tabs-border-bottom-width);
+  display: flex;
+  flex-grow: 1;
+  flex-shrink: 0;
+  justify-content: flex-start;
+}
+.tabs ul.is-left {
+  padding-right: 0.75em;
+}
+.tabs ul.is-center {
+  flex: none;
+  justify-content: center;
+  padding-left: 0.75em;
+  padding-right: 0.75em;
+}
+.tabs ul.is-right {
+  justify-content: flex-end;
+  padding-left: 0.75em;
+}
+.tabs .icon:first-child {
+  margin-inline-end: 0.5em;
+}
+.tabs .icon:last-child {
+  margin-inline-start: 0.5em;
+}
+.tabs.is-centered ul {
+  justify-content: center;
+}
+.tabs.is-right ul {
+  justify-content: flex-end;
+}
+.tabs.is-boxed a {
+  border: 1px solid transparent;
+  border-start-start-radius: var(--bulma-tabs-boxed-link-radius);
+  border-start-end-radius: var(--bulma-tabs-boxed-link-radius);
+}
+.tabs.is-boxed a:hover {
+  background-color: var(--bulma-tabs-boxed-link-hover-background-color);
+  border-bottom-color: var(--bulma-tabs-boxed-link-hover-border-bottom-color);
+}
+.tabs.is-boxed li.is-active a {
+  background-color: var(--bulma-tabs-boxed-link-active-background-color);
+  border-color: var(--bulma-tabs-boxed-link-active-border-color);
+  border-bottom-color: var(--bulma-tabs-boxed-link-active-border-bottom-color) !important;
+}
+.tabs.is-fullwidth li {
+  flex-grow: 1;
+  flex-shrink: 0;
+}
+.tabs.is-toggle a {
+  border-color: var(--bulma-tabs-toggle-link-border-color);
+  border-style: var(--bulma-tabs-toggle-link-border-style);
+  border-width: var(--bulma-tabs-toggle-link-border-width);
+  margin-bottom: 0;
+  position: relative;
+}
+.tabs.is-toggle a:hover {
+  background-color: var(--bulma-tabs-toggle-link-hover-background-color);
+  border-color: var(--bulma-tabs-toggle-link-hover-border-color);
+  z-index: 2;
+}
+.tabs.is-toggle li + li {
+  margin-inline-start: calc(-1 * var(--bulma-tabs-toggle-link-border-width));
+}
+.tabs.is-toggle li:first-child a {
+  border-start-start-radius: var(--bulma-tabs-toggle-link-radius);
+  border-end-start-radius: var(--bulma-tabs-toggle-link-radius);
+}
+.tabs.is-toggle li:last-child a {
+  border-start-end-radius: var(--bulma-tabs-toggle-link-radius);
+  border-end-end-radius: var(--bulma-tabs-toggle-link-radius);
+}
+.tabs.is-toggle li.is-active a {
+  background-color: var(--bulma-tabs-toggle-link-active-background-color);
+  border-color: var(--bulma-tabs-toggle-link-active-border-color);
+  color: var(--bulma-tabs-toggle-link-active-color);
+  z-index: 1;
+}
+.tabs.is-toggle ul {
+  border-bottom: none;
+}
+.tabs.is-toggle.is-toggle-rounded li:first-child a {
+  border-start-start-radius: var(--bulma-radius-rounded);
+  border-end-start-radius: var(--bulma-radius-rounded);
+  padding-inline-start: 1.25em;
+}
+.tabs.is-toggle.is-toggle-rounded li:last-child a {
+  border-start-end-radius: var(--bulma-radius-rounded);
+  border-end-end-radius: var(--bulma-radius-rounded);
+  padding-inline-end: 1.25em;
+}
+.tabs.is-small {
+  font-size: var(--bulma-size-small);
+}
+.tabs.is-medium {
+  font-size: var(--bulma-size-medium);
+}
+.tabs.is-large {
+  font-size: var(--bulma-size-large);
+}
+
+/* Bulma Grid */
+:root {
+  --bulma-column-gap: 0.75rem;
+}
+
+.column {
+  display: block;
+  flex-basis: 0;
+  flex-grow: 1;
+  flex-shrink: 1;
+  padding: var(--bulma-column-gap);
+}
+.columns.is-mobile > .column.is-narrow {
+  flex: none;
+  width: unset;
+}
+.columns.is-mobile > .column.is-full {
+  flex: none;
+  width: 100%;
+}
+.columns.is-mobile > .column.is-three-quarters {
+  flex: none;
+  width: 75%;
+}
+.columns.is-mobile > .column.is-two-thirds {
+  flex: none;
+  width: 66.6666%;
+}
+.columns.is-mobile > .column.is-half {
+  flex: none;
+  width: 50%;
+}
+.columns.is-mobile > .column.is-one-third {
+  flex: none;
+  width: 33.3333%;
+}
+.columns.is-mobile > .column.is-one-quarter {
+  flex: none;
+  width: 25%;
+}
+.columns.is-mobile > .column.is-one-fifth {
+  flex: none;
+  width: 20%;
+}
+.columns.is-mobile > .column.is-two-fifths {
+  flex: none;
+  width: 40%;
+}
+.columns.is-mobile > .column.is-three-fifths {
+  flex: none;
+  width: 60%;
+}
+.columns.is-mobile > .column.is-four-fifths {
+  flex: none;
+  width: 80%;
+}
+.columns.is-mobile > .column.is-offset-three-quarters {
+  margin-inline-start: 75%;
+}
+.columns.is-mobile > .column.is-offset-two-thirds {
+  margin-inline-start: 66.6666%;
+}
+.columns.is-mobile > .column.is-offset-half {
+  margin-inline-start: 50%;
+}
+.columns.is-mobile > .column.is-offset-one-third {
+  margin-inline-start: 0.3333%;
+}
+.columns.is-mobile > .column.is-offset-one-quarter {
+  margin-inline-start: 25%;
+}
+.columns.is-mobile > .column.is-offset-one-fifth {
+  margin-inline-start: 20%;
+}
+.columns.is-mobile > .column.is-offset-two-fifths {
+  margin-inline-start: 40%;
+}
+.columns.is-mobile > .column.is-offset-three-fifths {
+  margin-inline-start: 60%;
+}
+.columns.is-mobile > .column.is-offset-four-fifths {
+  margin-inline-start: 80%;
+}
+.columns.is-mobile > .column.is-0 {
+  flex: none;
+  width: 0%;
+}
+.columns.is-mobile > .column.is-offset-0 {
+  margin-inline-start: 0%;
+}
+.columns.is-mobile > .column.is-1 {
+  flex: none;
+  width: 8.3333333333%;
+}
+.columns.is-mobile > .column.is-offset-1 {
+  margin-inline-start: 8.3333333333%;
+}
+.columns.is-mobile > .column.is-2 {
+  flex: none;
+  width: 16.6666666667%;
+}
+.columns.is-mobile > .column.is-offset-2 {
+  margin-inline-start: 16.6666666667%;
+}
+.columns.is-mobile > .column.is-3 {
+  flex: none;
+  width: 25%;
+}
+.columns.is-mobile > .column.is-offset-3 {
+  margin-inline-start: 25%;
+}
+.columns.is-mobile > .column.is-4 {
+  flex: none;
+  width: 33.3333333333%;
+}
+.columns.is-mobile > .column.is-offset-4 {
+  margin-inline-start: 33.3333333333%;
+}
+.columns.is-mobile > .column.is-5 {
+  flex: none;
+  width: 41.6666666667%;
+}
+.columns.is-mobile > .column.is-offset-5 {
+  margin-inline-start: 41.6666666667%;
+}
+.columns.is-mobile > .column.is-6 {
+  flex: none;
+  width: 50%;
+}
+.columns.is-mobile > .column.is-offset-6 {
+  margin-inline-start: 50%;
+}
+.columns.is-mobile > .column.is-7 {
+  flex: none;
+  width: 58.3333333333%;
+}
+.columns.is-mobile > .column.is-offset-7 {
+  margin-inline-start: 58.3333333333%;
+}
+.columns.is-mobile > .column.is-8 {
+  flex: none;
+  width: 66.6666666667%;
+}
+.columns.is-mobile > .column.is-offset-8 {
+  margin-inline-start: 66.6666666667%;
+}
+.columns.is-mobile > .column.is-9 {
+  flex: none;
+  width: 75%;
+}
+.columns.is-mobile > .column.is-offset-9 {
+  margin-inline-start: 75%;
+}
+.columns.is-mobile > .column.is-10 {
+  flex: none;
+  width: 83.3333333333%;
+}
+.columns.is-mobile > .column.is-offset-10 {
+  margin-inline-start: 83.3333333333%;
+}
+.columns.is-mobile > .column.is-11 {
+  flex: none;
+  width: 91.6666666667%;
+}
+.columns.is-mobile > .column.is-offset-11 {
+  margin-inline-start: 91.6666666667%;
+}
+.columns.is-mobile > .column.is-12 {
+  flex: none;
+  width: 100%;
+}
+.columns.is-mobile > .column.is-offset-12 {
+  margin-inline-start: 100%;
+}
+@media screen and (max-width: 768px) {
+  .column.is-narrow-mobile {
+    flex: none;
+    width: unset;
+  }
+  .column.is-full-mobile {
+    flex: none;
+    width: 100%;
+  }
+  .column.is-three-quarters-mobile {
+    flex: none;
+    width: 75%;
+  }
+  .column.is-two-thirds-mobile {
+    flex: none;
+    width: 66.6666%;
+  }
+  .column.is-half-mobile {
+    flex: none;
+    width: 50%;
+  }
+  .column.is-one-third-mobile {
+    flex: none;
+    width: 33.3333%;
+  }
+  .column.is-one-quarter-mobile {
+    flex: none;
+    width: 25%;
+  }
+  .column.is-one-fifth-mobile {
+    flex: none;
+    width: 20%;
+  }
+  .column.is-two-fifths-mobile {
+    flex: none;
+    width: 40%;
+  }
+  .column.is-three-fifths-mobile {
+    flex: none;
+    width: 60%;
+  }
+  .column.is-four-fifths-mobile {
+    flex: none;
+    width: 80%;
+  }
+  .column.is-offset-three-quarters-mobile {
+    margin-inline-start: 75%;
+  }
+  .column.is-offset-two-thirds-mobile {
+    margin-inline-start: 66.6666%;
+  }
+  .column.is-offset-half-mobile {
+    margin-inline-start: 50%;
+  }
+  .column.is-offset-one-third-mobile {
+    margin-inline-start: 0.3333%;
+  }
+  .column.is-offset-one-quarter-mobile {
+    margin-inline-start: 25%;
+  }
+  .column.is-offset-one-fifth-mobile {
+    margin-inline-start: 20%;
+  }
+  .column.is-offset-two-fifths-mobile {
+    margin-inline-start: 40%;
+  }
+  .column.is-offset-three-fifths-mobile {
+    margin-inline-start: 60%;
+  }
+  .column.is-offset-four-fifths-mobile {
+    margin-inline-start: 80%;
+  }
+  .column.is-0-mobile {
+    flex: none;
+    width: 0%;
+  }
+  .column.is-offset-0-mobile {
+    margin-inline-start: 0%;
+  }
+  .column.is-1-mobile {
+    flex: none;
+    width: 8.3333333333%;
+  }
+  .column.is-offset-1-mobile {
+    margin-inline-start: 8.3333333333%;
+  }
+  .column.is-2-mobile {
+    flex: none;
+    width: 16.6666666667%;
+  }
+  .column.is-offset-2-mobile {
+    margin-inline-start: 16.6666666667%;
+  }
+  .column.is-3-mobile {
+    flex: none;
+    width: 25%;
+  }
+  .column.is-offset-3-mobile {
+    margin-inline-start: 25%;
+  }
+  .column.is-4-mobile {
+    flex: none;
+    width: 33.3333333333%;
+  }
+  .column.is-offset-4-mobile {
+    margin-inline-start: 33.3333333333%;
+  }
+  .column.is-5-mobile {
+    flex: none;
+    width: 41.6666666667%;
+  }
+  .column.is-offset-5-mobile {
+    margin-inline-start: 41.6666666667%;
+  }
+  .column.is-6-mobile {
+    flex: none;
+    width: 50%;
+  }
+  .column.is-offset-6-mobile {
+    margin-inline-start: 50%;
+  }
+  .column.is-7-mobile {
+    flex: none;
+    width: 58.3333333333%;
+  }
+  .column.is-offset-7-mobile {
+    margin-inline-start: 58.3333333333%;
+  }
+  .column.is-8-mobile {
+    flex: none;
+    width: 66.6666666667%;
+  }
+  .column.is-offset-8-mobile {
+    margin-inline-start: 66.6666666667%;
+  }
+  .column.is-9-mobile {
+    flex: none;
+    width: 75%;
+  }
+  .column.is-offset-9-mobile {
+    margin-inline-start: 75%;
+  }
+  .column.is-10-mobile {
+    flex: none;
+    width: 83.3333333333%;
+  }
+  .column.is-offset-10-mobile {
+    margin-inline-start: 83.3333333333%;
+  }
+  .column.is-11-mobile {
+    flex: none;
+    width: 91.6666666667%;
+  }
+  .column.is-offset-11-mobile {
+    margin-inline-start: 91.6666666667%;
+  }
+  .column.is-12-mobile {
+    flex: none;
+    width: 100%;
+  }
+  .column.is-offset-12-mobile {
+    margin-inline-start: 100%;
+  }
+}
+@media screen and (min-width: 769px), print {
+  .column.is-narrow, .column.is-narrow-tablet {
+    flex: none;
+    width: unset;
+  }
+  .column.is-full, .column.is-full-tablet {
+    flex: none;
+    width: 100%;
+  }
+  .column.is-three-quarters, .column.is-three-quarters-tablet {
+    flex: none;
+    width: 75%;
+  }
+  .column.is-two-thirds, .column.is-two-thirds-tablet {
+    flex: none;
+    width: 66.6666%;
+  }
+  .column.is-half, .column.is-half-tablet {
+    flex: none;
+    width: 50%;
+  }
+  .column.is-one-third, .column.is-one-third-tablet {
+    flex: none;
+    width: 33.3333%;
+  }
+  .column.is-one-quarter, .column.is-one-quarter-tablet {
+    flex: none;
+    width: 25%;
+  }
+  .column.is-one-fifth, .column.is-one-fifth-tablet {
+    flex: none;
+    width: 20%;
+  }
+  .column.is-two-fifths, .column.is-two-fifths-tablet {
+    flex: none;
+    width: 40%;
+  }
+  .column.is-three-fifths, .column.is-three-fifths-tablet {
+    flex: none;
+    width: 60%;
+  }
+  .column.is-four-fifths, .column.is-four-fifths-tablet {
+    flex: none;
+    width: 80%;
+  }
+  .column.is-offset-three-quarters, .column.is-offset-three-quarters-tablet {
+    margin-inline-start: 75%;
+  }
+  .column.is-offset-two-thirds, .column.is-offset-two-thirds-tablet {
+    margin-inline-start: 66.6666%;
+  }
+  .column.is-offset-half, .column.is-offset-half-tablet {
+    margin-inline-start: 50%;
+  }
+  .column.is-offset-one-third, .column.is-offset-one-third-tablet {
+    margin-inline-start: 0.3333%;
+  }
+  .column.is-offset-one-quarter, .column.is-offset-one-quarter-tablet {
+    margin-inline-start: 25%;
+  }
+  .column.is-offset-one-fifth, .column.is-offset-one-fifth-tablet {
+    margin-inline-start: 20%;
+  }
+  .column.is-offset-two-fifths, .column.is-offset-two-fifths-tablet {
+    margin-inline-start: 40%;
+  }
+  .column.is-offset-three-fifths, .column.is-offset-three-fifths-tablet {
+    margin-inline-start: 60%;
+  }
+  .column.is-offset-four-fifths, .column.is-offset-four-fifths-tablet {
+    margin-inline-start: 80%;
+  }
+  .column.is-0, .column.is-0-tablet {
+    flex: none;
+    width: 0%;
+  }
+  .column.is-offset-0, .column.is-offset-0-tablet {
+    margin-inline-start: 0%;
+  }
+  .column.is-1, .column.is-1-tablet {
+    flex: none;
+    width: 8.3333333333%;
+  }
+  .column.is-offset-1, .column.is-offset-1-tablet {
+    margin-inline-start: 8.3333333333%;
+  }
+  .column.is-2, .column.is-2-tablet {
+    flex: none;
+    width: 16.6666666667%;
+  }
+  .column.is-offset-2, .column.is-offset-2-tablet {
+    margin-inline-start: 16.6666666667%;
+  }
+  .column.is-3, .column.is-3-tablet {
+    flex: none;
+    width: 25%;
+  }
+  .column.is-offset-3, .column.is-offset-3-tablet {
+    margin-inline-start: 25%;
+  }
+  .column.is-4, .column.is-4-tablet {
+    flex: none;
+    width: 33.3333333333%;
+  }
+  .column.is-offset-4, .column.is-offset-4-tablet {
+    margin-inline-start: 33.3333333333%;
+  }
+  .column.is-5, .column.is-5-tablet {
+    flex: none;
+    width: 41.6666666667%;
+  }
+  .column.is-offset-5, .column.is-offset-5-tablet {
+    margin-inline-start: 41.6666666667%;
+  }
+  .column.is-6, .column.is-6-tablet {
+    flex: none;
+    width: 50%;
+  }
+  .column.is-offset-6, .column.is-offset-6-tablet {
+    margin-inline-start: 50%;
+  }
+  .column.is-7, .column.is-7-tablet {
+    flex: none;
+    width: 58.3333333333%;
+  }
+  .column.is-offset-7, .column.is-offset-7-tablet {
+    margin-inline-start: 58.3333333333%;
+  }
+  .column.is-8, .column.is-8-tablet {
+    flex: none;
+    width: 66.6666666667%;
+  }
+  .column.is-offset-8, .column.is-offset-8-tablet {
+    margin-inline-start: 66.6666666667%;
+  }
+  .column.is-9, .column.is-9-tablet {
+    flex: none;
+    width: 75%;
+  }
+  .column.is-offset-9, .column.is-offset-9-tablet {
+    margin-inline-start: 75%;
+  }
+  .column.is-10, .column.is-10-tablet {
+    flex: none;
+    width: 83.3333333333%;
+  }
+  .column.is-offset-10, .column.is-offset-10-tablet {
+    margin-inline-start: 83.3333333333%;
+  }
+  .column.is-11, .column.is-11-tablet {
+    flex: none;
+    width: 91.6666666667%;
+  }
+  .column.is-offset-11, .column.is-offset-11-tablet {
+    margin-inline-start: 91.6666666667%;
+  }
+  .column.is-12, .column.is-12-tablet {
+    flex: none;
+    width: 100%;
+  }
+  .column.is-offset-12, .column.is-offset-12-tablet {
+    margin-inline-start: 100%;
+  }
+}
+@media screen and (max-width: 1023px) {
+  .column.is-narrow-touch {
+    flex: none;
+    width: unset;
+  }
+  .column.is-full-touch {
+    flex: none;
+    width: 100%;
+  }
+  .column.is-three-quarters-touch {
+    flex: none;
+    width: 75%;
+  }
+  .column.is-two-thirds-touch {
+    flex: none;
+    width: 66.6666%;
+  }
+  .column.is-half-touch {
+    flex: none;
+    width: 50%;
+  }
+  .column.is-one-third-touch {
+    flex: none;
+    width: 33.3333%;
+  }
+  .column.is-one-quarter-touch {
+    flex: none;
+    width: 25%;
+  }
+  .column.is-one-fifth-touch {
+    flex: none;
+    width: 20%;
+  }
+  .column.is-two-fifths-touch {
+    flex: none;
+    width: 40%;
+  }
+  .column.is-three-fifths-touch {
+    flex: none;
+    width: 60%;
+  }
+  .column.is-four-fifths-touch {
+    flex: none;
+    width: 80%;
+  }
+  .column.is-offset-three-quarters-touch {
+    margin-inline-start: 75%;
+  }
+  .column.is-offset-two-thirds-touch {
+    margin-inline-start: 66.6666%;
+  }
+  .column.is-offset-half-touch {
+    margin-inline-start: 50%;
+  }
+  .column.is-offset-one-third-touch {
+    margin-inline-start: 0.3333%;
+  }
+  .column.is-offset-one-quarter-touch {
+    margin-inline-start: 25%;
+  }
+  .column.is-offset-one-fifth-touch {
+    margin-inline-start: 20%;
+  }
+  .column.is-offset-two-fifths-touch {
+    margin-inline-start: 40%;
+  }
+  .column.is-offset-three-fifths-touch {
+    margin-inline-start: 60%;
+  }
+  .column.is-offset-four-fifths-touch {
+    margin-inline-start: 80%;
+  }
+  .column.is-0-touch {
+    flex: none;
+    width: 0%;
+  }
+  .column.is-offset-0-touch {
+    margin-inline-start: 0%;
+  }
+  .column.is-1-touch {
+    flex: none;
+    width: 8.3333333333%;
+  }
+  .column.is-offset-1-touch {
+    margin-inline-start: 8.3333333333%;
+  }
+  .column.is-2-touch {
+    flex: none;
+    width: 16.6666666667%;
+  }
+  .column.is-offset-2-touch {
+    margin-inline-start: 16.6666666667%;
+  }
+  .column.is-3-touch {
+    flex: none;
+    width: 25%;
+  }
+  .column.is-offset-3-touch {
+    margin-inline-start: 25%;
+  }
+  .column.is-4-touch {
+    flex: none;
+    width: 33.3333333333%;
+  }
+  .column.is-offset-4-touch {
+    margin-inline-start: 33.3333333333%;
+  }
+  .column.is-5-touch {
+    flex: none;
+    width: 41.6666666667%;
+  }
+  .column.is-offset-5-touch {
+    margin-inline-start: 41.6666666667%;
+  }
+  .column.is-6-touch {
+    flex: none;
+    width: 50%;
+  }
+  .column.is-offset-6-touch {
+    margin-inline-start: 50%;
+  }
+  .column.is-7-touch {
+    flex: none;
+    width: 58.3333333333%;
+  }
+  .column.is-offset-7-touch {
+    margin-inline-start: 58.3333333333%;
+  }
+  .column.is-8-touch {
+    flex: none;
+    width: 66.6666666667%;
+  }
+  .column.is-offset-8-touch {
+    margin-inline-start: 66.6666666667%;
+  }
+  .column.is-9-touch {
+    flex: none;
+    width: 75%;
+  }
+  .column.is-offset-9-touch {
+    margin-inline-start: 75%;
+  }
+  .column.is-10-touch {
+    flex: none;
+    width: 83.3333333333%;
+  }
+  .column.is-offset-10-touch {
+    margin-inline-start: 83.3333333333%;
+  }
+  .column.is-11-touch {
+    flex: none;
+    width: 91.6666666667%;
+  }
+  .column.is-offset-11-touch {
+    margin-inline-start: 91.6666666667%;
+  }
+  .column.is-12-touch {
+    flex: none;
+    width: 100%;
+  }
+  .column.is-offset-12-touch {
+    margin-inline-start: 100%;
+  }
+}
+@media screen and (min-width: 1024px) {
+  .column.is-narrow-desktop {
+    flex: none;
+    width: unset;
+  }
+  .column.is-full-desktop {
+    flex: none;
+    width: 100%;
+  }
+  .column.is-three-quarters-desktop {
+    flex: none;
+    width: 75%;
+  }
+  .column.is-two-thirds-desktop {
+    flex: none;
+    width: 66.6666%;
+  }
+  .column.is-half-desktop {
+    flex: none;
+    width: 50%;
+  }
+  .column.is-one-third-desktop {
+    flex: none;
+    width: 33.3333%;
+  }
+  .column.is-one-quarter-desktop {
+    flex: none;
+    width: 25%;
+  }
+  .column.is-one-fifth-desktop {
+    flex: none;
+    width: 20%;
+  }
+  .column.is-two-fifths-desktop {
+    flex: none;
+    width: 40%;
+  }
+  .column.is-three-fifths-desktop {
+    flex: none;
+    width: 60%;
+  }
+  .column.is-four-fifths-desktop {
+    flex: none;
+    width: 80%;
+  }
+  .column.is-offset-three-quarters-desktop {
+    margin-inline-start: 75%;
+  }
+  .column.is-offset-two-thirds-desktop {
+    margin-inline-start: 66.6666%;
+  }
+  .column.is-offset-half-desktop {
+    margin-inline-start: 50%;
+  }
+  .column.is-offset-one-third-desktop {
+    margin-inline-start: 0.3333%;
+  }
+  .column.is-offset-one-quarter-desktop {
+    margin-inline-start: 25%;
+  }
+  .column.is-offset-one-fifth-desktop {
+    margin-inline-start: 20%;
+  }
+  .column.is-offset-two-fifths-desktop {
+    margin-inline-start: 40%;
+  }
+  .column.is-offset-three-fifths-desktop {
+    margin-inline-start: 60%;
+  }
+  .column.is-offset-four-fifths-desktop {
+    margin-inline-start: 80%;
+  }
+  .column.is-0-desktop {
+    flex: none;
+    width: 0%;
+  }
+  .column.is-offset-0-desktop {
+    margin-inline-start: 0%;
+  }
+  .column.is-1-desktop {
+    flex: none;
+    width: 8.3333333333%;
+  }
+  .column.is-offset-1-desktop {
+    margin-inline-start: 8.3333333333%;
+  }
+  .column.is-2-desktop {
+    flex: none;
+    width: 16.6666666667%;
+  }
+  .column.is-offset-2-desktop {
+    margin-inline-start: 16.6666666667%;
+  }
+  .column.is-3-desktop {
+    flex: none;
+    width: 25%;
+  }
+  .column.is-offset-3-desktop {
+    margin-inline-start: 25%;
+  }
+  .column.is-4-desktop {
+    flex: none;
+    width: 33.3333333333%;
+  }
+  .column.is-offset-4-desktop {
+    margin-inline-start: 33.3333333333%;
+  }
+  .column.is-5-desktop {
+    flex: none;
+    width: 41.6666666667%;
+  }
+  .column.is-offset-5-desktop {
+    margin-inline-start: 41.6666666667%;
+  }
+  .column.is-6-desktop {
+    flex: none;
+    width: 50%;
+  }
+  .column.is-offset-6-desktop {
+    margin-inline-start: 50%;
+  }
+  .column.is-7-desktop {
+    flex: none;
+    width: 58.3333333333%;
+  }
+  .column.is-offset-7-desktop {
+    margin-inline-start: 58.3333333333%;
+  }
+  .column.is-8-desktop {
+    flex: none;
+    width: 66.6666666667%;
+  }
+  .column.is-offset-8-desktop {
+    margin-inline-start: 66.6666666667%;
+  }
+  .column.is-9-desktop {
+    flex: none;
+    width: 75%;
+  }
+  .column.is-offset-9-desktop {
+    margin-inline-start: 75%;
+  }
+  .column.is-10-desktop {
+    flex: none;
+    width: 83.3333333333%;
+  }
+  .column.is-offset-10-desktop {
+    margin-inline-start: 83.3333333333%;
+  }
+  .column.is-11-desktop {
+    flex: none;
+    width: 91.6666666667%;
+  }
+  .column.is-offset-11-desktop {
+    margin-inline-start: 91.6666666667%;
+  }
+  .column.is-12-desktop {
+    flex: none;
+    width: 100%;
+  }
+  .column.is-offset-12-desktop {
+    margin-inline-start: 100%;
+  }
+}
+@media screen and (min-width: 1216px) {
+  .column.is-narrow-widescreen {
+    flex: none;
+    width: unset;
+  }
+  .column.is-full-widescreen {
+    flex: none;
+    width: 100%;
+  }
+  .column.is-three-quarters-widescreen {
+    flex: none;
+    width: 75%;
+  }
+  .column.is-two-thirds-widescreen {
+    flex: none;
+    width: 66.6666%;
+  }
+  .column.is-half-widescreen {
+    flex: none;
+    width: 50%;
+  }
+  .column.is-one-third-widescreen {
+    flex: none;
+    width: 33.3333%;
+  }
+  .column.is-one-quarter-widescreen {
+    flex: none;
+    width: 25%;
+  }
+  .column.is-one-fifth-widescreen {
+    flex: none;
+    width: 20%;
+  }
+  .column.is-two-fifths-widescreen {
+    flex: none;
+    width: 40%;
+  }
+  .column.is-three-fifths-widescreen {
+    flex: none;
+    width: 60%;
+  }
+  .column.is-four-fifths-widescreen {
+    flex: none;
+    width: 80%;
+  }
+  .column.is-offset-three-quarters-widescreen {
+    margin-inline-start: 75%;
+  }
+  .column.is-offset-two-thirds-widescreen {
+    margin-inline-start: 66.6666%;
+  }
+  .column.is-offset-half-widescreen {
+    margin-inline-start: 50%;
+  }
+  .column.is-offset-one-third-widescreen {
+    margin-inline-start: 0.3333%;
+  }
+  .column.is-offset-one-quarter-widescreen {
+    margin-inline-start: 25%;
+  }
+  .column.is-offset-one-fifth-widescreen {
+    margin-inline-start: 20%;
+  }
+  .column.is-offset-two-fifths-widescreen {
+    margin-inline-start: 40%;
+  }
+  .column.is-offset-three-fifths-widescreen {
+    margin-inline-start: 60%;
+  }
+  .column.is-offset-four-fifths-widescreen {
+    margin-inline-start: 80%;
+  }
+  .column.is-0-widescreen {
+    flex: none;
+    width: 0%;
+  }
+  .column.is-offset-0-widescreen {
+    margin-inline-start: 0%;
+  }
+  .column.is-1-widescreen {
+    flex: none;
+    width: 8.3333333333%;
+  }
+  .column.is-offset-1-widescreen {
+    margin-inline-start: 8.3333333333%;
+  }
+  .column.is-2-widescreen {
+    flex: none;
+    width: 16.6666666667%;
+  }
+  .column.is-offset-2-widescreen {
+    margin-inline-start: 16.6666666667%;
+  }
+  .column.is-3-widescreen {
+    flex: none;
+    width: 25%;
+  }
+  .column.is-offset-3-widescreen {
+    margin-inline-start: 25%;
+  }
+  .column.is-4-widescreen {
+    flex: none;
+    width: 33.3333333333%;
+  }
+  .column.is-offset-4-widescreen {
+    margin-inline-start: 33.3333333333%;
+  }
+  .column.is-5-widescreen {
+    flex: none;
+    width: 41.6666666667%;
+  }
+  .column.is-offset-5-widescreen {
+    margin-inline-start: 41.6666666667%;
+  }
+  .column.is-6-widescreen {
+    flex: none;
+    width: 50%;
+  }
+  .column.is-offset-6-widescreen {
+    margin-inline-start: 50%;
+  }
+  .column.is-7-widescreen {
+    flex: none;
+    width: 58.3333333333%;
+  }
+  .column.is-offset-7-widescreen {
+    margin-inline-start: 58.3333333333%;
+  }
+  .column.is-8-widescreen {
+    flex: none;
+    width: 66.6666666667%;
+  }
+  .column.is-offset-8-widescreen {
+    margin-inline-start: 66.6666666667%;
+  }
+  .column.is-9-widescreen {
+    flex: none;
+    width: 75%;
+  }
+  .column.is-offset-9-widescreen {
+    margin-inline-start: 75%;
+  }
+  .column.is-10-widescreen {
+    flex: none;
+    width: 83.3333333333%;
+  }
+  .column.is-offset-10-widescreen {
+    margin-inline-start: 83.3333333333%;
+  }
+  .column.is-11-widescreen {
+    flex: none;
+    width: 91.6666666667%;
+  }
+  .column.is-offset-11-widescreen {
+    margin-inline-start: 91.6666666667%;
+  }
+  .column.is-12-widescreen {
+    flex: none;
+    width: 100%;
+  }
+  .column.is-offset-12-widescreen {
+    margin-inline-start: 100%;
+  }
+}
+@media screen and (min-width: 1408px) {
+  .column.is-narrow-fullhd {
+    flex: none;
+    width: unset;
+  }
+  .column.is-full-fullhd {
+    flex: none;
+    width: 100%;
+  }
+  .column.is-three-quarters-fullhd {
+    flex: none;
+    width: 75%;
+  }
+  .column.is-two-thirds-fullhd {
+    flex: none;
+    width: 66.6666%;
+  }
+  .column.is-half-fullhd {
+    flex: none;
+    width: 50%;
+  }
+  .column.is-one-third-fullhd {
+    flex: none;
+    width: 33.3333%;
+  }
+  .column.is-one-quarter-fullhd {
+    flex: none;
+    width: 25%;
+  }
+  .column.is-one-fifth-fullhd {
+    flex: none;
+    width: 20%;
+  }
+  .column.is-two-fifths-fullhd {
+    flex: none;
+    width: 40%;
+  }
+  .column.is-three-fifths-fullhd {
+    flex: none;
+    width: 60%;
+  }
+  .column.is-four-fifths-fullhd {
+    flex: none;
+    width: 80%;
+  }
+  .column.is-offset-three-quarters-fullhd {
+    margin-inline-start: 75%;
+  }
+  .column.is-offset-two-thirds-fullhd {
+    margin-inline-start: 66.6666%;
+  }
+  .column.is-offset-half-fullhd {
+    margin-inline-start: 50%;
+  }
+  .column.is-offset-one-third-fullhd {
+    margin-inline-start: 33.3333%;
+  }
+  .column.is-offset-one-quarter-fullhd {
+    margin-inline-start: 25%;
+  }
+  .column.is-offset-one-fifth-fullhd {
+    margin-inline-start: 20%;
+  }
+  .column.is-offset-two-fifths-fullhd {
+    margin-inline-start: 40%;
+  }
+  .column.is-offset-three-fifths-fullhd {
+    margin-inline-start: 60%;
+  }
+  .column.is-offset-four-fifths-fullhd {
+    margin-inline-start: 80%;
+  }
+  .column.is-0-fullhd {
+    flex: none;
+    width: 0%;
+  }
+  .column.is-offset-0-fullhd {
+    margin-inline-start: 0%;
+  }
+  .column.is-1-fullhd {
+    flex: none;
+    width: 8.3333333333%;
+  }
+  .column.is-offset-1-fullhd {
+    margin-inline-start: 8.3333333333%;
+  }
+  .column.is-2-fullhd {
+    flex: none;
+    width: 16.6666666667%;
+  }
+  .column.is-offset-2-fullhd {
+    margin-inline-start: 16.6666666667%;
+  }
+  .column.is-3-fullhd {
+    flex: none;
+    width: 25%;
+  }
+  .column.is-offset-3-fullhd {
+    margin-inline-start: 25%;
+  }
+  .column.is-4-fullhd {
+    flex: none;
+    width: 33.3333333333%;
+  }
+  .column.is-offset-4-fullhd {
+    margin-inline-start: 33.3333333333%;
+  }
+  .column.is-5-fullhd {
+    flex: none;
+    width: 41.6666666667%;
+  }
+  .column.is-offset-5-fullhd {
+    margin-inline-start: 41.6666666667%;
+  }
+  .column.is-6-fullhd {
+    flex: none;
+    width: 50%;
+  }
+  .column.is-offset-6-fullhd {
+    margin-inline-start: 50%;
+  }
+  .column.is-7-fullhd {
+    flex: none;
+    width: 58.3333333333%;
+  }
+  .column.is-offset-7-fullhd {
+    margin-inline-start: 58.3333333333%;
+  }
+  .column.is-8-fullhd {
+    flex: none;
+    width: 66.6666666667%;
+  }
+  .column.is-offset-8-fullhd {
+    margin-inline-start: 66.6666666667%;
+  }
+  .column.is-9-fullhd {
+    flex: none;
+    width: 75%;
+  }
+  .column.is-offset-9-fullhd {
+    margin-inline-start: 75%;
+  }
+  .column.is-10-fullhd {
+    flex: none;
+    width: 83.3333333333%;
+  }
+  .column.is-offset-10-fullhd {
+    margin-inline-start: 83.3333333333%;
+  }
+  .column.is-11-fullhd {
+    flex: none;
+    width: 91.6666666667%;
+  }
+  .column.is-offset-11-fullhd {
+    margin-inline-start: 91.6666666667%;
+  }
+  .column.is-12-fullhd {
+    flex: none;
+    width: 100%;
+  }
+  .column.is-offset-12-fullhd {
+    margin-inline-start: 100%;
+  }
+}
+
+.columns {
+  margin-inline-start: calc(-1 * var(--bulma-column-gap));
+  margin-inline-end: calc(-1 * var(--bulma-column-gap));
+  margin-top: calc(-1 * var(--bulma-column-gap));
+}
+.columns:last-child {
+  margin-bottom: calc(-1 * var(--bulma-column-gap));
+}
+.columns:not(:last-child) {
+  margin-bottom: calc(var(--bulma-block-spacing) - var(--bulma-column-gap));
+}
+.columns.is-centered {
+  justify-content: center;
+}
+.columns.is-gapless {
+  margin-inline-start: 0;
+  margin-inline-end: 0;
+  margin-top: 0;
+}
+.columns.is-gapless > .column {
+  margin: 0;
+  padding: 0 !important;
+}
+.columns.is-gapless:not(:last-child) {
+  margin-bottom: 1.5rem;
+}
+.columns.is-gapless:last-child {
+  margin-bottom: 0;
+}
+.columns.is-mobile {
+  display: flex;
+}
+.columns.is-multiline {
+  flex-wrap: wrap;
+}
+.columns.is-vcentered {
+  align-items: center;
+}
+@media screen and (min-width: 769px), print {
+  .columns:not(.is-desktop) {
+    display: flex;
+  }
+}
+@media screen and (min-width: 1024px) {
+  .columns.is-desktop {
+    display: flex;
+  }
+}
+.columns.is-0 {
+  --bulma-column-gap: 0rem;
+}
+@media screen and (max-width: 768px) {
+  .columns.is-0-mobile {
+    --bulma-column-gap: 0rem;
+  }
+}
+@media screen and (min-width: 769px), print {
+  .columns.is-0-tablet {
+    --bulma-column-gap: 0rem;
+  }
+}
+@media screen and (min-width: 769px) and (max-width: 1023px) {
+  .columns.is-0-tablet-only {
+    --bulma-column-gap: 0rem;
+  }
+}
+@media screen and (max-width: 1023px) {
+  .columns.is-0-touch {
+    --bulma-column-gap: 0rem;
+  }
+}
+@media screen and (min-width: 1024px) {
+  .columns.is-0-desktop {
+    --bulma-column-gap: 0rem;
+  }
+}
+@media screen and (min-width: 1024px) and (max-width: 1215px) {
+  .columns.is-0-desktop-only {
+    --bulma-column-gap: 0rem;
+  }
+}
+@media screen and (min-width: 1216px) {
+  .columns.is-0-widescreen {
+    --bulma-column-gap: 0rem;
+  }
+}
+@media screen and (min-width: 1216px) and (max-width: 1407px) {
+  .columns.is-0-widescreen-only {
+    --bulma-column-gap: 0rem;
+  }
+}
+@media screen and (min-width: 1408px) {
+  .columns.is-0-fullhd {
+    --bulma-column-gap: 0rem;
+  }
+}
+.columns.is-1 {
+  --bulma-column-gap: 0.25rem;
+}
+@media screen and (max-width: 768px) {
+  .columns.is-1-mobile {
+    --bulma-column-gap: 0.25rem;
+  }
+}
+@media screen and (min-width: 769px), print {
+  .columns.is-1-tablet {
+    --bulma-column-gap: 0.25rem;
+  }
+}
+@media screen and (min-width: 769px) and (max-width: 1023px) {
+  .columns.is-1-tablet-only {
+    --bulma-column-gap: 0.25rem;
+  }
+}
+@media screen and (max-width: 1023px) {
+  .columns.is-1-touch {
+    --bulma-column-gap: 0.25rem;
+  }
+}
+@media screen and (min-width: 1024px) {
+  .columns.is-1-desktop {
+    --bulma-column-gap: 0.25rem;
+  }
+}
+@media screen and (min-width: 1024px) and (max-width: 1215px) {
+  .columns.is-1-desktop-only {
+    --bulma-column-gap: 0.25rem;
+  }
+}
+@media screen and (min-width: 1216px) {
+  .columns.is-1-widescreen {
+    --bulma-column-gap: 0.25rem;
+  }
+}
+@media screen and (min-width: 1216px) and (max-width: 1407px) {
+  .columns.is-1-widescreen-only {
+    --bulma-column-gap: 0.25rem;
+  }
+}
+@media screen and (min-width: 1408px) {
+  .columns.is-1-fullhd {
+    --bulma-column-gap: 0.25rem;
+  }
+}
+.columns.is-2 {
+  --bulma-column-gap: 0.5rem;
+}
+@media screen and (max-width: 768px) {
+  .columns.is-2-mobile {
+    --bulma-column-gap: 0.5rem;
+  }
+}
+@media screen and (min-width: 769px), print {
+  .columns.is-2-tablet {
+    --bulma-column-gap: 0.5rem;
+  }
+}
+@media screen and (min-width: 769px) and (max-width: 1023px) {
+  .columns.is-2-tablet-only {
+    --bulma-column-gap: 0.5rem;
+  }
+}
+@media screen and (max-width: 1023px) {
+  .columns.is-2-touch {
+    --bulma-column-gap: 0.5rem;
+  }
+}
+@media screen and (min-width: 1024px) {
+  .columns.is-2-desktop {
+    --bulma-column-gap: 0.5rem;
+  }
+}
+@media screen and (min-width: 1024px) and (max-width: 1215px) {
+  .columns.is-2-desktop-only {
+    --bulma-column-gap: 0.5rem;
+  }
+}
+@media screen and (min-width: 1216px) {
+  .columns.is-2-widescreen {
+    --bulma-column-gap: 0.5rem;
+  }
+}
+@media screen and (min-width: 1216px) and (max-width: 1407px) {
+  .columns.is-2-widescreen-only {
+    --bulma-column-gap: 0.5rem;
+  }
+}
+@media screen and (min-width: 1408px) {
+  .columns.is-2-fullhd {
+    --bulma-column-gap: 0.5rem;
+  }
+}
+.columns.is-3 {
+  --bulma-column-gap: 0.75rem;
+}
+@media screen and (max-width: 768px) {
+  .columns.is-3-mobile {
+    --bulma-column-gap: 0.75rem;
+  }
+}
+@media screen and (min-width: 769px), print {
+  .columns.is-3-tablet {
+    --bulma-column-gap: 0.75rem;
+  }
+}
+@media screen and (min-width: 769px) and (max-width: 1023px) {
+  .columns.is-3-tablet-only {
+    --bulma-column-gap: 0.75rem;
+  }
+}
+@media screen and (max-width: 1023px) {
+  .columns.is-3-touch {
+    --bulma-column-gap: 0.75rem;
+  }
+}
+@media screen and (min-width: 1024px) {
+  .columns.is-3-desktop {
+    --bulma-column-gap: 0.75rem;
+  }
+}
+@media screen and (min-width: 1024px) and (max-width: 1215px) {
+  .columns.is-3-desktop-only {
+    --bulma-column-gap: 0.75rem;
+  }
+}
+@media screen and (min-width: 1216px) {
+  .columns.is-3-widescreen {
+    --bulma-column-gap: 0.75rem;
+  }
+}
+@media screen and (min-width: 1216px) and (max-width: 1407px) {
+  .columns.is-3-widescreen-only {
+    --bulma-column-gap: 0.75rem;
+  }
+}
+@media screen and (min-width: 1408px) {
+  .columns.is-3-fullhd {
+    --bulma-column-gap: 0.75rem;
+  }
+}
+.columns.is-4 {
+  --bulma-column-gap: 1rem;
+}
+@media screen and (max-width: 768px) {
+  .columns.is-4-mobile {
+    --bulma-column-gap: 1rem;
+  }
+}
+@media screen and (min-width: 769px), print {
+  .columns.is-4-tablet {
+    --bulma-column-gap: 1rem;
+  }
+}
+@media screen and (min-width: 769px) and (max-width: 1023px) {
+  .columns.is-4-tablet-only {
+    --bulma-column-gap: 1rem;
+  }
+}
+@media screen and (max-width: 1023px) {
+  .columns.is-4-touch {
+    --bulma-column-gap: 1rem;
+  }
+}
+@media screen and (min-width: 1024px) {
+  .columns.is-4-desktop {
+    --bulma-column-gap: 1rem;
+  }
+}
+@media screen and (min-width: 1024px) and (max-width: 1215px) {
+  .columns.is-4-desktop-only {
+    --bulma-column-gap: 1rem;
+  }
+}
+@media screen and (min-width: 1216px) {
+  .columns.is-4-widescreen {
+    --bulma-column-gap: 1rem;
+  }
+}
+@media screen and (min-width: 1216px) and (max-width: 1407px) {
+  .columns.is-4-widescreen-only {
+    --bulma-column-gap: 1rem;
+  }
+}
+@media screen and (min-width: 1408px) {
+  .columns.is-4-fullhd {
+    --bulma-column-gap: 1rem;
+  }
+}
+.columns.is-5 {
+  --bulma-column-gap: 1.25rem;
+}
+@media screen and (max-width: 768px) {
+  .columns.is-5-mobile {
+    --bulma-column-gap: 1.25rem;
+  }
+}
+@media screen and (min-width: 769px), print {
+  .columns.is-5-tablet {
+    --bulma-column-gap: 1.25rem;
+  }
+}
+@media screen and (min-width: 769px) and (max-width: 1023px) {
+  .columns.is-5-tablet-only {
+    --bulma-column-gap: 1.25rem;
+  }
+}
+@media screen and (max-width: 1023px) {
+  .columns.is-5-touch {
+    --bulma-column-gap: 1.25rem;
+  }
+}
+@media screen and (min-width: 1024px) {
+  .columns.is-5-desktop {
+    --bulma-column-gap: 1.25rem;
+  }
+}
+@media screen and (min-width: 1024px) and (max-width: 1215px) {
+  .columns.is-5-desktop-only {
+    --bulma-column-gap: 1.25rem;
+  }
+}
+@media screen and (min-width: 1216px) {
+  .columns.is-5-widescreen {
+    --bulma-column-gap: 1.25rem;
+  }
+}
+@media screen and (min-width: 1216px) and (max-width: 1407px) {
+  .columns.is-5-widescreen-only {
+    --bulma-column-gap: 1.25rem;
+  }
+}
+@media screen and (min-width: 1408px) {
+  .columns.is-5-fullhd {
+    --bulma-column-gap: 1.25rem;
+  }
+}
+.columns.is-6 {
+  --bulma-column-gap: 1.5rem;
+}
+@media screen and (max-width: 768px) {
+  .columns.is-6-mobile {
+    --bulma-column-gap: 1.5rem;
+  }
+}
+@media screen and (min-width: 769px), print {
+  .columns.is-6-tablet {
+    --bulma-column-gap: 1.5rem;
+  }
+}
+@media screen and (min-width: 769px) and (max-width: 1023px) {
+  .columns.is-6-tablet-only {
+    --bulma-column-gap: 1.5rem;
+  }
+}
+@media screen and (max-width: 1023px) {
+  .columns.is-6-touch {
+    --bulma-column-gap: 1.5rem;
+  }
+}
+@media screen and (min-width: 1024px) {
+  .columns.is-6-desktop {
+    --bulma-column-gap: 1.5rem;
+  }
+}
+@media screen and (min-width: 1024px) and (max-width: 1215px) {
+  .columns.is-6-desktop-only {
+    --bulma-column-gap: 1.5rem;
+  }
+}
+@media screen and (min-width: 1216px) {
+  .columns.is-6-widescreen {
+    --bulma-column-gap: 1.5rem;
+  }
+}
+@media screen and (min-width: 1216px) and (max-width: 1407px) {
+  .columns.is-6-widescreen-only {
+    --bulma-column-gap: 1.5rem;
+  }
+}
+@media screen and (min-width: 1408px) {
+  .columns.is-6-fullhd {
+    --bulma-column-gap: 1.5rem;
+  }
+}
+.columns.is-7 {
+  --bulma-column-gap: 1.75rem;
+}
+@media screen and (max-width: 768px) {
+  .columns.is-7-mobile {
+    --bulma-column-gap: 1.75rem;
+  }
+}
+@media screen and (min-width: 769px), print {
+  .columns.is-7-tablet {
+    --bulma-column-gap: 1.75rem;
+  }
+}
+@media screen and (min-width: 769px) and (max-width: 1023px) {
+  .columns.is-7-tablet-only {
+    --bulma-column-gap: 1.75rem;
+  }
+}
+@media screen and (max-width: 1023px) {
+  .columns.is-7-touch {
+    --bulma-column-gap: 1.75rem;
+  }
+}
+@media screen and (min-width: 1024px) {
+  .columns.is-7-desktop {
+    --bulma-column-gap: 1.75rem;
+  }
+}
+@media screen and (min-width: 1024px) and (max-width: 1215px) {
+  .columns.is-7-desktop-only {
+    --bulma-column-gap: 1.75rem;
+  }
+}
+@media screen and (min-width: 1216px) {
+  .columns.is-7-widescreen {
+    --bulma-column-gap: 1.75rem;
+  }
+}
+@media screen and (min-width: 1216px) and (max-width: 1407px) {
+  .columns.is-7-widescreen-only {
+    --bulma-column-gap: 1.75rem;
+  }
+}
+@media screen and (min-width: 1408px) {
+  .columns.is-7-fullhd {
+    --bulma-column-gap: 1.75rem;
+  }
+}
+.columns.is-8 {
+  --bulma-column-gap: 2rem;
+}
+@media screen and (max-width: 768px) {
+  .columns.is-8-mobile {
+    --bulma-column-gap: 2rem;
+  }
+}
+@media screen and (min-width: 769px), print {
+  .columns.is-8-tablet {
+    --bulma-column-gap: 2rem;
+  }
+}
+@media screen and (min-width: 769px) and (max-width: 1023px) {
+  .columns.is-8-tablet-only {
+    --bulma-column-gap: 2rem;
+  }
+}
+@media screen and (max-width: 1023px) {
+  .columns.is-8-touch {
+    --bulma-column-gap: 2rem;
+  }
+}
+@media screen and (min-width: 1024px) {
+  .columns.is-8-desktop {
+    --bulma-column-gap: 2rem;
+  }
+}
+@media screen and (min-width: 1024px) and (max-width: 1215px) {
+  .columns.is-8-desktop-only {
+    --bulma-column-gap: 2rem;
+  }
+}
+@media screen and (min-width: 1216px) {
+  .columns.is-8-widescreen {
+    --bulma-column-gap: 2rem;
+  }
+}
+@media screen and (min-width: 1216px) and (max-width: 1407px) {
+  .columns.is-8-widescreen-only {
+    --bulma-column-gap: 2rem;
+  }
+}
+@media screen and (min-width: 1408px) {
+  .columns.is-8-fullhd {
+    --bulma-column-gap: 2rem;
+  }
+}
+
+.fixed-grid {
+  container-name: bulma-fixed-grid;
+  container-type: inline-size;
+}
+.fixed-grid > .grid {
+  --bulma-grid-gap-count: calc(var(--bulma-grid-column-count) - 1);
+  --bulma-grid-column-count: 2;
+  grid-template-columns: repeat(var(--bulma-grid-column-count), 1fr);
+}
+.fixed-grid.has-1-cols > .grid {
+  --bulma-grid-column-count: 1;
+}
+.fixed-grid.has-2-cols > .grid {
+  --bulma-grid-column-count: 2;
+}
+.fixed-grid.has-3-cols > .grid {
+  --bulma-grid-column-count: 3;
+}
+.fixed-grid.has-4-cols > .grid {
+  --bulma-grid-column-count: 4;
+}
+.fixed-grid.has-5-cols > .grid {
+  --bulma-grid-column-count: 5;
+}
+.fixed-grid.has-6-cols > .grid {
+  --bulma-grid-column-count: 6;
+}
+.fixed-grid.has-7-cols > .grid {
+  --bulma-grid-column-count: 7;
+}
+.fixed-grid.has-8-cols > .grid {
+  --bulma-grid-column-count: 8;
+}
+.fixed-grid.has-9-cols > .grid {
+  --bulma-grid-column-count: 9;
+}
+.fixed-grid.has-10-cols > .grid {
+  --bulma-grid-column-count: 10;
+}
+.fixed-grid.has-11-cols > .grid {
+  --bulma-grid-column-count: 11;
+}
+.fixed-grid.has-12-cols > .grid {
+  --bulma-grid-column-count: 12;
+}
+@container bulma-fixed-grid (max-width: 768px) {
+  .fixed-grid.has-1-cols-mobile > .grid {
+    --bulma-grid-column-count: 1;
+  }
+  .fixed-grid.has-2-cols-mobile > .grid {
+    --bulma-grid-column-count: 2;
+  }
+  .fixed-grid.has-3-cols-mobile > .grid {
+    --bulma-grid-column-count: 3;
+  }
+  .fixed-grid.has-4-cols-mobile > .grid {
+    --bulma-grid-column-count: 4;
+  }
+  .fixed-grid.has-5-cols-mobile > .grid {
+    --bulma-grid-column-count: 5;
+  }
+  .fixed-grid.has-6-cols-mobile > .grid {
+    --bulma-grid-column-count: 6;
+  }
+  .fixed-grid.has-7-cols-mobile > .grid {
+    --bulma-grid-column-count: 7;
+  }
+  .fixed-grid.has-8-cols-mobile > .grid {
+    --bulma-grid-column-count: 8;
+  }
+  .fixed-grid.has-9-cols-mobile > .grid {
+    --bulma-grid-column-count: 9;
+  }
+  .fixed-grid.has-10-cols-mobile > .grid {
+    --bulma-grid-column-count: 10;
+  }
+  .fixed-grid.has-11-cols-mobile > .grid {
+    --bulma-grid-column-count: 11;
+  }
+  .fixed-grid.has-12-cols-mobile > .grid {
+    --bulma-grid-column-count: 12;
+  }
+}
+@container bulma-fixed-grid (min-width: 769px) {
+  .fixed-grid.has-1-cols-tablet > .grid {
+    --bulma-grid-column-count: 1;
+  }
+  .fixed-grid.has-2-cols-tablet > .grid {
+    --bulma-grid-column-count: 2;
+  }
+  .fixed-grid.has-3-cols-tablet > .grid {
+    --bulma-grid-column-count: 3;
+  }
+  .fixed-grid.has-4-cols-tablet > .grid {
+    --bulma-grid-column-count: 4;
+  }
+  .fixed-grid.has-5-cols-tablet > .grid {
+    --bulma-grid-column-count: 5;
+  }
+  .fixed-grid.has-6-cols-tablet > .grid {
+    --bulma-grid-column-count: 6;
+  }
+  .fixed-grid.has-7-cols-tablet > .grid {
+    --bulma-grid-column-count: 7;
+  }
+  .fixed-grid.has-8-cols-tablet > .grid {
+    --bulma-grid-column-count: 8;
+  }
+  .fixed-grid.has-9-cols-tablet > .grid {
+    --bulma-grid-column-count: 9;
+  }
+  .fixed-grid.has-10-cols-tablet > .grid {
+    --bulma-grid-column-count: 10;
+  }
+  .fixed-grid.has-11-cols-tablet > .grid {
+    --bulma-grid-column-count: 11;
+  }
+  .fixed-grid.has-12-cols-tablet > .grid {
+    --bulma-grid-column-count: 12;
+  }
+}
+@container bulma-fixed-grid (min-width: 1024px) {
+  .fixed-grid.has-1-cols-desktop > .grid {
+    --bulma-grid-column-count: 1;
+  }
+  .fixed-grid.has-2-cols-desktop > .grid {
+    --bulma-grid-column-count: 2;
+  }
+  .fixed-grid.has-3-cols-desktop > .grid {
+    --bulma-grid-column-count: 3;
+  }
+  .fixed-grid.has-4-cols-desktop > .grid {
+    --bulma-grid-column-count: 4;
+  }
+  .fixed-grid.has-5-cols-desktop > .grid {
+    --bulma-grid-column-count: 5;
+  }
+  .fixed-grid.has-6-cols-desktop > .grid {
+    --bulma-grid-column-count: 6;
+  }
+  .fixed-grid.has-7-cols-desktop > .grid {
+    --bulma-grid-column-count: 7;
+  }
+  .fixed-grid.has-8-cols-desktop > .grid {
+    --bulma-grid-column-count: 8;
+  }
+  .fixed-grid.has-9-cols-desktop > .grid {
+    --bulma-grid-column-count: 9;
+  }
+  .fixed-grid.has-10-cols-desktop > .grid {
+    --bulma-grid-column-count: 10;
+  }
+  .fixed-grid.has-11-cols-desktop > .grid {
+    --bulma-grid-column-count: 11;
+  }
+  .fixed-grid.has-12-cols-desktop > .grid {
+    --bulma-grid-column-count: 12;
+  }
+}
+@container bulma-fixed-grid (min-width: 1216px) {
+  .fixed-grid.has-1-cols-widescreen > .grid {
+    --bulma-grid-column-count: 1;
+  }
+  .fixed-grid.has-2-cols-widescreen > .grid {
+    --bulma-grid-column-count: 2;
+  }
+  .fixed-grid.has-3-cols-widescreen > .grid {
+    --bulma-grid-column-count: 3;
+  }
+  .fixed-grid.has-4-cols-widescreen > .grid {
+    --bulma-grid-column-count: 4;
+  }
+  .fixed-grid.has-5-cols-widescreen > .grid {
+    --bulma-grid-column-count: 5;
+  }
+  .fixed-grid.has-6-cols-widescreen > .grid {
+    --bulma-grid-column-count: 6;
+  }
+  .fixed-grid.has-7-cols-widescreen > .grid {
+    --bulma-grid-column-count: 7;
+  }
+  .fixed-grid.has-8-cols-widescreen > .grid {
+    --bulma-grid-column-count: 8;
+  }
+  .fixed-grid.has-9-cols-widescreen > .grid {
+    --bulma-grid-column-count: 9;
+  }
+  .fixed-grid.has-10-cols-widescreen > .grid {
+    --bulma-grid-column-count: 10;
+  }
+  .fixed-grid.has-11-cols-widescreen > .grid {
+    --bulma-grid-column-count: 11;
+  }
+  .fixed-grid.has-12-cols-widescreen > .grid {
+    --bulma-grid-column-count: 12;
+  }
+}
+@container bulma-fixed-grid (min-width: 1408px) {
+  .fixed-grid.has-1-cols-fullhd > .grid {
+    --bulma-grid-column-count: 1;
+  }
+  .fixed-grid.has-2-cols-fullhd > .grid {
+    --bulma-grid-column-count: 2;
+  }
+  .fixed-grid.has-3-cols-fullhd > .grid {
+    --bulma-grid-column-count: 3;
+  }
+  .fixed-grid.has-4-cols-fullhd > .grid {
+    --bulma-grid-column-count: 4;
+  }
+  .fixed-grid.has-5-cols-fullhd > .grid {
+    --bulma-grid-column-count: 5;
+  }
+  .fixed-grid.has-6-cols-fullhd > .grid {
+    --bulma-grid-column-count: 6;
+  }
+  .fixed-grid.has-7-cols-fullhd > .grid {
+    --bulma-grid-column-count: 7;
+  }
+  .fixed-grid.has-8-cols-fullhd > .grid {
+    --bulma-grid-column-count: 8;
+  }
+  .fixed-grid.has-9-cols-fullhd > .grid {
+    --bulma-grid-column-count: 9;
+  }
+  .fixed-grid.has-10-cols-fullhd > .grid {
+    --bulma-grid-column-count: 10;
+  }
+  .fixed-grid.has-11-cols-fullhd > .grid {
+    --bulma-grid-column-count: 11;
+  }
+  .fixed-grid.has-12-cols-fullhd > .grid {
+    --bulma-grid-column-count: 12;
+  }
+}
+@container bulma-fixed-grid (max-width: 768px) {
+  .fixed-grid.has-auto-count .grid {
+    --bulma-grid-column-count: 2;
+  }
+}
+@container bulma-fixed-grid (min-width: 769px) {
+  .fixed-grid.has-auto-count .grid {
+    --bulma-grid-column-count: 4;
+  }
+}
+@container bulma-fixed-grid (min-width: 1024px) {
+  .fixed-grid.has-auto-count .grid {
+    --bulma-grid-column-count: 8;
+  }
+}
+@container bulma-fixed-grid (min-width: 1216px) {
+  .fixed-grid.has-auto-count .grid {
+    --bulma-grid-column-count: 12;
+  }
+}
+@container bulma-fixed-grid (min-width: 1408px) {
+  .fixed-grid.has-auto-count .grid {
+    --bulma-grid-column-count: 16;
+  }
+}
+
+.grid {
+  --bulma-grid-gap: 0.75rem;
+  --bulma-grid-column-min: 9rem;
+  --bulma-grid-cell-column-span: 1;
+  --bulma-grid-cell-row-span: 1;
+  display: grid;
+  gap: var(--bulma-grid-gap);
+  column-gap: var(--bulma-grid-column-gap, var(--bulma-grid-gap));
+  row-gap: var(--bulma-grid-row-gap, var(--bulma-grid-gap));
+  grid-template-columns: repeat(auto-fit, minmax(var(--bulma-grid-column-min), 1fr));
+  grid-template-rows: auto;
+}
+.grid.is-auto-fill {
+  grid-template-columns: repeat(auto-fill, minmax(var(--bulma-grid-column-min), 1fr));
+}
+.grid.is-col-min-1 {
+  --bulma-grid-column-min: 1.5rem;
+}
+.grid.is-col-min-2 {
+  --bulma-grid-column-min: 3rem;
+}
+.grid.is-col-min-3 {
+  --bulma-grid-column-min: 4.5rem;
+}
+.grid.is-col-min-4 {
+  --bulma-grid-column-min: 6rem;
+}
+.grid.is-col-min-5 {
+  --bulma-grid-column-min: 7.5rem;
+}
+.grid.is-col-min-6 {
+  --bulma-grid-column-min: 9rem;
+}
+.grid.is-col-min-7 {
+  --bulma-grid-column-min: 10.5rem;
+}
+.grid.is-col-min-8 {
+  --bulma-grid-column-min: 12rem;
+}
+.grid.is-col-min-9 {
+  --bulma-grid-column-min: 13.5rem;
+}
+.grid.is-col-min-10 {
+  --bulma-grid-column-min: 15rem;
+}
+.grid.is-col-min-11 {
+  --bulma-grid-column-min: 16.5rem;
+}
+.grid.is-col-min-12 {
+  --bulma-grid-column-min: 18rem;
+}
+.grid.is-col-min-13 {
+  --bulma-grid-column-min: 19.5rem;
+}
+.grid.is-col-min-14 {
+  --bulma-grid-column-min: 21rem;
+}
+.grid.is-col-min-15 {
+  --bulma-grid-column-min: 22.5rem;
+}
+.grid.is-col-min-16 {
+  --bulma-grid-column-min: 24rem;
+}
+.grid.is-col-min-17 {
+  --bulma-grid-column-min: 25.5rem;
+}
+.grid.is-col-min-18 {
+  --bulma-grid-column-min: 27rem;
+}
+.grid.is-col-min-19 {
+  --bulma-grid-column-min: 28.5rem;
+}
+.grid.is-col-min-20 {
+  --bulma-grid-column-min: 30rem;
+}
+.grid.is-col-min-21 {
+  --bulma-grid-column-min: 31.5rem;
+}
+.grid.is-col-min-22 {
+  --bulma-grid-column-min: 33rem;
+}
+.grid.is-col-min-23 {
+  --bulma-grid-column-min: 34.5rem;
+}
+.grid.is-col-min-24 {
+  --bulma-grid-column-min: 36rem;
+}
+.grid.is-col-min-25 {
+  --bulma-grid-column-min: 37.5rem;
+}
+.grid.is-col-min-26 {
+  --bulma-grid-column-min: 39rem;
+}
+.grid.is-col-min-27 {
+  --bulma-grid-column-min: 40.5rem;
+}
+.grid.is-col-min-28 {
+  --bulma-grid-column-min: 42rem;
+}
+.grid.is-col-min-29 {
+  --bulma-grid-column-min: 43.5rem;
+}
+.grid.is-col-min-30 {
+  --bulma-grid-column-min: 45rem;
+}
+.grid.is-col-min-31 {
+  --bulma-grid-column-min: 46.5rem;
+}
+.grid.is-col-min-32 {
+  --bulma-grid-column-min: 48rem;
+}
+
+.cell {
+  grid-column-end: span var(--bulma-grid-cell-column-span);
+  grid-column-start: var(--bulma-grid-cell-column-start);
+  grid-row-end: span var(--bulma-grid-cell-row-span);
+  grid-row-start: var(--bulma-grid-cell-row-start);
+}
+.cell.is-col-start-end {
+  --bulma-grid-cell-column-start: -1;
+}
+.cell.is-row-start-end {
+  --bulma-grid-cell-row-start: -1;
+}
+.cell.is-col-start-1 {
+  --bulma-grid-cell-column-start: 1;
+}
+.cell.is-col-end-1 {
+  --bulma-grid-cell-column-end: 1;
+}
+.cell.is-col-from-end-1 {
+  --bulma-grid-cell-column-start: -1;
+}
+.cell.is-col-span-1 {
+  --bulma-grid-cell-column-span: 1;
+}
+.cell.is-row-start-1 {
+  --bulma-grid-cell-row-start: 1;
+}
+.cell.is-row-end-1 {
+  --bulma-grid-cell-row-end: 1;
+}
+.cell.is-row-from-end-1 {
+  --bulma-grid-cell-row-start: -1;
+}
+.cell.is-row-span-1 {
+  --bulma-grid-cell-row-span: 1;
+}
+.cell.is-col-start-2 {
+  --bulma-grid-cell-column-start: 2;
+}
+.cell.is-col-end-2 {
+  --bulma-grid-cell-column-end: 2;
+}
+.cell.is-col-from-end-2 {
+  --bulma-grid-cell-column-start: -2;
+}
+.cell.is-col-span-2 {
+  --bulma-grid-cell-column-span: 2;
+}
+.cell.is-row-start-2 {
+  --bulma-grid-cell-row-start: 2;
+}
+.cell.is-row-end-2 {
+  --bulma-grid-cell-row-end: 2;
+}
+.cell.is-row-from-end-2 {
+  --bulma-grid-cell-row-start: -2;
+}
+.cell.is-row-span-2 {
+  --bulma-grid-cell-row-span: 2;
+}
+.cell.is-col-start-3 {
+  --bulma-grid-cell-column-start: 3;
+}
+.cell.is-col-end-3 {
+  --bulma-grid-cell-column-end: 3;
+}
+.cell.is-col-from-end-3 {
+  --bulma-grid-cell-column-start: -3;
+}
+.cell.is-col-span-3 {
+  --bulma-grid-cell-column-span: 3;
+}
+.cell.is-row-start-3 {
+  --bulma-grid-cell-row-start: 3;
+}
+.cell.is-row-end-3 {
+  --bulma-grid-cell-row-end: 3;
+}
+.cell.is-row-from-end-3 {
+  --bulma-grid-cell-row-start: -3;
+}
+.cell.is-row-span-3 {
+  --bulma-grid-cell-row-span: 3;
+}
+.cell.is-col-start-4 {
+  --bulma-grid-cell-column-start: 4;
+}
+.cell.is-col-end-4 {
+  --bulma-grid-cell-column-end: 4;
+}
+.cell.is-col-from-end-4 {
+  --bulma-grid-cell-column-start: -4;
+}
+.cell.is-col-span-4 {
+  --bulma-grid-cell-column-span: 4;
+}
+.cell.is-row-start-4 {
+  --bulma-grid-cell-row-start: 4;
+}
+.cell.is-row-end-4 {
+  --bulma-grid-cell-row-end: 4;
+}
+.cell.is-row-from-end-4 {
+  --bulma-grid-cell-row-start: -4;
+}
+.cell.is-row-span-4 {
+  --bulma-grid-cell-row-span: 4;
+}
+.cell.is-col-start-5 {
+  --bulma-grid-cell-column-start: 5;
+}
+.cell.is-col-end-5 {
+  --bulma-grid-cell-column-end: 5;
+}
+.cell.is-col-from-end-5 {
+  --bulma-grid-cell-column-start: -5;
+}
+.cell.is-col-span-5 {
+  --bulma-grid-cell-column-span: 5;
+}
+.cell.is-row-start-5 {
+  --bulma-grid-cell-row-start: 5;
+}
+.cell.is-row-end-5 {
+  --bulma-grid-cell-row-end: 5;
+}
+.cell.is-row-from-end-5 {
+  --bulma-grid-cell-row-start: -5;
+}
+.cell.is-row-span-5 {
+  --bulma-grid-cell-row-span: 5;
+}
+.cell.is-col-start-6 {
+  --bulma-grid-cell-column-start: 6;
+}
+.cell.is-col-end-6 {
+  --bulma-grid-cell-column-end: 6;
+}
+.cell.is-col-from-end-6 {
+  --bulma-grid-cell-column-start: -6;
+}
+.cell.is-col-span-6 {
+  --bulma-grid-cell-column-span: 6;
+}
+.cell.is-row-start-6 {
+  --bulma-grid-cell-row-start: 6;
+}
+.cell.is-row-end-6 {
+  --bulma-grid-cell-row-end: 6;
+}
+.cell.is-row-from-end-6 {
+  --bulma-grid-cell-row-start: -6;
+}
+.cell.is-row-span-6 {
+  --bulma-grid-cell-row-span: 6;
+}
+.cell.is-col-start-7 {
+  --bulma-grid-cell-column-start: 7;
+}
+.cell.is-col-end-7 {
+  --bulma-grid-cell-column-end: 7;
+}
+.cell.is-col-from-end-7 {
+  --bulma-grid-cell-column-start: -7;
+}
+.cell.is-col-span-7 {
+  --bulma-grid-cell-column-span: 7;
+}
+.cell.is-row-start-7 {
+  --bulma-grid-cell-row-start: 7;
+}
+.cell.is-row-end-7 {
+  --bulma-grid-cell-row-end: 7;
+}
+.cell.is-row-from-end-7 {
+  --bulma-grid-cell-row-start: -7;
+}
+.cell.is-row-span-7 {
+  --bulma-grid-cell-row-span: 7;
+}
+.cell.is-col-start-8 {
+  --bulma-grid-cell-column-start: 8;
+}
+.cell.is-col-end-8 {
+  --bulma-grid-cell-column-end: 8;
+}
+.cell.is-col-from-end-8 {
+  --bulma-grid-cell-column-start: -8;
+}
+.cell.is-col-span-8 {
+  --bulma-grid-cell-column-span: 8;
+}
+.cell.is-row-start-8 {
+  --bulma-grid-cell-row-start: 8;
+}
+.cell.is-row-end-8 {
+  --bulma-grid-cell-row-end: 8;
+}
+.cell.is-row-from-end-8 {
+  --bulma-grid-cell-row-start: -8;
+}
+.cell.is-row-span-8 {
+  --bulma-grid-cell-row-span: 8;
+}
+.cell.is-col-start-9 {
+  --bulma-grid-cell-column-start: 9;
+}
+.cell.is-col-end-9 {
+  --bulma-grid-cell-column-end: 9;
+}
+.cell.is-col-from-end-9 {
+  --bulma-grid-cell-column-start: -9;
+}
+.cell.is-col-span-9 {
+  --bulma-grid-cell-column-span: 9;
+}
+.cell.is-row-start-9 {
+  --bulma-grid-cell-row-start: 9;
+}
+.cell.is-row-end-9 {
+  --bulma-grid-cell-row-end: 9;
+}
+.cell.is-row-from-end-9 {
+  --bulma-grid-cell-row-start: -9;
+}
+.cell.is-row-span-9 {
+  --bulma-grid-cell-row-span: 9;
+}
+.cell.is-col-start-10 {
+  --bulma-grid-cell-column-start: 10;
+}
+.cell.is-col-end-10 {
+  --bulma-grid-cell-column-end: 10;
+}
+.cell.is-col-from-end-10 {
+  --bulma-grid-cell-column-start: -10;
+}
+.cell.is-col-span-10 {
+  --bulma-grid-cell-column-span: 10;
+}
+.cell.is-row-start-10 {
+  --bulma-grid-cell-row-start: 10;
+}
+.cell.is-row-end-10 {
+  --bulma-grid-cell-row-end: 10;
+}
+.cell.is-row-from-end-10 {
+  --bulma-grid-cell-row-start: -10;
+}
+.cell.is-row-span-10 {
+  --bulma-grid-cell-row-span: 10;
+}
+.cell.is-col-start-11 {
+  --bulma-grid-cell-column-start: 11;
+}
+.cell.is-col-end-11 {
+  --bulma-grid-cell-column-end: 11;
+}
+.cell.is-col-from-end-11 {
+  --bulma-grid-cell-column-start: -11;
+}
+.cell.is-col-span-11 {
+  --bulma-grid-cell-column-span: 11;
+}
+.cell.is-row-start-11 {
+  --bulma-grid-cell-row-start: 11;
+}
+.cell.is-row-end-11 {
+  --bulma-grid-cell-row-end: 11;
+}
+.cell.is-row-from-end-11 {
+  --bulma-grid-cell-row-start: -11;
+}
+.cell.is-row-span-11 {
+  --bulma-grid-cell-row-span: 11;
+}
+.cell.is-col-start-12 {
+  --bulma-grid-cell-column-start: 12;
+}
+.cell.is-col-end-12 {
+  --bulma-grid-cell-column-end: 12;
+}
+.cell.is-col-from-end-12 {
+  --bulma-grid-cell-column-start: -12;
+}
+.cell.is-col-span-12 {
+  --bulma-grid-cell-column-span: 12;
+}
+.cell.is-row-start-12 {
+  --bulma-grid-cell-row-start: 12;
+}
+.cell.is-row-end-12 {
+  --bulma-grid-cell-row-end: 12;
+}
+.cell.is-row-from-end-12 {
+  --bulma-grid-cell-row-start: -12;
+}
+.cell.is-row-span-12 {
+  --bulma-grid-cell-row-span: 12;
+}
+@media screen and (max-width: 768px) {
+  .cell.is-col-start-1-mobile {
+    --bulma-grid-cell-column-start: 1;
+  }
+  .cell.is-col-end-1-mobile {
+    --bulma-grid-cell-column-end: 1;
+  }
+  .cell.is-col-from-end-1-mobile {
+    --bulma-grid-cell-column-start: -1;
+  }
+  .cell.is-col-span-1-mobile {
+    --bulma-grid-cell-column-span: 1;
+  }
+  .cell.is-row-start-1-mobile {
+    --bulma-grid-cell-row-start: 1;
+  }
+  .cell.is-row-end-1-mobile {
+    --bulma-grid-cell-row-end: 1;
+  }
+  .cell.is-row-from-end-1-mobile {
+    --bulma-grid-cell-row-start: -1;
+  }
+  .cell.is-row-span-1-mobile {
+    --bulma-grid-cell-row-span: 1;
+  }
+  .cell.is-col-start-2-mobile {
+    --bulma-grid-cell-column-start: 2;
+  }
+  .cell.is-col-end-2-mobile {
+    --bulma-grid-cell-column-end: 2;
+  }
+  .cell.is-col-from-end-2-mobile {
+    --bulma-grid-cell-column-start: -2;
+  }
+  .cell.is-col-span-2-mobile {
+    --bulma-grid-cell-column-span: 2;
+  }
+  .cell.is-row-start-2-mobile {
+    --bulma-grid-cell-row-start: 2;
+  }
+  .cell.is-row-end-2-mobile {
+    --bulma-grid-cell-row-end: 2;
+  }
+  .cell.is-row-from-end-2-mobile {
+    --bulma-grid-cell-row-start: -2;
+  }
+  .cell.is-row-span-2-mobile {
+    --bulma-grid-cell-row-span: 2;
+  }
+  .cell.is-col-start-3-mobile {
+    --bulma-grid-cell-column-start: 3;
+  }
+  .cell.is-col-end-3-mobile {
+    --bulma-grid-cell-column-end: 3;
+  }
+  .cell.is-col-from-end-3-mobile {
+    --bulma-grid-cell-column-start: -3;
+  }
+  .cell.is-col-span-3-mobile {
+    --bulma-grid-cell-column-span: 3;
+  }
+  .cell.is-row-start-3-mobile {
+    --bulma-grid-cell-row-start: 3;
+  }
+  .cell.is-row-end-3-mobile {
+    --bulma-grid-cell-row-end: 3;
+  }
+  .cell.is-row-from-end-3-mobile {
+    --bulma-grid-cell-row-start: -3;
+  }
+  .cell.is-row-span-3-mobile {
+    --bulma-grid-cell-row-span: 3;
+  }
+  .cell.is-col-start-4-mobile {
+    --bulma-grid-cell-column-start: 4;
+  }
+  .cell.is-col-end-4-mobile {
+    --bulma-grid-cell-column-end: 4;
+  }
+  .cell.is-col-from-end-4-mobile {
+    --bulma-grid-cell-column-start: -4;
+  }
+  .cell.is-col-span-4-mobile {
+    --bulma-grid-cell-column-span: 4;
+  }
+  .cell.is-row-start-4-mobile {
+    --bulma-grid-cell-row-start: 4;
+  }
+  .cell.is-row-end-4-mobile {
+    --bulma-grid-cell-row-end: 4;
+  }
+  .cell.is-row-from-end-4-mobile {
+    --bulma-grid-cell-row-start: -4;
+  }
+  .cell.is-row-span-4-mobile {
+    --bulma-grid-cell-row-span: 4;
+  }
+  .cell.is-col-start-5-mobile {
+    --bulma-grid-cell-column-start: 5;
+  }
+  .cell.is-col-end-5-mobile {
+    --bulma-grid-cell-column-end: 5;
+  }
+  .cell.is-col-from-end-5-mobile {
+    --bulma-grid-cell-column-start: -5;
+  }
+  .cell.is-col-span-5-mobile {
+    --bulma-grid-cell-column-span: 5;
+  }
+  .cell.is-row-start-5-mobile {
+    --bulma-grid-cell-row-start: 5;
+  }
+  .cell.is-row-end-5-mobile {
+    --bulma-grid-cell-row-end: 5;
+  }
+  .cell.is-row-from-end-5-mobile {
+    --bulma-grid-cell-row-start: -5;
+  }
+  .cell.is-row-span-5-mobile {
+    --bulma-grid-cell-row-span: 5;
+  }
+  .cell.is-col-start-6-mobile {
+    --bulma-grid-cell-column-start: 6;
+  }
+  .cell.is-col-end-6-mobile {
+    --bulma-grid-cell-column-end: 6;
+  }
+  .cell.is-col-from-end-6-mobile {
+    --bulma-grid-cell-column-start: -6;
+  }
+  .cell.is-col-span-6-mobile {
+    --bulma-grid-cell-column-span: 6;
+  }
+  .cell.is-row-start-6-mobile {
+    --bulma-grid-cell-row-start: 6;
+  }
+  .cell.is-row-end-6-mobile {
+    --bulma-grid-cell-row-end: 6;
+  }
+  .cell.is-row-from-end-6-mobile {
+    --bulma-grid-cell-row-start: -6;
+  }
+  .cell.is-row-span-6-mobile {
+    --bulma-grid-cell-row-span: 6;
+  }
+  .cell.is-col-start-7-mobile {
+    --bulma-grid-cell-column-start: 7;
+  }
+  .cell.is-col-end-7-mobile {
+    --bulma-grid-cell-column-end: 7;
+  }
+  .cell.is-col-from-end-7-mobile {
+    --bulma-grid-cell-column-start: -7;
+  }
+  .cell.is-col-span-7-mobile {
+    --bulma-grid-cell-column-span: 7;
+  }
+  .cell.is-row-start-7-mobile {
+    --bulma-grid-cell-row-start: 7;
+  }
+  .cell.is-row-end-7-mobile {
+    --bulma-grid-cell-row-end: 7;
+  }
+  .cell.is-row-from-end-7-mobile {
+    --bulma-grid-cell-row-start: -7;
+  }
+  .cell.is-row-span-7-mobile {
+    --bulma-grid-cell-row-span: 7;
+  }
+  .cell.is-col-start-8-mobile {
+    --bulma-grid-cell-column-start: 8;
+  }
+  .cell.is-col-end-8-mobile {
+    --bulma-grid-cell-column-end: 8;
+  }
+  .cell.is-col-from-end-8-mobile {
+    --bulma-grid-cell-column-start: -8;
+  }
+  .cell.is-col-span-8-mobile {
+    --bulma-grid-cell-column-span: 8;
+  }
+  .cell.is-row-start-8-mobile {
+    --bulma-grid-cell-row-start: 8;
+  }
+  .cell.is-row-end-8-mobile {
+    --bulma-grid-cell-row-end: 8;
+  }
+  .cell.is-row-from-end-8-mobile {
+    --bulma-grid-cell-row-start: -8;
+  }
+  .cell.is-row-span-8-mobile {
+    --bulma-grid-cell-row-span: 8;
+  }
+  .cell.is-col-start-9-mobile {
+    --bulma-grid-cell-column-start: 9;
+  }
+  .cell.is-col-end-9-mobile {
+    --bulma-grid-cell-column-end: 9;
+  }
+  .cell.is-col-from-end-9-mobile {
+    --bulma-grid-cell-column-start: -9;
+  }
+  .cell.is-col-span-9-mobile {
+    --bulma-grid-cell-column-span: 9;
+  }
+  .cell.is-row-start-9-mobile {
+    --bulma-grid-cell-row-start: 9;
+  }
+  .cell.is-row-end-9-mobile {
+    --bulma-grid-cell-row-end: 9;
+  }
+  .cell.is-row-from-end-9-mobile {
+    --bulma-grid-cell-row-start: -9;
+  }
+  .cell.is-row-span-9-mobile {
+    --bulma-grid-cell-row-span: 9;
+  }
+  .cell.is-col-start-10-mobile {
+    --bulma-grid-cell-column-start: 10;
+  }
+  .cell.is-col-end-10-mobile {
+    --bulma-grid-cell-column-end: 10;
+  }
+  .cell.is-col-from-end-10-mobile {
+    --bulma-grid-cell-column-start: -10;
+  }
+  .cell.is-col-span-10-mobile {
+    --bulma-grid-cell-column-span: 10;
+  }
+  .cell.is-row-start-10-mobile {
+    --bulma-grid-cell-row-start: 10;
+  }
+  .cell.is-row-end-10-mobile {
+    --bulma-grid-cell-row-end: 10;
+  }
+  .cell.is-row-from-end-10-mobile {
+    --bulma-grid-cell-row-start: -10;
+  }
+  .cell.is-row-span-10-mobile {
+    --bulma-grid-cell-row-span: 10;
+  }
+  .cell.is-col-start-11-mobile {
+    --bulma-grid-cell-column-start: 11;
+  }
+  .cell.is-col-end-11-mobile {
+    --bulma-grid-cell-column-end: 11;
+  }
+  .cell.is-col-from-end-11-mobile {
+    --bulma-grid-cell-column-start: -11;
+  }
+  .cell.is-col-span-11-mobile {
+    --bulma-grid-cell-column-span: 11;
+  }
+  .cell.is-row-start-11-mobile {
+    --bulma-grid-cell-row-start: 11;
+  }
+  .cell.is-row-end-11-mobile {
+    --bulma-grid-cell-row-end: 11;
+  }
+  .cell.is-row-from-end-11-mobile {
+    --bulma-grid-cell-row-start: -11;
+  }
+  .cell.is-row-span-11-mobile {
+    --bulma-grid-cell-row-span: 11;
+  }
+  .cell.is-col-start-12-mobile {
+    --bulma-grid-cell-column-start: 12;
+  }
+  .cell.is-col-end-12-mobile {
+    --bulma-grid-cell-column-end: 12;
+  }
+  .cell.is-col-from-end-12-mobile {
+    --bulma-grid-cell-column-start: -12;
+  }
+  .cell.is-col-span-12-mobile {
+    --bulma-grid-cell-column-span: 12;
+  }
+  .cell.is-row-start-12-mobile {
+    --bulma-grid-cell-row-start: 12;
+  }
+  .cell.is-row-end-12-mobile {
+    --bulma-grid-cell-row-end: 12;
+  }
+  .cell.is-row-from-end-12-mobile {
+    --bulma-grid-cell-row-start: -12;
+  }
+  .cell.is-row-span-12-mobile {
+    --bulma-grid-cell-row-span: 12;
+  }
+}
+@media screen and (min-width: 769px), print {
+  .cell.is-col-start-1-tablet {
+    --bulma-grid-cell-column-start: 1;
+  }
+  .cell.is-col-end-1-tablet {
+    --bulma-grid-cell-column-end: 1;
+  }
+  .cell.is-col-from-end-1-tablet {
+    --bulma-grid-cell-column-start: -1;
+  }
+  .cell.is-col-span-1-tablet {
+    --bulma-grid-cell-column-span: 1;
+  }
+  .cell.is-row-start-1-tablet {
+    --bulma-grid-cell-row-start: 1;
+  }
+  .cell.is-row-end-1-tablet {
+    --bulma-grid-cell-row-end: 1;
+  }
+  .cell.is-row-from-end-1-tablet {
+    --bulma-grid-cell-row-start: -1;
+  }
+  .cell.is-row-span-1-tablet {
+    --bulma-grid-cell-row-span: 1;
+  }
+  .cell.is-col-start-2-tablet {
+    --bulma-grid-cell-column-start: 2;
+  }
+  .cell.is-col-end-2-tablet {
+    --bulma-grid-cell-column-end: 2;
+  }
+  .cell.is-col-from-end-2-tablet {
+    --bulma-grid-cell-column-start: -2;
+  }
+  .cell.is-col-span-2-tablet {
+    --bulma-grid-cell-column-span: 2;
+  }
+  .cell.is-row-start-2-tablet {
+    --bulma-grid-cell-row-start: 2;
+  }
+  .cell.is-row-end-2-tablet {
+    --bulma-grid-cell-row-end: 2;
+  }
+  .cell.is-row-from-end-2-tablet {
+    --bulma-grid-cell-row-start: -2;
+  }
+  .cell.is-row-span-2-tablet {
+    --bulma-grid-cell-row-span: 2;
+  }
+  .cell.is-col-start-3-tablet {
+    --bulma-grid-cell-column-start: 3;
+  }
+  .cell.is-col-end-3-tablet {
+    --bulma-grid-cell-column-end: 3;
+  }
+  .cell.is-col-from-end-3-tablet {
+    --bulma-grid-cell-column-start: -3;
+  }
+  .cell.is-col-span-3-tablet {
+    --bulma-grid-cell-column-span: 3;
+  }
+  .cell.is-row-start-3-tablet {
+    --bulma-grid-cell-row-start: 3;
+  }
+  .cell.is-row-end-3-tablet {
+    --bulma-grid-cell-row-end: 3;
+  }
+  .cell.is-row-from-end-3-tablet {
+    --bulma-grid-cell-row-start: -3;
+  }
+  .cell.is-row-span-3-tablet {
+    --bulma-grid-cell-row-span: 3;
+  }
+  .cell.is-col-start-4-tablet {
+    --bulma-grid-cell-column-start: 4;
+  }
+  .cell.is-col-end-4-tablet {
+    --bulma-grid-cell-column-end: 4;
+  }
+  .cell.is-col-from-end-4-tablet {
+    --bulma-grid-cell-column-start: -4;
+  }
+  .cell.is-col-span-4-tablet {
+    --bulma-grid-cell-column-span: 4;
+  }
+  .cell.is-row-start-4-tablet {
+    --bulma-grid-cell-row-start: 4;
+  }
+  .cell.is-row-end-4-tablet {
+    --bulma-grid-cell-row-end: 4;
+  }
+  .cell.is-row-from-end-4-tablet {
+    --bulma-grid-cell-row-start: -4;
+  }
+  .cell.is-row-span-4-tablet {
+    --bulma-grid-cell-row-span: 4;
+  }
+  .cell.is-col-start-5-tablet {
+    --bulma-grid-cell-column-start: 5;
+  }
+  .cell.is-col-end-5-tablet {
+    --bulma-grid-cell-column-end: 5;
+  }
+  .cell.is-col-from-end-5-tablet {
+    --bulma-grid-cell-column-start: -5;
+  }
+  .cell.is-col-span-5-tablet {
+    --bulma-grid-cell-column-span: 5;
+  }
+  .cell.is-row-start-5-tablet {
+    --bulma-grid-cell-row-start: 5;
+  }
+  .cell.is-row-end-5-tablet {
+    --bulma-grid-cell-row-end: 5;
+  }
+  .cell.is-row-from-end-5-tablet {
+    --bulma-grid-cell-row-start: -5;
+  }
+  .cell.is-row-span-5-tablet {
+    --bulma-grid-cell-row-span: 5;
+  }
+  .cell.is-col-start-6-tablet {
+    --bulma-grid-cell-column-start: 6;
+  }
+  .cell.is-col-end-6-tablet {
+    --bulma-grid-cell-column-end: 6;
+  }
+  .cell.is-col-from-end-6-tablet {
+    --bulma-grid-cell-column-start: -6;
+  }
+  .cell.is-col-span-6-tablet {
+    --bulma-grid-cell-column-span: 6;
+  }
+  .cell.is-row-start-6-tablet {
+    --bulma-grid-cell-row-start: 6;
+  }
+  .cell.is-row-end-6-tablet {
+    --bulma-grid-cell-row-end: 6;
+  }
+  .cell.is-row-from-end-6-tablet {
+    --bulma-grid-cell-row-start: -6;
+  }
+  .cell.is-row-span-6-tablet {
+    --bulma-grid-cell-row-span: 6;
+  }
+  .cell.is-col-start-7-tablet {
+    --bulma-grid-cell-column-start: 7;
+  }
+  .cell.is-col-end-7-tablet {
+    --bulma-grid-cell-column-end: 7;
+  }
+  .cell.is-col-from-end-7-tablet {
+    --bulma-grid-cell-column-start: -7;
+  }
+  .cell.is-col-span-7-tablet {
+    --bulma-grid-cell-column-span: 7;
+  }
+  .cell.is-row-start-7-tablet {
+    --bulma-grid-cell-row-start: 7;
+  }
+  .cell.is-row-end-7-tablet {
+    --bulma-grid-cell-row-end: 7;
+  }
+  .cell.is-row-from-end-7-tablet {
+    --bulma-grid-cell-row-start: -7;
+  }
+  .cell.is-row-span-7-tablet {
+    --bulma-grid-cell-row-span: 7;
+  }
+  .cell.is-col-start-8-tablet {
+    --bulma-grid-cell-column-start: 8;
+  }
+  .cell.is-col-end-8-tablet {
+    --bulma-grid-cell-column-end: 8;
+  }
+  .cell.is-col-from-end-8-tablet {
+    --bulma-grid-cell-column-start: -8;
+  }
+  .cell.is-col-span-8-tablet {
+    --bulma-grid-cell-column-span: 8;
+  }
+  .cell.is-row-start-8-tablet {
+    --bulma-grid-cell-row-start: 8;
+  }
+  .cell.is-row-end-8-tablet {
+    --bulma-grid-cell-row-end: 8;
+  }
+  .cell.is-row-from-end-8-tablet {
+    --bulma-grid-cell-row-start: -8;
+  }
+  .cell.is-row-span-8-tablet {
+    --bulma-grid-cell-row-span: 8;
+  }
+  .cell.is-col-start-9-tablet {
+    --bulma-grid-cell-column-start: 9;
+  }
+  .cell.is-col-end-9-tablet {
+    --bulma-grid-cell-column-end: 9;
+  }
+  .cell.is-col-from-end-9-tablet {
+    --bulma-grid-cell-column-start: -9;
+  }
+  .cell.is-col-span-9-tablet {
+    --bulma-grid-cell-column-span: 9;
+  }
+  .cell.is-row-start-9-tablet {
+    --bulma-grid-cell-row-start: 9;
+  }
+  .cell.is-row-end-9-tablet {
+    --bulma-grid-cell-row-end: 9;
+  }
+  .cell.is-row-from-end-9-tablet {
+    --bulma-grid-cell-row-start: -9;
+  }
+  .cell.is-row-span-9-tablet {
+    --bulma-grid-cell-row-span: 9;
+  }
+  .cell.is-col-start-10-tablet {
+    --bulma-grid-cell-column-start: 10;
+  }
+  .cell.is-col-end-10-tablet {
+    --bulma-grid-cell-column-end: 10;
+  }
+  .cell.is-col-from-end-10-tablet {
+    --bulma-grid-cell-column-start: -10;
+  }
+  .cell.is-col-span-10-tablet {
+    --bulma-grid-cell-column-span: 10;
+  }
+  .cell.is-row-start-10-tablet {
+    --bulma-grid-cell-row-start: 10;
+  }
+  .cell.is-row-end-10-tablet {
+    --bulma-grid-cell-row-end: 10;
+  }
+  .cell.is-row-from-end-10-tablet {
+    --bulma-grid-cell-row-start: -10;
+  }
+  .cell.is-row-span-10-tablet {
+    --bulma-grid-cell-row-span: 10;
+  }
+  .cell.is-col-start-11-tablet {
+    --bulma-grid-cell-column-start: 11;
+  }
+  .cell.is-col-end-11-tablet {
+    --bulma-grid-cell-column-end: 11;
+  }
+  .cell.is-col-from-end-11-tablet {
+    --bulma-grid-cell-column-start: -11;
+  }
+  .cell.is-col-span-11-tablet {
+    --bulma-grid-cell-column-span: 11;
+  }
+  .cell.is-row-start-11-tablet {
+    --bulma-grid-cell-row-start: 11;
+  }
+  .cell.is-row-end-11-tablet {
+    --bulma-grid-cell-row-end: 11;
+  }
+  .cell.is-row-from-end-11-tablet {
+    --bulma-grid-cell-row-start: -11;
+  }
+  .cell.is-row-span-11-tablet {
+    --bulma-grid-cell-row-span: 11;
+  }
+  .cell.is-col-start-12-tablet {
+    --bulma-grid-cell-column-start: 12;
+  }
+  .cell.is-col-end-12-tablet {
+    --bulma-grid-cell-column-end: 12;
+  }
+  .cell.is-col-from-end-12-tablet {
+    --bulma-grid-cell-column-start: -12;
+  }
+  .cell.is-col-span-12-tablet {
+    --bulma-grid-cell-column-span: 12;
+  }
+  .cell.is-row-start-12-tablet {
+    --bulma-grid-cell-row-start: 12;
+  }
+  .cell.is-row-end-12-tablet {
+    --bulma-grid-cell-row-end: 12;
+  }
+  .cell.is-row-from-end-12-tablet {
+    --bulma-grid-cell-row-start: -12;
+  }
+  .cell.is-row-span-12-tablet {
+    --bulma-grid-cell-row-span: 12;
+  }
+}
+@media screen and (min-width: 769px) and (max-width: 1023px) {
+  .cell.is-col-start-1-tablet-only {
+    --bulma-grid-cell-column-start: 1;
+  }
+  .cell.is-col-end-1-tablet-only {
+    --bulma-grid-cell-column-end: 1;
+  }
+  .cell.is-col-from-end-1-tablet-only {
+    --bulma-grid-cell-column-start: -1;
+  }
+  .cell.is-col-span-1-tablet-only {
+    --bulma-grid-cell-column-span: 1;
+  }
+  .cell.is-row-start-1-tablet-only {
+    --bulma-grid-cell-row-start: 1;
+  }
+  .cell.is-row-end-1-tablet-only {
+    --bulma-grid-cell-row-end: 1;
+  }
+  .cell.is-row-from-end-1-tablet-only {
+    --bulma-grid-cell-row-start: -1;
+  }
+  .cell.is-row-span-1-tablet-only {
+    --bulma-grid-cell-row-span: 1;
+  }
+  .cell.is-col-start-2-tablet-only {
+    --bulma-grid-cell-column-start: 2;
+  }
+  .cell.is-col-end-2-tablet-only {
+    --bulma-grid-cell-column-end: 2;
+  }
+  .cell.is-col-from-end-2-tablet-only {
+    --bulma-grid-cell-column-start: -2;
+  }
+  .cell.is-col-span-2-tablet-only {
+    --bulma-grid-cell-column-span: 2;
+  }
+  .cell.is-row-start-2-tablet-only {
+    --bulma-grid-cell-row-start: 2;
+  }
+  .cell.is-row-end-2-tablet-only {
+    --bulma-grid-cell-row-end: 2;
+  }
+  .cell.is-row-from-end-2-tablet-only {
+    --bulma-grid-cell-row-start: -2;
+  }
+  .cell.is-row-span-2-tablet-only {
+    --bulma-grid-cell-row-span: 2;
+  }
+  .cell.is-col-start-3-tablet-only {
+    --bulma-grid-cell-column-start: 3;
+  }
+  .cell.is-col-end-3-tablet-only {
+    --bulma-grid-cell-column-end: 3;
+  }
+  .cell.is-col-from-end-3-tablet-only {
+    --bulma-grid-cell-column-start: -3;
+  }
+  .cell.is-col-span-3-tablet-only {
+    --bulma-grid-cell-column-span: 3;
+  }
+  .cell.is-row-start-3-tablet-only {
+    --bulma-grid-cell-row-start: 3;
+  }
+  .cell.is-row-end-3-tablet-only {
+    --bulma-grid-cell-row-end: 3;
+  }
+  .cell.is-row-from-end-3-tablet-only {
+    --bulma-grid-cell-row-start: -3;
+  }
+  .cell.is-row-span-3-tablet-only {
+    --bulma-grid-cell-row-span: 3;
+  }
+  .cell.is-col-start-4-tablet-only {
+    --bulma-grid-cell-column-start: 4;
+  }
+  .cell.is-col-end-4-tablet-only {
+    --bulma-grid-cell-column-end: 4;
+  }
+  .cell.is-col-from-end-4-tablet-only {
+    --bulma-grid-cell-column-start: -4;
+  }
+  .cell.is-col-span-4-tablet-only {
+    --bulma-grid-cell-column-span: 4;
+  }
+  .cell.is-row-start-4-tablet-only {
+    --bulma-grid-cell-row-start: 4;
+  }
+  .cell.is-row-end-4-tablet-only {
+    --bulma-grid-cell-row-end: 4;
+  }
+  .cell.is-row-from-end-4-tablet-only {
+    --bulma-grid-cell-row-start: -4;
+  }
+  .cell.is-row-span-4-tablet-only {
+    --bulma-grid-cell-row-span: 4;
+  }
+  .cell.is-col-start-5-tablet-only {
+    --bulma-grid-cell-column-start: 5;
+  }
+  .cell.is-col-end-5-tablet-only {
+    --bulma-grid-cell-column-end: 5;
+  }
+  .cell.is-col-from-end-5-tablet-only {
+    --bulma-grid-cell-column-start: -5;
+  }
+  .cell.is-col-span-5-tablet-only {
+    --bulma-grid-cell-column-span: 5;
+  }
+  .cell.is-row-start-5-tablet-only {
+    --bulma-grid-cell-row-start: 5;
+  }
+  .cell.is-row-end-5-tablet-only {
+    --bulma-grid-cell-row-end: 5;
+  }
+  .cell.is-row-from-end-5-tablet-only {
+    --bulma-grid-cell-row-start: -5;
+  }
+  .cell.is-row-span-5-tablet-only {
+    --bulma-grid-cell-row-span: 5;
+  }
+  .cell.is-col-start-6-tablet-only {
+    --bulma-grid-cell-column-start: 6;
+  }
+  .cell.is-col-end-6-tablet-only {
+    --bulma-grid-cell-column-end: 6;
+  }
+  .cell.is-col-from-end-6-tablet-only {
+    --bulma-grid-cell-column-start: -6;
+  }
+  .cell.is-col-span-6-tablet-only {
+    --bulma-grid-cell-column-span: 6;
+  }
+  .cell.is-row-start-6-tablet-only {
+    --bulma-grid-cell-row-start: 6;
+  }
+  .cell.is-row-end-6-tablet-only {
+    --bulma-grid-cell-row-end: 6;
+  }
+  .cell.is-row-from-end-6-tablet-only {
+    --bulma-grid-cell-row-start: -6;
+  }
+  .cell.is-row-span-6-tablet-only {
+    --bulma-grid-cell-row-span: 6;
+  }
+  .cell.is-col-start-7-tablet-only {
+    --bulma-grid-cell-column-start: 7;
+  }
+  .cell.is-col-end-7-tablet-only {
+    --bulma-grid-cell-column-end: 7;
+  }
+  .cell.is-col-from-end-7-tablet-only {
+    --bulma-grid-cell-column-start: -7;
+  }
+  .cell.is-col-span-7-tablet-only {
+    --bulma-grid-cell-column-span: 7;
+  }
+  .cell.is-row-start-7-tablet-only {
+    --bulma-grid-cell-row-start: 7;
+  }
+  .cell.is-row-end-7-tablet-only {
+    --bulma-grid-cell-row-end: 7;
+  }
+  .cell.is-row-from-end-7-tablet-only {
+    --bulma-grid-cell-row-start: -7;
+  }
+  .cell.is-row-span-7-tablet-only {
+    --bulma-grid-cell-row-span: 7;
+  }
+  .cell.is-col-start-8-tablet-only {
+    --bulma-grid-cell-column-start: 8;
+  }
+  .cell.is-col-end-8-tablet-only {
+    --bulma-grid-cell-column-end: 8;
+  }
+  .cell.is-col-from-end-8-tablet-only {
+    --bulma-grid-cell-column-start: -8;
+  }
+  .cell.is-col-span-8-tablet-only {
+    --bulma-grid-cell-column-span: 8;
+  }
+  .cell.is-row-start-8-tablet-only {
+    --bulma-grid-cell-row-start: 8;
+  }
+  .cell.is-row-end-8-tablet-only {
+    --bulma-grid-cell-row-end: 8;
+  }
+  .cell.is-row-from-end-8-tablet-only {
+    --bulma-grid-cell-row-start: -8;
+  }
+  .cell.is-row-span-8-tablet-only {
+    --bulma-grid-cell-row-span: 8;
+  }
+  .cell.is-col-start-9-tablet-only {
+    --bulma-grid-cell-column-start: 9;
+  }
+  .cell.is-col-end-9-tablet-only {
+    --bulma-grid-cell-column-end: 9;
+  }
+  .cell.is-col-from-end-9-tablet-only {
+    --bulma-grid-cell-column-start: -9;
+  }
+  .cell.is-col-span-9-tablet-only {
+    --bulma-grid-cell-column-span: 9;
+  }
+  .cell.is-row-start-9-tablet-only {
+    --bulma-grid-cell-row-start: 9;
+  }
+  .cell.is-row-end-9-tablet-only {
+    --bulma-grid-cell-row-end: 9;
+  }
+  .cell.is-row-from-end-9-tablet-only {
+    --bulma-grid-cell-row-start: -9;
+  }
+  .cell.is-row-span-9-tablet-only {
+    --bulma-grid-cell-row-span: 9;
+  }
+  .cell.is-col-start-10-tablet-only {
+    --bulma-grid-cell-column-start: 10;
+  }
+  .cell.is-col-end-10-tablet-only {
+    --bulma-grid-cell-column-end: 10;
+  }
+  .cell.is-col-from-end-10-tablet-only {
+    --bulma-grid-cell-column-start: -10;
+  }
+  .cell.is-col-span-10-tablet-only {
+    --bulma-grid-cell-column-span: 10;
+  }
+  .cell.is-row-start-10-tablet-only {
+    --bulma-grid-cell-row-start: 10;
+  }
+  .cell.is-row-end-10-tablet-only {
+    --bulma-grid-cell-row-end: 10;
+  }
+  .cell.is-row-from-end-10-tablet-only {
+    --bulma-grid-cell-row-start: -10;
+  }
+  .cell.is-row-span-10-tablet-only {
+    --bulma-grid-cell-row-span: 10;
+  }
+  .cell.is-col-start-11-tablet-only {
+    --bulma-grid-cell-column-start: 11;
+  }
+  .cell.is-col-end-11-tablet-only {
+    --bulma-grid-cell-column-end: 11;
+  }
+  .cell.is-col-from-end-11-tablet-only {
+    --bulma-grid-cell-column-start: -11;
+  }
+  .cell.is-col-span-11-tablet-only {
+    --bulma-grid-cell-column-span: 11;
+  }
+  .cell.is-row-start-11-tablet-only {
+    --bulma-grid-cell-row-start: 11;
+  }
+  .cell.is-row-end-11-tablet-only {
+    --bulma-grid-cell-row-end: 11;
+  }
+  .cell.is-row-from-end-11-tablet-only {
+    --bulma-grid-cell-row-start: -11;
+  }
+  .cell.is-row-span-11-tablet-only {
+    --bulma-grid-cell-row-span: 11;
+  }
+  .cell.is-col-start-12-tablet-only {
+    --bulma-grid-cell-column-start: 12;
+  }
+  .cell.is-col-end-12-tablet-only {
+    --bulma-grid-cell-column-end: 12;
+  }
+  .cell.is-col-from-end-12-tablet-only {
+    --bulma-grid-cell-column-start: -12;
+  }
+  .cell.is-col-span-12-tablet-only {
+    --bulma-grid-cell-column-span: 12;
+  }
+  .cell.is-row-start-12-tablet-only {
+    --bulma-grid-cell-row-start: 12;
+  }
+  .cell.is-row-end-12-tablet-only {
+    --bulma-grid-cell-row-end: 12;
+  }
+  .cell.is-row-from-end-12-tablet-only {
+    --bulma-grid-cell-row-start: -12;
+  }
+  .cell.is-row-span-12-tablet-only {
+    --bulma-grid-cell-row-span: 12;
+  }
+}
+@media screen and (min-width: 1024px) {
+  .cell.is-col-start-1-desktop {
+    --bulma-grid-cell-column-start: 1;
+  }
+  .cell.is-col-end-1-desktop {
+    --bulma-grid-cell-column-end: 1;
+  }
+  .cell.is-col-from-end-1-desktop {
+    --bulma-grid-cell-column-start: -1;
+  }
+  .cell.is-col-span-1-desktop {
+    --bulma-grid-cell-column-span: 1;
+  }
+  .cell.is-row-start-1-desktop {
+    --bulma-grid-cell-row-start: 1;
+  }
+  .cell.is-row-end-1-desktop {
+    --bulma-grid-cell-row-end: 1;
+  }
+  .cell.is-row-from-end-1-desktop {
+    --bulma-grid-cell-row-start: -1;
+  }
+  .cell.is-row-span-1-desktop {
+    --bulma-grid-cell-row-span: 1;
+  }
+  .cell.is-col-start-2-desktop {
+    --bulma-grid-cell-column-start: 2;
+  }
+  .cell.is-col-end-2-desktop {
+    --bulma-grid-cell-column-end: 2;
+  }
+  .cell.is-col-from-end-2-desktop {
+    --bulma-grid-cell-column-start: -2;
+  }
+  .cell.is-col-span-2-desktop {
+    --bulma-grid-cell-column-span: 2;
+  }
+  .cell.is-row-start-2-desktop {
+    --bulma-grid-cell-row-start: 2;
+  }
+  .cell.is-row-end-2-desktop {
+    --bulma-grid-cell-row-end: 2;
+  }
+  .cell.is-row-from-end-2-desktop {
+    --bulma-grid-cell-row-start: -2;
+  }
+  .cell.is-row-span-2-desktop {
+    --bulma-grid-cell-row-span: 2;
+  }
+  .cell.is-col-start-3-desktop {
+    --bulma-grid-cell-column-start: 3;
+  }
+  .cell.is-col-end-3-desktop {
+    --bulma-grid-cell-column-end: 3;
+  }
+  .cell.is-col-from-end-3-desktop {
+    --bulma-grid-cell-column-start: -3;
+  }
+  .cell.is-col-span-3-desktop {
+    --bulma-grid-cell-column-span: 3;
+  }
+  .cell.is-row-start-3-desktop {
+    --bulma-grid-cell-row-start: 3;
+  }
+  .cell.is-row-end-3-desktop {
+    --bulma-grid-cell-row-end: 3;
+  }
+  .cell.is-row-from-end-3-desktop {
+    --bulma-grid-cell-row-start: -3;
+  }
+  .cell.is-row-span-3-desktop {
+    --bulma-grid-cell-row-span: 3;
+  }
+  .cell.is-col-start-4-desktop {
+    --bulma-grid-cell-column-start: 4;
+  }
+  .cell.is-col-end-4-desktop {
+    --bulma-grid-cell-column-end: 4;
+  }
+  .cell.is-col-from-end-4-desktop {
+    --bulma-grid-cell-column-start: -4;
+  }
+  .cell.is-col-span-4-desktop {
+    --bulma-grid-cell-column-span: 4;
+  }
+  .cell.is-row-start-4-desktop {
+    --bulma-grid-cell-row-start: 4;
+  }
+  .cell.is-row-end-4-desktop {
+    --bulma-grid-cell-row-end: 4;
+  }
+  .cell.is-row-from-end-4-desktop {
+    --bulma-grid-cell-row-start: -4;
+  }
+  .cell.is-row-span-4-desktop {
+    --bulma-grid-cell-row-span: 4;
+  }
+  .cell.is-col-start-5-desktop {
+    --bulma-grid-cell-column-start: 5;
+  }
+  .cell.is-col-end-5-desktop {
+    --bulma-grid-cell-column-end: 5;
+  }
+  .cell.is-col-from-end-5-desktop {
+    --bulma-grid-cell-column-start: -5;
+  }
+  .cell.is-col-span-5-desktop {
+    --bulma-grid-cell-column-span: 5;
+  }
+  .cell.is-row-start-5-desktop {
+    --bulma-grid-cell-row-start: 5;
+  }
+  .cell.is-row-end-5-desktop {
+    --bulma-grid-cell-row-end: 5;
+  }
+  .cell.is-row-from-end-5-desktop {
+    --bulma-grid-cell-row-start: -5;
+  }
+  .cell.is-row-span-5-desktop {
+    --bulma-grid-cell-row-span: 5;
+  }
+  .cell.is-col-start-6-desktop {
+    --bulma-grid-cell-column-start: 6;
+  }
+  .cell.is-col-end-6-desktop {
+    --bulma-grid-cell-column-end: 6;
+  }
+  .cell.is-col-from-end-6-desktop {
+    --bulma-grid-cell-column-start: -6;
+  }
+  .cell.is-col-span-6-desktop {
+    --bulma-grid-cell-column-span: 6;
+  }
+  .cell.is-row-start-6-desktop {
+    --bulma-grid-cell-row-start: 6;
+  }
+  .cell.is-row-end-6-desktop {
+    --bulma-grid-cell-row-end: 6;
+  }
+  .cell.is-row-from-end-6-desktop {
+    --bulma-grid-cell-row-start: -6;
+  }
+  .cell.is-row-span-6-desktop {
+    --bulma-grid-cell-row-span: 6;
+  }
+  .cell.is-col-start-7-desktop {
+    --bulma-grid-cell-column-start: 7;
+  }
+  .cell.is-col-end-7-desktop {
+    --bulma-grid-cell-column-end: 7;
+  }
+  .cell.is-col-from-end-7-desktop {
+    --bulma-grid-cell-column-start: -7;
+  }
+  .cell.is-col-span-7-desktop {
+    --bulma-grid-cell-column-span: 7;
+  }
+  .cell.is-row-start-7-desktop {
+    --bulma-grid-cell-row-start: 7;
+  }
+  .cell.is-row-end-7-desktop {
+    --bulma-grid-cell-row-end: 7;
+  }
+  .cell.is-row-from-end-7-desktop {
+    --bulma-grid-cell-row-start: -7;
+  }
+  .cell.is-row-span-7-desktop {
+    --bulma-grid-cell-row-span: 7;
+  }
+  .cell.is-col-start-8-desktop {
+    --bulma-grid-cell-column-start: 8;
+  }
+  .cell.is-col-end-8-desktop {
+    --bulma-grid-cell-column-end: 8;
+  }
+  .cell.is-col-from-end-8-desktop {
+    --bulma-grid-cell-column-start: -8;
+  }
+  .cell.is-col-span-8-desktop {
+    --bulma-grid-cell-column-span: 8;
+  }
+  .cell.is-row-start-8-desktop {
+    --bulma-grid-cell-row-start: 8;
+  }
+  .cell.is-row-end-8-desktop {
+    --bulma-grid-cell-row-end: 8;
+  }
+  .cell.is-row-from-end-8-desktop {
+    --bulma-grid-cell-row-start: -8;
+  }
+  .cell.is-row-span-8-desktop {
+    --bulma-grid-cell-row-span: 8;
+  }
+  .cell.is-col-start-9-desktop {
+    --bulma-grid-cell-column-start: 9;
+  }
+  .cell.is-col-end-9-desktop {
+    --bulma-grid-cell-column-end: 9;
+  }
+  .cell.is-col-from-end-9-desktop {
+    --bulma-grid-cell-column-start: -9;
+  }
+  .cell.is-col-span-9-desktop {
+    --bulma-grid-cell-column-span: 9;
+  }
+  .cell.is-row-start-9-desktop {
+    --bulma-grid-cell-row-start: 9;
+  }
+  .cell.is-row-end-9-desktop {
+    --bulma-grid-cell-row-end: 9;
+  }
+  .cell.is-row-from-end-9-desktop {
+    --bulma-grid-cell-row-start: -9;
+  }
+  .cell.is-row-span-9-desktop {
+    --bulma-grid-cell-row-span: 9;
+  }
+  .cell.is-col-start-10-desktop {
+    --bulma-grid-cell-column-start: 10;
+  }
+  .cell.is-col-end-10-desktop {
+    --bulma-grid-cell-column-end: 10;
+  }
+  .cell.is-col-from-end-10-desktop {
+    --bulma-grid-cell-column-start: -10;
+  }
+  .cell.is-col-span-10-desktop {
+    --bulma-grid-cell-column-span: 10;
+  }
+  .cell.is-row-start-10-desktop {
+    --bulma-grid-cell-row-start: 10;
+  }
+  .cell.is-row-end-10-desktop {
+    --bulma-grid-cell-row-end: 10;
+  }
+  .cell.is-row-from-end-10-desktop {
+    --bulma-grid-cell-row-start: -10;
+  }
+  .cell.is-row-span-10-desktop {
+    --bulma-grid-cell-row-span: 10;
+  }
+  .cell.is-col-start-11-desktop {
+    --bulma-grid-cell-column-start: 11;
+  }
+  .cell.is-col-end-11-desktop {
+    --bulma-grid-cell-column-end: 11;
+  }
+  .cell.is-col-from-end-11-desktop {
+    --bulma-grid-cell-column-start: -11;
+  }
+  .cell.is-col-span-11-desktop {
+    --bulma-grid-cell-column-span: 11;
+  }
+  .cell.is-row-start-11-desktop {
+    --bulma-grid-cell-row-start: 11;
+  }
+  .cell.is-row-end-11-desktop {
+    --bulma-grid-cell-row-end: 11;
+  }
+  .cell.is-row-from-end-11-desktop {
+    --bulma-grid-cell-row-start: -11;
+  }
+  .cell.is-row-span-11-desktop {
+    --bulma-grid-cell-row-span: 11;
+  }
+  .cell.is-col-start-12-desktop {
+    --bulma-grid-cell-column-start: 12;
+  }
+  .cell.is-col-end-12-desktop {
+    --bulma-grid-cell-column-end: 12;
+  }
+  .cell.is-col-from-end-12-desktop {
+    --bulma-grid-cell-column-start: -12;
+  }
+  .cell.is-col-span-12-desktop {
+    --bulma-grid-cell-column-span: 12;
+  }
+  .cell.is-row-start-12-desktop {
+    --bulma-grid-cell-row-start: 12;
+  }
+  .cell.is-row-end-12-desktop {
+    --bulma-grid-cell-row-end: 12;
+  }
+  .cell.is-row-from-end-12-desktop {
+    --bulma-grid-cell-row-start: -12;
+  }
+  .cell.is-row-span-12-desktop {
+    --bulma-grid-cell-row-span: 12;
+  }
+}
+@media screen and (min-width: 1024px) and (max-width: 1215px) {
+  .cell.is-col-start-1-desktop-only {
+    --bulma-grid-cell-column-start: 1;
+  }
+  .cell.is-col-end-1-desktop-only {
+    --bulma-grid-cell-column-end: 1;
+  }
+  .cell.is-col-from-end-1-desktop-only {
+    --bulma-grid-cell-column-start: -1;
+  }
+  .cell.is-col-span-1-desktop-only {
+    --bulma-grid-cell-column-span: 1;
+  }
+  .cell.is-row-start-1-desktop-only {
+    --bulma-grid-cell-row-start: 1;
+  }
+  .cell.is-row-end-1-desktop-only {
+    --bulma-grid-cell-row-end: 1;
+  }
+  .cell.is-row-from-end-1-desktop-only {
+    --bulma-grid-cell-row-start: -1;
+  }
+  .cell.is-row-span-1-desktop-only {
+    --bulma-grid-cell-row-span: 1;
+  }
+  .cell.is-col-start-2-desktop-only {
+    --bulma-grid-cell-column-start: 2;
+  }
+  .cell.is-col-end-2-desktop-only {
+    --bulma-grid-cell-column-end: 2;
+  }
+  .cell.is-col-from-end-2-desktop-only {
+    --bulma-grid-cell-column-start: -2;
+  }
+  .cell.is-col-span-2-desktop-only {
+    --bulma-grid-cell-column-span: 2;
+  }
+  .cell.is-row-start-2-desktop-only {
+    --bulma-grid-cell-row-start: 2;
+  }
+  .cell.is-row-end-2-desktop-only {
+    --bulma-grid-cell-row-end: 2;
+  }
+  .cell.is-row-from-end-2-desktop-only {
+    --bulma-grid-cell-row-start: -2;
+  }
+  .cell.is-row-span-2-desktop-only {
+    --bulma-grid-cell-row-span: 2;
+  }
+  .cell.is-col-start-3-desktop-only {
+    --bulma-grid-cell-column-start: 3;
+  }
+  .cell.is-col-end-3-desktop-only {
+    --bulma-grid-cell-column-end: 3;
+  }
+  .cell.is-col-from-end-3-desktop-only {
+    --bulma-grid-cell-column-start: -3;
+  }
+  .cell.is-col-span-3-desktop-only {
+    --bulma-grid-cell-column-span: 3;
+  }
+  .cell.is-row-start-3-desktop-only {
+    --bulma-grid-cell-row-start: 3;
+  }
+  .cell.is-row-end-3-desktop-only {
+    --bulma-grid-cell-row-end: 3;
+  }
+  .cell.is-row-from-end-3-desktop-only {
+    --bulma-grid-cell-row-start: -3;
+  }
+  .cell.is-row-span-3-desktop-only {
+    --bulma-grid-cell-row-span: 3;
+  }
+  .cell.is-col-start-4-desktop-only {
+    --bulma-grid-cell-column-start: 4;
+  }
+  .cell.is-col-end-4-desktop-only {
+    --bulma-grid-cell-column-end: 4;
+  }
+  .cell.is-col-from-end-4-desktop-only {
+    --bulma-grid-cell-column-start: -4;
+  }
+  .cell.is-col-span-4-desktop-only {
+    --bulma-grid-cell-column-span: 4;
+  }
+  .cell.is-row-start-4-desktop-only {
+    --bulma-grid-cell-row-start: 4;
+  }
+  .cell.is-row-end-4-desktop-only {
+    --bulma-grid-cell-row-end: 4;
+  }
+  .cell.is-row-from-end-4-desktop-only {
+    --bulma-grid-cell-row-start: -4;
+  }
+  .cell.is-row-span-4-desktop-only {
+    --bulma-grid-cell-row-span: 4;
+  }
+  .cell.is-col-start-5-desktop-only {
+    --bulma-grid-cell-column-start: 5;
+  }
+  .cell.is-col-end-5-desktop-only {
+    --bulma-grid-cell-column-end: 5;
+  }
+  .cell.is-col-from-end-5-desktop-only {
+    --bulma-grid-cell-column-start: -5;
+  }
+  .cell.is-col-span-5-desktop-only {
+    --bulma-grid-cell-column-span: 5;
+  }
+  .cell.is-row-start-5-desktop-only {
+    --bulma-grid-cell-row-start: 5;
+  }
+  .cell.is-row-end-5-desktop-only {
+    --bulma-grid-cell-row-end: 5;
+  }
+  .cell.is-row-from-end-5-desktop-only {
+    --bulma-grid-cell-row-start: -5;
+  }
+  .cell.is-row-span-5-desktop-only {
+    --bulma-grid-cell-row-span: 5;
+  }
+  .cell.is-col-start-6-desktop-only {
+    --bulma-grid-cell-column-start: 6;
+  }
+  .cell.is-col-end-6-desktop-only {
+    --bulma-grid-cell-column-end: 6;
+  }
+  .cell.is-col-from-end-6-desktop-only {
+    --bulma-grid-cell-column-start: -6;
+  }
+  .cell.is-col-span-6-desktop-only {
+    --bulma-grid-cell-column-span: 6;
+  }
+  .cell.is-row-start-6-desktop-only {
+    --bulma-grid-cell-row-start: 6;
+  }
+  .cell.is-row-end-6-desktop-only {
+    --bulma-grid-cell-row-end: 6;
+  }
+  .cell.is-row-from-end-6-desktop-only {
+    --bulma-grid-cell-row-start: -6;
+  }
+  .cell.is-row-span-6-desktop-only {
+    --bulma-grid-cell-row-span: 6;
+  }
+  .cell.is-col-start-7-desktop-only {
+    --bulma-grid-cell-column-start: 7;
+  }
+  .cell.is-col-end-7-desktop-only {
+    --bulma-grid-cell-column-end: 7;
+  }
+  .cell.is-col-from-end-7-desktop-only {
+    --bulma-grid-cell-column-start: -7;
+  }
+  .cell.is-col-span-7-desktop-only {
+    --bulma-grid-cell-column-span: 7;
+  }
+  .cell.is-row-start-7-desktop-only {
+    --bulma-grid-cell-row-start: 7;
+  }
+  .cell.is-row-end-7-desktop-only {
+    --bulma-grid-cell-row-end: 7;
+  }
+  .cell.is-row-from-end-7-desktop-only {
+    --bulma-grid-cell-row-start: -7;
+  }
+  .cell.is-row-span-7-desktop-only {
+    --bulma-grid-cell-row-span: 7;
+  }
+  .cell.is-col-start-8-desktop-only {
+    --bulma-grid-cell-column-start: 8;
+  }
+  .cell.is-col-end-8-desktop-only {
+    --bulma-grid-cell-column-end: 8;
+  }
+  .cell.is-col-from-end-8-desktop-only {
+    --bulma-grid-cell-column-start: -8;
+  }
+  .cell.is-col-span-8-desktop-only {
+    --bulma-grid-cell-column-span: 8;
+  }
+  .cell.is-row-start-8-desktop-only {
+    --bulma-grid-cell-row-start: 8;
+  }
+  .cell.is-row-end-8-desktop-only {
+    --bulma-grid-cell-row-end: 8;
+  }
+  .cell.is-row-from-end-8-desktop-only {
+    --bulma-grid-cell-row-start: -8;
+  }
+  .cell.is-row-span-8-desktop-only {
+    --bulma-grid-cell-row-span: 8;
+  }
+  .cell.is-col-start-9-desktop-only {
+    --bulma-grid-cell-column-start: 9;
+  }
+  .cell.is-col-end-9-desktop-only {
+    --bulma-grid-cell-column-end: 9;
+  }
+  .cell.is-col-from-end-9-desktop-only {
+    --bulma-grid-cell-column-start: -9;
+  }
+  .cell.is-col-span-9-desktop-only {
+    --bulma-grid-cell-column-span: 9;
+  }
+  .cell.is-row-start-9-desktop-only {
+    --bulma-grid-cell-row-start: 9;
+  }
+  .cell.is-row-end-9-desktop-only {
+    --bulma-grid-cell-row-end: 9;
+  }
+  .cell.is-row-from-end-9-desktop-only {
+    --bulma-grid-cell-row-start: -9;
+  }
+  .cell.is-row-span-9-desktop-only {
+    --bulma-grid-cell-row-span: 9;
+  }
+  .cell.is-col-start-10-desktop-only {
+    --bulma-grid-cell-column-start: 10;
+  }
+  .cell.is-col-end-10-desktop-only {
+    --bulma-grid-cell-column-end: 10;
+  }
+  .cell.is-col-from-end-10-desktop-only {
+    --bulma-grid-cell-column-start: -10;
+  }
+  .cell.is-col-span-10-desktop-only {
+    --bulma-grid-cell-column-span: 10;
+  }
+  .cell.is-row-start-10-desktop-only {
+    --bulma-grid-cell-row-start: 10;
+  }
+  .cell.is-row-end-10-desktop-only {
+    --bulma-grid-cell-row-end: 10;
+  }
+  .cell.is-row-from-end-10-desktop-only {
+    --bulma-grid-cell-row-start: -10;
+  }
+  .cell.is-row-span-10-desktop-only {
+    --bulma-grid-cell-row-span: 10;
+  }
+  .cell.is-col-start-11-desktop-only {
+    --bulma-grid-cell-column-start: 11;
+  }
+  .cell.is-col-end-11-desktop-only {
+    --bulma-grid-cell-column-end: 11;
+  }
+  .cell.is-col-from-end-11-desktop-only {
+    --bulma-grid-cell-column-start: -11;
+  }
+  .cell.is-col-span-11-desktop-only {
+    --bulma-grid-cell-column-span: 11;
+  }
+  .cell.is-row-start-11-desktop-only {
+    --bulma-grid-cell-row-start: 11;
+  }
+  .cell.is-row-end-11-desktop-only {
+    --bulma-grid-cell-row-end: 11;
+  }
+  .cell.is-row-from-end-11-desktop-only {
+    --bulma-grid-cell-row-start: -11;
+  }
+  .cell.is-row-span-11-desktop-only {
+    --bulma-grid-cell-row-span: 11;
+  }
+  .cell.is-col-start-12-desktop-only {
+    --bulma-grid-cell-column-start: 12;
+  }
+  .cell.is-col-end-12-desktop-only {
+    --bulma-grid-cell-column-end: 12;
+  }
+  .cell.is-col-from-end-12-desktop-only {
+    --bulma-grid-cell-column-start: -12;
+  }
+  .cell.is-col-span-12-desktop-only {
+    --bulma-grid-cell-column-span: 12;
+  }
+  .cell.is-row-start-12-desktop-only {
+    --bulma-grid-cell-row-start: 12;
+  }
+  .cell.is-row-end-12-desktop-only {
+    --bulma-grid-cell-row-end: 12;
+  }
+  .cell.is-row-from-end-12-desktop-only {
+    --bulma-grid-cell-row-start: -12;
+  }
+  .cell.is-row-span-12-desktop-only {
+    --bulma-grid-cell-row-span: 12;
+  }
+}
+@media screen and (min-width: 1216px) {
+  .cell.is-col-start-1-widescreen {
+    --bulma-grid-cell-column-start: 1;
+  }
+  .cell.is-col-end-1-widescreen {
+    --bulma-grid-cell-column-end: 1;
+  }
+  .cell.is-col-from-end-1-widescreen {
+    --bulma-grid-cell-column-start: -1;
+  }
+  .cell.is-col-span-1-widescreen {
+    --bulma-grid-cell-column-span: 1;
+  }
+  .cell.is-row-start-1-widescreen {
+    --bulma-grid-cell-row-start: 1;
+  }
+  .cell.is-row-end-1-widescreen {
+    --bulma-grid-cell-row-end: 1;
+  }
+  .cell.is-row-from-end-1-widescreen {
+    --bulma-grid-cell-row-start: -1;
+  }
+  .cell.is-row-span-1-widescreen {
+    --bulma-grid-cell-row-span: 1;
+  }
+  .cell.is-col-start-2-widescreen {
+    --bulma-grid-cell-column-start: 2;
+  }
+  .cell.is-col-end-2-widescreen {
+    --bulma-grid-cell-column-end: 2;
+  }
+  .cell.is-col-from-end-2-widescreen {
+    --bulma-grid-cell-column-start: -2;
+  }
+  .cell.is-col-span-2-widescreen {
+    --bulma-grid-cell-column-span: 2;
+  }
+  .cell.is-row-start-2-widescreen {
+    --bulma-grid-cell-row-start: 2;
+  }
+  .cell.is-row-end-2-widescreen {
+    --bulma-grid-cell-row-end: 2;
+  }
+  .cell.is-row-from-end-2-widescreen {
+    --bulma-grid-cell-row-start: -2;
+  }
+  .cell.is-row-span-2-widescreen {
+    --bulma-grid-cell-row-span: 2;
+  }
+  .cell.is-col-start-3-widescreen {
+    --bulma-grid-cell-column-start: 3;
+  }
+  .cell.is-col-end-3-widescreen {
+    --bulma-grid-cell-column-end: 3;
+  }
+  .cell.is-col-from-end-3-widescreen {
+    --bulma-grid-cell-column-start: -3;
+  }
+  .cell.is-col-span-3-widescreen {
+    --bulma-grid-cell-column-span: 3;
+  }
+  .cell.is-row-start-3-widescreen {
+    --bulma-grid-cell-row-start: 3;
+  }
+  .cell.is-row-end-3-widescreen {
+    --bulma-grid-cell-row-end: 3;
+  }
+  .cell.is-row-from-end-3-widescreen {
+    --bulma-grid-cell-row-start: -3;
+  }
+  .cell.is-row-span-3-widescreen {
+    --bulma-grid-cell-row-span: 3;
+  }
+  .cell.is-col-start-4-widescreen {
+    --bulma-grid-cell-column-start: 4;
+  }
+  .cell.is-col-end-4-widescreen {
+    --bulma-grid-cell-column-end: 4;
+  }
+  .cell.is-col-from-end-4-widescreen {
+    --bulma-grid-cell-column-start: -4;
+  }
+  .cell.is-col-span-4-widescreen {
+    --bulma-grid-cell-column-span: 4;
+  }
+  .cell.is-row-start-4-widescreen {
+    --bulma-grid-cell-row-start: 4;
+  }
+  .cell.is-row-end-4-widescreen {
+    --bulma-grid-cell-row-end: 4;
+  }
+  .cell.is-row-from-end-4-widescreen {
+    --bulma-grid-cell-row-start: -4;
+  }
+  .cell.is-row-span-4-widescreen {
+    --bulma-grid-cell-row-span: 4;
+  }
+  .cell.is-col-start-5-widescreen {
+    --bulma-grid-cell-column-start: 5;
+  }
+  .cell.is-col-end-5-widescreen {
+    --bulma-grid-cell-column-end: 5;
+  }
+  .cell.is-col-from-end-5-widescreen {
+    --bulma-grid-cell-column-start: -5;
+  }
+  .cell.is-col-span-5-widescreen {
+    --bulma-grid-cell-column-span: 5;
+  }
+  .cell.is-row-start-5-widescreen {
+    --bulma-grid-cell-row-start: 5;
+  }
+  .cell.is-row-end-5-widescreen {
+    --bulma-grid-cell-row-end: 5;
+  }
+  .cell.is-row-from-end-5-widescreen {
+    --bulma-grid-cell-row-start: -5;
+  }
+  .cell.is-row-span-5-widescreen {
+    --bulma-grid-cell-row-span: 5;
+  }
+  .cell.is-col-start-6-widescreen {
+    --bulma-grid-cell-column-start: 6;
+  }
+  .cell.is-col-end-6-widescreen {
+    --bulma-grid-cell-column-end: 6;
+  }
+  .cell.is-col-from-end-6-widescreen {
+    --bulma-grid-cell-column-start: -6;
+  }
+  .cell.is-col-span-6-widescreen {
+    --bulma-grid-cell-column-span: 6;
+  }
+  .cell.is-row-start-6-widescreen {
+    --bulma-grid-cell-row-start: 6;
+  }
+  .cell.is-row-end-6-widescreen {
+    --bulma-grid-cell-row-end: 6;
+  }
+  .cell.is-row-from-end-6-widescreen {
+    --bulma-grid-cell-row-start: -6;
+  }
+  .cell.is-row-span-6-widescreen {
+    --bulma-grid-cell-row-span: 6;
+  }
+  .cell.is-col-start-7-widescreen {
+    --bulma-grid-cell-column-start: 7;
+  }
+  .cell.is-col-end-7-widescreen {
+    --bulma-grid-cell-column-end: 7;
+  }
+  .cell.is-col-from-end-7-widescreen {
+    --bulma-grid-cell-column-start: -7;
+  }
+  .cell.is-col-span-7-widescreen {
+    --bulma-grid-cell-column-span: 7;
+  }
+  .cell.is-row-start-7-widescreen {
+    --bulma-grid-cell-row-start: 7;
+  }
+  .cell.is-row-end-7-widescreen {
+    --bulma-grid-cell-row-end: 7;
+  }
+  .cell.is-row-from-end-7-widescreen {
+    --bulma-grid-cell-row-start: -7;
+  }
+  .cell.is-row-span-7-widescreen {
+    --bulma-grid-cell-row-span: 7;
+  }
+  .cell.is-col-start-8-widescreen {
+    --bulma-grid-cell-column-start: 8;
+  }
+  .cell.is-col-end-8-widescreen {
+    --bulma-grid-cell-column-end: 8;
+  }
+  .cell.is-col-from-end-8-widescreen {
+    --bulma-grid-cell-column-start: -8;
+  }
+  .cell.is-col-span-8-widescreen {
+    --bulma-grid-cell-column-span: 8;
+  }
+  .cell.is-row-start-8-widescreen {
+    --bulma-grid-cell-row-start: 8;
+  }
+  .cell.is-row-end-8-widescreen {
+    --bulma-grid-cell-row-end: 8;
+  }
+  .cell.is-row-from-end-8-widescreen {
+    --bulma-grid-cell-row-start: -8;
+  }
+  .cell.is-row-span-8-widescreen {
+    --bulma-grid-cell-row-span: 8;
+  }
+  .cell.is-col-start-9-widescreen {
+    --bulma-grid-cell-column-start: 9;
+  }
+  .cell.is-col-end-9-widescreen {
+    --bulma-grid-cell-column-end: 9;
+  }
+  .cell.is-col-from-end-9-widescreen {
+    --bulma-grid-cell-column-start: -9;
+  }
+  .cell.is-col-span-9-widescreen {
+    --bulma-grid-cell-column-span: 9;
+  }
+  .cell.is-row-start-9-widescreen {
+    --bulma-grid-cell-row-start: 9;
+  }
+  .cell.is-row-end-9-widescreen {
+    --bulma-grid-cell-row-end: 9;
+  }
+  .cell.is-row-from-end-9-widescreen {
+    --bulma-grid-cell-row-start: -9;
+  }
+  .cell.is-row-span-9-widescreen {
+    --bulma-grid-cell-row-span: 9;
+  }
+  .cell.is-col-start-10-widescreen {
+    --bulma-grid-cell-column-start: 10;
+  }
+  .cell.is-col-end-10-widescreen {
+    --bulma-grid-cell-column-end: 10;
+  }
+  .cell.is-col-from-end-10-widescreen {
+    --bulma-grid-cell-column-start: -10;
+  }
+  .cell.is-col-span-10-widescreen {
+    --bulma-grid-cell-column-span: 10;
+  }
+  .cell.is-row-start-10-widescreen {
+    --bulma-grid-cell-row-start: 10;
+  }
+  .cell.is-row-end-10-widescreen {
+    --bulma-grid-cell-row-end: 10;
+  }
+  .cell.is-row-from-end-10-widescreen {
+    --bulma-grid-cell-row-start: -10;
+  }
+  .cell.is-row-span-10-widescreen {
+    --bulma-grid-cell-row-span: 10;
+  }
+  .cell.is-col-start-11-widescreen {
+    --bulma-grid-cell-column-start: 11;
+  }
+  .cell.is-col-end-11-widescreen {
+    --bulma-grid-cell-column-end: 11;
+  }
+  .cell.is-col-from-end-11-widescreen {
+    --bulma-grid-cell-column-start: -11;
+  }
+  .cell.is-col-span-11-widescreen {
+    --bulma-grid-cell-column-span: 11;
+  }
+  .cell.is-row-start-11-widescreen {
+    --bulma-grid-cell-row-start: 11;
+  }
+  .cell.is-row-end-11-widescreen {
+    --bulma-grid-cell-row-end: 11;
+  }
+  .cell.is-row-from-end-11-widescreen {
+    --bulma-grid-cell-row-start: -11;
+  }
+  .cell.is-row-span-11-widescreen {
+    --bulma-grid-cell-row-span: 11;
+  }
+  .cell.is-col-start-12-widescreen {
+    --bulma-grid-cell-column-start: 12;
+  }
+  .cell.is-col-end-12-widescreen {
+    --bulma-grid-cell-column-end: 12;
+  }
+  .cell.is-col-from-end-12-widescreen {
+    --bulma-grid-cell-column-start: -12;
+  }
+  .cell.is-col-span-12-widescreen {
+    --bulma-grid-cell-column-span: 12;
+  }
+  .cell.is-row-start-12-widescreen {
+    --bulma-grid-cell-row-start: 12;
+  }
+  .cell.is-row-end-12-widescreen {
+    --bulma-grid-cell-row-end: 12;
+  }
+  .cell.is-row-from-end-12-widescreen {
+    --bulma-grid-cell-row-start: -12;
+  }
+  .cell.is-row-span-12-widescreen {
+    --bulma-grid-cell-row-span: 12;
+  }
+}
+@media screen and (min-width: 1216px) and (max-width: 1407px) {
+  .cell.is-col-start-1-widescreen-only {
+    --bulma-grid-cell-column-start: 1;
+  }
+  .cell.is-col-end-1-widescreen-only {
+    --bulma-grid-cell-column-end: 1;
+  }
+  .cell.is-col-from-end-1-widescreen-only {
+    --bulma-grid-cell-column-start: -1;
+  }
+  .cell.is-col-span-1-widescreen-only {
+    --bulma-grid-cell-column-span: 1;
+  }
+  .cell.is-row-start-1-widescreen-only {
+    --bulma-grid-cell-row-start: 1;
+  }
+  .cell.is-row-end-1-widescreen-only {
+    --bulma-grid-cell-row-end: 1;
+  }
+  .cell.is-row-from-end-1-widescreen-only {
+    --bulma-grid-cell-row-start: -1;
+  }
+  .cell.is-row-span-1-widescreen-only {
+    --bulma-grid-cell-row-span: 1;
+  }
+  .cell.is-col-start-2-widescreen-only {
+    --bulma-grid-cell-column-start: 2;
+  }
+  .cell.is-col-end-2-widescreen-only {
+    --bulma-grid-cell-column-end: 2;
+  }
+  .cell.is-col-from-end-2-widescreen-only {
+    --bulma-grid-cell-column-start: -2;
+  }
+  .cell.is-col-span-2-widescreen-only {
+    --bulma-grid-cell-column-span: 2;
+  }
+  .cell.is-row-start-2-widescreen-only {
+    --bulma-grid-cell-row-start: 2;
+  }
+  .cell.is-row-end-2-widescreen-only {
+    --bulma-grid-cell-row-end: 2;
+  }
+  .cell.is-row-from-end-2-widescreen-only {
+    --bulma-grid-cell-row-start: -2;
+  }
+  .cell.is-row-span-2-widescreen-only {
+    --bulma-grid-cell-row-span: 2;
+  }
+  .cell.is-col-start-3-widescreen-only {
+    --bulma-grid-cell-column-start: 3;
+  }
+  .cell.is-col-end-3-widescreen-only {
+    --bulma-grid-cell-column-end: 3;
+  }
+  .cell.is-col-from-end-3-widescreen-only {
+    --bulma-grid-cell-column-start: -3;
+  }
+  .cell.is-col-span-3-widescreen-only {
+    --bulma-grid-cell-column-span: 3;
+  }
+  .cell.is-row-start-3-widescreen-only {
+    --bulma-grid-cell-row-start: 3;
+  }
+  .cell.is-row-end-3-widescreen-only {
+    --bulma-grid-cell-row-end: 3;
+  }
+  .cell.is-row-from-end-3-widescreen-only {
+    --bulma-grid-cell-row-start: -3;
+  }
+  .cell.is-row-span-3-widescreen-only {
+    --bulma-grid-cell-row-span: 3;
+  }
+  .cell.is-col-start-4-widescreen-only {
+    --bulma-grid-cell-column-start: 4;
+  }
+  .cell.is-col-end-4-widescreen-only {
+    --bulma-grid-cell-column-end: 4;
+  }
+  .cell.is-col-from-end-4-widescreen-only {
+    --bulma-grid-cell-column-start: -4;
+  }
+  .cell.is-col-span-4-widescreen-only {
+    --bulma-grid-cell-column-span: 4;
+  }
+  .cell.is-row-start-4-widescreen-only {
+    --bulma-grid-cell-row-start: 4;
+  }
+  .cell.is-row-end-4-widescreen-only {
+    --bulma-grid-cell-row-end: 4;
+  }
+  .cell.is-row-from-end-4-widescreen-only {
+    --bulma-grid-cell-row-start: -4;
+  }
+  .cell.is-row-span-4-widescreen-only {
+    --bulma-grid-cell-row-span: 4;
+  }
+  .cell.is-col-start-5-widescreen-only {
+    --bulma-grid-cell-column-start: 5;
+  }
+  .cell.is-col-end-5-widescreen-only {
+    --bulma-grid-cell-column-end: 5;
+  }
+  .cell.is-col-from-end-5-widescreen-only {
+    --bulma-grid-cell-column-start: -5;
+  }
+  .cell.is-col-span-5-widescreen-only {
+    --bulma-grid-cell-column-span: 5;
+  }
+  .cell.is-row-start-5-widescreen-only {
+    --bulma-grid-cell-row-start: 5;
+  }
+  .cell.is-row-end-5-widescreen-only {
+    --bulma-grid-cell-row-end: 5;
+  }
+  .cell.is-row-from-end-5-widescreen-only {
+    --bulma-grid-cell-row-start: -5;
+  }
+  .cell.is-row-span-5-widescreen-only {
+    --bulma-grid-cell-row-span: 5;
+  }
+  .cell.is-col-start-6-widescreen-only {
+    --bulma-grid-cell-column-start: 6;
+  }
+  .cell.is-col-end-6-widescreen-only {
+    --bulma-grid-cell-column-end: 6;
+  }
+  .cell.is-col-from-end-6-widescreen-only {
+    --bulma-grid-cell-column-start: -6;
+  }
+  .cell.is-col-span-6-widescreen-only {
+    --bulma-grid-cell-column-span: 6;
+  }
+  .cell.is-row-start-6-widescreen-only {
+    --bulma-grid-cell-row-start: 6;
+  }
+  .cell.is-row-end-6-widescreen-only {
+    --bulma-grid-cell-row-end: 6;
+  }
+  .cell.is-row-from-end-6-widescreen-only {
+    --bulma-grid-cell-row-start: -6;
+  }
+  .cell.is-row-span-6-widescreen-only {
+    --bulma-grid-cell-row-span: 6;
+  }
+  .cell.is-col-start-7-widescreen-only {
+    --bulma-grid-cell-column-start: 7;
+  }
+  .cell.is-col-end-7-widescreen-only {
+    --bulma-grid-cell-column-end: 7;
+  }
+  .cell.is-col-from-end-7-widescreen-only {
+    --bulma-grid-cell-column-start: -7;
+  }
+  .cell.is-col-span-7-widescreen-only {
+    --bulma-grid-cell-column-span: 7;
+  }
+  .cell.is-row-start-7-widescreen-only {
+    --bulma-grid-cell-row-start: 7;
+  }
+  .cell.is-row-end-7-widescreen-only {
+    --bulma-grid-cell-row-end: 7;
+  }
+  .cell.is-row-from-end-7-widescreen-only {
+    --bulma-grid-cell-row-start: -7;
+  }
+  .cell.is-row-span-7-widescreen-only {
+    --bulma-grid-cell-row-span: 7;
+  }
+  .cell.is-col-start-8-widescreen-only {
+    --bulma-grid-cell-column-start: 8;
+  }
+  .cell.is-col-end-8-widescreen-only {
+    --bulma-grid-cell-column-end: 8;
+  }
+  .cell.is-col-from-end-8-widescreen-only {
+    --bulma-grid-cell-column-start: -8;
+  }
+  .cell.is-col-span-8-widescreen-only {
+    --bulma-grid-cell-column-span: 8;
+  }
+  .cell.is-row-start-8-widescreen-only {
+    --bulma-grid-cell-row-start: 8;
+  }
+  .cell.is-row-end-8-widescreen-only {
+    --bulma-grid-cell-row-end: 8;
+  }
+  .cell.is-row-from-end-8-widescreen-only {
+    --bulma-grid-cell-row-start: -8;
+  }
+  .cell.is-row-span-8-widescreen-only {
+    --bulma-grid-cell-row-span: 8;
+  }
+  .cell.is-col-start-9-widescreen-only {
+    --bulma-grid-cell-column-start: 9;
+  }
+  .cell.is-col-end-9-widescreen-only {
+    --bulma-grid-cell-column-end: 9;
+  }
+  .cell.is-col-from-end-9-widescreen-only {
+    --bulma-grid-cell-column-start: -9;
+  }
+  .cell.is-col-span-9-widescreen-only {
+    --bulma-grid-cell-column-span: 9;
+  }
+  .cell.is-row-start-9-widescreen-only {
+    --bulma-grid-cell-row-start: 9;
+  }
+  .cell.is-row-end-9-widescreen-only {
+    --bulma-grid-cell-row-end: 9;
+  }
+  .cell.is-row-from-end-9-widescreen-only {
+    --bulma-grid-cell-row-start: -9;
+  }
+  .cell.is-row-span-9-widescreen-only {
+    --bulma-grid-cell-row-span: 9;
+  }
+  .cell.is-col-start-10-widescreen-only {
+    --bulma-grid-cell-column-start: 10;
+  }
+  .cell.is-col-end-10-widescreen-only {
+    --bulma-grid-cell-column-end: 10;
+  }
+  .cell.is-col-from-end-10-widescreen-only {
+    --bulma-grid-cell-column-start: -10;
+  }
+  .cell.is-col-span-10-widescreen-only {
+    --bulma-grid-cell-column-span: 10;
+  }
+  .cell.is-row-start-10-widescreen-only {
+    --bulma-grid-cell-row-start: 10;
+  }
+  .cell.is-row-end-10-widescreen-only {
+    --bulma-grid-cell-row-end: 10;
+  }
+  .cell.is-row-from-end-10-widescreen-only {
+    --bulma-grid-cell-row-start: -10;
+  }
+  .cell.is-row-span-10-widescreen-only {
+    --bulma-grid-cell-row-span: 10;
+  }
+  .cell.is-col-start-11-widescreen-only {
+    --bulma-grid-cell-column-start: 11;
+  }
+  .cell.is-col-end-11-widescreen-only {
+    --bulma-grid-cell-column-end: 11;
+  }
+  .cell.is-col-from-end-11-widescreen-only {
+    --bulma-grid-cell-column-start: -11;
+  }
+  .cell.is-col-span-11-widescreen-only {
+    --bulma-grid-cell-column-span: 11;
+  }
+  .cell.is-row-start-11-widescreen-only {
+    --bulma-grid-cell-row-start: 11;
+  }
+  .cell.is-row-end-11-widescreen-only {
+    --bulma-grid-cell-row-end: 11;
+  }
+  .cell.is-row-from-end-11-widescreen-only {
+    --bulma-grid-cell-row-start: -11;
+  }
+  .cell.is-row-span-11-widescreen-only {
+    --bulma-grid-cell-row-span: 11;
+  }
+  .cell.is-col-start-12-widescreen-only {
+    --bulma-grid-cell-column-start: 12;
+  }
+  .cell.is-col-end-12-widescreen-only {
+    --bulma-grid-cell-column-end: 12;
+  }
+  .cell.is-col-from-end-12-widescreen-only {
+    --bulma-grid-cell-column-start: -12;
+  }
+  .cell.is-col-span-12-widescreen-only {
+    --bulma-grid-cell-column-span: 12;
+  }
+  .cell.is-row-start-12-widescreen-only {
+    --bulma-grid-cell-row-start: 12;
+  }
+  .cell.is-row-end-12-widescreen-only {
+    --bulma-grid-cell-row-end: 12;
+  }
+  .cell.is-row-from-end-12-widescreen-only {
+    --bulma-grid-cell-row-start: -12;
+  }
+  .cell.is-row-span-12-widescreen-only {
+    --bulma-grid-cell-row-span: 12;
+  }
+}
+@media screen and (min-width: 1408px) {
+  .cell.is-col-start-1-fullhd {
+    --bulma-grid-cell-column-start: 1;
+  }
+  .cell.is-col-end-1-fullhd {
+    --bulma-grid-cell-column-end: 1;
+  }
+  .cell.is-col-from-end-1-fullhd {
+    --bulma-grid-cell-column-start: -1;
+  }
+  .cell.is-col-span-1-fullhd {
+    --bulma-grid-cell-column-span: 1;
+  }
+  .cell.is-row-start-1-fullhd {
+    --bulma-grid-cell-row-start: 1;
+  }
+  .cell.is-row-end-1-fullhd {
+    --bulma-grid-cell-row-end: 1;
+  }
+  .cell.is-row-from-end-1-fullhd {
+    --bulma-grid-cell-row-start: -1;
+  }
+  .cell.is-row-span-1-fullhd {
+    --bulma-grid-cell-row-span: 1;
+  }
+  .cell.is-col-start-2-fullhd {
+    --bulma-grid-cell-column-start: 2;
+  }
+  .cell.is-col-end-2-fullhd {
+    --bulma-grid-cell-column-end: 2;
+  }
+  .cell.is-col-from-end-2-fullhd {
+    --bulma-grid-cell-column-start: -2;
+  }
+  .cell.is-col-span-2-fullhd {
+    --bulma-grid-cell-column-span: 2;
+  }
+  .cell.is-row-start-2-fullhd {
+    --bulma-grid-cell-row-start: 2;
+  }
+  .cell.is-row-end-2-fullhd {
+    --bulma-grid-cell-row-end: 2;
+  }
+  .cell.is-row-from-end-2-fullhd {
+    --bulma-grid-cell-row-start: -2;
+  }
+  .cell.is-row-span-2-fullhd {
+    --bulma-grid-cell-row-span: 2;
+  }
+  .cell.is-col-start-3-fullhd {
+    --bulma-grid-cell-column-start: 3;
+  }
+  .cell.is-col-end-3-fullhd {
+    --bulma-grid-cell-column-end: 3;
+  }
+  .cell.is-col-from-end-3-fullhd {
+    --bulma-grid-cell-column-start: -3;
+  }
+  .cell.is-col-span-3-fullhd {
+    --bulma-grid-cell-column-span: 3;
+  }
+  .cell.is-row-start-3-fullhd {
+    --bulma-grid-cell-row-start: 3;
+  }
+  .cell.is-row-end-3-fullhd {
+    --bulma-grid-cell-row-end: 3;
+  }
+  .cell.is-row-from-end-3-fullhd {
+    --bulma-grid-cell-row-start: -3;
+  }
+  .cell.is-row-span-3-fullhd {
+    --bulma-grid-cell-row-span: 3;
+  }
+  .cell.is-col-start-4-fullhd {
+    --bulma-grid-cell-column-start: 4;
+  }
+  .cell.is-col-end-4-fullhd {
+    --bulma-grid-cell-column-end: 4;
+  }
+  .cell.is-col-from-end-4-fullhd {
+    --bulma-grid-cell-column-start: -4;
+  }
+  .cell.is-col-span-4-fullhd {
+    --bulma-grid-cell-column-span: 4;
+  }
+  .cell.is-row-start-4-fullhd {
+    --bulma-grid-cell-row-start: 4;
+  }
+  .cell.is-row-end-4-fullhd {
+    --bulma-grid-cell-row-end: 4;
+  }
+  .cell.is-row-from-end-4-fullhd {
+    --bulma-grid-cell-row-start: -4;
+  }
+  .cell.is-row-span-4-fullhd {
+    --bulma-grid-cell-row-span: 4;
+  }
+  .cell.is-col-start-5-fullhd {
+    --bulma-grid-cell-column-start: 5;
+  }
+  .cell.is-col-end-5-fullhd {
+    --bulma-grid-cell-column-end: 5;
+  }
+  .cell.is-col-from-end-5-fullhd {
+    --bulma-grid-cell-column-start: -5;
+  }
+  .cell.is-col-span-5-fullhd {
+    --bulma-grid-cell-column-span: 5;
+  }
+  .cell.is-row-start-5-fullhd {
+    --bulma-grid-cell-row-start: 5;
+  }
+  .cell.is-row-end-5-fullhd {
+    --bulma-grid-cell-row-end: 5;
+  }
+  .cell.is-row-from-end-5-fullhd {
+    --bulma-grid-cell-row-start: -5;
+  }
+  .cell.is-row-span-5-fullhd {
+    --bulma-grid-cell-row-span: 5;
+  }
+  .cell.is-col-start-6-fullhd {
+    --bulma-grid-cell-column-start: 6;
+  }
+  .cell.is-col-end-6-fullhd {
+    --bulma-grid-cell-column-end: 6;
+  }
+  .cell.is-col-from-end-6-fullhd {
+    --bulma-grid-cell-column-start: -6;
+  }
+  .cell.is-col-span-6-fullhd {
+    --bulma-grid-cell-column-span: 6;
+  }
+  .cell.is-row-start-6-fullhd {
+    --bulma-grid-cell-row-start: 6;
+  }
+  .cell.is-row-end-6-fullhd {
+    --bulma-grid-cell-row-end: 6;
+  }
+  .cell.is-row-from-end-6-fullhd {
+    --bulma-grid-cell-row-start: -6;
+  }
+  .cell.is-row-span-6-fullhd {
+    --bulma-grid-cell-row-span: 6;
+  }
+  .cell.is-col-start-7-fullhd {
+    --bulma-grid-cell-column-start: 7;
+  }
+  .cell.is-col-end-7-fullhd {
+    --bulma-grid-cell-column-end: 7;
+  }
+  .cell.is-col-from-end-7-fullhd {
+    --bulma-grid-cell-column-start: -7;
+  }
+  .cell.is-col-span-7-fullhd {
+    --bulma-grid-cell-column-span: 7;
+  }
+  .cell.is-row-start-7-fullhd {
+    --bulma-grid-cell-row-start: 7;
+  }
+  .cell.is-row-end-7-fullhd {
+    --bulma-grid-cell-row-end: 7;
+  }
+  .cell.is-row-from-end-7-fullhd {
+    --bulma-grid-cell-row-start: -7;
+  }
+  .cell.is-row-span-7-fullhd {
+    --bulma-grid-cell-row-span: 7;
+  }
+  .cell.is-col-start-8-fullhd {
+    --bulma-grid-cell-column-start: 8;
+  }
+  .cell.is-col-end-8-fullhd {
+    --bulma-grid-cell-column-end: 8;
+  }
+  .cell.is-col-from-end-8-fullhd {
+    --bulma-grid-cell-column-start: -8;
+  }
+  .cell.is-col-span-8-fullhd {
+    --bulma-grid-cell-column-span: 8;
+  }
+  .cell.is-row-start-8-fullhd {
+    --bulma-grid-cell-row-start: 8;
+  }
+  .cell.is-row-end-8-fullhd {
+    --bulma-grid-cell-row-end: 8;
+  }
+  .cell.is-row-from-end-8-fullhd {
+    --bulma-grid-cell-row-start: -8;
+  }
+  .cell.is-row-span-8-fullhd {
+    --bulma-grid-cell-row-span: 8;
+  }
+  .cell.is-col-start-9-fullhd {
+    --bulma-grid-cell-column-start: 9;
+  }
+  .cell.is-col-end-9-fullhd {
+    --bulma-grid-cell-column-end: 9;
+  }
+  .cell.is-col-from-end-9-fullhd {
+    --bulma-grid-cell-column-start: -9;
+  }
+  .cell.is-col-span-9-fullhd {
+    --bulma-grid-cell-column-span: 9;
+  }
+  .cell.is-row-start-9-fullhd {
+    --bulma-grid-cell-row-start: 9;
+  }
+  .cell.is-row-end-9-fullhd {
+    --bulma-grid-cell-row-end: 9;
+  }
+  .cell.is-row-from-end-9-fullhd {
+    --bulma-grid-cell-row-start: -9;
+  }
+  .cell.is-row-span-9-fullhd {
+    --bulma-grid-cell-row-span: 9;
+  }
+  .cell.is-col-start-10-fullhd {
+    --bulma-grid-cell-column-start: 10;
+  }
+  .cell.is-col-end-10-fullhd {
+    --bulma-grid-cell-column-end: 10;
+  }
+  .cell.is-col-from-end-10-fullhd {
+    --bulma-grid-cell-column-start: -10;
+  }
+  .cell.is-col-span-10-fullhd {
+    --bulma-grid-cell-column-span: 10;
+  }
+  .cell.is-row-start-10-fullhd {
+    --bulma-grid-cell-row-start: 10;
+  }
+  .cell.is-row-end-10-fullhd {
+    --bulma-grid-cell-row-end: 10;
+  }
+  .cell.is-row-from-end-10-fullhd {
+    --bulma-grid-cell-row-start: -10;
+  }
+  .cell.is-row-span-10-fullhd {
+    --bulma-grid-cell-row-span: 10;
+  }
+  .cell.is-col-start-11-fullhd {
+    --bulma-grid-cell-column-start: 11;
+  }
+  .cell.is-col-end-11-fullhd {
+    --bulma-grid-cell-column-end: 11;
+  }
+  .cell.is-col-from-end-11-fullhd {
+    --bulma-grid-cell-column-start: -11;
+  }
+  .cell.is-col-span-11-fullhd {
+    --bulma-grid-cell-column-span: 11;
+  }
+  .cell.is-row-start-11-fullhd {
+    --bulma-grid-cell-row-start: 11;
+  }
+  .cell.is-row-end-11-fullhd {
+    --bulma-grid-cell-row-end: 11;
+  }
+  .cell.is-row-from-end-11-fullhd {
+    --bulma-grid-cell-row-start: -11;
+  }
+  .cell.is-row-span-11-fullhd {
+    --bulma-grid-cell-row-span: 11;
+  }
+  .cell.is-col-start-12-fullhd {
+    --bulma-grid-cell-column-start: 12;
+  }
+  .cell.is-col-end-12-fullhd {
+    --bulma-grid-cell-column-end: 12;
+  }
+  .cell.is-col-from-end-12-fullhd {
+    --bulma-grid-cell-column-start: -12;
+  }
+  .cell.is-col-span-12-fullhd {
+    --bulma-grid-cell-column-span: 12;
+  }
+  .cell.is-row-start-12-fullhd {
+    --bulma-grid-cell-row-start: 12;
+  }
+  .cell.is-row-end-12-fullhd {
+    --bulma-grid-cell-row-end: 12;
+  }
+  .cell.is-row-from-end-12-fullhd {
+    --bulma-grid-cell-row-start: -12;
+  }
+  .cell.is-row-span-12-fullhd {
+    --bulma-grid-cell-row-span: 12;
+  }
+}
+
+/* Bulma Components */
+.container {
+  flex-grow: 1;
+  margin: 0 auto;
+  position: relative;
+  width: 100%;
+}
+.container.is-fluid {
+  max-width: none !important;
+  padding-left: 32px;
+  padding-right: 32px;
+  width: 100%;
+}
+.container.is-max-tablet {
+  max-width: 705px;
+}
+@media screen and (min-width: 1024px) {
+  .container {
+    max-width: 960px;
+  }
+}
+@media screen and (max-width: 1215px) {
+  .container.is-widescreen:not(.is-max-tablet):not(.is-max-desktop) {
+    max-width: 1152px;
+  }
+}
+@media screen and (max-width: 1407px) {
+  .container.is-fullhd:not(.is-max-tablet):not(.is-max-desktop):not(.is-max-widescreen) {
+    max-width: 1344px;
+  }
+}
+@media screen and (min-width: 1216px) {
+  .container:not(.is-max-tablet):not(.is-max-desktop) {
+    max-width: 1152px;
+  }
+}
+@media screen and (min-width: 1408px) {
+  .container:not(.is-max-tablet):not(.is-max-desktop):not(.is-max-widescreen) {
+    max-width: 1344px;
+  }
+}
+
+.footer {
+  --bulma-footer-background-color: var(--bulma-scheme-main-bis);
+  --bulma-footer-color: false;
+  --bulma-footer-padding: 3rem 1.5rem 6rem;
+  background-color: var(--bulma-footer-background-color);
+  padding: var(--bulma-footer-padding);
+}
+
+.hero {
+  --bulma-hero-body-padding: 3rem 1.5rem;
+  --bulma-hero-body-padding-tablet: 3rem 3rem;
+  --bulma-hero-body-padding-small: 1.5rem;
+  --bulma-hero-body-padding-medium: 9rem 4.5rem;
+  --bulma-hero-body-padding-large: 18rem 6rem;
+}
+
+.hero {
+  align-items: stretch;
+  display: flex;
+  flex-direction: column;
+  justify-content: space-between;
+}
+.hero .navbar {
+  background: none;
+}
+.hero .tabs ul {
+  border-bottom: none;
+}
+.hero.is-white {
+  --bulma-hero-h: var(--bulma-white-h);
+  --bulma-hero-s: var(--bulma-white-s);
+  --bulma-hero-background-l: var(--bulma-white-l);
+  --bulma-hero-color-l: var(--bulma-white-invert-l);
+  background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+  color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+}
+.hero.is-white .navbar {
+  --bulma-navbar-item-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-navbar-item-hover-background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-navbar-item-hover-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+  --bulma-navbar-item-active-background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-navbar-item-active-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+}
+.hero.is-white .tabs {
+  --bulma-tabs-link-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-tabs-boxed-link-active-background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-tabs-boxed-link-active-border-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+  --bulma-tabs-link-active-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+}
+.hero.is-white .subtitle {
+  --bulma-subtitle-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-subtitle-strong-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+}
+.hero.is-white .title {
+  --bulma-title-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-title-strong-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+}
+.hero.is-white.is-bold {
+  background-image: linear-gradient(141deg, hsl(calc(var(--bulma-hero-h) - 5deg), calc(var(--bulma-hero-s) + 10%), calc(var(--bulma-hero-background-l) + 5%)) 0%, hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l)) 71%, hsl(calc(var(--bulma-hero-h) + 5deg), calc(var(--bulma-hero-s) - 10%), calc(var(--bulma-hero-background-l) - 5%)) 100%);
+}
+@media screen and (max-width: 768px) {
+  .hero.is-white.is-bold .navbar-menu {
+    background-image: linear-gradient(141deg, hsl(calc(var(--bulma-hero-h) - 5deg), calc(var(--bulma-hero-s) + 10%), calc(var(--bulma-hero-background-l) + 5%)) 0%, hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l)) 71%, hsl(calc(var(--bulma-hero-h) + 5deg), calc(var(--bulma-hero-s) - 10%), calc(var(--bulma-hero-background-l) - 5%)) 100%);
+  }
+}
+.hero.is-black {
+  --bulma-hero-h: var(--bulma-black-h);
+  --bulma-hero-s: var(--bulma-black-s);
+  --bulma-hero-background-l: var(--bulma-black-l);
+  --bulma-hero-color-l: var(--bulma-black-invert-l);
+  background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+  color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+}
+.hero.is-black .navbar {
+  --bulma-navbar-item-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-navbar-item-hover-background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-navbar-item-hover-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+  --bulma-navbar-item-active-background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-navbar-item-active-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+}
+.hero.is-black .tabs {
+  --bulma-tabs-link-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-tabs-boxed-link-active-background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-tabs-boxed-link-active-border-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+  --bulma-tabs-link-active-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+}
+.hero.is-black .subtitle {
+  --bulma-subtitle-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-subtitle-strong-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+}
+.hero.is-black .title {
+  --bulma-title-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-title-strong-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+}
+.hero.is-black.is-bold {
+  background-image: linear-gradient(141deg, hsl(calc(var(--bulma-hero-h) - 5deg), calc(var(--bulma-hero-s) + 10%), calc(var(--bulma-hero-background-l) + 5%)) 0%, hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l)) 71%, hsl(calc(var(--bulma-hero-h) + 5deg), calc(var(--bulma-hero-s) - 10%), calc(var(--bulma-hero-background-l) - 5%)) 100%);
+}
+@media screen and (max-width: 768px) {
+  .hero.is-black.is-bold .navbar-menu {
+    background-image: linear-gradient(141deg, hsl(calc(var(--bulma-hero-h) - 5deg), calc(var(--bulma-hero-s) + 10%), calc(var(--bulma-hero-background-l) + 5%)) 0%, hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l)) 71%, hsl(calc(var(--bulma-hero-h) + 5deg), calc(var(--bulma-hero-s) - 10%), calc(var(--bulma-hero-background-l) - 5%)) 100%);
+  }
+}
+.hero.is-light {
+  --bulma-hero-h: var(--bulma-light-h);
+  --bulma-hero-s: var(--bulma-light-s);
+  --bulma-hero-background-l: var(--bulma-light-l);
+  --bulma-hero-color-l: var(--bulma-light-invert-l);
+  background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+  color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+}
+.hero.is-light .navbar {
+  --bulma-navbar-item-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-navbar-item-hover-background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-navbar-item-hover-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+  --bulma-navbar-item-active-background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-navbar-item-active-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+}
+.hero.is-light .tabs {
+  --bulma-tabs-link-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-tabs-boxed-link-active-background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-tabs-boxed-link-active-border-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+  --bulma-tabs-link-active-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+}
+.hero.is-light .subtitle {
+  --bulma-subtitle-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-subtitle-strong-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+}
+.hero.is-light .title {
+  --bulma-title-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-title-strong-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+}
+.hero.is-light.is-bold {
+  background-image: linear-gradient(141deg, hsl(calc(var(--bulma-hero-h) - 5deg), calc(var(--bulma-hero-s) + 10%), calc(var(--bulma-hero-background-l) + 5%)) 0%, hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l)) 71%, hsl(calc(var(--bulma-hero-h) + 5deg), calc(var(--bulma-hero-s) - 10%), calc(var(--bulma-hero-background-l) - 5%)) 100%);
+}
+@media screen and (max-width: 768px) {
+  .hero.is-light.is-bold .navbar-menu {
+    background-image: linear-gradient(141deg, hsl(calc(var(--bulma-hero-h) - 5deg), calc(var(--bulma-hero-s) + 10%), calc(var(--bulma-hero-background-l) + 5%)) 0%, hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l)) 71%, hsl(calc(var(--bulma-hero-h) + 5deg), calc(var(--bulma-hero-s) - 10%), calc(var(--bulma-hero-background-l) - 5%)) 100%);
+  }
+}
+.hero.is-dark {
+  --bulma-hero-h: var(--bulma-dark-h);
+  --bulma-hero-s: var(--bulma-dark-s);
+  --bulma-hero-background-l: var(--bulma-dark-l);
+  --bulma-hero-color-l: var(--bulma-dark-invert-l);
+  background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+  color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+}
+.hero.is-dark .navbar {
+  --bulma-navbar-item-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-navbar-item-hover-background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-navbar-item-hover-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+  --bulma-navbar-item-active-background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-navbar-item-active-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+}
+.hero.is-dark .tabs {
+  --bulma-tabs-link-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-tabs-boxed-link-active-background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-tabs-boxed-link-active-border-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+  --bulma-tabs-link-active-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+}
+.hero.is-dark .subtitle {
+  --bulma-subtitle-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-subtitle-strong-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+}
+.hero.is-dark .title {
+  --bulma-title-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-title-strong-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+}
+.hero.is-dark.is-bold {
+  background-image: linear-gradient(141deg, hsl(calc(var(--bulma-hero-h) - 5deg), calc(var(--bulma-hero-s) + 10%), calc(var(--bulma-hero-background-l) + 5%)) 0%, hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l)) 71%, hsl(calc(var(--bulma-hero-h) + 5deg), calc(var(--bulma-hero-s) - 10%), calc(var(--bulma-hero-background-l) - 5%)) 100%);
+}
+@media screen and (max-width: 768px) {
+  .hero.is-dark.is-bold .navbar-menu {
+    background-image: linear-gradient(141deg, hsl(calc(var(--bulma-hero-h) - 5deg), calc(var(--bulma-hero-s) + 10%), calc(var(--bulma-hero-background-l) + 5%)) 0%, hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l)) 71%, hsl(calc(var(--bulma-hero-h) + 5deg), calc(var(--bulma-hero-s) - 10%), calc(var(--bulma-hero-background-l) - 5%)) 100%);
+  }
+}
+.hero.is-text {
+  --bulma-hero-h: var(--bulma-text-h);
+  --bulma-hero-s: var(--bulma-text-s);
+  --bulma-hero-background-l: var(--bulma-text-l);
+  --bulma-hero-color-l: var(--bulma-text-invert-l);
+  background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+  color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+}
+.hero.is-text .navbar {
+  --bulma-navbar-item-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-navbar-item-hover-background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-navbar-item-hover-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+  --bulma-navbar-item-active-background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-navbar-item-active-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+}
+.hero.is-text .tabs {
+  --bulma-tabs-link-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-tabs-boxed-link-active-background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-tabs-boxed-link-active-border-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+  --bulma-tabs-link-active-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+}
+.hero.is-text .subtitle {
+  --bulma-subtitle-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-subtitle-strong-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+}
+.hero.is-text .title {
+  --bulma-title-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-title-strong-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+}
+.hero.is-text.is-bold {
+  background-image: linear-gradient(141deg, hsl(calc(var(--bulma-hero-h) - 5deg), calc(var(--bulma-hero-s) + 10%), calc(var(--bulma-hero-background-l) + 5%)) 0%, hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l)) 71%, hsl(calc(var(--bulma-hero-h) + 5deg), calc(var(--bulma-hero-s) - 10%), calc(var(--bulma-hero-background-l) - 5%)) 100%);
+}
+@media screen and (max-width: 768px) {
+  .hero.is-text.is-bold .navbar-menu {
+    background-image: linear-gradient(141deg, hsl(calc(var(--bulma-hero-h) - 5deg), calc(var(--bulma-hero-s) + 10%), calc(var(--bulma-hero-background-l) + 5%)) 0%, hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l)) 71%, hsl(calc(var(--bulma-hero-h) + 5deg), calc(var(--bulma-hero-s) - 10%), calc(var(--bulma-hero-background-l) - 5%)) 100%);
+  }
+}
+.hero.is-primary {
+  --bulma-hero-h: var(--bulma-primary-h);
+  --bulma-hero-s: var(--bulma-primary-s);
+  --bulma-hero-background-l: var(--bulma-primary-l);
+  --bulma-hero-color-l: var(--bulma-primary-invert-l);
+  background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+  color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+}
+.hero.is-primary .navbar {
+  --bulma-navbar-item-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-navbar-item-hover-background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-navbar-item-hover-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+  --bulma-navbar-item-active-background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-navbar-item-active-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+}
+.hero.is-primary .tabs {
+  --bulma-tabs-link-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-tabs-boxed-link-active-background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-tabs-boxed-link-active-border-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+  --bulma-tabs-link-active-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+}
+.hero.is-primary .subtitle {
+  --bulma-subtitle-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-subtitle-strong-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+}
+.hero.is-primary .title {
+  --bulma-title-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-title-strong-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+}
+.hero.is-primary.is-bold {
+  background-image: linear-gradient(141deg, hsl(calc(var(--bulma-hero-h) - 5deg), calc(var(--bulma-hero-s) + 10%), calc(var(--bulma-hero-background-l) + 5%)) 0%, hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l)) 71%, hsl(calc(var(--bulma-hero-h) + 5deg), calc(var(--bulma-hero-s) - 10%), calc(var(--bulma-hero-background-l) - 5%)) 100%);
+}
+@media screen and (max-width: 768px) {
+  .hero.is-primary.is-bold .navbar-menu {
+    background-image: linear-gradient(141deg, hsl(calc(var(--bulma-hero-h) - 5deg), calc(var(--bulma-hero-s) + 10%), calc(var(--bulma-hero-background-l) + 5%)) 0%, hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l)) 71%, hsl(calc(var(--bulma-hero-h) + 5deg), calc(var(--bulma-hero-s) - 10%), calc(var(--bulma-hero-background-l) - 5%)) 100%);
+  }
+}
+.hero.is-link {
+  --bulma-hero-h: var(--bulma-link-h);
+  --bulma-hero-s: var(--bulma-link-s);
+  --bulma-hero-background-l: var(--bulma-link-l);
+  --bulma-hero-color-l: var(--bulma-link-invert-l);
+  background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+  color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+}
+.hero.is-link .navbar {
+  --bulma-navbar-item-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-navbar-item-hover-background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-navbar-item-hover-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+  --bulma-navbar-item-active-background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-navbar-item-active-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+}
+.hero.is-link .tabs {
+  --bulma-tabs-link-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-tabs-boxed-link-active-background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-tabs-boxed-link-active-border-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+  --bulma-tabs-link-active-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+}
+.hero.is-link .subtitle {
+  --bulma-subtitle-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-subtitle-strong-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+}
+.hero.is-link .title {
+  --bulma-title-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-title-strong-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+}
+.hero.is-link.is-bold {
+  background-image: linear-gradient(141deg, hsl(calc(var(--bulma-hero-h) - 5deg), calc(var(--bulma-hero-s) + 10%), calc(var(--bulma-hero-background-l) + 5%)) 0%, hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l)) 71%, hsl(calc(var(--bulma-hero-h) + 5deg), calc(var(--bulma-hero-s) - 10%), calc(var(--bulma-hero-background-l) - 5%)) 100%);
+}
+@media screen and (max-width: 768px) {
+  .hero.is-link.is-bold .navbar-menu {
+    background-image: linear-gradient(141deg, hsl(calc(var(--bulma-hero-h) - 5deg), calc(var(--bulma-hero-s) + 10%), calc(var(--bulma-hero-background-l) + 5%)) 0%, hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l)) 71%, hsl(calc(var(--bulma-hero-h) + 5deg), calc(var(--bulma-hero-s) - 10%), calc(var(--bulma-hero-background-l) - 5%)) 100%);
+  }
+}
+.hero.is-info {
+  --bulma-hero-h: var(--bulma-info-h);
+  --bulma-hero-s: var(--bulma-info-s);
+  --bulma-hero-background-l: var(--bulma-info-l);
+  --bulma-hero-color-l: var(--bulma-info-invert-l);
+  background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+  color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+}
+.hero.is-info .navbar {
+  --bulma-navbar-item-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-navbar-item-hover-background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-navbar-item-hover-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+  --bulma-navbar-item-active-background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-navbar-item-active-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+}
+.hero.is-info .tabs {
+  --bulma-tabs-link-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-tabs-boxed-link-active-background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-tabs-boxed-link-active-border-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+  --bulma-tabs-link-active-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+}
+.hero.is-info .subtitle {
+  --bulma-subtitle-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-subtitle-strong-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+}
+.hero.is-info .title {
+  --bulma-title-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-title-strong-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+}
+.hero.is-info.is-bold {
+  background-image: linear-gradient(141deg, hsl(calc(var(--bulma-hero-h) - 5deg), calc(var(--bulma-hero-s) + 10%), calc(var(--bulma-hero-background-l) + 5%)) 0%, hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l)) 71%, hsl(calc(var(--bulma-hero-h) + 5deg), calc(var(--bulma-hero-s) - 10%), calc(var(--bulma-hero-background-l) - 5%)) 100%);
+}
+@media screen and (max-width: 768px) {
+  .hero.is-info.is-bold .navbar-menu {
+    background-image: linear-gradient(141deg, hsl(calc(var(--bulma-hero-h) - 5deg), calc(var(--bulma-hero-s) + 10%), calc(var(--bulma-hero-background-l) + 5%)) 0%, hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l)) 71%, hsl(calc(var(--bulma-hero-h) + 5deg), calc(var(--bulma-hero-s) - 10%), calc(var(--bulma-hero-background-l) - 5%)) 100%);
+  }
+}
+.hero.is-success {
+  --bulma-hero-h: var(--bulma-success-h);
+  --bulma-hero-s: var(--bulma-success-s);
+  --bulma-hero-background-l: var(--bulma-success-l);
+  --bulma-hero-color-l: var(--bulma-success-invert-l);
+  background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+  color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+}
+.hero.is-success .navbar {
+  --bulma-navbar-item-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-navbar-item-hover-background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-navbar-item-hover-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+  --bulma-navbar-item-active-background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-navbar-item-active-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+}
+.hero.is-success .tabs {
+  --bulma-tabs-link-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-tabs-boxed-link-active-background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-tabs-boxed-link-active-border-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+  --bulma-tabs-link-active-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+}
+.hero.is-success .subtitle {
+  --bulma-subtitle-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-subtitle-strong-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+}
+.hero.is-success .title {
+  --bulma-title-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-title-strong-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+}
+.hero.is-success.is-bold {
+  background-image: linear-gradient(141deg, hsl(calc(var(--bulma-hero-h) - 5deg), calc(var(--bulma-hero-s) + 10%), calc(var(--bulma-hero-background-l) + 5%)) 0%, hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l)) 71%, hsl(calc(var(--bulma-hero-h) + 5deg), calc(var(--bulma-hero-s) - 10%), calc(var(--bulma-hero-background-l) - 5%)) 100%);
+}
+@media screen and (max-width: 768px) {
+  .hero.is-success.is-bold .navbar-menu {
+    background-image: linear-gradient(141deg, hsl(calc(var(--bulma-hero-h) - 5deg), calc(var(--bulma-hero-s) + 10%), calc(var(--bulma-hero-background-l) + 5%)) 0%, hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l)) 71%, hsl(calc(var(--bulma-hero-h) + 5deg), calc(var(--bulma-hero-s) - 10%), calc(var(--bulma-hero-background-l) - 5%)) 100%);
+  }
+}
+.hero.is-warning {
+  --bulma-hero-h: var(--bulma-warning-h);
+  --bulma-hero-s: var(--bulma-warning-s);
+  --bulma-hero-background-l: var(--bulma-warning-l);
+  --bulma-hero-color-l: var(--bulma-warning-invert-l);
+  background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+  color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+}
+.hero.is-warning .navbar {
+  --bulma-navbar-item-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-navbar-item-hover-background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-navbar-item-hover-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+  --bulma-navbar-item-active-background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-navbar-item-active-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+}
+.hero.is-warning .tabs {
+  --bulma-tabs-link-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-tabs-boxed-link-active-background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-tabs-boxed-link-active-border-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+  --bulma-tabs-link-active-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+}
+.hero.is-warning .subtitle {
+  --bulma-subtitle-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-subtitle-strong-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+}
+.hero.is-warning .title {
+  --bulma-title-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-title-strong-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+}
+.hero.is-warning.is-bold {
+  background-image: linear-gradient(141deg, hsl(calc(var(--bulma-hero-h) - 5deg), calc(var(--bulma-hero-s) + 10%), calc(var(--bulma-hero-background-l) + 5%)) 0%, hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l)) 71%, hsl(calc(var(--bulma-hero-h) + 5deg), calc(var(--bulma-hero-s) - 10%), calc(var(--bulma-hero-background-l) - 5%)) 100%);
+}
+@media screen and (max-width: 768px) {
+  .hero.is-warning.is-bold .navbar-menu {
+    background-image: linear-gradient(141deg, hsl(calc(var(--bulma-hero-h) - 5deg), calc(var(--bulma-hero-s) + 10%), calc(var(--bulma-hero-background-l) + 5%)) 0%, hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l)) 71%, hsl(calc(var(--bulma-hero-h) + 5deg), calc(var(--bulma-hero-s) - 10%), calc(var(--bulma-hero-background-l) - 5%)) 100%);
+  }
+}
+.hero.is-danger {
+  --bulma-hero-h: var(--bulma-danger-h);
+  --bulma-hero-s: var(--bulma-danger-s);
+  --bulma-hero-background-l: var(--bulma-danger-l);
+  --bulma-hero-color-l: var(--bulma-danger-invert-l);
+  background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+  color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+}
+.hero.is-danger .navbar {
+  --bulma-navbar-item-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-navbar-item-hover-background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-navbar-item-hover-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+  --bulma-navbar-item-active-background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-navbar-item-active-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+}
+.hero.is-danger .tabs {
+  --bulma-tabs-link-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-tabs-boxed-link-active-background-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-tabs-boxed-link-active-border-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+  --bulma-tabs-link-active-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l));
+}
+.hero.is-danger .subtitle {
+  --bulma-subtitle-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-subtitle-strong-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+}
+.hero.is-danger .title {
+  --bulma-title-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+  --bulma-title-strong-color: hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l));
+}
+.hero.is-danger.is-bold {
+  background-image: linear-gradient(141deg, hsl(calc(var(--bulma-hero-h) - 5deg), calc(var(--bulma-hero-s) + 10%), calc(var(--bulma-hero-background-l) + 5%)) 0%, hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-background-l)) 71%, hsl(calc(var(--bulma-hero-h) + 5deg), calc(var(--bulma-hero-s) - 10%), calc(var(--bulma-hero-background-l) - 5%)) 100%);
+}
+@media screen and (max-width: 768px) {
+  .hero.is-danger.is-bold .navbar-menu {
+    background-image: linear-gradient(141deg, hsl(calc(var(--bulma-hero-h) - 5deg), calc(var(--bulma-hero-s) + 10%), calc(var(--bulma-hero-background-l) + 5%)) 0%, hsl(var(--bulma-hero-h), var(--bulma-hero-s), var(--bulma-hero-color-l)) 71%, hsl(calc(var(--bulma-hero-h) + 5deg), calc(var(--bulma-hero-s) - 10%), calc(var(--bulma-hero-background-l) - 5%)) 100%);
+  }
+}
+.hero.is-small .hero-body {
+  padding: var(--bulma-hero-body-padding-small);
+}
+@media screen and (min-width: 769px), print {
+  .hero.is-medium .hero-body {
+    padding: var(--bulma-hero-body-padding-medium);
+  }
+}
+@media screen and (min-width: 769px), print {
+  .hero.is-large .hero-body {
+    padding: var(--bulma-hero-body-padding-large);
+  }
+}
+.hero.is-halfheight .hero-body, .hero.is-fullheight .hero-body, .hero.is-fullheight-with-navbar .hero-body {
+  align-items: center;
+  display: flex;
+}
+.hero.is-halfheight .hero-body > .container, .hero.is-fullheight .hero-body > .container, .hero.is-fullheight-with-navbar .hero-body > .container {
+  flex-grow: 1;
+  flex-shrink: 1;
+}
+.hero.is-halfheight {
+  min-height: 50vh;
+}
+.hero.is-fullheight {
+  min-height: 100vh;
+}
+
+.hero-video {
+  overflow: hidden;
+}
+.hero-video video {
+  left: 50%;
+  min-height: 100%;
+  min-width: 100%;
+  position: absolute;
+  top: 50%;
+  transform: translate3d(-50%, -50%, 0);
+}
+.hero-video.is-transparent {
+  opacity: 0.3;
+}
+@media screen and (max-width: 768px) {
+  .hero-video {
+    display: none;
+  }
+}
+
+.hero-buttons {
+  margin-top: 1.5rem;
+}
+@media screen and (max-width: 768px) {
+  .hero-buttons .button {
+    display: flex;
+  }
+  .hero-buttons .button:not(:last-child) {
+    margin-bottom: 0.75rem;
+  }
+}
+@media screen and (min-width: 769px), print {
+  .hero-buttons {
+    display: flex;
+    justify-content: center;
+  }
+  .hero-buttons .button:not(:last-child) {
+    margin-inline-end: 1.5rem;
+  }
+}
+
+.hero-head,
+.hero-foot {
+  flex-grow: 0;
+  flex-shrink: 0;
+}
+
+.hero-body {
+  flex-grow: 1;
+  flex-shrink: 0;
+  padding: var(--bulma-hero-body-padding);
+}
+@media screen and (min-width: 769px), print {
+  .hero-body {
+    padding: var(--bulma-hero-body-padding-tablet);
+  }
+}
+
+.level {
+  --bulma-level-item-spacing: calc(var(--bulma-block-spacing) * 0.5);
+  align-items: center;
+  display: flex;
+  flex-direction: column;
+  justify-content: space-between;
+  gap: var(--bulma-level-item-spacing);
+}
+.level code {
+  border-radius: var(--bulma-radius);
+}
+.level img {
+  display: inline-block;
+  vertical-align: top;
+}
+.level.is-mobile {
+  display: flex;
+  flex-direction: row;
+}
+.level.is-mobile .level-left,
+.level.is-mobile .level-right {
+  display: flex;
+}
+.level.is-mobile .level-item:not(.is-narrow) {
+  flex-grow: 1;
+}
+@media screen and (min-width: 769px), print {
+  .level {
+    display: flex;
+    flex-direction: row;
+  }
+  .level > .level-item:not(.is-narrow) {
+    flex-grow: 1;
+  }
+}
+
+.level-item {
+  align-items: center;
+  display: flex;
+  flex-basis: auto;
+  flex-grow: 0;
+  flex-shrink: 0;
+  justify-content: center;
+}
+.level-item .title,
+.level-item .subtitle {
+  margin-bottom: 0;
+}
+
+.level-left,
+.level-right {
+  flex-basis: auto;
+  flex-grow: 0;
+  flex-shrink: 0;
+  gap: calc(var(--bulma-block-spacing) * 0.5);
+}
+.level-left .level-item.is-flexible,
+.level-right .level-item.is-flexible {
+  flex-grow: 1;
+}
+
+.level-left {
+  align-items: center;
+  display: flex;
+  flex-direction: column;
+  justify-content: flex-start;
+}
+@media screen and (min-width: 769px), print {
+  .level-left {
+    flex-direction: row;
+  }
+}
+
+.level-right {
+  align-items: center;
+  display: flex;
+  flex-direction: column;
+  justify-content: flex-end;
+}
+@media screen and (min-width: 769px), print {
+  .level-right {
+    flex-direction: row;
+  }
+}
+
+.media {
+  --bulma-media-border-color: hsla(var(--bulma-scheme-h), var(--bulma-scheme-s), var(--bulma-border-l), 0.5);
+  --bulma-media-border-size: 1px;
+  --bulma-media-spacing: 1rem;
+  --bulma-media-spacing-large: 1.5rem;
+  --bulma-media-content-spacing: 0.75rem;
+  --bulma-media-level-1-spacing: 0.75rem;
+  --bulma-media-level-1-content-spacing: 0.5rem;
+  --bulma-media-level-2-spacing: 0.5rem;
+  align-items: flex-start;
+  display: flex;
+  text-align: inherit;
+}
+.media .content:not(:last-child) {
+  margin-bottom: var(--bulma-media-content-spacing);
+}
+.media .media {
+  border-top-color: var(--bulma-media-border-color);
+  border-top-style: solid;
+  border-top-width: var(--bulma-media-border-size);
+  display: flex;
+  padding-top: var(--bulma-media-level-1-spacing);
+}
+.media .media .content:not(:last-child),
+.media .media .control:not(:last-child) {
+  margin-bottom: var(--bulma-media-level-1-content-spacing);
+}
+.media .media .media {
+  padding-top: var(--bulma-media-level-2-spacing);
+}
+.media .media .media + .media {
+  margin-top: var(--bulma-media-level-2-spacing);
+}
+.media + .media {
+  border-top-color: var(--bulma-media-border-color);
+  border-top-style: solid;
+  border-top-width: var(--bulma-media-border-size);
+  margin-top: var(--bulma-media-spacing);
+  padding-top: var(--bulma-media-spacing);
+}
+.media.is-large + .media {
+  margin-top: var(--bulma-media-spacing-large);
+  padding-top: var(--bulma-media-spacing-large);
+}
+
+.media-left,
+.media-right {
+  flex-basis: auto;
+  flex-grow: 0;
+  flex-shrink: 0;
+}
+
+.media-left {
+  margin-inline-end: var(--bulma-media-spacing);
+}
+
+.media-right {
+  margin-inline-start: var(--bulma-media-spacing);
+}
+
+.media-content {
+  flex-basis: auto;
+  flex-grow: 1;
+  flex-shrink: 1;
+  text-align: inherit;
+}
+
+@media screen and (max-width: 768px) {
+  .media-content {
+    overflow-x: auto;
+  }
+}
+.section {
+  --bulma-section-padding: 3rem 1.5rem;
+  --bulma-section-padding-desktop: 3rem 3rem;
+  --bulma-section-padding-medium: 9rem 4.5rem;
+  --bulma-section-padding-large: 18rem 6rem;
+  padding: var(--bulma-section-padding);
+}
+@media screen and (min-width: 1024px) {
+  .section {
+    padding: var(--bulma-section-padding-desktop);
+  }
+  .section.is-medium {
+    padding: var(--bulma-section-padding-medium);
+  }
+  .section.is-large {
+    padding: var(--bulma-section-padding-large);
+  }
+}
+.section.is-fullheight {
+  min-height: 100vh;
+}
+
+:root {
+  --bulma-skeleton-background: var(--bulma-border);
+  --bulma-skeleton-radius: var(--bulma-radius-small);
+  --bulma-skeleton-block-min-height: 4.5em;
+  --bulma-skeleton-lines-gap: 0.75em;
+  --bulma-skeleton-line-height: 0.75em;
+}
+
+.skeleton-lines > div, .skeleton-block, .has-skeleton::after, .is-skeleton {
+  animation-duration: 2s;
+  animation-iteration-count: infinite;
+  animation-name: pulsate;
+  animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
+  background-color: var(--bulma-skeleton-background);
+  border-radius: var(--bulma-skeleton-radius);
+  box-shadow: none;
+  pointer-events: none;
+}
+
+.is-skeleton {
+  color: transparent !important;
+}
+.is-skeleton em,
+.is-skeleton strong {
+  color: inherit;
+}
+.is-skeleton img {
+  visibility: hidden;
+}
+.is-skeleton.checkbox input {
+  opacity: 0;
+}
+.is-skeleton.delete {
+  border-radius: var(--bulma-radius-rounded);
+}
+.is-skeleton.delete::before, .is-skeleton.delete::after {
+  display: none;
+}
+
+input.is-skeleton,
+textarea.is-skeleton {
+  resize: none;
+}
+input.is-skeleton::-moz-placeholder,
+textarea.is-skeleton::-moz-placeholder {
+  color: transparent !important;
+}
+input.is-skeleton::-webkit-input-placeholder,
+textarea.is-skeleton::-webkit-input-placeholder {
+  color: transparent !important;
+}
+input.is-skeleton:-moz-placeholder,
+textarea.is-skeleton:-moz-placeholder {
+  color: transparent !important;
+}
+input.is-skeleton:-ms-input-placeholder,
+textarea.is-skeleton:-ms-input-placeholder {
+  color: transparent !important;
+}
+
+.has-skeleton {
+  color: transparent !important;
+  position: relative;
+}
+.has-skeleton::after {
+  content: "";
+  display: block;
+  height: 100%;
+  left: 0;
+  max-width: 100%;
+  min-width: 10%;
+  position: absolute;
+  top: 0;
+  width: 7em;
+}
+
+.skeleton-block {
+  color: transparent !important;
+  min-height: var(--bulma-skeleton-block-min-height);
+}
+
+.skeleton-lines {
+  color: transparent !important;
+  display: flex;
+  flex-direction: column;
+  gap: var(--bulma-skeleton-lines-gap);
+  position: relative;
+}
+.skeleton-lines > div {
+  height: var(--bulma-skeleton-line-height);
+}
+.skeleton-lines > div:last-child {
+  min-width: 4em;
+  width: 30%;
+}
+
+/* Bulma Helpers */
+.is-aspect-ratio-1by1 {
+  aspect-ratio: 1/1;
+}
+
+.is-aspect-ratio-5by4 {
+  aspect-ratio: 5/4;
+}
+
+.is-aspect-ratio-4by3 {
+  aspect-ratio: 4/3;
+}
+
+.is-aspect-ratio-3by2 {
+  aspect-ratio: 3/2;
+}
+
+.is-aspect-ratio-5by3 {
+  aspect-ratio: 5/3;
+}
+
+.is-aspect-ratio-16by9 {
+  aspect-ratio: 16/9;
+}
+
+.is-aspect-ratio-2by1 {
+  aspect-ratio: 2/1;
+}
+
+.is-aspect-ratio-3by1 {
+  aspect-ratio: 3/1;
+}
+
+.is-aspect-ratio-4by5 {
+  aspect-ratio: 4/5;
+}
+
+.is-aspect-ratio-3by4 {
+  aspect-ratio: 3/4;
+}
+
+.is-aspect-ratio-2by3 {
+  aspect-ratio: 2/3;
+}
+
+.is-aspect-ratio-3by5 {
+  aspect-ratio: 3/5;
+}
+
+.is-aspect-ratio-9by16 {
+  aspect-ratio: 9/16;
+}
+
+.is-aspect-ratio-1by2 {
+  aspect-ratio: 1/2;
+}
+
+.is-aspect-ratio-1by3 {
+  aspect-ratio: 1/3;
+}
+
+.has-radius-small {
+  border-radius: var(--bulma-radius-small);
+}
+
+.has-radius-normal {
+  border-radius: var(--bulma-radius);
+}
+
+.has-radius-large {
+  border-radius: var(--bulma-radius-large);
+}
+
+.has-radius-rounded {
+  border-radius: var(--bulma-radius-rounded);
+}
+
+.has-background {
+  background-color: var(--bulma-background);
+}
+
+.has-text-white {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-l)) !important;
+}
+
+.has-background-white {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-l)) !important;
+}
+
+.has-text-white-invert {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-invert-l)) !important;
+}
+
+.has-background-white-invert {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-invert-l)) !important;
+}
+
+.has-text-white-on-scheme {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-on-scheme-l)) !important;
+}
+
+.has-background-white-on-scheme {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-on-scheme-l)) !important;
+}
+
+.has-text-white-light {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-light-l)) !important;
+}
+
+.has-background-white-light {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-light-l)) !important;
+}
+
+.has-text-white-light-invert {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-light-invert-l)) !important;
+}
+
+.has-background-white-light-invert {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-light-invert-l)) !important;
+}
+
+.has-text-white-dark {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-dark-l)) !important;
+}
+
+.has-background-white-dark {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-dark-l)) !important;
+}
+
+.has-text-white-dark-invert {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-dark-invert-l)) !important;
+}
+
+.has-background-white-dark-invert {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-dark-invert-l)) !important;
+}
+
+.has-text-white-soft {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-soft-l)) !important;
+}
+
+.has-background-white-soft {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-soft-l)) !important;
+}
+
+.has-text-white-bold {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-bold-l)) !important;
+}
+
+.has-background-white-bold {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-bold-l)) !important;
+}
+
+.has-text-white-soft-invert {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-soft-invert-l)) !important;
+}
+
+.has-background-white-soft-invert {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-soft-invert-l)) !important;
+}
+
+.has-text-white-bold-invert {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-bold-invert-l)) !important;
+}
+
+.has-background-white-bold-invert {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-bold-invert-l)) !important;
+}
+
+.has-text-white-00 {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-00-l)) !important;
+}
+
+.has-background-white-00 {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-00-l)) !important;
+}
+
+.has-text-white-00-invert {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-00-invert-l)) !important;
+}
+
+.has-background-white-00-invert {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-00-invert-l)) !important;
+}
+
+.has-text-white-05 {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-05-l)) !important;
+}
+
+.has-background-white-05 {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-05-l)) !important;
+}
+
+.has-text-white-05-invert {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-05-invert-l)) !important;
+}
+
+.has-background-white-05-invert {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-05-invert-l)) !important;
+}
+
+.has-text-white-10 {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-10-l)) !important;
+}
+
+.has-background-white-10 {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-10-l)) !important;
+}
+
+.has-text-white-10-invert {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-10-invert-l)) !important;
+}
+
+.has-background-white-10-invert {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-10-invert-l)) !important;
+}
+
+.has-text-white-15 {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-15-l)) !important;
+}
+
+.has-background-white-15 {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-15-l)) !important;
+}
+
+.has-text-white-15-invert {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-15-invert-l)) !important;
+}
+
+.has-background-white-15-invert {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-15-invert-l)) !important;
+}
+
+.has-text-white-20 {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-20-l)) !important;
+}
+
+.has-background-white-20 {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-20-l)) !important;
+}
+
+.has-text-white-20-invert {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-20-invert-l)) !important;
+}
+
+.has-background-white-20-invert {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-20-invert-l)) !important;
+}
+
+.has-text-white-25 {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-25-l)) !important;
+}
+
+.has-background-white-25 {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-25-l)) !important;
+}
+
+.has-text-white-25-invert {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-25-invert-l)) !important;
+}
+
+.has-background-white-25-invert {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-25-invert-l)) !important;
+}
+
+.has-text-white-30 {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-30-l)) !important;
+}
+
+.has-background-white-30 {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-30-l)) !important;
+}
+
+.has-text-white-30-invert {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-30-invert-l)) !important;
+}
+
+.has-background-white-30-invert {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-30-invert-l)) !important;
+}
+
+.has-text-white-35 {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-35-l)) !important;
+}
+
+.has-background-white-35 {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-35-l)) !important;
+}
+
+.has-text-white-35-invert {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-35-invert-l)) !important;
+}
+
+.has-background-white-35-invert {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-35-invert-l)) !important;
+}
+
+.has-text-white-40 {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-40-l)) !important;
+}
+
+.has-background-white-40 {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-40-l)) !important;
+}
+
+.has-text-white-40-invert {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-40-invert-l)) !important;
+}
+
+.has-background-white-40-invert {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-40-invert-l)) !important;
+}
+
+.has-text-white-45 {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-45-l)) !important;
+}
+
+.has-background-white-45 {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-45-l)) !important;
+}
+
+.has-text-white-45-invert {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-45-invert-l)) !important;
+}
+
+.has-background-white-45-invert {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-45-invert-l)) !important;
+}
+
+.has-text-white-50 {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-50-l)) !important;
+}
+
+.has-background-white-50 {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-50-l)) !important;
+}
+
+.has-text-white-50-invert {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-50-invert-l)) !important;
+}
+
+.has-background-white-50-invert {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-50-invert-l)) !important;
+}
+
+.has-text-white-55 {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-55-l)) !important;
+}
+
+.has-background-white-55 {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-55-l)) !important;
+}
+
+.has-text-white-55-invert {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-55-invert-l)) !important;
+}
+
+.has-background-white-55-invert {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-55-invert-l)) !important;
+}
+
+.has-text-white-60 {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-60-l)) !important;
+}
+
+.has-background-white-60 {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-60-l)) !important;
+}
+
+.has-text-white-60-invert {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-60-invert-l)) !important;
+}
+
+.has-background-white-60-invert {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-60-invert-l)) !important;
+}
+
+.has-text-white-65 {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-65-l)) !important;
+}
+
+.has-background-white-65 {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-65-l)) !important;
+}
+
+.has-text-white-65-invert {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-65-invert-l)) !important;
+}
+
+.has-background-white-65-invert {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-65-invert-l)) !important;
+}
+
+.has-text-white-70 {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-70-l)) !important;
+}
+
+.has-background-white-70 {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-70-l)) !important;
+}
+
+.has-text-white-70-invert {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-70-invert-l)) !important;
+}
+
+.has-background-white-70-invert {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-70-invert-l)) !important;
+}
+
+.has-text-white-75 {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-75-l)) !important;
+}
+
+.has-background-white-75 {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-75-l)) !important;
+}
+
+.has-text-white-75-invert {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-75-invert-l)) !important;
+}
+
+.has-background-white-75-invert {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-75-invert-l)) !important;
+}
+
+.has-text-white-80 {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-80-l)) !important;
+}
+
+.has-background-white-80 {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-80-l)) !important;
+}
+
+.has-text-white-80-invert {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-80-invert-l)) !important;
+}
+
+.has-background-white-80-invert {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-80-invert-l)) !important;
+}
+
+.has-text-white-85 {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-85-l)) !important;
+}
+
+.has-background-white-85 {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-85-l)) !important;
+}
+
+.has-text-white-85-invert {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-85-invert-l)) !important;
+}
+
+.has-background-white-85-invert {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-85-invert-l)) !important;
+}
+
+.has-text-white-90 {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-90-l)) !important;
+}
+
+.has-background-white-90 {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-90-l)) !important;
+}
+
+.has-text-white-90-invert {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-90-invert-l)) !important;
+}
+
+.has-background-white-90-invert {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-90-invert-l)) !important;
+}
+
+.has-text-white-95 {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-95-l)) !important;
+}
+
+.has-background-white-95 {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-95-l)) !important;
+}
+
+.has-text-white-95-invert {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-95-invert-l)) !important;
+}
+
+.has-background-white-95-invert {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-95-invert-l)) !important;
+}
+
+.has-text-white-100 {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-100-l)) !important;
+}
+
+.has-background-white-100 {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-100-l)) !important;
+}
+
+.has-text-white-100-invert {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-100-invert-l)) !important;
+}
+
+.has-background-white-100-invert {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), var(--bulma-white-100-invert-l)) !important;
+}
+
+a.has-text-white:hover, a.has-text-white:focus-visible,
+button.has-text-white:hover,
+button.has-text-white:focus-visible,
+has-text-white.is-hoverable:hover,
+has-text-white.is-hoverable:focus-visible {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), calc(var(--bulma-white-l) + var(--bulma-hover-color-l-delta))) !important;
+}
+a.has-text-white:active,
+button.has-text-white:active,
+has-text-white.is-hoverable:active {
+  color: hsl(var(--bulma-white-h), var(--bulma-white-s), calc(var(--bulma-white-l) + var(--bulma-active-color-l-delta))) !important;
+}
+
+a.has-background-white:hover, a.has-background-white:focus-visible,
+button.has-background-white:hover,
+button.has-background-white:focus-visible,
+has-background-white.is-hoverable:hover,
+has-background-white.is-hoverable:focus-visible {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), calc(var(--bulma-white-l) + var(--bulma-hover-background-l-delta))) !important;
+}
+a.has-background-white:active,
+button.has-background-white:active,
+has-background-white.is-hoverable:active {
+  background-color: hsl(var(--bulma-white-h), var(--bulma-white-s), calc(var(--bulma-white-l) + var(--bulma-active-background-l-delta))) !important;
+}
+
+.is-palette-white {
+  --h: var(--bulma-white-h);
+  --s: var(--bulma-white-s);
+  --l: var(--bulma-white-l);
+  --color: hsl(var(--h), var(--s), var(--l));
+  --00-l: var(--bulma-white-00-l);
+  --color-00: hsl(var(--h), var(--s), var(--00-l));
+  --05-l: var(--bulma-white-05-l);
+  --color-05: hsl(var(--h), var(--s), var(--05-l));
+  --10-l: var(--bulma-white-10-l);
+  --color-10: hsl(var(--h), var(--s), var(--10-l));
+  --15-l: var(--bulma-white-15-l);
+  --color-15: hsl(var(--h), var(--s), var(--15-l));
+  --20-l: var(--bulma-white-20-l);
+  --color-20: hsl(var(--h), var(--s), var(--20-l));
+  --25-l: var(--bulma-white-25-l);
+  --color-25: hsl(var(--h), var(--s), var(--25-l));
+  --30-l: var(--bulma-white-30-l);
+  --color-30: hsl(var(--h), var(--s), var(--30-l));
+  --35-l: var(--bulma-white-35-l);
+  --color-35: hsl(var(--h), var(--s), var(--35-l));
+  --40-l: var(--bulma-white-40-l);
+  --color-40: hsl(var(--h), var(--s), var(--40-l));
+  --45-l: var(--bulma-white-45-l);
+  --color-45: hsl(var(--h), var(--s), var(--45-l));
+  --50-l: var(--bulma-white-50-l);
+  --color-50: hsl(var(--h), var(--s), var(--50-l));
+  --55-l: var(--bulma-white-55-l);
+  --color-55: hsl(var(--h), var(--s), var(--55-l));
+  --60-l: var(--bulma-white-60-l);
+  --color-60: hsl(var(--h), var(--s), var(--60-l));
+  --65-l: var(--bulma-white-65-l);
+  --color-65: hsl(var(--h), var(--s), var(--65-l));
+  --70-l: var(--bulma-white-70-l);
+  --color-70: hsl(var(--h), var(--s), var(--70-l));
+  --75-l: var(--bulma-white-75-l);
+  --color-75: hsl(var(--h), var(--s), var(--75-l));
+  --80-l: var(--bulma-white-80-l);
+  --color-80: hsl(var(--h), var(--s), var(--80-l));
+  --85-l: var(--bulma-white-85-l);
+  --color-85: hsl(var(--h), var(--s), var(--85-l));
+  --90-l: var(--bulma-white-90-l);
+  --color-90: hsl(var(--h), var(--s), var(--90-l));
+  --95-l: var(--bulma-white-95-l);
+  --color-95: hsl(var(--h), var(--s), var(--95-l));
+  --100-l: var(--bulma-white-100-l);
+  --color-100: hsl(var(--h), var(--s), var(--100-l));
+}
+
+.has-text-black {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-l)) !important;
+}
+
+.has-background-black {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-l)) !important;
+}
+
+.has-text-black-invert {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-invert-l)) !important;
+}
+
+.has-background-black-invert {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-invert-l)) !important;
+}
+
+.has-text-black-on-scheme {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-on-scheme-l)) !important;
+}
+
+.has-background-black-on-scheme {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-on-scheme-l)) !important;
+}
+
+.has-text-black-light {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-light-l)) !important;
+}
+
+.has-background-black-light {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-light-l)) !important;
+}
+
+.has-text-black-light-invert {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-light-invert-l)) !important;
+}
+
+.has-background-black-light-invert {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-light-invert-l)) !important;
+}
+
+.has-text-black-dark {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-dark-l)) !important;
+}
+
+.has-background-black-dark {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-dark-l)) !important;
+}
+
+.has-text-black-dark-invert {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-dark-invert-l)) !important;
+}
+
+.has-background-black-dark-invert {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-dark-invert-l)) !important;
+}
+
+.has-text-black-soft {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-soft-l)) !important;
+}
+
+.has-background-black-soft {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-soft-l)) !important;
+}
+
+.has-text-black-bold {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-bold-l)) !important;
+}
+
+.has-background-black-bold {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-bold-l)) !important;
+}
+
+.has-text-black-soft-invert {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-soft-invert-l)) !important;
+}
+
+.has-background-black-soft-invert {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-soft-invert-l)) !important;
+}
+
+.has-text-black-bold-invert {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-bold-invert-l)) !important;
+}
+
+.has-background-black-bold-invert {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-bold-invert-l)) !important;
+}
+
+.has-text-black-00 {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-00-l)) !important;
+}
+
+.has-background-black-00 {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-00-l)) !important;
+}
+
+.has-text-black-00-invert {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-00-invert-l)) !important;
+}
+
+.has-background-black-00-invert {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-00-invert-l)) !important;
+}
+
+.has-text-black-05 {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-05-l)) !important;
+}
+
+.has-background-black-05 {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-05-l)) !important;
+}
+
+.has-text-black-05-invert {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-05-invert-l)) !important;
+}
+
+.has-background-black-05-invert {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-05-invert-l)) !important;
+}
+
+.has-text-black-10 {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-10-l)) !important;
+}
+
+.has-background-black-10 {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-10-l)) !important;
+}
+
+.has-text-black-10-invert {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-10-invert-l)) !important;
+}
+
+.has-background-black-10-invert {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-10-invert-l)) !important;
+}
+
+.has-text-black-15 {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-15-l)) !important;
+}
+
+.has-background-black-15 {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-15-l)) !important;
+}
+
+.has-text-black-15-invert {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-15-invert-l)) !important;
+}
+
+.has-background-black-15-invert {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-15-invert-l)) !important;
+}
+
+.has-text-black-20 {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-20-l)) !important;
+}
+
+.has-background-black-20 {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-20-l)) !important;
+}
+
+.has-text-black-20-invert {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-20-invert-l)) !important;
+}
+
+.has-background-black-20-invert {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-20-invert-l)) !important;
+}
+
+.has-text-black-25 {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-25-l)) !important;
+}
+
+.has-background-black-25 {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-25-l)) !important;
+}
+
+.has-text-black-25-invert {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-25-invert-l)) !important;
+}
+
+.has-background-black-25-invert {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-25-invert-l)) !important;
+}
+
+.has-text-black-30 {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-30-l)) !important;
+}
+
+.has-background-black-30 {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-30-l)) !important;
+}
+
+.has-text-black-30-invert {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-30-invert-l)) !important;
+}
+
+.has-background-black-30-invert {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-30-invert-l)) !important;
+}
+
+.has-text-black-35 {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-35-l)) !important;
+}
+
+.has-background-black-35 {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-35-l)) !important;
+}
+
+.has-text-black-35-invert {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-35-invert-l)) !important;
+}
+
+.has-background-black-35-invert {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-35-invert-l)) !important;
+}
+
+.has-text-black-40 {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-40-l)) !important;
+}
+
+.has-background-black-40 {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-40-l)) !important;
+}
+
+.has-text-black-40-invert {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-40-invert-l)) !important;
+}
+
+.has-background-black-40-invert {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-40-invert-l)) !important;
+}
+
+.has-text-black-45 {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-45-l)) !important;
+}
+
+.has-background-black-45 {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-45-l)) !important;
+}
+
+.has-text-black-45-invert {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-45-invert-l)) !important;
+}
+
+.has-background-black-45-invert {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-45-invert-l)) !important;
+}
+
+.has-text-black-50 {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-50-l)) !important;
+}
+
+.has-background-black-50 {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-50-l)) !important;
+}
+
+.has-text-black-50-invert {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-50-invert-l)) !important;
+}
+
+.has-background-black-50-invert {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-50-invert-l)) !important;
+}
+
+.has-text-black-55 {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-55-l)) !important;
+}
+
+.has-background-black-55 {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-55-l)) !important;
+}
+
+.has-text-black-55-invert {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-55-invert-l)) !important;
+}
+
+.has-background-black-55-invert {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-55-invert-l)) !important;
+}
+
+.has-text-black-60 {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-60-l)) !important;
+}
+
+.has-background-black-60 {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-60-l)) !important;
+}
+
+.has-text-black-60-invert {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-60-invert-l)) !important;
+}
+
+.has-background-black-60-invert {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-60-invert-l)) !important;
+}
+
+.has-text-black-65 {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-65-l)) !important;
+}
+
+.has-background-black-65 {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-65-l)) !important;
+}
+
+.has-text-black-65-invert {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-65-invert-l)) !important;
+}
+
+.has-background-black-65-invert {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-65-invert-l)) !important;
+}
+
+.has-text-black-70 {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-70-l)) !important;
+}
+
+.has-background-black-70 {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-70-l)) !important;
+}
+
+.has-text-black-70-invert {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-70-invert-l)) !important;
+}
+
+.has-background-black-70-invert {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-70-invert-l)) !important;
+}
+
+.has-text-black-75 {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-75-l)) !important;
+}
+
+.has-background-black-75 {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-75-l)) !important;
+}
+
+.has-text-black-75-invert {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-75-invert-l)) !important;
+}
+
+.has-background-black-75-invert {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-75-invert-l)) !important;
+}
+
+.has-text-black-80 {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-80-l)) !important;
+}
+
+.has-background-black-80 {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-80-l)) !important;
+}
+
+.has-text-black-80-invert {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-80-invert-l)) !important;
+}
+
+.has-background-black-80-invert {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-80-invert-l)) !important;
+}
+
+.has-text-black-85 {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-85-l)) !important;
+}
+
+.has-background-black-85 {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-85-l)) !important;
+}
+
+.has-text-black-85-invert {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-85-invert-l)) !important;
+}
+
+.has-background-black-85-invert {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-85-invert-l)) !important;
+}
+
+.has-text-black-90 {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-90-l)) !important;
+}
+
+.has-background-black-90 {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-90-l)) !important;
+}
+
+.has-text-black-90-invert {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-90-invert-l)) !important;
+}
+
+.has-background-black-90-invert {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-90-invert-l)) !important;
+}
+
+.has-text-black-95 {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-95-l)) !important;
+}
+
+.has-background-black-95 {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-95-l)) !important;
+}
+
+.has-text-black-95-invert {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-95-invert-l)) !important;
+}
+
+.has-background-black-95-invert {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-95-invert-l)) !important;
+}
+
+.has-text-black-100 {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-100-l)) !important;
+}
+
+.has-background-black-100 {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-100-l)) !important;
+}
+
+.has-text-black-100-invert {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-100-invert-l)) !important;
+}
+
+.has-background-black-100-invert {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), var(--bulma-black-100-invert-l)) !important;
+}
+
+a.has-text-black:hover, a.has-text-black:focus-visible,
+button.has-text-black:hover,
+button.has-text-black:focus-visible,
+has-text-black.is-hoverable:hover,
+has-text-black.is-hoverable:focus-visible {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), calc(var(--bulma-black-l) + var(--bulma-hover-color-l-delta))) !important;
+}
+a.has-text-black:active,
+button.has-text-black:active,
+has-text-black.is-hoverable:active {
+  color: hsl(var(--bulma-black-h), var(--bulma-black-s), calc(var(--bulma-black-l) + var(--bulma-active-color-l-delta))) !important;
+}
+
+a.has-background-black:hover, a.has-background-black:focus-visible,
+button.has-background-black:hover,
+button.has-background-black:focus-visible,
+has-background-black.is-hoverable:hover,
+has-background-black.is-hoverable:focus-visible {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), calc(var(--bulma-black-l) + var(--bulma-hover-background-l-delta))) !important;
+}
+a.has-background-black:active,
+button.has-background-black:active,
+has-background-black.is-hoverable:active {
+  background-color: hsl(var(--bulma-black-h), var(--bulma-black-s), calc(var(--bulma-black-l) + var(--bulma-active-background-l-delta))) !important;
+}
+
+.is-palette-black {
+  --h: var(--bulma-black-h);
+  --s: var(--bulma-black-s);
+  --l: var(--bulma-black-l);
+  --color: hsl(var(--h), var(--s), var(--l));
+  --00-l: var(--bulma-black-00-l);
+  --color-00: hsl(var(--h), var(--s), var(--00-l));
+  --05-l: var(--bulma-black-05-l);
+  --color-05: hsl(var(--h), var(--s), var(--05-l));
+  --10-l: var(--bulma-black-10-l);
+  --color-10: hsl(var(--h), var(--s), var(--10-l));
+  --15-l: var(--bulma-black-15-l);
+  --color-15: hsl(var(--h), var(--s), var(--15-l));
+  --20-l: var(--bulma-black-20-l);
+  --color-20: hsl(var(--h), var(--s), var(--20-l));
+  --25-l: var(--bulma-black-25-l);
+  --color-25: hsl(var(--h), var(--s), var(--25-l));
+  --30-l: var(--bulma-black-30-l);
+  --color-30: hsl(var(--h), var(--s), var(--30-l));
+  --35-l: var(--bulma-black-35-l);
+  --color-35: hsl(var(--h), var(--s), var(--35-l));
+  --40-l: var(--bulma-black-40-l);
+  --color-40: hsl(var(--h), var(--s), var(--40-l));
+  --45-l: var(--bulma-black-45-l);
+  --color-45: hsl(var(--h), var(--s), var(--45-l));
+  --50-l: var(--bulma-black-50-l);
+  --color-50: hsl(var(--h), var(--s), var(--50-l));
+  --55-l: var(--bulma-black-55-l);
+  --color-55: hsl(var(--h), var(--s), var(--55-l));
+  --60-l: var(--bulma-black-60-l);
+  --color-60: hsl(var(--h), var(--s), var(--60-l));
+  --65-l: var(--bulma-black-65-l);
+  --color-65: hsl(var(--h), var(--s), var(--65-l));
+  --70-l: var(--bulma-black-70-l);
+  --color-70: hsl(var(--h), var(--s), var(--70-l));
+  --75-l: var(--bulma-black-75-l);
+  --color-75: hsl(var(--h), var(--s), var(--75-l));
+  --80-l: var(--bulma-black-80-l);
+  --color-80: hsl(var(--h), var(--s), var(--80-l));
+  --85-l: var(--bulma-black-85-l);
+  --color-85: hsl(var(--h), var(--s), var(--85-l));
+  --90-l: var(--bulma-black-90-l);
+  --color-90: hsl(var(--h), var(--s), var(--90-l));
+  --95-l: var(--bulma-black-95-l);
+  --color-95: hsl(var(--h), var(--s), var(--95-l));
+  --100-l: var(--bulma-black-100-l);
+  --color-100: hsl(var(--h), var(--s), var(--100-l));
+}
+
+.has-text-light {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-l)) !important;
+}
+
+.has-background-light {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-l)) !important;
+}
+
+.has-text-light-invert {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-invert-l)) !important;
+}
+
+.has-background-light-invert {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-invert-l)) !important;
+}
+
+.has-text-light-on-scheme {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-on-scheme-l)) !important;
+}
+
+.has-background-light-on-scheme {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-on-scheme-l)) !important;
+}
+
+.has-text-light-light {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-light-l)) !important;
+}
+
+.has-background-light-light {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-light-l)) !important;
+}
+
+.has-text-light-light-invert {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-light-invert-l)) !important;
+}
+
+.has-background-light-light-invert {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-light-invert-l)) !important;
+}
+
+.has-text-light-dark {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-dark-l)) !important;
+}
+
+.has-background-light-dark {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-dark-l)) !important;
+}
+
+.has-text-light-dark-invert {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-dark-invert-l)) !important;
+}
+
+.has-background-light-dark-invert {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-dark-invert-l)) !important;
+}
+
+.has-text-light-soft {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-soft-l)) !important;
+}
+
+.has-background-light-soft {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-soft-l)) !important;
+}
+
+.has-text-light-bold {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-bold-l)) !important;
+}
+
+.has-background-light-bold {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-bold-l)) !important;
+}
+
+.has-text-light-soft-invert {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-soft-invert-l)) !important;
+}
+
+.has-background-light-soft-invert {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-soft-invert-l)) !important;
+}
+
+.has-text-light-bold-invert {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-bold-invert-l)) !important;
+}
+
+.has-background-light-bold-invert {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-bold-invert-l)) !important;
+}
+
+.has-text-light-00 {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-00-l)) !important;
+}
+
+.has-background-light-00 {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-00-l)) !important;
+}
+
+.has-text-light-00-invert {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-00-invert-l)) !important;
+}
+
+.has-background-light-00-invert {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-00-invert-l)) !important;
+}
+
+.has-text-light-05 {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-05-l)) !important;
+}
+
+.has-background-light-05 {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-05-l)) !important;
+}
+
+.has-text-light-05-invert {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-05-invert-l)) !important;
+}
+
+.has-background-light-05-invert {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-05-invert-l)) !important;
+}
+
+.has-text-light-10 {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-10-l)) !important;
+}
+
+.has-background-light-10 {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-10-l)) !important;
+}
+
+.has-text-light-10-invert {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-10-invert-l)) !important;
+}
+
+.has-background-light-10-invert {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-10-invert-l)) !important;
+}
+
+.has-text-light-15 {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-15-l)) !important;
+}
+
+.has-background-light-15 {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-15-l)) !important;
+}
+
+.has-text-light-15-invert {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-15-invert-l)) !important;
+}
+
+.has-background-light-15-invert {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-15-invert-l)) !important;
+}
+
+.has-text-light-20 {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-20-l)) !important;
+}
+
+.has-background-light-20 {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-20-l)) !important;
+}
+
+.has-text-light-20-invert {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-20-invert-l)) !important;
+}
+
+.has-background-light-20-invert {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-20-invert-l)) !important;
+}
+
+.has-text-light-25 {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-25-l)) !important;
+}
+
+.has-background-light-25 {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-25-l)) !important;
+}
+
+.has-text-light-25-invert {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-25-invert-l)) !important;
+}
+
+.has-background-light-25-invert {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-25-invert-l)) !important;
+}
+
+.has-text-light-30 {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-30-l)) !important;
+}
+
+.has-background-light-30 {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-30-l)) !important;
+}
+
+.has-text-light-30-invert {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-30-invert-l)) !important;
+}
+
+.has-background-light-30-invert {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-30-invert-l)) !important;
+}
+
+.has-text-light-35 {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-35-l)) !important;
+}
+
+.has-background-light-35 {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-35-l)) !important;
+}
+
+.has-text-light-35-invert {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-35-invert-l)) !important;
+}
+
+.has-background-light-35-invert {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-35-invert-l)) !important;
+}
+
+.has-text-light-40 {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-40-l)) !important;
+}
+
+.has-background-light-40 {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-40-l)) !important;
+}
+
+.has-text-light-40-invert {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-40-invert-l)) !important;
+}
+
+.has-background-light-40-invert {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-40-invert-l)) !important;
+}
+
+.has-text-light-45 {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-45-l)) !important;
+}
+
+.has-background-light-45 {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-45-l)) !important;
+}
+
+.has-text-light-45-invert {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-45-invert-l)) !important;
+}
+
+.has-background-light-45-invert {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-45-invert-l)) !important;
+}
+
+.has-text-light-50 {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-50-l)) !important;
+}
+
+.has-background-light-50 {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-50-l)) !important;
+}
+
+.has-text-light-50-invert {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-50-invert-l)) !important;
+}
+
+.has-background-light-50-invert {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-50-invert-l)) !important;
+}
+
+.has-text-light-55 {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-55-l)) !important;
+}
+
+.has-background-light-55 {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-55-l)) !important;
+}
+
+.has-text-light-55-invert {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-55-invert-l)) !important;
+}
+
+.has-background-light-55-invert {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-55-invert-l)) !important;
+}
+
+.has-text-light-60 {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-60-l)) !important;
+}
+
+.has-background-light-60 {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-60-l)) !important;
+}
+
+.has-text-light-60-invert {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-60-invert-l)) !important;
+}
+
+.has-background-light-60-invert {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-60-invert-l)) !important;
+}
+
+.has-text-light-65 {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-65-l)) !important;
+}
+
+.has-background-light-65 {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-65-l)) !important;
+}
+
+.has-text-light-65-invert {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-65-invert-l)) !important;
+}
+
+.has-background-light-65-invert {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-65-invert-l)) !important;
+}
+
+.has-text-light-70 {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-70-l)) !important;
+}
+
+.has-background-light-70 {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-70-l)) !important;
+}
+
+.has-text-light-70-invert {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-70-invert-l)) !important;
+}
+
+.has-background-light-70-invert {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-70-invert-l)) !important;
+}
+
+.has-text-light-75 {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-75-l)) !important;
+}
+
+.has-background-light-75 {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-75-l)) !important;
+}
+
+.has-text-light-75-invert {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-75-invert-l)) !important;
+}
+
+.has-background-light-75-invert {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-75-invert-l)) !important;
+}
+
+.has-text-light-80 {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-80-l)) !important;
+}
+
+.has-background-light-80 {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-80-l)) !important;
+}
+
+.has-text-light-80-invert {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-80-invert-l)) !important;
+}
+
+.has-background-light-80-invert {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-80-invert-l)) !important;
+}
+
+.has-text-light-85 {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-85-l)) !important;
+}
+
+.has-background-light-85 {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-85-l)) !important;
+}
+
+.has-text-light-85-invert {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-85-invert-l)) !important;
+}
+
+.has-background-light-85-invert {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-85-invert-l)) !important;
+}
+
+.has-text-light-90 {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-90-l)) !important;
+}
+
+.has-background-light-90 {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-90-l)) !important;
+}
+
+.has-text-light-90-invert {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-90-invert-l)) !important;
+}
+
+.has-background-light-90-invert {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-90-invert-l)) !important;
+}
+
+.has-text-light-95 {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-95-l)) !important;
+}
+
+.has-background-light-95 {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-95-l)) !important;
+}
+
+.has-text-light-95-invert {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-95-invert-l)) !important;
+}
+
+.has-background-light-95-invert {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-95-invert-l)) !important;
+}
+
+.has-text-light-100 {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-100-l)) !important;
+}
+
+.has-background-light-100 {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-100-l)) !important;
+}
+
+.has-text-light-100-invert {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-100-invert-l)) !important;
+}
+
+.has-background-light-100-invert {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), var(--bulma-light-100-invert-l)) !important;
+}
+
+a.has-text-light:hover, a.has-text-light:focus-visible,
+button.has-text-light:hover,
+button.has-text-light:focus-visible,
+has-text-light.is-hoverable:hover,
+has-text-light.is-hoverable:focus-visible {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), calc(var(--bulma-light-l) + var(--bulma-hover-color-l-delta))) !important;
+}
+a.has-text-light:active,
+button.has-text-light:active,
+has-text-light.is-hoverable:active {
+  color: hsl(var(--bulma-light-h), var(--bulma-light-s), calc(var(--bulma-light-l) + var(--bulma-active-color-l-delta))) !important;
+}
+
+a.has-background-light:hover, a.has-background-light:focus-visible,
+button.has-background-light:hover,
+button.has-background-light:focus-visible,
+has-background-light.is-hoverable:hover,
+has-background-light.is-hoverable:focus-visible {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), calc(var(--bulma-light-l) + var(--bulma-hover-background-l-delta))) !important;
+}
+a.has-background-light:active,
+button.has-background-light:active,
+has-background-light.is-hoverable:active {
+  background-color: hsl(var(--bulma-light-h), var(--bulma-light-s), calc(var(--bulma-light-l) + var(--bulma-active-background-l-delta))) !important;
+}
+
+.is-palette-light {
+  --h: var(--bulma-light-h);
+  --s: var(--bulma-light-s);
+  --l: var(--bulma-light-l);
+  --color: hsl(var(--h), var(--s), var(--l));
+  --00-l: var(--bulma-light-00-l);
+  --color-00: hsl(var(--h), var(--s), var(--00-l));
+  --05-l: var(--bulma-light-05-l);
+  --color-05: hsl(var(--h), var(--s), var(--05-l));
+  --10-l: var(--bulma-light-10-l);
+  --color-10: hsl(var(--h), var(--s), var(--10-l));
+  --15-l: var(--bulma-light-15-l);
+  --color-15: hsl(var(--h), var(--s), var(--15-l));
+  --20-l: var(--bulma-light-20-l);
+  --color-20: hsl(var(--h), var(--s), var(--20-l));
+  --25-l: var(--bulma-light-25-l);
+  --color-25: hsl(var(--h), var(--s), var(--25-l));
+  --30-l: var(--bulma-light-30-l);
+  --color-30: hsl(var(--h), var(--s), var(--30-l));
+  --35-l: var(--bulma-light-35-l);
+  --color-35: hsl(var(--h), var(--s), var(--35-l));
+  --40-l: var(--bulma-light-40-l);
+  --color-40: hsl(var(--h), var(--s), var(--40-l));
+  --45-l: var(--bulma-light-45-l);
+  --color-45: hsl(var(--h), var(--s), var(--45-l));
+  --50-l: var(--bulma-light-50-l);
+  --color-50: hsl(var(--h), var(--s), var(--50-l));
+  --55-l: var(--bulma-light-55-l);
+  --color-55: hsl(var(--h), var(--s), var(--55-l));
+  --60-l: var(--bulma-light-60-l);
+  --color-60: hsl(var(--h), var(--s), var(--60-l));
+  --65-l: var(--bulma-light-65-l);
+  --color-65: hsl(var(--h), var(--s), var(--65-l));
+  --70-l: var(--bulma-light-70-l);
+  --color-70: hsl(var(--h), var(--s), var(--70-l));
+  --75-l: var(--bulma-light-75-l);
+  --color-75: hsl(var(--h), var(--s), var(--75-l));
+  --80-l: var(--bulma-light-80-l);
+  --color-80: hsl(var(--h), var(--s), var(--80-l));
+  --85-l: var(--bulma-light-85-l);
+  --color-85: hsl(var(--h), var(--s), var(--85-l));
+  --90-l: var(--bulma-light-90-l);
+  --color-90: hsl(var(--h), var(--s), var(--90-l));
+  --95-l: var(--bulma-light-95-l);
+  --color-95: hsl(var(--h), var(--s), var(--95-l));
+  --100-l: var(--bulma-light-100-l);
+  --color-100: hsl(var(--h), var(--s), var(--100-l));
+}
+
+.has-text-dark {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-l)) !important;
+}
+
+.has-background-dark {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-l)) !important;
+}
+
+.has-text-dark-invert {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-invert-l)) !important;
+}
+
+.has-background-dark-invert {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-invert-l)) !important;
+}
+
+.has-text-dark-on-scheme {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-on-scheme-l)) !important;
+}
+
+.has-background-dark-on-scheme {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-on-scheme-l)) !important;
+}
+
+.has-text-dark-light {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-light-l)) !important;
+}
+
+.has-background-dark-light {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-light-l)) !important;
+}
+
+.has-text-dark-light-invert {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-light-invert-l)) !important;
+}
+
+.has-background-dark-light-invert {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-light-invert-l)) !important;
+}
+
+.has-text-dark-dark {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-dark-l)) !important;
+}
+
+.has-background-dark-dark {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-dark-l)) !important;
+}
+
+.has-text-dark-dark-invert {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-dark-invert-l)) !important;
+}
+
+.has-background-dark-dark-invert {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-dark-invert-l)) !important;
+}
+
+.has-text-dark-soft {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-soft-l)) !important;
+}
+
+.has-background-dark-soft {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-soft-l)) !important;
+}
+
+.has-text-dark-bold {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-bold-l)) !important;
+}
+
+.has-background-dark-bold {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-bold-l)) !important;
+}
+
+.has-text-dark-soft-invert {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-soft-invert-l)) !important;
+}
+
+.has-background-dark-soft-invert {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-soft-invert-l)) !important;
+}
+
+.has-text-dark-bold-invert {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-bold-invert-l)) !important;
+}
+
+.has-background-dark-bold-invert {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-bold-invert-l)) !important;
+}
+
+.has-text-dark-00 {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-00-l)) !important;
+}
+
+.has-background-dark-00 {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-00-l)) !important;
+}
+
+.has-text-dark-00-invert {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-00-invert-l)) !important;
+}
+
+.has-background-dark-00-invert {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-00-invert-l)) !important;
+}
+
+.has-text-dark-05 {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-05-l)) !important;
+}
+
+.has-background-dark-05 {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-05-l)) !important;
+}
+
+.has-text-dark-05-invert {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-05-invert-l)) !important;
+}
+
+.has-background-dark-05-invert {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-05-invert-l)) !important;
+}
+
+.has-text-dark-10 {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-10-l)) !important;
+}
+
+.has-background-dark-10 {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-10-l)) !important;
+}
+
+.has-text-dark-10-invert {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-10-invert-l)) !important;
+}
+
+.has-background-dark-10-invert {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-10-invert-l)) !important;
+}
+
+.has-text-dark-15 {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-15-l)) !important;
+}
+
+.has-background-dark-15 {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-15-l)) !important;
+}
+
+.has-text-dark-15-invert {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-15-invert-l)) !important;
+}
+
+.has-background-dark-15-invert {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-15-invert-l)) !important;
+}
+
+.has-text-dark-20 {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-20-l)) !important;
+}
+
+.has-background-dark-20 {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-20-l)) !important;
+}
+
+.has-text-dark-20-invert {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-20-invert-l)) !important;
+}
+
+.has-background-dark-20-invert {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-20-invert-l)) !important;
+}
+
+.has-text-dark-25 {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-25-l)) !important;
+}
+
+.has-background-dark-25 {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-25-l)) !important;
+}
+
+.has-text-dark-25-invert {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-25-invert-l)) !important;
+}
+
+.has-background-dark-25-invert {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-25-invert-l)) !important;
+}
+
+.has-text-dark-30 {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-30-l)) !important;
+}
+
+.has-background-dark-30 {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-30-l)) !important;
+}
+
+.has-text-dark-30-invert {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-30-invert-l)) !important;
+}
+
+.has-background-dark-30-invert {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-30-invert-l)) !important;
+}
+
+.has-text-dark-35 {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-35-l)) !important;
+}
+
+.has-background-dark-35 {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-35-l)) !important;
+}
+
+.has-text-dark-35-invert {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-35-invert-l)) !important;
+}
+
+.has-background-dark-35-invert {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-35-invert-l)) !important;
+}
+
+.has-text-dark-40 {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-40-l)) !important;
+}
+
+.has-background-dark-40 {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-40-l)) !important;
+}
+
+.has-text-dark-40-invert {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-40-invert-l)) !important;
+}
+
+.has-background-dark-40-invert {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-40-invert-l)) !important;
+}
+
+.has-text-dark-45 {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-45-l)) !important;
+}
+
+.has-background-dark-45 {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-45-l)) !important;
+}
+
+.has-text-dark-45-invert {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-45-invert-l)) !important;
+}
+
+.has-background-dark-45-invert {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-45-invert-l)) !important;
+}
+
+.has-text-dark-50 {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-50-l)) !important;
+}
+
+.has-background-dark-50 {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-50-l)) !important;
+}
+
+.has-text-dark-50-invert {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-50-invert-l)) !important;
+}
+
+.has-background-dark-50-invert {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-50-invert-l)) !important;
+}
+
+.has-text-dark-55 {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-55-l)) !important;
+}
+
+.has-background-dark-55 {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-55-l)) !important;
+}
+
+.has-text-dark-55-invert {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-55-invert-l)) !important;
+}
+
+.has-background-dark-55-invert {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-55-invert-l)) !important;
+}
+
+.has-text-dark-60 {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-60-l)) !important;
+}
+
+.has-background-dark-60 {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-60-l)) !important;
+}
+
+.has-text-dark-60-invert {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-60-invert-l)) !important;
+}
+
+.has-background-dark-60-invert {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-60-invert-l)) !important;
+}
+
+.has-text-dark-65 {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-65-l)) !important;
+}
+
+.has-background-dark-65 {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-65-l)) !important;
+}
+
+.has-text-dark-65-invert {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-65-invert-l)) !important;
+}
+
+.has-background-dark-65-invert {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-65-invert-l)) !important;
+}
+
+.has-text-dark-70 {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-70-l)) !important;
+}
+
+.has-background-dark-70 {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-70-l)) !important;
+}
+
+.has-text-dark-70-invert {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-70-invert-l)) !important;
+}
+
+.has-background-dark-70-invert {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-70-invert-l)) !important;
+}
+
+.has-text-dark-75 {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-75-l)) !important;
+}
+
+.has-background-dark-75 {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-75-l)) !important;
+}
+
+.has-text-dark-75-invert {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-75-invert-l)) !important;
+}
+
+.has-background-dark-75-invert {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-75-invert-l)) !important;
+}
+
+.has-text-dark-80 {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-80-l)) !important;
+}
+
+.has-background-dark-80 {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-80-l)) !important;
+}
+
+.has-text-dark-80-invert {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-80-invert-l)) !important;
+}
+
+.has-background-dark-80-invert {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-80-invert-l)) !important;
+}
+
+.has-text-dark-85 {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-85-l)) !important;
+}
+
+.has-background-dark-85 {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-85-l)) !important;
+}
+
+.has-text-dark-85-invert {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-85-invert-l)) !important;
+}
+
+.has-background-dark-85-invert {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-85-invert-l)) !important;
+}
+
+.has-text-dark-90 {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-90-l)) !important;
+}
+
+.has-background-dark-90 {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-90-l)) !important;
+}
+
+.has-text-dark-90-invert {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-90-invert-l)) !important;
+}
+
+.has-background-dark-90-invert {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-90-invert-l)) !important;
+}
+
+.has-text-dark-95 {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-95-l)) !important;
+}
+
+.has-background-dark-95 {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-95-l)) !important;
+}
+
+.has-text-dark-95-invert {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-95-invert-l)) !important;
+}
+
+.has-background-dark-95-invert {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-95-invert-l)) !important;
+}
+
+.has-text-dark-100 {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-100-l)) !important;
+}
+
+.has-background-dark-100 {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-100-l)) !important;
+}
+
+.has-text-dark-100-invert {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-100-invert-l)) !important;
+}
+
+.has-background-dark-100-invert {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), var(--bulma-dark-100-invert-l)) !important;
+}
+
+a.has-text-dark:hover, a.has-text-dark:focus-visible,
+button.has-text-dark:hover,
+button.has-text-dark:focus-visible,
+has-text-dark.is-hoverable:hover,
+has-text-dark.is-hoverable:focus-visible {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), calc(var(--bulma-dark-l) + var(--bulma-hover-color-l-delta))) !important;
+}
+a.has-text-dark:active,
+button.has-text-dark:active,
+has-text-dark.is-hoverable:active {
+  color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), calc(var(--bulma-dark-l) + var(--bulma-active-color-l-delta))) !important;
+}
+
+a.has-background-dark:hover, a.has-background-dark:focus-visible,
+button.has-background-dark:hover,
+button.has-background-dark:focus-visible,
+has-background-dark.is-hoverable:hover,
+has-background-dark.is-hoverable:focus-visible {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), calc(var(--bulma-dark-l) + var(--bulma-hover-background-l-delta))) !important;
+}
+a.has-background-dark:active,
+button.has-background-dark:active,
+has-background-dark.is-hoverable:active {
+  background-color: hsl(var(--bulma-dark-h), var(--bulma-dark-s), calc(var(--bulma-dark-l) + var(--bulma-active-background-l-delta))) !important;
+}
+
+.is-palette-dark {
+  --h: var(--bulma-dark-h);
+  --s: var(--bulma-dark-s);
+  --l: var(--bulma-dark-l);
+  --color: hsl(var(--h), var(--s), var(--l));
+  --00-l: var(--bulma-dark-00-l);
+  --color-00: hsl(var(--h), var(--s), var(--00-l));
+  --05-l: var(--bulma-dark-05-l);
+  --color-05: hsl(var(--h), var(--s), var(--05-l));
+  --10-l: var(--bulma-dark-10-l);
+  --color-10: hsl(var(--h), var(--s), var(--10-l));
+  --15-l: var(--bulma-dark-15-l);
+  --color-15: hsl(var(--h), var(--s), var(--15-l));
+  --20-l: var(--bulma-dark-20-l);
+  --color-20: hsl(var(--h), var(--s), var(--20-l));
+  --25-l: var(--bulma-dark-25-l);
+  --color-25: hsl(var(--h), var(--s), var(--25-l));
+  --30-l: var(--bulma-dark-30-l);
+  --color-30: hsl(var(--h), var(--s), var(--30-l));
+  --35-l: var(--bulma-dark-35-l);
+  --color-35: hsl(var(--h), var(--s), var(--35-l));
+  --40-l: var(--bulma-dark-40-l);
+  --color-40: hsl(var(--h), var(--s), var(--40-l));
+  --45-l: var(--bulma-dark-45-l);
+  --color-45: hsl(var(--h), var(--s), var(--45-l));
+  --50-l: var(--bulma-dark-50-l);
+  --color-50: hsl(var(--h), var(--s), var(--50-l));
+  --55-l: var(--bulma-dark-55-l);
+  --color-55: hsl(var(--h), var(--s), var(--55-l));
+  --60-l: var(--bulma-dark-60-l);
+  --color-60: hsl(var(--h), var(--s), var(--60-l));
+  --65-l: var(--bulma-dark-65-l);
+  --color-65: hsl(var(--h), var(--s), var(--65-l));
+  --70-l: var(--bulma-dark-70-l);
+  --color-70: hsl(var(--h), var(--s), var(--70-l));
+  --75-l: var(--bulma-dark-75-l);
+  --color-75: hsl(var(--h), var(--s), var(--75-l));
+  --80-l: var(--bulma-dark-80-l);
+  --color-80: hsl(var(--h), var(--s), var(--80-l));
+  --85-l: var(--bulma-dark-85-l);
+  --color-85: hsl(var(--h), var(--s), var(--85-l));
+  --90-l: var(--bulma-dark-90-l);
+  --color-90: hsl(var(--h), var(--s), var(--90-l));
+  --95-l: var(--bulma-dark-95-l);
+  --color-95: hsl(var(--h), var(--s), var(--95-l));
+  --100-l: var(--bulma-dark-100-l);
+  --color-100: hsl(var(--h), var(--s), var(--100-l));
+}
+
+.has-text-text {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-l)) !important;
+}
+
+.has-background-text {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-l)) !important;
+}
+
+.has-text-text-invert {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-invert-l)) !important;
+}
+
+.has-background-text-invert {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-invert-l)) !important;
+}
+
+.has-text-text-on-scheme {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-on-scheme-l)) !important;
+}
+
+.has-background-text-on-scheme {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-on-scheme-l)) !important;
+}
+
+.has-text-text-light {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-light-l)) !important;
+}
+
+.has-background-text-light {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-light-l)) !important;
+}
+
+.has-text-text-light-invert {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-light-invert-l)) !important;
+}
+
+.has-background-text-light-invert {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-light-invert-l)) !important;
+}
+
+.has-text-text-dark {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-dark-l)) !important;
+}
+
+.has-background-text-dark {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-dark-l)) !important;
+}
+
+.has-text-text-dark-invert {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-dark-invert-l)) !important;
+}
+
+.has-background-text-dark-invert {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-dark-invert-l)) !important;
+}
+
+.has-text-text-soft {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-soft-l)) !important;
+}
+
+.has-background-text-soft {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-soft-l)) !important;
+}
+
+.has-text-text-bold {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-bold-l)) !important;
+}
+
+.has-background-text-bold {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-bold-l)) !important;
+}
+
+.has-text-text-soft-invert {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-soft-invert-l)) !important;
+}
+
+.has-background-text-soft-invert {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-soft-invert-l)) !important;
+}
+
+.has-text-text-bold-invert {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-bold-invert-l)) !important;
+}
+
+.has-background-text-bold-invert {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-bold-invert-l)) !important;
+}
+
+.has-text-text-00 {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-00-l)) !important;
+}
+
+.has-background-text-00 {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-00-l)) !important;
+}
+
+.has-text-text-00-invert {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-00-invert-l)) !important;
+}
+
+.has-background-text-00-invert {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-00-invert-l)) !important;
+}
+
+.has-text-text-05 {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-05-l)) !important;
+}
+
+.has-background-text-05 {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-05-l)) !important;
+}
+
+.has-text-text-05-invert {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-05-invert-l)) !important;
+}
+
+.has-background-text-05-invert {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-05-invert-l)) !important;
+}
+
+.has-text-text-10 {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-10-l)) !important;
+}
+
+.has-background-text-10 {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-10-l)) !important;
+}
+
+.has-text-text-10-invert {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-10-invert-l)) !important;
+}
+
+.has-background-text-10-invert {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-10-invert-l)) !important;
+}
+
+.has-text-text-15 {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-15-l)) !important;
+}
+
+.has-background-text-15 {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-15-l)) !important;
+}
+
+.has-text-text-15-invert {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-15-invert-l)) !important;
+}
+
+.has-background-text-15-invert {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-15-invert-l)) !important;
+}
+
+.has-text-text-20 {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-20-l)) !important;
+}
+
+.has-background-text-20 {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-20-l)) !important;
+}
+
+.has-text-text-20-invert {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-20-invert-l)) !important;
+}
+
+.has-background-text-20-invert {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-20-invert-l)) !important;
+}
+
+.has-text-text-25 {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-25-l)) !important;
+}
+
+.has-background-text-25 {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-25-l)) !important;
+}
+
+.has-text-text-25-invert {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-25-invert-l)) !important;
+}
+
+.has-background-text-25-invert {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-25-invert-l)) !important;
+}
+
+.has-text-text-30 {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-30-l)) !important;
+}
+
+.has-background-text-30 {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-30-l)) !important;
+}
+
+.has-text-text-30-invert {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-30-invert-l)) !important;
+}
+
+.has-background-text-30-invert {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-30-invert-l)) !important;
+}
+
+.has-text-text-35 {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-35-l)) !important;
+}
+
+.has-background-text-35 {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-35-l)) !important;
+}
+
+.has-text-text-35-invert {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-35-invert-l)) !important;
+}
+
+.has-background-text-35-invert {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-35-invert-l)) !important;
+}
+
+.has-text-text-40 {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-40-l)) !important;
+}
+
+.has-background-text-40 {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-40-l)) !important;
+}
+
+.has-text-text-40-invert {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-40-invert-l)) !important;
+}
+
+.has-background-text-40-invert {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-40-invert-l)) !important;
+}
+
+.has-text-text-45 {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-45-l)) !important;
+}
+
+.has-background-text-45 {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-45-l)) !important;
+}
+
+.has-text-text-45-invert {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-45-invert-l)) !important;
+}
+
+.has-background-text-45-invert {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-45-invert-l)) !important;
+}
+
+.has-text-text-50 {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-50-l)) !important;
+}
+
+.has-background-text-50 {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-50-l)) !important;
+}
+
+.has-text-text-50-invert {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-50-invert-l)) !important;
+}
+
+.has-background-text-50-invert {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-50-invert-l)) !important;
+}
+
+.has-text-text-55 {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-55-l)) !important;
+}
+
+.has-background-text-55 {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-55-l)) !important;
+}
+
+.has-text-text-55-invert {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-55-invert-l)) !important;
+}
+
+.has-background-text-55-invert {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-55-invert-l)) !important;
+}
+
+.has-text-text-60 {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-60-l)) !important;
+}
+
+.has-background-text-60 {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-60-l)) !important;
+}
+
+.has-text-text-60-invert {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-60-invert-l)) !important;
+}
+
+.has-background-text-60-invert {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-60-invert-l)) !important;
+}
+
+.has-text-text-65 {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-65-l)) !important;
+}
+
+.has-background-text-65 {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-65-l)) !important;
+}
+
+.has-text-text-65-invert {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-65-invert-l)) !important;
+}
+
+.has-background-text-65-invert {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-65-invert-l)) !important;
+}
+
+.has-text-text-70 {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-70-l)) !important;
+}
+
+.has-background-text-70 {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-70-l)) !important;
+}
+
+.has-text-text-70-invert {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-70-invert-l)) !important;
+}
+
+.has-background-text-70-invert {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-70-invert-l)) !important;
+}
+
+.has-text-text-75 {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-75-l)) !important;
+}
+
+.has-background-text-75 {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-75-l)) !important;
+}
+
+.has-text-text-75-invert {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-75-invert-l)) !important;
+}
+
+.has-background-text-75-invert {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-75-invert-l)) !important;
+}
+
+.has-text-text-80 {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-80-l)) !important;
+}
+
+.has-background-text-80 {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-80-l)) !important;
+}
+
+.has-text-text-80-invert {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-80-invert-l)) !important;
+}
+
+.has-background-text-80-invert {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-80-invert-l)) !important;
+}
+
+.has-text-text-85 {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-85-l)) !important;
+}
+
+.has-background-text-85 {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-85-l)) !important;
+}
+
+.has-text-text-85-invert {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-85-invert-l)) !important;
+}
+
+.has-background-text-85-invert {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-85-invert-l)) !important;
+}
+
+.has-text-text-90 {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-90-l)) !important;
+}
+
+.has-background-text-90 {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-90-l)) !important;
+}
+
+.has-text-text-90-invert {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-90-invert-l)) !important;
+}
+
+.has-background-text-90-invert {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-90-invert-l)) !important;
+}
+
+.has-text-text-95 {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-95-l)) !important;
+}
+
+.has-background-text-95 {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-95-l)) !important;
+}
+
+.has-text-text-95-invert {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-95-invert-l)) !important;
+}
+
+.has-background-text-95-invert {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-95-invert-l)) !important;
+}
+
+.has-text-text-100 {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-100-l)) !important;
+}
+
+.has-background-text-100 {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-100-l)) !important;
+}
+
+.has-text-text-100-invert {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-100-invert-l)) !important;
+}
+
+.has-background-text-100-invert {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), var(--bulma-text-100-invert-l)) !important;
+}
+
+a.has-text-text:hover, a.has-text-text:focus-visible,
+button.has-text-text:hover,
+button.has-text-text:focus-visible,
+has-text-text.is-hoverable:hover,
+has-text-text.is-hoverable:focus-visible {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), calc(var(--bulma-text-l) + var(--bulma-hover-color-l-delta))) !important;
+}
+a.has-text-text:active,
+button.has-text-text:active,
+has-text-text.is-hoverable:active {
+  color: hsl(var(--bulma-text-h), var(--bulma-text-s), calc(var(--bulma-text-l) + var(--bulma-active-color-l-delta))) !important;
+}
+
+a.has-background-text:hover, a.has-background-text:focus-visible,
+button.has-background-text:hover,
+button.has-background-text:focus-visible,
+has-background-text.is-hoverable:hover,
+has-background-text.is-hoverable:focus-visible {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), calc(var(--bulma-text-l) + var(--bulma-hover-background-l-delta))) !important;
+}
+a.has-background-text:active,
+button.has-background-text:active,
+has-background-text.is-hoverable:active {
+  background-color: hsl(var(--bulma-text-h), var(--bulma-text-s), calc(var(--bulma-text-l) + var(--bulma-active-background-l-delta))) !important;
+}
+
+.is-palette-text {
+  --h: var(--bulma-text-h);
+  --s: var(--bulma-text-s);
+  --l: var(--bulma-text-l);
+  --color: hsl(var(--h), var(--s), var(--l));
+  --00-l: var(--bulma-text-00-l);
+  --color-00: hsl(var(--h), var(--s), var(--00-l));
+  --05-l: var(--bulma-text-05-l);
+  --color-05: hsl(var(--h), var(--s), var(--05-l));
+  --10-l: var(--bulma-text-10-l);
+  --color-10: hsl(var(--h), var(--s), var(--10-l));
+  --15-l: var(--bulma-text-15-l);
+  --color-15: hsl(var(--h), var(--s), var(--15-l));
+  --20-l: var(--bulma-text-20-l);
+  --color-20: hsl(var(--h), var(--s), var(--20-l));
+  --25-l: var(--bulma-text-25-l);
+  --color-25: hsl(var(--h), var(--s), var(--25-l));
+  --30-l: var(--bulma-text-30-l);
+  --color-30: hsl(var(--h), var(--s), var(--30-l));
+  --35-l: var(--bulma-text-35-l);
+  --color-35: hsl(var(--h), var(--s), var(--35-l));
+  --40-l: var(--bulma-text-40-l);
+  --color-40: hsl(var(--h), var(--s), var(--40-l));
+  --45-l: var(--bulma-text-45-l);
+  --color-45: hsl(var(--h), var(--s), var(--45-l));
+  --50-l: var(--bulma-text-50-l);
+  --color-50: hsl(var(--h), var(--s), var(--50-l));
+  --55-l: var(--bulma-text-55-l);
+  --color-55: hsl(var(--h), var(--s), var(--55-l));
+  --60-l: var(--bulma-text-60-l);
+  --color-60: hsl(var(--h), var(--s), var(--60-l));
+  --65-l: var(--bulma-text-65-l);
+  --color-65: hsl(var(--h), var(--s), var(--65-l));
+  --70-l: var(--bulma-text-70-l);
+  --color-70: hsl(var(--h), var(--s), var(--70-l));
+  --75-l: var(--bulma-text-75-l);
+  --color-75: hsl(var(--h), var(--s), var(--75-l));
+  --80-l: var(--bulma-text-80-l);
+  --color-80: hsl(var(--h), var(--s), var(--80-l));
+  --85-l: var(--bulma-text-85-l);
+  --color-85: hsl(var(--h), var(--s), var(--85-l));
+  --90-l: var(--bulma-text-90-l);
+  --color-90: hsl(var(--h), var(--s), var(--90-l));
+  --95-l: var(--bulma-text-95-l);
+  --color-95: hsl(var(--h), var(--s), var(--95-l));
+  --100-l: var(--bulma-text-100-l);
+  --color-100: hsl(var(--h), var(--s), var(--100-l));
+}
+
+.has-text-primary {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-l)) !important;
+}
+
+.has-background-primary {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-l)) !important;
+}
+
+.has-text-primary-invert {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-invert-l)) !important;
+}
+
+.has-background-primary-invert {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-invert-l)) !important;
+}
+
+.has-text-primary-on-scheme {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-on-scheme-l)) !important;
+}
+
+.has-background-primary-on-scheme {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-on-scheme-l)) !important;
+}
+
+.has-text-primary-light {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-light-l)) !important;
+}
+
+.has-background-primary-light {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-light-l)) !important;
+}
+
+.has-text-primary-light-invert {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-light-invert-l)) !important;
+}
+
+.has-background-primary-light-invert {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-light-invert-l)) !important;
+}
+
+.has-text-primary-dark {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-dark-l)) !important;
+}
+
+.has-background-primary-dark {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-dark-l)) !important;
+}
+
+.has-text-primary-dark-invert {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-dark-invert-l)) !important;
+}
+
+.has-background-primary-dark-invert {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-dark-invert-l)) !important;
+}
+
+.has-text-primary-soft {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-soft-l)) !important;
+}
+
+.has-background-primary-soft {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-soft-l)) !important;
+}
+
+.has-text-primary-bold {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-bold-l)) !important;
+}
+
+.has-background-primary-bold {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-bold-l)) !important;
+}
+
+.has-text-primary-soft-invert {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-soft-invert-l)) !important;
+}
+
+.has-background-primary-soft-invert {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-soft-invert-l)) !important;
+}
+
+.has-text-primary-bold-invert {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-bold-invert-l)) !important;
+}
+
+.has-background-primary-bold-invert {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-bold-invert-l)) !important;
+}
+
+.has-text-primary-00 {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-00-l)) !important;
+}
+
+.has-background-primary-00 {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-00-l)) !important;
+}
+
+.has-text-primary-00-invert {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-00-invert-l)) !important;
+}
+
+.has-background-primary-00-invert {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-00-invert-l)) !important;
+}
+
+.has-text-primary-05 {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-05-l)) !important;
+}
+
+.has-background-primary-05 {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-05-l)) !important;
+}
+
+.has-text-primary-05-invert {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-05-invert-l)) !important;
+}
+
+.has-background-primary-05-invert {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-05-invert-l)) !important;
+}
+
+.has-text-primary-10 {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-10-l)) !important;
+}
+
+.has-background-primary-10 {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-10-l)) !important;
+}
+
+.has-text-primary-10-invert {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-10-invert-l)) !important;
+}
+
+.has-background-primary-10-invert {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-10-invert-l)) !important;
+}
+
+.has-text-primary-15 {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-15-l)) !important;
+}
+
+.has-background-primary-15 {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-15-l)) !important;
+}
+
+.has-text-primary-15-invert {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-15-invert-l)) !important;
+}
+
+.has-background-primary-15-invert {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-15-invert-l)) !important;
+}
+
+.has-text-primary-20 {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-20-l)) !important;
+}
+
+.has-background-primary-20 {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-20-l)) !important;
+}
+
+.has-text-primary-20-invert {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-20-invert-l)) !important;
+}
+
+.has-background-primary-20-invert {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-20-invert-l)) !important;
+}
+
+.has-text-primary-25 {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-25-l)) !important;
+}
+
+.has-background-primary-25 {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-25-l)) !important;
+}
+
+.has-text-primary-25-invert {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-25-invert-l)) !important;
+}
+
+.has-background-primary-25-invert {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-25-invert-l)) !important;
+}
+
+.has-text-primary-30 {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-30-l)) !important;
+}
+
+.has-background-primary-30 {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-30-l)) !important;
+}
+
+.has-text-primary-30-invert {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-30-invert-l)) !important;
+}
+
+.has-background-primary-30-invert {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-30-invert-l)) !important;
+}
+
+.has-text-primary-35 {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-35-l)) !important;
+}
+
+.has-background-primary-35 {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-35-l)) !important;
+}
+
+.has-text-primary-35-invert {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-35-invert-l)) !important;
+}
+
+.has-background-primary-35-invert {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-35-invert-l)) !important;
+}
+
+.has-text-primary-40 {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-40-l)) !important;
+}
+
+.has-background-primary-40 {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-40-l)) !important;
+}
+
+.has-text-primary-40-invert {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-40-invert-l)) !important;
+}
+
+.has-background-primary-40-invert {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-40-invert-l)) !important;
+}
+
+.has-text-primary-45 {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-45-l)) !important;
+}
+
+.has-background-primary-45 {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-45-l)) !important;
+}
+
+.has-text-primary-45-invert {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-45-invert-l)) !important;
+}
+
+.has-background-primary-45-invert {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-45-invert-l)) !important;
+}
+
+.has-text-primary-50 {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-50-l)) !important;
+}
+
+.has-background-primary-50 {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-50-l)) !important;
+}
+
+.has-text-primary-50-invert {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-50-invert-l)) !important;
+}
+
+.has-background-primary-50-invert {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-50-invert-l)) !important;
+}
+
+.has-text-primary-55 {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-55-l)) !important;
+}
+
+.has-background-primary-55 {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-55-l)) !important;
+}
+
+.has-text-primary-55-invert {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-55-invert-l)) !important;
+}
+
+.has-background-primary-55-invert {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-55-invert-l)) !important;
+}
+
+.has-text-primary-60 {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-60-l)) !important;
+}
+
+.has-background-primary-60 {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-60-l)) !important;
+}
+
+.has-text-primary-60-invert {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-60-invert-l)) !important;
+}
+
+.has-background-primary-60-invert {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-60-invert-l)) !important;
+}
+
+.has-text-primary-65 {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-65-l)) !important;
+}
+
+.has-background-primary-65 {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-65-l)) !important;
+}
+
+.has-text-primary-65-invert {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-65-invert-l)) !important;
+}
+
+.has-background-primary-65-invert {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-65-invert-l)) !important;
+}
+
+.has-text-primary-70 {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-70-l)) !important;
+}
+
+.has-background-primary-70 {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-70-l)) !important;
+}
+
+.has-text-primary-70-invert {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-70-invert-l)) !important;
+}
+
+.has-background-primary-70-invert {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-70-invert-l)) !important;
+}
+
+.has-text-primary-75 {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-75-l)) !important;
+}
+
+.has-background-primary-75 {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-75-l)) !important;
+}
+
+.has-text-primary-75-invert {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-75-invert-l)) !important;
+}
+
+.has-background-primary-75-invert {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-75-invert-l)) !important;
+}
+
+.has-text-primary-80 {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-80-l)) !important;
+}
+
+.has-background-primary-80 {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-80-l)) !important;
+}
+
+.has-text-primary-80-invert {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-80-invert-l)) !important;
+}
+
+.has-background-primary-80-invert {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-80-invert-l)) !important;
+}
+
+.has-text-primary-85 {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-85-l)) !important;
+}
+
+.has-background-primary-85 {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-85-l)) !important;
+}
+
+.has-text-primary-85-invert {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-85-invert-l)) !important;
+}
+
+.has-background-primary-85-invert {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-85-invert-l)) !important;
+}
+
+.has-text-primary-90 {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-90-l)) !important;
+}
+
+.has-background-primary-90 {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-90-l)) !important;
+}
+
+.has-text-primary-90-invert {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-90-invert-l)) !important;
+}
+
+.has-background-primary-90-invert {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-90-invert-l)) !important;
+}
+
+.has-text-primary-95 {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-95-l)) !important;
+}
+
+.has-background-primary-95 {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-95-l)) !important;
+}
+
+.has-text-primary-95-invert {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-95-invert-l)) !important;
+}
+
+.has-background-primary-95-invert {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-95-invert-l)) !important;
+}
+
+.has-text-primary-100 {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-100-l)) !important;
+}
+
+.has-background-primary-100 {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-100-l)) !important;
+}
+
+.has-text-primary-100-invert {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-100-invert-l)) !important;
+}
+
+.has-background-primary-100-invert {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), var(--bulma-primary-100-invert-l)) !important;
+}
+
+a.has-text-primary:hover, a.has-text-primary:focus-visible,
+button.has-text-primary:hover,
+button.has-text-primary:focus-visible,
+has-text-primary.is-hoverable:hover,
+has-text-primary.is-hoverable:focus-visible {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), calc(var(--bulma-primary-l) + var(--bulma-hover-color-l-delta))) !important;
+}
+a.has-text-primary:active,
+button.has-text-primary:active,
+has-text-primary.is-hoverable:active {
+  color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), calc(var(--bulma-primary-l) + var(--bulma-active-color-l-delta))) !important;
+}
+
+a.has-background-primary:hover, a.has-background-primary:focus-visible,
+button.has-background-primary:hover,
+button.has-background-primary:focus-visible,
+has-background-primary.is-hoverable:hover,
+has-background-primary.is-hoverable:focus-visible {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), calc(var(--bulma-primary-l) + var(--bulma-hover-background-l-delta))) !important;
+}
+a.has-background-primary:active,
+button.has-background-primary:active,
+has-background-primary.is-hoverable:active {
+  background-color: hsl(var(--bulma-primary-h), var(--bulma-primary-s), calc(var(--bulma-primary-l) + var(--bulma-active-background-l-delta))) !important;
+}
+
+.is-palette-primary {
+  --h: var(--bulma-primary-h);
+  --s: var(--bulma-primary-s);
+  --l: var(--bulma-primary-l);
+  --color: hsl(var(--h), var(--s), var(--l));
+  --00-l: var(--bulma-primary-00-l);
+  --color-00: hsl(var(--h), var(--s), var(--00-l));
+  --05-l: var(--bulma-primary-05-l);
+  --color-05: hsl(var(--h), var(--s), var(--05-l));
+  --10-l: var(--bulma-primary-10-l);
+  --color-10: hsl(var(--h), var(--s), var(--10-l));
+  --15-l: var(--bulma-primary-15-l);
+  --color-15: hsl(var(--h), var(--s), var(--15-l));
+  --20-l: var(--bulma-primary-20-l);
+  --color-20: hsl(var(--h), var(--s), var(--20-l));
+  --25-l: var(--bulma-primary-25-l);
+  --color-25: hsl(var(--h), var(--s), var(--25-l));
+  --30-l: var(--bulma-primary-30-l);
+  --color-30: hsl(var(--h), var(--s), var(--30-l));
+  --35-l: var(--bulma-primary-35-l);
+  --color-35: hsl(var(--h), var(--s), var(--35-l));
+  --40-l: var(--bulma-primary-40-l);
+  --color-40: hsl(var(--h), var(--s), var(--40-l));
+  --45-l: var(--bulma-primary-45-l);
+  --color-45: hsl(var(--h), var(--s), var(--45-l));
+  --50-l: var(--bulma-primary-50-l);
+  --color-50: hsl(var(--h), var(--s), var(--50-l));
+  --55-l: var(--bulma-primary-55-l);
+  --color-55: hsl(var(--h), var(--s), var(--55-l));
+  --60-l: var(--bulma-primary-60-l);
+  --color-60: hsl(var(--h), var(--s), var(--60-l));
+  --65-l: var(--bulma-primary-65-l);
+  --color-65: hsl(var(--h), var(--s), var(--65-l));
+  --70-l: var(--bulma-primary-70-l);
+  --color-70: hsl(var(--h), var(--s), var(--70-l));
+  --75-l: var(--bulma-primary-75-l);
+  --color-75: hsl(var(--h), var(--s), var(--75-l));
+  --80-l: var(--bulma-primary-80-l);
+  --color-80: hsl(var(--h), var(--s), var(--80-l));
+  --85-l: var(--bulma-primary-85-l);
+  --color-85: hsl(var(--h), var(--s), var(--85-l));
+  --90-l: var(--bulma-primary-90-l);
+  --color-90: hsl(var(--h), var(--s), var(--90-l));
+  --95-l: var(--bulma-primary-95-l);
+  --color-95: hsl(var(--h), var(--s), var(--95-l));
+  --100-l: var(--bulma-primary-100-l);
+  --color-100: hsl(var(--h), var(--s), var(--100-l));
+}
+
+.has-text-link {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-l)) !important;
+}
+
+.has-background-link {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-l)) !important;
+}
+
+.has-text-link-invert {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-invert-l)) !important;
+}
+
+.has-background-link-invert {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-invert-l)) !important;
+}
+
+.has-text-link-on-scheme {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-on-scheme-l)) !important;
+}
+
+.has-background-link-on-scheme {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-on-scheme-l)) !important;
+}
+
+.has-text-link-light {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-light-l)) !important;
+}
+
+.has-background-link-light {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-light-l)) !important;
+}
+
+.has-text-link-light-invert {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-light-invert-l)) !important;
+}
+
+.has-background-link-light-invert {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-light-invert-l)) !important;
+}
+
+.has-text-link-dark {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-dark-l)) !important;
+}
+
+.has-background-link-dark {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-dark-l)) !important;
+}
+
+.has-text-link-dark-invert {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-dark-invert-l)) !important;
+}
+
+.has-background-link-dark-invert {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-dark-invert-l)) !important;
+}
+
+.has-text-link-soft {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-soft-l)) !important;
+}
+
+.has-background-link-soft {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-soft-l)) !important;
+}
+
+.has-text-link-bold {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-bold-l)) !important;
+}
+
+.has-background-link-bold {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-bold-l)) !important;
+}
+
+.has-text-link-soft-invert {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-soft-invert-l)) !important;
+}
+
+.has-background-link-soft-invert {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-soft-invert-l)) !important;
+}
+
+.has-text-link-bold-invert {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-bold-invert-l)) !important;
+}
+
+.has-background-link-bold-invert {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-bold-invert-l)) !important;
+}
+
+.has-text-link-00 {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-00-l)) !important;
+}
+
+.has-background-link-00 {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-00-l)) !important;
+}
+
+.has-text-link-00-invert {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-00-invert-l)) !important;
+}
+
+.has-background-link-00-invert {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-00-invert-l)) !important;
+}
+
+.has-text-link-05 {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-05-l)) !important;
+}
+
+.has-background-link-05 {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-05-l)) !important;
+}
+
+.has-text-link-05-invert {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-05-invert-l)) !important;
+}
+
+.has-background-link-05-invert {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-05-invert-l)) !important;
+}
+
+.has-text-link-10 {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-10-l)) !important;
+}
+
+.has-background-link-10 {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-10-l)) !important;
+}
+
+.has-text-link-10-invert {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-10-invert-l)) !important;
+}
+
+.has-background-link-10-invert {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-10-invert-l)) !important;
+}
+
+.has-text-link-15 {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-15-l)) !important;
+}
+
+.has-background-link-15 {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-15-l)) !important;
+}
+
+.has-text-link-15-invert {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-15-invert-l)) !important;
+}
+
+.has-background-link-15-invert {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-15-invert-l)) !important;
+}
+
+.has-text-link-20 {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-20-l)) !important;
+}
+
+.has-background-link-20 {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-20-l)) !important;
+}
+
+.has-text-link-20-invert {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-20-invert-l)) !important;
+}
+
+.has-background-link-20-invert {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-20-invert-l)) !important;
+}
+
+.has-text-link-25 {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-25-l)) !important;
+}
+
+.has-background-link-25 {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-25-l)) !important;
+}
+
+.has-text-link-25-invert {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-25-invert-l)) !important;
+}
+
+.has-background-link-25-invert {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-25-invert-l)) !important;
+}
+
+.has-text-link-30 {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-30-l)) !important;
+}
+
+.has-background-link-30 {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-30-l)) !important;
+}
+
+.has-text-link-30-invert {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-30-invert-l)) !important;
+}
+
+.has-background-link-30-invert {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-30-invert-l)) !important;
+}
+
+.has-text-link-35 {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-35-l)) !important;
+}
+
+.has-background-link-35 {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-35-l)) !important;
+}
+
+.has-text-link-35-invert {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-35-invert-l)) !important;
+}
+
+.has-background-link-35-invert {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-35-invert-l)) !important;
+}
+
+.has-text-link-40 {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-40-l)) !important;
+}
+
+.has-background-link-40 {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-40-l)) !important;
+}
+
+.has-text-link-40-invert {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-40-invert-l)) !important;
+}
+
+.has-background-link-40-invert {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-40-invert-l)) !important;
+}
+
+.has-text-link-45 {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-45-l)) !important;
+}
+
+.has-background-link-45 {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-45-l)) !important;
+}
+
+.has-text-link-45-invert {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-45-invert-l)) !important;
+}
+
+.has-background-link-45-invert {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-45-invert-l)) !important;
+}
+
+.has-text-link-50 {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-50-l)) !important;
+}
+
+.has-background-link-50 {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-50-l)) !important;
+}
+
+.has-text-link-50-invert {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-50-invert-l)) !important;
+}
+
+.has-background-link-50-invert {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-50-invert-l)) !important;
+}
+
+.has-text-link-55 {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-55-l)) !important;
+}
+
+.has-background-link-55 {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-55-l)) !important;
+}
+
+.has-text-link-55-invert {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-55-invert-l)) !important;
+}
+
+.has-background-link-55-invert {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-55-invert-l)) !important;
+}
+
+.has-text-link-60 {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-60-l)) !important;
+}
+
+.has-background-link-60 {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-60-l)) !important;
+}
+
+.has-text-link-60-invert {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-60-invert-l)) !important;
+}
+
+.has-background-link-60-invert {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-60-invert-l)) !important;
+}
+
+.has-text-link-65 {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-65-l)) !important;
+}
+
+.has-background-link-65 {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-65-l)) !important;
+}
+
+.has-text-link-65-invert {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-65-invert-l)) !important;
+}
+
+.has-background-link-65-invert {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-65-invert-l)) !important;
+}
+
+.has-text-link-70 {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-70-l)) !important;
+}
+
+.has-background-link-70 {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-70-l)) !important;
+}
+
+.has-text-link-70-invert {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-70-invert-l)) !important;
+}
+
+.has-background-link-70-invert {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-70-invert-l)) !important;
+}
+
+.has-text-link-75 {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-75-l)) !important;
+}
+
+.has-background-link-75 {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-75-l)) !important;
+}
+
+.has-text-link-75-invert {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-75-invert-l)) !important;
+}
+
+.has-background-link-75-invert {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-75-invert-l)) !important;
+}
+
+.has-text-link-80 {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-80-l)) !important;
+}
+
+.has-background-link-80 {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-80-l)) !important;
+}
+
+.has-text-link-80-invert {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-80-invert-l)) !important;
+}
+
+.has-background-link-80-invert {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-80-invert-l)) !important;
+}
+
+.has-text-link-85 {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-85-l)) !important;
+}
+
+.has-background-link-85 {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-85-l)) !important;
+}
+
+.has-text-link-85-invert {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-85-invert-l)) !important;
+}
+
+.has-background-link-85-invert {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-85-invert-l)) !important;
+}
+
+.has-text-link-90 {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-90-l)) !important;
+}
+
+.has-background-link-90 {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-90-l)) !important;
+}
+
+.has-text-link-90-invert {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-90-invert-l)) !important;
+}
+
+.has-background-link-90-invert {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-90-invert-l)) !important;
+}
+
+.has-text-link-95 {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-95-l)) !important;
+}
+
+.has-background-link-95 {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-95-l)) !important;
+}
+
+.has-text-link-95-invert {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-95-invert-l)) !important;
+}
+
+.has-background-link-95-invert {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-95-invert-l)) !important;
+}
+
+.has-text-link-100 {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-100-l)) !important;
+}
+
+.has-background-link-100 {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-100-l)) !important;
+}
+
+.has-text-link-100-invert {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-100-invert-l)) !important;
+}
+
+.has-background-link-100-invert {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), var(--bulma-link-100-invert-l)) !important;
+}
+
+a.has-text-link:hover, a.has-text-link:focus-visible,
+button.has-text-link:hover,
+button.has-text-link:focus-visible,
+has-text-link.is-hoverable:hover,
+has-text-link.is-hoverable:focus-visible {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), calc(var(--bulma-link-l) + var(--bulma-hover-color-l-delta))) !important;
+}
+a.has-text-link:active,
+button.has-text-link:active,
+has-text-link.is-hoverable:active {
+  color: hsl(var(--bulma-link-h), var(--bulma-link-s), calc(var(--bulma-link-l) + var(--bulma-active-color-l-delta))) !important;
+}
+
+a.has-background-link:hover, a.has-background-link:focus-visible,
+button.has-background-link:hover,
+button.has-background-link:focus-visible,
+has-background-link.is-hoverable:hover,
+has-background-link.is-hoverable:focus-visible {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), calc(var(--bulma-link-l) + var(--bulma-hover-background-l-delta))) !important;
+}
+a.has-background-link:active,
+button.has-background-link:active,
+has-background-link.is-hoverable:active {
+  background-color: hsl(var(--bulma-link-h), var(--bulma-link-s), calc(var(--bulma-link-l) + var(--bulma-active-background-l-delta))) !important;
+}
+
+.is-palette-link {
+  --h: var(--bulma-link-h);
+  --s: var(--bulma-link-s);
+  --l: var(--bulma-link-l);
+  --color: hsl(var(--h), var(--s), var(--l));
+  --00-l: var(--bulma-link-00-l);
+  --color-00: hsl(var(--h), var(--s), var(--00-l));
+  --05-l: var(--bulma-link-05-l);
+  --color-05: hsl(var(--h), var(--s), var(--05-l));
+  --10-l: var(--bulma-link-10-l);
+  --color-10: hsl(var(--h), var(--s), var(--10-l));
+  --15-l: var(--bulma-link-15-l);
+  --color-15: hsl(var(--h), var(--s), var(--15-l));
+  --20-l: var(--bulma-link-20-l);
+  --color-20: hsl(var(--h), var(--s), var(--20-l));
+  --25-l: var(--bulma-link-25-l);
+  --color-25: hsl(var(--h), var(--s), var(--25-l));
+  --30-l: var(--bulma-link-30-l);
+  --color-30: hsl(var(--h), var(--s), var(--30-l));
+  --35-l: var(--bulma-link-35-l);
+  --color-35: hsl(var(--h), var(--s), var(--35-l));
+  --40-l: var(--bulma-link-40-l);
+  --color-40: hsl(var(--h), var(--s), var(--40-l));
+  --45-l: var(--bulma-link-45-l);
+  --color-45: hsl(var(--h), var(--s), var(--45-l));
+  --50-l: var(--bulma-link-50-l);
+  --color-50: hsl(var(--h), var(--s), var(--50-l));
+  --55-l: var(--bulma-link-55-l);
+  --color-55: hsl(var(--h), var(--s), var(--55-l));
+  --60-l: var(--bulma-link-60-l);
+  --color-60: hsl(var(--h), var(--s), var(--60-l));
+  --65-l: var(--bulma-link-65-l);
+  --color-65: hsl(var(--h), var(--s), var(--65-l));
+  --70-l: var(--bulma-link-70-l);
+  --color-70: hsl(var(--h), var(--s), var(--70-l));
+  --75-l: var(--bulma-link-75-l);
+  --color-75: hsl(var(--h), var(--s), var(--75-l));
+  --80-l: var(--bulma-link-80-l);
+  --color-80: hsl(var(--h), var(--s), var(--80-l));
+  --85-l: var(--bulma-link-85-l);
+  --color-85: hsl(var(--h), var(--s), var(--85-l));
+  --90-l: var(--bulma-link-90-l);
+  --color-90: hsl(var(--h), var(--s), var(--90-l));
+  --95-l: var(--bulma-link-95-l);
+  --color-95: hsl(var(--h), var(--s), var(--95-l));
+  --100-l: var(--bulma-link-100-l);
+  --color-100: hsl(var(--h), var(--s), var(--100-l));
+}
+
+.has-text-info {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-l)) !important;
+}
+
+.has-background-info {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-l)) !important;
+}
+
+.has-text-info-invert {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-invert-l)) !important;
+}
+
+.has-background-info-invert {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-invert-l)) !important;
+}
+
+.has-text-info-on-scheme {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-on-scheme-l)) !important;
+}
+
+.has-background-info-on-scheme {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-on-scheme-l)) !important;
+}
+
+.has-text-info-light {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-light-l)) !important;
+}
+
+.has-background-info-light {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-light-l)) !important;
+}
+
+.has-text-info-light-invert {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-light-invert-l)) !important;
+}
+
+.has-background-info-light-invert {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-light-invert-l)) !important;
+}
+
+.has-text-info-dark {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-dark-l)) !important;
+}
+
+.has-background-info-dark {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-dark-l)) !important;
+}
+
+.has-text-info-dark-invert {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-dark-invert-l)) !important;
+}
+
+.has-background-info-dark-invert {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-dark-invert-l)) !important;
+}
+
+.has-text-info-soft {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-soft-l)) !important;
+}
+
+.has-background-info-soft {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-soft-l)) !important;
+}
+
+.has-text-info-bold {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-bold-l)) !important;
+}
+
+.has-background-info-bold {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-bold-l)) !important;
+}
+
+.has-text-info-soft-invert {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-soft-invert-l)) !important;
+}
+
+.has-background-info-soft-invert {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-soft-invert-l)) !important;
+}
+
+.has-text-info-bold-invert {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-bold-invert-l)) !important;
+}
+
+.has-background-info-bold-invert {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-bold-invert-l)) !important;
+}
+
+.has-text-info-00 {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-00-l)) !important;
+}
+
+.has-background-info-00 {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-00-l)) !important;
+}
+
+.has-text-info-00-invert {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-00-invert-l)) !important;
+}
+
+.has-background-info-00-invert {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-00-invert-l)) !important;
+}
+
+.has-text-info-05 {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-05-l)) !important;
+}
+
+.has-background-info-05 {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-05-l)) !important;
+}
+
+.has-text-info-05-invert {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-05-invert-l)) !important;
+}
+
+.has-background-info-05-invert {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-05-invert-l)) !important;
+}
+
+.has-text-info-10 {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-10-l)) !important;
+}
+
+.has-background-info-10 {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-10-l)) !important;
+}
+
+.has-text-info-10-invert {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-10-invert-l)) !important;
+}
+
+.has-background-info-10-invert {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-10-invert-l)) !important;
+}
+
+.has-text-info-15 {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-15-l)) !important;
+}
+
+.has-background-info-15 {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-15-l)) !important;
+}
+
+.has-text-info-15-invert {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-15-invert-l)) !important;
+}
+
+.has-background-info-15-invert {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-15-invert-l)) !important;
+}
+
+.has-text-info-20 {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-20-l)) !important;
+}
+
+.has-background-info-20 {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-20-l)) !important;
+}
+
+.has-text-info-20-invert {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-20-invert-l)) !important;
+}
+
+.has-background-info-20-invert {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-20-invert-l)) !important;
+}
+
+.has-text-info-25 {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-25-l)) !important;
+}
+
+.has-background-info-25 {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-25-l)) !important;
+}
+
+.has-text-info-25-invert {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-25-invert-l)) !important;
+}
+
+.has-background-info-25-invert {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-25-invert-l)) !important;
+}
+
+.has-text-info-30 {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-30-l)) !important;
+}
+
+.has-background-info-30 {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-30-l)) !important;
+}
+
+.has-text-info-30-invert {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-30-invert-l)) !important;
+}
+
+.has-background-info-30-invert {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-30-invert-l)) !important;
+}
+
+.has-text-info-35 {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-35-l)) !important;
+}
+
+.has-background-info-35 {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-35-l)) !important;
+}
+
+.has-text-info-35-invert {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-35-invert-l)) !important;
+}
+
+.has-background-info-35-invert {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-35-invert-l)) !important;
+}
+
+.has-text-info-40 {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-40-l)) !important;
+}
+
+.has-background-info-40 {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-40-l)) !important;
+}
+
+.has-text-info-40-invert {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-40-invert-l)) !important;
+}
+
+.has-background-info-40-invert {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-40-invert-l)) !important;
+}
+
+.has-text-info-45 {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-45-l)) !important;
+}
+
+.has-background-info-45 {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-45-l)) !important;
+}
+
+.has-text-info-45-invert {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-45-invert-l)) !important;
+}
+
+.has-background-info-45-invert {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-45-invert-l)) !important;
+}
+
+.has-text-info-50 {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-50-l)) !important;
+}
+
+.has-background-info-50 {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-50-l)) !important;
+}
+
+.has-text-info-50-invert {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-50-invert-l)) !important;
+}
+
+.has-background-info-50-invert {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-50-invert-l)) !important;
+}
+
+.has-text-info-55 {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-55-l)) !important;
+}
+
+.has-background-info-55 {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-55-l)) !important;
+}
+
+.has-text-info-55-invert {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-55-invert-l)) !important;
+}
+
+.has-background-info-55-invert {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-55-invert-l)) !important;
+}
+
+.has-text-info-60 {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-60-l)) !important;
+}
+
+.has-background-info-60 {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-60-l)) !important;
+}
+
+.has-text-info-60-invert {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-60-invert-l)) !important;
+}
+
+.has-background-info-60-invert {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-60-invert-l)) !important;
+}
+
+.has-text-info-65 {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-65-l)) !important;
+}
+
+.has-background-info-65 {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-65-l)) !important;
+}
+
+.has-text-info-65-invert {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-65-invert-l)) !important;
+}
+
+.has-background-info-65-invert {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-65-invert-l)) !important;
+}
+
+.has-text-info-70 {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-70-l)) !important;
+}
+
+.has-background-info-70 {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-70-l)) !important;
+}
+
+.has-text-info-70-invert {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-70-invert-l)) !important;
+}
+
+.has-background-info-70-invert {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-70-invert-l)) !important;
+}
+
+.has-text-info-75 {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-75-l)) !important;
+}
+
+.has-background-info-75 {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-75-l)) !important;
+}
+
+.has-text-info-75-invert {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-75-invert-l)) !important;
+}
+
+.has-background-info-75-invert {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-75-invert-l)) !important;
+}
+
+.has-text-info-80 {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-80-l)) !important;
+}
+
+.has-background-info-80 {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-80-l)) !important;
+}
+
+.has-text-info-80-invert {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-80-invert-l)) !important;
+}
+
+.has-background-info-80-invert {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-80-invert-l)) !important;
+}
+
+.has-text-info-85 {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-85-l)) !important;
+}
+
+.has-background-info-85 {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-85-l)) !important;
+}
+
+.has-text-info-85-invert {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-85-invert-l)) !important;
+}
+
+.has-background-info-85-invert {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-85-invert-l)) !important;
+}
+
+.has-text-info-90 {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-90-l)) !important;
+}
+
+.has-background-info-90 {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-90-l)) !important;
+}
+
+.has-text-info-90-invert {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-90-invert-l)) !important;
+}
+
+.has-background-info-90-invert {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-90-invert-l)) !important;
+}
+
+.has-text-info-95 {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-95-l)) !important;
+}
+
+.has-background-info-95 {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-95-l)) !important;
+}
+
+.has-text-info-95-invert {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-95-invert-l)) !important;
+}
+
+.has-background-info-95-invert {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-95-invert-l)) !important;
+}
+
+.has-text-info-100 {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-100-l)) !important;
+}
+
+.has-background-info-100 {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-100-l)) !important;
+}
+
+.has-text-info-100-invert {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-100-invert-l)) !important;
+}
+
+.has-background-info-100-invert {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), var(--bulma-info-100-invert-l)) !important;
+}
+
+a.has-text-info:hover, a.has-text-info:focus-visible,
+button.has-text-info:hover,
+button.has-text-info:focus-visible,
+has-text-info.is-hoverable:hover,
+has-text-info.is-hoverable:focus-visible {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), calc(var(--bulma-info-l) + var(--bulma-hover-color-l-delta))) !important;
+}
+a.has-text-info:active,
+button.has-text-info:active,
+has-text-info.is-hoverable:active {
+  color: hsl(var(--bulma-info-h), var(--bulma-info-s), calc(var(--bulma-info-l) + var(--bulma-active-color-l-delta))) !important;
+}
+
+a.has-background-info:hover, a.has-background-info:focus-visible,
+button.has-background-info:hover,
+button.has-background-info:focus-visible,
+has-background-info.is-hoverable:hover,
+has-background-info.is-hoverable:focus-visible {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), calc(var(--bulma-info-l) + var(--bulma-hover-background-l-delta))) !important;
+}
+a.has-background-info:active,
+button.has-background-info:active,
+has-background-info.is-hoverable:active {
+  background-color: hsl(var(--bulma-info-h), var(--bulma-info-s), calc(var(--bulma-info-l) + var(--bulma-active-background-l-delta))) !important;
+}
+
+.is-palette-info {
+  --h: var(--bulma-info-h);
+  --s: var(--bulma-info-s);
+  --l: var(--bulma-info-l);
+  --color: hsl(var(--h), var(--s), var(--l));
+  --00-l: var(--bulma-info-00-l);
+  --color-00: hsl(var(--h), var(--s), var(--00-l));
+  --05-l: var(--bulma-info-05-l);
+  --color-05: hsl(var(--h), var(--s), var(--05-l));
+  --10-l: var(--bulma-info-10-l);
+  --color-10: hsl(var(--h), var(--s), var(--10-l));
+  --15-l: var(--bulma-info-15-l);
+  --color-15: hsl(var(--h), var(--s), var(--15-l));
+  --20-l: var(--bulma-info-20-l);
+  --color-20: hsl(var(--h), var(--s), var(--20-l));
+  --25-l: var(--bulma-info-25-l);
+  --color-25: hsl(var(--h), var(--s), var(--25-l));
+  --30-l: var(--bulma-info-30-l);
+  --color-30: hsl(var(--h), var(--s), var(--30-l));
+  --35-l: var(--bulma-info-35-l);
+  --color-35: hsl(var(--h), var(--s), var(--35-l));
+  --40-l: var(--bulma-info-40-l);
+  --color-40: hsl(var(--h), var(--s), var(--40-l));
+  --45-l: var(--bulma-info-45-l);
+  --color-45: hsl(var(--h), var(--s), var(--45-l));
+  --50-l: var(--bulma-info-50-l);
+  --color-50: hsl(var(--h), var(--s), var(--50-l));
+  --55-l: var(--bulma-info-55-l);
+  --color-55: hsl(var(--h), var(--s), var(--55-l));
+  --60-l: var(--bulma-info-60-l);
+  --color-60: hsl(var(--h), var(--s), var(--60-l));
+  --65-l: var(--bulma-info-65-l);
+  --color-65: hsl(var(--h), var(--s), var(--65-l));
+  --70-l: var(--bulma-info-70-l);
+  --color-70: hsl(var(--h), var(--s), var(--70-l));
+  --75-l: var(--bulma-info-75-l);
+  --color-75: hsl(var(--h), var(--s), var(--75-l));
+  --80-l: var(--bulma-info-80-l);
+  --color-80: hsl(var(--h), var(--s), var(--80-l));
+  --85-l: var(--bulma-info-85-l);
+  --color-85: hsl(var(--h), var(--s), var(--85-l));
+  --90-l: var(--bulma-info-90-l);
+  --color-90: hsl(var(--h), var(--s), var(--90-l));
+  --95-l: var(--bulma-info-95-l);
+  --color-95: hsl(var(--h), var(--s), var(--95-l));
+  --100-l: var(--bulma-info-100-l);
+  --color-100: hsl(var(--h), var(--s), var(--100-l));
+}
+
+.has-text-success {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-l)) !important;
+}
+
+.has-background-success {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-l)) !important;
+}
+
+.has-text-success-invert {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-invert-l)) !important;
+}
+
+.has-background-success-invert {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-invert-l)) !important;
+}
+
+.has-text-success-on-scheme {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-on-scheme-l)) !important;
+}
+
+.has-background-success-on-scheme {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-on-scheme-l)) !important;
+}
+
+.has-text-success-light {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-light-l)) !important;
+}
+
+.has-background-success-light {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-light-l)) !important;
+}
+
+.has-text-success-light-invert {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-light-invert-l)) !important;
+}
+
+.has-background-success-light-invert {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-light-invert-l)) !important;
+}
+
+.has-text-success-dark {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-dark-l)) !important;
+}
+
+.has-background-success-dark {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-dark-l)) !important;
+}
+
+.has-text-success-dark-invert {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-dark-invert-l)) !important;
+}
+
+.has-background-success-dark-invert {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-dark-invert-l)) !important;
+}
+
+.has-text-success-soft {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-soft-l)) !important;
+}
+
+.has-background-success-soft {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-soft-l)) !important;
+}
+
+.has-text-success-bold {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-bold-l)) !important;
+}
+
+.has-background-success-bold {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-bold-l)) !important;
+}
+
+.has-text-success-soft-invert {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-soft-invert-l)) !important;
+}
+
+.has-background-success-soft-invert {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-soft-invert-l)) !important;
+}
+
+.has-text-success-bold-invert {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-bold-invert-l)) !important;
+}
+
+.has-background-success-bold-invert {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-bold-invert-l)) !important;
+}
+
+.has-text-success-00 {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-00-l)) !important;
+}
+
+.has-background-success-00 {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-00-l)) !important;
+}
+
+.has-text-success-00-invert {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-00-invert-l)) !important;
+}
+
+.has-background-success-00-invert {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-00-invert-l)) !important;
+}
+
+.has-text-success-05 {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-05-l)) !important;
+}
+
+.has-background-success-05 {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-05-l)) !important;
+}
+
+.has-text-success-05-invert {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-05-invert-l)) !important;
+}
+
+.has-background-success-05-invert {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-05-invert-l)) !important;
+}
+
+.has-text-success-10 {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-10-l)) !important;
+}
+
+.has-background-success-10 {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-10-l)) !important;
+}
+
+.has-text-success-10-invert {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-10-invert-l)) !important;
+}
+
+.has-background-success-10-invert {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-10-invert-l)) !important;
+}
+
+.has-text-success-15 {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-15-l)) !important;
+}
+
+.has-background-success-15 {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-15-l)) !important;
+}
+
+.has-text-success-15-invert {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-15-invert-l)) !important;
+}
+
+.has-background-success-15-invert {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-15-invert-l)) !important;
+}
+
+.has-text-success-20 {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-20-l)) !important;
+}
+
+.has-background-success-20 {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-20-l)) !important;
+}
+
+.has-text-success-20-invert {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-20-invert-l)) !important;
+}
+
+.has-background-success-20-invert {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-20-invert-l)) !important;
+}
+
+.has-text-success-25 {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-25-l)) !important;
+}
+
+.has-background-success-25 {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-25-l)) !important;
+}
+
+.has-text-success-25-invert {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-25-invert-l)) !important;
+}
+
+.has-background-success-25-invert {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-25-invert-l)) !important;
+}
+
+.has-text-success-30 {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-30-l)) !important;
+}
+
+.has-background-success-30 {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-30-l)) !important;
+}
+
+.has-text-success-30-invert {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-30-invert-l)) !important;
+}
+
+.has-background-success-30-invert {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-30-invert-l)) !important;
+}
+
+.has-text-success-35 {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-35-l)) !important;
+}
+
+.has-background-success-35 {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-35-l)) !important;
+}
+
+.has-text-success-35-invert {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-35-invert-l)) !important;
+}
+
+.has-background-success-35-invert {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-35-invert-l)) !important;
+}
+
+.has-text-success-40 {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-40-l)) !important;
+}
+
+.has-background-success-40 {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-40-l)) !important;
+}
+
+.has-text-success-40-invert {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-40-invert-l)) !important;
+}
+
+.has-background-success-40-invert {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-40-invert-l)) !important;
+}
+
+.has-text-success-45 {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-45-l)) !important;
+}
+
+.has-background-success-45 {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-45-l)) !important;
+}
+
+.has-text-success-45-invert {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-45-invert-l)) !important;
+}
+
+.has-background-success-45-invert {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-45-invert-l)) !important;
+}
+
+.has-text-success-50 {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-50-l)) !important;
+}
+
+.has-background-success-50 {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-50-l)) !important;
+}
+
+.has-text-success-50-invert {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-50-invert-l)) !important;
+}
+
+.has-background-success-50-invert {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-50-invert-l)) !important;
+}
+
+.has-text-success-55 {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-55-l)) !important;
+}
+
+.has-background-success-55 {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-55-l)) !important;
+}
+
+.has-text-success-55-invert {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-55-invert-l)) !important;
+}
+
+.has-background-success-55-invert {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-55-invert-l)) !important;
+}
+
+.has-text-success-60 {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-60-l)) !important;
+}
+
+.has-background-success-60 {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-60-l)) !important;
+}
+
+.has-text-success-60-invert {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-60-invert-l)) !important;
+}
+
+.has-background-success-60-invert {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-60-invert-l)) !important;
+}
+
+.has-text-success-65 {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-65-l)) !important;
+}
+
+.has-background-success-65 {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-65-l)) !important;
+}
+
+.has-text-success-65-invert {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-65-invert-l)) !important;
+}
+
+.has-background-success-65-invert {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-65-invert-l)) !important;
+}
+
+.has-text-success-70 {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-70-l)) !important;
+}
+
+.has-background-success-70 {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-70-l)) !important;
+}
+
+.has-text-success-70-invert {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-70-invert-l)) !important;
+}
+
+.has-background-success-70-invert {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-70-invert-l)) !important;
+}
+
+.has-text-success-75 {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-75-l)) !important;
+}
+
+.has-background-success-75 {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-75-l)) !important;
+}
+
+.has-text-success-75-invert {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-75-invert-l)) !important;
+}
+
+.has-background-success-75-invert {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-75-invert-l)) !important;
+}
+
+.has-text-success-80 {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-80-l)) !important;
+}
+
+.has-background-success-80 {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-80-l)) !important;
+}
+
+.has-text-success-80-invert {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-80-invert-l)) !important;
+}
+
+.has-background-success-80-invert {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-80-invert-l)) !important;
+}
+
+.has-text-success-85 {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-85-l)) !important;
+}
+
+.has-background-success-85 {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-85-l)) !important;
+}
+
+.has-text-success-85-invert {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-85-invert-l)) !important;
+}
+
+.has-background-success-85-invert {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-85-invert-l)) !important;
+}
+
+.has-text-success-90 {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-90-l)) !important;
+}
+
+.has-background-success-90 {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-90-l)) !important;
+}
+
+.has-text-success-90-invert {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-90-invert-l)) !important;
+}
+
+.has-background-success-90-invert {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-90-invert-l)) !important;
+}
+
+.has-text-success-95 {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-95-l)) !important;
+}
+
+.has-background-success-95 {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-95-l)) !important;
+}
+
+.has-text-success-95-invert {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-95-invert-l)) !important;
+}
+
+.has-background-success-95-invert {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-95-invert-l)) !important;
+}
+
+.has-text-success-100 {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-100-l)) !important;
+}
+
+.has-background-success-100 {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-100-l)) !important;
+}
+
+.has-text-success-100-invert {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-100-invert-l)) !important;
+}
+
+.has-background-success-100-invert {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), var(--bulma-success-100-invert-l)) !important;
+}
+
+a.has-text-success:hover, a.has-text-success:focus-visible,
+button.has-text-success:hover,
+button.has-text-success:focus-visible,
+has-text-success.is-hoverable:hover,
+has-text-success.is-hoverable:focus-visible {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), calc(var(--bulma-success-l) + var(--bulma-hover-color-l-delta))) !important;
+}
+a.has-text-success:active,
+button.has-text-success:active,
+has-text-success.is-hoverable:active {
+  color: hsl(var(--bulma-success-h), var(--bulma-success-s), calc(var(--bulma-success-l) + var(--bulma-active-color-l-delta))) !important;
+}
+
+a.has-background-success:hover, a.has-background-success:focus-visible,
+button.has-background-success:hover,
+button.has-background-success:focus-visible,
+has-background-success.is-hoverable:hover,
+has-background-success.is-hoverable:focus-visible {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), calc(var(--bulma-success-l) + var(--bulma-hover-background-l-delta))) !important;
+}
+a.has-background-success:active,
+button.has-background-success:active,
+has-background-success.is-hoverable:active {
+  background-color: hsl(var(--bulma-success-h), var(--bulma-success-s), calc(var(--bulma-success-l) + var(--bulma-active-background-l-delta))) !important;
+}
+
+.is-palette-success {
+  --h: var(--bulma-success-h);
+  --s: var(--bulma-success-s);
+  --l: var(--bulma-success-l);
+  --color: hsl(var(--h), var(--s), var(--l));
+  --00-l: var(--bulma-success-00-l);
+  --color-00: hsl(var(--h), var(--s), var(--00-l));
+  --05-l: var(--bulma-success-05-l);
+  --color-05: hsl(var(--h), var(--s), var(--05-l));
+  --10-l: var(--bulma-success-10-l);
+  --color-10: hsl(var(--h), var(--s), var(--10-l));
+  --15-l: var(--bulma-success-15-l);
+  --color-15: hsl(var(--h), var(--s), var(--15-l));
+  --20-l: var(--bulma-success-20-l);
+  --color-20: hsl(var(--h), var(--s), var(--20-l));
+  --25-l: var(--bulma-success-25-l);
+  --color-25: hsl(var(--h), var(--s), var(--25-l));
+  --30-l: var(--bulma-success-30-l);
+  --color-30: hsl(var(--h), var(--s), var(--30-l));
+  --35-l: var(--bulma-success-35-l);
+  --color-35: hsl(var(--h), var(--s), var(--35-l));
+  --40-l: var(--bulma-success-40-l);
+  --color-40: hsl(var(--h), var(--s), var(--40-l));
+  --45-l: var(--bulma-success-45-l);
+  --color-45: hsl(var(--h), var(--s), var(--45-l));
+  --50-l: var(--bulma-success-50-l);
+  --color-50: hsl(var(--h), var(--s), var(--50-l));
+  --55-l: var(--bulma-success-55-l);
+  --color-55: hsl(var(--h), var(--s), var(--55-l));
+  --60-l: var(--bulma-success-60-l);
+  --color-60: hsl(var(--h), var(--s), var(--60-l));
+  --65-l: var(--bulma-success-65-l);
+  --color-65: hsl(var(--h), var(--s), var(--65-l));
+  --70-l: var(--bulma-success-70-l);
+  --color-70: hsl(var(--h), var(--s), var(--70-l));
+  --75-l: var(--bulma-success-75-l);
+  --color-75: hsl(var(--h), var(--s), var(--75-l));
+  --80-l: var(--bulma-success-80-l);
+  --color-80: hsl(var(--h), var(--s), var(--80-l));
+  --85-l: var(--bulma-success-85-l);
+  --color-85: hsl(var(--h), var(--s), var(--85-l));
+  --90-l: var(--bulma-success-90-l);
+  --color-90: hsl(var(--h), var(--s), var(--90-l));
+  --95-l: var(--bulma-success-95-l);
+  --color-95: hsl(var(--h), var(--s), var(--95-l));
+  --100-l: var(--bulma-success-100-l);
+  --color-100: hsl(var(--h), var(--s), var(--100-l));
+}
+
+.has-text-warning {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-l)) !important;
+}
+
+.has-background-warning {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-l)) !important;
+}
+
+.has-text-warning-invert {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-invert-l)) !important;
+}
+
+.has-background-warning-invert {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-invert-l)) !important;
+}
+
+.has-text-warning-on-scheme {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-on-scheme-l)) !important;
+}
+
+.has-background-warning-on-scheme {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-on-scheme-l)) !important;
+}
+
+.has-text-warning-light {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-light-l)) !important;
+}
+
+.has-background-warning-light {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-light-l)) !important;
+}
+
+.has-text-warning-light-invert {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-light-invert-l)) !important;
+}
+
+.has-background-warning-light-invert {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-light-invert-l)) !important;
+}
+
+.has-text-warning-dark {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-dark-l)) !important;
+}
+
+.has-background-warning-dark {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-dark-l)) !important;
+}
+
+.has-text-warning-dark-invert {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-dark-invert-l)) !important;
+}
+
+.has-background-warning-dark-invert {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-dark-invert-l)) !important;
+}
+
+.has-text-warning-soft {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-soft-l)) !important;
+}
+
+.has-background-warning-soft {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-soft-l)) !important;
+}
+
+.has-text-warning-bold {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-bold-l)) !important;
+}
+
+.has-background-warning-bold {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-bold-l)) !important;
+}
+
+.has-text-warning-soft-invert {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-soft-invert-l)) !important;
+}
+
+.has-background-warning-soft-invert {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-soft-invert-l)) !important;
+}
+
+.has-text-warning-bold-invert {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-bold-invert-l)) !important;
+}
+
+.has-background-warning-bold-invert {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-bold-invert-l)) !important;
+}
+
+.has-text-warning-00 {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-00-l)) !important;
+}
+
+.has-background-warning-00 {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-00-l)) !important;
+}
+
+.has-text-warning-00-invert {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-00-invert-l)) !important;
+}
+
+.has-background-warning-00-invert {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-00-invert-l)) !important;
+}
+
+.has-text-warning-05 {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-05-l)) !important;
+}
+
+.has-background-warning-05 {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-05-l)) !important;
+}
+
+.has-text-warning-05-invert {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-05-invert-l)) !important;
+}
+
+.has-background-warning-05-invert {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-05-invert-l)) !important;
+}
+
+.has-text-warning-10 {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-10-l)) !important;
+}
+
+.has-background-warning-10 {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-10-l)) !important;
+}
+
+.has-text-warning-10-invert {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-10-invert-l)) !important;
+}
+
+.has-background-warning-10-invert {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-10-invert-l)) !important;
+}
+
+.has-text-warning-15 {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-15-l)) !important;
+}
+
+.has-background-warning-15 {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-15-l)) !important;
+}
+
+.has-text-warning-15-invert {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-15-invert-l)) !important;
+}
+
+.has-background-warning-15-invert {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-15-invert-l)) !important;
+}
+
+.has-text-warning-20 {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-20-l)) !important;
+}
+
+.has-background-warning-20 {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-20-l)) !important;
+}
+
+.has-text-warning-20-invert {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-20-invert-l)) !important;
+}
+
+.has-background-warning-20-invert {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-20-invert-l)) !important;
+}
+
+.has-text-warning-25 {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-25-l)) !important;
+}
+
+.has-background-warning-25 {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-25-l)) !important;
+}
+
+.has-text-warning-25-invert {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-25-invert-l)) !important;
+}
+
+.has-background-warning-25-invert {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-25-invert-l)) !important;
+}
+
+.has-text-warning-30 {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-30-l)) !important;
+}
+
+.has-background-warning-30 {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-30-l)) !important;
+}
+
+.has-text-warning-30-invert {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-30-invert-l)) !important;
+}
+
+.has-background-warning-30-invert {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-30-invert-l)) !important;
+}
+
+.has-text-warning-35 {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-35-l)) !important;
+}
+
+.has-background-warning-35 {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-35-l)) !important;
+}
+
+.has-text-warning-35-invert {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-35-invert-l)) !important;
+}
+
+.has-background-warning-35-invert {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-35-invert-l)) !important;
+}
+
+.has-text-warning-40 {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-40-l)) !important;
+}
+
+.has-background-warning-40 {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-40-l)) !important;
+}
+
+.has-text-warning-40-invert {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-40-invert-l)) !important;
+}
+
+.has-background-warning-40-invert {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-40-invert-l)) !important;
+}
+
+.has-text-warning-45 {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-45-l)) !important;
+}
+
+.has-background-warning-45 {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-45-l)) !important;
+}
+
+.has-text-warning-45-invert {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-45-invert-l)) !important;
+}
+
+.has-background-warning-45-invert {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-45-invert-l)) !important;
+}
+
+.has-text-warning-50 {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-50-l)) !important;
+}
+
+.has-background-warning-50 {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-50-l)) !important;
+}
+
+.has-text-warning-50-invert {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-50-invert-l)) !important;
+}
+
+.has-background-warning-50-invert {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-50-invert-l)) !important;
+}
+
+.has-text-warning-55 {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-55-l)) !important;
+}
+
+.has-background-warning-55 {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-55-l)) !important;
+}
+
+.has-text-warning-55-invert {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-55-invert-l)) !important;
+}
+
+.has-background-warning-55-invert {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-55-invert-l)) !important;
+}
+
+.has-text-warning-60 {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-60-l)) !important;
+}
+
+.has-background-warning-60 {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-60-l)) !important;
+}
+
+.has-text-warning-60-invert {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-60-invert-l)) !important;
+}
+
+.has-background-warning-60-invert {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-60-invert-l)) !important;
+}
+
+.has-text-warning-65 {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-65-l)) !important;
+}
+
+.has-background-warning-65 {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-65-l)) !important;
+}
+
+.has-text-warning-65-invert {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-65-invert-l)) !important;
+}
+
+.has-background-warning-65-invert {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-65-invert-l)) !important;
+}
+
+.has-text-warning-70 {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-70-l)) !important;
+}
+
+.has-background-warning-70 {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-70-l)) !important;
+}
+
+.has-text-warning-70-invert {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-70-invert-l)) !important;
+}
+
+.has-background-warning-70-invert {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-70-invert-l)) !important;
+}
+
+.has-text-warning-75 {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-75-l)) !important;
+}
+
+.has-background-warning-75 {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-75-l)) !important;
+}
+
+.has-text-warning-75-invert {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-75-invert-l)) !important;
+}
+
+.has-background-warning-75-invert {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-75-invert-l)) !important;
+}
+
+.has-text-warning-80 {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-80-l)) !important;
+}
+
+.has-background-warning-80 {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-80-l)) !important;
+}
+
+.has-text-warning-80-invert {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-80-invert-l)) !important;
+}
+
+.has-background-warning-80-invert {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-80-invert-l)) !important;
+}
+
+.has-text-warning-85 {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-85-l)) !important;
+}
+
+.has-background-warning-85 {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-85-l)) !important;
+}
+
+.has-text-warning-85-invert {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-85-invert-l)) !important;
+}
+
+.has-background-warning-85-invert {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-85-invert-l)) !important;
+}
+
+.has-text-warning-90 {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-90-l)) !important;
+}
+
+.has-background-warning-90 {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-90-l)) !important;
+}
+
+.has-text-warning-90-invert {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-90-invert-l)) !important;
+}
+
+.has-background-warning-90-invert {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-90-invert-l)) !important;
+}
+
+.has-text-warning-95 {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-95-l)) !important;
+}
+
+.has-background-warning-95 {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-95-l)) !important;
+}
+
+.has-text-warning-95-invert {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-95-invert-l)) !important;
+}
+
+.has-background-warning-95-invert {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-95-invert-l)) !important;
+}
+
+.has-text-warning-100 {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-100-l)) !important;
+}
+
+.has-background-warning-100 {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-100-l)) !important;
+}
+
+.has-text-warning-100-invert {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-100-invert-l)) !important;
+}
+
+.has-background-warning-100-invert {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), var(--bulma-warning-100-invert-l)) !important;
+}
+
+a.has-text-warning:hover, a.has-text-warning:focus-visible,
+button.has-text-warning:hover,
+button.has-text-warning:focus-visible,
+has-text-warning.is-hoverable:hover,
+has-text-warning.is-hoverable:focus-visible {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), calc(var(--bulma-warning-l) + var(--bulma-hover-color-l-delta))) !important;
+}
+a.has-text-warning:active,
+button.has-text-warning:active,
+has-text-warning.is-hoverable:active {
+  color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), calc(var(--bulma-warning-l) + var(--bulma-active-color-l-delta))) !important;
+}
+
+a.has-background-warning:hover, a.has-background-warning:focus-visible,
+button.has-background-warning:hover,
+button.has-background-warning:focus-visible,
+has-background-warning.is-hoverable:hover,
+has-background-warning.is-hoverable:focus-visible {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), calc(var(--bulma-warning-l) + var(--bulma-hover-background-l-delta))) !important;
+}
+a.has-background-warning:active,
+button.has-background-warning:active,
+has-background-warning.is-hoverable:active {
+  background-color: hsl(var(--bulma-warning-h), var(--bulma-warning-s), calc(var(--bulma-warning-l) + var(--bulma-active-background-l-delta))) !important;
+}
+
+.is-palette-warning {
+  --h: var(--bulma-warning-h);
+  --s: var(--bulma-warning-s);
+  --l: var(--bulma-warning-l);
+  --color: hsl(var(--h), var(--s), var(--l));
+  --00-l: var(--bulma-warning-00-l);
+  --color-00: hsl(var(--h), var(--s), var(--00-l));
+  --05-l: var(--bulma-warning-05-l);
+  --color-05: hsl(var(--h), var(--s), var(--05-l));
+  --10-l: var(--bulma-warning-10-l);
+  --color-10: hsl(var(--h), var(--s), var(--10-l));
+  --15-l: var(--bulma-warning-15-l);
+  --color-15: hsl(var(--h), var(--s), var(--15-l));
+  --20-l: var(--bulma-warning-20-l);
+  --color-20: hsl(var(--h), var(--s), var(--20-l));
+  --25-l: var(--bulma-warning-25-l);
+  --color-25: hsl(var(--h), var(--s), var(--25-l));
+  --30-l: var(--bulma-warning-30-l);
+  --color-30: hsl(var(--h), var(--s), var(--30-l));
+  --35-l: var(--bulma-warning-35-l);
+  --color-35: hsl(var(--h), var(--s), var(--35-l));
+  --40-l: var(--bulma-warning-40-l);
+  --color-40: hsl(var(--h), var(--s), var(--40-l));
+  --45-l: var(--bulma-warning-45-l);
+  --color-45: hsl(var(--h), var(--s), var(--45-l));
+  --50-l: var(--bulma-warning-50-l);
+  --color-50: hsl(var(--h), var(--s), var(--50-l));
+  --55-l: var(--bulma-warning-55-l);
+  --color-55: hsl(var(--h), var(--s), var(--55-l));
+  --60-l: var(--bulma-warning-60-l);
+  --color-60: hsl(var(--h), var(--s), var(--60-l));
+  --65-l: var(--bulma-warning-65-l);
+  --color-65: hsl(var(--h), var(--s), var(--65-l));
+  --70-l: var(--bulma-warning-70-l);
+  --color-70: hsl(var(--h), var(--s), var(--70-l));
+  --75-l: var(--bulma-warning-75-l);
+  --color-75: hsl(var(--h), var(--s), var(--75-l));
+  --80-l: var(--bulma-warning-80-l);
+  --color-80: hsl(var(--h), var(--s), var(--80-l));
+  --85-l: var(--bulma-warning-85-l);
+  --color-85: hsl(var(--h), var(--s), var(--85-l));
+  --90-l: var(--bulma-warning-90-l);
+  --color-90: hsl(var(--h), var(--s), var(--90-l));
+  --95-l: var(--bulma-warning-95-l);
+  --color-95: hsl(var(--h), var(--s), var(--95-l));
+  --100-l: var(--bulma-warning-100-l);
+  --color-100: hsl(var(--h), var(--s), var(--100-l));
+}
+
+.has-text-danger {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-l)) !important;
+}
+
+.has-background-danger {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-l)) !important;
+}
+
+.has-text-danger-invert {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-invert-l)) !important;
+}
+
+.has-background-danger-invert {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-invert-l)) !important;
+}
+
+.has-text-danger-on-scheme {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-on-scheme-l)) !important;
+}
+
+.has-background-danger-on-scheme {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-on-scheme-l)) !important;
+}
+
+.has-text-danger-light {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-light-l)) !important;
+}
+
+.has-background-danger-light {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-light-l)) !important;
+}
+
+.has-text-danger-light-invert {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-light-invert-l)) !important;
+}
+
+.has-background-danger-light-invert {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-light-invert-l)) !important;
+}
+
+.has-text-danger-dark {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-dark-l)) !important;
+}
+
+.has-background-danger-dark {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-dark-l)) !important;
+}
+
+.has-text-danger-dark-invert {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-dark-invert-l)) !important;
+}
+
+.has-background-danger-dark-invert {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-dark-invert-l)) !important;
+}
+
+.has-text-danger-soft {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-soft-l)) !important;
+}
+
+.has-background-danger-soft {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-soft-l)) !important;
+}
+
+.has-text-danger-bold {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-bold-l)) !important;
+}
+
+.has-background-danger-bold {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-bold-l)) !important;
+}
+
+.has-text-danger-soft-invert {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-soft-invert-l)) !important;
+}
+
+.has-background-danger-soft-invert {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-soft-invert-l)) !important;
+}
+
+.has-text-danger-bold-invert {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-bold-invert-l)) !important;
+}
+
+.has-background-danger-bold-invert {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-bold-invert-l)) !important;
+}
+
+.has-text-danger-00 {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-00-l)) !important;
+}
+
+.has-background-danger-00 {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-00-l)) !important;
+}
+
+.has-text-danger-00-invert {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-00-invert-l)) !important;
+}
+
+.has-background-danger-00-invert {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-00-invert-l)) !important;
+}
+
+.has-text-danger-05 {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-05-l)) !important;
+}
+
+.has-background-danger-05 {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-05-l)) !important;
+}
+
+.has-text-danger-05-invert {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-05-invert-l)) !important;
+}
+
+.has-background-danger-05-invert {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-05-invert-l)) !important;
+}
+
+.has-text-danger-10 {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-10-l)) !important;
+}
+
+.has-background-danger-10 {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-10-l)) !important;
+}
+
+.has-text-danger-10-invert {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-10-invert-l)) !important;
+}
+
+.has-background-danger-10-invert {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-10-invert-l)) !important;
+}
+
+.has-text-danger-15 {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-15-l)) !important;
+}
+
+.has-background-danger-15 {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-15-l)) !important;
+}
+
+.has-text-danger-15-invert {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-15-invert-l)) !important;
+}
+
+.has-background-danger-15-invert {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-15-invert-l)) !important;
+}
+
+.has-text-danger-20 {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-20-l)) !important;
+}
+
+.has-background-danger-20 {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-20-l)) !important;
+}
+
+.has-text-danger-20-invert {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-20-invert-l)) !important;
+}
+
+.has-background-danger-20-invert {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-20-invert-l)) !important;
+}
+
+.has-text-danger-25 {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-25-l)) !important;
+}
+
+.has-background-danger-25 {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-25-l)) !important;
+}
+
+.has-text-danger-25-invert {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-25-invert-l)) !important;
+}
+
+.has-background-danger-25-invert {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-25-invert-l)) !important;
+}
+
+.has-text-danger-30 {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-30-l)) !important;
+}
+
+.has-background-danger-30 {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-30-l)) !important;
+}
+
+.has-text-danger-30-invert {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-30-invert-l)) !important;
+}
+
+.has-background-danger-30-invert {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-30-invert-l)) !important;
+}
+
+.has-text-danger-35 {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-35-l)) !important;
+}
+
+.has-background-danger-35 {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-35-l)) !important;
+}
+
+.has-text-danger-35-invert {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-35-invert-l)) !important;
+}
+
+.has-background-danger-35-invert {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-35-invert-l)) !important;
+}
+
+.has-text-danger-40 {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-40-l)) !important;
+}
+
+.has-background-danger-40 {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-40-l)) !important;
+}
+
+.has-text-danger-40-invert {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-40-invert-l)) !important;
+}
+
+.has-background-danger-40-invert {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-40-invert-l)) !important;
+}
+
+.has-text-danger-45 {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-45-l)) !important;
+}
+
+.has-background-danger-45 {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-45-l)) !important;
+}
+
+.has-text-danger-45-invert {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-45-invert-l)) !important;
+}
+
+.has-background-danger-45-invert {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-45-invert-l)) !important;
+}
+
+.has-text-danger-50 {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-50-l)) !important;
+}
+
+.has-background-danger-50 {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-50-l)) !important;
+}
+
+.has-text-danger-50-invert {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-50-invert-l)) !important;
+}
+
+.has-background-danger-50-invert {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-50-invert-l)) !important;
+}
+
+.has-text-danger-55 {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-55-l)) !important;
+}
+
+.has-background-danger-55 {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-55-l)) !important;
+}
+
+.has-text-danger-55-invert {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-55-invert-l)) !important;
+}
+
+.has-background-danger-55-invert {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-55-invert-l)) !important;
+}
+
+.has-text-danger-60 {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-60-l)) !important;
+}
+
+.has-background-danger-60 {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-60-l)) !important;
+}
+
+.has-text-danger-60-invert {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-60-invert-l)) !important;
+}
+
+.has-background-danger-60-invert {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-60-invert-l)) !important;
+}
+
+.has-text-danger-65 {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-65-l)) !important;
+}
+
+.has-background-danger-65 {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-65-l)) !important;
+}
+
+.has-text-danger-65-invert {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-65-invert-l)) !important;
+}
+
+.has-background-danger-65-invert {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-65-invert-l)) !important;
+}
+
+.has-text-danger-70 {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-70-l)) !important;
+}
+
+.has-background-danger-70 {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-70-l)) !important;
+}
+
+.has-text-danger-70-invert {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-70-invert-l)) !important;
+}
+
+.has-background-danger-70-invert {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-70-invert-l)) !important;
+}
+
+.has-text-danger-75 {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-75-l)) !important;
+}
+
+.has-background-danger-75 {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-75-l)) !important;
+}
+
+.has-text-danger-75-invert {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-75-invert-l)) !important;
+}
+
+.has-background-danger-75-invert {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-75-invert-l)) !important;
+}
+
+.has-text-danger-80 {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-80-l)) !important;
+}
+
+.has-background-danger-80 {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-80-l)) !important;
+}
+
+.has-text-danger-80-invert {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-80-invert-l)) !important;
+}
+
+.has-background-danger-80-invert {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-80-invert-l)) !important;
+}
+
+.has-text-danger-85 {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-85-l)) !important;
+}
+
+.has-background-danger-85 {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-85-l)) !important;
+}
+
+.has-text-danger-85-invert {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-85-invert-l)) !important;
+}
+
+.has-background-danger-85-invert {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-85-invert-l)) !important;
+}
+
+.has-text-danger-90 {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-90-l)) !important;
+}
+
+.has-background-danger-90 {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-90-l)) !important;
+}
+
+.has-text-danger-90-invert {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-90-invert-l)) !important;
+}
+
+.has-background-danger-90-invert {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-90-invert-l)) !important;
+}
+
+.has-text-danger-95 {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-95-l)) !important;
+}
+
+.has-background-danger-95 {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-95-l)) !important;
+}
+
+.has-text-danger-95-invert {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-95-invert-l)) !important;
+}
+
+.has-background-danger-95-invert {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-95-invert-l)) !important;
+}
+
+.has-text-danger-100 {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-100-l)) !important;
+}
+
+.has-background-danger-100 {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-100-l)) !important;
+}
+
+.has-text-danger-100-invert {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-100-invert-l)) !important;
+}
+
+.has-background-danger-100-invert {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), var(--bulma-danger-100-invert-l)) !important;
+}
+
+a.has-text-danger:hover, a.has-text-danger:focus-visible,
+button.has-text-danger:hover,
+button.has-text-danger:focus-visible,
+has-text-danger.is-hoverable:hover,
+has-text-danger.is-hoverable:focus-visible {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), calc(var(--bulma-danger-l) + var(--bulma-hover-color-l-delta))) !important;
+}
+a.has-text-danger:active,
+button.has-text-danger:active,
+has-text-danger.is-hoverable:active {
+  color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), calc(var(--bulma-danger-l) + var(--bulma-active-color-l-delta))) !important;
+}
+
+a.has-background-danger:hover, a.has-background-danger:focus-visible,
+button.has-background-danger:hover,
+button.has-background-danger:focus-visible,
+has-background-danger.is-hoverable:hover,
+has-background-danger.is-hoverable:focus-visible {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), calc(var(--bulma-danger-l) + var(--bulma-hover-background-l-delta))) !important;
+}
+a.has-background-danger:active,
+button.has-background-danger:active,
+has-background-danger.is-hoverable:active {
+  background-color: hsl(var(--bulma-danger-h), var(--bulma-danger-s), calc(var(--bulma-danger-l) + var(--bulma-active-background-l-delta))) !important;
+}
+
+.is-palette-danger {
+  --h: var(--bulma-danger-h);
+  --s: var(--bulma-danger-s);
+  --l: var(--bulma-danger-l);
+  --color: hsl(var(--h), var(--s), var(--l));
+  --00-l: var(--bulma-danger-00-l);
+  --color-00: hsl(var(--h), var(--s), var(--00-l));
+  --05-l: var(--bulma-danger-05-l);
+  --color-05: hsl(var(--h), var(--s), var(--05-l));
+  --10-l: var(--bulma-danger-10-l);
+  --color-10: hsl(var(--h), var(--s), var(--10-l));
+  --15-l: var(--bulma-danger-15-l);
+  --color-15: hsl(var(--h), var(--s), var(--15-l));
+  --20-l: var(--bulma-danger-20-l);
+  --color-20: hsl(var(--h), var(--s), var(--20-l));
+  --25-l: var(--bulma-danger-25-l);
+  --color-25: hsl(var(--h), var(--s), var(--25-l));
+  --30-l: var(--bulma-danger-30-l);
+  --color-30: hsl(var(--h), var(--s), var(--30-l));
+  --35-l: var(--bulma-danger-35-l);
+  --color-35: hsl(var(--h), var(--s), var(--35-l));
+  --40-l: var(--bulma-danger-40-l);
+  --color-40: hsl(var(--h), var(--s), var(--40-l));
+  --45-l: var(--bulma-danger-45-l);
+  --color-45: hsl(var(--h), var(--s), var(--45-l));
+  --50-l: var(--bulma-danger-50-l);
+  --color-50: hsl(var(--h), var(--s), var(--50-l));
+  --55-l: var(--bulma-danger-55-l);
+  --color-55: hsl(var(--h), var(--s), var(--55-l));
+  --60-l: var(--bulma-danger-60-l);
+  --color-60: hsl(var(--h), var(--s), var(--60-l));
+  --65-l: var(--bulma-danger-65-l);
+  --color-65: hsl(var(--h), var(--s), var(--65-l));
+  --70-l: var(--bulma-danger-70-l);
+  --color-70: hsl(var(--h), var(--s), var(--70-l));
+  --75-l: var(--bulma-danger-75-l);
+  --color-75: hsl(var(--h), var(--s), var(--75-l));
+  --80-l: var(--bulma-danger-80-l);
+  --color-80: hsl(var(--h), var(--s), var(--80-l));
+  --85-l: var(--bulma-danger-85-l);
+  --color-85: hsl(var(--h), var(--s), var(--85-l));
+  --90-l: var(--bulma-danger-90-l);
+  --color-90: hsl(var(--h), var(--s), var(--90-l));
+  --95-l: var(--bulma-danger-95-l);
+  --color-95: hsl(var(--h), var(--s), var(--95-l));
+  --100-l: var(--bulma-danger-100-l);
+  --color-100: hsl(var(--h), var(--s), var(--100-l));
+}
+
+.has-text-black-bis {
+  color: hsl(221, 14%, 9%) !important;
+}
+
+.has-background-black-bis {
+  background-color: hsl(221, 14%, 9%) !important;
+}
+
+.has-text-black-ter {
+  color: hsl(221, 14%, 14%) !important;
+}
+
+.has-background-black-ter {
+  background-color: hsl(221, 14%, 14%) !important;
+}
+
+.has-text-grey-darker {
+  color: hsl(221, 14%, 21%) !important;
+}
+
+.has-background-grey-darker {
+  background-color: hsl(221, 14%, 21%) !important;
+}
+
+.has-text-grey-dark {
+  color: hsl(221, 14%, 29%) !important;
+}
+
+.has-background-grey-dark {
+  background-color: hsl(221, 14%, 29%) !important;
+}
+
+.has-text-grey {
+  color: hsl(221, 14%, 48%) !important;
+}
+
+.has-background-grey {
+  background-color: hsl(221, 14%, 48%) !important;
+}
+
+.has-text-grey-light {
+  color: hsl(221, 14%, 71%) !important;
+}
+
+.has-background-grey-light {
+  background-color: hsl(221, 14%, 71%) !important;
+}
+
+.has-text-grey-lighter {
+  color: hsl(221, 14%, 86%) !important;
+}
+
+.has-background-grey-lighter {
+  background-color: hsl(221, 14%, 86%) !important;
+}
+
+.has-text-white-ter {
+  color: hsl(221, 14%, 96%) !important;
+}
+
+.has-background-white-ter {
+  background-color: hsl(221, 14%, 96%) !important;
+}
+
+.has-text-white-bis {
+  color: hsl(221, 14%, 98%) !important;
+}
+
+.has-background-white-bis {
+  background-color: hsl(221, 14%, 98%) !important;
+}
+
+.has-text-current {
+  color: currentColor !important;
+}
+
+.has-text-inherit {
+  color: inherit !important;
+}
+
+.has-background-current {
+  background-color: currentColor !important;
+}
+
+.has-background-inherit {
+  background-color: inherit !important;
+}
+
+.is-flex-direction-row {
+  flex-direction: row !important;
+}
+
+.is-flex-direction-row-reverse {
+  flex-direction: row-reverse !important;
+}
+
+.is-flex-direction-column {
+  flex-direction: column !important;
+}
+
+.is-flex-direction-column-reverse {
+  flex-direction: column-reverse !important;
+}
+
+.is-flex-wrap-nowrap {
+  flex-wrap: nowrap !important;
+}
+
+.is-flex-wrap-wrap {
+  flex-wrap: wrap !important;
+}
+
+.is-flex-wrap-wrap-reverse {
+  flex-wrap: wrap-reverse !important;
+}
+
+.is-justify-content-flex-start {
+  justify-content: flex-start !important;
+}
+
+.is-justify-content-flex-end {
+  justify-content: flex-end !important;
+}
+
+.is-justify-content-center {
+  justify-content: center !important;
+}
+
+.is-justify-content-space-between {
+  justify-content: space-between !important;
+}
+
+.is-justify-content-space-around {
+  justify-content: space-around !important;
+}
+
+.is-justify-content-space-evenly {
+  justify-content: space-evenly !important;
+}
+
+.is-justify-content-start {
+  justify-content: start !important;
+}
+
+.is-justify-content-end {
+  justify-content: end !important;
+}
+
+.is-justify-content-left {
+  justify-content: left !important;
+}
+
+.is-justify-content-right {
+  justify-content: right !important;
+}
+
+.is-align-content-flex-start {
+  align-content: flex-start !important;
+}
+
+.is-align-content-flex-end {
+  align-content: flex-end !important;
+}
+
+.is-align-content-center {
+  align-content: center !important;
+}
+
+.is-align-content-space-between {
+  align-content: space-between !important;
+}
+
+.is-align-content-space-around {
+  align-content: space-around !important;
+}
+
+.is-align-content-space-evenly {
+  align-content: space-evenly !important;
+}
+
+.is-align-content-stretch {
+  align-content: stretch !important;
+}
+
+.is-align-content-start {
+  align-content: start !important;
+}
+
+.is-align-content-end {
+  align-content: end !important;
+}
+
+.is-align-content-baseline {
+  align-content: baseline !important;
+}
+
+.is-align-items-stretch {
+  align-items: stretch !important;
+}
+
+.is-align-items-flex-start {
+  align-items: flex-start !important;
+}
+
+.is-align-items-flex-end {
+  align-items: flex-end !important;
+}
+
+.is-align-items-center {
+  align-items: center !important;
+}
+
+.is-align-items-baseline {
+  align-items: baseline !important;
+}
+
+.is-align-items-start {
+  align-items: start !important;
+}
+
+.is-align-items-end {
+  align-items: end !important;
+}
+
+.is-align-items-self-start {
+  align-items: self-start !important;
+}
+
+.is-align-items-self-end {
+  align-items: self-end !important;
+}
+
+.is-align-self-auto {
+  align-self: auto !important;
+}
+
+.is-align-self-flex-start {
+  align-self: flex-start !important;
+}
+
+.is-align-self-flex-end {
+  align-self: flex-end !important;
+}
+
+.is-align-self-center {
+  align-self: center !important;
+}
+
+.is-align-self-baseline {
+  align-self: baseline !important;
+}
+
+.is-align-self-stretch {
+  align-self: stretch !important;
+}
+
+.is-flex-grow-0 {
+  flex-grow: 0 !important;
+}
+
+.is-flex-grow-1 {
+  flex-grow: 1 !important;
+}
+
+.is-flex-grow-2 {
+  flex-grow: 2 !important;
+}
+
+.is-flex-grow-3 {
+  flex-grow: 3 !important;
+}
+
+.is-flex-grow-4 {
+  flex-grow: 4 !important;
+}
+
+.is-flex-grow-5 {
+  flex-grow: 5 !important;
+}
+
+.is-flex-shrink-0 {
+  flex-shrink: 0 !important;
+}
+
+.is-flex-shrink-1 {
+  flex-shrink: 1 !important;
+}
+
+.is-flex-shrink-2 {
+  flex-shrink: 2 !important;
+}
+
+.is-flex-shrink-3 {
+  flex-shrink: 3 !important;
+}
+
+.is-flex-shrink-4 {
+  flex-shrink: 4 !important;
+}
+
+.is-flex-shrink-5 {
+  flex-shrink: 5 !important;
+}
+
+.is-clearfix::after {
+  clear: both;
+  content: " ";
+  display: table;
+}
+
+.is-float-left,
+.is-pulled-left {
+  float: left !important;
+}
+
+.is-float-right,
+.is-pulled-right {
+  float: right !important;
+}
+
+.is-float-none {
+  float: none !important;
+}
+
+.is-clear-both {
+  clear: both !important;
+}
+
+.is-clear-left {
+  clear: left !important;
+}
+
+.is-clear-none {
+  clear: none !important;
+}
+
+.is-clear-right {
+  clear: right !important;
+}
+
+.is-gapless {
+  gap: 0 !important;
+}
+
+.is-gap-0 {
+  gap: 0rem !important;
+}
+
+.is-gap-0\.5 {
+  gap: 0.25rem !important;
+}
+
+.is-gap-1 {
+  gap: 0.5rem !important;
+}
+
+.is-gap-1\.5 {
+  gap: 0.75rem !important;
+}
+
+.is-gap-2 {
+  gap: 1rem !important;
+}
+
+.is-gap-2\.5 {
+  gap: 1.25rem !important;
+}
+
+.is-gap-3 {
+  gap: 1.5rem !important;
+}
+
+.is-gap-3\.5 {
+  gap: 1.75rem !important;
+}
+
+.is-gap-4 {
+  gap: 2rem !important;
+}
+
+.is-gap-4\.5 {
+  gap: 2.25rem !important;
+}
+
+.is-gap-5 {
+  gap: 2.5rem !important;
+}
+
+.is-gap-5\.5 {
+  gap: 2.75rem !important;
+}
+
+.is-gap-6 {
+  gap: 3rem !important;
+}
+
+.is-gap-6\.5 {
+  gap: 3.25rem !important;
+}
+
+.is-gap-7 {
+  gap: 3.5rem !important;
+}
+
+.is-gap-7\.5 {
+  gap: 3.75rem !important;
+}
+
+.is-gap-8 {
+  gap: 4rem !important;
+}
+
+.is-column-gap-0 {
+  column-gap: 0rem !important;
+}
+
+.is-column-gap-0\.5 {
+  column-gap: 0.25rem !important;
+}
+
+.is-column-gap-1 {
+  column-gap: 0.5rem !important;
+}
+
+.is-column-gap-1\.5 {
+  column-gap: 0.75rem !important;
+}
+
+.is-column-gap-2 {
+  column-gap: 1rem !important;
+}
+
+.is-column-gap-2\.5 {
+  column-gap: 1.25rem !important;
+}
+
+.is-column-gap-3 {
+  column-gap: 1.5rem !important;
+}
+
+.is-column-gap-3\.5 {
+  column-gap: 1.75rem !important;
+}
+
+.is-column-gap-4 {
+  column-gap: 2rem !important;
+}
+
+.is-column-gap-4\.5 {
+  column-gap: 2.25rem !important;
+}
+
+.is-column-gap-5 {
+  column-gap: 2.5rem !important;
+}
+
+.is-column-gap-5\.5 {
+  column-gap: 2.75rem !important;
+}
+
+.is-column-gap-6 {
+  column-gap: 3rem !important;
+}
+
+.is-column-gap-6\.5 {
+  column-gap: 3.25rem !important;
+}
+
+.is-column-gap-7 {
+  column-gap: 3.5rem !important;
+}
+
+.is-column-gap-7\.5 {
+  column-gap: 3.75rem !important;
+}
+
+.is-column-gap-8 {
+  column-gap: 4rem !important;
+}
+
+.is-row-gap-0 {
+  row-gap: 0rem !important;
+}
+
+.is-row-gap-0\.5 {
+  row-gap: 0.25rem !important;
+}
+
+.is-row-gap-1 {
+  row-gap: 0.5rem !important;
+}
+
+.is-row-gap-1\.5 {
+  row-gap: 0.75rem !important;
+}
+
+.is-row-gap-2 {
+  row-gap: 1rem !important;
+}
+
+.is-row-gap-2\.5 {
+  row-gap: 1.25rem !important;
+}
+
+.is-row-gap-3 {
+  row-gap: 1.5rem !important;
+}
+
+.is-row-gap-3\.5 {
+  row-gap: 1.75rem !important;
+}
+
+.is-row-gap-4 {
+  row-gap: 2rem !important;
+}
+
+.is-row-gap-4\.5 {
+  row-gap: 2.25rem !important;
+}
+
+.is-row-gap-5 {
+  row-gap: 2.5rem !important;
+}
+
+.is-row-gap-5\.5 {
+  row-gap: 2.75rem !important;
+}
+
+.is-row-gap-6 {
+  row-gap: 3rem !important;
+}
+
+.is-row-gap-6\.5 {
+  row-gap: 3.25rem !important;
+}
+
+.is-row-gap-7 {
+  row-gap: 3.5rem !important;
+}
+
+.is-row-gap-7\.5 {
+  row-gap: 3.75rem !important;
+}
+
+.is-row-gap-8 {
+  row-gap: 4rem !important;
+}
+
+.is-clipped {
+  overflow: hidden !important;
+}
+
+.is-overflow-auto {
+  overflow: auto !important;
+}
+
+.is-overflow-x-auto {
+  overflow-x: auto !important;
+}
+
+.is-overflow-y-auto {
+  overflow-y: auto !important;
+}
+
+.is-overflow-clip {
+  overflow: clip !important;
+}
+
+.is-overflow-x-clip {
+  overflow-x: clip !important;
+}
+
+.is-overflow-y-clip {
+  overflow-y: clip !important;
+}
+
+.is-overflow-hidden {
+  overflow: hidden !important;
+}
+
+.is-overflow-x-hidden {
+  overflow-x: hidden !important;
+}
+
+.is-overflow-y-hidden {
+  overflow-y: hidden !important;
+}
+
+.is-overflow-scroll {
+  overflow: scroll !important;
+}
+
+.is-overflow-x-scroll {
+  overflow-x: scroll !important;
+}
+
+.is-overflow-y-scroll {
+  overflow-y: scroll !important;
+}
+
+.is-overflow-visible {
+  overflow: visible !important;
+}
+
+.is-overflow-x-visible {
+  overflow-x: visible !important;
+}
+
+.is-overflow-y-visible {
+  overflow-y: visible !important;
+}
+
+.is-relative {
+  position: relative !important;
+}
+
+.is-position-absolute {
+  position: absolute !important;
+}
+
+.is-position-fixed {
+  position: fixed !important;
+}
+
+.is-position-relative {
+  position: relative !important;
+}
+
+.is-position-static {
+  position: static !important;
+}
+
+.is-position-sticky {
+  position: sticky !important;
+}
+
+.marginless {
+  margin: 0 !important;
+}
+
+.paddingless {
+  padding: 0 !important;
+}
+
+.m-0 {
+  margin: 0 !important;
+}
+
+.mt-0 {
+  margin-top: 0 !important;
+}
+
+.mr-0 {
+  margin-right: 0 !important;
+}
+
+.mb-0 {
+  margin-bottom: 0 !important;
+}
+
+.ml-0 {
+  margin-left: 0 !important;
+}
+
+.mx-0 {
+  margin-left: 0 !important;
+  margin-right: 0 !important;
+}
+
+.my-0 {
+  margin-top: 0 !important;
+  margin-bottom: 0 !important;
+}
+
+.m-1 {
+  margin: 0.25rem !important;
+}
+
+.mt-1 {
+  margin-top: 0.25rem !important;
+}
+
+.mr-1 {
+  margin-right: 0.25rem !important;
+}
+
+.mb-1 {
+  margin-bottom: 0.25rem !important;
+}
+
+.ml-1 {
+  margin-left: 0.25rem !important;
+}
+
+.mx-1 {
+  margin-left: 0.25rem !important;
+  margin-right: 0.25rem !important;
+}
+
+.my-1 {
+  margin-top: 0.25rem !important;
+  margin-bottom: 0.25rem !important;
+}
+
+.m-2 {
+  margin: 0.5rem !important;
+}
+
+.mt-2 {
+  margin-top: 0.5rem !important;
+}
+
+.mr-2 {
+  margin-right: 0.5rem !important;
+}
+
+.mb-2 {
+  margin-bottom: 0.5rem !important;
+}
+
+.ml-2 {
+  margin-left: 0.5rem !important;
+}
+
+.mx-2 {
+  margin-left: 0.5rem !important;
+  margin-right: 0.5rem !important;
+}
+
+.my-2 {
+  margin-top: 0.5rem !important;
+  margin-bottom: 0.5rem !important;
+}
+
+.m-3 {
+  margin: 0.75rem !important;
+}
+
+.mt-3 {
+  margin-top: 0.75rem !important;
+}
+
+.mr-3 {
+  margin-right: 0.75rem !important;
+}
+
+.mb-3 {
+  margin-bottom: 0.75rem !important;
+}
+
+.ml-3 {
+  margin-left: 0.75rem !important;
+}
+
+.mx-3 {
+  margin-left: 0.75rem !important;
+  margin-right: 0.75rem !important;
+}
+
+.my-3 {
+  margin-top: 0.75rem !important;
+  margin-bottom: 0.75rem !important;
+}
+
+.m-4 {
+  margin: 1rem !important;
+}
+
+.mt-4 {
+  margin-top: 1rem !important;
+}
+
+.mr-4 {
+  margin-right: 1rem !important;
+}
+
+.mb-4 {
+  margin-bottom: 1rem !important;
+}
+
+.ml-4 {
+  margin-left: 1rem !important;
+}
+
+.mx-4 {
+  margin-left: 1rem !important;
+  margin-right: 1rem !important;
+}
+
+.my-4 {
+  margin-top: 1rem !important;
+  margin-bottom: 1rem !important;
+}
+
+.m-5 {
+  margin: 1.5rem !important;
+}
+
+.mt-5 {
+  margin-top: 1.5rem !important;
+}
+
+.mr-5 {
+  margin-right: 1.5rem !important;
+}
+
+.mb-5 {
+  margin-bottom: 1.5rem !important;
+}
+
+.ml-5 {
+  margin-left: 1.5rem !important;
+}
+
+.mx-5 {
+  margin-left: 1.5rem !important;
+  margin-right: 1.5rem !important;
+}
+
+.my-5 {
+  margin-top: 1.5rem !important;
+  margin-bottom: 1.5rem !important;
+}
+
+.m-6 {
+  margin: 3rem !important;
+}
+
+.mt-6 {
+  margin-top: 3rem !important;
+}
+
+.mr-6 {
+  margin-right: 3rem !important;
+}
+
+.mb-6 {
+  margin-bottom: 3rem !important;
+}
+
+.ml-6 {
+  margin-left: 3rem !important;
+}
+
+.mx-6 {
+  margin-left: 3rem !important;
+  margin-right: 3rem !important;
+}
+
+.my-6 {
+  margin-top: 3rem !important;
+  margin-bottom: 3rem !important;
+}
+
+.m-auto {
+  margin: auto !important;
+}
+
+.mt-auto {
+  margin-top: auto !important;
+}
+
+.mr-auto {
+  margin-right: auto !important;
+}
+
+.mb-auto {
+  margin-bottom: auto !important;
+}
+
+.ml-auto {
+  margin-left: auto !important;
+}
+
+.mx-auto {
+  margin-left: auto !important;
+  margin-right: auto !important;
+}
+
+.my-auto {
+  margin-top: auto !important;
+  margin-bottom: auto !important;
+}
+
+.p-0 {
+  padding: 0 !important;
+}
+
+.pt-0 {
+  padding-top: 0 !important;
+}
+
+.pr-0 {
+  padding-right: 0 !important;
+}
+
+.pb-0 {
+  padding-bottom: 0 !important;
+}
+
+.pl-0 {
+  padding-left: 0 !important;
+}
+
+.px-0 {
+  padding-left: 0 !important;
+  padding-right: 0 !important;
+}
+
+.py-0 {
+  padding-top: 0 !important;
+  padding-bottom: 0 !important;
+}
+
+.p-1 {
+  padding: 0.25rem !important;
+}
+
+.pt-1 {
+  padding-top: 0.25rem !important;
+}
+
+.pr-1 {
+  padding-right: 0.25rem !important;
+}
+
+.pb-1 {
+  padding-bottom: 0.25rem !important;
+}
+
+.pl-1 {
+  padding-left: 0.25rem !important;
+}
+
+.px-1 {
+  padding-left: 0.25rem !important;
+  padding-right: 0.25rem !important;
+}
+
+.py-1 {
+  padding-top: 0.25rem !important;
+  padding-bottom: 0.25rem !important;
+}
+
+.p-2 {
+  padding: 0.5rem !important;
+}
+
+.pt-2 {
+  padding-top: 0.5rem !important;
+}
+
+.pr-2 {
+  padding-right: 0.5rem !important;
+}
+
+.pb-2 {
+  padding-bottom: 0.5rem !important;
+}
+
+.pl-2 {
+  padding-left: 0.5rem !important;
+}
+
+.px-2 {
+  padding-left: 0.5rem !important;
+  padding-right: 0.5rem !important;
+}
+
+.py-2 {
+  padding-top: 0.5rem !important;
+  padding-bottom: 0.5rem !important;
+}
+
+.p-3 {
+  padding: 0.75rem !important;
+}
+
+.pt-3 {
+  padding-top: 0.75rem !important;
+}
+
+.pr-3 {
+  padding-right: 0.75rem !important;
+}
+
+.pb-3 {
+  padding-bottom: 0.75rem !important;
+}
+
+.pl-3 {
+  padding-left: 0.75rem !important;
+}
+
+.px-3 {
+  padding-left: 0.75rem !important;
+  padding-right: 0.75rem !important;
+}
+
+.py-3 {
+  padding-top: 0.75rem !important;
+  padding-bottom: 0.75rem !important;
+}
+
+.p-4 {
+  padding: 1rem !important;
+}
+
+.pt-4 {
+  padding-top: 1rem !important;
+}
+
+.pr-4 {
+  padding-right: 1rem !important;
+}
+
+.pb-4 {
+  padding-bottom: 1rem !important;
+}
+
+.pl-4 {
+  padding-left: 1rem !important;
+}
+
+.px-4 {
+  padding-left: 1rem !important;
+  padding-right: 1rem !important;
+}
+
+.py-4 {
+  padding-top: 1rem !important;
+  padding-bottom: 1rem !important;
+}
+
+.p-5 {
+  padding: 1.5rem !important;
+}
+
+.pt-5 {
+  padding-top: 1.5rem !important;
+}
+
+.pr-5 {
+  padding-right: 1.5rem !important;
+}
+
+.pb-5 {
+  padding-bottom: 1.5rem !important;
+}
+
+.pl-5 {
+  padding-left: 1.5rem !important;
+}
+
+.px-5 {
+  padding-left: 1.5rem !important;
+  padding-right: 1.5rem !important;
+}
+
+.py-5 {
+  padding-top: 1.5rem !important;
+  padding-bottom: 1.5rem !important;
+}
+
+.p-6 {
+  padding: 3rem !important;
+}
+
+.pt-6 {
+  padding-top: 3rem !important;
+}
+
+.pr-6 {
+  padding-right: 3rem !important;
+}
+
+.pb-6 {
+  padding-bottom: 3rem !important;
+}
+
+.pl-6 {
+  padding-left: 3rem !important;
+}
+
+.px-6 {
+  padding-left: 3rem !important;
+  padding-right: 3rem !important;
+}
+
+.py-6 {
+  padding-top: 3rem !important;
+  padding-bottom: 3rem !important;
+}
+
+.p-auto {
+  padding: auto !important;
+}
+
+.pt-auto {
+  padding-top: auto !important;
+}
+
+.pr-auto {
+  padding-right: auto !important;
+}
+
+.pb-auto {
+  padding-bottom: auto !important;
+}
+
+.pl-auto {
+  padding-left: auto !important;
+}
+
+.px-auto {
+  padding-left: auto !important;
+  padding-right: auto !important;
+}
+
+.py-auto {
+  padding-top: auto !important;
+  padding-bottom: auto !important;
+}
+
+.is-size-1 {
+  font-size: 3rem !important;
+}
+
+.is-size-2 {
+  font-size: 2.5rem !important;
+}
+
+.is-size-3 {
+  font-size: 2rem !important;
+}
+
+.is-size-4 {
+  font-size: 1.5rem !important;
+}
+
+.is-size-5 {
+  font-size: 1.25rem !important;
+}
+
+.is-size-6 {
+  font-size: 1rem !important;
+}
+
+.is-size-7 {
+  font-size: 0.75rem !important;
+}
+
+@media screen and (max-width: 768px) {
+  .is-size-1-mobile {
+    font-size: 3rem !important;
+  }
+  .is-size-2-mobile {
+    font-size: 2.5rem !important;
+  }
+  .is-size-3-mobile {
+    font-size: 2rem !important;
+  }
+  .is-size-4-mobile {
+    font-size: 1.5rem !important;
+  }
+  .is-size-5-mobile {
+    font-size: 1.25rem !important;
+  }
+  .is-size-6-mobile {
+    font-size: 1rem !important;
+  }
+  .is-size-7-mobile {
+    font-size: 0.75rem !important;
+  }
+}
+@media screen and (min-width: 769px), print {
+  .is-size-1-tablet {
+    font-size: 3rem !important;
+  }
+  .is-size-2-tablet {
+    font-size: 2.5rem !important;
+  }
+  .is-size-3-tablet {
+    font-size: 2rem !important;
+  }
+  .is-size-4-tablet {
+    font-size: 1.5rem !important;
+  }
+  .is-size-5-tablet {
+    font-size: 1.25rem !important;
+  }
+  .is-size-6-tablet {
+    font-size: 1rem !important;
+  }
+  .is-size-7-tablet {
+    font-size: 0.75rem !important;
+  }
+}
+@media screen and (max-width: 1023px) {
+  .is-size-1-touch {
+    font-size: 3rem !important;
+  }
+  .is-size-2-touch {
+    font-size: 2.5rem !important;
+  }
+  .is-size-3-touch {
+    font-size: 2rem !important;
+  }
+  .is-size-4-touch {
+    font-size: 1.5rem !important;
+  }
+  .is-size-5-touch {
+    font-size: 1.25rem !important;
+  }
+  .is-size-6-touch {
+    font-size: 1rem !important;
+  }
+  .is-size-7-touch {
+    font-size: 0.75rem !important;
+  }
+}
+@media screen and (min-width: 1024px) {
+  .is-size-1-desktop {
+    font-size: 3rem !important;
+  }
+  .is-size-2-desktop {
+    font-size: 2.5rem !important;
+  }
+  .is-size-3-desktop {
+    font-size: 2rem !important;
+  }
+  .is-size-4-desktop {
+    font-size: 1.5rem !important;
+  }
+  .is-size-5-desktop {
+    font-size: 1.25rem !important;
+  }
+  .is-size-6-desktop {
+    font-size: 1rem !important;
+  }
+  .is-size-7-desktop {
+    font-size: 0.75rem !important;
+  }
+}
+@media screen and (min-width: 1216px) {
+  .is-size-1-widescreen {
+    font-size: 3rem !important;
+  }
+  .is-size-2-widescreen {
+    font-size: 2.5rem !important;
+  }
+  .is-size-3-widescreen {
+    font-size: 2rem !important;
+  }
+  .is-size-4-widescreen {
+    font-size: 1.5rem !important;
+  }
+  .is-size-5-widescreen {
+    font-size: 1.25rem !important;
+  }
+  .is-size-6-widescreen {
+    font-size: 1rem !important;
+  }
+  .is-size-7-widescreen {
+    font-size: 0.75rem !important;
+  }
+}
+@media screen and (min-width: 1408px) {
+  .is-size-1-fullhd {
+    font-size: 3rem !important;
+  }
+  .is-size-2-fullhd {
+    font-size: 2.5rem !important;
+  }
+  .is-size-3-fullhd {
+    font-size: 2rem !important;
+  }
+  .is-size-4-fullhd {
+    font-size: 1.5rem !important;
+  }
+  .is-size-5-fullhd {
+    font-size: 1.25rem !important;
+  }
+  .is-size-6-fullhd {
+    font-size: 1rem !important;
+  }
+  .is-size-7-fullhd {
+    font-size: 0.75rem !important;
+  }
+}
+.has-text-centered {
+  text-align: center !important;
+}
+
+.has-text-justified {
+  text-align: justify !important;
+}
+
+.has-text-left {
+  text-align: left !important;
+}
+
+.has-text-right {
+  text-align: right !important;
+}
+
+@media screen and (max-width: 768px) {
+  .has-text-centered-mobile {
+    text-align: center !important;
+  }
+}
+@media screen and (min-width: 769px), print {
+  .has-text-centered-tablet {
+    text-align: center !important;
+  }
+}
+@media screen and (min-width: 769px) and (max-width: 1023px) {
+  .has-text-centered-tablet-only {
+    text-align: center !important;
+  }
+}
+@media screen and (max-width: 1023px) {
+  .has-text-centered-touch {
+    text-align: center !important;
+  }
+}
+@media screen and (min-width: 1024px) {
+  .has-text-centered-desktop {
+    text-align: center !important;
+  }
+}
+@media screen and (min-width: 1024px) and (max-width: 1215px) {
+  .has-text-centered-desktop-only {
+    text-align: center !important;
+  }
+}
+@media screen and (min-width: 1216px) {
+  .has-text-centered-widescreen {
+    text-align: center !important;
+  }
+}
+@media screen and (min-width: 1216px) and (max-width: 1407px) {
+  .has-text-centered-widescreen-only {
+    text-align: center !important;
+  }
+}
+@media screen and (min-width: 1408px) {
+  .has-text-centered-fullhd {
+    text-align: center !important;
+  }
+}
+@media screen and (max-width: 768px) {
+  .has-text-justified-mobile {
+    text-align: justify !important;
+  }
+}
+@media screen and (min-width: 769px), print {
+  .has-text-justified-tablet {
+    text-align: justify !important;
+  }
+}
+@media screen and (min-width: 769px) and (max-width: 1023px) {
+  .has-text-justified-tablet-only {
+    text-align: justify !important;
+  }
+}
+@media screen and (max-width: 1023px) {
+  .has-text-justified-touch {
+    text-align: justify !important;
+  }
+}
+@media screen and (min-width: 1024px) {
+  .has-text-justified-desktop {
+    text-align: justify !important;
+  }
+}
+@media screen and (min-width: 1024px) and (max-width: 1215px) {
+  .has-text-justified-desktop-only {
+    text-align: justify !important;
+  }
+}
+@media screen and (min-width: 1216px) {
+  .has-text-justified-widescreen {
+    text-align: justify !important;
+  }
+}
+@media screen and (min-width: 1216px) and (max-width: 1407px) {
+  .has-text-justified-widescreen-only {
+    text-align: justify !important;
+  }
+}
+@media screen and (min-width: 1408px) {
+  .has-text-justified-fullhd {
+    text-align: justify !important;
+  }
+}
+@media screen and (max-width: 768px) {
+  .has-text-left-mobile {
+    text-align: left !important;
+  }
+}
+@media screen and (min-width: 769px), print {
+  .has-text-left-tablet {
+    text-align: left !important;
+  }
+}
+@media screen and (min-width: 769px) and (max-width: 1023px) {
+  .has-text-left-tablet-only {
+    text-align: left !important;
+  }
+}
+@media screen and (max-width: 1023px) {
+  .has-text-left-touch {
+    text-align: left !important;
+  }
+}
+@media screen and (min-width: 1024px) {
+  .has-text-left-desktop {
+    text-align: left !important;
+  }
+}
+@media screen and (min-width: 1024px) and (max-width: 1215px) {
+  .has-text-left-desktop-only {
+    text-align: left !important;
+  }
+}
+@media screen and (min-width: 1216px) {
+  .has-text-left-widescreen {
+    text-align: left !important;
+  }
+}
+@media screen and (min-width: 1216px) and (max-width: 1407px) {
+  .has-text-left-widescreen-only {
+    text-align: left !important;
+  }
+}
+@media screen and (min-width: 1408px) {
+  .has-text-left-fullhd {
+    text-align: left !important;
+  }
+}
+@media screen and (max-width: 768px) {
+  .has-text-right-mobile {
+    text-align: right !important;
+  }
+}
+@media screen and (min-width: 769px), print {
+  .has-text-right-tablet {
+    text-align: right !important;
+  }
+}
+@media screen and (min-width: 769px) and (max-width: 1023px) {
+  .has-text-right-tablet-only {
+    text-align: right !important;
+  }
+}
+@media screen and (max-width: 1023px) {
+  .has-text-right-touch {
+    text-align: right !important;
+  }
+}
+@media screen and (min-width: 1024px) {
+  .has-text-right-desktop {
+    text-align: right !important;
+  }
+}
+@media screen and (min-width: 1024px) and (max-width: 1215px) {
+  .has-text-right-desktop-only {
+    text-align: right !important;
+  }
+}
+@media screen and (min-width: 1216px) {
+  .has-text-right-widescreen {
+    text-align: right !important;
+  }
+}
+@media screen and (min-width: 1216px) and (max-width: 1407px) {
+  .has-text-right-widescreen-only {
+    text-align: right !important;
+  }
+}
+@media screen and (min-width: 1408px) {
+  .has-text-right-fullhd {
+    text-align: right !important;
+  }
+}
+.is-capitalized {
+  text-transform: capitalize !important;
+}
+
+.is-lowercase {
+  text-transform: lowercase !important;
+}
+
+.is-uppercase {
+  text-transform: uppercase !important;
+}
+
+.is-italic {
+  font-style: italic !important;
+}
+
+.is-underlined {
+  text-decoration: underline !important;
+}
+
+.has-text-weight-light {
+  font-weight: 300 !important;
+}
+
+.has-text-weight-normal {
+  font-weight: 400 !important;
+}
+
+.has-text-weight-medium {
+  font-weight: 500 !important;
+}
+
+.has-text-weight-semibold {
+  font-weight: 600 !important;
+}
+
+.has-text-weight-bold {
+  font-weight: 700 !important;
+}
+
+.is-family-primary {
+  font-family: "Inter", "SF Pro", "Segoe UI", "Roboto", "Oxygen", "Ubuntu", "Helvetica Neue", "Helvetica", "Arial", sans-serif !important;
+}
+
+.is-family-secondary {
+  font-family: "Inter", "SF Pro", "Segoe UI", "Roboto", "Oxygen", "Ubuntu", "Helvetica Neue", "Helvetica", "Arial", sans-serif !important;
+}
+
+.is-family-sans-serif {
+  font-family: "Inter", "SF Pro", "Segoe UI", "Roboto", "Oxygen", "Ubuntu", "Helvetica Neue", "Helvetica", "Arial", sans-serif !important;
+}
+
+.is-family-monospace {
+  font-family: "Inconsolata", "Hack", "SF Mono", "Roboto Mono", "Source Code Pro", "Ubuntu Mono", monospace !important;
+}
+
+.is-family-code {
+  font-family: "Inconsolata", "Hack", "SF Mono", "Roboto Mono", "Source Code Pro", "Ubuntu Mono", monospace !important;
+}
+
+.is-display-none,
+.is-hidden {
+  display: none !important;
+}
+
+.is-display-block,
+.is-block {
+  display: block !important;
+}
+
+@media screen and (max-width: 768px) {
+  .is-display-block-mobile,
+  .is-block-mobile {
+    display: block !important;
+  }
+}
+@media screen and (min-width: 769px), print {
+  .is-display-block-tablet,
+  .is-block-tablet {
+    display: block !important;
+  }
+}
+@media screen and (min-width: 769px) and (max-width: 1023px) {
+  .is-display-block-tablet-only,
+  .is-block-tablet-only {
+    display: block !important;
+  }
+}
+@media screen and (max-width: 1023px) {
+  .is-display-block-touch,
+  .is-block-touch {
+    display: block !important;
+  }
+}
+@media screen and (min-width: 1024px) {
+  .is-display-block-desktop,
+  .is-block-desktop {
+    display: block !important;
+  }
+}
+@media screen and (min-width: 1024px) and (max-width: 1215px) {
+  .is-display-block-desktop-only,
+  .is-block-desktop-only {
+    display: block !important;
+  }
+}
+@media screen and (min-width: 1216px) {
+  .is-display-block-widescreen,
+  .is-block-widescreen {
+    display: block !important;
+  }
+}
+@media screen and (min-width: 1216px) and (max-width: 1407px) {
+  .is-display-block-widescreen-only,
+  .is-block-widescreen-only {
+    display: block !important;
+  }
+}
+@media screen and (min-width: 1408px) {
+  .is-display-block-fullhd,
+  .is-block-fullhd {
+    display: block !important;
+  }
+}
+.is-display-flex,
+.is-flex {
+  display: flex !important;
+}
+
+@media screen and (max-width: 768px) {
+  .is-display-flex-mobile,
+  .is-flex-mobile {
+    display: flex !important;
+  }
+}
+@media screen and (min-width: 769px), print {
+  .is-display-flex-tablet,
+  .is-flex-tablet {
+    display: flex !important;
+  }
+}
+@media screen and (min-width: 769px) and (max-width: 1023px) {
+  .is-display-flex-tablet-only,
+  .is-flex-tablet-only {
+    display: flex !important;
+  }
+}
+@media screen and (max-width: 1023px) {
+  .is-display-flex-touch,
+  .is-flex-touch {
+    display: flex !important;
+  }
+}
+@media screen and (min-width: 1024px) {
+  .is-display-flex-desktop,
+  .is-flex-desktop {
+    display: flex !important;
+  }
+}
+@media screen and (min-width: 1024px) and (max-width: 1215px) {
+  .is-display-flex-desktop-only,
+  .is-flex-desktop-only {
+    display: flex !important;
+  }
+}
+@media screen and (min-width: 1216px) {
+  .is-display-flex-widescreen,
+  .is-flex-widescreen {
+    display: flex !important;
+  }
+}
+@media screen and (min-width: 1216px) and (max-width: 1407px) {
+  .is-display-flex-widescreen-only,
+  .is-flex-widescreen-only {
+    display: flex !important;
+  }
+}
+@media screen and (min-width: 1408px) {
+  .is-display-flex-fullhd,
+  .is-flex-fullhd {
+    display: flex !important;
+  }
+}
+.is-display-inline,
+.is-inline {
+  display: inline !important;
+}
+
+@media screen and (max-width: 768px) {
+  .is-display-inline-mobile,
+  .is-inline-mobile {
+    display: inline !important;
+  }
+}
+@media screen and (min-width: 769px), print {
+  .is-display-inline-tablet,
+  .is-inline-tablet {
+    display: inline !important;
+  }
+}
+@media screen and (min-width: 769px) and (max-width: 1023px) {
+  .is-display-inline-tablet-only,
+  .is-inline-tablet-only {
+    display: inline !important;
+  }
+}
+@media screen and (max-width: 1023px) {
+  .is-display-inline-touch,
+  .is-inline-touch {
+    display: inline !important;
+  }
+}
+@media screen and (min-width: 1024px) {
+  .is-display-inline-desktop,
+  .is-inline-desktop {
+    display: inline !important;
+  }
+}
+@media screen and (min-width: 1024px) and (max-width: 1215px) {
+  .is-display-inline-desktop-only,
+  .is-inline-desktop-only {
+    display: inline !important;
+  }
+}
+@media screen and (min-width: 1216px) {
+  .is-display-inline-widescreen,
+  .is-inline-widescreen {
+    display: inline !important;
+  }
+}
+@media screen and (min-width: 1216px) and (max-width: 1407px) {
+  .is-display-inline-widescreen-only,
+  .is-inline-widescreen-only {
+    display: inline !important;
+  }
+}
+@media screen and (min-width: 1408px) {
+  .is-display-inline-fullhd,
+  .is-inline-fullhd {
+    display: inline !important;
+  }
+}
+.is-display-inline-block,
+.is-inline-block {
+  display: inline-block !important;
+}
+
+@media screen and (max-width: 768px) {
+  .is-display-inline-block-mobile,
+  .is-inline-block-mobile {
+    display: inline-block !important;
+  }
+}
+@media screen and (min-width: 769px), print {
+  .is-display-inline-block-tablet,
+  .is-inline-block-tablet {
+    display: inline-block !important;
+  }
+}
+@media screen and (min-width: 769px) and (max-width: 1023px) {
+  .is-display-inline-block-tablet-only,
+  .is-inline-block-tablet-only {
+    display: inline-block !important;
+  }
+}
+@media screen and (max-width: 1023px) {
+  .is-display-inline-block-touch,
+  .is-inline-block-touch {
+    display: inline-block !important;
+  }
+}
+@media screen and (min-width: 1024px) {
+  .is-display-inline-block-desktop,
+  .is-inline-block-desktop {
+    display: inline-block !important;
+  }
+}
+@media screen and (min-width: 1024px) and (max-width: 1215px) {
+  .is-display-inline-block-desktop-only,
+  .is-inline-block-desktop-only {
+    display: inline-block !important;
+  }
+}
+@media screen and (min-width: 1216px) {
+  .is-display-inline-block-widescreen,
+  .is-inline-block-widescreen {
+    display: inline-block !important;
+  }
+}
+@media screen and (min-width: 1216px) and (max-width: 1407px) {
+  .is-display-inline-block-widescreen-only,
+  .is-inline-block-widescreen-only {
+    display: inline-block !important;
+  }
+}
+@media screen and (min-width: 1408px) {
+  .is-display-inline-block-fullhd,
+  .is-inline-block-fullhd {
+    display: inline-block !important;
+  }
+}
+.is-display-inline-flex,
+.is-inline-flex {
+  display: inline-flex !important;
+}
+
+@media screen and (max-width: 768px) {
+  .is-display-inline-flex-mobile,
+  .is-inline-flex-mobile {
+    display: inline-flex !important;
+  }
+}
+@media screen and (min-width: 769px), print {
+  .is-display-inline-flex-tablet,
+  .is-inline-flex-tablet {
+    display: inline-flex !important;
+  }
+}
+@media screen and (min-width: 769px) and (max-width: 1023px) {
+  .is-display-inline-flex-tablet-only,
+  .is-inline-flex-tablet-only {
+    display: inline-flex !important;
+  }
+}
+@media screen and (max-width: 1023px) {
+  .is-display-inline-flex-touch,
+  .is-inline-flex-touch {
+    display: inline-flex !important;
+  }
+}
+@media screen and (min-width: 1024px) {
+  .is-display-inline-flex-desktop,
+  .is-inline-flex-desktop {
+    display: inline-flex !important;
+  }
+}
+@media screen and (min-width: 1024px) and (max-width: 1215px) {
+  .is-display-inline-flex-desktop-only,
+  .is-inline-flex-desktop-only {
+    display: inline-flex !important;
+  }
+}
+@media screen and (min-width: 1216px) {
+  .is-display-inline-flex-widescreen,
+  .is-inline-flex-widescreen {
+    display: inline-flex !important;
+  }
+}
+@media screen and (min-width: 1216px) and (max-width: 1407px) {
+  .is-display-inline-flex-widescreen-only,
+  .is-inline-flex-widescreen-only {
+    display: inline-flex !important;
+  }
+}
+@media screen and (min-width: 1408px) {
+  .is-display-inline-flex-fullhd,
+  .is-inline-flex-fullhd {
+    display: inline-flex !important;
+  }
+}
+.is-display-grid,
+.is-grid {
+  display: grid !important;
+}
+
+@media screen and (max-width: 768px) {
+  .is-display-grid-mobile,
+  .is-grid-mobile {
+    display: grid !important;
+  }
+}
+@media screen and (min-width: 769px), print {
+  .is-display-grid-tablet,
+  .is-grid-tablet {
+    display: grid !important;
+  }
+}
+@media screen and (min-width: 769px) and (max-width: 1023px) {
+  .is-display-grid-tablet-only,
+  .is-grid-tablet-only {
+    display: grid !important;
+  }
+}
+@media screen and (max-width: 1023px) {
+  .is-display-grid-touch,
+  .is-grid-touch {
+    display: grid !important;
+  }
+}
+@media screen and (min-width: 1024px) {
+  .is-display-grid-desktop,
+  .is-grid-desktop {
+    display: grid !important;
+  }
+}
+@media screen and (min-width: 1024px) and (max-width: 1215px) {
+  .is-display-grid-desktop-only,
+  .is-grid-desktop-only {
+    display: grid !important;
+  }
+}
+@media screen and (min-width: 1216px) {
+  .is-display-grid-widescreen,
+  .is-grid-widescreen {
+    display: grid !important;
+  }
+}
+@media screen and (min-width: 1216px) and (max-width: 1407px) {
+  .is-display-grid-widescreen-only,
+  .is-grid-widescreen-only {
+    display: grid !important;
+  }
+}
+@media screen and (min-width: 1408px) {
+  .is-display-grid-fullhd,
+  .is-grid-fullhd {
+    display: grid !important;
+  }
+}
+.is-sr-only {
+  border: none !important;
+  clip: rect(0, 0, 0, 0) !important;
+  height: 0.01em !important;
+  overflow: hidden !important;
+  padding: 0 !important;
+  position: absolute !important;
+  white-space: nowrap !important;
+  width: 0.01em !important;
+}
+
+@media screen and (max-width: 768px) {
+  .is-display-none-mobile,
+  .is-hidden-mobile {
+    display: none !important;
+  }
+}
+@media screen and (min-width: 769px), print {
+  .is-display-none-tablet,
+  .is-hidden-tablet {
+    display: none !important;
+  }
+}
+@media screen and (min-width: 769px) and (max-width: 1023px) {
+  .is-display-none-tablet-only,
+  .is-hidden-tablet-only {
+    display: none !important;
+  }
+}
+@media screen and (max-width: 1023px) {
+  .is-display-none-touch,
+  .is-hidden-touch {
+    display: none !important;
+  }
+}
+@media screen and (min-width: 1024px) {
+  .is-display-none-desktop,
+  .is-hidden-desktop {
+    display: none !important;
+  }
+}
+@media screen and (min-width: 1024px) and (max-width: 1215px) {
+  .is-display-none-desktop-only,
+  .is-hidden-desktop-only {
+    display: none !important;
+  }
+}
+@media screen and (min-width: 1216px) {
+  .is-display-none-widescreen,
+  .is-hidden-widescreen {
+    display: none !important;
+  }
+}
+@media screen and (min-width: 1216px) and (max-width: 1407px) {
+  .is-display-none-widescreen-only,
+  .is-hidden-widescreen-only {
+    display: none !important;
+  }
+}
+@media screen and (min-width: 1408px) {
+  .is-display-none-fullhd,
+  .is-hidden-fullhd {
+    display: none !important;
+  }
+}
+.is-visibility-hidden,
+.is-invisible {
+  visibility: hidden !important;
+}
+
+@media screen and (max-width: 768px) {
+  .is-visibility-hidden-mobile,
+  .is-invisible-mobile {
+    visibility: hidden !important;
+  }
+}
+@media screen and (min-width: 769px), print {
+  .is-visibility-hidden-tablet,
+  .is-invisible-tablet {
+    visibility: hidden !important;
+  }
+}
+@media screen and (min-width: 769px) and (max-width: 1023px) {
+  .is-visibility-hidden-tablet-only,
+  .is-invisible-tablet-only {
+    visibility: hidden !important;
+  }
+}
+@media screen and (max-width: 1023px) {
+  .is-visibility-hidden-touch,
+  .is-invisible-touch {
+    visibility: hidden !important;
+  }
+}
+@media screen and (min-width: 1024px) {
+  .is-visibility-hidden-desktop,
+  .is-invisible-desktop {
+    visibility: hidden !important;
+  }
+}
+@media screen and (min-width: 1024px) and (max-width: 1215px) {
+  .is-visibility-hidden-desktop-only,
+  .is-invisible-desktop-only {
+    visibility: hidden !important;
+  }
+}
+@media screen and (min-width: 1216px) {
+  .is-visibility-hidden-widescreen,
+  .is-invisible-widescreen {
+    visibility: hidden !important;
+  }
+}
+@media screen and (min-width: 1216px) and (max-width: 1407px) {
+  .is-visibility-hidden-widescreen-only,
+  .is-invisible-widescreen-only {
+    visibility: hidden !important;
+  }
+}
+@media screen and (min-width: 1408px) {
+  .is-visibility-hidden-fullhd,
+  .is-invisible-fullhd {
+    visibility: hidden !important;
+  }
+}
+.is-radiusless {
+  border-radius: 0 !important;
+}
+
+.is-shadowless {
+  box-shadow: none !important;
+}
+
+.is-clickable {
+  cursor: pointer !important;
+  pointer-events: all !important;
+}
+
+/*# sourceMappingURL=bulma.css.map */
diff --git a/test/js/bun/css/files/bulma.min.css b/test/js/bun/css/files/bulma.min.css
new file mode 100644
index 0000000000..8c4a583cdf
--- /dev/null
+++ b/test/js/bun/css/files/bulma.min.css
@@ -0,0 +1 @@
+:root{--bulma-control-radius:var(--bulma-radius);--bulma-control-radius-small:var(--bulma-radius-small);--bulma-control-border-width:1px;--bulma-control-height:2.5em;--bulma-control-line-height:1.5;--bulma-control-padding-vertical:calc(.5em - 1px);--bulma-control-padding-horizontal:calc(.75em - 1px);--bulma-control-size:var(--bulma-size-normal);--bulma-control-focus-shadow-l:50%;--bulma-scheme-h:221;--bulma-scheme-s:14%;--bulma-light-l:96%;--bulma-light-invert-l:21%;--bulma-dark-l:21%;--bulma-dark-invert-l:96%;--bulma-soft-l:90%;--bulma-bold-l:20%;--bulma-soft-invert-l:20%;--bulma-bold-invert-l:90%;--bulma-hover-background-l-delta:-5%;--bulma-active-background-l-delta:-10%;--bulma-hover-border-l-delta:-10%;--bulma-active-border-l-delta:-20%;--bulma-hover-color-l-delta:-5%;--bulma-active-color-l-delta:-10%;--bulma-hover-shadow-a-delta:-.05;--bulma-active-shadow-a-delta:-.1;--bulma-scheme-brightness:light;--bulma-scheme-main-l:100%;--bulma-scheme-main-bis-l:98%;--bulma-scheme-main-ter-l:96%;--bulma-background-l:96%;--bulma-border-weak-l:93%;--bulma-border-l:86%;--bulma-text-weak-l:48%;--bulma-text-l:29%;--bulma-text-strong-l:21%;--bulma-text-title-l:14%;--bulma-scheme-invert-ter-l:14%;--bulma-scheme-invert-bis-l:7%;--bulma-scheme-invert-l:4%;--bulma-family-primary:Inter,SF Pro,Segoe UI,Roboto,Oxygen,Ubuntu,Helvetica Neue,Helvetica,Arial,sans-serif;--bulma-family-secondary:Inter,SF Pro,Segoe UI,Roboto,Oxygen,Ubuntu,Helvetica Neue,Helvetica,Arial,sans-serif;--bulma-family-code:Inconsolata,Hack,SF Mono,Roboto Mono,Source Code Pro,Ubuntu Mono,monospace;--bulma-size-small:.75rem;--bulma-size-normal:1rem;--bulma-size-medium:1.25rem;--bulma-size-large:1.5rem;--bulma-weight-light:300;--bulma-weight-normal:400;--bulma-weight-medium:500;--bulma-weight-semibold:600;--bulma-weight-bold:700;--bulma-weight-extrabold:800;--bulma-block-spacing:1.5rem;--bulma-duration:.294s;--bulma-easing:ease-out;--bulma-radius-small:.25rem;--bulma-radius:.375rem;--bulma-radius-medium:.5em;--bulma-radius-large:.75rem;--bulma-radius-rounded:9999px;--bulma-speed:86ms;--bulma-arrow-color:var(--bulma-link);--bulma-loading-color:var(--bulma-border);--bulma-burger-h:var(--bulma-link-h);--bulma-burger-s:var(--bulma-link-s);--bulma-burger-l:var(--bulma-link-l);--bulma-burger-border-radius:.5em;--bulma-burger-gap:5px;--bulma-burger-item-height:2px;--bulma-burger-item-width:20px;--bulma-white:hsla(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-l),1);--bulma-white-base:hsla(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-l),1);--bulma-white-rgb:255,255,255;--bulma-white-h:221deg;--bulma-white-s:14%;--bulma-white-l:100%;--bulma-white-invert-l:4%;--bulma-white-invert:#090a0c;--bulma-white-on-scheme-l:35%;--bulma-white-on-scheme:hsla(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-on-scheme-l),1);--bulma-black:hsla(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-l),1);--bulma-black-base:hsla(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-l),1);--bulma-black-rgb:9,10,12;--bulma-black-h:221deg;--bulma-black-s:14%;--bulma-black-l:4%;--bulma-black-invert-l:100%;--bulma-black-invert:#fff;--bulma-black-on-scheme-l:4%;--bulma-black-on-scheme:hsla(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-on-scheme-l),1);--bulma-light:hsla(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-l),1);--bulma-light-base:hsla(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-l),1);--bulma-light-rgb:243,244,246;--bulma-light-h:221deg;--bulma-light-s:14%;--bulma-light-invert:#2e333d;--bulma-light-on-scheme-l:36%;--bulma-light-on-scheme:hsla(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-on-scheme-l),1);--bulma-dark:hsla(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-l),1);--bulma-dark-base:hsla(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-l),1);--bulma-dark-rgb:46,51,61;--bulma-dark-h:221deg;--bulma-dark-s:14%;--bulma-dark-invert:#f3f4f6;--bulma-dark-on-scheme-l:21%;--bulma-dark-on-scheme:hsla(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-on-scheme-l),1);--bulma-text:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-l));--bulma-text-base:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-l),1);--bulma-text-rgb:64,70,84;--bulma-text-h:221deg;--bulma-text-s:14%;--bulma-text-00-l:0%;--bulma-text-05-l:4%;--bulma-text-10-l:9%;--bulma-text-15-l:14%;--bulma-text-20-l:19%;--bulma-text-25-l:24%;--bulma-text-30-l:29%;--bulma-text-35-l:34%;--bulma-text-40-l:39%;--bulma-text-45-l:44%;--bulma-text-50-l:49%;--bulma-text-55-l:54%;--bulma-text-60-l:59%;--bulma-text-65-l:64%;--bulma-text-70-l:69%;--bulma-text-75-l:74%;--bulma-text-80-l:79%;--bulma-text-85-l:84%;--bulma-text-90-l:89%;--bulma-text-95-l:94%;--bulma-text-100-l:99%;--bulma-text-00:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-00-l),1);--bulma-text-00-invert-l:var(--bulma-text-60-l);--bulma-text-00-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-00-invert-l),1);--bulma-text-05:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-05-l),1);--bulma-text-05-invert-l:var(--bulma-text-60-l);--bulma-text-05-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-05-invert-l),1);--bulma-text-10:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-10-l),1);--bulma-text-10-invert-l:var(--bulma-text-70-l);--bulma-text-10-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-10-invert-l),1);--bulma-text-15:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-15-l),1);--bulma-text-15-invert-l:var(--bulma-text-75-l);--bulma-text-15-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-15-invert-l),1);--bulma-text-20:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-20-l),1);--bulma-text-20-invert-l:var(--bulma-text-85-l);--bulma-text-20-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-20-invert-l),1);--bulma-text-25:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-25-l),1);--bulma-text-25-invert-l:var(--bulma-text-95-l);--bulma-text-25-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-25-invert-l),1);--bulma-text-30:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-30-l),1);--bulma-text-30-invert-l:var(--bulma-text-100-l);--bulma-text-30-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-30-invert-l),1);--bulma-text-35:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-35-l),1);--bulma-text-35-invert-l:var(--bulma-text-100-l);--bulma-text-35-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-35-invert-l),1);--bulma-text-40:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-40-l),1);--bulma-text-40-invert-l:var(--bulma-text-100-l);--bulma-text-40-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-40-invert-l),1);--bulma-text-45:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-45-l),1);--bulma-text-45-invert-l:var(--bulma-text-100-l);--bulma-text-45-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-45-invert-l),1);--bulma-text-50:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-50-l),1);--bulma-text-50-invert-l:var(--bulma-text-100-l);--bulma-text-50-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-50-invert-l),1);--bulma-text-55:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-55-l),1);--bulma-text-55-invert-l:var(--bulma-text-100-l);--bulma-text-55-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-55-invert-l),1);--bulma-text-60:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-60-l),1);--bulma-text-60-invert-l:var(--bulma-text-05-l);--bulma-text-60-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-60-invert-l),1);--bulma-text-65:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-65-l),1);--bulma-text-65-invert-l:var(--bulma-text-05-l);--bulma-text-65-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-65-invert-l),1);--bulma-text-70:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-70-l),1);--bulma-text-70-invert-l:var(--bulma-text-10-l);--bulma-text-70-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-70-invert-l),1);--bulma-text-75:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-75-l),1);--bulma-text-75-invert-l:var(--bulma-text-15-l);--bulma-text-75-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-75-invert-l),1);--bulma-text-80:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-80-l),1);--bulma-text-80-invert-l:var(--bulma-text-15-l);--bulma-text-80-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-80-invert-l),1);--bulma-text-85:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-85-l),1);--bulma-text-85-invert-l:var(--bulma-text-20-l);--bulma-text-85-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-85-invert-l),1);--bulma-text-90:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-90-l),1);--bulma-text-90-invert-l:var(--bulma-text-20-l);--bulma-text-90-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-90-invert-l),1);--bulma-text-95:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-95-l),1);--bulma-text-95-invert-l:var(--bulma-text-25-l);--bulma-text-95-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-95-invert-l),1);--bulma-text-100:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-100-l),1);--bulma-text-100-invert-l:var(--bulma-text-25-l);--bulma-text-100-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-100-invert-l),1);--bulma-text-invert-l:var(--bulma-text-100-l);--bulma-text-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-invert-l),1);--bulma-text-light-l:var(--bulma-text-90-l);--bulma-text-light:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-light-l),1);--bulma-text-light-invert-l:var(--bulma-text-20-l);--bulma-text-light-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-light-invert-l),1);--bulma-text-dark-l:var(--bulma-text-10-l);--bulma-text-dark:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-dark-l),1);--bulma-text-dark-invert-l:var(--bulma-text-70-l);--bulma-text-dark-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-dark-invert-l),1);--bulma-text-soft:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-soft-l),1);--bulma-text-bold:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-bold-l),1);--bulma-text-soft-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-soft-invert-l),1);--bulma-text-bold-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-bold-invert-l),1);--bulma-text-on-scheme-l:29%;--bulma-text-on-scheme:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-on-scheme-l),1);--bulma-primary:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-l),1);--bulma-primary-base:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-l),1);--bulma-primary-rgb:0,209,178;--bulma-primary-h:171deg;--bulma-primary-s:100%;--bulma-primary-l:41%;--bulma-primary-00-l:1%;--bulma-primary-05-l:6%;--bulma-primary-10-l:11%;--bulma-primary-15-l:16%;--bulma-primary-20-l:21%;--bulma-primary-25-l:26%;--bulma-primary-30-l:31%;--bulma-primary-35-l:36%;--bulma-primary-40-l:41%;--bulma-primary-45-l:46%;--bulma-primary-50-l:51%;--bulma-primary-55-l:56%;--bulma-primary-60-l:61%;--bulma-primary-65-l:66%;--bulma-primary-70-l:71%;--bulma-primary-75-l:76%;--bulma-primary-80-l:81%;--bulma-primary-85-l:86%;--bulma-primary-90-l:91%;--bulma-primary-95-l:96%;--bulma-primary-100-l:100%;--bulma-primary-00:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-00-l),1);--bulma-primary-00-invert-l:var(--bulma-primary-30-l);--bulma-primary-00-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-00-invert-l),1);--bulma-primary-05:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-05-l),1);--bulma-primary-05-invert-l:var(--bulma-primary-40-l);--bulma-primary-05-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-05-invert-l),1);--bulma-primary-10:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-10-l),1);--bulma-primary-10-invert-l:var(--bulma-primary-50-l);--bulma-primary-10-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-10-invert-l),1);--bulma-primary-15:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-15-l),1);--bulma-primary-15-invert-l:var(--bulma-primary-100-l);--bulma-primary-15-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-15-invert-l),1);--bulma-primary-20:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-20-l),1);--bulma-primary-20-invert-l:var(--bulma-primary-100-l);--bulma-primary-20-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-20-invert-l),1);--bulma-primary-25:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-25-l),1);--bulma-primary-25-invert-l:var(--bulma-primary-100-l);--bulma-primary-25-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-25-invert-l),1);--bulma-primary-30:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-30-l),1);--bulma-primary-30-invert-l:var(--bulma-primary-00-l);--bulma-primary-30-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-30-invert-l),1);--bulma-primary-35:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-35-l),1);--bulma-primary-35-invert-l:var(--bulma-primary-00-l);--bulma-primary-35-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-35-invert-l),1);--bulma-primary-40:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-40-l),1);--bulma-primary-40-invert-l:var(--bulma-primary-05-l);--bulma-primary-40-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-40-invert-l),1);--bulma-primary-45:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-45-l),1);--bulma-primary-45-invert-l:var(--bulma-primary-05-l);--bulma-primary-45-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-45-invert-l),1);--bulma-primary-50:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-50-l),1);--bulma-primary-50-invert-l:var(--bulma-primary-10-l);--bulma-primary-50-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-50-invert-l),1);--bulma-primary-55:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-55-l),1);--bulma-primary-55-invert-l:var(--bulma-primary-10-l);--bulma-primary-55-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-55-invert-l),1);--bulma-primary-60:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-60-l),1);--bulma-primary-60-invert-l:var(--bulma-primary-10-l);--bulma-primary-60-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-60-invert-l),1);--bulma-primary-65:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-65-l),1);--bulma-primary-65-invert-l:var(--bulma-primary-10-l);--bulma-primary-65-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-65-invert-l),1);--bulma-primary-70:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-70-l),1);--bulma-primary-70-invert-l:var(--bulma-primary-10-l);--bulma-primary-70-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-70-invert-l),1);--bulma-primary-75:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-75-l),1);--bulma-primary-75-invert-l:var(--bulma-primary-10-l);--bulma-primary-75-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-75-invert-l),1);--bulma-primary-80:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-80-l),1);--bulma-primary-80-invert-l:var(--bulma-primary-10-l);--bulma-primary-80-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-80-invert-l),1);--bulma-primary-85:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-85-l),1);--bulma-primary-85-invert-l:var(--bulma-primary-10-l);--bulma-primary-85-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-85-invert-l),1);--bulma-primary-90:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-90-l),1);--bulma-primary-90-invert-l:var(--bulma-primary-10-l);--bulma-primary-90-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-90-invert-l),1);--bulma-primary-95:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-95-l),1);--bulma-primary-95-invert-l:var(--bulma-primary-10-l);--bulma-primary-95-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-95-invert-l),1);--bulma-primary-100:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-100-l),1);--bulma-primary-100-invert-l:var(--bulma-primary-15-l);--bulma-primary-100-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-100-invert-l),1);--bulma-primary-invert-l:var(--bulma-primary-05-l);--bulma-primary-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-invert-l),1);--bulma-primary-light-l:var(--bulma-primary-90-l);--bulma-primary-light:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-light-l),1);--bulma-primary-light-invert-l:var(--bulma-primary-10-l);--bulma-primary-light-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-light-invert-l),1);--bulma-primary-dark-l:var(--bulma-primary-10-l);--bulma-primary-dark:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-dark-l),1);--bulma-primary-dark-invert-l:var(--bulma-primary-50-l);--bulma-primary-dark-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-dark-invert-l),1);--bulma-primary-soft:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-soft-l),1);--bulma-primary-bold:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-bold-l),1);--bulma-primary-soft-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-soft-invert-l),1);--bulma-primary-bold-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-bold-invert-l),1);--bulma-primary-on-scheme-l:21%;--bulma-primary-on-scheme:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-on-scheme-l),1);--bulma-link:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-l));--bulma-link-base:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-l),1);--bulma-link-rgb:66,88,255;--bulma-link-h:233deg;--bulma-link-s:100%;--bulma-link-l:63%;--bulma-link-00-l:0%;--bulma-link-05-l:3%;--bulma-link-10-l:8%;--bulma-link-15-l:13%;--bulma-link-20-l:18%;--bulma-link-25-l:23%;--bulma-link-30-l:28%;--bulma-link-35-l:33%;--bulma-link-40-l:38%;--bulma-link-45-l:43%;--bulma-link-50-l:48%;--bulma-link-55-l:53%;--bulma-link-60-l:58%;--bulma-link-65-l:63%;--bulma-link-70-l:68%;--bulma-link-75-l:73%;--bulma-link-80-l:78%;--bulma-link-85-l:83%;--bulma-link-90-l:88%;--bulma-link-95-l:93%;--bulma-link-100-l:98%;--bulma-link-00:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-00-l),1);--bulma-link-00-invert-l:var(--bulma-link-75-l);--bulma-link-00-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-00-invert-l),1);--bulma-link-05:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-05-l),1);--bulma-link-05-invert-l:var(--bulma-link-75-l);--bulma-link-05-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-05-invert-l),1);--bulma-link-10:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-10-l),1);--bulma-link-10-invert-l:var(--bulma-link-75-l);--bulma-link-10-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-10-invert-l),1);--bulma-link-15:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-15-l),1);--bulma-link-15-invert-l:var(--bulma-link-80-l);--bulma-link-15-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-15-invert-l),1);--bulma-link-20:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-20-l),1);--bulma-link-20-invert-l:var(--bulma-link-80-l);--bulma-link-20-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-20-invert-l),1);--bulma-link-25:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-25-l),1);--bulma-link-25-invert-l:var(--bulma-link-85-l);--bulma-link-25-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-25-invert-l),1);--bulma-link-30:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-30-l),1);--bulma-link-30-invert-l:var(--bulma-link-90-l);--bulma-link-30-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-30-invert-l),1);--bulma-link-35:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-35-l),1);--bulma-link-35-invert-l:var(--bulma-link-90-l);--bulma-link-35-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-35-invert-l),1);--bulma-link-40:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-40-l),1);--bulma-link-40-invert-l:var(--bulma-link-95-l);--bulma-link-40-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-40-invert-l),1);--bulma-link-45:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-45-l),1);--bulma-link-45-invert-l:var(--bulma-link-100-l);--bulma-link-45-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-45-invert-l),1);--bulma-link-50:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-50-l),1);--bulma-link-50-invert-l:var(--bulma-link-100-l);--bulma-link-50-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-50-invert-l),1);--bulma-link-55:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-55-l),1);--bulma-link-55-invert-l:var(--bulma-link-100-l);--bulma-link-55-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-55-invert-l),1);--bulma-link-60:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-60-l),1);--bulma-link-60-invert-l:var(--bulma-link-100-l);--bulma-link-60-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-60-invert-l),1);--bulma-link-65:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-65-l),1);--bulma-link-65-invert-l:var(--bulma-link-100-l);--bulma-link-65-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-65-invert-l),1);--bulma-link-70:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-70-l),1);--bulma-link-70-invert-l:var(--bulma-link-100-l);--bulma-link-70-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-70-invert-l),1);--bulma-link-75:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-75-l),1);--bulma-link-75-invert-l:var(--bulma-link-10-l);--bulma-link-75-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-75-invert-l),1);--bulma-link-80:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-80-l),1);--bulma-link-80-invert-l:var(--bulma-link-20-l);--bulma-link-80-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-80-invert-l),1);--bulma-link-85:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-85-l),1);--bulma-link-85-invert-l:var(--bulma-link-25-l);--bulma-link-85-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-85-invert-l),1);--bulma-link-90:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-90-l),1);--bulma-link-90-invert-l:var(--bulma-link-35-l);--bulma-link-90-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-90-invert-l),1);--bulma-link-95:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-95-l),1);--bulma-link-95-invert-l:var(--bulma-link-40-l);--bulma-link-95-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-95-invert-l),1);--bulma-link-100:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-100-l),1);--bulma-link-100-invert-l:var(--bulma-link-50-l);--bulma-link-100-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-100-invert-l),1);--bulma-link-invert-l:var(--bulma-link-100-l);--bulma-link-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-invert-l),1);--bulma-link-light-l:var(--bulma-link-90-l);--bulma-link-light:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-light-l),1);--bulma-link-light-invert-l:var(--bulma-link-35-l);--bulma-link-light-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-light-invert-l),1);--bulma-link-dark-l:var(--bulma-link-10-l);--bulma-link-dark:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-dark-l),1);--bulma-link-dark-invert-l:var(--bulma-link-75-l);--bulma-link-dark-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-dark-invert-l),1);--bulma-link-soft:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-soft-l),1);--bulma-link-bold:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-bold-l),1);--bulma-link-soft-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-soft-invert-l),1);--bulma-link-bold-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-bold-invert-l),1);--bulma-link-on-scheme-l:58%;--bulma-link-on-scheme:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-on-scheme-l),1);--bulma-info:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-l),1);--bulma-info-base:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-l),1);--bulma-info-rgb:102,209,255;--bulma-info-h:198deg;--bulma-info-s:100%;--bulma-info-l:70%;--bulma-info-00-l:0%;--bulma-info-05-l:5%;--bulma-info-10-l:10%;--bulma-info-15-l:15%;--bulma-info-20-l:20%;--bulma-info-25-l:25%;--bulma-info-30-l:30%;--bulma-info-35-l:35%;--bulma-info-40-l:40%;--bulma-info-45-l:45%;--bulma-info-50-l:50%;--bulma-info-55-l:55%;--bulma-info-60-l:60%;--bulma-info-65-l:65%;--bulma-info-70-l:70%;--bulma-info-75-l:75%;--bulma-info-80-l:80%;--bulma-info-85-l:85%;--bulma-info-90-l:90%;--bulma-info-95-l:95%;--bulma-info-100-l:100%;--bulma-info-00:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-00-l),1);--bulma-info-00-invert-l:var(--bulma-info-45-l);--bulma-info-00-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-00-invert-l),1);--bulma-info-05:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-05-l),1);--bulma-info-05-invert-l:var(--bulma-info-50-l);--bulma-info-05-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-05-invert-l),1);--bulma-info-10:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-10-l),1);--bulma-info-10-invert-l:var(--bulma-info-60-l);--bulma-info-10-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-10-invert-l),1);--bulma-info-15:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-15-l),1);--bulma-info-15-invert-l:var(--bulma-info-80-l);--bulma-info-15-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-15-invert-l),1);--bulma-info-20:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-20-l),1);--bulma-info-20-invert-l:var(--bulma-info-95-l);--bulma-info-20-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-20-invert-l),1);--bulma-info-25:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-25-l),1);--bulma-info-25-invert-l:var(--bulma-info-100-l);--bulma-info-25-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-25-invert-l),1);--bulma-info-30:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-30-l),1);--bulma-info-30-invert-l:var(--bulma-info-100-l);--bulma-info-30-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-30-invert-l),1);--bulma-info-35:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-35-l),1);--bulma-info-35-invert-l:var(--bulma-info-100-l);--bulma-info-35-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-35-invert-l),1);--bulma-info-40:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-40-l),1);--bulma-info-40-invert-l:var(--bulma-info-100-l);--bulma-info-40-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-40-invert-l),1);--bulma-info-45:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-45-l),1);--bulma-info-45-invert-l:var(--bulma-info-00-l);--bulma-info-45-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-45-invert-l),1);--bulma-info-50:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-50-l),1);--bulma-info-50-invert-l:var(--bulma-info-05-l);--bulma-info-50-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-50-invert-l),1);--bulma-info-55:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-55-l),1);--bulma-info-55-invert-l:var(--bulma-info-05-l);--bulma-info-55-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-55-invert-l),1);--bulma-info-60:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-60-l),1);--bulma-info-60-invert-l:var(--bulma-info-10-l);--bulma-info-60-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-60-invert-l),1);--bulma-info-65:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-65-l),1);--bulma-info-65-invert-l:var(--bulma-info-10-l);--bulma-info-65-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-65-invert-l),1);--bulma-info-70:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-70-l),1);--bulma-info-70-invert-l:var(--bulma-info-10-l);--bulma-info-70-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-70-invert-l),1);--bulma-info-75:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-75-l),1);--bulma-info-75-invert-l:var(--bulma-info-10-l);--bulma-info-75-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-75-invert-l),1);--bulma-info-80:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-80-l),1);--bulma-info-80-invert-l:var(--bulma-info-15-l);--bulma-info-80-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-80-invert-l),1);--bulma-info-85:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-85-l),1);--bulma-info-85-invert-l:var(--bulma-info-15-l);--bulma-info-85-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-85-invert-l),1);--bulma-info-90:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-90-l),1);--bulma-info-90-invert-l:var(--bulma-info-15-l);--bulma-info-90-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-90-invert-l),1);--bulma-info-95:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-95-l),1);--bulma-info-95-invert-l:var(--bulma-info-20-l);--bulma-info-95-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-95-invert-l),1);--bulma-info-100:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-100-l),1);--bulma-info-100-invert-l:var(--bulma-info-20-l);--bulma-info-100-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-100-invert-l),1);--bulma-info-invert-l:var(--bulma-info-10-l);--bulma-info-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-invert-l),1);--bulma-info-light-l:var(--bulma-info-90-l);--bulma-info-light:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-light-l),1);--bulma-info-light-invert-l:var(--bulma-info-15-l);--bulma-info-light-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-light-invert-l),1);--bulma-info-dark-l:var(--bulma-info-10-l);--bulma-info-dark:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-dark-l),1);--bulma-info-dark-invert-l:var(--bulma-info-60-l);--bulma-info-dark-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-dark-invert-l),1);--bulma-info-soft:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-soft-l),1);--bulma-info-bold:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-bold-l),1);--bulma-info-soft-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-soft-invert-l),1);--bulma-info-bold-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-bold-invert-l),1);--bulma-info-on-scheme-l:25%;--bulma-info-on-scheme:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-on-scheme-l),1);--bulma-success:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-l),1);--bulma-success-base:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-l),1);--bulma-success-rgb:72,199,142;--bulma-success-h:153deg;--bulma-success-s:53%;--bulma-success-l:53%;--bulma-success-00-l:0%;--bulma-success-05-l:3%;--bulma-success-10-l:8%;--bulma-success-15-l:13%;--bulma-success-20-l:18%;--bulma-success-25-l:23%;--bulma-success-30-l:28%;--bulma-success-35-l:33%;--bulma-success-40-l:38%;--bulma-success-45-l:43%;--bulma-success-50-l:48%;--bulma-success-55-l:53%;--bulma-success-60-l:58%;--bulma-success-65-l:63%;--bulma-success-70-l:68%;--bulma-success-75-l:73%;--bulma-success-80-l:78%;--bulma-success-85-l:83%;--bulma-success-90-l:88%;--bulma-success-95-l:93%;--bulma-success-100-l:98%;--bulma-success-00:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-00-l),1);--bulma-success-00-invert-l:var(--bulma-success-45-l);--bulma-success-00-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-00-invert-l),1);--bulma-success-05:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-05-l),1);--bulma-success-05-invert-l:var(--bulma-success-45-l);--bulma-success-05-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-05-invert-l),1);--bulma-success-10:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-10-l),1);--bulma-success-10-invert-l:var(--bulma-success-55-l);--bulma-success-10-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-10-invert-l),1);--bulma-success-15:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-15-l),1);--bulma-success-15-invert-l:var(--bulma-success-75-l);--bulma-success-15-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-15-invert-l),1);--bulma-success-20:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-20-l),1);--bulma-success-20-invert-l:var(--bulma-success-90-l);--bulma-success-20-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-20-invert-l),1);--bulma-success-25:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-25-l),1);--bulma-success-25-invert-l:var(--bulma-success-100-l);--bulma-success-25-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-25-invert-l),1);--bulma-success-30:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-30-l),1);--bulma-success-30-invert-l:var(--bulma-success-100-l);--bulma-success-30-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-30-invert-l),1);--bulma-success-35:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-35-l),1);--bulma-success-35-invert-l:var(--bulma-success-100-l);--bulma-success-35-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-35-invert-l),1);--bulma-success-40:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-40-l),1);--bulma-success-40-invert-l:var(--bulma-success-100-l);--bulma-success-40-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-40-invert-l),1);--bulma-success-45:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-45-l),1);--bulma-success-45-invert-l:var(--bulma-success-05-l);--bulma-success-45-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-45-invert-l),1);--bulma-success-50:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-50-l),1);--bulma-success-50-invert-l:var(--bulma-success-05-l);--bulma-success-50-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-50-invert-l),1);--bulma-success-55:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-55-l),1);--bulma-success-55-invert-l:var(--bulma-success-10-l);--bulma-success-55-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-55-invert-l),1);--bulma-success-60:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-60-l),1);--bulma-success-60-invert-l:var(--bulma-success-10-l);--bulma-success-60-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-60-invert-l),1);--bulma-success-65:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-65-l),1);--bulma-success-65-invert-l:var(--bulma-success-10-l);--bulma-success-65-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-65-invert-l),1);--bulma-success-70:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-70-l),1);--bulma-success-70-invert-l:var(--bulma-success-10-l);--bulma-success-70-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-70-invert-l),1);--bulma-success-75:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-75-l),1);--bulma-success-75-invert-l:var(--bulma-success-15-l);--bulma-success-75-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-75-invert-l),1);--bulma-success-80:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-80-l),1);--bulma-success-80-invert-l:var(--bulma-success-15-l);--bulma-success-80-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-80-invert-l),1);--bulma-success-85:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-85-l),1);--bulma-success-85-invert-l:var(--bulma-success-15-l);--bulma-success-85-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-85-invert-l),1);--bulma-success-90:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-90-l),1);--bulma-success-90-invert-l:var(--bulma-success-20-l);--bulma-success-90-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-90-invert-l),1);--bulma-success-95:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-95-l),1);--bulma-success-95-invert-l:var(--bulma-success-20-l);--bulma-success-95-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-95-invert-l),1);--bulma-success-100:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-100-l),1);--bulma-success-100-invert-l:var(--bulma-success-20-l);--bulma-success-100-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-100-invert-l),1);--bulma-success-invert-l:var(--bulma-success-10-l);--bulma-success-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-invert-l),1);--bulma-success-light-l:var(--bulma-success-90-l);--bulma-success-light:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-light-l),1);--bulma-success-light-invert-l:var(--bulma-success-20-l);--bulma-success-light-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-light-invert-l),1);--bulma-success-dark-l:var(--bulma-success-10-l);--bulma-success-dark:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-dark-l),1);--bulma-success-dark-invert-l:var(--bulma-success-55-l);--bulma-success-dark-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-dark-invert-l),1);--bulma-success-soft:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-soft-l),1);--bulma-success-bold:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-bold-l),1);--bulma-success-soft-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-soft-invert-l),1);--bulma-success-bold-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-bold-invert-l),1);--bulma-success-on-scheme-l:23%;--bulma-success-on-scheme:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-on-scheme-l),1);--bulma-warning:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-l),1);--bulma-warning-base:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-l),1);--bulma-warning-rgb:255,183,15;--bulma-warning-h:42deg;--bulma-warning-s:100%;--bulma-warning-l:53%;--bulma-warning-00-l:0%;--bulma-warning-05-l:3%;--bulma-warning-10-l:8%;--bulma-warning-15-l:13%;--bulma-warning-20-l:18%;--bulma-warning-25-l:23%;--bulma-warning-30-l:28%;--bulma-warning-35-l:33%;--bulma-warning-40-l:38%;--bulma-warning-45-l:43%;--bulma-warning-50-l:48%;--bulma-warning-55-l:53%;--bulma-warning-60-l:58%;--bulma-warning-65-l:63%;--bulma-warning-70-l:68%;--bulma-warning-75-l:73%;--bulma-warning-80-l:78%;--bulma-warning-85-l:83%;--bulma-warning-90-l:88%;--bulma-warning-95-l:93%;--bulma-warning-100-l:98%;--bulma-warning-00:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-00-l),1);--bulma-warning-00-invert-l:var(--bulma-warning-40-l);--bulma-warning-00-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-00-invert-l),1);--bulma-warning-05:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-05-l),1);--bulma-warning-05-invert-l:var(--bulma-warning-45-l);--bulma-warning-05-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-05-invert-l),1);--bulma-warning-10:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-10-l),1);--bulma-warning-10-invert-l:var(--bulma-warning-50-l);--bulma-warning-10-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-10-invert-l),1);--bulma-warning-15:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-15-l),1);--bulma-warning-15-invert-l:var(--bulma-warning-70-l);--bulma-warning-15-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-15-invert-l),1);--bulma-warning-20:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-20-l),1);--bulma-warning-20-invert-l:var(--bulma-warning-100-l);--bulma-warning-20-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-20-invert-l),1);--bulma-warning-25:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-25-l),1);--bulma-warning-25-invert-l:var(--bulma-warning-100-l);--bulma-warning-25-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-25-invert-l),1);--bulma-warning-30:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-30-l),1);--bulma-warning-30-invert-l:var(--bulma-warning-100-l);--bulma-warning-30-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-30-invert-l),1);--bulma-warning-35:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-35-l),1);--bulma-warning-35-invert-l:var(--bulma-warning-100-l);--bulma-warning-35-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-35-invert-l),1);--bulma-warning-40:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-40-l),1);--bulma-warning-40-invert-l:var(--bulma-warning-00-l);--bulma-warning-40-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-40-invert-l),1);--bulma-warning-45:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-45-l),1);--bulma-warning-45-invert-l:var(--bulma-warning-05-l);--bulma-warning-45-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-45-invert-l),1);--bulma-warning-50:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-50-l),1);--bulma-warning-50-invert-l:var(--bulma-warning-10-l);--bulma-warning-50-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-50-invert-l),1);--bulma-warning-55:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-55-l),1);--bulma-warning-55-invert-l:var(--bulma-warning-10-l);--bulma-warning-55-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-55-invert-l),1);--bulma-warning-60:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-60-l),1);--bulma-warning-60-invert-l:var(--bulma-warning-10-l);--bulma-warning-60-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-60-invert-l),1);--bulma-warning-65:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-65-l),1);--bulma-warning-65-invert-l:var(--bulma-warning-10-l);--bulma-warning-65-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-65-invert-l),1);--bulma-warning-70:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-70-l),1);--bulma-warning-70-invert-l:var(--bulma-warning-15-l);--bulma-warning-70-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-70-invert-l),1);--bulma-warning-75:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-75-l),1);--bulma-warning-75-invert-l:var(--bulma-warning-15-l);--bulma-warning-75-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-75-invert-l),1);--bulma-warning-80:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-80-l),1);--bulma-warning-80-invert-l:var(--bulma-warning-15-l);--bulma-warning-80-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-80-invert-l),1);--bulma-warning-85:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-85-l),1);--bulma-warning-85-invert-l:var(--bulma-warning-15-l);--bulma-warning-85-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-85-invert-l),1);--bulma-warning-90:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-90-l),1);--bulma-warning-90-invert-l:var(--bulma-warning-15-l);--bulma-warning-90-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-90-invert-l),1);--bulma-warning-95:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-95-l),1);--bulma-warning-95-invert-l:var(--bulma-warning-15-l);--bulma-warning-95-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-95-invert-l),1);--bulma-warning-100:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-100-l),1);--bulma-warning-100-invert-l:var(--bulma-warning-20-l);--bulma-warning-100-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-100-invert-l),1);--bulma-warning-invert-l:var(--bulma-warning-10-l);--bulma-warning-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-invert-l),1);--bulma-warning-light-l:var(--bulma-warning-90-l);--bulma-warning-light:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-light-l),1);--bulma-warning-light-invert-l:var(--bulma-warning-15-l);--bulma-warning-light-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-light-invert-l),1);--bulma-warning-dark-l:var(--bulma-warning-10-l);--bulma-warning-dark:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-dark-l),1);--bulma-warning-dark-invert-l:var(--bulma-warning-50-l);--bulma-warning-dark-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-dark-invert-l),1);--bulma-warning-soft:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-soft-l),1);--bulma-warning-bold:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-bold-l),1);--bulma-warning-soft-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-soft-invert-l),1);--bulma-warning-bold-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-bold-invert-l),1);--bulma-warning-on-scheme-l:23%;--bulma-warning-on-scheme:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-on-scheme-l),1);--bulma-danger:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-l),1);--bulma-danger-base:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-l),1);--bulma-danger-rgb:255,102,133;--bulma-danger-h:348deg;--bulma-danger-s:100%;--bulma-danger-l:70%;--bulma-danger-00-l:0%;--bulma-danger-05-l:5%;--bulma-danger-10-l:10%;--bulma-danger-15-l:15%;--bulma-danger-20-l:20%;--bulma-danger-25-l:25%;--bulma-danger-30-l:30%;--bulma-danger-35-l:35%;--bulma-danger-40-l:40%;--bulma-danger-45-l:45%;--bulma-danger-50-l:50%;--bulma-danger-55-l:55%;--bulma-danger-60-l:60%;--bulma-danger-65-l:65%;--bulma-danger-70-l:70%;--bulma-danger-75-l:75%;--bulma-danger-80-l:80%;--bulma-danger-85-l:85%;--bulma-danger-90-l:90%;--bulma-danger-95-l:95%;--bulma-danger-100-l:100%;--bulma-danger-00:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-00-l),1);--bulma-danger-00-invert-l:var(--bulma-danger-65-l);--bulma-danger-00-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-00-invert-l),1);--bulma-danger-05:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-05-l),1);--bulma-danger-05-invert-l:var(--bulma-danger-70-l);--bulma-danger-05-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-05-invert-l),1);--bulma-danger-10:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-10-l),1);--bulma-danger-10-invert-l:var(--bulma-danger-75-l);--bulma-danger-10-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-10-invert-l),1);--bulma-danger-15:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-15-l),1);--bulma-danger-15-invert-l:var(--bulma-danger-80-l);--bulma-danger-15-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-15-invert-l),1);--bulma-danger-20:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-20-l),1);--bulma-danger-20-invert-l:var(--bulma-danger-85-l);--bulma-danger-20-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-20-invert-l),1);--bulma-danger-25:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-25-l),1);--bulma-danger-25-invert-l:var(--bulma-danger-90-l);--bulma-danger-25-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-25-invert-l),1);--bulma-danger-30:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-30-l),1);--bulma-danger-30-invert-l:var(--bulma-danger-100-l);--bulma-danger-30-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-30-invert-l),1);--bulma-danger-35:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-35-l),1);--bulma-danger-35-invert-l:var(--bulma-danger-100-l);--bulma-danger-35-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-35-invert-l),1);--bulma-danger-40:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-40-l),1);--bulma-danger-40-invert-l:var(--bulma-danger-100-l);--bulma-danger-40-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-40-invert-l),1);--bulma-danger-45:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-45-l),1);--bulma-danger-45-invert-l:var(--bulma-danger-100-l);--bulma-danger-45-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-45-invert-l),1);--bulma-danger-50:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-50-l),1);--bulma-danger-50-invert-l:var(--bulma-danger-100-l);--bulma-danger-50-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-50-invert-l),1);--bulma-danger-55:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-55-l),1);--bulma-danger-55-invert-l:var(--bulma-danger-100-l);--bulma-danger-55-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-55-invert-l),1);--bulma-danger-60:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-60-l),1);--bulma-danger-60-invert-l:var(--bulma-danger-100-l);--bulma-danger-60-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-60-invert-l),1);--bulma-danger-65:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-65-l),1);--bulma-danger-65-invert-l:var(--bulma-danger-00-l);--bulma-danger-65-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-65-invert-l),1);--bulma-danger-70:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-70-l),1);--bulma-danger-70-invert-l:var(--bulma-danger-05-l);--bulma-danger-70-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-70-invert-l),1);--bulma-danger-75:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-75-l),1);--bulma-danger-75-invert-l:var(--bulma-danger-10-l);--bulma-danger-75-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-75-invert-l),1);--bulma-danger-80:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-80-l),1);--bulma-danger-80-invert-l:var(--bulma-danger-15-l);--bulma-danger-80-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-80-invert-l),1);--bulma-danger-85:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-85-l),1);--bulma-danger-85-invert-l:var(--bulma-danger-20-l);--bulma-danger-85-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-85-invert-l),1);--bulma-danger-90:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-90-l),1);--bulma-danger-90-invert-l:var(--bulma-danger-25-l);--bulma-danger-90-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-90-invert-l),1);--bulma-danger-95:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-95-l),1);--bulma-danger-95-invert-l:var(--bulma-danger-25-l);--bulma-danger-95-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-95-invert-l),1);--bulma-danger-100:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-100-l),1);--bulma-danger-100-invert-l:var(--bulma-danger-30-l);--bulma-danger-100-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-100-invert-l),1);--bulma-danger-invert-l:var(--bulma-danger-05-l);--bulma-danger-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-invert-l),1);--bulma-danger-light-l:var(--bulma-danger-90-l);--bulma-danger-light:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-light-l),1);--bulma-danger-light-invert-l:var(--bulma-danger-25-l);--bulma-danger-light-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-light-invert-l),1);--bulma-danger-dark-l:var(--bulma-danger-10-l);--bulma-danger-dark:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-dark-l),1);--bulma-danger-dark-invert-l:var(--bulma-danger-75-l);--bulma-danger-dark-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-dark-invert-l),1);--bulma-danger-soft:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-soft-l),1);--bulma-danger-bold:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-bold-l),1);--bulma-danger-soft-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-soft-invert-l),1);--bulma-danger-bold-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-bold-invert-l),1);--bulma-danger-on-scheme-l:40%;--bulma-danger-on-scheme:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-on-scheme-l),1);--bulma-black-bis:#14161a;--bulma-black-ter:#1f2229;--bulma-grey-darker:#2e333d;--bulma-grey-dark:#404654;--bulma-grey:#69748c;--bulma-grey-light:#abb1bf;--bulma-grey-lighter:#d6d9e0;--bulma-white-ter:#f3f4f6;--bulma-white-bis:#f9fafb;--bulma-shadow-h:221deg;--bulma-shadow-s:14%;--bulma-shadow-l:4%;--bulma-size-1:3rem;--bulma-size-2:2.5rem;--bulma-size-3:2rem;--bulma-size-4:1.5rem;--bulma-size-5:1.25rem;--bulma-size-6:1rem;--bulma-size-7:.75rem;--bulma-scheme-main:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-scheme-main-l));--bulma-scheme-main-bis:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-scheme-main-bis-l));--bulma-scheme-main-ter:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-scheme-main-ter-l));--bulma-background:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-background-l));--bulma-background-hover:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),calc(var(--bulma-background-l) + var(--bulma-hover-background-l-delta)));--bulma-background-active:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),calc(var(--bulma-background-l) + var(--bulma-active-background-l-delta)));--bulma-border-weak:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-border-weak-l));--bulma-border:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-border-l));--bulma-border-hover:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),calc(var(--bulma-border-l) + var(--bulma-hover-border-l-delta)));--bulma-border-active:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),calc(var(--bulma-border-l) + var(--bulma-active-border-l-delta)));--bulma-text-weak:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-weak-l));--bulma-text-strong:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-strong-l));--bulma-scheme-invert-ter:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-scheme-invert-ter-l));--bulma-scheme-invert-bis:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-scheme-invert-bis-l));--bulma-scheme-invert:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-scheme-invert-l));--bulma-link-text:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-on-scheme-l));--bulma-link-text-hover:hsl(var(--bulma-link-h),var(--bulma-link-s),calc(var(--bulma-link-on-scheme-l) + var(--bulma-hover-color-l-delta)));--bulma-link-text-active:hsl(var(--bulma-link-h),var(--bulma-link-s),calc(var(--bulma-link-on-scheme-l) + var(--bulma-active-color-l-delta)));--bulma-focus-h:var(--bulma-link-h);--bulma-focus-s:var(--bulma-link-s);--bulma-focus-l:var(--bulma-link-l);--bulma-focus-offset:1px;--bulma-focus-style:solid;--bulma-focus-width:2px;--bulma-focus-shadow-size:0 0 0 .1875em;--bulma-focus-shadow-alpha:.25;--bulma-code:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-on-scheme-l));--bulma-code-background:var(--bulma-background);--bulma-pre:var(--bulma-text);--bulma-pre-background:var(--bulma-background);--bulma-shadow:0 .5em 1em -.125em hsla(var(--bulma-shadow-h),var(--bulma-shadow-s),var(--bulma-shadow-l),.1),0 0px 0 1px hsla(var(--bulma-shadow-h),var(--bulma-shadow-s),var(--bulma-shadow-l),.02)}@media (prefers-color-scheme:light){:root{--bulma-scheme-h:221;--bulma-scheme-s:14%;--bulma-light-l:96%;--bulma-light-invert-l:21%;--bulma-dark-l:21%;--bulma-dark-invert-l:96%;--bulma-soft-l:90%;--bulma-bold-l:20%;--bulma-soft-invert-l:20%;--bulma-bold-invert-l:90%;--bulma-hover-background-l-delta:-5%;--bulma-active-background-l-delta:-10%;--bulma-hover-border-l-delta:-10%;--bulma-active-border-l-delta:-20%;--bulma-hover-color-l-delta:-5%;--bulma-active-color-l-delta:-10%;--bulma-hover-shadow-a-delta:-.05;--bulma-active-shadow-a-delta:-.1;--bulma-scheme-brightness:light;--bulma-scheme-main-l:100%;--bulma-scheme-main-bis-l:98%;--bulma-scheme-main-ter-l:96%;--bulma-background-l:96%;--bulma-border-weak-l:93%;--bulma-border-l:86%;--bulma-text-weak-l:48%;--bulma-text-l:29%;--bulma-text-strong-l:21%;--bulma-text-title-l:14%;--bulma-scheme-invert-ter-l:14%;--bulma-scheme-invert-bis-l:7%;--bulma-scheme-invert-l:4%;--bulma-family-primary:Inter,SF Pro,Segoe UI,Roboto,Oxygen,Ubuntu,Helvetica Neue,Helvetica,Arial,sans-serif;--bulma-family-secondary:Inter,SF Pro,Segoe UI,Roboto,Oxygen,Ubuntu,Helvetica Neue,Helvetica,Arial,sans-serif;--bulma-family-code:Inconsolata,Hack,SF Mono,Roboto Mono,Source Code Pro,Ubuntu Mono,monospace;--bulma-size-small:.75rem;--bulma-size-normal:1rem;--bulma-size-medium:1.25rem;--bulma-size-large:1.5rem;--bulma-weight-light:300;--bulma-weight-normal:400;--bulma-weight-medium:500;--bulma-weight-semibold:600;--bulma-weight-bold:700;--bulma-weight-extrabold:800;--bulma-block-spacing:1.5rem;--bulma-duration:.294s;--bulma-easing:ease-out;--bulma-radius-small:.25rem;--bulma-radius:.375rem;--bulma-radius-medium:.5em;--bulma-radius-large:.75rem;--bulma-radius-rounded:9999px;--bulma-speed:86ms;--bulma-arrow-color:var(--bulma-link);--bulma-loading-color:var(--bulma-border);--bulma-burger-h:var(--bulma-link-h);--bulma-burger-s:var(--bulma-link-s);--bulma-burger-l:var(--bulma-link-l);--bulma-burger-border-radius:.5em;--bulma-burger-gap:5px;--bulma-burger-item-height:2px;--bulma-burger-item-width:20px;--bulma-white:hsla(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-l),1);--bulma-white-base:hsla(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-l),1);--bulma-white-rgb:255,255,255;--bulma-white-h:221deg;--bulma-white-s:14%;--bulma-white-l:100%;--bulma-white-invert-l:4%;--bulma-white-invert:#090a0c;--bulma-white-on-scheme-l:35%;--bulma-white-on-scheme:hsla(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-on-scheme-l),1);--bulma-black:hsla(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-l),1);--bulma-black-base:hsla(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-l),1);--bulma-black-rgb:9,10,12;--bulma-black-h:221deg;--bulma-black-s:14%;--bulma-black-l:4%;--bulma-black-invert-l:100%;--bulma-black-invert:#fff;--bulma-black-on-scheme-l:4%;--bulma-black-on-scheme:hsla(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-on-scheme-l),1);--bulma-light:hsla(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-l),1);--bulma-light-base:hsla(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-l),1);--bulma-light-rgb:243,244,246;--bulma-light-h:221deg;--bulma-light-s:14%;--bulma-light-invert:#2e333d;--bulma-light-on-scheme-l:36%;--bulma-light-on-scheme:hsla(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-on-scheme-l),1);--bulma-dark:hsla(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-l),1);--bulma-dark-base:hsla(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-l),1);--bulma-dark-rgb:46,51,61;--bulma-dark-h:221deg;--bulma-dark-s:14%;--bulma-dark-invert:#f3f4f6;--bulma-dark-on-scheme-l:21%;--bulma-dark-on-scheme:hsla(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-on-scheme-l),1);--bulma-text:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-l),1);--bulma-text-base:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-l),1);--bulma-text-rgb:64,70,84;--bulma-text-h:221deg;--bulma-text-s:14%;--bulma-text-00-l:0%;--bulma-text-05-l:4%;--bulma-text-10-l:9%;--bulma-text-15-l:14%;--bulma-text-20-l:19%;--bulma-text-25-l:24%;--bulma-text-30-l:29%;--bulma-text-35-l:34%;--bulma-text-40-l:39%;--bulma-text-45-l:44%;--bulma-text-50-l:49%;--bulma-text-55-l:54%;--bulma-text-60-l:59%;--bulma-text-65-l:64%;--bulma-text-70-l:69%;--bulma-text-75-l:74%;--bulma-text-80-l:79%;--bulma-text-85-l:84%;--bulma-text-90-l:89%;--bulma-text-95-l:94%;--bulma-text-100-l:99%;--bulma-text-00:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-00-l),1);--bulma-text-00-invert-l:var(--bulma-text-60-l);--bulma-text-00-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-00-invert-l),1);--bulma-text-05:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-05-l),1);--bulma-text-05-invert-l:var(--bulma-text-60-l);--bulma-text-05-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-05-invert-l),1);--bulma-text-10:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-10-l),1);--bulma-text-10-invert-l:var(--bulma-text-70-l);--bulma-text-10-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-10-invert-l),1);--bulma-text-15:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-15-l),1);--bulma-text-15-invert-l:var(--bulma-text-75-l);--bulma-text-15-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-15-invert-l),1);--bulma-text-20:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-20-l),1);--bulma-text-20-invert-l:var(--bulma-text-85-l);--bulma-text-20-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-20-invert-l),1);--bulma-text-25:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-25-l),1);--bulma-text-25-invert-l:var(--bulma-text-95-l);--bulma-text-25-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-25-invert-l),1);--bulma-text-30:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-30-l),1);--bulma-text-30-invert-l:var(--bulma-text-100-l);--bulma-text-30-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-30-invert-l),1);--bulma-text-35:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-35-l),1);--bulma-text-35-invert-l:var(--bulma-text-100-l);--bulma-text-35-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-35-invert-l),1);--bulma-text-40:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-40-l),1);--bulma-text-40-invert-l:var(--bulma-text-100-l);--bulma-text-40-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-40-invert-l),1);--bulma-text-45:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-45-l),1);--bulma-text-45-invert-l:var(--bulma-text-100-l);--bulma-text-45-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-45-invert-l),1);--bulma-text-50:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-50-l),1);--bulma-text-50-invert-l:var(--bulma-text-100-l);--bulma-text-50-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-50-invert-l),1);--bulma-text-55:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-55-l),1);--bulma-text-55-invert-l:var(--bulma-text-100-l);--bulma-text-55-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-55-invert-l),1);--bulma-text-60:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-60-l),1);--bulma-text-60-invert-l:var(--bulma-text-05-l);--bulma-text-60-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-60-invert-l),1);--bulma-text-65:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-65-l),1);--bulma-text-65-invert-l:var(--bulma-text-05-l);--bulma-text-65-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-65-invert-l),1);--bulma-text-70:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-70-l),1);--bulma-text-70-invert-l:var(--bulma-text-10-l);--bulma-text-70-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-70-invert-l),1);--bulma-text-75:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-75-l),1);--bulma-text-75-invert-l:var(--bulma-text-15-l);--bulma-text-75-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-75-invert-l),1);--bulma-text-80:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-80-l),1);--bulma-text-80-invert-l:var(--bulma-text-15-l);--bulma-text-80-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-80-invert-l),1);--bulma-text-85:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-85-l),1);--bulma-text-85-invert-l:var(--bulma-text-20-l);--bulma-text-85-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-85-invert-l),1);--bulma-text-90:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-90-l),1);--bulma-text-90-invert-l:var(--bulma-text-20-l);--bulma-text-90-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-90-invert-l),1);--bulma-text-95:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-95-l),1);--bulma-text-95-invert-l:var(--bulma-text-25-l);--bulma-text-95-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-95-invert-l),1);--bulma-text-100:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-100-l),1);--bulma-text-100-invert-l:var(--bulma-text-25-l);--bulma-text-100-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-100-invert-l),1);--bulma-text-invert-l:var(--bulma-text-100-l);--bulma-text-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-invert-l),1);--bulma-text-light-l:var(--bulma-text-90-l);--bulma-text-light:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-light-l),1);--bulma-text-light-invert-l:var(--bulma-text-20-l);--bulma-text-light-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-light-invert-l),1);--bulma-text-dark-l:var(--bulma-text-10-l);--bulma-text-dark:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-dark-l),1);--bulma-text-dark-invert-l:var(--bulma-text-70-l);--bulma-text-dark-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-dark-invert-l),1);--bulma-text-soft:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-soft-l),1);--bulma-text-bold:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-bold-l),1);--bulma-text-soft-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-soft-invert-l),1);--bulma-text-bold-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-bold-invert-l),1);--bulma-text-on-scheme-l:29%;--bulma-text-on-scheme:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-on-scheme-l),1);--bulma-primary:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-l),1);--bulma-primary-base:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-l),1);--bulma-primary-rgb:0,209,178;--bulma-primary-h:171deg;--bulma-primary-s:100%;--bulma-primary-l:41%;--bulma-primary-00-l:1%;--bulma-primary-05-l:6%;--bulma-primary-10-l:11%;--bulma-primary-15-l:16%;--bulma-primary-20-l:21%;--bulma-primary-25-l:26%;--bulma-primary-30-l:31%;--bulma-primary-35-l:36%;--bulma-primary-40-l:41%;--bulma-primary-45-l:46%;--bulma-primary-50-l:51%;--bulma-primary-55-l:56%;--bulma-primary-60-l:61%;--bulma-primary-65-l:66%;--bulma-primary-70-l:71%;--bulma-primary-75-l:76%;--bulma-primary-80-l:81%;--bulma-primary-85-l:86%;--bulma-primary-90-l:91%;--bulma-primary-95-l:96%;--bulma-primary-100-l:100%;--bulma-primary-00:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-00-l),1);--bulma-primary-00-invert-l:var(--bulma-primary-30-l);--bulma-primary-00-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-00-invert-l),1);--bulma-primary-05:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-05-l),1);--bulma-primary-05-invert-l:var(--bulma-primary-40-l);--bulma-primary-05-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-05-invert-l),1);--bulma-primary-10:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-10-l),1);--bulma-primary-10-invert-l:var(--bulma-primary-50-l);--bulma-primary-10-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-10-invert-l),1);--bulma-primary-15:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-15-l),1);--bulma-primary-15-invert-l:var(--bulma-primary-100-l);--bulma-primary-15-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-15-invert-l),1);--bulma-primary-20:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-20-l),1);--bulma-primary-20-invert-l:var(--bulma-primary-100-l);--bulma-primary-20-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-20-invert-l),1);--bulma-primary-25:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-25-l),1);--bulma-primary-25-invert-l:var(--bulma-primary-100-l);--bulma-primary-25-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-25-invert-l),1);--bulma-primary-30:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-30-l),1);--bulma-primary-30-invert-l:var(--bulma-primary-00-l);--bulma-primary-30-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-30-invert-l),1);--bulma-primary-35:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-35-l),1);--bulma-primary-35-invert-l:var(--bulma-primary-00-l);--bulma-primary-35-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-35-invert-l),1);--bulma-primary-40:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-40-l),1);--bulma-primary-40-invert-l:var(--bulma-primary-05-l);--bulma-primary-40-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-40-invert-l),1);--bulma-primary-45:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-45-l),1);--bulma-primary-45-invert-l:var(--bulma-primary-05-l);--bulma-primary-45-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-45-invert-l),1);--bulma-primary-50:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-50-l),1);--bulma-primary-50-invert-l:var(--bulma-primary-10-l);--bulma-primary-50-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-50-invert-l),1);--bulma-primary-55:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-55-l),1);--bulma-primary-55-invert-l:var(--bulma-primary-10-l);--bulma-primary-55-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-55-invert-l),1);--bulma-primary-60:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-60-l),1);--bulma-primary-60-invert-l:var(--bulma-primary-10-l);--bulma-primary-60-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-60-invert-l),1);--bulma-primary-65:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-65-l),1);--bulma-primary-65-invert-l:var(--bulma-primary-10-l);--bulma-primary-65-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-65-invert-l),1);--bulma-primary-70:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-70-l),1);--bulma-primary-70-invert-l:var(--bulma-primary-10-l);--bulma-primary-70-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-70-invert-l),1);--bulma-primary-75:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-75-l),1);--bulma-primary-75-invert-l:var(--bulma-primary-10-l);--bulma-primary-75-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-75-invert-l),1);--bulma-primary-80:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-80-l),1);--bulma-primary-80-invert-l:var(--bulma-primary-10-l);--bulma-primary-80-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-80-invert-l),1);--bulma-primary-85:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-85-l),1);--bulma-primary-85-invert-l:var(--bulma-primary-10-l);--bulma-primary-85-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-85-invert-l),1);--bulma-primary-90:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-90-l),1);--bulma-primary-90-invert-l:var(--bulma-primary-10-l);--bulma-primary-90-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-90-invert-l),1);--bulma-primary-95:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-95-l),1);--bulma-primary-95-invert-l:var(--bulma-primary-10-l);--bulma-primary-95-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-95-invert-l),1);--bulma-primary-100:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-100-l),1);--bulma-primary-100-invert-l:var(--bulma-primary-15-l);--bulma-primary-100-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-100-invert-l),1);--bulma-primary-invert-l:var(--bulma-primary-05-l);--bulma-primary-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-invert-l),1);--bulma-primary-light-l:var(--bulma-primary-90-l);--bulma-primary-light:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-light-l),1);--bulma-primary-light-invert-l:var(--bulma-primary-10-l);--bulma-primary-light-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-light-invert-l),1);--bulma-primary-dark-l:var(--bulma-primary-10-l);--bulma-primary-dark:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-dark-l),1);--bulma-primary-dark-invert-l:var(--bulma-primary-50-l);--bulma-primary-dark-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-dark-invert-l),1);--bulma-primary-soft:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-soft-l),1);--bulma-primary-bold:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-bold-l),1);--bulma-primary-soft-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-soft-invert-l),1);--bulma-primary-bold-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-bold-invert-l),1);--bulma-primary-on-scheme-l:21%;--bulma-primary-on-scheme:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-on-scheme-l),1);--bulma-link:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-l),1);--bulma-link-base:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-l),1);--bulma-link-rgb:66,88,255;--bulma-link-h:233deg;--bulma-link-s:100%;--bulma-link-l:63%;--bulma-link-00-l:0%;--bulma-link-05-l:3%;--bulma-link-10-l:8%;--bulma-link-15-l:13%;--bulma-link-20-l:18%;--bulma-link-25-l:23%;--bulma-link-30-l:28%;--bulma-link-35-l:33%;--bulma-link-40-l:38%;--bulma-link-45-l:43%;--bulma-link-50-l:48%;--bulma-link-55-l:53%;--bulma-link-60-l:58%;--bulma-link-65-l:63%;--bulma-link-70-l:68%;--bulma-link-75-l:73%;--bulma-link-80-l:78%;--bulma-link-85-l:83%;--bulma-link-90-l:88%;--bulma-link-95-l:93%;--bulma-link-100-l:98%;--bulma-link-00:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-00-l),1);--bulma-link-00-invert-l:var(--bulma-link-75-l);--bulma-link-00-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-00-invert-l),1);--bulma-link-05:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-05-l),1);--bulma-link-05-invert-l:var(--bulma-link-75-l);--bulma-link-05-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-05-invert-l),1);--bulma-link-10:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-10-l),1);--bulma-link-10-invert-l:var(--bulma-link-75-l);--bulma-link-10-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-10-invert-l),1);--bulma-link-15:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-15-l),1);--bulma-link-15-invert-l:var(--bulma-link-80-l);--bulma-link-15-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-15-invert-l),1);--bulma-link-20:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-20-l),1);--bulma-link-20-invert-l:var(--bulma-link-80-l);--bulma-link-20-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-20-invert-l),1);--bulma-link-25:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-25-l),1);--bulma-link-25-invert-l:var(--bulma-link-85-l);--bulma-link-25-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-25-invert-l),1);--bulma-link-30:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-30-l),1);--bulma-link-30-invert-l:var(--bulma-link-90-l);--bulma-link-30-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-30-invert-l),1);--bulma-link-35:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-35-l),1);--bulma-link-35-invert-l:var(--bulma-link-90-l);--bulma-link-35-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-35-invert-l),1);--bulma-link-40:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-40-l),1);--bulma-link-40-invert-l:var(--bulma-link-95-l);--bulma-link-40-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-40-invert-l),1);--bulma-link-45:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-45-l),1);--bulma-link-45-invert-l:var(--bulma-link-100-l);--bulma-link-45-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-45-invert-l),1);--bulma-link-50:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-50-l),1);--bulma-link-50-invert-l:var(--bulma-link-100-l);--bulma-link-50-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-50-invert-l),1);--bulma-link-55:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-55-l),1);--bulma-link-55-invert-l:var(--bulma-link-100-l);--bulma-link-55-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-55-invert-l),1);--bulma-link-60:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-60-l),1);--bulma-link-60-invert-l:var(--bulma-link-100-l);--bulma-link-60-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-60-invert-l),1);--bulma-link-65:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-65-l),1);--bulma-link-65-invert-l:var(--bulma-link-100-l);--bulma-link-65-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-65-invert-l),1);--bulma-link-70:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-70-l),1);--bulma-link-70-invert-l:var(--bulma-link-100-l);--bulma-link-70-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-70-invert-l),1);--bulma-link-75:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-75-l),1);--bulma-link-75-invert-l:var(--bulma-link-10-l);--bulma-link-75-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-75-invert-l),1);--bulma-link-80:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-80-l),1);--bulma-link-80-invert-l:var(--bulma-link-20-l);--bulma-link-80-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-80-invert-l),1);--bulma-link-85:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-85-l),1);--bulma-link-85-invert-l:var(--bulma-link-25-l);--bulma-link-85-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-85-invert-l),1);--bulma-link-90:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-90-l),1);--bulma-link-90-invert-l:var(--bulma-link-35-l);--bulma-link-90-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-90-invert-l),1);--bulma-link-95:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-95-l),1);--bulma-link-95-invert-l:var(--bulma-link-40-l);--bulma-link-95-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-95-invert-l),1);--bulma-link-100:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-100-l),1);--bulma-link-100-invert-l:var(--bulma-link-50-l);--bulma-link-100-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-100-invert-l),1);--bulma-link-invert-l:var(--bulma-link-100-l);--bulma-link-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-invert-l),1);--bulma-link-light-l:var(--bulma-link-90-l);--bulma-link-light:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-light-l),1);--bulma-link-light-invert-l:var(--bulma-link-35-l);--bulma-link-light-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-light-invert-l),1);--bulma-link-dark-l:var(--bulma-link-10-l);--bulma-link-dark:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-dark-l),1);--bulma-link-dark-invert-l:var(--bulma-link-75-l);--bulma-link-dark-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-dark-invert-l),1);--bulma-link-soft:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-soft-l),1);--bulma-link-bold:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-bold-l),1);--bulma-link-soft-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-soft-invert-l),1);--bulma-link-bold-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-bold-invert-l),1);--bulma-link-on-scheme-l:58%;--bulma-link-on-scheme:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-on-scheme-l),1);--bulma-info:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-l),1);--bulma-info-base:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-l),1);--bulma-info-rgb:102,209,255;--bulma-info-h:198deg;--bulma-info-s:100%;--bulma-info-l:70%;--bulma-info-00-l:0%;--bulma-info-05-l:5%;--bulma-info-10-l:10%;--bulma-info-15-l:15%;--bulma-info-20-l:20%;--bulma-info-25-l:25%;--bulma-info-30-l:30%;--bulma-info-35-l:35%;--bulma-info-40-l:40%;--bulma-info-45-l:45%;--bulma-info-50-l:50%;--bulma-info-55-l:55%;--bulma-info-60-l:60%;--bulma-info-65-l:65%;--bulma-info-70-l:70%;--bulma-info-75-l:75%;--bulma-info-80-l:80%;--bulma-info-85-l:85%;--bulma-info-90-l:90%;--bulma-info-95-l:95%;--bulma-info-100-l:100%;--bulma-info-00:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-00-l),1);--bulma-info-00-invert-l:var(--bulma-info-45-l);--bulma-info-00-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-00-invert-l),1);--bulma-info-05:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-05-l),1);--bulma-info-05-invert-l:var(--bulma-info-50-l);--bulma-info-05-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-05-invert-l),1);--bulma-info-10:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-10-l),1);--bulma-info-10-invert-l:var(--bulma-info-60-l);--bulma-info-10-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-10-invert-l),1);--bulma-info-15:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-15-l),1);--bulma-info-15-invert-l:var(--bulma-info-80-l);--bulma-info-15-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-15-invert-l),1);--bulma-info-20:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-20-l),1);--bulma-info-20-invert-l:var(--bulma-info-95-l);--bulma-info-20-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-20-invert-l),1);--bulma-info-25:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-25-l),1);--bulma-info-25-invert-l:var(--bulma-info-100-l);--bulma-info-25-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-25-invert-l),1);--bulma-info-30:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-30-l),1);--bulma-info-30-invert-l:var(--bulma-info-100-l);--bulma-info-30-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-30-invert-l),1);--bulma-info-35:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-35-l),1);--bulma-info-35-invert-l:var(--bulma-info-100-l);--bulma-info-35-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-35-invert-l),1);--bulma-info-40:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-40-l),1);--bulma-info-40-invert-l:var(--bulma-info-100-l);--bulma-info-40-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-40-invert-l),1);--bulma-info-45:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-45-l),1);--bulma-info-45-invert-l:var(--bulma-info-00-l);--bulma-info-45-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-45-invert-l),1);--bulma-info-50:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-50-l),1);--bulma-info-50-invert-l:var(--bulma-info-05-l);--bulma-info-50-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-50-invert-l),1);--bulma-info-55:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-55-l),1);--bulma-info-55-invert-l:var(--bulma-info-05-l);--bulma-info-55-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-55-invert-l),1);--bulma-info-60:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-60-l),1);--bulma-info-60-invert-l:var(--bulma-info-10-l);--bulma-info-60-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-60-invert-l),1);--bulma-info-65:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-65-l),1);--bulma-info-65-invert-l:var(--bulma-info-10-l);--bulma-info-65-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-65-invert-l),1);--bulma-info-70:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-70-l),1);--bulma-info-70-invert-l:var(--bulma-info-10-l);--bulma-info-70-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-70-invert-l),1);--bulma-info-75:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-75-l),1);--bulma-info-75-invert-l:var(--bulma-info-10-l);--bulma-info-75-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-75-invert-l),1);--bulma-info-80:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-80-l),1);--bulma-info-80-invert-l:var(--bulma-info-15-l);--bulma-info-80-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-80-invert-l),1);--bulma-info-85:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-85-l),1);--bulma-info-85-invert-l:var(--bulma-info-15-l);--bulma-info-85-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-85-invert-l),1);--bulma-info-90:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-90-l),1);--bulma-info-90-invert-l:var(--bulma-info-15-l);--bulma-info-90-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-90-invert-l),1);--bulma-info-95:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-95-l),1);--bulma-info-95-invert-l:var(--bulma-info-20-l);--bulma-info-95-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-95-invert-l),1);--bulma-info-100:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-100-l),1);--bulma-info-100-invert-l:var(--bulma-info-20-l);--bulma-info-100-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-100-invert-l),1);--bulma-info-invert-l:var(--bulma-info-10-l);--bulma-info-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-invert-l),1);--bulma-info-light-l:var(--bulma-info-90-l);--bulma-info-light:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-light-l),1);--bulma-info-light-invert-l:var(--bulma-info-15-l);--bulma-info-light-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-light-invert-l),1);--bulma-info-dark-l:var(--bulma-info-10-l);--bulma-info-dark:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-dark-l),1);--bulma-info-dark-invert-l:var(--bulma-info-60-l);--bulma-info-dark-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-dark-invert-l),1);--bulma-info-soft:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-soft-l),1);--bulma-info-bold:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-bold-l),1);--bulma-info-soft-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-soft-invert-l),1);--bulma-info-bold-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-bold-invert-l),1);--bulma-info-on-scheme-l:25%;--bulma-info-on-scheme:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-on-scheme-l),1);--bulma-success:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-l),1);--bulma-success-base:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-l),1);--bulma-success-rgb:72,199,142;--bulma-success-h:153deg;--bulma-success-s:53%;--bulma-success-l:53%;--bulma-success-00-l:0%;--bulma-success-05-l:3%;--bulma-success-10-l:8%;--bulma-success-15-l:13%;--bulma-success-20-l:18%;--bulma-success-25-l:23%;--bulma-success-30-l:28%;--bulma-success-35-l:33%;--bulma-success-40-l:38%;--bulma-success-45-l:43%;--bulma-success-50-l:48%;--bulma-success-55-l:53%;--bulma-success-60-l:58%;--bulma-success-65-l:63%;--bulma-success-70-l:68%;--bulma-success-75-l:73%;--bulma-success-80-l:78%;--bulma-success-85-l:83%;--bulma-success-90-l:88%;--bulma-success-95-l:93%;--bulma-success-100-l:98%;--bulma-success-00:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-00-l),1);--bulma-success-00-invert-l:var(--bulma-success-45-l);--bulma-success-00-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-00-invert-l),1);--bulma-success-05:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-05-l),1);--bulma-success-05-invert-l:var(--bulma-success-45-l);--bulma-success-05-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-05-invert-l),1);--bulma-success-10:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-10-l),1);--bulma-success-10-invert-l:var(--bulma-success-55-l);--bulma-success-10-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-10-invert-l),1);--bulma-success-15:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-15-l),1);--bulma-success-15-invert-l:var(--bulma-success-75-l);--bulma-success-15-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-15-invert-l),1);--bulma-success-20:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-20-l),1);--bulma-success-20-invert-l:var(--bulma-success-90-l);--bulma-success-20-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-20-invert-l),1);--bulma-success-25:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-25-l),1);--bulma-success-25-invert-l:var(--bulma-success-100-l);--bulma-success-25-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-25-invert-l),1);--bulma-success-30:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-30-l),1);--bulma-success-30-invert-l:var(--bulma-success-100-l);--bulma-success-30-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-30-invert-l),1);--bulma-success-35:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-35-l),1);--bulma-success-35-invert-l:var(--bulma-success-100-l);--bulma-success-35-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-35-invert-l),1);--bulma-success-40:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-40-l),1);--bulma-success-40-invert-l:var(--bulma-success-100-l);--bulma-success-40-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-40-invert-l),1);--bulma-success-45:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-45-l),1);--bulma-success-45-invert-l:var(--bulma-success-05-l);--bulma-success-45-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-45-invert-l),1);--bulma-success-50:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-50-l),1);--bulma-success-50-invert-l:var(--bulma-success-05-l);--bulma-success-50-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-50-invert-l),1);--bulma-success-55:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-55-l),1);--bulma-success-55-invert-l:var(--bulma-success-10-l);--bulma-success-55-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-55-invert-l),1);--bulma-success-60:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-60-l),1);--bulma-success-60-invert-l:var(--bulma-success-10-l);--bulma-success-60-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-60-invert-l),1);--bulma-success-65:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-65-l),1);--bulma-success-65-invert-l:var(--bulma-success-10-l);--bulma-success-65-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-65-invert-l),1);--bulma-success-70:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-70-l),1);--bulma-success-70-invert-l:var(--bulma-success-10-l);--bulma-success-70-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-70-invert-l),1);--bulma-success-75:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-75-l),1);--bulma-success-75-invert-l:var(--bulma-success-15-l);--bulma-success-75-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-75-invert-l),1);--bulma-success-80:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-80-l),1);--bulma-success-80-invert-l:var(--bulma-success-15-l);--bulma-success-80-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-80-invert-l),1);--bulma-success-85:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-85-l),1);--bulma-success-85-invert-l:var(--bulma-success-15-l);--bulma-success-85-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-85-invert-l),1);--bulma-success-90:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-90-l),1);--bulma-success-90-invert-l:var(--bulma-success-20-l);--bulma-success-90-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-90-invert-l),1);--bulma-success-95:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-95-l),1);--bulma-success-95-invert-l:var(--bulma-success-20-l);--bulma-success-95-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-95-invert-l),1);--bulma-success-100:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-100-l),1);--bulma-success-100-invert-l:var(--bulma-success-20-l);--bulma-success-100-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-100-invert-l),1);--bulma-success-invert-l:var(--bulma-success-10-l);--bulma-success-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-invert-l),1);--bulma-success-light-l:var(--bulma-success-90-l);--bulma-success-light:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-light-l),1);--bulma-success-light-invert-l:var(--bulma-success-20-l);--bulma-success-light-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-light-invert-l),1);--bulma-success-dark-l:var(--bulma-success-10-l);--bulma-success-dark:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-dark-l),1);--bulma-success-dark-invert-l:var(--bulma-success-55-l);--bulma-success-dark-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-dark-invert-l),1);--bulma-success-soft:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-soft-l),1);--bulma-success-bold:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-bold-l),1);--bulma-success-soft-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-soft-invert-l),1);--bulma-success-bold-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-bold-invert-l),1);--bulma-success-on-scheme-l:23%;--bulma-success-on-scheme:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-on-scheme-l),1);--bulma-warning:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-l),1);--bulma-warning-base:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-l),1);--bulma-warning-rgb:255,183,15;--bulma-warning-h:42deg;--bulma-warning-s:100%;--bulma-warning-l:53%;--bulma-warning-00-l:0%;--bulma-warning-05-l:3%;--bulma-warning-10-l:8%;--bulma-warning-15-l:13%;--bulma-warning-20-l:18%;--bulma-warning-25-l:23%;--bulma-warning-30-l:28%;--bulma-warning-35-l:33%;--bulma-warning-40-l:38%;--bulma-warning-45-l:43%;--bulma-warning-50-l:48%;--bulma-warning-55-l:53%;--bulma-warning-60-l:58%;--bulma-warning-65-l:63%;--bulma-warning-70-l:68%;--bulma-warning-75-l:73%;--bulma-warning-80-l:78%;--bulma-warning-85-l:83%;--bulma-warning-90-l:88%;--bulma-warning-95-l:93%;--bulma-warning-100-l:98%;--bulma-warning-00:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-00-l),1);--bulma-warning-00-invert-l:var(--bulma-warning-40-l);--bulma-warning-00-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-00-invert-l),1);--bulma-warning-05:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-05-l),1);--bulma-warning-05-invert-l:var(--bulma-warning-45-l);--bulma-warning-05-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-05-invert-l),1);--bulma-warning-10:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-10-l),1);--bulma-warning-10-invert-l:var(--bulma-warning-50-l);--bulma-warning-10-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-10-invert-l),1);--bulma-warning-15:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-15-l),1);--bulma-warning-15-invert-l:var(--bulma-warning-70-l);--bulma-warning-15-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-15-invert-l),1);--bulma-warning-20:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-20-l),1);--bulma-warning-20-invert-l:var(--bulma-warning-100-l);--bulma-warning-20-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-20-invert-l),1);--bulma-warning-25:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-25-l),1);--bulma-warning-25-invert-l:var(--bulma-warning-100-l);--bulma-warning-25-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-25-invert-l),1);--bulma-warning-30:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-30-l),1);--bulma-warning-30-invert-l:var(--bulma-warning-100-l);--bulma-warning-30-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-30-invert-l),1);--bulma-warning-35:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-35-l),1);--bulma-warning-35-invert-l:var(--bulma-warning-100-l);--bulma-warning-35-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-35-invert-l),1);--bulma-warning-40:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-40-l),1);--bulma-warning-40-invert-l:var(--bulma-warning-00-l);--bulma-warning-40-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-40-invert-l),1);--bulma-warning-45:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-45-l),1);--bulma-warning-45-invert-l:var(--bulma-warning-05-l);--bulma-warning-45-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-45-invert-l),1);--bulma-warning-50:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-50-l),1);--bulma-warning-50-invert-l:var(--bulma-warning-10-l);--bulma-warning-50-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-50-invert-l),1);--bulma-warning-55:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-55-l),1);--bulma-warning-55-invert-l:var(--bulma-warning-10-l);--bulma-warning-55-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-55-invert-l),1);--bulma-warning-60:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-60-l),1);--bulma-warning-60-invert-l:var(--bulma-warning-10-l);--bulma-warning-60-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-60-invert-l),1);--bulma-warning-65:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-65-l),1);--bulma-warning-65-invert-l:var(--bulma-warning-10-l);--bulma-warning-65-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-65-invert-l),1);--bulma-warning-70:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-70-l),1);--bulma-warning-70-invert-l:var(--bulma-warning-15-l);--bulma-warning-70-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-70-invert-l),1);--bulma-warning-75:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-75-l),1);--bulma-warning-75-invert-l:var(--bulma-warning-15-l);--bulma-warning-75-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-75-invert-l),1);--bulma-warning-80:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-80-l),1);--bulma-warning-80-invert-l:var(--bulma-warning-15-l);--bulma-warning-80-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-80-invert-l),1);--bulma-warning-85:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-85-l),1);--bulma-warning-85-invert-l:var(--bulma-warning-15-l);--bulma-warning-85-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-85-invert-l),1);--bulma-warning-90:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-90-l),1);--bulma-warning-90-invert-l:var(--bulma-warning-15-l);--bulma-warning-90-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-90-invert-l),1);--bulma-warning-95:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-95-l),1);--bulma-warning-95-invert-l:var(--bulma-warning-15-l);--bulma-warning-95-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-95-invert-l),1);--bulma-warning-100:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-100-l),1);--bulma-warning-100-invert-l:var(--bulma-warning-20-l);--bulma-warning-100-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-100-invert-l),1);--bulma-warning-invert-l:var(--bulma-warning-10-l);--bulma-warning-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-invert-l),1);--bulma-warning-light-l:var(--bulma-warning-90-l);--bulma-warning-light:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-light-l),1);--bulma-warning-light-invert-l:var(--bulma-warning-15-l);--bulma-warning-light-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-light-invert-l),1);--bulma-warning-dark-l:var(--bulma-warning-10-l);--bulma-warning-dark:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-dark-l),1);--bulma-warning-dark-invert-l:var(--bulma-warning-50-l);--bulma-warning-dark-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-dark-invert-l),1);--bulma-warning-soft:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-soft-l),1);--bulma-warning-bold:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-bold-l),1);--bulma-warning-soft-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-soft-invert-l),1);--bulma-warning-bold-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-bold-invert-l),1);--bulma-warning-on-scheme-l:23%;--bulma-warning-on-scheme:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-on-scheme-l),1);--bulma-danger:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-l),1);--bulma-danger-base:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-l),1);--bulma-danger-rgb:255,102,133;--bulma-danger-h:348deg;--bulma-danger-s:100%;--bulma-danger-l:70%;--bulma-danger-00-l:0%;--bulma-danger-05-l:5%;--bulma-danger-10-l:10%;--bulma-danger-15-l:15%;--bulma-danger-20-l:20%;--bulma-danger-25-l:25%;--bulma-danger-30-l:30%;--bulma-danger-35-l:35%;--bulma-danger-40-l:40%;--bulma-danger-45-l:45%;--bulma-danger-50-l:50%;--bulma-danger-55-l:55%;--bulma-danger-60-l:60%;--bulma-danger-65-l:65%;--bulma-danger-70-l:70%;--bulma-danger-75-l:75%;--bulma-danger-80-l:80%;--bulma-danger-85-l:85%;--bulma-danger-90-l:90%;--bulma-danger-95-l:95%;--bulma-danger-100-l:100%;--bulma-danger-00:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-00-l),1);--bulma-danger-00-invert-l:var(--bulma-danger-65-l);--bulma-danger-00-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-00-invert-l),1);--bulma-danger-05:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-05-l),1);--bulma-danger-05-invert-l:var(--bulma-danger-70-l);--bulma-danger-05-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-05-invert-l),1);--bulma-danger-10:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-10-l),1);--bulma-danger-10-invert-l:var(--bulma-danger-75-l);--bulma-danger-10-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-10-invert-l),1);--bulma-danger-15:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-15-l),1);--bulma-danger-15-invert-l:var(--bulma-danger-80-l);--bulma-danger-15-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-15-invert-l),1);--bulma-danger-20:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-20-l),1);--bulma-danger-20-invert-l:var(--bulma-danger-85-l);--bulma-danger-20-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-20-invert-l),1);--bulma-danger-25:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-25-l),1);--bulma-danger-25-invert-l:var(--bulma-danger-90-l);--bulma-danger-25-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-25-invert-l),1);--bulma-danger-30:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-30-l),1);--bulma-danger-30-invert-l:var(--bulma-danger-100-l);--bulma-danger-30-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-30-invert-l),1);--bulma-danger-35:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-35-l),1);--bulma-danger-35-invert-l:var(--bulma-danger-100-l);--bulma-danger-35-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-35-invert-l),1);--bulma-danger-40:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-40-l),1);--bulma-danger-40-invert-l:var(--bulma-danger-100-l);--bulma-danger-40-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-40-invert-l),1);--bulma-danger-45:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-45-l),1);--bulma-danger-45-invert-l:var(--bulma-danger-100-l);--bulma-danger-45-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-45-invert-l),1);--bulma-danger-50:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-50-l),1);--bulma-danger-50-invert-l:var(--bulma-danger-100-l);--bulma-danger-50-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-50-invert-l),1);--bulma-danger-55:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-55-l),1);--bulma-danger-55-invert-l:var(--bulma-danger-100-l);--bulma-danger-55-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-55-invert-l),1);--bulma-danger-60:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-60-l),1);--bulma-danger-60-invert-l:var(--bulma-danger-100-l);--bulma-danger-60-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-60-invert-l),1);--bulma-danger-65:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-65-l),1);--bulma-danger-65-invert-l:var(--bulma-danger-00-l);--bulma-danger-65-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-65-invert-l),1);--bulma-danger-70:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-70-l),1);--bulma-danger-70-invert-l:var(--bulma-danger-05-l);--bulma-danger-70-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-70-invert-l),1);--bulma-danger-75:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-75-l),1);--bulma-danger-75-invert-l:var(--bulma-danger-10-l);--bulma-danger-75-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-75-invert-l),1);--bulma-danger-80:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-80-l),1);--bulma-danger-80-invert-l:var(--bulma-danger-15-l);--bulma-danger-80-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-80-invert-l),1);--bulma-danger-85:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-85-l),1);--bulma-danger-85-invert-l:var(--bulma-danger-20-l);--bulma-danger-85-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-85-invert-l),1);--bulma-danger-90:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-90-l),1);--bulma-danger-90-invert-l:var(--bulma-danger-25-l);--bulma-danger-90-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-90-invert-l),1);--bulma-danger-95:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-95-l),1);--bulma-danger-95-invert-l:var(--bulma-danger-25-l);--bulma-danger-95-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-95-invert-l),1);--bulma-danger-100:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-100-l),1);--bulma-danger-100-invert-l:var(--bulma-danger-30-l);--bulma-danger-100-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-100-invert-l),1);--bulma-danger-invert-l:var(--bulma-danger-05-l);--bulma-danger-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-invert-l),1);--bulma-danger-light-l:var(--bulma-danger-90-l);--bulma-danger-light:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-light-l),1);--bulma-danger-light-invert-l:var(--bulma-danger-25-l);--bulma-danger-light-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-light-invert-l),1);--bulma-danger-dark-l:var(--bulma-danger-10-l);--bulma-danger-dark:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-dark-l),1);--bulma-danger-dark-invert-l:var(--bulma-danger-75-l);--bulma-danger-dark-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-dark-invert-l),1);--bulma-danger-soft:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-soft-l),1);--bulma-danger-bold:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-bold-l),1);--bulma-danger-soft-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-soft-invert-l),1);--bulma-danger-bold-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-bold-invert-l),1);--bulma-danger-on-scheme-l:40%;--bulma-danger-on-scheme:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-on-scheme-l),1);--bulma-black-bis:#14161a;--bulma-black-ter:#1f2229;--bulma-grey-darker:#2e333d;--bulma-grey-dark:#404654;--bulma-grey:#69748c;--bulma-grey-light:#abb1bf;--bulma-grey-lighter:#d6d9e0;--bulma-white-ter:#f3f4f6;--bulma-white-bis:#f9fafb;--bulma-shadow-h:221deg;--bulma-shadow-s:14%;--bulma-shadow-l:4%;--bulma-size-1:3rem;--bulma-size-2:2.5rem;--bulma-size-3:2rem;--bulma-size-4:1.5rem;--bulma-size-5:1.25rem;--bulma-size-6:1rem;--bulma-size-7:.75rem}}@media (prefers-color-scheme:dark){:root{--bulma-white-on-scheme-l:100%;--bulma-white-on-scheme:hsla(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-on-scheme-l),1);--bulma-black-on-scheme-l:0%;--bulma-black-on-scheme:hsla(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-on-scheme-l),1);--bulma-light-on-scheme-l:96%;--bulma-light-on-scheme:hsla(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-on-scheme-l),1);--bulma-dark-on-scheme-l:56%;--bulma-dark-on-scheme:hsla(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-on-scheme-l),1);--bulma-text-on-scheme-l:54%;--bulma-text-on-scheme:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-on-scheme-l),1);--bulma-primary-on-scheme-l:41%;--bulma-primary-on-scheme:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-on-scheme-l),1);--bulma-link-on-scheme-l:73%;--bulma-link-on-scheme:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-on-scheme-l),1);--bulma-info-on-scheme-l:70%;--bulma-info-on-scheme:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-on-scheme-l),1);--bulma-success-on-scheme-l:53%;--bulma-success-on-scheme:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-on-scheme-l),1);--bulma-warning-on-scheme-l:53%;--bulma-warning-on-scheme:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-on-scheme-l),1);--bulma-danger-on-scheme-l:70%;--bulma-danger-on-scheme:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-on-scheme-l),1);--bulma-scheme-brightness:dark;--bulma-scheme-main-l:9%;--bulma-scheme-main-bis-l:11%;--bulma-scheme-main-ter-l:13%;--bulma-soft-l:20%;--bulma-bold-l:90%;--bulma-soft-invert-l:90%;--bulma-bold-invert-l:20%;--bulma-background-l:14%;--bulma-border-weak-l:21%;--bulma-border-l:24%;--bulma-text-weak-l:53%;--bulma-text-l:71%;--bulma-text-strong-l:93%;--bulma-text-title-l:100%;--bulma-hover-background-l-delta:5%;--bulma-active-background-l-delta:10%;--bulma-hover-border-l-delta:10%;--bulma-active-border-l-delta:20%;--bulma-hover-color-l-delta:5%;--bulma-active-color-l-delta:10%;--bulma-shadow-h:0deg;--bulma-shadow-s:0%;--bulma-shadow-l:100%}}[data-theme=light],.theme-light{--bulma-scheme-h:221;--bulma-scheme-s:14%;--bulma-light-l:96%;--bulma-light-invert-l:21%;--bulma-dark-l:21%;--bulma-dark-invert-l:96%;--bulma-soft-l:90%;--bulma-bold-l:20%;--bulma-soft-invert-l:20%;--bulma-bold-invert-l:90%;--bulma-hover-background-l-delta:-5%;--bulma-active-background-l-delta:-10%;--bulma-hover-border-l-delta:-10%;--bulma-active-border-l-delta:-20%;--bulma-hover-color-l-delta:-5%;--bulma-active-color-l-delta:-10%;--bulma-hover-shadow-a-delta:-.05;--bulma-active-shadow-a-delta:-.1;--bulma-scheme-brightness:light;--bulma-scheme-main-l:100%;--bulma-scheme-main-bis-l:98%;--bulma-scheme-main-ter-l:96%;--bulma-background-l:96%;--bulma-border-weak-l:93%;--bulma-border-l:86%;--bulma-text-weak-l:48%;--bulma-text-l:29%;--bulma-text-strong-l:21%;--bulma-text-title-l:14%;--bulma-scheme-invert-ter-l:14%;--bulma-scheme-invert-bis-l:7%;--bulma-scheme-invert-l:4%;--bulma-family-primary:Inter,SF Pro,Segoe UI,Roboto,Oxygen,Ubuntu,Helvetica Neue,Helvetica,Arial,sans-serif;--bulma-family-secondary:Inter,SF Pro,Segoe UI,Roboto,Oxygen,Ubuntu,Helvetica Neue,Helvetica,Arial,sans-serif;--bulma-family-code:Inconsolata,Hack,SF Mono,Roboto Mono,Source Code Pro,Ubuntu Mono,monospace;--bulma-size-small:.75rem;--bulma-size-normal:1rem;--bulma-size-medium:1.25rem;--bulma-size-large:1.5rem;--bulma-weight-light:300;--bulma-weight-normal:400;--bulma-weight-medium:500;--bulma-weight-semibold:600;--bulma-weight-bold:700;--bulma-weight-extrabold:800;--bulma-block-spacing:1.5rem;--bulma-duration:.294s;--bulma-easing:ease-out;--bulma-radius-small:.25rem;--bulma-radius:.375rem;--bulma-radius-medium:.5em;--bulma-radius-large:.75rem;--bulma-radius-rounded:9999px;--bulma-speed:86ms;--bulma-arrow-color:var(--bulma-link);--bulma-loading-color:var(--bulma-border);--bulma-burger-h:var(--bulma-link-h);--bulma-burger-s:var(--bulma-link-s);--bulma-burger-l:var(--bulma-link-l);--bulma-burger-border-radius:.5em;--bulma-burger-gap:5px;--bulma-burger-item-height:2px;--bulma-burger-item-width:20px;--bulma-white:hsla(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-l),1);--bulma-white-base:hsla(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-l),1);--bulma-white-rgb:255,255,255;--bulma-white-h:221deg;--bulma-white-s:14%;--bulma-white-l:100%;--bulma-white-invert-l:4%;--bulma-white-invert:#090a0c;--bulma-white-on-scheme-l:35%;--bulma-white-on-scheme:hsla(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-on-scheme-l),1);--bulma-black:hsla(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-l),1);--bulma-black-base:hsla(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-l),1);--bulma-black-rgb:9,10,12;--bulma-black-h:221deg;--bulma-black-s:14%;--bulma-black-l:4%;--bulma-black-invert-l:100%;--bulma-black-invert:#fff;--bulma-black-on-scheme-l:4%;--bulma-black-on-scheme:hsla(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-on-scheme-l),1);--bulma-light:hsla(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-l),1);--bulma-light-base:hsla(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-l),1);--bulma-light-rgb:243,244,246;--bulma-light-h:221deg;--bulma-light-s:14%;--bulma-light-invert:#2e333d;--bulma-light-on-scheme-l:36%;--bulma-light-on-scheme:hsla(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-on-scheme-l),1);--bulma-dark:hsla(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-l),1);--bulma-dark-base:hsla(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-l),1);--bulma-dark-rgb:46,51,61;--bulma-dark-h:221deg;--bulma-dark-s:14%;--bulma-dark-invert:#f3f4f6;--bulma-dark-on-scheme-l:21%;--bulma-dark-on-scheme:hsla(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-on-scheme-l),1);--bulma-text:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-l));--bulma-text-base:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-l),1);--bulma-text-rgb:64,70,84;--bulma-text-h:221deg;--bulma-text-s:14%;--bulma-text-00-l:0%;--bulma-text-05-l:4%;--bulma-text-10-l:9%;--bulma-text-15-l:14%;--bulma-text-20-l:19%;--bulma-text-25-l:24%;--bulma-text-30-l:29%;--bulma-text-35-l:34%;--bulma-text-40-l:39%;--bulma-text-45-l:44%;--bulma-text-50-l:49%;--bulma-text-55-l:54%;--bulma-text-60-l:59%;--bulma-text-65-l:64%;--bulma-text-70-l:69%;--bulma-text-75-l:74%;--bulma-text-80-l:79%;--bulma-text-85-l:84%;--bulma-text-90-l:89%;--bulma-text-95-l:94%;--bulma-text-100-l:99%;--bulma-text-00:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-00-l),1);--bulma-text-00-invert-l:var(--bulma-text-60-l);--bulma-text-00-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-00-invert-l),1);--bulma-text-05:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-05-l),1);--bulma-text-05-invert-l:var(--bulma-text-60-l);--bulma-text-05-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-05-invert-l),1);--bulma-text-10:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-10-l),1);--bulma-text-10-invert-l:var(--bulma-text-70-l);--bulma-text-10-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-10-invert-l),1);--bulma-text-15:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-15-l),1);--bulma-text-15-invert-l:var(--bulma-text-75-l);--bulma-text-15-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-15-invert-l),1);--bulma-text-20:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-20-l),1);--bulma-text-20-invert-l:var(--bulma-text-85-l);--bulma-text-20-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-20-invert-l),1);--bulma-text-25:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-25-l),1);--bulma-text-25-invert-l:var(--bulma-text-95-l);--bulma-text-25-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-25-invert-l),1);--bulma-text-30:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-30-l),1);--bulma-text-30-invert-l:var(--bulma-text-100-l);--bulma-text-30-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-30-invert-l),1);--bulma-text-35:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-35-l),1);--bulma-text-35-invert-l:var(--bulma-text-100-l);--bulma-text-35-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-35-invert-l),1);--bulma-text-40:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-40-l),1);--bulma-text-40-invert-l:var(--bulma-text-100-l);--bulma-text-40-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-40-invert-l),1);--bulma-text-45:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-45-l),1);--bulma-text-45-invert-l:var(--bulma-text-100-l);--bulma-text-45-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-45-invert-l),1);--bulma-text-50:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-50-l),1);--bulma-text-50-invert-l:var(--bulma-text-100-l);--bulma-text-50-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-50-invert-l),1);--bulma-text-55:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-55-l),1);--bulma-text-55-invert-l:var(--bulma-text-100-l);--bulma-text-55-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-55-invert-l),1);--bulma-text-60:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-60-l),1);--bulma-text-60-invert-l:var(--bulma-text-05-l);--bulma-text-60-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-60-invert-l),1);--bulma-text-65:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-65-l),1);--bulma-text-65-invert-l:var(--bulma-text-05-l);--bulma-text-65-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-65-invert-l),1);--bulma-text-70:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-70-l),1);--bulma-text-70-invert-l:var(--bulma-text-10-l);--bulma-text-70-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-70-invert-l),1);--bulma-text-75:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-75-l),1);--bulma-text-75-invert-l:var(--bulma-text-15-l);--bulma-text-75-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-75-invert-l),1);--bulma-text-80:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-80-l),1);--bulma-text-80-invert-l:var(--bulma-text-15-l);--bulma-text-80-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-80-invert-l),1);--bulma-text-85:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-85-l),1);--bulma-text-85-invert-l:var(--bulma-text-20-l);--bulma-text-85-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-85-invert-l),1);--bulma-text-90:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-90-l),1);--bulma-text-90-invert-l:var(--bulma-text-20-l);--bulma-text-90-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-90-invert-l),1);--bulma-text-95:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-95-l),1);--bulma-text-95-invert-l:var(--bulma-text-25-l);--bulma-text-95-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-95-invert-l),1);--bulma-text-100:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-100-l),1);--bulma-text-100-invert-l:var(--bulma-text-25-l);--bulma-text-100-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-100-invert-l),1);--bulma-text-invert-l:var(--bulma-text-100-l);--bulma-text-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-invert-l),1);--bulma-text-light-l:var(--bulma-text-90-l);--bulma-text-light:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-light-l),1);--bulma-text-light-invert-l:var(--bulma-text-20-l);--bulma-text-light-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-light-invert-l),1);--bulma-text-dark-l:var(--bulma-text-10-l);--bulma-text-dark:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-dark-l),1);--bulma-text-dark-invert-l:var(--bulma-text-70-l);--bulma-text-dark-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-dark-invert-l),1);--bulma-text-soft:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-soft-l),1);--bulma-text-bold:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-bold-l),1);--bulma-text-soft-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-soft-invert-l),1);--bulma-text-bold-invert:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-bold-invert-l),1);--bulma-text-on-scheme-l:29%;--bulma-text-on-scheme:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-on-scheme-l),1);--bulma-primary:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-l),1);--bulma-primary-base:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-l),1);--bulma-primary-rgb:0,209,178;--bulma-primary-h:171deg;--bulma-primary-s:100%;--bulma-primary-l:41%;--bulma-primary-00-l:1%;--bulma-primary-05-l:6%;--bulma-primary-10-l:11%;--bulma-primary-15-l:16%;--bulma-primary-20-l:21%;--bulma-primary-25-l:26%;--bulma-primary-30-l:31%;--bulma-primary-35-l:36%;--bulma-primary-40-l:41%;--bulma-primary-45-l:46%;--bulma-primary-50-l:51%;--bulma-primary-55-l:56%;--bulma-primary-60-l:61%;--bulma-primary-65-l:66%;--bulma-primary-70-l:71%;--bulma-primary-75-l:76%;--bulma-primary-80-l:81%;--bulma-primary-85-l:86%;--bulma-primary-90-l:91%;--bulma-primary-95-l:96%;--bulma-primary-100-l:100%;--bulma-primary-00:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-00-l),1);--bulma-primary-00-invert-l:var(--bulma-primary-30-l);--bulma-primary-00-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-00-invert-l),1);--bulma-primary-05:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-05-l),1);--bulma-primary-05-invert-l:var(--bulma-primary-40-l);--bulma-primary-05-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-05-invert-l),1);--bulma-primary-10:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-10-l),1);--bulma-primary-10-invert-l:var(--bulma-primary-50-l);--bulma-primary-10-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-10-invert-l),1);--bulma-primary-15:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-15-l),1);--bulma-primary-15-invert-l:var(--bulma-primary-100-l);--bulma-primary-15-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-15-invert-l),1);--bulma-primary-20:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-20-l),1);--bulma-primary-20-invert-l:var(--bulma-primary-100-l);--bulma-primary-20-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-20-invert-l),1);--bulma-primary-25:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-25-l),1);--bulma-primary-25-invert-l:var(--bulma-primary-100-l);--bulma-primary-25-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-25-invert-l),1);--bulma-primary-30:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-30-l),1);--bulma-primary-30-invert-l:var(--bulma-primary-00-l);--bulma-primary-30-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-30-invert-l),1);--bulma-primary-35:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-35-l),1);--bulma-primary-35-invert-l:var(--bulma-primary-00-l);--bulma-primary-35-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-35-invert-l),1);--bulma-primary-40:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-40-l),1);--bulma-primary-40-invert-l:var(--bulma-primary-05-l);--bulma-primary-40-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-40-invert-l),1);--bulma-primary-45:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-45-l),1);--bulma-primary-45-invert-l:var(--bulma-primary-05-l);--bulma-primary-45-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-45-invert-l),1);--bulma-primary-50:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-50-l),1);--bulma-primary-50-invert-l:var(--bulma-primary-10-l);--bulma-primary-50-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-50-invert-l),1);--bulma-primary-55:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-55-l),1);--bulma-primary-55-invert-l:var(--bulma-primary-10-l);--bulma-primary-55-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-55-invert-l),1);--bulma-primary-60:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-60-l),1);--bulma-primary-60-invert-l:var(--bulma-primary-10-l);--bulma-primary-60-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-60-invert-l),1);--bulma-primary-65:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-65-l),1);--bulma-primary-65-invert-l:var(--bulma-primary-10-l);--bulma-primary-65-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-65-invert-l),1);--bulma-primary-70:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-70-l),1);--bulma-primary-70-invert-l:var(--bulma-primary-10-l);--bulma-primary-70-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-70-invert-l),1);--bulma-primary-75:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-75-l),1);--bulma-primary-75-invert-l:var(--bulma-primary-10-l);--bulma-primary-75-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-75-invert-l),1);--bulma-primary-80:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-80-l),1);--bulma-primary-80-invert-l:var(--bulma-primary-10-l);--bulma-primary-80-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-80-invert-l),1);--bulma-primary-85:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-85-l),1);--bulma-primary-85-invert-l:var(--bulma-primary-10-l);--bulma-primary-85-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-85-invert-l),1);--bulma-primary-90:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-90-l),1);--bulma-primary-90-invert-l:var(--bulma-primary-10-l);--bulma-primary-90-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-90-invert-l),1);--bulma-primary-95:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-95-l),1);--bulma-primary-95-invert-l:var(--bulma-primary-10-l);--bulma-primary-95-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-95-invert-l),1);--bulma-primary-100:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-100-l),1);--bulma-primary-100-invert-l:var(--bulma-primary-15-l);--bulma-primary-100-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-100-invert-l),1);--bulma-primary-invert-l:var(--bulma-primary-05-l);--bulma-primary-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-invert-l),1);--bulma-primary-light-l:var(--bulma-primary-90-l);--bulma-primary-light:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-light-l),1);--bulma-primary-light-invert-l:var(--bulma-primary-10-l);--bulma-primary-light-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-light-invert-l),1);--bulma-primary-dark-l:var(--bulma-primary-10-l);--bulma-primary-dark:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-dark-l),1);--bulma-primary-dark-invert-l:var(--bulma-primary-50-l);--bulma-primary-dark-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-dark-invert-l),1);--bulma-primary-soft:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-soft-l),1);--bulma-primary-bold:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-bold-l),1);--bulma-primary-soft-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-soft-invert-l),1);--bulma-primary-bold-invert:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-bold-invert-l),1);--bulma-primary-on-scheme-l:21%;--bulma-primary-on-scheme:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-on-scheme-l),1);--bulma-link:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-l));--bulma-link-base:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-l),1);--bulma-link-rgb:66,88,255;--bulma-link-h:233deg;--bulma-link-s:100%;--bulma-link-l:63%;--bulma-link-00-l:0%;--bulma-link-05-l:3%;--bulma-link-10-l:8%;--bulma-link-15-l:13%;--bulma-link-20-l:18%;--bulma-link-25-l:23%;--bulma-link-30-l:28%;--bulma-link-35-l:33%;--bulma-link-40-l:38%;--bulma-link-45-l:43%;--bulma-link-50-l:48%;--bulma-link-55-l:53%;--bulma-link-60-l:58%;--bulma-link-65-l:63%;--bulma-link-70-l:68%;--bulma-link-75-l:73%;--bulma-link-80-l:78%;--bulma-link-85-l:83%;--bulma-link-90-l:88%;--bulma-link-95-l:93%;--bulma-link-100-l:98%;--bulma-link-00:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-00-l),1);--bulma-link-00-invert-l:var(--bulma-link-75-l);--bulma-link-00-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-00-invert-l),1);--bulma-link-05:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-05-l),1);--bulma-link-05-invert-l:var(--bulma-link-75-l);--bulma-link-05-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-05-invert-l),1);--bulma-link-10:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-10-l),1);--bulma-link-10-invert-l:var(--bulma-link-75-l);--bulma-link-10-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-10-invert-l),1);--bulma-link-15:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-15-l),1);--bulma-link-15-invert-l:var(--bulma-link-80-l);--bulma-link-15-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-15-invert-l),1);--bulma-link-20:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-20-l),1);--bulma-link-20-invert-l:var(--bulma-link-80-l);--bulma-link-20-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-20-invert-l),1);--bulma-link-25:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-25-l),1);--bulma-link-25-invert-l:var(--bulma-link-85-l);--bulma-link-25-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-25-invert-l),1);--bulma-link-30:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-30-l),1);--bulma-link-30-invert-l:var(--bulma-link-90-l);--bulma-link-30-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-30-invert-l),1);--bulma-link-35:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-35-l),1);--bulma-link-35-invert-l:var(--bulma-link-90-l);--bulma-link-35-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-35-invert-l),1);--bulma-link-40:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-40-l),1);--bulma-link-40-invert-l:var(--bulma-link-95-l);--bulma-link-40-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-40-invert-l),1);--bulma-link-45:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-45-l),1);--bulma-link-45-invert-l:var(--bulma-link-100-l);--bulma-link-45-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-45-invert-l),1);--bulma-link-50:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-50-l),1);--bulma-link-50-invert-l:var(--bulma-link-100-l);--bulma-link-50-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-50-invert-l),1);--bulma-link-55:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-55-l),1);--bulma-link-55-invert-l:var(--bulma-link-100-l);--bulma-link-55-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-55-invert-l),1);--bulma-link-60:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-60-l),1);--bulma-link-60-invert-l:var(--bulma-link-100-l);--bulma-link-60-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-60-invert-l),1);--bulma-link-65:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-65-l),1);--bulma-link-65-invert-l:var(--bulma-link-100-l);--bulma-link-65-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-65-invert-l),1);--bulma-link-70:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-70-l),1);--bulma-link-70-invert-l:var(--bulma-link-100-l);--bulma-link-70-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-70-invert-l),1);--bulma-link-75:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-75-l),1);--bulma-link-75-invert-l:var(--bulma-link-10-l);--bulma-link-75-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-75-invert-l),1);--bulma-link-80:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-80-l),1);--bulma-link-80-invert-l:var(--bulma-link-20-l);--bulma-link-80-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-80-invert-l),1);--bulma-link-85:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-85-l),1);--bulma-link-85-invert-l:var(--bulma-link-25-l);--bulma-link-85-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-85-invert-l),1);--bulma-link-90:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-90-l),1);--bulma-link-90-invert-l:var(--bulma-link-35-l);--bulma-link-90-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-90-invert-l),1);--bulma-link-95:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-95-l),1);--bulma-link-95-invert-l:var(--bulma-link-40-l);--bulma-link-95-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-95-invert-l),1);--bulma-link-100:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-100-l),1);--bulma-link-100-invert-l:var(--bulma-link-50-l);--bulma-link-100-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-100-invert-l),1);--bulma-link-invert-l:var(--bulma-link-100-l);--bulma-link-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-invert-l),1);--bulma-link-light-l:var(--bulma-link-90-l);--bulma-link-light:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-light-l),1);--bulma-link-light-invert-l:var(--bulma-link-35-l);--bulma-link-light-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-light-invert-l),1);--bulma-link-dark-l:var(--bulma-link-10-l);--bulma-link-dark:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-dark-l),1);--bulma-link-dark-invert-l:var(--bulma-link-75-l);--bulma-link-dark-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-dark-invert-l),1);--bulma-link-soft:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-soft-l),1);--bulma-link-bold:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-bold-l),1);--bulma-link-soft-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-soft-invert-l),1);--bulma-link-bold-invert:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-bold-invert-l),1);--bulma-link-on-scheme-l:58%;--bulma-link-on-scheme:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-on-scheme-l),1);--bulma-info:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-l),1);--bulma-info-base:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-l),1);--bulma-info-rgb:102,209,255;--bulma-info-h:198deg;--bulma-info-s:100%;--bulma-info-l:70%;--bulma-info-00-l:0%;--bulma-info-05-l:5%;--bulma-info-10-l:10%;--bulma-info-15-l:15%;--bulma-info-20-l:20%;--bulma-info-25-l:25%;--bulma-info-30-l:30%;--bulma-info-35-l:35%;--bulma-info-40-l:40%;--bulma-info-45-l:45%;--bulma-info-50-l:50%;--bulma-info-55-l:55%;--bulma-info-60-l:60%;--bulma-info-65-l:65%;--bulma-info-70-l:70%;--bulma-info-75-l:75%;--bulma-info-80-l:80%;--bulma-info-85-l:85%;--bulma-info-90-l:90%;--bulma-info-95-l:95%;--bulma-info-100-l:100%;--bulma-info-00:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-00-l),1);--bulma-info-00-invert-l:var(--bulma-info-45-l);--bulma-info-00-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-00-invert-l),1);--bulma-info-05:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-05-l),1);--bulma-info-05-invert-l:var(--bulma-info-50-l);--bulma-info-05-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-05-invert-l),1);--bulma-info-10:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-10-l),1);--bulma-info-10-invert-l:var(--bulma-info-60-l);--bulma-info-10-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-10-invert-l),1);--bulma-info-15:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-15-l),1);--bulma-info-15-invert-l:var(--bulma-info-80-l);--bulma-info-15-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-15-invert-l),1);--bulma-info-20:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-20-l),1);--bulma-info-20-invert-l:var(--bulma-info-95-l);--bulma-info-20-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-20-invert-l),1);--bulma-info-25:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-25-l),1);--bulma-info-25-invert-l:var(--bulma-info-100-l);--bulma-info-25-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-25-invert-l),1);--bulma-info-30:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-30-l),1);--bulma-info-30-invert-l:var(--bulma-info-100-l);--bulma-info-30-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-30-invert-l),1);--bulma-info-35:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-35-l),1);--bulma-info-35-invert-l:var(--bulma-info-100-l);--bulma-info-35-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-35-invert-l),1);--bulma-info-40:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-40-l),1);--bulma-info-40-invert-l:var(--bulma-info-100-l);--bulma-info-40-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-40-invert-l),1);--bulma-info-45:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-45-l),1);--bulma-info-45-invert-l:var(--bulma-info-00-l);--bulma-info-45-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-45-invert-l),1);--bulma-info-50:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-50-l),1);--bulma-info-50-invert-l:var(--bulma-info-05-l);--bulma-info-50-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-50-invert-l),1);--bulma-info-55:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-55-l),1);--bulma-info-55-invert-l:var(--bulma-info-05-l);--bulma-info-55-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-55-invert-l),1);--bulma-info-60:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-60-l),1);--bulma-info-60-invert-l:var(--bulma-info-10-l);--bulma-info-60-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-60-invert-l),1);--bulma-info-65:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-65-l),1);--bulma-info-65-invert-l:var(--bulma-info-10-l);--bulma-info-65-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-65-invert-l),1);--bulma-info-70:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-70-l),1);--bulma-info-70-invert-l:var(--bulma-info-10-l);--bulma-info-70-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-70-invert-l),1);--bulma-info-75:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-75-l),1);--bulma-info-75-invert-l:var(--bulma-info-10-l);--bulma-info-75-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-75-invert-l),1);--bulma-info-80:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-80-l),1);--bulma-info-80-invert-l:var(--bulma-info-15-l);--bulma-info-80-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-80-invert-l),1);--bulma-info-85:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-85-l),1);--bulma-info-85-invert-l:var(--bulma-info-15-l);--bulma-info-85-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-85-invert-l),1);--bulma-info-90:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-90-l),1);--bulma-info-90-invert-l:var(--bulma-info-15-l);--bulma-info-90-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-90-invert-l),1);--bulma-info-95:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-95-l),1);--bulma-info-95-invert-l:var(--bulma-info-20-l);--bulma-info-95-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-95-invert-l),1);--bulma-info-100:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-100-l),1);--bulma-info-100-invert-l:var(--bulma-info-20-l);--bulma-info-100-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-100-invert-l),1);--bulma-info-invert-l:var(--bulma-info-10-l);--bulma-info-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-invert-l),1);--bulma-info-light-l:var(--bulma-info-90-l);--bulma-info-light:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-light-l),1);--bulma-info-light-invert-l:var(--bulma-info-15-l);--bulma-info-light-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-light-invert-l),1);--bulma-info-dark-l:var(--bulma-info-10-l);--bulma-info-dark:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-dark-l),1);--bulma-info-dark-invert-l:var(--bulma-info-60-l);--bulma-info-dark-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-dark-invert-l),1);--bulma-info-soft:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-soft-l),1);--bulma-info-bold:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-bold-l),1);--bulma-info-soft-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-soft-invert-l),1);--bulma-info-bold-invert:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-bold-invert-l),1);--bulma-info-on-scheme-l:25%;--bulma-info-on-scheme:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-on-scheme-l),1);--bulma-success:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-l),1);--bulma-success-base:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-l),1);--bulma-success-rgb:72,199,142;--bulma-success-h:153deg;--bulma-success-s:53%;--bulma-success-l:53%;--bulma-success-00-l:0%;--bulma-success-05-l:3%;--bulma-success-10-l:8%;--bulma-success-15-l:13%;--bulma-success-20-l:18%;--bulma-success-25-l:23%;--bulma-success-30-l:28%;--bulma-success-35-l:33%;--bulma-success-40-l:38%;--bulma-success-45-l:43%;--bulma-success-50-l:48%;--bulma-success-55-l:53%;--bulma-success-60-l:58%;--bulma-success-65-l:63%;--bulma-success-70-l:68%;--bulma-success-75-l:73%;--bulma-success-80-l:78%;--bulma-success-85-l:83%;--bulma-success-90-l:88%;--bulma-success-95-l:93%;--bulma-success-100-l:98%;--bulma-success-00:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-00-l),1);--bulma-success-00-invert-l:var(--bulma-success-45-l);--bulma-success-00-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-00-invert-l),1);--bulma-success-05:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-05-l),1);--bulma-success-05-invert-l:var(--bulma-success-45-l);--bulma-success-05-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-05-invert-l),1);--bulma-success-10:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-10-l),1);--bulma-success-10-invert-l:var(--bulma-success-55-l);--bulma-success-10-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-10-invert-l),1);--bulma-success-15:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-15-l),1);--bulma-success-15-invert-l:var(--bulma-success-75-l);--bulma-success-15-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-15-invert-l),1);--bulma-success-20:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-20-l),1);--bulma-success-20-invert-l:var(--bulma-success-90-l);--bulma-success-20-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-20-invert-l),1);--bulma-success-25:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-25-l),1);--bulma-success-25-invert-l:var(--bulma-success-100-l);--bulma-success-25-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-25-invert-l),1);--bulma-success-30:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-30-l),1);--bulma-success-30-invert-l:var(--bulma-success-100-l);--bulma-success-30-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-30-invert-l),1);--bulma-success-35:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-35-l),1);--bulma-success-35-invert-l:var(--bulma-success-100-l);--bulma-success-35-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-35-invert-l),1);--bulma-success-40:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-40-l),1);--bulma-success-40-invert-l:var(--bulma-success-100-l);--bulma-success-40-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-40-invert-l),1);--bulma-success-45:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-45-l),1);--bulma-success-45-invert-l:var(--bulma-success-05-l);--bulma-success-45-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-45-invert-l),1);--bulma-success-50:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-50-l),1);--bulma-success-50-invert-l:var(--bulma-success-05-l);--bulma-success-50-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-50-invert-l),1);--bulma-success-55:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-55-l),1);--bulma-success-55-invert-l:var(--bulma-success-10-l);--bulma-success-55-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-55-invert-l),1);--bulma-success-60:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-60-l),1);--bulma-success-60-invert-l:var(--bulma-success-10-l);--bulma-success-60-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-60-invert-l),1);--bulma-success-65:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-65-l),1);--bulma-success-65-invert-l:var(--bulma-success-10-l);--bulma-success-65-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-65-invert-l),1);--bulma-success-70:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-70-l),1);--bulma-success-70-invert-l:var(--bulma-success-10-l);--bulma-success-70-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-70-invert-l),1);--bulma-success-75:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-75-l),1);--bulma-success-75-invert-l:var(--bulma-success-15-l);--bulma-success-75-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-75-invert-l),1);--bulma-success-80:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-80-l),1);--bulma-success-80-invert-l:var(--bulma-success-15-l);--bulma-success-80-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-80-invert-l),1);--bulma-success-85:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-85-l),1);--bulma-success-85-invert-l:var(--bulma-success-15-l);--bulma-success-85-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-85-invert-l),1);--bulma-success-90:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-90-l),1);--bulma-success-90-invert-l:var(--bulma-success-20-l);--bulma-success-90-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-90-invert-l),1);--bulma-success-95:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-95-l),1);--bulma-success-95-invert-l:var(--bulma-success-20-l);--bulma-success-95-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-95-invert-l),1);--bulma-success-100:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-100-l),1);--bulma-success-100-invert-l:var(--bulma-success-20-l);--bulma-success-100-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-100-invert-l),1);--bulma-success-invert-l:var(--bulma-success-10-l);--bulma-success-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-invert-l),1);--bulma-success-light-l:var(--bulma-success-90-l);--bulma-success-light:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-light-l),1);--bulma-success-light-invert-l:var(--bulma-success-20-l);--bulma-success-light-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-light-invert-l),1);--bulma-success-dark-l:var(--bulma-success-10-l);--bulma-success-dark:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-dark-l),1);--bulma-success-dark-invert-l:var(--bulma-success-55-l);--bulma-success-dark-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-dark-invert-l),1);--bulma-success-soft:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-soft-l),1);--bulma-success-bold:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-bold-l),1);--bulma-success-soft-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-soft-invert-l),1);--bulma-success-bold-invert:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-bold-invert-l),1);--bulma-success-on-scheme-l:23%;--bulma-success-on-scheme:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-on-scheme-l),1);--bulma-warning:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-l),1);--bulma-warning-base:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-l),1);--bulma-warning-rgb:255,183,15;--bulma-warning-h:42deg;--bulma-warning-s:100%;--bulma-warning-l:53%;--bulma-warning-00-l:0%;--bulma-warning-05-l:3%;--bulma-warning-10-l:8%;--bulma-warning-15-l:13%;--bulma-warning-20-l:18%;--bulma-warning-25-l:23%;--bulma-warning-30-l:28%;--bulma-warning-35-l:33%;--bulma-warning-40-l:38%;--bulma-warning-45-l:43%;--bulma-warning-50-l:48%;--bulma-warning-55-l:53%;--bulma-warning-60-l:58%;--bulma-warning-65-l:63%;--bulma-warning-70-l:68%;--bulma-warning-75-l:73%;--bulma-warning-80-l:78%;--bulma-warning-85-l:83%;--bulma-warning-90-l:88%;--bulma-warning-95-l:93%;--bulma-warning-100-l:98%;--bulma-warning-00:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-00-l),1);--bulma-warning-00-invert-l:var(--bulma-warning-40-l);--bulma-warning-00-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-00-invert-l),1);--bulma-warning-05:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-05-l),1);--bulma-warning-05-invert-l:var(--bulma-warning-45-l);--bulma-warning-05-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-05-invert-l),1);--bulma-warning-10:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-10-l),1);--bulma-warning-10-invert-l:var(--bulma-warning-50-l);--bulma-warning-10-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-10-invert-l),1);--bulma-warning-15:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-15-l),1);--bulma-warning-15-invert-l:var(--bulma-warning-70-l);--bulma-warning-15-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-15-invert-l),1);--bulma-warning-20:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-20-l),1);--bulma-warning-20-invert-l:var(--bulma-warning-100-l);--bulma-warning-20-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-20-invert-l),1);--bulma-warning-25:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-25-l),1);--bulma-warning-25-invert-l:var(--bulma-warning-100-l);--bulma-warning-25-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-25-invert-l),1);--bulma-warning-30:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-30-l),1);--bulma-warning-30-invert-l:var(--bulma-warning-100-l);--bulma-warning-30-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-30-invert-l),1);--bulma-warning-35:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-35-l),1);--bulma-warning-35-invert-l:var(--bulma-warning-100-l);--bulma-warning-35-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-35-invert-l),1);--bulma-warning-40:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-40-l),1);--bulma-warning-40-invert-l:var(--bulma-warning-00-l);--bulma-warning-40-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-40-invert-l),1);--bulma-warning-45:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-45-l),1);--bulma-warning-45-invert-l:var(--bulma-warning-05-l);--bulma-warning-45-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-45-invert-l),1);--bulma-warning-50:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-50-l),1);--bulma-warning-50-invert-l:var(--bulma-warning-10-l);--bulma-warning-50-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-50-invert-l),1);--bulma-warning-55:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-55-l),1);--bulma-warning-55-invert-l:var(--bulma-warning-10-l);--bulma-warning-55-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-55-invert-l),1);--bulma-warning-60:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-60-l),1);--bulma-warning-60-invert-l:var(--bulma-warning-10-l);--bulma-warning-60-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-60-invert-l),1);--bulma-warning-65:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-65-l),1);--bulma-warning-65-invert-l:var(--bulma-warning-10-l);--bulma-warning-65-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-65-invert-l),1);--bulma-warning-70:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-70-l),1);--bulma-warning-70-invert-l:var(--bulma-warning-15-l);--bulma-warning-70-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-70-invert-l),1);--bulma-warning-75:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-75-l),1);--bulma-warning-75-invert-l:var(--bulma-warning-15-l);--bulma-warning-75-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-75-invert-l),1);--bulma-warning-80:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-80-l),1);--bulma-warning-80-invert-l:var(--bulma-warning-15-l);--bulma-warning-80-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-80-invert-l),1);--bulma-warning-85:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-85-l),1);--bulma-warning-85-invert-l:var(--bulma-warning-15-l);--bulma-warning-85-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-85-invert-l),1);--bulma-warning-90:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-90-l),1);--bulma-warning-90-invert-l:var(--bulma-warning-15-l);--bulma-warning-90-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-90-invert-l),1);--bulma-warning-95:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-95-l),1);--bulma-warning-95-invert-l:var(--bulma-warning-15-l);--bulma-warning-95-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-95-invert-l),1);--bulma-warning-100:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-100-l),1);--bulma-warning-100-invert-l:var(--bulma-warning-20-l);--bulma-warning-100-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-100-invert-l),1);--bulma-warning-invert-l:var(--bulma-warning-10-l);--bulma-warning-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-invert-l),1);--bulma-warning-light-l:var(--bulma-warning-90-l);--bulma-warning-light:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-light-l),1);--bulma-warning-light-invert-l:var(--bulma-warning-15-l);--bulma-warning-light-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-light-invert-l),1);--bulma-warning-dark-l:var(--bulma-warning-10-l);--bulma-warning-dark:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-dark-l),1);--bulma-warning-dark-invert-l:var(--bulma-warning-50-l);--bulma-warning-dark-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-dark-invert-l),1);--bulma-warning-soft:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-soft-l),1);--bulma-warning-bold:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-bold-l),1);--bulma-warning-soft-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-soft-invert-l),1);--bulma-warning-bold-invert:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-bold-invert-l),1);--bulma-warning-on-scheme-l:23%;--bulma-warning-on-scheme:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-on-scheme-l),1);--bulma-danger:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-l),1);--bulma-danger-base:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-l),1);--bulma-danger-rgb:255,102,133;--bulma-danger-h:348deg;--bulma-danger-s:100%;--bulma-danger-l:70%;--bulma-danger-00-l:0%;--bulma-danger-05-l:5%;--bulma-danger-10-l:10%;--bulma-danger-15-l:15%;--bulma-danger-20-l:20%;--bulma-danger-25-l:25%;--bulma-danger-30-l:30%;--bulma-danger-35-l:35%;--bulma-danger-40-l:40%;--bulma-danger-45-l:45%;--bulma-danger-50-l:50%;--bulma-danger-55-l:55%;--bulma-danger-60-l:60%;--bulma-danger-65-l:65%;--bulma-danger-70-l:70%;--bulma-danger-75-l:75%;--bulma-danger-80-l:80%;--bulma-danger-85-l:85%;--bulma-danger-90-l:90%;--bulma-danger-95-l:95%;--bulma-danger-100-l:100%;--bulma-danger-00:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-00-l),1);--bulma-danger-00-invert-l:var(--bulma-danger-65-l);--bulma-danger-00-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-00-invert-l),1);--bulma-danger-05:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-05-l),1);--bulma-danger-05-invert-l:var(--bulma-danger-70-l);--bulma-danger-05-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-05-invert-l),1);--bulma-danger-10:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-10-l),1);--bulma-danger-10-invert-l:var(--bulma-danger-75-l);--bulma-danger-10-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-10-invert-l),1);--bulma-danger-15:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-15-l),1);--bulma-danger-15-invert-l:var(--bulma-danger-80-l);--bulma-danger-15-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-15-invert-l),1);--bulma-danger-20:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-20-l),1);--bulma-danger-20-invert-l:var(--bulma-danger-85-l);--bulma-danger-20-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-20-invert-l),1);--bulma-danger-25:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-25-l),1);--bulma-danger-25-invert-l:var(--bulma-danger-90-l);--bulma-danger-25-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-25-invert-l),1);--bulma-danger-30:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-30-l),1);--bulma-danger-30-invert-l:var(--bulma-danger-100-l);--bulma-danger-30-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-30-invert-l),1);--bulma-danger-35:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-35-l),1);--bulma-danger-35-invert-l:var(--bulma-danger-100-l);--bulma-danger-35-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-35-invert-l),1);--bulma-danger-40:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-40-l),1);--bulma-danger-40-invert-l:var(--bulma-danger-100-l);--bulma-danger-40-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-40-invert-l),1);--bulma-danger-45:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-45-l),1);--bulma-danger-45-invert-l:var(--bulma-danger-100-l);--bulma-danger-45-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-45-invert-l),1);--bulma-danger-50:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-50-l),1);--bulma-danger-50-invert-l:var(--bulma-danger-100-l);--bulma-danger-50-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-50-invert-l),1);--bulma-danger-55:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-55-l),1);--bulma-danger-55-invert-l:var(--bulma-danger-100-l);--bulma-danger-55-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-55-invert-l),1);--bulma-danger-60:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-60-l),1);--bulma-danger-60-invert-l:var(--bulma-danger-100-l);--bulma-danger-60-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-60-invert-l),1);--bulma-danger-65:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-65-l),1);--bulma-danger-65-invert-l:var(--bulma-danger-00-l);--bulma-danger-65-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-65-invert-l),1);--bulma-danger-70:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-70-l),1);--bulma-danger-70-invert-l:var(--bulma-danger-05-l);--bulma-danger-70-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-70-invert-l),1);--bulma-danger-75:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-75-l),1);--bulma-danger-75-invert-l:var(--bulma-danger-10-l);--bulma-danger-75-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-75-invert-l),1);--bulma-danger-80:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-80-l),1);--bulma-danger-80-invert-l:var(--bulma-danger-15-l);--bulma-danger-80-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-80-invert-l),1);--bulma-danger-85:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-85-l),1);--bulma-danger-85-invert-l:var(--bulma-danger-20-l);--bulma-danger-85-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-85-invert-l),1);--bulma-danger-90:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-90-l),1);--bulma-danger-90-invert-l:var(--bulma-danger-25-l);--bulma-danger-90-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-90-invert-l),1);--bulma-danger-95:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-95-l),1);--bulma-danger-95-invert-l:var(--bulma-danger-25-l);--bulma-danger-95-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-95-invert-l),1);--bulma-danger-100:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-100-l),1);--bulma-danger-100-invert-l:var(--bulma-danger-30-l);--bulma-danger-100-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-100-invert-l),1);--bulma-danger-invert-l:var(--bulma-danger-05-l);--bulma-danger-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-invert-l),1);--bulma-danger-light-l:var(--bulma-danger-90-l);--bulma-danger-light:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-light-l),1);--bulma-danger-light-invert-l:var(--bulma-danger-25-l);--bulma-danger-light-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-light-invert-l),1);--bulma-danger-dark-l:var(--bulma-danger-10-l);--bulma-danger-dark:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-dark-l),1);--bulma-danger-dark-invert-l:var(--bulma-danger-75-l);--bulma-danger-dark-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-dark-invert-l),1);--bulma-danger-soft:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-soft-l),1);--bulma-danger-bold:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-bold-l),1);--bulma-danger-soft-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-soft-invert-l),1);--bulma-danger-bold-invert:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-bold-invert-l),1);--bulma-danger-on-scheme-l:40%;--bulma-danger-on-scheme:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-on-scheme-l),1);--bulma-black-bis:#14161a;--bulma-black-ter:#1f2229;--bulma-grey-darker:#2e333d;--bulma-grey-dark:#404654;--bulma-grey:#69748c;--bulma-grey-light:#abb1bf;--bulma-grey-lighter:#d6d9e0;--bulma-white-ter:#f3f4f6;--bulma-white-bis:#f9fafb;--bulma-shadow-h:221deg;--bulma-shadow-s:14%;--bulma-shadow-l:4%;--bulma-size-1:3rem;--bulma-size-2:2.5rem;--bulma-size-3:2rem;--bulma-size-4:1.5rem;--bulma-size-5:1.25rem;--bulma-size-6:1rem;--bulma-size-7:.75rem;--bulma-scheme-main:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-scheme-main-l));--bulma-scheme-main-bis:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-scheme-main-bis-l));--bulma-scheme-main-ter:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-scheme-main-ter-l));--bulma-background:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-background-l));--bulma-background-hover:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),calc(var(--bulma-background-l) + var(--bulma-hover-background-l-delta)));--bulma-background-active:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),calc(var(--bulma-background-l) + var(--bulma-active-background-l-delta)));--bulma-border-weak:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-border-weak-l));--bulma-border:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-border-l));--bulma-border-hover:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),calc(var(--bulma-border-l) + var(--bulma-hover-border-l-delta)));--bulma-border-active:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),calc(var(--bulma-border-l) + var(--bulma-active-border-l-delta)));--bulma-text-weak:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-weak-l));--bulma-text-strong:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-strong-l));--bulma-scheme-invert-ter:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-scheme-invert-ter-l));--bulma-scheme-invert-bis:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-scheme-invert-bis-l));--bulma-scheme-invert:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-scheme-invert-l));--bulma-link-text:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-on-scheme-l));--bulma-link-text-hover:hsl(var(--bulma-link-h),var(--bulma-link-s),calc(var(--bulma-link-on-scheme-l) + var(--bulma-hover-color-l-delta)));--bulma-link-text-active:hsl(var(--bulma-link-h),var(--bulma-link-s),calc(var(--bulma-link-on-scheme-l) + var(--bulma-active-color-l-delta)));--bulma-focus-h:var(--bulma-link-h);--bulma-focus-s:var(--bulma-link-s);--bulma-focus-l:var(--bulma-link-l);--bulma-focus-offset:1px;--bulma-focus-style:solid;--bulma-focus-width:2px;--bulma-focus-shadow-size:0 0 0 .1875em;--bulma-focus-shadow-alpha:.25;--bulma-code:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-on-scheme-l));--bulma-code-background:var(--bulma-background);--bulma-pre:var(--bulma-text);--bulma-pre-background:var(--bulma-background);--bulma-shadow:0 .5em 1em -.125em hsla(var(--bulma-shadow-h),var(--bulma-shadow-s),var(--bulma-shadow-l),.1),0 0px 0 1px hsla(var(--bulma-shadow-h),var(--bulma-shadow-s),var(--bulma-shadow-l),.02)}[data-theme=dark],.theme-dark{--bulma-white-on-scheme-l:100%;--bulma-white-on-scheme:hsla(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-on-scheme-l),1);--bulma-black-on-scheme-l:0%;--bulma-black-on-scheme:hsla(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-on-scheme-l),1);--bulma-light-on-scheme-l:96%;--bulma-light-on-scheme:hsla(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-on-scheme-l),1);--bulma-dark-on-scheme-l:56%;--bulma-dark-on-scheme:hsla(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-on-scheme-l),1);--bulma-text-on-scheme-l:54%;--bulma-text-on-scheme:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-on-scheme-l),1);--bulma-primary-on-scheme-l:41%;--bulma-primary-on-scheme:hsla(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-on-scheme-l),1);--bulma-link-on-scheme-l:73%;--bulma-link-on-scheme:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-on-scheme-l),1);--bulma-info-on-scheme-l:70%;--bulma-info-on-scheme:hsla(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-on-scheme-l),1);--bulma-success-on-scheme-l:53%;--bulma-success-on-scheme:hsla(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-on-scheme-l),1);--bulma-warning-on-scheme-l:53%;--bulma-warning-on-scheme:hsla(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-on-scheme-l),1);--bulma-danger-on-scheme-l:70%;--bulma-danger-on-scheme:hsla(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-on-scheme-l),1);--bulma-scheme-brightness:dark;--bulma-scheme-main-l:9%;--bulma-scheme-main-bis-l:11%;--bulma-scheme-main-ter-l:13%;--bulma-soft-l:20%;--bulma-bold-l:90%;--bulma-soft-invert-l:90%;--bulma-bold-invert-l:20%;--bulma-background-l:14%;--bulma-border-weak-l:21%;--bulma-border-l:24%;--bulma-text-weak-l:53%;--bulma-text-l:71%;--bulma-text-strong-l:93%;--bulma-text-title-l:100%;--bulma-hover-background-l-delta:5%;--bulma-active-background-l-delta:10%;--bulma-hover-border-l-delta:10%;--bulma-active-border-l-delta:20%;--bulma-hover-color-l-delta:5%;--bulma-active-color-l-delta:10%;--bulma-shadow-h:0deg;--bulma-shadow-s:0%;--bulma-shadow-l:100%;--bulma-scheme-main:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-scheme-main-l));--bulma-scheme-main-bis:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-scheme-main-bis-l));--bulma-scheme-main-ter:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-scheme-main-ter-l));--bulma-background:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-background-l));--bulma-background-hover:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),calc(var(--bulma-background-l) + var(--bulma-hover-background-l-delta)));--bulma-background-active:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),calc(var(--bulma-background-l) + var(--bulma-active-background-l-delta)));--bulma-border-weak:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-border-weak-l));--bulma-border:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-border-l));--bulma-border-hover:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),calc(var(--bulma-border-l) + var(--bulma-hover-border-l-delta)));--bulma-border-active:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),calc(var(--bulma-border-l) + var(--bulma-active-border-l-delta)));--bulma-text-weak:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-weak-l));--bulma-text:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-l));--bulma-text-strong:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-strong-l));--bulma-scheme-invert-ter:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-scheme-invert-ter-l));--bulma-scheme-invert-bis:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-scheme-invert-bis-l));--bulma-scheme-invert:hsl(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-scheme-invert-l));--bulma-link:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-l));--bulma-link-text:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-on-scheme-l));--bulma-link-text-hover:hsl(var(--bulma-link-h),var(--bulma-link-s),calc(var(--bulma-link-on-scheme-l) + var(--bulma-hover-color-l-delta)));--bulma-link-text-active:hsl(var(--bulma-link-h),var(--bulma-link-s),calc(var(--bulma-link-on-scheme-l) + var(--bulma-active-color-l-delta)));--bulma-focus-h:var(--bulma-link-h);--bulma-focus-s:var(--bulma-link-s);--bulma-focus-l:var(--bulma-link-l);--bulma-focus-offset:1px;--bulma-focus-style:solid;--bulma-focus-width:2px;--bulma-focus-shadow-size:0 0 0 .1875em;--bulma-focus-shadow-alpha:.25;--bulma-code:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-on-scheme-l));--bulma-code-background:var(--bulma-background);--bulma-pre:var(--bulma-text);--bulma-pre-background:var(--bulma-background);--bulma-shadow:0 .5em 1em -.125em hsla(var(--bulma-shadow-h),var(--bulma-shadow-s),var(--bulma-shadow-l),.1),0 0px 0 1px hsla(var(--bulma-shadow-h),var(--bulma-shadow-s),var(--bulma-shadow-l),.02)}html,body,p,ol,ul,li,dl,dt,dd,blockquote,figure,fieldset,legend,textarea,pre,iframe,hr,h1,h2,h3,h4,h5,h6{margin:0;padding:0}h1,h2,h3,h4,h5,h6{font-size:100%;font-weight:400}ul{list-style:none}button,input,select,textarea{margin:0}html{box-sizing:border-box}*,:before,:after{box-sizing:inherit}img,video{max-width:100%;height:auto}iframe{border:0}table{border-collapse:collapse;border-spacing:0}td,th{padding:0}td:not([align]),th:not([align]){text-align:inherit}:root{--bulma-body-background-color:var(--bulma-scheme-main);--bulma-body-size:1em;--bulma-body-min-width:300px;--bulma-body-rendering:optimizeLegibility;--bulma-body-family:var(--bulma-family-primary);--bulma-body-overflow-x:hidden;--bulma-body-overflow-y:scroll;--bulma-body-color:var(--bulma-text);--bulma-body-font-size:1em;--bulma-body-weight:var(--bulma-weight-normal);--bulma-body-line-height:1.5;--bulma-code-family:var(--bulma-family-code);--bulma-code-padding:.25em .5em .25em;--bulma-code-weight:normal;--bulma-code-size:.875em;--bulma-small-font-size:.875em;--bulma-hr-background-color:var(--bulma-background);--bulma-hr-height:2px;--bulma-hr-margin:1.5rem 0;--bulma-strong-color:var(--bulma-text-strong);--bulma-strong-weight:var(--bulma-weight-semibold);--bulma-pre-font-size:.875em;--bulma-pre-padding:1.25rem 1.5rem;--bulma-pre-code-font-size:1em}html{background-color:var(--bulma-body-background-color);font-size:var(--bulma-body-size);-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;min-width:var(--bulma-body-min-width);overflow-x:var(--bulma-body-overflow-x);overflow-y:var(--bulma-body-overflow-y);text-rendering:var(--bulma-body-rendering);text-size-adjust:100%}article,aside,figure,footer,header,hgroup,section{display:block}body,button,input,optgroup,select,textarea{font-family:var(--bulma-body-family)}code,pre{-moz-osx-font-smoothing:auto;-webkit-font-smoothing:auto;font-family:var(--bulma-code-family)}body{color:var(--bulma-body-color);font-size:var(--bulma-body-font-size);font-weight:var(--bulma-body-weight);line-height:var(--bulma-body-line-height)}a,button{cursor:pointer}a:focus-visible,button:focus-visible{outline-color:hsl(var(--bulma-focus-h),var(--bulma-focus-s),var(--bulma-focus-l));outline-offset:var(--bulma-focus-offset);outline-style:var(--bulma-focus-style);outline-width:var(--bulma-focus-width)}a:focus-visible:active,button:focus-visible:active,a:active,button:active{outline-width:1px}a{color:var(--bulma-link-text);cursor:pointer;transition-duration:var(--bulma-duration);text-decoration:none;transition-property:background-color,border-color,color}a strong{color:currentColor}button{appearance:none;color:inherit;transition-duration:var(--bulma-duration);background:0 0;border:none;margin:0;padding:0;font-family:inherit;font-size:1em;transition-property:background-color,border-color,color}code{background-color:var(--bulma-code-background);color:var(--bulma-code);font-size:var(--bulma-code-size);font-weight:var(--bulma-code-weight);padding:var(--bulma-code-padding);border-radius:.5em}hr{background-color:var(--bulma-hr-background-color);height:var(--bulma-hr-height);margin:var(--bulma-hr-margin);border:none;display:block}img{max-width:100%;height:auto}input[type=checkbox],input[type=radio]{vertical-align:baseline}small{font-size:var(--bulma-small-font-size)}span{font-style:inherit;font-weight:inherit}strong{color:var(--bulma-strong-color);font-weight:var(--bulma-strong-weight)}svg{width:auto;height:auto}fieldset{border:none}pre{-webkit-overflow-scrolling:touch;background-color:var(--bulma-pre-background);color:var(--bulma-pre);font-size:var(--bulma-pre-font-size);padding:var(--bulma-pre-padding);white-space:pre;word-wrap:normal;overflow-x:auto}pre code{color:currentColor;font-size:var(--bulma-pre-code-font-size);background-color:#0000;padding:0}table td,table th{vertical-align:top}table td:not([align]),table th:not([align]){text-align:inherit}table th{color:var(--bulma-text-strong)}@keyframes spinAround{0%{transform:rotate(0)}to{transform:rotate(359deg)}}@keyframes pulsate{50%{opacity:.5}}.navbar-link:not(.is-arrowless):after,.select:not(.is-multiple):not(.is-loading):after{border:.125em solid var(--bulma-arrow-color);content:" ";pointer-events:none;transform-origin:50%;transition-duration:var(--bulma-duration);border-top:0;border-right:0;width:.625em;height:.625em;margin-top:-.4375em;transition-property:border-color;display:block;position:absolute;top:50%;transform:rotate(-45deg)}.skeleton-block:not(:last-child),.media:not(:last-child),.level:not(:last-child),.fixed-grid:not(:last-child),.grid:not(:last-child),.tabs:not(:last-child),.pagination:not(:last-child),.message:not(:last-child),.card:not(:last-child),.breadcrumb:not(:last-child),.field:not(:last-child),.file:not(:last-child),.title:not(:last-child),.subtitle:not(:last-child),.tags:not(:last-child),.table:not(:last-child),.table-container:not(:last-child),.progress:not(:last-child),.notification:not(:last-child),.content:not(:last-child),.buttons:not(:last-child),.box:not(:last-child),.block:not(:last-child){margin-bottom:var(--bulma-block-spacing)}.pagination-previous,.pagination-next,.pagination-link,.pagination-ellipsis,.file-cta,.file-name,.select select,.input,.textarea,.button{appearance:none;border-style:solid;border-color:#0000;border-width:var(--bulma-control-border-width);border-radius:var(--bulma-control-radius);box-shadow:none;font-size:var(--bulma-control-size);height:var(--bulma-control-height);line-height:var(--bulma-control-line-height);padding-bottom:var(--bulma-control-padding-vertical);padding-left:var(--bulma-control-padding-horizontal);padding-right:var(--bulma-control-padding-horizontal);padding-top:var(--bulma-control-padding-vertical);transition-duration:var(--bulma-duration);vertical-align:top;justify-content:flex-start;align-items:center;transition-property:background-color,border-color,box-shadow,color;display:inline-flex;position:relative}.pagination-previous:focus,.pagination-next:focus,.pagination-link:focus,.pagination-ellipsis:focus,.file-cta:focus,.file-name:focus,.select select:focus,.input:focus,.textarea:focus,.button:focus,.pagination-previous:focus-visible,.pagination-next:focus-visible,.pagination-link:focus-visible,.pagination-ellipsis:focus-visible,.file-cta:focus-visible,.file-name:focus-visible,.select select:focus-visible,.input:focus-visible,.textarea:focus-visible,.button:focus-visible,.pagination-previous:focus-within,.pagination-next:focus-within,.pagination-link:focus-within,.pagination-ellipsis:focus-within,.file-cta:focus-within,.file-name:focus-within,.select select:focus-within,.input:focus-within,.textarea:focus-within,.button:focus-within,.is-focused.pagination-previous,.is-focused.pagination-next,.is-focused.pagination-link,.is-focused.pagination-ellipsis,.is-focused.file-cta,.is-focused.file-name,.select select.is-focused,.is-focused.input,.is-focused.textarea,.is-focused.button,.pagination-previous:active,.pagination-next:active,.pagination-link:active,.pagination-ellipsis:active,.file-cta:active,.file-name:active,.select select:active,.input:active,.textarea:active,.button:active,.is-active.pagination-previous,.is-active.pagination-next,.is-active.pagination-link,.is-active.pagination-ellipsis,.is-active.file-cta,.is-active.file-name,.select select.is-active,.is-active.input,.is-active.textarea,.is-active.button{outline:none}[disabled].pagination-previous,[disabled].pagination-next,[disabled].pagination-link,[disabled].pagination-ellipsis,[disabled].file-cta,[disabled].file-name,.select select[disabled],[disabled].input,[disabled].textarea,[disabled].button,fieldset[disabled] .pagination-previous,fieldset[disabled] .pagination-next,fieldset[disabled] .pagination-link,fieldset[disabled] .pagination-ellipsis,fieldset[disabled] .file-cta,fieldset[disabled] .file-name,fieldset[disabled] .select select,.select fieldset[disabled] select,fieldset[disabled] .input,fieldset[disabled] .textarea,fieldset[disabled] .button{cursor:not-allowed}.modal-close{--bulma-delete-dimensions:1.25rem;--bulma-delete-background-l:0%;--bulma-delete-background-alpha:.5;--bulma-delete-color:var(--bulma-white);appearance:none;background-color:hsla(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-delete-background-l),var(--bulma-delete-background-alpha));border-radius:var(--bulma-radius-rounded);cursor:pointer;pointer-events:auto;height:var(--bulma-delete-dimensions);max-height:var(--bulma-delete-dimensions);max-width:var(--bulma-delete-dimensions);min-height:var(--bulma-delete-dimensions);min-width:var(--bulma-delete-dimensions);vertical-align:top;width:var(--bulma-delete-dimensions);border:none;outline:none;flex-grow:0;flex-shrink:0;font-size:1em;display:inline-flex;position:relative}.modal-close:before,.modal-close:after{background-color:var(--bulma-delete-color);content:"";transform-origin:50%;display:block;position:absolute;top:50%;left:50%;transform:translate(-50%)translateY(-50%)rotate(45deg)}.modal-close:before{width:50%;height:2px}.modal-close:after{width:2px;height:50%}.modal-close:hover,.modal-close:focus{--bulma-delete-background-alpha:.4}.modal-close:active{--bulma-delete-background-alpha:.5}.is-small.modal-close{--bulma-delete-dimensions:1rem}.is-medium.modal-close{--bulma-delete-dimensions:1.5rem}.is-large.modal-close{--bulma-delete-dimensions:2rem}.control.is-loading:after,.select.is-loading:after,.button.is-loading:after{border:2px solid var(--bulma-loading-color);border-radius:var(--bulma-radius-rounded);content:"";border-top-color:#0000;border-right-color:#0000;width:1em;height:1em;animation:.5s linear infinite spinAround;display:block;position:relative}.is-overlay,.hero-video,.modal,.modal-background{position:absolute;inset:0}.navbar-burger,.menu-list a,.menu-list button,.menu-list .menu-item{appearance:none;color:inherit;background:0 0;border:none;margin:0;padding:0;font-family:inherit;font-size:1em}.is-unselectable,.tabs,.pagination-previous,.pagination-next,.pagination-link,.pagination-ellipsis,.breadcrumb,.file,.button{-webkit-touch-callout:none;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none}.box{--bulma-box-background-color:var(--bulma-scheme-main);--bulma-box-color:var(--bulma-text);--bulma-box-radius:var(--bulma-radius-large);--bulma-box-shadow:var(--bulma-shadow);--bulma-box-padding:1.25rem;--bulma-box-link-hover-shadow:0 .5em 1em -.125em hsla(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-scheme-invert-l),.1),0 0 0 1px var(--bulma-link);--bulma-box-link-active-shadow:inset 0 1px 2px hsla(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-scheme-invert-l),.2),0 0 0 1px var(--bulma-link);background-color:var(--bulma-box-background-color);border-radius:var(--bulma-box-radius);box-shadow:var(--bulma-box-shadow);color:var(--bulma-box-color);padding:var(--bulma-box-padding);display:block}a.box:hover,a.box:focus{box-shadow:var(--bulma-box-link-hover-shadow)}a.box:active{box-shadow:var(--bulma-box-link-active-shadow)}.button{--bulma-button-family:false;--bulma-button-weight:var(--bulma-weight-medium);--bulma-button-border-color:var(--bulma-border);--bulma-button-border-style:solid;--bulma-button-border-width:var(--bulma-control-border-width);--bulma-button-padding-vertical:.5em;--bulma-button-padding-horizontal:1em;--bulma-button-focus-border-color:var(--bulma-link-focus-border);--bulma-button-focus-box-shadow-size:0 0 0 .125em;--bulma-button-focus-box-shadow-color:hsla(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-on-scheme-l),.25);--bulma-button-active-color:var(--bulma-link-active);--bulma-button-active-border-color:var(--bulma-link-active-border);--bulma-button-text-color:var(--bulma-text);--bulma-button-text-decoration:underline;--bulma-button-text-hover-background-color:var(--bulma-background);--bulma-button-text-hover-color:var(--bulma-text-strong);--bulma-button-ghost-background:none;--bulma-button-ghost-border-color:transparent;--bulma-button-ghost-color:var(--bulma-link-text);--bulma-button-ghost-decoration:none;--bulma-button-ghost-hover-color:var(--bulma-link);--bulma-button-ghost-hover-decoration:underline;--bulma-button-disabled-background-color:var(--bulma-scheme-main);--bulma-button-disabled-border-color:var(--bulma-border);--bulma-button-disabled-shadow:none;--bulma-button-disabled-opacity:.5;--bulma-button-static-color:var(--bulma-text-weak);--bulma-button-static-background-color:var(--bulma-scheme-main-ter);--bulma-button-static-border-color:var(--bulma-border);--bulma-button-h:var(--bulma-scheme-h);--bulma-button-s:var(--bulma-scheme-s);--bulma-button-l:var(--bulma-scheme-main-l);--bulma-button-background-l:var(--bulma-scheme-main-l);--bulma-button-background-l-delta:0%;--bulma-button-hover-background-l-delta:var(--bulma-hover-background-l-delta);--bulma-button-active-background-l-delta:var(--bulma-active-background-l-delta);--bulma-button-color-l:var(--bulma-text-strong-l);--bulma-button-border-l:var(--bulma-border-l);--bulma-button-border-l-delta:0%;--bulma-button-hover-border-l-delta:var(--bulma-hover-border-l-delta);--bulma-button-active-border-l-delta:var(--bulma-active-border-l-delta);--bulma-button-focus-border-l-delta:var(--bulma-focus-border-l-delta);--bulma-button-outer-shadow-h:0;--bulma-button-outer-shadow-s:0%;--bulma-button-outer-shadow-l:20%;--bulma-button-outer-shadow-a:.05;--bulma-loading-color:hsl(var(--bulma-button-h),var(--bulma-button-s),var(--bulma-button-color-l));background-color:hsl(var(--bulma-button-h),var(--bulma-button-s),calc(var(--bulma-button-background-l) + var(--bulma-button-background-l-delta)));border-color:hsl(var(--bulma-button-h),var(--bulma-button-s),calc(var(--bulma-button-border-l) + var(--bulma-button-border-l-delta)));border-style:var(--bulma-button-border-style);border-width:var(--bulma-button-border-width);box-shadow:0px .0625em .125em hsla(var(--bulma-button-outer-shadow-h),var(--bulma-button-outer-shadow-s),var(--bulma-button-outer-shadow-l),var(--bulma-button-outer-shadow-a)),0px .125em .25em hsla(var(--bulma-button-outer-shadow-h),var(--bulma-button-outer-shadow-s),var(--bulma-button-outer-shadow-l),var(--bulma-button-outer-shadow-a));color:hsl(var(--bulma-button-h),var(--bulma-button-s),var(--bulma-button-color-l));cursor:pointer;font-weight:var(--bulma-button-weight);padding-bottom:calc(var(--bulma-button-padding-vertical) - var(--bulma-button-border-width));padding-left:calc(var(--bulma-button-padding-horizontal) - var(--bulma-button-border-width));padding-right:calc(var(--bulma-button-padding-horizontal) - var(--bulma-button-border-width));padding-top:calc(var(--bulma-button-padding-vertical) - var(--bulma-button-border-width));text-align:center;white-space:nowrap;justify-content:center;height:auto}.button strong{color:inherit}.button .icon,.button .icon.is-small,.button .icon.is-medium,.button .icon.is-large{width:1.5em;height:1.5em}.button .icon:first-child:not(:last-child){margin-inline-start:calc(-.5*var(--bulma-button-padding-horizontal));margin-inline-end:calc(var(--bulma-button-padding-horizontal)*.25)}.button .icon:last-child:not(:first-child){margin-inline-start:calc(var(--bulma-button-padding-horizontal)*.25);margin-inline-end:calc(-.5*var(--bulma-button-padding-horizontal))}.button .icon:first-child:last-child{margin-inline-start:calc(-.5*var(--bulma-button-padding-horizontal));margin-inline-end:calc(-.5*var(--bulma-button-padding-horizontal))}.button:hover,.button.is-hovered{--bulma-button-background-l-delta:var(--bulma-button-hover-background-l-delta);--bulma-button-border-l-delta:var(--bulma-button-hover-border-l-delta)}.button:focus-visible,.button.is-focused{--bulma-button-border-width:1px;border-color:hsl(var(--bulma-focus-h),var(--bulma-focus-s),var(--bulma-focus-l));box-shadow:var(--bulma-focus-shadow-size)hsla(var(--bulma-focus-h),var(--bulma-focus-s),var(--bulma-focus-l),var(--bulma-focus-shadow-alpha))}.button:active,.button.is-active{--bulma-button-background-l-delta:var(--bulma-button-active-background-l-delta);--bulma-button-border-l-delta:var(--bulma-button-active-border-l-delta);--bulma-button-outer-shadow-a:0}.button[disabled],fieldset[disabled] .button{background-color:var(--bulma-button-disabled-background-color);border-color:var(--bulma-button-disabled-border-color);box-shadow:var(--bulma-button-disabled-shadow);opacity:var(--bulma-button-disabled-opacity)}.button.is-white{--bulma-button-h:var(--bulma-white-h);--bulma-button-s:var(--bulma-white-s);--bulma-button-l:var(--bulma-white-l);--bulma-button-background-l:var(--bulma-white-l);--bulma-button-border-l:var(--bulma-white-l);--bulma-button-border-width:0px;--bulma-button-color-l:var(--bulma-white-invert-l);--bulma-button-outer-shadow-a:0}.button.is-white:focus-visible,.button.is-white.is-focused{--bulma-button-border-width:1px}.button.is-white.is-soft{--bulma-button-background-l:var(--bulma-soft-l);--bulma-button-color-l:var(--bulma-soft-invert-l)}.button.is-white.is-bold{--bulma-button-background-l:var(--bulma-bold-l);--bulma-button-color-l:var(--bulma-bold-invert-l)}.button.is-white[disabled],fieldset[disabled] .button.is-white{background-color:var(--bulma-white);border-color:var(--bulma-white);box-shadow:none}.button.is-black{--bulma-button-h:var(--bulma-black-h);--bulma-button-s:var(--bulma-black-s);--bulma-button-l:var(--bulma-black-l);--bulma-button-background-l:var(--bulma-black-l);--bulma-button-border-l:var(--bulma-black-l);--bulma-button-border-width:0px;--bulma-button-color-l:var(--bulma-black-invert-l);--bulma-button-outer-shadow-a:0}.button.is-black:focus-visible,.button.is-black.is-focused{--bulma-button-border-width:1px}.button.is-black.is-soft{--bulma-button-background-l:var(--bulma-soft-l);--bulma-button-color-l:var(--bulma-soft-invert-l)}.button.is-black.is-bold{--bulma-button-background-l:var(--bulma-bold-l);--bulma-button-color-l:var(--bulma-bold-invert-l)}.button.is-black[disabled],fieldset[disabled] .button.is-black{background-color:var(--bulma-black);border-color:var(--bulma-black);box-shadow:none}.button.is-light{--bulma-button-h:var(--bulma-light-h);--bulma-button-s:var(--bulma-light-s);--bulma-button-l:var(--bulma-light-l);--bulma-button-background-l:var(--bulma-light-l);--bulma-button-border-l:var(--bulma-light-l);--bulma-button-border-width:0px;--bulma-button-color-l:var(--bulma-light-invert-l);--bulma-button-outer-shadow-a:0}.button.is-light:focus-visible,.button.is-light.is-focused{--bulma-button-border-width:1px}.button.is-light.is-soft{--bulma-button-background-l:var(--bulma-soft-l);--bulma-button-color-l:var(--bulma-soft-invert-l)}.button.is-light.is-bold{--bulma-button-background-l:var(--bulma-bold-l);--bulma-button-color-l:var(--bulma-bold-invert-l)}.button.is-light[disabled],fieldset[disabled] .button.is-light{background-color:var(--bulma-light);border-color:var(--bulma-light);box-shadow:none}.button.is-dark{--bulma-button-h:var(--bulma-dark-h);--bulma-button-s:var(--bulma-dark-s);--bulma-button-l:var(--bulma-dark-l);--bulma-button-background-l:var(--bulma-dark-l);--bulma-button-border-l:var(--bulma-dark-l);--bulma-button-border-width:0px;--bulma-button-color-l:var(--bulma-dark-invert-l);--bulma-button-outer-shadow-a:0}.button.is-dark:focus-visible,.button.is-dark.is-focused{--bulma-button-border-width:1px}.button.is-dark.is-soft{--bulma-button-background-l:var(--bulma-soft-l);--bulma-button-color-l:var(--bulma-soft-invert-l)}.button.is-dark.is-bold{--bulma-button-background-l:var(--bulma-bold-l);--bulma-button-color-l:var(--bulma-bold-invert-l)}.button.is-dark[disabled],fieldset[disabled] .button.is-dark{background-color:var(--bulma-dark);border-color:var(--bulma-dark);box-shadow:none}.button.is-text{--bulma-button-h:var(--bulma-text-h);--bulma-button-s:var(--bulma-text-s);--bulma-button-l:var(--bulma-text-l);--bulma-button-background-l:var(--bulma-text-l);--bulma-button-border-l:var(--bulma-text-l);--bulma-button-border-width:0px;--bulma-button-color-l:var(--bulma-text-invert-l);--bulma-button-outer-shadow-a:0}.button.is-text:focus-visible,.button.is-text.is-focused{--bulma-button-border-width:1px}.button.is-text.is-light{--bulma-button-background-l:var(--bulma-light-l);--bulma-button-color-l:var(--bulma-text-light-invert-l)}.button.is-text.is-dark{--bulma-button-background-l:var(--bulma-dark-l);--bulma-button-color-l:var(--bulma-text-dark-invert-l)}.button.is-text.is-soft{--bulma-button-background-l:var(--bulma-soft-l);--bulma-button-color-l:var(--bulma-soft-invert-l)}.button.is-text.is-bold{--bulma-button-background-l:var(--bulma-bold-l);--bulma-button-color-l:var(--bulma-bold-invert-l)}.button.is-text[disabled],fieldset[disabled] .button.is-text{background-color:var(--bulma-text);border-color:var(--bulma-text);box-shadow:none}.button.is-primary{--bulma-button-h:var(--bulma-primary-h);--bulma-button-s:var(--bulma-primary-s);--bulma-button-l:var(--bulma-primary-l);--bulma-button-background-l:var(--bulma-primary-l);--bulma-button-border-l:var(--bulma-primary-l);--bulma-button-border-width:0px;--bulma-button-color-l:var(--bulma-primary-invert-l);--bulma-button-outer-shadow-a:0}.button.is-primary:focus-visible,.button.is-primary.is-focused{--bulma-button-border-width:1px}.button.is-primary.is-light{--bulma-button-background-l:var(--bulma-light-l);--bulma-button-color-l:var(--bulma-primary-light-invert-l)}.button.is-primary.is-dark{--bulma-button-background-l:var(--bulma-dark-l);--bulma-button-color-l:var(--bulma-primary-dark-invert-l)}.button.is-primary.is-soft{--bulma-button-background-l:var(--bulma-soft-l);--bulma-button-color-l:var(--bulma-soft-invert-l)}.button.is-primary.is-bold{--bulma-button-background-l:var(--bulma-bold-l);--bulma-button-color-l:var(--bulma-bold-invert-l)}.button.is-primary[disabled],fieldset[disabled] .button.is-primary{background-color:var(--bulma-primary);border-color:var(--bulma-primary);box-shadow:none}.button.is-link{--bulma-button-h:var(--bulma-link-h);--bulma-button-s:var(--bulma-link-s);--bulma-button-l:var(--bulma-link-l);--bulma-button-background-l:var(--bulma-link-l);--bulma-button-border-l:var(--bulma-link-l);--bulma-button-border-width:0px;--bulma-button-color-l:var(--bulma-link-invert-l);--bulma-button-outer-shadow-a:0}.button.is-link:focus-visible,.button.is-link.is-focused{--bulma-button-border-width:1px}.button.is-link.is-light{--bulma-button-background-l:var(--bulma-light-l);--bulma-button-color-l:var(--bulma-link-light-invert-l)}.button.is-link.is-dark{--bulma-button-background-l:var(--bulma-dark-l);--bulma-button-color-l:var(--bulma-link-dark-invert-l)}.button.is-link.is-soft{--bulma-button-background-l:var(--bulma-soft-l);--bulma-button-color-l:var(--bulma-soft-invert-l)}.button.is-link.is-bold{--bulma-button-background-l:var(--bulma-bold-l);--bulma-button-color-l:var(--bulma-bold-invert-l)}.button.is-link[disabled],fieldset[disabled] .button.is-link{background-color:var(--bulma-link);border-color:var(--bulma-link);box-shadow:none}.button.is-info{--bulma-button-h:var(--bulma-info-h);--bulma-button-s:var(--bulma-info-s);--bulma-button-l:var(--bulma-info-l);--bulma-button-background-l:var(--bulma-info-l);--bulma-button-border-l:var(--bulma-info-l);--bulma-button-border-width:0px;--bulma-button-color-l:var(--bulma-info-invert-l);--bulma-button-outer-shadow-a:0}.button.is-info:focus-visible,.button.is-info.is-focused{--bulma-button-border-width:1px}.button.is-info.is-light{--bulma-button-background-l:var(--bulma-light-l);--bulma-button-color-l:var(--bulma-info-light-invert-l)}.button.is-info.is-dark{--bulma-button-background-l:var(--bulma-dark-l);--bulma-button-color-l:var(--bulma-info-dark-invert-l)}.button.is-info.is-soft{--bulma-button-background-l:var(--bulma-soft-l);--bulma-button-color-l:var(--bulma-soft-invert-l)}.button.is-info.is-bold{--bulma-button-background-l:var(--bulma-bold-l);--bulma-button-color-l:var(--bulma-bold-invert-l)}.button.is-info[disabled],fieldset[disabled] .button.is-info{background-color:var(--bulma-info);border-color:var(--bulma-info);box-shadow:none}.button.is-success{--bulma-button-h:var(--bulma-success-h);--bulma-button-s:var(--bulma-success-s);--bulma-button-l:var(--bulma-success-l);--bulma-button-background-l:var(--bulma-success-l);--bulma-button-border-l:var(--bulma-success-l);--bulma-button-border-width:0px;--bulma-button-color-l:var(--bulma-success-invert-l);--bulma-button-outer-shadow-a:0}.button.is-success:focus-visible,.button.is-success.is-focused{--bulma-button-border-width:1px}.button.is-success.is-light{--bulma-button-background-l:var(--bulma-light-l);--bulma-button-color-l:var(--bulma-success-light-invert-l)}.button.is-success.is-dark{--bulma-button-background-l:var(--bulma-dark-l);--bulma-button-color-l:var(--bulma-success-dark-invert-l)}.button.is-success.is-soft{--bulma-button-background-l:var(--bulma-soft-l);--bulma-button-color-l:var(--bulma-soft-invert-l)}.button.is-success.is-bold{--bulma-button-background-l:var(--bulma-bold-l);--bulma-button-color-l:var(--bulma-bold-invert-l)}.button.is-success[disabled],fieldset[disabled] .button.is-success{background-color:var(--bulma-success);border-color:var(--bulma-success);box-shadow:none}.button.is-warning{--bulma-button-h:var(--bulma-warning-h);--bulma-button-s:var(--bulma-warning-s);--bulma-button-l:var(--bulma-warning-l);--bulma-button-background-l:var(--bulma-warning-l);--bulma-button-border-l:var(--bulma-warning-l);--bulma-button-border-width:0px;--bulma-button-color-l:var(--bulma-warning-invert-l);--bulma-button-outer-shadow-a:0}.button.is-warning:focus-visible,.button.is-warning.is-focused{--bulma-button-border-width:1px}.button.is-warning.is-light{--bulma-button-background-l:var(--bulma-light-l);--bulma-button-color-l:var(--bulma-warning-light-invert-l)}.button.is-warning.is-dark{--bulma-button-background-l:var(--bulma-dark-l);--bulma-button-color-l:var(--bulma-warning-dark-invert-l)}.button.is-warning.is-soft{--bulma-button-background-l:var(--bulma-soft-l);--bulma-button-color-l:var(--bulma-soft-invert-l)}.button.is-warning.is-bold{--bulma-button-background-l:var(--bulma-bold-l);--bulma-button-color-l:var(--bulma-bold-invert-l)}.button.is-warning[disabled],fieldset[disabled] .button.is-warning{background-color:var(--bulma-warning);border-color:var(--bulma-warning);box-shadow:none}.button.is-danger{--bulma-button-h:var(--bulma-danger-h);--bulma-button-s:var(--bulma-danger-s);--bulma-button-l:var(--bulma-danger-l);--bulma-button-background-l:var(--bulma-danger-l);--bulma-button-border-l:var(--bulma-danger-l);--bulma-button-border-width:0px;--bulma-button-color-l:var(--bulma-danger-invert-l);--bulma-button-outer-shadow-a:0}.button.is-danger:focus-visible,.button.is-danger.is-focused{--bulma-button-border-width:1px}.button.is-danger.is-light{--bulma-button-background-l:var(--bulma-light-l);--bulma-button-color-l:var(--bulma-danger-light-invert-l)}.button.is-danger.is-dark{--bulma-button-background-l:var(--bulma-dark-l);--bulma-button-color-l:var(--bulma-danger-dark-invert-l)}.button.is-danger.is-soft{--bulma-button-background-l:var(--bulma-soft-l);--bulma-button-color-l:var(--bulma-soft-invert-l)}.button.is-danger.is-bold{--bulma-button-background-l:var(--bulma-bold-l);--bulma-button-color-l:var(--bulma-bold-invert-l)}.button.is-danger[disabled],fieldset[disabled] .button.is-danger{background-color:var(--bulma-danger);border-color:var(--bulma-danger);box-shadow:none}.button.is-outlined{--bulma-button-border-width:max(1px,.0625em);border-color:hsl(var(--bulma-button-h),var(--bulma-button-s),var(--bulma-button-l));color:hsl(var(--bulma-button-h),var(--bulma-button-s),var(--bulma-button-l));background-color:#0000}.button.is-outlined:hover{--bulma-button-border-width:max(2px,.125em);--bulma-button-outer-shadow-alpha:1}.button.is-inverted{background-color:hsl(var(--bulma-button-h),var(--bulma-button-s),calc(var(--bulma-button-color-l) + var(--bulma-button-background-l-delta)));color:hsl(var(--bulma-button-h),var(--bulma-button-s),var(--bulma-button-background-l))}.button.is-text{color:var(--bulma-button-text-color);text-decoration:var(--bulma-button-text-decoration);background-color:#0000;border-color:#0000}.button.is-text:hover,.button.is-text.is-hovered{background-color:var(--bulma-button-text-hover-background-color);color:var(--bulma-button-text-hover-color)}.button.is-text:active,.button.is-text.is-active{color:var(--bulma-button-text-hover-color)}.button.is-text[disabled],fieldset[disabled] .button.is-text{box-shadow:none;background-color:#0000;border-color:#0000}.button.is-ghost{background:var(--bulma-button-ghost-background);border-color:var(--bulma-button-ghost-border-color);box-shadow:none;color:var(--bulma-button-ghost-color);text-decoration:var(--bulma-button-ghost-decoration)}.button.is-ghost:hover,.button.is-ghost.is-hovered{color:var(--bulma-button-ghost-hover-color);text-decoration:var(--bulma-button-ghost-hover-decoration)}.button.is-small{--bulma-control-size:var(--bulma-size-small);--bulma-control-radius:var(--bulma-radius-small)}.button.is-normal{--bulma-control-size:var(--bulma-size-normal);--bulma-control-radius:var(--bulma-radius)}.button.is-medium{--bulma-control-size:var(--bulma-size-medium);--bulma-control-radius:var(--bulma-radius-medium)}.button.is-large{--bulma-control-size:var(--bulma-size-large);--bulma-control-radius:var(--bulma-radius-medium)}.button.is-fullwidth{width:100%;display:flex}.button.is-loading{box-shadow:none;pointer-events:none;color:#0000!important}.button.is-loading:after{position:absolute;top:calc(50% - .5em);left:calc(50% - .5em);position:absolute!important}.button.is-static{background-color:var(--bulma-button-static-background-color);border-color:var(--bulma-button-static-border-color);color:var(--bulma-button-static-color);box-shadow:none;pointer-events:none}.button.is-rounded{border-radius:var(--bulma-radius-rounded);padding-left:calc(var(--bulma-button-padding-horizontal) + .25em - var(--bulma-button-border-width));padding-right:calc(var(--bulma-button-padding-horizontal) + .25em - var(--bulma-button-border-width))}.buttons{flex-wrap:wrap;justify-content:flex-start;align-items:center;gap:.75rem;display:flex}.buttons.are-small{--bulma-control-size:var(--bulma-size-small);--bulma-control-radius:var(--bulma-radius-small)}.buttons.are-medium{--bulma-control-size:var(--bulma-size-medium);--bulma-control-radius:var(--bulma-radius-medium)}.buttons.are-large{--bulma-control-size:var(--bulma-size-large);--bulma-control-radius:var(--bulma-radius-large)}.buttons.has-addons{gap:0}.buttons.has-addons .button:not(:first-child){border-start-start-radius:0;border-end-start-radius:0}.buttons.has-addons .button:not(:last-child){border-start-end-radius:0;border-end-end-radius:0;margin-inline-end:-1px}.buttons.has-addons .button:hover,.buttons.has-addons .button.is-hovered{z-index:2}.buttons.has-addons .button:focus,.buttons.has-addons .button.is-focused,.buttons.has-addons .button:active,.buttons.has-addons .button.is-active,.buttons.has-addons .button.is-selected{z-index:3}.buttons.has-addons .button:focus:hover,.buttons.has-addons .button.is-focused:hover,.buttons.has-addons .button:active:hover,.buttons.has-addons .button.is-active:hover,.buttons.has-addons .button.is-selected:hover{z-index:4}.buttons.has-addons .button.is-expanded{flex-grow:1;flex-shrink:1}.buttons.is-centered{justify-content:center}.buttons.is-right{justify-content:flex-end}@media screen and (width<=768px){.button.is-responsive.is-small{font-size:calc(var(--bulma-size-small)*.75)}.button.is-responsive,.button.is-responsive.is-normal{font-size:calc(var(--bulma-size-small)*.875)}.button.is-responsive.is-medium{font-size:var(--bulma-size-small)}.button.is-responsive.is-large{font-size:var(--bulma-size-normal)}}@media screen and (width>=769px) and (width<=1023px){.button.is-responsive.is-small{font-size:calc(var(--bulma-size-small)*.875)}.button.is-responsive,.button.is-responsive.is-normal{font-size:var(--bulma-size-small)}.button.is-responsive.is-medium{font-size:var(--bulma-size-normal)}.button.is-responsive.is-large{font-size:var(--bulma-size-medium)}}.content{--bulma-content-heading-color:var(--bulma-text-strong);--bulma-content-heading-weight:var(--bulma-weight-extrabold);--bulma-content-heading-line-height:1.125;--bulma-content-block-margin-bottom:1em;--bulma-content-blockquote-background-color:var(--bulma-background);--bulma-content-blockquote-border-left:5px solid var(--bulma-border);--bulma-content-blockquote-padding:1.25em 1.5em;--bulma-content-pre-padding:1.25em 1.5em;--bulma-content-table-cell-border:1px solid var(--bulma-border);--bulma-content-table-cell-border-width:0 0 1px;--bulma-content-table-cell-padding:.5em .75em;--bulma-content-table-cell-heading-color:var(--bulma-text-strong);--bulma-content-table-head-cell-border-width:0 0 2px;--bulma-content-table-head-cell-color:var(--bulma-text-strong);--bulma-content-table-body-last-row-cell-border-bottom-width:0;--bulma-content-table-foot-cell-border-width:2px 0 0;--bulma-content-table-foot-cell-color:var(--bulma-text-strong)}.content li+li{margin-top:.25em}.content p:not(:last-child),.content dl:not(:last-child),.content ol:not(:last-child),.content ul:not(:last-child),.content blockquote:not(:last-child),.content pre:not(:last-child),.content table:not(:last-child){margin-bottom:var(--bulma-content-block-margin-bottom)}.content h1,.content h2,.content h3,.content h4,.content h5,.content h6{color:var(--bulma-content-heading-color);font-weight:var(--bulma-content-heading-weight);line-height:var(--bulma-content-heading-line-height)}.content h1{margin-bottom:.5em;font-size:2em}.content h1:not(:first-child){margin-top:1em}.content h2{margin-bottom:.5714em;font-size:1.75em}.content h2:not(:first-child){margin-top:1.1428em}.content h3{margin-bottom:.6666em;font-size:1.5em}.content h3:not(:first-child){margin-top:1.3333em}.content h4{margin-bottom:.8em;font-size:1.25em}.content h5{margin-bottom:.8888em;font-size:1.125em}.content h6{margin-bottom:1em;font-size:1em}.content blockquote{background-color:var(--bulma-content-blockquote-background-color);border-inline-start:var(--bulma-content-blockquote-border-left);padding:var(--bulma-content-blockquote-padding)}.content ol{margin-inline-start:2em;list-style-position:outside}.content ol:not(:first-child){margin-top:1em}.content ol:not([type]){list-style-type:decimal}.content ol:not([type]).is-lower-alpha{list-style-type:lower-alpha}.content ol:not([type]).is-lower-roman{list-style-type:lower-roman}.content ol:not([type]).is-upper-alpha{list-style-type:upper-alpha}.content ol:not([type]).is-upper-roman{list-style-type:upper-roman}.content ul{margin-inline-start:2em;list-style:disc}.content ul:not(:first-child){margin-top:1em}.content ul ul{margin-top:.25em;margin-bottom:.25em;list-style-type:circle}.content ul ul ul{list-style-type:square}.content dd{margin-inline-start:2em}.content figure:not([class]){text-align:center;margin-left:2em;margin-right:2em}.content figure:not([class]):not(:first-child){margin-top:2em}.content figure:not([class]):not(:last-child){margin-bottom:2em}.content figure:not([class]) img{display:inline-block}.content figure:not([class]) figcaption{font-style:italic}.content pre{-webkit-overflow-scrolling:touch;padding:var(--bulma-content-pre-padding);white-space:pre;word-wrap:normal;overflow-x:auto}.content sup,.content sub{font-size:75%}.content table td,.content table th{border:var(--bulma-content-table-cell-border);border-width:var(--bulma-content-table-cell-border-width);padding:var(--bulma-content-table-cell-padding);vertical-align:top}.content table th{color:var(--bulma-content-table-cell-heading-color)}.content table th:not([align]){text-align:inherit}.content table thead td,.content table thead th{border-width:var(--bulma-content-table-head-cell-border-width);color:var(--bulma-content-table-head-cell-color)}.content table tfoot td,.content table tfoot th{border-width:var(--bulma-content-table-foot-cell-border-width);color:var(--bulma-content-table-foot-cell-color)}.content table tbody tr:last-child td,.content table tbody tr:last-child th{border-bottom-width:var(--bulma-content-table-body-last-row-cell-border-bottom-width)}.content .tabs li+li{margin-top:0}.content.is-small{font-size:var(--bulma-size-small)}.content.is-normal{font-size:var(--bulma-size-normal)}.content.is-medium{font-size:var(--bulma-size-medium)}.content.is-large{font-size:var(--bulma-size-large)}.delete{--bulma-delete-dimensions:1.25rem;--bulma-delete-background-l:0%;--bulma-delete-background-alpha:.5;--bulma-delete-color:var(--bulma-white);appearance:none;background-color:hsla(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-delete-background-l),var(--bulma-delete-background-alpha));border-radius:var(--bulma-radius-rounded);cursor:pointer;pointer-events:auto;height:var(--bulma-delete-dimensions);max-height:var(--bulma-delete-dimensions);max-width:var(--bulma-delete-dimensions);min-height:var(--bulma-delete-dimensions);min-width:var(--bulma-delete-dimensions);vertical-align:top;width:var(--bulma-delete-dimensions);border:none;outline:none;flex-grow:0;flex-shrink:0;font-size:1em;display:inline-flex;position:relative}.delete:before,.delete:after{background-color:var(--bulma-delete-color);content:"";transform-origin:50%;display:block;position:absolute;top:50%;left:50%;transform:translate(-50%)translateY(-50%)rotate(45deg)}.delete:before{width:50%;height:2px}.delete:after{width:2px;height:50%}.delete:hover,.delete:focus{--bulma-delete-background-alpha:.4}.delete:active{--bulma-delete-background-alpha:.5}.delete.is-small{--bulma-delete-dimensions:1rem}.delete.is-medium{--bulma-delete-dimensions:1.5rem}.delete.is-large{--bulma-delete-dimensions:2rem}.icon,.icon-text{--bulma-icon-dimensions:1.5rem;--bulma-icon-dimensions-small:1rem;--bulma-icon-dimensions-medium:2rem;--bulma-icon-dimensions-large:3rem;--bulma-icon-text-spacing:.25em}.icon{height:var(--bulma-icon-dimensions);transition-duration:var(--bulma-duration);width:var(--bulma-icon-dimensions);flex-shrink:0;justify-content:center;align-items:center;transition-property:color;display:inline-flex}.icon.is-small{height:var(--bulma-icon-dimensions-small);width:var(--bulma-icon-dimensions-small)}.icon.is-medium{height:var(--bulma-icon-dimensions-medium);width:var(--bulma-icon-dimensions-medium)}.icon.is-large{height:var(--bulma-icon-dimensions-large);width:var(--bulma-icon-dimensions-large)}.icon-text{color:inherit;align-items:flex-start;gap:var(--bulma-icon-text-spacing);line-height:var(--bulma-icon-dimensions);vertical-align:top;flex-wrap:wrap;display:inline-flex}.icon-text .icon{flex-grow:0;flex-shrink:0}div.icon-text{display:flex}.image{display:block;position:relative}.image img{width:100%;height:auto;display:block}.image img.is-rounded{border-radius:var(--bulma-radius-rounded)}.image.is-fullwidth{width:100%}.image.is-square img,.image.is-square .has-ratio{width:100%;height:100%;position:absolute;inset:0}.image.is-square,.image.is-1by1{aspect-ratio:1}.image.is-1by1 img,.image.is-1by1 .has-ratio{width:100%;height:100%;position:absolute;inset:0}.image.is-5by4{aspect-ratio:5/4}.image.is-5by4 img,.image.is-5by4 .has-ratio{width:100%;height:100%;position:absolute;inset:0}.image.is-4by3{aspect-ratio:4/3}.image.is-4by3 img,.image.is-4by3 .has-ratio{width:100%;height:100%;position:absolute;inset:0}.image.is-3by2{aspect-ratio:3/2}.image.is-3by2 img,.image.is-3by2 .has-ratio{width:100%;height:100%;position:absolute;inset:0}.image.is-5by3{aspect-ratio:5/3}.image.is-5by3 img,.image.is-5by3 .has-ratio{width:100%;height:100%;position:absolute;inset:0}.image.is-16by9{aspect-ratio:16/9}.image.is-16by9 img,.image.is-16by9 .has-ratio{width:100%;height:100%;position:absolute;inset:0}.image.is-2by1{aspect-ratio:2}.image.is-2by1 img,.image.is-2by1 .has-ratio{width:100%;height:100%;position:absolute;inset:0}.image.is-3by1{aspect-ratio:3}.image.is-3by1 img,.image.is-3by1 .has-ratio{width:100%;height:100%;position:absolute;inset:0}.image.is-4by5{aspect-ratio:4/5}.image.is-4by5 img,.image.is-4by5 .has-ratio{width:100%;height:100%;position:absolute;inset:0}.image.is-3by4{aspect-ratio:3/4}.image.is-3by4 img,.image.is-3by4 .has-ratio{width:100%;height:100%;position:absolute;inset:0}.image.is-2by3{aspect-ratio:2/3}.image.is-2by3 img,.image.is-2by3 .has-ratio{width:100%;height:100%;position:absolute;inset:0}.image.is-3by5{aspect-ratio:3/5}.image.is-3by5 img,.image.is-3by5 .has-ratio{width:100%;height:100%;position:absolute;inset:0}.image.is-9by16{aspect-ratio:9/16}.image.is-9by16 img,.image.is-9by16 .has-ratio{width:100%;height:100%;position:absolute;inset:0}.image.is-1by2{aspect-ratio:1/2}.image.is-1by2 img,.image.is-1by2 .has-ratio{width:100%;height:100%;position:absolute;inset:0}.image.is-1by3{aspect-ratio:1/3}.image.is-1by3 img,.image.is-1by3 .has-ratio{width:100%;height:100%;position:absolute;inset:0}.image.is-16x16{width:16px;height:16px}.image.is-24x24{width:24px;height:24px}.image.is-32x32{width:32px;height:32px}.image.is-48x48{width:48px;height:48px}.image.is-64x64{width:64px;height:64px}.image.is-96x96{width:96px;height:96px}.image.is-128x128{width:128px;height:128px}.loader{border:2px solid var(--bulma-border);border-radius:var(--bulma-radius-rounded);content:"";border-top-color:#0000;border-right-color:#0000;width:1em;height:1em;animation:.5s linear infinite spinAround;display:block;position:relative}.notification{--bulma-notification-h:var(--bulma-scheme-h);--bulma-notification-s:var(--bulma-scheme-s);--bulma-notification-background-l:var(--bulma-background-l);--bulma-notification-color-l:var(--bulma-text-strong-l);--bulma-notification-code-background-color:var(--bulma-scheme-main);--bulma-notification-radius:var(--bulma-radius);--bulma-notification-padding:1.375em 1.5em;background-color:hsl(var(--bulma-notification-h),var(--bulma-notification-s),var(--bulma-notification-background-l));border-radius:var(--bulma-notification-radius);color:hsl(var(--bulma-notification-h),var(--bulma-notification-s),var(--bulma-notification-color-l));padding:var(--bulma-notification-padding);position:relative}.notification a:not(.button):not(.dropdown-item){color:currentColor;text-decoration:underline}.notification strong{color:currentColor}.notification code,.notification pre{background:var(--bulma-notification-code-background-color)}.notification pre code{background:0 0}.notification>.delete{inset-inline-end:1rem;position:absolute;top:1rem}.notification .title,.notification .subtitle,.notification .content{color:currentColor}.notification.is-white{--bulma-notification-h:var(--bulma-white-h);--bulma-notification-s:var(--bulma-white-s);--bulma-notification-background-l:var(--bulma-white-l);--bulma-notification-color-l:var(--bulma-white-invert-l)}.notification.is-white.is-light{--bulma-notification-background-l:90%;--bulma-notification-color-l:var(--bulma-white-light-invert-l)}.notification.is-white.is-dark{--bulma-notification-background-l:20%;--bulma-notification-color-l:var(--bulma-white-dark-invert-l)}.notification.is-black{--bulma-notification-h:var(--bulma-black-h);--bulma-notification-s:var(--bulma-black-s);--bulma-notification-background-l:var(--bulma-black-l);--bulma-notification-color-l:var(--bulma-black-invert-l)}.notification.is-black.is-light{--bulma-notification-background-l:90%;--bulma-notification-color-l:var(--bulma-black-light-invert-l)}.notification.is-black.is-dark{--bulma-notification-background-l:20%;--bulma-notification-color-l:var(--bulma-black-dark-invert-l)}.notification.is-light{--bulma-notification-h:var(--bulma-light-h);--bulma-notification-s:var(--bulma-light-s);--bulma-notification-background-l:var(--bulma-light-l);--bulma-notification-color-l:var(--bulma-light-invert-l)}.notification.is-light.is-light{--bulma-notification-background-l:90%;--bulma-notification-color-l:var(--bulma-light-light-invert-l)}.notification.is-light.is-dark{--bulma-notification-background-l:20%;--bulma-notification-color-l:var(--bulma-light-dark-invert-l)}.notification.is-dark{--bulma-notification-h:var(--bulma-dark-h);--bulma-notification-s:var(--bulma-dark-s);--bulma-notification-background-l:var(--bulma-dark-l);--bulma-notification-color-l:var(--bulma-dark-invert-l)}.notification.is-dark.is-light{--bulma-notification-background-l:90%;--bulma-notification-color-l:var(--bulma-dark-light-invert-l)}.notification.is-dark.is-dark{--bulma-notification-background-l:20%;--bulma-notification-color-l:var(--bulma-dark-dark-invert-l)}.notification.is-text{--bulma-notification-h:var(--bulma-text-h);--bulma-notification-s:var(--bulma-text-s);--bulma-notification-background-l:var(--bulma-text-l);--bulma-notification-color-l:var(--bulma-text-invert-l)}.notification.is-text.is-light{--bulma-notification-background-l:90%;--bulma-notification-color-l:var(--bulma-text-light-invert-l)}.notification.is-text.is-dark{--bulma-notification-background-l:20%;--bulma-notification-color-l:var(--bulma-text-dark-invert-l)}.notification.is-primary{--bulma-notification-h:var(--bulma-primary-h);--bulma-notification-s:var(--bulma-primary-s);--bulma-notification-background-l:var(--bulma-primary-l);--bulma-notification-color-l:var(--bulma-primary-invert-l)}.notification.is-primary.is-light{--bulma-notification-background-l:90%;--bulma-notification-color-l:var(--bulma-primary-light-invert-l)}.notification.is-primary.is-dark{--bulma-notification-background-l:20%;--bulma-notification-color-l:var(--bulma-primary-dark-invert-l)}.notification.is-link{--bulma-notification-h:var(--bulma-link-h);--bulma-notification-s:var(--bulma-link-s);--bulma-notification-background-l:var(--bulma-link-l);--bulma-notification-color-l:var(--bulma-link-invert-l)}.notification.is-link.is-light{--bulma-notification-background-l:90%;--bulma-notification-color-l:var(--bulma-link-light-invert-l)}.notification.is-link.is-dark{--bulma-notification-background-l:20%;--bulma-notification-color-l:var(--bulma-link-dark-invert-l)}.notification.is-info{--bulma-notification-h:var(--bulma-info-h);--bulma-notification-s:var(--bulma-info-s);--bulma-notification-background-l:var(--bulma-info-l);--bulma-notification-color-l:var(--bulma-info-invert-l)}.notification.is-info.is-light{--bulma-notification-background-l:90%;--bulma-notification-color-l:var(--bulma-info-light-invert-l)}.notification.is-info.is-dark{--bulma-notification-background-l:20%;--bulma-notification-color-l:var(--bulma-info-dark-invert-l)}.notification.is-success{--bulma-notification-h:var(--bulma-success-h);--bulma-notification-s:var(--bulma-success-s);--bulma-notification-background-l:var(--bulma-success-l);--bulma-notification-color-l:var(--bulma-success-invert-l)}.notification.is-success.is-light{--bulma-notification-background-l:90%;--bulma-notification-color-l:var(--bulma-success-light-invert-l)}.notification.is-success.is-dark{--bulma-notification-background-l:20%;--bulma-notification-color-l:var(--bulma-success-dark-invert-l)}.notification.is-warning{--bulma-notification-h:var(--bulma-warning-h);--bulma-notification-s:var(--bulma-warning-s);--bulma-notification-background-l:var(--bulma-warning-l);--bulma-notification-color-l:var(--bulma-warning-invert-l)}.notification.is-warning.is-light{--bulma-notification-background-l:90%;--bulma-notification-color-l:var(--bulma-warning-light-invert-l)}.notification.is-warning.is-dark{--bulma-notification-background-l:20%;--bulma-notification-color-l:var(--bulma-warning-dark-invert-l)}.notification.is-danger{--bulma-notification-h:var(--bulma-danger-h);--bulma-notification-s:var(--bulma-danger-s);--bulma-notification-background-l:var(--bulma-danger-l);--bulma-notification-color-l:var(--bulma-danger-invert-l)}.notification.is-danger.is-light{--bulma-notification-background-l:90%;--bulma-notification-color-l:var(--bulma-danger-light-invert-l)}.notification.is-danger.is-dark{--bulma-notification-background-l:20%;--bulma-notification-color-l:var(--bulma-danger-dark-invert-l)}.progress{--bulma-progress-border-radius:var(--bulma-radius-rounded);--bulma-progress-bar-background-color:var(--bulma-border-weak);--bulma-progress-value-background-color:var(--bulma-text);--bulma-progress-indeterminate-duration:1.5s;appearance:none;border-radius:var(--bulma-progress-border-radius);height:var(--bulma-size-normal);border:none;width:100%;padding:0;display:block;overflow:hidden}.progress::-webkit-progress-bar{background-color:var(--bulma-progress-bar-background-color)}.progress::-webkit-progress-value{background-color:var(--bulma-progress-value-background-color)}.progress::-moz-progress-bar{background-color:var(--bulma-progress-value-background-color)}.progress::-ms-fill{background-color:var(--bulma-progress-value-background-color);border:none}.progress.is-white{--bulma-progress-value-background-color:var(--bulma-white)}.progress.is-black{--bulma-progress-value-background-color:var(--bulma-black)}.progress.is-light{--bulma-progress-value-background-color:var(--bulma-light)}.progress.is-dark{--bulma-progress-value-background-color:var(--bulma-dark)}.progress.is-text{--bulma-progress-value-background-color:var(--bulma-text)}.progress.is-primary{--bulma-progress-value-background-color:var(--bulma-primary)}.progress.is-link{--bulma-progress-value-background-color:var(--bulma-link)}.progress.is-info{--bulma-progress-value-background-color:var(--bulma-info)}.progress.is-success{--bulma-progress-value-background-color:var(--bulma-success)}.progress.is-warning{--bulma-progress-value-background-color:var(--bulma-warning)}.progress.is-danger{--bulma-progress-value-background-color:var(--bulma-danger)}.progress:indeterminate{animation-duration:var(--bulma-progress-indeterminate-duration);background-color:var(--bulma-progress-bar-background-color);background-image:linear-gradient(to right,var(--bulma-progress-value-background-color)30%,var(--bulma-progress-bar-background-color)30%);background-position:0 0;background-repeat:no-repeat;background-size:150% 150%;animation-name:moveIndeterminate;animation-timing-function:linear;animation-iteration-count:infinite}.progress:indeterminate::-webkit-progress-bar{background-color:#0000}.progress:indeterminate::-moz-progress-bar{background-color:#0000}.progress:indeterminate::-ms-fill{animation-name:none}.progress.is-small{height:var(--bulma-size-small)}.progress.is-medium{height:var(--bulma-size-medium)}.progress.is-large{height:var(--bulma-size-large)}@keyframes moveIndeterminate{0%{background-position:200% 0}to{background-position:-200% 0}}.table{--bulma-table-color:var(--bulma-text-strong);--bulma-table-background-color:var(--bulma-scheme-main);--bulma-table-cell-border-color:var(--bulma-border);--bulma-table-cell-border-style:solid;--bulma-table-cell-border-width:0 0 1px;--bulma-table-cell-padding:.5em .75em;--bulma-table-cell-heading-color:var(--bulma-text-strong);--bulma-table-cell-text-align:left;--bulma-table-head-cell-border-width:0 0 2px;--bulma-table-head-cell-color:var(--bulma-text-strong);--bulma-table-foot-cell-border-width:2px 0 0;--bulma-table-foot-cell-color:var(--bulma-text-strong);--bulma-table-head-background-color:transparent;--bulma-table-body-background-color:transparent;--bulma-table-foot-background-color:transparent;--bulma-table-row-hover-background-color:var(--bulma-scheme-main-bis);--bulma-table-row-active-background-color:var(--bulma-primary);--bulma-table-row-active-color:var(--bulma-primary-invert);--bulma-table-striped-row-even-background-color:var(--bulma-scheme-main-bis);--bulma-table-striped-row-even-hover-background-color:var(--bulma-scheme-main-ter);background-color:var(--bulma-table-background-color);color:var(--bulma-table-color)}.table td,.table th{background-color:var(--bulma-table-cell-background-color);border-color:var(--bulma-table-cell-border-color);border-style:var(--bulma-table-cell-border-style);border-width:var(--bulma-table-cell-border-width);color:var(--bulma-table-color);padding:var(--bulma-table-cell-padding);vertical-align:top}.table td.is-white,.table th.is-white{--bulma-table-color:var(--bulma-white-invert);--bulma-table-cell-heading-color:var(--bulma-white-invert);--bulma-table-cell-background-color:var(--bulma-white);--bulma-table-cell-border-color:var(--bulma-white)}.table td.is-black,.table th.is-black{--bulma-table-color:var(--bulma-black-invert);--bulma-table-cell-heading-color:var(--bulma-black-invert);--bulma-table-cell-background-color:var(--bulma-black);--bulma-table-cell-border-color:var(--bulma-black)}.table td.is-light,.table th.is-light{--bulma-table-color:var(--bulma-light-invert);--bulma-table-cell-heading-color:var(--bulma-light-invert);--bulma-table-cell-background-color:var(--bulma-light);--bulma-table-cell-border-color:var(--bulma-light)}.table td.is-dark,.table th.is-dark{--bulma-table-color:var(--bulma-dark-invert);--bulma-table-cell-heading-color:var(--bulma-dark-invert);--bulma-table-cell-background-color:var(--bulma-dark);--bulma-table-cell-border-color:var(--bulma-dark)}.table td.is-text,.table th.is-text{--bulma-table-color:var(--bulma-text-invert);--bulma-table-cell-heading-color:var(--bulma-text-invert);--bulma-table-cell-background-color:var(--bulma-text);--bulma-table-cell-border-color:var(--bulma-text)}.table td.is-primary,.table th.is-primary{--bulma-table-color:var(--bulma-primary-invert);--bulma-table-cell-heading-color:var(--bulma-primary-invert);--bulma-table-cell-background-color:var(--bulma-primary);--bulma-table-cell-border-color:var(--bulma-primary)}.table td.is-link,.table th.is-link{--bulma-table-color:var(--bulma-link-invert);--bulma-table-cell-heading-color:var(--bulma-link-invert);--bulma-table-cell-background-color:var(--bulma-link);--bulma-table-cell-border-color:var(--bulma-link)}.table td.is-info,.table th.is-info{--bulma-table-color:var(--bulma-info-invert);--bulma-table-cell-heading-color:var(--bulma-info-invert);--bulma-table-cell-background-color:var(--bulma-info);--bulma-table-cell-border-color:var(--bulma-info)}.table td.is-success,.table th.is-success{--bulma-table-color:var(--bulma-success-invert);--bulma-table-cell-heading-color:var(--bulma-success-invert);--bulma-table-cell-background-color:var(--bulma-success);--bulma-table-cell-border-color:var(--bulma-success)}.table td.is-warning,.table th.is-warning{--bulma-table-color:var(--bulma-warning-invert);--bulma-table-cell-heading-color:var(--bulma-warning-invert);--bulma-table-cell-background-color:var(--bulma-warning);--bulma-table-cell-border-color:var(--bulma-warning)}.table td.is-danger,.table th.is-danger{--bulma-table-color:var(--bulma-danger-invert);--bulma-table-cell-heading-color:var(--bulma-danger-invert);--bulma-table-cell-background-color:var(--bulma-danger);--bulma-table-cell-border-color:var(--bulma-danger)}.table td.is-narrow,.table th.is-narrow{white-space:nowrap;width:1%}.table td.is-selected,.table th.is-selected{background-color:var(--bulma-table-row-active-background-color);color:var(--bulma-table-row-active-color)}.table td.is-selected a,.table td.is-selected strong,.table th.is-selected a,.table th.is-selected strong{color:currentColor}.table td.is-vcentered,.table th.is-vcentered{vertical-align:middle}.table th{color:var(--bulma-table-cell-heading-color)}.table th:not([align]){text-align:var(--bulma-table-cell-text-align)}.table tr.is-selected{background-color:var(--bulma-table-row-active-background-color);color:var(--bulma-table-row-active-color)}.table tr.is-selected a,.table tr.is-selected strong{color:currentColor}.table tr.is-selected td,.table tr.is-selected th{border-color:var(--bulma-table-row-active-color);color:currentColor}.table tr.is-white{--bulma-table-color:var(--bulma-white-invert);--bulma-table-cell-heading-color:var(--bulma-white-invert);--bulma-table-cell-background-color:var(--bulma-white);--bulma-table-cell-border-color:var(--bulma-white)}.table tr.is-black{--bulma-table-color:var(--bulma-black-invert);--bulma-table-cell-heading-color:var(--bulma-black-invert);--bulma-table-cell-background-color:var(--bulma-black);--bulma-table-cell-border-color:var(--bulma-black)}.table tr.is-light{--bulma-table-color:var(--bulma-light-invert);--bulma-table-cell-heading-color:var(--bulma-light-invert);--bulma-table-cell-background-color:var(--bulma-light);--bulma-table-cell-border-color:var(--bulma-light)}.table tr.is-dark{--bulma-table-color:var(--bulma-dark-invert);--bulma-table-cell-heading-color:var(--bulma-dark-invert);--bulma-table-cell-background-color:var(--bulma-dark);--bulma-table-cell-border-color:var(--bulma-dark)}.table tr.is-text{--bulma-table-color:var(--bulma-text-invert);--bulma-table-cell-heading-color:var(--bulma-text-invert);--bulma-table-cell-background-color:var(--bulma-text);--bulma-table-cell-border-color:var(--bulma-text)}.table tr.is-primary{--bulma-table-color:var(--bulma-primary-invert);--bulma-table-cell-heading-color:var(--bulma-primary-invert);--bulma-table-cell-background-color:var(--bulma-primary);--bulma-table-cell-border-color:var(--bulma-primary)}.table tr.is-link{--bulma-table-color:var(--bulma-link-invert);--bulma-table-cell-heading-color:var(--bulma-link-invert);--bulma-table-cell-background-color:var(--bulma-link);--bulma-table-cell-border-color:var(--bulma-link)}.table tr.is-info{--bulma-table-color:var(--bulma-info-invert);--bulma-table-cell-heading-color:var(--bulma-info-invert);--bulma-table-cell-background-color:var(--bulma-info);--bulma-table-cell-border-color:var(--bulma-info)}.table tr.is-success{--bulma-table-color:var(--bulma-success-invert);--bulma-table-cell-heading-color:var(--bulma-success-invert);--bulma-table-cell-background-color:var(--bulma-success);--bulma-table-cell-border-color:var(--bulma-success)}.table tr.is-warning{--bulma-table-color:var(--bulma-warning-invert);--bulma-table-cell-heading-color:var(--bulma-warning-invert);--bulma-table-cell-background-color:var(--bulma-warning);--bulma-table-cell-border-color:var(--bulma-warning)}.table tr.is-danger{--bulma-table-color:var(--bulma-danger-invert);--bulma-table-cell-heading-color:var(--bulma-danger-invert);--bulma-table-cell-background-color:var(--bulma-danger);--bulma-table-cell-border-color:var(--bulma-danger)}.table thead{background-color:var(--bulma-table-head-background-color)}.table thead td,.table thead th{border-width:var(--bulma-table-head-cell-border-width);color:var(--bulma-table-head-cell-color)}.table tfoot{background-color:var(--bulma-table-foot-background-color)}.table tfoot td,.table tfoot th{border-width:var(--bulma-table-foot-cell-border-width);color:var(--bulma-table-foot-cell-color)}.table tbody{background-color:var(--bulma-table-body-background-color)}.table tbody tr:last-child td,.table tbody tr:last-child th{border-bottom-width:0}.table.is-bordered td,.table.is-bordered th{border-width:1px}.table.is-bordered tr:last-child td,.table.is-bordered tr:last-child th{border-bottom-width:1px}.table.is-fullwidth{width:100%}.table.is-hoverable tbody tr:not(.is-selected):hover,.table.is-hoverable.is-striped tbody tr:not(.is-selected):hover{background-color:var(--bulma-table-row-hover-background-color)}.table.is-hoverable.is-striped tbody tr:not(.is-selected):hover:nth-child(2n){background-color:var(--bulma-table-striped-row-even-hover-background-color)}.table.is-narrow td,.table.is-narrow th{padding:.25em .5em}.table.is-striped tbody tr:not(.is-selected):nth-child(2n){background-color:var(--bulma-table-striped-row-even-background-color)}.table-container{-webkit-overflow-scrolling:touch;max-width:100%;overflow:auto hidden}.tags{color:hsl(var(--bulma-tag-h),var(--bulma-tag-s),var(--bulma-tag-color-l));flex-wrap:wrap;justify-content:flex-start;align-items:center;gap:.5rem;display:flex}.tags.are-medium .tag:not(.is-normal):not(.is-large){font-size:var(--bulma-size-normal)}.tags.are-large .tag:not(.is-normal):not(.is-medium){font-size:var(--bulma-size-medium)}.tags.is-centered{justify-content:center;gap:.25rem}.tags.is-right{justify-content:flex-end}.tags.has-addons{gap:0}.tags.has-addons .tag:not(:first-child){border-start-start-radius:0;border-end-start-radius:0}.tags.has-addons .tag:not(:last-child){border-start-end-radius:0;border-end-end-radius:0}.tag{--bulma-tag-h:var(--bulma-scheme-h);--bulma-tag-s:var(--bulma-scheme-s);--bulma-tag-background-l:var(--bulma-background-l);--bulma-tag-background-l-delta:0%;--bulma-tag-hover-background-l-delta:var(--bulma-hover-background-l-delta);--bulma-tag-active-background-l-delta:var(--bulma-active-background-l-delta);--bulma-tag-color-l:var(--bulma-text-l);--bulma-tag-radius:var(--bulma-radius);--bulma-tag-delete-margin:1px;background-color:hsl(var(--bulma-tag-h),var(--bulma-tag-s),calc(var(--bulma-tag-background-l) + var(--bulma-tag-background-l-delta)));border-radius:var(--bulma-radius);color:hsl(var(--bulma-tag-h),var(--bulma-tag-s),var(--bulma-tag-color-l));font-size:var(--bulma-size-small);white-space:nowrap;justify-content:center;align-items:center;height:2em;padding-left:.75em;padding-right:.75em;line-height:1.5;display:inline-flex}.tag .delete{margin-inline:.25rem -.375rem}.tag.is-white{--bulma-tag-h:var(--bulma-white-h);--bulma-tag-s:var(--bulma-white-s);--bulma-tag-background-l:var(--bulma-white-l);--bulma-tag-color-l:var(--bulma-white-invert-l)}.tag.is-white.is-light{--bulma-tag-background-l:var(--bulma-light-l);--bulma-tag-color-l:var(--bulma-white-light-invert-l)}.tag.is-black{--bulma-tag-h:var(--bulma-black-h);--bulma-tag-s:var(--bulma-black-s);--bulma-tag-background-l:var(--bulma-black-l);--bulma-tag-color-l:var(--bulma-black-invert-l)}.tag.is-black.is-light{--bulma-tag-background-l:var(--bulma-light-l);--bulma-tag-color-l:var(--bulma-black-light-invert-l)}.tag.is-light{--bulma-tag-h:var(--bulma-light-h);--bulma-tag-s:var(--bulma-light-s);--bulma-tag-background-l:var(--bulma-light-l);--bulma-tag-color-l:var(--bulma-light-invert-l)}.tag.is-light.is-light{--bulma-tag-background-l:var(--bulma-light-l);--bulma-tag-color-l:var(--bulma-light-light-invert-l)}.tag.is-dark{--bulma-tag-h:var(--bulma-dark-h);--bulma-tag-s:var(--bulma-dark-s);--bulma-tag-background-l:var(--bulma-dark-l);--bulma-tag-color-l:var(--bulma-dark-invert-l)}.tag.is-dark.is-light{--bulma-tag-background-l:var(--bulma-light-l);--bulma-tag-color-l:var(--bulma-dark-light-invert-l)}.tag.is-text{--bulma-tag-h:var(--bulma-text-h);--bulma-tag-s:var(--bulma-text-s);--bulma-tag-background-l:var(--bulma-text-l);--bulma-tag-color-l:var(--bulma-text-invert-l)}.tag.is-text.is-light{--bulma-tag-background-l:var(--bulma-light-l);--bulma-tag-color-l:var(--bulma-text-light-invert-l)}.tag.is-primary{--bulma-tag-h:var(--bulma-primary-h);--bulma-tag-s:var(--bulma-primary-s);--bulma-tag-background-l:var(--bulma-primary-l);--bulma-tag-color-l:var(--bulma-primary-invert-l)}.tag.is-primary.is-light{--bulma-tag-background-l:var(--bulma-light-l);--bulma-tag-color-l:var(--bulma-primary-light-invert-l)}.tag.is-link{--bulma-tag-h:var(--bulma-link-h);--bulma-tag-s:var(--bulma-link-s);--bulma-tag-background-l:var(--bulma-link-l);--bulma-tag-color-l:var(--bulma-link-invert-l)}.tag.is-link.is-light{--bulma-tag-background-l:var(--bulma-light-l);--bulma-tag-color-l:var(--bulma-link-light-invert-l)}.tag.is-info{--bulma-tag-h:var(--bulma-info-h);--bulma-tag-s:var(--bulma-info-s);--bulma-tag-background-l:var(--bulma-info-l);--bulma-tag-color-l:var(--bulma-info-invert-l)}.tag.is-info.is-light{--bulma-tag-background-l:var(--bulma-light-l);--bulma-tag-color-l:var(--bulma-info-light-invert-l)}.tag.is-success{--bulma-tag-h:var(--bulma-success-h);--bulma-tag-s:var(--bulma-success-s);--bulma-tag-background-l:var(--bulma-success-l);--bulma-tag-color-l:var(--bulma-success-invert-l)}.tag.is-success.is-light{--bulma-tag-background-l:var(--bulma-light-l);--bulma-tag-color-l:var(--bulma-success-light-invert-l)}.tag.is-warning{--bulma-tag-h:var(--bulma-warning-h);--bulma-tag-s:var(--bulma-warning-s);--bulma-tag-background-l:var(--bulma-warning-l);--bulma-tag-color-l:var(--bulma-warning-invert-l)}.tag.is-warning.is-light{--bulma-tag-background-l:var(--bulma-light-l);--bulma-tag-color-l:var(--bulma-warning-light-invert-l)}.tag.is-danger{--bulma-tag-h:var(--bulma-danger-h);--bulma-tag-s:var(--bulma-danger-s);--bulma-tag-background-l:var(--bulma-danger-l);--bulma-tag-color-l:var(--bulma-danger-invert-l)}.tag.is-danger.is-light{--bulma-tag-background-l:var(--bulma-light-l);--bulma-tag-color-l:var(--bulma-danger-light-invert-l)}.tag.is-normal{font-size:var(--bulma-size-small)}.tag.is-medium{font-size:var(--bulma-size-normal)}.tag.is-large{font-size:var(--bulma-size-medium)}.tag .icon:first-child:not(:last-child){margin-inline:-.375em .1875em}.tag .icon:last-child:not(:first-child){margin-inline:.1875em -.375em}.tag .icon:first-child:last-child{margin-inline:-.375em}.tag.is-delete{width:2em;margin-inline-start:var(--bulma-tag-delete-margin);padding:0;position:relative}.tag.is-delete:before,.tag.is-delete:after{content:"";transform-origin:50%;background-color:currentColor;display:block;position:absolute;top:50%;left:50%;transform:translate(-50%)translateY(-50%)rotate(45deg)}.tag.is-delete:before{width:50%;height:1px}.tag.is-delete:after{width:1px;height:50%}.tag.is-rounded{border-radius:var(--bulma-radius-rounded)}a.tag,button.tag,.tag.is-hoverable{cursor:pointer}a.tag:hover,button.tag:hover,.tag.is-hoverable:hover{--bulma-tag-background-l-delta:var(--bulma-tag-hover-background-l-delta)}a.tag:active,button.tag:active,.tag.is-hoverable:active{--bulma-tag-background-l-delta:var(--bulma-tag-active-background-l-delta)}.title,.subtitle{--bulma-title-color:var(--bulma-text-strong);--bulma-title-family:false;--bulma-title-size:var(--bulma-size-3);--bulma-title-weight:var(--bulma-weight-extrabold);--bulma-title-line-height:1.125;--bulma-title-strong-color:inherit;--bulma-title-strong-weight:inherit;--bulma-title-sub-size:.75em;--bulma-title-sup-size:.75em;--bulma-subtitle-color:var(--bulma-text);--bulma-subtitle-family:false;--bulma-subtitle-size:var(--bulma-size-5);--bulma-subtitle-weight:var(--bulma-weight-normal);--bulma-subtitle-line-height:1.25;--bulma-subtitle-strong-color:var(--bulma-text-strong);--bulma-subtitle-strong-weight:var(--bulma-weight-semibold);word-break:break-word}.title em,.title span,.subtitle em,.subtitle span{font-weight:inherit}.title sub,.subtitle sub{font-size:var(--bulma-title-sub-size)}.title sup,.subtitle sup{font-size:var(--bulma-title-sup-size)}.title .tag,.subtitle .tag{vertical-align:middle}.title{color:var(--bulma-title-color);font-size:var(--bulma-title-size);font-weight:var(--bulma-title-weight);line-height:var(--bulma-title-line-height)}.title strong{color:var(--bulma-title-strong-color);font-weight:var(--bulma-title-strong-weight)}.title:not(.is-spaced):has(+.subtitle){margin-bottom:0}.title.is-1{font-size:3rem}.title.is-2{font-size:2.5rem}.title.is-3{font-size:2rem}.title.is-4{font-size:1.5rem}.title.is-5{font-size:1.25rem}.title.is-6{font-size:1rem}.title.is-7{font-size:.75rem}.subtitle{color:var(--bulma-subtitle-color);font-size:var(--bulma-subtitle-size);font-weight:var(--bulma-subtitle-weight);line-height:var(--bulma-subtitle-line-height)}.subtitle strong{color:var(--bulma-subtitle-strong-color);font-weight:var(--bulma-subtitle-strong-weight)}.subtitle:not(.is-spaced):has(+.title){margin-bottom:0}.subtitle.is-1{font-size:3rem}.subtitle.is-2{font-size:2.5rem}.subtitle.is-3{font-size:2rem}.subtitle.is-4{font-size:1.5rem}.subtitle.is-5{font-size:1.25rem}.subtitle.is-6{font-size:1rem}.subtitle.is-7{font-size:.75rem}.control,.input,.textarea,.select{--bulma-input-h:var(--bulma-scheme-h);--bulma-input-s:var(--bulma-scheme-s);--bulma-input-l:var(--bulma-scheme-main-l);--bulma-input-border-style:solid;--bulma-input-border-width:var(--bulma-control-border-width);--bulma-input-border-l:var(--bulma-border-l);--bulma-input-border-l-delta:0%;--bulma-input-hover-border-l-delta:var(--bulma-hover-border-l-delta);--bulma-input-active-border-l-delta:var(--bulma-active-border-l-delta);--bulma-input-focus-h:var(--bulma-focus-h);--bulma-input-focus-s:var(--bulma-focus-s);--bulma-input-focus-l:var(--bulma-focus-l);--bulma-input-focus-shadow-size:var(--bulma-focus-shadow-size);--bulma-input-focus-shadow-alpha:var(--bulma-focus-shadow-alpha);--bulma-input-color-l:var(--bulma-text-strong-l);--bulma-input-background-l:var(--bulma-scheme-main-l);--bulma-input-background-l-delta:0%;--bulma-input-height:var(--bulma-control-height);--bulma-input-shadow:inset 0 .0625em .125em hsla(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-scheme-invert-l),.05);--bulma-input-placeholder-color:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-strong-l),.3);--bulma-input-disabled-color:var(--bulma-text-weak);--bulma-input-disabled-background-color:var(--bulma-background);--bulma-input-disabled-border-color:var(--bulma-background);--bulma-input-disabled-placeholder-color:hsla(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-weak-l),.3);--bulma-input-arrow:var(--bulma-link);--bulma-input-icon-color:var(--bulma-text-light);--bulma-input-icon-hover-color:var(--bulma-text-weak);--bulma-input-icon-focus-color:var(--bulma-link);--bulma-input-radius:var(--bulma-radius)}.select select,.input,.textarea{background-color:hsl(var(--bulma-input-h),var(--bulma-input-s),calc(var(--bulma-input-background-l) + var(--bulma-input-background-l-delta)));border-color:hsl(var(--bulma-input-h),var(--bulma-input-s),calc(var(--bulma-input-border-l) + var(--bulma-input-border-l-delta)));border-radius:var(--bulma-input-radius);color:hsl(var(--bulma-input-h),var(--bulma-input-s),var(--bulma-input-color-l))}.select select::placeholder,.input::placeholder,.textarea::placeholder{color:var(--bulma-input-placeholder-color)}.select select::-moz-placeholder,.input::-moz-placeholder,.textarea::-moz-placeholder{color:var(--bulma-input-placeholder-color)}.select select:-moz-placeholder,.input:-moz-placeholder,.textarea:-moz-placeholder{color:var(--bulma-input-placeholder-color)}.select select:-ms-input-placeholder,.input:-ms-input-placeholder,.textarea:-ms-input-placeholder{color:var(--bulma-input-placeholder-color)}.select select:hover,.input:hover,.textarea:hover,.select select.is-hovered,.is-hovered.input,.is-hovered.textarea{--bulma-input-border-l-delta:var(--bulma-input-hover-border-l-delta)}.select select:active,.input:active,.textarea:active,.select select.is-active,.is-active.input,.is-active.textarea{--bulma-input-border-l-delta:var(--bulma-input-active-border-l-delta)}.select select:focus,.input:focus,.textarea:focus,.select select:focus-within,.input:focus-within,.textarea:focus-within,.select select.is-focused,.is-focused.input,.is-focused.textarea{border-color:hsl(var(--bulma-input-focus-h),var(--bulma-input-focus-s),var(--bulma-input-focus-l));box-shadow:var(--bulma-input-focus-shadow-size)hsla(var(--bulma-input-focus-h),var(--bulma-input-focus-s),var(--bulma-input-focus-l),var(--bulma-input-focus-shadow-alpha))}.select select[disabled],[disabled].input,[disabled].textarea,fieldset[disabled] .select select,.select fieldset[disabled] select,fieldset[disabled] .input,fieldset[disabled] .textarea{background-color:var(--bulma-input-disabled-background-color);border-color:var(--bulma-input-disabled-border-color);box-shadow:none;color:var(--bulma-input-disabled-color)}.select select[disabled]::placeholder,[disabled].input::placeholder,[disabled].textarea::placeholder,fieldset[disabled] .select select::placeholder,.select fieldset[disabled] select::placeholder,fieldset[disabled] .input::placeholder,fieldset[disabled] .textarea::placeholder{color:var(--bulma-input-disabled-placeholder-color)}.select select[disabled]::-moz-placeholder,[disabled].input::-moz-placeholder,[disabled].textarea::-moz-placeholder,fieldset[disabled] .select select::-moz-placeholder,.select fieldset[disabled] select::-moz-placeholder,fieldset[disabled] .input::-moz-placeholder,fieldset[disabled] .textarea::-moz-placeholder{color:var(--bulma-input-disabled-placeholder-color)}.select select[disabled]:-moz-placeholder,[disabled].input:-moz-placeholder,[disabled].textarea:-moz-placeholder,fieldset[disabled] .select select:-moz-placeholder,.select fieldset[disabled] select:-moz-placeholder,fieldset[disabled] .input:-moz-placeholder,fieldset[disabled] .textarea:-moz-placeholder{color:var(--bulma-input-disabled-placeholder-color)}.select select[disabled]:-ms-input-placeholder,[disabled].input:-ms-input-placeholder,[disabled].textarea:-ms-input-placeholder,fieldset[disabled] .select select:-ms-input-placeholder,.select fieldset[disabled] select:-ms-input-placeholder,fieldset[disabled] .input:-ms-input-placeholder,fieldset[disabled] .textarea:-ms-input-placeholder{color:var(--bulma-input-disabled-placeholder-color)}.textarea,.input{box-shadow:inset 0 .0625em .125em hsla(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-scheme-invert-l),.05);width:100%;max-width:100%}[readonly].textarea,[readonly].input{box-shadow:none}.is-white.textarea,.is-white.input{--bulma-input-h:var(--bulma-white-h);--bulma-input-s:var(--bulma-white-s);--bulma-input-l:var(--bulma-white-l);--bulma-input-focus-h:var(--bulma-white-h);--bulma-input-focus-s:var(--bulma-white-s);--bulma-input-focus-l:var(--bulma-white-l);--bulma-input-border-l:var(--bulma-white-l)}.is-black.textarea,.is-black.input{--bulma-input-h:var(--bulma-black-h);--bulma-input-s:var(--bulma-black-s);--bulma-input-l:var(--bulma-black-l);--bulma-input-focus-h:var(--bulma-black-h);--bulma-input-focus-s:var(--bulma-black-s);--bulma-input-focus-l:var(--bulma-black-l);--bulma-input-border-l:var(--bulma-black-l)}.is-light.textarea,.is-light.input{--bulma-input-h:var(--bulma-light-h);--bulma-input-s:var(--bulma-light-s);--bulma-input-l:var(--bulma-light-l);--bulma-input-focus-h:var(--bulma-light-h);--bulma-input-focus-s:var(--bulma-light-s);--bulma-input-focus-l:var(--bulma-light-l);--bulma-input-border-l:var(--bulma-light-l)}.is-dark.textarea,.is-dark.input{--bulma-input-h:var(--bulma-dark-h);--bulma-input-s:var(--bulma-dark-s);--bulma-input-l:var(--bulma-dark-l);--bulma-input-focus-h:var(--bulma-dark-h);--bulma-input-focus-s:var(--bulma-dark-s);--bulma-input-focus-l:var(--bulma-dark-l);--bulma-input-border-l:var(--bulma-dark-l)}.is-text.textarea,.is-text.input{--bulma-input-h:var(--bulma-text-h);--bulma-input-s:var(--bulma-text-s);--bulma-input-l:var(--bulma-text-l);--bulma-input-focus-h:var(--bulma-text-h);--bulma-input-focus-s:var(--bulma-text-s);--bulma-input-focus-l:var(--bulma-text-l);--bulma-input-border-l:var(--bulma-text-l)}.is-primary.textarea,.is-primary.input{--bulma-input-h:var(--bulma-primary-h);--bulma-input-s:var(--bulma-primary-s);--bulma-input-l:var(--bulma-primary-l);--bulma-input-focus-h:var(--bulma-primary-h);--bulma-input-focus-s:var(--bulma-primary-s);--bulma-input-focus-l:var(--bulma-primary-l);--bulma-input-border-l:var(--bulma-primary-l)}.is-link.textarea,.is-link.input{--bulma-input-h:var(--bulma-link-h);--bulma-input-s:var(--bulma-link-s);--bulma-input-l:var(--bulma-link-l);--bulma-input-focus-h:var(--bulma-link-h);--bulma-input-focus-s:var(--bulma-link-s);--bulma-input-focus-l:var(--bulma-link-l);--bulma-input-border-l:var(--bulma-link-l)}.is-info.textarea,.is-info.input{--bulma-input-h:var(--bulma-info-h);--bulma-input-s:var(--bulma-info-s);--bulma-input-l:var(--bulma-info-l);--bulma-input-focus-h:var(--bulma-info-h);--bulma-input-focus-s:var(--bulma-info-s);--bulma-input-focus-l:var(--bulma-info-l);--bulma-input-border-l:var(--bulma-info-l)}.is-success.textarea,.is-success.input{--bulma-input-h:var(--bulma-success-h);--bulma-input-s:var(--bulma-success-s);--bulma-input-l:var(--bulma-success-l);--bulma-input-focus-h:var(--bulma-success-h);--bulma-input-focus-s:var(--bulma-success-s);--bulma-input-focus-l:var(--bulma-success-l);--bulma-input-border-l:var(--bulma-success-l)}.is-warning.textarea,.is-warning.input{--bulma-input-h:var(--bulma-warning-h);--bulma-input-s:var(--bulma-warning-s);--bulma-input-l:var(--bulma-warning-l);--bulma-input-focus-h:var(--bulma-warning-h);--bulma-input-focus-s:var(--bulma-warning-s);--bulma-input-focus-l:var(--bulma-warning-l);--bulma-input-border-l:var(--bulma-warning-l)}.is-danger.textarea,.is-danger.input{--bulma-input-h:var(--bulma-danger-h);--bulma-input-s:var(--bulma-danger-s);--bulma-input-l:var(--bulma-danger-l);--bulma-input-focus-h:var(--bulma-danger-h);--bulma-input-focus-s:var(--bulma-danger-s);--bulma-input-focus-l:var(--bulma-danger-l);--bulma-input-border-l:var(--bulma-danger-l)}.is-small.textarea,.is-small.input{border-radius:var(--bulma-radius-small);font-size:var(--bulma-size-small)}.is-medium.textarea,.is-medium.input{font-size:var(--bulma-size-medium)}.is-large.textarea,.is-large.input{font-size:var(--bulma-size-large)}.is-fullwidth.textarea,.is-fullwidth.input{width:100%;display:block}.is-inline.textarea,.is-inline.input{width:auto;display:inline}.input.is-rounded{border-radius:var(--bulma-radius-rounded);padding-left:calc(1.125em - 1px);padding-right:calc(1.125em - 1px)}.input.is-static{box-shadow:none;background-color:#0000;border-color:#0000;padding-left:0;padding-right:0}.textarea{--bulma-textarea-padding:var(--bulma-control-padding-horizontal);--bulma-textarea-max-height:40em;--bulma-textarea-min-height:8em;padding:var(--bulma-textarea-padding);resize:vertical;min-width:100%;max-width:100%;display:block}.textarea:not([rows]){max-height:var(--bulma-textarea-max-height);min-height:var(--bulma-textarea-min-height)}.textarea[rows]{height:initial}.textarea.has-fixed-size{resize:none}.radio,.checkbox{cursor:pointer;line-height:1.25;display:inline-block;position:relative}.radio input,.checkbox input{cursor:pointer}[disabled].radio,[disabled].checkbox,fieldset[disabled] .radio,fieldset[disabled] .checkbox,.radio input[disabled],.checkbox input[disabled]{color:var(--bulma-text-weak);cursor:not-allowed}.checkboxes,.radios{flex-wrap:wrap;gap:.5em 1em;display:flex}.select{--bulma-input-h:var(--bulma-scheme-h);--bulma-input-s:var(--bulma-scheme-s);--bulma-input-border-style:solid;--bulma-input-border-width:1px;--bulma-input-border-l:var(--bulma-border-l);vertical-align:top;max-width:100%;display:inline-block;position:relative}.select:not(.is-multiple){height:var(--bulma-control-height)}.select:not(.is-multiple):not(.is-loading):after{z-index:4;inset-inline-end:1.125em}.select.is-rounded select{border-radius:var(--bulma-radius-rounded);padding-inline-start:1em}.select select{cursor:pointer;outline:none;max-width:100%;font-size:1em;display:block}.select select::-ms-expand{display:none}.select select[disabled]:hover,fieldset[disabled] .select select:hover{border-color:var(--bulma-background)}.select select:not([multiple]){padding-inline-end:2.5em}.select select[multiple]{height:auto;padding:0}.select select[multiple] option{padding:.5em 1em}.select.is-white{--bulma-input-h:var(--bulma-white-h);--bulma-input-s:var(--bulma-white-s);--bulma-input-l:var(--bulma-white-l);--bulma-input-focus-h:var(--bulma-white-h);--bulma-input-focus-s:var(--bulma-white-s);--bulma-input-focus-l:var(--bulma-white-l);--bulma-input-border-l:var(--bulma-white-l);--bulma-arrow-color:var(--bulma-white)}.select.is-black{--bulma-input-h:var(--bulma-black-h);--bulma-input-s:var(--bulma-black-s);--bulma-input-l:var(--bulma-black-l);--bulma-input-focus-h:var(--bulma-black-h);--bulma-input-focus-s:var(--bulma-black-s);--bulma-input-focus-l:var(--bulma-black-l);--bulma-input-border-l:var(--bulma-black-l);--bulma-arrow-color:var(--bulma-black)}.select.is-light{--bulma-input-h:var(--bulma-light-h);--bulma-input-s:var(--bulma-light-s);--bulma-input-l:var(--bulma-light-l);--bulma-input-focus-h:var(--bulma-light-h);--bulma-input-focus-s:var(--bulma-light-s);--bulma-input-focus-l:var(--bulma-light-l);--bulma-input-border-l:var(--bulma-light-l);--bulma-arrow-color:var(--bulma-light)}.select.is-dark{--bulma-input-h:var(--bulma-dark-h);--bulma-input-s:var(--bulma-dark-s);--bulma-input-l:var(--bulma-dark-l);--bulma-input-focus-h:var(--bulma-dark-h);--bulma-input-focus-s:var(--bulma-dark-s);--bulma-input-focus-l:var(--bulma-dark-l);--bulma-input-border-l:var(--bulma-dark-l);--bulma-arrow-color:var(--bulma-dark)}.select.is-text{--bulma-input-h:var(--bulma-text-h);--bulma-input-s:var(--bulma-text-s);--bulma-input-l:var(--bulma-text-l);--bulma-input-focus-h:var(--bulma-text-h);--bulma-input-focus-s:var(--bulma-text-s);--bulma-input-focus-l:var(--bulma-text-l);--bulma-input-border-l:var(--bulma-text-l);--bulma-arrow-color:var(--bulma-text)}.select.is-primary{--bulma-input-h:var(--bulma-primary-h);--bulma-input-s:var(--bulma-primary-s);--bulma-input-l:var(--bulma-primary-l);--bulma-input-focus-h:var(--bulma-primary-h);--bulma-input-focus-s:var(--bulma-primary-s);--bulma-input-focus-l:var(--bulma-primary-l);--bulma-input-border-l:var(--bulma-primary-l);--bulma-arrow-color:var(--bulma-primary)}.select.is-link{--bulma-input-h:var(--bulma-link-h);--bulma-input-s:var(--bulma-link-s);--bulma-input-l:var(--bulma-link-l);--bulma-input-focus-h:var(--bulma-link-h);--bulma-input-focus-s:var(--bulma-link-s);--bulma-input-focus-l:var(--bulma-link-l);--bulma-input-border-l:var(--bulma-link-l);--bulma-arrow-color:var(--bulma-link)}.select.is-info{--bulma-input-h:var(--bulma-info-h);--bulma-input-s:var(--bulma-info-s);--bulma-input-l:var(--bulma-info-l);--bulma-input-focus-h:var(--bulma-info-h);--bulma-input-focus-s:var(--bulma-info-s);--bulma-input-focus-l:var(--bulma-info-l);--bulma-input-border-l:var(--bulma-info-l);--bulma-arrow-color:var(--bulma-info)}.select.is-success{--bulma-input-h:var(--bulma-success-h);--bulma-input-s:var(--bulma-success-s);--bulma-input-l:var(--bulma-success-l);--bulma-input-focus-h:var(--bulma-success-h);--bulma-input-focus-s:var(--bulma-success-s);--bulma-input-focus-l:var(--bulma-success-l);--bulma-input-border-l:var(--bulma-success-l);--bulma-arrow-color:var(--bulma-success)}.select.is-warning{--bulma-input-h:var(--bulma-warning-h);--bulma-input-s:var(--bulma-warning-s);--bulma-input-l:var(--bulma-warning-l);--bulma-input-focus-h:var(--bulma-warning-h);--bulma-input-focus-s:var(--bulma-warning-s);--bulma-input-focus-l:var(--bulma-warning-l);--bulma-input-border-l:var(--bulma-warning-l);--bulma-arrow-color:var(--bulma-warning)}.select.is-danger{--bulma-input-h:var(--bulma-danger-h);--bulma-input-s:var(--bulma-danger-s);--bulma-input-l:var(--bulma-danger-l);--bulma-input-focus-h:var(--bulma-danger-h);--bulma-input-focus-s:var(--bulma-danger-s);--bulma-input-focus-l:var(--bulma-danger-l);--bulma-input-border-l:var(--bulma-danger-l);--bulma-arrow-color:var(--bulma-danger)}.select.is-small{border-radius:var(--bulma-radius-small);font-size:var(--bulma-size-small)}.select.is-medium{font-size:var(--bulma-size-medium)}.select.is-large{font-size:var(--bulma-size-large)}.select.is-disabled:after{opacity:.5;border-color:var(--bulma-text-weak)!important}.select.is-fullwidth,.select.is-fullwidth select{width:100%}.select.is-loading:after{inset-inline-end:.625em;margin-top:0;position:absolute;top:.625em;transform:none}.select.is-loading.is-small:after{font-size:var(--bulma-size-small)}.select.is-loading.is-medium:after{font-size:var(--bulma-size-medium)}.select.is-loading.is-large:after{font-size:var(--bulma-size-large)}.file{--bulma-file-radius:var(--bulma-radius);--bulma-file-name-border-color:var(--bulma-border);--bulma-file-name-border-style:solid;--bulma-file-name-border-width:1px 1px 1px 0;--bulma-file-name-max-width:16em;--bulma-file-h:var(--bulma-scheme-h);--bulma-file-s:var(--bulma-scheme-s);--bulma-file-background-l:var(--bulma-scheme-main-ter-l);--bulma-file-background-l-delta:0%;--bulma-file-hover-background-l-delta:-5%;--bulma-file-active-background-l-delta:-10%;--bulma-file-border-l:var(--bulma-border-l);--bulma-file-border-l-delta:0%;--bulma-file-hover-border-l-delta:-10%;--bulma-file-active-border-l-delta:-20%;--bulma-file-cta-color-l:var(--bulma-text-strong-l);--bulma-file-name-color-l:var(--bulma-text-strong-l);--bulma-file-color-l-delta:0%;--bulma-file-hover-color-l-delta:-5%;--bulma-file-active-color-l-delta:-10%;justify-content:flex-start;align-items:stretch;display:flex;position:relative}.file.is-white{--bulma-file-h:var(--bulma-white-h);--bulma-file-s:var(--bulma-white-s);--bulma-file-background-l:var(--bulma-white-l);--bulma-file-border-l:var(--bulma-white-l);--bulma-file-cta-color-l:var(--bulma-white-invert-l);--bulma-file-name-color-l:var(--bulma-white-on-scheme-l)}.file.is-black{--bulma-file-h:var(--bulma-black-h);--bulma-file-s:var(--bulma-black-s);--bulma-file-background-l:var(--bulma-black-l);--bulma-file-border-l:var(--bulma-black-l);--bulma-file-cta-color-l:var(--bulma-black-invert-l);--bulma-file-name-color-l:var(--bulma-black-on-scheme-l)}.file.is-light{--bulma-file-h:var(--bulma-light-h);--bulma-file-s:var(--bulma-light-s);--bulma-file-background-l:var(--bulma-light-l);--bulma-file-border-l:var(--bulma-light-l);--bulma-file-cta-color-l:var(--bulma-light-invert-l);--bulma-file-name-color-l:var(--bulma-light-on-scheme-l)}.file.is-dark{--bulma-file-h:var(--bulma-dark-h);--bulma-file-s:var(--bulma-dark-s);--bulma-file-background-l:var(--bulma-dark-l);--bulma-file-border-l:var(--bulma-dark-l);--bulma-file-cta-color-l:var(--bulma-dark-invert-l);--bulma-file-name-color-l:var(--bulma-dark-on-scheme-l)}.file.is-text{--bulma-file-h:var(--bulma-text-h);--bulma-file-s:var(--bulma-text-s);--bulma-file-background-l:var(--bulma-text-l);--bulma-file-border-l:var(--bulma-text-l);--bulma-file-cta-color-l:var(--bulma-text-invert-l);--bulma-file-name-color-l:var(--bulma-text-on-scheme-l)}.file.is-primary{--bulma-file-h:var(--bulma-primary-h);--bulma-file-s:var(--bulma-primary-s);--bulma-file-background-l:var(--bulma-primary-l);--bulma-file-border-l:var(--bulma-primary-l);--bulma-file-cta-color-l:var(--bulma-primary-invert-l);--bulma-file-name-color-l:var(--bulma-primary-on-scheme-l)}.file.is-link{--bulma-file-h:var(--bulma-link-h);--bulma-file-s:var(--bulma-link-s);--bulma-file-background-l:var(--bulma-link-l);--bulma-file-border-l:var(--bulma-link-l);--bulma-file-cta-color-l:var(--bulma-link-invert-l);--bulma-file-name-color-l:var(--bulma-link-on-scheme-l)}.file.is-info{--bulma-file-h:var(--bulma-info-h);--bulma-file-s:var(--bulma-info-s);--bulma-file-background-l:var(--bulma-info-l);--bulma-file-border-l:var(--bulma-info-l);--bulma-file-cta-color-l:var(--bulma-info-invert-l);--bulma-file-name-color-l:var(--bulma-info-on-scheme-l)}.file.is-success{--bulma-file-h:var(--bulma-success-h);--bulma-file-s:var(--bulma-success-s);--bulma-file-background-l:var(--bulma-success-l);--bulma-file-border-l:var(--bulma-success-l);--bulma-file-cta-color-l:var(--bulma-success-invert-l);--bulma-file-name-color-l:var(--bulma-success-on-scheme-l)}.file.is-warning{--bulma-file-h:var(--bulma-warning-h);--bulma-file-s:var(--bulma-warning-s);--bulma-file-background-l:var(--bulma-warning-l);--bulma-file-border-l:var(--bulma-warning-l);--bulma-file-cta-color-l:var(--bulma-warning-invert-l);--bulma-file-name-color-l:var(--bulma-warning-on-scheme-l)}.file.is-danger{--bulma-file-h:var(--bulma-danger-h);--bulma-file-s:var(--bulma-danger-s);--bulma-file-background-l:var(--bulma-danger-l);--bulma-file-border-l:var(--bulma-danger-l);--bulma-file-cta-color-l:var(--bulma-danger-invert-l);--bulma-file-name-color-l:var(--bulma-danger-on-scheme-l)}.file.is-small{font-size:var(--bulma-size-small)}.file.is-normal{font-size:var(--bulma-size-normal)}.file.is-medium{font-size:var(--bulma-size-medium)}.file.is-medium .file-icon .fa{font-size:1.5rem}.file.is-large{font-size:var(--bulma-size-large)}.file.is-large .file-icon .fa{font-size:2rem}.file.has-name .file-cta{border-start-end-radius:0;border-end-end-radius:0}.file.has-name .file-name{border-start-start-radius:0;border-end-start-radius:0}.file.has-name.is-empty .file-cta{border-radius:var(--bulma-file-radius)}.file.has-name.is-empty .file-name{display:none}.file.is-boxed .file-label{flex-direction:column}.file.is-boxed .file-cta{flex-direction:column;height:auto;padding:1em 3em}.file.is-boxed .file-name{border-width:0 1px 1px}.file.is-boxed .file-icon{width:1.5em;height:1.5em}.file.is-boxed .file-icon .fa{font-size:1.5rem}.file.is-boxed.is-small .file-icon .fa{font-size:1rem}.file.is-boxed.is-medium .file-icon .fa{font-size:2rem}.file.is-boxed.is-large .file-icon .fa{font-size:2.5rem}.file.is-boxed.has-name .file-cta{border-start-start-radius:var(--bulma-file-radius);border-start-end-radius:var(--bulma-file-radius);border-end-end-radius:0;border-end-start-radius:0}.file.is-boxed.has-name .file-name{border-width:0 1px 1px;border-start-start-radius:0;border-start-end-radius:0;border-end-end-radius:var(--bulma-file-radius);border-end-start-radius:var(--bulma-file-radius)}.file.is-centered{justify-content:center}.file.is-fullwidth .file-label{width:100%}.file.is-fullwidth .file-name{flex-grow:1;max-width:none}.file.is-right{justify-content:flex-end}.file.is-right .file-cta{border-radius:0 var(--bulma-file-radius)var(--bulma-file-radius)0}.file.is-right .file-name{border-radius:var(--bulma-file-radius)0 0 var(--bulma-file-radius);border-width:1px 0 1px 1px;order:-1}.file-label{cursor:pointer;justify-content:flex-start;align-items:stretch;display:flex;position:relative;overflow:hidden}.file-label:hover{--bulma-file-background-l-delta:var(--bulma-file-hover-background-l-delta);--bulma-file-border-l-delta:var(--bulma-file-hover-border-l-delta);--bulma-file-color-l-delta:var(--bulma-file-hover-color-l-delta)}.file-label:active{--bulma-file-background-l-delta:var(--bulma-file-active-background-l-delta);--bulma-file-border-l-delta:var(--bulma-file-active-border-l-delta);--bulma-file-color-l-delta:var(--bulma-file-active-color-l-delta)}.file-input{opacity:0;outline:none;width:100%;height:100%;position:absolute;top:0;left:0}.file-cta,.file-name{border-color:hsl(var(--bulma-file-h),var(--bulma-file-s),calc(var(--bulma-file-border-l) + var(--bulma-file-border-l-delta)));border-radius:var(--bulma-file-radius);white-space:nowrap;padding-left:1em;padding-right:1em;font-size:1em}.file-cta{background-color:hsl(var(--bulma-file-h),var(--bulma-file-s),calc(var(--bulma-file-background-l) + var(--bulma-file-background-l-delta)));color:hsl(var(--bulma-file-h),var(--bulma-file-s),calc(var(--bulma-file-cta-color-l) + var(--bulma-file-color-l-delta)))}.file-name{border-color:hsl(var(--bulma-file-h),var(--bulma-file-s),calc(var(--bulma-file-border-l) + var(--bulma-file-color-l-delta)));border-style:var(--bulma-file-name-border-style);border-width:var(--bulma-file-name-border-width);color:hsl(var(--bulma-file-h),var(--bulma-file-s),calc(var(--bulma-file-name-color-l) + var(--bulma-file-color-l-delta)));max-width:var(--bulma-file-name-max-width);text-align:inherit;text-overflow:ellipsis;display:block;overflow:hidden}.file-icon{justify-content:center;align-items:center;width:1em;height:1em;margin-inline-end:.5em;display:flex}.file-icon .fa{font-size:1rem}:root{--bulma-label-color:var(--bulma-text-strong);--bulma-label-spacing:.5em;--bulma-label-weight:var(--bulma-weight-semibold);--bulma-help-size:var(--bulma-size-small);--bulma-field-block-spacing:.75rem}.label{color:var(--bulma-label-color);font-size:var(--bulma-size-normal);font-weight:var(--bulma-weight-semibold);display:block}.label:not(:last-child){margin-bottom:var(--bulma-label-spacing)}.label.is-small{font-size:var(--bulma-size-small)}.label.is-medium{font-size:var(--bulma-size-medium)}.label.is-large{font-size:var(--bulma-size-large)}.help{font-size:var(--bulma-help-size);margin-top:.25rem;display:block}.help.is-white{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-on-scheme-l))}.help.is-black{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-on-scheme-l))}.help.is-light{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-on-scheme-l))}.help.is-dark{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-on-scheme-l))}.help.is-text{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-on-scheme-l))}.help.is-primary{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-on-scheme-l))}.help.is-link{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-on-scheme-l))}.help.is-info{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-on-scheme-l))}.help.is-success{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-on-scheme-l))}.help.is-warning{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-on-scheme-l))}.help.is-danger{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-on-scheme-l))}.field{--bulma-block-spacing:var(--bulma-field-block-spacing)}.field.has-addons{justify-content:flex-start;display:flex}.field.has-addons .control:not(:last-child){margin-inline-end:-1px}.field.has-addons .control:not(:first-child):not(:last-child) .button,.field.has-addons .control:not(:first-child):not(:last-child) .input,.field.has-addons .control:not(:first-child):not(:last-child) .select select{border-radius:0}.field.has-addons .control:first-child:not(:only-child) .button,.field.has-addons .control:first-child:not(:only-child) .input,.field.has-addons .control:first-child:not(:only-child) .select select{border-start-end-radius:0;border-end-end-radius:0}.field.has-addons .control:last-child:not(:only-child) .button,.field.has-addons .control:last-child:not(:only-child) .input,.field.has-addons .control:last-child:not(:only-child) .select select{border-start-start-radius:0;border-end-start-radius:0}.field.has-addons .control .button:not([disabled]):hover,.field.has-addons .control .button:not([disabled]).is-hovered,.field.has-addons .control .input:not([disabled]):hover,.field.has-addons .control .input:not([disabled]).is-hovered,.field.has-addons .control .select select:not([disabled]):hover,.field.has-addons .control .select select:not([disabled]).is-hovered{z-index:2}.field.has-addons .control .button:not([disabled]):focus,.field.has-addons .control .button:not([disabled]).is-focused,.field.has-addons .control .button:not([disabled]):active,.field.has-addons .control .button:not([disabled]).is-active,.field.has-addons .control .input:not([disabled]):focus,.field.has-addons .control .input:not([disabled]).is-focused,.field.has-addons .control .input:not([disabled]):active,.field.has-addons .control .input:not([disabled]).is-active,.field.has-addons .control .select select:not([disabled]):focus,.field.has-addons .control .select select:not([disabled]).is-focused,.field.has-addons .control .select select:not([disabled]):active,.field.has-addons .control .select select:not([disabled]).is-active{z-index:3}.field.has-addons .control .button:not([disabled]):focus:hover,.field.has-addons .control .button:not([disabled]).is-focused:hover,.field.has-addons .control .button:not([disabled]):active:hover,.field.has-addons .control .button:not([disabled]).is-active:hover,.field.has-addons .control .input:not([disabled]):focus:hover,.field.has-addons .control .input:not([disabled]).is-focused:hover,.field.has-addons .control .input:not([disabled]):active:hover,.field.has-addons .control .input:not([disabled]).is-active:hover,.field.has-addons .control .select select:not([disabled]):focus:hover,.field.has-addons .control .select select:not([disabled]).is-focused:hover,.field.has-addons .control .select select:not([disabled]):active:hover,.field.has-addons .control .select select:not([disabled]).is-active:hover{z-index:4}.field.has-addons .control.is-expanded{flex-grow:1;flex-shrink:1}.field.has-addons.has-addons-centered{justify-content:center}.field.has-addons.has-addons-right{justify-content:flex-end}.field.has-addons.has-addons-fullwidth .control{flex-grow:1;flex-shrink:0}.field.is-grouped{justify-content:flex-start;gap:.75rem;display:flex}.field.is-grouped>.control{flex-shrink:0}.field.is-grouped>.control.is-expanded{flex-grow:1;flex-shrink:1}.field.is-grouped.is-grouped-centered{justify-content:center}.field.is-grouped.is-grouped-right{justify-content:flex-end}.field.is-grouped.is-grouped-multiline{flex-wrap:wrap}@media screen and (width>=769px),print{.field.is-horizontal{display:flex}}.field-label .label{font-size:inherit}@media screen and (width<=768px){.field-label{margin-bottom:.5rem}}@media screen and (width>=769px),print{.field-label{text-align:right;flex:1 0 0;margin-inline-end:1.5rem}.field-label.is-small{font-size:var(--bulma-size-small);padding-top:.375em}.field-label.is-normal{padding-top:.375em}.field-label.is-medium{font-size:var(--bulma-size-medium);padding-top:.375em}.field-label.is-large{font-size:var(--bulma-size-large);padding-top:.375em}}.field-body .field .field{margin-bottom:0}@media screen and (width>=769px),print{.field-body{flex:5 1 0;display:flex}.field-body .field{margin-bottom:0}.field-body>.field{flex-shrink:1}.field-body>.field:not(.is-narrow){flex-grow:1}.field-body>.field:not(:last-child){margin-inline-end:.75rem}}.control{box-sizing:border-box;clear:both;font-size:var(--bulma-size-normal);text-align:inherit;position:relative}.control.has-icons-left .input:hover~.icon,.control.has-icons-left .select:hover~.icon,.control.has-icons-right .input:hover~.icon,.control.has-icons-right .select:hover~.icon{color:var(--bulma-input-icon-hover-color)}.control.has-icons-left .input:focus~.icon,.control.has-icons-left .select:focus~.icon,.control.has-icons-right .input:focus~.icon,.control.has-icons-right .select:focus~.icon{color:var(--bulma-input-icon-focus-color)}.control.has-icons-left .input.is-small~.icon,.control.has-icons-left .select.is-small~.icon,.control.has-icons-right .input.is-small~.icon,.control.has-icons-right .select.is-small~.icon{font-size:var(--bulma-size-small)}.control.has-icons-left .input.is-medium~.icon,.control.has-icons-left .select.is-medium~.icon,.control.has-icons-right .input.is-medium~.icon,.control.has-icons-right .select.is-medium~.icon{font-size:var(--bulma-size-medium)}.control.has-icons-left .input.is-large~.icon,.control.has-icons-left .select.is-large~.icon,.control.has-icons-right .input.is-large~.icon,.control.has-icons-right .select.is-large~.icon{font-size:var(--bulma-size-large)}.control.has-icons-left .icon,.control.has-icons-right .icon{color:var(--bulma-input-icon-color);height:var(--bulma-input-height);pointer-events:none;width:var(--bulma-input-height);z-index:4;position:absolute;top:0}.control.has-icons-left .input,.control.has-icons-left .select select{padding-left:var(--bulma-input-height)}.control.has-icons-left .icon.is-left{left:0}.control.has-icons-right .input,.control.has-icons-right .select select{padding-right:var(--bulma-input-height)}.control.has-icons-right .icon.is-right{right:0}.control.is-loading:after{inset-inline-end:.75em;z-index:4;top:.75em;position:absolute!important}.control.is-loading.is-small:after{font-size:var(--bulma-size-small)}.control.is-loading.is-medium:after{font-size:var(--bulma-size-medium)}.control.is-loading.is-large:after{font-size:var(--bulma-size-large)}.breadcrumb{--bulma-breadcrumb-item-color:var(--bulma-link-text);--bulma-breadcrumb-item-hover-color:var(--bulma-link-text-hover);--bulma-breadcrumb-item-active-color:var(--bulma-link-text-active);--bulma-breadcrumb-item-padding-vertical:0;--bulma-breadcrumb-item-padding-horizontal:.75em;--bulma-breadcrumb-item-separator-color:var(--bulma-border);font-size:var(--bulma-size-normal);white-space:nowrap}.breadcrumb a{color:var(--bulma-breadcrumb-item-color);padding:var(--bulma-breadcrumb-item-padding-vertical)var(--bulma-breadcrumb-item-padding-horizontal);justify-content:center;align-items:center;display:flex}.breadcrumb a:hover{color:var(--bulma-breadcrumb-item-hover-color)}.breadcrumb li{align-items:center;display:flex}.breadcrumb li:first-child a{padding-inline-start:0}.breadcrumb li.is-active a{color:var(--bulma-breadcrumb-item-active-color);cursor:default;pointer-events:none}.breadcrumb li+li:before{color:var(--bulma-breadcrumb-item-separator-color);content:"/"}.breadcrumb ul,.breadcrumb ol{flex-wrap:wrap;justify-content:flex-start;align-items:flex-start;display:flex}.breadcrumb .icon:first-child{margin-inline-end:.5em}.breadcrumb .icon:last-child{margin-inline-start:.5em}.breadcrumb.is-centered ol,.breadcrumb.is-centered ul{justify-content:center}.breadcrumb.is-right ol,.breadcrumb.is-right ul{justify-content:flex-end}.breadcrumb.is-small{font-size:var(--bulma-size-small)}.breadcrumb.is-medium{font-size:var(--bulma-size-medium)}.breadcrumb.is-large{font-size:var(--bulma-size-large)}.breadcrumb.has-arrow-separator li+li:before{content:"→"}.breadcrumb.has-bullet-separator li+li:before{content:"•"}.breadcrumb.has-dot-separator li+li:before{content:"·"}.breadcrumb.has-succeeds-separator li+li:before{content:"≻"}.card{--bulma-card-color:var(--bulma-text);--bulma-card-background-color:var(--bulma-scheme-main);--bulma-card-shadow:var(--bulma-shadow);--bulma-card-radius:.75rem;--bulma-card-header-background-color:transparent;--bulma-card-header-color:var(--bulma-text-strong);--bulma-card-header-padding:.75rem 1rem;--bulma-card-header-shadow:0 .125em .25em hsla(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-scheme-invert-l),.1);--bulma-card-header-weight:var(--bulma-weight-bold);--bulma-card-content-background-color:transparent;--bulma-card-content-padding:1.5rem;--bulma-card-footer-background-color:transparent;--bulma-card-footer-border-top:1px solid var(--bulma-border-weak);--bulma-card-footer-padding:.75rem;--bulma-card-media-margin:var(--bulma-block-spacing);background-color:var(--bulma-card-background-color);border-radius:var(--bulma-card-radius);box-shadow:var(--bulma-card-shadow);color:var(--bulma-card-color);max-width:100%;position:relative}.card-footer:first-child,.card-content:first-child,.card-header:first-child{border-start-start-radius:var(--bulma-card-radius);border-start-end-radius:var(--bulma-card-radius)}.card-footer:last-child,.card-content:last-child,.card-header:last-child{border-end-end-radius:var(--bulma-card-radius);border-end-start-radius:var(--bulma-card-radius)}.card-header{background-color:var(--bulma-card-header-background-color);box-shadow:var(--bulma-card-header-shadow);align-items:stretch;display:flex}.card-header-title{color:var(--bulma-card-header-color);font-weight:var(--bulma-card-header-weight);padding:var(--bulma-card-header-padding);flex-grow:1;align-items:center;display:flex}.card-header-title.is-centered{justify-content:center}.card-header-icon{appearance:none;color:inherit;cursor:pointer;padding:0;padding:var(--bulma-card-header-padding);background:0 0;border:none;justify-content:center;align-items:center;margin:0;font-family:inherit;font-size:1em;display:flex}.card-image{display:block;position:relative}.card-image:first-child img{border-start-start-radius:var(--bulma-card-radius);border-start-end-radius:var(--bulma-card-radius)}.card-image:last-child img{border-end-end-radius:var(--bulma-card-radius);border-end-start-radius:var(--bulma-card-radius)}.card-content{background-color:var(--bulma-card-content-background-color);padding:var(--bulma-card-content-padding)}.card-footer{background-color:var(--bulma-card-footer-background-color);border-top:var(--bulma-card-footer-border-top);align-items:stretch;display:flex}.card-footer-item{padding:var(--bulma-card-footer-padding);flex:1 0 0;justify-content:center;align-items:center;display:flex}.card-footer-item:not(:last-child){border-inline-end:var(--bulma-card-footer-border-top)}.card .media:not(:last-child){margin-bottom:var(--bulma-card-media-margin)}.dropdown{--bulma-dropdown-menu-min-width:12rem;--bulma-dropdown-content-background-color:var(--bulma-scheme-main);--bulma-dropdown-content-offset:.25rem;--bulma-dropdown-content-padding-bottom:.5rem;--bulma-dropdown-content-padding-top:.5rem;--bulma-dropdown-content-radius:var(--bulma-radius);--bulma-dropdown-content-shadow:var(--bulma-shadow);--bulma-dropdown-content-z:20;--bulma-dropdown-item-h:var(--bulma-scheme-h);--bulma-dropdown-item-s:var(--bulma-scheme-s);--bulma-dropdown-item-l:var(--bulma-scheme-main-l);--bulma-dropdown-item-background-l:var(--bulma-scheme-main-l);--bulma-dropdown-item-background-l-delta:0%;--bulma-dropdown-item-hover-background-l-delta:var(--bulma-hover-background-l-delta);--bulma-dropdown-item-active-background-l-delta:var(--bulma-active-background-l-delta);--bulma-dropdown-item-color-l:var(--bulma-text-strong-l);--bulma-dropdown-item-selected-h:var(--bulma-link-h);--bulma-dropdown-item-selected-s:var(--bulma-link-s);--bulma-dropdown-item-selected-l:var(--bulma-link-l);--bulma-dropdown-item-selected-background-l:var(--bulma-link-l);--bulma-dropdown-item-selected-color-l:var(--bulma-link-invert-l);--bulma-dropdown-divider-background-color:var(--bulma-border-weak);vertical-align:top;display:inline-flex;position:relative}.dropdown.is-active .dropdown-menu,.dropdown.is-hoverable:hover .dropdown-menu{display:block}.dropdown.is-right .dropdown-menu{left:auto;right:0}.dropdown.is-up .dropdown-menu{padding-bottom:var(--bulma-dropdown-content-offset);padding-top:initial;top:auto;bottom:100%}.dropdown-menu{min-width:var(--bulma-dropdown-menu-min-width);padding-top:var(--bulma-dropdown-content-offset);z-index:var(--bulma-dropdown-content-z);display:none;position:absolute;top:100%;left:0}.dropdown-content{background-color:var(--bulma-dropdown-content-background-color);border-radius:var(--bulma-dropdown-content-radius);box-shadow:var(--bulma-dropdown-content-shadow);padding-bottom:var(--bulma-dropdown-content-padding-bottom);padding-top:var(--bulma-dropdown-content-padding-top)}.dropdown-item{color:hsl(var(--bulma-dropdown-item-h),var(--bulma-dropdown-item-s),var(--bulma-dropdown-item-color-l));padding:.375rem 1rem;font-size:.875rem;line-height:1.5;display:block}a.dropdown-item,button.dropdown-item{background-color:hsl(var(--bulma-dropdown-item-h),var(--bulma-dropdown-item-s),calc(var(--bulma-dropdown-item-background-l) + var(--bulma-dropdown-item-background-l-delta)));text-align:inherit;white-space:nowrap;width:100%;padding-inline-end:3rem}a.dropdown-item:hover,button.dropdown-item:hover{--bulma-dropdown-item-background-l-delta:var(--bulma-dropdown-item-hover-background-l-delta);--bulma-dropdown-item-border-l-delta:var(--bulma-dropdown-item-hover-border-l-delta)}a.dropdown-item:active,button.dropdown-item:active{--bulma-dropdown-item-background-l-delta:var(--bulma-dropdown-item-active-background-l-delta);--bulma-dropdown-item-border-l-delta:var(--bulma-dropdown-item-active-border-l-delta)}a.dropdown-item.is-active,a.dropdown-item.is-selected,button.dropdown-item.is-active,button.dropdown-item.is-selected{--bulma-dropdown-item-h:var(--bulma-dropdown-item-selected-h);--bulma-dropdown-item-s:var(--bulma-dropdown-item-selected-s);--bulma-dropdown-item-l:var(--bulma-dropdown-item-selected-l);--bulma-dropdown-item-background-l:var(--bulma-dropdown-item-selected-background-l);--bulma-dropdown-item-color-l:var(--bulma-dropdown-item-selected-color-l)}.dropdown-divider{background-color:var(--bulma-dropdown-divider-background-color);border:none;height:1px;margin:.5rem 0;display:block}.menu{--bulma-menu-item-h:var(--bulma-scheme-h);--bulma-menu-item-s:var(--bulma-scheme-s);--bulma-menu-item-l:var(--bulma-scheme-main-l);--bulma-menu-item-background-l:var(--bulma-scheme-main-l);--bulma-menu-item-background-l-delta:0%;--bulma-menu-item-hover-background-l-delta:var(--bulma-hover-background-l-delta);--bulma-menu-item-active-background-l-delta:var(--bulma-active-background-l-delta);--bulma-menu-item-color-l:var(--bulma-text-l);--bulma-menu-item-radius:var(--bulma-radius-small);--bulma-menu-item-selected-h:var(--bulma-link-h);--bulma-menu-item-selected-s:var(--bulma-link-s);--bulma-menu-item-selected-l:var(--bulma-link-l);--bulma-menu-item-selected-background-l:var(--bulma-link-l);--bulma-menu-item-selected-color-l:var(--bulma-link-invert-l);--bulma-menu-list-border-left:1px solid var(--bulma-border);--bulma-menu-list-line-height:1.25;--bulma-menu-list-link-padding:.5em .75em;--bulma-menu-nested-list-margin:.75em;--bulma-menu-nested-list-padding-left:.75em;--bulma-menu-label-color:var(--bulma-text-weak);--bulma-menu-label-font-size:.75em;--bulma-menu-label-letter-spacing:.1em;--bulma-menu-label-spacing:1em;font-size:var(--bulma-size-normal)}.menu.is-small{font-size:var(--bulma-size-small)}.menu.is-medium{font-size:var(--bulma-size-medium)}.menu.is-large{font-size:var(--bulma-size-large)}.menu-list{line-height:var(--bulma-menu-list-line-height)}.menu-list a,.menu-list button,.menu-list .menu-item{background-color:hsl(var(--bulma-menu-item-h),var(--bulma-menu-item-s),calc(var(--bulma-menu-item-background-l) + var(--bulma-menu-item-background-l-delta)));border-radius:var(--bulma-menu-item-radius);color:hsl(var(--bulma-menu-item-h),var(--bulma-menu-item-s),var(--bulma-menu-item-color-l));padding:var(--bulma-menu-list-link-padding);text-align:left;width:100%;display:block}.menu-list a:hover,.menu-list button:hover,.menu-list .menu-item:hover{--bulma-menu-item-background-l-delta:var(--bulma-menu-item-hover-background-l-delta)}.menu-list a:active,.menu-list button:active,.menu-list .menu-item:active{--bulma-menu-item-background-l-delta:var(--bulma-menu-item-active-background-l-delta)}.menu-list a.is-active,.menu-list a.is-selected,.menu-list button.is-active,.menu-list button.is-selected,.menu-list .menu-item.is-active,.menu-list .menu-item.is-selected{--bulma-menu-item-h:var(--bulma-menu-item-selected-h);--bulma-menu-item-s:var(--bulma-menu-item-selected-s);--bulma-menu-item-l:var(--bulma-menu-item-selected-l);--bulma-menu-item-background-l:var(--bulma-menu-item-selected-background-l);--bulma-menu-item-color-l:var(--bulma-menu-item-selected-color-l)}.menu-list li ul{border-inline-start:var(--bulma-menu-list-border-left);margin:var(--bulma-menu-nested-list-margin);padding-inline-start:var(--bulma-menu-nested-list-padding-left)}.menu-label{color:var(--bulma-menu-label-color);font-size:var(--bulma-menu-label-font-size);letter-spacing:var(--bulma-menu-label-letter-spacing);text-transform:uppercase}.menu-label:not(:first-child){margin-top:var(--bulma-menu-label-spacing)}.menu-label:not(:last-child){margin-bottom:var(--bulma-menu-label-spacing)}.message{--bulma-message-border-l-delta:-20%;--bulma-message-radius:var(--bulma-radius);--bulma-message-header-weight:var(--bulma-weight-semibold);--bulma-message-header-padding:1em 1.25em;--bulma-message-header-radius:var(--bulma-radius);--bulma-message-body-border-width:0 0 0 4px;--bulma-message-body-color:var(--bulma-text);--bulma-message-body-padding:1.25em 1.5em;--bulma-message-body-radius:var(--bulma-radius-small);--bulma-message-body-pre-code-background-color:transparent;--bulma-message-header-body-border-width:0;--bulma-message-h:var(--bulma-scheme-h);--bulma-message-s:var(--bulma-scheme-s);--bulma-message-background-l:var(--bulma-background-l);--bulma-message-border-l:var(--bulma-border-l);--bulma-message-border-style:solid;--bulma-message-border-width:.25em;--bulma-message-color-l:var(--bulma-text-l);--bulma-message-header-background-l:var(--bulma-dark-l);--bulma-message-header-color-l:var(--bulma-text-dark-invert-l);border-radius:var(--bulma-message-radius);color:hsl(var(--bulma-message-h),var(--bulma-message-s),var(--bulma-message-color-l));font-size:var(--bulma-size-normal)}.message strong{color:currentColor}.message a:not(.button):not(.tag):not(.dropdown-item){color:currentColor;text-decoration:underline}.message.is-small{font-size:var(--bulma-size-small)}.message.is-medium{font-size:var(--bulma-size-medium)}.message.is-large{font-size:var(--bulma-size-large)}.message.is-white{--bulma-message-h:var(--bulma-white-h);--bulma-message-s:var(--bulma-white-s);--bulma-message-border-l:calc(var(--bulma-white-l) + var(--bulma-message-border-l-delta));--bulma-message-color-l:var(--bulma-white-on-scheme-l);--bulma-message-header-background-l:var(--bulma-white-l);--bulma-message-header-color-l:var(--bulma-white-invert-l)}.message.is-black{--bulma-message-h:var(--bulma-black-h);--bulma-message-s:var(--bulma-black-s);--bulma-message-border-l:calc(var(--bulma-black-l) + var(--bulma-message-border-l-delta));--bulma-message-color-l:var(--bulma-black-on-scheme-l);--bulma-message-header-background-l:var(--bulma-black-l);--bulma-message-header-color-l:var(--bulma-black-invert-l)}.message.is-light{--bulma-message-h:var(--bulma-light-h);--bulma-message-s:var(--bulma-light-s);--bulma-message-border-l:calc(var(--bulma-light-l) + var(--bulma-message-border-l-delta));--bulma-message-color-l:var(--bulma-light-on-scheme-l);--bulma-message-header-background-l:var(--bulma-light-l);--bulma-message-header-color-l:var(--bulma-light-invert-l)}.message.is-dark{--bulma-message-h:var(--bulma-dark-h);--bulma-message-s:var(--bulma-dark-s);--bulma-message-border-l:calc(var(--bulma-dark-l) + var(--bulma-message-border-l-delta));--bulma-message-color-l:var(--bulma-dark-on-scheme-l);--bulma-message-header-background-l:var(--bulma-dark-l);--bulma-message-header-color-l:var(--bulma-dark-invert-l)}.message.is-text{--bulma-message-h:var(--bulma-text-h);--bulma-message-s:var(--bulma-text-s);--bulma-message-border-l:calc(var(--bulma-text-l) + var(--bulma-message-border-l-delta));--bulma-message-color-l:var(--bulma-text-on-scheme-l);--bulma-message-header-background-l:var(--bulma-text-l);--bulma-message-header-color-l:var(--bulma-text-invert-l)}.message.is-primary{--bulma-message-h:var(--bulma-primary-h);--bulma-message-s:var(--bulma-primary-s);--bulma-message-border-l:calc(var(--bulma-primary-l) + var(--bulma-message-border-l-delta));--bulma-message-color-l:var(--bulma-primary-on-scheme-l);--bulma-message-header-background-l:var(--bulma-primary-l);--bulma-message-header-color-l:var(--bulma-primary-invert-l)}.message.is-link{--bulma-message-h:var(--bulma-link-h);--bulma-message-s:var(--bulma-link-s);--bulma-message-border-l:calc(var(--bulma-link-l) + var(--bulma-message-border-l-delta));--bulma-message-color-l:var(--bulma-link-on-scheme-l);--bulma-message-header-background-l:var(--bulma-link-l);--bulma-message-header-color-l:var(--bulma-link-invert-l)}.message.is-info{--bulma-message-h:var(--bulma-info-h);--bulma-message-s:var(--bulma-info-s);--bulma-message-border-l:calc(var(--bulma-info-l) + var(--bulma-message-border-l-delta));--bulma-message-color-l:var(--bulma-info-on-scheme-l);--bulma-message-header-background-l:var(--bulma-info-l);--bulma-message-header-color-l:var(--bulma-info-invert-l)}.message.is-success{--bulma-message-h:var(--bulma-success-h);--bulma-message-s:var(--bulma-success-s);--bulma-message-border-l:calc(var(--bulma-success-l) + var(--bulma-message-border-l-delta));--bulma-message-color-l:var(--bulma-success-on-scheme-l);--bulma-message-header-background-l:var(--bulma-success-l);--bulma-message-header-color-l:var(--bulma-success-invert-l)}.message.is-warning{--bulma-message-h:var(--bulma-warning-h);--bulma-message-s:var(--bulma-warning-s);--bulma-message-border-l:calc(var(--bulma-warning-l) + var(--bulma-message-border-l-delta));--bulma-message-color-l:var(--bulma-warning-on-scheme-l);--bulma-message-header-background-l:var(--bulma-warning-l);--bulma-message-header-color-l:var(--bulma-warning-invert-l)}.message.is-danger{--bulma-message-h:var(--bulma-danger-h);--bulma-message-s:var(--bulma-danger-s);--bulma-message-border-l:calc(var(--bulma-danger-l) + var(--bulma-message-border-l-delta));--bulma-message-color-l:var(--bulma-danger-on-scheme-l);--bulma-message-header-background-l:var(--bulma-danger-l);--bulma-message-header-color-l:var(--bulma-danger-invert-l)}.message-header{background-color:hsl(var(--bulma-message-h),var(--bulma-message-s),var(--bulma-message-header-background-l));color:hsl(var(--bulma-message-h),var(--bulma-message-s),var(--bulma-message-header-color-l));font-weight:var(--bulma-message-header-weight);padding:var(--bulma-message-header-padding);border-start-start-radius:var(--bulma-message-header-radius);border-start-end-radius:var(--bulma-message-header-radius);justify-content:space-between;align-items:center;line-height:1.25;display:flex;position:relative}.message-header .delete{flex-grow:0;flex-shrink:0;margin-inline-start:.75em}.message-header+.message-body{border-width:var(--bulma-message-header-body-border-width);border-start-start-radius:0;border-start-end-radius:0}.message-body{background-color:hsl(var(--bulma-message-h),var(--bulma-message-s),var(--bulma-message-background-l));border-inline-start-color:hsl(var(--bulma-message-h),var(--bulma-message-s),var(--bulma-message-border-l));border-inline-start-style:var(--bulma-message-border-style);border-inline-start-width:var(--bulma-message-border-width);border-radius:var(--bulma-message-body-radius);padding:var(--bulma-message-body-padding)}.message-body code,.message-body pre{background-color:hsl(var(--bulma-message-h),var(--bulma-message-s),var(--bulma-message-header-color-l));color:hsl(var(--bulma-message-h),var(--bulma-message-s),var(--bulma-message-header-background-l))}.message-body pre code{background-color:var(--bulma-message-body-pre-code-background-color)}.modal{--bulma-modal-z:40;--bulma-modal-background-background-color:hsla(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-scheme-invert-l),.86);--bulma-modal-content-width:40rem;--bulma-modal-content-margin-mobile:1.25rem;--bulma-modal-content-spacing-mobile:10rem;--bulma-modal-content-spacing-tablet:2.5rem;--bulma-modal-close-dimensions:2.5rem;--bulma-modal-close-right:1.25rem;--bulma-modal-close-top:1.25rem;--bulma-modal-card-spacing:2.5rem;--bulma-modal-card-head-background-color:var(--bulma-scheme-main);--bulma-modal-card-head-padding:2rem;--bulma-modal-card-head-radius:var(--bulma-radius-large);--bulma-modal-card-title-color:var(--bulma-text-strong);--bulma-modal-card-title-line-height:1;--bulma-modal-card-title-size:var(--bulma-size-4);--bulma-modal-card-foot-background-color:var(--bulma-scheme-main-bis);--bulma-modal-card-foot-radius:var(--bulma-radius-large);--bulma-modal-card-body-background-color:var(--bulma-scheme-main);--bulma-modal-card-body-padding:2rem;z-index:var(--bulma-modal-z);flex-direction:column;justify-content:center;align-items:center;display:none;position:fixed;overflow:hidden}.modal.is-active{display:flex}.modal-background{background-color:var(--bulma-modal-background-background-color)}.modal-content,.modal-card{margin:0 var(--bulma-modal-content-margin-mobile);max-height:calc(100vh - var(--bulma-modal-content-spacing-mobile));width:100%;position:relative;overflow:auto}@media screen and (width>=769px){.modal-content,.modal-card{max-height:calc(100vh - var(--bulma-modal-content-spacing-tablet));width:var(--bulma-modal-content-width);margin:0 auto}}.modal-close{height:var(--bulma-modal-close-dimensions);inset-inline-end:var(--bulma-modal-close-right);top:var(--bulma-modal-close-top);width:var(--bulma-modal-close-dimensions);background:0 0;position:fixed}.modal-card{max-height:calc(100vh - var(--bulma-modal-card-spacing));flex-direction:column;display:flex;overflow:hidden visible}.modal-card-head,.modal-card-foot{padding:var(--bulma-modal-card-head-padding);flex-shrink:0;justify-content:flex-start;align-items:center;display:flex;position:relative}.modal-card-head{background-color:var(--bulma-modal-card-head-background-color);box-shadow:var(--bulma-shadow);border-start-start-radius:var(--bulma-modal-card-head-radius);border-start-end-radius:var(--bulma-modal-card-head-radius)}.modal-card-title{color:var(--bulma-modal-card-title-color);font-size:var(--bulma-modal-card-title-size);line-height:var(--bulma-modal-card-title-line-height);flex-grow:1;flex-shrink:0}.modal-card-foot{background-color:var(--bulma-modal-card-foot-background-color);border-end-end-radius:var(--bulma-modal-card-foot-radius);border-end-start-radius:var(--bulma-modal-card-foot-radius)}.modal-card-body{-webkit-overflow-scrolling:touch;background-color:var(--bulma-modal-card-body-background-color);padding:var(--bulma-modal-card-body-padding);flex-grow:1;flex-shrink:1;overflow:auto}:root{--bulma-navbar-height:3.25rem}.navbar{--bulma-navbar-h:var(--bulma-scheme-h);--bulma-navbar-s:var(--bulma-scheme-s);--bulma-navbar-l:var(--bulma-scheme-main-l);--bulma-navbar-background-color:var(--bulma-scheme-main);--bulma-navbar-box-shadow-size:0 .125em 0 0;--bulma-navbar-box-shadow-color:var(--bulma-background);--bulma-navbar-padding-vertical:1rem;--bulma-navbar-padding-horizontal:2rem;--bulma-navbar-z:30;--bulma-navbar-fixed-z:30;--bulma-navbar-item-background-a:0;--bulma-navbar-item-background-l:var(--bulma-scheme-main-l);--bulma-navbar-item-background-l-delta:0%;--bulma-navbar-item-hover-background-l-delta:var(--bulma-hover-background-l-delta);--bulma-navbar-item-active-background-l-delta:var(--bulma-active-background-l-delta);--bulma-navbar-item-color-l:var(--bulma-text-l);--bulma-navbar-item-color:hsl(var(--bulma-navbar-h),var(--bulma-navbar-s),var(--bulma-navbar-item-color-l));--bulma-navbar-item-selected-h:var(--bulma-link-h);--bulma-navbar-item-selected-s:var(--bulma-link-s);--bulma-navbar-item-selected-l:var(--bulma-link-l);--bulma-navbar-item-selected-background-l:var(--bulma-link-l);--bulma-navbar-item-selected-color-l:var(--bulma-link-invert-l);--bulma-navbar-item-img-max-height:1.75rem;--bulma-navbar-burger-color:var(--bulma-link);--bulma-navbar-tab-hover-background-color:transparent;--bulma-navbar-tab-hover-border-bottom-color:var(--bulma-link);--bulma-navbar-tab-active-color:var(--bulma-link);--bulma-navbar-tab-active-background-color:transparent;--bulma-navbar-tab-active-border-bottom-color:var(--bulma-link);--bulma-navbar-tab-active-border-bottom-style:solid;--bulma-navbar-tab-active-border-bottom-width:.1875em;--bulma-navbar-dropdown-background-color:var(--bulma-scheme-main);--bulma-navbar-dropdown-border-l:var(--bulma-border-l);--bulma-navbar-dropdown-border-color:hsl(var(--bulma-navbar-h),var(--bulma-navbar-s),var(--bulma-navbar-dropdown-border-l));--bulma-navbar-dropdown-border-style:solid;--bulma-navbar-dropdown-border-width:.125em;--bulma-navbar-dropdown-offset:-.25em;--bulma-navbar-dropdown-arrow:var(--bulma-link);--bulma-navbar-dropdown-radius:var(--bulma-radius-large);--bulma-navbar-dropdown-z:20;--bulma-navbar-dropdown-boxed-radius:var(--bulma-radius-large);--bulma-navbar-dropdown-boxed-shadow:0 .5em .5em hsla(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-scheme-invert-l),.1),0 0 0 1px hsla(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-scheme-invert-l),.1);--bulma-navbar-dropdown-item-h:var(--bulma-scheme-h);--bulma-navbar-dropdown-item-s:var(--bulma-scheme-s);--bulma-navbar-dropdown-item-l:var(--bulma-scheme-main-l);--bulma-navbar-dropdown-item-background-l:var(--bulma-scheme-main-l);--bulma-navbar-dropdown-item-color-l:var(--bulma-text-l);--bulma-navbar-divider-background-l:var(--bulma-background-l);--bulma-navbar-divider-height:.125em;--bulma-navbar-bottom-box-shadow-size:0 -.125em 0 0;background-color:var(--bulma-navbar-background-color);min-height:var(--bulma-navbar-height);z-index:var(--bulma-navbar-z);position:relative}.navbar.is-white{--bulma-navbar-h:var(--bulma-white-h);--bulma-navbar-s:var(--bulma-white-s);--bulma-navbar-l:var(--bulma-white-l);--bulma-burger-h:var(--bulma-white-h);--bulma-burger-s:var(--bulma-white-s);--bulma-burger-l:var(--bulma-white-invert-l);--bulma-navbar-background-color:var(--bulma-white);--bulma-navbar-item-background-l:var(--bulma-white-l);--bulma-navbar-item-color-l:var(--bulma-white-invert-l);--bulma-navbar-item-selected-h:var(--bulma-white-h);--bulma-navbar-item-selected-s:var(--bulma-white-s);--bulma-navbar-item-selected-l:var(--bulma-white-l);--bulma-navbar-item-selected-background-l:var(--bulma-white-l);--bulma-navbar-item-selected-color-l:var(--bulma-white-invert-l);--bulma-navbar-dropdown-arrow:var(--bulma-white-invert-l);--bulma-navbar-dropdown-background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-navbar-dropdown-item-background-l));--bulma-navbar-dropdown-item-h:var(--bulma-white-h);--bulma-navbar-dropdown-item-s:var(--bulma-white-s)}.navbar.is-black{--bulma-navbar-h:var(--bulma-black-h);--bulma-navbar-s:var(--bulma-black-s);--bulma-navbar-l:var(--bulma-black-l);--bulma-burger-h:var(--bulma-black-h);--bulma-burger-s:var(--bulma-black-s);--bulma-burger-l:var(--bulma-black-invert-l);--bulma-navbar-background-color:var(--bulma-black);--bulma-navbar-item-background-l:var(--bulma-black-l);--bulma-navbar-item-color-l:var(--bulma-black-invert-l);--bulma-navbar-item-selected-h:var(--bulma-black-h);--bulma-navbar-item-selected-s:var(--bulma-black-s);--bulma-navbar-item-selected-l:var(--bulma-black-l);--bulma-navbar-item-selected-background-l:var(--bulma-black-l);--bulma-navbar-item-selected-color-l:var(--bulma-black-invert-l);--bulma-navbar-dropdown-arrow:var(--bulma-black-invert-l);--bulma-navbar-dropdown-background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-navbar-dropdown-item-background-l));--bulma-navbar-dropdown-item-h:var(--bulma-black-h);--bulma-navbar-dropdown-item-s:var(--bulma-black-s)}.navbar.is-light{--bulma-navbar-h:var(--bulma-light-h);--bulma-navbar-s:var(--bulma-light-s);--bulma-navbar-l:var(--bulma-light-l);--bulma-burger-h:var(--bulma-light-h);--bulma-burger-s:var(--bulma-light-s);--bulma-burger-l:var(--bulma-light-invert-l);--bulma-navbar-background-color:var(--bulma-light);--bulma-navbar-item-background-l:var(--bulma-light-l);--bulma-navbar-item-color-l:var(--bulma-light-invert-l);--bulma-navbar-item-selected-h:var(--bulma-light-h);--bulma-navbar-item-selected-s:var(--bulma-light-s);--bulma-navbar-item-selected-l:var(--bulma-light-l);--bulma-navbar-item-selected-background-l:var(--bulma-light-l);--bulma-navbar-item-selected-color-l:var(--bulma-light-invert-l);--bulma-navbar-dropdown-arrow:var(--bulma-light-invert-l);--bulma-navbar-dropdown-background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-navbar-dropdown-item-background-l));--bulma-navbar-dropdown-item-h:var(--bulma-light-h);--bulma-navbar-dropdown-item-s:var(--bulma-light-s)}.navbar.is-dark{--bulma-navbar-h:var(--bulma-dark-h);--bulma-navbar-s:var(--bulma-dark-s);--bulma-navbar-l:var(--bulma-dark-l);--bulma-burger-h:var(--bulma-dark-h);--bulma-burger-s:var(--bulma-dark-s);--bulma-burger-l:var(--bulma-dark-invert-l);--bulma-navbar-background-color:var(--bulma-dark);--bulma-navbar-item-background-l:var(--bulma-dark-l);--bulma-navbar-item-color-l:var(--bulma-dark-invert-l);--bulma-navbar-item-selected-h:var(--bulma-dark-h);--bulma-navbar-item-selected-s:var(--bulma-dark-s);--bulma-navbar-item-selected-l:var(--bulma-dark-l);--bulma-navbar-item-selected-background-l:var(--bulma-dark-l);--bulma-navbar-item-selected-color-l:var(--bulma-dark-invert-l);--bulma-navbar-dropdown-arrow:var(--bulma-dark-invert-l);--bulma-navbar-dropdown-background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-navbar-dropdown-item-background-l));--bulma-navbar-dropdown-item-h:var(--bulma-dark-h);--bulma-navbar-dropdown-item-s:var(--bulma-dark-s)}.navbar.is-text{--bulma-navbar-h:var(--bulma-text-h);--bulma-navbar-s:var(--bulma-text-s);--bulma-navbar-l:var(--bulma-text-l);--bulma-burger-h:var(--bulma-text-h);--bulma-burger-s:var(--bulma-text-s);--bulma-burger-l:var(--bulma-text-invert-l);--bulma-navbar-background-color:var(--bulma-text);--bulma-navbar-item-background-l:var(--bulma-text-l);--bulma-navbar-item-color-l:var(--bulma-text-invert-l);--bulma-navbar-item-selected-h:var(--bulma-text-h);--bulma-navbar-item-selected-s:var(--bulma-text-s);--bulma-navbar-item-selected-l:var(--bulma-text-l);--bulma-navbar-item-selected-background-l:var(--bulma-text-l);--bulma-navbar-item-selected-color-l:var(--bulma-text-invert-l);--bulma-navbar-dropdown-arrow:var(--bulma-text-invert-l);--bulma-navbar-dropdown-background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-navbar-dropdown-item-background-l));--bulma-navbar-dropdown-item-h:var(--bulma-text-h);--bulma-navbar-dropdown-item-s:var(--bulma-text-s)}.navbar.is-primary{--bulma-navbar-h:var(--bulma-primary-h);--bulma-navbar-s:var(--bulma-primary-s);--bulma-navbar-l:var(--bulma-primary-l);--bulma-burger-h:var(--bulma-primary-h);--bulma-burger-s:var(--bulma-primary-s);--bulma-burger-l:var(--bulma-primary-invert-l);--bulma-navbar-background-color:var(--bulma-primary);--bulma-navbar-item-background-l:var(--bulma-primary-l);--bulma-navbar-item-color-l:var(--bulma-primary-invert-l);--bulma-navbar-item-selected-h:var(--bulma-primary-h);--bulma-navbar-item-selected-s:var(--bulma-primary-s);--bulma-navbar-item-selected-l:var(--bulma-primary-l);--bulma-navbar-item-selected-background-l:var(--bulma-primary-l);--bulma-navbar-item-selected-color-l:var(--bulma-primary-invert-l);--bulma-navbar-dropdown-arrow:var(--bulma-primary-invert-l);--bulma-navbar-dropdown-background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-navbar-dropdown-item-background-l));--bulma-navbar-dropdown-item-h:var(--bulma-primary-h);--bulma-navbar-dropdown-item-s:var(--bulma-primary-s)}.navbar.is-link{--bulma-navbar-h:var(--bulma-link-h);--bulma-navbar-s:var(--bulma-link-s);--bulma-navbar-l:var(--bulma-link-l);--bulma-burger-h:var(--bulma-link-h);--bulma-burger-s:var(--bulma-link-s);--bulma-burger-l:var(--bulma-link-invert-l);--bulma-navbar-background-color:var(--bulma-link);--bulma-navbar-item-background-l:var(--bulma-link-l);--bulma-navbar-item-color-l:var(--bulma-link-invert-l);--bulma-navbar-item-selected-h:var(--bulma-link-h);--bulma-navbar-item-selected-s:var(--bulma-link-s);--bulma-navbar-item-selected-l:var(--bulma-link-l);--bulma-navbar-item-selected-background-l:var(--bulma-link-l);--bulma-navbar-item-selected-color-l:var(--bulma-link-invert-l);--bulma-navbar-dropdown-arrow:var(--bulma-link-invert-l);--bulma-navbar-dropdown-background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-navbar-dropdown-item-background-l));--bulma-navbar-dropdown-item-h:var(--bulma-link-h);--bulma-navbar-dropdown-item-s:var(--bulma-link-s)}.navbar.is-info{--bulma-navbar-h:var(--bulma-info-h);--bulma-navbar-s:var(--bulma-info-s);--bulma-navbar-l:var(--bulma-info-l);--bulma-burger-h:var(--bulma-info-h);--bulma-burger-s:var(--bulma-info-s);--bulma-burger-l:var(--bulma-info-invert-l);--bulma-navbar-background-color:var(--bulma-info);--bulma-navbar-item-background-l:var(--bulma-info-l);--bulma-navbar-item-color-l:var(--bulma-info-invert-l);--bulma-navbar-item-selected-h:var(--bulma-info-h);--bulma-navbar-item-selected-s:var(--bulma-info-s);--bulma-navbar-item-selected-l:var(--bulma-info-l);--bulma-navbar-item-selected-background-l:var(--bulma-info-l);--bulma-navbar-item-selected-color-l:var(--bulma-info-invert-l);--bulma-navbar-dropdown-arrow:var(--bulma-info-invert-l);--bulma-navbar-dropdown-background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-navbar-dropdown-item-background-l));--bulma-navbar-dropdown-item-h:var(--bulma-info-h);--bulma-navbar-dropdown-item-s:var(--bulma-info-s)}.navbar.is-success{--bulma-navbar-h:var(--bulma-success-h);--bulma-navbar-s:var(--bulma-success-s);--bulma-navbar-l:var(--bulma-success-l);--bulma-burger-h:var(--bulma-success-h);--bulma-burger-s:var(--bulma-success-s);--bulma-burger-l:var(--bulma-success-invert-l);--bulma-navbar-background-color:var(--bulma-success);--bulma-navbar-item-background-l:var(--bulma-success-l);--bulma-navbar-item-color-l:var(--bulma-success-invert-l);--bulma-navbar-item-selected-h:var(--bulma-success-h);--bulma-navbar-item-selected-s:var(--bulma-success-s);--bulma-navbar-item-selected-l:var(--bulma-success-l);--bulma-navbar-item-selected-background-l:var(--bulma-success-l);--bulma-navbar-item-selected-color-l:var(--bulma-success-invert-l);--bulma-navbar-dropdown-arrow:var(--bulma-success-invert-l);--bulma-navbar-dropdown-background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-navbar-dropdown-item-background-l));--bulma-navbar-dropdown-item-h:var(--bulma-success-h);--bulma-navbar-dropdown-item-s:var(--bulma-success-s)}.navbar.is-warning{--bulma-navbar-h:var(--bulma-warning-h);--bulma-navbar-s:var(--bulma-warning-s);--bulma-navbar-l:var(--bulma-warning-l);--bulma-burger-h:var(--bulma-warning-h);--bulma-burger-s:var(--bulma-warning-s);--bulma-burger-l:var(--bulma-warning-invert-l);--bulma-navbar-background-color:var(--bulma-warning);--bulma-navbar-item-background-l:var(--bulma-warning-l);--bulma-navbar-item-color-l:var(--bulma-warning-invert-l);--bulma-navbar-item-selected-h:var(--bulma-warning-h);--bulma-navbar-item-selected-s:var(--bulma-warning-s);--bulma-navbar-item-selected-l:var(--bulma-warning-l);--bulma-navbar-item-selected-background-l:var(--bulma-warning-l);--bulma-navbar-item-selected-color-l:var(--bulma-warning-invert-l);--bulma-navbar-dropdown-arrow:var(--bulma-warning-invert-l);--bulma-navbar-dropdown-background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-navbar-dropdown-item-background-l));--bulma-navbar-dropdown-item-h:var(--bulma-warning-h);--bulma-navbar-dropdown-item-s:var(--bulma-warning-s)}.navbar.is-danger{--bulma-navbar-h:var(--bulma-danger-h);--bulma-navbar-s:var(--bulma-danger-s);--bulma-navbar-l:var(--bulma-danger-l);--bulma-burger-h:var(--bulma-danger-h);--bulma-burger-s:var(--bulma-danger-s);--bulma-burger-l:var(--bulma-danger-invert-l);--bulma-navbar-background-color:var(--bulma-danger);--bulma-navbar-item-background-l:var(--bulma-danger-l);--bulma-navbar-item-color-l:var(--bulma-danger-invert-l);--bulma-navbar-item-selected-h:var(--bulma-danger-h);--bulma-navbar-item-selected-s:var(--bulma-danger-s);--bulma-navbar-item-selected-l:var(--bulma-danger-l);--bulma-navbar-item-selected-background-l:var(--bulma-danger-l);--bulma-navbar-item-selected-color-l:var(--bulma-danger-invert-l);--bulma-navbar-dropdown-arrow:var(--bulma-danger-invert-l);--bulma-navbar-dropdown-background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-navbar-dropdown-item-background-l));--bulma-navbar-dropdown-item-h:var(--bulma-danger-h);--bulma-navbar-dropdown-item-s:var(--bulma-danger-s)}.navbar>.container{min-height:var(--bulma-navbar-height);align-items:stretch;width:100%;display:flex}.navbar.has-shadow{box-shadow:var(--bulma-navbar-box-shadow-size)var(--bulma-navbar-box-shadow-color)}.navbar.is-fixed-bottom,.navbar.is-fixed-top{z-index:var(--bulma-navbar-fixed-z);position:fixed;left:0;right:0}.navbar.is-fixed-bottom{bottom:0}.navbar.is-fixed-bottom.has-shadow{box-shadow:var(--bulma-navbar-bottom-box-shadow-size)var(--bulma-navbar-box-shadow-color)}.navbar.is-fixed-top{top:0}html.has-navbar-fixed-top,body.has-navbar-fixed-top{padding-top:var(--bulma-navbar-height)}html.has-navbar-fixed-bottom,body.has-navbar-fixed-bottom{padding-bottom:var(--bulma-navbar-height)}.navbar-brand,.navbar-tabs{min-height:var(--bulma-navbar-height);flex-shrink:0;align-items:stretch;display:flex}.navbar-tabs{-webkit-overflow-scrolling:touch;max-width:100vw;overflow:auto hidden}.navbar-burger{appearance:none;border-radius:var(--bulma-burger-border-radius);color:hsl(var(--bulma-burger-h),var(--bulma-burger-s),var(--bulma-burger-l));cursor:pointer;vertical-align:top;background:0 0;border:none;flex-direction:column;flex-shrink:0;justify-content:center;align-items:center;width:2.5rem;height:2.5rem;display:inline-flex;position:relative}.navbar-burger span{height:var(--bulma-burger-item-height);left:calc(50% - (var(--bulma-burger-item-width))/2);transform-origin:50%;transition-duration:var(--bulma-duration);transition-property:background-color,color,opacity,transform;transition-timing-function:var(--bulma-easing);width:var(--bulma-burger-item-width);background-color:currentColor;display:block;position:absolute}.navbar-burger span:first-child,.navbar-burger span:nth-child(2){top:calc(50% - (var(--bulma-burger-item-height))/2)}.navbar-burger span:nth-child(3){bottom:calc(50% + var(--bulma-burger-gap))}.navbar-burger span:nth-child(4){top:calc(50% + var(--bulma-burger-gap))}.navbar-burger:hover{background-color:hsla(var(--bulma-burger-h),var(--bulma-burger-s),var(--bulma-burger-l),.1)}.navbar-burger:active{background-color:hsla(var(--bulma-burger-h),var(--bulma-burger-s),var(--bulma-burger-l),.2)}.navbar-burger.is-active span:first-child{transform:rotate(-45deg)}.navbar-burger.is-active span:nth-child(2){transform:rotate(45deg)}.navbar-burger.is-active span:nth-child(3),.navbar-burger.is-active span:nth-child(4){opacity:0}.navbar-burger{color:var(--bulma-navbar-burger-color);align-self:center;margin-inline:auto .375rem}.navbar-menu{display:none}.navbar-item,.navbar-link{color:var(--bulma-navbar-item-color);gap:.75rem;padding:.5rem .75rem;line-height:1.5;display:block;position:relative}.navbar-item .icon:only-child,.navbar-link .icon:only-child{margin-left:-.25rem;margin-right:-.25rem}a.navbar-item,.navbar-link{background-color:hsla(var(--bulma-navbar-h),var(--bulma-navbar-s),calc(var(--bulma-navbar-item-background-l) + var(--bulma-navbar-item-background-l-delta)),var(--bulma-navbar-item-background-a));cursor:pointer}a.navbar-item:focus,a.navbar-item:focus-within,a.navbar-item:hover,.navbar-link:focus,.navbar-link:focus-within,.navbar-link:hover{--bulma-navbar-item-background-l-delta:var(--bulma-navbar-item-hover-background-l-delta);--bulma-navbar-item-background-a:1}a.navbar-item:active,.navbar-link:active{--bulma-navbar-item-background-l-delta:var(--bulma-navbar-item-active-background-l-delta);--bulma-navbar-item-background-a:1}a.navbar-item.is-active,a.navbar-item.is-selected,.navbar-link.is-active,.navbar-link.is-selected{--bulma-navbar-h:var(--bulma-navbar-item-selected-h);--bulma-navbar-s:var(--bulma-navbar-item-selected-s);--bulma-navbar-l:var(--bulma-navbar-item-selected-l);--bulma-navbar-item-background-l:var(--bulma-navbar-item-selected-background-l);--bulma-navbar-item-background-a:1;--bulma-navbar-item-color-l:var(--bulma-navbar-item-selected-color-l)}.navbar-item{flex-grow:0;flex-shrink:0}.navbar-item img,.navbar-item svg{max-height:var(--bulma-navbar-item-img-max-height)}.navbar-item.has-dropdown{padding:0}.navbar-item.is-expanded{flex-grow:1;flex-shrink:1}.navbar-item.is-tab{min-height:var(--bulma-navbar-height);border-bottom:1px solid #0000;padding-bottom:calc(.5rem - 1px)}.navbar-item.is-tab:focus,.navbar-item.is-tab:hover{background-color:var(--bulma-navbar-tab-hover-background-color);border-bottom-color:var(--bulma-navbar-tab-hover-border-bottom-color)}.navbar-item.is-tab.is-active{background-color:var(--bulma-navbar-tab-active-background-color);border-bottom-color:var(--bulma-navbar-tab-active-border-bottom-color);border-bottom-style:var(--bulma-navbar-tab-active-border-bottom-style);border-bottom-width:var(--bulma-navbar-tab-active-border-bottom-width);color:var(--bulma-navbar-tab-active-color);padding-bottom:calc(.5rem - var(--bulma-navbar-tab-active-border-bottom-width))}.navbar-content{flex-grow:1;flex-shrink:1}.navbar-link:not(.is-arrowless){padding-inline-end:2.5em}.navbar-link:not(.is-arrowless):after{border-color:var(--bulma-navbar-dropdown-arrow);margin-top:-.375em;inset-inline-end:1.125em}.navbar-dropdown{padding-top:.5rem;padding-bottom:.75rem;font-size:.875rem}.navbar-dropdown .navbar-item{padding-left:1.5rem;padding-right:1.5rem}.navbar-dropdown .navbar-item:not(.is-active,.is-selected){background-color:hsl(var(--bulma-navbar-dropdown-item-h),var(--bulma-navbar-dropdown-item-s),calc(var(--bulma-navbar-dropdown-item-background-l) + var(--bulma-navbar-item-background-l-delta)));color:hsl(var(--bulma-navbar-dropdown-item-h),var(--bulma-navbar-dropdown-item-s),var(--bulma-navbar-dropdown-item-color-l))}.navbar-divider{background-color:hsl(var(--bulma-navbar-h),var(--bulma-navbar-s),var(--bulma-navbar-divider-background-l));height:var(--bulma-navbar-divider-height);border:none;margin:.5rem 0;display:none}@media screen and (width<=1023px){.navbar>.container{display:block}.navbar-brand .navbar-item,.navbar-tabs .navbar-item{align-items:center;display:flex}.navbar-link:after{display:none}.navbar-menu{background-color:var(--bulma-navbar-background-color);box-shadow:0 .5em 1em hsla(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-scheme-invert-l),.1);padding:.5rem 0}.navbar-menu.is-active{display:block}.navbar.is-fixed-bottom-touch,.navbar.is-fixed-top-touch{z-index:var(--bulma-navbar-fixed-z);position:fixed;left:0;right:0}.navbar.is-fixed-bottom-touch{bottom:0}.navbar.is-fixed-bottom-touch.has-shadow{box-shadow:0 -.125em .1875em hsla(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-scheme-invert-l),.1)}.navbar.is-fixed-top-touch{top:0}.navbar.is-fixed-top .navbar-menu,.navbar.is-fixed-top-touch .navbar-menu{-webkit-overflow-scrolling:touch;max-height:calc(100vh - var(--bulma-navbar-height));overflow:auto}html.has-navbar-fixed-top-touch,body.has-navbar-fixed-top-touch{padding-top:var(--bulma-navbar-height)}html.has-navbar-fixed-bottom-touch,body.has-navbar-fixed-bottom-touch{padding-bottom:var(--bulma-navbar-height)}}@media screen and (width>=1024px){.navbar,.navbar-menu,.navbar-start,.navbar-end{align-items:stretch;display:flex}.navbar{min-height:var(--bulma-navbar-height)}.navbar.is-spaced{padding:var(--bulma-navbar-padding-vertical)var(--bulma-navbar-padding-horizontal)}.navbar.is-spaced .navbar-start,.navbar.is-spaced .navbar-end{align-items:center}.navbar.is-spaced a.navbar-item,.navbar.is-spaced .navbar-link{border-radius:var(--bulma-radius)}.navbar.is-transparent{--bulma-navbar-item-background-a:0}.navbar.is-transparent .navbar-dropdown a.navbar-item{background-color:hsl(var(--bulma-navbar-h),var(--bulma-navbar-s),calc(var(--bulma-navbar-item-background-l) + var(--bulma-navbar-item-background-l-delta)))}.navbar.is-transparent .navbar-dropdown a.navbar-item.is-active,.navbar.is-transparent .navbar-dropdown a.navbar-item.is-selected{--bulma-navbar-h:var(--bulma-navbar-item-selected-h);--bulma-navbar-s:var(--bulma-navbar-item-selected-s);--bulma-navbar-l:var(--bulma-navbar-item-selected-l);--bulma-navbar-item-background-l:var(--bulma-navbar-item-selected-background-l);--bulma-navbar-item-color-l:var(--bulma-navbar-item-selected-color-l)}.navbar-burger{display:none}.navbar-item,.navbar-link{align-items:center;display:flex}.navbar-item.has-dropdown{align-items:stretch}.navbar-item.has-dropdown-up .navbar-link:after{transform:rotate(135deg)translate(.25em,-.25em)}.navbar-item.has-dropdown-up .navbar-dropdown{border-bottom-color:var(--bulma-navbar-dropdown-border-color);border-bottom-style:var(--bulma-navbar-dropdown-border-style);border-bottom-width:var(--bulma-navbar-dropdown-border-width);border-radius:var(--bulma-navbar-dropdown-radius)var(--bulma-navbar-dropdown-radius)0 0;box-shadow:0 -.5em .5em hsla(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-scheme-invert-l),.1);border-top:none;top:auto;bottom:100%}.navbar-item.is-active .navbar-dropdown,.navbar-item.is-hoverable:focus .navbar-dropdown,.navbar-item.is-hoverable:focus-within .navbar-dropdown,.navbar-item.is-hoverable:hover .navbar-dropdown{display:block}.navbar.is-spaced .navbar-item.is-active .navbar-dropdown,.navbar-item.is-active .navbar-dropdown.is-boxed,.navbar.is-spaced .navbar-item.is-hoverable:focus .navbar-dropdown,.navbar-item.is-hoverable:focus .navbar-dropdown.is-boxed,.navbar.is-spaced .navbar-item.is-hoverable:focus-within .navbar-dropdown,.navbar-item.is-hoverable:focus-within .navbar-dropdown.is-boxed,.navbar.is-spaced .navbar-item.is-hoverable:hover .navbar-dropdown,.navbar-item.is-hoverable:hover .navbar-dropdown.is-boxed{opacity:1;pointer-events:auto;transform:translateY(0)}.navbar-menu{flex-grow:1;flex-shrink:0}.navbar-start{justify-content:flex-start;margin-inline-end:auto}.navbar-end{justify-content:flex-end;margin-inline-start:auto}.navbar-dropdown{background-color:var(--bulma-navbar-dropdown-background-color);border-top-color:var(--bulma-navbar-dropdown-border-color);border-top-style:var(--bulma-navbar-dropdown-border-style);border-top-width:var(--bulma-navbar-dropdown-border-width);box-shadow:0 .5em .5em hsla(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-scheme-invert-l),.1);inset-inline-start:0;z-index:var(--bulma-navbar-dropdown-z);border-end-end-radius:var(--bulma-navbar-dropdown-radius);border-end-start-radius:var(--bulma-navbar-dropdown-radius);min-width:100%;font-size:.875rem;display:none;position:absolute;top:100%}.navbar-dropdown .navbar-item{white-space:nowrap;padding:.375rem 1rem}.navbar-dropdown a.navbar-item{padding-inline-end:3rem}.navbar-dropdown a.navbar-item:not(.is-active,.is-selected){background-color:hsl(var(--bulma-navbar-dropdown-item-h),var(--bulma-navbar-dropdown-item-s),calc(var(--bulma-navbar-dropdown-item-background-l) + var(--bulma-navbar-item-background-l-delta)));color:hsl(var(--bulma-navbar-dropdown-item-h),var(--bulma-navbar-dropdown-item-s),var(--bulma-navbar-dropdown-item-color-l))}.navbar.is-spaced .navbar-dropdown,.navbar-dropdown.is-boxed{border-radius:var(--bulma-navbar-dropdown-boxed-radius);box-shadow:var(--bulma-navbar-dropdown-boxed-shadow);opacity:0;pointer-events:none;top:calc(100% + (var(--bulma-navbar-dropdown-offset)));transition-duration:var(--bulma-duration);border-top:none;transition-property:opacity,transform;display:block;transform:translateY(-5px)}.navbar-dropdown.is-right{left:auto;right:0}.navbar-divider{display:block}.navbar>.container .navbar-brand,.container>.navbar .navbar-brand{margin-inline-start:-.75rem}.navbar>.container .navbar-menu,.container>.navbar .navbar-menu{margin-inline-end:-.75rem}.navbar.is-fixed-bottom-desktop,.navbar.is-fixed-top-desktop{z-index:var(--bulma-navbar-fixed-z);position:fixed;left:0;right:0}.navbar.is-fixed-bottom-desktop{bottom:0}.navbar.is-fixed-bottom-desktop.has-shadow{box-shadow:0 -.125em .1875em hsla(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-scheme-invert-l),.1)}.navbar.is-fixed-top-desktop{top:0}html.has-navbar-fixed-top-desktop,body.has-navbar-fixed-top-desktop{padding-top:var(--bulma-navbar-height)}html.has-navbar-fixed-bottom-desktop,body.has-navbar-fixed-bottom-desktop{padding-bottom:var(--bulma-navbar-height)}html.has-spaced-navbar-fixed-top,body.has-spaced-navbar-fixed-top{padding-top:calc(var(--bulma-navbar-height) + var(--bulma-navbar-padding-vertical)*2)}html.has-spaced-navbar-fixed-bottom,body.has-spaced-navbar-fixed-bottom{padding-bottom:calc(var(--bulma-navbar-height) + var(--bulma-navbar-padding-vertical)*2)}}.hero.is-fullheight-with-navbar{min-height:calc(100vh - var(--bulma-navbar-height))}.pagination{--bulma-pagination-margin:-.25rem;--bulma-pagination-min-width:var(--bulma-control-height);--bulma-pagination-item-h:var(--bulma-scheme-h);--bulma-pagination-item-s:var(--bulma-scheme-s);--bulma-pagination-item-l:var(--bulma-scheme-main-l);--bulma-pagination-item-background-l-delta:0%;--bulma-pagination-item-hover-background-l-delta:var(--bulma-hover-background-l-delta);--bulma-pagination-item-active-background-l-delta:var(--bulma-active-background-l-delta);--bulma-pagination-item-border-style:solid;--bulma-pagination-item-border-width:var(--bulma-control-border-width);--bulma-pagination-item-border-l:var(--bulma-border-l);--bulma-pagination-item-border-l-delta:0%;--bulma-pagination-item-hover-border-l-delta:var(--bulma-hover-border-l-delta);--bulma-pagination-item-active-border-l-delta:var(--bulma-active-border-l-delta);--bulma-pagination-item-focus-border-l-delta:var(--bulma-focus-border-l-delta);--bulma-pagination-item-color-l:var(--bulma-text-strong-l);--bulma-pagination-item-font-size:1em;--bulma-pagination-item-margin:.25rem;--bulma-pagination-item-padding-left:.5em;--bulma-pagination-item-padding-right:.5em;--bulma-pagination-item-outer-shadow-h:0;--bulma-pagination-item-outer-shadow-s:0%;--bulma-pagination-item-outer-shadow-l:20%;--bulma-pagination-item-outer-shadow-a:.05;--bulma-pagination-nav-padding-left:.75em;--bulma-pagination-nav-padding-right:.75em;--bulma-pagination-disabled-color:var(--bulma-text-weak);--bulma-pagination-disabled-background-color:var(--bulma-border);--bulma-pagination-disabled-border-color:var(--bulma-border);--bulma-pagination-current-color:var(--bulma-link-invert);--bulma-pagination-current-background-color:var(--bulma-link);--bulma-pagination-current-border-color:var(--bulma-link);--bulma-pagination-ellipsis-color:var(--bulma-text-weak);--bulma-pagination-shadow-inset:inset 0 .0625em .125em hsla(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-scheme-invert-l),.2);--bulma-pagination-selected-item-h:var(--bulma-link-h);--bulma-pagination-selected-item-s:var(--bulma-link-s);--bulma-pagination-selected-item-l:var(--bulma-link-l);--bulma-pagination-selected-item-background-l:var(--bulma-link-l);--bulma-pagination-selected-item-border-l:var(--bulma-link-l);--bulma-pagination-selected-item-color-l:var(--bulma-link-invert-l);font-size:var(--bulma-size-normal);margin:var(--bulma-pagination-margin)}.pagination.is-small{font-size:var(--bulma-size-small)}.pagination.is-medium{font-size:var(--bulma-size-medium)}.pagination.is-large{font-size:var(--bulma-size-large)}.pagination.is-rounded .pagination-previous,.pagination.is-rounded .pagination-next{border-radius:var(--bulma-radius-rounded);padding-left:1em;padding-right:1em}.pagination.is-rounded .pagination-link{border-radius:var(--bulma-radius-rounded)}.pagination,.pagination-list{text-align:center;justify-content:center;align-items:center;display:flex}.pagination-previous,.pagination-next,.pagination-link,.pagination-ellipsis{color:hsl(var(--bulma-pagination-item-h),var(--bulma-pagination-item-s),var(--bulma-pagination-item-color-l));font-size:var(--bulma-pagination-item-font-size);margin:var(--bulma-pagination-item-margin);padding-left:var(--bulma-pagination-item-padding-left);padding-right:var(--bulma-pagination-item-padding-right);text-align:center;justify-content:center}.pagination-previous,.pagination-next,.pagination-link{background-color:hsl(var(--bulma-pagination-item-h),var(--bulma-pagination-item-s),calc(var(--bulma-pagination-item-background-l) + var(--bulma-pagination-item-background-l-delta)));border-color:hsl(var(--bulma-pagination-item-h),var(--bulma-pagination-item-s),calc(var(--bulma-pagination-item-border-l) + var(--bulma-pagination-item-border-l-delta)));border-style:var(--bulma-pagination-item-border-style);border-width:var(--bulma-pagination-item-border-width);box-shadow:0px .0625em .125em hsla(var(--bulma-pagination-item-outer-shadow-h),var(--bulma-pagination-item-outer-shadow-s),var(--bulma-pagination-item-outer-shadow-l),var(--bulma-pagination-item-outer-shadow-a)),0px .125em .25em hsla(var(--bulma-pagination-item-outer-shadow-h),var(--bulma-pagination-item-outer-shadow-s),var(--bulma-pagination-item-outer-shadow-l),var(--bulma-pagination-item-outer-shadow-a));color:hsl(var(--bulma-pagination-item-h),var(--bulma-pagination-item-s),var(--bulma-pagination-item-color-l));min-width:var(--bulma-pagination-min-width);transition-duration:var(--bulma-duration);transition-property:background-color,border-color,box-shadow,color}.pagination-previous:hover,.pagination-next:hover,.pagination-link:hover,.pagination-previous:focus,.pagination-next:focus,.pagination-link:focus{--bulma-pagination-item-background-l-delta:var(--bulma-pagination-item-hover-background-l-delta);--bulma-pagination-item-border-l-delta:var(--bulma-pagination-item-hover-border-l-delta)}.pagination-previous:active,.pagination-next:active,.pagination-link:active{box-shadow:var(--bulma-pagination-shadow-inset)}.pagination-previous[disabled],.pagination-previous.is-disabled,.pagination-next[disabled],.pagination-next.is-disabled,.pagination-link[disabled],.pagination-link.is-disabled{background-color:var(--bulma-pagination-disabled-background-color);border-color:var(--bulma-pagination-disabled-border-color);box-shadow:none;color:var(--bulma-pagination-disabled-color);opacity:.5}.pagination-previous,.pagination-next{padding-left:var(--bulma-pagination-nav-padding-left);padding-right:var(--bulma-pagination-nav-padding-right);white-space:nowrap}.pagination-link.is-current,.pagination-link.is-selected{--bulma-pagination-item-h:var(--bulma-pagination-selected-item-h);--bulma-pagination-item-s:var(--bulma-pagination-selected-item-s);--bulma-pagination-item-l:var(--bulma-pagination-selected-item-l);--bulma-pagination-item-background-l:var(--bulma-pagination-selected-item-background-l);--bulma-pagination-item-border-l:var(--bulma-pagination-selected-item-border-l);--bulma-pagination-item-color-l:var(--bulma-pagination-selected-item-color-l)}.pagination-ellipsis{color:var(--bulma-pagination-ellipsis-color);pointer-events:none}.pagination-list{flex-wrap:wrap}.pagination-list li{list-style:none}@media screen and (width<=768px){.pagination{flex-wrap:wrap}.pagination-previous,.pagination-next,.pagination-list li{flex-grow:1;flex-shrink:1}}@media screen and (width>=769px),print{.pagination-list{flex-grow:1;flex-shrink:1;order:1;justify-content:flex-start}.pagination-previous,.pagination-next,.pagination-link,.pagination-ellipsis{margin-top:0;margin-bottom:0}.pagination-previous{order:2}.pagination-next{order:3}.pagination{justify-content:space-between;margin-top:0;margin-bottom:0}.pagination.is-centered .pagination-previous{order:1}.pagination.is-centered .pagination-list{order:2;justify-content:center}.pagination.is-centered .pagination-next{order:3}.pagination.is-right .pagination-previous{order:1}.pagination.is-right .pagination-next{order:2}.pagination.is-right .pagination-list{order:3;justify-content:flex-end}}.panel{--bulma-panel-margin:var(--bulma-block-spacing);--bulma-panel-item-border:1px solid var(--bulma-border-weak);--bulma-panel-radius:var(--bulma-radius-large);--bulma-panel-shadow:var(--bulma-shadow);--bulma-panel-heading-line-height:1.25;--bulma-panel-heading-padding:1em 1.25em;--bulma-panel-heading-radius:var(--bulma-radius);--bulma-panel-heading-size:1.25em;--bulma-panel-heading-weight:var(--bulma-weight-bold);--bulma-panel-tabs-font-size:1em;--bulma-panel-tab-border-bottom-color:var(--bulma-border);--bulma-panel-tab-border-bottom-style:solid;--bulma-panel-tab-border-bottom-width:1px;--bulma-panel-tab-active-color:var(--bulma-link-active);--bulma-panel-list-item-color:var(--bulma-text);--bulma-panel-list-item-hover-color:var(--bulma-link);--bulma-panel-block-color:var(--bulma-text-strong);--bulma-panel-block-hover-background-color:var(--bulma-background);--bulma-panel-block-active-border-left-color:var(--bulma-link);--bulma-panel-block-active-color:var(--bulma-link-active);--bulma-panel-block-active-icon-color:var(--bulma-link);--bulma-panel-icon-color:var(--bulma-text-weak);--bulma-panel-h:var(--bulma-scheme-h);--bulma-panel-s:var(--bulma-scheme-s);--bulma-panel-color-l:var(--bulma-text-l);--bulma-panel-heading-background-l:var(--bulma-text-l);--bulma-panel-heading-color-l:var(--bulma-text-invert-l);border-radius:var(--bulma-panel-radius);box-shadow:var(--bulma-panel-shadow);font-size:var(--bulma-size-normal)}.panel:not(:last-child){margin-bottom:var(--bulma-panel-margin)}.panel.is-white{--bulma-panel-h:var(--bulma-white-h);--bulma-panel-s:var(--bulma-white-s);--bulma-panel-color-l:var(--bulma-white-l);--bulma-panel-heading-background-l:var(--bulma-white-l);--bulma-panel-heading-color-l:var(--bulma-white-invert-l)}.panel.is-black{--bulma-panel-h:var(--bulma-black-h);--bulma-panel-s:var(--bulma-black-s);--bulma-panel-color-l:var(--bulma-black-l);--bulma-panel-heading-background-l:var(--bulma-black-l);--bulma-panel-heading-color-l:var(--bulma-black-invert-l)}.panel.is-light{--bulma-panel-h:var(--bulma-light-h);--bulma-panel-s:var(--bulma-light-s);--bulma-panel-color-l:var(--bulma-light-l);--bulma-panel-heading-background-l:var(--bulma-light-l);--bulma-panel-heading-color-l:var(--bulma-light-invert-l)}.panel.is-dark{--bulma-panel-h:var(--bulma-dark-h);--bulma-panel-s:var(--bulma-dark-s);--bulma-panel-color-l:var(--bulma-dark-l);--bulma-panel-heading-background-l:var(--bulma-dark-l);--bulma-panel-heading-color-l:var(--bulma-dark-invert-l)}.panel.is-text{--bulma-panel-h:var(--bulma-text-h);--bulma-panel-s:var(--bulma-text-s);--bulma-panel-color-l:var(--bulma-text-l);--bulma-panel-heading-background-l:var(--bulma-text-l);--bulma-panel-heading-color-l:var(--bulma-text-invert-l)}.panel.is-primary{--bulma-panel-h:var(--bulma-primary-h);--bulma-panel-s:var(--bulma-primary-s);--bulma-panel-color-l:var(--bulma-primary-l);--bulma-panel-heading-background-l:var(--bulma-primary-l);--bulma-panel-heading-color-l:var(--bulma-primary-invert-l)}.panel.is-link{--bulma-panel-h:var(--bulma-link-h);--bulma-panel-s:var(--bulma-link-s);--bulma-panel-color-l:var(--bulma-link-l);--bulma-panel-heading-background-l:var(--bulma-link-l);--bulma-panel-heading-color-l:var(--bulma-link-invert-l)}.panel.is-info{--bulma-panel-h:var(--bulma-info-h);--bulma-panel-s:var(--bulma-info-s);--bulma-panel-color-l:var(--bulma-info-l);--bulma-panel-heading-background-l:var(--bulma-info-l);--bulma-panel-heading-color-l:var(--bulma-info-invert-l)}.panel.is-success{--bulma-panel-h:var(--bulma-success-h);--bulma-panel-s:var(--bulma-success-s);--bulma-panel-color-l:var(--bulma-success-l);--bulma-panel-heading-background-l:var(--bulma-success-l);--bulma-panel-heading-color-l:var(--bulma-success-invert-l)}.panel.is-warning{--bulma-panel-h:var(--bulma-warning-h);--bulma-panel-s:var(--bulma-warning-s);--bulma-panel-color-l:var(--bulma-warning-l);--bulma-panel-heading-background-l:var(--bulma-warning-l);--bulma-panel-heading-color-l:var(--bulma-warning-invert-l)}.panel.is-danger{--bulma-panel-h:var(--bulma-danger-h);--bulma-panel-s:var(--bulma-danger-s);--bulma-panel-color-l:var(--bulma-danger-l);--bulma-panel-heading-background-l:var(--bulma-danger-l);--bulma-panel-heading-color-l:var(--bulma-danger-invert-l)}.panel-tabs:not(:last-child),.panel-block:not(:last-child){border-bottom:var(--bulma-panel-item-border)}.panel-heading{background-color:hsl(var(--bulma-panel-h),var(--bulma-panel-s),var(--bulma-panel-heading-background-l));border-radius:var(--bulma-panel-radius)var(--bulma-panel-radius)0 0;color:hsl(var(--bulma-panel-h),var(--bulma-panel-s),var(--bulma-panel-heading-color-l));font-size:var(--bulma-panel-heading-size);font-weight:var(--bulma-panel-heading-weight);line-height:var(--bulma-panel-heading-line-height);padding:var(--bulma-panel-heading-padding)}.panel-tabs{font-size:var(--bulma-panel-tabs-font-size);justify-content:center;align-items:flex-end;display:flex}.panel-tabs a{border-bottom-color:var(--bulma-panel-tab-border-bottom-color);border-bottom-style:var(--bulma-panel-tab-border-bottom-style);border-bottom-width:var(--bulma-panel-tab-border-bottom-width);margin-bottom:-1px;padding:.75em}.panel-tabs a.is-active{border-bottom-color:hsl(var(--bulma-panel-h),var(--bulma-panel-s),var(--bulma-panel-color-l));color:var(--bulma-panel-tab-active-color)}.panel-list a{color:var(--bulma-panel-list-item-color)}.panel-list a:hover{color:var(--bulma-panel-list-item-hover-color)}.panel-block{color:var(--bulma-panel-block-color);justify-content:flex-start;align-items:center;padding:.75em 1em;display:flex}.panel-block input[type=checkbox]{margin-inline-end:.75em}.panel-block>.control{flex-grow:1;flex-shrink:1;width:100%}.panel-block.is-wrapped{flex-wrap:wrap}.panel-block.is-active{border-left-color:var(--bulma-panel-block-active-border-left-color);color:var(--bulma-panel-block-active-color)}.panel-block.is-active .panel-icon{color:hsl(var(--bulma-panel-h),var(--bulma-panel-s),var(--bulma-panel-color-l))}.panel-block:last-child{border-end-end-radius:var(--bulma-panel-radius);border-end-start-radius:var(--bulma-panel-radius)}a.panel-block,label.panel-block{cursor:pointer}a.panel-block:hover,label.panel-block:hover{background-color:var(--bulma-panel-block-hover-background-color)}.panel-icon{text-align:center;vertical-align:top;color:var(--bulma-panel-icon-color);width:1em;height:1em;margin-inline-end:.75em;font-size:1em;line-height:1em;display:inline-block}.panel-icon .fa{font-size:inherit;line-height:inherit}.tabs{--bulma-tabs-border-bottom-color:var(--bulma-border);--bulma-tabs-border-bottom-style:solid;--bulma-tabs-border-bottom-width:1px;--bulma-tabs-link-color:var(--bulma-text);--bulma-tabs-link-hover-border-bottom-color:var(--bulma-text-strong);--bulma-tabs-link-hover-color:var(--bulma-text-strong);--bulma-tabs-link-active-border-bottom-color:var(--bulma-link-text);--bulma-tabs-link-active-color:var(--bulma-link-text);--bulma-tabs-link-padding:.5em 1em;--bulma-tabs-boxed-link-radius:var(--bulma-radius);--bulma-tabs-boxed-link-hover-background-color:var(--bulma-background);--bulma-tabs-boxed-link-hover-border-bottom-color:var(--bulma-border);--bulma-tabs-boxed-link-active-background-color:var(--bulma-scheme-main);--bulma-tabs-boxed-link-active-border-color:var(--bulma-border);--bulma-tabs-boxed-link-active-border-bottom-color:transparent;--bulma-tabs-toggle-link-border-color:var(--bulma-border);--bulma-tabs-toggle-link-border-style:solid;--bulma-tabs-toggle-link-border-width:1px;--bulma-tabs-toggle-link-hover-background-color:var(--bulma-background);--bulma-tabs-toggle-link-hover-border-color:var(--bulma-border-hover);--bulma-tabs-toggle-link-radius:var(--bulma-radius);--bulma-tabs-toggle-link-active-background-color:var(--bulma-link);--bulma-tabs-toggle-link-active-border-color:var(--bulma-link);--bulma-tabs-toggle-link-active-color:var(--bulma-link-invert);-webkit-overflow-scrolling:touch;font-size:var(--bulma-size-normal);white-space:nowrap;justify-content:space-between;align-items:stretch;display:flex;overflow:auto hidden}.tabs a{border-bottom-color:var(--bulma-tabs-border-bottom-color);border-bottom-style:var(--bulma-tabs-border-bottom-style);border-bottom-width:var(--bulma-tabs-border-bottom-width);color:var(--bulma-tabs-link-color);margin-bottom:calc(-1*var(--bulma-tabs-border-bottom-width));padding:var(--bulma-tabs-link-padding);transition-duration:var(--bulma-duration);vertical-align:top;justify-content:center;align-items:center;transition-property:background-color,border-color,color;display:flex}.tabs a:hover{border-bottom-color:var(--bulma-tabs-link-hover-border-bottom-color);color:var(--bulma-tabs-link-hover-color)}.tabs li{display:block}.tabs li.is-active a{border-bottom-color:var(--bulma-tabs-link-active-border-bottom-color);color:var(--bulma-tabs-link-active-color)}.tabs ul{border-bottom-color:var(--bulma-tabs-border-bottom-color);border-bottom-style:var(--bulma-tabs-border-bottom-style);border-bottom-width:var(--bulma-tabs-border-bottom-width);flex-grow:1;flex-shrink:0;justify-content:flex-start;align-items:center;display:flex}.tabs ul.is-left{padding-right:.75em}.tabs ul.is-center{flex:none;justify-content:center;padding-left:.75em;padding-right:.75em}.tabs ul.is-right{justify-content:flex-end;padding-left:.75em}.tabs .icon:first-child{margin-inline-end:.5em}.tabs .icon:last-child{margin-inline-start:.5em}.tabs.is-centered ul{justify-content:center}.tabs.is-right ul{justify-content:flex-end}.tabs.is-boxed a{border:1px solid #0000;border-start-start-radius:var(--bulma-tabs-boxed-link-radius);border-start-end-radius:var(--bulma-tabs-boxed-link-radius)}.tabs.is-boxed a:hover{background-color:var(--bulma-tabs-boxed-link-hover-background-color);border-bottom-color:var(--bulma-tabs-boxed-link-hover-border-bottom-color)}.tabs.is-boxed li.is-active a{background-color:var(--bulma-tabs-boxed-link-active-background-color);border-color:var(--bulma-tabs-boxed-link-active-border-color);border-bottom-color:var(--bulma-tabs-boxed-link-active-border-bottom-color)!important}.tabs.is-fullwidth li{flex-grow:1;flex-shrink:0}.tabs.is-toggle a{border-color:var(--bulma-tabs-toggle-link-border-color);border-style:var(--bulma-tabs-toggle-link-border-style);border-width:var(--bulma-tabs-toggle-link-border-width);margin-bottom:0;position:relative}.tabs.is-toggle a:hover{background-color:var(--bulma-tabs-toggle-link-hover-background-color);border-color:var(--bulma-tabs-toggle-link-hover-border-color);z-index:2}.tabs.is-toggle li+li{margin-inline-start:calc(-1*var(--bulma-tabs-toggle-link-border-width))}.tabs.is-toggle li:first-child a{border-start-start-radius:var(--bulma-tabs-toggle-link-radius);border-end-start-radius:var(--bulma-tabs-toggle-link-radius)}.tabs.is-toggle li:last-child a{border-start-end-radius:var(--bulma-tabs-toggle-link-radius);border-end-end-radius:var(--bulma-tabs-toggle-link-radius)}.tabs.is-toggle li.is-active a{background-color:var(--bulma-tabs-toggle-link-active-background-color);border-color:var(--bulma-tabs-toggle-link-active-border-color);color:var(--bulma-tabs-toggle-link-active-color);z-index:1}.tabs.is-toggle ul{border-bottom:none}.tabs.is-toggle.is-toggle-rounded li:first-child a{border-start-start-radius:var(--bulma-radius-rounded);border-end-start-radius:var(--bulma-radius-rounded);padding-inline-start:1.25em}.tabs.is-toggle.is-toggle-rounded li:last-child a{border-start-end-radius:var(--bulma-radius-rounded);border-end-end-radius:var(--bulma-radius-rounded);padding-inline-end:1.25em}.tabs.is-small{font-size:var(--bulma-size-small)}.tabs.is-medium{font-size:var(--bulma-size-medium)}.tabs.is-large{font-size:var(--bulma-size-large)}:root{--bulma-column-gap:.75rem}.column{padding:var(--bulma-column-gap);flex:1 1 0;display:block}.columns.is-mobile>.column.is-narrow{width:unset;flex:none}.columns.is-mobile>.column.is-full{flex:none;width:100%}.columns.is-mobile>.column.is-three-quarters{flex:none;width:75%}.columns.is-mobile>.column.is-two-thirds{flex:none;width:66.6666%}.columns.is-mobile>.column.is-half{flex:none;width:50%}.columns.is-mobile>.column.is-one-third{flex:none;width:33.3333%}.columns.is-mobile>.column.is-one-quarter{flex:none;width:25%}.columns.is-mobile>.column.is-one-fifth{flex:none;width:20%}.columns.is-mobile>.column.is-two-fifths{flex:none;width:40%}.columns.is-mobile>.column.is-three-fifths{flex:none;width:60%}.columns.is-mobile>.column.is-four-fifths{flex:none;width:80%}.columns.is-mobile>.column.is-offset-three-quarters{margin-inline-start:75%}.columns.is-mobile>.column.is-offset-two-thirds{margin-inline-start:66.6666%}.columns.is-mobile>.column.is-offset-half{margin-inline-start:50%}.columns.is-mobile>.column.is-offset-one-third{margin-inline-start:.3333%}.columns.is-mobile>.column.is-offset-one-quarter{margin-inline-start:25%}.columns.is-mobile>.column.is-offset-one-fifth{margin-inline-start:20%}.columns.is-mobile>.column.is-offset-two-fifths{margin-inline-start:40%}.columns.is-mobile>.column.is-offset-three-fifths{margin-inline-start:60%}.columns.is-mobile>.column.is-offset-four-fifths{margin-inline-start:80%}.columns.is-mobile>.column.is-0{flex:none;width:0%}.columns.is-mobile>.column.is-offset-0{margin-inline-start:0%}.columns.is-mobile>.column.is-1{flex:none;width:8.33333%}.columns.is-mobile>.column.is-offset-1{margin-inline-start:8.33333%}.columns.is-mobile>.column.is-2{flex:none;width:16.6667%}.columns.is-mobile>.column.is-offset-2{margin-inline-start:16.6667%}.columns.is-mobile>.column.is-3{flex:none;width:25%}.columns.is-mobile>.column.is-offset-3{margin-inline-start:25%}.columns.is-mobile>.column.is-4{flex:none;width:33.3333%}.columns.is-mobile>.column.is-offset-4{margin-inline-start:33.3333%}.columns.is-mobile>.column.is-5{flex:none;width:41.6667%}.columns.is-mobile>.column.is-offset-5{margin-inline-start:41.6667%}.columns.is-mobile>.column.is-6{flex:none;width:50%}.columns.is-mobile>.column.is-offset-6{margin-inline-start:50%}.columns.is-mobile>.column.is-7{flex:none;width:58.3333%}.columns.is-mobile>.column.is-offset-7{margin-inline-start:58.3333%}.columns.is-mobile>.column.is-8{flex:none;width:66.6667%}.columns.is-mobile>.column.is-offset-8{margin-inline-start:66.6667%}.columns.is-mobile>.column.is-9{flex:none;width:75%}.columns.is-mobile>.column.is-offset-9{margin-inline-start:75%}.columns.is-mobile>.column.is-10{flex:none;width:83.3333%}.columns.is-mobile>.column.is-offset-10{margin-inline-start:83.3333%}.columns.is-mobile>.column.is-11{flex:none;width:91.6667%}.columns.is-mobile>.column.is-offset-11{margin-inline-start:91.6667%}.columns.is-mobile>.column.is-12{flex:none;width:100%}.columns.is-mobile>.column.is-offset-12{margin-inline-start:100%}@media screen and (width<=768px){.column.is-narrow-mobile{width:unset;flex:none}.column.is-full-mobile{flex:none;width:100%}.column.is-three-quarters-mobile{flex:none;width:75%}.column.is-two-thirds-mobile{flex:none;width:66.6666%}.column.is-half-mobile{flex:none;width:50%}.column.is-one-third-mobile{flex:none;width:33.3333%}.column.is-one-quarter-mobile{flex:none;width:25%}.column.is-one-fifth-mobile{flex:none;width:20%}.column.is-two-fifths-mobile{flex:none;width:40%}.column.is-three-fifths-mobile{flex:none;width:60%}.column.is-four-fifths-mobile{flex:none;width:80%}.column.is-offset-three-quarters-mobile{margin-inline-start:75%}.column.is-offset-two-thirds-mobile{margin-inline-start:66.6666%}.column.is-offset-half-mobile{margin-inline-start:50%}.column.is-offset-one-third-mobile{margin-inline-start:.3333%}.column.is-offset-one-quarter-mobile{margin-inline-start:25%}.column.is-offset-one-fifth-mobile{margin-inline-start:20%}.column.is-offset-two-fifths-mobile{margin-inline-start:40%}.column.is-offset-three-fifths-mobile{margin-inline-start:60%}.column.is-offset-four-fifths-mobile{margin-inline-start:80%}.column.is-0-mobile{flex:none;width:0%}.column.is-offset-0-mobile{margin-inline-start:0%}.column.is-1-mobile{flex:none;width:8.33333%}.column.is-offset-1-mobile{margin-inline-start:8.33333%}.column.is-2-mobile{flex:none;width:16.6667%}.column.is-offset-2-mobile{margin-inline-start:16.6667%}.column.is-3-mobile{flex:none;width:25%}.column.is-offset-3-mobile{margin-inline-start:25%}.column.is-4-mobile{flex:none;width:33.3333%}.column.is-offset-4-mobile{margin-inline-start:33.3333%}.column.is-5-mobile{flex:none;width:41.6667%}.column.is-offset-5-mobile{margin-inline-start:41.6667%}.column.is-6-mobile{flex:none;width:50%}.column.is-offset-6-mobile{margin-inline-start:50%}.column.is-7-mobile{flex:none;width:58.3333%}.column.is-offset-7-mobile{margin-inline-start:58.3333%}.column.is-8-mobile{flex:none;width:66.6667%}.column.is-offset-8-mobile{margin-inline-start:66.6667%}.column.is-9-mobile{flex:none;width:75%}.column.is-offset-9-mobile{margin-inline-start:75%}.column.is-10-mobile{flex:none;width:83.3333%}.column.is-offset-10-mobile{margin-inline-start:83.3333%}.column.is-11-mobile{flex:none;width:91.6667%}.column.is-offset-11-mobile{margin-inline-start:91.6667%}.column.is-12-mobile{flex:none;width:100%}.column.is-offset-12-mobile{margin-inline-start:100%}}@media screen and (width>=769px),print{.column.is-narrow,.column.is-narrow-tablet{width:unset;flex:none}.column.is-full,.column.is-full-tablet{flex:none;width:100%}.column.is-three-quarters,.column.is-three-quarters-tablet{flex:none;width:75%}.column.is-two-thirds,.column.is-two-thirds-tablet{flex:none;width:66.6666%}.column.is-half,.column.is-half-tablet{flex:none;width:50%}.column.is-one-third,.column.is-one-third-tablet{flex:none;width:33.3333%}.column.is-one-quarter,.column.is-one-quarter-tablet{flex:none;width:25%}.column.is-one-fifth,.column.is-one-fifth-tablet{flex:none;width:20%}.column.is-two-fifths,.column.is-two-fifths-tablet{flex:none;width:40%}.column.is-three-fifths,.column.is-three-fifths-tablet{flex:none;width:60%}.column.is-four-fifths,.column.is-four-fifths-tablet{flex:none;width:80%}.column.is-offset-three-quarters,.column.is-offset-three-quarters-tablet{margin-inline-start:75%}.column.is-offset-two-thirds,.column.is-offset-two-thirds-tablet{margin-inline-start:66.6666%}.column.is-offset-half,.column.is-offset-half-tablet{margin-inline-start:50%}.column.is-offset-one-third,.column.is-offset-one-third-tablet{margin-inline-start:.3333%}.column.is-offset-one-quarter,.column.is-offset-one-quarter-tablet{margin-inline-start:25%}.column.is-offset-one-fifth,.column.is-offset-one-fifth-tablet{margin-inline-start:20%}.column.is-offset-two-fifths,.column.is-offset-two-fifths-tablet{margin-inline-start:40%}.column.is-offset-three-fifths,.column.is-offset-three-fifths-tablet{margin-inline-start:60%}.column.is-offset-four-fifths,.column.is-offset-four-fifths-tablet{margin-inline-start:80%}.column.is-0,.column.is-0-tablet{flex:none;width:0%}.column.is-offset-0,.column.is-offset-0-tablet{margin-inline-start:0%}.column.is-1,.column.is-1-tablet{flex:none;width:8.33333%}.column.is-offset-1,.column.is-offset-1-tablet{margin-inline-start:8.33333%}.column.is-2,.column.is-2-tablet{flex:none;width:16.6667%}.column.is-offset-2,.column.is-offset-2-tablet{margin-inline-start:16.6667%}.column.is-3,.column.is-3-tablet{flex:none;width:25%}.column.is-offset-3,.column.is-offset-3-tablet{margin-inline-start:25%}.column.is-4,.column.is-4-tablet{flex:none;width:33.3333%}.column.is-offset-4,.column.is-offset-4-tablet{margin-inline-start:33.3333%}.column.is-5,.column.is-5-tablet{flex:none;width:41.6667%}.column.is-offset-5,.column.is-offset-5-tablet{margin-inline-start:41.6667%}.column.is-6,.column.is-6-tablet{flex:none;width:50%}.column.is-offset-6,.column.is-offset-6-tablet{margin-inline-start:50%}.column.is-7,.column.is-7-tablet{flex:none;width:58.3333%}.column.is-offset-7,.column.is-offset-7-tablet{margin-inline-start:58.3333%}.column.is-8,.column.is-8-tablet{flex:none;width:66.6667%}.column.is-offset-8,.column.is-offset-8-tablet{margin-inline-start:66.6667%}.column.is-9,.column.is-9-tablet{flex:none;width:75%}.column.is-offset-9,.column.is-offset-9-tablet{margin-inline-start:75%}.column.is-10,.column.is-10-tablet{flex:none;width:83.3333%}.column.is-offset-10,.column.is-offset-10-tablet{margin-inline-start:83.3333%}.column.is-11,.column.is-11-tablet{flex:none;width:91.6667%}.column.is-offset-11,.column.is-offset-11-tablet{margin-inline-start:91.6667%}.column.is-12,.column.is-12-tablet{flex:none;width:100%}.column.is-offset-12,.column.is-offset-12-tablet{margin-inline-start:100%}}@media screen and (width<=1023px){.column.is-narrow-touch{width:unset;flex:none}.column.is-full-touch{flex:none;width:100%}.column.is-three-quarters-touch{flex:none;width:75%}.column.is-two-thirds-touch{flex:none;width:66.6666%}.column.is-half-touch{flex:none;width:50%}.column.is-one-third-touch{flex:none;width:33.3333%}.column.is-one-quarter-touch{flex:none;width:25%}.column.is-one-fifth-touch{flex:none;width:20%}.column.is-two-fifths-touch{flex:none;width:40%}.column.is-three-fifths-touch{flex:none;width:60%}.column.is-four-fifths-touch{flex:none;width:80%}.column.is-offset-three-quarters-touch{margin-inline-start:75%}.column.is-offset-two-thirds-touch{margin-inline-start:66.6666%}.column.is-offset-half-touch{margin-inline-start:50%}.column.is-offset-one-third-touch{margin-inline-start:.3333%}.column.is-offset-one-quarter-touch{margin-inline-start:25%}.column.is-offset-one-fifth-touch{margin-inline-start:20%}.column.is-offset-two-fifths-touch{margin-inline-start:40%}.column.is-offset-three-fifths-touch{margin-inline-start:60%}.column.is-offset-four-fifths-touch{margin-inline-start:80%}.column.is-0-touch{flex:none;width:0%}.column.is-offset-0-touch{margin-inline-start:0%}.column.is-1-touch{flex:none;width:8.33333%}.column.is-offset-1-touch{margin-inline-start:8.33333%}.column.is-2-touch{flex:none;width:16.6667%}.column.is-offset-2-touch{margin-inline-start:16.6667%}.column.is-3-touch{flex:none;width:25%}.column.is-offset-3-touch{margin-inline-start:25%}.column.is-4-touch{flex:none;width:33.3333%}.column.is-offset-4-touch{margin-inline-start:33.3333%}.column.is-5-touch{flex:none;width:41.6667%}.column.is-offset-5-touch{margin-inline-start:41.6667%}.column.is-6-touch{flex:none;width:50%}.column.is-offset-6-touch{margin-inline-start:50%}.column.is-7-touch{flex:none;width:58.3333%}.column.is-offset-7-touch{margin-inline-start:58.3333%}.column.is-8-touch{flex:none;width:66.6667%}.column.is-offset-8-touch{margin-inline-start:66.6667%}.column.is-9-touch{flex:none;width:75%}.column.is-offset-9-touch{margin-inline-start:75%}.column.is-10-touch{flex:none;width:83.3333%}.column.is-offset-10-touch{margin-inline-start:83.3333%}.column.is-11-touch{flex:none;width:91.6667%}.column.is-offset-11-touch{margin-inline-start:91.6667%}.column.is-12-touch{flex:none;width:100%}.column.is-offset-12-touch{margin-inline-start:100%}}@media screen and (width>=1024px){.column.is-narrow-desktop{width:unset;flex:none}.column.is-full-desktop{flex:none;width:100%}.column.is-three-quarters-desktop{flex:none;width:75%}.column.is-two-thirds-desktop{flex:none;width:66.6666%}.column.is-half-desktop{flex:none;width:50%}.column.is-one-third-desktop{flex:none;width:33.3333%}.column.is-one-quarter-desktop{flex:none;width:25%}.column.is-one-fifth-desktop{flex:none;width:20%}.column.is-two-fifths-desktop{flex:none;width:40%}.column.is-three-fifths-desktop{flex:none;width:60%}.column.is-four-fifths-desktop{flex:none;width:80%}.column.is-offset-three-quarters-desktop{margin-inline-start:75%}.column.is-offset-two-thirds-desktop{margin-inline-start:66.6666%}.column.is-offset-half-desktop{margin-inline-start:50%}.column.is-offset-one-third-desktop{margin-inline-start:.3333%}.column.is-offset-one-quarter-desktop{margin-inline-start:25%}.column.is-offset-one-fifth-desktop{margin-inline-start:20%}.column.is-offset-two-fifths-desktop{margin-inline-start:40%}.column.is-offset-three-fifths-desktop{margin-inline-start:60%}.column.is-offset-four-fifths-desktop{margin-inline-start:80%}.column.is-0-desktop{flex:none;width:0%}.column.is-offset-0-desktop{margin-inline-start:0%}.column.is-1-desktop{flex:none;width:8.33333%}.column.is-offset-1-desktop{margin-inline-start:8.33333%}.column.is-2-desktop{flex:none;width:16.6667%}.column.is-offset-2-desktop{margin-inline-start:16.6667%}.column.is-3-desktop{flex:none;width:25%}.column.is-offset-3-desktop{margin-inline-start:25%}.column.is-4-desktop{flex:none;width:33.3333%}.column.is-offset-4-desktop{margin-inline-start:33.3333%}.column.is-5-desktop{flex:none;width:41.6667%}.column.is-offset-5-desktop{margin-inline-start:41.6667%}.column.is-6-desktop{flex:none;width:50%}.column.is-offset-6-desktop{margin-inline-start:50%}.column.is-7-desktop{flex:none;width:58.3333%}.column.is-offset-7-desktop{margin-inline-start:58.3333%}.column.is-8-desktop{flex:none;width:66.6667%}.column.is-offset-8-desktop{margin-inline-start:66.6667%}.column.is-9-desktop{flex:none;width:75%}.column.is-offset-9-desktop{margin-inline-start:75%}.column.is-10-desktop{flex:none;width:83.3333%}.column.is-offset-10-desktop{margin-inline-start:83.3333%}.column.is-11-desktop{flex:none;width:91.6667%}.column.is-offset-11-desktop{margin-inline-start:91.6667%}.column.is-12-desktop{flex:none;width:100%}.column.is-offset-12-desktop{margin-inline-start:100%}}@media screen and (width>=1216px){.column.is-narrow-widescreen{width:unset;flex:none}.column.is-full-widescreen{flex:none;width:100%}.column.is-three-quarters-widescreen{flex:none;width:75%}.column.is-two-thirds-widescreen{flex:none;width:66.6666%}.column.is-half-widescreen{flex:none;width:50%}.column.is-one-third-widescreen{flex:none;width:33.3333%}.column.is-one-quarter-widescreen{flex:none;width:25%}.column.is-one-fifth-widescreen{flex:none;width:20%}.column.is-two-fifths-widescreen{flex:none;width:40%}.column.is-three-fifths-widescreen{flex:none;width:60%}.column.is-four-fifths-widescreen{flex:none;width:80%}.column.is-offset-three-quarters-widescreen{margin-inline-start:75%}.column.is-offset-two-thirds-widescreen{margin-inline-start:66.6666%}.column.is-offset-half-widescreen{margin-inline-start:50%}.column.is-offset-one-third-widescreen{margin-inline-start:.3333%}.column.is-offset-one-quarter-widescreen{margin-inline-start:25%}.column.is-offset-one-fifth-widescreen{margin-inline-start:20%}.column.is-offset-two-fifths-widescreen{margin-inline-start:40%}.column.is-offset-three-fifths-widescreen{margin-inline-start:60%}.column.is-offset-four-fifths-widescreen{margin-inline-start:80%}.column.is-0-widescreen{flex:none;width:0%}.column.is-offset-0-widescreen{margin-inline-start:0%}.column.is-1-widescreen{flex:none;width:8.33333%}.column.is-offset-1-widescreen{margin-inline-start:8.33333%}.column.is-2-widescreen{flex:none;width:16.6667%}.column.is-offset-2-widescreen{margin-inline-start:16.6667%}.column.is-3-widescreen{flex:none;width:25%}.column.is-offset-3-widescreen{margin-inline-start:25%}.column.is-4-widescreen{flex:none;width:33.3333%}.column.is-offset-4-widescreen{margin-inline-start:33.3333%}.column.is-5-widescreen{flex:none;width:41.6667%}.column.is-offset-5-widescreen{margin-inline-start:41.6667%}.column.is-6-widescreen{flex:none;width:50%}.column.is-offset-6-widescreen{margin-inline-start:50%}.column.is-7-widescreen{flex:none;width:58.3333%}.column.is-offset-7-widescreen{margin-inline-start:58.3333%}.column.is-8-widescreen{flex:none;width:66.6667%}.column.is-offset-8-widescreen{margin-inline-start:66.6667%}.column.is-9-widescreen{flex:none;width:75%}.column.is-offset-9-widescreen{margin-inline-start:75%}.column.is-10-widescreen{flex:none;width:83.3333%}.column.is-offset-10-widescreen{margin-inline-start:83.3333%}.column.is-11-widescreen{flex:none;width:91.6667%}.column.is-offset-11-widescreen{margin-inline-start:91.6667%}.column.is-12-widescreen{flex:none;width:100%}.column.is-offset-12-widescreen{margin-inline-start:100%}}@media screen and (width>=1408px){.column.is-narrow-fullhd{width:unset;flex:none}.column.is-full-fullhd{flex:none;width:100%}.column.is-three-quarters-fullhd{flex:none;width:75%}.column.is-two-thirds-fullhd{flex:none;width:66.6666%}.column.is-half-fullhd{flex:none;width:50%}.column.is-one-third-fullhd{flex:none;width:33.3333%}.column.is-one-quarter-fullhd{flex:none;width:25%}.column.is-one-fifth-fullhd{flex:none;width:20%}.column.is-two-fifths-fullhd{flex:none;width:40%}.column.is-three-fifths-fullhd{flex:none;width:60%}.column.is-four-fifths-fullhd{flex:none;width:80%}.column.is-offset-three-quarters-fullhd{margin-inline-start:75%}.column.is-offset-two-thirds-fullhd{margin-inline-start:66.6666%}.column.is-offset-half-fullhd{margin-inline-start:50%}.column.is-offset-one-third-fullhd{margin-inline-start:33.3333%}.column.is-offset-one-quarter-fullhd{margin-inline-start:25%}.column.is-offset-one-fifth-fullhd{margin-inline-start:20%}.column.is-offset-two-fifths-fullhd{margin-inline-start:40%}.column.is-offset-three-fifths-fullhd{margin-inline-start:60%}.column.is-offset-four-fifths-fullhd{margin-inline-start:80%}.column.is-0-fullhd{flex:none;width:0%}.column.is-offset-0-fullhd{margin-inline-start:0%}.column.is-1-fullhd{flex:none;width:8.33333%}.column.is-offset-1-fullhd{margin-inline-start:8.33333%}.column.is-2-fullhd{flex:none;width:16.6667%}.column.is-offset-2-fullhd{margin-inline-start:16.6667%}.column.is-3-fullhd{flex:none;width:25%}.column.is-offset-3-fullhd{margin-inline-start:25%}.column.is-4-fullhd{flex:none;width:33.3333%}.column.is-offset-4-fullhd{margin-inline-start:33.3333%}.column.is-5-fullhd{flex:none;width:41.6667%}.column.is-offset-5-fullhd{margin-inline-start:41.6667%}.column.is-6-fullhd{flex:none;width:50%}.column.is-offset-6-fullhd{margin-inline-start:50%}.column.is-7-fullhd{flex:none;width:58.3333%}.column.is-offset-7-fullhd{margin-inline-start:58.3333%}.column.is-8-fullhd{flex:none;width:66.6667%}.column.is-offset-8-fullhd{margin-inline-start:66.6667%}.column.is-9-fullhd{flex:none;width:75%}.column.is-offset-9-fullhd{margin-inline-start:75%}.column.is-10-fullhd{flex:none;width:83.3333%}.column.is-offset-10-fullhd{margin-inline-start:83.3333%}.column.is-11-fullhd{flex:none;width:91.6667%}.column.is-offset-11-fullhd{margin-inline-start:91.6667%}.column.is-12-fullhd{flex:none;width:100%}.column.is-offset-12-fullhd{margin-inline-start:100%}}.columns{margin-inline-start:calc(-1*var(--bulma-column-gap));margin-inline-end:calc(-1*var(--bulma-column-gap));margin-top:calc(-1*var(--bulma-column-gap))}.columns:last-child{margin-bottom:calc(-1*var(--bulma-column-gap))}.columns:not(:last-child){margin-bottom:calc(var(--bulma-block-spacing) - var(--bulma-column-gap))}.columns.is-centered{justify-content:center}.columns.is-gapless{margin-inline:0;margin-top:0}.columns.is-gapless>.column{margin:0;padding:0!important}.columns.is-gapless:not(:last-child){margin-bottom:1.5rem}.columns.is-gapless:last-child{margin-bottom:0}.columns.is-mobile{display:flex}.columns.is-multiline{flex-wrap:wrap}.columns.is-vcentered{align-items:center}@media screen and (width>=769px),print{.columns:not(.is-desktop){display:flex}}@media screen and (width>=1024px){.columns.is-desktop{display:flex}}.columns.is-0{--bulma-column-gap:0rem}@media screen and (width<=768px){.columns.is-0-mobile{--bulma-column-gap:0rem}}@media screen and (width>=769px),print{.columns.is-0-tablet{--bulma-column-gap:0rem}}@media screen and (width>=769px) and (width<=1023px){.columns.is-0-tablet-only{--bulma-column-gap:0rem}}@media screen and (width<=1023px){.columns.is-0-touch{--bulma-column-gap:0rem}}@media screen and (width>=1024px){.columns.is-0-desktop{--bulma-column-gap:0rem}}@media screen and (width>=1024px) and (width<=1215px){.columns.is-0-desktop-only{--bulma-column-gap:0rem}}@media screen and (width>=1216px){.columns.is-0-widescreen{--bulma-column-gap:0rem}}@media screen and (width>=1216px) and (width<=1407px){.columns.is-0-widescreen-only{--bulma-column-gap:0rem}}@media screen and (width>=1408px){.columns.is-0-fullhd{--bulma-column-gap:0rem}}.columns.is-1{--bulma-column-gap:.25rem}@media screen and (width<=768px){.columns.is-1-mobile{--bulma-column-gap:.25rem}}@media screen and (width>=769px),print{.columns.is-1-tablet{--bulma-column-gap:.25rem}}@media screen and (width>=769px) and (width<=1023px){.columns.is-1-tablet-only{--bulma-column-gap:.25rem}}@media screen and (width<=1023px){.columns.is-1-touch{--bulma-column-gap:.25rem}}@media screen and (width>=1024px){.columns.is-1-desktop{--bulma-column-gap:.25rem}}@media screen and (width>=1024px) and (width<=1215px){.columns.is-1-desktop-only{--bulma-column-gap:.25rem}}@media screen and (width>=1216px){.columns.is-1-widescreen{--bulma-column-gap:.25rem}}@media screen and (width>=1216px) and (width<=1407px){.columns.is-1-widescreen-only{--bulma-column-gap:.25rem}}@media screen and (width>=1408px){.columns.is-1-fullhd{--bulma-column-gap:.25rem}}.columns.is-2{--bulma-column-gap:.5rem}@media screen and (width<=768px){.columns.is-2-mobile{--bulma-column-gap:.5rem}}@media screen and (width>=769px),print{.columns.is-2-tablet{--bulma-column-gap:.5rem}}@media screen and (width>=769px) and (width<=1023px){.columns.is-2-tablet-only{--bulma-column-gap:.5rem}}@media screen and (width<=1023px){.columns.is-2-touch{--bulma-column-gap:.5rem}}@media screen and (width>=1024px){.columns.is-2-desktop{--bulma-column-gap:.5rem}}@media screen and (width>=1024px) and (width<=1215px){.columns.is-2-desktop-only{--bulma-column-gap:.5rem}}@media screen and (width>=1216px){.columns.is-2-widescreen{--bulma-column-gap:.5rem}}@media screen and (width>=1216px) and (width<=1407px){.columns.is-2-widescreen-only{--bulma-column-gap:.5rem}}@media screen and (width>=1408px){.columns.is-2-fullhd{--bulma-column-gap:.5rem}}.columns.is-3{--bulma-column-gap:.75rem}@media screen and (width<=768px){.columns.is-3-mobile{--bulma-column-gap:.75rem}}@media screen and (width>=769px),print{.columns.is-3-tablet{--bulma-column-gap:.75rem}}@media screen and (width>=769px) and (width<=1023px){.columns.is-3-tablet-only{--bulma-column-gap:.75rem}}@media screen and (width<=1023px){.columns.is-3-touch{--bulma-column-gap:.75rem}}@media screen and (width>=1024px){.columns.is-3-desktop{--bulma-column-gap:.75rem}}@media screen and (width>=1024px) and (width<=1215px){.columns.is-3-desktop-only{--bulma-column-gap:.75rem}}@media screen and (width>=1216px){.columns.is-3-widescreen{--bulma-column-gap:.75rem}}@media screen and (width>=1216px) and (width<=1407px){.columns.is-3-widescreen-only{--bulma-column-gap:.75rem}}@media screen and (width>=1408px){.columns.is-3-fullhd{--bulma-column-gap:.75rem}}.columns.is-4{--bulma-column-gap:1rem}@media screen and (width<=768px){.columns.is-4-mobile{--bulma-column-gap:1rem}}@media screen and (width>=769px),print{.columns.is-4-tablet{--bulma-column-gap:1rem}}@media screen and (width>=769px) and (width<=1023px){.columns.is-4-tablet-only{--bulma-column-gap:1rem}}@media screen and (width<=1023px){.columns.is-4-touch{--bulma-column-gap:1rem}}@media screen and (width>=1024px){.columns.is-4-desktop{--bulma-column-gap:1rem}}@media screen and (width>=1024px) and (width<=1215px){.columns.is-4-desktop-only{--bulma-column-gap:1rem}}@media screen and (width>=1216px){.columns.is-4-widescreen{--bulma-column-gap:1rem}}@media screen and (width>=1216px) and (width<=1407px){.columns.is-4-widescreen-only{--bulma-column-gap:1rem}}@media screen and (width>=1408px){.columns.is-4-fullhd{--bulma-column-gap:1rem}}.columns.is-5{--bulma-column-gap:1.25rem}@media screen and (width<=768px){.columns.is-5-mobile{--bulma-column-gap:1.25rem}}@media screen and (width>=769px),print{.columns.is-5-tablet{--bulma-column-gap:1.25rem}}@media screen and (width>=769px) and (width<=1023px){.columns.is-5-tablet-only{--bulma-column-gap:1.25rem}}@media screen and (width<=1023px){.columns.is-5-touch{--bulma-column-gap:1.25rem}}@media screen and (width>=1024px){.columns.is-5-desktop{--bulma-column-gap:1.25rem}}@media screen and (width>=1024px) and (width<=1215px){.columns.is-5-desktop-only{--bulma-column-gap:1.25rem}}@media screen and (width>=1216px){.columns.is-5-widescreen{--bulma-column-gap:1.25rem}}@media screen and (width>=1216px) and (width<=1407px){.columns.is-5-widescreen-only{--bulma-column-gap:1.25rem}}@media screen and (width>=1408px){.columns.is-5-fullhd{--bulma-column-gap:1.25rem}}.columns.is-6{--bulma-column-gap:1.5rem}@media screen and (width<=768px){.columns.is-6-mobile{--bulma-column-gap:1.5rem}}@media screen and (width>=769px),print{.columns.is-6-tablet{--bulma-column-gap:1.5rem}}@media screen and (width>=769px) and (width<=1023px){.columns.is-6-tablet-only{--bulma-column-gap:1.5rem}}@media screen and (width<=1023px){.columns.is-6-touch{--bulma-column-gap:1.5rem}}@media screen and (width>=1024px){.columns.is-6-desktop{--bulma-column-gap:1.5rem}}@media screen and (width>=1024px) and (width<=1215px){.columns.is-6-desktop-only{--bulma-column-gap:1.5rem}}@media screen and (width>=1216px){.columns.is-6-widescreen{--bulma-column-gap:1.5rem}}@media screen and (width>=1216px) and (width<=1407px){.columns.is-6-widescreen-only{--bulma-column-gap:1.5rem}}@media screen and (width>=1408px){.columns.is-6-fullhd{--bulma-column-gap:1.5rem}}.columns.is-7{--bulma-column-gap:1.75rem}@media screen and (width<=768px){.columns.is-7-mobile{--bulma-column-gap:1.75rem}}@media screen and (width>=769px),print{.columns.is-7-tablet{--bulma-column-gap:1.75rem}}@media screen and (width>=769px) and (width<=1023px){.columns.is-7-tablet-only{--bulma-column-gap:1.75rem}}@media screen and (width<=1023px){.columns.is-7-touch{--bulma-column-gap:1.75rem}}@media screen and (width>=1024px){.columns.is-7-desktop{--bulma-column-gap:1.75rem}}@media screen and (width>=1024px) and (width<=1215px){.columns.is-7-desktop-only{--bulma-column-gap:1.75rem}}@media screen and (width>=1216px){.columns.is-7-widescreen{--bulma-column-gap:1.75rem}}@media screen and (width>=1216px) and (width<=1407px){.columns.is-7-widescreen-only{--bulma-column-gap:1.75rem}}@media screen and (width>=1408px){.columns.is-7-fullhd{--bulma-column-gap:1.75rem}}.columns.is-8{--bulma-column-gap:2rem}@media screen and (width<=768px){.columns.is-8-mobile{--bulma-column-gap:2rem}}@media screen and (width>=769px),print{.columns.is-8-tablet{--bulma-column-gap:2rem}}@media screen and (width>=769px) and (width<=1023px){.columns.is-8-tablet-only{--bulma-column-gap:2rem}}@media screen and (width<=1023px){.columns.is-8-touch{--bulma-column-gap:2rem}}@media screen and (width>=1024px){.columns.is-8-desktop{--bulma-column-gap:2rem}}@media screen and (width>=1024px) and (width<=1215px){.columns.is-8-desktop-only{--bulma-column-gap:2rem}}@media screen and (width>=1216px){.columns.is-8-widescreen{--bulma-column-gap:2rem}}@media screen and (width>=1216px) and (width<=1407px){.columns.is-8-widescreen-only{--bulma-column-gap:2rem}}@media screen and (width>=1408px){.columns.is-8-fullhd{--bulma-column-gap:2rem}}.fixed-grid{container:bulma-fixed-grid/inline-size}.fixed-grid>.grid{--bulma-grid-gap-count:calc(var(--bulma-grid-column-count) - 1);--bulma-grid-column-count:2;grid-template-columns:repeat(var(--bulma-grid-column-count),1fr)}.fixed-grid.has-1-cols>.grid{--bulma-grid-column-count:1}.fixed-grid.has-2-cols>.grid{--bulma-grid-column-count:2}.fixed-grid.has-3-cols>.grid{--bulma-grid-column-count:3}.fixed-grid.has-4-cols>.grid{--bulma-grid-column-count:4}.fixed-grid.has-5-cols>.grid{--bulma-grid-column-count:5}.fixed-grid.has-6-cols>.grid{--bulma-grid-column-count:6}.fixed-grid.has-7-cols>.grid{--bulma-grid-column-count:7}.fixed-grid.has-8-cols>.grid{--bulma-grid-column-count:8}.fixed-grid.has-9-cols>.grid{--bulma-grid-column-count:9}.fixed-grid.has-10-cols>.grid{--bulma-grid-column-count:10}.fixed-grid.has-11-cols>.grid{--bulma-grid-column-count:11}.fixed-grid.has-12-cols>.grid{--bulma-grid-column-count:12}@container bulma-fixed-grid (width<=768px){.fixed-grid.has-1-cols-mobile>.grid{--bulma-grid-column-count:1}.fixed-grid.has-2-cols-mobile>.grid{--bulma-grid-column-count:2}.fixed-grid.has-3-cols-mobile>.grid{--bulma-grid-column-count:3}.fixed-grid.has-4-cols-mobile>.grid{--bulma-grid-column-count:4}.fixed-grid.has-5-cols-mobile>.grid{--bulma-grid-column-count:5}.fixed-grid.has-6-cols-mobile>.grid{--bulma-grid-column-count:6}.fixed-grid.has-7-cols-mobile>.grid{--bulma-grid-column-count:7}.fixed-grid.has-8-cols-mobile>.grid{--bulma-grid-column-count:8}.fixed-grid.has-9-cols-mobile>.grid{--bulma-grid-column-count:9}.fixed-grid.has-10-cols-mobile>.grid{--bulma-grid-column-count:10}.fixed-grid.has-11-cols-mobile>.grid{--bulma-grid-column-count:11}.fixed-grid.has-12-cols-mobile>.grid{--bulma-grid-column-count:12}}@container bulma-fixed-grid (width>=769px){.fixed-grid.has-1-cols-tablet>.grid{--bulma-grid-column-count:1}.fixed-grid.has-2-cols-tablet>.grid{--bulma-grid-column-count:2}.fixed-grid.has-3-cols-tablet>.grid{--bulma-grid-column-count:3}.fixed-grid.has-4-cols-tablet>.grid{--bulma-grid-column-count:4}.fixed-grid.has-5-cols-tablet>.grid{--bulma-grid-column-count:5}.fixed-grid.has-6-cols-tablet>.grid{--bulma-grid-column-count:6}.fixed-grid.has-7-cols-tablet>.grid{--bulma-grid-column-count:7}.fixed-grid.has-8-cols-tablet>.grid{--bulma-grid-column-count:8}.fixed-grid.has-9-cols-tablet>.grid{--bulma-grid-column-count:9}.fixed-grid.has-10-cols-tablet>.grid{--bulma-grid-column-count:10}.fixed-grid.has-11-cols-tablet>.grid{--bulma-grid-column-count:11}.fixed-grid.has-12-cols-tablet>.grid{--bulma-grid-column-count:12}}@container bulma-fixed-grid (width>=1024px){.fixed-grid.has-1-cols-desktop>.grid{--bulma-grid-column-count:1}.fixed-grid.has-2-cols-desktop>.grid{--bulma-grid-column-count:2}.fixed-grid.has-3-cols-desktop>.grid{--bulma-grid-column-count:3}.fixed-grid.has-4-cols-desktop>.grid{--bulma-grid-column-count:4}.fixed-grid.has-5-cols-desktop>.grid{--bulma-grid-column-count:5}.fixed-grid.has-6-cols-desktop>.grid{--bulma-grid-column-count:6}.fixed-grid.has-7-cols-desktop>.grid{--bulma-grid-column-count:7}.fixed-grid.has-8-cols-desktop>.grid{--bulma-grid-column-count:8}.fixed-grid.has-9-cols-desktop>.grid{--bulma-grid-column-count:9}.fixed-grid.has-10-cols-desktop>.grid{--bulma-grid-column-count:10}.fixed-grid.has-11-cols-desktop>.grid{--bulma-grid-column-count:11}.fixed-grid.has-12-cols-desktop>.grid{--bulma-grid-column-count:12}}@container bulma-fixed-grid (width>=1216px){.fixed-grid.has-1-cols-widescreen>.grid{--bulma-grid-column-count:1}.fixed-grid.has-2-cols-widescreen>.grid{--bulma-grid-column-count:2}.fixed-grid.has-3-cols-widescreen>.grid{--bulma-grid-column-count:3}.fixed-grid.has-4-cols-widescreen>.grid{--bulma-grid-column-count:4}.fixed-grid.has-5-cols-widescreen>.grid{--bulma-grid-column-count:5}.fixed-grid.has-6-cols-widescreen>.grid{--bulma-grid-column-count:6}.fixed-grid.has-7-cols-widescreen>.grid{--bulma-grid-column-count:7}.fixed-grid.has-8-cols-widescreen>.grid{--bulma-grid-column-count:8}.fixed-grid.has-9-cols-widescreen>.grid{--bulma-grid-column-count:9}.fixed-grid.has-10-cols-widescreen>.grid{--bulma-grid-column-count:10}.fixed-grid.has-11-cols-widescreen>.grid{--bulma-grid-column-count:11}.fixed-grid.has-12-cols-widescreen>.grid{--bulma-grid-column-count:12}}@container bulma-fixed-grid (width>=1408px){.fixed-grid.has-1-cols-fullhd>.grid{--bulma-grid-column-count:1}.fixed-grid.has-2-cols-fullhd>.grid{--bulma-grid-column-count:2}.fixed-grid.has-3-cols-fullhd>.grid{--bulma-grid-column-count:3}.fixed-grid.has-4-cols-fullhd>.grid{--bulma-grid-column-count:4}.fixed-grid.has-5-cols-fullhd>.grid{--bulma-grid-column-count:5}.fixed-grid.has-6-cols-fullhd>.grid{--bulma-grid-column-count:6}.fixed-grid.has-7-cols-fullhd>.grid{--bulma-grid-column-count:7}.fixed-grid.has-8-cols-fullhd>.grid{--bulma-grid-column-count:8}.fixed-grid.has-9-cols-fullhd>.grid{--bulma-grid-column-count:9}.fixed-grid.has-10-cols-fullhd>.grid{--bulma-grid-column-count:10}.fixed-grid.has-11-cols-fullhd>.grid{--bulma-grid-column-count:11}.fixed-grid.has-12-cols-fullhd>.grid{--bulma-grid-column-count:12}}@container bulma-fixed-grid (width<=768px){.fixed-grid.has-auto-count .grid{--bulma-grid-column-count:2}}@container bulma-fixed-grid (width>=769px){.fixed-grid.has-auto-count .grid{--bulma-grid-column-count:4}}@container bulma-fixed-grid (width>=1024px){.fixed-grid.has-auto-count .grid{--bulma-grid-column-count:8}}@container bulma-fixed-grid (width>=1216px){.fixed-grid.has-auto-count .grid{--bulma-grid-column-count:12}}@container bulma-fixed-grid (width>=1408px){.fixed-grid.has-auto-count .grid{--bulma-grid-column-count:16}}.grid{--bulma-grid-gap:.75rem;--bulma-grid-column-min:9rem;--bulma-grid-cell-column-span:1;--bulma-grid-cell-row-span:1;gap:var(--bulma-grid-gap);column-gap:var(--bulma-grid-column-gap,var(--bulma-grid-gap));row-gap:var(--bulma-grid-row-gap,var(--bulma-grid-gap));grid-template-columns:repeat(auto-fit,minmax(var(--bulma-grid-column-min),1fr));grid-template-rows:auto;display:grid}.grid.is-auto-fill{grid-template-columns:repeat(auto-fill,minmax(var(--bulma-grid-column-min),1fr))}.grid.is-col-min-1{--bulma-grid-column-min:1.5rem}.grid.is-col-min-2{--bulma-grid-column-min:3rem}.grid.is-col-min-3{--bulma-grid-column-min:4.5rem}.grid.is-col-min-4{--bulma-grid-column-min:6rem}.grid.is-col-min-5{--bulma-grid-column-min:7.5rem}.grid.is-col-min-6{--bulma-grid-column-min:9rem}.grid.is-col-min-7{--bulma-grid-column-min:10.5rem}.grid.is-col-min-8{--bulma-grid-column-min:12rem}.grid.is-col-min-9{--bulma-grid-column-min:13.5rem}.grid.is-col-min-10{--bulma-grid-column-min:15rem}.grid.is-col-min-11{--bulma-grid-column-min:16.5rem}.grid.is-col-min-12{--bulma-grid-column-min:18rem}.grid.is-col-min-13{--bulma-grid-column-min:19.5rem}.grid.is-col-min-14{--bulma-grid-column-min:21rem}.grid.is-col-min-15{--bulma-grid-column-min:22.5rem}.grid.is-col-min-16{--bulma-grid-column-min:24rem}.grid.is-col-min-17{--bulma-grid-column-min:25.5rem}.grid.is-col-min-18{--bulma-grid-column-min:27rem}.grid.is-col-min-19{--bulma-grid-column-min:28.5rem}.grid.is-col-min-20{--bulma-grid-column-min:30rem}.grid.is-col-min-21{--bulma-grid-column-min:31.5rem}.grid.is-col-min-22{--bulma-grid-column-min:33rem}.grid.is-col-min-23{--bulma-grid-column-min:34.5rem}.grid.is-col-min-24{--bulma-grid-column-min:36rem}.grid.is-col-min-25{--bulma-grid-column-min:37.5rem}.grid.is-col-min-26{--bulma-grid-column-min:39rem}.grid.is-col-min-27{--bulma-grid-column-min:40.5rem}.grid.is-col-min-28{--bulma-grid-column-min:42rem}.grid.is-col-min-29{--bulma-grid-column-min:43.5rem}.grid.is-col-min-30{--bulma-grid-column-min:45rem}.grid.is-col-min-31{--bulma-grid-column-min:46.5rem}.grid.is-col-min-32{--bulma-grid-column-min:48rem}.cell{grid-column-end:span var(--bulma-grid-cell-column-span);grid-column-start:var(--bulma-grid-cell-column-start);grid-row-end:span var(--bulma-grid-cell-row-span);grid-row-start:var(--bulma-grid-cell-row-start)}.cell.is-col-start-end{--bulma-grid-cell-column-start:-1}.cell.is-row-start-end{--bulma-grid-cell-row-start:-1}.cell.is-col-start-1{--bulma-grid-cell-column-start:1}.cell.is-col-end-1{--bulma-grid-cell-column-end:1}.cell.is-col-from-end-1{--bulma-grid-cell-column-start:-1}.cell.is-col-span-1{--bulma-grid-cell-column-span:1}.cell.is-row-start-1{--bulma-grid-cell-row-start:1}.cell.is-row-end-1{--bulma-grid-cell-row-end:1}.cell.is-row-from-end-1{--bulma-grid-cell-row-start:-1}.cell.is-row-span-1{--bulma-grid-cell-row-span:1}.cell.is-col-start-2{--bulma-grid-cell-column-start:2}.cell.is-col-end-2{--bulma-grid-cell-column-end:2}.cell.is-col-from-end-2{--bulma-grid-cell-column-start:-2}.cell.is-col-span-2{--bulma-grid-cell-column-span:2}.cell.is-row-start-2{--bulma-grid-cell-row-start:2}.cell.is-row-end-2{--bulma-grid-cell-row-end:2}.cell.is-row-from-end-2{--bulma-grid-cell-row-start:-2}.cell.is-row-span-2{--bulma-grid-cell-row-span:2}.cell.is-col-start-3{--bulma-grid-cell-column-start:3}.cell.is-col-end-3{--bulma-grid-cell-column-end:3}.cell.is-col-from-end-3{--bulma-grid-cell-column-start:-3}.cell.is-col-span-3{--bulma-grid-cell-column-span:3}.cell.is-row-start-3{--bulma-grid-cell-row-start:3}.cell.is-row-end-3{--bulma-grid-cell-row-end:3}.cell.is-row-from-end-3{--bulma-grid-cell-row-start:-3}.cell.is-row-span-3{--bulma-grid-cell-row-span:3}.cell.is-col-start-4{--bulma-grid-cell-column-start:4}.cell.is-col-end-4{--bulma-grid-cell-column-end:4}.cell.is-col-from-end-4{--bulma-grid-cell-column-start:-4}.cell.is-col-span-4{--bulma-grid-cell-column-span:4}.cell.is-row-start-4{--bulma-grid-cell-row-start:4}.cell.is-row-end-4{--bulma-grid-cell-row-end:4}.cell.is-row-from-end-4{--bulma-grid-cell-row-start:-4}.cell.is-row-span-4{--bulma-grid-cell-row-span:4}.cell.is-col-start-5{--bulma-grid-cell-column-start:5}.cell.is-col-end-5{--bulma-grid-cell-column-end:5}.cell.is-col-from-end-5{--bulma-grid-cell-column-start:-5}.cell.is-col-span-5{--bulma-grid-cell-column-span:5}.cell.is-row-start-5{--bulma-grid-cell-row-start:5}.cell.is-row-end-5{--bulma-grid-cell-row-end:5}.cell.is-row-from-end-5{--bulma-grid-cell-row-start:-5}.cell.is-row-span-5{--bulma-grid-cell-row-span:5}.cell.is-col-start-6{--bulma-grid-cell-column-start:6}.cell.is-col-end-6{--bulma-grid-cell-column-end:6}.cell.is-col-from-end-6{--bulma-grid-cell-column-start:-6}.cell.is-col-span-6{--bulma-grid-cell-column-span:6}.cell.is-row-start-6{--bulma-grid-cell-row-start:6}.cell.is-row-end-6{--bulma-grid-cell-row-end:6}.cell.is-row-from-end-6{--bulma-grid-cell-row-start:-6}.cell.is-row-span-6{--bulma-grid-cell-row-span:6}.cell.is-col-start-7{--bulma-grid-cell-column-start:7}.cell.is-col-end-7{--bulma-grid-cell-column-end:7}.cell.is-col-from-end-7{--bulma-grid-cell-column-start:-7}.cell.is-col-span-7{--bulma-grid-cell-column-span:7}.cell.is-row-start-7{--bulma-grid-cell-row-start:7}.cell.is-row-end-7{--bulma-grid-cell-row-end:7}.cell.is-row-from-end-7{--bulma-grid-cell-row-start:-7}.cell.is-row-span-7{--bulma-grid-cell-row-span:7}.cell.is-col-start-8{--bulma-grid-cell-column-start:8}.cell.is-col-end-8{--bulma-grid-cell-column-end:8}.cell.is-col-from-end-8{--bulma-grid-cell-column-start:-8}.cell.is-col-span-8{--bulma-grid-cell-column-span:8}.cell.is-row-start-8{--bulma-grid-cell-row-start:8}.cell.is-row-end-8{--bulma-grid-cell-row-end:8}.cell.is-row-from-end-8{--bulma-grid-cell-row-start:-8}.cell.is-row-span-8{--bulma-grid-cell-row-span:8}.cell.is-col-start-9{--bulma-grid-cell-column-start:9}.cell.is-col-end-9{--bulma-grid-cell-column-end:9}.cell.is-col-from-end-9{--bulma-grid-cell-column-start:-9}.cell.is-col-span-9{--bulma-grid-cell-column-span:9}.cell.is-row-start-9{--bulma-grid-cell-row-start:9}.cell.is-row-end-9{--bulma-grid-cell-row-end:9}.cell.is-row-from-end-9{--bulma-grid-cell-row-start:-9}.cell.is-row-span-9{--bulma-grid-cell-row-span:9}.cell.is-col-start-10{--bulma-grid-cell-column-start:10}.cell.is-col-end-10{--bulma-grid-cell-column-end:10}.cell.is-col-from-end-10{--bulma-grid-cell-column-start:-10}.cell.is-col-span-10{--bulma-grid-cell-column-span:10}.cell.is-row-start-10{--bulma-grid-cell-row-start:10}.cell.is-row-end-10{--bulma-grid-cell-row-end:10}.cell.is-row-from-end-10{--bulma-grid-cell-row-start:-10}.cell.is-row-span-10{--bulma-grid-cell-row-span:10}.cell.is-col-start-11{--bulma-grid-cell-column-start:11}.cell.is-col-end-11{--bulma-grid-cell-column-end:11}.cell.is-col-from-end-11{--bulma-grid-cell-column-start:-11}.cell.is-col-span-11{--bulma-grid-cell-column-span:11}.cell.is-row-start-11{--bulma-grid-cell-row-start:11}.cell.is-row-end-11{--bulma-grid-cell-row-end:11}.cell.is-row-from-end-11{--bulma-grid-cell-row-start:-11}.cell.is-row-span-11{--bulma-grid-cell-row-span:11}.cell.is-col-start-12{--bulma-grid-cell-column-start:12}.cell.is-col-end-12{--bulma-grid-cell-column-end:12}.cell.is-col-from-end-12{--bulma-grid-cell-column-start:-12}.cell.is-col-span-12{--bulma-grid-cell-column-span:12}.cell.is-row-start-12{--bulma-grid-cell-row-start:12}.cell.is-row-end-12{--bulma-grid-cell-row-end:12}.cell.is-row-from-end-12{--bulma-grid-cell-row-start:-12}.cell.is-row-span-12{--bulma-grid-cell-row-span:12}@media screen and (width<=768px){.cell.is-col-start-1-mobile{--bulma-grid-cell-column-start:1}.cell.is-col-end-1-mobile{--bulma-grid-cell-column-end:1}.cell.is-col-from-end-1-mobile{--bulma-grid-cell-column-start:-1}.cell.is-col-span-1-mobile{--bulma-grid-cell-column-span:1}.cell.is-row-start-1-mobile{--bulma-grid-cell-row-start:1}.cell.is-row-end-1-mobile{--bulma-grid-cell-row-end:1}.cell.is-row-from-end-1-mobile{--bulma-grid-cell-row-start:-1}.cell.is-row-span-1-mobile{--bulma-grid-cell-row-span:1}.cell.is-col-start-2-mobile{--bulma-grid-cell-column-start:2}.cell.is-col-end-2-mobile{--bulma-grid-cell-column-end:2}.cell.is-col-from-end-2-mobile{--bulma-grid-cell-column-start:-2}.cell.is-col-span-2-mobile{--bulma-grid-cell-column-span:2}.cell.is-row-start-2-mobile{--bulma-grid-cell-row-start:2}.cell.is-row-end-2-mobile{--bulma-grid-cell-row-end:2}.cell.is-row-from-end-2-mobile{--bulma-grid-cell-row-start:-2}.cell.is-row-span-2-mobile{--bulma-grid-cell-row-span:2}.cell.is-col-start-3-mobile{--bulma-grid-cell-column-start:3}.cell.is-col-end-3-mobile{--bulma-grid-cell-column-end:3}.cell.is-col-from-end-3-mobile{--bulma-grid-cell-column-start:-3}.cell.is-col-span-3-mobile{--bulma-grid-cell-column-span:3}.cell.is-row-start-3-mobile{--bulma-grid-cell-row-start:3}.cell.is-row-end-3-mobile{--bulma-grid-cell-row-end:3}.cell.is-row-from-end-3-mobile{--bulma-grid-cell-row-start:-3}.cell.is-row-span-3-mobile{--bulma-grid-cell-row-span:3}.cell.is-col-start-4-mobile{--bulma-grid-cell-column-start:4}.cell.is-col-end-4-mobile{--bulma-grid-cell-column-end:4}.cell.is-col-from-end-4-mobile{--bulma-grid-cell-column-start:-4}.cell.is-col-span-4-mobile{--bulma-grid-cell-column-span:4}.cell.is-row-start-4-mobile{--bulma-grid-cell-row-start:4}.cell.is-row-end-4-mobile{--bulma-grid-cell-row-end:4}.cell.is-row-from-end-4-mobile{--bulma-grid-cell-row-start:-4}.cell.is-row-span-4-mobile{--bulma-grid-cell-row-span:4}.cell.is-col-start-5-mobile{--bulma-grid-cell-column-start:5}.cell.is-col-end-5-mobile{--bulma-grid-cell-column-end:5}.cell.is-col-from-end-5-mobile{--bulma-grid-cell-column-start:-5}.cell.is-col-span-5-mobile{--bulma-grid-cell-column-span:5}.cell.is-row-start-5-mobile{--bulma-grid-cell-row-start:5}.cell.is-row-end-5-mobile{--bulma-grid-cell-row-end:5}.cell.is-row-from-end-5-mobile{--bulma-grid-cell-row-start:-5}.cell.is-row-span-5-mobile{--bulma-grid-cell-row-span:5}.cell.is-col-start-6-mobile{--bulma-grid-cell-column-start:6}.cell.is-col-end-6-mobile{--bulma-grid-cell-column-end:6}.cell.is-col-from-end-6-mobile{--bulma-grid-cell-column-start:-6}.cell.is-col-span-6-mobile{--bulma-grid-cell-column-span:6}.cell.is-row-start-6-mobile{--bulma-grid-cell-row-start:6}.cell.is-row-end-6-mobile{--bulma-grid-cell-row-end:6}.cell.is-row-from-end-6-mobile{--bulma-grid-cell-row-start:-6}.cell.is-row-span-6-mobile{--bulma-grid-cell-row-span:6}.cell.is-col-start-7-mobile{--bulma-grid-cell-column-start:7}.cell.is-col-end-7-mobile{--bulma-grid-cell-column-end:7}.cell.is-col-from-end-7-mobile{--bulma-grid-cell-column-start:-7}.cell.is-col-span-7-mobile{--bulma-grid-cell-column-span:7}.cell.is-row-start-7-mobile{--bulma-grid-cell-row-start:7}.cell.is-row-end-7-mobile{--bulma-grid-cell-row-end:7}.cell.is-row-from-end-7-mobile{--bulma-grid-cell-row-start:-7}.cell.is-row-span-7-mobile{--bulma-grid-cell-row-span:7}.cell.is-col-start-8-mobile{--bulma-grid-cell-column-start:8}.cell.is-col-end-8-mobile{--bulma-grid-cell-column-end:8}.cell.is-col-from-end-8-mobile{--bulma-grid-cell-column-start:-8}.cell.is-col-span-8-mobile{--bulma-grid-cell-column-span:8}.cell.is-row-start-8-mobile{--bulma-grid-cell-row-start:8}.cell.is-row-end-8-mobile{--bulma-grid-cell-row-end:8}.cell.is-row-from-end-8-mobile{--bulma-grid-cell-row-start:-8}.cell.is-row-span-8-mobile{--bulma-grid-cell-row-span:8}.cell.is-col-start-9-mobile{--bulma-grid-cell-column-start:9}.cell.is-col-end-9-mobile{--bulma-grid-cell-column-end:9}.cell.is-col-from-end-9-mobile{--bulma-grid-cell-column-start:-9}.cell.is-col-span-9-mobile{--bulma-grid-cell-column-span:9}.cell.is-row-start-9-mobile{--bulma-grid-cell-row-start:9}.cell.is-row-end-9-mobile{--bulma-grid-cell-row-end:9}.cell.is-row-from-end-9-mobile{--bulma-grid-cell-row-start:-9}.cell.is-row-span-9-mobile{--bulma-grid-cell-row-span:9}.cell.is-col-start-10-mobile{--bulma-grid-cell-column-start:10}.cell.is-col-end-10-mobile{--bulma-grid-cell-column-end:10}.cell.is-col-from-end-10-mobile{--bulma-grid-cell-column-start:-10}.cell.is-col-span-10-mobile{--bulma-grid-cell-column-span:10}.cell.is-row-start-10-mobile{--bulma-grid-cell-row-start:10}.cell.is-row-end-10-mobile{--bulma-grid-cell-row-end:10}.cell.is-row-from-end-10-mobile{--bulma-grid-cell-row-start:-10}.cell.is-row-span-10-mobile{--bulma-grid-cell-row-span:10}.cell.is-col-start-11-mobile{--bulma-grid-cell-column-start:11}.cell.is-col-end-11-mobile{--bulma-grid-cell-column-end:11}.cell.is-col-from-end-11-mobile{--bulma-grid-cell-column-start:-11}.cell.is-col-span-11-mobile{--bulma-grid-cell-column-span:11}.cell.is-row-start-11-mobile{--bulma-grid-cell-row-start:11}.cell.is-row-end-11-mobile{--bulma-grid-cell-row-end:11}.cell.is-row-from-end-11-mobile{--bulma-grid-cell-row-start:-11}.cell.is-row-span-11-mobile{--bulma-grid-cell-row-span:11}.cell.is-col-start-12-mobile{--bulma-grid-cell-column-start:12}.cell.is-col-end-12-mobile{--bulma-grid-cell-column-end:12}.cell.is-col-from-end-12-mobile{--bulma-grid-cell-column-start:-12}.cell.is-col-span-12-mobile{--bulma-grid-cell-column-span:12}.cell.is-row-start-12-mobile{--bulma-grid-cell-row-start:12}.cell.is-row-end-12-mobile{--bulma-grid-cell-row-end:12}.cell.is-row-from-end-12-mobile{--bulma-grid-cell-row-start:-12}.cell.is-row-span-12-mobile{--bulma-grid-cell-row-span:12}}@media screen and (width>=769px),print{.cell.is-col-start-1-tablet{--bulma-grid-cell-column-start:1}.cell.is-col-end-1-tablet{--bulma-grid-cell-column-end:1}.cell.is-col-from-end-1-tablet{--bulma-grid-cell-column-start:-1}.cell.is-col-span-1-tablet{--bulma-grid-cell-column-span:1}.cell.is-row-start-1-tablet{--bulma-grid-cell-row-start:1}.cell.is-row-end-1-tablet{--bulma-grid-cell-row-end:1}.cell.is-row-from-end-1-tablet{--bulma-grid-cell-row-start:-1}.cell.is-row-span-1-tablet{--bulma-grid-cell-row-span:1}.cell.is-col-start-2-tablet{--bulma-grid-cell-column-start:2}.cell.is-col-end-2-tablet{--bulma-grid-cell-column-end:2}.cell.is-col-from-end-2-tablet{--bulma-grid-cell-column-start:-2}.cell.is-col-span-2-tablet{--bulma-grid-cell-column-span:2}.cell.is-row-start-2-tablet{--bulma-grid-cell-row-start:2}.cell.is-row-end-2-tablet{--bulma-grid-cell-row-end:2}.cell.is-row-from-end-2-tablet{--bulma-grid-cell-row-start:-2}.cell.is-row-span-2-tablet{--bulma-grid-cell-row-span:2}.cell.is-col-start-3-tablet{--bulma-grid-cell-column-start:3}.cell.is-col-end-3-tablet{--bulma-grid-cell-column-end:3}.cell.is-col-from-end-3-tablet{--bulma-grid-cell-column-start:-3}.cell.is-col-span-3-tablet{--bulma-grid-cell-column-span:3}.cell.is-row-start-3-tablet{--bulma-grid-cell-row-start:3}.cell.is-row-end-3-tablet{--bulma-grid-cell-row-end:3}.cell.is-row-from-end-3-tablet{--bulma-grid-cell-row-start:-3}.cell.is-row-span-3-tablet{--bulma-grid-cell-row-span:3}.cell.is-col-start-4-tablet{--bulma-grid-cell-column-start:4}.cell.is-col-end-4-tablet{--bulma-grid-cell-column-end:4}.cell.is-col-from-end-4-tablet{--bulma-grid-cell-column-start:-4}.cell.is-col-span-4-tablet{--bulma-grid-cell-column-span:4}.cell.is-row-start-4-tablet{--bulma-grid-cell-row-start:4}.cell.is-row-end-4-tablet{--bulma-grid-cell-row-end:4}.cell.is-row-from-end-4-tablet{--bulma-grid-cell-row-start:-4}.cell.is-row-span-4-tablet{--bulma-grid-cell-row-span:4}.cell.is-col-start-5-tablet{--bulma-grid-cell-column-start:5}.cell.is-col-end-5-tablet{--bulma-grid-cell-column-end:5}.cell.is-col-from-end-5-tablet{--bulma-grid-cell-column-start:-5}.cell.is-col-span-5-tablet{--bulma-grid-cell-column-span:5}.cell.is-row-start-5-tablet{--bulma-grid-cell-row-start:5}.cell.is-row-end-5-tablet{--bulma-grid-cell-row-end:5}.cell.is-row-from-end-5-tablet{--bulma-grid-cell-row-start:-5}.cell.is-row-span-5-tablet{--bulma-grid-cell-row-span:5}.cell.is-col-start-6-tablet{--bulma-grid-cell-column-start:6}.cell.is-col-end-6-tablet{--bulma-grid-cell-column-end:6}.cell.is-col-from-end-6-tablet{--bulma-grid-cell-column-start:-6}.cell.is-col-span-6-tablet{--bulma-grid-cell-column-span:6}.cell.is-row-start-6-tablet{--bulma-grid-cell-row-start:6}.cell.is-row-end-6-tablet{--bulma-grid-cell-row-end:6}.cell.is-row-from-end-6-tablet{--bulma-grid-cell-row-start:-6}.cell.is-row-span-6-tablet{--bulma-grid-cell-row-span:6}.cell.is-col-start-7-tablet{--bulma-grid-cell-column-start:7}.cell.is-col-end-7-tablet{--bulma-grid-cell-column-end:7}.cell.is-col-from-end-7-tablet{--bulma-grid-cell-column-start:-7}.cell.is-col-span-7-tablet{--bulma-grid-cell-column-span:7}.cell.is-row-start-7-tablet{--bulma-grid-cell-row-start:7}.cell.is-row-end-7-tablet{--bulma-grid-cell-row-end:7}.cell.is-row-from-end-7-tablet{--bulma-grid-cell-row-start:-7}.cell.is-row-span-7-tablet{--bulma-grid-cell-row-span:7}.cell.is-col-start-8-tablet{--bulma-grid-cell-column-start:8}.cell.is-col-end-8-tablet{--bulma-grid-cell-column-end:8}.cell.is-col-from-end-8-tablet{--bulma-grid-cell-column-start:-8}.cell.is-col-span-8-tablet{--bulma-grid-cell-column-span:8}.cell.is-row-start-8-tablet{--bulma-grid-cell-row-start:8}.cell.is-row-end-8-tablet{--bulma-grid-cell-row-end:8}.cell.is-row-from-end-8-tablet{--bulma-grid-cell-row-start:-8}.cell.is-row-span-8-tablet{--bulma-grid-cell-row-span:8}.cell.is-col-start-9-tablet{--bulma-grid-cell-column-start:9}.cell.is-col-end-9-tablet{--bulma-grid-cell-column-end:9}.cell.is-col-from-end-9-tablet{--bulma-grid-cell-column-start:-9}.cell.is-col-span-9-tablet{--bulma-grid-cell-column-span:9}.cell.is-row-start-9-tablet{--bulma-grid-cell-row-start:9}.cell.is-row-end-9-tablet{--bulma-grid-cell-row-end:9}.cell.is-row-from-end-9-tablet{--bulma-grid-cell-row-start:-9}.cell.is-row-span-9-tablet{--bulma-grid-cell-row-span:9}.cell.is-col-start-10-tablet{--bulma-grid-cell-column-start:10}.cell.is-col-end-10-tablet{--bulma-grid-cell-column-end:10}.cell.is-col-from-end-10-tablet{--bulma-grid-cell-column-start:-10}.cell.is-col-span-10-tablet{--bulma-grid-cell-column-span:10}.cell.is-row-start-10-tablet{--bulma-grid-cell-row-start:10}.cell.is-row-end-10-tablet{--bulma-grid-cell-row-end:10}.cell.is-row-from-end-10-tablet{--bulma-grid-cell-row-start:-10}.cell.is-row-span-10-tablet{--bulma-grid-cell-row-span:10}.cell.is-col-start-11-tablet{--bulma-grid-cell-column-start:11}.cell.is-col-end-11-tablet{--bulma-grid-cell-column-end:11}.cell.is-col-from-end-11-tablet{--bulma-grid-cell-column-start:-11}.cell.is-col-span-11-tablet{--bulma-grid-cell-column-span:11}.cell.is-row-start-11-tablet{--bulma-grid-cell-row-start:11}.cell.is-row-end-11-tablet{--bulma-grid-cell-row-end:11}.cell.is-row-from-end-11-tablet{--bulma-grid-cell-row-start:-11}.cell.is-row-span-11-tablet{--bulma-grid-cell-row-span:11}.cell.is-col-start-12-tablet{--bulma-grid-cell-column-start:12}.cell.is-col-end-12-tablet{--bulma-grid-cell-column-end:12}.cell.is-col-from-end-12-tablet{--bulma-grid-cell-column-start:-12}.cell.is-col-span-12-tablet{--bulma-grid-cell-column-span:12}.cell.is-row-start-12-tablet{--bulma-grid-cell-row-start:12}.cell.is-row-end-12-tablet{--bulma-grid-cell-row-end:12}.cell.is-row-from-end-12-tablet{--bulma-grid-cell-row-start:-12}.cell.is-row-span-12-tablet{--bulma-grid-cell-row-span:12}}@media screen and (width>=769px) and (width<=1023px){.cell.is-col-start-1-tablet-only{--bulma-grid-cell-column-start:1}.cell.is-col-end-1-tablet-only{--bulma-grid-cell-column-end:1}.cell.is-col-from-end-1-tablet-only{--bulma-grid-cell-column-start:-1}.cell.is-col-span-1-tablet-only{--bulma-grid-cell-column-span:1}.cell.is-row-start-1-tablet-only{--bulma-grid-cell-row-start:1}.cell.is-row-end-1-tablet-only{--bulma-grid-cell-row-end:1}.cell.is-row-from-end-1-tablet-only{--bulma-grid-cell-row-start:-1}.cell.is-row-span-1-tablet-only{--bulma-grid-cell-row-span:1}.cell.is-col-start-2-tablet-only{--bulma-grid-cell-column-start:2}.cell.is-col-end-2-tablet-only{--bulma-grid-cell-column-end:2}.cell.is-col-from-end-2-tablet-only{--bulma-grid-cell-column-start:-2}.cell.is-col-span-2-tablet-only{--bulma-grid-cell-column-span:2}.cell.is-row-start-2-tablet-only{--bulma-grid-cell-row-start:2}.cell.is-row-end-2-tablet-only{--bulma-grid-cell-row-end:2}.cell.is-row-from-end-2-tablet-only{--bulma-grid-cell-row-start:-2}.cell.is-row-span-2-tablet-only{--bulma-grid-cell-row-span:2}.cell.is-col-start-3-tablet-only{--bulma-grid-cell-column-start:3}.cell.is-col-end-3-tablet-only{--bulma-grid-cell-column-end:3}.cell.is-col-from-end-3-tablet-only{--bulma-grid-cell-column-start:-3}.cell.is-col-span-3-tablet-only{--bulma-grid-cell-column-span:3}.cell.is-row-start-3-tablet-only{--bulma-grid-cell-row-start:3}.cell.is-row-end-3-tablet-only{--bulma-grid-cell-row-end:3}.cell.is-row-from-end-3-tablet-only{--bulma-grid-cell-row-start:-3}.cell.is-row-span-3-tablet-only{--bulma-grid-cell-row-span:3}.cell.is-col-start-4-tablet-only{--bulma-grid-cell-column-start:4}.cell.is-col-end-4-tablet-only{--bulma-grid-cell-column-end:4}.cell.is-col-from-end-4-tablet-only{--bulma-grid-cell-column-start:-4}.cell.is-col-span-4-tablet-only{--bulma-grid-cell-column-span:4}.cell.is-row-start-4-tablet-only{--bulma-grid-cell-row-start:4}.cell.is-row-end-4-tablet-only{--bulma-grid-cell-row-end:4}.cell.is-row-from-end-4-tablet-only{--bulma-grid-cell-row-start:-4}.cell.is-row-span-4-tablet-only{--bulma-grid-cell-row-span:4}.cell.is-col-start-5-tablet-only{--bulma-grid-cell-column-start:5}.cell.is-col-end-5-tablet-only{--bulma-grid-cell-column-end:5}.cell.is-col-from-end-5-tablet-only{--bulma-grid-cell-column-start:-5}.cell.is-col-span-5-tablet-only{--bulma-grid-cell-column-span:5}.cell.is-row-start-5-tablet-only{--bulma-grid-cell-row-start:5}.cell.is-row-end-5-tablet-only{--bulma-grid-cell-row-end:5}.cell.is-row-from-end-5-tablet-only{--bulma-grid-cell-row-start:-5}.cell.is-row-span-5-tablet-only{--bulma-grid-cell-row-span:5}.cell.is-col-start-6-tablet-only{--bulma-grid-cell-column-start:6}.cell.is-col-end-6-tablet-only{--bulma-grid-cell-column-end:6}.cell.is-col-from-end-6-tablet-only{--bulma-grid-cell-column-start:-6}.cell.is-col-span-6-tablet-only{--bulma-grid-cell-column-span:6}.cell.is-row-start-6-tablet-only{--bulma-grid-cell-row-start:6}.cell.is-row-end-6-tablet-only{--bulma-grid-cell-row-end:6}.cell.is-row-from-end-6-tablet-only{--bulma-grid-cell-row-start:-6}.cell.is-row-span-6-tablet-only{--bulma-grid-cell-row-span:6}.cell.is-col-start-7-tablet-only{--bulma-grid-cell-column-start:7}.cell.is-col-end-7-tablet-only{--bulma-grid-cell-column-end:7}.cell.is-col-from-end-7-tablet-only{--bulma-grid-cell-column-start:-7}.cell.is-col-span-7-tablet-only{--bulma-grid-cell-column-span:7}.cell.is-row-start-7-tablet-only{--bulma-grid-cell-row-start:7}.cell.is-row-end-7-tablet-only{--bulma-grid-cell-row-end:7}.cell.is-row-from-end-7-tablet-only{--bulma-grid-cell-row-start:-7}.cell.is-row-span-7-tablet-only{--bulma-grid-cell-row-span:7}.cell.is-col-start-8-tablet-only{--bulma-grid-cell-column-start:8}.cell.is-col-end-8-tablet-only{--bulma-grid-cell-column-end:8}.cell.is-col-from-end-8-tablet-only{--bulma-grid-cell-column-start:-8}.cell.is-col-span-8-tablet-only{--bulma-grid-cell-column-span:8}.cell.is-row-start-8-tablet-only{--bulma-grid-cell-row-start:8}.cell.is-row-end-8-tablet-only{--bulma-grid-cell-row-end:8}.cell.is-row-from-end-8-tablet-only{--bulma-grid-cell-row-start:-8}.cell.is-row-span-8-tablet-only{--bulma-grid-cell-row-span:8}.cell.is-col-start-9-tablet-only{--bulma-grid-cell-column-start:9}.cell.is-col-end-9-tablet-only{--bulma-grid-cell-column-end:9}.cell.is-col-from-end-9-tablet-only{--bulma-grid-cell-column-start:-9}.cell.is-col-span-9-tablet-only{--bulma-grid-cell-column-span:9}.cell.is-row-start-9-tablet-only{--bulma-grid-cell-row-start:9}.cell.is-row-end-9-tablet-only{--bulma-grid-cell-row-end:9}.cell.is-row-from-end-9-tablet-only{--bulma-grid-cell-row-start:-9}.cell.is-row-span-9-tablet-only{--bulma-grid-cell-row-span:9}.cell.is-col-start-10-tablet-only{--bulma-grid-cell-column-start:10}.cell.is-col-end-10-tablet-only{--bulma-grid-cell-column-end:10}.cell.is-col-from-end-10-tablet-only{--bulma-grid-cell-column-start:-10}.cell.is-col-span-10-tablet-only{--bulma-grid-cell-column-span:10}.cell.is-row-start-10-tablet-only{--bulma-grid-cell-row-start:10}.cell.is-row-end-10-tablet-only{--bulma-grid-cell-row-end:10}.cell.is-row-from-end-10-tablet-only{--bulma-grid-cell-row-start:-10}.cell.is-row-span-10-tablet-only{--bulma-grid-cell-row-span:10}.cell.is-col-start-11-tablet-only{--bulma-grid-cell-column-start:11}.cell.is-col-end-11-tablet-only{--bulma-grid-cell-column-end:11}.cell.is-col-from-end-11-tablet-only{--bulma-grid-cell-column-start:-11}.cell.is-col-span-11-tablet-only{--bulma-grid-cell-column-span:11}.cell.is-row-start-11-tablet-only{--bulma-grid-cell-row-start:11}.cell.is-row-end-11-tablet-only{--bulma-grid-cell-row-end:11}.cell.is-row-from-end-11-tablet-only{--bulma-grid-cell-row-start:-11}.cell.is-row-span-11-tablet-only{--bulma-grid-cell-row-span:11}.cell.is-col-start-12-tablet-only{--bulma-grid-cell-column-start:12}.cell.is-col-end-12-tablet-only{--bulma-grid-cell-column-end:12}.cell.is-col-from-end-12-tablet-only{--bulma-grid-cell-column-start:-12}.cell.is-col-span-12-tablet-only{--bulma-grid-cell-column-span:12}.cell.is-row-start-12-tablet-only{--bulma-grid-cell-row-start:12}.cell.is-row-end-12-tablet-only{--bulma-grid-cell-row-end:12}.cell.is-row-from-end-12-tablet-only{--bulma-grid-cell-row-start:-12}.cell.is-row-span-12-tablet-only{--bulma-grid-cell-row-span:12}}@media screen and (width>=1024px){.cell.is-col-start-1-desktop{--bulma-grid-cell-column-start:1}.cell.is-col-end-1-desktop{--bulma-grid-cell-column-end:1}.cell.is-col-from-end-1-desktop{--bulma-grid-cell-column-start:-1}.cell.is-col-span-1-desktop{--bulma-grid-cell-column-span:1}.cell.is-row-start-1-desktop{--bulma-grid-cell-row-start:1}.cell.is-row-end-1-desktop{--bulma-grid-cell-row-end:1}.cell.is-row-from-end-1-desktop{--bulma-grid-cell-row-start:-1}.cell.is-row-span-1-desktop{--bulma-grid-cell-row-span:1}.cell.is-col-start-2-desktop{--bulma-grid-cell-column-start:2}.cell.is-col-end-2-desktop{--bulma-grid-cell-column-end:2}.cell.is-col-from-end-2-desktop{--bulma-grid-cell-column-start:-2}.cell.is-col-span-2-desktop{--bulma-grid-cell-column-span:2}.cell.is-row-start-2-desktop{--bulma-grid-cell-row-start:2}.cell.is-row-end-2-desktop{--bulma-grid-cell-row-end:2}.cell.is-row-from-end-2-desktop{--bulma-grid-cell-row-start:-2}.cell.is-row-span-2-desktop{--bulma-grid-cell-row-span:2}.cell.is-col-start-3-desktop{--bulma-grid-cell-column-start:3}.cell.is-col-end-3-desktop{--bulma-grid-cell-column-end:3}.cell.is-col-from-end-3-desktop{--bulma-grid-cell-column-start:-3}.cell.is-col-span-3-desktop{--bulma-grid-cell-column-span:3}.cell.is-row-start-3-desktop{--bulma-grid-cell-row-start:3}.cell.is-row-end-3-desktop{--bulma-grid-cell-row-end:3}.cell.is-row-from-end-3-desktop{--bulma-grid-cell-row-start:-3}.cell.is-row-span-3-desktop{--bulma-grid-cell-row-span:3}.cell.is-col-start-4-desktop{--bulma-grid-cell-column-start:4}.cell.is-col-end-4-desktop{--bulma-grid-cell-column-end:4}.cell.is-col-from-end-4-desktop{--bulma-grid-cell-column-start:-4}.cell.is-col-span-4-desktop{--bulma-grid-cell-column-span:4}.cell.is-row-start-4-desktop{--bulma-grid-cell-row-start:4}.cell.is-row-end-4-desktop{--bulma-grid-cell-row-end:4}.cell.is-row-from-end-4-desktop{--bulma-grid-cell-row-start:-4}.cell.is-row-span-4-desktop{--bulma-grid-cell-row-span:4}.cell.is-col-start-5-desktop{--bulma-grid-cell-column-start:5}.cell.is-col-end-5-desktop{--bulma-grid-cell-column-end:5}.cell.is-col-from-end-5-desktop{--bulma-grid-cell-column-start:-5}.cell.is-col-span-5-desktop{--bulma-grid-cell-column-span:5}.cell.is-row-start-5-desktop{--bulma-grid-cell-row-start:5}.cell.is-row-end-5-desktop{--bulma-grid-cell-row-end:5}.cell.is-row-from-end-5-desktop{--bulma-grid-cell-row-start:-5}.cell.is-row-span-5-desktop{--bulma-grid-cell-row-span:5}.cell.is-col-start-6-desktop{--bulma-grid-cell-column-start:6}.cell.is-col-end-6-desktop{--bulma-grid-cell-column-end:6}.cell.is-col-from-end-6-desktop{--bulma-grid-cell-column-start:-6}.cell.is-col-span-6-desktop{--bulma-grid-cell-column-span:6}.cell.is-row-start-6-desktop{--bulma-grid-cell-row-start:6}.cell.is-row-end-6-desktop{--bulma-grid-cell-row-end:6}.cell.is-row-from-end-6-desktop{--bulma-grid-cell-row-start:-6}.cell.is-row-span-6-desktop{--bulma-grid-cell-row-span:6}.cell.is-col-start-7-desktop{--bulma-grid-cell-column-start:7}.cell.is-col-end-7-desktop{--bulma-grid-cell-column-end:7}.cell.is-col-from-end-7-desktop{--bulma-grid-cell-column-start:-7}.cell.is-col-span-7-desktop{--bulma-grid-cell-column-span:7}.cell.is-row-start-7-desktop{--bulma-grid-cell-row-start:7}.cell.is-row-end-7-desktop{--bulma-grid-cell-row-end:7}.cell.is-row-from-end-7-desktop{--bulma-grid-cell-row-start:-7}.cell.is-row-span-7-desktop{--bulma-grid-cell-row-span:7}.cell.is-col-start-8-desktop{--bulma-grid-cell-column-start:8}.cell.is-col-end-8-desktop{--bulma-grid-cell-column-end:8}.cell.is-col-from-end-8-desktop{--bulma-grid-cell-column-start:-8}.cell.is-col-span-8-desktop{--bulma-grid-cell-column-span:8}.cell.is-row-start-8-desktop{--bulma-grid-cell-row-start:8}.cell.is-row-end-8-desktop{--bulma-grid-cell-row-end:8}.cell.is-row-from-end-8-desktop{--bulma-grid-cell-row-start:-8}.cell.is-row-span-8-desktop{--bulma-grid-cell-row-span:8}.cell.is-col-start-9-desktop{--bulma-grid-cell-column-start:9}.cell.is-col-end-9-desktop{--bulma-grid-cell-column-end:9}.cell.is-col-from-end-9-desktop{--bulma-grid-cell-column-start:-9}.cell.is-col-span-9-desktop{--bulma-grid-cell-column-span:9}.cell.is-row-start-9-desktop{--bulma-grid-cell-row-start:9}.cell.is-row-end-9-desktop{--bulma-grid-cell-row-end:9}.cell.is-row-from-end-9-desktop{--bulma-grid-cell-row-start:-9}.cell.is-row-span-9-desktop{--bulma-grid-cell-row-span:9}.cell.is-col-start-10-desktop{--bulma-grid-cell-column-start:10}.cell.is-col-end-10-desktop{--bulma-grid-cell-column-end:10}.cell.is-col-from-end-10-desktop{--bulma-grid-cell-column-start:-10}.cell.is-col-span-10-desktop{--bulma-grid-cell-column-span:10}.cell.is-row-start-10-desktop{--bulma-grid-cell-row-start:10}.cell.is-row-end-10-desktop{--bulma-grid-cell-row-end:10}.cell.is-row-from-end-10-desktop{--bulma-grid-cell-row-start:-10}.cell.is-row-span-10-desktop{--bulma-grid-cell-row-span:10}.cell.is-col-start-11-desktop{--bulma-grid-cell-column-start:11}.cell.is-col-end-11-desktop{--bulma-grid-cell-column-end:11}.cell.is-col-from-end-11-desktop{--bulma-grid-cell-column-start:-11}.cell.is-col-span-11-desktop{--bulma-grid-cell-column-span:11}.cell.is-row-start-11-desktop{--bulma-grid-cell-row-start:11}.cell.is-row-end-11-desktop{--bulma-grid-cell-row-end:11}.cell.is-row-from-end-11-desktop{--bulma-grid-cell-row-start:-11}.cell.is-row-span-11-desktop{--bulma-grid-cell-row-span:11}.cell.is-col-start-12-desktop{--bulma-grid-cell-column-start:12}.cell.is-col-end-12-desktop{--bulma-grid-cell-column-end:12}.cell.is-col-from-end-12-desktop{--bulma-grid-cell-column-start:-12}.cell.is-col-span-12-desktop{--bulma-grid-cell-column-span:12}.cell.is-row-start-12-desktop{--bulma-grid-cell-row-start:12}.cell.is-row-end-12-desktop{--bulma-grid-cell-row-end:12}.cell.is-row-from-end-12-desktop{--bulma-grid-cell-row-start:-12}.cell.is-row-span-12-desktop{--bulma-grid-cell-row-span:12}}@media screen and (width>=1024px) and (width<=1215px){.cell.is-col-start-1-desktop-only{--bulma-grid-cell-column-start:1}.cell.is-col-end-1-desktop-only{--bulma-grid-cell-column-end:1}.cell.is-col-from-end-1-desktop-only{--bulma-grid-cell-column-start:-1}.cell.is-col-span-1-desktop-only{--bulma-grid-cell-column-span:1}.cell.is-row-start-1-desktop-only{--bulma-grid-cell-row-start:1}.cell.is-row-end-1-desktop-only{--bulma-grid-cell-row-end:1}.cell.is-row-from-end-1-desktop-only{--bulma-grid-cell-row-start:-1}.cell.is-row-span-1-desktop-only{--bulma-grid-cell-row-span:1}.cell.is-col-start-2-desktop-only{--bulma-grid-cell-column-start:2}.cell.is-col-end-2-desktop-only{--bulma-grid-cell-column-end:2}.cell.is-col-from-end-2-desktop-only{--bulma-grid-cell-column-start:-2}.cell.is-col-span-2-desktop-only{--bulma-grid-cell-column-span:2}.cell.is-row-start-2-desktop-only{--bulma-grid-cell-row-start:2}.cell.is-row-end-2-desktop-only{--bulma-grid-cell-row-end:2}.cell.is-row-from-end-2-desktop-only{--bulma-grid-cell-row-start:-2}.cell.is-row-span-2-desktop-only{--bulma-grid-cell-row-span:2}.cell.is-col-start-3-desktop-only{--bulma-grid-cell-column-start:3}.cell.is-col-end-3-desktop-only{--bulma-grid-cell-column-end:3}.cell.is-col-from-end-3-desktop-only{--bulma-grid-cell-column-start:-3}.cell.is-col-span-3-desktop-only{--bulma-grid-cell-column-span:3}.cell.is-row-start-3-desktop-only{--bulma-grid-cell-row-start:3}.cell.is-row-end-3-desktop-only{--bulma-grid-cell-row-end:3}.cell.is-row-from-end-3-desktop-only{--bulma-grid-cell-row-start:-3}.cell.is-row-span-3-desktop-only{--bulma-grid-cell-row-span:3}.cell.is-col-start-4-desktop-only{--bulma-grid-cell-column-start:4}.cell.is-col-end-4-desktop-only{--bulma-grid-cell-column-end:4}.cell.is-col-from-end-4-desktop-only{--bulma-grid-cell-column-start:-4}.cell.is-col-span-4-desktop-only{--bulma-grid-cell-column-span:4}.cell.is-row-start-4-desktop-only{--bulma-grid-cell-row-start:4}.cell.is-row-end-4-desktop-only{--bulma-grid-cell-row-end:4}.cell.is-row-from-end-4-desktop-only{--bulma-grid-cell-row-start:-4}.cell.is-row-span-4-desktop-only{--bulma-grid-cell-row-span:4}.cell.is-col-start-5-desktop-only{--bulma-grid-cell-column-start:5}.cell.is-col-end-5-desktop-only{--bulma-grid-cell-column-end:5}.cell.is-col-from-end-5-desktop-only{--bulma-grid-cell-column-start:-5}.cell.is-col-span-5-desktop-only{--bulma-grid-cell-column-span:5}.cell.is-row-start-5-desktop-only{--bulma-grid-cell-row-start:5}.cell.is-row-end-5-desktop-only{--bulma-grid-cell-row-end:5}.cell.is-row-from-end-5-desktop-only{--bulma-grid-cell-row-start:-5}.cell.is-row-span-5-desktop-only{--bulma-grid-cell-row-span:5}.cell.is-col-start-6-desktop-only{--bulma-grid-cell-column-start:6}.cell.is-col-end-6-desktop-only{--bulma-grid-cell-column-end:6}.cell.is-col-from-end-6-desktop-only{--bulma-grid-cell-column-start:-6}.cell.is-col-span-6-desktop-only{--bulma-grid-cell-column-span:6}.cell.is-row-start-6-desktop-only{--bulma-grid-cell-row-start:6}.cell.is-row-end-6-desktop-only{--bulma-grid-cell-row-end:6}.cell.is-row-from-end-6-desktop-only{--bulma-grid-cell-row-start:-6}.cell.is-row-span-6-desktop-only{--bulma-grid-cell-row-span:6}.cell.is-col-start-7-desktop-only{--bulma-grid-cell-column-start:7}.cell.is-col-end-7-desktop-only{--bulma-grid-cell-column-end:7}.cell.is-col-from-end-7-desktop-only{--bulma-grid-cell-column-start:-7}.cell.is-col-span-7-desktop-only{--bulma-grid-cell-column-span:7}.cell.is-row-start-7-desktop-only{--bulma-grid-cell-row-start:7}.cell.is-row-end-7-desktop-only{--bulma-grid-cell-row-end:7}.cell.is-row-from-end-7-desktop-only{--bulma-grid-cell-row-start:-7}.cell.is-row-span-7-desktop-only{--bulma-grid-cell-row-span:7}.cell.is-col-start-8-desktop-only{--bulma-grid-cell-column-start:8}.cell.is-col-end-8-desktop-only{--bulma-grid-cell-column-end:8}.cell.is-col-from-end-8-desktop-only{--bulma-grid-cell-column-start:-8}.cell.is-col-span-8-desktop-only{--bulma-grid-cell-column-span:8}.cell.is-row-start-8-desktop-only{--bulma-grid-cell-row-start:8}.cell.is-row-end-8-desktop-only{--bulma-grid-cell-row-end:8}.cell.is-row-from-end-8-desktop-only{--bulma-grid-cell-row-start:-8}.cell.is-row-span-8-desktop-only{--bulma-grid-cell-row-span:8}.cell.is-col-start-9-desktop-only{--bulma-grid-cell-column-start:9}.cell.is-col-end-9-desktop-only{--bulma-grid-cell-column-end:9}.cell.is-col-from-end-9-desktop-only{--bulma-grid-cell-column-start:-9}.cell.is-col-span-9-desktop-only{--bulma-grid-cell-column-span:9}.cell.is-row-start-9-desktop-only{--bulma-grid-cell-row-start:9}.cell.is-row-end-9-desktop-only{--bulma-grid-cell-row-end:9}.cell.is-row-from-end-9-desktop-only{--bulma-grid-cell-row-start:-9}.cell.is-row-span-9-desktop-only{--bulma-grid-cell-row-span:9}.cell.is-col-start-10-desktop-only{--bulma-grid-cell-column-start:10}.cell.is-col-end-10-desktop-only{--bulma-grid-cell-column-end:10}.cell.is-col-from-end-10-desktop-only{--bulma-grid-cell-column-start:-10}.cell.is-col-span-10-desktop-only{--bulma-grid-cell-column-span:10}.cell.is-row-start-10-desktop-only{--bulma-grid-cell-row-start:10}.cell.is-row-end-10-desktop-only{--bulma-grid-cell-row-end:10}.cell.is-row-from-end-10-desktop-only{--bulma-grid-cell-row-start:-10}.cell.is-row-span-10-desktop-only{--bulma-grid-cell-row-span:10}.cell.is-col-start-11-desktop-only{--bulma-grid-cell-column-start:11}.cell.is-col-end-11-desktop-only{--bulma-grid-cell-column-end:11}.cell.is-col-from-end-11-desktop-only{--bulma-grid-cell-column-start:-11}.cell.is-col-span-11-desktop-only{--bulma-grid-cell-column-span:11}.cell.is-row-start-11-desktop-only{--bulma-grid-cell-row-start:11}.cell.is-row-end-11-desktop-only{--bulma-grid-cell-row-end:11}.cell.is-row-from-end-11-desktop-only{--bulma-grid-cell-row-start:-11}.cell.is-row-span-11-desktop-only{--bulma-grid-cell-row-span:11}.cell.is-col-start-12-desktop-only{--bulma-grid-cell-column-start:12}.cell.is-col-end-12-desktop-only{--bulma-grid-cell-column-end:12}.cell.is-col-from-end-12-desktop-only{--bulma-grid-cell-column-start:-12}.cell.is-col-span-12-desktop-only{--bulma-grid-cell-column-span:12}.cell.is-row-start-12-desktop-only{--bulma-grid-cell-row-start:12}.cell.is-row-end-12-desktop-only{--bulma-grid-cell-row-end:12}.cell.is-row-from-end-12-desktop-only{--bulma-grid-cell-row-start:-12}.cell.is-row-span-12-desktop-only{--bulma-grid-cell-row-span:12}}@media screen and (width>=1216px){.cell.is-col-start-1-widescreen{--bulma-grid-cell-column-start:1}.cell.is-col-end-1-widescreen{--bulma-grid-cell-column-end:1}.cell.is-col-from-end-1-widescreen{--bulma-grid-cell-column-start:-1}.cell.is-col-span-1-widescreen{--bulma-grid-cell-column-span:1}.cell.is-row-start-1-widescreen{--bulma-grid-cell-row-start:1}.cell.is-row-end-1-widescreen{--bulma-grid-cell-row-end:1}.cell.is-row-from-end-1-widescreen{--bulma-grid-cell-row-start:-1}.cell.is-row-span-1-widescreen{--bulma-grid-cell-row-span:1}.cell.is-col-start-2-widescreen{--bulma-grid-cell-column-start:2}.cell.is-col-end-2-widescreen{--bulma-grid-cell-column-end:2}.cell.is-col-from-end-2-widescreen{--bulma-grid-cell-column-start:-2}.cell.is-col-span-2-widescreen{--bulma-grid-cell-column-span:2}.cell.is-row-start-2-widescreen{--bulma-grid-cell-row-start:2}.cell.is-row-end-2-widescreen{--bulma-grid-cell-row-end:2}.cell.is-row-from-end-2-widescreen{--bulma-grid-cell-row-start:-2}.cell.is-row-span-2-widescreen{--bulma-grid-cell-row-span:2}.cell.is-col-start-3-widescreen{--bulma-grid-cell-column-start:3}.cell.is-col-end-3-widescreen{--bulma-grid-cell-column-end:3}.cell.is-col-from-end-3-widescreen{--bulma-grid-cell-column-start:-3}.cell.is-col-span-3-widescreen{--bulma-grid-cell-column-span:3}.cell.is-row-start-3-widescreen{--bulma-grid-cell-row-start:3}.cell.is-row-end-3-widescreen{--bulma-grid-cell-row-end:3}.cell.is-row-from-end-3-widescreen{--bulma-grid-cell-row-start:-3}.cell.is-row-span-3-widescreen{--bulma-grid-cell-row-span:3}.cell.is-col-start-4-widescreen{--bulma-grid-cell-column-start:4}.cell.is-col-end-4-widescreen{--bulma-grid-cell-column-end:4}.cell.is-col-from-end-4-widescreen{--bulma-grid-cell-column-start:-4}.cell.is-col-span-4-widescreen{--bulma-grid-cell-column-span:4}.cell.is-row-start-4-widescreen{--bulma-grid-cell-row-start:4}.cell.is-row-end-4-widescreen{--bulma-grid-cell-row-end:4}.cell.is-row-from-end-4-widescreen{--bulma-grid-cell-row-start:-4}.cell.is-row-span-4-widescreen{--bulma-grid-cell-row-span:4}.cell.is-col-start-5-widescreen{--bulma-grid-cell-column-start:5}.cell.is-col-end-5-widescreen{--bulma-grid-cell-column-end:5}.cell.is-col-from-end-5-widescreen{--bulma-grid-cell-column-start:-5}.cell.is-col-span-5-widescreen{--bulma-grid-cell-column-span:5}.cell.is-row-start-5-widescreen{--bulma-grid-cell-row-start:5}.cell.is-row-end-5-widescreen{--bulma-grid-cell-row-end:5}.cell.is-row-from-end-5-widescreen{--bulma-grid-cell-row-start:-5}.cell.is-row-span-5-widescreen{--bulma-grid-cell-row-span:5}.cell.is-col-start-6-widescreen{--bulma-grid-cell-column-start:6}.cell.is-col-end-6-widescreen{--bulma-grid-cell-column-end:6}.cell.is-col-from-end-6-widescreen{--bulma-grid-cell-column-start:-6}.cell.is-col-span-6-widescreen{--bulma-grid-cell-column-span:6}.cell.is-row-start-6-widescreen{--bulma-grid-cell-row-start:6}.cell.is-row-end-6-widescreen{--bulma-grid-cell-row-end:6}.cell.is-row-from-end-6-widescreen{--bulma-grid-cell-row-start:-6}.cell.is-row-span-6-widescreen{--bulma-grid-cell-row-span:6}.cell.is-col-start-7-widescreen{--bulma-grid-cell-column-start:7}.cell.is-col-end-7-widescreen{--bulma-grid-cell-column-end:7}.cell.is-col-from-end-7-widescreen{--bulma-grid-cell-column-start:-7}.cell.is-col-span-7-widescreen{--bulma-grid-cell-column-span:7}.cell.is-row-start-7-widescreen{--bulma-grid-cell-row-start:7}.cell.is-row-end-7-widescreen{--bulma-grid-cell-row-end:7}.cell.is-row-from-end-7-widescreen{--bulma-grid-cell-row-start:-7}.cell.is-row-span-7-widescreen{--bulma-grid-cell-row-span:7}.cell.is-col-start-8-widescreen{--bulma-grid-cell-column-start:8}.cell.is-col-end-8-widescreen{--bulma-grid-cell-column-end:8}.cell.is-col-from-end-8-widescreen{--bulma-grid-cell-column-start:-8}.cell.is-col-span-8-widescreen{--bulma-grid-cell-column-span:8}.cell.is-row-start-8-widescreen{--bulma-grid-cell-row-start:8}.cell.is-row-end-8-widescreen{--bulma-grid-cell-row-end:8}.cell.is-row-from-end-8-widescreen{--bulma-grid-cell-row-start:-8}.cell.is-row-span-8-widescreen{--bulma-grid-cell-row-span:8}.cell.is-col-start-9-widescreen{--bulma-grid-cell-column-start:9}.cell.is-col-end-9-widescreen{--bulma-grid-cell-column-end:9}.cell.is-col-from-end-9-widescreen{--bulma-grid-cell-column-start:-9}.cell.is-col-span-9-widescreen{--bulma-grid-cell-column-span:9}.cell.is-row-start-9-widescreen{--bulma-grid-cell-row-start:9}.cell.is-row-end-9-widescreen{--bulma-grid-cell-row-end:9}.cell.is-row-from-end-9-widescreen{--bulma-grid-cell-row-start:-9}.cell.is-row-span-9-widescreen{--bulma-grid-cell-row-span:9}.cell.is-col-start-10-widescreen{--bulma-grid-cell-column-start:10}.cell.is-col-end-10-widescreen{--bulma-grid-cell-column-end:10}.cell.is-col-from-end-10-widescreen{--bulma-grid-cell-column-start:-10}.cell.is-col-span-10-widescreen{--bulma-grid-cell-column-span:10}.cell.is-row-start-10-widescreen{--bulma-grid-cell-row-start:10}.cell.is-row-end-10-widescreen{--bulma-grid-cell-row-end:10}.cell.is-row-from-end-10-widescreen{--bulma-grid-cell-row-start:-10}.cell.is-row-span-10-widescreen{--bulma-grid-cell-row-span:10}.cell.is-col-start-11-widescreen{--bulma-grid-cell-column-start:11}.cell.is-col-end-11-widescreen{--bulma-grid-cell-column-end:11}.cell.is-col-from-end-11-widescreen{--bulma-grid-cell-column-start:-11}.cell.is-col-span-11-widescreen{--bulma-grid-cell-column-span:11}.cell.is-row-start-11-widescreen{--bulma-grid-cell-row-start:11}.cell.is-row-end-11-widescreen{--bulma-grid-cell-row-end:11}.cell.is-row-from-end-11-widescreen{--bulma-grid-cell-row-start:-11}.cell.is-row-span-11-widescreen{--bulma-grid-cell-row-span:11}.cell.is-col-start-12-widescreen{--bulma-grid-cell-column-start:12}.cell.is-col-end-12-widescreen{--bulma-grid-cell-column-end:12}.cell.is-col-from-end-12-widescreen{--bulma-grid-cell-column-start:-12}.cell.is-col-span-12-widescreen{--bulma-grid-cell-column-span:12}.cell.is-row-start-12-widescreen{--bulma-grid-cell-row-start:12}.cell.is-row-end-12-widescreen{--bulma-grid-cell-row-end:12}.cell.is-row-from-end-12-widescreen{--bulma-grid-cell-row-start:-12}.cell.is-row-span-12-widescreen{--bulma-grid-cell-row-span:12}}@media screen and (width>=1216px) and (width<=1407px){.cell.is-col-start-1-widescreen-only{--bulma-grid-cell-column-start:1}.cell.is-col-end-1-widescreen-only{--bulma-grid-cell-column-end:1}.cell.is-col-from-end-1-widescreen-only{--bulma-grid-cell-column-start:-1}.cell.is-col-span-1-widescreen-only{--bulma-grid-cell-column-span:1}.cell.is-row-start-1-widescreen-only{--bulma-grid-cell-row-start:1}.cell.is-row-end-1-widescreen-only{--bulma-grid-cell-row-end:1}.cell.is-row-from-end-1-widescreen-only{--bulma-grid-cell-row-start:-1}.cell.is-row-span-1-widescreen-only{--bulma-grid-cell-row-span:1}.cell.is-col-start-2-widescreen-only{--bulma-grid-cell-column-start:2}.cell.is-col-end-2-widescreen-only{--bulma-grid-cell-column-end:2}.cell.is-col-from-end-2-widescreen-only{--bulma-grid-cell-column-start:-2}.cell.is-col-span-2-widescreen-only{--bulma-grid-cell-column-span:2}.cell.is-row-start-2-widescreen-only{--bulma-grid-cell-row-start:2}.cell.is-row-end-2-widescreen-only{--bulma-grid-cell-row-end:2}.cell.is-row-from-end-2-widescreen-only{--bulma-grid-cell-row-start:-2}.cell.is-row-span-2-widescreen-only{--bulma-grid-cell-row-span:2}.cell.is-col-start-3-widescreen-only{--bulma-grid-cell-column-start:3}.cell.is-col-end-3-widescreen-only{--bulma-grid-cell-column-end:3}.cell.is-col-from-end-3-widescreen-only{--bulma-grid-cell-column-start:-3}.cell.is-col-span-3-widescreen-only{--bulma-grid-cell-column-span:3}.cell.is-row-start-3-widescreen-only{--bulma-grid-cell-row-start:3}.cell.is-row-end-3-widescreen-only{--bulma-grid-cell-row-end:3}.cell.is-row-from-end-3-widescreen-only{--bulma-grid-cell-row-start:-3}.cell.is-row-span-3-widescreen-only{--bulma-grid-cell-row-span:3}.cell.is-col-start-4-widescreen-only{--bulma-grid-cell-column-start:4}.cell.is-col-end-4-widescreen-only{--bulma-grid-cell-column-end:4}.cell.is-col-from-end-4-widescreen-only{--bulma-grid-cell-column-start:-4}.cell.is-col-span-4-widescreen-only{--bulma-grid-cell-column-span:4}.cell.is-row-start-4-widescreen-only{--bulma-grid-cell-row-start:4}.cell.is-row-end-4-widescreen-only{--bulma-grid-cell-row-end:4}.cell.is-row-from-end-4-widescreen-only{--bulma-grid-cell-row-start:-4}.cell.is-row-span-4-widescreen-only{--bulma-grid-cell-row-span:4}.cell.is-col-start-5-widescreen-only{--bulma-grid-cell-column-start:5}.cell.is-col-end-5-widescreen-only{--bulma-grid-cell-column-end:5}.cell.is-col-from-end-5-widescreen-only{--bulma-grid-cell-column-start:-5}.cell.is-col-span-5-widescreen-only{--bulma-grid-cell-column-span:5}.cell.is-row-start-5-widescreen-only{--bulma-grid-cell-row-start:5}.cell.is-row-end-5-widescreen-only{--bulma-grid-cell-row-end:5}.cell.is-row-from-end-5-widescreen-only{--bulma-grid-cell-row-start:-5}.cell.is-row-span-5-widescreen-only{--bulma-grid-cell-row-span:5}.cell.is-col-start-6-widescreen-only{--bulma-grid-cell-column-start:6}.cell.is-col-end-6-widescreen-only{--bulma-grid-cell-column-end:6}.cell.is-col-from-end-6-widescreen-only{--bulma-grid-cell-column-start:-6}.cell.is-col-span-6-widescreen-only{--bulma-grid-cell-column-span:6}.cell.is-row-start-6-widescreen-only{--bulma-grid-cell-row-start:6}.cell.is-row-end-6-widescreen-only{--bulma-grid-cell-row-end:6}.cell.is-row-from-end-6-widescreen-only{--bulma-grid-cell-row-start:-6}.cell.is-row-span-6-widescreen-only{--bulma-grid-cell-row-span:6}.cell.is-col-start-7-widescreen-only{--bulma-grid-cell-column-start:7}.cell.is-col-end-7-widescreen-only{--bulma-grid-cell-column-end:7}.cell.is-col-from-end-7-widescreen-only{--bulma-grid-cell-column-start:-7}.cell.is-col-span-7-widescreen-only{--bulma-grid-cell-column-span:7}.cell.is-row-start-7-widescreen-only{--bulma-grid-cell-row-start:7}.cell.is-row-end-7-widescreen-only{--bulma-grid-cell-row-end:7}.cell.is-row-from-end-7-widescreen-only{--bulma-grid-cell-row-start:-7}.cell.is-row-span-7-widescreen-only{--bulma-grid-cell-row-span:7}.cell.is-col-start-8-widescreen-only{--bulma-grid-cell-column-start:8}.cell.is-col-end-8-widescreen-only{--bulma-grid-cell-column-end:8}.cell.is-col-from-end-8-widescreen-only{--bulma-grid-cell-column-start:-8}.cell.is-col-span-8-widescreen-only{--bulma-grid-cell-column-span:8}.cell.is-row-start-8-widescreen-only{--bulma-grid-cell-row-start:8}.cell.is-row-end-8-widescreen-only{--bulma-grid-cell-row-end:8}.cell.is-row-from-end-8-widescreen-only{--bulma-grid-cell-row-start:-8}.cell.is-row-span-8-widescreen-only{--bulma-grid-cell-row-span:8}.cell.is-col-start-9-widescreen-only{--bulma-grid-cell-column-start:9}.cell.is-col-end-9-widescreen-only{--bulma-grid-cell-column-end:9}.cell.is-col-from-end-9-widescreen-only{--bulma-grid-cell-column-start:-9}.cell.is-col-span-9-widescreen-only{--bulma-grid-cell-column-span:9}.cell.is-row-start-9-widescreen-only{--bulma-grid-cell-row-start:9}.cell.is-row-end-9-widescreen-only{--bulma-grid-cell-row-end:9}.cell.is-row-from-end-9-widescreen-only{--bulma-grid-cell-row-start:-9}.cell.is-row-span-9-widescreen-only{--bulma-grid-cell-row-span:9}.cell.is-col-start-10-widescreen-only{--bulma-grid-cell-column-start:10}.cell.is-col-end-10-widescreen-only{--bulma-grid-cell-column-end:10}.cell.is-col-from-end-10-widescreen-only{--bulma-grid-cell-column-start:-10}.cell.is-col-span-10-widescreen-only{--bulma-grid-cell-column-span:10}.cell.is-row-start-10-widescreen-only{--bulma-grid-cell-row-start:10}.cell.is-row-end-10-widescreen-only{--bulma-grid-cell-row-end:10}.cell.is-row-from-end-10-widescreen-only{--bulma-grid-cell-row-start:-10}.cell.is-row-span-10-widescreen-only{--bulma-grid-cell-row-span:10}.cell.is-col-start-11-widescreen-only{--bulma-grid-cell-column-start:11}.cell.is-col-end-11-widescreen-only{--bulma-grid-cell-column-end:11}.cell.is-col-from-end-11-widescreen-only{--bulma-grid-cell-column-start:-11}.cell.is-col-span-11-widescreen-only{--bulma-grid-cell-column-span:11}.cell.is-row-start-11-widescreen-only{--bulma-grid-cell-row-start:11}.cell.is-row-end-11-widescreen-only{--bulma-grid-cell-row-end:11}.cell.is-row-from-end-11-widescreen-only{--bulma-grid-cell-row-start:-11}.cell.is-row-span-11-widescreen-only{--bulma-grid-cell-row-span:11}.cell.is-col-start-12-widescreen-only{--bulma-grid-cell-column-start:12}.cell.is-col-end-12-widescreen-only{--bulma-grid-cell-column-end:12}.cell.is-col-from-end-12-widescreen-only{--bulma-grid-cell-column-start:-12}.cell.is-col-span-12-widescreen-only{--bulma-grid-cell-column-span:12}.cell.is-row-start-12-widescreen-only{--bulma-grid-cell-row-start:12}.cell.is-row-end-12-widescreen-only{--bulma-grid-cell-row-end:12}.cell.is-row-from-end-12-widescreen-only{--bulma-grid-cell-row-start:-12}.cell.is-row-span-12-widescreen-only{--bulma-grid-cell-row-span:12}}@media screen and (width>=1408px){.cell.is-col-start-1-fullhd{--bulma-grid-cell-column-start:1}.cell.is-col-end-1-fullhd{--bulma-grid-cell-column-end:1}.cell.is-col-from-end-1-fullhd{--bulma-grid-cell-column-start:-1}.cell.is-col-span-1-fullhd{--bulma-grid-cell-column-span:1}.cell.is-row-start-1-fullhd{--bulma-grid-cell-row-start:1}.cell.is-row-end-1-fullhd{--bulma-grid-cell-row-end:1}.cell.is-row-from-end-1-fullhd{--bulma-grid-cell-row-start:-1}.cell.is-row-span-1-fullhd{--bulma-grid-cell-row-span:1}.cell.is-col-start-2-fullhd{--bulma-grid-cell-column-start:2}.cell.is-col-end-2-fullhd{--bulma-grid-cell-column-end:2}.cell.is-col-from-end-2-fullhd{--bulma-grid-cell-column-start:-2}.cell.is-col-span-2-fullhd{--bulma-grid-cell-column-span:2}.cell.is-row-start-2-fullhd{--bulma-grid-cell-row-start:2}.cell.is-row-end-2-fullhd{--bulma-grid-cell-row-end:2}.cell.is-row-from-end-2-fullhd{--bulma-grid-cell-row-start:-2}.cell.is-row-span-2-fullhd{--bulma-grid-cell-row-span:2}.cell.is-col-start-3-fullhd{--bulma-grid-cell-column-start:3}.cell.is-col-end-3-fullhd{--bulma-grid-cell-column-end:3}.cell.is-col-from-end-3-fullhd{--bulma-grid-cell-column-start:-3}.cell.is-col-span-3-fullhd{--bulma-grid-cell-column-span:3}.cell.is-row-start-3-fullhd{--bulma-grid-cell-row-start:3}.cell.is-row-end-3-fullhd{--bulma-grid-cell-row-end:3}.cell.is-row-from-end-3-fullhd{--bulma-grid-cell-row-start:-3}.cell.is-row-span-3-fullhd{--bulma-grid-cell-row-span:3}.cell.is-col-start-4-fullhd{--bulma-grid-cell-column-start:4}.cell.is-col-end-4-fullhd{--bulma-grid-cell-column-end:4}.cell.is-col-from-end-4-fullhd{--bulma-grid-cell-column-start:-4}.cell.is-col-span-4-fullhd{--bulma-grid-cell-column-span:4}.cell.is-row-start-4-fullhd{--bulma-grid-cell-row-start:4}.cell.is-row-end-4-fullhd{--bulma-grid-cell-row-end:4}.cell.is-row-from-end-4-fullhd{--bulma-grid-cell-row-start:-4}.cell.is-row-span-4-fullhd{--bulma-grid-cell-row-span:4}.cell.is-col-start-5-fullhd{--bulma-grid-cell-column-start:5}.cell.is-col-end-5-fullhd{--bulma-grid-cell-column-end:5}.cell.is-col-from-end-5-fullhd{--bulma-grid-cell-column-start:-5}.cell.is-col-span-5-fullhd{--bulma-grid-cell-column-span:5}.cell.is-row-start-5-fullhd{--bulma-grid-cell-row-start:5}.cell.is-row-end-5-fullhd{--bulma-grid-cell-row-end:5}.cell.is-row-from-end-5-fullhd{--bulma-grid-cell-row-start:-5}.cell.is-row-span-5-fullhd{--bulma-grid-cell-row-span:5}.cell.is-col-start-6-fullhd{--bulma-grid-cell-column-start:6}.cell.is-col-end-6-fullhd{--bulma-grid-cell-column-end:6}.cell.is-col-from-end-6-fullhd{--bulma-grid-cell-column-start:-6}.cell.is-col-span-6-fullhd{--bulma-grid-cell-column-span:6}.cell.is-row-start-6-fullhd{--bulma-grid-cell-row-start:6}.cell.is-row-end-6-fullhd{--bulma-grid-cell-row-end:6}.cell.is-row-from-end-6-fullhd{--bulma-grid-cell-row-start:-6}.cell.is-row-span-6-fullhd{--bulma-grid-cell-row-span:6}.cell.is-col-start-7-fullhd{--bulma-grid-cell-column-start:7}.cell.is-col-end-7-fullhd{--bulma-grid-cell-column-end:7}.cell.is-col-from-end-7-fullhd{--bulma-grid-cell-column-start:-7}.cell.is-col-span-7-fullhd{--bulma-grid-cell-column-span:7}.cell.is-row-start-7-fullhd{--bulma-grid-cell-row-start:7}.cell.is-row-end-7-fullhd{--bulma-grid-cell-row-end:7}.cell.is-row-from-end-7-fullhd{--bulma-grid-cell-row-start:-7}.cell.is-row-span-7-fullhd{--bulma-grid-cell-row-span:7}.cell.is-col-start-8-fullhd{--bulma-grid-cell-column-start:8}.cell.is-col-end-8-fullhd{--bulma-grid-cell-column-end:8}.cell.is-col-from-end-8-fullhd{--bulma-grid-cell-column-start:-8}.cell.is-col-span-8-fullhd{--bulma-grid-cell-column-span:8}.cell.is-row-start-8-fullhd{--bulma-grid-cell-row-start:8}.cell.is-row-end-8-fullhd{--bulma-grid-cell-row-end:8}.cell.is-row-from-end-8-fullhd{--bulma-grid-cell-row-start:-8}.cell.is-row-span-8-fullhd{--bulma-grid-cell-row-span:8}.cell.is-col-start-9-fullhd{--bulma-grid-cell-column-start:9}.cell.is-col-end-9-fullhd{--bulma-grid-cell-column-end:9}.cell.is-col-from-end-9-fullhd{--bulma-grid-cell-column-start:-9}.cell.is-col-span-9-fullhd{--bulma-grid-cell-column-span:9}.cell.is-row-start-9-fullhd{--bulma-grid-cell-row-start:9}.cell.is-row-end-9-fullhd{--bulma-grid-cell-row-end:9}.cell.is-row-from-end-9-fullhd{--bulma-grid-cell-row-start:-9}.cell.is-row-span-9-fullhd{--bulma-grid-cell-row-span:9}.cell.is-col-start-10-fullhd{--bulma-grid-cell-column-start:10}.cell.is-col-end-10-fullhd{--bulma-grid-cell-column-end:10}.cell.is-col-from-end-10-fullhd{--bulma-grid-cell-column-start:-10}.cell.is-col-span-10-fullhd{--bulma-grid-cell-column-span:10}.cell.is-row-start-10-fullhd{--bulma-grid-cell-row-start:10}.cell.is-row-end-10-fullhd{--bulma-grid-cell-row-end:10}.cell.is-row-from-end-10-fullhd{--bulma-grid-cell-row-start:-10}.cell.is-row-span-10-fullhd{--bulma-grid-cell-row-span:10}.cell.is-col-start-11-fullhd{--bulma-grid-cell-column-start:11}.cell.is-col-end-11-fullhd{--bulma-grid-cell-column-end:11}.cell.is-col-from-end-11-fullhd{--bulma-grid-cell-column-start:-11}.cell.is-col-span-11-fullhd{--bulma-grid-cell-column-span:11}.cell.is-row-start-11-fullhd{--bulma-grid-cell-row-start:11}.cell.is-row-end-11-fullhd{--bulma-grid-cell-row-end:11}.cell.is-row-from-end-11-fullhd{--bulma-grid-cell-row-start:-11}.cell.is-row-span-11-fullhd{--bulma-grid-cell-row-span:11}.cell.is-col-start-12-fullhd{--bulma-grid-cell-column-start:12}.cell.is-col-end-12-fullhd{--bulma-grid-cell-column-end:12}.cell.is-col-from-end-12-fullhd{--bulma-grid-cell-column-start:-12}.cell.is-col-span-12-fullhd{--bulma-grid-cell-column-span:12}.cell.is-row-start-12-fullhd{--bulma-grid-cell-row-start:12}.cell.is-row-end-12-fullhd{--bulma-grid-cell-row-end:12}.cell.is-row-from-end-12-fullhd{--bulma-grid-cell-row-start:-12}.cell.is-row-span-12-fullhd{--bulma-grid-cell-row-span:12}}.container{flex-grow:1;width:100%;margin:0 auto;position:relative}.container.is-fluid{width:100%;padding-left:32px;padding-right:32px;max-width:none!important}.container.is-max-tablet{max-width:705px}@media screen and (width>=1024px){.container{max-width:960px}}@media screen and (width<=1215px){.container.is-widescreen:not(.is-max-tablet):not(.is-max-desktop){max-width:1152px}}@media screen and (width<=1407px){.container.is-fullhd:not(.is-max-tablet):not(.is-max-desktop):not(.is-max-widescreen){max-width:1344px}}@media screen and (width>=1216px){.container:not(.is-max-tablet):not(.is-max-desktop){max-width:1152px}}@media screen and (width>=1408px){.container:not(.is-max-tablet):not(.is-max-desktop):not(.is-max-widescreen){max-width:1344px}}.footer{--bulma-footer-background-color:var(--bulma-scheme-main-bis);--bulma-footer-color:false;--bulma-footer-padding:3rem 1.5rem 6rem;background-color:var(--bulma-footer-background-color);padding:var(--bulma-footer-padding)}.hero{--bulma-hero-body-padding:3rem 1.5rem;--bulma-hero-body-padding-tablet:3rem 3rem;--bulma-hero-body-padding-small:1.5rem;--bulma-hero-body-padding-medium:9rem 4.5rem;--bulma-hero-body-padding-large:18rem 6rem;flex-direction:column;justify-content:space-between;align-items:stretch;display:flex}.hero .navbar{background:0 0}.hero .tabs ul{border-bottom:none}.hero.is-white{--bulma-hero-h:var(--bulma-white-h);--bulma-hero-s:var(--bulma-white-s);--bulma-hero-background-l:var(--bulma-white-l);--bulma-hero-color-l:var(--bulma-white-invert-l);background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l));color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))}.hero.is-white .navbar{--bulma-navbar-item-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-navbar-item-hover-background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-navbar-item-hover-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l));--bulma-navbar-item-active-background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-navbar-item-active-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l))}.hero.is-white .tabs{--bulma-tabs-link-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-tabs-boxed-link-active-background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-tabs-boxed-link-active-border-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l));--bulma-tabs-link-active-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l))}.hero.is-white .subtitle{--bulma-subtitle-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-subtitle-strong-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))}.hero.is-white .title{--bulma-title-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-title-strong-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))}.hero.is-white.is-bold{background-image:linear-gradient(141deg,hsl(calc(var(--bulma-hero-h) - 5deg),calc(var(--bulma-hero-s) + 10%),calc(var(--bulma-hero-background-l) + 5%))0%,hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l))71%,hsl(calc(var(--bulma-hero-h) + 5deg),calc(var(--bulma-hero-s) - 10%),calc(var(--bulma-hero-background-l) - 5%))100%)}@media screen and (width<=768px){.hero.is-white.is-bold .navbar-menu{background-image:linear-gradient(141deg,hsl(calc(var(--bulma-hero-h) - 5deg),calc(var(--bulma-hero-s) + 10%),calc(var(--bulma-hero-background-l) + 5%))0%,hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))71%,hsl(calc(var(--bulma-hero-h) + 5deg),calc(var(--bulma-hero-s) - 10%),calc(var(--bulma-hero-background-l) - 5%))100%)}}.hero.is-black{--bulma-hero-h:var(--bulma-black-h);--bulma-hero-s:var(--bulma-black-s);--bulma-hero-background-l:var(--bulma-black-l);--bulma-hero-color-l:var(--bulma-black-invert-l);background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l));color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))}.hero.is-black .navbar{--bulma-navbar-item-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-navbar-item-hover-background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-navbar-item-hover-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l));--bulma-navbar-item-active-background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-navbar-item-active-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l))}.hero.is-black .tabs{--bulma-tabs-link-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-tabs-boxed-link-active-background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-tabs-boxed-link-active-border-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l));--bulma-tabs-link-active-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l))}.hero.is-black .subtitle{--bulma-subtitle-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-subtitle-strong-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))}.hero.is-black .title{--bulma-title-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-title-strong-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))}.hero.is-black.is-bold{background-image:linear-gradient(141deg,hsl(calc(var(--bulma-hero-h) - 5deg),calc(var(--bulma-hero-s) + 10%),calc(var(--bulma-hero-background-l) + 5%))0%,hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l))71%,hsl(calc(var(--bulma-hero-h) + 5deg),calc(var(--bulma-hero-s) - 10%),calc(var(--bulma-hero-background-l) - 5%))100%)}@media screen and (width<=768px){.hero.is-black.is-bold .navbar-menu{background-image:linear-gradient(141deg,hsl(calc(var(--bulma-hero-h) - 5deg),calc(var(--bulma-hero-s) + 10%),calc(var(--bulma-hero-background-l) + 5%))0%,hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))71%,hsl(calc(var(--bulma-hero-h) + 5deg),calc(var(--bulma-hero-s) - 10%),calc(var(--bulma-hero-background-l) - 5%))100%)}}.hero.is-light{--bulma-hero-h:var(--bulma-light-h);--bulma-hero-s:var(--bulma-light-s);--bulma-hero-background-l:var(--bulma-light-l);--bulma-hero-color-l:var(--bulma-light-invert-l);background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l));color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))}.hero.is-light .navbar{--bulma-navbar-item-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-navbar-item-hover-background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-navbar-item-hover-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l));--bulma-navbar-item-active-background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-navbar-item-active-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l))}.hero.is-light .tabs{--bulma-tabs-link-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-tabs-boxed-link-active-background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-tabs-boxed-link-active-border-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l));--bulma-tabs-link-active-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l))}.hero.is-light .subtitle{--bulma-subtitle-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-subtitle-strong-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))}.hero.is-light .title{--bulma-title-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-title-strong-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))}.hero.is-light.is-bold{background-image:linear-gradient(141deg,hsl(calc(var(--bulma-hero-h) - 5deg),calc(var(--bulma-hero-s) + 10%),calc(var(--bulma-hero-background-l) + 5%))0%,hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l))71%,hsl(calc(var(--bulma-hero-h) + 5deg),calc(var(--bulma-hero-s) - 10%),calc(var(--bulma-hero-background-l) - 5%))100%)}@media screen and (width<=768px){.hero.is-light.is-bold .navbar-menu{background-image:linear-gradient(141deg,hsl(calc(var(--bulma-hero-h) - 5deg),calc(var(--bulma-hero-s) + 10%),calc(var(--bulma-hero-background-l) + 5%))0%,hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))71%,hsl(calc(var(--bulma-hero-h) + 5deg),calc(var(--bulma-hero-s) - 10%),calc(var(--bulma-hero-background-l) - 5%))100%)}}.hero.is-dark{--bulma-hero-h:var(--bulma-dark-h);--bulma-hero-s:var(--bulma-dark-s);--bulma-hero-background-l:var(--bulma-dark-l);--bulma-hero-color-l:var(--bulma-dark-invert-l);background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l));color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))}.hero.is-dark .navbar{--bulma-navbar-item-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-navbar-item-hover-background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-navbar-item-hover-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l));--bulma-navbar-item-active-background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-navbar-item-active-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l))}.hero.is-dark .tabs{--bulma-tabs-link-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-tabs-boxed-link-active-background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-tabs-boxed-link-active-border-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l));--bulma-tabs-link-active-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l))}.hero.is-dark .subtitle{--bulma-subtitle-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-subtitle-strong-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))}.hero.is-dark .title{--bulma-title-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-title-strong-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))}.hero.is-dark.is-bold{background-image:linear-gradient(141deg,hsl(calc(var(--bulma-hero-h) - 5deg),calc(var(--bulma-hero-s) + 10%),calc(var(--bulma-hero-background-l) + 5%))0%,hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l))71%,hsl(calc(var(--bulma-hero-h) + 5deg),calc(var(--bulma-hero-s) - 10%),calc(var(--bulma-hero-background-l) - 5%))100%)}@media screen and (width<=768px){.hero.is-dark.is-bold .navbar-menu{background-image:linear-gradient(141deg,hsl(calc(var(--bulma-hero-h) - 5deg),calc(var(--bulma-hero-s) + 10%),calc(var(--bulma-hero-background-l) + 5%))0%,hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))71%,hsl(calc(var(--bulma-hero-h) + 5deg),calc(var(--bulma-hero-s) - 10%),calc(var(--bulma-hero-background-l) - 5%))100%)}}.hero.is-text{--bulma-hero-h:var(--bulma-text-h);--bulma-hero-s:var(--bulma-text-s);--bulma-hero-background-l:var(--bulma-text-l);--bulma-hero-color-l:var(--bulma-text-invert-l);background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l));color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))}.hero.is-text .navbar{--bulma-navbar-item-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-navbar-item-hover-background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-navbar-item-hover-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l));--bulma-navbar-item-active-background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-navbar-item-active-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l))}.hero.is-text .tabs{--bulma-tabs-link-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-tabs-boxed-link-active-background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-tabs-boxed-link-active-border-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l));--bulma-tabs-link-active-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l))}.hero.is-text .subtitle{--bulma-subtitle-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-subtitle-strong-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))}.hero.is-text .title{--bulma-title-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-title-strong-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))}.hero.is-text.is-bold{background-image:linear-gradient(141deg,hsl(calc(var(--bulma-hero-h) - 5deg),calc(var(--bulma-hero-s) + 10%),calc(var(--bulma-hero-background-l) + 5%))0%,hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l))71%,hsl(calc(var(--bulma-hero-h) + 5deg),calc(var(--bulma-hero-s) - 10%),calc(var(--bulma-hero-background-l) - 5%))100%)}@media screen and (width<=768px){.hero.is-text.is-bold .navbar-menu{background-image:linear-gradient(141deg,hsl(calc(var(--bulma-hero-h) - 5deg),calc(var(--bulma-hero-s) + 10%),calc(var(--bulma-hero-background-l) + 5%))0%,hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))71%,hsl(calc(var(--bulma-hero-h) + 5deg),calc(var(--bulma-hero-s) - 10%),calc(var(--bulma-hero-background-l) - 5%))100%)}}.hero.is-primary{--bulma-hero-h:var(--bulma-primary-h);--bulma-hero-s:var(--bulma-primary-s);--bulma-hero-background-l:var(--bulma-primary-l);--bulma-hero-color-l:var(--bulma-primary-invert-l);background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l));color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))}.hero.is-primary .navbar{--bulma-navbar-item-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-navbar-item-hover-background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-navbar-item-hover-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l));--bulma-navbar-item-active-background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-navbar-item-active-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l))}.hero.is-primary .tabs{--bulma-tabs-link-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-tabs-boxed-link-active-background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-tabs-boxed-link-active-border-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l));--bulma-tabs-link-active-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l))}.hero.is-primary .subtitle{--bulma-subtitle-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-subtitle-strong-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))}.hero.is-primary .title{--bulma-title-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-title-strong-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))}.hero.is-primary.is-bold{background-image:linear-gradient(141deg,hsl(calc(var(--bulma-hero-h) - 5deg),calc(var(--bulma-hero-s) + 10%),calc(var(--bulma-hero-background-l) + 5%))0%,hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l))71%,hsl(calc(var(--bulma-hero-h) + 5deg),calc(var(--bulma-hero-s) - 10%),calc(var(--bulma-hero-background-l) - 5%))100%)}@media screen and (width<=768px){.hero.is-primary.is-bold .navbar-menu{background-image:linear-gradient(141deg,hsl(calc(var(--bulma-hero-h) - 5deg),calc(var(--bulma-hero-s) + 10%),calc(var(--bulma-hero-background-l) + 5%))0%,hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))71%,hsl(calc(var(--bulma-hero-h) + 5deg),calc(var(--bulma-hero-s) - 10%),calc(var(--bulma-hero-background-l) - 5%))100%)}}.hero.is-link{--bulma-hero-h:var(--bulma-link-h);--bulma-hero-s:var(--bulma-link-s);--bulma-hero-background-l:var(--bulma-link-l);--bulma-hero-color-l:var(--bulma-link-invert-l);background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l));color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))}.hero.is-link .navbar{--bulma-navbar-item-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-navbar-item-hover-background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-navbar-item-hover-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l));--bulma-navbar-item-active-background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-navbar-item-active-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l))}.hero.is-link .tabs{--bulma-tabs-link-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-tabs-boxed-link-active-background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-tabs-boxed-link-active-border-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l));--bulma-tabs-link-active-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l))}.hero.is-link .subtitle{--bulma-subtitle-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-subtitle-strong-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))}.hero.is-link .title{--bulma-title-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-title-strong-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))}.hero.is-link.is-bold{background-image:linear-gradient(141deg,hsl(calc(var(--bulma-hero-h) - 5deg),calc(var(--bulma-hero-s) + 10%),calc(var(--bulma-hero-background-l) + 5%))0%,hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l))71%,hsl(calc(var(--bulma-hero-h) + 5deg),calc(var(--bulma-hero-s) - 10%),calc(var(--bulma-hero-background-l) - 5%))100%)}@media screen and (width<=768px){.hero.is-link.is-bold .navbar-menu{background-image:linear-gradient(141deg,hsl(calc(var(--bulma-hero-h) - 5deg),calc(var(--bulma-hero-s) + 10%),calc(var(--bulma-hero-background-l) + 5%))0%,hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))71%,hsl(calc(var(--bulma-hero-h) + 5deg),calc(var(--bulma-hero-s) - 10%),calc(var(--bulma-hero-background-l) - 5%))100%)}}.hero.is-info{--bulma-hero-h:var(--bulma-info-h);--bulma-hero-s:var(--bulma-info-s);--bulma-hero-background-l:var(--bulma-info-l);--bulma-hero-color-l:var(--bulma-info-invert-l);background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l));color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))}.hero.is-info .navbar{--bulma-navbar-item-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-navbar-item-hover-background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-navbar-item-hover-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l));--bulma-navbar-item-active-background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-navbar-item-active-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l))}.hero.is-info .tabs{--bulma-tabs-link-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-tabs-boxed-link-active-background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-tabs-boxed-link-active-border-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l));--bulma-tabs-link-active-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l))}.hero.is-info .subtitle{--bulma-subtitle-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-subtitle-strong-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))}.hero.is-info .title{--bulma-title-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-title-strong-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))}.hero.is-info.is-bold{background-image:linear-gradient(141deg,hsl(calc(var(--bulma-hero-h) - 5deg),calc(var(--bulma-hero-s) + 10%),calc(var(--bulma-hero-background-l) + 5%))0%,hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l))71%,hsl(calc(var(--bulma-hero-h) + 5deg),calc(var(--bulma-hero-s) - 10%),calc(var(--bulma-hero-background-l) - 5%))100%)}@media screen and (width<=768px){.hero.is-info.is-bold .navbar-menu{background-image:linear-gradient(141deg,hsl(calc(var(--bulma-hero-h) - 5deg),calc(var(--bulma-hero-s) + 10%),calc(var(--bulma-hero-background-l) + 5%))0%,hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))71%,hsl(calc(var(--bulma-hero-h) + 5deg),calc(var(--bulma-hero-s) - 10%),calc(var(--bulma-hero-background-l) - 5%))100%)}}.hero.is-success{--bulma-hero-h:var(--bulma-success-h);--bulma-hero-s:var(--bulma-success-s);--bulma-hero-background-l:var(--bulma-success-l);--bulma-hero-color-l:var(--bulma-success-invert-l);background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l));color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))}.hero.is-success .navbar{--bulma-navbar-item-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-navbar-item-hover-background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-navbar-item-hover-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l));--bulma-navbar-item-active-background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-navbar-item-active-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l))}.hero.is-success .tabs{--bulma-tabs-link-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-tabs-boxed-link-active-background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-tabs-boxed-link-active-border-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l));--bulma-tabs-link-active-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l))}.hero.is-success .subtitle{--bulma-subtitle-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-subtitle-strong-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))}.hero.is-success .title{--bulma-title-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-title-strong-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))}.hero.is-success.is-bold{background-image:linear-gradient(141deg,hsl(calc(var(--bulma-hero-h) - 5deg),calc(var(--bulma-hero-s) + 10%),calc(var(--bulma-hero-background-l) + 5%))0%,hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l))71%,hsl(calc(var(--bulma-hero-h) + 5deg),calc(var(--bulma-hero-s) - 10%),calc(var(--bulma-hero-background-l) - 5%))100%)}@media screen and (width<=768px){.hero.is-success.is-bold .navbar-menu{background-image:linear-gradient(141deg,hsl(calc(var(--bulma-hero-h) - 5deg),calc(var(--bulma-hero-s) + 10%),calc(var(--bulma-hero-background-l) + 5%))0%,hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))71%,hsl(calc(var(--bulma-hero-h) + 5deg),calc(var(--bulma-hero-s) - 10%),calc(var(--bulma-hero-background-l) - 5%))100%)}}.hero.is-warning{--bulma-hero-h:var(--bulma-warning-h);--bulma-hero-s:var(--bulma-warning-s);--bulma-hero-background-l:var(--bulma-warning-l);--bulma-hero-color-l:var(--bulma-warning-invert-l);background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l));color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))}.hero.is-warning .navbar{--bulma-navbar-item-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-navbar-item-hover-background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-navbar-item-hover-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l));--bulma-navbar-item-active-background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-navbar-item-active-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l))}.hero.is-warning .tabs{--bulma-tabs-link-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-tabs-boxed-link-active-background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-tabs-boxed-link-active-border-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l));--bulma-tabs-link-active-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l))}.hero.is-warning .subtitle{--bulma-subtitle-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-subtitle-strong-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))}.hero.is-warning .title{--bulma-title-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-title-strong-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))}.hero.is-warning.is-bold{background-image:linear-gradient(141deg,hsl(calc(var(--bulma-hero-h) - 5deg),calc(var(--bulma-hero-s) + 10%),calc(var(--bulma-hero-background-l) + 5%))0%,hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l))71%,hsl(calc(var(--bulma-hero-h) + 5deg),calc(var(--bulma-hero-s) - 10%),calc(var(--bulma-hero-background-l) - 5%))100%)}@media screen and (width<=768px){.hero.is-warning.is-bold .navbar-menu{background-image:linear-gradient(141deg,hsl(calc(var(--bulma-hero-h) - 5deg),calc(var(--bulma-hero-s) + 10%),calc(var(--bulma-hero-background-l) + 5%))0%,hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))71%,hsl(calc(var(--bulma-hero-h) + 5deg),calc(var(--bulma-hero-s) - 10%),calc(var(--bulma-hero-background-l) - 5%))100%)}}.hero.is-danger{--bulma-hero-h:var(--bulma-danger-h);--bulma-hero-s:var(--bulma-danger-s);--bulma-hero-background-l:var(--bulma-danger-l);--bulma-hero-color-l:var(--bulma-danger-invert-l);background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l));color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))}.hero.is-danger .navbar{--bulma-navbar-item-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-navbar-item-hover-background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-navbar-item-hover-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l));--bulma-navbar-item-active-background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-navbar-item-active-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l))}.hero.is-danger .tabs{--bulma-tabs-link-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-tabs-boxed-link-active-background-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-tabs-boxed-link-active-border-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l));--bulma-tabs-link-active-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l))}.hero.is-danger .subtitle{--bulma-subtitle-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-subtitle-strong-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))}.hero.is-danger .title{--bulma-title-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l));--bulma-title-strong-color:hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))}.hero.is-danger.is-bold{background-image:linear-gradient(141deg,hsl(calc(var(--bulma-hero-h) - 5deg),calc(var(--bulma-hero-s) + 10%),calc(var(--bulma-hero-background-l) + 5%))0%,hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-background-l))71%,hsl(calc(var(--bulma-hero-h) + 5deg),calc(var(--bulma-hero-s) - 10%),calc(var(--bulma-hero-background-l) - 5%))100%)}@media screen and (width<=768px){.hero.is-danger.is-bold .navbar-menu{background-image:linear-gradient(141deg,hsl(calc(var(--bulma-hero-h) - 5deg),calc(var(--bulma-hero-s) + 10%),calc(var(--bulma-hero-background-l) + 5%))0%,hsl(var(--bulma-hero-h),var(--bulma-hero-s),var(--bulma-hero-color-l))71%,hsl(calc(var(--bulma-hero-h) + 5deg),calc(var(--bulma-hero-s) - 10%),calc(var(--bulma-hero-background-l) - 5%))100%)}}.hero.is-small .hero-body{padding:var(--bulma-hero-body-padding-small)}@media screen and (width>=769px),print{.hero.is-medium .hero-body{padding:var(--bulma-hero-body-padding-medium)}.hero.is-large .hero-body{padding:var(--bulma-hero-body-padding-large)}}.hero.is-halfheight .hero-body,.hero.is-fullheight .hero-body,.hero.is-fullheight-with-navbar .hero-body{align-items:center;display:flex}.hero.is-halfheight .hero-body>.container,.hero.is-fullheight .hero-body>.container,.hero.is-fullheight-with-navbar .hero-body>.container{flex-grow:1;flex-shrink:1}.hero.is-halfheight{min-height:50vh}.hero.is-fullheight{min-height:100vh}.hero-video{overflow:hidden}.hero-video video{min-width:100%;min-height:100%;position:absolute;top:50%;left:50%;transform:translate(-50%,-50%)}.hero-video.is-transparent{opacity:.3}@media screen and (width<=768px){.hero-video{display:none}}.hero-buttons{margin-top:1.5rem}@media screen and (width<=768px){.hero-buttons .button{display:flex}.hero-buttons .button:not(:last-child){margin-bottom:.75rem}}@media screen and (width>=769px),print{.hero-buttons{justify-content:center;display:flex}.hero-buttons .button:not(:last-child){margin-inline-end:1.5rem}}.hero-head,.hero-foot{flex-grow:0;flex-shrink:0}.hero-body{padding:var(--bulma-hero-body-padding);flex-grow:1;flex-shrink:0}@media screen and (width>=769px),print{.hero-body{padding:var(--bulma-hero-body-padding-tablet)}}.level{--bulma-level-item-spacing:calc(var(--bulma-block-spacing)*.5);justify-content:space-between;align-items:center;gap:var(--bulma-level-item-spacing);flex-direction:column;display:flex}.level code{border-radius:var(--bulma-radius)}.level img{vertical-align:top;display:inline-block}.level.is-mobile{flex-direction:row;display:flex}.level.is-mobile .level-left,.level.is-mobile .level-right{display:flex}.level.is-mobile .level-item:not(.is-narrow){flex-grow:1}@media screen and (width>=769px),print{.level{flex-direction:row;display:flex}.level>.level-item:not(.is-narrow){flex-grow:1}}.level-item{flex:none;justify-content:center;align-items:center;display:flex}.level-item .title,.level-item .subtitle{margin-bottom:0}.level-left,.level-right{gap:calc(var(--bulma-block-spacing)*.5);flex:none}.level-left .level-item.is-flexible,.level-right .level-item.is-flexible{flex-grow:1}.level-left{flex-direction:column;justify-content:flex-start;align-items:center;display:flex}@media screen and (width>=769px),print{.level-left{flex-direction:row}}.level-right{flex-direction:column;justify-content:flex-end;align-items:center;display:flex}@media screen and (width>=769px),print{.level-right{flex-direction:row}}.media{--bulma-media-border-color:hsla(var(--bulma-scheme-h),var(--bulma-scheme-s),var(--bulma-border-l),.5);--bulma-media-border-size:1px;--bulma-media-spacing:1rem;--bulma-media-spacing-large:1.5rem;--bulma-media-content-spacing:.75rem;--bulma-media-level-1-spacing:.75rem;--bulma-media-level-1-content-spacing:.5rem;--bulma-media-level-2-spacing:.5rem;text-align:inherit;align-items:flex-start;display:flex}.media .content:not(:last-child){margin-bottom:var(--bulma-media-content-spacing)}.media .media{border-top-color:var(--bulma-media-border-color);border-top-style:solid;border-top-width:var(--bulma-media-border-size);padding-top:var(--bulma-media-level-1-spacing);display:flex}.media .media .content:not(:last-child),.media .media .control:not(:last-child){margin-bottom:var(--bulma-media-level-1-content-spacing)}.media .media .media{padding-top:var(--bulma-media-level-2-spacing)}.media .media .media+.media{margin-top:var(--bulma-media-level-2-spacing)}.media+.media{border-top-color:var(--bulma-media-border-color);border-top-style:solid;border-top-width:var(--bulma-media-border-size);margin-top:var(--bulma-media-spacing);padding-top:var(--bulma-media-spacing)}.media.is-large+.media{margin-top:var(--bulma-media-spacing-large);padding-top:var(--bulma-media-spacing-large)}.media-left,.media-right{flex:none}.media-left{margin-inline-end:var(--bulma-media-spacing)}.media-right{margin-inline-start:var(--bulma-media-spacing)}.media-content{text-align:inherit;flex:auto}@media screen and (width<=768px){.media-content{overflow-x:auto}}.section{--bulma-section-padding:3rem 1.5rem;--bulma-section-padding-desktop:3rem 3rem;--bulma-section-padding-medium:9rem 4.5rem;--bulma-section-padding-large:18rem 6rem;padding:var(--bulma-section-padding)}@media screen and (width>=1024px){.section{padding:var(--bulma-section-padding-desktop)}.section.is-medium{padding:var(--bulma-section-padding-medium)}.section.is-large{padding:var(--bulma-section-padding-large)}}.section.is-fullheight{min-height:100vh}:root{--bulma-skeleton-background:var(--bulma-border);--bulma-skeleton-radius:var(--bulma-radius-small);--bulma-skeleton-block-min-height:4.5em;--bulma-skeleton-lines-gap:.75em;--bulma-skeleton-line-height:.75em}.skeleton-lines>div,.skeleton-block,.has-skeleton:after,.is-skeleton{background-color:var(--bulma-skeleton-background);border-radius:var(--bulma-skeleton-radius);box-shadow:none;pointer-events:none;animation-name:pulsate;animation-duration:2s;animation-timing-function:cubic-bezier(.4,0,.6,1);animation-iteration-count:infinite}.is-skeleton{color:#0000!important}.is-skeleton em,.is-skeleton strong{color:inherit}.is-skeleton img{visibility:hidden}.is-skeleton.checkbox input{opacity:0}.is-skeleton.delete{border-radius:var(--bulma-radius-rounded)}.is-skeleton.delete:before,.is-skeleton.delete:after{display:none}input.is-skeleton,textarea.is-skeleton{resize:none}input.is-skeleton::placeholder,textarea.is-skeleton::placeholder{color:#0000!important}input.is-skeleton::-moz-placeholder,textarea.is-skeleton::-moz-placeholder{color:#0000!important}input.is-skeleton:-moz-placeholder,textarea.is-skeleton:-moz-placeholder{color:#0000!important}input.is-skeleton:-ms-input-placeholder,textarea.is-skeleton:-ms-input-placeholder{color:#0000!important}.has-skeleton{position:relative;color:#0000!important}.has-skeleton:after{content:"";width:7em;min-width:10%;max-width:100%;height:100%;display:block;position:absolute;top:0;left:0}.skeleton-block{min-height:var(--bulma-skeleton-block-min-height);color:#0000!important}.skeleton-lines{gap:var(--bulma-skeleton-lines-gap);flex-direction:column;display:flex;position:relative;color:#0000!important}.skeleton-lines>div{height:var(--bulma-skeleton-line-height)}.skeleton-lines>div:last-child{width:30%;min-width:4em}.is-aspect-ratio-1by1{aspect-ratio:1}.is-aspect-ratio-5by4{aspect-ratio:5/4}.is-aspect-ratio-4by3{aspect-ratio:4/3}.is-aspect-ratio-3by2{aspect-ratio:3/2}.is-aspect-ratio-5by3{aspect-ratio:5/3}.is-aspect-ratio-16by9{aspect-ratio:16/9}.is-aspect-ratio-2by1{aspect-ratio:2}.is-aspect-ratio-3by1{aspect-ratio:3}.is-aspect-ratio-4by5{aspect-ratio:4/5}.is-aspect-ratio-3by4{aspect-ratio:3/4}.is-aspect-ratio-2by3{aspect-ratio:2/3}.is-aspect-ratio-3by5{aspect-ratio:3/5}.is-aspect-ratio-9by16{aspect-ratio:9/16}.is-aspect-ratio-1by2{aspect-ratio:1/2}.is-aspect-ratio-1by3{aspect-ratio:1/3}.has-radius-small{border-radius:var(--bulma-radius-small)}.has-radius-normal{border-radius:var(--bulma-radius)}.has-radius-large{border-radius:var(--bulma-radius-large)}.has-radius-rounded{border-radius:var(--bulma-radius-rounded)}.has-background{background-color:var(--bulma-background)}.has-text-white{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-l))!important}.has-background-white{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-l))!important}.has-text-white-invert{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-invert-l))!important}.has-background-white-invert{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-invert-l))!important}.has-text-white-on-scheme{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-on-scheme-l))!important}.has-background-white-on-scheme{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-on-scheme-l))!important}.has-text-white-light{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-light-l))!important}.has-background-white-light{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-light-l))!important}.has-text-white-light-invert{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-light-invert-l))!important}.has-background-white-light-invert{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-light-invert-l))!important}.has-text-white-dark{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-dark-l))!important}.has-background-white-dark{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-dark-l))!important}.has-text-white-dark-invert{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-dark-invert-l))!important}.has-background-white-dark-invert{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-dark-invert-l))!important}.has-text-white-soft{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-soft-l))!important}.has-background-white-soft{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-soft-l))!important}.has-text-white-bold{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-bold-l))!important}.has-background-white-bold{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-bold-l))!important}.has-text-white-soft-invert{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-soft-invert-l))!important}.has-background-white-soft-invert{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-soft-invert-l))!important}.has-text-white-bold-invert{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-bold-invert-l))!important}.has-background-white-bold-invert{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-bold-invert-l))!important}.has-text-white-00{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-00-l))!important}.has-background-white-00{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-00-l))!important}.has-text-white-00-invert{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-00-invert-l))!important}.has-background-white-00-invert{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-00-invert-l))!important}.has-text-white-05{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-05-l))!important}.has-background-white-05{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-05-l))!important}.has-text-white-05-invert{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-05-invert-l))!important}.has-background-white-05-invert{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-05-invert-l))!important}.has-text-white-10{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-10-l))!important}.has-background-white-10{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-10-l))!important}.has-text-white-10-invert{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-10-invert-l))!important}.has-background-white-10-invert{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-10-invert-l))!important}.has-text-white-15{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-15-l))!important}.has-background-white-15{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-15-l))!important}.has-text-white-15-invert{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-15-invert-l))!important}.has-background-white-15-invert{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-15-invert-l))!important}.has-text-white-20{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-20-l))!important}.has-background-white-20{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-20-l))!important}.has-text-white-20-invert{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-20-invert-l))!important}.has-background-white-20-invert{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-20-invert-l))!important}.has-text-white-25{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-25-l))!important}.has-background-white-25{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-25-l))!important}.has-text-white-25-invert{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-25-invert-l))!important}.has-background-white-25-invert{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-25-invert-l))!important}.has-text-white-30{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-30-l))!important}.has-background-white-30{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-30-l))!important}.has-text-white-30-invert{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-30-invert-l))!important}.has-background-white-30-invert{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-30-invert-l))!important}.has-text-white-35{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-35-l))!important}.has-background-white-35{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-35-l))!important}.has-text-white-35-invert{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-35-invert-l))!important}.has-background-white-35-invert{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-35-invert-l))!important}.has-text-white-40{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-40-l))!important}.has-background-white-40{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-40-l))!important}.has-text-white-40-invert{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-40-invert-l))!important}.has-background-white-40-invert{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-40-invert-l))!important}.has-text-white-45{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-45-l))!important}.has-background-white-45{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-45-l))!important}.has-text-white-45-invert{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-45-invert-l))!important}.has-background-white-45-invert{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-45-invert-l))!important}.has-text-white-50{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-50-l))!important}.has-background-white-50{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-50-l))!important}.has-text-white-50-invert{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-50-invert-l))!important}.has-background-white-50-invert{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-50-invert-l))!important}.has-text-white-55{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-55-l))!important}.has-background-white-55{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-55-l))!important}.has-text-white-55-invert{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-55-invert-l))!important}.has-background-white-55-invert{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-55-invert-l))!important}.has-text-white-60{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-60-l))!important}.has-background-white-60{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-60-l))!important}.has-text-white-60-invert{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-60-invert-l))!important}.has-background-white-60-invert{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-60-invert-l))!important}.has-text-white-65{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-65-l))!important}.has-background-white-65{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-65-l))!important}.has-text-white-65-invert{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-65-invert-l))!important}.has-background-white-65-invert{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-65-invert-l))!important}.has-text-white-70{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-70-l))!important}.has-background-white-70{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-70-l))!important}.has-text-white-70-invert{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-70-invert-l))!important}.has-background-white-70-invert{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-70-invert-l))!important}.has-text-white-75{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-75-l))!important}.has-background-white-75{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-75-l))!important}.has-text-white-75-invert{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-75-invert-l))!important}.has-background-white-75-invert{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-75-invert-l))!important}.has-text-white-80{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-80-l))!important}.has-background-white-80{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-80-l))!important}.has-text-white-80-invert{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-80-invert-l))!important}.has-background-white-80-invert{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-80-invert-l))!important}.has-text-white-85{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-85-l))!important}.has-background-white-85{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-85-l))!important}.has-text-white-85-invert{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-85-invert-l))!important}.has-background-white-85-invert{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-85-invert-l))!important}.has-text-white-90{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-90-l))!important}.has-background-white-90{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-90-l))!important}.has-text-white-90-invert{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-90-invert-l))!important}.has-background-white-90-invert{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-90-invert-l))!important}.has-text-white-95{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-95-l))!important}.has-background-white-95{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-95-l))!important}.has-text-white-95-invert{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-95-invert-l))!important}.has-background-white-95-invert{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-95-invert-l))!important}.has-text-white-100{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-100-l))!important}.has-background-white-100{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-100-l))!important}.has-text-white-100-invert{color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-100-invert-l))!important}.has-background-white-100-invert{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),var(--bulma-white-100-invert-l))!important}a.has-text-white:hover,a.has-text-white:focus-visible,button.has-text-white:hover,button.has-text-white:focus-visible,has-text-white.is-hoverable:hover,has-text-white.is-hoverable:focus-visible{color:hsl(var(--bulma-white-h),var(--bulma-white-s),calc(var(--bulma-white-l) + var(--bulma-hover-color-l-delta)))!important}a.has-text-white:active,button.has-text-white:active,has-text-white.is-hoverable:active{color:hsl(var(--bulma-white-h),var(--bulma-white-s),calc(var(--bulma-white-l) + var(--bulma-active-color-l-delta)))!important}a.has-background-white:hover,a.has-background-white:focus-visible,button.has-background-white:hover,button.has-background-white:focus-visible,has-background-white.is-hoverable:hover,has-background-white.is-hoverable:focus-visible{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),calc(var(--bulma-white-l) + var(--bulma-hover-background-l-delta)))!important}a.has-background-white:active,button.has-background-white:active,has-background-white.is-hoverable:active{background-color:hsl(var(--bulma-white-h),var(--bulma-white-s),calc(var(--bulma-white-l) + var(--bulma-active-background-l-delta)))!important}.is-palette-white{--h:var(--bulma-white-h);--s:var(--bulma-white-s);--l:var(--bulma-white-l);--color:hsl(var(--h),var(--s),var(--l));--00-l:var(--bulma-white-00-l);--color-00:hsl(var(--h),var(--s),var(--00-l));--05-l:var(--bulma-white-05-l);--color-05:hsl(var(--h),var(--s),var(--05-l));--10-l:var(--bulma-white-10-l);--color-10:hsl(var(--h),var(--s),var(--10-l));--15-l:var(--bulma-white-15-l);--color-15:hsl(var(--h),var(--s),var(--15-l));--20-l:var(--bulma-white-20-l);--color-20:hsl(var(--h),var(--s),var(--20-l));--25-l:var(--bulma-white-25-l);--color-25:hsl(var(--h),var(--s),var(--25-l));--30-l:var(--bulma-white-30-l);--color-30:hsl(var(--h),var(--s),var(--30-l));--35-l:var(--bulma-white-35-l);--color-35:hsl(var(--h),var(--s),var(--35-l));--40-l:var(--bulma-white-40-l);--color-40:hsl(var(--h),var(--s),var(--40-l));--45-l:var(--bulma-white-45-l);--color-45:hsl(var(--h),var(--s),var(--45-l));--50-l:var(--bulma-white-50-l);--color-50:hsl(var(--h),var(--s),var(--50-l));--55-l:var(--bulma-white-55-l);--color-55:hsl(var(--h),var(--s),var(--55-l));--60-l:var(--bulma-white-60-l);--color-60:hsl(var(--h),var(--s),var(--60-l));--65-l:var(--bulma-white-65-l);--color-65:hsl(var(--h),var(--s),var(--65-l));--70-l:var(--bulma-white-70-l);--color-70:hsl(var(--h),var(--s),var(--70-l));--75-l:var(--bulma-white-75-l);--color-75:hsl(var(--h),var(--s),var(--75-l));--80-l:var(--bulma-white-80-l);--color-80:hsl(var(--h),var(--s),var(--80-l));--85-l:var(--bulma-white-85-l);--color-85:hsl(var(--h),var(--s),var(--85-l));--90-l:var(--bulma-white-90-l);--color-90:hsl(var(--h),var(--s),var(--90-l));--95-l:var(--bulma-white-95-l);--color-95:hsl(var(--h),var(--s),var(--95-l));--100-l:var(--bulma-white-100-l);--color-100:hsl(var(--h),var(--s),var(--100-l))}.has-text-black{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-l))!important}.has-background-black{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-l))!important}.has-text-black-invert{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-invert-l))!important}.has-background-black-invert{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-invert-l))!important}.has-text-black-on-scheme{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-on-scheme-l))!important}.has-background-black-on-scheme{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-on-scheme-l))!important}.has-text-black-light{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-light-l))!important}.has-background-black-light{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-light-l))!important}.has-text-black-light-invert{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-light-invert-l))!important}.has-background-black-light-invert{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-light-invert-l))!important}.has-text-black-dark{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-dark-l))!important}.has-background-black-dark{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-dark-l))!important}.has-text-black-dark-invert{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-dark-invert-l))!important}.has-background-black-dark-invert{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-dark-invert-l))!important}.has-text-black-soft{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-soft-l))!important}.has-background-black-soft{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-soft-l))!important}.has-text-black-bold{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-bold-l))!important}.has-background-black-bold{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-bold-l))!important}.has-text-black-soft-invert{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-soft-invert-l))!important}.has-background-black-soft-invert{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-soft-invert-l))!important}.has-text-black-bold-invert{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-bold-invert-l))!important}.has-background-black-bold-invert{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-bold-invert-l))!important}.has-text-black-00{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-00-l))!important}.has-background-black-00{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-00-l))!important}.has-text-black-00-invert{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-00-invert-l))!important}.has-background-black-00-invert{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-00-invert-l))!important}.has-text-black-05{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-05-l))!important}.has-background-black-05{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-05-l))!important}.has-text-black-05-invert{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-05-invert-l))!important}.has-background-black-05-invert{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-05-invert-l))!important}.has-text-black-10{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-10-l))!important}.has-background-black-10{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-10-l))!important}.has-text-black-10-invert{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-10-invert-l))!important}.has-background-black-10-invert{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-10-invert-l))!important}.has-text-black-15{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-15-l))!important}.has-background-black-15{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-15-l))!important}.has-text-black-15-invert{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-15-invert-l))!important}.has-background-black-15-invert{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-15-invert-l))!important}.has-text-black-20{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-20-l))!important}.has-background-black-20{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-20-l))!important}.has-text-black-20-invert{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-20-invert-l))!important}.has-background-black-20-invert{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-20-invert-l))!important}.has-text-black-25{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-25-l))!important}.has-background-black-25{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-25-l))!important}.has-text-black-25-invert{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-25-invert-l))!important}.has-background-black-25-invert{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-25-invert-l))!important}.has-text-black-30{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-30-l))!important}.has-background-black-30{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-30-l))!important}.has-text-black-30-invert{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-30-invert-l))!important}.has-background-black-30-invert{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-30-invert-l))!important}.has-text-black-35{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-35-l))!important}.has-background-black-35{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-35-l))!important}.has-text-black-35-invert{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-35-invert-l))!important}.has-background-black-35-invert{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-35-invert-l))!important}.has-text-black-40{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-40-l))!important}.has-background-black-40{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-40-l))!important}.has-text-black-40-invert{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-40-invert-l))!important}.has-background-black-40-invert{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-40-invert-l))!important}.has-text-black-45{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-45-l))!important}.has-background-black-45{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-45-l))!important}.has-text-black-45-invert{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-45-invert-l))!important}.has-background-black-45-invert{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-45-invert-l))!important}.has-text-black-50{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-50-l))!important}.has-background-black-50{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-50-l))!important}.has-text-black-50-invert{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-50-invert-l))!important}.has-background-black-50-invert{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-50-invert-l))!important}.has-text-black-55{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-55-l))!important}.has-background-black-55{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-55-l))!important}.has-text-black-55-invert{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-55-invert-l))!important}.has-background-black-55-invert{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-55-invert-l))!important}.has-text-black-60{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-60-l))!important}.has-background-black-60{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-60-l))!important}.has-text-black-60-invert{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-60-invert-l))!important}.has-background-black-60-invert{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-60-invert-l))!important}.has-text-black-65{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-65-l))!important}.has-background-black-65{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-65-l))!important}.has-text-black-65-invert{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-65-invert-l))!important}.has-background-black-65-invert{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-65-invert-l))!important}.has-text-black-70{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-70-l))!important}.has-background-black-70{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-70-l))!important}.has-text-black-70-invert{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-70-invert-l))!important}.has-background-black-70-invert{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-70-invert-l))!important}.has-text-black-75{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-75-l))!important}.has-background-black-75{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-75-l))!important}.has-text-black-75-invert{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-75-invert-l))!important}.has-background-black-75-invert{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-75-invert-l))!important}.has-text-black-80{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-80-l))!important}.has-background-black-80{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-80-l))!important}.has-text-black-80-invert{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-80-invert-l))!important}.has-background-black-80-invert{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-80-invert-l))!important}.has-text-black-85{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-85-l))!important}.has-background-black-85{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-85-l))!important}.has-text-black-85-invert{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-85-invert-l))!important}.has-background-black-85-invert{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-85-invert-l))!important}.has-text-black-90{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-90-l))!important}.has-background-black-90{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-90-l))!important}.has-text-black-90-invert{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-90-invert-l))!important}.has-background-black-90-invert{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-90-invert-l))!important}.has-text-black-95{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-95-l))!important}.has-background-black-95{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-95-l))!important}.has-text-black-95-invert{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-95-invert-l))!important}.has-background-black-95-invert{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-95-invert-l))!important}.has-text-black-100{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-100-l))!important}.has-background-black-100{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-100-l))!important}.has-text-black-100-invert{color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-100-invert-l))!important}.has-background-black-100-invert{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),var(--bulma-black-100-invert-l))!important}a.has-text-black:hover,a.has-text-black:focus-visible,button.has-text-black:hover,button.has-text-black:focus-visible,has-text-black.is-hoverable:hover,has-text-black.is-hoverable:focus-visible{color:hsl(var(--bulma-black-h),var(--bulma-black-s),calc(var(--bulma-black-l) + var(--bulma-hover-color-l-delta)))!important}a.has-text-black:active,button.has-text-black:active,has-text-black.is-hoverable:active{color:hsl(var(--bulma-black-h),var(--bulma-black-s),calc(var(--bulma-black-l) + var(--bulma-active-color-l-delta)))!important}a.has-background-black:hover,a.has-background-black:focus-visible,button.has-background-black:hover,button.has-background-black:focus-visible,has-background-black.is-hoverable:hover,has-background-black.is-hoverable:focus-visible{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),calc(var(--bulma-black-l) + var(--bulma-hover-background-l-delta)))!important}a.has-background-black:active,button.has-background-black:active,has-background-black.is-hoverable:active{background-color:hsl(var(--bulma-black-h),var(--bulma-black-s),calc(var(--bulma-black-l) + var(--bulma-active-background-l-delta)))!important}.is-palette-black{--h:var(--bulma-black-h);--s:var(--bulma-black-s);--l:var(--bulma-black-l);--color:hsl(var(--h),var(--s),var(--l));--00-l:var(--bulma-black-00-l);--color-00:hsl(var(--h),var(--s),var(--00-l));--05-l:var(--bulma-black-05-l);--color-05:hsl(var(--h),var(--s),var(--05-l));--10-l:var(--bulma-black-10-l);--color-10:hsl(var(--h),var(--s),var(--10-l));--15-l:var(--bulma-black-15-l);--color-15:hsl(var(--h),var(--s),var(--15-l));--20-l:var(--bulma-black-20-l);--color-20:hsl(var(--h),var(--s),var(--20-l));--25-l:var(--bulma-black-25-l);--color-25:hsl(var(--h),var(--s),var(--25-l));--30-l:var(--bulma-black-30-l);--color-30:hsl(var(--h),var(--s),var(--30-l));--35-l:var(--bulma-black-35-l);--color-35:hsl(var(--h),var(--s),var(--35-l));--40-l:var(--bulma-black-40-l);--color-40:hsl(var(--h),var(--s),var(--40-l));--45-l:var(--bulma-black-45-l);--color-45:hsl(var(--h),var(--s),var(--45-l));--50-l:var(--bulma-black-50-l);--color-50:hsl(var(--h),var(--s),var(--50-l));--55-l:var(--bulma-black-55-l);--color-55:hsl(var(--h),var(--s),var(--55-l));--60-l:var(--bulma-black-60-l);--color-60:hsl(var(--h),var(--s),var(--60-l));--65-l:var(--bulma-black-65-l);--color-65:hsl(var(--h),var(--s),var(--65-l));--70-l:var(--bulma-black-70-l);--color-70:hsl(var(--h),var(--s),var(--70-l));--75-l:var(--bulma-black-75-l);--color-75:hsl(var(--h),var(--s),var(--75-l));--80-l:var(--bulma-black-80-l);--color-80:hsl(var(--h),var(--s),var(--80-l));--85-l:var(--bulma-black-85-l);--color-85:hsl(var(--h),var(--s),var(--85-l));--90-l:var(--bulma-black-90-l);--color-90:hsl(var(--h),var(--s),var(--90-l));--95-l:var(--bulma-black-95-l);--color-95:hsl(var(--h),var(--s),var(--95-l));--100-l:var(--bulma-black-100-l);--color-100:hsl(var(--h),var(--s),var(--100-l))}.has-text-light{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-l))!important}.has-background-light{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-l))!important}.has-text-light-invert{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-invert-l))!important}.has-background-light-invert{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-invert-l))!important}.has-text-light-on-scheme{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-on-scheme-l))!important}.has-background-light-on-scheme{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-on-scheme-l))!important}.has-text-light-light{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-light-l))!important}.has-background-light-light{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-light-l))!important}.has-text-light-light-invert{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-light-invert-l))!important}.has-background-light-light-invert{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-light-invert-l))!important}.has-text-light-dark{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-dark-l))!important}.has-background-light-dark{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-dark-l))!important}.has-text-light-dark-invert{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-dark-invert-l))!important}.has-background-light-dark-invert{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-dark-invert-l))!important}.has-text-light-soft{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-soft-l))!important}.has-background-light-soft{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-soft-l))!important}.has-text-light-bold{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-bold-l))!important}.has-background-light-bold{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-bold-l))!important}.has-text-light-soft-invert{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-soft-invert-l))!important}.has-background-light-soft-invert{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-soft-invert-l))!important}.has-text-light-bold-invert{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-bold-invert-l))!important}.has-background-light-bold-invert{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-bold-invert-l))!important}.has-text-light-00{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-00-l))!important}.has-background-light-00{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-00-l))!important}.has-text-light-00-invert{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-00-invert-l))!important}.has-background-light-00-invert{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-00-invert-l))!important}.has-text-light-05{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-05-l))!important}.has-background-light-05{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-05-l))!important}.has-text-light-05-invert{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-05-invert-l))!important}.has-background-light-05-invert{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-05-invert-l))!important}.has-text-light-10{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-10-l))!important}.has-background-light-10{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-10-l))!important}.has-text-light-10-invert{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-10-invert-l))!important}.has-background-light-10-invert{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-10-invert-l))!important}.has-text-light-15{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-15-l))!important}.has-background-light-15{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-15-l))!important}.has-text-light-15-invert{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-15-invert-l))!important}.has-background-light-15-invert{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-15-invert-l))!important}.has-text-light-20{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-20-l))!important}.has-background-light-20{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-20-l))!important}.has-text-light-20-invert{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-20-invert-l))!important}.has-background-light-20-invert{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-20-invert-l))!important}.has-text-light-25{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-25-l))!important}.has-background-light-25{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-25-l))!important}.has-text-light-25-invert{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-25-invert-l))!important}.has-background-light-25-invert{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-25-invert-l))!important}.has-text-light-30{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-30-l))!important}.has-background-light-30{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-30-l))!important}.has-text-light-30-invert{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-30-invert-l))!important}.has-background-light-30-invert{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-30-invert-l))!important}.has-text-light-35{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-35-l))!important}.has-background-light-35{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-35-l))!important}.has-text-light-35-invert{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-35-invert-l))!important}.has-background-light-35-invert{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-35-invert-l))!important}.has-text-light-40{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-40-l))!important}.has-background-light-40{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-40-l))!important}.has-text-light-40-invert{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-40-invert-l))!important}.has-background-light-40-invert{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-40-invert-l))!important}.has-text-light-45{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-45-l))!important}.has-background-light-45{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-45-l))!important}.has-text-light-45-invert{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-45-invert-l))!important}.has-background-light-45-invert{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-45-invert-l))!important}.has-text-light-50{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-50-l))!important}.has-background-light-50{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-50-l))!important}.has-text-light-50-invert{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-50-invert-l))!important}.has-background-light-50-invert{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-50-invert-l))!important}.has-text-light-55{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-55-l))!important}.has-background-light-55{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-55-l))!important}.has-text-light-55-invert{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-55-invert-l))!important}.has-background-light-55-invert{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-55-invert-l))!important}.has-text-light-60{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-60-l))!important}.has-background-light-60{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-60-l))!important}.has-text-light-60-invert{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-60-invert-l))!important}.has-background-light-60-invert{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-60-invert-l))!important}.has-text-light-65{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-65-l))!important}.has-background-light-65{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-65-l))!important}.has-text-light-65-invert{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-65-invert-l))!important}.has-background-light-65-invert{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-65-invert-l))!important}.has-text-light-70{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-70-l))!important}.has-background-light-70{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-70-l))!important}.has-text-light-70-invert{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-70-invert-l))!important}.has-background-light-70-invert{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-70-invert-l))!important}.has-text-light-75{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-75-l))!important}.has-background-light-75{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-75-l))!important}.has-text-light-75-invert{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-75-invert-l))!important}.has-background-light-75-invert{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-75-invert-l))!important}.has-text-light-80{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-80-l))!important}.has-background-light-80{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-80-l))!important}.has-text-light-80-invert{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-80-invert-l))!important}.has-background-light-80-invert{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-80-invert-l))!important}.has-text-light-85{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-85-l))!important}.has-background-light-85{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-85-l))!important}.has-text-light-85-invert{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-85-invert-l))!important}.has-background-light-85-invert{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-85-invert-l))!important}.has-text-light-90{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-90-l))!important}.has-background-light-90{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-90-l))!important}.has-text-light-90-invert{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-90-invert-l))!important}.has-background-light-90-invert{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-90-invert-l))!important}.has-text-light-95{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-95-l))!important}.has-background-light-95{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-95-l))!important}.has-text-light-95-invert{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-95-invert-l))!important}.has-background-light-95-invert{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-95-invert-l))!important}.has-text-light-100{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-100-l))!important}.has-background-light-100{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-100-l))!important}.has-text-light-100-invert{color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-100-invert-l))!important}.has-background-light-100-invert{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),var(--bulma-light-100-invert-l))!important}a.has-text-light:hover,a.has-text-light:focus-visible,button.has-text-light:hover,button.has-text-light:focus-visible,has-text-light.is-hoverable:hover,has-text-light.is-hoverable:focus-visible{color:hsl(var(--bulma-light-h),var(--bulma-light-s),calc(var(--bulma-light-l) + var(--bulma-hover-color-l-delta)))!important}a.has-text-light:active,button.has-text-light:active,has-text-light.is-hoverable:active{color:hsl(var(--bulma-light-h),var(--bulma-light-s),calc(var(--bulma-light-l) + var(--bulma-active-color-l-delta)))!important}a.has-background-light:hover,a.has-background-light:focus-visible,button.has-background-light:hover,button.has-background-light:focus-visible,has-background-light.is-hoverable:hover,has-background-light.is-hoverable:focus-visible{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),calc(var(--bulma-light-l) + var(--bulma-hover-background-l-delta)))!important}a.has-background-light:active,button.has-background-light:active,has-background-light.is-hoverable:active{background-color:hsl(var(--bulma-light-h),var(--bulma-light-s),calc(var(--bulma-light-l) + var(--bulma-active-background-l-delta)))!important}.is-palette-light{--h:var(--bulma-light-h);--s:var(--bulma-light-s);--l:var(--bulma-light-l);--color:hsl(var(--h),var(--s),var(--l));--00-l:var(--bulma-light-00-l);--color-00:hsl(var(--h),var(--s),var(--00-l));--05-l:var(--bulma-light-05-l);--color-05:hsl(var(--h),var(--s),var(--05-l));--10-l:var(--bulma-light-10-l);--color-10:hsl(var(--h),var(--s),var(--10-l));--15-l:var(--bulma-light-15-l);--color-15:hsl(var(--h),var(--s),var(--15-l));--20-l:var(--bulma-light-20-l);--color-20:hsl(var(--h),var(--s),var(--20-l));--25-l:var(--bulma-light-25-l);--color-25:hsl(var(--h),var(--s),var(--25-l));--30-l:var(--bulma-light-30-l);--color-30:hsl(var(--h),var(--s),var(--30-l));--35-l:var(--bulma-light-35-l);--color-35:hsl(var(--h),var(--s),var(--35-l));--40-l:var(--bulma-light-40-l);--color-40:hsl(var(--h),var(--s),var(--40-l));--45-l:var(--bulma-light-45-l);--color-45:hsl(var(--h),var(--s),var(--45-l));--50-l:var(--bulma-light-50-l);--color-50:hsl(var(--h),var(--s),var(--50-l));--55-l:var(--bulma-light-55-l);--color-55:hsl(var(--h),var(--s),var(--55-l));--60-l:var(--bulma-light-60-l);--color-60:hsl(var(--h),var(--s),var(--60-l));--65-l:var(--bulma-light-65-l);--color-65:hsl(var(--h),var(--s),var(--65-l));--70-l:var(--bulma-light-70-l);--color-70:hsl(var(--h),var(--s),var(--70-l));--75-l:var(--bulma-light-75-l);--color-75:hsl(var(--h),var(--s),var(--75-l));--80-l:var(--bulma-light-80-l);--color-80:hsl(var(--h),var(--s),var(--80-l));--85-l:var(--bulma-light-85-l);--color-85:hsl(var(--h),var(--s),var(--85-l));--90-l:var(--bulma-light-90-l);--color-90:hsl(var(--h),var(--s),var(--90-l));--95-l:var(--bulma-light-95-l);--color-95:hsl(var(--h),var(--s),var(--95-l));--100-l:var(--bulma-light-100-l);--color-100:hsl(var(--h),var(--s),var(--100-l))}.has-text-dark{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-l))!important}.has-background-dark{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-l))!important}.has-text-dark-invert{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-invert-l))!important}.has-background-dark-invert{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-invert-l))!important}.has-text-dark-on-scheme{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-on-scheme-l))!important}.has-background-dark-on-scheme{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-on-scheme-l))!important}.has-text-dark-light{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-light-l))!important}.has-background-dark-light{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-light-l))!important}.has-text-dark-light-invert{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-light-invert-l))!important}.has-background-dark-light-invert{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-light-invert-l))!important}.has-text-dark-dark{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-dark-l))!important}.has-background-dark-dark{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-dark-l))!important}.has-text-dark-dark-invert{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-dark-invert-l))!important}.has-background-dark-dark-invert{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-dark-invert-l))!important}.has-text-dark-soft{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-soft-l))!important}.has-background-dark-soft{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-soft-l))!important}.has-text-dark-bold{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-bold-l))!important}.has-background-dark-bold{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-bold-l))!important}.has-text-dark-soft-invert{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-soft-invert-l))!important}.has-background-dark-soft-invert{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-soft-invert-l))!important}.has-text-dark-bold-invert{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-bold-invert-l))!important}.has-background-dark-bold-invert{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-bold-invert-l))!important}.has-text-dark-00{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-00-l))!important}.has-background-dark-00{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-00-l))!important}.has-text-dark-00-invert{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-00-invert-l))!important}.has-background-dark-00-invert{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-00-invert-l))!important}.has-text-dark-05{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-05-l))!important}.has-background-dark-05{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-05-l))!important}.has-text-dark-05-invert{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-05-invert-l))!important}.has-background-dark-05-invert{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-05-invert-l))!important}.has-text-dark-10{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-10-l))!important}.has-background-dark-10{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-10-l))!important}.has-text-dark-10-invert{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-10-invert-l))!important}.has-background-dark-10-invert{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-10-invert-l))!important}.has-text-dark-15{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-15-l))!important}.has-background-dark-15{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-15-l))!important}.has-text-dark-15-invert{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-15-invert-l))!important}.has-background-dark-15-invert{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-15-invert-l))!important}.has-text-dark-20{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-20-l))!important}.has-background-dark-20{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-20-l))!important}.has-text-dark-20-invert{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-20-invert-l))!important}.has-background-dark-20-invert{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-20-invert-l))!important}.has-text-dark-25{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-25-l))!important}.has-background-dark-25{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-25-l))!important}.has-text-dark-25-invert{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-25-invert-l))!important}.has-background-dark-25-invert{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-25-invert-l))!important}.has-text-dark-30{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-30-l))!important}.has-background-dark-30{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-30-l))!important}.has-text-dark-30-invert{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-30-invert-l))!important}.has-background-dark-30-invert{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-30-invert-l))!important}.has-text-dark-35{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-35-l))!important}.has-background-dark-35{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-35-l))!important}.has-text-dark-35-invert{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-35-invert-l))!important}.has-background-dark-35-invert{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-35-invert-l))!important}.has-text-dark-40{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-40-l))!important}.has-background-dark-40{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-40-l))!important}.has-text-dark-40-invert{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-40-invert-l))!important}.has-background-dark-40-invert{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-40-invert-l))!important}.has-text-dark-45{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-45-l))!important}.has-background-dark-45{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-45-l))!important}.has-text-dark-45-invert{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-45-invert-l))!important}.has-background-dark-45-invert{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-45-invert-l))!important}.has-text-dark-50{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-50-l))!important}.has-background-dark-50{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-50-l))!important}.has-text-dark-50-invert{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-50-invert-l))!important}.has-background-dark-50-invert{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-50-invert-l))!important}.has-text-dark-55{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-55-l))!important}.has-background-dark-55{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-55-l))!important}.has-text-dark-55-invert{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-55-invert-l))!important}.has-background-dark-55-invert{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-55-invert-l))!important}.has-text-dark-60{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-60-l))!important}.has-background-dark-60{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-60-l))!important}.has-text-dark-60-invert{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-60-invert-l))!important}.has-background-dark-60-invert{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-60-invert-l))!important}.has-text-dark-65{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-65-l))!important}.has-background-dark-65{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-65-l))!important}.has-text-dark-65-invert{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-65-invert-l))!important}.has-background-dark-65-invert{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-65-invert-l))!important}.has-text-dark-70{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-70-l))!important}.has-background-dark-70{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-70-l))!important}.has-text-dark-70-invert{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-70-invert-l))!important}.has-background-dark-70-invert{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-70-invert-l))!important}.has-text-dark-75{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-75-l))!important}.has-background-dark-75{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-75-l))!important}.has-text-dark-75-invert{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-75-invert-l))!important}.has-background-dark-75-invert{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-75-invert-l))!important}.has-text-dark-80{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-80-l))!important}.has-background-dark-80{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-80-l))!important}.has-text-dark-80-invert{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-80-invert-l))!important}.has-background-dark-80-invert{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-80-invert-l))!important}.has-text-dark-85{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-85-l))!important}.has-background-dark-85{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-85-l))!important}.has-text-dark-85-invert{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-85-invert-l))!important}.has-background-dark-85-invert{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-85-invert-l))!important}.has-text-dark-90{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-90-l))!important}.has-background-dark-90{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-90-l))!important}.has-text-dark-90-invert{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-90-invert-l))!important}.has-background-dark-90-invert{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-90-invert-l))!important}.has-text-dark-95{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-95-l))!important}.has-background-dark-95{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-95-l))!important}.has-text-dark-95-invert{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-95-invert-l))!important}.has-background-dark-95-invert{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-95-invert-l))!important}.has-text-dark-100{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-100-l))!important}.has-background-dark-100{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-100-l))!important}.has-text-dark-100-invert{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-100-invert-l))!important}.has-background-dark-100-invert{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),var(--bulma-dark-100-invert-l))!important}a.has-text-dark:hover,a.has-text-dark:focus-visible,button.has-text-dark:hover,button.has-text-dark:focus-visible,has-text-dark.is-hoverable:hover,has-text-dark.is-hoverable:focus-visible{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),calc(var(--bulma-dark-l) + var(--bulma-hover-color-l-delta)))!important}a.has-text-dark:active,button.has-text-dark:active,has-text-dark.is-hoverable:active{color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),calc(var(--bulma-dark-l) + var(--bulma-active-color-l-delta)))!important}a.has-background-dark:hover,a.has-background-dark:focus-visible,button.has-background-dark:hover,button.has-background-dark:focus-visible,has-background-dark.is-hoverable:hover,has-background-dark.is-hoverable:focus-visible{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),calc(var(--bulma-dark-l) + var(--bulma-hover-background-l-delta)))!important}a.has-background-dark:active,button.has-background-dark:active,has-background-dark.is-hoverable:active{background-color:hsl(var(--bulma-dark-h),var(--bulma-dark-s),calc(var(--bulma-dark-l) + var(--bulma-active-background-l-delta)))!important}.is-palette-dark{--h:var(--bulma-dark-h);--s:var(--bulma-dark-s);--l:var(--bulma-dark-l);--color:hsl(var(--h),var(--s),var(--l));--00-l:var(--bulma-dark-00-l);--color-00:hsl(var(--h),var(--s),var(--00-l));--05-l:var(--bulma-dark-05-l);--color-05:hsl(var(--h),var(--s),var(--05-l));--10-l:var(--bulma-dark-10-l);--color-10:hsl(var(--h),var(--s),var(--10-l));--15-l:var(--bulma-dark-15-l);--color-15:hsl(var(--h),var(--s),var(--15-l));--20-l:var(--bulma-dark-20-l);--color-20:hsl(var(--h),var(--s),var(--20-l));--25-l:var(--bulma-dark-25-l);--color-25:hsl(var(--h),var(--s),var(--25-l));--30-l:var(--bulma-dark-30-l);--color-30:hsl(var(--h),var(--s),var(--30-l));--35-l:var(--bulma-dark-35-l);--color-35:hsl(var(--h),var(--s),var(--35-l));--40-l:var(--bulma-dark-40-l);--color-40:hsl(var(--h),var(--s),var(--40-l));--45-l:var(--bulma-dark-45-l);--color-45:hsl(var(--h),var(--s),var(--45-l));--50-l:var(--bulma-dark-50-l);--color-50:hsl(var(--h),var(--s),var(--50-l));--55-l:var(--bulma-dark-55-l);--color-55:hsl(var(--h),var(--s),var(--55-l));--60-l:var(--bulma-dark-60-l);--color-60:hsl(var(--h),var(--s),var(--60-l));--65-l:var(--bulma-dark-65-l);--color-65:hsl(var(--h),var(--s),var(--65-l));--70-l:var(--bulma-dark-70-l);--color-70:hsl(var(--h),var(--s),var(--70-l));--75-l:var(--bulma-dark-75-l);--color-75:hsl(var(--h),var(--s),var(--75-l));--80-l:var(--bulma-dark-80-l);--color-80:hsl(var(--h),var(--s),var(--80-l));--85-l:var(--bulma-dark-85-l);--color-85:hsl(var(--h),var(--s),var(--85-l));--90-l:var(--bulma-dark-90-l);--color-90:hsl(var(--h),var(--s),var(--90-l));--95-l:var(--bulma-dark-95-l);--color-95:hsl(var(--h),var(--s),var(--95-l));--100-l:var(--bulma-dark-100-l);--color-100:hsl(var(--h),var(--s),var(--100-l))}.has-text-text{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-l))!important}.has-background-text{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-l))!important}.has-text-text-invert{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-invert-l))!important}.has-background-text-invert{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-invert-l))!important}.has-text-text-on-scheme{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-on-scheme-l))!important}.has-background-text-on-scheme{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-on-scheme-l))!important}.has-text-text-light{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-light-l))!important}.has-background-text-light{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-light-l))!important}.has-text-text-light-invert{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-light-invert-l))!important}.has-background-text-light-invert{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-light-invert-l))!important}.has-text-text-dark{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-dark-l))!important}.has-background-text-dark{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-dark-l))!important}.has-text-text-dark-invert{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-dark-invert-l))!important}.has-background-text-dark-invert{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-dark-invert-l))!important}.has-text-text-soft{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-soft-l))!important}.has-background-text-soft{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-soft-l))!important}.has-text-text-bold{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-bold-l))!important}.has-background-text-bold{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-bold-l))!important}.has-text-text-soft-invert{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-soft-invert-l))!important}.has-background-text-soft-invert{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-soft-invert-l))!important}.has-text-text-bold-invert{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-bold-invert-l))!important}.has-background-text-bold-invert{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-bold-invert-l))!important}.has-text-text-00{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-00-l))!important}.has-background-text-00{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-00-l))!important}.has-text-text-00-invert{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-00-invert-l))!important}.has-background-text-00-invert{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-00-invert-l))!important}.has-text-text-05{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-05-l))!important}.has-background-text-05{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-05-l))!important}.has-text-text-05-invert{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-05-invert-l))!important}.has-background-text-05-invert{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-05-invert-l))!important}.has-text-text-10{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-10-l))!important}.has-background-text-10{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-10-l))!important}.has-text-text-10-invert{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-10-invert-l))!important}.has-background-text-10-invert{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-10-invert-l))!important}.has-text-text-15{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-15-l))!important}.has-background-text-15{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-15-l))!important}.has-text-text-15-invert{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-15-invert-l))!important}.has-background-text-15-invert{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-15-invert-l))!important}.has-text-text-20{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-20-l))!important}.has-background-text-20{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-20-l))!important}.has-text-text-20-invert{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-20-invert-l))!important}.has-background-text-20-invert{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-20-invert-l))!important}.has-text-text-25{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-25-l))!important}.has-background-text-25{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-25-l))!important}.has-text-text-25-invert{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-25-invert-l))!important}.has-background-text-25-invert{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-25-invert-l))!important}.has-text-text-30{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-30-l))!important}.has-background-text-30{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-30-l))!important}.has-text-text-30-invert{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-30-invert-l))!important}.has-background-text-30-invert{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-30-invert-l))!important}.has-text-text-35{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-35-l))!important}.has-background-text-35{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-35-l))!important}.has-text-text-35-invert{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-35-invert-l))!important}.has-background-text-35-invert{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-35-invert-l))!important}.has-text-text-40{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-40-l))!important}.has-background-text-40{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-40-l))!important}.has-text-text-40-invert{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-40-invert-l))!important}.has-background-text-40-invert{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-40-invert-l))!important}.has-text-text-45{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-45-l))!important}.has-background-text-45{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-45-l))!important}.has-text-text-45-invert{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-45-invert-l))!important}.has-background-text-45-invert{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-45-invert-l))!important}.has-text-text-50{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-50-l))!important}.has-background-text-50{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-50-l))!important}.has-text-text-50-invert{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-50-invert-l))!important}.has-background-text-50-invert{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-50-invert-l))!important}.has-text-text-55{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-55-l))!important}.has-background-text-55{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-55-l))!important}.has-text-text-55-invert{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-55-invert-l))!important}.has-background-text-55-invert{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-55-invert-l))!important}.has-text-text-60{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-60-l))!important}.has-background-text-60{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-60-l))!important}.has-text-text-60-invert{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-60-invert-l))!important}.has-background-text-60-invert{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-60-invert-l))!important}.has-text-text-65{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-65-l))!important}.has-background-text-65{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-65-l))!important}.has-text-text-65-invert{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-65-invert-l))!important}.has-background-text-65-invert{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-65-invert-l))!important}.has-text-text-70{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-70-l))!important}.has-background-text-70{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-70-l))!important}.has-text-text-70-invert{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-70-invert-l))!important}.has-background-text-70-invert{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-70-invert-l))!important}.has-text-text-75{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-75-l))!important}.has-background-text-75{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-75-l))!important}.has-text-text-75-invert{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-75-invert-l))!important}.has-background-text-75-invert{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-75-invert-l))!important}.has-text-text-80{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-80-l))!important}.has-background-text-80{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-80-l))!important}.has-text-text-80-invert{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-80-invert-l))!important}.has-background-text-80-invert{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-80-invert-l))!important}.has-text-text-85{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-85-l))!important}.has-background-text-85{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-85-l))!important}.has-text-text-85-invert{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-85-invert-l))!important}.has-background-text-85-invert{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-85-invert-l))!important}.has-text-text-90{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-90-l))!important}.has-background-text-90{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-90-l))!important}.has-text-text-90-invert{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-90-invert-l))!important}.has-background-text-90-invert{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-90-invert-l))!important}.has-text-text-95{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-95-l))!important}.has-background-text-95{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-95-l))!important}.has-text-text-95-invert{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-95-invert-l))!important}.has-background-text-95-invert{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-95-invert-l))!important}.has-text-text-100{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-100-l))!important}.has-background-text-100{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-100-l))!important}.has-text-text-100-invert{color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-100-invert-l))!important}.has-background-text-100-invert{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),var(--bulma-text-100-invert-l))!important}a.has-text-text:hover,a.has-text-text:focus-visible,button.has-text-text:hover,button.has-text-text:focus-visible,has-text-text.is-hoverable:hover,has-text-text.is-hoverable:focus-visible{color:hsl(var(--bulma-text-h),var(--bulma-text-s),calc(var(--bulma-text-l) + var(--bulma-hover-color-l-delta)))!important}a.has-text-text:active,button.has-text-text:active,has-text-text.is-hoverable:active{color:hsl(var(--bulma-text-h),var(--bulma-text-s),calc(var(--bulma-text-l) + var(--bulma-active-color-l-delta)))!important}a.has-background-text:hover,a.has-background-text:focus-visible,button.has-background-text:hover,button.has-background-text:focus-visible,has-background-text.is-hoverable:hover,has-background-text.is-hoverable:focus-visible{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),calc(var(--bulma-text-l) + var(--bulma-hover-background-l-delta)))!important}a.has-background-text:active,button.has-background-text:active,has-background-text.is-hoverable:active{background-color:hsl(var(--bulma-text-h),var(--bulma-text-s),calc(var(--bulma-text-l) + var(--bulma-active-background-l-delta)))!important}.is-palette-text{--h:var(--bulma-text-h);--s:var(--bulma-text-s);--l:var(--bulma-text-l);--color:hsl(var(--h),var(--s),var(--l));--00-l:var(--bulma-text-00-l);--color-00:hsl(var(--h),var(--s),var(--00-l));--05-l:var(--bulma-text-05-l);--color-05:hsl(var(--h),var(--s),var(--05-l));--10-l:var(--bulma-text-10-l);--color-10:hsl(var(--h),var(--s),var(--10-l));--15-l:var(--bulma-text-15-l);--color-15:hsl(var(--h),var(--s),var(--15-l));--20-l:var(--bulma-text-20-l);--color-20:hsl(var(--h),var(--s),var(--20-l));--25-l:var(--bulma-text-25-l);--color-25:hsl(var(--h),var(--s),var(--25-l));--30-l:var(--bulma-text-30-l);--color-30:hsl(var(--h),var(--s),var(--30-l));--35-l:var(--bulma-text-35-l);--color-35:hsl(var(--h),var(--s),var(--35-l));--40-l:var(--bulma-text-40-l);--color-40:hsl(var(--h),var(--s),var(--40-l));--45-l:var(--bulma-text-45-l);--color-45:hsl(var(--h),var(--s),var(--45-l));--50-l:var(--bulma-text-50-l);--color-50:hsl(var(--h),var(--s),var(--50-l));--55-l:var(--bulma-text-55-l);--color-55:hsl(var(--h),var(--s),var(--55-l));--60-l:var(--bulma-text-60-l);--color-60:hsl(var(--h),var(--s),var(--60-l));--65-l:var(--bulma-text-65-l);--color-65:hsl(var(--h),var(--s),var(--65-l));--70-l:var(--bulma-text-70-l);--color-70:hsl(var(--h),var(--s),var(--70-l));--75-l:var(--bulma-text-75-l);--color-75:hsl(var(--h),var(--s),var(--75-l));--80-l:var(--bulma-text-80-l);--color-80:hsl(var(--h),var(--s),var(--80-l));--85-l:var(--bulma-text-85-l);--color-85:hsl(var(--h),var(--s),var(--85-l));--90-l:var(--bulma-text-90-l);--color-90:hsl(var(--h),var(--s),var(--90-l));--95-l:var(--bulma-text-95-l);--color-95:hsl(var(--h),var(--s),var(--95-l));--100-l:var(--bulma-text-100-l);--color-100:hsl(var(--h),var(--s),var(--100-l))}.has-text-primary{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-l))!important}.has-background-primary{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-l))!important}.has-text-primary-invert{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-invert-l))!important}.has-background-primary-invert{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-invert-l))!important}.has-text-primary-on-scheme{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-on-scheme-l))!important}.has-background-primary-on-scheme{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-on-scheme-l))!important}.has-text-primary-light{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-light-l))!important}.has-background-primary-light{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-light-l))!important}.has-text-primary-light-invert{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-light-invert-l))!important}.has-background-primary-light-invert{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-light-invert-l))!important}.has-text-primary-dark{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-dark-l))!important}.has-background-primary-dark{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-dark-l))!important}.has-text-primary-dark-invert{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-dark-invert-l))!important}.has-background-primary-dark-invert{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-dark-invert-l))!important}.has-text-primary-soft{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-soft-l))!important}.has-background-primary-soft{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-soft-l))!important}.has-text-primary-bold{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-bold-l))!important}.has-background-primary-bold{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-bold-l))!important}.has-text-primary-soft-invert{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-soft-invert-l))!important}.has-background-primary-soft-invert{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-soft-invert-l))!important}.has-text-primary-bold-invert{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-bold-invert-l))!important}.has-background-primary-bold-invert{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-bold-invert-l))!important}.has-text-primary-00{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-00-l))!important}.has-background-primary-00{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-00-l))!important}.has-text-primary-00-invert{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-00-invert-l))!important}.has-background-primary-00-invert{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-00-invert-l))!important}.has-text-primary-05{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-05-l))!important}.has-background-primary-05{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-05-l))!important}.has-text-primary-05-invert{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-05-invert-l))!important}.has-background-primary-05-invert{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-05-invert-l))!important}.has-text-primary-10{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-10-l))!important}.has-background-primary-10{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-10-l))!important}.has-text-primary-10-invert{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-10-invert-l))!important}.has-background-primary-10-invert{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-10-invert-l))!important}.has-text-primary-15{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-15-l))!important}.has-background-primary-15{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-15-l))!important}.has-text-primary-15-invert{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-15-invert-l))!important}.has-background-primary-15-invert{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-15-invert-l))!important}.has-text-primary-20{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-20-l))!important}.has-background-primary-20{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-20-l))!important}.has-text-primary-20-invert{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-20-invert-l))!important}.has-background-primary-20-invert{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-20-invert-l))!important}.has-text-primary-25{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-25-l))!important}.has-background-primary-25{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-25-l))!important}.has-text-primary-25-invert{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-25-invert-l))!important}.has-background-primary-25-invert{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-25-invert-l))!important}.has-text-primary-30{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-30-l))!important}.has-background-primary-30{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-30-l))!important}.has-text-primary-30-invert{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-30-invert-l))!important}.has-background-primary-30-invert{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-30-invert-l))!important}.has-text-primary-35{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-35-l))!important}.has-background-primary-35{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-35-l))!important}.has-text-primary-35-invert{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-35-invert-l))!important}.has-background-primary-35-invert{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-35-invert-l))!important}.has-text-primary-40{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-40-l))!important}.has-background-primary-40{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-40-l))!important}.has-text-primary-40-invert{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-40-invert-l))!important}.has-background-primary-40-invert{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-40-invert-l))!important}.has-text-primary-45{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-45-l))!important}.has-background-primary-45{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-45-l))!important}.has-text-primary-45-invert{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-45-invert-l))!important}.has-background-primary-45-invert{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-45-invert-l))!important}.has-text-primary-50{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-50-l))!important}.has-background-primary-50{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-50-l))!important}.has-text-primary-50-invert{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-50-invert-l))!important}.has-background-primary-50-invert{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-50-invert-l))!important}.has-text-primary-55{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-55-l))!important}.has-background-primary-55{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-55-l))!important}.has-text-primary-55-invert{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-55-invert-l))!important}.has-background-primary-55-invert{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-55-invert-l))!important}.has-text-primary-60{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-60-l))!important}.has-background-primary-60{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-60-l))!important}.has-text-primary-60-invert{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-60-invert-l))!important}.has-background-primary-60-invert{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-60-invert-l))!important}.has-text-primary-65{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-65-l))!important}.has-background-primary-65{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-65-l))!important}.has-text-primary-65-invert{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-65-invert-l))!important}.has-background-primary-65-invert{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-65-invert-l))!important}.has-text-primary-70{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-70-l))!important}.has-background-primary-70{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-70-l))!important}.has-text-primary-70-invert{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-70-invert-l))!important}.has-background-primary-70-invert{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-70-invert-l))!important}.has-text-primary-75{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-75-l))!important}.has-background-primary-75{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-75-l))!important}.has-text-primary-75-invert{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-75-invert-l))!important}.has-background-primary-75-invert{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-75-invert-l))!important}.has-text-primary-80{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-80-l))!important}.has-background-primary-80{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-80-l))!important}.has-text-primary-80-invert{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-80-invert-l))!important}.has-background-primary-80-invert{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-80-invert-l))!important}.has-text-primary-85{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-85-l))!important}.has-background-primary-85{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-85-l))!important}.has-text-primary-85-invert{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-85-invert-l))!important}.has-background-primary-85-invert{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-85-invert-l))!important}.has-text-primary-90{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-90-l))!important}.has-background-primary-90{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-90-l))!important}.has-text-primary-90-invert{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-90-invert-l))!important}.has-background-primary-90-invert{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-90-invert-l))!important}.has-text-primary-95{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-95-l))!important}.has-background-primary-95{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-95-l))!important}.has-text-primary-95-invert{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-95-invert-l))!important}.has-background-primary-95-invert{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-95-invert-l))!important}.has-text-primary-100{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-100-l))!important}.has-background-primary-100{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-100-l))!important}.has-text-primary-100-invert{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-100-invert-l))!important}.has-background-primary-100-invert{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),var(--bulma-primary-100-invert-l))!important}a.has-text-primary:hover,a.has-text-primary:focus-visible,button.has-text-primary:hover,button.has-text-primary:focus-visible,has-text-primary.is-hoverable:hover,has-text-primary.is-hoverable:focus-visible{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),calc(var(--bulma-primary-l) + var(--bulma-hover-color-l-delta)))!important}a.has-text-primary:active,button.has-text-primary:active,has-text-primary.is-hoverable:active{color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),calc(var(--bulma-primary-l) + var(--bulma-active-color-l-delta)))!important}a.has-background-primary:hover,a.has-background-primary:focus-visible,button.has-background-primary:hover,button.has-background-primary:focus-visible,has-background-primary.is-hoverable:hover,has-background-primary.is-hoverable:focus-visible{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),calc(var(--bulma-primary-l) + var(--bulma-hover-background-l-delta)))!important}a.has-background-primary:active,button.has-background-primary:active,has-background-primary.is-hoverable:active{background-color:hsl(var(--bulma-primary-h),var(--bulma-primary-s),calc(var(--bulma-primary-l) + var(--bulma-active-background-l-delta)))!important}.is-palette-primary{--h:var(--bulma-primary-h);--s:var(--bulma-primary-s);--l:var(--bulma-primary-l);--color:hsl(var(--h),var(--s),var(--l));--00-l:var(--bulma-primary-00-l);--color-00:hsl(var(--h),var(--s),var(--00-l));--05-l:var(--bulma-primary-05-l);--color-05:hsl(var(--h),var(--s),var(--05-l));--10-l:var(--bulma-primary-10-l);--color-10:hsl(var(--h),var(--s),var(--10-l));--15-l:var(--bulma-primary-15-l);--color-15:hsl(var(--h),var(--s),var(--15-l));--20-l:var(--bulma-primary-20-l);--color-20:hsl(var(--h),var(--s),var(--20-l));--25-l:var(--bulma-primary-25-l);--color-25:hsl(var(--h),var(--s),var(--25-l));--30-l:var(--bulma-primary-30-l);--color-30:hsl(var(--h),var(--s),var(--30-l));--35-l:var(--bulma-primary-35-l);--color-35:hsl(var(--h),var(--s),var(--35-l));--40-l:var(--bulma-primary-40-l);--color-40:hsl(var(--h),var(--s),var(--40-l));--45-l:var(--bulma-primary-45-l);--color-45:hsl(var(--h),var(--s),var(--45-l));--50-l:var(--bulma-primary-50-l);--color-50:hsl(var(--h),var(--s),var(--50-l));--55-l:var(--bulma-primary-55-l);--color-55:hsl(var(--h),var(--s),var(--55-l));--60-l:var(--bulma-primary-60-l);--color-60:hsl(var(--h),var(--s),var(--60-l));--65-l:var(--bulma-primary-65-l);--color-65:hsl(var(--h),var(--s),var(--65-l));--70-l:var(--bulma-primary-70-l);--color-70:hsl(var(--h),var(--s),var(--70-l));--75-l:var(--bulma-primary-75-l);--color-75:hsl(var(--h),var(--s),var(--75-l));--80-l:var(--bulma-primary-80-l);--color-80:hsl(var(--h),var(--s),var(--80-l));--85-l:var(--bulma-primary-85-l);--color-85:hsl(var(--h),var(--s),var(--85-l));--90-l:var(--bulma-primary-90-l);--color-90:hsl(var(--h),var(--s),var(--90-l));--95-l:var(--bulma-primary-95-l);--color-95:hsl(var(--h),var(--s),var(--95-l));--100-l:var(--bulma-primary-100-l);--color-100:hsl(var(--h),var(--s),var(--100-l))}.has-text-link{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-l))!important}.has-background-link{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-l))!important}.has-text-link-invert{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-invert-l))!important}.has-background-link-invert{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-invert-l))!important}.has-text-link-on-scheme{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-on-scheme-l))!important}.has-background-link-on-scheme{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-on-scheme-l))!important}.has-text-link-light{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-light-l))!important}.has-background-link-light{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-light-l))!important}.has-text-link-light-invert{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-light-invert-l))!important}.has-background-link-light-invert{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-light-invert-l))!important}.has-text-link-dark{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-dark-l))!important}.has-background-link-dark{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-dark-l))!important}.has-text-link-dark-invert{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-dark-invert-l))!important}.has-background-link-dark-invert{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-dark-invert-l))!important}.has-text-link-soft{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-soft-l))!important}.has-background-link-soft{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-soft-l))!important}.has-text-link-bold{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-bold-l))!important}.has-background-link-bold{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-bold-l))!important}.has-text-link-soft-invert{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-soft-invert-l))!important}.has-background-link-soft-invert{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-soft-invert-l))!important}.has-text-link-bold-invert{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-bold-invert-l))!important}.has-background-link-bold-invert{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-bold-invert-l))!important}.has-text-link-00{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-00-l))!important}.has-background-link-00{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-00-l))!important}.has-text-link-00-invert{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-00-invert-l))!important}.has-background-link-00-invert{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-00-invert-l))!important}.has-text-link-05{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-05-l))!important}.has-background-link-05{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-05-l))!important}.has-text-link-05-invert{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-05-invert-l))!important}.has-background-link-05-invert{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-05-invert-l))!important}.has-text-link-10{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-10-l))!important}.has-background-link-10{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-10-l))!important}.has-text-link-10-invert{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-10-invert-l))!important}.has-background-link-10-invert{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-10-invert-l))!important}.has-text-link-15{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-15-l))!important}.has-background-link-15{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-15-l))!important}.has-text-link-15-invert{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-15-invert-l))!important}.has-background-link-15-invert{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-15-invert-l))!important}.has-text-link-20{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-20-l))!important}.has-background-link-20{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-20-l))!important}.has-text-link-20-invert{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-20-invert-l))!important}.has-background-link-20-invert{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-20-invert-l))!important}.has-text-link-25{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-25-l))!important}.has-background-link-25{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-25-l))!important}.has-text-link-25-invert{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-25-invert-l))!important}.has-background-link-25-invert{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-25-invert-l))!important}.has-text-link-30{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-30-l))!important}.has-background-link-30{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-30-l))!important}.has-text-link-30-invert{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-30-invert-l))!important}.has-background-link-30-invert{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-30-invert-l))!important}.has-text-link-35{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-35-l))!important}.has-background-link-35{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-35-l))!important}.has-text-link-35-invert{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-35-invert-l))!important}.has-background-link-35-invert{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-35-invert-l))!important}.has-text-link-40{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-40-l))!important}.has-background-link-40{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-40-l))!important}.has-text-link-40-invert{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-40-invert-l))!important}.has-background-link-40-invert{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-40-invert-l))!important}.has-text-link-45{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-45-l))!important}.has-background-link-45{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-45-l))!important}.has-text-link-45-invert{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-45-invert-l))!important}.has-background-link-45-invert{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-45-invert-l))!important}.has-text-link-50{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-50-l))!important}.has-background-link-50{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-50-l))!important}.has-text-link-50-invert{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-50-invert-l))!important}.has-background-link-50-invert{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-50-invert-l))!important}.has-text-link-55{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-55-l))!important}.has-background-link-55{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-55-l))!important}.has-text-link-55-invert{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-55-invert-l))!important}.has-background-link-55-invert{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-55-invert-l))!important}.has-text-link-60{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-60-l))!important}.has-background-link-60{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-60-l))!important}.has-text-link-60-invert{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-60-invert-l))!important}.has-background-link-60-invert{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-60-invert-l))!important}.has-text-link-65{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-65-l))!important}.has-background-link-65{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-65-l))!important}.has-text-link-65-invert{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-65-invert-l))!important}.has-background-link-65-invert{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-65-invert-l))!important}.has-text-link-70{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-70-l))!important}.has-background-link-70{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-70-l))!important}.has-text-link-70-invert{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-70-invert-l))!important}.has-background-link-70-invert{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-70-invert-l))!important}.has-text-link-75{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-75-l))!important}.has-background-link-75{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-75-l))!important}.has-text-link-75-invert{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-75-invert-l))!important}.has-background-link-75-invert{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-75-invert-l))!important}.has-text-link-80{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-80-l))!important}.has-background-link-80{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-80-l))!important}.has-text-link-80-invert{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-80-invert-l))!important}.has-background-link-80-invert{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-80-invert-l))!important}.has-text-link-85{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-85-l))!important}.has-background-link-85{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-85-l))!important}.has-text-link-85-invert{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-85-invert-l))!important}.has-background-link-85-invert{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-85-invert-l))!important}.has-text-link-90{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-90-l))!important}.has-background-link-90{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-90-l))!important}.has-text-link-90-invert{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-90-invert-l))!important}.has-background-link-90-invert{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-90-invert-l))!important}.has-text-link-95{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-95-l))!important}.has-background-link-95{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-95-l))!important}.has-text-link-95-invert{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-95-invert-l))!important}.has-background-link-95-invert{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-95-invert-l))!important}.has-text-link-100{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-100-l))!important}.has-background-link-100{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-100-l))!important}.has-text-link-100-invert{color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-100-invert-l))!important}.has-background-link-100-invert{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),var(--bulma-link-100-invert-l))!important}a.has-text-link:hover,a.has-text-link:focus-visible,button.has-text-link:hover,button.has-text-link:focus-visible,has-text-link.is-hoverable:hover,has-text-link.is-hoverable:focus-visible{color:hsl(var(--bulma-link-h),var(--bulma-link-s),calc(var(--bulma-link-l) + var(--bulma-hover-color-l-delta)))!important}a.has-text-link:active,button.has-text-link:active,has-text-link.is-hoverable:active{color:hsl(var(--bulma-link-h),var(--bulma-link-s),calc(var(--bulma-link-l) + var(--bulma-active-color-l-delta)))!important}a.has-background-link:hover,a.has-background-link:focus-visible,button.has-background-link:hover,button.has-background-link:focus-visible,has-background-link.is-hoverable:hover,has-background-link.is-hoverable:focus-visible{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),calc(var(--bulma-link-l) + var(--bulma-hover-background-l-delta)))!important}a.has-background-link:active,button.has-background-link:active,has-background-link.is-hoverable:active{background-color:hsl(var(--bulma-link-h),var(--bulma-link-s),calc(var(--bulma-link-l) + var(--bulma-active-background-l-delta)))!important}.is-palette-link{--h:var(--bulma-link-h);--s:var(--bulma-link-s);--l:var(--bulma-link-l);--color:hsl(var(--h),var(--s),var(--l));--00-l:var(--bulma-link-00-l);--color-00:hsl(var(--h),var(--s),var(--00-l));--05-l:var(--bulma-link-05-l);--color-05:hsl(var(--h),var(--s),var(--05-l));--10-l:var(--bulma-link-10-l);--color-10:hsl(var(--h),var(--s),var(--10-l));--15-l:var(--bulma-link-15-l);--color-15:hsl(var(--h),var(--s),var(--15-l));--20-l:var(--bulma-link-20-l);--color-20:hsl(var(--h),var(--s),var(--20-l));--25-l:var(--bulma-link-25-l);--color-25:hsl(var(--h),var(--s),var(--25-l));--30-l:var(--bulma-link-30-l);--color-30:hsl(var(--h),var(--s),var(--30-l));--35-l:var(--bulma-link-35-l);--color-35:hsl(var(--h),var(--s),var(--35-l));--40-l:var(--bulma-link-40-l);--color-40:hsl(var(--h),var(--s),var(--40-l));--45-l:var(--bulma-link-45-l);--color-45:hsl(var(--h),var(--s),var(--45-l));--50-l:var(--bulma-link-50-l);--color-50:hsl(var(--h),var(--s),var(--50-l));--55-l:var(--bulma-link-55-l);--color-55:hsl(var(--h),var(--s),var(--55-l));--60-l:var(--bulma-link-60-l);--color-60:hsl(var(--h),var(--s),var(--60-l));--65-l:var(--bulma-link-65-l);--color-65:hsl(var(--h),var(--s),var(--65-l));--70-l:var(--bulma-link-70-l);--color-70:hsl(var(--h),var(--s),var(--70-l));--75-l:var(--bulma-link-75-l);--color-75:hsl(var(--h),var(--s),var(--75-l));--80-l:var(--bulma-link-80-l);--color-80:hsl(var(--h),var(--s),var(--80-l));--85-l:var(--bulma-link-85-l);--color-85:hsl(var(--h),var(--s),var(--85-l));--90-l:var(--bulma-link-90-l);--color-90:hsl(var(--h),var(--s),var(--90-l));--95-l:var(--bulma-link-95-l);--color-95:hsl(var(--h),var(--s),var(--95-l));--100-l:var(--bulma-link-100-l);--color-100:hsl(var(--h),var(--s),var(--100-l))}.has-text-info{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-l))!important}.has-background-info{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-l))!important}.has-text-info-invert{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-invert-l))!important}.has-background-info-invert{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-invert-l))!important}.has-text-info-on-scheme{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-on-scheme-l))!important}.has-background-info-on-scheme{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-on-scheme-l))!important}.has-text-info-light{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-light-l))!important}.has-background-info-light{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-light-l))!important}.has-text-info-light-invert{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-light-invert-l))!important}.has-background-info-light-invert{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-light-invert-l))!important}.has-text-info-dark{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-dark-l))!important}.has-background-info-dark{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-dark-l))!important}.has-text-info-dark-invert{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-dark-invert-l))!important}.has-background-info-dark-invert{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-dark-invert-l))!important}.has-text-info-soft{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-soft-l))!important}.has-background-info-soft{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-soft-l))!important}.has-text-info-bold{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-bold-l))!important}.has-background-info-bold{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-bold-l))!important}.has-text-info-soft-invert{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-soft-invert-l))!important}.has-background-info-soft-invert{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-soft-invert-l))!important}.has-text-info-bold-invert{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-bold-invert-l))!important}.has-background-info-bold-invert{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-bold-invert-l))!important}.has-text-info-00{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-00-l))!important}.has-background-info-00{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-00-l))!important}.has-text-info-00-invert{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-00-invert-l))!important}.has-background-info-00-invert{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-00-invert-l))!important}.has-text-info-05{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-05-l))!important}.has-background-info-05{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-05-l))!important}.has-text-info-05-invert{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-05-invert-l))!important}.has-background-info-05-invert{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-05-invert-l))!important}.has-text-info-10{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-10-l))!important}.has-background-info-10{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-10-l))!important}.has-text-info-10-invert{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-10-invert-l))!important}.has-background-info-10-invert{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-10-invert-l))!important}.has-text-info-15{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-15-l))!important}.has-background-info-15{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-15-l))!important}.has-text-info-15-invert{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-15-invert-l))!important}.has-background-info-15-invert{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-15-invert-l))!important}.has-text-info-20{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-20-l))!important}.has-background-info-20{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-20-l))!important}.has-text-info-20-invert{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-20-invert-l))!important}.has-background-info-20-invert{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-20-invert-l))!important}.has-text-info-25{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-25-l))!important}.has-background-info-25{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-25-l))!important}.has-text-info-25-invert{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-25-invert-l))!important}.has-background-info-25-invert{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-25-invert-l))!important}.has-text-info-30{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-30-l))!important}.has-background-info-30{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-30-l))!important}.has-text-info-30-invert{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-30-invert-l))!important}.has-background-info-30-invert{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-30-invert-l))!important}.has-text-info-35{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-35-l))!important}.has-background-info-35{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-35-l))!important}.has-text-info-35-invert{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-35-invert-l))!important}.has-background-info-35-invert{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-35-invert-l))!important}.has-text-info-40{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-40-l))!important}.has-background-info-40{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-40-l))!important}.has-text-info-40-invert{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-40-invert-l))!important}.has-background-info-40-invert{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-40-invert-l))!important}.has-text-info-45{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-45-l))!important}.has-background-info-45{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-45-l))!important}.has-text-info-45-invert{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-45-invert-l))!important}.has-background-info-45-invert{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-45-invert-l))!important}.has-text-info-50{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-50-l))!important}.has-background-info-50{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-50-l))!important}.has-text-info-50-invert{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-50-invert-l))!important}.has-background-info-50-invert{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-50-invert-l))!important}.has-text-info-55{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-55-l))!important}.has-background-info-55{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-55-l))!important}.has-text-info-55-invert{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-55-invert-l))!important}.has-background-info-55-invert{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-55-invert-l))!important}.has-text-info-60{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-60-l))!important}.has-background-info-60{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-60-l))!important}.has-text-info-60-invert{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-60-invert-l))!important}.has-background-info-60-invert{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-60-invert-l))!important}.has-text-info-65{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-65-l))!important}.has-background-info-65{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-65-l))!important}.has-text-info-65-invert{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-65-invert-l))!important}.has-background-info-65-invert{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-65-invert-l))!important}.has-text-info-70{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-70-l))!important}.has-background-info-70{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-70-l))!important}.has-text-info-70-invert{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-70-invert-l))!important}.has-background-info-70-invert{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-70-invert-l))!important}.has-text-info-75{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-75-l))!important}.has-background-info-75{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-75-l))!important}.has-text-info-75-invert{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-75-invert-l))!important}.has-background-info-75-invert{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-75-invert-l))!important}.has-text-info-80{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-80-l))!important}.has-background-info-80{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-80-l))!important}.has-text-info-80-invert{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-80-invert-l))!important}.has-background-info-80-invert{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-80-invert-l))!important}.has-text-info-85{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-85-l))!important}.has-background-info-85{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-85-l))!important}.has-text-info-85-invert{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-85-invert-l))!important}.has-background-info-85-invert{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-85-invert-l))!important}.has-text-info-90{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-90-l))!important}.has-background-info-90{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-90-l))!important}.has-text-info-90-invert{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-90-invert-l))!important}.has-background-info-90-invert{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-90-invert-l))!important}.has-text-info-95{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-95-l))!important}.has-background-info-95{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-95-l))!important}.has-text-info-95-invert{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-95-invert-l))!important}.has-background-info-95-invert{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-95-invert-l))!important}.has-text-info-100{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-100-l))!important}.has-background-info-100{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-100-l))!important}.has-text-info-100-invert{color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-100-invert-l))!important}.has-background-info-100-invert{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),var(--bulma-info-100-invert-l))!important}a.has-text-info:hover,a.has-text-info:focus-visible,button.has-text-info:hover,button.has-text-info:focus-visible,has-text-info.is-hoverable:hover,has-text-info.is-hoverable:focus-visible{color:hsl(var(--bulma-info-h),var(--bulma-info-s),calc(var(--bulma-info-l) + var(--bulma-hover-color-l-delta)))!important}a.has-text-info:active,button.has-text-info:active,has-text-info.is-hoverable:active{color:hsl(var(--bulma-info-h),var(--bulma-info-s),calc(var(--bulma-info-l) + var(--bulma-active-color-l-delta)))!important}a.has-background-info:hover,a.has-background-info:focus-visible,button.has-background-info:hover,button.has-background-info:focus-visible,has-background-info.is-hoverable:hover,has-background-info.is-hoverable:focus-visible{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),calc(var(--bulma-info-l) + var(--bulma-hover-background-l-delta)))!important}a.has-background-info:active,button.has-background-info:active,has-background-info.is-hoverable:active{background-color:hsl(var(--bulma-info-h),var(--bulma-info-s),calc(var(--bulma-info-l) + var(--bulma-active-background-l-delta)))!important}.is-palette-info{--h:var(--bulma-info-h);--s:var(--bulma-info-s);--l:var(--bulma-info-l);--color:hsl(var(--h),var(--s),var(--l));--00-l:var(--bulma-info-00-l);--color-00:hsl(var(--h),var(--s),var(--00-l));--05-l:var(--bulma-info-05-l);--color-05:hsl(var(--h),var(--s),var(--05-l));--10-l:var(--bulma-info-10-l);--color-10:hsl(var(--h),var(--s),var(--10-l));--15-l:var(--bulma-info-15-l);--color-15:hsl(var(--h),var(--s),var(--15-l));--20-l:var(--bulma-info-20-l);--color-20:hsl(var(--h),var(--s),var(--20-l));--25-l:var(--bulma-info-25-l);--color-25:hsl(var(--h),var(--s),var(--25-l));--30-l:var(--bulma-info-30-l);--color-30:hsl(var(--h),var(--s),var(--30-l));--35-l:var(--bulma-info-35-l);--color-35:hsl(var(--h),var(--s),var(--35-l));--40-l:var(--bulma-info-40-l);--color-40:hsl(var(--h),var(--s),var(--40-l));--45-l:var(--bulma-info-45-l);--color-45:hsl(var(--h),var(--s),var(--45-l));--50-l:var(--bulma-info-50-l);--color-50:hsl(var(--h),var(--s),var(--50-l));--55-l:var(--bulma-info-55-l);--color-55:hsl(var(--h),var(--s),var(--55-l));--60-l:var(--bulma-info-60-l);--color-60:hsl(var(--h),var(--s),var(--60-l));--65-l:var(--bulma-info-65-l);--color-65:hsl(var(--h),var(--s),var(--65-l));--70-l:var(--bulma-info-70-l);--color-70:hsl(var(--h),var(--s),var(--70-l));--75-l:var(--bulma-info-75-l);--color-75:hsl(var(--h),var(--s),var(--75-l));--80-l:var(--bulma-info-80-l);--color-80:hsl(var(--h),var(--s),var(--80-l));--85-l:var(--bulma-info-85-l);--color-85:hsl(var(--h),var(--s),var(--85-l));--90-l:var(--bulma-info-90-l);--color-90:hsl(var(--h),var(--s),var(--90-l));--95-l:var(--bulma-info-95-l);--color-95:hsl(var(--h),var(--s),var(--95-l));--100-l:var(--bulma-info-100-l);--color-100:hsl(var(--h),var(--s),var(--100-l))}.has-text-success{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-l))!important}.has-background-success{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-l))!important}.has-text-success-invert{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-invert-l))!important}.has-background-success-invert{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-invert-l))!important}.has-text-success-on-scheme{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-on-scheme-l))!important}.has-background-success-on-scheme{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-on-scheme-l))!important}.has-text-success-light{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-light-l))!important}.has-background-success-light{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-light-l))!important}.has-text-success-light-invert{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-light-invert-l))!important}.has-background-success-light-invert{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-light-invert-l))!important}.has-text-success-dark{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-dark-l))!important}.has-background-success-dark{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-dark-l))!important}.has-text-success-dark-invert{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-dark-invert-l))!important}.has-background-success-dark-invert{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-dark-invert-l))!important}.has-text-success-soft{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-soft-l))!important}.has-background-success-soft{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-soft-l))!important}.has-text-success-bold{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-bold-l))!important}.has-background-success-bold{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-bold-l))!important}.has-text-success-soft-invert{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-soft-invert-l))!important}.has-background-success-soft-invert{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-soft-invert-l))!important}.has-text-success-bold-invert{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-bold-invert-l))!important}.has-background-success-bold-invert{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-bold-invert-l))!important}.has-text-success-00{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-00-l))!important}.has-background-success-00{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-00-l))!important}.has-text-success-00-invert{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-00-invert-l))!important}.has-background-success-00-invert{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-00-invert-l))!important}.has-text-success-05{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-05-l))!important}.has-background-success-05{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-05-l))!important}.has-text-success-05-invert{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-05-invert-l))!important}.has-background-success-05-invert{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-05-invert-l))!important}.has-text-success-10{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-10-l))!important}.has-background-success-10{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-10-l))!important}.has-text-success-10-invert{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-10-invert-l))!important}.has-background-success-10-invert{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-10-invert-l))!important}.has-text-success-15{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-15-l))!important}.has-background-success-15{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-15-l))!important}.has-text-success-15-invert{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-15-invert-l))!important}.has-background-success-15-invert{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-15-invert-l))!important}.has-text-success-20{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-20-l))!important}.has-background-success-20{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-20-l))!important}.has-text-success-20-invert{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-20-invert-l))!important}.has-background-success-20-invert{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-20-invert-l))!important}.has-text-success-25{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-25-l))!important}.has-background-success-25{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-25-l))!important}.has-text-success-25-invert{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-25-invert-l))!important}.has-background-success-25-invert{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-25-invert-l))!important}.has-text-success-30{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-30-l))!important}.has-background-success-30{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-30-l))!important}.has-text-success-30-invert{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-30-invert-l))!important}.has-background-success-30-invert{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-30-invert-l))!important}.has-text-success-35{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-35-l))!important}.has-background-success-35{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-35-l))!important}.has-text-success-35-invert{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-35-invert-l))!important}.has-background-success-35-invert{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-35-invert-l))!important}.has-text-success-40{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-40-l))!important}.has-background-success-40{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-40-l))!important}.has-text-success-40-invert{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-40-invert-l))!important}.has-background-success-40-invert{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-40-invert-l))!important}.has-text-success-45{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-45-l))!important}.has-background-success-45{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-45-l))!important}.has-text-success-45-invert{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-45-invert-l))!important}.has-background-success-45-invert{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-45-invert-l))!important}.has-text-success-50{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-50-l))!important}.has-background-success-50{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-50-l))!important}.has-text-success-50-invert{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-50-invert-l))!important}.has-background-success-50-invert{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-50-invert-l))!important}.has-text-success-55{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-55-l))!important}.has-background-success-55{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-55-l))!important}.has-text-success-55-invert{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-55-invert-l))!important}.has-background-success-55-invert{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-55-invert-l))!important}.has-text-success-60{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-60-l))!important}.has-background-success-60{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-60-l))!important}.has-text-success-60-invert{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-60-invert-l))!important}.has-background-success-60-invert{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-60-invert-l))!important}.has-text-success-65{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-65-l))!important}.has-background-success-65{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-65-l))!important}.has-text-success-65-invert{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-65-invert-l))!important}.has-background-success-65-invert{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-65-invert-l))!important}.has-text-success-70{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-70-l))!important}.has-background-success-70{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-70-l))!important}.has-text-success-70-invert{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-70-invert-l))!important}.has-background-success-70-invert{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-70-invert-l))!important}.has-text-success-75{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-75-l))!important}.has-background-success-75{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-75-l))!important}.has-text-success-75-invert{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-75-invert-l))!important}.has-background-success-75-invert{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-75-invert-l))!important}.has-text-success-80{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-80-l))!important}.has-background-success-80{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-80-l))!important}.has-text-success-80-invert{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-80-invert-l))!important}.has-background-success-80-invert{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-80-invert-l))!important}.has-text-success-85{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-85-l))!important}.has-background-success-85{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-85-l))!important}.has-text-success-85-invert{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-85-invert-l))!important}.has-background-success-85-invert{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-85-invert-l))!important}.has-text-success-90{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-90-l))!important}.has-background-success-90{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-90-l))!important}.has-text-success-90-invert{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-90-invert-l))!important}.has-background-success-90-invert{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-90-invert-l))!important}.has-text-success-95{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-95-l))!important}.has-background-success-95{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-95-l))!important}.has-text-success-95-invert{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-95-invert-l))!important}.has-background-success-95-invert{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-95-invert-l))!important}.has-text-success-100{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-100-l))!important}.has-background-success-100{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-100-l))!important}.has-text-success-100-invert{color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-100-invert-l))!important}.has-background-success-100-invert{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),var(--bulma-success-100-invert-l))!important}a.has-text-success:hover,a.has-text-success:focus-visible,button.has-text-success:hover,button.has-text-success:focus-visible,has-text-success.is-hoverable:hover,has-text-success.is-hoverable:focus-visible{color:hsl(var(--bulma-success-h),var(--bulma-success-s),calc(var(--bulma-success-l) + var(--bulma-hover-color-l-delta)))!important}a.has-text-success:active,button.has-text-success:active,has-text-success.is-hoverable:active{color:hsl(var(--bulma-success-h),var(--bulma-success-s),calc(var(--bulma-success-l) + var(--bulma-active-color-l-delta)))!important}a.has-background-success:hover,a.has-background-success:focus-visible,button.has-background-success:hover,button.has-background-success:focus-visible,has-background-success.is-hoverable:hover,has-background-success.is-hoverable:focus-visible{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),calc(var(--bulma-success-l) + var(--bulma-hover-background-l-delta)))!important}a.has-background-success:active,button.has-background-success:active,has-background-success.is-hoverable:active{background-color:hsl(var(--bulma-success-h),var(--bulma-success-s),calc(var(--bulma-success-l) + var(--bulma-active-background-l-delta)))!important}.is-palette-success{--h:var(--bulma-success-h);--s:var(--bulma-success-s);--l:var(--bulma-success-l);--color:hsl(var(--h),var(--s),var(--l));--00-l:var(--bulma-success-00-l);--color-00:hsl(var(--h),var(--s),var(--00-l));--05-l:var(--bulma-success-05-l);--color-05:hsl(var(--h),var(--s),var(--05-l));--10-l:var(--bulma-success-10-l);--color-10:hsl(var(--h),var(--s),var(--10-l));--15-l:var(--bulma-success-15-l);--color-15:hsl(var(--h),var(--s),var(--15-l));--20-l:var(--bulma-success-20-l);--color-20:hsl(var(--h),var(--s),var(--20-l));--25-l:var(--bulma-success-25-l);--color-25:hsl(var(--h),var(--s),var(--25-l));--30-l:var(--bulma-success-30-l);--color-30:hsl(var(--h),var(--s),var(--30-l));--35-l:var(--bulma-success-35-l);--color-35:hsl(var(--h),var(--s),var(--35-l));--40-l:var(--bulma-success-40-l);--color-40:hsl(var(--h),var(--s),var(--40-l));--45-l:var(--bulma-success-45-l);--color-45:hsl(var(--h),var(--s),var(--45-l));--50-l:var(--bulma-success-50-l);--color-50:hsl(var(--h),var(--s),var(--50-l));--55-l:var(--bulma-success-55-l);--color-55:hsl(var(--h),var(--s),var(--55-l));--60-l:var(--bulma-success-60-l);--color-60:hsl(var(--h),var(--s),var(--60-l));--65-l:var(--bulma-success-65-l);--color-65:hsl(var(--h),var(--s),var(--65-l));--70-l:var(--bulma-success-70-l);--color-70:hsl(var(--h),var(--s),var(--70-l));--75-l:var(--bulma-success-75-l);--color-75:hsl(var(--h),var(--s),var(--75-l));--80-l:var(--bulma-success-80-l);--color-80:hsl(var(--h),var(--s),var(--80-l));--85-l:var(--bulma-success-85-l);--color-85:hsl(var(--h),var(--s),var(--85-l));--90-l:var(--bulma-success-90-l);--color-90:hsl(var(--h),var(--s),var(--90-l));--95-l:var(--bulma-success-95-l);--color-95:hsl(var(--h),var(--s),var(--95-l));--100-l:var(--bulma-success-100-l);--color-100:hsl(var(--h),var(--s),var(--100-l))}.has-text-warning{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-l))!important}.has-background-warning{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-l))!important}.has-text-warning-invert{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-invert-l))!important}.has-background-warning-invert{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-invert-l))!important}.has-text-warning-on-scheme{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-on-scheme-l))!important}.has-background-warning-on-scheme{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-on-scheme-l))!important}.has-text-warning-light{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-light-l))!important}.has-background-warning-light{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-light-l))!important}.has-text-warning-light-invert{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-light-invert-l))!important}.has-background-warning-light-invert{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-light-invert-l))!important}.has-text-warning-dark{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-dark-l))!important}.has-background-warning-dark{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-dark-l))!important}.has-text-warning-dark-invert{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-dark-invert-l))!important}.has-background-warning-dark-invert{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-dark-invert-l))!important}.has-text-warning-soft{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-soft-l))!important}.has-background-warning-soft{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-soft-l))!important}.has-text-warning-bold{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-bold-l))!important}.has-background-warning-bold{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-bold-l))!important}.has-text-warning-soft-invert{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-soft-invert-l))!important}.has-background-warning-soft-invert{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-soft-invert-l))!important}.has-text-warning-bold-invert{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-bold-invert-l))!important}.has-background-warning-bold-invert{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-bold-invert-l))!important}.has-text-warning-00{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-00-l))!important}.has-background-warning-00{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-00-l))!important}.has-text-warning-00-invert{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-00-invert-l))!important}.has-background-warning-00-invert{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-00-invert-l))!important}.has-text-warning-05{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-05-l))!important}.has-background-warning-05{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-05-l))!important}.has-text-warning-05-invert{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-05-invert-l))!important}.has-background-warning-05-invert{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-05-invert-l))!important}.has-text-warning-10{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-10-l))!important}.has-background-warning-10{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-10-l))!important}.has-text-warning-10-invert{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-10-invert-l))!important}.has-background-warning-10-invert{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-10-invert-l))!important}.has-text-warning-15{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-15-l))!important}.has-background-warning-15{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-15-l))!important}.has-text-warning-15-invert{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-15-invert-l))!important}.has-background-warning-15-invert{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-15-invert-l))!important}.has-text-warning-20{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-20-l))!important}.has-background-warning-20{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-20-l))!important}.has-text-warning-20-invert{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-20-invert-l))!important}.has-background-warning-20-invert{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-20-invert-l))!important}.has-text-warning-25{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-25-l))!important}.has-background-warning-25{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-25-l))!important}.has-text-warning-25-invert{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-25-invert-l))!important}.has-background-warning-25-invert{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-25-invert-l))!important}.has-text-warning-30{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-30-l))!important}.has-background-warning-30{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-30-l))!important}.has-text-warning-30-invert{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-30-invert-l))!important}.has-background-warning-30-invert{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-30-invert-l))!important}.has-text-warning-35{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-35-l))!important}.has-background-warning-35{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-35-l))!important}.has-text-warning-35-invert{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-35-invert-l))!important}.has-background-warning-35-invert{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-35-invert-l))!important}.has-text-warning-40{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-40-l))!important}.has-background-warning-40{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-40-l))!important}.has-text-warning-40-invert{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-40-invert-l))!important}.has-background-warning-40-invert{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-40-invert-l))!important}.has-text-warning-45{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-45-l))!important}.has-background-warning-45{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-45-l))!important}.has-text-warning-45-invert{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-45-invert-l))!important}.has-background-warning-45-invert{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-45-invert-l))!important}.has-text-warning-50{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-50-l))!important}.has-background-warning-50{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-50-l))!important}.has-text-warning-50-invert{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-50-invert-l))!important}.has-background-warning-50-invert{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-50-invert-l))!important}.has-text-warning-55{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-55-l))!important}.has-background-warning-55{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-55-l))!important}.has-text-warning-55-invert{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-55-invert-l))!important}.has-background-warning-55-invert{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-55-invert-l))!important}.has-text-warning-60{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-60-l))!important}.has-background-warning-60{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-60-l))!important}.has-text-warning-60-invert{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-60-invert-l))!important}.has-background-warning-60-invert{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-60-invert-l))!important}.has-text-warning-65{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-65-l))!important}.has-background-warning-65{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-65-l))!important}.has-text-warning-65-invert{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-65-invert-l))!important}.has-background-warning-65-invert{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-65-invert-l))!important}.has-text-warning-70{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-70-l))!important}.has-background-warning-70{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-70-l))!important}.has-text-warning-70-invert{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-70-invert-l))!important}.has-background-warning-70-invert{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-70-invert-l))!important}.has-text-warning-75{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-75-l))!important}.has-background-warning-75{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-75-l))!important}.has-text-warning-75-invert{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-75-invert-l))!important}.has-background-warning-75-invert{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-75-invert-l))!important}.has-text-warning-80{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-80-l))!important}.has-background-warning-80{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-80-l))!important}.has-text-warning-80-invert{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-80-invert-l))!important}.has-background-warning-80-invert{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-80-invert-l))!important}.has-text-warning-85{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-85-l))!important}.has-background-warning-85{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-85-l))!important}.has-text-warning-85-invert{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-85-invert-l))!important}.has-background-warning-85-invert{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-85-invert-l))!important}.has-text-warning-90{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-90-l))!important}.has-background-warning-90{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-90-l))!important}.has-text-warning-90-invert{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-90-invert-l))!important}.has-background-warning-90-invert{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-90-invert-l))!important}.has-text-warning-95{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-95-l))!important}.has-background-warning-95{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-95-l))!important}.has-text-warning-95-invert{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-95-invert-l))!important}.has-background-warning-95-invert{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-95-invert-l))!important}.has-text-warning-100{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-100-l))!important}.has-background-warning-100{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-100-l))!important}.has-text-warning-100-invert{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-100-invert-l))!important}.has-background-warning-100-invert{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),var(--bulma-warning-100-invert-l))!important}a.has-text-warning:hover,a.has-text-warning:focus-visible,button.has-text-warning:hover,button.has-text-warning:focus-visible,has-text-warning.is-hoverable:hover,has-text-warning.is-hoverable:focus-visible{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),calc(var(--bulma-warning-l) + var(--bulma-hover-color-l-delta)))!important}a.has-text-warning:active,button.has-text-warning:active,has-text-warning.is-hoverable:active{color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),calc(var(--bulma-warning-l) + var(--bulma-active-color-l-delta)))!important}a.has-background-warning:hover,a.has-background-warning:focus-visible,button.has-background-warning:hover,button.has-background-warning:focus-visible,has-background-warning.is-hoverable:hover,has-background-warning.is-hoverable:focus-visible{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),calc(var(--bulma-warning-l) + var(--bulma-hover-background-l-delta)))!important}a.has-background-warning:active,button.has-background-warning:active,has-background-warning.is-hoverable:active{background-color:hsl(var(--bulma-warning-h),var(--bulma-warning-s),calc(var(--bulma-warning-l) + var(--bulma-active-background-l-delta)))!important}.is-palette-warning{--h:var(--bulma-warning-h);--s:var(--bulma-warning-s);--l:var(--bulma-warning-l);--color:hsl(var(--h),var(--s),var(--l));--00-l:var(--bulma-warning-00-l);--color-00:hsl(var(--h),var(--s),var(--00-l));--05-l:var(--bulma-warning-05-l);--color-05:hsl(var(--h),var(--s),var(--05-l));--10-l:var(--bulma-warning-10-l);--color-10:hsl(var(--h),var(--s),var(--10-l));--15-l:var(--bulma-warning-15-l);--color-15:hsl(var(--h),var(--s),var(--15-l));--20-l:var(--bulma-warning-20-l);--color-20:hsl(var(--h),var(--s),var(--20-l));--25-l:var(--bulma-warning-25-l);--color-25:hsl(var(--h),var(--s),var(--25-l));--30-l:var(--bulma-warning-30-l);--color-30:hsl(var(--h),var(--s),var(--30-l));--35-l:var(--bulma-warning-35-l);--color-35:hsl(var(--h),var(--s),var(--35-l));--40-l:var(--bulma-warning-40-l);--color-40:hsl(var(--h),var(--s),var(--40-l));--45-l:var(--bulma-warning-45-l);--color-45:hsl(var(--h),var(--s),var(--45-l));--50-l:var(--bulma-warning-50-l);--color-50:hsl(var(--h),var(--s),var(--50-l));--55-l:var(--bulma-warning-55-l);--color-55:hsl(var(--h),var(--s),var(--55-l));--60-l:var(--bulma-warning-60-l);--color-60:hsl(var(--h),var(--s),var(--60-l));--65-l:var(--bulma-warning-65-l);--color-65:hsl(var(--h),var(--s),var(--65-l));--70-l:var(--bulma-warning-70-l);--color-70:hsl(var(--h),var(--s),var(--70-l));--75-l:var(--bulma-warning-75-l);--color-75:hsl(var(--h),var(--s),var(--75-l));--80-l:var(--bulma-warning-80-l);--color-80:hsl(var(--h),var(--s),var(--80-l));--85-l:var(--bulma-warning-85-l);--color-85:hsl(var(--h),var(--s),var(--85-l));--90-l:var(--bulma-warning-90-l);--color-90:hsl(var(--h),var(--s),var(--90-l));--95-l:var(--bulma-warning-95-l);--color-95:hsl(var(--h),var(--s),var(--95-l));--100-l:var(--bulma-warning-100-l);--color-100:hsl(var(--h),var(--s),var(--100-l))}.has-text-danger{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-l))!important}.has-background-danger{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-l))!important}.has-text-danger-invert{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-invert-l))!important}.has-background-danger-invert{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-invert-l))!important}.has-text-danger-on-scheme{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-on-scheme-l))!important}.has-background-danger-on-scheme{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-on-scheme-l))!important}.has-text-danger-light{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-light-l))!important}.has-background-danger-light{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-light-l))!important}.has-text-danger-light-invert{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-light-invert-l))!important}.has-background-danger-light-invert{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-light-invert-l))!important}.has-text-danger-dark{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-dark-l))!important}.has-background-danger-dark{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-dark-l))!important}.has-text-danger-dark-invert{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-dark-invert-l))!important}.has-background-danger-dark-invert{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-dark-invert-l))!important}.has-text-danger-soft{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-soft-l))!important}.has-background-danger-soft{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-soft-l))!important}.has-text-danger-bold{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-bold-l))!important}.has-background-danger-bold{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-bold-l))!important}.has-text-danger-soft-invert{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-soft-invert-l))!important}.has-background-danger-soft-invert{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-soft-invert-l))!important}.has-text-danger-bold-invert{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-bold-invert-l))!important}.has-background-danger-bold-invert{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-bold-invert-l))!important}.has-text-danger-00{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-00-l))!important}.has-background-danger-00{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-00-l))!important}.has-text-danger-00-invert{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-00-invert-l))!important}.has-background-danger-00-invert{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-00-invert-l))!important}.has-text-danger-05{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-05-l))!important}.has-background-danger-05{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-05-l))!important}.has-text-danger-05-invert{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-05-invert-l))!important}.has-background-danger-05-invert{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-05-invert-l))!important}.has-text-danger-10{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-10-l))!important}.has-background-danger-10{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-10-l))!important}.has-text-danger-10-invert{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-10-invert-l))!important}.has-background-danger-10-invert{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-10-invert-l))!important}.has-text-danger-15{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-15-l))!important}.has-background-danger-15{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-15-l))!important}.has-text-danger-15-invert{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-15-invert-l))!important}.has-background-danger-15-invert{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-15-invert-l))!important}.has-text-danger-20{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-20-l))!important}.has-background-danger-20{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-20-l))!important}.has-text-danger-20-invert{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-20-invert-l))!important}.has-background-danger-20-invert{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-20-invert-l))!important}.has-text-danger-25{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-25-l))!important}.has-background-danger-25{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-25-l))!important}.has-text-danger-25-invert{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-25-invert-l))!important}.has-background-danger-25-invert{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-25-invert-l))!important}.has-text-danger-30{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-30-l))!important}.has-background-danger-30{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-30-l))!important}.has-text-danger-30-invert{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-30-invert-l))!important}.has-background-danger-30-invert{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-30-invert-l))!important}.has-text-danger-35{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-35-l))!important}.has-background-danger-35{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-35-l))!important}.has-text-danger-35-invert{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-35-invert-l))!important}.has-background-danger-35-invert{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-35-invert-l))!important}.has-text-danger-40{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-40-l))!important}.has-background-danger-40{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-40-l))!important}.has-text-danger-40-invert{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-40-invert-l))!important}.has-background-danger-40-invert{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-40-invert-l))!important}.has-text-danger-45{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-45-l))!important}.has-background-danger-45{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-45-l))!important}.has-text-danger-45-invert{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-45-invert-l))!important}.has-background-danger-45-invert{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-45-invert-l))!important}.has-text-danger-50{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-50-l))!important}.has-background-danger-50{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-50-l))!important}.has-text-danger-50-invert{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-50-invert-l))!important}.has-background-danger-50-invert{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-50-invert-l))!important}.has-text-danger-55{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-55-l))!important}.has-background-danger-55{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-55-l))!important}.has-text-danger-55-invert{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-55-invert-l))!important}.has-background-danger-55-invert{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-55-invert-l))!important}.has-text-danger-60{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-60-l))!important}.has-background-danger-60{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-60-l))!important}.has-text-danger-60-invert{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-60-invert-l))!important}.has-background-danger-60-invert{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-60-invert-l))!important}.has-text-danger-65{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-65-l))!important}.has-background-danger-65{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-65-l))!important}.has-text-danger-65-invert{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-65-invert-l))!important}.has-background-danger-65-invert{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-65-invert-l))!important}.has-text-danger-70{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-70-l))!important}.has-background-danger-70{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-70-l))!important}.has-text-danger-70-invert{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-70-invert-l))!important}.has-background-danger-70-invert{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-70-invert-l))!important}.has-text-danger-75{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-75-l))!important}.has-background-danger-75{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-75-l))!important}.has-text-danger-75-invert{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-75-invert-l))!important}.has-background-danger-75-invert{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-75-invert-l))!important}.has-text-danger-80{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-80-l))!important}.has-background-danger-80{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-80-l))!important}.has-text-danger-80-invert{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-80-invert-l))!important}.has-background-danger-80-invert{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-80-invert-l))!important}.has-text-danger-85{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-85-l))!important}.has-background-danger-85{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-85-l))!important}.has-text-danger-85-invert{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-85-invert-l))!important}.has-background-danger-85-invert{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-85-invert-l))!important}.has-text-danger-90{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-90-l))!important}.has-background-danger-90{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-90-l))!important}.has-text-danger-90-invert{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-90-invert-l))!important}.has-background-danger-90-invert{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-90-invert-l))!important}.has-text-danger-95{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-95-l))!important}.has-background-danger-95{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-95-l))!important}.has-text-danger-95-invert{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-95-invert-l))!important}.has-background-danger-95-invert{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-95-invert-l))!important}.has-text-danger-100{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-100-l))!important}.has-background-danger-100{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-100-l))!important}.has-text-danger-100-invert{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-100-invert-l))!important}.has-background-danger-100-invert{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),var(--bulma-danger-100-invert-l))!important}a.has-text-danger:hover,a.has-text-danger:focus-visible,button.has-text-danger:hover,button.has-text-danger:focus-visible,has-text-danger.is-hoverable:hover,has-text-danger.is-hoverable:focus-visible{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),calc(var(--bulma-danger-l) + var(--bulma-hover-color-l-delta)))!important}a.has-text-danger:active,button.has-text-danger:active,has-text-danger.is-hoverable:active{color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),calc(var(--bulma-danger-l) + var(--bulma-active-color-l-delta)))!important}a.has-background-danger:hover,a.has-background-danger:focus-visible,button.has-background-danger:hover,button.has-background-danger:focus-visible,has-background-danger.is-hoverable:hover,has-background-danger.is-hoverable:focus-visible{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),calc(var(--bulma-danger-l) + var(--bulma-hover-background-l-delta)))!important}a.has-background-danger:active,button.has-background-danger:active,has-background-danger.is-hoverable:active{background-color:hsl(var(--bulma-danger-h),var(--bulma-danger-s),calc(var(--bulma-danger-l) + var(--bulma-active-background-l-delta)))!important}.is-palette-danger{--h:var(--bulma-danger-h);--s:var(--bulma-danger-s);--l:var(--bulma-danger-l);--color:hsl(var(--h),var(--s),var(--l));--00-l:var(--bulma-danger-00-l);--color-00:hsl(var(--h),var(--s),var(--00-l));--05-l:var(--bulma-danger-05-l);--color-05:hsl(var(--h),var(--s),var(--05-l));--10-l:var(--bulma-danger-10-l);--color-10:hsl(var(--h),var(--s),var(--10-l));--15-l:var(--bulma-danger-15-l);--color-15:hsl(var(--h),var(--s),var(--15-l));--20-l:var(--bulma-danger-20-l);--color-20:hsl(var(--h),var(--s),var(--20-l));--25-l:var(--bulma-danger-25-l);--color-25:hsl(var(--h),var(--s),var(--25-l));--30-l:var(--bulma-danger-30-l);--color-30:hsl(var(--h),var(--s),var(--30-l));--35-l:var(--bulma-danger-35-l);--color-35:hsl(var(--h),var(--s),var(--35-l));--40-l:var(--bulma-danger-40-l);--color-40:hsl(var(--h),var(--s),var(--40-l));--45-l:var(--bulma-danger-45-l);--color-45:hsl(var(--h),var(--s),var(--45-l));--50-l:var(--bulma-danger-50-l);--color-50:hsl(var(--h),var(--s),var(--50-l));--55-l:var(--bulma-danger-55-l);--color-55:hsl(var(--h),var(--s),var(--55-l));--60-l:var(--bulma-danger-60-l);--color-60:hsl(var(--h),var(--s),var(--60-l));--65-l:var(--bulma-danger-65-l);--color-65:hsl(var(--h),var(--s),var(--65-l));--70-l:var(--bulma-danger-70-l);--color-70:hsl(var(--h),var(--s),var(--70-l));--75-l:var(--bulma-danger-75-l);--color-75:hsl(var(--h),var(--s),var(--75-l));--80-l:var(--bulma-danger-80-l);--color-80:hsl(var(--h),var(--s),var(--80-l));--85-l:var(--bulma-danger-85-l);--color-85:hsl(var(--h),var(--s),var(--85-l));--90-l:var(--bulma-danger-90-l);--color-90:hsl(var(--h),var(--s),var(--90-l));--95-l:var(--bulma-danger-95-l);--color-95:hsl(var(--h),var(--s),var(--95-l));--100-l:var(--bulma-danger-100-l);--color-100:hsl(var(--h),var(--s),var(--100-l))}.has-text-black-bis{color:#14161a!important}.has-background-black-bis{background-color:#14161a!important}.has-text-black-ter{color:#1f2229!important}.has-background-black-ter{background-color:#1f2229!important}.has-text-grey-darker{color:#2e333d!important}.has-background-grey-darker{background-color:#2e333d!important}.has-text-grey-dark{color:#404654!important}.has-background-grey-dark{background-color:#404654!important}.has-text-grey{color:#69748c!important}.has-background-grey{background-color:#69748c!important}.has-text-grey-light{color:#abb1bf!important}.has-background-grey-light{background-color:#abb1bf!important}.has-text-grey-lighter{color:#d6d9e0!important}.has-background-grey-lighter{background-color:#d6d9e0!important}.has-text-white-ter{color:#f3f4f6!important}.has-background-white-ter{background-color:#f3f4f6!important}.has-text-white-bis{color:#f9fafb!important}.has-background-white-bis{background-color:#f9fafb!important}.has-text-current{color:currentColor!important}.has-text-inherit{color:inherit!important}.has-background-current{background-color:currentColor!important}.has-background-inherit{background-color:inherit!important}.is-flex-direction-row{flex-direction:row!important}.is-flex-direction-row-reverse{flex-direction:row-reverse!important}.is-flex-direction-column{flex-direction:column!important}.is-flex-direction-column-reverse{flex-direction:column-reverse!important}.is-flex-wrap-nowrap{flex-wrap:nowrap!important}.is-flex-wrap-wrap{flex-wrap:wrap!important}.is-flex-wrap-wrap-reverse{flex-wrap:wrap-reverse!important}.is-justify-content-flex-start{justify-content:flex-start!important}.is-justify-content-flex-end{justify-content:flex-end!important}.is-justify-content-center{justify-content:center!important}.is-justify-content-space-between{justify-content:space-between!important}.is-justify-content-space-around{justify-content:space-around!important}.is-justify-content-space-evenly{justify-content:space-evenly!important}.is-justify-content-start{justify-content:start!important}.is-justify-content-end{justify-content:end!important}.is-justify-content-left{justify-content:left!important}.is-justify-content-right{justify-content:right!important}.is-align-content-flex-start{align-content:flex-start!important}.is-align-content-flex-end{align-content:flex-end!important}.is-align-content-center{align-content:center!important}.is-align-content-space-between{align-content:space-between!important}.is-align-content-space-around{align-content:space-around!important}.is-align-content-space-evenly{align-content:space-evenly!important}.is-align-content-stretch{align-content:stretch!important}.is-align-content-start{align-content:start!important}.is-align-content-end{align-content:end!important}.is-align-content-baseline{align-content:baseline!important}.is-align-items-stretch{align-items:stretch!important}.is-align-items-flex-start{align-items:flex-start!important}.is-align-items-flex-end{align-items:flex-end!important}.is-align-items-center{align-items:center!important}.is-align-items-baseline{align-items:baseline!important}.is-align-items-start{align-items:start!important}.is-align-items-end{align-items:end!important}.is-align-items-self-start{align-items:self-start!important}.is-align-items-self-end{align-items:self-end!important}.is-align-self-auto{align-self:auto!important}.is-align-self-flex-start{align-self:flex-start!important}.is-align-self-flex-end{align-self:flex-end!important}.is-align-self-center{align-self:center!important}.is-align-self-baseline{align-self:baseline!important}.is-align-self-stretch{align-self:stretch!important}.is-flex-grow-0{flex-grow:0!important}.is-flex-grow-1{flex-grow:1!important}.is-flex-grow-2{flex-grow:2!important}.is-flex-grow-3{flex-grow:3!important}.is-flex-grow-4{flex-grow:4!important}.is-flex-grow-5{flex-grow:5!important}.is-flex-shrink-0{flex-shrink:0!important}.is-flex-shrink-1{flex-shrink:1!important}.is-flex-shrink-2{flex-shrink:2!important}.is-flex-shrink-3{flex-shrink:3!important}.is-flex-shrink-4{flex-shrink:4!important}.is-flex-shrink-5{flex-shrink:5!important}.is-clearfix:after{clear:both;content:" ";display:table}.is-float-left,.is-pulled-left{float:left!important}.is-float-right,.is-pulled-right{float:right!important}.is-float-none{float:none!important}.is-clear-both{clear:both!important}.is-clear-left{clear:left!important}.is-clear-none{clear:none!important}.is-clear-right{clear:right!important}.is-gapless{gap:0!important}.is-gap-0{gap:0!important}.is-gap-0\.5{gap:.25rem!important}.is-gap-1{gap:.5rem!important}.is-gap-1\.5{gap:.75rem!important}.is-gap-2{gap:1rem!important}.is-gap-2\.5{gap:1.25rem!important}.is-gap-3{gap:1.5rem!important}.is-gap-3\.5{gap:1.75rem!important}.is-gap-4{gap:2rem!important}.is-gap-4\.5{gap:2.25rem!important}.is-gap-5{gap:2.5rem!important}.is-gap-5\.5{gap:2.75rem!important}.is-gap-6{gap:3rem!important}.is-gap-6\.5{gap:3.25rem!important}.is-gap-7{gap:3.5rem!important}.is-gap-7\.5{gap:3.75rem!important}.is-gap-8{gap:4rem!important}.is-column-gap-0{column-gap:0!important}.is-column-gap-0\.5{column-gap:.25rem!important}.is-column-gap-1{column-gap:.5rem!important}.is-column-gap-1\.5{column-gap:.75rem!important}.is-column-gap-2{column-gap:1rem!important}.is-column-gap-2\.5{column-gap:1.25rem!important}.is-column-gap-3{column-gap:1.5rem!important}.is-column-gap-3\.5{column-gap:1.75rem!important}.is-column-gap-4{column-gap:2rem!important}.is-column-gap-4\.5{column-gap:2.25rem!important}.is-column-gap-5{column-gap:2.5rem!important}.is-column-gap-5\.5{column-gap:2.75rem!important}.is-column-gap-6{column-gap:3rem!important}.is-column-gap-6\.5{column-gap:3.25rem!important}.is-column-gap-7{column-gap:3.5rem!important}.is-column-gap-7\.5{column-gap:3.75rem!important}.is-column-gap-8{column-gap:4rem!important}.is-row-gap-0{row-gap:0!important}.is-row-gap-0\.5{row-gap:.25rem!important}.is-row-gap-1{row-gap:.5rem!important}.is-row-gap-1\.5{row-gap:.75rem!important}.is-row-gap-2{row-gap:1rem!important}.is-row-gap-2\.5{row-gap:1.25rem!important}.is-row-gap-3{row-gap:1.5rem!important}.is-row-gap-3\.5{row-gap:1.75rem!important}.is-row-gap-4{row-gap:2rem!important}.is-row-gap-4\.5{row-gap:2.25rem!important}.is-row-gap-5{row-gap:2.5rem!important}.is-row-gap-5\.5{row-gap:2.75rem!important}.is-row-gap-6{row-gap:3rem!important}.is-row-gap-6\.5{row-gap:3.25rem!important}.is-row-gap-7{row-gap:3.5rem!important}.is-row-gap-7\.5{row-gap:3.75rem!important}.is-row-gap-8{row-gap:4rem!important}.is-clipped{overflow:hidden!important}.is-overflow-auto{overflow:auto!important}.is-overflow-x-auto{overflow-x:auto!important}.is-overflow-y-auto{overflow-y:auto!important}.is-overflow-clip{overflow:clip!important}.is-overflow-x-clip{overflow-x:clip!important}.is-overflow-y-clip{overflow-y:clip!important}.is-overflow-hidden{overflow:hidden!important}.is-overflow-x-hidden{overflow-x:hidden!important}.is-overflow-y-hidden{overflow-y:hidden!important}.is-overflow-scroll{overflow:scroll!important}.is-overflow-x-scroll{overflow-x:scroll!important}.is-overflow-y-scroll{overflow-y:scroll!important}.is-overflow-visible{overflow:visible!important}.is-overflow-x-visible{overflow-x:visible!important}.is-overflow-y-visible{overflow-y:visible!important}.is-relative{position:relative!important}.is-position-absolute{position:absolute!important}.is-position-fixed{position:fixed!important}.is-position-relative{position:relative!important}.is-position-static{position:static!important}.is-position-sticky{position:sticky!important}.marginless{margin:0!important}.paddingless{padding:0!important}.m-0{margin:0!important}.mt-0{margin-top:0!important}.mr-0{margin-right:0!important}.mb-0{margin-bottom:0!important}.ml-0{margin-left:0!important}.mx-0{margin-left:0!important;margin-right:0!important}.my-0{margin-top:0!important;margin-bottom:0!important}.m-1{margin:.25rem!important}.mt-1{margin-top:.25rem!important}.mr-1{margin-right:.25rem!important}.mb-1{margin-bottom:.25rem!important}.ml-1{margin-left:.25rem!important}.mx-1{margin-left:.25rem!important;margin-right:.25rem!important}.my-1{margin-top:.25rem!important;margin-bottom:.25rem!important}.m-2{margin:.5rem!important}.mt-2{margin-top:.5rem!important}.mr-2{margin-right:.5rem!important}.mb-2{margin-bottom:.5rem!important}.ml-2{margin-left:.5rem!important}.mx-2{margin-left:.5rem!important;margin-right:.5rem!important}.my-2{margin-top:.5rem!important;margin-bottom:.5rem!important}.m-3{margin:.75rem!important}.mt-3{margin-top:.75rem!important}.mr-3{margin-right:.75rem!important}.mb-3{margin-bottom:.75rem!important}.ml-3{margin-left:.75rem!important}.mx-3{margin-left:.75rem!important;margin-right:.75rem!important}.my-3{margin-top:.75rem!important;margin-bottom:.75rem!important}.m-4{margin:1rem!important}.mt-4{margin-top:1rem!important}.mr-4{margin-right:1rem!important}.mb-4{margin-bottom:1rem!important}.ml-4{margin-left:1rem!important}.mx-4{margin-left:1rem!important;margin-right:1rem!important}.my-4{margin-top:1rem!important;margin-bottom:1rem!important}.m-5{margin:1.5rem!important}.mt-5{margin-top:1.5rem!important}.mr-5{margin-right:1.5rem!important}.mb-5{margin-bottom:1.5rem!important}.ml-5{margin-left:1.5rem!important}.mx-5{margin-left:1.5rem!important;margin-right:1.5rem!important}.my-5{margin-top:1.5rem!important;margin-bottom:1.5rem!important}.m-6{margin:3rem!important}.mt-6{margin-top:3rem!important}.mr-6{margin-right:3rem!important}.mb-6{margin-bottom:3rem!important}.ml-6{margin-left:3rem!important}.mx-6{margin-left:3rem!important;margin-right:3rem!important}.my-6{margin-top:3rem!important;margin-bottom:3rem!important}.m-auto{margin:auto!important}.mt-auto{margin-top:auto!important}.mr-auto{margin-right:auto!important}.mb-auto{margin-bottom:auto!important}.ml-auto{margin-left:auto!important}.mx-auto{margin-left:auto!important;margin-right:auto!important}.my-auto{margin-top:auto!important;margin-bottom:auto!important}.p-0{padding:0!important}.pt-0{padding-top:0!important}.pr-0{padding-right:0!important}.pb-0{padding-bottom:0!important}.pl-0{padding-left:0!important}.px-0{padding-left:0!important;padding-right:0!important}.py-0{padding-top:0!important;padding-bottom:0!important}.p-1{padding:.25rem!important}.pt-1{padding-top:.25rem!important}.pr-1{padding-right:.25rem!important}.pb-1{padding-bottom:.25rem!important}.pl-1{padding-left:.25rem!important}.px-1{padding-left:.25rem!important;padding-right:.25rem!important}.py-1{padding-top:.25rem!important;padding-bottom:.25rem!important}.p-2{padding:.5rem!important}.pt-2{padding-top:.5rem!important}.pr-2{padding-right:.5rem!important}.pb-2{padding-bottom:.5rem!important}.pl-2{padding-left:.5rem!important}.px-2{padding-left:.5rem!important;padding-right:.5rem!important}.py-2{padding-top:.5rem!important;padding-bottom:.5rem!important}.p-3{padding:.75rem!important}.pt-3{padding-top:.75rem!important}.pr-3{padding-right:.75rem!important}.pb-3{padding-bottom:.75rem!important}.pl-3{padding-left:.75rem!important}.px-3{padding-left:.75rem!important;padding-right:.75rem!important}.py-3{padding-top:.75rem!important;padding-bottom:.75rem!important}.p-4{padding:1rem!important}.pt-4{padding-top:1rem!important}.pr-4{padding-right:1rem!important}.pb-4{padding-bottom:1rem!important}.pl-4{padding-left:1rem!important}.px-4{padding-left:1rem!important;padding-right:1rem!important}.py-4{padding-top:1rem!important;padding-bottom:1rem!important}.p-5{padding:1.5rem!important}.pt-5{padding-top:1.5rem!important}.pr-5{padding-right:1.5rem!important}.pb-5{padding-bottom:1.5rem!important}.pl-5{padding-left:1.5rem!important}.px-5{padding-left:1.5rem!important;padding-right:1.5rem!important}.py-5{padding-top:1.5rem!important;padding-bottom:1.5rem!important}.p-6{padding:3rem!important}.pt-6{padding-top:3rem!important}.pr-6{padding-right:3rem!important}.pb-6{padding-bottom:3rem!important}.pl-6{padding-left:3rem!important}.px-6{padding-left:3rem!important;padding-right:3rem!important}.py-6{padding-top:3rem!important;padding-bottom:3rem!important}.p-auto{padding:auto!important}.pt-auto{padding-top:auto!important}.pr-auto{padding-right:auto!important}.pb-auto{padding-bottom:auto!important}.pl-auto{padding-left:auto!important}.px-auto{padding-left:auto!important;padding-right:auto!important}.py-auto{padding-top:auto!important;padding-bottom:auto!important}.is-size-1{font-size:3rem!important}.is-size-2{font-size:2.5rem!important}.is-size-3{font-size:2rem!important}.is-size-4{font-size:1.5rem!important}.is-size-5{font-size:1.25rem!important}.is-size-6{font-size:1rem!important}.is-size-7{font-size:.75rem!important}@media screen and (width<=768px){.is-size-1-mobile{font-size:3rem!important}.is-size-2-mobile{font-size:2.5rem!important}.is-size-3-mobile{font-size:2rem!important}.is-size-4-mobile{font-size:1.5rem!important}.is-size-5-mobile{font-size:1.25rem!important}.is-size-6-mobile{font-size:1rem!important}.is-size-7-mobile{font-size:.75rem!important}}@media screen and (width>=769px),print{.is-size-1-tablet{font-size:3rem!important}.is-size-2-tablet{font-size:2.5rem!important}.is-size-3-tablet{font-size:2rem!important}.is-size-4-tablet{font-size:1.5rem!important}.is-size-5-tablet{font-size:1.25rem!important}.is-size-6-tablet{font-size:1rem!important}.is-size-7-tablet{font-size:.75rem!important}}@media screen and (width<=1023px){.is-size-1-touch{font-size:3rem!important}.is-size-2-touch{font-size:2.5rem!important}.is-size-3-touch{font-size:2rem!important}.is-size-4-touch{font-size:1.5rem!important}.is-size-5-touch{font-size:1.25rem!important}.is-size-6-touch{font-size:1rem!important}.is-size-7-touch{font-size:.75rem!important}}@media screen and (width>=1024px){.is-size-1-desktop{font-size:3rem!important}.is-size-2-desktop{font-size:2.5rem!important}.is-size-3-desktop{font-size:2rem!important}.is-size-4-desktop{font-size:1.5rem!important}.is-size-5-desktop{font-size:1.25rem!important}.is-size-6-desktop{font-size:1rem!important}.is-size-7-desktop{font-size:.75rem!important}}@media screen and (width>=1216px){.is-size-1-widescreen{font-size:3rem!important}.is-size-2-widescreen{font-size:2.5rem!important}.is-size-3-widescreen{font-size:2rem!important}.is-size-4-widescreen{font-size:1.5rem!important}.is-size-5-widescreen{font-size:1.25rem!important}.is-size-6-widescreen{font-size:1rem!important}.is-size-7-widescreen{font-size:.75rem!important}}@media screen and (width>=1408px){.is-size-1-fullhd{font-size:3rem!important}.is-size-2-fullhd{font-size:2.5rem!important}.is-size-3-fullhd{font-size:2rem!important}.is-size-4-fullhd{font-size:1.5rem!important}.is-size-5-fullhd{font-size:1.25rem!important}.is-size-6-fullhd{font-size:1rem!important}.is-size-7-fullhd{font-size:.75rem!important}}.has-text-centered{text-align:center!important}.has-text-justified{text-align:justify!important}.has-text-left{text-align:left!important}.has-text-right{text-align:right!important}@media screen and (width<=768px){.has-text-centered-mobile{text-align:center!important}}@media screen and (width>=769px),print{.has-text-centered-tablet{text-align:center!important}}@media screen and (width>=769px) and (width<=1023px){.has-text-centered-tablet-only{text-align:center!important}}@media screen and (width<=1023px){.has-text-centered-touch{text-align:center!important}}@media screen and (width>=1024px){.has-text-centered-desktop{text-align:center!important}}@media screen and (width>=1024px) and (width<=1215px){.has-text-centered-desktop-only{text-align:center!important}}@media screen and (width>=1216px){.has-text-centered-widescreen{text-align:center!important}}@media screen and (width>=1216px) and (width<=1407px){.has-text-centered-widescreen-only{text-align:center!important}}@media screen and (width>=1408px){.has-text-centered-fullhd{text-align:center!important}}@media screen and (width<=768px){.has-text-justified-mobile{text-align:justify!important}}@media screen and (width>=769px),print{.has-text-justified-tablet{text-align:justify!important}}@media screen and (width>=769px) and (width<=1023px){.has-text-justified-tablet-only{text-align:justify!important}}@media screen and (width<=1023px){.has-text-justified-touch{text-align:justify!important}}@media screen and (width>=1024px){.has-text-justified-desktop{text-align:justify!important}}@media screen and (width>=1024px) and (width<=1215px){.has-text-justified-desktop-only{text-align:justify!important}}@media screen and (width>=1216px){.has-text-justified-widescreen{text-align:justify!important}}@media screen and (width>=1216px) and (width<=1407px){.has-text-justified-widescreen-only{text-align:justify!important}}@media screen and (width>=1408px){.has-text-justified-fullhd{text-align:justify!important}}@media screen and (width<=768px){.has-text-left-mobile{text-align:left!important}}@media screen and (width>=769px),print{.has-text-left-tablet{text-align:left!important}}@media screen and (width>=769px) and (width<=1023px){.has-text-left-tablet-only{text-align:left!important}}@media screen and (width<=1023px){.has-text-left-touch{text-align:left!important}}@media screen and (width>=1024px){.has-text-left-desktop{text-align:left!important}}@media screen and (width>=1024px) and (width<=1215px){.has-text-left-desktop-only{text-align:left!important}}@media screen and (width>=1216px){.has-text-left-widescreen{text-align:left!important}}@media screen and (width>=1216px) and (width<=1407px){.has-text-left-widescreen-only{text-align:left!important}}@media screen and (width>=1408px){.has-text-left-fullhd{text-align:left!important}}@media screen and (width<=768px){.has-text-right-mobile{text-align:right!important}}@media screen and (width>=769px),print{.has-text-right-tablet{text-align:right!important}}@media screen and (width>=769px) and (width<=1023px){.has-text-right-tablet-only{text-align:right!important}}@media screen and (width<=1023px){.has-text-right-touch{text-align:right!important}}@media screen and (width>=1024px){.has-text-right-desktop{text-align:right!important}}@media screen and (width>=1024px) and (width<=1215px){.has-text-right-desktop-only{text-align:right!important}}@media screen and (width>=1216px){.has-text-right-widescreen{text-align:right!important}}@media screen and (width>=1216px) and (width<=1407px){.has-text-right-widescreen-only{text-align:right!important}}@media screen and (width>=1408px){.has-text-right-fullhd{text-align:right!important}}.is-capitalized{text-transform:capitalize!important}.is-lowercase{text-transform:lowercase!important}.is-uppercase{text-transform:uppercase!important}.is-italic{font-style:italic!important}.is-underlined{text-decoration:underline!important}.has-text-weight-light{font-weight:300!important}.has-text-weight-normal{font-weight:400!important}.has-text-weight-medium{font-weight:500!important}.has-text-weight-semibold{font-weight:600!important}.has-text-weight-bold{font-weight:700!important}.is-family-primary,.is-family-secondary,.is-family-sans-serif{font-family:Inter,SF Pro,Segoe UI,Roboto,Oxygen,Ubuntu,Helvetica Neue,Helvetica,Arial,sans-serif!important}.is-family-monospace,.is-family-code{font-family:Inconsolata,Hack,SF Mono,Roboto Mono,Source Code Pro,Ubuntu Mono,monospace!important}.is-display-none,.is-hidden{display:none!important}.is-display-block,.is-block{display:block!important}@media screen and (width<=768px){.is-display-block-mobile,.is-block-mobile{display:block!important}}@media screen and (width>=769px),print{.is-display-block-tablet,.is-block-tablet{display:block!important}}@media screen and (width>=769px) and (width<=1023px){.is-display-block-tablet-only,.is-block-tablet-only{display:block!important}}@media screen and (width<=1023px){.is-display-block-touch,.is-block-touch{display:block!important}}@media screen and (width>=1024px){.is-display-block-desktop,.is-block-desktop{display:block!important}}@media screen and (width>=1024px) and (width<=1215px){.is-display-block-desktop-only,.is-block-desktop-only{display:block!important}}@media screen and (width>=1216px){.is-display-block-widescreen,.is-block-widescreen{display:block!important}}@media screen and (width>=1216px) and (width<=1407px){.is-display-block-widescreen-only,.is-block-widescreen-only{display:block!important}}@media screen and (width>=1408px){.is-display-block-fullhd,.is-block-fullhd{display:block!important}}.is-display-flex,.is-flex{display:flex!important}@media screen and (width<=768px){.is-display-flex-mobile,.is-flex-mobile{display:flex!important}}@media screen and (width>=769px),print{.is-display-flex-tablet,.is-flex-tablet{display:flex!important}}@media screen and (width>=769px) and (width<=1023px){.is-display-flex-tablet-only,.is-flex-tablet-only{display:flex!important}}@media screen and (width<=1023px){.is-display-flex-touch,.is-flex-touch{display:flex!important}}@media screen and (width>=1024px){.is-display-flex-desktop,.is-flex-desktop{display:flex!important}}@media screen and (width>=1024px) and (width<=1215px){.is-display-flex-desktop-only,.is-flex-desktop-only{display:flex!important}}@media screen and (width>=1216px){.is-display-flex-widescreen,.is-flex-widescreen{display:flex!important}}@media screen and (width>=1216px) and (width<=1407px){.is-display-flex-widescreen-only,.is-flex-widescreen-only{display:flex!important}}@media screen and (width>=1408px){.is-display-flex-fullhd,.is-flex-fullhd{display:flex!important}}.is-display-inline,.is-inline{display:inline!important}@media screen and (width<=768px){.is-display-inline-mobile,.is-inline-mobile{display:inline!important}}@media screen and (width>=769px),print{.is-display-inline-tablet,.is-inline-tablet{display:inline!important}}@media screen and (width>=769px) and (width<=1023px){.is-display-inline-tablet-only,.is-inline-tablet-only{display:inline!important}}@media screen and (width<=1023px){.is-display-inline-touch,.is-inline-touch{display:inline!important}}@media screen and (width>=1024px){.is-display-inline-desktop,.is-inline-desktop{display:inline!important}}@media screen and (width>=1024px) and (width<=1215px){.is-display-inline-desktop-only,.is-inline-desktop-only{display:inline!important}}@media screen and (width>=1216px){.is-display-inline-widescreen,.is-inline-widescreen{display:inline!important}}@media screen and (width>=1216px) and (width<=1407px){.is-display-inline-widescreen-only,.is-inline-widescreen-only{display:inline!important}}@media screen and (width>=1408px){.is-display-inline-fullhd,.is-inline-fullhd{display:inline!important}}.is-display-inline-block,.is-inline-block{display:inline-block!important}@media screen and (width<=768px){.is-display-inline-block-mobile,.is-inline-block-mobile{display:inline-block!important}}@media screen and (width>=769px),print{.is-display-inline-block-tablet,.is-inline-block-tablet{display:inline-block!important}}@media screen and (width>=769px) and (width<=1023px){.is-display-inline-block-tablet-only,.is-inline-block-tablet-only{display:inline-block!important}}@media screen and (width<=1023px){.is-display-inline-block-touch,.is-inline-block-touch{display:inline-block!important}}@media screen and (width>=1024px){.is-display-inline-block-desktop,.is-inline-block-desktop{display:inline-block!important}}@media screen and (width>=1024px) and (width<=1215px){.is-display-inline-block-desktop-only,.is-inline-block-desktop-only{display:inline-block!important}}@media screen and (width>=1216px){.is-display-inline-block-widescreen,.is-inline-block-widescreen{display:inline-block!important}}@media screen and (width>=1216px) and (width<=1407px){.is-display-inline-block-widescreen-only,.is-inline-block-widescreen-only{display:inline-block!important}}@media screen and (width>=1408px){.is-display-inline-block-fullhd,.is-inline-block-fullhd{display:inline-block!important}}.is-display-inline-flex,.is-inline-flex{display:inline-flex!important}@media screen and (width<=768px){.is-display-inline-flex-mobile,.is-inline-flex-mobile{display:inline-flex!important}}@media screen and (width>=769px),print{.is-display-inline-flex-tablet,.is-inline-flex-tablet{display:inline-flex!important}}@media screen and (width>=769px) and (width<=1023px){.is-display-inline-flex-tablet-only,.is-inline-flex-tablet-only{display:inline-flex!important}}@media screen and (width<=1023px){.is-display-inline-flex-touch,.is-inline-flex-touch{display:inline-flex!important}}@media screen and (width>=1024px){.is-display-inline-flex-desktop,.is-inline-flex-desktop{display:inline-flex!important}}@media screen and (width>=1024px) and (width<=1215px){.is-display-inline-flex-desktop-only,.is-inline-flex-desktop-only{display:inline-flex!important}}@media screen and (width>=1216px){.is-display-inline-flex-widescreen,.is-inline-flex-widescreen{display:inline-flex!important}}@media screen and (width>=1216px) and (width<=1407px){.is-display-inline-flex-widescreen-only,.is-inline-flex-widescreen-only{display:inline-flex!important}}@media screen and (width>=1408px){.is-display-inline-flex-fullhd,.is-inline-flex-fullhd{display:inline-flex!important}}.is-display-grid,.is-grid{display:grid!important}@media screen and (width<=768px){.is-display-grid-mobile,.is-grid-mobile{display:grid!important}}@media screen and (width>=769px),print{.is-display-grid-tablet,.is-grid-tablet{display:grid!important}}@media screen and (width>=769px) and (width<=1023px){.is-display-grid-tablet-only,.is-grid-tablet-only{display:grid!important}}@media screen and (width<=1023px){.is-display-grid-touch,.is-grid-touch{display:grid!important}}@media screen and (width>=1024px){.is-display-grid-desktop,.is-grid-desktop{display:grid!important}}@media screen and (width>=1024px) and (width<=1215px){.is-display-grid-desktop-only,.is-grid-desktop-only{display:grid!important}}@media screen and (width>=1216px){.is-display-grid-widescreen,.is-grid-widescreen{display:grid!important}}@media screen and (width>=1216px) and (width<=1407px){.is-display-grid-widescreen-only,.is-grid-widescreen-only{display:grid!important}}@media screen and (width>=1408px){.is-display-grid-fullhd,.is-grid-fullhd{display:grid!important}}.is-sr-only{clip:rect(0,0,0,0)!important;white-space:nowrap!important;border:none!important;width:.01em!important;height:.01em!important;padding:0!important;position:absolute!important;overflow:hidden!important}@media screen and (width<=768px){.is-display-none-mobile,.is-hidden-mobile{display:none!important}}@media screen and (width>=769px),print{.is-display-none-tablet,.is-hidden-tablet{display:none!important}}@media screen and (width>=769px) and (width<=1023px){.is-display-none-tablet-only,.is-hidden-tablet-only{display:none!important}}@media screen and (width<=1023px){.is-display-none-touch,.is-hidden-touch{display:none!important}}@media screen and (width>=1024px){.is-display-none-desktop,.is-hidden-desktop{display:none!important}}@media screen and (width>=1024px) and (width<=1215px){.is-display-none-desktop-only,.is-hidden-desktop-only{display:none!important}}@media screen and (width>=1216px){.is-display-none-widescreen,.is-hidden-widescreen{display:none!important}}@media screen and (width>=1216px) and (width<=1407px){.is-display-none-widescreen-only,.is-hidden-widescreen-only{display:none!important}}@media screen and (width>=1408px){.is-display-none-fullhd,.is-hidden-fullhd{display:none!important}}.is-visibility-hidden,.is-invisible{visibility:hidden!important}@media screen and (width<=768px){.is-visibility-hidden-mobile,.is-invisible-mobile{visibility:hidden!important}}@media screen and (width>=769px),print{.is-visibility-hidden-tablet,.is-invisible-tablet{visibility:hidden!important}}@media screen and (width>=769px) and (width<=1023px){.is-visibility-hidden-tablet-only,.is-invisible-tablet-only{visibility:hidden!important}}@media screen and (width<=1023px){.is-visibility-hidden-touch,.is-invisible-touch{visibility:hidden!important}}@media screen and (width>=1024px){.is-visibility-hidden-desktop,.is-invisible-desktop{visibility:hidden!important}}@media screen and (width>=1024px) and (width<=1215px){.is-visibility-hidden-desktop-only,.is-invisible-desktop-only{visibility:hidden!important}}@media screen and (width>=1216px){.is-visibility-hidden-widescreen,.is-invisible-widescreen{visibility:hidden!important}}@media screen and (width>=1216px) and (width<=1407px){.is-visibility-hidden-widescreen-only,.is-invisible-widescreen-only{visibility:hidden!important}}@media screen and (width>=1408px){.is-visibility-hidden-fullhd,.is-invisible-fullhd{visibility:hidden!important}}.is-radiusless{border-radius:0!important}.is-shadowless{box-shadow:none!important}.is-clickable{cursor:pointer!important;pointer-events:all!important}
\ No newline at end of file
diff --git a/test/js/bun/css/files/foundation.css b/test/js/bun/css/files/foundation.css
new file mode 100644
index 0000000000..14d322a5ce
--- /dev/null
+++ b/test/js/bun/css/files/foundation.css
@@ -0,0 +1,6902 @@
+@charset "UTF-8";
+/**
+ * Foundation for Sites
+ * Version 6.9.0
+ * https://get.foundation
+ * Licensed under MIT Open Source
+ */
+@media print, screen and (min-width: 40em) {
+  .reveal.large, .reveal.small, .reveal.tiny, .reveal {
+    right: auto;
+    left: auto;
+    margin: 0 auto;
+  }
+}
+/*! normalize.css v8.0.0 | MIT License | github.com/necolas/normalize.css */
+html {
+  line-height: 1.15;
+  -webkit-text-size-adjust: 100%;
+}
+
+body {
+  margin: 0;
+}
+
+h1 {
+  font-size: 2em;
+  margin: 0.67em 0;
+}
+
+hr {
+  -webkit-box-sizing: content-box;
+          box-sizing: content-box;
+  height: 0;
+  overflow: visible;
+}
+
+pre {
+  font-family: monospace, monospace;
+  font-size: 1em;
+}
+
+a {
+  background-color: transparent;
+}
+
+abbr[title] {
+  border-bottom: 0;
+  -webkit-text-decoration: underline dotted;
+          text-decoration: underline dotted;
+}
+
+b,
+strong {
+  font-weight: bolder;
+}
+
+code,
+kbd,
+samp {
+  font-family: monospace, monospace;
+  font-size: 1em;
+}
+
+small {
+  font-size: 80%;
+}
+
+sub,
+sup {
+  font-size: 75%;
+  line-height: 0;
+  position: relative;
+  vertical-align: baseline;
+}
+
+sub {
+  bottom: -0.25em;
+}
+
+sup {
+  top: -0.5em;
+}
+
+img {
+  border-style: none;
+}
+
+button,
+input,
+optgroup,
+select,
+textarea {
+  font-family: inherit;
+  font-size: 100%;
+  line-height: 1.15;
+  margin: 0;
+}
+
+button,
+input {
+  overflow: visible;
+}
+
+button,
+select {
+  text-transform: none;
+}
+
+button,
+[type=button],
+[type=reset],
+[type=submit] {
+  -webkit-appearance: button;
+}
+
+button::-moz-focus-inner,
+[type=button]::-moz-focus-inner,
+[type=reset]::-moz-focus-inner,
+[type=submit]::-moz-focus-inner {
+  border-style: none;
+  padding: 0;
+}
+
+button:-moz-focusring,
+[type=button]:-moz-focusring,
+[type=reset]:-moz-focusring,
+[type=submit]:-moz-focusring {
+  outline: 1px dotted ButtonText;
+}
+
+fieldset {
+  padding: 0.35em 0.75em 0.625em;
+}
+
+legend {
+  -webkit-box-sizing: border-box;
+          box-sizing: border-box;
+  color: inherit;
+  display: table;
+  max-width: 100%;
+  padding: 0;
+  white-space: normal;
+}
+
+progress {
+  vertical-align: baseline;
+}
+
+textarea {
+  overflow: auto;
+}
+
+[type=checkbox],
+[type=radio] {
+  -webkit-box-sizing: border-box;
+          box-sizing: border-box;
+  padding: 0;
+}
+
+[type=number]::-webkit-inner-spin-button,
+[type=number]::-webkit-outer-spin-button {
+  height: auto;
+}
+
+[type=search] {
+  -webkit-appearance: textfield;
+  outline-offset: -2px;
+}
+
+[type=search]::-webkit-search-decoration {
+  -webkit-appearance: none;
+}
+
+::-webkit-file-upload-button {
+  -webkit-appearance: button;
+  font: inherit;
+}
+
+details {
+  display: block;
+}
+
+summary {
+  display: list-item;
+}
+
+template {
+  display: none;
+}
+
+[hidden] {
+  display: none;
+}
+
+[data-whatintent=mouse] *, [data-whatintent=mouse] *:focus,
+[data-whatintent=touch] *,
+[data-whatintent=touch] *:focus,
+[data-whatinput=mouse] *,
+[data-whatinput=mouse] *:focus,
+[data-whatinput=touch] *,
+[data-whatinput=touch] *:focus {
+  outline: none;
+}
+
+[draggable=false] {
+  -webkit-touch-callout: none;
+  -webkit-user-select: none;
+}
+
+.foundation-mq {
+  font-family: "small=0em&medium=40em&large=64em&xlarge=75em&xxlarge=90em";
+}
+
+html {
+  -webkit-box-sizing: border-box;
+          box-sizing: border-box;
+  font-size: 100%;
+}
+
+*,
+*::before,
+*::after {
+  -webkit-box-sizing: inherit;
+          box-sizing: inherit;
+}
+
+body {
+  margin: 0;
+  padding: 0;
+  background: #fefefe;
+  font-family: "Helvetica Neue", Helvetica, Roboto, Arial, sans-serif;
+  font-weight: normal;
+  line-height: 1.5;
+  color: #0a0a0a;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+img {
+  display: inline-block;
+  vertical-align: middle;
+  max-width: 100%;
+  height: auto;
+  -ms-interpolation-mode: bicubic;
+}
+
+textarea {
+  height: auto;
+  min-height: 50px;
+  border-radius: 0;
+}
+
+select {
+  -webkit-box-sizing: border-box;
+          box-sizing: border-box;
+  width: 100%;
+  border-radius: 0;
+}
+
+.map_canvas img,
+.map_canvas embed,
+.map_canvas object,
+.mqa-display img,
+.mqa-display embed,
+.mqa-display object {
+  max-width: none !important;
+}
+
+button {
+  padding: 0;
+  -webkit-appearance: none;
+     -moz-appearance: none;
+          appearance: none;
+  border: 0;
+  border-radius: 0;
+  background: transparent;
+  line-height: 1;
+  cursor: auto;
+}
+[data-whatinput=mouse] button {
+  outline: 0;
+}
+
+pre {
+  overflow: auto;
+  -webkit-overflow-scrolling: touch;
+}
+
+button,
+input,
+optgroup,
+select,
+textarea {
+  font-family: inherit;
+}
+
+.is-visible {
+  display: block !important;
+}
+
+.is-hidden {
+  display: none !important;
+}
+
+[type=text], [type=password], [type=date], [type=datetime], [type=datetime-local], [type=month], [type=week], [type=email], [type=number], [type=search], [type=tel], [type=time], [type=url], [type=color],
+textarea {
+  -webkit-appearance: none;
+     -moz-appearance: none;
+          appearance: none;
+  display: block;
+  -webkit-box-sizing: border-box;
+          box-sizing: border-box;
+  width: 100%;
+  height: 2.4375rem;
+  margin: 0 0 1rem;
+  padding: 0.5rem;
+  border: 1px solid #cacaca;
+  border-radius: 0;
+  background-color: #fefefe;
+  -webkit-box-shadow: inset 0 1px 2px rgba(10, 10, 10, 0.1);
+          box-shadow: inset 0 1px 2px rgba(10, 10, 10, 0.1);
+  font-family: inherit;
+  font-size: 1rem;
+  font-weight: normal;
+  line-height: 1.5;
+  color: #0a0a0a;
+  -webkit-transition: border-color 0.25s ease-in-out, -webkit-box-shadow 0.5s;
+  transition: border-color 0.25s ease-in-out, -webkit-box-shadow 0.5s;
+  transition: box-shadow 0.5s, border-color 0.25s ease-in-out;
+  transition: box-shadow 0.5s, border-color 0.25s ease-in-out, -webkit-box-shadow 0.5s;
+}
+[type=text]:focus, [type=password]:focus, [type=date]:focus, [type=datetime]:focus, [type=datetime-local]:focus, [type=month]:focus, [type=week]:focus, [type=email]:focus, [type=number]:focus, [type=search]:focus, [type=tel]:focus, [type=time]:focus, [type=url]:focus, [type=color]:focus,
+textarea:focus {
+  outline: none;
+  border: 1px solid #8a8a8a;
+  background-color: #fefefe;
+  -webkit-box-shadow: 0 0 5px #cacaca;
+          box-shadow: 0 0 5px #cacaca;
+  -webkit-transition: border-color 0.25s ease-in-out, -webkit-box-shadow 0.5s;
+  transition: border-color 0.25s ease-in-out, -webkit-box-shadow 0.5s;
+  transition: box-shadow 0.5s, border-color 0.25s ease-in-out;
+  transition: box-shadow 0.5s, border-color 0.25s ease-in-out, -webkit-box-shadow 0.5s;
+}
+
+textarea {
+  max-width: 100%;
+}
+textarea[rows] {
+  height: auto;
+}
+
+input:disabled, input[readonly],
+textarea:disabled,
+textarea[readonly] {
+  background-color: #e6e6e6;
+  cursor: not-allowed;
+}
+
+[type=submit],
+[type=button] {
+  -webkit-appearance: none;
+     -moz-appearance: none;
+          appearance: none;
+  border-radius: 0;
+}
+
+input[type=search] {
+  -webkit-box-sizing: border-box;
+          box-sizing: border-box;
+}
+
+::-webkit-input-placeholder {
+  color: #cacaca;
+}
+
+::-moz-placeholder {
+  color: #cacaca;
+}
+
+:-ms-input-placeholder {
+  color: #cacaca;
+}
+
+::-ms-input-placeholder {
+  color: #cacaca;
+}
+
+::placeholder {
+  color: #cacaca;
+}
+
+[type=file],
+[type=checkbox],
+[type=radio] {
+  margin: 0 0 1rem;
+}
+
+[type=checkbox] + label,
+[type=radio] + label {
+  display: inline-block;
+  vertical-align: baseline;
+  margin-left: 0.5rem;
+  margin-right: 1rem;
+  margin-bottom: 0;
+}
+[type=checkbox] + label[for],
+[type=radio] + label[for] {
+  cursor: pointer;
+}
+
+label > [type=checkbox],
+label > [type=radio] {
+  margin-right: 0.5rem;
+}
+
+[type=file] {
+  width: 100%;
+}
+
+label {
+  display: block;
+  margin: 0;
+  font-size: 0.875rem;
+  font-weight: normal;
+  line-height: 1.8;
+  color: #0a0a0a;
+}
+label.middle {
+  margin: 0 0 1rem;
+  line-height: 1.5;
+  padding: 0.5625rem 0;
+}
+
+.help-text {
+  margin-top: -0.5rem;
+  font-size: 0.8125rem;
+  font-style: italic;
+  color: #0a0a0a;
+}
+
+.input-group {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  width: 100%;
+  margin-bottom: 1rem;
+  -webkit-box-align: stretch;
+      -ms-flex-align: stretch;
+          align-items: stretch;
+}
+.input-group > :first-child, .input-group > :first-child.input-group-button > * {
+  border-radius: 0 0 0 0;
+}
+.input-group > :last-child, .input-group > :last-child.input-group-button > * {
+  border-radius: 0 0 0 0;
+}
+
+.input-group-button a,
+.input-group-button input,
+.input-group-button button,
+.input-group-button label, .input-group-button, .input-group-field, .input-group-label {
+  margin: 0;
+  white-space: nowrap;
+}
+
+.input-group-label {
+  padding: 0 1rem;
+  border: 1px solid #cacaca;
+  background: #e6e6e6;
+  color: #0a0a0a;
+  text-align: center;
+  white-space: nowrap;
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -webkit-box-flex: 0;
+      -ms-flex: 0 0 auto;
+          flex: 0 0 auto;
+  -webkit-box-align: center;
+      -ms-flex-align: center;
+          align-items: center;
+}
+.input-group-label:first-child {
+  border-right: 0;
+}
+.input-group-label:last-child {
+  border-left: 0;
+}
+
+.input-group-field {
+  border-radius: 0;
+  -webkit-box-flex: 1;
+      -ms-flex: 1 1 0px;
+          flex: 1 1 0px;
+  min-width: 0;
+}
+
+.input-group-button {
+  padding-top: 0;
+  padding-bottom: 0;
+  text-align: center;
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -webkit-box-flex: 0;
+      -ms-flex: 0 0 auto;
+          flex: 0 0 auto;
+}
+.input-group-button a,
+.input-group-button input,
+.input-group-button button,
+.input-group-button label {
+  -ms-flex-item-align: stretch;
+      align-self: stretch;
+  height: auto;
+  padding-top: 0;
+  padding-bottom: 0;
+  font-size: 1rem;
+}
+
+fieldset {
+  margin: 0;
+  padding: 0;
+  border: 0;
+}
+
+legend {
+  max-width: 100%;
+  margin-bottom: 0.5rem;
+}
+
+.fieldset {
+  margin: 1.125rem 0;
+  padding: 1.25rem;
+  border: 1px solid #cacaca;
+}
+.fieldset legend {
+  margin: 0;
+  margin-left: -0.1875rem;
+  padding: 0 0.1875rem;
+}
+
+select {
+  height: 2.4375rem;
+  margin: 0 0 1rem;
+  padding: 0.5rem;
+  -webkit-appearance: none;
+     -moz-appearance: none;
+          appearance: none;
+  border: 1px solid #cacaca;
+  border-radius: 0;
+  background-color: #fefefe;
+  font-family: inherit;
+  font-size: 1rem;
+  font-weight: normal;
+  line-height: 1.5;
+  color: #0a0a0a;
+  -webkit-transition: border-color 0.25s ease-in-out, -webkit-box-shadow 0.5s;
+  transition: border-color 0.25s ease-in-out, -webkit-box-shadow 0.5s;
+  transition: box-shadow 0.5s, border-color 0.25s ease-in-out;
+  transition: box-shadow 0.5s, border-color 0.25s ease-in-out, -webkit-box-shadow 0.5s;
+  background-origin: content-box;
+  background-position: right -1rem center;
+  background-repeat: no-repeat;
+  background-size: 9px 6px;
+  padding-right: 1.5rem;
+  background-image: url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg" version="1.1" width="32" height="24" viewBox="0 0 32 24"><polygon points="0,0 32,0 16,24" style="fill: rgb%28138, 138, 138%29"></polygon></svg>');
+}
+/* @zackradisic: purposefully removed this because it's a stupid old IE hack */
+/* @media screen and (min-width: 0\0 ) {
+  select {
+    background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAYCAYAAACbU/80AAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAIpJREFUeNrEkckNgDAMBBfRkEt0ObRBBdsGXUDgmQfK4XhH2m8czQAAy27R3tsw4Qfe2x8uOO6oYLb6GlOor3GF+swURAOmUJ+RwtEJs9WvTGEYxBXqI1MQAZhCfUQKRzDMVj+TwrAIV6jvSUEkYAr1LSkcyTBb/V+KYfX7xAeusq3sLDtGH3kEGACPWIflNZfhRQAAAABJRU5ErkJggg==");
+  }
+} */
+select:focus {
+  outline: none;
+  border: 1px solid #8a8a8a;
+  background-color: #fefefe;
+  -webkit-box-shadow: 0 0 5px #cacaca;
+          box-shadow: 0 0 5px #cacaca;
+  -webkit-transition: border-color 0.25s ease-in-out, -webkit-box-shadow 0.5s;
+  transition: border-color 0.25s ease-in-out, -webkit-box-shadow 0.5s;
+  transition: box-shadow 0.5s, border-color 0.25s ease-in-out;
+  transition: box-shadow 0.5s, border-color 0.25s ease-in-out, -webkit-box-shadow 0.5s;
+}
+select:disabled {
+  background-color: #e6e6e6;
+  cursor: not-allowed;
+}
+select::-ms-expand {
+  display: none;
+}
+select[multiple] {
+  height: auto;
+  background-image: none;
+}
+select:not([multiple]) {
+  padding-top: 0;
+  padding-bottom: 0;
+}
+
+.is-invalid-input:not(:focus) {
+  border-color: #cc4b37;
+  background-color: rgb(249, 236.1, 234.1);
+}
+.is-invalid-input:not(:focus)::-webkit-input-placeholder {
+  color: #cc4b37;
+}
+.is-invalid-input:not(:focus)::-moz-placeholder {
+  color: #cc4b37;
+}
+.is-invalid-input:not(:focus):-ms-input-placeholder {
+  color: #cc4b37;
+}
+.is-invalid-input:not(:focus)::-ms-input-placeholder {
+  color: #cc4b37;
+}
+.is-invalid-input:not(:focus)::placeholder {
+  color: #cc4b37;
+}
+
+.is-invalid-label {
+  color: #cc4b37;
+}
+
+.form-error {
+  display: none;
+  margin-top: -0.5rem;
+  margin-bottom: 1rem;
+  font-size: 0.75rem;
+  font-weight: bold;
+  color: #cc4b37;
+}
+.form-error.is-visible {
+  display: block;
+}
+
+div,
+dl,
+dt,
+dd,
+ul,
+ol,
+li,
+h1,
+h2,
+h3,
+h4,
+h5,
+h6,
+pre,
+form,
+p,
+blockquote,
+th,
+td {
+  margin: 0;
+  padding: 0;
+}
+
+p {
+  margin-bottom: 1rem;
+  font-size: inherit;
+  line-height: 1.6;
+  text-rendering: optimizeLegibility;
+}
+
+em,
+i {
+  font-style: italic;
+  line-height: inherit;
+}
+
+strong,
+b {
+  font-weight: bold;
+  line-height: inherit;
+}
+
+small {
+  font-size: 80%;
+  line-height: inherit;
+}
+
+h1, .h1,
+h2, .h2,
+h3, .h3,
+h4, .h4,
+h5, .h5,
+h6, .h6 {
+  font-family: "Helvetica Neue", Helvetica, Roboto, Arial, sans-serif;
+  font-style: normal;
+  font-weight: normal;
+  color: inherit;
+  text-rendering: optimizeLegibility;
+}
+h1 small, .h1 small,
+h2 small, .h2 small,
+h3 small, .h3 small,
+h4 small, .h4 small,
+h5 small, .h5 small,
+h6 small, .h6 small {
+  line-height: 0;
+  color: #cacaca;
+}
+
+h1, .h1 {
+  font-size: 1.5rem;
+  line-height: 1.4;
+  margin-top: 0;
+  margin-bottom: 0.5rem;
+}
+
+h2, .h2 {
+  font-size: 1.25rem;
+  line-height: 1.4;
+  margin-top: 0;
+  margin-bottom: 0.5rem;
+}
+
+h3, .h3 {
+  font-size: 1.1875rem;
+  line-height: 1.4;
+  margin-top: 0;
+  margin-bottom: 0.5rem;
+}
+
+h4, .h4 {
+  font-size: 1.125rem;
+  line-height: 1.4;
+  margin-top: 0;
+  margin-bottom: 0.5rem;
+}
+
+h5, .h5 {
+  font-size: 1.0625rem;
+  line-height: 1.4;
+  margin-top: 0;
+  margin-bottom: 0.5rem;
+}
+
+h6, .h6 {
+  font-size: 1rem;
+  line-height: 1.4;
+  margin-top: 0;
+  margin-bottom: 0.5rem;
+}
+
+@media print, screen and (min-width: 40em) {
+  h1, .h1 {
+    font-size: 3rem;
+  }
+  h2, .h2 {
+    font-size: 2.5rem;
+  }
+  h3, .h3 {
+    font-size: 1.9375rem;
+  }
+  h4, .h4 {
+    font-size: 1.5625rem;
+  }
+  h5, .h5 {
+    font-size: 1.25rem;
+  }
+  h6, .h6 {
+    font-size: 1rem;
+  }
+}
+a {
+  line-height: inherit;
+  color: #1779ba;
+  text-decoration: none;
+  cursor: pointer;
+}
+a:hover, a:focus {
+  color: rgb(19.78, 104.06, 159.96);
+}
+a img {
+  border: 0;
+}
+
+hr {
+  clear: both;
+  max-width: 75rem;
+  height: 0;
+  margin: 1.25rem auto;
+  border-top: 0;
+  border-right: 0;
+  border-bottom: 1px solid #cacaca;
+  border-left: 0;
+}
+
+ul,
+ol,
+dl {
+  margin-bottom: 1rem;
+  list-style-position: outside;
+  line-height: 1.6;
+}
+
+li {
+  font-size: inherit;
+}
+
+ul {
+  margin-left: 1.25rem;
+  list-style-type: disc;
+}
+
+ol {
+  margin-left: 1.25rem;
+}
+
+ul ul, ul ol, ol ul, ol ol {
+  margin-left: 1.25rem;
+  margin-bottom: 0;
+}
+
+dl {
+  margin-bottom: 1rem;
+}
+dl dt {
+  margin-bottom: 0.3rem;
+  font-weight: bold;
+}
+
+blockquote {
+  margin: 0 0 1rem;
+  padding: 0.5625rem 1.25rem 0 1.1875rem;
+  border-left: 1px solid #cacaca;
+}
+blockquote, blockquote p {
+  line-height: 1.6;
+  color: #8a8a8a;
+}
+
+abbr, abbr[title] {
+  border-bottom: 1px dotted #0a0a0a;
+  cursor: help;
+  text-decoration: none;
+}
+
+figure {
+  margin: 0;
+}
+
+kbd {
+  margin: 0;
+  padding: 0.125rem 0.25rem 0;
+  background-color: #e6e6e6;
+  font-family: Consolas, "Liberation Mono", Courier, monospace;
+  color: #0a0a0a;
+}
+
+.subheader {
+  margin-top: 0.2rem;
+  margin-bottom: 0.5rem;
+  font-weight: normal;
+  line-height: 1.4;
+  color: #8a8a8a;
+}
+
+.lead {
+  font-size: 125%;
+  line-height: 1.6;
+}
+
+.stat {
+  font-size: 2.5rem;
+  line-height: 1;
+}
+p + .stat {
+  margin-top: -1rem;
+}
+
+ul.no-bullet, ol.no-bullet {
+  margin-left: 0;
+  list-style: none;
+}
+
+.cite-block, cite {
+  display: block;
+  color: #8a8a8a;
+  font-size: 0.8125rem;
+}
+.cite-block:before, cite:before {
+  content: "— ";
+}
+
+.code-inline, code {
+  border: 1px solid #cacaca;
+  background-color: #e6e6e6;
+  font-family: Consolas, "Liberation Mono", Courier, monospace;
+  font-weight: normal;
+  color: #0a0a0a;
+  display: inline;
+  max-width: 100%;
+  word-wrap: break-word;
+  padding: 0.125rem 0.3125rem 0.0625rem;
+}
+
+.code-block {
+  border: 1px solid #cacaca;
+  background-color: #e6e6e6;
+  font-family: Consolas, "Liberation Mono", Courier, monospace;
+  font-weight: normal;
+  color: #0a0a0a;
+  display: block;
+  overflow: auto;
+  white-space: pre;
+  padding: 1rem;
+  margin-bottom: 1.5rem;
+}
+
+.text-left {
+  text-align: left;
+}
+
+.text-right {
+  text-align: right;
+}
+
+.text-center {
+  text-align: center;
+}
+
+.text-justify {
+  text-align: justify;
+}
+
+@media print, screen and (min-width: 40em) {
+  .medium-text-left {
+    text-align: left;
+  }
+  .medium-text-right {
+    text-align: right;
+  }
+  .medium-text-center {
+    text-align: center;
+  }
+  .medium-text-justify {
+    text-align: justify;
+  }
+}
+@media print, screen and (min-width: 64em) {
+  .large-text-left {
+    text-align: left;
+  }
+  .large-text-right {
+    text-align: right;
+  }
+  .large-text-center {
+    text-align: center;
+  }
+  .large-text-justify {
+    text-align: justify;
+  }
+}
+.show-for-print {
+  display: none !important;
+}
+
+@media print {
+  * {
+    background: transparent !important;
+    color: black !important;
+    -webkit-print-color-adjust: economy;
+            print-color-adjust: economy;
+    -webkit-box-shadow: none !important;
+            box-shadow: none !important;
+    text-shadow: none !important;
+  }
+  .show-for-print {
+    display: block !important;
+  }
+  .hide-for-print {
+    display: none !important;
+  }
+  table.show-for-print {
+    display: table !important;
+  }
+  thead.show-for-print {
+    display: table-header-group !important;
+  }
+  tbody.show-for-print {
+    display: table-row-group !important;
+  }
+  tr.show-for-print {
+    display: table-row !important;
+  }
+  td.show-for-print {
+    display: table-cell !important;
+  }
+  th.show-for-print {
+    display: table-cell !important;
+  }
+  a,
+  a:visited {
+    text-decoration: underline;
+  }
+  a[href]:after {
+    content: " (" attr(href) ")";
+  }
+  .ir a:after,
+  a[href^="javascript:"]:after,
+  a[href^="#"]:after {
+    content: "";
+  }
+  abbr[title]:after {
+    content: " (" attr(title) ")";
+  }
+  pre,
+  blockquote {
+    border: 1px solid #8a8a8a;
+    page-break-inside: avoid;
+  }
+  thead {
+    display: table-header-group;
+  }
+  tr,
+  img {
+    page-break-inside: avoid;
+  }
+  img {
+    max-width: 100% !important;
+  }
+  @page {
+    margin: 0.5cm;
+  }
+  p,
+  h2,
+  h3 {
+    orphans: 3;
+    widows: 3;
+  }
+  h2,
+  h3 {
+    page-break-after: avoid;
+  }
+  .print-break-inside {
+    page-break-inside: auto;
+  }
+}
+.grid-container {
+  max-width: 75rem;
+  margin-left: auto;
+  margin-right: auto;
+  padding-right: 0.625rem;
+  padding-left: 0.625rem;
+}
+@media print, screen and (min-width: 40em) {
+  .grid-container {
+    padding-right: 0.9375rem;
+    padding-left: 0.9375rem;
+  }
+}
+.grid-container.fluid {
+  max-width: 100%;
+  margin-left: auto;
+  margin-right: auto;
+  padding-right: 0.625rem;
+  padding-left: 0.625rem;
+}
+@media print, screen and (min-width: 40em) {
+  .grid-container.fluid {
+    padding-right: 0.9375rem;
+    padding-left: 0.9375rem;
+  }
+}
+.grid-container.full {
+  max-width: 100%;
+  margin-left: auto;
+  margin-right: auto;
+  padding-right: 0;
+  padding-left: 0;
+}
+
+.grid-x {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -webkit-box-orient: horizontal;
+  -webkit-box-direction: normal;
+      -ms-flex-flow: row wrap;
+          flex-flow: row wrap;
+}
+
+.cell {
+  -webkit-box-flex: 0;
+      -ms-flex: 0 0 auto;
+          flex: 0 0 auto;
+  min-height: 0;
+  min-width: 0;
+  width: 100%;
+}
+.cell.auto {
+  -webkit-box-flex: 1;
+      -ms-flex: 1 1 0px;
+          flex: 1 1 0;
+}
+.cell.shrink {
+  -webkit-box-flex: 0;
+      -ms-flex: 0 0 auto;
+          flex: 0 0 auto;
+}
+
+.grid-x > .auto {
+  width: auto;
+}
+.grid-x > .shrink {
+  width: auto;
+}
+
+.grid-x > .small-shrink, .grid-x > .small-full, .grid-x > .small-1, .grid-x > .small-2, .grid-x > .small-3, .grid-x > .small-4, .grid-x > .small-5, .grid-x > .small-6, .grid-x > .small-7, .grid-x > .small-8, .grid-x > .small-9, .grid-x > .small-10, .grid-x > .small-11, .grid-x > .small-12 {
+  -ms-flex-preferred-size: auto;
+      flex-basis: auto;
+}
+
+@media print, screen and (min-width: 40em) {
+  .grid-x > .medium-shrink, .grid-x > .medium-full, .grid-x > .medium-1, .grid-x > .medium-2, .grid-x > .medium-3, .grid-x > .medium-4, .grid-x > .medium-5, .grid-x > .medium-6, .grid-x > .medium-7, .grid-x > .medium-8, .grid-x > .medium-9, .grid-x > .medium-10, .grid-x > .medium-11, .grid-x > .medium-12 {
+    -ms-flex-preferred-size: auto;
+        flex-basis: auto;
+  }
+}
+@media print, screen and (min-width: 64em) {
+  .grid-x > .large-shrink, .grid-x > .large-full, .grid-x > .large-1, .grid-x > .large-2, .grid-x > .large-3, .grid-x > .large-4, .grid-x > .large-5, .grid-x > .large-6, .grid-x > .large-7, .grid-x > .large-8, .grid-x > .large-9, .grid-x > .large-10, .grid-x > .large-11, .grid-x > .large-12 {
+    -ms-flex-preferred-size: auto;
+        flex-basis: auto;
+  }
+}
+.grid-x > .small-12, .grid-x > .small-11, .grid-x > .small-10, .grid-x > .small-9, .grid-x > .small-8, .grid-x > .small-7, .grid-x > .small-6, .grid-x > .small-5, .grid-x > .small-4, .grid-x > .small-3, .grid-x > .small-2, .grid-x > .small-1 {
+  -webkit-box-flex: 0;
+      -ms-flex: 0 0 auto;
+          flex: 0 0 auto;
+}
+
+.grid-x > .small-1 {
+  width: 8.3333333333%;
+}
+
+.grid-x > .small-2 {
+  width: 16.6666666667%;
+}
+
+.grid-x > .small-3 {
+  width: 25%;
+}
+
+.grid-x > .small-4 {
+  width: 33.3333333333%;
+}
+
+.grid-x > .small-5 {
+  width: 41.6666666667%;
+}
+
+.grid-x > .small-6 {
+  width: 50%;
+}
+
+.grid-x > .small-7 {
+  width: 58.3333333333%;
+}
+
+.grid-x > .small-8 {
+  width: 66.6666666667%;
+}
+
+.grid-x > .small-9 {
+  width: 75%;
+}
+
+.grid-x > .small-10 {
+  width: 83.3333333333%;
+}
+
+.grid-x > .small-11 {
+  width: 91.6666666667%;
+}
+
+.grid-x > .small-12 {
+  width: 100%;
+}
+
+@media print, screen and (min-width: 40em) {
+  .grid-x > .medium-auto {
+    -webkit-box-flex: 1;
+        -ms-flex: 1 1 0px;
+            flex: 1 1 0;
+    width: auto;
+  }
+  .grid-x > .medium-12, .grid-x > .medium-11, .grid-x > .medium-10, .grid-x > .medium-9, .grid-x > .medium-8, .grid-x > .medium-7, .grid-x > .medium-6, .grid-x > .medium-5, .grid-x > .medium-4, .grid-x > .medium-3, .grid-x > .medium-2, .grid-x > .medium-1, .grid-x > .medium-shrink {
+    -webkit-box-flex: 0;
+        -ms-flex: 0 0 auto;
+            flex: 0 0 auto;
+  }
+  .grid-x > .medium-shrink {
+    width: auto;
+  }
+  .grid-x > .medium-1 {
+    width: 8.3333333333%;
+  }
+  .grid-x > .medium-2 {
+    width: 16.6666666667%;
+  }
+  .grid-x > .medium-3 {
+    width: 25%;
+  }
+  .grid-x > .medium-4 {
+    width: 33.3333333333%;
+  }
+  .grid-x > .medium-5 {
+    width: 41.6666666667%;
+  }
+  .grid-x > .medium-6 {
+    width: 50%;
+  }
+  .grid-x > .medium-7 {
+    width: 58.3333333333%;
+  }
+  .grid-x > .medium-8 {
+    width: 66.6666666667%;
+  }
+  .grid-x > .medium-9 {
+    width: 75%;
+  }
+  .grid-x > .medium-10 {
+    width: 83.3333333333%;
+  }
+  .grid-x > .medium-11 {
+    width: 91.6666666667%;
+  }
+  .grid-x > .medium-12 {
+    width: 100%;
+  }
+}
+@media print, screen and (min-width: 64em) {
+  .grid-x > .large-auto {
+    -webkit-box-flex: 1;
+        -ms-flex: 1 1 0px;
+            flex: 1 1 0;
+    width: auto;
+  }
+  .grid-x > .large-12, .grid-x > .large-11, .grid-x > .large-10, .grid-x > .large-9, .grid-x > .large-8, .grid-x > .large-7, .grid-x > .large-6, .grid-x > .large-5, .grid-x > .large-4, .grid-x > .large-3, .grid-x > .large-2, .grid-x > .large-1, .grid-x > .large-shrink {
+    -webkit-box-flex: 0;
+        -ms-flex: 0 0 auto;
+            flex: 0 0 auto;
+  }
+  .grid-x > .large-shrink {
+    width: auto;
+  }
+  .grid-x > .large-1 {
+    width: 8.3333333333%;
+  }
+  .grid-x > .large-2 {
+    width: 16.6666666667%;
+  }
+  .grid-x > .large-3 {
+    width: 25%;
+  }
+  .grid-x > .large-4 {
+    width: 33.3333333333%;
+  }
+  .grid-x > .large-5 {
+    width: 41.6666666667%;
+  }
+  .grid-x > .large-6 {
+    width: 50%;
+  }
+  .grid-x > .large-7 {
+    width: 58.3333333333%;
+  }
+  .grid-x > .large-8 {
+    width: 66.6666666667%;
+  }
+  .grid-x > .large-9 {
+    width: 75%;
+  }
+  .grid-x > .large-10 {
+    width: 83.3333333333%;
+  }
+  .grid-x > .large-11 {
+    width: 91.6666666667%;
+  }
+  .grid-x > .large-12 {
+    width: 100%;
+  }
+}
+.grid-margin-x:not(.grid-x) > .cell {
+  width: auto;
+}
+
+.grid-margin-y:not(.grid-y) > .cell {
+  height: auto;
+}
+
+.grid-margin-x {
+  margin-left: -0.625rem;
+  margin-right: -0.625rem;
+}
+@media print, screen and (min-width: 40em) {
+  .grid-margin-x {
+    margin-left: -0.9375rem;
+    margin-right: -0.9375rem;
+  }
+}
+.grid-margin-x > .cell {
+  width: calc(100% - 1.25rem);
+  margin-left: 0.625rem;
+  margin-right: 0.625rem;
+}
+@media print, screen and (min-width: 40em) {
+  .grid-margin-x > .cell {
+    width: calc(100% - 1.875rem);
+    margin-left: 0.9375rem;
+    margin-right: 0.9375rem;
+  }
+}
+.grid-margin-x > .auto {
+  width: auto;
+}
+.grid-margin-x > .shrink {
+  width: auto;
+}
+.grid-margin-x > .small-1 {
+  width: calc(8.3333333333% - 1.25rem);
+}
+.grid-margin-x > .small-2 {
+  width: calc(16.6666666667% - 1.25rem);
+}
+.grid-margin-x > .small-3 {
+  width: calc(25% - 1.25rem);
+}
+.grid-margin-x > .small-4 {
+  width: calc(33.3333333333% - 1.25rem);
+}
+.grid-margin-x > .small-5 {
+  width: calc(41.6666666667% - 1.25rem);
+}
+.grid-margin-x > .small-6 {
+  width: calc(50% - 1.25rem);
+}
+.grid-margin-x > .small-7 {
+  width: calc(58.3333333333% - 1.25rem);
+}
+.grid-margin-x > .small-8 {
+  width: calc(66.6666666667% - 1.25rem);
+}
+.grid-margin-x > .small-9 {
+  width: calc(75% - 1.25rem);
+}
+.grid-margin-x > .small-10 {
+  width: calc(83.3333333333% - 1.25rem);
+}
+.grid-margin-x > .small-11 {
+  width: calc(91.6666666667% - 1.25rem);
+}
+.grid-margin-x > .small-12 {
+  width: calc(100% - 1.25rem);
+}
+@media print, screen and (min-width: 40em) {
+  .grid-margin-x > .auto {
+    width: auto;
+  }
+  .grid-margin-x > .shrink {
+    width: auto;
+  }
+  .grid-margin-x > .small-1 {
+    width: calc(8.3333333333% - 1.875rem);
+  }
+  .grid-margin-x > .small-2 {
+    width: calc(16.6666666667% - 1.875rem);
+  }
+  .grid-margin-x > .small-3 {
+    width: calc(25% - 1.875rem);
+  }
+  .grid-margin-x > .small-4 {
+    width: calc(33.3333333333% - 1.875rem);
+  }
+  .grid-margin-x > .small-5 {
+    width: calc(41.6666666667% - 1.875rem);
+  }
+  .grid-margin-x > .small-6 {
+    width: calc(50% - 1.875rem);
+  }
+  .grid-margin-x > .small-7 {
+    width: calc(58.3333333333% - 1.875rem);
+  }
+  .grid-margin-x > .small-8 {
+    width: calc(66.6666666667% - 1.875rem);
+  }
+  .grid-margin-x > .small-9 {
+    width: calc(75% - 1.875rem);
+  }
+  .grid-margin-x > .small-10 {
+    width: calc(83.3333333333% - 1.875rem);
+  }
+  .grid-margin-x > .small-11 {
+    width: calc(91.6666666667% - 1.875rem);
+  }
+  .grid-margin-x > .small-12 {
+    width: calc(100% - 1.875rem);
+  }
+  .grid-margin-x > .medium-auto {
+    width: auto;
+  }
+  .grid-margin-x > .medium-shrink {
+    width: auto;
+  }
+  .grid-margin-x > .medium-1 {
+    width: calc(8.3333333333% - 1.875rem);
+  }
+  .grid-margin-x > .medium-2 {
+    width: calc(16.6666666667% - 1.875rem);
+  }
+  .grid-margin-x > .medium-3 {
+    width: calc(25% - 1.875rem);
+  }
+  .grid-margin-x > .medium-4 {
+    width: calc(33.3333333333% - 1.875rem);
+  }
+  .grid-margin-x > .medium-5 {
+    width: calc(41.6666666667% - 1.875rem);
+  }
+  .grid-margin-x > .medium-6 {
+    width: calc(50% - 1.875rem);
+  }
+  .grid-margin-x > .medium-7 {
+    width: calc(58.3333333333% - 1.875rem);
+  }
+  .grid-margin-x > .medium-8 {
+    width: calc(66.6666666667% - 1.875rem);
+  }
+  .grid-margin-x > .medium-9 {
+    width: calc(75% - 1.875rem);
+  }
+  .grid-margin-x > .medium-10 {
+    width: calc(83.3333333333% - 1.875rem);
+  }
+  .grid-margin-x > .medium-11 {
+    width: calc(91.6666666667% - 1.875rem);
+  }
+  .grid-margin-x > .medium-12 {
+    width: calc(100% - 1.875rem);
+  }
+}
+@media print, screen and (min-width: 64em) {
+  .grid-margin-x > .large-auto {
+    width: auto;
+  }
+  .grid-margin-x > .large-shrink {
+    width: auto;
+  }
+  .grid-margin-x > .large-1 {
+    width: calc(8.3333333333% - 1.875rem);
+  }
+  .grid-margin-x > .large-2 {
+    width: calc(16.6666666667% - 1.875rem);
+  }
+  .grid-margin-x > .large-3 {
+    width: calc(25% - 1.875rem);
+  }
+  .grid-margin-x > .large-4 {
+    width: calc(33.3333333333% - 1.875rem);
+  }
+  .grid-margin-x > .large-5 {
+    width: calc(41.6666666667% - 1.875rem);
+  }
+  .grid-margin-x > .large-6 {
+    width: calc(50% - 1.875rem);
+  }
+  .grid-margin-x > .large-7 {
+    width: calc(58.3333333333% - 1.875rem);
+  }
+  .grid-margin-x > .large-8 {
+    width: calc(66.6666666667% - 1.875rem);
+  }
+  .grid-margin-x > .large-9 {
+    width: calc(75% - 1.875rem);
+  }
+  .grid-margin-x > .large-10 {
+    width: calc(83.3333333333% - 1.875rem);
+  }
+  .grid-margin-x > .large-11 {
+    width: calc(91.6666666667% - 1.875rem);
+  }
+  .grid-margin-x > .large-12 {
+    width: calc(100% - 1.875rem);
+  }
+}
+
+.grid-padding-x .grid-padding-x {
+  margin-right: -0.625rem;
+  margin-left: -0.625rem;
+}
+@media print, screen and (min-width: 40em) {
+  .grid-padding-x .grid-padding-x {
+    margin-right: -0.9375rem;
+    margin-left: -0.9375rem;
+  }
+}
+.grid-container:not(.full) > .grid-padding-x {
+  margin-right: -0.625rem;
+  margin-left: -0.625rem;
+}
+@media print, screen and (min-width: 40em) {
+  .grid-container:not(.full) > .grid-padding-x {
+    margin-right: -0.9375rem;
+    margin-left: -0.9375rem;
+  }
+}
+.grid-padding-x > .cell {
+  padding-right: 0.625rem;
+  padding-left: 0.625rem;
+}
+@media print, screen and (min-width: 40em) {
+  .grid-padding-x > .cell {
+    padding-right: 0.9375rem;
+    padding-left: 0.9375rem;
+  }
+}
+
+.small-up-1 > .cell {
+  width: 100%;
+}
+
+.small-up-2 > .cell {
+  width: 50%;
+}
+
+.small-up-3 > .cell {
+  width: 33.3333333333%;
+}
+
+.small-up-4 > .cell {
+  width: 25%;
+}
+
+.small-up-5 > .cell {
+  width: 20%;
+}
+
+.small-up-6 > .cell {
+  width: 16.6666666667%;
+}
+
+.small-up-7 > .cell {
+  width: 14.2857142857%;
+}
+
+.small-up-8 > .cell {
+  width: 12.5%;
+}
+
+@media print, screen and (min-width: 40em) {
+  .medium-up-1 > .cell {
+    width: 100%;
+  }
+  .medium-up-2 > .cell {
+    width: 50%;
+  }
+  .medium-up-3 > .cell {
+    width: 33.3333333333%;
+  }
+  .medium-up-4 > .cell {
+    width: 25%;
+  }
+  .medium-up-5 > .cell {
+    width: 20%;
+  }
+  .medium-up-6 > .cell {
+    width: 16.6666666667%;
+  }
+  .medium-up-7 > .cell {
+    width: 14.2857142857%;
+  }
+  .medium-up-8 > .cell {
+    width: 12.5%;
+  }
+}
+@media print, screen and (min-width: 64em) {
+  .large-up-1 > .cell {
+    width: 100%;
+  }
+  .large-up-2 > .cell {
+    width: 50%;
+  }
+  .large-up-3 > .cell {
+    width: 33.3333333333%;
+  }
+  .large-up-4 > .cell {
+    width: 25%;
+  }
+  .large-up-5 > .cell {
+    width: 20%;
+  }
+  .large-up-6 > .cell {
+    width: 16.6666666667%;
+  }
+  .large-up-7 > .cell {
+    width: 14.2857142857%;
+  }
+  .large-up-8 > .cell {
+    width: 12.5%;
+  }
+}
+.grid-margin-x.small-up-1 > .cell {
+  width: calc(100% - 1.25rem);
+}
+
+.grid-margin-x.small-up-2 > .cell {
+  width: calc(50% - 1.25rem);
+}
+
+.grid-margin-x.small-up-3 > .cell {
+  width: calc(33.3333333333% - 1.25rem);
+}
+
+.grid-margin-x.small-up-4 > .cell {
+  width: calc(25% - 1.25rem);
+}
+
+.grid-margin-x.small-up-5 > .cell {
+  width: calc(20% - 1.25rem);
+}
+
+.grid-margin-x.small-up-6 > .cell {
+  width: calc(16.6666666667% - 1.25rem);
+}
+
+.grid-margin-x.small-up-7 > .cell {
+  width: calc(14.2857142857% - 1.25rem);
+}
+
+.grid-margin-x.small-up-8 > .cell {
+  width: calc(12.5% - 1.25rem);
+}
+
+@media print, screen and (min-width: 40em) {
+  .grid-margin-x.small-up-1 > .cell {
+    width: calc(100% - 1.875rem);
+  }
+  .grid-margin-x.small-up-2 > .cell {
+    width: calc(50% - 1.875rem);
+  }
+  .grid-margin-x.small-up-3 > .cell {
+    width: calc(33.3333333333% - 1.875rem);
+  }
+  .grid-margin-x.small-up-4 > .cell {
+    width: calc(25% - 1.875rem);
+  }
+  .grid-margin-x.small-up-5 > .cell {
+    width: calc(20% - 1.875rem);
+  }
+  .grid-margin-x.small-up-6 > .cell {
+    width: calc(16.6666666667% - 1.875rem);
+  }
+  .grid-margin-x.small-up-7 > .cell {
+    width: calc(14.2857142857% - 1.875rem);
+  }
+  .grid-margin-x.small-up-8 > .cell {
+    width: calc(12.5% - 1.875rem);
+  }
+  .grid-margin-x.medium-up-1 > .cell {
+    width: calc(100% - 1.875rem);
+  }
+  .grid-margin-x.medium-up-2 > .cell {
+    width: calc(50% - 1.875rem);
+  }
+  .grid-margin-x.medium-up-3 > .cell {
+    width: calc(33.3333333333% - 1.875rem);
+  }
+  .grid-margin-x.medium-up-4 > .cell {
+    width: calc(25% - 1.875rem);
+  }
+  .grid-margin-x.medium-up-5 > .cell {
+    width: calc(20% - 1.875rem);
+  }
+  .grid-margin-x.medium-up-6 > .cell {
+    width: calc(16.6666666667% - 1.875rem);
+  }
+  .grid-margin-x.medium-up-7 > .cell {
+    width: calc(14.2857142857% - 1.875rem);
+  }
+  .grid-margin-x.medium-up-8 > .cell {
+    width: calc(12.5% - 1.875rem);
+  }
+}
+@media print, screen and (min-width: 64em) {
+  .grid-margin-x.large-up-1 > .cell {
+    width: calc(100% - 1.875rem);
+  }
+  .grid-margin-x.large-up-2 > .cell {
+    width: calc(50% - 1.875rem);
+  }
+  .grid-margin-x.large-up-3 > .cell {
+    width: calc(33.3333333333% - 1.875rem);
+  }
+  .grid-margin-x.large-up-4 > .cell {
+    width: calc(25% - 1.875rem);
+  }
+  .grid-margin-x.large-up-5 > .cell {
+    width: calc(20% - 1.875rem);
+  }
+  .grid-margin-x.large-up-6 > .cell {
+    width: calc(16.6666666667% - 1.875rem);
+  }
+  .grid-margin-x.large-up-7 > .cell {
+    width: calc(14.2857142857% - 1.875rem);
+  }
+  .grid-margin-x.large-up-8 > .cell {
+    width: calc(12.5% - 1.875rem);
+  }
+}
+.small-margin-collapse {
+  margin-right: 0;
+  margin-left: 0;
+}
+.small-margin-collapse > .cell {
+  margin-right: 0;
+  margin-left: 0;
+}
+.small-margin-collapse > .small-1 {
+  width: 8.3333333333%;
+}
+.small-margin-collapse > .small-2 {
+  width: 16.6666666667%;
+}
+.small-margin-collapse > .small-3 {
+  width: 25%;
+}
+.small-margin-collapse > .small-4 {
+  width: 33.3333333333%;
+}
+.small-margin-collapse > .small-5 {
+  width: 41.6666666667%;
+}
+.small-margin-collapse > .small-6 {
+  width: 50%;
+}
+.small-margin-collapse > .small-7 {
+  width: 58.3333333333%;
+}
+.small-margin-collapse > .small-8 {
+  width: 66.6666666667%;
+}
+.small-margin-collapse > .small-9 {
+  width: 75%;
+}
+.small-margin-collapse > .small-10 {
+  width: 83.3333333333%;
+}
+.small-margin-collapse > .small-11 {
+  width: 91.6666666667%;
+}
+.small-margin-collapse > .small-12 {
+  width: 100%;
+}
+@media print, screen and (min-width: 40em) {
+  .small-margin-collapse > .medium-1 {
+    width: 8.3333333333%;
+  }
+  .small-margin-collapse > .medium-2 {
+    width: 16.6666666667%;
+  }
+  .small-margin-collapse > .medium-3 {
+    width: 25%;
+  }
+  .small-margin-collapse > .medium-4 {
+    width: 33.3333333333%;
+  }
+  .small-margin-collapse > .medium-5 {
+    width: 41.6666666667%;
+  }
+  .small-margin-collapse > .medium-6 {
+    width: 50%;
+  }
+  .small-margin-collapse > .medium-7 {
+    width: 58.3333333333%;
+  }
+  .small-margin-collapse > .medium-8 {
+    width: 66.6666666667%;
+  }
+  .small-margin-collapse > .medium-9 {
+    width: 75%;
+  }
+  .small-margin-collapse > .medium-10 {
+    width: 83.3333333333%;
+  }
+  .small-margin-collapse > .medium-11 {
+    width: 91.6666666667%;
+  }
+  .small-margin-collapse > .medium-12 {
+    width: 100%;
+  }
+}
+@media print, screen and (min-width: 64em) {
+  .small-margin-collapse > .large-1 {
+    width: 8.3333333333%;
+  }
+  .small-margin-collapse > .large-2 {
+    width: 16.6666666667%;
+  }
+  .small-margin-collapse > .large-3 {
+    width: 25%;
+  }
+  .small-margin-collapse > .large-4 {
+    width: 33.3333333333%;
+  }
+  .small-margin-collapse > .large-5 {
+    width: 41.6666666667%;
+  }
+  .small-margin-collapse > .large-6 {
+    width: 50%;
+  }
+  .small-margin-collapse > .large-7 {
+    width: 58.3333333333%;
+  }
+  .small-margin-collapse > .large-8 {
+    width: 66.6666666667%;
+  }
+  .small-margin-collapse > .large-9 {
+    width: 75%;
+  }
+  .small-margin-collapse > .large-10 {
+    width: 83.3333333333%;
+  }
+  .small-margin-collapse > .large-11 {
+    width: 91.6666666667%;
+  }
+  .small-margin-collapse > .large-12 {
+    width: 100%;
+  }
+}
+
+.small-padding-collapse {
+  margin-right: 0;
+  margin-left: 0;
+}
+.small-padding-collapse > .cell {
+  padding-right: 0;
+  padding-left: 0;
+}
+
+@media print, screen and (min-width: 40em) {
+  .medium-margin-collapse {
+    margin-right: 0;
+    margin-left: 0;
+  }
+  .medium-margin-collapse > .cell {
+    margin-right: 0;
+    margin-left: 0;
+  }
+}
+@media print, screen and (min-width: 40em) {
+  .medium-margin-collapse > .small-1 {
+    width: 8.3333333333%;
+  }
+  .medium-margin-collapse > .small-2 {
+    width: 16.6666666667%;
+  }
+  .medium-margin-collapse > .small-3 {
+    width: 25%;
+  }
+  .medium-margin-collapse > .small-4 {
+    width: 33.3333333333%;
+  }
+  .medium-margin-collapse > .small-5 {
+    width: 41.6666666667%;
+  }
+  .medium-margin-collapse > .small-6 {
+    width: 50%;
+  }
+  .medium-margin-collapse > .small-7 {
+    width: 58.3333333333%;
+  }
+  .medium-margin-collapse > .small-8 {
+    width: 66.6666666667%;
+  }
+  .medium-margin-collapse > .small-9 {
+    width: 75%;
+  }
+  .medium-margin-collapse > .small-10 {
+    width: 83.3333333333%;
+  }
+  .medium-margin-collapse > .small-11 {
+    width: 91.6666666667%;
+  }
+  .medium-margin-collapse > .small-12 {
+    width: 100%;
+  }
+}
+@media print, screen and (min-width: 40em) {
+  .medium-margin-collapse > .medium-1 {
+    width: 8.3333333333%;
+  }
+  .medium-margin-collapse > .medium-2 {
+    width: 16.6666666667%;
+  }
+  .medium-margin-collapse > .medium-3 {
+    width: 25%;
+  }
+  .medium-margin-collapse > .medium-4 {
+    width: 33.3333333333%;
+  }
+  .medium-margin-collapse > .medium-5 {
+    width: 41.6666666667%;
+  }
+  .medium-margin-collapse > .medium-6 {
+    width: 50%;
+  }
+  .medium-margin-collapse > .medium-7 {
+    width: 58.3333333333%;
+  }
+  .medium-margin-collapse > .medium-8 {
+    width: 66.6666666667%;
+  }
+  .medium-margin-collapse > .medium-9 {
+    width: 75%;
+  }
+  .medium-margin-collapse > .medium-10 {
+    width: 83.3333333333%;
+  }
+  .medium-margin-collapse > .medium-11 {
+    width: 91.6666666667%;
+  }
+  .medium-margin-collapse > .medium-12 {
+    width: 100%;
+  }
+}
+@media print, screen and (min-width: 64em) {
+  .medium-margin-collapse > .large-1 {
+    width: 8.3333333333%;
+  }
+  .medium-margin-collapse > .large-2 {
+    width: 16.6666666667%;
+  }
+  .medium-margin-collapse > .large-3 {
+    width: 25%;
+  }
+  .medium-margin-collapse > .large-4 {
+    width: 33.3333333333%;
+  }
+  .medium-margin-collapse > .large-5 {
+    width: 41.6666666667%;
+  }
+  .medium-margin-collapse > .large-6 {
+    width: 50%;
+  }
+  .medium-margin-collapse > .large-7 {
+    width: 58.3333333333%;
+  }
+  .medium-margin-collapse > .large-8 {
+    width: 66.6666666667%;
+  }
+  .medium-margin-collapse > .large-9 {
+    width: 75%;
+  }
+  .medium-margin-collapse > .large-10 {
+    width: 83.3333333333%;
+  }
+  .medium-margin-collapse > .large-11 {
+    width: 91.6666666667%;
+  }
+  .medium-margin-collapse > .large-12 {
+    width: 100%;
+  }
+}
+
+@media print, screen and (min-width: 40em) {
+  .medium-padding-collapse {
+    margin-right: 0;
+    margin-left: 0;
+  }
+  .medium-padding-collapse > .cell {
+    padding-right: 0;
+    padding-left: 0;
+  }
+}
+
+@media print, screen and (min-width: 64em) {
+  .large-margin-collapse {
+    margin-right: 0;
+    margin-left: 0;
+  }
+  .large-margin-collapse > .cell {
+    margin-right: 0;
+    margin-left: 0;
+  }
+}
+@media print, screen and (min-width: 64em) {
+  .large-margin-collapse > .small-1 {
+    width: 8.3333333333%;
+  }
+  .large-margin-collapse > .small-2 {
+    width: 16.6666666667%;
+  }
+  .large-margin-collapse > .small-3 {
+    width: 25%;
+  }
+  .large-margin-collapse > .small-4 {
+    width: 33.3333333333%;
+  }
+  .large-margin-collapse > .small-5 {
+    width: 41.6666666667%;
+  }
+  .large-margin-collapse > .small-6 {
+    width: 50%;
+  }
+  .large-margin-collapse > .small-7 {
+    width: 58.3333333333%;
+  }
+  .large-margin-collapse > .small-8 {
+    width: 66.6666666667%;
+  }
+  .large-margin-collapse > .small-9 {
+    width: 75%;
+  }
+  .large-margin-collapse > .small-10 {
+    width: 83.3333333333%;
+  }
+  .large-margin-collapse > .small-11 {
+    width: 91.6666666667%;
+  }
+  .large-margin-collapse > .small-12 {
+    width: 100%;
+  }
+}
+@media print, screen and (min-width: 64em) {
+  .large-margin-collapse > .medium-1 {
+    width: 8.3333333333%;
+  }
+  .large-margin-collapse > .medium-2 {
+    width: 16.6666666667%;
+  }
+  .large-margin-collapse > .medium-3 {
+    width: 25%;
+  }
+  .large-margin-collapse > .medium-4 {
+    width: 33.3333333333%;
+  }
+  .large-margin-collapse > .medium-5 {
+    width: 41.6666666667%;
+  }
+  .large-margin-collapse > .medium-6 {
+    width: 50%;
+  }
+  .large-margin-collapse > .medium-7 {
+    width: 58.3333333333%;
+  }
+  .large-margin-collapse > .medium-8 {
+    width: 66.6666666667%;
+  }
+  .large-margin-collapse > .medium-9 {
+    width: 75%;
+  }
+  .large-margin-collapse > .medium-10 {
+    width: 83.3333333333%;
+  }
+  .large-margin-collapse > .medium-11 {
+    width: 91.6666666667%;
+  }
+  .large-margin-collapse > .medium-12 {
+    width: 100%;
+  }
+}
+@media print, screen and (min-width: 64em) {
+  .large-margin-collapse > .large-1 {
+    width: 8.3333333333%;
+  }
+  .large-margin-collapse > .large-2 {
+    width: 16.6666666667%;
+  }
+  .large-margin-collapse > .large-3 {
+    width: 25%;
+  }
+  .large-margin-collapse > .large-4 {
+    width: 33.3333333333%;
+  }
+  .large-margin-collapse > .large-5 {
+    width: 41.6666666667%;
+  }
+  .large-margin-collapse > .large-6 {
+    width: 50%;
+  }
+  .large-margin-collapse > .large-7 {
+    width: 58.3333333333%;
+  }
+  .large-margin-collapse > .large-8 {
+    width: 66.6666666667%;
+  }
+  .large-margin-collapse > .large-9 {
+    width: 75%;
+  }
+  .large-margin-collapse > .large-10 {
+    width: 83.3333333333%;
+  }
+  .large-margin-collapse > .large-11 {
+    width: 91.6666666667%;
+  }
+  .large-margin-collapse > .large-12 {
+    width: 100%;
+  }
+}
+
+@media print, screen and (min-width: 64em) {
+  .large-padding-collapse {
+    margin-right: 0;
+    margin-left: 0;
+  }
+  .large-padding-collapse > .cell {
+    padding-right: 0;
+    padding-left: 0;
+  }
+}
+
+.small-offset-0 {
+  margin-left: 0%;
+}
+
+.grid-margin-x > .small-offset-0 {
+  margin-left: calc(0% + 1.25rem / 2);
+}
+
+.small-offset-1 {
+  margin-left: 8.3333333333%;
+}
+
+.grid-margin-x > .small-offset-1 {
+  margin-left: calc(8.3333333333% + 1.25rem / 2);
+}
+
+.small-offset-2 {
+  margin-left: 16.6666666667%;
+}
+
+.grid-margin-x > .small-offset-2 {
+  margin-left: calc(16.6666666667% + 1.25rem / 2);
+}
+
+.small-offset-3 {
+  margin-left: 25%;
+}
+
+.grid-margin-x > .small-offset-3 {
+  margin-left: calc(25% + 1.25rem / 2);
+}
+
+.small-offset-4 {
+  margin-left: 33.3333333333%;
+}
+
+.grid-margin-x > .small-offset-4 {
+  margin-left: calc(33.3333333333% + 1.25rem / 2);
+}
+
+.small-offset-5 {
+  margin-left: 41.6666666667%;
+}
+
+.grid-margin-x > .small-offset-5 {
+  margin-left: calc(41.6666666667% + 1.25rem / 2);
+}
+
+.small-offset-6 {
+  margin-left: 50%;
+}
+
+.grid-margin-x > .small-offset-6 {
+  margin-left: calc(50% + 1.25rem / 2);
+}
+
+.small-offset-7 {
+  margin-left: 58.3333333333%;
+}
+
+.grid-margin-x > .small-offset-7 {
+  margin-left: calc(58.3333333333% + 1.25rem / 2);
+}
+
+.small-offset-8 {
+  margin-left: 66.6666666667%;
+}
+
+.grid-margin-x > .small-offset-8 {
+  margin-left: calc(66.6666666667% + 1.25rem / 2);
+}
+
+.small-offset-9 {
+  margin-left: 75%;
+}
+
+.grid-margin-x > .small-offset-9 {
+  margin-left: calc(75% + 1.25rem / 2);
+}
+
+.small-offset-10 {
+  margin-left: 83.3333333333%;
+}
+
+.grid-margin-x > .small-offset-10 {
+  margin-left: calc(83.3333333333% + 1.25rem / 2);
+}
+
+.small-offset-11 {
+  margin-left: 91.6666666667%;
+}
+
+.grid-margin-x > .small-offset-11 {
+  margin-left: calc(91.6666666667% + 1.25rem / 2);
+}
+
+@media print, screen and (min-width: 40em) {
+  .medium-offset-0 {
+    margin-left: 0%;
+  }
+  .grid-margin-x > .medium-offset-0 {
+    margin-left: calc(0% + 1.875rem / 2);
+  }
+  .medium-offset-1 {
+    margin-left: 8.3333333333%;
+  }
+  .grid-margin-x > .medium-offset-1 {
+    margin-left: calc(8.3333333333% + 1.875rem / 2);
+  }
+  .medium-offset-2 {
+    margin-left: 16.6666666667%;
+  }
+  .grid-margin-x > .medium-offset-2 {
+    margin-left: calc(16.6666666667% + 1.875rem / 2);
+  }
+  .medium-offset-3 {
+    margin-left: 25%;
+  }
+  .grid-margin-x > .medium-offset-3 {
+    margin-left: calc(25% + 1.875rem / 2);
+  }
+  .medium-offset-4 {
+    margin-left: 33.3333333333%;
+  }
+  .grid-margin-x > .medium-offset-4 {
+    margin-left: calc(33.3333333333% + 1.875rem / 2);
+  }
+  .medium-offset-5 {
+    margin-left: 41.6666666667%;
+  }
+  .grid-margin-x > .medium-offset-5 {
+    margin-left: calc(41.6666666667% + 1.875rem / 2);
+  }
+  .medium-offset-6 {
+    margin-left: 50%;
+  }
+  .grid-margin-x > .medium-offset-6 {
+    margin-left: calc(50% + 1.875rem / 2);
+  }
+  .medium-offset-7 {
+    margin-left: 58.3333333333%;
+  }
+  .grid-margin-x > .medium-offset-7 {
+    margin-left: calc(58.3333333333% + 1.875rem / 2);
+  }
+  .medium-offset-8 {
+    margin-left: 66.6666666667%;
+  }
+  .grid-margin-x > .medium-offset-8 {
+    margin-left: calc(66.6666666667% + 1.875rem / 2);
+  }
+  .medium-offset-9 {
+    margin-left: 75%;
+  }
+  .grid-margin-x > .medium-offset-9 {
+    margin-left: calc(75% + 1.875rem / 2);
+  }
+  .medium-offset-10 {
+    margin-left: 83.3333333333%;
+  }
+  .grid-margin-x > .medium-offset-10 {
+    margin-left: calc(83.3333333333% + 1.875rem / 2);
+  }
+  .medium-offset-11 {
+    margin-left: 91.6666666667%;
+  }
+  .grid-margin-x > .medium-offset-11 {
+    margin-left: calc(91.6666666667% + 1.875rem / 2);
+  }
+}
+@media print, screen and (min-width: 64em) {
+  .large-offset-0 {
+    margin-left: 0%;
+  }
+  .grid-margin-x > .large-offset-0 {
+    margin-left: calc(0% + 1.875rem / 2);
+  }
+  .large-offset-1 {
+    margin-left: 8.3333333333%;
+  }
+  .grid-margin-x > .large-offset-1 {
+    margin-left: calc(8.3333333333% + 1.875rem / 2);
+  }
+  .large-offset-2 {
+    margin-left: 16.6666666667%;
+  }
+  .grid-margin-x > .large-offset-2 {
+    margin-left: calc(16.6666666667% + 1.875rem / 2);
+  }
+  .large-offset-3 {
+    margin-left: 25%;
+  }
+  .grid-margin-x > .large-offset-3 {
+    margin-left: calc(25% + 1.875rem / 2);
+  }
+  .large-offset-4 {
+    margin-left: 33.3333333333%;
+  }
+  .grid-margin-x > .large-offset-4 {
+    margin-left: calc(33.3333333333% + 1.875rem / 2);
+  }
+  .large-offset-5 {
+    margin-left: 41.6666666667%;
+  }
+  .grid-margin-x > .large-offset-5 {
+    margin-left: calc(41.6666666667% + 1.875rem / 2);
+  }
+  .large-offset-6 {
+    margin-left: 50%;
+  }
+  .grid-margin-x > .large-offset-6 {
+    margin-left: calc(50% + 1.875rem / 2);
+  }
+  .large-offset-7 {
+    margin-left: 58.3333333333%;
+  }
+  .grid-margin-x > .large-offset-7 {
+    margin-left: calc(58.3333333333% + 1.875rem / 2);
+  }
+  .large-offset-8 {
+    margin-left: 66.6666666667%;
+  }
+  .grid-margin-x > .large-offset-8 {
+    margin-left: calc(66.6666666667% + 1.875rem / 2);
+  }
+  .large-offset-9 {
+    margin-left: 75%;
+  }
+  .grid-margin-x > .large-offset-9 {
+    margin-left: calc(75% + 1.875rem / 2);
+  }
+  .large-offset-10 {
+    margin-left: 83.3333333333%;
+  }
+  .grid-margin-x > .large-offset-10 {
+    margin-left: calc(83.3333333333% + 1.875rem / 2);
+  }
+  .large-offset-11 {
+    margin-left: 91.6666666667%;
+  }
+  .grid-margin-x > .large-offset-11 {
+    margin-left: calc(91.6666666667% + 1.875rem / 2);
+  }
+}
+.grid-y {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -webkit-box-orient: vertical;
+  -webkit-box-direction: normal;
+      -ms-flex-flow: column nowrap;
+          flex-flow: column nowrap;
+}
+.grid-y > .cell {
+  height: auto;
+  max-height: none;
+}
+.grid-y > .auto {
+  height: auto;
+}
+.grid-y > .shrink {
+  height: auto;
+}
+.grid-y > .small-shrink, .grid-y > .small-full, .grid-y > .small-1, .grid-y > .small-2, .grid-y > .small-3, .grid-y > .small-4, .grid-y > .small-5, .grid-y > .small-6, .grid-y > .small-7, .grid-y > .small-8, .grid-y > .small-9, .grid-y > .small-10, .grid-y > .small-11, .grid-y > .small-12 {
+  -ms-flex-preferred-size: auto;
+      flex-basis: auto;
+}
+@media print, screen and (min-width: 40em) {
+  .grid-y > .medium-shrink, .grid-y > .medium-full, .grid-y > .medium-1, .grid-y > .medium-2, .grid-y > .medium-3, .grid-y > .medium-4, .grid-y > .medium-5, .grid-y > .medium-6, .grid-y > .medium-7, .grid-y > .medium-8, .grid-y > .medium-9, .grid-y > .medium-10, .grid-y > .medium-11, .grid-y > .medium-12 {
+    -ms-flex-preferred-size: auto;
+        flex-basis: auto;
+  }
+}
+@media print, screen and (min-width: 64em) {
+  .grid-y > .large-shrink, .grid-y > .large-full, .grid-y > .large-1, .grid-y > .large-2, .grid-y > .large-3, .grid-y > .large-4, .grid-y > .large-5, .grid-y > .large-6, .grid-y > .large-7, .grid-y > .large-8, .grid-y > .large-9, .grid-y > .large-10, .grid-y > .large-11, .grid-y > .large-12 {
+    -ms-flex-preferred-size: auto;
+        flex-basis: auto;
+  }
+}
+.grid-y > .small-12, .grid-y > .small-11, .grid-y > .small-10, .grid-y > .small-9, .grid-y > .small-8, .grid-y > .small-7, .grid-y > .small-6, .grid-y > .small-5, .grid-y > .small-4, .grid-y > .small-3, .grid-y > .small-2, .grid-y > .small-1 {
+  -webkit-box-flex: 0;
+      -ms-flex: 0 0 auto;
+          flex: 0 0 auto;
+}
+.grid-y > .small-1 {
+  height: 8.3333333333%;
+}
+.grid-y > .small-2 {
+  height: 16.6666666667%;
+}
+.grid-y > .small-3 {
+  height: 25%;
+}
+.grid-y > .small-4 {
+  height: 33.3333333333%;
+}
+.grid-y > .small-5 {
+  height: 41.6666666667%;
+}
+.grid-y > .small-6 {
+  height: 50%;
+}
+.grid-y > .small-7 {
+  height: 58.3333333333%;
+}
+.grid-y > .small-8 {
+  height: 66.6666666667%;
+}
+.grid-y > .small-9 {
+  height: 75%;
+}
+.grid-y > .small-10 {
+  height: 83.3333333333%;
+}
+.grid-y > .small-11 {
+  height: 91.6666666667%;
+}
+.grid-y > .small-12 {
+  height: 100%;
+}
+@media print, screen and (min-width: 40em) {
+  .grid-y > .medium-auto {
+    -webkit-box-flex: 1;
+        -ms-flex: 1 1 0px;
+            flex: 1 1 0;
+    height: auto;
+  }
+  .grid-y > .medium-12, .grid-y > .medium-11, .grid-y > .medium-10, .grid-y > .medium-9, .grid-y > .medium-8, .grid-y > .medium-7, .grid-y > .medium-6, .grid-y > .medium-5, .grid-y > .medium-4, .grid-y > .medium-3, .grid-y > .medium-2, .grid-y > .medium-1, .grid-y > .medium-shrink {
+    -webkit-box-flex: 0;
+        -ms-flex: 0 0 auto;
+            flex: 0 0 auto;
+  }
+  .grid-y > .medium-shrink {
+    height: auto;
+  }
+  .grid-y > .medium-1 {
+    height: 8.3333333333%;
+  }
+  .grid-y > .medium-2 {
+    height: 16.6666666667%;
+  }
+  .grid-y > .medium-3 {
+    height: 25%;
+  }
+  .grid-y > .medium-4 {
+    height: 33.3333333333%;
+  }
+  .grid-y > .medium-5 {
+    height: 41.6666666667%;
+  }
+  .grid-y > .medium-6 {
+    height: 50%;
+  }
+  .grid-y > .medium-7 {
+    height: 58.3333333333%;
+  }
+  .grid-y > .medium-8 {
+    height: 66.6666666667%;
+  }
+  .grid-y > .medium-9 {
+    height: 75%;
+  }
+  .grid-y > .medium-10 {
+    height: 83.3333333333%;
+  }
+  .grid-y > .medium-11 {
+    height: 91.6666666667%;
+  }
+  .grid-y > .medium-12 {
+    height: 100%;
+  }
+}
+@media print, screen and (min-width: 64em) {
+  .grid-y > .large-auto {
+    -webkit-box-flex: 1;
+        -ms-flex: 1 1 0px;
+            flex: 1 1 0;
+    height: auto;
+  }
+  .grid-y > .large-12, .grid-y > .large-11, .grid-y > .large-10, .grid-y > .large-9, .grid-y > .large-8, .grid-y > .large-7, .grid-y > .large-6, .grid-y > .large-5, .grid-y > .large-4, .grid-y > .large-3, .grid-y > .large-2, .grid-y > .large-1, .grid-y > .large-shrink {
+    -webkit-box-flex: 0;
+        -ms-flex: 0 0 auto;
+            flex: 0 0 auto;
+  }
+  .grid-y > .large-shrink {
+    height: auto;
+  }
+  .grid-y > .large-1 {
+    height: 8.3333333333%;
+  }
+  .grid-y > .large-2 {
+    height: 16.6666666667%;
+  }
+  .grid-y > .large-3 {
+    height: 25%;
+  }
+  .grid-y > .large-4 {
+    height: 33.3333333333%;
+  }
+  .grid-y > .large-5 {
+    height: 41.6666666667%;
+  }
+  .grid-y > .large-6 {
+    height: 50%;
+  }
+  .grid-y > .large-7 {
+    height: 58.3333333333%;
+  }
+  .grid-y > .large-8 {
+    height: 66.6666666667%;
+  }
+  .grid-y > .large-9 {
+    height: 75%;
+  }
+  .grid-y > .large-10 {
+    height: 83.3333333333%;
+  }
+  .grid-y > .large-11 {
+    height: 91.6666666667%;
+  }
+  .grid-y > .large-12 {
+    height: 100%;
+  }
+}
+
+.grid-padding-y .grid-padding-y {
+  margin-top: -0.625rem;
+  margin-bottom: -0.625rem;
+}
+@media print, screen and (min-width: 40em) {
+  .grid-padding-y .grid-padding-y {
+    margin-top: -0.9375rem;
+    margin-bottom: -0.9375rem;
+  }
+}
+.grid-padding-y > .cell {
+  padding-top: 0.625rem;
+  padding-bottom: 0.625rem;
+}
+@media print, screen and (min-width: 40em) {
+  .grid-padding-y > .cell {
+    padding-top: 0.9375rem;
+    padding-bottom: 0.9375rem;
+  }
+}
+
+.grid-margin-y {
+  margin-top: -0.625rem;
+  margin-bottom: -0.625rem;
+}
+@media print, screen and (min-width: 40em) {
+  .grid-margin-y {
+    margin-top: -0.9375rem;
+    margin-bottom: -0.9375rem;
+  }
+}
+.grid-margin-y > .cell {
+  height: calc(100% - 1.25rem);
+  margin-top: 0.625rem;
+  margin-bottom: 0.625rem;
+}
+@media print, screen and (min-width: 40em) {
+  .grid-margin-y > .cell {
+    height: calc(100% - 1.875rem);
+    margin-top: 0.9375rem;
+    margin-bottom: 0.9375rem;
+  }
+}
+.grid-margin-y > .auto {
+  height: auto;
+}
+.grid-margin-y > .shrink {
+  height: auto;
+}
+.grid-margin-y > .small-1 {
+  height: calc(8.3333333333% - 1.25rem);
+}
+.grid-margin-y > .small-2 {
+  height: calc(16.6666666667% - 1.25rem);
+}
+.grid-margin-y > .small-3 {
+  height: calc(25% - 1.25rem);
+}
+.grid-margin-y > .small-4 {
+  height: calc(33.3333333333% - 1.25rem);
+}
+.grid-margin-y > .small-5 {
+  height: calc(41.6666666667% - 1.25rem);
+}
+.grid-margin-y > .small-6 {
+  height: calc(50% - 1.25rem);
+}
+.grid-margin-y > .small-7 {
+  height: calc(58.3333333333% - 1.25rem);
+}
+.grid-margin-y > .small-8 {
+  height: calc(66.6666666667% - 1.25rem);
+}
+.grid-margin-y > .small-9 {
+  height: calc(75% - 1.25rem);
+}
+.grid-margin-y > .small-10 {
+  height: calc(83.3333333333% - 1.25rem);
+}
+.grid-margin-y > .small-11 {
+  height: calc(91.6666666667% - 1.25rem);
+}
+.grid-margin-y > .small-12 {
+  height: calc(100% - 1.25rem);
+}
+@media print, screen and (min-width: 40em) {
+  .grid-margin-y > .auto {
+    height: auto;
+  }
+  .grid-margin-y > .shrink {
+    height: auto;
+  }
+  .grid-margin-y > .small-1 {
+    height: calc(8.3333333333% - 1.875rem);
+  }
+  .grid-margin-y > .small-2 {
+    height: calc(16.6666666667% - 1.875rem);
+  }
+  .grid-margin-y > .small-3 {
+    height: calc(25% - 1.875rem);
+  }
+  .grid-margin-y > .small-4 {
+    height: calc(33.3333333333% - 1.875rem);
+  }
+  .grid-margin-y > .small-5 {
+    height: calc(41.6666666667% - 1.875rem);
+  }
+  .grid-margin-y > .small-6 {
+    height: calc(50% - 1.875rem);
+  }
+  .grid-margin-y > .small-7 {
+    height: calc(58.3333333333% - 1.875rem);
+  }
+  .grid-margin-y > .small-8 {
+    height: calc(66.6666666667% - 1.875rem);
+  }
+  .grid-margin-y > .small-9 {
+    height: calc(75% - 1.875rem);
+  }
+  .grid-margin-y > .small-10 {
+    height: calc(83.3333333333% - 1.875rem);
+  }
+  .grid-margin-y > .small-11 {
+    height: calc(91.6666666667% - 1.875rem);
+  }
+  .grid-margin-y > .small-12 {
+    height: calc(100% - 1.875rem);
+  }
+  .grid-margin-y > .medium-auto {
+    height: auto;
+  }
+  .grid-margin-y > .medium-shrink {
+    height: auto;
+  }
+  .grid-margin-y > .medium-1 {
+    height: calc(8.3333333333% - 1.875rem);
+  }
+  .grid-margin-y > .medium-2 {
+    height: calc(16.6666666667% - 1.875rem);
+  }
+  .grid-margin-y > .medium-3 {
+    height: calc(25% - 1.875rem);
+  }
+  .grid-margin-y > .medium-4 {
+    height: calc(33.3333333333% - 1.875rem);
+  }
+  .grid-margin-y > .medium-5 {
+    height: calc(41.6666666667% - 1.875rem);
+  }
+  .grid-margin-y > .medium-6 {
+    height: calc(50% - 1.875rem);
+  }
+  .grid-margin-y > .medium-7 {
+    height: calc(58.3333333333% - 1.875rem);
+  }
+  .grid-margin-y > .medium-8 {
+    height: calc(66.6666666667% - 1.875rem);
+  }
+  .grid-margin-y > .medium-9 {
+    height: calc(75% - 1.875rem);
+  }
+  .grid-margin-y > .medium-10 {
+    height: calc(83.3333333333% - 1.875rem);
+  }
+  .grid-margin-y > .medium-11 {
+    height: calc(91.6666666667% - 1.875rem);
+  }
+  .grid-margin-y > .medium-12 {
+    height: calc(100% - 1.875rem);
+  }
+}
+@media print, screen and (min-width: 64em) {
+  .grid-margin-y > .large-auto {
+    height: auto;
+  }
+  .grid-margin-y > .large-shrink {
+    height: auto;
+  }
+  .grid-margin-y > .large-1 {
+    height: calc(8.3333333333% - 1.875rem);
+  }
+  .grid-margin-y > .large-2 {
+    height: calc(16.6666666667% - 1.875rem);
+  }
+  .grid-margin-y > .large-3 {
+    height: calc(25% - 1.875rem);
+  }
+  .grid-margin-y > .large-4 {
+    height: calc(33.3333333333% - 1.875rem);
+  }
+  .grid-margin-y > .large-5 {
+    height: calc(41.6666666667% - 1.875rem);
+  }
+  .grid-margin-y > .large-6 {
+    height: calc(50% - 1.875rem);
+  }
+  .grid-margin-y > .large-7 {
+    height: calc(58.3333333333% - 1.875rem);
+  }
+  .grid-margin-y > .large-8 {
+    height: calc(66.6666666667% - 1.875rem);
+  }
+  .grid-margin-y > .large-9 {
+    height: calc(75% - 1.875rem);
+  }
+  .grid-margin-y > .large-10 {
+    height: calc(83.3333333333% - 1.875rem);
+  }
+  .grid-margin-y > .large-11 {
+    height: calc(91.6666666667% - 1.875rem);
+  }
+  .grid-margin-y > .large-12 {
+    height: calc(100% - 1.875rem);
+  }
+}
+
+.grid-frame {
+  overflow: hidden;
+  position: relative;
+  -ms-flex-wrap: nowrap;
+      flex-wrap: nowrap;
+  -webkit-box-align: stretch;
+      -ms-flex-align: stretch;
+          align-items: stretch;
+  width: 100vw;
+}
+
+.cell .grid-frame {
+  width: 100%;
+}
+
+.cell-block {
+  overflow-x: auto;
+  max-width: 100%;
+  -webkit-overflow-scrolling: touch;
+  -ms-overflow-style: -ms-autohiding-scrollbar;
+}
+
+.cell-block-y {
+  overflow-y: auto;
+  max-height: 100%;
+  min-height: 100%;
+  -webkit-overflow-scrolling: touch;
+  -ms-overflow-style: -ms-autohiding-scrollbar;
+}
+
+.cell-block-container {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -webkit-box-orient: vertical;
+  -webkit-box-direction: normal;
+      -ms-flex-direction: column;
+          flex-direction: column;
+  max-height: 100%;
+}
+.cell-block-container > .grid-x {
+  max-height: 100%;
+  -ms-flex-wrap: nowrap;
+      flex-wrap: nowrap;
+}
+
+@media print, screen and (min-width: 40em) {
+  .medium-grid-frame {
+    overflow: hidden;
+    position: relative;
+    -ms-flex-wrap: nowrap;
+        flex-wrap: nowrap;
+    -webkit-box-align: stretch;
+        -ms-flex-align: stretch;
+            align-items: stretch;
+    width: 100vw;
+  }
+  .cell .medium-grid-frame {
+    width: 100%;
+  }
+  .medium-cell-block {
+    overflow-x: auto;
+    max-width: 100%;
+    -webkit-overflow-scrolling: touch;
+    -ms-overflow-style: -ms-autohiding-scrollbar;
+  }
+  .medium-cell-block-container {
+    display: -webkit-box;
+    display: -ms-flexbox;
+    display: flex;
+    -webkit-box-orient: vertical;
+    -webkit-box-direction: normal;
+        -ms-flex-direction: column;
+            flex-direction: column;
+    max-height: 100%;
+  }
+  .medium-cell-block-container > .grid-x {
+    max-height: 100%;
+    -ms-flex-wrap: nowrap;
+        flex-wrap: nowrap;
+  }
+  .medium-cell-block-y {
+    overflow-y: auto;
+    max-height: 100%;
+    min-height: 100%;
+    -webkit-overflow-scrolling: touch;
+    -ms-overflow-style: -ms-autohiding-scrollbar;
+  }
+}
+@media print, screen and (min-width: 64em) {
+  .large-grid-frame {
+    overflow: hidden;
+    position: relative;
+    -ms-flex-wrap: nowrap;
+        flex-wrap: nowrap;
+    -webkit-box-align: stretch;
+        -ms-flex-align: stretch;
+            align-items: stretch;
+    width: 100vw;
+  }
+  .cell .large-grid-frame {
+    width: 100%;
+  }
+  .large-cell-block {
+    overflow-x: auto;
+    max-width: 100%;
+    -webkit-overflow-scrolling: touch;
+    -ms-overflow-style: -ms-autohiding-scrollbar;
+  }
+  .large-cell-block-container {
+    display: -webkit-box;
+    display: -ms-flexbox;
+    display: flex;
+    -webkit-box-orient: vertical;
+    -webkit-box-direction: normal;
+        -ms-flex-direction: column;
+            flex-direction: column;
+    max-height: 100%;
+  }
+  .large-cell-block-container > .grid-x {
+    max-height: 100%;
+    -ms-flex-wrap: nowrap;
+        flex-wrap: nowrap;
+  }
+  .large-cell-block-y {
+    overflow-y: auto;
+    max-height: 100%;
+    min-height: 100%;
+    -webkit-overflow-scrolling: touch;
+    -ms-overflow-style: -ms-autohiding-scrollbar;
+  }
+}
+.grid-y.grid-frame {
+  overflow: hidden;
+  position: relative;
+  -ms-flex-wrap: nowrap;
+      flex-wrap: nowrap;
+  -webkit-box-align: stretch;
+      -ms-flex-align: stretch;
+          align-items: stretch;
+  height: 100vh;
+  width: auto;
+}
+@media print, screen and (min-width: 40em) {
+  .grid-y.medium-grid-frame {
+    overflow: hidden;
+    position: relative;
+    -ms-flex-wrap: nowrap;
+        flex-wrap: nowrap;
+    -webkit-box-align: stretch;
+        -ms-flex-align: stretch;
+            align-items: stretch;
+    height: 100vh;
+    width: auto;
+  }
+}
+@media print, screen and (min-width: 64em) {
+  .grid-y.large-grid-frame {
+    overflow: hidden;
+    position: relative;
+    -ms-flex-wrap: nowrap;
+        flex-wrap: nowrap;
+    -webkit-box-align: stretch;
+        -ms-flex-align: stretch;
+            align-items: stretch;
+    height: 100vh;
+    width: auto;
+  }
+}
+
+.cell .grid-y.grid-frame {
+  height: 100%;
+}
+@media print, screen and (min-width: 40em) {
+  .cell .grid-y.medium-grid-frame {
+    height: 100%;
+  }
+}
+@media print, screen and (min-width: 64em) {
+  .cell .grid-y.large-grid-frame {
+    height: 100%;
+  }
+}
+
+.grid-margin-y {
+  margin-top: -0.625rem;
+  margin-bottom: -0.625rem;
+}
+@media print, screen and (min-width: 40em) {
+  .grid-margin-y {
+    margin-top: -0.9375rem;
+    margin-bottom: -0.9375rem;
+  }
+}
+.grid-margin-y > .cell {
+  height: calc(100% - 1.25rem);
+  margin-top: 0.625rem;
+  margin-bottom: 0.625rem;
+}
+@media print, screen and (min-width: 40em) {
+  .grid-margin-y > .cell {
+    height: calc(100% - 1.875rem);
+    margin-top: 0.9375rem;
+    margin-bottom: 0.9375rem;
+  }
+}
+.grid-margin-y > .auto {
+  height: auto;
+}
+.grid-margin-y > .shrink {
+  height: auto;
+}
+.grid-margin-y > .small-1 {
+  height: calc(8.3333333333% - 1.25rem);
+}
+.grid-margin-y > .small-2 {
+  height: calc(16.6666666667% - 1.25rem);
+}
+.grid-margin-y > .small-3 {
+  height: calc(25% - 1.25rem);
+}
+.grid-margin-y > .small-4 {
+  height: calc(33.3333333333% - 1.25rem);
+}
+.grid-margin-y > .small-5 {
+  height: calc(41.6666666667% - 1.25rem);
+}
+.grid-margin-y > .small-6 {
+  height: calc(50% - 1.25rem);
+}
+.grid-margin-y > .small-7 {
+  height: calc(58.3333333333% - 1.25rem);
+}
+.grid-margin-y > .small-8 {
+  height: calc(66.6666666667% - 1.25rem);
+}
+.grid-margin-y > .small-9 {
+  height: calc(75% - 1.25rem);
+}
+.grid-margin-y > .small-10 {
+  height: calc(83.3333333333% - 1.25rem);
+}
+.grid-margin-y > .small-11 {
+  height: calc(91.6666666667% - 1.25rem);
+}
+.grid-margin-y > .small-12 {
+  height: calc(100% - 1.25rem);
+}
+@media print, screen and (min-width: 40em) {
+  .grid-margin-y > .auto {
+    height: auto;
+  }
+  .grid-margin-y > .shrink {
+    height: auto;
+  }
+  .grid-margin-y > .small-1 {
+    height: calc(8.3333333333% - 1.875rem);
+  }
+  .grid-margin-y > .small-2 {
+    height: calc(16.6666666667% - 1.875rem);
+  }
+  .grid-margin-y > .small-3 {
+    height: calc(25% - 1.875rem);
+  }
+  .grid-margin-y > .small-4 {
+    height: calc(33.3333333333% - 1.875rem);
+  }
+  .grid-margin-y > .small-5 {
+    height: calc(41.6666666667% - 1.875rem);
+  }
+  .grid-margin-y > .small-6 {
+    height: calc(50% - 1.875rem);
+  }
+  .grid-margin-y > .small-7 {
+    height: calc(58.3333333333% - 1.875rem);
+  }
+  .grid-margin-y > .small-8 {
+    height: calc(66.6666666667% - 1.875rem);
+  }
+  .grid-margin-y > .small-9 {
+    height: calc(75% - 1.875rem);
+  }
+  .grid-margin-y > .small-10 {
+    height: calc(83.3333333333% - 1.875rem);
+  }
+  .grid-margin-y > .small-11 {
+    height: calc(91.6666666667% - 1.875rem);
+  }
+  .grid-margin-y > .small-12 {
+    height: calc(100% - 1.875rem);
+  }
+  .grid-margin-y > .medium-auto {
+    height: auto;
+  }
+  .grid-margin-y > .medium-shrink {
+    height: auto;
+  }
+  .grid-margin-y > .medium-1 {
+    height: calc(8.3333333333% - 1.875rem);
+  }
+  .grid-margin-y > .medium-2 {
+    height: calc(16.6666666667% - 1.875rem);
+  }
+  .grid-margin-y > .medium-3 {
+    height: calc(25% - 1.875rem);
+  }
+  .grid-margin-y > .medium-4 {
+    height: calc(33.3333333333% - 1.875rem);
+  }
+  .grid-margin-y > .medium-5 {
+    height: calc(41.6666666667% - 1.875rem);
+  }
+  .grid-margin-y > .medium-6 {
+    height: calc(50% - 1.875rem);
+  }
+  .grid-margin-y > .medium-7 {
+    height: calc(58.3333333333% - 1.875rem);
+  }
+  .grid-margin-y > .medium-8 {
+    height: calc(66.6666666667% - 1.875rem);
+  }
+  .grid-margin-y > .medium-9 {
+    height: calc(75% - 1.875rem);
+  }
+  .grid-margin-y > .medium-10 {
+    height: calc(83.3333333333% - 1.875rem);
+  }
+  .grid-margin-y > .medium-11 {
+    height: calc(91.6666666667% - 1.875rem);
+  }
+  .grid-margin-y > .medium-12 {
+    height: calc(100% - 1.875rem);
+  }
+}
+@media print, screen and (min-width: 64em) {
+  .grid-margin-y > .large-auto {
+    height: auto;
+  }
+  .grid-margin-y > .large-shrink {
+    height: auto;
+  }
+  .grid-margin-y > .large-1 {
+    height: calc(8.3333333333% - 1.875rem);
+  }
+  .grid-margin-y > .large-2 {
+    height: calc(16.6666666667% - 1.875rem);
+  }
+  .grid-margin-y > .large-3 {
+    height: calc(25% - 1.875rem);
+  }
+  .grid-margin-y > .large-4 {
+    height: calc(33.3333333333% - 1.875rem);
+  }
+  .grid-margin-y > .large-5 {
+    height: calc(41.6666666667% - 1.875rem);
+  }
+  .grid-margin-y > .large-6 {
+    height: calc(50% - 1.875rem);
+  }
+  .grid-margin-y > .large-7 {
+    height: calc(58.3333333333% - 1.875rem);
+  }
+  .grid-margin-y > .large-8 {
+    height: calc(66.6666666667% - 1.875rem);
+  }
+  .grid-margin-y > .large-9 {
+    height: calc(75% - 1.875rem);
+  }
+  .grid-margin-y > .large-10 {
+    height: calc(83.3333333333% - 1.875rem);
+  }
+  .grid-margin-y > .large-11 {
+    height: calc(91.6666666667% - 1.875rem);
+  }
+  .grid-margin-y > .large-12 {
+    height: calc(100% - 1.875rem);
+  }
+}
+
+.grid-frame.grid-margin-y {
+  height: calc(100vh + 1.25rem);
+}
+@media print, screen and (min-width: 40em) {
+  .grid-frame.grid-margin-y {
+    height: calc(100vh + 1.875rem);
+  }
+}
+@media print, screen and (min-width: 64em) {
+  .grid-frame.grid-margin-y {
+    height: calc(100vh + 1.875rem);
+  }
+}
+
+@media print, screen and (min-width: 40em) {
+  .grid-margin-y.medium-grid-frame {
+    height: calc(100vh + 1.875rem);
+  }
+}
+@media print, screen and (min-width: 64em) {
+  .grid-margin-y.large-grid-frame {
+    height: calc(100vh + 1.875rem);
+  }
+}
+.button {
+  display: inline-block;
+  vertical-align: middle;
+  margin: 0 0 1rem 0;
+  border: 1px solid transparent;
+  border-radius: 0;
+  -webkit-transition: background-color 0.25s ease-out, color 0.25s ease-out;
+  transition: background-color 0.25s ease-out, color 0.25s ease-out;
+  font-family: inherit;
+  font-size: 0.9rem;
+  -webkit-appearance: none;
+  line-height: 1;
+  text-align: center;
+  cursor: pointer;
+  padding: 0.85em 1em;
+}
+[data-whatinput=mouse] .button {
+  outline: 0;
+}
+.button.tiny {
+  font-size: 0.6rem;
+}
+.button.small {
+  font-size: 0.75rem;
+}
+.button.large {
+  font-size: 1.25rem;
+}
+.button.expanded {
+  display: block;
+  width: 100%;
+  margin-right: 0;
+  margin-left: 0;
+}
+.button, .button.disabled, .button[disabled], .button.disabled:hover, .button[disabled]:hover, .button.disabled:focus, .button[disabled]:focus {
+  background-color: #1779ba;
+  color: #fefefe;
+}
+.button:hover, .button:focus {
+  background-color: rgb(19.55, 102.85, 158.1);
+  color: #fefefe;
+}
+.button.primary, .button.primary.disabled, .button.primary[disabled], .button.primary.disabled:hover, .button.primary[disabled]:hover, .button.primary.disabled:focus, .button.primary[disabled]:focus {
+  background-color: #1779ba;
+  color: #fefefe;
+}
+.button.primary:hover, .button.primary:focus {
+  background-color: rgb(18.4, 96.8, 148.8);
+  color: #fefefe;
+}
+.button.secondary, .button.secondary.disabled, .button.secondary[disabled], .button.secondary.disabled:hover, .button.secondary[disabled]:hover, .button.secondary.disabled:focus, .button.secondary[disabled]:focus {
+  background-color: #767676;
+  color: #fefefe;
+}
+.button.secondary:hover, .button.secondary:focus {
+  background-color: rgb(94.4, 94.4, 94.4);
+  color: #fefefe;
+}
+.button.success, .button.success.disabled, .button.success[disabled], .button.success.disabled:hover, .button.success[disabled]:hover, .button.success.disabled:focus, .button.success[disabled]:focus {
+  background-color: #3adb76;
+  color: #0a0a0a;
+}
+.button.success:hover, .button.success:focus {
+  background-color: rgb(34.2386266094, 187.3613733906, 91.3030042918);
+  color: #0a0a0a;
+}
+.button.warning, .button.warning.disabled, .button.warning[disabled], .button.warning.disabled:hover, .button.warning[disabled]:hover, .button.warning.disabled:focus, .button.warning[disabled]:focus {
+  background-color: #ffae00;
+  color: #0a0a0a;
+}
+.button.warning:hover, .button.warning:focus {
+  background-color: rgb(204, 139.2, 0);
+  color: #0a0a0a;
+}
+.button.alert, .button.alert.disabled, .button.alert[disabled], .button.alert.disabled:hover, .button.alert[disabled]:hover, .button.alert.disabled:focus, .button.alert[disabled]:focus {
+  background-color: #cc4b37;
+  color: #fefefe;
+}
+.button.alert:hover, .button.alert:focus {
+  background-color: rgb(165.0996015936, 58.6103585657, 42.1003984064);
+  color: #fefefe;
+}
+.button.hollow, .button.hollow:hover, .button.hollow:focus, .button.hollow.disabled, .button.hollow.disabled:hover, .button.hollow.disabled:focus, .button.hollow[disabled], .button.hollow[disabled]:hover, .button.hollow[disabled]:focus {
+  background-color: transparent;
+}
+.button.hollow, .button.hollow.disabled, .button.hollow[disabled], .button.hollow.disabled:hover, .button.hollow[disabled]:hover, .button.hollow.disabled:focus, .button.hollow[disabled]:focus {
+  border: 1px solid #1779ba;
+  color: #1779ba;
+}
+.button.hollow:hover, .button.hollow:focus {
+  border-color: rgb(11.5, 60.5, 93);
+  color: rgb(11.5, 60.5, 93);
+}
+.button.hollow.primary, .button.hollow.primary.disabled, .button.hollow.primary[disabled], .button.hollow.primary.disabled:hover, .button.hollow.primary[disabled]:hover, .button.hollow.primary.disabled:focus, .button.hollow.primary[disabled]:focus {
+  border: 1px solid #1779ba;
+  color: #1779ba;
+}
+.button.hollow.primary:hover, .button.hollow.primary:focus {
+  border-color: rgb(11.5, 60.5, 93);
+  color: rgb(11.5, 60.5, 93);
+}
+.button.hollow.secondary, .button.hollow.secondary.disabled, .button.hollow.secondary[disabled], .button.hollow.secondary.disabled:hover, .button.hollow.secondary[disabled]:hover, .button.hollow.secondary.disabled:focus, .button.hollow.secondary[disabled]:focus {
+  border: 1px solid #767676;
+  color: #767676;
+}
+.button.hollow.secondary:hover, .button.hollow.secondary:focus {
+  border-color: #3b3b3b;
+  color: #3b3b3b;
+}
+.button.hollow.success, .button.hollow.success.disabled, .button.hollow.success[disabled], .button.hollow.success.disabled:hover, .button.hollow.success[disabled]:hover, .button.hollow.success.disabled:focus, .button.hollow.success[disabled]:focus {
+  border: 1px solid #3adb76;
+  color: #3adb76;
+}
+.button.hollow.success:hover, .button.hollow.success:focus {
+  border-color: rgb(21.3991416309, 117.1008583691, 57.0643776824);
+  color: rgb(21.3991416309, 117.1008583691, 57.0643776824);
+}
+.button.hollow.warning, .button.hollow.warning.disabled, .button.hollow.warning[disabled], .button.hollow.warning.disabled:hover, .button.hollow.warning[disabled]:hover, .button.hollow.warning.disabled:focus, .button.hollow.warning[disabled]:focus {
+  border: 1px solid #ffae00;
+  color: #ffae00;
+}
+.button.hollow.warning:hover, .button.hollow.warning:focus {
+  border-color: rgb(127.5, 87, 0);
+  color: rgb(127.5, 87, 0);
+}
+.button.hollow.alert, .button.hollow.alert.disabled, .button.hollow.alert[disabled], .button.hollow.alert.disabled:hover, .button.hollow.alert[disabled]:hover, .button.hollow.alert.disabled:focus, .button.hollow.alert[disabled]:focus {
+  border: 1px solid #cc4b37;
+  color: #cc4b37;
+}
+.button.hollow.alert:hover, .button.hollow.alert:focus {
+  border-color: rgb(103.187250996, 36.6314741036, 26.312749004);
+  color: rgb(103.187250996, 36.6314741036, 26.312749004);
+}
+.button.clear, .button.clear:hover, .button.clear:focus, .button.clear.disabled, .button.clear.disabled:hover, .button.clear.disabled:focus, .button.clear[disabled], .button.clear[disabled]:hover, .button.clear[disabled]:focus {
+  border-color: transparent;
+  background-color: transparent;
+}
+.button.clear, .button.clear.disabled, .button.clear[disabled], .button.clear.disabled:hover, .button.clear[disabled]:hover, .button.clear.disabled:focus, .button.clear[disabled]:focus {
+  color: #1779ba;
+}
+.button.clear:hover, .button.clear:focus {
+  color: rgb(11.5, 60.5, 93);
+}
+.button.clear.primary, .button.clear.primary.disabled, .button.clear.primary[disabled], .button.clear.primary.disabled:hover, .button.clear.primary[disabled]:hover, .button.clear.primary.disabled:focus, .button.clear.primary[disabled]:focus {
+  color: #1779ba;
+}
+.button.clear.primary:hover, .button.clear.primary:focus {
+  color: rgb(11.5, 60.5, 93);
+}
+.button.clear.secondary, .button.clear.secondary.disabled, .button.clear.secondary[disabled], .button.clear.secondary.disabled:hover, .button.clear.secondary[disabled]:hover, .button.clear.secondary.disabled:focus, .button.clear.secondary[disabled]:focus {
+  color: #767676;
+}
+.button.clear.secondary:hover, .button.clear.secondary:focus {
+  color: #3b3b3b;
+}
+.button.clear.success, .button.clear.success.disabled, .button.clear.success[disabled], .button.clear.success.disabled:hover, .button.clear.success[disabled]:hover, .button.clear.success.disabled:focus, .button.clear.success[disabled]:focus {
+  color: #3adb76;
+}
+.button.clear.success:hover, .button.clear.success:focus {
+  color: rgb(21.3991416309, 117.1008583691, 57.0643776824);
+}
+.button.clear.warning, .button.clear.warning.disabled, .button.clear.warning[disabled], .button.clear.warning.disabled:hover, .button.clear.warning[disabled]:hover, .button.clear.warning.disabled:focus, .button.clear.warning[disabled]:focus {
+  color: #ffae00;
+}
+.button.clear.warning:hover, .button.clear.warning:focus {
+  color: rgb(127.5, 87, 0);
+}
+.button.clear.alert, .button.clear.alert.disabled, .button.clear.alert[disabled], .button.clear.alert.disabled:hover, .button.clear.alert[disabled]:hover, .button.clear.alert.disabled:focus, .button.clear.alert[disabled]:focus {
+  color: #cc4b37;
+}
+.button.clear.alert:hover, .button.clear.alert:focus {
+  color: rgb(103.187250996, 36.6314741036, 26.312749004);
+}
+.button.disabled, .button[disabled] {
+  opacity: 0.25;
+  cursor: not-allowed;
+}
+.button.dropdown::after {
+  display: block;
+  width: 0;
+  height: 0;
+  border-style: solid;
+  border-width: 0.4em;
+  content: "";
+  border-bottom-width: 0;
+  border-color: #fefefe transparent transparent;
+  position: relative;
+  top: 0.4em;
+  display: inline-block;
+  float: right;
+  margin-left: 1em;
+}
+.button.dropdown.hollow::after, .button.dropdown.clear::after {
+  border-top-color: #1779ba;
+}
+.button.dropdown.hollow.primary::after, .button.dropdown.clear.primary::after {
+  border-top-color: #1779ba;
+}
+.button.dropdown.hollow.secondary::after, .button.dropdown.clear.secondary::after {
+  border-top-color: #767676;
+}
+.button.dropdown.hollow.success::after, .button.dropdown.clear.success::after {
+  border-top-color: #3adb76;
+}
+.button.dropdown.hollow.warning::after, .button.dropdown.clear.warning::after {
+  border-top-color: #ffae00;
+}
+.button.dropdown.hollow.alert::after, .button.dropdown.clear.alert::after {
+  border-top-color: #cc4b37;
+}
+.button.arrow-only::after {
+  top: -0.1em;
+  float: none;
+  margin-left: 0;
+}
+
+a.button:hover, a.button:focus {
+  text-decoration: none;
+}
+
+.button-group {
+  margin-bottom: 1rem;
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -ms-flex-wrap: wrap;
+      flex-wrap: wrap;
+  -webkit-box-align: stretch;
+      -ms-flex-align: stretch;
+          align-items: stretch;
+  -webkit-box-flex: 1;
+      -ms-flex-positive: 1;
+          flex-grow: 1;
+}
+.button-group::before, .button-group::after {
+  display: none;
+}
+.button-group::before, .button-group::after {
+  display: table;
+  content: " ";
+  -ms-flex-preferred-size: 0;
+      flex-basis: 0;
+  -webkit-box-ordinal-group: 2;
+      -ms-flex-order: 1;
+          order: 1;
+}
+.button-group::after {
+  clear: both;
+}
+.button-group .button {
+  margin: 0;
+  margin-right: 1px;
+  margin-bottom: 1px;
+  font-size: 0.9rem;
+  -webkit-box-flex: 0;
+      -ms-flex: 0 0 auto;
+          flex: 0 0 auto;
+}
+.button-group .button:last-child {
+  margin-right: 0;
+}
+.button-group.tiny .button {
+  font-size: 0.6rem;
+}
+.button-group.small .button {
+  font-size: 0.75rem;
+}
+.button-group.large .button {
+  font-size: 1.25rem;
+}
+.button-group.expanded .button {
+  -webkit-box-flex: 1;
+      -ms-flex: 1 1 0px;
+          flex: 1 1 0px;
+}
+.button-group.primary .button, .button-group.primary .button.disabled, .button-group.primary .button[disabled], .button-group.primary .button.disabled:hover, .button-group.primary .button[disabled]:hover, .button-group.primary .button.disabled:focus, .button-group.primary .button[disabled]:focus {
+  background-color: #1779ba;
+  color: #fefefe;
+}
+.button-group.primary .button:hover, .button-group.primary .button:focus {
+  background-color: rgb(18.4, 96.8, 148.8);
+  color: #fefefe;
+}
+.button-group.secondary .button, .button-group.secondary .button.disabled, .button-group.secondary .button[disabled], .button-group.secondary .button.disabled:hover, .button-group.secondary .button[disabled]:hover, .button-group.secondary .button.disabled:focus, .button-group.secondary .button[disabled]:focus {
+  background-color: #767676;
+  color: #fefefe;
+}
+.button-group.secondary .button:hover, .button-group.secondary .button:focus {
+  background-color: rgb(94.4, 94.4, 94.4);
+  color: #fefefe;
+}
+.button-group.success .button, .button-group.success .button.disabled, .button-group.success .button[disabled], .button-group.success .button.disabled:hover, .button-group.success .button[disabled]:hover, .button-group.success .button.disabled:focus, .button-group.success .button[disabled]:focus {
+  background-color: #3adb76;
+  color: #0a0a0a;
+}
+.button-group.success .button:hover, .button-group.success .button:focus {
+  background-color: rgb(34.2386266094, 187.3613733906, 91.3030042918);
+  color: #0a0a0a;
+}
+.button-group.warning .button, .button-group.warning .button.disabled, .button-group.warning .button[disabled], .button-group.warning .button.disabled:hover, .button-group.warning .button[disabled]:hover, .button-group.warning .button.disabled:focus, .button-group.warning .button[disabled]:focus {
+  background-color: #ffae00;
+  color: #0a0a0a;
+}
+.button-group.warning .button:hover, .button-group.warning .button:focus {
+  background-color: rgb(204, 139.2, 0);
+  color: #0a0a0a;
+}
+.button-group.alert .button, .button-group.alert .button.disabled, .button-group.alert .button[disabled], .button-group.alert .button.disabled:hover, .button-group.alert .button[disabled]:hover, .button-group.alert .button.disabled:focus, .button-group.alert .button[disabled]:focus {
+  background-color: #cc4b37;
+  color: #fefefe;
+}
+.button-group.alert .button:hover, .button-group.alert .button:focus {
+  background-color: rgb(165.0996015936, 58.6103585657, 42.1003984064);
+  color: #fefefe;
+}
+.button-group.hollow .button, .button-group.hollow .button:hover, .button-group.hollow .button:focus, .button-group.hollow .button.disabled, .button-group.hollow .button.disabled:hover, .button-group.hollow .button.disabled:focus, .button-group.hollow .button[disabled], .button-group.hollow .button[disabled]:hover, .button-group.hollow .button[disabled]:focus {
+  background-color: transparent;
+}
+.button-group.hollow .button, .button-group.hollow .button.disabled, .button-group.hollow .button[disabled], .button-group.hollow .button.disabled:hover, .button-group.hollow .button[disabled]:hover, .button-group.hollow .button.disabled:focus, .button-group.hollow .button[disabled]:focus {
+  border: 1px solid #1779ba;
+  color: #1779ba;
+}
+.button-group.hollow .button:hover, .button-group.hollow .button:focus {
+  border-color: rgb(11.5, 60.5, 93);
+  color: rgb(11.5, 60.5, 93);
+}
+.button-group.hollow.primary .button, .button-group.hollow.primary .button.disabled, .button-group.hollow.primary .button[disabled], .button-group.hollow.primary .button.disabled:hover, .button-group.hollow.primary .button[disabled]:hover, .button-group.hollow.primary .button.disabled:focus, .button-group.hollow.primary .button[disabled]:focus, .button-group.hollow .button.primary, .button-group.hollow .button.primary.disabled, .button-group.hollow .button.primary[disabled], .button-group.hollow .button.primary.disabled:hover, .button-group.hollow .button.primary[disabled]:hover, .button-group.hollow .button.primary.disabled:focus, .button-group.hollow .button.primary[disabled]:focus {
+  border: 1px solid #1779ba;
+  color: #1779ba;
+}
+.button-group.hollow.primary .button:hover, .button-group.hollow.primary .button:focus, .button-group.hollow .button.primary:hover, .button-group.hollow .button.primary:focus {
+  border-color: rgb(11.5, 60.5, 93);
+  color: rgb(11.5, 60.5, 93);
+}
+.button-group.hollow.secondary .button, .button-group.hollow.secondary .button.disabled, .button-group.hollow.secondary .button[disabled], .button-group.hollow.secondary .button.disabled:hover, .button-group.hollow.secondary .button[disabled]:hover, .button-group.hollow.secondary .button.disabled:focus, .button-group.hollow.secondary .button[disabled]:focus, .button-group.hollow .button.secondary, .button-group.hollow .button.secondary.disabled, .button-group.hollow .button.secondary[disabled], .button-group.hollow .button.secondary.disabled:hover, .button-group.hollow .button.secondary[disabled]:hover, .button-group.hollow .button.secondary.disabled:focus, .button-group.hollow .button.secondary[disabled]:focus {
+  border: 1px solid #767676;
+  color: #767676;
+}
+.button-group.hollow.secondary .button:hover, .button-group.hollow.secondary .button:focus, .button-group.hollow .button.secondary:hover, .button-group.hollow .button.secondary:focus {
+  border-color: #3b3b3b;
+  color: #3b3b3b;
+}
+.button-group.hollow.success .button, .button-group.hollow.success .button.disabled, .button-group.hollow.success .button[disabled], .button-group.hollow.success .button.disabled:hover, .button-group.hollow.success .button[disabled]:hover, .button-group.hollow.success .button.disabled:focus, .button-group.hollow.success .button[disabled]:focus, .button-group.hollow .button.success, .button-group.hollow .button.success.disabled, .button-group.hollow .button.success[disabled], .button-group.hollow .button.success.disabled:hover, .button-group.hollow .button.success[disabled]:hover, .button-group.hollow .button.success.disabled:focus, .button-group.hollow .button.success[disabled]:focus {
+  border: 1px solid #3adb76;
+  color: #3adb76;
+}
+.button-group.hollow.success .button:hover, .button-group.hollow.success .button:focus, .button-group.hollow .button.success:hover, .button-group.hollow .button.success:focus {
+  border-color: rgb(21.3991416309, 117.1008583691, 57.0643776824);
+  color: rgb(21.3991416309, 117.1008583691, 57.0643776824);
+}
+.button-group.hollow.warning .button, .button-group.hollow.warning .button.disabled, .button-group.hollow.warning .button[disabled], .button-group.hollow.warning .button.disabled:hover, .button-group.hollow.warning .button[disabled]:hover, .button-group.hollow.warning .button.disabled:focus, .button-group.hollow.warning .button[disabled]:focus, .button-group.hollow .button.warning, .button-group.hollow .button.warning.disabled, .button-group.hollow .button.warning[disabled], .button-group.hollow .button.warning.disabled:hover, .button-group.hollow .button.warning[disabled]:hover, .button-group.hollow .button.warning.disabled:focus, .button-group.hollow .button.warning[disabled]:focus {
+  border: 1px solid #ffae00;
+  color: #ffae00;
+}
+.button-group.hollow.warning .button:hover, .button-group.hollow.warning .button:focus, .button-group.hollow .button.warning:hover, .button-group.hollow .button.warning:focus {
+  border-color: rgb(127.5, 87, 0);
+  color: rgb(127.5, 87, 0);
+}
+.button-group.hollow.alert .button, .button-group.hollow.alert .button.disabled, .button-group.hollow.alert .button[disabled], .button-group.hollow.alert .button.disabled:hover, .button-group.hollow.alert .button[disabled]:hover, .button-group.hollow.alert .button.disabled:focus, .button-group.hollow.alert .button[disabled]:focus, .button-group.hollow .button.alert, .button-group.hollow .button.alert.disabled, .button-group.hollow .button.alert[disabled], .button-group.hollow .button.alert.disabled:hover, .button-group.hollow .button.alert[disabled]:hover, .button-group.hollow .button.alert.disabled:focus, .button-group.hollow .button.alert[disabled]:focus {
+  border: 1px solid #cc4b37;
+  color: #cc4b37;
+}
+.button-group.hollow.alert .button:hover, .button-group.hollow.alert .button:focus, .button-group.hollow .button.alert:hover, .button-group.hollow .button.alert:focus {
+  border-color: rgb(103.187250996, 36.6314741036, 26.312749004);
+  color: rgb(103.187250996, 36.6314741036, 26.312749004);
+}
+.button-group.clear .button, .button-group.clear .button:hover, .button-group.clear .button:focus, .button-group.clear .button.disabled, .button-group.clear .button.disabled:hover, .button-group.clear .button.disabled:focus, .button-group.clear .button[disabled], .button-group.clear .button[disabled]:hover, .button-group.clear .button[disabled]:focus {
+  border-color: transparent;
+  background-color: transparent;
+}
+.button-group.clear .button, .button-group.clear .button.disabled, .button-group.clear .button[disabled], .button-group.clear .button.disabled:hover, .button-group.clear .button[disabled]:hover, .button-group.clear .button.disabled:focus, .button-group.clear .button[disabled]:focus {
+  color: #1779ba;
+}
+.button-group.clear .button:hover, .button-group.clear .button:focus {
+  color: rgb(11.5, 60.5, 93);
+}
+.button-group.clear.primary .button, .button-group.clear.primary .button.disabled, .button-group.clear.primary .button[disabled], .button-group.clear.primary .button.disabled:hover, .button-group.clear.primary .button[disabled]:hover, .button-group.clear.primary .button.disabled:focus, .button-group.clear.primary .button[disabled]:focus, .button-group.clear .button.primary, .button-group.clear .button.primary.disabled, .button-group.clear .button.primary[disabled], .button-group.clear .button.primary.disabled:hover, .button-group.clear .button.primary[disabled]:hover, .button-group.clear .button.primary.disabled:focus, .button-group.clear .button.primary[disabled]:focus {
+  color: #1779ba;
+}
+.button-group.clear.primary .button:hover, .button-group.clear.primary .button:focus, .button-group.clear .button.primary:hover, .button-group.clear .button.primary:focus {
+  color: rgb(11.5, 60.5, 93);
+}
+.button-group.clear.secondary .button, .button-group.clear.secondary .button.disabled, .button-group.clear.secondary .button[disabled], .button-group.clear.secondary .button.disabled:hover, .button-group.clear.secondary .button[disabled]:hover, .button-group.clear.secondary .button.disabled:focus, .button-group.clear.secondary .button[disabled]:focus, .button-group.clear .button.secondary, .button-group.clear .button.secondary.disabled, .button-group.clear .button.secondary[disabled], .button-group.clear .button.secondary.disabled:hover, .button-group.clear .button.secondary[disabled]:hover, .button-group.clear .button.secondary.disabled:focus, .button-group.clear .button.secondary[disabled]:focus {
+  color: #767676;
+}
+.button-group.clear.secondary .button:hover, .button-group.clear.secondary .button:focus, .button-group.clear .button.secondary:hover, .button-group.clear .button.secondary:focus {
+  color: #3b3b3b;
+}
+.button-group.clear.success .button, .button-group.clear.success .button.disabled, .button-group.clear.success .button[disabled], .button-group.clear.success .button.disabled:hover, .button-group.clear.success .button[disabled]:hover, .button-group.clear.success .button.disabled:focus, .button-group.clear.success .button[disabled]:focus, .button-group.clear .button.success, .button-group.clear .button.success.disabled, .button-group.clear .button.success[disabled], .button-group.clear .button.success.disabled:hover, .button-group.clear .button.success[disabled]:hover, .button-group.clear .button.success.disabled:focus, .button-group.clear .button.success[disabled]:focus {
+  color: #3adb76;
+}
+.button-group.clear.success .button:hover, .button-group.clear.success .button:focus, .button-group.clear .button.success:hover, .button-group.clear .button.success:focus {
+  color: rgb(21.3991416309, 117.1008583691, 57.0643776824);
+}
+.button-group.clear.warning .button, .button-group.clear.warning .button.disabled, .button-group.clear.warning .button[disabled], .button-group.clear.warning .button.disabled:hover, .button-group.clear.warning .button[disabled]:hover, .button-group.clear.warning .button.disabled:focus, .button-group.clear.warning .button[disabled]:focus, .button-group.clear .button.warning, .button-group.clear .button.warning.disabled, .button-group.clear .button.warning[disabled], .button-group.clear .button.warning.disabled:hover, .button-group.clear .button.warning[disabled]:hover, .button-group.clear .button.warning.disabled:focus, .button-group.clear .button.warning[disabled]:focus {
+  color: #ffae00;
+}
+.button-group.clear.warning .button:hover, .button-group.clear.warning .button:focus, .button-group.clear .button.warning:hover, .button-group.clear .button.warning:focus {
+  color: rgb(127.5, 87, 0);
+}
+.button-group.clear.alert .button, .button-group.clear.alert .button.disabled, .button-group.clear.alert .button[disabled], .button-group.clear.alert .button.disabled:hover, .button-group.clear.alert .button[disabled]:hover, .button-group.clear.alert .button.disabled:focus, .button-group.clear.alert .button[disabled]:focus, .button-group.clear .button.alert, .button-group.clear .button.alert.disabled, .button-group.clear .button.alert[disabled], .button-group.clear .button.alert.disabled:hover, .button-group.clear .button.alert[disabled]:hover, .button-group.clear .button.alert.disabled:focus, .button-group.clear .button.alert[disabled]:focus {
+  color: #cc4b37;
+}
+.button-group.clear.alert .button:hover, .button-group.clear.alert .button:focus, .button-group.clear .button.alert:hover, .button-group.clear .button.alert:focus {
+  color: rgb(103.187250996, 36.6314741036, 26.312749004);
+}
+.button-group.no-gaps .button {
+  margin-right: -0.0625rem;
+}
+.button-group.no-gaps .button + .button {
+  border-left-color: transparent;
+}
+.button-group.stacked, .button-group.stacked-for-small, .button-group.stacked-for-medium {
+  -ms-flex-wrap: wrap;
+      flex-wrap: wrap;
+}
+.button-group.stacked .button, .button-group.stacked-for-small .button, .button-group.stacked-for-medium .button {
+  -webkit-box-flex: 0;
+      -ms-flex: 0 0 100%;
+          flex: 0 0 100%;
+}
+.button-group.stacked .button:last-child, .button-group.stacked-for-small .button:last-child, .button-group.stacked-for-medium .button:last-child {
+  margin-bottom: 0;
+}
+.button-group.stacked.expanded .button, .button-group.stacked-for-small.expanded .button, .button-group.stacked-for-medium.expanded .button {
+  -webkit-box-flex: 1;
+      -ms-flex: 1 1 0px;
+          flex: 1 1 0px;
+}
+@media print, screen and (min-width: 40em) {
+  .button-group.stacked-for-small .button {
+    -webkit-box-flex: 0;
+        -ms-flex: 0 0 auto;
+            flex: 0 0 auto;
+    margin-bottom: 0;
+  }
+}
+@media print, screen and (min-width: 64em) {
+  .button-group.stacked-for-medium .button {
+    -webkit-box-flex: 0;
+        -ms-flex: 0 0 auto;
+            flex: 0 0 auto;
+    margin-bottom: 0;
+  }
+}
+@media print, screen and (max-width: 39.99875em) {
+  .button-group.stacked-for-small.expanded {
+    display: block;
+  }
+  .button-group.stacked-for-small.expanded .button {
+    display: block;
+    margin-right: 0;
+  }
+}
+@media print, screen and (max-width: 63.99875em) {
+  .button-group.stacked-for-medium.expanded {
+    display: block;
+  }
+  .button-group.stacked-for-medium.expanded .button {
+    display: block;
+    margin-right: 0;
+  }
+}
+
+.close-button {
+  position: absolute;
+  z-index: 10;
+  color: #8a8a8a;
+  cursor: pointer;
+}
+[data-whatinput=mouse] .close-button {
+  outline: 0;
+}
+.close-button:hover, .close-button:focus {
+  color: #0a0a0a;
+}
+.close-button.small {
+  right: 0.66rem;
+  top: 0.33em;
+  font-size: 1.5em;
+  line-height: 1;
+}
+
+.close-button.medium, .close-button {
+  right: 1rem;
+  top: 0.5rem;
+  font-size: 2em;
+  line-height: 1;
+}
+
+.label {
+  display: inline-block;
+  padding: 0.33333rem 0.5rem;
+  border-radius: 0;
+  font-size: 0.8rem;
+  line-height: 1;
+  white-space: nowrap;
+  cursor: default;
+  background: #1779ba;
+  color: #fefefe;
+}
+.label.primary {
+  background: #1779ba;
+  color: #fefefe;
+}
+.label.secondary {
+  background: #767676;
+  color: #fefefe;
+}
+.label.success {
+  background: #3adb76;
+  color: #0a0a0a;
+}
+.label.warning {
+  background: #ffae00;
+  color: #0a0a0a;
+}
+.label.alert {
+  background: #cc4b37;
+  color: #fefefe;
+}
+
+.progress {
+  height: 1rem;
+  margin-bottom: 1rem;
+  border-radius: 0;
+  background-color: #cacaca;
+}
+.progress.primary .progress-meter {
+  background-color: #1779ba;
+}
+.progress.secondary .progress-meter {
+  background-color: #767676;
+}
+.progress.success .progress-meter {
+  background-color: #3adb76;
+}
+.progress.warning .progress-meter {
+  background-color: #ffae00;
+}
+.progress.alert .progress-meter {
+  background-color: #cc4b37;
+}
+
+.progress-meter {
+  position: relative;
+  display: block;
+  width: 0%;
+  height: 100%;
+  background-color: #1779ba;
+}
+
+.progress-meter-text {
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  -webkit-transform: translate(-50%, -50%);
+          transform: translate(-50%, -50%);
+  margin: 0;
+  font-size: 0.75rem;
+  font-weight: bold;
+  color: #fefefe;
+  white-space: nowrap;
+}
+
+.slider {
+  position: relative;
+  height: 0.5rem;
+  margin-top: 1.25rem;
+  margin-bottom: 2.25rem;
+  background-color: #e6e6e6;
+  cursor: pointer;
+  -webkit-user-select: none;
+     -moz-user-select: none;
+      -ms-user-select: none;
+          user-select: none;
+  -ms-touch-action: none;
+      touch-action: none;
+}
+
+.slider-fill {
+  position: absolute;
+  top: 0;
+  left: 0;
+  display: inline-block;
+  max-width: 100%;
+  height: 0.5rem;
+  background-color: #cacaca;
+  -webkit-transition: all 0.2s ease-in-out;
+  transition: all 0.2s ease-in-out;
+}
+.slider-fill.is-dragging {
+  -webkit-transition: all 0s linear;
+  transition: all 0s linear;
+}
+
+.slider-handle {
+  left: 0;
+  z-index: 1;
+  cursor: -webkit-grab;
+  cursor: grab;
+  display: inline-block;
+  width: 1.4rem;
+  height: 1.4rem;
+  border-radius: 0;
+  background-color: #1779ba;
+  -webkit-transition: all 0.2s ease-in-out;
+  transition: all 0.2s ease-in-out;
+  -ms-touch-action: manipulation;
+      touch-action: manipulation;
+  position: absolute;
+  top: 50%;
+  -webkit-transform: translateY(-50%);
+          transform: translateY(-50%);
+}
+[data-whatinput=mouse] .slider-handle {
+  outline: 0;
+}
+.slider-handle:hover {
+  background-color: rgb(19.55, 102.85, 158.1);
+}
+.slider-handle.is-dragging {
+  -webkit-transition: all 0s linear;
+  transition: all 0s linear;
+  cursor: -webkit-grabbing;
+  cursor: grabbing;
+}
+
+.slider.disabled,
+.slider[disabled] {
+  opacity: 0.25;
+  cursor: not-allowed;
+}
+
+.slider.vertical {
+  display: inline-block;
+  width: 0.5rem;
+  height: 12.5rem;
+  margin: 0 1.25rem;
+  -webkit-transform: scale(1, -1);
+          transform: scale(1, -1);
+}
+.slider.vertical .slider-fill {
+  top: 0;
+  width: 0.5rem;
+  max-height: 100%;
+}
+.slider.vertical .slider-handle {
+  position: absolute;
+  top: 0;
+  left: 50%;
+  width: 1.4rem;
+  height: 1.4rem;
+  -webkit-transform: translateX(-50%);
+          transform: translateX(-50%);
+}
+
+.switch {
+  position: relative;
+  margin-bottom: 1rem;
+  outline: 0;
+  font-size: 0.875rem;
+  font-weight: bold;
+  color: #fefefe;
+  -webkit-user-select: none;
+     -moz-user-select: none;
+      -ms-user-select: none;
+          user-select: none;
+  height: 2rem;
+}
+
+.switch-input {
+  position: absolute;
+  margin-bottom: 0;
+  opacity: 0;
+}
+
+.switch-paddle {
+  position: relative;
+  display: block;
+  width: 4rem;
+  height: 2rem;
+  border-radius: 0;
+  background: #cacaca;
+  -webkit-transition: all 0.25s ease-out;
+  transition: all 0.25s ease-out;
+  font-weight: inherit;
+  color: inherit;
+  cursor: pointer;
+}
+input + .switch-paddle {
+  margin: 0;
+}
+.switch-paddle::after {
+  position: absolute;
+  top: 0.25rem;
+  left: 0.25rem;
+  display: block;
+  width: 1.5rem;
+  height: 1.5rem;
+  -webkit-transform: translate3d(0, 0, 0);
+          transform: translate3d(0, 0, 0);
+  border-radius: 0;
+  background: #fefefe;
+  -webkit-transition: all 0.25s ease-out;
+  transition: all 0.25s ease-out;
+  content: "";
+}
+input:checked ~ .switch-paddle {
+  background: #1779ba;
+}
+input:checked ~ .switch-paddle::after {
+  left: 2.25rem;
+}
+input:focus-visible ~ .switch-paddle {
+  background: rgb(181.8, 181.8, 181.8);
+}
+input:focus-visible ~ .switch-paddle::after {
+  background: #fefefe;
+}
+input:checked:focus-visible ~ .switch-paddle {
+  background: rgb(19.55, 102.85, 158.1);
+}
+input:disabled ~ .switch-paddle {
+  cursor: not-allowed;
+  opacity: 0.5;
+}
+[data-whatinput=mouse] input:focus ~ .switch-paddle {
+  outline: 0;
+}
+
+.switch-inactive, .switch-active {
+  position: absolute;
+  top: 50%;
+  -webkit-transform: translateY(-50%);
+          transform: translateY(-50%);
+}
+
+.switch-active {
+  left: 8%;
+  display: none;
+}
+input:checked + label > .switch-active {
+  display: block;
+}
+
+.switch-inactive {
+  right: 15%;
+}
+input:checked + label > .switch-inactive {
+  display: none;
+}
+
+.switch.tiny {
+  height: 1.5rem;
+}
+.switch.tiny .switch-paddle {
+  width: 3rem;
+  height: 1.5rem;
+  font-size: 0.625rem;
+}
+.switch.tiny .switch-paddle::after {
+  top: 0.25rem;
+  left: 0.25rem;
+  width: 1rem;
+  height: 1rem;
+}
+.switch.tiny input:checked ~ .switch-paddle::after {
+  left: 1.75rem;
+}
+
+.switch.small {
+  height: 1.75rem;
+}
+.switch.small .switch-paddle {
+  width: 3.5rem;
+  height: 1.75rem;
+  font-size: 0.75rem;
+}
+.switch.small .switch-paddle::after {
+  top: 0.25rem;
+  left: 0.25rem;
+  width: 1.25rem;
+  height: 1.25rem;
+}
+.switch.small input:checked ~ .switch-paddle::after {
+  left: 2rem;
+}
+
+.switch.large {
+  height: 2.5rem;
+}
+.switch.large .switch-paddle {
+  width: 5rem;
+  height: 2.5rem;
+  font-size: 1rem;
+}
+.switch.large .switch-paddle::after {
+  top: 0.25rem;
+  left: 0.25rem;
+  width: 2rem;
+  height: 2rem;
+}
+.switch.large input:checked ~ .switch-paddle::after {
+  left: 2.75rem;
+}
+
+table {
+  border-collapse: collapse;
+  width: 100%;
+  margin-bottom: 1rem;
+  border-radius: 0;
+}
+thead,
+tbody,
+tfoot {
+  border: 1px solid rgb(241.3, 241.3, 241.3);
+  background-color: #fefefe;
+}
+
+caption {
+  padding: 0.5rem 0.625rem 0.625rem;
+  font-weight: bold;
+}
+
+thead {
+  background: rgb(247.65, 247.65, 247.65);
+  color: #0a0a0a;
+}
+
+tfoot {
+  background: rgb(241.3, 241.3, 241.3);
+  color: #0a0a0a;
+}
+
+thead tr,
+tfoot tr {
+  background: transparent;
+}
+thead th,
+thead td,
+tfoot th,
+tfoot td {
+  padding: 0.5rem 0.625rem 0.625rem;
+  font-weight: bold;
+  text-align: left;
+}
+
+tbody th,
+tbody td {
+  padding: 0.5rem 0.625rem 0.625rem;
+}
+
+tbody tr:nth-child(even) {
+  border-bottom: 0;
+  background-color: rgb(241.3, 241.3, 241.3);
+}
+
+table.unstriped tbody {
+  background-color: #fefefe;
+}
+table.unstriped tbody tr {
+  border-bottom: 1px solid rgb(241.3, 241.3, 241.3);
+  background-color: #fefefe;
+}
+
+@media print, screen and (max-width: 63.99875em) {
+  table.stack thead {
+    display: none;
+  }
+  table.stack tfoot {
+    display: none;
+  }
+  table.stack tr,
+  table.stack th,
+  table.stack td {
+    display: block;
+  }
+  table.stack td {
+    border-top: 0;
+  }
+}
+
+table.scroll {
+  display: block;
+  width: 100%;
+  overflow-x: auto;
+}
+
+table.hover thead tr:hover {
+  background-color: rgb(242.55, 242.55, 242.55);
+}
+table.hover tfoot tr:hover {
+  background-color: rgb(236.2, 236.2, 236.2);
+}
+table.hover tbody tr:hover {
+  background-color: rgb(248.9, 248.9, 248.9);
+}
+table.hover:not(.unstriped) tr:nth-of-type(even):hover {
+  background-color: rgb(236.15, 236.15, 236.15);
+}
+
+.table-scroll {
+  overflow-x: auto;
+}
+
+.badge {
+  display: inline-block;
+  min-width: 2.1em;
+  padding: 0.3em;
+  border-radius: 50%;
+  font-size: 0.6rem;
+  text-align: center;
+  background: #1779ba;
+  color: #fefefe;
+}
+.badge.primary {
+  background: #1779ba;
+  color: #fefefe;
+}
+.badge.secondary {
+  background: #767676;
+  color: #fefefe;
+}
+.badge.success {
+  background: #3adb76;
+  color: #0a0a0a;
+}
+.badge.warning {
+  background: #ffae00;
+  color: #0a0a0a;
+}
+.badge.alert {
+  background: #cc4b37;
+  color: #fefefe;
+}
+
+.breadcrumbs {
+  margin: 0 0 1rem 0;
+  list-style: none;
+}
+.breadcrumbs::before, .breadcrumbs::after {
+  display: table;
+  content: " ";
+  -ms-flex-preferred-size: 0;
+      flex-basis: 0;
+  -webkit-box-ordinal-group: 2;
+      -ms-flex-order: 1;
+          order: 1;
+}
+.breadcrumbs::after {
+  clear: both;
+}
+.breadcrumbs li {
+  float: left;
+  font-size: 0.6875rem;
+  color: #0a0a0a;
+  cursor: default;
+  text-transform: uppercase;
+}
+.breadcrumbs li:not(:last-child)::after {
+  position: relative;
+  margin: 0 0.75rem;
+  opacity: 1;
+  content: "/";
+  color: #cacaca;
+}
+.breadcrumbs a {
+  color: #1779ba;
+}
+.breadcrumbs a:hover {
+  text-decoration: underline;
+}
+.breadcrumbs .disabled {
+  color: #cacaca;
+  cursor: not-allowed;
+}
+
+.callout {
+  background-color: rgb(254.85, 254.85, 254.85);
+  color: #0a0a0a;
+  position: relative;
+  margin: 0 0 1rem 0;
+  padding: 1rem;
+  border: 1px solid rgba(10, 10, 10, 0.25);
+  border-radius: 0;
+}
+.callout > :first-child {
+  margin-top: 0;
+}
+.callout > :last-child {
+  margin-bottom: 0;
+}
+.callout.primary {
+  background-color: rgb(214.8186602871, 235.9894736842, 250.0313397129);
+  color: #0a0a0a;
+}
+.callout.secondary {
+  background-color: rgb(234.45, 234.45, 234.45);
+  color: #0a0a0a;
+}
+.callout.success {
+  background-color: rgb(225.45, 249.6, 234.45);
+  color: #0a0a0a;
+}
+.callout.warning {
+  background-color: rgb(255, 242.85, 216.75);
+  color: #0a0a0a;
+}
+.callout.alert {
+  background-color: rgb(247.35, 228, 225);
+  color: #0a0a0a;
+}
+.callout.small {
+  padding-top: 0.5rem;
+  padding-right: 0.5rem;
+  padding-bottom: 0.5rem;
+  padding-left: 0.5rem;
+}
+.callout.large {
+  padding-top: 3rem;
+  padding-right: 3rem;
+  padding-bottom: 3rem;
+  padding-left: 3rem;
+}
+
+.card {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -webkit-box-orient: vertical;
+  -webkit-box-direction: normal;
+      -ms-flex-direction: column;
+          flex-direction: column;
+  -webkit-box-flex: 1;
+      -ms-flex-positive: 1;
+          flex-grow: 1;
+  margin-bottom: 1rem;
+  border: 1px solid #e6e6e6;
+  border-radius: 0;
+  background: #fefefe;
+  -webkit-box-shadow: none;
+          box-shadow: none;
+  overflow: hidden;
+  color: #0a0a0a;
+}
+.card > :last-child {
+  margin-bottom: 0;
+}
+
+.card-divider {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -webkit-box-flex: 0;
+      -ms-flex: 0 1 auto;
+          flex: 0 1 auto;
+  padding: 1rem;
+  background: #e6e6e6;
+}
+.card-divider > :last-child {
+  margin-bottom: 0;
+}
+
+.card-section {
+  -webkit-box-flex: 1;
+      -ms-flex: 1 0 auto;
+          flex: 1 0 auto;
+  padding: 1rem;
+}
+.card-section > :last-child {
+  margin-bottom: 0;
+}
+
+.card-image {
+  min-height: 1px;
+}
+
+.dropdown-pane {
+  position: absolute;
+  z-index: 10;
+  display: none;
+  width: 300px;
+  padding: 1rem;
+  visibility: hidden;
+  border: 1px solid #cacaca;
+  border-radius: 0;
+  background-color: #fefefe;
+  font-size: 1rem;
+}
+.dropdown-pane.is-opening {
+  display: block;
+}
+.dropdown-pane.is-open {
+  display: block;
+  visibility: visible;
+}
+
+.dropdown-pane.tiny {
+  width: 100px;
+}
+
+.dropdown-pane.small {
+  width: 200px;
+}
+
+.dropdown-pane.large {
+  width: 400px;
+}
+
+.pagination {
+  margin-left: 0;
+  margin-bottom: 1rem;
+}
+.pagination::before, .pagination::after {
+  display: table;
+  content: " ";
+  -ms-flex-preferred-size: 0;
+      flex-basis: 0;
+  -webkit-box-ordinal-group: 2;
+      -ms-flex-order: 1;
+          order: 1;
+}
+.pagination::after {
+  clear: both;
+}
+.pagination li {
+  margin-right: 0.0625rem;
+  border-radius: 0;
+  font-size: 0.875rem;
+  display: none;
+}
+.pagination li:last-child, .pagination li:first-child {
+  display: inline-block;
+}
+@media print, screen and (min-width: 40em) {
+  .pagination li {
+    display: inline-block;
+  }
+}
+.pagination a,
+.pagination button {
+  display: block;
+  padding: 0.1875rem 0.625rem;
+  border-radius: 0;
+  color: #0a0a0a;
+}
+.pagination a:hover,
+.pagination button:hover {
+  background: #e6e6e6;
+}
+.pagination .current {
+  padding: 0.1875rem 0.625rem;
+  background: #1779ba;
+  color: #fefefe;
+  cursor: default;
+}
+.pagination .disabled {
+  padding: 0.1875rem 0.625rem;
+  color: #cacaca;
+  cursor: not-allowed;
+}
+.pagination .disabled:hover {
+  background: transparent;
+}
+.pagination .ellipsis::after {
+  padding: 0.1875rem 0.625rem;
+  content: "…";
+  color: #0a0a0a;
+}
+
+.pagination-previous a::before,
+.pagination-previous.disabled::before {
+  display: inline-block;
+  margin-right: 0.5rem;
+  content: "«";
+}
+
+.pagination-next a::after,
+.pagination-next.disabled::after {
+  display: inline-block;
+  margin-left: 0.5rem;
+  content: "»";
+}
+
+.has-tip {
+  position: relative;
+  display: inline-block;
+  border-bottom: dotted 1px #8a8a8a;
+  font-weight: bold;
+  cursor: help;
+}
+
+.tooltip {
+  position: absolute;
+  top: calc(100% + 0.6495rem);
+  z-index: 1200;
+  max-width: 10rem;
+  padding: 0.75rem;
+  border-radius: 0;
+  background-color: #0a0a0a;
+  font-size: 80%;
+  color: #fefefe;
+}
+.tooltip::before {
+  position: absolute;
+}
+.tooltip.bottom::before {
+  display: block;
+  width: 0;
+  height: 0;
+  border-style: solid;
+  border-width: 0.75rem;
+  content: "";
+  border-top-width: 0;
+  border-color: transparent transparent #0a0a0a;
+  bottom: 100%;
+}
+.tooltip.bottom.align-center::before {
+  left: 50%;
+  -webkit-transform: translateX(-50%);
+          transform: translateX(-50%);
+}
+.tooltip.top::before {
+  display: block;
+  width: 0;
+  height: 0;
+  border-style: solid;
+  border-width: 0.75rem;
+  content: "";
+  border-bottom-width: 0;
+  border-color: #0a0a0a transparent transparent;
+  top: 100%;
+  bottom: auto;
+}
+.tooltip.top.align-center::before {
+  left: 50%;
+  -webkit-transform: translateX(-50%);
+          transform: translateX(-50%);
+}
+.tooltip.left::before {
+  display: block;
+  width: 0;
+  height: 0;
+  border-style: solid;
+  border-width: 0.75rem;
+  content: "";
+  border-right-width: 0;
+  border-color: transparent transparent transparent #0a0a0a;
+  left: 100%;
+}
+.tooltip.left.align-center::before {
+  bottom: auto;
+  top: 50%;
+  -webkit-transform: translateY(-50%);
+          transform: translateY(-50%);
+}
+.tooltip.right::before {
+  display: block;
+  width: 0;
+  height: 0;
+  border-style: solid;
+  border-width: 0.75rem;
+  content: "";
+  border-left-width: 0;
+  border-color: transparent #0a0a0a transparent transparent;
+  right: 100%;
+  left: auto;
+}
+.tooltip.right.align-center::before {
+  bottom: auto;
+  top: 50%;
+  -webkit-transform: translateY(-50%);
+          transform: translateY(-50%);
+}
+.tooltip.align-top::before {
+  bottom: auto;
+  top: 10%;
+}
+.tooltip.align-bottom::before {
+  bottom: 10%;
+  top: auto;
+}
+.tooltip.align-left::before {
+  left: 10%;
+  right: auto;
+}
+.tooltip.align-right::before {
+  left: auto;
+  right: 10%;
+}
+
+.accordion {
+  margin-left: 0;
+  background: #fefefe;
+  list-style-type: none;
+}
+.accordion[disabled] .accordion-title {
+  cursor: not-allowed;
+}
+
+.accordion-item:first-child > :first-child {
+  border-radius: 0 0 0 0;
+}
+.accordion-item:last-child > :last-child {
+  border-radius: 0 0 0 0;
+}
+
+.accordion-title {
+  position: relative;
+  display: block;
+  padding: 1.25rem 1rem;
+  border: 1px solid #e6e6e6;
+  border-bottom: 0;
+  font-size: 0.75rem;
+  line-height: 1;
+  color: #1779ba;
+}
+:last-child:not(.is-active) > .accordion-title {
+  border-bottom: 1px solid #e6e6e6;
+  border-radius: 0 0 0 0;
+}
+.accordion-title:hover, .accordion-title:focus {
+  background-color: #e6e6e6;
+}
+.accordion-title::before {
+  position: absolute;
+  top: 50%;
+  right: 1rem;
+  margin-top: -0.5rem;
+  content: "+";
+}
+.is-active > .accordion-title::before {
+  content: "–";
+}
+
+.accordion-content {
+  display: none;
+  padding: 1rem;
+  border: 1px solid #e6e6e6;
+  border-bottom: 0;
+  background-color: #fefefe;
+  color: #0a0a0a;
+}
+:last-child > .accordion-content:last-child {
+  border-bottom: 1px solid #e6e6e6;
+}
+
+.media-object {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  margin-bottom: 1rem;
+  -ms-flex-wrap: nowrap;
+      flex-wrap: nowrap;
+}
+.media-object img {
+  max-width: none;
+}
+@media print, screen and (max-width: 39.99875em) {
+  .media-object.stack-for-small {
+    -ms-flex-wrap: wrap;
+        flex-wrap: wrap;
+  }
+}
+
+.media-object-section {
+  -webkit-box-flex: 0;
+      -ms-flex: 0 1 auto;
+          flex: 0 1 auto;
+}
+.media-object-section:first-child {
+  padding-right: 1rem;
+}
+.media-object-section:last-child:not(:nth-child(2)) {
+  padding-left: 1rem;
+}
+.media-object-section > :last-child {
+  margin-bottom: 0;
+}
+@media print, screen and (max-width: 39.99875em) {
+  .stack-for-small .media-object-section {
+    padding: 0;
+    padding-bottom: 1rem;
+    -ms-flex-preferred-size: 100%;
+        flex-basis: 100%;
+    max-width: 100%;
+  }
+  .stack-for-small .media-object-section img {
+    width: 100%;
+  }
+}
+.media-object-section.main-section {
+  -webkit-box-flex: 1;
+      -ms-flex: 1 1 0px;
+          flex: 1 1 0px;
+}
+
+.orbit {
+  position: relative;
+}
+
+.orbit-container {
+  position: relative;
+  height: 0;
+  margin: 0;
+  list-style: none;
+  overflow: hidden;
+}
+
+.orbit-slide {
+  width: 100%;
+  position: absolute;
+}
+.orbit-slide.no-motionui.is-active {
+  top: 0;
+  left: 0;
+}
+
+.orbit-figure {
+  margin: 0;
+}
+
+.orbit-image {
+  width: 100%;
+  max-width: 100%;
+  margin: 0;
+}
+
+.orbit-caption {
+  position: absolute;
+  bottom: 0;
+  width: 100%;
+  margin-bottom: 0;
+  padding: 1rem;
+  background-color: rgba(10, 10, 10, 0.5);
+  color: #fefefe;
+}
+
+.orbit-next, .orbit-previous {
+  z-index: 10;
+  padding: 1rem;
+  color: #fefefe;
+  position: absolute;
+  top: 50%;
+  -webkit-transform: translateY(-50%);
+          transform: translateY(-50%);
+}
+[data-whatinput=mouse] .orbit-next, [data-whatinput=mouse] .orbit-previous {
+  outline: 0;
+}
+.orbit-next:hover, .orbit-previous:hover, .orbit-next:active, .orbit-previous:active, .orbit-next:focus, .orbit-previous:focus {
+  background-color: rgba(10, 10, 10, 0.5);
+}
+
+.orbit-previous {
+  left: 0;
+}
+
+.orbit-next {
+  left: auto;
+  right: 0;
+}
+
+.orbit-bullets {
+  position: relative;
+  margin-top: 0.8rem;
+  margin-bottom: 0.8rem;
+  text-align: center;
+}
+[data-whatinput=mouse] .orbit-bullets {
+  outline: 0;
+}
+.orbit-bullets button {
+  width: 1.2rem;
+  height: 1.2rem;
+  margin: 0.1rem;
+  border-radius: 50%;
+  background-color: #cacaca;
+}
+.orbit-bullets button:hover {
+  background-color: #8a8a8a;
+}
+.orbit-bullets button.is-active {
+  background-color: #8a8a8a;
+}
+
+.responsive-embed,
+.flex-video {
+  position: relative;
+  height: 0;
+  margin-bottom: 1rem;
+  padding-bottom: 75%;
+  overflow: hidden;
+}
+.responsive-embed iframe,
+.responsive-embed object,
+.responsive-embed embed,
+.responsive-embed video,
+.flex-video iframe,
+.flex-video object,
+.flex-video embed,
+.flex-video video {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+}
+.responsive-embed.widescreen,
+.flex-video.widescreen {
+  padding-bottom: 56.25%;
+}
+
+.tabs {
+  margin: 0;
+  border: 1px solid #e6e6e6;
+  background: #fefefe;
+  list-style-type: none;
+}
+.tabs::before, .tabs::after {
+  display: table;
+  content: " ";
+  -ms-flex-preferred-size: 0;
+      flex-basis: 0;
+  -webkit-box-ordinal-group: 2;
+      -ms-flex-order: 1;
+          order: 1;
+}
+.tabs::after {
+  clear: both;
+}
+
+.tabs.vertical > li {
+  display: block;
+  float: none;
+  width: auto;
+}
+
+.tabs.simple > li > a {
+  padding: 0;
+}
+.tabs.simple > li > a:hover {
+  background: transparent;
+}
+
+.tabs.primary {
+  background: #1779ba;
+}
+.tabs.primary > li > a {
+  color: #fefefe;
+}
+.tabs.primary > li > a:hover, .tabs.primary > li > a:focus {
+  background: rgb(21.85, 114.95, 176.7);
+}
+
+.tabs-title {
+  float: left;
+}
+.tabs-title > a {
+  display: block;
+  padding: 1.25rem 1.5rem;
+  font-size: 0.75rem;
+  line-height: 1;
+  color: #1779ba;
+}
+[data-whatinput=mouse] .tabs-title > a {
+  outline: 0;
+}
+.tabs-title > a:hover {
+  background: #fefefe;
+  color: rgb(19.78, 104.06, 159.96);
+}
+.tabs-title > a:focus, .tabs-title > a[aria-selected=true] {
+  background: #e6e6e6;
+  color: #1779ba;
+}
+
+.tabs-content {
+  border: 1px solid #e6e6e6;
+  border-top: 0;
+  background: #fefefe;
+  color: #0a0a0a;
+  -webkit-transition: all 0.5s ease;
+  transition: all 0.5s ease;
+}
+
+.tabs-content.vertical {
+  border: 1px solid #e6e6e6;
+  border-left: 0;
+}
+
+.tabs-panel {
+  display: none;
+  padding: 1rem;
+}
+.tabs-panel.is-active {
+  display: block;
+}
+
+.thumbnail {
+  display: inline-block;
+  max-width: 100%;
+  margin-bottom: 1rem;
+  border: 4px solid #fefefe;
+  border-radius: 0;
+  -webkit-box-shadow: 0 0 0 1px rgba(10, 10, 10, 0.2);
+          box-shadow: 0 0 0 1px rgba(10, 10, 10, 0.2);
+  line-height: 0;
+}
+
+a.thumbnail {
+  -webkit-transition: -webkit-box-shadow 200ms ease-out;
+  transition: -webkit-box-shadow 200ms ease-out;
+  transition: box-shadow 200ms ease-out;
+  transition: box-shadow 200ms ease-out, -webkit-box-shadow 200ms ease-out;
+}
+a.thumbnail:hover, a.thumbnail:focus {
+  -webkit-box-shadow: 0 0 6px 1px rgba(23, 121, 186, 0.5);
+          box-shadow: 0 0 6px 1px rgba(23, 121, 186, 0.5);
+}
+a.thumbnail image {
+  -webkit-box-shadow: none;
+          box-shadow: none;
+}
+
+.menu {
+  padding: 0;
+  margin: 0;
+  list-style: none;
+  position: relative;
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -ms-flex-wrap: wrap;
+      flex-wrap: wrap;
+}
+[data-whatinput=mouse] .menu li {
+  outline: 0;
+}
+.menu a,
+.menu .button {
+  line-height: 1;
+  text-decoration: none;
+  display: block;
+  padding: 0.7rem 1rem;
+}
+.menu input,
+.menu select,
+.menu a,
+.menu button {
+  margin-bottom: 0;
+}
+.menu input {
+  display: inline-block;
+}
+.menu, .menu.horizontal {
+  -ms-flex-wrap: wrap;
+      flex-wrap: wrap;
+  -webkit-box-orient: horizontal;
+  -webkit-box-direction: normal;
+      -ms-flex-direction: row;
+          flex-direction: row;
+}
+.menu.vertical {
+  -ms-flex-wrap: nowrap;
+      flex-wrap: nowrap;
+  -webkit-box-orient: vertical;
+  -webkit-box-direction: normal;
+      -ms-flex-direction: column;
+          flex-direction: column;
+}
+.menu.vertical.icon-top li a img,
+.menu.vertical.icon-top li a i,
+.menu.vertical.icon-top li a svg, .menu.vertical.icon-bottom li a img,
+.menu.vertical.icon-bottom li a i,
+.menu.vertical.icon-bottom li a svg {
+  text-align: left;
+}
+.menu.expanded li {
+  -webkit-box-flex: 1;
+      -ms-flex: 1 1 0px;
+          flex: 1 1 0px;
+}
+.menu.expanded.icon-top li a img,
+.menu.expanded.icon-top li a i,
+.menu.expanded.icon-top li a svg, .menu.expanded.icon-bottom li a img,
+.menu.expanded.icon-bottom li a i,
+.menu.expanded.icon-bottom li a svg {
+  text-align: left;
+}
+.menu.simple {
+  -webkit-box-align: center;
+      -ms-flex-align: center;
+          align-items: center;
+}
+.menu.simple li + li {
+  margin-left: 1rem;
+}
+.menu.simple a {
+  padding: 0;
+}
+@media print, screen and (min-width: 40em) {
+  .menu.medium-horizontal {
+    -ms-flex-wrap: wrap;
+        flex-wrap: wrap;
+    -webkit-box-orient: horizontal;
+    -webkit-box-direction: normal;
+        -ms-flex-direction: row;
+            flex-direction: row;
+  }
+  .menu.medium-vertical {
+    -ms-flex-wrap: nowrap;
+        flex-wrap: nowrap;
+    -webkit-box-orient: vertical;
+    -webkit-box-direction: normal;
+        -ms-flex-direction: column;
+            flex-direction: column;
+  }
+  .menu.medium-expanded li {
+    -webkit-box-flex: 1;
+        -ms-flex: 1 1 0px;
+            flex: 1 1 0px;
+  }
+  .menu.medium-simple li {
+    -webkit-box-flex: 1;
+        -ms-flex: 1 1 0px;
+            flex: 1 1 0px;
+  }
+}
+@media print, screen and (min-width: 64em) {
+  .menu.large-horizontal {
+    -ms-flex-wrap: wrap;
+        flex-wrap: wrap;
+    -webkit-box-orient: horizontal;
+    -webkit-box-direction: normal;
+        -ms-flex-direction: row;
+            flex-direction: row;
+  }
+  .menu.large-vertical {
+    -ms-flex-wrap: nowrap;
+        flex-wrap: nowrap;
+    -webkit-box-orient: vertical;
+    -webkit-box-direction: normal;
+        -ms-flex-direction: column;
+            flex-direction: column;
+  }
+  .menu.large-expanded li {
+    -webkit-box-flex: 1;
+        -ms-flex: 1 1 0px;
+            flex: 1 1 0px;
+  }
+  .menu.large-simple li {
+    -webkit-box-flex: 1;
+        -ms-flex: 1 1 0px;
+            flex: 1 1 0px;
+  }
+}
+.menu.nested {
+  margin-right: 0;
+  margin-left: 1rem;
+}
+.menu.icons a {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+}
+.menu.icon-top a, .menu.icon-right a, .menu.icon-bottom a, .menu.icon-left a {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+}
+.menu.icon-left li a, .menu.nested.icon-left li a {
+  -webkit-box-orient: horizontal;
+  -webkit-box-direction: normal;
+      -ms-flex-flow: row nowrap;
+          flex-flow: row nowrap;
+}
+.menu.icon-left li a img,
+.menu.icon-left li a i,
+.menu.icon-left li a svg, .menu.nested.icon-left li a img,
+.menu.nested.icon-left li a i,
+.menu.nested.icon-left li a svg {
+  margin-right: 0.25rem;
+}
+.menu.icon-right li a, .menu.nested.icon-right li a {
+  -webkit-box-orient: horizontal;
+  -webkit-box-direction: normal;
+      -ms-flex-flow: row nowrap;
+          flex-flow: row nowrap;
+}
+.menu.icon-right li a img,
+.menu.icon-right li a i,
+.menu.icon-right li a svg, .menu.nested.icon-right li a img,
+.menu.nested.icon-right li a i,
+.menu.nested.icon-right li a svg {
+  margin-left: 0.25rem;
+}
+.menu.icon-top li a, .menu.nested.icon-top li a {
+  -webkit-box-orient: vertical;
+  -webkit-box-direction: normal;
+      -ms-flex-flow: column nowrap;
+          flex-flow: column nowrap;
+}
+.menu.icon-top li a img,
+.menu.icon-top li a i,
+.menu.icon-top li a svg, .menu.nested.icon-top li a img,
+.menu.nested.icon-top li a i,
+.menu.nested.icon-top li a svg {
+  -ms-flex-item-align: stretch;
+      align-self: stretch;
+  margin-bottom: 0.25rem;
+  text-align: center;
+}
+.menu.icon-bottom li a, .menu.nested.icon-bottom li a {
+  -webkit-box-orient: vertical;
+  -webkit-box-direction: normal;
+      -ms-flex-flow: column nowrap;
+          flex-flow: column nowrap;
+}
+.menu.icon-bottom li a img,
+.menu.icon-bottom li a i,
+.menu.icon-bottom li a svg, .menu.nested.icon-bottom li a img,
+.menu.nested.icon-bottom li a i,
+.menu.nested.icon-bottom li a svg {
+  -ms-flex-item-align: stretch;
+      align-self: stretch;
+  margin-bottom: 0.25rem;
+  text-align: center;
+}
+.menu .is-active > a {
+  background: #1779ba;
+  color: #fefefe;
+}
+.menu .active > a {
+  background: #1779ba;
+  color: #fefefe;
+}
+.menu.align-left {
+  -webkit-box-pack: start;
+      -ms-flex-pack: start;
+          justify-content: flex-start;
+}
+.menu.align-right li {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -webkit-box-pack: end;
+      -ms-flex-pack: end;
+          justify-content: flex-end;
+}
+.menu.align-right li .submenu li {
+  -webkit-box-pack: start;
+      -ms-flex-pack: start;
+          justify-content: flex-start;
+}
+.menu.align-right.vertical li {
+  display: block;
+  text-align: right;
+}
+.menu.align-right.vertical li .submenu li {
+  text-align: right;
+}
+.menu.align-right.icon-top li a img,
+.menu.align-right.icon-top li a i,
+.menu.align-right.icon-top li a svg, .menu.align-right.icon-bottom li a img,
+.menu.align-right.icon-bottom li a i,
+.menu.align-right.icon-bottom li a svg {
+  text-align: right;
+}
+.menu.align-right .nested {
+  margin-right: 1rem;
+  margin-left: 0;
+}
+.menu.align-center li {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -webkit-box-pack: center;
+      -ms-flex-pack: center;
+          justify-content: center;
+}
+.menu.align-center li .submenu li {
+  -webkit-box-pack: start;
+      -ms-flex-pack: start;
+          justify-content: flex-start;
+}
+.menu .menu-text {
+  padding: 0.7rem 1rem;
+  font-weight: bold;
+  line-height: 1;
+  color: inherit;
+}
+
+.menu-centered > .menu {
+  -webkit-box-pack: center;
+      -ms-flex-pack: center;
+          justify-content: center;
+}
+.menu-centered > .menu li {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -webkit-box-pack: center;
+      -ms-flex-pack: center;
+          justify-content: center;
+}
+.menu-centered > .menu li .submenu li {
+  -webkit-box-pack: start;
+      -ms-flex-pack: start;
+          justify-content: flex-start;
+}
+
+.no-js [data-responsive-menu] ul {
+  display: none;
+}
+
+.menu-icon {
+  position: relative;
+  display: inline-block;
+  vertical-align: middle;
+  width: 20px;
+  height: 16px;
+  cursor: pointer;
+}
+.menu-icon::after {
+  position: absolute;
+  top: 0;
+  left: 0;
+  display: block;
+  width: 100%;
+  height: 2px;
+  background: #fefefe;
+  -webkit-box-shadow: 0 7px 0 #fefefe, 0 14px 0 #fefefe;
+          box-shadow: 0 7px 0 #fefefe, 0 14px 0 #fefefe;
+  content: "";
+}
+.menu-icon:hover::after {
+  background: #cacaca;
+  -webkit-box-shadow: 0 7px 0 #cacaca, 0 14px 0 #cacaca;
+          box-shadow: 0 7px 0 #cacaca, 0 14px 0 #cacaca;
+}
+
+.menu-icon.dark {
+  position: relative;
+  display: inline-block;
+  vertical-align: middle;
+  width: 20px;
+  height: 16px;
+  cursor: pointer;
+}
+.menu-icon.dark::after {
+  position: absolute;
+  top: 0;
+  left: 0;
+  display: block;
+  width: 100%;
+  height: 2px;
+  background: #0a0a0a;
+  -webkit-box-shadow: 0 7px 0 #0a0a0a, 0 14px 0 #0a0a0a;
+          box-shadow: 0 7px 0 #0a0a0a, 0 14px 0 #0a0a0a;
+  content: "";
+}
+.menu-icon.dark:hover::after {
+  background: #8a8a8a;
+  -webkit-box-shadow: 0 7px 0 #8a8a8a, 0 14px 0 #8a8a8a;
+          box-shadow: 0 7px 0 #8a8a8a, 0 14px 0 #8a8a8a;
+}
+
+.accordion-menu li {
+  width: 100%;
+}
+.accordion-menu a {
+  padding: 0.7rem 1rem;
+}
+.accordion-menu .is-accordion-submenu a {
+  padding: 0.7rem 1rem;
+}
+.accordion-menu .nested.is-accordion-submenu {
+  margin-right: 0;
+  margin-left: 1rem;
+}
+.accordion-menu.align-right .nested.is-accordion-submenu {
+  margin-right: 1rem;
+  margin-left: 0;
+}
+.accordion-menu .is-accordion-submenu-parent:not(.has-submenu-toggle) > a {
+  position: relative;
+}
+.accordion-menu .is-accordion-submenu-parent:not(.has-submenu-toggle) > a::after {
+  display: block;
+  width: 0;
+  height: 0;
+  border-style: solid;
+  border-width: 6px;
+  content: "";
+  border-bottom-width: 0;
+  border-color: #1779ba transparent transparent;
+  position: absolute;
+  top: 50%;
+  margin-top: -3px;
+  right: 1rem;
+}
+.accordion-menu.align-left .is-accordion-submenu-parent > a::after {
+  right: 1rem;
+  left: auto;
+}
+.accordion-menu.align-right .is-accordion-submenu-parent > a::after {
+  right: auto;
+  left: 1rem;
+}
+.accordion-menu .is-accordion-submenu-parent[aria-expanded=true] > a::after {
+  -webkit-transform: rotate(180deg);
+          transform: rotate(180deg);
+  -webkit-transform-origin: 50% 50%;
+          transform-origin: 50% 50%;
+}
+
+.is-accordion-submenu-parent {
+  position: relative;
+}
+
+.has-submenu-toggle > a {
+  margin-right: 40px;
+}
+
+.submenu-toggle {
+  position: absolute;
+  top: 0;
+  right: 0;
+  width: 40px;
+  height: 40px;
+  cursor: pointer;
+}
+.submenu-toggle::after {
+  display: block;
+  width: 0;
+  height: 0;
+  border-style: solid;
+  border-width: 6px;
+  content: "";
+  border-bottom-width: 0;
+  border-color: #1779ba transparent transparent;
+  top: 0;
+  bottom: 0;
+  margin: auto;
+}
+
+.submenu-toggle[aria-expanded=true]::after {
+  -webkit-transform: scaleY(-1);
+          transform: scaleY(-1);
+  -webkit-transform-origin: 50% 50%;
+          transform-origin: 50% 50%;
+}
+
+.submenu-toggle-text {
+  position: absolute !important;
+  width: 1px !important;
+  height: 1px !important;
+  padding: 0 !important;
+  overflow: hidden !important;
+  clip: rect(0, 0, 0, 0) !important;
+  white-space: nowrap !important;
+  border: 0 !important;
+}
+
+.is-drilldown {
+  position: relative;
+  overflow: hidden;
+}
+.is-drilldown li {
+  display: block;
+}
+.is-drilldown.animate-height {
+  -webkit-transition: height 0.5s;
+  transition: height 0.5s;
+}
+
+.drilldown a {
+  padding: 0.7rem 1rem;
+  background: #fefefe;
+}
+.drilldown .is-drilldown-submenu {
+  position: absolute;
+  top: 0;
+  left: 100%;
+  z-index: -1;
+  width: 100%;
+  background: #fefefe;
+  -webkit-transition: -webkit-transform 0.15s linear;
+  transition: -webkit-transform 0.15s linear;
+  transition: transform 0.15s linear;
+  transition: transform 0.15s linear, -webkit-transform 0.15s linear;
+}
+.drilldown .is-drilldown-submenu.is-active {
+  z-index: 1;
+  display: block;
+  -webkit-transform: translateX(-100%);
+          transform: translateX(-100%);
+}
+.drilldown .is-drilldown-submenu.is-closing {
+  -webkit-transform: translateX(100%);
+          transform: translateX(100%);
+}
+.drilldown .is-drilldown-submenu a {
+  padding: 0.7rem 1rem;
+}
+.drilldown .nested.is-drilldown-submenu {
+  margin-right: 0;
+  margin-left: 0;
+}
+.drilldown .drilldown-submenu-cover-previous {
+  min-height: 100%;
+}
+.drilldown .is-drilldown-submenu-parent > a {
+  position: relative;
+}
+.drilldown .is-drilldown-submenu-parent > a::after {
+  display: block;
+  width: 0;
+  height: 0;
+  border-style: solid;
+  border-width: 6px;
+  content: "";
+  border-right-width: 0;
+  border-color: transparent transparent transparent #1779ba;
+  position: absolute;
+  top: 50%;
+  margin-top: -6px;
+  right: 1rem;
+}
+.drilldown.align-left .is-drilldown-submenu-parent > a::after {
+  display: block;
+  width: 0;
+  height: 0;
+  border-style: solid;
+  border-width: 6px;
+  content: "";
+  border-right-width: 0;
+  border-color: transparent transparent transparent #1779ba;
+  right: 1rem;
+  left: auto;
+}
+.drilldown.align-right .is-drilldown-submenu-parent > a::after {
+  display: block;
+  width: 0;
+  height: 0;
+  border-style: solid;
+  border-width: 6px;
+  content: "";
+  border-left-width: 0;
+  border-color: transparent #1779ba transparent transparent;
+  right: auto;
+  left: 1rem;
+}
+.drilldown .js-drilldown-back > a::before {
+  display: block;
+  width: 0;
+  height: 0;
+  border-style: solid;
+  border-width: 6px;
+  content: "";
+  border-left-width: 0;
+  border-color: transparent #1779ba transparent transparent;
+  display: inline-block;
+  vertical-align: middle;
+  margin-right: 0.75rem;
+}
+
+.dropdown.menu > li.opens-left > .is-dropdown-submenu {
+  top: 100%;
+  right: 0;
+  left: auto;
+}
+.dropdown.menu > li.opens-right > .is-dropdown-submenu {
+  top: 100%;
+  right: auto;
+  left: 0;
+}
+.dropdown.menu > li.is-dropdown-submenu-parent > a {
+  position: relative;
+  padding-right: 1.5rem;
+}
+.dropdown.menu > li.is-dropdown-submenu-parent > a::after {
+  display: block;
+  width: 0;
+  height: 0;
+  border-style: solid;
+  border-width: 6px;
+  content: "";
+  border-bottom-width: 0;
+  border-color: #1779ba transparent transparent;
+  right: 5px;
+  left: auto;
+  margin-top: -3px;
+}
+[data-whatinput=mouse] .dropdown.menu a {
+  outline: 0;
+}
+.dropdown.menu > li > a {
+  padding: 0.7rem 1rem;
+}
+.dropdown.menu > li.is-active > a {
+  background: transparent;
+  color: #1779ba;
+}
+.no-js .dropdown.menu ul {
+  display: none;
+}
+.dropdown.menu .nested.is-dropdown-submenu {
+  margin-right: 0;
+  margin-left: 0;
+}
+.dropdown.menu.vertical > li .is-dropdown-submenu {
+  top: 0;
+}
+.dropdown.menu.vertical > li.opens-left > .is-dropdown-submenu {
+  top: 0;
+  right: 100%;
+  left: auto;
+}
+.dropdown.menu.vertical > li.opens-right > .is-dropdown-submenu {
+  right: auto;
+  left: 100%;
+}
+.dropdown.menu.vertical > li > a::after {
+  right: 14px;
+}
+.dropdown.menu.vertical > li.opens-left > a::after {
+  display: block;
+  width: 0;
+  height: 0;
+  border-style: solid;
+  border-width: 6px;
+  content: "";
+  border-left-width: 0;
+  border-color: transparent #1779ba transparent transparent;
+  right: auto;
+  left: 5px;
+}
+.dropdown.menu.vertical > li.opens-right > a::after {
+  display: block;
+  width: 0;
+  height: 0;
+  border-style: solid;
+  border-width: 6px;
+  content: "";
+  border-right-width: 0;
+  border-color: transparent transparent transparent #1779ba;
+}
+@media print, screen and (min-width: 40em) {
+  .dropdown.menu.medium-horizontal > li.opens-left > .is-dropdown-submenu {
+    top: 100%;
+    right: 0;
+    left: auto;
+  }
+  .dropdown.menu.medium-horizontal > li.opens-right > .is-dropdown-submenu {
+    top: 100%;
+    right: auto;
+    left: 0;
+  }
+  .dropdown.menu.medium-horizontal > li.is-dropdown-submenu-parent > a {
+    position: relative;
+    padding-right: 1.5rem;
+  }
+  .dropdown.menu.medium-horizontal > li.is-dropdown-submenu-parent > a::after {
+    display: block;
+    width: 0;
+    height: 0;
+    border-style: solid;
+    border-width: 6px;
+    content: "";
+    border-bottom-width: 0;
+    border-color: #1779ba transparent transparent;
+    right: 5px;
+    left: auto;
+    margin-top: -3px;
+  }
+  .dropdown.menu.medium-vertical > li .is-dropdown-submenu {
+    top: 0;
+  }
+  .dropdown.menu.medium-vertical > li.opens-left > .is-dropdown-submenu {
+    top: 0;
+    right: 100%;
+    left: auto;
+  }
+  .dropdown.menu.medium-vertical > li.opens-right > .is-dropdown-submenu {
+    right: auto;
+    left: 100%;
+  }
+  .dropdown.menu.medium-vertical > li > a::after {
+    right: 14px;
+  }
+  .dropdown.menu.medium-vertical > li.opens-left > a::after {
+    display: block;
+    width: 0;
+    height: 0;
+    border-style: solid;
+    border-width: 6px;
+    content: "";
+    border-left-width: 0;
+    border-color: transparent #1779ba transparent transparent;
+    right: auto;
+    left: 5px;
+  }
+  .dropdown.menu.medium-vertical > li.opens-right > a::after {
+    display: block;
+    width: 0;
+    height: 0;
+    border-style: solid;
+    border-width: 6px;
+    content: "";
+    border-right-width: 0;
+    border-color: transparent transparent transparent #1779ba;
+  }
+}
+@media print, screen and (min-width: 64em) {
+  .dropdown.menu.large-horizontal > li.opens-left > .is-dropdown-submenu {
+    top: 100%;
+    right: 0;
+    left: auto;
+  }
+  .dropdown.menu.large-horizontal > li.opens-right > .is-dropdown-submenu {
+    top: 100%;
+    right: auto;
+    left: 0;
+  }
+  .dropdown.menu.large-horizontal > li.is-dropdown-submenu-parent > a {
+    position: relative;
+    padding-right: 1.5rem;
+  }
+  .dropdown.menu.large-horizontal > li.is-dropdown-submenu-parent > a::after {
+    display: block;
+    width: 0;
+    height: 0;
+    border-style: solid;
+    border-width: 6px;
+    content: "";
+    border-bottom-width: 0;
+    border-color: #1779ba transparent transparent;
+    right: 5px;
+    left: auto;
+    margin-top: -3px;
+  }
+  .dropdown.menu.large-vertical > li .is-dropdown-submenu {
+    top: 0;
+  }
+  .dropdown.menu.large-vertical > li.opens-left > .is-dropdown-submenu {
+    top: 0;
+    right: 100%;
+    left: auto;
+  }
+  .dropdown.menu.large-vertical > li.opens-right > .is-dropdown-submenu {
+    right: auto;
+    left: 100%;
+  }
+  .dropdown.menu.large-vertical > li > a::after {
+    right: 14px;
+  }
+  .dropdown.menu.large-vertical > li.opens-left > a::after {
+    display: block;
+    width: 0;
+    height: 0;
+    border-style: solid;
+    border-width: 6px;
+    content: "";
+    border-left-width: 0;
+    border-color: transparent #1779ba transparent transparent;
+    right: auto;
+    left: 5px;
+  }
+  .dropdown.menu.large-vertical > li.opens-right > a::after {
+    display: block;
+    width: 0;
+    height: 0;
+    border-style: solid;
+    border-width: 6px;
+    content: "";
+    border-right-width: 0;
+    border-color: transparent transparent transparent #1779ba;
+  }
+}
+.dropdown.menu.align-right .is-dropdown-submenu.first-sub {
+  top: 100%;
+  right: 0;
+  left: auto;
+}
+
+.is-dropdown-menu.vertical {
+  width: 100px;
+}
+.is-dropdown-menu.vertical.align-right {
+  float: right;
+}
+
+.is-dropdown-submenu-parent {
+  position: relative;
+}
+.is-dropdown-submenu-parent a::after {
+  position: absolute;
+  top: 50%;
+  right: 5px;
+  left: auto;
+  margin-top: -6px;
+}
+.is-dropdown-submenu-parent.opens-inner > .is-dropdown-submenu {
+  top: 100%;
+  left: auto;
+}
+.is-dropdown-submenu-parent.opens-left > .is-dropdown-submenu {
+  right: 100%;
+  left: auto;
+}
+.is-dropdown-submenu-parent.opens-right > .is-dropdown-submenu {
+  right: auto;
+  left: 100%;
+}
+
+.is-dropdown-submenu {
+  position: absolute;
+  top: 0;
+  left: 100%;
+  z-index: 1;
+  display: none;
+  min-width: 200px;
+  border: 1px solid #cacaca;
+  background: #fefefe;
+}
+.dropdown .is-dropdown-submenu a {
+  padding: 0.7rem 1rem;
+}
+.is-dropdown-submenu .is-dropdown-submenu-parent > a::after {
+  right: 14px;
+}
+.is-dropdown-submenu .is-dropdown-submenu-parent.opens-left > a::after {
+  display: block;
+  width: 0;
+  height: 0;
+  border-style: solid;
+  border-width: 6px;
+  content: "";
+  border-left-width: 0;
+  border-color: transparent #1779ba transparent transparent;
+  right: auto;
+  left: 5px;
+}
+.is-dropdown-submenu .is-dropdown-submenu-parent.opens-right > a::after {
+  display: block;
+  width: 0;
+  height: 0;
+  border-style: solid;
+  border-width: 6px;
+  content: "";
+  border-right-width: 0;
+  border-color: transparent transparent transparent #1779ba;
+}
+.is-dropdown-submenu .is-dropdown-submenu {
+  margin-top: -1px;
+}
+.is-dropdown-submenu > li {
+  width: 100%;
+}
+.is-dropdown-submenu.js-dropdown-active {
+  display: block;
+}
+
+.is-off-canvas-open {
+  overflow: hidden;
+}
+
+.js-off-canvas-overlay {
+  position: absolute;
+  top: 0;
+  left: 0;
+  z-index: 11;
+  width: 100%;
+  height: 100%;
+  -webkit-transition: opacity 0.5s ease, visibility 0.5s ease;
+  transition: opacity 0.5s ease, visibility 0.5s ease;
+  background: rgba(254, 254, 254, 0.25);
+  opacity: 0;
+  visibility: hidden;
+  overflow: hidden;
+}
+.js-off-canvas-overlay.is-visible {
+  opacity: 1;
+  visibility: visible;
+}
+.js-off-canvas-overlay.is-closable {
+  cursor: pointer;
+}
+.js-off-canvas-overlay.is-overlay-absolute {
+  position: absolute;
+}
+.js-off-canvas-overlay.is-overlay-fixed {
+  position: fixed;
+}
+
+.off-canvas-wrapper {
+  position: relative;
+  overflow: hidden;
+}
+
+.off-canvas {
+  z-index: 12;
+  -webkit-transition: -webkit-transform 0.5s ease;
+  transition: -webkit-transform 0.5s ease;
+  transition: transform 0.5s ease;
+  transition: transform 0.5s ease, -webkit-transform 0.5s ease;
+  -webkit-backface-visibility: hidden;
+          backface-visibility: hidden;
+  background: #e6e6e6;
+  position: fixed;
+}
+[data-whatinput=mouse] .off-canvas {
+  outline: 0;
+}
+.off-canvas.is-transition-push {
+  z-index: 12;
+}
+.off-canvas.is-closed {
+  visibility: hidden;
+}
+.off-canvas.is-transition-overlap {
+  z-index: 13;
+}
+.off-canvas.is-transition-overlap.is-open {
+  -webkit-box-shadow: 0 0 10px rgba(10, 10, 10, 0.7);
+          box-shadow: 0 0 10px rgba(10, 10, 10, 0.7);
+}
+.off-canvas.is-open {
+  -webkit-transform: translate(0, 0);
+          transform: translate(0, 0);
+}
+
+.off-canvas-absolute {
+  z-index: 12;
+  -webkit-transition: -webkit-transform 0.5s ease;
+  transition: -webkit-transform 0.5s ease;
+  transition: transform 0.5s ease;
+  transition: transform 0.5s ease, -webkit-transform 0.5s ease;
+  -webkit-backface-visibility: hidden;
+          backface-visibility: hidden;
+  background: #e6e6e6;
+  position: absolute;
+}
+[data-whatinput=mouse] .off-canvas-absolute {
+  outline: 0;
+}
+.off-canvas-absolute.is-transition-push {
+  z-index: 12;
+}
+.off-canvas-absolute.is-closed {
+  visibility: hidden;
+}
+.off-canvas-absolute.is-transition-overlap {
+  z-index: 13;
+}
+.off-canvas-absolute.is-transition-overlap.is-open {
+  -webkit-box-shadow: 0 0 10px rgba(10, 10, 10, 0.7);
+          box-shadow: 0 0 10px rgba(10, 10, 10, 0.7);
+}
+.off-canvas-absolute.is-open {
+  -webkit-transform: translate(0, 0);
+          transform: translate(0, 0);
+}
+
+.position-left {
+  top: 0;
+  left: 0;
+  height: 100%;
+  overflow-y: auto;
+  -webkit-overflow-scrolling: touch;
+  width: 250px;
+  -webkit-transform: translateX(-250px);
+          transform: translateX(-250px);
+}
+.off-canvas-content .off-canvas.position-left {
+  -webkit-transform: translateX(-250px);
+          transform: translateX(-250px);
+}
+.off-canvas-content .off-canvas.position-left.is-transition-overlap.is-open {
+  -webkit-transform: translate(0, 0);
+          transform: translate(0, 0);
+}
+
+.off-canvas-content.is-open-left.has-transition-push {
+  -webkit-transform: translateX(250px);
+          transform: translateX(250px);
+}
+
+.position-left.is-transition-push {
+  -webkit-box-shadow: inset -13px 0 20px -13px rgba(10, 10, 10, 0.25);
+          box-shadow: inset -13px 0 20px -13px rgba(10, 10, 10, 0.25);
+}
+
+.position-right {
+  top: 0;
+  right: 0;
+  height: 100%;
+  overflow-y: auto;
+  -webkit-overflow-scrolling: touch;
+  width: 250px;
+  -webkit-transform: translateX(250px);
+          transform: translateX(250px);
+}
+.off-canvas-content .off-canvas.position-right {
+  -webkit-transform: translateX(250px);
+          transform: translateX(250px);
+}
+.off-canvas-content .off-canvas.position-right.is-transition-overlap.is-open {
+  -webkit-transform: translate(0, 0);
+          transform: translate(0, 0);
+}
+
+.off-canvas-content.is-open-right.has-transition-push {
+  -webkit-transform: translateX(-250px);
+          transform: translateX(-250px);
+}
+
+.position-right.is-transition-push {
+  -webkit-box-shadow: inset 13px 0 20px -13px rgba(10, 10, 10, 0.25);
+          box-shadow: inset 13px 0 20px -13px rgba(10, 10, 10, 0.25);
+}
+
+.position-top {
+  top: 0;
+  left: 0;
+  width: 100%;
+  overflow-x: auto;
+  -webkit-overflow-scrolling: touch;
+  height: 250px;
+  -webkit-transform: translateY(-250px);
+          transform: translateY(-250px);
+}
+.off-canvas-content .off-canvas.position-top {
+  -webkit-transform: translateY(-250px);
+          transform: translateY(-250px);
+}
+.off-canvas-content .off-canvas.position-top.is-transition-overlap.is-open {
+  -webkit-transform: translate(0, 0);
+          transform: translate(0, 0);
+}
+
+.off-canvas-content.is-open-top.has-transition-push {
+  -webkit-transform: translateY(250px);
+          transform: translateY(250px);
+}
+
+.position-top.is-transition-push {
+  -webkit-box-shadow: inset 0 -13px 20px -13px rgba(10, 10, 10, 0.25);
+          box-shadow: inset 0 -13px 20px -13px rgba(10, 10, 10, 0.25);
+}
+
+.position-bottom {
+  bottom: 0;
+  left: 0;
+  width: 100%;
+  overflow-x: auto;
+  -webkit-overflow-scrolling: touch;
+  height: 250px;
+  -webkit-transform: translateY(250px);
+          transform: translateY(250px);
+}
+.off-canvas-content .off-canvas.position-bottom {
+  -webkit-transform: translateY(250px);
+          transform: translateY(250px);
+}
+.off-canvas-content .off-canvas.position-bottom.is-transition-overlap.is-open {
+  -webkit-transform: translate(0, 0);
+          transform: translate(0, 0);
+}
+
+.off-canvas-content.is-open-bottom.has-transition-push {
+  -webkit-transform: translateY(-250px);
+          transform: translateY(-250px);
+}
+
+.position-bottom.is-transition-push {
+  -webkit-box-shadow: inset 0 13px 20px -13px rgba(10, 10, 10, 0.25);
+          box-shadow: inset 0 13px 20px -13px rgba(10, 10, 10, 0.25);
+}
+
+.off-canvas-content {
+  -webkit-transform: none;
+          transform: none;
+  -webkit-backface-visibility: hidden;
+          backface-visibility: hidden;
+}
+.off-canvas-content.has-transition-overlap, .off-canvas-content.has-transition-push {
+  -webkit-transition: -webkit-transform 0.5s ease;
+  transition: -webkit-transform 0.5s ease;
+  transition: transform 0.5s ease;
+  transition: transform 0.5s ease, -webkit-transform 0.5s ease;
+}
+.off-canvas-content.has-transition-push {
+  -webkit-transform: translate(0, 0);
+          transform: translate(0, 0);
+}
+.off-canvas-content .off-canvas.is-open {
+  -webkit-transform: translate(0, 0);
+          transform: translate(0, 0);
+}
+
+@media print, screen and (min-width: 40em) {
+  .position-left.reveal-for-medium {
+    -webkit-transform: none;
+            transform: none;
+    z-index: 12;
+    -webkit-transition: none;
+    transition: none;
+    visibility: visible;
+  }
+  .position-left.reveal-for-medium .close-button {
+    display: none;
+  }
+  .off-canvas-content .position-left.reveal-for-medium {
+    -webkit-transform: none;
+            transform: none;
+  }
+  .off-canvas-content.has-reveal-left {
+    margin-left: 250px;
+  }
+  .position-left.reveal-for-medium ~ .off-canvas-content {
+    margin-left: 250px;
+  }
+  .position-right.reveal-for-medium {
+    -webkit-transform: none;
+            transform: none;
+    z-index: 12;
+    -webkit-transition: none;
+    transition: none;
+    visibility: visible;
+  }
+  .position-right.reveal-for-medium .close-button {
+    display: none;
+  }
+  .off-canvas-content .position-right.reveal-for-medium {
+    -webkit-transform: none;
+            transform: none;
+  }
+  .off-canvas-content.has-reveal-right {
+    margin-right: 250px;
+  }
+  .position-right.reveal-for-medium ~ .off-canvas-content {
+    margin-right: 250px;
+  }
+  .position-top.reveal-for-medium {
+    -webkit-transform: none;
+            transform: none;
+    z-index: 12;
+    -webkit-transition: none;
+    transition: none;
+    visibility: visible;
+  }
+  .position-top.reveal-for-medium .close-button {
+    display: none;
+  }
+  .off-canvas-content .position-top.reveal-for-medium {
+    -webkit-transform: none;
+            transform: none;
+  }
+  .off-canvas-content.has-reveal-top {
+    margin-top: 250px;
+  }
+  .position-top.reveal-for-medium ~ .off-canvas-content {
+    margin-top: 250px;
+  }
+  .position-bottom.reveal-for-medium {
+    -webkit-transform: none;
+            transform: none;
+    z-index: 12;
+    -webkit-transition: none;
+    transition: none;
+    visibility: visible;
+  }
+  .position-bottom.reveal-for-medium .close-button {
+    display: none;
+  }
+  .off-canvas-content .position-bottom.reveal-for-medium {
+    -webkit-transform: none;
+            transform: none;
+  }
+  .off-canvas-content.has-reveal-bottom {
+    margin-bottom: 250px;
+  }
+  .position-bottom.reveal-for-medium ~ .off-canvas-content {
+    margin-bottom: 250px;
+  }
+}
+@media print, screen and (min-width: 64em) {
+  .position-left.reveal-for-large {
+    -webkit-transform: none;
+            transform: none;
+    z-index: 12;
+    -webkit-transition: none;
+    transition: none;
+    visibility: visible;
+  }
+  .position-left.reveal-for-large .close-button {
+    display: none;
+  }
+  .off-canvas-content .position-left.reveal-for-large {
+    -webkit-transform: none;
+            transform: none;
+  }
+  .off-canvas-content.has-reveal-left {
+    margin-left: 250px;
+  }
+  .position-left.reveal-for-large ~ .off-canvas-content {
+    margin-left: 250px;
+  }
+  .position-right.reveal-for-large {
+    -webkit-transform: none;
+            transform: none;
+    z-index: 12;
+    -webkit-transition: none;
+    transition: none;
+    visibility: visible;
+  }
+  .position-right.reveal-for-large .close-button {
+    display: none;
+  }
+  .off-canvas-content .position-right.reveal-for-large {
+    -webkit-transform: none;
+            transform: none;
+  }
+  .off-canvas-content.has-reveal-right {
+    margin-right: 250px;
+  }
+  .position-right.reveal-for-large ~ .off-canvas-content {
+    margin-right: 250px;
+  }
+  .position-top.reveal-for-large {
+    -webkit-transform: none;
+            transform: none;
+    z-index: 12;
+    -webkit-transition: none;
+    transition: none;
+    visibility: visible;
+  }
+  .position-top.reveal-for-large .close-button {
+    display: none;
+  }
+  .off-canvas-content .position-top.reveal-for-large {
+    -webkit-transform: none;
+            transform: none;
+  }
+  .off-canvas-content.has-reveal-top {
+    margin-top: 250px;
+  }
+  .position-top.reveal-for-large ~ .off-canvas-content {
+    margin-top: 250px;
+  }
+  .position-bottom.reveal-for-large {
+    -webkit-transform: none;
+            transform: none;
+    z-index: 12;
+    -webkit-transition: none;
+    transition: none;
+    visibility: visible;
+  }
+  .position-bottom.reveal-for-large .close-button {
+    display: none;
+  }
+  .off-canvas-content .position-bottom.reveal-for-large {
+    -webkit-transform: none;
+            transform: none;
+  }
+  .off-canvas-content.has-reveal-bottom {
+    margin-bottom: 250px;
+  }
+  .position-bottom.reveal-for-large ~ .off-canvas-content {
+    margin-bottom: 250px;
+  }
+}
+@media print, screen and (min-width: 40em) {
+  .off-canvas.in-canvas-for-medium {
+    visibility: visible;
+    height: auto;
+    position: static;
+    background: none;
+    width: auto;
+    overflow: visible;
+    -webkit-transition: none;
+    transition: none;
+  }
+  .off-canvas.in-canvas-for-medium.position-left, .off-canvas.in-canvas-for-medium.position-right, .off-canvas.in-canvas-for-medium.position-top, .off-canvas.in-canvas-for-medium.position-bottom {
+    -webkit-box-shadow: none;
+            box-shadow: none;
+    -webkit-transform: none;
+            transform: none;
+  }
+  .off-canvas.in-canvas-for-medium .close-button {
+    display: none;
+  }
+}
+@media print, screen and (min-width: 64em) {
+  .off-canvas.in-canvas-for-large {
+    visibility: visible;
+    height: auto;
+    position: static;
+    background: none;
+    width: auto;
+    overflow: visible;
+    -webkit-transition: none;
+    transition: none;
+  }
+  .off-canvas.in-canvas-for-large.position-left, .off-canvas.in-canvas-for-large.position-right, .off-canvas.in-canvas-for-large.position-top, .off-canvas.in-canvas-for-large.position-bottom {
+    -webkit-box-shadow: none;
+            box-shadow: none;
+    -webkit-transform: none;
+            transform: none;
+  }
+  .off-canvas.in-canvas-for-large .close-button {
+    display: none;
+  }
+}
+html.is-reveal-open {
+  position: fixed;
+  width: 100%;
+  overflow-y: hidden;
+}
+html.is-reveal-open.zf-has-scroll {
+  overflow-y: scroll;
+  -webkit-overflow-scrolling: touch;
+}
+html.is-reveal-open body {
+  overflow-y: hidden;
+}
+
+.reveal-overlay {
+  position: fixed;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  z-index: 1005;
+  display: none;
+  background-color: rgba(10, 10, 10, 0.45);
+  overflow-y: auto;
+  -webkit-overflow-scrolling: touch;
+}
+
+.reveal {
+  position: relative;
+  top: 100px;
+  margin-right: auto;
+  margin-left: auto;
+  overflow-y: auto;
+  -webkit-overflow-scrolling: touch;
+  z-index: 1006;
+  -webkit-backface-visibility: hidden;
+          backface-visibility: hidden;
+  display: none;
+  padding: 1rem;
+  border: 1px solid #cacaca;
+  border-radius: 0;
+  background-color: #fefefe;
+}
+[data-whatinput=mouse] .reveal {
+  outline: 0;
+}
+@media print, screen and (min-width: 40em) {
+  .reveal {
+    min-height: 0;
+  }
+}
+.reveal .column {
+  min-width: 0;
+}
+.reveal > :last-child {
+  margin-bottom: 0;
+}
+@media print, screen and (min-width: 40em) {
+  .reveal {
+    width: 600px;
+    max-width: 75rem;
+  }
+}
+.reveal.collapse {
+  padding: 0;
+}
+@media print, screen and (min-width: 40em) {
+  .reveal.tiny {
+    width: 30%;
+    max-width: 75rem;
+  }
+}
+@media print, screen and (min-width: 40em) {
+  .reveal.small {
+    width: 50%;
+    max-width: 75rem;
+  }
+}
+@media print, screen and (min-width: 40em) {
+  .reveal.large {
+    width: 90%;
+    max-width: 75rem;
+  }
+}
+.reveal.full {
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  width: 100%;
+  max-width: none;
+  height: 100%;
+  min-height: 100%;
+  margin-left: 0;
+  border: 0;
+  border-radius: 0;
+}
+@media print, screen and (max-width: 39.99875em) {
+  .reveal {
+    top: 0;
+    right: 0;
+    bottom: 0;
+    left: 0;
+    width: 100%;
+    max-width: none;
+    height: 100%;
+    min-height: 100%;
+    margin-left: 0;
+    border: 0;
+    border-radius: 0;
+  }
+}
+.reveal.without-overlay {
+  position: fixed;
+}
+
+.sticky-container {
+  position: relative;
+}
+
+.sticky {
+  position: relative;
+  z-index: 0;
+  -webkit-transform: translate3d(0, 0, 0);
+          transform: translate3d(0, 0, 0);
+}
+
+.sticky.is-stuck {
+  position: fixed;
+  z-index: 5;
+  width: 100%;
+}
+.sticky.is-stuck.is-at-top {
+  top: 0;
+}
+.sticky.is-stuck.is-at-bottom {
+  bottom: 0;
+}
+
+.sticky.is-anchored {
+  position: relative;
+  right: auto;
+  left: auto;
+}
+.sticky.is-anchored.is-at-bottom {
+  bottom: 0;
+}
+
+.title-bar {
+  padding: 0.5rem;
+  background: #0a0a0a;
+  color: #fefefe;
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -webkit-box-pack: start;
+      -ms-flex-pack: start;
+          justify-content: flex-start;
+  -webkit-box-align: center;
+      -ms-flex-align: center;
+          align-items: center;
+}
+.title-bar .menu-icon {
+  margin-left: 0.25rem;
+  margin-right: 0.25rem;
+}
+
+.title-bar-left,
+.title-bar-right {
+  -webkit-box-flex: 1;
+      -ms-flex: 1 1 0px;
+          flex: 1 1 0px;
+}
+
+.title-bar-right {
+  text-align: right;
+}
+
+.title-bar-title {
+  display: inline-block;
+  vertical-align: middle;
+  font-weight: bold;
+}
+
+.top-bar {
+  padding: 0.5rem;
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -ms-flex-wrap: nowrap;
+      flex-wrap: nowrap;
+  -webkit-box-pack: justify;
+      -ms-flex-pack: justify;
+          justify-content: space-between;
+  -webkit-box-align: center;
+      -ms-flex-align: center;
+          align-items: center;
+}
+.top-bar,
+.top-bar ul {
+  background-color: #e6e6e6;
+}
+.top-bar input {
+  max-width: 200px;
+  margin-right: 1rem;
+}
+.top-bar .input-group-field {
+  width: 100%;
+  margin-right: 0;
+}
+.top-bar input.button {
+  width: auto;
+}
+
+.top-bar {
+  -ms-flex-wrap: wrap;
+      flex-wrap: wrap;
+}
+.top-bar .top-bar-left,
+.top-bar .top-bar-right {
+  -webkit-box-flex: 0;
+      -ms-flex: 0 0 100%;
+          flex: 0 0 100%;
+  max-width: 100%;
+}
+
+@media print, screen and (min-width: 40em) {
+  .top-bar {
+    -ms-flex-wrap: nowrap;
+        flex-wrap: nowrap;
+  }
+  .top-bar .top-bar-left {
+    -webkit-box-flex: 1;
+        -ms-flex: 1 1 auto;
+            flex: 1 1 auto;
+    margin-right: auto;
+  }
+  .top-bar .top-bar-right {
+    -webkit-box-flex: 0;
+        -ms-flex: 0 1 auto;
+            flex: 0 1 auto;
+    margin-left: auto;
+  }
+}
+@media print, screen and (max-width: 63.99875em) {
+  .top-bar.stacked-for-medium {
+    -ms-flex-wrap: wrap;
+        flex-wrap: wrap;
+  }
+  .top-bar.stacked-for-medium .top-bar-left,
+  .top-bar.stacked-for-medium .top-bar-right {
+    -webkit-box-flex: 0;
+        -ms-flex: 0 0 100%;
+            flex: 0 0 100%;
+    max-width: 100%;
+  }
+}
+@media print, screen and (max-width: 74.99875em) {
+  .top-bar.stacked-for-large {
+    -ms-flex-wrap: wrap;
+        flex-wrap: wrap;
+  }
+  .top-bar.stacked-for-large .top-bar-left,
+  .top-bar.stacked-for-large .top-bar-right {
+    -webkit-box-flex: 0;
+        -ms-flex: 0 0 100%;
+            flex: 0 0 100%;
+    max-width: 100%;
+  }
+}
+
+.top-bar-title {
+  -webkit-box-flex: 0;
+      -ms-flex: 0 0 auto;
+          flex: 0 0 auto;
+  margin: 0.5rem 1rem 0.5rem 0;
+}
+
+.top-bar-left,
+.top-bar-right {
+  -webkit-box-flex: 0;
+      -ms-flex: 0 0 auto;
+          flex: 0 0 auto;
+}
+
+.float-left {
+  float: left !important;
+}
+
+.float-right {
+  float: right !important;
+}
+
+.float-center {
+  display: block;
+  margin-right: auto;
+  margin-left: auto;
+}
+
+.clearfix::before, .clearfix::after {
+  display: table;
+  content: " ";
+  -ms-flex-preferred-size: 0;
+      flex-basis: 0;
+  -webkit-box-ordinal-group: 2;
+      -ms-flex-order: 1;
+          order: 1;
+}
+.clearfix::after {
+  clear: both;
+}
+
+.align-left {
+  -webkit-box-pack: start;
+      -ms-flex-pack: start;
+          justify-content: flex-start;
+}
+
+.align-right {
+  -webkit-box-pack: end;
+      -ms-flex-pack: end;
+          justify-content: flex-end;
+}
+
+.align-center {
+  -webkit-box-pack: center;
+      -ms-flex-pack: center;
+          justify-content: center;
+}
+
+.align-justify {
+  -webkit-box-pack: justify;
+      -ms-flex-pack: justify;
+          justify-content: space-between;
+}
+
+.align-spaced {
+  -ms-flex-pack: distribute;
+      justify-content: space-around;
+}
+
+.align-left.vertical.menu > li > a {
+  -webkit-box-pack: start;
+      -ms-flex-pack: start;
+          justify-content: flex-start;
+}
+
+.align-right.vertical.menu > li > a {
+  -webkit-box-pack: end;
+      -ms-flex-pack: end;
+          justify-content: flex-end;
+}
+
+.align-center.vertical.menu > li > a {
+  -webkit-box-pack: center;
+      -ms-flex-pack: center;
+          justify-content: center;
+}
+
+.align-top {
+  -webkit-box-align: start;
+      -ms-flex-align: start;
+          align-items: flex-start;
+}
+
+.align-self-top {
+  -ms-flex-item-align: start;
+      align-self: flex-start;
+}
+
+.align-bottom {
+  -webkit-box-align: end;
+      -ms-flex-align: end;
+          align-items: flex-end;
+}
+
+.align-self-bottom {
+  -ms-flex-item-align: end;
+      align-self: flex-end;
+}
+
+.align-middle {
+  -webkit-box-align: center;
+      -ms-flex-align: center;
+          align-items: center;
+}
+
+.align-self-middle {
+  -ms-flex-item-align: center;
+      align-self: center;
+}
+
+.align-stretch {
+  -webkit-box-align: stretch;
+      -ms-flex-align: stretch;
+          align-items: stretch;
+}
+
+.align-self-stretch {
+  -ms-flex-item-align: stretch;
+      align-self: stretch;
+}
+
+.align-center-middle {
+  -webkit-box-pack: center;
+      -ms-flex-pack: center;
+          justify-content: center;
+  -webkit-box-align: center;
+      -ms-flex-align: center;
+          align-items: center;
+  -ms-flex-line-pack: center;
+      align-content: center;
+}
+
+.small-order-1 {
+  -webkit-box-ordinal-group: 2;
+      -ms-flex-order: 1;
+          order: 1;
+}
+
+.small-order-2 {
+  -webkit-box-ordinal-group: 3;
+      -ms-flex-order: 2;
+          order: 2;
+}
+
+.small-order-3 {
+  -webkit-box-ordinal-group: 4;
+      -ms-flex-order: 3;
+          order: 3;
+}
+
+.small-order-4 {
+  -webkit-box-ordinal-group: 5;
+      -ms-flex-order: 4;
+          order: 4;
+}
+
+.small-order-5 {
+  -webkit-box-ordinal-group: 6;
+      -ms-flex-order: 5;
+          order: 5;
+}
+
+.small-order-6 {
+  -webkit-box-ordinal-group: 7;
+      -ms-flex-order: 6;
+          order: 6;
+}
+
+@media print, screen and (min-width: 40em) {
+  .medium-order-1 {
+    -webkit-box-ordinal-group: 2;
+        -ms-flex-order: 1;
+            order: 1;
+  }
+  .medium-order-2 {
+    -webkit-box-ordinal-group: 3;
+        -ms-flex-order: 2;
+            order: 2;
+  }
+  .medium-order-3 {
+    -webkit-box-ordinal-group: 4;
+        -ms-flex-order: 3;
+            order: 3;
+  }
+  .medium-order-4 {
+    -webkit-box-ordinal-group: 5;
+        -ms-flex-order: 4;
+            order: 4;
+  }
+  .medium-order-5 {
+    -webkit-box-ordinal-group: 6;
+        -ms-flex-order: 5;
+            order: 5;
+  }
+  .medium-order-6 {
+    -webkit-box-ordinal-group: 7;
+        -ms-flex-order: 6;
+            order: 6;
+  }
+}
+@media print, screen and (min-width: 64em) {
+  .large-order-1 {
+    -webkit-box-ordinal-group: 2;
+        -ms-flex-order: 1;
+            order: 1;
+  }
+  .large-order-2 {
+    -webkit-box-ordinal-group: 3;
+        -ms-flex-order: 2;
+            order: 2;
+  }
+  .large-order-3 {
+    -webkit-box-ordinal-group: 4;
+        -ms-flex-order: 3;
+            order: 3;
+  }
+  .large-order-4 {
+    -webkit-box-ordinal-group: 5;
+        -ms-flex-order: 4;
+            order: 4;
+  }
+  .large-order-5 {
+    -webkit-box-ordinal-group: 6;
+        -ms-flex-order: 5;
+            order: 5;
+  }
+  .large-order-6 {
+    -webkit-box-ordinal-group: 7;
+        -ms-flex-order: 6;
+            order: 6;
+  }
+}
+.flex-container {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+}
+
+.flex-child-auto {
+  -webkit-box-flex: 1;
+      -ms-flex: 1 1 auto;
+          flex: 1 1 auto;
+}
+
+.flex-child-grow {
+  -webkit-box-flex: 1;
+      -ms-flex: 1 0 auto;
+          flex: 1 0 auto;
+}
+
+.flex-child-shrink {
+  -webkit-box-flex: 0;
+      -ms-flex: 0 1 auto;
+          flex: 0 1 auto;
+}
+
+.flex-dir-row {
+  -webkit-box-orient: horizontal;
+  -webkit-box-direction: normal;
+      -ms-flex-direction: row;
+          flex-direction: row;
+}
+
+.flex-dir-row-reverse {
+  -webkit-box-orient: horizontal;
+  -webkit-box-direction: reverse;
+      -ms-flex-direction: row-reverse;
+          flex-direction: row-reverse;
+}
+
+.flex-dir-column {
+  -webkit-box-orient: vertical;
+  -webkit-box-direction: normal;
+      -ms-flex-direction: column;
+          flex-direction: column;
+}
+
+.flex-dir-column-reverse {
+  -webkit-box-orient: vertical;
+  -webkit-box-direction: reverse;
+      -ms-flex-direction: column-reverse;
+          flex-direction: column-reverse;
+}
+
+@media print, screen and (min-width: 40em) {
+  .medium-flex-container {
+    display: -webkit-box;
+    display: -ms-flexbox;
+    display: flex;
+  }
+  .medium-flex-child-auto {
+    -webkit-box-flex: 1;
+        -ms-flex: 1 1 auto;
+            flex: 1 1 auto;
+  }
+  .medium-flex-child-grow {
+    -webkit-box-flex: 1;
+        -ms-flex: 1 0 auto;
+            flex: 1 0 auto;
+  }
+  .medium-flex-child-shrink {
+    -webkit-box-flex: 0;
+        -ms-flex: 0 1 auto;
+            flex: 0 1 auto;
+  }
+  .medium-flex-dir-row {
+    -webkit-box-orient: horizontal;
+    -webkit-box-direction: normal;
+        -ms-flex-direction: row;
+            flex-direction: row;
+  }
+  .medium-flex-dir-row-reverse {
+    -webkit-box-orient: horizontal;
+    -webkit-box-direction: reverse;
+        -ms-flex-direction: row-reverse;
+            flex-direction: row-reverse;
+  }
+  .medium-flex-dir-column {
+    -webkit-box-orient: vertical;
+    -webkit-box-direction: normal;
+        -ms-flex-direction: column;
+            flex-direction: column;
+  }
+  .medium-flex-dir-column-reverse {
+    -webkit-box-orient: vertical;
+    -webkit-box-direction: reverse;
+        -ms-flex-direction: column-reverse;
+            flex-direction: column-reverse;
+  }
+}
+@media print, screen and (min-width: 64em) {
+  .large-flex-container {
+    display: -webkit-box;
+    display: -ms-flexbox;
+    display: flex;
+  }
+  .large-flex-child-auto {
+    -webkit-box-flex: 1;
+        -ms-flex: 1 1 auto;
+            flex: 1 1 auto;
+  }
+  .large-flex-child-grow {
+    -webkit-box-flex: 1;
+        -ms-flex: 1 0 auto;
+            flex: 1 0 auto;
+  }
+  .large-flex-child-shrink {
+    -webkit-box-flex: 0;
+        -ms-flex: 0 1 auto;
+            flex: 0 1 auto;
+  }
+  .large-flex-dir-row {
+    -webkit-box-orient: horizontal;
+    -webkit-box-direction: normal;
+        -ms-flex-direction: row;
+            flex-direction: row;
+  }
+  .large-flex-dir-row-reverse {
+    -webkit-box-orient: horizontal;
+    -webkit-box-direction: reverse;
+        -ms-flex-direction: row-reverse;
+            flex-direction: row-reverse;
+  }
+  .large-flex-dir-column {
+    -webkit-box-orient: vertical;
+    -webkit-box-direction: normal;
+        -ms-flex-direction: column;
+            flex-direction: column;
+  }
+  .large-flex-dir-column-reverse {
+    -webkit-box-orient: vertical;
+    -webkit-box-direction: reverse;
+        -ms-flex-direction: column-reverse;
+            flex-direction: column-reverse;
+  }
+}
+.hide {
+  display: none !important;
+}
+
+.invisible {
+  visibility: hidden;
+}
+
+.visible {
+  visibility: visible;
+}
+
+@media print, screen and (max-width: 39.99875em) {
+  .hide-for-small-only {
+    display: none !important;
+  }
+}
+
+@media screen and (max-width: 0em), screen and (min-width: 40em) {
+  .show-for-small-only {
+    display: none !important;
+  }
+}
+
+@media print, screen and (min-width: 40em) {
+  .hide-for-medium {
+    display: none !important;
+  }
+}
+
+@media screen and (max-width: 39.99875em) {
+  .show-for-medium {
+    display: none !important;
+  }
+}
+
+@media print, screen and (min-width: 40em) and (max-width: 63.99875em) {
+  .hide-for-medium-only {
+    display: none !important;
+  }
+}
+
+@media screen and (max-width: 39.99875em), screen and (min-width: 64em) {
+  .show-for-medium-only {
+    display: none !important;
+  }
+}
+
+@media print, screen and (min-width: 64em) {
+  .hide-for-large {
+    display: none !important;
+  }
+}
+
+@media screen and (max-width: 63.99875em) {
+  .show-for-large {
+    display: none !important;
+  }
+}
+
+@media print, screen and (min-width: 64em) and (max-width: 74.99875em) {
+  .hide-for-large-only {
+    display: none !important;
+  }
+}
+
+@media screen and (max-width: 63.99875em), screen and (min-width: 75em) {
+  .show-for-large-only {
+    display: none !important;
+  }
+}
+
+.show-for-sr,
+.show-on-focus {
+  position: absolute !important;
+  width: 1px !important;
+  height: 1px !important;
+  padding: 0 !important;
+  overflow: hidden !important;
+  clip: rect(0, 0, 0, 0) !important;
+  white-space: nowrap !important;
+  border: 0 !important;
+}
+
+.show-on-focus:active, .show-on-focus:focus {
+  position: static !important;
+  width: auto !important;
+  height: auto !important;
+  overflow: visible !important;
+  clip: auto !important;
+  white-space: normal !important;
+}
+
+.show-for-landscape,
+.hide-for-portrait {
+  display: block !important;
+}
+@media screen and (orientation: landscape) {
+  .show-for-landscape,
+  .hide-for-portrait {
+    display: block !important;
+  }
+}
+@media screen and (orientation: portrait) {
+  .show-for-landscape,
+  .hide-for-portrait {
+    display: none !important;
+  }
+}
+
+.hide-for-landscape,
+.show-for-portrait {
+  display: none !important;
+}
+@media screen and (orientation: landscape) {
+  .hide-for-landscape,
+  .show-for-portrait {
+    display: none !important;
+  }
+}
+@media screen and (orientation: portrait) {
+  .hide-for-landscape,
+  .show-for-portrait {
+    display: block !important;
+  }
+}
+
+.show-for-dark-mode {
+  display: none;
+}
+
+.hide-for-dark-mode {
+  display: block;
+}
+
+@media screen and (prefers-color-scheme: dark) {
+  .show-for-dark-mode {
+    display: block !important;
+  }
+  .hide-for-dark-mode {
+    display: none !important;
+  }
+}
+.show-for-ie {
+  display: none;
+}
+
+@media all and (-ms-high-contrast: none), (-ms-high-contrast: active) {
+  .show-for-ie {
+    display: block !important;
+  }
+  .hide-for-ie {
+    display: none !important;
+  }
+}
+.show-for-sticky {
+  display: none;
+}
+
+.is-stuck .show-for-sticky {
+  display: block;
+}
+
+.is-stuck .hide-for-sticky {
+  display: none;
+}
+/*# sourceMappingURL=foundation.css.map */
\ No newline at end of file
diff --git a/test/js/bun/css/files/foundation.min.css b/test/js/bun/css/files/foundation.min.css
new file mode 100644
index 0000000000..bbb2527356
--- /dev/null
+++ b/test/js/bun/css/files/foundation.min.css
@@ -0,0 +1 @@
+@media print,screen and (width>=40em){.reveal.large,.reveal.small,.reveal.tiny,.reveal{margin:0 auto;left:auto;right:auto}}html{-webkit-text-size-adjust:100%;line-height:1.15}body{margin:0}h1{margin:.67em 0;font-size:2em}hr{-webkit-box-sizing:content-box;box-sizing:content-box;height:0;overflow:visible}pre{font-family:monospace;font-size:1em}a{background-color:#0000}abbr[title]{border-bottom:0;text-decoration:underline dotted}b,strong{font-weight:bolder}code,kbd,samp{font-family:monospace;font-size:1em}small{font-size:80%}sub,sup{vertical-align:baseline;font-size:75%;line-height:0;position:relative}sub{bottom:-.25em}sup{top:-.5em}img{border-style:none}button,input,optgroup,select,textarea{margin:0;font-family:inherit;font-size:100%;line-height:1.15}button,input{overflow:visible}button,select{text-transform:none}button,[type=button],[type=reset],[type=submit]{-webkit-appearance:button}button::-moz-focus-inner,[type=button]::-moz-focus-inner,[type=reset]::-moz-focus-inner,[type=submit]::-moz-focus-inner{border-style:none;padding:0}button:-moz-focusring,[type=button]:-moz-focusring,[type=reset]:-moz-focusring,[type=submit]:-moz-focusring{outline:1px dotted buttontext}fieldset{padding:.35em .75em .625em}legend{-webkit-box-sizing:border-box;box-sizing:border-box;color:inherit;white-space:normal;max-width:100%;padding:0;display:table}progress{vertical-align:baseline}textarea{overflow:auto}[type=checkbox],[type=radio]{-webkit-box-sizing:border-box;box-sizing:border-box;padding:0}[type=number]::-webkit-inner-spin-button,[type=number]::-webkit-outer-spin-button{height:auto}[type=search]{-webkit-appearance:textfield;outline-offset:-2px}[type=search]::-webkit-search-decoration{-webkit-appearance:none}::-webkit-file-upload-button{-webkit-appearance:button;font:inherit}details{display:block}summary{display:list-item}template,[hidden]{display:none}[data-whatintent=mouse] *,[data-whatintent=mouse] :focus,[data-whatintent=touch] *,[data-whatintent=touch] :focus,[data-whatinput=mouse] *,[data-whatinput=mouse] :focus,[data-whatinput=touch] *,[data-whatinput=touch] :focus{outline:none}[draggable=false]{-webkit-touch-callout:none;-webkit-user-select:none}.foundation-mq{font-family:"small=0em&medium=40em&large=64em&xlarge=75em&xxlarge=90em"}html{-webkit-box-sizing:border-box;box-sizing:border-box;font-size:100%}*,:before,:after{-webkit-box-sizing:inherit;box-sizing:inherit}body{color:#0a0a0a;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale;background:#fefefe;margin:0;padding:0;font-family:Helvetica Neue,Helvetica,Roboto,Arial,sans-serif;font-weight:400;line-height:1.5}img{vertical-align:middle;-ms-interpolation-mode:bicubic;max-width:100%;height:auto;display:inline-block}textarea{border-radius:0;height:auto;min-height:50px}select{-webkit-box-sizing:border-box;box-sizing:border-box;border-radius:0;width:100%}.map_canvas img,.map_canvas embed,.map_canvas object,.mqa-display img,.mqa-display embed,.mqa-display object{max-width:none!important}button{-webkit-appearance:none;-moz-appearance:none;appearance:none;cursor:auto;background:0 0;border:0;border-radius:0;padding:0;line-height:1}[data-whatinput=mouse] button{outline:0}pre{-webkit-overflow-scrolling:touch;overflow:auto}button,input,optgroup,select,textarea{font-family:inherit}.is-visible{display:block!important}.is-hidden{display:none!important}[type=text],[type=password],[type=date],[type=datetime],[type=datetime-local],[type=month],[type=week],[type=email],[type=number],[type=search],[type=tel],[type=time],[type=url],[type=color],textarea{-webkit-appearance:none;-moz-appearance:none;appearance:none;-webkit-box-sizing:border-box;box-sizing:border-box;color:#0a0a0a;background-color:#fefefe;border:1px solid #cacaca;border-radius:0;width:100%;height:2.4375rem;margin:0 0 1rem;padding:.5rem;font-family:inherit;font-size:1rem;font-weight:400;line-height:1.5;-webkit-transition:box-shadow .5s,border-color .25s ease-in-out,-webkit-box-shadow .5s;transition:box-shadow .5s,border-color .25s ease-in-out,-webkit-box-shadow .5s;display:block;-webkit-box-shadow:inset 0 1px 2px #0a0a0a1a;box-shadow:inset 0 1px 2px #0a0a0a1a}[type=text]:focus,[type=password]:focus,[type=date]:focus,[type=datetime]:focus,[type=datetime-local]:focus,[type=month]:focus,[type=week]:focus,[type=email]:focus,[type=number]:focus,[type=search]:focus,[type=tel]:focus,[type=time]:focus,[type=url]:focus,[type=color]:focus,textarea:focus{background-color:#fefefe;border:1px solid #8a8a8a;outline:none;-webkit-transition:box-shadow .5s,border-color .25s ease-in-out,-webkit-box-shadow .5s;transition:box-shadow .5s,border-color .25s ease-in-out,-webkit-box-shadow .5s;-webkit-box-shadow:0 0 5px #cacaca;box-shadow:0 0 5px #cacaca}textarea{max-width:100%}textarea[rows]{height:auto}input:disabled,input[readonly],textarea:disabled,textarea[readonly]{cursor:not-allowed;background-color:#e6e6e6}[type=submit],[type=button]{-webkit-appearance:none;-moz-appearance:none;appearance:none;border-radius:0}input[type=search]{-webkit-box-sizing:border-box;box-sizing:border-box}::-webkit-input-placeholder{color:#cacaca}::placeholder{color:#cacaca}:-ms-input-placeholder{color:#cacaca}::-moz-placeholder{color:#cacaca}::placeholder{color:#cacaca}[type=file],[type=checkbox],[type=radio]{margin:0 0 1rem}[type=checkbox]+label,[type=radio]+label{vertical-align:baseline;margin-bottom:0;margin-left:.5rem;margin-right:1rem;display:inline-block}[type=checkbox]+label[for],[type=radio]+label[for]{cursor:pointer}label>[type=checkbox],label>[type=radio]{margin-right:.5rem}[type=file]{width:100%}label{color:#0a0a0a;margin:0;font-size:.875rem;font-weight:400;line-height:1.8;display:block}label.middle{margin:0 0 1rem;padding:.5625rem 0;line-height:1.5}.help-text{color:#0a0a0a;margin-top:-.5rem;font-size:.8125rem;font-style:italic}.input-group{align-items:stretch;width:100%;margin-bottom:1rem;display:-webkit-box;display:-ms-flexbox;display:flex}.input-group>:first-child,.input-group>:first-child.input-group-button>*,.input-group>:last-child,.input-group>:last-child.input-group-button>*{border-radius:0}.input-group-button a,.input-group-button input,.input-group-button button,.input-group-button label,.input-group-button,.input-group-field,.input-group-label{white-space:nowrap;margin:0}.input-group-label{color:#0a0a0a;text-align:center;white-space:nowrap;background:#e6e6e6;border:1px solid #cacaca;-webkit-box-flex:0;-ms-flex:none;flex:none;align-items:center;padding:0 1rem;display:-webkit-box;display:-ms-flexbox;display:flex}.input-group-label:first-child{border-right:0}.input-group-label:last-child{border-left:0}.input-group-field{border-radius:0;-webkit-box-flex:1;-ms-flex:1 1 0;flex:1 1 0;min-width:0}.input-group-button{text-align:center;-webkit-box-flex:0;-ms-flex:none;flex:none;padding-top:0;padding-bottom:0;display:-webkit-box;display:-ms-flexbox;display:flex}.input-group-button a,.input-group-button input,.input-group-button button,.input-group-button label{align-self:stretch;height:auto;padding-top:0;padding-bottom:0;font-size:1rem}fieldset{border:0;margin:0;padding:0}legend{max-width:100%;margin-bottom:.5rem}.fieldset{border:1px solid #cacaca;margin:1.125rem 0;padding:1.25rem}.fieldset legend{margin:0 0 0 -.1875rem;padding:0 .1875rem}select{-webkit-appearance:none;-moz-appearance:none;appearance:none;color:#0a0a0a;background-color:#fefefe;background-image:url("data:image/svg+xml;utf8,<svg xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\" width=\"32\" height=\"24\" viewBox=\"0 0 32 24\"><polygon points=\"0,0 32,0 16,24\" style=\"fill: rgb%28138, 138, 138%29\"></polygon></svg>");background-position:right -1rem center;background-repeat:no-repeat;background-size:9px 6px;background-origin:content-box;border:1px solid #cacaca;border-radius:0;height:2.4375rem;margin:0 0 1rem;padding:.5rem 1.5rem .5rem .5rem;font-family:inherit;font-size:1rem;font-weight:400;line-height:1.5;-webkit-transition:box-shadow .5s,border-color .25s ease-in-out,-webkit-box-shadow .5s;transition:box-shadow .5s,border-color .25s ease-in-out,-webkit-box-shadow .5s}select:focus{background-color:#fefefe;border:1px solid #8a8a8a;outline:none;-webkit-transition:box-shadow .5s,border-color .25s ease-in-out,-webkit-box-shadow .5s;transition:box-shadow .5s,border-color .25s ease-in-out,-webkit-box-shadow .5s;-webkit-box-shadow:0 0 5px #cacaca;box-shadow:0 0 5px #cacaca}select:disabled{cursor:not-allowed;background-color:#e6e6e6}select::-ms-expand{display:none}select[multiple]{background-image:none;height:auto}select:not([multiple]){padding-top:0;padding-bottom:0}.is-invalid-input:not(:focus){background-color:#f9ecea;border-color:#cc4b37}.is-invalid-input:not(:focus)::-webkit-input-placeholder{color:#cc4b37}.is-invalid-input:not(:focus):-ms-input-placeholder{color:#cc4b37}.is-invalid-input:not(:focus)::-moz-placeholder{color:#cc4b37}.is-invalid-input:not(:focus)::placeholder,.is-invalid-label{color:#cc4b37}.form-error{color:#cc4b37;margin-top:-.5rem;margin-bottom:1rem;font-size:.75rem;font-weight:700;display:none}.form-error.is-visible{display:block}div,dl,dt,dd,ul,ol,li,h1,h2,h3,h4,h5,h6,pre,form,p,blockquote,th,td{margin:0;padding:0}p{font-size:inherit;text-rendering:optimizeLegibility;margin-bottom:1rem;line-height:1.6}em,i{font-style:italic;line-height:inherit}strong,b{font-weight:700;line-height:inherit}small{font-size:80%;line-height:inherit}h1,.h1,h2,.h2,h3,.h3,h4,.h4,h5,.h5,h6,.h6{color:inherit;text-rendering:optimizeLegibility;font-family:Helvetica Neue,Helvetica,Roboto,Arial,sans-serif;font-style:normal;font-weight:400}h1 small,.h1 small,h2 small,.h2 small,h3 small,.h3 small,h4 small,.h4 small,h5 small,.h5 small,h6 small,.h6 small{color:#cacaca;line-height:0}h1,.h1{margin-top:0;margin-bottom:.5rem;font-size:1.5rem;line-height:1.4}h2,.h2{margin-top:0;margin-bottom:.5rem;font-size:1.25rem;line-height:1.4}h3,.h3{margin-top:0;margin-bottom:.5rem;font-size:1.1875rem;line-height:1.4}h4,.h4{margin-top:0;margin-bottom:.5rem;font-size:1.125rem;line-height:1.4}h5,.h5{margin-top:0;margin-bottom:.5rem;font-size:1.0625rem;line-height:1.4}h6,.h6{margin-top:0;margin-bottom:.5rem;font-size:1rem;line-height:1.4}@media print,screen and (width>=40em){h1,.h1{font-size:3rem}h2,.h2{font-size:2.5rem}h3,.h3{font-size:1.9375rem}h4,.h4{font-size:1.5625rem}h5,.h5{font-size:1.25rem}h6,.h6{font-size:1rem}}a{line-height:inherit;color:#1779ba;cursor:pointer;text-decoration:none}a:hover,a:focus{color:#1468a0}a img{border:0}hr{clear:both;border:0;border-bottom:1px solid #cacaca;max-width:75rem;height:0;margin:1.25rem auto}ul,ol,dl{margin-bottom:1rem;line-height:1.6;list-style-position:outside}li{font-size:inherit}ul{margin-left:1.25rem;list-style-type:disc}ol{margin-left:1.25rem}ul ul,ul ol,ol ul,ol ol{margin-bottom:0;margin-left:1.25rem}dl{margin-bottom:1rem}dl dt{margin-bottom:.3rem;font-weight:700}blockquote{border-left:1px solid #cacaca;margin:0 0 1rem;padding:.5625rem 1.25rem 0 1.1875rem}blockquote,blockquote p{color:#8a8a8a;line-height:1.6}abbr,abbr[title]{cursor:help;border-bottom:1px dotted #0a0a0a;text-decoration:none}figure{margin:0}kbd{color:#0a0a0a;background-color:#e6e6e6;margin:0;padding:.125rem .25rem 0;font-family:Consolas,Liberation Mono,Courier,monospace}.subheader{color:#8a8a8a;margin-top:.2rem;margin-bottom:.5rem;font-weight:400;line-height:1.4}.lead{font-size:125%;line-height:1.6}.stat{font-size:2.5rem;line-height:1}p+.stat{margin-top:-1rem}ul.no-bullet,ol.no-bullet{margin-left:0;list-style:none}.cite-block,cite{color:#8a8a8a;font-size:.8125rem;display:block}.cite-block:before,cite:before{content:"— "}.code-inline,code{color:#0a0a0a;word-wrap:break-word;background-color:#e6e6e6;border:1px solid #cacaca;max-width:100%;padding:.125rem .3125rem .0625rem;font-family:Consolas,Liberation Mono,Courier,monospace;font-weight:400;display:inline}.code-block{color:#0a0a0a;white-space:pre;background-color:#e6e6e6;border:1px solid #cacaca;margin-bottom:1.5rem;padding:1rem;font-family:Consolas,Liberation Mono,Courier,monospace;font-weight:400;display:block;overflow:auto}.text-left{text-align:left}.text-right{text-align:right}.text-center{text-align:center}.text-justify{text-align:justify}@media print,screen and (width>=40em){.medium-text-left{text-align:left}.medium-text-right{text-align:right}.medium-text-center{text-align:center}.medium-text-justify{text-align:justify}}@media print,screen and (width>=64em){.large-text-left{text-align:left}.large-text-right{text-align:right}.large-text-center{text-align:center}.large-text-justify{text-align:justify}}.show-for-print{display:none!important}@media print{*{-webkit-print-color-adjust:economy;print-color-adjust:economy;color:#000!important;-webkit-box-shadow:none!important;box-shadow:none!important;text-shadow:none!important;background:0 0!important}.show-for-print{display:block!important}.hide-for-print{display:none!important}table.show-for-print{display:table!important}thead.show-for-print{display:table-header-group!important}tbody.show-for-print{display:table-row-group!important}tr.show-for-print{display:table-row!important}td.show-for-print,th.show-for-print{display:table-cell!important}a,a:visited{text-decoration:underline}a[href]:after{content:" (" attr(href)")"}.ir a:after,a[href^=javascript\:]:after,a[href^=\#]:after{content:""}abbr[title]:after{content:" (" attr(title)")"}pre,blockquote{page-break-inside:avoid;border:1px solid #8a8a8a}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100%!important}@page{margin:.5cm}p,h2,h3{orphans:3;widows:3}h2,h3{page-break-after:avoid}.print-break-inside{page-break-inside:auto}}.grid-container{max-width:75rem;margin-left:auto;margin-right:auto;padding-left:.625rem;padding-right:.625rem}@media print,screen and (width>=40em){.grid-container{padding-left:.9375rem;padding-right:.9375rem}}.grid-container.fluid{max-width:100%;margin-left:auto;margin-right:auto;padding-left:.625rem;padding-right:.625rem}@media print,screen and (width>=40em){.grid-container.fluid{padding-left:.9375rem;padding-right:.9375rem}}.grid-container.full{max-width:100%;margin-left:auto;margin-right:auto;padding-left:0;padding-right:0}.grid-x{-webkit-box-orient:horizontal;-webkit-box-direction:normal;-ms-flex-flow:wrap;flex-flow:wrap;display:-webkit-box;display:-ms-flexbox;display:flex}.cell{-webkit-box-flex:0;-ms-flex:none;flex:none;width:100%;min-width:0;min-height:0}.cell.auto{-webkit-box-flex:1;-ms-flex:1 1 0;flex:1 1 0}.cell.shrink{-webkit-box-flex:0;-ms-flex:none;flex:none}.grid-x>.auto,.grid-x>.shrink{width:auto}.grid-x>.small-shrink,.grid-x>.small-full,.grid-x>.small-1,.grid-x>.small-2,.grid-x>.small-3,.grid-x>.small-4,.grid-x>.small-5,.grid-x>.small-6,.grid-x>.small-7,.grid-x>.small-8,.grid-x>.small-9,.grid-x>.small-10,.grid-x>.small-11,.grid-x>.small-12{-ms-flex-preferred-size:auto;flex-basis:auto}@media print,screen and (width>=40em){.grid-x>.medium-shrink,.grid-x>.medium-full,.grid-x>.medium-1,.grid-x>.medium-2,.grid-x>.medium-3,.grid-x>.medium-4,.grid-x>.medium-5,.grid-x>.medium-6,.grid-x>.medium-7,.grid-x>.medium-8,.grid-x>.medium-9,.grid-x>.medium-10,.grid-x>.medium-11,.grid-x>.medium-12{-ms-flex-preferred-size:auto;flex-basis:auto}}@media print,screen and (width>=64em){.grid-x>.large-shrink,.grid-x>.large-full,.grid-x>.large-1,.grid-x>.large-2,.grid-x>.large-3,.grid-x>.large-4,.grid-x>.large-5,.grid-x>.large-6,.grid-x>.large-7,.grid-x>.large-8,.grid-x>.large-9,.grid-x>.large-10,.grid-x>.large-11,.grid-x>.large-12{-ms-flex-preferred-size:auto;flex-basis:auto}}.grid-x>.small-12,.grid-x>.small-11,.grid-x>.small-10,.grid-x>.small-9,.grid-x>.small-8,.grid-x>.small-7,.grid-x>.small-6,.grid-x>.small-5,.grid-x>.small-4,.grid-x>.small-3,.grid-x>.small-2,.grid-x>.small-1{-webkit-box-flex:0;-ms-flex:none;flex:none}.grid-x>.small-1{width:8.33333%}.grid-x>.small-2{width:16.6667%}.grid-x>.small-3{width:25%}.grid-x>.small-4{width:33.3333%}.grid-x>.small-5{width:41.6667%}.grid-x>.small-6{width:50%}.grid-x>.small-7{width:58.3333%}.grid-x>.small-8{width:66.6667%}.grid-x>.small-9{width:75%}.grid-x>.small-10{width:83.3333%}.grid-x>.small-11{width:91.6667%}.grid-x>.small-12{width:100%}@media print,screen and (width>=40em){.grid-x>.medium-auto{-webkit-box-flex:1;-ms-flex:1 1 0;flex:1 1 0;width:auto}.grid-x>.medium-12,.grid-x>.medium-11,.grid-x>.medium-10,.grid-x>.medium-9,.grid-x>.medium-8,.grid-x>.medium-7,.grid-x>.medium-6,.grid-x>.medium-5,.grid-x>.medium-4,.grid-x>.medium-3,.grid-x>.medium-2,.grid-x>.medium-1,.grid-x>.medium-shrink{-webkit-box-flex:0;-ms-flex:none;flex:none}.grid-x>.medium-shrink{width:auto}.grid-x>.medium-1{width:8.33333%}.grid-x>.medium-2{width:16.6667%}.grid-x>.medium-3{width:25%}.grid-x>.medium-4{width:33.3333%}.grid-x>.medium-5{width:41.6667%}.grid-x>.medium-6{width:50%}.grid-x>.medium-7{width:58.3333%}.grid-x>.medium-8{width:66.6667%}.grid-x>.medium-9{width:75%}.grid-x>.medium-10{width:83.3333%}.grid-x>.medium-11{width:91.6667%}.grid-x>.medium-12{width:100%}}@media print,screen and (width>=64em){.grid-x>.large-auto{-webkit-box-flex:1;-ms-flex:1 1 0;flex:1 1 0;width:auto}.grid-x>.large-12,.grid-x>.large-11,.grid-x>.large-10,.grid-x>.large-9,.grid-x>.large-8,.grid-x>.large-7,.grid-x>.large-6,.grid-x>.large-5,.grid-x>.large-4,.grid-x>.large-3,.grid-x>.large-2,.grid-x>.large-1,.grid-x>.large-shrink{-webkit-box-flex:0;-ms-flex:none;flex:none}.grid-x>.large-shrink{width:auto}.grid-x>.large-1{width:8.33333%}.grid-x>.large-2{width:16.6667%}.grid-x>.large-3{width:25%}.grid-x>.large-4{width:33.3333%}.grid-x>.large-5{width:41.6667%}.grid-x>.large-6{width:50%}.grid-x>.large-7{width:58.3333%}.grid-x>.large-8{width:66.6667%}.grid-x>.large-9{width:75%}.grid-x>.large-10{width:83.3333%}.grid-x>.large-11{width:91.6667%}.grid-x>.large-12{width:100%}}.grid-margin-x:not(.grid-x)>.cell{width:auto}.grid-margin-y:not(.grid-y)>.cell{height:auto}.grid-margin-x{margin-left:-.625rem;margin-right:-.625rem}@media print,screen and (width>=40em){.grid-margin-x{margin-left:-.9375rem;margin-right:-.9375rem}}.grid-margin-x>.cell{width:calc(100% - 1.25rem);margin-left:.625rem;margin-right:.625rem}@media print,screen and (width>=40em){.grid-margin-x>.cell{width:calc(100% - 1.875rem);margin-left:.9375rem;margin-right:.9375rem}}.grid-margin-x>.auto,.grid-margin-x>.shrink{width:auto}.grid-margin-x>.small-1{width:calc(8.33333% - 1.25rem)}.grid-margin-x>.small-2{width:calc(16.6667% - 1.25rem)}.grid-margin-x>.small-3{width:calc(25% - 1.25rem)}.grid-margin-x>.small-4{width:calc(33.3333% - 1.25rem)}.grid-margin-x>.small-5{width:calc(41.6667% - 1.25rem)}.grid-margin-x>.small-6{width:calc(50% - 1.25rem)}.grid-margin-x>.small-7{width:calc(58.3333% - 1.25rem)}.grid-margin-x>.small-8{width:calc(66.6667% - 1.25rem)}.grid-margin-x>.small-9{width:calc(75% - 1.25rem)}.grid-margin-x>.small-10{width:calc(83.3333% - 1.25rem)}.grid-margin-x>.small-11{width:calc(91.6667% - 1.25rem)}.grid-margin-x>.small-12{width:calc(100% - 1.25rem)}@media print,screen and (width>=40em){.grid-margin-x>.auto,.grid-margin-x>.shrink{width:auto}.grid-margin-x>.small-1{width:calc(8.33333% - 1.875rem)}.grid-margin-x>.small-2{width:calc(16.6667% - 1.875rem)}.grid-margin-x>.small-3{width:calc(25% - 1.875rem)}.grid-margin-x>.small-4{width:calc(33.3333% - 1.875rem)}.grid-margin-x>.small-5{width:calc(41.6667% - 1.875rem)}.grid-margin-x>.small-6{width:calc(50% - 1.875rem)}.grid-margin-x>.small-7{width:calc(58.3333% - 1.875rem)}.grid-margin-x>.small-8{width:calc(66.6667% - 1.875rem)}.grid-margin-x>.small-9{width:calc(75% - 1.875rem)}.grid-margin-x>.small-10{width:calc(83.3333% - 1.875rem)}.grid-margin-x>.small-11{width:calc(91.6667% - 1.875rem)}.grid-margin-x>.small-12{width:calc(100% - 1.875rem)}.grid-margin-x>.medium-auto,.grid-margin-x>.medium-shrink{width:auto}.grid-margin-x>.medium-1{width:calc(8.33333% - 1.875rem)}.grid-margin-x>.medium-2{width:calc(16.6667% - 1.875rem)}.grid-margin-x>.medium-3{width:calc(25% - 1.875rem)}.grid-margin-x>.medium-4{width:calc(33.3333% - 1.875rem)}.grid-margin-x>.medium-5{width:calc(41.6667% - 1.875rem)}.grid-margin-x>.medium-6{width:calc(50% - 1.875rem)}.grid-margin-x>.medium-7{width:calc(58.3333% - 1.875rem)}.grid-margin-x>.medium-8{width:calc(66.6667% - 1.875rem)}.grid-margin-x>.medium-9{width:calc(75% - 1.875rem)}.grid-margin-x>.medium-10{width:calc(83.3333% - 1.875rem)}.grid-margin-x>.medium-11{width:calc(91.6667% - 1.875rem)}.grid-margin-x>.medium-12{width:calc(100% - 1.875rem)}}@media print,screen and (width>=64em){.grid-margin-x>.large-auto,.grid-margin-x>.large-shrink{width:auto}.grid-margin-x>.large-1{width:calc(8.33333% - 1.875rem)}.grid-margin-x>.large-2{width:calc(16.6667% - 1.875rem)}.grid-margin-x>.large-3{width:calc(25% - 1.875rem)}.grid-margin-x>.large-4{width:calc(33.3333% - 1.875rem)}.grid-margin-x>.large-5{width:calc(41.6667% - 1.875rem)}.grid-margin-x>.large-6{width:calc(50% - 1.875rem)}.grid-margin-x>.large-7{width:calc(58.3333% - 1.875rem)}.grid-margin-x>.large-8{width:calc(66.6667% - 1.875rem)}.grid-margin-x>.large-9{width:calc(75% - 1.875rem)}.grid-margin-x>.large-10{width:calc(83.3333% - 1.875rem)}.grid-margin-x>.large-11{width:calc(91.6667% - 1.875rem)}.grid-margin-x>.large-12{width:calc(100% - 1.875rem)}}.grid-padding-x .grid-padding-x{margin-left:-.625rem;margin-right:-.625rem}@media print,screen and (width>=40em){.grid-padding-x .grid-padding-x{margin-left:-.9375rem;margin-right:-.9375rem}}.grid-container:not(.full)>.grid-padding-x{margin-left:-.625rem;margin-right:-.625rem}@media print,screen and (width>=40em){.grid-container:not(.full)>.grid-padding-x{margin-left:-.9375rem;margin-right:-.9375rem}}.grid-padding-x>.cell{padding-left:.625rem;padding-right:.625rem}@media print,screen and (width>=40em){.grid-padding-x>.cell{padding-left:.9375rem;padding-right:.9375rem}}.small-up-1>.cell{width:100%}.small-up-2>.cell{width:50%}.small-up-3>.cell{width:33.3333%}.small-up-4>.cell{width:25%}.small-up-5>.cell{width:20%}.small-up-6>.cell{width:16.6667%}.small-up-7>.cell{width:14.2857%}.small-up-8>.cell{width:12.5%}@media print,screen and (width>=40em){.medium-up-1>.cell{width:100%}.medium-up-2>.cell{width:50%}.medium-up-3>.cell{width:33.3333%}.medium-up-4>.cell{width:25%}.medium-up-5>.cell{width:20%}.medium-up-6>.cell{width:16.6667%}.medium-up-7>.cell{width:14.2857%}.medium-up-8>.cell{width:12.5%}}@media print,screen and (width>=64em){.large-up-1>.cell{width:100%}.large-up-2>.cell{width:50%}.large-up-3>.cell{width:33.3333%}.large-up-4>.cell{width:25%}.large-up-5>.cell{width:20%}.large-up-6>.cell{width:16.6667%}.large-up-7>.cell{width:14.2857%}.large-up-8>.cell{width:12.5%}}.grid-margin-x.small-up-1>.cell{width:calc(100% - 1.25rem)}.grid-margin-x.small-up-2>.cell{width:calc(50% - 1.25rem)}.grid-margin-x.small-up-3>.cell{width:calc(33.3333% - 1.25rem)}.grid-margin-x.small-up-4>.cell{width:calc(25% - 1.25rem)}.grid-margin-x.small-up-5>.cell{width:calc(20% - 1.25rem)}.grid-margin-x.small-up-6>.cell{width:calc(16.6667% - 1.25rem)}.grid-margin-x.small-up-7>.cell{width:calc(14.2857% - 1.25rem)}.grid-margin-x.small-up-8>.cell{width:calc(12.5% - 1.25rem)}@media print,screen and (width>=40em){.grid-margin-x.small-up-1>.cell{width:calc(100% - 1.875rem)}.grid-margin-x.small-up-2>.cell{width:calc(50% - 1.875rem)}.grid-margin-x.small-up-3>.cell{width:calc(33.3333% - 1.875rem)}.grid-margin-x.small-up-4>.cell{width:calc(25% - 1.875rem)}.grid-margin-x.small-up-5>.cell{width:calc(20% - 1.875rem)}.grid-margin-x.small-up-6>.cell{width:calc(16.6667% - 1.875rem)}.grid-margin-x.small-up-7>.cell{width:calc(14.2857% - 1.875rem)}.grid-margin-x.small-up-8>.cell{width:calc(12.5% - 1.875rem)}.grid-margin-x.medium-up-1>.cell{width:calc(100% - 1.875rem)}.grid-margin-x.medium-up-2>.cell{width:calc(50% - 1.875rem)}.grid-margin-x.medium-up-3>.cell{width:calc(33.3333% - 1.875rem)}.grid-margin-x.medium-up-4>.cell{width:calc(25% - 1.875rem)}.grid-margin-x.medium-up-5>.cell{width:calc(20% - 1.875rem)}.grid-margin-x.medium-up-6>.cell{width:calc(16.6667% - 1.875rem)}.grid-margin-x.medium-up-7>.cell{width:calc(14.2857% - 1.875rem)}.grid-margin-x.medium-up-8>.cell{width:calc(12.5% - 1.875rem)}}@media print,screen and (width>=64em){.grid-margin-x.large-up-1>.cell{width:calc(100% - 1.875rem)}.grid-margin-x.large-up-2>.cell{width:calc(50% - 1.875rem)}.grid-margin-x.large-up-3>.cell{width:calc(33.3333% - 1.875rem)}.grid-margin-x.large-up-4>.cell{width:calc(25% - 1.875rem)}.grid-margin-x.large-up-5>.cell{width:calc(20% - 1.875rem)}.grid-margin-x.large-up-6>.cell{width:calc(16.6667% - 1.875rem)}.grid-margin-x.large-up-7>.cell{width:calc(14.2857% - 1.875rem)}.grid-margin-x.large-up-8>.cell{width:calc(12.5% - 1.875rem)}}.small-margin-collapse,.small-margin-collapse>.cell{margin-left:0;margin-right:0}.small-margin-collapse>.small-1{width:8.33333%}.small-margin-collapse>.small-2{width:16.6667%}.small-margin-collapse>.small-3{width:25%}.small-margin-collapse>.small-4{width:33.3333%}.small-margin-collapse>.small-5{width:41.6667%}.small-margin-collapse>.small-6{width:50%}.small-margin-collapse>.small-7{width:58.3333%}.small-margin-collapse>.small-8{width:66.6667%}.small-margin-collapse>.small-9{width:75%}.small-margin-collapse>.small-10{width:83.3333%}.small-margin-collapse>.small-11{width:91.6667%}.small-margin-collapse>.small-12{width:100%}@media print,screen and (width>=40em){.small-margin-collapse>.medium-1{width:8.33333%}.small-margin-collapse>.medium-2{width:16.6667%}.small-margin-collapse>.medium-3{width:25%}.small-margin-collapse>.medium-4{width:33.3333%}.small-margin-collapse>.medium-5{width:41.6667%}.small-margin-collapse>.medium-6{width:50%}.small-margin-collapse>.medium-7{width:58.3333%}.small-margin-collapse>.medium-8{width:66.6667%}.small-margin-collapse>.medium-9{width:75%}.small-margin-collapse>.medium-10{width:83.3333%}.small-margin-collapse>.medium-11{width:91.6667%}.small-margin-collapse>.medium-12{width:100%}}@media print,screen and (width>=64em){.small-margin-collapse>.large-1{width:8.33333%}.small-margin-collapse>.large-2{width:16.6667%}.small-margin-collapse>.large-3{width:25%}.small-margin-collapse>.large-4{width:33.3333%}.small-margin-collapse>.large-5{width:41.6667%}.small-margin-collapse>.large-6{width:50%}.small-margin-collapse>.large-7{width:58.3333%}.small-margin-collapse>.large-8{width:66.6667%}.small-margin-collapse>.large-9{width:75%}.small-margin-collapse>.large-10{width:83.3333%}.small-margin-collapse>.large-11{width:91.6667%}.small-margin-collapse>.large-12{width:100%}}.small-padding-collapse{margin-left:0;margin-right:0}.small-padding-collapse>.cell{padding-left:0;padding-right:0}@media print,screen and (width>=40em){.medium-margin-collapse,.medium-margin-collapse>.cell{margin-left:0;margin-right:0}.medium-margin-collapse>.small-1{width:8.33333%}.medium-margin-collapse>.small-2{width:16.6667%}.medium-margin-collapse>.small-3{width:25%}.medium-margin-collapse>.small-4{width:33.3333%}.medium-margin-collapse>.small-5{width:41.6667%}.medium-margin-collapse>.small-6{width:50%}.medium-margin-collapse>.small-7{width:58.3333%}.medium-margin-collapse>.small-8{width:66.6667%}.medium-margin-collapse>.small-9{width:75%}.medium-margin-collapse>.small-10{width:83.3333%}.medium-margin-collapse>.small-11{width:91.6667%}.medium-margin-collapse>.small-12{width:100%}.medium-margin-collapse>.medium-1{width:8.33333%}.medium-margin-collapse>.medium-2{width:16.6667%}.medium-margin-collapse>.medium-3{width:25%}.medium-margin-collapse>.medium-4{width:33.3333%}.medium-margin-collapse>.medium-5{width:41.6667%}.medium-margin-collapse>.medium-6{width:50%}.medium-margin-collapse>.medium-7{width:58.3333%}.medium-margin-collapse>.medium-8{width:66.6667%}.medium-margin-collapse>.medium-9{width:75%}.medium-margin-collapse>.medium-10{width:83.3333%}.medium-margin-collapse>.medium-11{width:91.6667%}.medium-margin-collapse>.medium-12{width:100%}}@media print,screen and (width>=64em){.medium-margin-collapse>.large-1{width:8.33333%}.medium-margin-collapse>.large-2{width:16.6667%}.medium-margin-collapse>.large-3{width:25%}.medium-margin-collapse>.large-4{width:33.3333%}.medium-margin-collapse>.large-5{width:41.6667%}.medium-margin-collapse>.large-6{width:50%}.medium-margin-collapse>.large-7{width:58.3333%}.medium-margin-collapse>.large-8{width:66.6667%}.medium-margin-collapse>.large-9{width:75%}.medium-margin-collapse>.large-10{width:83.3333%}.medium-margin-collapse>.large-11{width:91.6667%}.medium-margin-collapse>.large-12{width:100%}}@media print,screen and (width>=40em){.medium-padding-collapse{margin-left:0;margin-right:0}.medium-padding-collapse>.cell{padding-left:0;padding-right:0}}@media print,screen and (width>=64em){.large-margin-collapse,.large-margin-collapse>.cell{margin-left:0;margin-right:0}.large-margin-collapse>.small-1{width:8.33333%}.large-margin-collapse>.small-2{width:16.6667%}.large-margin-collapse>.small-3{width:25%}.large-margin-collapse>.small-4{width:33.3333%}.large-margin-collapse>.small-5{width:41.6667%}.large-margin-collapse>.small-6{width:50%}.large-margin-collapse>.small-7{width:58.3333%}.large-margin-collapse>.small-8{width:66.6667%}.large-margin-collapse>.small-9{width:75%}.large-margin-collapse>.small-10{width:83.3333%}.large-margin-collapse>.small-11{width:91.6667%}.large-margin-collapse>.small-12{width:100%}.large-margin-collapse>.medium-1{width:8.33333%}.large-margin-collapse>.medium-2{width:16.6667%}.large-margin-collapse>.medium-3{width:25%}.large-margin-collapse>.medium-4{width:33.3333%}.large-margin-collapse>.medium-5{width:41.6667%}.large-margin-collapse>.medium-6{width:50%}.large-margin-collapse>.medium-7{width:58.3333%}.large-margin-collapse>.medium-8{width:66.6667%}.large-margin-collapse>.medium-9{width:75%}.large-margin-collapse>.medium-10{width:83.3333%}.large-margin-collapse>.medium-11{width:91.6667%}.large-margin-collapse>.medium-12{width:100%}.large-margin-collapse>.large-1{width:8.33333%}.large-margin-collapse>.large-2{width:16.6667%}.large-margin-collapse>.large-3{width:25%}.large-margin-collapse>.large-4{width:33.3333%}.large-margin-collapse>.large-5{width:41.6667%}.large-margin-collapse>.large-6{width:50%}.large-margin-collapse>.large-7{width:58.3333%}.large-margin-collapse>.large-8{width:66.6667%}.large-margin-collapse>.large-9{width:75%}.large-margin-collapse>.large-10{width:83.3333%}.large-margin-collapse>.large-11{width:91.6667%}.large-margin-collapse>.large-12{width:100%}.large-padding-collapse{margin-left:0;margin-right:0}.large-padding-collapse>.cell{padding-left:0;padding-right:0}}.small-offset-0{margin-left:0%}.grid-margin-x>.small-offset-0{margin-left:.625rem}.small-offset-1{margin-left:8.33333%}.grid-margin-x>.small-offset-1{margin-left:calc(8.33333% + .625rem)}.small-offset-2{margin-left:16.6667%}.grid-margin-x>.small-offset-2{margin-left:calc(16.6667% + .625rem)}.small-offset-3{margin-left:25%}.grid-margin-x>.small-offset-3{margin-left:calc(25% + .625rem)}.small-offset-4{margin-left:33.3333%}.grid-margin-x>.small-offset-4{margin-left:calc(33.3333% + .625rem)}.small-offset-5{margin-left:41.6667%}.grid-margin-x>.small-offset-5{margin-left:calc(41.6667% + .625rem)}.small-offset-6{margin-left:50%}.grid-margin-x>.small-offset-6{margin-left:calc(50% + .625rem)}.small-offset-7{margin-left:58.3333%}.grid-margin-x>.small-offset-7{margin-left:calc(58.3333% + .625rem)}.small-offset-8{margin-left:66.6667%}.grid-margin-x>.small-offset-8{margin-left:calc(66.6667% + .625rem)}.small-offset-9{margin-left:75%}.grid-margin-x>.small-offset-9{margin-left:calc(75% + .625rem)}.small-offset-10{margin-left:83.3333%}.grid-margin-x>.small-offset-10{margin-left:calc(83.3333% + .625rem)}.small-offset-11{margin-left:91.6667%}.grid-margin-x>.small-offset-11{margin-left:calc(91.6667% + .625rem)}@media print,screen and (width>=40em){.medium-offset-0{margin-left:0%}.grid-margin-x>.medium-offset-0{margin-left:.9375rem}.medium-offset-1{margin-left:8.33333%}.grid-margin-x>.medium-offset-1{margin-left:calc(8.33333% + .9375rem)}.medium-offset-2{margin-left:16.6667%}.grid-margin-x>.medium-offset-2{margin-left:calc(16.6667% + .9375rem)}.medium-offset-3{margin-left:25%}.grid-margin-x>.medium-offset-3{margin-left:calc(25% + .9375rem)}.medium-offset-4{margin-left:33.3333%}.grid-margin-x>.medium-offset-4{margin-left:calc(33.3333% + .9375rem)}.medium-offset-5{margin-left:41.6667%}.grid-margin-x>.medium-offset-5{margin-left:calc(41.6667% + .9375rem)}.medium-offset-6{margin-left:50%}.grid-margin-x>.medium-offset-6{margin-left:calc(50% + .9375rem)}.medium-offset-7{margin-left:58.3333%}.grid-margin-x>.medium-offset-7{margin-left:calc(58.3333% + .9375rem)}.medium-offset-8{margin-left:66.6667%}.grid-margin-x>.medium-offset-8{margin-left:calc(66.6667% + .9375rem)}.medium-offset-9{margin-left:75%}.grid-margin-x>.medium-offset-9{margin-left:calc(75% + .9375rem)}.medium-offset-10{margin-left:83.3333%}.grid-margin-x>.medium-offset-10{margin-left:calc(83.3333% + .9375rem)}.medium-offset-11{margin-left:91.6667%}.grid-margin-x>.medium-offset-11{margin-left:calc(91.6667% + .9375rem)}}@media print,screen and (width>=64em){.large-offset-0{margin-left:0%}.grid-margin-x>.large-offset-0{margin-left:.9375rem}.large-offset-1{margin-left:8.33333%}.grid-margin-x>.large-offset-1{margin-left:calc(8.33333% + .9375rem)}.large-offset-2{margin-left:16.6667%}.grid-margin-x>.large-offset-2{margin-left:calc(16.6667% + .9375rem)}.large-offset-3{margin-left:25%}.grid-margin-x>.large-offset-3{margin-left:calc(25% + .9375rem)}.large-offset-4{margin-left:33.3333%}.grid-margin-x>.large-offset-4{margin-left:calc(33.3333% + .9375rem)}.large-offset-5{margin-left:41.6667%}.grid-margin-x>.large-offset-5{margin-left:calc(41.6667% + .9375rem)}.large-offset-6{margin-left:50%}.grid-margin-x>.large-offset-6{margin-left:calc(50% + .9375rem)}.large-offset-7{margin-left:58.3333%}.grid-margin-x>.large-offset-7{margin-left:calc(58.3333% + .9375rem)}.large-offset-8{margin-left:66.6667%}.grid-margin-x>.large-offset-8{margin-left:calc(66.6667% + .9375rem)}.large-offset-9{margin-left:75%}.grid-margin-x>.large-offset-9{margin-left:calc(75% + .9375rem)}.large-offset-10{margin-left:83.3333%}.grid-margin-x>.large-offset-10{margin-left:calc(83.3333% + .9375rem)}.large-offset-11{margin-left:91.6667%}.grid-margin-x>.large-offset-11{margin-left:calc(91.6667% + .9375rem)}}.grid-y{-webkit-box-orient:vertical;-webkit-box-direction:normal;-ms-flex-flow:column;flex-flow:column;display:-webkit-box;display:-ms-flexbox;display:flex}.grid-y>.cell{height:auto;max-height:none}.grid-y>.auto,.grid-y>.shrink{height:auto}.grid-y>.small-shrink,.grid-y>.small-full,.grid-y>.small-1,.grid-y>.small-2,.grid-y>.small-3,.grid-y>.small-4,.grid-y>.small-5,.grid-y>.small-6,.grid-y>.small-7,.grid-y>.small-8,.grid-y>.small-9,.grid-y>.small-10,.grid-y>.small-11,.grid-y>.small-12{-ms-flex-preferred-size:auto;flex-basis:auto}@media print,screen and (width>=40em){.grid-y>.medium-shrink,.grid-y>.medium-full,.grid-y>.medium-1,.grid-y>.medium-2,.grid-y>.medium-3,.grid-y>.medium-4,.grid-y>.medium-5,.grid-y>.medium-6,.grid-y>.medium-7,.grid-y>.medium-8,.grid-y>.medium-9,.grid-y>.medium-10,.grid-y>.medium-11,.grid-y>.medium-12{-ms-flex-preferred-size:auto;flex-basis:auto}}@media print,screen and (width>=64em){.grid-y>.large-shrink,.grid-y>.large-full,.grid-y>.large-1,.grid-y>.large-2,.grid-y>.large-3,.grid-y>.large-4,.grid-y>.large-5,.grid-y>.large-6,.grid-y>.large-7,.grid-y>.large-8,.grid-y>.large-9,.grid-y>.large-10,.grid-y>.large-11,.grid-y>.large-12{-ms-flex-preferred-size:auto;flex-basis:auto}}.grid-y>.small-12,.grid-y>.small-11,.grid-y>.small-10,.grid-y>.small-9,.grid-y>.small-8,.grid-y>.small-7,.grid-y>.small-6,.grid-y>.small-5,.grid-y>.small-4,.grid-y>.small-3,.grid-y>.small-2,.grid-y>.small-1{-webkit-box-flex:0;-ms-flex:none;flex:none}.grid-y>.small-1{height:8.33333%}.grid-y>.small-2{height:16.6667%}.grid-y>.small-3{height:25%}.grid-y>.small-4{height:33.3333%}.grid-y>.small-5{height:41.6667%}.grid-y>.small-6{height:50%}.grid-y>.small-7{height:58.3333%}.grid-y>.small-8{height:66.6667%}.grid-y>.small-9{height:75%}.grid-y>.small-10{height:83.3333%}.grid-y>.small-11{height:91.6667%}.grid-y>.small-12{height:100%}@media print,screen and (width>=40em){.grid-y>.medium-auto{-webkit-box-flex:1;-ms-flex:1 1 0;flex:1 1 0;height:auto}.grid-y>.medium-12,.grid-y>.medium-11,.grid-y>.medium-10,.grid-y>.medium-9,.grid-y>.medium-8,.grid-y>.medium-7,.grid-y>.medium-6,.grid-y>.medium-5,.grid-y>.medium-4,.grid-y>.medium-3,.grid-y>.medium-2,.grid-y>.medium-1,.grid-y>.medium-shrink{-webkit-box-flex:0;-ms-flex:none;flex:none}.grid-y>.medium-shrink{height:auto}.grid-y>.medium-1{height:8.33333%}.grid-y>.medium-2{height:16.6667%}.grid-y>.medium-3{height:25%}.grid-y>.medium-4{height:33.3333%}.grid-y>.medium-5{height:41.6667%}.grid-y>.medium-6{height:50%}.grid-y>.medium-7{height:58.3333%}.grid-y>.medium-8{height:66.6667%}.grid-y>.medium-9{height:75%}.grid-y>.medium-10{height:83.3333%}.grid-y>.medium-11{height:91.6667%}.grid-y>.medium-12{height:100%}}@media print,screen and (width>=64em){.grid-y>.large-auto{-webkit-box-flex:1;-ms-flex:1 1 0;flex:1 1 0;height:auto}.grid-y>.large-12,.grid-y>.large-11,.grid-y>.large-10,.grid-y>.large-9,.grid-y>.large-8,.grid-y>.large-7,.grid-y>.large-6,.grid-y>.large-5,.grid-y>.large-4,.grid-y>.large-3,.grid-y>.large-2,.grid-y>.large-1,.grid-y>.large-shrink{-webkit-box-flex:0;-ms-flex:none;flex:none}.grid-y>.large-shrink{height:auto}.grid-y>.large-1{height:8.33333%}.grid-y>.large-2{height:16.6667%}.grid-y>.large-3{height:25%}.grid-y>.large-4{height:33.3333%}.grid-y>.large-5{height:41.6667%}.grid-y>.large-6{height:50%}.grid-y>.large-7{height:58.3333%}.grid-y>.large-8{height:66.6667%}.grid-y>.large-9{height:75%}.grid-y>.large-10{height:83.3333%}.grid-y>.large-11{height:91.6667%}.grid-y>.large-12{height:100%}}.grid-padding-y .grid-padding-y{margin-top:-.625rem;margin-bottom:-.625rem}@media print,screen and (width>=40em){.grid-padding-y .grid-padding-y{margin-top:-.9375rem;margin-bottom:-.9375rem}}.grid-padding-y>.cell{padding-top:.625rem;padding-bottom:.625rem}@media print,screen and (width>=40em){.grid-padding-y>.cell{padding-top:.9375rem;padding-bottom:.9375rem}}@media print,screen and (width>=40em){.grid-margin-y{margin-top:-.9375rem;margin-bottom:-.9375rem}}@media print,screen and (width>=40em){.grid-margin-y>.cell{height:calc(100% - 1.875rem);margin-top:.9375rem;margin-bottom:.9375rem}}.grid-margin-y>.auto,.grid-margin-y>.shrink{height:auto}@media print,screen and (width>=40em){.grid-margin-y>.auto,.grid-margin-y>.shrink{height:auto}.grid-margin-y>.small-1{height:calc(8.33333% - 1.875rem)}.grid-margin-y>.small-2{height:calc(16.6667% - 1.875rem)}.grid-margin-y>.small-3{height:calc(25% - 1.875rem)}.grid-margin-y>.small-4{height:calc(33.3333% - 1.875rem)}.grid-margin-y>.small-5{height:calc(41.6667% - 1.875rem)}.grid-margin-y>.small-6{height:calc(50% - 1.875rem)}.grid-margin-y>.small-7{height:calc(58.3333% - 1.875rem)}.grid-margin-y>.small-8{height:calc(66.6667% - 1.875rem)}.grid-margin-y>.small-9{height:calc(75% - 1.875rem)}.grid-margin-y>.small-10{height:calc(83.3333% - 1.875rem)}.grid-margin-y>.small-11{height:calc(91.6667% - 1.875rem)}.grid-margin-y>.small-12{height:calc(100% - 1.875rem)}.grid-margin-y>.medium-auto,.grid-margin-y>.medium-shrink{height:auto}.grid-margin-y>.medium-1{height:calc(8.33333% - 1.875rem)}.grid-margin-y>.medium-2{height:calc(16.6667% - 1.875rem)}.grid-margin-y>.medium-3{height:calc(25% - 1.875rem)}.grid-margin-y>.medium-4{height:calc(33.3333% - 1.875rem)}.grid-margin-y>.medium-5{height:calc(41.6667% - 1.875rem)}.grid-margin-y>.medium-6{height:calc(50% - 1.875rem)}.grid-margin-y>.medium-7{height:calc(58.3333% - 1.875rem)}.grid-margin-y>.medium-8{height:calc(66.6667% - 1.875rem)}.grid-margin-y>.medium-9{height:calc(75% - 1.875rem)}.grid-margin-y>.medium-10{height:calc(83.3333% - 1.875rem)}.grid-margin-y>.medium-11{height:calc(91.6667% - 1.875rem)}.grid-margin-y>.medium-12{height:calc(100% - 1.875rem)}}@media print,screen and (width>=64em){.grid-margin-y>.large-auto,.grid-margin-y>.large-shrink{height:auto}.grid-margin-y>.large-1{height:calc(8.33333% - 1.875rem)}.grid-margin-y>.large-2{height:calc(16.6667% - 1.875rem)}.grid-margin-y>.large-3{height:calc(25% - 1.875rem)}.grid-margin-y>.large-4{height:calc(33.3333% - 1.875rem)}.grid-margin-y>.large-5{height:calc(41.6667% - 1.875rem)}.grid-margin-y>.large-6{height:calc(50% - 1.875rem)}.grid-margin-y>.large-7{height:calc(58.3333% - 1.875rem)}.grid-margin-y>.large-8{height:calc(66.6667% - 1.875rem)}.grid-margin-y>.large-9{height:calc(75% - 1.875rem)}.grid-margin-y>.large-10{height:calc(83.3333% - 1.875rem)}.grid-margin-y>.large-11{height:calc(91.6667% - 1.875rem)}.grid-margin-y>.large-12{height:calc(100% - 1.875rem)}}.grid-frame{-ms-flex-wrap:nowrap;flex-wrap:nowrap;align-items:stretch;width:100vw;position:relative;overflow:hidden}.cell .grid-frame{width:100%}.cell-block{-webkit-overflow-scrolling:touch;-ms-overflow-style:-ms-autohiding-scrollbar;max-width:100%;overflow-x:auto}.cell-block-y{-webkit-overflow-scrolling:touch;-ms-overflow-style:-ms-autohiding-scrollbar;min-height:100%;max-height:100%;overflow-y:auto}.cell-block-container{-webkit-box-orient:vertical;-webkit-box-direction:normal;-ms-flex-direction:column;flex-direction:column;max-height:100%;display:-webkit-box;display:-ms-flexbox;display:flex}.cell-block-container>.grid-x{-ms-flex-wrap:nowrap;flex-wrap:nowrap;max-height:100%}@media print,screen and (width>=40em){.medium-grid-frame{-ms-flex-wrap:nowrap;flex-wrap:nowrap;align-items:stretch;width:100vw;position:relative;overflow:hidden}.cell .medium-grid-frame{width:100%}.medium-cell-block{-webkit-overflow-scrolling:touch;-ms-overflow-style:-ms-autohiding-scrollbar;max-width:100%;overflow-x:auto}.medium-cell-block-container{-webkit-box-orient:vertical;-webkit-box-direction:normal;-ms-flex-direction:column;flex-direction:column;max-height:100%;display:-webkit-box;display:-ms-flexbox;display:flex}.medium-cell-block-container>.grid-x{-ms-flex-wrap:nowrap;flex-wrap:nowrap;max-height:100%}.medium-cell-block-y{-webkit-overflow-scrolling:touch;-ms-overflow-style:-ms-autohiding-scrollbar;min-height:100%;max-height:100%;overflow-y:auto}}@media print,screen and (width>=64em){.large-grid-frame{-ms-flex-wrap:nowrap;flex-wrap:nowrap;align-items:stretch;width:100vw;position:relative;overflow:hidden}.cell .large-grid-frame{width:100%}.large-cell-block{-webkit-overflow-scrolling:touch;-ms-overflow-style:-ms-autohiding-scrollbar;max-width:100%;overflow-x:auto}.large-cell-block-container{-webkit-box-orient:vertical;-webkit-box-direction:normal;-ms-flex-direction:column;flex-direction:column;max-height:100%;display:-webkit-box;display:-ms-flexbox;display:flex}.large-cell-block-container>.grid-x{-ms-flex-wrap:nowrap;flex-wrap:nowrap;max-height:100%}.large-cell-block-y{-webkit-overflow-scrolling:touch;-ms-overflow-style:-ms-autohiding-scrollbar;min-height:100%;max-height:100%;overflow-y:auto}}.grid-y.grid-frame{-ms-flex-wrap:nowrap;flex-wrap:nowrap;align-items:stretch;width:auto;height:100vh;position:relative;overflow:hidden}@media print,screen and (width>=40em){.grid-y.medium-grid-frame{-ms-flex-wrap:nowrap;flex-wrap:nowrap;align-items:stretch;width:auto;height:100vh;position:relative;overflow:hidden}}@media print,screen and (width>=64em){.grid-y.large-grid-frame{-ms-flex-wrap:nowrap;flex-wrap:nowrap;align-items:stretch;width:auto;height:100vh;position:relative;overflow:hidden}}.cell .grid-y.grid-frame{height:100%}@media print,screen and (width>=40em){.cell .grid-y.medium-grid-frame{height:100%}}@media print,screen and (width>=64em){.cell .grid-y.large-grid-frame{height:100%}}.grid-margin-y{margin-top:-.625rem;margin-bottom:-.625rem}@media print,screen and (width>=40em){.grid-margin-y{margin-top:-.9375rem;margin-bottom:-.9375rem}}.grid-margin-y>.cell{height:calc(100% - 1.25rem);margin-top:.625rem;margin-bottom:.625rem}@media print,screen and (width>=40em){.grid-margin-y>.cell{height:calc(100% - 1.875rem);margin-top:.9375rem;margin-bottom:.9375rem}}.grid-margin-y>.auto,.grid-margin-y>.shrink{height:auto}.grid-margin-y>.small-1{height:calc(8.33333% - 1.25rem)}.grid-margin-y>.small-2{height:calc(16.6667% - 1.25rem)}.grid-margin-y>.small-3{height:calc(25% - 1.25rem)}.grid-margin-y>.small-4{height:calc(33.3333% - 1.25rem)}.grid-margin-y>.small-5{height:calc(41.6667% - 1.25rem)}.grid-margin-y>.small-6{height:calc(50% - 1.25rem)}.grid-margin-y>.small-7{height:calc(58.3333% - 1.25rem)}.grid-margin-y>.small-8{height:calc(66.6667% - 1.25rem)}.grid-margin-y>.small-9{height:calc(75% - 1.25rem)}.grid-margin-y>.small-10{height:calc(83.3333% - 1.25rem)}.grid-margin-y>.small-11{height:calc(91.6667% - 1.25rem)}.grid-margin-y>.small-12{height:calc(100% - 1.25rem)}@media print,screen and (width>=40em){.grid-margin-y>.auto,.grid-margin-y>.shrink{height:auto}.grid-margin-y>.small-1{height:calc(8.33333% - 1.875rem)}.grid-margin-y>.small-2{height:calc(16.6667% - 1.875rem)}.grid-margin-y>.small-3{height:calc(25% - 1.875rem)}.grid-margin-y>.small-4{height:calc(33.3333% - 1.875rem)}.grid-margin-y>.small-5{height:calc(41.6667% - 1.875rem)}.grid-margin-y>.small-6{height:calc(50% - 1.875rem)}.grid-margin-y>.small-7{height:calc(58.3333% - 1.875rem)}.grid-margin-y>.small-8{height:calc(66.6667% - 1.875rem)}.grid-margin-y>.small-9{height:calc(75% - 1.875rem)}.grid-margin-y>.small-10{height:calc(83.3333% - 1.875rem)}.grid-margin-y>.small-11{height:calc(91.6667% - 1.875rem)}.grid-margin-y>.small-12{height:calc(100% - 1.875rem)}.grid-margin-y>.medium-auto,.grid-margin-y>.medium-shrink{height:auto}.grid-margin-y>.medium-1{height:calc(8.33333% - 1.875rem)}.grid-margin-y>.medium-2{height:calc(16.6667% - 1.875rem)}.grid-margin-y>.medium-3{height:calc(25% - 1.875rem)}.grid-margin-y>.medium-4{height:calc(33.3333% - 1.875rem)}.grid-margin-y>.medium-5{height:calc(41.6667% - 1.875rem)}.grid-margin-y>.medium-6{height:calc(50% - 1.875rem)}.grid-margin-y>.medium-7{height:calc(58.3333% - 1.875rem)}.grid-margin-y>.medium-8{height:calc(66.6667% - 1.875rem)}.grid-margin-y>.medium-9{height:calc(75% - 1.875rem)}.grid-margin-y>.medium-10{height:calc(83.3333% - 1.875rem)}.grid-margin-y>.medium-11{height:calc(91.6667% - 1.875rem)}.grid-margin-y>.medium-12{height:calc(100% - 1.875rem)}}@media print,screen and (width>=64em){.grid-margin-y>.large-auto,.grid-margin-y>.large-shrink{height:auto}.grid-margin-y>.large-1{height:calc(8.33333% - 1.875rem)}.grid-margin-y>.large-2{height:calc(16.6667% - 1.875rem)}.grid-margin-y>.large-3{height:calc(25% - 1.875rem)}.grid-margin-y>.large-4{height:calc(33.3333% - 1.875rem)}.grid-margin-y>.large-5{height:calc(41.6667% - 1.875rem)}.grid-margin-y>.large-6{height:calc(50% - 1.875rem)}.grid-margin-y>.large-7{height:calc(58.3333% - 1.875rem)}.grid-margin-y>.large-8{height:calc(66.6667% - 1.875rem)}.grid-margin-y>.large-9{height:calc(75% - 1.875rem)}.grid-margin-y>.large-10{height:calc(83.3333% - 1.875rem)}.grid-margin-y>.large-11{height:calc(91.6667% - 1.875rem)}.grid-margin-y>.large-12{height:calc(100% - 1.875rem)}}.grid-frame.grid-margin-y{height:calc(100vh + 1.25rem)}@media print,screen and (width>=40em){.grid-frame.grid-margin-y{height:calc(100vh + 1.875rem)}}@media print,screen and (width>=64em){.grid-frame.grid-margin-y{height:calc(100vh + 1.875rem)}}@media print,screen and (width>=40em){.grid-margin-y.medium-grid-frame{height:calc(100vh + 1.875rem)}}@media print,screen and (width>=64em){.grid-margin-y.large-grid-frame{height:calc(100vh + 1.875rem)}}.button{vertical-align:middle;-webkit-appearance:none;text-align:center;cursor:pointer;border:1px solid #0000;border-radius:0;margin:0 0 1rem;padding:.85em 1em;font-family:inherit;font-size:.9rem;line-height:1;-webkit-transition:background-color .25s ease-out,color .25s ease-out;transition:background-color .25s ease-out,color .25s ease-out;display:inline-block}[data-whatinput=mouse] .button{outline:0}.button.tiny{font-size:.6rem}.button.small{font-size:.75rem}.button.large{font-size:1.25rem}.button.expanded{width:100%;margin-left:0;margin-right:0;display:block}.button,.button.disabled,.button[disabled],.button.disabled:hover,.button[disabled]:hover,.button.disabled:focus,.button[disabled]:focus{color:#fefefe;background-color:#1779ba}.button:hover,.button:focus{color:#fefefe;background-color:#14679e}.button.primary,.button.primary.disabled,.button.primary[disabled],.button.primary.disabled:hover,.button.primary[disabled]:hover,.button.primary.disabled:focus,.button.primary[disabled]:focus{color:#fefefe;background-color:#1779ba}.button.primary:hover,.button.primary:focus{color:#fefefe;background-color:#126195}.button.secondary,.button.secondary.disabled,.button.secondary[disabled],.button.secondary.disabled:hover,.button.secondary[disabled]:hover,.button.secondary.disabled:focus,.button.secondary[disabled]:focus{color:#fefefe;background-color:#767676}.button.secondary:hover,.button.secondary:focus{color:#fefefe;background-color:#5e5e5e}.button.success,.button.success.disabled,.button.success[disabled],.button.success.disabled:hover,.button.success[disabled]:hover,.button.success.disabled:focus,.button.success[disabled]:focus{color:#0a0a0a;background-color:#3adb76}.button.success:hover,.button.success:focus{color:#0a0a0a;background-color:#22bb5b}.button.warning,.button.warning.disabled,.button.warning[disabled],.button.warning.disabled:hover,.button.warning[disabled]:hover,.button.warning.disabled:focus,.button.warning[disabled]:focus{color:#0a0a0a;background-color:#ffae00}.button.warning:hover,.button.warning:focus{color:#0a0a0a;background-color:#cc8b00}.button.alert,.button.alert.disabled,.button.alert[disabled],.button.alert.disabled:hover,.button.alert[disabled]:hover,.button.alert.disabled:focus,.button.alert[disabled]:focus{color:#fefefe;background-color:#cc4b37}.button.alert:hover,.button.alert:focus{color:#fefefe;background-color:#a53b2a}.button.hollow,.button.hollow:hover,.button.hollow:focus,.button.hollow.disabled,.button.hollow.disabled:hover,.button.hollow.disabled:focus,.button.hollow[disabled],.button.hollow[disabled]:hover,.button.hollow[disabled]:focus{background-color:#0000}.button.hollow,.button.hollow.disabled,.button.hollow[disabled],.button.hollow.disabled:hover,.button.hollow[disabled]:hover,.button.hollow.disabled:focus,.button.hollow[disabled]:focus{color:#1779ba;border:1px solid #1779ba}.button.hollow:hover,.button.hollow:focus{color:#0c3d5d;border-color:#0c3d5d}.button.hollow.primary,.button.hollow.primary.disabled,.button.hollow.primary[disabled],.button.hollow.primary.disabled:hover,.button.hollow.primary[disabled]:hover,.button.hollow.primary.disabled:focus,.button.hollow.primary[disabled]:focus{color:#1779ba;border:1px solid #1779ba}.button.hollow.primary:hover,.button.hollow.primary:focus{color:#0c3d5d;border-color:#0c3d5d}.button.hollow.secondary,.button.hollow.secondary.disabled,.button.hollow.secondary[disabled],.button.hollow.secondary.disabled:hover,.button.hollow.secondary[disabled]:hover,.button.hollow.secondary.disabled:focus,.button.hollow.secondary[disabled]:focus{color:#767676;border:1px solid #767676}.button.hollow.secondary:hover,.button.hollow.secondary:focus{color:#3b3b3b;border-color:#3b3b3b}.button.hollow.success,.button.hollow.success.disabled,.button.hollow.success[disabled],.button.hollow.success.disabled:hover,.button.hollow.success[disabled]:hover,.button.hollow.success.disabled:focus,.button.hollow.success[disabled]:focus{color:#3adb76;border:1px solid #3adb76}.button.hollow.success:hover,.button.hollow.success:focus{color:#157539;border-color:#157539}.button.hollow.warning,.button.hollow.warning.disabled,.button.hollow.warning[disabled],.button.hollow.warning.disabled:hover,.button.hollow.warning[disabled]:hover,.button.hollow.warning.disabled:focus,.button.hollow.warning[disabled]:focus{color:#ffae00;border:1px solid #ffae00}.button.hollow.warning:hover,.button.hollow.warning:focus{color:#805700;border-color:#805700}.button.hollow.alert,.button.hollow.alert.disabled,.button.hollow.alert[disabled],.button.hollow.alert.disabled:hover,.button.hollow.alert[disabled]:hover,.button.hollow.alert.disabled:focus,.button.hollow.alert[disabled]:focus{color:#cc4b37;border:1px solid #cc4b37}.button.hollow.alert:hover,.button.hollow.alert:focus{color:#67251a;border-color:#67251a}.button.clear,.button.clear:hover,.button.clear:focus,.button.clear.disabled,.button.clear.disabled:hover,.button.clear.disabled:focus,.button.clear[disabled],.button.clear[disabled]:hover,.button.clear[disabled]:focus{background-color:#0000;border-color:#0000}.button.clear,.button.clear.disabled,.button.clear[disabled],.button.clear.disabled:hover,.button.clear[disabled]:hover,.button.clear.disabled:focus,.button.clear[disabled]:focus{color:#1779ba}.button.clear:hover,.button.clear:focus{color:#0c3d5d}.button.clear.primary,.button.clear.primary.disabled,.button.clear.primary[disabled],.button.clear.primary.disabled:hover,.button.clear.primary[disabled]:hover,.button.clear.primary.disabled:focus,.button.clear.primary[disabled]:focus{color:#1779ba}.button.clear.primary:hover,.button.clear.primary:focus{color:#0c3d5d}.button.clear.secondary,.button.clear.secondary.disabled,.button.clear.secondary[disabled],.button.clear.secondary.disabled:hover,.button.clear.secondary[disabled]:hover,.button.clear.secondary.disabled:focus,.button.clear.secondary[disabled]:focus{color:#767676}.button.clear.secondary:hover,.button.clear.secondary:focus{color:#3b3b3b}.button.clear.success,.button.clear.success.disabled,.button.clear.success[disabled],.button.clear.success.disabled:hover,.button.clear.success[disabled]:hover,.button.clear.success.disabled:focus,.button.clear.success[disabled]:focus{color:#3adb76}.button.clear.success:hover,.button.clear.success:focus{color:#157539}.button.clear.warning,.button.clear.warning.disabled,.button.clear.warning[disabled],.button.clear.warning.disabled:hover,.button.clear.warning[disabled]:hover,.button.clear.warning.disabled:focus,.button.clear.warning[disabled]:focus{color:#ffae00}.button.clear.warning:hover,.button.clear.warning:focus{color:#805700}.button.clear.alert,.button.clear.alert.disabled,.button.clear.alert[disabled],.button.clear.alert.disabled:hover,.button.clear.alert[disabled]:hover,.button.clear.alert.disabled:focus,.button.clear.alert[disabled]:focus{color:#cc4b37}.button.clear.alert:hover,.button.clear.alert:focus{color:#67251a}.button.disabled,.button[disabled]{opacity:.25;cursor:not-allowed}.button.dropdown:after{content:"";float:right;border:.4em solid #0000;border-top-color:#fefefe;border-bottom-width:0;width:0;height:0;margin-left:1em;display:inline-block;position:relative;top:.4em}.button.dropdown.hollow:after,.button.dropdown.clear:after,.button.dropdown.hollow.primary:after,.button.dropdown.clear.primary:after{border-top-color:#1779ba}.button.dropdown.hollow.secondary:after,.button.dropdown.clear.secondary:after{border-top-color:#767676}.button.dropdown.hollow.success:after,.button.dropdown.clear.success:after{border-top-color:#3adb76}.button.dropdown.hollow.warning:after,.button.dropdown.clear.warning:after{border-top-color:#ffae00}.button.dropdown.hollow.alert:after,.button.dropdown.clear.alert:after{border-top-color:#cc4b37}.button.arrow-only:after{float:none;margin-left:0;top:-.1em}a.button:hover,a.button:focus{text-decoration:none}.button-group{-webkit-box-flex:1;-ms-flex-positive:1;-ms-flex-wrap:wrap;flex-wrap:wrap;flex-grow:1;align-items:stretch;margin-bottom:1rem;display:-webkit-box;display:-ms-flexbox;display:flex}.button-group:before,.button-group:after{content:" ";-webkit-box-ordinal-group:2;-ms-flex-preferred-size:0;-ms-flex-order:1;flex-basis:0;order:1;display:table}.button-group:after{clear:both}.button-group .button{-webkit-box-flex:0;-ms-flex:none;flex:none;margin:0 1px 1px 0;font-size:.9rem}.button-group .button:last-child{margin-right:0}.button-group.tiny .button{font-size:.6rem}.button-group.small .button{font-size:.75rem}.button-group.large .button{font-size:1.25rem}.button-group.expanded .button{-webkit-box-flex:1;-ms-flex:1 1 0;flex:1 1 0}.button-group.primary .button,.button-group.primary .button.disabled,.button-group.primary .button[disabled],.button-group.primary .button.disabled:hover,.button-group.primary .button[disabled]:hover,.button-group.primary .button.disabled:focus,.button-group.primary .button[disabled]:focus{color:#fefefe;background-color:#1779ba}.button-group.primary .button:hover,.button-group.primary .button:focus{color:#fefefe;background-color:#126195}.button-group.secondary .button,.button-group.secondary .button.disabled,.button-group.secondary .button[disabled],.button-group.secondary .button.disabled:hover,.button-group.secondary .button[disabled]:hover,.button-group.secondary .button.disabled:focus,.button-group.secondary .button[disabled]:focus{color:#fefefe;background-color:#767676}.button-group.secondary .button:hover,.button-group.secondary .button:focus{color:#fefefe;background-color:#5e5e5e}.button-group.success .button,.button-group.success .button.disabled,.button-group.success .button[disabled],.button-group.success .button.disabled:hover,.button-group.success .button[disabled]:hover,.button-group.success .button.disabled:focus,.button-group.success .button[disabled]:focus{color:#0a0a0a;background-color:#3adb76}.button-group.success .button:hover,.button-group.success .button:focus{color:#0a0a0a;background-color:#22bb5b}.button-group.warning .button,.button-group.warning .button.disabled,.button-group.warning .button[disabled],.button-group.warning .button.disabled:hover,.button-group.warning .button[disabled]:hover,.button-group.warning .button.disabled:focus,.button-group.warning .button[disabled]:focus{color:#0a0a0a;background-color:#ffae00}.button-group.warning .button:hover,.button-group.warning .button:focus{color:#0a0a0a;background-color:#cc8b00}.button-group.alert .button,.button-group.alert .button.disabled,.button-group.alert .button[disabled],.button-group.alert .button.disabled:hover,.button-group.alert .button[disabled]:hover,.button-group.alert .button.disabled:focus,.button-group.alert .button[disabled]:focus{color:#fefefe;background-color:#cc4b37}.button-group.alert .button:hover,.button-group.alert .button:focus{color:#fefefe;background-color:#a53b2a}.button-group.hollow .button,.button-group.hollow .button:hover,.button-group.hollow .button:focus,.button-group.hollow .button.disabled,.button-group.hollow .button.disabled:hover,.button-group.hollow .button.disabled:focus,.button-group.hollow .button[disabled],.button-group.hollow .button[disabled]:hover,.button-group.hollow .button[disabled]:focus{background-color:#0000}.button-group.hollow .button,.button-group.hollow .button.disabled,.button-group.hollow .button[disabled],.button-group.hollow .button.disabled:hover,.button-group.hollow .button[disabled]:hover,.button-group.hollow .button.disabled:focus,.button-group.hollow .button[disabled]:focus{color:#1779ba;border:1px solid #1779ba}.button-group.hollow .button:hover,.button-group.hollow .button:focus{color:#0c3d5d;border-color:#0c3d5d}.button-group.hollow.primary .button,.button-group.hollow.primary .button.disabled,.button-group.hollow.primary .button[disabled],.button-group.hollow.primary .button.disabled:hover,.button-group.hollow.primary .button[disabled]:hover,.button-group.hollow.primary .button.disabled:focus,.button-group.hollow.primary .button[disabled]:focus,.button-group.hollow .button.primary,.button-group.hollow .button.primary.disabled,.button-group.hollow .button.primary[disabled],.button-group.hollow .button.primary.disabled:hover,.button-group.hollow .button.primary[disabled]:hover,.button-group.hollow .button.primary.disabled:focus,.button-group.hollow .button.primary[disabled]:focus{color:#1779ba;border:1px solid #1779ba}.button-group.hollow.primary .button:hover,.button-group.hollow.primary .button:focus,.button-group.hollow .button.primary:hover,.button-group.hollow .button.primary:focus{color:#0c3d5d;border-color:#0c3d5d}.button-group.hollow.secondary .button,.button-group.hollow.secondary .button.disabled,.button-group.hollow.secondary .button[disabled],.button-group.hollow.secondary .button.disabled:hover,.button-group.hollow.secondary .button[disabled]:hover,.button-group.hollow.secondary .button.disabled:focus,.button-group.hollow.secondary .button[disabled]:focus,.button-group.hollow .button.secondary,.button-group.hollow .button.secondary.disabled,.button-group.hollow .button.secondary[disabled],.button-group.hollow .button.secondary.disabled:hover,.button-group.hollow .button.secondary[disabled]:hover,.button-group.hollow .button.secondary.disabled:focus,.button-group.hollow .button.secondary[disabled]:focus{color:#767676;border:1px solid #767676}.button-group.hollow.secondary .button:hover,.button-group.hollow.secondary .button:focus,.button-group.hollow .button.secondary:hover,.button-group.hollow .button.secondary:focus{color:#3b3b3b;border-color:#3b3b3b}.button-group.hollow.success .button,.button-group.hollow.success .button.disabled,.button-group.hollow.success .button[disabled],.button-group.hollow.success .button.disabled:hover,.button-group.hollow.success .button[disabled]:hover,.button-group.hollow.success .button.disabled:focus,.button-group.hollow.success .button[disabled]:focus,.button-group.hollow .button.success,.button-group.hollow .button.success.disabled,.button-group.hollow .button.success[disabled],.button-group.hollow .button.success.disabled:hover,.button-group.hollow .button.success[disabled]:hover,.button-group.hollow .button.success.disabled:focus,.button-group.hollow .button.success[disabled]:focus{color:#3adb76;border:1px solid #3adb76}.button-group.hollow.success .button:hover,.button-group.hollow.success .button:focus,.button-group.hollow .button.success:hover,.button-group.hollow .button.success:focus{color:#157539;border-color:#157539}.button-group.hollow.warning .button,.button-group.hollow.warning .button.disabled,.button-group.hollow.warning .button[disabled],.button-group.hollow.warning .button.disabled:hover,.button-group.hollow.warning .button[disabled]:hover,.button-group.hollow.warning .button.disabled:focus,.button-group.hollow.warning .button[disabled]:focus,.button-group.hollow .button.warning,.button-group.hollow .button.warning.disabled,.button-group.hollow .button.warning[disabled],.button-group.hollow .button.warning.disabled:hover,.button-group.hollow .button.warning[disabled]:hover,.button-group.hollow .button.warning.disabled:focus,.button-group.hollow .button.warning[disabled]:focus{color:#ffae00;border:1px solid #ffae00}.button-group.hollow.warning .button:hover,.button-group.hollow.warning .button:focus,.button-group.hollow .button.warning:hover,.button-group.hollow .button.warning:focus{color:#805700;border-color:#805700}.button-group.hollow.alert .button,.button-group.hollow.alert .button.disabled,.button-group.hollow.alert .button[disabled],.button-group.hollow.alert .button.disabled:hover,.button-group.hollow.alert .button[disabled]:hover,.button-group.hollow.alert .button.disabled:focus,.button-group.hollow.alert .button[disabled]:focus,.button-group.hollow .button.alert,.button-group.hollow .button.alert.disabled,.button-group.hollow .button.alert[disabled],.button-group.hollow .button.alert.disabled:hover,.button-group.hollow .button.alert[disabled]:hover,.button-group.hollow .button.alert.disabled:focus,.button-group.hollow .button.alert[disabled]:focus{color:#cc4b37;border:1px solid #cc4b37}.button-group.hollow.alert .button:hover,.button-group.hollow.alert .button:focus,.button-group.hollow .button.alert:hover,.button-group.hollow .button.alert:focus{color:#67251a;border-color:#67251a}.button-group.clear .button,.button-group.clear .button:hover,.button-group.clear .button:focus,.button-group.clear .button.disabled,.button-group.clear .button.disabled:hover,.button-group.clear .button.disabled:focus,.button-group.clear .button[disabled],.button-group.clear .button[disabled]:hover,.button-group.clear .button[disabled]:focus{background-color:#0000;border-color:#0000}.button-group.clear .button,.button-group.clear .button.disabled,.button-group.clear .button[disabled],.button-group.clear .button.disabled:hover,.button-group.clear .button[disabled]:hover,.button-group.clear .button.disabled:focus,.button-group.clear .button[disabled]:focus{color:#1779ba}.button-group.clear .button:hover,.button-group.clear .button:focus{color:#0c3d5d}.button-group.clear.primary .button,.button-group.clear.primary .button.disabled,.button-group.clear.primary .button[disabled],.button-group.clear.primary .button.disabled:hover,.button-group.clear.primary .button[disabled]:hover,.button-group.clear.primary .button.disabled:focus,.button-group.clear.primary .button[disabled]:focus,.button-group.clear .button.primary,.button-group.clear .button.primary.disabled,.button-group.clear .button.primary[disabled],.button-group.clear .button.primary.disabled:hover,.button-group.clear .button.primary[disabled]:hover,.button-group.clear .button.primary.disabled:focus,.button-group.clear .button.primary[disabled]:focus{color:#1779ba}.button-group.clear.primary .button:hover,.button-group.clear.primary .button:focus,.button-group.clear .button.primary:hover,.button-group.clear .button.primary:focus{color:#0c3d5d}.button-group.clear.secondary .button,.button-group.clear.secondary .button.disabled,.button-group.clear.secondary .button[disabled],.button-group.clear.secondary .button.disabled:hover,.button-group.clear.secondary .button[disabled]:hover,.button-group.clear.secondary .button.disabled:focus,.button-group.clear.secondary .button[disabled]:focus,.button-group.clear .button.secondary,.button-group.clear .button.secondary.disabled,.button-group.clear .button.secondary[disabled],.button-group.clear .button.secondary.disabled:hover,.button-group.clear .button.secondary[disabled]:hover,.button-group.clear .button.secondary.disabled:focus,.button-group.clear .button.secondary[disabled]:focus{color:#767676}.button-group.clear.secondary .button:hover,.button-group.clear.secondary .button:focus,.button-group.clear .button.secondary:hover,.button-group.clear .button.secondary:focus{color:#3b3b3b}.button-group.clear.success .button,.button-group.clear.success .button.disabled,.button-group.clear.success .button[disabled],.button-group.clear.success .button.disabled:hover,.button-group.clear.success .button[disabled]:hover,.button-group.clear.success .button.disabled:focus,.button-group.clear.success .button[disabled]:focus,.button-group.clear .button.success,.button-group.clear .button.success.disabled,.button-group.clear .button.success[disabled],.button-group.clear .button.success.disabled:hover,.button-group.clear .button.success[disabled]:hover,.button-group.clear .button.success.disabled:focus,.button-group.clear .button.success[disabled]:focus{color:#3adb76}.button-group.clear.success .button:hover,.button-group.clear.success .button:focus,.button-group.clear .button.success:hover,.button-group.clear .button.success:focus{color:#157539}.button-group.clear.warning .button,.button-group.clear.warning .button.disabled,.button-group.clear.warning .button[disabled],.button-group.clear.warning .button.disabled:hover,.button-group.clear.warning .button[disabled]:hover,.button-group.clear.warning .button.disabled:focus,.button-group.clear.warning .button[disabled]:focus,.button-group.clear .button.warning,.button-group.clear .button.warning.disabled,.button-group.clear .button.warning[disabled],.button-group.clear .button.warning.disabled:hover,.button-group.clear .button.warning[disabled]:hover,.button-group.clear .button.warning.disabled:focus,.button-group.clear .button.warning[disabled]:focus{color:#ffae00}.button-group.clear.warning .button:hover,.button-group.clear.warning .button:focus,.button-group.clear .button.warning:hover,.button-group.clear .button.warning:focus{color:#805700}.button-group.clear.alert .button,.button-group.clear.alert .button.disabled,.button-group.clear.alert .button[disabled],.button-group.clear.alert .button.disabled:hover,.button-group.clear.alert .button[disabled]:hover,.button-group.clear.alert .button.disabled:focus,.button-group.clear.alert .button[disabled]:focus,.button-group.clear .button.alert,.button-group.clear .button.alert.disabled,.button-group.clear .button.alert[disabled],.button-group.clear .button.alert.disabled:hover,.button-group.clear .button.alert[disabled]:hover,.button-group.clear .button.alert.disabled:focus,.button-group.clear .button.alert[disabled]:focus{color:#cc4b37}.button-group.clear.alert .button:hover,.button-group.clear.alert .button:focus,.button-group.clear .button.alert:hover,.button-group.clear .button.alert:focus{color:#67251a}.button-group.no-gaps .button{margin-right:-.0625rem}.button-group.no-gaps .button+.button{border-left-color:#0000}.button-group.stacked,.button-group.stacked-for-small,.button-group.stacked-for-medium{-ms-flex-wrap:wrap;flex-wrap:wrap}.button-group.stacked .button,.button-group.stacked-for-small .button,.button-group.stacked-for-medium .button{-webkit-box-flex:0;-ms-flex:0 0 100%;flex:0 0 100%}.button-group.stacked .button:last-child,.button-group.stacked-for-small .button:last-child,.button-group.stacked-for-medium .button:last-child{margin-bottom:0}.button-group.stacked.expanded .button,.button-group.stacked-for-small.expanded .button,.button-group.stacked-for-medium.expanded .button{-webkit-box-flex:1;-ms-flex:1 1 0;flex:1 1 0}@media print,screen and (width>=40em){.button-group.stacked-for-small .button{-webkit-box-flex:0;-ms-flex:none;flex:none;margin-bottom:0}}@media print,screen and (width>=64em){.button-group.stacked-for-medium .button{-webkit-box-flex:0;-ms-flex:none;flex:none;margin-bottom:0}}@media print,screen and (width<=39.9988em){.button-group.stacked-for-small.expanded{display:block}.button-group.stacked-for-small.expanded .button{margin-right:0;display:block}}@media print,screen and (width<=63.9988em){.button-group.stacked-for-medium.expanded{display:block}.button-group.stacked-for-medium.expanded .button{margin-right:0;display:block}}.close-button{z-index:10;color:#8a8a8a;cursor:pointer;position:absolute}[data-whatinput=mouse] .close-button{outline:0}.close-button:hover,.close-button:focus{color:#0a0a0a}.close-button.small{font-size:1.5em;line-height:1;top:.33em;right:.66rem}.close-button.medium,.close-button{font-size:2em;line-height:1;top:.5rem;right:1rem}.label{white-space:nowrap;cursor:default;color:#fefefe;background:#1779ba;border-radius:0;padding:.33333rem .5rem;font-size:.8rem;line-height:1;display:inline-block}.label.primary{color:#fefefe;background:#1779ba}.label.secondary{color:#fefefe;background:#767676}.label.success{color:#0a0a0a;background:#3adb76}.label.warning{color:#0a0a0a;background:#ffae00}.label.alert{color:#fefefe;background:#cc4b37}.progress{background-color:#cacaca;border-radius:0;height:1rem;margin-bottom:1rem}.progress.primary .progress-meter{background-color:#1779ba}.progress.secondary .progress-meter{background-color:#767676}.progress.success .progress-meter{background-color:#3adb76}.progress.warning .progress-meter{background-color:#ffae00}.progress.alert .progress-meter{background-color:#cc4b37}.progress-meter{background-color:#1779ba;width:0%;height:100%;display:block;position:relative}.progress-meter-text{color:#fefefe;white-space:nowrap;margin:0;font-size:.75rem;font-weight:700;position:absolute;top:50%;left:50%;-webkit-transform:translate(-50%,-50%);transform:translate(-50%,-50%)}.slider{cursor:pointer;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;-ms-touch-action:none;touch-action:none;background-color:#e6e6e6;height:.5rem;margin-top:1.25rem;margin-bottom:2.25rem;position:relative}.slider-fill{background-color:#cacaca;max-width:100%;height:.5rem;-webkit-transition:all .2s ease-in-out;transition:all .2s ease-in-out;display:inline-block;position:absolute;top:0;left:0}.slider-fill.is-dragging{-webkit-transition:all linear;transition:all linear}.slider-handle{z-index:1;cursor:-webkit-grab;cursor:grab;-ms-touch-action:manipulation;touch-action:manipulation;background-color:#1779ba;border-radius:0;width:1.4rem;height:1.4rem;-webkit-transition:all .2s ease-in-out;transition:all .2s ease-in-out;display:inline-block;position:absolute;top:50%;left:0;-webkit-transform:translateY(-50%);transform:translateY(-50%)}[data-whatinput=mouse] .slider-handle{outline:0}.slider-handle:hover{background-color:#14679e}.slider-handle.is-dragging{cursor:-webkit-grabbing;cursor:grabbing;-webkit-transition:all linear;transition:all linear}.slider.disabled,.slider[disabled]{opacity:.25;cursor:not-allowed}.slider.vertical{width:.5rem;height:12.5rem;margin:0 1.25rem;display:inline-block;-webkit-transform:scaleY(-1);transform:scaleY(-1)}.slider.vertical .slider-fill{width:.5rem;max-height:100%;top:0}.slider.vertical .slider-handle{width:1.4rem;height:1.4rem;position:absolute;top:0;left:50%;-webkit-transform:translate(-50%);transform:translate(-50%)}.switch{color:#fefefe;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;outline:0;height:2rem;margin-bottom:1rem;font-size:.875rem;font-weight:700;position:relative}.switch-input{opacity:0;margin-bottom:0;position:absolute}.switch-paddle{font-weight:inherit;color:inherit;cursor:pointer;background:#cacaca;border-radius:0;width:4rem;height:2rem;-webkit-transition:all .25s ease-out;transition:all .25s ease-out;display:block;position:relative}input+.switch-paddle{margin:0}.switch-paddle:after{content:"";background:#fefefe;border-radius:0;width:1.5rem;height:1.5rem;-webkit-transition:all .25s ease-out;transition:all .25s ease-out;display:block;position:absolute;top:.25rem;left:.25rem;-webkit-transform:translate(0,0);transform:translate(0,0)}input:checked~.switch-paddle{background:#1779ba}input:checked~.switch-paddle:after{left:2.25rem}input:focus-visible~.switch-paddle{background:#b6b6b6}input:focus-visible~.switch-paddle:after{background:#fefefe}input:checked:focus-visible~.switch-paddle{background:#14679e}input:disabled~.switch-paddle{cursor:not-allowed;opacity:.5}[data-whatinput=mouse] input:focus~.switch-paddle{outline:0}.switch-inactive,.switch-active{position:absolute;top:50%;-webkit-transform:translateY(-50%);transform:translateY(-50%)}.switch-active{display:none;left:8%}input:checked+label>.switch-active{display:block}.switch-inactive{right:15%}input:checked+label>.switch-inactive{display:none}.switch.tiny{height:1.5rem}.switch.tiny .switch-paddle{width:3rem;height:1.5rem;font-size:.625rem}.switch.tiny .switch-paddle:after{width:1rem;height:1rem;top:.25rem;left:.25rem}.switch.tiny input:checked~.switch-paddle:after{left:1.75rem}.switch.small{height:1.75rem}.switch.small .switch-paddle{width:3.5rem;height:1.75rem;font-size:.75rem}.switch.small .switch-paddle:after{width:1.25rem;height:1.25rem;top:.25rem;left:.25rem}.switch.small input:checked~.switch-paddle:after{left:2rem}.switch.large{height:2.5rem}.switch.large .switch-paddle{width:5rem;height:2.5rem;font-size:1rem}.switch.large .switch-paddle:after{width:2rem;height:2rem;top:.25rem;left:.25rem}.switch.large input:checked~.switch-paddle:after{left:2.75rem}table{border-collapse:collapse;border-radius:0;width:100%;margin-bottom:1rem}thead,tbody,tfoot{background-color:#fefefe;border:1px solid #f1f1f1}caption{padding:.5rem .625rem .625rem;font-weight:700}thead{color:#0a0a0a;background:#f8f8f8}tfoot{color:#0a0a0a;background:#f1f1f1}thead tr,tfoot tr{background:0 0}thead th,thead td,tfoot th,tfoot td{text-align:left;padding:.5rem .625rem .625rem;font-weight:700}tbody th,tbody td{padding:.5rem .625rem .625rem}tbody tr:nth-child(2n){background-color:#f1f1f1;border-bottom:0}table.unstriped tbody{background-color:#fefefe}table.unstriped tbody tr{background-color:#fefefe;border-bottom:1px solid #f1f1f1}@media print,screen and (width<=63.9988em){table.stack thead,table.stack tfoot{display:none}table.stack tr,table.stack th,table.stack td{display:block}table.stack td{border-top:0}}table.scroll{width:100%;display:block;overflow-x:auto}table.hover thead tr:hover{background-color:#f3f3f3}table.hover tfoot tr:hover{background-color:#ececec}table.hover tbody tr:hover{background-color:#f9f9f9}table.hover:not(.unstriped) tr:nth-of-type(2n):hover{background-color:#ececec}.table-scroll{overflow-x:auto}.badge{text-align:center;color:#fefefe;background:#1779ba;border-radius:50%;min-width:2.1em;padding:.3em;font-size:.6rem;display:inline-block}.badge.primary{color:#fefefe;background:#1779ba}.badge.secondary{color:#fefefe;background:#767676}.badge.success{color:#0a0a0a;background:#3adb76}.badge.warning{color:#0a0a0a;background:#ffae00}.badge.alert{color:#fefefe;background:#cc4b37}.breadcrumbs{margin:0 0 1rem;list-style:none}.breadcrumbs:before,.breadcrumbs:after{content:" ";-webkit-box-ordinal-group:2;-ms-flex-preferred-size:0;-ms-flex-order:1;flex-basis:0;order:1;display:table}.breadcrumbs:after{clear:both}.breadcrumbs li{float:left;color:#0a0a0a;cursor:default;text-transform:uppercase;font-size:.6875rem}.breadcrumbs li:not(:last-child):after{opacity:1;content:"/";color:#cacaca;margin:0 .75rem;position:relative}.breadcrumbs a{color:#1779ba}.breadcrumbs a:hover{text-decoration:underline}.breadcrumbs .disabled{color:#cacaca;cursor:not-allowed}.callout{color:#0a0a0a;background-color:#fff;border:1px solid #0a0a0a40;border-radius:0;margin:0 0 1rem;padding:1rem;position:relative}.callout>:first-child{margin-top:0}.callout>:last-child{margin-bottom:0}.callout.primary{color:#0a0a0a;background-color:#d7ecfa}.callout.secondary{color:#0a0a0a;background-color:#eaeaea}.callout.success{color:#0a0a0a;background-color:#e1faea}.callout.warning{color:#0a0a0a;background-color:#fff3d9}.callout.alert{color:#0a0a0a;background-color:#f7e4e1}.callout.small{padding:.5rem}.callout.large{padding:3rem}.card{-webkit-box-shadow:none;box-shadow:none;color:#0a0a0a;background:#fefefe;border:1px solid #e6e6e6;border-radius:0;-webkit-box-orient:vertical;-webkit-box-direction:normal;-webkit-box-flex:1;-ms-flex-positive:1;-ms-flex-direction:column;flex-direction:column;flex-grow:1;margin-bottom:1rem;display:-webkit-box;display:-ms-flexbox;display:flex;overflow:hidden}.card>:last-child{margin-bottom:0}.card-divider{background:#e6e6e6;-webkit-box-flex:0;-ms-flex:0 auto;flex:0 auto;padding:1rem;display:-webkit-box;display:-ms-flexbox;display:flex}.card-divider>:last-child{margin-bottom:0}.card-section{-webkit-box-flex:1;-ms-flex:1 0 auto;flex:1 0 auto;padding:1rem}.card-section>:last-child{margin-bottom:0}.card-image{min-height:1px}.dropdown-pane{z-index:10;visibility:hidden;background-color:#fefefe;border:1px solid #cacaca;border-radius:0;width:300px;padding:1rem;font-size:1rem;display:none;position:absolute}.dropdown-pane.is-opening{display:block}.dropdown-pane.is-open{visibility:visible;display:block}.dropdown-pane.tiny{width:100px}.dropdown-pane.small{width:200px}.dropdown-pane.large{width:400px}.pagination{margin-bottom:1rem;margin-left:0}.pagination:before,.pagination:after{content:" ";-webkit-box-ordinal-group:2;-ms-flex-preferred-size:0;-ms-flex-order:1;flex-basis:0;order:1;display:table}.pagination:after{clear:both}.pagination li{border-radius:0;margin-right:.0625rem;font-size:.875rem;display:none}.pagination li:last-child,.pagination li:first-child{display:inline-block}@media print,screen and (width>=40em){.pagination li{display:inline-block}}.pagination a,.pagination button{color:#0a0a0a;border-radius:0;padding:.1875rem .625rem;display:block}.pagination a:hover,.pagination button:hover{background:#e6e6e6}.pagination .current{color:#fefefe;cursor:default;background:#1779ba;padding:.1875rem .625rem}.pagination .disabled{color:#cacaca;cursor:not-allowed;padding:.1875rem .625rem}.pagination .disabled:hover{background:0 0}.pagination .ellipsis:after{content:"…";color:#0a0a0a;padding:.1875rem .625rem}.pagination-previous a:before,.pagination-previous.disabled:before{content:"«";margin-right:.5rem;display:inline-block}.pagination-next a:after,.pagination-next.disabled:after{content:"»";margin-left:.5rem;display:inline-block}.has-tip{cursor:help;border-bottom:1px dotted #8a8a8a;font-weight:700;display:inline-block;position:relative}.tooltip{z-index:1200;color:#fefefe;background-color:#0a0a0a;border-radius:0;max-width:10rem;padding:.75rem;font-size:80%;position:absolute;top:calc(100% + .6495rem)}.tooltip:before{position:absolute}.tooltip.bottom:before{content:"";border:.75rem solid #0000;border-top-width:0;border-bottom-color:#0a0a0a;width:0;height:0;display:block;bottom:100%}.tooltip.bottom.align-center:before{left:50%;-webkit-transform:translate(-50%);transform:translate(-50%)}.tooltip.top:before{content:"";border:.75rem solid #0000;border-top-color:#0a0a0a;border-bottom-width:0;width:0;height:0;display:block;top:100%;bottom:auto}.tooltip.top.align-center:before{left:50%;-webkit-transform:translate(-50%);transform:translate(-50%)}.tooltip.left:before{content:"";border:.75rem solid #0000;border-left-color:#0a0a0a;border-right-width:0;width:0;height:0;display:block;left:100%}.tooltip.left.align-center:before{top:50%;bottom:auto;-webkit-transform:translateY(-50%);transform:translateY(-50%)}.tooltip.right:before{content:"";border:.75rem solid #0000;border-left-width:0;border-right-color:#0a0a0a;width:0;height:0;display:block;left:auto;right:100%}.tooltip.right.align-center:before{top:50%;bottom:auto;-webkit-transform:translateY(-50%);transform:translateY(-50%)}.tooltip.align-top:before{top:10%;bottom:auto}.tooltip.align-bottom:before{top:auto;bottom:10%}.tooltip.align-left:before{left:10%;right:auto}.tooltip.align-right:before{left:auto;right:10%}.accordion{background:#fefefe;margin-left:0;list-style-type:none}.accordion[disabled] .accordion-title{cursor:not-allowed}.accordion-item:first-child>:first-child,.accordion-item:last-child>:last-child{border-radius:0}.accordion-title{color:#1779ba;border:1px solid #e6e6e6;border-bottom:0;padding:1.25rem 1rem;font-size:.75rem;line-height:1;display:block;position:relative}:last-child:not(.is-active)>.accordion-title{border-bottom:1px solid #e6e6e6;border-radius:0}.accordion-title:hover,.accordion-title:focus{background-color:#e6e6e6}.accordion-title:before{content:"+";margin-top:-.5rem;position:absolute;top:50%;right:1rem}.is-active>.accordion-title:before{content:"–"}.accordion-content{color:#0a0a0a;background-color:#fefefe;border:1px solid #e6e6e6;border-bottom:0;padding:1rem;display:none}:last-child>.accordion-content:last-child{border-bottom:1px solid #e6e6e6}.media-object{-ms-flex-wrap:nowrap;flex-wrap:nowrap;margin-bottom:1rem;display:-webkit-box;display:-ms-flexbox;display:flex}.media-object img{max-width:none}@media print,screen and (width<=39.9988em){.media-object.stack-for-small{-ms-flex-wrap:wrap;flex-wrap:wrap}}.media-object-section{-webkit-box-flex:0;-ms-flex:0 auto;flex:0 auto}.media-object-section:first-child{padding-right:1rem}.media-object-section:last-child:not(:nth-child(2)){padding-left:1rem}.media-object-section>:last-child{margin-bottom:0}@media print,screen and (width<=39.9988em){.stack-for-small .media-object-section{-ms-flex-preferred-size:100%;flex-basis:100%;max-width:100%;padding:0 0 1rem}.stack-for-small .media-object-section img{width:100%}}.media-object-section.main-section{-webkit-box-flex:1;-ms-flex:1 1 0;flex:1 1 0}.orbit{position:relative}.orbit-container{height:0;margin:0;list-style:none;position:relative;overflow:hidden}.orbit-slide{width:100%;position:absolute}.orbit-slide.no-motionui.is-active{top:0;left:0}.orbit-figure{margin:0}.orbit-image{width:100%;max-width:100%;margin:0}.orbit-caption{color:#fefefe;background-color:#0a0a0a80;width:100%;margin-bottom:0;padding:1rem;position:absolute;bottom:0}.orbit-next,.orbit-previous{z-index:10;color:#fefefe;padding:1rem;position:absolute;top:50%;-webkit-transform:translateY(-50%);transform:translateY(-50%)}[data-whatinput=mouse] .orbit-next,[data-whatinput=mouse] .orbit-previous{outline:0}.orbit-next:hover,.orbit-previous:hover,.orbit-next:active,.orbit-previous:active,.orbit-next:focus,.orbit-previous:focus{background-color:#0a0a0a80}.orbit-previous{left:0}.orbit-next{left:auto;right:0}.orbit-bullets{text-align:center;margin-top:.8rem;margin-bottom:.8rem;position:relative}[data-whatinput=mouse] .orbit-bullets{outline:0}.orbit-bullets button{background-color:#cacaca;border-radius:50%;width:1.2rem;height:1.2rem;margin:.1rem}.orbit-bullets button:hover,.orbit-bullets button.is-active{background-color:#8a8a8a}.responsive-embed,.flex-video{height:0;margin-bottom:1rem;padding-bottom:75%;position:relative;overflow:hidden}.responsive-embed iframe,.responsive-embed object,.responsive-embed embed,.responsive-embed video,.flex-video iframe,.flex-video object,.flex-video embed,.flex-video video{width:100%;height:100%;position:absolute;top:0;left:0}.responsive-embed.widescreen,.flex-video.widescreen{padding-bottom:56.25%}.tabs{background:#fefefe;border:1px solid #e6e6e6;margin:0;list-style-type:none}.tabs:before,.tabs:after{content:" ";-webkit-box-ordinal-group:2;-ms-flex-preferred-size:0;-ms-flex-order:1;flex-basis:0;order:1;display:table}.tabs:after{clear:both}.tabs.vertical>li{float:none;width:auto;display:block}.tabs.simple>li>a{padding:0}.tabs.simple>li>a:hover{background:0 0}.tabs.primary{background:#1779ba}.tabs.primary>li>a{color:#fefefe}.tabs.primary>li>a:hover,.tabs.primary>li>a:focus{background:#1673b1}.tabs-title{float:left}.tabs-title>a{color:#1779ba;padding:1.25rem 1.5rem;font-size:.75rem;line-height:1;display:block}[data-whatinput=mouse] .tabs-title>a{outline:0}.tabs-title>a:hover{color:#1468a0;background:#fefefe}.tabs-title>a:focus,.tabs-title>a[aria-selected=true]{color:#1779ba;background:#e6e6e6}.tabs-content{color:#0a0a0a;background:#fefefe;border:1px solid #e6e6e6;border-top:0;-webkit-transition:all .5s;transition:all .5s}.tabs-content.vertical{border:1px solid #e6e6e6;border-left:0}.tabs-panel{padding:1rem;display:none}.tabs-panel.is-active{display:block}.thumbnail{border:4px solid #fefefe;border-radius:0;max-width:100%;margin-bottom:1rem;line-height:0;display:inline-block;-webkit-box-shadow:0 0 0 1px #0a0a0a33;box-shadow:0 0 0 1px #0a0a0a33}a.thumbnail{-webkit-transition:box-shadow .2s ease-out,-webkit-box-shadow .2s ease-out;transition:box-shadow .2s ease-out,-webkit-box-shadow .2s ease-out}a.thumbnail:hover,a.thumbnail:focus{-webkit-box-shadow:0 0 6px 1px #1779ba80;box-shadow:0 0 6px 1px #1779ba80}a.thumbnail image{-webkit-box-shadow:none;box-shadow:none}.menu{-ms-flex-wrap:wrap;flex-wrap:wrap;margin:0;padding:0;list-style:none;display:-webkit-box;display:-ms-flexbox;display:flex;position:relative}[data-whatinput=mouse] .menu li{outline:0}.menu a,.menu .button{padding:.7rem 1rem;line-height:1;text-decoration:none;display:block}.menu input,.menu select,.menu a,.menu button{margin-bottom:0}.menu input{display:inline-block}.menu,.menu.horizontal{-webkit-box-orient:horizontal;-webkit-box-direction:normal;-ms-flex-flow:wrap;flex-flow:wrap}.menu.vertical{-webkit-box-orient:vertical;-webkit-box-direction:normal;-ms-flex-flow:column;flex-flow:column}.menu.vertical.icon-top li a img,.menu.vertical.icon-top li a i,.menu.vertical.icon-top li a svg,.menu.vertical.icon-bottom li a img,.menu.vertical.icon-bottom li a i,.menu.vertical.icon-bottom li a svg{text-align:left}.menu.expanded li{-webkit-box-flex:1;-ms-flex:1 1 0;flex:1 1 0}.menu.expanded.icon-top li a img,.menu.expanded.icon-top li a i,.menu.expanded.icon-top li a svg,.menu.expanded.icon-bottom li a img,.menu.expanded.icon-bottom li a i,.menu.expanded.icon-bottom li a svg{text-align:left}.menu.simple{align-items:center}.menu.simple li+li{margin-left:1rem}.menu.simple a{padding:0}@media print,screen and (width>=40em){.menu.medium-horizontal{-webkit-box-orient:horizontal;-webkit-box-direction:normal;-ms-flex-flow:wrap;flex-flow:wrap}.menu.medium-vertical{-webkit-box-orient:vertical;-webkit-box-direction:normal;-ms-flex-flow:column;flex-flow:column}.menu.medium-expanded li,.menu.medium-simple li{-webkit-box-flex:1;-ms-flex:1 1 0;flex:1 1 0}}@media print,screen and (width>=64em){.menu.large-horizontal{-webkit-box-orient:horizontal;-webkit-box-direction:normal;-ms-flex-flow:wrap;flex-flow:wrap}.menu.large-vertical{-webkit-box-orient:vertical;-webkit-box-direction:normal;-ms-flex-flow:column;flex-flow:column}.menu.large-expanded li,.menu.large-simple li{-webkit-box-flex:1;-ms-flex:1 1 0;flex:1 1 0}}.menu.nested{margin-left:1rem;margin-right:0}.menu.icons a,.menu.icon-top a,.menu.icon-right a,.menu.icon-bottom a,.menu.icon-left a{display:-webkit-box;display:-ms-flexbox;display:flex}.menu.icon-left li a,.menu.nested.icon-left li a{-webkit-box-orient:horizontal;-webkit-box-direction:normal;-ms-flex-flow:row;flex-flow:row}.menu.icon-left li a img,.menu.icon-left li a i,.menu.icon-left li a svg,.menu.nested.icon-left li a img,.menu.nested.icon-left li a i,.menu.nested.icon-left li a svg{margin-right:.25rem}.menu.icon-right li a,.menu.nested.icon-right li a{-webkit-box-orient:horizontal;-webkit-box-direction:normal;-ms-flex-flow:row;flex-flow:row}.menu.icon-right li a img,.menu.icon-right li a i,.menu.icon-right li a svg,.menu.nested.icon-right li a img,.menu.nested.icon-right li a i,.menu.nested.icon-right li a svg{margin-left:.25rem}.menu.icon-top li a,.menu.nested.icon-top li a{-webkit-box-orient:vertical;-webkit-box-direction:normal;-ms-flex-flow:column;flex-flow:column}.menu.icon-top li a img,.menu.icon-top li a i,.menu.icon-top li a svg,.menu.nested.icon-top li a img,.menu.nested.icon-top li a i,.menu.nested.icon-top li a svg{text-align:center;align-self:stretch;margin-bottom:.25rem}.menu.icon-bottom li a,.menu.nested.icon-bottom li a{-webkit-box-orient:vertical;-webkit-box-direction:normal;-ms-flex-flow:column;flex-flow:column}.menu.icon-bottom li a img,.menu.icon-bottom li a i,.menu.icon-bottom li a svg,.menu.nested.icon-bottom li a img,.menu.nested.icon-bottom li a i,.menu.nested.icon-bottom li a svg{text-align:center;align-self:stretch;margin-bottom:.25rem}.menu .is-active>a,.menu .active>a{color:#fefefe;background:#1779ba}.menu.align-left{justify-content:flex-start}.menu.align-right li{justify-content:flex-end;display:-webkit-box;display:-ms-flexbox;display:flex}.menu.align-right li .submenu li{justify-content:flex-start}.menu.align-right.vertical li{text-align:right;display:block}.menu.align-right.vertical li .submenu li,.menu.align-right.icon-top li a img,.menu.align-right.icon-top li a i,.menu.align-right.icon-top li a svg,.menu.align-right.icon-bottom li a img,.menu.align-right.icon-bottom li a i,.menu.align-right.icon-bottom li a svg{text-align:right}.menu.align-right .nested{margin-left:0;margin-right:1rem}.menu.align-center li{justify-content:center;display:-webkit-box;display:-ms-flexbox;display:flex}.menu.align-center li .submenu li{justify-content:flex-start}.menu .menu-text{color:inherit;padding:.7rem 1rem;font-weight:700;line-height:1}.menu-centered>.menu{justify-content:center}.menu-centered>.menu li{justify-content:center;display:-webkit-box;display:-ms-flexbox;display:flex}.menu-centered>.menu li .submenu li{justify-content:flex-start}.no-js [data-responsive-menu] ul{display:none}.menu-icon{vertical-align:middle;cursor:pointer;width:20px;height:16px;display:inline-block;position:relative}.menu-icon:after{content:"";background:#fefefe;width:100%;height:2px;display:block;position:absolute;top:0;left:0;-webkit-box-shadow:0 7px #fefefe,0 14px #fefefe;box-shadow:0 7px #fefefe,0 14px #fefefe}.menu-icon:hover:after{background:#cacaca;-webkit-box-shadow:0 7px #cacaca,0 14px #cacaca;box-shadow:0 7px #cacaca,0 14px #cacaca}.menu-icon.dark{vertical-align:middle;cursor:pointer;width:20px;height:16px;display:inline-block;position:relative}.menu-icon.dark:after{content:"";background:#0a0a0a;width:100%;height:2px;display:block;position:absolute;top:0;left:0;-webkit-box-shadow:0 7px #0a0a0a,0 14px #0a0a0a;box-shadow:0 7px #0a0a0a,0 14px #0a0a0a}.menu-icon.dark:hover:after{background:#8a8a8a;-webkit-box-shadow:0 7px #8a8a8a,0 14px #8a8a8a;box-shadow:0 7px #8a8a8a,0 14px #8a8a8a}.accordion-menu li{width:100%}.accordion-menu a,.accordion-menu .is-accordion-submenu a{padding:.7rem 1rem}.accordion-menu .nested.is-accordion-submenu{margin-left:1rem;margin-right:0}.accordion-menu.align-right .nested.is-accordion-submenu{margin-left:0;margin-right:1rem}.accordion-menu .is-accordion-submenu-parent:not(.has-submenu-toggle)>a{position:relative}.accordion-menu .is-accordion-submenu-parent:not(.has-submenu-toggle)>a:after{content:"";border:6px solid #0000;border-top-color:#1779ba;border-bottom-width:0;width:0;height:0;margin-top:-3px;display:block;position:absolute;top:50%;right:1rem}.accordion-menu.align-left .is-accordion-submenu-parent>a:after{left:auto;right:1rem}.accordion-menu.align-right .is-accordion-submenu-parent>a:after{left:1rem;right:auto}.accordion-menu .is-accordion-submenu-parent[aria-expanded=true]>a:after{-webkit-transform-origin:50%;transform-origin:50%;-webkit-transform:rotate(180deg);transform:rotate(180deg)}.is-accordion-submenu-parent{position:relative}.has-submenu-toggle>a{margin-right:40px}.submenu-toggle{cursor:pointer;width:40px;height:40px;position:absolute;top:0;right:0}.submenu-toggle:after{content:"";border:6px solid #0000;border-top-color:#1779ba;border-bottom-width:0;width:0;height:0;margin:auto;display:block;top:0;bottom:0}.submenu-toggle[aria-expanded=true]:after{-webkit-transform-origin:50%;transform-origin:50%;-webkit-transform:scaleY(-1);transform:scaleY(-1)}.submenu-toggle-text{clip:rect(0,0,0,0)!important;white-space:nowrap!important;border:0!important;width:1px!important;height:1px!important;padding:0!important;position:absolute!important;overflow:hidden!important}.is-drilldown{position:relative;overflow:hidden}.is-drilldown li{display:block}.is-drilldown.animate-height{-webkit-transition:height .5s;transition:height .5s}.drilldown a{background:#fefefe;padding:.7rem 1rem}.drilldown .is-drilldown-submenu{z-index:-1;background:#fefefe;width:100%;-webkit-transition:transform .15s linear,-webkit-transform .15s linear;transition:transform .15s linear,-webkit-transform .15s linear;position:absolute;top:0;left:100%}.drilldown .is-drilldown-submenu.is-active{z-index:1;display:block;-webkit-transform:translate(-100%);transform:translate(-100%)}.drilldown .is-drilldown-submenu.is-closing{-webkit-transform:translate(100%);transform:translate(100%)}.drilldown .is-drilldown-submenu a{padding:.7rem 1rem}.drilldown .nested.is-drilldown-submenu{margin-left:0;margin-right:0}.drilldown .drilldown-submenu-cover-previous{min-height:100%}.drilldown .is-drilldown-submenu-parent>a{position:relative}.drilldown .is-drilldown-submenu-parent>a:after{content:"";border:6px solid #0000;border-left-color:#1779ba;border-right-width:0;width:0;height:0;margin-top:-6px;display:block;position:absolute;top:50%;right:1rem}.drilldown.align-left .is-drilldown-submenu-parent>a:after{content:"";border:6px solid #0000;border-left-color:#1779ba;border-right-width:0;width:0;height:0;display:block;left:auto;right:1rem}.drilldown.align-right .is-drilldown-submenu-parent>a:after{content:"";border:6px solid #0000;border-left-width:0;border-right-color:#1779ba;width:0;height:0;display:block;left:1rem;right:auto}.drilldown .js-drilldown-back>a:before{content:"";vertical-align:middle;border:6px solid #0000;border-left-width:0;border-right-color:#1779ba;width:0;height:0;margin-right:.75rem;display:inline-block}.dropdown.menu>li.opens-left>.is-dropdown-submenu{top:100%;left:auto;right:0}.dropdown.menu>li.opens-right>.is-dropdown-submenu{top:100%;left:0;right:auto}.dropdown.menu>li.is-dropdown-submenu-parent>a{padding-right:1.5rem;position:relative}.dropdown.menu>li.is-dropdown-submenu-parent>a:after{content:"";border:6px solid #0000;border-top-color:#1779ba;border-bottom-width:0;width:0;height:0;margin-top:-3px;display:block;left:auto;right:5px}[data-whatinput=mouse] .dropdown.menu a{outline:0}.dropdown.menu>li>a{padding:.7rem 1rem}.dropdown.menu>li.is-active>a{color:#1779ba;background:0 0}.no-js .dropdown.menu ul{display:none}.dropdown.menu .nested.is-dropdown-submenu{margin-left:0;margin-right:0}.dropdown.menu.vertical>li .is-dropdown-submenu{top:0}.dropdown.menu.vertical>li.opens-left>.is-dropdown-submenu{top:0;left:auto;right:100%}.dropdown.menu.vertical>li.opens-right>.is-dropdown-submenu{left:100%;right:auto}.dropdown.menu.vertical>li>a:after{right:14px}.dropdown.menu.vertical>li.opens-left>a:after{content:"";border:6px solid #0000;border-left-width:0;border-right-color:#1779ba;width:0;height:0;display:block;left:5px;right:auto}.dropdown.menu.vertical>li.opens-right>a:after{content:"";border:6px solid #0000;border-left-color:#1779ba;border-right-width:0;width:0;height:0;display:block}@media print,screen and (width>=40em){.dropdown.menu.medium-horizontal>li.opens-left>.is-dropdown-submenu{top:100%;left:auto;right:0}.dropdown.menu.medium-horizontal>li.opens-right>.is-dropdown-submenu{top:100%;left:0;right:auto}.dropdown.menu.medium-horizontal>li.is-dropdown-submenu-parent>a{padding-right:1.5rem;position:relative}.dropdown.menu.medium-horizontal>li.is-dropdown-submenu-parent>a:after{content:"";border:6px solid #0000;border-top-color:#1779ba;border-bottom-width:0;width:0;height:0;margin-top:-3px;display:block;left:auto;right:5px}.dropdown.menu.medium-vertical>li .is-dropdown-submenu{top:0}.dropdown.menu.medium-vertical>li.opens-left>.is-dropdown-submenu{top:0;left:auto;right:100%}.dropdown.menu.medium-vertical>li.opens-right>.is-dropdown-submenu{left:100%;right:auto}.dropdown.menu.medium-vertical>li>a:after{right:14px}.dropdown.menu.medium-vertical>li.opens-left>a:after{content:"";border:6px solid #0000;border-left-width:0;border-right-color:#1779ba;width:0;height:0;display:block;left:5px;right:auto}.dropdown.menu.medium-vertical>li.opens-right>a:after{content:"";border:6px solid #0000;border-left-color:#1779ba;border-right-width:0;width:0;height:0;display:block}}@media print,screen and (width>=64em){.dropdown.menu.large-horizontal>li.opens-left>.is-dropdown-submenu{top:100%;left:auto;right:0}.dropdown.menu.large-horizontal>li.opens-right>.is-dropdown-submenu{top:100%;left:0;right:auto}.dropdown.menu.large-horizontal>li.is-dropdown-submenu-parent>a{padding-right:1.5rem;position:relative}.dropdown.menu.large-horizontal>li.is-dropdown-submenu-parent>a:after{content:"";border:6px solid #0000;border-top-color:#1779ba;border-bottom-width:0;width:0;height:0;margin-top:-3px;display:block;left:auto;right:5px}.dropdown.menu.large-vertical>li .is-dropdown-submenu{top:0}.dropdown.menu.large-vertical>li.opens-left>.is-dropdown-submenu{top:0;left:auto;right:100%}.dropdown.menu.large-vertical>li.opens-right>.is-dropdown-submenu{left:100%;right:auto}.dropdown.menu.large-vertical>li>a:after{right:14px}.dropdown.menu.large-vertical>li.opens-left>a:after{content:"";border:6px solid #0000;border-left-width:0;border-right-color:#1779ba;width:0;height:0;display:block;left:5px;right:auto}.dropdown.menu.large-vertical>li.opens-right>a:after{content:"";border:6px solid #0000;border-left-color:#1779ba;border-right-width:0;width:0;height:0;display:block}}.dropdown.menu.align-right .is-dropdown-submenu.first-sub{top:100%;left:auto;right:0}.is-dropdown-menu.vertical{width:100px}.is-dropdown-menu.vertical.align-right{float:right}.is-dropdown-submenu-parent{position:relative}.is-dropdown-submenu-parent a:after{margin-top:-6px;position:absolute;top:50%;left:auto;right:5px}.is-dropdown-submenu-parent.opens-inner>.is-dropdown-submenu{top:100%;left:auto}.is-dropdown-submenu-parent.opens-left>.is-dropdown-submenu{left:auto;right:100%}.is-dropdown-submenu-parent.opens-right>.is-dropdown-submenu{left:100%;right:auto}.is-dropdown-submenu{z-index:1;background:#fefefe;border:1px solid #cacaca;min-width:200px;display:none;position:absolute;top:0;left:100%}.dropdown .is-dropdown-submenu a{padding:.7rem 1rem}.is-dropdown-submenu .is-dropdown-submenu-parent>a:after{right:14px}.is-dropdown-submenu .is-dropdown-submenu-parent.opens-left>a:after{content:"";border:6px solid #0000;border-left-width:0;border-right-color:#1779ba;width:0;height:0;display:block;left:5px;right:auto}.is-dropdown-submenu .is-dropdown-submenu-parent.opens-right>a:after{content:"";border:6px solid #0000;border-left-color:#1779ba;border-right-width:0;width:0;height:0;display:block}.is-dropdown-submenu .is-dropdown-submenu{margin-top:-1px}.is-dropdown-submenu>li{width:100%}.is-dropdown-submenu.js-dropdown-active{display:block}.is-off-canvas-open{overflow:hidden}.js-off-canvas-overlay{z-index:11;opacity:0;visibility:hidden;background:#fefefe40;width:100%;height:100%;-webkit-transition:opacity .5s,visibility .5s;transition:opacity .5s,visibility .5s;position:absolute;top:0;left:0;overflow:hidden}.js-off-canvas-overlay.is-visible{opacity:1;visibility:visible}.js-off-canvas-overlay.is-closable{cursor:pointer}.js-off-canvas-overlay.is-overlay-absolute{position:absolute}.js-off-canvas-overlay.is-overlay-fixed{position:fixed}.off-canvas-wrapper{position:relative;overflow:hidden}.off-canvas{z-index:12;-webkit-backface-visibility:hidden;backface-visibility:hidden;background:#e6e6e6;-webkit-transition:transform .5s,-webkit-transform .5s;transition:transform .5s,-webkit-transform .5s;position:fixed}[data-whatinput=mouse] .off-canvas{outline:0}.off-canvas.is-transition-push{z-index:12}.off-canvas.is-closed{visibility:hidden}.off-canvas.is-transition-overlap{z-index:13}.off-canvas.is-transition-overlap.is-open{-webkit-box-shadow:0 0 10px #0a0a0ab3;box-shadow:0 0 10px #0a0a0ab3}.off-canvas.is-open{-webkit-transform:translate(0);transform:translate(0)}.off-canvas-absolute{z-index:12;-webkit-backface-visibility:hidden;backface-visibility:hidden;background:#e6e6e6;-webkit-transition:transform .5s,-webkit-transform .5s;transition:transform .5s,-webkit-transform .5s;position:absolute}[data-whatinput=mouse] .off-canvas-absolute{outline:0}.off-canvas-absolute.is-transition-push{z-index:12}.off-canvas-absolute.is-closed{visibility:hidden}.off-canvas-absolute.is-transition-overlap{z-index:13}.off-canvas-absolute.is-transition-overlap.is-open{-webkit-box-shadow:0 0 10px #0a0a0ab3;box-shadow:0 0 10px #0a0a0ab3}.off-canvas-absolute.is-open{-webkit-transform:translate(0);transform:translate(0)}.position-left{-webkit-overflow-scrolling:touch;width:250px;height:100%;top:0;left:0;overflow-y:auto;-webkit-transform:translate(-250px);transform:translate(-250px)}.off-canvas-content .off-canvas.position-left{-webkit-transform:translate(-250px);transform:translate(-250px)}.off-canvas-content .off-canvas.position-left.is-transition-overlap.is-open{-webkit-transform:translate(0);transform:translate(0)}.off-canvas-content.is-open-left.has-transition-push{-webkit-transform:translate(250px);transform:translate(250px)}.position-left.is-transition-push{-webkit-box-shadow:inset -13px 0 20px -13px #0a0a0a40;box-shadow:inset -13px 0 20px -13px #0a0a0a40}.position-right{-webkit-overflow-scrolling:touch;width:250px;height:100%;top:0;right:0;overflow-y:auto;-webkit-transform:translate(250px);transform:translate(250px)}.off-canvas-content .off-canvas.position-right{-webkit-transform:translate(250px);transform:translate(250px)}.off-canvas-content .off-canvas.position-right.is-transition-overlap.is-open{-webkit-transform:translate(0);transform:translate(0)}.off-canvas-content.is-open-right.has-transition-push{-webkit-transform:translate(-250px);transform:translate(-250px)}.position-right.is-transition-push{-webkit-box-shadow:inset 13px 0 20px -13px #0a0a0a40;box-shadow:inset 13px 0 20px -13px #0a0a0a40}.position-top{-webkit-overflow-scrolling:touch;width:100%;height:250px;top:0;left:0;overflow-x:auto;-webkit-transform:translateY(-250px);transform:translateY(-250px)}.off-canvas-content .off-canvas.position-top{-webkit-transform:translateY(-250px);transform:translateY(-250px)}.off-canvas-content .off-canvas.position-top.is-transition-overlap.is-open{-webkit-transform:translate(0);transform:translate(0)}.off-canvas-content.is-open-top.has-transition-push{-webkit-transform:translateY(250px);transform:translateY(250px)}.position-top.is-transition-push{-webkit-box-shadow:inset 0 -13px 20px -13px #0a0a0a40;box-shadow:inset 0 -13px 20px -13px #0a0a0a40}.position-bottom{-webkit-overflow-scrolling:touch;width:100%;height:250px;bottom:0;left:0;overflow-x:auto;-webkit-transform:translateY(250px);transform:translateY(250px)}.off-canvas-content .off-canvas.position-bottom{-webkit-transform:translateY(250px);transform:translateY(250px)}.off-canvas-content .off-canvas.position-bottom.is-transition-overlap.is-open{-webkit-transform:translate(0);transform:translate(0)}.off-canvas-content.is-open-bottom.has-transition-push{-webkit-transform:translateY(-250px);transform:translateY(-250px)}.position-bottom.is-transition-push{-webkit-box-shadow:inset 0 13px 20px -13px #0a0a0a40;box-shadow:inset 0 13px 20px -13px #0a0a0a40}.off-canvas-content{-webkit-backface-visibility:hidden;backface-visibility:hidden;-webkit-transform:none;transform:none}.off-canvas-content.has-transition-overlap,.off-canvas-content.has-transition-push{-webkit-transition:transform .5s,-webkit-transform .5s;transition:transform .5s,-webkit-transform .5s}.off-canvas-content.has-transition-push,.off-canvas-content .off-canvas.is-open{-webkit-transform:translate(0);transform:translate(0)}@media print,screen and (width>=40em){.position-left.reveal-for-medium{z-index:12;visibility:visible;-webkit-transition:none;transition:none;-webkit-transform:none;transform:none}.position-left.reveal-for-medium .close-button{display:none}.off-canvas-content .position-left.reveal-for-medium{-webkit-transform:none;transform:none}.off-canvas-content.has-reveal-left,.position-left.reveal-for-medium~.off-canvas-content{margin-left:250px}.position-right.reveal-for-medium{z-index:12;visibility:visible;-webkit-transition:none;transition:none;-webkit-transform:none;transform:none}.position-right.reveal-for-medium .close-button{display:none}.off-canvas-content .position-right.reveal-for-medium{-webkit-transform:none;transform:none}.off-canvas-content.has-reveal-right,.position-right.reveal-for-medium~.off-canvas-content{margin-right:250px}.position-top.reveal-for-medium{z-index:12;visibility:visible;-webkit-transition:none;transition:none;-webkit-transform:none;transform:none}.position-top.reveal-for-medium .close-button{display:none}.off-canvas-content .position-top.reveal-for-medium{-webkit-transform:none;transform:none}.off-canvas-content.has-reveal-top,.position-top.reveal-for-medium~.off-canvas-content{margin-top:250px}.position-bottom.reveal-for-medium{z-index:12;visibility:visible;-webkit-transition:none;transition:none;-webkit-transform:none;transform:none}.position-bottom.reveal-for-medium .close-button{display:none}.off-canvas-content .position-bottom.reveal-for-medium{-webkit-transform:none;transform:none}.off-canvas-content.has-reveal-bottom,.position-bottom.reveal-for-medium~.off-canvas-content{margin-bottom:250px}}@media print,screen and (width>=64em){.position-left.reveal-for-large{z-index:12;visibility:visible;-webkit-transition:none;transition:none;-webkit-transform:none;transform:none}.position-left.reveal-for-large .close-button{display:none}.off-canvas-content .position-left.reveal-for-large{-webkit-transform:none;transform:none}.off-canvas-content.has-reveal-left,.position-left.reveal-for-large~.off-canvas-content{margin-left:250px}.position-right.reveal-for-large{z-index:12;visibility:visible;-webkit-transition:none;transition:none;-webkit-transform:none;transform:none}.position-right.reveal-for-large .close-button{display:none}.off-canvas-content .position-right.reveal-for-large{-webkit-transform:none;transform:none}.off-canvas-content.has-reveal-right,.position-right.reveal-for-large~.off-canvas-content{margin-right:250px}.position-top.reveal-for-large{z-index:12;visibility:visible;-webkit-transition:none;transition:none;-webkit-transform:none;transform:none}.position-top.reveal-for-large .close-button{display:none}.off-canvas-content .position-top.reveal-for-large{-webkit-transform:none;transform:none}.off-canvas-content.has-reveal-top,.position-top.reveal-for-large~.off-canvas-content{margin-top:250px}.position-bottom.reveal-for-large{z-index:12;visibility:visible;-webkit-transition:none;transition:none;-webkit-transform:none;transform:none}.position-bottom.reveal-for-large .close-button{display:none}.off-canvas-content .position-bottom.reveal-for-large{-webkit-transform:none;transform:none}.off-canvas-content.has-reveal-bottom,.position-bottom.reveal-for-large~.off-canvas-content{margin-bottom:250px}}@media print,screen and (width>=40em){.off-canvas.in-canvas-for-medium{visibility:visible;background:0 0;width:auto;height:auto;-webkit-transition:none;transition:none;position:static;overflow:visible}.off-canvas.in-canvas-for-medium.position-left,.off-canvas.in-canvas-for-medium.position-right,.off-canvas.in-canvas-for-medium.position-top,.off-canvas.in-canvas-for-medium.position-bottom{-webkit-box-shadow:none;box-shadow:none;-webkit-transform:none;transform:none}.off-canvas.in-canvas-for-medium .close-button{display:none}}@media print,screen and (width>=64em){.off-canvas.in-canvas-for-large{visibility:visible;background:0 0;width:auto;height:auto;-webkit-transition:none;transition:none;position:static;overflow:visible}.off-canvas.in-canvas-for-large.position-left,.off-canvas.in-canvas-for-large.position-right,.off-canvas.in-canvas-for-large.position-top,.off-canvas.in-canvas-for-large.position-bottom{-webkit-box-shadow:none;box-shadow:none;-webkit-transform:none;transform:none}.off-canvas.in-canvas-for-large .close-button{display:none}}html.is-reveal-open{width:100%;position:fixed;overflow-y:hidden}html.is-reveal-open.zf-has-scroll{-webkit-overflow-scrolling:touch;overflow-y:scroll}html.is-reveal-open body{overflow-y:hidden}.reveal-overlay{z-index:1005;-webkit-overflow-scrolling:touch;background-color:#0a0a0a73;display:none;position:fixed;inset:0;overflow-y:auto}.reveal{-webkit-overflow-scrolling:touch;z-index:1006;-webkit-backface-visibility:hidden;backface-visibility:hidden;background-color:#fefefe;border:1px solid #cacaca;border-radius:0;margin-left:auto;margin-right:auto;padding:1rem;display:none;position:relative;top:100px;overflow-y:auto}[data-whatinput=mouse] .reveal{outline:0}@media print,screen and (width>=40em){.reveal{min-height:0}}.reveal .column{min-width:0}.reveal>:last-child{margin-bottom:0}@media print,screen and (width>=40em){.reveal{width:600px;max-width:75rem}}.reveal.collapse{padding:0}@media print,screen and (width>=40em){.reveal.tiny{width:30%;max-width:75rem}.reveal.small{width:50%;max-width:75rem}.reveal.large{width:90%;max-width:75rem}}.reveal.full{border:0;border-radius:0;width:100%;max-width:none;height:100%;min-height:100%;margin-left:0;inset:0}@media print,screen and (width<=39.9988em){.reveal{border:0;border-radius:0;width:100%;max-width:none;height:100%;min-height:100%;margin-left:0;inset:0}}.reveal.without-overlay{position:fixed}.sticky-container{position:relative}.sticky{z-index:0;position:relative;-webkit-transform:translate(0,0);transform:translate(0,0)}.sticky.is-stuck{z-index:5;width:100%;position:fixed}.sticky.is-stuck.is-at-top{top:0}.sticky.is-stuck.is-at-bottom{bottom:0}.sticky.is-anchored{position:relative;left:auto;right:auto}.sticky.is-anchored.is-at-bottom{bottom:0}.title-bar{color:#fefefe;background:#0a0a0a;justify-content:flex-start;align-items:center;padding:.5rem;display:-webkit-box;display:-ms-flexbox;display:flex}.title-bar .menu-icon{margin-left:.25rem;margin-right:.25rem}.title-bar-left,.title-bar-right{-webkit-box-flex:1;-ms-flex:1 1 0;flex:1 1 0}.title-bar-right{text-align:right}.title-bar-title{vertical-align:middle;font-weight:700;display:inline-block}.top-bar{-ms-flex-wrap:nowrap;flex-wrap:nowrap;justify-content:space-between;align-items:center;padding:.5rem;display:-webkit-box;display:-ms-flexbox;display:flex}.top-bar,.top-bar ul{background-color:#e6e6e6}.top-bar input{max-width:200px;margin-right:1rem}.top-bar .input-group-field{width:100%;margin-right:0}.top-bar input.button{width:auto}.top-bar{-ms-flex-wrap:wrap;flex-wrap:wrap}.top-bar .top-bar-left,.top-bar .top-bar-right{-webkit-box-flex:0;-ms-flex:0 0 100%;flex:0 0 100%;max-width:100%}@media print,screen and (width>=40em){.top-bar{-ms-flex-wrap:nowrap;flex-wrap:nowrap}.top-bar .top-bar-left{-webkit-box-flex:1;-ms-flex:auto;flex:auto;margin-right:auto}.top-bar .top-bar-right{-webkit-box-flex:0;-ms-flex:0 auto;flex:0 auto;margin-left:auto}}@media print,screen and (width<=63.9988em){.top-bar.stacked-for-medium{-ms-flex-wrap:wrap;flex-wrap:wrap}.top-bar.stacked-for-medium .top-bar-left,.top-bar.stacked-for-medium .top-bar-right{-webkit-box-flex:0;-ms-flex:0 0 100%;flex:0 0 100%;max-width:100%}}@media print,screen and (width<=74.9988em){.top-bar.stacked-for-large{-ms-flex-wrap:wrap;flex-wrap:wrap}.top-bar.stacked-for-large .top-bar-left,.top-bar.stacked-for-large .top-bar-right{-webkit-box-flex:0;-ms-flex:0 0 100%;flex:0 0 100%;max-width:100%}}.top-bar-title{-webkit-box-flex:0;-ms-flex:none;flex:none;margin:.5rem 1rem .5rem 0}.top-bar-left,.top-bar-right{-webkit-box-flex:0;-ms-flex:none;flex:none}.float-left{float:left!important}.float-right{float:right!important}.float-center{margin-left:auto;margin-right:auto;display:block}.clearfix:before,.clearfix:after{content:" ";-webkit-box-ordinal-group:2;-ms-flex-preferred-size:0;-ms-flex-order:1;flex-basis:0;order:1;display:table}.clearfix:after{clear:both}.align-left{justify-content:flex-start}.align-right{justify-content:flex-end}.align-center{justify-content:center}.align-justify{justify-content:space-between}.align-spaced{justify-content:space-around}.align-left.vertical.menu>li>a{justify-content:flex-start}.align-right.vertical.menu>li>a{justify-content:flex-end}.align-center.vertical.menu>li>a{justify-content:center}.align-top{align-items:flex-start}.align-self-top{align-self:flex-start}.align-bottom{align-items:flex-end}.align-self-bottom{align-self:flex-end}.align-middle{align-items:center}.align-self-middle{align-self:center}.align-stretch{align-items:stretch}.align-self-stretch{align-self:stretch}.align-center-middle{place-content:center;align-items:center}.small-order-1{-webkit-box-ordinal-group:2;-ms-flex-order:1;order:1}.small-order-2{-webkit-box-ordinal-group:3;-ms-flex-order:2;order:2}.small-order-3{-webkit-box-ordinal-group:4;-ms-flex-order:3;order:3}.small-order-4{-webkit-box-ordinal-group:5;-ms-flex-order:4;order:4}.small-order-5{-webkit-box-ordinal-group:6;-ms-flex-order:5;order:5}.small-order-6{-webkit-box-ordinal-group:7;-ms-flex-order:6;order:6}@media print,screen and (width>=40em){.medium-order-1{-webkit-box-ordinal-group:2;-ms-flex-order:1;order:1}.medium-order-2{-webkit-box-ordinal-group:3;-ms-flex-order:2;order:2}.medium-order-3{-webkit-box-ordinal-group:4;-ms-flex-order:3;order:3}.medium-order-4{-webkit-box-ordinal-group:5;-ms-flex-order:4;order:4}.medium-order-5{-webkit-box-ordinal-group:6;-ms-flex-order:5;order:5}.medium-order-6{-webkit-box-ordinal-group:7;-ms-flex-order:6;order:6}}@media print,screen and (width>=64em){.large-order-1{-webkit-box-ordinal-group:2;-ms-flex-order:1;order:1}.large-order-2{-webkit-box-ordinal-group:3;-ms-flex-order:2;order:2}.large-order-3{-webkit-box-ordinal-group:4;-ms-flex-order:3;order:3}.large-order-4{-webkit-box-ordinal-group:5;-ms-flex-order:4;order:4}.large-order-5{-webkit-box-ordinal-group:6;-ms-flex-order:5;order:5}.large-order-6{-webkit-box-ordinal-group:7;-ms-flex-order:6;order:6}}.flex-container{display:-webkit-box;display:-ms-flexbox;display:flex}.flex-child-auto{-webkit-box-flex:1;-ms-flex:auto;flex:auto}.flex-child-grow{-webkit-box-flex:1;-ms-flex:1 0 auto;flex:1 0 auto}.flex-child-shrink{-webkit-box-flex:0;-ms-flex:0 auto;flex:0 auto}.flex-dir-row{-webkit-box-orient:horizontal;-webkit-box-direction:normal;-ms-flex-direction:row;flex-direction:row}.flex-dir-row-reverse{-webkit-box-orient:horizontal;-webkit-box-direction:reverse;-ms-flex-direction:row-reverse;flex-direction:row-reverse}.flex-dir-column{-webkit-box-orient:vertical;-webkit-box-direction:normal;-ms-flex-direction:column;flex-direction:column}.flex-dir-column-reverse{-webkit-box-orient:vertical;-webkit-box-direction:reverse;-ms-flex-direction:column-reverse;flex-direction:column-reverse}@media print,screen and (width>=40em){.medium-flex-container{display:-webkit-box;display:-ms-flexbox;display:flex}.medium-flex-child-auto{-webkit-box-flex:1;-ms-flex:auto;flex:auto}.medium-flex-child-grow{-webkit-box-flex:1;-ms-flex:1 0 auto;flex:1 0 auto}.medium-flex-child-shrink{-webkit-box-flex:0;-ms-flex:0 auto;flex:0 auto}.medium-flex-dir-row{-webkit-box-orient:horizontal;-webkit-box-direction:normal;-ms-flex-direction:row;flex-direction:row}.medium-flex-dir-row-reverse{-webkit-box-orient:horizontal;-webkit-box-direction:reverse;-ms-flex-direction:row-reverse;flex-direction:row-reverse}.medium-flex-dir-column{-webkit-box-orient:vertical;-webkit-box-direction:normal;-ms-flex-direction:column;flex-direction:column}.medium-flex-dir-column-reverse{-webkit-box-orient:vertical;-webkit-box-direction:reverse;-ms-flex-direction:column-reverse;flex-direction:column-reverse}}@media print,screen and (width>=64em){.large-flex-container{display:-webkit-box;display:-ms-flexbox;display:flex}.large-flex-child-auto{-webkit-box-flex:1;-ms-flex:auto;flex:auto}.large-flex-child-grow{-webkit-box-flex:1;-ms-flex:1 0 auto;flex:1 0 auto}.large-flex-child-shrink{-webkit-box-flex:0;-ms-flex:0 auto;flex:0 auto}.large-flex-dir-row{-webkit-box-orient:horizontal;-webkit-box-direction:normal;-ms-flex-direction:row;flex-direction:row}.large-flex-dir-row-reverse{-webkit-box-orient:horizontal;-webkit-box-direction:reverse;-ms-flex-direction:row-reverse;flex-direction:row-reverse}.large-flex-dir-column{-webkit-box-orient:vertical;-webkit-box-direction:normal;-ms-flex-direction:column;flex-direction:column}.large-flex-dir-column-reverse{-webkit-box-orient:vertical;-webkit-box-direction:reverse;-ms-flex-direction:column-reverse;flex-direction:column-reverse}}.hide{display:none!important}.invisible{visibility:hidden}.visible{visibility:visible}@media print,screen and (width<=39.9988em){.hide-for-small-only{display:none!important}}@media screen and (width<=0),screen and (width>=40em){.show-for-small-only{display:none!important}}@media print,screen and (width>=40em){.hide-for-medium{display:none!important}}@media screen and (width<=39.9988em){.show-for-medium{display:none!important}}@media print,screen and (width>=40em) and (width<=63.9988em){.hide-for-medium-only{display:none!important}}@media screen and (width<=39.9988em),screen and (width>=64em){.show-for-medium-only{display:none!important}}@media print,screen and (width>=64em){.hide-for-large{display:none!important}}@media screen and (width<=63.9988em){.show-for-large{display:none!important}}@media print,screen and (width>=64em) and (width<=74.9988em){.hide-for-large-only{display:none!important}}@media screen and (width<=63.9988em),screen and (width>=75em){.show-for-large-only{display:none!important}}.show-for-sr,.show-on-focus{clip:rect(0,0,0,0)!important;white-space:nowrap!important;border:0!important;width:1px!important;height:1px!important;padding:0!important;position:absolute!important;overflow:hidden!important}.show-on-focus:active,.show-on-focus:focus{clip:auto!important;white-space:normal!important;width:auto!important;height:auto!important;position:static!important;overflow:visible!important}.show-for-landscape,.hide-for-portrait{display:block!important}@media screen and (orientation:landscape){.show-for-landscape,.hide-for-portrait{display:block!important}}@media screen and (orientation:portrait){.show-for-landscape,.hide-for-portrait{display:none!important}}.hide-for-landscape,.show-for-portrait{display:none!important}@media screen and (orientation:landscape){.hide-for-landscape,.show-for-portrait{display:none!important}}@media screen and (orientation:portrait){.hide-for-landscape,.show-for-portrait{display:block!important}}.show-for-dark-mode{display:none}.hide-for-dark-mode{display:block}@media screen and (prefers-color-scheme:dark){.show-for-dark-mode{display:block!important}.hide-for-dark-mode{display:none!important}}.show-for-ie{display:none}@media (-ms-high-contrast:none),(-ms-high-contrast:active){.show-for-ie{display:block!important}.hide-for-ie{display:none!important}}.show-for-sticky{display:none}.is-stuck .show-for-sticky{display:block}.is-stuck .hide-for-sticky{display:none}
\ No newline at end of file
diff --git a/test/js/bun/css/files/hint.css b/test/js/bun/css/files/hint.css
new file mode 100644
index 0000000000..f65b62d58d
--- /dev/null
+++ b/test/js/bun/css/files/hint.css
@@ -0,0 +1,561 @@
+/*! Hint.css - v3.0.0 - 2023-11-29
+* https://kushagra.dev/lab/hint/
+* Copyright (c) 2023 Kushagra Gour */
+
+/*-------------------------------------*\
+	HINT.css - A CSS tooltip library
+\*-------------------------------------*/
+/**
+ * HINT.css is a tooltip library made in pure CSS.
+ *
+ * Source: https://github.com/chinchang/hint.css
+ * Demo: http://kushagragour.in/lab/hint/
+ *
+ */
+/**
+ * source: hint-core.scss
+ *
+ * Defines the basic styling for the tooltip.
+ * Each tooltip is made of 2 parts:
+ * 	1) body (:after)
+ * 	2) arrow (:before)
+ *
+ * Classes added:
+ * 	1) hint
+ */
+ [class*=hint--] {
+  position: relative;
+  display: inline-block;
+  /**
+   * tooltip arrow
+   */
+  /**
+   * tooltip body
+   */
+}
+[class*=hint--]:before, [class*=hint--]:after {
+  position: absolute;
+  transform: translate3d(0, 0, 0);
+  visibility: hidden;
+  opacity: 0;
+  z-index: 1000000;
+  pointer-events: none;
+  transition: 0.3s ease;
+  transition-delay: 0ms;
+}
+[class*=hint--]:hover:before, [class*=hint--]:hover:after {
+  visibility: visible;
+  opacity: 1;
+}
+[class*=hint--]:hover:before, [class*=hint--]:hover:after {
+  transition-delay: 100ms;
+}
+[class*=hint--]:before {
+  content: "";
+  position: absolute;
+  background: transparent;
+  border: 6px solid transparent;
+  background-color: hsl(0, 0%, 22%);
+  clip-path: polygon(0% 0%, 100% 0%, 100% 100%);
+  z-index: 1000001;
+}
+[class*=hint--]:after {
+  background: hsl(0, 0%, 22%);
+  color: white;
+  padding: 8px 10px;
+  font-size: 1rem;
+  font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+  line-height: 1rem;
+  white-space: nowrap;
+}
+[class*=hint--][aria-label]:after {
+  content: attr(aria-label);
+}
+[class*=hint--][data-hint]:after {
+  content: attr(data-hint);
+}
+
+[aria-label=""]:before, [aria-label=""]:after,
+[data-hint=""]:before,
+[data-hint=""]:after {
+  display: none !important;
+}
+
+/**
+ * source: hint-position.scss
+ *
+ * Defines the positoning logic for the tooltips.
+ *
+ * Classes added:
+ * 	1) hint--top
+ * 	2) hint--bottom
+ * 	3) hint--left
+ * 	4) hint--right
+ */
+/**
+ * top tooltip
+ */
+.hint--top {
+  --rotation: 135deg;
+}
+.hint--top:before {
+  margin-bottom: -5.5px;
+  transform: rotate(var(--rotation));
+}
+.hint--top:before, .hint--top:after {
+  bottom: 100%;
+  left: 50%;
+}
+.hint--top:before {
+  left: calc(50% - 6px);
+}
+.hint--top:after {
+  transform: translateX(-50%);
+}
+.hint--top:hover:before {
+  transform: translateY(-8px) rotate(var(--rotation));
+}
+.hint--top:hover:after {
+  transform: translateX(-50%) translateY(-8px);
+}
+
+/**
+ * bottom tooltip
+ */
+.hint--bottom {
+  --rotation: -45deg;
+}
+.hint--bottom:before {
+  margin-top: -5.5px;
+  transform: rotate(var(--rotation));
+}
+.hint--bottom:before, .hint--bottom:after {
+  top: 100%;
+  left: 50%;
+}
+.hint--bottom:before {
+  left: calc(50% - 6px);
+}
+.hint--bottom:after {
+  transform: translateX(-50%);
+}
+.hint--bottom:hover:before {
+  transform: translateY(8px) rotate(var(--rotation));
+}
+.hint--bottom:hover:after {
+  transform: translateX(-50%) translateY(8px);
+}
+
+/**
+ * right tooltip
+ */
+.hint--right {
+  --rotation: -135deg;
+}
+.hint--right:before {
+  margin-left: -5.5px;
+  margin-bottom: -6px;
+  transform: rotate(var(--rotation));
+}
+.hint--right:after {
+  margin-bottom: calc(-1 * (1rem + 16px) / 2);
+}
+.hint--right:before, .hint--right:after {
+  left: 100%;
+  bottom: 50%;
+}
+.hint--right:hover:before {
+  transform: translateX(8px) rotate(var(--rotation));
+}
+.hint--right:hover:after {
+  transform: translateX(8px);
+}
+
+/**
+ * left tooltip
+ */
+.hint--left {
+  --rotation: 45deg;
+}
+.hint--left:before {
+  margin-right: -5.5px;
+  margin-bottom: -6px;
+  transform: rotate(var(--rotation));
+}
+.hint--left:after {
+  margin-bottom: calc(-1 * (1rem + 16px) / 2);
+}
+.hint--left:before, .hint--left:after {
+  right: 100%;
+  bottom: 50%;
+}
+.hint--left:hover:before {
+  transform: translateX(-8px) rotate(var(--rotation));
+}
+.hint--left:hover:after {
+  transform: translateX(-8px);
+}
+
+/**
+ * top-left tooltip
+ */
+.hint--top-left {
+  --rotation: 135deg;
+}
+.hint--top-left:before {
+  margin-bottom: -5.5px;
+  transform: rotate(var(--rotation));
+}
+.hint--top-left:before, .hint--top-left:after {
+  bottom: 100%;
+  left: 50%;
+}
+.hint--top-left:before {
+  left: calc(50% - 6px);
+}
+.hint--top-left:after {
+  transform: translateX(-100%);
+}
+.hint--top-left:after {
+  margin-left: 12px;
+}
+.hint--top-left:hover:before {
+  transform: translateY(-8px) rotate(var(--rotation));
+}
+.hint--top-left:hover:after {
+  transform: translateX(-100%) translateY(-8px);
+}
+
+/**
+ * top-right tooltip
+ */
+.hint--top-right {
+  --rotation: 135deg;
+}
+.hint--top-right:before {
+  margin-bottom: -5.5px;
+  transform: rotate(var(--rotation));
+}
+.hint--top-right:before, .hint--top-right:after {
+  bottom: 100%;
+  left: 50%;
+}
+.hint--top-right:before {
+  left: calc(50% - 6px);
+}
+.hint--top-right:after {
+  transform: translateX(0);
+}
+.hint--top-right:after {
+  margin-left: -12px;
+}
+.hint--top-right:hover:before {
+  transform: translateY(-8px) rotate(var(--rotation));
+}
+.hint--top-right:hover:after {
+  transform: translateY(-8px);
+}
+
+/**
+ * bottom-left tooltip
+ */
+.hint--bottom-left {
+  --rotation: -45deg;
+}
+.hint--bottom-left:before {
+  margin-top: -5.5px;
+  transform: rotate(var(--rotation));
+}
+.hint--bottom-left:before, .hint--bottom-left:after {
+  top: 100%;
+  left: 50%;
+}
+.hint--bottom-left:before {
+  left: calc(50% - 6px);
+}
+.hint--bottom-left:after {
+  transform: translateX(-100%);
+}
+.hint--bottom-left:after {
+  margin-left: 12px;
+}
+.hint--bottom-left:hover:before {
+  transform: translateY(8px) rotate(var(--rotation));
+}
+.hint--bottom-left:hover:after {
+  transform: translateX(-100%) translateY(8px);
+}
+
+/**
+ * bottom-right tooltip
+ */
+.hint--bottom-right {
+  --rotation: -45deg;
+}
+.hint--bottom-right:before {
+  margin-top: -5.5px;
+  transform: rotate(var(--rotation));
+}
+.hint--bottom-right:before, .hint--bottom-right:after {
+  top: 100%;
+  left: 50%;
+}
+.hint--bottom-right:before {
+  left: calc(50% - 6px);
+}
+.hint--bottom-right:after {
+  transform: translateX(0);
+}
+.hint--bottom-right:after {
+  margin-left: -12px;
+}
+.hint--bottom-right:hover:before {
+  transform: translateY(8px) rotate(var(--rotation));
+}
+.hint--bottom-right:hover:after {
+  transform: translateY(8px);
+}
+
+/**
+ * source: hint-sizes.scss
+ *
+ * Defines width restricted tooltips that can span
+ * across multiple lines.
+ *
+ * Classes added:
+ * 	1) hint--small
+ * 	2) hint--medium
+ * 	3) hint--large
+ * 	4) hint--fit
+ *
+ */
+.hint--small:after,
+.hint--medium:after,
+.hint--large:after,
+.hint--fit:after {
+  box-sizing: border-box;
+  white-space: normal;
+  line-height: 1.4em;
+  word-wrap: break-word;
+}
+
+.hint--small:after {
+  width: 80px;
+}
+
+.hint--medium:after {
+  width: 150px;
+}
+
+.hint--large:after {
+  width: 300px;
+}
+
+.hint--fit:after {
+  width: 100%;
+}
+
+/**
+ * source: hint-theme.scss
+ *
+ * Defines basic theme for tooltips.
+ *
+ */
+[class*=hint--] {
+  /**
+   * tooltip body
+   */
+}
+[class*=hint--]:after {
+  text-shadow: 0 1px 0px black;
+  box-shadow: 4px 4px 8px rgba(0, 0, 0, 0.3);
+}
+
+/**
+ * source: hint-color-types.scss
+ *
+ * Contains tooltips of various types based on color differences.
+ *
+ * Classes added:
+ * 	1) hint--error
+ * 	2) hint--warning
+ * 	3) hint--info
+ * 	4) hint--success
+ *
+ */
+/**
+ * Error
+ */
+.hint--error:after {
+  background-color: hsl(1, 40%, 50%);
+  text-shadow: 0 1px 0px #592726;
+}
+.hint--error:before {
+  background-color: hsl(1, 40%, 50%);
+}
+
+/**
+ * Warning
+ */
+.hint--warning:after {
+  background-color: hsl(38, 46%, 54%);
+  text-shadow: 0 1px 0px #6c5328;
+}
+.hint--warning:before {
+  background-color: hsl(38, 46%, 54%);
+}
+
+/**
+ * Info
+ */
+.hint--info:after {
+  background-color: hsl(200, 50%, 45%);
+  text-shadow: 0 1px 0px #1a3c4d;
+}
+.hint--info:before {
+  background-color: hsl(200, 50%, 45%);
+}
+
+/**
+ * Success
+ */
+.hint--success:after {
+  background-color: hsl(121, 32%, 40%);
+  text-shadow: 0 1px 0px #1a321a;
+}
+.hint--success:before {
+  background-color: hsl(121, 32%, 40%);
+}
+
+/**
+ * source: hint-always.scss
+ *
+ * Defines a persisted tooltip which shows always.
+ *
+ * Classes added:
+ * 	1) hint--always
+ *
+ */
+.hint--always:after, .hint--always:before {
+  opacity: 1;
+  visibility: visible;
+}
+.hint--always.hint--top:before {
+  transform: translateY(-8px) rotate(var(--rotation));
+}
+.hint--always.hint--top:after {
+  transform: translateX(-50%) translateY(-8px);
+}
+.hint--always.hint--top-left:before {
+  transform: translateY(-8px) rotate(var(--rotation));
+}
+.hint--always.hint--top-left:after {
+  transform: translateX(-100%) translateY(-8px);
+}
+.hint--always.hint--top-right:before {
+  transform: translateY(-8px) rotate(var(--rotation));
+}
+.hint--always.hint--top-right:after {
+  transform: translateY(-8px);
+}
+.hint--always.hint--bottom:before {
+  transform: translateY(8px) rotate(var(--rotation));
+}
+.hint--always.hint--bottom:after {
+  transform: translateX(-50%) translateY(8px);
+}
+.hint--always.hint--bottom-left:before {
+  transform: translateY(8px) rotate(var(--rotation));
+}
+.hint--always.hint--bottom-left:after {
+  transform: translateX(-100%) translateY(8px);
+}
+.hint--always.hint--bottom-right:before {
+  transform: translateY(8px) rotate(var(--rotation));
+}
+.hint--always.hint--bottom-right:after {
+  transform: translateY(8px);
+}
+.hint--always.hint--left:before {
+  transform: translateX(-8px) rotate(var(--rotation));
+}
+.hint--always.hint--left:after {
+  transform: translateX(-8px);
+}
+.hint--always.hint--right:before {
+  transform: translateX(8px) rotate(var(--rotation));
+}
+.hint--always.hint--right:after {
+  transform: translateX(8px);
+}
+
+/**
+ * source: hint-rounded.scss
+ *
+ * Defines rounded corner tooltips.
+ *
+ * Classes added:
+ * 	1) hint--rounded
+ *
+ */
+.hint--rounded:before {
+  border-radius: 0 4px 0 0;
+}
+.hint--rounded:after {
+  border-radius: 4px;
+}
+
+/**
+ * source: hint-effects.scss
+ *
+ * Defines various transition effects for the tooltips.
+ *
+ * Classes added:
+ * 	1) hint--no-animate
+ * 	2) hint--bounce
+ *
+ */
+.hint--no-animate:before, .hint--no-animate:after {
+  transition-duration: 0ms;
+}
+
+.hint--bounce:before, .hint--bounce:after {
+  transition: opacity 0.3s ease, visibility 0.3s ease, transform 0.3s cubic-bezier(0.71, 1.7, 0.77, 1.24);
+}
+
+@supports (transition-timing-function: linear(0, 1)) {
+  .hint--bounce:before, .hint--bounce:after {
+    --spring-easing: linear(
+    	0,
+    	0.009,
+    	0.035 2.1%,
+    	0.141 4.4%,
+    	0.723 12.9%,
+    	0.938,
+    	1.077 20.4%,
+    	1.121,
+    	1.149 24.3%,
+    	1.159,
+    	1.163 27%,
+    	1.154,
+    	1.129 32.8%,
+    	1.051 39.6%,
+    	1.017 43.1%,
+    	0.991,
+    	0.977 51%,
+    	0.975 57.1%,
+    	0.997 69.8%,
+    	1.003 76.9%,
+    	1
+    );
+    transition: opacity 0.3s ease, visibility 0.3s ease, transform 0.5s var(--spring-easing);
+  }
+}
+.hint--no-shadow:before, .hint--no-shadow:after {
+  text-shadow: initial;
+  box-shadow: initial;
+}
+
+.hint--no-arrow:before {
+  display: none;
+}
\ No newline at end of file
diff --git a/test/js/bun/css/files/materialize.css b/test/js/bun/css/files/materialize.css
new file mode 100644
index 0000000000..8bc9c1bc6d
--- /dev/null
+++ b/test/js/bun/css/files/materialize.css
@@ -0,0 +1,8711 @@
+/*!
+* Materialize v2.1.1 (https://materializeweb.com)
+* Copyright 2014-2024 Materialize
+* MIT License (https://raw.githubusercontent.com/materializecss/materialize/master/LICENSE)
+*/
+@charset "UTF-8";
+:root {
+  --md-source: #006495;
+  /* primary */
+  --md-ref-palette-primary0: #000000;
+  --md-ref-palette-primary10: #001e30;
+  --md-ref-palette-primary20: #003450;
+  --md-ref-palette-primary25: #003f60;
+  --md-ref-palette-primary30: #004b71;
+  --md-ref-palette-primary35: #005783;
+  --md-ref-palette-primary40: #006495;
+  --md-ref-palette-primary50: #0f7eb8;
+  --md-ref-palette-primary60: #3d98d4;
+  --md-ref-palette-primary70: #5db3f0;
+  --md-ref-palette-primary80: #8fcdff;
+  --md-ref-palette-primary90: #cbe6ff;
+  --md-ref-palette-primary95: #e6f2ff;
+  --md-ref-palette-primary98: #f7f9ff;
+  --md-ref-palette-primary99: #fcfcff;
+  --md-ref-palette-primary100: #ffffff;
+  /* secondary */
+  --md-ref-palette-secondary0: #000000;
+  --md-ref-palette-secondary10: #0d1d29;
+  --md-ref-palette-secondary20: #22323f;
+  --md-ref-palette-secondary25: #2d3d4b;
+  --md-ref-palette-secondary30: #394856;
+  --md-ref-palette-secondary35: #445462;
+  --md-ref-palette-secondary40: #50606f;
+  --md-ref-palette-secondary50: #697988;
+  --md-ref-palette-secondary60: #8293a2;
+  --md-ref-palette-secondary70: #9dadbd;
+  --md-ref-palette-secondary80: #b8c8d9;
+  --md-ref-palette-secondary90: #d4e4f6;
+  --md-ref-palette-secondary95: #e6f2ff;
+  --md-ref-palette-secondary98: #f7f9ff;
+  --md-ref-palette-secondary99: #fcfcff;
+  --md-ref-palette-secondary100: #ffffff;
+  /* tertiary */
+  --md-ref-palette-tertiary0: #000000;
+  --md-ref-palette-tertiary10: #211634;
+  --md-ref-palette-tertiary20: #362b4a;
+  --md-ref-palette-tertiary25: #423656;
+  --md-ref-palette-tertiary30: #4d4162;
+  --md-ref-palette-tertiary35: #594c6e;
+  --md-ref-palette-tertiary40: #66587b;
+  --md-ref-palette-tertiary50: #7f7195;
+  --md-ref-palette-tertiary60: #998ab0;
+  --md-ref-palette-tertiary70: #b4a4cb;
+  --md-ref-palette-tertiary80: #d0bfe7;
+  --md-ref-palette-tertiary90: #ecdcff;
+  --md-ref-palette-tertiary95: #f7edff;
+  --md-ref-palette-tertiary98: #fef7ff;
+  --md-ref-palette-tertiary99: #fffbff;
+  --md-ref-palette-tertiary100: #ffffff;
+  /* neutral */
+  --md-ref-palette-neutral0: #000000;
+  --md-ref-palette-neutral10: #1a1c1e;
+  --md-ref-palette-neutral20: #2e3133;
+  --md-ref-palette-neutral25: #3a3c3e;
+  --md-ref-palette-neutral30: #454749;
+  --md-ref-palette-neutral35: #515255;
+  --md-ref-palette-neutral40: #5d5e61;
+  --md-ref-palette-neutral50: #76777a;
+  --md-ref-palette-neutral60: #8f9194;
+  --md-ref-palette-neutral70: #aaabae;
+  --md-ref-palette-neutral80: #c6c6c9;
+  --md-ref-palette-neutral90: #e2e2e5;
+  --md-ref-palette-neutral95: #f0f0f3;
+  --md-ref-palette-neutral98: #f9f9fc;
+  --md-ref-palette-neutral99: #fcfcff;
+  --md-ref-palette-neutral100: #ffffff;
+  /* neutral-variant */
+  --md-ref-palette-neutral-variant0: #000000;
+  --md-ref-palette-neutral-variant10: #161c22;
+  --md-ref-palette-neutral-variant20: #2b3137;
+  --md-ref-palette-neutral-variant25: #363c42;
+  --md-ref-palette-neutral-variant30: #41474d;
+  --md-ref-palette-neutral-variant35: #4d5359;
+  --md-ref-palette-neutral-variant40: #595f65;
+  --md-ref-palette-neutral-variant50: #72787e;
+  --md-ref-palette-neutral-variant60: #8b9198;
+  --md-ref-palette-neutral-variant70: #a6acb3;
+  --md-ref-palette-neutral-variant80: #c1c7ce;
+  --md-ref-palette-neutral-variant90: #dee3ea;
+  --md-ref-palette-neutral-variant95: #ecf1f9;
+  --md-ref-palette-neutral-variant98: #f7f9ff;
+  --md-ref-palette-neutral-variant99: #fcfcff;
+  --md-ref-palette-neutral-variant100: #ffffff;
+  /* error */
+  --md-ref-palette-error0: #000000;
+  --md-ref-palette-error10: #410002;
+  --md-ref-palette-error20: #690005;
+  --md-ref-palette-error25: #7e0007;
+  --md-ref-palette-error30: #93000a;
+  --md-ref-palette-error35: #a80710;
+  --md-ref-palette-error40: #ba1a1a;
+  --md-ref-palette-error50: #de3730;
+  --md-ref-palette-error60: #ff5449;
+  --md-ref-palette-error70: #ff897d;
+  --md-ref-palette-error80: #ffb4ab;
+  --md-ref-palette-error90: #ffdad6;
+  --md-ref-palette-error95: #ffedea;
+  --md-ref-palette-error98: #fff8f7;
+  --md-ref-palette-error99: #fffbff;
+  --md-ref-palette-error100: #ffffff;
+  /* light */
+  --md-sys-color-primary-light: #006495;
+  --md-sys-color-on-primary-light: #ffffff;
+  --md-sys-color-primary-container-light: #cbe6ff;
+  --md-sys-color-on-primary-container-light: #001e30;
+  --md-sys-color-secondary-light: #50606f;
+  --md-sys-color-on-secondary-light: #ffffff;
+  --md-sys-color-secondary-container-light: #d4e4f6;
+  --md-sys-color-on-secondary-container-light: #0d1d29;
+  --md-sys-color-tertiary-light: #66587b;
+  --md-sys-color-on-tertiary-light: #ffffff;
+  --md-sys-color-tertiary-container-light: #ecdcff;
+  --md-sys-color-on-tertiary-container-light: #211634;
+  --md-sys-color-error-light: #ba1a1a;
+  --md-sys-color-error-container-light: #ffdad6;
+  --md-sys-color-on-error-light: #ffffff;
+  --md-sys-color-on-error-container-light: #410002;
+  --md-sys-color-background-light: #fcfcff;
+  --md-sys-color-on-background-light: #1a1c1e;
+  --md-sys-color-surface-light: #fcfcff;
+  --md-sys-color-on-surface-light: #1a1c1e;
+  --md-sys-color-surface-variant-light: #dee3ea;
+  --md-sys-color-on-surface-variant-light: #41474d;
+  --md-sys-color-outline-light: #72787e;
+  --md-sys-color-inverse-on-surface-light: #f0f0f3;
+  --md-sys-color-inverse-surface-light: #2e3133;
+  --md-sys-color-inverse-primary-light: #8fcdff;
+  --md-sys-color-shadow-light: #000000;
+  --md-sys-color-surface-tint-light: #006495;
+  --md-sys-color-outline-variant-light: #c1c7ce;
+  --md-sys-color-scrim-light: #000000;
+  /* dark */
+  --md-sys-color-primary-dark: #8fcdff;
+  --md-sys-color-on-primary-dark: #003450;
+  --md-sys-color-primary-container-dark: #004b71;
+  --md-sys-color-on-primary-container-dark: #cbe6ff;
+  --md-sys-color-secondary-dark: #b8c8d9;
+  --md-sys-color-on-secondary-dark: #22323f;
+  --md-sys-color-secondary-container-dark: #394856;
+  --md-sys-color-on-secondary-container-dark: #d4e4f6;
+  --md-sys-color-tertiary-dark: #d0bfe7;
+  --md-sys-color-on-tertiary-dark: #362b4a;
+  --md-sys-color-tertiary-container-dark: #4d4162;
+  --md-sys-color-on-tertiary-container-dark: #ecdcff;
+  --md-sys-color-error-dark: #ffb4ab;
+  --md-sys-color-error-container-dark: #93000a;
+  --md-sys-color-on-error-dark: #690005;
+  --md-sys-color-on-error-container-dark: #ffdad6;
+  --md-sys-color-background-dark: #1a1c1e;
+  --md-sys-color-on-background-dark: #e2e2e5;
+  --md-sys-color-surface-dark: #1a1c1e;
+  --md-sys-color-on-surface-dark: #e2e2e5;
+  --md-sys-color-surface-variant-dark: #41474d;
+  --md-sys-color-on-surface-variant-dark: #c1c7ce;
+  --md-sys-color-outline-dark: #8b9198;
+  --md-sys-color-inverse-on-surface-dark: #1a1c1e;
+  --md-sys-color-inverse-surface-dark: #e2e2e5;
+  --md-sys-color-inverse-primary-dark: #006495;
+  --md-sys-color-shadow-dark: #000000;
+  --md-sys-color-surface-tint-dark: #8fcdff;
+  --md-sys-color-outline-variant-dark: #41474d;
+  --md-sys-color-scrim-dark: #000000;
+  /* display - large */
+  --md-sys-typescale-display-large-font-family-name: Roboto;
+  --md-sys-typescale-display-large-font-family-style: Regular;
+  --md-sys-typescale-display-large-font-weight: 400px;
+  --md-sys-typescale-display-large-font-size: 57px;
+  --md-sys-typescale-display-large-line-height: 64px;
+  --md-sys-typescale-display-large-letter-spacing: -0.25px;
+  /* display - medium */
+  --md-sys-typescale-display-medium-font-family-name: Roboto;
+  --md-sys-typescale-display-medium-font-family-style: Regular;
+  --md-sys-typescale-display-medium-font-weight: 400px;
+  --md-sys-typescale-display-medium-font-size: 45px;
+  --md-sys-typescale-display-medium-line-height: 52px;
+  --md-sys-typescale-display-medium-letter-spacing: 0px;
+  /* display - small */
+  --md-sys-typescale-display-small-font-family-name: Roboto;
+  --md-sys-typescale-display-small-font-family-style: Regular;
+  --md-sys-typescale-display-small-font-weight: 400px;
+  --md-sys-typescale-display-small-font-size: 36px;
+  --md-sys-typescale-display-small-line-height: 44px;
+  --md-sys-typescale-display-small-letter-spacing: 0px;
+  /* headline - large */
+  --md-sys-typescale-headline-large-font-family-name: Roboto;
+  --md-sys-typescale-headline-large-font-family-style: Regular;
+  --md-sys-typescale-headline-large-font-weight: 400px;
+  --md-sys-typescale-headline-large-font-size: 32px;
+  --md-sys-typescale-headline-large-line-height: 40px;
+  --md-sys-typescale-headline-large-letter-spacing: 0px;
+  /* headline - medium */
+  --md-sys-typescale-headline-medium-font-family-name: Roboto;
+  --md-sys-typescale-headline-medium-font-family-style: Regular;
+  --md-sys-typescale-headline-medium-font-weight: 400px;
+  --md-sys-typescale-headline-medium-font-size: 28px;
+  --md-sys-typescale-headline-medium-line-height: 36px;
+  --md-sys-typescale-headline-medium-letter-spacing: 0px;
+  /* headline - small */
+  --md-sys-typescale-headline-small-font-family-name: Roboto;
+  --md-sys-typescale-headline-small-font-family-style: Regular;
+  --md-sys-typescale-headline-small-font-weight: 400px;
+  --md-sys-typescale-headline-small-font-size: 24px;
+  --md-sys-typescale-headline-small-line-height: 32px;
+  --md-sys-typescale-headline-small-letter-spacing: 0px;
+  /* body - large */
+  --md-sys-typescale-body-large-font-family-name: Roboto;
+  --md-sys-typescale-body-large-font-family-style: Regular;
+  --md-sys-typescale-body-large-font-weight: 400px;
+  --md-sys-typescale-body-large-font-size: 16px;
+  --md-sys-typescale-body-large-line-height: 24px;
+  --md-sys-typescale-body-large-letter-spacing: 0.50px;
+  /* body - medium */
+  --md-sys-typescale-body-medium-font-family-name: Roboto;
+  --md-sys-typescale-body-medium-font-family-style: Regular;
+  --md-sys-typescale-body-medium-font-weight: 400px;
+  --md-sys-typescale-body-medium-font-size: 14px;
+  --md-sys-typescale-body-medium-line-height: 20px;
+  --md-sys-typescale-body-medium-letter-spacing: 0.25px;
+  /* body - small */
+  --md-sys-typescale-body-small-font-family-name: Roboto;
+  --md-sys-typescale-body-small-font-family-style: Regular;
+  --md-sys-typescale-body-small-font-weight: 400px;
+  --md-sys-typescale-body-small-font-size: 12px;
+  --md-sys-typescale-body-small-line-height: 16px;
+  --md-sys-typescale-body-small-letter-spacing: 0.40px;
+  /* label - large */
+  --md-sys-typescale-label-large-font-family-name: Roboto;
+  --md-sys-typescale-label-large-font-family-style: Medium;
+  --md-sys-typescale-label-large-font-weight: 500px;
+  --md-sys-typescale-label-large-font-size: 14px;
+  --md-sys-typescale-label-large-line-height: 20px;
+  --md-sys-typescale-label-large-letter-spacing: 0.10px;
+  /* label - medium */
+  --md-sys-typescale-label-medium-font-family-name: Roboto;
+  --md-sys-typescale-label-medium-font-family-style: Medium;
+  --md-sys-typescale-label-medium-font-weight: 500px;
+  --md-sys-typescale-label-medium-font-size: 12px;
+  --md-sys-typescale-label-medium-line-height: 16px;
+  --md-sys-typescale-label-medium-letter-spacing: 0.50px;
+  /* label - small */
+  --md-sys-typescale-label-small-font-family-name: Roboto;
+  --md-sys-typescale-label-small-font-family-style: Medium;
+  --md-sys-typescale-label-small-font-weight: 500px;
+  --md-sys-typescale-label-small-font-size: 11px;
+  --md-sys-typescale-label-small-line-height: 16px;
+  --md-sys-typescale-label-small-letter-spacing: 0.50px;
+  /* title - large */
+  --md-sys-typescale-title-large-font-family-name: Roboto;
+  --md-sys-typescale-title-large-font-family-style: Regular;
+  --md-sys-typescale-title-large-font-weight: 400px;
+  --md-sys-typescale-title-large-font-size: 22px;
+  --md-sys-typescale-title-large-line-height: 28px;
+  --md-sys-typescale-title-large-letter-spacing: 0px;
+  /* title - medium */
+  --md-sys-typescale-title-medium-font-family-name: Roboto;
+  --md-sys-typescale-title-medium-font-family-style: Medium;
+  --md-sys-typescale-title-medium-font-weight: 500px;
+  --md-sys-typescale-title-medium-font-size: 16px;
+  --md-sys-typescale-title-medium-line-height: 24px;
+  --md-sys-typescale-title-medium-letter-spacing: 0.15px;
+  /* title - small */
+  --md-sys-typescale-title-small-font-family-name: Roboto;
+  --md-sys-typescale-title-small-font-family-style: Medium;
+  --md-sys-typescale-title-small-font-weight: 500px;
+  --md-sys-typescale-title-small-font-size: 14px;
+  --md-sys-typescale-title-small-line-height: 20px;
+  --md-sys-typescale-title-small-letter-spacing: 0.10px;
+}
+
+/* System Defaults */
+:root, :host {
+  color-scheme: light;
+  --md-sys-color-primary: var(--md-sys-color-primary-light);
+  --md-sys-color-on-primary: var(--md-sys-color-on-primary-light);
+  --md-sys-color-primary-container: var(--md-sys-color-primary-container-light);
+  --md-sys-color-on-primary-container: var(--md-sys-color-on-primary-container-light);
+  --md-sys-color-secondary: var(--md-sys-color-secondary-light);
+  --md-sys-color-on-secondary: var(--md-sys-color-on-secondary-light);
+  --md-sys-color-secondary-container: var(--md-sys-color-secondary-container-light);
+  --md-sys-color-on-secondary-container: var(--md-sys-color-on-secondary-container-light);
+  --md-sys-color-tertiary: var(--md-sys-color-tertiary-light);
+  --md-sys-color-on-tertiary: var(--md-sys-color-on-tertiary-light);
+  --md-sys-color-tertiary-container: var(--md-sys-color-tertiary-container-light);
+  --md-sys-color-on-tertiary-container: var(--md-sys-color-on-tertiary-container-light);
+  --md-sys-color-error: var(--md-sys-color-error-light);
+  --md-sys-color-on-error: var(--md-sys-color-on-error-light);
+  --md-sys-color-error-container: var(--md-sys-color-error-container-light);
+  --md-sys-color-on-error-container: var(--md-sys-color-on-error-container-light);
+  --md-sys-color-outline: var(--md-sys-color-outline-light);
+  --md-sys-color-background: var(--md-sys-color-background-light);
+  --md-sys-color-on-background: var(--md-sys-color-on-background-light);
+  --md-sys-color-surface: var(--md-sys-color-surface-light);
+  --md-sys-color-on-surface: var(--md-sys-color-on-surface-light);
+  --md-sys-color-surface-variant: var(--md-sys-color-surface-variant-light);
+  --md-sys-color-on-surface-variant: var(--md-sys-color-on-surface-variant-light);
+  --md-sys-color-inverse-surface: var(--md-sys-color-inverse-surface-light);
+  --md-sys-color-inverse-on-surface: var(--md-sys-color-inverse-on-surface-light);
+  --md-sys-color-inverse-primary: var(--md-sys-color-inverse-primary-light);
+  --md-sys-color-shadow: var(--md-sys-color-shadow-light);
+  --md-sys-color-surface-tint: var(--md-sys-color-surface-tint-light);
+  --md-sys-color-outline-variant: var(--md-sys-color-outline-variant-light);
+  --md-sys-color-scrim: var(--md-sys-color-scrim-light);
+}
+
+@media (prefers-color-scheme: dark) {
+  :root, :host {
+    color-scheme: dark;
+    --md-sys-color-primary: var(--md-sys-color-primary-dark);
+    --md-sys-color-on-primary: var(--md-sys-color-on-primary-dark);
+    --md-sys-color-primary-container: var(--md-sys-color-primary-container-dark);
+    --md-sys-color-on-primary-container: var(--md-sys-color-on-primary-container-dark);
+    --md-sys-color-secondary: var(--md-sys-color-secondary-dark);
+    --md-sys-color-on-secondary: var(--md-sys-color-on-secondary-dark);
+    --md-sys-color-secondary-container: var(--md-sys-color-secondary-container-dark);
+    --md-sys-color-on-secondary-container: var(--md-sys-color-on-secondary-container-dark);
+    --md-sys-color-tertiary: var(--md-sys-color-tertiary-dark);
+    --md-sys-color-on-tertiary: var(--md-sys-color-on-tertiary-dark);
+    --md-sys-color-tertiary-container: var(--md-sys-color-tertiary-container-dark);
+    --md-sys-color-on-tertiary-container: var(--md-sys-color-on-tertiary-container-dark);
+    --md-sys-color-error: var(--md-sys-color-error-dark);
+    --md-sys-color-on-error: var(--md-sys-color-on-error-dark);
+    --md-sys-color-error-container: var(--md-sys-color-error-container-dark);
+    --md-sys-color-on-error-container: var(--md-sys-color-on-error-container-dark);
+    --md-sys-color-outline: var(--md-sys-color-outline-dark);
+    --md-sys-color-background: var(--md-sys-color-background-dark);
+    --md-sys-color-on-background: var(--md-sys-color-on-background-dark);
+    --md-sys-color-surface: var(--md-sys-color-surface-dark);
+    --md-sys-color-on-surface: var(--md-sys-color-on-surface-dark);
+    --md-sys-color-surface-variant: var(--md-sys-color-surface-variant-dark);
+    --md-sys-color-on-surface-variant: var(--md-sys-color-on-surface-variant-dark);
+    --md-sys-color-inverse-surface: var(--md-sys-color-inverse-surface-dark);
+    --md-sys-color-inverse-on-surface: var(--md-sys-color-inverse-on-surface-dark);
+    --md-sys-color-inverse-primary: var(--md-sys-color-inverse-primary-dark);
+    --md-sys-color-shadow: var(--md-sys-color-shadow-dark);
+    --md-sys-color-surface-tint: var(--md-sys-color-surface-tint-dark);
+    --md-sys-color-outline-variant: var(--md-sys-color-outline-variant-dark);
+    --md-sys-color-scrim: var(--md-sys-color-scrim-dark);
+  }
+}
+/* ===================================================================== Themes */
+:root[theme=light] {
+  color-scheme: light;
+  --md-sys-color-primary: var(--md-sys-color-primary-light);
+  --md-sys-color-on-primary: var(--md-sys-color-on-primary-light);
+  --md-sys-color-primary-container: var(--md-sys-color-primary-container-light);
+  --md-sys-color-on-primary-container: var(--md-sys-color-on-primary-container-light);
+  --md-sys-color-secondary: var(--md-sys-color-secondary-light);
+  --md-sys-color-on-secondary: var(--md-sys-color-on-secondary-light);
+  --md-sys-color-secondary-container: var(--md-sys-color-secondary-container-light);
+  --md-sys-color-on-secondary-container: var(--md-sys-color-on-secondary-container-light);
+  --md-sys-color-tertiary: var(--md-sys-color-tertiary-light);
+  --md-sys-color-on-tertiary: var(--md-sys-color-on-tertiary-light);
+  --md-sys-color-tertiary-container: var(--md-sys-color-tertiary-container-light);
+  --md-sys-color-on-tertiary-container: var(--md-sys-color-on-tertiary-container-light);
+  --md-sys-color-error: var(--md-sys-color-error-light);
+  --md-sys-color-on-error: var(--md-sys-color-on-error-light);
+  --md-sys-color-error-container: var(--md-sys-color-error-container-light);
+  --md-sys-color-on-error-container: var(--md-sys-color-on-error-container-light);
+  --md-sys-color-outline: var(--md-sys-color-outline-light);
+  --md-sys-color-background: var(--md-sys-color-background-light);
+  --md-sys-color-on-background: var(--md-sys-color-on-background-light);
+  --md-sys-color-surface: var(--md-sys-color-surface-light);
+  --md-sys-color-on-surface: var(--md-sys-color-on-surface-light);
+  --md-sys-color-surface-variant: var(--md-sys-color-surface-variant-light);
+  --md-sys-color-on-surface-variant: var(--md-sys-color-on-surface-variant-light);
+  --md-sys-color-inverse-surface: var(--md-sys-color-inverse-surface-light);
+  --md-sys-color-inverse-on-surface: var(--md-sys-color-inverse-on-surface-light);
+  --md-sys-color-inverse-primary: var(--md-sys-color-inverse-primary-light);
+  --md-sys-color-shadow: var(--md-sys-color-shadow-light);
+  --md-sys-color-surface-tint: var(--md-sys-color-surface-tint-light);
+  --md-sys-color-outline-variant: var(--md-sys-color-outline-variant-light);
+  --md-sys-color-scrim: var(--md-sys-color-scrim-light);
+}
+
+:root[theme=dark] {
+  color-scheme: dark;
+  --md-sys-color-primary: var(--md-sys-color-primary-dark);
+  --md-sys-color-on-primary: var(--md-sys-color-on-primary-dark);
+  --md-sys-color-primary-container: var(--md-sys-color-primary-container-dark);
+  --md-sys-color-on-primary-container: var(--md-sys-color-on-primary-container-dark);
+  --md-sys-color-secondary: var(--md-sys-color-secondary-dark);
+  --md-sys-color-on-secondary: var(--md-sys-color-on-secondary-dark);
+  --md-sys-color-secondary-container: var(--md-sys-color-secondary-container-dark);
+  --md-sys-color-on-secondary-container: var(--md-sys-color-on-secondary-container-dark);
+  --md-sys-color-tertiary: var(--md-sys-color-tertiary-dark);
+  --md-sys-color-on-tertiary: var(--md-sys-color-on-tertiary-dark);
+  --md-sys-color-tertiary-container: var(--md-sys-color-tertiary-container-dark);
+  --md-sys-color-on-tertiary-container: var(--md-sys-color-on-tertiary-container-dark);
+  --md-sys-color-error: var(--md-sys-color-error-dark);
+  --md-sys-color-on-error: var(--md-sys-color-on-error-dark);
+  --md-sys-color-error-container: var(--md-sys-color-error-container-dark);
+  --md-sys-color-on-error-container: var(--md-sys-color-on-error-container-dark);
+  --md-sys-color-outline: var(--md-sys-color-outline-dark);
+  --md-sys-color-background: var(--md-sys-color-background-dark);
+  --md-sys-color-on-background: var(--md-sys-color-on-background-dark);
+  --md-sys-color-surface: var(--md-sys-color-surface-dark);
+  --md-sys-color-on-surface: var(--md-sys-color-on-surface-dark);
+  --md-sys-color-surface-variant: var(--md-sys-color-surface-variant-dark);
+  --md-sys-color-on-surface-variant: var(--md-sys-color-on-surface-variant-dark);
+  --md-sys-color-inverse-surface: var(--md-sys-color-inverse-surface-dark);
+  --md-sys-color-inverse-on-surface: var(--md-sys-color-inverse-on-surface-dark);
+  --md-sys-color-inverse-primary: var(--md-sys-color-inverse-primary-dark);
+  --md-sys-color-shadow: var(--md-sys-color-shadow-dark);
+  --md-sys-color-surface-tint: var(--md-sys-color-surface-tint-dark);
+  --md-sys-color-outline-variant: var(--md-sys-color-outline-variant-dark);
+  --md-sys-color-scrim: var(--md-sys-color-scrim-dark);
+}
+
+.primary {
+  background-color: var(--md-sys-color-primary);
+}
+
+.primary-text {
+  color: var(--md-sys-color-primary);
+}
+
+.on-primary {
+  background-color: var(--md-sys-color-on-primary);
+}
+
+.on-primary-text {
+  color: var(--md-sys-color-on-primary);
+}
+
+.primary-container {
+  background-color: var(--md-sys-color-primary-container);
+}
+
+.primary-container-text {
+  color: var(--md-sys-color-primary-container);
+}
+
+.on-primary-container {
+  background-color: var(--md-sys-color-on-primary-container);
+}
+
+.on-primary-container-text {
+  color: var(--md-sys-color-on-primary-container);
+}
+
+.secondary {
+  background-color: var(--md-sys-color-secondary);
+}
+
+.secondary-text {
+  color: var(--md-sys-color-secondary);
+}
+
+.on-secondary {
+  background-color: var(--md-sys-color-on-secondary);
+}
+
+.on-secondary-text {
+  color: var(--md-sys-color-on-secondary);
+}
+
+.secondary-container {
+  background-color: var(--md-sys-color-secondary-container);
+}
+
+.secondary-container-text {
+  color: var(--md-sys-color-secondary-container);
+}
+
+.on-secondary-container {
+  background-color: var(--md-sys-color-on-secondary-container);
+}
+
+.on-secondary-container-text {
+  color: var(--md-sys-color-on-secondary-container);
+}
+
+.tertiary {
+  background-color: var(--md-sys-color-tertiary);
+}
+
+.tertiary-text {
+  color: var(--md-sys-color-tertiary);
+}
+
+.on-tertiary {
+  background-color: var(--md-sys-color-on-tertiary);
+}
+
+.on-tertiary-text {
+  color: var(--md-sys-color-on-tertiary);
+}
+
+.tertiary-container {
+  background-color: var(--md-sys-color-tertiary-container);
+}
+
+.tertiary-container-text {
+  color: var(--md-sys-color-tertiary-container);
+}
+
+.on-tertiary-container {
+  background-color: var(--md-sys-color-on-tertiary-container);
+}
+
+.on-tertiary-container-text {
+  color: var(--md-sys-color-on-tertiary-container);
+}
+
+.error {
+  background-color: var(--md-sys-color-error);
+}
+
+.error-text {
+  color: var(--md-sys-color-error);
+}
+
+.on-error {
+  background-color: var(--md-sys-color-on-error);
+}
+
+.on-error-text {
+  color: var(--md-sys-color-on-error);
+}
+
+.error-container {
+  background-color: var(--md-sys-color-error-container);
+}
+
+.error-container-text {
+  color: var(--md-sys-color-error-container);
+}
+
+.on-error-container {
+  background-color: var(--md-sys-color-on-error-container);
+}
+
+.on-error-container-text {
+  color: var(--md-sys-color-on-error-container);
+}
+
+.background {
+  background-color: var(--md-sys-color-background);
+}
+
+.background-text {
+  color: var(--md-sys-color-background);
+}
+
+.on-background {
+  background-color: var(--md-sys-color-on-background);
+}
+
+.on-background-text {
+  color: var(--md-sys-color-on-background);
+}
+
+.surface, .switch label input[type=checkbox]:checked + .lever:after {
+  background-color: var(--md-sys-color-surface);
+}
+
+.surface-text {
+  color: var(--md-sys-color-surface);
+}
+
+.on-surface {
+  background-color: var(--md-sys-color-on-surface);
+}
+
+.on-surface-text {
+  color: var(--md-sys-color-on-surface);
+}
+
+.surface-variant, .progress, input[type=range]::-moz-range-track, input[type=range]::-webkit-slider-runnable-track {
+  background-color: var(--md-sys-color-surface-variant);
+}
+
+.surface-variant-text {
+  color: var(--md-sys-color-surface-variant);
+}
+
+.on-surface-variant {
+  background-color: var(--md-sys-color-on-surface-variant);
+}
+
+.on-surface-variant-text, .chip > .material-icons {
+  color: var(--md-sys-color-on-surface-variant);
+}
+
+.outline, .switch label .lever:after {
+  background-color: var(--md-sys-color-outline);
+}
+
+.outline-text {
+  color: var(--md-sys-color-outline);
+}
+
+.inverse-on-surface {
+  background-color: var(--md-sys-color-inverse-on-surface);
+}
+
+.inverse-on-surface-text {
+  color: var(--md-sys-color-inverse-on-surface);
+}
+
+.inverse-surface {
+  background-color: var(--md-sys-color-inverse-surface);
+}
+
+.inverse-surface-text {
+  color: var(--md-sys-color-inverse-surface);
+}
+
+.inverse-primary {
+  background-color: var(--md-sys-color-inverse-primary);
+}
+
+.inverse-primary-text {
+  color: var(--md-sys-color-inverse-primary);
+}
+
+.shadow {
+  background-color: var(--md-sys-color-shadow);
+}
+
+.shadow-text {
+  color: var(--md-sys-color-shadow);
+}
+
+.surface-tint {
+  background-color: var(--md-sys-color-surface-tint);
+}
+
+.surface-tint-text {
+  color: var(--md-sys-color-surface-tint);
+}
+
+.outline-variant {
+  background-color: var(--md-sys-color-outline-variant);
+}
+
+.outline-variant-text {
+  color: var(--md-sys-color-outline-variant);
+}
+
+.scrim {
+  background-color: var(--md-sys-color-scrim);
+}
+
+.scrim-text {
+  color: var(--md-sys-color-scrim);
+}
+
+.display-large {
+  font-family: var(--md-sys-typescale-display-large-font-family-name);
+  font-style: var(--md-sys-typescale-display-large-font-family-style);
+  font-weight: var(--md-sys-typescale-display-large-font-weight);
+  font-size: var(--md-sys-typescale-display-large-font-size);
+  letter-spacing: var(--md-sys-typescale-display-large-tracking);
+  line-height: var(--md-sys-typescale-display-large-height);
+  text-transform: var(--md-sys-typescale-display-large-text-transform);
+  text-decoration: var(--md-sys-typescale-display-large-text-decoration);
+}
+
+.display-medium {
+  font-family: var(--md-sys-typescale-display-medium-font-family-name);
+  font-style: var(--md-sys-typescale-display-medium-font-family-style);
+  font-weight: var(--md-sys-typescale-display-medium-font-weight);
+  font-size: var(--md-sys-typescale-display-medium-font-size);
+  letter-spacing: var(--md-sys-typescale-display-medium-tracking);
+  line-height: var(--md-sys-typescale-display-medium-height);
+  text-transform: var(--md-sys-typescale-display-medium-text-transform);
+  text-decoration: var(--md-sys-typescale-display-medium-text-decoration);
+}
+
+.display-small {
+  font-family: var(--md-sys-typescale-display-small-font-family-name);
+  font-style: var(--md-sys-typescale-display-small-font-family-style);
+  font-weight: var(--md-sys-typescale-display-small-font-weight);
+  font-size: var(--md-sys-typescale-display-small-font-size);
+  letter-spacing: var(--md-sys-typescale-display-small-tracking);
+  line-height: var(--md-sys-typescale-display-small-height);
+  text-transform: var(--md-sys-typescale-display-small-text-transform);
+  text-decoration: var(--md-sys-typescale-display-small-text-decoration);
+}
+
+.headline-large {
+  font-family: var(--md-sys-typescale-headline-large-font-family-name);
+  font-style: var(--md-sys-typescale-headline-large-font-family-style);
+  font-weight: var(--md-sys-typescale-headline-large-font-weight);
+  font-size: var(--md-sys-typescale-headline-large-font-size);
+  letter-spacing: var(--md-sys-typescale-headline-large-tracking);
+  line-height: var(--md-sys-typescale-headline-large-height);
+  text-transform: var(--md-sys-typescale-headline-large-text-transform);
+  text-decoration: var(--md-sys-typescale-headline-large-text-decoration);
+}
+
+.headline-medium {
+  font-family: var(--md-sys-typescale-headline-medium-font-family-name);
+  font-style: var(--md-sys-typescale-headline-medium-font-family-style);
+  font-weight: var(--md-sys-typescale-headline-medium-font-weight);
+  font-size: var(--md-sys-typescale-headline-medium-font-size);
+  letter-spacing: var(--md-sys-typescale-headline-medium-tracking);
+  line-height: var(--md-sys-typescale-headline-medium-height);
+  text-transform: var(--md-sys-typescale-headline-medium-text-transform);
+  text-decoration: var(--md-sys-typescale-headline-medium-text-decoration);
+}
+
+.headline-small {
+  font-family: var(--md-sys-typescale-headline-small-font-family-name);
+  font-style: var(--md-sys-typescale-headline-small-font-family-style);
+  font-weight: var(--md-sys-typescale-headline-small-font-weight);
+  font-size: var(--md-sys-typescale-headline-small-font-size);
+  letter-spacing: var(--md-sys-typescale-headline-small-tracking);
+  line-height: var(--md-sys-typescale-headline-small-height);
+  text-transform: var(--md-sys-typescale-headline-small-text-transform);
+  text-decoration: var(--md-sys-typescale-headline-small-text-decoration);
+}
+
+.body-large {
+  font-family: var(--md-sys-typescale-body-large-font-family-name);
+  font-style: var(--md-sys-typescale-body-large-font-family-style);
+  font-weight: var(--md-sys-typescale-body-large-font-weight);
+  font-size: var(--md-sys-typescale-body-large-font-size);
+  letter-spacing: var(--md-sys-typescale-body-large-tracking);
+  line-height: var(--md-sys-typescale-body-large-height);
+  text-transform: var(--md-sys-typescale-body-large-text-transform);
+  text-decoration: var(--md-sys-typescale-body-large-text-decoration);
+}
+
+.body-medium {
+  font-family: var(--md-sys-typescale-body-medium-font-family-name);
+  font-style: var(--md-sys-typescale-body-medium-font-family-style);
+  font-weight: var(--md-sys-typescale-body-medium-font-weight);
+  font-size: var(--md-sys-typescale-body-medium-font-size);
+  letter-spacing: var(--md-sys-typescale-body-medium-tracking);
+  line-height: var(--md-sys-typescale-body-medium-height);
+  text-transform: var(--md-sys-typescale-body-medium-text-transform);
+  text-decoration: var(--md-sys-typescale-body-medium-text-decoration);
+}
+
+.body-small {
+  font-family: var(--md-sys-typescale-body-small-font-family-name);
+  font-style: var(--md-sys-typescale-body-small-font-family-style);
+  font-weight: var(--md-sys-typescale-body-small-font-weight);
+  font-size: var(--md-sys-typescale-body-small-font-size);
+  letter-spacing: var(--md-sys-typescale-body-small-tracking);
+  line-height: var(--md-sys-typescale-body-small-height);
+  text-transform: var(--md-sys-typescale-body-small-text-transform);
+  text-decoration: var(--md-sys-typescale-body-small-text-decoration);
+}
+
+.label-large {
+  font-family: var(--md-sys-typescale-label-large-font-family-name);
+  font-style: var(--md-sys-typescale-label-large-font-family-style);
+  font-weight: var(--md-sys-typescale-label-large-font-weight);
+  font-size: var(--md-sys-typescale-label-large-font-size);
+  letter-spacing: var(--md-sys-typescale-label-large-tracking);
+  line-height: var(--md-sys-typescale-label-large-height);
+  text-transform: var(--md-sys-typescale-label-large-text-transform);
+  text-decoration: var(--md-sys-typescale-label-large-text-decoration);
+}
+
+.label-medium {
+  font-family: var(--md-sys-typescale-label-medium-font-family-name);
+  font-style: var(--md-sys-typescale-label-medium-font-family-style);
+  font-weight: var(--md-sys-typescale-label-medium-font-weight);
+  font-size: var(--md-sys-typescale-label-medium-font-size);
+  letter-spacing: var(--md-sys-typescale-label-medium-tracking);
+  line-height: var(--md-sys-typescale-label-medium-height);
+  text-transform: var(--md-sys-typescale-label-medium-text-transform);
+  text-decoration: var(--md-sys-typescale-label-medium-text-decoration);
+}
+
+.label-small {
+  font-family: var(--md-sys-typescale-label-small-font-family-name);
+  font-style: var(--md-sys-typescale-label-small-font-family-style);
+  font-weight: var(--md-sys-typescale-label-small-font-weight);
+  font-size: var(--md-sys-typescale-label-small-font-size);
+  letter-spacing: var(--md-sys-typescale-label-small-tracking);
+  line-height: var(--md-sys-typescale-label-small-height);
+  text-transform: var(--md-sys-typescale-label-small-text-transform);
+  text-decoration: var(--md-sys-typescale-label-small-text-decoration);
+}
+
+.title-large {
+  font-family: var(--md-sys-typescale-title-large-font-family-name);
+  font-style: var(--md-sys-typescale-title-large-font-family-style);
+  font-weight: var(--md-sys-typescale-title-large-font-weight);
+  font-size: var(--md-sys-typescale-title-large-font-size);
+  letter-spacing: var(--md-sys-typescale-title-large-tracking);
+  line-height: var(--md-sys-typescale-title-large-height);
+  text-transform: var(--md-sys-typescale-title-large-text-transform);
+  text-decoration: var(--md-sys-typescale-title-large-text-decoration);
+}
+
+.title-medium {
+  font-family: var(--md-sys-typescale-title-medium-font-family-name);
+  font-style: var(--md-sys-typescale-title-medium-font-family-style);
+  font-weight: var(--md-sys-typescale-title-medium-font-weight);
+  font-size: var(--md-sys-typescale-title-medium-font-size);
+  letter-spacing: var(--md-sys-typescale-title-medium-tracking);
+  line-height: var(--md-sys-typescale-title-medium-height);
+  text-transform: var(--md-sys-typescale-title-medium-text-transform);
+  text-decoration: var(--md-sys-typescale-title-medium-text-decoration);
+}
+
+.title-small {
+  font-family: var(--md-sys-typescale-title-small-font-family-name);
+  font-style: var(--md-sys-typescale-title-small-font-family-style);
+  font-weight: var(--md-sys-typescale-title-small-font-weight);
+  font-size: var(--md-sys-typescale-title-small-font-size);
+  letter-spacing: var(--md-sys-typescale-title-small-tracking);
+  line-height: var(--md-sys-typescale-title-small-height);
+  text-transform: var(--md-sys-typescale-title-small-text-transform);
+  text-decoration: var(--md-sys-typescale-title-small-text-decoration);
+}
+
+.materialize-red {
+  background-color: #e51c23 !important;
+}
+
+.materialize-red-text {
+  color: #e51c23 !important;
+}
+
+.materialize-red.lighten-5 {
+  background-color: #fdeaeb !important;
+}
+
+.materialize-red-text.text-lighten-5 {
+  color: #fdeaeb !important;
+}
+
+.materialize-red.lighten-4 {
+  background-color: #f8c1c3 !important;
+}
+
+.materialize-red-text.text-lighten-4 {
+  color: #f8c1c3 !important;
+}
+
+.materialize-red.lighten-3 {
+  background-color: #f3989b !important;
+}
+
+.materialize-red-text.text-lighten-3 {
+  color: #f3989b !important;
+}
+
+.materialize-red.lighten-2 {
+  background-color: #ee6e73 !important;
+}
+
+.materialize-red-text.text-lighten-2 {
+  color: #ee6e73 !important;
+}
+
+.materialize-red.lighten-1 {
+  background-color: #ea454b !important;
+}
+
+.materialize-red-text.text-lighten-1 {
+  color: #ea454b !important;
+}
+
+.materialize-red.darken-1 {
+  background-color: #d0181e !important;
+}
+
+.materialize-red-text.text-darken-1 {
+  color: #d0181e !important;
+}
+
+.materialize-red.darken-2 {
+  background-color: #b9151b !important;
+}
+
+.materialize-red-text.text-darken-2 {
+  color: #b9151b !important;
+}
+
+.materialize-red.darken-3 {
+  background-color: #a21318 !important;
+}
+
+.materialize-red-text.text-darken-3 {
+  color: #a21318 !important;
+}
+
+.materialize-red.darken-4 {
+  background-color: #8b1014 !important;
+}
+
+.materialize-red-text.text-darken-4 {
+  color: #8b1014 !important;
+}
+
+.red {
+  background-color: #F44336 !important;
+}
+
+.red-text {
+  color: #F44336 !important;
+}
+
+.red.lighten-5 {
+  background-color: #FFEBEE !important;
+}
+
+.red-text.text-lighten-5 {
+  color: #FFEBEE !important;
+}
+
+.red.lighten-4 {
+  background-color: #FFCDD2 !important;
+}
+
+.red-text.text-lighten-4 {
+  color: #FFCDD2 !important;
+}
+
+.red.lighten-3 {
+  background-color: #EF9A9A !important;
+}
+
+.red-text.text-lighten-3 {
+  color: #EF9A9A !important;
+}
+
+.red.lighten-2 {
+  background-color: #E57373 !important;
+}
+
+.red-text.text-lighten-2 {
+  color: #E57373 !important;
+}
+
+.red.lighten-1 {
+  background-color: #EF5350 !important;
+}
+
+.red-text.text-lighten-1 {
+  color: #EF5350 !important;
+}
+
+.red.darken-1 {
+  background-color: #E53935 !important;
+}
+
+.red-text.text-darken-1 {
+  color: #E53935 !important;
+}
+
+.red.darken-2 {
+  background-color: #D32F2F !important;
+}
+
+.red-text.text-darken-2 {
+  color: #D32F2F !important;
+}
+
+.red.darken-3 {
+  background-color: #C62828 !important;
+}
+
+.red-text.text-darken-3 {
+  color: #C62828 !important;
+}
+
+.red.darken-4 {
+  background-color: #B71C1C !important;
+}
+
+.red-text.text-darken-4 {
+  color: #B71C1C !important;
+}
+
+.red.accent-1 {
+  background-color: #FF8A80 !important;
+}
+
+.red-text.text-accent-1 {
+  color: #FF8A80 !important;
+}
+
+.red.accent-2 {
+  background-color: #FF5252 !important;
+}
+
+.red-text.text-accent-2 {
+  color: #FF5252 !important;
+}
+
+.red.accent-3 {
+  background-color: #FF1744 !important;
+}
+
+.red-text.text-accent-3 {
+  color: #FF1744 !important;
+}
+
+.red.accent-4 {
+  background-color: #D50000 !important;
+}
+
+.red-text.text-accent-4 {
+  color: #D50000 !important;
+}
+
+.pink {
+  background-color: #e91e63 !important;
+}
+
+.pink-text {
+  color: #e91e63 !important;
+}
+
+.pink.lighten-5 {
+  background-color: #fce4ec !important;
+}
+
+.pink-text.text-lighten-5 {
+  color: #fce4ec !important;
+}
+
+.pink.lighten-4 {
+  background-color: #f8bbd0 !important;
+}
+
+.pink-text.text-lighten-4 {
+  color: #f8bbd0 !important;
+}
+
+.pink.lighten-3 {
+  background-color: #f48fb1 !important;
+}
+
+.pink-text.text-lighten-3 {
+  color: #f48fb1 !important;
+}
+
+.pink.lighten-2 {
+  background-color: #f06292 !important;
+}
+
+.pink-text.text-lighten-2 {
+  color: #f06292 !important;
+}
+
+.pink.lighten-1 {
+  background-color: #ec407a !important;
+}
+
+.pink-text.text-lighten-1 {
+  color: #ec407a !important;
+}
+
+.pink.darken-1 {
+  background-color: #d81b60 !important;
+}
+
+.pink-text.text-darken-1 {
+  color: #d81b60 !important;
+}
+
+.pink.darken-2 {
+  background-color: #c2185b !important;
+}
+
+.pink-text.text-darken-2 {
+  color: #c2185b !important;
+}
+
+.pink.darken-3 {
+  background-color: #ad1457 !important;
+}
+
+.pink-text.text-darken-3 {
+  color: #ad1457 !important;
+}
+
+.pink.darken-4 {
+  background-color: #880e4f !important;
+}
+
+.pink-text.text-darken-4 {
+  color: #880e4f !important;
+}
+
+.pink.accent-1 {
+  background-color: #ff80ab !important;
+}
+
+.pink-text.text-accent-1 {
+  color: #ff80ab !important;
+}
+
+.pink.accent-2 {
+  background-color: #ff4081 !important;
+}
+
+.pink-text.text-accent-2 {
+  color: #ff4081 !important;
+}
+
+.pink.accent-3 {
+  background-color: #f50057 !important;
+}
+
+.pink-text.text-accent-3 {
+  color: #f50057 !important;
+}
+
+.pink.accent-4 {
+  background-color: #c51162 !important;
+}
+
+.pink-text.text-accent-4 {
+  color: #c51162 !important;
+}
+
+.purple {
+  background-color: #9c27b0 !important;
+}
+
+.purple-text {
+  color: #9c27b0 !important;
+}
+
+.purple.lighten-5 {
+  background-color: #f3e5f5 !important;
+}
+
+.purple-text.text-lighten-5 {
+  color: #f3e5f5 !important;
+}
+
+.purple.lighten-4 {
+  background-color: #e1bee7 !important;
+}
+
+.purple-text.text-lighten-4 {
+  color: #e1bee7 !important;
+}
+
+.purple.lighten-3 {
+  background-color: #ce93d8 !important;
+}
+
+.purple-text.text-lighten-3 {
+  color: #ce93d8 !important;
+}
+
+.purple.lighten-2 {
+  background-color: #ba68c8 !important;
+}
+
+.purple-text.text-lighten-2 {
+  color: #ba68c8 !important;
+}
+
+.purple.lighten-1 {
+  background-color: #ab47bc !important;
+}
+
+.purple-text.text-lighten-1 {
+  color: #ab47bc !important;
+}
+
+.purple.darken-1 {
+  background-color: #8e24aa !important;
+}
+
+.purple-text.text-darken-1 {
+  color: #8e24aa !important;
+}
+
+.purple.darken-2 {
+  background-color: #7b1fa2 !important;
+}
+
+.purple-text.text-darken-2 {
+  color: #7b1fa2 !important;
+}
+
+.purple.darken-3 {
+  background-color: #6a1b9a !important;
+}
+
+.purple-text.text-darken-3 {
+  color: #6a1b9a !important;
+}
+
+.purple.darken-4 {
+  background-color: #4a148c !important;
+}
+
+.purple-text.text-darken-4 {
+  color: #4a148c !important;
+}
+
+.purple.accent-1 {
+  background-color: #ea80fc !important;
+}
+
+.purple-text.text-accent-1 {
+  color: #ea80fc !important;
+}
+
+.purple.accent-2 {
+  background-color: #e040fb !important;
+}
+
+.purple-text.text-accent-2 {
+  color: #e040fb !important;
+}
+
+.purple.accent-3 {
+  background-color: #d500f9 !important;
+}
+
+.purple-text.text-accent-3 {
+  color: #d500f9 !important;
+}
+
+.purple.accent-4 {
+  background-color: #aa00ff !important;
+}
+
+.purple-text.text-accent-4 {
+  color: #aa00ff !important;
+}
+
+.deep-purple {
+  background-color: #673ab7 !important;
+}
+
+.deep-purple-text {
+  color: #673ab7 !important;
+}
+
+.deep-purple.lighten-5 {
+  background-color: #ede7f6 !important;
+}
+
+.deep-purple-text.text-lighten-5 {
+  color: #ede7f6 !important;
+}
+
+.deep-purple.lighten-4 {
+  background-color: #d1c4e9 !important;
+}
+
+.deep-purple-text.text-lighten-4 {
+  color: #d1c4e9 !important;
+}
+
+.deep-purple.lighten-3 {
+  background-color: #b39ddb !important;
+}
+
+.deep-purple-text.text-lighten-3 {
+  color: #b39ddb !important;
+}
+
+.deep-purple.lighten-2 {
+  background-color: #9575cd !important;
+}
+
+.deep-purple-text.text-lighten-2 {
+  color: #9575cd !important;
+}
+
+.deep-purple.lighten-1 {
+  background-color: #7e57c2 !important;
+}
+
+.deep-purple-text.text-lighten-1 {
+  color: #7e57c2 !important;
+}
+
+.deep-purple.darken-1 {
+  background-color: #5e35b1 !important;
+}
+
+.deep-purple-text.text-darken-1 {
+  color: #5e35b1 !important;
+}
+
+.deep-purple.darken-2 {
+  background-color: #512da8 !important;
+}
+
+.deep-purple-text.text-darken-2 {
+  color: #512da8 !important;
+}
+
+.deep-purple.darken-3 {
+  background-color: #4527a0 !important;
+}
+
+.deep-purple-text.text-darken-3 {
+  color: #4527a0 !important;
+}
+
+.deep-purple.darken-4 {
+  background-color: #311b92 !important;
+}
+
+.deep-purple-text.text-darken-4 {
+  color: #311b92 !important;
+}
+
+.deep-purple.accent-1 {
+  background-color: #b388ff !important;
+}
+
+.deep-purple-text.text-accent-1 {
+  color: #b388ff !important;
+}
+
+.deep-purple.accent-2 {
+  background-color: #7c4dff !important;
+}
+
+.deep-purple-text.text-accent-2 {
+  color: #7c4dff !important;
+}
+
+.deep-purple.accent-3 {
+  background-color: #651fff !important;
+}
+
+.deep-purple-text.text-accent-3 {
+  color: #651fff !important;
+}
+
+.deep-purple.accent-4 {
+  background-color: #6200ea !important;
+}
+
+.deep-purple-text.text-accent-4 {
+  color: #6200ea !important;
+}
+
+.indigo {
+  background-color: #3f51b5 !important;
+}
+
+.indigo-text {
+  color: #3f51b5 !important;
+}
+
+.indigo.lighten-5 {
+  background-color: #e8eaf6 !important;
+}
+
+.indigo-text.text-lighten-5 {
+  color: #e8eaf6 !important;
+}
+
+.indigo.lighten-4 {
+  background-color: #c5cae9 !important;
+}
+
+.indigo-text.text-lighten-4 {
+  color: #c5cae9 !important;
+}
+
+.indigo.lighten-3 {
+  background-color: #9fa8da !important;
+}
+
+.indigo-text.text-lighten-3 {
+  color: #9fa8da !important;
+}
+
+.indigo.lighten-2 {
+  background-color: #7986cb !important;
+}
+
+.indigo-text.text-lighten-2 {
+  color: #7986cb !important;
+}
+
+.indigo.lighten-1 {
+  background-color: #5c6bc0 !important;
+}
+
+.indigo-text.text-lighten-1 {
+  color: #5c6bc0 !important;
+}
+
+.indigo.darken-1 {
+  background-color: #3949ab !important;
+}
+
+.indigo-text.text-darken-1 {
+  color: #3949ab !important;
+}
+
+.indigo.darken-2 {
+  background-color: #303f9f !important;
+}
+
+.indigo-text.text-darken-2 {
+  color: #303f9f !important;
+}
+
+.indigo.darken-3 {
+  background-color: #283593 !important;
+}
+
+.indigo-text.text-darken-3 {
+  color: #283593 !important;
+}
+
+.indigo.darken-4 {
+  background-color: #1a237e !important;
+}
+
+.indigo-text.text-darken-4 {
+  color: #1a237e !important;
+}
+
+.indigo.accent-1 {
+  background-color: #8c9eff !important;
+}
+
+.indigo-text.text-accent-1 {
+  color: #8c9eff !important;
+}
+
+.indigo.accent-2 {
+  background-color: #536dfe !important;
+}
+
+.indigo-text.text-accent-2 {
+  color: #536dfe !important;
+}
+
+.indigo.accent-3 {
+  background-color: #3d5afe !important;
+}
+
+.indigo-text.text-accent-3 {
+  color: #3d5afe !important;
+}
+
+.indigo.accent-4 {
+  background-color: #304ffe !important;
+}
+
+.indigo-text.text-accent-4 {
+  color: #304ffe !important;
+}
+
+.blue {
+  background-color: #2196F3 !important;
+}
+
+.blue-text {
+  color: #2196F3 !important;
+}
+
+.blue.lighten-5 {
+  background-color: #E3F2FD !important;
+}
+
+.blue-text.text-lighten-5 {
+  color: #E3F2FD !important;
+}
+
+.blue.lighten-4 {
+  background-color: #BBDEFB !important;
+}
+
+.blue-text.text-lighten-4 {
+  color: #BBDEFB !important;
+}
+
+.blue.lighten-3 {
+  background-color: #90CAF9 !important;
+}
+
+.blue-text.text-lighten-3 {
+  color: #90CAF9 !important;
+}
+
+.blue.lighten-2 {
+  background-color: #64B5F6 !important;
+}
+
+.blue-text.text-lighten-2 {
+  color: #64B5F6 !important;
+}
+
+.blue.lighten-1 {
+  background-color: #42A5F5 !important;
+}
+
+.blue-text.text-lighten-1 {
+  color: #42A5F5 !important;
+}
+
+.blue.darken-1 {
+  background-color: #1E88E5 !important;
+}
+
+.blue-text.text-darken-1 {
+  color: #1E88E5 !important;
+}
+
+.blue.darken-2 {
+  background-color: #1976D2 !important;
+}
+
+.blue-text.text-darken-2 {
+  color: #1976D2 !important;
+}
+
+.blue.darken-3 {
+  background-color: #1565C0 !important;
+}
+
+.blue-text.text-darken-3 {
+  color: #1565C0 !important;
+}
+
+.blue.darken-4 {
+  background-color: #0D47A1 !important;
+}
+
+.blue-text.text-darken-4 {
+  color: #0D47A1 !important;
+}
+
+.blue.accent-1 {
+  background-color: #82B1FF !important;
+}
+
+.blue-text.text-accent-1 {
+  color: #82B1FF !important;
+}
+
+.blue.accent-2 {
+  background-color: #448AFF !important;
+}
+
+.blue-text.text-accent-2 {
+  color: #448AFF !important;
+}
+
+.blue.accent-3 {
+  background-color: #2979FF !important;
+}
+
+.blue-text.text-accent-3 {
+  color: #2979FF !important;
+}
+
+.blue.accent-4 {
+  background-color: #2962FF !important;
+}
+
+.blue-text.text-accent-4 {
+  color: #2962FF !important;
+}
+
+.light-blue {
+  background-color: #03a9f4 !important;
+}
+
+.light-blue-text {
+  color: #03a9f4 !important;
+}
+
+.light-blue.lighten-5 {
+  background-color: #e1f5fe !important;
+}
+
+.light-blue-text.text-lighten-5 {
+  color: #e1f5fe !important;
+}
+
+.light-blue.lighten-4 {
+  background-color: #b3e5fc !important;
+}
+
+.light-blue-text.text-lighten-4 {
+  color: #b3e5fc !important;
+}
+
+.light-blue.lighten-3 {
+  background-color: #81d4fa !important;
+}
+
+.light-blue-text.text-lighten-3 {
+  color: #81d4fa !important;
+}
+
+.light-blue.lighten-2 {
+  background-color: #4fc3f7 !important;
+}
+
+.light-blue-text.text-lighten-2 {
+  color: #4fc3f7 !important;
+}
+
+.light-blue.lighten-1 {
+  background-color: #29b6f6 !important;
+}
+
+.light-blue-text.text-lighten-1 {
+  color: #29b6f6 !important;
+}
+
+.light-blue.darken-1 {
+  background-color: #039be5 !important;
+}
+
+.light-blue-text.text-darken-1 {
+  color: #039be5 !important;
+}
+
+.light-blue.darken-2 {
+  background-color: #0288d1 !important;
+}
+
+.light-blue-text.text-darken-2 {
+  color: #0288d1 !important;
+}
+
+.light-blue.darken-3 {
+  background-color: #0277bd !important;
+}
+
+.light-blue-text.text-darken-3 {
+  color: #0277bd !important;
+}
+
+.light-blue.darken-4 {
+  background-color: #01579b !important;
+}
+
+.light-blue-text.text-darken-4 {
+  color: #01579b !important;
+}
+
+.light-blue.accent-1 {
+  background-color: #80d8ff !important;
+}
+
+.light-blue-text.text-accent-1 {
+  color: #80d8ff !important;
+}
+
+.light-blue.accent-2 {
+  background-color: #40c4ff !important;
+}
+
+.light-blue-text.text-accent-2 {
+  color: #40c4ff !important;
+}
+
+.light-blue.accent-3 {
+  background-color: #00b0ff !important;
+}
+
+.light-blue-text.text-accent-3 {
+  color: #00b0ff !important;
+}
+
+.light-blue.accent-4 {
+  background-color: #0091ea !important;
+}
+
+.light-blue-text.text-accent-4 {
+  color: #0091ea !important;
+}
+
+.cyan {
+  background-color: #00bcd4 !important;
+}
+
+.cyan-text {
+  color: #00bcd4 !important;
+}
+
+.cyan.lighten-5 {
+  background-color: #e0f7fa !important;
+}
+
+.cyan-text.text-lighten-5 {
+  color: #e0f7fa !important;
+}
+
+.cyan.lighten-4 {
+  background-color: #b2ebf2 !important;
+}
+
+.cyan-text.text-lighten-4 {
+  color: #b2ebf2 !important;
+}
+
+.cyan.lighten-3 {
+  background-color: #80deea !important;
+}
+
+.cyan-text.text-lighten-3 {
+  color: #80deea !important;
+}
+
+.cyan.lighten-2 {
+  background-color: #4dd0e1 !important;
+}
+
+.cyan-text.text-lighten-2 {
+  color: #4dd0e1 !important;
+}
+
+.cyan.lighten-1 {
+  background-color: #26c6da !important;
+}
+
+.cyan-text.text-lighten-1 {
+  color: #26c6da !important;
+}
+
+.cyan.darken-1 {
+  background-color: #00acc1 !important;
+}
+
+.cyan-text.text-darken-1 {
+  color: #00acc1 !important;
+}
+
+.cyan.darken-2 {
+  background-color: #0097a7 !important;
+}
+
+.cyan-text.text-darken-2 {
+  color: #0097a7 !important;
+}
+
+.cyan.darken-3 {
+  background-color: #00838f !important;
+}
+
+.cyan-text.text-darken-3 {
+  color: #00838f !important;
+}
+
+.cyan.darken-4 {
+  background-color: #006064 !important;
+}
+
+.cyan-text.text-darken-4 {
+  color: #006064 !important;
+}
+
+.cyan.accent-1 {
+  background-color: #84ffff !important;
+}
+
+.cyan-text.text-accent-1 {
+  color: #84ffff !important;
+}
+
+.cyan.accent-2 {
+  background-color: #18ffff !important;
+}
+
+.cyan-text.text-accent-2 {
+  color: #18ffff !important;
+}
+
+.cyan.accent-3 {
+  background-color: #00e5ff !important;
+}
+
+.cyan-text.text-accent-3 {
+  color: #00e5ff !important;
+}
+
+.cyan.accent-4 {
+  background-color: #00b8d4 !important;
+}
+
+.cyan-text.text-accent-4 {
+  color: #00b8d4 !important;
+}
+
+.teal {
+  background-color: #009688 !important;
+}
+
+.teal-text {
+  color: #009688 !important;
+}
+
+.teal.lighten-5 {
+  background-color: #e0f2f1 !important;
+}
+
+.teal-text.text-lighten-5 {
+  color: #e0f2f1 !important;
+}
+
+.teal.lighten-4 {
+  background-color: #b2dfdb !important;
+}
+
+.teal-text.text-lighten-4 {
+  color: #b2dfdb !important;
+}
+
+.teal.lighten-3 {
+  background-color: #80cbc4 !important;
+}
+
+.teal-text.text-lighten-3 {
+  color: #80cbc4 !important;
+}
+
+.teal.lighten-2 {
+  background-color: #4db6ac !important;
+}
+
+.teal-text.text-lighten-2 {
+  color: #4db6ac !important;
+}
+
+.teal.lighten-1 {
+  background-color: #26a69a !important;
+}
+
+.teal-text.text-lighten-1 {
+  color: #26a69a !important;
+}
+
+.teal.darken-1 {
+  background-color: #00897b !important;
+}
+
+.teal-text.text-darken-1 {
+  color: #00897b !important;
+}
+
+.teal.darken-2 {
+  background-color: #00796b !important;
+}
+
+.teal-text.text-darken-2 {
+  color: #00796b !important;
+}
+
+.teal.darken-3 {
+  background-color: #00695c !important;
+}
+
+.teal-text.text-darken-3 {
+  color: #00695c !important;
+}
+
+.teal.darken-4 {
+  background-color: #004d40 !important;
+}
+
+.teal-text.text-darken-4 {
+  color: #004d40 !important;
+}
+
+.teal.accent-1 {
+  background-color: #a7ffeb !important;
+}
+
+.teal-text.text-accent-1 {
+  color: #a7ffeb !important;
+}
+
+.teal.accent-2 {
+  background-color: #64ffda !important;
+}
+
+.teal-text.text-accent-2 {
+  color: #64ffda !important;
+}
+
+.teal.accent-3 {
+  background-color: #1de9b6 !important;
+}
+
+.teal-text.text-accent-3 {
+  color: #1de9b6 !important;
+}
+
+.teal.accent-4 {
+  background-color: #00bfa5 !important;
+}
+
+.teal-text.text-accent-4 {
+  color: #00bfa5 !important;
+}
+
+.green {
+  background-color: #4CAF50 !important;
+}
+
+.green-text {
+  color: #4CAF50 !important;
+}
+
+.green.lighten-5 {
+  background-color: #E8F5E9 !important;
+}
+
+.green-text.text-lighten-5 {
+  color: #E8F5E9 !important;
+}
+
+.green.lighten-4 {
+  background-color: #C8E6C9 !important;
+}
+
+.green-text.text-lighten-4 {
+  color: #C8E6C9 !important;
+}
+
+.green.lighten-3 {
+  background-color: #A5D6A7 !important;
+}
+
+.green-text.text-lighten-3 {
+  color: #A5D6A7 !important;
+}
+
+.green.lighten-2 {
+  background-color: #81C784 !important;
+}
+
+.green-text.text-lighten-2 {
+  color: #81C784 !important;
+}
+
+.green.lighten-1 {
+  background-color: #66BB6A !important;
+}
+
+.green-text.text-lighten-1 {
+  color: #66BB6A !important;
+}
+
+.green.darken-1 {
+  background-color: #43A047 !important;
+}
+
+.green-text.text-darken-1 {
+  color: #43A047 !important;
+}
+
+.green.darken-2 {
+  background-color: #388E3C !important;
+}
+
+.green-text.text-darken-2 {
+  color: #388E3C !important;
+}
+
+.green.darken-3 {
+  background-color: #2E7D32 !important;
+}
+
+.green-text.text-darken-3 {
+  color: #2E7D32 !important;
+}
+
+.green.darken-4 {
+  background-color: #1B5E20 !important;
+}
+
+.green-text.text-darken-4 {
+  color: #1B5E20 !important;
+}
+
+.green.accent-1 {
+  background-color: #B9F6CA !important;
+}
+
+.green-text.text-accent-1 {
+  color: #B9F6CA !important;
+}
+
+.green.accent-2 {
+  background-color: #69F0AE !important;
+}
+
+.green-text.text-accent-2 {
+  color: #69F0AE !important;
+}
+
+.green.accent-3 {
+  background-color: #00E676 !important;
+}
+
+.green-text.text-accent-3 {
+  color: #00E676 !important;
+}
+
+.green.accent-4 {
+  background-color: #00C853 !important;
+}
+
+.green-text.text-accent-4 {
+  color: #00C853 !important;
+}
+
+.light-green {
+  background-color: #8bc34a !important;
+}
+
+.light-green-text {
+  color: #8bc34a !important;
+}
+
+.light-green.lighten-5 {
+  background-color: #f1f8e9 !important;
+}
+
+.light-green-text.text-lighten-5 {
+  color: #f1f8e9 !important;
+}
+
+.light-green.lighten-4 {
+  background-color: #dcedc8 !important;
+}
+
+.light-green-text.text-lighten-4 {
+  color: #dcedc8 !important;
+}
+
+.light-green.lighten-3 {
+  background-color: #c5e1a5 !important;
+}
+
+.light-green-text.text-lighten-3 {
+  color: #c5e1a5 !important;
+}
+
+.light-green.lighten-2 {
+  background-color: #aed581 !important;
+}
+
+.light-green-text.text-lighten-2 {
+  color: #aed581 !important;
+}
+
+.light-green.lighten-1 {
+  background-color: #9ccc65 !important;
+}
+
+.light-green-text.text-lighten-1 {
+  color: #9ccc65 !important;
+}
+
+.light-green.darken-1 {
+  background-color: #7cb342 !important;
+}
+
+.light-green-text.text-darken-1 {
+  color: #7cb342 !important;
+}
+
+.light-green.darken-2 {
+  background-color: #689f38 !important;
+}
+
+.light-green-text.text-darken-2 {
+  color: #689f38 !important;
+}
+
+.light-green.darken-3 {
+  background-color: #558b2f !important;
+}
+
+.light-green-text.text-darken-3 {
+  color: #558b2f !important;
+}
+
+.light-green.darken-4 {
+  background-color: #33691e !important;
+}
+
+.light-green-text.text-darken-4 {
+  color: #33691e !important;
+}
+
+.light-green.accent-1 {
+  background-color: #ccff90 !important;
+}
+
+.light-green-text.text-accent-1 {
+  color: #ccff90 !important;
+}
+
+.light-green.accent-2 {
+  background-color: #b2ff59 !important;
+}
+
+.light-green-text.text-accent-2 {
+  color: #b2ff59 !important;
+}
+
+.light-green.accent-3 {
+  background-color: #76ff03 !important;
+}
+
+.light-green-text.text-accent-3 {
+  color: #76ff03 !important;
+}
+
+.light-green.accent-4 {
+  background-color: #64dd17 !important;
+}
+
+.light-green-text.text-accent-4 {
+  color: #64dd17 !important;
+}
+
+.lime {
+  background-color: #cddc39 !important;
+}
+
+.lime-text {
+  color: #cddc39 !important;
+}
+
+.lime.lighten-5 {
+  background-color: #f9fbe7 !important;
+}
+
+.lime-text.text-lighten-5 {
+  color: #f9fbe7 !important;
+}
+
+.lime.lighten-4 {
+  background-color: #f0f4c3 !important;
+}
+
+.lime-text.text-lighten-4 {
+  color: #f0f4c3 !important;
+}
+
+.lime.lighten-3 {
+  background-color: #e6ee9c !important;
+}
+
+.lime-text.text-lighten-3 {
+  color: #e6ee9c !important;
+}
+
+.lime.lighten-2 {
+  background-color: #dce775 !important;
+}
+
+.lime-text.text-lighten-2 {
+  color: #dce775 !important;
+}
+
+.lime.lighten-1 {
+  background-color: #d4e157 !important;
+}
+
+.lime-text.text-lighten-1 {
+  color: #d4e157 !important;
+}
+
+.lime.darken-1 {
+  background-color: #c0ca33 !important;
+}
+
+.lime-text.text-darken-1 {
+  color: #c0ca33 !important;
+}
+
+.lime.darken-2 {
+  background-color: #afb42b !important;
+}
+
+.lime-text.text-darken-2 {
+  color: #afb42b !important;
+}
+
+.lime.darken-3 {
+  background-color: #9e9d24 !important;
+}
+
+.lime-text.text-darken-3 {
+  color: #9e9d24 !important;
+}
+
+.lime.darken-4 {
+  background-color: #827717 !important;
+}
+
+.lime-text.text-darken-4 {
+  color: #827717 !important;
+}
+
+.lime.accent-1 {
+  background-color: #f4ff81 !important;
+}
+
+.lime-text.text-accent-1 {
+  color: #f4ff81 !important;
+}
+
+.lime.accent-2 {
+  background-color: #eeff41 !important;
+}
+
+.lime-text.text-accent-2 {
+  color: #eeff41 !important;
+}
+
+.lime.accent-3 {
+  background-color: #c6ff00 !important;
+}
+
+.lime-text.text-accent-3 {
+  color: #c6ff00 !important;
+}
+
+.lime.accent-4 {
+  background-color: #aeea00 !important;
+}
+
+.lime-text.text-accent-4 {
+  color: #aeea00 !important;
+}
+
+.yellow {
+  background-color: #ffeb3b !important;
+}
+
+.yellow-text {
+  color: #ffeb3b !important;
+}
+
+.yellow.lighten-5 {
+  background-color: #fffde7 !important;
+}
+
+.yellow-text.text-lighten-5 {
+  color: #fffde7 !important;
+}
+
+.yellow.lighten-4 {
+  background-color: #fff9c4 !important;
+}
+
+.yellow-text.text-lighten-4 {
+  color: #fff9c4 !important;
+}
+
+.yellow.lighten-3 {
+  background-color: #fff59d !important;
+}
+
+.yellow-text.text-lighten-3 {
+  color: #fff59d !important;
+}
+
+.yellow.lighten-2 {
+  background-color: #fff176 !important;
+}
+
+.yellow-text.text-lighten-2 {
+  color: #fff176 !important;
+}
+
+.yellow.lighten-1 {
+  background-color: #ffee58 !important;
+}
+
+.yellow-text.text-lighten-1 {
+  color: #ffee58 !important;
+}
+
+.yellow.darken-1 {
+  background-color: #fdd835 !important;
+}
+
+.yellow-text.text-darken-1 {
+  color: #fdd835 !important;
+}
+
+.yellow.darken-2 {
+  background-color: #fbc02d !important;
+}
+
+.yellow-text.text-darken-2 {
+  color: #fbc02d !important;
+}
+
+.yellow.darken-3 {
+  background-color: #f9a825 !important;
+}
+
+.yellow-text.text-darken-3 {
+  color: #f9a825 !important;
+}
+
+.yellow.darken-4 {
+  background-color: #f57f17 !important;
+}
+
+.yellow-text.text-darken-4 {
+  color: #f57f17 !important;
+}
+
+.yellow.accent-1 {
+  background-color: #ffff8d !important;
+}
+
+.yellow-text.text-accent-1 {
+  color: #ffff8d !important;
+}
+
+.yellow.accent-2 {
+  background-color: #ffff00 !important;
+}
+
+.yellow-text.text-accent-2 {
+  color: #ffff00 !important;
+}
+
+.yellow.accent-3 {
+  background-color: #ffea00 !important;
+}
+
+.yellow-text.text-accent-3 {
+  color: #ffea00 !important;
+}
+
+.yellow.accent-4 {
+  background-color: #ffd600 !important;
+}
+
+.yellow-text.text-accent-4 {
+  color: #ffd600 !important;
+}
+
+.amber {
+  background-color: #ffc107 !important;
+}
+
+.amber-text {
+  color: #ffc107 !important;
+}
+
+.amber.lighten-5 {
+  background-color: #fff8e1 !important;
+}
+
+.amber-text.text-lighten-5 {
+  color: #fff8e1 !important;
+}
+
+.amber.lighten-4 {
+  background-color: #ffecb3 !important;
+}
+
+.amber-text.text-lighten-4 {
+  color: #ffecb3 !important;
+}
+
+.amber.lighten-3 {
+  background-color: #ffe082 !important;
+}
+
+.amber-text.text-lighten-3 {
+  color: #ffe082 !important;
+}
+
+.amber.lighten-2 {
+  background-color: #ffd54f !important;
+}
+
+.amber-text.text-lighten-2 {
+  color: #ffd54f !important;
+}
+
+.amber.lighten-1 {
+  background-color: #ffca28 !important;
+}
+
+.amber-text.text-lighten-1 {
+  color: #ffca28 !important;
+}
+
+.amber.darken-1 {
+  background-color: #ffb300 !important;
+}
+
+.amber-text.text-darken-1 {
+  color: #ffb300 !important;
+}
+
+.amber.darken-2 {
+  background-color: #ffa000 !important;
+}
+
+.amber-text.text-darken-2 {
+  color: #ffa000 !important;
+}
+
+.amber.darken-3 {
+  background-color: #ff8f00 !important;
+}
+
+.amber-text.text-darken-3 {
+  color: #ff8f00 !important;
+}
+
+.amber.darken-4 {
+  background-color: #ff6f00 !important;
+}
+
+.amber-text.text-darken-4 {
+  color: #ff6f00 !important;
+}
+
+.amber.accent-1 {
+  background-color: #ffe57f !important;
+}
+
+.amber-text.text-accent-1 {
+  color: #ffe57f !important;
+}
+
+.amber.accent-2 {
+  background-color: #ffd740 !important;
+}
+
+.amber-text.text-accent-2 {
+  color: #ffd740 !important;
+}
+
+.amber.accent-3 {
+  background-color: #ffc400 !important;
+}
+
+.amber-text.text-accent-3 {
+  color: #ffc400 !important;
+}
+
+.amber.accent-4 {
+  background-color: #ffab00 !important;
+}
+
+.amber-text.text-accent-4 {
+  color: #ffab00 !important;
+}
+
+.orange {
+  background-color: #ff9800 !important;
+}
+
+.orange-text {
+  color: #ff9800 !important;
+}
+
+.orange.lighten-5 {
+  background-color: #fff3e0 !important;
+}
+
+.orange-text.text-lighten-5 {
+  color: #fff3e0 !important;
+}
+
+.orange.lighten-4 {
+  background-color: #ffe0b2 !important;
+}
+
+.orange-text.text-lighten-4 {
+  color: #ffe0b2 !important;
+}
+
+.orange.lighten-3 {
+  background-color: #ffcc80 !important;
+}
+
+.orange-text.text-lighten-3 {
+  color: #ffcc80 !important;
+}
+
+.orange.lighten-2 {
+  background-color: #ffb74d !important;
+}
+
+.orange-text.text-lighten-2 {
+  color: #ffb74d !important;
+}
+
+.orange.lighten-1 {
+  background-color: #ffa726 !important;
+}
+
+.orange-text.text-lighten-1 {
+  color: #ffa726 !important;
+}
+
+.orange.darken-1 {
+  background-color: #fb8c00 !important;
+}
+
+.orange-text.text-darken-1 {
+  color: #fb8c00 !important;
+}
+
+.orange.darken-2 {
+  background-color: #f57c00 !important;
+}
+
+.orange-text.text-darken-2 {
+  color: #f57c00 !important;
+}
+
+.orange.darken-3 {
+  background-color: #ef6c00 !important;
+}
+
+.orange-text.text-darken-3 {
+  color: #ef6c00 !important;
+}
+
+.orange.darken-4 {
+  background-color: #e65100 !important;
+}
+
+.orange-text.text-darken-4 {
+  color: #e65100 !important;
+}
+
+.orange.accent-1 {
+  background-color: #ffd180 !important;
+}
+
+.orange-text.text-accent-1 {
+  color: #ffd180 !important;
+}
+
+.orange.accent-2 {
+  background-color: #ffab40 !important;
+}
+
+.orange-text.text-accent-2 {
+  color: #ffab40 !important;
+}
+
+.orange.accent-3 {
+  background-color: #ff9100 !important;
+}
+
+.orange-text.text-accent-3 {
+  color: #ff9100 !important;
+}
+
+.orange.accent-4 {
+  background-color: #ff6d00 !important;
+}
+
+.orange-text.text-accent-4 {
+  color: #ff6d00 !important;
+}
+
+.deep-orange {
+  background-color: #ff5722 !important;
+}
+
+.deep-orange-text {
+  color: #ff5722 !important;
+}
+
+.deep-orange.lighten-5 {
+  background-color: #fbe9e7 !important;
+}
+
+.deep-orange-text.text-lighten-5 {
+  color: #fbe9e7 !important;
+}
+
+.deep-orange.lighten-4 {
+  background-color: #ffccbc !important;
+}
+
+.deep-orange-text.text-lighten-4 {
+  color: #ffccbc !important;
+}
+
+.deep-orange.lighten-3 {
+  background-color: #ffab91 !important;
+}
+
+.deep-orange-text.text-lighten-3 {
+  color: #ffab91 !important;
+}
+
+.deep-orange.lighten-2 {
+  background-color: #ff8a65 !important;
+}
+
+.deep-orange-text.text-lighten-2 {
+  color: #ff8a65 !important;
+}
+
+.deep-orange.lighten-1 {
+  background-color: #ff7043 !important;
+}
+
+.deep-orange-text.text-lighten-1 {
+  color: #ff7043 !important;
+}
+
+.deep-orange.darken-1 {
+  background-color: #f4511e !important;
+}
+
+.deep-orange-text.text-darken-1 {
+  color: #f4511e !important;
+}
+
+.deep-orange.darken-2 {
+  background-color: #e64a19 !important;
+}
+
+.deep-orange-text.text-darken-2 {
+  color: #e64a19 !important;
+}
+
+.deep-orange.darken-3 {
+  background-color: #d84315 !important;
+}
+
+.deep-orange-text.text-darken-3 {
+  color: #d84315 !important;
+}
+
+.deep-orange.darken-4 {
+  background-color: #bf360c !important;
+}
+
+.deep-orange-text.text-darken-4 {
+  color: #bf360c !important;
+}
+
+.deep-orange.accent-1 {
+  background-color: #ff9e80 !important;
+}
+
+.deep-orange-text.text-accent-1 {
+  color: #ff9e80 !important;
+}
+
+.deep-orange.accent-2 {
+  background-color: #ff6e40 !important;
+}
+
+.deep-orange-text.text-accent-2 {
+  color: #ff6e40 !important;
+}
+
+.deep-orange.accent-3 {
+  background-color: #ff3d00 !important;
+}
+
+.deep-orange-text.text-accent-3 {
+  color: #ff3d00 !important;
+}
+
+.deep-orange.accent-4 {
+  background-color: #dd2c00 !important;
+}
+
+.deep-orange-text.text-accent-4 {
+  color: #dd2c00 !important;
+}
+
+.brown {
+  background-color: #795548 !important;
+}
+
+.brown-text {
+  color: #795548 !important;
+}
+
+.brown.lighten-5 {
+  background-color: #efebe9 !important;
+}
+
+.brown-text.text-lighten-5 {
+  color: #efebe9 !important;
+}
+
+.brown.lighten-4 {
+  background-color: #d7ccc8 !important;
+}
+
+.brown-text.text-lighten-4 {
+  color: #d7ccc8 !important;
+}
+
+.brown.lighten-3 {
+  background-color: #bcaaa4 !important;
+}
+
+.brown-text.text-lighten-3 {
+  color: #bcaaa4 !important;
+}
+
+.brown.lighten-2 {
+  background-color: #a1887f !important;
+}
+
+.brown-text.text-lighten-2 {
+  color: #a1887f !important;
+}
+
+.brown.lighten-1 {
+  background-color: #8d6e63 !important;
+}
+
+.brown-text.text-lighten-1 {
+  color: #8d6e63 !important;
+}
+
+.brown.darken-1 {
+  background-color: #6d4c41 !important;
+}
+
+.brown-text.text-darken-1 {
+  color: #6d4c41 !important;
+}
+
+.brown.darken-2 {
+  background-color: #5d4037 !important;
+}
+
+.brown-text.text-darken-2 {
+  color: #5d4037 !important;
+}
+
+.brown.darken-3 {
+  background-color: #4e342e !important;
+}
+
+.brown-text.text-darken-3 {
+  color: #4e342e !important;
+}
+
+.brown.darken-4 {
+  background-color: #3e2723 !important;
+}
+
+.brown-text.text-darken-4 {
+  color: #3e2723 !important;
+}
+
+.blue-grey {
+  background-color: #607d8b !important;
+}
+
+.blue-grey-text {
+  color: #607d8b !important;
+}
+
+.blue-grey.lighten-5 {
+  background-color: #eceff1 !important;
+}
+
+.blue-grey-text.text-lighten-5 {
+  color: #eceff1 !important;
+}
+
+.blue-grey.lighten-4 {
+  background-color: #cfd8dc !important;
+}
+
+.blue-grey-text.text-lighten-4 {
+  color: #cfd8dc !important;
+}
+
+.blue-grey.lighten-3 {
+  background-color: #b0bec5 !important;
+}
+
+.blue-grey-text.text-lighten-3 {
+  color: #b0bec5 !important;
+}
+
+.blue-grey.lighten-2 {
+  background-color: #90a4ae !important;
+}
+
+.blue-grey-text.text-lighten-2 {
+  color: #90a4ae !important;
+}
+
+.blue-grey.lighten-1 {
+  background-color: #78909c !important;
+}
+
+.blue-grey-text.text-lighten-1 {
+  color: #78909c !important;
+}
+
+.blue-grey.darken-1 {
+  background-color: #546e7a !important;
+}
+
+.blue-grey-text.text-darken-1 {
+  color: #546e7a !important;
+}
+
+.blue-grey.darken-2 {
+  background-color: #455a64 !important;
+}
+
+.blue-grey-text.text-darken-2 {
+  color: #455a64 !important;
+}
+
+.blue-grey.darken-3 {
+  background-color: #37474f !important;
+}
+
+.blue-grey-text.text-darken-3 {
+  color: #37474f !important;
+}
+
+.blue-grey.darken-4 {
+  background-color: #263238 !important;
+}
+
+.blue-grey-text.text-darken-4 {
+  color: #263238 !important;
+}
+
+.grey {
+  background-color: #9e9e9e !important;
+}
+
+.grey-text {
+  color: #9e9e9e !important;
+}
+
+.grey.lighten-5 {
+  background-color: #fafafa !important;
+}
+
+.grey-text.text-lighten-5 {
+  color: #fafafa !important;
+}
+
+.grey.lighten-4 {
+  background-color: #f5f5f5 !important;
+}
+
+.grey-text.text-lighten-4 {
+  color: #f5f5f5 !important;
+}
+
+.grey.lighten-3 {
+  background-color: #eeeeee !important;
+}
+
+.grey-text.text-lighten-3 {
+  color: #eeeeee !important;
+}
+
+.grey.lighten-2 {
+  background-color: #e0e0e0 !important;
+}
+
+.grey-text.text-lighten-2 {
+  color: #e0e0e0 !important;
+}
+
+.grey.lighten-1 {
+  background-color: #bdbdbd !important;
+}
+
+.grey-text.text-lighten-1 {
+  color: #bdbdbd !important;
+}
+
+.grey.darken-1 {
+  background-color: #757575 !important;
+}
+
+.grey-text.text-darken-1 {
+  color: #757575 !important;
+}
+
+.grey.darken-2 {
+  background-color: #616161 !important;
+}
+
+.grey-text.text-darken-2 {
+  color: #616161 !important;
+}
+
+.grey.darken-3 {
+  background-color: #424242 !important;
+}
+
+.grey-text.text-darken-3 {
+  color: #424242 !important;
+}
+
+.grey.darken-4 {
+  background-color: #212121 !important;
+}
+
+.grey-text.text-darken-4 {
+  color: #212121 !important;
+}
+
+.black {
+  background-color: #000000 !important;
+}
+
+.black-text {
+  color: #000000 !important;
+}
+
+.white {
+  background-color: #FFFFFF !important;
+}
+
+.white-text {
+  color: #FFFFFF !important;
+}
+
+.transparent {
+  background-color: transparent !important;
+}
+
+.transparent-text {
+  color: transparent !important;
+}
+
+/*! normalize.css v8.0.1 | MIT License | github.com/necolas/normalize.css */
+/* Document
+   ========================================================================== */
+/**
+ * 1. Correct the line height in all browsers.
+ * 2. Prevent adjustments of font size after orientation changes in iOS.
+ */
+html {
+  line-height: 1.15; /* 1 */
+  -webkit-text-size-adjust: 100%; /* 2 */
+}
+
+/* Sections
+   ========================================================================== */
+/**
+ * Remove the margin in all browsers.
+ */
+body {
+  margin: 0;
+}
+
+/**
+ * Render the `main` element consistently in IE.
+ */
+main {
+  display: block;
+}
+
+/**
+ * Correct the font size and margin on `h1` elements within `section` and
+ * `article` contexts in Chrome, Firefox, and Safari.
+ */
+h1 {
+  font-size: 2em;
+  margin: 0.67em 0;
+}
+
+/* Grouping content
+   ========================================================================== */
+/**
+ * 1. Add the correct box sizing in Firefox.
+ * 2. Show the overflow in Edge and IE.
+ */
+hr {
+  box-sizing: content-box; /* 1 */
+  height: 0; /* 1 */
+  overflow: visible; /* 2 */
+}
+
+/**
+ * 1. Correct the inheritance and scaling of font size in all browsers.
+ * 2. Correct the odd `em` font sizing in all browsers.
+ */
+pre {
+  font-family: monospace, monospace; /* 1 */
+  font-size: 1em; /* 2 */
+}
+
+/* Text-level semantics
+   ========================================================================== */
+/**
+ * Remove the gray background on active links in IE 10.
+ */
+a {
+  background-color: transparent;
+}
+
+/**
+ * 1. Remove the bottom border in Chrome 57-
+ * 2. Add the correct text decoration in Chrome, Edge, IE, Opera, and Safari.
+ */
+abbr[title] {
+  border-bottom: none; /* 1 */
+  text-decoration: underline; /* 2 */
+  text-decoration: underline dotted; /* 2 */
+}
+
+/**
+ * Add the correct font weight in Chrome, Edge, and Safari.
+ */
+b,
+strong {
+  font-weight: bolder;
+}
+
+/**
+ * 1. Correct the inheritance and scaling of font size in all browsers.
+ * 2. Correct the odd `em` font sizing in all browsers.
+ */
+code,
+kbd,
+samp {
+  font-family: monospace, monospace; /* 1 */
+  font-size: 1em; /* 2 */
+}
+
+/**
+ * Add the correct font size in all browsers.
+ */
+small {
+  font-size: 80%;
+}
+
+/**
+ * Prevent `sub` and `sup` elements from affecting the line height in
+ * all browsers.
+ */
+sub,
+sup {
+  font-size: 75%;
+  line-height: 0;
+  position: relative;
+  vertical-align: baseline;
+}
+
+sub {
+  bottom: -0.25em;
+}
+
+sup {
+  top: -0.5em;
+}
+
+/* Embedded content
+   ========================================================================== */
+/**
+ * Remove the border on images inside links in IE 10.
+ */
+img {
+  border-style: none;
+}
+
+/* Forms
+   ========================================================================== */
+/**
+ * 1. Change the font styles in all browsers.
+ * 2. Remove the margin in Firefox and Safari.
+ */
+button,
+input,
+optgroup,
+select,
+textarea {
+  font-family: inherit; /* 1 */
+  font-size: 100%; /* 1 */
+  line-height: 1.15; /* 1 */
+  margin: 0; /* 2 */
+}
+
+/**
+ * Show the overflow in IE.
+ * 1. Show the overflow in Edge.
+ */
+button,
+input { /* 1 */
+  overflow: visible;
+}
+
+/**
+ * Remove the inheritance of text transform in Edge, Firefox, and IE.
+ * 1. Remove the inheritance of text transform in Firefox.
+ */
+button,
+select { /* 1 */
+  text-transform: none;
+}
+
+/**
+ * Correct the inability to style clickable types in iOS and Safari.
+ */
+button,
+[type=button],
+[type=reset],
+[type=submit] {
+  -webkit-appearance: button;
+}
+
+/**
+ * Remove the inner border and padding in Firefox.
+ */
+button::-moz-focus-inner,
+[type=button]::-moz-focus-inner,
+[type=reset]::-moz-focus-inner,
+[type=submit]::-moz-focus-inner {
+  border-style: none;
+  padding: 0;
+}
+
+/**
+ * Restore the focus styles unset by the previous rule.
+ */
+button:-moz-focusring,
+[type=button]:-moz-focusring,
+[type=reset]:-moz-focusring,
+[type=submit]:-moz-focusring {
+  outline: 1px dotted ButtonText;
+}
+
+/**
+ * Correct the padding in Firefox.
+ */
+fieldset {
+  padding: 0.35em 0.75em 0.625em;
+}
+
+/**
+ * 1. Correct the text wrapping in Edge and IE.
+ * 2. Correct the color inheritance from `fieldset` elements in IE.
+ * 3. Remove the padding so developers are not caught out when they zero out
+ *    `fieldset` elements in all browsers.
+ */
+legend {
+  box-sizing: border-box; /* 1 */
+  color: inherit; /* 2 */
+  display: table; /* 1 */
+  max-width: 100%; /* 1 */
+  padding: 0; /* 3 */
+  white-space: normal; /* 1 */
+}
+
+/**
+ * Add the correct vertical alignment in Chrome, Firefox, and Opera.
+ */
+progress {
+  vertical-align: baseline;
+}
+
+/**
+ * Remove the default vertical scrollbar in IE 10+.
+ */
+textarea {
+  overflow: auto;
+}
+
+/**
+ * 1. Add the correct box sizing in IE 10.
+ * 2. Remove the padding in IE 10.
+ */
+[type=checkbox],
+[type=radio] {
+  box-sizing: border-box; /* 1 */
+  padding: 0; /* 2 */
+}
+
+/**
+ * Correct the cursor style of increment and decrement buttons in Chrome.
+ */
+[type=number]::-webkit-inner-spin-button,
+[type=number]::-webkit-outer-spin-button {
+  height: auto;
+}
+
+/**
+ * 1. Correct the odd appearance in Chrome and Safari.
+ * 2. Correct the outline style in Safari.
+ */
+[type=search] {
+  -webkit-appearance: textfield; /* 1 */
+  outline-offset: -2px; /* 2 */
+}
+
+/**
+ * Remove the inner padding in Chrome and Safari on macOS.
+ */
+[type=search]::-webkit-search-decoration {
+  -webkit-appearance: none;
+}
+
+/**
+ * 1. Correct the inability to style clickable types in iOS and Safari.
+ * 2. Change font properties to `inherit` in Safari.
+ */
+::-webkit-file-upload-button {
+  -webkit-appearance: button; /* 1 */
+  font: inherit; /* 2 */
+}
+
+/* Interactive
+   ========================================================================== */
+/*
+ * Add the correct display in Edge, IE 10+, and Firefox.
+ */
+details {
+  display: block;
+}
+
+/*
+ * Add the correct display in all browsers.
+ */
+summary {
+  display: list-item;
+}
+
+/* Misc
+   ========================================================================== */
+/**
+ * Add the correct display in IE 10+.
+ */
+template {
+  display: none;
+}
+
+/**
+ * Add the correct display in IE 10.
+ */
+[hidden] {
+  display: none;
+}
+
+html {
+  box-sizing: border-box;
+}
+
+*, *:before, *:after {
+  box-sizing: inherit;
+}
+
+body {
+  background-color: var(--md-sys-color-background);
+  color: var(--md-sys-color-on-background);
+}
+
+button,
+input,
+optgroup,
+select,
+textarea {
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen-Sans, Ubuntu, Cantarell, "Helvetica Neue", sans-serif;
+}
+
+a {
+  color: #039be5;
+  text-decoration: none;
+  -webkit-tap-highlight-color: transparent;
+}
+
+.valign-wrapper {
+  display: flex;
+  align-items: center;
+}
+
+.clearfix {
+  clear: both;
+}
+
+.z-depth-0, .btn:focus.tonal, .btn-small:focus.tonal, .btn-large:focus.tonal, .btn:focus.filled, .btn-small:focus.filled, .btn-large:focus.filled, .btn.disabled, .btn-floating.disabled, .btn-large.disabled, .btn-small.disabled, .btn-flat.disabled,
+.btn:disabled, .btn-floating:disabled, .btn-large:disabled, .btn-small:disabled, .btn-flat:disabled,
+.btn[disabled], .btn-floating[disabled], .btn-large[disabled], .btn-small[disabled], .btn-flat[disabled], .btn.text, .text.btn-small, .text.btn-large, .btn-flat {
+  box-shadow: none !important;
+}
+
+/* 2dp elevation modified*/
+.z-depth-1, .sidenav, .collapsible, .dropdown-content, .btn-floating, .btn:focus.elevated, .btn-small:focus.elevated, .btn-large:focus.elevated, .btn.tonal:hover, .tonal.btn-small:hover, .tonal.btn-large:hover, .btn.filled:hover, .filled.btn-small:hover, .filled.btn-large:hover, .btn.elevated, .elevated.btn-small, .elevated.btn-large, .card, .card-panel, nav {
+  box-shadow: 0 2px 2px 0 rgba(0, 0, 0, 0.14), 0 3px 1px -2px rgba(0, 0, 0, 0.12), 0 1px 5px 0 rgba(0, 0, 0, 0.2);
+}
+
+.z-depth-1-half, .btn-floating:focus, .btn-floating:hover {
+  box-shadow: 0 3px 3px 0 rgba(0, 0, 0, 0.14), 0 1px 7px 0 rgba(0, 0, 0, 0.12), 0 3px 1px -1px rgba(0, 0, 0, 0.2);
+}
+
+/* 6dp elevation modified*/
+.z-depth-2, .btn.elevated:hover, .elevated.btn-small:hover, .elevated.btn-large:hover {
+  box-shadow: 0 4px 5px 0 rgba(0, 0, 0, 0.14), 0 1px 10px 0 rgba(0, 0, 0, 0.12), 0 2px 4px -1px rgba(0, 0, 0, 0.3);
+}
+
+/* 12dp elevation modified*/
+.z-depth-3, .toast {
+  box-shadow: 0 8px 17px 2px rgba(0, 0, 0, 0.14), 0 3px 14px 2px rgba(0, 0, 0, 0.12), 0 5px 5px -3px rgba(0, 0, 0, 0.2);
+}
+
+/* 16dp elevation */
+.z-depth-4 {
+  box-shadow: 0 16px 24px 2px rgba(0, 0, 0, 0.14), 0 6px 30px 5px rgba(0, 0, 0, 0.12), 0 8px 10px -7px rgba(0, 0, 0, 0.2);
+}
+
+/* 24dp elevation */
+.z-depth-5, .modal {
+  box-shadow: 0 24px 38px 3px rgba(0, 0, 0, 0.14), 0 9px 46px 8px rgba(0, 0, 0, 0.12), 0 11px 15px -7px rgba(0, 0, 0, 0.2);
+}
+
+.hoverable {
+  transition: box-shadow 0.25s;
+}
+.hoverable:hover {
+  box-shadow: 0 8px 17px 0 rgba(0, 0, 0, 0.2), 0 6px 20px 0 rgba(0, 0, 0, 0.19);
+}
+
+.divider {
+  height: 1px;
+  overflow: hidden;
+  background-color: var(--md-sys-color-outline-variant);
+}
+
+blockquote {
+  margin: 20px 0;
+  padding-left: 1.5rem;
+  border-left: 5px solid var(--md-sys-color-primary);
+}
+
+i {
+  line-height: inherit;
+}
+i.left {
+  float: left;
+  margin-left: -8px;
+}
+i.right {
+  float: right;
+}
+i.tiny {
+  font-size: 1rem;
+}
+i.small {
+  font-size: 2rem;
+}
+i.medium {
+  font-size: 4rem;
+}
+i.large {
+  font-size: 6rem;
+}
+
+html.noscroll {
+  position: fixed;
+  overflow-y: scroll;
+  width: 100%;
+}
+
+img.responsive-img,
+video.responsive-video {
+  max-width: 100%;
+  height: auto;
+}
+
+.pagination li {
+  display: inline-block;
+  border-radius: 2px;
+  text-align: center;
+  vertical-align: top;
+  height: 30px;
+}
+.pagination li a {
+  color: var(--md-sys-color-on-surface-variant);
+  display: inline-block;
+  font-size: 1.2rem;
+  padding: 0 10px;
+  line-height: 30px;
+}
+.pagination li:hover:not(.disabled) {
+  background-color: rgba(var(--md-sys-color-primary-numeric), 0.06);
+}
+.pagination li.active a {
+  color: var(--md-sys-color-on-primary);
+}
+.pagination li.active, .pagination li.active:hover {
+  background-color: var(--md-sys-color-primary);
+}
+.pagination li.disabled a {
+  cursor: default;
+  color: var(--md-sys-color-on-surface);
+}
+.pagination li i {
+  font-size: 2rem;
+}
+.pagination li.pages ul li {
+  display: inline-block;
+  float: none;
+}
+
+@media only screen and (max-width : 992.99px) {
+  .pagination {
+    width: 100%;
+  }
+  .pagination li.prev,
+  .pagination li.next {
+    width: 10%;
+  }
+  .pagination li.pages {
+    width: 80%;
+    overflow: hidden;
+    white-space: nowrap;
+  }
+}
+.breadcrumb {
+  display: inline-block;
+  font-size: 18px;
+  color: var(--font-on-primary-color-medium);
+}
+.breadcrumb i,
+.breadcrumb [class^=mdi-], .breadcrumb [class*=mdi-],
+.breadcrumb i.material-icons, .breadcrumb i.material-symbols-outlined,
+.breadcrumb i.material-symbols-rounded, .breadcrumb i.material-symbols-sharp {
+  display: block;
+  float: left;
+  font-size: 24px;
+}
+.breadcrumb:before {
+  content: "\e5cc";
+  color: var(--font-on-primary-color-medium);
+  vertical-align: top;
+  display: inline-block;
+  font-family: "Material Symbols Outlined", "Material Symbols Rounded", "Material Symbols Sharp", "Material Icons";
+  font-weight: normal;
+  font-style: normal;
+  font-size: 25px;
+  margin: 0 10px 0 8px;
+  -webkit-font-smoothing: antialiased;
+  float: left;
+}
+.breadcrumb:first-child:before {
+  display: none;
+}
+.breadcrumb:last-child {
+  color: var(--md-sys-color-on-primary);
+}
+
+.parallax-container {
+  position: relative;
+  overflow: hidden;
+  height: 500px;
+}
+.parallax-container .parallax {
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  z-index: -1;
+}
+.parallax-container .parallax img {
+  opacity: 0;
+  position: absolute;
+  left: 50%;
+  bottom: 0;
+  min-width: 100%;
+  min-height: 100%;
+  transform: translate3d(0, 0, 0);
+  transform: translateX(-50%);
+}
+
+.pin-top, .pin-bottom {
+  position: relative;
+}
+
+.pinned {
+  position: fixed !important;
+}
+
+/*********************
+  Transition Classes
+**********************/
+ul.staggered-list li {
+  opacity: 0;
+}
+
+.fade-in {
+  opacity: 0;
+  transform-origin: 0 50%;
+}
+
+/*********************
+  Media Query Classes
+**********************/
+@media only screen and (max-width : 600.99px) {
+  .hide-on-small-only, .hide-on-small-and-down {
+    display: none !important;
+  }
+}
+
+@media only screen and (max-width : 992.99px) {
+  .hide-on-med-and-down {
+    display: none !important;
+  }
+}
+
+@media only screen and (min-width : 601px) {
+  .hide-on-med-and-up {
+    display: none !important;
+  }
+}
+
+@media only screen and (min-width: 601px) and (max-width: 992.99px) {
+  .hide-on-med-only {
+    display: none !important;
+  }
+}
+
+@media only screen and (min-width : 993px) {
+  .hide-on-large-only {
+    display: none !important;
+  }
+}
+
+@media only screen and (min-width : 1201px) {
+  .hide-on-extra-large-only {
+    display: none !important;
+  }
+}
+
+@media only screen and (min-width : 1201px) {
+  .show-on-extra-large {
+    display: block !important;
+  }
+}
+
+@media only screen and (min-width : 993px) {
+  .show-on-large {
+    display: block !important;
+  }
+}
+
+@media only screen and (min-width: 601px) and (max-width: 992.99px) {
+  .show-on-medium {
+    display: block !important;
+  }
+}
+
+@media only screen and (max-width : 600.99px) {
+  .show-on-small {
+    display: block !important;
+  }
+}
+
+@media only screen and (min-width : 601px) {
+  .show-on-medium-and-up {
+    display: block !important;
+  }
+}
+
+@media only screen and (max-width : 992.99px) {
+  .show-on-medium-and-down {
+    display: block !important;
+  }
+}
+
+@media only screen and (max-width : 600.99px) {
+  .center-on-small-only {
+    text-align: center;
+  }
+}
+
+.page-footer {
+  margin-top: 5rem;
+  padding-top: 3rem;
+  border-top: 1px dashed var(--md-sys-color-outline-variant);
+}
+.page-footer p {
+  color: var(--md-sys-color-outline-light);
+}
+.page-footer a {
+  color: var(--md-sys-color-primary);
+}
+.page-footer .footer-copyright,
+.page-footer .footer-copyright a {
+  overflow: hidden;
+  min-height: 50px;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 10px 0px;
+}
+
+.page-footer ul {
+  padding-left: 0;
+  list-style-type: none;
+}
+
+table, th, td {
+  border: none;
+}
+
+table {
+  width: 100%;
+  display: table;
+  border-collapse: collapse;
+  border-spacing: 0;
+}
+table.striped tr {
+  border-bottom: none;
+}
+table.striped tbody > tr:nth-child(odd) {
+  background-color: rgba(0, 0, 0, 0.08);
+}
+table.highlight > tbody > tr {
+  transition: background-color 0.25s ease;
+}
+table.highlight > tbody > tr:hover {
+  background-color: rgba(0, 0, 0, 0.04);
+}
+table thead {
+  color: var(--md-sys-color-on-surface-variant);
+}
+table.centered thead tr th, table.centered tbody tr td {
+  text-align: center;
+}
+
+tr {
+  border-bottom: 1px solid var(--md-sys-color-outline-variant);
+}
+
+td, th {
+  padding: 15px 5px;
+  display: table-cell;
+  text-align: left;
+  vertical-align: middle;
+  border-radius: 0;
+}
+
+@media only screen and (max-width : 992.99px) {
+  table.responsive-table {
+    width: 100%;
+    border-collapse: collapse;
+    border-spacing: 0;
+    display: block;
+    position: relative;
+    /* sort out borders */
+  }
+  table.responsive-table td:empty:before {
+    content: " ";
+  }
+  table.responsive-table th,
+  table.responsive-table td {
+    margin: 0;
+    vertical-align: top;
+  }
+  table.responsive-table th {
+    text-align: left;
+  }
+  table.responsive-table thead {
+    display: block;
+    float: left;
+  }
+  table.responsive-table thead tr {
+    display: block;
+    padding: 0 10px 0 0;
+  }
+  table.responsive-table thead tr th::before {
+    content: " ";
+  }
+  table.responsive-table tbody {
+    display: block;
+    width: auto;
+    position: relative;
+    overflow-x: auto;
+    white-space: nowrap;
+  }
+  table.responsive-table tbody tr {
+    display: inline-block;
+    vertical-align: top;
+  }
+  table.responsive-table th {
+    display: block;
+    text-align: right;
+  }
+  table.responsive-table td {
+    display: block;
+    min-height: 1.25em;
+    text-align: left;
+  }
+  table.responsive-table tr {
+    border-bottom: none;
+    padding: 0 10px;
+  }
+  table.responsive-table thead {
+    border: 0;
+    border-right: 1px solid var(--md-sys-color-outline-variant);
+  }
+}
+.video-container {
+  position: relative;
+  padding-bottom: 56.25%;
+  height: 0;
+  overflow: hidden;
+}
+.video-container iframe, .video-container object, .video-container embed {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+}
+
+/*******************
+  Utility Classes
+*******************/
+.hide {
+  display: none !important;
+}
+
+.left-align {
+  text-align: left;
+}
+
+.right-align {
+  text-align: right;
+}
+
+.center, .center-align {
+  text-align: center;
+}
+
+.left {
+  float: left !important;
+}
+
+.right {
+  float: right !important;
+}
+
+.no-select, input[type=range],
+input[type=range] + .thumb {
+  user-select: none;
+}
+
+.circle {
+  border-radius: 50%;
+}
+
+.center-block {
+  display: block;
+  margin-left: auto;
+  margin-right: auto;
+}
+
+.truncate {
+  display: block;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.no-padding {
+  padding: 0 !important;
+}
+
+/**************************
+  Utility Spacing Classes
+**************************/
+.m-0 {
+  margin: 0 !important;
+}
+
+.mt-0 {
+  margin-top: 0 !important;
+}
+
+.mr-0 {
+  margin-right: 0 !important;
+}
+
+.mb-0 {
+  margin-bottom: 0 !important;
+}
+
+.ml-0 {
+  margin-left: 0 !important;
+}
+
+.mx-0 {
+  margin-left: 0 !important;
+  margin-right: 0 !important;
+}
+
+.my-0 {
+  margin-top: 0 !important;
+  margin-bottom: 0 !important;
+}
+
+.m-1 {
+  margin: 0.25rem !important;
+}
+
+.mt-1 {
+  margin-top: 0.25rem !important;
+}
+
+.mr-1 {
+  margin-right: 0.25rem !important;
+}
+
+.mb-1 {
+  margin-bottom: 0.25rem !important;
+}
+
+.ml-1 {
+  margin-left: 0.25rem !important;
+}
+
+.mx-1 {
+  margin-left: 0.25rem !important;
+  margin-right: 0.25rem !important;
+}
+
+.my-1 {
+  margin-top: 0.25rem !important;
+  margin-bottom: 0.25rem !important;
+}
+
+.m-2 {
+  margin: 0.5rem !important;
+}
+
+.mt-2 {
+  margin-top: 0.5rem !important;
+}
+
+.mr-2 {
+  margin-right: 0.5rem !important;
+}
+
+.mb-2 {
+  margin-bottom: 0.5rem !important;
+}
+
+.ml-2 {
+  margin-left: 0.5rem !important;
+}
+
+.mx-2 {
+  margin-left: 0.5rem !important;
+  margin-right: 0.5rem !important;
+}
+
+.my-2 {
+  margin-top: 0.5rem !important;
+  margin-bottom: 0.5rem !important;
+}
+
+.m-3 {
+  margin: 0.75rem !important;
+}
+
+.mt-3 {
+  margin-top: 0.75rem !important;
+}
+
+.mr-3 {
+  margin-right: 0.75rem !important;
+}
+
+.mb-3 {
+  margin-bottom: 0.75rem !important;
+}
+
+.ml-3 {
+  margin-left: 0.75rem !important;
+}
+
+.mx-3 {
+  margin-left: 0.75rem !important;
+  margin-right: 0.75rem !important;
+}
+
+.my-3 {
+  margin-top: 0.75rem !important;
+  margin-bottom: 0.75rem !important;
+}
+
+.m-4 {
+  margin: 1rem !important;
+}
+
+.mt-4 {
+  margin-top: 1rem !important;
+}
+
+.mr-4 {
+  margin-right: 1rem !important;
+}
+
+.mb-4 {
+  margin-bottom: 1rem !important;
+}
+
+.ml-4 {
+  margin-left: 1rem !important;
+}
+
+.mx-4 {
+  margin-left: 1rem !important;
+  margin-right: 1rem !important;
+}
+
+.my-4 {
+  margin-top: 1rem !important;
+  margin-bottom: 1rem !important;
+}
+
+.m-5 {
+  margin: 1.5rem !important;
+}
+
+.mt-5 {
+  margin-top: 1.5rem !important;
+}
+
+.mr-5 {
+  margin-right: 1.5rem !important;
+}
+
+.mb-5 {
+  margin-bottom: 1.5rem !important;
+}
+
+.ml-5 {
+  margin-left: 1.5rem !important;
+}
+
+.mx-5 {
+  margin-left: 1.5rem !important;
+  margin-right: 1.5rem !important;
+}
+
+.my-5 {
+  margin-top: 1.5rem !important;
+  margin-bottom: 1.5rem !important;
+}
+
+.m-6 {
+  margin: 3rem !important;
+}
+
+.mt-6 {
+  margin-top: 3rem !important;
+}
+
+.mr-6 {
+  margin-right: 3rem !important;
+}
+
+.mb-6 {
+  margin-bottom: 3rem !important;
+}
+
+.ml-6 {
+  margin-left: 3rem !important;
+}
+
+.mx-6 {
+  margin-left: 3rem !important;
+  margin-right: 3rem !important;
+}
+
+.my-6 {
+  margin-top: 3rem !important;
+  margin-bottom: 3rem !important;
+}
+
+.m-auto {
+  margin: auto !important;
+}
+
+.mt-auto {
+  margin-top: auto !important;
+}
+
+.mr-auto {
+  margin-right: auto !important;
+}
+
+.mb-auto {
+  margin-bottom: auto !important;
+}
+
+.ml-auto {
+  margin-left: auto !important;
+}
+
+.mx-auto {
+  margin-left: auto !important;
+  margin-right: auto !important;
+}
+
+.my-auto {
+  margin-top: auto !important;
+  margin-bottom: auto !important;
+}
+
+.p-0 {
+  padding: 0 !important;
+}
+
+.pt-0 {
+  padding-top: 0 !important;
+}
+
+.pr-0 {
+  padding-right: 0 !important;
+}
+
+.pb-0 {
+  padding-bottom: 0 !important;
+}
+
+.pl-0 {
+  padding-left: 0 !important;
+}
+
+.px-0 {
+  padding-left: 0 !important;
+  padding-right: 0 !important;
+}
+
+.py-0 {
+  padding-top: 0 !important;
+  padding-bottom: 0 !important;
+}
+
+.p-1 {
+  padding: 0.25rem !important;
+}
+
+.pt-1 {
+  padding-top: 0.25rem !important;
+}
+
+.pr-1 {
+  padding-right: 0.25rem !important;
+}
+
+.pb-1 {
+  padding-bottom: 0.25rem !important;
+}
+
+.pl-1 {
+  padding-left: 0.25rem !important;
+}
+
+.px-1 {
+  padding-left: 0.25rem !important;
+  padding-right: 0.25rem !important;
+}
+
+.py-1 {
+  padding-top: 0.25rem !important;
+  padding-bottom: 0.25rem !important;
+}
+
+.p-2 {
+  padding: 0.5rem !important;
+}
+
+.pt-2 {
+  padding-top: 0.5rem !important;
+}
+
+.pr-2 {
+  padding-right: 0.5rem !important;
+}
+
+.pb-2 {
+  padding-bottom: 0.5rem !important;
+}
+
+.pl-2 {
+  padding-left: 0.5rem !important;
+}
+
+.px-2 {
+  padding-left: 0.5rem !important;
+  padding-right: 0.5rem !important;
+}
+
+.py-2 {
+  padding-top: 0.5rem !important;
+  padding-bottom: 0.5rem !important;
+}
+
+.p-3 {
+  padding: 0.75rem !important;
+}
+
+.pt-3 {
+  padding-top: 0.75rem !important;
+}
+
+.pr-3 {
+  padding-right: 0.75rem !important;
+}
+
+.pb-3 {
+  padding-bottom: 0.75rem !important;
+}
+
+.pl-3 {
+  padding-left: 0.75rem !important;
+}
+
+.px-3 {
+  padding-left: 0.75rem !important;
+  padding-right: 0.75rem !important;
+}
+
+.py-3 {
+  padding-top: 0.75rem !important;
+  padding-bottom: 0.75rem !important;
+}
+
+.p-4 {
+  padding: 1rem !important;
+}
+
+.pt-4 {
+  padding-top: 1rem !important;
+}
+
+.pr-4 {
+  padding-right: 1rem !important;
+}
+
+.pb-4 {
+  padding-bottom: 1rem !important;
+}
+
+.pl-4 {
+  padding-left: 1rem !important;
+}
+
+.px-4 {
+  padding-left: 1rem !important;
+  padding-right: 1rem !important;
+}
+
+.py-4 {
+  padding-top: 1rem !important;
+  padding-bottom: 1rem !important;
+}
+
+.p-5 {
+  padding: 1.5rem !important;
+}
+
+.pt-5 {
+  padding-top: 1.5rem !important;
+}
+
+.pr-5 {
+  padding-right: 1.5rem !important;
+}
+
+.pb-5 {
+  padding-bottom: 1.5rem !important;
+}
+
+.pl-5 {
+  padding-left: 1.5rem !important;
+}
+
+.px-5 {
+  padding-left: 1.5rem !important;
+  padding-right: 1.5rem !important;
+}
+
+.py-5 {
+  padding-top: 1.5rem !important;
+  padding-bottom: 1.5rem !important;
+}
+
+.p-6 {
+  padding: 3rem !important;
+}
+
+.pt-6 {
+  padding-top: 3rem !important;
+}
+
+.pr-6 {
+  padding-right: 3rem !important;
+}
+
+.pb-6 {
+  padding-bottom: 3rem !important;
+}
+
+.pl-6 {
+  padding-left: 3rem !important;
+}
+
+.px-6 {
+  padding-left: 3rem !important;
+  padding-right: 3rem !important;
+}
+
+.py-6 {
+  padding-top: 3rem !important;
+  padding-bottom: 3rem !important;
+}
+
+.p-auto {
+  padding: auto !important;
+}
+
+.pt-auto {
+  padding-top: auto !important;
+}
+
+.pr-auto {
+  padding-right: auto !important;
+}
+
+.pb-auto {
+  padding-bottom: auto !important;
+}
+
+.pl-auto {
+  padding-left: auto !important;
+}
+
+.px-auto {
+  padding-left: auto !important;
+  padding-right: auto !important;
+}
+
+.py-auto {
+  padding-top: auto !important;
+  padding-bottom: auto !important;
+}
+
+.collection {
+  padding-left: 0;
+  list-style-type: none;
+  margin: 0.5rem 0 1rem 0;
+  border: 1px solid var(--md-sys-color-outline-variant);
+  border-radius: 2px;
+  overflow: hidden;
+  position: relative;
+}
+.collection .collection-item {
+  background-color: transparent;
+  line-height: 1.5rem;
+  padding: 10px 20px;
+  margin: 0;
+  border-bottom: 1px solid var(--md-sys-color-outline-variant);
+}
+.collection .collection-item.avatar {
+  min-height: 84px;
+  padding-left: 72px;
+  position: relative;
+}
+.collection .collection-item.avatar:not(.circle-clipper) > .circle,
+.collection .collection-item.avatar :not(.circle-clipper) > .circle {
+  position: absolute;
+  width: 42px;
+  height: 42px;
+  overflow: hidden;
+  left: 15px;
+  display: inline-block;
+  vertical-align: middle;
+}
+.collection .collection-item.avatar i.circle {
+  font-size: 18px;
+  line-height: 42px;
+  color: #fff;
+  background-color: var(--md-sys-color-shadow-light);
+  text-align: center;
+}
+.collection .collection-item.avatar .title {
+  font-size: 16px;
+}
+.collection .collection-item.avatar p {
+  margin: 0;
+}
+.collection .collection-item.avatar .secondary-content {
+  position: absolute;
+  top: 16px;
+  right: 16px;
+}
+.collection .collection-item:last-child {
+  border-bottom: none;
+}
+.collection .collection-item.active {
+  background-color: var(--md-sys-color-primary);
+  color: var(--md-sys-color-on-primary);
+}
+.collection .collection-item.active .secondary-content {
+  color: var(--md-sys-color-on-primary);
+}
+.collection a.collection-item {
+  display: block;
+  transition: 0.25s;
+  color: var(--md-sys-color-primary);
+}
+.collection a.collection-item:not(.active):hover {
+  background-color: rgba(0, 0, 0, 0.04);
+}
+.collection.with-header .collection-header {
+  background-color: transparent;
+  border-bottom: 1px solid var(--md-sys-color-outline-variant);
+  padding: 10px 20px;
+}
+.collection.with-header .collection-item {
+  padding-left: 30px;
+}
+.collection.with-header .collection-item.avatar {
+  padding-left: 72px;
+}
+
+.secondary-content {
+  float: right;
+  color: var(--md-sys-color-primary);
+}
+
+.collapsible .collection {
+  margin: 0;
+  border: none;
+}
+
+:root {
+  --bagde-height: 22px;
+}
+
+span.badge {
+  min-width: 3rem;
+  padding: 0 6px;
+  margin-left: 14px;
+  text-align: center;
+  font-size: 1rem;
+  line-height: var(--bagde-height);
+  height: var(--bagde-height);
+  color: var(--md-sys-color-on-surface-variant);
+  float: right;
+  box-sizing: border-box;
+}
+span.badge.new {
+  font-weight: 300;
+  font-size: 0.8rem;
+  color: var(--md-sys-color-on-primary);
+  background-color: var(--md-sys-color-primary);
+  border-radius: 2px;
+}
+span.badge.new:after {
+  content: " new";
+}
+span.badge[data-badge-caption]::after {
+  content: " " attr(data-badge-caption);
+}
+
+.active span.badge {
+  color: var(--md-sys-color-on-primary);
+}
+
+nav ul a span.badge {
+  display: inline-block;
+  float: none;
+  margin-left: 4px;
+  line-height: var(--bagde-height);
+  height: var(--bagde-height);
+  -webkit-font-smoothing: auto;
+}
+
+.collection-item span.badge {
+  margin-top: calc(0.75rem - var(--bagde-height) * 0.5);
+}
+
+.collapsible span.badge {
+  margin-left: auto;
+}
+
+.collapsible .active span.badge:not(.new) {
+  color: var(--md-sys-color-on-surface-variant);
+}
+
+.sidenav span.badge {
+  margin-top: calc(var(--sidenav-line-height) * 0.5 - 11px);
+}
+
+table span.badge {
+  display: inline-block;
+  float: none;
+  margin-left: auto;
+}
+
+/* This is needed for some mobile phones to display the Google Icon font properly */
+.material-icons, .material-symbols-outlined,
+.material-symbols-rounded, .material-symbols-sharp {
+  text-rendering: optimizeLegibility;
+  font-feature-settings: "liga";
+}
+
+.container {
+  margin: 0 auto;
+  max-width: 1280px;
+  width: 90%;
+}
+
+@media only screen and (min-width : 601px) {
+  .container {
+    width: 85%;
+  }
+}
+@media only screen and (min-width : 993px) {
+  .container {
+    width: 70%;
+  }
+}
+.section {
+  padding: 1rem 0;
+}
+
+body {
+  --gap-size: 1.5rem;
+}
+
+.row {
+  display: grid;
+  grid-template-columns: repeat(12, 1fr);
+  gap: var(--gap-size);
+}
+.row .s1 {
+  grid-column: auto/span 1;
+}
+.row .s2 {
+  grid-column: auto/span 2;
+}
+.row .s3 {
+  grid-column: auto/span 3;
+}
+.row .s4 {
+  grid-column: auto/span 4;
+}
+.row .s5 {
+  grid-column: auto/span 5;
+}
+.row .s6 {
+  grid-column: auto/span 6;
+}
+.row .s7 {
+  grid-column: auto/span 7;
+}
+.row .s8 {
+  grid-column: auto/span 8;
+}
+.row .s9 {
+  grid-column: auto/span 9;
+}
+.row .s10 {
+  grid-column: auto/span 10;
+}
+.row .s11 {
+  grid-column: auto/span 11;
+}
+.row .s12 {
+  grid-column: auto/span 12;
+}
+.row .offset-s1 {
+  grid-column-start: 3;
+}
+.row .offset-s2 {
+  grid-column-start: 2;
+}
+.row .offset-s3 {
+  grid-column-start: 4;
+}
+.row .offset-s4 {
+  grid-column-start: 5;
+}
+.row .offset-s5 {
+  grid-column-start: 6;
+}
+.row .offset-s6 {
+  grid-column-start: 7;
+}
+.row .offset-s7 {
+  grid-column-start: 8;
+}
+.row .offset-s8 {
+  grid-column-start: 9;
+}
+.row .offset-s9 {
+  grid-column-start: 10;
+}
+.row .offset-s10 {
+  grid-column-start: 11;
+}
+.row .offset-s11 {
+  grid-column-start: 12;
+}
+@media only screen and (min-width : 601px) {
+  .row .m1 {
+    grid-column: auto/span 1;
+  }
+  .row .m2 {
+    grid-column: auto/span 2;
+  }
+  .row .m3 {
+    grid-column: auto/span 3;
+  }
+  .row .m4 {
+    grid-column: auto/span 4;
+  }
+  .row .m5 {
+    grid-column: auto/span 5;
+  }
+  .row .m6 {
+    grid-column: auto/span 6;
+  }
+  .row .m7 {
+    grid-column: auto/span 7;
+  }
+  .row .m8 {
+    grid-column: auto/span 8;
+  }
+  .row .m9 {
+    grid-column: auto/span 9;
+  }
+  .row .m10 {
+    grid-column: auto/span 10;
+  }
+  .row .m11 {
+    grid-column: auto/span 11;
+  }
+  .row .m12 {
+    grid-column: auto/span 12;
+  }
+  .row .offset-m1 {
+    grid-column-start: 2;
+  }
+  .row .offset-m2 {
+    grid-column-start: 3;
+  }
+  .row .offset-m3 {
+    grid-column-start: 4;
+  }
+  .row .offset-m4 {
+    grid-column-start: 5;
+  }
+  .row .offset-m5 {
+    grid-column-start: 6;
+  }
+  .row .offset-m6 {
+    grid-column-start: 7;
+  }
+  .row .offset-m7 {
+    grid-column-start: 8;
+  }
+  .row .offset-m8 {
+    grid-column-start: 9;
+  }
+  .row .offset-m9 {
+    grid-column-start: 10;
+  }
+  .row .offset-m10 {
+    grid-column-start: 11;
+  }
+  .row .offset-m11 {
+    grid-column-start: 12;
+  }
+}
+@media only screen and (min-width : 993px) {
+  .row .l1 {
+    grid-column: auto/span 1;
+  }
+  .row .l2 {
+    grid-column: auto/span 2;
+  }
+  .row .l3 {
+    grid-column: auto/span 3;
+  }
+  .row .l4 {
+    grid-column: auto/span 4;
+  }
+  .row .l5 {
+    grid-column: auto/span 5;
+  }
+  .row .l6 {
+    grid-column: auto/span 6;
+  }
+  .row .l7 {
+    grid-column: auto/span 7;
+  }
+  .row .l8 {
+    grid-column: auto/span 8;
+  }
+  .row .l9 {
+    grid-column: auto/span 9;
+  }
+  .row .l10 {
+    grid-column: auto/span 10;
+  }
+  .row .l11 {
+    grid-column: auto/span 11;
+  }
+  .row .l12 {
+    grid-column: auto/span 12;
+  }
+  .row .offset-l1 {
+    grid-column-start: 2;
+  }
+  .row .offset-l2 {
+    grid-column-start: 3;
+  }
+  .row .offset-l3 {
+    grid-column-start: 4;
+  }
+  .row .offset-l4 {
+    grid-column-start: 5;
+  }
+  .row .offset-l5 {
+    grid-column-start: 6;
+  }
+  .row .offset-l6 {
+    grid-column-start: 7;
+  }
+  .row .offset-l7 {
+    grid-column-start: 8;
+  }
+  .row .offset-l8 {
+    grid-column-start: 9;
+  }
+  .row .offset-l9 {
+    grid-column-start: 10;
+  }
+  .row .offset-l10 {
+    grid-column-start: 11;
+  }
+  .row .offset-l11 {
+    grid-column-start: 12;
+  }
+}
+@media only screen and (min-width : 1201px) {
+  .row .xl1 {
+    grid-column: auto/span 1;
+  }
+  .row .xl2 {
+    grid-column: auto/span 2;
+  }
+  .row .xl3 {
+    grid-column: auto/span 3;
+  }
+  .row .xl4 {
+    grid-column: auto/span 4;
+  }
+  .row .xl5 {
+    grid-column: auto/span 5;
+  }
+  .row .xl6 {
+    grid-column: auto/span 6;
+  }
+  .row .xl7 {
+    grid-column: auto/span 7;
+  }
+  .row .xl8 {
+    grid-column: auto/span 8;
+  }
+  .row .xl9 {
+    grid-column: auto/span 9;
+  }
+  .row .xl10 {
+    grid-column: auto/span 10;
+  }
+  .row .xl11 {
+    grid-column: auto/span 11;
+  }
+  .row .xl12 {
+    grid-column: auto/span 12;
+  }
+  .row .offset-xl1 {
+    grid-column-start: 2;
+  }
+  .row .offset-xl2 {
+    grid-column-start: 3;
+  }
+  .row .offset-xl3 {
+    grid-column-start: 4;
+  }
+  .row .offset-xl4 {
+    grid-column-start: 5;
+  }
+  .row .offset-xl5 {
+    grid-column-start: 6;
+  }
+  .row .offset-xl6 {
+    grid-column-start: 7;
+  }
+  .row .offset-xl7 {
+    grid-column-start: 8;
+  }
+  .row .offset-xl8 {
+    grid-column-start: 9;
+  }
+  .row .offset-xl9 {
+    grid-column-start: 10;
+  }
+  .row .offset-xl10 {
+    grid-column-start: 11;
+  }
+  .row .offset-xl11 {
+    grid-column-start: 12;
+  }
+}
+
+.g-0 {
+  gap: 0;
+}
+
+.g-1 {
+  gap: calc(0.25 * var(--gap-size));
+}
+
+.g-2 {
+  gap: calc(0.5 * var(--gap-size));
+}
+
+.g-3 {
+  gap: calc(1 * var(--gap-size));
+}
+
+.g-4 {
+  gap: calc(1.5 * var(--gap-size));
+}
+
+.g-5 {
+  gap: calc(3 * var(--gap-size));
+}
+
+:root {
+  --navbar-height: 64px;
+  --navbar-height-mobile: 56px;
+}
+
+nav {
+  color: var(--md-sys-color-on-primary);
+  background-color: var(--md-sys-color-secondary-container);
+  width: 100%;
+  height: var(--navbar-height-mobile);
+  line-height: var(--navbar-height-mobile);
+}
+nav.nav-extended {
+  height: auto;
+}
+nav.nav-extended .nav-wrapper {
+  min-height: var(--navbar-height-mobile);
+  height: auto;
+}
+nav.nav-extended .nav-content {
+  position: relative;
+  line-height: normal;
+}
+nav a {
+  color: var(--md-sys-color-on-primary);
+}
+nav i,
+nav [class^=mdi-], nav [class*=mdi-],
+nav i.material-icons, nav i.material-symbols-outlined,
+nav i.material-symbols-rounded, nav i.material-symbols-sharp {
+  display: block;
+  font-size: 24px;
+  height: var(--navbar-height-mobile);
+  line-height: var(--navbar-height-mobile);
+}
+nav .nav-wrapper {
+  position: relative;
+  height: 100%;
+}
+@media only screen and (min-width : 993px) {
+  nav a.sidenav-trigger {
+    display: none;
+  }
+}
+nav .sidenav-trigger {
+  float: left;
+  position: relative;
+  z-index: 1;
+  height: var(--navbar-height-mobile);
+  margin: 0 18px;
+}
+nav .sidenav-trigger i {
+  height: var(--navbar-height-mobile);
+  line-height: var(--navbar-height-mobile);
+}
+nav .brand-logo {
+  position: absolute;
+  color: var(--md-sys-color-on-primary);
+  display: inline-block;
+  font-size: 2.1rem;
+  padding: 0;
+}
+nav .brand-logo.center {
+  left: 50%;
+  transform: translateX(-50%);
+}
+@media only screen and (max-width : 992.99px) {
+  nav .brand-logo {
+    left: 50%;
+    transform: translateX(-50%);
+  }
+  nav .brand-logo.left, nav .brand-logo.right {
+    padding: 0;
+    transform: none;
+  }
+  nav .brand-logo.left {
+    left: 0.5rem;
+  }
+  nav .brand-logo.right {
+    right: 0.5rem;
+    left: auto;
+  }
+}
+nav .brand-logo.right {
+  right: 0.5rem;
+  padding: 0;
+}
+nav .brand-logo i,
+nav .brand-logo [class^=mdi-], nav .brand-logo [class*=mdi-],
+nav .brand-logo i.material-icons, nav .brand-logo i.material-symbols-outlined,
+nav .brand-logo i.material-symbols-rounded, nav .brand-logo i.material-symbols-sharp {
+  float: left;
+  margin-right: 15px;
+}
+nav .nav-title {
+  display: inline-block;
+  font-size: 32px;
+  padding: 28px 0;
+}
+nav ul:not(.dropdown-content) {
+  list-style-type: none;
+  margin: 0;
+}
+nav ul:not(.dropdown-content) > li {
+  transition: background-color 0.3s;
+  float: left;
+  padding: 0;
+}
+nav ul:not(.dropdown-content) > li > a {
+  transition: background-color 0.3s;
+  font-size: 1rem;
+  color: var(--md-sys-color-on-primary);
+  display: block;
+  padding: 0 15px;
+  cursor: pointer;
+}
+nav ul:not(.dropdown-content) > li > a.active {
+  background-color: var(--md-ref-palette-primary80);
+}
+nav ul:not(.dropdown-content) > li > a:hover:not(.active) {
+  background-color: var(--md-ref-palette-primary70);
+}
+nav ul:not(.dropdown-content) > li > a.btn, nav ul:not(.dropdown-content) > li > a.btn-small, nav ul:not(.dropdown-content) > li > a.btn-large, nav ul:not(.dropdown-content) > li > a.btn-flat, nav ul:not(.dropdown-content) > li > a.btn-floating {
+  margin-top: -2px;
+  margin-left: 15px;
+  margin-right: 15px;
+  display: inline-block;
+}
+nav ul:not(.dropdown-content) > li > a.btn > .material-icons, nav ul:not(.dropdown-content) > li > a.btn-small > .material-icons, nav ul:not(.dropdown-content) > li > a.btn > .material-symbols-outlined, nav ul:not(.dropdown-content) > li > a.btn-small > .material-symbols-outlined, nav ul:not(.dropdown-content) > li > a.btn > .material-symbols-rounded, nav ul:not(.dropdown-content) > li > a.btn-small > .material-symbols-rounded, nav ul:not(.dropdown-content) > li > a.btn > .material-symbols-sharp, nav ul:not(.dropdown-content) > li > a.btn-small > .material-symbols-sharp, nav ul:not(.dropdown-content) > li > a.btn-large > .material-icons, nav ul:not(.dropdown-content) > li > a.btn-large > .material-symbols-outlined, nav ul:not(.dropdown-content) > li > a.btn-large > .material-symbols-rounded, nav ul:not(.dropdown-content) > li > a.btn-large > .material-symbols-sharp, nav ul:not(.dropdown-content) > li > a.btn-flat > .material-icons, nav ul:not(.dropdown-content) > li > a.btn-flat > .material-symbols-outlined, nav ul:not(.dropdown-content) > li > a.btn-flat > .material-symbols-rounded, nav ul:not(.dropdown-content) > li > a.btn-flat > .material-symbols-sharp, nav ul:not(.dropdown-content) > li > a.btn-floating > .material-icons, nav ul:not(.dropdown-content) > li > a.btn-floating > .material-symbols-outlined, nav ul:not(.dropdown-content) > li > a.btn-floating > .material-symbols-rounded, nav ul:not(.dropdown-content) > li > a.btn-floating > .material-symbols-sharp {
+  height: inherit;
+  line-height: inherit;
+}
+nav ul:not(.dropdown-content).left {
+  float: left;
+}
+nav form {
+  height: 100%;
+}
+nav .input-field {
+  margin: 0;
+  height: 100%;
+}
+nav .input-field input[type=search] {
+  height: 100%;
+  font-size: 1.2rem;
+  border: none;
+  padding-left: 2rem;
+  color: var(--md-sys-color-on-primary);
+}
+nav .input-field input[type=search]:focus, nav .input-field input[type=search][type=text]:valid, nav .input-field input[type=search][type=password]:valid, nav .input-field input[type=search][type=email]:valid, nav .input-field input[type=search][type=url]:valid, nav .input-field input[type=search][type=date]:valid {
+  border: none;
+  box-shadow: none;
+}
+nav .input-field label {
+  top: 0;
+  left: 0;
+}
+nav .input-field label i {
+  color: var(--font-on-primary-color-medium);
+  transition: color 0.3s;
+}
+nav .input-field label.active i {
+  color: var(--md-sys-color-on-primary);
+}
+
+.navbar-fixed {
+  position: relative;
+  height: var(--navbar-height-mobile);
+  z-index: 997;
+}
+.navbar-fixed nav {
+  position: fixed;
+  right: 0;
+}
+
+@media only screen and (min-width : 601px) {
+  nav.nav-extended .nav-wrapper {
+    min-height: var(--navbar-height-mobile);
+  }
+  nav, nav .nav-wrapper i, nav a.sidenav-trigger, nav a.sidenav-trigger i {
+    height: var(--navbar-height);
+    line-height: var(--navbar-height);
+  }
+  .navbar-fixed {
+    height: var(--navbar-height);
+  }
+}
+a {
+  text-decoration: none;
+}
+
+html {
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen-Sans, Ubuntu, Cantarell, "Helvetica Neue", sans-serif;
+  font-weight: normal;
+  color: var(--md-sys-color-on-background);
+}
+@media only screen and (min-width: 0) {
+  html {
+    font-size: 14px;
+  }
+}
+@media only screen and (min-width: 993px) {
+  html {
+    font-size: 14.5px;
+  }
+}
+@media only screen and (min-width: 1201px) {
+  html {
+    font-size: 15px;
+  }
+}
+
+h1, h2, h3, h4, h5, h6 {
+  font-weight: 400;
+  line-height: 1.3;
+}
+
+h1 a, h2 a, h3 a, h4 a, h5 a, h6 a {
+  font-weight: inherit;
+}
+
+h1 {
+  font-size: 4.2rem;
+  line-height: 110%;
+  margin: 2.8rem 0 1.68rem 0;
+}
+
+h2 {
+  font-size: 3.56rem;
+  line-height: 110%;
+  margin: 2.3733333333rem 0 1.424rem 0;
+}
+
+h3 {
+  font-size: 2.92rem;
+  line-height: 110%;
+  margin: 1.9466666667rem 0 1.168rem 0;
+}
+
+h4 {
+  font-size: 2.28rem;
+  line-height: 110%;
+  margin: 1.52rem 0 0.912rem 0;
+}
+
+h5 {
+  font-size: 1.64rem;
+  line-height: 110%;
+  margin: 1.0933333333rem 0 0.656rem 0;
+}
+
+h6 {
+  font-size: 1.15rem;
+  line-height: 110%;
+  margin: 0.7666666667rem 0 0.46rem 0;
+}
+
+em {
+  font-style: italic;
+}
+
+strong {
+  font-weight: 500;
+}
+
+small {
+  font-size: 75%;
+}
+
+.light {
+  font-weight: 300;
+}
+
+.thin {
+  font-weight: 200;
+}
+
+@media only screen and (min-width: 360px) {
+  .flow-text {
+    font-size: 1.2rem;
+  }
+}
+@media only screen and (min-width: 390px) {
+  .flow-text {
+    font-size: 1.224rem;
+  }
+}
+@media only screen and (min-width: 420px) {
+  .flow-text {
+    font-size: 1.248rem;
+  }
+}
+@media only screen and (min-width: 450px) {
+  .flow-text {
+    font-size: 1.272rem;
+  }
+}
+@media only screen and (min-width: 480px) {
+  .flow-text {
+    font-size: 1.296rem;
+  }
+}
+@media only screen and (min-width: 510px) {
+  .flow-text {
+    font-size: 1.32rem;
+  }
+}
+@media only screen and (min-width: 540px) {
+  .flow-text {
+    font-size: 1.344rem;
+  }
+}
+@media only screen and (min-width: 570px) {
+  .flow-text {
+    font-size: 1.368rem;
+  }
+}
+@media only screen and (min-width: 600px) {
+  .flow-text {
+    font-size: 1.392rem;
+  }
+}
+@media only screen and (min-width: 630px) {
+  .flow-text {
+    font-size: 1.416rem;
+  }
+}
+@media only screen and (min-width: 660px) {
+  .flow-text {
+    font-size: 1.44rem;
+  }
+}
+@media only screen and (min-width: 690px) {
+  .flow-text {
+    font-size: 1.464rem;
+  }
+}
+@media only screen and (min-width: 720px) {
+  .flow-text {
+    font-size: 1.488rem;
+  }
+}
+@media only screen and (min-width: 750px) {
+  .flow-text {
+    font-size: 1.512rem;
+  }
+}
+@media only screen and (min-width: 780px) {
+  .flow-text {
+    font-size: 1.536rem;
+  }
+}
+@media only screen and (min-width: 810px) {
+  .flow-text {
+    font-size: 1.56rem;
+  }
+}
+@media only screen and (min-width: 840px) {
+  .flow-text {
+    font-size: 1.584rem;
+  }
+}
+@media only screen and (min-width: 870px) {
+  .flow-text {
+    font-size: 1.608rem;
+  }
+}
+@media only screen and (min-width: 900px) {
+  .flow-text {
+    font-size: 1.632rem;
+  }
+}
+@media only screen and (min-width: 930px) {
+  .flow-text {
+    font-size: 1.656rem;
+  }
+}
+@media only screen and (min-width: 960px) {
+  .flow-text {
+    font-size: 1.68rem;
+  }
+}
+@media only screen and (max-width: 360px) {
+  .flow-text {
+    font-size: 1.2rem;
+  }
+}
+
+.scale-transition {
+  transition: transform 0.3s cubic-bezier(0.53, 0.01, 0.36, 1.63) !important;
+}
+.scale-transition.scale-out {
+  transform: scale(0);
+  transition: transform 0.2s !important;
+}
+.scale-transition.scale-in {
+  transform: scale(1);
+}
+
+.card-panel {
+  transition: box-shadow 0.25s;
+  padding: 24px;
+  margin: 0.5rem 0 1rem 0;
+  border-radius: 12px;
+  background-color: var(--md-sys-color-surface);
+}
+
+.card {
+  overflow: hidden;
+  position: relative;
+  background-color: var(--md-sys-color-surface);
+  transition: box-shadow 0.25s;
+  border-radius: 12px;
+}
+.card .card-title {
+  font-size: 24px;
+  font-weight: 300;
+}
+.card .card-title.activator {
+  cursor: pointer;
+}
+.card.small, .card.medium, .card.large {
+  position: relative;
+}
+.card.small .card-image, .card.medium .card-image, .card.large .card-image {
+  max-height: 60%;
+  overflow: hidden;
+}
+.card.small .card-image + .card-content, .card.medium .card-image + .card-content, .card.large .card-image + .card-content {
+  max-height: 40%;
+}
+.card.small .card-content, .card.medium .card-content, .card.large .card-content {
+  max-height: 100%;
+  overflow: hidden;
+}
+.card.small .card-action, .card.medium .card-action, .card.large .card-action {
+  position: absolute;
+  bottom: 0;
+  left: 0;
+  right: 0;
+}
+.card.small {
+  height: 300px;
+}
+.card.medium {
+  height: 400px;
+}
+.card.large {
+  height: 500px;
+}
+.card.horizontal {
+  display: flex;
+}
+.card.horizontal.small .card-image, .card.horizontal.medium .card-image, .card.horizontal.large .card-image {
+  height: 100%;
+  max-height: none;
+  overflow: visible;
+}
+.card.horizontal.small .card-image img, .card.horizontal.medium .card-image img, .card.horizontal.large .card-image img {
+  height: 100%;
+}
+.card.horizontal .card-image {
+  max-width: 50%;
+}
+.card.horizontal .card-image img {
+  border-radius: 2px 0 0 2px;
+  max-width: 100%;
+  width: auto;
+}
+.card.horizontal .card-stacked {
+  display: flex;
+  flex-direction: column;
+  flex: 1;
+  position: relative;
+}
+.card.horizontal .card-stacked .card-content {
+  flex-grow: 1;
+}
+.card.sticky-action .card-action {
+  z-index: 2;
+}
+.card.sticky-action .card-reveal {
+  z-index: 1;
+  padding-bottom: 64px;
+}
+.card .card-image {
+  position: relative;
+}
+.card .card-image img {
+  display: block;
+  border-radius: 2px 2px 0 0;
+  position: relative;
+  left: 0;
+  right: 0;
+  top: 0;
+  bottom: 0;
+  width: 100%;
+}
+.card .card-image .card-title {
+  color: var(--md-sys-color-surface);
+  position: absolute;
+  bottom: 0;
+  left: 0;
+  max-width: 100%;
+  padding: 24px;
+}
+.card .card-content {
+  padding: 24px;
+  border-radius: 0 0 2px 2px;
+}
+.card .card-content p {
+  margin: 0;
+}
+.card .card-content .card-title {
+  display: block;
+  line-height: 32px;
+  margin-bottom: 8px;
+}
+.card .card-content .card-title i {
+  line-height: 32px;
+}
+.card .card-action {
+  border-top: 1px solid var(--md-sys-color-outline-variant);
+  position: relative;
+  background-color: inherit;
+}
+.card .card-action:last-child {
+  border-radius: 0 0 2px 2px;
+}
+.card .card-action a {
+  padding: 16px 24px;
+  display: inline-block;
+}
+.card .card-action a:not(.btn):not(.btn-small):not(.btn-large):not(.btn-large):not(.btn-floating) {
+  color: var(--md-sys-color-primary);
+  transition: color 0.3s ease;
+}
+.card .card-action a:not(.btn):not(.btn-small):not(.btn-large):not(.btn-large):not(.btn-floating):hover {
+  background-color: rgba(var(--md-sys-color-primary-numeric), 0.06);
+}
+.card .card-reveal {
+  padding: 24px;
+  position: absolute;
+  background-color: var(--md-sys-color-surface);
+  width: 100%;
+  overflow-y: auto;
+  left: 0;
+  top: 100%;
+  height: 100%;
+  z-index: 3;
+  display: none;
+}
+.card .card-reveal .card-title {
+  cursor: pointer;
+  display: block;
+}
+
+#toast-container {
+  display: block;
+  position: fixed;
+  z-index: 10000;
+}
+@media only screen and (max-width : 600.99px) {
+  #toast-container {
+    min-width: 100%;
+    bottom: 0%;
+  }
+}
+@media only screen and (min-width : 601px) and (max-width : 992.99px) {
+  #toast-container {
+    left: 5%;
+    bottom: 7%;
+    max-width: 90%;
+  }
+}
+@media only screen and (min-width : 993px) {
+  #toast-container {
+    top: 10%;
+    right: 7%;
+    max-width: 86%;
+  }
+}
+
+.toast {
+  border-radius: 4px;
+  top: 35px;
+  width: auto;
+  margin-top: 10px;
+  position: relative;
+  max-width: 100%;
+  height: auto;
+  min-height: 48px;
+  padding-left: 16px;
+  padding-right: 12px;
+  font-size: 14px;
+  font-weight: 500;
+  line-height: 20px;
+  color: var(--md-sys-color-inverse-on-surface);
+  background-color: var(--md-sys-color-inverse-surface);
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  cursor: default;
+}
+.toast .toast-action {
+  color: var(--md-sys-color-inverse-primary);
+  font-weight: 500;
+  margin-right: -25px;
+  margin-left: 3rem;
+}
+.toast.rounded {
+  border-radius: 24px;
+}
+@media only screen and (max-width : 600.99px) {
+  .toast {
+    width: 100%;
+    border-radius: 0;
+  }
+}
+
+.tabs {
+  padding-left: 0;
+  list-style-type: none;
+  position: relative;
+  overflow-x: auto;
+  overflow-y: hidden;
+  height: 48px;
+  width: 100%;
+  background-color: var(--md-sys-color-surface);
+  margin: 0 auto;
+  white-space: nowrap;
+}
+.tabs.tabs-transparent {
+  background-color: transparent;
+}
+.tabs.tabs-transparent .tab a {
+  color: var(--font-on-primary-color-medium);
+}
+.tabs.tabs-transparent .tab.disabled a,
+.tabs.tabs-transparent .tab.disabled a:hover,
+.tabs.tabs-transparent .tab.disabled a:focus {
+  color: rgba(255, 255, 255, 0.38);
+}
+.tabs.tabs-transparent .tab a:hover {
+  background-color: rgba(0, 0, 0, 0.04);
+}
+.tabs.tabs-transparent .tab a.active,
+.tabs.tabs-transparent .tab a:focus {
+  background-color: transparent;
+}
+.tabs.tabs-transparent .tab a:hover,
+.tabs.tabs-transparent .tab a.active,
+.tabs.tabs-transparent .tab a:focus {
+  color: var(--md-sys-color-on-primary);
+}
+.tabs.tabs-transparent .indicator {
+  background-color: var(--md-sys-color-on-primary);
+}
+.tabs.tabs-fixed-width {
+  display: flex;
+}
+.tabs.tabs-fixed-width .tab {
+  flex-grow: 1;
+}
+.tabs .tab {
+  padding-left: 0;
+  list-style-type: none;
+  display: inline-block;
+  text-align: center;
+  line-height: 48px;
+  height: 48px;
+  padding: 0;
+  margin: 0;
+}
+.tabs .tab a {
+  color: var(--md-sys-color-on-surface-variant);
+  display: block;
+  width: 100%;
+  height: 100%;
+  padding: 0 24px;
+  font-size: 14px;
+  text-overflow: ellipsis;
+  overflow: hidden;
+  transition: color 0.28s ease, background-color 0.28s ease;
+}
+.tabs .tab a.active {
+  background-color: transparent;
+}
+.tabs .tab a.active, .tabs .tab a:focus, .tabs .tab a:hover {
+  color: var(--md-sys-color-primary);
+}
+.tabs .tab a:hover {
+  background-color: rgba(var(--md-sys-color-primary-numeric), 0.06);
+}
+.tabs .tab a:focus, .tabs .tab a.active {
+  background-color: rgba(var(--md-sys-color-primary-numeric), 0.18);
+  outline: none;
+}
+.tabs .tab.disabled a, .tabs .tab.disabled a:hover {
+  color: var(--md-sys-color-on-surface);
+  cursor: default;
+  background-color: transparent;
+}
+.tabs .tab.disabled a:not(:focus), .tabs .tab.disabled a:hover:not(:focus) {
+  background-color: transparent;
+}
+.tabs .indicator {
+  position: absolute;
+  bottom: 0;
+  height: 3px;
+  background-color: var(--md-sys-color-primary);
+  will-change: left, right;
+  border-radius: 3px 3px 0 0;
+}
+
+/* Fixed Sidenav hide on smaller */
+@media only screen and (max-width : 992.99px) {
+  .tabs {
+    display: flex;
+  }
+  .tabs .tab {
+    flex-grow: 1;
+  }
+  .tabs .tab a {
+    padding: 0 12px;
+  }
+}
+.material-tooltip {
+  padding: 0 8px;
+  border-radius: 4px;
+  color: var(--md-sys-color-inverse-on-surface);
+  background-color: var(--md-sys-color-inverse-surface);
+  font-family: var(--md-sys-typescale-body-small-font-family-name);
+  font-size: var(--md-sys-typescale-body-small-font-size);
+  line-height: var(--md-sys-typescale-body-small-line-height);
+  font-weight: var(--md-sys-typescale-body-small-font-weight);
+  min-height: 24px;
+  opacity: 0;
+  padding-top: 6px;
+  padding-bottom: 6px;
+  font-size: 12px;
+  line-height: 16px;
+  font-weight: 400;
+  letter-spacing: 0.4px;
+  position: absolute;
+  max-width: 300px;
+  overflow: hidden;
+  left: 0;
+  top: 0;
+  pointer-events: none;
+  display: flex;
+  align-items: center;
+  visibility: hidden;
+  z-index: 2000;
+}
+
+.backdrop {
+  position: absolute;
+  opacity: 0;
+  height: 7px;
+  width: 14px;
+  border-radius: 0 0 50% 50%;
+  background-color: var(--md-sys-color-inverse-surface);
+  z-index: -1;
+  transform-origin: 50% 0;
+  visibility: hidden;
+}
+
+.btn, .btn-small, .btn-large, .btn-floating, .btn-flat {
+  --btn-height: 40px;
+  --btn-font-size-icon: 16px;
+  --btn-padding: 24px;
+  --btn-padding-icon: 16px;
+  --btn-gap-icon: 8px;
+  --btn-border-radius: 4px;
+  --btn-font-size: 14px;
+  height: var(--btn-height);
+  border: none;
+  border-radius: var(--btn-border-radius);
+  padding-left: var(--btn-padding);
+  padding-right: var(--btn-padding);
+  font-size: ver(--btn-font-size);
+  font-weight: 500;
+  text-decoration: none;
+  display: inline-flex;
+  align-items: center;
+  cursor: pointer;
+  -webkit-tap-highlight-color: transparent;
+  white-space: nowrap;
+  outline: 0;
+  user-select: none;
+  transition: background-color 0.2s ease-out;
+}
+
+.btn.icon-left, .icon-left.btn-small, .icon-left.btn-large, .btn.icon-right, .icon-right.btn-small, .icon-right.btn-large {
+  position: relative;
+}
+
+.btn.icon-left, .icon-left.btn-small, .icon-left.btn-large {
+  padding-left: calc(var(--btn-padding-icon) + var(--btn-font-size-icon) + var(--btn-gap-icon));
+}
+
+.btn.icon-right, .icon-right.btn-small, .icon-right.btn-large {
+  padding-right: calc(var(--btn-padding-icon) + var(--btn-font-size-icon) + var(--btn-gap-icon));
+}
+
+.btn.icon-left i, .icon-left.btn-small i, .icon-left.btn-large i, .btn.icon-right i, .icon-right.btn-small i, .icon-right.btn-large i {
+  position: absolute;
+  font-size: var(--btn-font-size-icon);
+}
+
+.btn.icon-left i, .icon-left.btn-small i, .icon-left.btn-large i {
+  left: var(--btn-padding-icon);
+}
+
+.btn.icon-right i, .icon-right.btn-small i, .icon-right.btn-large i {
+  right: var(--btn-padding-icon);
+}
+
+.btn.filled, .filled.btn-small, .filled.btn-large {
+  color: var(--md-sys-color-on-primary);
+  background-color: var(--md-sys-color-primary);
+}
+
+.btn.tonal, .tonal.btn-small, .tonal.btn-large {
+  color: var(--md-sys-color-on-secondary-container);
+  background-color: var(--md-sys-color-secondary-container);
+}
+
+.btn.elevated, .elevated.btn-small, .elevated.btn-large {
+  color: var(--md-sys-color-on-secondary-container);
+  background-color: var(--md-sys-color-secondary-container);
+}
+
+.btn.outlined, .outlined.btn-small, .outlined.btn-large {
+  background-color: transparent;
+  color: var(--md-sys-color-primary);
+  border: 1px solid var(--md-sys-color-outline);
+}
+
+.btn.text, .text.btn-small, .text.btn-large, .btn-flat {
+  color: var(--md-sys-color-primary);
+  background-color: transparent;
+}
+
+.btn.disabled, .btn-floating.disabled, .btn-large.disabled, .btn-small.disabled, .btn-flat.disabled,
+.btn:disabled, .btn-floating:disabled, .btn-large:disabled, .btn-small:disabled, .btn-flat:disabled,
+.btn[disabled], .btn-floating[disabled], .btn-large[disabled], .btn-small[disabled], .btn-flat[disabled] {
+  color: color-mix(in srgb, transparent, var(--md-sys-color-on-surface) 76%);
+  background-color: color-mix(in srgb, transparent, var(--md-sys-color-on-surface) 24%);
+  pointer-events: none;
+  box-shadow: none;
+  cursor: default;
+}
+
+.btn.elevated:hover, .elevated.btn-small:hover, .elevated.btn-large:hover {
+  color: var(--md-sys-color-primary);
+  background-color: color-mix(in srgb, var(--md-sys-color-secondary-container), var(--md-sys-color-on-secondary-container) 16%);
+}
+
+.btn.filled:hover, .filled.btn-small:hover, .filled.btn-large:hover {
+  color: var(--md-sys-color-on-primary);
+  background-color: color-mix(in srgb, var(--md-sys-color-primary), var(--md-sys-color-on-primary) 16%);
+}
+
+.btn.tonal:hover, .tonal.btn-small:hover, .tonal.btn-large:hover {
+  color: var(--md-sys-color-on-secondary-container);
+  background-color: color-mix(in srgb, var(--md-sys-color-secondary-container), var(--md-sys-color-on-secondary-container) 16%);
+}
+
+.btn.outlined:hover, .outlined.btn-small:hover, .outlined.btn-large:hover {
+  color: var(--md-sys-color-primary);
+  background-color: color-mix(in srgb, transparent, var(--md-sys-color-primary) 16%);
+}
+
+.btn.text:hover, .text.btn-small:hover, .text.btn-large:hover {
+  color: var(--md-sys-color-primary);
+  background-color: color-mix(in srgb, var(--md-sys-color-primary) 16%, transparent);
+}
+
+.btn:focus.elevated, .btn-small:focus.elevated, .btn-large:focus.elevated {
+  color: var(--md-sys-color-primary);
+  background-color: color-mix(in srgb, var(--md-sys-color-secondary-container), var(--md-sys-color-primary) 20%);
+}
+
+.btn:focus.filled, .btn-small:focus.filled, .btn-large:focus.filled {
+  color: var(--md-sys-color-on-primary);
+  background-color: color-mix(in srgb, var(--md-sys-color-primary), var(--md-sys-color-on-primary) 20%);
+}
+
+.btn:focus.tonal, .btn-small:focus.tonal, .btn-large:focus.tonal {
+  color: var(--md-sys-color-on-secondary-container);
+  background-color: color-mix(in srgb, var(--md-sys-color-secondary-container), var(--md-sys-color-on-secondary-container) 20%);
+}
+
+.btn:focus.outlined, .btn-small:focus.outlined, .btn-large:focus.outlined {
+  color: var(--md-sys-color-primary);
+  background-color: color-mix(in srgb, transparent, var(--md-sys-color-primary) 20%);
+  border: 1px solid var(--md-sys-color-primary);
+}
+
+.btn:focus.text, .btn-small:focus.text, .btn-large:focus.text {
+  color: var(--md-sys-color-primary);
+  background-color: color-mix(in srgb, transparent, var(--md-sys-color-primary) 20%);
+}
+
+.btn:focus-visible.filled, .btn-small:focus-visible.filled, .btn-large:focus-visible.filled, .btn:focus-visible.elevated, .btn-small:focus-visible.elevated, .btn-large:focus-visible.elevated, .btn:focus-visible.tonal, .btn-small:focus-visible.tonal, .btn-large:focus-visible.tonal, .btn:focus-visible.outlined, .btn-small:focus-visible.outlined, .btn-large:focus-visible.outlined, .btn:focus-visible.text, .btn-small:focus-visible.text, .btn-large:focus-visible.text {
+  outline: 3px solid var(--md-sys-color-secondary);
+  outline-offset: 2px;
+}
+
+.btn-floating {
+  width: 40px;
+  height: 40px;
+  color: var(--md-sys-color-on-primary-container);
+  background-color: var(--md-sys-color-primary-container);
+  border-radius: 16px;
+  padding: 0;
+  display: grid;
+  grid-auto-flow: column;
+  align-items: center;
+  position: relative;
+  overflow: hidden;
+  z-index: 1;
+  transition: background-color 0.3s;
+  cursor: pointer;
+  vertical-align: middle;
+}
+.btn-floating:hover {
+  background-color: color-mix(in srgb, var(--md-sys-color-primary-container), var(--md-sys-color-on-primary-container) 16%);
+}
+.btn-floating:focus {
+  background-color: var(--md-ref-palette-secondary80);
+}
+.btn-floating:before {
+  border-radius: 0;
+}
+.btn-floating.btn-large {
+  width: 56px;
+  height: 56px;
+  padding: 0;
+}
+.btn-floating.btn-large.halfway-fab {
+  bottom: -28px;
+}
+.btn-floating.btn-small {
+  --btn-small-height: calc(0.75 * var(--btn-height));
+  width: var(--btn-small-height) e;
+  height: var(--btn-small-height);
+}
+.btn-floating.btn-small.halfway-fab {
+  bottom: calc(var(--btn-small-height) * -0.5);
+}
+.btn-floating.halfway-fab {
+  position: absolute;
+  right: 24px;
+  bottom: -20px;
+}
+.btn-floating.halfway-fab.left {
+  right: auto;
+  left: 24px;
+}
+.btn-floating i {
+  color: var(--md-sys-color-on-secondary);
+  font-size: 1.6rem;
+  width: inherit;
+  display: inline-block;
+  text-align: center;
+}
+
+button.btn-floating {
+  border: none;
+}
+
+.fixed-action-btn {
+  position: fixed;
+  right: 23px;
+  bottom: 23px;
+  padding-top: 15px;
+  margin-bottom: 0;
+  z-index: 997;
+}
+.fixed-action-btn.active ul {
+  visibility: visible;
+  padding-left: 0;
+  list-style-type: none;
+}
+.fixed-action-btn.direction-left, .fixed-action-btn.direction-right {
+  padding: 0 0 0 15px;
+}
+.fixed-action-btn.direction-left ul, .fixed-action-btn.direction-right ul {
+  text-align: right;
+  right: 64px;
+  top: 50%;
+  transform: translateY(-50%);
+  height: 100%;
+  left: auto;
+  /*width 100% only goes to width of button container */
+  width: 500px;
+}
+.fixed-action-btn.direction-left ul li, .fixed-action-btn.direction-right ul li {
+  display: inline-block;
+  margin: 7.5px 15px 0 0;
+}
+.fixed-action-btn.direction-right {
+  padding: 0 15px 0 0;
+}
+.fixed-action-btn.direction-right ul {
+  text-align: left;
+  direction: rtl;
+  left: 64px;
+  right: auto;
+}
+.fixed-action-btn.direction-right ul li {
+  margin: 7.5px 0 0 15px;
+}
+.fixed-action-btn.direction-bottom {
+  padding: 0 0 15px 0;
+}
+.fixed-action-btn.direction-bottom ul {
+  top: 64px;
+  bottom: auto;
+  display: flex;
+  flex-direction: column-reverse;
+}
+.fixed-action-btn.direction-bottom ul li {
+  margin: 15px 0 0 0;
+}
+.fixed-action-btn.toolbar {
+  padding: 0;
+  height: 56px;
+}
+.fixed-action-btn.toolbar.active > a i {
+  opacity: 0;
+}
+.fixed-action-btn.toolbar ul {
+  display: flex;
+  top: 0;
+  bottom: 0;
+  z-index: 1;
+}
+.fixed-action-btn.toolbar ul li {
+  flex: 1;
+  display: inline-block;
+  margin: 0;
+  height: 100%;
+  transition: none;
+}
+.fixed-action-btn.toolbar ul li a {
+  display: block;
+  overflow: hidden;
+  position: relative;
+  width: 100%;
+  height: 100%;
+  background-color: transparent;
+  box-shadow: none;
+  color: var(--md-sys-color-on-secondary);
+  line-height: 56px;
+  z-index: 1;
+}
+.fixed-action-btn.toolbar ul li a i {
+  line-height: inherit;
+}
+.fixed-action-btn ul {
+  left: 0;
+  right: 0;
+  text-align: center;
+  position: absolute;
+  bottom: 64px;
+  margin: 0;
+  visibility: hidden;
+}
+.fixed-action-btn ul li {
+  margin-bottom: 15px;
+}
+.fixed-action-btn ul a.btn-floating {
+  opacity: 0;
+}
+.fixed-action-btn .fab-backdrop {
+  position: absolute;
+  top: 0;
+  left: 0;
+  z-index: -1;
+  width: 40px;
+  height: 40px;
+  background-color: var(--md-sys-color-secondary);
+  border-radius: 16px;
+  transform: scale(0);
+}
+
+.btn-large {
+  height: calc(1.5 * var(--btn-height));
+  font-size: 18px;
+  padding: 0 28px;
+}
+.btn-large i {
+  font-size: 1.6rem;
+}
+
+.btn-small {
+  height: calc(0.75 * var(--btn-height));
+  font-size: 13px;
+}
+.btn-small i {
+  font-size: 1.2rem;
+}
+
+.btn-block {
+  display: block;
+}
+
+.btn.rounded, .rounded.btn-large, .rounded.btn-small {
+  border-radius: 99999px;
+}
+
+[popover] {
+  outline: none;
+  padding: 0;
+  border: none;
+}
+
+.dropdown-content {
+  padding-left: 0;
+  list-style-type: none;
+  background-color: var(--md-sys-color-surface);
+  margin: 0;
+  display: none;
+  min-width: 100px;
+  overflow-y: auto;
+  opacity: 0;
+  position: absolute;
+  left: 0;
+  top: 0;
+  z-index: 9999;
+  transform-origin: 0 0;
+  user-select: none;
+}
+.dropdown-content li {
+  clear: both;
+  color: var(--md-sys-color-on-background);
+  cursor: pointer;
+  min-height: 50px;
+  line-height: 1.5rem;
+  width: 100%;
+  text-align: left;
+}
+.dropdown-content li.divider {
+  min-height: 0;
+  height: 1px;
+}
+.dropdown-content li > a, .dropdown-content li > span {
+  font-size: 16px;
+  color: var(--md-sys-color-primary);
+  display: block;
+  line-height: 22px;
+  padding: 14px 16px;
+}
+.dropdown-content li > span > label {
+  top: 1px;
+  left: 0;
+  height: 18px;
+}
+.dropdown-content li > a > i {
+  height: inherit;
+  line-height: inherit;
+  float: left;
+  margin: 0 24px 0 0;
+  width: 24px;
+}
+.dropdown-content li:not(.disabled):hover, .dropdown-content li.active {
+  background-color: color-mix(in srgb, var(--md-sys-color-surface), var(--md-sys-color-on-surface) 8%);
+}
+
+body.keyboard-focused .dropdown-content li:focus {
+  background-color: rgba(0, 0, 0, 0.12);
+}
+
+.input-field.col .dropdown-content [type=checkbox] + label {
+  top: 1px;
+  left: 0;
+  height: 18px;
+  transform: none;
+}
+
+.dropdown-trigger {
+  cursor: pointer;
+}
+
+.modal {
+  --modal-footer-height: 56px;
+  --modal-footer-divider-height: 1px;
+  --modal-border-radius: 28px;
+  --modal-padding: 24px;
+  display: none;
+  position: fixed;
+  left: 0;
+  right: 0;
+  background-color: var(--md-sys-color-surface);
+  padding: 0;
+  max-height: 70%;
+  width: 55%;
+  margin: auto;
+  overflow-y: auto;
+  border-radius: var(--modal-border-radius);
+  will-change: top, opacity;
+}
+.modal:focus {
+  outline: none;
+}
+@media only screen and (max-width : 992.99px) {
+  .modal {
+    width: 80%;
+  }
+}
+.modal h1, .modal h2, .modal h3, .modal h4 {
+  margin-top: 0;
+}
+.modal .modal-content {
+  padding: var(--modal-padding);
+  overflow-y: hidden;
+}
+.modal .modal-close {
+  cursor: pointer;
+}
+.modal .modal-footer {
+  border-radius: 0 0 var(--modal-border-radius) var(--modal-border-radius);
+  background-color: var(--md-sys-color-surface);
+  padding: 4px 6px;
+  height: var(--modal-footer-height);
+  width: 100%;
+  text-align: right;
+}
+.modal .modal-footer .btn, .modal .modal-footer .btn-large, .modal .modal-footer .btn-small, .modal .modal-footer .btn-flat {
+  margin: 6px 0;
+}
+
+.modal-overlay {
+  position: fixed;
+  z-index: 999;
+  top: -25%;
+  left: 0;
+  bottom: 0;
+  right: 0;
+  height: 125%;
+  width: 100%;
+  background: #000;
+  display: none;
+  will-change: opacity;
+}
+
+.modal.modal-fixed-footer {
+  padding: 0;
+  height: 70%;
+}
+.modal.modal-fixed-footer .modal-content {
+  position: absolute;
+  height: calc(100% - var(--modal-footer-height));
+  max-height: 100%;
+  width: 100%;
+  overflow-y: auto;
+}
+.modal.modal-fixed-footer .modal-footer {
+  border-top: var(--modal-footer-divider-height) solid var(--md-sys-color-outline-variant);
+  position: absolute;
+  bottom: var(--modal-footer-divider-height);
+}
+
+.modal.bottom-sheet {
+  top: auto;
+  bottom: -100%;
+  margin: 0;
+  width: 100%;
+  max-height: 45%;
+  border-radius: 0;
+  will-change: bottom, opacity;
+}
+
+.collapsible {
+  padding-left: 0;
+  list-style-type: none;
+  border-top: 1px solid var(--md-sys-color-outline-variant);
+  border-right: 1px solid var(--md-sys-color-outline-variant);
+  border-left: 1px solid var(--md-sys-color-outline-variant);
+  margin: 0.5rem 0 1rem 0;
+}
+
+.collapsible-header {
+  display: flex;
+  cursor: pointer;
+  -webkit-tap-highlight-color: transparent;
+  line-height: 1.5;
+  padding: 1rem;
+  border-bottom: 1px solid var(--md-sys-color-outline-variant);
+}
+.collapsible-header:focus {
+  outline: 0;
+}
+.collapsible-header i {
+  width: 2rem;
+  font-size: 1.6rem;
+  display: inline-block;
+  text-align: center;
+  margin-right: 1rem;
+}
+
+.collapsible-header::after {
+  content: "▾";
+  text-align: right;
+  margin-right: 0.25rem;
+  width: 100%;
+}
+
+.active .collapsible-header::after {
+  content: "▴";
+}
+
+.keyboard-focused .collapsible-header:focus {
+  background-color: rgba(0, 0, 0, 0.12);
+}
+
+.collapsible-body {
+  max-height: 0;
+  border-bottom: 1px solid var(--md-sys-color-outline-variant);
+  box-sizing: border-box;
+  padding: 0 2rem;
+  overflow: hidden;
+}
+
+.collapsible.popout {
+  border: none;
+  box-shadow: none;
+}
+.collapsible.popout > li {
+  box-shadow: 0 2px 5px 0 rgba(0, 0, 0, 0.16), 0 2px 10px 0 rgba(0, 0, 0, 0.12);
+  margin: 0 24px;
+  transition: margin 0.35s cubic-bezier(0.25, 0.46, 0.45, 0.94);
+}
+.collapsible.popout > li.active {
+  box-shadow: 0 5px 11px 0 rgba(0, 0, 0, 0.18), 0 4px 15px 0 rgba(0, 0, 0, 0.15);
+  margin: 16px 0;
+}
+
+.chip {
+  --font-size: 14px;
+  --font-size-icon: 18px;
+  --padding: 8px;
+  color: var(--md-sys-color-on-surface-variant);
+  background-color: rgba(0, 0, 0, 0.09);
+  display: inline-flex;
+  white-space: nowrap;
+  gap: 8px;
+  margin: 0;
+  height: 32px;
+  padding-left: var(--padding);
+  padding-right: var(--padding);
+  font-size: var(--font-size);
+  font-weight: 500;
+  border-radius: 8px;
+  align-items: center;
+  user-select: none;
+  vertical-align: top;
+}
+.chip:focus {
+  outline: none;
+  background-color: var(--md-sys-color-primary);
+  color: var(--md-sys-color-on-primary);
+}
+
+.chip.outlined {
+  background-color: transparent;
+  border-color: var(--md-sys-color-outline);
+  border-width: 1px;
+  border-style: solid;
+}
+
+.chip > img {
+  margin: 0;
+  width: 24px;
+  height: 24px;
+  object-fit: cover;
+  border-radius: 12px;
+}
+
+.chip > .material-icons {
+  font-size: var(--font-size-icon);
+}
+
+.chip .close {
+  border-radius: 50%;
+  height: 24px;
+  width: 24px;
+  padding: 0;
+  display: grid;
+  justify-content: center;
+  align-content: center;
+  cursor: pointer;
+}
+
+.chip .close:hover {
+  background-color: rgba(136, 136, 136, 0.5333333333);
+}
+
+.chips {
+  display: flex;
+  gap: 4px;
+  flex-wrap: wrap;
+  border: none;
+  border-bottom: 1px solid var(--md-sys-color-on-surface-variant);
+  box-shadow: none;
+  margin: 0 0 8px 0;
+  padding: 4px;
+  outline: none;
+  transition: all 0.3s;
+}
+.chips.focus {
+  border-bottom: 1px solid var(--md-sys-color-primary);
+  box-shadow: 0 1px 0 0 var(--md-sys-color-primary);
+}
+.chips:hover {
+  cursor: text;
+}
+.chips input:not([type]):not(.browser-default).input {
+  background: none;
+  border: 0;
+  color: var(--md-sys-color-on-background);
+  display: inline-block;
+  font-size: 16px;
+  height: 32px;
+  outline: 0;
+  margin: 0;
+  padding: 0;
+  width: 120px;
+}
+.chips input:not([type]):not(.browser-default).input:focus {
+  border: 0;
+  box-shadow: none;
+}
+.chips .autocomplete-content {
+  margin-top: 0;
+  margin-bottom: 0;
+}
+
+.prefix ~ .chips {
+  margin-left: 3rem;
+  width: 92%;
+  width: calc(100% - 3rem);
+}
+
+.suffix ~ .chips {
+  margin-right: 3rem;
+  width: 92%;
+  width: calc(100% - 3rem);
+}
+
+.chips:empty ~ label {
+  font-size: 0.8rem;
+  transform: translateY(-140%);
+}
+
+.materialboxed {
+  display: block;
+  cursor: zoom-in;
+  position: relative;
+  transition: opacity 0.4s;
+  -webkit-backface-visibility: hidden;
+}
+.materialboxed:hover:not(.active) {
+  opacity: 0.8;
+}
+.materialboxed.active {
+  cursor: zoom-out;
+}
+
+#materialbox-overlay {
+  position: fixed;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  background-color: var(--md-sys-color-background);
+  z-index: 1000;
+  will-change: opacity;
+}
+
+.materialbox-caption {
+  position: fixed;
+  display: none;
+  color: var(--md-sys-color-on-background);
+  line-height: 50px;
+  bottom: 0;
+  left: 0;
+  width: 100%;
+  text-align: center;
+  padding: 0% 15%;
+  height: 50px;
+  z-index: 1000;
+  -webkit-font-smoothing: antialiased;
+}
+
+select:focus {
+  outline: 1px solid var(--md-ref-palette-primary80);
+}
+
+/*
+button:focus {
+  outline: none;
+  background-color: $button-background-focus;
+}
+*/
+label {
+  font-size: 0.8rem;
+  color: var(--md-sys-color-on-surface-variant);
+}
+
+/* Style Placeholders */
+::placeholder {
+  color: var(--md-sys-color-on-surface-variant);
+}
+
+/* Text inputs */
+input:not([type]):not(.browser-default),
+input[type=text]:not(.browser-default),
+input[type=password]:not(.browser-default),
+input[type=email]:not(.browser-default),
+input[type=url]:not(.browser-default),
+input[type=time]:not(.browser-default),
+input[type=date]:not(.browser-default),
+input[type=datetime]:not(.browser-default),
+input[type=datetime-local]:not(.browser-default),
+input[type=month]:not(.browser-default),
+input[type=tel]:not(.browser-default),
+input[type=number]:not(.browser-default),
+input[type=search]:not(.browser-default),
+textarea.materialize-textarea {
+  outline: none;
+  color: var(--md-sys-color-on-background);
+  width: 100%;
+  font-size: 16px;
+  height: 56px;
+}
+
+/* Validation Sass Placeholders */
+/*
+%custom-success-message {
+  content: attr(data-success);
+  color: $success-color;
+}
+%custom-error-message {
+  content: attr(data-error);
+  color: var(--md-sys-color-error);
+}
+*/
+.input-field {
+  --input-color: var(--md-sys-color-primary);
+  position: relative;
+  clear: both;
+}
+.input-field input, .input-field textarea {
+  box-sizing: border-box; /* https://stackoverflow.com/questions/1377719/padding-within-inputs-breaks-width-100*/
+  padding: 0 16px;
+  padding-top: 20px;
+  background-color: var(--md-sys-color-surface);
+  border: none;
+  border-radius: 4px;
+  border-bottom: 1px solid var(--md-sys-color-on-surface-variant);
+  border-bottom-left-radius: 0;
+  border-bottom-right-radius: 0;
+}
+.input-field input:focus:not([readonly]), .input-field textarea:focus:not([readonly]) {
+  border-bottom: 2px solid var(--input-color);
+  padding-top: 21px;
+}
+.input-field input:disabled, .input-field input[readonly=readonly], .input-field textarea:disabled, .input-field textarea[readonly=readonly] {
+  color: rgba(var(--md_sys_color_on-surface), 0.38);
+  border-color: rgba(var(--md_sys_color_on-surface), 0.12);
+  background-color: rgba(var(--md_sys_color_on-surface), 0.04);
+}
+.input-field input:focus:not([readonly]) + label, .input-field textarea:focus:not([readonly]) + label {
+  color: var(--input-color);
+}
+.input-field input:focus:not([readonly]) + label, .input-field input:not([placeholder=" "]) + label, .input-field input:not(:placeholder-shown) + label, .input-field textarea:focus:not([readonly]) + label, .input-field textarea:not([placeholder=" "]) + label, .input-field textarea:not(:placeholder-shown) + label {
+  transform: scale(0.75);
+  top: 8px;
+}
+.input-field input:disabled + label, .input-field input[readonly=readonly] + label, .input-field textarea:disabled + label, .input-field textarea[readonly=readonly] + label {
+  color: rgba(var(--md_sys_color_on-surface), 0.38);
+}
+.input-field input::placeholder {
+  user-select: none;
+}
+.input-field > label {
+  color: var(--md-sys-color-on-surface-variant);
+  user-select: none;
+  font-size: 16px;
+  position: absolute;
+  left: 16px;
+  top: 16px;
+  cursor: text;
+  transform-origin: top left;
+  transition: left 0.2s ease-out, top 0.2s ease-out, transform 0.2s ease-out;
+}
+.input-field .supporting-text {
+  color: var(--md-sys-color-on-surface-variant);
+  font-size: 12px;
+  padding: 0 16px;
+  margin-top: 4px;
+}
+.input-field .character-counter {
+  color: var(--md-sys-color-on-surface-variant);
+  font-size: 12px;
+  float: right;
+  padding: 0 16px;
+  margin-top: 4px;
+}
+.input-field .prefix {
+  position: absolute;
+  left: 12px;
+  top: 16px;
+  user-select: none;
+  display: flex;
+  align-self: center;
+}
+.input-field .suffix {
+  position: absolute;
+  right: 12px;
+  top: 16px;
+  user-select: none;
+}
+.input-field .prefix ~ input, .input-field .prefix ~ textarea {
+  padding-left: 52px;
+}
+.input-field .suffix ~ input, .input-field .suffix ~ textarea {
+  padding-right: 52px;
+}
+.input-field .prefix ~ label {
+  left: 52px;
+}
+.input-field.outlined input, .input-field.outlined textarea {
+  padding-top: 0;
+  background-color: var(--md-sys-color-background);
+  border: 1px solid var(--md-sys-color-on-surface-variant);
+  border-radius: 4px;
+}
+.input-field.outlined input:focus:not([readonly]), .input-field.outlined textarea:focus:not([readonly]) {
+  border: 2px solid var(--input-color);
+  padding-top: 0;
+  margin-left: -1px;
+}
+.input-field.outlined input:focus:not([readonly]) + label, .input-field.outlined textarea:focus:not([readonly]) + label {
+  color: var(--input-color);
+}
+.input-field.outlined input:focus:not([readonly]) + label, .input-field.outlined input:not([placeholder=" "]) + label, .input-field.outlined input:not(:placeholder-shown) + label, .input-field.outlined textarea:focus:not([readonly]) + label, .input-field.outlined textarea:not([placeholder=" "]) + label, .input-field.outlined textarea:not(:placeholder-shown) + label {
+  top: -8px;
+  left: 16px;
+  margin-left: -4px;
+  padding: 0 4px;
+  background-color: var(--md-sys-color-background);
+}
+.input-field.outlined input:disabled, .input-field.outlined input[readonly=readonly], .input-field.outlined textarea:disabled, .input-field.outlined textarea[readonly=readonly] {
+  color: rgba(var(--md_sys_color_on-surface), 0.38);
+  border-color: rgba(var(--md_sys_color_on-surface), 0.12);
+}
+.input-field.error input, .input-field.error textarea {
+  border-color: var(--md-sys-color-error);
+}
+.input-field.error input:focus:not([readonly]), .input-field.error textarea:focus:not([readonly]) {
+  border-color: var(--md-sys-color-error);
+}
+.input-field.error input:focus:not([readonly]) + label, .input-field.error textarea:focus:not([readonly]) + label {
+  color: var(--md-sys-color-error);
+}
+.input-field.error label {
+  color: var(--md-sys-color-error);
+}
+.input-field.error .supporting-text {
+  color: var(--md-sys-color-error);
+}
+.input-field.error .suffix {
+  color: var(--md-sys-color-error);
+}
+
+/* Search Field */
+.searchbar .prefix {
+  position: absolute;
+  padding-left: 1rem;
+  top: 0;
+  user-select: none;
+  display: flex;
+  align-self: center;
+}
+.searchbar > input {
+  border-width: 0;
+  background-color: transparent;
+  padding-left: 3rem;
+}
+
+.searchbar.has-sidebar {
+  margin-left: 0;
+}
+@media only screen and (min-width : 993px) {
+  .searchbar.has-sidebar {
+    margin-left: 300px;
+  }
+}
+
+/*
+.input-field input[type=search] {
+  display: block;
+  line-height: inherit;
+
+  .nav-wrapper & {
+    height: inherit;
+    padding-left: 4rem;
+    width: calc(100% - 4rem);
+    border: 0;
+    box-shadow: none;
+  }
+  &:focus:not(.browser-default) {
+    border: 0;
+    box-shadow: none;
+  }
+  & + .label-icon {
+    transform: none;
+    left: 1rem;
+  }
+}
+*/
+/* Textarea */
+textarea {
+  width: 100%;
+  height: 3rem;
+  background-color: transparent;
+}
+textarea.materialize-textarea {
+  padding-top: 26px !important;
+  padding-bottom: 4px !important;
+  line-height: normal;
+  overflow-y: hidden; /* prevents scroll bar flash */
+  resize: none;
+  min-height: 3rem;
+  box-sizing: border-box;
+}
+
+.hiddendiv {
+  visibility: hidden;
+  white-space: pre-wrap;
+  word-wrap: break-word;
+  overflow-wrap: break-word; /* future version of deprecated 'word-wrap' */
+  padding-top: 1.2rem; /* prevents text jump on Enter keypress */
+  position: absolute;
+  top: 0;
+  z-index: -1;
+}
+
+/* Autocomplete Items */
+.autocomplete-content li .highlight {
+  color: var(--md-sys-color-on-background);
+}
+.autocomplete-content li img {
+  height: 40px;
+  width: 40px;
+  margin: 5px 15px;
+}
+
+[type=radio]:not(:checked),
+[type=radio]:checked {
+  position: absolute;
+  opacity: 0;
+  pointer-events: none;
+}
+
+[type=radio]:not(:checked) + span,
+[type=radio]:checked + span {
+  position: relative;
+  padding-left: 35px;
+  cursor: pointer;
+  display: inline-block;
+  height: 25px;
+  line-height: 25px;
+  font-size: 1rem;
+  transition: 0.28s ease;
+  user-select: none;
+}
+
+[type=radio] + span:before,
+[type=radio] + span:after {
+  content: "";
+  position: absolute;
+  left: 0;
+  top: 0;
+  margin: 4px;
+  width: 16px;
+  height: 16px;
+  z-index: 0;
+  transition: 0.28s ease;
+}
+
+/* Unchecked styles */
+[type=radio]:not(:checked) + span:before,
+[type=radio]:not(:checked) + span:after,
+[type=radio]:checked + span:before,
+[type=radio]:checked + span:after,
+[type=radio].with-gap:checked + span:before,
+[type=radio].with-gap:checked + span:after {
+  border-radius: 50%;
+}
+
+[type=radio]:not(:checked) + span:before,
+[type=radio]:not(:checked) + span:after {
+  border: 2px solid var(--md-sys-color-on-surface-variant);
+}
+
+[type=radio]:not(:checked) + span:after {
+  transform: scale(0);
+}
+
+/* Checked styles */
+[type=radio]:checked + span:before {
+  border: 2px solid transparent;
+}
+
+[type=radio]:checked + span:after,
+[type=radio].with-gap:checked + span:before,
+[type=radio].with-gap:checked + span:after {
+  border: 2px solid var(--md-sys-color-primary);
+}
+
+[type=radio]:checked + span:after,
+[type=radio].with-gap:checked + span:after {
+  background-color: var(--md-sys-color-primary);
+}
+
+[type=radio]:checked + span:after {
+  transform: scale(1.02);
+}
+
+/* Radio With gap */
+[type=radio].with-gap:checked + span:after {
+  transform: scale(0.5);
+}
+
+/* Focused styles */
+[type=radio].tabbed:focus + span:before {
+  box-shadow: 0 0 0 10px rgba(var(--md-sys-color-primary-numeric), 0.18);
+}
+
+/* Disabled Radio With gap */
+[type=radio].with-gap:disabled:checked + span:before {
+  border: 2px solid var(--md-sys-color-on-surface);
+}
+
+[type=radio].with-gap:disabled:checked + span:after {
+  border: none;
+  background-color: var(--md-sys-color-on-surface);
+}
+
+/* Disabled style */
+[type=radio]:disabled:not(:checked) + span:before,
+[type=radio]:disabled:checked + span:before {
+  background-color: transparent;
+  border-color: var(--md-sys-color-on-surface);
+}
+
+[type=radio]:disabled + span {
+  color: var(--md-sys-color-on-surface);
+}
+
+[type=radio]:disabled:not(:checked) + span:before {
+  border-color: var(--md-sys-color-on-surface);
+}
+
+[type=radio]:disabled:checked + span:after {
+  background-color: var(--md-sys-color-on-surface);
+  border-color: var(--md-sys-color-on-surface);
+}
+
+/* Checkboxes
+   ========================================================================== */
+/* Remove default checkbox */
+[type=checkbox]:not(:checked),
+[type=checkbox]:checked {
+  position: absolute;
+  opacity: 0;
+  pointer-events: none;
+}
+
+[type=checkbox] {
+  /* checkbox aspect */
+}
+[type=checkbox] + span:not(.lever) {
+  position: relative;
+  padding-left: 35px;
+  cursor: pointer;
+  display: inline-block;
+  height: 25px;
+  line-height: 25px;
+  font-size: 1rem;
+  user-select: none;
+}
+[type=checkbox] + span:not(.lever):before, [type=checkbox]:not(.filled-in) + span:not(.lever):after {
+  content: "";
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 18px;
+  height: 18px;
+  z-index: 0;
+  border: 2px solid var(--md-sys-color-on-surface-variant);
+  border-radius: 1px;
+  margin-top: 3px;
+  transition: 0.2s;
+}
+[type=checkbox]:not(.filled-in) + span:not(.lever):after {
+  border: 0;
+  transform: scale(0);
+}
+[type=checkbox]:not(:checked):disabled + span:not(.lever):before {
+  border: none;
+  background-color: var(--md-sys-color-on-surface);
+}
+[type=checkbox].tabbed:focus + span:not(.lever):after {
+  transform: scale(1);
+  border: 0;
+  border-radius: 50%;
+  box-shadow: 0 0 0 10px rgba(0, 0, 0, 0.12);
+  background-color: rgba(0, 0, 0, 0.12);
+}
+
+[type=checkbox]:checked + span:not(.lever):before {
+  top: -4px;
+  left: -5px;
+  width: 12px;
+  height: 22px;
+  border-top: 2px solid transparent;
+  border-left: 2px solid transparent;
+  border-right: 2px solid var(--md-sys-color-primary);
+  border-bottom: 2px solid var(--md-sys-color-primary);
+  transform: rotate(40deg);
+  backface-visibility: hidden;
+  transform-origin: 100% 100%;
+}
+[type=checkbox]:checked:disabled + span:before {
+  border-right: 2px solid var(--md-sys-color-on-surface);
+  border-bottom: 2px solid var(--md-sys-color-on-surface);
+}
+
+/* Indeterminate checkbox */
+[type=checkbox]:indeterminate + span:not(.lever):before {
+  top: -11px;
+  left: -12px;
+  width: 10px;
+  height: 22px;
+  border-top: none;
+  border-left: none;
+  border-right: 2px solid var(--md-sys-color-primary);
+  border-bottom: none;
+  transform: rotate(90deg);
+  backface-visibility: hidden;
+  transform-origin: 100% 100%;
+}
+[type=checkbox]:indeterminate:disabled + span:not(.lever):before {
+  border-right: 2px solid var(--md-sys-color-on-surface);
+  background-color: transparent;
+}
+
+[type=checkbox].filled-in + span:not(.lever):after {
+  border-radius: 2px;
+}
+[type=checkbox].filled-in + span:not(.lever):before,
+[type=checkbox].filled-in + span:not(.lever):after {
+  content: "";
+  left: 0;
+  position: absolute;
+  /* .1s delay is for check animation */
+  transition: border 0.25s, background-color 0.25s, width 0.2s 0.1s, height 0.2s 0.1s, top 0.2s 0.1s, left 0.2s 0.1s;
+  z-index: 1;
+}
+[type=checkbox].filled-in:not(:checked) + span:not(.lever):before {
+  width: 0;
+  height: 0;
+  border: 3px solid transparent;
+  left: 6px;
+  top: 10px;
+  transform: rotateZ(37deg);
+  transform-origin: 100% 100%;
+}
+[type=checkbox].filled-in:not(:checked) + span:not(.lever):after {
+  height: 20px;
+  width: 20px;
+  background-color: transparent;
+  border: 2px solid var(--md-sys-color-on-surface-variant);
+  top: 0px;
+  z-index: 0;
+}
+[type=checkbox].filled-in:checked + span:not(.lever):before {
+  top: 0;
+  left: 1px;
+  width: 8px;
+  height: 13px;
+  border-top: 2px solid transparent;
+  border-left: 2px solid transparent;
+  border-right: 2px solid var(--md-sys-color-on-primary);
+  border-bottom: 2px solid var(--md-sys-color-on-primary);
+  transform: rotateZ(37deg);
+  transform-origin: 100% 100%;
+}
+[type=checkbox].filled-in:checked + span:not(.lever):after {
+  top: 0;
+  width: 20px;
+  height: 20px;
+  border: 2px solid var(--md-sys-color-primary);
+  background-color: var(--md-sys-color-primary);
+  z-index: 0;
+}
+[type=checkbox].filled-in.tabbed:focus + span:not(.lever):after {
+  border-radius: 2px;
+  border-color: var(--md-sys-color-on-surface-variant) r;
+  background-color: rgba(0, 0, 0, 0.12);
+}
+[type=checkbox].filled-in.tabbed:checked:focus + span:not(.lever):after {
+  border-radius: 2px;
+  background-color: var(--md-sys-color-primary);
+  border-color: var(--md-sys-color-primary);
+}
+[type=checkbox].filled-in:disabled:not(:checked) + span:not(.lever):before {
+  background-color: transparent;
+  border: 2px solid transparent;
+}
+[type=checkbox].filled-in:disabled:not(:checked) + span:not(.lever):after {
+  border-color: transparent;
+  background-color: var(--md-sys-color-on-surface);
+}
+[type=checkbox].filled-in:disabled:checked + span:not(.lever):before {
+  background-color: transparent;
+}
+[type=checkbox].filled-in:disabled:checked + span:not(.lever):after {
+  background-color: var(--md-sys-color-on-surface);
+  border-color: var(--md-sys-color-on-surface);
+}
+
+.switch {
+  --track-height: 32px;
+  --track-width: 52px;
+  --border-width: 2px;
+  --size-off: 16px;
+  --size-on: 24px;
+  --icon-size: 16px;
+  --gap-on: calc(((var(--track-height) - var(--size-on)) / 2) - var(--border-width));
+  --gap-off: calc(((var(--track-height) - var(--size-off)) / 2) - var(--border-width));
+}
+
+.switch,
+.switch * {
+  -webkit-tap-highlight-color: transparent;
+  user-select: none;
+}
+
+.switch label {
+  cursor: pointer;
+}
+
+.switch label input[type=checkbox] {
+  opacity: 0;
+  width: 0;
+  height: 0;
+}
+.switch label input[type=checkbox]:checked + .lever {
+  background-color: var(--md-sys-color-primary);
+  border-color: var(--md-sys-color-primary);
+}
+.switch label input[type=checkbox]:checked + .lever:before, .switch label input[type=checkbox]:checked + .lever:after {
+  top: var(--gap-on);
+  left: calc(var(--track-width) - var(--size-on) - var(--gap-on) - 2 * var(--border-width));
+  width: var(--size-on);
+  height: var(--size-on);
+}
+.switch label .lever {
+  content: "";
+  display: inline-block;
+  position: relative;
+  width: var(--track-width);
+  height: var(--track-height);
+  border-style: solid;
+  border-width: 2px;
+  border-color: var(--md-sys-color-outline);
+  background-color: var(--md-sys-color-surface-variant);
+  border-radius: 15px;
+  margin-right: 10px;
+  transition: background 0.3s ease;
+  vertical-align: middle;
+  margin: 0 16px;
+}
+.switch label .lever:before, .switch label .lever:after {
+  content: "";
+  position: absolute;
+  display: inline-block;
+  width: var(--size-off);
+  height: var(--size-off);
+  border-radius: 50%;
+  left: var(--gap-off);
+  top: var(--gap-off);
+  transition: left 0.3s ease, background 0.3s ease, box-shadow 0.1s ease, transform 0.1s ease;
+}
+.switch label .lever:after {
+  height: var(--size-off);
+  width: var(--size-off);
+}
+
+input[type=checkbox]:not(:disabled) ~ .lever:active:before,
+input[type=checkbox]:not(:disabled).tabbed:focus ~ .lever::before,
+input[type=checkbox]:not(:disabled) ~ .lever:hover::before {
+  transform: scale(2.4);
+}
+
+input[type=checkbox]:checked:not(:disabled) ~ .lever:hover::before {
+  background-color: rgba(var(--md-sys-color-primary-numeric), 0.06);
+}
+
+input[type=checkbox]:checked:not(:disabled) ~ .lever:active::before,
+input[type=checkbox]:checked:not(:disabled).tabbed:focus ~ .lever::before {
+  background-color: rgba(var(--md-sys-color-primary-numeric), 0.18);
+}
+
+input[type=checkbox]:not(:disabled) ~ .lever:hover::before {
+  background-color: rgba(0, 0, 0, 0.04);
+}
+
+input[type=checkbox]:not(:disabled) ~ .lever:active:before,
+input[type=checkbox]:not(:disabled).tabbed:focus ~ .lever::before {
+  background-color: rgba(0, 0, 0, 0.12);
+}
+
+.switch input[type=checkbox][disabled] + .lever {
+  cursor: default;
+  opacity: 0.5;
+}
+
+select.browser-default {
+  opacity: 1;
+  color: var(--md-sys-color-on-background);
+}
+
+select {
+  opacity: 0;
+  background-color: var(--md-sys-color-surface);
+  width: 100%;
+  padding: 5px;
+  border: 1px solid var(--md-sys-color-outline-variant);
+  border-radius: 2px;
+  height: 3rem;
+}
+
+.select-wrapper {
+  /*
+  &.valid .helper-text[data-success],
+  &.invalid ~ .helper-text[data-error] {
+    @extend %hidden-text;
+  }
+
+  &.valid {
+    & > input.select-dropdown {
+      @extend %valid-input-style;
+    }
+    & ~ .helper-text:after {
+      //@extend %custom-success-message;
+    }
+  }
+
+  &.invalid {
+    & > input.select-dropdown,
+    & > input.select-dropdown:focus {
+      @extend %invalid-input-style;
+    }
+    & ~ .helper-text:after {
+      //@extend %custom-error-message;
+    }
+  }
+
+  &.valid + label,
+  &.invalid + label {
+    width: 100%;
+    pointer-events: none;
+  }
+  & + label:after {
+    //@extend %input-after-style;
+  }
+  */
+  position: relative;
+  /*
+  input.select-dropdown {    
+    &:focus {
+      border-bottom: 1px solid var(--md-sys-color-primary);
+    }
+    position: relative;
+    cursor: pointer;
+    background-color: transparent;
+    border: none;
+    border-bottom: 2px solid var(--md-sys-color-on-surface-variant);
+    outline: none;
+    height: 3rem;
+    line-height: 3rem;
+    width: 100%;
+    font-size: 16px;
+    margin: 0 0 8px 0;
+    padding: 0;
+    display: block;
+    user-select:none;
+    z-index: 1;
+    color: var(--md-sys-color-on-background);
+  }
+  */
+}
+.select-wrapper .caret {
+  position: absolute;
+  right: 0;
+  top: 0;
+  bottom: 0;
+  margin: auto 0;
+  z-index: 0;
+  fill: var(--md-sys-color-on-background);
+}
+.select-wrapper .hide-select {
+  width: 0;
+  height: 0;
+  overflow: hidden;
+  position: absolute;
+  top: 0;
+  z-index: -1;
+}
+
+select:disabled {
+  color: var(--md-sys-color-on-surface);
+}
+
+.select-wrapper.disabled + label {
+  color: var(--md-sys-color-on-surface);
+}
+.select-wrapper.disabled .caret {
+  fill: var(--md-sys-color-on-surface);
+}
+
+.select-wrapper input.select-dropdown:disabled {
+  color: var(--md-sys-color-on-surface);
+  cursor: default;
+  user-select: none;
+}
+
+.select-wrapper i {
+  color: var(--md-sys-color-on-surface);
+}
+
+.select-dropdown li.disabled,
+.select-dropdown li.disabled > span,
+.select-dropdown li.optgroup {
+  color: var(--md-sys-color-on-surface);
+}
+
+/*
+body.keyboard-focused {
+  .select-dropdown.dropdown-content li:focus {
+    //background-color: $select-option-focus;
+  }
+}
+
+.select-dropdown.dropdown-content {
+  li {
+    &:hover:not(.disabled) {
+      //background-color: $select-option-hover;
+    }
+
+    &.selected:not(.disabled) {
+      //background-color: $select-option-selected;
+    }
+  }
+}
+*/
+/*
+// Prefix Icons
+.prefix ~ .select-wrapper {
+  margin-left: 3rem;
+  width: 92%;
+  width: calc(100% - 3rem);
+}
+.prefix ~ label { margin-left: 3rem; }
+// Suffix Icons
+.suffix ~ .select-wrapper {
+  margin-right: 3rem;
+  width: 92%;
+  width: calc(100% - 3rem);
+}
+.suffix ~ label { margin-right: 3rem; }
+*/
+.select-dropdown li img {
+  height: 40px;
+  width: 40px;
+  margin: 5px 15px;
+  float: right;
+}
+
+.select-dropdown li.optgroup {
+  border-top: 1px solid rgba(0, 0, 0, 0.04);
+}
+.select-dropdown li.optgroup.selected > span {
+  color: var(--md-sys-color-on-background);
+}
+.select-dropdown li.optgroup > span {
+  color: var(--md-sys-color-on-surface-variant);
+}
+.select-dropdown li.optgroup ~ li.optgroup-option {
+  padding-left: 1rem;
+}
+
+/*
+.select-dropdown .selected {
+  color: red;
+}
+*/
+.file-field {
+  display: grid;
+  grid-template-columns: min-content auto;
+  gap: 10px;
+}
+.file-field .file-path-wrapper {
+  overflow: hidden;
+}
+.file-field input.file-path {
+  width: 100%;
+}
+.file-field .btn, .file-field .btn-large, .file-field .btn-small {
+  height: 3rem;
+  line-height: 3rem;
+}
+.file-field span {
+  cursor: pointer;
+}
+.file-field input[type=file] {
+  position: absolute;
+  top: 0;
+  right: 0;
+  left: 0;
+  bottom: 0;
+  cursor: pointer;
+  width: 100%;
+  margin: 0;
+  padding: 0;
+  opacity: 0;
+  font-size: 20px;
+  filter: alpha(opacity=0);
+}
+.file-field input[type=file]::-webkit-file-upload-button {
+  display: none;
+}
+
+.range-field {
+  position: relative;
+}
+
+input[type=range],
+input[type=range] + .thumb {
+  cursor: pointer;
+}
+
+input[type=range] {
+  position: relative;
+  background-color: transparent;
+  border: none;
+  outline: none;
+  width: 100%;
+  margin: 15px 0;
+  padding: 0;
+}
+input[type=range]:focus {
+  outline: none;
+}
+
+input[type=range] + .thumb {
+  position: absolute;
+  top: 10px;
+  left: 0;
+  border: none;
+  height: 0;
+  width: 0;
+  border-radius: 50%;
+  background-color: var(--md-sys-color-primary);
+  margin-left: 7px;
+  transform-origin: 50% 50%;
+  transform: rotate(-45deg);
+}
+input[type=range] + .thumb .value {
+  display: block;
+  width: 30px;
+  text-align: center;
+  color: var(--md-sys-color-primary);
+  font-size: 0;
+  transform: rotate(45deg);
+}
+input[type=range] + .thumb.active {
+  border-radius: 50% 50% 50% 0;
+}
+input[type=range] + .thumb.active .value {
+  color: var(--md-sys-color-on-primary);
+  margin-left: -1px;
+  margin-top: 8px;
+  font-size: 10px;
+}
+
+input[type=range] {
+  -webkit-appearance: none;
+}
+
+input[type=range]::-webkit-slider-runnable-track {
+  height: 3px;
+  border: none;
+}
+
+input[type=range]::-webkit-slider-thumb {
+  border: none;
+  height: 14px;
+  width: 14px;
+  border-radius: 50%;
+  background: var(--md-sys-color-primary);
+  transition: box-shadow 0.3s;
+  -webkit-appearance: none;
+  background-color: var(--md-sys-color-primary);
+  transform-origin: 50% 50%;
+  margin: -5px 0 0 0;
+}
+
+.keyboard-focused input[type=range]:focus:not(.active)::-webkit-slider-thumb {
+  box-shadow: 0 0 0 10px rgba(var(--md-sys-color-primary-numeric), 0.18);
+}
+
+input[type=range] {
+  /*required for proper track sizing in FF*/
+}
+
+input[type=range]::-moz-range-track {
+  height: 3px;
+  border: none;
+}
+
+input[type=range]::-moz-focus-inner {
+  border: 0;
+}
+
+input[type=range]::-moz-range-thumb {
+  border: none;
+  height: 14px;
+  width: 14px;
+  border-radius: 50%;
+  background: var(--md-sys-color-primary);
+  transition: box-shadow 0.3s;
+  margin-top: -5px;
+}
+
+input[type=range]:-moz-focusring {
+  outline: 1px solid #fff;
+  outline-offset: -1px;
+}
+
+.keyboard-focused input[type=range]:focus:not(.active)::-moz-range-thumb {
+  box-shadow: 0 0 0 10px rgba(var(--md-sys-color-primary-numeric), 0.18);
+}
+
+input[type=range]::-ms-track {
+  height: 3px;
+  background: transparent;
+  border-color: transparent;
+  border-width: 6px 0;
+  /*remove default tick marks*/
+  color: transparent;
+}
+
+input[type=range]::-ms-fill-lower,
+input[type=range]::-moz-range-progress {
+  background: var(--md-sys-color-primary);
+}
+
+input[type=range]::-ms-fill-upper,
+input[type=range]::-moz-range-track {
+  background: var(--md-sys-color-shadow-light);
+}
+
+input[type=range]::-ms-thumb {
+  border: none;
+  height: 14px;
+  width: 14px;
+  border-radius: 50%;
+  background: var(--md-sys-color-primary);
+  transition: box-shadow 0.3s;
+}
+
+.keyboard-focused input[type=range]:focus:not(.active)::-ms-thumb {
+  box-shadow: 0 0 0 10px rgba(var(--md-sys-color-primary-numeric), 0.18);
+}
+
+.table-of-contents {
+  list-style: none;
+}
+.table-of-contents.fixed {
+  position: fixed;
+}
+.table-of-contents li {
+  padding: 0;
+}
+.table-of-contents a {
+  display: inline-block;
+  font-weight: 400;
+  color: var(--md-sys-color-secondary);
+  padding-left: 16px;
+  height: 2rem;
+  line-height: 2rem;
+  border-left: 1px solid var(--md-sys-color-outline-variant);
+}
+.table-of-contents a:hover {
+  color: var(--md-sys-color-on-background);
+  padding-left: 15px;
+}
+.table-of-contents a.active {
+  color: var(--md-sys-color-primary);
+  font-weight: 500;
+  padding-left: 14px;
+  border-left: 2px solid var(--md-sys-color-primary);
+}
+
+/* This should be an UL-Element*/
+.sidenav {
+  --sidenav-width: 300px;
+  --sidenav-font-size: 14px;
+  --sidenav-padding: 16px;
+  --sidenav-item-height: 48px;
+  --sidenav-line-height: var(--sidenav-item-height);
+  position: fixed;
+  width: var(--sidenav-width);
+  left: 0;
+  top: 0;
+  margin: 0;
+  transform: translateX(-100%);
+  height: 100vh;
+  padding: 0;
+  z-index: 999;
+  overflow-y: auto;
+  will-change: transform;
+  backface-visibility: hidden;
+  transform: translateX(-105%);
+  user-select: none;
+  color: var(--md-sys-color-on-secondary-container);
+  background-color: var(--md-sys-color-surface);
+  /* Hover only on top row */
+  /*a:hover {
+    //color: red;
+    //background-color: var(--md-sys-color-on-secondary-container);
+    //md.sys.color.on-secondary-container
+  }*/
+}
+.sidenav.right-aligned {
+  right: 0;
+  transform: translateX(105%);
+  left: auto;
+  transform: translateX(100%);
+}
+.sidenav .collapsible {
+  margin: 0;
+}
+.sidenav a:focus {
+  background-color: rgba(0, 0, 0, 0.12);
+}
+.sidenav li.active > a:not(.collapsible-header):not(.btn):not(.btn-large):not(.btn-small):not(.btn-large):not(.btn-small):not(.btn-flat):not(.btn-large):not(.btn-floating) {
+  background-color: color-mix(in srgb, var(--md-sys-color-secondary) 10%, transparent);
+}
+.sidenav .collapsible-body > ul {
+  padding-left: 10px;
+}
+.sidenav li {
+  list-style: none;
+  display: grid;
+  align-content: center;
+}
+.sidenav li > a {
+  /* https://stackoverflow.com/questions/5848090/full-width-hover-background-for-nested-lists */
+  margin: 0 12px;
+  padding: 0 var(--sidenav-padding);
+  /*
+  min-width: 0;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  */
+  display: flex;
+  height: var(--sidenav-item-height);
+  font-size: var(--sidenav-font-size);
+  font-weight: 500;
+  align-items: center;
+  overflow: hidden;
+  border-radius: 100px;
+  /* TODO: Use special class in future like "mw-icon" */
+}
+.sidenav li > a:not(.btn):not(.btn-large):not(.btn-small):not(.btn-flat):not(.btn-large):not(.btn-floating) {
+  color: var(--md-sys-color-on-secondary-container);
+}
+.sidenav li > a:not(.btn):not(.btn-large):not(.btn-small):not(.btn-flat):not(.btn-large):not(.btn-floating):hover {
+  background-color: color-mix(in srgb, var(--md-sys-color-on-surface) 8%, transparent);
+}
+.sidenav li > a.btn, .sidenav li > a.btn-small, .sidenav li > a.btn-large, .sidenav li > a.btn-flat, .sidenav li > a.btn-floating {
+  margin: 10px 15px;
+}
+.sidenav li > a > .material-icons, .sidenav li > a > .material-symbols-outlined, .sidenav li > a > .material-symbols-rounded, .sidenav li > a > .material-symbols-sharp {
+  display: inline-flex;
+  vertical-align: middle;
+  margin-right: 12px;
+}
+.sidenav .divider {
+  margin: calc(var(--sidenav-padding) * 0.5) 0 0 0;
+}
+.sidenav .subheader {
+  cursor: initial;
+  pointer-events: none;
+  color: red;
+  font-size: var(--sidenav-font-size);
+  font-weight: 500;
+  line-height: var(--sidenav-line-height);
+}
+.sidenav .user-view {
+  position: relative;
+  padding: calc(var(--sidenav-padding) * 2) calc(var(--sidenav-padding) * 2) 0;
+  margin-bottom: calc(var(--sidenav-padding) * 0.5);
+}
+.sidenav .user-view > a {
+  height: auto;
+  padding: 0;
+}
+.sidenav .user-view > a:hover {
+  background-color: transparent;
+}
+.sidenav .user-view .background {
+  overflow: hidden;
+  position: absolute;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  z-index: -1;
+}
+.sidenav .user-view .circle, .sidenav .user-view .name, .sidenav .user-view .email {
+  display: block;
+}
+.sidenav .user-view .circle {
+  height: 64px;
+  width: 64px;
+}
+.sidenav .user-view .name,
+.sidenav .user-view .email {
+  font-size: var(--sidenav-font-size);
+  line-height: calc(var(--sidenav-line-height) * 0.5);
+}
+.sidenav .user-view .name {
+  margin-top: 16px;
+  font-weight: 500;
+}
+.sidenav .user-view .email {
+  padding-bottom: 16px;
+  font-weight: 400;
+}
+
+.drag-target {
+  height: 100%;
+  position: fixed;
+  top: 0;
+  left: 0;
+  z-index: 998;
+}
+.drag-target.right-aligned {
+  right: 0;
+}
+
+.sidenav.sidenav-fixed {
+  left: 0;
+  transform: translateX(0);
+  position: fixed;
+}
+.sidenav.sidenav-fixed.right-aligned {
+  right: 0;
+  left: auto;
+}
+
+@media only screen and (max-width : 992.99px) {
+  .sidenav.sidenav-fixed {
+    transform: translateX(-105%);
+  }
+  .sidenav.sidenav-fixed.right-aligned {
+    transform: translateX(105%);
+  }
+  .sidenav > a {
+    padding: 0 var(--sidenav-padding);
+  }
+  .sidenav .user-view {
+    padding: var(--sidenav-padding) var(--sidenav-padding) 0;
+  }
+}
+.sidenav .collapsible-body {
+  padding: 0;
+}
+
+.sidenav-overlay {
+  position: fixed;
+  top: 0;
+  left: 0;
+  right: 0;
+  opacity: 0;
+  height: 120vh;
+  background-color: rgba(0, 0, 0, 0.5);
+  z-index: 997;
+  display: none;
+}
+
+.sidenav .collapsible,
+.sidenav.sidenav-fixed .collapsible {
+  border: none;
+  box-shadow: none;
+}
+.sidenav .collapsible-header,
+.sidenav.sidenav-fixed .collapsible-header {
+  border: none;
+}
+.sidenav .collapsible-body,
+.sidenav.sidenav-fixed .collapsible-body {
+  border: none;
+}
+
+.progress {
+  position: relative;
+  height: 4px;
+  display: block;
+  width: 100%;
+  border-radius: 4px;
+  margin: 0.5rem 0 1rem 0;
+  overflow: hidden;
+  background-color: var(--md-sys-color-secondary-container);
+}
+.progress .determinate {
+  position: absolute;
+  top: 0;
+  left: 0;
+  bottom: 0;
+  background-color: var(--md-sys-color-primary);
+  transition: width 0.3s linear;
+}
+.progress .indeterminate {
+  background-color: var(--md-sys-color-primary);
+}
+.progress .indeterminate:before {
+  content: "";
+  position: absolute;
+  background-color: inherit;
+  top: 0;
+  left: 0;
+  bottom: 0;
+  will-change: left, right;
+  animation: indeterminate 2.1s cubic-bezier(0.65, 0.815, 0.735, 0.395) infinite;
+}
+.progress .indeterminate:after {
+  content: "";
+  position: absolute;
+  background-color: inherit;
+  top: 0;
+  left: 0;
+  bottom: 0;
+  will-change: left, right;
+  animation: indeterminate-short 2.1s cubic-bezier(0.165, 0.84, 0.44, 1) infinite;
+  animation-delay: 1.15s;
+}
+
+@keyframes indeterminate {
+  0% {
+    left: -35%;
+    right: 100%;
+  }
+  60% {
+    left: 100%;
+    right: -90%;
+  }
+  100% {
+    left: 100%;
+    right: -90%;
+  }
+}
+@keyframes indeterminate-short {
+  0% {
+    left: -200%;
+    right: 100%;
+  }
+  60% {
+    left: 107%;
+    right: -8%;
+  }
+  100% {
+    left: 107%;
+    right: -8%;
+  }
+}
+/*
+    @license
+    Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
+    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+    Code distributed by Google as part of the polymer project is also
+    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+ */
+/**************************/
+/* STYLES FOR THE SPINNER */
+/**************************/
+/*
+ * Constants:
+ *      STROKEWIDTH = 3px
+ *      ARCSIZE     = 270 degrees (amount of circle the arc takes up)
+ *      ARCTIME     = 1333ms (time it takes to expand and contract arc)
+ *      ARCSTARTROT = 216 degrees (how much the start location of the arc
+ *                                should rotate each time, 216 gives us a
+ *                                5 pointed star shape (it's 360/5 * 3).
+ *                                For a 7 pointed star, we might do
+ *                                360/7 * 3 = 154.286)
+ *      CONTAINERWIDTH = 28px
+ *      SHRINK_TIME = 400ms
+ */
+.preloader-wrapper {
+  display: inline-block;
+  position: relative;
+  width: 50px;
+  height: 50px;
+}
+.preloader-wrapper.small {
+  width: 36px;
+  height: 36px;
+}
+.preloader-wrapper.big {
+  width: 64px;
+  height: 64px;
+}
+.preloader-wrapper.active {
+  /* duration: 360 * ARCTIME / (ARCSTARTROT + (360-ARCSIZE)) */
+  -webkit-animation: container-rotate 1568ms linear infinite;
+  animation: container-rotate 1568ms linear infinite;
+}
+
+@-webkit-keyframes container-rotate {
+  to {
+    -webkit-transform: rotate(360deg);
+  }
+}
+@keyframes container-rotate {
+  to {
+    transform: rotate(360deg);
+  }
+}
+.spinner-layer {
+  position: absolute;
+  width: 100%;
+  height: 100%;
+  opacity: 0;
+  border-color: var(--md-sys-color-primary);
+}
+
+.spinner-blue,
+.spinner-blue-only {
+  border-color: #4285f4;
+}
+
+.spinner-red,
+.spinner-red-only {
+  border-color: #db4437;
+}
+
+.spinner-yellow,
+.spinner-yellow-only {
+  border-color: #f4b400;
+}
+
+.spinner-green,
+.spinner-green-only {
+  border-color: #0f9d58;
+}
+
+/**
+ * IMPORTANT NOTE ABOUT CSS ANIMATION PROPERTIES (keanulee):
+ *
+ * iOS Safari (tested on iOS 8.1) does not handle animation-delay very well - it doesn't
+ * guarantee that the animation will start _exactly_ after that value. So we avoid using
+ * animation-delay and instead set custom keyframes for each color (as redundant as it
+ * seems).
+ *
+ * We write out each animation in full (instead of separating animation-name,
+ * animation-duration, etc.) because under the polyfill, Safari does not recognize those
+ * specific properties properly, treats them as -webkit-animation, and overrides the
+ * other animation rules. See https://github.com/Polymer/platform/issues/53.
+ */
+.active .spinner-layer.spinner-blue {
+  /* durations: 4 * ARCTIME */
+  -webkit-animation: fill-unfill-rotate 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both, blue-fade-in-out 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both;
+  animation: fill-unfill-rotate 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both, blue-fade-in-out 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both;
+}
+
+.active .spinner-layer.spinner-red {
+  /* durations: 4 * ARCTIME */
+  -webkit-animation: fill-unfill-rotate 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both, red-fade-in-out 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both;
+  animation: fill-unfill-rotate 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both, red-fade-in-out 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both;
+}
+
+.active .spinner-layer.spinner-yellow {
+  /* durations: 4 * ARCTIME */
+  -webkit-animation: fill-unfill-rotate 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both, yellow-fade-in-out 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both;
+  animation: fill-unfill-rotate 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both, yellow-fade-in-out 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both;
+}
+
+.active .spinner-layer.spinner-green {
+  /* durations: 4 * ARCTIME */
+  -webkit-animation: fill-unfill-rotate 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both, green-fade-in-out 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both;
+  animation: fill-unfill-rotate 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both, green-fade-in-out 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both;
+}
+
+.active .spinner-layer,
+.active .spinner-layer.spinner-blue-only,
+.active .spinner-layer.spinner-red-only,
+.active .spinner-layer.spinner-yellow-only,
+.active .spinner-layer.spinner-green-only {
+  /* durations: 4 * ARCTIME */
+  opacity: 1;
+  -webkit-animation: fill-unfill-rotate 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both;
+  animation: fill-unfill-rotate 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both;
+}
+
+@-webkit-keyframes fill-unfill-rotate {
+  12.5% {
+    -webkit-transform: rotate(135deg);
+  } /* 0.5 * ARCSIZE */
+  25% {
+    -webkit-transform: rotate(270deg);
+  } /* 1   * ARCSIZE */
+  37.5% {
+    -webkit-transform: rotate(405deg);
+  } /* 1.5 * ARCSIZE */
+  50% {
+    -webkit-transform: rotate(540deg);
+  } /* 2   * ARCSIZE */
+  62.5% {
+    -webkit-transform: rotate(675deg);
+  } /* 2.5 * ARCSIZE */
+  75% {
+    -webkit-transform: rotate(810deg);
+  } /* 3   * ARCSIZE */
+  87.5% {
+    -webkit-transform: rotate(945deg);
+  } /* 3.5 * ARCSIZE */
+  to {
+    -webkit-transform: rotate(1080deg);
+  } /* 4   * ARCSIZE */
+}
+@keyframes fill-unfill-rotate {
+  12.5% {
+    transform: rotate(135deg);
+  } /* 0.5 * ARCSIZE */
+  25% {
+    transform: rotate(270deg);
+  } /* 1   * ARCSIZE */
+  37.5% {
+    transform: rotate(405deg);
+  } /* 1.5 * ARCSIZE */
+  50% {
+    transform: rotate(540deg);
+  } /* 2   * ARCSIZE */
+  62.5% {
+    transform: rotate(675deg);
+  } /* 2.5 * ARCSIZE */
+  75% {
+    transform: rotate(810deg);
+  } /* 3   * ARCSIZE */
+  87.5% {
+    transform: rotate(945deg);
+  } /* 3.5 * ARCSIZE */
+  to {
+    transform: rotate(1080deg);
+  } /* 4   * ARCSIZE */
+}
+@-webkit-keyframes blue-fade-in-out {
+  from {
+    opacity: 1;
+  }
+  25% {
+    opacity: 1;
+  }
+  26% {
+    opacity: 0;
+  }
+  89% {
+    opacity: 0;
+  }
+  90% {
+    opacity: 1;
+  }
+  100% {
+    opacity: 1;
+  }
+}
+@keyframes blue-fade-in-out {
+  from {
+    opacity: 1;
+  }
+  25% {
+    opacity: 1;
+  }
+  26% {
+    opacity: 0;
+  }
+  89% {
+    opacity: 0;
+  }
+  90% {
+    opacity: 1;
+  }
+  100% {
+    opacity: 1;
+  }
+}
+@-webkit-keyframes red-fade-in-out {
+  from {
+    opacity: 0;
+  }
+  15% {
+    opacity: 0;
+  }
+  25% {
+    opacity: 1;
+  }
+  50% {
+    opacity: 1;
+  }
+  51% {
+    opacity: 0;
+  }
+}
+@keyframes red-fade-in-out {
+  from {
+    opacity: 0;
+  }
+  15% {
+    opacity: 0;
+  }
+  25% {
+    opacity: 1;
+  }
+  50% {
+    opacity: 1;
+  }
+  51% {
+    opacity: 0;
+  }
+}
+@-webkit-keyframes yellow-fade-in-out {
+  from {
+    opacity: 0;
+  }
+  40% {
+    opacity: 0;
+  }
+  50% {
+    opacity: 1;
+  }
+  75% {
+    opacity: 1;
+  }
+  76% {
+    opacity: 0;
+  }
+}
+@keyframes yellow-fade-in-out {
+  from {
+    opacity: 0;
+  }
+  40% {
+    opacity: 0;
+  }
+  50% {
+    opacity: 1;
+  }
+  75% {
+    opacity: 1;
+  }
+  76% {
+    opacity: 0;
+  }
+}
+@-webkit-keyframes green-fade-in-out {
+  from {
+    opacity: 0;
+  }
+  65% {
+    opacity: 0;
+  }
+  75% {
+    opacity: 1;
+  }
+  90% {
+    opacity: 1;
+  }
+  100% {
+    opacity: 0;
+  }
+}
+@keyframes green-fade-in-out {
+  from {
+    opacity: 0;
+  }
+  65% {
+    opacity: 0;
+  }
+  75% {
+    opacity: 1;
+  }
+  90% {
+    opacity: 1;
+  }
+  100% {
+    opacity: 0;
+  }
+}
+/**
+ * Patch the gap that appear between the two adjacent div.circle-clipper while the
+ * spinner is rotating (appears on Chrome 38, Safari 7.1, and IE 11).
+ */
+.gap-patch {
+  position: absolute;
+  top: 0;
+  left: 45%;
+  width: 10%;
+  height: 100%;
+  overflow: hidden;
+  border-color: inherit;
+}
+
+.gap-patch .circle {
+  width: 1000%;
+  left: -450%;
+}
+
+.circle-clipper {
+  display: inline-block;
+  position: relative;
+  width: 50%;
+  height: 100%;
+  overflow: hidden;
+  border-color: inherit;
+}
+.circle-clipper .circle {
+  width: 200%;
+  height: 100%;
+  border-width: 3px; /* STROKEWIDTH */
+  border-style: solid;
+  border-color: inherit;
+  border-bottom-color: transparent !important;
+  border-radius: 50%;
+  -webkit-animation: none;
+  animation: none;
+  position: absolute;
+  top: 0;
+  right: 0;
+  bottom: 0;
+}
+.circle-clipper.left .circle {
+  left: 0;
+  border-right-color: transparent !important;
+  -webkit-transform: rotate(129deg);
+  transform: rotate(129deg);
+}
+.circle-clipper.right .circle {
+  left: -100%;
+  border-left-color: transparent !important;
+  -webkit-transform: rotate(-129deg);
+  transform: rotate(-129deg);
+}
+
+.active .circle-clipper.left .circle {
+  /* duration: ARCTIME */
+  -webkit-animation: left-spin 1333ms cubic-bezier(0.4, 0, 0.2, 1) infinite both;
+  animation: left-spin 1333ms cubic-bezier(0.4, 0, 0.2, 1) infinite both;
+}
+
+.active .circle-clipper.right .circle {
+  /* duration: ARCTIME */
+  -webkit-animation: right-spin 1333ms cubic-bezier(0.4, 0, 0.2, 1) infinite both;
+  animation: right-spin 1333ms cubic-bezier(0.4, 0, 0.2, 1) infinite both;
+}
+
+@-webkit-keyframes left-spin {
+  from {
+    -webkit-transform: rotate(130deg);
+  }
+  50% {
+    -webkit-transform: rotate(-5deg);
+  }
+  to {
+    -webkit-transform: rotate(130deg);
+  }
+}
+@keyframes left-spin {
+  from {
+    transform: rotate(130deg);
+  }
+  50% {
+    transform: rotate(-5deg);
+  }
+  to {
+    transform: rotate(130deg);
+  }
+}
+@-webkit-keyframes right-spin {
+  from {
+    -webkit-transform: rotate(-130deg);
+  }
+  50% {
+    -webkit-transform: rotate(5deg);
+  }
+  to {
+    -webkit-transform: rotate(-130deg);
+  }
+}
+@keyframes right-spin {
+  from {
+    transform: rotate(-130deg);
+  }
+  50% {
+    transform: rotate(5deg);
+  }
+  to {
+    transform: rotate(-130deg);
+  }
+}
+#spinnerContainer.cooldown {
+  /* duration: SHRINK_TIME */
+  -webkit-animation: container-rotate 1568ms linear infinite, fade-out 400ms cubic-bezier(0.4, 0, 0.2, 1);
+  animation: container-rotate 1568ms linear infinite, fade-out 400ms cubic-bezier(0.4, 0, 0.2, 1);
+}
+
+@-webkit-keyframes fade-out {
+  from {
+    opacity: 1;
+  }
+  to {
+    opacity: 0;
+  }
+}
+@keyframes fade-out {
+  from {
+    opacity: 1;
+  }
+  to {
+    opacity: 0;
+  }
+}
+.slider {
+  position: relative;
+  height: 400px;
+  width: 100%;
+}
+.slider.fullscreen {
+  height: 100%;
+  width: 100%;
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+}
+.slider.fullscreen ul.slides {
+  padding-left: 0;
+  list-style-type: none;
+  height: 100%;
+}
+.slider.fullscreen ul.indicators {
+  padding-left: 0;
+  list-style-type: none;
+  z-index: 2;
+  bottom: 30px;
+}
+.slider.fullscreen ul.indicators .indicator-item {
+  background-color: rgba(255, 255, 255, 0.45);
+}
+.slider.fullscreen ul.indicators .indicator-item.active {
+  background-color: var(--md-ref-palette-primary100);
+}
+.slider .slides {
+  background-color: var(--md-sys-color-surface);
+  margin: 0;
+  height: 400px;
+  padding-left: 0;
+  list-style-type: none;
+}
+.slider .slides li {
+  padding-left: 0;
+  list-style-type: none;
+  opacity: 0;
+  position: absolute;
+  top: 0;
+  left: 0;
+  z-index: 1;
+  width: 100%;
+  height: inherit;
+  overflow: hidden;
+}
+.slider .slides li img {
+  height: 100%;
+  width: 100%;
+  background-size: cover;
+  background-position: center;
+}
+.slider .slides li .caption {
+  color: #fff;
+  position: absolute;
+  top: 15%;
+  left: 15%;
+  width: 70%;
+  opacity: 0;
+}
+.slider .slides li .caption p {
+  color: rgba(255, 255, 255, 0.75);
+}
+.slider .slides li.active {
+  z-index: 2;
+}
+.slider .indicators {
+  padding-left: 0;
+  list-style-type: none;
+  position: absolute;
+  text-align: center;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  margin: 0;
+}
+.slider .indicators .indicator-item {
+  display: inline-block;
+  position: relative;
+  height: 16px;
+  width: 16px;
+  margin: 0 12px;
+}
+.slider .indicators .indicator-item-btn {
+  position: absolute;
+  top: 0;
+  left: 0;
+  cursor: pointer;
+  background-color: var(--md-sys-color-shadow-light);
+  transition: background-color 0.3s;
+  border-radius: 50%;
+  border-width: 0;
+  width: 100%;
+  height: 100%;
+}
+.slider .indicators .indicator-item-btn.active {
+  background-color: var(--md-sys-color-primary);
+}
+
+.carousel {
+  --carousel-height: 400px;
+  overflow: hidden;
+  position: relative;
+  width: 100%;
+  height: var(--carousel-height);
+  perspective: 500px;
+  transform-style: preserve-3d;
+  transform-origin: 0% 50%;
+}
+.carousel.carousel-slider {
+  top: 0;
+  left: 0;
+}
+.carousel.carousel-slider .carousel-fixed-item {
+  position: absolute;
+  left: 0;
+  right: 0;
+  bottom: 20px;
+  z-index: 1;
+}
+.carousel.carousel-slider .carousel-fixed-item.with-indicators {
+  bottom: 68px;
+}
+.carousel.carousel-slider .carousel-item {
+  width: 100%;
+  height: 100%;
+  min-height: var(--carousel-height);
+  position: absolute;
+  top: 0;
+  left: 0;
+}
+.carousel.carousel-slider .carousel-item h2 {
+  font-size: 24px;
+  font-weight: 500;
+  line-height: 32px;
+}
+.carousel.carousel-slider .carousel-item p {
+  font-size: 15px;
+}
+.carousel .carousel-item {
+  visibility: hidden;
+  width: calc(var(--carousel-height) * 0.5);
+  height: calc(var(--carousel-height) * 0.5);
+  position: absolute;
+  top: 0;
+  left: 0;
+}
+.carousel .carousel-item > img {
+  width: 100%;
+}
+.carousel .indicators {
+  padding-left: 0;
+  list-style-type: none;
+  position: absolute;
+  text-align: center;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  margin: 0;
+}
+.carousel .indicators .indicator-item {
+  display: inline-block;
+  position: relative;
+  cursor: pointer;
+  height: 8px;
+  width: 8px;
+  margin: 24px 4px;
+  background-color: rgba(255, 255, 255, 0.45);
+  transition: background-color 0.3s;
+  border-radius: 50%;
+}
+.carousel .indicators .indicator-item.active {
+  background-color: var(--md-ref-palette-primary100);
+}
+.carousel.scrolling .carousel-item .materialboxed,
+.carousel .carousel-item:not(.active) .materialboxed {
+  pointer-events: none;
+}
+
+.tap-target-wrapper {
+  width: 800px;
+  height: 800px;
+  position: fixed;
+  z-index: 1000;
+  visibility: hidden;
+  transition: visibility 0s 0.3s;
+}
+
+.tap-target-wrapper.open {
+  visibility: visible;
+  transition: visibility 0s;
+}
+.tap-target-wrapper.open .tap-target {
+  transform: scale(1);
+  opacity: 0.95;
+  transition: transform 0.3s cubic-bezier(0.42, 0, 0.58, 1), opacity 0.3s cubic-bezier(0.42, 0, 0.58, 1);
+}
+.tap-target-wrapper.open .tap-target-wave::before {
+  transform: scale(1);
+}
+.tap-target-wrapper.open .tap-target-wave::after {
+  visibility: visible;
+  animation: pulse-animation 1s cubic-bezier(0.24, 0, 0.38, 1) infinite;
+  transition: opacity 0.3s, transform 0.3s, visibility 0s 1s;
+}
+
+.tap-target {
+  position: absolute;
+  font-size: 1rem;
+  border-radius: 50%;
+  background-color: var(--md-sys-color-primary-container);
+  color: var(--md-sys-color-primary);
+  box-shadow: 0 20px 20px 0 rgba(0, 0, 0, 0.14), 0 10px 50px 0 rgba(0, 0, 0, 0.12), 0 30px 10px -20px rgba(0, 0, 0, 0.2);
+  width: 100%;
+  height: 100%;
+  opacity: 0;
+  transform: scale(0);
+  transition: transform 0.3s cubic-bezier(0.42, 0, 0.58, 1), opacity 0.3s cubic-bezier(0.42, 0, 0.58, 1);
+}
+
+.tap-target-content {
+  position: relative;
+  display: table-cell;
+}
+
+.tap-target-wave {
+  position: absolute;
+  border-radius: 50%;
+  z-index: 10001;
+}
+.tap-target-wave::before, .tap-target-wave::after {
+  content: "";
+  display: block;
+  position: absolute;
+  width: 100%;
+  height: 100%;
+  border-radius: 50%;
+  background-color: var(--md-sys-color-surface);
+}
+.tap-target-wave::before {
+  transform: scale(0);
+  transition: transform 0.3s;
+}
+.tap-target-wave::after {
+  visibility: hidden;
+  transition: opacity 0.3s, transform 0.3s, visibility 0s;
+  z-index: -1;
+}
+
+.tap-target-origin {
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%);
+  z-index: 10002;
+  position: absolute !important;
+}
+.tap-target-origin:not(.btn):not(.btn-large):not(.btn-small), .tap-target-origin:not(.btn):not(.btn-large):not(.btn-small):hover {
+  background: none;
+}
+
+@media only screen and (max-width: 600px) {
+  .tap-target, .tap-target-wrapper {
+    width: 600px;
+    height: 600px;
+  }
+}
+.pulse {
+  overflow: visible;
+  position: relative;
+}
+.pulse::before {
+  content: "";
+  display: block;
+  position: absolute;
+  pointer-events: none;
+  width: 100%;
+  height: 100%;
+  top: 0;
+  left: 0;
+  background-color: inherit;
+  border-radius: inherit;
+  transition: opacity 0.3s, transform 0.3s;
+  animation: pulse-animation 1s cubic-bezier(0.24, 0, 0.38, 1) infinite;
+  z-index: -1;
+}
+
+@keyframes pulse-animation {
+  0% {
+    opacity: 1;
+    transform: scale(1);
+  }
+  50% {
+    opacity: 0;
+    transform: scale(1.5);
+  }
+  100% {
+    opacity: 0;
+    transform: scale(1.5);
+  }
+}
+/* Modal */
+.datepicker-modal {
+  max-width: 325px;
+  min-width: 300px;
+  max-height: none;
+}
+
+.datepicker-container.modal-content {
+  display: flex;
+  flex-direction: column;
+  padding: 0;
+  background-color: var(--md-sys-color-surface);
+}
+
+.datepicker-controls {
+  display: flex;
+  justify-content: space-between;
+  width: 280px;
+  margin: 0 auto;
+}
+.datepicker-controls .selects-container {
+  display: flex;
+}
+.datepicker-controls .select-wrapper input {
+  border-bottom: none;
+  text-align: center;
+  margin: 0;
+}
+.datepicker-controls .select-wrapper input:focus {
+  border-bottom: none;
+}
+.datepicker-controls .select-wrapper .caret {
+  display: none;
+}
+.datepicker-controls .select-year input {
+  width: 50px;
+}
+.datepicker-controls .select-month input {
+  width: 80px;
+}
+.datepicker-controls .month-prev,
+.datepicker-controls .month-next {
+  display: inline-flex;
+  align-items: center;
+}
+.datepicker-controls .month-prev > svg,
+.datepicker-controls .month-next > svg {
+  fill: var(--md-sys-color-on-surface-variant);
+}
+
+.month-prev, .month-next {
+  margin-top: 4px;
+  cursor: pointer;
+  background-color: transparent;
+  border: none;
+}
+
+/* Date Display */
+.datepicker-date-display {
+  flex: 1 auto;
+  background-color: var(--md-sys-color-primary);
+  color: var(--md-sys-color-on-primary);
+  padding: 20px 22px;
+  font-weight: 500;
+}
+.datepicker-date-display .year-text {
+  display: block;
+  font-size: 1.5rem;
+  line-height: 25px;
+  color: var(--md-sys-color-on-primary);
+}
+.datepicker-date-display .date-text {
+  display: block;
+  font-size: 2.8rem;
+  line-height: 47px;
+  font-weight: 500;
+}
+
+/* Calendar */
+.datepicker-calendar-container {
+  flex: 2.5 auto;
+}
+
+.datepicker-table {
+  width: 280px;
+  font-size: 1rem;
+  margin: 0 auto;
+}
+.datepicker-table thead {
+  border-bottom: none;
+}
+.datepicker-table th {
+  padding: 10px 5px;
+  text-align: center;
+}
+.datepicker-table tr {
+  border: none;
+}
+.datepicker-table abbr {
+  text-decoration: none;
+  color: var(--md-sys-color-on-surface-variant);
+}
+.datepicker-table td {
+  color: var(--md-sys-color-on-background);
+  border-radius: 50%;
+  padding: 0;
+}
+.datepicker-table td.is-today {
+  color: var(--md-sys-color-primary);
+}
+.datepicker-table td.is-selected {
+  background-color: var(--md-sys-color-primary);
+  color: var(--md-sys-color-on-primary);
+}
+.datepicker-table td.is-outside-current-month, .datepicker-table td.is-disabled {
+  color: var(--md-sys-color-on-surface);
+  pointer-events: none;
+}
+
+.datepicker-day-button {
+  background-color: transparent;
+  border: none;
+  line-height: 38px;
+  display: block;
+  width: 100%;
+  border-radius: 50%;
+  padding: 0 5px;
+  cursor: pointer;
+  color: inherit;
+}
+.datepicker-day-button:hover {
+  background-color: rgba(var(--md-sys-color-primary-numeric), 0.06);
+}
+.datepicker-day-button:focus {
+  background-color: rgba(var(--md-sys-color-primary-numeric), 0.18);
+}
+
+/* Footer */
+.datepicker-footer {
+  width: 280px;
+  margin: 0 auto;
+  padding-bottom: 5px;
+  display: flex;
+  justify-content: space-between;
+}
+
+.datepicker-cancel,
+.datepicker-clear,
+.datepicker-today,
+.datepicker-done {
+  color: var(--md-sys-color-primary);
+  padding: 0 1rem;
+}
+
+.datepicker-clear {
+  color: var(--md-sys-color-error);
+}
+
+/* Media Queries */
+@media only screen and (min-width : 601px) {
+  .datepicker-modal {
+    max-width: 625px;
+  }
+  .datepicker-container.modal-content {
+    flex-direction: row;
+  }
+  .datepicker-date-display {
+    flex: 0 1 270px;
+  }
+  .datepicker-controls,
+  .datepicker-table,
+  .datepicker-footer {
+    width: 320px;
+  }
+  .datepicker-day-button {
+    line-height: 44px;
+  }
+}
+/* Timepicker Containers */
+.timepicker-modal {
+  max-width: 325px;
+  max-height: none;
+}
+
+.timepicker-container.modal-content {
+  display: flex;
+  flex-direction: column;
+  padding: 0;
+}
+
+.text-primary {
+  color: var(--md-sys-color-on-primary);
+}
+
+/* Clock Digital Display */
+.timepicker-digital-display {
+  width: 200px;
+  flex: 1 auto;
+  background-color: var(--md-sys-color-primary);
+  padding: 10px;
+  font-weight: 300;
+}
+
+.timepicker-text-container {
+  font-size: 4rem;
+  font-weight: bold;
+  text-align: center;
+  color: var(--font-on-primary-color-medium);
+  font-weight: 400;
+  position: relative;
+  user-select: none;
+}
+.timepicker-text-container input[type=text] {
+  height: 4rem;
+  color: rgba(255, 255, 255, 0.6);
+  border-bottom: 0px;
+  font-size: 4rem;
+  direction: ltr;
+}
+
+.timepicker-input-hours,
+.timepicker-input-minutes,
+.timepicker-span-am-pm div {
+  cursor: pointer;
+}
+
+input[type=text].timepicker-input-hours {
+  text-align: right;
+  width: 28%;
+  margin-right: 3px;
+}
+
+input[type=text].timepicker-input-minutes {
+  width: 33%;
+  margin-left: 3px;
+}
+
+input[type=text].text-primary {
+  color: rgb(255, 255, 255);
+}
+
+.timepicker-display-am-pm {
+  font-size: 1.3rem;
+  position: absolute;
+  right: 1rem;
+  bottom: 1rem;
+  font-weight: 400;
+}
+
+/* Analog Clock Display */
+.timepicker-analog-display {
+  flex: 2.5 auto;
+  background-color: var(--md-sys-color-surface);
+}
+
+.timepicker-plate {
+  background-color: rgba(0, 0, 0, 0.09);
+  border-radius: 50%;
+  width: 270px;
+  height: 270px;
+  overflow: visible;
+  position: relative;
+  margin: auto;
+  margin-top: 25px;
+  margin-bottom: 5px;
+  user-select: none;
+}
+
+.timepicker-canvas,
+.timepicker-dial {
+  position: absolute;
+  left: 0;
+  right: 0;
+  top: 0;
+  bottom: 0;
+}
+
+.timepicker-minutes {
+  visibility: hidden;
+}
+
+.timepicker-tick {
+  border-radius: 50%;
+  color: var(--md-sys-color-on-background);
+  line-height: 40px;
+  text-align: center;
+  width: 40px;
+  height: 40px;
+  position: absolute;
+  cursor: pointer;
+  font-size: 15px;
+}
+
+.timepicker-tick.active,
+.timepicker-tick:hover {
+  background-color: rgba(var(--md-sys-color-primary-numeric), 0.06);
+}
+
+.timepicker-dial {
+  transition: transform 350ms, opacity 350ms;
+}
+
+.timepicker-dial-out {
+  opacity: 0;
+}
+.timepicker-dial-out.timepicker-hours {
+  transform: scale(1.1, 1.1);
+}
+.timepicker-dial-out.timepicker-minutes {
+  transform: scale(0.8, 0.8);
+}
+
+.timepicker-canvas {
+  transition: opacity 175ms;
+}
+.timepicker-canvas line {
+  stroke: var(--md-sys-color-primary);
+  stroke-width: 4;
+  stroke-linecap: round;
+}
+
+.timepicker-canvas-out {
+  opacity: 0.25;
+}
+
+.timepicker-canvas-bearing {
+  stroke: none;
+  fill: var(--md-sys-color-primary);
+}
+
+.timepicker-canvas-bg {
+  stroke: none;
+  fill: var(--md-sys-color-primary);
+}
+
+/* Footer */
+.timepicker-footer {
+  margin: 0 auto;
+  padding: 5px 1rem;
+  display: flex;
+  justify-content: space-between;
+}
+
+.timepicker-clear {
+  color: var(--md-sys-color-error);
+}
+
+.timepicker-close {
+  color: var(--md-sys-color-primary);
+}
+
+.timepicker-clear,
+.timepicker-close {
+  padding: 0 20px;
+}
+
+/* Media Queries */
+@media only screen and (min-width : 601px) {
+  .timepicker-modal {
+    max-width: 600px;
+  }
+  .timepicker-container.modal-content {
+    flex-direction: row;
+  }
+  .timepicker-text-container {
+    top: 32%;
+  }
+  .timepicker-display-am-pm {
+    position: relative;
+    right: auto;
+    bottom: auto;
+    text-align: center;
+    margin-top: 1.2rem;
+  }
+}
\ No newline at end of file
diff --git a/test/js/bun/css/files/normalize.css b/test/js/bun/css/files/normalize.css
new file mode 100644
index 0000000000..b6eb821659
--- /dev/null
+++ b/test/js/bun/css/files/normalize.css
@@ -0,0 +1,349 @@
+/*! normalize.css v8.0.1 | MIT License | github.com/necolas/normalize.css */
+
+/* Document
+   ========================================================================== */
+
+/**
+ * 1. Correct the line height in all browsers.
+ * 2. Prevent adjustments of font size after orientation changes in iOS.
+ */
+
+ html {
+  line-height: 1.15; /* 1 */
+  -webkit-text-size-adjust: 100%; /* 2 */
+}
+
+/* Sections
+   ========================================================================== */
+
+/**
+ * Remove the margin in all browsers.
+ */
+
+body {
+  margin: 0;
+}
+
+/**
+ * Render the `main` element consistently in IE.
+ */
+
+main {
+  display: block;
+}
+
+/**
+ * Correct the font size and margin on `h1` elements within `section` and
+ * `article` contexts in Chrome, Firefox, and Safari.
+ */
+
+h1 {
+  font-size: 2em;
+  margin: 0.67em 0;
+}
+
+/* Grouping content
+   ========================================================================== */
+
+/**
+ * 1. Add the correct box sizing in Firefox.
+ * 2. Show the overflow in Edge and IE.
+ */
+
+hr {
+  box-sizing: content-box; /* 1 */
+  height: 0; /* 1 */
+  overflow: visible; /* 2 */
+}
+
+/**
+ * 1. Correct the inheritance and scaling of font size in all browsers.
+ * 2. Correct the odd `em` font sizing in all browsers.
+ */
+
+pre {
+  font-family: monospace, monospace; /* 1 */
+  font-size: 1em; /* 2 */
+}
+
+/* Text-level semantics
+   ========================================================================== */
+
+/**
+ * Remove the gray background on active links in IE 10.
+ */
+
+a {
+  background-color: transparent;
+}
+
+/**
+ * 1. Remove the bottom border in Chrome 57-
+ * 2. Add the correct text decoration in Chrome, Edge, IE, Opera, and Safari.
+ */
+
+abbr[title] {
+  border-bottom: none; /* 1 */
+  text-decoration: underline; /* 2 */
+  text-decoration: underline dotted; /* 2 */
+}
+
+/**
+ * Add the correct font weight in Chrome, Edge, and Safari.
+ */
+
+b,
+strong {
+  font-weight: bolder;
+}
+
+/**
+ * 1. Correct the inheritance and scaling of font size in all browsers.
+ * 2. Correct the odd `em` font sizing in all browsers.
+ */
+
+code,
+kbd,
+samp {
+  font-family: monospace, monospace; /* 1 */
+  font-size: 1em; /* 2 */
+}
+
+/**
+ * Add the correct font size in all browsers.
+ */
+
+small {
+  font-size: 80%;
+}
+
+/**
+ * Prevent `sub` and `sup` elements from affecting the line height in
+ * all browsers.
+ */
+
+sub,
+sup {
+  font-size: 75%;
+  line-height: 0;
+  position: relative;
+  vertical-align: baseline;
+}
+
+sub {
+  bottom: -0.25em;
+}
+
+sup {
+  top: -0.5em;
+}
+
+/* Embedded content
+   ========================================================================== */
+
+/**
+ * Remove the border on images inside links in IE 10.
+ */
+
+img {
+  border-style: none;
+}
+
+/* Forms
+   ========================================================================== */
+
+/**
+ * 1. Change the font styles in all browsers.
+ * 2. Remove the margin in Firefox and Safari.
+ */
+
+button,
+input,
+optgroup,
+select,
+textarea {
+  font-family: inherit; /* 1 */
+  font-size: 100%; /* 1 */
+  line-height: 1.15; /* 1 */
+  margin: 0; /* 2 */
+}
+
+/**
+ * Show the overflow in IE.
+ * 1. Show the overflow in Edge.
+ */
+
+button,
+input { /* 1 */
+  overflow: visible;
+}
+
+/**
+ * Remove the inheritance of text transform in Edge, Firefox, and IE.
+ * 1. Remove the inheritance of text transform in Firefox.
+ */
+
+button,
+select { /* 1 */
+  text-transform: none;
+}
+
+/**
+ * Correct the inability to style clickable types in iOS and Safari.
+ */
+
+button,
+[type="button"],
+[type="reset"],
+[type="submit"] {
+  -webkit-appearance: button;
+}
+
+/**
+ * Remove the inner border and padding in Firefox.
+ */
+
+button::-moz-focus-inner,
+[type="button"]::-moz-focus-inner,
+[type="reset"]::-moz-focus-inner,
+[type="submit"]::-moz-focus-inner {
+  border-style: none;
+  padding: 0;
+}
+
+/**
+ * Restore the focus styles unset by the previous rule.
+ */
+
+button:-moz-focusring,
+[type="button"]:-moz-focusring,
+[type="reset"]:-moz-focusring,
+[type="submit"]:-moz-focusring {
+  outline: 1px dotted ButtonText;
+}
+
+/**
+ * Correct the padding in Firefox.
+ */
+
+fieldset {
+  padding: 0.35em 0.75em 0.625em;
+}
+
+/**
+ * 1. Correct the text wrapping in Edge and IE.
+ * 2. Correct the color inheritance from `fieldset` elements in IE.
+ * 3. Remove the padding so developers are not caught out when they zero out
+ *    `fieldset` elements in all browsers.
+ */
+
+legend {
+  box-sizing: border-box; /* 1 */
+  color: inherit; /* 2 */
+  display: table; /* 1 */
+  max-width: 100%; /* 1 */
+  padding: 0; /* 3 */
+  white-space: normal; /* 1 */
+}
+
+/**
+ * Add the correct vertical alignment in Chrome, Firefox, and Opera.
+ */
+
+progress {
+  vertical-align: baseline;
+}
+
+/**
+ * Remove the default vertical scrollbar in IE 10+.
+ */
+
+textarea {
+  overflow: auto;
+}
+
+/**
+ * 1. Add the correct box sizing in IE 10.
+ * 2. Remove the padding in IE 10.
+ */
+
+[type="checkbox"],
+[type="radio"] {
+  box-sizing: border-box; /* 1 */
+  padding: 0; /* 2 */
+}
+
+/**
+ * Correct the cursor style of increment and decrement buttons in Chrome.
+ */
+
+[type="number"]::-webkit-inner-spin-button,
+[type="number"]::-webkit-outer-spin-button {
+  height: auto;
+}
+
+/**
+ * 1. Correct the odd appearance in Chrome and Safari.
+ * 2. Correct the outline style in Safari.
+ */
+
+[type="search"] {
+  -webkit-appearance: textfield; /* 1 */
+  outline-offset: -2px; /* 2 */
+}
+
+/**
+ * Remove the inner padding in Chrome and Safari on macOS.
+ */
+
+[type="search"]::-webkit-search-decoration {
+  -webkit-appearance: none;
+}
+
+/**
+ * 1. Correct the inability to style clickable types in iOS and Safari.
+ * 2. Change font properties to `inherit` in Safari.
+ */
+
+::-webkit-file-upload-button {
+  -webkit-appearance: button; /* 1 */
+  font: inherit; /* 2 */
+}
+
+/* Interactive
+   ========================================================================== */
+
+/*
+ * Add the correct display in Edge, IE 10+, and Firefox.
+ */
+
+details {
+  display: block;
+}
+
+/*
+ * Add the correct display in all browsers.
+ */
+
+summary {
+  display: list-item;
+}
+
+/* Misc
+   ========================================================================== */
+
+/**
+ * Add the correct display in IE 10+.
+ */
+
+template {
+  display: none;
+}
+
+/**
+ * Add the correct display in IE 10.
+ */
+
+[hidden] {
+  display: none;
+}
\ No newline at end of file
diff --git a/test/js/bun/css/files/pico.css b/test/js/bun/css/files/pico.css
new file mode 100644
index 0000000000..0610d5f532
--- /dev/null
+++ b/test/js/bun/css/files/pico.css
@@ -0,0 +1,2802 @@
+@charset "UTF-8";
+/*!
+ * Pico CSS ✨ v2.0.6 (https://picocss.com)
+ * Copyright 2019-2024 - Licensed under MIT
+ */
+/**
+ * Styles
+ */
+:root {
+  --pico-font-family-emoji: "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+  --pico-font-family-sans-serif: system-ui, "Segoe UI", Roboto, Oxygen, Ubuntu, Cantarell, Helvetica, Arial, "Helvetica Neue", sans-serif, var(--pico-font-family-emoji);
+  --pico-font-family-monospace: ui-monospace, SFMono-Regular, "SF Mono", Menlo, Consolas, "Liberation Mono", monospace, var(--pico-font-family-emoji);
+  --pico-font-family: var(--pico-font-family-sans-serif);
+  --pico-line-height: 1.5;
+  --pico-font-weight: 400;
+  --pico-font-size: 100%;
+  --pico-text-underline-offset: 0.1rem;
+  --pico-border-radius: 0.25rem;
+  --pico-border-width: 0.0625rem;
+  --pico-outline-width: 0.125rem;
+  --pico-transition: 0.2s ease-in-out;
+  --pico-spacing: 1rem;
+  --pico-typography-spacing-vertical: 1rem;
+  --pico-block-spacing-vertical: var(--pico-spacing);
+  --pico-block-spacing-horizontal: var(--pico-spacing);
+  --pico-grid-column-gap: var(--pico-spacing);
+  --pico-grid-row-gap: var(--pico-spacing);
+  --pico-form-element-spacing-vertical: 0.75rem;
+  --pico-form-element-spacing-horizontal: 1rem;
+  --pico-group-box-shadow: 0 0 0 rgba(0, 0, 0, 0);
+  --pico-group-box-shadow-focus-with-button: 0 0 0 var(--pico-outline-width) var(--pico-primary-focus);
+  --pico-group-box-shadow-focus-with-input: 0 0 0 0.0625rem var(--pico-form-element-border-color);
+  --pico-modal-overlay-backdrop-filter: blur(0.375rem);
+  --pico-nav-element-spacing-vertical: 1rem;
+  --pico-nav-element-spacing-horizontal: 0.5rem;
+  --pico-nav-link-spacing-vertical: 0.5rem;
+  --pico-nav-link-spacing-horizontal: 0.5rem;
+  --pico-nav-breadcrumb-divider: ">";
+  --pico-icon-checkbox: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' viewBox='0 0 24 24' fill='none' stroke='rgb(255, 255, 255)' stroke-width='4' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpolyline points='20 6 9 17 4 12'%3E%3C/polyline%3E%3C/svg%3E");
+  --pico-icon-minus: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' viewBox='0 0 24 24' fill='none' stroke='rgb(255, 255, 255)' stroke-width='4' stroke-linecap='round' stroke-linejoin='round'%3E%3Cline x1='5' y1='12' x2='19' y2='12'%3E%3C/line%3E%3C/svg%3E");
+  --pico-icon-chevron: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' viewBox='0 0 24 24' fill='none' stroke='rgb(136, 145, 164)' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpolyline points='6 9 12 15 18 9'%3E%3C/polyline%3E%3C/svg%3E");
+  --pico-icon-date: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' viewBox='0 0 24 24' fill='none' stroke='rgb(136, 145, 164)' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3E%3Crect x='3' y='4' width='18' height='18' rx='2' ry='2'%3E%3C/rect%3E%3Cline x1='16' y1='2' x2='16' y2='6'%3E%3C/line%3E%3Cline x1='8' y1='2' x2='8' y2='6'%3E%3C/line%3E%3Cline x1='3' y1='10' x2='21' y2='10'%3E%3C/line%3E%3C/svg%3E");
+  --pico-icon-time: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' viewBox='0 0 24 24' fill='none' stroke='rgb(136, 145, 164)' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3E%3Ccircle cx='12' cy='12' r='10'%3E%3C/circle%3E%3Cpolyline points='12 6 12 12 16 14'%3E%3C/polyline%3E%3C/svg%3E");
+  --pico-icon-search: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' viewBox='0 0 24 24' fill='none' stroke='rgb(136, 145, 164)' stroke-width='1.5' stroke-linecap='round' stroke-linejoin='round'%3E%3Ccircle cx='11' cy='11' r='8'%3E%3C/circle%3E%3Cline x1='21' y1='21' x2='16.65' y2='16.65'%3E%3C/line%3E%3C/svg%3E");
+  --pico-icon-close: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' viewBox='0 0 24 24' fill='none' stroke='rgb(136, 145, 164)' stroke-width='3' stroke-linecap='round' stroke-linejoin='round'%3E%3Cline x1='18' y1='6' x2='6' y2='18'%3E%3C/line%3E%3Cline x1='6' y1='6' x2='18' y2='18'%3E%3C/line%3E%3C/svg%3E");
+  --pico-icon-loading: url("data:image/svg+xml,%3Csvg fill='none' height='24' width='24' viewBox='0 0 24 24' xmlns='http://www.w3.org/2000/svg' %3E%3Cstyle%3E g %7B animation: rotate 2s linear infinite; transform-origin: center center; %7D circle %7B stroke-dasharray: 75,100; stroke-dashoffset: -5; animation: dash 1.5s ease-in-out infinite; stroke-linecap: round; %7D @keyframes rotate %7B 0%25 %7B transform: rotate(0deg); %7D 100%25 %7B transform: rotate(360deg); %7D %7D @keyframes dash %7B 0%25 %7B stroke-dasharray: 1,100; stroke-dashoffset: 0; %7D 50%25 %7B stroke-dasharray: 44.5,100; stroke-dashoffset: -17.5; %7D 100%25 %7B stroke-dasharray: 44.5,100; stroke-dashoffset: -62; %7D %7D %3C/style%3E%3Cg%3E%3Ccircle cx='12' cy='12' r='10' fill='none' stroke='rgb(136, 145, 164)' stroke-width='4' /%3E%3C/g%3E%3C/svg%3E");
+}
+@media (min-width: 576px) {
+  :root {
+    --pico-font-size: 106.25%;
+  }
+}
+@media (min-width: 768px) {
+  :root {
+    --pico-font-size: 112.5%;
+  }
+}
+@media (min-width: 1024px) {
+  :root {
+    --pico-font-size: 118.75%;
+  }
+}
+@media (min-width: 1280px) {
+  :root {
+    --pico-font-size: 125%;
+  }
+}
+@media (min-width: 1536px) {
+  :root {
+    --pico-font-size: 131.25%;
+  }
+}
+
+a {
+  --pico-text-decoration: underline;
+}
+a.secondary, a.contrast {
+  --pico-text-decoration: underline;
+}
+
+small {
+  --pico-font-size: 0.875em;
+}
+
+h1,
+h2,
+h3,
+h4,
+h5,
+h6 {
+  --pico-font-weight: 700;
+}
+
+h1 {
+  --pico-font-size: 2rem;
+  --pico-line-height: 1.125;
+  --pico-typography-spacing-top: 3rem;
+}
+
+h2 {
+  --pico-font-size: 1.75rem;
+  --pico-line-height: 1.15;
+  --pico-typography-spacing-top: 2.625rem;
+}
+
+h3 {
+  --pico-font-size: 1.5rem;
+  --pico-line-height: 1.175;
+  --pico-typography-spacing-top: 2.25rem;
+}
+
+h4 {
+  --pico-font-size: 1.25rem;
+  --pico-line-height: 1.2;
+  --pico-typography-spacing-top: 1.874rem;
+}
+
+h5 {
+  --pico-font-size: 1.125rem;
+  --pico-line-height: 1.225;
+  --pico-typography-spacing-top: 1.6875rem;
+}
+
+h6 {
+  --pico-font-size: 1rem;
+  --pico-line-height: 1.25;
+  --pico-typography-spacing-top: 1.5rem;
+}
+
+thead th,
+thead td,
+tfoot th,
+tfoot td {
+  --pico-font-weight: 600;
+  --pico-border-width: 0.1875rem;
+}
+
+pre,
+code,
+kbd,
+samp {
+  --pico-font-family: var(--pico-font-family-monospace);
+}
+
+kbd {
+  --pico-font-weight: bolder;
+}
+
+input:not([type=submit],
+[type=button],
+[type=reset],
+[type=checkbox],
+[type=radio],
+[type=file]),
+:where(select, textarea) {
+  --pico-outline-width: 0.0625rem;
+}
+
+[type=search] {
+  --pico-border-radius: 5rem;
+}
+
+[type=checkbox],
+[type=radio] {
+  --pico-border-width: 0.125rem;
+}
+
+[type=checkbox][role=switch] {
+  --pico-border-width: 0.1875rem;
+}
+
+details.dropdown summary:not([role=button]) {
+  --pico-outline-width: 0.0625rem;
+}
+
+nav details.dropdown summary:focus-visible {
+  --pico-outline-width: 0.125rem;
+}
+
+[role=search] {
+  --pico-border-radius: 5rem;
+}
+
+[role=search]:has(button.secondary:focus,
+[type=submit].secondary:focus,
+[type=button].secondary:focus,
+[role=button].secondary:focus),
+[role=group]:has(button.secondary:focus,
+[type=submit].secondary:focus,
+[type=button].secondary:focus,
+[role=button].secondary:focus) {
+  --pico-group-box-shadow-focus-with-button: 0 0 0 var(--pico-outline-width) var(--pico-secondary-focus);
+}
+[role=search]:has(button.contrast:focus,
+[type=submit].contrast:focus,
+[type=button].contrast:focus,
+[role=button].contrast:focus),
+[role=group]:has(button.contrast:focus,
+[type=submit].contrast:focus,
+[type=button].contrast:focus,
+[role=button].contrast:focus) {
+  --pico-group-box-shadow-focus-with-button: 0 0 0 var(--pico-outline-width) var(--pico-contrast-focus);
+}
+[role=search] button,
+[role=search] [type=submit],
+[role=search] [type=button],
+[role=search] [role=button],
+[role=group] button,
+[role=group] [type=submit],
+[role=group] [type=button],
+[role=group] [role=button] {
+  --pico-form-element-spacing-horizontal: 2rem;
+}
+
+details summary[role=button]:not(.outline)::after {
+  filter: brightness(0) invert(1);
+}
+
+[aria-busy=true]:not(input, select, textarea):is(button, [type=submit], [type=button], [type=reset], [role=button]):not(.outline)::before {
+  filter: brightness(0) invert(1);
+}
+
+/**
+ * Color schemes
+ */
+[data-theme=light],
+:root:not([data-theme=dark]) {
+  --pico-background-color: #fff;
+  --pico-color: #373c44;
+  --pico-text-selection-color: rgba(2, 154, 232, 0.25);
+  --pico-muted-color: #646b79;
+  --pico-muted-border-color: #e7eaf0;
+  --pico-primary: #0172ad;
+  --pico-primary-background: #0172ad;
+  --pico-primary-border: var(--pico-primary-background);
+  --pico-primary-underline: rgba(1, 114, 173, 0.5);
+  --pico-primary-hover: #015887;
+  --pico-primary-hover-background: #02659a;
+  --pico-primary-hover-border: var(--pico-primary-hover-background);
+  --pico-primary-hover-underline: var(--pico-primary-hover);
+  --pico-primary-focus: rgba(2, 154, 232, 0.5);
+  --pico-primary-inverse: #fff;
+  --pico-secondary: #5d6b89;
+  --pico-secondary-background: #525f7a;
+  --pico-secondary-border: var(--pico-secondary-background);
+  --pico-secondary-underline: rgba(93, 107, 137, 0.5);
+  --pico-secondary-hover: #48536b;
+  --pico-secondary-hover-background: #48536b;
+  --pico-secondary-hover-border: var(--pico-secondary-hover-background);
+  --pico-secondary-hover-underline: var(--pico-secondary-hover);
+  --pico-secondary-focus: rgba(93, 107, 137, 0.25);
+  --pico-secondary-inverse: #fff;
+  --pico-contrast: #181c25;
+  --pico-contrast-background: #181c25;
+  --pico-contrast-border: var(--pico-contrast-background);
+  --pico-contrast-underline: rgba(24, 28, 37, 0.5);
+  --pico-contrast-hover: #000;
+  --pico-contrast-hover-background: #000;
+  --pico-contrast-hover-border: var(--pico-contrast-hover-background);
+  --pico-contrast-hover-underline: var(--pico-secondary-hover);
+  --pico-contrast-focus: rgba(93, 107, 137, 0.25);
+  --pico-contrast-inverse: #fff;
+  --pico-box-shadow: 0.0145rem 0.029rem 0.174rem rgba(129, 145, 181, 0.01698), 0.0335rem 0.067rem 0.402rem rgba(129, 145, 181, 0.024), 0.0625rem 0.125rem 0.75rem rgba(129, 145, 181, 0.03), 0.1125rem 0.225rem 1.35rem rgba(129, 145, 181, 0.036), 0.2085rem 0.417rem 2.502rem rgba(129, 145, 181, 0.04302), 0.5rem 1rem 6rem rgba(129, 145, 181, 0.06), 0 0 0 0.0625rem rgba(129, 145, 181, 0.015);
+  --pico-h1-color: #2d3138;
+  --pico-h2-color: #373c44;
+  --pico-h3-color: #424751;
+  --pico-h4-color: #4d535e;
+  --pico-h5-color: #5c6370;
+  --pico-h6-color: #646b79;
+  --pico-mark-background-color: #fde7c0;
+  --pico-mark-color: #0f1114;
+  --pico-ins-color: #1d6a54;
+  --pico-del-color: #883935;
+  --pico-blockquote-border-color: var(--pico-muted-border-color);
+  --pico-blockquote-footer-color: var(--pico-muted-color);
+  --pico-button-box-shadow: 0 0 0 rgba(0, 0, 0, 0);
+  --pico-button-hover-box-shadow: 0 0 0 rgba(0, 0, 0, 0);
+  --pico-table-border-color: var(--pico-muted-border-color);
+  --pico-table-row-stripped-background-color: rgba(111, 120, 135, 0.0375);
+  --pico-code-background-color: #f3f5f7;
+  --pico-code-color: #646b79;
+  --pico-code-kbd-background-color: var(--pico-color);
+  --pico-code-kbd-color: var(--pico-background-color);
+  --pico-form-element-background-color: #fbfcfc;
+  --pico-form-element-selected-background-color: #dfe3eb;
+  --pico-form-element-border-color: #cfd5e2;
+  --pico-form-element-color: #23262c;
+  --pico-form-element-placeholder-color: var(--pico-muted-color);
+  --pico-form-element-active-background-color: #fff;
+  --pico-form-element-active-border-color: var(--pico-primary-border);
+  --pico-form-element-focus-color: var(--pico-primary-border);
+  --pico-form-element-disabled-opacity: 0.5;
+  --pico-form-element-invalid-border-color: #b86a6b;
+  --pico-form-element-invalid-active-border-color: #c84f48;
+  --pico-form-element-invalid-focus-color: var(--pico-form-element-invalid-active-border-color);
+  --pico-form-element-valid-border-color: #4c9b8a;
+  --pico-form-element-valid-active-border-color: #279977;
+  --pico-form-element-valid-focus-color: var(--pico-form-element-valid-active-border-color);
+  --pico-switch-background-color: #bfc7d9;
+  --pico-switch-checked-background-color: var(--pico-primary-background);
+  --pico-switch-color: #fff;
+  --pico-switch-thumb-box-shadow: 0 0 0 rgba(0, 0, 0, 0);
+  --pico-range-border-color: #dfe3eb;
+  --pico-range-active-border-color: #bfc7d9;
+  --pico-range-thumb-border-color: var(--pico-background-color);
+  --pico-range-thumb-color: var(--pico-secondary-background);
+  --pico-range-thumb-active-color: var(--pico-primary-background);
+  --pico-accordion-border-color: var(--pico-muted-border-color);
+  --pico-accordion-active-summary-color: var(--pico-primary-hover);
+  --pico-accordion-close-summary-color: var(--pico-color);
+  --pico-accordion-open-summary-color: var(--pico-muted-color);
+  --pico-card-background-color: var(--pico-background-color);
+  --pico-card-border-color: var(--pico-muted-border-color);
+  --pico-card-box-shadow: var(--pico-box-shadow);
+  --pico-card-sectioning-background-color: #fbfcfc;
+  --pico-dropdown-background-color: #fff;
+  --pico-dropdown-border-color: #eff1f4;
+  --pico-dropdown-box-shadow: var(--pico-box-shadow);
+  --pico-dropdown-color: var(--pico-color);
+  --pico-dropdown-hover-background-color: #eff1f4;
+  --pico-loading-spinner-opacity: 0.5;
+  --pico-modal-overlay-background-color: rgba(232, 234, 237, 0.75);
+  --pico-progress-background-color: #dfe3eb;
+  --pico-progress-color: var(--pico-primary-background);
+  --pico-tooltip-background-color: var(--pico-contrast-background);
+  --pico-tooltip-color: var(--pico-contrast-inverse);
+  --pico-icon-valid: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' viewBox='0 0 24 24' fill='none' stroke='rgb(76, 155, 138)' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpolyline points='20 6 9 17 4 12'%3E%3C/polyline%3E%3C/svg%3E");
+  --pico-icon-invalid: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' viewBox='0 0 24 24' fill='none' stroke='rgb(200, 79, 72)' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3E%3Ccircle cx='12' cy='12' r='10'%3E%3C/circle%3E%3Cline x1='12' y1='8' x2='12' y2='12'%3E%3C/line%3E%3Cline x1='12' y1='16' x2='12.01' y2='16'%3E%3C/line%3E%3C/svg%3E");
+  color-scheme: light;
+}
+[data-theme=light] input:is([type=submit],
+[type=button],
+[type=reset],
+[type=checkbox],
+[type=radio],
+[type=file]),
+:root:not([data-theme=dark]) input:is([type=submit],
+[type=button],
+[type=reset],
+[type=checkbox],
+[type=radio],
+[type=file]) {
+  --pico-form-element-focus-color: var(--pico-primary-focus);
+}
+
+@media only screen and (prefers-color-scheme: dark) {
+  :root:not([data-theme]) {
+    --pico-background-color: #13171f;
+    --pico-color: #c2c7d0;
+    --pico-text-selection-color: rgba(1, 170, 255, 0.1875);
+    --pico-muted-color: #7b8495;
+    --pico-muted-border-color: #202632;
+    --pico-primary: #01aaff;
+    --pico-primary-background: #0172ad;
+    --pico-primary-border: var(--pico-primary-background);
+    --pico-primary-underline: rgba(1, 170, 255, 0.5);
+    --pico-primary-hover: #79c0ff;
+    --pico-primary-hover-background: #017fc0;
+    --pico-primary-hover-border: var(--pico-primary-hover-background);
+    --pico-primary-hover-underline: var(--pico-primary-hover);
+    --pico-primary-focus: rgba(1, 170, 255, 0.375);
+    --pico-primary-inverse: #fff;
+    --pico-secondary: #969eaf;
+    --pico-secondary-background: #525f7a;
+    --pico-secondary-border: var(--pico-secondary-background);
+    --pico-secondary-underline: rgba(150, 158, 175, 0.5);
+    --pico-secondary-hover: #b3b9c5;
+    --pico-secondary-hover-background: #5d6b89;
+    --pico-secondary-hover-border: var(--pico-secondary-hover-background);
+    --pico-secondary-hover-underline: var(--pico-secondary-hover);
+    --pico-secondary-focus: rgba(144, 158, 190, 0.25);
+    --pico-secondary-inverse: #fff;
+    --pico-contrast: #dfe3eb;
+    --pico-contrast-background: #eff1f4;
+    --pico-contrast-border: var(--pico-contrast-background);
+    --pico-contrast-underline: rgba(223, 227, 235, 0.5);
+    --pico-contrast-hover: #fff;
+    --pico-contrast-hover-background: #fff;
+    --pico-contrast-hover-border: var(--pico-contrast-hover-background);
+    --pico-contrast-hover-underline: var(--pico-contrast-hover);
+    --pico-contrast-focus: rgba(207, 213, 226, 0.25);
+    --pico-contrast-inverse: #000;
+    --pico-box-shadow: 0.0145rem 0.029rem 0.174rem rgba(7, 9, 12, 0.01698), 0.0335rem 0.067rem 0.402rem rgba(7, 9, 12, 0.024), 0.0625rem 0.125rem 0.75rem rgba(7, 9, 12, 0.03), 0.1125rem 0.225rem 1.35rem rgba(7, 9, 12, 0.036), 0.2085rem 0.417rem 2.502rem rgba(7, 9, 12, 0.04302), 0.5rem 1rem 6rem rgba(7, 9, 12, 0.06), 0 0 0 0.0625rem rgba(7, 9, 12, 0.015);
+    --pico-h1-color: #f0f1f3;
+    --pico-h2-color: #e0e3e7;
+    --pico-h3-color: #c2c7d0;
+    --pico-h4-color: #b3b9c5;
+    --pico-h5-color: #a4acba;
+    --pico-h6-color: #8891a4;
+    --pico-mark-background-color: #014063;
+    --pico-mark-color: #fff;
+    --pico-ins-color: #62af9a;
+    --pico-del-color: #ce7e7b;
+    --pico-blockquote-border-color: var(--pico-muted-border-color);
+    --pico-blockquote-footer-color: var(--pico-muted-color);
+    --pico-button-box-shadow: 0 0 0 rgba(0, 0, 0, 0);
+    --pico-button-hover-box-shadow: 0 0 0 rgba(0, 0, 0, 0);
+    --pico-table-border-color: var(--pico-muted-border-color);
+    --pico-table-row-stripped-background-color: rgba(111, 120, 135, 0.0375);
+    --pico-code-background-color: #1a1f28;
+    --pico-code-color: #8891a4;
+    --pico-code-kbd-background-color: var(--pico-color);
+    --pico-code-kbd-color: var(--pico-background-color);
+    --pico-form-element-background-color: #1c212c;
+    --pico-form-element-selected-background-color: #2a3140;
+    --pico-form-element-border-color: #2a3140;
+    --pico-form-element-color: #e0e3e7;
+    --pico-form-element-placeholder-color: #8891a4;
+    --pico-form-element-active-background-color: #1a1f28;
+    --pico-form-element-active-border-color: var(--pico-primary-border);
+    --pico-form-element-focus-color: var(--pico-primary-border);
+    --pico-form-element-disabled-opacity: 0.5;
+    --pico-form-element-invalid-border-color: #964a50;
+    --pico-form-element-invalid-active-border-color: #b7403b;
+    --pico-form-element-invalid-focus-color: var(--pico-form-element-invalid-active-border-color);
+    --pico-form-element-valid-border-color: #2a7b6f;
+    --pico-form-element-valid-active-border-color: #16896a;
+    --pico-form-element-valid-focus-color: var(--pico-form-element-valid-active-border-color);
+    --pico-switch-background-color: #333c4e;
+    --pico-switch-checked-background-color: var(--pico-primary-background);
+    --pico-switch-color: #fff;
+    --pico-switch-thumb-box-shadow: 0 0 0 rgba(0, 0, 0, 0);
+    --pico-range-border-color: #202632;
+    --pico-range-active-border-color: #2a3140;
+    --pico-range-thumb-border-color: var(--pico-background-color);
+    --pico-range-thumb-color: var(--pico-secondary-background);
+    --pico-range-thumb-active-color: var(--pico-primary-background);
+    --pico-accordion-border-color: var(--pico-muted-border-color);
+    --pico-accordion-active-summary-color: var(--pico-primary-hover);
+    --pico-accordion-close-summary-color: var(--pico-color);
+    --pico-accordion-open-summary-color: var(--pico-muted-color);
+    --pico-card-background-color: #181c25;
+    --pico-card-border-color: var(--pico-card-background-color);
+    --pico-card-box-shadow: var(--pico-box-shadow);
+    --pico-card-sectioning-background-color: #1a1f28;
+    --pico-dropdown-background-color: #181c25;
+    --pico-dropdown-border-color: #202632;
+    --pico-dropdown-box-shadow: var(--pico-box-shadow);
+    --pico-dropdown-color: var(--pico-color);
+    --pico-dropdown-hover-background-color: #202632;
+    --pico-loading-spinner-opacity: 0.5;
+    --pico-modal-overlay-background-color: rgba(8, 9, 10, 0.75);
+    --pico-progress-background-color: #202632;
+    --pico-progress-color: var(--pico-primary-background);
+    --pico-tooltip-background-color: var(--pico-contrast-background);
+    --pico-tooltip-color: var(--pico-contrast-inverse);
+    --pico-icon-valid: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' viewBox='0 0 24 24' fill='none' stroke='rgb(42, 123, 111)' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpolyline points='20 6 9 17 4 12'%3E%3C/polyline%3E%3C/svg%3E");
+    --pico-icon-invalid: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' viewBox='0 0 24 24' fill='none' stroke='rgb(150, 74, 80)' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3E%3Ccircle cx='12' cy='12' r='10'%3E%3C/circle%3E%3Cline x1='12' y1='8' x2='12' y2='12'%3E%3C/line%3E%3Cline x1='12' y1='16' x2='12.01' y2='16'%3E%3C/line%3E%3C/svg%3E");
+    color-scheme: dark;
+  }
+  :root:not([data-theme]) input:is([type=submit],
+  [type=button],
+  [type=reset],
+  [type=checkbox],
+  [type=radio],
+  [type=file]) {
+    --pico-form-element-focus-color: var(--pico-primary-focus);
+  }
+  :root:not([data-theme]) details summary[role=button].contrast:not(.outline)::after {
+    filter: brightness(0);
+  }
+  :root:not([data-theme]) [aria-busy=true]:not(input, select, textarea).contrast:is(button,
+  [type=submit],
+  [type=button],
+  [type=reset],
+  [role=button]):not(.outline)::before {
+    filter: brightness(0);
+  }
+}
+[data-theme=dark] {
+  --pico-background-color: #13171f;
+  --pico-color: #c2c7d0;
+  --pico-text-selection-color: rgba(1, 170, 255, 0.1875);
+  --pico-muted-color: #7b8495;
+  --pico-muted-border-color: #202632;
+  --pico-primary: #01aaff;
+  --pico-primary-background: #0172ad;
+  --pico-primary-border: var(--pico-primary-background);
+  --pico-primary-underline: rgba(1, 170, 255, 0.5);
+  --pico-primary-hover: #79c0ff;
+  --pico-primary-hover-background: #017fc0;
+  --pico-primary-hover-border: var(--pico-primary-hover-background);
+  --pico-primary-hover-underline: var(--pico-primary-hover);
+  --pico-primary-focus: rgba(1, 170, 255, 0.375);
+  --pico-primary-inverse: #fff;
+  --pico-secondary: #969eaf;
+  --pico-secondary-background: #525f7a;
+  --pico-secondary-border: var(--pico-secondary-background);
+  --pico-secondary-underline: rgba(150, 158, 175, 0.5);
+  --pico-secondary-hover: #b3b9c5;
+  --pico-secondary-hover-background: #5d6b89;
+  --pico-secondary-hover-border: var(--pico-secondary-hover-background);
+  --pico-secondary-hover-underline: var(--pico-secondary-hover);
+  --pico-secondary-focus: rgba(144, 158, 190, 0.25);
+  --pico-secondary-inverse: #fff;
+  --pico-contrast: #dfe3eb;
+  --pico-contrast-background: #eff1f4;
+  --pico-contrast-border: var(--pico-contrast-background);
+  --pico-contrast-underline: rgba(223, 227, 235, 0.5);
+  --pico-contrast-hover: #fff;
+  --pico-contrast-hover-background: #fff;
+  --pico-contrast-hover-border: var(--pico-contrast-hover-background);
+  --pico-contrast-hover-underline: var(--pico-contrast-hover);
+  --pico-contrast-focus: rgba(207, 213, 226, 0.25);
+  --pico-contrast-inverse: #000;
+  --pico-box-shadow: 0.0145rem 0.029rem 0.174rem rgba(7, 9, 12, 0.01698), 0.0335rem 0.067rem 0.402rem rgba(7, 9, 12, 0.024), 0.0625rem 0.125rem 0.75rem rgba(7, 9, 12, 0.03), 0.1125rem 0.225rem 1.35rem rgba(7, 9, 12, 0.036), 0.2085rem 0.417rem 2.502rem rgba(7, 9, 12, 0.04302), 0.5rem 1rem 6rem rgba(7, 9, 12, 0.06), 0 0 0 0.0625rem rgba(7, 9, 12, 0.015);
+  --pico-h1-color: #f0f1f3;
+  --pico-h2-color: #e0e3e7;
+  --pico-h3-color: #c2c7d0;
+  --pico-h4-color: #b3b9c5;
+  --pico-h5-color: #a4acba;
+  --pico-h6-color: #8891a4;
+  --pico-mark-background-color: #014063;
+  --pico-mark-color: #fff;
+  --pico-ins-color: #62af9a;
+  --pico-del-color: #ce7e7b;
+  --pico-blockquote-border-color: var(--pico-muted-border-color);
+  --pico-blockquote-footer-color: var(--pico-muted-color);
+  --pico-button-box-shadow: 0 0 0 rgba(0, 0, 0, 0);
+  --pico-button-hover-box-shadow: 0 0 0 rgba(0, 0, 0, 0);
+  --pico-table-border-color: var(--pico-muted-border-color);
+  --pico-table-row-stripped-background-color: rgba(111, 120, 135, 0.0375);
+  --pico-code-background-color: #1a1f28;
+  --pico-code-color: #8891a4;
+  --pico-code-kbd-background-color: var(--pico-color);
+  --pico-code-kbd-color: var(--pico-background-color);
+  --pico-form-element-background-color: #1c212c;
+  --pico-form-element-selected-background-color: #2a3140;
+  --pico-form-element-border-color: #2a3140;
+  --pico-form-element-color: #e0e3e7;
+  --pico-form-element-placeholder-color: #8891a4;
+  --pico-form-element-active-background-color: #1a1f28;
+  --pico-form-element-active-border-color: var(--pico-primary-border);
+  --pico-form-element-focus-color: var(--pico-primary-border);
+  --pico-form-element-disabled-opacity: 0.5;
+  --pico-form-element-invalid-border-color: #964a50;
+  --pico-form-element-invalid-active-border-color: #b7403b;
+  --pico-form-element-invalid-focus-color: var(--pico-form-element-invalid-active-border-color);
+  --pico-form-element-valid-border-color: #2a7b6f;
+  --pico-form-element-valid-active-border-color: #16896a;
+  --pico-form-element-valid-focus-color: var(--pico-form-element-valid-active-border-color);
+  --pico-switch-background-color: #333c4e;
+  --pico-switch-checked-background-color: var(--pico-primary-background);
+  --pico-switch-color: #fff;
+  --pico-switch-thumb-box-shadow: 0 0 0 rgba(0, 0, 0, 0);
+  --pico-range-border-color: #202632;
+  --pico-range-active-border-color: #2a3140;
+  --pico-range-thumb-border-color: var(--pico-background-color);
+  --pico-range-thumb-color: var(--pico-secondary-background);
+  --pico-range-thumb-active-color: var(--pico-primary-background);
+  --pico-accordion-border-color: var(--pico-muted-border-color);
+  --pico-accordion-active-summary-color: var(--pico-primary-hover);
+  --pico-accordion-close-summary-color: var(--pico-color);
+  --pico-accordion-open-summary-color: var(--pico-muted-color);
+  --pico-card-background-color: #181c25;
+  --pico-card-border-color: var(--pico-card-background-color);
+  --pico-card-box-shadow: var(--pico-box-shadow);
+  --pico-card-sectioning-background-color: #1a1f28;
+  --pico-dropdown-background-color: #181c25;
+  --pico-dropdown-border-color: #202632;
+  --pico-dropdown-box-shadow: var(--pico-box-shadow);
+  --pico-dropdown-color: var(--pico-color);
+  --pico-dropdown-hover-background-color: #202632;
+  --pico-loading-spinner-opacity: 0.5;
+  --pico-modal-overlay-background-color: rgba(8, 9, 10, 0.75);
+  --pico-progress-background-color: #202632;
+  --pico-progress-color: var(--pico-primary-background);
+  --pico-tooltip-background-color: var(--pico-contrast-background);
+  --pico-tooltip-color: var(--pico-contrast-inverse);
+  --pico-icon-valid: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' viewBox='0 0 24 24' fill='none' stroke='rgb(42, 123, 111)' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpolyline points='20 6 9 17 4 12'%3E%3C/polyline%3E%3C/svg%3E");
+  --pico-icon-invalid: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' viewBox='0 0 24 24' fill='none' stroke='rgb(150, 74, 80)' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3E%3Ccircle cx='12' cy='12' r='10'%3E%3C/circle%3E%3Cline x1='12' y1='8' x2='12' y2='12'%3E%3C/line%3E%3Cline x1='12' y1='16' x2='12.01' y2='16'%3E%3C/line%3E%3C/svg%3E");
+  color-scheme: dark;
+}
+[data-theme=dark] input:is([type=submit],
+[type=button],
+[type=reset],
+[type=checkbox],
+[type=radio],
+[type=file]) {
+  --pico-form-element-focus-color: var(--pico-primary-focus);
+}
+[data-theme=dark] details summary[role=button].contrast:not(.outline)::after {
+  filter: brightness(0);
+}
+[data-theme=dark] [aria-busy=true]:not(input, select, textarea).contrast:is(button,
+[type=submit],
+[type=button],
+[type=reset],
+[role=button]):not(.outline)::before {
+  filter: brightness(0);
+}
+
+progress,
+[type=checkbox],
+[type=radio],
+[type=range] {
+  accent-color: var(--pico-primary);
+}
+
+/**
+ * Document
+ * Content-box & Responsive typography
+ */
+*,
+*::before,
+*::after {
+  box-sizing: border-box;
+  background-repeat: no-repeat;
+}
+
+::before,
+::after {
+  text-decoration: inherit;
+  vertical-align: inherit;
+}
+
+:where(:root) {
+  -webkit-tap-highlight-color: transparent;
+  -webkit-text-size-adjust: 100%;
+  -moz-text-size-adjust: 100%;
+  text-size-adjust: 100%;
+  background-color: var(--pico-background-color);
+  color: var(--pico-color);
+  font-weight: var(--pico-font-weight);
+  font-size: var(--pico-font-size);
+  line-height: var(--pico-line-height);
+  font-family: var(--pico-font-family);
+  text-underline-offset: var(--pico-text-underline-offset);
+  text-rendering: optimizeLegibility;
+  overflow-wrap: break-word;
+  -moz-tab-size: 4;
+  -o-tab-size: 4;
+  tab-size: 4;
+}
+
+/**
+ * Landmarks
+ */
+body {
+  width: 100%;
+  margin: 0;
+}
+
+main {
+  display: block;
+}
+
+body > header,
+body > main,
+body > footer {
+  padding-block: var(--pico-block-spacing-vertical);
+}
+
+/**
+ * Section
+ */
+section {
+  margin-bottom: var(--pico-block-spacing-vertical);
+}
+
+/**
+ * Container
+ */
+.container,
+.container-fluid {
+  width: 100%;
+  margin-right: auto;
+  margin-left: auto;
+  padding-right: var(--pico-spacing);
+  padding-left: var(--pico-spacing);
+}
+
+@media (min-width: 576px) {
+  .container {
+    max-width: 510px;
+    padding-right: 0;
+    padding-left: 0;
+  }
+}
+@media (min-width: 768px) {
+  .container {
+    max-width: 700px;
+  }
+}
+@media (min-width: 1024px) {
+  .container {
+    max-width: 950px;
+  }
+}
+@media (min-width: 1280px) {
+  .container {
+    max-width: 1200px;
+  }
+}
+@media (min-width: 1536px) {
+  .container {
+    max-width: 1450px;
+  }
+}
+
+/**
+ * Grid
+ * Minimal grid system with auto-layout columns
+ */
+.grid {
+  grid-column-gap: var(--pico-grid-column-gap);
+  grid-row-gap: var(--pico-grid-row-gap);
+  display: grid;
+  grid-template-columns: 1fr;
+}
+@media (min-width: 768px) {
+  .grid {
+    grid-template-columns: repeat(auto-fit, minmax(0%, 1fr));
+  }
+}
+.grid > * {
+  min-width: 0;
+}
+
+/**
+ * Overflow auto
+ */
+.overflow-auto {
+  overflow: auto;
+}
+
+/**
+ * Typography
+ */
+b,
+strong {
+  font-weight: bolder;
+}
+
+sub,
+sup {
+  position: relative;
+  font-size: 0.75em;
+  line-height: 0;
+  vertical-align: baseline;
+}
+
+sub {
+  bottom: -0.25em;
+}
+
+sup {
+  top: -0.5em;
+}
+
+address,
+blockquote,
+dl,
+ol,
+p,
+pre,
+table,
+ul {
+  margin-top: 0;
+  margin-bottom: var(--pico-typography-spacing-vertical);
+  color: var(--pico-color);
+  font-style: normal;
+  font-weight: var(--pico-font-weight);
+}
+
+h1,
+h2,
+h3,
+h4,
+h5,
+h6 {
+  margin-top: 0;
+  margin-bottom: var(--pico-typography-spacing-vertical);
+  color: var(--pico-color);
+  font-weight: var(--pico-font-weight);
+  font-size: var(--pico-font-size);
+  line-height: var(--pico-line-height);
+  font-family: var(--pico-font-family);
+}
+
+h1 {
+  --pico-color: var(--pico-h1-color);
+}
+
+h2 {
+  --pico-color: var(--pico-h2-color);
+}
+
+h3 {
+  --pico-color: var(--pico-h3-color);
+}
+
+h4 {
+  --pico-color: var(--pico-h4-color);
+}
+
+h5 {
+  --pico-color: var(--pico-h5-color);
+}
+
+h6 {
+  --pico-color: var(--pico-h6-color);
+}
+
+:where(article, address, blockquote, dl, figure, form, ol, p, pre, table, ul) ~ :is(h1, h2, h3, h4, h5, h6) {
+  margin-top: var(--pico-typography-spacing-top);
+}
+
+p {
+  margin-bottom: var(--pico-typography-spacing-vertical);
+}
+
+hgroup {
+  margin-bottom: var(--pico-typography-spacing-vertical);
+}
+hgroup > * {
+  margin-top: 0;
+  margin-bottom: 0;
+}
+hgroup > *:not(:first-child):last-child {
+  --pico-color: var(--pico-muted-color);
+  --pico-font-weight: unset;
+  font-size: 1rem;
+}
+
+:where(ol, ul) li {
+  margin-bottom: calc(var(--pico-typography-spacing-vertical) * 0.25);
+}
+
+:where(dl, ol, ul) :where(dl, ol, ul) {
+  margin: 0;
+  margin-top: calc(var(--pico-typography-spacing-vertical) * 0.25);
+}
+
+ul li {
+  list-style: square;
+}
+
+mark {
+  padding: 0.125rem 0.25rem;
+  background-color: var(--pico-mark-background-color);
+  color: var(--pico-mark-color);
+  vertical-align: baseline;
+}
+
+blockquote {
+  display: block;
+  margin: var(--pico-typography-spacing-vertical) 0;
+  padding: var(--pico-spacing);
+  border-right: none;
+  border-left: 0.25rem solid var(--pico-blockquote-border-color);
+  border-inline-start: 0.25rem solid var(--pico-blockquote-border-color);
+  border-inline-end: none;
+}
+blockquote footer {
+  margin-top: calc(var(--pico-typography-spacing-vertical) * 0.5);
+  color: var(--pico-blockquote-footer-color);
+}
+
+abbr[title] {
+  border-bottom: 1px dotted;
+  text-decoration: none;
+  cursor: help;
+}
+
+ins {
+  color: var(--pico-ins-color);
+  text-decoration: none;
+}
+
+del {
+  color: var(--pico-del-color);
+}
+
+::-moz-selection {
+  background-color: var(--pico-text-selection-color);
+}
+
+::selection {
+  background-color: var(--pico-text-selection-color);
+}
+
+/**
+ * Link
+ */
+:where(a:not([role=button])),
+[role=link] {
+  --pico-color: var(--pico-primary);
+  --pico-background-color: transparent;
+  --pico-underline: var(--pico-primary-underline);
+  outline: none;
+  background-color: var(--pico-background-color);
+  color: var(--pico-color);
+  -webkit-text-decoration: var(--pico-text-decoration);
+  text-decoration: var(--pico-text-decoration);
+  text-decoration-color: var(--pico-underline);
+  text-underline-offset: 0.125em;
+  transition: background-color var(--pico-transition), color var(--pico-transition), box-shadow var(--pico-transition), -webkit-text-decoration var(--pico-transition);
+  transition: background-color var(--pico-transition), color var(--pico-transition), text-decoration var(--pico-transition), box-shadow var(--pico-transition);
+  transition: background-color var(--pico-transition), color var(--pico-transition), text-decoration var(--pico-transition), box-shadow var(--pico-transition), -webkit-text-decoration var(--pico-transition);
+}
+:where(a:not([role=button])):is([aria-current]:not([aria-current=false]), :hover, :active, :focus),
+[role=link]:is([aria-current]:not([aria-current=false]), :hover, :active, :focus) {
+  --pico-color: var(--pico-primary-hover);
+  --pico-underline: var(--pico-primary-hover-underline);
+  --pico-text-decoration: underline;
+}
+:where(a:not([role=button])):focus-visible,
+[role=link]:focus-visible {
+  box-shadow: 0 0 0 var(--pico-outline-width) var(--pico-primary-focus);
+}
+:where(a:not([role=button])).secondary,
+[role=link].secondary {
+  --pico-color: var(--pico-secondary);
+  --pico-underline: var(--pico-secondary-underline);
+}
+:where(a:not([role=button])).secondary:is([aria-current]:not([aria-current=false]), :hover, :active, :focus),
+[role=link].secondary:is([aria-current]:not([aria-current=false]), :hover, :active, :focus) {
+  --pico-color: var(--pico-secondary-hover);
+  --pico-underline: var(--pico-secondary-hover-underline);
+}
+:where(a:not([role=button])).contrast,
+[role=link].contrast {
+  --pico-color: var(--pico-contrast);
+  --pico-underline: var(--pico-contrast-underline);
+}
+:where(a:not([role=button])).contrast:is([aria-current]:not([aria-current=false]), :hover, :active, :focus),
+[role=link].contrast:is([aria-current]:not([aria-current=false]), :hover, :active, :focus) {
+  --pico-color: var(--pico-contrast-hover);
+  --pico-underline: var(--pico-contrast-hover-underline);
+}
+
+a[role=button] {
+  display: inline-block;
+}
+
+/**
+ * Button
+ */
+button {
+  margin: 0;
+  overflow: visible;
+  font-family: inherit;
+  text-transform: none;
+}
+
+button,
+[type=submit],
+[type=reset],
+[type=button] {
+  -webkit-appearance: button;
+}
+
+button,
+[type=submit],
+[type=reset],
+[type=button],
+[type=file]::file-selector-button,
+[role=button] {
+  --pico-background-color: var(--pico-primary-background);
+  --pico-border-color: var(--pico-primary-border);
+  --pico-color: var(--pico-primary-inverse);
+  --pico-box-shadow: var(--pico-button-box-shadow, 0 0 0 rgba(0, 0, 0, 0));
+  padding: var(--pico-form-element-spacing-vertical) var(--pico-form-element-spacing-horizontal);
+  border: var(--pico-border-width) solid var(--pico-border-color);
+  border-radius: var(--pico-border-radius);
+  outline: none;
+  background-color: var(--pico-background-color);
+  box-shadow: var(--pico-box-shadow);
+  color: var(--pico-color);
+  font-weight: var(--pico-font-weight);
+  font-size: 1rem;
+  line-height: var(--pico-line-height);
+  text-align: center;
+  text-decoration: none;
+  cursor: pointer;
+  -webkit-user-select: none;
+  -moz-user-select: none;
+  user-select: none;
+  transition: background-color var(--pico-transition), border-color var(--pico-transition), color var(--pico-transition), box-shadow var(--pico-transition);
+}
+button:is([aria-current]:not([aria-current=false])), button:is(:hover, :active, :focus),
+[type=submit]:is([aria-current]:not([aria-current=false])),
+[type=submit]:is(:hover, :active, :focus),
+[type=reset]:is([aria-current]:not([aria-current=false])),
+[type=reset]:is(:hover, :active, :focus),
+[type=button]:is([aria-current]:not([aria-current=false])),
+[type=button]:is(:hover, :active, :focus),
+[type=file]::file-selector-button:is([aria-current]:not([aria-current=false])),
+[type=file]::file-selector-button:is(:hover, :active, :focus),
+[role=button]:is([aria-current]:not([aria-current=false])),
+[role=button]:is(:hover, :active, :focus) {
+  --pico-background-color: var(--pico-primary-hover-background);
+  --pico-border-color: var(--pico-primary-hover-border);
+  --pico-box-shadow: var(--pico-button-hover-box-shadow, 0 0 0 rgba(0, 0, 0, 0));
+  --pico-color: var(--pico-primary-inverse);
+}
+button:focus, button:is([aria-current]:not([aria-current=false])):focus,
+[type=submit]:focus,
+[type=submit]:is([aria-current]:not([aria-current=false])):focus,
+[type=reset]:focus,
+[type=reset]:is([aria-current]:not([aria-current=false])):focus,
+[type=button]:focus,
+[type=button]:is([aria-current]:not([aria-current=false])):focus,
+[type=file]::file-selector-button:focus,
+[type=file]::file-selector-button:is([aria-current]:not([aria-current=false])):focus,
+[role=button]:focus,
+[role=button]:is([aria-current]:not([aria-current=false])):focus {
+  --pico-box-shadow: var(--pico-button-hover-box-shadow, 0 0 0 rgba(0, 0, 0, 0)), 0 0 0 var(--pico-outline-width) var(--pico-primary-focus);
+}
+
+[type=submit],
+[type=reset],
+[type=button] {
+  margin-bottom: var(--pico-spacing);
+}
+
+:is(button, [type=submit], [type=button], [role=button]).secondary,
+[type=reset],
+[type=file]::file-selector-button {
+  --pico-background-color: var(--pico-secondary-background);
+  --pico-border-color: var(--pico-secondary-border);
+  --pico-color: var(--pico-secondary-inverse);
+  cursor: pointer;
+}
+:is(button, [type=submit], [type=button], [role=button]).secondary:is([aria-current]:not([aria-current=false]), :hover, :active, :focus),
+[type=reset]:is([aria-current]:not([aria-current=false]), :hover, :active, :focus),
+[type=file]::file-selector-button:is([aria-current]:not([aria-current=false]), :hover, :active, :focus) {
+  --pico-background-color: var(--pico-secondary-hover-background);
+  --pico-border-color: var(--pico-secondary-hover-border);
+  --pico-color: var(--pico-secondary-inverse);
+}
+:is(button, [type=submit], [type=button], [role=button]).secondary:focus, :is(button, [type=submit], [type=button], [role=button]).secondary:is([aria-current]:not([aria-current=false])):focus,
+[type=reset]:focus,
+[type=reset]:is([aria-current]:not([aria-current=false])):focus,
+[type=file]::file-selector-button:focus,
+[type=file]::file-selector-button:is([aria-current]:not([aria-current=false])):focus {
+  --pico-box-shadow: var(--pico-button-hover-box-shadow, 0 0 0 rgba(0, 0, 0, 0)), 0 0 0 var(--pico-outline-width) var(--pico-secondary-focus);
+}
+
+:is(button, [type=submit], [type=button], [role=button]).contrast {
+  --pico-background-color: var(--pico-contrast-background);
+  --pico-border-color: var(--pico-contrast-border);
+  --pico-color: var(--pico-contrast-inverse);
+}
+:is(button, [type=submit], [type=button], [role=button]).contrast:is([aria-current]:not([aria-current=false]), :hover, :active, :focus) {
+  --pico-background-color: var(--pico-contrast-hover-background);
+  --pico-border-color: var(--pico-contrast-hover-border);
+  --pico-color: var(--pico-contrast-inverse);
+}
+:is(button, [type=submit], [type=button], [role=button]).contrast:focus, :is(button, [type=submit], [type=button], [role=button]).contrast:is([aria-current]:not([aria-current=false])):focus {
+  --pico-box-shadow: var(--pico-button-hover-box-shadow, 0 0 0 rgba(0, 0, 0, 0)), 0 0 0 var(--pico-outline-width) var(--pico-contrast-focus);
+}
+
+:is(button, [type=submit], [type=button], [role=button]).outline,
+[type=reset].outline {
+  --pico-background-color: transparent;
+  --pico-color: var(--pico-primary);
+  --pico-border-color: var(--pico-primary);
+}
+:is(button, [type=submit], [type=button], [role=button]).outline:is([aria-current]:not([aria-current=false]), :hover, :active, :focus),
+[type=reset].outline:is([aria-current]:not([aria-current=false]), :hover, :active, :focus) {
+  --pico-background-color: transparent;
+  --pico-color: var(--pico-primary-hover);
+  --pico-border-color: var(--pico-primary-hover);
+}
+
+:is(button, [type=submit], [type=button], [role=button]).outline.secondary,
+[type=reset].outline {
+  --pico-color: var(--pico-secondary);
+  --pico-border-color: var(--pico-secondary);
+}
+:is(button, [type=submit], [type=button], [role=button]).outline.secondary:is([aria-current]:not([aria-current=false]), :hover, :active, :focus),
+[type=reset].outline:is([aria-current]:not([aria-current=false]), :hover, :active, :focus) {
+  --pico-color: var(--pico-secondary-hover);
+  --pico-border-color: var(--pico-secondary-hover);
+}
+
+:is(button, [type=submit], [type=button], [role=button]).outline.contrast {
+  --pico-color: var(--pico-contrast);
+  --pico-border-color: var(--pico-contrast);
+}
+:is(button, [type=submit], [type=button], [role=button]).outline.contrast:is([aria-current]:not([aria-current=false]), :hover, :active, :focus) {
+  --pico-color: var(--pico-contrast-hover);
+  --pico-border-color: var(--pico-contrast-hover);
+}
+
+:where(button, [type=submit], [type=reset], [type=button], [role=button])[disabled],
+:where(fieldset[disabled]) :is(button, [type=submit], [type=button], [type=reset], [role=button]) {
+  opacity: 0.5;
+  pointer-events: none;
+}
+
+/**
+ * Table
+ */
+:where(table) {
+  width: 100%;
+  border-collapse: collapse;
+  border-spacing: 0;
+  text-indent: 0;
+}
+
+th,
+td {
+  padding: calc(var(--pico-spacing) / 2) var(--pico-spacing);
+  border-bottom: var(--pico-border-width) solid var(--pico-table-border-color);
+  background-color: var(--pico-background-color);
+  color: var(--pico-color);
+  font-weight: var(--pico-font-weight);
+  text-align: left;
+  text-align: start;
+}
+
+tfoot th,
+tfoot td {
+  border-top: var(--pico-border-width) solid var(--pico-table-border-color);
+  border-bottom: 0;
+}
+
+table.striped tbody tr:nth-child(odd) th,
+table.striped tbody tr:nth-child(odd) td {
+  background-color: var(--pico-table-row-stripped-background-color);
+}
+
+/**
+ * Embedded content
+ */
+:where(audio, canvas, iframe, img, svg, video) {
+  vertical-align: middle;
+}
+
+audio,
+video {
+  display: inline-block;
+}
+
+audio:not([controls]) {
+  display: none;
+  height: 0;
+}
+
+:where(iframe) {
+  border-style: none;
+}
+
+img {
+  max-width: 100%;
+  height: auto;
+  border-style: none;
+}
+
+:where(svg:not([fill])) {
+  fill: currentColor;
+}
+
+svg:not(:root) {
+  overflow: hidden;
+}
+
+/**
+ * Code
+ */
+pre,
+code,
+kbd,
+samp {
+  font-size: 0.875em;
+  font-family: var(--pico-font-family);
+}
+
+pre code {
+  font-size: inherit;
+  font-family: inherit;
+}
+
+pre {
+  -ms-overflow-style: scrollbar;
+  overflow: auto;
+}
+
+pre,
+code,
+kbd {
+  border-radius: var(--pico-border-radius);
+  background: var(--pico-code-background-color);
+  color: var(--pico-code-color);
+  font-weight: var(--pico-font-weight);
+  line-height: initial;
+}
+
+code,
+kbd {
+  display: inline-block;
+  padding: 0.375rem;
+}
+
+pre {
+  display: block;
+  margin-bottom: var(--pico-spacing);
+  overflow-x: auto;
+}
+pre > code {
+  display: block;
+  padding: var(--pico-spacing);
+  background: none;
+  line-height: var(--pico-line-height);
+}
+
+kbd {
+  background-color: var(--pico-code-kbd-background-color);
+  color: var(--pico-code-kbd-color);
+  vertical-align: baseline;
+}
+
+/**
+ * Figure
+ */
+figure {
+  display: block;
+  margin: 0;
+  padding: 0;
+}
+figure figcaption {
+  padding: calc(var(--pico-spacing) * 0.5) 0;
+  color: var(--pico-muted-color);
+}
+
+/**
+ * Miscs
+ */
+hr {
+  height: 0;
+  margin: var(--pico-typography-spacing-vertical) 0;
+  border: 0;
+  border-top: 1px solid var(--pico-muted-border-color);
+  color: inherit;
+}
+
+[hidden],
+template {
+  display: none !important;
+}
+
+canvas {
+  display: inline-block;
+}
+
+/**
+ * Basics form elements
+ */
+input,
+optgroup,
+select,
+textarea {
+  margin: 0;
+  font-size: 1rem;
+  line-height: var(--pico-line-height);
+  font-family: inherit;
+  letter-spacing: inherit;
+}
+
+input {
+  overflow: visible;
+}
+
+select {
+  text-transform: none;
+}
+
+legend {
+  max-width: 100%;
+  padding: 0;
+  color: inherit;
+  white-space: normal;
+}
+
+textarea {
+  overflow: auto;
+}
+
+[type=checkbox],
+[type=radio] {
+  padding: 0;
+}
+
+::-webkit-inner-spin-button,
+::-webkit-outer-spin-button {
+  height: auto;
+}
+
+[type=search] {
+  -webkit-appearance: textfield;
+  outline-offset: -2px;
+}
+
+[type=search]::-webkit-search-decoration {
+  -webkit-appearance: none;
+}
+
+::-webkit-file-upload-button {
+  -webkit-appearance: button;
+  font: inherit;
+}
+
+::-moz-focus-inner {
+  padding: 0;
+  border-style: none;
+}
+
+:-moz-focusring {
+  outline: none;
+}
+
+:-moz-ui-invalid {
+  box-shadow: none;
+}
+
+::-ms-expand {
+  display: none;
+}
+
+[type=file],
+[type=range] {
+  padding: 0;
+  border-width: 0;
+}
+
+input:not([type=checkbox], [type=radio], [type=range]) {
+  height: calc(1rem * var(--pico-line-height) + var(--pico-form-element-spacing-vertical) * 2 + var(--pico-border-width) * 2);
+}
+
+fieldset {
+  width: 100%;
+  margin: 0;
+  margin-bottom: var(--pico-spacing);
+  padding: 0;
+  border: 0;
+}
+
+label,
+fieldset legend {
+  display: block;
+  margin-bottom: calc(var(--pico-spacing) * 0.375);
+  color: var(--pico-color);
+  font-weight: var(--pico-form-label-font-weight, var(--pico-font-weight));
+}
+
+fieldset legend {
+  margin-bottom: calc(var(--pico-spacing) * 0.5);
+}
+
+input:not([type=checkbox], [type=radio]),
+button[type=submit],
+select,
+textarea {
+  width: 100%;
+}
+
+input:not([type=checkbox], [type=radio], [type=range], [type=file]),
+select,
+textarea {
+  -webkit-appearance: none;
+  -moz-appearance: none;
+  appearance: none;
+  padding: var(--pico-form-element-spacing-vertical) var(--pico-form-element-spacing-horizontal);
+}
+
+input,
+select,
+textarea {
+  --pico-background-color: var(--pico-form-element-background-color);
+  --pico-border-color: var(--pico-form-element-border-color);
+  --pico-color: var(--pico-form-element-color);
+  --pico-box-shadow: none;
+  border: var(--pico-border-width) solid var(--pico-border-color);
+  border-radius: var(--pico-border-radius);
+  outline: none;
+  background-color: var(--pico-background-color);
+  box-shadow: var(--pico-box-shadow);
+  color: var(--pico-color);
+  font-weight: var(--pico-font-weight);
+  transition: background-color var(--pico-transition), border-color var(--pico-transition), color var(--pico-transition), box-shadow var(--pico-transition);
+}
+
+input:not([type=submit],
+[type=button],
+[type=reset],
+[type=checkbox],
+[type=radio],
+[readonly]):is(:active, :focus),
+:where(select, textarea):not([readonly]):is(:active, :focus) {
+  --pico-background-color: var(--pico-form-element-active-background-color);
+}
+
+input:not([type=submit], [type=button], [type=reset], [role=switch], [readonly]):is(:active, :focus),
+:where(select, textarea):not([readonly]):is(:active, :focus) {
+  --pico-border-color: var(--pico-form-element-active-border-color);
+}
+
+input:not([type=submit],
+[type=button],
+[type=reset],
+[type=range],
+[type=file],
+[readonly]):focus,
+:where(select, textarea):not([readonly]):focus {
+  --pico-box-shadow: 0 0 0 var(--pico-outline-width) var(--pico-form-element-focus-color);
+}
+
+input:not([type=submit], [type=button], [type=reset])[disabled],
+select[disabled],
+textarea[disabled],
+label[aria-disabled=true],
+:where(fieldset[disabled]) :is(input:not([type=submit], [type=button], [type=reset]), select, textarea) {
+  opacity: var(--pico-form-element-disabled-opacity);
+  pointer-events: none;
+}
+
+label[aria-disabled=true] input[disabled] {
+  opacity: 1;
+}
+
+:where(input, select, textarea):not([type=checkbox],
+[type=radio],
+[type=date],
+[type=datetime-local],
+[type=month],
+[type=time],
+[type=week],
+[type=range])[aria-invalid] {
+  padding-right: calc(var(--pico-form-element-spacing-horizontal) + 1.5rem) !important;
+  padding-left: var(--pico-form-element-spacing-horizontal);
+  padding-inline-start: var(--pico-form-element-spacing-horizontal) !important;
+  padding-inline-end: calc(var(--pico-form-element-spacing-horizontal) + 1.5rem) !important;
+  background-position: center right 0.75rem;
+  background-size: 1rem auto;
+  background-repeat: no-repeat;
+}
+:where(input, select, textarea):not([type=checkbox],
+[type=radio],
+[type=date],
+[type=datetime-local],
+[type=month],
+[type=time],
+[type=week],
+[type=range])[aria-invalid=false]:not(select) {
+  background-image: var(--pico-icon-valid);
+}
+:where(input, select, textarea):not([type=checkbox],
+[type=radio],
+[type=date],
+[type=datetime-local],
+[type=month],
+[type=time],
+[type=week],
+[type=range])[aria-invalid=true]:not(select) {
+  background-image: var(--pico-icon-invalid);
+}
+:where(input, select, textarea)[aria-invalid=false] {
+  --pico-border-color: var(--pico-form-element-valid-border-color);
+}
+:where(input, select, textarea)[aria-invalid=false]:is(:active, :focus) {
+  --pico-border-color: var(--pico-form-element-valid-active-border-color) !important;
+}
+:where(input, select, textarea)[aria-invalid=false]:is(:active, :focus):not([type=checkbox], [type=radio]) {
+  --pico-box-shadow: 0 0 0 var(--pico-outline-width) var(--pico-form-element-valid-focus-color) !important;
+}
+:where(input, select, textarea)[aria-invalid=true] {
+  --pico-border-color: var(--pico-form-element-invalid-border-color);
+}
+:where(input, select, textarea)[aria-invalid=true]:is(:active, :focus) {
+  --pico-border-color: var(--pico-form-element-invalid-active-border-color) !important;
+}
+:where(input, select, textarea)[aria-invalid=true]:is(:active, :focus):not([type=checkbox], [type=radio]) {
+  --pico-box-shadow: 0 0 0 var(--pico-outline-width) var(--pico-form-element-invalid-focus-color) !important;
+}
+
+[dir=rtl] :where(input, select, textarea):not([type=checkbox], [type=radio]):is([aria-invalid], [aria-invalid=true], [aria-invalid=false]) {
+  background-position: center left 0.75rem;
+}
+
+input::placeholder,
+input::-webkit-input-placeholder,
+textarea::placeholder,
+textarea::-webkit-input-placeholder,
+select:invalid {
+  color: var(--pico-form-element-placeholder-color);
+  opacity: 1;
+}
+
+input:not([type=checkbox], [type=radio]),
+select,
+textarea {
+  margin-bottom: var(--pico-spacing);
+}
+
+select::-ms-expand {
+  border: 0;
+  background-color: transparent;
+}
+select:not([multiple], [size]) {
+  padding-right: calc(var(--pico-form-element-spacing-horizontal) + 1.5rem);
+  padding-left: var(--pico-form-element-spacing-horizontal);
+  padding-inline-start: var(--pico-form-element-spacing-horizontal);
+  padding-inline-end: calc(var(--pico-form-element-spacing-horizontal) + 1.5rem);
+  background-image: var(--pico-icon-chevron);
+  background-position: center right 0.75rem;
+  background-size: 1rem auto;
+  background-repeat: no-repeat;
+}
+select[multiple] option:checked {
+  background: var(--pico-form-element-selected-background-color);
+  color: var(--pico-form-element-color);
+}
+
+[dir=rtl] select:not([multiple], [size]) {
+  background-position: center left 0.75rem;
+}
+
+textarea {
+  display: block;
+  resize: vertical;
+}
+textarea[aria-invalid] {
+  --pico-icon-height: calc(1rem * var(--pico-line-height) + var(--pico-form-element-spacing-vertical) * 2 + var(--pico-border-width) * 2);
+  background-position: top right 0.75rem !important;
+  background-size: 1rem var(--pico-icon-height) !important;
+}
+
+:where(input, select, textarea, fieldset, .grid) + small {
+  display: block;
+  width: 100%;
+  margin-top: calc(var(--pico-spacing) * -0.75);
+  margin-bottom: var(--pico-spacing);
+  color: var(--pico-muted-color);
+}
+:where(input, select, textarea, fieldset, .grid)[aria-invalid=false] + small {
+  color: var(--pico-ins-color);
+}
+:where(input, select, textarea, fieldset, .grid)[aria-invalid=true] + small {
+  color: var(--pico-del-color);
+}
+
+label > :where(input, select, textarea) {
+  margin-top: calc(var(--pico-spacing) * 0.25);
+}
+
+/**
+ * Checkboxes, Radios and Switches
+ */
+label:has([type=checkbox], [type=radio]) {
+  width: -moz-fit-content;
+  width: fit-content;
+  cursor: pointer;
+}
+
+[type=checkbox],
+[type=radio] {
+  -webkit-appearance: none;
+  -moz-appearance: none;
+  appearance: none;
+  width: 1.25em;
+  height: 1.25em;
+  margin-top: -0.125em;
+  margin-inline-end: 0.5em;
+  border-width: var(--pico-border-width);
+  vertical-align: middle;
+  cursor: pointer;
+}
+[type=checkbox]::-ms-check,
+[type=radio]::-ms-check {
+  display: none;
+}
+[type=checkbox]:checked, [type=checkbox]:checked:active, [type=checkbox]:checked:focus,
+[type=radio]:checked,
+[type=radio]:checked:active,
+[type=radio]:checked:focus {
+  --pico-background-color: var(--pico-primary-background);
+  --pico-border-color: var(--pico-primary-border);
+  background-image: var(--pico-icon-checkbox);
+  background-position: center;
+  background-size: 0.75em auto;
+  background-repeat: no-repeat;
+}
+[type=checkbox] ~ label,
+[type=radio] ~ label {
+  display: inline-block;
+  margin-bottom: 0;
+  cursor: pointer;
+}
+[type=checkbox] ~ label:not(:last-of-type),
+[type=radio] ~ label:not(:last-of-type) {
+  margin-inline-end: 1em;
+}
+
+[type=checkbox]:indeterminate {
+  --pico-background-color: var(--pico-primary-background);
+  --pico-border-color: var(--pico-primary-border);
+  background-image: var(--pico-icon-minus);
+  background-position: center;
+  background-size: 0.75em auto;
+  background-repeat: no-repeat;
+}
+
+[type=radio] {
+  border-radius: 50%;
+}
+[type=radio]:checked, [type=radio]:checked:active, [type=radio]:checked:focus {
+  --pico-background-color: var(--pico-primary-inverse);
+  border-width: 0.35em;
+  background-image: none;
+}
+
+[type=checkbox][role=switch] {
+  --pico-background-color: var(--pico-switch-background-color);
+  --pico-color: var(--pico-switch-color);
+  width: 2.25em;
+  height: 1.25em;
+  border: var(--pico-border-width) solid var(--pico-border-color);
+  border-radius: 1.25em;
+  background-color: var(--pico-background-color);
+  line-height: 1.25em;
+}
+[type=checkbox][role=switch]:not([aria-invalid]) {
+  --pico-border-color: var(--pico-switch-background-color);
+}
+[type=checkbox][role=switch]:before {
+  display: block;
+  aspect-ratio: 1;
+  height: 100%;
+  border-radius: 50%;
+  background-color: var(--pico-color);
+  box-shadow: var(--pico-switch-thumb-box-shadow);
+  content: "";
+  transition: margin 0.1s ease-in-out;
+}
+[type=checkbox][role=switch]:focus {
+  --pico-background-color: var(--pico-switch-background-color);
+  --pico-border-color: var(--pico-switch-background-color);
+}
+[type=checkbox][role=switch]:checked {
+  --pico-background-color: var(--pico-switch-checked-background-color);
+  --pico-border-color: var(--pico-switch-checked-background-color);
+  background-image: none;
+}
+[type=checkbox][role=switch]:checked::before {
+  margin-inline-start: calc(2.25em - 1.25em);
+}
+[type=checkbox][role=switch][disabled] {
+  --pico-background-color: var(--pico-border-color);
+}
+
+[type=checkbox][aria-invalid=false]:checked, [type=checkbox][aria-invalid=false]:checked:active, [type=checkbox][aria-invalid=false]:checked:focus,
+[type=checkbox][role=switch][aria-invalid=false]:checked,
+[type=checkbox][role=switch][aria-invalid=false]:checked:active,
+[type=checkbox][role=switch][aria-invalid=false]:checked:focus {
+  --pico-background-color: var(--pico-form-element-valid-border-color);
+}
+[type=checkbox]:checked[aria-invalid=true], [type=checkbox]:checked:active[aria-invalid=true], [type=checkbox]:checked:focus[aria-invalid=true],
+[type=checkbox][role=switch]:checked[aria-invalid=true],
+[type=checkbox][role=switch]:checked:active[aria-invalid=true],
+[type=checkbox][role=switch]:checked:focus[aria-invalid=true] {
+  --pico-background-color: var(--pico-form-element-invalid-border-color);
+}
+
+[type=checkbox][aria-invalid=false]:checked, [type=checkbox][aria-invalid=false]:checked:active, [type=checkbox][aria-invalid=false]:checked:focus,
+[type=radio][aria-invalid=false]:checked,
+[type=radio][aria-invalid=false]:checked:active,
+[type=radio][aria-invalid=false]:checked:focus,
+[type=checkbox][role=switch][aria-invalid=false]:checked,
+[type=checkbox][role=switch][aria-invalid=false]:checked:active,
+[type=checkbox][role=switch][aria-invalid=false]:checked:focus {
+  --pico-border-color: var(--pico-form-element-valid-border-color);
+}
+[type=checkbox]:checked[aria-invalid=true], [type=checkbox]:checked:active[aria-invalid=true], [type=checkbox]:checked:focus[aria-invalid=true],
+[type=radio]:checked[aria-invalid=true],
+[type=radio]:checked:active[aria-invalid=true],
+[type=radio]:checked:focus[aria-invalid=true],
+[type=checkbox][role=switch]:checked[aria-invalid=true],
+[type=checkbox][role=switch]:checked:active[aria-invalid=true],
+[type=checkbox][role=switch]:checked:focus[aria-invalid=true] {
+  --pico-border-color: var(--pico-form-element-invalid-border-color);
+}
+
+/**
+ * Input type color
+ */
+[type=color]::-webkit-color-swatch-wrapper {
+  padding: 0;
+}
+[type=color]::-moz-focus-inner {
+  padding: 0;
+}
+[type=color]::-webkit-color-swatch {
+  border: 0;
+  border-radius: calc(var(--pico-border-radius) * 0.5);
+}
+[type=color]::-moz-color-swatch {
+  border: 0;
+  border-radius: calc(var(--pico-border-radius) * 0.5);
+}
+
+/**
+ * Input type datetime
+ */
+input:not([type=checkbox], [type=radio], [type=range], [type=file]):is([type=date], [type=datetime-local], [type=month], [type=time], [type=week]) {
+  --pico-icon-position: 0.75rem;
+  --pico-icon-width: 1rem;
+  padding-right: calc(var(--pico-icon-width) + var(--pico-icon-position));
+  background-image: var(--pico-icon-date);
+  background-position: center right var(--pico-icon-position);
+  background-size: var(--pico-icon-width) auto;
+  background-repeat: no-repeat;
+}
+input:not([type=checkbox], [type=radio], [type=range], [type=file])[type=time] {
+  background-image: var(--pico-icon-time);
+}
+
+[type=date]::-webkit-calendar-picker-indicator,
+[type=datetime-local]::-webkit-calendar-picker-indicator,
+[type=month]::-webkit-calendar-picker-indicator,
+[type=time]::-webkit-calendar-picker-indicator,
+[type=week]::-webkit-calendar-picker-indicator {
+  width: var(--pico-icon-width);
+  margin-right: calc(var(--pico-icon-width) * -1);
+  margin-left: var(--pico-icon-position);
+  opacity: 0;
+}
+
+@-moz-document url-prefix() {
+  [type=date],
+  [type=datetime-local],
+  [type=month],
+  [type=time],
+  [type=week] {
+    padding-right: var(--pico-form-element-spacing-horizontal) !important;
+    background-image: none !important;
+  }
+}
+[dir=rtl] :is([type=date], [type=datetime-local], [type=month], [type=time], [type=week]) {
+  text-align: right;
+}
+
+/**
+ * Input type file
+ */
+[type=file] {
+  --pico-color: var(--pico-muted-color);
+  margin-left: calc(var(--pico-outline-width) * -1);
+  padding: calc(var(--pico-form-element-spacing-vertical) * 0.5) 0;
+  padding-left: var(--pico-outline-width);
+  border: 0;
+  border-radius: 0;
+  background: none;
+}
+[type=file]::file-selector-button {
+  margin-right: calc(var(--pico-spacing) / 2);
+  padding: calc(var(--pico-form-element-spacing-vertical) * 0.5) var(--pico-form-element-spacing-horizontal);
+}
+[type=file]:is(:hover, :active, :focus)::file-selector-button {
+  --pico-background-color: var(--pico-secondary-hover-background);
+  --pico-border-color: var(--pico-secondary-hover-border);
+}
+[type=file]:focus::file-selector-button {
+  --pico-box-shadow: var(--pico-button-hover-box-shadow, 0 0 0 rgba(0, 0, 0, 0)), 0 0 0 var(--pico-outline-width) var(--pico-secondary-focus);
+}
+
+/**
+ * Input type range
+ */
+[type=range] {
+  -webkit-appearance: none;
+  -moz-appearance: none;
+  appearance: none;
+  width: 100%;
+  height: 1.25rem;
+  background: none;
+}
+[type=range]::-webkit-slider-runnable-track {
+  width: 100%;
+  height: 0.375rem;
+  border-radius: var(--pico-border-radius);
+  background-color: var(--pico-range-border-color);
+  -webkit-transition: background-color var(--pico-transition), box-shadow var(--pico-transition);
+  transition: background-color var(--pico-transition), box-shadow var(--pico-transition);
+}
+[type=range]::-moz-range-track {
+  width: 100%;
+  height: 0.375rem;
+  border-radius: var(--pico-border-radius);
+  background-color: var(--pico-range-border-color);
+  -moz-transition: background-color var(--pico-transition), box-shadow var(--pico-transition);
+  transition: background-color var(--pico-transition), box-shadow var(--pico-transition);
+}
+[type=range]::-ms-track {
+  width: 100%;
+  height: 0.375rem;
+  border-radius: var(--pico-border-radius);
+  background-color: var(--pico-range-border-color);
+  -ms-transition: background-color var(--pico-transition), box-shadow var(--pico-transition);
+  transition: background-color var(--pico-transition), box-shadow var(--pico-transition);
+}
+[type=range]::-webkit-slider-thumb {
+  -webkit-appearance: none;
+  width: 1.25rem;
+  height: 1.25rem;
+  margin-top: -0.4375rem;
+  border: 2px solid var(--pico-range-thumb-border-color);
+  border-radius: 50%;
+  background-color: var(--pico-range-thumb-color);
+  cursor: pointer;
+  -webkit-transition: background-color var(--pico-transition), transform var(--pico-transition);
+  transition: background-color var(--pico-transition), transform var(--pico-transition);
+}
+[type=range]::-moz-range-thumb {
+  -webkit-appearance: none;
+  width: 1.25rem;
+  height: 1.25rem;
+  margin-top: -0.4375rem;
+  border: 2px solid var(--pico-range-thumb-border-color);
+  border-radius: 50%;
+  background-color: var(--pico-range-thumb-color);
+  cursor: pointer;
+  -moz-transition: background-color var(--pico-transition), transform var(--pico-transition);
+  transition: background-color var(--pico-transition), transform var(--pico-transition);
+}
+[type=range]::-ms-thumb {
+  -webkit-appearance: none;
+  width: 1.25rem;
+  height: 1.25rem;
+  margin-top: -0.4375rem;
+  border: 2px solid var(--pico-range-thumb-border-color);
+  border-radius: 50%;
+  background-color: var(--pico-range-thumb-color);
+  cursor: pointer;
+  -ms-transition: background-color var(--pico-transition), transform var(--pico-transition);
+  transition: background-color var(--pico-transition), transform var(--pico-transition);
+}
+[type=range]:active, [type=range]:focus-within {
+  --pico-range-border-color: var(--pico-range-active-border-color);
+  --pico-range-thumb-color: var(--pico-range-thumb-active-color);
+}
+[type=range]:active::-webkit-slider-thumb {
+  transform: scale(1.25);
+}
+[type=range]:active::-moz-range-thumb {
+  transform: scale(1.25);
+}
+[type=range]:active::-ms-thumb {
+  transform: scale(1.25);
+}
+
+/**
+ * Input type search
+ */
+input:not([type=checkbox], [type=radio], [type=range], [type=file])[type=search] {
+  padding-inline-start: calc(var(--pico-form-element-spacing-horizontal) + 1.75rem);
+  background-image: var(--pico-icon-search);
+  background-position: center left calc(var(--pico-form-element-spacing-horizontal) + 0.125rem);
+  background-size: 1rem auto;
+  background-repeat: no-repeat;
+}
+input:not([type=checkbox], [type=radio], [type=range], [type=file])[type=search][aria-invalid] {
+  padding-inline-start: calc(var(--pico-form-element-spacing-horizontal) + 1.75rem) !important;
+  background-position: center left 1.125rem, center right 0.75rem;
+}
+input:not([type=checkbox], [type=radio], [type=range], [type=file])[type=search][aria-invalid=false] {
+  background-image: var(--pico-icon-search), var(--pico-icon-valid);
+}
+input:not([type=checkbox], [type=radio], [type=range], [type=file])[type=search][aria-invalid=true] {
+  background-image: var(--pico-icon-search), var(--pico-icon-invalid);
+}
+
+[dir=rtl] :where(input):not([type=checkbox], [type=radio], [type=range], [type=file])[type=search] {
+  background-position: center right 1.125rem;
+}
+[dir=rtl] :where(input):not([type=checkbox], [type=radio], [type=range], [type=file])[type=search][aria-invalid] {
+  background-position: center right 1.125rem, center left 0.75rem;
+}
+
+/**
+ * Accordion (<details>)
+ */
+details {
+  display: block;
+  margin-bottom: var(--pico-spacing);
+}
+details summary {
+  line-height: 1rem;
+  list-style-type: none;
+  cursor: pointer;
+  transition: color var(--pico-transition);
+}
+details summary:not([role]) {
+  color: var(--pico-accordion-close-summary-color);
+}
+details summary::-webkit-details-marker {
+  display: none;
+}
+details summary::marker {
+  display: none;
+}
+details summary::-moz-list-bullet {
+  list-style-type: none;
+}
+details summary::after {
+  display: block;
+  width: 1rem;
+  height: 1rem;
+  margin-inline-start: calc(var(--pico-spacing, 1rem) * 0.5);
+  float: right;
+  transform: rotate(-90deg);
+  background-image: var(--pico-icon-chevron);
+  background-position: right center;
+  background-size: 1rem auto;
+  background-repeat: no-repeat;
+  content: "";
+  transition: transform var(--pico-transition);
+}
+details summary:focus {
+  outline: none;
+}
+details summary:focus:not([role]) {
+  color: var(--pico-accordion-active-summary-color);
+}
+details summary:focus-visible:not([role]) {
+  outline: var(--pico-outline-width) solid var(--pico-primary-focus);
+  outline-offset: calc(var(--pico-spacing, 1rem) * 0.5);
+  color: var(--pico-primary);
+}
+details summary[role=button] {
+  width: 100%;
+  text-align: left;
+}
+details summary[role=button]::after {
+  height: calc(1rem * var(--pico-line-height, 1.5));
+}
+details[open] > summary {
+  margin-bottom: var(--pico-spacing);
+}
+details[open] > summary:not([role]):not(:focus) {
+  color: var(--pico-accordion-open-summary-color);
+}
+details[open] > summary::after {
+  transform: rotate(0);
+}
+
+[dir=rtl] details summary {
+  text-align: right;
+}
+[dir=rtl] details summary::after {
+  float: left;
+  background-position: left center;
+}
+
+/**
+ * Card (<article>)
+ */
+article {
+  margin-bottom: var(--pico-block-spacing-vertical);
+  padding: var(--pico-block-spacing-vertical) var(--pico-block-spacing-horizontal);
+  border-radius: var(--pico-border-radius);
+  background: var(--pico-card-background-color);
+  box-shadow: var(--pico-card-box-shadow);
+}
+article > header,
+article > footer {
+  margin-right: calc(var(--pico-block-spacing-horizontal) * -1);
+  margin-left: calc(var(--pico-block-spacing-horizontal) * -1);
+  padding: calc(var(--pico-block-spacing-vertical) * 0.66) var(--pico-block-spacing-horizontal);
+  background-color: var(--pico-card-sectioning-background-color);
+}
+article > header {
+  margin-top: calc(var(--pico-block-spacing-vertical) * -1);
+  margin-bottom: var(--pico-block-spacing-vertical);
+  border-bottom: var(--pico-border-width) solid var(--pico-card-border-color);
+  border-top-right-radius: var(--pico-border-radius);
+  border-top-left-radius: var(--pico-border-radius);
+}
+article > footer {
+  margin-top: var(--pico-block-spacing-vertical);
+  margin-bottom: calc(var(--pico-block-spacing-vertical) * -1);
+  border-top: var(--pico-border-width) solid var(--pico-card-border-color);
+  border-bottom-right-radius: var(--pico-border-radius);
+  border-bottom-left-radius: var(--pico-border-radius);
+}
+
+/**
+ * Dropdown (details.dropdown)
+ */
+details.dropdown {
+  position: relative;
+  border-bottom: none;
+}
+details.dropdown summary::after,
+details.dropdown > button::after,
+details.dropdown > a::after {
+  display: block;
+  width: 1rem;
+  height: calc(1rem * var(--pico-line-height, 1.5));
+  margin-inline-start: 0.25rem;
+  float: right;
+  transform: rotate(0deg) translateX(0.2rem);
+  background-image: var(--pico-icon-chevron);
+  background-position: right center;
+  background-size: 1rem auto;
+  background-repeat: no-repeat;
+  content: "";
+}
+
+nav details.dropdown {
+  margin-bottom: 0;
+}
+
+details.dropdown summary:not([role]) {
+  height: calc(1rem * var(--pico-line-height) + var(--pico-form-element-spacing-vertical) * 2 + var(--pico-border-width) * 2);
+  padding: var(--pico-form-element-spacing-vertical) var(--pico-form-element-spacing-horizontal);
+  border: var(--pico-border-width) solid var(--pico-form-element-border-color);
+  border-radius: var(--pico-border-radius);
+  background-color: var(--pico-form-element-background-color);
+  color: var(--pico-form-element-placeholder-color);
+  line-height: inherit;
+  cursor: pointer;
+  -webkit-user-select: none;
+  -moz-user-select: none;
+  user-select: none;
+  transition: background-color var(--pico-transition), border-color var(--pico-transition), color var(--pico-transition), box-shadow var(--pico-transition);
+}
+details.dropdown summary:not([role]):active, details.dropdown summary:not([role]):focus {
+  border-color: var(--pico-form-element-active-border-color);
+  background-color: var(--pico-form-element-active-background-color);
+}
+details.dropdown summary:not([role]):focus {
+  box-shadow: 0 0 0 var(--pico-outline-width) var(--pico-form-element-focus-color);
+}
+details.dropdown summary:not([role]):focus-visible {
+  outline: none;
+}
+details.dropdown summary:not([role])[aria-invalid=false] {
+  --pico-form-element-border-color: var(--pico-form-element-valid-border-color);
+  --pico-form-element-active-border-color: var(--pico-form-element-valid-focus-color);
+  --pico-form-element-focus-color: var(--pico-form-element-valid-focus-color);
+}
+details.dropdown summary:not([role])[aria-invalid=true] {
+  --pico-form-element-border-color: var(--pico-form-element-invalid-border-color);
+  --pico-form-element-active-border-color: var(--pico-form-element-invalid-focus-color);
+  --pico-form-element-focus-color: var(--pico-form-element-invalid-focus-color);
+}
+
+nav details.dropdown {
+  display: inline;
+  margin: calc(var(--pico-nav-element-spacing-vertical) * -1) 0;
+}
+nav details.dropdown summary::after {
+  transform: rotate(0deg) translateX(0rem);
+}
+nav details.dropdown summary:not([role]) {
+  height: calc(1rem * var(--pico-line-height) + var(--pico-nav-link-spacing-vertical) * 2);
+  padding: calc(var(--pico-nav-link-spacing-vertical) - var(--pico-border-width) * 2) var(--pico-nav-link-spacing-horizontal);
+}
+nav details.dropdown summary:not([role]):focus-visible {
+  box-shadow: 0 0 0 var(--pico-outline-width) var(--pico-primary-focus);
+}
+
+details.dropdown summary + ul {
+  display: flex;
+  z-index: 99;
+  position: absolute;
+  left: 0;
+  flex-direction: column;
+  width: 100%;
+  min-width: -moz-fit-content;
+  min-width: fit-content;
+  margin: 0;
+  margin-top: var(--pico-outline-width);
+  padding: 0;
+  border: var(--pico-border-width) solid var(--pico-dropdown-border-color);
+  border-radius: var(--pico-border-radius);
+  background-color: var(--pico-dropdown-background-color);
+  box-shadow: var(--pico-dropdown-box-shadow);
+  color: var(--pico-dropdown-color);
+  white-space: nowrap;
+  opacity: 0;
+  transition: opacity var(--pico-transition), transform 0s ease-in-out 1s;
+}
+details.dropdown summary + ul[dir=rtl] {
+  right: 0;
+  left: auto;
+}
+details.dropdown summary + ul li {
+  width: 100%;
+  margin-bottom: 0;
+  padding: calc(var(--pico-form-element-spacing-vertical) * 0.5) var(--pico-form-element-spacing-horizontal);
+  list-style: none;
+}
+details.dropdown summary + ul li:first-of-type {
+  margin-top: calc(var(--pico-form-element-spacing-vertical) * 0.5);
+}
+details.dropdown summary + ul li:last-of-type {
+  margin-bottom: calc(var(--pico-form-element-spacing-vertical) * 0.5);
+}
+details.dropdown summary + ul li a {
+  display: block;
+  margin: calc(var(--pico-form-element-spacing-vertical) * -0.5) calc(var(--pico-form-element-spacing-horizontal) * -1);
+  padding: calc(var(--pico-form-element-spacing-vertical) * 0.5) var(--pico-form-element-spacing-horizontal);
+  overflow: hidden;
+  border-radius: 0;
+  color: var(--pico-dropdown-color);
+  text-decoration: none;
+  text-overflow: ellipsis;
+}
+details.dropdown summary + ul li a:hover, details.dropdown summary + ul li a:focus, details.dropdown summary + ul li a:active, details.dropdown summary + ul li a:focus-visible, details.dropdown summary + ul li a[aria-current]:not([aria-current=false]) {
+  background-color: var(--pico-dropdown-hover-background-color);
+}
+details.dropdown summary + ul li label {
+  width: 100%;
+}
+details.dropdown summary + ul li:has(label):hover {
+  background-color: var(--pico-dropdown-hover-background-color);
+}
+
+details.dropdown[open] summary {
+  margin-bottom: 0;
+}
+
+details.dropdown[open] summary + ul {
+  transform: scaleY(1);
+  opacity: 1;
+  transition: opacity var(--pico-transition), transform 0s ease-in-out 0s;
+}
+
+details.dropdown[open] summary::before {
+  display: block;
+  z-index: 1;
+  position: fixed;
+  width: 100vw;
+  height: 100vh;
+  inset: 0;
+  background: none;
+  content: "";
+  cursor: default;
+}
+
+label > details.dropdown {
+  margin-top: calc(var(--pico-spacing) * 0.25);
+}
+
+/**
+ * Group ([role="group"], [role="search"])
+ */
+[role=search],
+[role=group] {
+  display: inline-flex;
+  position: relative;
+  width: 100%;
+  margin-bottom: var(--pico-spacing);
+  border-radius: var(--pico-border-radius);
+  box-shadow: var(--pico-group-box-shadow, 0 0 0 rgba(0, 0, 0, 0));
+  vertical-align: middle;
+  transition: box-shadow var(--pico-transition);
+}
+[role=search] > *,
+[role=search] input:not([type=checkbox], [type=radio]),
+[role=search] select,
+[role=group] > *,
+[role=group] input:not([type=checkbox], [type=radio]),
+[role=group] select {
+  position: relative;
+  flex: 1 1 auto;
+  margin-bottom: 0;
+}
+[role=search] > *:not(:first-child),
+[role=search] input:not([type=checkbox], [type=radio]):not(:first-child),
+[role=search] select:not(:first-child),
+[role=group] > *:not(:first-child),
+[role=group] input:not([type=checkbox], [type=radio]):not(:first-child),
+[role=group] select:not(:first-child) {
+  margin-left: 0;
+  border-top-left-radius: 0;
+  border-bottom-left-radius: 0;
+}
+[role=search] > *:not(:last-child),
+[role=search] input:not([type=checkbox], [type=radio]):not(:last-child),
+[role=search] select:not(:last-child),
+[role=group] > *:not(:last-child),
+[role=group] input:not([type=checkbox], [type=radio]):not(:last-child),
+[role=group] select:not(:last-child) {
+  border-top-right-radius: 0;
+  border-bottom-right-radius: 0;
+}
+[role=search] > *:focus,
+[role=search] input:not([type=checkbox], [type=radio]):focus,
+[role=search] select:focus,
+[role=group] > *:focus,
+[role=group] input:not([type=checkbox], [type=radio]):focus,
+[role=group] select:focus {
+  z-index: 2;
+}
+[role=search] button:not(:first-child),
+[role=search] [type=submit]:not(:first-child),
+[role=search] [type=reset]:not(:first-child),
+[role=search] [type=button]:not(:first-child),
+[role=search] [role=button]:not(:first-child),
+[role=search] input:not([type=checkbox], [type=radio]):not(:first-child),
+[role=search] select:not(:first-child),
+[role=group] button:not(:first-child),
+[role=group] [type=submit]:not(:first-child),
+[role=group] [type=reset]:not(:first-child),
+[role=group] [type=button]:not(:first-child),
+[role=group] [role=button]:not(:first-child),
+[role=group] input:not([type=checkbox], [type=radio]):not(:first-child),
+[role=group] select:not(:first-child) {
+  margin-left: calc(var(--pico-border-width) * -1);
+}
+[role=search] button,
+[role=search] [type=submit],
+[role=search] [type=reset],
+[role=search] [type=button],
+[role=search] [role=button],
+[role=group] button,
+[role=group] [type=submit],
+[role=group] [type=reset],
+[role=group] [type=button],
+[role=group] [role=button] {
+  width: auto;
+}
+@supports selector(:has(*)) {
+  [role=search]:has(button:focus, [type=submit]:focus, [type=button]:focus, [role=button]:focus),
+  [role=group]:has(button:focus, [type=submit]:focus, [type=button]:focus, [role=button]:focus) {
+    --pico-group-box-shadow: var(--pico-group-box-shadow-focus-with-button);
+  }
+  [role=search]:has(button:focus, [type=submit]:focus, [type=button]:focus, [role=button]:focus) input:not([type=checkbox], [type=radio]),
+  [role=search]:has(button:focus, [type=submit]:focus, [type=button]:focus, [role=button]:focus) select,
+  [role=group]:has(button:focus, [type=submit]:focus, [type=button]:focus, [role=button]:focus) input:not([type=checkbox], [type=radio]),
+  [role=group]:has(button:focus, [type=submit]:focus, [type=button]:focus, [role=button]:focus) select {
+    border-color: transparent;
+  }
+  [role=search]:has(input:not([type=submit], [type=button]):focus, select:focus),
+  [role=group]:has(input:not([type=submit], [type=button]):focus, select:focus) {
+    --pico-group-box-shadow: var(--pico-group-box-shadow-focus-with-input);
+  }
+  [role=search]:has(input:not([type=submit], [type=button]):focus, select:focus) button,
+  [role=search]:has(input:not([type=submit], [type=button]):focus, select:focus) [type=submit],
+  [role=search]:has(input:not([type=submit], [type=button]):focus, select:focus) [type=button],
+  [role=search]:has(input:not([type=submit], [type=button]):focus, select:focus) [role=button],
+  [role=group]:has(input:not([type=submit], [type=button]):focus, select:focus) button,
+  [role=group]:has(input:not([type=submit], [type=button]):focus, select:focus) [type=submit],
+  [role=group]:has(input:not([type=submit], [type=button]):focus, select:focus) [type=button],
+  [role=group]:has(input:not([type=submit], [type=button]):focus, select:focus) [role=button] {
+    --pico-button-box-shadow: 0 0 0 var(--pico-border-width) var(--pico-primary-border);
+    --pico-button-hover-box-shadow: 0 0 0 var(--pico-border-width) var(--pico-primary-hover-border);
+  }
+  [role=search] button:focus,
+  [role=search] [type=submit]:focus,
+  [role=search] [type=reset]:focus,
+  [role=search] [type=button]:focus,
+  [role=search] [role=button]:focus,
+  [role=group] button:focus,
+  [role=group] [type=submit]:focus,
+  [role=group] [type=reset]:focus,
+  [role=group] [type=button]:focus,
+  [role=group] [role=button]:focus {
+    box-shadow: none;
+  }
+}
+
+[role=search] > *:first-child {
+  border-top-left-radius: 5rem;
+  border-bottom-left-radius: 5rem;
+}
+[role=search] > *:last-child {
+  border-top-right-radius: 5rem;
+  border-bottom-right-radius: 5rem;
+}
+
+/**
+ * Loading ([aria-busy=true])
+ */
+[aria-busy=true]:not(input, select, textarea, html) {
+  white-space: nowrap;
+}
+[aria-busy=true]:not(input, select, textarea, html)::before {
+  display: inline-block;
+  width: 1em;
+  height: 1em;
+  background-image: var(--pico-icon-loading);
+  background-size: 1em auto;
+  background-repeat: no-repeat;
+  content: "";
+  vertical-align: -0.125em;
+}
+[aria-busy=true]:not(input, select, textarea, html):not(:empty)::before {
+  margin-inline-end: calc(var(--pico-spacing) * 0.5);
+}
+[aria-busy=true]:not(input, select, textarea, html):empty {
+  text-align: center;
+}
+
+button[aria-busy=true],
+[type=submit][aria-busy=true],
+[type=button][aria-busy=true],
+[type=reset][aria-busy=true],
+[role=button][aria-busy=true],
+a[aria-busy=true] {
+  pointer-events: none;
+}
+
+/**
+ * Modal (<dialog>)
+ */
+:root {
+  --pico-scrollbar-width: 0px;
+}
+
+dialog {
+  display: flex;
+  z-index: 999;
+  position: fixed;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  align-items: center;
+  justify-content: center;
+  width: inherit;
+  min-width: 100%;
+  height: inherit;
+  min-height: 100%;
+  padding: 0;
+  border: 0;
+  -webkit-backdrop-filter: var(--pico-modal-overlay-backdrop-filter);
+  backdrop-filter: var(--pico-modal-overlay-backdrop-filter);
+  background-color: var(--pico-modal-overlay-background-color);
+  color: var(--pico-color);
+}
+dialog article {
+  width: 100%;
+  max-height: calc(100vh - var(--pico-spacing) * 2);
+  margin: var(--pico-spacing);
+  overflow: auto;
+}
+@media (min-width: 576px) {
+  dialog article {
+    max-width: 510px;
+  }
+}
+@media (min-width: 768px) {
+  dialog article {
+    max-width: 700px;
+  }
+}
+dialog article > header > * {
+  margin-bottom: 0;
+}
+dialog article > header .close, dialog article > header :is(a, button)[rel=prev] {
+  margin: 0;
+  margin-left: var(--pico-spacing);
+  padding: 0;
+  float: right;
+}
+dialog article > footer {
+  text-align: right;
+}
+dialog article > footer button,
+dialog article > footer [role=button] {
+  margin-bottom: 0;
+}
+dialog article > footer button:not(:first-of-type),
+dialog article > footer [role=button]:not(:first-of-type) {
+  margin-left: calc(var(--pico-spacing) * 0.5);
+}
+dialog article .close, dialog article :is(a, button)[rel=prev] {
+  display: block;
+  width: 1rem;
+  height: 1rem;
+  margin-top: calc(var(--pico-spacing) * -1);
+  margin-bottom: var(--pico-spacing);
+  margin-left: auto;
+  border: none;
+  background-image: var(--pico-icon-close);
+  background-position: center;
+  background-size: auto 1rem;
+  background-repeat: no-repeat;
+  background-color: transparent;
+  opacity: 0.5;
+  transition: opacity var(--pico-transition);
+}
+dialog article .close:is([aria-current]:not([aria-current=false]), :hover, :active, :focus), dialog article :is(a, button)[rel=prev]:is([aria-current]:not([aria-current=false]), :hover, :active, :focus) {
+  opacity: 1;
+}
+dialog:not([open]), dialog[open=false] {
+  display: none;
+}
+
+.modal-is-open {
+  padding-right: var(--pico-scrollbar-width, 0px);
+  overflow: hidden;
+  pointer-events: none;
+  touch-action: none;
+}
+.modal-is-open dialog {
+  pointer-events: auto;
+  touch-action: auto;
+}
+
+:where(.modal-is-opening, .modal-is-closing) dialog,
+:where(.modal-is-opening, .modal-is-closing) dialog > article {
+  animation-duration: 0.2s;
+  animation-timing-function: ease-in-out;
+  animation-fill-mode: both;
+}
+:where(.modal-is-opening, .modal-is-closing) dialog {
+  animation-duration: 0.8s;
+  animation-name: modal-overlay;
+}
+:where(.modal-is-opening, .modal-is-closing) dialog > article {
+  animation-delay: 0.2s;
+  animation-name: modal;
+}
+
+.modal-is-closing dialog,
+.modal-is-closing dialog > article {
+  animation-delay: 0s;
+  animation-direction: reverse;
+}
+
+@keyframes modal-overlay {
+  from {
+    -webkit-backdrop-filter: none;
+    backdrop-filter: none;
+    background-color: transparent;
+  }
+}
+@keyframes modal {
+  from {
+    transform: translateY(-100%);
+    opacity: 0;
+  }
+}
+/**
+ * Nav
+ */
+:where(nav li)::before {
+  float: left;
+  content: "​";
+}
+
+nav,
+nav ul {
+  display: flex;
+}
+
+nav {
+  justify-content: space-between;
+  overflow: visible;
+}
+nav ol,
+nav ul {
+  align-items: center;
+  margin-bottom: 0;
+  padding: 0;
+  list-style: none;
+}
+nav ol:first-of-type,
+nav ul:first-of-type {
+  margin-left: calc(var(--pico-nav-element-spacing-horizontal) * -1);
+}
+nav ol:last-of-type,
+nav ul:last-of-type {
+  margin-right: calc(var(--pico-nav-element-spacing-horizontal) * -1);
+}
+nav li {
+  display: inline-block;
+  margin: 0;
+  padding: var(--pico-nav-element-spacing-vertical) var(--pico-nav-element-spacing-horizontal);
+}
+nav li :where(a, [role=link]) {
+  display: inline-block;
+  margin: calc(var(--pico-nav-link-spacing-vertical) * -1) calc(var(--pico-nav-link-spacing-horizontal) * -1);
+  padding: var(--pico-nav-link-spacing-vertical) var(--pico-nav-link-spacing-horizontal);
+  border-radius: var(--pico-border-radius);
+}
+nav li :where(a, [role=link]):not(:hover) {
+  text-decoration: none;
+}
+nav li button,
+nav li [role=button],
+nav li [type=button],
+nav li input:not([type=checkbox], [type=radio], [type=range], [type=file]),
+nav li select {
+  height: auto;
+  margin-right: inherit;
+  margin-bottom: 0;
+  margin-left: inherit;
+  padding: calc(var(--pico-nav-link-spacing-vertical) - var(--pico-border-width) * 2) var(--pico-nav-link-spacing-horizontal);
+}
+nav[aria-label=breadcrumb] {
+  align-items: center;
+  justify-content: start;
+}
+nav[aria-label=breadcrumb] ul li:not(:first-child) {
+  margin-inline-start: var(--pico-nav-link-spacing-horizontal);
+}
+nav[aria-label=breadcrumb] ul li a {
+  margin: calc(var(--pico-nav-link-spacing-vertical) * -1) 0;
+  margin-inline-start: calc(var(--pico-nav-link-spacing-horizontal) * -1);
+}
+nav[aria-label=breadcrumb] ul li:not(:last-child)::after {
+  display: inline-block;
+  position: absolute;
+  width: calc(var(--pico-nav-link-spacing-horizontal) * 4);
+  margin: 0 calc(var(--pico-nav-link-spacing-horizontal) * -1);
+  content: var(--pico-nav-breadcrumb-divider);
+  color: var(--pico-muted-color);
+  text-align: center;
+  text-decoration: none;
+  white-space: nowrap;
+}
+nav[aria-label=breadcrumb] a[aria-current]:not([aria-current=false]) {
+  background-color: transparent;
+  color: inherit;
+  text-decoration: none;
+  pointer-events: none;
+}
+
+aside nav,
+aside ol,
+aside ul,
+aside li {
+  display: block;
+}
+aside li {
+  padding: calc(var(--pico-nav-element-spacing-vertical) * 0.5) var(--pico-nav-element-spacing-horizontal);
+}
+aside li a {
+  display: block;
+}
+aside li [role=button] {
+  margin: inherit;
+}
+
+[dir=rtl] nav[aria-label=breadcrumb] ul li:not(:last-child) ::after {
+  content: "\\";
+}
+
+/**
+ * Progress
+ */
+progress {
+  display: inline-block;
+  vertical-align: baseline;
+}
+
+progress {
+  -webkit-appearance: none;
+  -moz-appearance: none;
+  display: inline-block;
+  appearance: none;
+  width: 100%;
+  height: 0.5rem;
+  margin-bottom: calc(var(--pico-spacing) * 0.5);
+  overflow: hidden;
+  border: 0;
+  border-radius: var(--pico-border-radius);
+  background-color: var(--pico-progress-background-color);
+  color: var(--pico-progress-color);
+}
+progress::-webkit-progress-bar {
+  border-radius: var(--pico-border-radius);
+  background: none;
+}
+progress[value]::-webkit-progress-value {
+  background-color: var(--pico-progress-color);
+  -webkit-transition: inline-size var(--pico-transition);
+  transition: inline-size var(--pico-transition);
+}
+progress::-moz-progress-bar {
+  background-color: var(--pico-progress-color);
+}
+@media (prefers-reduced-motion: no-preference) {
+  progress:indeterminate {
+    background: var(--pico-progress-background-color) linear-gradient(to right, var(--pico-progress-color) 30%, var(--pico-progress-background-color) 30%) top left/150% 150% no-repeat;
+    animation: progress-indeterminate 1s linear infinite;
+  }
+  progress:indeterminate[value]::-webkit-progress-value {
+    background-color: transparent;
+  }
+  progress:indeterminate::-moz-progress-bar {
+    background-color: transparent;
+  }
+}
+
+@media (prefers-reduced-motion: no-preference) {
+  [dir=rtl] progress:indeterminate {
+    animation-direction: reverse;
+  }
+}
+
+@keyframes progress-indeterminate {
+  0% {
+    background-position: 200% 0;
+  }
+  100% {
+    background-position: -200% 0;
+  }
+}
+/**
+ * Tooltip ([data-tooltip])
+ */
+[data-tooltip] {
+  position: relative;
+}
+[data-tooltip]:not(a, button, input) {
+  border-bottom: 1px dotted;
+  text-decoration: none;
+  cursor: help;
+}
+[data-tooltip][data-placement=top]::before, [data-tooltip][data-placement=top]::after, [data-tooltip]::before, [data-tooltip]::after {
+  display: block;
+  z-index: 99;
+  position: absolute;
+  bottom: 100%;
+  left: 50%;
+  padding: 0.25rem 0.5rem;
+  overflow: hidden;
+  transform: translate(-50%, -0.25rem);
+  border-radius: var(--pico-border-radius);
+  background: var(--pico-tooltip-background-color);
+  content: attr(data-tooltip);
+  color: var(--pico-tooltip-color);
+  font-style: normal;
+  font-weight: var(--pico-font-weight);
+  font-size: 0.875rem;
+  text-decoration: none;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  opacity: 0;
+  pointer-events: none;
+}
+[data-tooltip][data-placement=top]::after, [data-tooltip]::after {
+  padding: 0;
+  transform: translate(-50%, 0rem);
+  border-top: 0.3rem solid;
+  border-right: 0.3rem solid transparent;
+  border-left: 0.3rem solid transparent;
+  border-radius: 0;
+  background-color: transparent;
+  content: "";
+  color: var(--pico-tooltip-background-color);
+}
+[data-tooltip][data-placement=bottom]::before, [data-tooltip][data-placement=bottom]::after {
+  top: 100%;
+  bottom: auto;
+  transform: translate(-50%, 0.25rem);
+}
+[data-tooltip][data-placement=bottom]:after {
+  transform: translate(-50%, -0.3rem);
+  border: 0.3rem solid transparent;
+  border-bottom: 0.3rem solid;
+}
+[data-tooltip][data-placement=left]::before, [data-tooltip][data-placement=left]::after {
+  top: 50%;
+  right: 100%;
+  bottom: auto;
+  left: auto;
+  transform: translate(-0.25rem, -50%);
+}
+[data-tooltip][data-placement=left]:after {
+  transform: translate(0.3rem, -50%);
+  border: 0.3rem solid transparent;
+  border-left: 0.3rem solid;
+}
+[data-tooltip][data-placement=right]::before, [data-tooltip][data-placement=right]::after {
+  top: 50%;
+  right: auto;
+  bottom: auto;
+  left: 100%;
+  transform: translate(0.25rem, -50%);
+}
+[data-tooltip][data-placement=right]:after {
+  transform: translate(-0.3rem, -50%);
+  border: 0.3rem solid transparent;
+  border-right: 0.3rem solid;
+}
+[data-tooltip]:focus::before, [data-tooltip]:focus::after, [data-tooltip]:hover::before, [data-tooltip]:hover::after {
+  opacity: 1;
+}
+@media (hover: hover) and (pointer: fine) {
+  [data-tooltip]:focus::before, [data-tooltip]:focus::after, [data-tooltip]:hover::before, [data-tooltip]:hover::after {
+    --pico-tooltip-slide-to: translate(-50%, -0.25rem);
+    transform: translate(-50%, 0.75rem);
+    animation-duration: 0.2s;
+    animation-fill-mode: forwards;
+    animation-name: tooltip-slide;
+    opacity: 0;
+  }
+  [data-tooltip]:focus::after, [data-tooltip]:hover::after {
+    --pico-tooltip-caret-slide-to: translate(-50%, 0rem);
+    transform: translate(-50%, -0.25rem);
+    animation-name: tooltip-caret-slide;
+  }
+  [data-tooltip][data-placement=bottom]:focus::before, [data-tooltip][data-placement=bottom]:focus::after, [data-tooltip][data-placement=bottom]:hover::before, [data-tooltip][data-placement=bottom]:hover::after {
+    --pico-tooltip-slide-to: translate(-50%, 0.25rem);
+    transform: translate(-50%, -0.75rem);
+    animation-name: tooltip-slide;
+  }
+  [data-tooltip][data-placement=bottom]:focus::after, [data-tooltip][data-placement=bottom]:hover::after {
+    --pico-tooltip-caret-slide-to: translate(-50%, -0.3rem);
+    transform: translate(-50%, -0.5rem);
+    animation-name: tooltip-caret-slide;
+  }
+  [data-tooltip][data-placement=left]:focus::before, [data-tooltip][data-placement=left]:focus::after, [data-tooltip][data-placement=left]:hover::before, [data-tooltip][data-placement=left]:hover::after {
+    --pico-tooltip-slide-to: translate(-0.25rem, -50%);
+    transform: translate(0.75rem, -50%);
+    animation-name: tooltip-slide;
+  }
+  [data-tooltip][data-placement=left]:focus::after, [data-tooltip][data-placement=left]:hover::after {
+    --pico-tooltip-caret-slide-to: translate(0.3rem, -50%);
+    transform: translate(0.05rem, -50%);
+    animation-name: tooltip-caret-slide;
+  }
+  [data-tooltip][data-placement=right]:focus::before, [data-tooltip][data-placement=right]:focus::after, [data-tooltip][data-placement=right]:hover::before, [data-tooltip][data-placement=right]:hover::after {
+    --pico-tooltip-slide-to: translate(0.25rem, -50%);
+    transform: translate(-0.75rem, -50%);
+    animation-name: tooltip-slide;
+  }
+  [data-tooltip][data-placement=right]:focus::after, [data-tooltip][data-placement=right]:hover::after {
+    --pico-tooltip-caret-slide-to: translate(-0.3rem, -50%);
+    transform: translate(-0.05rem, -50%);
+    animation-name: tooltip-caret-slide;
+  }
+}
+@keyframes tooltip-slide {
+  to {
+    transform: var(--pico-tooltip-slide-to);
+    opacity: 1;
+  }
+}
+@keyframes tooltip-caret-slide {
+  50% {
+    opacity: 0;
+  }
+  to {
+    transform: var(--pico-tooltip-caret-slide-to);
+    opacity: 1;
+  }
+}
+
+/**
+ * Accessibility & User interaction
+ */
+[aria-controls] {
+  cursor: pointer;
+}
+
+[aria-disabled=true],
+[disabled] {
+  cursor: not-allowed;
+}
+
+[aria-hidden=false][hidden] {
+  display: initial;
+}
+
+[aria-hidden=false][hidden]:not(:focus) {
+  clip: rect(0, 0, 0, 0);
+  position: absolute;
+}
+
+a,
+area,
+button,
+input,
+label,
+select,
+summary,
+textarea,
+[tabindex] {
+  -ms-touch-action: manipulation;
+}
+
+[dir=rtl] {
+  direction: rtl;
+}
+
+/**
+ * Reduce Motion Features
+ */
+@media (prefers-reduced-motion: reduce) {
+  *:not([aria-busy=true]),
+  :not([aria-busy=true])::before,
+  :not([aria-busy=true])::after {
+    background-attachment: initial !important;
+    animation-duration: 1ms !important;
+    animation-delay: -1ms !important;
+    animation-iteration-count: 1 !important;
+    scroll-behavior: auto !important;
+    transition-delay: 0s !important;
+    transition-duration: 0s !important;
+  }
+}
\ No newline at end of file
diff --git a/test/js/bun/css/files/random-gradients.css b/test/js/bun/css/files/random-gradients.css
new file mode 100644
index 0000000000..7821c50480
--- /dev/null
+++ b/test/js/bun/css/files/random-gradients.css
@@ -0,0 +1,112 @@
+.gradient-1 {
+    background: linear-gradient(45deg, #ff6b6b, #4ecdc4);
+}
+
+.gradient-2 {
+    background: radial-gradient(circle, #ffd166, #06d6a0);
+}
+
+.gradient-3 {
+    background: conic-gradient(from 45deg, #118ab2, #ef476f, #ffd166);
+}
+
+.gradient-4 {
+    background: linear-gradient(to right, #e76f51, #f4a261, #e9c46a);
+}
+
+.gradient-5 {
+    background: repeating-linear-gradient(45deg, #2a9d8f, #2a9d8f 10px, #264653 10px, #264653 20px);
+}
+
+.gradient-6 {
+    background: linear-gradient(135deg, #540d6e, #ee4266, #ffd23f);
+}
+
+.gradient-7 {
+    background: radial-gradient(ellipse at top left, #3a86ff, #8338ec, #ff006e);
+}
+
+.gradient-8 {
+    background: linear-gradient(to bottom right, #f72585, #7209b7, #3a0ca3, #4361ee);
+}
+
+.gradient-9 {
+    background: repeating-radial-gradient(circle at 50% 50%, #b5179e, #b5179e 10px, #7209b7 10px, #7209b7 20px);
+}
+
+.gradient-10 {
+    background: conic-gradient(at 70% 30%, #ff9e00, #ff0000, #ff00bf, #a033ff, #0096ff);
+}
+
+.lmao {
+  background: rgb(2,0,36);
+  background: -moz-linear-gradient(90deg, rgba(2,0,36,1) 0%, rgba(9,9,121,1) 35%, rgba(0,212,255,1) 100%);
+  background: -webkit-linear-gradient(90deg, rgba(2,0,36,1) 0%, rgba(9,9,121,1) 35%, rgba(0,212,255,1) 100%);
+  background: linear-gradient(90deg, rgba(2,0,36,1) 0%, rgba(9,9,121,1) 35%, rgba(0,212,255,1) 100%);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr="#020024",endColorstr="#00d4ff",GradientType=1);
+}
+
+.lol {
+  background: rgb(238,174,202);
+  background: -moz-radial-gradient(circle, rgba(238,174,202,1) 0%, rgba(251,0,0,1) 25%, rgba(255,169,0,1) 33%, rgba(150,107,159,1) 47%, rgba(126,88,147,1) 60%, rgba(123,9,241,1) 72%, rgba(51,31,111,0.7749474789915967) 100%);
+  background: -webkit-radial-gradient(circle, rgba(238,174,202,1) 0%, rgba(251,0,0,1) 25%, rgba(255,169,0,1) 33%, rgba(150,107,159,1) 47%, rgba(126,88,147,1) 60%, rgba(123,9,241,1) 72%, rgba(51,31,111,0.7749474789915967) 100%);
+  background: radial-gradient(circle, rgba(238,174,202,1) 0%, rgba(251,0,0,1) 25%, rgba(255,169,0,1) 33%, rgba(150,107,159,1) 47%, rgba(126,88,147,1) 60%, rgba(123,9,241,1) 72%, rgba(51,31,111,0.7749474789915967) 100%);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr="#eeaeca",endColorstr="#331f6f",GradientType=1);
+}
+
+.gradient-11 {
+    background: conic-gradient(from 217deg at 82% 65%, #ff6b6b 0deg, #4ecdc4 72deg, #45b7d1 144deg, #f8a5c2 216deg, #c3f0ca 288deg, #ff6b6b 360deg);
+}
+
+.gradient-12 {
+    background: repeating-radial-gradient(circle at 10% 20%, #ff9a8b 0%, #ff6a88 5%, #ff99ac 10%, #ff9a8b 15%);
+}
+
+.gradient-13 {
+    background: linear-gradient(45deg, #8a2387, #e94057, #f27121),
+                linear-gradient(135deg, #00c6ff, #0072ff);
+    background-blend-mode: multiply;
+}
+
+.gradient-14 {
+    background: radial-gradient(circle at top right, #ff0844, #ffb199),
+                radial-gradient(circle at bottom left, #21d4fd, #b721ff);
+    background-blend-mode: screen;
+}
+
+.gradient-15 {
+    background: repeating-conic-gradient(from 45deg, #3f5efb 0deg 10deg, #fc466b 10deg 20deg, #3f5efb 20deg 30deg);
+}
+
+.gradient-16 {
+    background: 
+        linear-gradient(217deg, rgba(255,0,0,.8), rgba(255,0,0,0) 70.71%),
+        linear-gradient(127deg, rgba(0,255,0,.8), rgba(0,255,0,0) 70.71%),
+        linear-gradient(336deg, rgba(0,0,255,.8), rgba(0,0,255,0) 70.71%);
+}
+
+.gradient-17 {
+    background: 
+        radial-gradient(circle at 50% -20%, #ff758c, transparent 80%),
+        radial-gradient(circle at 50% 120%, #ff7eb3, transparent 80%);
+}
+
+.gradient-18 {
+    background-image: 
+        repeating-linear-gradient(45deg, #3f87a6 0px, #3f87a6 20px, #ebf8e1 20px, #ebf8e1 40px),
+        repeating-linear-gradient(-45deg, #f69d3c 0px, #f69d3c 20px, #3f87a6 20px, #3f87a6 40px);
+}
+
+.gradient-19 {
+    background: 
+        linear-gradient(to right, #fa709a 0%, #fee140 100%),
+        linear-gradient(to top, #30cfd0 0%, #330867 100%);
+    background-blend-mode: soft-light;
+}
+
+.gradient-20 {
+    background: 
+        radial-gradient(circle at 30% 107%, #fdf497 0%, #fdf497 5%, #fd5949 45%, #d6249f 60%, #285aeb 90%),
+        linear-gradient(135deg, #79f1a4 10%, #0e5cad 100%);
+    background-blend-mode: overlay;
+}
diff --git a/test/js/bun/css/files/tachyons.css b/test/js/bun/css/files/tachyons.css
new file mode 100644
index 0000000000..b83624b13d
--- /dev/null
+++ b/test/js/bun/css/files/tachyons.css
@@ -0,0 +1,3315 @@
+/*! TACHYONS v4.12.0 | http://tachyons.io */
+/*
+ *
+ *      ________            ______
+ *      ___  __/_____ _________  /______  ______________________
+ *      __  /  _  __ `/  ___/_  __ \_  / / /  __ \_  __ \_  ___/
+ *      _  /   / /_/ // /__ _  / / /  /_/ // /_/ /  / / /(__  )
+ *      /_/    \__,_/ \___/ /_/ /_/_\__, / \____//_/ /_//____/
+ *                                 /____/
+ *
+ *    TABLE OF CONTENTS
+ *
+ *    1. External Library Includes
+ *       - Normalize.css | http://normalize.css.github.io
+ *    2. Tachyons Modules
+ *    3. Variables
+ *       - Media Queries
+ *       - Colors
+ *    4. Debugging
+ *       - Debug all
+ *       - Debug children
+ *
+ */
+/* External Library Includes */
+/*! normalize.css v8.0.0 | MIT License | github.com/necolas/normalize.css */
+/* Document
+   ========================================================================== */
+/**
+ * 1. Correct the line height in all browsers.
+ * 2. Prevent adjustments of font size after orientation changes in iOS.
+ */
+ html { line-height: 1.15; /* 1 */ -webkit-text-size-adjust: 100%; /* 2 */ }
+ /* Sections
+    ========================================================================== */
+ /**
+  * Remove the margin in all browsers.
+  */
+ body { margin: 0; }
+ /**
+  * Correct the font size and margin on `h1` elements within `section` and
+  * `article` contexts in Chrome, Firefox, and Safari.
+  */
+ h1 { font-size: 2em; margin: .67em 0; }
+ /* Grouping content
+    ========================================================================== */
+ /**
+  * 1. Add the correct box sizing in Firefox.
+  * 2. Show the overflow in Edge and IE.
+  */
+ hr { box-sizing: content-box; /* 1 */ height: 0; /* 1 */ overflow: visible; /* 2 */ }
+ /**
+  * 1. Correct the inheritance and scaling of font size in all browsers.
+  * 2. Correct the odd `em` font sizing in all browsers.
+  */
+ pre { font-family: monospace, monospace; /* 1 */ font-size: 1em; /* 2 */ }
+ /* Text-level semantics
+    ========================================================================== */
+ /**
+  * Remove the gray background on active links in IE 10.
+  */
+ a { background-color: transparent; }
+ /**
+  * 1. Remove the bottom border in Chrome 57-
+  * 2. Add the correct text decoration in Chrome, Edge, IE, Opera, and Safari.
+  */
+ abbr[title] { border-bottom: none; /* 1 */ text-decoration: underline; /* 2 */ -webkit-text-decoration: underline dotted; text-decoration: underline dotted; /* 2 */ }
+ /**
+  * Add the correct font weight in Chrome, Edge, and Safari.
+  */
+ b, strong { font-weight: bolder; }
+ /**
+  * 1. Correct the inheritance and scaling of font size in all browsers.
+  * 2. Correct the odd `em` font sizing in all browsers.
+  */
+ code, kbd, samp { font-family: monospace, monospace; /* 1 */ font-size: 1em; /* 2 */ }
+ /**
+  * Add the correct font size in all browsers.
+  */
+ small { font-size: 80%; }
+ /**
+  * Prevent `sub` and `sup` elements from affecting the line height in
+  * all browsers.
+  */
+ sub, sup { font-size: 75%; line-height: 0; position: relative; vertical-align: baseline; }
+ sub { bottom: -0.25em; }
+ sup { top: -0.5em; }
+ /* Embedded content
+    ========================================================================== */
+ /**
+  * Remove the border on images inside links in IE 10.
+  */
+ img { border-style: none; }
+ /* Forms
+    ========================================================================== */
+ /**
+  * 1. Change the font styles in all browsers.
+  * 2. Remove the margin in Firefox and Safari.
+  */
+ button, input, optgroup, select, textarea { font-family: inherit; /* 1 */ font-size: 100%; /* 1 */ line-height: 1.15; /* 1 */ margin: 0; /* 2 */ }
+ /**
+  * Show the overflow in IE.
+  * 1. Show the overflow in Edge.
+  */
+ button, input {/* 1 */ overflow: visible; }
+ /**
+  * Remove the inheritance of text transform in Edge, Firefox, and IE.
+  * 1. Remove the inheritance of text transform in Firefox.
+  */
+ button, select {/* 1 */ text-transform: none; }
+ /**
+  * Correct the inability to style clickable types in iOS and Safari.
+  */
+ button, [type="button"], [type="reset"], [type="submit"] { -webkit-appearance: button; }
+ /**
+  * Remove the inner border and padding in Firefox.
+  */
+ button::-moz-focus-inner, [type="button"]::-moz-focus-inner,
+ [type="reset"]::-moz-focus-inner, [type="submit"]::-moz-focus-inner { border-style: none; padding: 0; }
+ /**
+  * Restore the focus styles unset by the previous rule.
+  */
+ button:-moz-focusring, [type="button"]:-moz-focusring,
+ [type="reset"]:-moz-focusring, [type="submit"]:-moz-focusring { outline: 1px dotted ButtonText; }
+ /**
+  * Correct the padding in Firefox.
+  */
+ fieldset { padding: .35em .75em .625em; }
+ /**
+  * 1. Correct the text wrapping in Edge and IE.
+  * 2. Correct the color inheritance from `fieldset` elements in IE.
+  * 3. Remove the padding so developers are not caught out when they zero out
+  *    `fieldset` elements in all browsers.
+  */
+ legend { box-sizing: border-box; /* 1 */ color: inherit; /* 2 */ display: table; /* 1 */ max-width: 100%; /* 1 */ padding: 0; /* 3 */ white-space: normal; /* 1 */ }
+ /**
+  * Add the correct vertical alignment in Chrome, Firefox, and Opera.
+  */
+ progress { vertical-align: baseline; }
+ /**
+  * Remove the default vertical scrollbar in IE 10+.
+  */
+ textarea { overflow: auto; }
+ /**
+  * 1. Add the correct box sizing in IE 10.
+  * 2. Remove the padding in IE 10.
+  */
+ [type="checkbox"], [type="radio"] { box-sizing: border-box; /* 1 */ padding: 0; /* 2 */ }
+ /**
+  * Correct the cursor style of increment and decrement buttons in Chrome.
+  */
+ [type="number"]::-webkit-inner-spin-button,
+ [type="number"]::-webkit-outer-spin-button { height: auto; }
+ /**
+  * 1. Correct the odd appearance in Chrome and Safari.
+  * 2. Correct the outline style in Safari.
+  */
+ [type="search"] { -webkit-appearance: textfield; /* 1 */ outline-offset: -2px; /* 2 */ }
+ /**
+  * Remove the inner padding in Chrome and Safari on macOS.
+  */
+ [type="search"]::-webkit-search-decoration { -webkit-appearance: none; }
+ /**
+  * 1. Correct the inability to style clickable types in iOS and Safari.
+  * 2. Change font properties to `inherit` in Safari.
+  */
+ ::-webkit-file-upload-button { -webkit-appearance: button; /* 1 */ font: inherit; /* 2 */ }
+ /* Interactive
+    ========================================================================== */
+ /*
+  * Add the correct display in Edge, IE 10+, and Firefox.
+  */
+ details { display: block; }
+ /*
+  * Add the correct display in all browsers.
+  */
+ summary { display: list-item; }
+ /* Misc
+    ========================================================================== */
+ /**
+  * Add the correct display in IE 10+.
+  */
+ template { display: none; }
+ /**
+  * Add the correct display in IE 10.
+  */
+ [hidden] { display: none; }
+ /* Modules */
+ /*
+  
+   BOX SIZING
+ 
+ */
+ html, body, div, article, aside, section, main, nav, footer, header, form,
+ fieldset, legend, pre, code, a, h1, h2, h3, h4, h5, h6, p, ul, ol, li, dl, dt,
+ dd, blockquote, figcaption, figure, textarea, table, td, th, tr,
+ input[type="email"], input[type="number"], input[type="password"],
+ input[type="tel"], input[type="text"], input[type="url"], .border-box { box-sizing: border-box; }
+ /*
+ 
+    ASPECT RATIOS
+ 
+ */
+ /* This is for fluid media that is embedded from third party sites like youtube, vimeo etc.
+  * Wrap the outer element in aspect-ratio and then extend it with the desired ratio i.e
+  * Make sure there are no height and width attributes on the embedded media.
+  * Adapted from: https://github.com/suitcss/components-flex-embed
+  *
+  * Example:
+  *
+  * <div class="aspect-ratio aspect-ratio--16x9">
+  *  <iframe class="aspect-ratio--object"></iframe>
+  * </div>
+  *
+  * */
+ .aspect-ratio { height: 0; position: relative; }
+ .aspect-ratio--16x9 { padding-bottom: 56.25%; }
+ .aspect-ratio--9x16 { padding-bottom: 177.77%; }
+ .aspect-ratio--4x3 { padding-bottom: 75%; }
+ .aspect-ratio--3x4 { padding-bottom: 133.33%; }
+ .aspect-ratio--6x4 { padding-bottom: 66.6%; }
+ .aspect-ratio--4x6 { padding-bottom: 150%; }
+ .aspect-ratio--8x5 { padding-bottom: 62.5%; }
+ .aspect-ratio--5x8 { padding-bottom: 160%; }
+ .aspect-ratio--7x5 { padding-bottom: 71.42%; }
+ .aspect-ratio--5x7 { padding-bottom: 140%; }
+ .aspect-ratio--1x1 { padding-bottom: 100%; }
+ .aspect-ratio--object { position: absolute; top: 0; right: 0; bottom: 0; left: 0; width: 100%; height: 100%; z-index: 100; }
+ /*
+ 
+    IMAGES
+    Docs: http://tachyons.io/docs/elements/images/
+ 
+ */
+ /* Responsive images! */
+ img { max-width: 100%; }
+ /*
+ 
+    BACKGROUND SIZE
+    Docs: http://tachyons.io/docs/themes/background-size/
+ 
+    Media Query Extensions:
+      -ns = not-small
+      -m  = medium
+      -l  = large
+ 
+ */
+ /*
+   Often used in combination with background image set as an inline style
+   on an html element.
+ */
+ .cover { background-size: cover !important; }
+ .contain { background-size: contain !important; }
+ /*
+ 
+     BACKGROUND POSITION
+ 
+     Base:
+     bg = background
+ 
+     Modifiers:
+     -center = center center
+     -top = top center
+     -right = center right
+     -bottom = bottom center
+     -left = center left
+ 
+     Media Query Extensions:
+       -ns = not-small
+       -m  = medium
+       -l  = large
+ 
+  */
+ .bg-center { background-repeat: no-repeat; background-position: center center; }
+ .bg-top { background-repeat: no-repeat; background-position: top center; }
+ .bg-right { background-repeat: no-repeat; background-position: center right; }
+ .bg-bottom { background-repeat: no-repeat; background-position: bottom center; }
+ .bg-left { background-repeat: no-repeat; background-position: center left; }
+ /*
+ 
+    OUTLINES
+ 
+    Media Query Extensions:
+      -ns = not-small
+      -m  = medium
+      -l  = large
+ 
+ */
+ .outline { outline: 1px solid; }
+ .outline-transparent { outline: 1px solid transparent; }
+ .outline-0 { outline: 0; }
+ /*
+ 
+     BORDERS
+     Docs: http://tachyons.io/docs/themes/borders/
+ 
+     Base:
+       b = border
+ 
+     Modifiers:
+       a = all
+       t = top
+       r = right
+       b = bottom
+       l = left
+       n = none
+ 
+    Media Query Extensions:
+      -ns = not-small
+      -m  = medium
+      -l  = large
+ 
+ */
+ .ba { border-style: solid; border-width: 1px; }
+ .bt { border-top-style: solid; border-top-width: 1px; }
+ .br { border-right-style: solid; border-right-width: 1px; }
+ .bb { border-bottom-style: solid; border-bottom-width: 1px; }
+ .bl { border-left-style: solid; border-left-width: 1px; }
+ .bn { border-style: none; border-width: 0; }
+ /*
+ 
+    BORDER COLORS
+    Docs: http://tachyons.io/docs/themes/borders/
+ 
+    Border colors can be used to extend the base
+    border classes ba,bt,bb,br,bl found in the _borders.css file.
+ 
+    The base border class by default will set the color of the border
+    to that of the current text color. These classes are for the cases
+    where you desire for the text and border colors to be different.
+ 
+    Base:
+      b = border
+ 
+    Modifiers:
+    --color-name = each color variable name is also a border color name
+ 
+ */
+ .b--black { border-color: #000; }
+ .b--near-black { border-color: #111; }
+ .b--dark-gray { border-color: #333; }
+ .b--mid-gray { border-color: #555; }
+ .b--gray { border-color: #777; }
+ .b--silver { border-color: #999; }
+ .b--light-silver { border-color: #aaa; }
+ .b--moon-gray { border-color: #ccc; }
+ .b--light-gray { border-color: #eee; }
+ .b--near-white { border-color: #f4f4f4; }
+ .b--white { border-color: #fff; }
+ .b--white-90 { border-color: rgba( 255, 255, 255, .9 ); }
+ .b--white-80 { border-color: rgba( 255, 255, 255, .8 ); }
+ .b--white-70 { border-color: rgba( 255, 255, 255, .7 ); }
+ .b--white-60 { border-color: rgba( 255, 255, 255, .6 ); }
+ .b--white-50 { border-color: rgba( 255, 255, 255, .5 ); }
+ .b--white-40 { border-color: rgba( 255, 255, 255, .4 ); }
+ .b--white-30 { border-color: rgba( 255, 255, 255, .3 ); }
+ .b--white-20 { border-color: rgba( 255, 255, 255, .2 ); }
+ .b--white-10 { border-color: rgba( 255, 255, 255, .1 ); }
+ .b--white-05 { border-color: rgba( 255, 255, 255, .05 ); }
+ .b--white-025 { border-color: rgba( 255, 255, 255, .025 ); }
+ .b--white-0125 { border-color: rgba( 255, 255, 255, .0125 ); }
+ .b--black-90 { border-color: rgba( 0, 0, 0, .9 ); }
+ .b--black-80 { border-color: rgba( 0, 0, 0, .8 ); }
+ .b--black-70 { border-color: rgba( 0, 0, 0, .7 ); }
+ .b--black-60 { border-color: rgba( 0, 0, 0, .6 ); }
+ .b--black-50 { border-color: rgba( 0, 0, 0, .5 ); }
+ .b--black-40 { border-color: rgba( 0, 0, 0, .4 ); }
+ .b--black-30 { border-color: rgba( 0, 0, 0, .3 ); }
+ .b--black-20 { border-color: rgba( 0, 0, 0, .2 ); }
+ .b--black-10 { border-color: rgba( 0, 0, 0, .1 ); }
+ .b--black-05 { border-color: rgba( 0, 0, 0, .05 ); }
+ .b--black-025 { border-color: rgba( 0, 0, 0, .025 ); }
+ .b--black-0125 { border-color: rgba( 0, 0, 0, .0125 ); }
+ .b--dark-red { border-color: #e7040f; }
+ .b--red { border-color: #ff4136; }
+ .b--light-red { border-color: #ff725c; }
+ .b--orange { border-color: #ff6300; }
+ .b--gold { border-color: #ffb700; }
+ .b--yellow { border-color: #ffd700; }
+ .b--light-yellow { border-color: #fbf1a9; }
+ .b--purple { border-color: #5e2ca5; }
+ .b--light-purple { border-color: #a463f2; }
+ .b--dark-pink { border-color: #d5008f; }
+ .b--hot-pink { border-color: #ff41b4; }
+ .b--pink { border-color: #ff80cc; }
+ .b--light-pink { border-color: #ffa3d7; }
+ .b--dark-green { border-color: #137752; }
+ .b--green { border-color: #19a974; }
+ .b--light-green { border-color: #9eebcf; }
+ .b--navy { border-color: #001b44; }
+ .b--dark-blue { border-color: #00449e; }
+ .b--blue { border-color: #357edd; }
+ .b--light-blue { border-color: #96ccff; }
+ .b--lightest-blue { border-color: #cdecff; }
+ .b--washed-blue { border-color: #f6fffe; }
+ .b--washed-green { border-color: #e8fdf5; }
+ .b--washed-yellow { border-color: #fffceb; }
+ .b--washed-red { border-color: #ffdfdf; }
+ .b--transparent { border-color: transparent; }
+ .b--inherit { border-color: inherit; }
+ .b--initial { border-color: initial; }
+ .b--unset { border-color: unset; }
+ /*
+ 
+    BORDER RADIUS
+    Docs: http://tachyons.io/docs/themes/border-radius/
+ 
+    Base:
+      br   = border-radius
+ 
+    Modifiers:
+      0    = 0/none
+      1    = 1st step in scale
+      2    = 2nd step in scale
+      3    = 3rd step in scale
+      4    = 4th step in scale
+ 
+    Literal values:
+      -100 = 100%
+      -pill = 9999px
+ 
+    Media Query Extensions:
+      -ns = not-small
+      -m  = medium
+      -l  = large
+ 
+ */
+ .br0 { border-radius: 0; }
+ .br1 { border-radius: .125rem; }
+ .br2 { border-radius: .25rem; }
+ .br3 { border-radius: .5rem; }
+ .br4 { border-radius: 1rem; }
+ .br-100 { border-radius: 100%; }
+ .br-pill { border-radius: 9999px; }
+ .br--bottom { border-top-left-radius: 0; border-top-right-radius: 0; }
+ .br--top { border-bottom-left-radius: 0; border-bottom-right-radius: 0; }
+ .br--right { border-top-left-radius: 0; border-bottom-left-radius: 0; }
+ .br--left { border-top-right-radius: 0; border-bottom-right-radius: 0; }
+ .br-inherit { border-radius: inherit; }
+ .br-initial { border-radius: initial; }
+ .br-unset { border-radius: unset; }
+ /*
+ 
+    BORDER STYLES
+    Docs: http://tachyons.io/docs/themes/borders/
+ 
+    Depends on base border module in _borders.css
+ 
+    Base:
+      b = border-style
+ 
+    Modifiers:
+      --none   = none
+      --dotted = dotted
+      --dashed = dashed
+      --solid  = solid
+ 
+    Media Query Extensions:
+      -ns = not-small
+      -m  = medium
+      -l  = large
+ 
+  */
+ .b--dotted { border-style: dotted; }
+ .b--dashed { border-style: dashed; }
+ .b--solid { border-style: solid; }
+ .b--none { border-style: none; }
+ /*
+ 
+    BORDER WIDTHS
+    Docs: http://tachyons.io/docs/themes/borders/
+ 
+    Base:
+      bw = border-width
+ 
+    Modifiers:
+      0 = 0 width border
+      1 = 1st step in border-width scale
+      2 = 2nd step in border-width scale
+      3 = 3rd step in border-width scale
+      4 = 4th step in border-width scale
+      5 = 5th step in border-width scale
+ 
+    Media Query Extensions:
+      -ns = not-small
+      -m  = medium
+      -l  = large
+ 
+ */
+ .bw0 { border-width: 0; }
+ .bw1 { border-width: .125rem; }
+ .bw2 { border-width: .25rem; }
+ .bw3 { border-width: .5rem; }
+ .bw4 { border-width: 1rem; }
+ .bw5 { border-width: 2rem; }
+ /* Resets */
+ .bt-0 { border-top-width: 0; }
+ .br-0 { border-right-width: 0; }
+ .bb-0 { border-bottom-width: 0; }
+ .bl-0 { border-left-width: 0; }
+ /*
+ 
+   BOX-SHADOW
+   Docs: http://tachyons.io/docs/themes/box-shadow/
+ 
+   Media Query Extensions:
+    -ns = not-small
+    -m  = medium
+    -l  = large
+ 
+  */
+ .shadow-1 { box-shadow: 0 0 4px 2px rgba( 0, 0, 0, .2 ); }
+ .shadow-2 { box-shadow: 0 0 8px 2px rgba( 0, 0, 0, .2 ); }
+ .shadow-3 { box-shadow: 2px 2px 4px 2px rgba( 0, 0, 0, .2 ); }
+ .shadow-4 { box-shadow: 2px 2px 8px 0 rgba( 0, 0, 0, .2 ); }
+ .shadow-5 { box-shadow: 4px 4px 8px 0 rgba( 0, 0, 0, .2 ); }
+ /*
+ 
+    CODE
+ 
+ */
+ .pre { overflow-x: auto; overflow-y: hidden; overflow: scroll; }
+ /*
+ 
+    COORDINATES
+    Docs: http://tachyons.io/docs/layout/position/
+ 
+    Use in combination with the position module.
+ 
+    Base:
+      top
+      bottom
+      right
+      left
+ 
+    Modifiers:
+      -0  = literal value 0
+      -1  = literal value 1
+      -2  = literal value 2
+      --1 = literal value -1
+      --2 = literal value -2
+ 
+    Media Query Extensions:
+      -ns = not-small
+      -m  = medium
+      -l  = large
+ 
+ */
+ .top-0 { top: 0; }
+ .right-0 { right: 0; }
+ .bottom-0 { bottom: 0; }
+ .left-0 { left: 0; }
+ .top-1 { top: 1rem; }
+ .right-1 { right: 1rem; }
+ .bottom-1 { bottom: 1rem; }
+ .left-1 { left: 1rem; }
+ .top-2 { top: 2rem; }
+ .right-2 { right: 2rem; }
+ .bottom-2 { bottom: 2rem; }
+ .left-2 { left: 2rem; }
+ .top--1 { top: -1rem; }
+ .right--1 { right: -1rem; }
+ .bottom--1 { bottom: -1rem; }
+ .left--1 { left: -1rem; }
+ .top--2 { top: -2rem; }
+ .right--2 { right: -2rem; }
+ .bottom--2 { bottom: -2rem; }
+ .left--2 { left: -2rem; }
+ .absolute--fill { top: 0; right: 0; bottom: 0; left: 0; }
+ /*
+ 
+    CLEARFIX
+    http://tachyons.io/docs/layout/clearfix/
+ 
+ */
+ /* Nicolas Gallaghers Clearfix solution
+    Ref: http://nicolasgallagher.com/micro-clearfix-hack/ */
+ .cf:before, .cf:after { content: " "; display: table; }
+ .cf:after { clear: both; }
+ /* .cf { *zoom: 1; } */
+ .cl { clear: left; }
+ .cr { clear: right; }
+ .cb { clear: both; }
+ .cn { clear: none; }
+ /*
+ 
+    DISPLAY
+    Docs: http://tachyons.io/docs/layout/display
+ 
+    Base:
+     d = display
+ 
+    Modifiers:
+     n     = none
+     b     = block
+     ib    = inline-block
+     it    = inline-table
+     t     = table
+     tc    = table-cell
+     t-row          = table-row
+     t-columm       = table-column
+     t-column-group = table-column-group
+ 
+    Media Query Extensions:
+      -ns = not-small
+      -m  = medium
+      -l  = large
+ 
+ */
+ .dn { display: none; }
+ .di { display: inline; }
+ .db { display: block; }
+ .dib { display: inline-block; }
+ .dit { display: inline-table; }
+ .dt { display: table; }
+ .dtc { display: table-cell; }
+ .dt-row { display: table-row; }
+ .dt-row-group { display: table-row-group; }
+ .dt-column { display: table-column; }
+ .dt-column-group { display: table-column-group; }
+ /*
+   This will set table to full width and then
+   all cells will be equal width
+ */
+ .dt--fixed { table-layout: fixed; width: 100%; }
+ /*
+ 
+   FLEXBOX
+ 
+   Media Query Extensions:
+    -ns = not-small
+    -m  = medium
+    -l  = large
+ 
+ */
+ .flex { display: flex; }
+ .inline-flex { display: inline-flex; }
+ /* 1. Fix for Chrome 44 bug.
+  * https://code.google.com/p/chromium/issues/detail?id=506893 */
+ .flex-auto { flex: 1 1 auto; min-width: 0; /* 1 */ min-height: 0; /* 1 */ }
+ .flex-none { flex: none; }
+ .flex-column { flex-direction: column; }
+ .flex-row { flex-direction: row; }
+ .flex-wrap { flex-wrap: wrap; }
+ .flex-nowrap { flex-wrap: nowrap; }
+ .flex-wrap-reverse { flex-wrap: wrap-reverse; }
+ .flex-column-reverse { flex-direction: column-reverse; }
+ .flex-row-reverse { flex-direction: row-reverse; }
+ .items-start { align-items: flex-start; }
+ .items-end { align-items: flex-end; }
+ .items-center { align-items: center; }
+ .items-baseline { align-items: baseline; }
+ .items-stretch { align-items: stretch; }
+ .self-start { align-self: flex-start; }
+ .self-end { align-self: flex-end; }
+ .self-center { align-self: center; }
+ .self-baseline { align-self: baseline; }
+ .self-stretch { align-self: stretch; }
+ .justify-start { justify-content: flex-start; }
+ .justify-end { justify-content: flex-end; }
+ .justify-center { justify-content: center; }
+ .justify-between { justify-content: space-between; }
+ .justify-around { justify-content: space-around; }
+ .content-start { align-content: flex-start; }
+ .content-end { align-content: flex-end; }
+ .content-center { align-content: center; }
+ .content-between { align-content: space-between; }
+ .content-around { align-content: space-around; }
+ .content-stretch { align-content: stretch; }
+ .order-0 { order: 0; }
+ .order-1 { order: 1; }
+ .order-2 { order: 2; }
+ .order-3 { order: 3; }
+ .order-4 { order: 4; }
+ .order-5 { order: 5; }
+ .order-6 { order: 6; }
+ .order-7 { order: 7; }
+ .order-8 { order: 8; }
+ .order-last { order: 99999; }
+ .flex-grow-0 { flex-grow: 0; }
+ .flex-grow-1 { flex-grow: 1; }
+ .flex-shrink-0 { flex-shrink: 0; }
+ .flex-shrink-1 { flex-shrink: 1; }
+ /*
+ 
+    FLOATS
+    http://tachyons.io/docs/layout/floats/
+ 
+    1. Floated elements are automatically rendered as block level elements.
+       Setting floats to display inline will fix the double margin bug in
+       ie6. You know... just in case.
+ 
+    2. Don't forget to clearfix your floats with .cf
+ 
+    Base:
+      f = float
+ 
+    Modifiers:
+      l = left
+      r = right
+      n = none
+ 
+    Media Query Extensions:
+      -ns = not-small
+      -m  = medium
+      -l  = large
+ 
+ */
+ .fl { float: left; _display: inline; }
+ .fr { float: right; _display: inline; }
+ .fn { float: none; }
+ /*
+ 
+    FONT FAMILY GROUPS
+    Docs: http://tachyons.io/docs/typography/font-family/
+ 
+ */
+ .sans-serif { font-family: -apple-system, BlinkMacSystemFont, 'avenir next', avenir, 'helvetica neue', helvetica, ubuntu, roboto, noto, 'segoe ui', arial, sans-serif; }
+ .serif { font-family: georgia, times, serif; }
+ .system-sans-serif { font-family: sans-serif; }
+ .system-serif { font-family: serif; }
+ /* Monospaced Typefaces (for code) */
+ /* From http://cssfontstack.com */
+ code, .code { font-family: Consolas, monaco, monospace; }
+ .courier { font-family: 'Courier Next', courier, monospace; }
+ /* Sans-Serif Typefaces */
+ .helvetica { font-family: 'helvetica neue', helvetica, sans-serif; }
+ .avenir { font-family: 'avenir next', avenir, sans-serif; }
+ /* Serif Typefaces */
+ .athelas { font-family: athelas, georgia, serif; }
+ .georgia { font-family: georgia, serif; }
+ .times { font-family: times, serif; }
+ .bodoni { font-family: "Bodoni MT", serif; }
+ .calisto { font-family: "Calisto MT", serif; }
+ .garamond { font-family: garamond, serif; }
+ .baskerville { font-family: baskerville, serif; }
+ /*
+ 
+    FONT STYLE
+    Docs: http://tachyons.io/docs/typography/font-style/
+ 
+    Media Query Extensions:
+      -ns = not-small
+      -m  = medium
+      -l  = large
+ 
+ */
+ .i { font-style: italic; }
+ .fs-normal { font-style: normal; }
+ /*
+ 
+    FONT WEIGHT
+    Docs: http://tachyons.io/docs/typography/font-weight/
+ 
+    Base
+      fw = font-weight
+ 
+    Modifiers:
+      1 = literal value 100
+      2 = literal value 200
+      3 = literal value 300
+      4 = literal value 400
+      5 = literal value 500
+      6 = literal value 600
+      7 = literal value 700
+      8 = literal value 800
+      9 = literal value 900
+ 
+    Media Query Extensions:
+      -ns = not-small
+      -m  = medium
+      -l  = large
+ 
+ */
+ .normal { font-weight: normal; }
+ .b { font-weight: bold; }
+ .fw1 { font-weight: 100; }
+ .fw2 { font-weight: 200; }
+ .fw3 { font-weight: 300; }
+ .fw4 { font-weight: 400; }
+ .fw5 { font-weight: 500; }
+ .fw6 { font-weight: 600; }
+ .fw7 { font-weight: 700; }
+ .fw8 { font-weight: 800; }
+ .fw9 { font-weight: 900; }
+ /*
+ 
+    FORMS
+    
+ */
+ .input-reset { -webkit-appearance: none; -moz-appearance: none; }
+ .button-reset::-moz-focus-inner, .input-reset::-moz-focus-inner { border: 0; padding: 0; }
+ /*
+ 
+    HEIGHTS
+    Docs: http://tachyons.io/docs/layout/heights/
+ 
+    Base:
+      h = height
+      min-h = min-height
+      min-vh = min-height vertical screen height
+      vh = vertical screen height
+ 
+    Modifiers
+      1 = 1st step in height scale
+      2 = 2nd step in height scale
+      3 = 3rd step in height scale
+      4 = 4th step in height scale
+      5 = 5th step in height scale
+ 
+      -25   = literal value 25%
+      -50   = literal value 50%
+      -75   = literal value 75%
+      -100  = literal value 100%
+ 
+      -auto = string value of auto
+      -inherit = string value of inherit
+ 
+    Media Query Extensions:
+      -ns = not-small
+      -m  = medium
+      -l  = large
+ 
+ */
+ /* Height Scale */
+ .h1 { height: 1rem; }
+ .h2 { height: 2rem; }
+ .h3 { height: 4rem; }
+ .h4 { height: 8rem; }
+ .h5 { height: 16rem; }
+ /* Height Percentages - Based off of height of parent */
+ .h-25 { height: 25%; }
+ .h-50 { height: 50%; }
+ .h-75 { height: 75%; }
+ .h-100 { height: 100%; }
+ .min-h-100 { min-height: 100%; }
+ /* Screen Height Percentage */
+ .vh-25 { height: 25vh; }
+ .vh-50 { height: 50vh; }
+ .vh-75 { height: 75vh; }
+ .vh-100 { height: 100vh; }
+ .min-vh-100 { min-height: 100vh; }
+ /* String Properties */
+ .h-auto { height: auto; }
+ .h-inherit { height: inherit; }
+ /*
+ 
+    LETTER SPACING
+    Docs: http://tachyons.io/docs/typography/tracking/
+ 
+    Media Query Extensions:
+      -ns = not-small
+      -m  = medium
+      -l  = large
+ 
+ */
+ .tracked { letter-spacing: .1em; }
+ .tracked-tight { letter-spacing: -.05em; }
+ .tracked-mega { letter-spacing: .25em; }
+ /*
+ 
+    LINE HEIGHT / LEADING
+    Docs: http://tachyons.io/docs/typography/line-height
+ 
+    Media Query Extensions:
+      -ns = not-small
+      -m  = medium
+      -l  = large
+ 
+ */
+ .lh-solid { line-height: 1; }
+ .lh-title { line-height: 1.25; }
+ .lh-copy { line-height: 1.5; }
+ /*
+ 
+    LINKS
+    Docs: http://tachyons.io/docs/elements/links/
+ 
+ */
+ .link { text-decoration: none; transition: color .15s ease-in; }
+ .link:link, .link:visited { transition: color .15s ease-in; }
+ .link:hover { transition: color .15s ease-in; }
+ .link:active { transition: color .15s ease-in; }
+ .link:focus { transition: color .15s ease-in; outline: 1px dotted currentColor; }
+ /*
+ 
+    LISTS
+    http://tachyons.io/docs/elements/lists/
+ 
+ */
+ .list { list-style-type: none; }
+ /*
+ 
+    MAX WIDTHS
+    Docs: http://tachyons.io/docs/layout/max-widths/
+ 
+    Base:
+      mw = max-width
+ 
+    Modifiers
+      1 = 1st step in width scale
+      2 = 2nd step in width scale
+      3 = 3rd step in width scale
+      4 = 4th step in width scale
+      5 = 5th step in width scale
+      6 = 6st step in width scale
+      7 = 7nd step in width scale
+      8 = 8rd step in width scale
+      9 = 9th step in width scale
+ 
+      -100 = literal value 100%
+ 
+      -none  = string value none
+ 
+ 
+    Media Query Extensions:
+      -ns = not-small
+      -m  = medium
+      -l  = large
+ 
+ */
+ /* Max Width Percentages */
+ .mw-100 { max-width: 100%; }
+ /* Max Width Scale */
+ .mw1 { max-width: 1rem; }
+ .mw2 { max-width: 2rem; }
+ .mw3 { max-width: 4rem; }
+ .mw4 { max-width: 8rem; }
+ .mw5 { max-width: 16rem; }
+ .mw6 { max-width: 32rem; }
+ .mw7 { max-width: 48rem; }
+ .mw8 { max-width: 64rem; }
+ .mw9 { max-width: 96rem; }
+ /* Max Width String Properties */
+ .mw-none { max-width: none; }
+ /*
+ 
+    WIDTHS
+    Docs: http://tachyons.io/docs/layout/widths/
+ 
+    Base:
+      w = width
+ 
+    Modifiers
+      1 = 1st step in width scale
+      2 = 2nd step in width scale
+      3 = 3rd step in width scale
+      4 = 4th step in width scale
+      5 = 5th step in width scale
+ 
+      -10  = literal value 10%
+      -20  = literal value 20%
+      -25  = literal value 25%
+      -30  = literal value 30%
+      -33  = literal value 33%
+      -34  = literal value 34%
+      -40  = literal value 40%
+      -50  = literal value 50%
+      -60  = literal value 60%
+      -70  = literal value 70%
+      -75  = literal value 75%
+      -80  = literal value 80%
+      -90  = literal value 90%
+      -100 = literal value 100%
+ 
+      -third      = 100% / 3 (Not supported in opera mini or IE8)
+      -two-thirds = 100% / 1.5 (Not supported in opera mini or IE8)
+      -auto       = string value auto
+ 
+ 
+    Media Query Extensions:
+      -ns = not-small
+      -m  = medium
+      -l  = large
+ 
+ */
+ /* Width Scale */
+ .w1 { width: 1rem; }
+ .w2 { width: 2rem; }
+ .w3 { width: 4rem; }
+ .w4 { width: 8rem; }
+ .w5 { width: 16rem; }
+ .w-10 { width: 10%; }
+ .w-20 { width: 20%; }
+ .w-25 { width: 25%; }
+ .w-30 { width: 30%; }
+ .w-33 { width: 33%; }
+ .w-34 { width: 34%; }
+ .w-40 { width: 40%; }
+ .w-50 { width: 50%; }
+ .w-60 { width: 60%; }
+ .w-70 { width: 70%; }
+ .w-75 { width: 75%; }
+ .w-80 { width: 80%; }
+ .w-90 { width: 90%; }
+ .w-100 { width: 100%; }
+ .w-third { width: 33.33333%; }
+ .w-two-thirds { width: 66.66667%; }
+ .w-auto { width: auto; }
+ /*
+ 
+     OVERFLOW
+ 
+     Media Query Extensions:
+       -ns = not-small
+       -m  = medium
+       -l  = large
+ 
+  */
+ .overflow-visible { overflow: visible; }
+ .overflow-hidden { overflow: hidden; }
+ .overflow-scroll { overflow: scroll; }
+ .overflow-auto { overflow: auto; }
+ .overflow-x-visible { overflow-x: visible; }
+ .overflow-x-hidden { overflow-x: hidden; }
+ .overflow-x-scroll { overflow-x: scroll; }
+ .overflow-x-auto { overflow-x: auto; }
+ .overflow-y-visible { overflow-y: visible; }
+ .overflow-y-hidden { overflow-y: hidden; }
+ .overflow-y-scroll { overflow-y: scroll; }
+ .overflow-y-auto { overflow-y: auto; }
+ /*
+ 
+    POSITIONING
+    Docs: http://tachyons.io/docs/layout/position/
+ 
+    Media Query Extensions:
+      -ns = not-small
+      -m  = medium
+      -l  = large
+ 
+ */
+ .static { position: static; }
+ .relative { position: relative; }
+ .absolute { position: absolute; }
+ .fixed { position: fixed; }
+ /*
+ 
+     OPACITY
+     Docs: http://tachyons.io/docs/themes/opacity/
+ 
+ */
+ .o-100 { opacity: 1; }
+ .o-90 { opacity: .9; }
+ .o-80 { opacity: .8; }
+ .o-70 { opacity: .7; }
+ .o-60 { opacity: .6; }
+ .o-50 { opacity: .5; }
+ .o-40 { opacity: .4; }
+ .o-30 { opacity: .3; }
+ .o-20 { opacity: .2; }
+ .o-10 { opacity: .1; }
+ .o-05 { opacity: .05; }
+ .o-025 { opacity: .025; }
+ .o-0 { opacity: 0; }
+ /*
+ 
+    ROTATIONS
+ 
+ */
+ .rotate-45 { -webkit-transform: rotate( 45deg ); transform: rotate( 45deg ); }
+ .rotate-90 { -webkit-transform: rotate( 90deg ); transform: rotate( 90deg ); }
+ .rotate-135 { -webkit-transform: rotate( 135deg ); transform: rotate( 135deg ); }
+ .rotate-180 { -webkit-transform: rotate( 180deg ); transform: rotate( 180deg ); }
+ .rotate-225 { -webkit-transform: rotate( 225deg ); transform: rotate( 225deg ); }
+ .rotate-270 { -webkit-transform: rotate( 270deg ); transform: rotate( 270deg ); }
+ .rotate-315 { -webkit-transform: rotate( 315deg ); transform: rotate( 315deg ); }
+ /*
+ 
+    SKINS
+    Docs: http://tachyons.io/docs/themes/skins/
+ 
+    Classes for setting foreground and background colors on elements.
+    If you haven't declared a border color, but set border on an element, it will 
+    be set to the current text color. 
+ 
+ */
+ /* Text colors */
+ .black-90 { color: rgba( 0, 0, 0, .9 ); }
+ .black-80 { color: rgba( 0, 0, 0, .8 ); }
+ .black-70 { color: rgba( 0, 0, 0, .7 ); }
+ .black-60 { color: rgba( 0, 0, 0, .6 ); }
+ .black-50 { color: rgba( 0, 0, 0, .5 ); }
+ .black-40 { color: rgba( 0, 0, 0, .4 ); }
+ .black-30 { color: rgba( 0, 0, 0, .3 ); }
+ .black-20 { color: rgba( 0, 0, 0, .2 ); }
+ .black-10 { color: rgba( 0, 0, 0, .1 ); }
+ .black-05 { color: rgba( 0, 0, 0, .05 ); }
+ .white-90 { color: rgba( 255, 255, 255, .9 ); }
+ .white-80 { color: rgba( 255, 255, 255, .8 ); }
+ .white-70 { color: rgba( 255, 255, 255, .7 ); }
+ .white-60 { color: rgba( 255, 255, 255, .6 ); }
+ .white-50 { color: rgba( 255, 255, 255, .5 ); }
+ .white-40 { color: rgba( 255, 255, 255, .4 ); }
+ .white-30 { color: rgba( 255, 255, 255, .3 ); }
+ .white-20 { color: rgba( 255, 255, 255, .2 ); }
+ .white-10 { color: rgba( 255, 255, 255, .1 ); }
+ .black { color: #000; }
+ .near-black { color: #111; }
+ .dark-gray { color: #333; }
+ .mid-gray { color: #555; }
+ .gray { color: #777; }
+ .silver { color: #999; }
+ .light-silver { color: #aaa; }
+ .moon-gray { color: #ccc; }
+ .light-gray { color: #eee; }
+ .near-white { color: #f4f4f4; }
+ .white { color: #fff; }
+ .dark-red { color: #e7040f; }
+ .red { color: #ff4136; }
+ .light-red { color: #ff725c; }
+ .orange { color: #ff6300; }
+ .gold { color: #ffb700; }
+ .yellow { color: #ffd700; }
+ .light-yellow { color: #fbf1a9; }
+ .purple { color: #5e2ca5; }
+ .light-purple { color: #a463f2; }
+ .dark-pink { color: #d5008f; }
+ .hot-pink { color: #ff41b4; }
+ .pink { color: #ff80cc; }
+ .light-pink { color: #ffa3d7; }
+ .dark-green { color: #137752; }
+ .green { color: #19a974; }
+ .light-green { color: #9eebcf; }
+ .navy { color: #001b44; }
+ .dark-blue { color: #00449e; }
+ .blue { color: #357edd; }
+ .light-blue { color: #96ccff; }
+ .lightest-blue { color: #cdecff; }
+ .washed-blue { color: #f6fffe; }
+ .washed-green { color: #e8fdf5; }
+ .washed-yellow { color: #fffceb; }
+ .washed-red { color: #ffdfdf; }
+ .color-inherit { color: inherit; }
+ /* Background colors */
+ .bg-black-90 { background-color: rgba( 0, 0, 0, .9 ); }
+ .bg-black-80 { background-color: rgba( 0, 0, 0, .8 ); }
+ .bg-black-70 { background-color: rgba( 0, 0, 0, .7 ); }
+ .bg-black-60 { background-color: rgba( 0, 0, 0, .6 ); }
+ .bg-black-50 { background-color: rgba( 0, 0, 0, .5 ); }
+ .bg-black-40 { background-color: rgba( 0, 0, 0, .4 ); }
+ .bg-black-30 { background-color: rgba( 0, 0, 0, .3 ); }
+ .bg-black-20 { background-color: rgba( 0, 0, 0, .2 ); }
+ .bg-black-10 { background-color: rgba( 0, 0, 0, .1 ); }
+ .bg-black-05 { background-color: rgba( 0, 0, 0, .05 ); }
+ .bg-white-90 { background-color: rgba( 255, 255, 255, .9 ); }
+ .bg-white-80 { background-color: rgba( 255, 255, 255, .8 ); }
+ .bg-white-70 { background-color: rgba( 255, 255, 255, .7 ); }
+ .bg-white-60 { background-color: rgba( 255, 255, 255, .6 ); }
+ .bg-white-50 { background-color: rgba( 255, 255, 255, .5 ); }
+ .bg-white-40 { background-color: rgba( 255, 255, 255, .4 ); }
+ .bg-white-30 { background-color: rgba( 255, 255, 255, .3 ); }
+ .bg-white-20 { background-color: rgba( 255, 255, 255, .2 ); }
+ .bg-white-10 { background-color: rgba( 255, 255, 255, .1 ); }
+ .bg-black { background-color: #000; }
+ .bg-near-black { background-color: #111; }
+ .bg-dark-gray { background-color: #333; }
+ .bg-mid-gray { background-color: #555; }
+ .bg-gray { background-color: #777; }
+ .bg-silver { background-color: #999; }
+ .bg-light-silver { background-color: #aaa; }
+ .bg-moon-gray { background-color: #ccc; }
+ .bg-light-gray { background-color: #eee; }
+ .bg-near-white { background-color: #f4f4f4; }
+ .bg-white { background-color: #fff; }
+ .bg-transparent { background-color: transparent; }
+ .bg-dark-red { background-color: #e7040f; }
+ .bg-red { background-color: #ff4136; }
+ .bg-light-red { background-color: #ff725c; }
+ .bg-orange { background-color: #ff6300; }
+ .bg-gold { background-color: #ffb700; }
+ .bg-yellow { background-color: #ffd700; }
+ .bg-light-yellow { background-color: #fbf1a9; }
+ .bg-purple { background-color: #5e2ca5; }
+ .bg-light-purple { background-color: #a463f2; }
+ .bg-dark-pink { background-color: #d5008f; }
+ .bg-hot-pink { background-color: #ff41b4; }
+ .bg-pink { background-color: #ff80cc; }
+ .bg-light-pink { background-color: #ffa3d7; }
+ .bg-dark-green { background-color: #137752; }
+ .bg-green { background-color: #19a974; }
+ .bg-light-green { background-color: #9eebcf; }
+ .bg-navy { background-color: #001b44; }
+ .bg-dark-blue { background-color: #00449e; }
+ .bg-blue { background-color: #357edd; }
+ .bg-light-blue { background-color: #96ccff; }
+ .bg-lightest-blue { background-color: #cdecff; }
+ .bg-washed-blue { background-color: #f6fffe; }
+ .bg-washed-green { background-color: #e8fdf5; }
+ .bg-washed-yellow { background-color: #fffceb; }
+ .bg-washed-red { background-color: #ffdfdf; }
+ .bg-inherit { background-color: inherit; }
+ /* 
+   
+    SKINS:PSEUDO
+ 
+    Customize the color of an element when
+    it is focused or hovered over.
+  
+  */
+ .hover-black:hover { color: #000; }
+ .hover-black:focus { color: #000; }
+ .hover-near-black:hover { color: #111; }
+ .hover-near-black:focus { color: #111; }
+ .hover-dark-gray:hover { color: #333; }
+ .hover-dark-gray:focus { color: #333; }
+ .hover-mid-gray:hover { color: #555; }
+ .hover-mid-gray:focus { color: #555; }
+ .hover-gray:hover { color: #777; }
+ .hover-gray:focus { color: #777; }
+ .hover-silver:hover { color: #999; }
+ .hover-silver:focus { color: #999; }
+ .hover-light-silver:hover { color: #aaa; }
+ .hover-light-silver:focus { color: #aaa; }
+ .hover-moon-gray:hover { color: #ccc; }
+ .hover-moon-gray:focus { color: #ccc; }
+ .hover-light-gray:hover { color: #eee; }
+ .hover-light-gray:focus { color: #eee; }
+ .hover-near-white:hover { color: #f4f4f4; }
+ .hover-near-white:focus { color: #f4f4f4; }
+ .hover-white:hover { color: #fff; }
+ .hover-white:focus { color: #fff; }
+ .hover-black-90:hover { color: rgba( 0, 0, 0, .9 ); }
+ .hover-black-90:focus { color: rgba( 0, 0, 0, .9 ); }
+ .hover-black-80:hover { color: rgba( 0, 0, 0, .8 ); }
+ .hover-black-80:focus { color: rgba( 0, 0, 0, .8 ); }
+ .hover-black-70:hover { color: rgba( 0, 0, 0, .7 ); }
+ .hover-black-70:focus { color: rgba( 0, 0, 0, .7 ); }
+ .hover-black-60:hover { color: rgba( 0, 0, 0, .6 ); }
+ .hover-black-60:focus { color: rgba( 0, 0, 0, .6 ); }
+ .hover-black-50:hover { color: rgba( 0, 0, 0, .5 ); }
+ .hover-black-50:focus { color: rgba( 0, 0, 0, .5 ); }
+ .hover-black-40:hover { color: rgba( 0, 0, 0, .4 ); }
+ .hover-black-40:focus { color: rgba( 0, 0, 0, .4 ); }
+ .hover-black-30:hover { color: rgba( 0, 0, 0, .3 ); }
+ .hover-black-30:focus { color: rgba( 0, 0, 0, .3 ); }
+ .hover-black-20:hover { color: rgba( 0, 0, 0, .2 ); }
+ .hover-black-20:focus { color: rgba( 0, 0, 0, .2 ); }
+ .hover-black-10:hover { color: rgba( 0, 0, 0, .1 ); }
+ .hover-black-10:focus { color: rgba( 0, 0, 0, .1 ); }
+ .hover-white-90:hover { color: rgba( 255, 255, 255, .9 ); }
+ .hover-white-90:focus { color: rgba( 255, 255, 255, .9 ); }
+ .hover-white-80:hover { color: rgba( 255, 255, 255, .8 ); }
+ .hover-white-80:focus { color: rgba( 255, 255, 255, .8 ); }
+ .hover-white-70:hover { color: rgba( 255, 255, 255, .7 ); }
+ .hover-white-70:focus { color: rgba( 255, 255, 255, .7 ); }
+ .hover-white-60:hover { color: rgba( 255, 255, 255, .6 ); }
+ .hover-white-60:focus { color: rgba( 255, 255, 255, .6 ); }
+ .hover-white-50:hover { color: rgba( 255, 255, 255, .5 ); }
+ .hover-white-50:focus { color: rgba( 255, 255, 255, .5 ); }
+ .hover-white-40:hover { color: rgba( 255, 255, 255, .4 ); }
+ .hover-white-40:focus { color: rgba( 255, 255, 255, .4 ); }
+ .hover-white-30:hover { color: rgba( 255, 255, 255, .3 ); }
+ .hover-white-30:focus { color: rgba( 255, 255, 255, .3 ); }
+ .hover-white-20:hover { color: rgba( 255, 255, 255, .2 ); }
+ .hover-white-20:focus { color: rgba( 255, 255, 255, .2 ); }
+ .hover-white-10:hover { color: rgba( 255, 255, 255, .1 ); }
+ .hover-white-10:focus { color: rgba( 255, 255, 255, .1 ); }
+ .hover-inherit:hover, .hover-inherit:focus { color: inherit; }
+ .hover-bg-black:hover { background-color: #000; }
+ .hover-bg-black:focus { background-color: #000; }
+ .hover-bg-near-black:hover { background-color: #111; }
+ .hover-bg-near-black:focus { background-color: #111; }
+ .hover-bg-dark-gray:hover { background-color: #333; }
+ .hover-bg-dark-gray:focus { background-color: #333; }
+ .hover-bg-mid-gray:hover { background-color: #555; }
+ .hover-bg-mid-gray:focus { background-color: #555; }
+ .hover-bg-gray:hover { background-color: #777; }
+ .hover-bg-gray:focus { background-color: #777; }
+ .hover-bg-silver:hover { background-color: #999; }
+ .hover-bg-silver:focus { background-color: #999; }
+ .hover-bg-light-silver:hover { background-color: #aaa; }
+ .hover-bg-light-silver:focus { background-color: #aaa; }
+ .hover-bg-moon-gray:hover { background-color: #ccc; }
+ .hover-bg-moon-gray:focus { background-color: #ccc; }
+ .hover-bg-light-gray:hover { background-color: #eee; }
+ .hover-bg-light-gray:focus { background-color: #eee; }
+ .hover-bg-near-white:hover { background-color: #f4f4f4; }
+ .hover-bg-near-white:focus { background-color: #f4f4f4; }
+ .hover-bg-white:hover { background-color: #fff; }
+ .hover-bg-white:focus { background-color: #fff; }
+ .hover-bg-transparent:hover { background-color: transparent; }
+ .hover-bg-transparent:focus { background-color: transparent; }
+ .hover-bg-black-90:hover { background-color: rgba( 0, 0, 0, .9 ); }
+ .hover-bg-black-90:focus { background-color: rgba( 0, 0, 0, .9 ); }
+ .hover-bg-black-80:hover { background-color: rgba( 0, 0, 0, .8 ); }
+ .hover-bg-black-80:focus { background-color: rgba( 0, 0, 0, .8 ); }
+ .hover-bg-black-70:hover { background-color: rgba( 0, 0, 0, .7 ); }
+ .hover-bg-black-70:focus { background-color: rgba( 0, 0, 0, .7 ); }
+ .hover-bg-black-60:hover { background-color: rgba( 0, 0, 0, .6 ); }
+ .hover-bg-black-60:focus { background-color: rgba( 0, 0, 0, .6 ); }
+ .hover-bg-black-50:hover { background-color: rgba( 0, 0, 0, .5 ); }
+ .hover-bg-black-50:focus { background-color: rgba( 0, 0, 0, .5 ); }
+ .hover-bg-black-40:hover { background-color: rgba( 0, 0, 0, .4 ); }
+ .hover-bg-black-40:focus { background-color: rgba( 0, 0, 0, .4 ); }
+ .hover-bg-black-30:hover { background-color: rgba( 0, 0, 0, .3 ); }
+ .hover-bg-black-30:focus { background-color: rgba( 0, 0, 0, .3 ); }
+ .hover-bg-black-20:hover { background-color: rgba( 0, 0, 0, .2 ); }
+ .hover-bg-black-20:focus { background-color: rgba( 0, 0, 0, .2 ); }
+ .hover-bg-black-10:hover { background-color: rgba( 0, 0, 0, .1 ); }
+ .hover-bg-black-10:focus { background-color: rgba( 0, 0, 0, .1 ); }
+ .hover-bg-white-90:hover { background-color: rgba( 255, 255, 255, .9 ); }
+ .hover-bg-white-90:focus { background-color: rgba( 255, 255, 255, .9 ); }
+ .hover-bg-white-80:hover { background-color: rgba( 255, 255, 255, .8 ); }
+ .hover-bg-white-80:focus { background-color: rgba( 255, 255, 255, .8 ); }
+ .hover-bg-white-70:hover { background-color: rgba( 255, 255, 255, .7 ); }
+ .hover-bg-white-70:focus { background-color: rgba( 255, 255, 255, .7 ); }
+ .hover-bg-white-60:hover { background-color: rgba( 255, 255, 255, .6 ); }
+ .hover-bg-white-60:focus { background-color: rgba( 255, 255, 255, .6 ); }
+ .hover-bg-white-50:hover { background-color: rgba( 255, 255, 255, .5 ); }
+ .hover-bg-white-50:focus { background-color: rgba( 255, 255, 255, .5 ); }
+ .hover-bg-white-40:hover { background-color: rgba( 255, 255, 255, .4 ); }
+ .hover-bg-white-40:focus { background-color: rgba( 255, 255, 255, .4 ); }
+ .hover-bg-white-30:hover { background-color: rgba( 255, 255, 255, .3 ); }
+ .hover-bg-white-30:focus { background-color: rgba( 255, 255, 255, .3 ); }
+ .hover-bg-white-20:hover { background-color: rgba( 255, 255, 255, .2 ); }
+ .hover-bg-white-20:focus { background-color: rgba( 255, 255, 255, .2 ); }
+ .hover-bg-white-10:hover { background-color: rgba( 255, 255, 255, .1 ); }
+ .hover-bg-white-10:focus { background-color: rgba( 255, 255, 255, .1 ); }
+ .hover-dark-red:hover { color: #e7040f; }
+ .hover-dark-red:focus { color: #e7040f; }
+ .hover-red:hover { color: #ff4136; }
+ .hover-red:focus { color: #ff4136; }
+ .hover-light-red:hover { color: #ff725c; }
+ .hover-light-red:focus { color: #ff725c; }
+ .hover-orange:hover { color: #ff6300; }
+ .hover-orange:focus { color: #ff6300; }
+ .hover-gold:hover { color: #ffb700; }
+ .hover-gold:focus { color: #ffb700; }
+ .hover-yellow:hover { color: #ffd700; }
+ .hover-yellow:focus { color: #ffd700; }
+ .hover-light-yellow:hover { color: #fbf1a9; }
+ .hover-light-yellow:focus { color: #fbf1a9; }
+ .hover-purple:hover { color: #5e2ca5; }
+ .hover-purple:focus { color: #5e2ca5; }
+ .hover-light-purple:hover { color: #a463f2; }
+ .hover-light-purple:focus { color: #a463f2; }
+ .hover-dark-pink:hover { color: #d5008f; }
+ .hover-dark-pink:focus { color: #d5008f; }
+ .hover-hot-pink:hover { color: #ff41b4; }
+ .hover-hot-pink:focus { color: #ff41b4; }
+ .hover-pink:hover { color: #ff80cc; }
+ .hover-pink:focus { color: #ff80cc; }
+ .hover-light-pink:hover { color: #ffa3d7; }
+ .hover-light-pink:focus { color: #ffa3d7; }
+ .hover-dark-green:hover { color: #137752; }
+ .hover-dark-green:focus { color: #137752; }
+ .hover-green:hover { color: #19a974; }
+ .hover-green:focus { color: #19a974; }
+ .hover-light-green:hover { color: #9eebcf; }
+ .hover-light-green:focus { color: #9eebcf; }
+ .hover-navy:hover { color: #001b44; }
+ .hover-navy:focus { color: #001b44; }
+ .hover-dark-blue:hover { color: #00449e; }
+ .hover-dark-blue:focus { color: #00449e; }
+ .hover-blue:hover { color: #357edd; }
+ .hover-blue:focus { color: #357edd; }
+ .hover-light-blue:hover { color: #96ccff; }
+ .hover-light-blue:focus { color: #96ccff; }
+ .hover-lightest-blue:hover { color: #cdecff; }
+ .hover-lightest-blue:focus { color: #cdecff; }
+ .hover-washed-blue:hover { color: #f6fffe; }
+ .hover-washed-blue:focus { color: #f6fffe; }
+ .hover-washed-green:hover { color: #e8fdf5; }
+ .hover-washed-green:focus { color: #e8fdf5; }
+ .hover-washed-yellow:hover { color: #fffceb; }
+ .hover-washed-yellow:focus { color: #fffceb; }
+ .hover-washed-red:hover { color: #ffdfdf; }
+ .hover-washed-red:focus { color: #ffdfdf; }
+ .hover-bg-dark-red:hover { background-color: #e7040f; }
+ .hover-bg-dark-red:focus { background-color: #e7040f; }
+ .hover-bg-red:hover { background-color: #ff4136; }
+ .hover-bg-red:focus { background-color: #ff4136; }
+ .hover-bg-light-red:hover { background-color: #ff725c; }
+ .hover-bg-light-red:focus { background-color: #ff725c; }
+ .hover-bg-orange:hover { background-color: #ff6300; }
+ .hover-bg-orange:focus { background-color: #ff6300; }
+ .hover-bg-gold:hover { background-color: #ffb700; }
+ .hover-bg-gold:focus { background-color: #ffb700; }
+ .hover-bg-yellow:hover { background-color: #ffd700; }
+ .hover-bg-yellow:focus { background-color: #ffd700; }
+ .hover-bg-light-yellow:hover { background-color: #fbf1a9; }
+ .hover-bg-light-yellow:focus { background-color: #fbf1a9; }
+ .hover-bg-purple:hover { background-color: #5e2ca5; }
+ .hover-bg-purple:focus { background-color: #5e2ca5; }
+ .hover-bg-light-purple:hover { background-color: #a463f2; }
+ .hover-bg-light-purple:focus { background-color: #a463f2; }
+ .hover-bg-dark-pink:hover { background-color: #d5008f; }
+ .hover-bg-dark-pink:focus { background-color: #d5008f; }
+ .hover-bg-hot-pink:hover { background-color: #ff41b4; }
+ .hover-bg-hot-pink:focus { background-color: #ff41b4; }
+ .hover-bg-pink:hover { background-color: #ff80cc; }
+ .hover-bg-pink:focus { background-color: #ff80cc; }
+ .hover-bg-light-pink:hover { background-color: #ffa3d7; }
+ .hover-bg-light-pink:focus { background-color: #ffa3d7; }
+ .hover-bg-dark-green:hover { background-color: #137752; }
+ .hover-bg-dark-green:focus { background-color: #137752; }
+ .hover-bg-green:hover { background-color: #19a974; }
+ .hover-bg-green:focus { background-color: #19a974; }
+ .hover-bg-light-green:hover { background-color: #9eebcf; }
+ .hover-bg-light-green:focus { background-color: #9eebcf; }
+ .hover-bg-navy:hover { background-color: #001b44; }
+ .hover-bg-navy:focus { background-color: #001b44; }
+ .hover-bg-dark-blue:hover { background-color: #00449e; }
+ .hover-bg-dark-blue:focus { background-color: #00449e; }
+ .hover-bg-blue:hover { background-color: #357edd; }
+ .hover-bg-blue:focus { background-color: #357edd; }
+ .hover-bg-light-blue:hover { background-color: #96ccff; }
+ .hover-bg-light-blue:focus { background-color: #96ccff; }
+ .hover-bg-lightest-blue:hover { background-color: #cdecff; }
+ .hover-bg-lightest-blue:focus { background-color: #cdecff; }
+ .hover-bg-washed-blue:hover { background-color: #f6fffe; }
+ .hover-bg-washed-blue:focus { background-color: #f6fffe; }
+ .hover-bg-washed-green:hover { background-color: #e8fdf5; }
+ .hover-bg-washed-green:focus { background-color: #e8fdf5; }
+ .hover-bg-washed-yellow:hover { background-color: #fffceb; }
+ .hover-bg-washed-yellow:focus { background-color: #fffceb; }
+ .hover-bg-washed-red:hover { background-color: #ffdfdf; }
+ .hover-bg-washed-red:focus { background-color: #ffdfdf; }
+ .hover-bg-inherit:hover, .hover-bg-inherit:focus { background-color: inherit; }
+ /* Variables */
+ /*
+    SPACING
+    Docs: http://tachyons.io/docs/layout/spacing/
+ 
+    An eight step powers of two scale ranging from 0 to 16rem.
+ 
+    Base:
+      p = padding
+      m = margin
+ 
+    Modifiers:
+      a = all
+      h = horizontal
+      v = vertical
+      t = top
+      r = right
+      b = bottom
+      l = left
+ 
+      0 = none
+      1 = 1st step in spacing scale
+      2 = 2nd step in spacing scale
+      3 = 3rd step in spacing scale
+      4 = 4th step in spacing scale
+      5 = 5th step in spacing scale
+      6 = 6th step in spacing scale
+      7 = 7th step in spacing scale
+ 
+    Media Query Extensions:
+      -ns = not-small
+      -m  = medium
+      -l  = large
+ 
+ */
+ .pa0 { padding: 0; }
+ .pa1 { padding: .25rem; }
+ .pa2 { padding: .5rem; }
+ .pa3 { padding: 1rem; }
+ .pa4 { padding: 2rem; }
+ .pa5 { padding: 4rem; }
+ .pa6 { padding: 8rem; }
+ .pa7 { padding: 16rem; }
+ .pl0 { padding-left: 0; }
+ .pl1 { padding-left: .25rem; }
+ .pl2 { padding-left: .5rem; }
+ .pl3 { padding-left: 1rem; }
+ .pl4 { padding-left: 2rem; }
+ .pl5 { padding-left: 4rem; }
+ .pl6 { padding-left: 8rem; }
+ .pl7 { padding-left: 16rem; }
+ .pr0 { padding-right: 0; }
+ .pr1 { padding-right: .25rem; }
+ .pr2 { padding-right: .5rem; }
+ .pr3 { padding-right: 1rem; }
+ .pr4 { padding-right: 2rem; }
+ .pr5 { padding-right: 4rem; }
+ .pr6 { padding-right: 8rem; }
+ .pr7 { padding-right: 16rem; }
+ .pb0 { padding-bottom: 0; }
+ .pb1 { padding-bottom: .25rem; }
+ .pb2 { padding-bottom: .5rem; }
+ .pb3 { padding-bottom: 1rem; }
+ .pb4 { padding-bottom: 2rem; }
+ .pb5 { padding-bottom: 4rem; }
+ .pb6 { padding-bottom: 8rem; }
+ .pb7 { padding-bottom: 16rem; }
+ .pt0 { padding-top: 0; }
+ .pt1 { padding-top: .25rem; }
+ .pt2 { padding-top: .5rem; }
+ .pt3 { padding-top: 1rem; }
+ .pt4 { padding-top: 2rem; }
+ .pt5 { padding-top: 4rem; }
+ .pt6 { padding-top: 8rem; }
+ .pt7 { padding-top: 16rem; }
+ .pv0 { padding-top: 0; padding-bottom: 0; }
+ .pv1 { padding-top: .25rem; padding-bottom: .25rem; }
+ .pv2 { padding-top: .5rem; padding-bottom: .5rem; }
+ .pv3 { padding-top: 1rem; padding-bottom: 1rem; }
+ .pv4 { padding-top: 2rem; padding-bottom: 2rem; }
+ .pv5 { padding-top: 4rem; padding-bottom: 4rem; }
+ .pv6 { padding-top: 8rem; padding-bottom: 8rem; }
+ .pv7 { padding-top: 16rem; padding-bottom: 16rem; }
+ .ph0 { padding-left: 0; padding-right: 0; }
+ .ph1 { padding-left: .25rem; padding-right: .25rem; }
+ .ph2 { padding-left: .5rem; padding-right: .5rem; }
+ .ph3 { padding-left: 1rem; padding-right: 1rem; }
+ .ph4 { padding-left: 2rem; padding-right: 2rem; }
+ .ph5 { padding-left: 4rem; padding-right: 4rem; }
+ .ph6 { padding-left: 8rem; padding-right: 8rem; }
+ .ph7 { padding-left: 16rem; padding-right: 16rem; }
+ .ma0 { margin: 0; }
+ .ma1 { margin: .25rem; }
+ .ma2 { margin: .5rem; }
+ .ma3 { margin: 1rem; }
+ .ma4 { margin: 2rem; }
+ .ma5 { margin: 4rem; }
+ .ma6 { margin: 8rem; }
+ .ma7 { margin: 16rem; }
+ .ml0 { margin-left: 0; }
+ .ml1 { margin-left: .25rem; }
+ .ml2 { margin-left: .5rem; }
+ .ml3 { margin-left: 1rem; }
+ .ml4 { margin-left: 2rem; }
+ .ml5 { margin-left: 4rem; }
+ .ml6 { margin-left: 8rem; }
+ .ml7 { margin-left: 16rem; }
+ .mr0 { margin-right: 0; }
+ .mr1 { margin-right: .25rem; }
+ .mr2 { margin-right: .5rem; }
+ .mr3 { margin-right: 1rem; }
+ .mr4 { margin-right: 2rem; }
+ .mr5 { margin-right: 4rem; }
+ .mr6 { margin-right: 8rem; }
+ .mr7 { margin-right: 16rem; }
+ .mb0 { margin-bottom: 0; }
+ .mb1 { margin-bottom: .25rem; }
+ .mb2 { margin-bottom: .5rem; }
+ .mb3 { margin-bottom: 1rem; }
+ .mb4 { margin-bottom: 2rem; }
+ .mb5 { margin-bottom: 4rem; }
+ .mb6 { margin-bottom: 8rem; }
+ .mb7 { margin-bottom: 16rem; }
+ .mt0 { margin-top: 0; }
+ .mt1 { margin-top: .25rem; }
+ .mt2 { margin-top: .5rem; }
+ .mt3 { margin-top: 1rem; }
+ .mt4 { margin-top: 2rem; }
+ .mt5 { margin-top: 4rem; }
+ .mt6 { margin-top: 8rem; }
+ .mt7 { margin-top: 16rem; }
+ .mv0 { margin-top: 0; margin-bottom: 0; }
+ .mv1 { margin-top: .25rem; margin-bottom: .25rem; }
+ .mv2 { margin-top: .5rem; margin-bottom: .5rem; }
+ .mv3 { margin-top: 1rem; margin-bottom: 1rem; }
+ .mv4 { margin-top: 2rem; margin-bottom: 2rem; }
+ .mv5 { margin-top: 4rem; margin-bottom: 4rem; }
+ .mv6 { margin-top: 8rem; margin-bottom: 8rem; }
+ .mv7 { margin-top: 16rem; margin-bottom: 16rem; }
+ .mh0 { margin-left: 0; margin-right: 0; }
+ .mh1 { margin-left: .25rem; margin-right: .25rem; }
+ .mh2 { margin-left: .5rem; margin-right: .5rem; }
+ .mh3 { margin-left: 1rem; margin-right: 1rem; }
+ .mh4 { margin-left: 2rem; margin-right: 2rem; }
+ .mh5 { margin-left: 4rem; margin-right: 4rem; }
+ .mh6 { margin-left: 8rem; margin-right: 8rem; }
+ .mh7 { margin-left: 16rem; margin-right: 16rem; }
+ /*
+    NEGATIVE MARGINS
+ 
+    Base:
+      n = negative
+ 
+    Modifiers:
+      a = all
+      t = top
+      r = right
+      b = bottom
+      l = left
+ 
+      1 = 1st step in spacing scale
+      2 = 2nd step in spacing scale
+      3 = 3rd step in spacing scale
+      4 = 4th step in spacing scale
+      5 = 5th step in spacing scale
+      6 = 6th step in spacing scale
+      7 = 7th step in spacing scale
+ 
+    Media Query Extensions:
+      -ns = not-small
+      -m  = medium
+      -l  = large
+ 
+ */
+ .na1 { margin: -0.25rem; }
+ .na2 { margin: -0.5rem; }
+ .na3 { margin: -1rem; }
+ .na4 { margin: -2rem; }
+ .na5 { margin: -4rem; }
+ .na6 { margin: -8rem; }
+ .na7 { margin: -16rem; }
+ .nl1 { margin-left: -0.25rem; }
+ .nl2 { margin-left: -0.5rem; }
+ .nl3 { margin-left: -1rem; }
+ .nl4 { margin-left: -2rem; }
+ .nl5 { margin-left: -4rem; }
+ .nl6 { margin-left: -8rem; }
+ .nl7 { margin-left: -16rem; }
+ .nr1 { margin-right: -0.25rem; }
+ .nr2 { margin-right: -0.5rem; }
+ .nr3 { margin-right: -1rem; }
+ .nr4 { margin-right: -2rem; }
+ .nr5 { margin-right: -4rem; }
+ .nr6 { margin-right: -8rem; }
+ .nr7 { margin-right: -16rem; }
+ .nb1 { margin-bottom: -0.25rem; }
+ .nb2 { margin-bottom: -0.5rem; }
+ .nb3 { margin-bottom: -1rem; }
+ .nb4 { margin-bottom: -2rem; }
+ .nb5 { margin-bottom: -4rem; }
+ .nb6 { margin-bottom: -8rem; }
+ .nb7 { margin-bottom: -16rem; }
+ .nt1 { margin-top: -0.25rem; }
+ .nt2 { margin-top: -0.5rem; }
+ .nt3 { margin-top: -1rem; }
+ .nt4 { margin-top: -2rem; }
+ .nt5 { margin-top: -4rem; }
+ .nt6 { margin-top: -8rem; }
+ .nt7 { margin-top: -16rem; }
+ /*
+ 
+   TABLES
+   Docs: http://tachyons.io/docs/elements/tables/
+ 
+ */
+ .collapse { border-collapse: collapse; border-spacing: 0; }
+ .striped--light-silver:nth-child(odd) { background-color: #aaa; }
+ .striped--moon-gray:nth-child(odd) { background-color: #ccc; }
+ .striped--light-gray:nth-child(odd) { background-color: #eee; }
+ .striped--near-white:nth-child(odd) { background-color: #f4f4f4; }
+ .stripe-light:nth-child(odd) { background-color: rgba( 255, 255, 255, .1 ); }
+ .stripe-dark:nth-child(odd) { background-color: rgba( 0, 0, 0, .1 ); }
+ /*
+ 
+    TEXT DECORATION
+    Docs: http://tachyons.io/docs/typography/text-decoration/
+ 
+ 
+    Media Query Extensions:
+      -ns = not-small
+      -m  = medium
+      -l  = large
+ 
+ */
+ .strike { text-decoration: line-through; }
+ .underline { text-decoration: underline; }
+ .no-underline { text-decoration: none; }
+ /*
+ 
+   TEXT ALIGN
+   Docs: http://tachyons.io/docs/typography/text-align/
+ 
+   Base
+     t = text-align
+ 
+   Modifiers
+     l = left
+     r = right
+     c = center
+     j = justify
+ 
+   Media Query Extensions:
+     -ns = not-small
+     -m  = medium
+     -l  = large
+ 
+ */
+ .tl { text-align: left; }
+ .tr { text-align: right; }
+ .tc { text-align: center; }
+ .tj { text-align: justify; }
+ /*
+ 
+    TEXT TRANSFORM
+    Docs: http://tachyons.io/docs/typography/text-transform/
+ 
+    Base:
+      tt = text-transform
+ 
+    Modifiers
+      c = capitalize
+      l = lowercase
+      u = uppercase
+      n = none
+ 
+    Media Query Extensions:
+      -ns = not-small
+      -m  = medium
+      -l  = large
+ 
+ */
+ .ttc { text-transform: capitalize; }
+ .ttl { text-transform: lowercase; }
+ .ttu { text-transform: uppercase; }
+ .ttn { text-transform: none; }
+ /*
+ 
+    TYPE SCALE
+    Docs: http://tachyons.io/docs/typography/scale/
+ 
+    Base:
+     f = font-size
+ 
+    Modifiers
+      1 = 1st step in size scale
+      2 = 2nd step in size scale
+      3 = 3rd step in size scale
+      4 = 4th step in size scale
+      5 = 5th step in size scale
+      6 = 6th step in size scale
+      7 = 7th step in size scale
+ 
+    Media Query Extensions:
+      -ns = not-small
+      -m  = medium
+      -l  = large
+ */
+ /*
+  * For Hero/Marketing Titles
+  *
+  * These generally are too large for mobile
+  * so be careful using them on smaller screens.
+  * */
+ .f-6, .f-headline { font-size: 6rem; }
+ .f-5, .f-subheadline { font-size: 5rem; }
+ /* Type Scale */
+ .f1 { font-size: 3rem; }
+ .f2 { font-size: 2.25rem; }
+ .f3 { font-size: 1.5rem; }
+ .f4 { font-size: 1.25rem; }
+ .f5 { font-size: 1rem; }
+ .f6 { font-size: .875rem; }
+ .f7 { font-size: .75rem; }
+ /* Small and hard to read for many people so use with extreme caution */
+ /*
+ 
+    TYPOGRAPHY
+    http://tachyons.io/docs/typography/measure/
+ 
+    Media Query Extensions:
+      -ns = not-small
+      -m  = medium
+      -l  = large
+ 
+ */
+ /* Measure is limited to ~66 characters */
+ .measure { max-width: 30em; }
+ /* Measure is limited to ~80 characters */
+ .measure-wide { max-width: 34em; }
+ /* Measure is limited to ~45 characters */
+ .measure-narrow { max-width: 20em; }
+ /* Book paragraph style - paragraphs are indented with no vertical spacing. */
+ .indent { text-indent: 1em; margin-top: 0; margin-bottom: 0; }
+ .small-caps { font-variant: small-caps; }
+ /* Combine this class with a width to truncate text (or just leave as is to truncate at width of containing element. */
+ .truncate { white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+ /*
+ 
+    UTILITIES
+ 
+    Media Query Extensions:
+      -ns = not-small
+      -m  = medium
+      -l  = large
+ 
+ */
+ /* Equivalent to .overflow-y-scroll */
+ .overflow-container { overflow-y: scroll; }
+ .center { margin-right: auto; margin-left: auto; }
+ .mr-auto { margin-right: auto; }
+ .ml-auto { margin-left: auto; }
+ /*
+ 
+    VISIBILITY
+ 
+    Media Query Extensions:
+      -ns = not-small
+      -m  = medium
+      -l  = large
+ 
+ */
+ /*
+     Text that is hidden but accessible
+     Ref: http://snook.ca/archives/html_and_css/hiding-content-for-accessibility
+ */
+ .clip { position: fixed !important; _position: absolute !important; clip: rect( 1px 1px 1px 1px ); /* IE6, IE7 */ clip: rect( 1px, 1px, 1px, 1px ); }
+ /*
+ 
+    WHITE SPACE
+ 
+    Media Query Extensions:
+      -ns = not-small
+      -m  = medium
+      -l  = large
+ 
+ */
+ .ws-normal { white-space: normal; }
+ .nowrap { white-space: nowrap; }
+ .pre { white-space: pre; }
+ /*
+ 
+    VERTICAL ALIGN
+ 
+    Media Query Extensions:
+      -ns = not-small
+      -m  = medium
+      -l  = large
+ 
+ */
+ .v-base { vertical-align: baseline; }
+ .v-mid { vertical-align: middle; }
+ .v-top { vertical-align: top; }
+ .v-btm { vertical-align: bottom; }
+ /*
+ 
+   HOVER EFFECTS
+   Docs: http://tachyons.io/docs/themes/hovers/
+ 
+     - Dim
+     - Glow
+     - Hide Child
+     - Underline text
+     - Grow
+     - Pointer
+     - Shadow
+ 
+ */
+ /*
+ 
+   Dim element on hover by adding the dim class.
+ 
+ */
+ .dim { opacity: 1; transition: opacity .15s ease-in; }
+ .dim:hover, .dim:focus { opacity: .5; transition: opacity .15s ease-in; }
+ .dim:active { opacity: .8; transition: opacity .15s ease-out; }
+ /*
+ 
+   Animate opacity to 100% on hover by adding the glow class.
+ 
+ */
+ .glow { transition: opacity .15s ease-in; }
+ .glow:hover, .glow:focus { opacity: 1; transition: opacity .15s ease-in; }
+ /*
+ 
+   Hide child & reveal on hover:
+ 
+   Put the hide-child class on a parent element and any nested element with the
+   child class will be hidden and displayed on hover or focus.
+ 
+   <div class="hide-child">
+     <div class="child"> Hidden until hover or focus </div>
+     <div class="child"> Hidden until hover or focus </div>
+     <div class="child"> Hidden until hover or focus </div>
+     <div class="child"> Hidden until hover or focus </div>
+   </div>
+ */
+ .hide-child .child { opacity: 0; transition: opacity .15s ease-in; }
+ .hide-child:hover  .child, .hide-child:focus  .child, .hide-child:active .child { opacity: 1; transition: opacity .15s ease-in; }
+ .underline-hover:hover, .underline-hover:focus { text-decoration: underline; }
+ /* Can combine this with overflow-hidden to make background images grow on hover
+  * even if you are using background-size: cover */
+ .grow { -moz-osx-font-smoothing: grayscale; -webkit-backface-visibility: hidden; backface-visibility: hidden; -webkit-transform: translateZ( 0 ); transform: translateZ( 0 ); transition: -webkit-transform .25s ease-out; transition: transform .25s ease-out; transition: transform .25s ease-out, -webkit-transform .25s ease-out; }
+ .grow:hover, .grow:focus { -webkit-transform: scale( 1.05 ); transform: scale( 1.05 ); }
+ .grow:active { -webkit-transform: scale( .90 ); transform: scale( .90 ); }
+ .grow-large { -moz-osx-font-smoothing: grayscale; -webkit-backface-visibility: hidden; backface-visibility: hidden; -webkit-transform: translateZ( 0 ); transform: translateZ( 0 ); transition: -webkit-transform .25s ease-in-out; transition: transform .25s ease-in-out; transition: transform .25s ease-in-out, -webkit-transform .25s ease-in-out; }
+ .grow-large:hover, .grow-large:focus { -webkit-transform: scale( 1.2 ); transform: scale( 1.2 ); }
+ .grow-large:active { -webkit-transform: scale( .95 ); transform: scale( .95 ); }
+ /* Add pointer on hover */
+ .pointer:hover { cursor: pointer; }
+ /* 
+    Add shadow on hover.
+ 
+    Performant box-shadow animation pattern from 
+    http://tobiasahlin.com/blog/how-to-animate-box-shadow/ 
+ */
+ .shadow-hover { cursor: pointer; position: relative; transition: all .5s cubic-bezier( .165, .84, .44, 1 ); }
+ .shadow-hover::after { content: ''; box-shadow: 0 0 16px 2px rgba( 0, 0, 0, .2 ); border-radius: inherit; opacity: 0; position: absolute; top: 0; left: 0; width: 100%; height: 100%; z-index: -1; transition: opacity .5s cubic-bezier( .165, .84, .44, 1 ); }
+ .shadow-hover:hover::after, .shadow-hover:focus::after { opacity: 1; }
+ /* Combine with classes in skins and skins-pseudo for 
+  * many different transition possibilities. */
+ .bg-animate, .bg-animate:hover, .bg-animate:focus { transition: background-color .15s ease-in-out; }
+ /*
+ 
+   Z-INDEX
+ 
+   Base
+     z = z-index
+ 
+   Modifiers
+     -0 = literal value 0
+     -1 = literal value 1
+     -2 = literal value 2
+     -3 = literal value 3
+     -4 = literal value 4
+     -5 = literal value 5
+     -999 = literal value 999
+     -9999 = literal value 9999
+ 
+     -max = largest accepted z-index value as integer
+ 
+     -inherit = string value inherit
+     -initial = string value initial
+     -unset = string value unset
+ 
+   MDN: https://developer.mozilla.org/en/docs/Web/CSS/z-index
+   Spec: http://www.w3.org/TR/CSS2/zindex.html
+   Articles:
+     https://philipwalton.com/articles/what-no-one-told-you-about-z-index/
+ 
+   Tips on extending:
+   There might be a time worth using negative z-index values.
+   Or if you are using tachyons with another project, you might need to
+   adjust these values to suit your needs.
+ 
+ */
+ .z-0 { z-index: 0; }
+ .z-1 { z-index: 1; }
+ .z-2 { z-index: 2; }
+ .z-3 { z-index: 3; }
+ .z-4 { z-index: 4; }
+ .z-5 { z-index: 5; }
+ .z-999 { z-index: 999; }
+ .z-9999 { z-index: 9999; }
+ .z-max { z-index: 2147483647; }
+ .z-inherit { z-index: inherit; }
+ .z-initial { z-index: initial; }
+ .z-unset { z-index: unset; }
+ /*
+ 
+     NESTED
+     Tachyons module for styling nested elements
+     that are generated by a cms.
+ 
+ */
+ .nested-copy-line-height p, .nested-copy-line-height ul,
+ .nested-copy-line-height ol { line-height: 1.5; }
+ .nested-headline-line-height h1, .nested-headline-line-height h2,
+ .nested-headline-line-height h3, .nested-headline-line-height h4,
+ .nested-headline-line-height h5, .nested-headline-line-height h6 { line-height: 1.25; }
+ .nested-list-reset ul, .nested-list-reset ol { padding-left: 0; margin-left: 0; list-style-type: none; }
+ .nested-copy-indent p+p { text-indent: 1em; margin-top: 0; margin-bottom: 0; }
+ .nested-copy-separator p+p { margin-top: 1.5em; }
+ .nested-img img { width: 100%; max-width: 100%; display: block; }
+ .nested-links a { color: #357edd; transition: color .15s ease-in; }
+ .nested-links a:hover { color: #96ccff; transition: color .15s ease-in; }
+ .nested-links a:focus { color: #96ccff; transition: color .15s ease-in; }
+ /*
+ 
+   STYLES
+ 
+   Add custom styles here.
+ 
+ */
+ /* Variables */
+ /* Importing here will allow you to override any variables in the modules */
+ /*
+ 
+    Tachyons
+    COLOR VARIABLES
+ 
+    Grayscale
+    - Solids
+    - Transparencies
+    Colors
+ 
+ */
+ /*
+ 
+   CUSTOM MEDIA QUERIES
+ 
+   Media query values can be changed to fit your own content.
+   There are no magic bullets when it comes to media query width values.
+   They should be declared in em units - and they should be set to meet
+   the needs of your content. You can also add additional media queries,
+   or remove some of the existing ones.
+ 
+   These media queries can be referenced like so:
+ 
+   @media (--breakpoint-not-small) {
+     .medium-and-larger-specific-style {
+       background-color: red;
+     }
+   }
+ 
+   @media (--breakpoint-medium) {
+     .medium-screen-specific-style {
+       background-color: red;
+     }
+   }
+ 
+   @media (--breakpoint-large) {
+     .large-and-larger-screen-specific-style {
+       background-color: red;
+     }
+   }
+ 
+ */
+ /* Media Queries */
+ /* Debugging */
+ /*
+ 
+   DEBUG CHILDREN
+   Docs: http://tachyons.io/docs/debug/
+ 
+   Just add the debug class to any element to see outlines on its
+   children.
+ 
+ */
+ .debug * { outline: 1px solid gold; }
+ .debug-white * { outline: 1px solid white; }
+ .debug-black * { outline: 1px solid black; }
+ /*
+ 
+    DEBUG GRID
+    http://tachyons.io/docs/debug-grid/
+ 
+    Can be useful for debugging layout issues
+    or helping to make sure things line up perfectly.
+    Just tack one of these classes onto a parent element.
+ 
+ */
+ .debug-grid { background: transparent url( data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAgAAAAICAYAAADED76LAAAAFElEQVR4AWPAC97/9x0eCsAEPgwAVLshdpENIxcAAAAASUVORK5CYII= ) repeat top left; }
+ .debug-grid-16 { background: transparent url( data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAMklEQVR4AWOgCLz/b0epAa6UGuBOqQHOQHLUgFEDnAbcBZ4UGwDOkiCnkIhdgNgNxAYAiYlD+8sEuo8AAAAASUVORK5CYII= ) repeat top left; }
+ .debug-grid-8-solid { background: white url( data:image/gif;base64,R0lGODdhCAAIAPEAAADw/wDx/////wAAACwAAAAACAAIAAACDZQvgaeb/lxbAIKA8y0AOw== ) repeat top left; }
+ .debug-grid-16-solid { background: white url( data:image/gif;base64,R0lGODdhEAAQAPEAAADw/wDx/xXy/////ywAAAAAEAAQAAACIZyPKckYDQFsb6ZqD85jZ2+BkwiRFKehhqQCQgDHcgwEBQA7 ) repeat top left; }
+ /* Uncomment out the line below to help debug layout issues */
+ /* @import './_debug'; */
+ @media screen and (min-width: 30em) {
+  .aspect-ratio-ns { height: 0; position: relative; }
+  .aspect-ratio--16x9-ns { padding-bottom: 56.25%; }
+  .aspect-ratio--9x16-ns { padding-bottom: 177.77%; }
+  .aspect-ratio--4x3-ns { padding-bottom: 75%; }
+  .aspect-ratio--3x4-ns { padding-bottom: 133.33%; }
+  .aspect-ratio--6x4-ns { padding-bottom: 66.6%; }
+  .aspect-ratio--4x6-ns { padding-bottom: 150%; }
+  .aspect-ratio--8x5-ns { padding-bottom: 62.5%; }
+  .aspect-ratio--5x8-ns { padding-bottom: 160%; }
+  .aspect-ratio--7x5-ns { padding-bottom: 71.42%; }
+  .aspect-ratio--5x7-ns { padding-bottom: 140%; }
+  .aspect-ratio--1x1-ns { padding-bottom: 100%; }
+  .aspect-ratio--object-ns { position: absolute; top: 0; right: 0; bottom: 0; left: 0; width: 100%; height: 100%; z-index: 100; }
+  .cover-ns { background-size: cover !important; }
+  .contain-ns { background-size: contain !important; }
+  .bg-center-ns { background-repeat: no-repeat; background-position: center center; }
+  .bg-top-ns { background-repeat: no-repeat; background-position: top center; }
+  .bg-right-ns { background-repeat: no-repeat; background-position: center right; }
+  .bg-bottom-ns { background-repeat: no-repeat; background-position: bottom center; }
+  .bg-left-ns { background-repeat: no-repeat; background-position: center left; }
+  .outline-ns { outline: 1px solid; }
+  .outline-transparent-ns { outline: 1px solid transparent; }
+  .outline-0-ns { outline: 0; }
+  .ba-ns { border-style: solid; border-width: 1px; }
+  .bt-ns { border-top-style: solid; border-top-width: 1px; }
+  .br-ns { border-right-style: solid; border-right-width: 1px; }
+  .bb-ns { border-bottom-style: solid; border-bottom-width: 1px; }
+  .bl-ns { border-left-style: solid; border-left-width: 1px; }
+  .bn-ns { border-style: none; border-width: 0; }
+  .br0-ns { border-radius: 0; }
+  .br1-ns { border-radius: .125rem; }
+  .br2-ns { border-radius: .25rem; }
+  .br3-ns { border-radius: .5rem; }
+  .br4-ns { border-radius: 1rem; }
+  .br-100-ns { border-radius: 100%; }
+  .br-pill-ns { border-radius: 9999px; }
+  .br--bottom-ns { border-top-left-radius: 0; border-top-right-radius: 0; }
+  .br--top-ns { border-bottom-left-radius: 0; border-bottom-right-radius: 0; }
+  .br--right-ns { border-top-left-radius: 0; border-bottom-left-radius: 0; }
+  .br--left-ns { border-top-right-radius: 0; border-bottom-right-radius: 0; }
+  .br-inherit-ns { border-radius: inherit; }
+  .br-initial-ns { border-radius: initial; }
+  .br-unset-ns { border-radius: unset; }
+  .b--dotted-ns { border-style: dotted; }
+  .b--dashed-ns { border-style: dashed; }
+  .b--solid-ns { border-style: solid; }
+  .b--none-ns { border-style: none; }
+  .bw0-ns { border-width: 0; }
+  .bw1-ns { border-width: .125rem; }
+  .bw2-ns { border-width: .25rem; }
+  .bw3-ns { border-width: .5rem; }
+  .bw4-ns { border-width: 1rem; }
+  .bw5-ns { border-width: 2rem; }
+  .bt-0-ns { border-top-width: 0; }
+  .br-0-ns { border-right-width: 0; }
+  .bb-0-ns { border-bottom-width: 0; }
+  .bl-0-ns { border-left-width: 0; }
+  .shadow-1-ns { box-shadow: 0 0 4px 2px rgba( 0, 0, 0, .2 ); }
+  .shadow-2-ns { box-shadow: 0 0 8px 2px rgba( 0, 0, 0, .2 ); }
+  .shadow-3-ns { box-shadow: 2px 2px 4px 2px rgba( 0, 0, 0, .2 ); }
+  .shadow-4-ns { box-shadow: 2px 2px 8px 0 rgba( 0, 0, 0, .2 ); }
+  .shadow-5-ns { box-shadow: 4px 4px 8px 0 rgba( 0, 0, 0, .2 ); }
+  .top-0-ns { top: 0; }
+  .left-0-ns { left: 0; }
+  .right-0-ns { right: 0; }
+  .bottom-0-ns { bottom: 0; }
+  .top-1-ns { top: 1rem; }
+  .left-1-ns { left: 1rem; }
+  .right-1-ns { right: 1rem; }
+  .bottom-1-ns { bottom: 1rem; }
+  .top-2-ns { top: 2rem; }
+  .left-2-ns { left: 2rem; }
+  .right-2-ns { right: 2rem; }
+  .bottom-2-ns { bottom: 2rem; }
+  .top--1-ns { top: -1rem; }
+  .right--1-ns { right: -1rem; }
+  .bottom--1-ns { bottom: -1rem; }
+  .left--1-ns { left: -1rem; }
+  .top--2-ns { top: -2rem; }
+  .right--2-ns { right: -2rem; }
+  .bottom--2-ns { bottom: -2rem; }
+  .left--2-ns { left: -2rem; }
+  .absolute--fill-ns { top: 0; right: 0; bottom: 0; left: 0; }
+  .cl-ns { clear: left; }
+  .cr-ns { clear: right; }
+  .cb-ns { clear: both; }
+  .cn-ns { clear: none; }
+  .dn-ns { display: none; }
+  .di-ns { display: inline; }
+  .db-ns { display: block; }
+  .dib-ns { display: inline-block; }
+  .dit-ns { display: inline-table; }
+  .dt-ns { display: table; }
+  .dtc-ns { display: table-cell; }
+  .dt-row-ns { display: table-row; }
+  .dt-row-group-ns { display: table-row-group; }
+  .dt-column-ns { display: table-column; }
+  .dt-column-group-ns { display: table-column-group; }
+  .dt--fixed-ns { table-layout: fixed; width: 100%; }
+  .flex-ns { display: flex; }
+  .inline-flex-ns { display: inline-flex; }
+  .flex-auto-ns { flex: 1 1 auto; min-width: 0; /* 1 */ min-height: 0; /* 1 */ }
+  .flex-none-ns { flex: none; }
+  .flex-column-ns { flex-direction: column; }
+  .flex-row-ns { flex-direction: row; }
+  .flex-wrap-ns { flex-wrap: wrap; }
+  .flex-nowrap-ns { flex-wrap: nowrap; }
+  .flex-wrap-reverse-ns { flex-wrap: wrap-reverse; }
+  .flex-column-reverse-ns { flex-direction: column-reverse; }
+  .flex-row-reverse-ns { flex-direction: row-reverse; }
+  .items-start-ns { align-items: flex-start; }
+  .items-end-ns { align-items: flex-end; }
+  .items-center-ns { align-items: center; }
+  .items-baseline-ns { align-items: baseline; }
+  .items-stretch-ns { align-items: stretch; }
+  .self-start-ns { align-self: flex-start; }
+  .self-end-ns { align-self: flex-end; }
+  .self-center-ns { align-self: center; }
+  .self-baseline-ns { align-self: baseline; }
+  .self-stretch-ns { align-self: stretch; }
+  .justify-start-ns { justify-content: flex-start; }
+  .justify-end-ns { justify-content: flex-end; }
+  .justify-center-ns { justify-content: center; }
+  .justify-between-ns { justify-content: space-between; }
+  .justify-around-ns { justify-content: space-around; }
+  .content-start-ns { align-content: flex-start; }
+  .content-end-ns { align-content: flex-end; }
+  .content-center-ns { align-content: center; }
+  .content-between-ns { align-content: space-between; }
+  .content-around-ns { align-content: space-around; }
+  .content-stretch-ns { align-content: stretch; }
+  .order-0-ns { order: 0; }
+  .order-1-ns { order: 1; }
+  .order-2-ns { order: 2; }
+  .order-3-ns { order: 3; }
+  .order-4-ns { order: 4; }
+  .order-5-ns { order: 5; }
+  .order-6-ns { order: 6; }
+  .order-7-ns { order: 7; }
+  .order-8-ns { order: 8; }
+  .order-last-ns { order: 99999; }
+  .flex-grow-0-ns { flex-grow: 0; }
+  .flex-grow-1-ns { flex-grow: 1; }
+  .flex-shrink-0-ns { flex-shrink: 0; }
+  .flex-shrink-1-ns { flex-shrink: 1; }
+  .fl-ns { float: left; _display: inline; }
+  .fr-ns { float: right; _display: inline; }
+  .fn-ns { float: none; }
+  .i-ns { font-style: italic; }
+  .fs-normal-ns { font-style: normal; }
+  .normal-ns { font-weight: normal; }
+  .b-ns { font-weight: bold; }
+  .fw1-ns { font-weight: 100; }
+  .fw2-ns { font-weight: 200; }
+  .fw3-ns { font-weight: 300; }
+  .fw4-ns { font-weight: 400; }
+  .fw5-ns { font-weight: 500; }
+  .fw6-ns { font-weight: 600; }
+  .fw7-ns { font-weight: 700; }
+  .fw8-ns { font-weight: 800; }
+  .fw9-ns { font-weight: 900; }
+  .h1-ns { height: 1rem; }
+  .h2-ns { height: 2rem; }
+  .h3-ns { height: 4rem; }
+  .h4-ns { height: 8rem; }
+  .h5-ns { height: 16rem; }
+  .h-25-ns { height: 25%; }
+  .h-50-ns { height: 50%; }
+  .h-75-ns { height: 75%; }
+  .h-100-ns { height: 100%; }
+  .min-h-100-ns { min-height: 100%; }
+  .vh-25-ns { height: 25vh; }
+  .vh-50-ns { height: 50vh; }
+  .vh-75-ns { height: 75vh; }
+  .vh-100-ns { height: 100vh; }
+  .min-vh-100-ns { min-height: 100vh; }
+  .h-auto-ns { height: auto; }
+  .h-inherit-ns { height: inherit; }
+  .tracked-ns { letter-spacing: .1em; }
+  .tracked-tight-ns { letter-spacing: -.05em; }
+  .tracked-mega-ns { letter-spacing: .25em; }
+  .lh-solid-ns { line-height: 1; }
+  .lh-title-ns { line-height: 1.25; }
+  .lh-copy-ns { line-height: 1.5; }
+  .mw-100-ns { max-width: 100%; }
+  .mw1-ns { max-width: 1rem; }
+  .mw2-ns { max-width: 2rem; }
+  .mw3-ns { max-width: 4rem; }
+  .mw4-ns { max-width: 8rem; }
+  .mw5-ns { max-width: 16rem; }
+  .mw6-ns { max-width: 32rem; }
+  .mw7-ns { max-width: 48rem; }
+  .mw8-ns { max-width: 64rem; }
+  .mw9-ns { max-width: 96rem; }
+  .mw-none-ns { max-width: none; }
+  .w1-ns { width: 1rem; }
+  .w2-ns { width: 2rem; }
+  .w3-ns { width: 4rem; }
+  .w4-ns { width: 8rem; }
+  .w5-ns { width: 16rem; }
+  .w-10-ns { width: 10%; }
+  .w-20-ns { width: 20%; }
+  .w-25-ns { width: 25%; }
+  .w-30-ns { width: 30%; }
+  .w-33-ns { width: 33%; }
+  .w-34-ns { width: 34%; }
+  .w-40-ns { width: 40%; }
+  .w-50-ns { width: 50%; }
+  .w-60-ns { width: 60%; }
+  .w-70-ns { width: 70%; }
+  .w-75-ns { width: 75%; }
+  .w-80-ns { width: 80%; }
+  .w-90-ns { width: 90%; }
+  .w-100-ns { width: 100%; }
+  .w-third-ns { width: 33.33333%; }
+  .w-two-thirds-ns { width: 66.66667%; }
+  .w-auto-ns { width: auto; }
+  .overflow-visible-ns { overflow: visible; }
+  .overflow-hidden-ns { overflow: hidden; }
+  .overflow-scroll-ns { overflow: scroll; }
+  .overflow-auto-ns { overflow: auto; }
+  .overflow-x-visible-ns { overflow-x: visible; }
+  .overflow-x-hidden-ns { overflow-x: hidden; }
+  .overflow-x-scroll-ns { overflow-x: scroll; }
+  .overflow-x-auto-ns { overflow-x: auto; }
+  .overflow-y-visible-ns { overflow-y: visible; }
+  .overflow-y-hidden-ns { overflow-y: hidden; }
+  .overflow-y-scroll-ns { overflow-y: scroll; }
+  .overflow-y-auto-ns { overflow-y: auto; }
+  .static-ns { position: static; }
+  .relative-ns { position: relative; }
+  .absolute-ns { position: absolute; }
+  .fixed-ns { position: fixed; }
+  .rotate-45-ns { -webkit-transform: rotate( 45deg ); transform: rotate( 45deg ); }
+  .rotate-90-ns { -webkit-transform: rotate( 90deg ); transform: rotate( 90deg ); }
+  .rotate-135-ns { -webkit-transform: rotate( 135deg ); transform: rotate( 135deg ); }
+  .rotate-180-ns { -webkit-transform: rotate( 180deg ); transform: rotate( 180deg ); }
+  .rotate-225-ns { -webkit-transform: rotate( 225deg ); transform: rotate( 225deg ); }
+  .rotate-270-ns { -webkit-transform: rotate( 270deg ); transform: rotate( 270deg ); }
+  .rotate-315-ns { -webkit-transform: rotate( 315deg ); transform: rotate( 315deg ); }
+  .pa0-ns { padding: 0; }
+  .pa1-ns { padding: .25rem; }
+  .pa2-ns { padding: .5rem; }
+  .pa3-ns { padding: 1rem; }
+  .pa4-ns { padding: 2rem; }
+  .pa5-ns { padding: 4rem; }
+  .pa6-ns { padding: 8rem; }
+  .pa7-ns { padding: 16rem; }
+  .pl0-ns { padding-left: 0; }
+  .pl1-ns { padding-left: .25rem; }
+  .pl2-ns { padding-left: .5rem; }
+  .pl3-ns { padding-left: 1rem; }
+  .pl4-ns { padding-left: 2rem; }
+  .pl5-ns { padding-left: 4rem; }
+  .pl6-ns { padding-left: 8rem; }
+  .pl7-ns { padding-left: 16rem; }
+  .pr0-ns { padding-right: 0; }
+  .pr1-ns { padding-right: .25rem; }
+  .pr2-ns { padding-right: .5rem; }
+  .pr3-ns { padding-right: 1rem; }
+  .pr4-ns { padding-right: 2rem; }
+  .pr5-ns { padding-right: 4rem; }
+  .pr6-ns { padding-right: 8rem; }
+  .pr7-ns { padding-right: 16rem; }
+  .pb0-ns { padding-bottom: 0; }
+  .pb1-ns { padding-bottom: .25rem; }
+  .pb2-ns { padding-bottom: .5rem; }
+  .pb3-ns { padding-bottom: 1rem; }
+  .pb4-ns { padding-bottom: 2rem; }
+  .pb5-ns { padding-bottom: 4rem; }
+  .pb6-ns { padding-bottom: 8rem; }
+  .pb7-ns { padding-bottom: 16rem; }
+  .pt0-ns { padding-top: 0; }
+  .pt1-ns { padding-top: .25rem; }
+  .pt2-ns { padding-top: .5rem; }
+  .pt3-ns { padding-top: 1rem; }
+  .pt4-ns { padding-top: 2rem; }
+  .pt5-ns { padding-top: 4rem; }
+  .pt6-ns { padding-top: 8rem; }
+  .pt7-ns { padding-top: 16rem; }
+  .pv0-ns { padding-top: 0; padding-bottom: 0; }
+  .pv1-ns { padding-top: .25rem; padding-bottom: .25rem; }
+  .pv2-ns { padding-top: .5rem; padding-bottom: .5rem; }
+  .pv3-ns { padding-top: 1rem; padding-bottom: 1rem; }
+  .pv4-ns { padding-top: 2rem; padding-bottom: 2rem; }
+  .pv5-ns { padding-top: 4rem; padding-bottom: 4rem; }
+  .pv6-ns { padding-top: 8rem; padding-bottom: 8rem; }
+  .pv7-ns { padding-top: 16rem; padding-bottom: 16rem; }
+  .ph0-ns { padding-left: 0; padding-right: 0; }
+  .ph1-ns { padding-left: .25rem; padding-right: .25rem; }
+  .ph2-ns { padding-left: .5rem; padding-right: .5rem; }
+  .ph3-ns { padding-left: 1rem; padding-right: 1rem; }
+  .ph4-ns { padding-left: 2rem; padding-right: 2rem; }
+  .ph5-ns { padding-left: 4rem; padding-right: 4rem; }
+  .ph6-ns { padding-left: 8rem; padding-right: 8rem; }
+  .ph7-ns { padding-left: 16rem; padding-right: 16rem; }
+  .ma0-ns { margin: 0; }
+  .ma1-ns { margin: .25rem; }
+  .ma2-ns { margin: .5rem; }
+  .ma3-ns { margin: 1rem; }
+  .ma4-ns { margin: 2rem; }
+  .ma5-ns { margin: 4rem; }
+  .ma6-ns { margin: 8rem; }
+  .ma7-ns { margin: 16rem; }
+  .ml0-ns { margin-left: 0; }
+  .ml1-ns { margin-left: .25rem; }
+  .ml2-ns { margin-left: .5rem; }
+  .ml3-ns { margin-left: 1rem; }
+  .ml4-ns { margin-left: 2rem; }
+  .ml5-ns { margin-left: 4rem; }
+  .ml6-ns { margin-left: 8rem; }
+  .ml7-ns { margin-left: 16rem; }
+  .mr0-ns { margin-right: 0; }
+  .mr1-ns { margin-right: .25rem; }
+  .mr2-ns { margin-right: .5rem; }
+  .mr3-ns { margin-right: 1rem; }
+  .mr4-ns { margin-right: 2rem; }
+  .mr5-ns { margin-right: 4rem; }
+  .mr6-ns { margin-right: 8rem; }
+  .mr7-ns { margin-right: 16rem; }
+  .mb0-ns { margin-bottom: 0; }
+  .mb1-ns { margin-bottom: .25rem; }
+  .mb2-ns { margin-bottom: .5rem; }
+  .mb3-ns { margin-bottom: 1rem; }
+  .mb4-ns { margin-bottom: 2rem; }
+  .mb5-ns { margin-bottom: 4rem; }
+  .mb6-ns { margin-bottom: 8rem; }
+  .mb7-ns { margin-bottom: 16rem; }
+  .mt0-ns { margin-top: 0; }
+  .mt1-ns { margin-top: .25rem; }
+  .mt2-ns { margin-top: .5rem; }
+  .mt3-ns { margin-top: 1rem; }
+  .mt4-ns { margin-top: 2rem; }
+  .mt5-ns { margin-top: 4rem; }
+  .mt6-ns { margin-top: 8rem; }
+  .mt7-ns { margin-top: 16rem; }
+  .mv0-ns { margin-top: 0; margin-bottom: 0; }
+  .mv1-ns { margin-top: .25rem; margin-bottom: .25rem; }
+  .mv2-ns { margin-top: .5rem; margin-bottom: .5rem; }
+  .mv3-ns { margin-top: 1rem; margin-bottom: 1rem; }
+  .mv4-ns { margin-top: 2rem; margin-bottom: 2rem; }
+  .mv5-ns { margin-top: 4rem; margin-bottom: 4rem; }
+  .mv6-ns { margin-top: 8rem; margin-bottom: 8rem; }
+  .mv7-ns { margin-top: 16rem; margin-bottom: 16rem; }
+  .mh0-ns { margin-left: 0; margin-right: 0; }
+  .mh1-ns { margin-left: .25rem; margin-right: .25rem; }
+  .mh2-ns { margin-left: .5rem; margin-right: .5rem; }
+  .mh3-ns { margin-left: 1rem; margin-right: 1rem; }
+  .mh4-ns { margin-left: 2rem; margin-right: 2rem; }
+  .mh5-ns { margin-left: 4rem; margin-right: 4rem; }
+  .mh6-ns { margin-left: 8rem; margin-right: 8rem; }
+  .mh7-ns { margin-left: 16rem; margin-right: 16rem; }
+  .na1-ns { margin: -0.25rem; }
+  .na2-ns { margin: -0.5rem; }
+  .na3-ns { margin: -1rem; }
+  .na4-ns { margin: -2rem; }
+  .na5-ns { margin: -4rem; }
+  .na6-ns { margin: -8rem; }
+  .na7-ns { margin: -16rem; }
+  .nl1-ns { margin-left: -0.25rem; }
+  .nl2-ns { margin-left: -0.5rem; }
+  .nl3-ns { margin-left: -1rem; }
+  .nl4-ns { margin-left: -2rem; }
+  .nl5-ns { margin-left: -4rem; }
+  .nl6-ns { margin-left: -8rem; }
+  .nl7-ns { margin-left: -16rem; }
+  .nr1-ns { margin-right: -0.25rem; }
+  .nr2-ns { margin-right: -0.5rem; }
+  .nr3-ns { margin-right: -1rem; }
+  .nr4-ns { margin-right: -2rem; }
+  .nr5-ns { margin-right: -4rem; }
+  .nr6-ns { margin-right: -8rem; }
+  .nr7-ns { margin-right: -16rem; }
+  .nb1-ns { margin-bottom: -0.25rem; }
+  .nb2-ns { margin-bottom: -0.5rem; }
+  .nb3-ns { margin-bottom: -1rem; }
+  .nb4-ns { margin-bottom: -2rem; }
+  .nb5-ns { margin-bottom: -4rem; }
+  .nb6-ns { margin-bottom: -8rem; }
+  .nb7-ns { margin-bottom: -16rem; }
+  .nt1-ns { margin-top: -0.25rem; }
+  .nt2-ns { margin-top: -0.5rem; }
+  .nt3-ns { margin-top: -1rem; }
+  .nt4-ns { margin-top: -2rem; }
+  .nt5-ns { margin-top: -4rem; }
+  .nt6-ns { margin-top: -8rem; }
+  .nt7-ns { margin-top: -16rem; }
+  .strike-ns { text-decoration: line-through; }
+  .underline-ns { text-decoration: underline; }
+  .no-underline-ns { text-decoration: none; }
+  .tl-ns { text-align: left; }
+  .tr-ns { text-align: right; }
+  .tc-ns { text-align: center; }
+  .tj-ns { text-align: justify; }
+  .ttc-ns { text-transform: capitalize; }
+  .ttl-ns { text-transform: lowercase; }
+  .ttu-ns { text-transform: uppercase; }
+  .ttn-ns { text-transform: none; }
+  .f-6-ns, .f-headline-ns { font-size: 6rem; }
+  .f-5-ns, .f-subheadline-ns { font-size: 5rem; }
+  .f1-ns { font-size: 3rem; }
+  .f2-ns { font-size: 2.25rem; }
+  .f3-ns { font-size: 1.5rem; }
+  .f4-ns { font-size: 1.25rem; }
+  .f5-ns { font-size: 1rem; }
+  .f6-ns { font-size: .875rem; }
+  .f7-ns { font-size: .75rem; }
+  .measure-ns { max-width: 30em; }
+  .measure-wide-ns { max-width: 34em; }
+  .measure-narrow-ns { max-width: 20em; }
+  .indent-ns { text-indent: 1em; margin-top: 0; margin-bottom: 0; }
+  .small-caps-ns { font-variant: small-caps; }
+  .truncate-ns { white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+  .center-ns { margin-right: auto; margin-left: auto; }
+  .mr-auto-ns { margin-right: auto; }
+  .ml-auto-ns { margin-left: auto; }
+  .clip-ns { position: fixed !important; _position: absolute !important; clip: rect( 1px 1px 1px 1px ); /* IE6, IE7 */ clip: rect( 1px, 1px, 1px, 1px ); }
+  .ws-normal-ns { white-space: normal; }
+  .nowrap-ns { white-space: nowrap; }
+  .pre-ns { white-space: pre; }
+  .v-base-ns { vertical-align: baseline; }
+  .v-mid-ns { vertical-align: middle; }
+  .v-top-ns { vertical-align: top; }
+  .v-btm-ns { vertical-align: bottom; }
+ }
+ @media screen and (min-width: 30em) and (max-width: 60em) {
+  .aspect-ratio-m { height: 0; position: relative; }
+  .aspect-ratio--16x9-m { padding-bottom: 56.25%; }
+  .aspect-ratio--9x16-m { padding-bottom: 177.77%; }
+  .aspect-ratio--4x3-m { padding-bottom: 75%; }
+  .aspect-ratio--3x4-m { padding-bottom: 133.33%; }
+  .aspect-ratio--6x4-m { padding-bottom: 66.6%; }
+  .aspect-ratio--4x6-m { padding-bottom: 150%; }
+  .aspect-ratio--8x5-m { padding-bottom: 62.5%; }
+  .aspect-ratio--5x8-m { padding-bottom: 160%; }
+  .aspect-ratio--7x5-m { padding-bottom: 71.42%; }
+  .aspect-ratio--5x7-m { padding-bottom: 140%; }
+  .aspect-ratio--1x1-m { padding-bottom: 100%; }
+  .aspect-ratio--object-m { position: absolute; top: 0; right: 0; bottom: 0; left: 0; width: 100%; height: 100%; z-index: 100; }
+  .cover-m { background-size: cover !important; }
+  .contain-m { background-size: contain !important; }
+  .bg-center-m { background-repeat: no-repeat; background-position: center center; }
+  .bg-top-m { background-repeat: no-repeat; background-position: top center; }
+  .bg-right-m { background-repeat: no-repeat; background-position: center right; }
+  .bg-bottom-m { background-repeat: no-repeat; background-position: bottom center; }
+  .bg-left-m { background-repeat: no-repeat; background-position: center left; }
+  .outline-m { outline: 1px solid; }
+  .outline-transparent-m { outline: 1px solid transparent; }
+  .outline-0-m { outline: 0; }
+  .ba-m { border-style: solid; border-width: 1px; }
+  .bt-m { border-top-style: solid; border-top-width: 1px; }
+  .br-m { border-right-style: solid; border-right-width: 1px; }
+  .bb-m { border-bottom-style: solid; border-bottom-width: 1px; }
+  .bl-m { border-left-style: solid; border-left-width: 1px; }
+  .bn-m { border-style: none; border-width: 0; }
+  .br0-m { border-radius: 0; }
+  .br1-m { border-radius: .125rem; }
+  .br2-m { border-radius: .25rem; }
+  .br3-m { border-radius: .5rem; }
+  .br4-m { border-radius: 1rem; }
+  .br-100-m { border-radius: 100%; }
+  .br-pill-m { border-radius: 9999px; }
+  .br--bottom-m { border-top-left-radius: 0; border-top-right-radius: 0; }
+  .br--top-m { border-bottom-left-radius: 0; border-bottom-right-radius: 0; }
+  .br--right-m { border-top-left-radius: 0; border-bottom-left-radius: 0; }
+  .br--left-m { border-top-right-radius: 0; border-bottom-right-radius: 0; }
+  .br-inherit-m { border-radius: inherit; }
+  .br-initial-m { border-radius: initial; }
+  .br-unset-m { border-radius: unset; }
+  .b--dotted-m { border-style: dotted; }
+  .b--dashed-m { border-style: dashed; }
+  .b--solid-m { border-style: solid; }
+  .b--none-m { border-style: none; }
+  .bw0-m { border-width: 0; }
+  .bw1-m { border-width: .125rem; }
+  .bw2-m { border-width: .25rem; }
+  .bw3-m { border-width: .5rem; }
+  .bw4-m { border-width: 1rem; }
+  .bw5-m { border-width: 2rem; }
+  .bt-0-m { border-top-width: 0; }
+  .br-0-m { border-right-width: 0; }
+  .bb-0-m { border-bottom-width: 0; }
+  .bl-0-m { border-left-width: 0; }
+  .shadow-1-m { box-shadow: 0 0 4px 2px rgba( 0, 0, 0, .2 ); }
+  .shadow-2-m { box-shadow: 0 0 8px 2px rgba( 0, 0, 0, .2 ); }
+  .shadow-3-m { box-shadow: 2px 2px 4px 2px rgba( 0, 0, 0, .2 ); }
+  .shadow-4-m { box-shadow: 2px 2px 8px 0 rgba( 0, 0, 0, .2 ); }
+  .shadow-5-m { box-shadow: 4px 4px 8px 0 rgba( 0, 0, 0, .2 ); }
+  .top-0-m { top: 0; }
+  .left-0-m { left: 0; }
+  .right-0-m { right: 0; }
+  .bottom-0-m { bottom: 0; }
+  .top-1-m { top: 1rem; }
+  .left-1-m { left: 1rem; }
+  .right-1-m { right: 1rem; }
+  .bottom-1-m { bottom: 1rem; }
+  .top-2-m { top: 2rem; }
+  .left-2-m { left: 2rem; }
+  .right-2-m { right: 2rem; }
+  .bottom-2-m { bottom: 2rem; }
+  .top--1-m { top: -1rem; }
+  .right--1-m { right: -1rem; }
+  .bottom--1-m { bottom: -1rem; }
+  .left--1-m { left: -1rem; }
+  .top--2-m { top: -2rem; }
+  .right--2-m { right: -2rem; }
+  .bottom--2-m { bottom: -2rem; }
+  .left--2-m { left: -2rem; }
+  .absolute--fill-m { top: 0; right: 0; bottom: 0; left: 0; }
+  .cl-m { clear: left; }
+  .cr-m { clear: right; }
+  .cb-m { clear: both; }
+  .cn-m { clear: none; }
+  .dn-m { display: none; }
+  .di-m { display: inline; }
+  .db-m { display: block; }
+  .dib-m { display: inline-block; }
+  .dit-m { display: inline-table; }
+  .dt-m { display: table; }
+  .dtc-m { display: table-cell; }
+  .dt-row-m { display: table-row; }
+  .dt-row-group-m { display: table-row-group; }
+  .dt-column-m { display: table-column; }
+  .dt-column-group-m { display: table-column-group; }
+  .dt--fixed-m { table-layout: fixed; width: 100%; }
+  .flex-m { display: flex; }
+  .inline-flex-m { display: inline-flex; }
+  .flex-auto-m { flex: 1 1 auto; min-width: 0; /* 1 */ min-height: 0; /* 1 */ }
+  .flex-none-m { flex: none; }
+  .flex-column-m { flex-direction: column; }
+  .flex-row-m { flex-direction: row; }
+  .flex-wrap-m { flex-wrap: wrap; }
+  .flex-nowrap-m { flex-wrap: nowrap; }
+  .flex-wrap-reverse-m { flex-wrap: wrap-reverse; }
+  .flex-column-reverse-m { flex-direction: column-reverse; }
+  .flex-row-reverse-m { flex-direction: row-reverse; }
+  .items-start-m { align-items: flex-start; }
+  .items-end-m { align-items: flex-end; }
+  .items-center-m { align-items: center; }
+  .items-baseline-m { align-items: baseline; }
+  .items-stretch-m { align-items: stretch; }
+  .self-start-m { align-self: flex-start; }
+  .self-end-m { align-self: flex-end; }
+  .self-center-m { align-self: center; }
+  .self-baseline-m { align-self: baseline; }
+  .self-stretch-m { align-self: stretch; }
+  .justify-start-m { justify-content: flex-start; }
+  .justify-end-m { justify-content: flex-end; }
+  .justify-center-m { justify-content: center; }
+  .justify-between-m { justify-content: space-between; }
+  .justify-around-m { justify-content: space-around; }
+  .content-start-m { align-content: flex-start; }
+  .content-end-m { align-content: flex-end; }
+  .content-center-m { align-content: center; }
+  .content-between-m { align-content: space-between; }
+  .content-around-m { align-content: space-around; }
+  .content-stretch-m { align-content: stretch; }
+  .order-0-m { order: 0; }
+  .order-1-m { order: 1; }
+  .order-2-m { order: 2; }
+  .order-3-m { order: 3; }
+  .order-4-m { order: 4; }
+  .order-5-m { order: 5; }
+  .order-6-m { order: 6; }
+  .order-7-m { order: 7; }
+  .order-8-m { order: 8; }
+  .order-last-m { order: 99999; }
+  .flex-grow-0-m { flex-grow: 0; }
+  .flex-grow-1-m { flex-grow: 1; }
+  .flex-shrink-0-m { flex-shrink: 0; }
+  .flex-shrink-1-m { flex-shrink: 1; }
+  .fl-m { float: left; _display: inline; }
+  .fr-m { float: right; _display: inline; }
+  .fn-m { float: none; }
+  .i-m { font-style: italic; }
+  .fs-normal-m { font-style: normal; }
+  .normal-m { font-weight: normal; }
+  .b-m { font-weight: bold; }
+  .fw1-m { font-weight: 100; }
+  .fw2-m { font-weight: 200; }
+  .fw3-m { font-weight: 300; }
+  .fw4-m { font-weight: 400; }
+  .fw5-m { font-weight: 500; }
+  .fw6-m { font-weight: 600; }
+  .fw7-m { font-weight: 700; }
+  .fw8-m { font-weight: 800; }
+  .fw9-m { font-weight: 900; }
+  .h1-m { height: 1rem; }
+  .h2-m { height: 2rem; }
+  .h3-m { height: 4rem; }
+  .h4-m { height: 8rem; }
+  .h5-m { height: 16rem; }
+  .h-25-m { height: 25%; }
+  .h-50-m { height: 50%; }
+  .h-75-m { height: 75%; }
+  .h-100-m { height: 100%; }
+  .min-h-100-m { min-height: 100%; }
+  .vh-25-m { height: 25vh; }
+  .vh-50-m { height: 50vh; }
+  .vh-75-m { height: 75vh; }
+  .vh-100-m { height: 100vh; }
+  .min-vh-100-m { min-height: 100vh; }
+  .h-auto-m { height: auto; }
+  .h-inherit-m { height: inherit; }
+  .tracked-m { letter-spacing: .1em; }
+  .tracked-tight-m { letter-spacing: -.05em; }
+  .tracked-mega-m { letter-spacing: .25em; }
+  .lh-solid-m { line-height: 1; }
+  .lh-title-m { line-height: 1.25; }
+  .lh-copy-m { line-height: 1.5; }
+  .mw-100-m { max-width: 100%; }
+  .mw1-m { max-width: 1rem; }
+  .mw2-m { max-width: 2rem; }
+  .mw3-m { max-width: 4rem; }
+  .mw4-m { max-width: 8rem; }
+  .mw5-m { max-width: 16rem; }
+  .mw6-m { max-width: 32rem; }
+  .mw7-m { max-width: 48rem; }
+  .mw8-m { max-width: 64rem; }
+  .mw9-m { max-width: 96rem; }
+  .mw-none-m { max-width: none; }
+  .w1-m { width: 1rem; }
+  .w2-m { width: 2rem; }
+  .w3-m { width: 4rem; }
+  .w4-m { width: 8rem; }
+  .w5-m { width: 16rem; }
+  .w-10-m { width: 10%; }
+  .w-20-m { width: 20%; }
+  .w-25-m { width: 25%; }
+  .w-30-m { width: 30%; }
+  .w-33-m { width: 33%; }
+  .w-34-m { width: 34%; }
+  .w-40-m { width: 40%; }
+  .w-50-m { width: 50%; }
+  .w-60-m { width: 60%; }
+  .w-70-m { width: 70%; }
+  .w-75-m { width: 75%; }
+  .w-80-m { width: 80%; }
+  .w-90-m { width: 90%; }
+  .w-100-m { width: 100%; }
+  .w-third-m { width: 33.33333%; }
+  .w-two-thirds-m { width: 66.66667%; }
+  .w-auto-m { width: auto; }
+  .overflow-visible-m { overflow: visible; }
+  .overflow-hidden-m { overflow: hidden; }
+  .overflow-scroll-m { overflow: scroll; }
+  .overflow-auto-m { overflow: auto; }
+  .overflow-x-visible-m { overflow-x: visible; }
+  .overflow-x-hidden-m { overflow-x: hidden; }
+  .overflow-x-scroll-m { overflow-x: scroll; }
+  .overflow-x-auto-m { overflow-x: auto; }
+  .overflow-y-visible-m { overflow-y: visible; }
+  .overflow-y-hidden-m { overflow-y: hidden; }
+  .overflow-y-scroll-m { overflow-y: scroll; }
+  .overflow-y-auto-m { overflow-y: auto; }
+  .static-m { position: static; }
+  .relative-m { position: relative; }
+  .absolute-m { position: absolute; }
+  .fixed-m { position: fixed; }
+  .rotate-45-m { -webkit-transform: rotate( 45deg ); transform: rotate( 45deg ); }
+  .rotate-90-m { -webkit-transform: rotate( 90deg ); transform: rotate( 90deg ); }
+  .rotate-135-m { -webkit-transform: rotate( 135deg ); transform: rotate( 135deg ); }
+  .rotate-180-m { -webkit-transform: rotate( 180deg ); transform: rotate( 180deg ); }
+  .rotate-225-m { -webkit-transform: rotate( 225deg ); transform: rotate( 225deg ); }
+  .rotate-270-m { -webkit-transform: rotate( 270deg ); transform: rotate( 270deg ); }
+  .rotate-315-m { -webkit-transform: rotate( 315deg ); transform: rotate( 315deg ); }
+  .pa0-m { padding: 0; }
+  .pa1-m { padding: .25rem; }
+  .pa2-m { padding: .5rem; }
+  .pa3-m { padding: 1rem; }
+  .pa4-m { padding: 2rem; }
+  .pa5-m { padding: 4rem; }
+  .pa6-m { padding: 8rem; }
+  .pa7-m { padding: 16rem; }
+  .pl0-m { padding-left: 0; }
+  .pl1-m { padding-left: .25rem; }
+  .pl2-m { padding-left: .5rem; }
+  .pl3-m { padding-left: 1rem; }
+  .pl4-m { padding-left: 2rem; }
+  .pl5-m { padding-left: 4rem; }
+  .pl6-m { padding-left: 8rem; }
+  .pl7-m { padding-left: 16rem; }
+  .pr0-m { padding-right: 0; }
+  .pr1-m { padding-right: .25rem; }
+  .pr2-m { padding-right: .5rem; }
+  .pr3-m { padding-right: 1rem; }
+  .pr4-m { padding-right: 2rem; }
+  .pr5-m { padding-right: 4rem; }
+  .pr6-m { padding-right: 8rem; }
+  .pr7-m { padding-right: 16rem; }
+  .pb0-m { padding-bottom: 0; }
+  .pb1-m { padding-bottom: .25rem; }
+  .pb2-m { padding-bottom: .5rem; }
+  .pb3-m { padding-bottom: 1rem; }
+  .pb4-m { padding-bottom: 2rem; }
+  .pb5-m { padding-bottom: 4rem; }
+  .pb6-m { padding-bottom: 8rem; }
+  .pb7-m { padding-bottom: 16rem; }
+  .pt0-m { padding-top: 0; }
+  .pt1-m { padding-top: .25rem; }
+  .pt2-m { padding-top: .5rem; }
+  .pt3-m { padding-top: 1rem; }
+  .pt4-m { padding-top: 2rem; }
+  .pt5-m { padding-top: 4rem; }
+  .pt6-m { padding-top: 8rem; }
+  .pt7-m { padding-top: 16rem; }
+  .pv0-m { padding-top: 0; padding-bottom: 0; }
+  .pv1-m { padding-top: .25rem; padding-bottom: .25rem; }
+  .pv2-m { padding-top: .5rem; padding-bottom: .5rem; }
+  .pv3-m { padding-top: 1rem; padding-bottom: 1rem; }
+  .pv4-m { padding-top: 2rem; padding-bottom: 2rem; }
+  .pv5-m { padding-top: 4rem; padding-bottom: 4rem; }
+  .pv6-m { padding-top: 8rem; padding-bottom: 8rem; }
+  .pv7-m { padding-top: 16rem; padding-bottom: 16rem; }
+  .ph0-m { padding-left: 0; padding-right: 0; }
+  .ph1-m { padding-left: .25rem; padding-right: .25rem; }
+  .ph2-m { padding-left: .5rem; padding-right: .5rem; }
+  .ph3-m { padding-left: 1rem; padding-right: 1rem; }
+  .ph4-m { padding-left: 2rem; padding-right: 2rem; }
+  .ph5-m { padding-left: 4rem; padding-right: 4rem; }
+  .ph6-m { padding-left: 8rem; padding-right: 8rem; }
+  .ph7-m { padding-left: 16rem; padding-right: 16rem; }
+  .ma0-m { margin: 0; }
+  .ma1-m { margin: .25rem; }
+  .ma2-m { margin: .5rem; }
+  .ma3-m { margin: 1rem; }
+  .ma4-m { margin: 2rem; }
+  .ma5-m { margin: 4rem; }
+  .ma6-m { margin: 8rem; }
+  .ma7-m { margin: 16rem; }
+  .ml0-m { margin-left: 0; }
+  .ml1-m { margin-left: .25rem; }
+  .ml2-m { margin-left: .5rem; }
+  .ml3-m { margin-left: 1rem; }
+  .ml4-m { margin-left: 2rem; }
+  .ml5-m { margin-left: 4rem; }
+  .ml6-m { margin-left: 8rem; }
+  .ml7-m { margin-left: 16rem; }
+  .mr0-m { margin-right: 0; }
+  .mr1-m { margin-right: .25rem; }
+  .mr2-m { margin-right: .5rem; }
+  .mr3-m { margin-right: 1rem; }
+  .mr4-m { margin-right: 2rem; }
+  .mr5-m { margin-right: 4rem; }
+  .mr6-m { margin-right: 8rem; }
+  .mr7-m { margin-right: 16rem; }
+  .mb0-m { margin-bottom: 0; }
+  .mb1-m { margin-bottom: .25rem; }
+  .mb2-m { margin-bottom: .5rem; }
+  .mb3-m { margin-bottom: 1rem; }
+  .mb4-m { margin-bottom: 2rem; }
+  .mb5-m { margin-bottom: 4rem; }
+  .mb6-m { margin-bottom: 8rem; }
+  .mb7-m { margin-bottom: 16rem; }
+  .mt0-m { margin-top: 0; }
+  .mt1-m { margin-top: .25rem; }
+  .mt2-m { margin-top: .5rem; }
+  .mt3-m { margin-top: 1rem; }
+  .mt4-m { margin-top: 2rem; }
+  .mt5-m { margin-top: 4rem; }
+  .mt6-m { margin-top: 8rem; }
+  .mt7-m { margin-top: 16rem; }
+  .mv0-m { margin-top: 0; margin-bottom: 0; }
+  .mv1-m { margin-top: .25rem; margin-bottom: .25rem; }
+  .mv2-m { margin-top: .5rem; margin-bottom: .5rem; }
+  .mv3-m { margin-top: 1rem; margin-bottom: 1rem; }
+  .mv4-m { margin-top: 2rem; margin-bottom: 2rem; }
+  .mv5-m { margin-top: 4rem; margin-bottom: 4rem; }
+  .mv6-m { margin-top: 8rem; margin-bottom: 8rem; }
+  .mv7-m { margin-top: 16rem; margin-bottom: 16rem; }
+  .mh0-m { margin-left: 0; margin-right: 0; }
+  .mh1-m { margin-left: .25rem; margin-right: .25rem; }
+  .mh2-m { margin-left: .5rem; margin-right: .5rem; }
+  .mh3-m { margin-left: 1rem; margin-right: 1rem; }
+  .mh4-m { margin-left: 2rem; margin-right: 2rem; }
+  .mh5-m { margin-left: 4rem; margin-right: 4rem; }
+  .mh6-m { margin-left: 8rem; margin-right: 8rem; }
+  .mh7-m { margin-left: 16rem; margin-right: 16rem; }
+  .na1-m { margin: -0.25rem; }
+  .na2-m { margin: -0.5rem; }
+  .na3-m { margin: -1rem; }
+  .na4-m { margin: -2rem; }
+  .na5-m { margin: -4rem; }
+  .na6-m { margin: -8rem; }
+  .na7-m { margin: -16rem; }
+  .nl1-m { margin-left: -0.25rem; }
+  .nl2-m { margin-left: -0.5rem; }
+  .nl3-m { margin-left: -1rem; }
+  .nl4-m { margin-left: -2rem; }
+  .nl5-m { margin-left: -4rem; }
+  .nl6-m { margin-left: -8rem; }
+  .nl7-m { margin-left: -16rem; }
+  .nr1-m { margin-right: -0.25rem; }
+  .nr2-m { margin-right: -0.5rem; }
+  .nr3-m { margin-right: -1rem; }
+  .nr4-m { margin-right: -2rem; }
+  .nr5-m { margin-right: -4rem; }
+  .nr6-m { margin-right: -8rem; }
+  .nr7-m { margin-right: -16rem; }
+  .nb1-m { margin-bottom: -0.25rem; }
+  .nb2-m { margin-bottom: -0.5rem; }
+  .nb3-m { margin-bottom: -1rem; }
+  .nb4-m { margin-bottom: -2rem; }
+  .nb5-m { margin-bottom: -4rem; }
+  .nb6-m { margin-bottom: -8rem; }
+  .nb7-m { margin-bottom: -16rem; }
+  .nt1-m { margin-top: -0.25rem; }
+  .nt2-m { margin-top: -0.5rem; }
+  .nt3-m { margin-top: -1rem; }
+  .nt4-m { margin-top: -2rem; }
+  .nt5-m { margin-top: -4rem; }
+  .nt6-m { margin-top: -8rem; }
+  .nt7-m { margin-top: -16rem; }
+  .strike-m { text-decoration: line-through; }
+  .underline-m { text-decoration: underline; }
+  .no-underline-m { text-decoration: none; }
+  .tl-m { text-align: left; }
+  .tr-m { text-align: right; }
+  .tc-m { text-align: center; }
+  .tj-m { text-align: justify; }
+  .ttc-m { text-transform: capitalize; }
+  .ttl-m { text-transform: lowercase; }
+  .ttu-m { text-transform: uppercase; }
+  .ttn-m { text-transform: none; }
+  .f-6-m, .f-headline-m { font-size: 6rem; }
+  .f-5-m, .f-subheadline-m { font-size: 5rem; }
+  .f1-m { font-size: 3rem; }
+  .f2-m { font-size: 2.25rem; }
+  .f3-m { font-size: 1.5rem; }
+  .f4-m { font-size: 1.25rem; }
+  .f5-m { font-size: 1rem; }
+  .f6-m { font-size: .875rem; }
+  .f7-m { font-size: .75rem; }
+  .measure-m { max-width: 30em; }
+  .measure-wide-m { max-width: 34em; }
+  .measure-narrow-m { max-width: 20em; }
+  .indent-m { text-indent: 1em; margin-top: 0; margin-bottom: 0; }
+  .small-caps-m { font-variant: small-caps; }
+  .truncate-m { white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+  .center-m { margin-right: auto; margin-left: auto; }
+  .mr-auto-m { margin-right: auto; }
+  .ml-auto-m { margin-left: auto; }
+  .clip-m { position: fixed !important; _position: absolute !important; clip: rect( 1px 1px 1px 1px ); /* IE6, IE7 */ clip: rect( 1px, 1px, 1px, 1px ); }
+  .ws-normal-m { white-space: normal; }
+  .nowrap-m { white-space: nowrap; }
+  .pre-m { white-space: pre; }
+  .v-base-m { vertical-align: baseline; }
+  .v-mid-m { vertical-align: middle; }
+  .v-top-m { vertical-align: top; }
+  .v-btm-m { vertical-align: bottom; }
+ }
+ @media screen and (min-width: 60em) {
+  .aspect-ratio-l { height: 0; position: relative; }
+  .aspect-ratio--16x9-l { padding-bottom: 56.25%; }
+  .aspect-ratio--9x16-l { padding-bottom: 177.77%; }
+  .aspect-ratio--4x3-l { padding-bottom: 75%; }
+  .aspect-ratio--3x4-l { padding-bottom: 133.33%; }
+  .aspect-ratio--6x4-l { padding-bottom: 66.6%; }
+  .aspect-ratio--4x6-l { padding-bottom: 150%; }
+  .aspect-ratio--8x5-l { padding-bottom: 62.5%; }
+  .aspect-ratio--5x8-l { padding-bottom: 160%; }
+  .aspect-ratio--7x5-l { padding-bottom: 71.42%; }
+  .aspect-ratio--5x7-l { padding-bottom: 140%; }
+  .aspect-ratio--1x1-l { padding-bottom: 100%; }
+  .aspect-ratio--object-l { position: absolute; top: 0; right: 0; bottom: 0; left: 0; width: 100%; height: 100%; z-index: 100; }
+  .cover-l { background-size: cover !important; }
+  .contain-l { background-size: contain !important; }
+  .bg-center-l { background-repeat: no-repeat; background-position: center center; }
+  .bg-top-l { background-repeat: no-repeat; background-position: top center; }
+  .bg-right-l { background-repeat: no-repeat; background-position: center right; }
+  .bg-bottom-l { background-repeat: no-repeat; background-position: bottom center; }
+  .bg-left-l { background-repeat: no-repeat; background-position: center left; }
+  .outline-l { outline: 1px solid; }
+  .outline-transparent-l { outline: 1px solid transparent; }
+  .outline-0-l { outline: 0; }
+  .ba-l { border-style: solid; border-width: 1px; }
+  .bt-l { border-top-style: solid; border-top-width: 1px; }
+  .br-l { border-right-style: solid; border-right-width: 1px; }
+  .bb-l { border-bottom-style: solid; border-bottom-width: 1px; }
+  .bl-l { border-left-style: solid; border-left-width: 1px; }
+  .bn-l { border-style: none; border-width: 0; }
+  .br0-l { border-radius: 0; }
+  .br1-l { border-radius: .125rem; }
+  .br2-l { border-radius: .25rem; }
+  .br3-l { border-radius: .5rem; }
+  .br4-l { border-radius: 1rem; }
+  .br-100-l { border-radius: 100%; }
+  .br-pill-l { border-radius: 9999px; }
+  .br--bottom-l { border-top-left-radius: 0; border-top-right-radius: 0; }
+  .br--top-l { border-bottom-left-radius: 0; border-bottom-right-radius: 0; }
+  .br--right-l { border-top-left-radius: 0; border-bottom-left-radius: 0; }
+  .br--left-l { border-top-right-radius: 0; border-bottom-right-radius: 0; }
+  .br-inherit-l { border-radius: inherit; }
+  .br-initial-l { border-radius: initial; }
+  .br-unset-l { border-radius: unset; }
+  .b--dotted-l { border-style: dotted; }
+  .b--dashed-l { border-style: dashed; }
+  .b--solid-l { border-style: solid; }
+  .b--none-l { border-style: none; }
+  .bw0-l { border-width: 0; }
+  .bw1-l { border-width: .125rem; }
+  .bw2-l { border-width: .25rem; }
+  .bw3-l { border-width: .5rem; }
+  .bw4-l { border-width: 1rem; }
+  .bw5-l { border-width: 2rem; }
+  .bt-0-l { border-top-width: 0; }
+  .br-0-l { border-right-width: 0; }
+  .bb-0-l { border-bottom-width: 0; }
+  .bl-0-l { border-left-width: 0; }
+  .shadow-1-l { box-shadow: 0 0 4px 2px rgba( 0, 0, 0, .2 ); }
+  .shadow-2-l { box-shadow: 0 0 8px 2px rgba( 0, 0, 0, .2 ); }
+  .shadow-3-l { box-shadow: 2px 2px 4px 2px rgba( 0, 0, 0, .2 ); }
+  .shadow-4-l { box-shadow: 2px 2px 8px 0 rgba( 0, 0, 0, .2 ); }
+  .shadow-5-l { box-shadow: 4px 4px 8px 0 rgba( 0, 0, 0, .2 ); }
+  .top-0-l { top: 0; }
+  .left-0-l { left: 0; }
+  .right-0-l { right: 0; }
+  .bottom-0-l { bottom: 0; }
+  .top-1-l { top: 1rem; }
+  .left-1-l { left: 1rem; }
+  .right-1-l { right: 1rem; }
+  .bottom-1-l { bottom: 1rem; }
+  .top-2-l { top: 2rem; }
+  .left-2-l { left: 2rem; }
+  .right-2-l { right: 2rem; }
+  .bottom-2-l { bottom: 2rem; }
+  .top--1-l { top: -1rem; }
+  .right--1-l { right: -1rem; }
+  .bottom--1-l { bottom: -1rem; }
+  .left--1-l { left: -1rem; }
+  .top--2-l { top: -2rem; }
+  .right--2-l { right: -2rem; }
+  .bottom--2-l { bottom: -2rem; }
+  .left--2-l { left: -2rem; }
+  .absolute--fill-l { top: 0; right: 0; bottom: 0; left: 0; }
+  .cl-l { clear: left; }
+  .cr-l { clear: right; }
+  .cb-l { clear: both; }
+  .cn-l { clear: none; }
+  .dn-l { display: none; }
+  .di-l { display: inline; }
+  .db-l { display: block; }
+  .dib-l { display: inline-block; }
+  .dit-l { display: inline-table; }
+  .dt-l { display: table; }
+  .dtc-l { display: table-cell; }
+  .dt-row-l { display: table-row; }
+  .dt-row-group-l { display: table-row-group; }
+  .dt-column-l { display: table-column; }
+  .dt-column-group-l { display: table-column-group; }
+  .dt--fixed-l { table-layout: fixed; width: 100%; }
+  .flex-l { display: flex; }
+  .inline-flex-l { display: inline-flex; }
+  .flex-auto-l { flex: 1 1 auto; min-width: 0; /* 1 */ min-height: 0; /* 1 */ }
+  .flex-none-l { flex: none; }
+  .flex-column-l { flex-direction: column; }
+  .flex-row-l { flex-direction: row; }
+  .flex-wrap-l { flex-wrap: wrap; }
+  .flex-nowrap-l { flex-wrap: nowrap; }
+  .flex-wrap-reverse-l { flex-wrap: wrap-reverse; }
+  .flex-column-reverse-l { flex-direction: column-reverse; }
+  .flex-row-reverse-l { flex-direction: row-reverse; }
+  .items-start-l { align-items: flex-start; }
+  .items-end-l { align-items: flex-end; }
+  .items-center-l { align-items: center; }
+  .items-baseline-l { align-items: baseline; }
+  .items-stretch-l { align-items: stretch; }
+  .self-start-l { align-self: flex-start; }
+  .self-end-l { align-self: flex-end; }
+  .self-center-l { align-self: center; }
+  .self-baseline-l { align-self: baseline; }
+  .self-stretch-l { align-self: stretch; }
+  .justify-start-l { justify-content: flex-start; }
+  .justify-end-l { justify-content: flex-end; }
+  .justify-center-l { justify-content: center; }
+  .justify-between-l { justify-content: space-between; }
+  .justify-around-l { justify-content: space-around; }
+  .content-start-l { align-content: flex-start; }
+  .content-end-l { align-content: flex-end; }
+  .content-center-l { align-content: center; }
+  .content-between-l { align-content: space-between; }
+  .content-around-l { align-content: space-around; }
+  .content-stretch-l { align-content: stretch; }
+  .order-0-l { order: 0; }
+  .order-1-l { order: 1; }
+  .order-2-l { order: 2; }
+  .order-3-l { order: 3; }
+  .order-4-l { order: 4; }
+  .order-5-l { order: 5; }
+  .order-6-l { order: 6; }
+  .order-7-l { order: 7; }
+  .order-8-l { order: 8; }
+  .order-last-l { order: 99999; }
+  .flex-grow-0-l { flex-grow: 0; }
+  .flex-grow-1-l { flex-grow: 1; }
+  .flex-shrink-0-l { flex-shrink: 0; }
+  .flex-shrink-1-l { flex-shrink: 1; }
+  .fl-l { float: left; _display: inline; }
+  .fr-l { float: right; _display: inline; }
+  .fn-l { float: none; }
+  .i-l { font-style: italic; }
+  .fs-normal-l { font-style: normal; }
+  .normal-l { font-weight: normal; }
+  .b-l { font-weight: bold; }
+  .fw1-l { font-weight: 100; }
+  .fw2-l { font-weight: 200; }
+  .fw3-l { font-weight: 300; }
+  .fw4-l { font-weight: 400; }
+  .fw5-l { font-weight: 500; }
+  .fw6-l { font-weight: 600; }
+  .fw7-l { font-weight: 700; }
+  .fw8-l { font-weight: 800; }
+  .fw9-l { font-weight: 900; }
+  .h1-l { height: 1rem; }
+  .h2-l { height: 2rem; }
+  .h3-l { height: 4rem; }
+  .h4-l { height: 8rem; }
+  .h5-l { height: 16rem; }
+  .h-25-l { height: 25%; }
+  .h-50-l { height: 50%; }
+  .h-75-l { height: 75%; }
+  .h-100-l { height: 100%; }
+  .min-h-100-l { min-height: 100%; }
+  .vh-25-l { height: 25vh; }
+  .vh-50-l { height: 50vh; }
+  .vh-75-l { height: 75vh; }
+  .vh-100-l { height: 100vh; }
+  .min-vh-100-l { min-height: 100vh; }
+  .h-auto-l { height: auto; }
+  .h-inherit-l { height: inherit; }
+  .tracked-l { letter-spacing: .1em; }
+  .tracked-tight-l { letter-spacing: -.05em; }
+  .tracked-mega-l { letter-spacing: .25em; }
+  .lh-solid-l { line-height: 1; }
+  .lh-title-l { line-height: 1.25; }
+  .lh-copy-l { line-height: 1.5; }
+  .mw-100-l { max-width: 100%; }
+  .mw1-l { max-width: 1rem; }
+  .mw2-l { max-width: 2rem; }
+  .mw3-l { max-width: 4rem; }
+  .mw4-l { max-width: 8rem; }
+  .mw5-l { max-width: 16rem; }
+  .mw6-l { max-width: 32rem; }
+  .mw7-l { max-width: 48rem; }
+  .mw8-l { max-width: 64rem; }
+  .mw9-l { max-width: 96rem; }
+  .mw-none-l { max-width: none; }
+  .w1-l { width: 1rem; }
+  .w2-l { width: 2rem; }
+  .w3-l { width: 4rem; }
+  .w4-l { width: 8rem; }
+  .w5-l { width: 16rem; }
+  .w-10-l { width: 10%; }
+  .w-20-l { width: 20%; }
+  .w-25-l { width: 25%; }
+  .w-30-l { width: 30%; }
+  .w-33-l { width: 33%; }
+  .w-34-l { width: 34%; }
+  .w-40-l { width: 40%; }
+  .w-50-l { width: 50%; }
+  .w-60-l { width: 60%; }
+  .w-70-l { width: 70%; }
+  .w-75-l { width: 75%; }
+  .w-80-l { width: 80%; }
+  .w-90-l { width: 90%; }
+  .w-100-l { width: 100%; }
+  .w-third-l { width: 33.33333%; }
+  .w-two-thirds-l { width: 66.66667%; }
+  .w-auto-l { width: auto; }
+  .overflow-visible-l { overflow: visible; }
+  .overflow-hidden-l { overflow: hidden; }
+  .overflow-scroll-l { overflow: scroll; }
+  .overflow-auto-l { overflow: auto; }
+  .overflow-x-visible-l { overflow-x: visible; }
+  .overflow-x-hidden-l { overflow-x: hidden; }
+  .overflow-x-scroll-l { overflow-x: scroll; }
+  .overflow-x-auto-l { overflow-x: auto; }
+  .overflow-y-visible-l { overflow-y: visible; }
+  .overflow-y-hidden-l { overflow-y: hidden; }
+  .overflow-y-scroll-l { overflow-y: scroll; }
+  .overflow-y-auto-l { overflow-y: auto; }
+  .static-l { position: static; }
+  .relative-l { position: relative; }
+  .absolute-l { position: absolute; }
+  .fixed-l { position: fixed; }
+  .rotate-45-l { -webkit-transform: rotate( 45deg ); transform: rotate( 45deg ); }
+  .rotate-90-l { -webkit-transform: rotate( 90deg ); transform: rotate( 90deg ); }
+  .rotate-135-l { -webkit-transform: rotate( 135deg ); transform: rotate( 135deg ); }
+  .rotate-180-l { -webkit-transform: rotate( 180deg ); transform: rotate( 180deg ); }
+  .rotate-225-l { -webkit-transform: rotate( 225deg ); transform: rotate( 225deg ); }
+  .rotate-270-l { -webkit-transform: rotate( 270deg ); transform: rotate( 270deg ); }
+  .rotate-315-l { -webkit-transform: rotate( 315deg ); transform: rotate( 315deg ); }
+  .pa0-l { padding: 0; }
+  .pa1-l { padding: .25rem; }
+  .pa2-l { padding: .5rem; }
+  .pa3-l { padding: 1rem; }
+  .pa4-l { padding: 2rem; }
+  .pa5-l { padding: 4rem; }
+  .pa6-l { padding: 8rem; }
+  .pa7-l { padding: 16rem; }
+  .pl0-l { padding-left: 0; }
+  .pl1-l { padding-left: .25rem; }
+  .pl2-l { padding-left: .5rem; }
+  .pl3-l { padding-left: 1rem; }
+  .pl4-l { padding-left: 2rem; }
+  .pl5-l { padding-left: 4rem; }
+  .pl6-l { padding-left: 8rem; }
+  .pl7-l { padding-left: 16rem; }
+  .pr0-l { padding-right: 0; }
+  .pr1-l { padding-right: .25rem; }
+  .pr2-l { padding-right: .5rem; }
+  .pr3-l { padding-right: 1rem; }
+  .pr4-l { padding-right: 2rem; }
+  .pr5-l { padding-right: 4rem; }
+  .pr6-l { padding-right: 8rem; }
+  .pr7-l { padding-right: 16rem; }
+  .pb0-l { padding-bottom: 0; }
+  .pb1-l { padding-bottom: .25rem; }
+  .pb2-l { padding-bottom: .5rem; }
+  .pb3-l { padding-bottom: 1rem; }
+  .pb4-l { padding-bottom: 2rem; }
+  .pb5-l { padding-bottom: 4rem; }
+  .pb6-l { padding-bottom: 8rem; }
+  .pb7-l { padding-bottom: 16rem; }
+  .pt0-l { padding-top: 0; }
+  .pt1-l { padding-top: .25rem; }
+  .pt2-l { padding-top: .5rem; }
+  .pt3-l { padding-top: 1rem; }
+  .pt4-l { padding-top: 2rem; }
+  .pt5-l { padding-top: 4rem; }
+  .pt6-l { padding-top: 8rem; }
+  .pt7-l { padding-top: 16rem; }
+  .pv0-l { padding-top: 0; padding-bottom: 0; }
+  .pv1-l { padding-top: .25rem; padding-bottom: .25rem; }
+  .pv2-l { padding-top: .5rem; padding-bottom: .5rem; }
+  .pv3-l { padding-top: 1rem; padding-bottom: 1rem; }
+  .pv4-l { padding-top: 2rem; padding-bottom: 2rem; }
+  .pv5-l { padding-top: 4rem; padding-bottom: 4rem; }
+  .pv6-l { padding-top: 8rem; padding-bottom: 8rem; }
+  .pv7-l { padding-top: 16rem; padding-bottom: 16rem; }
+  .ph0-l { padding-left: 0; padding-right: 0; }
+  .ph1-l { padding-left: .25rem; padding-right: .25rem; }
+  .ph2-l { padding-left: .5rem; padding-right: .5rem; }
+  .ph3-l { padding-left: 1rem; padding-right: 1rem; }
+  .ph4-l { padding-left: 2rem; padding-right: 2rem; }
+  .ph5-l { padding-left: 4rem; padding-right: 4rem; }
+  .ph6-l { padding-left: 8rem; padding-right: 8rem; }
+  .ph7-l { padding-left: 16rem; padding-right: 16rem; }
+  .ma0-l { margin: 0; }
+  .ma1-l { margin: .25rem; }
+  .ma2-l { margin: .5rem; }
+  .ma3-l { margin: 1rem; }
+  .ma4-l { margin: 2rem; }
+  .ma5-l { margin: 4rem; }
+  .ma6-l { margin: 8rem; }
+  .ma7-l { margin: 16rem; }
+  .ml0-l { margin-left: 0; }
+  .ml1-l { margin-left: .25rem; }
+  .ml2-l { margin-left: .5rem; }
+  .ml3-l { margin-left: 1rem; }
+  .ml4-l { margin-left: 2rem; }
+  .ml5-l { margin-left: 4rem; }
+  .ml6-l { margin-left: 8rem; }
+  .ml7-l { margin-left: 16rem; }
+  .mr0-l { margin-right: 0; }
+  .mr1-l { margin-right: .25rem; }
+  .mr2-l { margin-right: .5rem; }
+  .mr3-l { margin-right: 1rem; }
+  .mr4-l { margin-right: 2rem; }
+  .mr5-l { margin-right: 4rem; }
+  .mr6-l { margin-right: 8rem; }
+  .mr7-l { margin-right: 16rem; }
+  .mb0-l { margin-bottom: 0; }
+  .mb1-l { margin-bottom: .25rem; }
+  .mb2-l { margin-bottom: .5rem; }
+  .mb3-l { margin-bottom: 1rem; }
+  .mb4-l { margin-bottom: 2rem; }
+  .mb5-l { margin-bottom: 4rem; }
+  .mb6-l { margin-bottom: 8rem; }
+  .mb7-l { margin-bottom: 16rem; }
+  .mt0-l { margin-top: 0; }
+  .mt1-l { margin-top: .25rem; }
+  .mt2-l { margin-top: .5rem; }
+  .mt3-l { margin-top: 1rem; }
+  .mt4-l { margin-top: 2rem; }
+  .mt5-l { margin-top: 4rem; }
+  .mt6-l { margin-top: 8rem; }
+  .mt7-l { margin-top: 16rem; }
+  .mv0-l { margin-top: 0; margin-bottom: 0; }
+  .mv1-l { margin-top: .25rem; margin-bottom: .25rem; }
+  .mv2-l { margin-top: .5rem; margin-bottom: .5rem; }
+  .mv3-l { margin-top: 1rem; margin-bottom: 1rem; }
+  .mv4-l { margin-top: 2rem; margin-bottom: 2rem; }
+  .mv5-l { margin-top: 4rem; margin-bottom: 4rem; }
+  .mv6-l { margin-top: 8rem; margin-bottom: 8rem; }
+  .mv7-l { margin-top: 16rem; margin-bottom: 16rem; }
+  .mh0-l { margin-left: 0; margin-right: 0; }
+  .mh1-l { margin-left: .25rem; margin-right: .25rem; }
+  .mh2-l { margin-left: .5rem; margin-right: .5rem; }
+  .mh3-l { margin-left: 1rem; margin-right: 1rem; }
+  .mh4-l { margin-left: 2rem; margin-right: 2rem; }
+  .mh5-l { margin-left: 4rem; margin-right: 4rem; }
+  .mh6-l { margin-left: 8rem; margin-right: 8rem; }
+  .mh7-l { margin-left: 16rem; margin-right: 16rem; }
+  .na1-l { margin: -0.25rem; }
+  .na2-l { margin: -0.5rem; }
+  .na3-l { margin: -1rem; }
+  .na4-l { margin: -2rem; }
+  .na5-l { margin: -4rem; }
+  .na6-l { margin: -8rem; }
+  .na7-l { margin: -16rem; }
+  .nl1-l { margin-left: -0.25rem; }
+  .nl2-l { margin-left: -0.5rem; }
+  .nl3-l { margin-left: -1rem; }
+  .nl4-l { margin-left: -2rem; }
+  .nl5-l { margin-left: -4rem; }
+  .nl6-l { margin-left: -8rem; }
+  .nl7-l { margin-left: -16rem; }
+  .nr1-l { margin-right: -0.25rem; }
+  .nr2-l { margin-right: -0.5rem; }
+  .nr3-l { margin-right: -1rem; }
+  .nr4-l { margin-right: -2rem; }
+  .nr5-l { margin-right: -4rem; }
+  .nr6-l { margin-right: -8rem; }
+  .nr7-l { margin-right: -16rem; }
+  .nb1-l { margin-bottom: -0.25rem; }
+  .nb2-l { margin-bottom: -0.5rem; }
+  .nb3-l { margin-bottom: -1rem; }
+  .nb4-l { margin-bottom: -2rem; }
+  .nb5-l { margin-bottom: -4rem; }
+  .nb6-l { margin-bottom: -8rem; }
+  .nb7-l { margin-bottom: -16rem; }
+  .nt1-l { margin-top: -0.25rem; }
+  .nt2-l { margin-top: -0.5rem; }
+  .nt3-l { margin-top: -1rem; }
+  .nt4-l { margin-top: -2rem; }
+  .nt5-l { margin-top: -4rem; }
+  .nt6-l { margin-top: -8rem; }
+  .nt7-l { margin-top: -16rem; }
+  .strike-l { text-decoration: line-through; }
+  .underline-l { text-decoration: underline; }
+  .no-underline-l { text-decoration: none; }
+  .tl-l { text-align: left; }
+  .tr-l { text-align: right; }
+  .tc-l { text-align: center; }
+  .tj-l { text-align: justify; }
+  .ttc-l { text-transform: capitalize; }
+  .ttl-l { text-transform: lowercase; }
+  .ttu-l { text-transform: uppercase; }
+  .ttn-l { text-transform: none; }
+  .f-6-l, .f-headline-l { font-size: 6rem; }
+  .f-5-l, .f-subheadline-l { font-size: 5rem; }
+  .f1-l { font-size: 3rem; }
+  .f2-l { font-size: 2.25rem; }
+  .f3-l { font-size: 1.5rem; }
+  .f4-l { font-size: 1.25rem; }
+  .f5-l { font-size: 1rem; }
+  .f6-l { font-size: .875rem; }
+  .f7-l { font-size: .75rem; }
+  .measure-l { max-width: 30em; }
+  .measure-wide-l { max-width: 34em; }
+  .measure-narrow-l { max-width: 20em; }
+  .indent-l { text-indent: 1em; margin-top: 0; margin-bottom: 0; }
+  .small-caps-l { font-variant: small-caps; }
+  .truncate-l { white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+  .center-l { margin-right: auto; margin-left: auto; }
+  .mr-auto-l { margin-right: auto; }
+  .ml-auto-l { margin-left: auto; }
+  .clip-l { position: fixed !important; _position: absolute !important; clip: rect( 1px 1px 1px 1px ); /* IE6, IE7 */ clip: rect( 1px, 1px, 1px, 1px ); }
+  .ws-normal-l { white-space: normal; }
+  .nowrap-l { white-space: nowrap; }
+  .pre-l { white-space: pre; }
+  .v-base-l { vertical-align: baseline; }
+  .v-mid-l { vertical-align: middle; }
+  .v-top-l { vertical-align: top; }
+  .v-btm-l { vertical-align: bottom; }
+ }
+ 
\ No newline at end of file
diff --git a/test/js/bun/css/files/tailwind.css b/test/js/bun/css/files/tailwind.css
new file mode 100644
index 0000000000..ad3f035cf4
--- /dev/null
+++ b/test/js/bun/css/files/tailwind.css
@@ -0,0 +1,2 @@
+/*! normalize.css v8.0.1 | MIT License | github.com/necolas/normalize.css */
+html{-webkit-text-size-adjust:100%;line-height:1.15}body{margin:0}main{display:block}h1{margin:.67em 0;font-size:2em}hr{box-sizing:content-box;height:0;overflow:visible}pre{font-family:monospace;font-size:1em}a{background-color:#0000}abbr[title]{text-decoration:underline;border-bottom:none;text-decoration:underline dotted}b,strong{font-weight:bolder}code,kbd,samp{font-family:monospace;font-size:1em}small{font-size:80%}sub,sup{vertical-align:baseline;font-size:75%;line-height:0;position:relative}sub{bottom:-.25em}sup{top:-.5em}button,input,optgroup,select,textarea{margin:0;font-family:inherit;font-size:100%;line-height:1.15}button,input{overflow:visible}button,select{text-transform:none}button,[type=button],[type=reset],[type=submit]{-webkit-appearance:button}button::-moz-focus-inner,[type=button]::-moz-focus-inner,[type=reset]::-moz-focus-inner,[type=submit]::-moz-focus-inner{border-style:none;padding:0}button:-moz-focusring,[type=button]:-moz-focusring,[type=reset]:-moz-focusring,[type=submit]:-moz-focusring{outline:1px dotted buttontext}fieldset{padding:.35em .75em .625em}legend{box-sizing:border-box;color:inherit;white-space:normal;max-width:100%;padding:0;display:table}progress{vertical-align:baseline}textarea{overflow:auto}[type=checkbox],[type=radio]{box-sizing:border-box;padding:0}[type=number]::-webkit-inner-spin-button,[type=number]::-webkit-outer-spin-button{height:auto}[type=search]{-webkit-appearance:textfield;outline-offset:-2px}[type=search]::-webkit-search-decoration{-webkit-appearance:none}::-webkit-file-upload-button{-webkit-appearance:button;font:inherit}details{display:block}summary{display:list-item}template,[hidden]{display:none}blockquote,dl,dd,h1,h2,h3,h4,h5,h6,hr,figure,p,pre{margin:0}button{background-color:#0000;background-image:none}button:focus{outline:1px dotted;outline:5px auto -webkit-focus-ring-color}fieldset{margin:0;padding:0}ol,ul{margin:0;padding:0;list-style:none}html{font-family:system-ui,-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Helvetica Neue,Arial,Noto Sans,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol,Noto Color Emoji;line-height:1.5}*,:before,:after{box-sizing:border-box;border:0 solid #e2e8f0}hr{border-top-width:1px}img{border-style:solid}textarea{resize:vertical}input:-ms-input-placeholder,textarea:-ms-input-placeholder{color:#a0aec0}input::-moz-placeholder,textarea::-moz-placeholder{color:#a0aec0}input::placeholder,textarea::placeholder{color:#a0aec0}button,[role=button]{cursor:pointer}table{border-collapse:collapse}h1,h2,h3,h4,h5,h6{font-size:inherit;font-weight:inherit}a{color:inherit;text-decoration:inherit}button,input,optgroup,select,textarea{line-height:inherit;color:inherit;padding:0}pre,code,kbd,samp{font-family:Menlo,Monaco,Consolas,Liberation Mono,Courier New,monospace}img,svg,video,canvas,audio,iframe,embed,object{vertical-align:middle;display:block}img,video{max-width:100%;height:auto}.container{width:100%}@media (width>=640px){.container{max-width:640px}}@media (width>=768px){.container{max-width:768px}}@media (width>=1024px){.container{max-width:1024px}}@media (width>=1280px){.container{max-width:1280px}}.space-y-0>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(0px*calc(1 - var(--space-y-reverse)));margin-bottom:calc(0px*var(--space-y-reverse))}.space-x-0>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(0px*var(--space-x-reverse));margin-left:calc(0px*calc(1 - var(--space-x-reverse)))}.space-y-1>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(.25rem*calc(1 - var(--space-y-reverse)));margin-bottom:calc(.25rem*var(--space-y-reverse))}.space-x-1>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(.25rem*var(--space-x-reverse));margin-left:calc(.25rem*calc(1 - var(--space-x-reverse)))}.space-y-2>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(.5rem*calc(1 - var(--space-y-reverse)));margin-bottom:calc(.5rem*var(--space-y-reverse))}.space-x-2>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(.5rem*var(--space-x-reverse));margin-left:calc(.5rem*calc(1 - var(--space-x-reverse)))}.space-y-3>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(.75rem*calc(1 - var(--space-y-reverse)));margin-bottom:calc(.75rem*var(--space-y-reverse))}.space-x-3>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(.75rem*var(--space-x-reverse));margin-left:calc(.75rem*calc(1 - var(--space-x-reverse)))}.space-y-4>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(1rem*calc(1 - var(--space-y-reverse)));margin-bottom:calc(1rem*var(--space-y-reverse))}.space-x-4>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(1rem*var(--space-x-reverse));margin-left:calc(1rem*calc(1 - var(--space-x-reverse)))}.space-y-5>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(1.25rem*calc(1 - var(--space-y-reverse)));margin-bottom:calc(1.25rem*var(--space-y-reverse))}.space-x-5>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(1.25rem*var(--space-x-reverse));margin-left:calc(1.25rem*calc(1 - var(--space-x-reverse)))}.space-y-6>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(1.5rem*calc(1 - var(--space-y-reverse)));margin-bottom:calc(1.5rem*var(--space-y-reverse))}.space-x-6>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(1.5rem*var(--space-x-reverse));margin-left:calc(1.5rem*calc(1 - var(--space-x-reverse)))}.space-y-8>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(2rem*calc(1 - var(--space-y-reverse)));margin-bottom:calc(2rem*var(--space-y-reverse))}.space-x-8>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(2rem*var(--space-x-reverse));margin-left:calc(2rem*calc(1 - var(--space-x-reverse)))}.space-y-10>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(2.5rem*calc(1 - var(--space-y-reverse)));margin-bottom:calc(2.5rem*var(--space-y-reverse))}.space-x-10>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(2.5rem*var(--space-x-reverse));margin-left:calc(2.5rem*calc(1 - var(--space-x-reverse)))}.space-y-12>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(3rem*calc(1 - var(--space-y-reverse)));margin-bottom:calc(3rem*var(--space-y-reverse))}.space-x-12>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(3rem*var(--space-x-reverse));margin-left:calc(3rem*calc(1 - var(--space-x-reverse)))}.space-y-16>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(4rem*calc(1 - var(--space-y-reverse)));margin-bottom:calc(4rem*var(--space-y-reverse))}.space-x-16>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(4rem*var(--space-x-reverse));margin-left:calc(4rem*calc(1 - var(--space-x-reverse)))}.space-y-20>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(5rem*calc(1 - var(--space-y-reverse)));margin-bottom:calc(5rem*var(--space-y-reverse))}.space-x-20>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(5rem*var(--space-x-reverse));margin-left:calc(5rem*calc(1 - var(--space-x-reverse)))}.space-y-24>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(6rem*calc(1 - var(--space-y-reverse)));margin-bottom:calc(6rem*var(--space-y-reverse))}.space-x-24>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(6rem*var(--space-x-reverse));margin-left:calc(6rem*calc(1 - var(--space-x-reverse)))}.space-y-32>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(8rem*calc(1 - var(--space-y-reverse)));margin-bottom:calc(8rem*var(--space-y-reverse))}.space-x-32>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(8rem*var(--space-x-reverse));margin-left:calc(8rem*calc(1 - var(--space-x-reverse)))}.space-y-40>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(10rem*calc(1 - var(--space-y-reverse)));margin-bottom:calc(10rem*var(--space-y-reverse))}.space-x-40>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(10rem*var(--space-x-reverse));margin-left:calc(10rem*calc(1 - var(--space-x-reverse)))}.space-y-48>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(12rem*calc(1 - var(--space-y-reverse)));margin-bottom:calc(12rem*var(--space-y-reverse))}.space-x-48>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(12rem*var(--space-x-reverse));margin-left:calc(12rem*calc(1 - var(--space-x-reverse)))}.space-y-56>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(14rem*calc(1 - var(--space-y-reverse)));margin-bottom:calc(14rem*var(--space-y-reverse))}.space-x-56>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(14rem*var(--space-x-reverse));margin-left:calc(14rem*calc(1 - var(--space-x-reverse)))}.space-y-64>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(16rem*calc(1 - var(--space-y-reverse)));margin-bottom:calc(16rem*var(--space-y-reverse))}.space-x-64>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(16rem*var(--space-x-reverse));margin-left:calc(16rem*calc(1 - var(--space-x-reverse)))}.space-y-px>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(1px*calc(1 - var(--space-y-reverse)));margin-bottom:calc(1px*var(--space-y-reverse))}.space-x-px>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(1px*var(--space-x-reverse));margin-left:calc(1px*calc(1 - var(--space-x-reverse)))}.-space-y-1>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(-.25rem*calc(1 - var(--space-y-reverse)));margin-bottom:calc(-.25rem*var(--space-y-reverse))}.-space-x-1>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(-.25rem*var(--space-x-reverse));margin-left:calc(-.25rem*calc(1 - var(--space-x-reverse)))}.-space-y-2>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(-.5rem*calc(1 - var(--space-y-reverse)));margin-bottom:calc(-.5rem*var(--space-y-reverse))}.-space-x-2>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(-.5rem*var(--space-x-reverse));margin-left:calc(-.5rem*calc(1 - var(--space-x-reverse)))}.-space-y-3>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(-.75rem*calc(1 - var(--space-y-reverse)));margin-bottom:calc(-.75rem*var(--space-y-reverse))}.-space-x-3>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(-.75rem*var(--space-x-reverse));margin-left:calc(-.75rem*calc(1 - var(--space-x-reverse)))}.-space-y-4>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(-1rem*calc(1 - var(--space-y-reverse)));margin-bottom:calc(-1rem*var(--space-y-reverse))}.-space-x-4>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(-1rem*var(--space-x-reverse));margin-left:calc(-1rem*calc(1 - var(--space-x-reverse)))}.-space-y-5>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(-1.25rem*calc(1 - var(--space-y-reverse)));margin-bottom:calc(-1.25rem*var(--space-y-reverse))}.-space-x-5>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(-1.25rem*var(--space-x-reverse));margin-left:calc(-1.25rem*calc(1 - var(--space-x-reverse)))}.-space-y-6>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(-1.5rem*calc(1 - var(--space-y-reverse)));margin-bottom:calc(-1.5rem*var(--space-y-reverse))}.-space-x-6>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(-1.5rem*var(--space-x-reverse));margin-left:calc(-1.5rem*calc(1 - var(--space-x-reverse)))}.-space-y-8>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(-2rem*calc(1 - var(--space-y-reverse)));margin-bottom:calc(-2rem*var(--space-y-reverse))}.-space-x-8>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(-2rem*var(--space-x-reverse));margin-left:calc(-2rem*calc(1 - var(--space-x-reverse)))}.-space-y-10>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(-2.5rem*calc(1 - var(--space-y-reverse)));margin-bottom:calc(-2.5rem*var(--space-y-reverse))}.-space-x-10>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(-2.5rem*var(--space-x-reverse));margin-left:calc(-2.5rem*calc(1 - var(--space-x-reverse)))}.-space-y-12>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(-3rem*calc(1 - var(--space-y-reverse)));margin-bottom:calc(-3rem*var(--space-y-reverse))}.-space-x-12>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(-3rem*var(--space-x-reverse));margin-left:calc(-3rem*calc(1 - var(--space-x-reverse)))}.-space-y-16>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(-4rem*calc(1 - var(--space-y-reverse)));margin-bottom:calc(-4rem*var(--space-y-reverse))}.-space-x-16>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(-4rem*var(--space-x-reverse));margin-left:calc(-4rem*calc(1 - var(--space-x-reverse)))}.-space-y-20>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(-5rem*calc(1 - var(--space-y-reverse)));margin-bottom:calc(-5rem*var(--space-y-reverse))}.-space-x-20>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(-5rem*var(--space-x-reverse));margin-left:calc(-5rem*calc(1 - var(--space-x-reverse)))}.-space-y-24>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(-6rem*calc(1 - var(--space-y-reverse)));margin-bottom:calc(-6rem*var(--space-y-reverse))}.-space-x-24>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(-6rem*var(--space-x-reverse));margin-left:calc(-6rem*calc(1 - var(--space-x-reverse)))}.-space-y-32>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(-8rem*calc(1 - var(--space-y-reverse)));margin-bottom:calc(-8rem*var(--space-y-reverse))}.-space-x-32>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(-8rem*var(--space-x-reverse));margin-left:calc(-8rem*calc(1 - var(--space-x-reverse)))}.-space-y-40>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(-10rem*calc(1 - var(--space-y-reverse)));margin-bottom:calc(-10rem*var(--space-y-reverse))}.-space-x-40>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(-10rem*var(--space-x-reverse));margin-left:calc(-10rem*calc(1 - var(--space-x-reverse)))}.-space-y-48>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(-12rem*calc(1 - var(--space-y-reverse)));margin-bottom:calc(-12rem*var(--space-y-reverse))}.-space-x-48>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(-12rem*var(--space-x-reverse));margin-left:calc(-12rem*calc(1 - var(--space-x-reverse)))}.-space-y-56>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(-14rem*calc(1 - var(--space-y-reverse)));margin-bottom:calc(-14rem*var(--space-y-reverse))}.-space-x-56>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(-14rem*var(--space-x-reverse));margin-left:calc(-14rem*calc(1 - var(--space-x-reverse)))}.-space-y-64>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(-16rem*calc(1 - var(--space-y-reverse)));margin-bottom:calc(-16rem*var(--space-y-reverse))}.-space-x-64>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(-16rem*var(--space-x-reverse));margin-left:calc(-16rem*calc(1 - var(--space-x-reverse)))}.-space-y-px>:not(template)~:not(template){--space-y-reverse:0;margin-top:calc(-1px*calc(1 - var(--space-y-reverse)));margin-bottom:calc(-1px*var(--space-y-reverse))}.-space-x-px>:not(template)~:not(template){--space-x-reverse:0;margin-right:calc(-1px*var(--space-x-reverse));margin-left:calc(-1px*calc(1 - var(--space-x-reverse)))}.space-y-reverse>:not(template)~:not(template){--space-y-reverse:1}.space-x-reverse>:not(template)~:not(template){--space-x-reverse:1}.divide-y-0>:not(template)~:not(template){--divide-y-reverse:0;border-top-width:calc(0px*calc(1 - var(--divide-y-reverse)));border-bottom-width:calc(0px*var(--divide-y-reverse))}.divide-x-0>:not(template)~:not(template){--divide-x-reverse:0;border-right-width:calc(0px*var(--divide-x-reverse));border-left-width:calc(0px*calc(1 - var(--divide-x-reverse)))}.divide-y-2>:not(template)~:not(template){--divide-y-reverse:0;border-top-width:calc(2px*calc(1 - var(--divide-y-reverse)));border-bottom-width:calc(2px*var(--divide-y-reverse))}.divide-x-2>:not(template)~:not(template){--divide-x-reverse:0;border-right-width:calc(2px*var(--divide-x-reverse));border-left-width:calc(2px*calc(1 - var(--divide-x-reverse)))}.divide-y-4>:not(template)~:not(template){--divide-y-reverse:0;border-top-width:calc(4px*calc(1 - var(--divide-y-reverse)));border-bottom-width:calc(4px*var(--divide-y-reverse))}.divide-x-4>:not(template)~:not(template){--divide-x-reverse:0;border-right-width:calc(4px*var(--divide-x-reverse));border-left-width:calc(4px*calc(1 - var(--divide-x-reverse)))}.divide-y-8>:not(template)~:not(template){--divide-y-reverse:0;border-top-width:calc(8px*calc(1 - var(--divide-y-reverse)));border-bottom-width:calc(8px*var(--divide-y-reverse))}.divide-x-8>:not(template)~:not(template){--divide-x-reverse:0;border-right-width:calc(8px*var(--divide-x-reverse));border-left-width:calc(8px*calc(1 - var(--divide-x-reverse)))}.divide-y>:not(template)~:not(template){--divide-y-reverse:0;border-top-width:calc(1px*calc(1 - var(--divide-y-reverse)));border-bottom-width:calc(1px*var(--divide-y-reverse))}.divide-x>:not(template)~:not(template){--divide-x-reverse:0;border-right-width:calc(1px*var(--divide-x-reverse));border-left-width:calc(1px*calc(1 - var(--divide-x-reverse)))}.divide-y-reverse>:not(template)~:not(template){--divide-y-reverse:1}.divide-x-reverse>:not(template)~:not(template){--divide-x-reverse:1}.divide-transparent>:not(template)~:not(template){border-color:#0000}.divide-current>:not(template)~:not(template){border-color:currentColor}.divide-black>:not(template)~:not(template){--divide-opacity:1;border-color:#000;border-color:rgba(0,0,0,var(--divide-opacity))}.divide-white>:not(template)~:not(template){--divide-opacity:1;border-color:#fff;border-color:rgba(255,255,255,var(--divide-opacity))}.divide-gray-100>:not(template)~:not(template){--divide-opacity:1;border-color:#f7fafc;border-color:rgba(247,250,252,var(--divide-opacity))}.divide-gray-200>:not(template)~:not(template){--divide-opacity:1;border-color:#edf2f7;border-color:rgba(237,242,247,var(--divide-opacity))}.divide-gray-300>:not(template)~:not(template){--divide-opacity:1;border-color:#e2e8f0;border-color:rgba(226,232,240,var(--divide-opacity))}.divide-gray-400>:not(template)~:not(template){--divide-opacity:1;border-color:#cbd5e0;border-color:rgba(203,213,224,var(--divide-opacity))}.divide-gray-500>:not(template)~:not(template){--divide-opacity:1;border-color:#a0aec0;border-color:rgba(160,174,192,var(--divide-opacity))}.divide-gray-600>:not(template)~:not(template){--divide-opacity:1;border-color:#718096;border-color:rgba(113,128,150,var(--divide-opacity))}.divide-gray-700>:not(template)~:not(template){--divide-opacity:1;border-color:#4a5568;border-color:rgba(74,85,104,var(--divide-opacity))}.divide-gray-800>:not(template)~:not(template){--divide-opacity:1;border-color:#2d3748;border-color:rgba(45,55,72,var(--divide-opacity))}.divide-gray-900>:not(template)~:not(template){--divide-opacity:1;border-color:#1a202c;border-color:rgba(26,32,44,var(--divide-opacity))}.divide-red-100>:not(template)~:not(template){--divide-opacity:1;border-color:#fff5f5;border-color:rgba(255,245,245,var(--divide-opacity))}.divide-red-200>:not(template)~:not(template){--divide-opacity:1;border-color:#fed7d7;border-color:rgba(254,215,215,var(--divide-opacity))}.divide-red-300>:not(template)~:not(template){--divide-opacity:1;border-color:#feb2b2;border-color:rgba(254,178,178,var(--divide-opacity))}.divide-red-400>:not(template)~:not(template){--divide-opacity:1;border-color:#fc8181;border-color:rgba(252,129,129,var(--divide-opacity))}.divide-red-500>:not(template)~:not(template){--divide-opacity:1;border-color:#f56565;border-color:rgba(245,101,101,var(--divide-opacity))}.divide-red-600>:not(template)~:not(template){--divide-opacity:1;border-color:#e53e3e;border-color:rgba(229,62,62,var(--divide-opacity))}.divide-red-700>:not(template)~:not(template){--divide-opacity:1;border-color:#c53030;border-color:rgba(197,48,48,var(--divide-opacity))}.divide-red-800>:not(template)~:not(template){--divide-opacity:1;border-color:#9b2c2c;border-color:rgba(155,44,44,var(--divide-opacity))}.divide-red-900>:not(template)~:not(template){--divide-opacity:1;border-color:#742a2a;border-color:rgba(116,42,42,var(--divide-opacity))}.divide-orange-100>:not(template)~:not(template){--divide-opacity:1;border-color:#fffaf0;border-color:rgba(255,250,240,var(--divide-opacity))}.divide-orange-200>:not(template)~:not(template){--divide-opacity:1;border-color:#feebc8;border-color:rgba(254,235,200,var(--divide-opacity))}.divide-orange-300>:not(template)~:not(template){--divide-opacity:1;border-color:#fbd38d;border-color:rgba(251,211,141,var(--divide-opacity))}.divide-orange-400>:not(template)~:not(template){--divide-opacity:1;border-color:#f6ad55;border-color:rgba(246,173,85,var(--divide-opacity))}.divide-orange-500>:not(template)~:not(template){--divide-opacity:1;border-color:#ed8936;border-color:rgba(237,137,54,var(--divide-opacity))}.divide-orange-600>:not(template)~:not(template){--divide-opacity:1;border-color:#dd6b20;border-color:rgba(221,107,32,var(--divide-opacity))}.divide-orange-700>:not(template)~:not(template){--divide-opacity:1;border-color:#c05621;border-color:rgba(192,86,33,var(--divide-opacity))}.divide-orange-800>:not(template)~:not(template){--divide-opacity:1;border-color:#9c4221;border-color:rgba(156,66,33,var(--divide-opacity))}.divide-orange-900>:not(template)~:not(template){--divide-opacity:1;border-color:#7b341e;border-color:rgba(123,52,30,var(--divide-opacity))}.divide-yellow-100>:not(template)~:not(template){--divide-opacity:1;border-color:ivory;border-color:rgba(255,255,240,var(--divide-opacity))}.divide-yellow-200>:not(template)~:not(template){--divide-opacity:1;border-color:#fefcbf;border-color:rgba(254,252,191,var(--divide-opacity))}.divide-yellow-300>:not(template)~:not(template){--divide-opacity:1;border-color:#faf089;border-color:rgba(250,240,137,var(--divide-opacity))}.divide-yellow-400>:not(template)~:not(template){--divide-opacity:1;border-color:#f6e05e;border-color:rgba(246,224,94,var(--divide-opacity))}.divide-yellow-500>:not(template)~:not(template){--divide-opacity:1;border-color:#ecc94b;border-color:rgba(236,201,75,var(--divide-opacity))}.divide-yellow-600>:not(template)~:not(template){--divide-opacity:1;border-color:#d69e2e;border-color:rgba(214,158,46,var(--divide-opacity))}.divide-yellow-700>:not(template)~:not(template){--divide-opacity:1;border-color:#b7791f;border-color:rgba(183,121,31,var(--divide-opacity))}.divide-yellow-800>:not(template)~:not(template){--divide-opacity:1;border-color:#975a16;border-color:rgba(151,90,22,var(--divide-opacity))}.divide-yellow-900>:not(template)~:not(template){--divide-opacity:1;border-color:#744210;border-color:rgba(116,66,16,var(--divide-opacity))}.divide-green-100>:not(template)~:not(template){--divide-opacity:1;border-color:#f0fff4;border-color:rgba(240,255,244,var(--divide-opacity))}.divide-green-200>:not(template)~:not(template){--divide-opacity:1;border-color:#c6f6d5;border-color:rgba(198,246,213,var(--divide-opacity))}.divide-green-300>:not(template)~:not(template){--divide-opacity:1;border-color:#9ae6b4;border-color:rgba(154,230,180,var(--divide-opacity))}.divide-green-400>:not(template)~:not(template){--divide-opacity:1;border-color:#68d391;border-color:rgba(104,211,145,var(--divide-opacity))}.divide-green-500>:not(template)~:not(template){--divide-opacity:1;border-color:#48bb78;border-color:rgba(72,187,120,var(--divide-opacity))}.divide-green-600>:not(template)~:not(template){--divide-opacity:1;border-color:#38a169;border-color:rgba(56,161,105,var(--divide-opacity))}.divide-green-700>:not(template)~:not(template){--divide-opacity:1;border-color:#2f855a;border-color:rgba(47,133,90,var(--divide-opacity))}.divide-green-800>:not(template)~:not(template){--divide-opacity:1;border-color:#276749;border-color:rgba(39,103,73,var(--divide-opacity))}.divide-green-900>:not(template)~:not(template){--divide-opacity:1;border-color:#22543d;border-color:rgba(34,84,61,var(--divide-opacity))}.divide-teal-100>:not(template)~:not(template){--divide-opacity:1;border-color:#e6fffa;border-color:rgba(230,255,250,var(--divide-opacity))}.divide-teal-200>:not(template)~:not(template){--divide-opacity:1;border-color:#b2f5ea;border-color:rgba(178,245,234,var(--divide-opacity))}.divide-teal-300>:not(template)~:not(template){--divide-opacity:1;border-color:#81e6d9;border-color:rgba(129,230,217,var(--divide-opacity))}.divide-teal-400>:not(template)~:not(template){--divide-opacity:1;border-color:#4fd1c5;border-color:rgba(79,209,197,var(--divide-opacity))}.divide-teal-500>:not(template)~:not(template){--divide-opacity:1;border-color:#38b2ac;border-color:rgba(56,178,172,var(--divide-opacity))}.divide-teal-600>:not(template)~:not(template){--divide-opacity:1;border-color:#319795;border-color:rgba(49,151,149,var(--divide-opacity))}.divide-teal-700>:not(template)~:not(template){--divide-opacity:1;border-color:#2c7a7b;border-color:rgba(44,122,123,var(--divide-opacity))}.divide-teal-800>:not(template)~:not(template){--divide-opacity:1;border-color:#285e61;border-color:rgba(40,94,97,var(--divide-opacity))}.divide-teal-900>:not(template)~:not(template){--divide-opacity:1;border-color:#234e52;border-color:rgba(35,78,82,var(--divide-opacity))}.divide-blue-100>:not(template)~:not(template){--divide-opacity:1;border-color:#ebf8ff;border-color:rgba(235,248,255,var(--divide-opacity))}.divide-blue-200>:not(template)~:not(template){--divide-opacity:1;border-color:#bee3f8;border-color:rgba(190,227,248,var(--divide-opacity))}.divide-blue-300>:not(template)~:not(template){--divide-opacity:1;border-color:#90cdf4;border-color:rgba(144,205,244,var(--divide-opacity))}.divide-blue-400>:not(template)~:not(template){--divide-opacity:1;border-color:#63b3ed;border-color:rgba(99,179,237,var(--divide-opacity))}.divide-blue-500>:not(template)~:not(template){--divide-opacity:1;border-color:#4299e1;border-color:rgba(66,153,225,var(--divide-opacity))}.divide-blue-600>:not(template)~:not(template){--divide-opacity:1;border-color:#3182ce;border-color:rgba(49,130,206,var(--divide-opacity))}.divide-blue-700>:not(template)~:not(template){--divide-opacity:1;border-color:#2b6cb0;border-color:rgba(43,108,176,var(--divide-opacity))}.divide-blue-800>:not(template)~:not(template){--divide-opacity:1;border-color:#2c5282;border-color:rgba(44,82,130,var(--divide-opacity))}.divide-blue-900>:not(template)~:not(template){--divide-opacity:1;border-color:#2a4365;border-color:rgba(42,67,101,var(--divide-opacity))}.divide-indigo-100>:not(template)~:not(template){--divide-opacity:1;border-color:#ebf4ff;border-color:rgba(235,244,255,var(--divide-opacity))}.divide-indigo-200>:not(template)~:not(template){--divide-opacity:1;border-color:#c3dafe;border-color:rgba(195,218,254,var(--divide-opacity))}.divide-indigo-300>:not(template)~:not(template){--divide-opacity:1;border-color:#a3bffa;border-color:rgba(163,191,250,var(--divide-opacity))}.divide-indigo-400>:not(template)~:not(template){--divide-opacity:1;border-color:#7f9cf5;border-color:rgba(127,156,245,var(--divide-opacity))}.divide-indigo-500>:not(template)~:not(template){--divide-opacity:1;border-color:#667eea;border-color:rgba(102,126,234,var(--divide-opacity))}.divide-indigo-600>:not(template)~:not(template){--divide-opacity:1;border-color:#5a67d8;border-color:rgba(90,103,216,var(--divide-opacity))}.divide-indigo-700>:not(template)~:not(template){--divide-opacity:1;border-color:#4c51bf;border-color:rgba(76,81,191,var(--divide-opacity))}.divide-indigo-800>:not(template)~:not(template){--divide-opacity:1;border-color:#434190;border-color:rgba(67,65,144,var(--divide-opacity))}.divide-indigo-900>:not(template)~:not(template){--divide-opacity:1;border-color:#3c366b;border-color:rgba(60,54,107,var(--divide-opacity))}.divide-purple-100>:not(template)~:not(template){--divide-opacity:1;border-color:#faf5ff;border-color:rgba(250,245,255,var(--divide-opacity))}.divide-purple-200>:not(template)~:not(template){--divide-opacity:1;border-color:#e9d8fd;border-color:rgba(233,216,253,var(--divide-opacity))}.divide-purple-300>:not(template)~:not(template){--divide-opacity:1;border-color:#d6bcfa;border-color:rgba(214,188,250,var(--divide-opacity))}.divide-purple-400>:not(template)~:not(template){--divide-opacity:1;border-color:#b794f4;border-color:rgba(183,148,244,var(--divide-opacity))}.divide-purple-500>:not(template)~:not(template){--divide-opacity:1;border-color:#9f7aea;border-color:rgba(159,122,234,var(--divide-opacity))}.divide-purple-600>:not(template)~:not(template){--divide-opacity:1;border-color:#805ad5;border-color:rgba(128,90,213,var(--divide-opacity))}.divide-purple-700>:not(template)~:not(template){--divide-opacity:1;border-color:#6b46c1;border-color:rgba(107,70,193,var(--divide-opacity))}.divide-purple-800>:not(template)~:not(template){--divide-opacity:1;border-color:#553c9a;border-color:rgba(85,60,154,var(--divide-opacity))}.divide-purple-900>:not(template)~:not(template){--divide-opacity:1;border-color:#44337a;border-color:rgba(68,51,122,var(--divide-opacity))}.divide-pink-100>:not(template)~:not(template){--divide-opacity:1;border-color:#fff5f7;border-color:rgba(255,245,247,var(--divide-opacity))}.divide-pink-200>:not(template)~:not(template){--divide-opacity:1;border-color:#fed7e2;border-color:rgba(254,215,226,var(--divide-opacity))}.divide-pink-300>:not(template)~:not(template){--divide-opacity:1;border-color:#fbb6ce;border-color:rgba(251,182,206,var(--divide-opacity))}.divide-pink-400>:not(template)~:not(template){--divide-opacity:1;border-color:#f687b3;border-color:rgba(246,135,179,var(--divide-opacity))}.divide-pink-500>:not(template)~:not(template){--divide-opacity:1;border-color:#ed64a6;border-color:rgba(237,100,166,var(--divide-opacity))}.divide-pink-600>:not(template)~:not(template){--divide-opacity:1;border-color:#d53f8c;border-color:rgba(213,63,140,var(--divide-opacity))}.divide-pink-700>:not(template)~:not(template){--divide-opacity:1;border-color:#b83280;border-color:rgba(184,50,128,var(--divide-opacity))}.divide-pink-800>:not(template)~:not(template){--divide-opacity:1;border-color:#97266d;border-color:rgba(151,38,109,var(--divide-opacity))}.divide-pink-900>:not(template)~:not(template){--divide-opacity:1;border-color:#702459;border-color:rgba(112,36,89,var(--divide-opacity))}.divide-solid>:not(template)~:not(template){border-style:solid}.divide-dashed>:not(template)~:not(template){border-style:dashed}.divide-dotted>:not(template)~:not(template){border-style:dotted}.divide-double>:not(template)~:not(template){border-style:double}.divide-none>:not(template)~:not(template){border-style:none}.divide-opacity-0>:not(template)~:not(template){--divide-opacity:0}.divide-opacity-25>:not(template)~:not(template){--divide-opacity:.25}.divide-opacity-50>:not(template)~:not(template){--divide-opacity:.5}.divide-opacity-75>:not(template)~:not(template){--divide-opacity:.75}.divide-opacity-100>:not(template)~:not(template){--divide-opacity:1}.sr-only{clip:rect(0,0,0,0);white-space:nowrap;border-width:0;width:1px;height:1px;margin:-1px;padding:0;position:absolute;overflow:hidden}.not-sr-only{clip:auto;white-space:normal;width:auto;height:auto;margin:0;padding:0;position:static;overflow:visible}.focus\:sr-only:focus{clip:rect(0,0,0,0);white-space:nowrap;border-width:0;width:1px;height:1px;margin:-1px;padding:0;position:absolute;overflow:hidden}.focus\:not-sr-only:focus{clip:auto;white-space:normal;width:auto;height:auto;margin:0;padding:0;position:static;overflow:visible}.appearance-none{-webkit-appearance:none;-moz-appearance:none;appearance:none}.bg-fixed{background-attachment:fixed}.bg-local{background-attachment:local}.bg-scroll{background-attachment:scroll}.bg-clip-border{background-clip:border-box}.bg-clip-padding{background-clip:padding-box}.bg-clip-content{background-clip:content-box}.bg-clip-text{-webkit-background-clip:text;background-clip:text}.bg-transparent{background-color:#0000}.bg-current{background-color:currentColor}.bg-black{--bg-opacity:1;background-color:#000;background-color:rgba(0,0,0,var(--bg-opacity))}.bg-white{--bg-opacity:1;background-color:#fff;background-color:rgba(255,255,255,var(--bg-opacity))}.bg-gray-100{--bg-opacity:1;background-color:#f7fafc;background-color:rgba(247,250,252,var(--bg-opacity))}.bg-gray-200{--bg-opacity:1;background-color:#edf2f7;background-color:rgba(237,242,247,var(--bg-opacity))}.bg-gray-300{--bg-opacity:1;background-color:#e2e8f0;background-color:rgba(226,232,240,var(--bg-opacity))}.bg-gray-400{--bg-opacity:1;background-color:#cbd5e0;background-color:rgba(203,213,224,var(--bg-opacity))}.bg-gray-500{--bg-opacity:1;background-color:#a0aec0;background-color:rgba(160,174,192,var(--bg-opacity))}.bg-gray-600{--bg-opacity:1;background-color:#718096;background-color:rgba(113,128,150,var(--bg-opacity))}.bg-gray-700{--bg-opacity:1;background-color:#4a5568;background-color:rgba(74,85,104,var(--bg-opacity))}.bg-gray-800{--bg-opacity:1;background-color:#2d3748;background-color:rgba(45,55,72,var(--bg-opacity))}.bg-gray-900{--bg-opacity:1;background-color:#1a202c;background-color:rgba(26,32,44,var(--bg-opacity))}.bg-red-100{--bg-opacity:1;background-color:#fff5f5;background-color:rgba(255,245,245,var(--bg-opacity))}.bg-red-200{--bg-opacity:1;background-color:#fed7d7;background-color:rgba(254,215,215,var(--bg-opacity))}.bg-red-300{--bg-opacity:1;background-color:#feb2b2;background-color:rgba(254,178,178,var(--bg-opacity))}.bg-red-400{--bg-opacity:1;background-color:#fc8181;background-color:rgba(252,129,129,var(--bg-opacity))}.bg-red-500{--bg-opacity:1;background-color:#f56565;background-color:rgba(245,101,101,var(--bg-opacity))}.bg-red-600{--bg-opacity:1;background-color:#e53e3e;background-color:rgba(229,62,62,var(--bg-opacity))}.bg-red-700{--bg-opacity:1;background-color:#c53030;background-color:rgba(197,48,48,var(--bg-opacity))}.bg-red-800{--bg-opacity:1;background-color:#9b2c2c;background-color:rgba(155,44,44,var(--bg-opacity))}.bg-red-900{--bg-opacity:1;background-color:#742a2a;background-color:rgba(116,42,42,var(--bg-opacity))}.bg-orange-100{--bg-opacity:1;background-color:#fffaf0;background-color:rgba(255,250,240,var(--bg-opacity))}.bg-orange-200{--bg-opacity:1;background-color:#feebc8;background-color:rgba(254,235,200,var(--bg-opacity))}.bg-orange-300{--bg-opacity:1;background-color:#fbd38d;background-color:rgba(251,211,141,var(--bg-opacity))}.bg-orange-400{--bg-opacity:1;background-color:#f6ad55;background-color:rgba(246,173,85,var(--bg-opacity))}.bg-orange-500{--bg-opacity:1;background-color:#ed8936;background-color:rgba(237,137,54,var(--bg-opacity))}.bg-orange-600{--bg-opacity:1;background-color:#dd6b20;background-color:rgba(221,107,32,var(--bg-opacity))}.bg-orange-700{--bg-opacity:1;background-color:#c05621;background-color:rgba(192,86,33,var(--bg-opacity))}.bg-orange-800{--bg-opacity:1;background-color:#9c4221;background-color:rgba(156,66,33,var(--bg-opacity))}.bg-orange-900{--bg-opacity:1;background-color:#7b341e;background-color:rgba(123,52,30,var(--bg-opacity))}.bg-yellow-100{--bg-opacity:1;background-color:ivory;background-color:rgba(255,255,240,var(--bg-opacity))}.bg-yellow-200{--bg-opacity:1;background-color:#fefcbf;background-color:rgba(254,252,191,var(--bg-opacity))}.bg-yellow-300{--bg-opacity:1;background-color:#faf089;background-color:rgba(250,240,137,var(--bg-opacity))}.bg-yellow-400{--bg-opacity:1;background-color:#f6e05e;background-color:rgba(246,224,94,var(--bg-opacity))}.bg-yellow-500{--bg-opacity:1;background-color:#ecc94b;background-color:rgba(236,201,75,var(--bg-opacity))}.bg-yellow-600{--bg-opacity:1;background-color:#d69e2e;background-color:rgba(214,158,46,var(--bg-opacity))}.bg-yellow-700{--bg-opacity:1;background-color:#b7791f;background-color:rgba(183,121,31,var(--bg-opacity))}.bg-yellow-800{--bg-opacity:1;background-color:#975a16;background-color:rgba(151,90,22,var(--bg-opacity))}.bg-yellow-900{--bg-opacity:1;background-color:#744210;background-color:rgba(116,66,16,var(--bg-opacity))}.bg-green-100{--bg-opacity:1;background-color:#f0fff4;background-color:rgba(240,255,244,var(--bg-opacity))}.bg-green-200{--bg-opacity:1;background-color:#c6f6d5;background-color:rgba(198,246,213,var(--bg-opacity))}.bg-green-300{--bg-opacity:1;background-color:#9ae6b4;background-color:rgba(154,230,180,var(--bg-opacity))}.bg-green-400{--bg-opacity:1;background-color:#68d391;background-color:rgba(104,211,145,var(--bg-opacity))}.bg-green-500{--bg-opacity:1;background-color:#48bb78;background-color:rgba(72,187,120,var(--bg-opacity))}.bg-green-600{--bg-opacity:1;background-color:#38a169;background-color:rgba(56,161,105,var(--bg-opacity))}.bg-green-700{--bg-opacity:1;background-color:#2f855a;background-color:rgba(47,133,90,var(--bg-opacity))}.bg-green-800{--bg-opacity:1;background-color:#276749;background-color:rgba(39,103,73,var(--bg-opacity))}.bg-green-900{--bg-opacity:1;background-color:#22543d;background-color:rgba(34,84,61,var(--bg-opacity))}.bg-teal-100{--bg-opacity:1;background-color:#e6fffa;background-color:rgba(230,255,250,var(--bg-opacity))}.bg-teal-200{--bg-opacity:1;background-color:#b2f5ea;background-color:rgba(178,245,234,var(--bg-opacity))}.bg-teal-300{--bg-opacity:1;background-color:#81e6d9;background-color:rgba(129,230,217,var(--bg-opacity))}.bg-teal-400{--bg-opacity:1;background-color:#4fd1c5;background-color:rgba(79,209,197,var(--bg-opacity))}.bg-teal-500{--bg-opacity:1;background-color:#38b2ac;background-color:rgba(56,178,172,var(--bg-opacity))}.bg-teal-600{--bg-opacity:1;background-color:#319795;background-color:rgba(49,151,149,var(--bg-opacity))}.bg-teal-700{--bg-opacity:1;background-color:#2c7a7b;background-color:rgba(44,122,123,var(--bg-opacity))}.bg-teal-800{--bg-opacity:1;background-color:#285e61;background-color:rgba(40,94,97,var(--bg-opacity))}.bg-teal-900{--bg-opacity:1;background-color:#234e52;background-color:rgba(35,78,82,var(--bg-opacity))}.bg-blue-100{--bg-opacity:1;background-color:#ebf8ff;background-color:rgba(235,248,255,var(--bg-opacity))}.bg-blue-200{--bg-opacity:1;background-color:#bee3f8;background-color:rgba(190,227,248,var(--bg-opacity))}.bg-blue-300{--bg-opacity:1;background-color:#90cdf4;background-color:rgba(144,205,244,var(--bg-opacity))}.bg-blue-400{--bg-opacity:1;background-color:#63b3ed;background-color:rgba(99,179,237,var(--bg-opacity))}.bg-blue-500{--bg-opacity:1;background-color:#4299e1;background-color:rgba(66,153,225,var(--bg-opacity))}.bg-blue-600{--bg-opacity:1;background-color:#3182ce;background-color:rgba(49,130,206,var(--bg-opacity))}.bg-blue-700{--bg-opacity:1;background-color:#2b6cb0;background-color:rgba(43,108,176,var(--bg-opacity))}.bg-blue-800{--bg-opacity:1;background-color:#2c5282;background-color:rgba(44,82,130,var(--bg-opacity))}.bg-blue-900{--bg-opacity:1;background-color:#2a4365;background-color:rgba(42,67,101,var(--bg-opacity))}.bg-indigo-100{--bg-opacity:1;background-color:#ebf4ff;background-color:rgba(235,244,255,var(--bg-opacity))}.bg-indigo-200{--bg-opacity:1;background-color:#c3dafe;background-color:rgba(195,218,254,var(--bg-opacity))}.bg-indigo-300{--bg-opacity:1;background-color:#a3bffa;background-color:rgba(163,191,250,var(--bg-opacity))}.bg-indigo-400{--bg-opacity:1;background-color:#7f9cf5;background-color:rgba(127,156,245,var(--bg-opacity))}.bg-indigo-500{--bg-opacity:1;background-color:#667eea;background-color:rgba(102,126,234,var(--bg-opacity))}.bg-indigo-600{--bg-opacity:1;background-color:#5a67d8;background-color:rgba(90,103,216,var(--bg-opacity))}.bg-indigo-700{--bg-opacity:1;background-color:#4c51bf;background-color:rgba(76,81,191,var(--bg-opacity))}.bg-indigo-800{--bg-opacity:1;background-color:#434190;background-color:rgba(67,65,144,var(--bg-opacity))}.bg-indigo-900{--bg-opacity:1;background-color:#3c366b;background-color:rgba(60,54,107,var(--bg-opacity))}.bg-purple-100{--bg-opacity:1;background-color:#faf5ff;background-color:rgba(250,245,255,var(--bg-opacity))}.bg-purple-200{--bg-opacity:1;background-color:#e9d8fd;background-color:rgba(233,216,253,var(--bg-opacity))}.bg-purple-300{--bg-opacity:1;background-color:#d6bcfa;background-color:rgba(214,188,250,var(--bg-opacity))}.bg-purple-400{--bg-opacity:1;background-color:#b794f4;background-color:rgba(183,148,244,var(--bg-opacity))}.bg-purple-500{--bg-opacity:1;background-color:#9f7aea;background-color:rgba(159,122,234,var(--bg-opacity))}.bg-purple-600{--bg-opacity:1;background-color:#805ad5;background-color:rgba(128,90,213,var(--bg-opacity))}.bg-purple-700{--bg-opacity:1;background-color:#6b46c1;background-color:rgba(107,70,193,var(--bg-opacity))}.bg-purple-800{--bg-opacity:1;background-color:#553c9a;background-color:rgba(85,60,154,var(--bg-opacity))}.bg-purple-900{--bg-opacity:1;background-color:#44337a;background-color:rgba(68,51,122,var(--bg-opacity))}.bg-pink-100{--bg-opacity:1;background-color:#fff5f7;background-color:rgba(255,245,247,var(--bg-opacity))}.bg-pink-200{--bg-opacity:1;background-color:#fed7e2;background-color:rgba(254,215,226,var(--bg-opacity))}.bg-pink-300{--bg-opacity:1;background-color:#fbb6ce;background-color:rgba(251,182,206,var(--bg-opacity))}.bg-pink-400{--bg-opacity:1;background-color:#f687b3;background-color:rgba(246,135,179,var(--bg-opacity))}.bg-pink-500{--bg-opacity:1;background-color:#ed64a6;background-color:rgba(237,100,166,var(--bg-opacity))}.bg-pink-600{--bg-opacity:1;background-color:#d53f8c;background-color:rgba(213,63,140,var(--bg-opacity))}.bg-pink-700{--bg-opacity:1;background-color:#b83280;background-color:rgba(184,50,128,var(--bg-opacity))}.bg-pink-800{--bg-opacity:1;background-color:#97266d;background-color:rgba(151,38,109,var(--bg-opacity))}.bg-pink-900{--bg-opacity:1;background-color:#702459;background-color:rgba(112,36,89,var(--bg-opacity))}.hover\:bg-transparent:hover{background-color:#0000}.hover\:bg-current:hover{background-color:currentColor}.hover\:bg-black:hover{--bg-opacity:1;background-color:#000;background-color:rgba(0,0,0,var(--bg-opacity))}.hover\:bg-white:hover{--bg-opacity:1;background-color:#fff;background-color:rgba(255,255,255,var(--bg-opacity))}.hover\:bg-gray-100:hover{--bg-opacity:1;background-color:#f7fafc;background-color:rgba(247,250,252,var(--bg-opacity))}.hover\:bg-gray-200:hover{--bg-opacity:1;background-color:#edf2f7;background-color:rgba(237,242,247,var(--bg-opacity))}.hover\:bg-gray-300:hover{--bg-opacity:1;background-color:#e2e8f0;background-color:rgba(226,232,240,var(--bg-opacity))}.hover\:bg-gray-400:hover{--bg-opacity:1;background-color:#cbd5e0;background-color:rgba(203,213,224,var(--bg-opacity))}.hover\:bg-gray-500:hover{--bg-opacity:1;background-color:#a0aec0;background-color:rgba(160,174,192,var(--bg-opacity))}.hover\:bg-gray-600:hover{--bg-opacity:1;background-color:#718096;background-color:rgba(113,128,150,var(--bg-opacity))}.hover\:bg-gray-700:hover{--bg-opacity:1;background-color:#4a5568;background-color:rgba(74,85,104,var(--bg-opacity))}.hover\:bg-gray-800:hover{--bg-opacity:1;background-color:#2d3748;background-color:rgba(45,55,72,var(--bg-opacity))}.hover\:bg-gray-900:hover{--bg-opacity:1;background-color:#1a202c;background-color:rgba(26,32,44,var(--bg-opacity))}.hover\:bg-red-100:hover{--bg-opacity:1;background-color:#fff5f5;background-color:rgba(255,245,245,var(--bg-opacity))}.hover\:bg-red-200:hover{--bg-opacity:1;background-color:#fed7d7;background-color:rgba(254,215,215,var(--bg-opacity))}.hover\:bg-red-300:hover{--bg-opacity:1;background-color:#feb2b2;background-color:rgba(254,178,178,var(--bg-opacity))}.hover\:bg-red-400:hover{--bg-opacity:1;background-color:#fc8181;background-color:rgba(252,129,129,var(--bg-opacity))}.hover\:bg-red-500:hover{--bg-opacity:1;background-color:#f56565;background-color:rgba(245,101,101,var(--bg-opacity))}.hover\:bg-red-600:hover{--bg-opacity:1;background-color:#e53e3e;background-color:rgba(229,62,62,var(--bg-opacity))}.hover\:bg-red-700:hover{--bg-opacity:1;background-color:#c53030;background-color:rgba(197,48,48,var(--bg-opacity))}.hover\:bg-red-800:hover{--bg-opacity:1;background-color:#9b2c2c;background-color:rgba(155,44,44,var(--bg-opacity))}.hover\:bg-red-900:hover{--bg-opacity:1;background-color:#742a2a;background-color:rgba(116,42,42,var(--bg-opacity))}.hover\:bg-orange-100:hover{--bg-opacity:1;background-color:#fffaf0;background-color:rgba(255,250,240,var(--bg-opacity))}.hover\:bg-orange-200:hover{--bg-opacity:1;background-color:#feebc8;background-color:rgba(254,235,200,var(--bg-opacity))}.hover\:bg-orange-300:hover{--bg-opacity:1;background-color:#fbd38d;background-color:rgba(251,211,141,var(--bg-opacity))}.hover\:bg-orange-400:hover{--bg-opacity:1;background-color:#f6ad55;background-color:rgba(246,173,85,var(--bg-opacity))}.hover\:bg-orange-500:hover{--bg-opacity:1;background-color:#ed8936;background-color:rgba(237,137,54,var(--bg-opacity))}.hover\:bg-orange-600:hover{--bg-opacity:1;background-color:#dd6b20;background-color:rgba(221,107,32,var(--bg-opacity))}.hover\:bg-orange-700:hover{--bg-opacity:1;background-color:#c05621;background-color:rgba(192,86,33,var(--bg-opacity))}.hover\:bg-orange-800:hover{--bg-opacity:1;background-color:#9c4221;background-color:rgba(156,66,33,var(--bg-opacity))}.hover\:bg-orange-900:hover{--bg-opacity:1;background-color:#7b341e;background-color:rgba(123,52,30,var(--bg-opacity))}.hover\:bg-yellow-100:hover{--bg-opacity:1;background-color:ivory;background-color:rgba(255,255,240,var(--bg-opacity))}.hover\:bg-yellow-200:hover{--bg-opacity:1;background-color:#fefcbf;background-color:rgba(254,252,191,var(--bg-opacity))}.hover\:bg-yellow-300:hover{--bg-opacity:1;background-color:#faf089;background-color:rgba(250,240,137,var(--bg-opacity))}.hover\:bg-yellow-400:hover{--bg-opacity:1;background-color:#f6e05e;background-color:rgba(246,224,94,var(--bg-opacity))}.hover\:bg-yellow-500:hover{--bg-opacity:1;background-color:#ecc94b;background-color:rgba(236,201,75,var(--bg-opacity))}.hover\:bg-yellow-600:hover{--bg-opacity:1;background-color:#d69e2e;background-color:rgba(214,158,46,var(--bg-opacity))}.hover\:bg-yellow-700:hover{--bg-opacity:1;background-color:#b7791f;background-color:rgba(183,121,31,var(--bg-opacity))}.hover\:bg-yellow-800:hover{--bg-opacity:1;background-color:#975a16;background-color:rgba(151,90,22,var(--bg-opacity))}.hover\:bg-yellow-900:hover{--bg-opacity:1;background-color:#744210;background-color:rgba(116,66,16,var(--bg-opacity))}.hover\:bg-green-100:hover{--bg-opacity:1;background-color:#f0fff4;background-color:rgba(240,255,244,var(--bg-opacity))}.hover\:bg-green-200:hover{--bg-opacity:1;background-color:#c6f6d5;background-color:rgba(198,246,213,var(--bg-opacity))}.hover\:bg-green-300:hover{--bg-opacity:1;background-color:#9ae6b4;background-color:rgba(154,230,180,var(--bg-opacity))}.hover\:bg-green-400:hover{--bg-opacity:1;background-color:#68d391;background-color:rgba(104,211,145,var(--bg-opacity))}.hover\:bg-green-500:hover{--bg-opacity:1;background-color:#48bb78;background-color:rgba(72,187,120,var(--bg-opacity))}.hover\:bg-green-600:hover{--bg-opacity:1;background-color:#38a169;background-color:rgba(56,161,105,var(--bg-opacity))}.hover\:bg-green-700:hover{--bg-opacity:1;background-color:#2f855a;background-color:rgba(47,133,90,var(--bg-opacity))}.hover\:bg-green-800:hover{--bg-opacity:1;background-color:#276749;background-color:rgba(39,103,73,var(--bg-opacity))}.hover\:bg-green-900:hover{--bg-opacity:1;background-color:#22543d;background-color:rgba(34,84,61,var(--bg-opacity))}.hover\:bg-teal-100:hover{--bg-opacity:1;background-color:#e6fffa;background-color:rgba(230,255,250,var(--bg-opacity))}.hover\:bg-teal-200:hover{--bg-opacity:1;background-color:#b2f5ea;background-color:rgba(178,245,234,var(--bg-opacity))}.hover\:bg-teal-300:hover{--bg-opacity:1;background-color:#81e6d9;background-color:rgba(129,230,217,var(--bg-opacity))}.hover\:bg-teal-400:hover{--bg-opacity:1;background-color:#4fd1c5;background-color:rgba(79,209,197,var(--bg-opacity))}.hover\:bg-teal-500:hover{--bg-opacity:1;background-color:#38b2ac;background-color:rgba(56,178,172,var(--bg-opacity))}.hover\:bg-teal-600:hover{--bg-opacity:1;background-color:#319795;background-color:rgba(49,151,149,var(--bg-opacity))}.hover\:bg-teal-700:hover{--bg-opacity:1;background-color:#2c7a7b;background-color:rgba(44,122,123,var(--bg-opacity))}.hover\:bg-teal-800:hover{--bg-opacity:1;background-color:#285e61;background-color:rgba(40,94,97,var(--bg-opacity))}.hover\:bg-teal-900:hover{--bg-opacity:1;background-color:#234e52;background-color:rgba(35,78,82,var(--bg-opacity))}.hover\:bg-blue-100:hover{--bg-opacity:1;background-color:#ebf8ff;background-color:rgba(235,248,255,var(--bg-opacity))}.hover\:bg-blue-200:hover{--bg-opacity:1;background-color:#bee3f8;background-color:rgba(190,227,248,var(--bg-opacity))}.hover\:bg-blue-300:hover{--bg-opacity:1;background-color:#90cdf4;background-color:rgba(144,205,244,var(--bg-opacity))}.hover\:bg-blue-400:hover{--bg-opacity:1;background-color:#63b3ed;background-color:rgba(99,179,237,var(--bg-opacity))}.hover\:bg-blue-500:hover{--bg-opacity:1;background-color:#4299e1;background-color:rgba(66,153,225,var(--bg-opacity))}.hover\:bg-blue-600:hover{--bg-opacity:1;background-color:#3182ce;background-color:rgba(49,130,206,var(--bg-opacity))}.hover\:bg-blue-700:hover{--bg-opacity:1;background-color:#2b6cb0;background-color:rgba(43,108,176,var(--bg-opacity))}.hover\:bg-blue-800:hover{--bg-opacity:1;background-color:#2c5282;background-color:rgba(44,82,130,var(--bg-opacity))}.hover\:bg-blue-900:hover{--bg-opacity:1;background-color:#2a4365;background-color:rgba(42,67,101,var(--bg-opacity))}.hover\:bg-indigo-100:hover{--bg-opacity:1;background-color:#ebf4ff;background-color:rgba(235,244,255,var(--bg-opacity))}.hover\:bg-indigo-200:hover{--bg-opacity:1;background-color:#c3dafe;background-color:rgba(195,218,254,var(--bg-opacity))}.hover\:bg-indigo-300:hover{--bg-opacity:1;background-color:#a3bffa;background-color:rgba(163,191,250,var(--bg-opacity))}.hover\:bg-indigo-400:hover{--bg-opacity:1;background-color:#7f9cf5;background-color:rgba(127,156,245,var(--bg-opacity))}.hover\:bg-indigo-500:hover{--bg-opacity:1;background-color:#667eea;background-color:rgba(102,126,234,var(--bg-opacity))}.hover\:bg-indigo-600:hover{--bg-opacity:1;background-color:#5a67d8;background-color:rgba(90,103,216,var(--bg-opacity))}.hover\:bg-indigo-700:hover{--bg-opacity:1;background-color:#4c51bf;background-color:rgba(76,81,191,var(--bg-opacity))}.hover\:bg-indigo-800:hover{--bg-opacity:1;background-color:#434190;background-color:rgba(67,65,144,var(--bg-opacity))}.hover\:bg-indigo-900:hover{--bg-opacity:1;background-color:#3c366b;background-color:rgba(60,54,107,var(--bg-opacity))}.hover\:bg-purple-100:hover{--bg-opacity:1;background-color:#faf5ff;background-color:rgba(250,245,255,var(--bg-opacity))}.hover\:bg-purple-200:hover{--bg-opacity:1;background-color:#e9d8fd;background-color:rgba(233,216,253,var(--bg-opacity))}.hover\:bg-purple-300:hover{--bg-opacity:1;background-color:#d6bcfa;background-color:rgba(214,188,250,var(--bg-opacity))}.hover\:bg-purple-400:hover{--bg-opacity:1;background-color:#b794f4;background-color:rgba(183,148,244,var(--bg-opacity))}.hover\:bg-purple-500:hover{--bg-opacity:1;background-color:#9f7aea;background-color:rgba(159,122,234,var(--bg-opacity))}.hover\:bg-purple-600:hover{--bg-opacity:1;background-color:#805ad5;background-color:rgba(128,90,213,var(--bg-opacity))}.hover\:bg-purple-700:hover{--bg-opacity:1;background-color:#6b46c1;background-color:rgba(107,70,193,var(--bg-opacity))}.hover\:bg-purple-800:hover{--bg-opacity:1;background-color:#553c9a;background-color:rgba(85,60,154,var(--bg-opacity))}.hover\:bg-purple-900:hover{--bg-opacity:1;background-color:#44337a;background-color:rgba(68,51,122,var(--bg-opacity))}.hover\:bg-pink-100:hover{--bg-opacity:1;background-color:#fff5f7;background-color:rgba(255,245,247,var(--bg-opacity))}.hover\:bg-pink-200:hover{--bg-opacity:1;background-color:#fed7e2;background-color:rgba(254,215,226,var(--bg-opacity))}.hover\:bg-pink-300:hover{--bg-opacity:1;background-color:#fbb6ce;background-color:rgba(251,182,206,var(--bg-opacity))}.hover\:bg-pink-400:hover{--bg-opacity:1;background-color:#f687b3;background-color:rgba(246,135,179,var(--bg-opacity))}.hover\:bg-pink-500:hover{--bg-opacity:1;background-color:#ed64a6;background-color:rgba(237,100,166,var(--bg-opacity))}.hover\:bg-pink-600:hover{--bg-opacity:1;background-color:#d53f8c;background-color:rgba(213,63,140,var(--bg-opacity))}.hover\:bg-pink-700:hover{--bg-opacity:1;background-color:#b83280;background-color:rgba(184,50,128,var(--bg-opacity))}.hover\:bg-pink-800:hover{--bg-opacity:1;background-color:#97266d;background-color:rgba(151,38,109,var(--bg-opacity))}.hover\:bg-pink-900:hover{--bg-opacity:1;background-color:#702459;background-color:rgba(112,36,89,var(--bg-opacity))}.focus\:bg-transparent:focus{background-color:#0000}.focus\:bg-current:focus{background-color:currentColor}.focus\:bg-black:focus{--bg-opacity:1;background-color:#000;background-color:rgba(0,0,0,var(--bg-opacity))}.focus\:bg-white:focus{--bg-opacity:1;background-color:#fff;background-color:rgba(255,255,255,var(--bg-opacity))}.focus\:bg-gray-100:focus{--bg-opacity:1;background-color:#f7fafc;background-color:rgba(247,250,252,var(--bg-opacity))}.focus\:bg-gray-200:focus{--bg-opacity:1;background-color:#edf2f7;background-color:rgba(237,242,247,var(--bg-opacity))}.focus\:bg-gray-300:focus{--bg-opacity:1;background-color:#e2e8f0;background-color:rgba(226,232,240,var(--bg-opacity))}.focus\:bg-gray-400:focus{--bg-opacity:1;background-color:#cbd5e0;background-color:rgba(203,213,224,var(--bg-opacity))}.focus\:bg-gray-500:focus{--bg-opacity:1;background-color:#a0aec0;background-color:rgba(160,174,192,var(--bg-opacity))}.focus\:bg-gray-600:focus{--bg-opacity:1;background-color:#718096;background-color:rgba(113,128,150,var(--bg-opacity))}.focus\:bg-gray-700:focus{--bg-opacity:1;background-color:#4a5568;background-color:rgba(74,85,104,var(--bg-opacity))}.focus\:bg-gray-800:focus{--bg-opacity:1;background-color:#2d3748;background-color:rgba(45,55,72,var(--bg-opacity))}.focus\:bg-gray-900:focus{--bg-opacity:1;background-color:#1a202c;background-color:rgba(26,32,44,var(--bg-opacity))}.focus\:bg-red-100:focus{--bg-opacity:1;background-color:#fff5f5;background-color:rgba(255,245,245,var(--bg-opacity))}.focus\:bg-red-200:focus{--bg-opacity:1;background-color:#fed7d7;background-color:rgba(254,215,215,var(--bg-opacity))}.focus\:bg-red-300:focus{--bg-opacity:1;background-color:#feb2b2;background-color:rgba(254,178,178,var(--bg-opacity))}.focus\:bg-red-400:focus{--bg-opacity:1;background-color:#fc8181;background-color:rgba(252,129,129,var(--bg-opacity))}.focus\:bg-red-500:focus{--bg-opacity:1;background-color:#f56565;background-color:rgba(245,101,101,var(--bg-opacity))}.focus\:bg-red-600:focus{--bg-opacity:1;background-color:#e53e3e;background-color:rgba(229,62,62,var(--bg-opacity))}.focus\:bg-red-700:focus{--bg-opacity:1;background-color:#c53030;background-color:rgba(197,48,48,var(--bg-opacity))}.focus\:bg-red-800:focus{--bg-opacity:1;background-color:#9b2c2c;background-color:rgba(155,44,44,var(--bg-opacity))}.focus\:bg-red-900:focus{--bg-opacity:1;background-color:#742a2a;background-color:rgba(116,42,42,var(--bg-opacity))}.focus\:bg-orange-100:focus{--bg-opacity:1;background-color:#fffaf0;background-color:rgba(255,250,240,var(--bg-opacity))}.focus\:bg-orange-200:focus{--bg-opacity:1;background-color:#feebc8;background-color:rgba(254,235,200,var(--bg-opacity))}.focus\:bg-orange-300:focus{--bg-opacity:1;background-color:#fbd38d;background-color:rgba(251,211,141,var(--bg-opacity))}.focus\:bg-orange-400:focus{--bg-opacity:1;background-color:#f6ad55;background-color:rgba(246,173,85,var(--bg-opacity))}.focus\:bg-orange-500:focus{--bg-opacity:1;background-color:#ed8936;background-color:rgba(237,137,54,var(--bg-opacity))}.focus\:bg-orange-600:focus{--bg-opacity:1;background-color:#dd6b20;background-color:rgba(221,107,32,var(--bg-opacity))}.focus\:bg-orange-700:focus{--bg-opacity:1;background-color:#c05621;background-color:rgba(192,86,33,var(--bg-opacity))}.focus\:bg-orange-800:focus{--bg-opacity:1;background-color:#9c4221;background-color:rgba(156,66,33,var(--bg-opacity))}.focus\:bg-orange-900:focus{--bg-opacity:1;background-color:#7b341e;background-color:rgba(123,52,30,var(--bg-opacity))}.focus\:bg-yellow-100:focus{--bg-opacity:1;background-color:ivory;background-color:rgba(255,255,240,var(--bg-opacity))}.focus\:bg-yellow-200:focus{--bg-opacity:1;background-color:#fefcbf;background-color:rgba(254,252,191,var(--bg-opacity))}.focus\:bg-yellow-300:focus{--bg-opacity:1;background-color:#faf089;background-color:rgba(250,240,137,var(--bg-opacity))}.focus\:bg-yellow-400:focus{--bg-opacity:1;background-color:#f6e05e;background-color:rgba(246,224,94,var(--bg-opacity))}.focus\:bg-yellow-500:focus{--bg-opacity:1;background-color:#ecc94b;background-color:rgba(236,201,75,var(--bg-opacity))}.focus\:bg-yellow-600:focus{--bg-opacity:1;background-color:#d69e2e;background-color:rgba(214,158,46,var(--bg-opacity))}.focus\:bg-yellow-700:focus{--bg-opacity:1;background-color:#b7791f;background-color:rgba(183,121,31,var(--bg-opacity))}.focus\:bg-yellow-800:focus{--bg-opacity:1;background-color:#975a16;background-color:rgba(151,90,22,var(--bg-opacity))}.focus\:bg-yellow-900:focus{--bg-opacity:1;background-color:#744210;background-color:rgba(116,66,16,var(--bg-opacity))}.focus\:bg-green-100:focus{--bg-opacity:1;background-color:#f0fff4;background-color:rgba(240,255,244,var(--bg-opacity))}.focus\:bg-green-200:focus{--bg-opacity:1;background-color:#c6f6d5;background-color:rgba(198,246,213,var(--bg-opacity))}.focus\:bg-green-300:focus{--bg-opacity:1;background-color:#9ae6b4;background-color:rgba(154,230,180,var(--bg-opacity))}.focus\:bg-green-400:focus{--bg-opacity:1;background-color:#68d391;background-color:rgba(104,211,145,var(--bg-opacity))}.focus\:bg-green-500:focus{--bg-opacity:1;background-color:#48bb78;background-color:rgba(72,187,120,var(--bg-opacity))}.focus\:bg-green-600:focus{--bg-opacity:1;background-color:#38a169;background-color:rgba(56,161,105,var(--bg-opacity))}.focus\:bg-green-700:focus{--bg-opacity:1;background-color:#2f855a;background-color:rgba(47,133,90,var(--bg-opacity))}.focus\:bg-green-800:focus{--bg-opacity:1;background-color:#276749;background-color:rgba(39,103,73,var(--bg-opacity))}.focus\:bg-green-900:focus{--bg-opacity:1;background-color:#22543d;background-color:rgba(34,84,61,var(--bg-opacity))}.focus\:bg-teal-100:focus{--bg-opacity:1;background-color:#e6fffa;background-color:rgba(230,255,250,var(--bg-opacity))}.focus\:bg-teal-200:focus{--bg-opacity:1;background-color:#b2f5ea;background-color:rgba(178,245,234,var(--bg-opacity))}.focus\:bg-teal-300:focus{--bg-opacity:1;background-color:#81e6d9;background-color:rgba(129,230,217,var(--bg-opacity))}.focus\:bg-teal-400:focus{--bg-opacity:1;background-color:#4fd1c5;background-color:rgba(79,209,197,var(--bg-opacity))}.focus\:bg-teal-500:focus{--bg-opacity:1;background-color:#38b2ac;background-color:rgba(56,178,172,var(--bg-opacity))}.focus\:bg-teal-600:focus{--bg-opacity:1;background-color:#319795;background-color:rgba(49,151,149,var(--bg-opacity))}.focus\:bg-teal-700:focus{--bg-opacity:1;background-color:#2c7a7b;background-color:rgba(44,122,123,var(--bg-opacity))}.focus\:bg-teal-800:focus{--bg-opacity:1;background-color:#285e61;background-color:rgba(40,94,97,var(--bg-opacity))}.focus\:bg-teal-900:focus{--bg-opacity:1;background-color:#234e52;background-color:rgba(35,78,82,var(--bg-opacity))}.focus\:bg-blue-100:focus{--bg-opacity:1;background-color:#ebf8ff;background-color:rgba(235,248,255,var(--bg-opacity))}.focus\:bg-blue-200:focus{--bg-opacity:1;background-color:#bee3f8;background-color:rgba(190,227,248,var(--bg-opacity))}.focus\:bg-blue-300:focus{--bg-opacity:1;background-color:#90cdf4;background-color:rgba(144,205,244,var(--bg-opacity))}.focus\:bg-blue-400:focus{--bg-opacity:1;background-color:#63b3ed;background-color:rgba(99,179,237,var(--bg-opacity))}.focus\:bg-blue-500:focus{--bg-opacity:1;background-color:#4299e1;background-color:rgba(66,153,225,var(--bg-opacity))}.focus\:bg-blue-600:focus{--bg-opacity:1;background-color:#3182ce;background-color:rgba(49,130,206,var(--bg-opacity))}.focus\:bg-blue-700:focus{--bg-opacity:1;background-color:#2b6cb0;background-color:rgba(43,108,176,var(--bg-opacity))}.focus\:bg-blue-800:focus{--bg-opacity:1;background-color:#2c5282;background-color:rgba(44,82,130,var(--bg-opacity))}.focus\:bg-blue-900:focus{--bg-opacity:1;background-color:#2a4365;background-color:rgba(42,67,101,var(--bg-opacity))}.focus\:bg-indigo-100:focus{--bg-opacity:1;background-color:#ebf4ff;background-color:rgba(235,244,255,var(--bg-opacity))}.focus\:bg-indigo-200:focus{--bg-opacity:1;background-color:#c3dafe;background-color:rgba(195,218,254,var(--bg-opacity))}.focus\:bg-indigo-300:focus{--bg-opacity:1;background-color:#a3bffa;background-color:rgba(163,191,250,var(--bg-opacity))}.focus\:bg-indigo-400:focus{--bg-opacity:1;background-color:#7f9cf5;background-color:rgba(127,156,245,var(--bg-opacity))}.focus\:bg-indigo-500:focus{--bg-opacity:1;background-color:#667eea;background-color:rgba(102,126,234,var(--bg-opacity))}.focus\:bg-indigo-600:focus{--bg-opacity:1;background-color:#5a67d8;background-color:rgba(90,103,216,var(--bg-opacity))}.focus\:bg-indigo-700:focus{--bg-opacity:1;background-color:#4c51bf;background-color:rgba(76,81,191,var(--bg-opacity))}.focus\:bg-indigo-800:focus{--bg-opacity:1;background-color:#434190;background-color:rgba(67,65,144,var(--bg-opacity))}.focus\:bg-indigo-900:focus{--bg-opacity:1;background-color:#3c366b;background-color:rgba(60,54,107,var(--bg-opacity))}.focus\:bg-purple-100:focus{--bg-opacity:1;background-color:#faf5ff;background-color:rgba(250,245,255,var(--bg-opacity))}.focus\:bg-purple-200:focus{--bg-opacity:1;background-color:#e9d8fd;background-color:rgba(233,216,253,var(--bg-opacity))}.focus\:bg-purple-300:focus{--bg-opacity:1;background-color:#d6bcfa;background-color:rgba(214,188,250,var(--bg-opacity))}.focus\:bg-purple-400:focus{--bg-opacity:1;background-color:#b794f4;background-color:rgba(183,148,244,var(--bg-opacity))}.focus\:bg-purple-500:focus{--bg-opacity:1;background-color:#9f7aea;background-color:rgba(159,122,234,var(--bg-opacity))}.focus\:bg-purple-600:focus{--bg-opacity:1;background-color:#805ad5;background-color:rgba(128,90,213,var(--bg-opacity))}.focus\:bg-purple-700:focus{--bg-opacity:1;background-color:#6b46c1;background-color:rgba(107,70,193,var(--bg-opacity))}.focus\:bg-purple-800:focus{--bg-opacity:1;background-color:#553c9a;background-color:rgba(85,60,154,var(--bg-opacity))}.focus\:bg-purple-900:focus{--bg-opacity:1;background-color:#44337a;background-color:rgba(68,51,122,var(--bg-opacity))}.focus\:bg-pink-100:focus{--bg-opacity:1;background-color:#fff5f7;background-color:rgba(255,245,247,var(--bg-opacity))}.focus\:bg-pink-200:focus{--bg-opacity:1;background-color:#fed7e2;background-color:rgba(254,215,226,var(--bg-opacity))}.focus\:bg-pink-300:focus{--bg-opacity:1;background-color:#fbb6ce;background-color:rgba(251,182,206,var(--bg-opacity))}.focus\:bg-pink-400:focus{--bg-opacity:1;background-color:#f687b3;background-color:rgba(246,135,179,var(--bg-opacity))}.focus\:bg-pink-500:focus{--bg-opacity:1;background-color:#ed64a6;background-color:rgba(237,100,166,var(--bg-opacity))}.focus\:bg-pink-600:focus{--bg-opacity:1;background-color:#d53f8c;background-color:rgba(213,63,140,var(--bg-opacity))}.focus\:bg-pink-700:focus{--bg-opacity:1;background-color:#b83280;background-color:rgba(184,50,128,var(--bg-opacity))}.focus\:bg-pink-800:focus{--bg-opacity:1;background-color:#97266d;background-color:rgba(151,38,109,var(--bg-opacity))}.focus\:bg-pink-900:focus{--bg-opacity:1;background-color:#702459;background-color:rgba(112,36,89,var(--bg-opacity))}.bg-none{background-image:none}.bg-gradient-to-t{background-image:linear-gradient(to top,var(--gradient-color-stops))}.bg-gradient-to-tr{background-image:linear-gradient(to top right,var(--gradient-color-stops))}.bg-gradient-to-r{background-image:linear-gradient(to right,var(--gradient-color-stops))}.bg-gradient-to-br{background-image:linear-gradient(to bottom right,var(--gradient-color-stops))}.bg-gradient-to-b{background-image:linear-gradient(to bottom,var(--gradient-color-stops))}.bg-gradient-to-bl{background-image:linear-gradient(to bottom left,var(--gradient-color-stops))}.bg-gradient-to-l{background-image:linear-gradient(to left,var(--gradient-color-stops))}.bg-gradient-to-tl{background-image:linear-gradient(to top left,var(--gradient-color-stops))}.from-transparent{--gradient-from-color:transparent;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#0000)}.from-current{--gradient-from-color:currentColor;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#fff0)}.from-black{--gradient-from-color:#000;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#0000)}.from-white{--gradient-from-color:#fff;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#fff0)}.from-gray-100{--gradient-from-color:#f7fafc;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#f7fafc00)}.from-gray-200{--gradient-from-color:#edf2f7;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#edf2f700)}.from-gray-300{--gradient-from-color:#e2e8f0;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#e2e8f000)}.from-gray-400{--gradient-from-color:#cbd5e0;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#cbd5e000)}.from-gray-500{--gradient-from-color:#a0aec0;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#a0aec000)}.from-gray-600{--gradient-from-color:#718096;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#71809600)}.from-gray-700{--gradient-from-color:#4a5568;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#4a556800)}.from-gray-800{--gradient-from-color:#2d3748;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#2d374800)}.from-gray-900{--gradient-from-color:#1a202c;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#1a202c00)}.from-red-100{--gradient-from-color:#fff5f5;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#fff5f500)}.from-red-200{--gradient-from-color:#fed7d7;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#fed7d700)}.from-red-300{--gradient-from-color:#feb2b2;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#feb2b200)}.from-red-400{--gradient-from-color:#fc8181;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#fc818100)}.from-red-500{--gradient-from-color:#f56565;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#f5656500)}.from-red-600{--gradient-from-color:#e53e3e;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#e53e3e00)}.from-red-700{--gradient-from-color:#c53030;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#c5303000)}.from-red-800{--gradient-from-color:#9b2c2c;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#9b2c2c00)}.from-red-900{--gradient-from-color:#742a2a;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#742a2a00)}.from-orange-100{--gradient-from-color:#fffaf0;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#fffaf000)}.from-orange-200{--gradient-from-color:#feebc8;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#feebc800)}.from-orange-300{--gradient-from-color:#fbd38d;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#fbd38d00)}.from-orange-400{--gradient-from-color:#f6ad55;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#f6ad5500)}.from-orange-500{--gradient-from-color:#ed8936;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#ed893600)}.from-orange-600{--gradient-from-color:#dd6b20;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#dd6b2000)}.from-orange-700{--gradient-from-color:#c05621;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#c0562100)}.from-orange-800{--gradient-from-color:#9c4221;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#9c422100)}.from-orange-900{--gradient-from-color:#7b341e;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#7b341e00)}.from-yellow-100{--gradient-from-color:ivory;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#fffff000)}.from-yellow-200{--gradient-from-color:#fefcbf;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#fefcbf00)}.from-yellow-300{--gradient-from-color:#faf089;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#faf08900)}.from-yellow-400{--gradient-from-color:#f6e05e;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#f6e05e00)}.from-yellow-500{--gradient-from-color:#ecc94b;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#ecc94b00)}.from-yellow-600{--gradient-from-color:#d69e2e;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#d69e2e00)}.from-yellow-700{--gradient-from-color:#b7791f;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#b7791f00)}.from-yellow-800{--gradient-from-color:#975a16;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#975a1600)}.from-yellow-900{--gradient-from-color:#744210;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#74421000)}.from-green-100{--gradient-from-color:#f0fff4;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#f0fff400)}.from-green-200{--gradient-from-color:#c6f6d5;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#c6f6d500)}.from-green-300{--gradient-from-color:#9ae6b4;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#9ae6b400)}.from-green-400{--gradient-from-color:#68d391;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#68d39100)}.from-green-500{--gradient-from-color:#48bb78;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#48bb7800)}.from-green-600{--gradient-from-color:#38a169;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#38a16900)}.from-green-700{--gradient-from-color:#2f855a;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#2f855a00)}.from-green-800{--gradient-from-color:#276749;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#27674900)}.from-green-900{--gradient-from-color:#22543d;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#22543d00)}.from-teal-100{--gradient-from-color:#e6fffa;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#e6fffa00)}.from-teal-200{--gradient-from-color:#b2f5ea;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#b2f5ea00)}.from-teal-300{--gradient-from-color:#81e6d9;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#81e6d900)}.from-teal-400{--gradient-from-color:#4fd1c5;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#4fd1c500)}.from-teal-500{--gradient-from-color:#38b2ac;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#38b2ac00)}.from-teal-600{--gradient-from-color:#319795;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#31979500)}.from-teal-700{--gradient-from-color:#2c7a7b;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#2c7a7b00)}.from-teal-800{--gradient-from-color:#285e61;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#285e6100)}.from-teal-900{--gradient-from-color:#234e52;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#234e5200)}.from-blue-100{--gradient-from-color:#ebf8ff;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#ebf8ff00)}.from-blue-200{--gradient-from-color:#bee3f8;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#bee3f800)}.from-blue-300{--gradient-from-color:#90cdf4;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#90cdf400)}.from-blue-400{--gradient-from-color:#63b3ed;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#63b3ed00)}.from-blue-500{--gradient-from-color:#4299e1;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#4299e100)}.from-blue-600{--gradient-from-color:#3182ce;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#3182ce00)}.from-blue-700{--gradient-from-color:#2b6cb0;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#2b6cb000)}.from-blue-800{--gradient-from-color:#2c5282;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#2c528200)}.from-blue-900{--gradient-from-color:#2a4365;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#2a436500)}.from-indigo-100{--gradient-from-color:#ebf4ff;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#ebf4ff00)}.from-indigo-200{--gradient-from-color:#c3dafe;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#c3dafe00)}.from-indigo-300{--gradient-from-color:#a3bffa;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#a3bffa00)}.from-indigo-400{--gradient-from-color:#7f9cf5;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#7f9cf500)}.from-indigo-500{--gradient-from-color:#667eea;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#667eea00)}.from-indigo-600{--gradient-from-color:#5a67d8;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#5a67d800)}.from-indigo-700{--gradient-from-color:#4c51bf;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#4c51bf00)}.from-indigo-800{--gradient-from-color:#434190;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#43419000)}.from-indigo-900{--gradient-from-color:#3c366b;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#3c366b00)}.from-purple-100{--gradient-from-color:#faf5ff;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#faf5ff00)}.from-purple-200{--gradient-from-color:#e9d8fd;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#e9d8fd00)}.from-purple-300{--gradient-from-color:#d6bcfa;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#d6bcfa00)}.from-purple-400{--gradient-from-color:#b794f4;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#b794f400)}.from-purple-500{--gradient-from-color:#9f7aea;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#9f7aea00)}.from-purple-600{--gradient-from-color:#805ad5;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#805ad500)}.from-purple-700{--gradient-from-color:#6b46c1;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#6b46c100)}.from-purple-800{--gradient-from-color:#553c9a;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#553c9a00)}.from-purple-900{--gradient-from-color:#44337a;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#44337a00)}.from-pink-100{--gradient-from-color:#fff5f7;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#fff5f700)}.from-pink-200{--gradient-from-color:#fed7e2;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#fed7e200)}.from-pink-300{--gradient-from-color:#fbb6ce;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#fbb6ce00)}.from-pink-400{--gradient-from-color:#f687b3;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#f687b300)}.from-pink-500{--gradient-from-color:#ed64a6;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#ed64a600)}.from-pink-600{--gradient-from-color:#d53f8c;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#d53f8c00)}.from-pink-700{--gradient-from-color:#b83280;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#b8328000)}.from-pink-800{--gradient-from-color:#97266d;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#97266d00)}.from-pink-900{--gradient-from-color:#702459;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#70245900)}.via-transparent{--gradient-via-color:transparent;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#0000)}.via-current{--gradient-via-color:currentColor;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#fff0)}.via-black{--gradient-via-color:#000;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#0000)}.via-white{--gradient-via-color:#fff;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#fff0)}.via-gray-100{--gradient-via-color:#f7fafc;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#f7fafc00)}.via-gray-200{--gradient-via-color:#edf2f7;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#edf2f700)}.via-gray-300{--gradient-via-color:#e2e8f0;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#e2e8f000)}.via-gray-400{--gradient-via-color:#cbd5e0;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#cbd5e000)}.via-gray-500{--gradient-via-color:#a0aec0;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#a0aec000)}.via-gray-600{--gradient-via-color:#718096;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#71809600)}.via-gray-700{--gradient-via-color:#4a5568;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#4a556800)}.via-gray-800{--gradient-via-color:#2d3748;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#2d374800)}.via-gray-900{--gradient-via-color:#1a202c;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#1a202c00)}.via-red-100{--gradient-via-color:#fff5f5;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#fff5f500)}.via-red-200{--gradient-via-color:#fed7d7;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#fed7d700)}.via-red-300{--gradient-via-color:#feb2b2;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#feb2b200)}.via-red-400{--gradient-via-color:#fc8181;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#fc818100)}.via-red-500{--gradient-via-color:#f56565;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#f5656500)}.via-red-600{--gradient-via-color:#e53e3e;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#e53e3e00)}.via-red-700{--gradient-via-color:#c53030;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#c5303000)}.via-red-800{--gradient-via-color:#9b2c2c;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#9b2c2c00)}.via-red-900{--gradient-via-color:#742a2a;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#742a2a00)}.via-orange-100{--gradient-via-color:#fffaf0;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#fffaf000)}.via-orange-200{--gradient-via-color:#feebc8;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#feebc800)}.via-orange-300{--gradient-via-color:#fbd38d;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#fbd38d00)}.via-orange-400{--gradient-via-color:#f6ad55;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#f6ad5500)}.via-orange-500{--gradient-via-color:#ed8936;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#ed893600)}.via-orange-600{--gradient-via-color:#dd6b20;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#dd6b2000)}.via-orange-700{--gradient-via-color:#c05621;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#c0562100)}.via-orange-800{--gradient-via-color:#9c4221;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#9c422100)}.via-orange-900{--gradient-via-color:#7b341e;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#7b341e00)}.via-yellow-100{--gradient-via-color:ivory;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#fffff000)}.via-yellow-200{--gradient-via-color:#fefcbf;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#fefcbf00)}.via-yellow-300{--gradient-via-color:#faf089;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#faf08900)}.via-yellow-400{--gradient-via-color:#f6e05e;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#f6e05e00)}.via-yellow-500{--gradient-via-color:#ecc94b;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#ecc94b00)}.via-yellow-600{--gradient-via-color:#d69e2e;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#d69e2e00)}.via-yellow-700{--gradient-via-color:#b7791f;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#b7791f00)}.via-yellow-800{--gradient-via-color:#975a16;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#975a1600)}.via-yellow-900{--gradient-via-color:#744210;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#74421000)}.via-green-100{--gradient-via-color:#f0fff4;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#f0fff400)}.via-green-200{--gradient-via-color:#c6f6d5;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#c6f6d500)}.via-green-300{--gradient-via-color:#9ae6b4;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#9ae6b400)}.via-green-400{--gradient-via-color:#68d391;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#68d39100)}.via-green-500{--gradient-via-color:#48bb78;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#48bb7800)}.via-green-600{--gradient-via-color:#38a169;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#38a16900)}.via-green-700{--gradient-via-color:#2f855a;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#2f855a00)}.via-green-800{--gradient-via-color:#276749;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#27674900)}.via-green-900{--gradient-via-color:#22543d;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#22543d00)}.via-teal-100{--gradient-via-color:#e6fffa;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#e6fffa00)}.via-teal-200{--gradient-via-color:#b2f5ea;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#b2f5ea00)}.via-teal-300{--gradient-via-color:#81e6d9;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#81e6d900)}.via-teal-400{--gradient-via-color:#4fd1c5;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#4fd1c500)}.via-teal-500{--gradient-via-color:#38b2ac;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#38b2ac00)}.via-teal-600{--gradient-via-color:#319795;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#31979500)}.via-teal-700{--gradient-via-color:#2c7a7b;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#2c7a7b00)}.via-teal-800{--gradient-via-color:#285e61;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#285e6100)}.via-teal-900{--gradient-via-color:#234e52;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#234e5200)}.via-blue-100{--gradient-via-color:#ebf8ff;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#ebf8ff00)}.via-blue-200{--gradient-via-color:#bee3f8;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#bee3f800)}.via-blue-300{--gradient-via-color:#90cdf4;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#90cdf400)}.via-blue-400{--gradient-via-color:#63b3ed;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#63b3ed00)}.via-blue-500{--gradient-via-color:#4299e1;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#4299e100)}.via-blue-600{--gradient-via-color:#3182ce;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#3182ce00)}.via-blue-700{--gradient-via-color:#2b6cb0;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#2b6cb000)}.via-blue-800{--gradient-via-color:#2c5282;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#2c528200)}.via-blue-900{--gradient-via-color:#2a4365;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#2a436500)}.via-indigo-100{--gradient-via-color:#ebf4ff;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#ebf4ff00)}.via-indigo-200{--gradient-via-color:#c3dafe;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#c3dafe00)}.via-indigo-300{--gradient-via-color:#a3bffa;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#a3bffa00)}.via-indigo-400{--gradient-via-color:#7f9cf5;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#7f9cf500)}.via-indigo-500{--gradient-via-color:#667eea;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#667eea00)}.via-indigo-600{--gradient-via-color:#5a67d8;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#5a67d800)}.via-indigo-700{--gradient-via-color:#4c51bf;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#4c51bf00)}.via-indigo-800{--gradient-via-color:#434190;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#43419000)}.via-indigo-900{--gradient-via-color:#3c366b;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#3c366b00)}.via-purple-100{--gradient-via-color:#faf5ff;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#faf5ff00)}.via-purple-200{--gradient-via-color:#e9d8fd;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#e9d8fd00)}.via-purple-300{--gradient-via-color:#d6bcfa;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#d6bcfa00)}.via-purple-400{--gradient-via-color:#b794f4;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#b794f400)}.via-purple-500{--gradient-via-color:#9f7aea;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#9f7aea00)}.via-purple-600{--gradient-via-color:#805ad5;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#805ad500)}.via-purple-700{--gradient-via-color:#6b46c1;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#6b46c100)}.via-purple-800{--gradient-via-color:#553c9a;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#553c9a00)}.via-purple-900{--gradient-via-color:#44337a;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#44337a00)}.via-pink-100{--gradient-via-color:#fff5f7;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#fff5f700)}.via-pink-200{--gradient-via-color:#fed7e2;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#fed7e200)}.via-pink-300{--gradient-via-color:#fbb6ce;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#fbb6ce00)}.via-pink-400{--gradient-via-color:#f687b3;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#f687b300)}.via-pink-500{--gradient-via-color:#ed64a6;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#ed64a600)}.via-pink-600{--gradient-via-color:#d53f8c;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#d53f8c00)}.via-pink-700{--gradient-via-color:#b83280;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#b8328000)}.via-pink-800{--gradient-via-color:#97266d;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#97266d00)}.via-pink-900{--gradient-via-color:#702459;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#70245900)}.to-transparent{--gradient-to-color:transparent}.to-current{--gradient-to-color:currentColor}.to-black{--gradient-to-color:#000}.to-white{--gradient-to-color:#fff}.to-gray-100{--gradient-to-color:#f7fafc}.to-gray-200{--gradient-to-color:#edf2f7}.to-gray-300{--gradient-to-color:#e2e8f0}.to-gray-400{--gradient-to-color:#cbd5e0}.to-gray-500{--gradient-to-color:#a0aec0}.to-gray-600{--gradient-to-color:#718096}.to-gray-700{--gradient-to-color:#4a5568}.to-gray-800{--gradient-to-color:#2d3748}.to-gray-900{--gradient-to-color:#1a202c}.to-red-100{--gradient-to-color:#fff5f5}.to-red-200{--gradient-to-color:#fed7d7}.to-red-300{--gradient-to-color:#feb2b2}.to-red-400{--gradient-to-color:#fc8181}.to-red-500{--gradient-to-color:#f56565}.to-red-600{--gradient-to-color:#e53e3e}.to-red-700{--gradient-to-color:#c53030}.to-red-800{--gradient-to-color:#9b2c2c}.to-red-900{--gradient-to-color:#742a2a}.to-orange-100{--gradient-to-color:#fffaf0}.to-orange-200{--gradient-to-color:#feebc8}.to-orange-300{--gradient-to-color:#fbd38d}.to-orange-400{--gradient-to-color:#f6ad55}.to-orange-500{--gradient-to-color:#ed8936}.to-orange-600{--gradient-to-color:#dd6b20}.to-orange-700{--gradient-to-color:#c05621}.to-orange-800{--gradient-to-color:#9c4221}.to-orange-900{--gradient-to-color:#7b341e}.to-yellow-100{--gradient-to-color:ivory}.to-yellow-200{--gradient-to-color:#fefcbf}.to-yellow-300{--gradient-to-color:#faf089}.to-yellow-400{--gradient-to-color:#f6e05e}.to-yellow-500{--gradient-to-color:#ecc94b}.to-yellow-600{--gradient-to-color:#d69e2e}.to-yellow-700{--gradient-to-color:#b7791f}.to-yellow-800{--gradient-to-color:#975a16}.to-yellow-900{--gradient-to-color:#744210}.to-green-100{--gradient-to-color:#f0fff4}.to-green-200{--gradient-to-color:#c6f6d5}.to-green-300{--gradient-to-color:#9ae6b4}.to-green-400{--gradient-to-color:#68d391}.to-green-500{--gradient-to-color:#48bb78}.to-green-600{--gradient-to-color:#38a169}.to-green-700{--gradient-to-color:#2f855a}.to-green-800{--gradient-to-color:#276749}.to-green-900{--gradient-to-color:#22543d}.to-teal-100{--gradient-to-color:#e6fffa}.to-teal-200{--gradient-to-color:#b2f5ea}.to-teal-300{--gradient-to-color:#81e6d9}.to-teal-400{--gradient-to-color:#4fd1c5}.to-teal-500{--gradient-to-color:#38b2ac}.to-teal-600{--gradient-to-color:#319795}.to-teal-700{--gradient-to-color:#2c7a7b}.to-teal-800{--gradient-to-color:#285e61}.to-teal-900{--gradient-to-color:#234e52}.to-blue-100{--gradient-to-color:#ebf8ff}.to-blue-200{--gradient-to-color:#bee3f8}.to-blue-300{--gradient-to-color:#90cdf4}.to-blue-400{--gradient-to-color:#63b3ed}.to-blue-500{--gradient-to-color:#4299e1}.to-blue-600{--gradient-to-color:#3182ce}.to-blue-700{--gradient-to-color:#2b6cb0}.to-blue-800{--gradient-to-color:#2c5282}.to-blue-900{--gradient-to-color:#2a4365}.to-indigo-100{--gradient-to-color:#ebf4ff}.to-indigo-200{--gradient-to-color:#c3dafe}.to-indigo-300{--gradient-to-color:#a3bffa}.to-indigo-400{--gradient-to-color:#7f9cf5}.to-indigo-500{--gradient-to-color:#667eea}.to-indigo-600{--gradient-to-color:#5a67d8}.to-indigo-700{--gradient-to-color:#4c51bf}.to-indigo-800{--gradient-to-color:#434190}.to-indigo-900{--gradient-to-color:#3c366b}.to-purple-100{--gradient-to-color:#faf5ff}.to-purple-200{--gradient-to-color:#e9d8fd}.to-purple-300{--gradient-to-color:#d6bcfa}.to-purple-400{--gradient-to-color:#b794f4}.to-purple-500{--gradient-to-color:#9f7aea}.to-purple-600{--gradient-to-color:#805ad5}.to-purple-700{--gradient-to-color:#6b46c1}.to-purple-800{--gradient-to-color:#553c9a}.to-purple-900{--gradient-to-color:#44337a}.to-pink-100{--gradient-to-color:#fff5f7}.to-pink-200{--gradient-to-color:#fed7e2}.to-pink-300{--gradient-to-color:#fbb6ce}.to-pink-400{--gradient-to-color:#f687b3}.to-pink-500{--gradient-to-color:#ed64a6}.to-pink-600{--gradient-to-color:#d53f8c}.to-pink-700{--gradient-to-color:#b83280}.to-pink-800{--gradient-to-color:#97266d}.to-pink-900{--gradient-to-color:#702459}.hover\:from-transparent:hover{--gradient-from-color:transparent;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#0000)}.hover\:from-current:hover{--gradient-from-color:currentColor;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#fff0)}.hover\:from-black:hover{--gradient-from-color:#000;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#0000)}.hover\:from-white:hover{--gradient-from-color:#fff;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#fff0)}.hover\:from-gray-100:hover{--gradient-from-color:#f7fafc;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#f7fafc00)}.hover\:from-gray-200:hover{--gradient-from-color:#edf2f7;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#edf2f700)}.hover\:from-gray-300:hover{--gradient-from-color:#e2e8f0;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#e2e8f000)}.hover\:from-gray-400:hover{--gradient-from-color:#cbd5e0;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#cbd5e000)}.hover\:from-gray-500:hover{--gradient-from-color:#a0aec0;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#a0aec000)}.hover\:from-gray-600:hover{--gradient-from-color:#718096;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#71809600)}.hover\:from-gray-700:hover{--gradient-from-color:#4a5568;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#4a556800)}.hover\:from-gray-800:hover{--gradient-from-color:#2d3748;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#2d374800)}.hover\:from-gray-900:hover{--gradient-from-color:#1a202c;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#1a202c00)}.hover\:from-red-100:hover{--gradient-from-color:#fff5f5;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#fff5f500)}.hover\:from-red-200:hover{--gradient-from-color:#fed7d7;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#fed7d700)}.hover\:from-red-300:hover{--gradient-from-color:#feb2b2;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#feb2b200)}.hover\:from-red-400:hover{--gradient-from-color:#fc8181;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#fc818100)}.hover\:from-red-500:hover{--gradient-from-color:#f56565;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#f5656500)}.hover\:from-red-600:hover{--gradient-from-color:#e53e3e;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#e53e3e00)}.hover\:from-red-700:hover{--gradient-from-color:#c53030;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#c5303000)}.hover\:from-red-800:hover{--gradient-from-color:#9b2c2c;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#9b2c2c00)}.hover\:from-red-900:hover{--gradient-from-color:#742a2a;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#742a2a00)}.hover\:from-orange-100:hover{--gradient-from-color:#fffaf0;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#fffaf000)}.hover\:from-orange-200:hover{--gradient-from-color:#feebc8;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#feebc800)}.hover\:from-orange-300:hover{--gradient-from-color:#fbd38d;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#fbd38d00)}.hover\:from-orange-400:hover{--gradient-from-color:#f6ad55;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#f6ad5500)}.hover\:from-orange-500:hover{--gradient-from-color:#ed8936;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#ed893600)}.hover\:from-orange-600:hover{--gradient-from-color:#dd6b20;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#dd6b2000)}.hover\:from-orange-700:hover{--gradient-from-color:#c05621;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#c0562100)}.hover\:from-orange-800:hover{--gradient-from-color:#9c4221;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#9c422100)}.hover\:from-orange-900:hover{--gradient-from-color:#7b341e;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#7b341e00)}.hover\:from-yellow-100:hover{--gradient-from-color:ivory;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#fffff000)}.hover\:from-yellow-200:hover{--gradient-from-color:#fefcbf;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#fefcbf00)}.hover\:from-yellow-300:hover{--gradient-from-color:#faf089;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#faf08900)}.hover\:from-yellow-400:hover{--gradient-from-color:#f6e05e;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#f6e05e00)}.hover\:from-yellow-500:hover{--gradient-from-color:#ecc94b;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#ecc94b00)}.hover\:from-yellow-600:hover{--gradient-from-color:#d69e2e;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#d69e2e00)}.hover\:from-yellow-700:hover{--gradient-from-color:#b7791f;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#b7791f00)}.hover\:from-yellow-800:hover{--gradient-from-color:#975a16;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#975a1600)}.hover\:from-yellow-900:hover{--gradient-from-color:#744210;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#74421000)}.hover\:from-green-100:hover{--gradient-from-color:#f0fff4;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#f0fff400)}.hover\:from-green-200:hover{--gradient-from-color:#c6f6d5;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#c6f6d500)}.hover\:from-green-300:hover{--gradient-from-color:#9ae6b4;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#9ae6b400)}.hover\:from-green-400:hover{--gradient-from-color:#68d391;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#68d39100)}.hover\:from-green-500:hover{--gradient-from-color:#48bb78;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#48bb7800)}.hover\:from-green-600:hover{--gradient-from-color:#38a169;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#38a16900)}.hover\:from-green-700:hover{--gradient-from-color:#2f855a;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#2f855a00)}.hover\:from-green-800:hover{--gradient-from-color:#276749;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#27674900)}.hover\:from-green-900:hover{--gradient-from-color:#22543d;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#22543d00)}.hover\:from-teal-100:hover{--gradient-from-color:#e6fffa;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#e6fffa00)}.hover\:from-teal-200:hover{--gradient-from-color:#b2f5ea;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#b2f5ea00)}.hover\:from-teal-300:hover{--gradient-from-color:#81e6d9;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#81e6d900)}.hover\:from-teal-400:hover{--gradient-from-color:#4fd1c5;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#4fd1c500)}.hover\:from-teal-500:hover{--gradient-from-color:#38b2ac;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#38b2ac00)}.hover\:from-teal-600:hover{--gradient-from-color:#319795;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#31979500)}.hover\:from-teal-700:hover{--gradient-from-color:#2c7a7b;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#2c7a7b00)}.hover\:from-teal-800:hover{--gradient-from-color:#285e61;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#285e6100)}.hover\:from-teal-900:hover{--gradient-from-color:#234e52;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#234e5200)}.hover\:from-blue-100:hover{--gradient-from-color:#ebf8ff;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#ebf8ff00)}.hover\:from-blue-200:hover{--gradient-from-color:#bee3f8;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#bee3f800)}.hover\:from-blue-300:hover{--gradient-from-color:#90cdf4;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#90cdf400)}.hover\:from-blue-400:hover{--gradient-from-color:#63b3ed;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#63b3ed00)}.hover\:from-blue-500:hover{--gradient-from-color:#4299e1;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#4299e100)}.hover\:from-blue-600:hover{--gradient-from-color:#3182ce;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#3182ce00)}.hover\:from-blue-700:hover{--gradient-from-color:#2b6cb0;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#2b6cb000)}.hover\:from-blue-800:hover{--gradient-from-color:#2c5282;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#2c528200)}.hover\:from-blue-900:hover{--gradient-from-color:#2a4365;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#2a436500)}.hover\:from-indigo-100:hover{--gradient-from-color:#ebf4ff;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#ebf4ff00)}.hover\:from-indigo-200:hover{--gradient-from-color:#c3dafe;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#c3dafe00)}.hover\:from-indigo-300:hover{--gradient-from-color:#a3bffa;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#a3bffa00)}.hover\:from-indigo-400:hover{--gradient-from-color:#7f9cf5;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#7f9cf500)}.hover\:from-indigo-500:hover{--gradient-from-color:#667eea;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#667eea00)}.hover\:from-indigo-600:hover{--gradient-from-color:#5a67d8;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#5a67d800)}.hover\:from-indigo-700:hover{--gradient-from-color:#4c51bf;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#4c51bf00)}.hover\:from-indigo-800:hover{--gradient-from-color:#434190;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#43419000)}.hover\:from-indigo-900:hover{--gradient-from-color:#3c366b;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#3c366b00)}.hover\:from-purple-100:hover{--gradient-from-color:#faf5ff;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#faf5ff00)}.hover\:from-purple-200:hover{--gradient-from-color:#e9d8fd;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#e9d8fd00)}.hover\:from-purple-300:hover{--gradient-from-color:#d6bcfa;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#d6bcfa00)}.hover\:from-purple-400:hover{--gradient-from-color:#b794f4;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#b794f400)}.hover\:from-purple-500:hover{--gradient-from-color:#9f7aea;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#9f7aea00)}.hover\:from-purple-600:hover{--gradient-from-color:#805ad5;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#805ad500)}.hover\:from-purple-700:hover{--gradient-from-color:#6b46c1;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#6b46c100)}.hover\:from-purple-800:hover{--gradient-from-color:#553c9a;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#553c9a00)}.hover\:from-purple-900:hover{--gradient-from-color:#44337a;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#44337a00)}.hover\:from-pink-100:hover{--gradient-from-color:#fff5f7;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#fff5f700)}.hover\:from-pink-200:hover{--gradient-from-color:#fed7e2;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#fed7e200)}.hover\:from-pink-300:hover{--gradient-from-color:#fbb6ce;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#fbb6ce00)}.hover\:from-pink-400:hover{--gradient-from-color:#f687b3;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#f687b300)}.hover\:from-pink-500:hover{--gradient-from-color:#ed64a6;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#ed64a600)}.hover\:from-pink-600:hover{--gradient-from-color:#d53f8c;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#d53f8c00)}.hover\:from-pink-700:hover{--gradient-from-color:#b83280;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#b8328000)}.hover\:from-pink-800:hover{--gradient-from-color:#97266d;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#97266d00)}.hover\:from-pink-900:hover{--gradient-from-color:#702459;--gradient-color-stops:var(--gradient-from-color),var(--gradient-to-color,#70245900)}.hover\:via-transparent:hover{--gradient-via-color:transparent;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#0000)}.hover\:via-current:hover{--gradient-via-color:currentColor;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#fff0)}.hover\:via-black:hover{--gradient-via-color:#000;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#0000)}.hover\:via-white:hover{--gradient-via-color:#fff;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#fff0)}.hover\:via-gray-100:hover{--gradient-via-color:#f7fafc;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#f7fafc00)}.hover\:via-gray-200:hover{--gradient-via-color:#edf2f7;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#edf2f700)}.hover\:via-gray-300:hover{--gradient-via-color:#e2e8f0;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#e2e8f000)}.hover\:via-gray-400:hover{--gradient-via-color:#cbd5e0;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#cbd5e000)}.hover\:via-gray-500:hover{--gradient-via-color:#a0aec0;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#a0aec000)}.hover\:via-gray-600:hover{--gradient-via-color:#718096;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#71809600)}.hover\:via-gray-700:hover{--gradient-via-color:#4a5568;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#4a556800)}.hover\:via-gray-800:hover{--gradient-via-color:#2d3748;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#2d374800)}.hover\:via-gray-900:hover{--gradient-via-color:#1a202c;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#1a202c00)}.hover\:via-red-100:hover{--gradient-via-color:#fff5f5;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#fff5f500)}.hover\:via-red-200:hover{--gradient-via-color:#fed7d7;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#fed7d700)}.hover\:via-red-300:hover{--gradient-via-color:#feb2b2;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#feb2b200)}.hover\:via-red-400:hover{--gradient-via-color:#fc8181;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#fc818100)}.hover\:via-red-500:hover{--gradient-via-color:#f56565;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#f5656500)}.hover\:via-red-600:hover{--gradient-via-color:#e53e3e;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#e53e3e00)}.hover\:via-red-700:hover{--gradient-via-color:#c53030;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#c5303000)}.hover\:via-red-800:hover{--gradient-via-color:#9b2c2c;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#9b2c2c00)}.hover\:via-red-900:hover{--gradient-via-color:#742a2a;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#742a2a00)}.hover\:via-orange-100:hover{--gradient-via-color:#fffaf0;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#fffaf000)}.hover\:via-orange-200:hover{--gradient-via-color:#feebc8;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#feebc800)}.hover\:via-orange-300:hover{--gradient-via-color:#fbd38d;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#fbd38d00)}.hover\:via-orange-400:hover{--gradient-via-color:#f6ad55;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#f6ad5500)}.hover\:via-orange-500:hover{--gradient-via-color:#ed8936;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#ed893600)}.hover\:via-orange-600:hover{--gradient-via-color:#dd6b20;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#dd6b2000)}.hover\:via-orange-700:hover{--gradient-via-color:#c05621;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#c0562100)}.hover\:via-orange-800:hover{--gradient-via-color:#9c4221;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#9c422100)}.hover\:via-orange-900:hover{--gradient-via-color:#7b341e;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#7b341e00)}.hover\:via-yellow-100:hover{--gradient-via-color:ivory;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#fffff000)}.hover\:via-yellow-200:hover{--gradient-via-color:#fefcbf;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#fefcbf00)}.hover\:via-yellow-300:hover{--gradient-via-color:#faf089;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#faf08900)}.hover\:via-yellow-400:hover{--gradient-via-color:#f6e05e;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#f6e05e00)}.hover\:via-yellow-500:hover{--gradient-via-color:#ecc94b;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#ecc94b00)}.hover\:via-yellow-600:hover{--gradient-via-color:#d69e2e;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#d69e2e00)}.hover\:via-yellow-700:hover{--gradient-via-color:#b7791f;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#b7791f00)}.hover\:via-yellow-800:hover{--gradient-via-color:#975a16;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#975a1600)}.hover\:via-yellow-900:hover{--gradient-via-color:#744210;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#74421000)}.hover\:via-green-100:hover{--gradient-via-color:#f0fff4;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#f0fff400)}.hover\:via-green-200:hover{--gradient-via-color:#c6f6d5;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#c6f6d500)}.hover\:via-green-300:hover{--gradient-via-color:#9ae6b4;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#9ae6b400)}.hover\:via-green-400:hover{--gradient-via-color:#68d391;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#68d39100)}.hover\:via-green-500:hover{--gradient-via-color:#48bb78;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#48bb7800)}.hover\:via-green-600:hover{--gradient-via-color:#38a169;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#38a16900)}.hover\:via-green-700:hover{--gradient-via-color:#2f855a;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#2f855a00)}.hover\:via-green-800:hover{--gradient-via-color:#276749;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#27674900)}.hover\:via-green-900:hover{--gradient-via-color:#22543d;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#22543d00)}.hover\:via-teal-100:hover{--gradient-via-color:#e6fffa;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#e6fffa00)}.hover\:via-teal-200:hover{--gradient-via-color:#b2f5ea;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#b2f5ea00)}.hover\:via-teal-300:hover{--gradient-via-color:#81e6d9;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#81e6d900)}.hover\:via-teal-400:hover{--gradient-via-color:#4fd1c5;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#4fd1c500)}.hover\:via-teal-500:hover{--gradient-via-color:#38b2ac;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#38b2ac00)}.hover\:via-teal-600:hover{--gradient-via-color:#319795;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#31979500)}.hover\:via-teal-700:hover{--gradient-via-color:#2c7a7b;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#2c7a7b00)}.hover\:via-teal-800:hover{--gradient-via-color:#285e61;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#285e6100)}.hover\:via-teal-900:hover{--gradient-via-color:#234e52;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#234e5200)}.hover\:via-blue-100:hover{--gradient-via-color:#ebf8ff;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#ebf8ff00)}.hover\:via-blue-200:hover{--gradient-via-color:#bee3f8;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#bee3f800)}.hover\:via-blue-300:hover{--gradient-via-color:#90cdf4;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#90cdf400)}.hover\:via-blue-400:hover{--gradient-via-color:#63b3ed;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#63b3ed00)}.hover\:via-blue-500:hover{--gradient-via-color:#4299e1;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#4299e100)}.hover\:via-blue-600:hover{--gradient-via-color:#3182ce;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#3182ce00)}.hover\:via-blue-700:hover{--gradient-via-color:#2b6cb0;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#2b6cb000)}.hover\:via-blue-800:hover{--gradient-via-color:#2c5282;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#2c528200)}.hover\:via-blue-900:hover{--gradient-via-color:#2a4365;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#2a436500)}.hover\:via-indigo-100:hover{--gradient-via-color:#ebf4ff;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#ebf4ff00)}.hover\:via-indigo-200:hover{--gradient-via-color:#c3dafe;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#c3dafe00)}.hover\:via-indigo-300:hover{--gradient-via-color:#a3bffa;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#a3bffa00)}.hover\:via-indigo-400:hover{--gradient-via-color:#7f9cf5;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#7f9cf500)}.hover\:via-indigo-500:hover{--gradient-via-color:#667eea;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#667eea00)}.hover\:via-indigo-600:hover{--gradient-via-color:#5a67d8;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#5a67d800)}.hover\:via-indigo-700:hover{--gradient-via-color:#4c51bf;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#4c51bf00)}.hover\:via-indigo-800:hover{--gradient-via-color:#434190;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#43419000)}.hover\:via-indigo-900:hover{--gradient-via-color:#3c366b;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#3c366b00)}.hover\:via-purple-100:hover{--gradient-via-color:#faf5ff;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#faf5ff00)}.hover\:via-purple-200:hover{--gradient-via-color:#e9d8fd;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#e9d8fd00)}.hover\:via-purple-300:hover{--gradient-via-color:#d6bcfa;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#d6bcfa00)}.hover\:via-purple-400:hover{--gradient-via-color:#b794f4;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#b794f400)}.hover\:via-purple-500:hover{--gradient-via-color:#9f7aea;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#9f7aea00)}.hover\:via-purple-600:hover{--gradient-via-color:#805ad5;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#805ad500)}.hover\:via-purple-700:hover{--gradient-via-color:#6b46c1;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#6b46c100)}.hover\:via-purple-800:hover{--gradient-via-color:#553c9a;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#553c9a00)}.hover\:via-purple-900:hover{--gradient-via-color:#44337a;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#44337a00)}.hover\:via-pink-100:hover{--gradient-via-color:#fff5f7;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#fff5f700)}.hover\:via-pink-200:hover{--gradient-via-color:#fed7e2;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#fed7e200)}.hover\:via-pink-300:hover{--gradient-via-color:#fbb6ce;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#fbb6ce00)}.hover\:via-pink-400:hover{--gradient-via-color:#f687b3;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#f687b300)}.hover\:via-pink-500:hover{--gradient-via-color:#ed64a6;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#ed64a600)}.hover\:via-pink-600:hover{--gradient-via-color:#d53f8c;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#d53f8c00)}.hover\:via-pink-700:hover{--gradient-via-color:#b83280;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#b8328000)}.hover\:via-pink-800:hover{--gradient-via-color:#97266d;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#97266d00)}.hover\:via-pink-900:hover{--gradient-via-color:#702459;--gradient-color-stops:var(--gradient-from-color),var(--gradient-via-color),var(--gradient-to-color,#70245900)}.hover\:to-transparent:hover{--gradient-to-color:transparent}.hover\:to-current:hover{--gradient-to-color:currentColor}.hover\:to-black:hover{--gradient-to-color:#000}.hover\:to-white:hover{--gradient-to-color:#fff}.hover\:to-gray-100:hover{--gradient-to-color:#f7fafc}.hover\:to-gray-200:hover{--gradient-to-color:#edf2f7}.hover\:to-gray-300:hover{--gradient-to-color:#e2e8f0}.hover\:to-gray-400:hover{--gradient-to-color:#cbd5e0}.hover\:to-gray-500:hover{--gradient-to-color:#a0aec0}.hover\:to-gray-600:hover{--gradient-to-color:#718096}.hover\:to-gray-700:hover{--gradient-to-color:#4a5568}.hover\:to-gray-800:hover{--gradient-to-color:#2d3748}.hover\:to-gray-900:hover{--gradient-to-color:#1a202c}.hover\:to-red-100:hover{--gradient-to-color:#fff5f5}.hover\:to-red-200:hover{--gradient-to-color:#fed7d7}.hover\:to-red-300:hover{--gradient-to-color:#feb2b2}.hover\:to-red-400:hover{--gradient-to-color:#fc8181}.hover\:to-red-500:hover{--gradient-to-color:#f56565}.hover\:to-red-600:hover{--gradient-to-color:#e53e3e}.hover\:to-red-700:hover{--gradient-to-color:#c53030}.hover\:to-red-800:hover{--gradient-to-color:#9b2c2c}.hover\:to-red-900:hover{--gradient-to-color:#742a2a}.hover\:to-orange-100:hover{--gradient-to-color:#fffaf0}.hover\:to-orange-200:hover{--gradient-to-color:#feebc8}.hover\:to-orange-300:hover{--gradient-to-color:#fbd38d}.hover\:to-orange-400:hover{--gradient-to-color:#f6ad55}.hover\:to-orange-500:hover{--gradient-to-color:#ed8936}.hover\:to-orange-600:hover{--gradient-to-color:#dd6b20}.hover\:to-orange-700:hover{--gradient-to-color:#c05621}.hover\:to-orange-800:hover{--gradient-to-color:#9c4221}.hover\:to-orange-900:hover{--gradient-to-color:#7b341e}.hover\:to-yellow-100:hover{--gradient-to-color:ivory}.hover\:to-yellow-200:hover{--gradient-to-color:#fefcbf}.hover\:to-yellow-300:hover{--gradient-to-color:#faf089}.hover\:to-yellow-400:hover{--gradient-to-color:#f6e05e}.hover\:to-yellow-500:hover{--gradient-to-color:#ecc94b}.hover\:to-yellow-600:hover{--gradient-to-color:#d69e2e}.hover\:to-yellow-700:hover{--gradient-to-color:#b7791f}.hover\:to-yellow-800:hover{--gradient-to-color:#975a16}.hover\:to-yellow-900:hover{--gradient-to-color:#744210}.hover\:to-green-100:hover{--gradient-to-color:#f0fff4}.hover\:to-green-200:hover{--gradient-to-color:#c6f6d5}.hover\:to-green-300:hover{--gradient-to-color:#9ae6b4}.hover\:to-green-400:hover{--gradient-to-color:#68d391}
\ No newline at end of file
diff --git a/test/js/bun/css/files/trainer-gallery-holo.css b/test/js/bun/css/files/trainer-gallery-holo.css
new file mode 100644
index 0000000000..96cfe529f1
--- /dev/null
+++ b/test/js/bun/css/files/trainer-gallery-holo.css
@@ -0,0 +1,117 @@
+/*
+
+  TRAINER GALLERY HOLO
+
+*/
+
+
+
+
+
+
+
+/*
+
+  SHINE LAYERS
+
+*/
+
+.card[data-rarity="trainer gallery rare holo"] .card__shine,
+.card[data-rarity="rare holo"][data-trainer-gallery="true"] .card__shine,
+.card[data-set="swshp"][data-number="swsh020"] .card__shine {
+
+  --space: 5%;
+  --angle: -22deg;
+  --imgsize: 300% 400%;
+
+  clip-path: var(--clip-borders);
+
+  background-image:
+    repeating-linear-gradient( var(--angle),  
+      hsla(283, 49%, 60%, 0.75) calc(var(--space)*1),
+      hsla(2, 74%, 59%, 0.75) calc(var(--space)*2), 
+      hsla(53, 67%, 53%, 0.75) calc(var(--space)*3),  
+      hsla(93, 56%, 52%, 0.75) calc(var(--space)*4),  
+      hsla(176, 38%, 50%, 0.75) calc(var(--space)*5),  
+      hsla(228, 100%, 77%, 0.75) calc(var(--space)*6), 
+      hsla(283, 49%, 61%, 0.75) calc(var(--space)*7)
+    );
+    
+    background-blend-mode: color-dodge;
+    background-size: var(--imgsize);
+    background-position: 0% calc(var(--background-y) * 1), var(--background-x) var(--background-y);
+    
+    filter: brightness(calc((var(--pointer-from-center)*0.3) + 0.5)) contrast(2.3) saturate(1);
+
+}
+
+.card[data-rarity="trainer gallery rare holo"] .card__shine:after,
+.card[data-rarity="rare holo"][data-trainer-gallery="true"] .card__shine:after,
+.card[data-set="swshp"][data-number="swsh020"] .card__shine:after {
+  
+  content: "";
+
+  background-image: 
+    radial-gradient( 
+      farthest-corner ellipse 
+      at calc( ((var(--pointer-x)) * 0.5) + 25% ) calc( ((var(--pointer-y)) * 0.5) + 25% ), 
+      hsl(0, 0%, 100%) 5%, 
+      hsla(300, 100%, 11%, 0.6) 40%, 
+      hsl(0, 0%, 22%) 120% 
+    );
+
+  background-position: center center;
+  background-size: 400% 500%;
+
+  filter: brightness(calc((var(--pointer-from-center)*0.2) + 0.4)) contrast(.85) saturate(1.1);
+  mix-blend-mode: hard-light;
+
+}
+
+.card[data-rarity="trainer gallery rare holo"] .card__shine:before,
+.card[data-rarity="rare holo"][data-trainer-gallery="true"] .card__shine:before,
+.card[data-set="swshp"][data-number="swsh020"] .card__shine:before {
+  content: none;
+  display: none;
+}
+
+
+
+
+
+
+
+
+
+
+
+/*
+
+  GLARE LAYERS
+
+*/
+
+.card[data-rarity="trainer gallery rare holo"] .card__glare,
+.card[data-rarity="rare holo"][data-trainer-gallery="true"] .card__glare,
+.card[data-set="swshp"][data-number="swsh020"] .card__glare {
+
+  background-image: 
+    radial-gradient( 
+      farthest-corner circle at var(--pointer-x) var(--pointer-y), 
+      hsla(0, 0%, 100%, 1) 10%, 
+      hsla(0, 0%, 100%, 0.6) 35%, 
+      hsla(180, 11%, 35%, 1) 60% 
+    );
+
+  mix-blend-mode: soft-light;
+
+}
+
+
+.card[data-rarity="trainer gallery rare holo"] .card__glare:before,
+.card[data-rarity="rare holo"][data-trainer-gallery="true"] .card__glare:before,
+.card[data-rarity="trainer gallery rare holo"] .card__glare:after,
+.card[data-rarity="rare holo"][data-trainer-gallery="true"] .card__glare:after {
+  content: none;
+  display: none;
+}
\ No newline at end of file
diff --git a/test/js/bun/css/files/uikit.css b/test/js/bun/css/files/uikit.css
new file mode 100644
index 0000000000..2ca63a0b7e
--- /dev/null
+++ b/test/js/bun/css/files/uikit.css
@@ -0,0 +1,12967 @@
+/*! UIkit 3.21.13 | https://www.getuikit.com | (c) 2014 - 2024 YOOtheme | MIT License */
+/* ========================================================================
+   Component: Base
+ ========================================================================== */
+/*
+ * 1. Set `font-size` to support `rem` units
+ * 2. Prevent adjustments of font size after orientation changes in iOS.
+ * 3. Style
+ */
+ html {
+  /* 1 */
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+  font-size: 16px;
+  font-weight: normal;
+  line-height: 1.5;
+  /* 2 */
+  -webkit-text-size-adjust: 100%;
+  /* 3 */
+  background: #fff;
+  color: #666;
+}
+/*
+ * Remove the margin in all browsers.
+ */
+body {
+  margin: 0;
+}
+/* Links
+ ========================================================================== */
+/*
+ * Style
+ */
+a,
+.uk-link {
+  color: #1e87f0;
+  text-decoration: none;
+  cursor: pointer;
+}
+a:hover,
+.uk-link:hover,
+.uk-link-toggle:hover .uk-link {
+  color: #0f6ecd;
+  text-decoration: underline;
+}
+/* Text-level semantics
+ ========================================================================== */
+/*
+ * 1. Add the correct text decoration in Edge.
+ * 2. The shorthand declaration `underline dotted` is not supported in Safari.
+ */
+abbr[title] {
+  /* 1 */
+  text-decoration: underline dotted;
+  /* 2 */
+  -webkit-text-decoration-style: dotted;
+}
+/*
+ * Add the correct font weight in Chrome, Edge, and Safari.
+ */
+b,
+strong {
+  font-weight: bolder;
+}
+/*
+ * 1. Consolas has a better baseline in running text compared to `Courier`
+ * 2. Correct the odd `em` font sizing in all browsers.
+ * 3. Style
+ */
+:not(pre) > code,
+:not(pre) > kbd,
+:not(pre) > samp {
+  /* 1 */
+  font-family: Consolas, monaco, monospace;
+  /* 2 */
+  font-size: 0.875rem;
+  /* 3 */
+  color: #f0506e;
+  white-space: nowrap;
+  padding: 2px 6px;
+  background: #f8f8f8;
+}
+/*
+ * Emphasize
+ */
+em {
+  color: #f0506e;
+}
+/*
+ * Insert
+ */
+ins {
+  background: #ffd;
+  color: #666;
+  text-decoration: none;
+}
+/*
+ * Mark
+ */
+mark {
+  background: #ffd;
+  color: #666;
+}
+/*
+ * Quote
+ */
+q {
+  font-style: italic;
+}
+/*
+ * Add the correct font size in all browsers.
+ */
+small {
+  font-size: 80%;
+}
+/*
+ * Prevents `sub` and `sup` affecting `line-height` in all browsers.
+ */
+sub,
+sup {
+  font-size: 75%;
+  line-height: 0;
+  position: relative;
+  vertical-align: baseline;
+}
+sup {
+  top: -0.5em;
+}
+sub {
+  bottom: -0.25em;
+}
+/* Embedded content
+ ========================================================================== */
+/*
+ * Remove the gap between the element and the bottom of its parent container.
+ */
+audio,
+canvas,
+iframe,
+img,
+svg,
+video {
+  vertical-align: middle;
+}
+/*
+ * 1. Constrain the element to its parent width.
+ * 2. Preserve the intrinsic aspect ratio and auto-scale the height of an image if the `height` attribute is present.
+ * 3. Take border and padding into account.
+ */
+canvas,
+img,
+svg,
+video {
+  /* 1 */
+  max-width: 100%;
+  /* 2 */
+  height: auto;
+  /* 3 */
+  box-sizing: border-box;
+}
+/*
+ * Deprecated: only needed for `img` elements with `uk-img`
+ * 1. Hide `alt` text for lazy load images.
+ * 2. Fix lazy loading images if parent element is set to `display: inline` and has `overflow: hidden`.
+ */
+img:not([src]) {
+  /* 1 */
+  visibility: hidden;
+  /* 2 */
+  min-width: 1px;
+}
+/*
+ * Iframe
+ * Remove border in all browsers
+ */
+iframe {
+  border: 0;
+}
+/* Block elements
+ ========================================================================== */
+/*
+ * Margins
+ */
+p,
+ul,
+ol,
+dl,
+pre,
+address,
+fieldset,
+figure {
+  margin: 0 0 20px 0;
+}
+/* Add margin if adjacent element */
+* + p,
+* + ul,
+* + ol,
+* + dl,
+* + pre,
+* + address,
+* + fieldset,
+* + figure {
+  margin-top: 20px;
+}
+/* Headings
+ ========================================================================== */
+h1,
+.uk-h1,
+h2,
+.uk-h2,
+h3,
+.uk-h3,
+h4,
+.uk-h4,
+h5,
+.uk-h5,
+h6,
+.uk-h6,
+.uk-heading-small,
+.uk-heading-medium,
+.uk-heading-large,
+.uk-heading-xlarge,
+.uk-heading-2xlarge,
+.uk-heading-3xlarge {
+  margin: 0 0 20px 0;
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+  font-weight: normal;
+  color: #333;
+  text-transform: none;
+}
+/* Add margin if adjacent element */
+* + h1,
+* + .uk-h1,
+* + h2,
+* + .uk-h2,
+* + h3,
+* + .uk-h3,
+* + h4,
+* + .uk-h4,
+* + h5,
+* + .uk-h5,
+* + h6,
+* + .uk-h6,
+* + .uk-heading-small,
+* + .uk-heading-medium,
+* + .uk-heading-large,
+* + .uk-heading-xlarge,
+* + .uk-heading-2xlarge,
+* + .uk-heading-3xlarge {
+  margin-top: 40px;
+}
+/*
+ * Sizes
+ */
+h1,
+.uk-h1 {
+  font-size: 2.23125rem;
+  line-height: 1.2;
+}
+h2,
+.uk-h2 {
+  font-size: 1.7rem;
+  line-height: 1.3;
+}
+h3,
+.uk-h3 {
+  font-size: 1.5rem;
+  line-height: 1.4;
+}
+h4,
+.uk-h4 {
+  font-size: 1.25rem;
+  line-height: 1.4;
+}
+h5,
+.uk-h5 {
+  font-size: 16px;
+  line-height: 1.4;
+}
+h6,
+.uk-h6 {
+  font-size: 0.875rem;
+  line-height: 1.4;
+}
+/* Tablet landscape and bigger */
+@media (min-width: 960px) {
+  h1,
+  .uk-h1 {
+    font-size: 2.625rem;
+  }
+  h2,
+  .uk-h2 {
+    font-size: 2rem;
+  }
+}
+/* Lists
+ ========================================================================== */
+ul,
+ol {
+  padding-left: 30px;
+}
+/*
+ * Reset margin for nested lists
+ */
+ul > li > ul,
+ul > li > ol,
+ol > li > ol,
+ol > li > ul {
+  margin: 0;
+}
+/* Description lists
+ ========================================================================== */
+dt {
+  font-weight: bold;
+}
+dd {
+  margin-left: 0;
+}
+/* Horizontal rules
+ ========================================================================== */
+/*
+ * 1. Show the overflow in Chrome, Edge and IE.
+ * 2. Add the correct text-align in Edge and IE.
+ * 3. Style
+ */
+hr,
+.uk-hr {
+  /* 1 */
+  overflow: visible;
+  /* 2 */
+  text-align: inherit;
+  /* 3 */
+  margin: 0 0 20px 0;
+  border: 0;
+  border-top: 1px solid #e5e5e5;
+}
+/* Add margin if adjacent element */
+* + hr,
+* + .uk-hr {
+  margin-top: 20px;
+}
+/* Address
+ ========================================================================== */
+address {
+  font-style: normal;
+}
+/* Blockquotes
+ ========================================================================== */
+blockquote {
+  margin: 0 0 20px 0;
+  font-size: 1.25rem;
+  line-height: 1.5;
+  font-style: italic;
+  color: #333;
+}
+/* Add margin if adjacent element */
+* + blockquote {
+  margin-top: 20px;
+}
+/*
+ * Content
+ */
+blockquote p:last-of-type {
+  margin-bottom: 0;
+}
+blockquote footer {
+  margin-top: 10px;
+  font-size: 0.875rem;
+  line-height: 1.5;
+  color: #666;
+}
+blockquote footer::before {
+  content: "— ";
+}
+/* Preformatted text
+ ========================================================================== */
+/*
+ * 1. Contain overflow in all browsers.
+ */
+pre {
+  font: 0.875rem / 1.5 Consolas, monaco, monospace;
+  color: #666;
+  -moz-tab-size: 4;
+  tab-size: 4;
+  /* 1 */
+  overflow: auto;
+  padding: 10px;
+  border: 1px solid #e5e5e5;
+  border-radius: 3px;
+  background: #fff;
+}
+pre code {
+  font-family: Consolas, monaco, monospace;
+}
+/* Focus
+ ========================================================================== */
+:focus {
+  outline: none;
+}
+:focus-visible {
+  outline: 2px dotted #333;
+}
+/* Selection pseudo-element
+ ========================================================================== */
+::selection {
+  background: #39f;
+  color: #fff;
+  text-shadow: none;
+}
+/* HTML5 elements
+ ========================================================================== */
+/*
+ * 1. Add the correct display in Edge, IE 10+, and Firefox.
+ * 2. Add the correct display in IE.
+ */
+details,
+main {
+  /* 2 */
+  display: block;
+}
+/*
+ * Add the correct display in all browsers.
+ */
+summary {
+  display: list-item;
+}
+/*
+ * Add the correct display in IE.
+ */
+template {
+  display: none;
+}
+/* Pass media breakpoints to JS
+ ========================================================================== */
+/*
+ * Breakpoints
+ */
+:root {
+  --uk-breakpoint-s: 640px;
+  --uk-breakpoint-m: 960px;
+  --uk-breakpoint-l: 1200px;
+  --uk-breakpoint-xl: 1600px;
+}
+/* ========================================================================
+   Component: Link
+ ========================================================================== */
+/* Muted
+ ========================================================================== */
+a.uk-link-muted,
+.uk-link-muted a,
+.uk-link-toggle .uk-link-muted {
+  color: #999;
+}
+a.uk-link-muted:hover,
+.uk-link-muted a:hover,
+.uk-link-toggle:hover .uk-link-muted {
+  color: #666;
+}
+/* Text
+ ========================================================================== */
+a.uk-link-text,
+.uk-link-text a,
+.uk-link-toggle .uk-link-text {
+  color: inherit;
+}
+a.uk-link-text:hover,
+.uk-link-text a:hover,
+.uk-link-toggle:hover .uk-link-text {
+  color: #999;
+}
+/* Heading
+ ========================================================================== */
+a.uk-link-heading,
+.uk-link-heading a,
+.uk-link-toggle .uk-link-heading {
+  color: inherit;
+}
+a.uk-link-heading:hover,
+.uk-link-heading a:hover,
+.uk-link-toggle:hover .uk-link-heading {
+  color: #1e87f0;
+  text-decoration: none;
+}
+/* Reset
+ ========================================================================== */
+/*
+ * `!important` needed to override inverse component
+ */
+a.uk-link-reset,
+.uk-link-reset a {
+  color: inherit !important;
+  text-decoration: none !important;
+}
+/* Toggle
+ ========================================================================== */
+.uk-link-toggle {
+  color: inherit !important;
+  text-decoration: none !important;
+}
+/* ========================================================================
+   Component: Heading
+ ========================================================================== */
+.uk-heading-small {
+  font-size: 2.6rem;
+  line-height: 1.2;
+}
+.uk-heading-medium {
+  font-size: 2.8875rem;
+  line-height: 1.1;
+}
+.uk-heading-large {
+  font-size: 3.4rem;
+  line-height: 1.1;
+}
+.uk-heading-xlarge {
+  font-size: 4rem;
+  line-height: 1;
+}
+.uk-heading-2xlarge {
+  font-size: 6rem;
+  line-height: 1;
+}
+.uk-heading-3xlarge {
+  font-size: 8rem;
+  line-height: 1;
+}
+/* Tablet Landscape and bigger */
+@media (min-width: 960px) {
+  .uk-heading-small {
+    font-size: 3.25rem;
+  }
+  .uk-heading-medium {
+    font-size: 3.5rem;
+  }
+  .uk-heading-large {
+    font-size: 4rem;
+  }
+  .uk-heading-xlarge {
+    font-size: 6rem;
+  }
+  .uk-heading-2xlarge {
+    font-size: 8rem;
+  }
+  .uk-heading-3xlarge {
+    font-size: 11rem;
+  }
+}
+/* Laptop and bigger */
+@media (min-width: 1200px) {
+  .uk-heading-medium {
+    font-size: 4rem;
+  }
+  .uk-heading-large {
+    font-size: 6rem;
+  }
+  .uk-heading-xlarge {
+    font-size: 8rem;
+  }
+  .uk-heading-2xlarge {
+    font-size: 11rem;
+  }
+  .uk-heading-3xlarge {
+    font-size: 15rem;
+  }
+}
+/* Primary
+   Deprecated: Use `uk-heading-medium` instead
+ ========================================================================== */
+/* Tablet landscape and bigger */
+/* Desktop and bigger */
+/* Hero
+   Deprecated: Use `uk-heading-xlarge` instead
+ ========================================================================== */
+/* Tablet landscape and bigger */
+/* Desktop and bigger */
+/* Divider
+ ========================================================================== */
+.uk-heading-divider {
+  padding-bottom: calc(5px + 0.1em);
+  border-bottom: calc(0.2px + 0.05em) solid #e5e5e5;
+}
+/* Bullet
+ ========================================================================== */
+.uk-heading-bullet {
+  position: relative;
+}
+/*
+ * 1. Using `inline-block` to make it work with text alignment
+ * 2. Center vertically
+ * 3. Style
+ */
+.uk-heading-bullet::before {
+  content: "";
+  /* 1 */
+  display: inline-block;
+  /* 2 */
+  position: relative;
+  top: calc(-0.1 * 1em);
+  vertical-align: middle;
+  /* 3 */
+  height: calc(4px + 0.7em);
+  margin-right: calc(5px + 0.2em);
+  border-left: calc(5px + 0.1em) solid #e5e5e5;
+}
+/* Line
+ ========================================================================== */
+/*
+ * Clip the child element
+ */
+.uk-heading-line {
+  overflow: hidden;
+}
+/*
+ * Extra markup is needed to make it work with text align
+ */
+.uk-heading-line > * {
+  display: inline-block;
+  position: relative;
+}
+/*
+ * 1. Center vertically
+ * 2. Make the element as large as possible. It's clipped by the container.
+ * 3. Style
+ */
+.uk-heading-line > ::before,
+.uk-heading-line > ::after {
+  content: "";
+  /* 1 */
+  position: absolute;
+  top: calc(50% - (calc(0.2px + 0.05em) / 2));
+  /* 2 */
+  width: 2000px;
+  /* 3 */
+  border-bottom: calc(0.2px + 0.05em) solid #e5e5e5;
+}
+.uk-heading-line > ::before {
+  right: 100%;
+  margin-right: calc(5px + 0.3em);
+}
+.uk-heading-line > ::after {
+  left: 100%;
+  margin-left: calc(5px + 0.3em);
+}
+/* ========================================================================
+   Component: Divider
+ ========================================================================== */
+/*
+ * 1. Reset default `hr`
+ * 2. Set margin if a `div` is used for semantical reason
+ */
+[class*="uk-divider"] {
+  /* 1 */
+  border: none;
+  /* 2 */
+  margin-bottom: 20px;
+}
+/* Add margin if adjacent element */
+* + [class*="uk-divider"] {
+  margin-top: 20px;
+}
+/* Icon
+ ========================================================================== */
+.uk-divider-icon {
+  position: relative;
+  height: 20px;
+  background-image: url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2220%22%20height%3D%2220%22%20viewBox%3D%220%200%2020%2020%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Ccircle%20fill%3D%22none%22%20stroke%3D%22%23e5e5e5%22%20stroke-width%3D%222%22%20cx%3D%2210%22%20cy%3D%2210%22%20r%3D%227%22%20%2F%3E%0A%3C%2Fsvg%3E%0A");
+  background-repeat: no-repeat;
+  background-position: 50% 50%;
+}
+.uk-divider-icon::before,
+.uk-divider-icon::after {
+  content: "";
+  position: absolute;
+  top: 50%;
+  max-width: calc(50% - (50px / 2));
+  border-bottom: 1px solid #e5e5e5;
+}
+.uk-divider-icon::before {
+  right: calc(50% + (50px / 2));
+  width: 100%;
+}
+.uk-divider-icon::after {
+  left: calc(50% + (50px / 2));
+  width: 100%;
+}
+/* Small
+ ========================================================================== */
+/*
+ * 1. Fix height because of `inline-block`
+ * 2. Using ::after and inline-block to make `text-align` work
+ */
+/* 1 */
+.uk-divider-small {
+  line-height: 0;
+}
+/* 2 */
+.uk-divider-small::after {
+  content: "";
+  display: inline-block;
+  width: 100px;
+  max-width: 100%;
+  border-top: 1px solid #e5e5e5;
+  vertical-align: top;
+}
+/* Vertical
+ ========================================================================== */
+.uk-divider-vertical {
+  width: max-content;
+  height: 100px;
+  margin-left: auto;
+  margin-right: auto;
+  border-left: 1px solid #e5e5e5;
+}
+/* ========================================================================
+   Component: List
+ ========================================================================== */
+.uk-list {
+  padding: 0;
+  list-style: none;
+}
+/*
+ * Avoid column break within the list item, when using `column-count`
+ */
+.uk-list > * {
+  break-inside: avoid-column;
+}
+/*
+ * Remove margin from the last-child
+ */
+.uk-list > * > :last-child {
+  margin-bottom: 0;
+}
+/*
+ * Style
+ */
+.uk-list > :nth-child(n+2),
+.uk-list > * > ul {
+  margin-top: 10px;
+}
+/* Marker modifiers
+ * Moving `::marker` inside `::before` to style it differently
+ * To style the `::marker` is currently only supported in Firefox and Safari
+ ========================================================================== */
+.uk-list-disc > *,
+.uk-list-circle > *,
+.uk-list-square > *,
+.uk-list-decimal > *,
+.uk-list-hyphen > * {
+  padding-left: 30px;
+}
+/*
+ * Type modifiers
+ */
+.uk-list-decimal {
+  counter-reset: decimal;
+}
+.uk-list-decimal > * {
+  counter-increment: decimal;
+}
+.uk-list-disc > ::before,
+.uk-list-circle > ::before,
+.uk-list-square > ::before,
+.uk-list-decimal > ::before,
+.uk-list-hyphen > ::before {
+  content: "";
+  position: relative;
+  left: -30px;
+  width: 30px;
+  height: 1.5em;
+  margin-bottom: -1.5em;
+  display: list-item;
+  list-style-position: inside;
+  text-align: right;
+}
+.uk-list-disc > ::before {
+  list-style-type: disc;
+}
+.uk-list-circle > ::before {
+  list-style-type: circle;
+}
+.uk-list-square > ::before {
+  list-style-type: square;
+}
+.uk-list-decimal > ::before {
+  content: counter(decimal, decimal) '\200A.\00A0';
+}
+.uk-list-hyphen > ::before {
+  content: '–\00A0\00A0';
+}
+/*
+ * Color modifiers
+ */
+.uk-list-muted > ::before {
+  color: #999 !important;
+}
+.uk-list-emphasis > ::before {
+  color: #333 !important;
+}
+.uk-list-primary > ::before {
+  color: #1e87f0 !important;
+}
+.uk-list-secondary > ::before {
+  color: #222 !important;
+}
+/* Image bullet modifier
+ ========================================================================== */
+.uk-list-bullet > * {
+  padding-left: 30px;
+}
+.uk-list-bullet > ::before {
+  content: "";
+  display: list-item;
+  position: relative;
+  left: -30px;
+  width: 30px;
+  height: 1.5em;
+  margin-bottom: -1.5em;
+  background-image: url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%226%22%20height%3D%226%22%20viewBox%3D%220%200%206%206%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Ccircle%20fill%3D%22%23666%22%20cx%3D%223%22%20cy%3D%223%22%20r%3D%223%22%20%2F%3E%0A%3C%2Fsvg%3E");
+  background-repeat: no-repeat;
+  background-position: 50% 50%;
+}
+/* Style modifiers
+ ========================================================================== */
+/*
+ * Divider
+ */
+.uk-list-divider > :nth-child(n+2) {
+  margin-top: 10px;
+  padding-top: 10px;
+  border-top: 1px solid #e5e5e5;
+}
+/*
+ * Striped
+ */
+.uk-list-striped > * {
+  padding: 10px 10px;
+}
+.uk-list-striped > *:nth-of-type(odd) {
+  border-top: 1px solid #e5e5e5;
+  border-bottom: 1px solid #e5e5e5;
+}
+.uk-list-striped > :nth-of-type(odd) {
+  background: #f8f8f8;
+}
+.uk-list-striped > :nth-child(n+2) {
+  margin-top: 0;
+}
+/* Size modifier
+ ========================================================================== */
+.uk-list-large > :nth-child(n+2),
+.uk-list-large > * > ul {
+  margin-top: 20px;
+}
+.uk-list-collapse > :nth-child(n+2),
+.uk-list-collapse > * > ul {
+  margin-top: 0;
+}
+/*
+ * Divider
+ */
+.uk-list-large.uk-list-divider > :nth-child(n+2) {
+  margin-top: 20px;
+  padding-top: 20px;
+}
+.uk-list-collapse.uk-list-divider > :nth-child(n+2) {
+  margin-top: 0;
+  padding-top: 0;
+}
+/*
+ * Striped
+ */
+.uk-list-large.uk-list-striped > * {
+  padding: 20px 10px;
+}
+.uk-list-collapse.uk-list-striped > * {
+  padding-top: 0;
+  padding-bottom: 0;
+}
+.uk-list-large.uk-list-striped > :nth-child(n+2),
+.uk-list-collapse.uk-list-striped > :nth-child(n+2) {
+  margin-top: 0;
+}
+/* ========================================================================
+   Component: Description list
+ ========================================================================== */
+/*
+ * Term
+ */
+.uk-description-list > dt {
+  color: #333;
+  font-size: 0.875rem;
+  font-weight: normal;
+  text-transform: uppercase;
+}
+.uk-description-list > dt:nth-child(n+2) {
+  margin-top: 20px;
+}
+/*
+ * Description
+ */
+/* Style modifier
+ ========================================================================== */
+/*
+ * Line
+ */
+.uk-description-list-divider > dt:nth-child(n+2) {
+  margin-top: 20px;
+  padding-top: 20px;
+  border-top: 1px solid #e5e5e5;
+}
+/* ========================================================================
+   Component: Table
+ ========================================================================== */
+/*
+ * 1. Remove most spacing between table cells.
+ * 2. Behave like a block element
+ * 3. Style
+ */
+.uk-table {
+  /* 1 */
+  border-collapse: collapse;
+  border-spacing: 0;
+  /* 2 */
+  width: 100%;
+  /* 3 */
+  margin-bottom: 20px;
+}
+/* Add margin if adjacent element */
+* + .uk-table {
+  margin-top: 20px;
+}
+/* Header cell
+ ========================================================================== */
+/*
+ * 1. Style
+ */
+.uk-table th {
+  padding: 16px 12px;
+  text-align: left;
+  vertical-align: bottom;
+  /* 1 */
+  font-size: 0.875rem;
+  font-weight: normal;
+  color: #999;
+  text-transform: uppercase;
+}
+/* Cell
+ ========================================================================== */
+.uk-table td {
+  padding: 16px 12px;
+  vertical-align: top;
+}
+/*
+ * Remove margin from the last-child
+ */
+.uk-table td > :last-child {
+  margin-bottom: 0;
+}
+/* Footer
+ ========================================================================== */
+.uk-table tfoot {
+  font-size: 0.875rem;
+}
+/* Caption
+ ========================================================================== */
+.uk-table caption {
+  font-size: 0.875rem;
+  text-align: left;
+  color: #999;
+}
+/* Alignment modifier
+ ========================================================================== */
+.uk-table-middle,
+.uk-table-middle td {
+  vertical-align: middle !important;
+}
+/* Style modifiers
+ ========================================================================== */
+/*
+ * Divider
+ */
+.uk-table-divider > tr:not(:first-child),
+.uk-table-divider > :not(:first-child) > tr,
+.uk-table-divider > :first-child > tr:not(:first-child) {
+  border-top: 1px solid #e5e5e5;
+}
+/*
+ * Striped
+ */
+.uk-table-striped > tr:nth-of-type(odd),
+.uk-table-striped tbody tr:nth-of-type(odd) {
+  background: #f8f8f8;
+  border-top: 1px solid #e5e5e5;
+  border-bottom: 1px solid #e5e5e5;
+}
+/*
+ * Hover
+ */
+.uk-table-hover > tr:hover,
+.uk-table-hover tbody tr:hover {
+  background: #ffd;
+}
+/* Active state
+ ========================================================================== */
+.uk-table > tr.uk-active,
+.uk-table tbody tr.uk-active {
+  background: #ffd;
+}
+/* Size modifier
+ ========================================================================== */
+.uk-table-small th,
+.uk-table-small td {
+  padding: 10px 12px;
+}
+.uk-table-large th,
+.uk-table-large td {
+  padding: 22px 12px;
+}
+/* Justify modifier
+ ========================================================================== */
+.uk-table-justify th:first-child,
+.uk-table-justify td:first-child {
+  padding-left: 0;
+}
+.uk-table-justify th:last-child,
+.uk-table-justify td:last-child {
+  padding-right: 0;
+}
+/* Cell size modifier
+ ========================================================================== */
+.uk-table-shrink {
+  width: 1px;
+}
+.uk-table-expand {
+  min-width: 150px;
+}
+/* Cell link modifier
+ ========================================================================== */
+/*
+ * Does not work with `uk-table-justify` at the moment
+ */
+.uk-table-link {
+  padding: 0 !important;
+}
+.uk-table-link > a {
+  display: block;
+  padding: 16px 12px;
+}
+.uk-table-small .uk-table-link > a {
+  padding: 10px 12px;
+}
+/* Responsive table
+ ========================================================================== */
+/* Phone landscape and smaller */
+@media (max-width: 959px) {
+  .uk-table-responsive,
+  .uk-table-responsive tbody,
+  .uk-table-responsive th,
+  .uk-table-responsive td,
+  .uk-table-responsive tr {
+    display: block;
+  }
+  .uk-table-responsive thead {
+    display: none;
+  }
+  .uk-table-responsive th,
+  .uk-table-responsive td {
+    width: auto !important;
+    max-width: none !important;
+    min-width: 0 !important;
+    overflow: visible !important;
+    white-space: normal !important;
+  }
+  .uk-table-responsive th:not(:first-child):not(.uk-table-link),
+  .uk-table-responsive td:not(:first-child):not(.uk-table-link),
+  .uk-table-responsive .uk-table-link:not(:first-child) > a {
+    padding-top: 5px !important;
+  }
+  .uk-table-responsive th:not(:last-child):not(.uk-table-link),
+  .uk-table-responsive td:not(:last-child):not(.uk-table-link),
+  .uk-table-responsive .uk-table-link:not(:last-child) > a {
+    padding-bottom: 5px !important;
+  }
+  .uk-table-justify.uk-table-responsive th,
+  .uk-table-justify.uk-table-responsive td {
+    padding-left: 0;
+    padding-right: 0;
+  }
+}
+.uk-table tbody tr {
+  transition: background-color 0.1s linear;
+}
+.uk-table-striped > tr:nth-of-type(even):last-child,
+.uk-table-striped tbody tr:nth-of-type(even):last-child {
+  border-bottom: 1px solid #e5e5e5;
+}
+/* ========================================================================
+   Component: Icon
+ ========================================================================== */
+/*
+ * Note: 1. - 7. is required for `button` elements. Needed for Close and Form Icon component.
+ * 1. Remove margins in Chrome, Safari and Opera.
+ * 2. Remove borders for `button`.
+ * 3. Remove border-radius in Chrome.
+ * 4. Address `overflow` set to `hidden` in IE.
+ * 5. Correct `font` properties and `color` not being inherited for `button`.
+ * 6. Remove the inheritance of text transform in Edge, Firefox, and IE.
+ * 7. Remove default `button` padding and background color
+ * 8. Style
+ * 9. Fill all SVG elements with the current text color if no `fill` attribute is set
+ * 10. Let the container fit the height of the icon
+ */
+.uk-icon {
+  /* 1 */
+  margin: 0;
+  /* 2 */
+  border: none;
+  /* 3 */
+  border-radius: 0;
+  /* 4 */
+  overflow: visible;
+  /* 5 */
+  font: inherit;
+  color: inherit;
+  /* 6 */
+  text-transform: none;
+  /* 7. */
+  padding: 0;
+  background-color: transparent;
+  /* 8 */
+  display: inline-block;
+  /* 9 */
+  fill: currentcolor;
+  /* 10 */
+  line-height: 0;
+}
+/* Required for `button`. */
+button.uk-icon:not(:disabled) {
+  cursor: pointer;
+}
+/*
+ * Remove the inner border and padding in Firefox.
+ */
+.uk-icon::-moz-focus-inner {
+  border: 0;
+  padding: 0;
+}
+/*
+ * Set the fill and stroke color of all SVG elements to the current text color
+ */
+.uk-icon:not(.uk-preserve) [fill*="#"]:not(.uk-preserve) {
+  fill: currentcolor;
+}
+.uk-icon:not(.uk-preserve) [stroke*="#"]:not(.uk-preserve) {
+  stroke: currentcolor;
+}
+/*
+ * Fix Firefox blurry SVG rendering: https://bugzilla.mozilla.org/show_bug.cgi?id=1046835
+ */
+.uk-icon > * {
+  transform: translate(0, 0);
+}
+/* Image modifier
+ ========================================================================== */
+/*
+ * Display images in icon dimensions
+ * 1. Required for `span` with background image
+ * 2. Required for `image`
+ */
+.uk-icon-image {
+  width: 20px;
+  height: 20px;
+  /* 1 */
+  background-position: 50% 50%;
+  background-repeat: no-repeat;
+  background-size: contain;
+  vertical-align: middle;
+  /* 2 */
+  object-fit: scale-down;
+  max-width: none;
+}
+/* Style modifiers
+ ========================================================================== */
+/*
+ * Link
+ * 1. Allow text within link
+ */
+.uk-icon-link {
+  color: #999;
+  /* 1 */
+  text-decoration: none !important;
+}
+.uk-icon-link:hover {
+  color: #666;
+}
+/* OnClick + Active */
+.uk-icon-link:active,
+.uk-active > .uk-icon-link {
+  color: #595959;
+}
+/*
+ * Button
+ * 1. Center icon vertically and horizontally
+ */
+.uk-icon-button {
+  box-sizing: border-box;
+  width: 36px;
+  height: 36px;
+  border-radius: 500px;
+  background: #f8f8f8;
+  color: #999;
+  vertical-align: middle;
+  /* 1 */
+  display: inline-flex;
+  justify-content: center;
+  align-items: center;
+  transition: 0.1s ease-in-out;
+  transition-property: color, background-color;
+}
+/* Hover */
+.uk-icon-button:hover {
+  background-color: #ebebeb;
+  color: #666;
+}
+/* OnClick + Active */
+.uk-icon-button:active,
+.uk-active > .uk-icon-button {
+  background-color: #dfdfdf;
+  color: #666;
+}
+/* ========================================================================
+   Component: Form Range
+ ========================================================================== */
+/*
+ * 1. Remove default style.
+ * 2. Define consistent box sizing.
+ * 3. Remove `margin` in all browsers.
+ * 4. Align to the center of the line box.
+ * 5. Prevent content overflow if a fixed width is used.
+ * 6. Take the full width.
+ * 7. Remove white background in Chrome.
+ */
+.uk-range {
+  /* 1 */
+  -webkit-appearance: none;
+  /* 2 */
+  box-sizing: border-box;
+  /* 3 */
+  margin: 0;
+  /* 4 */
+  vertical-align: middle;
+  /* 5 */
+  max-width: 100%;
+  /* 6 */
+  width: 100%;
+  /* 7 */
+  background: transparent;
+}
+/* Focus */
+.uk-range:focus {
+  outline: none;
+}
+.uk-range::-moz-focus-outer {
+  border: none;
+}
+/*
+ * Improves consistency of cursor style for clickable elements
+ */
+.uk-range:not(:disabled)::-webkit-slider-thumb {
+  cursor: pointer;
+}
+.uk-range:not(:disabled)::-moz-range-thumb {
+  cursor: pointer;
+}
+/*
+ * Track
+ * 1. Safari doesn't have a focus state. Using active instead.
+ */
+/* Webkit */
+.uk-range::-webkit-slider-runnable-track {
+  height: 3px;
+  background: #ebebeb;
+  border-radius: 500px;
+}
+.uk-range:focus::-webkit-slider-runnable-track,
+.uk-range:active::-webkit-slider-runnable-track {
+  background: #dedede;
+}
+/* Firefox */
+.uk-range::-moz-range-track {
+  height: 3px;
+  background: #ebebeb;
+  border-radius: 500px;
+}
+.uk-range:focus::-moz-range-track {
+  background: #dedede;
+}
+/*
+ * Thumb
+ * 1. Reset
+ * 2. Style
+ */
+/* Webkit */
+.uk-range::-webkit-slider-thumb {
+  /* 1 */
+  -webkit-appearance: none;
+  margin-top: -7px;
+  /* 2 */
+  height: 15px;
+  width: 15px;
+  border-radius: 500px;
+  background: #fff;
+  border: 1px solid #cccccc;
+}
+/* Firefox */
+.uk-range::-moz-range-thumb {
+  /* 1 */
+  border: none;
+  /* 2 */
+  height: 15px;
+  width: 15px;
+  margin-top: -7px;
+  border-radius: 500px;
+  background: #fff;
+  border: 1px solid #cccccc;
+}
+/* ========================================================================
+   Component: Form
+ ========================================================================== */
+/*
+ * 1. Define consistent box sizing.
+ *    Default is `content-box` with following exceptions set to `border-box`
+ *    `select`, `input[type="checkbox"]` and `input[type="radio"]`
+ *    `input[type="search"]` in Chrome, Safari and Opera
+ *    `input[type="color"]` in Firefox
+ * 2. Address margins set differently in Firefox/IE and Chrome/Safari/Opera.
+ * 3. Remove `border-radius` in iOS.
+ * 4. Change font properties to `inherit` in all browsers.
+ */
+.uk-input,
+.uk-select,
+.uk-textarea,
+.uk-radio,
+.uk-checkbox {
+  /* 1 */
+  box-sizing: border-box;
+  /* 2 */
+  margin: 0;
+  /* 3 */
+  border-radius: 0;
+  /* 4 */
+  font: inherit;
+}
+/*
+ * Show the overflow in Edge.
+ */
+.uk-input {
+  overflow: visible;
+}
+/*
+ * Remove the inheritance of text transform in Firefox.
+ */
+.uk-select {
+  text-transform: none;
+}
+/*
+ * 1. Change font properties to `inherit` in all browsers
+ * 2. Don't inherit the `font-weight` and use `bold` instead.
+ * NOTE: Both declarations don't work in Chrome, Safari and Opera.
+ */
+.uk-select optgroup {
+  /* 1 */
+  font: inherit;
+  /* 2 */
+  font-weight: bold;
+}
+/*
+ * Remove the default vertical scrollbar in IE 10+.
+ */
+.uk-textarea {
+  overflow: auto;
+}
+/*
+ * Remove the inner padding and cancel buttons in Chrome on OS X and Safari on OS X.
+ */
+.uk-input[type="search"]::-webkit-search-cancel-button,
+.uk-input[type="search"]::-webkit-search-decoration {
+  -webkit-appearance: none;
+}
+/*
+ * Correct the cursor style of increment and decrement buttons in Chrome.
+ */
+.uk-input[type="number"]::-webkit-inner-spin-button,
+.uk-input[type="number"]::-webkit-outer-spin-button {
+  height: auto;
+}
+/*
+ * Removes placeholder transparency in Firefox.
+ */
+.uk-input::-moz-placeholder,
+.uk-textarea::-moz-placeholder {
+  opacity: 1;
+}
+/*
+ * Improves consistency of cursor style for clickable elements
+ */
+.uk-radio:not(:disabled),
+.uk-checkbox:not(:disabled) {
+  cursor: pointer;
+}
+/*
+ * Define consistent border, margin, and padding.
+ * 1. Reset `min-width`
+ */
+.uk-fieldset {
+  border: none;
+  margin: 0;
+  padding: 0;
+  /* 1 */
+  min-width: 0;
+}
+/* Input, select and textarea
+ * Allowed: `text`, `password`, `datetime-local`, `date`,  `month`,
+            `time`, `week`, `number`, `email`, `url`, `search`, `tel`, `color`
+ * Disallowed: `range`, `radio`, `checkbox`, `file`, `submit`, `reset` and `image`
+ ========================================================================== */
+/*
+ * Remove default style in iOS.
+ */
+.uk-input,
+.uk-textarea {
+  -webkit-appearance: none;
+}
+/*
+ * 1. Prevent content overflow if a fixed width is used
+ * 2. Take the full width
+ * 3. Reset default
+ * 4. Style
+ */
+.uk-input,
+.uk-select,
+.uk-textarea {
+  /* 1 */
+  max-width: 100%;
+  /* 2 */
+  width: 100%;
+  /* 3 */
+  border: 0 none;
+  /* 4 */
+  padding: 0 10px;
+  background: #fff;
+  color: #666;
+  border: 1px solid #e5e5e5;
+  transition: 0.2s ease-in-out;
+  transition-property: color, background-color, border;
+}
+/*
+ * Single-line
+ * 1. Allow any element to look like an `input` or `select` element
+ * 2. Make sure line-height is not larger than height
+ *    Also needed to center the text vertically
+ */
+.uk-input,
+.uk-select:not([multiple]):not([size]) {
+  height: 40px;
+  vertical-align: middle;
+  /* 1 */
+  display: inline-block;
+}
+/* 2 */
+.uk-input:not(input),
+.uk-select:not(select) {
+  line-height: 38px;
+}
+/*
+ * Multi-line
+ */
+.uk-select[multiple],
+.uk-select[size],
+.uk-textarea {
+  padding-top: 6px;
+  padding-bottom: 6px;
+  vertical-align: top;
+}
+.uk-select[multiple],
+.uk-select[size] {
+  resize: vertical;
+}
+/* Focus */
+.uk-input:focus,
+.uk-select:focus,
+.uk-textarea:focus {
+  outline: none;
+  background-color: #fff;
+  color: #666;
+  border-color: #1e87f0;
+}
+/* Disabled */
+.uk-input:disabled,
+.uk-select:disabled,
+.uk-textarea:disabled {
+  background-color: #f8f8f8;
+  color: #999;
+  border-color: #e5e5e5;
+}
+/*
+ * Placeholder
+ */
+.uk-input::placeholder {
+  color: #999;
+}
+.uk-textarea::placeholder {
+  color: #999;
+}
+/* Style modifier (`uk-input`, `uk-select` and `uk-textarea`)
+ ========================================================================== */
+/*
+ * Small
+ */
+.uk-form-small {
+  font-size: 0.875rem;
+}
+/* Single-line */
+.uk-form-small:not(textarea):not([multiple]):not([size]) {
+  height: 30px;
+  padding-left: 8px;
+  padding-right: 8px;
+}
+/* Multi-line */
+textarea.uk-form-small,
+[multiple].uk-form-small,
+[size].uk-form-small {
+  padding: 5px 8px;
+}
+.uk-form-small:not(select):not(input):not(textarea) {
+  line-height: 28px;
+}
+/*
+ * Large
+ */
+.uk-form-large {
+  font-size: 1.25rem;
+}
+/* Single-line */
+.uk-form-large:not(textarea):not([multiple]):not([size]) {
+  height: 55px;
+  padding-left: 12px;
+  padding-right: 12px;
+}
+/* Multi-line */
+textarea.uk-form-large,
+[multiple].uk-form-large,
+[size].uk-form-large {
+  padding: 7px 12px;
+}
+.uk-form-large:not(select):not(input):not(textarea) {
+  line-height: 53px;
+}
+/* Style modifier (`uk-input`, `uk-select` and `uk-textarea`)
+ ========================================================================== */
+/*
+ * Error
+ */
+.uk-form-danger,
+.uk-form-danger:focus {
+  color: #f0506e;
+  border-color: #f0506e;
+}
+/*
+ * Success
+ */
+.uk-form-success,
+.uk-form-success:focus {
+  color: #32d296;
+  border-color: #32d296;
+}
+/*
+ * Blank
+ */
+.uk-form-blank {
+  background: none;
+  border-color: transparent;
+}
+.uk-form-blank:focus {
+  border-color: #e5e5e5;
+  border-style: solid;
+}
+/* Width modifiers (`uk-input`, `uk-select` and `uk-textarea`)
+ ========================================================================== */
+/*
+ * Fixed widths
+ * Different widths for mini sized `input` and `select` elements
+ */
+input.uk-form-width-xsmall {
+  width: 50px;
+}
+select.uk-form-width-xsmall {
+  width: 75px;
+}
+.uk-form-width-small {
+  width: 130px;
+}
+.uk-form-width-medium {
+  width: 200px;
+}
+.uk-form-width-large {
+  width: 500px;
+}
+/* Select
+ ========================================================================== */
+/*
+ * 1. Remove default style. Also works in Firefox
+ * 2. Style
+ * 3. Set `color` for options in the select dropdown, because the inherited `color` might be too light.
+ */
+.uk-select:not([multiple]):not([size]) {
+  /* 1 */
+  -webkit-appearance: none;
+  -moz-appearance: none;
+  /* 2 */
+  padding-right: 20px;
+  background-image: url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2224%22%20height%3D%2216%22%20viewBox%3D%220%200%2024%2016%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Cpolygon%20fill%3D%22%23666%22%20points%3D%2212%201%209%206%2015%206%22%20%2F%3E%0A%20%20%20%20%3Cpolygon%20fill%3D%22%23666%22%20points%3D%2212%2013%209%208%2015%208%22%20%2F%3E%0A%3C%2Fsvg%3E%0A");
+  background-repeat: no-repeat;
+  background-position: 100% 50%;
+}
+/* 3 */
+.uk-select:not([multiple]):not([size]) option {
+  color: #666;
+}
+/*
+ * Disabled
+ */
+.uk-select:not([multiple]):not([size]):disabled {
+  background-image: url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2224%22%20height%3D%2216%22%20viewBox%3D%220%200%2024%2016%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Cpolygon%20fill%3D%22%23999%22%20points%3D%2212%201%209%206%2015%206%22%20%2F%3E%0A%20%20%20%20%3Cpolygon%20fill%3D%22%23999%22%20points%3D%2212%2013%209%208%2015%208%22%20%2F%3E%0A%3C%2Fsvg%3E%0A");
+}
+/* Datalist
+ ========================================================================== */
+/*
+ * 1. Remove default style in Chrome
+ */
+.uk-input[list] {
+  padding-right: 20px;
+  background-repeat: no-repeat;
+  background-position: 100% 50%;
+}
+.uk-input[list]:hover,
+.uk-input[list]:focus {
+  background-image: url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2224%22%20height%3D%2216%22%20viewBox%3D%220%200%2024%2016%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Cpolygon%20fill%3D%22%23666%22%20points%3D%2212%2012%208%206%2016%206%22%20%2F%3E%0A%3C%2Fsvg%3E%0A");
+}
+/* 1 */
+.uk-input[list]::-webkit-calendar-picker-indicator {
+  display: none !important;
+}
+/* Radio and checkbox
+ ========================================================================== */
+/*
+ * 1. Style
+ * 2. Make box more robust so it clips the child element
+ * 3. Vertical alignment
+ * 4. Remove default style
+ * 5. Fix black background on iOS
+ * 6. Center icons
+ */
+.uk-radio,
+.uk-checkbox {
+  /* 1 */
+  display: inline-block;
+  height: 16px;
+  width: 16px;
+  /* 2 */
+  overflow: hidden;
+  /* 3 */
+  margin-top: -4px;
+  vertical-align: middle;
+  /* 4 */
+  -webkit-appearance: none;
+  -moz-appearance: none;
+  /* 5 */
+  background-color: transparent;
+  /* 6 */
+  background-repeat: no-repeat;
+  background-position: 50% 50%;
+  border: 1px solid #cccccc;
+  transition: 0.2s ease-in-out;
+  transition-property: background-color, border;
+}
+.uk-radio {
+  border-radius: 50%;
+}
+/* Focus */
+.uk-radio:focus,
+.uk-checkbox:focus {
+  background-color: rgba(0, 0, 0, 0);
+  outline: none;
+  border-color: #1e87f0;
+}
+/*
+ * Checked
+ */
+.uk-radio:checked,
+.uk-checkbox:checked,
+.uk-checkbox:indeterminate {
+  background-color: #1e87f0;
+  border-color: transparent;
+}
+/* Focus */
+.uk-radio:checked:focus,
+.uk-checkbox:checked:focus,
+.uk-checkbox:indeterminate:focus {
+  background-color: #0e6dcd;
+}
+/*
+ * Icons
+ */
+.uk-radio:checked {
+  background-image: url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2216%22%20height%3D%2216%22%20viewBox%3D%220%200%2016%2016%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Ccircle%20fill%3D%22%23fff%22%20cx%3D%228%22%20cy%3D%228%22%20r%3D%222%22%20%2F%3E%0A%3C%2Fsvg%3E");
+}
+.uk-checkbox:checked {
+  background-image: url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2214%22%20height%3D%2211%22%20viewBox%3D%220%200%2014%2011%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Cpolygon%20fill%3D%22%23fff%22%20points%3D%2212%201%205%207.5%202%205%201%205.5%205%2010%2013%201.5%22%20%2F%3E%0A%3C%2Fsvg%3E%0A");
+}
+.uk-checkbox:indeterminate {
+  background-image: url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2216%22%20height%3D%2216%22%20viewBox%3D%220%200%2016%2016%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Crect%20fill%3D%22%23fff%22%20x%3D%223%22%20y%3D%228%22%20width%3D%2210%22%20height%3D%221%22%20%2F%3E%0A%3C%2Fsvg%3E");
+}
+/*
+ * Disabled
+ */
+.uk-radio:disabled,
+.uk-checkbox:disabled {
+  background-color: #f8f8f8;
+  border-color: #e5e5e5;
+}
+.uk-radio:disabled:checked {
+  background-image: url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2216%22%20height%3D%2216%22%20viewBox%3D%220%200%2016%2016%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Ccircle%20fill%3D%22%23999%22%20cx%3D%228%22%20cy%3D%228%22%20r%3D%222%22%20%2F%3E%0A%3C%2Fsvg%3E");
+}
+.uk-checkbox:disabled:checked {
+  background-image: url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2214%22%20height%3D%2211%22%20viewBox%3D%220%200%2014%2011%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Cpolygon%20fill%3D%22%23999%22%20points%3D%2212%201%205%207.5%202%205%201%205.5%205%2010%2013%201.5%22%20%2F%3E%0A%3C%2Fsvg%3E%0A");
+}
+.uk-checkbox:disabled:indeterminate {
+  background-image: url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2216%22%20height%3D%2216%22%20viewBox%3D%220%200%2016%2016%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Crect%20fill%3D%22%23999%22%20x%3D%223%22%20y%3D%228%22%20width%3D%2210%22%20height%3D%221%22%20%2F%3E%0A%3C%2Fsvg%3E");
+}
+/* Legend
+ ========================================================================== */
+/*
+ * Legend
+ * 1. Behave like block element
+ * 2. Correct the color inheritance from `fieldset` elements in IE.
+ * 3. Remove padding so people aren't caught out if they zero out fieldsets.
+ * 4. Style
+ */
+.uk-legend {
+  /* 1 */
+  width: 100%;
+  /* 2 */
+  color: inherit;
+  /* 3 */
+  padding: 0;
+  /* 4 */
+  font-size: 1.5rem;
+  line-height: 1.4;
+}
+/* Custom controls
+ ========================================================================== */
+/*
+ * 1. Container fits its content
+ * 2. Create position context
+ * 3. Prevent content overflow
+ * 4. Behave like most inline-block elements
+ */
+.uk-form-custom {
+  /* 1 */
+  display: inline-block;
+  /* 2 */
+  position: relative;
+  /* 3 */
+  max-width: 100%;
+  /* 4 */
+  vertical-align: middle;
+}
+/*
+ * 1. Position and resize the form control to always cover its container
+ * 2. Required for Firefox for positioning to the left
+ * 3. Required for Webkit to make `height` work
+ * 4. Hide controle and show cursor
+ * 5. Needed for the cursor
+ * 6. Clip height caused by 5. Needed for Webkit only
+ */
+.uk-form-custom select,
+.uk-form-custom input[type="file"] {
+  /* 1 */
+  position: absolute;
+  top: 0;
+  z-index: 1;
+  width: 100%;
+  height: 100%;
+  /* 2 */
+  left: 0;
+  /* 3 */
+  -webkit-appearance: none;
+  /* 4 */
+  opacity: 0;
+  cursor: pointer;
+}
+.uk-form-custom input[type="file"] {
+  /* 5 */
+  font-size: 500px;
+  /* 6 */
+  overflow: hidden;
+}
+/* Label
+ ========================================================================== */
+.uk-form-label {
+  color: #333;
+  font-size: 0.875rem;
+}
+/* Layout
+ ========================================================================== */
+/*
+ * Stacked
+ */
+.uk-form-stacked .uk-form-label {
+  display: block;
+  margin-bottom: 5px;
+}
+/*
+ * Horizontal
+ */
+/* Tablet portrait and smaller */
+@media (max-width: 959px) {
+  /* Behave like `uk-form-stacked` */
+  .uk-form-horizontal .uk-form-label {
+    display: block;
+    margin-bottom: 5px;
+  }
+}
+/* Tablet landscape and bigger */
+@media (min-width: 960px) {
+  .uk-form-horizontal .uk-form-label {
+    width: 200px;
+    margin-top: 7px;
+    float: left;
+  }
+  .uk-form-horizontal .uk-form-controls {
+    margin-left: 215px;
+  }
+  /* Better vertical alignment if controls are checkboxes and radio buttons with text */
+  .uk-form-horizontal .uk-form-controls-text {
+    padding-top: 7px;
+  }
+}
+/* Icons
+ ========================================================================== */
+/*
+ * 1. Set position
+ * 2. Set width
+ * 3. Center icon vertically and horizontally
+ * 4. Style
+ */
+.uk-form-icon {
+  /* 1 */
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  left: 0;
+  /* 2 */
+  width: 40px;
+  /* 3 */
+  display: inline-flex;
+  justify-content: center;
+  align-items: center;
+  /* 4 */
+  color: #999;
+}
+/*
+ * Required for `a`.
+ */
+.uk-form-icon:hover {
+  color: #666;
+}
+/*
+ * Make `input` element clickable through icon, e.g. if it's a `span`
+ */
+.uk-form-icon:not(a):not(button):not(input) {
+  pointer-events: none;
+}
+/*
+ * Input padding
+ */
+.uk-form-icon:not(.uk-form-icon-flip) ~ .uk-input {
+  padding-left: 40px !important;
+}
+/*
+ * Position modifier
+ */
+.uk-form-icon-flip {
+  right: 0;
+  left: auto;
+}
+.uk-form-icon-flip ~ .uk-input {
+  padding-right: 40px !important;
+}
+/* ========================================================================
+   Component: Button
+ ========================================================================== */
+/*
+ * 1. Remove margins in Chrome, Safari and Opera.
+ * 2. Remove borders for `button`.
+ * 3. Address `overflow` set to `hidden` in IE.
+ * 4. Correct `font` properties and `color` not being inherited for `button`.
+ * 5. Remove the inheritance of text transform in Edge, Firefox, and IE.
+ * 6. Remove default style for `input type="submit"`in iOS.
+ * 7. Style
+ * 8. `line-height` is used to create a height because it also centers the text vertically for `a` elements.
+ *    Better would be to use height and flexbox to center the text vertically but flexbox doesn't work in Firefox on `button` elements.
+ * 9. Align text if button has a width
+ * 10. Required for `a`.
+ */
+.uk-button {
+  /* 1 */
+  margin: 0;
+  /* 2 */
+  border: none;
+  /* 3 */
+  overflow: visible;
+  /* 4 */
+  font: inherit;
+  color: inherit;
+  /* 5 */
+  text-transform: none;
+  /* 6 */
+  -webkit-appearance: none;
+  border-radius: 0;
+  /* 7 */
+  display: inline-block;
+  box-sizing: border-box;
+  padding: 0 30px;
+  vertical-align: middle;
+  font-size: 0.875rem;
+  /* 8 */
+  line-height: 38px;
+  /* 9 */
+  text-align: center;
+  /* 10 */
+  text-decoration: none;
+  text-transform: uppercase;
+  transition: 0.1s ease-in-out;
+  transition-property: color, background-color, border-color;
+}
+.uk-button:not(:disabled) {
+  cursor: pointer;
+}
+/*
+ * Remove the inner border and padding in Firefox.
+ */
+.uk-button::-moz-focus-inner {
+  border: 0;
+  padding: 0;
+}
+/* Hover */
+.uk-button:hover {
+  /* 9 */
+  text-decoration: none;
+}
+/* OnClick + Active */
+/* Style modifiers
+ ========================================================================== */
+/*
+ * Default
+ */
+.uk-button-default {
+  background-color: transparent;
+  color: #333;
+  border: 1px solid #e5e5e5;
+}
+/* Hover */
+.uk-button-default:hover {
+  background-color: transparent;
+  color: #333;
+  border-color: #b2b2b2;
+}
+/* OnClick + Active */
+.uk-button-default:active,
+.uk-button-default.uk-active {
+  background-color: transparent;
+  color: #333;
+  border-color: #999999;
+}
+/*
+ * Primary
+ */
+.uk-button-primary {
+  background-color: #1e87f0;
+  color: #fff;
+  border: 1px solid transparent;
+}
+/* Hover */
+.uk-button-primary:hover {
+  background-color: #0f7ae5;
+  color: #fff;
+}
+/* OnClick + Active */
+.uk-button-primary:active,
+.uk-button-primary.uk-active {
+  background-color: #0e6dcd;
+  color: #fff;
+}
+/*
+ * Secondary
+ */
+.uk-button-secondary {
+  background-color: #222;
+  color: #fff;
+  border: 1px solid transparent;
+}
+/* Hover */
+.uk-button-secondary:hover {
+  background-color: #151515;
+  color: #fff;
+}
+/* OnClick + Active */
+.uk-button-secondary:active,
+.uk-button-secondary.uk-active {
+  background-color: #080808;
+  color: #fff;
+}
+/*
+ * Danger
+ */
+.uk-button-danger {
+  background-color: #f0506e;
+  color: #fff;
+  border: 1px solid transparent;
+}
+/* Hover */
+.uk-button-danger:hover {
+  background-color: #ee395b;
+  color: #fff;
+}
+/* OnClick + Active */
+.uk-button-danger:active,
+.uk-button-danger.uk-active {
+  background-color: #ec2147;
+  color: #fff;
+}
+/*
+ * Disabled
+ * The same for all style modifiers
+ */
+.uk-button-default:disabled,
+.uk-button-primary:disabled,
+.uk-button-secondary:disabled,
+.uk-button-danger:disabled {
+  background-color: transparent;
+  color: #999;
+  border-color: #e5e5e5;
+}
+/* Size modifiers
+ ========================================================================== */
+.uk-button-small {
+  padding: 0 15px;
+  line-height: 28px;
+  font-size: 0.875rem;
+}
+.uk-button-large {
+  padding: 0 40px;
+  line-height: 53px;
+  font-size: 0.875rem;
+}
+/* Text modifiers
+ ========================================================================== */
+/*
+ * Text
+ * 1. Reset
+ * 2. Style
+ */
+.uk-button-text {
+  /* 1 */
+  padding: 0;
+  line-height: 1.5;
+  background: none;
+  /* 2 */
+  color: #333;
+  position: relative;
+}
+.uk-button-text::before {
+  content: "";
+  position: absolute;
+  bottom: 0;
+  left: 0;
+  right: 100%;
+  border-bottom: 1px solid currentColor;
+  transition: right 0.3s ease-out;
+}
+/* Hover */
+.uk-button-text:hover {
+  color: #333;
+}
+.uk-button-text:hover::before {
+  right: 0;
+}
+/* Disabled */
+.uk-button-text:disabled {
+  color: #999;
+}
+.uk-button-text:disabled::before {
+  display: none;
+}
+/*
+ * Link
+ * 1. Reset
+ * 2. Style
+ */
+.uk-button-link {
+  /* 1 */
+  padding: 0;
+  line-height: 1.5;
+  background: none;
+  /* 2 */
+  color: #333;
+}
+/* Hover */
+.uk-button-link:hover {
+  color: #999;
+  text-decoration: none;
+}
+/* Disabled */
+.uk-button-link:disabled {
+  color: #999;
+  text-decoration: none;
+}
+/* Group
+ ========================================================================== */
+/*
+ * 1. Using `flex` instead of `inline-block` to prevent whitespace betweent child elements
+ * 2. Behave like button
+ * 3. Create position context
+ */
+.uk-button-group {
+  /* 1 */
+  display: inline-flex;
+  /* 2 */
+  vertical-align: middle;
+  /* 3 */
+  position: relative;
+}
+/* Group
+     ========================================================================== */
+/*
+     * Collapse border
+     */
+.uk-button-group > .uk-button:nth-child(n+2),
+.uk-button-group > div:nth-child(n+2) .uk-button {
+  margin-left: -1px;
+}
+/*
+     * Create position context to superimpose the successor elements border
+     * Known issue: If you use an `a` element as button and an icon inside,
+     * the active state will not work if you click the icon inside the button
+     * Workaround: Just use a `button` or `input` element as button
+     */
+.uk-button-group .uk-button:hover,
+.uk-button-group .uk-button:focus,
+.uk-button-group .uk-button:active,
+.uk-button-group .uk-button.uk-active {
+  position: relative;
+  z-index: 1;
+}
+/* ========================================================================
+   Component: Progress
+ ========================================================================== */
+/*
+ * 1. Add the correct vertical alignment in all browsers.
+ * 2. Behave like a block element.
+ * 3. Remove borders in Firefox.
+ * 4. Remove default style in Chrome, Safari and Edge.
+ * 5. Style
+ */
+.uk-progress {
+  /* 1 */
+  vertical-align: baseline;
+  /* 2 */
+  display: block;
+  width: 100%;
+  /* 3 */
+  border: 0;
+  /* 4 */
+  background-color: #f8f8f8;
+  /* 5 */
+  margin-bottom: 20px;
+  height: 15px;
+  border-radius: 500px;
+  overflow: hidden;
+}
+/* Add margin if adjacent element */
+* + .uk-progress {
+  margin-top: 20px;
+}
+/*
+ * Show background color set on `uk-progress` in Chrome, Safari and Edge.
+ */
+.uk-progress::-webkit-progress-bar {
+  background-color: transparent;
+}
+/*
+ * Progress Bar
+ * 1. Transitions don't work on `::-moz-progress-bar` pseudo element in Firefox yet.
+ *    https://bugzilla.mozilla.org/show_bug.cgi?id=662351
+ */
+.uk-progress::-webkit-progress-value {
+  background-color: #1e87f0;
+  transition: width 0.6s ease;
+}
+.uk-progress::-moz-progress-bar {
+  background-color: #1e87f0;
+  /* 1 */
+  transition: width 0.6s ease;
+}
+/* ========================================================================
+   Component: Section
+ ========================================================================== */
+/*
+ * 1. Make it work with `100vh` and height in general
+ */
+.uk-section {
+  display: flow-root;
+  box-sizing: border-box;
+  /* 1 */
+  padding-top: 40px;
+  padding-bottom: 40px;
+}
+/* Desktop and bigger */
+@media (min-width: 960px) {
+  .uk-section {
+    padding-top: 70px;
+    padding-bottom: 70px;
+  }
+}
+/*
+ * Remove margin from the last-child
+ */
+.uk-section > :last-child {
+  margin-bottom: 0;
+}
+/* Size modifiers
+ ========================================================================== */
+/*
+ * XSmall
+ */
+.uk-section-xsmall {
+  padding-top: 20px;
+  padding-bottom: 20px;
+}
+/*
+ * Small
+ */
+.uk-section-small {
+  padding-top: 40px;
+  padding-bottom: 40px;
+}
+/*
+ * Large
+ */
+.uk-section-large {
+  padding-top: 70px;
+  padding-bottom: 70px;
+}
+/* Tablet landscape and bigger */
+@media (min-width: 960px) {
+  .uk-section-large {
+    padding-top: 140px;
+    padding-bottom: 140px;
+  }
+}
+/*
+ * XLarge
+ */
+.uk-section-xlarge {
+  padding-top: 140px;
+  padding-bottom: 140px;
+}
+/* Tablet landscape and bigger */
+@media (min-width: 960px) {
+  .uk-section-xlarge {
+    padding-top: 210px;
+    padding-bottom: 210px;
+  }
+}
+/* Style modifiers
+ ========================================================================== */
+/*
+ * Default
+ */
+.uk-section-default {
+  --uk-inverse: dark;
+  background: #fff;
+}
+/*
+ * Muted
+ */
+.uk-section-muted {
+  --uk-inverse: dark;
+  background: #f8f8f8;
+}
+/*
+ * Primary
+ */
+.uk-section-primary {
+  --uk-inverse: light;
+  background: #1e87f0;
+}
+/*
+ * Secondary
+ */
+.uk-section-secondary {
+  --uk-inverse: light;
+  background: #222;
+}
+/* Overlap modifier
+ ========================================================================== */
+/*
+ * Reserved modifier to make a section overlap another section with an border image
+ * Implemented by the theme
+ */
+/* ========================================================================
+   Component: Container
+ ========================================================================== */
+/*
+ * 1. Box sizing has to be `content-box` so the max-width is always the same and
+ *    unaffected by the padding on different breakpoints. It's important for the size modifiers.
+ */
+.uk-container {
+  display: flow-root;
+  /* 1 */
+  box-sizing: content-box;
+  max-width: 1200px;
+  margin-left: auto;
+  margin-right: auto;
+  padding-left: 15px;
+  padding-right: 15px;
+}
+/* Phone landscape and bigger */
+@media (min-width: 640px) {
+  .uk-container {
+    padding-left: 30px;
+    padding-right: 30px;
+  }
+}
+/* Tablet landscape and bigger */
+@media (min-width: 960px) {
+  .uk-container {
+    padding-left: 40px;
+    padding-right: 40px;
+  }
+}
+/*
+ * Remove margin from the last-child
+ */
+.uk-container > :last-child {
+  margin-bottom: 0;
+}
+/*
+ * Remove padding from nested containers
+ */
+.uk-container .uk-container {
+  padding-left: 0;
+  padding-right: 0;
+}
+/* Size modifier
+ ========================================================================== */
+.uk-container-xsmall {
+  max-width: 750px;
+}
+.uk-container-small {
+  max-width: 900px;
+}
+.uk-container-large {
+  max-width: 1400px;
+}
+.uk-container-xlarge {
+  max-width: 1600px;
+}
+.uk-container-expand {
+  max-width: none;
+}
+/* Expand modifier
+ ========================================================================== */
+/*
+ * Expand one side only
+ */
+.uk-container-expand-left {
+  margin-left: 0;
+}
+.uk-container-expand-right {
+  margin-right: 0;
+}
+/* Phone landscape and bigger */
+@media (min-width: 640px) {
+  .uk-container-expand-left.uk-container-xsmall,
+  .uk-container-expand-right.uk-container-xsmall {
+    max-width: calc(50% + (750px / 2) - 30px);
+  }
+  .uk-container-expand-left.uk-container-small,
+  .uk-container-expand-right.uk-container-small {
+    max-width: calc(50% + (900px / 2) - 30px);
+  }
+}
+/* Tablet landscape and bigger */
+@media (min-width: 960px) {
+  .uk-container-expand-left,
+  .uk-container-expand-right {
+    max-width: calc(50% + (1200px / 2) - 40px);
+  }
+  .uk-container-expand-left.uk-container-xsmall,
+  .uk-container-expand-right.uk-container-xsmall {
+    max-width: calc(50% + (750px / 2) - 40px);
+  }
+  .uk-container-expand-left.uk-container-small,
+  .uk-container-expand-right.uk-container-small {
+    max-width: calc(50% + (900px / 2) - 40px);
+  }
+  .uk-container-expand-left.uk-container-large,
+  .uk-container-expand-right.uk-container-large {
+    max-width: calc(50% + (1400px / 2) - 40px);
+  }
+  .uk-container-expand-left.uk-container-xlarge,
+  .uk-container-expand-right.uk-container-xlarge {
+    max-width: calc(50% + (1600px / 2) - 40px);
+  }
+}
+/* Item
+ ========================================================================== */
+/*
+ * Utility classes to reset container padding on the left or right side
+ * Note: It has to be negative margin on the item, because it's specific to the item.
+ */
+.uk-container-item-padding-remove-left,
+.uk-container-item-padding-remove-right {
+  width: calc(100% + 15px);
+}
+.uk-container-item-padding-remove-left {
+  margin-left: -15px;
+}
+.uk-container-item-padding-remove-right {
+  margin-right: -15px;
+}
+/* Phone landscape and bigger */
+@media (min-width: 640px) {
+  .uk-container-item-padding-remove-left,
+  .uk-container-item-padding-remove-right {
+    width: calc(100% + 30px);
+  }
+  .uk-container-item-padding-remove-left {
+    margin-left: -30px;
+  }
+  .uk-container-item-padding-remove-right {
+    margin-right: -30px;
+  }
+}
+/* Tablet landscape and bigger */
+@media (min-width: 960px) {
+  .uk-container-item-padding-remove-left,
+  .uk-container-item-padding-remove-right {
+    width: calc(100% + 40px);
+  }
+  .uk-container-item-padding-remove-left {
+    margin-left: -40px;
+  }
+  .uk-container-item-padding-remove-right {
+    margin-right: -40px;
+  }
+}
+/* ========================================================================
+   Component: Tile
+ ========================================================================== */
+.uk-tile {
+  display: flow-root;
+  position: relative;
+  box-sizing: border-box;
+  padding-left: 15px;
+  padding-right: 15px;
+  padding-top: 40px;
+  padding-bottom: 40px;
+}
+/* Phone landscape and bigger */
+@media (min-width: 640px) {
+  .uk-tile {
+    padding-left: 30px;
+    padding-right: 30px;
+  }
+}
+/* Tablet landscape and bigger */
+@media (min-width: 960px) {
+  .uk-tile {
+    padding-left: 40px;
+    padding-right: 40px;
+    padding-top: 70px;
+    padding-bottom: 70px;
+  }
+}
+/*
+ * Remove margin from the last-child
+ */
+.uk-tile > :last-child {
+  margin-bottom: 0;
+}
+/* Size modifiers
+ ========================================================================== */
+/*
+ * XSmall
+ */
+.uk-tile-xsmall {
+  padding-top: 20px;
+  padding-bottom: 20px;
+}
+/*
+ * Small
+ */
+.uk-tile-small {
+  padding-top: 40px;
+  padding-bottom: 40px;
+}
+/*
+ * Large
+ */
+.uk-tile-large {
+  padding-top: 70px;
+  padding-bottom: 70px;
+}
+/* Tablet landscape and bigger */
+@media (min-width: 960px) {
+  .uk-tile-large {
+    padding-top: 140px;
+    padding-bottom: 140px;
+  }
+}
+/*
+ * XLarge
+ */
+.uk-tile-xlarge {
+  padding-top: 140px;
+  padding-bottom: 140px;
+}
+/* Tablet landscape and bigger */
+@media (min-width: 960px) {
+  .uk-tile-xlarge {
+    padding-top: 210px;
+    padding-bottom: 210px;
+  }
+}
+/* Style modifiers
+ ========================================================================== */
+/*
+ * Default
+ */
+.uk-tile-default {
+  --uk-inverse: dark;
+  background-color: #fff;
+}
+/*
+ * Muted
+ */
+.uk-tile-muted {
+  --uk-inverse: dark;
+  background-color: #f8f8f8;
+}
+/*
+ * Primary
+ */
+.uk-tile-primary {
+  --uk-inverse: light;
+  background-color: #1e87f0;
+}
+/*
+ * Secondary
+ */
+.uk-tile-secondary {
+  --uk-inverse: light;
+  background-color: #222;
+}
+/* ========================================================================
+   Component: Card
+ ========================================================================== */
+.uk-card {
+  position: relative;
+  box-sizing: border-box;
+  transition: box-shadow 0.1s ease-in-out;
+}
+/* Sections
+ ========================================================================== */
+.uk-card-body {
+  display: flow-root;
+  padding: 30px 30px;
+}
+.uk-card-header {
+  display: flow-root;
+  padding: 15px 30px;
+}
+.uk-card-footer {
+  display: flow-root;
+  padding: 15px 30px;
+}
+/* Desktop and bigger */
+@media (min-width: 1200px) {
+  .uk-card-body {
+    padding: 40px 40px;
+  }
+  .uk-card-header {
+    padding: 20px 40px;
+  }
+  .uk-card-footer {
+    padding: 20px 40px;
+  }
+}
+/*
+ * Remove margin from the last-child
+ */
+.uk-card-body > :last-child,
+.uk-card-header > :last-child,
+.uk-card-footer > :last-child {
+  margin-bottom: 0;
+}
+/* Media
+ ========================================================================== */
+/*
+ * Reserved alignment modifier to style the media element, e.g. with `border-radius`
+ * Implemented by the theme
+ */
+/* Title
+ ========================================================================== */
+.uk-card-title {
+  font-size: 1.5rem;
+  line-height: 1.4;
+}
+/* Badge
+ ========================================================================== */
+/*
+ * 1. Position
+ * 2. Size
+ * 3. Style
+ * 4. Center child vertically
+ */
+.uk-card-badge {
+  /* 1 */
+  position: absolute;
+  top: 15px;
+  right: 15px;
+  z-index: 1;
+  /* 2 */
+  height: 22px;
+  padding: 0 10px;
+  /* 3 */
+  background: #1e87f0;
+  color: #fff;
+  font-size: 0.875rem;
+  /* 4 */
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  line-height: 0;
+  border-radius: 2px;
+  text-transform: uppercase;
+}
+/*
+ * Remove margin from adjacent element
+ */
+.uk-card-badge:first-child + * {
+  margin-top: 0;
+}
+/* Hover modifier
+ ========================================================================== */
+.uk-card-hover:not(.uk-card-default):not(.uk-card-primary):not(.uk-card-secondary):hover {
+  background-color: #fff;
+  box-shadow: 0 14px 25px rgba(0, 0, 0, 0.16);
+}
+/* Style modifiers
+ ========================================================================== */
+/*
+ * Default
+ * Note: Header and Footer are only implemented for the default style
+ */
+.uk-card-default {
+  --uk-inverse: dark;
+  background-color: #fff;
+  color: #666;
+  box-shadow: 0 5px 15px rgba(0, 0, 0, 0.08);
+}
+.uk-card-default .uk-card-title {
+  color: #333;
+}
+.uk-card-default.uk-card-hover:hover {
+  background-color: #fff;
+  box-shadow: 0 14px 25px rgba(0, 0, 0, 0.16);
+}
+.uk-card-default .uk-card-header {
+  border-bottom: 1px solid #e5e5e5;
+}
+.uk-card-default .uk-card-footer {
+  border-top: 1px solid #e5e5e5;
+}
+/*
+ * Primary
+ */
+.uk-card-primary {
+  --uk-inverse: light;
+  background-color: #1e87f0;
+  color: #fff;
+  box-shadow: 0 5px 15px rgba(0, 0, 0, 0.08);
+}
+.uk-card-primary .uk-card-title {
+  color: #fff;
+}
+.uk-card-primary.uk-card-hover:hover {
+  background-color: #1e87f0;
+  box-shadow: 0 14px 25px rgba(0, 0, 0, 0.16);
+}
+/*
+ * Secondary
+ */
+.uk-card-secondary {
+  --uk-inverse: light;
+  background-color: #222;
+  color: #fff;
+  box-shadow: 0 5px 15px rgba(0, 0, 0, 0.08);
+}
+.uk-card-secondary .uk-card-title {
+  color: #fff;
+}
+.uk-card-secondary.uk-card-hover:hover {
+  background-color: #222;
+  box-shadow: 0 14px 25px rgba(0, 0, 0, 0.16);
+}
+/* Size modifier
+ ========================================================================== */
+/*
+ * Small
+ */
+.uk-card-small.uk-card-body,
+.uk-card-small .uk-card-body {
+  padding: 20px 20px;
+}
+.uk-card-small .uk-card-header {
+  padding: 13px 20px;
+}
+.uk-card-small .uk-card-footer {
+  padding: 13px 20px;
+}
+/*
+ * Large
+ */
+/* Desktop and bigger */
+@media (min-width: 1200px) {
+  .uk-card-large.uk-card-body,
+  .uk-card-large .uk-card-body {
+    padding: 70px 70px;
+  }
+  .uk-card-large .uk-card-header {
+    padding: 35px 70px;
+  }
+  .uk-card-large .uk-card-footer {
+    padding: 35px 70px;
+  }
+}
+/*
+     * Default
+     */
+.uk-card-body > .uk-nav-default {
+  margin-left: -30px;
+  margin-right: -30px;
+}
+.uk-card-body > .uk-nav-default:only-child {
+  margin-top: -15px;
+  margin-bottom: -15px;
+}
+.uk-card-body > .uk-nav-default > li > a,
+.uk-card-body > .uk-nav-default .uk-nav-header,
+.uk-card-body > .uk-nav-default .uk-nav-divider {
+  padding-left: 30px;
+  padding-right: 30px;
+}
+.uk-card-body > .uk-nav-default .uk-nav-sub {
+  padding-left: 45px;
+}
+/* Desktop and bigger */
+@media (min-width: 1200px) {
+  .uk-card-body > .uk-nav-default {
+    margin-left: -40px;
+    margin-right: -40px;
+  }
+  .uk-card-body > .uk-nav-default:only-child {
+    margin-top: -25px;
+    margin-bottom: -25px;
+  }
+  .uk-card-body > .uk-nav-default > li > a,
+  .uk-card-body > .uk-nav-default .uk-nav-header,
+  .uk-card-body > .uk-nav-default .uk-nav-divider {
+    padding-left: 40px;
+    padding-right: 40px;
+  }
+  .uk-card-body > .uk-nav-default .uk-nav-sub {
+    padding-left: 55px;
+  }
+}
+/*
+     * Small
+     */
+.uk-card-small > .uk-nav-default {
+  margin-left: -20px;
+  margin-right: -20px;
+}
+.uk-card-small > .uk-nav-default:only-child {
+  margin-top: -5px;
+  margin-bottom: -5px;
+}
+.uk-card-small > .uk-nav-default > li > a,
+.uk-card-small > .uk-nav-default .uk-nav-header,
+.uk-card-small > .uk-nav-default .uk-nav-divider {
+  padding-left: 20px;
+  padding-right: 20px;
+}
+.uk-card-small > .uk-nav-default .uk-nav-sub {
+  padding-left: 35px;
+}
+/*
+     * Large
+     */
+/* Desktop and bigger */
+@media (min-width: 1200px) {
+  .uk-card-large > .uk-nav-default {
+    margin: 0;
+  }
+  .uk-card-large > .uk-nav-default:only-child {
+    margin: 0;
+  }
+  .uk-card-large > .uk-nav-default > li > a,
+  .uk-card-large > .uk-nav-default .uk-nav-header,
+  .uk-card-large > .uk-nav-default .uk-nav-divider {
+    padding-left: 0;
+    padding-right: 0;
+  }
+  .uk-card-large > .uk-nav-default .uk-nav-sub {
+    padding-left: 15px;
+  }
+}
+/* ========================================================================
+   Component: Close
+ ========================================================================== */
+/*
+ * Adopts `uk-icon`
+ */
+.uk-close {
+  color: #999;
+  transition: 0.1s ease-in-out;
+  transition-property: color, opacity;
+}
+/* Hover */
+.uk-close:hover {
+  color: #666;
+}
+/* ========================================================================
+   Component: Spinner
+ ========================================================================== */
+/*
+ * Adopts `uk-icon`
+ */
+/* SVG
+ ========================================================================== */
+.uk-spinner > * {
+  animation: uk-spinner-rotate 1.4s linear infinite;
+}
+@keyframes uk-spinner-rotate {
+  0% {
+    transform: rotate(0deg);
+  }
+  100% {
+    transform: rotate(270deg);
+  }
+}
+/*
+ * Circle
+ */
+.uk-spinner > * > * {
+  stroke-dasharray: 88px;
+  stroke-dashoffset: 0;
+  transform-origin: center;
+  animation: uk-spinner-dash 1.4s ease-in-out infinite;
+  stroke-width: 1;
+  stroke-linecap: round;
+}
+@keyframes uk-spinner-dash {
+  0% {
+    stroke-dashoffset: 88px;
+  }
+  50% {
+    stroke-dashoffset: 22px;
+    transform: rotate(135deg);
+  }
+  100% {
+    stroke-dashoffset: 88px;
+    transform: rotate(450deg);
+  }
+}
+/* ========================================================================
+   Component: Totop
+ ========================================================================== */
+/*
+ * Addopts `uk-icon`
+ */
+.uk-totop {
+  padding: 5px;
+  color: #999;
+  transition: color 0.1s ease-in-out;
+}
+/* Hover */
+.uk-totop:hover {
+  color: #666;
+}
+/* OnClick */
+.uk-totop:active {
+  color: #333;
+}
+/* ========================================================================
+   Component: Marker
+ ========================================================================== */
+/*
+ * Addopts `uk-icon`
+ */
+.uk-marker {
+  padding: 5px;
+  background: #222;
+  color: #fff;
+  border-radius: 500px;
+}
+/* Hover */
+.uk-marker:hover {
+  color: #fff;
+}
+/* ========================================================================
+   Component: Alert
+ ========================================================================== */
+.uk-alert {
+  position: relative;
+  margin-bottom: 20px;
+  padding: 15px 29px 15px 15px;
+  background: #f8f8f8;
+  color: #666;
+}
+/* Add margin if adjacent element */
+* + .uk-alert {
+  margin-top: 20px;
+}
+/*
+ * Remove margin from the last-child
+ */
+.uk-alert > :last-child {
+  margin-bottom: 0;
+}
+/* Close
+ * Adopts `uk-close`
+ ========================================================================== */
+.uk-alert-close {
+  position: absolute;
+  top: 20px;
+  right: 15px;
+  color: inherit;
+  opacity: 0.4;
+}
+/*
+ * Remove margin from adjacent element
+ */
+.uk-alert-close:first-child + * {
+  margin-top: 0;
+}
+/*
+ * Hover
+ */
+.uk-alert-close:hover {
+  color: inherit;
+  opacity: 0.8;
+}
+/* Style modifiers
+ ========================================================================== */
+/*
+ * Primary
+ */
+.uk-alert-primary {
+  background: #d8eafc;
+  color: #1e87f0;
+}
+/*
+ * Success
+ */
+.uk-alert-success {
+  background: #edfbf6;
+  color: #32d296;
+}
+/*
+ * Warning
+ */
+.uk-alert-warning {
+  background: #fff6ee;
+  color: #faa05a;
+}
+/*
+ * Danger
+ */
+.uk-alert-danger {
+  background: #fef4f6;
+  color: #f0506e;
+}
+/*
+     * Content
+     */
+.uk-alert h1,
+.uk-alert h2,
+.uk-alert h3,
+.uk-alert h4,
+.uk-alert h5,
+.uk-alert h6 {
+  color: inherit;
+}
+.uk-alert a:not([class]) {
+  color: inherit;
+  text-decoration: underline;
+}
+.uk-alert a:not([class]):hover {
+  color: inherit;
+  text-decoration: underline;
+}
+/* ========================================================================
+   Component: Placeholder
+ ========================================================================== */
+.uk-placeholder {
+  margin-bottom: 20px;
+  padding: 30px 30px;
+  background: transparent;
+  border: 1px dashed #e5e5e5;
+}
+/* Add margin if adjacent element */
+* + .uk-placeholder {
+  margin-top: 20px;
+}
+/*
+ * Remove margin from the last-child
+ */
+.uk-placeholder > :last-child {
+  margin-bottom: 0;
+}
+/* ========================================================================
+   Component: Badge
+ ========================================================================== */
+/*
+ * 1. Style
+ * 2. Center child vertically and horizontally
+ */
+.uk-badge {
+  box-sizing: border-box;
+  min-width: 18px;
+  height: 18px;
+  padding: 0 5px;
+  border-radius: 500px;
+  vertical-align: middle;
+  /* 1 */
+  background: #1e87f0;
+  color: #fff !important;
+  font-size: 11px;
+  /* 2 */
+  display: inline-flex;
+  justify-content: center;
+  align-items: center;
+  line-height: 0;
+}
+/*
+ * Required for `a`
+ */
+.uk-badge:hover {
+  text-decoration: none;
+}
+/* ========================================================================
+   Component: Label
+ ========================================================================== */
+.uk-label {
+  display: inline-block;
+  padding: 0 10px;
+  background: #1e87f0;
+  line-height: 1.5;
+  font-size: 0.875rem;
+  color: #fff;
+  vertical-align: middle;
+  white-space: nowrap;
+  border-radius: 2px;
+  text-transform: uppercase;
+}
+/* Color modifiers
+ ========================================================================== */
+/*
+ * Success
+ */
+.uk-label-success {
+  background-color: #32d296;
+  color: #fff;
+}
+/*
+ * Warning
+ */
+.uk-label-warning {
+  background-color: #faa05a;
+  color: #fff;
+}
+/*
+ * Danger
+ */
+.uk-label-danger {
+  background-color: #f0506e;
+  color: #fff;
+}
+/* ========================================================================
+   Component: Overlay
+ ========================================================================== */
+.uk-overlay {
+  padding: 30px 30px;
+}
+/*
+ * Remove margin from the last-child
+ */
+.uk-overlay > :last-child {
+  margin-bottom: 0;
+}
+/* Icon
+ ========================================================================== */
+/* Style modifiers
+ ========================================================================== */
+/*
+ * Default
+ */
+.uk-overlay-default {
+  --uk-inverse: dark;
+  background: rgba(255, 255, 255, 0.8);
+}
+/*
+ * Primary
+ */
+.uk-overlay-primary {
+  --uk-inverse: light;
+  background: rgba(34, 34, 34, 0.8);
+}
+/* ========================================================================
+   Component: Article
+ ========================================================================== */
+.uk-article {
+  display: flow-root;
+}
+/*
+ * Remove margin from the last-child
+ */
+.uk-article > :last-child {
+  margin-bottom: 0;
+}
+/* Adjacent sibling
+ ========================================================================== */
+.uk-article + .uk-article {
+  margin-top: 70px;
+}
+/* Title
+ ========================================================================== */
+.uk-article-title {
+  font-size: 2.23125rem;
+  line-height: 1.2;
+}
+/* Tablet landscape and bigger */
+@media (min-width: 960px) {
+  .uk-article-title {
+    font-size: 2.625rem;
+  }
+}
+/* Meta
+ ========================================================================== */
+.uk-article-meta {
+  font-size: 0.875rem;
+  line-height: 1.4;
+  color: #999;
+}
+.uk-article-meta a {
+  color: #999;
+}
+.uk-article-meta a:hover {
+  color: #666;
+  text-decoration: none;
+}
+/* ========================================================================
+   Component: Comment
+ ========================================================================== */
+/* Sections
+ ========================================================================== */
+.uk-comment-body {
+  display: flow-root;
+  overflow-wrap: break-word;
+  word-wrap: break-word;
+}
+.uk-comment-header {
+  display: flow-root;
+  margin-bottom: 20px;
+}
+/*
+ * Remove margin from the last-child
+ */
+.uk-comment-body > :last-child,
+.uk-comment-header > :last-child {
+  margin-bottom: 0;
+}
+/* Title
+ ========================================================================== */
+.uk-comment-title {
+  font-size: 1.25rem;
+  line-height: 1.4;
+}
+/* Meta
+ ========================================================================== */
+.uk-comment-meta {
+  font-size: 0.875rem;
+  line-height: 1.4;
+  color: #999;
+}
+/* Avatar
+ ========================================================================== */
+/* List
+ ========================================================================== */
+.uk-comment-list {
+  padding: 0;
+  list-style: none;
+}
+/* Adjacent siblings */
+.uk-comment-list > :nth-child(n+2) {
+  margin-top: 70px;
+}
+/*
+ * Sublists
+ * Note: General sibling selector allows reply block between comment and sublist
+ */
+.uk-comment-list .uk-comment ~ ul {
+  margin: 70px 0 0 0;
+  padding-left: 30px;
+  list-style: none;
+}
+/* Tablet and bigger */
+@media (min-width: 960px) {
+  .uk-comment-list .uk-comment ~ ul {
+    padding-left: 100px;
+  }
+}
+/* Adjacent siblings */
+.uk-comment-list .uk-comment ~ ul > :nth-child(n+2) {
+  margin-top: 70px;
+}
+/* Style modifier
+ ========================================================================== */
+.uk-comment-primary {
+  padding: 30px;
+  background-color: #f8f8f8;
+}
+/* ========================================================================
+   Component: Search
+ ========================================================================== */
+/*
+ * 1. Container fits its content
+ * 2. Create position context
+ * 3. Prevent content overflow
+ * 4. Reset `form`
+ */
+.uk-search {
+  /* 1 */
+  display: inline-block;
+  /* 2 */
+  position: relative;
+  /* 3 */
+  max-width: 100%;
+  /* 4 */
+  margin: 0;
+}
+/* Input
+ ========================================================================== */
+/*
+ * Remove the inner padding and cancel buttons in Chrome on OS X and Safari on OS X.
+ */
+.uk-search-input::-webkit-search-cancel-button,
+.uk-search-input::-webkit-search-decoration {
+  -webkit-appearance: none;
+}
+/*
+ * Removes placeholder transparency in Firefox.
+ */
+.uk-search-input::-moz-placeholder {
+  opacity: 1;
+}
+/*
+ * 1. Define consistent box sizing.
+ * 2. Address margins set differently in Firefox/IE and Chrome/Safari/Opera.
+ * 3. Remove `border-radius` in iOS.
+ * 4. Change font properties to `inherit` in all browsers
+ * 5. Show the overflow in Edge.
+ * 6. Remove default style in iOS.
+ * 7. Vertical alignment
+ * 8. Take the full container width
+ * 9. Style
+ */
+.uk-search-input {
+  /* 1 */
+  box-sizing: border-box;
+  /* 2 */
+  margin: 0;
+  /* 3 */
+  border-radius: 0;
+  /* 4 */
+  font: inherit;
+  /* 5 */
+  overflow: visible;
+  /* 6 */
+  -webkit-appearance: none;
+  /* 7 */
+  vertical-align: middle;
+  /* 8 */
+  width: 100%;
+  /* 9 */
+  border: none;
+  color: #666;
+}
+.uk-search-input:focus {
+  outline: none;
+}
+/* Placeholder */
+.uk-search-input::placeholder {
+  color: #999;
+}
+/* Icon (Adopts `uk-icon`)
+ ========================================================================== */
+/*
+ * Position above input
+ * 1. Set position
+ * 2. Center icon vertically and horizontally
+ * 3. Style
+ */
+.uk-search .uk-search-icon {
+  /* 1 */
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  left: 0;
+  /* 2 */
+  display: inline-flex;
+  justify-content: center;
+  align-items: center;
+  /* 3 */
+  color: #999;
+}
+/*
+ * Required for `a`.
+ */
+.uk-search .uk-search-icon:hover {
+  color: #999;
+}
+/*
+ * Make `input` element clickable through icon, e.g. if it's a `span`
+ */
+.uk-search .uk-search-icon:not(a):not(button):not(input) {
+  pointer-events: none;
+}
+/*
+ * Position modifier
+ */
+.uk-search .uk-search-icon-flip {
+  right: 0;
+  left: auto;
+}
+/* Default modifier
+ ========================================================================== */
+.uk-search-default {
+  width: 240px;
+}
+/*
+ * Input
+ */
+.uk-search-default .uk-search-input {
+  height: 40px;
+  padding-left: 10px;
+  padding-right: 10px;
+  background: transparent;
+  border: 1px solid #e5e5e5;
+}
+/* Focus */
+.uk-search-default .uk-search-input:focus {
+  background-color: rgba(0, 0, 0, 0);
+  border-color: #1e87f0;
+}
+/*
+ * Icon
+ */
+.uk-search-default .uk-search-icon {
+  width: 40px;
+}
+.uk-search-default:has(.uk-search-icon:not(.uk-search-icon-flip)) .uk-search-input {
+  padding-left: 40px;
+}
+.uk-search-default:has(.uk-search-icon-flip) .uk-search-input {
+  padding-right: 40px;
+}
+/* Navbar modifier
+ ========================================================================== */
+.uk-search-navbar {
+  width: 240px;
+}
+/*
+ * Input
+ */
+.uk-search-navbar .uk-search-input {
+  height: 40px;
+  padding-left: 10px;
+  padding-right: 10px;
+  background: #fff;
+  border: 1px solid #e5e5e5;
+}
+/* Focus */
+.uk-search-navbar .uk-search-input:focus {
+  background-color: #fff;
+  border-color: #1e87f0;
+}
+/*
+ * Icon
+ */
+.uk-search-navbar .uk-search-icon {
+  width: 40px;
+}
+.uk-search-navbar:has(.uk-search-icon:not(.uk-search-icon-flip)) .uk-search-input {
+  padding-left: 40px;
+}
+.uk-search-navbar:has(.uk-search-icon-flip) .uk-search-input {
+  padding-right: 40px;
+}
+/* Medium modifier
+ ========================================================================== */
+.uk-search-medium {
+  width: 400px;
+}
+/*
+ * Input
+ */
+.uk-search-medium .uk-search-input {
+  height: 40px;
+  background: transparent;
+  font-size: 1.5rem;
+}
+/* Focus */
+/*
+ * Icon
+ */
+.uk-search-medium .uk-search-icon {
+  width: 24px;
+}
+.uk-search-medium:has(.uk-search-icon:not(.uk-search-icon-flip)) .uk-search-input {
+  padding-left: 34px;
+}
+.uk-search-medium:has(.uk-search-icon-flip) .uk-search-input {
+  padding-right: 34px;
+}
+/* Large modifier
+ ========================================================================== */
+.uk-search-large {
+  width: 500px;
+}
+/*
+ * Input
+ */
+.uk-search-large .uk-search-input {
+  height: 80px;
+  background: transparent;
+  font-size: 2.625rem;
+}
+/* Focus */
+/*
+ * Icon
+ */
+.uk-search-large .uk-search-icon {
+  width: 40px;
+}
+.uk-search-large:has(.uk-search-icon:not(.uk-search-icon-flip)) .uk-search-input {
+  padding-left: 60px;
+}
+.uk-search-large:has(.uk-search-icon-flip) .uk-search-input {
+  padding-right: 60px;
+}
+/* Toggle
+ ========================================================================== */
+.uk-search-toggle {
+  color: #999;
+}
+/* Hover */
+.uk-search-toggle:hover {
+  color: #666;
+}
+/* ========================================================================
+   Component: Accordion
+ ========================================================================== */
+.uk-accordion {
+  padding: 0;
+  list-style: none;
+}
+/* Item
+ ========================================================================== */
+.uk-accordion > :nth-child(n+2) {
+  margin-top: 20px;
+}
+/* Title
+ ========================================================================== */
+.uk-accordion-title {
+  display: block;
+  font-size: 1.25rem;
+  line-height: 1.4;
+  color: #333;
+  overflow: hidden;
+}
+.uk-accordion-title::before {
+  content: "";
+  width: 1.4em;
+  height: 1.4em;
+  margin-left: 10px;
+  float: right;
+  background-image: url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2213%22%20height%3D%2213%22%20viewBox%3D%220%200%2013%2013%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Crect%20fill%3D%22%23666%22%20width%3D%2213%22%20height%3D%221%22%20x%3D%220%22%20y%3D%226%22%20%2F%3E%0A%20%20%20%20%3Crect%20fill%3D%22%23666%22%20width%3D%221%22%20height%3D%2213%22%20x%3D%226%22%20y%3D%220%22%20%2F%3E%0A%3C%2Fsvg%3E");
+  background-repeat: no-repeat;
+  background-position: 50% 50%;
+}
+.uk-open > .uk-accordion-title::before {
+  background-image: url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2213%22%20height%3D%2213%22%20viewBox%3D%220%200%2013%2013%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Crect%20fill%3D%22%23666%22%20width%3D%2213%22%20height%3D%221%22%20x%3D%220%22%20y%3D%226%22%20%2F%3E%0A%3C%2Fsvg%3E");
+}
+/* Hover */
+.uk-accordion-title:hover {
+  color: #666;
+  text-decoration: none;
+}
+/* Content
+ ========================================================================== */
+.uk-accordion-content {
+  display: flow-root;
+  margin-top: 20px;
+}
+/*
+ * Remove margin from the last-child
+ */
+.uk-accordion-content > :last-child {
+  margin-bottom: 0;
+}
+/* ========================================================================
+   Component: Drop
+ ========================================================================== */
+/*
+ * 1. Hide by default
+ * 2. Set position
+ * 3. Set a default width
+ */
+.uk-drop {
+  /* 1 */
+  display: none;
+  /* 2 */
+  position: absolute;
+  z-index: 1020;
+  --uk-position-offset: 20px;
+  --uk-position-viewport-offset: 15px;
+  /* 3 */
+  box-sizing: border-box;
+  width: 300px;
+}
+/* Show */
+.uk-drop.uk-open {
+  display: block;
+}
+/* Grid modifiers
+ ========================================================================== */
+.uk-drop-stack .uk-drop-grid > * {
+  width: 100% !important;
+}
+/* Parent icon
+ ========================================================================== */
+.uk-drop-parent-icon {
+  margin-left: 0.25em;
+  transition: transform 0.3s ease-out;
+}
+[aria-expanded="true"] > .uk-drop-parent-icon {
+  transform: rotateX(180deg);
+}
+/* ========================================================================
+   Component: Dropbar
+ ========================================================================== */
+/*
+ * Adopts `uk-drop`
+ * 1. Reset drop
+ * 2. Style
+ */
+.uk-dropbar {
+  --uk-position-offset: 0;
+  --uk-position-shift-offset: 0;
+  --uk-position-viewport-offset: 0;
+  --uk-inverse: dark;
+  /* 1 */
+  width: auto;
+  /* 2 */
+  padding: 25px 15px 25px 15px;
+  background: #fff;
+  color: #666;
+}
+/*
+ * Remove margin from the last-child
+ */
+.uk-dropbar > :last-child {
+  margin-bottom: 0;
+}
+/* Phone landscape and bigger */
+@media (min-width: 640px) {
+  .uk-dropbar {
+    padding-left: 30px;
+    padding-right: 30px;
+  }
+}
+/* Tablet landscape and bigger */
+@media (min-width: 960px) {
+  .uk-dropbar {
+    padding-left: 40px;
+    padding-right: 40px;
+  }
+}
+.uk-dropbar :focus-visible {
+  outline-color: #333 !important;
+}
+/* Size modifier
+ ========================================================================== */
+.uk-dropbar-large {
+  padding-top: 40px;
+  padding-bottom: 40px;
+}
+/* Direction modifier
+ ========================================================================== */
+.uk-dropbar-top {
+  box-shadow: 0 12px 7px -6px rgba(0, 0, 0, 0.05);
+}
+.uk-dropbar-bottom {
+  box-shadow: 0 -12px 7px -6px rgba(0, 0, 0, 0.05);
+}
+.uk-dropbar-left {
+  box-shadow: 12px 0 7px -6px rgba(0, 0, 0, 0.05);
+}
+.uk-dropbar-right {
+  box-shadow: -12px 0 7px -6px rgba(0, 0, 0, 0.05);
+}
+/* ========================================================================
+   Component: Dropnav
+ ========================================================================== */
+/*
+ * 1. Position
+ * 2. Reset dropbar
+ * 3. Width
+ */
+.uk-dropnav-dropbar {
+  /* 1 */
+  position: absolute;
+  z-index: 980;
+  /* 2 */
+  padding: 0;
+  /* 3 */
+  left: 0;
+  right: 0;
+}
+/* ========================================================================
+   Component: Modal
+ ========================================================================== */
+/*
+ * 1. Hide by default
+ * 2. Set position
+ * 3. Allow scrolling for the modal dialog
+ * 4. Horizontal padding
+ * 5. Mask the background page
+ * 6. Fade-in transition
+ */
+.uk-modal {
+  /* 1 */
+  display: none;
+  /* 2 */
+  position: fixed;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  z-index: 1010;
+  /* 3 */
+  overflow-y: auto;
+  /* 4 */
+  padding: 15px 15px;
+  /* 5 */
+  background: rgba(0, 0, 0, 0.6);
+  /* 6 */
+  opacity: 0;
+  transition: opacity 0.15s linear;
+}
+/* Phone landscape and bigger */
+@media (min-width: 640px) {
+  .uk-modal {
+    padding: 50px 30px;
+  }
+}
+/* Tablet landscape and bigger */
+@media (min-width: 960px) {
+  .uk-modal {
+    padding-left: 40px;
+    padding-right: 40px;
+  }
+}
+/*
+ * Open
+ */
+.uk-modal.uk-open {
+  opacity: 1;
+}
+/* Page
+ ========================================================================== */
+/*
+ * Prevent scrollbars
+ */
+.uk-modal-page {
+  overflow: hidden;
+}
+/* Dialog
+ ========================================================================== */
+/*
+ * 1. Create position context for spinner and close button
+ * 2. Dimensions
+ * 3. `!important` is needed to overwrite `uk-width-auto`. See `#modal-media-image` in tests
+ * 4. Style
+ * 5. Slide-in transition
+ */
+.uk-modal-dialog {
+  /* 1 */
+  position: relative;
+  /* 2 */
+  box-sizing: border-box;
+  margin: 0 auto;
+  width: 600px;
+  /* 3 */
+  max-width: 100% !important;
+  /* 4 */
+  background: #fff;
+  /* 5 */
+  opacity: 0;
+  transform: translateY(-100px);
+  transition: 0.3s linear;
+  transition-property: opacity, transform;
+}
+/*
+ * Open
+ */
+.uk-open > .uk-modal-dialog {
+  opacity: 1;
+  transform: translateY(0);
+}
+/* Size modifier
+ ========================================================================== */
+/*
+ * Container size
+ * Take the same size as the Container component
+ */
+.uk-modal-container .uk-modal-dialog {
+  width: 1200px;
+}
+/*
+ * Full size
+ * 1. Remove padding and background from modal
+ * 2. Reset all default declarations from modal dialog
+ */
+/* 1 */
+.uk-modal-full {
+  padding: 0;
+  background: none;
+}
+/* 2 */
+.uk-modal-full .uk-modal-dialog {
+  margin: 0;
+  width: 100%;
+  max-width: 100%;
+  transform: translateY(0);
+}
+/* Sections
+ ========================================================================== */
+.uk-modal-body {
+  display: flow-root;
+  padding: 20px 20px;
+}
+.uk-modal-header {
+  display: flow-root;
+  padding: 10px 20px;
+  background: #fff;
+  border-bottom: 1px solid #e5e5e5;
+}
+.uk-modal-footer {
+  display: flow-root;
+  padding: 10px 20px;
+  background: #fff;
+  border-top: 1px solid #e5e5e5;
+}
+/* Phone landscape and bigger */
+@media (min-width: 640px) {
+  .uk-modal-body {
+    padding: 30px 30px;
+  }
+  .uk-modal-header {
+    padding: 15px 30px;
+  }
+  .uk-modal-footer {
+    padding: 15px 30px;
+  }
+}
+/*
+ * Remove margin from the last-child
+ */
+.uk-modal-body > :last-child,
+.uk-modal-header > :last-child,
+.uk-modal-footer > :last-child {
+  margin-bottom: 0;
+}
+/* Title
+ ========================================================================== */
+.uk-modal-title {
+  font-size: 2rem;
+  line-height: 1.3;
+}
+/* Close
+ * Adopts `uk-close`
+ ========================================================================== */
+[class*="uk-modal-close-"] {
+  position: absolute;
+  z-index: 1010;
+  top: 10px;
+  right: 10px;
+  padding: 5px;
+}
+/*
+ * Remove margin from adjacent element
+ */
+[class*="uk-modal-close-"]:first-child + * {
+  margin-top: 0;
+}
+/*
+ * Hover
+ */
+/*
+ * Default
+ */
+/*
+ * Outside
+ * 1. Prevent scrollbar on small devices
+ */
+.uk-modal-close-outside {
+  top: 0;
+  /* 1 */
+  right: -5px;
+  transform: translate(0, -100%);
+  color: #ffffff;
+}
+.uk-modal-close-outside:hover {
+  color: #fff;
+}
+/* Tablet landscape and bigger */
+@media (min-width: 960px) {
+  /* 1 */
+  .uk-modal-close-outside {
+    right: 0;
+    transform: translate(100%, -100%);
+  }
+}
+/*
+ * Full
+ */
+.uk-modal-close-full {
+  top: 0;
+  right: 0;
+  padding: 10px;
+  background: #fff;
+}
+/* Tablet landscape and bigger */
+@media (min-width: 960px) {
+  .uk-modal-close-full {
+    padding: 20px;
+  }
+}
+/* ========================================================================
+   Component: Slideshow
+ ========================================================================== */
+/*
+ * 1. Prevent tab highlighting on iOS.
+ */
+.uk-slideshow {
+  /* 1 */
+  -webkit-tap-highlight-color: transparent;
+}
+/* Items
+ ========================================================================== */
+/*
+ * 1. Create position and stacking context
+ * 2. Reset list
+ * 3. Clip child elements
+ * 4. Prevent displaying the callout information on iOS.
+ * 5. Disable horizontal panning gestures
+ */
+.uk-slideshow-items {
+  /* 1 */
+  position: relative;
+  z-index: 0;
+  /* 2 */
+  margin: 0;
+  padding: 0;
+  list-style: none;
+  /* 3 */
+  overflow: hidden;
+  /* 4 */
+  -webkit-touch-callout: none;
+  /* 5 */
+  touch-action: pan-y;
+}
+/* Item
+ ========================================================================== */
+/*
+ * 1. Position items above each other
+ * 2. Take the full width
+ * 3. Clip child elements, e.g. for `uk-cover`
+ * 4. Optimize animation
+ */
+.uk-slideshow-items > * {
+  /* 1 */
+  position: absolute;
+  top: 0;
+  left: 0;
+  /* 2 */
+  right: 0;
+  bottom: 0;
+  /* 3 */
+  overflow: hidden;
+  /* 4 */
+  will-change: transform, opacity;
+}
+/*
+ * Hide not active items
+ */
+.uk-slideshow-items > :not(.uk-active) {
+  display: none;
+}
+/* ========================================================================
+   Component: Slider
+ ========================================================================== */
+/*
+ * 1. Prevent tab highlighting on iOS.
+ */
+.uk-slider {
+  /* 1 */
+  -webkit-tap-highlight-color: transparent;
+}
+/* Container
+ ========================================================================== */
+/*
+ * 1. Clip child elements
+ * 2. Prevent accidental scrolling through elements in slide getting focused
+ */
+.uk-slider-container {
+  /* 1 */
+  overflow: hidden;
+  /* 2 */
+  overflow: clip;
+}
+/*
+ * Widen container to prevent box-shadows from clipping, `large-box-shadow`
+ */
+.uk-slider-container-offset {
+  margin: -11px -25px -39px -25px;
+  padding: 11px 25px 39px 25px;
+}
+/* Items
+ ========================================================================== */
+/*
+ * 1. Optimize animation
+ * 2. Create a containing block. In Safari it's neither created by `transform` nor `will-change`.
+ * 3. Disable horizontal panning gestures
+ */
+.uk-slider-items {
+  /* 1 */
+  will-change: transform;
+  /* 2 */
+  position: relative;
+  /* 3 */
+  touch-action: pan-y;
+}
+/*
+ * 1. Reset list style without interfering with grid
+ * 2. Prevent displaying the callout information on iOS.
+ */
+.uk-slider-items:not(.uk-grid) {
+  display: flex;
+  /* 1 */
+  margin: 0;
+  padding: 0;
+  list-style: none;
+  /* 2 */
+  -webkit-touch-callout: none;
+}
+.uk-slider-items.uk-grid {
+  flex-wrap: nowrap;
+}
+/* Item
+ ========================================================================== */
+/*
+ * 1. Let items take content dimensions (0 0 auto)
+ *    `max-width` needed to keep image responsiveness and prevent content overflow
+ * 2. Create position context
+ */
+.uk-slider-items > * {
+  /* 1 */
+  flex: none !important;
+  box-sizing: border-box;
+  max-width: 100%;
+  /* 2 */
+  position: relative;
+}
+/* ========================================================================
+   Component: Sticky
+ ========================================================================== */
+/*
+ * 1. Create position context so it's t the same like when fixed.
+ * 2. Create stacking context already when not sticky to have the same context
+*     for position set to `sticky` and `relative`
+ * 2. More robust if padding and border are used and the sticky height is transitioned
+ */
+.uk-sticky {
+  /* 1 */
+  position: relative;
+  /* 2 */
+  z-index: 980;
+  /* 3 */
+  box-sizing: border-box;
+}
+/*
+ * 1. Force new layer to resolve frame rate issues on devices with lower frame rates
+ */
+.uk-sticky-fixed {
+  margin: 0 !important;
+  /* 1 */
+  -webkit-backface-visibility: hidden;
+  backface-visibility: hidden;
+}
+/*
+ * Faster animations
+ */
+.uk-sticky[class*="uk-animation-"] {
+  animation-duration: 0.2s;
+}
+.uk-sticky.uk-animation-reverse {
+  animation-duration: 0.2s;
+}
+/*
+ * Placeholder
+ * Make content clickable for sticky cover and reveal effects
+ */
+.uk-sticky-placeholder {
+  pointer-events: none;
+}
+/* ========================================================================
+   Component: Off-canvas
+ ========================================================================== */
+/*
+ * 1. Hide by default
+ * 2. Set position
+ */
+.uk-offcanvas {
+  /* 1 */
+  display: none;
+  /* 2 */
+  position: fixed;
+  top: 0;
+  bottom: 0;
+  left: 0;
+  z-index: 1000;
+}
+/*
+ * Flip modifier
+ */
+.uk-offcanvas-flip .uk-offcanvas {
+  right: 0;
+  left: auto;
+}
+/* Bar
+ ========================================================================== */
+/*
+ * 1. Set position
+ * 2. Size and style
+ * 3. Allow scrolling
+ */
+.uk-offcanvas-bar {
+  --uk-inverse: light;
+  /* 1 */
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  left: -270px;
+  /* 2 */
+  box-sizing: border-box;
+  width: 270px;
+  padding: 20px 20px;
+  background: #222;
+  /* 3 */
+  overflow-y: auto;
+}
+/* Phone landscape and bigger */
+@media (min-width: 640px) {
+  .uk-offcanvas-bar {
+    left: -350px;
+    width: 350px;
+    padding: 30px 30px;
+  }
+}
+/* Flip modifier */
+.uk-offcanvas-flip .uk-offcanvas-bar {
+  left: auto;
+  right: -270px;
+}
+/* Tablet landscape and bigger */
+@media (min-width: 640px) {
+  .uk-offcanvas-flip .uk-offcanvas-bar {
+    right: -350px;
+  }
+}
+/*
+ * Open
+ */
+.uk-open > .uk-offcanvas-bar {
+  left: 0;
+}
+.uk-offcanvas-flip .uk-open > .uk-offcanvas-bar {
+  left: auto;
+  right: 0;
+}
+/*
+ * Slide Animation (Used in slide and push mode)
+ */
+.uk-offcanvas-bar-animation {
+  transition: left 0.3s ease-out;
+}
+.uk-offcanvas-flip .uk-offcanvas-bar-animation {
+  transition-property: right;
+}
+/*
+ * Reveal Animation
+ * 1. Set position
+ * 2. Clip the bar
+ * 3. Animation
+ * 4. Reset position
+ */
+.uk-offcanvas-reveal {
+  /* 1 */
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  left: 0;
+  /* 2 */
+  width: 0;
+  overflow: hidden;
+  /* 3 */
+  transition: width 0.3s ease-out;
+}
+.uk-offcanvas-reveal .uk-offcanvas-bar {
+  /* 4 */
+  left: 0;
+}
+.uk-offcanvas-flip .uk-offcanvas-reveal .uk-offcanvas-bar {
+  /* 4 */
+  left: auto;
+  right: 0;
+}
+.uk-open > .uk-offcanvas-reveal {
+  width: 270px;
+}
+/* Tablet landscape and bigger */
+@media (min-width: 640px) {
+  .uk-open > .uk-offcanvas-reveal {
+    width: 350px;
+  }
+}
+/*
+ * Flip modifier
+ */
+.uk-offcanvas-flip .uk-offcanvas-reveal {
+  right: 0;
+  left: auto;
+}
+/* Close
+ * Adopts `uk-close`
+ ========================================================================== */
+.uk-offcanvas-close {
+  position: absolute;
+  z-index: 1000;
+  top: 5px;
+  right: 5px;
+  padding: 5px;
+}
+/* Tablet landscape and bigger */
+@media (min-width: 640px) {
+  .uk-offcanvas-close {
+    top: 10px;
+    right: 10px;
+  }
+}
+/*
+ * Remove margin from adjacent element
+ */
+.uk-offcanvas-close:first-child + * {
+  margin-top: 0;
+}
+/* Overlay
+ ========================================================================== */
+/*
+ * Overlay the whole page. Needed for the `::before`
+ * 1. Using `100vw` so no modification is needed when off-canvas is flipped
+ * 2. Allow for closing with swipe gesture on devices with pointer events.
+ */
+.uk-offcanvas-overlay {
+  /* 1 */
+  width: 100vw;
+  /* 2 */
+  touch-action: none;
+}
+/*
+ * 1. Mask the whole page
+ * 2. Fade-in transition
+ */
+.uk-offcanvas-overlay::before {
+  /* 1 */
+  content: "";
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  left: 0;
+  right: 0;
+  background: rgba(0, 0, 0, 0.1);
+  /* 2 */
+  opacity: 0;
+  transition: opacity 0.15s linear;
+}
+.uk-offcanvas-overlay.uk-open::before {
+  opacity: 1;
+}
+/* Prevent scrolling
+ ========================================================================== */
+/*
+ * Prevent horizontal scrollbar when the content is slide-out
+ * Has to be on the `html` element too to make it work on the `body`
+ * 1. `clip` is needed for `position: sticky` elements to keep their position
+ */
+.uk-offcanvas-page,
+.uk-offcanvas-container {
+  overflow-x: hidden;
+  /* 1 */
+  overflow-x: clip;
+}
+/* Container
+ ========================================================================== */
+/*
+ * Prepare slide-out animation (Used in reveal and push mode)
+ * Using `position: left` instead of `transform` because position `fixed` elements like sticky navbars
+ * lose their fixed state and behaves like `absolute` within a transformed container
+ * 1. Provide a fixed width and prevent shrinking
+ */
+.uk-offcanvas-container {
+  position: relative;
+  left: 0;
+  transition: left 0.3s ease-out;
+  /* 1 */
+  box-sizing: border-box;
+  width: 100%;
+}
+/*
+ * Activate slide-out animation
+ */
+:not(.uk-offcanvas-flip).uk-offcanvas-container-animation {
+  left: 270px;
+}
+.uk-offcanvas-flip.uk-offcanvas-container-animation {
+  left: -270px;
+}
+/* Tablet landscape and bigger */
+@media (min-width: 640px) {
+  :not(.uk-offcanvas-flip).uk-offcanvas-container-animation {
+    left: 350px;
+  }
+  .uk-offcanvas-flip.uk-offcanvas-container-animation {
+    left: -350px;
+  }
+}
+/* ========================================================================
+   Component: Switcher
+ ========================================================================== */
+/*
+ * Reset list
+ */
+.uk-switcher {
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+/* Items
+ ========================================================================== */
+/*
+ * Hide not active items
+ */
+.uk-switcher > :not(.uk-active) {
+  display: none;
+}
+/*
+ * Remove margin from the last-child
+ */
+.uk-switcher > * > :last-child {
+  margin-bottom: 0;
+}
+/* ========================================================================
+   Component: Leader
+ ========================================================================== */
+.uk-leader {
+  overflow: hidden;
+}
+/*
+ * 1. Place element in text flow
+ * 2. Never break into a new line
+ * 3. Get a string back with as many repeating characters to fill the container
+ * 4. Prevent wrapping. Overflowing characters will be clipped by the container
+ */
+.uk-leader-fill::after {
+  /* 1 */
+  display: inline-block;
+  margin-left: 15px;
+  /* 2 */
+  width: 0;
+  /* 3 */
+  content: attr(data-fill);
+  /* 4 */
+  white-space: nowrap;
+}
+/*
+ * Hide if media does not match
+ */
+.uk-leader-fill.uk-leader-hide::after {
+  display: none;
+}
+/*
+ * Pass fill character to JS
+ */
+:root {
+  --uk-leader-fill-content: .;
+}
+/* ========================================================================
+   Component: Notification
+ ========================================================================== */
+/*
+ * 1. Set position
+ * 2. Dimensions
+ */
+.uk-notification {
+  /* 1 */
+  position: fixed;
+  top: 10px;
+  left: 10px;
+  z-index: 1040;
+  /* 2 */
+  box-sizing: border-box;
+  width: 350px;
+}
+/* Position modifiers
+========================================================================== */
+.uk-notification-top-right,
+.uk-notification-bottom-right {
+  left: auto;
+  right: 10px;
+}
+.uk-notification-top-center,
+.uk-notification-bottom-center {
+  left: 50%;
+  margin-left: -175px;
+}
+.uk-notification-bottom-left,
+.uk-notification-bottom-right,
+.uk-notification-bottom-center {
+  top: auto;
+  bottom: 10px;
+}
+/* Responsiveness
+========================================================================== */
+/* Phones portrait and smaller */
+@media (max-width: 639px) {
+  .uk-notification {
+    left: 10px;
+    right: 10px;
+    width: auto;
+    margin: 0;
+  }
+}
+/* Message
+========================================================================== */
+.uk-notification-message {
+  position: relative;
+  padding: 15px;
+  background: #f8f8f8;
+  color: #666;
+  font-size: 1.25rem;
+  line-height: 1.4;
+  cursor: pointer;
+}
+* + .uk-notification-message {
+  margin-top: 10px;
+}
+/* Close
+ * Adopts `uk-close`
+ ========================================================================== */
+.uk-notification-close {
+  display: none;
+  position: absolute;
+  top: 20px;
+  right: 15px;
+}
+.uk-notification-message:hover .uk-notification-close {
+  display: block;
+}
+/* Style modifiers
+ ========================================================================== */
+/*
+ * Primary
+ */
+.uk-notification-message-primary {
+  color: #1e87f0;
+}
+/*
+ * Success
+ */
+.uk-notification-message-success {
+  color: #32d296;
+}
+/*
+ * Warning
+ */
+.uk-notification-message-warning {
+  color: #faa05a;
+}
+/*
+ * Danger
+ */
+.uk-notification-message-danger {
+  color: #f0506e;
+}
+/* ========================================================================
+   Component: Tooltip
+ ========================================================================== */
+/*
+ * 1. Hide by default
+ * 2. Position
+ * 3. Remove tooltip from document flow to keep the UIkit container from changing its size when injected into the document initially
+ * 4. Dimensions
+ * 5. Style
+ */
+.uk-tooltip {
+  /* 1 */
+  display: none;
+  /* 2 */
+  position: absolute;
+  z-index: 1030;
+  --uk-position-offset: 10px;
+  --uk-position-viewport-offset: 10;
+  /* 3 */
+  top: 0;
+  /* 4 */
+  box-sizing: border-box;
+  max-width: 200px;
+  padding: 3px 6px;
+  /* 5 */
+  background: #666;
+  border-radius: 2px;
+  color: #fff;
+  font-size: 12px;
+}
+/* Show */
+.uk-tooltip.uk-active {
+  display: block;
+}
+/* ========================================================================
+   Component: Sortable
+ ========================================================================== */
+.uk-sortable {
+  position: relative;
+}
+/*
+ * Remove margin from the last-child
+ */
+.uk-sortable > :last-child {
+  margin-bottom: 0;
+}
+/* Drag
+ ========================================================================== */
+.uk-sortable-drag {
+  position: fixed !important;
+  z-index: 1050 !important;
+  pointer-events: none;
+}
+/* Placeholder
+ ========================================================================== */
+.uk-sortable-placeholder {
+  opacity: 0;
+  pointer-events: none;
+}
+/* Empty modifier
+ ========================================================================== */
+.uk-sortable-empty {
+  min-height: 50px;
+}
+/* Handle
+ ========================================================================== */
+/* Hover */
+.uk-sortable-handle:hover {
+  cursor: move;
+}
+/* ========================================================================
+   Component: Countdown
+ ========================================================================== */
+/* Item
+ ========================================================================== */
+/* Number
+ ========================================================================== */
+/*
+ * 1. Make numbers all of the same size to prevent jumping. Must be supported by the font.
+ * 2. Style
+ */
+.uk-countdown-number {
+  /* 1 */
+  font-variant-numeric: tabular-nums;
+  /* 2 */
+  font-size: 2rem;
+  line-height: 0.8;
+}
+/* Phone landscape and bigger */
+@media (min-width: 640px) {
+  .uk-countdown-number {
+    font-size: 4rem;
+  }
+}
+/* Tablet landscape and bigger */
+@media (min-width: 960px) {
+  .uk-countdown-number {
+    font-size: 6rem;
+  }
+}
+/* Separator
+ ========================================================================== */
+.uk-countdown-separator {
+  font-size: 1rem;
+  line-height: 1.6;
+}
+/* Phone landscape and bigger */
+@media (min-width: 640px) {
+  .uk-countdown-separator {
+    font-size: 2rem;
+  }
+}
+/* Tablet landscape and bigger */
+@media (min-width: 960px) {
+  .uk-countdown-separator {
+    font-size: 3rem;
+  }
+}
+/* Label
+ ========================================================================== */
+/* ========================================================================
+   Component: Thumbnav
+ ========================================================================== */
+/*
+ * 1. Allow items to wrap into the next line
+ * 2. Reset list
+ * 3. Gutter
+ */
+.uk-thumbnav {
+  display: flex;
+  /* 1 */
+  flex-wrap: wrap;
+  /* 2 */
+  margin: 0;
+  padding: 0;
+  list-style: none;
+  /* 3 */
+  margin-left: -15px;
+}
+/*
+ * Space is allocated based on content dimensions, but shrinks: 0 1 auto
+ * 1. Gutter
+ */
+.uk-thumbnav > * {
+  /* 1 */
+  padding-left: 15px;
+}
+/* Items
+ ========================================================================== */
+/*
+ * Items
+ */
+.uk-thumbnav > * > * {
+  display: inline-block;
+  position: relative;
+}
+.uk-thumbnav > * > *::after {
+  content: "";
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  left: 0;
+  right: 0;
+  background-image: linear-gradient(180deg, rgba(255, 255, 255, 0), rgba(255, 255, 255, 0.4));
+  transition: opacity 0.1s ease-in-out;
+}
+/* Hover */
+.uk-thumbnav > * > :hover::after {
+  opacity: 0;
+}
+/* Active */
+.uk-thumbnav > .uk-active > *::after {
+  opacity: 0;
+}
+/* Modifier: 'uk-thumbnav-vertical'
+ ========================================================================== */
+/*
+ * 1. Change direction
+ * 2. Gutter
+ */
+.uk-thumbnav-vertical {
+  /* 1 */
+  flex-direction: column;
+  /* 2 */
+  margin-left: 0;
+  margin-top: -15px;
+}
+/* 2 */
+.uk-thumbnav-vertical > * {
+  padding-left: 0;
+  padding-top: 15px;
+}
+/* ========================================================================
+   Component: Iconnav
+ ========================================================================== */
+/*
+ * 1. Allow items to wrap into the next line
+ * 2. Reset list
+ * 3. Gutter
+ */
+.uk-iconnav {
+  display: flex;
+  /* 1 */
+  flex-wrap: wrap;
+  /* 2 */
+  margin: 0;
+  padding: 0;
+  list-style: none;
+  /* 3 */
+  margin-left: -10px;
+}
+/*
+ * Space is allocated based on content dimensions, but shrinks: 0 1 auto
+ * 1. Gutter
+ */
+.uk-iconnav > * {
+  /* 1 */
+  padding-left: 10px;
+}
+/* Items
+ ========================================================================== */
+/*
+ * Items must target `a` elements to exclude other elements (e.g. dropdowns)
+ * 1. Center content vertically if there is still some text
+ * 2. Imitate white space gap when using flexbox
+ * 3. Force text not to affect item height
+ * 4. Style
+ * 5. Required for `a` if there is still some text
+ */
+.uk-iconnav > * > a {
+  /* 1 */
+  display: flex;
+  align-items: center;
+  /* 2 */
+  column-gap: 0.25em;
+  /* 3 */
+  line-height: 0;
+  /* 4 */
+  color: #999;
+  /* 5 */
+  text-decoration: none;
+  font-size: 0.875rem;
+  transition: 0.1s ease-in-out;
+  transition-property: color, background-color;
+}
+/* Hover */
+.uk-iconnav > * > a:hover {
+  color: #666;
+}
+/* Active */
+.uk-iconnav > .uk-active > a {
+  color: #666;
+}
+/* Modifier: 'uk-iconnav-vertical'
+ ========================================================================== */
+/*
+ * 1. Change direction
+ * 2. Gutter
+ */
+.uk-iconnav-vertical {
+  /* 1 */
+  flex-direction: column;
+  /* 2 */
+  margin-left: 0;
+  margin-top: -10px;
+}
+/* 2 */
+.uk-iconnav-vertical > * {
+  padding-left: 0;
+  padding-top: 10px;
+}
+/* ========================================================================
+   Component: Grid
+ ========================================================================== */
+/*
+ * 1. Allow cells to wrap into the next line
+ * 2. Reset list
+ */
+.uk-grid {
+  display: flex;
+  /* 1 */
+  flex-wrap: wrap;
+  /* 2 */
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+/*
+ * Grid cell
+ * Note: Space is allocated solely based on content dimensions, but shrinks: 0 1 auto
+ * Reset margin for e.g. paragraphs
+ */
+.uk-grid > * {
+  margin: 0;
+}
+/*
+ * Remove margin from the last-child
+ */
+.uk-grid > * > :last-child {
+  margin-bottom: 0;
+}
+/* Gutter
+ ========================================================================== */
+/*
+ * Default
+ */
+/* Horizontal */
+.uk-grid {
+  margin-left: -30px;
+}
+.uk-grid > * {
+  padding-left: 30px;
+}
+/* Vertical */
+.uk-grid + .uk-grid,
+.uk-grid > .uk-grid-margin,
+* + .uk-grid-margin {
+  margin-top: 30px;
+}
+/* Desktop and bigger */
+@media (min-width: 1200px) {
+  /* Horizontal */
+  .uk-grid {
+    margin-left: -40px;
+  }
+  .uk-grid > * {
+    padding-left: 40px;
+  }
+  /* Vertical */
+  .uk-grid + .uk-grid,
+  .uk-grid > .uk-grid-margin,
+  * + .uk-grid-margin {
+    margin-top: 40px;
+  }
+}
+/*
+ * Small
+ */
+/* Horizontal */
+.uk-grid-small,
+.uk-grid-column-small {
+  margin-left: -15px;
+}
+.uk-grid-small > *,
+.uk-grid-column-small > * {
+  padding-left: 15px;
+}
+/* Vertical */
+.uk-grid + .uk-grid-small,
+.uk-grid + .uk-grid-row-small,
+.uk-grid-small > .uk-grid-margin,
+.uk-grid-row-small > .uk-grid-margin,
+* + .uk-grid-margin-small {
+  margin-top: 15px;
+}
+/*
+ * Medium
+ */
+/* Horizontal */
+.uk-grid-medium,
+.uk-grid-column-medium {
+  margin-left: -30px;
+}
+.uk-grid-medium > *,
+.uk-grid-column-medium > * {
+  padding-left: 30px;
+}
+/* Vertical */
+.uk-grid + .uk-grid-medium,
+.uk-grid + .uk-grid-row-medium,
+.uk-grid-medium > .uk-grid-margin,
+.uk-grid-row-medium > .uk-grid-margin,
+* + .uk-grid-margin-medium {
+  margin-top: 30px;
+}
+/*
+ * Large
+ */
+/* Horizontal */
+.uk-grid-large,
+.uk-grid-column-large {
+  margin-left: -40px;
+}
+.uk-grid-large > *,
+.uk-grid-column-large > * {
+  padding-left: 40px;
+}
+/* Vertical */
+.uk-grid + .uk-grid-large,
+.uk-grid + .uk-grid-row-large,
+.uk-grid-large > .uk-grid-margin,
+.uk-grid-row-large > .uk-grid-margin,
+* + .uk-grid-margin-large {
+  margin-top: 40px;
+}
+/* Desktop and bigger */
+@media (min-width: 1200px) {
+  /* Horizontal */
+  .uk-grid-large,
+  .uk-grid-column-large {
+    margin-left: -70px;
+  }
+  .uk-grid-large > *,
+  .uk-grid-column-large > * {
+    padding-left: 70px;
+  }
+  /* Vertical */
+  .uk-grid + .uk-grid-large,
+  .uk-grid + .uk-grid-row-large,
+  .uk-grid-large > .uk-grid-margin,
+  .uk-grid-row-large > .uk-grid-margin,
+  * + .uk-grid-margin-large {
+    margin-top: 70px;
+  }
+}
+/*
+ * Collapse
+ */
+/* Horizontal */
+.uk-grid-collapse,
+.uk-grid-column-collapse {
+  margin-left: 0;
+}
+.uk-grid-collapse > *,
+.uk-grid-column-collapse > * {
+  padding-left: 0;
+}
+/* Vertical */
+.uk-grid + .uk-grid-collapse,
+.uk-grid + .uk-grid-row-collapse,
+.uk-grid-collapse > .uk-grid-margin,
+.uk-grid-row-collapse > .uk-grid-margin {
+  margin-top: 0;
+}
+/* Divider
+ ========================================================================== */
+.uk-grid-divider > * {
+  position: relative;
+}
+.uk-grid-divider > :not(.uk-first-column)::before {
+  content: "";
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  border-left: 1px solid #e5e5e5;
+}
+/* Vertical */
+.uk-grid-divider.uk-grid-stack > .uk-grid-margin::before {
+  content: "";
+  position: absolute;
+  left: 0;
+  right: 0;
+  border-top: 1px solid #e5e5e5;
+}
+/*
+ * Default
+ */
+/* Horizontal */
+.uk-grid-divider {
+  margin-left: -60px;
+}
+.uk-grid-divider > * {
+  padding-left: 60px;
+}
+.uk-grid-divider > :not(.uk-first-column)::before {
+  left: 30px;
+}
+/* Vertical */
+.uk-grid-divider.uk-grid-stack > .uk-grid-margin {
+  margin-top: 60px;
+}
+.uk-grid-divider.uk-grid-stack > .uk-grid-margin::before {
+  top: -30px;
+  left: 60px;
+}
+/* Desktop and bigger */
+@media (min-width: 1200px) {
+  /* Horizontal */
+  .uk-grid-divider {
+    margin-left: -80px;
+  }
+  .uk-grid-divider > * {
+    padding-left: 80px;
+  }
+  .uk-grid-divider > :not(.uk-first-column)::before {
+    left: 40px;
+  }
+  /* Vertical */
+  .uk-grid-divider.uk-grid-stack > .uk-grid-margin {
+    margin-top: 80px;
+  }
+  .uk-grid-divider.uk-grid-stack > .uk-grid-margin::before {
+    top: -40px;
+    left: 80px;
+  }
+}
+/*
+ * Small
+ */
+/* Horizontal */
+.uk-grid-divider.uk-grid-small,
+.uk-grid-divider.uk-grid-column-small {
+  margin-left: -30px;
+}
+.uk-grid-divider.uk-grid-small > *,
+.uk-grid-divider.uk-grid-column-small > * {
+  padding-left: 30px;
+}
+.uk-grid-divider.uk-grid-small > :not(.uk-first-column)::before,
+.uk-grid-divider.uk-grid-column-small > :not(.uk-first-column)::before {
+  left: 15px;
+}
+/* Vertical */
+.uk-grid-divider.uk-grid-small.uk-grid-stack > .uk-grid-margin,
+.uk-grid-divider.uk-grid-row-small.uk-grid-stack > .uk-grid-margin {
+  margin-top: 30px;
+}
+.uk-grid-divider.uk-grid-small.uk-grid-stack > .uk-grid-margin::before {
+  top: -15px;
+  left: 30px;
+}
+.uk-grid-divider.uk-grid-row-small.uk-grid-stack > .uk-grid-margin::before {
+  top: -15px;
+}
+.uk-grid-divider.uk-grid-column-small.uk-grid-stack > .uk-grid-margin::before {
+  left: 30px;
+}
+/*
+ * Medium
+ */
+/* Horizontal */
+.uk-grid-divider.uk-grid-medium,
+.uk-grid-divider.uk-grid-column-medium {
+  margin-left: -60px;
+}
+.uk-grid-divider.uk-grid-medium > *,
+.uk-grid-divider.uk-grid-column-medium > * {
+  padding-left: 60px;
+}
+.uk-grid-divider.uk-grid-medium > :not(.uk-first-column)::before,
+.uk-grid-divider.uk-grid-column-medium > :not(.uk-first-column)::before {
+  left: 30px;
+}
+/* Vertical */
+.uk-grid-divider.uk-grid-medium.uk-grid-stack > .uk-grid-margin,
+.uk-grid-divider.uk-grid-row-medium.uk-grid-stack > .uk-grid-margin {
+  margin-top: 60px;
+}
+.uk-grid-divider.uk-grid-medium.uk-grid-stack > .uk-grid-margin::before {
+  top: -30px;
+  left: 60px;
+}
+.uk-grid-divider.uk-grid-row-medium.uk-grid-stack > .uk-grid-margin::before {
+  top: -30px;
+}
+.uk-grid-divider.uk-grid-column-medium.uk-grid-stack > .uk-grid-margin::before {
+  left: 60px;
+}
+/*
+ * Large
+ */
+/* Horizontal */
+.uk-grid-divider.uk-grid-large,
+.uk-grid-divider.uk-grid-column-large {
+  margin-left: -80px;
+}
+.uk-grid-divider.uk-grid-large > *,
+.uk-grid-divider.uk-grid-column-large > * {
+  padding-left: 80px;
+}
+.uk-grid-divider.uk-grid-large > :not(.uk-first-column)::before,
+.uk-grid-divider.uk-grid-column-large > :not(.uk-first-column)::before {
+  left: 40px;
+}
+/* Vertical */
+.uk-grid-divider.uk-grid-large.uk-grid-stack > .uk-grid-margin,
+.uk-grid-divider.uk-grid-row-large.uk-grid-stack > .uk-grid-margin {
+  margin-top: 80px;
+}
+.uk-grid-divider.uk-grid-large.uk-grid-stack > .uk-grid-margin::before {
+  top: -40px;
+  left: 80px;
+}
+.uk-grid-divider.uk-grid-row-large.uk-grid-stack > .uk-grid-margin::before {
+  top: -40px;
+}
+.uk-grid-divider.uk-grid-column-large.uk-grid-stack > .uk-grid-margin::before {
+  left: 80px;
+}
+/* Desktop and bigger */
+@media (min-width: 1200px) {
+  /* Horizontal */
+  .uk-grid-divider.uk-grid-large,
+  .uk-grid-divider.uk-grid-column-large {
+    margin-left: -140px;
+  }
+  .uk-grid-divider.uk-grid-large > *,
+  .uk-grid-divider.uk-grid-column-large > * {
+    padding-left: 140px;
+  }
+  .uk-grid-divider.uk-grid-large > :not(.uk-first-column)::before,
+  .uk-grid-divider.uk-grid-column-large > :not(.uk-first-column)::before {
+    left: 70px;
+  }
+  /* Vertical */
+  .uk-grid-divider.uk-grid-large.uk-grid-stack > .uk-grid-margin,
+  .uk-grid-divider.uk-grid-row-large.uk-grid-stack > .uk-grid-margin {
+    margin-top: 140px;
+  }
+  .uk-grid-divider.uk-grid-large.uk-grid-stack > .uk-grid-margin::before {
+    top: -70px;
+    left: 140px;
+  }
+  .uk-grid-divider.uk-grid-row-large.uk-grid-stack > .uk-grid-margin::before {
+    top: -70px;
+  }
+  .uk-grid-divider.uk-grid-column-large.uk-grid-stack > .uk-grid-margin::before {
+    left: 140px;
+  }
+}
+/* Match child of a grid cell
+ ========================================================================== */
+/*
+ * Behave like a block element
+ * 1. Wrap into the next line
+ * 2. Take the full width, at least 100%. Only if no class from the Width component is set.
+ * 3. Expand width even if larger than 100%, e.g. because of negative margin (Needed for nested grids)
+ */
+.uk-grid-match > *,
+.uk-grid-item-match {
+  display: flex;
+  /* 1 */
+  flex-wrap: wrap;
+}
+.uk-grid-match > * > :not([class*="uk-width"]),
+.uk-grid-item-match > :not([class*="uk-width"]) {
+  /* 2 */
+  box-sizing: border-box;
+  width: 100%;
+  /* 3 */
+  flex: auto;
+}
+/* ========================================================================
+   Component: Nav
+ ========================================================================== */
+/*
+ * Reset
+ */
+.uk-nav,
+.uk-nav ul {
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+/*
+* 1. Center content vertically, e.g. an icon
+* 2. Imitate white space gap when using flexbox
+* 3. Reset link
+ */
+.uk-nav li > a {
+  /* 1 */
+  display: flex;
+  align-items: center;
+  /* 2 */
+  column-gap: 0.25em;
+  /* 3*/
+  text-decoration: none;
+}
+/*
+ * Items
+ * Must target `a` elements to exclude other elements (e.g. lists)
+ */
+.uk-nav > li > a {
+  padding: 5px 0;
+}
+/* Sublists
+ ========================================================================== */
+/*
+ * Level 2
+ * `ul` needed for higher specificity to override padding
+ */
+ul.uk-nav-sub {
+  padding: 5px 0 5px 15px;
+}
+/*
+ * Level 3 and deeper
+ */
+.uk-nav-sub ul {
+  padding-left: 15px;
+}
+/*
+ * Items
+ */
+.uk-nav-sub a {
+  padding: 2px 0;
+}
+/* Parent icon
+ ========================================================================== */
+.uk-nav-parent-icon {
+  margin-left: auto;
+  transition: transform 0.3s ease-out;
+}
+.uk-nav > li.uk-open > a .uk-nav-parent-icon {
+  transform: rotateX(180deg);
+}
+/* Header
+ ========================================================================== */
+.uk-nav-header {
+  padding: 5px 0;
+  text-transform: uppercase;
+  font-size: 0.875rem;
+}
+.uk-nav-header:not(:first-child) {
+  margin-top: 20px;
+}
+/* Divider
+ ========================================================================== */
+.uk-nav .uk-nav-divider {
+  margin: 5px 0;
+}
+/* Default modifier
+ ========================================================================== */
+.uk-nav-default {
+  font-size: 0.875rem;
+  line-height: 1.5;
+}
+/*
+ * Items
+ */
+.uk-nav-default > li > a {
+  color: #999;
+}
+/* Hover */
+.uk-nav-default > li > a:hover {
+  color: #666;
+}
+/* Active */
+.uk-nav-default > li.uk-active > a {
+  color: #333;
+}
+/*
+ * Subtitle
+ */
+.uk-nav-default .uk-nav-subtitle {
+  font-size: 12px;
+}
+/*
+ * Header
+ */
+.uk-nav-default .uk-nav-header {
+  color: #333;
+}
+/*
+ * Divider
+ */
+.uk-nav-default .uk-nav-divider {
+  border-top: 1px solid #e5e5e5;
+}
+/*
+ * Sublists
+ */
+.uk-nav-default .uk-nav-sub {
+  font-size: 0.875rem;
+  line-height: 1.5;
+}
+.uk-nav-default .uk-nav-sub a {
+  color: #999;
+}
+.uk-nav-default .uk-nav-sub a:hover {
+  color: #666;
+}
+.uk-nav-default .uk-nav-sub li.uk-active > a {
+  color: #333;
+}
+/* Primary modifier
+ ========================================================================== */
+.uk-nav-primary {
+  font-size: 1.5rem;
+  line-height: 1.5;
+}
+/*
+ * Items
+ */
+.uk-nav-primary > li > a {
+  color: #999;
+}
+/* Hover */
+.uk-nav-primary > li > a:hover {
+  color: #666;
+}
+/* Active */
+.uk-nav-primary > li.uk-active > a {
+  color: #333;
+}
+/*
+ * Subtitle
+ */
+.uk-nav-primary .uk-nav-subtitle {
+  font-size: 1.25rem;
+}
+/*
+ * Header
+ */
+.uk-nav-primary .uk-nav-header {
+  color: #333;
+}
+/*
+ * Divider
+ */
+.uk-nav-primary .uk-nav-divider {
+  border-top: 1px solid #e5e5e5;
+}
+/*
+ * Sublists
+ */
+.uk-nav-primary .uk-nav-sub {
+  font-size: 1.25rem;
+  line-height: 1.5;
+}
+.uk-nav-primary .uk-nav-sub a {
+  color: #999;
+}
+.uk-nav-primary .uk-nav-sub a:hover {
+  color: #666;
+}
+.uk-nav-primary .uk-nav-sub li.uk-active > a {
+  color: #333;
+}
+/* Secondary modifier
+ ========================================================================== */
+.uk-nav-secondary {
+  font-size: 16px;
+  line-height: 1.5;
+}
+.uk-nav-secondary > :not(.uk-nav-divider) + :not(.uk-nav-header, .uk-nav-divider) {
+  margin-top: 0;
+}
+/*
+ * Items
+ */
+.uk-nav-secondary > li > a {
+  color: #333;
+  padding: 10px 10px;
+}
+/* Hover */
+.uk-nav-secondary > li > a:hover {
+  color: #333;
+  background-color: #f8f8f8;
+}
+/* Active */
+.uk-nav-secondary > li.uk-active > a {
+  color: #333;
+  background-color: #f8f8f8;
+}
+/*
+ * Subtitle
+ */
+.uk-nav-secondary .uk-nav-subtitle {
+  font-size: 0.875rem;
+  color: #999;
+}
+/* Hover */
+.uk-nav-secondary > li > a:hover .uk-nav-subtitle {
+  color: #666;
+}
+/* Active */
+.uk-nav-secondary > li.uk-active > a .uk-nav-subtitle {
+  color: #333;
+}
+/*
+ * Header
+ */
+.uk-nav-secondary .uk-nav-header {
+  color: #333;
+}
+/*
+ * Divider
+ */
+.uk-nav-secondary .uk-nav-divider {
+  border-top: 1px solid #e5e5e5;
+}
+/*
+ * Sublists
+ */
+.uk-nav-secondary .uk-nav-sub {
+  font-size: 0.875rem;
+  line-height: 1.5;
+}
+.uk-nav-secondary .uk-nav-sub a {
+  color: #999;
+}
+.uk-nav-secondary .uk-nav-sub a:hover {
+  color: #666;
+}
+.uk-nav-secondary .uk-nav-sub li.uk-active > a {
+  color: #333;
+}
+/* Size modifier
+ ========================================================================== */
+/*
+ * Medium
+ */
+.uk-nav-medium {
+  font-size: 2.8875rem;
+  line-height: 1;
+}
+.uk-nav-large {
+  font-size: 3.4rem;
+  line-height: 1;
+}
+.uk-nav-xlarge {
+  font-size: 4rem;
+  line-height: 1;
+}
+/* Tablet Landscape and bigger */
+@media (min-width: 960px) {
+  .uk-nav-medium {
+    font-size: 3.5rem;
+  }
+  .uk-nav-large {
+    font-size: 4rem;
+  }
+  .uk-nav-xlarge {
+    font-size: 6rem;
+  }
+}
+/* Laptop and bigger */
+@media (min-width: 1200px) {
+  .uk-nav-medium {
+    font-size: 4rem;
+  }
+  .uk-nav-large {
+    font-size: 6rem;
+  }
+  .uk-nav-xlarge {
+    font-size: 8rem;
+  }
+}
+/* Alignment modifier
+ ========================================================================== */
+/*
+ * 1. Center header
+ * 2. Center items
+ */
+/* 1 */
+.uk-nav-center {
+  text-align: center;
+}
+/* 2 */
+.uk-nav-center li > a {
+  justify-content: center;
+}
+/* Sublists */
+.uk-nav-center .uk-nav-sub,
+.uk-nav-center .uk-nav-sub ul {
+  padding-left: 0;
+}
+/* Parent icon  */
+.uk-nav-center .uk-nav-parent-icon {
+  margin-left: 0.25em;
+}
+/* Style modifier
+ ========================================================================== */
+/*
+ * Divider
+ * Naming is in plural to prevent conflicts with divider sub object.
+ */
+.uk-nav.uk-nav-divider > :not(.uk-nav-header, .uk-nav-divider) + :not(.uk-nav-header, .uk-nav-divider) {
+  margin-top: 5px;
+  padding-top: 5px;
+  border-top: 1px solid #e5e5e5;
+}
+/* ========================================================================
+   Component: Navbar
+ ========================================================================== */
+/*
+ * 1. Create position context to center navbar group
+ */
+.uk-navbar {
+  display: flex;
+  /* 1 */
+  position: relative;
+}
+/* Container
+ ========================================================================== */
+.uk-navbar-container:not(.uk-navbar-transparent) {
+  background: #f8f8f8;
+}
+/* Groups
+ ========================================================================== */
+/*
+ * 1. Align navs and items vertically if they have a different height
+ */
+.uk-navbar-left,
+.uk-navbar-right,
+[class*="uk-navbar-center"] {
+  display: flex;
+  gap: 15px;
+  /* 1 */
+  align-items: center;
+}
+/*
+ * Horizontal alignment
+ * 1. Create position context for centered navbar with sub groups (left/right)
+ * 2. Fix text wrapping if content is larger than 50% of the container.
+ * 3. Needed for dropdowns because a new position context is created
+ *    `z-index` must be smaller than off-canvas
+ * 4. Align sub groups for centered navbar
+ */
+.uk-navbar-right {
+  margin-left: auto;
+}
+.uk-navbar-center:only-child {
+  margin-left: auto;
+  margin-right: auto;
+  /* 1 */
+  position: relative;
+}
+.uk-navbar-center:not(:only-child) {
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%);
+  /* 2 */
+  width: max-content;
+  box-sizing: border-box;
+  /* 3 */
+  z-index: 990;
+}
+/* 4 */
+.uk-navbar-center-left,
+.uk-navbar-center-right {
+  position: absolute;
+  top: 0;
+}
+.uk-navbar-center-left {
+  right: calc(100% + 15px);
+}
+.uk-navbar-center-right {
+  left: calc(100% + 15px);
+}
+[class*="uk-navbar-center-"] {
+  width: max-content;
+  box-sizing: border-box;
+}
+/* Nav
+ ========================================================================== */
+/*
+ * 1. Reset list
+ */
+.uk-navbar-nav {
+  display: flex;
+  gap: 15px;
+  /* 1 */
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+/*
+ * Allow items to wrap into the next line
+ * Only not `absolute` positioned groups
+ */
+.uk-navbar-left,
+.uk-navbar-right,
+.uk-navbar-center:only-child {
+  flex-wrap: wrap;
+}
+/*
+ * Items
+ * 1. Center content vertically and horizontally
+ * 2. Imitate white space gap when using flexbox
+ * 3. Dimensions
+ * 4. Style
+ * 5. Required for `a`
+ */
+.uk-navbar-nav > li > a,
+.uk-navbar-item,
+.uk-navbar-toggle {
+  /* 1 */
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  /* 2 */
+  column-gap: 0.25em;
+  /* 3 */
+  box-sizing: border-box;
+  min-height: 80px;
+  /* 4 */
+  font-size: 0.875rem;
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+  /* 5 */
+  text-decoration: none;
+}
+/*
+ * Nav items
+ */
+.uk-navbar-nav > li > a {
+  padding: 0 0;
+  color: #999;
+  text-transform: uppercase;
+  transition: 0.1s ease-in-out;
+  transition-property: color, background-color;
+}
+/*
+ * Hover
+ * Apply hover style also if dropdown is opened
+ */
+.uk-navbar-nav > li:hover > a,
+.uk-navbar-nav > li > a[aria-expanded="true"] {
+  color: #666;
+}
+/* OnClick */
+.uk-navbar-nav > li > a:active {
+  color: #333;
+}
+/* Active */
+.uk-navbar-nav > li.uk-active > a {
+  color: #333;
+}
+/* Parent icon modifier
+ ========================================================================== */
+.uk-navbar-parent-icon {
+  margin-left: 4px;
+  transition: transform 0.3s ease-out;
+}
+.uk-navbar-nav > li > a[aria-expanded="true"] .uk-navbar-parent-icon {
+  transform: rotateX(180deg);
+}
+/* Item
+ ========================================================================== */
+.uk-navbar-item {
+  padding: 0 0;
+  color: #666;
+}
+/*
+ * Remove margin from the last-child
+ */
+.uk-navbar-item > :last-child {
+  margin-bottom: 0;
+}
+/* Toggle
+ ========================================================================== */
+.uk-navbar-toggle {
+  padding: 0 0;
+  color: #999;
+}
+.uk-navbar-toggle:hover,
+.uk-navbar-toggle[aria-expanded="true"] {
+  color: #666;
+  text-decoration: none;
+}
+/*
+ * Icon
+ * Adopts `uk-icon`
+ */
+/* Hover */
+/* Subtitle
+ ========================================================================== */
+.uk-navbar-subtitle {
+  font-size: 0.875rem;
+}
+/* Justify modifier
+ ========================================================================== */
+.uk-navbar-justify .uk-navbar-left,
+.uk-navbar-justify .uk-navbar-right,
+.uk-navbar-justify .uk-navbar-nav,
+.uk-navbar-justify .uk-navbar-nav > li,
+.uk-navbar-justify .uk-navbar-item,
+.uk-navbar-justify .uk-navbar-toggle {
+  flex-grow: 1;
+}
+/* Style modifiers
+ ========================================================================== */
+/* Dropdown
+ ========================================================================== */
+/*
+ * Adopts `uk-drop`
+ * 1. Set a default width
+ * 2. Style
+ */
+.uk-navbar-dropdown {
+  --uk-position-offset: 15px;
+  --uk-position-shift-offset: 0;
+  --uk-position-viewport-offset: 15px;
+  --uk-inverse: dark;
+  /* 1 */
+  width: 200px;
+  /* 2 */
+  padding: 25px;
+  background: #fff;
+  color: #666;
+  box-shadow: 0 5px 12px rgba(0, 0, 0, 0.15);
+}
+/*
+ * Remove margin from the last-child
+ */
+.uk-navbar-dropdown > :last-child {
+  margin-bottom: 0;
+}
+.uk-navbar-dropdown :focus-visible {
+  outline-color: #333 !important;
+}
+/*
+ * Grid
+ * Adopts `uk-grid`
+ */
+/* Gutter Horizontal */
+.uk-navbar-dropdown .uk-drop-grid {
+  margin-left: -30px;
+}
+.uk-navbar-dropdown .uk-drop-grid > * {
+  padding-left: 30px;
+}
+/* Gutter Vertical */
+.uk-navbar-dropdown .uk-drop-grid > .uk-grid-margin {
+  margin-top: 30px;
+}
+/*
+ * Width modifier
+ */
+.uk-navbar-dropdown-width-2:not(.uk-drop-stack) {
+  width: 400px;
+}
+.uk-navbar-dropdown-width-3:not(.uk-drop-stack) {
+  width: 600px;
+}
+.uk-navbar-dropdown-width-4:not(.uk-drop-stack) {
+  width: 800px;
+}
+.uk-navbar-dropdown-width-5:not(.uk-drop-stack) {
+  width: 1000px;
+}
+/*
+ * Size modifier
+ */
+.uk-navbar-dropdown-large {
+  --uk-position-shift-offset: 0;
+  padding: 40px;
+}
+/*
+ * Dropbar modifier
+ * 1. Reset dropdown width to prevent to early shifting
+ * 2. Reset style
+ * 3. Padding
+ */
+.uk-navbar-dropdown-dropbar {
+  /* 1 */
+  width: auto;
+  /* 2 */
+  background: transparent;
+  /* 3 */
+  padding: 25px 0 25px 0;
+  --uk-position-offset: 0;
+  --uk-position-shift-offset: 0;
+  --uk-position-viewport-offset: 15px;
+  box-shadow: none;
+}
+/* Phone landscape and bigger */
+@media (min-width: 640px) {
+  .uk-navbar-dropdown-dropbar {
+    --uk-position-viewport-offset: 30px;
+  }
+}
+/* Tablet landscape and bigger */
+@media (min-width: 960px) {
+  .uk-navbar-dropdown-dropbar {
+    --uk-position-viewport-offset: 40px;
+  }
+}
+.uk-navbar-dropdown-dropbar-large {
+  --uk-position-shift-offset: 0;
+  padding-top: 40px;
+  padding-bottom: 40px;
+}
+/* Dropdown Nav
+ * Adopts `uk-nav`
+ ========================================================================== */
+.uk-navbar-dropdown-nav {
+  font-size: 0.875rem;
+}
+/*
+ * Items
+ */
+.uk-navbar-dropdown-nav > li > a {
+  color: #999;
+}
+/* Hover */
+.uk-navbar-dropdown-nav > li > a:hover {
+  color: #666;
+}
+/* Active */
+.uk-navbar-dropdown-nav > li.uk-active > a {
+  color: #333;
+}
+/*
+ * Subtitle
+ */
+.uk-navbar-dropdown-nav .uk-nav-subtitle {
+  font-size: 12px;
+}
+/*
+ * Header
+ */
+.uk-navbar-dropdown-nav .uk-nav-header {
+  color: #333;
+}
+/*
+ * Divider
+ */
+.uk-navbar-dropdown-nav .uk-nav-divider {
+  border-top: 1px solid #e5e5e5;
+}
+/*
+ * Sublists
+ */
+.uk-navbar-dropdown-nav .uk-nav-sub a {
+  color: #999;
+}
+.uk-navbar-dropdown-nav .uk-nav-sub a:hover {
+  color: #666;
+}
+.uk-navbar-dropdown-nav .uk-nav-sub li.uk-active > a {
+  color: #333;
+}
+/* Dropbar
+ ========================================================================== */
+/*
+ * Adopts `uk-dropnav-dropbar`
+ */
+.uk-navbar-container {
+  transition: 0.1s ease-in-out;
+  transition-property: background-color;
+}
+/* Tablet landscape and bigger */
+@media (min-width: 960px) {
+  .uk-navbar-left,
+  .uk-navbar-right,
+  [class*="uk-navbar-center"] {
+    gap: 30px;
+  }
+  .uk-navbar-center-left {
+    right: calc(100% + 30px);
+  }
+  .uk-navbar-center-right {
+    left: calc(100% + 30px);
+  }
+}
+/* Tablet landscape and bigger */
+@media (min-width: 960px) {
+  .uk-navbar-nav {
+    gap: 30px;
+  }
+}
+/* ========================================================================
+   Component: Subnav
+ ========================================================================== */
+/*
+ * 1. Allow items to wrap into the next line
+ * 2. Center items vertically if they have a different height
+ * 3. Gutter
+ * 4. Reset list
+ */
+.uk-subnav {
+  display: flex;
+  /* 1 */
+  flex-wrap: wrap;
+  /* 2 */
+  align-items: center;
+  /* 3 */
+  margin-left: -20px;
+  /* 4 */
+  padding: 0;
+  list-style: none;
+}
+/*
+ * 1. Space is allocated solely based on content dimensions: 0 0 auto
+ * 2. Gutter
+ * 3. Create position context for dropdowns
+ */
+.uk-subnav > * {
+  /* 1 */
+  flex: none;
+  /* 2 */
+  padding-left: 20px;
+  /* 3 */
+  position: relative;
+}
+/* Items
+ ========================================================================== */
+/*
+ * Items must target `a` elements to exclude other elements (e.g. dropdowns)
+ * Using `:first-child` instead of `a` to support `span` elements for text
+ * 1. Center content vertically, e.g. an icon
+ * 2. Imitate white space gap when using flexbox
+ * 3. Style
+ */
+.uk-subnav > * > :first-child {
+  /* 1 */
+  display: flex;
+  align-items: center;
+  /* 2 */
+  column-gap: 0.25em;
+  /* 3 */
+  color: #999;
+  font-size: 0.875rem;
+  text-transform: uppercase;
+  transition: 0.1s ease-in-out;
+  transition-property: color, background-color;
+}
+/* Hover */
+.uk-subnav > * > a:hover {
+  color: #666;
+  text-decoration: none;
+}
+/* Active */
+.uk-subnav > .uk-active > a {
+  color: #333;
+}
+/* Divider modifier
+ ========================================================================== */
+/*
+ * Set gutter
+ */
+.uk-subnav-divider {
+  margin-left: -41px;
+}
+/*
+ * Align items and divider vertically
+ */
+.uk-subnav-divider > * {
+  display: flex;
+  align-items: center;
+}
+/*
+ * Divider
+ * 1. `nth-child` makes it also work without JS if it's only one row
+ */
+.uk-subnav-divider > ::before {
+  content: "";
+  height: 1.5em;
+  margin-left: 0px;
+  margin-right: 20px;
+  border-left: 1px solid transparent;
+}
+/* 1 */
+.uk-subnav-divider > :nth-child(n+2):not(.uk-first-column)::before {
+  border-left-color: #e5e5e5;
+}
+/* Pill modifier
+ ========================================================================== */
+.uk-subnav-pill > * > :first-child {
+  padding: 5px 10px;
+  background: transparent;
+  color: #999;
+}
+/* Hover */
+.uk-subnav-pill > * > a:hover {
+  background-color: #f8f8f8;
+  color: #666;
+}
+/* OnClick */
+.uk-subnav-pill > * > a:active {
+  background-color: #f8f8f8;
+  color: #666;
+}
+/* Active */
+.uk-subnav-pill > .uk-active > a {
+  background-color: #1e87f0;
+  color: #fff;
+}
+/* Disabled
+ * The same for all style modifiers
+ ========================================================================== */
+.uk-subnav > .uk-disabled > a {
+  color: #999;
+}
+/* ========================================================================
+   Component: Breadcrumb
+ ========================================================================== */
+/*
+ * Reset list
+ */
+.uk-breadcrumb {
+  padding: 0;
+  list-style: none;
+}
+/*
+ * 1. Doesn't generate any box and replaced by child boxes
+ */
+.uk-breadcrumb > * {
+  display: contents;
+}
+/* Items
+ ========================================================================== */
+.uk-breadcrumb > * > * {
+  font-size: 0.875rem;
+  color: #999;
+}
+/* Hover */
+.uk-breadcrumb > * > :hover {
+  color: #666;
+  text-decoration: none;
+}
+/* Disabled */
+/* Active */
+.uk-breadcrumb > :last-child > span,
+.uk-breadcrumb > :last-child > a:not([href]) {
+  color: #666;
+}
+/*
+ * Divider
+ * `nth-child` makes it also work without JS if it's only one row
+ * 1. Remove space between inline block elements.
+ * 2. Style
+ */
+.uk-breadcrumb > :nth-child(n+2):not(.uk-first-column)::before {
+  content: "/";
+  display: inline-block;
+  /* 1 */
+  margin: 0 20px 0 calc(20px - 4px);
+  /* 2 */
+  font-size: 0.875rem;
+  color: #999;
+}
+/* ========================================================================
+   Component: Pagination
+ ========================================================================== */
+/*
+ * 1. Allow items to wrap into the next line
+ * 2. Center items vertically if they have a different height
+ * 3. Gutter
+ * 4. Reset list
+ */
+.uk-pagination {
+  display: flex;
+  /* 1 */
+  flex-wrap: wrap;
+  /* 2 */
+  align-items: center;
+  /* 3 */
+  margin-left: 0;
+  /* 4 */
+  padding: 0;
+  list-style: none;
+}
+/*
+ * 1. Space is allocated solely based on content dimensions: 0 0 auto
+ * 2. Gutter
+ * 3. Create position context for dropdowns
+ */
+.uk-pagination > * {
+  /* 1 */
+  flex: none;
+  /* 2 */
+  padding-left: 0;
+  /* 3 */
+  position: relative;
+}
+/* Items
+ ========================================================================== */
+/*
+ * 1. Center content vertically, e.g. an icon
+ * 2. Imitate white space gap when using flexbox
+ * 3. Style
+ */
+.uk-pagination > * > * {
+  /* 1 */
+  display: flex;
+  align-items: center;
+  /* 2 */
+  column-gap: 0.25em;
+  /* 3 */
+  padding: 5px 10px;
+  color: #999;
+  transition: color 0.1s ease-in-out;
+}
+/* Hover */
+.uk-pagination > * > :hover {
+  color: #666;
+  text-decoration: none;
+}
+/* Active */
+.uk-pagination > .uk-active > * {
+  color: #666;
+}
+/* Disabled */
+.uk-pagination > .uk-disabled > * {
+  color: #999;
+}
+/* ========================================================================
+   Component: Tab
+ ========================================================================== */
+/*
+ * 1. Allow items to wrap into the next line
+ * 2. Gutter
+ * 3. Reset list
+ */
+.uk-tab {
+  display: flex;
+  /* 1 */
+  flex-wrap: wrap;
+  /* 2 */
+  margin-left: -20px;
+  /* 3 */
+  padding: 0;
+  list-style: none;
+  position: relative;
+}
+.uk-tab::before {
+  content: "";
+  position: absolute;
+  bottom: 0;
+  left: 20px;
+  right: 0;
+  border-bottom: 1px solid #e5e5e5;
+}
+/*
+ * 1. Space is allocated solely based on content dimensions: 0 0 auto
+ * 2. Gutter
+ * 3. Create position context for dropdowns
+ */
+.uk-tab > * {
+  /* 1 */
+  flex: none;
+  /* 2 */
+  padding-left: 20px;
+  /* 3 */
+  position: relative;
+}
+/* Items
+ ========================================================================== */
+/*
+ * Items must target `a` elements to exclude other elements (e.g. dropdowns)
+ * 1. Center content vertically, e.g. an icon
+ * 2. Imitate white space gap when using flexbox
+ * 3. Center content if a width is set
+ * 4. Style
+ */
+.uk-tab > * > a {
+  /* 1 */
+  display: flex;
+  align-items: center;
+  /* 2 */
+  column-gap: 0.25em;
+  /* 3 */
+  justify-content: center;
+  /* 4 */
+  padding: 5px 10px;
+  color: #999;
+  border-bottom: 1px solid transparent;
+  font-size: 0.875rem;
+  text-transform: uppercase;
+  transition: color 0.1s ease-in-out;
+}
+/* Hover */
+.uk-tab > * > a:hover {
+  color: #666;
+  text-decoration: none;
+}
+/* Active */
+.uk-tab > .uk-active > a {
+  color: #333;
+  border-color: #1e87f0;
+}
+/* Disabled */
+.uk-tab > .uk-disabled > a {
+  color: #999;
+}
+/* Position modifier
+ ========================================================================== */
+/*
+ * Bottom
+ */
+.uk-tab-bottom::before {
+  top: 0;
+  bottom: auto;
+}
+.uk-tab-bottom > * > a {
+  border-top: 1px solid transparent;
+  border-bottom: none;
+}
+/*
+ * Left + Right
+ * 1. Reset Gutter
+ */
+.uk-tab-left,
+.uk-tab-right {
+  flex-direction: column;
+  /* 1 */
+  margin-left: 0;
+}
+/* 1 */
+.uk-tab-left > *,
+.uk-tab-right > * {
+  padding-left: 0;
+}
+.uk-tab-left::before {
+  top: 0;
+  bottom: 0;
+  left: auto;
+  right: 0;
+  border-left: 1px solid #e5e5e5;
+  border-bottom: none;
+}
+.uk-tab-right::before {
+  top: 0;
+  bottom: 0;
+  left: 0;
+  right: auto;
+  border-left: 1px solid #e5e5e5;
+  border-bottom: none;
+}
+.uk-tab-left > * > a {
+  justify-content: left;
+  border-right: 1px solid transparent;
+  border-bottom: none;
+}
+.uk-tab-right > * > a {
+  justify-content: left;
+  border-left: 1px solid transparent;
+  border-bottom: none;
+}
+.uk-tab .uk-dropdown {
+  margin-left: 30px;
+}
+/* ========================================================================
+   Component: Slidenav
+ ========================================================================== */
+/*
+ * Adopts `uk-icon`
+ */
+.uk-slidenav {
+  padding: 5px 10px;
+  color: rgba(102, 102, 102, 0.5);
+  transition: color 0.1s ease-in-out;
+}
+/* Hover */
+.uk-slidenav:hover {
+  color: rgba(102, 102, 102, 0.9);
+}
+/* OnClick */
+.uk-slidenav:active {
+  color: rgba(102, 102, 102, 0.5);
+}
+/* Icon modifier
+ ========================================================================== */
+/*
+ * Previous
+ */
+/*
+ * Next
+ */
+/* Size modifier
+ ========================================================================== */
+.uk-slidenav-large {
+  padding: 10px 10px;
+}
+/* Container
+ ========================================================================== */
+.uk-slidenav-container {
+  display: flex;
+}
+/* ========================================================================
+   Component: Dotnav
+ ========================================================================== */
+/*
+ * 1. Allow items to wrap into the next line
+ * 2. Reset list
+ * 3. Gutter
+ */
+.uk-dotnav {
+  display: flex;
+  /* 1 */
+  flex-wrap: wrap;
+  /* 2 */
+  margin: 0;
+  padding: 0;
+  list-style: none;
+  /* 3 */
+  margin-left: -12px;
+}
+/*
+ * 1. Space is allocated solely based on content dimensions: 0 0 auto
+ * 2. Gutter
+ */
+.uk-dotnav > * {
+  /* 1 */
+  flex: none;
+  /* 2 */
+  padding-left: 12px;
+}
+/* Items
+ ========================================================================== */
+/*
+ * Items
+ * 1. Hide text if present
+ */
+.uk-dotnav > * > * {
+  display: block;
+  box-sizing: border-box;
+  width: 10px;
+  height: 10px;
+  border-radius: 50%;
+  background: transparent;
+  /* 1 */
+  text-indent: 100%;
+  overflow: hidden;
+  white-space: nowrap;
+  border: 1px solid rgba(102, 102, 102, 0.4);
+  transition: 0.2s ease-in-out;
+  transition-property: background-color, border-color;
+}
+/* Hover */
+.uk-dotnav > * > :hover {
+  background-color: rgba(102, 102, 102, 0.6);
+  border-color: transparent;
+}
+/* OnClick */
+.uk-dotnav > * > :active {
+  background-color: rgba(102, 102, 102, 0.2);
+  border-color: transparent;
+}
+/* Active */
+.uk-dotnav > .uk-active > * {
+  background-color: rgba(102, 102, 102, 0.6);
+  border-color: transparent;
+}
+/* Modifier: 'uk-dotnav-vertical'
+ ========================================================================== */
+/*
+ * 1. Change direction
+ * 2. Gutter
+ */
+.uk-dotnav-vertical {
+  /* 1 */
+  flex-direction: column;
+  /* 2 */
+  margin-left: 0;
+  margin-top: -12px;
+}
+/* 2 */
+.uk-dotnav-vertical > * {
+  padding-left: 0;
+  padding-top: 12px;
+}
+/* ========================================================================
+   Component: Dropdown
+ ========================================================================== */
+/*
+ * Adopts `uk-drop`
+ * 1. Reset drop and let text expand the width instead of wrapping
+ * 2. Set a default width
+ * 3. Style
+ */
+.uk-dropdown {
+  --uk-position-offset: 10px;
+  --uk-position-viewport-offset: 15px;
+  --uk-inverse: dark;
+  /* 1 */
+  width: auto;
+  /* 2 */
+  min-width: 200px;
+  /* 3 */
+  padding: 25px;
+  background: #fff;
+  color: #666;
+  box-shadow: 0 5px 12px rgba(0, 0, 0, 0.15);
+}
+/*
+ * Remove margin from the last-child
+ */
+.uk-dropdown > :last-child {
+  margin-bottom: 0;
+}
+.uk-dropdown :focus-visible {
+  outline-color: #333 !important;
+}
+/* Size modifier
+ ========================================================================== */
+.uk-dropdown-large {
+  padding: 40px;
+}
+/* Dropbar modifier
+ ========================================================================== */
+/*
+ * 1. Reset dropdown width to prevent to early shifting
+ * 2. Reset style
+ * 3. Padding
+ */
+.uk-dropdown-dropbar {
+  /* 1 */
+  width: auto;
+  /* 2 */
+  background: transparent;
+  /* 3 */
+  padding: 5px 0 25px 0;
+  --uk-position-viewport-offset: 15px;
+  box-shadow: none;
+}
+/* Phone landscape and bigger */
+@media (min-width: 640px) {
+  .uk-dropdown-dropbar {
+    --uk-position-viewport-offset: 30px;
+  }
+}
+/* Tablet landscape and bigger */
+@media (min-width: 960px) {
+  .uk-dropdown-dropbar {
+    --uk-position-viewport-offset: 40px;
+  }
+}
+.uk-dropdown-dropbar-large {
+  padding-top: 40px;
+  padding-bottom: 40px;
+}
+/* Nav
+ * Adopts `uk-nav`
+ ========================================================================== */
+.uk-dropdown-nav {
+  font-size: 0.875rem;
+}
+/*
+ * Items
+ */
+.uk-dropdown-nav > li > a {
+  color: #999;
+}
+/* Hover + Active */
+.uk-dropdown-nav > li > a:hover,
+.uk-dropdown-nav > li.uk-active > a {
+  color: #666;
+}
+/*
+ * Subtitle
+ */
+.uk-dropdown-nav .uk-nav-subtitle {
+  font-size: 12px;
+}
+/*
+ * Header
+ */
+.uk-dropdown-nav .uk-nav-header {
+  color: #333;
+}
+/*
+ * Divider
+ */
+.uk-dropdown-nav .uk-nav-divider {
+  border-top: 1px solid #e5e5e5;
+}
+/*
+ * Sublists
+ */
+.uk-dropdown-nav .uk-nav-sub a {
+  color: #999;
+}
+.uk-dropdown-nav .uk-nav-sub a:hover,
+.uk-dropdown-nav .uk-nav-sub li.uk-active > a {
+  color: #666;
+}
+/* ========================================================================
+   Component: Lightbox
+ ========================================================================== */
+/*
+ * 1. Hide by default
+ * 2. Set position
+ * 3. Allow scrolling for the modal dialog
+ * 4. Horizontal padding
+ * 5. Mask the background page
+ * 6. Fade-in transition
+ * 7. Prevent cancellation of pointer events while dragging
+ */
+.uk-lightbox {
+  /* 1 */
+  display: none;
+  /* 2 */
+  position: fixed;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  z-index: 1010;
+  /* 5 */
+  background: #000;
+  /* 6 */
+  opacity: 0;
+  transition: opacity 0.15s linear;
+  /* 7 */
+  touch-action: pinch-zoom;
+}
+/*
+ * Open
+ * 1. Center child
+ * 2. Fade-in
+ */
+.uk-lightbox.uk-open {
+  display: block;
+  /* 2 */
+  opacity: 1;
+}
+/*
+ * Focus
+ */
+.uk-lightbox :focus-visible {
+  outline-color: rgba(255, 255, 255, 0.7);
+}
+/* Page
+ ========================================================================== */
+/*
+ * Prevent scrollbars
+ */
+.uk-lightbox-page {
+  overflow: hidden;
+}
+/* Item
+ ========================================================================== */
+/*
+ * 1. Center child within the viewport
+ * 2. Not visible by default
+ * 3. Color needed for spinner icon
+ * 4. Optimize animation
+ * 5. Responsiveness
+ *    Using `vh` for `max-height` to fix image proportions after resize in Safari and Opera
+ */
+.uk-lightbox-items > * {
+  /* 1 */
+  position: absolute;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  /* 2 */
+  display: none;
+  justify-content: center;
+  align-items: center;
+  /* 3 */
+  color: rgba(255, 255, 255, 0.7);
+  /* 4 */
+  will-change: transform, opacity;
+}
+/* 5 */
+.uk-lightbox-items > * > * {
+  max-width: 100vw;
+  max-height: 100vh;
+}
+.uk-lightbox-items > * > :not(iframe) {
+  width: auto;
+  height: auto;
+}
+.uk-lightbox-items > .uk-active {
+  display: flex;
+}
+/* Toolbar
+ ========================================================================== */
+.uk-lightbox-toolbar {
+  padding: 10px 10px;
+  background: rgba(0, 0, 0, 0.3);
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-lightbox-toolbar > * {
+  color: rgba(255, 255, 255, 0.7);
+}
+/* Toolbar Icon (Close)
+ ========================================================================== */
+.uk-lightbox-toolbar-icon {
+  padding: 5px;
+  color: rgba(255, 255, 255, 0.7);
+}
+/*
+ * Hover
+ */
+.uk-lightbox-toolbar-icon:hover {
+  color: #fff;
+}
+/* Button (Slidenav)
+ ========================================================================== */
+/*
+ * 1. Center icon vertically and horizontally
+ */
+.uk-lightbox-button {
+  box-sizing: border-box;
+  width: 50px;
+  height: 50px;
+  background: rgba(0, 0, 0, 0.3);
+  color: rgba(255, 255, 255, 0.7);
+  /* 1 */
+  display: inline-flex;
+  justify-content: center;
+  align-items: center;
+}
+/* Hover */
+.uk-lightbox-button:hover {
+  color: #fff;
+}
+/* OnClick */
+/* Caption
+ ========================================================================== */
+.uk-lightbox-caption:empty {
+  display: none;
+}
+/* Iframe
+ ========================================================================== */
+.uk-lightbox-iframe {
+  width: 80%;
+  height: 80%;
+}
+/* ========================================================================
+   Component: Animation
+ ========================================================================== */
+[class*="uk-animation-"] {
+  animation: 0.5s ease-out both;
+}
+/* Animations
+ ========================================================================== */
+/*
+ * Fade
+ */
+.uk-animation-fade {
+  animation-name: uk-fade;
+  animation-duration: 0.8s;
+  animation-timing-function: linear;
+}
+/*
+ * Scale
+ */
+.uk-animation-scale-up {
+  animation-name: uk-fade, uk-scale-up;
+}
+.uk-animation-scale-down {
+  animation-name: uk-fade, uk-scale-down;
+}
+/*
+ * Slide
+ */
+.uk-animation-slide-top {
+  animation-name: uk-fade, uk-slide-top;
+}
+.uk-animation-slide-bottom {
+  animation-name: uk-fade, uk-slide-bottom;
+}
+.uk-animation-slide-left {
+  animation-name: uk-fade, uk-slide-left;
+}
+.uk-animation-slide-right {
+  animation-name: uk-fade, uk-slide-right;
+}
+/*
+ * Slide Small
+ */
+.uk-animation-slide-top-small {
+  animation-name: uk-fade, uk-slide-top-small;
+}
+.uk-animation-slide-bottom-small {
+  animation-name: uk-fade, uk-slide-bottom-small;
+}
+.uk-animation-slide-left-small {
+  animation-name: uk-fade, uk-slide-left-small;
+}
+.uk-animation-slide-right-small {
+  animation-name: uk-fade, uk-slide-right-small;
+}
+/*
+ * Slide Medium
+ */
+.uk-animation-slide-top-medium {
+  animation-name: uk-fade, uk-slide-top-medium;
+}
+.uk-animation-slide-bottom-medium {
+  animation-name: uk-fade, uk-slide-bottom-medium;
+}
+.uk-animation-slide-left-medium {
+  animation-name: uk-fade, uk-slide-left-medium;
+}
+.uk-animation-slide-right-medium {
+  animation-name: uk-fade, uk-slide-right-medium;
+}
+/*
+ * Kenburns
+ */
+.uk-animation-kenburns {
+  animation-name: uk-kenburns;
+  animation-duration: 15s;
+}
+/*
+ * Shake
+ */
+.uk-animation-shake {
+  animation-name: uk-shake;
+}
+/*
+ * SVG Stroke
+ * The `--uk-animation-stroke` custom property contains the longest path length.
+ * Set it manually or use `uk-svg="stroke-animation: true"` to set it automatically.
+ * All strokes are animated by the same pace and doesn't end simultaneously.
+ * To end simultaneously, `pathLength="1"` could be used, but it's not working in Safari yet.
+ */
+.uk-animation-stroke {
+  animation-name: uk-stroke;
+  animation-duration: 2s;
+  stroke-dasharray: var(--uk-animation-stroke);
+}
+/* Direction modifier
+ ========================================================================== */
+.uk-animation-reverse {
+  animation-direction: reverse;
+  animation-timing-function: ease-in;
+}
+/* Duration modifier
+ ========================================================================== */
+.uk-animation-fast {
+  animation-duration: 0.1s;
+}
+/* Toggle animation based on the State of the Parent Element
+ ========================================================================== */
+.uk-animation-toggle:not(:hover):not(:focus) [class*="uk-animation-"] {
+  animation-name: none;
+}
+/* Keyframes used by animation classes
+ ========================================================================== */
+/*
+ * Fade
+ */
+@keyframes uk-fade {
+  0% {
+    opacity: 0;
+  }
+  100% {
+    opacity: 1;
+  }
+}
+/*
+ * Scale
+ */
+@keyframes uk-scale-up {
+  0% {
+    transform: scale(0.9);
+  }
+  100% {
+    transform: scale(1);
+  }
+}
+@keyframes uk-scale-down {
+  0% {
+    transform: scale(1.1);
+  }
+  100% {
+    transform: scale(1);
+  }
+}
+/*
+ * Slide
+ */
+@keyframes uk-slide-top {
+  0% {
+    transform: translateY(-100%);
+  }
+  100% {
+    transform: translateY(0);
+  }
+}
+@keyframes uk-slide-bottom {
+  0% {
+    transform: translateY(100%);
+  }
+  100% {
+    transform: translateY(0);
+  }
+}
+@keyframes uk-slide-left {
+  0% {
+    transform: translateX(-100%);
+  }
+  100% {
+    transform: translateX(0);
+  }
+}
+@keyframes uk-slide-right {
+  0% {
+    transform: translateX(100%);
+  }
+  100% {
+    transform: translateX(0);
+  }
+}
+/*
+ * Slide Small
+ */
+@keyframes uk-slide-top-small {
+  0% {
+    transform: translateY(-10px);
+  }
+  100% {
+    transform: translateY(0);
+  }
+}
+@keyframes uk-slide-bottom-small {
+  0% {
+    transform: translateY(10px);
+  }
+  100% {
+    transform: translateY(0);
+  }
+}
+@keyframes uk-slide-left-small {
+  0% {
+    transform: translateX(-10px);
+  }
+  100% {
+    transform: translateX(0);
+  }
+}
+@keyframes uk-slide-right-small {
+  0% {
+    transform: translateX(10px);
+  }
+  100% {
+    transform: translateX(0);
+  }
+}
+/*
+ * Slide Medium
+ */
+@keyframes uk-slide-top-medium {
+  0% {
+    transform: translateY(-50px);
+  }
+  100% {
+    transform: translateY(0);
+  }
+}
+@keyframes uk-slide-bottom-medium {
+  0% {
+    transform: translateY(50px);
+  }
+  100% {
+    transform: translateY(0);
+  }
+}
+@keyframes uk-slide-left-medium {
+  0% {
+    transform: translateX(-50px);
+  }
+  100% {
+    transform: translateX(0);
+  }
+}
+@keyframes uk-slide-right-medium {
+  0% {
+    transform: translateX(50px);
+  }
+  100% {
+    transform: translateX(0);
+  }
+}
+/*
+ * Kenburns
+ */
+@keyframes uk-kenburns {
+  0% {
+    transform: scale(1);
+  }
+  100% {
+    transform: scale(1.2);
+  }
+}
+/*
+ * Shake
+ */
+@keyframes uk-shake {
+  0%,
+  100% {
+    transform: translateX(0);
+  }
+  10% {
+    transform: translateX(-9px);
+  }
+  20% {
+    transform: translateX(8px);
+  }
+  30% {
+    transform: translateX(-7px);
+  }
+  40% {
+    transform: translateX(6px);
+  }
+  50% {
+    transform: translateX(-5px);
+  }
+  60% {
+    transform: translateX(4px);
+  }
+  70% {
+    transform: translateX(-3px);
+  }
+  80% {
+    transform: translateX(2px);
+  }
+  90% {
+    transform: translateX(-1px);
+  }
+}
+/*
+ * Stroke
+ */
+@keyframes uk-stroke {
+  0% {
+    stroke-dashoffset: var(--uk-animation-stroke);
+  }
+  100% {
+    stroke-dashoffset: 0;
+  }
+}
+/* ========================================================================
+   Component: Width
+ ========================================================================== */
+/* Equal child widths
+ ========================================================================== */
+[class*="uk-child-width"] > * {
+  box-sizing: border-box;
+  width: 100%;
+}
+.uk-child-width-1-2 > * {
+  width: 50%;
+}
+.uk-child-width-1-3 > * {
+  width: calc(100% / 3);
+}
+.uk-child-width-1-4 > * {
+  width: 25%;
+}
+.uk-child-width-1-5 > * {
+  width: 20%;
+}
+.uk-child-width-1-6 > * {
+  width: calc(100% / 6);
+}
+.uk-child-width-auto > * {
+  width: auto;
+}
+/*
+ * 1. Reset the `min-width`, which is set to auto by default, because
+ *    flex items won't shrink below their minimum intrinsic content size.
+ *    Using `1px` instead of `0`, so items still wrap into the next line,
+ *    if they have zero width and padding and the predecessor is 100% wide.
+ */
+.uk-child-width-expand > :not([class*="uk-width"]) {
+  flex: 1;
+  /* 1 */
+  min-width: 1px;
+}
+/* Phone landscape and bigger */
+@media (min-width: 640px) {
+  .uk-child-width-1-1\@s > * {
+    width: 100%;
+  }
+  .uk-child-width-1-2\@s > * {
+    width: 50%;
+  }
+  .uk-child-width-1-3\@s > * {
+    width: calc(100% / 3);
+  }
+  .uk-child-width-1-4\@s > * {
+    width: 25%;
+  }
+  .uk-child-width-1-5\@s > * {
+    width: 20%;
+  }
+  .uk-child-width-1-6\@s > * {
+    width: calc(100% / 6);
+  }
+  .uk-child-width-auto\@s > * {
+    width: auto;
+  }
+  .uk-child-width-expand\@s > :not([class*="uk-width"]) {
+    flex: 1;
+    min-width: 1px;
+  }
+  /* Reset expand */
+  .uk-child-width-1-1\@s > :not([class*="uk-width"]),
+  .uk-child-width-1-2\@s > :not([class*="uk-width"]),
+  .uk-child-width-1-3\@s > :not([class*="uk-width"]),
+  .uk-child-width-1-4\@s > :not([class*="uk-width"]),
+  .uk-child-width-1-5\@s > :not([class*="uk-width"]),
+  .uk-child-width-1-6\@s > :not([class*="uk-width"]),
+  .uk-child-width-auto\@s > :not([class*="uk-width"]) {
+    flex: initial;
+  }
+}
+/* Tablet landscape and bigger */
+@media (min-width: 960px) {
+  .uk-child-width-1-1\@m > * {
+    width: 100%;
+  }
+  .uk-child-width-1-2\@m > * {
+    width: 50%;
+  }
+  .uk-child-width-1-3\@m > * {
+    width: calc(100% / 3);
+  }
+  .uk-child-width-1-4\@m > * {
+    width: 25%;
+  }
+  .uk-child-width-1-5\@m > * {
+    width: 20%;
+  }
+  .uk-child-width-1-6\@m > * {
+    width: calc(100% / 6);
+  }
+  .uk-child-width-auto\@m > * {
+    width: auto;
+  }
+  .uk-child-width-expand\@m > :not([class*="uk-width"]) {
+    flex: 1;
+    min-width: 1px;
+  }
+  /* Reset expand */
+  .uk-child-width-1-1\@m > :not([class*="uk-width"]),
+  .uk-child-width-1-2\@m > :not([class*="uk-width"]),
+  .uk-child-width-1-3\@m > :not([class*="uk-width"]),
+  .uk-child-width-1-4\@m > :not([class*="uk-width"]),
+  .uk-child-width-1-5\@m > :not([class*="uk-width"]),
+  .uk-child-width-1-6\@m > :not([class*="uk-width"]),
+  .uk-child-width-auto\@m > :not([class*="uk-width"]) {
+    flex: initial;
+  }
+}
+/* Desktop and bigger */
+@media (min-width: 1200px) {
+  .uk-child-width-1-1\@l > * {
+    width: 100%;
+  }
+  .uk-child-width-1-2\@l > * {
+    width: 50%;
+  }
+  .uk-child-width-1-3\@l > * {
+    width: calc(100% / 3);
+  }
+  .uk-child-width-1-4\@l > * {
+    width: 25%;
+  }
+  .uk-child-width-1-5\@l > * {
+    width: 20%;
+  }
+  .uk-child-width-1-6\@l > * {
+    width: calc(100% / 6);
+  }
+  .uk-child-width-auto\@l > * {
+    width: auto;
+  }
+  .uk-child-width-expand\@l > :not([class*="uk-width"]) {
+    flex: 1;
+    min-width: 1px;
+  }
+  /* Reset expand */
+  .uk-child-width-1-1\@l > :not([class*="uk-width"]),
+  .uk-child-width-1-2\@l > :not([class*="uk-width"]),
+  .uk-child-width-1-3\@l > :not([class*="uk-width"]),
+  .uk-child-width-1-4\@l > :not([class*="uk-width"]),
+  .uk-child-width-1-5\@l > :not([class*="uk-width"]),
+  .uk-child-width-1-6\@l > :not([class*="uk-width"]),
+  .uk-child-width-auto\@l > :not([class*="uk-width"]) {
+    flex: initial;
+  }
+}
+/* Large screen and bigger */
+@media (min-width: 1600px) {
+  .uk-child-width-1-1\@xl > * {
+    width: 100%;
+  }
+  .uk-child-width-1-2\@xl > * {
+    width: 50%;
+  }
+  .uk-child-width-1-3\@xl > * {
+    width: calc(100% / 3);
+  }
+  .uk-child-width-1-4\@xl > * {
+    width: 25%;
+  }
+  .uk-child-width-1-5\@xl > * {
+    width: 20%;
+  }
+  .uk-child-width-1-6\@xl > * {
+    width: calc(100% / 6);
+  }
+  .uk-child-width-auto\@xl > * {
+    width: auto;
+  }
+  .uk-child-width-expand\@xl > :not([class*="uk-width"]) {
+    flex: 1;
+    min-width: 1px;
+  }
+  /* Reset expand */
+  .uk-child-width-1-1\@xl > :not([class*="uk-width"]),
+  .uk-child-width-1-2\@xl > :not([class*="uk-width"]),
+  .uk-child-width-1-3\@xl > :not([class*="uk-width"]),
+  .uk-child-width-1-4\@xl > :not([class*="uk-width"]),
+  .uk-child-width-1-5\@xl > :not([class*="uk-width"]),
+  .uk-child-width-1-6\@xl > :not([class*="uk-width"]),
+  .uk-child-width-auto\@xl > :not([class*="uk-width"]) {
+    flex: initial;
+  }
+}
+/* Single Widths
+ ========================================================================== */
+/*
+ * 1. `max-width` is needed for the pixel-based classes
+ */
+[class*="uk-width"] {
+  box-sizing: border-box;
+  width: 100%;
+  /* 1 */
+  max-width: 100%;
+}
+/* Halves */
+.uk-width-1-2 {
+  width: 50%;
+}
+/* Thirds */
+.uk-width-1-3 {
+  width: calc(100% / 3);
+}
+.uk-width-2-3 {
+  width: calc(200% / 3);
+}
+/* Quarters */
+.uk-width-1-4 {
+  width: 25%;
+}
+.uk-width-3-4 {
+  width: 75%;
+}
+/* Fifths */
+.uk-width-1-5 {
+  width: 20%;
+}
+.uk-width-2-5 {
+  width: 40%;
+}
+.uk-width-3-5 {
+  width: 60%;
+}
+.uk-width-4-5 {
+  width: 80%;
+}
+/* Sixths */
+.uk-width-1-6 {
+  width: calc(100% / 6);
+}
+.uk-width-5-6 {
+  width: calc(500% / 6);
+}
+/* Pixel */
+.uk-width-small {
+  width: 150px;
+}
+.uk-width-medium {
+  width: 300px;
+}
+.uk-width-large {
+  width: 450px;
+}
+.uk-width-xlarge {
+  width: 600px;
+}
+.uk-width-2xlarge {
+  width: 750px;
+}
+/* Auto */
+.uk-width-auto {
+  width: auto;
+}
+/* Expand */
+.uk-width-expand {
+  flex: 1;
+  min-width: 1px;
+}
+/* Phone landscape and bigger */
+@media (min-width: 640px) {
+  /* Whole */
+  .uk-width-1-1\@s {
+    width: 100%;
+  }
+  /* Halves */
+  .uk-width-1-2\@s {
+    width: 50%;
+  }
+  /* Thirds */
+  .uk-width-1-3\@s {
+    width: calc(100% / 3);
+  }
+  .uk-width-2-3\@s {
+    width: calc(200% / 3);
+  }
+  /* Quarters */
+  .uk-width-1-4\@s {
+    width: 25%;
+  }
+  .uk-width-3-4\@s {
+    width: 75%;
+  }
+  /* Fifths */
+  .uk-width-1-5\@s {
+    width: 20%;
+  }
+  .uk-width-2-5\@s {
+    width: 40%;
+  }
+  .uk-width-3-5\@s {
+    width: 60%;
+  }
+  .uk-width-4-5\@s {
+    width: 80%;
+  }
+  /* Sixths */
+  .uk-width-1-6\@s {
+    width: calc(100% / 6);
+  }
+  .uk-width-5-6\@s {
+    width: calc(500% / 6);
+  }
+  /* Pixel */
+  .uk-width-small\@s {
+    width: 150px;
+  }
+  .uk-width-medium\@s {
+    width: 300px;
+  }
+  .uk-width-large\@s {
+    width: 450px;
+  }
+  .uk-width-xlarge\@s {
+    width: 600px;
+  }
+  .uk-width-2xlarge\@s {
+    width: 750px;
+  }
+  /* Auto */
+  .uk-width-auto\@s {
+    width: auto;
+  }
+  /* Expand */
+  .uk-width-expand\@s {
+    flex: 1;
+    min-width: 1px;
+  }
+  /* Reset expand */
+  .uk-width-1-1\@s,
+  .uk-width-1-2\@s,
+  .uk-width-1-3\@s,
+  .uk-width-2-3\@s,
+  .uk-width-1-4\@s,
+  .uk-width-3-4\@s,
+  .uk-width-1-5\@s,
+  .uk-width-2-5\@s,
+  .uk-width-3-5\@s,
+  .uk-width-4-5\@s,
+  .uk-width-1-6\@s,
+  .uk-width-5-6\@s,
+  .uk-width-small\@s,
+  .uk-width-medium\@s,
+  .uk-width-large\@s,
+  .uk-width-xlarge\@s,
+  .uk-width-2xlarge\@s,
+  .uk-width-auto\@s {
+    flex: initial;
+  }
+}
+/* Tablet landscape and bigger */
+@media (min-width: 960px) {
+  /* Whole */
+  .uk-width-1-1\@m {
+    width: 100%;
+  }
+  /* Halves */
+  .uk-width-1-2\@m {
+    width: 50%;
+  }
+  /* Thirds */
+  .uk-width-1-3\@m {
+    width: calc(100% / 3);
+  }
+  .uk-width-2-3\@m {
+    width: calc(200% / 3);
+  }
+  /* Quarters */
+  .uk-width-1-4\@m {
+    width: 25%;
+  }
+  .uk-width-3-4\@m {
+    width: 75%;
+  }
+  /* Fifths */
+  .uk-width-1-5\@m {
+    width: 20%;
+  }
+  .uk-width-2-5\@m {
+    width: 40%;
+  }
+  .uk-width-3-5\@m {
+    width: 60%;
+  }
+  .uk-width-4-5\@m {
+    width: 80%;
+  }
+  /* Sixths */
+  .uk-width-1-6\@m {
+    width: calc(100% / 6);
+  }
+  .uk-width-5-6\@m {
+    width: calc(500% / 6);
+  }
+  /* Pixel */
+  .uk-width-small\@m {
+    width: 150px;
+  }
+  .uk-width-medium\@m {
+    width: 300px;
+  }
+  .uk-width-large\@m {
+    width: 450px;
+  }
+  .uk-width-xlarge\@m {
+    width: 600px;
+  }
+  .uk-width-2xlarge\@m {
+    width: 750px;
+  }
+  /* Auto */
+  .uk-width-auto\@m {
+    width: auto;
+  }
+  /* Expand */
+  .uk-width-expand\@m {
+    flex: 1;
+    min-width: 1px;
+  }
+  /* Reset expand */
+  .uk-width-1-1\@m,
+  .uk-width-1-2\@m,
+  .uk-width-1-3\@m,
+  .uk-width-2-3\@m,
+  .uk-width-1-4\@m,
+  .uk-width-3-4\@m,
+  .uk-width-1-5\@m,
+  .uk-width-2-5\@m,
+  .uk-width-3-5\@m,
+  .uk-width-4-5\@m,
+  .uk-width-1-6\@m,
+  .uk-width-5-6\@m,
+  .uk-width-small\@m,
+  .uk-width-medium\@m,
+  .uk-width-large\@m,
+  .uk-width-xlarge\@m,
+  .uk-width-2xlarge\@m,
+  .uk-width-auto\@m {
+    flex: initial;
+  }
+}
+/* Desktop and bigger */
+@media (min-width: 1200px) {
+  /* Whole */
+  .uk-width-1-1\@l {
+    width: 100%;
+  }
+  /* Halves */
+  .uk-width-1-2\@l {
+    width: 50%;
+  }
+  /* Thirds */
+  .uk-width-1-3\@l {
+    width: calc(100% / 3);
+  }
+  .uk-width-2-3\@l {
+    width: calc(200% / 3);
+  }
+  /* Quarters */
+  .uk-width-1-4\@l {
+    width: 25%;
+  }
+  .uk-width-3-4\@l {
+    width: 75%;
+  }
+  /* Fifths */
+  .uk-width-1-5\@l {
+    width: 20%;
+  }
+  .uk-width-2-5\@l {
+    width: 40%;
+  }
+  .uk-width-3-5\@l {
+    width: 60%;
+  }
+  .uk-width-4-5\@l {
+    width: 80%;
+  }
+  /* Sixths */
+  .uk-width-1-6\@l {
+    width: calc(100% / 6);
+  }
+  .uk-width-5-6\@l {
+    width: calc(500% / 6);
+  }
+  /* Pixel */
+  .uk-width-small\@l {
+    width: 150px;
+  }
+  .uk-width-medium\@l {
+    width: 300px;
+  }
+  .uk-width-large\@l {
+    width: 450px;
+  }
+  .uk-width-xlarge\@l {
+    width: 600px;
+  }
+  .uk-width-2xlarge\@l {
+    width: 750px;
+  }
+  /* Auto */
+  .uk-width-auto\@l {
+    width: auto;
+  }
+  /* Expand */
+  .uk-width-expand\@l {
+    flex: 1;
+    min-width: 1px;
+  }
+  /* Reset expand */
+  .uk-width-1-1\@l,
+  .uk-width-1-2\@l,
+  .uk-width-1-3\@l,
+  .uk-width-2-3\@l,
+  .uk-width-1-4\@l,
+  .uk-width-3-4\@l,
+  .uk-width-1-5\@l,
+  .uk-width-2-5\@l,
+  .uk-width-3-5\@l,
+  .uk-width-4-5\@l,
+  .uk-width-1-6\@l,
+  .uk-width-5-6\@l,
+  .uk-width-small\@l,
+  .uk-width-medium\@l,
+  .uk-width-large\@l,
+  .uk-width-xlarge\@l,
+  .uk-width-2xlarge\@l,
+  .uk-width-auto\@l {
+    flex: initial;
+  }
+}
+/* Large screen and bigger */
+@media (min-width: 1600px) {
+  /* Whole */
+  .uk-width-1-1\@xl {
+    width: 100%;
+  }
+  /* Halves */
+  .uk-width-1-2\@xl {
+    width: 50%;
+  }
+  /* Thirds */
+  .uk-width-1-3\@xl {
+    width: calc(100% / 3);
+  }
+  .uk-width-2-3\@xl {
+    width: calc(200% / 3);
+  }
+  /* Quarters */
+  .uk-width-1-4\@xl {
+    width: 25%;
+  }
+  .uk-width-3-4\@xl {
+    width: 75%;
+  }
+  /* Fifths */
+  .uk-width-1-5\@xl {
+    width: 20%;
+  }
+  .uk-width-2-5\@xl {
+    width: 40%;
+  }
+  .uk-width-3-5\@xl {
+    width: 60%;
+  }
+  .uk-width-4-5\@xl {
+    width: 80%;
+  }
+  /* Sixths */
+  .uk-width-1-6\@xl {
+    width: calc(100% / 6);
+  }
+  .uk-width-5-6\@xl {
+    width: calc(500% / 6);
+  }
+  /* Pixel */
+  .uk-width-small\@xl {
+    width: 150px;
+  }
+  .uk-width-medium\@xl {
+    width: 300px;
+  }
+  .uk-width-large\@xl {
+    width: 450px;
+  }
+  .uk-width-xlarge\@xl {
+    width: 600px;
+  }
+  .uk-width-2xlarge\@xl {
+    width: 750px;
+  }
+  /* Auto */
+  .uk-width-auto\@xl {
+    width: auto;
+  }
+  /* Expand */
+  .uk-width-expand\@xl {
+    flex: 1;
+    min-width: 1px;
+  }
+  /* Reset expand */
+  .uk-width-1-1\@xl,
+  .uk-width-1-2\@xl,
+  .uk-width-1-3\@xl,
+  .uk-width-2-3\@xl,
+  .uk-width-1-4\@xl,
+  .uk-width-3-4\@xl,
+  .uk-width-1-5\@xl,
+  .uk-width-2-5\@xl,
+  .uk-width-3-5\@xl,
+  .uk-width-4-5\@xl,
+  .uk-width-1-6\@xl,
+  .uk-width-5-6\@xl,
+  .uk-width-small\@xl,
+  .uk-width-medium\@xl,
+  .uk-width-large\@xl,
+  .uk-width-xlarge\@xl,
+  .uk-width-2xlarge\@xl,
+  .uk-width-auto\@xl {
+    flex: initial;
+  }
+}
+/* Intrinsic Widths
+ ========================================================================== */
+.uk-width-max-content {
+  width: max-content;
+}
+.uk-width-min-content {
+  width: min-content;
+}
+/* ========================================================================
+   Component: Height
+ ========================================================================== */
+[class*="uk-height"] {
+  box-sizing: border-box;
+}
+/*
+ * Only works if parent element has a height set
+ */
+.uk-height-1-1 {
+  height: 100%;
+}
+/*
+ * Useful to create image teasers
+ */
+.uk-height-viewport {
+  min-height: 100vh;
+}
+.uk-height-viewport-2 {
+  min-height: 200vh;
+}
+.uk-height-viewport-3 {
+  min-height: 300vh;
+}
+.uk-height-viewport-4 {
+  min-height: 400vh;
+}
+/*
+ * Pixel
+ * Useful for `overflow: auto`
+ */
+.uk-height-small {
+  height: 150px;
+}
+.uk-height-medium {
+  height: 300px;
+}
+.uk-height-large {
+  height: 450px;
+}
+.uk-height-max-small {
+  max-height: 150px;
+}
+.uk-height-max-medium {
+  max-height: 300px;
+}
+.uk-height-max-large {
+  max-height: 450px;
+}
+/* ========================================================================
+   Component: Text
+ ========================================================================== */
+/* Style modifiers
+ ========================================================================== */
+.uk-text-lead {
+  font-size: 1.5rem;
+  line-height: 1.5;
+  color: #333;
+}
+.uk-text-meta {
+  font-size: 0.875rem;
+  line-height: 1.4;
+  color: #999;
+}
+.uk-text-meta > a {
+  color: #999;
+}
+.uk-text-meta > a:hover {
+  color: #666;
+  text-decoration: none;
+}
+/* Size modifiers
+ ========================================================================== */
+.uk-text-small {
+  font-size: 0.875rem;
+  line-height: 1.5;
+}
+.uk-text-large {
+  font-size: 1.5rem;
+  line-height: 1.5;
+}
+.uk-text-default {
+  font-size: 16px;
+  line-height: 1.5;
+}
+/* Weight modifier
+ ========================================================================== */
+.uk-text-light {
+  font-weight: 300;
+}
+.uk-text-normal {
+  font-weight: 400;
+}
+.uk-text-bold {
+  font-weight: 700;
+}
+.uk-text-lighter {
+  font-weight: lighter;
+}
+.uk-text-bolder {
+  font-weight: bolder;
+}
+/* Style modifier
+ ========================================================================== */
+.uk-text-italic {
+  font-style: italic;
+}
+/* Transform modifier
+ ========================================================================== */
+.uk-text-capitalize {
+  text-transform: capitalize !important;
+}
+.uk-text-uppercase {
+  text-transform: uppercase !important;
+}
+.uk-text-lowercase {
+  text-transform: lowercase !important;
+}
+/* Decoration modifier
+ ========================================================================== */
+.uk-text-decoration-none {
+  text-decoration: none !important;
+}
+/* Color modifiers
+ ========================================================================== */
+.uk-text-muted {
+  color: #999 !important;
+}
+.uk-text-emphasis {
+  color: #333 !important;
+}
+.uk-text-primary {
+  color: #1e87f0 !important;
+}
+.uk-text-secondary {
+  color: #222 !important;
+}
+.uk-text-success {
+  color: #32d296 !important;
+}
+.uk-text-warning {
+  color: #faa05a !important;
+}
+.uk-text-danger {
+  color: #f0506e !important;
+}
+/* Background modifier
+ ========================================================================== */
+/*
+ * 1. The background clips to the foreground text. Works in all browsers.
+ * 2. Default color is set to transparent.
+ * 3. Container fits the text
+ * 4. Style
+ */
+.uk-text-background {
+  /* 1 */
+  -webkit-background-clip: text;
+  /* 2 */
+  color: transparent !important;
+  /* 3 */
+  display: inline-block;
+  /* 4 */
+  background-color: #1e87f0;
+  background-image: linear-gradient(90deg, #1e87f0 0%, #411ef0 100%);
+}
+/* Alignment modifiers
+ ========================================================================== */
+.uk-text-left {
+  text-align: left !important;
+}
+.uk-text-right {
+  text-align: right !important;
+}
+.uk-text-center {
+  text-align: center !important;
+}
+.uk-text-justify {
+  text-align: justify !important;
+}
+/* Phone landscape and bigger */
+@media (min-width: 640px) {
+  .uk-text-left\@s {
+    text-align: left !important;
+  }
+  .uk-text-right\@s {
+    text-align: right !important;
+  }
+  .uk-text-center\@s {
+    text-align: center !important;
+  }
+}
+/* Tablet landscape and bigger */
+@media (min-width: 960px) {
+  .uk-text-left\@m {
+    text-align: left !important;
+  }
+  .uk-text-right\@m {
+    text-align: right !important;
+  }
+  .uk-text-center\@m {
+    text-align: center !important;
+  }
+}
+/* Desktop and bigger */
+@media (min-width: 1200px) {
+  .uk-text-left\@l {
+    text-align: left !important;
+  }
+  .uk-text-right\@l {
+    text-align: right !important;
+  }
+  .uk-text-center\@l {
+    text-align: center !important;
+  }
+}
+/* Large screen and bigger */
+@media (min-width: 1600px) {
+  .uk-text-left\@xl {
+    text-align: left !important;
+  }
+  .uk-text-right\@xl {
+    text-align: right !important;
+  }
+  .uk-text-center\@xl {
+    text-align: center !important;
+  }
+}
+/*
+ * Vertical
+ */
+.uk-text-top {
+  vertical-align: top !important;
+}
+.uk-text-middle {
+  vertical-align: middle !important;
+}
+.uk-text-bottom {
+  vertical-align: bottom !important;
+}
+.uk-text-baseline {
+  vertical-align: baseline !important;
+}
+/* Wrap modifiers
+ ========================================================================== */
+/*
+ * Prevent text from wrapping onto multiple lines
+ */
+.uk-text-nowrap {
+  white-space: nowrap;
+}
+/*
+ * 1. Make sure a max-width is set after which truncation can occur
+ * 2. Prevent text from wrapping onto multiple lines, and truncate with an ellipsis
+ * 3. Fix for table cells
+ */
+.uk-text-truncate {
+  /* 1 */
+  max-width: 100%;
+  /* 2 */
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+/* 2 */
+th.uk-text-truncate,
+td.uk-text-truncate {
+  max-width: 0;
+}
+/*
+ * Wrap long words onto the next line and break them if they are too long to fit.
+ * 1. Make it work with table cells in all browsers.
+ * Note: Not using `hyphens: auto` because it hyphenates text even if not needed.
+ */
+.uk-text-break {
+  overflow-wrap: break-word;
+}
+/* 1 */
+th.uk-text-break,
+td.uk-text-break {
+  word-break: break-word;
+}
+/* ========================================================================
+   Component: Column
+ ========================================================================== */
+[class*="uk-column-"] {
+  column-gap: 30px;
+}
+/* Desktop and bigger */
+@media (min-width: 1200px) {
+  [class*="uk-column-"] {
+    column-gap: 40px;
+  }
+}
+/*
+ * Fix image 1px line wrapping into the next column in Chrome
+ */
+[class*="uk-column-"] img {
+  transform: translate3d(0, 0, 0);
+}
+/* Divider
+ ========================================================================== */
+/*
+ * 1. Double the column gap
+ */
+.uk-column-divider {
+  column-rule: 1px solid #e5e5e5;
+  /* 1 */
+  column-gap: 60px;
+}
+/* Desktop and bigger */
+@media (min-width: 1200px) {
+  .uk-column-divider {
+    column-gap: 80px;
+  }
+}
+/* Width modifiers
+ ========================================================================== */
+.uk-column-1-2 {
+  column-count: 2;
+}
+.uk-column-1-3 {
+  column-count: 3;
+}
+.uk-column-1-4 {
+  column-count: 4;
+}
+.uk-column-1-5 {
+  column-count: 5;
+}
+.uk-column-1-6 {
+  column-count: 6;
+}
+/* Phone landscape and bigger */
+@media (min-width: 640px) {
+  .uk-column-1-2\@s {
+    column-count: 2;
+  }
+  .uk-column-1-3\@s {
+    column-count: 3;
+  }
+  .uk-column-1-4\@s {
+    column-count: 4;
+  }
+  .uk-column-1-5\@s {
+    column-count: 5;
+  }
+  .uk-column-1-6\@s {
+    column-count: 6;
+  }
+}
+/* Tablet landscape and bigger */
+@media (min-width: 960px) {
+  .uk-column-1-2\@m {
+    column-count: 2;
+  }
+  .uk-column-1-3\@m {
+    column-count: 3;
+  }
+  .uk-column-1-4\@m {
+    column-count: 4;
+  }
+  .uk-column-1-5\@m {
+    column-count: 5;
+  }
+  .uk-column-1-6\@m {
+    column-count: 6;
+  }
+}
+/* Desktop and bigger */
+@media (min-width: 1200px) {
+  .uk-column-1-2\@l {
+    column-count: 2;
+  }
+  .uk-column-1-3\@l {
+    column-count: 3;
+  }
+  .uk-column-1-4\@l {
+    column-count: 4;
+  }
+  .uk-column-1-5\@l {
+    column-count: 5;
+  }
+  .uk-column-1-6\@l {
+    column-count: 6;
+  }
+}
+/* Large screen and bigger */
+@media (min-width: 1600px) {
+  .uk-column-1-2\@xl {
+    column-count: 2;
+  }
+  .uk-column-1-3\@xl {
+    column-count: 3;
+  }
+  .uk-column-1-4\@xl {
+    column-count: 4;
+  }
+  .uk-column-1-5\@xl {
+    column-count: 5;
+  }
+  .uk-column-1-6\@xl {
+    column-count: 6;
+  }
+}
+/* Make element span across all columns
+ * Does not work in Firefox yet
+ ========================================================================== */
+.uk-column-span {
+  column-span: all;
+}
+/* ========================================================================
+   Component: Cover
+ ========================================================================== */
+/*
+ * Works with iframes and embedded content
+ * 1. Use attribute to apply transform instantly. Needed if transform is transitioned.
+ * 2. Reset responsiveness for embedded content
+ * 3. Center object
+ * Note: Percent values on the `top` property only works if this element
+ *       is absolute positioned or if the container has a height
+ */
+/* 1 */
+[uk-cover]:where(canvas, iframe, svg),
+[data-uk-cover]:where(canvas, iframe, svg) {
+  /* 2 */
+  max-width: none;
+  /* 3 */
+  position: absolute;
+  left: 50%;
+  top: 50%;
+  --uk-position-translate-x: -50%;
+  --uk-position-translate-y: -50%;
+  transform: translate(var(--uk-position-translate-x), var(--uk-position-translate-y));
+}
+iframe[uk-cover],
+iframe[data-uk-cover] {
+  pointer-events: none;
+}
+[uk-cover]:where(img, video),
+[data-uk-cover]:where(img, video) {
+  /* 3 */
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  box-sizing: border-box;
+  object-fit: cover;
+  object-position: center;
+}
+/* Container
+ ========================================================================== */
+/*
+ * 1. Parent container which clips resized object
+ * 2. Needed if the child is positioned absolute. See note above
+ */
+.uk-cover-container {
+  /* 1 */
+  overflow: hidden;
+  /* 2 */
+  position: relative;
+}
+/* ========================================================================
+   Component: Background
+ ========================================================================== */
+/* Color
+ ========================================================================== */
+.uk-background-default {
+  background-color: #fff;
+}
+.uk-background-muted {
+  background-color: #f8f8f8;
+}
+.uk-background-primary {
+  background-color: #1e87f0;
+}
+.uk-background-secondary {
+  background-color: #222;
+}
+/* Size
+ ========================================================================== */
+.uk-background-cover,
+.uk-background-contain,
+.uk-background-width-1-1,
+.uk-background-height-1-1 {
+  background-position: 50% 50%;
+  background-repeat: no-repeat;
+}
+.uk-background-cover {
+  background-size: cover;
+}
+.uk-background-contain {
+  background-size: contain;
+}
+.uk-background-width-1-1 {
+  background-size: 100%;
+}
+.uk-background-height-1-1 {
+  background-size: auto 100%;
+}
+/* Position
+ ========================================================================== */
+.uk-background-top-left {
+  background-position: 0 0;
+}
+.uk-background-top-center {
+  background-position: 50% 0;
+}
+.uk-background-top-right {
+  background-position: 100% 0;
+}
+.uk-background-center-left {
+  background-position: 0 50%;
+}
+.uk-background-center-center {
+  background-position: 50% 50%;
+}
+.uk-background-center-right {
+  background-position: 100% 50%;
+}
+.uk-background-bottom-left {
+  background-position: 0 100%;
+}
+.uk-background-bottom-center {
+  background-position: 50% 100%;
+}
+.uk-background-bottom-right {
+  background-position: 100% 100%;
+}
+/* Repeat
+ ========================================================================== */
+.uk-background-norepeat {
+  background-repeat: no-repeat;
+}
+/* Attachment
+ ========================================================================== */
+/*
+ * 1. Fix bug introduced in Chrome 67: the background image is not visible if any element on the page uses `translate3d`
+ */
+.uk-background-fixed {
+  background-attachment: fixed;
+  /* 1 */
+  backface-visibility: hidden;
+}
+/*
+ * Exclude touch devices because `fixed` doesn't work on iOS and Android
+ */
+@media (pointer: coarse) {
+  .uk-background-fixed {
+    background-attachment: scroll;
+  }
+}
+/* Image
+ ========================================================================== */
+/* Phone portrait and smaller */
+@media (max-width: 639px) {
+  .uk-background-image\@s {
+    background-image: none !important;
+  }
+}
+/* Phone landscape and smaller */
+@media (max-width: 959px) {
+  .uk-background-image\@m {
+    background-image: none !important;
+  }
+}
+/* Tablet landscape and smaller */
+@media (max-width: 1199px) {
+  .uk-background-image\@l {
+    background-image: none !important;
+  }
+}
+/* Desktop and smaller */
+@media (max-width: 1599px) {
+  .uk-background-image\@xl {
+    background-image: none !important;
+  }
+}
+/* Blend modes
+ ========================================================================== */
+.uk-background-blend-multiply {
+  background-blend-mode: multiply;
+}
+.uk-background-blend-screen {
+  background-blend-mode: screen;
+}
+.uk-background-blend-overlay {
+  background-blend-mode: overlay;
+}
+.uk-background-blend-darken {
+  background-blend-mode: darken;
+}
+.uk-background-blend-lighten {
+  background-blend-mode: lighten;
+}
+.uk-background-blend-color-dodge {
+  background-blend-mode: color-dodge;
+}
+.uk-background-blend-color-burn {
+  background-blend-mode: color-burn;
+}
+.uk-background-blend-hard-light {
+  background-blend-mode: hard-light;
+}
+.uk-background-blend-soft-light {
+  background-blend-mode: soft-light;
+}
+.uk-background-blend-difference {
+  background-blend-mode: difference;
+}
+.uk-background-blend-exclusion {
+  background-blend-mode: exclusion;
+}
+.uk-background-blend-hue {
+  background-blend-mode: hue;
+}
+.uk-background-blend-saturation {
+  background-blend-mode: saturation;
+}
+.uk-background-blend-color {
+  background-blend-mode: color;
+}
+.uk-background-blend-luminosity {
+  background-blend-mode: luminosity;
+}
+/* ========================================================================
+   Component: Align
+ ========================================================================== */
+/*
+ * Default
+ */
+[class*="uk-align"] {
+  display: block;
+  margin-bottom: 30px;
+}
+* + [class*="uk-align"] {
+  margin-top: 30px;
+}
+/*
+ * Center
+ */
+.uk-align-center {
+  margin-left: auto;
+  margin-right: auto;
+}
+/*
+ * Left/Right
+ */
+.uk-align-left {
+  margin-top: 0;
+  margin-right: 30px;
+  float: left;
+}
+.uk-align-right {
+  margin-top: 0;
+  margin-left: 30px;
+  float: right;
+}
+/* Phone landscape and bigger */
+@media (min-width: 640px) {
+  .uk-align-left\@s {
+    margin-top: 0;
+    margin-right: 30px;
+    float: left;
+  }
+  .uk-align-right\@s {
+    margin-top: 0;
+    margin-left: 30px;
+    float: right;
+  }
+}
+/* Tablet landscape and bigger */
+@media (min-width: 960px) {
+  .uk-align-left\@m {
+    margin-top: 0;
+    margin-right: 30px;
+    float: left;
+  }
+  .uk-align-right\@m {
+    margin-top: 0;
+    margin-left: 30px;
+    float: right;
+  }
+}
+/* Desktop and bigger */
+@media (min-width: 1200px) {
+  .uk-align-left\@l {
+    margin-top: 0;
+    float: left;
+  }
+  .uk-align-right\@l {
+    margin-top: 0;
+    float: right;
+  }
+  .uk-align-left,
+  .uk-align-left\@s,
+  .uk-align-left\@m,
+  .uk-align-left\@l {
+    margin-right: 40px;
+  }
+  .uk-align-right,
+  .uk-align-right\@s,
+  .uk-align-right\@m,
+  .uk-align-right\@l {
+    margin-left: 40px;
+  }
+}
+/* Large screen and bigger */
+@media (min-width: 1600px) {
+  .uk-align-left\@xl {
+    margin-top: 0;
+    margin-right: 40px;
+    float: left;
+  }
+  .uk-align-right\@xl {
+    margin-top: 0;
+    margin-left: 40px;
+    float: right;
+  }
+}
+/* ========================================================================
+   Component: SVG
+ ========================================================================== */
+/*
+ * 1. Fill all SVG elements with the current text color if no `fill` attribute is set
+ * 2. Set the fill and stroke color of all SVG elements to the current text color
+ */
+/* 1 */
+.uk-svg,
+.uk-svg:not(.uk-preserve) [fill*="#"]:not(.uk-preserve) {
+  fill: currentcolor;
+}
+.uk-svg:not(.uk-preserve) [stroke*="#"]:not(.uk-preserve) {
+  stroke: currentcolor;
+}
+/*
+ * Fix Firefox blurry SVG rendering: https://bugzilla.mozilla.org/show_bug.cgi?id=1046835
+ */
+.uk-svg {
+  transform: translate(0, 0);
+}
+/* ========================================================================
+   Component: Utility
+ ========================================================================== */
+/* Panel
+ ========================================================================== */
+.uk-panel {
+  display: flow-root;
+  position: relative;
+  box-sizing: border-box;
+}
+/*
+ * Remove margin from the last-child
+ */
+.uk-panel > :last-child {
+  margin-bottom: 0;
+}
+/*
+ * Scrollable
+ */
+.uk-panel-scrollable {
+  height: 170px;
+  padding: 10px;
+  border: 1px solid #e5e5e5;
+  overflow: auto;
+  resize: both;
+}
+/* Clearfix
+ ========================================================================== */
+/*
+ * 1. `table-cell` is used with `::before` because `table` creates a 1px gap when it becomes a flex item, only in Webkit
+ * 2. `table` is used again with `::after` because `clear` only works with block elements.
+ * Note: `display: block` with `overflow: hidden` is currently not working in the latest Safari
+ */
+/* 1 */
+.uk-clearfix::before {
+  content: "";
+  display: table-cell;
+}
+/* 2 */
+.uk-clearfix::after {
+  content: "";
+  display: table;
+  clear: both;
+}
+/* Float
+ ========================================================================== */
+/*
+ * 1. Prevent content overflow
+ */
+.uk-float-left {
+  float: left;
+}
+.uk-float-right {
+  float: right;
+}
+/* 1 */
+[class*="uk-float-"] {
+  max-width: 100%;
+}
+/* Overflow
+ ========================================================================== */
+.uk-overflow-hidden {
+  overflow: hidden;
+}
+/*
+ * Enable scrollbars if content is clipped
+ */
+.uk-overflow-auto {
+  overflow: auto;
+}
+.uk-overflow-auto > :last-child {
+  margin-bottom: 0;
+}
+/* Box Sizing
+ ========================================================================== */
+.uk-box-sizing-content {
+  box-sizing: content-box;
+}
+.uk-box-sizing-border {
+  box-sizing: border-box;
+}
+/* Resize
+ ========================================================================== */
+.uk-resize {
+  resize: both;
+}
+.uk-resize-horizontal {
+  resize: horizontal;
+}
+.uk-resize-vertical {
+  resize: vertical;
+}
+/* Display
+ ========================================================================== */
+.uk-display-block {
+  display: block !important;
+}
+.uk-display-inline {
+  display: inline !important;
+}
+.uk-display-inline-block {
+  display: inline-block !important;
+}
+/* Inline
+ ========================================================================== */
+/*
+ * 1. Container fits its content
+ * 2. Create position context
+ * 3. Prevent content overflow
+ * 4. Behave like most inline-block elements
+ * 5. Force new layer without creating a new stacking context
+ *    to fix 1px glitch when combined with overlays and transitions in Webkit
+ * 6. Clip child elements
+ */
+[class*="uk-inline"] {
+  /* 1 */
+  display: inline-block;
+  /* 2 */
+  position: relative;
+  /* 3 */
+  max-width: 100%;
+  /* 4 */
+  vertical-align: middle;
+  /* 5 */
+  -webkit-backface-visibility: hidden;
+}
+.uk-inline-clip {
+  /* 6 */
+  overflow: hidden;
+}
+/* Responsive objects
+ ========================================================================== */
+/*
+ * Preserve original dimensions
+ * Because `img, `video`, `canvas` and  `audio` are already responsive by default, see Base component
+ */
+.uk-preserve-width,
+.uk-preserve-width canvas,
+.uk-preserve-width img,
+.uk-preserve-width svg,
+.uk-preserve-width video {
+  max-width: none;
+}
+/*
+ * Responsiveness
+ * Corrects `max-width` and `max-height` behavior if padding and border are used
+ */
+.uk-responsive-width,
+.uk-responsive-height {
+  box-sizing: border-box;
+}
+/*
+ * 1. Set a maximum width. `important` needed to override `uk-preserve-width img`
+ * 2. Auto scale the height. Only needed if `height` attribute is present
+ */
+.uk-responsive-width {
+  /* 1 */
+  max-width: 100% !important;
+  /* 2 */
+  height: auto;
+}
+/*
+ * 1. Set a maximum height. Only works if the parent element has a fixed height
+ * 2. Auto scale the width. Only needed if `width` attribute is present
+ * 3. Reset max-width, which `img, `video`, `canvas` and  `audio` already have by default
+ */
+.uk-responsive-height {
+  /* 1 */
+  max-height: 100%;
+  /* 2 */
+  width: auto;
+  /* 3 */
+  max-width: none;
+}
+/*
+ * Fix initial iframe width. Without the viewport is expanded on iOS devices
+ */
+[uk-responsive],
+[data-uk-responsive] {
+  max-width: 100%;
+}
+/* Object
+ ========================================================================== */
+.uk-object-cover {
+  object-fit: cover;
+}
+.uk-object-contain {
+  object-fit: contain;
+}
+.uk-object-fill {
+  object-fit: fill;
+}
+.uk-object-none {
+  object-fit: none;
+}
+.uk-object-scale-down {
+  object-fit: scale-down;
+}
+/*
+ * Position
+ */
+.uk-object-top-left {
+  object-position: 0 0;
+}
+.uk-object-top-center {
+  object-position: 50% 0;
+}
+.uk-object-top-right {
+  object-position: 100% 0;
+}
+.uk-object-center-left {
+  object-position: 0 50%;
+}
+.uk-object-center-center {
+  object-position: 50% 50%;
+}
+.uk-object-center-right {
+  object-position: 100% 50%;
+}
+.uk-object-bottom-left {
+  object-position: 0 100%;
+}
+.uk-object-bottom-center {
+  object-position: 50% 100%;
+}
+.uk-object-bottom-right {
+  object-position: 100% 100%;
+}
+/* Border
+ ========================================================================== */
+.uk-border-circle {
+  border-radius: 50%;
+}
+.uk-border-pill {
+  border-radius: 500px;
+}
+.uk-border-rounded {
+  border-radius: 5px;
+}
+/*
+ * Fix `overflow: hidden` to be ignored with border-radius and CSS transforms in Webkit
+ */
+.uk-inline-clip[class*="uk-border-"] {
+  -webkit-transform: translateZ(0);
+}
+/* Box-shadow
+ ========================================================================== */
+.uk-box-shadow-small {
+  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.08);
+}
+.uk-box-shadow-medium {
+  box-shadow: 0 5px 15px rgba(0, 0, 0, 0.08);
+}
+.uk-box-shadow-large {
+  box-shadow: 0 14px 25px rgba(0, 0, 0, 0.16);
+}
+.uk-box-shadow-xlarge {
+  box-shadow: 0 28px 50px rgba(0, 0, 0, 0.16);
+}
+/*
+ * Hover
+ */
+[class*="uk-box-shadow-hover"] {
+  transition: box-shadow 0.1s ease-in-out;
+}
+.uk-box-shadow-hover-small:hover {
+  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.08);
+}
+.uk-box-shadow-hover-medium:hover {
+  box-shadow: 0 5px 15px rgba(0, 0, 0, 0.08);
+}
+.uk-box-shadow-hover-large:hover {
+  box-shadow: 0 14px 25px rgba(0, 0, 0, 0.16);
+}
+.uk-box-shadow-hover-xlarge:hover {
+  box-shadow: 0 28px 50px rgba(0, 0, 0, 0.16);
+}
+/* Box-shadow bottom
+ ========================================================================== */
+/*
+ * 1. Set position.
+ * 2. Set style
+ * 3. Fix shadow being clipped in Safari if container is animated
+ */
+@supports (filter: blur(0)) {
+  .uk-box-shadow-bottom {
+    display: inline-block;
+    position: relative;
+    z-index: 0;
+    max-width: 100%;
+    vertical-align: middle;
+  }
+  .uk-box-shadow-bottom::after {
+    content: "";
+    /* 1 */
+    position: absolute;
+    bottom: -30px;
+    left: 0;
+    right: 0;
+    z-index: -1;
+    /* 2 */
+    height: 30px;
+    border-radius: 100%;
+    background: #444;
+    filter: blur(20px);
+    /* 3 */
+    will-change: filter;
+  }
+}
+/* Drop cap
+ ========================================================================== */
+/*
+ * 1. Firefox doesn't apply `::first-letter` if the first letter is inside child elements
+ *    https://bugzilla.mozilla.org/show_bug.cgi?id=214004
+ * 2. In Firefox, a floating `::first-letter` doesn't have a line box and there for no `line-height`
+ *    https://bugzilla.mozilla.org/show_bug.cgi?id=317933
+ */
+.uk-dropcap::first-letter,
+.uk-dropcap > p:first-of-type::first-letter {
+  display: block;
+  margin-right: 10px;
+  float: left;
+  font-size: 4.5em;
+  line-height: 1;
+  margin-bottom: -2px;
+}
+/* 2 */
+@-moz-document url-prefix() {
+  .uk-dropcap::first-letter,
+  .uk-dropcap > p:first-of-type::first-letter {
+    margin-top: 1.1%;
+  }
+}
+/* Logo
+ ========================================================================== */
+/*
+ * 1. Style
+ * 2. Required for `a`
+ * 3. Behave like image but can be overridden through flex utility classes
+ */
+.uk-logo {
+  /* 1 */
+  font-size: 1.5rem;
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+  color: #333;
+  /* 2 */
+  text-decoration: none;
+}
+/* 3 */
+:where(.uk-logo) {
+  display: inline-block;
+  vertical-align: middle;
+}
+/* Hover */
+.uk-logo:hover {
+  color: #333;
+  /* 1 */
+  text-decoration: none;
+}
+.uk-logo :where(img, svg, video) {
+  display: block;
+}
+.uk-logo-inverse {
+  display: none;
+}
+/* Disabled State
+ ========================================================================== */
+.uk-disabled {
+  pointer-events: none;
+}
+/* Drag State
+ ========================================================================== */
+/*
+ * 1. Needed if moving over elements with have their own cursor on hover, e.g. links or buttons
+ * 2. Fix dragging over iframes
+ */
+.uk-drag,
+.uk-drag * {
+  cursor: move;
+}
+/* 2 */
+.uk-drag iframe {
+  pointer-events: none;
+}
+/* Dragover State
+ ========================================================================== */
+/*
+ * Create a box-shadow when dragging a file over the upload area
+ */
+.uk-dragover {
+  box-shadow: 0 0 20px rgba(100, 100, 100, 0.3);
+}
+/* Blend modes
+ ========================================================================== */
+.uk-blend-multiply {
+  mix-blend-mode: multiply;
+}
+.uk-blend-screen {
+  mix-blend-mode: screen;
+}
+.uk-blend-overlay {
+  mix-blend-mode: overlay;
+}
+.uk-blend-darken {
+  mix-blend-mode: darken;
+}
+.uk-blend-lighten {
+  mix-blend-mode: lighten;
+}
+.uk-blend-color-dodge {
+  mix-blend-mode: color-dodge;
+}
+.uk-blend-color-burn {
+  mix-blend-mode: color-burn;
+}
+.uk-blend-hard-light {
+  mix-blend-mode: hard-light;
+}
+.uk-blend-soft-light {
+  mix-blend-mode: soft-light;
+}
+.uk-blend-difference {
+  mix-blend-mode: difference;
+}
+.uk-blend-exclusion {
+  mix-blend-mode: exclusion;
+}
+.uk-blend-hue {
+  mix-blend-mode: hue;
+}
+.uk-blend-saturation {
+  mix-blend-mode: saturation;
+}
+.uk-blend-color {
+  mix-blend-mode: color;
+}
+.uk-blend-luminosity {
+  mix-blend-mode: luminosity;
+}
+/* Transform
+========================================================================== */
+.uk-transform-center {
+  transform: translate(-50%, -50%);
+}
+/* Transform Origin
+========================================================================== */
+.uk-transform-origin-top-left {
+  transform-origin: 0 0;
+}
+.uk-transform-origin-top-center {
+  transform-origin: 50% 0;
+}
+.uk-transform-origin-top-right {
+  transform-origin: 100% 0;
+}
+.uk-transform-origin-center-left {
+  transform-origin: 0 50%;
+}
+.uk-transform-origin-center-right {
+  transform-origin: 100% 50%;
+}
+.uk-transform-origin-bottom-left {
+  transform-origin: 0 100%;
+}
+.uk-transform-origin-bottom-center {
+  transform-origin: 50% 100%;
+}
+.uk-transform-origin-bottom-right {
+  transform-origin: 100% 100%;
+}
+/* ========================================================================
+   Component: Flex
+ ========================================================================== */
+.uk-flex {
+  display: flex;
+}
+.uk-flex-inline {
+  display: inline-flex;
+}
+/* Alignment
+ ========================================================================== */
+/*
+ * Align items along the main axis of the current line of the flex container
+ * Row: Horizontal
+ */
+.uk-flex-left {
+  justify-content: flex-start;
+}
+.uk-flex-center {
+  justify-content: center;
+}
+.uk-flex-right {
+  justify-content: flex-end;
+}
+.uk-flex-between {
+  justify-content: space-between;
+}
+.uk-flex-around {
+  justify-content: space-around;
+}
+/* Phone landscape and bigger */
+@media (min-width: 640px) {
+  .uk-flex-left\@s {
+    justify-content: flex-start;
+  }
+  .uk-flex-center\@s {
+    justify-content: center;
+  }
+  .uk-flex-right\@s {
+    justify-content: flex-end;
+  }
+  .uk-flex-between\@s {
+    justify-content: space-between;
+  }
+  .uk-flex-around\@s {
+    justify-content: space-around;
+  }
+}
+/* Tablet landscape and bigger */
+@media (min-width: 960px) {
+  .uk-flex-left\@m {
+    justify-content: flex-start;
+  }
+  .uk-flex-center\@m {
+    justify-content: center;
+  }
+  .uk-flex-right\@m {
+    justify-content: flex-end;
+  }
+  .uk-flex-between\@m {
+    justify-content: space-between;
+  }
+  .uk-flex-around\@m {
+    justify-content: space-around;
+  }
+}
+/* Desktop and bigger */
+@media (min-width: 1200px) {
+  .uk-flex-left\@l {
+    justify-content: flex-start;
+  }
+  .uk-flex-center\@l {
+    justify-content: center;
+  }
+  .uk-flex-right\@l {
+    justify-content: flex-end;
+  }
+  .uk-flex-between\@l {
+    justify-content: space-between;
+  }
+  .uk-flex-around\@l {
+    justify-content: space-around;
+  }
+}
+/* Large screen and bigger */
+@media (min-width: 1600px) {
+  .uk-flex-left\@xl {
+    justify-content: flex-start;
+  }
+  .uk-flex-center\@xl {
+    justify-content: center;
+  }
+  .uk-flex-right\@xl {
+    justify-content: flex-end;
+  }
+  .uk-flex-between\@xl {
+    justify-content: space-between;
+  }
+  .uk-flex-around\@xl {
+    justify-content: space-around;
+  }
+}
+/*
+ * Align items in the cross axis of the current line of the flex container
+ * Row: Vertical
+ */
+.uk-flex-stretch {
+  align-items: stretch;
+}
+.uk-flex-top {
+  align-items: flex-start;
+}
+.uk-flex-middle {
+  align-items: center;
+}
+.uk-flex-bottom {
+  align-items: flex-end;
+}
+/* Phone landscape and bigger */
+@media (min-width: 640px) {
+  .uk-flex-stretch\@s {
+    align-items: stretch;
+  }
+  .uk-flex-top\@s {
+    align-items: flex-start;
+  }
+  .uk-flex-middle\@s {
+    align-items: center;
+  }
+  .uk-flex-bottom\@s {
+    align-items: flex-end;
+  }
+}
+/* Tablet landscape and bigger */
+@media (min-width: 960px) {
+  .uk-flex-stretch\@m {
+    align-items: stretch;
+  }
+  .uk-flex-top\@m {
+    align-items: flex-start;
+  }
+  .uk-flex-middle\@m {
+    align-items: center;
+  }
+  .uk-flex-bottom\@m {
+    align-items: flex-end;
+  }
+}
+/* Desktop and bigger */
+@media (min-width: 1200px) {
+  .uk-flex-stretch\@l {
+    align-items: stretch;
+  }
+  .uk-flex-top\@l {
+    align-items: flex-start;
+  }
+  .uk-flex-middle\@l {
+    align-items: center;
+  }
+  .uk-flex-bottom\@l {
+    align-items: flex-end;
+  }
+}
+/* Large screen and bigger */
+@media (min-width: 1600px) {
+  .uk-flex-stretch\@xl {
+    align-items: stretch;
+  }
+  .uk-flex-top\@xl {
+    align-items: flex-start;
+  }
+  .uk-flex-middle\@xl {
+    align-items: center;
+  }
+  .uk-flex-bottom\@xl {
+    align-items: flex-end;
+  }
+}
+/* Direction
+ ========================================================================== */
+.uk-flex-row {
+  flex-direction: row;
+}
+.uk-flex-row-reverse {
+  flex-direction: row-reverse;
+}
+.uk-flex-column {
+  flex-direction: column;
+}
+.uk-flex-column-reverse {
+  flex-direction: column-reverse;
+}
+/* Phone landscape and bigger */
+@media (min-width: 640px) {
+  .uk-flex-row\@s {
+    flex-direction: row;
+  }
+  .uk-flex-column\@s {
+    flex-direction: column;
+  }
+}
+/* Tablet landscape and bigger */
+@media (min-width: 960px) {
+  .uk-flex-row\@m {
+    flex-direction: row;
+  }
+  .uk-flex-column\@m {
+    flex-direction: column;
+  }
+}
+/* Desktop and bigger */
+@media (min-width: 1200px) {
+  .uk-flex-row\@l {
+    flex-direction: row;
+  }
+  .uk-flex-column\@l {
+    flex-direction: column;
+  }
+}
+/* Large screen and bigger */
+@media (min-width: 1600px) {
+  .uk-flex-row\@xl {
+    flex-direction: row;
+  }
+  .uk-flex-column\@xl {
+    flex-direction: column;
+  }
+}
+/* Wrap
+ ========================================================================== */
+.uk-flex-nowrap {
+  flex-wrap: nowrap;
+}
+.uk-flex-wrap {
+  flex-wrap: wrap;
+}
+.uk-flex-wrap-reverse {
+  flex-wrap: wrap-reverse;
+}
+/*
+ * Aligns items within the flex container when there is extra space in the cross-axis
+ * Only works if there is more than one line of flex items
+ */
+.uk-flex-wrap-stretch {
+  align-content: stretch;
+}
+.uk-flex-wrap-top {
+  align-content: flex-start;
+}
+.uk-flex-wrap-middle {
+  align-content: center;
+}
+.uk-flex-wrap-bottom {
+  align-content: flex-end;
+}
+.uk-flex-wrap-between {
+  align-content: space-between;
+}
+.uk-flex-wrap-around {
+  align-content: space-around;
+}
+/* Item ordering
+ ========================================================================== */
+/*
+ * Default is 0
+ */
+.uk-flex-first {
+  order: -1;
+}
+.uk-flex-last {
+  order: 99;
+}
+/* Phone landscape and bigger */
+@media (min-width: 640px) {
+  .uk-flex-first\@s {
+    order: -1;
+  }
+  .uk-flex-last\@s {
+    order: 99;
+  }
+}
+/* Tablet landscape and bigger */
+@media (min-width: 960px) {
+  .uk-flex-first\@m {
+    order: -1;
+  }
+  .uk-flex-last\@m {
+    order: 99;
+  }
+}
+/* Desktop and bigger */
+@media (min-width: 1200px) {
+  .uk-flex-first\@l {
+    order: -1;
+  }
+  .uk-flex-last\@l {
+    order: 99;
+  }
+}
+/* Large screen and bigger */
+@media (min-width: 1600px) {
+  .uk-flex-first\@xl {
+    order: -1;
+  }
+  .uk-flex-last\@xl {
+    order: 99;
+  }
+}
+/* Item dimensions
+ ========================================================================== */
+/*
+ * Initial: 0 1 auto
+ * Content dimensions, but shrinks
+ */
+.uk-flex-initial {
+  flex: initial;
+}
+/*
+ * No Flex: 0 0 auto
+ * Content dimensions
+ */
+.uk-flex-none {
+  flex: none;
+}
+/*
+ * Relative Flex: 1 1 auto
+ * Space is allocated considering content
+ */
+.uk-flex-auto {
+  flex: auto;
+}
+/*
+ * Absolute Flex: 1 1 0%
+ * Space is allocated solely based on flex
+ */
+.uk-flex-1 {
+  flex: 1;
+}
+/* Phone landscape and bigger */
+@media (min-width: 640px) {
+  .uk-flex-initial\@s {
+    flex: initial;
+  }
+  .uk-flex-none\@s {
+    flex: none;
+  }
+  .uk-flex-1\@s {
+    flex: 1;
+  }
+}
+/* Tablet landscape and bigger */
+@media (min-width: 960px) {
+  .uk-flex-initial\@m {
+    flex: initial;
+  }
+  .uk-flex-none\@m {
+    flex: none;
+  }
+  .uk-flex-1\@m {
+    flex: 1;
+  }
+}
+/* Desktop and bigger */
+@media (min-width: 1200px) {
+  .uk-flex-initial\@l {
+    flex: initial;
+  }
+  .uk-flex-none\@l {
+    flex: none;
+  }
+  .uk-flex-1\@l {
+    flex: 1;
+  }
+}
+/* Large screen and bigger */
+@media (min-width: 1600px) {
+  .uk-flex-initial\@xl {
+    flex: initial;
+  }
+  .uk-flex-none\@xl {
+    flex: none;
+  }
+  .uk-flex-1\@xl {
+    flex: 1;
+  }
+}
+/* ========================================================================
+   Component: Margin
+ ========================================================================== */
+/*
+ * Default
+ */
+.uk-margin {
+  margin-bottom: 20px;
+}
+* + .uk-margin {
+  margin-top: 20px !important;
+}
+.uk-margin-top {
+  margin-top: 20px !important;
+}
+.uk-margin-bottom {
+  margin-bottom: 20px !important;
+}
+.uk-margin-left {
+  margin-left: 20px !important;
+}
+.uk-margin-right {
+  margin-right: 20px !important;
+}
+/* Small
+ ========================================================================== */
+.uk-margin-small {
+  margin-bottom: 10px;
+}
+* + .uk-margin-small {
+  margin-top: 10px !important;
+}
+.uk-margin-small-top {
+  margin-top: 10px !important;
+}
+.uk-margin-small-bottom {
+  margin-bottom: 10px !important;
+}
+.uk-margin-small-left {
+  margin-left: 10px !important;
+}
+.uk-margin-small-right {
+  margin-right: 10px !important;
+}
+/* Medium
+ ========================================================================== */
+.uk-margin-medium {
+  margin-bottom: 40px;
+}
+* + .uk-margin-medium {
+  margin-top: 40px !important;
+}
+.uk-margin-medium-top {
+  margin-top: 40px !important;
+}
+.uk-margin-medium-bottom {
+  margin-bottom: 40px !important;
+}
+.uk-margin-medium-left {
+  margin-left: 40px !important;
+}
+.uk-margin-medium-right {
+  margin-right: 40px !important;
+}
+/* Large
+ ========================================================================== */
+.uk-margin-large {
+  margin-bottom: 40px;
+}
+* + .uk-margin-large {
+  margin-top: 40px !important;
+}
+.uk-margin-large-top {
+  margin-top: 40px !important;
+}
+.uk-margin-large-bottom {
+  margin-bottom: 40px !important;
+}
+.uk-margin-large-left {
+  margin-left: 40px !important;
+}
+.uk-margin-large-right {
+  margin-right: 40px !important;
+}
+/* Desktop and bigger */
+@media (min-width: 1200px) {
+  .uk-margin-large {
+    margin-bottom: 70px;
+  }
+  * + .uk-margin-large {
+    margin-top: 70px !important;
+  }
+  .uk-margin-large-top {
+    margin-top: 70px !important;
+  }
+  .uk-margin-large-bottom {
+    margin-bottom: 70px !important;
+  }
+  .uk-margin-large-left {
+    margin-left: 70px !important;
+  }
+  .uk-margin-large-right {
+    margin-right: 70px !important;
+  }
+}
+/* XLarge
+ ========================================================================== */
+.uk-margin-xlarge {
+  margin-bottom: 70px;
+}
+* + .uk-margin-xlarge {
+  margin-top: 70px !important;
+}
+.uk-margin-xlarge-top {
+  margin-top: 70px !important;
+}
+.uk-margin-xlarge-bottom {
+  margin-bottom: 70px !important;
+}
+.uk-margin-xlarge-left {
+  margin-left: 70px !important;
+}
+.uk-margin-xlarge-right {
+  margin-right: 70px !important;
+}
+/* Desktop and bigger */
+@media (min-width: 1200px) {
+  .uk-margin-xlarge {
+    margin-bottom: 140px;
+  }
+  * + .uk-margin-xlarge {
+    margin-top: 140px !important;
+  }
+  .uk-margin-xlarge-top {
+    margin-top: 140px !important;
+  }
+  .uk-margin-xlarge-bottom {
+    margin-bottom: 140px !important;
+  }
+  .uk-margin-xlarge-left {
+    margin-left: 140px !important;
+  }
+  .uk-margin-xlarge-right {
+    margin-right: 140px !important;
+  }
+}
+/* Auto
+ ========================================================================== */
+.uk-margin-auto {
+  margin-left: auto !important;
+  margin-right: auto !important;
+}
+.uk-margin-auto-top {
+  margin-top: auto !important;
+}
+.uk-margin-auto-bottom {
+  margin-bottom: auto !important;
+}
+.uk-margin-auto-left {
+  margin-left: auto !important;
+}
+.uk-margin-auto-right {
+  margin-right: auto !important;
+}
+.uk-margin-auto-vertical {
+  margin-top: auto !important;
+  margin-bottom: auto !important;
+}
+/* Phone landscape and bigger */
+@media (min-width: 640px) {
+  .uk-margin-auto\@s {
+    margin-left: auto !important;
+    margin-right: auto !important;
+  }
+  .uk-margin-auto-left\@s {
+    margin-left: auto !important;
+  }
+  .uk-margin-auto-right\@s {
+    margin-right: auto !important;
+  }
+}
+/* Tablet landscape and bigger */
+@media (min-width: 960px) {
+  .uk-margin-auto\@m {
+    margin-left: auto !important;
+    margin-right: auto !important;
+  }
+  .uk-margin-auto-left\@m {
+    margin-left: auto !important;
+  }
+  .uk-margin-auto-right\@m {
+    margin-right: auto !important;
+  }
+}
+/* Desktop and bigger */
+@media (min-width: 1200px) {
+  .uk-margin-auto\@l {
+    margin-left: auto !important;
+    margin-right: auto !important;
+  }
+  .uk-margin-auto-left\@l {
+    margin-left: auto !important;
+  }
+  .uk-margin-auto-right\@l {
+    margin-right: auto !important;
+  }
+}
+/* Large screen and bigger */
+@media (min-width: 1600px) {
+  .uk-margin-auto\@xl {
+    margin-left: auto !important;
+    margin-right: auto !important;
+  }
+  .uk-margin-auto-left\@xl {
+    margin-left: auto !important;
+  }
+  .uk-margin-auto-right\@xl {
+    margin-right: auto !important;
+  }
+}
+/* Remove
+ ========================================================================== */
+.uk-margin-remove {
+  margin: 0 !important;
+}
+.uk-margin-remove-top {
+  margin-top: 0 !important;
+}
+.uk-margin-remove-bottom {
+  margin-bottom: 0 !important;
+}
+.uk-margin-remove-left {
+  margin-left: 0 !important;
+}
+.uk-margin-remove-right {
+  margin-right: 0 !important;
+}
+.uk-margin-remove-vertical {
+  margin-top: 0 !important;
+  margin-bottom: 0 !important;
+}
+.uk-margin-remove-adjacent + *,
+.uk-margin-remove-first-child > :first-child {
+  margin-top: 0 !important;
+}
+.uk-margin-remove-last-child > :last-child {
+  margin-bottom: 0 !important;
+}
+/* Phone landscape and bigger */
+@media (min-width: 640px) {
+  .uk-margin-remove-left\@s {
+    margin-left: 0 !important;
+  }
+  .uk-margin-remove-right\@s {
+    margin-right: 0 !important;
+  }
+}
+/* Tablet landscape and bigger */
+@media (min-width: 960px) {
+  .uk-margin-remove-left\@m {
+    margin-left: 0 !important;
+  }
+  .uk-margin-remove-right\@m {
+    margin-right: 0 !important;
+  }
+}
+/* Desktop and bigger */
+@media (min-width: 1200px) {
+  .uk-margin-remove-left\@l {
+    margin-left: 0 !important;
+  }
+  .uk-margin-remove-right\@l {
+    margin-right: 0 !important;
+  }
+}
+/* Large screen and bigger */
+@media (min-width: 1600px) {
+  .uk-margin-remove-left\@xl {
+    margin-left: 0 !important;
+  }
+  .uk-margin-remove-right\@xl {
+    margin-right: 0 !important;
+  }
+}
+/* ========================================================================
+   Component: Padding
+ ========================================================================== */
+.uk-padding {
+  padding: 30px;
+}
+/* Desktop and bigger */
+@media (min-width: 1200px) {
+  .uk-padding {
+    padding: 40px;
+  }
+}
+/* Small
+ ========================================================================== */
+.uk-padding-small {
+  padding: 15px;
+}
+/* Large
+ ========================================================================== */
+.uk-padding-large {
+  padding: 40px;
+}
+/* Desktop and bigger */
+@media (min-width: 1200px) {
+  .uk-padding-large {
+    padding: 70px;
+  }
+}
+/* Remove
+ ========================================================================== */
+.uk-padding-remove {
+  padding: 0 !important;
+}
+.uk-padding-remove-top {
+  padding-top: 0 !important;
+}
+.uk-padding-remove-bottom {
+  padding-bottom: 0 !important;
+}
+.uk-padding-remove-left {
+  padding-left: 0 !important;
+}
+.uk-padding-remove-right {
+  padding-right: 0 !important;
+}
+.uk-padding-remove-vertical {
+  padding-top: 0 !important;
+  padding-bottom: 0 !important;
+}
+.uk-padding-remove-horizontal {
+  padding-left: 0 !important;
+  padding-right: 0 !important;
+}
+/* ========================================================================
+   Component: Position
+ ========================================================================== */
+:root {
+  --uk-position-margin-offset: 0px;
+}
+/* Directions
+ ========================================================================== */
+/*
+ * 1. Prevent content overflow.
+ */
+[class*="uk-position-top"],
+[class*="uk-position-bottom"],
+[class*="uk-position-left"],
+[class*="uk-position-right"],
+[class*="uk-position-center"] {
+  position: absolute !important;
+  /* 1 */
+  max-width: calc(100% - (var(--uk-position-margin-offset) * 2));
+  box-sizing: border-box;
+}
+/*
+ * Edges
+ * Don't use `width: 100%` because it's wrong if the parent has padding.
+ */
+.uk-position-top {
+  top: 0;
+  left: 0;
+  right: 0;
+}
+.uk-position-bottom {
+  bottom: 0;
+  left: 0;
+  right: 0;
+}
+.uk-position-left {
+  top: 0;
+  bottom: 0;
+  left: 0;
+}
+.uk-position-right {
+  top: 0;
+  bottom: 0;
+  right: 0;
+}
+/*
+ * Corners
+ */
+.uk-position-top-left {
+  top: 0;
+  left: 0;
+}
+.uk-position-top-right {
+  top: 0;
+  right: 0;
+}
+.uk-position-bottom-left {
+  bottom: 0;
+  left: 0;
+}
+.uk-position-bottom-right {
+  bottom: 0;
+  right: 0;
+}
+/*
+ * Center
+ * 1. Fix text wrapping if content is larger than 50% of the container.
+ *    Using `max-content` requires `max-width` of 100% which is set generally.
+ */
+.uk-position-center {
+  top: calc(50% - var(--uk-position-margin-offset));
+  left: calc(50% - var(--uk-position-margin-offset));
+  --uk-position-translate-x: -50%;
+  --uk-position-translate-y: -50%;
+  transform: translate(var(--uk-position-translate-x), var(--uk-position-translate-y));
+  /* 1 */
+  width: max-content;
+}
+/* Vertical */
+[class*="uk-position-center-left"],
+[class*="uk-position-center-right"],
+.uk-position-center-vertical {
+  top: calc(50% - var(--uk-position-margin-offset));
+  --uk-position-translate-y: -50%;
+  transform: translate(0, var(--uk-position-translate-y));
+}
+.uk-position-center-left {
+  left: 0;
+}
+.uk-position-center-right {
+  right: 0;
+}
+.uk-position-center-vertical {
+  left: 0;
+  right: 0;
+}
+.uk-position-center-left-out {
+  right: 100%;
+  width: max-content;
+}
+.uk-position-center-right-out {
+  left: 100%;
+  width: max-content;
+}
+/* Horizontal */
+.uk-position-top-center,
+.uk-position-bottom-center,
+.uk-position-center-horizontal {
+  left: calc(50% - var(--uk-position-margin-offset));
+  --uk-position-translate-x: -50%;
+  transform: translate(var(--uk-position-translate-x), 0);
+  /* 1 */
+  width: max-content;
+}
+.uk-position-top-center {
+  top: 0;
+}
+.uk-position-bottom-center {
+  bottom: 0;
+}
+.uk-position-center-horizontal {
+  top: 0;
+  bottom: 0;
+}
+/*
+ * Cover
+ */
+.uk-position-cover {
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  left: 0;
+  right: 0;
+}
+/* Margin
+ ========================================================================== */
+.uk-position-small {
+  margin: 15px;
+  --uk-position-margin-offset: 15px;
+}
+.uk-position-medium {
+  margin: 30px;
+  --uk-position-margin-offset: 30px;
+}
+.uk-position-large {
+  margin: 30px;
+  --uk-position-margin-offset: 30px;
+}
+/* Desktop and bigger */
+@media (min-width: 1200px) {
+  .uk-position-large {
+    margin: 50px;
+    --uk-position-margin-offset: 50px;
+  }
+}
+/* Schemes
+ ========================================================================== */
+.uk-position-relative {
+  position: relative  !important;
+}
+.uk-position-absolute {
+  position: absolute  !important;
+}
+.uk-position-fixed {
+  position: fixed  !important;
+}
+.uk-position-sticky {
+  position: sticky  !important;
+}
+/* Layer
+ ========================================================================== */
+.uk-position-z-index {
+  z-index: 1;
+}
+.uk-position-z-index-zero {
+  z-index: 0;
+}
+.uk-position-z-index-negative {
+  z-index: -1;
+}
+.uk-position-z-index-high {
+  z-index: 990;
+}
+/* ========================================================================
+   Component: Transition
+ ========================================================================== */
+/* Transitions
+ ========================================================================== */
+/*
+ * The toggle is triggered on touch devices by two methods:
+ * 1. Using `:focus` and tabindex
+ * 2. Using `:hover` and a `touchstart` event listener registered on the document
+ *    (Doesn't work on Surface touch devices)
+ */
+:where(.uk-transition-fade),
+:where([class*="uk-transition-scale"]),
+:where([class*="uk-transition-slide"]) {
+  --uk-position-translate-x: 0;
+  --uk-position-translate-y: 0;
+}
+.uk-transition-fade,
+[class*="uk-transition-scale"],
+[class*="uk-transition-slide"] {
+  --uk-translate-x: 0;
+  --uk-translate-y: 0;
+  --uk-scale-x: 1;
+  --uk-scale-y: 1;
+  transform: translate(var(--uk-position-translate-x), var(--uk-position-translate-y)) translate(var(--uk-translate-x), var(--uk-translate-y)) scale(var(--uk-scale-x), var(--uk-scale-y));
+  transition: 0.3s ease-out;
+  transition-property: opacity, transform, filter;
+  opacity: 0;
+}
+/*
+ * Fade
+ */
+.uk-transition-toggle:hover .uk-transition-fade,
+.uk-transition-toggle:focus .uk-transition-fade,
+.uk-transition-toggle .uk-transition-fade:focus-within,
+.uk-transition-active.uk-active .uk-transition-fade {
+  opacity: 1;
+}
+/*
+ * Scale
+ * 1. Make image rendering the same during the transition as before and after. Prefixed because of Safari.
+ */
+/* 1 */
+[class*="uk-transition-scale"] {
+  -webkit-backface-visibility: hidden;
+}
+.uk-transition-scale-up {
+  --uk-scale-x: 1;
+  --uk-scale-y: 1;
+}
+.uk-transition-scale-down {
+  --uk-scale-x: 1.03;
+  --uk-scale-y: 1.03;
+}
+/* Show */
+.uk-transition-toggle:hover .uk-transition-scale-up,
+.uk-transition-toggle:focus .uk-transition-scale-up,
+.uk-transition-toggle .uk-transition-scale-up:focus-within,
+.uk-transition-active.uk-active .uk-transition-scale-up {
+  --uk-scale-x: 1.03;
+  --uk-scale-y: 1.03;
+  opacity: 1;
+}
+.uk-transition-toggle:hover .uk-transition-scale-down,
+.uk-transition-toggle:focus .uk-transition-scale-down,
+.uk-transition-toggle .uk-transition-scale-down:focus-within,
+.uk-transition-active.uk-active .uk-transition-scale-down {
+  --uk-scale-x: 1;
+  --uk-scale-y: 1;
+  opacity: 1;
+}
+/*
+ * Slide
+ */
+.uk-transition-slide-top {
+  --uk-translate-y: -100%;
+}
+.uk-transition-slide-bottom {
+  --uk-translate-y: 100%;
+}
+.uk-transition-slide-left {
+  --uk-translate-x: -100%;
+}
+.uk-transition-slide-right {
+  --uk-translate-x: 100%;
+}
+.uk-transition-slide-top-small {
+  --uk-translate-y: calc(-1 * 10px);
+}
+.uk-transition-slide-bottom-small {
+  --uk-translate-y: 10px;
+}
+.uk-transition-slide-left-small {
+  --uk-translate-x: calc(-1 * 10px);
+}
+.uk-transition-slide-right-small {
+  --uk-translate-x: 10px;
+}
+.uk-transition-slide-top-medium {
+  --uk-translate-y: calc(-1 * 50px);
+}
+.uk-transition-slide-bottom-medium {
+  --uk-translate-y: 50px;
+}
+.uk-transition-slide-left-medium {
+  --uk-translate-x: calc(-1 * 50px);
+}
+.uk-transition-slide-right-medium {
+  --uk-translate-x: 50px;
+}
+/* Show */
+.uk-transition-toggle:hover [class*="uk-transition-slide"],
+.uk-transition-toggle:focus [class*="uk-transition-slide"],
+.uk-transition-toggle [class*="uk-transition-slide"]:focus-within,
+.uk-transition-active.uk-active [class*="uk-transition-slide"] {
+  --uk-translate-x: 0;
+  --uk-translate-y: 0;
+  opacity: 1;
+}
+/* Opacity modifier
+ ========================================================================== */
+.uk-transition-opaque {
+  opacity: 1;
+}
+/* Duration modifier
+ ========================================================================== */
+.uk-transition-slow {
+  transition-duration: 0.7s;
+}
+/* Disable modifier
+ ========================================================================== */
+.uk-transition-disable,
+.uk-transition-disable * {
+  transition: none !important;
+}
+/* ========================================================================
+   Component: Visibility
+ ========================================================================== */
+/*
+ * Hidden
+ * `hidden` attribute also set here to make it stronger
+ */
+[hidden],
+.uk-hidden {
+  display: none !important;
+}
+/* Phone landscape and bigger */
+@media (min-width: 640px) {
+  .uk-hidden\@s {
+    display: none !important;
+  }
+}
+/* Tablet landscape and bigger */
+@media (min-width: 960px) {
+  .uk-hidden\@m {
+    display: none !important;
+  }
+}
+/* Desktop and bigger */
+@media (min-width: 1200px) {
+  .uk-hidden\@l {
+    display: none !important;
+  }
+}
+/* Large screen and bigger */
+@media (min-width: 1600px) {
+  .uk-hidden\@xl {
+    display: none !important;
+  }
+}
+/*
+ * Visible
+ */
+/* Phone portrait and smaller */
+@media (max-width: 639px) {
+  .uk-visible\@s {
+    display: none !important;
+  }
+}
+/* Phone landscape and smaller */
+@media (max-width: 959px) {
+  .uk-visible\@m {
+    display: none !important;
+  }
+}
+/* Tablet landscape and smaller */
+@media (max-width: 1199px) {
+  .uk-visible\@l {
+    display: none !important;
+  }
+}
+/* Desktop and smaller */
+@media (max-width: 1599px) {
+  .uk-visible\@xl {
+    display: none !important;
+  }
+}
+/* Visibility
+ ========================================================================== */
+.uk-invisible {
+  visibility: hidden !important;
+}
+/* Based on the State of the Parent Element
+ ========================================================================== */
+/*
+ * Mind that `display: none`, `visibility: hidden` and `opacity: 0`
+ * remove the element from the accessibility tree and that
+ * `display: none` and `visibility: hidden` are not focusable.
+ *
+ * The target stays visible if any element within receives focus through keyboard.
+ */
+/*
+ * Remove space when hidden.
+ * 1. Remove from document flow.
+ * 2. Hide element and shrink its dimension. Current browsers and screen readers
+ *    keep the element in the accessibility tree even with zero dimensions.
+ *    Using `tabindex="-1"` will show the element on touch devices.
+ *    Note: `clip-path` doesn't work with `tabindex` on touch devices.
+ */
+.uk-hidden-visually:not(:focus):not(:active):not(:focus-within),
+.uk-visible-toggle:not(:hover):not(:focus) .uk-hidden-hover:not(:focus-within) {
+  /* 1 */
+  position: absolute !important;
+  /* 2 */
+  width: 0 !important;
+  height: 0 !important;
+  padding: 0 !important;
+  border: 0 !important;
+  margin: 0 !important;
+  overflow: hidden !important;
+}
+/*
+ * Keep space when hidden.
+ * Hide element without shrinking its dimension.
+ * Note: `clip-path` doesn't work with hover for elements outside of the toggle box.
+ */
+.uk-visible-toggle:not(:hover):not(:focus) .uk-invisible-hover:not(:focus-within) {
+  opacity: 0 !important;
+}
+/* Based on Hover Capability of the Pointing Device
+ ========================================================================== */
+/*
+ * Hover
+ */
+/* Hide if primary pointing device doesn't support hover, e.g. touch screens. */
+@media (hover: none) {
+  .uk-hidden-touch {
+    display: none !important;
+  }
+}
+/* Hide if primary pointing device supports hover, e.g. mice. */
+@media (hover) {
+  .uk-hidden-notouch {
+    display: none !important;
+  }
+}
+/* ========================================================================
+   Component: Inverse
+ ========================================================================== */
+/*
+ * Implemented class depends on the general theme color
+ * `uk-light` is for light colors on dark backgrounds
+ * `uk-dark` is or dark colors on light backgrounds
+ */
+.uk-light,
+.uk-section-primary:not(.uk-preserve-color),
+.uk-section-secondary:not(.uk-preserve-color),
+.uk-tile-primary:not(.uk-preserve-color),
+.uk-tile-secondary:not(.uk-preserve-color),
+.uk-card-primary.uk-card-body,
+.uk-card-primary > :not([class*="uk-card-media"]),
+.uk-card-secondary.uk-card-body,
+.uk-card-secondary > :not([class*="uk-card-media"]),
+.uk-overlay-primary,
+.uk-offcanvas-bar {
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-light a,
+.uk-light .uk-link,
+.uk-section-primary:not(.uk-preserve-color) a,
+.uk-section-primary:not(.uk-preserve-color) .uk-link,
+.uk-section-secondary:not(.uk-preserve-color) a,
+.uk-section-secondary:not(.uk-preserve-color) .uk-link,
+.uk-tile-primary:not(.uk-preserve-color) a,
+.uk-tile-primary:not(.uk-preserve-color) .uk-link,
+.uk-tile-secondary:not(.uk-preserve-color) a,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-link,
+.uk-card-primary.uk-card-body a,
+.uk-card-primary.uk-card-body .uk-link,
+.uk-card-primary > :not([class*="uk-card-media"]) a,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-link,
+.uk-card-secondary.uk-card-body a,
+.uk-card-secondary.uk-card-body .uk-link,
+.uk-card-secondary > :not([class*="uk-card-media"]) a,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-link,
+.uk-overlay-primary a,
+.uk-overlay-primary .uk-link,
+.uk-offcanvas-bar a,
+.uk-offcanvas-bar .uk-link {
+  color: #fff;
+}
+.uk-light a:hover,
+.uk-light .uk-link:hover,
+.uk-light .uk-link-toggle:hover .uk-link,
+.uk-section-primary:not(.uk-preserve-color) a:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-link:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-link-toggle:hover .uk-link,
+.uk-section-secondary:not(.uk-preserve-color) a:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-link:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-link-toggle:hover .uk-link,
+.uk-tile-primary:not(.uk-preserve-color) a:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-link:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-link-toggle:hover .uk-link,
+.uk-tile-secondary:not(.uk-preserve-color) a:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-link:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-link-toggle:hover .uk-link,
+.uk-card-primary.uk-card-body a:hover,
+.uk-card-primary.uk-card-body .uk-link:hover,
+.uk-card-primary.uk-card-body .uk-link-toggle:hover .uk-link,
+.uk-card-primary > :not([class*="uk-card-media"]) a:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-link:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-link-toggle:hover .uk-link,
+.uk-card-secondary.uk-card-body a:hover,
+.uk-card-secondary.uk-card-body .uk-link:hover,
+.uk-card-secondary.uk-card-body .uk-link-toggle:hover .uk-link,
+.uk-card-secondary > :not([class*="uk-card-media"]) a:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-link:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-link-toggle:hover .uk-link,
+.uk-overlay-primary a:hover,
+.uk-overlay-primary .uk-link:hover,
+.uk-overlay-primary .uk-link-toggle:hover .uk-link,
+.uk-offcanvas-bar a:hover,
+.uk-offcanvas-bar .uk-link:hover,
+.uk-offcanvas-bar .uk-link-toggle:hover .uk-link {
+  color: #fff;
+}
+.uk-light :not(pre) > code,
+.uk-light :not(pre) > kbd,
+.uk-light :not(pre) > samp,
+.uk-section-primary:not(.uk-preserve-color) :not(pre) > code,
+.uk-section-primary:not(.uk-preserve-color) :not(pre) > kbd,
+.uk-section-primary:not(.uk-preserve-color) :not(pre) > samp,
+.uk-section-secondary:not(.uk-preserve-color) :not(pre) > code,
+.uk-section-secondary:not(.uk-preserve-color) :not(pre) > kbd,
+.uk-section-secondary:not(.uk-preserve-color) :not(pre) > samp,
+.uk-tile-primary:not(.uk-preserve-color) :not(pre) > code,
+.uk-tile-primary:not(.uk-preserve-color) :not(pre) > kbd,
+.uk-tile-primary:not(.uk-preserve-color) :not(pre) > samp,
+.uk-tile-secondary:not(.uk-preserve-color) :not(pre) > code,
+.uk-tile-secondary:not(.uk-preserve-color) :not(pre) > kbd,
+.uk-tile-secondary:not(.uk-preserve-color) :not(pre) > samp,
+.uk-card-primary.uk-card-body :not(pre) > code,
+.uk-card-primary.uk-card-body :not(pre) > kbd,
+.uk-card-primary.uk-card-body :not(pre) > samp,
+.uk-card-primary > :not([class*="uk-card-media"]) :not(pre) > code,
+.uk-card-primary > :not([class*="uk-card-media"]) :not(pre) > kbd,
+.uk-card-primary > :not([class*="uk-card-media"]) :not(pre) > samp,
+.uk-card-secondary.uk-card-body :not(pre) > code,
+.uk-card-secondary.uk-card-body :not(pre) > kbd,
+.uk-card-secondary.uk-card-body :not(pre) > samp,
+.uk-card-secondary > :not([class*="uk-card-media"]) :not(pre) > code,
+.uk-card-secondary > :not([class*="uk-card-media"]) :not(pre) > kbd,
+.uk-card-secondary > :not([class*="uk-card-media"]) :not(pre) > samp,
+.uk-overlay-primary :not(pre) > code,
+.uk-overlay-primary :not(pre) > kbd,
+.uk-overlay-primary :not(pre) > samp,
+.uk-offcanvas-bar :not(pre) > code,
+.uk-offcanvas-bar :not(pre) > kbd,
+.uk-offcanvas-bar :not(pre) > samp {
+  color: rgba(255, 255, 255, 0.7);
+  background-color: rgba(255, 255, 255, 0.1);
+}
+.uk-light em,
+.uk-section-primary:not(.uk-preserve-color) em,
+.uk-section-secondary:not(.uk-preserve-color) em,
+.uk-tile-primary:not(.uk-preserve-color) em,
+.uk-tile-secondary:not(.uk-preserve-color) em,
+.uk-card-primary.uk-card-body em,
+.uk-card-primary > :not([class*="uk-card-media"]) em,
+.uk-card-secondary.uk-card-body em,
+.uk-card-secondary > :not([class*="uk-card-media"]) em,
+.uk-overlay-primary em,
+.uk-offcanvas-bar em {
+  color: #fff;
+}
+.uk-light h1,
+.uk-light .uk-h1,
+.uk-light h2,
+.uk-light .uk-h2,
+.uk-light h3,
+.uk-light .uk-h3,
+.uk-light h4,
+.uk-light .uk-h4,
+.uk-light h5,
+.uk-light .uk-h5,
+.uk-light h6,
+.uk-light .uk-h6,
+.uk-light .uk-heading-small,
+.uk-light .uk-heading-medium,
+.uk-light .uk-heading-large,
+.uk-light .uk-heading-xlarge,
+.uk-light .uk-heading-2xlarge,
+.uk-light .uk-heading-3xlarge,
+.uk-section-primary:not(.uk-preserve-color) h1,
+.uk-section-primary:not(.uk-preserve-color) .uk-h1,
+.uk-section-primary:not(.uk-preserve-color) h2,
+.uk-section-primary:not(.uk-preserve-color) .uk-h2,
+.uk-section-primary:not(.uk-preserve-color) h3,
+.uk-section-primary:not(.uk-preserve-color) .uk-h3,
+.uk-section-primary:not(.uk-preserve-color) h4,
+.uk-section-primary:not(.uk-preserve-color) .uk-h4,
+.uk-section-primary:not(.uk-preserve-color) h5,
+.uk-section-primary:not(.uk-preserve-color) .uk-h5,
+.uk-section-primary:not(.uk-preserve-color) h6,
+.uk-section-primary:not(.uk-preserve-color) .uk-h6,
+.uk-section-primary:not(.uk-preserve-color) .uk-heading-small,
+.uk-section-primary:not(.uk-preserve-color) .uk-heading-medium,
+.uk-section-primary:not(.uk-preserve-color) .uk-heading-large,
+.uk-section-primary:not(.uk-preserve-color) .uk-heading-xlarge,
+.uk-section-primary:not(.uk-preserve-color) .uk-heading-2xlarge,
+.uk-section-primary:not(.uk-preserve-color) .uk-heading-3xlarge,
+.uk-section-secondary:not(.uk-preserve-color) h1,
+.uk-section-secondary:not(.uk-preserve-color) .uk-h1,
+.uk-section-secondary:not(.uk-preserve-color) h2,
+.uk-section-secondary:not(.uk-preserve-color) .uk-h2,
+.uk-section-secondary:not(.uk-preserve-color) h3,
+.uk-section-secondary:not(.uk-preserve-color) .uk-h3,
+.uk-section-secondary:not(.uk-preserve-color) h4,
+.uk-section-secondary:not(.uk-preserve-color) .uk-h4,
+.uk-section-secondary:not(.uk-preserve-color) h5,
+.uk-section-secondary:not(.uk-preserve-color) .uk-h5,
+.uk-section-secondary:not(.uk-preserve-color) h6,
+.uk-section-secondary:not(.uk-preserve-color) .uk-h6,
+.uk-section-secondary:not(.uk-preserve-color) .uk-heading-small,
+.uk-section-secondary:not(.uk-preserve-color) .uk-heading-medium,
+.uk-section-secondary:not(.uk-preserve-color) .uk-heading-large,
+.uk-section-secondary:not(.uk-preserve-color) .uk-heading-xlarge,
+.uk-section-secondary:not(.uk-preserve-color) .uk-heading-2xlarge,
+.uk-section-secondary:not(.uk-preserve-color) .uk-heading-3xlarge,
+.uk-tile-primary:not(.uk-preserve-color) h1,
+.uk-tile-primary:not(.uk-preserve-color) .uk-h1,
+.uk-tile-primary:not(.uk-preserve-color) h2,
+.uk-tile-primary:not(.uk-preserve-color) .uk-h2,
+.uk-tile-primary:not(.uk-preserve-color) h3,
+.uk-tile-primary:not(.uk-preserve-color) .uk-h3,
+.uk-tile-primary:not(.uk-preserve-color) h4,
+.uk-tile-primary:not(.uk-preserve-color) .uk-h4,
+.uk-tile-primary:not(.uk-preserve-color) h5,
+.uk-tile-primary:not(.uk-preserve-color) .uk-h5,
+.uk-tile-primary:not(.uk-preserve-color) h6,
+.uk-tile-primary:not(.uk-preserve-color) .uk-h6,
+.uk-tile-primary:not(.uk-preserve-color) .uk-heading-small,
+.uk-tile-primary:not(.uk-preserve-color) .uk-heading-medium,
+.uk-tile-primary:not(.uk-preserve-color) .uk-heading-large,
+.uk-tile-primary:not(.uk-preserve-color) .uk-heading-xlarge,
+.uk-tile-primary:not(.uk-preserve-color) .uk-heading-2xlarge,
+.uk-tile-primary:not(.uk-preserve-color) .uk-heading-3xlarge,
+.uk-tile-secondary:not(.uk-preserve-color) h1,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-h1,
+.uk-tile-secondary:not(.uk-preserve-color) h2,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-h2,
+.uk-tile-secondary:not(.uk-preserve-color) h3,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-h3,
+.uk-tile-secondary:not(.uk-preserve-color) h4,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-h4,
+.uk-tile-secondary:not(.uk-preserve-color) h5,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-h5,
+.uk-tile-secondary:not(.uk-preserve-color) h6,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-h6,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-heading-small,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-heading-medium,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-heading-large,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-heading-xlarge,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-heading-2xlarge,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-heading-3xlarge,
+.uk-card-primary.uk-card-body h1,
+.uk-card-primary.uk-card-body .uk-h1,
+.uk-card-primary.uk-card-body h2,
+.uk-card-primary.uk-card-body .uk-h2,
+.uk-card-primary.uk-card-body h3,
+.uk-card-primary.uk-card-body .uk-h3,
+.uk-card-primary.uk-card-body h4,
+.uk-card-primary.uk-card-body .uk-h4,
+.uk-card-primary.uk-card-body h5,
+.uk-card-primary.uk-card-body .uk-h5,
+.uk-card-primary.uk-card-body h6,
+.uk-card-primary.uk-card-body .uk-h6,
+.uk-card-primary.uk-card-body .uk-heading-small,
+.uk-card-primary.uk-card-body .uk-heading-medium,
+.uk-card-primary.uk-card-body .uk-heading-large,
+.uk-card-primary.uk-card-body .uk-heading-xlarge,
+.uk-card-primary.uk-card-body .uk-heading-2xlarge,
+.uk-card-primary.uk-card-body .uk-heading-3xlarge,
+.uk-card-primary > :not([class*="uk-card-media"]) h1,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-h1,
+.uk-card-primary > :not([class*="uk-card-media"]) h2,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-h2,
+.uk-card-primary > :not([class*="uk-card-media"]) h3,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-h3,
+.uk-card-primary > :not([class*="uk-card-media"]) h4,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-h4,
+.uk-card-primary > :not([class*="uk-card-media"]) h5,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-h5,
+.uk-card-primary > :not([class*="uk-card-media"]) h6,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-h6,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-heading-small,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-heading-medium,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-heading-large,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-heading-xlarge,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-heading-2xlarge,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-heading-3xlarge,
+.uk-card-secondary.uk-card-body h1,
+.uk-card-secondary.uk-card-body .uk-h1,
+.uk-card-secondary.uk-card-body h2,
+.uk-card-secondary.uk-card-body .uk-h2,
+.uk-card-secondary.uk-card-body h3,
+.uk-card-secondary.uk-card-body .uk-h3,
+.uk-card-secondary.uk-card-body h4,
+.uk-card-secondary.uk-card-body .uk-h4,
+.uk-card-secondary.uk-card-body h5,
+.uk-card-secondary.uk-card-body .uk-h5,
+.uk-card-secondary.uk-card-body h6,
+.uk-card-secondary.uk-card-body .uk-h6,
+.uk-card-secondary.uk-card-body .uk-heading-small,
+.uk-card-secondary.uk-card-body .uk-heading-medium,
+.uk-card-secondary.uk-card-body .uk-heading-large,
+.uk-card-secondary.uk-card-body .uk-heading-xlarge,
+.uk-card-secondary.uk-card-body .uk-heading-2xlarge,
+.uk-card-secondary.uk-card-body .uk-heading-3xlarge,
+.uk-card-secondary > :not([class*="uk-card-media"]) h1,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-h1,
+.uk-card-secondary > :not([class*="uk-card-media"]) h2,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-h2,
+.uk-card-secondary > :not([class*="uk-card-media"]) h3,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-h3,
+.uk-card-secondary > :not([class*="uk-card-media"]) h4,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-h4,
+.uk-card-secondary > :not([class*="uk-card-media"]) h5,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-h5,
+.uk-card-secondary > :not([class*="uk-card-media"]) h6,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-h6,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-heading-small,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-heading-medium,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-heading-large,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-heading-xlarge,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-heading-2xlarge,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-heading-3xlarge,
+.uk-overlay-primary h1,
+.uk-overlay-primary .uk-h1,
+.uk-overlay-primary h2,
+.uk-overlay-primary .uk-h2,
+.uk-overlay-primary h3,
+.uk-overlay-primary .uk-h3,
+.uk-overlay-primary h4,
+.uk-overlay-primary .uk-h4,
+.uk-overlay-primary h5,
+.uk-overlay-primary .uk-h5,
+.uk-overlay-primary h6,
+.uk-overlay-primary .uk-h6,
+.uk-overlay-primary .uk-heading-small,
+.uk-overlay-primary .uk-heading-medium,
+.uk-overlay-primary .uk-heading-large,
+.uk-overlay-primary .uk-heading-xlarge,
+.uk-overlay-primary .uk-heading-2xlarge,
+.uk-overlay-primary .uk-heading-3xlarge,
+.uk-offcanvas-bar h1,
+.uk-offcanvas-bar .uk-h1,
+.uk-offcanvas-bar h2,
+.uk-offcanvas-bar .uk-h2,
+.uk-offcanvas-bar h3,
+.uk-offcanvas-bar .uk-h3,
+.uk-offcanvas-bar h4,
+.uk-offcanvas-bar .uk-h4,
+.uk-offcanvas-bar h5,
+.uk-offcanvas-bar .uk-h5,
+.uk-offcanvas-bar h6,
+.uk-offcanvas-bar .uk-h6,
+.uk-offcanvas-bar .uk-heading-small,
+.uk-offcanvas-bar .uk-heading-medium,
+.uk-offcanvas-bar .uk-heading-large,
+.uk-offcanvas-bar .uk-heading-xlarge,
+.uk-offcanvas-bar .uk-heading-2xlarge,
+.uk-offcanvas-bar .uk-heading-3xlarge {
+  color: #fff;
+}
+.uk-light blockquote,
+.uk-section-primary:not(.uk-preserve-color) blockquote,
+.uk-section-secondary:not(.uk-preserve-color) blockquote,
+.uk-tile-primary:not(.uk-preserve-color) blockquote,
+.uk-tile-secondary:not(.uk-preserve-color) blockquote,
+.uk-card-primary.uk-card-body blockquote,
+.uk-card-primary > :not([class*="uk-card-media"]) blockquote,
+.uk-card-secondary.uk-card-body blockquote,
+.uk-card-secondary > :not([class*="uk-card-media"]) blockquote,
+.uk-overlay-primary blockquote,
+.uk-offcanvas-bar blockquote {
+  color: #fff;
+}
+.uk-light blockquote footer,
+.uk-section-primary:not(.uk-preserve-color) blockquote footer,
+.uk-section-secondary:not(.uk-preserve-color) blockquote footer,
+.uk-tile-primary:not(.uk-preserve-color) blockquote footer,
+.uk-tile-secondary:not(.uk-preserve-color) blockquote footer,
+.uk-card-primary.uk-card-body blockquote footer,
+.uk-card-primary > :not([class*="uk-card-media"]) blockquote footer,
+.uk-card-secondary.uk-card-body blockquote footer,
+.uk-card-secondary > :not([class*="uk-card-media"]) blockquote footer,
+.uk-overlay-primary blockquote footer,
+.uk-offcanvas-bar blockquote footer {
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-light hr,
+.uk-light .uk-hr,
+.uk-section-primary:not(.uk-preserve-color) hr,
+.uk-section-primary:not(.uk-preserve-color) .uk-hr,
+.uk-section-secondary:not(.uk-preserve-color) hr,
+.uk-section-secondary:not(.uk-preserve-color) .uk-hr,
+.uk-tile-primary:not(.uk-preserve-color) hr,
+.uk-tile-primary:not(.uk-preserve-color) .uk-hr,
+.uk-tile-secondary:not(.uk-preserve-color) hr,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-hr,
+.uk-card-primary.uk-card-body hr,
+.uk-card-primary.uk-card-body .uk-hr,
+.uk-card-primary > :not([class*="uk-card-media"]) hr,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-hr,
+.uk-card-secondary.uk-card-body hr,
+.uk-card-secondary.uk-card-body .uk-hr,
+.uk-card-secondary > :not([class*="uk-card-media"]) hr,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-hr,
+.uk-overlay-primary hr,
+.uk-overlay-primary .uk-hr,
+.uk-offcanvas-bar hr,
+.uk-offcanvas-bar .uk-hr {
+  border-top-color: rgba(255, 255, 255, 0.2);
+}
+.uk-light :focus-visible,
+.uk-section-primary:not(.uk-preserve-color) :focus-visible,
+.uk-section-secondary:not(.uk-preserve-color) :focus-visible,
+.uk-tile-primary:not(.uk-preserve-color) :focus-visible,
+.uk-tile-secondary:not(.uk-preserve-color) :focus-visible,
+.uk-card-primary.uk-card-body :focus-visible,
+.uk-card-primary > :not([class*="uk-card-media"]) :focus-visible,
+.uk-card-secondary.uk-card-body :focus-visible,
+.uk-card-secondary > :not([class*="uk-card-media"]) :focus-visible,
+.uk-overlay-primary :focus-visible,
+.uk-offcanvas-bar :focus-visible {
+  outline-color: #fff;
+}
+.uk-light a.uk-link-muted,
+.uk-light .uk-link-muted a,
+.uk-section-primary:not(.uk-preserve-color) a.uk-link-muted,
+.uk-section-primary:not(.uk-preserve-color) .uk-link-muted a,
+.uk-section-secondary:not(.uk-preserve-color) a.uk-link-muted,
+.uk-section-secondary:not(.uk-preserve-color) .uk-link-muted a,
+.uk-tile-primary:not(.uk-preserve-color) a.uk-link-muted,
+.uk-tile-primary:not(.uk-preserve-color) .uk-link-muted a,
+.uk-tile-secondary:not(.uk-preserve-color) a.uk-link-muted,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-link-muted a,
+.uk-card-primary.uk-card-body a.uk-link-muted,
+.uk-card-primary.uk-card-body .uk-link-muted a,
+.uk-card-primary > :not([class*="uk-card-media"]) a.uk-link-muted,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-link-muted a,
+.uk-card-secondary.uk-card-body a.uk-link-muted,
+.uk-card-secondary.uk-card-body .uk-link-muted a,
+.uk-card-secondary > :not([class*="uk-card-media"]) a.uk-link-muted,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-link-muted a,
+.uk-overlay-primary a.uk-link-muted,
+.uk-overlay-primary .uk-link-muted a,
+.uk-offcanvas-bar a.uk-link-muted,
+.uk-offcanvas-bar .uk-link-muted a {
+  color: rgba(255, 255, 255, 0.5);
+}
+.uk-light a.uk-link-muted:hover,
+.uk-light .uk-link-muted a:hover,
+.uk-light .uk-link-toggle:hover .uk-link-muted,
+.uk-section-primary:not(.uk-preserve-color) a.uk-link-muted:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-link-muted a:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-link-toggle:hover .uk-link-muted,
+.uk-section-secondary:not(.uk-preserve-color) a.uk-link-muted:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-link-muted a:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-link-toggle:hover .uk-link-muted,
+.uk-tile-primary:not(.uk-preserve-color) a.uk-link-muted:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-link-muted a:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-link-toggle:hover .uk-link-muted,
+.uk-tile-secondary:not(.uk-preserve-color) a.uk-link-muted:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-link-muted a:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-link-toggle:hover .uk-link-muted,
+.uk-card-primary.uk-card-body a.uk-link-muted:hover,
+.uk-card-primary.uk-card-body .uk-link-muted a:hover,
+.uk-card-primary.uk-card-body .uk-link-toggle:hover .uk-link-muted,
+.uk-card-primary > :not([class*="uk-card-media"]) a.uk-link-muted:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-link-muted a:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-link-toggle:hover .uk-link-muted,
+.uk-card-secondary.uk-card-body a.uk-link-muted:hover,
+.uk-card-secondary.uk-card-body .uk-link-muted a:hover,
+.uk-card-secondary.uk-card-body .uk-link-toggle:hover .uk-link-muted,
+.uk-card-secondary > :not([class*="uk-card-media"]) a.uk-link-muted:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-link-muted a:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-link-toggle:hover .uk-link-muted,
+.uk-overlay-primary a.uk-link-muted:hover,
+.uk-overlay-primary .uk-link-muted a:hover,
+.uk-overlay-primary .uk-link-toggle:hover .uk-link-muted,
+.uk-offcanvas-bar a.uk-link-muted:hover,
+.uk-offcanvas-bar .uk-link-muted a:hover,
+.uk-offcanvas-bar .uk-link-toggle:hover .uk-link-muted {
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-light a.uk-link-text:hover,
+.uk-light .uk-link-text a:hover,
+.uk-light .uk-link-toggle:hover .uk-link-text,
+.uk-section-primary:not(.uk-preserve-color) a.uk-link-text:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-link-text a:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-link-toggle:hover .uk-link-text,
+.uk-section-secondary:not(.uk-preserve-color) a.uk-link-text:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-link-text a:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-link-toggle:hover .uk-link-text,
+.uk-tile-primary:not(.uk-preserve-color) a.uk-link-text:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-link-text a:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-link-toggle:hover .uk-link-text,
+.uk-tile-secondary:not(.uk-preserve-color) a.uk-link-text:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-link-text a:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-link-toggle:hover .uk-link-text,
+.uk-card-primary.uk-card-body a.uk-link-text:hover,
+.uk-card-primary.uk-card-body .uk-link-text a:hover,
+.uk-card-primary.uk-card-body .uk-link-toggle:hover .uk-link-text,
+.uk-card-primary > :not([class*="uk-card-media"]) a.uk-link-text:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-link-text a:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-link-toggle:hover .uk-link-text,
+.uk-card-secondary.uk-card-body a.uk-link-text:hover,
+.uk-card-secondary.uk-card-body .uk-link-text a:hover,
+.uk-card-secondary.uk-card-body .uk-link-toggle:hover .uk-link-text,
+.uk-card-secondary > :not([class*="uk-card-media"]) a.uk-link-text:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-link-text a:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-link-toggle:hover .uk-link-text,
+.uk-overlay-primary a.uk-link-text:hover,
+.uk-overlay-primary .uk-link-text a:hover,
+.uk-overlay-primary .uk-link-toggle:hover .uk-link-text,
+.uk-offcanvas-bar a.uk-link-text:hover,
+.uk-offcanvas-bar .uk-link-text a:hover,
+.uk-offcanvas-bar .uk-link-toggle:hover .uk-link-text {
+  color: rgba(255, 255, 255, 0.5);
+}
+.uk-light a.uk-link-heading:hover,
+.uk-light .uk-link-heading a:hover,
+.uk-light .uk-link-toggle:hover .uk-link-heading,
+.uk-section-primary:not(.uk-preserve-color) a.uk-link-heading:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-link-heading a:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-link-toggle:hover .uk-link-heading,
+.uk-section-secondary:not(.uk-preserve-color) a.uk-link-heading:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-link-heading a:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-link-toggle:hover .uk-link-heading,
+.uk-tile-primary:not(.uk-preserve-color) a.uk-link-heading:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-link-heading a:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-link-toggle:hover .uk-link-heading,
+.uk-tile-secondary:not(.uk-preserve-color) a.uk-link-heading:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-link-heading a:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-link-toggle:hover .uk-link-heading,
+.uk-card-primary.uk-card-body a.uk-link-heading:hover,
+.uk-card-primary.uk-card-body .uk-link-heading a:hover,
+.uk-card-primary.uk-card-body .uk-link-toggle:hover .uk-link-heading,
+.uk-card-primary > :not([class*="uk-card-media"]) a.uk-link-heading:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-link-heading a:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-link-toggle:hover .uk-link-heading,
+.uk-card-secondary.uk-card-body a.uk-link-heading:hover,
+.uk-card-secondary.uk-card-body .uk-link-heading a:hover,
+.uk-card-secondary.uk-card-body .uk-link-toggle:hover .uk-link-heading,
+.uk-card-secondary > :not([class*="uk-card-media"]) a.uk-link-heading:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-link-heading a:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-link-toggle:hover .uk-link-heading,
+.uk-overlay-primary a.uk-link-heading:hover,
+.uk-overlay-primary .uk-link-heading a:hover,
+.uk-overlay-primary .uk-link-toggle:hover .uk-link-heading,
+.uk-offcanvas-bar a.uk-link-heading:hover,
+.uk-offcanvas-bar .uk-link-heading a:hover,
+.uk-offcanvas-bar .uk-link-toggle:hover .uk-link-heading {
+  color: #fff;
+}
+.uk-light .uk-heading-divider,
+.uk-section-primary:not(.uk-preserve-color) .uk-heading-divider,
+.uk-section-secondary:not(.uk-preserve-color) .uk-heading-divider,
+.uk-tile-primary:not(.uk-preserve-color) .uk-heading-divider,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-heading-divider,
+.uk-card-primary.uk-card-body .uk-heading-divider,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-heading-divider,
+.uk-card-secondary.uk-card-body .uk-heading-divider,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-heading-divider,
+.uk-overlay-primary .uk-heading-divider,
+.uk-offcanvas-bar .uk-heading-divider {
+  border-bottom-color: rgba(255, 255, 255, 0.2);
+}
+.uk-light .uk-heading-bullet::before,
+.uk-section-primary:not(.uk-preserve-color) .uk-heading-bullet::before,
+.uk-section-secondary:not(.uk-preserve-color) .uk-heading-bullet::before,
+.uk-tile-primary:not(.uk-preserve-color) .uk-heading-bullet::before,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-heading-bullet::before,
+.uk-card-primary.uk-card-body .uk-heading-bullet::before,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-heading-bullet::before,
+.uk-card-secondary.uk-card-body .uk-heading-bullet::before,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-heading-bullet::before,
+.uk-overlay-primary .uk-heading-bullet::before,
+.uk-offcanvas-bar .uk-heading-bullet::before {
+  border-left-color: rgba(255, 255, 255, 0.2);
+}
+.uk-light .uk-heading-line > ::before,
+.uk-light .uk-heading-line > ::after,
+.uk-section-primary:not(.uk-preserve-color) .uk-heading-line > ::before,
+.uk-section-primary:not(.uk-preserve-color) .uk-heading-line > ::after,
+.uk-section-secondary:not(.uk-preserve-color) .uk-heading-line > ::before,
+.uk-section-secondary:not(.uk-preserve-color) .uk-heading-line > ::after,
+.uk-tile-primary:not(.uk-preserve-color) .uk-heading-line > ::before,
+.uk-tile-primary:not(.uk-preserve-color) .uk-heading-line > ::after,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-heading-line > ::before,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-heading-line > ::after,
+.uk-card-primary.uk-card-body .uk-heading-line > ::before,
+.uk-card-primary.uk-card-body .uk-heading-line > ::after,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-heading-line > ::before,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-heading-line > ::after,
+.uk-card-secondary.uk-card-body .uk-heading-line > ::before,
+.uk-card-secondary.uk-card-body .uk-heading-line > ::after,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-heading-line > ::before,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-heading-line > ::after,
+.uk-overlay-primary .uk-heading-line > ::before,
+.uk-overlay-primary .uk-heading-line > ::after,
+.uk-offcanvas-bar .uk-heading-line > ::before,
+.uk-offcanvas-bar .uk-heading-line > ::after {
+  border-bottom-color: rgba(255, 255, 255, 0.2);
+}
+.uk-light .uk-divider-icon,
+.uk-section-primary:not(.uk-preserve-color) .uk-divider-icon,
+.uk-section-secondary:not(.uk-preserve-color) .uk-divider-icon,
+.uk-tile-primary:not(.uk-preserve-color) .uk-divider-icon,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-divider-icon,
+.uk-card-primary.uk-card-body .uk-divider-icon,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-divider-icon,
+.uk-card-secondary.uk-card-body .uk-divider-icon,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-divider-icon,
+.uk-overlay-primary .uk-divider-icon,
+.uk-offcanvas-bar .uk-divider-icon {
+  background-image: url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2220%22%20height%3D%2220%22%20viewBox%3D%220%200%2020%2020%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Ccircle%20fill%3D%22none%22%20stroke%3D%22rgba%28255,%20255,%20255,%200.2%29%22%20stroke-width%3D%222%22%20cx%3D%2210%22%20cy%3D%2210%22%20r%3D%227%22%20%2F%3E%0A%3C%2Fsvg%3E%0A");
+}
+.uk-light .uk-divider-icon::before,
+.uk-light .uk-divider-icon::after,
+.uk-section-primary:not(.uk-preserve-color) .uk-divider-icon::before,
+.uk-section-primary:not(.uk-preserve-color) .uk-divider-icon::after,
+.uk-section-secondary:not(.uk-preserve-color) .uk-divider-icon::before,
+.uk-section-secondary:not(.uk-preserve-color) .uk-divider-icon::after,
+.uk-tile-primary:not(.uk-preserve-color) .uk-divider-icon::before,
+.uk-tile-primary:not(.uk-preserve-color) .uk-divider-icon::after,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-divider-icon::before,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-divider-icon::after,
+.uk-card-primary.uk-card-body .uk-divider-icon::before,
+.uk-card-primary.uk-card-body .uk-divider-icon::after,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-divider-icon::before,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-divider-icon::after,
+.uk-card-secondary.uk-card-body .uk-divider-icon::before,
+.uk-card-secondary.uk-card-body .uk-divider-icon::after,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-divider-icon::before,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-divider-icon::after,
+.uk-overlay-primary .uk-divider-icon::before,
+.uk-overlay-primary .uk-divider-icon::after,
+.uk-offcanvas-bar .uk-divider-icon::before,
+.uk-offcanvas-bar .uk-divider-icon::after {
+  border-bottom-color: rgba(255, 255, 255, 0.2);
+}
+.uk-light .uk-divider-small::after,
+.uk-section-primary:not(.uk-preserve-color) .uk-divider-small::after,
+.uk-section-secondary:not(.uk-preserve-color) .uk-divider-small::after,
+.uk-tile-primary:not(.uk-preserve-color) .uk-divider-small::after,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-divider-small::after,
+.uk-card-primary.uk-card-body .uk-divider-small::after,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-divider-small::after,
+.uk-card-secondary.uk-card-body .uk-divider-small::after,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-divider-small::after,
+.uk-overlay-primary .uk-divider-small::after,
+.uk-offcanvas-bar .uk-divider-small::after {
+  border-top-color: rgba(255, 255, 255, 0.2);
+}
+.uk-light .uk-divider-vertical,
+.uk-section-primary:not(.uk-preserve-color) .uk-divider-vertical,
+.uk-section-secondary:not(.uk-preserve-color) .uk-divider-vertical,
+.uk-tile-primary:not(.uk-preserve-color) .uk-divider-vertical,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-divider-vertical,
+.uk-card-primary.uk-card-body .uk-divider-vertical,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-divider-vertical,
+.uk-card-secondary.uk-card-body .uk-divider-vertical,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-divider-vertical,
+.uk-overlay-primary .uk-divider-vertical,
+.uk-offcanvas-bar .uk-divider-vertical {
+  border-left-color: rgba(255, 255, 255, 0.2);
+}
+.uk-light .uk-list-muted > ::before,
+.uk-section-primary:not(.uk-preserve-color) .uk-list-muted > ::before,
+.uk-section-secondary:not(.uk-preserve-color) .uk-list-muted > ::before,
+.uk-tile-primary:not(.uk-preserve-color) .uk-list-muted > ::before,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-list-muted > ::before,
+.uk-card-primary.uk-card-body .uk-list-muted > ::before,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-list-muted > ::before,
+.uk-card-secondary.uk-card-body .uk-list-muted > ::before,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-list-muted > ::before,
+.uk-overlay-primary .uk-list-muted > ::before,
+.uk-offcanvas-bar .uk-list-muted > ::before {
+  color: rgba(255, 255, 255, 0.5) !important;
+}
+.uk-light .uk-list-emphasis > ::before,
+.uk-section-primary:not(.uk-preserve-color) .uk-list-emphasis > ::before,
+.uk-section-secondary:not(.uk-preserve-color) .uk-list-emphasis > ::before,
+.uk-tile-primary:not(.uk-preserve-color) .uk-list-emphasis > ::before,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-list-emphasis > ::before,
+.uk-card-primary.uk-card-body .uk-list-emphasis > ::before,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-list-emphasis > ::before,
+.uk-card-secondary.uk-card-body .uk-list-emphasis > ::before,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-list-emphasis > ::before,
+.uk-overlay-primary .uk-list-emphasis > ::before,
+.uk-offcanvas-bar .uk-list-emphasis > ::before {
+  color: #fff !important;
+}
+.uk-light .uk-list-primary > ::before,
+.uk-section-primary:not(.uk-preserve-color) .uk-list-primary > ::before,
+.uk-section-secondary:not(.uk-preserve-color) .uk-list-primary > ::before,
+.uk-tile-primary:not(.uk-preserve-color) .uk-list-primary > ::before,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-list-primary > ::before,
+.uk-card-primary.uk-card-body .uk-list-primary > ::before,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-list-primary > ::before,
+.uk-card-secondary.uk-card-body .uk-list-primary > ::before,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-list-primary > ::before,
+.uk-overlay-primary .uk-list-primary > ::before,
+.uk-offcanvas-bar .uk-list-primary > ::before {
+  color: #fff !important;
+}
+.uk-light .uk-list-secondary > ::before,
+.uk-section-primary:not(.uk-preserve-color) .uk-list-secondary > ::before,
+.uk-section-secondary:not(.uk-preserve-color) .uk-list-secondary > ::before,
+.uk-tile-primary:not(.uk-preserve-color) .uk-list-secondary > ::before,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-list-secondary > ::before,
+.uk-card-primary.uk-card-body .uk-list-secondary > ::before,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-list-secondary > ::before,
+.uk-card-secondary.uk-card-body .uk-list-secondary > ::before,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-list-secondary > ::before,
+.uk-overlay-primary .uk-list-secondary > ::before,
+.uk-offcanvas-bar .uk-list-secondary > ::before {
+  color: #fff !important;
+}
+.uk-light .uk-list-bullet > ::before,
+.uk-section-primary:not(.uk-preserve-color) .uk-list-bullet > ::before,
+.uk-section-secondary:not(.uk-preserve-color) .uk-list-bullet > ::before,
+.uk-tile-primary:not(.uk-preserve-color) .uk-list-bullet > ::before,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-list-bullet > ::before,
+.uk-card-primary.uk-card-body .uk-list-bullet > ::before,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-list-bullet > ::before,
+.uk-card-secondary.uk-card-body .uk-list-bullet > ::before,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-list-bullet > ::before,
+.uk-overlay-primary .uk-list-bullet > ::before,
+.uk-offcanvas-bar .uk-list-bullet > ::before {
+  background-image: url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%226%22%20height%3D%226%22%20viewBox%3D%220%200%206%206%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Ccircle%20fill%3D%22rgba%28255,%20255,%20255,%200.7%29%22%20cx%3D%223%22%20cy%3D%223%22%20r%3D%223%22%20%2F%3E%0A%3C%2Fsvg%3E");
+}
+.uk-light .uk-list-divider > :nth-child(n+2),
+.uk-section-primary:not(.uk-preserve-color) .uk-list-divider > :nth-child(n+2),
+.uk-section-secondary:not(.uk-preserve-color) .uk-list-divider > :nth-child(n+2),
+.uk-tile-primary:not(.uk-preserve-color) .uk-list-divider > :nth-child(n+2),
+.uk-tile-secondary:not(.uk-preserve-color) .uk-list-divider > :nth-child(n+2),
+.uk-card-primary.uk-card-body .uk-list-divider > :nth-child(n+2),
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-list-divider > :nth-child(n+2),
+.uk-card-secondary.uk-card-body .uk-list-divider > :nth-child(n+2),
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-list-divider > :nth-child(n+2),
+.uk-overlay-primary .uk-list-divider > :nth-child(n+2),
+.uk-offcanvas-bar .uk-list-divider > :nth-child(n+2) {
+  border-top-color: rgba(255, 255, 255, 0.2);
+}
+.uk-light .uk-list-striped > *:nth-of-type(odd),
+.uk-section-primary:not(.uk-preserve-color) .uk-list-striped > *:nth-of-type(odd),
+.uk-section-secondary:not(.uk-preserve-color) .uk-list-striped > *:nth-of-type(odd),
+.uk-tile-primary:not(.uk-preserve-color) .uk-list-striped > *:nth-of-type(odd),
+.uk-tile-secondary:not(.uk-preserve-color) .uk-list-striped > *:nth-of-type(odd),
+.uk-card-primary.uk-card-body .uk-list-striped > *:nth-of-type(odd),
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-list-striped > *:nth-of-type(odd),
+.uk-card-secondary.uk-card-body .uk-list-striped > *:nth-of-type(odd),
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-list-striped > *:nth-of-type(odd),
+.uk-overlay-primary .uk-list-striped > *:nth-of-type(odd),
+.uk-offcanvas-bar .uk-list-striped > *:nth-of-type(odd) {
+  border-top-color: rgba(255, 255, 255, 0.2);
+  border-bottom-color: rgba(255, 255, 255, 0.2);
+}
+.uk-light .uk-list-striped > :nth-of-type(odd),
+.uk-section-primary:not(.uk-preserve-color) .uk-list-striped > :nth-of-type(odd),
+.uk-section-secondary:not(.uk-preserve-color) .uk-list-striped > :nth-of-type(odd),
+.uk-tile-primary:not(.uk-preserve-color) .uk-list-striped > :nth-of-type(odd),
+.uk-tile-secondary:not(.uk-preserve-color) .uk-list-striped > :nth-of-type(odd),
+.uk-card-primary.uk-card-body .uk-list-striped > :nth-of-type(odd),
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-list-striped > :nth-of-type(odd),
+.uk-card-secondary.uk-card-body .uk-list-striped > :nth-of-type(odd),
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-list-striped > :nth-of-type(odd),
+.uk-overlay-primary .uk-list-striped > :nth-of-type(odd),
+.uk-offcanvas-bar .uk-list-striped > :nth-of-type(odd) {
+  background-color: rgba(255, 255, 255, 0.1);
+}
+.uk-light .uk-table th,
+.uk-section-primary:not(.uk-preserve-color) .uk-table th,
+.uk-section-secondary:not(.uk-preserve-color) .uk-table th,
+.uk-tile-primary:not(.uk-preserve-color) .uk-table th,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-table th,
+.uk-card-primary.uk-card-body .uk-table th,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-table th,
+.uk-card-secondary.uk-card-body .uk-table th,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-table th,
+.uk-overlay-primary .uk-table th,
+.uk-offcanvas-bar .uk-table th {
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-light .uk-table caption,
+.uk-section-primary:not(.uk-preserve-color) .uk-table caption,
+.uk-section-secondary:not(.uk-preserve-color) .uk-table caption,
+.uk-tile-primary:not(.uk-preserve-color) .uk-table caption,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-table caption,
+.uk-card-primary.uk-card-body .uk-table caption,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-table caption,
+.uk-card-secondary.uk-card-body .uk-table caption,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-table caption,
+.uk-overlay-primary .uk-table caption,
+.uk-offcanvas-bar .uk-table caption {
+  color: rgba(255, 255, 255, 0.5);
+}
+.uk-light .uk-table > tr.uk-active,
+.uk-light .uk-table tbody tr.uk-active,
+.uk-section-primary:not(.uk-preserve-color) .uk-table > tr.uk-active,
+.uk-section-primary:not(.uk-preserve-color) .uk-table tbody tr.uk-active,
+.uk-section-secondary:not(.uk-preserve-color) .uk-table > tr.uk-active,
+.uk-section-secondary:not(.uk-preserve-color) .uk-table tbody tr.uk-active,
+.uk-tile-primary:not(.uk-preserve-color) .uk-table > tr.uk-active,
+.uk-tile-primary:not(.uk-preserve-color) .uk-table tbody tr.uk-active,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-table > tr.uk-active,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-table tbody tr.uk-active,
+.uk-card-primary.uk-card-body .uk-table > tr.uk-active,
+.uk-card-primary.uk-card-body .uk-table tbody tr.uk-active,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-table > tr.uk-active,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-table tbody tr.uk-active,
+.uk-card-secondary.uk-card-body .uk-table > tr.uk-active,
+.uk-card-secondary.uk-card-body .uk-table tbody tr.uk-active,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-table > tr.uk-active,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-table tbody tr.uk-active,
+.uk-overlay-primary .uk-table > tr.uk-active,
+.uk-overlay-primary .uk-table tbody tr.uk-active,
+.uk-offcanvas-bar .uk-table > tr.uk-active,
+.uk-offcanvas-bar .uk-table tbody tr.uk-active {
+  background: rgba(255, 255, 255, 0.08);
+}
+.uk-light .uk-table-divider > tr:not(:first-child),
+.uk-light .uk-table-divider > :not(:first-child) > tr,
+.uk-light .uk-table-divider > :first-child > tr:not(:first-child),
+.uk-section-primary:not(.uk-preserve-color) .uk-table-divider > tr:not(:first-child),
+.uk-section-primary:not(.uk-preserve-color) .uk-table-divider > :not(:first-child) > tr,
+.uk-section-primary:not(.uk-preserve-color) .uk-table-divider > :first-child > tr:not(:first-child),
+.uk-section-secondary:not(.uk-preserve-color) .uk-table-divider > tr:not(:first-child),
+.uk-section-secondary:not(.uk-preserve-color) .uk-table-divider > :not(:first-child) > tr,
+.uk-section-secondary:not(.uk-preserve-color) .uk-table-divider > :first-child > tr:not(:first-child),
+.uk-tile-primary:not(.uk-preserve-color) .uk-table-divider > tr:not(:first-child),
+.uk-tile-primary:not(.uk-preserve-color) .uk-table-divider > :not(:first-child) > tr,
+.uk-tile-primary:not(.uk-preserve-color) .uk-table-divider > :first-child > tr:not(:first-child),
+.uk-tile-secondary:not(.uk-preserve-color) .uk-table-divider > tr:not(:first-child),
+.uk-tile-secondary:not(.uk-preserve-color) .uk-table-divider > :not(:first-child) > tr,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-table-divider > :first-child > tr:not(:first-child),
+.uk-card-primary.uk-card-body .uk-table-divider > tr:not(:first-child),
+.uk-card-primary.uk-card-body .uk-table-divider > :not(:first-child) > tr,
+.uk-card-primary.uk-card-body .uk-table-divider > :first-child > tr:not(:first-child),
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-table-divider > tr:not(:first-child),
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-table-divider > :not(:first-child) > tr,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-table-divider > :first-child > tr:not(:first-child),
+.uk-card-secondary.uk-card-body .uk-table-divider > tr:not(:first-child),
+.uk-card-secondary.uk-card-body .uk-table-divider > :not(:first-child) > tr,
+.uk-card-secondary.uk-card-body .uk-table-divider > :first-child > tr:not(:first-child),
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-table-divider > tr:not(:first-child),
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-table-divider > :not(:first-child) > tr,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-table-divider > :first-child > tr:not(:first-child),
+.uk-overlay-primary .uk-table-divider > tr:not(:first-child),
+.uk-overlay-primary .uk-table-divider > :not(:first-child) > tr,
+.uk-overlay-primary .uk-table-divider > :first-child > tr:not(:first-child),
+.uk-offcanvas-bar .uk-table-divider > tr:not(:first-child),
+.uk-offcanvas-bar .uk-table-divider > :not(:first-child) > tr,
+.uk-offcanvas-bar .uk-table-divider > :first-child > tr:not(:first-child) {
+  border-top-color: rgba(255, 255, 255, 0.2);
+}
+.uk-light .uk-table-striped > tr:nth-of-type(odd),
+.uk-light .uk-table-striped tbody tr:nth-of-type(odd),
+.uk-section-primary:not(.uk-preserve-color) .uk-table-striped > tr:nth-of-type(odd),
+.uk-section-primary:not(.uk-preserve-color) .uk-table-striped tbody tr:nth-of-type(odd),
+.uk-section-secondary:not(.uk-preserve-color) .uk-table-striped > tr:nth-of-type(odd),
+.uk-section-secondary:not(.uk-preserve-color) .uk-table-striped tbody tr:nth-of-type(odd),
+.uk-tile-primary:not(.uk-preserve-color) .uk-table-striped > tr:nth-of-type(odd),
+.uk-tile-primary:not(.uk-preserve-color) .uk-table-striped tbody tr:nth-of-type(odd),
+.uk-tile-secondary:not(.uk-preserve-color) .uk-table-striped > tr:nth-of-type(odd),
+.uk-tile-secondary:not(.uk-preserve-color) .uk-table-striped tbody tr:nth-of-type(odd),
+.uk-card-primary.uk-card-body .uk-table-striped > tr:nth-of-type(odd),
+.uk-card-primary.uk-card-body .uk-table-striped tbody tr:nth-of-type(odd),
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-table-striped > tr:nth-of-type(odd),
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-table-striped tbody tr:nth-of-type(odd),
+.uk-card-secondary.uk-card-body .uk-table-striped > tr:nth-of-type(odd),
+.uk-card-secondary.uk-card-body .uk-table-striped tbody tr:nth-of-type(odd),
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-table-striped > tr:nth-of-type(odd),
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-table-striped tbody tr:nth-of-type(odd),
+.uk-overlay-primary .uk-table-striped > tr:nth-of-type(odd),
+.uk-overlay-primary .uk-table-striped tbody tr:nth-of-type(odd),
+.uk-offcanvas-bar .uk-table-striped > tr:nth-of-type(odd),
+.uk-offcanvas-bar .uk-table-striped tbody tr:nth-of-type(odd) {
+  background: rgba(255, 255, 255, 0.1);
+  border-top-color: rgba(255, 255, 255, 0.2);
+  border-bottom-color: rgba(255, 255, 255, 0.2);
+}
+.uk-light .uk-table-hover > tr:hover,
+.uk-light .uk-table-hover tbody tr:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-table-hover > tr:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-table-hover tbody tr:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-table-hover > tr:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-table-hover tbody tr:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-table-hover > tr:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-table-hover tbody tr:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-table-hover > tr:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-table-hover tbody tr:hover,
+.uk-card-primary.uk-card-body .uk-table-hover > tr:hover,
+.uk-card-primary.uk-card-body .uk-table-hover tbody tr:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-table-hover > tr:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-table-hover tbody tr:hover,
+.uk-card-secondary.uk-card-body .uk-table-hover > tr:hover,
+.uk-card-secondary.uk-card-body .uk-table-hover tbody tr:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-table-hover > tr:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-table-hover tbody tr:hover,
+.uk-overlay-primary .uk-table-hover > tr:hover,
+.uk-overlay-primary .uk-table-hover tbody tr:hover,
+.uk-offcanvas-bar .uk-table-hover > tr:hover,
+.uk-offcanvas-bar .uk-table-hover tbody tr:hover {
+  background: rgba(255, 255, 255, 0.08);
+}
+.uk-light .uk-icon-link,
+.uk-section-primary:not(.uk-preserve-color) .uk-icon-link,
+.uk-section-secondary:not(.uk-preserve-color) .uk-icon-link,
+.uk-tile-primary:not(.uk-preserve-color) .uk-icon-link,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-icon-link,
+.uk-card-primary.uk-card-body .uk-icon-link,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-icon-link,
+.uk-card-secondary.uk-card-body .uk-icon-link,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-icon-link,
+.uk-overlay-primary .uk-icon-link,
+.uk-offcanvas-bar .uk-icon-link {
+  color: rgba(255, 255, 255, 0.5);
+}
+.uk-light .uk-icon-link:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-icon-link:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-icon-link:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-icon-link:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-icon-link:hover,
+.uk-card-primary.uk-card-body .uk-icon-link:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-icon-link:hover,
+.uk-card-secondary.uk-card-body .uk-icon-link:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-icon-link:hover,
+.uk-overlay-primary .uk-icon-link:hover,
+.uk-offcanvas-bar .uk-icon-link:hover {
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-light .uk-icon-link:active,
+.uk-light .uk-active > .uk-icon-link,
+.uk-section-primary:not(.uk-preserve-color) .uk-icon-link:active,
+.uk-section-primary:not(.uk-preserve-color) .uk-active > .uk-icon-link,
+.uk-section-secondary:not(.uk-preserve-color) .uk-icon-link:active,
+.uk-section-secondary:not(.uk-preserve-color) .uk-active > .uk-icon-link,
+.uk-tile-primary:not(.uk-preserve-color) .uk-icon-link:active,
+.uk-tile-primary:not(.uk-preserve-color) .uk-active > .uk-icon-link,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-icon-link:active,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-active > .uk-icon-link,
+.uk-card-primary.uk-card-body .uk-icon-link:active,
+.uk-card-primary.uk-card-body .uk-active > .uk-icon-link,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-icon-link:active,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-active > .uk-icon-link,
+.uk-card-secondary.uk-card-body .uk-icon-link:active,
+.uk-card-secondary.uk-card-body .uk-active > .uk-icon-link,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-icon-link:active,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-active > .uk-icon-link,
+.uk-overlay-primary .uk-icon-link:active,
+.uk-overlay-primary .uk-active > .uk-icon-link,
+.uk-offcanvas-bar .uk-icon-link:active,
+.uk-offcanvas-bar .uk-active > .uk-icon-link {
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-light .uk-icon-button,
+.uk-section-primary:not(.uk-preserve-color) .uk-icon-button,
+.uk-section-secondary:not(.uk-preserve-color) .uk-icon-button,
+.uk-tile-primary:not(.uk-preserve-color) .uk-icon-button,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-icon-button,
+.uk-card-primary.uk-card-body .uk-icon-button,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-icon-button,
+.uk-card-secondary.uk-card-body .uk-icon-button,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-icon-button,
+.uk-overlay-primary .uk-icon-button,
+.uk-offcanvas-bar .uk-icon-button {
+  background-color: rgba(255, 255, 255, 0.1);
+  color: rgba(255, 255, 255, 0.5);
+}
+.uk-light .uk-icon-button:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-icon-button:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-icon-button:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-icon-button:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-icon-button:hover,
+.uk-card-primary.uk-card-body .uk-icon-button:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-icon-button:hover,
+.uk-card-secondary.uk-card-body .uk-icon-button:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-icon-button:hover,
+.uk-overlay-primary .uk-icon-button:hover,
+.uk-offcanvas-bar .uk-icon-button:hover {
+  background-color: rgba(255, 255, 255, 0.15);
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-light .uk-icon-button:active,
+.uk-section-primary:not(.uk-preserve-color) .uk-icon-button:active,
+.uk-section-secondary:not(.uk-preserve-color) .uk-icon-button:active,
+.uk-tile-primary:not(.uk-preserve-color) .uk-icon-button:active,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-icon-button:active,
+.uk-card-primary.uk-card-body .uk-icon-button:active,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-icon-button:active,
+.uk-card-secondary.uk-card-body .uk-icon-button:active,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-icon-button:active,
+.uk-overlay-primary .uk-icon-button:active,
+.uk-offcanvas-bar .uk-icon-button:active {
+  background-color: rgba(255, 255, 255, 0.2);
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-light .uk-input,
+.uk-light .uk-select,
+.uk-light .uk-textarea,
+.uk-section-primary:not(.uk-preserve-color) .uk-input,
+.uk-section-primary:not(.uk-preserve-color) .uk-select,
+.uk-section-primary:not(.uk-preserve-color) .uk-textarea,
+.uk-section-secondary:not(.uk-preserve-color) .uk-input,
+.uk-section-secondary:not(.uk-preserve-color) .uk-select,
+.uk-section-secondary:not(.uk-preserve-color) .uk-textarea,
+.uk-tile-primary:not(.uk-preserve-color) .uk-input,
+.uk-tile-primary:not(.uk-preserve-color) .uk-select,
+.uk-tile-primary:not(.uk-preserve-color) .uk-textarea,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-input,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-select,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-textarea,
+.uk-card-primary.uk-card-body .uk-input,
+.uk-card-primary.uk-card-body .uk-select,
+.uk-card-primary.uk-card-body .uk-textarea,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-input,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-select,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-textarea,
+.uk-card-secondary.uk-card-body .uk-input,
+.uk-card-secondary.uk-card-body .uk-select,
+.uk-card-secondary.uk-card-body .uk-textarea,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-input,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-select,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-textarea,
+.uk-overlay-primary .uk-input,
+.uk-overlay-primary .uk-select,
+.uk-overlay-primary .uk-textarea,
+.uk-offcanvas-bar .uk-input,
+.uk-offcanvas-bar .uk-select,
+.uk-offcanvas-bar .uk-textarea {
+  background-color: rgba(255, 255, 255, 0.1);
+  color: rgba(255, 255, 255, 0.7);
+  background-clip: padding-box;
+  border-color: rgba(255, 255, 255, 0.2);
+}
+.uk-light .uk-input:focus,
+.uk-light .uk-select:focus,
+.uk-light .uk-textarea:focus,
+.uk-section-primary:not(.uk-preserve-color) .uk-input:focus,
+.uk-section-primary:not(.uk-preserve-color) .uk-select:focus,
+.uk-section-primary:not(.uk-preserve-color) .uk-textarea:focus,
+.uk-section-secondary:not(.uk-preserve-color) .uk-input:focus,
+.uk-section-secondary:not(.uk-preserve-color) .uk-select:focus,
+.uk-section-secondary:not(.uk-preserve-color) .uk-textarea:focus,
+.uk-tile-primary:not(.uk-preserve-color) .uk-input:focus,
+.uk-tile-primary:not(.uk-preserve-color) .uk-select:focus,
+.uk-tile-primary:not(.uk-preserve-color) .uk-textarea:focus,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-input:focus,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-select:focus,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-textarea:focus,
+.uk-card-primary.uk-card-body .uk-input:focus,
+.uk-card-primary.uk-card-body .uk-select:focus,
+.uk-card-primary.uk-card-body .uk-textarea:focus,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-input:focus,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-select:focus,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-textarea:focus,
+.uk-card-secondary.uk-card-body .uk-input:focus,
+.uk-card-secondary.uk-card-body .uk-select:focus,
+.uk-card-secondary.uk-card-body .uk-textarea:focus,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-input:focus,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-select:focus,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-textarea:focus,
+.uk-overlay-primary .uk-input:focus,
+.uk-overlay-primary .uk-select:focus,
+.uk-overlay-primary .uk-textarea:focus,
+.uk-offcanvas-bar .uk-input:focus,
+.uk-offcanvas-bar .uk-select:focus,
+.uk-offcanvas-bar .uk-textarea:focus {
+  background-color: rgba(255, 255, 255, 0.15);
+  color: rgba(255, 255, 255, 0.7);
+  border-color: rgba(255, 255, 255, 0.7);
+}
+.uk-light .uk-input::placeholder,
+.uk-section-primary:not(.uk-preserve-color) .uk-input::placeholder,
+.uk-section-secondary:not(.uk-preserve-color) .uk-input::placeholder,
+.uk-tile-primary:not(.uk-preserve-color) .uk-input::placeholder,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-input::placeholder,
+.uk-card-primary.uk-card-body .uk-input::placeholder,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-input::placeholder,
+.uk-card-secondary.uk-card-body .uk-input::placeholder,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-input::placeholder,
+.uk-overlay-primary .uk-input::placeholder,
+.uk-offcanvas-bar .uk-input::placeholder {
+  color: rgba(255, 255, 255, 0.5);
+}
+.uk-light .uk-textarea::placeholder,
+.uk-section-primary:not(.uk-preserve-color) .uk-textarea::placeholder,
+.uk-section-secondary:not(.uk-preserve-color) .uk-textarea::placeholder,
+.uk-tile-primary:not(.uk-preserve-color) .uk-textarea::placeholder,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-textarea::placeholder,
+.uk-card-primary.uk-card-body .uk-textarea::placeholder,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-textarea::placeholder,
+.uk-card-secondary.uk-card-body .uk-textarea::placeholder,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-textarea::placeholder,
+.uk-overlay-primary .uk-textarea::placeholder,
+.uk-offcanvas-bar .uk-textarea::placeholder {
+  color: rgba(255, 255, 255, 0.5);
+}
+.uk-light .uk-select:not([multiple]):not([size]),
+.uk-section-primary:not(.uk-preserve-color) .uk-select:not([multiple]):not([size]),
+.uk-section-secondary:not(.uk-preserve-color) .uk-select:not([multiple]):not([size]),
+.uk-tile-primary:not(.uk-preserve-color) .uk-select:not([multiple]):not([size]),
+.uk-tile-secondary:not(.uk-preserve-color) .uk-select:not([multiple]):not([size]),
+.uk-card-primary.uk-card-body .uk-select:not([multiple]):not([size]),
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-select:not([multiple]):not([size]),
+.uk-card-secondary.uk-card-body .uk-select:not([multiple]):not([size]),
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-select:not([multiple]):not([size]),
+.uk-overlay-primary .uk-select:not([multiple]):not([size]),
+.uk-offcanvas-bar .uk-select:not([multiple]):not([size]) {
+  background-image: url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2224%22%20height%3D%2216%22%20viewBox%3D%220%200%2024%2016%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Cpolygon%20fill%3D%22rgba%28255,%20255,%20255,%200.7%29%22%20points%3D%2212%201%209%206%2015%206%22%20%2F%3E%0A%20%20%20%20%3Cpolygon%20fill%3D%22rgba%28255,%20255,%20255,%200.7%29%22%20points%3D%2212%2013%209%208%2015%208%22%20%2F%3E%0A%3C%2Fsvg%3E%0A");
+}
+.uk-light .uk-input[list]:hover,
+.uk-light .uk-input[list]:focus,
+.uk-section-primary:not(.uk-preserve-color) .uk-input[list]:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-input[list]:focus,
+.uk-section-secondary:not(.uk-preserve-color) .uk-input[list]:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-input[list]:focus,
+.uk-tile-primary:not(.uk-preserve-color) .uk-input[list]:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-input[list]:focus,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-input[list]:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-input[list]:focus,
+.uk-card-primary.uk-card-body .uk-input[list]:hover,
+.uk-card-primary.uk-card-body .uk-input[list]:focus,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-input[list]:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-input[list]:focus,
+.uk-card-secondary.uk-card-body .uk-input[list]:hover,
+.uk-card-secondary.uk-card-body .uk-input[list]:focus,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-input[list]:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-input[list]:focus,
+.uk-overlay-primary .uk-input[list]:hover,
+.uk-overlay-primary .uk-input[list]:focus,
+.uk-offcanvas-bar .uk-input[list]:hover,
+.uk-offcanvas-bar .uk-input[list]:focus {
+  background-image: url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2224%22%20height%3D%2216%22%20viewBox%3D%220%200%2024%2016%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Cpolygon%20fill%3D%22rgba%28255,%20255,%20255,%200.7%29%22%20points%3D%2212%2012%208%206%2016%206%22%20%2F%3E%0A%3C%2Fsvg%3E%0A");
+}
+.uk-light .uk-radio,
+.uk-light .uk-checkbox,
+.uk-section-primary:not(.uk-preserve-color) .uk-radio,
+.uk-section-primary:not(.uk-preserve-color) .uk-checkbox,
+.uk-section-secondary:not(.uk-preserve-color) .uk-radio,
+.uk-section-secondary:not(.uk-preserve-color) .uk-checkbox,
+.uk-tile-primary:not(.uk-preserve-color) .uk-radio,
+.uk-tile-primary:not(.uk-preserve-color) .uk-checkbox,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-radio,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-checkbox,
+.uk-card-primary.uk-card-body .uk-radio,
+.uk-card-primary.uk-card-body .uk-checkbox,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-radio,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-checkbox,
+.uk-card-secondary.uk-card-body .uk-radio,
+.uk-card-secondary.uk-card-body .uk-checkbox,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-radio,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-checkbox,
+.uk-overlay-primary .uk-radio,
+.uk-overlay-primary .uk-checkbox,
+.uk-offcanvas-bar .uk-radio,
+.uk-offcanvas-bar .uk-checkbox {
+  background-color: rgba(255, 255, 255, 0.1);
+  border-color: rgba(255, 255, 255, 0.2);
+}
+.uk-light .uk-radio:focus,
+.uk-light .uk-checkbox:focus,
+.uk-section-primary:not(.uk-preserve-color) .uk-radio:focus,
+.uk-section-primary:not(.uk-preserve-color) .uk-checkbox:focus,
+.uk-section-secondary:not(.uk-preserve-color) .uk-radio:focus,
+.uk-section-secondary:not(.uk-preserve-color) .uk-checkbox:focus,
+.uk-tile-primary:not(.uk-preserve-color) .uk-radio:focus,
+.uk-tile-primary:not(.uk-preserve-color) .uk-checkbox:focus,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-radio:focus,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-checkbox:focus,
+.uk-card-primary.uk-card-body .uk-radio:focus,
+.uk-card-primary.uk-card-body .uk-checkbox:focus,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-radio:focus,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-checkbox:focus,
+.uk-card-secondary.uk-card-body .uk-radio:focus,
+.uk-card-secondary.uk-card-body .uk-checkbox:focus,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-radio:focus,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-checkbox:focus,
+.uk-overlay-primary .uk-radio:focus,
+.uk-overlay-primary .uk-checkbox:focus,
+.uk-offcanvas-bar .uk-radio:focus,
+.uk-offcanvas-bar .uk-checkbox:focus {
+  background-color: rgba(255, 255, 255, 0.15);
+  border-color: rgba(255, 255, 255, 0.7);
+}
+.uk-light .uk-radio:checked,
+.uk-light .uk-checkbox:checked,
+.uk-light .uk-checkbox:indeterminate,
+.uk-section-primary:not(.uk-preserve-color) .uk-radio:checked,
+.uk-section-primary:not(.uk-preserve-color) .uk-checkbox:checked,
+.uk-section-primary:not(.uk-preserve-color) .uk-checkbox:indeterminate,
+.uk-section-secondary:not(.uk-preserve-color) .uk-radio:checked,
+.uk-section-secondary:not(.uk-preserve-color) .uk-checkbox:checked,
+.uk-section-secondary:not(.uk-preserve-color) .uk-checkbox:indeterminate,
+.uk-tile-primary:not(.uk-preserve-color) .uk-radio:checked,
+.uk-tile-primary:not(.uk-preserve-color) .uk-checkbox:checked,
+.uk-tile-primary:not(.uk-preserve-color) .uk-checkbox:indeterminate,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-radio:checked,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-checkbox:checked,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-checkbox:indeterminate,
+.uk-card-primary.uk-card-body .uk-radio:checked,
+.uk-card-primary.uk-card-body .uk-checkbox:checked,
+.uk-card-primary.uk-card-body .uk-checkbox:indeterminate,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-radio:checked,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-checkbox:checked,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-checkbox:indeterminate,
+.uk-card-secondary.uk-card-body .uk-radio:checked,
+.uk-card-secondary.uk-card-body .uk-checkbox:checked,
+.uk-card-secondary.uk-card-body .uk-checkbox:indeterminate,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-radio:checked,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-checkbox:checked,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-checkbox:indeterminate,
+.uk-overlay-primary .uk-radio:checked,
+.uk-overlay-primary .uk-checkbox:checked,
+.uk-overlay-primary .uk-checkbox:indeterminate,
+.uk-offcanvas-bar .uk-radio:checked,
+.uk-offcanvas-bar .uk-checkbox:checked,
+.uk-offcanvas-bar .uk-checkbox:indeterminate {
+  background-color: #fff;
+  border-color: #fff;
+}
+.uk-light .uk-radio:checked:focus,
+.uk-light .uk-checkbox:checked:focus,
+.uk-light .uk-checkbox:indeterminate:focus,
+.uk-section-primary:not(.uk-preserve-color) .uk-radio:checked:focus,
+.uk-section-primary:not(.uk-preserve-color) .uk-checkbox:checked:focus,
+.uk-section-primary:not(.uk-preserve-color) .uk-checkbox:indeterminate:focus,
+.uk-section-secondary:not(.uk-preserve-color) .uk-radio:checked:focus,
+.uk-section-secondary:not(.uk-preserve-color) .uk-checkbox:checked:focus,
+.uk-section-secondary:not(.uk-preserve-color) .uk-checkbox:indeterminate:focus,
+.uk-tile-primary:not(.uk-preserve-color) .uk-radio:checked:focus,
+.uk-tile-primary:not(.uk-preserve-color) .uk-checkbox:checked:focus,
+.uk-tile-primary:not(.uk-preserve-color) .uk-checkbox:indeterminate:focus,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-radio:checked:focus,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-checkbox:checked:focus,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-checkbox:indeterminate:focus,
+.uk-card-primary.uk-card-body .uk-radio:checked:focus,
+.uk-card-primary.uk-card-body .uk-checkbox:checked:focus,
+.uk-card-primary.uk-card-body .uk-checkbox:indeterminate:focus,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-radio:checked:focus,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-checkbox:checked:focus,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-checkbox:indeterminate:focus,
+.uk-card-secondary.uk-card-body .uk-radio:checked:focus,
+.uk-card-secondary.uk-card-body .uk-checkbox:checked:focus,
+.uk-card-secondary.uk-card-body .uk-checkbox:indeterminate:focus,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-radio:checked:focus,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-checkbox:checked:focus,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-checkbox:indeterminate:focus,
+.uk-overlay-primary .uk-radio:checked:focus,
+.uk-overlay-primary .uk-checkbox:checked:focus,
+.uk-overlay-primary .uk-checkbox:indeterminate:focus,
+.uk-offcanvas-bar .uk-radio:checked:focus,
+.uk-offcanvas-bar .uk-checkbox:checked:focus,
+.uk-offcanvas-bar .uk-checkbox:indeterminate:focus {
+  background-color: #ffffff;
+}
+.uk-light .uk-radio:checked,
+.uk-section-primary:not(.uk-preserve-color) .uk-radio:checked,
+.uk-section-secondary:not(.uk-preserve-color) .uk-radio:checked,
+.uk-tile-primary:not(.uk-preserve-color) .uk-radio:checked,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-radio:checked,
+.uk-card-primary.uk-card-body .uk-radio:checked,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-radio:checked,
+.uk-card-secondary.uk-card-body .uk-radio:checked,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-radio:checked,
+.uk-overlay-primary .uk-radio:checked,
+.uk-offcanvas-bar .uk-radio:checked {
+  background-image: url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2216%22%20height%3D%2216%22%20viewBox%3D%220%200%2016%2016%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Ccircle%20fill%3D%22%23666%22%20cx%3D%228%22%20cy%3D%228%22%20r%3D%222%22%20%2F%3E%0A%3C%2Fsvg%3E");
+}
+.uk-light .uk-checkbox:checked,
+.uk-section-primary:not(.uk-preserve-color) .uk-checkbox:checked,
+.uk-section-secondary:not(.uk-preserve-color) .uk-checkbox:checked,
+.uk-tile-primary:not(.uk-preserve-color) .uk-checkbox:checked,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-checkbox:checked,
+.uk-card-primary.uk-card-body .uk-checkbox:checked,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-checkbox:checked,
+.uk-card-secondary.uk-card-body .uk-checkbox:checked,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-checkbox:checked,
+.uk-overlay-primary .uk-checkbox:checked,
+.uk-offcanvas-bar .uk-checkbox:checked {
+  background-image: url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2214%22%20height%3D%2211%22%20viewBox%3D%220%200%2014%2011%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Cpolygon%20fill%3D%22%23666%22%20points%3D%2212%201%205%207.5%202%205%201%205.5%205%2010%2013%201.5%22%20%2F%3E%0A%3C%2Fsvg%3E%0A");
+}
+.uk-light .uk-checkbox:indeterminate,
+.uk-section-primary:not(.uk-preserve-color) .uk-checkbox:indeterminate,
+.uk-section-secondary:not(.uk-preserve-color) .uk-checkbox:indeterminate,
+.uk-tile-primary:not(.uk-preserve-color) .uk-checkbox:indeterminate,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-checkbox:indeterminate,
+.uk-card-primary.uk-card-body .uk-checkbox:indeterminate,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-checkbox:indeterminate,
+.uk-card-secondary.uk-card-body .uk-checkbox:indeterminate,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-checkbox:indeterminate,
+.uk-overlay-primary .uk-checkbox:indeterminate,
+.uk-offcanvas-bar .uk-checkbox:indeterminate {
+  background-image: url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2216%22%20height%3D%2216%22%20viewBox%3D%220%200%2016%2016%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Crect%20fill%3D%22%23666%22%20x%3D%223%22%20y%3D%228%22%20width%3D%2210%22%20height%3D%221%22%20%2F%3E%0A%3C%2Fsvg%3E");
+}
+.uk-light .uk-form-label,
+.uk-section-primary:not(.uk-preserve-color) .uk-form-label,
+.uk-section-secondary:not(.uk-preserve-color) .uk-form-label,
+.uk-tile-primary:not(.uk-preserve-color) .uk-form-label,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-form-label,
+.uk-card-primary.uk-card-body .uk-form-label,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-form-label,
+.uk-card-secondary.uk-card-body .uk-form-label,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-form-label,
+.uk-overlay-primary .uk-form-label,
+.uk-offcanvas-bar .uk-form-label {
+  color: #fff;
+}
+.uk-light .uk-form-icon,
+.uk-section-primary:not(.uk-preserve-color) .uk-form-icon,
+.uk-section-secondary:not(.uk-preserve-color) .uk-form-icon,
+.uk-tile-primary:not(.uk-preserve-color) .uk-form-icon,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-form-icon,
+.uk-card-primary.uk-card-body .uk-form-icon,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-form-icon,
+.uk-card-secondary.uk-card-body .uk-form-icon,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-form-icon,
+.uk-overlay-primary .uk-form-icon,
+.uk-offcanvas-bar .uk-form-icon {
+  color: rgba(255, 255, 255, 0.5);
+}
+.uk-light .uk-form-icon:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-form-icon:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-form-icon:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-form-icon:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-form-icon:hover,
+.uk-card-primary.uk-card-body .uk-form-icon:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-form-icon:hover,
+.uk-card-secondary.uk-card-body .uk-form-icon:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-form-icon:hover,
+.uk-overlay-primary .uk-form-icon:hover,
+.uk-offcanvas-bar .uk-form-icon:hover {
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-light .uk-button-default,
+.uk-section-primary:not(.uk-preserve-color) .uk-button-default,
+.uk-section-secondary:not(.uk-preserve-color) .uk-button-default,
+.uk-tile-primary:not(.uk-preserve-color) .uk-button-default,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-button-default,
+.uk-card-primary.uk-card-body .uk-button-default,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-button-default,
+.uk-card-secondary.uk-card-body .uk-button-default,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-button-default,
+.uk-overlay-primary .uk-button-default,
+.uk-offcanvas-bar .uk-button-default {
+  background-color: transparent;
+  color: #fff;
+  border-color: rgba(255, 255, 255, 0.7);
+}
+.uk-light .uk-button-default:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-button-default:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-button-default:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-button-default:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-button-default:hover,
+.uk-card-primary.uk-card-body .uk-button-default:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-button-default:hover,
+.uk-card-secondary.uk-card-body .uk-button-default:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-button-default:hover,
+.uk-overlay-primary .uk-button-default:hover,
+.uk-offcanvas-bar .uk-button-default:hover {
+  background-color: transparent;
+  color: #fff;
+  border-color: #fff;
+}
+.uk-light .uk-button-default:active,
+.uk-light .uk-button-default.uk-active,
+.uk-section-primary:not(.uk-preserve-color) .uk-button-default:active,
+.uk-section-primary:not(.uk-preserve-color) .uk-button-default.uk-active,
+.uk-section-secondary:not(.uk-preserve-color) .uk-button-default:active,
+.uk-section-secondary:not(.uk-preserve-color) .uk-button-default.uk-active,
+.uk-tile-primary:not(.uk-preserve-color) .uk-button-default:active,
+.uk-tile-primary:not(.uk-preserve-color) .uk-button-default.uk-active,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-button-default:active,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-button-default.uk-active,
+.uk-card-primary.uk-card-body .uk-button-default:active,
+.uk-card-primary.uk-card-body .uk-button-default.uk-active,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-button-default:active,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-button-default.uk-active,
+.uk-card-secondary.uk-card-body .uk-button-default:active,
+.uk-card-secondary.uk-card-body .uk-button-default.uk-active,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-button-default:active,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-button-default.uk-active,
+.uk-overlay-primary .uk-button-default:active,
+.uk-overlay-primary .uk-button-default.uk-active,
+.uk-offcanvas-bar .uk-button-default:active,
+.uk-offcanvas-bar .uk-button-default.uk-active {
+  background-color: transparent;
+  color: #fff;
+  border-color: #fff;
+}
+.uk-light .uk-button-primary,
+.uk-section-primary:not(.uk-preserve-color) .uk-button-primary,
+.uk-section-secondary:not(.uk-preserve-color) .uk-button-primary,
+.uk-tile-primary:not(.uk-preserve-color) .uk-button-primary,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-button-primary,
+.uk-card-primary.uk-card-body .uk-button-primary,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-button-primary,
+.uk-card-secondary.uk-card-body .uk-button-primary,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-button-primary,
+.uk-overlay-primary .uk-button-primary,
+.uk-offcanvas-bar .uk-button-primary {
+  background-color: #fff;
+  color: #666;
+}
+.uk-light .uk-button-primary:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-button-primary:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-button-primary:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-button-primary:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-button-primary:hover,
+.uk-card-primary.uk-card-body .uk-button-primary:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-button-primary:hover,
+.uk-card-secondary.uk-card-body .uk-button-primary:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-button-primary:hover,
+.uk-overlay-primary .uk-button-primary:hover,
+.uk-offcanvas-bar .uk-button-primary:hover {
+  background-color: #f2f2f2;
+  color: #666;
+}
+.uk-light .uk-button-primary:active,
+.uk-light .uk-button-primary.uk-active,
+.uk-section-primary:not(.uk-preserve-color) .uk-button-primary:active,
+.uk-section-primary:not(.uk-preserve-color) .uk-button-primary.uk-active,
+.uk-section-secondary:not(.uk-preserve-color) .uk-button-primary:active,
+.uk-section-secondary:not(.uk-preserve-color) .uk-button-primary.uk-active,
+.uk-tile-primary:not(.uk-preserve-color) .uk-button-primary:active,
+.uk-tile-primary:not(.uk-preserve-color) .uk-button-primary.uk-active,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-button-primary:active,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-button-primary.uk-active,
+.uk-card-primary.uk-card-body .uk-button-primary:active,
+.uk-card-primary.uk-card-body .uk-button-primary.uk-active,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-button-primary:active,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-button-primary.uk-active,
+.uk-card-secondary.uk-card-body .uk-button-primary:active,
+.uk-card-secondary.uk-card-body .uk-button-primary.uk-active,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-button-primary:active,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-button-primary.uk-active,
+.uk-overlay-primary .uk-button-primary:active,
+.uk-overlay-primary .uk-button-primary.uk-active,
+.uk-offcanvas-bar .uk-button-primary:active,
+.uk-offcanvas-bar .uk-button-primary.uk-active {
+  background-color: #e6e6e6;
+  color: #666;
+}
+.uk-light .uk-button-secondary,
+.uk-section-primary:not(.uk-preserve-color) .uk-button-secondary,
+.uk-section-secondary:not(.uk-preserve-color) .uk-button-secondary,
+.uk-tile-primary:not(.uk-preserve-color) .uk-button-secondary,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-button-secondary,
+.uk-card-primary.uk-card-body .uk-button-secondary,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-button-secondary,
+.uk-card-secondary.uk-card-body .uk-button-secondary,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-button-secondary,
+.uk-overlay-primary .uk-button-secondary,
+.uk-offcanvas-bar .uk-button-secondary {
+  background-color: #fff;
+  color: #666;
+}
+.uk-light .uk-button-secondary:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-button-secondary:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-button-secondary:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-button-secondary:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-button-secondary:hover,
+.uk-card-primary.uk-card-body .uk-button-secondary:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-button-secondary:hover,
+.uk-card-secondary.uk-card-body .uk-button-secondary:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-button-secondary:hover,
+.uk-overlay-primary .uk-button-secondary:hover,
+.uk-offcanvas-bar .uk-button-secondary:hover {
+  background-color: #f2f2f2;
+  color: #666;
+}
+.uk-light .uk-button-secondary:active,
+.uk-light .uk-button-secondary.uk-active,
+.uk-section-primary:not(.uk-preserve-color) .uk-button-secondary:active,
+.uk-section-primary:not(.uk-preserve-color) .uk-button-secondary.uk-active,
+.uk-section-secondary:not(.uk-preserve-color) .uk-button-secondary:active,
+.uk-section-secondary:not(.uk-preserve-color) .uk-button-secondary.uk-active,
+.uk-tile-primary:not(.uk-preserve-color) .uk-button-secondary:active,
+.uk-tile-primary:not(.uk-preserve-color) .uk-button-secondary.uk-active,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-button-secondary:active,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-button-secondary.uk-active,
+.uk-card-primary.uk-card-body .uk-button-secondary:active,
+.uk-card-primary.uk-card-body .uk-button-secondary.uk-active,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-button-secondary:active,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-button-secondary.uk-active,
+.uk-card-secondary.uk-card-body .uk-button-secondary:active,
+.uk-card-secondary.uk-card-body .uk-button-secondary.uk-active,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-button-secondary:active,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-button-secondary.uk-active,
+.uk-overlay-primary .uk-button-secondary:active,
+.uk-overlay-primary .uk-button-secondary.uk-active,
+.uk-offcanvas-bar .uk-button-secondary:active,
+.uk-offcanvas-bar .uk-button-secondary.uk-active {
+  background-color: #e6e6e6;
+  color: #666;
+}
+.uk-light .uk-button-text,
+.uk-section-primary:not(.uk-preserve-color) .uk-button-text,
+.uk-section-secondary:not(.uk-preserve-color) .uk-button-text,
+.uk-tile-primary:not(.uk-preserve-color) .uk-button-text,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-button-text,
+.uk-card-primary.uk-card-body .uk-button-text,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-button-text,
+.uk-card-secondary.uk-card-body .uk-button-text,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-button-text,
+.uk-overlay-primary .uk-button-text,
+.uk-offcanvas-bar .uk-button-text {
+  color: #fff;
+}
+.uk-light .uk-button-text::before,
+.uk-section-primary:not(.uk-preserve-color) .uk-button-text::before,
+.uk-section-secondary:not(.uk-preserve-color) .uk-button-text::before,
+.uk-tile-primary:not(.uk-preserve-color) .uk-button-text::before,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-button-text::before,
+.uk-card-primary.uk-card-body .uk-button-text::before,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-button-text::before,
+.uk-card-secondary.uk-card-body .uk-button-text::before,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-button-text::before,
+.uk-overlay-primary .uk-button-text::before,
+.uk-offcanvas-bar .uk-button-text::before {
+  border-bottom-color: #fff;
+}
+.uk-light .uk-button-text:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-button-text:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-button-text:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-button-text:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-button-text:hover,
+.uk-card-primary.uk-card-body .uk-button-text:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-button-text:hover,
+.uk-card-secondary.uk-card-body .uk-button-text:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-button-text:hover,
+.uk-overlay-primary .uk-button-text:hover,
+.uk-offcanvas-bar .uk-button-text:hover {
+  color: #fff;
+}
+.uk-light .uk-button-text:disabled,
+.uk-section-primary:not(.uk-preserve-color) .uk-button-text:disabled,
+.uk-section-secondary:not(.uk-preserve-color) .uk-button-text:disabled,
+.uk-tile-primary:not(.uk-preserve-color) .uk-button-text:disabled,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-button-text:disabled,
+.uk-card-primary.uk-card-body .uk-button-text:disabled,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-button-text:disabled,
+.uk-card-secondary.uk-card-body .uk-button-text:disabled,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-button-text:disabled,
+.uk-overlay-primary .uk-button-text:disabled,
+.uk-offcanvas-bar .uk-button-text:disabled {
+  color: rgba(255, 255, 255, 0.5);
+}
+.uk-light .uk-button-link,
+.uk-section-primary:not(.uk-preserve-color) .uk-button-link,
+.uk-section-secondary:not(.uk-preserve-color) .uk-button-link,
+.uk-tile-primary:not(.uk-preserve-color) .uk-button-link,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-button-link,
+.uk-card-primary.uk-card-body .uk-button-link,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-button-link,
+.uk-card-secondary.uk-card-body .uk-button-link,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-button-link,
+.uk-overlay-primary .uk-button-link,
+.uk-offcanvas-bar .uk-button-link {
+  color: #fff;
+}
+.uk-light .uk-button-link:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-button-link:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-button-link:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-button-link:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-button-link:hover,
+.uk-card-primary.uk-card-body .uk-button-link:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-button-link:hover,
+.uk-card-secondary.uk-card-body .uk-button-link:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-button-link:hover,
+.uk-overlay-primary .uk-button-link:hover,
+.uk-offcanvas-bar .uk-button-link:hover {
+  color: rgba(255, 255, 255, 0.5);
+}
+.uk-light.uk-card-badge,
+.uk-section-primary:not(.uk-preserve-color).uk-card-badge,
+.uk-section-secondary:not(.uk-preserve-color).uk-card-badge,
+.uk-tile-primary:not(.uk-preserve-color).uk-card-badge,
+.uk-tile-secondary:not(.uk-preserve-color).uk-card-badge,
+.uk-card-primary.uk-card-body.uk-card-badge,
+.uk-card-primary > :not([class*="uk-card-media"]).uk-card-badge,
+.uk-card-secondary.uk-card-body.uk-card-badge,
+.uk-card-secondary > :not([class*="uk-card-media"]).uk-card-badge,
+.uk-overlay-primary.uk-card-badge,
+.uk-offcanvas-bar.uk-card-badge {
+  background-color: #fff;
+  color: #666;
+}
+.uk-light .uk-close,
+.uk-section-primary:not(.uk-preserve-color) .uk-close,
+.uk-section-secondary:not(.uk-preserve-color) .uk-close,
+.uk-tile-primary:not(.uk-preserve-color) .uk-close,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-close,
+.uk-card-primary.uk-card-body .uk-close,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-close,
+.uk-card-secondary.uk-card-body .uk-close,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-close,
+.uk-overlay-primary .uk-close,
+.uk-offcanvas-bar .uk-close {
+  color: rgba(255, 255, 255, 0.5);
+}
+.uk-light .uk-close:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-close:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-close:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-close:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-close:hover,
+.uk-card-primary.uk-card-body .uk-close:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-close:hover,
+.uk-card-secondary.uk-card-body .uk-close:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-close:hover,
+.uk-overlay-primary .uk-close:hover,
+.uk-offcanvas-bar .uk-close:hover {
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-light .uk-totop,
+.uk-section-primary:not(.uk-preserve-color) .uk-totop,
+.uk-section-secondary:not(.uk-preserve-color) .uk-totop,
+.uk-tile-primary:not(.uk-preserve-color) .uk-totop,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-totop,
+.uk-card-primary.uk-card-body .uk-totop,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-totop,
+.uk-card-secondary.uk-card-body .uk-totop,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-totop,
+.uk-overlay-primary .uk-totop,
+.uk-offcanvas-bar .uk-totop {
+  color: rgba(255, 255, 255, 0.5);
+}
+.uk-light .uk-totop:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-totop:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-totop:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-totop:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-totop:hover,
+.uk-card-primary.uk-card-body .uk-totop:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-totop:hover,
+.uk-card-secondary.uk-card-body .uk-totop:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-totop:hover,
+.uk-overlay-primary .uk-totop:hover,
+.uk-offcanvas-bar .uk-totop:hover {
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-light .uk-totop:active,
+.uk-section-primary:not(.uk-preserve-color) .uk-totop:active,
+.uk-section-secondary:not(.uk-preserve-color) .uk-totop:active,
+.uk-tile-primary:not(.uk-preserve-color) .uk-totop:active,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-totop:active,
+.uk-card-primary.uk-card-body .uk-totop:active,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-totop:active,
+.uk-card-secondary.uk-card-body .uk-totop:active,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-totop:active,
+.uk-overlay-primary .uk-totop:active,
+.uk-offcanvas-bar .uk-totop:active {
+  color: #fff;
+}
+.uk-light .uk-marker,
+.uk-section-primary:not(.uk-preserve-color) .uk-marker,
+.uk-section-secondary:not(.uk-preserve-color) .uk-marker,
+.uk-tile-primary:not(.uk-preserve-color) .uk-marker,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-marker,
+.uk-card-primary.uk-card-body .uk-marker,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-marker,
+.uk-card-secondary.uk-card-body .uk-marker,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-marker,
+.uk-overlay-primary .uk-marker,
+.uk-offcanvas-bar .uk-marker {
+  background: #f8f8f8;
+  color: #666;
+}
+.uk-light .uk-marker:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-marker:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-marker:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-marker:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-marker:hover,
+.uk-card-primary.uk-card-body .uk-marker:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-marker:hover,
+.uk-card-secondary.uk-card-body .uk-marker:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-marker:hover,
+.uk-overlay-primary .uk-marker:hover,
+.uk-offcanvas-bar .uk-marker:hover {
+  color: #666;
+}
+.uk-light .uk-badge,
+.uk-section-primary:not(.uk-preserve-color) .uk-badge,
+.uk-section-secondary:not(.uk-preserve-color) .uk-badge,
+.uk-tile-primary:not(.uk-preserve-color) .uk-badge,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-badge,
+.uk-card-primary.uk-card-body .uk-badge,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-badge,
+.uk-card-secondary.uk-card-body .uk-badge,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-badge,
+.uk-overlay-primary .uk-badge,
+.uk-offcanvas-bar .uk-badge {
+  background-color: #fff;
+  color: #666 !important;
+}
+.uk-light .uk-label,
+.uk-section-primary:not(.uk-preserve-color) .uk-label,
+.uk-section-secondary:not(.uk-preserve-color) .uk-label,
+.uk-tile-primary:not(.uk-preserve-color) .uk-label,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-label,
+.uk-card-primary.uk-card-body .uk-label,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-label,
+.uk-card-secondary.uk-card-body .uk-label,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-label,
+.uk-overlay-primary .uk-label,
+.uk-offcanvas-bar .uk-label {
+  background-color: #fff;
+  color: #666;
+}
+.uk-light .uk-article-meta,
+.uk-section-primary:not(.uk-preserve-color) .uk-article-meta,
+.uk-section-secondary:not(.uk-preserve-color) .uk-article-meta,
+.uk-tile-primary:not(.uk-preserve-color) .uk-article-meta,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-article-meta,
+.uk-card-primary.uk-card-body .uk-article-meta,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-article-meta,
+.uk-card-secondary.uk-card-body .uk-article-meta,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-article-meta,
+.uk-overlay-primary .uk-article-meta,
+.uk-offcanvas-bar .uk-article-meta {
+  color: rgba(255, 255, 255, 0.5);
+}
+.uk-light .uk-search-input,
+.uk-section-primary:not(.uk-preserve-color) .uk-search-input,
+.uk-section-secondary:not(.uk-preserve-color) .uk-search-input,
+.uk-tile-primary:not(.uk-preserve-color) .uk-search-input,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-search-input,
+.uk-card-primary.uk-card-body .uk-search-input,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-search-input,
+.uk-card-secondary.uk-card-body .uk-search-input,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-search-input,
+.uk-overlay-primary .uk-search-input,
+.uk-offcanvas-bar .uk-search-input {
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-light .uk-search-input::placeholder,
+.uk-section-primary:not(.uk-preserve-color) .uk-search-input::placeholder,
+.uk-section-secondary:not(.uk-preserve-color) .uk-search-input::placeholder,
+.uk-tile-primary:not(.uk-preserve-color) .uk-search-input::placeholder,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-search-input::placeholder,
+.uk-card-primary.uk-card-body .uk-search-input::placeholder,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-search-input::placeholder,
+.uk-card-secondary.uk-card-body .uk-search-input::placeholder,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-search-input::placeholder,
+.uk-overlay-primary .uk-search-input::placeholder,
+.uk-offcanvas-bar .uk-search-input::placeholder {
+  color: rgba(255, 255, 255, 0.5);
+}
+.uk-light .uk-search .uk-search-icon,
+.uk-section-primary:not(.uk-preserve-color) .uk-search .uk-search-icon,
+.uk-section-secondary:not(.uk-preserve-color) .uk-search .uk-search-icon,
+.uk-tile-primary:not(.uk-preserve-color) .uk-search .uk-search-icon,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-search .uk-search-icon,
+.uk-card-primary.uk-card-body .uk-search .uk-search-icon,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-search .uk-search-icon,
+.uk-card-secondary.uk-card-body .uk-search .uk-search-icon,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-search .uk-search-icon,
+.uk-overlay-primary .uk-search .uk-search-icon,
+.uk-offcanvas-bar .uk-search .uk-search-icon {
+  color: rgba(255, 255, 255, 0.5);
+}
+.uk-light .uk-search .uk-search-icon:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-search .uk-search-icon:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-search .uk-search-icon:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-search .uk-search-icon:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-search .uk-search-icon:hover,
+.uk-card-primary.uk-card-body .uk-search .uk-search-icon:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-search .uk-search-icon:hover,
+.uk-card-secondary.uk-card-body .uk-search .uk-search-icon:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-search .uk-search-icon:hover,
+.uk-overlay-primary .uk-search .uk-search-icon:hover,
+.uk-offcanvas-bar .uk-search .uk-search-icon:hover {
+  color: rgba(255, 255, 255, 0.5);
+}
+.uk-light .uk-search-default .uk-search-input,
+.uk-section-primary:not(.uk-preserve-color) .uk-search-default .uk-search-input,
+.uk-section-secondary:not(.uk-preserve-color) .uk-search-default .uk-search-input,
+.uk-tile-primary:not(.uk-preserve-color) .uk-search-default .uk-search-input,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-search-default .uk-search-input,
+.uk-card-primary.uk-card-body .uk-search-default .uk-search-input,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-search-default .uk-search-input,
+.uk-card-secondary.uk-card-body .uk-search-default .uk-search-input,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-search-default .uk-search-input,
+.uk-overlay-primary .uk-search-default .uk-search-input,
+.uk-offcanvas-bar .uk-search-default .uk-search-input {
+  background-color: transparent;
+  border-color: rgba(255, 255, 255, 0.2);
+}
+.uk-light .uk-search-default .uk-search-input:focus,
+.uk-section-primary:not(.uk-preserve-color) .uk-search-default .uk-search-input:focus,
+.uk-section-secondary:not(.uk-preserve-color) .uk-search-default .uk-search-input:focus,
+.uk-tile-primary:not(.uk-preserve-color) .uk-search-default .uk-search-input:focus,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-search-default .uk-search-input:focus,
+.uk-card-primary.uk-card-body .uk-search-default .uk-search-input:focus,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-search-default .uk-search-input:focus,
+.uk-card-secondary.uk-card-body .uk-search-default .uk-search-input:focus,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-search-default .uk-search-input:focus,
+.uk-overlay-primary .uk-search-default .uk-search-input:focus,
+.uk-offcanvas-bar .uk-search-default .uk-search-input:focus {
+  background-color: rgba(0, 0, 0, 0.05);
+}
+.uk-light .uk-search-navbar .uk-search-input,
+.uk-section-primary:not(.uk-preserve-color) .uk-search-navbar .uk-search-input,
+.uk-section-secondary:not(.uk-preserve-color) .uk-search-navbar .uk-search-input,
+.uk-tile-primary:not(.uk-preserve-color) .uk-search-navbar .uk-search-input,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-search-navbar .uk-search-input,
+.uk-card-primary.uk-card-body .uk-search-navbar .uk-search-input,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-search-navbar .uk-search-input,
+.uk-card-secondary.uk-card-body .uk-search-navbar .uk-search-input,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-search-navbar .uk-search-input,
+.uk-overlay-primary .uk-search-navbar .uk-search-input,
+.uk-offcanvas-bar .uk-search-navbar .uk-search-input {
+  background-color: transparent;
+  border-color: rgba(255, 255, 255, 0.2);
+}
+.uk-light .uk-search-navbar .uk-search-input:focus,
+.uk-section-primary:not(.uk-preserve-color) .uk-search-navbar .uk-search-input:focus,
+.uk-section-secondary:not(.uk-preserve-color) .uk-search-navbar .uk-search-input:focus,
+.uk-tile-primary:not(.uk-preserve-color) .uk-search-navbar .uk-search-input:focus,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-search-navbar .uk-search-input:focus,
+.uk-card-primary.uk-card-body .uk-search-navbar .uk-search-input:focus,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-search-navbar .uk-search-input:focus,
+.uk-card-secondary.uk-card-body .uk-search-navbar .uk-search-input:focus,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-search-navbar .uk-search-input:focus,
+.uk-overlay-primary .uk-search-navbar .uk-search-input:focus,
+.uk-offcanvas-bar .uk-search-navbar .uk-search-input:focus {
+  background-color: rgba(0, 0, 0, 0.05);
+}
+.uk-light .uk-search-medium .uk-search-input,
+.uk-section-primary:not(.uk-preserve-color) .uk-search-medium .uk-search-input,
+.uk-section-secondary:not(.uk-preserve-color) .uk-search-medium .uk-search-input,
+.uk-tile-primary:not(.uk-preserve-color) .uk-search-medium .uk-search-input,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-search-medium .uk-search-input,
+.uk-card-primary.uk-card-body .uk-search-medium .uk-search-input,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-search-medium .uk-search-input,
+.uk-card-secondary.uk-card-body .uk-search-medium .uk-search-input,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-search-medium .uk-search-input,
+.uk-overlay-primary .uk-search-medium .uk-search-input,
+.uk-offcanvas-bar .uk-search-medium .uk-search-input {
+  background-color: transparent;
+}
+.uk-light .uk-search-large .uk-search-input,
+.uk-section-primary:not(.uk-preserve-color) .uk-search-large .uk-search-input,
+.uk-section-secondary:not(.uk-preserve-color) .uk-search-large .uk-search-input,
+.uk-tile-primary:not(.uk-preserve-color) .uk-search-large .uk-search-input,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-search-large .uk-search-input,
+.uk-card-primary.uk-card-body .uk-search-large .uk-search-input,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-search-large .uk-search-input,
+.uk-card-secondary.uk-card-body .uk-search-large .uk-search-input,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-search-large .uk-search-input,
+.uk-overlay-primary .uk-search-large .uk-search-input,
+.uk-offcanvas-bar .uk-search-large .uk-search-input {
+  background-color: transparent;
+}
+.uk-light .uk-search-toggle,
+.uk-section-primary:not(.uk-preserve-color) .uk-search-toggle,
+.uk-section-secondary:not(.uk-preserve-color) .uk-search-toggle,
+.uk-tile-primary:not(.uk-preserve-color) .uk-search-toggle,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-search-toggle,
+.uk-card-primary.uk-card-body .uk-search-toggle,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-search-toggle,
+.uk-card-secondary.uk-card-body .uk-search-toggle,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-search-toggle,
+.uk-overlay-primary .uk-search-toggle,
+.uk-offcanvas-bar .uk-search-toggle {
+  color: rgba(255, 255, 255, 0.5);
+}
+.uk-light .uk-search-toggle:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-search-toggle:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-search-toggle:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-search-toggle:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-search-toggle:hover,
+.uk-card-primary.uk-card-body .uk-search-toggle:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-search-toggle:hover,
+.uk-card-secondary.uk-card-body .uk-search-toggle:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-search-toggle:hover,
+.uk-overlay-primary .uk-search-toggle:hover,
+.uk-offcanvas-bar .uk-search-toggle:hover {
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-light .uk-accordion-title,
+.uk-section-primary:not(.uk-preserve-color) .uk-accordion-title,
+.uk-section-secondary:not(.uk-preserve-color) .uk-accordion-title,
+.uk-tile-primary:not(.uk-preserve-color) .uk-accordion-title,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-accordion-title,
+.uk-card-primary.uk-card-body .uk-accordion-title,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-accordion-title,
+.uk-card-secondary.uk-card-body .uk-accordion-title,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-accordion-title,
+.uk-overlay-primary .uk-accordion-title,
+.uk-offcanvas-bar .uk-accordion-title {
+  color: #fff;
+}
+.uk-light .uk-accordion-title:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-accordion-title:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-accordion-title:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-accordion-title:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-accordion-title:hover,
+.uk-card-primary.uk-card-body .uk-accordion-title:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-accordion-title:hover,
+.uk-card-secondary.uk-card-body .uk-accordion-title:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-accordion-title:hover,
+.uk-overlay-primary .uk-accordion-title:hover,
+.uk-offcanvas-bar .uk-accordion-title:hover {
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-light .uk-thumbnav > * > *::after,
+.uk-section-primary:not(.uk-preserve-color) .uk-thumbnav > * > *::after,
+.uk-section-secondary:not(.uk-preserve-color) .uk-thumbnav > * > *::after,
+.uk-tile-primary:not(.uk-preserve-color) .uk-thumbnav > * > *::after,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-thumbnav > * > *::after,
+.uk-card-primary.uk-card-body .uk-thumbnav > * > *::after,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-thumbnav > * > *::after,
+.uk-card-secondary.uk-card-body .uk-thumbnav > * > *::after,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-thumbnav > * > *::after,
+.uk-overlay-primary .uk-thumbnav > * > *::after,
+.uk-offcanvas-bar .uk-thumbnav > * > *::after {
+  background-image: linear-gradient(180deg, rgba(0, 0, 0, 0), rgba(0, 0, 0, 0.4));
+}
+.uk-light .uk-iconnav > * > a,
+.uk-section-primary:not(.uk-preserve-color) .uk-iconnav > * > a,
+.uk-section-secondary:not(.uk-preserve-color) .uk-iconnav > * > a,
+.uk-tile-primary:not(.uk-preserve-color) .uk-iconnav > * > a,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-iconnav > * > a,
+.uk-card-primary.uk-card-body .uk-iconnav > * > a,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-iconnav > * > a,
+.uk-card-secondary.uk-card-body .uk-iconnav > * > a,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-iconnav > * > a,
+.uk-overlay-primary .uk-iconnav > * > a,
+.uk-offcanvas-bar .uk-iconnav > * > a {
+  color: rgba(255, 255, 255, 0.5);
+}
+.uk-light .uk-iconnav > * > a:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-iconnav > * > a:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-iconnav > * > a:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-iconnav > * > a:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-iconnav > * > a:hover,
+.uk-card-primary.uk-card-body .uk-iconnav > * > a:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-iconnav > * > a:hover,
+.uk-card-secondary.uk-card-body .uk-iconnav > * > a:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-iconnav > * > a:hover,
+.uk-overlay-primary .uk-iconnav > * > a:hover,
+.uk-offcanvas-bar .uk-iconnav > * > a:hover {
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-light .uk-iconnav > .uk-active > a,
+.uk-section-primary:not(.uk-preserve-color) .uk-iconnav > .uk-active > a,
+.uk-section-secondary:not(.uk-preserve-color) .uk-iconnav > .uk-active > a,
+.uk-tile-primary:not(.uk-preserve-color) .uk-iconnav > .uk-active > a,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-iconnav > .uk-active > a,
+.uk-card-primary.uk-card-body .uk-iconnav > .uk-active > a,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-iconnav > .uk-active > a,
+.uk-card-secondary.uk-card-body .uk-iconnav > .uk-active > a,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-iconnav > .uk-active > a,
+.uk-overlay-primary .uk-iconnav > .uk-active > a,
+.uk-offcanvas-bar .uk-iconnav > .uk-active > a {
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-light .uk-grid-divider > :not(.uk-first-column)::before,
+.uk-section-primary:not(.uk-preserve-color) .uk-grid-divider > :not(.uk-first-column)::before,
+.uk-section-secondary:not(.uk-preserve-color) .uk-grid-divider > :not(.uk-first-column)::before,
+.uk-tile-primary:not(.uk-preserve-color) .uk-grid-divider > :not(.uk-first-column)::before,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-grid-divider > :not(.uk-first-column)::before,
+.uk-card-primary.uk-card-body .uk-grid-divider > :not(.uk-first-column)::before,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-grid-divider > :not(.uk-first-column)::before,
+.uk-card-secondary.uk-card-body .uk-grid-divider > :not(.uk-first-column)::before,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-grid-divider > :not(.uk-first-column)::before,
+.uk-overlay-primary .uk-grid-divider > :not(.uk-first-column)::before,
+.uk-offcanvas-bar .uk-grid-divider > :not(.uk-first-column)::before {
+  border-left-color: rgba(255, 255, 255, 0.2);
+}
+.uk-light .uk-grid-divider.uk-grid-stack > .uk-grid-margin::before,
+.uk-section-primary:not(.uk-preserve-color) .uk-grid-divider.uk-grid-stack > .uk-grid-margin::before,
+.uk-section-secondary:not(.uk-preserve-color) .uk-grid-divider.uk-grid-stack > .uk-grid-margin::before,
+.uk-tile-primary:not(.uk-preserve-color) .uk-grid-divider.uk-grid-stack > .uk-grid-margin::before,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-grid-divider.uk-grid-stack > .uk-grid-margin::before,
+.uk-card-primary.uk-card-body .uk-grid-divider.uk-grid-stack > .uk-grid-margin::before,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-grid-divider.uk-grid-stack > .uk-grid-margin::before,
+.uk-card-secondary.uk-card-body .uk-grid-divider.uk-grid-stack > .uk-grid-margin::before,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-grid-divider.uk-grid-stack > .uk-grid-margin::before,
+.uk-overlay-primary .uk-grid-divider.uk-grid-stack > .uk-grid-margin::before,
+.uk-offcanvas-bar .uk-grid-divider.uk-grid-stack > .uk-grid-margin::before {
+  border-top-color: rgba(255, 255, 255, 0.2);
+}
+.uk-light .uk-nav-default > li > a,
+.uk-section-primary:not(.uk-preserve-color) .uk-nav-default > li > a,
+.uk-section-secondary:not(.uk-preserve-color) .uk-nav-default > li > a,
+.uk-tile-primary:not(.uk-preserve-color) .uk-nav-default > li > a,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-default > li > a,
+.uk-card-primary.uk-card-body .uk-nav-default > li > a,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-nav-default > li > a,
+.uk-card-secondary.uk-card-body .uk-nav-default > li > a,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-nav-default > li > a,
+.uk-overlay-primary .uk-nav-default > li > a,
+.uk-offcanvas-bar .uk-nav-default > li > a {
+  color: rgba(255, 255, 255, 0.5);
+}
+.uk-light .uk-nav-default > li > a:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-nav-default > li > a:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-nav-default > li > a:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-nav-default > li > a:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-default > li > a:hover,
+.uk-card-primary.uk-card-body .uk-nav-default > li > a:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-nav-default > li > a:hover,
+.uk-card-secondary.uk-card-body .uk-nav-default > li > a:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-nav-default > li > a:hover,
+.uk-overlay-primary .uk-nav-default > li > a:hover,
+.uk-offcanvas-bar .uk-nav-default > li > a:hover {
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-light .uk-nav-default > li.uk-active > a,
+.uk-section-primary:not(.uk-preserve-color) .uk-nav-default > li.uk-active > a,
+.uk-section-secondary:not(.uk-preserve-color) .uk-nav-default > li.uk-active > a,
+.uk-tile-primary:not(.uk-preserve-color) .uk-nav-default > li.uk-active > a,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-default > li.uk-active > a,
+.uk-card-primary.uk-card-body .uk-nav-default > li.uk-active > a,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-nav-default > li.uk-active > a,
+.uk-card-secondary.uk-card-body .uk-nav-default > li.uk-active > a,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-nav-default > li.uk-active > a,
+.uk-overlay-primary .uk-nav-default > li.uk-active > a,
+.uk-offcanvas-bar .uk-nav-default > li.uk-active > a {
+  color: #fff;
+}
+.uk-light .uk-nav-default .uk-nav-header,
+.uk-section-primary:not(.uk-preserve-color) .uk-nav-default .uk-nav-header,
+.uk-section-secondary:not(.uk-preserve-color) .uk-nav-default .uk-nav-header,
+.uk-tile-primary:not(.uk-preserve-color) .uk-nav-default .uk-nav-header,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-default .uk-nav-header,
+.uk-card-primary.uk-card-body .uk-nav-default .uk-nav-header,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-nav-default .uk-nav-header,
+.uk-card-secondary.uk-card-body .uk-nav-default .uk-nav-header,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-nav-default .uk-nav-header,
+.uk-overlay-primary .uk-nav-default .uk-nav-header,
+.uk-offcanvas-bar .uk-nav-default .uk-nav-header {
+  color: #fff;
+}
+.uk-light .uk-nav-default .uk-nav-divider,
+.uk-section-primary:not(.uk-preserve-color) .uk-nav-default .uk-nav-divider,
+.uk-section-secondary:not(.uk-preserve-color) .uk-nav-default .uk-nav-divider,
+.uk-tile-primary:not(.uk-preserve-color) .uk-nav-default .uk-nav-divider,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-default .uk-nav-divider,
+.uk-card-primary.uk-card-body .uk-nav-default .uk-nav-divider,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-nav-default .uk-nav-divider,
+.uk-card-secondary.uk-card-body .uk-nav-default .uk-nav-divider,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-nav-default .uk-nav-divider,
+.uk-overlay-primary .uk-nav-default .uk-nav-divider,
+.uk-offcanvas-bar .uk-nav-default .uk-nav-divider {
+  border-top-color: rgba(255, 255, 255, 0.2);
+}
+.uk-light .uk-nav-default .uk-nav-sub a,
+.uk-section-primary:not(.uk-preserve-color) .uk-nav-default .uk-nav-sub a,
+.uk-section-secondary:not(.uk-preserve-color) .uk-nav-default .uk-nav-sub a,
+.uk-tile-primary:not(.uk-preserve-color) .uk-nav-default .uk-nav-sub a,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-default .uk-nav-sub a,
+.uk-card-primary.uk-card-body .uk-nav-default .uk-nav-sub a,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-nav-default .uk-nav-sub a,
+.uk-card-secondary.uk-card-body .uk-nav-default .uk-nav-sub a,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-nav-default .uk-nav-sub a,
+.uk-overlay-primary .uk-nav-default .uk-nav-sub a,
+.uk-offcanvas-bar .uk-nav-default .uk-nav-sub a {
+  color: rgba(255, 255, 255, 0.5);
+}
+.uk-light .uk-nav-default .uk-nav-sub a:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-nav-default .uk-nav-sub a:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-nav-default .uk-nav-sub a:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-nav-default .uk-nav-sub a:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-default .uk-nav-sub a:hover,
+.uk-card-primary.uk-card-body .uk-nav-default .uk-nav-sub a:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-nav-default .uk-nav-sub a:hover,
+.uk-card-secondary.uk-card-body .uk-nav-default .uk-nav-sub a:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-nav-default .uk-nav-sub a:hover,
+.uk-overlay-primary .uk-nav-default .uk-nav-sub a:hover,
+.uk-offcanvas-bar .uk-nav-default .uk-nav-sub a:hover {
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-light .uk-nav-default .uk-nav-sub li.uk-active > a,
+.uk-section-primary:not(.uk-preserve-color) .uk-nav-default .uk-nav-sub li.uk-active > a,
+.uk-section-secondary:not(.uk-preserve-color) .uk-nav-default .uk-nav-sub li.uk-active > a,
+.uk-tile-primary:not(.uk-preserve-color) .uk-nav-default .uk-nav-sub li.uk-active > a,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-default .uk-nav-sub li.uk-active > a,
+.uk-card-primary.uk-card-body .uk-nav-default .uk-nav-sub li.uk-active > a,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-nav-default .uk-nav-sub li.uk-active > a,
+.uk-card-secondary.uk-card-body .uk-nav-default .uk-nav-sub li.uk-active > a,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-nav-default .uk-nav-sub li.uk-active > a,
+.uk-overlay-primary .uk-nav-default .uk-nav-sub li.uk-active > a,
+.uk-offcanvas-bar .uk-nav-default .uk-nav-sub li.uk-active > a {
+  color: #fff;
+}
+.uk-light .uk-nav-primary > li > a,
+.uk-section-primary:not(.uk-preserve-color) .uk-nav-primary > li > a,
+.uk-section-secondary:not(.uk-preserve-color) .uk-nav-primary > li > a,
+.uk-tile-primary:not(.uk-preserve-color) .uk-nav-primary > li > a,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-primary > li > a,
+.uk-card-primary.uk-card-body .uk-nav-primary > li > a,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-nav-primary > li > a,
+.uk-card-secondary.uk-card-body .uk-nav-primary > li > a,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-nav-primary > li > a,
+.uk-overlay-primary .uk-nav-primary > li > a,
+.uk-offcanvas-bar .uk-nav-primary > li > a {
+  color: rgba(255, 255, 255, 0.5);
+}
+.uk-light .uk-nav-primary > li > a:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-nav-primary > li > a:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-nav-primary > li > a:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-nav-primary > li > a:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-primary > li > a:hover,
+.uk-card-primary.uk-card-body .uk-nav-primary > li > a:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-nav-primary > li > a:hover,
+.uk-card-secondary.uk-card-body .uk-nav-primary > li > a:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-nav-primary > li > a:hover,
+.uk-overlay-primary .uk-nav-primary > li > a:hover,
+.uk-offcanvas-bar .uk-nav-primary > li > a:hover {
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-light .uk-nav-primary > li.uk-active > a,
+.uk-section-primary:not(.uk-preserve-color) .uk-nav-primary > li.uk-active > a,
+.uk-section-secondary:not(.uk-preserve-color) .uk-nav-primary > li.uk-active > a,
+.uk-tile-primary:not(.uk-preserve-color) .uk-nav-primary > li.uk-active > a,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-primary > li.uk-active > a,
+.uk-card-primary.uk-card-body .uk-nav-primary > li.uk-active > a,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-nav-primary > li.uk-active > a,
+.uk-card-secondary.uk-card-body .uk-nav-primary > li.uk-active > a,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-nav-primary > li.uk-active > a,
+.uk-overlay-primary .uk-nav-primary > li.uk-active > a,
+.uk-offcanvas-bar .uk-nav-primary > li.uk-active > a {
+  color: #fff;
+}
+.uk-light .uk-nav-primary .uk-nav-header,
+.uk-section-primary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-header,
+.uk-section-secondary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-header,
+.uk-tile-primary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-header,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-header,
+.uk-card-primary.uk-card-body .uk-nav-primary .uk-nav-header,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-nav-primary .uk-nav-header,
+.uk-card-secondary.uk-card-body .uk-nav-primary .uk-nav-header,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-nav-primary .uk-nav-header,
+.uk-overlay-primary .uk-nav-primary .uk-nav-header,
+.uk-offcanvas-bar .uk-nav-primary .uk-nav-header {
+  color: #fff;
+}
+.uk-light .uk-nav-primary .uk-nav-divider,
+.uk-section-primary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-divider,
+.uk-section-secondary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-divider,
+.uk-tile-primary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-divider,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-divider,
+.uk-card-primary.uk-card-body .uk-nav-primary .uk-nav-divider,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-nav-primary .uk-nav-divider,
+.uk-card-secondary.uk-card-body .uk-nav-primary .uk-nav-divider,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-nav-primary .uk-nav-divider,
+.uk-overlay-primary .uk-nav-primary .uk-nav-divider,
+.uk-offcanvas-bar .uk-nav-primary .uk-nav-divider {
+  border-top-color: rgba(255, 255, 255, 0.2);
+}
+.uk-light .uk-nav-primary .uk-nav-sub a,
+.uk-section-primary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-sub a,
+.uk-section-secondary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-sub a,
+.uk-tile-primary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-sub a,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-sub a,
+.uk-card-primary.uk-card-body .uk-nav-primary .uk-nav-sub a,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-nav-primary .uk-nav-sub a,
+.uk-card-secondary.uk-card-body .uk-nav-primary .uk-nav-sub a,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-nav-primary .uk-nav-sub a,
+.uk-overlay-primary .uk-nav-primary .uk-nav-sub a,
+.uk-offcanvas-bar .uk-nav-primary .uk-nav-sub a {
+  color: rgba(255, 255, 255, 0.5);
+}
+.uk-light .uk-nav-primary .uk-nav-sub a:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-sub a:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-sub a:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-sub a:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-sub a:hover,
+.uk-card-primary.uk-card-body .uk-nav-primary .uk-nav-sub a:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-nav-primary .uk-nav-sub a:hover,
+.uk-card-secondary.uk-card-body .uk-nav-primary .uk-nav-sub a:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-nav-primary .uk-nav-sub a:hover,
+.uk-overlay-primary .uk-nav-primary .uk-nav-sub a:hover,
+.uk-offcanvas-bar .uk-nav-primary .uk-nav-sub a:hover {
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-light .uk-nav-primary .uk-nav-sub li.uk-active > a,
+.uk-section-primary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-sub li.uk-active > a,
+.uk-section-secondary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-sub li.uk-active > a,
+.uk-tile-primary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-sub li.uk-active > a,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-primary .uk-nav-sub li.uk-active > a,
+.uk-card-primary.uk-card-body .uk-nav-primary .uk-nav-sub li.uk-active > a,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-nav-primary .uk-nav-sub li.uk-active > a,
+.uk-card-secondary.uk-card-body .uk-nav-primary .uk-nav-sub li.uk-active > a,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-nav-primary .uk-nav-sub li.uk-active > a,
+.uk-overlay-primary .uk-nav-primary .uk-nav-sub li.uk-active > a,
+.uk-offcanvas-bar .uk-nav-primary .uk-nav-sub li.uk-active > a {
+  color: #fff;
+}
+.uk-light .uk-nav-secondary > li > a,
+.uk-section-primary:not(.uk-preserve-color) .uk-nav-secondary > li > a,
+.uk-section-secondary:not(.uk-preserve-color) .uk-nav-secondary > li > a,
+.uk-tile-primary:not(.uk-preserve-color) .uk-nav-secondary > li > a,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-secondary > li > a,
+.uk-card-primary.uk-card-body .uk-nav-secondary > li > a,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-nav-secondary > li > a,
+.uk-card-secondary.uk-card-body .uk-nav-secondary > li > a,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-nav-secondary > li > a,
+.uk-overlay-primary .uk-nav-secondary > li > a,
+.uk-offcanvas-bar .uk-nav-secondary > li > a {
+  color: #fff;
+}
+.uk-light .uk-nav-secondary > li > a:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-nav-secondary > li > a:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-nav-secondary > li > a:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-nav-secondary > li > a:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-secondary > li > a:hover,
+.uk-card-primary.uk-card-body .uk-nav-secondary > li > a:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-nav-secondary > li > a:hover,
+.uk-card-secondary.uk-card-body .uk-nav-secondary > li > a:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-nav-secondary > li > a:hover,
+.uk-overlay-primary .uk-nav-secondary > li > a:hover,
+.uk-offcanvas-bar .uk-nav-secondary > li > a:hover {
+  color: #fff;
+  background-color: rgba(255, 255, 255, 0.1);
+}
+.uk-light .uk-nav-secondary > li.uk-active > a,
+.uk-section-primary:not(.uk-preserve-color) .uk-nav-secondary > li.uk-active > a,
+.uk-section-secondary:not(.uk-preserve-color) .uk-nav-secondary > li.uk-active > a,
+.uk-tile-primary:not(.uk-preserve-color) .uk-nav-secondary > li.uk-active > a,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-secondary > li.uk-active > a,
+.uk-card-primary.uk-card-body .uk-nav-secondary > li.uk-active > a,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-nav-secondary > li.uk-active > a,
+.uk-card-secondary.uk-card-body .uk-nav-secondary > li.uk-active > a,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-nav-secondary > li.uk-active > a,
+.uk-overlay-primary .uk-nav-secondary > li.uk-active > a,
+.uk-offcanvas-bar .uk-nav-secondary > li.uk-active > a {
+  color: #fff;
+  background-color: rgba(255, 255, 255, 0.1);
+}
+.uk-light .uk-nav-secondary .uk-nav-subtitle,
+.uk-section-primary:not(.uk-preserve-color) .uk-nav-secondary .uk-nav-subtitle,
+.uk-section-secondary:not(.uk-preserve-color) .uk-nav-secondary .uk-nav-subtitle,
+.uk-tile-primary:not(.uk-preserve-color) .uk-nav-secondary .uk-nav-subtitle,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-secondary .uk-nav-subtitle,
+.uk-card-primary.uk-card-body .uk-nav-secondary .uk-nav-subtitle,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-nav-secondary .uk-nav-subtitle,
+.uk-card-secondary.uk-card-body .uk-nav-secondary .uk-nav-subtitle,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-nav-secondary .uk-nav-subtitle,
+.uk-overlay-primary .uk-nav-secondary .uk-nav-subtitle,
+.uk-offcanvas-bar .uk-nav-secondary .uk-nav-subtitle {
+  color: rgba(255, 255, 255, 0.5);
+}
+.uk-light .uk-nav-secondary > li > a:hover .uk-nav-subtitle,
+.uk-section-primary:not(.uk-preserve-color) .uk-nav-secondary > li > a:hover .uk-nav-subtitle,
+.uk-section-secondary:not(.uk-preserve-color) .uk-nav-secondary > li > a:hover .uk-nav-subtitle,
+.uk-tile-primary:not(.uk-preserve-color) .uk-nav-secondary > li > a:hover .uk-nav-subtitle,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-secondary > li > a:hover .uk-nav-subtitle,
+.uk-card-primary.uk-card-body .uk-nav-secondary > li > a:hover .uk-nav-subtitle,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-nav-secondary > li > a:hover .uk-nav-subtitle,
+.uk-card-secondary.uk-card-body .uk-nav-secondary > li > a:hover .uk-nav-subtitle,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-nav-secondary > li > a:hover .uk-nav-subtitle,
+.uk-overlay-primary .uk-nav-secondary > li > a:hover .uk-nav-subtitle,
+.uk-offcanvas-bar .uk-nav-secondary > li > a:hover .uk-nav-subtitle {
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-light .uk-nav-secondary > li.uk-active > a .uk-nav-subtitle,
+.uk-section-primary:not(.uk-preserve-color) .uk-nav-secondary > li.uk-active > a .uk-nav-subtitle,
+.uk-section-secondary:not(.uk-preserve-color) .uk-nav-secondary > li.uk-active > a .uk-nav-subtitle,
+.uk-tile-primary:not(.uk-preserve-color) .uk-nav-secondary > li.uk-active > a .uk-nav-subtitle,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-secondary > li.uk-active > a .uk-nav-subtitle,
+.uk-card-primary.uk-card-body .uk-nav-secondary > li.uk-active > a .uk-nav-subtitle,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-nav-secondary > li.uk-active > a .uk-nav-subtitle,
+.uk-card-secondary.uk-card-body .uk-nav-secondary > li.uk-active > a .uk-nav-subtitle,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-nav-secondary > li.uk-active > a .uk-nav-subtitle,
+.uk-overlay-primary .uk-nav-secondary > li.uk-active > a .uk-nav-subtitle,
+.uk-offcanvas-bar .uk-nav-secondary > li.uk-active > a .uk-nav-subtitle {
+  color: #fff;
+}
+.uk-light .uk-nav-secondary .uk-nav-header,
+.uk-section-primary:not(.uk-preserve-color) .uk-nav-secondary .uk-nav-header,
+.uk-section-secondary:not(.uk-preserve-color) .uk-nav-secondary .uk-nav-header,
+.uk-tile-primary:not(.uk-preserve-color) .uk-nav-secondary .uk-nav-header,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-secondary .uk-nav-header,
+.uk-card-primary.uk-card-body .uk-nav-secondary .uk-nav-header,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-nav-secondary .uk-nav-header,
+.uk-card-secondary.uk-card-body .uk-nav-secondary .uk-nav-header,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-nav-secondary .uk-nav-header,
+.uk-overlay-primary .uk-nav-secondary .uk-nav-header,
+.uk-offcanvas-bar .uk-nav-secondary .uk-nav-header {
+  color: #fff;
+}
+.uk-light .uk-nav-secondary .uk-nav-divider,
+.uk-section-primary:not(.uk-preserve-color) .uk-nav-secondary .uk-nav-divider,
+.uk-section-secondary:not(.uk-preserve-color) .uk-nav-secondary .uk-nav-divider,
+.uk-tile-primary:not(.uk-preserve-color) .uk-nav-secondary .uk-nav-divider,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-secondary .uk-nav-divider,
+.uk-card-primary.uk-card-body .uk-nav-secondary .uk-nav-divider,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-nav-secondary .uk-nav-divider,
+.uk-card-secondary.uk-card-body .uk-nav-secondary .uk-nav-divider,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-nav-secondary .uk-nav-divider,
+.uk-overlay-primary .uk-nav-secondary .uk-nav-divider,
+.uk-offcanvas-bar .uk-nav-secondary .uk-nav-divider {
+  border-top-color: rgba(255, 255, 255, 0.2);
+}
+.uk-light .uk-nav-secondary .uk-nav-sub a,
+.uk-section-primary:not(.uk-preserve-color) .uk-nav-secondary .uk-nav-sub a,
+.uk-section-secondary:not(.uk-preserve-color) .uk-nav-secondary .uk-nav-sub a,
+.uk-tile-primary:not(.uk-preserve-color) .uk-nav-secondary .uk-nav-sub a,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-secondary .uk-nav-sub a,
+.uk-card-primary.uk-card-body .uk-nav-secondary .uk-nav-sub a,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-nav-secondary .uk-nav-sub a,
+.uk-card-secondary.uk-card-body .uk-nav-secondary .uk-nav-sub a,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-nav-secondary .uk-nav-sub a,
+.uk-overlay-primary .uk-nav-secondary .uk-nav-sub a,
+.uk-offcanvas-bar .uk-nav-secondary .uk-nav-sub a {
+  color: rgba(255, 255, 255, 0.5);
+}
+.uk-light .uk-nav-secondary .uk-nav-sub a:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-nav-secondary .uk-nav-sub a:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-nav-secondary .uk-nav-sub a:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-nav-secondary .uk-nav-sub a:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-secondary .uk-nav-sub a:hover,
+.uk-card-primary.uk-card-body .uk-nav-secondary .uk-nav-sub a:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-nav-secondary .uk-nav-sub a:hover,
+.uk-card-secondary.uk-card-body .uk-nav-secondary .uk-nav-sub a:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-nav-secondary .uk-nav-sub a:hover,
+.uk-overlay-primary .uk-nav-secondary .uk-nav-sub a:hover,
+.uk-offcanvas-bar .uk-nav-secondary .uk-nav-sub a:hover {
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-light .uk-nav-secondary .uk-nav-sub li.uk-active > a,
+.uk-section-primary:not(.uk-preserve-color) .uk-nav-secondary .uk-nav-sub li.uk-active > a,
+.uk-section-secondary:not(.uk-preserve-color) .uk-nav-secondary .uk-nav-sub li.uk-active > a,
+.uk-tile-primary:not(.uk-preserve-color) .uk-nav-secondary .uk-nav-sub li.uk-active > a,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-nav-secondary .uk-nav-sub li.uk-active > a,
+.uk-card-primary.uk-card-body .uk-nav-secondary .uk-nav-sub li.uk-active > a,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-nav-secondary .uk-nav-sub li.uk-active > a,
+.uk-card-secondary.uk-card-body .uk-nav-secondary .uk-nav-sub li.uk-active > a,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-nav-secondary .uk-nav-sub li.uk-active > a,
+.uk-overlay-primary .uk-nav-secondary .uk-nav-sub li.uk-active > a,
+.uk-offcanvas-bar .uk-nav-secondary .uk-nav-sub li.uk-active > a {
+  color: #fff;
+}
+.uk-light .uk-nav.uk-nav-divider > :not(.uk-nav-divider) + :not(.uk-nav-header, .uk-nav-divider),
+.uk-section-primary:not(.uk-preserve-color) .uk-nav.uk-nav-divider > :not(.uk-nav-divider) + :not(.uk-nav-header, .uk-nav-divider),
+.uk-section-secondary:not(.uk-preserve-color) .uk-nav.uk-nav-divider > :not(.uk-nav-divider) + :not(.uk-nav-header, .uk-nav-divider),
+.uk-tile-primary:not(.uk-preserve-color) .uk-nav.uk-nav-divider > :not(.uk-nav-divider) + :not(.uk-nav-header, .uk-nav-divider),
+.uk-tile-secondary:not(.uk-preserve-color) .uk-nav.uk-nav-divider > :not(.uk-nav-divider) + :not(.uk-nav-header, .uk-nav-divider),
+.uk-card-primary.uk-card-body .uk-nav.uk-nav-divider > :not(.uk-nav-divider) + :not(.uk-nav-header, .uk-nav-divider),
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-nav.uk-nav-divider > :not(.uk-nav-divider) + :not(.uk-nav-header, .uk-nav-divider),
+.uk-card-secondary.uk-card-body .uk-nav.uk-nav-divider > :not(.uk-nav-divider) + :not(.uk-nav-header, .uk-nav-divider),
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-nav.uk-nav-divider > :not(.uk-nav-divider) + :not(.uk-nav-header, .uk-nav-divider),
+.uk-overlay-primary .uk-nav.uk-nav-divider > :not(.uk-nav-divider) + :not(.uk-nav-header, .uk-nav-divider),
+.uk-offcanvas-bar .uk-nav.uk-nav-divider > :not(.uk-nav-divider) + :not(.uk-nav-header, .uk-nav-divider) {
+  border-top-color: rgba(255, 255, 255, 0.2);
+}
+.uk-light .uk-navbar-nav > li > a,
+.uk-section-primary:not(.uk-preserve-color) .uk-navbar-nav > li > a,
+.uk-section-secondary:not(.uk-preserve-color) .uk-navbar-nav > li > a,
+.uk-tile-primary:not(.uk-preserve-color) .uk-navbar-nav > li > a,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-navbar-nav > li > a,
+.uk-card-primary.uk-card-body .uk-navbar-nav > li > a,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-navbar-nav > li > a,
+.uk-card-secondary.uk-card-body .uk-navbar-nav > li > a,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-navbar-nav > li > a,
+.uk-overlay-primary .uk-navbar-nav > li > a,
+.uk-offcanvas-bar .uk-navbar-nav > li > a {
+  color: rgba(255, 255, 255, 0.5);
+}
+.uk-light .uk-navbar-nav > li:hover > a,
+.uk-light .uk-navbar-nav > li > a[aria-expanded="true"],
+.uk-section-primary:not(.uk-preserve-color) .uk-navbar-nav > li:hover > a,
+.uk-section-primary:not(.uk-preserve-color) .uk-navbar-nav > li > a[aria-expanded="true"],
+.uk-section-secondary:not(.uk-preserve-color) .uk-navbar-nav > li:hover > a,
+.uk-section-secondary:not(.uk-preserve-color) .uk-navbar-nav > li > a[aria-expanded="true"],
+.uk-tile-primary:not(.uk-preserve-color) .uk-navbar-nav > li:hover > a,
+.uk-tile-primary:not(.uk-preserve-color) .uk-navbar-nav > li > a[aria-expanded="true"],
+.uk-tile-secondary:not(.uk-preserve-color) .uk-navbar-nav > li:hover > a,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-navbar-nav > li > a[aria-expanded="true"],
+.uk-card-primary.uk-card-body .uk-navbar-nav > li:hover > a,
+.uk-card-primary.uk-card-body .uk-navbar-nav > li > a[aria-expanded="true"],
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-navbar-nav > li:hover > a,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-navbar-nav > li > a[aria-expanded="true"],
+.uk-card-secondary.uk-card-body .uk-navbar-nav > li:hover > a,
+.uk-card-secondary.uk-card-body .uk-navbar-nav > li > a[aria-expanded="true"],
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-navbar-nav > li:hover > a,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-navbar-nav > li > a[aria-expanded="true"],
+.uk-overlay-primary .uk-navbar-nav > li:hover > a,
+.uk-overlay-primary .uk-navbar-nav > li > a[aria-expanded="true"],
+.uk-offcanvas-bar .uk-navbar-nav > li:hover > a,
+.uk-offcanvas-bar .uk-navbar-nav > li > a[aria-expanded="true"] {
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-light .uk-navbar-nav > li > a:active,
+.uk-section-primary:not(.uk-preserve-color) .uk-navbar-nav > li > a:active,
+.uk-section-secondary:not(.uk-preserve-color) .uk-navbar-nav > li > a:active,
+.uk-tile-primary:not(.uk-preserve-color) .uk-navbar-nav > li > a:active,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-navbar-nav > li > a:active,
+.uk-card-primary.uk-card-body .uk-navbar-nav > li > a:active,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-navbar-nav > li > a:active,
+.uk-card-secondary.uk-card-body .uk-navbar-nav > li > a:active,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-navbar-nav > li > a:active,
+.uk-overlay-primary .uk-navbar-nav > li > a:active,
+.uk-offcanvas-bar .uk-navbar-nav > li > a:active {
+  color: #fff;
+}
+.uk-light .uk-navbar-nav > li.uk-active > a,
+.uk-section-primary:not(.uk-preserve-color) .uk-navbar-nav > li.uk-active > a,
+.uk-section-secondary:not(.uk-preserve-color) .uk-navbar-nav > li.uk-active > a,
+.uk-tile-primary:not(.uk-preserve-color) .uk-navbar-nav > li.uk-active > a,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-navbar-nav > li.uk-active > a,
+.uk-card-primary.uk-card-body .uk-navbar-nav > li.uk-active > a,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-navbar-nav > li.uk-active > a,
+.uk-card-secondary.uk-card-body .uk-navbar-nav > li.uk-active > a,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-navbar-nav > li.uk-active > a,
+.uk-overlay-primary .uk-navbar-nav > li.uk-active > a,
+.uk-offcanvas-bar .uk-navbar-nav > li.uk-active > a {
+  color: #fff;
+}
+.uk-light .uk-navbar-item,
+.uk-section-primary:not(.uk-preserve-color) .uk-navbar-item,
+.uk-section-secondary:not(.uk-preserve-color) .uk-navbar-item,
+.uk-tile-primary:not(.uk-preserve-color) .uk-navbar-item,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-navbar-item,
+.uk-card-primary.uk-card-body .uk-navbar-item,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-navbar-item,
+.uk-card-secondary.uk-card-body .uk-navbar-item,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-navbar-item,
+.uk-overlay-primary .uk-navbar-item,
+.uk-offcanvas-bar .uk-navbar-item {
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-light .uk-navbar-toggle,
+.uk-section-primary:not(.uk-preserve-color) .uk-navbar-toggle,
+.uk-section-secondary:not(.uk-preserve-color) .uk-navbar-toggle,
+.uk-tile-primary:not(.uk-preserve-color) .uk-navbar-toggle,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-navbar-toggle,
+.uk-card-primary.uk-card-body .uk-navbar-toggle,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-navbar-toggle,
+.uk-card-secondary.uk-card-body .uk-navbar-toggle,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-navbar-toggle,
+.uk-overlay-primary .uk-navbar-toggle,
+.uk-offcanvas-bar .uk-navbar-toggle {
+  color: rgba(255, 255, 255, 0.5);
+}
+.uk-light .uk-navbar-toggle:hover,
+.uk-light .uk-navbar-toggle[aria-expanded="true"],
+.uk-section-primary:not(.uk-preserve-color) .uk-navbar-toggle:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-navbar-toggle[aria-expanded="true"],
+.uk-section-secondary:not(.uk-preserve-color) .uk-navbar-toggle:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-navbar-toggle[aria-expanded="true"],
+.uk-tile-primary:not(.uk-preserve-color) .uk-navbar-toggle:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-navbar-toggle[aria-expanded="true"],
+.uk-tile-secondary:not(.uk-preserve-color) .uk-navbar-toggle:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-navbar-toggle[aria-expanded="true"],
+.uk-card-primary.uk-card-body .uk-navbar-toggle:hover,
+.uk-card-primary.uk-card-body .uk-navbar-toggle[aria-expanded="true"],
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-navbar-toggle:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-navbar-toggle[aria-expanded="true"],
+.uk-card-secondary.uk-card-body .uk-navbar-toggle:hover,
+.uk-card-secondary.uk-card-body .uk-navbar-toggle[aria-expanded="true"],
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-navbar-toggle:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-navbar-toggle[aria-expanded="true"],
+.uk-overlay-primary .uk-navbar-toggle:hover,
+.uk-overlay-primary .uk-navbar-toggle[aria-expanded="true"],
+.uk-offcanvas-bar .uk-navbar-toggle:hover,
+.uk-offcanvas-bar .uk-navbar-toggle[aria-expanded="true"] {
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-light .uk-subnav > * > :first-child,
+.uk-section-primary:not(.uk-preserve-color) .uk-subnav > * > :first-child,
+.uk-section-secondary:not(.uk-preserve-color) .uk-subnav > * > :first-child,
+.uk-tile-primary:not(.uk-preserve-color) .uk-subnav > * > :first-child,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-subnav > * > :first-child,
+.uk-card-primary.uk-card-body .uk-subnav > * > :first-child,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-subnav > * > :first-child,
+.uk-card-secondary.uk-card-body .uk-subnav > * > :first-child,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-subnav > * > :first-child,
+.uk-overlay-primary .uk-subnav > * > :first-child,
+.uk-offcanvas-bar .uk-subnav > * > :first-child {
+  color: rgba(255, 255, 255, 0.5);
+}
+.uk-light .uk-subnav > * > a:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-subnav > * > a:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-subnav > * > a:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-subnav > * > a:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-subnav > * > a:hover,
+.uk-card-primary.uk-card-body .uk-subnav > * > a:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-subnav > * > a:hover,
+.uk-card-secondary.uk-card-body .uk-subnav > * > a:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-subnav > * > a:hover,
+.uk-overlay-primary .uk-subnav > * > a:hover,
+.uk-offcanvas-bar .uk-subnav > * > a:hover {
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-light .uk-subnav > .uk-active > a,
+.uk-section-primary:not(.uk-preserve-color) .uk-subnav > .uk-active > a,
+.uk-section-secondary:not(.uk-preserve-color) .uk-subnav > .uk-active > a,
+.uk-tile-primary:not(.uk-preserve-color) .uk-subnav > .uk-active > a,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-subnav > .uk-active > a,
+.uk-card-primary.uk-card-body .uk-subnav > .uk-active > a,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-subnav > .uk-active > a,
+.uk-card-secondary.uk-card-body .uk-subnav > .uk-active > a,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-subnav > .uk-active > a,
+.uk-overlay-primary .uk-subnav > .uk-active > a,
+.uk-offcanvas-bar .uk-subnav > .uk-active > a {
+  color: #fff;
+}
+.uk-light .uk-subnav-divider > :nth-child(n+2):not(.uk-first-column)::before,
+.uk-section-primary:not(.uk-preserve-color) .uk-subnav-divider > :nth-child(n+2):not(.uk-first-column)::before,
+.uk-section-secondary:not(.uk-preserve-color) .uk-subnav-divider > :nth-child(n+2):not(.uk-first-column)::before,
+.uk-tile-primary:not(.uk-preserve-color) .uk-subnav-divider > :nth-child(n+2):not(.uk-first-column)::before,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-subnav-divider > :nth-child(n+2):not(.uk-first-column)::before,
+.uk-card-primary.uk-card-body .uk-subnav-divider > :nth-child(n+2):not(.uk-first-column)::before,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-subnav-divider > :nth-child(n+2):not(.uk-first-column)::before,
+.uk-card-secondary.uk-card-body .uk-subnav-divider > :nth-child(n+2):not(.uk-first-column)::before,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-subnav-divider > :nth-child(n+2):not(.uk-first-column)::before,
+.uk-overlay-primary .uk-subnav-divider > :nth-child(n+2):not(.uk-first-column)::before,
+.uk-offcanvas-bar .uk-subnav-divider > :nth-child(n+2):not(.uk-first-column)::before {
+  border-left-color: rgba(255, 255, 255, 0.2);
+}
+.uk-light .uk-subnav-pill > * > :first-child,
+.uk-section-primary:not(.uk-preserve-color) .uk-subnav-pill > * > :first-child,
+.uk-section-secondary:not(.uk-preserve-color) .uk-subnav-pill > * > :first-child,
+.uk-tile-primary:not(.uk-preserve-color) .uk-subnav-pill > * > :first-child,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-subnav-pill > * > :first-child,
+.uk-card-primary.uk-card-body .uk-subnav-pill > * > :first-child,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-subnav-pill > * > :first-child,
+.uk-card-secondary.uk-card-body .uk-subnav-pill > * > :first-child,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-subnav-pill > * > :first-child,
+.uk-overlay-primary .uk-subnav-pill > * > :first-child,
+.uk-offcanvas-bar .uk-subnav-pill > * > :first-child {
+  background-color: transparent;
+  color: rgba(255, 255, 255, 0.5);
+}
+.uk-light .uk-subnav-pill > * > a:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-subnav-pill > * > a:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-subnav-pill > * > a:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-subnav-pill > * > a:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-subnav-pill > * > a:hover,
+.uk-card-primary.uk-card-body .uk-subnav-pill > * > a:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-subnav-pill > * > a:hover,
+.uk-card-secondary.uk-card-body .uk-subnav-pill > * > a:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-subnav-pill > * > a:hover,
+.uk-overlay-primary .uk-subnav-pill > * > a:hover,
+.uk-offcanvas-bar .uk-subnav-pill > * > a:hover {
+  background-color: rgba(255, 255, 255, 0.1);
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-light .uk-subnav-pill > * > a:active,
+.uk-section-primary:not(.uk-preserve-color) .uk-subnav-pill > * > a:active,
+.uk-section-secondary:not(.uk-preserve-color) .uk-subnav-pill > * > a:active,
+.uk-tile-primary:not(.uk-preserve-color) .uk-subnav-pill > * > a:active,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-subnav-pill > * > a:active,
+.uk-card-primary.uk-card-body .uk-subnav-pill > * > a:active,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-subnav-pill > * > a:active,
+.uk-card-secondary.uk-card-body .uk-subnav-pill > * > a:active,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-subnav-pill > * > a:active,
+.uk-overlay-primary .uk-subnav-pill > * > a:active,
+.uk-offcanvas-bar .uk-subnav-pill > * > a:active {
+  background-color: rgba(255, 255, 255, 0.1);
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-light .uk-subnav-pill > .uk-active > a,
+.uk-section-primary:not(.uk-preserve-color) .uk-subnav-pill > .uk-active > a,
+.uk-section-secondary:not(.uk-preserve-color) .uk-subnav-pill > .uk-active > a,
+.uk-tile-primary:not(.uk-preserve-color) .uk-subnav-pill > .uk-active > a,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-subnav-pill > .uk-active > a,
+.uk-card-primary.uk-card-body .uk-subnav-pill > .uk-active > a,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-subnav-pill > .uk-active > a,
+.uk-card-secondary.uk-card-body .uk-subnav-pill > .uk-active > a,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-subnav-pill > .uk-active > a,
+.uk-overlay-primary .uk-subnav-pill > .uk-active > a,
+.uk-offcanvas-bar .uk-subnav-pill > .uk-active > a {
+  background-color: #fff;
+  color: #666;
+}
+.uk-light .uk-subnav > .uk-disabled > a,
+.uk-section-primary:not(.uk-preserve-color) .uk-subnav > .uk-disabled > a,
+.uk-section-secondary:not(.uk-preserve-color) .uk-subnav > .uk-disabled > a,
+.uk-tile-primary:not(.uk-preserve-color) .uk-subnav > .uk-disabled > a,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-subnav > .uk-disabled > a,
+.uk-card-primary.uk-card-body .uk-subnav > .uk-disabled > a,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-subnav > .uk-disabled > a,
+.uk-card-secondary.uk-card-body .uk-subnav > .uk-disabled > a,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-subnav > .uk-disabled > a,
+.uk-overlay-primary .uk-subnav > .uk-disabled > a,
+.uk-offcanvas-bar .uk-subnav > .uk-disabled > a {
+  color: rgba(255, 255, 255, 0.5);
+}
+.uk-light .uk-breadcrumb > * > *,
+.uk-section-primary:not(.uk-preserve-color) .uk-breadcrumb > * > *,
+.uk-section-secondary:not(.uk-preserve-color) .uk-breadcrumb > * > *,
+.uk-tile-primary:not(.uk-preserve-color) .uk-breadcrumb > * > *,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-breadcrumb > * > *,
+.uk-card-primary.uk-card-body .uk-breadcrumb > * > *,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-breadcrumb > * > *,
+.uk-card-secondary.uk-card-body .uk-breadcrumb > * > *,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-breadcrumb > * > *,
+.uk-overlay-primary .uk-breadcrumb > * > *,
+.uk-offcanvas-bar .uk-breadcrumb > * > * {
+  color: rgba(255, 255, 255, 0.5);
+}
+.uk-light .uk-breadcrumb > * > :hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-breadcrumb > * > :hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-breadcrumb > * > :hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-breadcrumb > * > :hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-breadcrumb > * > :hover,
+.uk-card-primary.uk-card-body .uk-breadcrumb > * > :hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-breadcrumb > * > :hover,
+.uk-card-secondary.uk-card-body .uk-breadcrumb > * > :hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-breadcrumb > * > :hover,
+.uk-overlay-primary .uk-breadcrumb > * > :hover,
+.uk-offcanvas-bar .uk-breadcrumb > * > :hover {
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-light .uk-breadcrumb > :last-child > *,
+.uk-section-primary:not(.uk-preserve-color) .uk-breadcrumb > :last-child > *,
+.uk-section-secondary:not(.uk-preserve-color) .uk-breadcrumb > :last-child > *,
+.uk-tile-primary:not(.uk-preserve-color) .uk-breadcrumb > :last-child > *,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-breadcrumb > :last-child > *,
+.uk-card-primary.uk-card-body .uk-breadcrumb > :last-child > *,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-breadcrumb > :last-child > *,
+.uk-card-secondary.uk-card-body .uk-breadcrumb > :last-child > *,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-breadcrumb > :last-child > *,
+.uk-overlay-primary .uk-breadcrumb > :last-child > *,
+.uk-offcanvas-bar .uk-breadcrumb > :last-child > * {
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-light .uk-breadcrumb > :nth-child(n+2):not(.uk-first-column)::before,
+.uk-section-primary:not(.uk-preserve-color) .uk-breadcrumb > :nth-child(n+2):not(.uk-first-column)::before,
+.uk-section-secondary:not(.uk-preserve-color) .uk-breadcrumb > :nth-child(n+2):not(.uk-first-column)::before,
+.uk-tile-primary:not(.uk-preserve-color) .uk-breadcrumb > :nth-child(n+2):not(.uk-first-column)::before,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-breadcrumb > :nth-child(n+2):not(.uk-first-column)::before,
+.uk-card-primary.uk-card-body .uk-breadcrumb > :nth-child(n+2):not(.uk-first-column)::before,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-breadcrumb > :nth-child(n+2):not(.uk-first-column)::before,
+.uk-card-secondary.uk-card-body .uk-breadcrumb > :nth-child(n+2):not(.uk-first-column)::before,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-breadcrumb > :nth-child(n+2):not(.uk-first-column)::before,
+.uk-overlay-primary .uk-breadcrumb > :nth-child(n+2):not(.uk-first-column)::before,
+.uk-offcanvas-bar .uk-breadcrumb > :nth-child(n+2):not(.uk-first-column)::before {
+  color: rgba(255, 255, 255, 0.5);
+}
+.uk-light .uk-pagination > * > *,
+.uk-section-primary:not(.uk-preserve-color) .uk-pagination > * > *,
+.uk-section-secondary:not(.uk-preserve-color) .uk-pagination > * > *,
+.uk-tile-primary:not(.uk-preserve-color) .uk-pagination > * > *,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-pagination > * > *,
+.uk-card-primary.uk-card-body .uk-pagination > * > *,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-pagination > * > *,
+.uk-card-secondary.uk-card-body .uk-pagination > * > *,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-pagination > * > *,
+.uk-overlay-primary .uk-pagination > * > *,
+.uk-offcanvas-bar .uk-pagination > * > * {
+  color: rgba(255, 255, 255, 0.5);
+}
+.uk-light .uk-pagination > * > :hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-pagination > * > :hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-pagination > * > :hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-pagination > * > :hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-pagination > * > :hover,
+.uk-card-primary.uk-card-body .uk-pagination > * > :hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-pagination > * > :hover,
+.uk-card-secondary.uk-card-body .uk-pagination > * > :hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-pagination > * > :hover,
+.uk-overlay-primary .uk-pagination > * > :hover,
+.uk-offcanvas-bar .uk-pagination > * > :hover {
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-light .uk-pagination > .uk-active > *,
+.uk-section-primary:not(.uk-preserve-color) .uk-pagination > .uk-active > *,
+.uk-section-secondary:not(.uk-preserve-color) .uk-pagination > .uk-active > *,
+.uk-tile-primary:not(.uk-preserve-color) .uk-pagination > .uk-active > *,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-pagination > .uk-active > *,
+.uk-card-primary.uk-card-body .uk-pagination > .uk-active > *,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-pagination > .uk-active > *,
+.uk-card-secondary.uk-card-body .uk-pagination > .uk-active > *,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-pagination > .uk-active > *,
+.uk-overlay-primary .uk-pagination > .uk-active > *,
+.uk-offcanvas-bar .uk-pagination > .uk-active > * {
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-light .uk-pagination > .uk-disabled > *,
+.uk-section-primary:not(.uk-preserve-color) .uk-pagination > .uk-disabled > *,
+.uk-section-secondary:not(.uk-preserve-color) .uk-pagination > .uk-disabled > *,
+.uk-tile-primary:not(.uk-preserve-color) .uk-pagination > .uk-disabled > *,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-pagination > .uk-disabled > *,
+.uk-card-primary.uk-card-body .uk-pagination > .uk-disabled > *,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-pagination > .uk-disabled > *,
+.uk-card-secondary.uk-card-body .uk-pagination > .uk-disabled > *,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-pagination > .uk-disabled > *,
+.uk-overlay-primary .uk-pagination > .uk-disabled > *,
+.uk-offcanvas-bar .uk-pagination > .uk-disabled > * {
+  color: rgba(255, 255, 255, 0.5);
+}
+.uk-light .uk-tab::before,
+.uk-section-primary:not(.uk-preserve-color) .uk-tab::before,
+.uk-section-secondary:not(.uk-preserve-color) .uk-tab::before,
+.uk-tile-primary:not(.uk-preserve-color) .uk-tab::before,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-tab::before,
+.uk-card-primary.uk-card-body .uk-tab::before,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-tab::before,
+.uk-card-secondary.uk-card-body .uk-tab::before,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-tab::before,
+.uk-overlay-primary .uk-tab::before,
+.uk-offcanvas-bar .uk-tab::before {
+  border-color: rgba(255, 255, 255, 0.2);
+}
+.uk-light .uk-tab > * > a,
+.uk-section-primary:not(.uk-preserve-color) .uk-tab > * > a,
+.uk-section-secondary:not(.uk-preserve-color) .uk-tab > * > a,
+.uk-tile-primary:not(.uk-preserve-color) .uk-tab > * > a,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-tab > * > a,
+.uk-card-primary.uk-card-body .uk-tab > * > a,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-tab > * > a,
+.uk-card-secondary.uk-card-body .uk-tab > * > a,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-tab > * > a,
+.uk-overlay-primary .uk-tab > * > a,
+.uk-offcanvas-bar .uk-tab > * > a {
+  color: rgba(255, 255, 255, 0.5);
+}
+.uk-light .uk-tab > * > a:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-tab > * > a:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-tab > * > a:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-tab > * > a:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-tab > * > a:hover,
+.uk-card-primary.uk-card-body .uk-tab > * > a:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-tab > * > a:hover,
+.uk-card-secondary.uk-card-body .uk-tab > * > a:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-tab > * > a:hover,
+.uk-overlay-primary .uk-tab > * > a:hover,
+.uk-offcanvas-bar .uk-tab > * > a:hover {
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-light .uk-tab > .uk-active > a,
+.uk-section-primary:not(.uk-preserve-color) .uk-tab > .uk-active > a,
+.uk-section-secondary:not(.uk-preserve-color) .uk-tab > .uk-active > a,
+.uk-tile-primary:not(.uk-preserve-color) .uk-tab > .uk-active > a,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-tab > .uk-active > a,
+.uk-card-primary.uk-card-body .uk-tab > .uk-active > a,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-tab > .uk-active > a,
+.uk-card-secondary.uk-card-body .uk-tab > .uk-active > a,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-tab > .uk-active > a,
+.uk-overlay-primary .uk-tab > .uk-active > a,
+.uk-offcanvas-bar .uk-tab > .uk-active > a {
+  color: #fff;
+  border-color: #fff;
+}
+.uk-light .uk-tab > .uk-disabled > a,
+.uk-section-primary:not(.uk-preserve-color) .uk-tab > .uk-disabled > a,
+.uk-section-secondary:not(.uk-preserve-color) .uk-tab > .uk-disabled > a,
+.uk-tile-primary:not(.uk-preserve-color) .uk-tab > .uk-disabled > a,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-tab > .uk-disabled > a,
+.uk-card-primary.uk-card-body .uk-tab > .uk-disabled > a,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-tab > .uk-disabled > a,
+.uk-card-secondary.uk-card-body .uk-tab > .uk-disabled > a,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-tab > .uk-disabled > a,
+.uk-overlay-primary .uk-tab > .uk-disabled > a,
+.uk-offcanvas-bar .uk-tab > .uk-disabled > a {
+  color: rgba(255, 255, 255, 0.5);
+}
+.uk-light .uk-slidenav,
+.uk-section-primary:not(.uk-preserve-color) .uk-slidenav,
+.uk-section-secondary:not(.uk-preserve-color) .uk-slidenav,
+.uk-tile-primary:not(.uk-preserve-color) .uk-slidenav,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-slidenav,
+.uk-card-primary.uk-card-body .uk-slidenav,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-slidenav,
+.uk-card-secondary.uk-card-body .uk-slidenav,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-slidenav,
+.uk-overlay-primary .uk-slidenav,
+.uk-offcanvas-bar .uk-slidenav {
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-light .uk-slidenav:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-slidenav:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-slidenav:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-slidenav:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-slidenav:hover,
+.uk-card-primary.uk-card-body .uk-slidenav:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-slidenav:hover,
+.uk-card-secondary.uk-card-body .uk-slidenav:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-slidenav:hover,
+.uk-overlay-primary .uk-slidenav:hover,
+.uk-offcanvas-bar .uk-slidenav:hover {
+  color: rgba(255, 255, 255, 0.95);
+}
+.uk-light .uk-slidenav:active,
+.uk-section-primary:not(.uk-preserve-color) .uk-slidenav:active,
+.uk-section-secondary:not(.uk-preserve-color) .uk-slidenav:active,
+.uk-tile-primary:not(.uk-preserve-color) .uk-slidenav:active,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-slidenav:active,
+.uk-card-primary.uk-card-body .uk-slidenav:active,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-slidenav:active,
+.uk-card-secondary.uk-card-body .uk-slidenav:active,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-slidenav:active,
+.uk-overlay-primary .uk-slidenav:active,
+.uk-offcanvas-bar .uk-slidenav:active {
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-light .uk-dotnav > * > *,
+.uk-section-primary:not(.uk-preserve-color) .uk-dotnav > * > *,
+.uk-section-secondary:not(.uk-preserve-color) .uk-dotnav > * > *,
+.uk-tile-primary:not(.uk-preserve-color) .uk-dotnav > * > *,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-dotnav > * > *,
+.uk-card-primary.uk-card-body .uk-dotnav > * > *,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-dotnav > * > *,
+.uk-card-secondary.uk-card-body .uk-dotnav > * > *,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-dotnav > * > *,
+.uk-overlay-primary .uk-dotnav > * > *,
+.uk-offcanvas-bar .uk-dotnav > * > * {
+  background-color: transparent;
+  border-color: rgba(255, 255, 255, 0.9);
+}
+.uk-light .uk-dotnav > * > :hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-dotnav > * > :hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-dotnav > * > :hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-dotnav > * > :hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-dotnav > * > :hover,
+.uk-card-primary.uk-card-body .uk-dotnav > * > :hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-dotnav > * > :hover,
+.uk-card-secondary.uk-card-body .uk-dotnav > * > :hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-dotnav > * > :hover,
+.uk-overlay-primary .uk-dotnav > * > :hover,
+.uk-offcanvas-bar .uk-dotnav > * > :hover {
+  background-color: rgba(255, 255, 255, 0.9);
+  border-color: transparent;
+}
+.uk-light .uk-dotnav > * > :active,
+.uk-section-primary:not(.uk-preserve-color) .uk-dotnav > * > :active,
+.uk-section-secondary:not(.uk-preserve-color) .uk-dotnav > * > :active,
+.uk-tile-primary:not(.uk-preserve-color) .uk-dotnav > * > :active,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-dotnav > * > :active,
+.uk-card-primary.uk-card-body .uk-dotnav > * > :active,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-dotnav > * > :active,
+.uk-card-secondary.uk-card-body .uk-dotnav > * > :active,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-dotnav > * > :active,
+.uk-overlay-primary .uk-dotnav > * > :active,
+.uk-offcanvas-bar .uk-dotnav > * > :active {
+  background-color: rgba(255, 255, 255, 0.5);
+  border-color: transparent;
+}
+.uk-light .uk-dotnav > .uk-active > *,
+.uk-section-primary:not(.uk-preserve-color) .uk-dotnav > .uk-active > *,
+.uk-section-secondary:not(.uk-preserve-color) .uk-dotnav > .uk-active > *,
+.uk-tile-primary:not(.uk-preserve-color) .uk-dotnav > .uk-active > *,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-dotnav > .uk-active > *,
+.uk-card-primary.uk-card-body .uk-dotnav > .uk-active > *,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-dotnav > .uk-active > *,
+.uk-card-secondary.uk-card-body .uk-dotnav > .uk-active > *,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-dotnav > .uk-active > *,
+.uk-overlay-primary .uk-dotnav > .uk-active > *,
+.uk-offcanvas-bar .uk-dotnav > .uk-active > * {
+  background-color: rgba(255, 255, 255, 0.9);
+  border-color: transparent;
+}
+.uk-light .uk-text-lead,
+.uk-section-primary:not(.uk-preserve-color) .uk-text-lead,
+.uk-section-secondary:not(.uk-preserve-color) .uk-text-lead,
+.uk-tile-primary:not(.uk-preserve-color) .uk-text-lead,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-text-lead,
+.uk-card-primary.uk-card-body .uk-text-lead,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-text-lead,
+.uk-card-secondary.uk-card-body .uk-text-lead,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-text-lead,
+.uk-overlay-primary .uk-text-lead,
+.uk-offcanvas-bar .uk-text-lead {
+  color: rgba(255, 255, 255, 0.7);
+}
+.uk-light .uk-text-meta,
+.uk-section-primary:not(.uk-preserve-color) .uk-text-meta,
+.uk-section-secondary:not(.uk-preserve-color) .uk-text-meta,
+.uk-tile-primary:not(.uk-preserve-color) .uk-text-meta,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-text-meta,
+.uk-card-primary.uk-card-body .uk-text-meta,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-text-meta,
+.uk-card-secondary.uk-card-body .uk-text-meta,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-text-meta,
+.uk-overlay-primary .uk-text-meta,
+.uk-offcanvas-bar .uk-text-meta {
+  color: rgba(255, 255, 255, 0.5);
+}
+.uk-light .uk-text-muted,
+.uk-section-primary:not(.uk-preserve-color) .uk-text-muted,
+.uk-section-secondary:not(.uk-preserve-color) .uk-text-muted,
+.uk-tile-primary:not(.uk-preserve-color) .uk-text-muted,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-text-muted,
+.uk-card-primary.uk-card-body .uk-text-muted,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-text-muted,
+.uk-card-secondary.uk-card-body .uk-text-muted,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-text-muted,
+.uk-overlay-primary .uk-text-muted,
+.uk-offcanvas-bar .uk-text-muted {
+  color: rgba(255, 255, 255, 0.5) !important;
+}
+.uk-light .uk-text-emphasis,
+.uk-section-primary:not(.uk-preserve-color) .uk-text-emphasis,
+.uk-section-secondary:not(.uk-preserve-color) .uk-text-emphasis,
+.uk-tile-primary:not(.uk-preserve-color) .uk-text-emphasis,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-text-emphasis,
+.uk-card-primary.uk-card-body .uk-text-emphasis,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-text-emphasis,
+.uk-card-secondary.uk-card-body .uk-text-emphasis,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-text-emphasis,
+.uk-overlay-primary .uk-text-emphasis,
+.uk-offcanvas-bar .uk-text-emphasis {
+  color: #fff !important;
+}
+.uk-light .uk-text-primary,
+.uk-section-primary:not(.uk-preserve-color) .uk-text-primary,
+.uk-section-secondary:not(.uk-preserve-color) .uk-text-primary,
+.uk-tile-primary:not(.uk-preserve-color) .uk-text-primary,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-text-primary,
+.uk-card-primary.uk-card-body .uk-text-primary,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-text-primary,
+.uk-card-secondary.uk-card-body .uk-text-primary,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-text-primary,
+.uk-overlay-primary .uk-text-primary,
+.uk-offcanvas-bar .uk-text-primary {
+  color: #fff !important;
+}
+.uk-light .uk-text-secondary,
+.uk-section-primary:not(.uk-preserve-color) .uk-text-secondary,
+.uk-section-secondary:not(.uk-preserve-color) .uk-text-secondary,
+.uk-tile-primary:not(.uk-preserve-color) .uk-text-secondary,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-text-secondary,
+.uk-card-primary.uk-card-body .uk-text-secondary,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-text-secondary,
+.uk-card-secondary.uk-card-body .uk-text-secondary,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-text-secondary,
+.uk-overlay-primary .uk-text-secondary,
+.uk-offcanvas-bar .uk-text-secondary {
+  color: #fff !important;
+}
+.uk-light .uk-column-divider,
+.uk-section-primary:not(.uk-preserve-color) .uk-column-divider,
+.uk-section-secondary:not(.uk-preserve-color) .uk-column-divider,
+.uk-tile-primary:not(.uk-preserve-color) .uk-column-divider,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-column-divider,
+.uk-card-primary.uk-card-body .uk-column-divider,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-column-divider,
+.uk-card-secondary.uk-card-body .uk-column-divider,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-column-divider,
+.uk-overlay-primary .uk-column-divider,
+.uk-offcanvas-bar .uk-column-divider {
+  column-rule-color: rgba(255, 255, 255, 0.2);
+}
+.uk-light .uk-logo,
+.uk-section-primary:not(.uk-preserve-color) .uk-logo,
+.uk-section-secondary:not(.uk-preserve-color) .uk-logo,
+.uk-tile-primary:not(.uk-preserve-color) .uk-logo,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-logo,
+.uk-card-primary.uk-card-body .uk-logo,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-logo,
+.uk-card-secondary.uk-card-body .uk-logo,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-logo,
+.uk-overlay-primary .uk-logo,
+.uk-offcanvas-bar .uk-logo {
+  color: #fff;
+}
+.uk-light .uk-logo:hover,
+.uk-section-primary:not(.uk-preserve-color) .uk-logo:hover,
+.uk-section-secondary:not(.uk-preserve-color) .uk-logo:hover,
+.uk-tile-primary:not(.uk-preserve-color) .uk-logo:hover,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-logo:hover,
+.uk-card-primary.uk-card-body .uk-logo:hover,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-logo:hover,
+.uk-card-secondary.uk-card-body .uk-logo:hover,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-logo:hover,
+.uk-overlay-primary .uk-logo:hover,
+.uk-offcanvas-bar .uk-logo:hover {
+  color: #fff;
+}
+.uk-light .uk-logo:has(.uk-logo-inverse) > :not(picture:has(.uk-logo-inverse)):not(.uk-logo-inverse),
+.uk-section-primary:not(.uk-preserve-color) .uk-logo:has(.uk-logo-inverse) > :not(picture:has(.uk-logo-inverse)):not(.uk-logo-inverse),
+.uk-section-secondary:not(.uk-preserve-color) .uk-logo:has(.uk-logo-inverse) > :not(picture:has(.uk-logo-inverse)):not(.uk-logo-inverse),
+.uk-tile-primary:not(.uk-preserve-color) .uk-logo:has(.uk-logo-inverse) > :not(picture:has(.uk-logo-inverse)):not(.uk-logo-inverse),
+.uk-tile-secondary:not(.uk-preserve-color) .uk-logo:has(.uk-logo-inverse) > :not(picture:has(.uk-logo-inverse)):not(.uk-logo-inverse),
+.uk-card-primary.uk-card-body .uk-logo:has(.uk-logo-inverse) > :not(picture:has(.uk-logo-inverse)):not(.uk-logo-inverse),
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-logo:has(.uk-logo-inverse) > :not(picture:has(.uk-logo-inverse)):not(.uk-logo-inverse),
+.uk-card-secondary.uk-card-body .uk-logo:has(.uk-logo-inverse) > :not(picture:has(.uk-logo-inverse)):not(.uk-logo-inverse),
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-logo:has(.uk-logo-inverse) > :not(picture:has(.uk-logo-inverse)):not(.uk-logo-inverse),
+.uk-overlay-primary .uk-logo:has(.uk-logo-inverse) > :not(picture:has(.uk-logo-inverse)):not(.uk-logo-inverse),
+.uk-offcanvas-bar .uk-logo:has(.uk-logo-inverse) > :not(picture:has(.uk-logo-inverse)):not(.uk-logo-inverse) {
+  display: none;
+}
+.uk-light .uk-logo-inverse,
+.uk-section-primary:not(.uk-preserve-color) .uk-logo-inverse,
+.uk-section-secondary:not(.uk-preserve-color) .uk-logo-inverse,
+.uk-tile-primary:not(.uk-preserve-color) .uk-logo-inverse,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-logo-inverse,
+.uk-card-primary.uk-card-body .uk-logo-inverse,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-logo-inverse,
+.uk-card-secondary.uk-card-body .uk-logo-inverse,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-logo-inverse,
+.uk-overlay-primary .uk-logo-inverse,
+.uk-offcanvas-bar .uk-logo-inverse {
+  display: block;
+}
+.uk-light .uk-table-striped > tr:nth-of-type(even):last-child,
+.uk-light .uk-table-striped tbody tr:nth-of-type(even):last-child,
+.uk-section-primary:not(.uk-preserve-color) .uk-table-striped > tr:nth-of-type(even):last-child,
+.uk-section-primary:not(.uk-preserve-color) .uk-table-striped tbody tr:nth-of-type(even):last-child,
+.uk-section-secondary:not(.uk-preserve-color) .uk-table-striped > tr:nth-of-type(even):last-child,
+.uk-section-secondary:not(.uk-preserve-color) .uk-table-striped tbody tr:nth-of-type(even):last-child,
+.uk-tile-primary:not(.uk-preserve-color) .uk-table-striped > tr:nth-of-type(even):last-child,
+.uk-tile-primary:not(.uk-preserve-color) .uk-table-striped tbody tr:nth-of-type(even):last-child,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-table-striped > tr:nth-of-type(even):last-child,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-table-striped tbody tr:nth-of-type(even):last-child,
+.uk-card-primary.uk-card-body .uk-table-striped > tr:nth-of-type(even):last-child,
+.uk-card-primary.uk-card-body .uk-table-striped tbody tr:nth-of-type(even):last-child,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-table-striped > tr:nth-of-type(even):last-child,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-table-striped tbody tr:nth-of-type(even):last-child,
+.uk-card-secondary.uk-card-body .uk-table-striped > tr:nth-of-type(even):last-child,
+.uk-card-secondary.uk-card-body .uk-table-striped tbody tr:nth-of-type(even):last-child,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-table-striped > tr:nth-of-type(even):last-child,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-table-striped tbody tr:nth-of-type(even):last-child,
+.uk-overlay-primary .uk-table-striped > tr:nth-of-type(even):last-child,
+.uk-overlay-primary .uk-table-striped tbody tr:nth-of-type(even):last-child,
+.uk-offcanvas-bar .uk-table-striped > tr:nth-of-type(even):last-child,
+.uk-offcanvas-bar .uk-table-striped tbody tr:nth-of-type(even):last-child {
+  border-bottom-color: rgba(255, 255, 255, 0.2);
+}
+.uk-light .uk-accordion-title::before,
+.uk-section-primary:not(.uk-preserve-color) .uk-accordion-title::before,
+.uk-section-secondary:not(.uk-preserve-color) .uk-accordion-title::before,
+.uk-tile-primary:not(.uk-preserve-color) .uk-accordion-title::before,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-accordion-title::before,
+.uk-card-primary.uk-card-body .uk-accordion-title::before,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-accordion-title::before,
+.uk-card-secondary.uk-card-body .uk-accordion-title::before,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-accordion-title::before,
+.uk-overlay-primary .uk-accordion-title::before,
+.uk-offcanvas-bar .uk-accordion-title::before {
+  background-image: url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2213%22%20height%3D%2213%22%20viewBox%3D%220%200%2013%2013%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Crect%20fill%3D%22rgba%28255,%20255,%20255,%200.7%29%22%20width%3D%2213%22%20height%3D%221%22%20x%3D%220%22%20y%3D%226%22%20%2F%3E%0A%20%20%20%20%3Crect%20fill%3D%22rgba%28255,%20255,%20255,%200.7%29%22%20width%3D%221%22%20height%3D%2213%22%20x%3D%226%22%20y%3D%220%22%20%2F%3E%0A%3C%2Fsvg%3E");
+}
+.uk-light .uk-open > .uk-accordion-title::before,
+.uk-section-primary:not(.uk-preserve-color) .uk-open > .uk-accordion-title::before,
+.uk-section-secondary:not(.uk-preserve-color) .uk-open > .uk-accordion-title::before,
+.uk-tile-primary:not(.uk-preserve-color) .uk-open > .uk-accordion-title::before,
+.uk-tile-secondary:not(.uk-preserve-color) .uk-open > .uk-accordion-title::before,
+.uk-card-primary.uk-card-body .uk-open > .uk-accordion-title::before,
+.uk-card-primary > :not([class*="uk-card-media"]) .uk-open > .uk-accordion-title::before,
+.uk-card-secondary.uk-card-body .uk-open > .uk-accordion-title::before,
+.uk-card-secondary > :not([class*="uk-card-media"]) .uk-open > .uk-accordion-title::before,
+.uk-overlay-primary .uk-open > .uk-accordion-title::before,
+.uk-offcanvas-bar .uk-open > .uk-accordion-title::before {
+  background-image: url("data:image/svg+xml;charset=UTF-8,%3Csvg%20width%3D%2213%22%20height%3D%2213%22%20viewBox%3D%220%200%2013%2013%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Crect%20fill%3D%22rgba%28255,%20255,%20255,%200.7%29%22%20width%3D%2213%22%20height%3D%221%22%20x%3D%220%22%20y%3D%226%22%20%2F%3E%0A%3C%2Fsvg%3E");
+}
+/*
+ * Pass dropbar behind color to JS
+ */
+* {
+  --uk-inverse: initial;
+}
+.uk-light,
+.uk-section-primary:not(.uk-preserve-color),
+.uk-section-secondary:not(.uk-preserve-color),
+.uk-tile-primary:not(.uk-preserve-color),
+.uk-tile-secondary:not(.uk-preserve-color),
+.uk-card-primary.uk-card-body,
+.uk-card-primary > :not([class*="uk-card-media"]),
+.uk-card-secondary.uk-card-body,
+.uk-card-secondary > :not([class*="uk-card-media"]),
+.uk-overlay-primary,
+.uk-offcanvas-bar {
+  --uk-inverse: light;
+}
+.uk-dark,
+.uk-section-default:not(.uk-preserve-color),
+.uk-section-muted:not(.uk-preserve-color),
+.uk-tile-default:not(.uk-preserve-color),
+.uk-tile-muted:not(.uk-preserve-color),
+.uk-card-default.uk-card-body,
+.uk-card-default > :not([class*="uk-card-media"]),
+.uk-overlay-default,
+.uk-dropbar,
+.uk-navbar-container:not(.uk-navbar-transparent),
+.uk-navbar-dropdown,
+.uk-dropdown {
+  --uk-inverse: dark;
+}
+.uk-inverse-light {
+  --uk-inverse: light !important;
+}
+.uk-inverse-dark {
+  --uk-inverse: dark !important;
+}
+/* ========================================================================
+   Component: Print
+ ========================================================================== */
+@media print {
+  *,
+  *::before,
+  *::after {
+    background: transparent !important;
+    color: black !important;
+    box-shadow: none !important;
+    text-shadow: none !important;
+  }
+  a,
+  a:visited {
+    text-decoration: underline;
+  }
+  pre,
+  blockquote {
+    border: 1px solid #999;
+    page-break-inside: avoid;
+  }
+  thead {
+    display: table-header-group;
+  }
+  tr,
+  img {
+    page-break-inside: avoid;
+  }
+  img {
+    max-width: 100% !important;
+  }
+  @page {
+    margin: 0.5cm;
+  }
+  p,
+  h2,
+  h3 {
+    orphans: 3;
+    widows: 3;
+  }
+  h2,
+  h3 {
+    page-break-after: avoid;
+  }
+}
\ No newline at end of file
diff --git a/test/js/bun/css/util.ts b/test/js/bun/css/util.ts
new file mode 100644
index 0000000000..09b4701739
--- /dev/null
+++ b/test/js/bun/css/util.ts
@@ -0,0 +1,51 @@
+import { describe, expect, test } from "bun:test";
+import { cssInternals } from "bun:internal-for-testing";
+import dedent from "./dedent";
+const { minifyTestWithOptions, testWithOptions, prefixTestWithOptions, attrTest: __attrTest } = cssInternals;
+
+type Browsers = {
+  android?: number;
+  chrome?: number;
+  edge?: number;
+  firefox?: number;
+  ie?: number;
+  ios_saf?: number;
+  opera?: number;
+  safari?: number;
+  samsung?: number;
+};
+
+export function minify_test(source: string, expected: string) {
+  return minifyTest(source, expected);
+}
+export function minifyTest(source: string, expected: string) {
+  test(source, () => {
+    expect(minifyTestWithOptions(source, expected)).toEqual(expected);
+  });
+}
+
+export function prefix_test(source: string, expected: string, targets: Browsers) {
+  test(source, () => {
+    expect(prefixTestWithOptions(source, expected, targets)).toEqualIgnoringWhitespace(expected);
+  });
+}
+
+export function css_test(source: string, expected: string) {
+  return cssTest(source, expected);
+}
+export function cssTest(source: string, expected: string) {
+  test(source, () => {
+    expect(testWithOptions(source, expected)).toEqualIgnoringWhitespace(expected);
+  });
+}
+
+export function attrTest(source: string, expected: string, minify: boolean, targets?: Browsers) {
+  return __attrTest(source, expected, minify, targets);
+}
+
+//
+export function indoc(...args: any) {
+  return dedent(...args);
+}
+
+export { minifyTestWithOptions };
diff --git a/test/js/bun/dns/resolve-dns.test.ts b/test/js/bun/dns/resolve-dns.test.ts
index 85edc37130..90e088b2c9 100644
--- a/test/js/bun/dns/resolve-dns.test.ts
+++ b/test/js/bun/dns/resolve-dns.test.ts
@@ -1,13 +1,13 @@
 import { SystemError, dns } from "bun";
 import { describe, expect, test } from "bun:test";
-import { withoutAggressiveGC } from "harness";
+import { isWindows, withoutAggressiveGC } from "harness";
 import { isIP, isIPv4, isIPv6 } from "node:net";
 
 const backends = ["system", "libc", "c-ares"];
 const validHostnames = ["localhost", "example.com"];
 const invalidHostnames = ["adsfa.asdfasdf.asdf.com"]; // known invalid
 const malformedHostnames = [" ", ".", " .", "localhost:80", "this is not a hostname"];
-const isWindows = process.platform === "win32";
+
 describe("dns", () => {
   describe.each(backends)("lookup() [backend: %s]", backend => {
     describe.each(validHostnames)("%s", hostname => {
diff --git a/test/js/bun/eventsource/eventsource.test.ts b/test/js/bun/eventsource/eventsource.test.ts
deleted file mode 100644
index 71878a26f5..0000000000
--- a/test/js/bun/eventsource/eventsource.test.ts
+++ /dev/null
@@ -1,152 +0,0 @@
-// function sse(req: Request) {
-//   const signal = req.signal;
-//   return new Response(
-//     new ReadableStream({
-//       type: "direct",
-//       async pull(controller) {
-//         while (!signal.aborted) {
-//           await controller.write(`data:Hello, World!\n\n`);
-//           await controller.write(`event: bun\ndata: Hello, World!\n\n`);
-//           await controller.write(`event: lines\ndata: Line 1!\ndata: Line 2!\n\n`);
-//           await controller.write(`event: id_test\nid:1\n\n`);
-//           await controller.flush();
-//           await Bun.sleep(100);
-//         }
-//         controller.close();
-//       },
-//     }),
-//     { status: 200, headers: { "Content-Type": "text/event-stream" } },
-//   );
-// }
-
-// function sse_unstable(req: Request) {
-//   const signal = req.signal;
-//   let id = parseInt(req.headers.get("last-event-id") || "0", 10);
-
-//   return new Response(
-//     new ReadableStream({
-//       type: "direct",
-//       async pull(controller) {
-//         if (!signal.aborted) {
-//           await controller.write(`id:${++id}\ndata: Hello, World!\nretry:100\n\n`);
-//           await controller.flush();
-//         }
-//         controller.close();
-//       },
-//     }),
-//     { status: 200, headers: { "Content-Type": "text/event-stream" } },
-//   );
-// }
-
-// function sseServer(
-//   done: (err?: unknown) => void,
-//   pathname: string,
-//   callback: (evtSource: EventSource, done: (err?: unknown) => void) => void,
-// ) {
-//   using server = Bun.serve({
-//     port: 0,
-//     fetch(req) {
-//       if (new URL(req.url).pathname === "/stream") {
-//         return sse(req);
-//       }
-//       if (new URL(req.url).pathname === "/unstable") {
-//         return sse_unstable(req);
-//       }
-//       return new Response("Hello, World!");
-//     },
-//   });
-//   let evtSource: EventSource | undefined;
-//   try {
-//     evtSource = new EventSource(`http://localhost:${server.port}${pathname}`);
-//     callback(evtSource, err => {
-//       try {
-//         done(err);
-//         evtSource?.close();
-//       } catch (err) {
-//         done(err);
-//       } finally {
-//         server.stop(true);
-//       }
-//     });
-//   } catch (err) {
-//     evtSource?.close();
-//     done(err);
-//   }
-// }
-
-// import { describe, expect, it } from "bun:test";
-
-// describe("events", () => {
-//   it("should call open", done => {
-//     sseServer(done, "/stream", (evtSource, done) => {
-//       evtSource.onopen = () => {
-//         done();
-//       };
-//       evtSource.onerror = err => {
-//         done(err);
-//       };
-//     });
-//   });
-
-//   it("should call message", done => {
-//     sseServer(done, "/stream", (evtSource, done) => {
-//       evtSource.onmessage = e => {
-//         expect(e.data).toBe("Hello, World!");
-//         done();
-//       };
-//     });
-//   });
-
-//   it("should call custom event", done => {
-//     sseServer(done, "/stream", (evtSource, done) => {
-//       evtSource.addEventListener("bun", e => {
-//         expect(e.data).toBe("Hello, World!");
-//         done();
-//       });
-//     });
-//   });
-
-//   it("should call event with multiple lines", done => {
-//     sseServer(done, "/stream", (evtSource, done) => {
-//       evtSource.addEventListener("lines", e => {
-//         expect(e.data).toBe("Line 1!\nLine 2!");
-//         done();
-//       });
-//     });
-//   });
-
-//   it("should receive id", done => {
-//     sseServer(done, "/stream", (evtSource, done) => {
-//       evtSource.addEventListener("id_test", e => {
-//         expect(e.lastEventId).toBe("1");
-//         done();
-//       });
-//     });
-//   });
-
-//   it("should reconnect with id", done => {
-//     sseServer(done, "/unstable", (evtSource, done) => {
-//       const ids: string[] = [];
-//       evtSource.onmessage = e => {
-//         ids.push(e.lastEventId);
-//         if (ids.length === 2) {
-//           for (let i = 0; i < 2; i++) {
-//             expect(ids[i]).toBe((i + 1).toString());
-//           }
-//           done();
-//         }
-//       };
-//     });
-//   });
-
-//   it("should call error", done => {
-//     sseServer(done, "/", (evtSource, done) => {
-//       evtSource.onerror = e => {
-//         expect(e.error.message).toBe(
-//           `EventSource's response has a MIME type that is not "text/event-stream". Aborting the connection.`,
-//         );
-//         done();
-//       };
-//     });
-//   });
-// });
diff --git a/test/js/bun/ffi/cc.test.ts b/test/js/bun/ffi/cc.test.ts
index 8e90b8ec52..93c5429f3e 100644
--- a/test/js/bun/ffi/cc.test.ts
+++ b/test/js/bun/ffi/cc.test.ts
@@ -2,8 +2,8 @@ import { expect, it } from "bun:test";
 import { bunEnv, bunExe, isWindows } from "harness";
 import path from "path";
 
-// TODO: we need to install build-essential and apple SDK in CI.
-// it can't find includes. It can on machiens with that enabled.
+// TODO: we need to install build-essential and Apple SDK in CI.
+// It can't find includes. It can on machines with that enabled.
 it.todoIf(isWindows)("can run a .c file", () => {
   const result = Bun.spawnSync({
     cmd: [bunExe(), path.join(__dirname, "cc-fixture.js")],
diff --git a/test/js/bun/ffi/ffi.test.fixture.callback.c b/test/js/bun/ffi/ffi.test.fixture.callback.c
index 3807160af4..6b3c626c09 100644
--- a/test/js/bun/ffi/ffi.test.fixture.callback.c
+++ b/test/js/bun/ffi/ffi.test.fixture.callback.c
@@ -35,6 +35,38 @@ typedef _Bool bool;
 #define true 1
 #define false 0
 
+#ifndef SRC_JS_NATIVE_API_TYPES_H_
+typedef struct napi_env__ *napi_env;
+typedef int64_t napi_value;
+typedef enum {
+  napi_ok,
+  napi_invalid_arg,
+  napi_object_expected,
+  napi_string_expected,
+  napi_name_expected,
+  napi_function_expected,
+  napi_number_expected,
+  napi_boolean_expected,
+  napi_array_expected,
+  napi_generic_failure,
+  napi_pending_exception,
+  napi_cancelled,
+  napi_escape_called_twice,
+  napi_handle_scope_mismatch,
+  napi_callback_scope_mismatch,
+  napi_queue_full,
+  napi_closing,
+  napi_bigint_expected,
+  napi_date_expected,
+  napi_arraybuffer_expected,
+  napi_detachable_arraybuffer_expected,
+  napi_would_deadlock // unused
+} napi_status;
+void* NapiHandleScope__open(void* napi_env, bool detached);
+void NapiHandleScope__close(void* napi_env, void* handleScope);
+extern struct napi_env__ Bun__thisFFIModuleNapiEnv;
+#endif
+
 
 #ifdef INJECT_BEFORE
 // #include <stdint.h>
@@ -45,14 +77,14 @@ typedef _Bool bool;
 // begin with a 15-bit pattern within the range 0x0002..0xFFFC.
 #define DoubleEncodeOffsetBit 49
 #define DoubleEncodeOffset    (1ll << DoubleEncodeOffsetBit)
-#define OtherTag              0x2
-#define BoolTag               0x4
-#define UndefinedTag          0x8
+#define OtherTag              0x2ll
+#define BoolTag               0x4ll
+#define UndefinedTag          0x8ll
 #define TagValueFalse            (OtherTag | BoolTag | false)
 #define TagValueTrue             (OtherTag | BoolTag | true)
 #define TagValueUndefined        (OtherTag | UndefinedTag)
 #define TagValueNull             (OtherTag)
-#define NotCellMask  NumberTag | OtherTag
+#define NotCellMask  (int64_t)(NumberTag | OtherTag)
 
 #define MAX_INT32 2147483648
 #define MAX_INT52 9007199254740991
@@ -70,6 +102,8 @@ typedef union EncodedJSValue {
   JSCell *ptr;
 #endif
 
+napi_value asNapiValue;
+
 #if IS_BIG_ENDIAN
   struct {
     int32_t tag;
@@ -140,6 +174,11 @@ static int32_t JSVALUE_TO_INT32(EncodedJSValue val) __attribute__((__always_inli
 static float JSVALUE_TO_FLOAT(EncodedJSValue val) __attribute__((__always_inline__));
 static double JSVALUE_TO_DOUBLE(EncodedJSValue val) __attribute__((__always_inline__));
 static bool JSVALUE_TO_BOOL(EncodedJSValue val) __attribute__((__always_inline__));
+static uint8_t GET_JSTYPE(EncodedJSValue val) __attribute__((__always_inline__));
+static bool JSTYPE_IS_TYPED_ARRAY(uint8_t type) __attribute__((__always_inline__));
+static bool JSCELL_IS_TYPED_ARRAY(EncodedJSValue val) __attribute__((__always_inline__));
+static void* JSVALUE_TO_TYPED_ARRAY_VECTOR(EncodedJSValue val) __attribute__((__always_inline__));
+static uint64_t JSVALUE_TO_TYPED_ARRAY_LENGTH(EncodedJSValue val) __attribute__((__always_inline__));
 
 static bool JSVALUE_IS_CELL(EncodedJSValue val) {
   return !(val.asInt64 & NotCellMask);
@@ -153,6 +192,25 @@ static bool JSVALUE_IS_NUMBER(EncodedJSValue val) {
   return val.asInt64 & NumberTag;
 }
 
+static uint8_t GET_JSTYPE(EncodedJSValue val) {
+  return *(uint8_t*)((uint8_t*)val.asPtr + JSCell__offsetOfType);
+}
+
+static bool JSTYPE_IS_TYPED_ARRAY(uint8_t type) {
+  return type >= JSTypeArrayBufferViewMin && type <= JSTypeArrayBufferViewMax;
+}
+
+static bool JSCELL_IS_TYPED_ARRAY(EncodedJSValue val) {
+  return JSVALUE_IS_CELL(val) && JSTYPE_IS_TYPED_ARRAY(GET_JSTYPE(val));
+}
+
+static void* JSVALUE_TO_TYPED_ARRAY_VECTOR(EncodedJSValue val) {
+  return *(void**)((char*)val.asPtr + JSArrayBufferView__offsetOfVector);
+}
+
+static uint64_t JSVALUE_TO_TYPED_ARRAY_LENGTH(EncodedJSValue val) {
+  return *(uint64_t*)((char*)val.asPtr + JSArrayBufferView__offsetOfLength);
+}
 
 // JSValue numbers-as-pointers are represented as a 52-bit integer
 // Previously, the pointer was stored at the end of the 64-bit value
@@ -162,6 +220,11 @@ static bool JSVALUE_IS_NUMBER(EncodedJSValue val) {
 static void* JSVALUE_TO_PTR(EncodedJSValue val) {
   if (val.asInt64 == TagValueNull)
     return 0;
+
+  if (JSCELL_IS_TYPED_ARRAY(val)) {
+      return JSVALUE_TO_TYPED_ARRAY_VECTOR(val);
+  }
+
   val.asInt64 -= DoubleEncodeOffset;
   size_t ptr = (size_t)val.asDouble;
   return (void*)ptr;
@@ -244,6 +307,10 @@ static uint64_t JSVALUE_TO_UINT64(EncodedJSValue value) {
     return (uint64_t)JSVALUE_TO_DOUBLE(value);
   }
 
+  if (JSCELL_IS_TYPED_ARRAY(value)) {
+    return (uint64_t)JSVALUE_TO_TYPED_ARRAY_LENGTH(value);
+  }
+
   return JSVALUE_TO_UINT64_SLOW(value);
 }
 static int64_t JSVALUE_TO_INT64(EncodedJSValue value) {
@@ -293,6 +360,9 @@ ZIG_REPR_TYPE JSFunctionCall(void* jsGlobalObject, void* callFrame);
  
 /* --- The Callback Function */
 bool my_callback_function(void* arg0) {
+#ifdef INJECT_BEFORE
+INJECT_BEFORE;
+#endif
  ZIG_REPR_TYPE arguments[1];
 arguments[0] = PTR_TO_JSVALUE(arg0).asZigRepr;
   return (bool)JSVALUE_TO_BOOL(_FFI_Callback_call((void*)0x0000000000000000ULL, 1, arguments));
diff --git a/test/js/bun/ffi/ffi.test.fixture.receiver.c b/test/js/bun/ffi/ffi.test.fixture.receiver.c
index 6d448c806d..814c66491b 100644
--- a/test/js/bun/ffi/ffi.test.fixture.receiver.c
+++ b/test/js/bun/ffi/ffi.test.fixture.receiver.c
@@ -35,6 +35,38 @@ typedef _Bool bool;
 #define true 1
 #define false 0
 
+#ifndef SRC_JS_NATIVE_API_TYPES_H_
+typedef struct napi_env__ *napi_env;
+typedef int64_t napi_value;
+typedef enum {
+  napi_ok,
+  napi_invalid_arg,
+  napi_object_expected,
+  napi_string_expected,
+  napi_name_expected,
+  napi_function_expected,
+  napi_number_expected,
+  napi_boolean_expected,
+  napi_array_expected,
+  napi_generic_failure,
+  napi_pending_exception,
+  napi_cancelled,
+  napi_escape_called_twice,
+  napi_handle_scope_mismatch,
+  napi_callback_scope_mismatch,
+  napi_queue_full,
+  napi_closing,
+  napi_bigint_expected,
+  napi_date_expected,
+  napi_arraybuffer_expected,
+  napi_detachable_arraybuffer_expected,
+  napi_would_deadlock // unused
+} napi_status;
+void* NapiHandleScope__open(void* napi_env, bool detached);
+void NapiHandleScope__close(void* napi_env, void* handleScope);
+extern struct napi_env__ Bun__thisFFIModuleNapiEnv;
+#endif
+
 
 #ifdef INJECT_BEFORE
 // #include <stdint.h>
@@ -45,14 +77,14 @@ typedef _Bool bool;
 // begin with a 15-bit pattern within the range 0x0002..0xFFFC.
 #define DoubleEncodeOffsetBit 49
 #define DoubleEncodeOffset    (1ll << DoubleEncodeOffsetBit)
-#define OtherTag              0x2
-#define BoolTag               0x4
-#define UndefinedTag          0x8
+#define OtherTag              0x2ll
+#define BoolTag               0x4ll
+#define UndefinedTag          0x8ll
 #define TagValueFalse            (OtherTag | BoolTag | false)
 #define TagValueTrue             (OtherTag | BoolTag | true)
 #define TagValueUndefined        (OtherTag | UndefinedTag)
 #define TagValueNull             (OtherTag)
-#define NotCellMask  NumberTag | OtherTag
+#define NotCellMask  (int64_t)(NumberTag | OtherTag)
 
 #define MAX_INT32 2147483648
 #define MAX_INT52 9007199254740991
@@ -70,6 +102,8 @@ typedef union EncodedJSValue {
   JSCell *ptr;
 #endif
 
+napi_value asNapiValue;
+
 #if IS_BIG_ENDIAN
   struct {
     int32_t tag;
@@ -140,6 +174,11 @@ static int32_t JSVALUE_TO_INT32(EncodedJSValue val) __attribute__((__always_inli
 static float JSVALUE_TO_FLOAT(EncodedJSValue val) __attribute__((__always_inline__));
 static double JSVALUE_TO_DOUBLE(EncodedJSValue val) __attribute__((__always_inline__));
 static bool JSVALUE_TO_BOOL(EncodedJSValue val) __attribute__((__always_inline__));
+static uint8_t GET_JSTYPE(EncodedJSValue val) __attribute__((__always_inline__));
+static bool JSTYPE_IS_TYPED_ARRAY(uint8_t type) __attribute__((__always_inline__));
+static bool JSCELL_IS_TYPED_ARRAY(EncodedJSValue val) __attribute__((__always_inline__));
+static void* JSVALUE_TO_TYPED_ARRAY_VECTOR(EncodedJSValue val) __attribute__((__always_inline__));
+static uint64_t JSVALUE_TO_TYPED_ARRAY_LENGTH(EncodedJSValue val) __attribute__((__always_inline__));
 
 static bool JSVALUE_IS_CELL(EncodedJSValue val) {
   return !(val.asInt64 & NotCellMask);
@@ -153,6 +192,25 @@ static bool JSVALUE_IS_NUMBER(EncodedJSValue val) {
   return val.asInt64 & NumberTag;
 }
 
+static uint8_t GET_JSTYPE(EncodedJSValue val) {
+  return *(uint8_t*)((uint8_t*)val.asPtr + JSCell__offsetOfType);
+}
+
+static bool JSTYPE_IS_TYPED_ARRAY(uint8_t type) {
+  return type >= JSTypeArrayBufferViewMin && type <= JSTypeArrayBufferViewMax;
+}
+
+static bool JSCELL_IS_TYPED_ARRAY(EncodedJSValue val) {
+  return JSVALUE_IS_CELL(val) && JSTYPE_IS_TYPED_ARRAY(GET_JSTYPE(val));
+}
+
+static void* JSVALUE_TO_TYPED_ARRAY_VECTOR(EncodedJSValue val) {
+  return *(void**)((char*)val.asPtr + JSArrayBufferView__offsetOfVector);
+}
+
+static uint64_t JSVALUE_TO_TYPED_ARRAY_LENGTH(EncodedJSValue val) {
+  return *(uint64_t*)((char*)val.asPtr + JSArrayBufferView__offsetOfLength);
+}
 
 // JSValue numbers-as-pointers are represented as a 52-bit integer
 // Previously, the pointer was stored at the end of the 64-bit value
@@ -162,6 +220,11 @@ static bool JSVALUE_IS_NUMBER(EncodedJSValue val) {
 static void* JSVALUE_TO_PTR(EncodedJSValue val) {
   if (val.asInt64 == TagValueNull)
     return 0;
+
+  if (JSCELL_IS_TYPED_ARRAY(val)) {
+      return JSVALUE_TO_TYPED_ARRAY_VECTOR(val);
+  }
+
   val.asInt64 -= DoubleEncodeOffset;
   size_t ptr = (size_t)val.asDouble;
   return (void*)ptr;
@@ -244,6 +307,10 @@ static uint64_t JSVALUE_TO_UINT64(EncodedJSValue value) {
     return (uint64_t)JSVALUE_TO_DOUBLE(value);
   }
 
+  if (JSCELL_IS_TYPED_ARRAY(value)) {
+    return (uint64_t)JSVALUE_TO_TYPED_ARRAY_LENGTH(value);
+  }
+
   return JSVALUE_TO_UINT64_SLOW(value);
 }
 static int64_t JSVALUE_TO_INT64(EncodedJSValue value) {
diff --git a/test/js/bun/http/body-leak-test-fixture.ts b/test/js/bun/http/body-leak-test-fixture.ts
index f9702c54e1..1cc5a28298 100644
--- a/test/js/bun/http/body-leak-test-fixture.ts
+++ b/test/js/bun/http/body-leak-test-fixture.ts
@@ -11,7 +11,9 @@ const server = Bun.serve({
         },
       });
     }
-    if (url.endsWith("/buffering")) {
+    if (url.endsWith("/json-buffering")) {
+      await req.json();
+    } else if (url.endsWith("/buffering")) {
       await req.text();
     } else if (url.endsWith("/buffering+body-getter")) {
       req.body;
diff --git a/test/js/bun/http/bun-listen-connect-args.test.ts b/test/js/bun/http/bun-listen-connect-args.test.ts
new file mode 100644
index 0000000000..21e62f2d2c
--- /dev/null
+++ b/test/js/bun/http/bun-listen-connect-args.test.ts
@@ -0,0 +1,74 @@
+import { describe, expect, test } from "bun:test";
+import { cwdScope, isWindows, rmScope, tempDirWithFiles } from "harness";
+
+describe.if(!isWindows)("unix socket", () => {
+  test("valid", () => {
+    using server = Bun.listen({
+      unix: Math.random().toString(32).slice(2, 15) + ".sock",
+      socket: {
+        open() {},
+        close() {},
+        data() {},
+        drain() {},
+      },
+    });
+    server.stop();
+  });
+
+  describe("allows", () => {
+    const permutations = [
+      {
+        unix: Math.random().toString(32).slice(2, 15) + ".sock",
+        port: 0,
+        hostname: "",
+      },
+      {
+        unix: Math.random().toString(32).slice(2, 15) + ".sock",
+        hostname: undefined,
+      },
+      {
+        unix: Math.random().toString(32).slice(2, 15) + ".sock",
+        hostname: null,
+      },
+      {
+        unix: Math.random().toString(32).slice(2, 15) + ".sock",
+        hostname: false,
+      },
+      {
+        unix: Math.random().toString(32).slice(2, 15) + ".sock",
+        hostname: Buffer.from(""),
+      },
+      {
+        unix: Math.random().toString(32).slice(2, 15) + ".sock",
+        hostname: Buffer.alloc(0),
+      },
+      {
+        unix: "unix://" + Math.random().toString(32).slice(2, 15) + ".sock",
+        hostname: Buffer.alloc(0),
+      },
+    ];
+
+    for (const args of permutations) {
+      test(`${JSON.stringify(args)}`, async () => {
+        const tempdir = tempDirWithFiles("test-socket", {
+          "foo.txt": "bar",
+        });
+        using cwd = cwdScope(tempdir);
+        using rm = rmScope(tempdir);
+        for (let i = 0; i < 100; i++) {
+          using server = Bun.listen({
+            ...args,
+            unix: args.unix.startsWith("unix://") ? "unix://" + i + args.unix.slice(7) : i + args.unix,
+            socket: {
+              open() {},
+              close() {},
+              data() {},
+              drain() {},
+            },
+          });
+          server.stop();
+        }
+      });
+    }
+  });
+});
diff --git a/test/js/bun/http/bun-request-fixture.js b/test/js/bun/http/bun-request-fixture.js
new file mode 100644
index 0000000000..f1f9c15306
--- /dev/null
+++ b/test/js/bun/http/bun-request-fixture.js
@@ -0,0 +1,6 @@
+export const signal = undefined;
+
+export const method = "POST";
+export const body = JSON.stringify({
+  hello: "world",
+});
diff --git a/test/js/bun/http/bun-serve-args.test.ts b/test/js/bun/http/bun-serve-args.test.ts
new file mode 100644
index 0000000000..8414c32d60
--- /dev/null
+++ b/test/js/bun/http/bun-serve-args.test.ts
@@ -0,0 +1,654 @@
+import { serve } from "bun";
+import { describe, expect, test } from "bun:test";
+import { tmpdirSync } from "../../../harness";
+
+const defaultHostname = "localhost";
+
+describe("Bun.serve basic options", () => {
+  test("minimal valid config", () => {
+    using server = serve({
+      port: 0,
+      fetch() {
+        return new Response("ok");
+      },
+    });
+    expect(server.port).toBeGreaterThan(0); // Default port
+    expect(server.hostname).toBe(defaultHostname);
+    server.stop();
+  });
+
+  test("port as string", () => {
+    using server = serve({
+      port: "0",
+      fetch() {
+        return new Response("ok");
+      },
+    });
+    expect(server.port).toBeGreaterThan(0);
+    server.stop();
+  });
+});
+
+describe("unix socket", () => {
+  const permutations = [
+    {
+      unix: Math.random().toString(32).slice(2, 15) + ".sock",
+      hostname: "",
+    },
+    {
+      unix: Math.random().toString(32).slice(2, 15) + ".sock",
+      hostname: undefined,
+    },
+    {
+      unix: Math.random().toString(32).slice(2, 15) + ".sock",
+      hostname: null,
+    },
+    {
+      unix: Buffer.from(Math.random().toString(32).slice(2, 15) + ".sock"),
+      hostname: null,
+    },
+    {
+      unix: Buffer.from(Math.random().toString(32).slice(2, 15) + ".sock"),
+      hostname: Buffer.from(""),
+    },
+  ] as const;
+
+  for (const { unix, hostname } of permutations) {
+    test(`unix: ${unix} and hostname: ${hostname}`, () => {
+      using server = serve({
+        // @ts-expect-error - Testing invalid combination
+        unix,
+        // @ts-expect-error - Testing invalid combination
+        hostname,
+        port: 0,
+        fetch() {
+          return new Response("ok");
+        },
+      });
+      // @ts-expect-error - Testing invalid property
+      expect(server.address + "").toBe(unix + "");
+      expect(server.port).toBeUndefined();
+      expect(server.hostname).toBeUndefined();
+      server.stop();
+    });
+  }
+});
+
+describe("hostname and port works", () => {
+  const permutations = [
+    {
+      port: 0,
+      hostname: defaultHostname,
+      unix: undefined,
+    },
+    {
+      port: 0,
+      hostname: undefined,
+      unix: "",
+    },
+    {
+      port: 0,
+      hostname: null,
+      unix: "",
+    },
+    {
+      port: 0,
+      hostname: null,
+      unix: Buffer.from(""),
+    },
+    {
+      port: 0,
+      hostname: Buffer.from(defaultHostname),
+      unix: Buffer.from(""),
+    },
+    {
+      port: 0,
+      hostname: Buffer.from(defaultHostname),
+      unix: undefined,
+    },
+  ] as const;
+
+  for (const { port, hostname, unix } of permutations) {
+    test(`port: ${port} and hostname: ${hostname} and unix: ${unix}`, () => {
+      using server = serve({
+        port,
+        // @ts-expect-error - Testing invalid combination
+        hostname,
+        // @ts-expect-error - Testing invalid combination
+        unix,
+        fetch() {
+          return new Response("ok");
+        },
+      });
+      expect(server.port).toBeGreaterThan(0);
+      expect(server.hostname).toBe((hostname || defaultHostname) + "");
+      server.stop();
+    });
+  }
+});
+
+describe("Bun.serve error handling", () => {
+  test("missing fetch handler throws", () => {
+    // @ts-expect-error - Testing runtime behavior
+    expect(() => serve({})).toThrow();
+  });
+
+  test("custom error handler", () => {
+    using server = serve({
+      port: 0,
+      error(error) {
+        return new Response(`Error: ${error.message}`, { status: 500 });
+      },
+      fetch() {
+        throw new Error("test error");
+      },
+    });
+    server.stop();
+  });
+});
+
+describe("Bun.serve websocket options", () => {
+  test("basic websocket config", () => {
+    using server = serve({
+      port: 0,
+      websocket: {
+        message(ws, message) {
+          ws.send(message);
+        },
+      },
+      fetch(req, server) {
+        if (server.upgrade(req)) {
+          return;
+        }
+        return new Response("Not a websocket");
+      },
+    });
+    server.stop();
+  });
+
+  test("websocket with all handlers", () => {
+    using server = serve({
+      port: 0,
+      websocket: {
+        open(ws) {},
+        message(ws, message) {},
+        drain(ws) {},
+        close(ws, code, reason) {},
+        ping(ws, data) {},
+        pong(ws, data) {},
+      },
+      fetch() {
+        return new Response("ok");
+      },
+    });
+    server.stop();
+  });
+
+  test("websocket with custom limits", () => {
+    using server = serve({
+      port: 0,
+      websocket: {
+        message(ws, message) {},
+        maxPayloadLength: 1024 * 1024, // 1MB
+        backpressureLimit: 1024 * 512, // 512KB
+        closeOnBackpressureLimit: true,
+        idleTimeout: 60, // 1 minute
+      },
+      fetch() {
+        return new Response("ok");
+      },
+    });
+    server.stop();
+  });
+
+  test("websocket with compression options", () => {
+    using server = serve({
+      port: 0,
+      websocket: {
+        message(ws, message) {},
+        perMessageDeflate: {
+          compress: true,
+          decompress: "shared",
+        },
+      },
+      fetch() {
+        return new Response("ok");
+      },
+    });
+    server.stop();
+  });
+});
+
+describe("Bun.serve development options", () => {
+  test("development mode", () => {
+    using server = serve({
+      development: true,
+      port: 0,
+      fetch() {
+        return new Response("ok");
+      },
+    });
+    expect(server.development).toBe(true);
+    server.stop();
+  });
+
+  test("custom server id", () => {
+    using server = serve({
+      id: "test-server",
+      port: 0,
+      fetch() {
+        return new Response("ok");
+      },
+    });
+    expect(server.id).toBe("test-server");
+    server.stop();
+  });
+});
+
+describe("Bun.serve static routes", () => {
+  test("static route handling", () => {
+    using server = serve({
+      port: 0,
+      static: {
+        "/": new Response("Home"),
+        "/about": new Response("About"),
+      },
+      fetch() {
+        return new Response("Not found");
+      },
+    });
+    server.stop();
+  });
+});
+
+describe("Bun.serve unix socket", () => {
+  test("unix socket config", () => {
+    const tmpdir = tmpdirSync();
+    using server = serve({
+      unix: tmpdir + "/test.sock",
+      fetch() {
+        return new Response("ok");
+      },
+    });
+    server.stop();
+  });
+
+  test("unix socket with websocket", () => {
+    const tmpdir = tmpdirSync();
+    using server = serve({
+      unix: tmpdir + "/test.sock",
+      websocket: {
+        message(ws, message) {},
+      },
+      fetch() {
+        return new Response("ok");
+      },
+    });
+    server.stop();
+  });
+});
+
+describe("Bun.serve hostname and port validation", () => {
+  test("hostname with port 0 gets random port", () => {
+    using server = serve({
+      hostname: "127.0.0.1",
+      port: 0,
+      fetch() {
+        return new Response("ok");
+      },
+    });
+    expect(server.port).toBeGreaterThan(0);
+    expect(server.hostname).toBe("127.0.0.1");
+    server.stop();
+  });
+
+  test("port with no hostname gets default hostname", () => {
+    using server = serve({
+      port: 0,
+      fetch() {
+        return new Response("ok");
+      },
+    });
+    expect(server.port).toBeGreaterThan(0);
+    expect(server.hostname).toBe(defaultHostname); // Default hostname
+    server.stop();
+  });
+
+  test("hostname with unix should throw", () => {
+    expect(() =>
+      serve({
+        // @ts-expect-error - Testing invalid combination
+        hostname: defaultHostname,
+        unix: "test.sock",
+        fetch() {
+          return new Response("ok");
+        },
+      }),
+    ).toThrow();
+  });
+
+  test("unix with no hostname/port is valid", () => {
+    const tmpdir = tmpdirSync();
+    using server = serve({
+      unix: tmpdir + "/test.sock",
+      fetch() {
+        return new Response("ok");
+      },
+    });
+    server.stop();
+  });
+
+  describe("various valid hostnames", () => {
+    const validHostnames = [defaultHostname, "127.0.0.1", "0.0.0.0"];
+
+    for (const hostname of validHostnames) {
+      test(hostname, () => {
+        using server = serve({
+          hostname,
+          port: 0,
+          fetch() {
+            return new Response("ok");
+          },
+        });
+        expect(server.hostname).toBe(hostname);
+        server.stop();
+      });
+    }
+  });
+
+  describe("various port types", () => {
+    const validPorts = [
+      [0, expect.any(Number)], // random port
+      ["0", expect.any(Number)], // random port as string
+    ] as const;
+
+    for (const [input, expected] of validPorts) {
+      test(JSON.stringify(input), () => {
+        using server = serve({
+          port: input,
+          fetch() {
+            return new Response("ok");
+          },
+        });
+
+        if (typeof expected === "object") {
+          expect(server.port).toBeGreaterThan(0);
+        } else {
+          expect(server.port).toBe(expected);
+        }
+        server.stop();
+      });
+    }
+  });
+});
+
+describe("Bun.serve hostname coercion", () => {
+  test.todo("number hostnames coerce to string", () => {
+    using server = serve({
+      // @ts-expect-error - Testing runtime coercion
+      hostname: 0, // Should coerce to "0"
+      port: 0,
+      fetch() {
+        return new Response("ok");
+      },
+    });
+    expect(server.hostname).toBe("0");
+    server.stop();
+  });
+
+  test("object with toString() coerces to string", () => {
+    const customHostname = {
+      toString() {
+        return defaultHostname;
+      },
+    };
+
+    using server = serve({
+      // @ts-expect-error - Testing runtime coercion
+      hostname: customHostname,
+      port: 0,
+      fetch() {
+        return new Response("ok");
+      },
+    });
+    expect(server.hostname).toBe(defaultHostname);
+    server.stop();
+  });
+
+  test("invalid toString() results should throw", () => {
+    const invalidHostnames = [
+      {
+        toString() {
+          return {};
+        },
+      },
+      {
+        toString() {
+          return [];
+        },
+      },
+      {
+        toString() {
+          return null;
+        },
+      },
+      {
+        toString() {
+          return undefined;
+        },
+      },
+      {
+        toString() {
+          throw new Error("invalid toString");
+        },
+      },
+      {
+        toString() {
+          return Symbol("test");
+        },
+      },
+    ];
+
+    for (const hostname of invalidHostnames) {
+      expect(() =>
+        serve({
+          // @ts-expect-error - Testing runtime coercion
+          hostname,
+          port: 0,
+          fetch() {
+            return new Response("ok");
+          },
+        }),
+      ).toThrow();
+    }
+  });
+
+  test("symbol hostnames should throw", () => {
+    expect(() =>
+      serve({
+        // @ts-expect-error - Testing runtime behavior
+        hostname: Symbol("test"),
+        port: 0,
+        fetch() {
+          return new Response("ok");
+        },
+      }),
+    ).toThrow();
+  });
+
+  test("coerced hostnames must still be valid", () => {
+    const invalidCoercions = [
+      {
+        toString() {
+          return "http://example.com";
+        },
+      },
+      {
+        toString() {
+          return "example.com:3000";
+        },
+      },
+      {
+        toString() {
+          return "-invalid.com";
+        },
+      },
+    ];
+
+    for (const hostname of invalidCoercions) {
+      expect(() =>
+        serve({
+          // @ts-expect-error - Testing runtime coercion
+          hostname,
+          port: 0,
+          fetch() {
+            return new Response("ok");
+          },
+        }),
+      ).toThrow();
+    }
+  });
+
+  describe("falsy values should use default or throw", () => {
+    test("undefined should use default", () => {
+      using server = serve({
+        hostname: undefined,
+        port: 0,
+        fetch() {
+          return new Response("ok");
+        },
+      });
+      expect(server.hostname).toBe(defaultHostname);
+      server.stop();
+    });
+
+    test("null should NOT throw", () => {
+      expect(() => {
+        using server = serve({
+          // @ts-expect-error - Testing runtime behavior
+          hostname: null,
+          port: 0,
+          fetch() {
+            return new Response("ok");
+          },
+        });
+        expect(server.hostname).toBe(defaultHostname);
+      }).not.toThrow();
+
+      test("empty string should be ignored", () => {
+        expect(() => {
+          using server = serve({
+            hostname: "",
+            port: 0,
+            fetch() {
+              return new Response("ok");
+            },
+          });
+          expect(server.hostname).toBe(defaultHostname);
+        }).not.toThrow();
+      });
+    });
+  });
+});
+
+describe("Bun.serve unix socket validation", () => {
+  test("unix socket with hostname should throw", () => {
+    expect(() =>
+      serve({
+        unix: "/tmp/test.sock",
+        // @ts-expect-error - Testing invalid combination
+        hostname: defaultHostname, // Cannot combine with unix
+        fetch() {
+          return new Response("ok");
+        },
+      }),
+    ).toThrow();
+  });
+
+  describe("invalid unix socket paths should throw", () => {
+    const invalidPaths = [
+      {
+        toString() {
+          throw new Error("invalid toString");
+        },
+        toJSON() {
+          return "invalid toJSON";
+        },
+      },
+      {
+        toString() {
+          return Symbol("test");
+        },
+        toJSON() {
+          return "Symbol(test)";
+        },
+      },
+    ];
+
+    for (const unix of invalidPaths) {
+      test(JSON.stringify(unix), () => {
+        expect(() =>
+          serve({
+            // @ts-expect-error - Testing invalid unix socket path
+            unix,
+            fetch() {
+              return new Response("ok");
+            },
+          }),
+        ).toThrow();
+      });
+    }
+  });
+
+  test("unix socket path coercion", () => {
+    // Number should coerce to string
+    using server = serve({
+      // @ts-expect-error - Testing runtime coercion
+      unix: Math.ceil(Math.random() * 100000000),
+      fetch() {
+        return new Response("ok");
+      },
+    });
+    server.stop();
+
+    // Object with toString()
+    const pathObj = {
+      toString() {
+        return Math.random().toString(32).slice(2, 15) + ".sock";
+      },
+    };
+
+    using server2 = serve({
+      // @ts-expect-error - Testing runtime coercion
+      unix: pathObj,
+      fetch() {
+        return new Response("ok");
+      },
+    });
+    server2.stop();
+  });
+
+  test("invalid unix socket path coercion should throw", () => {
+    const invalidCoercions = [
+      {
+        toString() {
+          throw new Error("invalid toString");
+        },
+      },
+    ];
+
+    for (const unix of invalidCoercions) {
+      expect(() => {
+        using server = serve({
+          port: 0,
+          // @ts-expect-error - Testing runtime coercion
+          unix,
+          fetch() {
+            return new Response("ok");
+          },
+        });
+        server.stop();
+      }).toThrow();
+    }
+  });
+});
diff --git a/test/js/bun/http/bun-serve-exports-fixture.js b/test/js/bun/http/bun-serve-exports-fixture.js
new file mode 100644
index 0000000000..63d070d51a
--- /dev/null
+++ b/test/js/bun/http/bun-serve-exports-fixture.js
@@ -0,0 +1,5 @@
+export const port = 0;
+
+export function fetch() {
+  return new Response();
+}
diff --git a/test/js/bun/http/bun-serve-ssl.test.ts b/test/js/bun/http/bun-serve-ssl.test.ts
new file mode 100644
index 0000000000..6e1bdee584
--- /dev/null
+++ b/test/js/bun/http/bun-serve-ssl.test.ts
@@ -0,0 +1,152 @@
+import { describe, expect, test } from "bun:test";
+import privateKey from "../../third_party/jsonwebtoken/priv.pem" with { type: "text" };
+import publicKey from "../../third_party/jsonwebtoken/pub.pem" with { type: "text" };
+import { tls } from "harness";
+
+describe("Bun.serve SSL validations", () => {
+  const fixtures = [
+    {
+      label: "invalid key",
+      tls: {
+        key: privateKey.slice(100),
+        cert: publicKey,
+      },
+    },
+    {
+      label: "invalid key #2",
+      tls: {
+        key: privateKey.slice(0, -20),
+        cert: publicKey,
+      },
+    },
+    {
+      label: "invalid cert",
+      tls: {
+        key: privateKey,
+        cert: publicKey.slice(0, -40),
+      },
+    },
+    {
+      label: "invalid cert #2",
+      tls: [
+        {
+          key: privateKey,
+          cert: publicKey,
+          serverName: "error-mc-erroryface.com",
+        },
+        {
+          key: privateKey,
+          cert: publicKey.slice(0, -40),
+          serverName: "error-mc-erroryface.co.uk",
+        },
+      ],
+    },
+    {
+      label: "invalid serverName: missing serverName",
+      tls: [
+        {
+          key: privateKey,
+          cert: publicKey,
+          serverName: "hello.com",
+        },
+        {
+          key: privateKey,
+          cert: publicKey,
+        },
+      ],
+    },
+    {
+      label: "invalid serverName: empty serverName",
+      tls: [
+        {
+          key: privateKey,
+          cert: publicKey,
+          serverName: "hello.com",
+        },
+        {
+          key: privateKey,
+          cert: publicKey,
+          serverName: "",
+        },
+      ],
+    },
+  ];
+  for (const development of [true, false]) {
+    for (const fixture of fixtures) {
+      test(`${fixture.label} ${development ? "development" : "production"}`, () => {
+        expect(() => {
+          Bun.serve({
+            port: 0,
+            tls: fixture.tls,
+            fetch: () => new Response("Hello, world!"),
+            development,
+          });
+        }).toThrow();
+      });
+    }
+  }
+
+  const validFixtures = [
+    {
+      label: "valid",
+      tls: {
+        key: privateKey,
+        cert: publicKey,
+      },
+    },
+    {
+      label: "valid 2",
+      tls: [
+        {
+          key: privateKey,
+          cert: publicKey,
+          serverName: "localhost",
+        },
+        {
+          key: privateKey,
+          cert: publicKey,
+          serverName: "localhost2.com",
+        },
+      ],
+    },
+  ];
+  for (const development of [true, false]) {
+    for (const fixture of validFixtures) {
+      test(`${fixture.label} ${development ? "development" : "production"}`, async () => {
+        using server = Bun.serve({
+          port: 0,
+          tls: fixture.tls,
+          fetch: () => new Response("Hello, world!"),
+          development,
+        });
+        expect(server.url).toBeDefined();
+        expect().pass();
+        let serverNames = Array.isArray(fixture.tls) ? fixture.tls.map(({ serverName }) => serverName) : ["localhost"];
+
+        for (const serverName of serverNames) {
+          const res = await fetch(server.url, {
+            headers: {
+              Host: serverName,
+            },
+            tls: {
+              rejectUnauthorized: false,
+            },
+            keepAlive: false,
+          });
+          expect(res.status).toBe(200);
+          expect(await res.text()).toBe("Hello, world!");
+        }
+
+        const res = await fetch(server.url, {
+          headers: {
+            Host: "badhost.com",
+          },
+          tls: {
+            rejectUnauthorized: false,
+          },
+          keepAlive: false,
+        });
+      });
+    }
+  }
+});
diff --git a/test/js/bun/http/bun-serve-static.test.ts b/test/js/bun/http/bun-serve-static.test.ts
index 2f2e96992b..df9aac2ee2 100644
--- a/test/js/bun/http/bun-serve-static.test.ts
+++ b/test/js/bun/http/bun-serve-static.test.ts
@@ -1,5 +1,5 @@
 import { afterAll, beforeAll, describe, expect, it, mock, test } from "bun:test";
-import { fillRepeating, isWindows } from "harness";
+import { fillRepeating, isBroken, isMacOS, isWindows } from "harness";
 
 const routes = {
   "/foo": new Response("foo", {
@@ -38,7 +38,7 @@ for (const [path, response] of Object.entries(routes)) {
   static_responses[path] = await response.clone().blob();
 }
 
-describe("static", () => {
+describe.todoIf(isBroken && isMacOS)("static", () => {
   let server: Server;
   let handler = mock(req => {
     return new Response(req.url, {
diff --git a/test/js/bun/http/bun-server.test.ts b/test/js/bun/http/bun-server.test.ts
index f6ebd8a57a..de430f36e3 100644
--- a/test/js/bun/http/bun-server.test.ts
+++ b/test/js/bun/http/bun-server.test.ts
@@ -100,7 +100,7 @@ describe("Server", () => {
   });
 
   test("should not allow Bun.serve with invalid tls option", () => {
-    [1, "string", true, Symbol("symbol"), false].forEach(value => {
+    [1, "string", true, Symbol("symbol")].forEach(value => {
       expect(() => {
         using server = Bun.serve({
           //@ts-ignore
@@ -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/http/fetch-file-upload.test.ts b/test/js/bun/http/fetch-file-upload.test.ts
index 1045e0a768..ae8a26a870 100644
--- a/test/js/bun/http/fetch-file-upload.test.ts
+++ b/test/js/bun/http/fetch-file-upload.test.ts
@@ -1,5 +1,5 @@
 import { expect, test } from "bun:test";
-import { withoutAggressiveGC } from "harness";
+import { isBroken, isWindows, withoutAggressiveGC } from "harness";
 import { tmpdir } from "os";
 import { join } from "path";
 
@@ -126,34 +126,38 @@ test("formData uploads roundtrip, without a call to .body", async () => {
   expect(await (resData.get("file") as Blob).arrayBuffer()).toEqual(await file.arrayBuffer());
 });
 
-test("uploads roundtrip with sendfile()", async () => {
-  const hugeTxt = Buffer.allocUnsafe(1024 * 1024 * 32 * "huge".length);
-  hugeTxt.fill("huge");
-  const hash = Bun.CryptoHasher.hash("sha256", hugeTxt, "hex");
+test.todoIf(isBroken && isWindows)(
+  "uploads roundtrip with sendfile()",
+  async () => {
+    const hugeTxt = Buffer.allocUnsafe(1024 * 1024 * 32 * "huge".length);
+    hugeTxt.fill("huge");
+    const hash = Bun.CryptoHasher.hash("sha256", hugeTxt, "hex");
 
-  const path = join(tmpdir(), "huge.txt");
-  require("fs").writeFileSync(path, hugeTxt);
-  using server = Bun.serve({
-    port: 0,
-    development: false,
-    maxRequestBodySize: hugeTxt.byteLength * 2,
-    async fetch(req) {
-      const hasher = new Bun.CryptoHasher("sha256");
-      for await (let chunk of req.body!) {
-        hasher.update(chunk);
-      }
-      return new Response(hasher.digest("hex"));
-    },
-  });
+    const path = join(tmpdir(), "huge.txt");
+    require("fs").writeFileSync(path, hugeTxt);
+    using server = Bun.serve({
+      port: 0,
+      development: false,
+      maxRequestBodySize: hugeTxt.byteLength * 2,
+      async fetch(req) {
+        const hasher = new Bun.CryptoHasher("sha256");
+        for await (let chunk of req.body!) {
+          hasher.update(chunk);
+        }
+        return new Response(hasher.digest("hex"));
+      },
+    });
 
-  const resp = await fetch(server.url, {
-    body: Bun.file(path),
-    method: "PUT",
-  });
+    const resp = await fetch(server.url, {
+      body: Bun.file(path),
+      method: "PUT",
+    });
 
-  expect(resp.status).toBe(200);
-  expect(await resp.text()).toBe(hash);
-}, 10_000);
+    expect(resp.status).toBe(200);
+    expect(await resp.text()).toBe(hash);
+  },
+  10_000,
+);
 
 test("missing file throws the expected error", async () => {
   Bun.gc(true);
diff --git a/test/js/bun/http/getIfPropertyExists.test.ts b/test/js/bun/http/getIfPropertyExists.test.ts
new file mode 100644
index 0000000000..2de06930f6
--- /dev/null
+++ b/test/js/bun/http/getIfPropertyExists.test.ts
@@ -0,0 +1,37 @@
+import { test, expect, describe } from "bun:test";
+import * as ServerOptions from "./bun-serve-exports-fixture.js";
+import * as RequestOptions from "./bun-request-fixture.js";
+
+describe("getIfPropertyExists", () => {
+  test("Bun.serve()", async () => {
+    expect(() => Bun.serve(ServerOptions).stop(true)).not.toThrow();
+  });
+
+  test("new Request()", async () => {
+    expect(await new Request("https://example.com/", RequestOptions).json()).toEqual({
+      hello: "world",
+    });
+  });
+
+  test("calls proxy getters", async () => {
+    expect(
+      await new Request(
+        "https://example.com/",
+        new Proxy(
+          {},
+          {
+            get: (target, prop) => {
+              if (prop === "body") {
+                return JSON.stringify({ hello: "world" });
+              } else if (prop === "method") {
+                return "POST";
+              }
+            },
+          },
+        ),
+      ).json(),
+    ).toEqual({
+      hello: "world",
+    });
+  });
+});
diff --git a/test/js/bun/http/hspec.test.ts b/test/js/bun/http/hspec.test.ts
new file mode 100644
index 0000000000..b2715ff831
--- /dev/null
+++ b/test/js/bun/http/hspec.test.ts
@@ -0,0 +1,7 @@
+import { test, expect } from "bun:test";
+import { runTests } from "./http-spec.ts";
+
+test("https://github.com/uNetworking/h1spec tests pass", async () => {
+  const passed = await runTests();
+  expect(passed).toBe(true);
+});
diff --git a/test/js/bun/http/http-spec.ts b/test/js/bun/http/http-spec.ts
new file mode 100644
index 0000000000..f51126b2d7
--- /dev/null
+++ b/test/js/bun/http/http-spec.ts
@@ -0,0 +1,344 @@
+// https://github.com/uNetworking/h1spec
+// https://github.com/oven-sh/bun/issues/14826
+// Thanks to Alex Hultman
+import net from "net";
+
+// Define test cases
+interface TestCase {
+  request: string;
+  description: string;
+  expectedStatus: [number, number][];
+  expectedTimeout?: boolean;
+}
+
+const testCases: TestCase[] = [
+  {
+    request: "G",
+    description: "Fragmented method",
+    expectedStatus: [[-1, -1]],
+    expectedTimeout: true,
+  },
+  {
+    request: "GET ",
+    description: "Fragmented URL 1",
+    expectedStatus: [[-1, -1]],
+    expectedTimeout: true,
+  },
+  {
+    request: "GET /hello",
+    description: "Fragmented URL 2",
+    expectedStatus: [[-1, -1]],
+    expectedTimeout: true,
+  },
+  {
+    request: "GET /hello ",
+    description: "Fragmented URL 3",
+    expectedStatus: [[-1, -1]],
+    expectedTimeout: true,
+  },
+  {
+    request: "GET /hello HTTP",
+    description: "Fragmented HTTP version",
+    expectedStatus: [[-1, -1]],
+    expectedTimeout: true,
+  },
+  {
+    request: "GET /hello HTTP/1.1",
+    description: "Fragmented request line",
+    expectedStatus: [[-1, -1]],
+    expectedTimeout: true,
+  },
+  {
+    request: "GET /hello HTTP/1.1\r",
+    description: "Fragmented request line newline 1",
+    expectedStatus: [[-1, -1]],
+    expectedTimeout: true,
+  },
+  {
+    request: "GET /hello HTTP/1.1\r\n",
+    description: "Fragmented request line newline 2",
+    expectedStatus: [[-1, -1]],
+    expectedTimeout: true,
+  },
+  {
+    request: "GET /hello HTTP/1.1\r\nHos",
+    description: "Fragmented field name",
+    expectedStatus: [[-1, -1]],
+    expectedTimeout: true,
+  },
+  {
+    request: "GET /hello HTTP/1.1\r\nHost:",
+    description: "Fragmented field value 1",
+    expectedStatus: [[-1, -1]],
+    expectedTimeout: true,
+  },
+  {
+    request: "GET /hello HTTP/1.1\r\nHost: ",
+    description: "Fragmented field value 2",
+    expectedStatus: [[-1, -1]],
+    expectedTimeout: true,
+  },
+  {
+    request: "GET /hello HTTP/1.1\r\nHost: localhost",
+    description: "Fragmented field value 3",
+    expectedStatus: [[-1, -1]],
+    expectedTimeout: true,
+  },
+  {
+    request: "GET /hello HTTP/1.1\r\nHost: localhost\r",
+    description: "Fragmented field value 4",
+    expectedStatus: [[-1, -1]],
+    expectedTimeout: true,
+  },
+  {
+    request: "GET /hello HTTP/1.1\r\nHost: localhost\r\n",
+    description: "Fragmented request",
+    expectedStatus: [[-1, -1]],
+    expectedTimeout: true,
+  },
+  {
+    request: "GET /hello HTTP/1.1\r\nHost: localhost\r\n\r",
+    description: "Fragmented request termination",
+    expectedStatus: [[-1, -1]],
+    expectedTimeout: true,
+  },
+  {
+    request: "GET / \r\n\r\n",
+    description: "Request without HTTP version",
+    expectedStatus: [[400, 599]],
+  },
+  {
+    request: "GET / HTTP/1.1\r\nHost: example.com\r\nExpect: 100-continue\r\n\r\n",
+    description: "Request with Expect header",
+    expectedStatus: [
+      [100, 100],
+      [200, 299],
+    ],
+  },
+  {
+    request: "GET / HTTP/1.1\r\nHost: example.com\r\n\r\n",
+    description: "Valid GET request",
+    expectedStatus: [[200, 299]],
+  },
+  {
+    request: "GET / HTTP/1.0\r\nHost: example.com\r\n\r\n",
+    description: "Valid GET request with HTTP/1.0",
+    expectedStatus: [[200, 299]],
+  },
+  {
+    request: "GET http://example.com/ HTTP/1.1\r\nHost: example.com\r\n\r\n",
+    description: "Valid GET request for a proxy URL",
+    expectedStatus: [[200, 299]],
+  },
+  {
+    request: "GET https://example.com/ HTTP/1.1\r\nHost: example.com\r\n\r\n",
+    description: "Valid GET request for an https proxy URL",
+    expectedStatus: [[200, 299]],
+  },
+  {
+    request: "GET HTTPS://example.com/ HTTP/1.1\r\nHost: example.com\r\n\r\n",
+    description: "Valid GET request for an HTTPS proxy URL",
+    expectedStatus: [[200, 299]],
+  },
+  {
+    request: "GET HTTPZ://example.com/ HTTP/1.1\r\nHost: example.com\r\n\r\n",
+    description: "Invalid GET request for an HTTPS proxy URL",
+    expectedStatus: [[400, 499]],
+  },
+  {
+    request: "GET H-TTP://example.com/ HTTP/1.1\r\nHost: example.com\r\n\r\n",
+    description: "Invalid GET request for an HTTPS proxy URL",
+    expectedStatus: [[400, 499]],
+  },
+  {
+    request: "GET HTTP://example.com/ HTTP/1.1\r\nHost: example.com\r\n\r\n",
+    description: "Valid GET request for an HTTP proxy URL",
+    expectedStatus: [[200, 299]],
+  },
+  {
+    request: "GET   HTTP/1.1\r\nHost: example.com\r\n\r\n",
+    description: "Invalid GET request target (space)",
+    expectedStatus: [[400, 499]],
+  },
+  {
+    request: "GET ^ HTTP/1.1\r\nHost: example.com\r\n\r\n",
+    description: "Invalid GET request target (caret)",
+    expectedStatus: [[400, 499]],
+  },
+  {
+    request: "GET / HTTP/1.1\r\nhoSt:\texample.com\r\nempty:\r\n\r\n",
+    description: "Valid GET request with edge cases",
+    expectedStatus: [[200, 299]],
+  },
+  {
+    request: "GET / HTTP/1.1\r\nHost: example.com\r\nX-Invalid[]: test\r\n\r\n",
+    description: "Invalid header characters",
+    expectedStatus: [[400, 499]],
+  },
+  {
+    request: "GET / HTTP/1.1\r\nContent-Length: 5\r\n\r\n",
+    description: "Missing Host header",
+    expectedStatus: [[400, 499]],
+  },
+  {
+    request: "GET / HTTP/1.1\r\nHost: example.com\r\nContent-Length: -123456789123456789123456789\r\n\r\n",
+    description: "Overflowing negative Content-Length header",
+    expectedStatus: [[400, 499]],
+  },
+  {
+    request: "GET / HTTP/1.1\r\nHost: example.com\r\nContent-Length: -1234\r\n\r\n",
+    description: "Negative Content-Length header",
+    expectedStatus: [[400, 499]],
+  },
+  {
+    request: "GET / HTTP/1.1\r\nHost: example.com\r\nContent-Length: abc\r\n\r\n",
+    description: "Non-numeric Content-Length header",
+    expectedStatus: [[400, 499]],
+  },
+  {
+    request: "GET / HTTP/1.1\r\nHost: example.com\r\nX-Empty-Header: \r\n\r\n",
+    description: "Empty header value",
+    expectedStatus: [[200, 299]],
+  },
+  {
+    request: "GET / HTTP/1.1\r\nHost: example.com\r\nX-Bad-Control-Char: test\x07\r\n\r\n",
+    description: "Header containing invalid control character",
+    expectedStatus: [[400, 499]],
+  },
+  {
+    request: "GET / HTTP/9.9\r\nHost: example.com\r\n\r\n",
+    description: "Invalid HTTP version",
+    expectedStatus: [
+      [400, 499],
+      [500, 599],
+    ],
+  },
+  {
+    request: "Extra lineGET / HTTP/1.1\r\nHost: example.com\r\n\r\n",
+    description: "Invalid prefix of request",
+    expectedStatus: [
+      [400, 499],
+      [500, 599],
+    ],
+  },
+  {
+    request: "GET / HTTP/1.1\r\nHost: example.com\r\n\rSome-Header: Test\r\n\r\n",
+    description: "Invalid line ending",
+    expectedStatus: [[400, 499]],
+  },
+  {
+    request: "POST / HTTP/1.1\r\nHost: example.com\r\nContent-Length: 5\r\n\r\nhello",
+    description: "Valid POST request with body",
+    expectedStatus: [
+      [200, 299],
+      [404, 404],
+    ],
+  },
+  {
+    request: "GET / HTTP/1.1\r\nHost: example.com\r\nTransfer-Encoding: chunked\r\nContent-Length: 5\r\n\r\n",
+    description: "Conflicting Transfer-Encoding and Content-Length",
+    expectedStatus: [[400, 499]],
+  },
+];
+
+export async function runTestsStandalone(host: string, port: number) {
+  const results = await Promise.all(testCases.map(testCase => runTestCase(testCase, host, parseInt(port, 10))));
+
+  const passedCount = results.filter(result => result).length;
+  console.log(`\n${passedCount} out of ${testCases.length} tests passed.`);
+  return passedCount === testCases.length;
+}
+
+// Run all test cases in parallel
+export async function runTests() {
+  let host, port;
+
+  using server = Bun.serve({
+    port: 0,
+    fetch(req) {
+      return new Response("Hello, world!");
+    },
+  });
+
+  host = server.url.hostname;
+  port = server.url.port;
+  return await runTestsStandalone(host, port);
+}
+
+// Run a single test case with a 3-second timeout on reading
+async function runTestCase(testCase: TestCase, host: string, port: number): Promise<boolean> {
+  try {
+    const conn = new Promise((resolve, reject) => {
+      const client = net.createConnection({ host, port }, () => {
+        resolve(client);
+      });
+      client.on("error", reject);
+    });
+
+    const client: net.Socket = await conn;
+
+    // Send the request
+    client.write(Buffer.from(testCase.request));
+
+    // Set up a read timeout promise
+    const readTimeout = new Promise<boolean>(resolve => {
+      const timeoutId = setTimeout(() => {
+        if (testCase.expectedTimeout) {
+          console.log(`✅ ${testCase.description}: Server waited successfully`);
+          client.destroy(); // Ensure the connection is closed on timeout
+          resolve(true);
+        } else {
+          console.error(`❌ ${testCase.description}: Read operation timed out`);
+          client.destroy(); // Ensure the connection is closed on timeout
+          resolve(false);
+        }
+      }, 500);
+
+      client.on("data", data => {
+        // Clear the timeout if read completes
+        clearTimeout(timeoutId);
+        const response = data.toString();
+        const statusCode = parseStatusCode(response);
+
+        const isSuccess = testCase.expectedStatus.some(([min, max]) => statusCode >= min && statusCode <= max);
+        if (!isSuccess) {
+          console.log(JSON.stringify(response, null, 2));
+        }
+        console.log(
+          `${isSuccess ? "✅" : "❌"} ${
+            testCase.description
+          }: Response Status Code ${statusCode}, Expected ranges: ${JSON.stringify(testCase.expectedStatus)}`,
+        );
+        client.destroy();
+        resolve(isSuccess);
+      });
+
+      client.on("error", error => {
+        clearTimeout(timeoutId);
+        console.error(`Error in test "${testCase.description}":`, error);
+        resolve(false);
+      });
+    });
+
+    // Wait for the read operation or timeout
+    return await readTimeout;
+  } catch (error) {
+    console.error(`Error in test "${testCase.description}":`, error);
+    return false;
+  }
+}
+
+// Parse the HTTP status code from the response
+function parseStatusCode(response: string): number {
+  const statusLine = response.split("\r\n")[0];
+  const match = statusLine.match(/HTTP\/1\.\d (\d{3})/);
+  return match ? parseInt(match[1], 10) : 0;
+}
+
+if (import.meta.main) {
+  if (process.argv.length > 2) {
+    await runTestsStandalone(process.argv[2], parseInt(process.argv[3], 10));
+  } else {
+    await runTests();
+  }
+}
diff --git a/test/js/bun/http/proxy.test.ts b/test/js/bun/http/proxy.test.ts
index 1b6953c70e..8946c4d469 100644
--- a/test/js/bun/http/proxy.test.ts
+++ b/test/js/bun/http/proxy.test.ts
@@ -51,6 +51,8 @@ async function createProxyServer(is_tls: boolean) {
           serverSocket.pipe(clientSocket);
         }
       });
+      // ignore client errors (can happen because of happy eye balls and now we error on write when not connected for node.js compatibility)
+      clientSocket.on("error", () => {});
 
       serverSocket.on("error", err => {
         clientSocket.end();
diff --git a/test/js/bun/http/serve-body-leak.test.ts b/test/js/bun/http/serve-body-leak.test.ts
index 5c2b7bad65..40f260bea5 100644
--- a/test/js/bun/http/serve-body-leak.test.ts
+++ b/test/js/bun/http/serve-body-leak.test.ts
@@ -1,12 +1,13 @@
 import type { Subprocess } from "bun";
 import { afterEach, beforeEach, expect, it } from "bun:test";
-import { bunEnv, bunExe, isDebug } from "harness";
+import { bunEnv, bunExe, isDebug, isFlaky, isLinux } from "harness";
 import { join } from "path";
 
 const payload = Buffer.alloc(512 * 1024, "1").toString("utf-8"); // decent size payload to test memory leak
 const batchSize = 40;
 const totalCount = 10_000;
 const zeroCopyPayload = new Blob([payload]);
+const zeroCopyJSONPayload = new Blob([JSON.stringify({ bun: payload })]);
 
 let url: URL;
 let process: Subprocess<"ignore", "pipe", "inherit"> | null = null;
@@ -63,6 +64,13 @@ async function callBuffering() {
   }).then(res => res.text());
   expect(result).toBe("Ok");
 }
+async function callJSONBuffering() {
+  const result = await fetch(`${url.origin}/json-buffering`, {
+    method: "POST",
+    body: zeroCopyJSONPayload,
+  }).then(res => res.text());
+  expect(result).toBe("Ok");
+}
 
 async function callBufferingBodyGetter() {
   const result = await fetch(`${url.origin}/buffering+body-getter`, {
@@ -142,13 +150,14 @@ async function calculateMemoryLeak(fn: () => Promise<void>) {
 for (const test_info of [
   ["#10265 should not leak memory when ignoring the body", callIgnore, false, 64],
   ["should not leak memory when buffering the body", callBuffering, false, 64],
+  ["should not leak memory when buffering a JSON body", callJSONBuffering, false, 64],
   ["should not leak memory when buffering the body and accessing req.body", callBufferingBodyGetter, false, 64],
-  ["should not leak memory when streaming the body", callStreaming, false, 64],
+  ["should not leak memory when streaming the body", callStreaming, isFlaky && isLinux, 64],
   ["should not leak memory when streaming the body incompletely", callIncompleteStreaming, false, 64],
   ["should not leak memory when streaming the body and echoing it back", callStreamingEcho, false, 64],
 ] as const) {
   const [testName, fn, skip, maxMemoryGrowth] = test_info;
-  it(
+  it.todoIf(skip)(
     testName,
     async () => {
       const report = await calculateMemoryLeak(fn);
diff --git a/test/js/bun/http/serve.test.ts b/test/js/bun/http/serve.test.ts
index 1376c0a1c1..daadea5474 100644
--- a/test/js/bun/http/serve.test.ts
+++ b/test/js/bun/http/serve.test.ts
@@ -1649,6 +1649,24 @@ describe("should error with invalid options", async () => {
       });
     }).toThrow("Expected lowMemoryMode to be a boolean");
   });
+  it("multiple missing server name", () => {
+    expect(() => {
+      Bun.serve({
+        port: 0,
+        fetch(req) {
+          return new Response("hi");
+        },
+        tls: [
+          {
+            key: "lkwejflkwjeflkj",
+          },
+          {
+            key: "lkwjefhwlkejfklwj",
+          },
+        ],
+      });
+    }).toThrow("SNI tls object must have a serverName");
+  });
 });
 it("should resolve pending promise if requested ended with pending read", async () => {
   let error: Error;
@@ -2055,3 +2073,95 @@ it("allow custom timeout per request", async () => {
   expect(res.status).toBe(200);
   expect(res.text()).resolves.toBe("Hello, World!");
 }, 20_000);
+
+it("#6462", async () => {
+  let headers: string[] = [];
+  using server = Bun.serve({
+    port: 0,
+    async fetch(request) {
+      for (const key of request.headers.keys()) {
+        headers = headers.concat([[key, request.headers.get(key)]]);
+      }
+      return new Response(
+        JSON.stringify({
+          "headers": headers,
+        }),
+        { status: 200 },
+      );
+    },
+  });
+
+  const bytes = Buffer.from(`GET / HTTP/1.1\r\nConnection: close\r\nHost: ${server.hostname}\r\nTest!: test\r\n\r\n`);
+  const { promise, resolve } = Promise.withResolvers();
+  await Bun.connect({
+    port: server.port,
+    hostname: server.hostname,
+    socket: {
+      open(socket) {
+        const wrote = socket.write(bytes);
+        console.log("wrote", wrote);
+      },
+      data(socket, data) {
+        console.log(data.toString("utf8"));
+      },
+      close(socket) {
+        resolve();
+      },
+    },
+  });
+  await promise;
+
+  expect(headers).toStrictEqual([
+    ["connection", "close"],
+    ["host", "localhost"],
+    ["test!", "test"],
+  ]);
+});
+
+it("#6583", async () => {
+  const callback = mock();
+  using server = Bun.serve({
+    fetch: callback,
+    port: 0,
+    hostname: "localhost",
+  });
+  const { promise, resolve } = Promise.withResolvers();
+  await Bun.connect({
+    port: server.port,
+    hostname: server.hostname,
+    tls: true,
+    socket: {
+      open(socket) {
+        socket.write("GET / HTTP/1.1\r\nConnection: close\r\nHost: localhost\r\n\r\n");
+      },
+      data(socket, data) {
+        console.log(data.toString("utf8"));
+      },
+      close(socket) {
+        resolve();
+      },
+    },
+  });
+  await promise;
+  expect(callback).not.toHaveBeenCalled();
+});
+
+it("do the best effort to flush everything", async () => {
+  using server = Bun.serve({
+    port: 0,
+    async fetch(req) {
+      return new Response(
+        new ReadableStream({
+          type: "direct",
+          async pull(ctrl) {
+            ctrl.write("b");
+            await Bun.sleep(10);
+            ctrl.write("un");
+          },
+        }),
+      );
+    },
+  });
+  let response = await fetch(server.url);
+  expect(await response.text()).toBe("bun");
+});
diff --git a/test/js/bun/ini/ini.test.ts b/test/js/bun/ini/ini.test.ts
index 7cb732829c..14667b673f 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 */ `
@@ -63,7 +70,7 @@ hello = \${LOL}
 hello = \${oooooooooooooooogaboga}
       `,
       env: {},
-      expected: { hello: "" },
+      expected: { hello: "${oooooooooooooooogaboga}" },
     });
 
     envVarTest({
diff --git a/test/js/bun/plugin/plugins.test.ts b/test/js/bun/plugin/plugins.test.ts
index 1b2013c534..d544fb953b 100644
--- a/test/js/bun/plugin/plugins.test.ts
+++ b/test/js/bun/plugin/plugins.test.ts
@@ -1,7 +1,7 @@
 /// <reference types="./plugins" />
 import { plugin } from "bun";
-import { describe, expect, it } from "bun:test";
-import { resolve } from "path";
+import { describe, expect, it, test } from "bun:test";
+import path, { dirname, join, resolve } from "path";
 
 declare global {
   var failingObject: any;
@@ -187,13 +187,14 @@ plugin({
 // This is to test that it works when imported from a separate file
 import "../../third_party/svelte";
 import "./module-plugins";
+import { render as svelteRender } from 'svelte/server'; 
 
 describe("require", () => {
   it("SSRs `<h1>Hello world!</h1>` with Svelte", () => {
     const { default: App } = require("./hello.svelte");
-    const { html } = App.render();
+    const { body } = svelteRender(App);
 
-    expect(html).toBe("<h1>Hello world!</h1>");
+    expect(body).toBe("<!--[--><h1>Hello world!</h1><!--]-->");
   });
 
   it("beep:boop returns 42", () => {
@@ -293,9 +294,8 @@ describe("dynamic import", () => {
   it("SSRs `<h1>Hello world!</h1>` with Svelte", async () => {
     const { default: App }: any = await import("./hello.svelte");
 
-    const { html } = App.render();
-
-    expect(html).toBe("<h1>Hello world!</h1>");
+    const { body } = svelteRender(App);
+    expect(body).toBe("<!--[--><h1>Hello world!</h1><!--]-->");
   });
 
   it("beep:boop returns 42", async () => {
@@ -324,9 +324,9 @@ import Hello from ${JSON.stringify(resolve(import.meta.dir, "hello2.svelte"))};
 export default Hello;
 `;
     const { default: SvelteApp } = await import("delay:hello2.svelte");
-    const { html } = SvelteApp.render();
+    const { body } = svelteRender(SvelteApp);
 
-    expect(html).toBe("<h1>Hello world!</h1>");
+    expect(body).toBe("<!--[--><h1>Hello world!</h1><!--]-->");
   });
 });
 
diff --git a/test/js/bun/resolve/esModule-annotation.test.js b/test/js/bun/resolve/esModule-annotation.test.js
index bb7b8a6861..4897f265d7 100644
--- a/test/js/bun/resolve/esModule-annotation.test.js
+++ b/test/js/bun/resolve/esModule-annotation.test.js
@@ -20,7 +20,7 @@ describe('without type: "module"', () => {
     });
 
     // The module namespace object will not have the __esModule property.
-    expect(WithoutTypeModuleExportEsModuleAnnotationNoDefault).not.toHaveProperty("__esModule");
+    expect(WithoutTypeModuleExportEsModuleAnnotationNoDefault.__esModule).toBeUndefined();
   });
 
   test("exports.default = true; exports.__esModule = true;", () => {
@@ -48,7 +48,7 @@ describe('with type: "module"', () => {
     });
 
     // The module namespace object WILL have the __esModule property.
-    expect(WithTypeModuleExportEsModuleAnnotationNoDefault).toHaveProperty("__esModule");
+    expect(WithTypeModuleExportEsModuleAnnotationNoDefault.__esModule).toBeTrue();
   });
 
   test("exports.default = true; exports.__esModule = true;", () => {
diff --git a/test/js/bun/resolve/esModule.test.ts b/test/js/bun/resolve/esModule.test.ts
new file mode 100644
index 0000000000..8130a1cbe8
--- /dev/null
+++ b/test/js/bun/resolve/esModule.test.ts
@@ -0,0 +1,27 @@
+import { test, expect } from "bun:test";
+
+const Self = await import("./esModule.test.ts");
+
+test("__esModule defaults to undefined", () => {
+  expect(Self.__esModule).toBeUndefined();
+});
+
+test("__esModule is settable", () => {
+  Self.__esModule = true;
+  expect(Self.__esModule).toBe(true);
+  Self.__esModule = false;
+  expect(Self.__esModule).toBe(undefined);
+  Self.__esModule = true;
+  expect(Self.__esModule).toBe(true);
+  Self.__esModule = undefined;
+});
+
+test("require of self sets __esModule", () => {
+  expect(Self.__esModule).toBeUndefined();
+  {
+    const Self = require("./esModule.test.ts");
+    expect(Self.__esModule).toBe(true);
+  }
+  expect(Self.__esModule).toBe(true);
+  expect(Object.getOwnPropertyNames(Self)).toBeEmpty();
+});
diff --git a/test/js/bun/resolve/import-custom-condition.test.ts b/test/js/bun/resolve/import-custom-condition.test.ts
index fa753b5a0b..ac366209fe 100644
--- a/test/js/bun/resolve/import-custom-condition.test.ts
+++ b/test/js/bun/resolve/import-custom-condition.test.ts
@@ -109,7 +109,7 @@ it("custom condition 'import' in package.json resolves in bun test", async () =>
   });
 
   expect(exitCode).toBe(0);
-  expect(stdout.toString("utf8")).toBe("1\n");
+  expect(stdout.toString("utf8")).toBe(`bun test ${Bun.version_with_sha}\n1\n`);
 });
 
 it("custom condition 'import' in package.json resolves in bun test with browser condition", async () => {
@@ -120,7 +120,7 @@ it("custom condition 'import' in package.json resolves in bun test with browser
   });
 
   expect(exitCode).toBe(0);
-  expect(stdout.toString("utf8")).toBe("2\n");
+  expect(stdout.toString("utf8")).toBe(`bun test ${Bun.version_with_sha}\n2\n`);
 });
 
 it("custom condition 'require' in package.json resolves", async () => {
diff --git a/test/js/bun/resolve/import-meta.test.js b/test/js/bun/resolve/import-meta.test.js
index 668e3ca8e9..9ad8a7bc03 100644
--- a/test/js/bun/resolve/import-meta.test.js
+++ b/test/js/bun/resolve/import-meta.test.js
@@ -1,16 +1,26 @@
 import { spawnSync } from "bun";
-import { expect, it } from "bun:test";
+import { expect, it, mock } from "bun:test";
 import { bunEnv, bunExe, ospath } from "harness";
 import { mkdirSync, rmSync, writeFileSync } from "node:fs";
-import * as Module from "node:module";
+import Module from "node:module";
 import { tmpdir } from "node:os";
 import { join, sep } from "node:path";
 import sync from "./require-json.json";
+import { isModuleResolveFilenameSlowPathEnabled } from "bun:internal-for-testing";
 
 const { path, dir, dirname, filename } = import.meta;
 
 const tmpbase = tmpdir() + sep;
 
+it("import.meta.require is settable", () => {
+  const old = import.meta.require;
+  const fn = mock(() => "hello");
+  import.meta.require = fn;
+  expect(import.meta.require("hello")).toBe("hello");
+  import.meta.require = old;
+  expect(fn).toHaveBeenCalledTimes(1);
+});
+
 it("import.meta.main", () => {
   const { exitCode } = spawnSync({
     cmd: [bunExe(), "run", join(import.meta.dir, "./main-test-script.js")],
@@ -62,8 +72,8 @@ it("Module.createRequire does not use file url as the referrer (err message chec
   } catch (e) {
     expect(e.name).not.toBe("UnreachableError");
     expect(e.message).not.toInclude("file:///");
-    expect(e.message).toInclude('"whaaat"');
-    expect(e.message).toInclude('"' + import.meta.path + '"');
+    expect(e.message).toInclude(`'whaaat'`);
+    expect(e.message).toInclude(`'` + import.meta.path + `'`);
   }
 });
 
@@ -127,7 +137,12 @@ it("Module._cache", () => {
 });
 
 it("Module._resolveFilename()", () => {
-  expect(Module._resolveFilename).toBeUndefined();
+  expect(isModuleResolveFilenameSlowPathEnabled()).toBe(false);
+  const original = Module._resolveFilename;
+  Module._resolveFilename = () => {};
+  expect(isModuleResolveFilenameSlowPathEnabled()).toBe(true);
+  Module._resolveFilename = original;
+  expect(isModuleResolveFilenameSlowPathEnabled()).toBe(false);
 });
 
 it("Module.createRequire(file://url).resolve(file://url)", () => {
diff --git a/test/js/bun/resolve/resolve.test.ts b/test/js/bun/resolve/resolve.test.ts
index 6491d75c2a..d2fa6fbb97 100644
--- a/test/js/bun/resolve/resolve.test.ts
+++ b/test/js/bun/resolve/resolve.test.ts
@@ -1,3 +1,7 @@
+import { it, expect } from "bun:test";
+import { mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
+import { bunExe, bunEnv, tempDirWithFiles, isWindows } from "harness";
 import { pathToFileURL } from "bun";
 import { expect, it } from "bun:test";
 import { mkdirSync, writeFileSync } from "fs";
@@ -311,3 +315,23 @@ it.todo("import override to bun:test", async () => {
   // @ts-expect-error
   expect(await import("#bun_test")).toBeDefined();
 });
+
+it.if(isWindows)("directory cache key computation", () => {
+  expect(import(`${process.cwd()}\\\\doesnotexist.ts`)).rejects.toThrow();
+  expect(import(`${process.cwd()}\\\\\\doesnotexist.ts`)).rejects.toThrow();
+  expect(import(`\\\\Test\\\\doesnotexist.ts\\` as any)).rejects.toThrow();
+  expect(import(`\\\\Test\\\\doesnotexist.ts\\\\` as any)).rejects.toThrow();
+  expect(import(`\\\\Test\\\\doesnotexist.ts\\\\\\` as any)).rejects.toThrow();
+  expect(import(`\\\\Test\\\\\\doesnotexist.ts` as any)).rejects.toThrow();
+  expect(import(`\\\\Test\\\\\\\\doesnotexist.ts` as any)).rejects.toThrow();
+  expect(import(`\\\\Test\\doesnotexist.ts` as any)).rejects.toThrow();
+  expect(import(`\\\\\\Test\\doesnotexist.ts` as any)).rejects.toThrow();
+  expect(import(`\\\\Test\\\\\\doesnotexist.ts\\` as any)).rejects.toThrow();
+  expect(import(`\\\\Test\\\\\\\\doesnotexist.ts\\` as any)).rejects.toThrow();
+  expect(import(`\\\\Test\\doesnotexist.ts\\` as any)).rejects.toThrow();
+  expect(import(`\\\\\\Test\\doesnotexist.ts\\` as any)).rejects.toThrow();
+  expect(import(`\\\\Test\\\\\\doesnotexist.ts\\\\` as any)).rejects.toThrow();
+  expect(import(`\\\\Test\\\\\\\\doesnotexist.ts\\\\` as any)).rejects.toThrow();
+  expect(import(`\\\\Test\\doesnotexist.ts\\\\` as any)).rejects.toThrow();
+  expect(import(`\\\\\\Test\\doesnotexist.ts\\\\` as any)).rejects.toThrow();
+});
diff --git a/test/js/bun/shell/bunshell-default.test.ts b/test/js/bun/shell/bunshell-default.test.ts
index 6c5b6b9ce9..ddd78df4db 100644
--- a/test/js/bun/shell/bunshell-default.test.ts
+++ b/test/js/bun/shell/bunshell-default.test.ts
@@ -23,6 +23,7 @@ test("default throw on command failure", async () => {
 
   await TestBuilder.command`echo ${code} > index.test.ts; ${bunExe()} test index.test.ts`
     .ensureTempDir()
+    .stdout(`bun test ${Bun.version_with_sha}\n`)
     .stderr(s => s.includes("1 pass"))
     .env(bunEnv)
     .run();
@@ -47,6 +48,7 @@ test("ShellError has .text()", async () => {
 
   await TestBuilder.command`echo ${code} > index.test.ts; ${bunExe()} test index.test.ts`
     .ensureTempDir()
+    .stdout(`bun test ${Bun.version_with_sha}\n`)
     .stderr(s => s.includes("1 pass"))
     .env(bunEnv)
     .run();
diff --git a/test/js/bun/shell/exec.test.ts b/test/js/bun/shell/exec.test.ts
index be3a333c31..b7c2721971 100644
--- a/test/js/bun/shell/exec.test.ts
+++ b/test/js/bun/shell/exec.test.ts
@@ -1,11 +1,11 @@
 import { $ } from "bun";
 import { describe, expect, test } from "bun:test";
-import { bunEnv, tmpdirSync } from "harness";
+import { bunEnv, bunExe, tmpdirSync } from "harness";
 import { join } from "path";
 import { createTestBuilder } from "./test_builder";
 const TestBuilder = createTestBuilder(import.meta.path);
 
-const BUN = process.argv0;
+const BUN = bunExe();
 
 $.nothrow();
 describe("bun exec", () => {
@@ -86,8 +86,9 @@ describe("bun exec", () => {
 
   test("works with latin1 paths", async () => {
     const tempdir = tmpdirSync();
-    await Bun.write(join(tempdir, "Í", "hi"), "text");
-    const result = await $`bun exec ls`
+    const abs = join(tempdir, "Í", "hi");
+    await Bun.write(abs, "text");
+    const result = await $`${BUN} exec ls`
       .env({ ...(bunEnv as any) })
       .cwd(join(tempdir, "Í"))
       .quiet();
diff --git a/test/js/bun/spawn/bun-ipc-inherit.test.ts b/test/js/bun/spawn/bun-ipc-inherit.test.ts
index 1c62c53de9..00a4ca8988 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 32221f56d8..3a06a045b6 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-signal.test.ts b/test/js/bun/spawn/spawn-signal.test.ts
new file mode 100644
index 0000000000..535bd23964
--- /dev/null
+++ b/test/js/bun/spawn/spawn-signal.test.ts
@@ -0,0 +1,93 @@
+import { test, expect } from "bun:test";
+import { spawn, sleep } from "bun";
+import { bunEnv, bunExe } from "harness";
+
+test("spawn AbortSignal works after spawning", async () => {
+  const controller = new AbortController();
+  const { signal } = controller;
+  const start = performance.now();
+  const subprocess = Bun.spawn({
+    cmd: [bunExe(), "--eval", "await Bun.sleep(100000)"],
+    env: bunEnv,
+    stdout: "inherit",
+    stderr: "inherit",
+    stdin: "inherit",
+    signal,
+  });
+  await Bun.sleep(1);
+  controller.abort();
+  expect(await subprocess.exited).not.toBe(0);
+  const end = performance.now();
+  expect(end - start).toBeLessThan(100);
+});
+
+test("spawn AbortSignal works if already aborted", async () => {
+  const controller = new AbortController();
+  const { signal } = controller;
+  const start = performance.now();
+  const subprocess = Bun.spawn({
+    cmd: [bunExe(), "--eval", "await Bun.sleep(100000)"],
+    env: bunEnv,
+    stdout: "inherit",
+    stderr: "inherit",
+    stdin: "inherit",
+    signal,
+  });
+  await Bun.sleep(1);
+  controller.abort();
+  expect(await subprocess.exited).not.toBe(0);
+  const end = performance.now();
+  expect(end - start).toBeLessThan(100);
+});
+
+test("spawn AbortSignal args validation", async () => {
+  expect(() =>
+    Bun.spawn({
+      cmd: [bunExe(), "--eval", "await Bun.sleep(100000)"],
+      env: bunEnv,
+      stdout: "inherit",
+      stderr: "inherit",
+      stdin: "inherit",
+      signal: 123,
+    }),
+  ).toThrow();
+});
+
+test("spawnSync AbortSignal works as timeout", async () => {
+  const start = performance.now();
+  const subprocess = Bun.spawnSync({
+    cmd: [bunExe(), "--eval", "await Bun.sleep(100000)"],
+    env: bunEnv,
+    stdout: "inherit",
+    stderr: "inherit",
+    stdin: "inherit",
+    signal: AbortSignal.timeout(10),
+  });
+
+  expect(subprocess.success).toBeFalse();
+  const end = performance.now();
+  expect(end - start).toBeLessThan(100);
+});
+
+// TODO: this test should fail.
+// It passes because we are ticking the event loop incorrectly in spawnSync.
+// it should be ticking a different event loop.
+test("spawnSync AbortSignal...executes javascript?", async () => {
+  const start = performance.now();
+  var signal = AbortSignal.timeout(10);
+  signal.addEventListener("abort", () => {
+    console.log("abort", performance.now());
+  });
+  const subprocess = Bun.spawnSync({
+    cmd: [bunExe(), "--eval", "await Bun.sleep(100000)"],
+    env: bunEnv,
+    stdout: "inherit",
+    stderr: "inherit",
+    stdin: "inherit",
+    signal,
+  });
+  console.log("after", performance.now());
+  expect(subprocess.success).toBeFalse();
+  const end = performance.now();
+  expect(end - start).toBeLessThan(100);
+});
diff --git a/test/js/bun/spawn/spawn.test.ts b/test/js/bun/spawn/spawn.test.ts
index 345e458e22..4f2adf2035 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/sqlite/sqlite.test.js b/test/js/bun/sqlite/sqlite.test.js
index 2836efcd1b..ae57c6cad8 100644
--- a/test/js/bun/sqlite/sqlite.test.js
+++ b/test/js/bun/sqlite/sqlite.test.js
@@ -587,6 +587,50 @@ it("db.query()", () => {
     }
   })(domjit);
 
+  // statement iterator
+  let i;
+  i = 0;
+  for (const row of db.query("SELECT * FROM test")) {
+    i === 0 && expect(JSON.stringify(row)).toBe(JSON.stringify({ id: 1, name: "Hello" }));
+    i === 1 && expect(JSON.stringify(row)).toBe(JSON.stringify({ id: 2, name: "World" }));
+    i++;
+  }
+  expect(i).toBe(2);
+
+  // iterate (no args)
+  i = 0;
+  for (const row of db.query("SELECT * FROM test").iterate()) {
+    i === 0 && expect(JSON.stringify(row)).toBe(JSON.stringify({ id: 1, name: "Hello" }));
+    i === 1 && expect(JSON.stringify(row)).toBe(JSON.stringify({ id: 2, name: "World" }));
+    i++;
+  }
+  expect(i).toBe(2);
+
+  // iterate (args)
+  i = 0;
+  for (const row of db.query("SELECT * FROM test WHERE name = $name").iterate({ $name: "World" })) {
+    i === 0 && expect(JSON.stringify(row)).toBe(JSON.stringify({ id: 2, name: "World" }));
+    i++;
+  }
+  expect(i).toBe(1);
+
+  // interrupted iterating, then call all()
+  const stmt = db.query("SELECT * FROM test");
+  i = 0;
+  for (const row of stmt) {
+    i === 0 && expect(JSON.stringify(row)).toBe(JSON.stringify({ id: 1, name: "Hello" }));
+    i++;
+    break;
+  }
+  expect(i).toBe(1);
+  rows = stmt.all();
+  expect(JSON.stringify(rows)).toBe(
+    JSON.stringify([
+      { id: 1, name: "Hello" },
+      { id: 2, name: "World" },
+    ]),
+  );
+
   db.close();
 
   // Check that a closed database doesn't crash
diff --git a/test/js/bun/symbols.test.ts b/test/js/bun/symbols.test.ts
new file mode 100644
index 0000000000..67127e3555
--- /dev/null
+++ b/test/js/bun/symbols.test.ts
@@ -0,0 +1,65 @@
+import { test, expect } from "bun:test";
+import { $ } from "bun";
+import { bunExe } from "harness";
+import { semver } from "bun";
+
+const BUN_EXE = bunExe();
+
+if (process.platform === "linux") {
+  test("objdump -T does not include symbols from glibc > 2.27", async () => {
+    const objdump = Bun.which("objdump") || Bun.which("llvm-objdump");
+    if (!objdump) {
+      throw new Error("objdump executable not found. Please install it.");
+    }
+
+    const output = await $`${objdump} -T ${BUN_EXE} | grep GLIBC_`.text();
+    const lines = output.split("\n");
+    const errors = [];
+    for (const line of lines) {
+      const match = line.match(/\(GLIBC_2(.*)\)\s/);
+      if (match?.[1]) {
+        let version = "2." + match[1];
+        if (version.startsWith("2..")) {
+          version = "2." + version.slice(3);
+        }
+        if (semver.order(version, "2.27.0") >= 0) {
+          errors.push({
+            symbol: line.slice(line.lastIndexOf(")") + 1).trim(),
+            "glibc version": version,
+          });
+        }
+      }
+    }
+    if (errors.length) {
+      throw new Error(`Found glibc symbols >= 2.27. This breaks Amazon Linux 2 and Vercel.
+
+${Bun.inspect.table(errors, { colors: true })}
+To fix this, add it to -Wl,-wrap=symbol in the linker flags and update workaround-missing-symbols.cpp.`);
+    }
+  });
+
+  test("libatomic.so is not linked", async () => {
+    const ldd = Bun.which("ldd");
+
+    if (!ldd) {
+      throw new Error("ldd executable not found. Please install it.");
+    }
+
+    const output = await $`${ldd} ${BUN_EXE}`.text();
+    const lines = output.split("\n");
+    const errors = [];
+    for (const line of lines) {
+      // libatomic
+      if (line.includes("libatomic")) {
+        errors.push(line);
+      }
+    }
+    if (errors.length) {
+      throw new Error(`libatomic.so is linked. This breaks Amazon Linux 2 and Vercel.
+
+${errors.join("\n")}
+
+To fix this, figure out which C math symbol is being used that causes it, and wrap it in workaround-missing-symbols.cpp.`);
+    }
+  });
+}
diff --git a/test/js/bun/test/__snapshots__/test-interop.js.snap b/test/js/bun/test/__snapshots__/test-interop.js.snap
index eb56d73084..c626a5ab56 100644
--- a/test/js/bun/test/__snapshots__/test-interop.js.snap
+++ b/test/js/bun/test/__snapshots__/test-interop.js.snap
@@ -1,11 +1,3 @@
 // Bun Snapshot v1, https://goo.gl/fbAQLP
 
 exports[`expect() toMatchSnapshot to return undefined 1`] = `"abc"`;
-
-exports[`expect() toMatchSnapshot to return undefined 1`] = `"abc"`;
-
-exports[`expect() toMatchSnapshot to return undefined 1`] = `"abc"`;
-
-exports[`expect() toMatchSnapshot to return undefined 1`] = `"abc"`;
-
-exports[`expect() toMatchSnapshot to return undefined 1`] = `"abc"`;
diff --git a/test/js/bun/test/expect.test.js b/test/js/bun/test/expect.test.js
index 33206f2f02..4f5b339ffb 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);
@@ -1103,6 +1128,32 @@ describe("expect()", () => {
     expect(w).toEqual(w);
   });
 
+  test("deepEquals Set/Map stress test", () => {
+    const arr1 = [];
+    const arr2 = [];
+    const arr3 = [];
+    const arr4 = [];
+
+    for (let i = 0; i < 150; i++) {
+      arr1[i] = [i];
+      arr2[i] = [i];
+      arr3[i] = [i, [i]];
+      arr4[i] = [i, [i]];
+    }
+
+    for (let i = 0; i < 2000; i++) {
+      let outerSet = new Set(arr1);
+      let innerSet = new Set(arr2);
+      Bun.deepEquals(outerSet, innerSet);
+    }
+
+    for (let i = 0; i < 1000; i++) {
+      let outerMap = new Map(arr3);
+      let innerMap = new Map(arr4);
+      Bun.deepEquals(outerMap, innerMap);
+    }
+  });
+
   test("deepEquals - Date", () => {
     let d = new Date();
     expect(d).toEqual(d);
diff --git a/test/js/bun/test/snapshot-tests/snapshots/__snapshots__/snapshot.test.ts.snap b/test/js/bun/test/snapshot-tests/snapshots/__snapshots__/snapshot.test.ts.snap
index 47112120bc..f6c84aef6a 100644
--- a/test/js/bun/test/snapshot-tests/snapshots/__snapshots__/snapshot.test.ts.snap
+++ b/test/js/bun/test/snapshot-tests/snapshots/__snapshots__/snapshot.test.ts.snap
@@ -368,3 +368,222 @@ exports[`most types: testing 7 2`] = `9`;
 exports[`most types: testing 7 3`] = `8`;
 
 exports[`most types: undefined 1`] = `undefined`;
+
+exports[`snapshots dollars 1`] = `
+"// Bun Snapshot v1, https://goo.gl/fbAQLP
+
+exports[\`abc 1\`] = \`"$"\`;
+"
+`;
+
+exports[`snapshots backslash 1`] = `
+"// Bun Snapshot v1, https://goo.gl/fbAQLP
+
+exports[\`abc 1\`] = \`"\\\\"\`;
+"
+`;
+
+exports[`snapshots dollars curly 1`] = `
+"// Bun Snapshot v1, https://goo.gl/fbAQLP
+
+exports[\`abc 1\`] = \`"\\\${}"\`;
+"
+`;
+
+exports[`snapshots dollars curly 2 1`] = `
+"// Bun Snapshot v1, https://goo.gl/fbAQLP
+
+exports[\`abc 1\`] = \`"\\\${"\`;
+"
+`;
+
+exports[`snapshots stuff 1`] = `
+"// Bun Snapshot v1, https://goo.gl/fbAQLP
+
+exports[\`abc 1\`] = \`
+"æ™
+
+!!!!*5897yhduN"'\\\`Il"
+\`;
+"
+`;
+
+exports[`snapshots stuff 2 1`] = `
+"// Bun Snapshot v1, https://goo.gl/fbAQLP
+
+exports[\`abc 1\`] = \`
+"æ™
+
+!!!!*5897yh!uN"'\\\`Il"
+\`;
+"
+`;
+
+exports[`snapshots regexp 1 1`] = `
+"// Bun Snapshot v1, https://goo.gl/fbAQLP
+
+exports[\`abc 1\`] = \`/\\\${1..}/\`;
+"
+`;
+
+exports[`snapshots regexp 2 1`] = `
+"// Bun Snapshot v1, https://goo.gl/fbAQLP
+
+exports[\`abc 1\`] = \`/\\\${2..}/\`;
+"
+`;
+
+exports[`snapshots string 1`] = `
+"// Bun Snapshot v1, https://goo.gl/fbAQLP
+
+exports[\`abc 1\`] = \`"abc"\`;
+"
+`;
+
+exports[`snapshots string with newline 1`] = `
+"// Bun Snapshot v1, https://goo.gl/fbAQLP
+
+exports[\`abc 1\`] = \`
+"qwerty
+ioup"
+\`;
+"
+`;
+
+exports[`snapshots null byte 1`] = `
+"// Bun Snapshot v1, https://goo.gl/fbAQLP
+
+exports[\`abc 1\`] = \`"1 \\x00"\`;
+"
+`;
+
+exports[`snapshots null byte 2 1`] = `
+"// Bun Snapshot v1, https://goo.gl/fbAQLP
+
+exports[\`abc 1\`] = \`"2 \\x00"\`;
+"
+`;
+
+exports[`snapshots backticks 1`] = `
+"// Bun Snapshot v1, https://goo.gl/fbAQLP
+
+exports[\`abc 1\`] = \`"This is \\\`wrong\\\`"\`;
+"
+`;
+
+exports[`snapshots unicode 1`] = `
+"// Bun Snapshot v1, https://goo.gl/fbAQLP
+
+exports[\`abc 1\`] = \`"😊abc\\\`\\\${def} �, � "\`;
+"
+`;
+
+exports[`snapshots jest newline oddity 1`] = `
+"// Bun Snapshot v1, https://goo.gl/fbAQLP
+
+exports[\`abc 1\`] = \`
+"
+"
+\`;
+"
+`;
+
+exports[`snapshots grow file for new snapshot 1`] = `
+"// Bun Snapshot v1, https://goo.gl/fbAQLP
+
+exports[\`abc 1\`] = \`"hello"\`;
+"
+`;
+
+exports[`snapshots grow file for new snapshot 2`] = `
+"// Bun Snapshot v1, https://goo.gl/fbAQLP
+
+exports[\`abc 1\`] = \`"hello"\`;
+
+exports[\`def 1\`] = \`"hello"\`;
+"
+`;
+
+exports[`snapshots grow file for new snapshot 3`] = `
+"// Bun Snapshot v1, https://goo.gl/fbAQLP
+
+exports[\`abc 1\`] = \`"goodbye"\`;
+
+exports[\`def 1\`] = \`"hello"\`;
+"
+`;
+
+exports[`snapshots backtick in test name 1`] = `
+"// Bun Snapshot v1, https://goo.gl/fbAQLP
+
+exports[\`\\\` 1\`] = \`"abc"\`;
+"
+`;
+
+exports[`snapshots dollars curly in test name 1`] = `
+"// Bun Snapshot v1, https://goo.gl/fbAQLP
+
+exports[\`\\\${} 1\`] = \`"abc"\`;
+"
+`;
+
+exports[`snapshots #15283 1`] = `
+"// Bun Snapshot v1, https://goo.gl/fbAQLP
+
+exports[\`Should work 1\`] = \`"This is \\\`wrong\\\`"\`;
+"
+`;
+
+exports[`snapshots #15283 unicode 1`] = `
+"// Bun Snapshot v1, https://goo.gl/fbAQLP
+
+exports[\`Should work 1\`] = \`"😊This is \\\`wrong\\\`"\`;
+"
+`;
+
+exports[`snapshots replaces file that fails to parse when update flag is used 1`] = `
+"// Bun Snapshot v1, https://goo.gl/fbAQLP
+
+exports[\`t1 1\`] = \`"abc def ghi jkl"\`;
+
+exports[\`t2 1\`] = \`"abc\\\`def"\`;
+
+exports[\`t3 1\`] = \`"abc def ghi"\`;
+"
+`;
+
+exports[`snapshots property matchers 1`] = `
+"// Bun Snapshot v1, https://goo.gl/fbAQLP
+
+exports[\`abc 1\`] = \`
+{
+  "createdAt": Any<Date>,
+  "id": Any<Number>,
+  "name": "LeBron James",
+}
+\`;
+"
+`;
+
+exports[`inline snapshots grow file for new snapshot 1`] = `
+"
+      test("abc", () => { expect("hello").toMatchInlineSnapshot(\`"hello"\`) });
+    "
+`;
+
+exports[`inline snapshots backtick in test name 1`] = `"test("\`", () => {expect("abc").toMatchInlineSnapshot(\`"abc"\`);})"`;
+
+exports[`inline snapshots dollars curly in test name 1`] = `"test("\${}", () => {expect("abc").toMatchInlineSnapshot(\`"abc"\`);})"`;
+
+exports[`inline snapshots #15283 1`] = `
+"it("Should work", () => {
+      expect(\`This is \\\`wrong\\\`\`).toMatchInlineSnapshot(\`"This is \\\`wrong\\\`"\`);
+    });"
+`;
+
+exports[`snapshots unicode surrogate halves 1`] = `
+"// Bun Snapshot v1, https://goo.gl/fbAQLP
+
+exports[\`abc 1\`] = \`"😊abc\\\`\\\${def} �, � "\`;
+"
+`;
diff --git a/test/js/bun/test/snapshot-tests/snapshots/more.test.ts b/test/js/bun/test/snapshot-tests/snapshots/more.test.ts
index 38214d3199..74b1a457e6 100644
--- a/test/js/bun/test/snapshot-tests/snapshots/more.test.ts
+++ b/test/js/bun/test/snapshot-tests/snapshots/more.test.ts
@@ -1,7 +1,7 @@
 import { describe, expect, test } from "bun:test";
 
 describe("d0", () => {
-  test.todo("snapshot serialize edgecases", () => {
+  test("snapshot serialize edgecases", () => {
     expect(1).toMatchSnapshot();
     expect("1\b2\n3\r4").toMatchSnapshot();
     expect("\r\n").toMatchSnapshot();
@@ -47,7 +47,7 @@ describe("d0", () => {
 
 describe("d0", () => {
   describe("d1", () => {
-    test.todo("t1", () => {
+    test("t1", () => {
       expect("hello`snapshot\\").toEqual("hello`snapshot\\");
       expect("hello`snapshot\\").toMatchSnapshot();
     });
@@ -58,7 +58,7 @@ describe("d0", () => {
   test("t3", () => {
     expect("hello snapshot").toMatchSnapshot();
   });
-  test.todo("t4", () => {
+  test("t4", () => {
     expect("hello`snapshot\\").toMatchSnapshot();
   });
 });
diff --git a/test/js/bun/test/snapshot-tests/snapshots/snapshot.test.ts b/test/js/bun/test/snapshot-tests/snapshots/snapshot.test.ts
index 5b68833f7d..abbb6cf96f 100644
--- a/test/js/bun/test/snapshot-tests/snapshots/snapshot.test.ts
+++ b/test/js/bun/test/snapshot-tests/snapshots/snapshot.test.ts
@@ -1,4 +1,7 @@
-import { expect, it, test } from "bun:test";
+import { $, spawnSync } from "bun";
+import { readFileSync, writeFileSync } from "fs";
+import { describe, expect, it, test } from "bun:test";
+import { bunEnv, bunExe, DirectoryTree, tempDirWithFiles } from "harness";
 
 function test1000000(arg1: any, arg218718132: any) {}
 
@@ -164,3 +167,565 @@ test("most types", () => {
 it("should work with expect.anything()", () => {
   // expect({ a: 0 }).toMatchSnapshot({ a: expect.anything() });
 });
+
+function defaultWrap(a: string, b: string = ""): string {
+  return `test("abc", () => { expect(${a}).toMatchSnapshot(${b}) });`;
+}
+
+class SnapshotTester {
+  dir: string;
+  targetSnapshotContents: string;
+  isFirst: boolean = true;
+  constructor(public inlineSnapshot: boolean) {
+    this.dir = tempDirWithFiles("snapshotTester", { "snapshot.test.ts": "" });
+    this.targetSnapshotContents = "";
+  }
+  test(
+    label: string,
+    contents: string,
+    opts: { shouldNotError?: boolean; shouldGrow?: boolean; skipSnapshot?: boolean } = {},
+  ) {
+    test(label, async () => await this.update(contents, opts));
+  }
+  async update(
+    contents: string,
+    opts: { shouldNotError?: boolean; shouldGrow?: boolean; skipSnapshot?: boolean; forceUpdate?: boolean } = {},
+  ) {
+    if (this.inlineSnapshot) {
+      contents = contents.replaceAll("toMatchSnapshot()", "toMatchInlineSnapshot('bad')");
+      this.targetSnapshotContents = contents;
+    }
+
+    const isFirst = this.isFirst;
+    this.isFirst = false;
+    await Bun.write(this.dir + "/snapshot.test.ts", contents);
+
+    if (!opts.shouldNotError) {
+      if (!isFirst) {
+        // make sure it fails first:
+        expect((await $`cd ${this.dir} && ${bunExe()} test ./snapshot.test.ts`.nothrow().quiet()).exitCode).not.toBe(0);
+        // make sure the existing snapshot is unchanged:
+        expect(await this.getSnapshotContents()).toBe(this.targetSnapshotContents);
+      }
+      // update snapshots now, using -u flag unless this is the first run
+      await $`cd ${this.dir} && ${bunExe()} test ${isFirst && !opts.forceUpdate ? "" : "-u"} ./snapshot.test.ts`.quiet();
+      // make sure the snapshot changed & didn't grow
+      const newContents = await this.getSnapshotContents();
+      if (!isFirst) {
+        expect(newContents).not.toStartWith(this.targetSnapshotContents);
+      }
+      if (!opts.skipSnapshot && !this.inlineSnapshot) expect(newContents).toMatchSnapshot();
+      this.targetSnapshotContents = newContents;
+    }
+    // run, make sure snapshot does not change
+    await $`cd ${this.dir} && ${bunExe()} test ./snapshot.test.ts`.quiet();
+    if (!opts.shouldGrow) {
+      expect(await this.getSnapshotContents()).toBe(this.targetSnapshotContents);
+    } else {
+      this.targetSnapshotContents = await this.getSnapshotContents();
+    }
+  }
+  async setSnapshotFile(contents: string) {
+    if (this.inlineSnapshot) throw new Error("not allowed");
+    await Bun.write(this.dir + "/__snapshots__/snapshot.test.ts.snap", contents);
+    this.isFirst = true;
+  }
+  async getSrcContents(): Promise<string> {
+    return await Bun.file(this.dir + "/snapshot.test.ts").text();
+  }
+  async getSnapshotContents(): Promise<string> {
+    if (this.inlineSnapshot) return await this.getSrcContents();
+    return await Bun.file(this.dir + "/__snapshots__/snapshot.test.ts.snap").text();
+  }
+}
+
+for (const inlineSnapshot of [false, true]) {
+  describe(inlineSnapshot ? "inline snapshots" : "snapshots", async () => {
+    const t = new SnapshotTester(inlineSnapshot);
+    await t.update(defaultWrap("''", inlineSnapshot ? '`""`' : undefined), { skipSnapshot: true });
+
+    t.test("dollars", defaultWrap("`\\$`"));
+    t.test("backslash", defaultWrap("`\\\\`"));
+    t.test("dollars curly", defaultWrap("`\\${}`"));
+    t.test("dollars curly 2", defaultWrap("`\\${`"));
+    t.test("stuff", defaultWrap(`\`æ™\n\r!!!!*5897yhduN\\"\\'\\\`Il\``));
+    t.test("stuff 2", defaultWrap(`\`æ™\n\r!!!!*5897yh!uN\\"\\'\\\`Il\``));
+
+    t.test("regexp 1", defaultWrap("/${1..}/"));
+    t.test("regexp 2", defaultWrap("/${2..}/"));
+    t.test("string", defaultWrap('"abc"'));
+    t.test("string with newline", defaultWrap('"qwerty\\nioup"'));
+
+    if (!inlineSnapshot)
+      // disabled for inline snapshot because of the bug in CodepointIterator; should be fixed by https://github.com/oven-sh/bun/pull/15163
+      t.test("null byte", defaultWrap('"1 \x00"'));
+    t.test("null byte 2", defaultWrap('"2 \\x00"'));
+
+    t.test("backticks", defaultWrap("`This is \\`wrong\\``"));
+    if (!inlineSnapshot)
+      // disabled for inline snapshot because reading the file will have U+FFFD in it rather than surrogate halves
+      t.test(
+        "unicode surrogate halves",
+        defaultWrap("'😊abc`${def} " + "😊".substring(0, 1) + ", " + "😊".substring(1, 2) + " '"),
+      );
+
+    if (!inlineSnapshot)
+      // disabled for inline snapshot because it needs to update the thing
+      t.test(
+        "property matchers",
+        defaultWrap(
+          '{createdAt: new Date(), id: Math.floor(Math.random() * 20), name: "LeBron James"}',
+          `{createdAt: expect.any(Date), id: expect.any(Number)}`,
+        ),
+      );
+
+    if (!inlineSnapshot) {
+      // these other ones are disabled in inline snapshots
+
+      test("jest newline oddity", async () => {
+        await t.update(defaultWrap("'\\n'"));
+        await t.update(defaultWrap("'\\r'"), { shouldNotError: true });
+        await t.update(defaultWrap("'\\r\\n'"), { shouldNotError: true });
+      });
+
+      test("don't grow file on error", async () => {
+        await t.setSnapshotFile("exports[`snap 1`] = `hello`goodbye`;");
+        try {
+          await t.update(/*js*/ `
+            test("t1", () => {expect("abc def ghi jkl").toMatchSnapshot();})
+            test("t2", () => {expect("abc\`def").toMatchSnapshot();})
+            test("t3", () => {expect("abc def ghi").toMatchSnapshot();})
+          `);
+        } catch (e) {}
+        expect(await t.getSnapshotContents()).toBe("exports[`snap 1`] = `hello`goodbye`;");
+      });
+
+      test("replaces file that fails to parse when update flag is used", async () => {
+        await t.setSnapshotFile("exports[`snap 1`] = `hello`goodbye`;");
+        await t.update(
+          /*js*/ `
+            test("t1", () => {expect("abc def ghi jkl").toMatchSnapshot();})
+            test("t2", () => {expect("abc\`def").toMatchSnapshot();})
+            test("t3", () => {expect("abc def ghi").toMatchSnapshot();})
+          `,
+          { forceUpdate: true },
+        );
+        expect(await t.getSnapshotContents()).toBe(
+          '// Bun Snapshot v1, https://goo.gl/fbAQLP\n\nexports[`t1 1`] = `"abc def ghi jkl"`;\n\nexports[`t2 1`] = `"abc\\`def"`;\n\nexports[`t3 1`] = `"abc def ghi"`;\n',
+        );
+      });
+
+      test("grow file for new snapshot", async () => {
+        const t4 = new SnapshotTester(inlineSnapshot);
+        await t4.update(/*js*/ `
+              test("abc", () => { expect("hello").toMatchSnapshot() });
+            `);
+        await t4.update(
+          /*js*/ `
+                test("abc", () => { expect("hello").toMatchSnapshot() });
+                test("def", () => { expect("goodbye").toMatchSnapshot() });
+              `,
+          { shouldNotError: true, shouldGrow: true },
+        );
+        await t4.update(/*js*/ `
+              test("abc", () => { expect("hello").toMatchSnapshot() });
+              test("def", () => { expect("hello").toMatchSnapshot() });
+            `);
+        await t4.update(/*js*/ `
+              test("abc", () => { expect("goodbye").toMatchSnapshot() });
+              test("def", () => { expect("hello").toMatchSnapshot() });
+            `);
+      });
+
+      const t2 = new SnapshotTester(inlineSnapshot);
+      t2.test("backtick in test name", `test("\`", () => {expect("abc").toMatchSnapshot();})`);
+      const t3 = new SnapshotTester(inlineSnapshot);
+      t3.test("dollars curly in test name", `test("\${}", () => {expect("abc").toMatchSnapshot();})`);
+
+      const t15283 = new SnapshotTester(inlineSnapshot);
+      t15283.test(
+        "#15283",
+        `it("Should work", () => {
+          expect(\`This is \\\`wrong\\\`\`).toMatchSnapshot();
+        });`,
+      );
+      t15283.test(
+        "#15283 unicode",
+        `it("Should work", () => {expect(\`😊This is \\\`wrong\\\`\`).toMatchSnapshot()});`,
+      );
+    }
+  });
+}
+
+test("basic unchanging inline snapshot", () => {
+  expect("hello").toMatchInlineSnapshot('"hello"');
+  expect({ v: new Date() }).toMatchInlineSnapshot(
+    { v: expect.any(Date) },
+    `
+{
+  "v": Any<Date>,
+}
+`,
+  );
+});
+
+class InlineSnapshotTester {
+  tmpdir: string;
+  tmpid: number;
+  constructor(tmpfiles: DirectoryTree) {
+    this.tmpdir = tempDirWithFiles("InlineSnapshotTester", tmpfiles);
+    this.tmpid = 0;
+  }
+  tmpfile(content: string): string {
+    const filename = "_" + this.tmpid++ + ".test.ts";
+    writeFileSync(this.tmpdir + "/" + filename, content);
+    return filename;
+  }
+  readfile(name: string): string {
+    return readFileSync(this.tmpdir + "/" + name, { encoding: "utf-8" });
+  }
+
+  testError(eopts: { update?: boolean; msg: string }, code: string): void {
+    const thefile = this.tmpfile(code);
+
+    const spawnres = Bun.spawnSync({
+      cmd: [bunExe(), "test", ...(eopts.update ? ["-u"] : []), thefile],
+      env: bunEnv,
+      cwd: this.tmpdir,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    expect(spawnres.stderr.toString()).toInclude(eopts.msg);
+    expect(spawnres.exitCode).not.toBe(0);
+    expect(this.readfile(thefile)).toEqual(code);
+  }
+  test(cb: (v: (a: string, b: string, c: string) => string) => string): void {
+    this.testInternal(
+      false,
+      cb((a, b, c) => a),
+      cb((a, b, c) => c),
+    );
+    this.testInternal(
+      true,
+      cb((a, b, c) => b),
+      cb((a, b, c) => c),
+    );
+  }
+  testInternal(use_update: boolean, before_value: string, after_value: string): void {
+    const thefile = this.tmpfile(before_value);
+
+    if (use_update) {
+      // run without update, expect error
+      const spawnres = Bun.spawnSync({
+        cmd: [bunExe(), "test", thefile],
+        env: bunEnv,
+        cwd: this.tmpdir,
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+      expect(spawnres.stderr.toString()).toInclude("error:");
+      expect(spawnres.exitCode).not.toBe(0);
+      expect(this.readfile(thefile)).toEqual(before_value);
+    }
+
+    {
+      const spawnres = Bun.spawnSync({
+        cmd: [bunExe(), "test", ...(use_update ? ["-u"] : []), thefile],
+        env: bunEnv,
+        cwd: this.tmpdir,
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+      expect(spawnres.stderr.toString()).not.toInclude("error:");
+      expect({
+        exitCode: spawnres.exitCode,
+        content: this.readfile(thefile),
+      }).toEqual({
+        exitCode: 0,
+        content: after_value,
+      });
+    }
+
+    // run without update, expect pass with no change
+    {
+      const spawnres = Bun.spawnSync({
+        cmd: [bunExe(), "test", thefile],
+        env: bunEnv,
+        cwd: this.tmpdir,
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+      expect(spawnres.stderr.toString()).not.toInclude("error:");
+      expect({
+        exitCode: spawnres.exitCode,
+        content: this.readfile(thefile),
+      }).toEqual({
+        exitCode: 0,
+        content: after_value,
+      });
+    }
+
+    // update again, expect pass with no change
+    {
+      const spawnres = Bun.spawnSync({
+        cmd: [bunExe(), "test", "-u", thefile],
+        env: bunEnv,
+        cwd: this.tmpdir,
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+      expect(spawnres.stderr.toString()).not.toInclude("error:");
+      expect({
+        exitCode: spawnres.exitCode,
+        content: this.readfile(thefile),
+      }).toEqual({
+        exitCode: 0,
+        content: after_value,
+      });
+    }
+  }
+}
+
+describe("inline snapshots", () => {
+  const bad = '"bad"';
+  const tester = new InlineSnapshotTester({
+    "helper.js": /*js*/ `
+      import {expect} from "bun:test";
+      export function wrongFile(value) {
+        expect(value).toMatchInlineSnapshot();
+      }
+    `,
+  });
+  test("changing inline snapshot", () => {
+    tester.test(
+      v => /*js*/ `
+        test("inline snapshots", () => {
+          expect("1").toMatchInlineSnapshot(${v("", bad, '`"1"`')});
+          expect("2").toMatchInlineSnapshot( ${v("", bad, '`"2"`')});
+          expect("3").toMatchInlineSnapshot(  ${v("", bad, '`"3"`')});
+        });
+        test("m1", () => {
+          expect("a").toMatchInlineSnapshot(${v("", bad, '`"a"`')});
+          expect("b").toMatchInlineSnapshot(${v("", bad, '`"b"`')});
+          expect("§<-1l").toMatchInlineSnapshot(${v("", bad, '`"§<-1l"`')});
+          expect("𐀁").toMatchInlineSnapshot(${v("", bad, '`"𐀁"`')});
+          expect( "m ") . toMatchInlineSnapshot ( ${v("", bad, '`"m "`')}) ;
+          expect("§§§").     toMatchInlineSnapshot(${v("", bad, '`"§§§"`')}) ;
+        });
+      `,
+    );
+  });
+  test("inline snapshot update cases", () => {
+    tester.test(
+      v => /*js*/ `
+        test("cases", () => {
+          expect("1").toMatchInlineSnapshot(${v("", bad, '`"1"`')});
+          expect("2").toMatchInlineSnapshot( ${v("", bad, '`"2"`')});
+          expect("3"). toMatchInlineSnapshot( ${v("", bad, '`"3"`')});
+          expect("4") . toMatchInlineSnapshot( ${v("", bad, '`"4"`')});
+          expect("5" ) . toMatchInlineSnapshot( ${v("", bad, '`"5"`')});
+          expect("6" ) . toMatchInlineSnapshot ( ${v("", bad, '`"6"`')});
+          expect("7" ) . toMatchInlineSnapshot (  ${v("", bad, '`"7"`')});
+          expect("8" ) . toMatchInlineSnapshot (  ${v("", bad, '`"8"`')}) ;
+          expect("9" ) . toMatchInlineSnapshot (  \n${v("", bad, '`"9"`')}) ;
+          expect("10" ) .\ntoMatchInlineSnapshot (  \n${v("", bad, '`"10"`')}) ;
+          expect("11")
+            .toMatchInlineSnapshot(${v("", bad, '`"11"`')}) ;
+          expect("12")\r
+            .\r
+              toMatchInlineSnapshot\r
+                (\r
+                  ${v("", bad, '`"12"`')})\r
+                    ;
+          expect("13").toMatchInlineSnapshot(${v("", bad, '`"13"`')}); expect("14").toMatchInlineSnapshot(${v("", bad, '`"14"`')}); expect("15").toMatchInlineSnapshot(${v("", bad, '`"15"`')}); 
+          expect({a: new Date()}).toMatchInlineSnapshot({a: expect.any(Date)}${v("", ', "bad"', ', `\n{\n  "a": Any<Date>,\n}\n`')});
+          expect({a: new Date()}).toMatchInlineSnapshot({a: expect.any(Date)}${v(",", ', "bad"', ', `\n{\n  "a": Any<Date>,\n}\n`')});
+          expect({a: new Date()}).toMatchInlineSnapshot({a: expect.any(Date)\n}${v("", ', "bad"', ', `\n{\n  "a": Any<Date>,\n}\n`')});
+          expect({a: new Date()}).\ntoMatchInlineSnapshot({a: expect.any(Date)\n}${v("", ', "bad"', ', `\n{\n  "a": Any<Date>,\n}\n`')});
+          expect({a: new Date()})\n.\ntoMatchInlineSnapshot({a: expect.any(Date)\n}${v("", ', "bad"', ', `\n{\n  "a": Any<Date>,\n}\n`')});
+          expect({a: new Date()})\n.\ntoMatchInlineSnapshot({a: \nexpect.any(Date)\n}${v("", ', "bad"', ', `\n{\n  "a": Any<Date>,\n}\n`')});
+          expect({a: new Date()})\n.\ntoMatchInlineSnapshot({a: \nexpect.any(\nDate)\n}${v("", ', "bad"', ', `\n{\n  "a": Any<Date>,\n}\n`')});
+          expect({a: new Date()}).toMatchInlineSnapshot( {a: expect.any(Date)} ${v("", ', "bad"', ', `\n{\n  "a": Any<Date>,\n}\n`')});
+          expect({a: new Date()}).toMatchInlineSnapshot( {a: expect.any(Date)} ${v(",", ', "bad"', ', `\n{\n  "a": Any<Date>,\n}\n`')});
+          expect("😊").toMatchInlineSnapshot(${v("", bad, '`"😊"`')});
+          expect("\\r").toMatchInlineSnapshot(${v("", bad, '`\n"\n"\n`')});
+          expect("\\r\\n").toMatchInlineSnapshot(${v("", bad, '`\n"\n"\n`')});
+          expect("\\n").toMatchInlineSnapshot(${v("", bad, '`\n"\n"\n`')});
+        });
+      `,
+    );
+  });
+  it("should error trying to update outside of a test", () => {
+    tester.testError(
+      { msg: "error: Snapshot matchers cannot be used outside of a test" },
+      /*js*/ `
+        expect("1").toMatchInlineSnapshot();
+      `,
+    );
+  });
+  it.skip("should pass not needing update outside of a test", () => {
+    // todo write the test right
+    tester.test(
+      v => /*js*/ `
+        expect("1").toMatchInlineSnapshot('"1"');
+      `,
+    );
+  });
+  it("should error trying to update the same line twice", () => {
+    tester.testError(
+      { msg: "error: Failed to update inline snapshot: Multiple inline snapshots for the same call are not supported" },
+      /*js*/ `
+        function oops(a) {expect(a).toMatchInlineSnapshot()}
+        test("whoops", () => {
+          oops(1);
+          oops(2);
+        });
+      `,
+    );
+
+    // fun trick:
+    // function oops(a) {expect(a).toMatchInlineSnapshot('1')}
+    // now do oops(1); oops(2);
+    // with `-u` it will toggle between '1' and '2' but won't error
+    // jest has the same bug so it's fine
+  });
+
+  // snapshot in a snapshot
+  it("should not allow a snapshot in a snapshot", () => {
+    // this is possible to support, but is not supported
+    tester.testError(
+      { msg: "error: Failed to update inline snapshot: Did not advance." },
+      ((v: (a: string, b: string, c: string) => string) => /*js*/ `
+        test("cases", () => {
+          expect({a: new Date()}).toMatchInlineSnapshot(
+            ( expect(2).toMatchInlineSnapshot(${v("", bad, "`2`")}) , {a: expect.any(Date)})
+              ${v(",", ', "bad"', ', `\n{\n  "a": Any<Date>,\n}\n`')}
+          );
+        });
+      `)((a, b, c) => a),
+    );
+  });
+
+  it("requires exactly 'toMatchInlineSnapshot' 1", () => {
+    tester.testError(
+      { msg: "error: Failed to update inline snapshot: Could not find 'toMatchInlineSnapshot' here" },
+      /*js*/ `
+        test("cases", () => {
+          expect(1)["toMatchInlineSnapshot"]();
+        });
+      `,
+    );
+  });
+  it("requires exactly 'toMatchInlineSnapshot' 2", () => {
+    tester.testError(
+      { msg: "error: Failed to update inline snapshot: Could not find 'toMatchInlineSnapshot' here" },
+      /*js*/ `
+        test("cases", () => {
+          expect(1).t\\u{6f}MatchInlineSnapshot();
+        });
+      `,
+    );
+  });
+  it("only replaces when the argument is a literal string 1", () => {
+    tester.testError(
+      {
+        update: true,
+        msg: "error: Failed to update inline snapshot: Argument must be a string literal",
+      },
+      /*js*/ `
+        test("cases", () => {
+          const value = "25";
+          expect({}).toMatchInlineSnapshot(value);
+        });
+      `,
+    );
+  });
+  it("only replaces when the argument is a literal string 2", () => {
+    tester.testError(
+      {
+        update: true,
+        msg: "error: Failed to update inline snapshot: Argument must be a string literal",
+      },
+      /*js*/ `
+        test("cases", () => {
+          const value = "25";
+          expect({}).toMatchInlineSnapshot({}, value);
+        });
+      `,
+    );
+  });
+  it("only replaces when the argument is a literal string 3", () => {
+    tester.testError(
+      {
+        update: true,
+        msg: "error: Failed to update inline snapshot: Argument must be a string literal",
+      },
+      /*js*/ `
+        test("cases", () => {
+          expect({}).toMatchInlineSnapshot({}, {});
+        });
+      `,
+    );
+  });
+  it("only replaces when the argument is a literal string 4", () => {
+    tester.testError(
+      {
+        update: true,
+        msg: "Matcher error: Expected properties must be an object",
+      },
+      /*js*/ `
+        test("cases", () => {
+          expect({}).toMatchInlineSnapshot("1", {});
+        });
+      `,
+    );
+  });
+  it("does not allow spread 1", () => {
+    tester.testError(
+      {
+        update: true,
+        msg: "error: Failed to update inline snapshot: Spread is not allowed",
+      },
+      /*js*/ `
+        test("cases", () => {
+          expect({}).toMatchInlineSnapshot(...["1"]);
+        });
+      `,
+    );
+  });
+  it("does not allow spread 2", () => {
+    tester.testError(
+      {
+        update: true,
+        msg: "error: Failed to update inline snapshot: Spread is not allowed",
+      },
+      /*js*/ `
+        test("cases", () => {
+          expect({}).toMatchInlineSnapshot({}, ...["1"]);
+        });
+      `,
+    );
+  });
+  it("limit two arguments", () => {
+    tester.testError(
+      {
+        update: true,
+        msg: "error: Failed to update inline snapshot: Snapshot expects at most two arguments",
+      },
+      /*js*/ `
+        test("cases", () => {
+          expect({}).toMatchInlineSnapshot({}, "1", "hello");
+        });
+      `,
+    );
+  });
+  it("must be in test file", () => {
+    tester.testError(
+      {
+        update: true,
+        msg: "Matcher error: Inline snapshot matchers must be called from the same file as the test",
+      },
+      /*js*/ `
+        import {wrongFile} from "./helper";
+        test("cases", () => {
+          wrongFile("interesting");
+        });
+      `,
+    );
+  });
+});
diff --git a/test/js/bun/test/test-test.test.ts b/test/js/bun/test/test-test.test.ts
index a6fce244ee..76868a5d03 100644
--- a/test/js/bun/test/test-test.test.ts
+++ b/test/js/bun/test/test-test.test.ts
@@ -43,7 +43,7 @@ it("shouldn't crash when async test runner callback throws", async () => {
     expect(err).toContain("error: ##123##");
     expect(err).toContain("error: ##456##");
     expect(stdout).toBeDefined();
-    expect(await new Response(stdout).text()).toBe("");
+    expect(await new Response(stdout).text()).toBe(`bun test ${Bun.version_with_sha}\n`);
     expect(await exited).toBe(1);
   } finally {
     await rm(test_dir, { force: true, recursive: true });
@@ -189,19 +189,19 @@ test("describe scope throwing doesn't block other tests from running", async ()
     it("test enqueued before a describe scope throws is never run", () => {
       throw new Error("This test failed");
     });
-  
+
     throw "This test passed. Ignore the error message";
-  
+
     it("test enqueued after a describe scope throws is never run", () => {
       throw new Error("This test failed");
     });
   });
-  
+
   it("a describe scope throwing doesn't cause all other tests in the file to fail", () => {
     console.log(
       String.fromCharCode(...[73, 32, 104, 97, 118, 101, 32, 98, 101, 101, 110, 32, 114, 101, 97, 99, 104, 101, 100, 33]),
     );
-  });  
+  });
 `;
 
   const dir = tmpdirSync();
@@ -303,7 +303,7 @@ it("should return non-zero exit code for invalid syntax", async () => {
     expect(err).toContain(" 1 fail");
     expect(err).toContain("Ran 1 tests across 1 files");
     expect(stdout).toBeDefined();
-    expect(await new Response(stdout).text()).toBe("");
+    expect(await new Response(stdout).text()).toBe(`bun test ${Bun.version_with_sha}\n`);
     expect(await exited).toBe(1);
   } finally {
     await rm(test_dir, { force: true, recursive: true });
@@ -331,7 +331,7 @@ it("invalid syntax counts towards bail", async () => {
     expect(err).not.toContain("DO NOT RUN ME");
     expect(err).toContain("Ran 3 tests across 3 files");
     expect(stdout).toBeDefined();
-    expect(await new Response(stdout).text()).toBe("");
+    expect(await new Response(stdout).text()).toBe(`bun test ${Bun.version_with_sha}\n`);
     expect(await exited).toBe(1);
   } finally {
     // await rm(test_dir, { force: true, recursive: true });
@@ -584,6 +584,7 @@ it("test --preload supports global lifecycle hooks", () => {
   });
   expect(stdout.toString().trim()).toBe(
     `
+bun test ${Bun.version_with_sha}
 beforeAll: #1
 beforeAll: #2
 beforeAll: TEST-FILE
@@ -661,7 +662,14 @@ describe("empty", () => {
     expect(err).toContain("0 fail");
     expect(stdout).toBeDefined();
     const out = await new Response(stdout).text();
-    expect(out.split(/\r?\n/)).toEqual(["before all", "before all scoped", "after all scoped", "after all", ""]);
+    expect(out.split(/\r?\n/)).toEqual([
+      `bun test ${Bun.version_with_sha}`,
+      "before all",
+      "before all scoped",
+      "after all scoped",
+      "after all",
+      "",
+    ]);
     expect(await exited).toBe(0);
   } finally {
     await rm(test_dir, { force: true, recursive: true });
diff --git a/test/js/bun/util/bun-cryptohasher.test.ts b/test/js/bun/util/bun-cryptohasher.test.ts
index 499328208f..aa159a65e6 100644
--- a/test/js/bun/util/bun-cryptohasher.test.ts
+++ b/test/js/bun/util/bun-cryptohasher.test.ts
@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test";
+import { withoutAggressiveGC } from "harness";
 
 test("Bun.file in CryptoHasher is not supported yet", () => {
   expect(() => Bun.SHA1.hash(Bun.file(import.meta.path))).toThrow();
@@ -14,6 +15,64 @@ test("CryptoHasher update should throw when no parameter/null/undefined is passe
   // @ts-expect-error
   expect(() => new Bun.CryptoHasher("sha1").update(null)).toThrow();
 });
+
+describe("HMAC", () => {
+  const hashes = {
+    "sha1": "e2e1f7f597941d9b0021978618218a9e08731426",
+    "sha256": "c7a7c96c73af32ea6e5b1ca6768b1d822249eb88f85160433d7b09bb2b21e170",
+    "sha384": "2483522dcb7cb65fa13f0a3c1efe867abbd79ecb19a6ba4bac45d4f4bac31de2e2463b11838b8055601fad73d0b5af4c",
+    "sha512":
+      "f82266c950db24eba03f899466fdf905494709f09f98f4b7d7db31f1443a33b4fe5ca82f74fb360609d8a05a87fb065dd77bee912c27de89cbba7897061ac735",
+    "blake2b512":
+      "9e66ba10f4d7e80abc2584150fc5f9a246634118280fd9ae086794d37cb9919d681ee285b68f9cec2eda9f878d157125cc465c8b0e3c023a7040ed0be7f25023",
+    "md5": "4e7eb9f9332e4eb1dc5a2d7d065ba1bf",
+    "sha224": "d34c3a2647d4f82a4e6baeaa7d94379eafd931e0c16cbc44b4ba4d1e",
+    "sha512-224": "af398c7f21f58e1377580227a89590d3ab8be52b31182fad9ec4d667",
+    "sha512-256": "0ed15b2750a2a7281e96af006ab79e82ed54a7a2081bdb49e70a70d8c6bfeff0",
+  };
+  for (let key of ["key", Buffer.from("key"), Buffer.from("key").buffer]) {
+    test.each(Object.entries(hashes))("%s (key: " + key.constructor.name + ")", (algorithm, expected) => {
+      const hmac = new Bun.CryptoHasher(algorithm, key);
+      hmac.update("data\n");
+      const copied = hmac.copy();
+      expect(hmac.algorithm).toEqual(algorithm);
+      expect(hmac.byteLength).toEqual(hashes[algorithm].length / 2);
+      expect(copied.copy()).toBeInstanceOf(Bun.CryptoHasher);
+
+      expect(hmac.digest("hex")).toEqual(expected);
+
+      expect(copied.algorithm).toEqual(algorithm);
+      expect(copied.byteLength).toEqual(hashes[algorithm].length / 2);
+
+      expect(copied.digest("hex")).toEqual(expected);
+      expect(() => hmac.digest()).toThrow();
+      expect(() => copied.digest()).toThrow();
+      expect(() => hmac.byteLength).toThrow();
+      expect(() => copied.byteLength).toThrow();
+      expect(() => copied.copy()).toThrow();
+      expect(() => hmac.copy()).toThrow();
+
+      // Note that algorithm may throw if the first time the property was accessed is after it was already consumed.
+      // This is a property caching edgecase that it does not always throw.
+      // But let's see if anyone complains about it. It is extremely minor
+    });
+  }
+
+  const unsupported = [
+    ["sha3-224"],
+    ["sha3-256"],
+    ["sha3-384"],
+    ["sha3-512"],
+    ["shake128"],
+    ["shake256"],
+    ["ripemd160"],
+  ] as const;
+  test.each(unsupported)("%s is not supported", algorithm => {
+    expect(() => new Bun.CryptoHasher(algorithm, "key")).toThrow();
+    expect(() => new Bun.CryptoHasher(algorithm)).not.toThrow();
+  });
+});
+
 describe("Hash is consistent", () => {
   const sourceInputs = [
     Buffer.from([
@@ -36,12 +95,36 @@ describe("Hash is consistent", () => {
 
   const inputs = [...sourceInputs, ...sourceInputs.map(x => new Blob([x]))];
 
+  for (let algorithm of [
+    Bun.SHA1,
+    Bun.SHA224,
+    Bun.SHA256,
+    Bun.SHA384,
+    Bun.SHA512,
+    Bun.SHA512_256,
+    Bun.MD4,
+    Bun.MD5,
+  ] as const) {
+    test(`second digest should throw an error ${algorithm.name}`, () => {
+      const hasher = new algorithm().update("hello");
+      hasher.digest();
+      expect(() => hasher.digest()).toThrow(
+        `${algorithm.name} hasher already digested, create a new instance to digest again`,
+      );
+      expect(() => hasher.update("world")).toThrow(
+        `${algorithm.name} hasher already digested, create a new instance to update`,
+      );
+    });
+  }
+
   for (let algorithm of ["sha1", "sha256", "sha512", "md5"] as const) {
     describe(algorithm, () => {
       const Class = globalThis.Bun[algorithm.toUpperCase() as "SHA1" | "SHA256" | "SHA512" | "MD5"];
       test("base64", () => {
         for (let buffer of inputs) {
           for (let i = 0; i < 100; i++) {
+            const hasher = new Bun.CryptoHasher(algorithm);
+            expect(hasher.update(buffer, "base64")).toBeInstanceOf(Bun.CryptoHasher);
             expect(Bun.CryptoHasher.hash(algorithm, buffer, "base64")).toEqual(
               Bun.CryptoHasher.hash(algorithm, buffer, "base64"),
             );
@@ -60,6 +143,8 @@ describe("Hash is consistent", () => {
       test("hex", () => {
         for (let buffer of inputs) {
           for (let i = 0; i < 100; i++) {
+            const hasher = new Bun.CryptoHasher(algorithm);
+            expect(hasher.update(buffer, "hex")).toBeInstanceOf(Bun.CryptoHasher);
             expect(Bun.CryptoHasher.hash(algorithm, buffer, "hex")).toEqual(
               Bun.CryptoHasher.hash(algorithm, buffer, "hex"),
             );
@@ -74,6 +159,84 @@ describe("Hash is consistent", () => {
           }
         }
       });
+
+      test("blob", () => {
+        for (let buffer of inputs) {
+          for (let i = 0; i < 100; i++) {
+            const hasher = new Bun.CryptoHasher(algorithm);
+            expect(hasher.update(buffer)).toBeInstanceOf(Bun.CryptoHasher);
+            expect(Bun.CryptoHasher.hash(algorithm, buffer)).toEqual(Bun.CryptoHasher.hash(algorithm, buffer));
+
+            const instance1 = new Class();
+            instance1.update(buffer);
+            const instance2 = new Class();
+            instance2.update(buffer);
+
+            expect(instance1.digest()).toEqual(instance2.digest());
+            expect(Class.hash(buffer)).toEqual(Class.hash(buffer));
+          }
+        }
+      });
+    });
+  }
+});
+
+describe("CryptoHasher", () => {
+  const algorithms = [
+    "blake2b256",
+    "blake2b512",
+    "ripemd160",
+    "rmd160",
+    "md4",
+    "md5",
+    "sha1",
+    "sha128",
+    "sha224",
+    "sha256",
+    "sha384",
+    "sha512",
+    "sha-1",
+    "sha-224",
+    "sha-256",
+    "sha-384",
+    "sha-512",
+    "sha-512/224",
+    "sha-512_224",
+    "sha-512224",
+    "sha512-224",
+    "sha-512/256",
+    "sha-512_256",
+    "sha-512256",
+    "sha512-256",
+    "sha384",
+    "sha3-224",
+    "sha3-256",
+    "sha3-384",
+    "sha3-512",
+    "shake128",
+    "shake256",
+  ] as const;
+
+  for (let algorithm of algorithms) {
+    describe(algorithm, () => {
+      for (let encoding of ["hex", "base64", "buffer", undefined, "base64url"] as const) {
+        describe(encoding || "default", () => {
+          test("instance", () => {
+            const hasher = new Bun.CryptoHasher(algorithm || undefined);
+            hasher.update("hello");
+            expect(hasher.digest(encoding)).toEqual(Bun.CryptoHasher.hash(algorithm, "hello", encoding));
+          });
+
+          test("consistent", () => {
+            const first = Bun.CryptoHasher.hash(algorithm, "hello", encoding);
+            withoutAggressiveGC(() => {
+              for (let i = 0; i < 100; i++) {
+                expect(Bun.CryptoHasher.hash(algorithm, "hello", encoding)).toStrictEqual(first);
+              }
+            });
+          });
+        });
+      }
     });
   }
 });
diff --git a/test/js/bun/util/filesystem_router.test.ts b/test/js/bun/util/filesystem_router.test.ts
index e297a57be6..96a503112b 100644
--- a/test/js/bun/util/filesystem_router.test.ts
+++ b/test/js/bun/util/filesystem_router.test.ts
@@ -344,6 +344,31 @@ it("reload() works", () => {
   expect(router.match("/posts")!.name).toBe("/posts");
 });
 
+it("reload() works with new dirs/files", () => {
+  const { dir } = make(["posts.tsx"]);
+
+  const router = new Bun.FileSystemRouter({
+    dir,
+    style: "nextjs",
+    assetPrefix: "/_next/static/",
+    origin: "https://nextjs.org",
+  });
+
+  expect(router.match("/posts")!.name).toBe("/posts");
+  createTree(dir, ['test/recursive/index.ts']);
+  router.reload();
+  expect(router.match("/test/recursive")!.name).toBe("/test/recursive");
+  rmSync(`${dir}/test/recursive`, {
+    recursive: true,
+    force: true
+  });
+  router.reload();
+  expect(router.match("/test/recursive")).toBe(null);
+  createTree(dir, ['test/test2/index.ts']);
+  router.reload();
+  expect(router.match("/test/test2")!.name).toBe("/test/test2");
+})
+
 it(".query works with dynamic routes, including params", () => {
   // set up the test
   const { dir } = make(["posts/[id].tsx"]);
diff --git a/test/js/bun/util/fuzzy-wuzzy.test.ts b/test/js/bun/util/fuzzy-wuzzy.test.ts
index d5a3888af0..967a510663 100644
--- a/test/js/bun/util/fuzzy-wuzzy.test.ts
+++ b/test/js/bun/util/fuzzy-wuzzy.test.ts
@@ -21,6 +21,7 @@ const ENABLE_LOGGING = false;
 
 import { describe, test } from "bun:test";
 import { isWindows } from "harness";
+import { EventEmitter } from "events";
 
 const Promise = globalThis.Promise;
 globalThis.Promise = function (...args) {
@@ -219,6 +220,9 @@ function callAllMethods(object) {
   for (const methodName of allThePropertyNames(object, callBanned)) {
     try {
       try {
+        if (object instanceof EventEmitter) {
+          object?.on?.("error", () => {});
+        }
         const returnValue = wrap(Reflect.apply(object?.[methodName], object, []));
         Bun.inspect?.(returnValue), queue.push(returnValue);
       } catch (e) {
@@ -245,6 +249,9 @@ function callAllMethods(object) {
             continue;
           }
           seen.add(method);
+          if (value instanceof EventEmitter) {
+            value?.on?.("error", () => {});
+          }
           const returnValue = wrap(Reflect?.apply?.(method, value, []));
           if (returnValue?.then) {
             continue;
diff --git a/test/js/bun/util/inspect.test.js b/test/js/bun/util/inspect.test.js
index 15ad2702c9..6ee2d89b6a 100644
--- a/test/js/bun/util/inspect.test.js
+++ b/test/js/bun/util/inspect.test.js
@@ -147,7 +147,6 @@ it("utf16 property name", () => {
         笑: "😀",
       },
     ],
-    null,
     2,
   );
   expect(Bun.inspect(db.prepare("select '😀' as 笑").all())).toBe(output);
@@ -526,13 +525,39 @@ it("Bun.inspect array with non-indexed properties", () => {
 });
 
 describe("console.logging function displays async and generator names", async () => {
-  const cases = [function a() {}, async function b() {}, function* c() {}, async function* d() {}];
+  const cases = [
+    function () {},
+    function a() {},
+    async function b() {},
+    function* c() {},
+    async function* d() {},
+    async function* () {},
+  ];
 
   const expected_logs = [
+    "[Function]",
     "[Function: a]",
     "[AsyncFunction: b]",
     "[GeneratorFunction: c]",
     "[AsyncGeneratorFunction: d]",
+    "[AsyncGeneratorFunction]",
+  ];
+
+  for (let i = 0; i < cases.length; i++) {
+    it(expected_logs[i], () => {
+      expect(Bun.inspect(cases[i])).toBe(expected_logs[i]);
+    });
+  }
+});
+describe("console.logging class displays names and extends", async () => {
+  class A {}
+  const cases = [A, class B extends A {}, class extends A {}, class {}];
+
+  const expected_logs = [
+    "[class A]",
+    "[class B extends A]",
+    "[class (anonymous) extends A]",
+    "[class (anonymous)]",
   ];
 
   for (let i = 0; i < cases.length; i++) {
@@ -563,3 +588,14 @@ it("console.log on a Blob shows name", () => {
     `File (3 bytes) {\n  name: "",\n  type: "text/plain;charset=utf-8",\n  lastModified: ${file.lastModified}\n}`,
   );
 });
+
+it("console.log on a arguments shows list", () => {
+  function fn() {
+    expect(Bun.inspect(arguments)).toBe(`[ 1, [ 1 ], [Function: fn] ]`);
+  }
+  fn(1, [1], fn);
+});
+
+it("console.log on null prototype", () => {
+  expect(Bun.inspect(Object.create(null))).toBe("[Object: null prototype] {}");
+});
diff --git a/test/js/bun/util/randomUUIDv7.test.ts b/test/js/bun/util/randomUUIDv7.test.ts
new file mode 100644
index 0000000000..14964b025e
--- /dev/null
+++ b/test/js/bun/util/randomUUIDv7.test.ts
@@ -0,0 +1,60 @@
+import { describe, expect, test } from "bun:test";
+
+describe("randomUUIDv7", () => {
+  test("basic", () => {
+    expect(Bun.randomUUIDv7()).toBeTypeOf("string");
+
+    // "0192ce01-8345-7e10-36a8-2f220ca9e4c7"
+    expect(Bun.randomUUIDv7()).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/);
+
+    // Version number:
+    expect(Bun.randomUUIDv7()["0192ce01-8345-".length]).toBe("7");
+  });
+
+  test("timestamp", () => {
+    const now = Date.now();
+    const uuid = Bun.randomUUIDv7(undefined, now).replaceAll("-", "");
+    const timestampOriginal = parseInt(uuid.slice(0, 12).toString(), 16);
+
+    // On Windows, timers drift by about 16ms. Let's 2x that.
+    const timestamp = Math.max(timestampOriginal, now) - Math.min(timestampOriginal, now);
+    expect(timestamp).toBeLessThanOrEqual(32);
+  });
+
+  test("base64 format", () => {
+    const uuid = Bun.randomUUIDv7("base64");
+    expect(uuid).toMatch(/^[0-9a-zA-Z+/=]+$/);
+  });
+
+  test("buffer output encoding", () => {
+    const uuid = Bun.randomUUIDv7("buffer");
+    expect(uuid).toBeInstanceOf(Buffer);
+    expect(uuid.byteLength).toBe(16);
+    console.log(uuid.toString("hex"));
+  });
+
+  test("custom timestamp", () => {
+    const customTimestamp = 1625097600000; // 2021-07-01T00:00:00.000Z
+    const uuid = Bun.randomUUIDv7("hex", customTimestamp);
+    expect(uuid).toStartWith("017a5f5d-");
+    expect(Bun.randomUUIDv7()).not.toStartWith("017a5f5d-");
+    expect(Bun.randomUUIDv7("hex", new Date(customTimestamp))).toStartWith("017a5f5d-");
+    console.log({ uuid });
+    console.log({ uuid: Bun.randomUUIDv7("hex", new Date(customTimestamp)) });
+    console.log({ uuid: Bun.randomUUIDv7("hex", new Date(customTimestamp)) });
+  });
+
+  test("monotonic", () => {
+    const customTimestamp = 1625097600000; // 2021-07-01T00:00:00.000Z
+    let input = Array.from({ length: 100 }, () => Bun.randomUUIDv7("hex", customTimestamp));
+    let sorted = input.slice().sort();
+
+    // If we get unlucky, it will rollover.
+    if (!Bun.deepEquals(sorted, input)) {
+      input = Array.from({ length: 100 }, () => Bun.randomUUIDv7("hex", customTimestamp));
+      sorted = input.slice().sort();
+    }
+
+    expect(sorted).toEqual(input);
+  });
+});
diff --git a/test/js/bun/websocket/websocket-server.test.ts b/test/js/bun/websocket/websocket-server.test.ts
index 6bcb231747..23022030c2 100644
--- a/test/js/bun/websocket/websocket-server.test.ts
+++ b/test/js/bun/websocket/websocket-server.test.ts
@@ -825,3 +825,13 @@ async function connect(server: Server): Promise<void> {
   clients.push(client);
   await promise;
 }
+
+it("you can call server.subscriberCount() when its not a websocket server", async () => {
+  using server = serve({
+    port: 0,
+    fetch(request, server) {
+      return new Response();
+    },
+  });
+  expect(server.subscriberCount("boop")).toBe(0);
+});
diff --git a/test/js/deno/performance/performance.test.ts b/test/js/deno/performance/performance.test.ts
index 00e0dc47b3..8753b774f8 100644
--- a/test/js/deno/performance/performance.test.ts
+++ b/test/js/deno/performance/performance.test.ts
@@ -28,7 +28,7 @@ test(function performanceToJSON() {
   assert("timeOrigin" in json);
   assert(json.timeOrigin === performance.timeOrigin);
   // check there are no other keys
-  assertEquals(Object.keys(json).length, 1);
+  assertEquals(Object.keys(json).length, 2);
 });
 
 test(function performanceMark() {
diff --git a/test/js/first_party/undici/undici-primordials.test.ts b/test/js/first_party/undici/undici-primordials.test.ts
index 326f28a2e0..805df11e4c 100644
--- a/test/js/first_party/undici/undici-primordials.test.ts
+++ b/test/js/first_party/undici/undici-primordials.test.ts
@@ -29,8 +29,62 @@ it("undici", () => {
   expect(undici.Headers).toBe(Headers);
   expect(undici.FormData).toBe(FormData);
   expect(undici.File).toBe(File);
-  expect(undici.URL).toBe(URL);
-  expect(undici.URLSearchParams).toBe(URLSearchParams);
+
+  const props = [
+    "Agent",
+    "BalancedPool",
+    "Client",
+    "CloseEvent",
+    "DecoratorHandler",
+    "Dispatcher",
+    "EnvHttpProxyAgent",
+    "ErrorEvent",
+    "EventSource",
+    "File",
+    "FileReader",
+    "FormData",
+    "Headers",
+    "MessageEvent",
+    "MockAgent",
+    "MockClient",
+    "MockPool",
+    "Pool",
+    "ProxyAgent",
+    "RedirectHandler",
+    "Request",
+    "Response",
+    "RetryAgent",
+    "RetryHandler",
+    "WebSocket",
+    "buildConnector",
+    "caches",
+    "connect",
+    "createRedirectInterceptor",
+    "default",
+    "deleteCookie",
+    "errors",
+    "fetch",
+    "getCookies",
+    "getGlobalDispatcher",
+    "getGlobalOrigin",
+    "getSetCookies",
+    "interceptors",
+    "mockErrors",
+    "parseMIMEType",
+    "pipeline",
+    "request",
+    "serializeAMimeType",
+    "setCookie",
+    "setGlobalDispatcher",
+    "setGlobalOrigin",
+    "stream",
+    "upgrade",
+    "util",
+  ];
+
+  for (const prop of props) {
+    expect(undici).toHaveProperty(prop);
+  }
 
   // Note: AbortSignal is not exported. It's just used internally.
 });
diff --git a/test/js/first_party/ws/ws.test.ts b/test/js/first_party/ws/ws.test.ts
index fa810ce0aa..1325be7ebe 100644
--- a/test/js/first_party/ws/ws.test.ts
+++ b/test/js/first_party/ws/ws.test.ts
@@ -4,6 +4,10 @@ import { afterEach, beforeEach, describe, expect, it } from "bun:test";
 import { bunEnv, bunExe } from "harness";
 import path from "node:path";
 import { Server, WebSocket, WebSocketServer } from "ws";
+import { createServer } from "http";
+import { connect, AddressInfo } from "net";
+import { once } from "events";
+import crypto from "crypto";
 
 const strings = [
   {
@@ -411,6 +415,47 @@ it("close event", async () => {
   wss.close();
 });
 
+// https://github.com/oven-sh/bun/issues/14345
+it("WebSocket finishRequest mocked", async () => {
+  const { promise, resolve, reject } = Promise.withResolvers();
+
+  using server = Bun.serve({
+    port: 0,
+    websocket: {
+      open() {},
+      close() {},
+      message() {},
+    },
+    fetch(req, server) {
+      expect(req.headers.get("X-Custom-Header")).toBe("CustomValue");
+      expect(req.headers.get("Another-Header")).toBe("AnotherValue");
+      return server.upgrade(req);
+    },
+  });
+
+  const customHeaders = {
+    "X-Custom-Header": "CustomValue",
+    "Another-Header": "AnotherValue",
+  };
+
+  const ws = new WebSocket(server.url, [], {
+    finishRequest: req => {
+      Object.entries(customHeaders).forEach(([key, value]) => {
+        req.setHeader(key, value);
+      });
+      req.end();
+    },
+  });
+
+  ws.once("open", () => {
+    ws.send("Hello");
+    ws.close();
+    resolve();
+  });
+
+  await promise;
+});
+
 function test(label: string, fn: (ws: WebSocket, done: (err?: unknown) => void) => void, timeout?: number) {
   it(
     label,
@@ -507,3 +552,175 @@ it("WebSocketServer should handle backpressure", async () => {
     wss.close();
   }
 });
+
+it("Server should be able to send empty pings", async () => {
+  // WebSocket frame creation function with masking
+  function createWebSocketFrame(message: string) {
+    const messageBuffer = Buffer.from(message);
+    const frame = [];
+
+    // Add FIN bit and opcode for text frame
+    frame.push(0x81);
+
+    // Payload length
+    if (messageBuffer.length < 126) {
+      frame.push(messageBuffer.length | 0x80); // Mask bit set
+    } else if (messageBuffer.length < 65536) {
+      frame.push(126 | 0x80); // Mask bit set
+      frame.push((messageBuffer.length >> 8) & 0xff);
+      frame.push(messageBuffer.length & 0xff);
+    } else {
+      frame.push(127 | 0x80); // Mask bit set
+      for (let i = 7; i >= 0; i--) {
+        frame.push((messageBuffer.length >> (i * 8)) & 0xff);
+      }
+    }
+
+    // Generate masking key
+    const maskingKey = crypto.randomBytes(4);
+    frame.push(...maskingKey);
+
+    // Mask the payload
+    const maskedPayload = Buffer.alloc(messageBuffer.length);
+    for (let i = 0; i < messageBuffer.length; i++) {
+      maskedPayload[i] = messageBuffer[i] ^ maskingKey[i % 4];
+    }
+
+    // Combine frame header and masked payload
+    return Buffer.concat([Buffer.from(frame), maskedPayload]);
+  }
+
+  async function checkPing(helloMessage: string, pingMessage?: string) {
+    const { promise, resolve, reject } = Promise.withResolvers();
+    const server = new WebSocketServer({ noServer: true });
+    const httpServer = createServer();
+
+    try {
+      server.on("connection", async incoming => {
+        incoming.on("message", value => {
+          try {
+            expect(value.toString()).toBe(helloMessage);
+            if (arguments.length > 1) {
+              incoming.ping(pingMessage);
+            } else {
+              incoming.ping();
+            }
+          } catch (e) {
+            reject(e);
+          }
+        });
+      });
+
+      httpServer.on("upgrade", async (request, socket, head) => {
+        server.handleUpgrade(request, socket, head, ws => {
+          server.emit("connection", ws, request);
+        });
+      });
+      httpServer.listen(0);
+      await once(httpServer, "listening");
+      const socket = connect({
+        port: (httpServer.address() as AddressInfo).port,
+        host: "127.0.0.1",
+      });
+
+      let upgradeResponse = "";
+
+      let state = 0; //connecting
+      socket.on("data", (data: Buffer) => {
+        switch (state) {
+          case 0: {
+            upgradeResponse += data.toString("utf8");
+
+            if (upgradeResponse.indexOf("\r\n\r\n") !== -1) {
+              if (upgradeResponse.indexOf("HTTP/1.1 101 Switching Protocols") !== -1) {
+                state = 1;
+                socket.write(createWebSocketFrame(helloMessage));
+              } else {
+                reject(new Error("Failed to Upgrade WebSockets"));
+                state = 2;
+                socket.end();
+              }
+            }
+            break;
+          }
+          case 1: {
+            if (data.at(0) === 137) {
+              try {
+                const len = data.at(1) as number;
+                if (len > 0) {
+                  const str = data.slice(2, len + 2).toString("utf8");
+                  resolve(str);
+                } else {
+                  resolve("");
+                }
+              } catch (e) {
+                reject(e);
+              }
+              state = 2;
+              socket.end();
+              break;
+            }
+            reject(new Error("Unexpected data received"));
+          }
+          case 2: {
+            reject(new Error("Connection Closed"));
+          }
+        }
+      });
+
+      // Generate a Sec-WebSocket-Key
+      const key = crypto.randomBytes(16).toString("base64");
+
+      // Create the WebSocket upgrade request
+      socket.write(
+        [
+          `GET / HTTP/1.1`,
+          `Host: 127.0.0.1`,
+          `Upgrade: websocket`,
+          `Connection: Upgrade`,
+          `Sec-WebSocket-Key: ${key}`,
+          `Sec-WebSocket-Version: 13`,
+          `\r\n`,
+        ].join("\r\n"),
+      );
+
+      return await promise;
+    } finally {
+      httpServer.closeAllConnections();
+    }
+  }
+  {
+    // test without any payload
+    const pingMessage = await checkPing("");
+    expect(pingMessage).toBe("");
+  }
+  {
+    // test with null payload
+    //@ts-ignore
+    const pingMessage = await checkPing("", null);
+    expect(pingMessage).toBe("");
+  }
+  {
+    // test with undefined payload
+    const pingMessage = await checkPing("", undefined);
+    expect(pingMessage).toBe("");
+  }
+  {
+    // test with some payload
+    const pingMessage = await checkPing("Hello", "bun");
+    expect(pingMessage).toBe("bun");
+  }
+  {
+    // test limits
+    const pingPayload = Buffer.alloc(125, "b").toString();
+    const pingMessage = await checkPing("Hello, World", pingPayload);
+    expect(pingMessage).toBe(pingPayload);
+  }
+
+  {
+    // should not be equal because is bigger than 125 bytes
+    const pingPayload = Buffer.alloc(126, "b").toString();
+    const pingMessage = await checkPing("Hello, World", pingPayload);
+    expect(pingMessage).not.toBe(pingPayload);
+  }
+});
diff --git a/test/js/junit-reporter/junit.test.js b/test/js/junit-reporter/junit.test.js
new file mode 100644
index 0000000000..fdbc19196b
--- /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/buffer.test.js b/test/js/node/buffer.test.js
index 17f25ec067..645d29ac9e 100644
--- a/test/js/node/buffer.test.js
+++ b/test/js/node/buffer.test.js
@@ -17,7 +17,6 @@ afterEach(() => gc());
  * 1. First we run them with native Buffer.write
  * 2. Then we run them with Node.js' implementation of Buffer.write, calling out to Bun's implementation of utf8Write, asciiWrite, latin1Write, base64Write, base64urlWrite, ucs2Write, utf16leWrite, utf16beWrite, etc.
  *
- *
  */
 const NumberIsInteger = Number.isInteger;
 class ERR_INVALID_ARG_TYPE extends TypeError {
@@ -308,8 +307,6 @@ for (let withOverridenBufferWrite of [false, true]) {
         // Try to copy 0 bytes past the end of the target buffer
         b.copy(Buffer.alloc(0), 1, 1, 1);
         b.copy(Buffer.alloc(1), 1, 1, 1);
-        // Try to copy 0 bytes from past the end of the source buffer
-        b.copy(Buffer.alloc(1), 0, 2048, 2048);
       });
 
       it("smart defaults and ability to pass string values as offset", () => {
@@ -636,6 +633,37 @@ for (let withOverridenBufferWrite of [false, true]) {
         expect(dot.toString("base64url")).toBe("__4uAA");
       });
 
+      describe("writing with offset undefined", () => {
+        [
+          ["writeUInt8", "readUInt8", 8, 1],
+          ["writeInt8", "readInt8", 8, 1],
+          ["writeUInt16LE", "readUInt16LE", 8, 2],
+          ["writeInt16LE", "readInt16LE", 8, 2],
+          ["writeUInt16BE", "readUInt16BE", 8, 2],
+          ["writeInt16BE", "readInt16BE", 8, 2],
+          ["writeUInt32LE", "readUInt32LE", 8, 4],
+          ["writeInt32LE", "readInt32LE", 8, 4],
+          ["writeUInt32BE", "readUInt32BE", 8, 4],
+          ["writeInt32BE", "readInt32BE", 8, 4],
+          ["writeFloatLE", "readFloatLE", 8, 4],
+          ["writeFloatBE", "readFloatBE", 8, 4],
+          ["writeDoubleLE", "readDoubleLE", 8, 8],
+          ["writeDoubleBE", "readDoubleBE", 8, 8],
+        ].forEach(([method, read, value, size]) => {
+          it(`${method} (implicit offset)`, () => {
+            const b = Buffer.alloc(10, 42);
+            expect(b[method](value)).toBe(size);
+            expect(b[read]()).toBe(value);
+          });
+
+          it(`${method} (explicit offset)`, () => {
+            const b = Buffer.alloc(10, 42);
+            expect(b[method](value, 0)).toBe(size);
+            expect(b[read]()).toBe(value);
+          });
+        });
+      });
+
       // https://github.com/joyent/node/issues/402
       it("writing base64 at a position > 0 should not mangle the result", () => {
         const segments = ["TWFkbmVzcz8h", "IFRoaXM=", "IGlz", "IG5vZGUuanMh"];
@@ -964,6 +992,10 @@ for (let withOverridenBufferWrite of [false, true]) {
         expect(buf[4]).toBe(128);
       });
 
+      it("fill(N, empty string) should be the same as fill(N) and not include any uninitialized bytes", () => {
+        expect(Buffer.alloc(100, "")).toEqual(Buffer.alloc(100));
+      });
+
       // https://github.com/joyent/node/issues/1758
       it("check for fractional length args, junk length args, etc.", () => {
         // Call .fill() first, stops valgrind warning about uninitialized memory reads.
@@ -1149,11 +1181,9 @@ for (let withOverridenBufferWrite of [false, true]) {
       });
 
       it("ParseArrayIndex() should reject values that don't fit in a 32 bits size_t", () => {
-        expect(() => {
-          const a = Buffer.alloc(1);
-          const b = Buffer.alloc(1);
-          a.copy(b, 0, 0x100000000, 0x100000001);
-        }).toThrow(RangeError);
+        const a = Buffer.alloc(1);
+        const b = Buffer.alloc(1);
+        expect(() => a.copy(b, 0, 0x100000000, 0x100000001)).toThrowWithCode(RangeError, "ERR_OUT_OF_RANGE");
       });
 
       it("unpooled buffer (replaces SlowBuffer)", () => {
@@ -2003,9 +2033,9 @@ for (let withOverridenBufferWrite of [false, true]) {
 
       it("constants", () => {
         expect(BufferModule.constants.MAX_LENGTH).toBe(4294967296);
-        expect(BufferModule.constants.MAX_STRING_LENGTH).toBe(4294967295);
+        expect(BufferModule.constants.MAX_STRING_LENGTH).toBe(2147483647);
         expect(BufferModule.default.constants.MAX_LENGTH).toBe(4294967296);
-        expect(BufferModule.default.constants.MAX_STRING_LENGTH).toBe(4294967295);
+        expect(BufferModule.default.constants.MAX_STRING_LENGTH).toBe(2147483647);
       });
 
       it("File", () => {
@@ -2917,3 +2947,27 @@ export function fillRepeating(dstBuffer, start, end) {
     sLen <<= 1; // double length for next segment
   }
 }
+
+describe("serialization", () => {
+  it("json", () => {
+    expect(JSON.stringify(Buffer.alloc(0))).toBe('{"type":"Buffer","data":[]}');
+    expect(JSON.stringify(Buffer.from([1, 2, 3, 4]))).toBe('{"type":"Buffer","data":[1,2,3,4]}');
+  });
+
+  it("and deserialization", () => {
+    const buf = Buffer.from("test");
+    const json = JSON.stringify(buf);
+    const obj = JSON.parse(json);
+    const copy = Buffer.from(obj);
+    expect(copy).toEqual(buf);
+  });
+
+  it("custom", () => {
+    const buffer = Buffer.from("test");
+    const string = JSON.stringify(buffer);
+    expect(string).toBe('{"type":"Buffer","data":[116,101,115,116]}');
+
+    const receiver = (key, value) => (value && value.type === "Buffer" ? Buffer.from(value.data) : value);
+    expect(JSON.parse(string, receiver)).toEqual(buffer);
+  });
+});
diff --git a/test/js/node/child_process/child_process.test.ts b/test/js/node/child_process/child_process.test.ts
index 5aacea2f33..f70772d421 100644
--- a/test/js/node/child_process/child_process.test.ts
+++ b/test/js/node/child_process/child_process.test.ts
@@ -96,7 +96,7 @@ describe("spawn()", () => {
   it("should disallow invalid filename", () => {
     // @ts-ignore
     expect(() => spawn(123)).toThrow({
-      message: 'The "file" argument must be of type string. Received: 123',
+      message: 'The "file" argument must be of type string. Received 123',
       code: "ERR_INVALID_ARG_TYPE",
     });
   });
@@ -279,6 +279,33 @@ describe("spawn()", () => {
     const { stdout } = spawnSync("bun", ["-v"], { encoding: "utf8" });
     expect(isValidSemver(stdout.trim())).toBe(true);
   });
+
+  describe("stdio", () => {
+    it("ignore", () => {
+      const child = spawn(bunExe(), ["-v"], { stdio: "ignore" });
+      expect(!!child).toBe(true);
+      expect(child.stdout).toBeNull();
+      expect(child.stderr).toBeNull();
+    });
+    it("inherit", () => {
+      const child = spawn(bunExe(), ["-v"], { stdio: "inherit" });
+      expect(!!child).toBe(true);
+      expect(child.stdout).toBeNull();
+      expect(child.stderr).toBeNull();
+    });
+    it("pipe", () => {
+      const child = spawn(bunExe(), ["-v"], { stdio: "pipe" });
+      expect(!!child).toBe(true);
+      expect(child.stdout).not.toBeNull();
+      expect(child.stderr).not.toBeNull();
+    });
+    it.todo("overlapped", () => {
+      const child = spawn(bunExe(), ["-v"], { stdio: "overlapped" });
+      expect(!!child).toBe(true);
+      expect(child.stdout).not.toBeNull();
+      expect(child.stderr).not.toBeNull();
+    });
+  });
 });
 
 describe("execFile()", () => {
@@ -417,3 +444,23 @@ 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");
+});
+
+it("spawnSync(does-not-exist)", () => {
+  const x = spawnSync("does-not-exist");
+  expect(x.error?.code).toEqual("ENOENT");
+  expect(x.error.path).toEqual("does-not-exist");
+  expect(x.signal).toEqual(null);
+  expect(x.output).toEqual([null, null, null]);
+  expect(x.stdout).toEqual(null);
+  expect(x.stderr).toEqual(null);
+});
diff --git a/test/js/node/cluster/common.ts b/test/js/node/cluster/common.ts
deleted file mode 100644
index b99b402c49..0000000000
--- a/test/js/node/cluster/common.ts
+++ /dev/null
@@ -1,37 +0,0 @@
-import assert from "node:assert";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import process from "node:process";
-import util from "node:util";
-
-export const isWindows = process.platform === "win32";
-
-export function tmpdirSync(pattern: string = "bun.test.") {
-  return fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), pattern));
-}
-
-export function isAlive(pid) {
-  try {
-    process.kill(pid, "SIGCONT");
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export function mustNotCall(msg?) {
-  return function mustNotCall(...args) {
-    const argsInfo = args.length > 0 ? `\ncalled with arguments: ${args.map(arg => util.inspect(arg)).join(", ")}` : "";
-    assert.fail(`${msg || "function should not have been called"} ` + argsInfo);
-  };
-}
-
-export function patchEmitter(emitter: any, prefix: string) {
-  var oldEmit = emitter.emit;
-
-  emitter.emit = function () {
-    console.log([prefix, arguments[0]]);
-    oldEmit.apply(emitter, arguments);
-  };
-}
diff --git a/test/js/node/cluster/test-docs-http-server.ts b/test/js/node/cluster/test-docs-http-server.ts
index 91547ed7ae..a72498d227 100644
--- a/test/js/node/cluster/test-docs-http-server.ts
+++ b/test/js/node/cluster/test-docs-http-server.ts
@@ -1,8 +1,14 @@
+import { isBroken, isWindows } from "harness";
 import assert from "node:assert";
 import cluster from "node:cluster";
 import http from "node:http";
 import { availableParallelism } from "node:os";
 
+if (isWindows && isBroken) {
+  console.log("Skipping on Windows because it does not work when there are more than 1 CPU");
+  process.exit(0);
+}
+
 const numCPUs = availableParallelism();
 let workers = 0;
 
diff --git a/test/js/node/cluster/test-worker-no-exit-http.ts b/test/js/node/cluster/test-worker-no-exit-http.ts
index 661c439861..93156225b9 100644
--- a/test/js/node/cluster/test-worker-no-exit-http.ts
+++ b/test/js/node/cluster/test-worker-no-exit-http.ts
@@ -1,7 +1,15 @@
 const assert = require("assert");
 const cluster = require("cluster");
 const http = require("http");
-import { patchEmitter } from "./common";
+
+function patchEmitter(emitter: any, prefix: string) {
+  var oldEmit = emitter.emit;
+
+  emitter.emit = function () {
+    console.log([prefix, arguments[0]]);
+    oldEmit.apply(emitter, arguments);
+  };
+}
 
 let destroyed;
 let success;
diff --git a/test/js/node/cluster/upstream/common/countdown.js b/test/js/node/cluster/upstream/common/countdown.js
deleted file mode 100644
index 9853c9fa47..0000000000
--- a/test/js/node/cluster/upstream/common/countdown.js
+++ /dev/null
@@ -1,27 +0,0 @@
-"use strict";
-
-const assert = require("assert");
-const kLimit = Symbol("limit");
-const kCallback = Symbol("callback");
-const common = require("./");
-
-class Countdown {
-  constructor(limit, cb) {
-    assert.strictEqual(typeof limit, "number");
-    assert.strictEqual(typeof cb, "function");
-    this[kLimit] = limit;
-    this[kCallback] = common.mustCall(cb);
-  }
-
-  dec() {
-    assert(this[kLimit] > 0, "Countdown expired");
-    if (--this[kLimit] === 0) this[kCallback]();
-    return this[kLimit];
-  }
-
-  get remaining() {
-    return this[kLimit];
-  }
-}
-
-module.exports = Countdown;
diff --git a/test/js/node/cluster/upstream/common/index.js b/test/js/node/cluster/upstream/common/index.js
deleted file mode 100644
index 46df521726..0000000000
--- a/test/js/node/cluster/upstream/common/index.js
+++ /dev/null
@@ -1,248 +0,0 @@
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-// /* eslint-disable node-core/crypto-check */
-"use strict";
-const process = global.process; // Some tests tamper with the process global.
-
-const assert = require("assert");
-const { exec, execSync, spawn, spawnSync } = require("child_process");
-const fs = require("fs");
-const net = require("net");
-// Do not require 'os' until needed so that test-os-checked-function can
-// monkey patch it. If 'os' is required here, that test will fail.
-const path = require("path");
-const { inspect } = require("util");
-const { isMainThread } = require("worker_threads");
-
-// Some tests assume a umask of 0o022 so set that up front. Tests that need a
-// different umask will set it themselves.
-//
-// Workers can read, but not set the umask, so check that this is the main
-// thread.
-if (isMainThread) process.umask(0o022);
-
-const noop = () => {};
-
-const isWindows = process.platform === "win32";
-const isSunOS = process.platform === "sunos";
-const isFreeBSD = process.platform === "freebsd";
-const isOpenBSD = process.platform === "openbsd";
-const isLinux = process.platform === "linux";
-const isOSX = process.platform === "darwin";
-const isPi = (() => {
-  try {
-    // Normal Raspberry Pi detection is to find the `Raspberry Pi` string in
-    // the contents of `/sys/firmware/devicetree/base/model` but that doesn't
-    // work inside a container. Match the chipset model number instead.
-    const cpuinfo = fs.readFileSync("/proc/cpuinfo", { encoding: "utf8" });
-    const ok = /^Hardware\s*:\s*(.*)$/im.exec(cpuinfo)?.[1] === "BCM2835";
-    /^/.test(""); // Clear RegExp.$_, some tests expect it to be empty.
-    return ok;
-  } catch {
-    return false;
-  }
-})();
-
-const isDumbTerminal = process.env.TERM === "dumb";
-
-const mustCallChecks = [];
-
-function runCallChecks(exitCode) {
-  if (exitCode !== 0) return;
-
-  const failed = mustCallChecks.filter(function (context) {
-    if ("minimum" in context) {
-      context.messageSegment = `at least ${context.minimum}`;
-      return context.actual < context.minimum;
-    }
-    context.messageSegment = `exactly ${context.exact}`;
-    return context.actual !== context.exact;
-  });
-
-  failed.forEach(function (context) {
-    console.log(
-      "Mismatched %s function calls. Expected %s, actual %d.",
-      context.name,
-      context.messageSegment,
-      context.actual,
-    );
-    console.log(context.stack.split("\n").slice(2).join("\n"));
-  });
-
-  if (failed.length) process.exit(1);
-}
-
-function mustCall(fn, exact) {
-  return _mustCallInner(fn, exact, "exact");
-}
-
-function mustSucceed(fn, exact) {
-  return mustCall(function (err, ...args) {
-    assert.ifError(err);
-    if (typeof fn === "function") return fn.apply(this, args);
-  }, exact);
-}
-
-function _mustCallInner(fn, criteria = 1, field) {
-  if (process._exiting) throw new Error("Cannot use common.mustCall*() in process exit handler");
-  if (typeof fn === "number") {
-    criteria = fn;
-    fn = noop;
-  } else if (fn === undefined) {
-    fn = noop;
-  }
-
-  if (typeof criteria !== "number") throw new TypeError(`Invalid ${field} value: ${criteria}`);
-
-  const context = {
-    [field]: criteria,
-    actual: 0,
-    stack: inspect(new Error()),
-    name: fn.name || "<anonymous>",
-  };
-
-  // Add the exit listener only once to avoid listener leak warnings
-  if (mustCallChecks.length === 0) process.on("exit", runCallChecks);
-
-  mustCallChecks.push(context);
-
-  const _return = function () {
-    // eslint-disable-line func-style
-    context.actual++;
-    return fn.apply(this, arguments);
-  };
-  // Function instances have own properties that may be relevant.
-  // Let's replicate those properties to the returned function.
-  // Refs: https://tc39.es/ecma262/#sec-function-instances
-  Object.defineProperties(_return, {
-    name: {
-      value: fn.name,
-      writable: false,
-      enumerable: false,
-      configurable: true,
-    },
-    length: {
-      value: fn.length,
-      writable: false,
-      enumerable: false,
-      configurable: true,
-    },
-  });
-  return _return;
-}
-
-function getCallSite(top) {
-  const originalStackFormatter = Error.prepareStackTrace;
-  Error.prepareStackTrace = (err, stack) => `${stack[0].getFileName()}:${stack[0].getLineNumber()}`;
-  const err = new Error();
-  Error.captureStackTrace(err, top);
-  // With the V8 Error API, the stack is not formatted until it is accessed
-  err.stack; // eslint-disable-line no-unused-expressions
-  Error.prepareStackTrace = originalStackFormatter;
-  return err.stack;
-}
-
-function mustNotCall(msg) {
-  const callSite = getCallSite(mustNotCall);
-  return function mustNotCall(...args) {
-    const argsInfo = args.length > 0 ? `\ncalled with arguments: ${args.map(arg => inspect(arg)).join(", ")}` : "";
-    assert.fail(`${msg || "function should not have been called"} at ${callSite}` + argsInfo);
-  };
-}
-
-function printSkipMessage(msg) {
-  console.log(`1..0 # Skipped: ${msg}`);
-}
-
-function skip(msg) {
-  printSkipMessage(msg);
-  process.exit(0);
-}
-
-function isAlive(pid) {
-  try {
-    process.kill(pid, "SIGCONT");
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function skipIf32Bits() {
-  if (bits < 64) {
-    skip("The tested feature is not available in 32bit builds");
-  }
-}
-
-function skipIfWorker() {
-  if (!isMainThread) {
-    skip("This test only works on a main thread");
-  }
-}
-
-function skipIfDumbTerminal() {
-  if (isDumbTerminal) {
-    skip("skipping - dumb terminal");
-  }
-}
-
-const common = {
-  isAlive,
-  isDumbTerminal,
-  isFreeBSD,
-  isLinux,
-  isMainThread,
-  isOpenBSD,
-  isOSX,
-  isPi,
-  isSunOS,
-  isWindows,
-  mustCall,
-  mustNotCall,
-  mustSucceed,
-  printSkipMessage,
-  skip,
-  skipIf32Bits,
-  skipIfDumbTerminal,
-  // On IBMi, process.platform and os.platform() both return 'aix',
-  // when built with Python versions earlier than 3.9.
-  // It is not enough to differentiate between IBMi and real AIX system.
-  get isAIX() {
-    return require("os").type() === "AIX";
-  },
-
-  get isIBMi() {
-    return require("os").type() === "OS400";
-  },
-
-  get isLinuxPPCBE() {
-    return process.platform === "linux" && process.arch === "ppc64" && require("os").endianness() === "BE";
-  },
-};
-
-const validProperties = new Set(Object.keys(common));
-module.exports = new Proxy(common, {
-  get(obj, prop) {
-    if (!validProperties.has(prop)) throw new Error(`Using invalid common property: '${prop}'`);
-    return obj[prop];
-  },
-});
diff --git a/test/js/node/cluster/upstream/common/tmpdir.js b/test/js/node/cluster/upstream/common/tmpdir.js
deleted file mode 100644
index 7de0b113a3..0000000000
--- a/test/js/node/cluster/upstream/common/tmpdir.js
+++ /dev/null
@@ -1,88 +0,0 @@
-"use strict";
-
-const { spawnSync } = require("child_process");
-const fs = require("fs");
-const path = require("path");
-const { pathToFileURL } = require("url");
-const { isMainThread } = require("worker_threads");
-
-function rmSync(pathname, useSpawn) {
-  if (useSpawn) {
-    const escapedPath = pathname.replaceAll("\\", "\\\\");
-    spawnSync(process.execPath, [
-      "-e",
-      `require("fs").rmSync("${escapedPath}", { maxRetries: 3, recursive: true, force: true });`,
-    ]);
-  } else {
-    fs.rmSync(pathname, { maxRetries: 3, recursive: true, force: true });
-  }
-}
-
-const testRoot = process.env.NODE_TEST_DIR ? fs.realpathSync(process.env.NODE_TEST_DIR) : path.resolve(__dirname, "..");
-
-// Using a `.` prefixed name, which is the convention for "hidden" on POSIX,
-// gets tools to ignore it by default or by simple rules, especially eslint.
-const tmpdirName = ".tmp." + (process.env.TEST_SERIAL_ID || process.env.TEST_THREAD_ID || "0");
-const tmpPath = path.join(testRoot, tmpdirName);
-
-let firstRefresh = true;
-function refresh(useSpawn = false) {
-  rmSync(tmpPath, useSpawn);
-  fs.mkdirSync(tmpPath);
-
-  if (firstRefresh) {
-    firstRefresh = false;
-    // Clean only when a test uses refresh. This allows for child processes to
-    // use the tmpdir and only the parent will clean on exit.
-    process.on("exit", () => {
-      return onexit(useSpawn);
-    });
-  }
-}
-
-function onexit(useSpawn) {
-  // Change directory to avoid possible EBUSY
-  if (isMainThread) process.chdir(testRoot);
-
-  try {
-    rmSync(tmpPath, useSpawn);
-  } catch (e) {
-    console.error("Can't clean tmpdir:", tmpPath);
-
-    const files = fs.readdirSync(tmpPath);
-    console.error("Files blocking:", files);
-
-    if (files.some(f => f.startsWith(".nfs"))) {
-      // Warn about NFS "silly rename"
-      console.error('Note: ".nfs*" might be files that were open and ' + "unlinked but not closed.");
-      console.error("See http://nfs.sourceforge.net/#faq_d2 for details.");
-    }
-
-    console.error();
-    throw e;
-  }
-}
-
-function resolve(...paths) {
-  return path.resolve(tmpPath, ...paths);
-}
-
-function hasEnoughSpace(size) {
-  const { bavail, bsize } = fs.statfsSync(tmpPath);
-  return bavail >= Math.ceil(size / bsize);
-}
-
-function fileURL(...paths) {
-  // When called without arguments, add explicit trailing slash
-  const fullPath = path.resolve(tmpPath + path.sep, ...paths);
-
-  return pathToFileURL(fullPath);
-}
-
-module.exports = {
-  fileURL,
-  hasEnoughSpace,
-  path: tmpPath,
-  refresh,
-  resolve,
-};
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-advanced-serialization.js b/test/js/node/cluster/upstream/parallel/test-cluster-advanced-serialization.js
deleted file mode 100644
index 8a368d44c7..0000000000
--- a/test/js/node/cluster/upstream/parallel/test-cluster-advanced-serialization.js
+++ /dev/null
@@ -1,28 +0,0 @@
-"use strict";
-const common = require("../common");
-const assert = require("assert");
-const cluster = require("cluster");
-
-if (cluster.isPrimary) {
-  cluster.settings.serialization = "advanced";
-  const worker = cluster.fork();
-  const circular = {};
-  circular.circular = circular;
-
-  worker.on(
-    "online",
-    common.mustCall(() => {
-      worker.send(circular);
-
-      worker.on(
-        "message",
-        common.mustCall(msg => {
-          assert.deepStrictEqual(msg, circular);
-          worker.kill();
-        }),
-      );
-    }),
-  );
-} else {
-  process.on("message", msg => process.send(msg));
-}
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-bind-privileged-port.js b/test/js/node/cluster/upstream/parallel/test-cluster-bind-privileged-port.js
deleted file mode 100644
index f3a788984b..0000000000
--- a/test/js/node/cluster/upstream/parallel/test-cluster-bind-privileged-port.js
+++ /dev/null
@@ -1,68 +0,0 @@
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const common = require("../common");
-if (common.isLinux) return; // TODO: bun
-const assert = require("assert");
-const cluster = require("cluster");
-const net = require("net");
-const { readFileSync } = require("fs");
-
-if (common.isLinux) {
-  try {
-    const unprivilegedPortStart = parseInt(readFileSync("/proc/sys/net/ipv4/ip_unprivileged_port_start"));
-    if (unprivilegedPortStart <= 42) {
-      common.skip("Port 42 is unprivileged");
-    }
-  } catch {
-    // Do nothing, feature doesn't exist, minimum is 1024 so 42 is usable.
-    // Continue...
-  }
-}
-
-// Skip on OS X Mojave. https://github.com/nodejs/node/issues/21679
-if (common.isOSX) common.skip("macOS may allow ordinary processes to use any port");
-
-if (common.isIBMi) common.skip("IBMi may allow ordinary processes to use any port");
-
-if (common.isWindows) common.skip("not reliable on Windows.");
-
-if (process.getuid() === 0) common.skip("Test is not supposed to be run as root.");
-
-if (cluster.isPrimary) {
-  cluster.fork().on(
-    "exit",
-    common.mustCall(exitCode => {
-      assert.strictEqual(exitCode, 0);
-    }),
-  );
-} else {
-  const s = net.createServer(common.mustNotCall());
-  s.listen(42, common.mustNotCall("listen should have failed"));
-  s.on(
-    "error",
-    common.mustCall(err => {
-      assert.strictEqual(err.code, "EACCES");
-      process.disconnect();
-    }),
-  );
-}
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-call-and-destroy.js b/test/js/node/cluster/upstream/parallel/test-cluster-call-and-destroy.js
deleted file mode 100644
index 6d9ff44e67..0000000000
--- a/test/js/node/cluster/upstream/parallel/test-cluster-call-and-destroy.js
+++ /dev/null
@@ -1,18 +0,0 @@
-"use strict";
-const common = require("../common");
-const cluster = require("cluster");
-const assert = require("assert");
-
-if (cluster.isPrimary) {
-  const worker = cluster.fork();
-  worker.on(
-    "disconnect",
-    common.mustCall(() => {
-      assert.strictEqual(worker.isConnected(), false);
-      worker.destroy();
-    }),
-  );
-} else {
-  assert.strictEqual(cluster.worker.isConnected(), true);
-  cluster.worker.disconnect();
-}
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-child-index-dgram.js b/test/js/node/cluster/upstream/parallel/test-cluster-child-index-dgram.js
deleted file mode 100644
index 426c8de9f4..0000000000
--- a/test/js/node/cluster/upstream/parallel/test-cluster-child-index-dgram.js
+++ /dev/null
@@ -1,43 +0,0 @@
-"use strict";
-const common = require("../common");
-const Countdown = require("../common/countdown");
-if (common.isWindows) common.skip("dgram clustering is currently not supported on Windows.");
-
-const cluster = require("cluster");
-const dgram = require("dgram");
-
-// Test an edge case when using `cluster` and `dgram.Socket.bind()`
-// the port of `0`.
-const kPort = 0;
-
-function child() {
-  const kTime = 2;
-  const countdown = new Countdown(kTime * 2, () => {
-    process.exit(0);
-  });
-  for (let i = 0; i < kTime; i += 1) {
-    const socket = new dgram.Socket("udp4");
-    socket.bind(
-      kPort,
-      common.mustCall(() => {
-        // `process.nextTick()` or `socket2.close()` would throw
-        // ERR_SOCKET_DGRAM_NOT_RUNNING
-        process.nextTick(() => {
-          socket.close(countdown.dec());
-          const socket2 = new dgram.Socket("udp4");
-          socket2.bind(
-            kPort,
-            common.mustCall(() => {
-              process.nextTick(() => {
-                socket2.close(countdown.dec());
-              });
-            }),
-          );
-        });
-      }),
-    );
-  }
-}
-
-if (cluster.isMaster) cluster.fork(__filename);
-else child();
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-child-index-net.js b/test/js/node/cluster/upstream/parallel/test-cluster-child-index-net.js
deleted file mode 100644
index 961924a2d6..0000000000
--- a/test/js/node/cluster/upstream/parallel/test-cluster-child-index-net.js
+++ /dev/null
@@ -1,35 +0,0 @@
-"use strict";
-const common = require("../common");
-const Countdown = require("../common/countdown");
-const cluster = require("cluster");
-const net = require("net");
-
-// Test an edge case when using `cluster` and `net.Server.listen()` to
-// the port of `0`.
-const kPort = 0;
-
-function child() {
-  const kTime = 2;
-  const countdown = new Countdown(kTime * 2, () => {
-    process.exit(0);
-  });
-  for (let i = 0; i < kTime; i += 1) {
-    const server = net.createServer();
-    server.listen(
-      kPort,
-      common.mustCall(() => {
-        server.close(countdown.dec());
-        const server2 = net.createServer();
-        server2.listen(
-          kPort,
-          common.mustCall(() => {
-            server2.close(countdown.dec());
-          }),
-        );
-      }),
-    );
-  }
-}
-
-if (cluster.isMaster) cluster.fork(__filename);
-else child();
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-concurrent-disconnect.js b/test/js/node/cluster/upstream/parallel/test-cluster-concurrent-disconnect.js
deleted file mode 100644
index 1e1daa9ef4..0000000000
--- a/test/js/node/cluster/upstream/parallel/test-cluster-concurrent-disconnect.js
+++ /dev/null
@@ -1,58 +0,0 @@
-"use strict";
-
-// Ref: https://github.com/nodejs/node/issues/32106
-
-const common = require("../common");
-if (common.isLinux) return; // TODO: bun
-if (common.isWindows) return; // TODO: bun
-
-const assert = require("assert");
-const cluster = require("cluster");
-const os = require("os");
-
-if (cluster.isPrimary) {
-  const workers = [];
-  const numCPUs = os.availableParallelism();
-  let waitOnline = numCPUs;
-  for (let i = 0; i < numCPUs; i++) {
-    const worker = cluster.fork();
-    workers[i] = worker;
-    worker.once(
-      "online",
-      common.mustCall(() => {
-        if (--waitOnline === 0)
-          for (const worker of workers) if (worker.isConnected()) worker.send(i % 2 ? "disconnect" : "destroy");
-      }),
-    );
-
-    // These errors can occur due to the nature of the test, we might be trying
-    // to send messages when the worker is disconnecting.
-    worker.on("error", err => {
-      assert.strictEqual(err.syscall, "write");
-      if (common.isOSX) {
-        assert(["EPIPE", "ENOTCONN"].includes(err.code), err);
-      } else {
-        assert(["EPIPE", "ECONNRESET"].includes(err.code), err);
-      }
-    });
-
-    worker.once(
-      "disconnect",
-      common.mustCall(() => {
-        for (const worker of workers) if (worker.isConnected()) worker.send("disconnect");
-      }),
-    );
-
-    worker.once(
-      "exit",
-      common.mustCall((code, signal) => {
-        assert.strictEqual(code, 0);
-        assert.strictEqual(signal, null);
-      }),
-    );
-  }
-} else {
-  process.on("message", msg => {
-    if (cluster.worker.isConnected()) cluster.worker[msg]();
-  });
-}
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-cwd.js b/test/js/node/cluster/upstream/parallel/test-cluster-cwd.js
deleted file mode 100644
index d28bfdf545..0000000000
--- a/test/js/node/cluster/upstream/parallel/test-cluster-cwd.js
+++ /dev/null
@@ -1,29 +0,0 @@
-"use strict";
-const common = require("../common");
-const assert = require("assert");
-const cluster = require("cluster");
-const tmpdir = require("../common/tmpdir");
-
-if (cluster.isPrimary) {
-  tmpdir.refresh();
-
-  assert.strictEqual(cluster.settings.cwd, undefined);
-  cluster.fork().on(
-    "message",
-    common.mustCall(msg => {
-      assert.strictEqual(msg, process.cwd());
-    }),
-  );
-
-  cluster.setupPrimary({ cwd: tmpdir.path });
-  assert.strictEqual(cluster.settings.cwd, tmpdir.path);
-  cluster.fork().on(
-    "message",
-    common.mustCall(msg => {
-      assert.strictEqual(msg, tmpdir.path);
-    }),
-  );
-} else {
-  process.send(process.cwd());
-  process.disconnect();
-}
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-disconnect-exitedAfterDisconnect-race.js b/test/js/node/cluster/upstream/parallel/test-cluster-disconnect-exitedAfterDisconnect-race.js
deleted file mode 100644
index f461734eb6..0000000000
--- a/test/js/node/cluster/upstream/parallel/test-cluster-disconnect-exitedAfterDisconnect-race.js
+++ /dev/null
@@ -1,33 +0,0 @@
-"use strict";
-
-const common = require("../common");
-
-// Test should fail in Node.js 5.4.1 and pass in later versions.
-
-const assert = require("assert");
-const cluster = require("cluster");
-
-if (cluster.isPrimary) {
-  cluster.on("exit", (worker, code) => {
-    assert.strictEqual(code, 0, `worker exited with code: ${code}, expected 0`);
-  });
-
-  return cluster.fork();
-}
-
-let eventFired = false;
-
-cluster.worker.disconnect();
-
-process.nextTick(
-  common.mustCall(() => {
-    assert.ok(!eventFired, "disconnect event should wait for ack");
-  }),
-);
-
-cluster.worker.on(
-  "disconnect",
-  common.mustCall(() => {
-    eventFired = true;
-  }),
-);
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-disconnect-leak.js b/test/js/node/cluster/upstream/parallel/test-cluster-disconnect-leak.js
deleted file mode 100644
index d1b4812004..0000000000
--- a/test/js/node/cluster/upstream/parallel/test-cluster-disconnect-leak.js
+++ /dev/null
@@ -1,27 +0,0 @@
-"use strict";
-
-// Test fails in Node v5.4.0 and passes in v5.4.1 and newer.
-
-const common = require("../common");
-const net = require("net");
-const cluster = require("cluster");
-
-cluster.schedulingPolicy = cluster.SCHED_NONE;
-
-if (cluster.isPrimary) {
-  const worker = cluster.fork();
-
-  // This is the important part of the test: Confirm that `disconnect` fires.
-  worker.on("disconnect", common.mustCall());
-
-  // These are just some extra stuff we're checking for good measure...
-  worker.on("exit", common.mustCall());
-  cluster.on("exit", common.mustCall());
-
-  cluster.disconnect();
-  return;
-}
-
-const server = net.createServer();
-
-server.listen(0);
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-fork-env.js b/test/js/node/cluster/upstream/parallel/test-cluster-fork-env.js
deleted file mode 100644
index 8bf9ef15d7..0000000000
--- a/test/js/node/cluster/upstream/parallel/test-cluster-fork-env.js
+++ /dev/null
@@ -1,66 +0,0 @@
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-require("../common");
-
-// This test checks that arguments provided to cluster.fork() will create
-// new environment variables and override existing environment variables
-// in the created worker process.
-
-const assert = require("assert");
-const cluster = require("cluster");
-
-if (cluster.isWorker) {
-  const result = cluster.worker.send({
-    prop: process.env.cluster_test_prop,
-    overwrite: process.env.cluster_test_overwrite,
-  });
-
-  assert.strictEqual(result, true);
-} else if (cluster.isPrimary) {
-  const checks = {
-    using: false,
-    overwrite: false,
-  };
-
-  // To check that the cluster extend on the process.env we will overwrite a
-  // property
-  process.env.cluster_test_overwrite = "old";
-
-  // Fork worker
-  const worker = cluster.fork({
-    "cluster_test_prop": "custom",
-    "cluster_test_overwrite": "new",
-  });
-
-  // Checks worker env
-  worker.on("message", function (data) {
-    checks.using = data.prop === "custom";
-    checks.overwrite = data.overwrite === "new";
-    process.exit(0);
-  });
-
-  process.once("exit", function () {
-    assert.ok(checks.using, "The worker did not receive the correct env.");
-    assert.ok(checks.overwrite, "The custom environment did not overwrite the existing environment.");
-  });
-}
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-fork-windowsHide.js b/test/js/node/cluster/upstream/parallel/test-cluster-fork-windowsHide.js
deleted file mode 100644
index 273e8146a7..0000000000
--- a/test/js/node/cluster/upstream/parallel/test-cluster-fork-windowsHide.js
+++ /dev/null
@@ -1,76 +0,0 @@
-"use strict";
-const common = require("../common");
-if (common.isWindows) return; // TODO: bun
-const assert = require("assert");
-const child_process = require("child_process");
-const cluster = require("cluster");
-
-if (!process.argv[2]) {
-  // It seems Windows only allocate new console window for
-  // attaching processes spawned by detached processes. i.e.
-  // - If process D is spawned by process C with `detached: true`,
-  //   and process W is spawned by process D with `detached: false`,
-  //   W will get a new black console window popped up.
-  // - If D is spawned by C with `detached: false` or W is spawned
-  //   by D with `detached: true`, no console window will pop up for W.
-  //
-  // So, we have to spawn a detached process first to run the actual test.
-  const primary = child_process.spawn(process.argv[0], [process.argv[1], "--cluster"], {
-    detached: true,
-    stdio: ["ignore", "ignore", "ignore", "ipc"],
-  });
-
-  const messageHandlers = {
-    workerOnline: common.mustCall(),
-    mainWindowHandle: common.mustCall(msg => {
-      assert.match(msg.value, /0\s*/);
-    }),
-    workerExit: common.mustCall(msg => {
-      assert.strictEqual(msg.code, 0);
-      assert.strictEqual(msg.signal, null);
-    }),
-  };
-
-  primary.on("message", msg => {
-    const handler = messageHandlers[msg.type];
-    assert.ok(handler);
-    handler(msg);
-  });
-
-  primary.on(
-    "exit",
-    common.mustCall((code, signal) => {
-      assert.strictEqual(code, 0);
-      assert.strictEqual(signal, null);
-    }),
-  );
-} else if (cluster.isPrimary) {
-  cluster.setupPrimary({
-    silent: true,
-    windowsHide: true,
-  });
-
-  const worker = cluster.fork();
-  worker.on("exit", (code, signal) => {
-    process.send({ type: "workerExit", code: code, signal: signal });
-  });
-
-  worker.on("online", msg => {
-    process.send({ type: "workerOnline" });
-
-    let output = "0";
-    if (process.platform === "win32") {
-      output = child_process.execSync(
-        "powershell -NoProfile -c " + `"(Get-Process -Id ${worker.process.pid}).MainWindowHandle"`,
-        { windowsHide: true, encoding: "utf8" },
-      );
-    }
-
-    process.send({ type: "mainWindowHandle", value: output });
-    worker.send("shutdown");
-  });
-} else {
-  cluster.worker.on("message", msg => {
-    cluster.worker.disconnect();
-  });
-}
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-invalid-message.js b/test/js/node/cluster/upstream/parallel/test-cluster-invalid-message.js
deleted file mode 100644
index fdfe1ada62..0000000000
--- a/test/js/node/cluster/upstream/parallel/test-cluster-invalid-message.js
+++ /dev/null
@@ -1,28 +0,0 @@
-"use strict";
-const common = require("../common");
-const assert = require("assert");
-const cluster = require("cluster");
-
-if (cluster.isPrimary) {
-  const worker = cluster.fork();
-
-  worker.on(
-    "exit",
-    common.mustCall((code, signal) => {
-      assert.strictEqual(code, 0);
-      assert.strictEqual(signal, null);
-    }),
-  );
-
-  worker.on("online", () => {
-    worker.send(
-      {
-        cmd: "NODE_CLUSTER",
-        ack: -1,
-      },
-      () => {
-        worker.disconnect();
-      },
-    );
-  });
-}
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-kill-disconnect.js b/test/js/node/cluster/upstream/parallel/test-cluster-kill-disconnect.js
deleted file mode 100644
index e1c0a313e2..0000000000
--- a/test/js/node/cluster/upstream/parallel/test-cluster-kill-disconnect.js
+++ /dev/null
@@ -1,34 +0,0 @@
-"use strict";
-const common = require("../common");
-
-// Check that cluster works perfectly for both `kill` and `disconnect` cases.
-// Also take into account that the `disconnect` event may be received after the
-// `exit` event.
-// https://github.com/nodejs/node/issues/3238
-
-const assert = require("assert");
-const cluster = require("cluster");
-
-if (cluster.isPrimary) {
-  function forkWorker(action) {
-    const worker = cluster.fork({ action });
-    worker.on(
-      "disconnect",
-      common.mustCall(() => {
-        assert.strictEqual(worker.exitedAfterDisconnect, true);
-      }),
-    );
-
-    worker.on(
-      "exit",
-      common.mustCall(() => {
-        assert.strictEqual(worker.exitedAfterDisconnect, true);
-      }),
-    );
-  }
-
-  forkWorker("disconnect");
-  forkWorker("kill");
-} else {
-  cluster.worker[process.env.action]();
-}
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-kill-infinite-loop.js b/test/js/node/cluster/upstream/parallel/test-cluster-kill-infinite-loop.js
deleted file mode 100644
index 837b11f2a1..0000000000
--- a/test/js/node/cluster/upstream/parallel/test-cluster-kill-infinite-loop.js
+++ /dev/null
@@ -1,27 +0,0 @@
-"use strict";
-const common = require("../common");
-const cluster = require("cluster");
-const assert = require("assert");
-
-if (cluster.isPrimary) {
-  const worker = cluster.fork();
-
-  worker.on(
-    "online",
-    common.mustCall(() => {
-      // Use worker.process.kill() instead of worker.kill() because the latter
-      // waits for a graceful disconnect, which will never happen.
-      worker.process.kill();
-    }),
-  );
-
-  worker.on(
-    "exit",
-    common.mustCall((code, signal) => {
-      assert.strictEqual(code, null);
-      assert.strictEqual(signal, "SIGTERM");
-    }),
-  );
-} else {
-  while (true);
-}
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-listening-port.js b/test/js/node/cluster/upstream/parallel/test-cluster-listening-port.js
deleted file mode 100644
index ecf9398cd7..0000000000
--- a/test/js/node/cluster/upstream/parallel/test-cluster-listening-port.js
+++ /dev/null
@@ -1,22 +0,0 @@
-"use strict";
-const common = require("../common");
-const assert = require("assert");
-const cluster = require("cluster");
-const net = require("net");
-
-if (cluster.isPrimary) {
-  cluster.fork();
-  cluster.on(
-    "listening",
-    common.mustCall(function (worker, address) {
-      const port = address.port;
-      // Ensure that the port is not 0 or null
-      assert(port);
-      // Ensure that the port is numerical
-      assert.strictEqual(typeof port, "number");
-      worker.kill();
-    }),
-  );
-} else {
-  net.createServer(common.mustNotCall()).listen(0);
-}
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-primary-error.js b/test/js/node/cluster/upstream/parallel/test-cluster-primary-error.js
deleted file mode 100644
index 763ae3eab3..0000000000
--- a/test/js/node/cluster/upstream/parallel/test-cluster-primary-error.js
+++ /dev/null
@@ -1,116 +0,0 @@
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const common = require("../common");
-const assert = require("assert");
-const cluster = require("cluster");
-
-const totalWorkers = 2;
-
-// Cluster setup
-if (cluster.isWorker) {
-  const http = require("http");
-  http.Server(() => {}).listen(0, "127.0.0.1");
-} else if (process.argv[2] === "cluster") {
-  // Send PID to testcase process
-  let forkNum = 0;
-  cluster.on(
-    "fork",
-    common.mustCall(function forkEvent(worker) {
-      // Send PID
-      process.send({
-        cmd: "worker",
-        workerPID: worker.process.pid,
-      });
-
-      // Stop listening when done
-      if (++forkNum === totalWorkers) {
-        cluster.removeListener("fork", forkEvent);
-      }
-    }, totalWorkers),
-  );
-
-  // Throw accidental error when all workers are listening
-  let listeningNum = 0;
-  cluster.on(
-    "listening",
-    common.mustCall(function listeningEvent() {
-      // When all workers are listening
-      if (++listeningNum === totalWorkers) {
-        // Stop listening
-        cluster.removeListener("listening", listeningEvent);
-
-        // Throw accidental error
-        process.nextTick(() => {
-          throw new Error("accidental error");
-        });
-      }
-    }, totalWorkers),
-  );
-
-  // Startup a basic cluster
-  cluster.fork();
-  cluster.fork();
-} else {
-  // This is the testcase
-
-  const fork = require("child_process").fork;
-
-  // List all workers
-  const workers = [];
-
-  // Spawn a cluster process
-  const primary = fork(process.argv[1], ["cluster"], { silent: true });
-
-  // Handle messages from the cluster
-  primary.on(
-    "message",
-    common.mustCall(data => {
-      // Add worker pid to list and progress tracker
-      if (data.cmd === "worker") {
-        workers.push(data.workerPID);
-      }
-    }, totalWorkers),
-  );
-
-  // When cluster is dead
-  primary.on(
-    "exit",
-    common.mustCall(code => {
-      // Check that the cluster died accidentally (non-zero exit code)
-      assert.strictEqual(code, 1);
-
-      // XXX(addaleax): The fact that this uses raw PIDs makes the test inherently
-      // flaky – another process might end up being started right after the
-      // workers finished and receive the same PID.
-      const pollWorkers = () => {
-        // When primary is dead all workers should be dead too
-        if (workers.some(pid => common.isAlive(pid))) {
-          setTimeout(pollWorkers, 50);
-        }
-      };
-
-      // Loop indefinitely until worker exit
-      pollWorkers();
-    }),
-  );
-}
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-primary-kill.js b/test/js/node/cluster/upstream/parallel/test-cluster-primary-kill.js
deleted file mode 100644
index 1a3a26f34d..0000000000
--- a/test/js/node/cluster/upstream/parallel/test-cluster-primary-kill.js
+++ /dev/null
@@ -1,85 +0,0 @@
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const common = require("../common");
-const assert = require("assert");
-const cluster = require("cluster");
-
-if (cluster.isWorker) {
-  // Keep the worker alive
-  const http = require("http");
-  http.Server().listen(0, "127.0.0.1");
-} else if (process.argv[2] === "cluster") {
-  const worker = cluster.fork();
-
-  // send PID info to testcase process
-  process.send({
-    pid: worker.process.pid,
-  });
-
-  // Terminate the cluster process
-  worker.once(
-    "listening",
-    common.mustCall(() => {
-      setTimeout(() => {
-        process.exit(0);
-      }, 1000);
-    }),
-  );
-} else {
-  // This is the testcase
-  const fork = require("child_process").fork;
-
-  // Spawn a cluster process
-  const primary = fork(process.argv[1], ["cluster"]);
-
-  // get pid info
-  let pid = null;
-  primary.once("message", data => {
-    pid = data.pid;
-  });
-
-  // When primary is dead
-  let alive = true;
-  primary.on(
-    "exit",
-    common.mustCall(code => {
-      // Make sure that the primary died on purpose
-      assert.strictEqual(code, 0);
-
-      // Check worker process status
-      const pollWorker = () => {
-        alive = common.isAlive(pid);
-        if (alive) {
-          setTimeout(pollWorker, 50);
-        }
-      };
-      // Loop indefinitely until worker exit.
-      pollWorker();
-    }),
-  );
-
-  process.once("exit", () => {
-    assert.strictEqual(typeof pid, "number", `got ${pid} instead of a worker pid`);
-    assert.strictEqual(alive, false, `worker was alive after primary died (alive = ${alive})`);
-  });
-}
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-process-disconnect.js b/test/js/node/cluster/upstream/parallel/test-cluster-process-disconnect.js
deleted file mode 100644
index bcaf7df146..0000000000
--- a/test/js/node/cluster/upstream/parallel/test-cluster-process-disconnect.js
+++ /dev/null
@@ -1,24 +0,0 @@
-"use strict";
-const common = require("../common");
-const assert = require("assert");
-const cluster = require("cluster");
-
-if (cluster.isPrimary) {
-  const worker = cluster.fork();
-  worker.on(
-    "exit",
-    common.mustCall((code, signal) => {
-      assert.strictEqual(code, 0, `Worker did not exit normally with code: ${code}`);
-      assert.strictEqual(signal, null, `Worker did not exit normally with signal: ${signal}`);
-    }),
-  );
-} else {
-  const net = require("net");
-  const server = net.createServer();
-  server.listen(
-    0,
-    common.mustCall(() => {
-      process.disconnect();
-    }),
-  );
-}
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-rr-handle-keep-loop-alive.js b/test/js/node/cluster/upstream/parallel/test-cluster-rr-handle-keep-loop-alive.js
deleted file mode 100644
index 8bb183af33..0000000000
--- a/test/js/node/cluster/upstream/parallel/test-cluster-rr-handle-keep-loop-alive.js
+++ /dev/null
@@ -1,26 +0,0 @@
-"use strict";
-
-const common = require("../common");
-const cluster = require("cluster");
-const net = require("net");
-const assert = require("assert");
-
-cluster.schedulingPolicy = cluster.SCHED_RR;
-
-if (cluster.isPrimary) {
-  let exited = false;
-  const worker = cluster.fork();
-  worker.on("exit", () => {
-    exited = true;
-  });
-  setTimeout(() => {
-    assert.ok(!exited);
-    worker.kill();
-  }, 3000);
-} else {
-  const server = net.createServer(common.mustNotCall());
-  server.listen(
-    0,
-    common.mustCall(() => process.channel.unref()),
-  );
-}
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-rr-ref.js b/test/js/node/cluster/upstream/parallel/test-cluster-rr-ref.js
deleted file mode 100644
index d5f0cbd083..0000000000
--- a/test/js/node/cluster/upstream/parallel/test-cluster-rr-ref.js
+++ /dev/null
@@ -1,20 +0,0 @@
-"use strict";
-
-const common = require("../common");
-const cluster = require("cluster");
-const net = require("net");
-
-if (cluster.isPrimary) {
-  cluster.fork().on("message", function (msg) {
-    if (msg === "done") this.kill();
-  });
-} else {
-  const server = net.createServer(common.mustNotCall());
-  server.listen(0, function () {
-    server.unref();
-    server.ref();
-    server.close(function () {
-      process.send("done");
-    });
-  });
-}
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-send-deadlock.js b/test/js/node/cluster/upstream/parallel/test-cluster-send-deadlock.js
deleted file mode 100644
index c5838a666c..0000000000
--- a/test/js/node/cluster/upstream/parallel/test-cluster-send-deadlock.js
+++ /dev/null
@@ -1,78 +0,0 @@
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-// Testing mutual send of handles: from primary to worker, and from worker to
-// primary.
-
-require("../common");
-const assert = require("assert");
-const cluster = require("cluster");
-const net = require("net");
-
-if (cluster.isPrimary) {
-  const worker = cluster.fork();
-  worker.on("exit", (code, signal) => {
-    assert.strictEqual(code, 0, `Worker exited with an error code: ${code}`);
-    assert(!signal, `Worker exited by a signal: ${signal}`);
-    server.close();
-  });
-
-  const server = net.createServer(socket => {
-    worker.send("handle", socket);
-  });
-
-  server.listen(0, () => {
-    worker.send({ message: "listen", port: server.address().port });
-  });
-} else {
-  process.on("message", (msg, handle) => {
-    if (msg.message && msg.message === "listen") {
-      assert(msg.port);
-      const client1 = net.connect(
-        {
-          host: "localhost",
-          port: msg.port,
-        },
-        () => {
-          const client2 = net.connect(
-            {
-              host: "localhost",
-              port: msg.port,
-            },
-            () => {
-              client1.on("close", onclose);
-              client2.on("close", onclose);
-              client1.end();
-              client2.end();
-            },
-          );
-        },
-      );
-      let waiting = 2;
-      const onclose = () => {
-        if (--waiting === 0) cluster.worker.disconnect();
-      };
-    } else {
-      process.send("reply", handle);
-    }
-  });
-}
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-setup-primary-argv.js b/test/js/node/cluster/upstream/parallel/test-cluster-setup-primary-argv.js
deleted file mode 100644
index 8908aa7372..0000000000
--- a/test/js/node/cluster/upstream/parallel/test-cluster-setup-primary-argv.js
+++ /dev/null
@@ -1,41 +0,0 @@
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const common = require("../common");
-const assert = require("assert");
-const cluster = require("cluster");
-
-setTimeout(common.mustNotCall("setup not emitted"), 1000).unref();
-
-cluster.on(
-  "setup",
-  common.mustCall(function () {
-    const clusterArgs = cluster.settings.args;
-    const realArgs = process.argv;
-    assert.strictEqual(clusterArgs[clusterArgs.length - 1], realArgs[realArgs.length - 1]);
-  }),
-);
-
-assert.notStrictEqual(process.argv[process.argv.length - 1], "OMG,OMG");
-process.argv.push("OMG,OMG");
-process.argv.push("OMG,OMG");
-cluster.setupPrimary();
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-setup-primary-cumulative.js b/test/js/node/cluster/upstream/parallel/test-cluster-setup-primary-cumulative.js
deleted file mode 100644
index f9b43121fb..0000000000
--- a/test/js/node/cluster/upstream/parallel/test-cluster-setup-primary-cumulative.js
+++ /dev/null
@@ -1,62 +0,0 @@
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-require("../common");
-const assert = require("assert");
-const cluster = require("cluster");
-
-assert(cluster.isPrimary);
-
-// cluster.settings should not be initialized until needed
-assert.deepStrictEqual(cluster.settings, {});
-
-cluster.setupPrimary();
-assert.deepStrictEqual(cluster.settings, {
-  args: process.argv.slice(2),
-  exec: process.argv[1],
-  execArgv: process.execArgv,
-  silent: false,
-});
-console.log("ok sets defaults");
-
-cluster.setupPrimary({ exec: "overridden" });
-assert.strictEqual(cluster.settings.exec, "overridden");
-console.log("ok overrides defaults");
-
-cluster.setupPrimary({ args: ["foo", "bar"] });
-assert.strictEqual(cluster.settings.exec, "overridden");
-assert.deepStrictEqual(cluster.settings.args, ["foo", "bar"]);
-
-cluster.setupPrimary({ execArgv: ["baz", "bang"] });
-assert.strictEqual(cluster.settings.exec, "overridden");
-assert.deepStrictEqual(cluster.settings.args, ["foo", "bar"]);
-assert.deepStrictEqual(cluster.settings.execArgv, ["baz", "bang"]);
-console.log("ok preserves unchanged settings on repeated calls");
-
-cluster.setupPrimary();
-assert.deepStrictEqual(cluster.settings, {
-  args: ["foo", "bar"],
-  exec: "overridden",
-  execArgv: ["baz", "bang"],
-  silent: false,
-});
-console.log("ok preserves current settings");
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-setup-primary-emit.js b/test/js/node/cluster/upstream/parallel/test-cluster-setup-primary-emit.js
deleted file mode 100644
index 305ebfced2..0000000000
--- a/test/js/node/cluster/upstream/parallel/test-cluster-setup-primary-emit.js
+++ /dev/null
@@ -1,55 +0,0 @@
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const common = require("../common");
-const assert = require("assert");
-const cluster = require("cluster");
-
-assert(cluster.isPrimary);
-
-function emitAndCatch(next) {
-  cluster.once(
-    "setup",
-    common.mustCall(function (settings) {
-      assert.strictEqual(settings.exec, "new-exec");
-      setImmediate(next);
-    }),
-  );
-  cluster.setupPrimary({ exec: "new-exec" });
-}
-
-function emitAndCatch2(next) {
-  cluster.once(
-    "setup",
-    common.mustCall(function (settings) {
-      assert("exec" in settings);
-      setImmediate(next);
-    }),
-  );
-  cluster.setupPrimary();
-}
-
-emitAndCatch(
-  common.mustCall(function () {
-    emitAndCatch2(common.mustCall());
-  }),
-);
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-setup-primary.js b/test/js/node/cluster/upstream/parallel/test-cluster-setup-primary.js
deleted file mode 100644
index ccb103cf08..0000000000
--- a/test/js/node/cluster/upstream/parallel/test-cluster-setup-primary.js
+++ /dev/null
@@ -1,93 +0,0 @@
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const common = require("../common");
-const assert = require("assert");
-const cluster = require("cluster");
-
-if (cluster.isWorker) {
-  // Just keep the worker alive
-  process.send(process.argv[2]);
-} else if (cluster.isPrimary) {
-  const checks = {
-    args: false,
-    setupEvent: false,
-    settingsObject: false,
-  };
-
-  const totalWorkers = 2;
-  let settings;
-
-  // Setup primary
-  cluster.setupPrimary({
-    args: ["custom argument"],
-    silent: true,
-  });
-
-  cluster.once("setup", function () {
-    checks.setupEvent = true;
-
-    settings = cluster.settings;
-    if (
-      settings &&
-      settings.args &&
-      settings.args[0] === "custom argument" &&
-      settings.silent === true &&
-      settings.exec === process.argv[1]
-    ) {
-      checks.settingsObject = true;
-    }
-  });
-
-  let correctInput = 0;
-
-  cluster.on(
-    "online",
-    common.mustCall(function listener(worker) {
-      worker.once("message", function (data) {
-        correctInput += data === "custom argument" ? 1 : 0;
-        if (correctInput === totalWorkers) {
-          checks.args = true;
-        }
-        worker.kill();
-      });
-    }, totalWorkers),
-  );
-
-  // Start all workers
-  cluster.fork();
-  cluster.fork();
-
-  // Check all values
-  process.once("exit", function () {
-    const argsMsg =
-      "Arguments was not send for one or more worker. " +
-      `${correctInput} workers receive argument, ` +
-      `but ${totalWorkers} were expected.`;
-    assert.ok(checks.args, argsMsg);
-
-    assert.ok(checks.setupEvent, "The setup event was never emitted");
-
-    const settingObjectMsg = "The settingsObject do not have correct " + `properties : ${JSON.stringify(settings)}`;
-    assert.ok(checks.settingsObject, settingObjectMsg);
-  });
-}
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-shared-handle-bind-privileged-port.js b/test/js/node/cluster/upstream/parallel/test-cluster-shared-handle-bind-privileged-port.js
deleted file mode 100644
index e69c79d697..0000000000
--- a/test/js/node/cluster/upstream/parallel/test-cluster-shared-handle-bind-privileged-port.js
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const common = require("../common");
-if (common.isLinux) return; // TODO: bun
-
-// Skip on OS X Mojave. https://github.com/nodejs/node/issues/21679
-if (common.isOSX) common.skip("macOS may allow ordinary processes to use any port");
-
-if (common.isIBMi) common.skip("IBMi may allow ordinary processes to use any port");
-
-if (common.isWindows) common.skip("not reliable on Windows");
-
-if (process.getuid() === 0) common.skip("as this test should not be run as `root`");
-
-const assert = require("assert");
-const cluster = require("cluster");
-const net = require("net");
-
-if (cluster.isPrimary) {
-  // Primary opens and binds the socket and shares it with the worker.
-  cluster.schedulingPolicy = cluster.SCHED_NONE;
-  cluster.fork().on(
-    "exit",
-    common.mustCall(function (exitCode) {
-      assert.strictEqual(exitCode, 0);
-    }),
-  );
-} else {
-  const s = net.createServer(common.mustNotCall());
-  s.listen(42, common.mustNotCall("listen should have failed"));
-  s.on(
-    "error",
-    common.mustCall(function (err) {
-      assert.strictEqual(err.code, "EACCES");
-      process.disconnect();
-    }),
-  );
-}
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-uncaught-exception.js b/test/js/node/cluster/upstream/parallel/test-cluster-uncaught-exception.js
deleted file mode 100644
index ee1dee617e..0000000000
--- a/test/js/node/cluster/upstream/parallel/test-cluster-uncaught-exception.js
+++ /dev/null
@@ -1,56 +0,0 @@
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-// Installing a custom uncaughtException handler should override the default
-// one that the cluster module installs.
-// https://github.com/joyent/node/issues/2556
-
-const common = require("../common");
-const assert = require("assert");
-const cluster = require("cluster");
-const fork = require("child_process").fork;
-
-const MAGIC_EXIT_CODE = 42;
-
-const isTestRunner = process.argv[2] !== "child";
-
-if (isTestRunner) {
-  const primary = fork(__filename, ["child"]);
-  primary.on(
-    "exit",
-    common.mustCall(code => {
-      assert.strictEqual(code, MAGIC_EXIT_CODE);
-    }),
-  );
-} else if (cluster.isPrimary) {
-  process.on(
-    "uncaughtException",
-    common.mustCall(() => {
-      process.nextTick(() => process.exit(MAGIC_EXIT_CODE));
-    }),
-  );
-  cluster.fork();
-  throw new Error("kill primary");
-} else {
-  // worker
-  process.exit();
-}
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-worker-death.js b/test/js/node/cluster/upstream/parallel/test-cluster-worker-death.js
deleted file mode 100644
index bab5c8df8a..0000000000
--- a/test/js/node/cluster/upstream/parallel/test-cluster-worker-death.js
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const common = require("../common");
-const assert = require("assert");
-const cluster = require("cluster");
-
-if (!cluster.isPrimary) {
-  process.exit(42);
-} else {
-  const worker = cluster.fork();
-  worker.on(
-    "exit",
-    common.mustCall(function (exitCode, signalCode) {
-      assert.strictEqual(exitCode, 42);
-      assert.strictEqual(signalCode, null);
-    }),
-  );
-  cluster.on(
-    "exit",
-    common.mustCall(function (worker_) {
-      assert.strictEqual(worker_, worker);
-    }),
-  );
-}
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-worker-disconnect-on-error.js b/test/js/node/cluster/upstream/parallel/test-cluster-worker-disconnect-on-error.js
deleted file mode 100644
index f9e3a0de2c..0000000000
--- a/test/js/node/cluster/upstream/parallel/test-cluster-worker-disconnect-on-error.js
+++ /dev/null
@@ -1,44 +0,0 @@
-"use strict";
-const common = require("../common");
-const http = require("http");
-const cluster = require("cluster");
-const assert = require("assert");
-
-cluster.schedulingPolicy = cluster.SCHED_NONE;
-
-const server = http.createServer();
-if (cluster.isPrimary) {
-  let worker;
-
-  server.listen(
-    0,
-    common.mustSucceed(() => {
-      assert(worker);
-
-      worker.send({ port: server.address().port });
-    }),
-  );
-
-  worker = cluster.fork();
-  worker.on(
-    "exit",
-    common.mustCall(() => {
-      server.close();
-    }),
-  );
-} else {
-  process.on(
-    "message",
-    common.mustCall(msg => {
-      assert(msg.port);
-
-      server.listen(msg.port);
-      server.on(
-        "error",
-        common.mustCall(e => {
-          cluster.worker.disconnect();
-        }),
-      );
-    }),
-  );
-}
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-worker-disconnect.js b/test/js/node/cluster/upstream/parallel/test-cluster-worker-disconnect.js
deleted file mode 100644
index 35cae334d9..0000000000
--- a/test/js/node/cluster/upstream/parallel/test-cluster-worker-disconnect.js
+++ /dev/null
@@ -1,118 +0,0 @@
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const common = require("../common");
-const assert = require("assert");
-const cluster = require("cluster");
-
-if (cluster.isWorker) {
-  const http = require("http");
-  http.Server(() => {}).listen(0, "127.0.0.1");
-
-  cluster.worker.on(
-    "disconnect",
-    common.mustCall(() => {
-      process.exit(42);
-    }),
-  );
-} else if (cluster.isPrimary) {
-  const checks = {
-    cluster: {
-      emitDisconnect: false,
-      emitExit: false,
-      callback: false,
-    },
-    worker: {
-      emitDisconnect: false,
-      emitDisconnectInsideWorker: false,
-      emitExit: false,
-      state: false,
-      voluntaryMode: false,
-      died: false,
-    },
-  };
-
-  // start worker
-  const worker = cluster.fork();
-
-  // Disconnect worker when it is ready
-  worker.once(
-    "listening",
-    common.mustCall(() => {
-      const w = worker.disconnect();
-      assert.strictEqual(worker, w, `${worker.id} did not return a reference`);
-    }),
-  );
-
-  // Check cluster events
-  cluster.once(
-    "disconnect",
-    common.mustCall(() => {
-      checks.cluster.emitDisconnect = true;
-    }),
-  );
-  cluster.once(
-    "exit",
-    common.mustCall(() => {
-      checks.cluster.emitExit = true;
-    }),
-  );
-
-  // Check worker events and properties
-  worker.once(
-    "disconnect",
-    common.mustCall(() => {
-      checks.worker.emitDisconnect = true;
-      checks.worker.voluntaryMode = worker.exitedAfterDisconnect;
-      checks.worker.state = worker.state;
-    }),
-  );
-
-  // Check that the worker died
-  worker.once(
-    "exit",
-    common.mustCall(code => {
-      checks.worker.emitExit = true;
-      checks.worker.died = !common.isAlive(worker.process.pid);
-      checks.worker.emitDisconnectInsideWorker = code === 42;
-    }),
-  );
-
-  process.once("exit", () => {
-    const w = checks.worker;
-    const c = checks.cluster;
-
-    // events
-    assert.ok(w.emitDisconnect, "Disconnect event did not emit");
-    assert.ok(w.emitDisconnectInsideWorker, "Disconnect event did not emit inside worker");
-    assert.ok(c.emitDisconnect, "Disconnect event did not emit");
-    assert.ok(w.emitExit, "Exit event did not emit");
-    assert.ok(c.emitExit, "Exit event did not emit");
-
-    // flags
-    assert.strictEqual(w.state, "disconnected");
-    assert.strictEqual(w.voluntaryMode, true);
-
-    // is process alive
-    assert.ok(w.died, "The worker did not die");
-  });
-}
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-worker-exit.js b/test/js/node/cluster/upstream/parallel/test-cluster-worker-exit.js
deleted file mode 100644
index e6e61ca604..0000000000
--- a/test/js/node/cluster/upstream/parallel/test-cluster-worker-exit.js
+++ /dev/null
@@ -1,142 +0,0 @@
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-// test-cluster-worker-exit.js
-// verifies that, when a child process exits (by calling `process.exit(code)`)
-// - the primary receives the proper events in the proper order, no duplicates
-// - the exitCode and signalCode are correct in the 'exit' event
-// - the worker.exitedAfterDisconnect flag, and worker.state are correct
-// - the worker process actually goes away
-
-const common = require("../common");
-const assert = require("assert");
-const cluster = require("cluster");
-
-const EXIT_CODE = 42;
-
-if (cluster.isWorker) {
-  const http = require("http");
-  const server = http.Server(() => {});
-
-  server.once(
-    "listening",
-    common.mustCall(() => {
-      process.exit(EXIT_CODE);
-    }),
-  );
-  server.listen(0, "127.0.0.1");
-} else if (cluster.isPrimary) {
-  const expected_results = {
-    cluster_emitDisconnect: [1, "the cluster did not emit 'disconnect'"],
-    cluster_emitExit: [1, "the cluster did not emit 'exit'"],
-    cluster_exitCode: [EXIT_CODE, "the cluster exited w/ incorrect exitCode"],
-    cluster_signalCode: [null, "the cluster exited w/ incorrect signalCode"],
-    worker_emitDisconnect: [1, "the worker did not emit 'disconnect'"],
-    worker_emitExit: [1, "the worker did not emit 'exit'"],
-    worker_state: ["disconnected", "the worker state is incorrect"],
-    worker_exitedAfterDisconnect: [false, "the .exitedAfterDisconnect flag is incorrect"],
-    worker_died: [true, "the worker is still running"],
-    worker_exitCode: [EXIT_CODE, "the worker exited w/ incorrect exitCode"],
-    worker_signalCode: [null, "the worker exited w/ incorrect signalCode"],
-  };
-  const results = {
-    cluster_emitDisconnect: 0,
-    cluster_emitExit: 0,
-    worker_emitDisconnect: 0,
-    worker_emitExit: 0,
-  };
-
-  // start worker
-  const worker = cluster.fork();
-
-  // Check cluster events
-  cluster.on(
-    "disconnect",
-    common.mustCall(() => {
-      results.cluster_emitDisconnect += 1;
-    }),
-  );
-  cluster.on(
-    "exit",
-    common.mustCall(worker => {
-      results.cluster_exitCode = worker.process.exitCode;
-      results.cluster_signalCode = worker.process.signalCode;
-      results.cluster_emitExit += 1;
-    }),
-  );
-
-  // Check worker events and properties
-  worker.on(
-    "disconnect",
-    common.mustCall(() => {
-      results.worker_emitDisconnect += 1;
-      results.worker_exitedAfterDisconnect = worker.exitedAfterDisconnect;
-      results.worker_state = worker.state;
-      if (results.worker_emitExit > 0) {
-        process.nextTick(() => finish_test());
-      }
-    }),
-  );
-
-  // Check that the worker died
-  worker.once(
-    "exit",
-    common.mustCall((exitCode, signalCode) => {
-      results.worker_exitCode = exitCode;
-      results.worker_signalCode = signalCode;
-      results.worker_emitExit += 1;
-      results.worker_died = !common.isAlive(worker.process.pid);
-      if (results.worker_emitDisconnect > 0) {
-        process.nextTick(() => finish_test());
-      }
-    }),
-  );
-
-  const finish_test = () => {
-    try {
-      checkResults(expected_results, results);
-    } catch (exc) {
-      if (exc.name !== "AssertionError") {
-        console.trace(exc);
-      }
-
-      process.exit(1);
-      return;
-    }
-    process.exit(0);
-  };
-}
-
-// Some helper functions ...
-
-function checkResults(expected_results, results) {
-  for (const k in expected_results) {
-    const actual = results[k];
-    const expected = expected_results[k];
-
-    assert.strictEqual(
-      actual,
-      expected && expected.length ? expected[0] : expected,
-      `${expected[1] || ""} [expected: ${expected[0]} / actual: ${actual}]`,
-    );
-  }
-}
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-worker-isdead.js b/test/js/node/cluster/upstream/parallel/test-cluster-worker-isdead.js
deleted file mode 100644
index 079a154443..0000000000
--- a/test/js/node/cluster/upstream/parallel/test-cluster-worker-isdead.js
+++ /dev/null
@@ -1,34 +0,0 @@
-"use strict";
-require("../common");
-const cluster = require("cluster");
-const assert = require("assert");
-
-if (cluster.isPrimary) {
-  const worker = cluster.fork();
-  let workerDead = worker.isDead();
-  assert.ok(
-    !workerDead,
-    `isDead() returned ${workerDead}. isDead() should return ` + "false right after the worker has been created.",
-  );
-
-  worker.on("exit", function () {
-    workerDead = worker.isDead();
-    assert.ok(
-      workerDead,
-      `isDead() returned ${workerDead}. After an event has been ` + "emitted, isDead should return true",
-    );
-  });
-
-  worker.on("message", function (msg) {
-    if (msg === "readyToDie") {
-      worker.kill();
-    }
-  });
-} else if (cluster.isWorker) {
-  const workerDead = cluster.worker.isDead();
-  assert.ok(
-    !workerDead,
-    `isDead() returned ${workerDead}. isDead() should return ` + "false when called from within a worker",
-  );
-  process.send("readyToDie");
-}
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-worker-kill-signal.js b/test/js/node/cluster/upstream/parallel/test-cluster-worker-kill-signal.js
deleted file mode 100644
index 1562a5e9f3..0000000000
--- a/test/js/node/cluster/upstream/parallel/test-cluster-worker-kill-signal.js
+++ /dev/null
@@ -1,56 +0,0 @@
-"use strict";
-// test-cluster-worker-kill-signal.js
-// verifies that when we're killing a worker using Worker.prototype.kill
-// and the worker's process was killed with the given signal (SIGKILL)
-
-const common = require("../common");
-const assert = require("assert");
-const cluster = require("cluster");
-
-if (cluster.isWorker) {
-  // Make the worker run something
-  const http = require("http");
-  const server = http.Server(() => {});
-
-  server.once("listening", common.mustCall());
-  server.listen(0, "127.0.0.1");
-} else if (cluster.isMaster) {
-  const KILL_SIGNAL = "SIGKILL";
-
-  // Start worker
-  const worker = cluster.fork();
-
-  // When the worker is up and running, kill it
-  worker.once(
-    "listening",
-    common.mustCall(() => {
-      worker.kill(KILL_SIGNAL);
-    }),
-  );
-
-  // Check worker events and properties
-  worker.on(
-    "disconnect",
-    common.mustCall(() => {
-      assert.strictEqual(worker.exitedAfterDisconnect, false);
-      assert.strictEqual(worker.state, "disconnected");
-    }, 1),
-  );
-
-  // Check that the worker died
-  worker.once(
-    "exit",
-    common.mustCall((exitCode, signalCode) => {
-      const isWorkerProcessStillAlive = common.isAlive(worker.process.pid);
-      const numOfRunningWorkers = Object.keys(cluster.workers).length;
-
-      assert.strictEqual(exitCode, null);
-      assert.strictEqual(signalCode, KILL_SIGNAL);
-      assert.strictEqual(isWorkerProcessStillAlive, false);
-      assert.strictEqual(numOfRunningWorkers, 0);
-    }, 1),
-  );
-
-  // Check if the cluster was killed as well
-  cluster.on("exit", common.mustCall(1));
-}
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-worker-kill.js b/test/js/node/cluster/upstream/parallel/test-cluster-worker-kill.js
deleted file mode 100644
index 1ba588b874..0000000000
--- a/test/js/node/cluster/upstream/parallel/test-cluster-worker-kill.js
+++ /dev/null
@@ -1,126 +0,0 @@
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-// test-cluster-worker-kill.js
-// verifies that, when a child process is killed (we use SIGKILL)
-// - the primary receives the proper events in the proper order, no duplicates
-// - the exitCode and signalCode are correct in the 'exit' event
-// - the worker.exitedAfterDisconnect flag, and worker.state are correct
-// - the worker process actually goes away
-
-const common = require("../common");
-const assert = require("assert");
-const cluster = require("cluster");
-
-if (cluster.isWorker) {
-  const http = require("http");
-  const server = http.Server(() => {});
-  server.once("listening", common.mustCall());
-  server.listen(0, "127.0.0.1");
-} else if (cluster.isPrimary) {
-  const KILL_SIGNAL = "SIGKILL";
-  const expected_results = {
-    cluster_emitDisconnect: [1, "the cluster did not emit 'disconnect'"],
-    cluster_emitExit: [1, "the cluster did not emit 'exit'"],
-    cluster_exitCode: [null, "the cluster exited w/ incorrect exitCode"],
-    cluster_signalCode: [KILL_SIGNAL, "the cluster exited w/ incorrect signalCode"],
-    worker_emitDisconnect: [1, "the worker did not emit 'disconnect'"],
-    worker_emitExit: [1, "the worker did not emit 'exit'"],
-    worker_state: ["disconnected", "the worker state is incorrect"],
-    worker_exitedAfter: [false, "the .exitedAfterDisconnect flag is incorrect"],
-    worker_died: [true, "the worker is still running"],
-    worker_exitCode: [null, "the worker exited w/ incorrect exitCode"],
-    worker_signalCode: [KILL_SIGNAL, "the worker exited w/ incorrect signalCode"],
-  };
-  const results = {
-    cluster_emitDisconnect: 0,
-    cluster_emitExit: 0,
-    worker_emitDisconnect: 0,
-    worker_emitExit: 0,
-  };
-
-  // start worker
-  const worker = cluster.fork();
-  // When the worker is up and running, kill it
-  worker.once(
-    "listening",
-    common.mustCall(() => {
-      worker.process.kill(KILL_SIGNAL);
-    }),
-  );
-
-  // Check cluster events
-  cluster.on(
-    "disconnect",
-    common.mustCall(() => {
-      results.cluster_emitDisconnect += 1;
-    }),
-  );
-  cluster.on(
-    "exit",
-    common.mustCall(worker => {
-      results.cluster_exitCode = worker.process.exitCode;
-      results.cluster_signalCode = worker.process.signalCode;
-      results.cluster_emitExit += 1;
-    }),
-  );
-
-  // Check worker events and properties
-  worker.on(
-    "disconnect",
-    common.mustCall(() => {
-      results.worker_emitDisconnect += 1;
-      results.worker_exitedAfter = worker.exitedAfterDisconnect;
-      results.worker_state = worker.state;
-    }),
-  );
-
-  // Check that the worker died
-  worker.once(
-    "exit",
-    common.mustCall((exitCode, signalCode) => {
-      results.worker_exitCode = exitCode;
-      results.worker_signalCode = signalCode;
-      results.worker_emitExit += 1;
-      results.worker_died = !common.isAlive(worker.process.pid);
-    }),
-  );
-
-  process.on("exit", () => {
-    checkResults(expected_results, results);
-  });
-}
-
-// Some helper functions ...
-
-function checkResults(expected_results, results) {
-  for (const k in expected_results) {
-    const actual = results[k];
-    const expected = expected_results[k];
-
-    assert.strictEqual(
-      actual,
-      expected && expected.length ? expected[0] : expected,
-      `${expected[1] || ""} [expected: ${expected[0]} / actual: ${actual}]`,
-    );
-  }
-}
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-worker-no-exit.js b/test/js/node/cluster/upstream/parallel/test-cluster-worker-no-exit.js
deleted file mode 100644
index 8dcfc45f2c..0000000000
--- a/test/js/node/cluster/upstream/parallel/test-cluster-worker-no-exit.js
+++ /dev/null
@@ -1,79 +0,0 @@
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const common = require("../common");
-if (common.isOSX) return; // TODO: bun
-if (common.isLinux) return; // TODO: bun
-if (common.isWindows) return; // TODO: bun
-const assert = require("assert");
-const cluster = require("cluster");
-const net = require("net");
-
-let destroyed;
-let success;
-let worker;
-let server;
-
-// Workers do not exit on disconnect, they exit under normal node rules: when
-// they have nothing keeping their loop alive, like an active connection
-//
-// test this by:
-//
-// 1 creating a server, so worker can make a connection to something
-// 2 disconnecting worker
-// 3 wait to confirm it did not exit
-// 4 destroy connection
-// 5 confirm it does exit
-if (cluster.isPrimary) {
-  server = net
-    .createServer(function (conn) {
-      server.close();
-      worker.disconnect();
-      worker
-        .once("disconnect", function () {
-          setTimeout(function () {
-            conn.destroy();
-            destroyed = true;
-          }, 1000);
-        })
-        .once("exit", function () {
-          // Worker should not exit while it has a connection
-          assert(destroyed, "worker exited before connection destroyed");
-          success = true;
-        });
-    })
-    .listen(0, function () {
-      const port = this.address().port;
-
-      worker = cluster.fork().on("online", function () {
-        this.send({ port });
-      });
-    });
-  process.on("exit", function () {
-    assert(success);
-  });
-} else {
-  process.on("message", function (msg) {
-    // We shouldn't exit, not while a network connection exists
-    net.connect(msg.port);
-  });
-}
diff --git a/test/js/node/crypto/crypto-oneshot.test.ts b/test/js/node/crypto/crypto-oneshot.test.ts
new file mode 100644
index 0000000000..45dde8827c
--- /dev/null
+++ b/test/js/node/crypto/crypto-oneshot.test.ts
@@ -0,0 +1,87 @@
+import { expect, test, describe } from "bun:test";
+import crypto from "crypto";
+import { readFileSync } from "fs";
+import { path } from "../test/common/fixtures";
+
+describe("crypto.hash", () => {
+  test("throws for invalid arguments", () => {
+    ([undefined, null, true, 1, () => {}, {}] as const).forEach(invalid => {
+      expect(() => crypto.hash(invalid, "test")).toThrow(
+        expect.objectContaining({
+          code: "ERR_INVALID_ARG_TYPE",
+        }),
+      );
+    });
+
+    [undefined, null, true, 1, () => {}, {}].forEach(invalid => {
+      expect(() => crypto.hash("sha1", invalid)).toThrow(
+        expect.objectContaining({
+          code: "ERR_INVALID_ARG_TYPE",
+        }),
+      );
+    });
+
+    [null, true, 1, () => {}, {}].forEach(invalid => {
+      expect(() => crypto.hash("sha1", "test", invalid)).toThrow(
+        expect.objectContaining({
+          code: "ERR_INVALID_ARG_TYPE",
+        }),
+      );
+    });
+
+    expect(() => crypto.hash("sha1", "test", "not an encoding")).toThrow(
+      expect.objectContaining({
+        code: "ERR_INVALID_ARG_VALUE",
+      }),
+    );
+  });
+  const input = readFileSync(path("utf8_test_text.txt"));
+  [
+    "blake2b256",
+    "blake2b512",
+    "ripemd160",
+    "rmd160",
+    "md4",
+    "md5",
+    "sha1",
+    "sha128",
+    "sha224",
+    "sha256",
+    "sha384",
+    "sha512",
+    "sha-1",
+    "sha-224",
+    "sha-256",
+    "sha-384",
+    "sha-512",
+    "sha-512/224",
+    "sha-512_224",
+    "sha-512224",
+    "sha512-224",
+    "sha-512/256",
+    "sha-512_256",
+    "sha-512256",
+    "sha512-256",
+    "sha384",
+    "sha3-224",
+    "sha3-256",
+    "sha3-384",
+    "sha3-512",
+    "shake128",
+    "shake256",
+  ].forEach(method => {
+    test(`output matches crypto.createHash(${method})`, () => {
+      for (const outputEncoding of ["buffer", "hex", "base64", undefined]) {
+        const oldDigest = crypto
+          .createHash(method)
+          .update(input)
+          .digest(outputEncoding || "hex");
+        const digestFromBuffer = crypto.hash(method, input, outputEncoding);
+        expect(digestFromBuffer).toEqual(oldDigest);
+
+        const digestFromString = crypto.hash(method, input.toString(), outputEncoding);
+        expect(digestFromString).toEqual(oldDigest);
+      }
+    });
+  });
+});
diff --git a/test/js/node/crypto/node-crypto.test.js b/test/js/node/crypto/node-crypto.test.js
index ba7386a333..f8cb1fb62f 100644
--- a/test/js/node/crypto/node-crypto.test.js
+++ b/test/js/node/crypto/node-crypto.test.js
@@ -1,7 +1,7 @@
 import { describe, expect, it } from "bun:test";
 
 import crypto from "node:crypto";
-import { PassThrough } from "node:stream";
+import { PassThrough, Readable } from "node:stream";
 import util from "node:util";
 
 it("crypto.randomBytes should return a Buffer", () => {
@@ -478,6 +478,27 @@ describe("createHash", () => {
     copy.update("world");
     expect(copy.digest("hex")).toBe(hash.digest("hex"));
   });
+
+  it("uses the Transform options object", () => {
+    const hasher = crypto.createHash("sha256", { defaultEncoding: "binary" });
+    hasher.on("readable", () => {
+      const data = hasher.read();
+      if (data) {
+        expect(data.toString("hex")).toBe("4d4d75d742863ab9656f3d5f76dff8589c3922e95a24ea6812157ffe4aaa3b6b");
+      }
+    });
+    const stream = Readable.from("ï");
+    stream.pipe(hasher);
+  });
+});
+
+describe("Hash", () => {
+  it("should have correct method names", () => {
+    const hash = crypto.createHash("sha256");
+    expect(hash.update.name).toBe("update");
+    expect(hash.digest.name).toBe("digest");
+    expect(hash.copy.name).toBe("copy");
+  });
 });
 
 it("crypto.createHmac", () => {
diff --git a/test/js/node/crypto/pbkdf2.test.ts b/test/js/node/crypto/pbkdf2.test.ts
index 9c4971a2c6..5d06fb1db7 100644
--- a/test/js/node/crypto/pbkdf2.test.ts
+++ b/test/js/node/crypto/pbkdf2.test.ts
@@ -69,13 +69,18 @@ testPBKDF2("password", "salt", 32, 32, "64c486c55d30d4c5a079b8823b7d7cb37ff0556f
 testPBKDF2("", "", 1, 32, "f7ce0b653d2d72a4108cf5abe912ffdd777616dbbb27a70e8204f3ae2d0f6fad", "hex");
 
 describe("invalid inputs", () => {
-  for (let input of ["test", {}, [], true, undefined, null]) {
+  for (let input of ["test", [], true, undefined, null]) {
     test(`${input} is invalid`, () => {
       expect(() => crypto.pbkdf2("pass", "salt", input, 8, "sha256")).toThrow(
-        `The "iteration count" argument must be of type integer. Received "${typeof input}"`,
+        `The "iteration count" argument must be of type integer. Received ${input}`,
       );
     });
   }
+  test(`{} is invalid`, () => {
+    expect(() => crypto.pbkdf2("pass", "salt", {}, 8, "sha256")).toThrow(
+      `The "iteration count" argument must be of type integer. Received {}`,
+    );
+  });
 
   test("invalid length", () => {
     expect(() => crypto.pbkdf2("password", "salt", 1, -1, "sha256")).toThrow();
@@ -115,7 +120,7 @@ describe("invalid inputs", () => {
 [Infinity, -Infinity, NaN].forEach(input => {
   test(`${input} keylen`, () => {
     expect(() => crypto.pbkdf2("password", "salt", 1, input, "sha256")).toThrow(
-      `The \"keylen\" argument must be of type integer. Received "number"`,
+      `The \"keylen\" argument must be of type integer. Received ${input}`,
     );
   });
 });
diff --git a/test/js/node/diagnostics_channel/diagnostics_channel.test.ts b/test/js/node/diagnostics_channel/diagnostics_channel.test.ts
index dd91d1225c..37dfd54d7a 100644
--- a/test/js/node/diagnostics_channel/diagnostics_channel.test.ts
+++ b/test/js/node/diagnostics_channel/diagnostics_channel.test.ts
@@ -40,7 +40,7 @@ describe("Channel", () => {
     expect(() => {
       // @ts-expect-error
       channel(null);
-    }).toThrow(/channel argument must be of type/);
+    }).toThrow(/"channel" argument must be of type string or symbol/);
 
     checkCalls();
   });
@@ -99,7 +99,7 @@ describe("Channel", () => {
     expect(() => {
       // @ts-expect-error
       subscribe(name, null);
-    }).toThrow(/subscription argument must be of type/);
+    }).toThrow(/"subscription" argument must be of type/);
 
     // Reaching zero subscribers should not delete from the channels map as there
     // will be no more weakref to incRef if another subscribe happens while the
@@ -154,7 +154,7 @@ describe("Channel", () => {
     expect(() => {
       // @ts-expect-error
       subscribe(null);
-    }).toThrow(/channel argument must be of type/);
+    }).toThrow(/"channel" argument must be of type/);
 
     checkCalls();
   });
diff --git a/test/js/node/dns/node-dns.test.js b/test/js/node/dns/node-dns.test.js
index 3e41e618b1..ecab13bd3f 100644
--- a/test/js/node/dns/node-dns.test.js
+++ b/test/js/node/dns/node-dns.test.js
@@ -1,4 +1,5 @@
 import { beforeAll, describe, expect, it, setDefaultTimeout, test } from "bun:test";
+import { isWindows } from "harness";
 import * as dns from "node:dns";
 import * as dns_promises from "node:dns/promises";
 import * as fs from "node:fs";
@@ -9,8 +10,6 @@ beforeAll(() => {
   setDefaultTimeout(1000 * 60 * 5);
 });
 
-const isWindows = process.platform === "win32";
-
 // TODO:
 test("it exists", () => {
   expect(dns).toBeDefined();
diff --git a/test/js/node/events/event-emitter.test.ts b/test/js/node/events/event-emitter.test.ts
index a878889a20..e1a63ead6d 100644
--- a/test/js/node/events/event-emitter.test.ts
+++ b/test/js/node/events/event-emitter.test.ts
@@ -878,3 +878,7 @@ test("getEventListeners", () => {
   target.dispatchEvent(new Event("hey"));
   expect(getEventListeners(target, "hey").length).toBe(0);
 });
+
+test("EventEmitter.name", () => {
+  expect(EventEmitter.name).toBe("EventEmitter");
+});
diff --git a/test/js/node/fs/fs-oom.test.ts b/test/js/node/fs/fs-oom.test.ts
index c45728be52..a859dc6a89 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);
+  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);
+      setSyntheticAllocationLimitForTesting(2 * 1024 * 1024);
 
-    try {
-      expect(() => readFileSync(memfd)).toThrow("Out of memory");
-      Bun.gc(true);
-      expect(() => readFileSync(memfd, "utf8")).toThrow("Out of memory");
-      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);
-    }
+      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 2b64c59115..5f01425eee 100644
--- a/test/js/node/fs/fs.test.ts
+++ b/test/js/node/fs/fs.test.ts
@@ -62,6 +62,19 @@ function mkdirForce(path: string) {
   if (!existsSync(path)) mkdirSync(path, { recursive: true });
 }
 
+function tmpdirTestMkdir(): string {
+  const now = Date.now().toString();
+  const tempdir = `${tmpdir()}/fs.test.ts/${now}/1234/hi`;
+  expect(existsSync(tempdir)).toBe(false);
+  const res = mkdirSync(tempdir, { recursive: true });
+  if (!res?.includes(now)) {
+    expect(res).toInclude("fs.test.ts");
+  }
+  expect(res).not.toInclude("1234");
+  expect(existsSync(tempdir)).toBe(true);
+  return tempdir;
+}
+
 it("fs.writeFile(1, data) should work when its inherited", async () => {
   expect([join(import.meta.dir, "fs-writeFile-1-fixture.js"), "1"]).toRun();
 });
@@ -83,6 +96,117 @@ it("writing to 1, 2 are possible", () => {
   expect(fs.writeSync(2, Buffer.from("\nhello-stderr-test\n"))).toBe(19);
 });
 
+describe("test-fs-assert-encoding-error", () => {
+  const testPath = join(tmpdirSync(), "assert-encoding-error");
+  const options = "test";
+  const expectedError = expect.objectContaining({
+    code: "ERR_INVALID_ARG_VALUE",
+    name: "TypeError",
+  });
+
+  it("readFile throws on invalid encoding", () => {
+    expect(() => {
+      fs.readFile(testPath, options, () => {});
+    }).toThrow(expectedError);
+  });
+
+  it("readFileSync throws on invalid encoding", () => {
+    expect(() => {
+      fs.readFileSync(testPath, options);
+    }).toThrow(expectedError);
+  });
+
+  it("readdir throws on invalid encoding", () => {
+    expect(() => {
+      fs.readdir(testPath, options, () => {});
+    }).toThrow(expectedError);
+  });
+
+  it("readdirSync throws on invalid encoding", () => {
+    expect(() => {
+      fs.readdirSync(testPath, options);
+    }).toThrow(expectedError);
+  });
+
+  it("readlink throws on invalid encoding", () => {
+    expect(() => {
+      fs.readlink(testPath, options, () => {});
+    }).toThrow(expectedError);
+  });
+
+  it("readlinkSync throws on invalid encoding", () => {
+    expect(() => {
+      fs.readlinkSync(testPath, options);
+    }).toThrow(expectedError);
+  });
+
+  it("writeFile throws on invalid encoding", () => {
+    expect(() => {
+      fs.writeFile(testPath, "data", options, () => {});
+    }).toThrow(expectedError);
+  });
+
+  it("writeFileSync throws on invalid encoding", () => {
+    expect(() => {
+      fs.writeFileSync(testPath, "data", options);
+    }).toThrow(expectedError);
+  });
+
+  it("appendFile throws on invalid encoding", () => {
+    expect(() => {
+      fs.appendFile(testPath, "data", options, () => {});
+    }).toThrow(expectedError);
+  });
+
+  it("appendFileSync throws on invalid encoding", () => {
+    expect(() => {
+      fs.appendFileSync(testPath, "data", options);
+    }).toThrow(expectedError);
+  });
+
+  it("watch throws on invalid encoding", () => {
+    expect(() => {
+      fs.watch(testPath, options, () => {});
+    }).toThrow(expectedError);
+  });
+
+  it("realpath throws on invalid encoding", () => {
+    expect(() => {
+      fs.realpath(testPath, options, () => {});
+    }).toThrow(expectedError);
+  });
+
+  it("realpathSync throws on invalid encoding", () => {
+    expect(() => {
+      fs.realpathSync(testPath, options);
+    }).toThrow(expectedError);
+  });
+
+  it("mkdtemp throws on invalid encoding", () => {
+    expect(() => {
+      fs.mkdtemp(testPath, options, () => {});
+    }).toThrow(expectedError);
+  });
+
+  it("mkdtempSync throws on invalid encoding", () => {
+    expect(() => {
+      fs.mkdtempSync(testPath, options);
+    }).toThrow(expectedError);
+  });
+
+  it.todo("ReadStream throws on invalid encoding", () => {
+    expect(() => {
+      fs.ReadStream(testPath, options);
+    }).toThrow(expectedError);
+  });
+
+  it.todo("WriteStream throws on invalid encoding", () => {
+    expect(() => {
+      fs.WriteStream(testPath, options);
+    }).toThrow(expectedError);
+  });
+});
+
 // TODO: port node.js tests for these
 it("fs.readv returns object", async done => {
   const fd = await promisify(fs.open)(import.meta.path, "r");
@@ -315,9 +439,7 @@ it("writeFileSync NOT in append SHOULD truncate the file", () => {
 
 describe("copyFileSync", () => {
   it("should work for files < 128 KB", () => {
-    const tempdir = `${tmpdir()}/fs.test.js/${Date.now()}/1234/hi`;
-    expect(existsSync(tempdir)).toBe(false);
-    expect(tempdir.includes(mkdirSync(tempdir, { recursive: true })!)).toBe(true);
+    const tempdir = tmpdirTestMkdir();
 
     // that don't exist
     copyFileSync(import.meta.path, tempdir + "/copyFileSync.js");
@@ -333,9 +455,7 @@ describe("copyFileSync", () => {
   });
 
   it("should work for files > 128 KB ", () => {
-    const tempdir = `${tmpdir()}/fs.test.js/${Date.now()}-1/1234/hi`;
-    expect(existsSync(tempdir)).toBe(false);
-    expect(tempdir.includes(mkdirSync(tempdir, { recursive: true })!)).toBe(true);
+    const tempdir = tmpdirTestMkdir();
     var buffer = new Int32Array(128 * 1024);
     for (let i = 0; i < buffer.length; i++) {
       buffer[i] = i % 256;
@@ -362,9 +482,7 @@ describe("copyFileSync", () => {
   });
 
   it("FICLONE option does not error ever", () => {
-    const tempdir = `${tmpdir()}/fs.test.js/${Date.now()}.FICLONE/1234/hi`;
-    expect(existsSync(tempdir)).toBe(false);
-    expect(tempdir.includes(mkdirSync(tempdir, { recursive: true })!)).toBe(true);
+    const tempdir = tmpdirTestMkdir();
 
     // that don't exist
     copyFileSync(import.meta.path, tempdir + "/copyFileSync.js", fs.constants.COPYFILE_FICLONE);
@@ -373,9 +491,7 @@ describe("copyFileSync", () => {
   });
 
   it("COPYFILE_EXCL works", () => {
-    const tempdir = `${tmpdir()}/fs.test.js/${Date.now()}.COPYFILE_EXCL/1234/hi`;
-    expect(existsSync(tempdir)).toBe(false);
-    expect(tempdir.includes(mkdirSync(tempdir, { recursive: true })!)).toBe(true);
+    const tempdir = tmpdirTestMkdir();
 
     // that don't exist
     copyFileSync(import.meta.path, tempdir + "/copyFileSync.js", fs.constants.COPYFILE_EXCL);
@@ -387,9 +503,7 @@ describe("copyFileSync", () => {
   if (process.platform === "linux") {
     describe("should work when copyFileRange is not available", () => {
       it("on large files", () => {
-        const tempdir = `${tmpdir()}/fs.test.js/${Date.now()}-1/1234/large`;
-        expect(existsSync(tempdir)).toBe(false);
-        expect(tempdir.includes(mkdirSync(tempdir, { recursive: true })!)).toBe(true);
+        const tempdir = tmpdirTestMkdir();
         var buffer = new Int32Array(128 * 1024);
         for (let i = 0; i < buffer.length; i++) {
           buffer[i] = i % 256;
@@ -421,9 +535,7 @@ describe("copyFileSync", () => {
       });
 
       it("on small files", () => {
-        const tempdir = `${tmpdir()}/fs.test.js/${Date.now()}-1/1234/small`;
-        expect(existsSync(tempdir)).toBe(false);
-        expect(tempdir.includes(mkdirSync(tempdir, { recursive: true })!)).toBe(true);
+        const tempdir = tmpdirTestMkdir();
         var buffer = new Int32Array(1 * 1024);
         for (let i = 0; i < buffer.length; i++) {
           buffer[i] = i % 256;
@@ -460,12 +572,22 @@ describe("copyFileSync", () => {
 
 describe("mkdirSync", () => {
   it("should create a directory", () => {
-    const tempdir = `${tmpdir()}/fs.test.js/${Date.now()}.mkdirSync/1234/hi`;
+    const now = Date.now().toString();
+    const base = join(now, ".mkdirSync", "1234", "hi");
+    const tempdir = `${tmpdir()}/${base}`;
     expect(existsSync(tempdir)).toBe(false);
-    expect(tempdir.includes(mkdirSync(tempdir, { recursive: true })!)).toBe(true);
+
+    const res = mkdirSync(tempdir, { recursive: true });
+    expect(res).toInclude(now);
+    expect(res).not.toInclude(".mkdirSync");
     expect(existsSync(tempdir)).toBe(true);
   });
 
+  it("should throw ENOENT for empty string", () => {
+    expect(() => mkdirSync("", { recursive: true })).toThrow("No such file or directory");
+    expect(() => mkdirSync("")).toThrow("No such file or directory");
+  });
+
   it("throws for invalid options", () => {
     const path = `${tmpdir()}/${Date.now()}.rm.dir2/foo/bar`;
 
@@ -475,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');
   });
 });
 
@@ -1090,6 +1212,11 @@ describe("readSync", () => {
     }
     closeSync(fd);
   });
+
+  it("works with invalid fd but zero length", () => {
+    expect(readSync(2147483640, Buffer.alloc(0))).toBe(0);
+    expect(readSync(2147483640, Buffer.alloc(10), 0, 0, 0)).toBe(0);
+  });
 });
 
 it("writevSync", () => {
@@ -1279,6 +1406,36 @@ describe("readFile", () => {
       });
     });
   });
+
+  it("works with flags", async () => {
+    const mydir = tempDirWithFiles("fs-read", {});
+    console.log(mydir);
+
+    for (const [flag, code] of [
+      ["a", "EBADF"],
+      ["ax", "EBADF"],
+      ["a+", undefined],
+      ["as", "EBADF"],
+      ["as+", undefined],
+      ["r", "ENOENT"],
+      ["rs", "ENOENT"],
+      ["r+", "ENOENT"],
+      ["rs+", "ENOENT"],
+      ["w", "EBADF"],
+      ["wx", "EBADF"],
+      ["w+", undefined],
+      ["wx+", undefined],
+    ]) {
+      const name = flag!.replace("+", "_plus") + ".txt";
+      if (code == null) {
+        expect(readFileSync(mydir + "/" + name, { encoding: "utf8", flag })).toBe("");
+        expect(readFileSync(mydir + "/" + name, { encoding: "utf8" })).toBe("");
+      } else {
+        expect.toThrowWithCode(() => readFileSync(mydir + "/" + name, { encoding: "utf8", flag }), code);
+        expect.toThrowWithCode(() => readFileSync(mydir + "/" + name, { encoding: "utf8" }), "ENOENT");
+      }
+    }
+  });
 });
 
 describe("writeFileSync", () => {
@@ -2069,7 +2226,7 @@ describe("fs.ReadStream", () => {
 
 describe("createWriteStream", () => {
   it("simple write stream finishes", async () => {
-    const path = `${tmpdir()}/fs.test.js/${Date.now()}.createWriteStream.txt`;
+    const path = `${tmpdir()}/fs.test.ts/${Date.now()}.createWriteStream.txt`;
     const stream = createWriteStream(path);
     stream.write("Test file written successfully");
     stream.end();
@@ -2087,7 +2244,7 @@ describe("createWriteStream", () => {
   });
 
   it("writing null throws ERR_STREAM_NULL_VALUES", async () => {
-    const path = `${tmpdir()}/fs.test.js/${Date.now()}.createWriteStreamNulls.txt`;
+    const path = `${tmpdir()}/fs.test.ts/${Date.now()}.createWriteStreamNulls.txt`;
     const stream = createWriteStream(path);
     try {
       stream.write(null);
@@ -2098,7 +2255,7 @@ describe("createWriteStream", () => {
   });
 
   it("writing null throws ERR_STREAM_NULL_VALUES (objectMode: true)", async () => {
-    const path = `${tmpdir()}/fs.test.js/${Date.now()}.createWriteStreamNulls.txt`;
+    const path = `${tmpdir()}/fs.test.ts/${Date.now()}.createWriteStreamNulls.txt`;
     const stream = createWriteStream(path, {
       // @ts-ignore-next-line
       objectMode: true,
@@ -2112,7 +2269,7 @@ describe("createWriteStream", () => {
   });
 
   it("writing false throws ERR_INVALID_ARG_TYPE", async () => {
-    const path = `${tmpdir()}/fs.test.js/${Date.now()}.createWriteStreamFalse.txt`;
+    const path = `${tmpdir()}/fs.test.ts/${Date.now()}.createWriteStreamFalse.txt`;
     const stream = createWriteStream(path);
     try {
       stream.write(false);
@@ -2123,7 +2280,7 @@ describe("createWriteStream", () => {
   });
 
   it("writing false throws ERR_INVALID_ARG_TYPE (objectMode: true)", async () => {
-    const path = `${tmpdir()}/fs.test.js/${Date.now()}.createWriteStreamFalse.txt`;
+    const path = `${tmpdir()}/fs.test.ts/${Date.now()}.createWriteStreamFalse.txt`;
     const stream = createWriteStream(path, {
       // @ts-ignore-next-line
       objectMode: true,
@@ -2137,7 +2294,7 @@ describe("createWriteStream", () => {
   });
 
   it("writing in append mode should not truncate the file", async () => {
-    const path = `${tmpdir()}/fs.test.js/${Date.now()}.createWriteStreamAppend.txt`;
+    const path = `${tmpdir()}/fs.test.ts/${Date.now()}.createWriteStreamAppend.txt`;
     const stream = createWriteStream(path, {
       // @ts-ignore-next-line
       flags: "a",
@@ -2228,7 +2385,7 @@ describe("fs/promises", () => {
   });
 
   it("writeFile", async () => {
-    const path = `${tmpdir()}/fs.test.js/${Date.now()}.writeFile.txt`;
+    const path = `${tmpdir()}/fs.test.ts/${Date.now()}.writeFile.txt`;
     await writeFile(path, "File written successfully");
     expect(readFileSync(path, "utf8")).toBe("File written successfully");
   });
@@ -2590,7 +2747,7 @@ it("fstat on a large file", () => {
   var dest: string = "",
     fd;
   try {
-    dest = `${tmpdir()}/fs.test.js/${Math.trunc(Math.random() * 10000000000).toString(32)}.stat.txt`;
+    dest = `${tmpdir()}/fs.test.ts/${Math.trunc(Math.random() * 10000000000).toString(32)}.stat.txt`;
     mkdirSync(dirname(dest), { recursive: true });
     const bigBuffer = new Uint8Array(1024 * 1024 * 1024);
     fd = openSync(dest, "w");
@@ -2653,6 +2810,8 @@ it("fs.constants", () => {
       COPYFILE_FICLONE: 2,
       UV_FS_COPYFILE_FICLONE_FORCE: 4,
       COPYFILE_FICLONE_FORCE: 4,
+      EXTENSIONLESS_FORMAT_JAVASCRIPT: 0,
+      EXTENSIONLESS_FORMAT_WASM: 1,
     } as any);
     return;
   }
@@ -3165,7 +3324,7 @@ it("new Stats", () => {
 it("test syscall errno, issue#4198", () => {
   const path = `${tmpdir()}/non-existent-${Date.now()}.txt`;
   expect(() => openSync(path, "r")).toThrow("No such file or directory");
-  expect(() => readSync(2147483640, Buffer.alloc(0))).toThrow("Bad file descriptor");
+  expect(() => readSync(2147483640, Buffer.alloc(1))).toThrow("Bad file descriptor");
   expect(() => readlinkSync(path)).toThrow("No such file or directory");
   expect(() => realpathSync(path)).toThrow("No such file or directory");
   expect(() => readFileSync(path)).toThrow("No such file or directory");
diff --git a/test/js/node/http/fixtures/http.compress.leak.server.ts b/test/js/node/http/fixtures/http.compress.leak.server.ts
new file mode 100644
index 0000000000..102b332d76
--- /dev/null
+++ b/test/js/node/http/fixtures/http.compress.leak.server.ts
@@ -0,0 +1,58 @@
+import jsc from "bun:jsc";
+import { createServer, Server } from "node:http";
+import { URL } from "node:url";
+import zlib from "node:zlib";
+
+const data = `<!DOCTYPE html><html lang="en"><head><meta charSet="utf-8"/><meta name="viewport" content="width=device-width, initial-scale=1"/><link rel="preload" href="/_next/static/media/4473ecc91f70f139-s.p.woff" as="font" crossorigin="" type="font/woff"/><link rel="preload" href="/_next/static/media/463dafcda517f24f-s.p.woff" as="font" crossorigin="" type="font/woff"/><link rel="preload" as="image" href="https://nextjs.org/icons/next.svg" fetchPriority="high"/><link rel="stylesheet" href="/_next/static/css/01541ae5165648e7.css" data-precedence="next"/><link rel="preload" as="script" fetchPriority="low" href="/_next/static/chunks/webpack-6b2f098d55ba02b2.js"/><script src="/_next/static/chunks/fd9d1056-2821b0f0cabcd8bd.js" async=""></script><script src="/_next/static/chunks/23-df62406fd8df4a89.js" async=""></script><script src="/_next/static/chunks/main-app-4783e5e93b5af5d5.js" async=""></script><script src="/_next/static/chunks/173-32f9ff9bdfb525b3.js" async=""></script><script src="/_next/static/chunks/app/page-565079b1ea34376a.js" async=""></script><title>Create Next App</title><meta name="description" content="Generated by create next app"/><link rel="icon" href="/favicon.ico" type="image/x-icon" sizes="16x16"/><meta name="next-size-adjust"/><script src="/_next/static/chunks/polyfills-78c92fac7aa8fdd8.js" noModule=""></script></head><body class="__variable_1e4310 __variable_c3aa02 antialiased"><div class="grid grid-rows-[20px_1fr_20px] items-center justify-items-center min-h-screen p-8 pb-20 gap-16 sm:p-20 font-[family-name:var(--font-geist-sans)]"><main class="flex flex-col gap-8 row-start-2 items-center sm:items-start"><img alt="Next.js logo" fetchPriority="high" width="180" height="38" decoding="async" data-nimg="1" class="dark:invert" style="color:transparent" src="https://nextjs.org/icons/next.svg"/><ol class="list-inside list-decimal text-sm text-center sm:text-left font-[family-name:var(--font-geist-mono)]"><li class="mb-2">Get started by editing<!-- --> <code class="bg-black/[.05] dark:bg-white/[.06] px-1 py-0.5 rounded font-semibold">app/page.tsx</code>.</li><li>Save and see your changes instantly.</li></ol><div class="flex gap-4 items-center flex-col sm:flex-row"><a class="rounded-full border border-solid border-transparent transition-colors flex items-center justify-center bg-foreground text-background gap-2 hover:bg-[#383838] dark:hover:bg-[#ccc] text-sm sm:text-base h-10 sm:h-12 px-4 sm:px-5" href="https://vercel.com/new?utm_source=create-next-app&amp;utm_medium=appdir-template-tw&amp;utm_campaign=create-next-app" target="_blank" rel="noopener noreferrer"><img alt="Vercel logomark" loading="lazy" width="20" height="20" decoding="async" data-nimg="1" class="dark:invert" style="color:transparent" src="https://nextjs.org/icons/vercel.svg"/>Deploy now</a><a class="rounded-full border border-solid border-black/[.08] dark:border-white/[.145] transition-colors flex items-center justify-center hover:bg-[#f2f2f2] dark:hover:bg-[#1a1a1a] hover:border-transparent text-sm sm:text-base h-10 sm:h-12 px-4 sm:px-5 sm:min-w-44" href="https://nextjs.org/docs?utm_source=create-next-app&amp;utm_medium=appdir-template-tw&amp;utm_campaign=create-next-app" target="_blank" rel="noopener noreferrer">Read our docs</a></div></main><footer class="row-start-3 flex gap-6 flex-wrap items-center justify-center"><a class="flex items-center gap-2 hover:underline hover:underline-offset-4" href="https://nextjs.org/learn?utm_source=create-next-app&amp;utm_medium=appdir-template-tw&amp;utm_campaign=create-next-app" target="_blank" rel="noopener noreferrer"><img aria-hidden="true" alt="File icon" loading="lazy" width="16" height="16" decoding="async" data-nimg="1" style="color:transparent" src="https://nextjs.org/icons/file.svg"/>Learn</a><a class="flex items-center gap-2 hover:underline hover:underline-offset-4" href="https://vercel.com/templates?framework=next.js&amp;utm_source=create-next-app&amp;utm_medium=appdir-template-tw&amp;utm_campaign=create-next-app" target="_blank" rel="noopener noreferrer"><img aria-hidden="true" alt="Window icon" loading="lazy" width="16" height="16" decoding="async" data-nimg="1" style="color:transparent" src="https://nextjs.org/icons/window.svg"/>Examples</a><a class="flex items-center gap-2 hover:underline hover:underline-offset-4" href="https://nextjs.org?utm_source=create-next-app&amp;utm_medium=appdir-template-tw&amp;utm_campaign=create-next-app" target="_blank" rel="noopener noreferrer"><img aria-hidden="true" alt="Globe icon" loading="lazy" width="16" height="16" decoding="async" data-nimg="1" style="color:transparent" src="https://nextjs.org/icons/globe.svg"/>Go to nextjs.org →</a></footer></div><script src="/_next/static/chunks/webpack-6b2f098d55ba02b2.js" async=""></script><script>(self.__next_f=self.__next_f||[]).push([0]);self.__next_f.push([2,null])</script><script>self.__next_f.push([1,"1:HL[\"/_next/static/media/4473ecc91f70f139-s.p.woff\",\"font\",{\"crossOrigin\":\"\",\"type\":\"font/woff\"}]\n2:HL[\"/_next/static/media/463dafcda517f24f-s.p.woff\",\"font\",{\"crossOrigin\":\"\",\"type\":\"font/woff\"}]\n3:HL[\"/_next/static/css/01541ae5165648e7.css\",\"style\"]\n"])</script><script>self.__next_f.push([1,"4:I[5751,[],\"\"]\n6:I[8173,[\"173\",\"static/chunks/173-32f9ff9bdfb525b3.js\",\"931\",\"static/chunks/app/page-565079b1ea34376a.js\"],\"Image\"]\n7:I[9275,[],\"\"]\n8:I[1343,[],\"\"]\na:I[6130,[],\"\"]\nb:[]\n"])</script><script>self.__next_f.push([1,"0:[\"$\",\"$L4\",null,{\"buildId\":\"Ox0kIiZiqaqrQTw92fv8T\",\"assetPrefix\":\"\",\"urlParts\":[\"\",\"\"],\"initialTree\":[\"\",{\"children\":[\"__PAGE__\",{}]},\"$undefined\",\"$undefined\",true],\"initialSeedData\":[\"\",{\"children\":[\"__PAGE__\",{},[[\"$L5\",[\"$\",\"div\",null,{\"className\":\"grid grid-rows-[20px_1fr_20px] items-center justify-items-center min-h-screen p-8 pb-20 gap-16 sm:p-20 font-[family-name:var(--font-geist-sans)]\",\"children\":[[\"$\",\"main\",null,{\"className\":\"flex flex-col gap-8 row-start-2 items-center sm:items-start\",\"children\":[[\"$\",\"$L6\",null,{\"className\":\"dark:invert\",\"src\":\"https://nextjs.org/icons/next.svg\",\"alt\":\"Next.js logo\",\"width\":180,\"height\":38,\"priority\":true}],[\"$\",\"ol\",null,{\"className\":\"list-inside list-decimal text-sm text-center sm:text-left font-[family-name:var(--font-geist-mono)]\",\"children\":[[\"$\",\"li\",null,{\"className\":\"mb-2\",\"children\":[\"Get started by editing\",\" \",[\"$\",\"code\",null,{\"className\":\"bg-black/[.05] dark:bg-white/[.06] px-1 py-0.5 rounded font-semibold\",\"children\":\"app/page.tsx\"}],\".\"]}],[\"$\",\"li\",null,{\"children\":\"Save and see your changes instantly.\"}]]}],[\"$\",\"div\",null,{\"className\":\"flex gap-4 items-center flex-col sm:flex-row\",\"children\":[[\"$\",\"a\",null,{\"className\":\"rounded-full border border-solid border-transparent transition-colors flex items-center justify-center bg-foreground text-background gap-2 hover:bg-[#383838] dark:hover:bg-[#ccc] text-sm sm:text-base h-10 sm:h-12 px-4 sm:px-5\",\"href\":\"https://vercel.com/new?utm_source=create-next-app\u0026utm_medium=appdir-template-tw\u0026utm_campaign=create-next-app\",\"target\":\"_blank\",\"rel\":\"noopener noreferrer\",\"children\":[[\"$\",\"$L6\",null,{\"className\":\"dark:invert\",\"src\":\"https://nextjs.org/icons/vercel.svg\",\"alt\":\"Vercel logomark\",\"width\":20,\"height\":20}],\"Deploy now\"]}],[\"$\",\"a\",null,{\"className\":\"rounded-full border border-solid border-black/[.08] dark:border-white/[.145] transition-colors flex items-center justify-center hover:bg-[#f2f2f2] dark:hover:bg-[#1a1a1a] hover:border-transparent text-sm sm:text-base h-10 sm:h-12 px-4 sm:px-5 sm:min-w-44\",\"href\":\"https://nextjs.org/docs?utm_source=create-next-app\u0026utm_medium=appdir-template-tw\u0026utm_campaign=create-next-app\",\"target\":\"_blank\",\"rel\":\"noopener noreferrer\",\"children\":\"Read our docs\"}]]}]]}],[\"$\",\"footer\",null,{\"className\":\"row-start-3 flex gap-6 flex-wrap items-center justify-center\",\"children\":[[\"$\",\"a\",null,{\"className\":\"flex items-center gap-2 hover:underline hover:underline-offset-4\",\"href\":\"https://nextjs.org/learn?utm_source=create-next-app\u0026utm_medium=appdir-template-tw\u0026utm_campaign=create-next-app\",\"target\":\"_blank\",\"rel\":\"noopener noreferrer\",\"children\":[[\"$\",\"$L6\",null,{\"aria-hidden\":true,\"src\":\"https://nextjs.org/icons/file.svg\",\"alt\":\"File icon\",\"width\":16,\"height\":16}],\"Learn\"]}],[\"$\",\"a\",null,{\"className\":\"flex items-center gap-2 hover:underline hover:underline-offset-4\",\"href\":\"https://vercel.com/templates?framework=next.js\u0026utm_source=create-next-app\u0026utm_medium=appdir-template-tw\u0026utm_campaign=create-next-app\",\"target\":\"_blank\",\"rel\":\"noopener noreferrer\",\"children\":[[\"$\",\"$L6\",null,{\"aria-hidden\":true,\"src\":\"https://nextjs.org/icons/window.svg\",\"alt\":\"Window icon\",\"width\":16,\"height\":16}],\"Examples\"]}],[\"$\",\"a\",null,{\"className\":\"flex items-center gap-2 hover:underline hover:underline-offset-4\",\"href\":\"https://nextjs.org?utm_source=create-next-app\u0026utm_medium=appdir-template-tw\u0026utm_campaign=create-next-app\",\"target\":\"_blank\",\"rel\":\"noopener noreferrer\",\"children\":[[\"$\",\"$L6\",null,{\"aria-hidden\":true,\"src\":\"https://nextjs.org/icons/globe.svg\",\"alt\":\"Globe icon\",\"width\":16,\"height\":16}],\"Go to nextjs.org →\"]}]]}]]}],null],null],null]},[[[[\"$\",\"link\",\"0\",{\"rel\":\"stylesheet\",\"href\":\"/_next/static/css/01541ae5165648e7.css\",\"precedence\":\"next\",\"crossOrigin\":\"$undefined\"}]],[\"$\",\"html\",null,{\"lang\":\"en\",\"children\":[\"$\",\"body\",null,{\"className\":\"__variable_1e4310 __variable_c3aa02 antialiased\",\"children\":[\"$\",\"$L7\",null,{\"parallelRouterKey\":\"children\",\"segmentPath\":[\"children\"],\"error\":\"$undefined\",\"errorStyles\":\"$undefined\",\"errorScripts\":\"$undefined\",\"template\":[\"$\",\"$L8\",null,{}],\"templateStyles\":\"$undefined\",\"templateScripts\":\"$undefined\",\"notFound\":[[\"$\",\"title\",null,{\"children\":\"404: This page could not be found.\"}],[\"$\",\"div\",null,{\"style\":{\"fontFamily\":\"system-ui,\\\"Segoe UI\\\",Roboto,Helvetica,Arial,sans-serif,\\\"Apple Color Emoji\\\",\\\"Segoe UI Emoji\\\"\",\"height\":\"100vh\",\"textAlign\":\"center\",\"display\":\"flex\",\"flexDirection\":\"column\",\"alignItems\":\"center\",\"justifyContent\":\"center\"},\"children\":[\"$\",\"div\",null,{\"children\":[[\"$\",\"style\",null,{\"dangerouslySetInnerHTML\":{\"__html\":\"body{color:#000;background:#fff;margin:0}.next-error-h1{border-right:1px solid rgba(0,0,0,.3)}@media (prefers-color-scheme:dark){body{color:#fff;background:#000}.next-error-h1{border-right:1px solid rgba(255,255,255,.3)}}\"}}],[\"$\",\"h1\",null,{\"className\":\"next-error-h1\",\"style\":{\"display\":\"inline-block\",\"margin\":\"0 20px 0 0\",\"padding\":\"0 23px 0 0\",\"fontSize\":24,\"fontWeight\":500,\"verticalAlign\":\"top\",\"lineHeight\":\"49px\"},\"children\":\"404\"}],[\"$\",\"div\",null,{\"style\":{\"display\":\"inline-block\"},\"children\":[\"$\",\"h2\",null,{\"style\":{\"fontSize\":14,\"fontWeight\":400,\"lineHeight\":\"49px\",\"margin\":0},\"children\":\"This page could not be found.\"}]}]]}]}]],\"notFoundStyles\":[]}]}]}]],null],null],\"couldBeIntercepted\":false,\"initialHead\":[null,\"$L9\"],\"globalErrorComponent\":\"$a\",\"missingSlots\":\"$Wb\"}]\n"])</script><script>self.__next_f.push([1,"9:[[\"$\",\"meta\",\"0\",{\"name\":\"viewport\",\"content\":\"width=device-width, initial-scale=1\"}],[\"$\",\"meta\",\"1\",{\"charSet\":\"utf-8\"}],[\"$\",\"title\",\"2\",{\"children\":\"Create Next App\"}],[\"$\",\"meta\",\"3\",{\"name\":\"description\",\"content\":\"Generated by create next app\"}],[\"$\",\"link\",\"4\",{\"rel\":\"icon\",\"href\":\"/favicon.ico\",\"type\":\"image/x-icon\",\"sizes\":\"16x16\"}],[\"$\",\"meta\",\"5\",{\"name\":\"next-size-adjust\"}]]\n5:null\n"])</script></body></html>`;
+
+function listen(server: Server, protocol: string = "http"): Promise<URL> {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => reject("Timed out"), 5000).unref();
+    server.listen({ port: 0 }, (err, hostname, port) => {
+      clearTimeout(timeout);
+
+      if (err) {
+        reject(err);
+      } else {
+        resolve(new URL(`${protocol}://${hostname}:${port}`));
+      }
+    });
+  });
+}
+
+const baseline = process.memoryUsage.rss();
+let count = 0;
+
+var server = createServer(async (req, res) => {
+  res.writeHead(200, { "Content-Type": "application/gzip" });
+  const gz = zlib.createGzip();
+
+  gz.pipe(res);
+
+  for (let i = 0; i < 10; i++) gz.write(data);
+  await Bun.sleep(10);
+  for (let i = 0; i < 10; i++) gz.write(data);
+  await Bun.sleep(10);
+  for (let i = 0; i < 10; i++) gz.write(data);
+  for (let i = 0; i < 10; i++) gz.write(data);
+  await Bun.sleep(10);
+  for (let i = 0; i < 10; i++) gz.write(data);
+  for (let i = 0; i < 10; i++) gz.write(data);
+  for (let i = 0; i < 10; i++) gz.write(data);
+  gz.end();
+
+  count += 1;
+  if (count % 1000 === 0) {
+    Bun.gc(true);
+    console.log("count", count, process.memoryUsage.rss());
+  }
+  if (count == 10_000) {
+    Bun.gc(true);
+    const after = process.memoryUsage.rss();
+    console.log("heapStats", jsc.heapStats());
+    process.send({ baseline, after });
+  }
+});
+const url = await listen(server);
+console.log("server", "listening on", url.port);
+process.send(url.port);
diff --git a/test/js/node/http/max-header-size-fixture.ts b/test/js/node/http/max-header-size-fixture.ts
index 33f4af5ec3..04954c9c47 100644
--- a/test/js/node/http/max-header-size-fixture.ts
+++ b/test/js/node/http/max-header-size-fixture.ts
@@ -1,6 +1,6 @@
 import http from "node:http";
 
-if (http.maxHeaderSize !== parseInt(process.env.BUN_HTTP_MAX_HEADER_SIZE, 10)) {
+if (http.maxHeaderSize !== parseInt(process.env.BUN_HTTP_MAX_HEADER_SIZE ?? "0", 10)) {
   throw new Error("BUN_HTTP_MAX_HEADER_SIZE is not set to the correct value");
 }
 
@@ -18,16 +18,20 @@ await fetch(`${server.url}/`, {
 });
 
 try {
-  await fetch(`${server.url}/`, {
+  const response = await fetch(`${server.url}/`, {
     headers: {
       "Huge": Buffer.alloc(http.maxHeaderSize + 1024, "abc").toString(),
     },
   });
-  throw new Error("bad");
-} catch (e) {
-  if (e.message.includes("bad")) {
-    process.exit(1);
+  if (response.status === 431) {
+    throw new Error("good!!");
   }
 
-  process.exit(0);
+  throw new Error("bad!");
+} catch (e) {
+  if (e instanceof Error && e.message.includes("good!!")) {
+    process.exit(0);
+  }
+
+  throw e;
 }
diff --git a/test/js/node/http/node-http-maxHeaderSize.test.ts b/test/js/node/http/node-http-maxHeaderSize.test.ts
index 86eda1ee07..3a77e783bd 100644
--- a/test/js/node/http/node-http-maxHeaderSize.test.ts
+++ b/test/js/node/http/node-http-maxHeaderSize.test.ts
@@ -18,22 +18,23 @@ test("maxHeaderSize", async () => {
       },
     });
 
-    expect(
-      async () =>
-        await fetch(`${server.url}/`, {
-          headers: {
-            "Huge": Buffer.alloc(8 * 1024, "abc").toString(),
-          },
-        }),
-    ).toThrow();
-    expect(
-      async () =>
-        await fetch(`${server.url}/`, {
-          headers: {
-            "Huge": Buffer.alloc(512, "abc").toString(),
-          },
-        }),
-    ).not.toThrow();
+    {
+      const response = await fetch(`${server.url}/`, {
+        headers: {
+          "Huge": Buffer.alloc(8 * 1024, "abc").toString(),
+        },
+      });
+      expect(response.status).toBe(431);
+    }
+
+    {
+      const response = await fetch(`${server.url}/`, {
+        headers: {
+          "Huge": Buffer.alloc(15 * 1024, "abc").toString(),
+        },
+      });
+      expect(response.status).toBe(431);
+    }
   }
   http.maxHeaderSize = 16 * 1024;
   {
@@ -45,22 +46,23 @@ test("maxHeaderSize", async () => {
       },
     });
 
-    expect(
-      async () =>
-        await fetch(`${server.url}/`, {
-          headers: {
-            "Huge": Buffer.alloc(15 * 1024, "abc").toString(),
-          },
-        }),
-    ).not.toThrow();
-    expect(
-      async () =>
-        await fetch(`${server.url}/`, {
-          headers: {
-            "Huge": Buffer.alloc(17 * 1024, "abc").toString(),
-          },
-        }),
-    ).toThrow();
+    {
+      const response = await fetch(`${server.url}/`, {
+        headers: {
+          "Huge": Buffer.alloc(15 * 1024, "abc").toString(),
+        },
+      });
+      expect(response.status).toBe(200);
+    }
+
+    {
+      const response = await fetch(`${server.url}/`, {
+        headers: {
+          "Huge": Buffer.alloc(17 * 1024, "abc").toString(),
+        },
+      });
+      expect(response.status).toBe(431);
+    }
   }
 
   http.maxHeaderSize = originalMaxHeaderSize;
diff --git a/test/js/node/http/node-http-proxy.js b/test/js/node/http/node-http-proxy.js
new file mode 100644
index 0000000000..410b030d5c
--- /dev/null
+++ b/test/js/node/http/node-http-proxy.js
@@ -0,0 +1,79 @@
+import assert from "node:assert";
+import { createServer, request } from "node:http";
+import url from "node:url";
+
+export async function run() {
+  const { promise, resolve, reject } = Promise.withResolvers();
+
+  const proxyServer = createServer(function (req, res) {
+    // Use URL object instead of deprecated url.parse
+    const parsedUrl = new URL(req.url, `http://${req.headers.host}`);
+
+    const options = {
+      protocol: parsedUrl.protocol,
+      hostname: parsedUrl.hostname,
+      port: parsedUrl.port,
+      path: parsedUrl.pathname + parsedUrl.search,
+      method: req.method,
+      headers: req.headers,
+    };
+
+    const proxyRequest = request(options, function (proxyResponse) {
+      res.writeHead(proxyResponse.statusCode, proxyResponse.headers);
+      proxyResponse.pipe(res); // Use pipe instead of manual data handling
+    });
+
+    proxyRequest.on("error", error => {
+      console.error("Proxy Request Error:", error);
+      res.writeHead(500);
+      res.end("Proxy Error");
+    });
+
+    req.pipe(proxyRequest); // Use pipe instead of manual data handling
+  });
+
+  proxyServer.listen(0, "localhost", async () => {
+    const address = proxyServer.address();
+
+    const options = {
+      protocol: "http:",
+      hostname: "localhost",
+      port: address.port,
+      path: "/", // Change path to /
+      headers: {
+        Host: "example.com",
+        "accept-encoding": "identity",
+      },
+    };
+
+    const req = request(options, res => {
+      let data = "";
+      res.on("data", chunk => {
+        data += chunk;
+      });
+      res.on("end", () => {
+        try {
+          assert.strictEqual(res.statusCode, 200);
+          assert(data.length > 0);
+          assert(data.includes("This domain is for use in illustrative examples in documents"));
+          resolve();
+        } catch (err) {
+          reject(err);
+        }
+      });
+    });
+
+    req.on("error", err => {
+      reject(err);
+    });
+
+    req.end();
+  });
+
+  await promise;
+  proxyServer.close();
+}
+
+if (import.meta.main) {
+  run().catch(console.error);
+}
diff --git a/test/js/node/http/node-http.compress.leak.test.ts b/test/js/node/http/node-http.compress.leak.test.ts
new file mode 100644
index 0000000000..1962c29a14
--- /dev/null
+++ b/test/js/node/http/node-http.compress.leak.test.ts
@@ -0,0 +1,38 @@
+import { expect, test } from "bun:test";
+import { bunExe } from "harness";
+import path from "node:path";
+
+// test does still leak but not as bad
+// prettier-ignore
+test.todo("http.Server + compression integration", async () => {
+  const { promise, resolve } = Promise.withResolvers();
+  const proc = Bun.spawn([bunExe(), path.resolve(import.meta.dir, "fixtures", "http.compress.leak.server.ts")], {
+    stdio: ["ignore", "inherit", "inherit"],
+    async ipc(message) {
+      if (typeof message === "string") {
+        const port = message;
+
+        for (let i = 0; i < 1_000; i++) {
+          const a = await Promise.all(
+            Array(10)
+              .fill(0)
+              .map(v => fetch(`http://localhost:${port}`, { headers: { "Accept-Encoding": "gzip" } })),
+          );
+          const b = await Promise.all(a.map(v => v.arrayBuffer()));
+        }
+        return;
+      }
+      if (typeof message === "object") {
+        const { baseline, after } = message;
+        console.log(baseline);
+        console.log(after);
+        console.log("-", after - baseline);
+        console.log("-", 1024 * 1024 * 20);
+        expect(after - baseline).toBeLessThan(1024 * 1024 * 20);
+        process.kill(proc.pid); // cleanup
+        resolve();
+      }
+    },
+  });
+  await promise;
+}, 0);
diff --git a/test/js/node/http/node-http.test.ts b/test/js/node/http/node-http.test.ts
index a3f4e2f767..1457d2e862 100644
--- a/test/js/node/http/node-http.test.ts
+++ b/test/js/node/http/node-http.test.ts
@@ -1,6 +1,11 @@
-// @ts-nocheck
-import { bunExe } from "bun:harness";
-import { bunEnv, randomPort } from "harness";
+/**
+ * All new tests in this file should also run in Node.js.
+ *
+ * Do not add any tests that only run in Bun.
+ *
+ * A handful of older tests do not run in Node in this file. These tests should be updated to run in Node, or deleted.
+ */
+import { bunEnv, randomPort, bunExe } from "harness";
 import { createTest } from "node-harness";
 import { spawnSync } from "node:child_process";
 import { EventEmitter, once } from "node:events";
@@ -23,10 +28,9 @@ import { tmpdir } from "node:os";
 import * as path from "node:path";
 import * as stream from "node:stream";
 import { PassThrough } from "node:stream";
-import url from "node:url";
 import * as zlib from "node:zlib";
+import { run as runHTTPProxyTest } from "./node-http-proxy.js";
 const { describe, expect, it, beforeAll, afterAll, createDoneDotAll, mock, test } = createTest(import.meta.path);
-
 function listen(server: Server, protocol: string = "http"): Promise<URL> {
   return new Promise((resolve, reject) => {
     const timeout = setTimeout(() => reject("Timed out"), 5000).unref();
@@ -323,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);
           });
@@ -679,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();
@@ -706,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 => {
@@ -772,62 +811,8 @@ describe("node:http", () => {
       });
     });
 
-    it("request via http proxy, issue#4295", done => {
-      const proxyServer = createServer(function (req, res) {
-        let option = url.parse(req.url);
-        option.host = req.headers.host;
-        option.headers = req.headers;
-
-        const proxyRequest = request(option, function (proxyResponse) {
-          res.writeHead(proxyResponse.statusCode, proxyResponse.headers);
-          proxyResponse.on("data", function (chunk) {
-            res.write(chunk, "binary");
-          });
-          proxyResponse.on("end", function () {
-            res.end();
-          });
-        });
-        req.on("data", function (chunk) {
-          proxyRequest.write(chunk, "binary");
-        });
-        req.on("end", function () {
-          proxyRequest.end();
-        });
-      });
-
-      proxyServer.listen({ port: 0 }, async (_err, hostname, port) => {
-        const options = {
-          protocol: "http:",
-          hostname: hostname,
-          port: port,
-          path: "http://example.com",
-          headers: {
-            Host: "example.com",
-            "accept-encoding": "identity",
-          },
-        };
-
-        const req = request(options, res => {
-          let data = "";
-          res.on("data", chunk => {
-            data += chunk;
-          });
-          res.on("end", () => {
-            try {
-              expect(res.statusCode).toBe(200);
-              expect(data.length).toBeGreaterThan(0);
-              expect(data).toContain("This domain is for use in illustrative examples in documents");
-              done();
-            } catch (err) {
-              done(err);
-            }
-          });
-        });
-        req.on("error", err => {
-          done(err);
-        });
-        req.end();
-      });
+    it("request via http proxy, issue#4295", async () => {
+      await runHTTPProxyTest();
     });
 
     it("should correctly stream a multi-chunk response #5320", async done => {
@@ -2440,3 +2425,134 @@ 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;
+});
+
+it("client should use chunked encoded if more than one write is called", async () => {
+  function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+  // Bun.serve is used here until #15576 or similar fix is merged
+  using server = Bun.serve({
+    port: 0,
+    hostname: "127.0.0.1",
+    fetch(req) {
+      if (req.headers.get("transfer-encoding") !== "chunked") {
+        return new Response("should be chunked encoding", { status: 500 });
+      }
+      return new Response(req.body);
+    },
+  });
+
+  // Options for the HTTP request
+  const options = {
+    hostname: "127.0.0.1", // Replace with the target server
+    port: server.port,
+    path: "/api/data",
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+  };
+
+  const { promise, resolve, reject } = Promise.withResolvers();
+
+  // Create the request
+  const req = http.request(options, res => {
+    if (res.statusCode !== 200) {
+      reject(new Error("Body should be chunked"));
+    }
+    const chunks = [];
+    // Collect the response data
+    res.on("data", chunk => {
+      chunks.push(chunk);
+    });
+
+    res.on("end", () => {
+      resolve(chunks);
+    });
+  });
+
+  // Handle errors
+  req.on("error", reject);
+
+  // Write chunks to the request body
+  req.write("Hello");
+  req.write(" ");
+  await sleep(100);
+  req.write("World");
+  req.write(" ");
+  await sleep(100);
+  req.write("BUN!");
+  // End the request and signal no more data will be sent
+  req.end();
+
+  const chunks = await promise;
+  expect(chunks.length).toBeGreaterThan(1);
+  expect(chunks[chunks.length - 1]?.toString()).toEndWith("BUN!");
+  expect(Buffer.concat(chunks).toString()).toBe("Hello World BUN!");
+});
+
+it("client should use content-length if only one write is called", async () => {
+  await using server = http.createServer((req, res) => {
+    if (req.headers["transfer-encoding"] === "chunked") {
+      return res.writeHead(500).end();
+    }
+    res.writeHead(200);
+    req.on("data", data => {
+      res.write(data);
+    });
+    req.on("end", () => {
+      res.end();
+    });
+  });
+
+  await once(server.listen(0, "127.0.0.1"), "listening");
+
+  // Options for the HTTP request
+  const options = {
+    hostname: "127.0.0.1", // Replace with the target server
+    port: server.address().port,
+    path: "/api/data",
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+  };
+
+  const { promise, resolve, reject } = Promise.withResolvers();
+
+  // Create the request
+  const req = http.request(options, res => {
+    if (res.statusCode !== 200) {
+      reject(new Error("Body should not be chunked"));
+    }
+    const chunks = [];
+    // Collect the response data
+    res.on("data", chunk => {
+      chunks.push(chunk);
+    });
+
+    res.on("end", () => {
+      resolve(chunks);
+    });
+  });
+  // Handle errors
+  req.on("error", reject);
+  // Write chunks to the request body
+  req.write("Hello World BUN!");
+  // End the request and signal no more data will be sent
+  req.end();
+
+  const chunks = await promise;
+  expect(chunks.length).toBe(1);
+  expect(chunks[0]?.toString()).toBe("Hello World BUN!");
+  expect(Buffer.concat(chunks).toString()).toBe("Hello World BUN!");
+});
diff --git a/test/js/node/http2/node-http2-memory-leak.js b/test/js/node/http2/node-http2-memory-leak.js
index 949ade1d49..877d95fd31 100644
--- a/test/js/node/http2/node-http2-memory-leak.js
+++ b/test/js/node/http2/node-http2-memory-leak.js
@@ -1,3 +1,5 @@
+import { heapStats } from "bun:jsc";
+
 // This file is meant to be able to run in node and bun
 const http2 = require("http2");
 const { TLS_OPTIONS, nodeEchoServer } = require("./http2-helpers.cjs");
@@ -20,7 +22,8 @@ const sleep = dur => new Promise(resolve => setTimeout(resolve, dur));
 // X iterations should be enough to detect a leak
 const ITERATIONS = 20;
 // lets send a bigish payload
-const PAYLOAD = Buffer.from("BUN".repeat((1024 * 128) / 3));
+// const PAYLOAD = Buffer.from("BUN".repeat((1024 * 128) / 3));
+const PAYLOAD = Buffer.alloc(1024 * 128, "b");
 const MULTIPLEX = 50;
 
 async function main() {
@@ -84,19 +87,19 @@ async function main() {
 
   try {
     const startStats = getHeapStats();
-
     // warm up
     await runRequests(ITERATIONS);
+
     await sleep(10);
     gc(true);
     // take a baseline
     const baseline = process.memoryUsage.rss();
-    console.error("Initial memory usage", (baseline / 1024 / 1024) | 0, "MB");
 
     // run requests
     await runRequests(ITERATIONS);
-    await sleep(10);
     gc(true);
+    await sleep(10);
+
     // take an end snapshot
     const end = process.memoryUsage.rss();
 
@@ -106,7 +109,7 @@ async function main() {
 
     // we executed 100 requests per iteration, memory usage should not go up by 10 MB
     if (deltaMegaBytes > 20) {
-      console.log("Too many bodies leaked", deltaMegaBytes);
+      console.error("Too many bodies leaked", deltaMegaBytes);
       process.exit(1);
     }
 
diff --git a/test/js/node/http2/node-http2.test.js b/test/js/node/http2/node-http2.test.js
index c3aec0694a..6d19fe6dd1 100644
--- a/test/js/node/http2/node-http2.test.js
+++ b/test/js/node/http2/node-http2.test.js
@@ -1,5 +1,4 @@
-import { which } from "bun";
-import { bunEnv, bunExe } from "harness";
+import { bunEnv, bunExe, nodeExe } from "harness";
 import fs from "node:fs";
 import http2 from "node:http2";
 import net from "node:net";
@@ -7,1296 +6,1296 @@ import { tmpdir } from "node:os";
 import path from "node:path";
 import tls from "node:tls";
 import { Duplex } from "stream";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from "bun:test";
 import http2utils from "./helpers";
 import { nodeEchoServer, TLS_CERT, TLS_OPTIONS } from "./http2-helpers";
 
-const nodeExecutable = which("node");
-let nodeEchoServer_;
+for (const nodeExecutable of [nodeExe(), bunExe()]) {
+  describe(`${path.basename(nodeExecutable)}`, () => {
+    let nodeEchoServer_;
 
-let HTTPS_SERVER;
-beforeAll(async () => {
-  nodeEchoServer_ = await nodeEchoServer();
-  HTTPS_SERVER = nodeEchoServer_.url;
-});
-afterAll(async () => {
-  nodeEchoServer_.subprocess?.kill?.(9);
-});
-
-async function nodeDynamicServer(test_name, code) {
-  if (!nodeExecutable) throw new Error("node executable not found");
-
-  const tmp_dir = path.join(fs.realpathSync(tmpdir()), "http.nodeDynamicServer");
-  if (!fs.existsSync(tmp_dir)) {
-    fs.mkdirSync(tmp_dir, { recursive: true });
-  }
-
-  const file_name = path.join(tmp_dir, test_name);
-  const contents = Buffer.from(`const http2 = require("http2");
-  const server = http2.createServer();
-${code}
-server.listen(0);
-server.on("listening", () => {
-  process.stdout.write(JSON.stringify(server.address()));
-});`);
-  fs.writeFileSync(file_name, contents);
-
-  const subprocess = Bun.spawn([nodeExecutable, file_name, JSON.stringify(TLS_CERT)], {
-    stdout: "pipe",
-    stdin: "inherit",
-    stderr: "inherit",
-  });
-  subprocess.unref();
-  const reader = subprocess.stdout.getReader();
-  const data = await reader.read();
-  const decoder = new TextDecoder("utf-8");
-  const address = JSON.parse(decoder.decode(data.value));
-  const url = `http://${address.family === "IPv6" ? `[${address.address}]` : address.address}:${address.port}`;
-  return { address, url, subprocess };
-}
-
-function doHttp2Request(url, headers, payload, options, request_options) {
-  const { promise, resolve, reject: promiseReject } = Promise.withResolvers();
-  if (url.startsWith(HTTPS_SERVER)) {
-    options = { ...(options || {}), rejectUnauthorized: true, ...TLS_OPTIONS };
-  }
-
-  const client = options ? http2.connect(url, options) : http2.connect(url);
-  client.on("error", promiseReject);
-  function reject(err) {
-    promiseReject(err);
-    client.close();
-  }
-
-  const req = request_options ? client.request(headers, request_options) : client.request(headers);
-
-  let response_headers = null;
-  req.on("response", (headers, flags) => {
-    response_headers = headers;
-  });
-
-  req.setEncoding("utf8");
-  let data = "";
-  req.on("data", chunk => {
-    data += chunk;
-  });
-  req.on("error", reject);
-  req.on("end", () => {
-    resolve({ data, headers: response_headers });
-    client.close();
-  });
-
-  if (payload) {
-    req.write(payload);
-  }
-  req.end();
-  return promise;
-}
-
-function doMultiplexHttp2Request(url, requests) {
-  const { promise, resolve, reject: promiseReject } = Promise.withResolvers();
-  const client = http2.connect(url, TLS_OPTIONS);
-
-  client.on("error", promiseReject);
-  function reject(err) {
-    promiseReject(err);
-    client.close();
-  }
-  let completed = 0;
-  const results = [];
-  for (let i = 0; i < requests.length; i++) {
-    const { headers, payload } = requests[i];
-
-    const req = client.request(headers);
-
-    let response_headers = null;
-    req.on("response", (headers, flags) => {
-      response_headers = headers;
+    let HTTPS_SERVER;
+    beforeEach(async () => {
+      nodeEchoServer_ = await nodeEchoServer();
+      HTTPS_SERVER = nodeEchoServer_.url;
+    });
+    afterEach(async () => {
+      nodeEchoServer_.subprocess?.kill?.(9);
     });
 
-    req.setEncoding("utf8");
-    let data = "";
-    req.on("data", chunk => {
-      data += chunk;
-    });
-    req.on("error", reject);
-    req.on("end", () => {
-      results.push({ data, headers: response_headers });
-      completed++;
-      if (completed === requests.length) {
-        resolve(results);
+    async function nodeDynamicServer(test_name, code) {
+      if (!nodeExecutable) throw new Error("node executable not found");
+
+      const tmp_dir = path.join(fs.realpathSync(tmpdir()), "http.nodeDynamicServer");
+      if (!fs.existsSync(tmp_dir)) {
+        fs.mkdirSync(tmp_dir, { recursive: true });
+      }
+
+      const file_name = path.join(tmp_dir, test_name);
+      const contents = Buffer.from(`const http2 = require("http2");
+    const server = http2.createServer();
+  ${code}
+  server.listen(0);
+  server.on("listening", () => {
+    process.stdout.write(JSON.stringify(server.address()));
+  });`);
+      fs.writeFileSync(file_name, contents);
+
+      const subprocess = Bun.spawn([nodeExecutable, file_name, JSON.stringify(TLS_CERT)], {
+        stdout: "pipe",
+        stdin: "inherit",
+        stderr: "inherit",
+        env: bunEnv,
+      });
+      subprocess.unref();
+      const reader = subprocess.stdout.getReader();
+      const data = await reader.read();
+      const decoder = new TextDecoder("utf-8");
+      const text = decoder.decode(data.value);
+      const address = JSON.parse(text);
+      const url = `http://${address.family === "IPv6" ? `[${address.address}]` : address.address}:${address.port}`;
+      return { address, url, subprocess };
+    }
+
+    function doHttp2Request(url, headers, payload, options, request_options) {
+      const { promise, resolve, reject: promiseReject } = Promise.withResolvers();
+      if (url.startsWith(HTTPS_SERVER)) {
+        options = { ...(options || {}), rejectUnauthorized: true, ...TLS_OPTIONS };
+      }
+
+      const client = options ? http2.connect(url, options) : http2.connect(url);
+      client.on("error", promiseReject);
+      function reject(err) {
+        promiseReject(err);
         client.close();
       }
-    });
 
-    if (payload) {
-      req.write(payload);
-    }
-    req.end();
-  }
-  return promise;
-}
+      const req = request_options ? client.request(headers, request_options) : client.request(headers);
 
-describe("Client Basics", () => {
-  // we dont support server yet but we support client
-  it("should be able to send a GET request", async () => {
-    const result = await doHttp2Request(HTTPS_SERVER, { ":path": "/get", "test-header": "test-value" });
-    let parsed;
-    expect(() => (parsed = JSON.parse(result.data))).not.toThrow();
-    expect(parsed.url).toBe(`${HTTPS_SERVER}/get`);
-    expect(parsed.headers["test-header"]).toBe("test-value");
-  });
-  it("should be able to send a POST request", async () => {
-    const payload = JSON.stringify({ "hello": "bun" });
-    const result = await doHttp2Request(
-      HTTPS_SERVER,
-      { ":path": "/post", "test-header": "test-value", ":method": "POST" },
-      payload,
-    );
-    let parsed;
-    expect(() => (parsed = JSON.parse(result.data))).not.toThrow();
-    expect(parsed.url).toBe(`${HTTPS_SERVER}/post`);
-    expect(parsed.headers["test-header"]).toBe("test-value");
-    expect(parsed.json).toEqual({ "hello": "bun" });
-    expect(parsed.data).toEqual(payload);
-  });
-  it("should be able to send data using end", async () => {
-    const payload = JSON.stringify({ "hello": "bun" });
-    const { promise, resolve, reject } = Promise.withResolvers();
-    const client = http2.connect(HTTPS_SERVER, TLS_OPTIONS);
-    client.on("error", reject);
-    const req = client.request({ ":path": "/post", "test-header": "test-value", ":method": "POST" });
-    let response_headers = null;
-    req.on("response", (headers, flags) => {
-      response_headers = headers;
-    });
-    req.setEncoding("utf8");
-    let data = "";
-    req.on("data", chunk => {
-      data += chunk;
-    });
-    req.on("end", () => {
-      resolve({ data, headers: response_headers });
-      client.close();
-    });
-    req.end(payload);
-    const result = await promise;
-    let parsed;
-    expect(() => (parsed = JSON.parse(result.data))).not.toThrow();
-    expect(parsed.url).toBe(`${HTTPS_SERVER}/post`);
-    expect(parsed.headers["test-header"]).toBe("test-value");
-    expect(parsed.json).toEqual({ "hello": "bun" });
-    expect(parsed.data).toEqual(payload);
-  });
-  it("should be able to mutiplex GET requests", async () => {
-    const results = await doMultiplexHttp2Request(HTTPS_SERVER, [
-      { headers: { ":path": "/get" } },
-      { headers: { ":path": "/get" } },
-      { headers: { ":path": "/get" } },
-      { headers: { ":path": "/get" } },
-      { headers: { ":path": "/get" } },
-    ]);
-    expect(results.length).toBe(5);
-    for (let i = 0; i < results.length; i++) {
-      let parsed;
-      expect(() => (parsed = JSON.parse(results[i].data))).not.toThrow();
-      expect(parsed.url).toBe(`${HTTPS_SERVER}/get`);
-    }
-  });
-  it("should be able to mutiplex POST requests", async () => {
-    const results = await doMultiplexHttp2Request(HTTPS_SERVER, [
-      { headers: { ":path": "/post", ":method": "POST" }, payload: JSON.stringify({ "request": 1 }) },
-      { headers: { ":path": "/post", ":method": "POST" }, payload: JSON.stringify({ "request": 2 }) },
-      { headers: { ":path": "/post", ":method": "POST" }, payload: JSON.stringify({ "request": 3 }) },
-      { headers: { ":path": "/post", ":method": "POST" }, payload: JSON.stringify({ "request": 4 }) },
-      { headers: { ":path": "/post", ":method": "POST" }, payload: JSON.stringify({ "request": 5 }) },
-    ]);
-    expect(results.length).toBe(5);
-    for (let i = 0; i < results.length; i++) {
-      let parsed;
-      expect(() => (parsed = JSON.parse(results[i].data))).not.toThrow();
-      expect(parsed.url).toBe(`${HTTPS_SERVER}/post`);
-      expect([1, 2, 3, 4, 5]).toContain(parsed.json?.request);
-    }
-  });
-  it("constants", () => {
-    expect(http2.constants).toEqual({
-      "NGHTTP2_ERR_FRAME_SIZE_ERROR": -522,
-      "NGHTTP2_SESSION_SERVER": 0,
-      "NGHTTP2_SESSION_CLIENT": 1,
-      "NGHTTP2_STREAM_STATE_IDLE": 1,
-      "NGHTTP2_STREAM_STATE_OPEN": 2,
-      "NGHTTP2_STREAM_STATE_RESERVED_LOCAL": 3,
-      "NGHTTP2_STREAM_STATE_RESERVED_REMOTE": 4,
-      "NGHTTP2_STREAM_STATE_HALF_CLOSED_LOCAL": 5,
-      "NGHTTP2_STREAM_STATE_HALF_CLOSED_REMOTE": 6,
-      "NGHTTP2_STREAM_STATE_CLOSED": 7,
-      "NGHTTP2_FLAG_NONE": 0,
-      "NGHTTP2_FLAG_END_STREAM": 1,
-      "NGHTTP2_FLAG_END_HEADERS": 4,
-      "NGHTTP2_FLAG_ACK": 1,
-      "NGHTTP2_FLAG_PADDED": 8,
-      "NGHTTP2_FLAG_PRIORITY": 32,
-      "DEFAULT_SETTINGS_HEADER_TABLE_SIZE": 4096,
-      "DEFAULT_SETTINGS_ENABLE_PUSH": 1,
-      "DEFAULT_SETTINGS_MAX_CONCURRENT_STREAMS": 4294967295,
-      "DEFAULT_SETTINGS_INITIAL_WINDOW_SIZE": 65535,
-      "DEFAULT_SETTINGS_MAX_FRAME_SIZE": 16384,
-      "DEFAULT_SETTINGS_MAX_HEADER_LIST_SIZE": 65535,
-      "DEFAULT_SETTINGS_ENABLE_CONNECT_PROTOCOL": 0,
-      "MAX_MAX_FRAME_SIZE": 16777215,
-      "MIN_MAX_FRAME_SIZE": 16384,
-      "MAX_INITIAL_WINDOW_SIZE": 2147483647,
-      "NGHTTP2_SETTINGS_HEADER_TABLE_SIZE": 1,
-      "NGHTTP2_SETTINGS_ENABLE_PUSH": 2,
-      "NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS": 3,
-      "NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE": 4,
-      "NGHTTP2_SETTINGS_MAX_FRAME_SIZE": 5,
-      "NGHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE": 6,
-      "NGHTTP2_SETTINGS_ENABLE_CONNECT_PROTOCOL": 8,
-      "PADDING_STRATEGY_NONE": 0,
-      "PADDING_STRATEGY_ALIGNED": 1,
-      "PADDING_STRATEGY_MAX": 2,
-      "PADDING_STRATEGY_CALLBACK": 1,
-      "NGHTTP2_NO_ERROR": 0,
-      "NGHTTP2_PROTOCOL_ERROR": 1,
-      "NGHTTP2_INTERNAL_ERROR": 2,
-      "NGHTTP2_FLOW_CONTROL_ERROR": 3,
-      "NGHTTP2_SETTINGS_TIMEOUT": 4,
-      "NGHTTP2_STREAM_CLOSED": 5,
-      "NGHTTP2_FRAME_SIZE_ERROR": 6,
-      "NGHTTP2_REFUSED_STREAM": 7,
-      "NGHTTP2_CANCEL": 8,
-      "NGHTTP2_COMPRESSION_ERROR": 9,
-      "NGHTTP2_CONNECT_ERROR": 10,
-      "NGHTTP2_ENHANCE_YOUR_CALM": 11,
-      "NGHTTP2_INADEQUATE_SECURITY": 12,
-      "NGHTTP2_HTTP_1_1_REQUIRED": 13,
-      "NGHTTP2_DEFAULT_WEIGHT": 16,
-      "HTTP2_HEADER_STATUS": ":status",
-      "HTTP2_HEADER_METHOD": ":method",
-      "HTTP2_HEADER_AUTHORITY": ":authority",
-      "HTTP2_HEADER_SCHEME": ":scheme",
-      "HTTP2_HEADER_PATH": ":path",
-      "HTTP2_HEADER_PROTOCOL": ":protocol",
-      "HTTP2_HEADER_ACCEPT_ENCODING": "accept-encoding",
-      "HTTP2_HEADER_ACCEPT_LANGUAGE": "accept-language",
-      "HTTP2_HEADER_ACCEPT_RANGES": "accept-ranges",
-      "HTTP2_HEADER_ACCEPT": "accept",
-      "HTTP2_HEADER_ACCESS_CONTROL_ALLOW_CREDENTIALS": "access-control-allow-credentials",
-      "HTTP2_HEADER_ACCESS_CONTROL_ALLOW_HEADERS": "access-control-allow-headers",
-      "HTTP2_HEADER_ACCESS_CONTROL_ALLOW_METHODS": "access-control-allow-methods",
-      "HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN": "access-control-allow-origin",
-      "HTTP2_HEADER_ACCESS_CONTROL_EXPOSE_HEADERS": "access-control-expose-headers",
-      "HTTP2_HEADER_ACCESS_CONTROL_REQUEST_HEADERS": "access-control-request-headers",
-      "HTTP2_HEADER_ACCESS_CONTROL_REQUEST_METHOD": "access-control-request-method",
-      "HTTP2_HEADER_AGE": "age",
-      "HTTP2_HEADER_AUTHORIZATION": "authorization",
-      "HTTP2_HEADER_CACHE_CONTROL": "cache-control",
-      "HTTP2_HEADER_CONNECTION": "connection",
-      "HTTP2_HEADER_CONTENT_DISPOSITION": "content-disposition",
-      "HTTP2_HEADER_CONTENT_ENCODING": "content-encoding",
-      "HTTP2_HEADER_CONTENT_LENGTH": "content-length",
-      "HTTP2_HEADER_CONTENT_TYPE": "content-type",
-      "HTTP2_HEADER_COOKIE": "cookie",
-      "HTTP2_HEADER_DATE": "date",
-      "HTTP2_HEADER_ETAG": "etag",
-      "HTTP2_HEADER_FORWARDED": "forwarded",
-      "HTTP2_HEADER_HOST": "host",
-      "HTTP2_HEADER_IF_MODIFIED_SINCE": "if-modified-since",
-      "HTTP2_HEADER_IF_NONE_MATCH": "if-none-match",
-      "HTTP2_HEADER_IF_RANGE": "if-range",
-      "HTTP2_HEADER_LAST_MODIFIED": "last-modified",
-      "HTTP2_HEADER_LINK": "link",
-      "HTTP2_HEADER_LOCATION": "location",
-      "HTTP2_HEADER_RANGE": "range",
-      "HTTP2_HEADER_REFERER": "referer",
-      "HTTP2_HEADER_SERVER": "server",
-      "HTTP2_HEADER_SET_COOKIE": "set-cookie",
-      "HTTP2_HEADER_STRICT_TRANSPORT_SECURITY": "strict-transport-security",
-      "HTTP2_HEADER_TRANSFER_ENCODING": "transfer-encoding",
-      "HTTP2_HEADER_TE": "te",
-      "HTTP2_HEADER_UPGRADE_INSECURE_REQUESTS": "upgrade-insecure-requests",
-      "HTTP2_HEADER_UPGRADE": "upgrade",
-      "HTTP2_HEADER_USER_AGENT": "user-agent",
-      "HTTP2_HEADER_VARY": "vary",
-      "HTTP2_HEADER_X_CONTENT_TYPE_OPTIONS": "x-content-type-options",
-      "HTTP2_HEADER_X_FRAME_OPTIONS": "x-frame-options",
-      "HTTP2_HEADER_KEEP_ALIVE": "keep-alive",
-      "HTTP2_HEADER_PROXY_CONNECTION": "proxy-connection",
-      "HTTP2_HEADER_X_XSS_PROTECTION": "x-xss-protection",
-      "HTTP2_HEADER_ALT_SVC": "alt-svc",
-      "HTTP2_HEADER_CONTENT_SECURITY_POLICY": "content-security-policy",
-      "HTTP2_HEADER_EARLY_DATA": "early-data",
-      "HTTP2_HEADER_EXPECT_CT": "expect-ct",
-      "HTTP2_HEADER_ORIGIN": "origin",
-      "HTTP2_HEADER_PURPOSE": "purpose",
-      "HTTP2_HEADER_TIMING_ALLOW_ORIGIN": "timing-allow-origin",
-      "HTTP2_HEADER_X_FORWARDED_FOR": "x-forwarded-for",
-      "HTTP2_HEADER_PRIORITY": "priority",
-      "HTTP2_HEADER_ACCEPT_CHARSET": "accept-charset",
-      "HTTP2_HEADER_ACCESS_CONTROL_MAX_AGE": "access-control-max-age",
-      "HTTP2_HEADER_ALLOW": "allow",
-      "HTTP2_HEADER_CONTENT_LANGUAGE": "content-language",
-      "HTTP2_HEADER_CONTENT_LOCATION": "content-location",
-      "HTTP2_HEADER_CONTENT_MD5": "content-md5",
-      "HTTP2_HEADER_CONTENT_RANGE": "content-range",
-      "HTTP2_HEADER_DNT": "dnt",
-      "HTTP2_HEADER_EXPECT": "expect",
-      "HTTP2_HEADER_EXPIRES": "expires",
-      "HTTP2_HEADER_FROM": "from",
-      "HTTP2_HEADER_IF_MATCH": "if-match",
-      "HTTP2_HEADER_IF_UNMODIFIED_SINCE": "if-unmodified-since",
-      "HTTP2_HEADER_MAX_FORWARDS": "max-forwards",
-      "HTTP2_HEADER_PREFER": "prefer",
-      "HTTP2_HEADER_PROXY_AUTHENTICATE": "proxy-authenticate",
-      "HTTP2_HEADER_PROXY_AUTHORIZATION": "proxy-authorization",
-      "HTTP2_HEADER_REFRESH": "refresh",
-      "HTTP2_HEADER_RETRY_AFTER": "retry-after",
-      "HTTP2_HEADER_TRAILER": "trailer",
-      "HTTP2_HEADER_TK": "tk",
-      "HTTP2_HEADER_VIA": "via",
-      "HTTP2_HEADER_WARNING": "warning",
-      "HTTP2_HEADER_WWW_AUTHENTICATE": "www-authenticate",
-      "HTTP2_HEADER_HTTP2_SETTINGS": "http2-settings",
-      "HTTP2_METHOD_ACL": "ACL",
-      "HTTP2_METHOD_BASELINE_CONTROL": "BASELINE-CONTROL",
-      "HTTP2_METHOD_BIND": "BIND",
-      "HTTP2_METHOD_CHECKIN": "CHECKIN",
-      "HTTP2_METHOD_CHECKOUT": "CHECKOUT",
-      "HTTP2_METHOD_CONNECT": "CONNECT",
-      "HTTP2_METHOD_COPY": "COPY",
-      "HTTP2_METHOD_DELETE": "DELETE",
-      "HTTP2_METHOD_GET": "GET",
-      "HTTP2_METHOD_HEAD": "HEAD",
-      "HTTP2_METHOD_LABEL": "LABEL",
-      "HTTP2_METHOD_LINK": "LINK",
-      "HTTP2_METHOD_LOCK": "LOCK",
-      "HTTP2_METHOD_MERGE": "MERGE",
-      "HTTP2_METHOD_MKACTIVITY": "MKACTIVITY",
-      "HTTP2_METHOD_MKCALENDAR": "MKCALENDAR",
-      "HTTP2_METHOD_MKCOL": "MKCOL",
-      "HTTP2_METHOD_MKREDIRECTREF": "MKREDIRECTREF",
-      "HTTP2_METHOD_MKWORKSPACE": "MKWORKSPACE",
-      "HTTP2_METHOD_MOVE": "MOVE",
-      "HTTP2_METHOD_OPTIONS": "OPTIONS",
-      "HTTP2_METHOD_ORDERPATCH": "ORDERPATCH",
-      "HTTP2_METHOD_PATCH": "PATCH",
-      "HTTP2_METHOD_POST": "POST",
-      "HTTP2_METHOD_PRI": "PRI",
-      "HTTP2_METHOD_PROPFIND": "PROPFIND",
-      "HTTP2_METHOD_PROPPATCH": "PROPPATCH",
-      "HTTP2_METHOD_PUT": "PUT",
-      "HTTP2_METHOD_REBIND": "REBIND",
-      "HTTP2_METHOD_REPORT": "REPORT",
-      "HTTP2_METHOD_SEARCH": "SEARCH",
-      "HTTP2_METHOD_TRACE": "TRACE",
-      "HTTP2_METHOD_UNBIND": "UNBIND",
-      "HTTP2_METHOD_UNCHECKOUT": "UNCHECKOUT",
-      "HTTP2_METHOD_UNLINK": "UNLINK",
-      "HTTP2_METHOD_UNLOCK": "UNLOCK",
-      "HTTP2_METHOD_UPDATE": "UPDATE",
-      "HTTP2_METHOD_UPDATEREDIRECTREF": "UPDATEREDIRECTREF",
-      "HTTP2_METHOD_VERSION_CONTROL": "VERSION-CONTROL",
-      "HTTP_STATUS_CONTINUE": 100,
-      "HTTP_STATUS_SWITCHING_PROTOCOLS": 101,
-      "HTTP_STATUS_PROCESSING": 102,
-      "HTTP_STATUS_EARLY_HINTS": 103,
-      "HTTP_STATUS_OK": 200,
-      "HTTP_STATUS_CREATED": 201,
-      "HTTP_STATUS_ACCEPTED": 202,
-      "HTTP_STATUS_NON_AUTHORITATIVE_INFORMATION": 203,
-      "HTTP_STATUS_NO_CONTENT": 204,
-      "HTTP_STATUS_RESET_CONTENT": 205,
-      "HTTP_STATUS_PARTIAL_CONTENT": 206,
-      "HTTP_STATUS_MULTI_STATUS": 207,
-      "HTTP_STATUS_ALREADY_REPORTED": 208,
-      "HTTP_STATUS_IM_USED": 226,
-      "HTTP_STATUS_MULTIPLE_CHOICES": 300,
-      "HTTP_STATUS_MOVED_PERMANENTLY": 301,
-      "HTTP_STATUS_FOUND": 302,
-      "HTTP_STATUS_SEE_OTHER": 303,
-      "HTTP_STATUS_NOT_MODIFIED": 304,
-      "HTTP_STATUS_USE_PROXY": 305,
-      "HTTP_STATUS_TEMPORARY_REDIRECT": 307,
-      "HTTP_STATUS_PERMANENT_REDIRECT": 308,
-      "HTTP_STATUS_BAD_REQUEST": 400,
-      "HTTP_STATUS_UNAUTHORIZED": 401,
-      "HTTP_STATUS_PAYMENT_REQUIRED": 402,
-      "HTTP_STATUS_FORBIDDEN": 403,
-      "HTTP_STATUS_NOT_FOUND": 404,
-      "HTTP_STATUS_METHOD_NOT_ALLOWED": 405,
-      "HTTP_STATUS_NOT_ACCEPTABLE": 406,
-      "HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED": 407,
-      "HTTP_STATUS_REQUEST_TIMEOUT": 408,
-      "HTTP_STATUS_CONFLICT": 409,
-      "HTTP_STATUS_GONE": 410,
-      "HTTP_STATUS_LENGTH_REQUIRED": 411,
-      "HTTP_STATUS_PRECONDITION_FAILED": 412,
-      "HTTP_STATUS_PAYLOAD_TOO_LARGE": 413,
-      "HTTP_STATUS_URI_TOO_LONG": 414,
-      "HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE": 415,
-      "HTTP_STATUS_RANGE_NOT_SATISFIABLE": 416,
-      "HTTP_STATUS_EXPECTATION_FAILED": 417,
-      "HTTP_STATUS_TEAPOT": 418,
-      "HTTP_STATUS_MISDIRECTED_REQUEST": 421,
-      "HTTP_STATUS_UNPROCESSABLE_ENTITY": 422,
-      "HTTP_STATUS_LOCKED": 423,
-      "HTTP_STATUS_FAILED_DEPENDENCY": 424,
-      "HTTP_STATUS_TOO_EARLY": 425,
-      "HTTP_STATUS_UPGRADE_REQUIRED": 426,
-      "HTTP_STATUS_PRECONDITION_REQUIRED": 428,
-      "HTTP_STATUS_TOO_MANY_REQUESTS": 429,
-      "HTTP_STATUS_REQUEST_HEADER_FIELDS_TOO_LARGE": 431,
-      "HTTP_STATUS_UNAVAILABLE_FOR_LEGAL_REASONS": 451,
-      "HTTP_STATUS_INTERNAL_SERVER_ERROR": 500,
-      "HTTP_STATUS_NOT_IMPLEMENTED": 501,
-      "HTTP_STATUS_BAD_GATEWAY": 502,
-      "HTTP_STATUS_SERVICE_UNAVAILABLE": 503,
-      "HTTP_STATUS_GATEWAY_TIMEOUT": 504,
-      "HTTP_STATUS_HTTP_VERSION_NOT_SUPPORTED": 505,
-      "HTTP_STATUS_VARIANT_ALSO_NEGOTIATES": 506,
-      "HTTP_STATUS_INSUFFICIENT_STORAGE": 507,
-      "HTTP_STATUS_LOOP_DETECTED": 508,
-      "HTTP_STATUS_BANDWIDTH_LIMIT_EXCEEDED": 509,
-      "HTTP_STATUS_NOT_EXTENDED": 510,
-      "HTTP_STATUS_NETWORK_AUTHENTICATION_REQUIRED": 511,
-    });
-  });
-  it("getDefaultSettings", () => {
-    const settings = http2.getDefaultSettings();
-    expect(settings).toEqual({
-      enableConnectProtocol: false,
-      headerTableSize: 4096,
-      enablePush: true,
-      initialWindowSize: 65535,
-      maxFrameSize: 16384,
-      maxConcurrentStreams: 2147483647,
-      maxHeaderListSize: 65535,
-      maxHeaderSize: 65535,
-    });
-  });
-  it("getPackedSettings/getUnpackedSettings", () => {
-    const settings = {
-      headerTableSize: 1,
-      enablePush: false,
-      initialWindowSize: 2,
-      maxFrameSize: 32768,
-      maxConcurrentStreams: 4,
-      maxHeaderListSize: 5,
-      maxHeaderSize: 5,
-      enableConnectProtocol: false,
-    };
-    const buffer = http2.getPackedSettings(settings);
-    expect(buffer.byteLength).toBe(36);
-    expect(http2.getUnpackedSettings(buffer)).toEqual(settings);
-  });
-  it("getUnpackedSettings should throw if buffer is too small", () => {
-    const buffer = new ArrayBuffer(1);
-    expect(() => http2.getUnpackedSettings(buffer)).toThrow(
-      /Expected buf to be a Buffer of at least 6 bytes and a multiple of 6 bytes/,
-    );
-  });
-  it("getUnpackedSettings should throw if buffer is not a multiple of 6 bytes", () => {
-    const buffer = new ArrayBuffer(7);
-    expect(() => http2.getUnpackedSettings(buffer)).toThrow(
-      /Expected buf to be a Buffer of at least 6 bytes and a multiple of 6 bytes/,
-    );
-  });
-  it("getUnpackedSettings should throw if buffer is not a buffer", () => {
-    const buffer = {};
-    expect(() => http2.getUnpackedSettings(buffer)).toThrow(/Expected buf to be a Buffer/);
-  });
-  it("headers cannot be bigger than 65536 bytes", async () => {
-    try {
-      await doHttp2Request(HTTPS_SERVER, { ":path": "/", "test-header": "A".repeat(90000) });
-      expect("unreachable").toBe(true);
-    } catch (err) {
-      expect(err.code).toBe("ERR_HTTP2_STREAM_ERROR");
-      expect(err.message).toBe("Stream closed with error code 9");
-    }
-  });
-  it("should be destroyed after close", async () => {
-    const { promise, resolve, reject: promiseReject } = Promise.withResolvers();
-    const client = http2.connect(`${HTTPS_SERVER}/get`, TLS_OPTIONS);
-    client.on("error", promiseReject);
-    client.on("close", resolve);
-    function reject(err) {
-      promiseReject(err);
-      client.close();
-    }
-    const req = client.request({
-      ":path": "/get",
-    });
-    req.on("error", reject);
-    req.on("end", () => {
-      client.close();
-    });
-    req.end();
-    await promise;
-    expect(client.destroyed).toBe(true);
-  });
-  it("should be destroyed after destroy", async () => {
-    const { promise, resolve, reject: promiseReject } = Promise.withResolvers();
-    const client = http2.connect(`${HTTPS_SERVER}/get`, TLS_OPTIONS);
-    client.on("error", promiseReject);
-    client.on("close", resolve);
-    function reject(err) {
-      promiseReject(err);
-      client.destroy();
-    }
-    const req = client.request({
-      ":path": "/get",
-    });
-    req.on("error", reject);
-    req.on("end", () => {
-      client.destroy();
-    });
-    req.end();
-    await promise;
-    expect(client.destroyed).toBe(true);
-  });
-  it("should fail to connect over HTTP/1.1", async () => {
-    const tls = TLS_CERT;
-    using server = Bun.serve({
-      port: 0,
-      hostname: "127.0.0.1",
-      tls: {
-        ...tls,
-        ca: TLS_CERT.ca,
-      },
-      fetch() {
-        return new Response("hello");
-      },
-    });
-    const url = `https://127.0.0.1:${server.port}`;
-    try {
-      await doHttp2Request(url, { ":path": "/" }, null, TLS_OPTIONS);
-      expect("unreachable").toBe(true);
-    } catch (err) {
-      expect(err.code).toBe("ERR_HTTP2_ERROR");
-    }
-  });
-  it("works with Duplex", async () => {
-    class JSSocket extends Duplex {
-      constructor(socket) {
-        super({ emitClose: true });
-        socket.on("close", () => this.destroy());
-        socket.on("data", data => this.push(data));
-        this.socket = socket;
-      }
-      _write(data, encoding, callback) {
-        this.socket.write(data, encoding, callback);
-      }
-      _read(size) {}
-      _final(cb) {
-        cb();
-      }
-    }
-    const { promise, resolve, reject } = Promise.withResolvers();
-    const socket = tls
-      .connect(
-        {
-          rejectUnauthorized: false,
-          host: new URL(HTTPS_SERVER).hostname,
-          port: new URL(HTTPS_SERVER).port,
-          ALPNProtocols: ["h2"],
-          ...TLS_OPTIONS,
-        },
-        () => {
-          doHttp2Request(`${HTTPS_SERVER}/get`, { ":path": "/get" }, null, {
-            createConnection: () => {
-              return new JSSocket(socket);
-            },
-          }).then(resolve, reject);
-        },
-      )
-      .on("error", reject);
-    const result = await promise;
-    let parsed;
-    expect(() => (parsed = JSON.parse(result.data))).not.toThrow();
-    expect(parsed.url).toBe(`${HTTPS_SERVER}/get`);
-    socket.destroy();
-  });
-  it("close callback", async () => {
-    const { promise, resolve, reject } = Promise.withResolvers();
-    const client = http2.connect(`${HTTPS_SERVER}/get`, TLS_OPTIONS);
-    client.on("error", reject);
-    client.close(resolve);
-    await promise;
-    expect(client.destroyed).toBe(true);
-  });
-  it("is possible to abort request", async () => {
-    const abortController = new AbortController();
-    const promise = doHttp2Request(`${HTTPS_SERVER}/get`, { ":path": "/get" }, null, null, {
-      signal: abortController.signal,
-    });
-    abortController.abort();
-    try {
-      await promise;
-      expect("unreachable").toBe(true);
-    } catch (err) {
-      expect(err.errno).toBe(http2.constants.NGHTTP2_CANCEL);
-    }
-  });
-  it("aborted event should work with abortController", async () => {
-    const abortController = new AbortController();
-    const { promise, resolve, reject } = Promise.withResolvers();
-    const client = http2.connect(HTTPS_SERVER, TLS_OPTIONS);
-    client.on("error", reject);
-    const req = client.request({ ":path": "/" }, { signal: abortController.signal });
-    req.on("aborted", resolve);
-    req.on("error", err => {
-      if (err.errno !== http2.constants.NGHTTP2_CANCEL) {
-        reject(err);
-      }
-    });
-    req.on("end", () => {
-      reject();
-      client.close();
-    });
-    abortController.abort();
-    const result = await promise;
-    expect(result).toBeUndefined();
-    expect(req.aborted).toBeTrue();
-    expect(req.rstCode).toBe(8);
-  });
-  it("aborted event should work with aborted signal", async () => {
-    const { promise, resolve, reject } = Promise.withResolvers();
-    const client = http2.connect(HTTPS_SERVER, TLS_OPTIONS);
-    client.on("error", reject);
-    const req = client.request({ ":path": "/" }, { signal: AbortSignal.abort() });
-    req.on("aborted", resolve);
-    req.on("error", err => {
-      if (err.errno !== http2.constants.NGHTTP2_CANCEL) {
-        reject(err);
-      }
-    });
-    req.on("end", () => {
-      reject();
-      client.close();
-    });
-    const result = await promise;
-    expect(result).toBeUndefined();
-    expect(req.rstCode).toBe(8);
-    expect(req.aborted).toBeTrue();
-  });
-  it("endAfterHeaders should work", async () => {
-    const { promise, resolve, reject } = Promise.withResolvers();
-    const client = http2.connect(HTTPS_SERVER, TLS_OPTIONS);
-    client.on("error", reject);
-    const req = client.request({ ":path": "/" });
-    req.endAfterHeaders = true;
-    let response_headers = null;
-    req.on("response", (headers, flags) => {
-      response_headers = headers;
-    });
-    req.setEncoding("utf8");
-    let data = "";
-    req.on("data", chunk => {
-      data += chunk;
-    });
-    req.on("error", console.error);
-    req.on("end", () => {
-      resolve();
-    });
-    await promise;
-    expect(response_headers[":status"]).toBe(200);
-    expect(data).toBeFalsy();
-  });
-  it("state should work", async () => {
-    const { promise, resolve, reject } = Promise.withResolvers();
-    const client = http2.connect(HTTPS_SERVER, TLS_OPTIONS);
-    client.on("error", reject);
-    const req = client.request({ ":path": "/", "test-header": "test-value" });
-    {
-      const state = req.state;
-      expect(typeof state).toBe("object");
-      expect(typeof state.state).toBe("number");
-      expect(typeof state.weight).toBe("number");
-      expect(typeof state.sumDependencyWeight).toBe("number");
-      expect(typeof state.localClose).toBe("number");
-      expect(typeof state.remoteClose).toBe("number");
-      expect(typeof state.localWindowSize).toBe("number");
-    }
-    // Test Session State.
-    {
-      const state = client.state;
-      expect(typeof state).toBe("object");
-      expect(typeof state.effectiveLocalWindowSize).toBe("number");
-      expect(typeof state.effectiveRecvDataLength).toBe("number");
-      expect(typeof state.nextStreamID).toBe("number");
-      expect(typeof state.localWindowSize).toBe("number");
-      expect(typeof state.lastProcStreamID).toBe("number");
-      expect(typeof state.remoteWindowSize).toBe("number");
-      expect(typeof state.outboundQueueSize).toBe("number");
-      expect(typeof state.deflateDynamicTableSize).toBe("number");
-      expect(typeof state.inflateDynamicTableSize).toBe("number");
-    }
-    let response_headers = null;
-    req.on("response", (headers, flags) => {
-      response_headers = headers;
-    });
-    req.on("end", () => {
-      resolve();
-      client.close();
-    });
-    await promise;
-    expect(response_headers[":status"]).toBe(200);
-  });
-  it("settings and properties should work", async () => {
-    const assertSettings = settings => {
-      expect(settings).toBeDefined();
-      expect(typeof settings).toBe("object");
-      expect(typeof settings.headerTableSize).toBe("number");
-      expect(typeof settings.enablePush).toBe("boolean");
-      expect(typeof settings.initialWindowSize).toBe("number");
-      expect(typeof settings.maxFrameSize).toBe("number");
-      expect(typeof settings.maxConcurrentStreams).toBe("number");
-      expect(typeof settings.maxHeaderListSize).toBe("number");
-      expect(typeof settings.maxHeaderSize).toBe("number");
-    };
-    const { promise, resolve, reject } = Promise.withResolvers();
-    const client = http2.connect("https://www.example.com");
-    client.on("error", reject);
-    expect(client.connecting).toBeTrue();
-    expect(client.alpnProtocol).toBeUndefined();
-    expect(client.encrypted).toBeTrue();
-    expect(client.closed).toBeFalse();
-    expect(client.destroyed).toBeFalse();
-    expect(client.originSet.length).toBe(0);
-    expect(client.pendingSettingsAck).toBeTrue();
-    let received_origin = null;
-    client.on("origin", origin => {
-      received_origin = origin;
-    });
-    assertSettings(client.localSettings);
-    expect(client.remoteSettings).toBeNull();
-    const headers = { ":path": "/" };
-    const req = client.request(headers);
-    expect(req.closed).toBeFalse();
-    expect(req.destroyed).toBeFalse();
-    // we always asign a stream id to the request
-    expect(req.pending).toBeFalse();
-    expect(typeof req.id).toBe("number");
-    expect(req.session).toBeDefined();
-    expect(req.sentHeaders).toEqual(headers);
-    expect(req.sentTrailers).toBeUndefined();
-    expect(req.sentInfoHeaders.length).toBe(0);
-    expect(req.scheme).toBe("https");
-    let response_headers = null;
-    req.on("response", (headers, flags) => {
-      response_headers = headers;
-    });
-    req.on("end", () => {
-      resolve();
-    });
-    await promise;
-    expect(response_headers[":status"]).toBe(200);
-    const settings = client.remoteSettings;
-    const localSettings = client.localSettings;
-    assertSettings(settings);
-    assertSettings(localSettings);
-    expect(settings).toEqual(client.remoteSettings);
-    expect(localSettings).toEqual(client.localSettings);
-    client.destroy();
-    expect(client.connecting).toBeFalse();
-    expect(client.alpnProtocol).toBe("h2");
-    expect(client.originSet.length).toBe(1);
-    expect(client.originSet).toEqual(received_origin);
-    expect(client.originSet[0]).toBe("www.example.com");
-    expect(client.pendingSettingsAck).toBeFalse();
-    expect(client.destroyed).toBeTrue();
-    expect(client.closed).toBeTrue();
-    expect(req.closed).toBeTrue();
-    expect(req.destroyed).toBeTrue();
-    expect(req.rstCode).toBe(http2.constants.NGHTTP2_NO_ERROR);
-  });
-  it("ping events should work", async () => {
-    const { promise, resolve, reject } = Promise.withResolvers();
-    const client = http2.connect(HTTPS_SERVER, TLS_OPTIONS);
-    client.on("error", reject);
-    client.on("connect", () => {
-      client.ping(Buffer.from("12345678"), (err, duration, payload) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve({ duration, payload });
-        }
+      let response_headers = null;
+      req.on("response", (headers, flags) => {
+        response_headers = headers;
+      });
+
+      req.setEncoding("utf8");
+      let data = "";
+      req.on("data", chunk => {
+        data += chunk;
+      });
+      req.on("error", reject);
+      req.on("end", () => {
+        resolve({ data, headers: response_headers });
         client.close();
       });
-    });
-    let received_ping;
-    client.on("ping", payload => {
-      received_ping = payload;
-    });
-    const result = await promise;
-    expect(typeof result.duration).toBe("number");
-    expect(result.payload).toBeInstanceOf(Buffer);
-    expect(result.payload.byteLength).toBe(8);
-    expect(received_ping).toBeInstanceOf(Buffer);
-    expect(received_ping.byteLength).toBe(8);
-    expect(received_ping).toEqual(result.payload);
-    expect(received_ping).toEqual(Buffer.from("12345678"));
-  });
-  it("ping without events should work", async () => {
-    const { promise, resolve, reject } = Promise.withResolvers();
-    const client = http2.connect(HTTPS_SERVER, TLS_OPTIONS);
-    client.on("error", reject);
-    client.on("connect", () => {
-      client.ping((err, duration, payload) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve({ duration, payload });
-        }
+
+      if (payload) {
+        req.write(payload);
+      }
+      req.end();
+      return promise;
+    }
+
+    function doMultiplexHttp2Request(url, requests) {
+      const { promise, resolve, reject: promiseReject } = Promise.withResolvers();
+      const client = http2.connect(url, TLS_OPTIONS);
+
+      client.on("error", promiseReject);
+      function reject(err) {
+        promiseReject(err);
         client.close();
-      });
-    });
-    let received_ping;
-    client.on("ping", payload => {
-      received_ping = payload;
-    });
-    const result = await promise;
-    expect(typeof result.duration).toBe("number");
-    expect(result.payload).toBeInstanceOf(Buffer);
-    expect(result.payload.byteLength).toBe(8);
-    expect(received_ping).toBeInstanceOf(Buffer);
-    expect(received_ping.byteLength).toBe(8);
-    expect(received_ping).toEqual(result.payload);
-  });
-  it("ping with wrong payload length events should error", async () => {
-    const { promise, resolve, reject } = Promise.withResolvers();
-    const client = http2.connect(HTTPS_SERVER, TLS_OPTIONS);
-    client.on("error", resolve);
-    client.on("connect", () => {
-      client.ping(Buffer.from("oops"), (err, duration, payload) => {
-        if (err) {
-          resolve(err);
-        } else {
-          reject("unreachable");
+      }
+      let completed = 0;
+      const results = [];
+      for (let i = 0; i < requests.length; i++) {
+        const { headers, payload } = requests[i];
+
+        const req = client.request(headers);
+
+        let response_headers = null;
+        req.on("response", (headers, flags) => {
+          response_headers = headers;
+        });
+
+        req.setEncoding("utf8");
+        let data = "";
+        req.on("data", chunk => {
+          data += chunk;
+        });
+        req.on("error", reject);
+        req.on("end", () => {
+          results.push({ data, headers: response_headers });
+          completed++;
+          if (completed === requests.length) {
+            resolve(results);
+            client.close();
+          }
+        });
+
+        if (payload) {
+          req.write(payload);
         }
-        client.close();
+        req.end();
+      }
+      return promise;
+    }
+
+    describe("Client Basics", () => {
+      // we dont support server yet but we support client
+      it("should be able to send a GET request", async () => {
+        const result = await doHttp2Request(HTTPS_SERVER, { ":path": "/get", "test-header": "test-value" });
+        let parsed;
+        expect(() => (parsed = JSON.parse(result.data))).not.toThrow();
+        expect(parsed.url).toBe(`${HTTPS_SERVER}/get`);
+        expect(parsed.headers["test-header"]).toBe("test-value");
       });
-    });
-    const result = await promise;
-    expect(result).toBeDefined();
-    expect(result.code).toBe("ERR_HTTP2_PING_LENGTH");
-  });
-  it("ping with wrong payload type events should throw", async () => {
-    const { promise, resolve, reject } = Promise.withResolvers();
-    const client = http2.connect(HTTPS_SERVER, TLS_OPTIONS);
-    client.on("error", resolve);
-    client.on("connect", () => {
-      try {
-        client.ping("oops", (err, duration, payload) => {
-          reject("unreachable");
+      it("should be able to send a POST request", async () => {
+        const payload = JSON.stringify({ "hello": "bun" });
+        const result = await doHttp2Request(
+          HTTPS_SERVER,
+          { ":path": "/post", "test-header": "test-value", ":method": "POST" },
+          payload,
+        );
+        let parsed;
+        expect(() => (parsed = JSON.parse(result.data))).not.toThrow();
+        expect(parsed.url).toBe(`${HTTPS_SERVER}/post`);
+        expect(parsed.headers["test-header"]).toBe("test-value");
+        expect(parsed.json).toEqual({ "hello": "bun" });
+        expect(parsed.data).toEqual(payload);
+      });
+      it("should be able to send data using end", async () => {
+        const payload = JSON.stringify({ "hello": "bun" });
+        const { promise, resolve, reject } = Promise.withResolvers();
+        const client = http2.connect(HTTPS_SERVER, TLS_OPTIONS);
+        client.on("error", reject);
+        const req = client.request({ ":path": "/post", "test-header": "test-value", ":method": "POST" });
+        let response_headers = null;
+        req.on("response", (headers, flags) => {
+          response_headers = headers;
+        });
+        req.setEncoding("utf8");
+        let data = "";
+        req.on("data", chunk => {
+          data += chunk;
+        });
+        req.on("end", () => {
+          resolve({ data, headers: response_headers });
           client.close();
         });
-      } catch (err) {
-        resolve(err);
-        client.close();
-      }
-    });
-    const result = await promise;
-    expect(result).toBeDefined();
-    expect(result.code).toBe("ERR_INVALID_ARG_TYPE");
-  });
-  it("stream event should work", async () => {
-    const { promise, resolve, reject } = Promise.withResolvers();
-    const client = http2.connect(HTTPS_SERVER, TLS_OPTIONS);
-    client.on("error", reject);
-    client.on("stream", stream => {
-      resolve(stream);
-      client.close();
-    });
-    client.request({ ":path": "/" }).end();
-    const stream = await promise;
-    expect(stream).toBeDefined();
-    expect(stream.id).toBe(1);
-  });
-  it("should wait request to be sent before closing", async () => {
-    const { promise, resolve, reject } = Promise.withResolvers();
-    const client = http2.connect(HTTPS_SERVER, TLS_OPTIONS);
-    client.on("error", reject);
-    const req = client.request({ ":path": "/" });
-    let response_headers = null;
-    req.on("response", (headers, flags) => {
-      response_headers = headers;
-    });
-    client.close(resolve);
-    req.end();
-    await promise;
-    expect(response_headers).toBeTruthy();
-    expect(response_headers[":status"]).toBe(200);
-  });
-  it("wantTrailers should work", async () => {
-    const { promise, resolve, reject } = Promise.withResolvers();
-    const client = http2.connect(HTTPS_SERVER, TLS_OPTIONS);
-    client.on("error", reject);
-    const headers = { ":path": "/", ":method": "POST", "x-wait-trailer": "true" };
-    const req = client.request(headers, {
-      waitForTrailers: true,
-    });
-    req.setEncoding("utf8");
-    let response_headers;
-    req.on("response", headers => {
-      response_headers = headers;
-    });
-    let trailers = { "x-trailer": "hello" };
-    req.on("wantTrailers", () => {
-      req.sendTrailers(trailers);
-    });
-    let data = "";
-    req.on("data", chunk => {
-      data += chunk;
-      client.close();
-    });
-    req.on("error", reject);
-    req.on("end", () => {
-      resolve({ data, headers: response_headers });
-      client.close();
-    });
-    req.end("hello");
-    const response = await promise;
-    let parsed;
-    expect(() => (parsed = JSON.parse(response.data))).not.toThrow();
-    expect(parsed.headers[":method"]).toEqual(headers[":method"]);
-    expect(parsed.headers[":path"]).toEqual(headers[":path"]);
-    expect(parsed.headers["x-wait-trailer"]).toEqual(headers["x-wait-trailer"]);
-    expect(parsed.trailers).toEqual(trailers);
-    expect(response.headers[":status"]).toBe(200);
-    expect(response.headers["set-cookie"]).toEqual([
-      "a=b",
-      "c=d; Wed, 21 Oct 2015 07:28:00 GMT; Secure; HttpOnly",
-      "e=f",
-    ]);
-  });
-
-  it("should not leak memory", () => {
-    const { stdout, exitCode } = Bun.spawnSync({
-      cmd: [bunExe(), "--smol", "run", path.join(import.meta.dir, "node-http2-memory-leak.js")],
-      env: {
-        ...bunEnv,
-        BUN_JSC_forceRAMSize: (1024 * 1024 * 64).toString("10"),
-        HTTP2_SERVER_INFO: JSON.stringify(nodeEchoServer_),
-        HTTP2_SERVER_TLS: JSON.stringify(TLS_OPTIONS),
-      },
-      stderr: "inherit",
-      stdin: "inherit",
-      stdout: "inherit",
-    });
-    expect(exitCode).toBe(0);
-  }, 100000);
-
-  it("should receive goaway", async () => {
-    const { promise, resolve, reject } = Promise.withResolvers();
-    const server = await nodeDynamicServer(
-      "http2.away.1.js",
-      `
-    server.on("stream", (stream, headers, flags) => {
-      stream.session.goaway(http2.constants.NGHTTP2_CONNECT_ERROR, 0, Buffer.from("123456"));
-    });
-  `,
-    );
-    try {
-      const client = http2.connect(server.url);
-      client.on("goaway", (...params) => resolve(params));
-      client.on("error", reject);
-      client.on("connect", () => {
-        const req = client.request({ ":path": "/" });
-        req.on("error", err => {
-          if (err.errno !== http2.constants.NGHTTP2_CONNECT_ERROR) {
-            reject(err);
-          }
-        });
-        req.end();
+        req.end(payload);
+        const result = await promise;
+        let parsed;
+        expect(() => (parsed = JSON.parse(result.data))).not.toThrow();
+        expect(parsed.url).toBe(`${HTTPS_SERVER}/post`);
+        expect(parsed.headers["test-header"]).toBe("test-value");
+        expect(parsed.json).toEqual({ "hello": "bun" });
+        expect(parsed.data).toEqual(payload);
       });
-      const result = await promise;
-      expect(result).toBeDefined();
-      const [code, lastStreamID, opaqueData] = result;
-      expect(code).toBe(http2.constants.NGHTTP2_CONNECT_ERROR);
-      expect(lastStreamID).toBe(0);
-      expect(opaqueData.toString()).toBe("123456");
-    } finally {
-      server.subprocess.kill();
-    }
-  });
-  it("should receive goaway without debug data", async () => {
-    const { promise, resolve, reject } = Promise.withResolvers();
-    const server = await nodeDynamicServer(
-      "http2.away.2.js",
-      `
-    server.on("stream", (stream, headers, flags) => {
-      stream.session.goaway(http2.constants.NGHTTP2_CONNECT_ERROR, 0);
-    });
-  `,
-    );
-    try {
-      const client = http2.connect(server.url);
-      client.on("goaway", (...params) => resolve(params));
-      client.on("error", reject);
-      client.on("connect", () => {
-        const req = client.request({ ":path": "/" });
-        req.on("error", err => {
-          if (err.errno !== http2.constants.NGHTTP2_CONNECT_ERROR) {
-            reject(err);
-          }
-        });
-        req.end();
-      });
-      const result = await promise;
-      expect(result).toBeDefined();
-      const [code, lastStreamID, opaqueData] = result;
-      expect(code).toBe(http2.constants.NGHTTP2_CONNECT_ERROR);
-      expect(lastStreamID).toBe(0);
-      expect(opaqueData.toString()).toBe("");
-    } finally {
-      server.subprocess.kill();
-    }
-  });
-  it("should not be able to write on socket", done => {
-    const client = http2.connect(HTTPS_SERVER, TLS_OPTIONS, (session, socket) => {
-      try {
-        client.socket.write("hello");
-        client.socket.end();
-        expect().fail("unreachable");
-      } catch (err) {
-        try {
-          expect(err.code).toBe("ERR_HTTP2_NO_SOCKET_MANIPULATION");
-        } catch (err) {
-          done(err);
+      it("should be able to mutiplex GET requests", async () => {
+        const results = await doMultiplexHttp2Request(HTTPS_SERVER, [
+          { headers: { ":path": "/get" } },
+          { headers: { ":path": "/get" } },
+          { headers: { ":path": "/get" } },
+          { headers: { ":path": "/get" } },
+          { headers: { ":path": "/get" } },
+        ]);
+        expect(results.length).toBe(5);
+        for (let i = 0; i < results.length; i++) {
+          let parsed;
+          expect(() => (parsed = JSON.parse(results[i].data))).not.toThrow();
+          expect(parsed.url).toBe(`${HTTPS_SERVER}/get`);
         }
-        done();
-      }
-    });
-  });
-  it("should handle bad GOAWAY server frame size", done => {
-    const server = net.createServer(socket => {
-      const settings = new http2utils.SettingsFrame(true);
-      socket.write(settings.data);
-      const frame = new http2utils.Frame(7, 7, 0, 0).data;
-      socket.write(Buffer.concat([frame, Buffer.alloc(7)]));
-    });
-    server.listen(0, "127.0.0.1", async () => {
-      const url = `http://127.0.0.1:${server.address().port}`;
-      try {
-        const { promise, resolve } = Promise.withResolvers();
-        const client = http2.connect(url);
-        client.on("error", resolve);
-        client.on("connect", () => {
-          const req = client.request({ ":path": "/" });
-          req.end();
+      });
+      it("should be able to mutiplex POST requests", async () => {
+        const results = await doMultiplexHttp2Request(HTTPS_SERVER, [
+          { headers: { ":path": "/post", ":method": "POST" }, payload: JSON.stringify({ "request": 1 }) },
+          { headers: { ":path": "/post", ":method": "POST" }, payload: JSON.stringify({ "request": 2 }) },
+          { headers: { ":path": "/post", ":method": "POST" }, payload: JSON.stringify({ "request": 3 }) },
+          { headers: { ":path": "/post", ":method": "POST" }, payload: JSON.stringify({ "request": 4 }) },
+          { headers: { ":path": "/post", ":method": "POST" }, payload: JSON.stringify({ "request": 5 }) },
+        ]);
+        expect(results.length).toBe(5);
+        for (let i = 0; i < results.length; i++) {
+          let parsed;
+          expect(() => (parsed = JSON.parse(results[i].data))).not.toThrow();
+          expect(parsed.url).toBe(`${HTTPS_SERVER}/post`);
+          expect([1, 2, 3, 4, 5]).toContain(parsed.json?.request);
+        }
+      });
+      it("constants", () => {
+        expect(http2.constants).toEqual({
+          "NGHTTP2_ERR_FRAME_SIZE_ERROR": -522,
+          "NGHTTP2_SESSION_SERVER": 0,
+          "NGHTTP2_SESSION_CLIENT": 1,
+          "NGHTTP2_STREAM_STATE_IDLE": 1,
+          "NGHTTP2_STREAM_STATE_OPEN": 2,
+          "NGHTTP2_STREAM_STATE_RESERVED_LOCAL": 3,
+          "NGHTTP2_STREAM_STATE_RESERVED_REMOTE": 4,
+          "NGHTTP2_STREAM_STATE_HALF_CLOSED_LOCAL": 5,
+          "NGHTTP2_STREAM_STATE_HALF_CLOSED_REMOTE": 6,
+          "NGHTTP2_STREAM_STATE_CLOSED": 7,
+          "NGHTTP2_FLAG_NONE": 0,
+          "NGHTTP2_FLAG_END_STREAM": 1,
+          "NGHTTP2_FLAG_END_HEADERS": 4,
+          "NGHTTP2_FLAG_ACK": 1,
+          "NGHTTP2_FLAG_PADDED": 8,
+          "NGHTTP2_FLAG_PRIORITY": 32,
+          "DEFAULT_SETTINGS_HEADER_TABLE_SIZE": 4096,
+          "DEFAULT_SETTINGS_ENABLE_PUSH": 1,
+          "DEFAULT_SETTINGS_MAX_CONCURRENT_STREAMS": 4294967295,
+          "DEFAULT_SETTINGS_INITIAL_WINDOW_SIZE": 65535,
+          "DEFAULT_SETTINGS_MAX_FRAME_SIZE": 16384,
+          "DEFAULT_SETTINGS_MAX_HEADER_LIST_SIZE": 65535,
+          "DEFAULT_SETTINGS_ENABLE_CONNECT_PROTOCOL": 0,
+          "MAX_MAX_FRAME_SIZE": 16777215,
+          "MIN_MAX_FRAME_SIZE": 16384,
+          "MAX_INITIAL_WINDOW_SIZE": 2147483647,
+          "NGHTTP2_SETTINGS_HEADER_TABLE_SIZE": 1,
+          "NGHTTP2_SETTINGS_ENABLE_PUSH": 2,
+          "NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS": 3,
+          "NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE": 4,
+          "NGHTTP2_SETTINGS_MAX_FRAME_SIZE": 5,
+          "NGHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE": 6,
+          "NGHTTP2_SETTINGS_ENABLE_CONNECT_PROTOCOL": 8,
+          "PADDING_STRATEGY_NONE": 0,
+          "PADDING_STRATEGY_ALIGNED": 1,
+          "PADDING_STRATEGY_MAX": 2,
+          "PADDING_STRATEGY_CALLBACK": 1,
+          "NGHTTP2_NO_ERROR": 0,
+          "NGHTTP2_PROTOCOL_ERROR": 1,
+          "NGHTTP2_INTERNAL_ERROR": 2,
+          "NGHTTP2_FLOW_CONTROL_ERROR": 3,
+          "NGHTTP2_SETTINGS_TIMEOUT": 4,
+          "NGHTTP2_STREAM_CLOSED": 5,
+          "NGHTTP2_FRAME_SIZE_ERROR": 6,
+          "NGHTTP2_REFUSED_STREAM": 7,
+          "NGHTTP2_CANCEL": 8,
+          "NGHTTP2_COMPRESSION_ERROR": 9,
+          "NGHTTP2_CONNECT_ERROR": 10,
+          "NGHTTP2_ENHANCE_YOUR_CALM": 11,
+          "NGHTTP2_INADEQUATE_SECURITY": 12,
+          "NGHTTP2_HTTP_1_1_REQUIRED": 13,
+          "NGHTTP2_DEFAULT_WEIGHT": 16,
+          "HTTP2_HEADER_STATUS": ":status",
+          "HTTP2_HEADER_METHOD": ":method",
+          "HTTP2_HEADER_AUTHORITY": ":authority",
+          "HTTP2_HEADER_SCHEME": ":scheme",
+          "HTTP2_HEADER_PATH": ":path",
+          "HTTP2_HEADER_PROTOCOL": ":protocol",
+          "HTTP2_HEADER_ACCEPT_ENCODING": "accept-encoding",
+          "HTTP2_HEADER_ACCEPT_LANGUAGE": "accept-language",
+          "HTTP2_HEADER_ACCEPT_RANGES": "accept-ranges",
+          "HTTP2_HEADER_ACCEPT": "accept",
+          "HTTP2_HEADER_ACCESS_CONTROL_ALLOW_CREDENTIALS": "access-control-allow-credentials",
+          "HTTP2_HEADER_ACCESS_CONTROL_ALLOW_HEADERS": "access-control-allow-headers",
+          "HTTP2_HEADER_ACCESS_CONTROL_ALLOW_METHODS": "access-control-allow-methods",
+          "HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN": "access-control-allow-origin",
+          "HTTP2_HEADER_ACCESS_CONTROL_EXPOSE_HEADERS": "access-control-expose-headers",
+          "HTTP2_HEADER_ACCESS_CONTROL_REQUEST_HEADERS": "access-control-request-headers",
+          "HTTP2_HEADER_ACCESS_CONTROL_REQUEST_METHOD": "access-control-request-method",
+          "HTTP2_HEADER_AGE": "age",
+          "HTTP2_HEADER_AUTHORIZATION": "authorization",
+          "HTTP2_HEADER_CACHE_CONTROL": "cache-control",
+          "HTTP2_HEADER_CONNECTION": "connection",
+          "HTTP2_HEADER_CONTENT_DISPOSITION": "content-disposition",
+          "HTTP2_HEADER_CONTENT_ENCODING": "content-encoding",
+          "HTTP2_HEADER_CONTENT_LENGTH": "content-length",
+          "HTTP2_HEADER_CONTENT_TYPE": "content-type",
+          "HTTP2_HEADER_COOKIE": "cookie",
+          "HTTP2_HEADER_DATE": "date",
+          "HTTP2_HEADER_ETAG": "etag",
+          "HTTP2_HEADER_FORWARDED": "forwarded",
+          "HTTP2_HEADER_HOST": "host",
+          "HTTP2_HEADER_IF_MODIFIED_SINCE": "if-modified-since",
+          "HTTP2_HEADER_IF_NONE_MATCH": "if-none-match",
+          "HTTP2_HEADER_IF_RANGE": "if-range",
+          "HTTP2_HEADER_LAST_MODIFIED": "last-modified",
+          "HTTP2_HEADER_LINK": "link",
+          "HTTP2_HEADER_LOCATION": "location",
+          "HTTP2_HEADER_RANGE": "range",
+          "HTTP2_HEADER_REFERER": "referer",
+          "HTTP2_HEADER_SERVER": "server",
+          "HTTP2_HEADER_SET_COOKIE": "set-cookie",
+          "HTTP2_HEADER_STRICT_TRANSPORT_SECURITY": "strict-transport-security",
+          "HTTP2_HEADER_TRANSFER_ENCODING": "transfer-encoding",
+          "HTTP2_HEADER_TE": "te",
+          "HTTP2_HEADER_UPGRADE_INSECURE_REQUESTS": "upgrade-insecure-requests",
+          "HTTP2_HEADER_UPGRADE": "upgrade",
+          "HTTP2_HEADER_USER_AGENT": "user-agent",
+          "HTTP2_HEADER_VARY": "vary",
+          "HTTP2_HEADER_X_CONTENT_TYPE_OPTIONS": "x-content-type-options",
+          "HTTP2_HEADER_X_FRAME_OPTIONS": "x-frame-options",
+          "HTTP2_HEADER_KEEP_ALIVE": "keep-alive",
+          "HTTP2_HEADER_PROXY_CONNECTION": "proxy-connection",
+          "HTTP2_HEADER_X_XSS_PROTECTION": "x-xss-protection",
+          "HTTP2_HEADER_ALT_SVC": "alt-svc",
+          "HTTP2_HEADER_CONTENT_SECURITY_POLICY": "content-security-policy",
+          "HTTP2_HEADER_EARLY_DATA": "early-data",
+          "HTTP2_HEADER_EXPECT_CT": "expect-ct",
+          "HTTP2_HEADER_ORIGIN": "origin",
+          "HTTP2_HEADER_PURPOSE": "purpose",
+          "HTTP2_HEADER_TIMING_ALLOW_ORIGIN": "timing-allow-origin",
+          "HTTP2_HEADER_X_FORWARDED_FOR": "x-forwarded-for",
+          "HTTP2_HEADER_PRIORITY": "priority",
+          "HTTP2_HEADER_ACCEPT_CHARSET": "accept-charset",
+          "HTTP2_HEADER_ACCESS_CONTROL_MAX_AGE": "access-control-max-age",
+          "HTTP2_HEADER_ALLOW": "allow",
+          "HTTP2_HEADER_CONTENT_LANGUAGE": "content-language",
+          "HTTP2_HEADER_CONTENT_LOCATION": "content-location",
+          "HTTP2_HEADER_CONTENT_MD5": "content-md5",
+          "HTTP2_HEADER_CONTENT_RANGE": "content-range",
+          "HTTP2_HEADER_DNT": "dnt",
+          "HTTP2_HEADER_EXPECT": "expect",
+          "HTTP2_HEADER_EXPIRES": "expires",
+          "HTTP2_HEADER_FROM": "from",
+          "HTTP2_HEADER_IF_MATCH": "if-match",
+          "HTTP2_HEADER_IF_UNMODIFIED_SINCE": "if-unmodified-since",
+          "HTTP2_HEADER_MAX_FORWARDS": "max-forwards",
+          "HTTP2_HEADER_PREFER": "prefer",
+          "HTTP2_HEADER_PROXY_AUTHENTICATE": "proxy-authenticate",
+          "HTTP2_HEADER_PROXY_AUTHORIZATION": "proxy-authorization",
+          "HTTP2_HEADER_REFRESH": "refresh",
+          "HTTP2_HEADER_RETRY_AFTER": "retry-after",
+          "HTTP2_HEADER_TRAILER": "trailer",
+          "HTTP2_HEADER_TK": "tk",
+          "HTTP2_HEADER_VIA": "via",
+          "HTTP2_HEADER_WARNING": "warning",
+          "HTTP2_HEADER_WWW_AUTHENTICATE": "www-authenticate",
+          "HTTP2_HEADER_HTTP2_SETTINGS": "http2-settings",
+          "HTTP2_METHOD_ACL": "ACL",
+          "HTTP2_METHOD_BASELINE_CONTROL": "BASELINE-CONTROL",
+          "HTTP2_METHOD_BIND": "BIND",
+          "HTTP2_METHOD_CHECKIN": "CHECKIN",
+          "HTTP2_METHOD_CHECKOUT": "CHECKOUT",
+          "HTTP2_METHOD_CONNECT": "CONNECT",
+          "HTTP2_METHOD_COPY": "COPY",
+          "HTTP2_METHOD_DELETE": "DELETE",
+          "HTTP2_METHOD_GET": "GET",
+          "HTTP2_METHOD_HEAD": "HEAD",
+          "HTTP2_METHOD_LABEL": "LABEL",
+          "HTTP2_METHOD_LINK": "LINK",
+          "HTTP2_METHOD_LOCK": "LOCK",
+          "HTTP2_METHOD_MERGE": "MERGE",
+          "HTTP2_METHOD_MKACTIVITY": "MKACTIVITY",
+          "HTTP2_METHOD_MKCALENDAR": "MKCALENDAR",
+          "HTTP2_METHOD_MKCOL": "MKCOL",
+          "HTTP2_METHOD_MKREDIRECTREF": "MKREDIRECTREF",
+          "HTTP2_METHOD_MKWORKSPACE": "MKWORKSPACE",
+          "HTTP2_METHOD_MOVE": "MOVE",
+          "HTTP2_METHOD_OPTIONS": "OPTIONS",
+          "HTTP2_METHOD_ORDERPATCH": "ORDERPATCH",
+          "HTTP2_METHOD_PATCH": "PATCH",
+          "HTTP2_METHOD_POST": "POST",
+          "HTTP2_METHOD_PRI": "PRI",
+          "HTTP2_METHOD_PROPFIND": "PROPFIND",
+          "HTTP2_METHOD_PROPPATCH": "PROPPATCH",
+          "HTTP2_METHOD_PUT": "PUT",
+          "HTTP2_METHOD_REBIND": "REBIND",
+          "HTTP2_METHOD_REPORT": "REPORT",
+          "HTTP2_METHOD_SEARCH": "SEARCH",
+          "HTTP2_METHOD_TRACE": "TRACE",
+          "HTTP2_METHOD_UNBIND": "UNBIND",
+          "HTTP2_METHOD_UNCHECKOUT": "UNCHECKOUT",
+          "HTTP2_METHOD_UNLINK": "UNLINK",
+          "HTTP2_METHOD_UNLOCK": "UNLOCK",
+          "HTTP2_METHOD_UPDATE": "UPDATE",
+          "HTTP2_METHOD_UPDATEREDIRECTREF": "UPDATEREDIRECTREF",
+          "HTTP2_METHOD_VERSION_CONTROL": "VERSION-CONTROL",
+          "HTTP_STATUS_CONTINUE": 100,
+          "HTTP_STATUS_SWITCHING_PROTOCOLS": 101,
+          "HTTP_STATUS_PROCESSING": 102,
+          "HTTP_STATUS_EARLY_HINTS": 103,
+          "HTTP_STATUS_OK": 200,
+          "HTTP_STATUS_CREATED": 201,
+          "HTTP_STATUS_ACCEPTED": 202,
+          "HTTP_STATUS_NON_AUTHORITATIVE_INFORMATION": 203,
+          "HTTP_STATUS_NO_CONTENT": 204,
+          "HTTP_STATUS_RESET_CONTENT": 205,
+          "HTTP_STATUS_PARTIAL_CONTENT": 206,
+          "HTTP_STATUS_MULTI_STATUS": 207,
+          "HTTP_STATUS_ALREADY_REPORTED": 208,
+          "HTTP_STATUS_IM_USED": 226,
+          "HTTP_STATUS_MULTIPLE_CHOICES": 300,
+          "HTTP_STATUS_MOVED_PERMANENTLY": 301,
+          "HTTP_STATUS_FOUND": 302,
+          "HTTP_STATUS_SEE_OTHER": 303,
+          "HTTP_STATUS_NOT_MODIFIED": 304,
+          "HTTP_STATUS_USE_PROXY": 305,
+          "HTTP_STATUS_TEMPORARY_REDIRECT": 307,
+          "HTTP_STATUS_PERMANENT_REDIRECT": 308,
+          "HTTP_STATUS_BAD_REQUEST": 400,
+          "HTTP_STATUS_UNAUTHORIZED": 401,
+          "HTTP_STATUS_PAYMENT_REQUIRED": 402,
+          "HTTP_STATUS_FORBIDDEN": 403,
+          "HTTP_STATUS_NOT_FOUND": 404,
+          "HTTP_STATUS_METHOD_NOT_ALLOWED": 405,
+          "HTTP_STATUS_NOT_ACCEPTABLE": 406,
+          "HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED": 407,
+          "HTTP_STATUS_REQUEST_TIMEOUT": 408,
+          "HTTP_STATUS_CONFLICT": 409,
+          "HTTP_STATUS_GONE": 410,
+          "HTTP_STATUS_LENGTH_REQUIRED": 411,
+          "HTTP_STATUS_PRECONDITION_FAILED": 412,
+          "HTTP_STATUS_PAYLOAD_TOO_LARGE": 413,
+          "HTTP_STATUS_URI_TOO_LONG": 414,
+          "HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE": 415,
+          "HTTP_STATUS_RANGE_NOT_SATISFIABLE": 416,
+          "HTTP_STATUS_EXPECTATION_FAILED": 417,
+          "HTTP_STATUS_TEAPOT": 418,
+          "HTTP_STATUS_MISDIRECTED_REQUEST": 421,
+          "HTTP_STATUS_UNPROCESSABLE_ENTITY": 422,
+          "HTTP_STATUS_LOCKED": 423,
+          "HTTP_STATUS_FAILED_DEPENDENCY": 424,
+          "HTTP_STATUS_TOO_EARLY": 425,
+          "HTTP_STATUS_UPGRADE_REQUIRED": 426,
+          "HTTP_STATUS_PRECONDITION_REQUIRED": 428,
+          "HTTP_STATUS_TOO_MANY_REQUESTS": 429,
+          "HTTP_STATUS_REQUEST_HEADER_FIELDS_TOO_LARGE": 431,
+          "HTTP_STATUS_UNAVAILABLE_FOR_LEGAL_REASONS": 451,
+          "HTTP_STATUS_INTERNAL_SERVER_ERROR": 500,
+          "HTTP_STATUS_NOT_IMPLEMENTED": 501,
+          "HTTP_STATUS_BAD_GATEWAY": 502,
+          "HTTP_STATUS_SERVICE_UNAVAILABLE": 503,
+          "HTTP_STATUS_GATEWAY_TIMEOUT": 504,
+          "HTTP_STATUS_HTTP_VERSION_NOT_SUPPORTED": 505,
+          "HTTP_STATUS_VARIANT_ALSO_NEGOTIATES": 506,
+          "HTTP_STATUS_INSUFFICIENT_STORAGE": 507,
+          "HTTP_STATUS_LOOP_DETECTED": 508,
+          "HTTP_STATUS_BANDWIDTH_LIMIT_EXCEEDED": 509,
+          "HTTP_STATUS_NOT_EXTENDED": 510,
+          "HTTP_STATUS_NETWORK_AUTHENTICATION_REQUIRED": 511,
         });
-        const result = await promise;
-        expect(result).toBeDefined();
-        expect(result.code).toBe("ERR_HTTP2_SESSION_ERROR");
-        expect(result.message).toBe("Session closed with error code 6");
-        done();
-      } catch (err) {
-        done(err);
-      } finally {
-        server.close();
-      }
-    });
-  });
-  it("should handle bad DATA_FRAME server frame size", done => {
-    const { promise: waitToWrite, resolve: allowWrite } = Promise.withResolvers();
-    const server = net.createServer(async socket => {
-      const settings = new http2utils.SettingsFrame(true);
-      socket.write(settings.data);
-      await waitToWrite;
-      const frame = new http2utils.DataFrame(1, Buffer.alloc(16384 * 2), 0, 1).data;
-      socket.write(frame);
-    });
-    server.listen(0, "127.0.0.1", async () => {
-      const url = `http://127.0.0.1:${server.address().port}`;
-      try {
-        const { promise, resolve } = Promise.withResolvers();
-        const client = http2.connect(url);
-        client.on("error", resolve);
-        client.on("connect", () => {
-          const req = client.request({ ":path": "/" });
-          req.end();
-          allowWrite();
+      });
+      it("getDefaultSettings", () => {
+        const settings = http2.getDefaultSettings();
+        expect(settings).toEqual({
+          enableConnectProtocol: false,
+          headerTableSize: 4096,
+          enablePush: false,
+          initialWindowSize: 65535,
+          maxFrameSize: 16384,
+          maxConcurrentStreams: 4294967295,
+          maxHeaderListSize: 65535,
+          maxHeaderSize: 65535,
         });
-        const result = await promise;
-        expect(result).toBeDefined();
-        expect(result.code).toBe("ERR_HTTP2_SESSION_ERROR");
-        expect(result.message).toBe("Session closed with error code 6");
-        done();
-      } catch (err) {
-        done(err);
-      } finally {
-        server.close();
-      }
-    });
-  });
-  it("should handle bad RST_FRAME server frame size (no stream)", done => {
-    const { promise: waitToWrite, resolve: allowWrite } = Promise.withResolvers();
-    const server = net.createServer(async socket => {
-      const settings = new http2utils.SettingsFrame(true);
-      socket.write(settings.data);
-      await waitToWrite;
-      const frame = new http2utils.Frame(4, 3, 0, 0).data;
-      socket.write(Buffer.concat([frame, Buffer.alloc(4)]));
-    });
-    server.listen(0, "127.0.0.1", async () => {
-      const url = `http://127.0.0.1:${server.address().port}`;
-      try {
-        const { promise, resolve } = Promise.withResolvers();
-        const client = http2.connect(url);
-        client.on("error", resolve);
-        client.on("connect", () => {
-          const req = client.request({ ":path": "/" });
-          req.end();
-          allowWrite();
+      });
+      it("getPackedSettings/getUnpackedSettings", () => {
+        const settings = {
+          headerTableSize: 1,
+          enablePush: false,
+          initialWindowSize: 2,
+          maxFrameSize: 32768,
+          maxConcurrentStreams: 4,
+          maxHeaderListSize: 5,
+          maxHeaderSize: 5,
+          enableConnectProtocol: false,
+        };
+        const buffer = http2.getPackedSettings(settings);
+        expect(buffer.byteLength).toBe(36);
+        expect(http2.getUnpackedSettings(buffer)).toEqual(settings);
+      });
+      it("getUnpackedSettings should throw if buffer is too small", () => {
+        const buffer = new ArrayBuffer(1);
+        expect(() => http2.getUnpackedSettings(buffer)).toThrow(
+          /Expected buf to be a Buffer of at least 6 bytes and a multiple of 6 bytes/,
+        );
+      });
+      it("getUnpackedSettings should throw if buffer is not a multiple of 6 bytes", () => {
+        const buffer = new ArrayBuffer(7);
+        expect(() => http2.getUnpackedSettings(buffer)).toThrow(
+          /Expected buf to be a Buffer of at least 6 bytes and a multiple of 6 bytes/,
+        );
+      });
+      it("getUnpackedSettings should throw if buffer is not a buffer", () => {
+        const buffer = {};
+        expect(() => http2.getUnpackedSettings(buffer)).toThrow(/Expected buf to be a Buffer/);
+      });
+      it("headers cannot be bigger than 65536 bytes", async () => {
+        try {
+          await doHttp2Request(HTTPS_SERVER, { ":path": "/", "test-header": "A".repeat(90000) });
+          expect("unreachable").toBe(true);
+        } catch (err) {
+          expect(err.code).toBe("ERR_HTTP2_STREAM_ERROR");
+          expect(err.message).toBe("Stream closed with error code NGHTTP2_COMPRESSION_ERROR");
+        }
+      });
+      it("should be destroyed after close", async () => {
+        const { promise, resolve, reject: promiseReject } = Promise.withResolvers();
+        const client = http2.connect(`${HTTPS_SERVER}/get`, TLS_OPTIONS);
+        client.on("error", promiseReject);
+        client.on("close", resolve);
+        function reject(err) {
+          promiseReject(err);
+          client.close();
+        }
+        const req = client.request({
+          ":path": "/get",
         });
-        const result = await promise;
-        expect(result).toBeDefined();
-        expect(result.code).toBe("ERR_HTTP2_SESSION_ERROR");
-        expect(result.message).toBe("Session closed with error code 1");
-        done();
-      } catch (err) {
-        done(err);
-      } finally {
-        server.close();
-      }
-    });
-  });
-  it("should handle bad RST_FRAME server frame size (less than allowed)", done => {
-    const { promise: waitToWrite, resolve: allowWrite } = Promise.withResolvers();
-    const server = net.createServer(async socket => {
-      const settings = new http2utils.SettingsFrame(true);
-      socket.write(settings.data);
-      await waitToWrite;
-      const frame = new http2utils.Frame(3, 3, 0, 1).data;
-      socket.write(Buffer.concat([frame, Buffer.alloc(3)]));
-    });
-    server.listen(0, "127.0.0.1", async () => {
-      const url = `http://127.0.0.1:${server.address().port}`;
-      try {
-        const { promise, resolve } = Promise.withResolvers();
-        const client = http2.connect(url);
-        client.on("error", resolve);
-        client.on("connect", () => {
-          const req = client.request({ ":path": "/" });
-          req.end();
-          allowWrite();
+        req.resume();
+        req.on("error", reject);
+        req.on("end", () => {
+          client.close();
         });
-        const result = await promise;
-        expect(result).toBeDefined();
-        expect(result.code).toBe("ERR_HTTP2_SESSION_ERROR");
-        expect(result.message).toBe("Session closed with error code 6");
-        done();
-      } catch (err) {
-        done(err);
-      } finally {
-        server.close();
-      }
-    });
-  });
-  it("should handle bad RST_FRAME server frame size (more than allowed)", done => {
-    const { promise: waitToWrite, resolve: allowWrite } = Promise.withResolvers();
-    const server = net.createServer(async socket => {
-      const settings = new http2utils.SettingsFrame(true);
-      socket.write(settings.data);
-      await waitToWrite;
-      const buffer = Buffer.alloc(16384 * 2);
-      const frame = new http2utils.Frame(buffer.byteLength, 3, 0, 1).data;
-      socket.write(Buffer.concat([frame, buffer]));
-    });
-    server.listen(0, "127.0.0.1", async () => {
-      const url = `http://127.0.0.1:${server.address().port}`;
-      try {
-        const { promise, resolve } = Promise.withResolvers();
-        const client = http2.connect(url);
-        client.on("error", resolve);
-        client.on("connect", () => {
-          const req = client.request({ ":path": "/" });
-          req.end();
-          allowWrite();
+        req.end();
+        await promise;
+        expect(client.destroyed).toBe(true);
+      });
+      it("should be destroyed after destroy", async () => {
+        const { promise, resolve, reject: promiseReject } = Promise.withResolvers();
+        const client = http2.connect(`${HTTPS_SERVER}/get`, TLS_OPTIONS);
+        client.on("error", promiseReject);
+        client.on("close", resolve);
+        function reject(err) {
+          promiseReject(err);
+          client.destroy();
+        }
+        const req = client.request({
+          ":path": "/get",
         });
+        req.on("error", reject);
+        req.resume();
+        req.on("end", () => {
+          client.destroy();
+        });
+        req.end();
+        await promise;
+        expect(client.destroyed).toBe(true);
+      });
+      it("should fail to connect over HTTP/1.1", async () => {
+        const tls = TLS_CERT;
+        using server = Bun.serve({
+          port: 0,
+          hostname: "127.0.0.1",
+          tls: {
+            ...tls,
+            ca: TLS_CERT.ca,
+          },
+          fetch() {
+            return new Response("hello");
+          },
+        });
+        const url = `https://127.0.0.1:${server.port}`;
+        try {
+          await doHttp2Request(url, { ":path": "/" }, null, TLS_OPTIONS);
+          expect("unreachable").toBe(true);
+        } catch (err) {
+          expect(err.code).toBe("ERR_HTTP2_ERROR");
+        }
+      });
+      it("works with Duplex", async () => {
+        class JSSocket extends Duplex {
+          constructor(socket) {
+            super({ emitClose: true });
+            socket.on("close", () => this.destroy());
+            socket.on("data", data => this.push(data));
+            this.socket = socket;
+          }
+          _write(data, encoding, callback) {
+            this.socket.write(data, encoding, callback);
+          }
+          _read(size) {}
+          _final(cb) {
+            cb();
+          }
+        }
+        const { promise, resolve, reject } = Promise.withResolvers();
+        const socket = tls
+          .connect(
+            {
+              rejectUnauthorized: false,
+              host: new URL(HTTPS_SERVER).hostname,
+              port: new URL(HTTPS_SERVER).port,
+              ALPNProtocols: ["h2"],
+              ...TLS_OPTIONS,
+            },
+            () => {
+              doHttp2Request(`${HTTPS_SERVER}/get`, { ":path": "/get" }, null, {
+                createConnection: () => {
+                  return new JSSocket(socket);
+                },
+              }).then(resolve, reject);
+            },
+          )
+          .on("error", reject);
         const result = await promise;
-        expect(result).toBeDefined();
-        expect(result.code).toBe("ERR_HTTP2_SESSION_ERROR");
-        expect(result.message).toBe("Session closed with error code 6");
-        done();
-      } catch (err) {
-        done(err);
-      } finally {
-        server.close();
-      }
-    });
-  });
+        let parsed;
+        expect(() => (parsed = JSON.parse(result.data))).not.toThrow();
+        expect(parsed.url).toBe(`${HTTPS_SERVER}/get`);
+        socket.destroy();
+      });
+      it("close callback", async () => {
+        const { promise, resolve, reject } = Promise.withResolvers();
+        const client = http2.connect(`${HTTPS_SERVER}/get`, TLS_OPTIONS);
+        client.on("error", reject);
+        client.close(resolve);
+        await promise;
+        expect(client.destroyed).toBe(true);
+      });
+      it("is possible to abort request", async () => {
+        const abortController = new AbortController();
+        const promise = doHttp2Request(`${HTTPS_SERVER}/get`, { ":path": "/get" }, null, null, {
+          signal: abortController.signal,
+        });
+        abortController.abort();
+        try {
+          await promise;
+          expect("unreachable").toBe(true);
+        } catch (err) {
+          expect(err.code).toBe("ABORT_ERR");
+        }
+      });
+      it("aborted event should work with abortController", async () => {
+        const abortController = new AbortController();
+        const { promise, resolve, reject } = Promise.withResolvers();
+        const client = http2.connect(HTTPS_SERVER, TLS_OPTIONS);
+        client.on("error", reject);
+        const req = client.request({ ":path": "/post", ":method": "POST" }, { signal: abortController.signal });
+        req.on("aborted", resolve);
+        req.on("error", err => {
+          if (err.code !== "ABORT_ERR") {
+            reject(err);
+          }
+        });
+        req.on("end", () => {
+          reject();
+          client.close();
+        });
+        abortController.abort();
+        const result = await promise;
+        expect(result).toBeUndefined();
+        expect(req.aborted).toBeTrue();
+        expect(req.rstCode).toBe(http2.constants.NGHTTP2_CANCEL);
+      });
 
-  it("should handle bad CONTINUATION_FRAME server frame size", done => {
-    const { promise: waitToWrite, resolve: allowWrite } = Promise.withResolvers();
-    const server = net.createServer(async socket => {
-      const settings = new http2utils.SettingsFrame(true);
-      socket.write(settings.data);
-      await waitToWrite;
+      it("aborted event should work with aborted signal", async () => {
+        const { promise, resolve, reject } = Promise.withResolvers();
+        const client = http2.connect(HTTPS_SERVER, TLS_OPTIONS);
+        client.on("error", reject);
+        const req = client.request({ ":path": "/post", ":method": "POST" }, { signal: AbortSignal.abort() });
+        req.on("aborted", reject); // will not be emited because we could not start the request at all
+        req.on("error", err => {
+          if (err.name !== "AbortError") {
+            reject(err);
+          } else {
+            resolve();
+          }
+        });
+        req.on("end", () => {
+          client.close();
+        });
+        const result = await promise;
+        expect(result).toBeUndefined();
+        expect(req.rstCode).toBe(http2.constants.NGHTTP2_CANCEL);
+        expect(req.aborted).toBeTrue(); // will be true in this case
+      });
 
-      const frame = new http2utils.HeadersFrame(1, http2utils.kFakeResponseHeaders, 0, true, false);
-      socket.write(frame.data);
-      const continuationFrame = new http2utils.ContinuationFrame(1, http2utils.kFakeResponseHeaders, 0, true, false);
-      socket.write(continuationFrame.data);
-    });
-    server.listen(0, "127.0.0.1", async () => {
-      const url = `http://127.0.0.1:${server.address().port}`;
-      try {
-        const { promise, resolve } = Promise.withResolvers();
-        const client = http2.connect(url);
-        client.on("error", resolve);
+      it("state should work", async () => {
+        const { promise, resolve, reject } = Promise.withResolvers();
+        const client = http2.connect(HTTPS_SERVER, TLS_OPTIONS);
+        client.on("error", reject);
+        const req = client.request({ ":path": "/", "test-header": "test-value" });
+        {
+          const state = req.state;
+          expect(typeof state).toBe("object");
+          expect(typeof state.state).toBe("number");
+          expect(typeof state.weight).toBe("number");
+          expect(typeof state.sumDependencyWeight).toBe("number");
+          expect(typeof state.localClose).toBe("number");
+          expect(typeof state.remoteClose).toBe("number");
+          expect(typeof state.localWindowSize).toBe("number");
+        }
+        // Test Session State.
+        {
+          const state = client.state;
+          expect(typeof state).toBe("object");
+          expect(typeof state.effectiveLocalWindowSize).toBe("number");
+          expect(typeof state.effectiveRecvDataLength).toBe("number");
+          expect(typeof state.nextStreamID).toBe("number");
+          expect(typeof state.localWindowSize).toBe("number");
+          expect(typeof state.lastProcStreamID).toBe("number");
+          expect(typeof state.remoteWindowSize).toBe("number");
+          expect(typeof state.outboundQueueSize).toBe("number");
+          expect(typeof state.deflateDynamicTableSize).toBe("number");
+          expect(typeof state.inflateDynamicTableSize).toBe("number");
+        }
+        let response_headers = null;
+        req.on("response", (headers, flags) => {
+          response_headers = headers;
+        });
+        req.resume();
+        req.on("end", () => {
+          resolve();
+          client.close();
+        });
+        await promise;
+        expect(response_headers[":status"]).toBe(200);
+      });
+      it("settings and properties should work", async () => {
+        const assertSettings = settings => {
+          expect(settings).toBeDefined();
+          expect(typeof settings).toBe("object");
+          expect(typeof settings.headerTableSize).toBe("number");
+          expect(typeof settings.enablePush).toBe("boolean");
+          expect(typeof settings.initialWindowSize).toBe("number");
+          expect(typeof settings.maxFrameSize).toBe("number");
+          expect(typeof settings.maxConcurrentStreams).toBe("number");
+          expect(typeof settings.maxHeaderListSize).toBe("number");
+          expect(typeof settings.maxHeaderSize).toBe("number");
+        };
+        const { promise, resolve, reject } = Promise.withResolvers();
+        const client = http2.connect("https://www.example.com");
+        client.on("error", reject);
+        expect(client.connecting).toBeTrue();
+        expect(client.alpnProtocol).toBeUndefined();
+        expect(client.encrypted).toBeTrue();
+        expect(client.closed).toBeFalse();
+        expect(client.destroyed).toBeFalse();
+        expect(client.originSet.length).toBe(0);
+        expect(client.pendingSettingsAck).toBeTrue();
+        let received_origin = null;
+        client.on("origin", origin => {
+          received_origin = origin;
+        });
+        assertSettings(client.localSettings);
+        expect(client.remoteSettings).toBeNull();
+        const headers = { ":path": "/" };
+        const req = client.request(headers);
+        expect(req.closed).toBeFalse();
+        expect(req.destroyed).toBeFalse();
+        // we always asign a stream id to the request
+        expect(req.pending).toBeFalse();
+        expect(typeof req.id).toBe("number");
+        expect(req.session).toBeDefined();
+        expect(req.sentHeaders).toEqual({
+          ":authority": "www.example.com",
+          ":method": "GET",
+          ":path": "/",
+          ":scheme": "https",
+        });
+        expect(req.sentTrailers).toBeUndefined();
+        expect(req.sentInfoHeaders.length).toBe(0);
+        expect(req.scheme).toBe("https");
+        let response_headers = null;
+        req.on("response", (headers, flags) => {
+          response_headers = headers;
+        });
+        req.resume();
+        req.on("end", () => {
+          resolve();
+        });
+        await promise;
+        expect(response_headers[":status"]).toBe(200);
+        const settings = client.remoteSettings;
+        const localSettings = client.localSettings;
+        assertSettings(settings);
+        assertSettings(localSettings);
+        expect(settings).toEqual(client.remoteSettings);
+        expect(localSettings).toEqual(client.localSettings);
+        client.destroy();
+        expect(client.connecting).toBeFalse();
+        expect(client.alpnProtocol).toBe("h2");
+        expect(client.originSet.length).toBe(1);
+        expect(client.originSet).toEqual(received_origin);
+        expect(client.originSet[0]).toBe("www.example.com");
+        expect(client.pendingSettingsAck).toBeFalse();
+        expect(client.destroyed).toBeTrue();
+        expect(client.closed).toBeTrue();
+        expect(req.closed).toBeTrue();
+        expect(req.destroyed).toBeTrue();
+        expect(req.rstCode).toBe(http2.constants.NGHTTP2_NO_ERROR);
+      });
+      it("ping events should work", async () => {
+        const { promise, resolve, reject } = Promise.withResolvers();
+        const client = http2.connect(HTTPS_SERVER, TLS_OPTIONS);
+        client.on("error", reject);
         client.on("connect", () => {
-          const req = client.request({ ":path": "/" });
-          req.end();
-          allowWrite();
+          client.ping(Buffer.from("12345678"), (err, duration, payload) => {
+            if (err) {
+              reject(err);
+            } else {
+              resolve({ duration, payload });
+            }
+            client.close();
+          });
+        });
+        let received_ping;
+        client.on("ping", payload => {
+          received_ping = payload;
+        });
+        const result = await promise;
+        expect(typeof result.duration).toBe("number");
+        expect(result.payload).toBeInstanceOf(Buffer);
+        expect(result.payload.byteLength).toBe(8);
+        expect(received_ping).toBeInstanceOf(Buffer);
+        expect(received_ping.byteLength).toBe(8);
+        expect(received_ping).toEqual(result.payload);
+        expect(received_ping).toEqual(Buffer.from("12345678"));
+      });
+      it("ping without events should work", async () => {
+        const { promise, resolve, reject } = Promise.withResolvers();
+        const client = http2.connect(HTTPS_SERVER, TLS_OPTIONS);
+        client.on("error", reject);
+        client.on("connect", () => {
+          client.ping((err, duration, payload) => {
+            if (err) {
+              reject(err);
+            } else {
+              resolve({ duration, payload });
+            }
+            client.close();
+          });
+        });
+        let received_ping;
+        client.on("ping", payload => {
+          received_ping = payload;
+        });
+        const result = await promise;
+        expect(typeof result.duration).toBe("number");
+        expect(result.payload).toBeInstanceOf(Buffer);
+        expect(result.payload.byteLength).toBe(8);
+        expect(received_ping).toBeInstanceOf(Buffer);
+        expect(received_ping.byteLength).toBe(8);
+        expect(received_ping).toEqual(result.payload);
+      });
+      it("ping with wrong payload length events should error", async () => {
+        const { promise, resolve, reject } = Promise.withResolvers();
+        const client = http2.connect(HTTPS_SERVER, TLS_OPTIONS);
+        client.on("error", reject);
+        client.on("connect", () => {
+          client.ping(Buffer.from("oops"), (err, duration, payload) => {
+            if (err) {
+              resolve(err);
+            } else {
+              reject("unreachable");
+            }
+            client.close();
+          });
         });
         const result = await promise;
         expect(result).toBeDefined();
-        expect(result.code).toBe("ERR_HTTP2_SESSION_ERROR");
-        expect(result.message).toBe("Session closed with error code 1");
-        done();
-      } catch (err) {
-        done(err);
-      } finally {
-        server.close();
-      }
-    });
-  });
-
-  it("should handle bad PRIOTITY_FRAME server frame size", done => {
-    const { promise: waitToWrite, resolve: allowWrite } = Promise.withResolvers();
-    const server = net.createServer(async socket => {
-      const settings = new http2utils.SettingsFrame(true);
-      socket.write(settings.data);
-      await waitToWrite;
-
-      const frame = new http2utils.Frame(4, 2, 0, 1).data;
-      socket.write(Buffer.concat([frame, Buffer.alloc(4)]));
-    });
-    server.listen(0, "127.0.0.1", async () => {
-      const url = `http://127.0.0.1:${server.address().port}`;
-      try {
-        const { promise, resolve } = Promise.withResolvers();
-        const client = http2.connect(url);
-        client.on("error", resolve);
+        expect(result.code).toBe("ERR_HTTP2_PING_LENGTH");
+      });
+      it("ping with wrong payload type events should throw", async () => {
+        const { promise, resolve, reject } = Promise.withResolvers();
+        const client = http2.connect(HTTPS_SERVER, TLS_OPTIONS);
+        client.on("error", reject);
         client.on("connect", () => {
-          const req = client.request({ ":path": "/" });
-          req.end();
-          allowWrite();
+          try {
+            client.ping("oops", (err, duration, payload) => {
+              reject("unreachable");
+              client.close();
+            });
+          } catch (err) {
+            resolve(err);
+            client.close();
+          }
         });
         const result = await promise;
         expect(result).toBeDefined();
-        expect(result.code).toBe("ERR_HTTP2_SESSION_ERROR");
-        expect(result.message).toBe("Session closed with error code 6");
-        done();
-      } catch (err) {
-        done(err);
-      } finally {
-        server.close();
-      }
+        expect(result.code).toBe("ERR_INVALID_ARG_TYPE");
+      });
+      it("stream event should work", async () => {
+        const { promise, resolve, reject } = Promise.withResolvers();
+        const client = http2.connect(HTTPS_SERVER, TLS_OPTIONS);
+        client.on("error", reject);
+        client.on("stream", stream => {
+          resolve(stream);
+          client.close();
+        });
+        client.request({ ":path": "/" }).end();
+        const stream = await promise;
+        expect(stream).toBeDefined();
+        expect(stream.id).toBe(1);
+      });
+      it("should wait request to be sent before closing", async () => {
+        const { promise, resolve, reject } = Promise.withResolvers();
+        const client = http2.connect(HTTPS_SERVER, TLS_OPTIONS);
+        client.on("error", reject);
+        const req = client.request({ ":path": "/" });
+        let response_headers = null;
+        req.on("response", (headers, flags) => {
+          response_headers = headers;
+        });
+        client.close(resolve);
+        req.end();
+        await promise;
+        expect(response_headers).toBeTruthy();
+        expect(response_headers[":status"]).toBe(200);
+      });
+      it("wantTrailers should work", async () => {
+        const { promise, resolve, reject } = Promise.withResolvers();
+        const client = http2.connect(HTTPS_SERVER, TLS_OPTIONS);
+        client.on("error", reject);
+        const headers = { ":path": "/", ":method": "POST", "x-wait-trailer": "true" };
+        const req = client.request(headers, {
+          waitForTrailers: true,
+        });
+        req.setEncoding("utf8");
+        let response_headers;
+        req.on("response", headers => {
+          response_headers = headers;
+        });
+        let trailers = { "x-trailer": "hello" };
+        req.on("wantTrailers", () => {
+          req.sendTrailers(trailers);
+        });
+        let data = "";
+        req.on("data", chunk => {
+          data += chunk;
+          client.close();
+        });
+        req.on("error", reject);
+        req.on("end", () => {
+          resolve({ data, headers: response_headers });
+          client.close();
+        });
+        req.end("hello");
+        const response = await promise;
+        let parsed;
+        expect(() => (parsed = JSON.parse(response.data))).not.toThrow();
+        expect(parsed.headers[":method"]).toEqual(headers[":method"]);
+        expect(parsed.headers[":path"]).toEqual(headers[":path"]);
+        expect(parsed.headers["x-wait-trailer"]).toEqual(headers["x-wait-trailer"]);
+        expect(parsed.trailers).toEqual(trailers);
+        expect(response.headers[":status"]).toBe(200);
+        expect(response.headers["set-cookie"]).toEqual([
+          "a=b",
+          "c=d; Wed, 21 Oct 2015 07:28:00 GMT; Secure; HttpOnly",
+          "e=f",
+        ]);
+      });
+
+      it("should not leak memory", () => {
+        const { stdout, exitCode } = Bun.spawnSync({
+          cmd: [bunExe(), "--smol", "run", path.join(import.meta.dir, "node-http2-memory-leak.js")],
+          env: {
+            ...bunEnv,
+            BUN_JSC_forceRAMSize: (1024 * 1024 * 64).toString("10"),
+            HTTP2_SERVER_INFO: JSON.stringify(nodeEchoServer_),
+            HTTP2_SERVER_TLS: JSON.stringify(TLS_OPTIONS),
+          },
+          stderr: "inherit",
+          stdin: "inherit",
+          stdout: "inherit",
+        });
+        expect(exitCode || 0).toBe(0);
+      }, 100000);
+
+      it("should receive goaway", async () => {
+        const { promise, resolve, reject } = Promise.withResolvers();
+        const server = await nodeDynamicServer(
+          "http2.away.1.js",
+          `
+      server.on("stream", (stream, headers, flags) => {
+        stream.session.goaway(http2.constants.NGHTTP2_CONNECT_ERROR, 0, Buffer.from("123456"));
+      });
+    `,
+        );
+        try {
+          const client = http2.connect(server.url);
+          client.on("goaway", (...params) => resolve(params));
+          client.on("error", reject);
+          client.on("connect", () => {
+            const req = client.request({ ":path": "/" });
+            req.on("error", err => {
+              if (err.errno !== http2.constants.NGHTTP2_CONNECT_ERROR) {
+                reject(err);
+              }
+            });
+            req.end();
+          });
+          const result = await promise;
+          expect(result).toBeDefined();
+          const [code, lastStreamID, opaqueData] = result;
+          expect(code).toBe(http2.constants.NGHTTP2_CONNECT_ERROR);
+          expect(lastStreamID).toBe(1);
+          expect(opaqueData.toString()).toBe("123456");
+        } finally {
+          server.subprocess.kill();
+        }
+      });
+      it("should receive goaway without debug data", async () => {
+        const { promise, resolve, reject } = Promise.withResolvers();
+        const server = await nodeDynamicServer(
+          "http2.away.2.js",
+          `
+      server.on("stream", (stream, headers, flags) => {
+        stream.session.goaway(http2.constants.NGHTTP2_CONNECT_ERROR, 0);
+      });
+    `,
+        );
+        try {
+          const client = http2.connect(server.url);
+          client.on("goaway", (...params) => resolve(params));
+          client.on("error", reject);
+          client.on("connect", () => {
+            const req = client.request({ ":path": "/" });
+            req.on("error", err => {
+              if (err.errno !== http2.constants.NGHTTP2_CONNECT_ERROR) {
+                reject(err);
+              }
+            });
+            req.end();
+          });
+          const result = await promise;
+          expect(result).toBeDefined();
+          const [code, lastStreamID, opaqueData] = result;
+          expect(code).toBe(http2.constants.NGHTTP2_CONNECT_ERROR);
+          expect(lastStreamID).toBe(1);
+          expect(opaqueData.toString()).toBe("");
+        } finally {
+          server.subprocess.kill();
+        }
+      });
+      it("should not be able to write on socket", done => {
+        const client = http2.connect(HTTPS_SERVER, TLS_OPTIONS, (session, socket) => {
+          try {
+            client.socket.write("hello");
+            client.socket.end();
+            expect().fail("unreachable");
+          } catch (err) {
+            try {
+              expect(err.code).toBe("ERR_HTTP2_NO_SOCKET_MANIPULATION");
+            } catch (err) {
+              done(err);
+            }
+            done();
+          }
+        });
+      });
+      it("should handle bad GOAWAY server frame size", done => {
+        const server = net.createServer(socket => {
+          const settings = new http2utils.SettingsFrame(true);
+          socket.write(settings.data);
+          const frame = new http2utils.Frame(7, 7, 0, 0).data;
+          socket.write(Buffer.concat([frame, Buffer.alloc(7)]));
+        });
+        server.listen(0, "127.0.0.1", async () => {
+          const url = `http://127.0.0.1:${server.address().port}`;
+          try {
+            const { promise, resolve } = Promise.withResolvers();
+            const client = http2.connect(url);
+            client.on("error", resolve);
+            client.on("connect", () => {
+              const req = client.request({ ":path": "/" });
+              req.end();
+            });
+            const result = await promise;
+            expect(result).toBeDefined();
+            expect(result.code).toBe("ERR_HTTP2_SESSION_ERROR");
+            expect(result.message).toBe("Session closed with error code NGHTTP2_FRAME_SIZE_ERROR");
+            done();
+          } catch (err) {
+            done(err);
+          } finally {
+            server.close();
+          }
+        });
+      });
+      it("should handle bad DATA_FRAME server frame size", done => {
+        const { promise: waitToWrite, resolve: allowWrite } = Promise.withResolvers();
+        const server = net.createServer(async socket => {
+          const settings = new http2utils.SettingsFrame(true);
+          socket.write(settings.data);
+          await waitToWrite;
+          const frame = new http2utils.DataFrame(1, Buffer.alloc(16384 * 2), 0, 1).data;
+          socket.write(frame);
+        });
+        server.listen(0, "127.0.0.1", async () => {
+          const url = `http://127.0.0.1:${server.address().port}`;
+          try {
+            const { promise, resolve } = Promise.withResolvers();
+            const client = http2.connect(url);
+            client.on("error", resolve);
+            client.on("connect", () => {
+              const req = client.request({ ":path": "/" });
+              req.end();
+              allowWrite();
+            });
+            const result = await promise;
+            expect(result).toBeDefined();
+            expect(result.code).toBe("ERR_HTTP2_SESSION_ERROR");
+            expect(result.message).toBe("Session closed with error code NGHTTP2_FRAME_SIZE_ERROR");
+            done();
+          } catch (err) {
+            done(err);
+          } finally {
+            server.close();
+          }
+        });
+      });
+      it("should handle bad RST_FRAME server frame size (no stream)", done => {
+        const { promise: waitToWrite, resolve: allowWrite } = Promise.withResolvers();
+        const server = net.createServer(async socket => {
+          const settings = new http2utils.SettingsFrame(true);
+          socket.write(settings.data);
+          await waitToWrite;
+          const frame = new http2utils.Frame(4, 3, 0, 0).data;
+          socket.write(Buffer.concat([frame, Buffer.alloc(4)]));
+        });
+        server.listen(0, "127.0.0.1", async () => {
+          const url = `http://127.0.0.1:${server.address().port}`;
+          try {
+            const { promise, resolve } = Promise.withResolvers();
+            const client = http2.connect(url);
+            client.on("error", resolve);
+            client.on("connect", () => {
+              const req = client.request({ ":path": "/" });
+              req.end();
+              allowWrite();
+            });
+            const result = await promise;
+            expect(result).toBeDefined();
+            expect(result.code).toBe("ERR_HTTP2_SESSION_ERROR");
+            expect(result.message).toBe("Session closed with error code NGHTTP2_PROTOCOL_ERROR");
+            done();
+          } catch (err) {
+            done(err);
+          } finally {
+            server.close();
+          }
+        });
+      });
+      it("should handle bad RST_FRAME server frame size (less than allowed)", done => {
+        const { promise: waitToWrite, resolve: allowWrite } = Promise.withResolvers();
+        const server = net.createServer(async socket => {
+          const settings = new http2utils.SettingsFrame(true);
+          socket.write(settings.data);
+          await waitToWrite;
+          const frame = new http2utils.Frame(3, 3, 0, 1).data;
+          socket.write(Buffer.concat([frame, Buffer.alloc(3)]));
+        });
+        server.listen(0, "127.0.0.1", async () => {
+          const url = `http://127.0.0.1:${server.address().port}`;
+          try {
+            const { promise, resolve } = Promise.withResolvers();
+            const client = http2.connect(url);
+            client.on("error", resolve);
+            client.on("connect", () => {
+              const req = client.request({ ":path": "/" });
+              req.end();
+              allowWrite();
+            });
+            const result = await promise;
+            expect(result).toBeDefined();
+            expect(result.code).toBe("ERR_HTTP2_SESSION_ERROR");
+            expect(result.message).toBe("Session closed with error code NGHTTP2_FRAME_SIZE_ERROR");
+            done();
+          } catch (err) {
+            done(err);
+          } finally {
+            server.close();
+          }
+        });
+      });
+      it("should handle bad RST_FRAME server frame size (more than allowed)", done => {
+        const { promise: waitToWrite, resolve: allowWrite } = Promise.withResolvers();
+        const server = net.createServer(async socket => {
+          const settings = new http2utils.SettingsFrame(true);
+          socket.write(settings.data);
+          await waitToWrite;
+          const buffer = Buffer.alloc(16384 * 2);
+          const frame = new http2utils.Frame(buffer.byteLength, 3, 0, 1).data;
+          socket.write(Buffer.concat([frame, buffer]));
+        });
+        server.listen(0, "127.0.0.1", async () => {
+          const url = `http://127.0.0.1:${server.address().port}`;
+          try {
+            const { promise, resolve } = Promise.withResolvers();
+            const client = http2.connect(url);
+            client.on("error", resolve);
+            client.on("connect", () => {
+              const req = client.request({ ":path": "/" });
+              req.end();
+              allowWrite();
+            });
+            const result = await promise;
+            expect(result).toBeDefined();
+            expect(result.code).toBe("ERR_HTTP2_SESSION_ERROR");
+            expect(result.message).toBe("Session closed with error code NGHTTP2_FRAME_SIZE_ERROR");
+            done();
+          } catch (err) {
+            done(err);
+          } finally {
+            server.close();
+          }
+        });
+      });
+
+      it("should handle bad CONTINUATION_FRAME server frame size", done => {
+        const { promise: waitToWrite, resolve: allowWrite } = Promise.withResolvers();
+        const server = net.createServer(async socket => {
+          const settings = new http2utils.SettingsFrame(true);
+          socket.write(settings.data);
+          await waitToWrite;
+
+          const frame = new http2utils.HeadersFrame(1, http2utils.kFakeResponseHeaders, 0, true, false);
+          socket.write(frame.data);
+          const continuationFrame = new http2utils.ContinuationFrame(
+            1,
+            http2utils.kFakeResponseHeaders,
+            0,
+            true,
+            false,
+          );
+          socket.write(continuationFrame.data);
+        });
+        server.listen(0, "127.0.0.1", async () => {
+          const url = `http://127.0.0.1:${server.address().port}`;
+          try {
+            const { promise, resolve } = Promise.withResolvers();
+            const client = http2.connect(url);
+            client.on("error", resolve);
+            client.on("connect", () => {
+              const req = client.request({ ":path": "/" });
+              req.end();
+              allowWrite();
+            });
+            const result = await promise;
+            expect(result).toBeDefined();
+            expect(result.code).toBe("ERR_HTTP2_SESSION_ERROR");
+            expect(result.message).toBe("Session closed with error code NGHTTP2_PROTOCOL_ERROR");
+            done();
+          } catch (err) {
+            done(err);
+          } finally {
+            server.close();
+          }
+        });
+      });
+
+      it("should handle bad PRIOTITY_FRAME server frame size", done => {
+        const { promise: waitToWrite, resolve: allowWrite } = Promise.withResolvers();
+        const server = net.createServer(async socket => {
+          const settings = new http2utils.SettingsFrame(true);
+          socket.write(settings.data);
+          await waitToWrite;
+
+          const frame = new http2utils.Frame(4, 2, 0, 1).data;
+          socket.write(Buffer.concat([frame, Buffer.alloc(4)]));
+        });
+        server.listen(0, "127.0.0.1", async () => {
+          const url = `http://127.0.0.1:${server.address().port}`;
+          try {
+            const { promise, resolve } = Promise.withResolvers();
+            const client = http2.connect(url);
+            client.on("error", resolve);
+            client.on("connect", () => {
+              const req = client.request({ ":path": "/" });
+              req.end();
+              allowWrite();
+            });
+            const result = await promise;
+            expect(result).toBeDefined();
+            expect(result.code).toBe("ERR_HTTP2_SESSION_ERROR");
+            expect(result.message).toBe("Session closed with error code NGHTTP2_FRAME_SIZE_ERROR");
+            done();
+          } catch (err) {
+            done(err);
+          } finally {
+            server.close();
+          }
+        });
+      });
     });
   });
-});
+}
diff --git a/test/js/node/missing-module.test.js b/test/js/node/missing-module.test.js
index 96540f19f7..b39446f1ab 100644
--- a/test/js/node/missing-module.test.js
+++ b/test/js/node/missing-module.test.js
@@ -2,6 +2,6 @@ import { expect, test } from "bun:test";
 
 test("not implemented yet module throws an error", () => {
   const missingModule = "node:missing" + "";
-  expect(() => require(missingModule)).toThrow(/^Cannot find package "node:missing" from "/);
-  expect(() => import(missingModule)).toThrow(/^Cannot find package "node:missing" from "/);
+  expect(() => require(missingModule)).toThrow(/^Cannot find package 'node:missing' from '/);
+  expect(() => import(missingModule)).toThrow(/^Cannot find package 'node:missing' from '/);
 });
diff --git a/test/js/node/module/node-module-module.test.js b/test/js/node/module/node-module-module.test.js
index ee5d6c303e..9c44c9656e 100644
--- a/test/js/node/module/node-module-module.test.js
+++ b/test/js/node/module/node-module-module.test.js
@@ -1,6 +1,6 @@
 import { expect, test } from "bun:test";
 import { bunEnv, bunExe, ospath } from "harness";
-import Module, { _nodeModulePaths, builtinModules, isBuiltin, wrap } from "module";
+import Module, { _nodeModulePaths, builtinModules, isBuiltin, wrap, createRequire } from "module";
 import path from "path";
 
 test("builtinModules exists", () => {
@@ -23,6 +23,20 @@ test("module.globalPaths exists", () => {
   expect(Array.isArray(require("module").globalPaths)).toBe(true);
 });
 
+test("createRequire trailing slash", () => {
+  const req = createRequire(import.meta.dir + "/");
+  expect(req.resolve("./node-module-module.test.js")).toBe(
+    ospath(path.resolve(import.meta.dir, "./node-module-module.test.js")),
+  );
+});
+
+test("createRequire trailing slash file url", () => {
+  const req = createRequire(Bun.pathToFileURL(import.meta.dir + "/"));
+  expect(req.resolve("./node-module-module.test.js")).toBe(
+    ospath(path.resolve(import.meta.dir, "./node-module-module.test.js")),
+  );
+});
+
 test("Module exists", () => {
   expect(Module).toBeDefined();
 });
diff --git a/test/js/node/net/node-net-allowHalfOpen.test.js b/test/js/node/net/node-net-allowHalfOpen.test.js
new file mode 100644
index 0000000000..3485bdc37b
--- /dev/null
+++ b/test/js/node/net/node-net-allowHalfOpen.test.js
@@ -0,0 +1,115 @@
+import net from "node:net";
+import { tempDirWithFiles, nodeExe } from "harness";
+import { expect, test } from "bun:test";
+
+async function nodeRun(callback, clients = 1) {
+  const cwd = tempDirWithFiles("server", {
+    "index.mjs": `
+  import net from "node:net";
+  let clients = ${clients};
+  const server = net.createServer({ allowHalfOpen: true }, socket => {
+    // Listen for data from the client
+    socket.on("data", data => {
+      console.log(data.toString());
+    });
+
+    socket.on("end", () => {
+      console.log("Received FIN");
+      if(--clients == 0) {
+        server.close();
+      }
+    });
+    socket.on("error", console.error);
+
+    // start sending FIN
+    socket.end();
+  });
+  server.listen(0, "127.0.0.1", ()=> {
+    console.log(server.address().port?.toString());
+  })
+  `,
+  });
+  const process = Bun.spawn([nodeExe(), "index.mjs"], {
+    cwd,
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  const reader = process.stdout.getReader();
+  let continueReading = true;
+  let stdout = "";
+  let port = 0;
+  do {
+    const { done, value } = await reader.read();
+
+    continueReading = !done;
+    const decoder = new TextDecoder();
+    if (value) {
+      if (!port) {
+        port = parseInt(decoder.decode(value), 10);
+        callback(port);
+      } else {
+        stdout += decoder.decode(value);
+      }
+    }
+  } while (continueReading);
+
+  return {
+    stdout,
+    stderr: (await Bun.readableStreamToText(process.stderr)).trim(),
+    code: await process.exited,
+  };
+}
+
+async function doHalfOpenRequest(port, allowHalfOpen) {
+  const { promise, resolve, reject } = Promise.withResolvers();
+
+  const client = net.connect({ host: "127.0.0.1", port, allowHalfOpen }, () => {
+    client.write("Hello, World");
+  });
+  client.on("error", reject);
+  client.on("close", resolve);
+  client.on("end", () => {
+    // delay the write response
+    setTimeout(() => {
+      client.write("Write after end");
+      client.end();
+    }, 10);
+  });
+  await promise;
+}
+
+test("allowHalfOpen: true should work on client-side", async () => {
+  const { promise: portPromise, resolve } = Promise.withResolvers();
+  const process = nodeRun(resolve, 1);
+
+  const port = await portPromise;
+  await doHalfOpenRequest(port, true);
+  const result = await process;
+  expect(result.code).toBe(0);
+  expect(result.stderr).toBe("");
+  expect(
+    result.stdout
+      .split("\n")
+      .map(s => s.trim())
+      .filter(s => s),
+  ).toEqual(["Hello, World", "Write after end", "Received FIN"]);
+});
+
+test("allowHalfOpen: false should work on client-side", async () => {
+  const { promise: portPromise, resolve } = Promise.withResolvers();
+  const process = nodeRun(resolve, 1);
+
+  const port = await portPromise;
+  await doHalfOpenRequest(port, false);
+  const result = await process;
+  expect(result.code).toBe(0);
+  expect(result.stderr).toBe("");
+  expect(
+    result.stdout
+      .split("\n")
+      .map(s => s.trim())
+      .filter(s => s),
+  ).toEqual(["Hello, World", "Received FIN"]);
+});
diff --git a/test/js/node/net/node-net-server.test.ts b/test/js/node/net/node-net-server.test.ts
index 1a17db9278..70034749ed 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 9e4aa7ffc2..ef56deafe9 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/browserify.test.js b/test/js/node/path/browserify.test.js
index 0678318908..a1838f127c 100644
--- a/test/js/node/path/browserify.test.js
+++ b/test/js/node/path/browserify.test.js
@@ -1,9 +1,9 @@
 import assert from "assert";
 import { describe, expect, it, test } from "bun:test";
+import { isWindows } from "harness";
 import path from "node:path";
 
 const { file } = import.meta;
-const isWindows = process.platform === "win32";
 const sep = isWindows ? "\\" : "/";
 
 describe("browserify path tests", () => {
diff --git a/test/js/node/path/dirname.test.js b/test/js/node/path/dirname.test.js
index 1874269a82..a5f54850e5 100644
--- a/test/js/node/path/dirname.test.js
+++ b/test/js/node/path/dirname.test.js
@@ -1,9 +1,8 @@
 import { describe, test } from "bun:test";
+import { isWindows } from "harness";
 import assert from "node:assert";
 import path from "node:path";
 
-const isWindows = process.platform === "win32";
-
 describe("path.dirname", () => {
   test("platform", () => {
     assert.strictEqual(path.dirname(__filename).substr(-9), isWindows ? "node\\path" : "node/path");
diff --git a/test/js/node/path/parse-format.test.js b/test/js/node/path/parse-format.test.js
index 2534e24b69..4e91eb7cab 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/path/path.test.js b/test/js/node/path/path.test.js
index ff36c51cb0..7a917b86e6 100644
--- a/test/js/node/path/path.test.js
+++ b/test/js/node/path/path.test.js
@@ -1,9 +1,8 @@
 import { describe, test } from "bun:test";
+import { isWindows } from "harness";
 import assert from "node:assert";
 import path from "node:path";
 
-const isWindows = process.platform === "win32";
-
 describe("path", () => {
   test("errors", () => {
     // Test thrown TypeErrors
diff --git a/test/js/node/path/posix-relative-on-windows.test.js b/test/js/node/path/posix-relative-on-windows.test.js
index 0fd5aebb81..9e5e3b9c59 100644
--- a/test/js/node/path/posix-relative-on-windows.test.js
+++ b/test/js/node/path/posix-relative-on-windows.test.js
@@ -1,9 +1,8 @@
 import { describe, test } from "bun:test";
+import { isWindows } from "harness";
 import assert from "node:assert";
 import path from "node:path";
 
-const isWindows = process.platform === "win32";
-
 describe("path.posix.relative", () => {
   test.skipIf(!isWindows)("on windows", () => {
     // Refs: https://github.com/nodejs/node/issues/13683
diff --git a/test/js/node/path/resolve.test.js b/test/js/node/path/resolve.test.js
index d1c80d17b5..7204751052 100644
--- a/test/js/node/path/resolve.test.js
+++ b/test/js/node/path/resolve.test.js
@@ -1,11 +1,10 @@
 import { describe, test } from "bun:test";
+import { isWindows } from "harness";
 import assert from "node:assert";
 // import child from "node:child_process";
 import path from "node:path";
 // import fixtures from "./common/fixtures.js";
 
-const isWindows = process.platform === "win32";
-
 describe("path.resolve", () => {
   test("general", () => {
     const failures = [];
diff --git a/test/js/node/path/to-namespaced-path.test.js b/test/js/node/path/to-namespaced-path.test.js
index 06bfe390c8..b5ba417ae4 100644
--- a/test/js/node/path/to-namespaced-path.test.js
+++ b/test/js/node/path/to-namespaced-path.test.js
@@ -2,8 +2,7 @@ import { describe, test } from "bun:test";
 import assert from "node:assert";
 import path from "node:path";
 import fixtures from "./common/fixtures.js";
-
-const isWindows = process.platform === "win32";
+import { isWindows } from "harness";
 
 describe("path.toNamespacedPath", () => {
   const emptyObj = {};
diff --git a/test/js/node/perf_hooks/perf_hooks.test.ts b/test/js/node/perf_hooks/perf_hooks.test.ts
index 16abc894d6..dda09cb45a 100644
--- a/test/js/node/perf_hooks/perf_hooks.test.ts
+++ b/test/js/node/perf_hooks/perf_hooks.test.ts
@@ -21,4 +21,5 @@ test("doesn't throw", () => {
   expect(() => performance.getEntriesByType("measure")).not.toThrow();
   expect(() => performance.now()).not.toThrow();
   expect(() => performance.timeOrigin).not.toThrow();
+  expect(() => performance.markResourceTiming()).not.toThrow();
 });
diff --git a/test/js/node/process/call-raise.js b/test/js/node/process/call-raise.js
index 898906759e..5b95f9ec44 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 ad12285d4b..09f9bb28f4 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) {
@@ -117,11 +118,15 @@ it("process.chdir() on root dir", () => {
   }
 });
 
-it("process.hrtime()", () => {
+it("process.hrtime()", async () => {
   const start = process.hrtime();
   const end = process.hrtime(start);
-  const end2 = process.hrtime();
   expect(end[0]).toBe(0);
+
+  // Flaky on Ubuntu.
+  await Bun.sleep(0);
+  const end2 = process.hrtime();
+
   expect(end2[1] > start[1]).toBe(true);
 });
 
@@ -135,8 +140,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]);
 });
@@ -234,7 +240,7 @@ it("process.umask()", () => {
   for (let notNumber of notNumbers) {
     expect(() => {
       process.umask(notNumber);
-    }).toThrow('The "mask" argument must be a number');
+    }).toThrow('The "mask" argument must be of type number');
   }
 
   let rangeErrors = [NaN, -1.4, Infinity, -Infinity, -1, 1.3, 4294967296];
diff --git a/test/js/node/stream/node-stream.test.js b/test/js/node/stream/node-stream.test.js
index c96be303f7..287aaf8f74 100644
--- a/test/js/node/stream/node-stream.test.js
+++ b/test/js/node/stream/node-stream.test.js
@@ -342,7 +342,7 @@ it.if(isMacOS || isGlibcVersionAtLeast("2.36.0"))("TTY streams", () => {
     stdio: ["ignore", "pipe", "pipe"],
   });
 
-  expect(stdout.toString()).toBe("");
+  expect(stdout.toString()).toEqual(expect.stringContaining("bun test v1."));
   try {
     expect(stderr.toString()).toContain("0 fail");
   } catch (error) {
diff --git a/test/js/node/string-module.test.js b/test/js/node/string-module.test.js
new file mode 100644
index 0000000000..31d4777181
--- /dev/null
+++ b/test/js/node/string-module.test.js
@@ -0,0 +1,19 @@
+import { expect, test } from "bun:test";
+
+test("should import and execute ES module from string", async () => {
+  const code = `export default function test(arg) { return arg + arg };`;
+  const mod = await import("data:text/javascript," + code).then(mod => mod.default);
+  const result = mod(1);
+  expect(result).toEqual(2);
+});
+
+test("should import and execute ES module from string (base64)", async () => {
+  const code = `export default function test(arg) { return arg + arg; }`;
+  const mod = await import("data:text/javascript;base64," + btoa(code)).then(mod => mod.default);
+  const result = mod(1);
+  expect(result).toEqual(2);
+});
+
+test("should throw when importing malformed string (base64)", async () => {
+  expect(() => import("data:text/javascript;base64,asdasdasd")).toThrowError("Base64DecodeError");
+});
diff --git a/test/js/node/test/common/assertSnapshot.js b/test/js/node/test/common/assertSnapshot.js
index 88f40281e0..a22455160b 100644
--- a/test/js/node/test/common/assertSnapshot.js
+++ b/test/js/node/test/common/assertSnapshot.js
@@ -25,7 +25,7 @@ function replaceWindowsPaths(str) {
 }
 
 function replaceFullPaths(str) {
-  return str.replaceAll(process.cwd(), '');
+  return str.replaceAll(path.resolve(__dirname, '../..'), '');
 }
 
 function transform(...args) {
@@ -78,8 +78,11 @@ async function spawnAndAssert(filename, transform = (x) => x, { tty = false, ...
     return;
   }
   const flags = common.parseTestFlags(filename);
-  const executable = tty ? 'tools/pseudo-tty.py' : process.execPath;
-  const args = tty ? [process.execPath, ...flags, filename] : [...flags, filename];
+  const executable = tty ? (process.env.PYTHON || 'python3') : process.execPath;
+  const args =
+    tty ?
+      [path.join(__dirname, '../..', 'tools/pseudo-tty.py'), process.execPath, ...flags, filename] :
+      [...flags, filename];
   const { stdout, stderr } = await common.spawnPromisified(executable, args, options);
   await assertSnapshot(transform(`${stdout}${stderr}`), filename);
 }
diff --git a/test/js/node/test/common/duplexpair.js b/test/js/node/test/common/duplexpair.js
deleted file mode 100644
index 1f41ed32f1..0000000000
--- a/test/js/node/test/common/duplexpair.js
+++ /dev/null
@@ -1,48 +0,0 @@
-'use strict';
-const { Duplex } = require('stream');
-const assert = require('assert');
-
-const kCallback = Symbol('Callback');
-const kOtherSide = Symbol('Other');
-
-class DuplexSocket extends Duplex {
-  constructor() {
-    super();
-    this[kCallback] = null;
-    this[kOtherSide] = null;
-  }
-
-  _read() {
-    const callback = this[kCallback];
-    if (callback) {
-      this[kCallback] = null;
-      callback();
-    }
-  }
-
-  _write(chunk, encoding, callback) {
-    assert.notStrictEqual(this[kOtherSide], null);
-    assert.strictEqual(this[kOtherSide][kCallback], null);
-    if (chunk.length === 0) {
-      process.nextTick(callback);
-    } else {
-      this[kOtherSide].push(chunk);
-      this[kOtherSide][kCallback] = callback;
-    }
-  }
-
-  _final(callback) {
-    this[kOtherSide].on('end', callback);
-    this[kOtherSide].push(null);
-  }
-}
-
-function makeDuplexPair() {
-  const clientSide = new DuplexSocket();
-  const serverSide = new DuplexSocket();
-  clientSide[kOtherSide] = serverSide;
-  serverSide[kOtherSide] = clientSide;
-  return { clientSide, serverSide };
-}
-
-module.exports = makeDuplexPair;
diff --git a/test/js/node/test/common/globals.js b/test/js/node/test/common/globals.js
index 42caece2b8..5d1c4415ee 100644
--- a/test/js/node/test/common/globals.js
+++ b/test/js/node/test/common/globals.js
@@ -79,7 +79,6 @@ const webIdlExposedWildcard = new Set([
   'TextDecoder',
   'AbortController',
   'AbortSignal',
-  'CustomEvent',
   'EventTarget',
   'Event',
   'URL',
@@ -127,7 +126,6 @@ const webIdlExposedWindow = new Set([
   'Response',
   'WebSocket',
   'EventSource',
-  'CloseEvent',
 ]);
 
 const nodeGlobals = new Set([
diff --git a/test/js/node/test/common/index.js b/test/js/node/test/common/index.js
index ea21d15c10..38a48e8901 100644
--- a/test/js/node/test/common/index.js
+++ b/test/js/node/test/common/index.js
@@ -141,7 +141,7 @@ const isSunOS = process.platform === 'sunos';
 const isFreeBSD = process.platform === 'freebsd';
 const isOpenBSD = process.platform === 'openbsd';
 const isLinux = process.platform === 'linux';
-const isOSX = process.platform === 'darwin';
+const isMacOS = process.platform === 'darwin';
 const isASan = process.config.variables.asan === 1;
 const isPi = (() => {
   try {
@@ -408,12 +408,14 @@ if (process.env.NODE_TEST_KNOWN_GLOBALS !== '0') {
     return leaked;
   }
 
-  process.on('exit', function() {
-    const leaked = leakedGlobals();
-    if (leaked.length > 0) {
-      assert.fail(`Unexpected global(s) found: ${leaked.join(', ')}`);
-    }
-  });
+  // --- Commmented out for Bun ---
+  // process.on('exit', function() {
+  //   const leaked = leakedGlobals();
+  //   if (leaked.length > 0) {
+  //     assert.fail(`Unexpected global(s) found: ${leaked.join(', ')}`);
+  //   }
+  // });
+  // --- Commmented out for Bun ---
 }
 
 const mustCallChecks = [];
@@ -964,9 +966,14 @@ function getPrintedStackTrace(stderr) {
  * @param {object} mod result returned by require()
  * @param {object} expectation shape of expected namespace.
  */
-function expectRequiredModule(mod, expectation) {
+function expectRequiredModule(mod, expectation, checkESModule = true) {
+  const clone = { ...mod };
+  if (Object.hasOwn(mod, 'default') && checkESModule) {
+    assert.strictEqual(mod.__esModule, true);
+    delete clone.__esModule;
+  }
   assert(isModuleNamespaceObject(mod));
-  assert.deepStrictEqual({ ...mod }, { ...expectation });
+  assert.deepStrictEqual(clone, { ...expectation });
 }
 
 const common = {
@@ -998,7 +1005,7 @@ const common = {
   isLinux,
   isMainThread,
   isOpenBSD,
-  isOSX,
+  isMacOS,
   isPi,
   isSunOS,
   isWindows,
diff --git a/test/js/node/test/common/index.mjs b/test/js/node/test/common/index.mjs
index 430527faf8..007ce233fb 100644
--- a/test/js/node/test/common/index.mjs
+++ b/test/js/node/test/common/index.mjs
@@ -30,7 +30,7 @@ const {
   isLinuxPPCBE,
   isMainThread,
   isOpenBSD,
-  isOSX,
+  isMacOS,
   isSunOS,
   isWindows,
   localIPv6Hosts,
@@ -85,7 +85,7 @@ export {
   isLinuxPPCBE,
   isMainThread,
   isOpenBSD,
-  isOSX,
+  isMacOS,
   isSunOS,
   isWindows,
   localIPv6Hosts,
diff --git a/test/js/node/test/common/process-exit-code-cases.js b/test/js/node/test/common/process-exit-code-cases.js
new file mode 100644
index 0000000000..54cfe2655b
--- /dev/null
+++ b/test/js/node/test/common/process-exit-code-cases.js
@@ -0,0 +1,138 @@
+'use strict';
+
+const assert = require('assert');
+
+function getTestCases(isWorker = false) {
+  const cases = [];
+  function exitsOnExitCodeSet() {
+    process.exitCode = 42;
+    process.on('exit', (code) => {
+      assert.strictEqual(process.exitCode, 42);
+      assert.strictEqual(code, 42);
+    });
+  }
+  cases.push({ func: exitsOnExitCodeSet, result: 42 });
+
+  function changesCodeViaExit() {
+    process.exitCode = 99;
+    process.on('exit', (code) => {
+      assert.strictEqual(process.exitCode, 42);
+      assert.strictEqual(code, 42);
+    });
+    process.exit(42);
+  }
+  cases.push({ func: changesCodeViaExit, result: 42 });
+
+  function changesCodeZeroExit() {
+    process.exitCode = 99;
+    process.on('exit', (code) => {
+      assert.strictEqual(process.exitCode, 0);
+      assert.strictEqual(code, 0);
+    });
+    process.exit(0);
+  }
+  cases.push({ func: changesCodeZeroExit, result: 0 });
+
+  function exitWithOneOnUncaught() {
+    process.exitCode = 99;
+    process.on('exit', (code) => {
+      // Cannot use assert because it will be uncaughtException -> 1 exit code
+      // that will render this test useless
+      if (code !== 1 || process.exitCode !== 1) {
+        console.log('wrong code! expected 1 for uncaughtException');
+        process.exit(99);
+      }
+    });
+    throw new Error('ok');
+  }
+  cases.push({
+    func: exitWithOneOnUncaught,
+    result: 1,
+    error: /^Error: ok$/,
+  });
+
+  function changeCodeInsideExit() {
+    process.exitCode = 95;
+    process.on('exit', (code) => {
+      assert.strictEqual(process.exitCode, 95);
+      assert.strictEqual(code, 95);
+      process.exitCode = 99;
+    });
+  }
+  cases.push({ func: changeCodeInsideExit, result: 99 });
+
+  function zeroExitWithUncaughtHandler() {
+    const noop = () => { };
+    process.on('exit', (code) => {
+      process.off('uncaughtException', noop);
+      assert.strictEqual(process.exitCode, undefined);
+      assert.strictEqual(code, 0);
+    });
+    process.on('uncaughtException', noop);
+    throw new Error('ok');
+  }
+  cases.push({ func: zeroExitWithUncaughtHandler, result: 0 });
+
+  function changeCodeInUncaughtHandler() {
+    const modifyExitCode = () => { process.exitCode = 97; };
+    process.on('exit', (code) => {
+      process.off('uncaughtException', modifyExitCode);
+      assert.strictEqual(process.exitCode, 97);
+      assert.strictEqual(code, 97);
+    });
+    process.on('uncaughtException', modifyExitCode);
+    throw new Error('ok');
+  }
+  cases.push({ func: changeCodeInUncaughtHandler, result: 97 });
+
+  function changeCodeInExitWithUncaught() {
+    process.on('exit', (code) => {
+      assert.strictEqual(process.exitCode, 1);
+      assert.strictEqual(code, 1);
+      process.exitCode = 98;
+    });
+    throw new Error('ok');
+  }
+  cases.push({
+    func: changeCodeInExitWithUncaught,
+    result: 98,
+    error: /^Error: ok$/,
+  });
+
+  function exitWithZeroInExitWithUncaught() {
+    process.on('exit', (code) => {
+      assert.strictEqual(process.exitCode, 1);
+      assert.strictEqual(code, 1);
+      process.exitCode = 0;
+    });
+    throw new Error('ok');
+  }
+  cases.push({
+    func: exitWithZeroInExitWithUncaught,
+    result: 0,
+    error: /^Error: ok$/,
+  });
+
+  function exitWithThrowInUncaughtHandler() {
+    process.on('uncaughtException', () => {
+      throw new Error('ok');
+    });
+    throw new Error('bad');
+  }
+  cases.push({
+    func: exitWithThrowInUncaughtHandler,
+    result: isWorker ? 1 : 7,
+    error: /^Error: ok$/,
+  });
+
+  function exitWithUndefinedFatalException() {
+    process._fatalException = undefined;
+    throw new Error('ok');
+  }
+  cases.push({
+    func: exitWithUndefinedFatalException,
+    result: 6,
+  });
+  return cases;
+}
+exports.getTestCases = getTestCases;
diff --git a/test/js/node/test/common/sea.js b/test/js/node/test/common/sea.js
index 863047ab36..53bfd93d92 100644
--- a/test/js/node/test/common/sea.js
+++ b/test/js/node/test/common/sea.js
@@ -5,7 +5,7 @@ const fixtures = require('../common/fixtures');
 const tmpdir = require('../common/tmpdir');
 const { inspect } = require('util');
 
-const { readFileSync, copyFileSync } = require('fs');
+const { readFileSync, copyFileSync, statSync } = require('fs');
 const {
   spawnSyncAndExitWithoutError,
 } = require('../common/child_process');
@@ -50,12 +50,23 @@ function skipIfSingleExecutableIsNotSupported() {
     common.skip('UndefinedBehavior Sanitizer is not supported');
   }
 
+  try {
+    readFileSync(process.execPath);
+  } catch (e) {
+    if (e.code === 'ERR_FS_FILE_TOO_LARGE') {
+      common.skip('The Node.js binary is too large to be supported by postject');
+    }
+  }
+
   tmpdir.refresh();
 
   // The SEA tests involve making a copy of the executable and writing some fixtures
-  // to the tmpdir. To be safe, ensure that at least 120MB disk space is available.
-  if (!tmpdir.hasEnoughSpace(120 * 1024 * 1024)) {
-    common.skip('Available disk space < 120MB');
+  // to the tmpdir. To be safe, ensure that the disk space has at least a copy of the
+  // executable and some extra space for blobs and configs is available.
+  const stat = statSync(process.execPath);
+  const expectedSpace = stat.size + 10 * 1024 * 1024;
+  if (!tmpdir.hasEnoughSpace(expectedSpace)) {
+    common.skip(`Available disk space < ${Math.floor(expectedSpace / 1024 / 1024)} MB`);
   }
 }
 
diff --git a/test/js/node/test/common/shared-lib-util.js b/test/js/node/test/common/shared-lib-util.js
index 3ecd38791c..b5d947a266 100644
--- a/test/js/node/test/common/shared-lib-util.js
+++ b/test/js/node/test/common/shared-lib-util.js
@@ -22,7 +22,7 @@ function addLibraryPath(env) {
   env.LIBPATH =
     (env.LIBPATH ? env.LIBPATH + path.delimiter : '') +
     kExecPath;
-  // For Mac OSX.
+  // For macOS.
   env.DYLD_LIBRARY_PATH =
     (env.DYLD_LIBRARY_PATH ? env.DYLD_LIBRARY_PATH + path.delimiter : '') +
     kExecPath;
diff --git a/test/js/node/test/parallel/.gitignore b/test/js/node/test/parallel/.gitignore
deleted file mode 100644
index 3a5f2a9153..0000000000
--- a/test/js/node/test/parallel/.gitignore
+++ /dev/null
@@ -1,69 +0,0 @@
-# Not working yet:
-child-process-double-pipe.test.js
-child-process-exec-cwd.test.js
-child-process-exec-timeout-expire.test.js
-child-process-spawn-controller.test.js
-child-process-stdio-inherit.test.js
-cluster-fork-env.test.js
-cluster-kill-infinite-loop.test.js
-file-write-stream4.test.js
-file-write-stream5.test.js
-filehandle-close.test.js
-fs-existssync-false.test.js
-fs-fmap.test.js
-fs-read-stream-fd.test.js
-fs-readdir-ucs2.test.js
-fs-watch-recursive-add-file-to-new-folder.test.js
-fs-watch-recursive-symlink.test.js
-http-parser-finish-error.test.js
-http-request-agent.test.js
-http2-connect-options.test.js
-https-server-connections-checking-leak.test.js
-module-circular-symlinks.test.js
-module-prototype-mutation.test.js
-net-bind-twice.test.js
-net-listen-error.test.js
-net-server-close.test.js
-net-write-fully-async-hex-string.test.js
-permission-fs-windows-path.test.js
-pipe-abstract-socket-http.test.js
-pipe-file-to-http.test.js
-process-ppid.test.js
-require-invalid-package.test.js
-require-long-path.test.js
-snapshot-dns-lookup-localhost.test.js
-trace-events-net-abstract-socket.test.js
-trace-events-worker-metadata-with-name.test.js
-windows-failed-heap-allocation.test.js
-worker-dns-terminate.test.js
-worker-esm-exit.test.js
-worker-message-port-wasm-module.test.js
-
-# Failing on Windows:
-pipe-head.test.js
-http-client-response-domain.test.js
-require-extensions-same-filename-as-dir-trailing-slash.test.js
-fs-realpath-on-substed-drive.test.js
-fs-symlink-dir-junction.test.js
-
-# macOS not working yet
-node-dns.test.js
-
-# Things we don't support:
-repl*
-inspector*
-npm*
-*changelog*
-permission*
-shadow-realm*
-trace-events*
-cli-node-options*
-corepack*
-eslint*
-coverage*
-buffer-zero-fill-cli*
-icu-minimum-version.test.js
-release-npm.test.js
-
-# Bad tests
-tls-wrap-no-abort.test.js
diff --git a/test/js/node/test/parallel/arm-math-illegal-instruction.test.js b/test/js/node/test/parallel/arm-math-illegal-instruction.test.js
deleted file mode 100644
index 58199f8742..0000000000
--- a/test/js/node/test/parallel/arm-math-illegal-instruction.test.js
+++ /dev/null
@@ -1,21 +0,0 @@
-//#FILE: test-arm-math-illegal-instruction.js
-//#SHA1: 08aea7234b93dfe296564c6dd21a58bc91acd9dd
-//-----------------
-"use strict";
-
-// This test ensures Math functions don't fail with an "illegal instruction"
-// error on ARM devices (primarily on the Raspberry Pi 1)
-// See https://github.com/nodejs/node/issues/1376
-// and https://code.google.com/p/v8/issues/detail?id=4019
-
-test("Math functions do not fail with illegal instruction on ARM devices", () => {
-  // Iterate over all Math functions
-  Object.getOwnPropertyNames(Math).forEach(functionName => {
-    if (!/[A-Z]/.test(functionName)) {
-      // The function names don't have capital letters.
-      expect(() => Math[functionName](-0.5)).not.toThrow();
-    }
-  });
-});
-
-//<#END_FILE: test-arm-math-illegal-instruction.js
diff --git a/test/js/node/test/parallel/assert-esm-cjs-message-verify.test.js b/test/js/node/test/parallel/assert-esm-cjs-message-verify.test.js
deleted file mode 100644
index 93537273a8..0000000000
--- a/test/js/node/test/parallel/assert-esm-cjs-message-verify.test.js
+++ /dev/null
@@ -1,54 +0,0 @@
-//#FILE: test-assert-esm-cjs-message-verify.js
-//#SHA1: 3d120c4813c4051523045df80fc501e9921b878f
-//-----------------
-"use strict";
-
-const { spawnPromisified } = require("../common");
-const tmpdir = require("../common/tmpdir");
-const assert = require("assert");
-const { writeFileSync, unlink } = require("fs");
-const { join } = require("path");
-
-tmpdir.refresh();
-
-const fileImports = {
-  cjs: 'const assert = require("assert");',
-  mjs: 'import assert from "assert";',
-};
-
-const fileNames = [];
-
-for (const [ext, header] of Object.entries(fileImports)) {
-  const fileName = `test-file.${ext}`;
-  // Store the generated filesnames in an array
-  fileNames.push(join(tmpdir.path, fileName));
-
-  writeFileSync(tmpdir.resolve(fileName), `${header}\nassert.ok(0 === 2);`);
-}
-
-describe("ensure the assert.ok throwing similar error messages for esm and cjs files", () => {
-  const nodejsPath = process.execPath;
-  const errorsMessages = [];
-
-  test("should return code 1 for each command", async () => {
-    for (const fileName of fileNames) {
-      const { stderr, code } = await spawnPromisified(nodejsPath, [fileName]);
-      expect(code).toBe(1);
-      // For each error message, filter the lines which will starts with AssertionError
-      errorsMessages.push(stderr.split("\n").find(s => s.startsWith("AssertionError")));
-    }
-  });
-
-  afterAll(() => {
-    expect(errorsMessages).toHaveLength(2);
-    expect(errorsMessages[0]).toEqual(errorsMessages[1]);
-
-    for (const fileName of fileNames) {
-      unlink(fileName, () => {});
-    }
-
-    tmpdir.refresh();
-  });
-});
-
-//<#END_FILE: test-assert-esm-cjs-message-verify.js
diff --git a/test/js/node/test/parallel/assert-strict-exists.test.js b/test/js/node/test/parallel/assert-strict-exists.test.js
deleted file mode 100644
index 3595cf38ec..0000000000
--- a/test/js/node/test/parallel/assert-strict-exists.test.js
+++ /dev/null
@@ -1,13 +0,0 @@
-//#FILE: test-assert-strict-exists.js
-//#SHA1: 390d3a53b3e79630cbb673eed78ac5857a49352f
-//-----------------
-"use strict";
-
-test("assert/strict is the same as assert.strict", () => {
-  const assert = require("assert");
-  const assertStrict = require("assert/strict");
-
-  expect(assertStrict).toBe(assert.strict);
-});
-
-//<#END_FILE: test-assert-strict-exists.js
diff --git a/test/js/node/test/parallel/async-hooks-recursive-stack-runinasyncscope.test.js b/test/js/node/test/parallel/async-hooks-recursive-stack-runinasyncscope.test.js
deleted file mode 100644
index 30f03f8332..0000000000
--- a/test/js/node/test/parallel/async-hooks-recursive-stack-runinasyncscope.test.js
+++ /dev/null
@@ -1,25 +0,0 @@
-//#FILE: test-async-hooks-recursive-stack-runInAsyncScope.js
-//#SHA1: 7258dfd5a442e34e60920fb484336420db8754e2
-//-----------------
-"use strict";
-
-const async_hooks = require("async_hooks");
-
-// This test verifies that the async ID stack can grow indefinitely.
-
-function recurse(n) {
-  const a = new async_hooks.AsyncResource("foobar");
-  a.runInAsyncScope(() => {
-    expect(a.asyncId()).toBe(async_hooks.executionAsyncId());
-    expect(a.triggerAsyncId()).toBe(async_hooks.triggerAsyncId());
-    if (n >= 0) recurse(n - 1);
-    expect(a.asyncId()).toBe(async_hooks.executionAsyncId());
-    expect(a.triggerAsyncId()).toBe(async_hooks.triggerAsyncId());
-  });
-}
-
-test("async ID stack can grow indefinitely", () => {
-  expect(() => recurse(1000)).not.toThrow();
-});
-
-//<#END_FILE: test-async-hooks-recursive-stack-runInAsyncScope.js
diff --git a/test/js/node/test/parallel/async-hooks-run-in-async-scope-this-arg.test.js b/test/js/node/test/parallel/async-hooks-run-in-async-scope-this-arg.test.js
deleted file mode 100644
index 41479c5c05..0000000000
--- a/test/js/node/test/parallel/async-hooks-run-in-async-scope-this-arg.test.js
+++ /dev/null
@@ -1,24 +0,0 @@
-//#FILE: test-async-hooks-run-in-async-scope-this-arg.js
-//#SHA1: a716f9818bdd704e1cf7ca188ffd4ccb9501a8a7
-//-----------------
-"use strict";
-
-// Test that passing thisArg to runInAsyncScope() works.
-
-const { AsyncResource } = require("async_hooks");
-
-const thisArg = {};
-
-const res = new AsyncResource("fhqwhgads");
-
-function callback() {
-  expect(this).toBe(thisArg);
-}
-
-test("runInAsyncScope with thisArg", () => {
-  const callbackSpy = jest.fn(callback);
-  res.runInAsyncScope(callbackSpy, thisArg);
-  expect(callbackSpy).toHaveBeenCalledTimes(1);
-});
-
-//<#END_FILE: test-async-hooks-run-in-async-scope-this-arg.js
diff --git a/test/js/node/test/parallel/async-hooks-worker-asyncfn-terminate-1.test.js b/test/js/node/test/parallel/async-hooks-worker-asyncfn-terminate-1.test.js
deleted file mode 100644
index c8988c5655..0000000000
--- a/test/js/node/test/parallel/async-hooks-worker-asyncfn-terminate-1.test.js
+++ /dev/null
@@ -1,30 +0,0 @@
-//#FILE: test-async-hooks-worker-asyncfn-terminate-1.js
-//#SHA1: 556f29e8c45107ff3448d713145f6f4e070e8073
-//-----------------
-"use strict";
-
-const { Worker } = require("worker_threads");
-
-test("Worker with async function and async_hooks terminates correctly", () => {
-  const w = new Worker(
-    `
-  const { createHook } = require('async_hooks');
-
-  setImmediate(async () => {
-    createHook({ init() {} }).enable();
-    await 0;
-    process.exit();
-  });
-  `,
-    { eval: true },
-  );
-
-  return new Promise(resolve => {
-    w.on("exit", () => {
-      expect(true).toBe(true); // Ensures the 'exit' event was called
-      resolve();
-    });
-  });
-});
-
-//<#END_FILE: test-async-hooks-worker-asyncfn-terminate-1.js
diff --git a/test/js/node/test/parallel/async-hooks-worker-asyncfn-terminate-2.test.js b/test/js/node/test/parallel/async-hooks-worker-asyncfn-terminate-2.test.js
deleted file mode 100644
index 2140f81307..0000000000
--- a/test/js/node/test/parallel/async-hooks-worker-asyncfn-terminate-2.test.js
+++ /dev/null
@@ -1,37 +0,0 @@
-//#FILE: test-async-hooks-worker-asyncfn-terminate-2.js
-//#SHA1: 2329c972e1256f3aadc37e92f0ff1219d8519328
-//-----------------
-"use strict";
-
-const { Worker } = require("worker_threads");
-
-// Like test-async-hooks-worker-promise.js but with the `await` and `createHook`
-// lines switched, because that resulted in different assertion failures
-// (one a Node.js assertion and one a V8 DCHECK) and it seems prudent to
-// cover both of those failures.
-
-test("Worker with async function and createHook", () => {
-  const w = new Worker(
-    `
-  const { createHook } = require('async_hooks');
-
-  setImmediate(async () => {
-    await 0;
-    createHook({ init() {} }).enable();
-    process.exit();
-  });
-  `,
-    { eval: true },
-  );
-
-  w.postMessage({});
-
-  return new Promise(resolve => {
-    w.on("exit", () => {
-      expect(true).toBe(true); // Equivalent to common.mustCall()
-      resolve();
-    });
-  });
-});
-
-//<#END_FILE: test-async-hooks-worker-asyncfn-terminate-2.js
diff --git a/test/js/node/test/parallel/async-hooks-worker-asyncfn-terminate-3.test.js b/test/js/node/test/parallel/async-hooks-worker-asyncfn-terminate-3.test.js
deleted file mode 100644
index ecc905292a..0000000000
--- a/test/js/node/test/parallel/async-hooks-worker-asyncfn-terminate-3.test.js
+++ /dev/null
@@ -1,33 +0,0 @@
-//#FILE: test-async-hooks-worker-asyncfn-terminate-3.js
-//#SHA1: bd68d52f5ecd5cb22738f78ee855706ed424cbf0
-//-----------------
-"use strict";
-
-const { Worker } = require("worker_threads");
-
-// Like test-async-hooks-worker-promise.js but with an additional statement
-// after the `process.exit()` call, that shouldn't really make a difference
-// but apparently does.
-
-test("Worker with async function and process.exit()", done => {
-  const w = new Worker(
-    `
-  const { createHook } = require('async_hooks');
-
-  setImmediate(async () => {
-    createHook({ init() {} }).enable();
-    await 0;
-    process.exit();
-    process._rawDebug('THIS SHOULD NEVER BE REACHED');
-  });
-  `,
-    { eval: true },
-  );
-
-  w.on("exit", () => {
-    expect(true).toBe(true); // Ensure the exit event is called
-    done();
-  });
-});
-
-//<#END_FILE: test-async-hooks-worker-asyncfn-terminate-3.js
diff --git a/test/js/node/test/parallel/async-local-storage-deep-stack.test.js b/test/js/node/test/parallel/async-local-storage-deep-stack.test.js
deleted file mode 100644
index 9c3926b18b..0000000000
--- a/test/js/node/test/parallel/async-local-storage-deep-stack.test.js
+++ /dev/null
@@ -1,25 +0,0 @@
-//#FILE: test-async-local-storage-deep-stack.js
-//#SHA1: 305d85dc794f55b19fffebfbb720ba0c83714f63
-//-----------------
-"use strict";
-
-const { AsyncLocalStorage } = require("async_hooks");
-
-// Regression test for: https://github.com/nodejs/node/issues/34556
-
-test("AsyncLocalStorage deep stack", () => {
-  const als = new AsyncLocalStorage();
-
-  const done = jest.fn();
-
-  function run(count) {
-    if (count !== 0) return als.run({}, run, --count);
-    done();
-  }
-
-  run(1000);
-
-  expect(done).toHaveBeenCalledTimes(1);
-});
-
-//<#END_FILE: test-async-local-storage-deep-stack.js
diff --git a/test/js/node/test/parallel/async-local-storage-http-multiclients.test.js b/test/js/node/test/parallel/async-local-storage-http-multiclients.test.js
deleted file mode 100644
index b90b19ea6b..0000000000
--- a/test/js/node/test/parallel/async-local-storage-http-multiclients.test.js
+++ /dev/null
@@ -1,89 +0,0 @@
-//#FILE: test-async-local-storage-http-multiclients.js
-//#SHA1: adf8feaec8fa034cbb22fd0f3e2a5ed224c1905e
-//-----------------
-"use strict";
-
-const { AsyncLocalStorage } = require("async_hooks");
-const http = require("http");
-
-const NUM_CLIENTS = 10;
-
-// Run multiple clients that receive data from a server
-// in multiple chunks, in a single non-closure function.
-// Use the AsyncLocalStorage (ALS) APIs to maintain the context
-// and data download. Make sure that individual clients
-// receive their respective data, with no conflicts.
-
-describe("AsyncLocalStorage with multiple HTTP clients", () => {
-  const cls = new AsyncLocalStorage();
-  let server;
-  let index = 0;
-
-  beforeAll(() => {
-    // Set up a server that sends large buffers of data, filled
-    // with cardinal numbers, increasing per request
-    server = http.createServer((q, r) => {
-      // Send a large chunk as response, otherwise the data
-      // may be sent in a single chunk, and the callback in the
-      // client may be called only once, defeating the purpose of test
-      r.end((index++ % 10).toString().repeat(1024 * 1024));
-    });
-  });
-
-  afterAll(() => {
-    server.close();
-  });
-
-  it("should handle multiple clients correctly", async () => {
-    const clientPromises = [];
-
-    await new Promise(resolve => {
-      server.listen(0, resolve);
-    });
-
-    for (let i = 0; i < NUM_CLIENTS; i++) {
-      clientPromises.push(
-        new Promise(resolve => {
-          cls.run(new Map(), () => {
-            const options = { port: server.address().port };
-            const req = http.get(options, res => {
-              const store = cls.getStore();
-              store.set("data", "");
-
-              // Make ondata and onend non-closure
-              // functions and fully dependent on ALS
-              res.setEncoding("utf8");
-              res.on("data", ondata);
-              res.on("end", () => {
-                onend();
-                resolve();
-              });
-            });
-            req.end();
-          });
-        }),
-      );
-    }
-
-    await Promise.all(clientPromises);
-  });
-
-  // Accumulate the current data chunk with the store data
-  function ondata(d) {
-    const store = cls.getStore();
-    expect(store).not.toBeUndefined();
-    let chunk = store.get("data");
-    chunk += d;
-    store.set("data", chunk);
-  }
-
-  // Retrieve the store data, and test for homogeneity
-  function onend() {
-    const store = cls.getStore();
-    expect(store).not.toBeUndefined();
-    const data = store.get("data");
-    expect(data).toBe(data[0].repeat(data.length));
-  }
-});
-
-//<#END_FILE: test-async-local-storage-http-multiclients.js
diff --git a/test/js/node/test/parallel/async-local-storage-snapshot.test.js b/test/js/node/test/parallel/async-local-storage-snapshot.test.js
deleted file mode 100644
index 8b4d0b80bd..0000000000
--- a/test/js/node/test/parallel/async-local-storage-snapshot.test.js
+++ /dev/null
@@ -1,24 +0,0 @@
-//#FILE: test-async-local-storage-snapshot.js
-//#SHA1: f8d967194bfb0b73994d296b03c0c43afa5127e5
-//-----------------
-"use strict";
-
-const { AsyncLocalStorage } = require("async_hooks");
-
-describe("AsyncLocalStorage snapshot", () => {
-  test("should preserve the original context when using snapshot", () => {
-    const asyncLocalStorage = new AsyncLocalStorage();
-
-    const runInAsyncScope = asyncLocalStorage.run(123, () => AsyncLocalStorage.snapshot());
-
-    const result = asyncLocalStorage.run(321, () => {
-      return runInAsyncScope(() => {
-        return asyncLocalStorage.getStore();
-      });
-    });
-
-    expect(result).toBe(123);
-  });
-});
-
-//<#END_FILE: test-async-local-storage-snapshot.js
diff --git a/test/js/node/test/parallel/atomics-wake.test.js b/test/js/node/test/parallel/atomics-wake.test.js
deleted file mode 100644
index 7c690a086a..0000000000
--- a/test/js/node/test/parallel/atomics-wake.test.js
+++ /dev/null
@@ -1,11 +0,0 @@
-//#FILE: test-atomics-wake.js
-//#SHA1: 311b66a7cd5fbc08a20b77de98a66f9cba763f8f
-//-----------------
-"use strict";
-
-// https://github.com/nodejs/node/issues/21219
-test("Atomics.wake should be undefined", () => {
-  expect(Atomics.wake).toBeUndefined();
-});
-
-//<#END_FILE: test-atomics-wake.js
diff --git a/test/js/node/test/parallel/bad-unicode.test.js b/test/js/node/test/parallel/bad-unicode.test.js
deleted file mode 100644
index 26c70dbf53..0000000000
--- a/test/js/node/test/parallel/bad-unicode.test.js
+++ /dev/null
@@ -1,38 +0,0 @@
-//#FILE: test-bad-unicode.js
-//#SHA1: e9b8765f74af6588aff1bd7bfcbc6a19187d100e
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-test("eval with bad unicode throws SyntaxError", () => {
-  expect(() => {
-    eval('"\\uc/ef"');
-  }).toThrow(
-    expect.objectContaining({
-      name: "SyntaxError",
-      message: expect.any(String),
-    }),
-  );
-});
-
-//<#END_FILE: test-bad-unicode.js
diff --git a/test/js/node/test/parallel/beforeexit-event-exit.test.js b/test/js/node/test/parallel/beforeexit-event-exit.test.js
deleted file mode 100644
index c7a0ad2a9c..0000000000
--- a/test/js/node/test/parallel/beforeexit-event-exit.test.js
+++ /dev/null
@@ -1,44 +0,0 @@
-//#FILE: test-beforeexit-event-exit.js
-//#SHA1: 27b6351612c5ec4f51d3317ca1c89511b833eaab
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-test("beforeExit event should not be called when process.exit() is called", () => {
-  const mockBeforeExit = jest.fn();
-  process.on("beforeExit", mockBeforeExit);
-
-  // Spy on process.exit to prevent actual exit
-  const exitSpy = jest.spyOn(process, "exit").mockImplementation(() => {});
-
-  process.exit();
-
-  expect(mockBeforeExit).not.toHaveBeenCalled();
-  expect(exitSpy).toHaveBeenCalled();
-
-  // Clean up
-  process.removeListener("beforeExit", mockBeforeExit);
-  exitSpy.mockRestore();
-});
-
-//<#END_FILE: test-beforeexit-event-exit.js
diff --git a/test/js/node/test/parallel/blob-createobjecturl.test.js b/test/js/node/test/parallel/blob-createobjecturl.test.js
deleted file mode 100644
index 9f94ba18f5..0000000000
--- a/test/js/node/test/parallel/blob-createobjecturl.test.js
+++ /dev/null
@@ -1,54 +0,0 @@
-//#FILE: test-blob-createobjecturl.js
-//#SHA1: d2030ca0ad6757dd9d338bc2e65cd3ff8917009d
-//-----------------
-// Flags: --no-warnings
-"use strict";
-
-// Because registering a Blob URL requires generating a random
-// UUID, it can only be done if crypto support is enabled.
-if (typeof crypto === "undefined") {
-  test.skip("missing crypto");
-}
-
-const { URL } = require("url");
-const { Blob, resolveObjectURL } = require("buffer");
-
-test("Blob URL creation and resolution", async () => {
-  const blob = new Blob(["hello"]);
-  const id = URL.createObjectURL(blob);
-  expect(typeof id).toBe("string");
-  const otherBlob = resolveObjectURL(id);
-  expect(otherBlob).toBeInstanceOf(Blob);
-  expect(otherBlob.constructor).toBe(Blob);
-  expect(otherBlob.size).toBe(5);
-  expect(Buffer.from(await otherBlob.arrayBuffer()).toString()).toBe("hello");
-  URL.revokeObjectURL(id);
-
-  // should do nothing
-  URL.revokeObjectURL(id);
-
-  expect(resolveObjectURL(id)).toBeUndefined();
-
-  // Leaving a Blob registered should not cause an assert
-  // when Node.js exists
-  URL.createObjectURL(new Blob());
-});
-
-test("resolveObjectURL with invalid inputs", () => {
-  ["not a url", undefined, 1, "blob:nodedata:1:wrong", {}].forEach(i => {
-    expect(resolveObjectURL(i)).toBeUndefined();
-  });
-});
-
-test("createObjectURL with invalid inputs", () => {
-  [undefined, 1, "", false, {}].forEach(i => {
-    expect(() => URL.createObjectURL(i)).toThrow(
-      expect.objectContaining({
-        code: "ERR_INVALID_ARG_TYPE",
-        message: expect.any(String),
-      }),
-    );
-  });
-});
-
-//<#END_FILE: test-blob-createobjecturl.js
diff --git a/test/js/node/test/parallel/buffer-failed-alloc-typed-arrays.test.js b/test/js/node/test/parallel/buffer-failed-alloc-typed-arrays.test.js
deleted file mode 100644
index 8dfcd1d03a..0000000000
--- a/test/js/node/test/parallel/buffer-failed-alloc-typed-arrays.test.js
+++ /dev/null
@@ -1,35 +0,0 @@
-//#FILE: test-buffer-failed-alloc-typed-arrays.js
-//#SHA1: caa3a29c5ca1921e9ab5324d464067a364b8e687
-//-----------------
-"use strict";
-
-const { Buffer } = require("buffer");
-const SlowBuffer = require("buffer").SlowBuffer;
-
-// Test failed or zero-sized Buffer allocations not affecting typed arrays.
-// This test exists because of a regression that occurred. Because Buffer
-// instances are allocated with the same underlying allocator as TypedArrays,
-// but Buffer's can optional be non-zero filled, there was a regression that
-// occurred when a Buffer allocated failed, the internal flag specifying
-// whether or not to zero-fill was not being reset, causing TypedArrays to
-// allocate incorrectly.
-
-test("failed or zero-sized Buffer allocations do not affect typed arrays", () => {
-  const zeroArray = new Uint32Array(10).fill(0);
-  const sizes = [1e20, 0, 0.1, -1, "a", undefined, null, NaN];
-  const allocators = [Buffer, SlowBuffer, Buffer.alloc, Buffer.allocUnsafe, Buffer.allocUnsafeSlow];
-
-  for (const allocator of allocators) {
-    for (const size of sizes) {
-      try {
-        // Some of these allocations are known to fail. If they do,
-        // Uint32Array should still produce a zeroed out result.
-        allocator(size);
-      } catch {
-        expect(new Uint32Array(10)).toEqual(zeroArray);
-      }
-    }
-  }
-});
-
-//<#END_FILE: test-buffer-failed-alloc-typed-arrays.js
diff --git a/test/js/node/test/parallel/buffer-inheritance.test.js b/test/js/node/test/parallel/buffer-inheritance.test.js
deleted file mode 100644
index 5939621c9f..0000000000
--- a/test/js/node/test/parallel/buffer-inheritance.test.js
+++ /dev/null
@@ -1,38 +0,0 @@
-//#FILE: test-buffer-inheritance.js
-//#SHA1: 01cba7d2cb76cb1d00fa91b3666dc58333b66e1b
-//-----------------
-"use strict";
-
-test("Buffer inheritance", () => {
-  function T(n) {
-    const ui8 = new Uint8Array(n);
-    Object.setPrototypeOf(ui8, T.prototype);
-    return ui8;
-  }
-  Object.setPrototypeOf(T.prototype, Buffer.prototype);
-  Object.setPrototypeOf(T, Buffer);
-
-  T.prototype.sum = function sum() {
-    let cntr = 0;
-    for (let i = 0; i < this.length; i++) cntr += this[i];
-    return cntr;
-  };
-
-  const vals = [new T(4), T(4)];
-
-  vals.forEach(function (t) {
-    expect(t.constructor).toBe(T);
-    expect(Object.getPrototypeOf(t)).toBe(T.prototype);
-    expect(Object.getPrototypeOf(Object.getPrototypeOf(t))).toBe(Buffer.prototype);
-
-    t.fill(5);
-    let cntr = 0;
-    for (let i = 0; i < t.length; i++) cntr += t[i];
-    expect(cntr).toBe(t.length * 5);
-
-    // Check this does not throw
-    expect(() => t.toString()).not.toThrow();
-  });
-});
-
-//<#END_FILE: test-buffer-inheritance.js
diff --git a/test/js/node/test/parallel/buffer-iterator.test.js b/test/js/node/test/parallel/buffer-iterator.test.js
deleted file mode 100644
index ca9cacb93d..0000000000
--- a/test/js/node/test/parallel/buffer-iterator.test.js
+++ /dev/null
@@ -1,72 +0,0 @@
-//#FILE: test-buffer-iterator.js
-//#SHA1: cd9bcdf671dc11d86bd194aa3e7500041f03eb4c
-//-----------------
-"use strict";
-
-// Buffers should be iterable
-test("Buffers are iterable", () => {
-  const buffer = Buffer.from([1, 2, 3, 4, 5]);
-  const arr = [];
-
-  for (const b of buffer) {
-    arr.push(b);
-  }
-
-  expect(arr).toEqual([1, 2, 3, 4, 5]);
-});
-
-// Buffer iterators should be iterable
-test("Buffer iterators are iterable", () => {
-  const buffer = Buffer.from([1, 2, 3, 4, 5]);
-  const arr = [];
-
-  for (const b of buffer[Symbol.iterator]()) {
-    arr.push(b);
-  }
-
-  expect(arr).toEqual([1, 2, 3, 4, 5]);
-});
-
-// buffer#values() should return iterator for values
-test("buffer.values() returns iterator for values", () => {
-  const buffer = Buffer.from([1, 2, 3, 4, 5]);
-  const arr = [];
-
-  for (const b of buffer.values()) {
-    arr.push(b);
-  }
-
-  expect(arr).toEqual([1, 2, 3, 4, 5]);
-});
-
-// buffer#keys() should return iterator for keys
-test("buffer.keys() returns iterator for keys", () => {
-  const buffer = Buffer.from([1, 2, 3, 4, 5]);
-  const arr = [];
-
-  for (const b of buffer.keys()) {
-    arr.push(b);
-  }
-
-  expect(arr).toEqual([0, 1, 2, 3, 4]);
-});
-
-// buffer#entries() should return iterator for entries
-test("buffer.entries() returns iterator for entries", () => {
-  const buffer = Buffer.from([1, 2, 3, 4, 5]);
-  const arr = [];
-
-  for (const b of buffer.entries()) {
-    arr.push(b);
-  }
-
-  expect(arr).toEqual([
-    [0, 1],
-    [1, 2],
-    [2, 3],
-    [3, 4],
-    [4, 5],
-  ]);
-});
-
-//<#END_FILE: test-buffer-iterator.js
diff --git a/test/js/node/test/parallel/buffer-nopendingdep-map.test.js b/test/js/node/test/parallel/buffer-nopendingdep-map.test.js
deleted file mode 100644
index 5fc9d4efad..0000000000
--- a/test/js/node/test/parallel/buffer-nopendingdep-map.test.js
+++ /dev/null
@@ -1,23 +0,0 @@
-//#FILE: test-buffer-nopendingdep-map.js
-//#SHA1: 908b5747ec3c5873c180b66b6e50221fd29169e3
-//-----------------
-// Flags: --no-warnings --pending-deprecation
-"use strict";
-
-test("Buffer methods should not emit deprecation warnings with --pending-deprecation", () => {
-  const warningListener = jest.fn();
-  process.on("warning", warningListener);
-
-  // With the --pending-deprecation flag, the deprecation warning for
-  // new Buffer() should not be emitted when Uint8Array methods are called.
-
-  Buffer.from("abc").map(i => i);
-  Buffer.from("abc").filter(i => i);
-  Buffer.from("abc").slice(1, 2);
-
-  expect(warningListener).not.toHaveBeenCalled();
-
-  process.removeListener("warning", warningListener);
-});
-
-//<#END_FILE: test-buffer-nopendingdep-map.js
diff --git a/test/js/node/test/parallel/buffer-of-no-deprecation.test.js b/test/js/node/test/parallel/buffer-of-no-deprecation.test.js
deleted file mode 100644
index 53c31f103c..0000000000
--- a/test/js/node/test/parallel/buffer-of-no-deprecation.test.js
+++ /dev/null
@@ -1,18 +0,0 @@
-//#FILE: test-buffer-of-no-deprecation.js
-//#SHA1: 7c233f8a82411a5d1c293daecef6494d02d7dabf
-//-----------------
-"use strict";
-
-test("Buffer.of() should not emit deprecation warning", () => {
-  const warningListener = jest.fn();
-  process.on("warning", warningListener);
-
-  Buffer.of(0, 1);
-
-  expect(warningListener).not.toHaveBeenCalled();
-
-  // Clean up the listener
-  process.removeListener("warning", warningListener);
-});
-
-//<#END_FILE: test-buffer-of-no-deprecation.js
diff --git a/test/js/node/test/parallel/buffer-safe-unsafe.test.js b/test/js/node/test/parallel/buffer-safe-unsafe.test.js
deleted file mode 100644
index 84e1db9096..0000000000
--- a/test/js/node/test/parallel/buffer-safe-unsafe.test.js
+++ /dev/null
@@ -1,27 +0,0 @@
-//#FILE: test-buffer-safe-unsafe.js
-//#SHA1: 87831e463ab52a79fca3ac2e28eec57666ea9e5e
-//-----------------
-"use strict";
-
-test("Buffer safe and unsafe allocations", () => {
-  const safe = Buffer.alloc(10);
-
-  function isZeroFilled(buf) {
-    for (let n = 0; n < buf.length; n++) if (buf[n] !== 0) return false;
-    return true;
-  }
-
-  expect(isZeroFilled(safe)).toBe(true);
-
-  // Test that unsafe allocations doesn't affect subsequent safe allocations
-  Buffer.allocUnsafe(10);
-  expect(isZeroFilled(new Float64Array(10))).toBe(true);
-
-  new Buffer(10);
-  expect(isZeroFilled(new Float64Array(10))).toBe(true);
-
-  Buffer.allocUnsafe(10);
-  expect(isZeroFilled(Buffer.alloc(10))).toBe(true);
-});
-
-//<#END_FILE: test-buffer-safe-unsafe.js
diff --git a/test/js/node/test/parallel/buffer-slice.test.js b/test/js/node/test/parallel/buffer-slice.test.js
deleted file mode 100644
index 5fde7bdf62..0000000000
--- a/test/js/node/test/parallel/buffer-slice.test.js
+++ /dev/null
@@ -1,114 +0,0 @@
-//#FILE: test-buffer-slice.js
-//#SHA1: 1f7289de3a6dd5167f3659cd5119e6489b059d43
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-test("Buffer slice operations", () => {
-  expect(Buffer.from("hello", "utf8").slice(0, 0).length).toBe(0);
-  expect(Buffer("hello", "utf8").slice(0, 0).length).toBe(0);
-
-  const buf = Buffer.from("0123456789", "utf8");
-  const expectedSameBufs = [
-    [buf.slice(-10, 10), Buffer.from("0123456789", "utf8")],
-    [buf.slice(-20, 10), Buffer.from("0123456789", "utf8")],
-    [buf.slice(-20, -10), Buffer.from("", "utf8")],
-    [buf.slice(), Buffer.from("0123456789", "utf8")],
-    [buf.slice(0), Buffer.from("0123456789", "utf8")],
-    [buf.slice(0, 0), Buffer.from("", "utf8")],
-    [buf.slice(undefined), Buffer.from("0123456789", "utf8")],
-    [buf.slice("foobar"), Buffer.from("0123456789", "utf8")],
-    [buf.slice(undefined, undefined), Buffer.from("0123456789", "utf8")],
-    [buf.slice(2), Buffer.from("23456789", "utf8")],
-    [buf.slice(5), Buffer.from("56789", "utf8")],
-    [buf.slice(10), Buffer.from("", "utf8")],
-    [buf.slice(5, 8), Buffer.from("567", "utf8")],
-    [buf.slice(8, -1), Buffer.from("8", "utf8")],
-    [buf.slice(-10), Buffer.from("0123456789", "utf8")],
-    [buf.slice(0, -9), Buffer.from("0", "utf8")],
-    [buf.slice(0, -10), Buffer.from("", "utf8")],
-    [buf.slice(0, -1), Buffer.from("012345678", "utf8")],
-    [buf.slice(2, -2), Buffer.from("234567", "utf8")],
-    [buf.slice(0, 65536), Buffer.from("0123456789", "utf8")],
-    [buf.slice(65536, 0), Buffer.from("", "utf8")],
-    [buf.slice(-5, -8), Buffer.from("", "utf8")],
-    [buf.slice(-5, -3), Buffer.from("56", "utf8")],
-    [buf.slice(-10, 10), Buffer.from("0123456789", "utf8")],
-    [buf.slice("0", "1"), Buffer.from("0", "utf8")],
-    [buf.slice("-5", "10"), Buffer.from("56789", "utf8")],
-    [buf.slice("-10", "10"), Buffer.from("0123456789", "utf8")],
-    [buf.slice("-10", "-5"), Buffer.from("01234", "utf8")],
-    [buf.slice("-10", "-0"), Buffer.from("", "utf8")],
-    [buf.slice("111"), Buffer.from("", "utf8")],
-    [buf.slice("0", "-111"), Buffer.from("", "utf8")],
-  ];
-
-  for (let i = 0, s = buf.toString(); i < buf.length; ++i) {
-    expectedSameBufs.push(
-      [buf.slice(i), Buffer.from(s.slice(i))],
-      [buf.slice(0, i), Buffer.from(s.slice(0, i))],
-      [buf.slice(-i), Buffer.from(s.slice(-i))],
-      [buf.slice(0, -i), Buffer.from(s.slice(0, -i))],
-    );
-  }
-
-  for (const [buf1, buf2] of expectedSameBufs) {
-    expect(Buffer.compare(buf1, buf2)).toBe(0);
-  }
-
-  const utf16Buf = Buffer.from("0123456789", "utf16le");
-  expect(utf16Buf.slice(0, 6)).toStrictEqual(Buffer.from("012", "utf16le"));
-
-  // Try to slice a zero length Buffer.
-  // See https://github.com/joyent/node/issues/5881
-  expect(Buffer.alloc(0).slice(0, 1).length).toBe(0);
-
-  // Single argument slice
-  expect(Buffer.from("abcde", "utf8").slice(1).toString("utf8")).toBe("bcde");
-
-  // slice(0,0).length === 0
-  expect(Buffer.from("hello", "utf8").slice(0, 0).length).toBe(0);
-
-  // Regression tests for https://github.com/nodejs/node/issues/9096
-  const regressionBuf = Buffer.from("abcd", "utf8");
-  expect(regressionBuf.slice(regressionBuf.length / 3).toString("utf8")).toBe("bcd");
-  expect(regressionBuf.slice(regressionBuf.length / 3, regressionBuf.length).toString()).toBe("bcd");
-
-  const largeSliceBuf = Buffer.from("abcdefg", "utf8");
-  expect(largeSliceBuf.slice(-(-1 >>> 0) - 1).toString("utf8")).toBe(largeSliceBuf.toString("utf8"));
-
-  const floatSliceBuf = Buffer.from("abc", "utf8");
-  expect(floatSliceBuf.slice(-0.5).toString("utf8")).toBe(floatSliceBuf.toString("utf8"));
-
-  const complexBuf = Buffer.from([
-    1, 29, 0, 0, 1, 143, 216, 162, 92, 254, 248, 63, 0, 0, 0, 18, 184, 6, 0, 175, 29, 0, 8, 11, 1, 0, 0,
-  ]);
-  const chunk1 = Buffer.from([1, 29, 0, 0, 1, 143, 216, 162, 92, 254, 248, 63, 0]);
-  const chunk2 = Buffer.from([0, 0, 18, 184, 6, 0, 175, 29, 0, 8, 11, 1, 0, 0]);
-  const middle = complexBuf.length / 2;
-
-  expect(complexBuf.slice(0, middle)).toStrictEqual(chunk1);
-  expect(complexBuf.slice(middle)).toStrictEqual(chunk2);
-});
-
-//<#END_FILE: test-buffer-slice.js
diff --git a/test/js/node/test/parallel/buffer-swap.test.js b/test/js/node/test/parallel/buffer-swap.test.js
deleted file mode 100644
index 89eef58dce..0000000000
--- a/test/js/node/test/parallel/buffer-swap.test.js
+++ /dev/null
@@ -1,153 +0,0 @@
-//#FILE: test-buffer-swap.js
-//#SHA1: 589e4ee82ab5f00e1cffdd4d326e21cc2f06b065
-//-----------------
-"use strict";
-
-describe("Buffer swap operations", () => {
-  test("Test buffers small enough to use the JS implementation", () => {
-    const buf = Buffer.from([
-      0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
-    ]);
-
-    expect(buf.swap16()).toBe(buf);
-    expect(buf).toEqual(
-      Buffer.from([0x02, 0x01, 0x04, 0x03, 0x06, 0x05, 0x08, 0x07, 0x0a, 0x09, 0x0c, 0x0b, 0x0e, 0x0d, 0x10, 0x0f]),
-    );
-    buf.swap16(); // restore
-
-    expect(buf.swap32()).toBe(buf);
-    expect(buf).toEqual(
-      Buffer.from([0x04, 0x03, 0x02, 0x01, 0x08, 0x07, 0x06, 0x05, 0x0c, 0x0b, 0x0a, 0x09, 0x10, 0x0f, 0x0e, 0x0d]),
-    );
-    buf.swap32(); // restore
-
-    expect(buf.swap64()).toBe(buf);
-    expect(buf).toEqual(
-      Buffer.from([0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x10, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09]),
-    );
-  });
-
-  test("Operates in-place", () => {
-    const buf = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]);
-    buf.slice(1, 5).swap32();
-    expect(buf).toEqual(Buffer.from([0x1, 0x5, 0x4, 0x3, 0x2, 0x6, 0x7]));
-    buf.slice(1, 5).swap16();
-    expect(buf).toEqual(Buffer.from([0x1, 0x4, 0x5, 0x2, 0x3, 0x6, 0x7]));
-
-    // Length assertions
-    const re16 = /Buffer size must be a multiple of 16-bits/;
-    const re32 = /Buffer size must be a multiple of 32-bits/;
-    const re64 = /Buffer size must be a multiple of 64-bits/;
-
-    expect(() => Buffer.from(buf).swap16()).toThrow(expect.objectContaining({ message: expect.any(String) }));
-    expect(() => Buffer.alloc(1025).swap16()).toThrow(expect.objectContaining({ message: expect.any(String) }));
-    expect(() => Buffer.from(buf).swap32()).toThrow(expect.objectContaining({ message: expect.any(String) }));
-    expect(() => buf.slice(1, 3).swap32()).toThrow(expect.objectContaining({ message: expect.any(String) }));
-    expect(() => Buffer.alloc(1025).swap32()).toThrow(expect.objectContaining({ message: expect.any(String) }));
-    expect(() => buf.slice(1, 3).swap64()).toThrow(expect.objectContaining({ message: expect.any(String) }));
-    expect(() => Buffer.alloc(1025).swap64()).toThrow(expect.objectContaining({ message: expect.any(String) }));
-  });
-
-  test("Swap64 on a slice", () => {
-    const buf = Buffer.from([
-      0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x01, 0x02, 0x03,
-      0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
-    ]);
-
-    buf.slice(2, 18).swap64();
-
-    expect(buf).toEqual(
-      Buffer.from([
-        0x01, 0x02, 0x0a, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x10, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b,
-        0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
-      ]),
-    );
-  });
-
-  test("Force use of native code (Buffer size above threshold limit for js impl)", () => {
-    const bufData = new Uint32Array(256).fill(0x04030201);
-    const buf = Buffer.from(bufData.buffer, bufData.byteOffset);
-    const otherBufData = new Uint32Array(256).fill(0x03040102);
-    const otherBuf = Buffer.from(otherBufData.buffer, otherBufData.byteOffset);
-    buf.swap16();
-    expect(buf).toEqual(otherBuf);
-  });
-
-  test("Force use of native code for swap32", () => {
-    const bufData = new Uint32Array(256).fill(0x04030201);
-    const buf = Buffer.from(bufData.buffer);
-    const otherBufData = new Uint32Array(256).fill(0x01020304);
-    const otherBuf = Buffer.from(otherBufData.buffer, otherBufData.byteOffset);
-    buf.swap32();
-    expect(buf).toEqual(otherBuf);
-  });
-
-  test("Force use of native code for swap64", () => {
-    const bufData = new Uint8Array(256 * 8);
-    const otherBufData = new Uint8Array(256 * 8);
-    for (let i = 0; i < bufData.length; i++) {
-      bufData[i] = i % 8;
-      otherBufData[otherBufData.length - i - 1] = i % 8;
-    }
-    const buf = Buffer.from(bufData.buffer, bufData.byteOffset);
-    const otherBuf = Buffer.from(otherBufData.buffer, otherBufData.byteOffset);
-    buf.swap64();
-    expect(buf).toEqual(otherBuf);
-  });
-
-  test("Test native code with buffers that are not memory-aligned (swap16)", () => {
-    const bufData = new Uint8Array(256 * 8);
-    const otherBufData = new Uint8Array(256 * 8 - 2);
-    for (let i = 0; i < bufData.length; i++) {
-      bufData[i] = i % 2;
-    }
-    for (let i = 1; i < otherBufData.length; i++) {
-      otherBufData[otherBufData.length - i] = (i + 1) % 2;
-    }
-    const buf = Buffer.from(bufData.buffer, bufData.byteOffset);
-    // 0|1 0|1 0|1...
-    const otherBuf = Buffer.from(otherBufData.buffer, otherBufData.byteOffset);
-    // 0|0 1|0 1|0...
-
-    buf.slice(1, buf.length - 1).swap16();
-    expect(buf.slice(0, otherBuf.length)).toEqual(otherBuf);
-  });
-
-  test("Test native code with buffers that are not memory-aligned (swap32)", () => {
-    const bufData = new Uint8Array(256 * 8);
-    const otherBufData = new Uint8Array(256 * 8 - 4);
-    for (let i = 0; i < bufData.length; i++) {
-      bufData[i] = i % 4;
-    }
-    for (let i = 1; i < otherBufData.length; i++) {
-      otherBufData[otherBufData.length - i] = (i + 1) % 4;
-    }
-    const buf = Buffer.from(bufData.buffer, bufData.byteOffset);
-    // 0|1 2 3 0|1 2 3...
-    const otherBuf = Buffer.from(otherBufData.buffer, otherBufData.byteOffset);
-    // 0|0 3 2 1|0 3 2...
-
-    buf.slice(1, buf.length - 3).swap32();
-    expect(buf.slice(0, otherBuf.length)).toEqual(otherBuf);
-  });
-
-  test("Test native code with buffers that are not memory-aligned (swap64)", () => {
-    const bufData = new Uint8Array(256 * 8);
-    const otherBufData = new Uint8Array(256 * 8 - 8);
-    for (let i = 0; i < bufData.length; i++) {
-      bufData[i] = i % 8;
-    }
-    for (let i = 1; i < otherBufData.length; i++) {
-      otherBufData[otherBufData.length - i] = (i + 1) % 8;
-    }
-    const buf = Buffer.from(bufData.buffer, bufData.byteOffset);
-    // 0|1 2 3 4 5 6 7 0|1 2 3 4...
-    const otherBuf = Buffer.from(otherBufData.buffer, otherBufData.byteOffset);
-    // 0|0 7 6 5 4 3 2 1|0 7 6 5...
-
-    buf.slice(1, buf.length - 7).swap64();
-    expect(buf.slice(0, otherBuf.length)).toEqual(otherBuf);
-  });
-});
-
-//<#END_FILE: test-buffer-swap.js
diff --git a/test/js/node/test/parallel/buffer-zero-fill-reset.test.js b/test/js/node/test/parallel/buffer-zero-fill-reset.test.js
deleted file mode 100644
index d4055fb35a..0000000000
--- a/test/js/node/test/parallel/buffer-zero-fill-reset.test.js
+++ /dev/null
@@ -1,20 +0,0 @@
-//#FILE: test-buffer-zero-fill-reset.js
-//#SHA1: 2278dd06a2e113e875c1f0f46580c0fcc4fc5254
-//-----------------
-"use strict";
-
-test("Uint8Array is zero-filled after Buffer.alloc(0)", () => {
-  function testUint8Array(ui) {
-    const length = ui.length;
-    for (let i = 0; i < length; i++) if (ui[i] !== 0) return false;
-    return true;
-  }
-
-  for (let i = 0; i < 100; i++) {
-    Buffer.alloc(0);
-    const ui = new Uint8Array(65);
-    expect(testUint8Array(ui)).toBe(true);
-  }
-});
-
-//<#END_FILE: test-buffer-zero-fill-reset.js
diff --git a/test/js/node/test/parallel/buffer-zero-fill.test.js b/test/js/node/test/parallel/buffer-zero-fill.test.js
deleted file mode 100644
index 003b4ffe08..0000000000
--- a/test/js/node/test/parallel/buffer-zero-fill.test.js
+++ /dev/null
@@ -1,20 +0,0 @@
-//#FILE: test-buffer-zero-fill.js
-//#SHA1: b710e0c9405c90f7526cf0efabd4c61ede37b1f7
-//-----------------
-"use strict";
-
-// Tests deprecated Buffer API on purpose
-test("Buffer zero-fill", () => {
-  const buf1 = Buffer(100);
-  const buf2 = new Buffer(100);
-
-  for (let n = 0; n < buf1.length; n++) {
-    expect(buf1[n]).toBe(0);
-  }
-
-  for (let n = 0; n < buf2.length; n++) {
-    expect(buf2[n]).toBe(0);
-  }
-});
-
-//<#END_FILE: test-buffer-zero-fill.js
diff --git a/test/js/node/test/parallel/child-process-exec-encoding.test.js b/test/js/node/test/parallel/child-process-exec-encoding.test.js
deleted file mode 100644
index 46ae2d5276..0000000000
--- a/test/js/node/test/parallel/child-process-exec-encoding.test.js
+++ /dev/null
@@ -1,61 +0,0 @@
-//#FILE: test-child-process-exec-encoding.js
-//#SHA1: 3ad6878126678aa6ad2c38a43264e5684dae6a72
-//-----------------
-"use strict";
-
-const stdoutData = "foo";
-const stderrData = "bar";
-
-if (process.argv[2] === "child") {
-  // The following console calls are part of the test.
-  console.log(stdoutData);
-  console.error(stderrData);
-} else {
-  const cp = require("child_process");
-  const expectedStdout = `${stdoutData}\n`;
-  const expectedStderr = `${stderrData}\n`;
-
-  function run(options) {
-    const cmd = `"${process.execPath}" "${__filename}" child`;
-
-    return new Promise((resolve, reject) => {
-      cp.exec(cmd, options, (error, stdout, stderr) => {
-        if (error) {
-          reject(error);
-        } else {
-          resolve({ stdout, stderr });
-        }
-      });
-    });
-  }
-
-  test("Test default encoding, which should be utf8", async () => {
-    const { stdout, stderr } = await run({});
-    expect(typeof stdout).toBe("string");
-    expect(typeof stderr).toBe("string");
-    expect(stdout).toBe(expectedStdout);
-    expect(stderr).toBe(expectedStderr);
-  });
-
-  test("Test explicit utf8 encoding", async () => {
-    const { stdout, stderr } = await run({ encoding: "utf8" });
-    expect(typeof stdout).toBe("string");
-    expect(typeof stderr).toBe("string");
-    expect(stdout).toBe(expectedStdout);
-    expect(stderr).toBe(expectedStderr);
-  });
-
-  test("Test cases that result in buffer encodings", async () => {
-    const encodings = [undefined, null, "buffer", "invalid"];
-
-    for (const encoding of encodings) {
-      const { stdout, stderr } = await run({ encoding });
-      expect(stdout).toBeInstanceOf(Buffer);
-      expect(stderr).toBeInstanceOf(Buffer);
-      expect(stdout.toString()).toBe(expectedStdout);
-      expect(stderr.toString()).toBe(expectedStderr);
-    }
-  });
-}
-
-//<#END_FILE: test-child-process-exec-encoding.js
diff --git a/test/js/node/test/parallel/child-process-exec-env.test.js b/test/js/node/test/parallel/child-process-exec-env.test.js
deleted file mode 100644
index 1649fad830..0000000000
--- a/test/js/node/test/parallel/child-process-exec-env.test.js
+++ /dev/null
@@ -1,50 +0,0 @@
-//#FILE: test-child-process-exec-env.js
-//#SHA1: cba9b5f7a9d1ab7cd674bde00c1c4184470e4899
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const { isWindows } = require("../common");
-const { exec } = require("child_process");
-const util = require("util");
-
-const execPromise = util.promisify(exec);
-
-test("exec with custom environment", async () => {
-  let command, options;
-
-  if (!isWindows) {
-    command = "/usr/bin/env";
-    options = { env: { HELLO: "WORLD" } };
-  } else {
-    command = "set";
-    options = { env: { ...process.env, HELLO: "WORLD" } };
-  }
-
-  const { stdout, stderr } = await execPromise(command, options);
-
-  expect(stdout).not.toBe("");
-  expect(stdout).toContain("HELLO=WORLD");
-  expect(stderr).toBe("");
-});
-
-//<#END_FILE: test-child-process-exec-env.js
diff --git a/test/js/node/test/parallel/child-process-exec-kill-throws.test.js b/test/js/node/test/parallel/child-process-exec-kill-throws.test.js
deleted file mode 100644
index b0b8482f24..0000000000
--- a/test/js/node/test/parallel/child-process-exec-kill-throws.test.js
+++ /dev/null
@@ -1,46 +0,0 @@
-//#FILE: test-child-process-exec-kill-throws.js
-//#SHA1: 968879ddf3244351dea40c681343ea8defc02a0b
-//-----------------
-"use strict";
-
-const cp = require("child_process");
-
-if (process.argv[2] === "child") {
-  // Since maxBuffer is 0, this should trigger an error.
-  console.log("foo");
-} else {
-  const originalKill = cp.ChildProcess.prototype.kill;
-
-  beforeEach(() => {
-    // Monkey patch ChildProcess#kill() to kill the process and then throw.
-    cp.ChildProcess.prototype.kill = function () {
-      originalKill.apply(this, arguments);
-      throw new Error("mock error");
-    };
-  });
-
-  afterEach(() => {
-    // Restore original kill method
-    cp.ChildProcess.prototype.kill = originalKill;
-  });
-
-  test("ChildProcess#kill() throws error", done => {
-    const cmd = `"${process.execPath}" "${__filename}" child`;
-    const options = { maxBuffer: 0, killSignal: "SIGKILL" };
-
-    const child = cp.exec(cmd, options, (err, stdout, stderr) => {
-      // Verify that if ChildProcess#kill() throws, the error is reported.
-      expect(err).toEqual(
-        expect.objectContaining({
-          message: "mock error",
-        }),
-      );
-      expect(stdout).toBe("");
-      expect(stderr).toBe("");
-      expect(child.killed).toBe(true);
-      done();
-    });
-  });
-}
-
-//<#END_FILE: test-child-process-exec-kill-throws.js
diff --git a/test/js/node/test/parallel/child-process-exec-std-encoding.test.js b/test/js/node/test/parallel/child-process-exec-std-encoding.test.js
deleted file mode 100644
index 010bc7097e..0000000000
--- a/test/js/node/test/parallel/child-process-exec-std-encoding.test.js
+++ /dev/null
@@ -1,31 +0,0 @@
-//#FILE: test-child-process-exec-std-encoding.js
-//#SHA1: fa74583780f5256e46fd7a5ad02aed4b20bb0b76
-//-----------------
-"use strict";
-
-const cp = require("child_process");
-
-const stdoutData = "foo";
-const stderrData = "bar";
-const expectedStdout = `${stdoutData}\n`;
-const expectedStderr = `${stderrData}\n`;
-
-if (process.argv[2] === "child") {
-  // The following console calls are part of the test.
-  console.log(stdoutData);
-  console.error(stderrData);
-} else {
-  test("child process exec with stdout and stderr encoding", done => {
-    const cmd = `"${process.execPath}" "${__filename}" child`;
-    const child = cp.exec(cmd, (error, stdout, stderr) => {
-      expect(error).toBeNull();
-      expect(stdout).toBe(expectedStdout);
-      expect(stderr).toBe(expectedStderr);
-      done();
-    });
-    child.stdout.setEncoding("utf-8");
-    child.stderr.setEncoding("utf-8");
-  });
-}
-
-//<#END_FILE: test-child-process-exec-std-encoding.js
diff --git a/test/js/node/test/parallel/child-process-exec-stdout-stderr-data-string.test.js b/test/js/node/test/parallel/child-process-exec-stdout-stderr-data-string.test.js
deleted file mode 100644
index 42a1a555ab..0000000000
--- a/test/js/node/test/parallel/child-process-exec-stdout-stderr-data-string.test.js
+++ /dev/null
@@ -1,34 +0,0 @@
-//#FILE: test-child-process-exec-stdout-stderr-data-string.js
-//#SHA1: 342c40f3dbb506150172c2471ae228fd8632b900
-//-----------------
-"use strict";
-// Refs: https://github.com/nodejs/node/issues/7342
-const { exec } = require("child_process");
-
-const command = process.platform === "win32" ? "dir" : "ls";
-
-test("exec stdout data is called at least once", done => {
-  const child = exec(command);
-  const onData = jest.fn();
-  child.stdout.on("data", onData);
-
-  child.on("close", () => {
-    expect(onData).toHaveBeenCalled();
-    done();
-  });
-});
-
-test("exec stderr data is called at least once and receives string", done => {
-  const child = exec("fhqwhgads");
-  const onData = jest.fn(data => {
-    expect(typeof data).toBe("string");
-  });
-  child.stderr.on("data", onData);
-
-  child.on("close", () => {
-    expect(onData).toHaveBeenCalled();
-    done();
-  });
-});
-
-//<#END_FILE: test-child-process-exec-stdout-stderr-data-string.js
diff --git a/test/js/node/test/parallel/child-process-exec-timeout-kill.test.js b/test/js/node/test/parallel/child-process-exec-timeout-kill.test.js
deleted file mode 100644
index 4aa9e93d26..0000000000
--- a/test/js/node/test/parallel/child-process-exec-timeout-kill.test.js
+++ /dev/null
@@ -1,49 +0,0 @@
-//#FILE: test-child-process-exec-timeout-kill.js
-//#SHA1: 01bc25d258b4d8905a2387e9a08b9ceb8c38c141
-//-----------------
-"use strict";
-
-// Test exec() with both a timeout and a killSignal.
-
-const cp = require("child_process");
-const path = require("path");
-
-const { kExpiringChildRunTime, kExpiringParentTimer } = require("../common/child_process");
-
-const logAfterTime = time => {
-  setTimeout(() => {
-    console.log(`Logged after ${time}ms`);
-  }, time);
-};
-
-if (process.argv[2] === "child") {
-  logAfterTime(kExpiringChildRunTime);
-  process.exit(0);
-}
-
-const cmd = `"${process.execPath}" "${__filename}" child`;
-
-test("exec with timeout and killSignal", done => {
-  // Test with a different kill signal.
-  cp.exec(
-    cmd,
-    {
-      timeout: kExpiringParentTimer,
-      killSignal: "SIGKILL",
-    },
-    (err, stdout, stderr) => {
-      console.log("[stdout]", stdout.trim());
-      console.log("[stderr]", stderr.trim());
-
-      expect(err.killed).toBe(true);
-      expect(err.code).toBeNull();
-      expect(err.signal).toBe("SIGKILL");
-      expect(err.cmd).toBe(cmd);
-      expect(stdout.trim()).toBe("");
-      expect(stderr.trim()).toBe("");
-      done();
-    },
-  );
-});
-
-//<#END_FILE: test-child-process-exec-timeout-kill.js
diff --git a/test/js/node/test/parallel/child-process-execfile-promisified-abortcontroller.test.js b/test/js/node/test/parallel/child-process-execfile-promisified-abortcontroller.test.js
deleted file mode 100644
index acebc661e9..0000000000
--- a/test/js/node/test/parallel/child-process-execfile-promisified-abortcontroller.test.js
+++ /dev/null
@@ -1,57 +0,0 @@
-//#FILE: test-child-process-execFile-promisified-abortController.js
-//#SHA1: 133445acf9aaafea4be11eb7965f222c5827f2f3
-//-----------------
-"use strict";
-
-const { promisify } = require("util");
-const execFile = require("child_process").execFile;
-const fixtures = require("../common/fixtures");
-
-const echoFixture = fixtures.path("echo.js");
-const promisified = promisify(execFile);
-const invalidArgTypeError = {
-  code: "ERR_INVALID_ARG_TYPE",
-  name: "TypeError",
-};
-
-test("Verify that the signal option works properly", async () => {
-  const ac = new AbortController();
-  const signal = ac.signal;
-  const promise = promisified(process.execPath, [echoFixture, 0], { signal });
-
-  ac.abort();
-
-  await expect(promise).rejects.toThrow(
-    expect.objectContaining({
-      name: "AbortError",
-      message: expect.any(String),
-    }),
-  );
-});
-
-test("Verify that the signal option works properly when already aborted", async () => {
-  const signal = AbortSignal.abort();
-
-  await expect(promisified(process.execPath, [echoFixture, 0], { signal })).rejects.toThrow(
-    expect.objectContaining({
-      name: "AbortError",
-      message: expect.any(String),
-    }),
-  );
-});
-
-test("Verify that if something different than Abortcontroller.signal is passed, ERR_INVALID_ARG_TYPE is thrown", () => {
-  const signal = {};
-  expect(() => {
-    promisified(process.execPath, [echoFixture, 0], { signal });
-  }).toThrow(expect.objectContaining(invalidArgTypeError));
-});
-
-test("Verify that if a string is passed as signal, ERR_INVALID_ARG_TYPE is thrown", () => {
-  const signal = "world!";
-  expect(() => {
-    promisified(process.execPath, [echoFixture, 0], { signal });
-  }).toThrow(expect.objectContaining(invalidArgTypeError));
-});
-
-//<#END_FILE: test-child-process-execFile-promisified-abortController.js
diff --git a/test/js/node/test/parallel/child-process-flush-stdio.test.js b/test/js/node/test/parallel/child-process-flush-stdio.test.js
deleted file mode 100644
index 53e4419b66..0000000000
--- a/test/js/node/test/parallel/child-process-flush-stdio.test.js
+++ /dev/null
@@ -1,41 +0,0 @@
-//#FILE: test-child-process-flush-stdio.js
-//#SHA1: 42d6ab8508587f13b81d2ec70d28fd88efe8fe05
-//-----------------
-"use strict";
-
-const cp = require("child_process");
-
-// Windows' `echo` command is a built-in shell command and not an external
-// executable like on *nix
-const opts = { shell: process.platform === "win32" };
-
-test("spawn echo without arguments", done => {
-  const p = cp.spawn("echo", [], opts);
-
-  p.on("close", (code, signal) => {
-    expect(code).toBe(0);
-    expect(signal).toBeNull();
-    done();
-  });
-
-  p.stdout.read();
-});
-
-test("spawn echo with argument", done => {
-  const buffer = [];
-  const p = cp.spawn("echo", ["123"], opts);
-
-  p.on("close", (code, signal) => {
-    expect(code).toBe(0);
-    expect(signal).toBeNull();
-    expect(Buffer.concat(buffer).toString().trim()).toBe("123");
-    done();
-  });
-
-  p.stdout.on("readable", () => {
-    let buf;
-    while ((buf = p.stdout.read()) !== null) buffer.push(buf);
-  });
-});
-
-//<#END_FILE: test-child-process-flush-stdio.js
diff --git a/test/js/node/test/parallel/child-process-fork-abort-signal.test.js b/test/js/node/test/parallel/child-process-fork-abort-signal.test.js
deleted file mode 100644
index f3c1dcfe65..0000000000
--- a/test/js/node/test/parallel/child-process-fork-abort-signal.test.js
+++ /dev/null
@@ -1,115 +0,0 @@
-//#FILE: test-child-process-fork-abort-signal.js
-//#SHA1: 4805d5dd4e3cb22ffd5a21fd9d92b6ccd6bc73cf
-//-----------------
-"use strict";
-
-const fixtures = require("../common/fixtures");
-const { fork } = require("child_process");
-
-test("aborting a forked child_process after calling fork", done => {
-  const ac = new AbortController();
-  const { signal } = ac;
-  const cp = fork(fixtures.path("child-process-stay-alive-forever.js"), {
-    signal,
-  });
-  cp.on("exit", (code, killSignal) => {
-    expect(code).toBeNull();
-    expect(killSignal).toBe("SIGTERM");
-    done();
-  });
-  cp.on("error", err => {
-    expect(err.name).toBe("AbortError");
-    done();
-  });
-  process.nextTick(() => ac.abort());
-});
-
-test("aborting with custom error", done => {
-  const ac = new AbortController();
-  const { signal } = ac;
-  const cp = fork(fixtures.path("child-process-stay-alive-forever.js"), {
-    signal,
-  });
-  cp.on("exit", (code, killSignal) => {
-    expect(code).toBeNull();
-    expect(killSignal).toBe("SIGTERM");
-    done();
-  });
-  cp.on("error", err => {
-    expect(err.name).toBe("AbortError");
-    expect(err.cause.name).toBe("Error");
-    expect(err.cause.message).toBe("boom");
-    done();
-  });
-  process.nextTick(() => ac.abort(new Error("boom")));
-});
-
-test("passing an already aborted signal to a forked child_process", done => {
-  const signal = AbortSignal.abort();
-  const cp = fork(fixtures.path("child-process-stay-alive-forever.js"), {
-    signal,
-  });
-  cp.on("exit", (code, killSignal) => {
-    expect(code).toBeNull();
-    expect(killSignal).toBe("SIGTERM");
-    done();
-  });
-  cp.on("error", err => {
-    expect(err.name).toBe("AbortError");
-    done();
-  });
-});
-
-test("passing an aborted signal with custom error to a forked child_process", done => {
-  const signal = AbortSignal.abort(new Error("boom"));
-  const cp = fork(fixtures.path("child-process-stay-alive-forever.js"), {
-    signal,
-  });
-  cp.on("exit", (code, killSignal) => {
-    expect(code).toBeNull();
-    expect(killSignal).toBe("SIGTERM");
-    done();
-  });
-  cp.on("error", err => {
-    expect(err.name).toBe("AbortError");
-    expect(err.cause.name).toBe("Error");
-    expect(err.cause.message).toBe("boom");
-    done();
-  });
-});
-
-test("passing a different kill signal", done => {
-  const signal = AbortSignal.abort();
-  const cp = fork(fixtures.path("child-process-stay-alive-forever.js"), {
-    signal,
-    killSignal: "SIGKILL",
-  });
-  cp.on("exit", (code, killSignal) => {
-    expect(code).toBeNull();
-    expect(killSignal).toBe("SIGKILL");
-    done();
-  });
-  cp.on("error", err => {
-    expect(err.name).toBe("AbortError");
-    done();
-  });
-});
-
-test("aborting a cp before close but after exit", done => {
-  const ac = new AbortController();
-  const { signal } = ac;
-  const cp = fork(fixtures.path("child-process-stay-alive-forever.js"), {
-    signal,
-  });
-  cp.on("exit", () => {
-    ac.abort();
-    done();
-  });
-  cp.on("error", () => {
-    done(new Error("Should not have errored"));
-  });
-
-  setTimeout(() => cp.kill(), 1);
-});
-
-//<#END_FILE: test-child-process-fork-abort-signal.js
diff --git a/test/js/node/test/parallel/child-process-fork-args.test.js b/test/js/node/test/parallel/child-process-fork-args.test.js
deleted file mode 100644
index f2efa98aa5..0000000000
--- a/test/js/node/test/parallel/child-process-fork-args.test.js
+++ /dev/null
@@ -1,88 +0,0 @@
-//#FILE: test-child-process-fork-args.js
-//#SHA1: 172297ab2ed7887ced1b830b8c36d2d6a508deed
-//-----------------
-"use strict";
-const fixtures = require("../common/fixtures");
-const { fork } = require("child_process");
-
-// This test check the arguments of `fork` method
-// Refs: https://github.com/nodejs/node/issues/20749
-const expectedEnv = { foo: "bar" };
-
-// Ensure that first argument `modulePath` must be provided
-// and be of type string
-test("fork modulePath argument must be a string", () => {
-  const invalidModulePath = [0, true, undefined, null, [], {}, () => {}, Symbol("t")];
-  invalidModulePath.forEach(modulePath => {
-    expect(() => fork(modulePath)).toThrow(
-      expect.objectContaining({
-        code: "ERR_INVALID_ARG_TYPE",
-        name: "TypeError",
-        message: expect.stringMatching(/^The "modulePath" argument must be of type string/),
-      }),
-    );
-  });
-});
-
-test("fork with valid modulePath", done => {
-  const cp = fork(fixtures.path("child-process-echo-options.js"));
-  cp.on("exit", code => {
-    expect(code).toBe(0);
-    done();
-  });
-});
-
-// Ensure that the second argument of `fork`
-// and `fork` should parse options
-// correctly if args is undefined or null
-test("fork second argument validation", () => {
-  const invalidSecondArgs = [0, true, () => {}, Symbol("t")];
-  invalidSecondArgs.forEach(arg => {
-    expect(() => {
-      fork(fixtures.path("child-process-echo-options.js"), arg);
-    }).toThrow(
-      expect.objectContaining({
-        code: "ERR_INVALID_ARG_TYPE",
-        name: "TypeError",
-      }),
-    );
-  });
-});
-
-test("fork with valid second argument", async () => {
-  const argsLists = [undefined, null, []];
-
-  for (const args of argsLists) {
-    const cp = fork(fixtures.path("child-process-echo-options.js"), args, {
-      env: { ...process.env, ...expectedEnv },
-    });
-
-    await new Promise(resolve => {
-      cp.on("message", ({ env }) => {
-        expect(env.foo).toBe(expectedEnv.foo);
-      });
-
-      cp.on("exit", code => {
-        expect(code).toBe(0);
-        resolve();
-      });
-    });
-  }
-});
-
-// Ensure that the third argument should be type of object if provided
-test("fork third argument must be an object if provided", () => {
-  const invalidThirdArgs = [0, true, () => {}, Symbol("t")];
-  invalidThirdArgs.forEach(arg => {
-    expect(() => {
-      fork(fixtures.path("child-process-echo-options.js"), [], arg);
-    }).toThrow(
-      expect.objectContaining({
-        code: "ERR_INVALID_ARG_TYPE",
-        name: "TypeError",
-      }),
-    );
-  });
-});
-
-//<#END_FILE: test-child-process-fork-args.js
diff --git a/test/js/node/test/parallel/child-process-fork-close.test.js b/test/js/node/test/parallel/child-process-fork-close.test.js
deleted file mode 100644
index d7dd94759a..0000000000
--- a/test/js/node/test/parallel/child-process-fork-close.test.js
+++ /dev/null
@@ -1,68 +0,0 @@
-//#FILE: test-child-process-fork-close.js
-//#SHA1: d196e4b4f06991be7c2a48169cb89b815c0f172b
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const { fork } = require("child_process");
-const path = require("path");
-
-test("child process fork close events", async () => {
-  const cp = fork(path.resolve(__dirname, "../fixtures/child-process-message-and-exit.js"));
-
-  let gotMessage = false;
-  let gotExit = false;
-  let gotClose = false;
-
-  const messagePromise = new Promise(resolve => {
-    cp.on("message", message => {
-      expect(gotMessage).toBe(false);
-      expect(gotClose).toBe(false);
-      expect(message).toBe("hello");
-      gotMessage = true;
-      resolve();
-    });
-  });
-
-  const exitPromise = new Promise(resolve => {
-    cp.on("exit", () => {
-      expect(gotExit).toBe(false);
-      expect(gotClose).toBe(false);
-      gotExit = true;
-      resolve();
-    });
-  });
-
-  const closePromise = new Promise(resolve => {
-    cp.on("close", () => {
-      expect(gotMessage).toBe(true);
-      expect(gotExit).toBe(true);
-      expect(gotClose).toBe(false);
-      gotClose = true;
-      resolve();
-    });
-  });
-
-  await Promise.all([messagePromise, exitPromise, closePromise]);
-});
-
-//<#END_FILE: test-child-process-fork-close.js
diff --git a/test/js/node/test/parallel/child-process-fork-detached.test.js b/test/js/node/test/parallel/child-process-fork-detached.test.js
deleted file mode 100644
index 18c3f6a0cb..0000000000
--- a/test/js/node/test/parallel/child-process-fork-detached.test.js
+++ /dev/null
@@ -1,31 +0,0 @@
-//#FILE: test-child-process-fork-detached.js
-//#SHA1: 289d7a5f7c5d58ae50a06e7427730c57d78fe39c
-//-----------------
-"use strict";
-
-const { fork } = require("child_process");
-const path = require("path");
-
-const fixturesPath = path.resolve(__dirname, "..", "fixtures");
-
-test("fork detached child process", done => {
-  const nonPersistentNode = fork(path.join(fixturesPath, "parent-process-nonpersistent-fork.js"), [], { silent: true });
-
-  let childId = -1;
-
-  nonPersistentNode.stdout.on("data", data => {
-    childId = parseInt(data, 10);
-    nonPersistentNode.kill();
-  });
-
-  nonPersistentNode.on("exit", () => {
-    expect(childId).not.toBe(-1);
-
-    // Killing the child process should not throw an error
-    expect(() => process.kill(childId)).not.toThrow();
-
-    done();
-  });
-});
-
-//<#END_FILE: test-child-process-fork-detached.js
diff --git a/test/js/node/test/parallel/child-process-fork-ref2.test.js b/test/js/node/test/parallel/child-process-fork-ref2.test.js
deleted file mode 100644
index ecea4bfd3a..0000000000
--- a/test/js/node/test/parallel/child-process-fork-ref2.test.js
+++ /dev/null
@@ -1,69 +0,0 @@
-//#FILE: test-child-process-fork-ref2.js
-//#SHA1: 6d8a2bec4198f9d9f71ce9f2cc880cfcd1c9d883
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const { fork } = require("child_process");
-const { debuglog } = require("util");
-const debug = debuglog("test");
-
-const platformTimeout = ms => ms;
-
-if (process.argv[2] === "child") {
-  test("child process", () => {
-    debug("child -> call disconnect");
-    process.disconnect();
-
-    return new Promise(resolve => {
-      setTimeout(() => {
-        debug("child -> will this keep it alive?");
-        const mockFn = jest.fn();
-        process.on("message", mockFn);
-        expect(mockFn).not.toHaveBeenCalled();
-        resolve();
-      }, platformTimeout(400));
-    });
-  });
-} else {
-  test("parent process", () => {
-    return new Promise(resolve => {
-      const child = fork(__filename, ["child"]);
-
-      const disconnectSpy = jest.fn(() => {
-        debug("parent -> disconnect");
-      });
-      child.on("disconnect", disconnectSpy);
-
-      const exitSpy = jest.fn(() => {
-        debug("parent -> exit");
-        expect(disconnectSpy).toHaveBeenCalledTimes(1);
-        resolve();
-      });
-      child.once("exit", exitSpy);
-
-      expect(exitSpy).toHaveBeenCalledTimes(0);
-    });
-  });
-}
-
-//<#END_FILE: test-child-process-fork-ref2.js
diff --git a/test/js/node/test/parallel/child-process-fork3.test.js b/test/js/node/test/parallel/child-process-fork3.test.js
deleted file mode 100644
index ab5558264a..0000000000
--- a/test/js/node/test/parallel/child-process-fork3.test.js
+++ /dev/null
@@ -1,36 +0,0 @@
-//#FILE: test-child-process-fork3.js
-//#SHA1: afa7c58bf22c64585426b2b3ec4358a415f4ff47
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const child_process = require("child_process");
-const path = require("path");
-
-test("child_process.fork should not hang", () => {
-  const emptyScriptPath = path.join(__dirname, "fixtures", "empty.js");
-  expect(() => {
-    child_process.fork(emptyScriptPath);
-  }).not.toThrow();
-});
-
-//<#END_FILE: test-child-process-fork3.js
diff --git a/test/js/node/test/parallel/child-process-kill.test.js b/test/js/node/test/parallel/child-process-kill.test.js
deleted file mode 100644
index 5a9ece5e38..0000000000
--- a/test/js/node/test/parallel/child-process-kill.test.js
+++ /dev/null
@@ -1,58 +0,0 @@
-//#FILE: test-child-process-kill.js
-//#SHA1: 308c453d51a13e0e2c640969456c0092ab00967d
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const { spawn } = require("child_process");
-const isWindows = process.platform === "win32";
-
-test("child process kill behavior", async () => {
-  const cat = spawn(isWindows ? "cmd" : "cat");
-
-  const stdoutEndPromise = new Promise(resolve => {
-    cat.stdout.on("end", resolve);
-  });
-
-  const stderrDataPromise = new Promise((resolve, reject) => {
-    cat.stderr.on("data", () => reject(new Error("stderr should not receive data")));
-    cat.stderr.on("end", resolve);
-  });
-
-  const exitPromise = new Promise(resolve => {
-    cat.on("exit", (code, signal) => {
-      expect(code).toBeNull();
-      expect(signal).toBe("SIGTERM");
-      expect(cat.signalCode).toBe("SIGTERM");
-      resolve();
-    });
-  });
-
-  expect(cat.signalCode).toBeNull();
-  expect(cat.killed).toBe(false);
-  cat.kill();
-  expect(cat.killed).toBe(true);
-
-  await Promise.all([stdoutEndPromise, stderrDataPromise, exitPromise]);
-});
-
-//<#END_FILE: test-child-process-kill.js
diff --git a/test/js/node/test/parallel/child-process-send-type-error.test.js b/test/js/node/test/parallel/child-process-send-type-error.test.js
deleted file mode 100644
index cc4908b7da..0000000000
--- a/test/js/node/test/parallel/child-process-send-type-error.test.js
+++ /dev/null
@@ -1,49 +0,0 @@
-//#FILE: test-child-process-send-type-error.js
-//#SHA1: 85b82f9c15ca3d5368e22ccd1e7f44672ce2fb0c
-//-----------------
-"use strict";
-
-const cp = require("child_process");
-
-function fail(proc, args) {
-  expect(() => {
-    proc.send.apply(proc, args);
-  }).toThrow(
-    expect.objectContaining({
-      code: "ERR_INVALID_ARG_TYPE",
-      name: "TypeError",
-    }),
-  );
-}
-
-let target = process;
-
-if (process.argv[2] !== "child") {
-  test("child process send type error", () => {
-    target = cp.fork(__filename, ["child"]);
-    target.on("exit", (code, signal) => {
-      expect(code).toBe(0);
-      expect(signal).toBeNull();
-    });
-
-    fail(target, ["msg", null, null]);
-    fail(target, ["msg", null, ""]);
-    fail(target, ["msg", null, "foo"]);
-    fail(target, ["msg", null, 0]);
-    fail(target, ["msg", null, NaN]);
-    fail(target, ["msg", null, 1]);
-    fail(target, ["msg", null, null, jest.fn()]);
-  });
-} else {
-  test("process send type error", () => {
-    fail(target, ["msg", null, null]);
-    fail(target, ["msg", null, ""]);
-    fail(target, ["msg", null, "foo"]);
-    fail(target, ["msg", null, 0]);
-    fail(target, ["msg", null, NaN]);
-    fail(target, ["msg", null, 1]);
-    fail(target, ["msg", null, null, jest.fn()]);
-  });
-}
-
-//<#END_FILE: test-child-process-send-type-error.js
diff --git a/test/js/node/test/parallel/child-process-set-blocking.test.js b/test/js/node/test/parallel/child-process-set-blocking.test.js
deleted file mode 100644
index a8288fc114..0000000000
--- a/test/js/node/test/parallel/child-process-set-blocking.test.js
+++ /dev/null
@@ -1,43 +0,0 @@
-//#FILE: test-child-process-set-blocking.js
-//#SHA1: 2855d3d616c7af61fc6b84705cd05515f02bcb47
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const { spawn } = require("child_process");
-const os = require("os");
-
-const SIZE = 100000;
-const python = process.env.PYTHON || (os.platform() === "win32" ? "python" : "python3");
-
-test("child process set blocking", done => {
-  const cp = spawn(python, ["-c", `print(${SIZE} * "C")`], {
-    stdio: "inherit",
-  });
-
-  cp.on("exit", code => {
-    expect(code).toBe(0);
-    done();
-  });
-});
-
-//<#END_FILE: test-child-process-set-blocking.js
diff --git a/test/js/node/test/parallel/child-process-spawnsync-env.test.js b/test/js/node/test/parallel/child-process-spawnsync-env.test.js
deleted file mode 100644
index e6368f7e38..0000000000
--- a/test/js/node/test/parallel/child-process-spawnsync-env.test.js
+++ /dev/null
@@ -1,41 +0,0 @@
-//#FILE: test-child-process-spawnsync-env.js
-//#SHA1: 21ad31214e1261fb3c2636bd98d36946e5be67de
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const cp = require("child_process");
-
-if (process.argv[2] === "child") {
-  console.log(process.env.foo);
-} else {
-  test("spawnSync with custom environment", () => {
-    const expected = "bar";
-    const child = cp.spawnSync(process.execPath, [__filename, "child"], {
-      env: Object.assign({}, process.env, { foo: expected }),
-    });
-
-    expect(child.stdout.toString().trim()).toBe(expected);
-  });
-}
-
-//<#END_FILE: test-child-process-spawnsync-env.js
diff --git a/test/js/node/test/parallel/child-process-stdio-big-write-end.test.js b/test/js/node/test/parallel/child-process-stdio-big-write-end.test.js
deleted file mode 100644
index ff1ea0cc16..0000000000
--- a/test/js/node/test/parallel/child-process-stdio-big-write-end.test.js
+++ /dev/null
@@ -1,92 +0,0 @@
-//#FILE: test-child-process-stdio-big-write-end.js
-//#SHA1: 728a12ebb5484fcc628e82386c3b521ab95e0456
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const { spawn } = require("child_process");
-const assert = require("assert");
-const debug = require("util").debuglog("test");
-
-let bufsize = 0;
-
-function runParent() {
-  return new Promise(resolve => {
-    const child = spawn(process.execPath, [__filename, "child"]);
-    let sent = 0;
-
-    let n = "";
-    child.stdout.setEncoding("ascii");
-    child.stdout.on("data", c => {
-      n += c;
-    });
-    child.stdout.on("end", () => {
-      expect(+n).toBe(sent);
-      debug("ok");
-      resolve();
-    });
-
-    // Write until the buffer fills up.
-    let buf;
-    do {
-      bufsize += 1024;
-      buf = Buffer.alloc(bufsize, ".");
-      sent += bufsize;
-    } while (child.stdin.write(buf));
-
-    // Then write a bunch more times.
-    for (let i = 0; i < 100; i++) {
-      const buf = Buffer.alloc(bufsize, ".");
-      sent += bufsize;
-      child.stdin.write(buf);
-    }
-
-    // Now end, before it's all flushed.
-    child.stdin.end();
-
-    // now we wait...
-  });
-}
-
-function runChild() {
-  return new Promise(resolve => {
-    let received = 0;
-    process.stdin.on("data", c => {
-      received += c.length;
-    });
-    process.stdin.on("end", () => {
-      // This console.log is part of the test.
-      console.log(received);
-      resolve();
-    });
-  });
-}
-
-if (process.argv[2] === "child") {
-  runChild();
-} else {
-  test("child process stdio big write end", async () => {
-    await runParent();
-  });
-}
-
-//<#END_FILE: test-child-process-stdio-big-write-end.js
diff --git a/test/js/node/test/parallel/child-process-stdio-overlapped.test.js b/test/js/node/test/parallel/child-process-stdio-overlapped.test.js
deleted file mode 100644
index e37232fce3..0000000000
--- a/test/js/node/test/parallel/child-process-stdio-overlapped.test.js
+++ /dev/null
@@ -1,91 +0,0 @@
-//#FILE: test-child-process-stdio-overlapped.js
-//#SHA1: 20ead82f2ea74983af7bead33605fe8f33fccf6d
-//-----------------
-// Test for "overlapped" stdio option. This test uses the "overlapped-checker"
-// helper program which basically a specialized echo program.
-//
-// The test has two goals:
-//
-// - Verify that overlapped I/O works on windows. The test program will deadlock
-//   if stdin doesn't have the FILE_FLAG_OVERLAPPED flag set on startup (see
-//   test/overlapped-checker/main_win.c for more details).
-// - Verify that "overlapped" stdio option works transparently as a pipe (on
-//   unix/windows)
-//
-// This is how the test works:
-//
-// - This script assumes only numeric strings are written to the test program
-//   stdout.
-// - The test program will be spawned with "overlapped" set on stdin and "pipe"
-//   set on stdout/stderr and at startup writes a number to its stdout
-// - When this script receives some data, it will parse the number, add 50 and
-//   write to the test program's stdin.
-// - The test program will then echo the number back to us which will repeat the
-//   cycle until the number reaches 200, at which point we send the "exit"
-//   string, which causes the test program to exit.
-// - Extra assertion: Every time the test program writes a string to its stdout,
-//   it will write the number of bytes written to stderr.
-// - If overlapped I/O is not setup correctly, this test is going to hang.
-"use strict";
-const path = require("path");
-const child_process = require("child_process");
-const fs = require("fs");
-
-const exeExtension = process.platform === "win32" ? ".exe" : "";
-const exe = "overlapped-checker" + exeExtension;
-const exePath = path.join(path.dirname(process.execPath), exe);
-
-test("overlapped stdio option", async () => {
-  if (!fs.existsSync(exePath)) {
-    console.log(exe + " binary is not available");
-    return;
-  }
-
-  const child = child_process.spawn(exePath, [], {
-    stdio: ["overlapped", "pipe", "pipe"],
-  });
-
-  child.stdin.setEncoding("utf8");
-  child.stdout.setEncoding("utf8");
-  child.stderr.setEncoding("utf8");
-
-  function writeNext(n) {
-    child.stdin.write((n + 50).toString());
-  }
-
-  child.stdout.on("data", s => {
-    const n = Number(s);
-    if (n >= 200) {
-      child.stdin.write("exit");
-      return;
-    }
-    writeNext(n);
-  });
-
-  let stderr = "";
-  child.stderr.on("data", s => {
-    stderr += s;
-  });
-
-  await new Promise(resolve => {
-    child.stderr.on("end", resolve);
-  });
-
-  // This is the sequence of numbers sent to us:
-  // - 0 (1 byte written)
-  // - 50 (2 bytes written)
-  // - 100 (3 bytes written)
-  // - 150 (3 bytes written)
-  // - 200 (3 bytes written)
-  expect(stderr).toBe("12333");
-
-  const exitPromise = new Promise(resolve => {
-    child.on("exit", resolve);
-  });
-
-  const status = await exitPromise;
-  // The test program will return the number of writes as status code.
-  expect(status).toBe(0);
-});
-
-//<#END_FILE: test-child-process-stdio-overlapped.js
diff --git a/test/js/node/test/parallel/cli-eval-event.test.js b/test/js/node/test/parallel/cli-eval-event.test.js
deleted file mode 100644
index 152c3da4dc..0000000000
--- a/test/js/node/test/parallel/cli-eval-event.test.js
+++ /dev/null
@@ -1,26 +0,0 @@
-//#FILE: test-cli-eval-event.js
-//#SHA1: d64fa25056a9ecf2e87e46560d477b42d3e32909
-//-----------------
-"use strict";
-
-const { spawn } = require("child_process");
-
-test("CLI eval event", () => {
-  return new Promise(resolve => {
-    const child = spawn(process.execPath, [
-      "-e",
-      `
-      const server = require('net').createServer().listen(0);
-      server.once('listening', server.close);
-    `,
-    ]);
-
-    child.once("exit", (exitCode, signalCode) => {
-      expect(exitCode).toBe(0);
-      expect(signalCode).toBeNull();
-      resolve();
-    });
-  });
-});
-
-//<#END_FILE: test-cli-eval-event.js
diff --git a/test/js/node/test/parallel/client-request-destroy.test.js b/test/js/node/test/parallel/client-request-destroy.test.js
deleted file mode 100644
index 165fbbdd33..0000000000
--- a/test/js/node/test/parallel/client-request-destroy.test.js
+++ /dev/null
@@ -1,19 +0,0 @@
-//#FILE: test-client-request-destroy.js
-//#SHA1: 343919bc022f2956e9aab5c9a215cbadca2364f1
-//-----------------
-"use strict";
-
-// Test that http.ClientRequest.prototype.destroy() returns `this`.
-
-const http = require("http");
-
-test("http.ClientRequest.prototype.destroy() returns `this`", () => {
-  const clientRequest = new http.ClientRequest({ createConnection: () => {} });
-
-  expect(clientRequest.destroyed).toBe(false);
-  expect(clientRequest.destroy()).toBe(clientRequest);
-  expect(clientRequest.destroyed).toBe(true);
-  expect(clientRequest.destroy()).toBe(clientRequest);
-});
-
-//<#END_FILE: test-client-request-destroy.js
diff --git a/test/js/node/test/parallel/cluster-bind-privileged-port.test.js b/test/js/node/test/parallel/cluster-bind-privileged-port.test.js
deleted file mode 100644
index c83b370b56..0000000000
--- a/test/js/node/test/parallel/cluster-bind-privileged-port.test.js
+++ /dev/null
@@ -1,79 +0,0 @@
-//#FILE: test-cluster-bind-privileged-port.js
-//#SHA1: f3a12e75717db9c1a1edd4f51fb2985787a50706
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const cluster = require("cluster");
-const net = require("net");
-const { readFileSync } = require("fs");
-
-const isLinux = process.platform === "linux";
-const isOSX = process.platform === "darwin";
-const isIBMi = process.platform === "os400";
-const isWindows = process.platform === "win32";
-
-const skipTest = () => {
-  test.skip("Skipping test", () => {});
-  process.exit(0);
-};
-
-if (isLinux) {
-  try {
-    const unprivilegedPortStart = parseInt(readFileSync("/proc/sys/net/ipv4/ip_unprivileged_port_start"));
-    if (unprivilegedPortStart <= 42) {
-      skipTest();
-    }
-  } catch {
-    // Do nothing, feature doesn't exist, minimum is 1024 so 42 is usable.
-    // Continue...
-  }
-}
-
-// Skip on OS X Mojave. https://github.com/nodejs/node/issues/21679
-if (isOSX) skipTest();
-
-if (isIBMi) skipTest();
-
-if (isWindows) skipTest();
-
-if (process.getuid() === 0) skipTest();
-
-if (cluster.isPrimary) {
-  test("primary cluster process", () => {
-    const worker = cluster.fork();
-    worker.on("exit", exitCode => {
-      expect(exitCode).toBe(0);
-    });
-  });
-} else {
-  test("worker cluster process", () => {
-    const s = net.createServer(jest.fn());
-    s.listen(42, jest.fn());
-    s.on("error", err => {
-      expect(err.code).toBe("EACCES");
-      process.disconnect();
-    });
-  });
-}
-
-//<#END_FILE: test-cluster-bind-privileged-port.js
diff --git a/test/js/node/test/parallel/cluster-call-and-destroy.test.js b/test/js/node/test/parallel/cluster-call-and-destroy.test.js
deleted file mode 100644
index 1e2914833f..0000000000
--- a/test/js/node/test/parallel/cluster-call-and-destroy.test.js
+++ /dev/null
@@ -1,26 +0,0 @@
-//#FILE: test-cluster-call-and-destroy.js
-//#SHA1: 840777cd738f6257dd874035b1c0291ebe16e326
-//-----------------
-"use strict";
-const cluster = require("cluster");
-
-if (cluster.isPrimary) {
-  test("worker disconnection and destruction", () => {
-    const worker = cluster.fork();
-
-    return new Promise(resolve => {
-      worker.on("disconnect", () => {
-        expect(worker.isConnected()).toBe(false);
-        worker.destroy();
-        resolve();
-      });
-    });
-  });
-} else {
-  test("worker connection in child process", () => {
-    expect(cluster.worker.isConnected()).toBe(true);
-    cluster.worker.disconnect();
-  });
-}
-
-//<#END_FILE: test-cluster-call-and-destroy.js
diff --git a/test/js/node/test/parallel/cluster-dgram-reuse.test.js b/test/js/node/test/parallel/cluster-dgram-reuse.test.js
deleted file mode 100644
index 143db050b6..0000000000
--- a/test/js/node/test/parallel/cluster-dgram-reuse.test.js
+++ /dev/null
@@ -1,46 +0,0 @@
-//#FILE: test-cluster-dgram-reuse.js
-//#SHA1: b7bfc0764ebc95fa5ef85ce1d860aebd3f7df539
-//-----------------
-"use strict";
-
-const cluster = require("cluster");
-const dgram = require("dgram");
-
-if (process.platform === "win32") {
-  test.skip("dgram clustering is currently not supported on windows.");
-} else {
-  if (cluster.isPrimary) {
-    test("Primary process", () => {
-      const worker = cluster.fork();
-      worker.on("exit", code => {
-        expect(code).toBe(0);
-      });
-    });
-  } else {
-    test("Worker process", async () => {
-      let waiting = 2;
-      function close() {
-        if (--waiting === 0) cluster.worker.disconnect();
-      }
-
-      const options = { type: "udp4", reuseAddr: true };
-      const socket1 = dgram.createSocket(options);
-      const socket2 = dgram.createSocket(options);
-
-      await new Promise(resolve => {
-        socket1.bind(0, () => {
-          socket2.bind(socket1.address().port, () => {
-            // Work around health check issue
-            process.nextTick(() => {
-              socket1.close(close);
-              socket2.close(close);
-              resolve();
-            });
-          });
-        });
-      });
-    });
-  }
-}
-
-//<#END_FILE: test-cluster-dgram-reuse.js
diff --git a/test/js/node/test/parallel/cluster-disconnect-idle-worker.test.js b/test/js/node/test/parallel/cluster-disconnect-idle-worker.test.js
deleted file mode 100644
index 217060fd12..0000000000
--- a/test/js/node/test/parallel/cluster-disconnect-idle-worker.test.js
+++ /dev/null
@@ -1,49 +0,0 @@
-//#FILE: test-cluster-disconnect-idle-worker.js
-//#SHA1: f559db612db77271be32bab2d7cb9a4e38f28670
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const cluster = require("cluster");
-const fork = cluster.fork;
-
-if (cluster.isPrimary) {
-  test("cluster disconnect idle worker", async () => {
-    fork(); // It is intentionally called `fork` instead of
-    fork(); // `cluster.fork` to test that `this` is not used
-
-    const disconnectCallback = jest.fn(() => {
-      expect(Object.keys(cluster.workers)).toEqual([]);
-    });
-
-    await new Promise(resolve => {
-      cluster.disconnect(() => {
-        disconnectCallback();
-        resolve();
-      });
-    });
-
-    expect(disconnectCallback).toHaveBeenCalledTimes(1);
-  });
-}
-
-//<#END_FILE: test-cluster-disconnect-idle-worker.js
diff --git a/test/js/node/test/parallel/cluster-disconnect-with-no-workers.test.js b/test/js/node/test/parallel/cluster-disconnect-with-no-workers.test.js
deleted file mode 100644
index 01c67b2877..0000000000
--- a/test/js/node/test/parallel/cluster-disconnect-with-no-workers.test.js
+++ /dev/null
@@ -1,47 +0,0 @@
-//#FILE: test-cluster-disconnect-with-no-workers.js
-//#SHA1: 06b4a0a662491bd9593c303307535a635d69d53e
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const cluster = require("cluster");
-
-let disconnected = false;
-
-test("cluster.disconnect with no workers", async () => {
-  const disconnectPromise = new Promise(resolve => {
-    cluster.disconnect(() => {
-      disconnected = true;
-      resolve();
-    });
-  });
-
-  // Assert that callback is not sometimes synchronous
-  expect(disconnected).toBe(false);
-
-  await disconnectPromise;
-
-  // Assert that the callback was called
-  expect(disconnected).toBe(true);
-});
-
-//<#END_FILE: test-cluster-disconnect-with-no-workers.js
diff --git a/test/js/node/test/parallel/cluster-eaddrinuse.test.js b/test/js/node/test/parallel/cluster-eaddrinuse.test.js
deleted file mode 100644
index c72c6d6af5..0000000000
--- a/test/js/node/test/parallel/cluster-eaddrinuse.test.js
+++ /dev/null
@@ -1,94 +0,0 @@
-//#FILE: test-cluster-eaddrinuse.js
-//#SHA1: a17cbbd83e23565c1cb547999357c14f03be6efa
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-// Check that having a worker bind to a port that's already taken doesn't
-// leave the primary process in a confused state. Releasing the port and
-// trying again should Just Work[TM].
-
-const { fork } = require("child_process");
-const net = require("net");
-
-const id = String(process.argv[2]);
-const port = String(process.argv[3]);
-
-if (id === "undefined") {
-  test("primary process", async () => {
-    const server = net.createServer(() => {
-      throw new Error("Server should not receive connections");
-    });
-
-    await new Promise(resolve => {
-      server.listen(0, () => {
-        const worker = fork(__filename, ["worker", server.address().port]);
-        worker.on("message", msg => {
-          if (msg !== "stop-listening") return;
-          server.close(() => {
-            worker.send("stopped-listening");
-          });
-        });
-        resolve();
-      });
-    });
-  });
-} else if (id === "worker") {
-  test("worker process", async () => {
-    let server = net.createServer(() => {
-      throw new Error("Server should not receive connections");
-    });
-
-    await expect(
-      new Promise((resolve, reject) => {
-        server.listen(port, () => reject(new Error("Server should not listen")));
-        server.on("error", resolve);
-      }),
-    ).resolves.toMatchObject({
-      code: "EADDRINUSE",
-      message: expect.any(String),
-    });
-
-    process.send("stop-listening");
-
-    await new Promise(resolve => {
-      process.once("message", msg => {
-        if (msg !== "stopped-listening") return;
-        server = net.createServer(() => {
-          throw new Error("Server should not receive connections");
-        });
-        server.listen(port, () => {
-          server.close();
-          resolve();
-        });
-      });
-    });
-  });
-} else {
-  test("invalid argument", () => {
-    expect(() => {
-      throw new Error("Bad argument");
-    }).toThrow("Bad argument");
-  });
-}
-
-//<#END_FILE: test-cluster-eaddrinuse.js
diff --git a/test/js/node/test/parallel/cluster-listen-pipe-readable-writable.test.js b/test/js/node/test/parallel/cluster-listen-pipe-readable-writable.test.js
deleted file mode 100644
index ea008eda16..0000000000
--- a/test/js/node/test/parallel/cluster-listen-pipe-readable-writable.test.js
+++ /dev/null
@@ -1,44 +0,0 @@
-//#FILE: test-cluster-listen-pipe-readable-writable.js
-//#SHA1: ec8b0021cb41214529af900b088dce4d31db708d
-//-----------------
-"use strict";
-
-const cluster = require("cluster");
-const net = require("net");
-const fs = require("fs");
-const path = require("path");
-const os = require("os");
-
-const PIPE = path.join(os.tmpdir(), "test.sock");
-
-if (process.platform === "win32") {
-  test.skip("skip on Windows", () => {});
-} else {
-  if (cluster.isPrimary) {
-    test("cluster worker can listen on pipe with readable and writable permissions", () => {
-      const worker = cluster.fork();
-      worker.on("exit", code => {
-        expect(code).toBe(0);
-      });
-    });
-  } else {
-    test("server listens on pipe with correct permissions", done => {
-      const server = net.createServer().listen(
-        {
-          path: PIPE,
-          readableAll: true,
-          writableAll: true,
-        },
-        () => {
-          const stat = fs.statSync(PIPE);
-          expect(stat.mode & 0o777).toBe(0o777);
-          server.close();
-          process.disconnect();
-          done();
-        },
-      );
-    });
-  }
-}
-
-//<#END_FILE: test-cluster-listen-pipe-readable-writable.js
diff --git a/test/js/node/test/parallel/cluster-send-handle-twice.test.js b/test/js/node/test/parallel/cluster-send-handle-twice.test.js
deleted file mode 100644
index 06cb47d583..0000000000
--- a/test/js/node/test/parallel/cluster-send-handle-twice.test.js
+++ /dev/null
@@ -1,75 +0,0 @@
-//#FILE: test-cluster-send-handle-twice.js
-//#SHA1: d667e299035da70aa7831cb6964ba4e974c6bdc8
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-// Testing to send an handle twice to the primary process.
-
-const cluster = require("cluster");
-const net = require("net");
-
-const workers = {
-  toStart: 1,
-};
-
-if (cluster.isPrimary) {
-  test("primary process", () => {
-    for (let i = 0; i < workers.toStart; ++i) {
-      const worker = cluster.fork();
-      worker.on("exit", (code, signal) => {
-        expect(code).toBe(0);
-        expect(signal).toBeNull();
-      });
-    }
-  });
-} else {
-  test("worker process", async () => {
-    const server = net.createServer(socket => {
-      process.send("send-handle-1", socket);
-      process.send("send-handle-2", socket);
-    });
-
-    await new Promise((resolve, reject) => {
-      server.listen(0, () => {
-        const client = net.connect({
-          host: "localhost",
-          port: server.address().port,
-        });
-        client.on("close", () => {
-          cluster.worker.disconnect();
-          resolve();
-        });
-        client.on("connect", () => {
-          client.end();
-        });
-      });
-
-      server.on("error", e => {
-        console.error(e);
-        reject(new Error("server.listen failed"));
-      });
-    });
-  });
-}
-
-//<#END_FILE: test-cluster-send-handle-twice.js
diff --git a/test/js/node/test/parallel/cluster-setup-primary-cumulative.test.js b/test/js/node/test/parallel/cluster-setup-primary-cumulative.test.js
deleted file mode 100644
index 178c7f77ab..0000000000
--- a/test/js/node/test/parallel/cluster-setup-primary-cumulative.test.js
+++ /dev/null
@@ -1,64 +0,0 @@
-//#FILE: test-cluster-setup-primary-cumulative.js
-//#SHA1: 8a64228ac6d42c930b2426bbc53009f5d8b96a17
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const assert = require("assert");
-const cluster = require("cluster");
-
-test("cluster setup primary cumulative", () => {
-  expect(cluster.isPrimary).toBe(true);
-
-  // cluster.settings should not be initialized until needed
-  expect(cluster.settings).toEqual({});
-
-  cluster.setupPrimary();
-  expect(cluster.settings).toEqual({
-    args: process.argv.slice(2),
-    exec: process.argv[1],
-    execArgv: process.execArgv,
-    silent: false,
-  });
-
-  cluster.setupPrimary({ exec: "overridden" });
-  expect(cluster.settings.exec).toBe("overridden");
-
-  cluster.setupPrimary({ args: ["foo", "bar"] });
-  expect(cluster.settings.exec).toBe("overridden");
-  expect(cluster.settings.args).toEqual(["foo", "bar"]);
-
-  cluster.setupPrimary({ execArgv: ["baz", "bang"] });
-  expect(cluster.settings.exec).toBe("overridden");
-  expect(cluster.settings.args).toEqual(["foo", "bar"]);
-  expect(cluster.settings.execArgv).toEqual(["baz", "bang"]);
-
-  cluster.setupPrimary();
-  expect(cluster.settings).toEqual({
-    args: ["foo", "bar"],
-    exec: "overridden",
-    execArgv: ["baz", "bang"],
-    silent: false,
-  });
-});
-
-//<#END_FILE: test-cluster-setup-primary-cumulative.js
diff --git a/test/js/node/test/parallel/cluster-setup-primary-emit.test.js b/test/js/node/test/parallel/cluster-setup-primary-emit.test.js
deleted file mode 100644
index dc036034bd..0000000000
--- a/test/js/node/test/parallel/cluster-setup-primary-emit.test.js
+++ /dev/null
@@ -1,67 +0,0 @@
-//#FILE: test-cluster-setup-primary-emit.js
-//#SHA1: 965f86ef2ea557510e956759d3f540edfa7b03de
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const cluster = require("cluster");
-
-expect(cluster.isPrimary).toBe(true);
-
-function emitAndCatch(next) {
-  return new Promise(resolve => {
-    cluster.once("setup", settings => {
-      expect(settings.exec).toBe("new-exec");
-      setImmediate(() => {
-        next();
-        resolve();
-      });
-    });
-    cluster.setupPrimary({ exec: "new-exec" });
-  });
-}
-
-function emitAndCatch2(next) {
-  return new Promise(resolve => {
-    cluster.once("setup", settings => {
-      expect(settings).toHaveProperty("exec");
-      setImmediate(() => {
-        next();
-        resolve();
-      });
-    });
-    cluster.setupPrimary();
-  });
-}
-
-test("cluster setup primary emit", async () => {
-  const nextSpy1 = jest.fn();
-  const nextSpy2 = jest.fn();
-
-  await emitAndCatch(nextSpy1);
-  expect(nextSpy1).toHaveBeenCalledTimes(1);
-
-  await emitAndCatch2(nextSpy2);
-  expect(nextSpy2).toHaveBeenCalledTimes(1);
-});
-
-//<#END_FILE: test-cluster-setup-primary-emit.js
diff --git a/test/js/node/test/parallel/cluster-setup-primary-multiple.test.js b/test/js/node/test/parallel/cluster-setup-primary-multiple.test.js
deleted file mode 100644
index 05a3ca9cf5..0000000000
--- a/test/js/node/test/parallel/cluster-setup-primary-multiple.test.js
+++ /dev/null
@@ -1,78 +0,0 @@
-//#FILE: test-cluster-setup-primary-multiple.js
-//#SHA1: a0b16cb2b01b0265f98508f2a6a9974396b6b03a
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const cluster = require("cluster");
-const debug = require("util").debuglog("test");
-
-test("cluster setup primary multiple times", async () => {
-  expect(cluster.isPrimary).toBe(true);
-
-  // The cluster.settings object is cloned even though the current implementation
-  // makes that unnecessary. This is to make the test less fragile if the
-  // implementation ever changes such that cluster.settings is mutated instead of
-  // replaced.
-  const cheapClone = obj => JSON.parse(JSON.stringify(obj));
-
-  const configs = [];
-
-  // Capture changes
-  cluster.on("setup", () => {
-    debug(`"setup" emitted ${JSON.stringify(cluster.settings)}`);
-    configs.push(cheapClone(cluster.settings));
-  });
-
-  const execs = ["node-next", "node-next-2", "node-next-3"];
-
-  // Make changes to cluster settings
-  for (let i = 0; i < execs.length; i++) {
-    await new Promise(resolve => {
-      setTimeout(() => {
-        cluster.setupPrimary({ exec: execs[i] });
-        resolve();
-      }, i * 100);
-    });
-  }
-
-  // Cluster emits 'setup' asynchronously, so we must stay alive long
-  // enough for that to happen
-  await new Promise(resolve => {
-    setTimeout(
-      () => {
-        debug("cluster setup complete");
-        resolve();
-      },
-      (execs.length + 1) * 100,
-    );
-  });
-
-  // Tests that "setup" is emitted for every call to setupPrimary
-  expect(configs.length).toBe(execs.length);
-
-  expect(configs[0].exec).toBe(execs[0]);
-  expect(configs[1].exec).toBe(execs[1]);
-  expect(configs[2].exec).toBe(execs[2]);
-});
-
-//<#END_FILE: test-cluster-setup-primary-multiple.js
diff --git a/test/js/node/test/parallel/cluster-worker-constructor.test.js b/test/js/node/test/parallel/cluster-worker-constructor.test.js
deleted file mode 100644
index 470481560e..0000000000
--- a/test/js/node/test/parallel/cluster-worker-constructor.test.js
+++ /dev/null
@@ -1,59 +0,0 @@
-//#FILE: test-cluster-worker-constructor.js
-//#SHA1: ef3237d09cf6339e487f14c40d4c047c6871ead2
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-// test-cluster-worker-constructor.js
-// validates correct behavior of the cluster.Worker constructor
-
-const cluster = require("cluster");
-
-describe("cluster.Worker constructor", () => {
-  test("creates a worker with default values", () => {
-    const worker = new cluster.Worker();
-    expect(worker.exitedAfterDisconnect).toBeUndefined();
-    expect(worker.state).toBe("none");
-    expect(worker.id).toBe(0);
-    expect(worker.process).toBeUndefined();
-  });
-
-  test("creates a worker with custom values", () => {
-    const worker = new cluster.Worker({
-      id: 3,
-      state: "online",
-      process: process,
-    });
-    expect(worker.exitedAfterDisconnect).toBeUndefined();
-    expect(worker.state).toBe("online");
-    expect(worker.id).toBe(3);
-    expect(worker.process).toBe(process);
-  });
-
-  test("creates a worker using call method", () => {
-    const worker = cluster.Worker.call({}, { id: 5 });
-    expect(worker).toBeInstanceOf(cluster.Worker);
-    expect(worker.id).toBe(5);
-  });
-});
-
-//<#END_FILE: test-cluster-worker-constructor.js
diff --git a/test/js/node/test/parallel/cluster-worker-destroy.test.js b/test/js/node/test/parallel/cluster-worker-destroy.test.js
deleted file mode 100644
index 607cbbb866..0000000000
--- a/test/js/node/test/parallel/cluster-worker-destroy.test.js
+++ /dev/null
@@ -1,73 +0,0 @@
-//#FILE: test-cluster-worker-destroy.js
-//#SHA1: 277a85b7c8fdda347d1f753601ac4b843a9a1c8d
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-// The goal of this test is to cover the Workers' implementation of
-// Worker.prototype.destroy. Worker.prototype.destroy is called within
-// the worker's context: once when the worker is still connected to the
-// primary, and another time when it's not connected to it, so that we cover
-// both code paths.
-
-const assert = require("assert");
-const cluster = require("cluster");
-
-let worker1, worker2;
-
-if (cluster.isPrimary) {
-  test("primary process", () => {
-    worker1 = cluster.fork();
-    worker2 = cluster.fork();
-
-    [worker1, worker2].forEach(worker => {
-      const disconnectSpy = jest.fn();
-      const exitSpy = jest.fn();
-
-      worker.on("disconnect", disconnectSpy);
-      worker.on("exit", exitSpy);
-
-      worker.on("exit", () => {
-        expect(disconnectSpy).toHaveBeenCalledTimes(1);
-        expect(exitSpy).toHaveBeenCalledTimes(1);
-      });
-    });
-  });
-} else if (cluster.worker.id === 1) {
-  test("worker 1: call destroy when worker is disconnected", () => {
-    // Call destroy when worker is disconnected
-    cluster.worker.process.on("disconnect", () => {
-      cluster.worker.destroy();
-    });
-
-    const w = cluster.worker.disconnect();
-    expect(w).toBe(cluster.worker);
-  });
-} else {
-  test("worker 2: call destroy when worker is not disconnected yet", () => {
-    // Call destroy when worker is not disconnected yet
-    cluster.worker.destroy();
-  });
-}
-
-//<#END_FILE: test-cluster-worker-destroy.js
diff --git a/test/js/node/test/parallel/cluster-worker-handle-close.test.js b/test/js/node/test/parallel/cluster-worker-handle-close.test.js
deleted file mode 100644
index f6f608e0ac..0000000000
--- a/test/js/node/test/parallel/cluster-worker-handle-close.test.js
+++ /dev/null
@@ -1,59 +0,0 @@
-//#FILE: test-cluster-worker-handle-close.js
-//#SHA1: 8aa4bcd8641fe9274b97853b80734ea6f18eafbb
-//-----------------
-"use strict";
-const cluster = require("cluster");
-const net = require("net");
-
-if (cluster.isPrimary) {
-  test("Primary process", () => {
-    cluster.schedulingPolicy = cluster.SCHED_RR;
-    expect(cluster.fork).not.toThrow();
-  });
-} else {
-  let server;
-
-  beforeAll(() => {
-    server = net.createServer(jest.fn());
-  });
-
-  test("Worker process", done => {
-    const serverListenSpy = jest.spyOn(server, "listen");
-    const netConnectSpy = jest.spyOn(net, "connect");
-
-    server.listen(0, () => {
-      expect(serverListenSpy).toHaveBeenCalledTimes(1);
-      expect(netConnectSpy).toHaveBeenCalledWith(server.address().port);
-      done();
-    });
-  });
-
-  test("Internal message handling", done => {
-    const handleCloseSpy = jest.fn(callback => callback());
-    const handle = { close: handleCloseSpy };
-
-    const messageHandler = (message, messageHandle) => {
-      if (message.act !== "newconn") {
-        return;
-      }
-
-      server.close();
-      messageHandle.close = jest.fn(() => {
-        handleCloseSpy.call(messageHandle, () => {
-          expect(handleCloseSpy).toHaveBeenCalledTimes(1);
-          process.exit();
-        });
-      });
-
-      expect(messageHandle.close).toHaveBeenCalledTimes(1);
-      done();
-    };
-
-    process.prependListener("internalMessage", messageHandler);
-
-    // Simulate an internal message
-    process.emit("internalMessage", { act: "newconn" }, handle);
-  });
-}
-
-//<#END_FILE: test-cluster-worker-handle-close.js
diff --git a/test/js/node/test/parallel/cluster-worker-isconnected.test.js b/test/js/node/test/parallel/cluster-worker-isconnected.test.js
deleted file mode 100644
index 4ca42ebe61..0000000000
--- a/test/js/node/test/parallel/cluster-worker-isconnected.test.js
+++ /dev/null
@@ -1,38 +0,0 @@
-//#FILE: test-cluster-worker-isconnected.js
-//#SHA1: cf1e0243c030fe4cf872716099e517daec3efffc
-//-----------------
-"use strict";
-const cluster = require("cluster");
-
-if (cluster.isPrimary) {
-  test("worker isConnected() in primary", () => {
-    const worker = cluster.fork();
-
-    expect(worker.isConnected()).toBe(true);
-
-    worker.on("disconnect", () => {
-      expect(worker.isConnected()).toBe(false);
-    });
-
-    worker.on("message", function (msg) {
-      if (msg === "readyToDisconnect") {
-        worker.disconnect();
-      }
-    });
-  });
-} else {
-  test("worker isConnected() in worker", () => {
-    function assertNotConnected() {
-      expect(cluster.worker.isConnected()).toBe(false);
-    }
-
-    expect(cluster.worker.isConnected()).toBe(true);
-
-    cluster.worker.on("disconnect", assertNotConnected);
-    cluster.worker.process.on("disconnect", assertNotConnected);
-
-    process.send("readyToDisconnect");
-  });
-}
-
-//<#END_FILE: test-cluster-worker-isconnected.js
diff --git a/test/js/node/test/parallel/console-assign-undefined.test.js b/test/js/node/test/parallel/console-assign-undefined.test.js
deleted file mode 100644
index cc46f41b42..0000000000
--- a/test/js/node/test/parallel/console-assign-undefined.test.js
+++ /dev/null
@@ -1,47 +0,0 @@
-//#FILE: test-console-assign-undefined.js
-//#SHA1: ccd5cd3087520e692e5123679c1753d168d310f0
-//-----------------
-"use strict";
-
-// Patch global.console before importing modules that may modify the console
-// object.
-
-let originalConsole;
-
-beforeAll(() => {
-  originalConsole = global.console;
-  global.console = 42;
-});
-
-afterAll(() => {
-  // Reset the console
-  global.console = originalConsole;
-});
-
-test("console can be assigned a non-object value", () => {
-  // Originally the console had a getter. Test twice to verify it had no side
-  // effect.
-  expect(global.console).toBe(42);
-  expect(global.console).toBe(42);
-
-  expect(() => console.log("foo")).toThrow(
-    expect.objectContaining({
-      name: "TypeError",
-      message: expect.any(String),
-    }),
-  );
-
-  global.console = 1;
-  expect(global.console).toBe(1);
-  expect(console).toBe(1);
-});
-
-test("console can be reset and used", () => {
-  global.console = originalConsole;
-  const consoleSpy = jest.spyOn(console, "log");
-  console.log("foo");
-  expect(consoleSpy).toHaveBeenCalledWith("foo");
-  consoleSpy.mockRestore();
-});
-
-//<#END_FILE: test-console-assign-undefined.js
diff --git a/test/js/node/test/parallel/console-issue-43095.test.js b/test/js/node/test/parallel/console-issue-43095.test.js
deleted file mode 100644
index 815c2d86ad..0000000000
--- a/test/js/node/test/parallel/console-issue-43095.test.js
+++ /dev/null
@@ -1,40 +0,0 @@
-//#FILE: test-console-issue-43095.js
-//#SHA1: 1c0c5cce62bcee4d50c6b716dd1430db2784c3f4
-//-----------------
-"use strict";
-
-const { inspect } = require("node:util");
-
-test("console output for revoked proxy", () => {
-  const consoleSpy = {
-    dir: jest.spyOn(console, "dir").mockImplementation(),
-    log: jest.spyOn(console, "log").mockImplementation(),
-  };
-
-  const r = Proxy.revocable({}, {});
-  r.revoke();
-
-  console.dir(r);
-  console.dir(r.proxy);
-  console.log(r.proxy);
-  console.log(inspect(r.proxy, { showProxy: true }));
-
-  expect(consoleSpy.dir).toHaveBeenCalledTimes(2);
-  expect(consoleSpy.log).toHaveBeenCalledTimes(2);
-
-  // Check that console.dir was called with the revoked proxy object
-  expect(consoleSpy.dir.mock.calls[0][0]).toBe(r);
-  expect(consoleSpy.dir.mock.calls[1][0]).toBe(r.proxy);
-
-  // Check that console.log was called with the revoked proxy
-  expect(consoleSpy.log.mock.calls[0][0]).toBe(r.proxy);
-
-  // Check that console.log was called with the inspected revoked proxy
-  expect(consoleSpy.log.mock.calls[1][0]).toBe(inspect(r.proxy, { showProxy: true }));
-
-  // Clean up
-  consoleSpy.dir.mockRestore();
-  consoleSpy.log.mockRestore();
-});
-
-//<#END_FILE: test-console-issue-43095.js
diff --git a/test/js/node/test/parallel/console-log-stdio-broken-dest.test.js b/test/js/node/test/parallel/console-log-stdio-broken-dest.test.js
deleted file mode 100644
index b93dfe3824..0000000000
--- a/test/js/node/test/parallel/console-log-stdio-broken-dest.test.js
+++ /dev/null
@@ -1,38 +0,0 @@
-//#FILE: test-console-log-stdio-broken-dest.js
-//#SHA1: c2c2e85eeb28db4ace2c4bb0a86f46f7e7bf2682
-//-----------------
-"use strict";
-
-const { Writable } = require("stream");
-const { Console } = require("console");
-const { EventEmitter } = require("events");
-
-test("Console log with broken destination", done => {
-  const stream = new Writable({
-    write(chunk, enc, cb) {
-      cb();
-    },
-    writev(chunks, cb) {
-      setTimeout(cb, 10, new Error("kaboom"));
-    },
-  });
-  const myConsole = new Console(stream, stream);
-
-  const warningListener = jest.fn();
-  process.on("warning", warningListener);
-
-  stream.cork();
-  for (let i = 0; i < EventEmitter.defaultMaxListeners + 1; i++) {
-    myConsole.log("a message");
-  }
-  stream.uncork();
-
-  // We need to wait for the next tick to ensure the error has time to propagate
-  process.nextTick(() => {
-    expect(warningListener).not.toHaveBeenCalled();
-    process.removeListener("warning", warningListener);
-    done();
-  });
-});
-
-//<#END_FILE: test-console-log-stdio-broken-dest.js
diff --git a/test/js/node/test/parallel/console-log-throw-primitive.test.js b/test/js/node/test/parallel/console-log-throw-primitive.test.js
deleted file mode 100644
index e318eaaf4d..0000000000
--- a/test/js/node/test/parallel/console-log-throw-primitive.test.js
+++ /dev/null
@@ -1,22 +0,0 @@
-//#FILE: test-console-log-throw-primitive.js
-//#SHA1: a1889badf1058f6fadc8984a5075f3d048e2948c
-//-----------------
-"use strict";
-
-const { Writable } = require("stream");
-const { Console } = require("console");
-
-test("Console.log should not throw when stream throws null", () => {
-  const stream = new Writable({
-    write() {
-      throw null; // eslint-disable-line no-throw-literal
-    },
-  });
-
-  const console = new Console({ stdout: stream });
-
-  // Should not throw
-  expect(() => console.log("test")).not.toThrow();
-});
-
-//<#END_FILE: test-console-log-throw-primitive.js
diff --git a/test/js/node/test/parallel/console-not-call-tostring.test.js b/test/js/node/test/parallel/console-not-call-tostring.test.js
deleted file mode 100644
index f43e7dbde6..0000000000
--- a/test/js/node/test/parallel/console-not-call-tostring.test.js
+++ /dev/null
@@ -1,39 +0,0 @@
-//#FILE: test-console-not-call-toString.js
-//#SHA1: e0bf3a601442b76f12f657e53df54690d2fe21fa
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-test("util.inspect does not call toString", () => {
-  function func() {}
-  let toStringCalled = false;
-  func.toString = function () {
-    toStringCalled = true;
-  };
-
-  require("util").inspect(func);
-
-  expect(toStringCalled).toBe(false);
-});
-
-//<#END_FILE: test-console-not-call-toString.js
diff --git a/test/js/node/test/parallel/console-self-assign.test.js b/test/js/node/test/parallel/console-self-assign.test.js
deleted file mode 100644
index e746e9a47a..0000000000
--- a/test/js/node/test/parallel/console-self-assign.test.js
+++ /dev/null
@@ -1,13 +0,0 @@
-//#FILE: test-console-self-assign.js
-//#SHA1: 7ed2fd07a18f0485f2592ada8e97e9c33753e691
-//-----------------
-"use strict";
-
-// Assigning to itself should not throw.
-test("console self-assignment", () => {
-  expect(() => {
-    global.console = global.console; // eslint-disable-line no-self-assign
-  }).not.toThrow();
-});
-
-//<#END_FILE: test-console-self-assign.js
diff --git a/test/js/node/test/parallel/crypto-dh-shared.test.js b/test/js/node/test/parallel/crypto-dh-shared.test.js
deleted file mode 100644
index f811ca4df7..0000000000
--- a/test/js/node/test/parallel/crypto-dh-shared.test.js
+++ /dev/null
@@ -1,21 +0,0 @@
-//#FILE: test-crypto-dh-shared.js
-//#SHA1: 8d5e31de4aa93f435c4c6d05d7b394156a38fb8e
-//-----------------
-"use strict";
-
-const crypto = require("crypto");
-
-test("Diffie-Hellman shared secret computation", () => {
-  const alice = crypto.createDiffieHellmanGroup("modp5");
-  const bob = crypto.createDiffieHellmanGroup("modp5");
-
-  alice.generateKeys();
-  bob.generateKeys();
-
-  const aSecret = alice.computeSecret(bob.getPublicKey()).toString("hex");
-  const bSecret = bob.computeSecret(alice.getPublicKey()).toString("hex");
-
-  expect(aSecret).toBe(bSecret);
-});
-
-//<#END_FILE: test-crypto-dh-shared.js
diff --git a/test/js/node/test/parallel/crypto-from-binary.test.js b/test/js/node/test/parallel/crypto-from-binary.test.js
deleted file mode 100644
index 3c015ec6b6..0000000000
--- a/test/js/node/test/parallel/crypto-from-binary.test.js
+++ /dev/null
@@ -1,66 +0,0 @@
-//#FILE: test-crypto-from-binary.js
-//#SHA1: 2f3b186e9b549c6910a58dea98e6bdeb7c540afa
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-// This is the same as test/simple/test-crypto, but from before the shift
-// to use buffers by default.
-
-const crypto = require("crypto");
-
-const EXTERN_APEX = 0xfbee9;
-
-// Manually controlled string for checking binary output
-let ucs2_control = "a\u0000";
-
-// Grow the strings to proper length
-while (ucs2_control.length <= EXTERN_APEX) {
-  ucs2_control = ucs2_control.repeat(2);
-}
-
-// Check resultant buffer and output string
-const b = Buffer.from(ucs2_control + ucs2_control, "ucs2");
-
-describe("Crypto from binary", () => {
-  beforeAll(() => {
-    if (!crypto) {
-      return test.skip("missing crypto");
-    }
-  });
-
-  test("Update from binary data - small slice", () => {
-    const datum1 = b.slice(700000);
-    const hash1_converted = crypto.createHash("sha1").update(datum1.toString("base64"), "base64").digest("hex");
-    const hash1_direct = crypto.createHash("sha1").update(datum1).digest("hex");
-    expect(hash1_direct).toBe(hash1_converted);
-  });
-
-  test("Update from binary data - full buffer", () => {
-    const datum2 = b;
-    const hash2_converted = crypto.createHash("sha1").update(datum2.toString("base64"), "base64").digest("hex");
-    const hash2_direct = crypto.createHash("sha1").update(datum2).digest("hex");
-    expect(hash2_direct).toBe(hash2_converted);
-  });
-});
-
-//<#END_FILE: test-crypto-from-binary.js
diff --git a/test/js/node/test/parallel/crypto-keygen-async-elliptic-curve-jwk-rsa.test.js b/test/js/node/test/parallel/crypto-keygen-async-elliptic-curve-jwk-rsa.test.js
deleted file mode 100644
index f19582afbd..0000000000
--- a/test/js/node/test/parallel/crypto-keygen-async-elliptic-curve-jwk-rsa.test.js
+++ /dev/null
@@ -1,45 +0,0 @@
-//#FILE: test-crypto-keygen-async-elliptic-curve-jwk-rsa.js
-//#SHA1: 4337f1e36680f21ed3439d7ab546ea855a0a842e
-//-----------------
-"use strict";
-
-const { generateKeyPair } = require("crypto");
-
-// Test async elliptic curve key generation with 'jwk' encoding and RSA.
-test("async elliptic curve key generation with jwk encoding and RSA", async () => {
-  const { publicKey, privateKey } = await new Promise((resolve, reject) => {
-    generateKeyPair(
-      "rsa",
-      {
-        modulusLength: 1024,
-        publicKeyEncoding: {
-          format: "jwk",
-        },
-        privateKeyEncoding: {
-          format: "jwk",
-        },
-      },
-      (err, publicKey, privateKey) => {
-        if (err) reject(err);
-        else resolve({ publicKey, privateKey });
-      },
-    );
-  });
-
-  expect(typeof publicKey).toBe("object");
-  expect(typeof privateKey).toBe("object");
-  expect(publicKey.kty).toBe("RSA");
-  expect(publicKey.kty).toBe(privateKey.kty);
-  expect(typeof publicKey.n).toBe("string");
-  expect(publicKey.n).toBe(privateKey.n);
-  expect(typeof publicKey.e).toBe("string");
-  expect(publicKey.e).toBe(privateKey.e);
-  expect(typeof privateKey.d).toBe("string");
-  expect(typeof privateKey.p).toBe("string");
-  expect(typeof privateKey.q).toBe("string");
-  expect(typeof privateKey.dp).toBe("string");
-  expect(typeof privateKey.dq).toBe("string");
-  expect(typeof privateKey.qi).toBe("string");
-});
-
-//<#END_FILE: test-crypto-keygen-async-elliptic-curve-jwk-rsa.js
diff --git a/test/js/node/test/parallel/crypto-keygen-async-encrypted-private-key-der.test.js b/test/js/node/test/parallel/crypto-keygen-async-encrypted-private-key-der.test.js
deleted file mode 100644
index 01e5b30494..0000000000
--- a/test/js/node/test/parallel/crypto-keygen-async-encrypted-private-key-der.test.js
+++ /dev/null
@@ -1,54 +0,0 @@
-//#FILE: test-crypto-keygen-async-encrypted-private-key-der.js
-//#SHA1: 30f86c68619f3f24294d5f062eed48b13c116b0c
-//-----------------
-"use strict";
-
-const crypto = require("crypto");
-const { assertApproximateSize, testEncryptDecrypt, testSignVerify } = require("../common/crypto");
-
-// Test async RSA key generation with an encrypted private key, but encoded as DER.
-test("RSA key generation with encrypted private key (DER)", async () => {
-  const { publicKey: publicKeyDER, privateKey: privateKeyDER } = await new Promise((resolve, reject) => {
-    crypto.generateKeyPair(
-      "rsa",
-      {
-        publicExponent: 0x10001,
-        modulusLength: 512,
-        publicKeyEncoding: {
-          type: "pkcs1",
-          format: "der",
-        },
-        privateKeyEncoding: {
-          type: "pkcs8",
-          format: "der",
-        },
-      },
-      (err, publicKey, privateKey) => {
-        if (err) reject(err);
-        else resolve({ publicKey, privateKey });
-      },
-    );
-  });
-
-  expect(Buffer.isBuffer(publicKeyDER)).toBe(true);
-  assertApproximateSize(publicKeyDER, 74);
-
-  expect(Buffer.isBuffer(privateKeyDER)).toBe(true);
-
-  const publicKey = {
-    key: publicKeyDER,
-    type: "pkcs1",
-    format: "der",
-  };
-  const privateKey = {
-    key: privateKeyDER,
-    format: "der",
-    type: "pkcs8",
-    passphrase: "secret",
-  };
-
-  await testEncryptDecrypt(publicKey, privateKey);
-  await testSignVerify(publicKey, privateKey);
-});
-
-//<#END_FILE: test-crypto-keygen-async-encrypted-private-key-der.js
diff --git a/test/js/node/test/parallel/crypto-keygen-async-explicit-elliptic-curve.test.js b/test/js/node/test/parallel/crypto-keygen-async-explicit-elliptic-curve.test.js
deleted file mode 100644
index 4d6f637147..0000000000
--- a/test/js/node/test/parallel/crypto-keygen-async-explicit-elliptic-curve.test.js
+++ /dev/null
@@ -1,50 +0,0 @@
-//#FILE: test-crypto-keygen-async-explicit-elliptic-curve.js
-//#SHA1: be1eabf816f52e5f53cb2535d47050b2552d21cd
-//-----------------
-"use strict";
-
-const crypto = require("crypto");
-
-// Skip the test if crypto support is not available
-if (!crypto.generateKeyPair) {
-  test.skip("missing crypto support", () => {});
-} else {
-  const { generateKeyPair } = crypto;
-
-  const { testSignVerify, spkiExp, sec1Exp } = require("../common/crypto");
-
-  // Test async explicit elliptic curve key generation, e.g. for ECDSA,
-  // with a SEC1 private key with paramEncoding explicit.
-  test("async explicit elliptic curve key generation", async () => {
-    await new Promise((resolve, reject) => {
-      generateKeyPair(
-        "ec",
-        {
-          namedCurve: "prime256v1",
-          paramEncoding: "explicit",
-          publicKeyEncoding: {
-            type: "spki",
-            format: "pem",
-          },
-          privateKeyEncoding: {
-            type: "sec1",
-            format: "pem",
-          },
-        },
-        (err, publicKey, privateKey) => {
-          if (err) reject(err);
-          else resolve({ publicKey, privateKey });
-        },
-      );
-    }).then(({ publicKey, privateKey }) => {
-      expect(typeof publicKey).toBe("string");
-      expect(publicKey).toMatch(spkiExp);
-      expect(typeof privateKey).toBe("string");
-      expect(privateKey).toMatch(sec1Exp);
-
-      return testSignVerify(publicKey, privateKey);
-    });
-  });
-}
-
-//<#END_FILE: test-crypto-keygen-async-explicit-elliptic-curve.js
diff --git a/test/js/node/test/parallel/crypto-keygen-async-named-elliptic-curve.test.js b/test/js/node/test/parallel/crypto-keygen-async-named-elliptic-curve.test.js
deleted file mode 100644
index 8721a4551f..0000000000
--- a/test/js/node/test/parallel/crypto-keygen-async-named-elliptic-curve.test.js
+++ /dev/null
@@ -1,51 +0,0 @@
-//#FILE: test-crypto-keygen-async-named-elliptic-curve.js
-//#SHA1: 77822175b9b2c2206ec4ab8a3e1182e3576b23bd
-//-----------------
-"use strict";
-
-const crypto = require("crypto");
-const { testSignVerify } = require("../common/crypto");
-
-if (!crypto.generateKeyPair) {
-  test.skip("missing crypto.generateKeyPair");
-}
-
-const spkiExp =
-  /^-----BEGIN PUBLIC KEY-----\n(?:[A-Za-z0-9+/=]{64}\n)*[A-Za-z0-9+/=]{1,64}\n-----END PUBLIC KEY-----\n$/;
-const sec1Exp =
-  /^-----BEGIN EC PRIVATE KEY-----\n(?:[A-Za-z0-9+/=]{64}\n)*[A-Za-z0-9+/=]{1,64}\n-----END EC PRIVATE KEY-----\n$/;
-
-// Test async named elliptic curve key generation, e.g. for ECDSA,
-// with a SEC1 private key.
-test("async named elliptic curve key generation with SEC1 private key", async () => {
-  const { publicKey, privateKey } = await new Promise((resolve, reject) => {
-    crypto.generateKeyPair(
-      "ec",
-      {
-        namedCurve: "prime256v1",
-        paramEncoding: "named",
-        publicKeyEncoding: {
-          type: "spki",
-          format: "pem",
-        },
-        privateKeyEncoding: {
-          type: "sec1",
-          format: "pem",
-        },
-      },
-      (err, publicKey, privateKey) => {
-        if (err) reject(err);
-        else resolve({ publicKey, privateKey });
-      },
-    );
-  });
-
-  expect(typeof publicKey).toBe("string");
-  expect(publicKey).toMatch(spkiExp);
-  expect(typeof privateKey).toBe("string");
-  expect(privateKey).toMatch(sec1Exp);
-
-  await testSignVerify(publicKey, privateKey);
-});
-
-//<#END_FILE: test-crypto-keygen-async-named-elliptic-curve.js
diff --git a/test/js/node/test/parallel/crypto-keygen-empty-passphrase-no-error.test.js b/test/js/node/test/parallel/crypto-keygen-empty-passphrase-no-error.test.js
deleted file mode 100644
index ed029ce08d..0000000000
--- a/test/js/node/test/parallel/crypto-keygen-empty-passphrase-no-error.test.js
+++ /dev/null
@@ -1,47 +0,0 @@
-//#FILE: test-crypto-keygen-empty-passphrase-no-error.js
-//#SHA1: a949b38385a5dd05507975cbc44b3beba764bd95
-//-----------------
-"use strict";
-
-const crypto = require("crypto");
-
-// Skip the test if crypto is not available
-if (typeof crypto.generateKeyPair !== "function") {
-  test.skip("missing crypto", () => {});
-} else {
-  test("generateKeyPair with empty passphrase should not throw ERR_OSSL_CRYPTO_MALLOC_FAILURE", async () => {
-    // Passing an empty passphrase string should not throw ERR_OSSL_CRYPTO_MALLOC_FAILURE even on OpenSSL 3.
-    // Regression test for https://github.com/nodejs/node/issues/41428.
-    await expect(
-      new Promise((resolve, reject) => {
-        crypto.generateKeyPair(
-          "rsa",
-          {
-            modulusLength: 1024,
-            publicKeyEncoding: {
-              type: "spki",
-              format: "pem",
-            },
-            privateKeyEncoding: {
-              type: "pkcs8",
-              format: "pem",
-              cipher: "aes-256-cbc",
-              passphrase: "",
-            },
-          },
-          (err, publicKey, privateKey) => {
-            if (err) reject(err);
-            else resolve({ publicKey, privateKey });
-          },
-        );
-      }),
-    ).resolves.toEqual(
-      expect.objectContaining({
-        publicKey: expect.any(String),
-        privateKey: expect.any(String),
-      }),
-    );
-  });
-}
-
-//<#END_FILE: test-crypto-keygen-empty-passphrase-no-error.js
diff --git a/test/js/node/test/parallel/crypto-keygen-key-object-without-encoding.test.js b/test/js/node/test/parallel/crypto-keygen-key-object-without-encoding.test.js
deleted file mode 100644
index 53d01c929f..0000000000
--- a/test/js/node/test/parallel/crypto-keygen-key-object-without-encoding.test.js
+++ /dev/null
@@ -1,90 +0,0 @@
-//#FILE: test-crypto-keygen-key-object-without-encoding.js
-//#SHA1: da408ed128f913dc7343ef88743b362c16420ba0
-//-----------------
-"use strict";
-
-const crypto = require("crypto");
-
-// Skip the test if crypto is not available
-if (!crypto.generateKeyPair) {
-  test.skip("missing crypto");
-}
-
-const { generateKeyPair } = crypto;
-
-// Helper functions for testing encryption/decryption and signing/verifying
-const testEncryptDecrypt = (publicKey, privateKey) => {
-  const plaintext = "Hello, World!";
-  const encrypted = crypto.publicEncrypt(publicKey, Buffer.from(plaintext));
-  const decrypted = crypto.privateDecrypt(privateKey, encrypted);
-  expect(decrypted.toString()).toBe(plaintext);
-};
-
-const testSignVerify = (publicKey, privateKey) => {
-  const data = "Hello, World!";
-  const sign = crypto.createSign("SHA256");
-  sign.update(data);
-  const signature = sign.sign(privateKey);
-  const verify = crypto.createVerify("SHA256");
-  verify.update(data);
-  expect(verify.verify(publicKey, signature)).toBe(true);
-};
-
-// Tests key objects are returned when key encodings are not specified.
-describe("generateKeyPair without encoding", () => {
-  // If no publicKeyEncoding is specified, a key object should be returned.
-  test("returns key object for public key when no encoding specified", done => {
-    generateKeyPair(
-      "rsa",
-      {
-        modulusLength: 1024,
-        privateKeyEncoding: {
-          type: "pkcs1",
-          format: "pem",
-        },
-      },
-      (err, publicKey, privateKey) => {
-        expect(err).toBe(null);
-        expect(typeof publicKey).toBe("object");
-        expect(publicKey.type).toBe("public");
-        expect(publicKey.asymmetricKeyType).toBe("rsa");
-
-        // The private key should still be a string.
-        expect(typeof privateKey).toBe("string");
-
-        testEncryptDecrypt(publicKey, privateKey);
-        testSignVerify(publicKey, privateKey);
-        done();
-      },
-    );
-  });
-
-  // If no privateKeyEncoding is specified, a key object should be returned.
-  test("returns key object for private key when no encoding specified", done => {
-    generateKeyPair(
-      "rsa",
-      {
-        modulusLength: 1024,
-        publicKeyEncoding: {
-          type: "pkcs1",
-          format: "pem",
-        },
-      },
-      (err, publicKey, privateKey) => {
-        expect(err).toBe(null);
-        // The public key should still be a string.
-        expect(typeof publicKey).toBe("string");
-
-        expect(typeof privateKey).toBe("object");
-        expect(privateKey.type).toBe("private");
-        expect(privateKey.asymmetricKeyType).toBe("rsa");
-
-        testEncryptDecrypt(publicKey, privateKey);
-        testSignVerify(publicKey, privateKey);
-        done();
-      },
-    );
-  });
-});
-
-//<#END_FILE: test-crypto-keygen-key-object-without-encoding.js
diff --git a/test/js/node/test/parallel/crypto-keygen-key-objects.test.js b/test/js/node/test/parallel/crypto-keygen-key-objects.test.js
deleted file mode 100644
index 29d4bbe5f8..0000000000
--- a/test/js/node/test/parallel/crypto-keygen-key-objects.test.js
+++ /dev/null
@@ -1,36 +0,0 @@
-//#FILE: test-crypto-keygen-key-objects.js
-//#SHA1: 7a2dce611ba70e533ebb73d9f281896bdf75051f
-//-----------------
-"use strict";
-
-if (!process.versions.bun) {
-  const common = require("../common");
-  if (!common.hasCrypto) common.skip("missing crypto");
-}
-
-const { generateKeyPairSync } = require("crypto");
-
-// Test sync key generation with key objects.
-test("generateKeyPairSync with RSA", () => {
-  const { publicKey, privateKey } = generateKeyPairSync("rsa", {
-    modulusLength: 512,
-  });
-
-  expect(typeof publicKey).toBe("object");
-  expect(publicKey.type).toBe("public");
-  expect(publicKey.asymmetricKeyType).toBe("rsa");
-  expect(publicKey.asymmetricKeyDetails).toEqual({
-    modulusLength: 512,
-    publicExponent: 65537n,
-  });
-
-  expect(typeof privateKey).toBe("object");
-  expect(privateKey.type).toBe("private");
-  expect(privateKey.asymmetricKeyType).toBe("rsa");
-  expect(privateKey.asymmetricKeyDetails).toEqual({
-    modulusLength: 512,
-    publicExponent: 65537n,
-  });
-});
-
-//<#END_FILE: test-crypto-keygen-key-objects.js
diff --git a/test/js/node/test/parallel/crypto-keygen-missing-oid.test.js b/test/js/node/test/parallel/crypto-keygen-missing-oid.test.js
deleted file mode 100644
index b91248c3a6..0000000000
--- a/test/js/node/test/parallel/crypto-keygen-missing-oid.test.js
+++ /dev/null
@@ -1,55 +0,0 @@
-//#FILE: test-crypto-keygen-missing-oid.js
-//#SHA1: ffcbc53b115cce8795ca1a0e73a533b04789a930
-//-----------------
-"use strict";
-
-const { generateKeyPair, generateKeyPairSync, getCurves } = require("crypto");
-
-// This test creates EC key pairs on curves without associated OIDs.
-// Specifying a key encoding should not crash.
-test("EC key pairs on curves without associated OIDs", () => {
-  if (process.versions.openssl >= "1.1.1i") {
-    const curves = ["Oakley-EC2N-3", "Oakley-EC2N-4"];
-    const availableCurves = getCurves();
-
-    for (const namedCurve of curves) {
-      if (!availableCurves.includes(namedCurve)) continue;
-
-      const expectedErrorCode = process.versions.openssl.startsWith("3.")
-        ? "ERR_OSSL_MISSING_OID"
-        : "ERR_OSSL_EC_MISSING_OID";
-
-      const params = {
-        namedCurve,
-        publicKeyEncoding: {
-          format: "der",
-          type: "spki",
-        },
-      };
-
-      expect(() => {
-        generateKeyPairSync("ec", params);
-      }).toThrow(
-        expect.objectContaining({
-          code: expectedErrorCode,
-          message: expect.any(String),
-        }),
-      );
-
-      return new Promise(resolve => {
-        generateKeyPair("ec", params, err => {
-          expect(err).toMatchObject({
-            code: expectedErrorCode,
-            message: expect.any(String),
-          });
-          resolve();
-        });
-      });
-    }
-  } else {
-    // Skip test if OpenSSL version is less than 1.1.1i
-    test.skip("OpenSSL version is less than 1.1.1i");
-  }
-});
-
-//<#END_FILE: test-crypto-keygen-missing-oid.js
diff --git a/test/js/node/test/parallel/crypto-keygen-non-standard-public-exponent.test.js b/test/js/node/test/parallel/crypto-keygen-non-standard-public-exponent.test.js
deleted file mode 100644
index 46fc35ffdb..0000000000
--- a/test/js/node/test/parallel/crypto-keygen-non-standard-public-exponent.test.js
+++ /dev/null
@@ -1,37 +0,0 @@
-//#FILE: test-crypto-keygen-non-standard-public-exponent.js
-//#SHA1: 955e956a08102b75fcf0571213a1dd939d1f51ac
-//-----------------
-"use strict";
-
-const crypto = require("crypto");
-
-if (!crypto.generateKeyPairSync) {
-  test.skip("missing crypto.generateKeyPairSync");
-}
-
-// Test sync key generation with key objects with a non-standard
-// publicExponent
-test("generateKeyPairSync with non-standard publicExponent", () => {
-  const { publicKey, privateKey } = crypto.generateKeyPairSync("rsa", {
-    publicExponent: 3,
-    modulusLength: 512,
-  });
-
-  expect(typeof publicKey).toBe("object");
-  expect(publicKey.type).toBe("public");
-  expect(publicKey.asymmetricKeyType).toBe("rsa");
-  expect(publicKey.asymmetricKeyDetails).toEqual({
-    modulusLength: 512,
-    publicExponent: 3n,
-  });
-
-  expect(typeof privateKey).toBe("object");
-  expect(privateKey.type).toBe("private");
-  expect(privateKey.asymmetricKeyType).toBe("rsa");
-  expect(privateKey.asymmetricKeyDetails).toEqual({
-    modulusLength: 512,
-    publicExponent: 3n,
-  });
-});
-
-//<#END_FILE: test-crypto-keygen-non-standard-public-exponent.js
diff --git a/test/js/node/test/parallel/crypto-keygen-sync.test.js b/test/js/node/test/parallel/crypto-keygen-sync.test.js
deleted file mode 100644
index 26d3a218fb..0000000000
--- a/test/js/node/test/parallel/crypto-keygen-sync.test.js
+++ /dev/null
@@ -1,50 +0,0 @@
-//#FILE: test-crypto-keygen-sync.js
-//#SHA1: 57749dc903b0d5f9b64a3d61f313be6e5549323f
-//-----------------
-"use strict";
-
-const crypto = require("crypto");
-const {
-  assertApproximateSize,
-  testEncryptDecrypt,
-  testSignVerify,
-  pkcs1PubExp,
-  pkcs8Exp,
-} = require("../common/crypto");
-
-// Skip the test if crypto support is not available
-if (typeof crypto.generateKeyPairSync !== "function") {
-  test.skip("missing crypto support", () => {});
-} else {
-  // To make the test faster, we will only test sync key generation once and
-  // with a relatively small key.
-  test("generateKeyPairSync", () => {
-    const ret = crypto.generateKeyPairSync("rsa", {
-      publicExponent: 3,
-      modulusLength: 512,
-      publicKeyEncoding: {
-        type: "pkcs1",
-        format: "pem",
-      },
-      privateKeyEncoding: {
-        type: "pkcs8",
-        format: "pem",
-      },
-    });
-
-    expect(Object.keys(ret)).toHaveLength(2);
-    const { publicKey, privateKey } = ret;
-
-    expect(typeof publicKey).toBe("string");
-    expect(publicKey).toMatch(pkcs1PubExp);
-    assertApproximateSize(publicKey, 162);
-    expect(typeof privateKey).toBe("string");
-    expect(privateKey).toMatch(pkcs8Exp);
-    assertApproximateSize(privateKey, 512);
-
-    testEncryptDecrypt(publicKey, privateKey);
-    testSignVerify(publicKey, privateKey);
-  });
-}
-
-//<#END_FILE: test-crypto-keygen-sync.js
diff --git a/test/js/node/test/parallel/crypto-lazy-transform-writable.test.js b/test/js/node/test/parallel/crypto-lazy-transform-writable.test.js
deleted file mode 100644
index 6df20ee83f..0000000000
--- a/test/js/node/test/parallel/crypto-lazy-transform-writable.test.js
+++ /dev/null
@@ -1,41 +0,0 @@
-//#FILE: test-crypto-lazy-transform-writable.js
-//#SHA1: 29f694c4ea89a94302b3aa84677b5e41c73077d7
-//-----------------
-"use strict";
-
-const crypto = require("crypto");
-const Stream = require("stream");
-
-if (!crypto) it.skip("missing crypto", () => {});
-
-test("crypto lazy transform writable", done => {
-  const hasher1 = crypto.createHash("sha256");
-  const hasher2 = crypto.createHash("sha256");
-
-  // Calculate the expected result.
-  hasher1.write(Buffer.from("hello world"));
-  hasher1.end();
-
-  const expected = hasher1.read().toString("hex");
-
-  class OldStream extends Stream {
-    constructor() {
-      super();
-      this.readable = true;
-    }
-  }
-
-  const stream = new OldStream();
-
-  stream.pipe(hasher2).on("finish", () => {
-    const hash = hasher2.read().toString("hex");
-    expect(hash).toBe(expected);
-    done();
-  });
-
-  stream.emit("data", Buffer.from("hello"));
-  stream.emit("data", Buffer.from(" world"));
-  stream.emit("end");
-});
-
-//<#END_FILE: test-crypto-lazy-transform-writable.js
diff --git a/test/js/node/test/parallel/crypto-padding-aes256.test.js b/test/js/node/test/parallel/crypto-padding-aes256.test.js
deleted file mode 100644
index 079e7a15b6..0000000000
--- a/test/js/node/test/parallel/crypto-padding-aes256.test.js
+++ /dev/null
@@ -1,64 +0,0 @@
-//#FILE: test-crypto-padding-aes256.js
-//#SHA1: 96fb5beb94bedbc768788ba2726dcd0e61733c5a
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-const crypto = require("crypto");
-
-const iv = Buffer.from("00000000000000000000000000000000", "hex");
-const key = Buffer.from("0123456789abcdef0123456789abcdef" + "0123456789abcdef0123456789abcdef", "hex");
-
-function encrypt(val, pad) {
-  const c = crypto.createCipheriv("aes256", key, iv);
-  c.setAutoPadding(pad);
-  return c.update(val, "utf8", "latin1") + c.final("latin1");
-}
-
-function decrypt(val, pad) {
-  const c = crypto.createDecipheriv("aes256", key, iv);
-  c.setAutoPadding(pad);
-  return c.update(val, "latin1", "utf8") + c.final("utf8");
-}
-
-test("AES256 encryption and decryption with no padding (multiple of block size)", () => {
-  // echo 0123456789abcdef0123456789abcdef \
-  // | openssl enc -e -aes256 -nopad -K <key> -iv <iv> \
-  // | openssl enc -d -aes256 -nopad -K <key> -iv <iv>
-  const plaintext = "0123456789abcdef0123456789abcdef"; // Multiple of block size
-  const encrypted = encrypt(plaintext, false);
-  const decrypted = decrypt(encrypted, false);
-  expect(decrypted).toBe(plaintext);
-});
-
-test("AES256 encryption and decryption with padding (not a multiple of block size)", () => {
-  // echo 0123456789abcdef0123456789abcde \
-  // | openssl enc -e -aes256 -K <key> -iv <iv> \
-  // | openssl enc -d -aes256 -K <key> -iv <iv>
-  const plaintext = "0123456789abcdef0123456789abcde"; // not a multiple
-  const encrypted = encrypt(plaintext, true);
-  const decrypted = decrypt(encrypted, true);
-  expect(decrypted).toBe(plaintext);
-});
-
-//<#END_FILE: test-crypto-padding-aes256.js
diff --git a/test/js/node/test/parallel/crypto-randomfillsync-regression.test.js b/test/js/node/test/parallel/crypto-randomfillsync-regression.test.js
deleted file mode 100644
index aa57030f2a..0000000000
--- a/test/js/node/test/parallel/crypto-randomfillsync-regression.test.js
+++ /dev/null
@@ -1,29 +0,0 @@
-//#FILE: test-crypto-randomfillsync-regression.js
-//#SHA1: f37bc7cc1eab82ab93665b246c0d44e9fce8d112
-//-----------------
-"use strict";
-
-// Skip the test if crypto is not available
-let randomFillSync;
-try {
-  ({ randomFillSync } = require("crypto"));
-} catch {
-  test.skip("missing crypto", () => {});
-}
-
-if (randomFillSync) {
-  test("randomFillSync regression test", () => {
-    const ab = new ArrayBuffer(20);
-    const buf = Buffer.from(ab, 10);
-
-    const before = buf.toString("hex");
-
-    randomFillSync(buf);
-
-    const after = buf.toString("hex");
-
-    expect(before).not.toBe(after);
-  });
-}
-
-//<#END_FILE: test-crypto-randomfillsync-regression.js
diff --git a/test/js/node/test/parallel/crypto-update-encoding.test.js b/test/js/node/test/parallel/crypto-update-encoding.test.js
deleted file mode 100644
index 1c0d269234..0000000000
--- a/test/js/node/test/parallel/crypto-update-encoding.test.js
+++ /dev/null
@@ -1,33 +0,0 @@
-//#FILE: test-crypto-update-encoding.js
-//#SHA1: dfe3c7e71e22a772cf6b2e6a6540be161fda3418
-//-----------------
-"use strict";
-
-const crypto = require("crypto");
-
-const zeros = Buffer.alloc;
-const key = zeros(16);
-const iv = zeros(16);
-
-const cipher = () => crypto.createCipheriv("aes-128-cbc", key, iv);
-const decipher = () => crypto.createDecipheriv("aes-128-cbc", key, iv);
-const hash = () => crypto.createSign("sha256");
-const hmac = () => crypto.createHmac("sha256", key);
-const sign = () => crypto.createSign("sha256");
-const verify = () => crypto.createVerify("sha256");
-
-test("crypto update ignores inputEncoding for Buffer input", () => {
-  const functions = [cipher, decipher, hash, hmac, sign, verify];
-  const sizes = [15, 16];
-
-  functions.forEach(f => {
-    sizes.forEach(n => {
-      const instance = f();
-      expect(() => {
-        instance.update(zeros(n), "hex");
-      }).not.toThrow();
-    });
-  });
-});
-
-//<#END_FILE: test-crypto-update-encoding.js
diff --git a/test/js/node/test/parallel/crypto-webcrypto-aes-decrypt-tag-too-small.test.js b/test/js/node/test/parallel/crypto-webcrypto-aes-decrypt-tag-too-small.test.js
deleted file mode 100644
index de241c13af..0000000000
--- a/test/js/node/test/parallel/crypto-webcrypto-aes-decrypt-tag-too-small.test.js
+++ /dev/null
@@ -1,40 +0,0 @@
-//#FILE: test-crypto-webcrypto-aes-decrypt-tag-too-small.js
-//#SHA1: e58d2e4e7dcfc3a29a6e9acbe177f32a1d6bf280
-//-----------------
-"use strict";
-
-if (!globalThis.crypto?.subtle) {
-  test.skip("missing crypto");
-}
-
-test("AES-GCM decrypt with tag too small", async () => {
-  const { subtle } = globalThis.crypto;
-
-  const key = await subtle.importKey(
-    "raw",
-    new Uint8Array(32),
-    {
-      name: "AES-GCM",
-    },
-    false,
-    ["encrypt", "decrypt"],
-  );
-
-  await expect(
-    subtle.decrypt(
-      {
-        name: "AES-GCM",
-        iv: new Uint8Array(12),
-      },
-      key,
-      new Uint8Array(0),
-    ),
-  ).rejects.toThrow(
-    expect.objectContaining({
-      name: "OperationError",
-      message: expect.any(String),
-    }),
-  );
-});
-
-//<#END_FILE: test-crypto-webcrypto-aes-decrypt-tag-too-small.js
diff --git a/test/js/node/test/parallel/dgram-abort-closed.test.js b/test/js/node/test/parallel/dgram-abort-closed.test.js
deleted file mode 100644
index eb09ac67eb..0000000000
--- a/test/js/node/test/parallel/dgram-abort-closed.test.js
+++ /dev/null
@@ -1,20 +0,0 @@
-//#FILE: test-dgram-abort-closed.js
-//#SHA1: 8d3ab4d13dda99cdccb6994f165f2ddacf58360c
-//-----------------
-"use strict";
-
-const dgram = require("dgram");
-
-test("AbortController with closed dgram socket", () => {
-  const controller = new AbortController();
-  const socket = dgram.createSocket({ type: "udp4", signal: controller.signal });
-
-  socket.close();
-
-  // This should not throw or cause any issues
-  expect(() => {
-    controller.abort();
-  }).not.toThrow();
-});
-
-//<#END_FILE: test-dgram-abort-closed.js
diff --git a/test/js/node/test/parallel/dgram-bind-default-address.test.js b/test/js/node/test/parallel/dgram-bind-default-address.test.js
deleted file mode 100644
index 542f335c6e..0000000000
--- a/test/js/node/test/parallel/dgram-bind-default-address.test.js
+++ /dev/null
@@ -1,82 +0,0 @@
-//#FILE: test-dgram-bind-default-address.js
-//#SHA1: f29269b15b1205e37cc43e02b76cc5d8eb3b70be
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const dgram = require("dgram");
-
-// Skip test in FreeBSD jails since 0.0.0.0 will resolve to default interface
-const inFreeBSDJail = process.platform === "freebsd" && process.env.CI === "true";
-if (inFreeBSDJail) {
-  test.skip("In a FreeBSD jail");
-}
-
-test("UDP4 socket bind to default address", async () => {
-  const socket = dgram.createSocket("udp4");
-
-  await new Promise(resolve => {
-    socket.bind(0, () => {
-      const address = socket.address();
-      expect(typeof address.port).toBe("number");
-      expect(isFinite(address.port)).toBe(true);
-      expect(address.port).toBeGreaterThan(0);
-      expect(address.address).toBe("0.0.0.0");
-      socket.close();
-      resolve();
-    });
-  });
-});
-
-const hasIPv6 = (() => {
-  try {
-    const socket = dgram.createSocket("udp6");
-    socket.close();
-    return true;
-  } catch {
-    return false;
-  }
-})();
-
-if (!hasIPv6) {
-  test.skip("udp6 part of test, because no IPv6 support");
-} else {
-  test("UDP6 socket bind to default address", async () => {
-    const socket = dgram.createSocket("udp6");
-
-    await new Promise(resolve => {
-      socket.bind(0, () => {
-        const address = socket.address();
-        expect(typeof address.port).toBe("number");
-        expect(isFinite(address.port)).toBe(true);
-        expect(address.port).toBeGreaterThan(0);
-        let addressValue = address.address;
-        if (addressValue === "::ffff:0.0.0.0") addressValue = "::";
-        expect(addressValue).toBe("::");
-        socket.close();
-        resolve();
-      });
-    });
-  });
-}
-
-//<#END_FILE: test-dgram-bind-default-address.js
diff --git a/test/js/node/test/parallel/dgram-bind.test.js b/test/js/node/test/parallel/dgram-bind.test.js
deleted file mode 100644
index 0bf412718a..0000000000
--- a/test/js/node/test/parallel/dgram-bind.test.js
+++ /dev/null
@@ -1,53 +0,0 @@
-//#FILE: test-dgram-bind.js
-//#SHA1: 748fcd0fcb3ed5103b9072bba3019e560fb2799b
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const dgram = require("dgram");
-
-test("dgram socket bind", async () => {
-  const socket = dgram.createSocket("udp4");
-
-  await new Promise(resolve => {
-    socket.on("listening", () => {
-      expect(() => {
-        socket.bind();
-      }).toThrow(
-        expect.objectContaining({
-          code: "ERR_SOCKET_ALREADY_BOUND",
-          name: "Error",
-          message: expect.stringMatching(/^Socket is already bound$/),
-        }),
-      );
-
-      socket.close();
-      resolve();
-    });
-
-    const result = socket.bind(); // Should not throw.
-
-    expect(result).toBe(socket); // Should have returned itself.
-  });
-});
-
-//<#END_FILE: test-dgram-bind.js
diff --git a/test/js/node/test/parallel/dgram-bytes-length.test.js b/test/js/node/test/parallel/dgram-bytes-length.test.js
deleted file mode 100644
index 1c1bd1e219..0000000000
--- a/test/js/node/test/parallel/dgram-bytes-length.test.js
+++ /dev/null
@@ -1,42 +0,0 @@
-//#FILE: test-dgram-bytes-length.js
-//#SHA1: f899cc14c13e8c913645e204819cf99b867aec5c
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const dgram = require("dgram");
-
-test("dgram bytes length", async () => {
-  const message = Buffer.from("Some bytes");
-  const client = dgram.createSocket("udp4");
-
-  await new Promise((resolve, reject) => {
-    client.send(message, 0, message.length, 41234, "localhost", function (err, bytes) {
-      if (err) reject(err);
-      expect(bytes).toBe(message.length);
-      client.close();
-      resolve();
-    });
-  });
-});
-
-//<#END_FILE: test-dgram-bytes-length.js
diff --git a/test/js/node/test/parallel/dgram-close-in-listening.test.js b/test/js/node/test/parallel/dgram-close-in-listening.test.js
deleted file mode 100644
index e669bea76c..0000000000
--- a/test/js/node/test/parallel/dgram-close-in-listening.test.js
+++ /dev/null
@@ -1,28 +0,0 @@
-//#FILE: test-dgram-close-in-listening.js
-//#SHA1: b37e742b092d70824b67c4ad4d3e1bb17a8c5cd5
-//-----------------
-"use strict";
-
-const dgram = require("dgram");
-
-test("dgram socket closed before sendQueue is drained does not crash", done => {
-  const buf = Buffer.alloc(1024, 42);
-
-  const socket = dgram.createSocket("udp4");
-
-  socket.on("listening", function () {
-    socket.close();
-  });
-
-  // Get a random port for send
-  const portGetter = dgram.createSocket("udp4").bind(0, "localhost", () => {
-    // Adds a listener to 'listening' to send the data when
-    // the socket is available
-    socket.send(buf, 0, buf.length, portGetter.address().port, portGetter.address().address);
-
-    portGetter.close();
-    done(); // Signal test completion
-  });
-});
-
-//<#END_FILE: test-dgram-close-in-listening.js
diff --git a/test/js/node/test/parallel/dgram-close.test.js b/test/js/node/test/parallel/dgram-close.test.js
deleted file mode 100644
index fe89cc0f66..0000000000
--- a/test/js/node/test/parallel/dgram-close.test.js
+++ /dev/null
@@ -1,64 +0,0 @@
-//#FILE: test-dgram-close.js
-//#SHA1: c396ba7a9c9ef45206989b36e4b5db0b95503e38
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-// Flags: --expose-internals
-"use strict";
-// Ensure that if a dgram socket is closed before the DNS lookup completes, it
-// won't crash.
-
-const dgram = require("dgram");
-
-const buf = Buffer.alloc(1024, 42);
-
-test("dgram socket close before DNS lookup completes", done => {
-  let socket = dgram.createSocket("udp4");
-
-  // Get a random port for send
-  const portGetter = dgram.createSocket("udp4");
-
-  portGetter.bind(0, "localhost", () => {
-    socket.send(buf, 0, buf.length, portGetter.address().port, portGetter.address().address);
-
-    expect(socket.close()).toBe(socket);
-
-    socket.on("close", () => {
-      socket = null;
-
-      // Verify that accessing handle after closure doesn't throw
-      setImmediate(() => {
-        setImmediate(() => {
-          // We can't access internal symbols, so we'll just check if this doesn't throw
-          expect(() => {
-            console.log("Handle fd is: ", "placeholder");
-          }).not.toThrow();
-
-          portGetter.close();
-          done();
-        });
-      });
-    });
-  });
-});
-
-//<#END_FILE: test-dgram-close.js
diff --git a/test/js/node/test/parallel/dgram-cluster-close-in-listening.test.js b/test/js/node/test/parallel/dgram-cluster-close-in-listening.test.js
deleted file mode 100644
index 3a882a49d2..0000000000
--- a/test/js/node/test/parallel/dgram-cluster-close-in-listening.test.js
+++ /dev/null
@@ -1,42 +0,0 @@
-//#FILE: test-dgram-cluster-close-in-listening.js
-//#SHA1: f288642fce76ef0138f8e44cd8eb09ded9dc4640
-//-----------------
-"use strict";
-// Ensure that closing dgram sockets in 'listening' callbacks of cluster workers
-// won't throw errors.
-
-const dgram = require("dgram");
-const cluster = require("cluster");
-
-if (process.platform === "win32") {
-  it.skip("dgram clustering is currently not supported on windows.", () => {});
-} else {
-  if (cluster.isPrimary) {
-    test("Primary cluster forks workers", () => {
-      for (let i = 0; i < 3; i += 1) {
-        expect(() => cluster.fork()).not.toThrow();
-      }
-    });
-  } else {
-    test("Worker handles dgram socket lifecycle", done => {
-      const socket = dgram.createSocket("udp4");
-
-      socket.on("error", () => {
-        done(new Error("Error event should not be called"));
-      });
-
-      socket.on("listening", () => {
-        socket.close();
-      });
-
-      socket.on("close", () => {
-        cluster.worker.disconnect();
-        done();
-      });
-
-      socket.bind(0);
-    });
-  }
-}
-
-//<#END_FILE: test-dgram-cluster-close-in-listening.js
diff --git a/test/js/node/test/parallel/dgram-connect-send-callback-multi-buffer.test.js b/test/js/node/test/parallel/dgram-connect-send-callback-multi-buffer.test.js
deleted file mode 100644
index 2d014e97c6..0000000000
--- a/test/js/node/test/parallel/dgram-connect-send-callback-multi-buffer.test.js
+++ /dev/null
@@ -1,36 +0,0 @@
-//#FILE: test-dgram-connect-send-callback-multi-buffer.js
-//#SHA1: f30fbed996bbcd2adb268e9e3412a5f83119f8ae
-//-----------------
-"use strict";
-
-const dgram = require("dgram");
-
-test("dgram connect send callback multi buffer", done => {
-  const client = dgram.createSocket("udp4");
-
-  const messageSent = jest.fn((err, bytes) => {
-    expect(bytes).toBe(buf1.length + buf2.length);
-  });
-
-  const buf1 = Buffer.alloc(256, "x");
-  const buf2 = Buffer.alloc(256, "y");
-
-  client.on("listening", () => {
-    const port = client.address().port;
-    client.connect(port, () => {
-      client.send([buf1, buf2], messageSent);
-    });
-  });
-
-  client.on("message", (buf, info) => {
-    const expected = Buffer.concat([buf1, buf2]);
-    expect(buf.equals(expected)).toBe(true);
-    client.close();
-    expect(messageSent).toHaveBeenCalledTimes(1);
-    done();
-  });
-
-  client.bind(0);
-});
-
-//<#END_FILE: test-dgram-connect-send-callback-multi-buffer.js
diff --git a/test/js/node/test/parallel/dgram-connect-send-default-host.test.js b/test/js/node/test/parallel/dgram-connect-send-default-host.test.js
deleted file mode 100644
index 6e597bae7c..0000000000
--- a/test/js/node/test/parallel/dgram-connect-send-default-host.test.js
+++ /dev/null
@@ -1,69 +0,0 @@
-//#FILE: test-dgram-connect-send-default-host.js
-//#SHA1: 78d734d664f2bf2f6376846bba7c909d8253c4dc
-//-----------------
-"use strict";
-
-const dgram = require("dgram");
-
-const toSend = [Buffer.alloc(256, "x"), Buffer.alloc(256, "y"), Buffer.alloc(256, "z"), "hello"];
-
-const received = [];
-
-test("dgram connect and send with default host", async () => {
-  const client = dgram.createSocket("udp4");
-  const server = dgram.createSocket("udp4");
-
-  const serverListening = new Promise(resolve => {
-    server.on("listening", resolve);
-  });
-
-  server.on("message", (buf, info) => {
-    received.push(buf.toString());
-
-    if (received.length === toSend.length * 2) {
-      // The replies may arrive out of order -> sort them before checking.
-      received.sort();
-
-      const expected = toSend.concat(toSend).map(String).sort();
-      expect(received).toEqual(expected);
-      client.close();
-      server.close();
-    }
-  });
-
-  server.bind(0);
-
-  await serverListening;
-
-  const port = server.address().port;
-  await new Promise((resolve, reject) => {
-    client.connect(port, err => {
-      if (err) reject(err);
-      else resolve();
-    });
-  });
-
-  client.send(toSend[0], 0, toSend[0].length);
-  client.send(toSend[1]);
-  client.send([toSend[2]]);
-  client.send(toSend[3], 0, toSend[3].length);
-
-  client.send(new Uint8Array(toSend[0]), 0, toSend[0].length);
-  client.send(new Uint8Array(toSend[1]));
-  client.send([new Uint8Array(toSend[2])]);
-  client.send(new Uint8Array(Buffer.from(toSend[3])), 0, toSend[3].length);
-
-  // Wait for all messages to be received
-  await new Promise(resolve => {
-    const checkInterval = setInterval(() => {
-      if (received.length === toSend.length * 2) {
-        clearInterval(checkInterval);
-        resolve();
-      }
-    }, 100);
-  });
-
-  expect(received.length).toBe(toSend.length * 2);
-});
-
-//<#END_FILE: test-dgram-connect-send-default-host.js
diff --git a/test/js/node/test/parallel/dgram-connect-send-empty-array.test.js b/test/js/node/test/parallel/dgram-connect-send-empty-array.test.js
deleted file mode 100644
index 32b665f932..0000000000
--- a/test/js/node/test/parallel/dgram-connect-send-empty-array.test.js
+++ /dev/null
@@ -1,29 +0,0 @@
-//#FILE: test-dgram-connect-send-empty-array.js
-//#SHA1: 81de5b211c0e3be3158d2c06178577f39e62f0d1
-//-----------------
-"use strict";
-
-const dgram = require("dgram");
-
-test("dgram.connect() and send empty array", () => {
-  const client = dgram.createSocket("udp4");
-
-  expect.assertions(1);
-
-  return new Promise(resolve => {
-    client.on("message", (buf, info) => {
-      const expected = Buffer.alloc(0);
-      expect(buf).toEqual(expected);
-      client.close();
-      resolve();
-    });
-
-    client.on("listening", () => {
-      client.connect(client.address().port, "127.0.0.1", () => client.send([]));
-    });
-
-    client.bind(0);
-  });
-});
-
-//<#END_FILE: test-dgram-connect-send-empty-array.js
diff --git a/test/js/node/test/parallel/dgram-connect-send-empty-buffer.test.js b/test/js/node/test/parallel/dgram-connect-send-empty-buffer.test.js
deleted file mode 100644
index 7c4209dbf1..0000000000
--- a/test/js/node/test/parallel/dgram-connect-send-empty-buffer.test.js
+++ /dev/null
@@ -1,28 +0,0 @@
-//#FILE: test-dgram-connect-send-empty-buffer.js
-//#SHA1: 08e8b667af8e6f97e6df2c95360a3a3aec05d435
-//-----------------
-"use strict";
-
-const dgram = require("dgram");
-
-test("dgram connect and send empty buffer", done => {
-  const client = dgram.createSocket("udp4");
-
-  client.bind(0, () => {
-    const port = client.address().port;
-    client.connect(port, () => {
-      const buf = Buffer.alloc(0);
-      client.send(buf, 0, 0, err => {
-        expect(err).toBeNull();
-      });
-    });
-
-    client.on("message", buffer => {
-      expect(buffer.length).toBe(0);
-      client.close();
-      done();
-    });
-  });
-});
-
-//<#END_FILE: test-dgram-connect-send-empty-buffer.js
diff --git a/test/js/node/test/parallel/dgram-connect-send-empty-packet.test.js b/test/js/node/test/parallel/dgram-connect-send-empty-packet.test.js
deleted file mode 100644
index d5f56ddb5d..0000000000
--- a/test/js/node/test/parallel/dgram-connect-send-empty-packet.test.js
+++ /dev/null
@@ -1,35 +0,0 @@
-//#FILE: test-dgram-connect-send-empty-packet.js
-//#SHA1: 107d20a1e7a2628097091471ffdad75fc714b1fb
-//-----------------
-"use strict";
-
-const dgram = require("dgram");
-
-test("dgram connect and send empty packet", done => {
-  const client = dgram.createSocket("udp4");
-
-  client.bind(0, () => {
-    expect.hasAssertions();
-    client.connect(client.address().port, () => {
-      client.on("message", callback);
-      const buf = Buffer.alloc(1);
-
-      const interval = setInterval(() => {
-        client.send(buf, 0, 0, callback);
-      }, 10);
-
-      function callback(firstArg) {
-        // If client.send() callback, firstArg should be null.
-        // If client.on('message') listener, firstArg should be a 0-length buffer.
-        if (firstArg instanceof Buffer) {
-          expect(firstArg.length).toBe(0);
-          clearInterval(interval);
-          client.close();
-          done();
-        }
-      }
-    });
-  });
-});
-
-//<#END_FILE: test-dgram-connect-send-empty-packet.js
diff --git a/test/js/node/test/parallel/dgram-connect-send-multi-string-array.test.js b/test/js/node/test/parallel/dgram-connect-send-multi-string-array.test.js
deleted file mode 100644
index 7ae5672c0f..0000000000
--- a/test/js/node/test/parallel/dgram-connect-send-multi-string-array.test.js
+++ /dev/null
@@ -1,25 +0,0 @@
-//#FILE: test-dgram-connect-send-multi-string-array.js
-//#SHA1: 611c15bc8089ffcae85adaa91bff5031c776a8ab
-//-----------------
-"use strict";
-
-const dgram = require("dgram");
-
-test("dgram.createSocket can send multi-string array", done => {
-  const socket = dgram.createSocket("udp4");
-  const data = ["foo", "bar", "baz"];
-
-  socket.on("message", (msg, rinfo) => {
-    socket.close();
-    expect(msg.toString()).toBe(data.join(""));
-    done();
-  });
-
-  socket.bind(0, () => {
-    socket.connect(socket.address().port, () => {
-      socket.send(data);
-    });
-  });
-});
-
-//<#END_FILE: test-dgram-connect-send-multi-string-array.js
diff --git a/test/js/node/test/parallel/dgram-implicit-bind.test.js b/test/js/node/test/parallel/dgram-implicit-bind.test.js
deleted file mode 100644
index d733e2109f..0000000000
--- a/test/js/node/test/parallel/dgram-implicit-bind.test.js
+++ /dev/null
@@ -1,61 +0,0 @@
-//#FILE: test-dgram-implicit-bind.js
-//#SHA1: 3b390facaac3ee5e617c9fdc11acdb9f019fabfa
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const dgram = require("dgram");
-
-test("dgram implicit bind", async () => {
-  const source = dgram.createSocket("udp4");
-  const target = dgram.createSocket("udp4");
-  let messages = 0;
-
-  const messageHandler = jest.fn(buf => {
-    if (buf.toString() === "abc") ++messages;
-    if (buf.toString() === "def") ++messages;
-    if (messages === 2) {
-      source.close();
-      target.close();
-    }
-  });
-
-  target.on("message", messageHandler);
-
-  await new Promise(resolve => {
-    target.on("listening", resolve);
-    target.bind(0);
-  });
-
-  // Second .send() call should not throw a bind error.
-  const port = target.address().port;
-  source.send(Buffer.from("abc"), 0, 3, port, "127.0.0.1");
-  source.send(Buffer.from("def"), 0, 3, port, "127.0.0.1");
-
-  // Wait for the messages to be processed
-  await new Promise(resolve => setTimeout(resolve, 100));
-
-  expect(messageHandler).toHaveBeenCalledTimes(2);
-  expect(messages).toBe(2);
-});
-
-//<#END_FILE: test-dgram-implicit-bind.js
diff --git a/test/js/node/test/parallel/dgram-listen-after-bind.test.js b/test/js/node/test/parallel/dgram-listen-after-bind.test.js
deleted file mode 100644
index fd8faa3fe8..0000000000
--- a/test/js/node/test/parallel/dgram-listen-after-bind.test.js
+++ /dev/null
@@ -1,50 +0,0 @@
-//#FILE: test-dgram-listen-after-bind.js
-//#SHA1: c1a91f2b83b502dd1abc4b46f023df6677fdf465
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const dgram = require("dgram");
-
-test("dgram listen after bind", done => {
-  const socket = dgram.createSocket("udp4");
-
-  socket.bind();
-
-  let fired = false;
-  const timer = setTimeout(() => {
-    socket.close();
-  }, 100);
-
-  socket.on("listening", () => {
-    clearTimeout(timer);
-    fired = true;
-    socket.close();
-  });
-
-  socket.on("close", () => {
-    expect(fired).toBe(true);
-    done();
-  });
-});
-
-//<#END_FILE: test-dgram-listen-after-bind.js
diff --git a/test/js/node/test/parallel/dgram-oob-buffer.test.js b/test/js/node/test/parallel/dgram-oob-buffer.test.js
deleted file mode 100644
index 4d1eae8968..0000000000
--- a/test/js/node/test/parallel/dgram-oob-buffer.test.js
+++ /dev/null
@@ -1,63 +0,0 @@
-//#FILE: test-dgram-oob-buffer.js
-//#SHA1: a851da9a2178e92ce8315294d7cebf6eb78eb4bd
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-// Some operating systems report errors when an UDP message is sent to an
-// unreachable host. This error can be reported by sendto() and even by
-// recvfrom(). Node should not propagate this error to the user.
-
-const dgram = require("dgram");
-
-test("UDP message sent to unreachable host should not propagate error", async () => {
-  const socket = dgram.createSocket("udp4");
-  const buf = Buffer.from([1, 2, 3, 4]);
-
-  const portGetter = dgram.createSocket("udp4");
-
-  await new Promise(resolve => {
-    portGetter.bind(0, "localhost", () => {
-      const { address, port } = portGetter.address();
-
-      portGetter.close(() => {
-        const sendCallback = jest.fn();
-
-        socket.send(buf, 0, 0, port, address, sendCallback);
-        socket.send(buf, 0, 4, port, address, sendCallback);
-        socket.send(buf, 1, 3, port, address, sendCallback);
-        socket.send(buf, 3, 1, port, address, sendCallback);
-        // Since length of zero means nothing, don't error despite OOB.
-        socket.send(buf, 4, 0, port, address, sendCallback);
-
-        socket.close();
-
-        // We expect the sendCallback to not be called
-        expect(sendCallback).not.toHaveBeenCalled();
-
-        resolve();
-      });
-    });
-  });
-});
-
-//<#END_FILE: test-dgram-oob-buffer.js
diff --git a/test/js/node/test/parallel/dgram-ref.test.js b/test/js/node/test/parallel/dgram-ref.test.js
deleted file mode 100644
index bbb6602414..0000000000
--- a/test/js/node/test/parallel/dgram-ref.test.js
+++ /dev/null
@@ -1,44 +0,0 @@
-//#FILE: test-dgram-ref.js
-//#SHA1: b1a50859a1784815d575d8203f7da20fe8d07e50
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const dgram = require("dgram");
-
-test("Should not hang when creating UDP sockets", () => {
-  // Should not hang, see https://github.com/nodejs/node-v0.x-archive/issues/1282
-  expect(() => dgram.createSocket("udp4")).not.toThrow();
-  expect(() => dgram.createSocket("udp6")).not.toThrow();
-});
-
-test("Test ref() on a closed socket", done => {
-  // Test the case of ref()'ing a socket with no handle.
-  const s = dgram.createSocket("udp4");
-
-  s.close(() => {
-    expect(() => s.ref()).not.toThrow();
-    done();
-  });
-});
-
-//<#END_FILE: test-dgram-ref.js
diff --git a/test/js/node/test/parallel/dgram-send-callback-buffer-empty-address.test.js b/test/js/node/test/parallel/dgram-send-callback-buffer-empty-address.test.js
deleted file mode 100644
index de86cfc036..0000000000
--- a/test/js/node/test/parallel/dgram-send-callback-buffer-empty-address.test.js
+++ /dev/null
@@ -1,27 +0,0 @@
-//#FILE: test-dgram-send-callback-buffer-empty-address.js
-//#SHA1: 5c76ad150693dcec8921099fa994f61aa783713c
-//-----------------
-"use strict";
-
-const dgram = require("dgram");
-
-test("dgram send callback with buffer and empty address", done => {
-  const client = dgram.createSocket("udp4");
-
-  const buf = Buffer.alloc(256, "x");
-
-  const onMessage = jest.fn(bytes => {
-    expect(bytes).toBe(buf.length);
-    client.close();
-    done();
-  });
-
-  client.bind(0, () => {
-    client.send(buf, client.address().port, error => {
-      expect(error).toBeFalsy();
-      onMessage(buf.length);
-    });
-  });
-});
-
-//<#END_FILE: test-dgram-send-callback-buffer-empty-address.js
diff --git a/test/js/node/test/parallel/dgram-send-callback-multi-buffer-empty-address.test.js b/test/js/node/test/parallel/dgram-send-callback-multi-buffer-empty-address.test.js
deleted file mode 100644
index 429e4cd9eb..0000000000
--- a/test/js/node/test/parallel/dgram-send-callback-multi-buffer-empty-address.test.js
+++ /dev/null
@@ -1,39 +0,0 @@
-//#FILE: test-dgram-send-callback-multi-buffer-empty-address.js
-//#SHA1: 61d00ee31b25f144989e0d3ced884a70f4e7d07a
-//-----------------
-"use strict";
-
-const dgram = require("dgram");
-
-let client;
-
-beforeEach(() => {
-  client = dgram.createSocket("udp4");
-});
-
-afterEach(() => {
-  client.close();
-});
-
-test("send callback multi buffer empty address", done => {
-  const buf1 = Buffer.alloc(256, "x");
-  const buf2 = Buffer.alloc(256, "y");
-
-  client.on("listening", function () {
-    const port = this.address().port;
-    client.send([buf1, buf2], port, (err, bytes) => {
-      expect(err).toBeNull();
-      expect(bytes).toBe(buf1.length + buf2.length);
-    });
-  });
-
-  client.on("message", buf => {
-    const expected = Buffer.concat([buf1, buf2]);
-    expect(buf.equals(expected)).toBe(true);
-    done();
-  });
-
-  client.bind(0);
-});
-
-//<#END_FILE: test-dgram-send-callback-multi-buffer-empty-address.js
diff --git a/test/js/node/test/parallel/dgram-send-callback-multi-buffer.test.js b/test/js/node/test/parallel/dgram-send-callback-multi-buffer.test.js
deleted file mode 100644
index 36cf0d1eaa..0000000000
--- a/test/js/node/test/parallel/dgram-send-callback-multi-buffer.test.js
+++ /dev/null
@@ -1,35 +0,0 @@
-//#FILE: test-dgram-send-callback-multi-buffer.js
-//#SHA1: 622d513f7897c216601b50a2960a8a36259b2595
-//-----------------
-"use strict";
-
-const dgram = require("dgram");
-
-test("dgram send callback with multiple buffers", done => {
-  const client = dgram.createSocket("udp4");
-
-  const messageSent = jest.fn((err, bytes) => {
-    expect(err).toBeNull();
-    expect(bytes).toBe(buf1.length + buf2.length);
-  });
-
-  const buf1 = Buffer.alloc(256, "x");
-  const buf2 = Buffer.alloc(256, "y");
-
-  client.on("listening", () => {
-    const port = client.address().port;
-    client.send([buf1, buf2], port, "localhost", messageSent);
-  });
-
-  client.on("message", (buf, info) => {
-    const expected = Buffer.concat([buf1, buf2]);
-    expect(buf.equals(expected)).toBe(true);
-    expect(messageSent).toHaveBeenCalledTimes(1);
-    client.close();
-    done();
-  });
-
-  client.bind(0);
-});
-
-//<#END_FILE: test-dgram-send-callback-multi-buffer.js
diff --git a/test/js/node/test/parallel/dgram-send-callback-recursive.test.js b/test/js/node/test/parallel/dgram-send-callback-recursive.test.js
deleted file mode 100644
index e42d990c9f..0000000000
--- a/test/js/node/test/parallel/dgram-send-callback-recursive.test.js
+++ /dev/null
@@ -1,51 +0,0 @@
-//#FILE: test-dgram-send-callback-recursive.js
-//#SHA1: fac7c8b29bd2122d4de273c54128b5a6100ad437
-//-----------------
-"use strict";
-
-const dgram = require("dgram");
-
-let received = 0;
-let sent = 0;
-const limit = 10;
-let async = false;
-let port;
-const chunk = "abc";
-
-test("dgram send callback recursive", done => {
-  const client = dgram.createSocket("udp4");
-
-  function onsend() {
-    if (sent++ < limit) {
-      client.send(chunk, 0, chunk.length, port, "127.0.0.1", onsend);
-    } else {
-      expect(async).toBe(true);
-    }
-  }
-
-  client.on("listening", function () {
-    port = this.address().port;
-
-    process.nextTick(() => {
-      async = true;
-    });
-
-    onsend();
-  });
-
-  client.on("message", (buf, info) => {
-    received++;
-    if (received === limit) {
-      client.close();
-    }
-  });
-
-  client.on("close", () => {
-    expect(received).toBe(limit);
-    done();
-  });
-
-  client.bind(0);
-});
-
-//<#END_FILE: test-dgram-send-callback-recursive.js
diff --git a/test/js/node/test/parallel/dgram-send-cb-quelches-error.test.js b/test/js/node/test/parallel/dgram-send-cb-quelches-error.test.js
deleted file mode 100644
index 96364d73fd..0000000000
--- a/test/js/node/test/parallel/dgram-send-cb-quelches-error.test.js
+++ /dev/null
@@ -1,44 +0,0 @@
-//#FILE: test-dgram-send-cb-quelches-error.js
-//#SHA1: 7525b0a8af0df192c36a848b23332424245d2937
-//-----------------
-"use strict";
-
-const assert = require("assert");
-const dgram = require("dgram");
-const dns = require("dns");
-
-test("dgram send callback quelches error", () => {
-  const socket = dgram.createSocket("udp4");
-  const buffer = Buffer.from("gary busey");
-
-  dns.setServers([]);
-
-  const onEvent = jest.fn(() => {
-    throw new Error("Error should not be emitted if there is callback");
-  });
-
-  socket.once("error", onEvent);
-
-  // assert that:
-  // * callbacks act as "error" listeners if given.
-  // * error is never emitter for missing dns entries
-  //   if a callback that handles error is present
-  // * error is emitted if a callback with no argument is passed
-  socket.send(buffer, 0, buffer.length, 100, "dne.example.com", callbackOnly);
-
-  function callbackOnly(err) {
-    expect(err).toBeTruthy();
-    socket.removeListener("error", onEvent);
-    socket.on("error", onError);
-    socket.send(buffer, 0, buffer.length, 100, "dne.invalid");
-  }
-
-  function onError(err) {
-    expect(err).toBeTruthy();
-    socket.close();
-  }
-
-  expect(onEvent).not.toHaveBeenCalled();
-});
-
-//<#END_FILE: test-dgram-send-cb-quelches-error.js
diff --git a/test/js/node/test/parallel/dgram-send-empty-buffer.test.js b/test/js/node/test/parallel/dgram-send-empty-buffer.test.js
deleted file mode 100644
index 3dcd6ffe3b..0000000000
--- a/test/js/node/test/parallel/dgram-send-empty-buffer.test.js
+++ /dev/null
@@ -1,50 +0,0 @@
-//#FILE: test-dgram-send-empty-buffer.js
-//#SHA1: ac60fc545252e681b648a7038d1bebe46ffbbac0
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const dgram = require("dgram");
-
-test("dgram send empty buffer", done => {
-  const client = dgram.createSocket("udp4");
-
-  client.bind(0, () => {
-    const port = client.address().port;
-
-    client.on("message", buffer => {
-      expect(buffer.length).toBe(0);
-      clearInterval(interval);
-      client.close();
-      done();
-    });
-
-    const buf = Buffer.alloc(0);
-    const interval = setInterval(() => {
-      client.send(buf, 0, 0, port, "127.0.0.1", () => {
-        // This callback is expected to be called
-      });
-    }, 10);
-  });
-});
-
-//<#END_FILE: test-dgram-send-empty-buffer.js
diff --git a/test/js/node/test/parallel/dgram-send-empty-packet.test.js b/test/js/node/test/parallel/dgram-send-empty-packet.test.js
deleted file mode 100644
index 07802512c7..0000000000
--- a/test/js/node/test/parallel/dgram-send-empty-packet.test.js
+++ /dev/null
@@ -1,34 +0,0 @@
-//#FILE: test-dgram-send-empty-packet.js
-//#SHA1: f39fb8a7245893f0f6f55aeb110d458e2f265013
-//-----------------
-"use strict";
-
-const dgram = require("dgram");
-
-test("send empty packet", done => {
-  const client = dgram.createSocket("udp4");
-
-  client.bind(0, () => {
-    client.on("message", jest.fn(callback));
-
-    const port = client.address().port;
-    const buf = Buffer.alloc(1);
-
-    const interval = setInterval(() => {
-      client.send(buf, 0, 0, port, "127.0.0.1", jest.fn(callback));
-    }, 10);
-
-    function callback(firstArg) {
-      // If client.send() callback, firstArg should be null.
-      // If client.on('message') listener, firstArg should be a 0-length buffer.
-      if (firstArg instanceof Buffer) {
-        expect(firstArg.length).toBe(0);
-        clearInterval(interval);
-        client.close();
-        done();
-      }
-    }
-  });
-});
-
-//<#END_FILE: test-dgram-send-empty-packet.js
diff --git a/test/js/node/test/parallel/dgram-send-multi-buffer-copy.test.js b/test/js/node/test/parallel/dgram-send-multi-buffer-copy.test.js
deleted file mode 100644
index b9baba6443..0000000000
--- a/test/js/node/test/parallel/dgram-send-multi-buffer-copy.test.js
+++ /dev/null
@@ -1,42 +0,0 @@
-//#FILE: test-dgram-send-multi-buffer-copy.js
-//#SHA1: 6adf8291a5dd40cb6a71ad3779f0d26d2150249a
-//-----------------
-"use strict";
-
-const dgram = require("dgram");
-
-let client;
-
-beforeEach(() => {
-  client = dgram.createSocket("udp4");
-});
-
-afterEach(() => {
-  client.close();
-});
-
-test("dgram send multi buffer copy", done => {
-  const onMessage = jest.fn((err, bytes) => {
-    expect(bytes).toBe(buf1.length + buf2.length);
-  });
-
-  const buf1 = Buffer.alloc(256, "x");
-  const buf2 = Buffer.alloc(256, "y");
-
-  client.on("listening", function () {
-    const toSend = [buf1, buf2];
-    client.send(toSend, this.address().port, "127.0.0.1", onMessage);
-    toSend.splice(0, 2);
-  });
-
-  client.on("message", (buf, info) => {
-    const expected = Buffer.concat([buf1, buf2]);
-    expect(buf.equals(expected)).toBe(true);
-    expect(onMessage).toHaveBeenCalledTimes(1);
-    done();
-  });
-
-  client.bind(0);
-});
-
-//<#END_FILE: test-dgram-send-multi-buffer-copy.js
diff --git a/test/js/node/test/parallel/dgram-send-multi-string-array.test.js b/test/js/node/test/parallel/dgram-send-multi-string-array.test.js
deleted file mode 100644
index 804ea7c285..0000000000
--- a/test/js/node/test/parallel/dgram-send-multi-string-array.test.js
+++ /dev/null
@@ -1,23 +0,0 @@
-//#FILE: test-dgram-send-multi-string-array.js
-//#SHA1: 8ea2007ac52bfde3742aabe352aab19bf91a4ac2
-//-----------------
-"use strict";
-
-const dgram = require("dgram");
-
-test("dgram send multiple strings as array", done => {
-  const socket = dgram.createSocket("udp4");
-  const data = ["foo", "bar", "baz"];
-
-  socket.on("message", (msg, rinfo) => {
-    socket.close();
-    expect(msg.toString()).toBe(data.join(""));
-    done();
-  });
-
-  socket.bind(() => {
-    socket.send(data, socket.address().port, "localhost");
-  });
-});
-
-//<#END_FILE: test-dgram-send-multi-string-array.js
diff --git a/test/js/node/test/parallel/dgram-udp4.test.js b/test/js/node/test/parallel/dgram-udp4.test.js
deleted file mode 100644
index 27be2e63fc..0000000000
--- a/test/js/node/test/parallel/dgram-udp4.test.js
+++ /dev/null
@@ -1,81 +0,0 @@
-//#FILE: test-dgram-udp4.js
-//#SHA1: 588735591046212fc512f69d9001ccb820c57a71
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const dgram = require("dgram");
-
-const message_to_send = "A message to send";
-const localhostIPv4 = "127.0.0.1";
-
-test("UDP4 server and client communication", async () => {
-  const server = dgram.createSocket("udp4");
-
-  const serverMessagePromise = new Promise(resolve => {
-    server.on("message", (msg, rinfo) => {
-      expect(rinfo.address).toBe(localhostIPv4);
-      expect(msg.toString()).toBe(message_to_send);
-      server.send(msg, 0, msg.length, rinfo.port, rinfo.address);
-      resolve();
-    });
-  });
-
-  const listeningPromise = new Promise(resolve => {
-    server.on("listening", resolve);
-  });
-
-  server.bind(0);
-
-  await listeningPromise;
-
-  const client = dgram.createSocket("udp4");
-  const port = server.address().port;
-
-  const clientMessagePromise = new Promise(resolve => {
-    client.on("message", (msg, rinfo) => {
-      expect(rinfo.address).toBe(localhostIPv4);
-      expect(rinfo.port).toBe(port);
-      expect(msg.toString()).toBe(message_to_send);
-      resolve();
-    });
-  });
-
-  client.send(message_to_send, 0, message_to_send.length, port, "localhost");
-
-  await Promise.all([serverMessagePromise, clientMessagePromise]);
-
-  const clientClosePromise = new Promise(resolve => {
-    client.on("close", resolve);
-  });
-
-  const serverClosePromise = new Promise(resolve => {
-    server.on("close", resolve);
-  });
-
-  client.close();
-  server.close();
-
-  await Promise.all([clientClosePromise, serverClosePromise]);
-});
-
-//<#END_FILE: test-dgram-udp4.js
diff --git a/test/js/node/test/parallel/dgram-unref-in-cluster.test.js b/test/js/node/test/parallel/dgram-unref-in-cluster.test.js
deleted file mode 100644
index dcca2428e3..0000000000
--- a/test/js/node/test/parallel/dgram-unref-in-cluster.test.js
+++ /dev/null
@@ -1,36 +0,0 @@
-//#FILE: test-dgram-unref-in-cluster.js
-//#SHA1: eca71c33b1bf5be34a28e6cc82df49c73e775153
-//-----------------
-"use strict";
-
-const dgram = require("dgram");
-const cluster = require("cluster");
-
-if (process.platform === "win32") {
-  test.skip("dgram clustering is currently not supported on Windows.");
-} else {
-  if (cluster.isPrimary) {
-    test("dgram unref in cluster", () => {
-      cluster.fork();
-    });
-  } else {
-    test("dgram unref in cluster worker", () => {
-      const socket = dgram.createSocket("udp4");
-      socket.unref();
-      socket.bind();
-
-      return new Promise(resolve => {
-        socket.on("listening", () => {
-          const sockets = process.getActiveResourcesInfo().filter(item => {
-            return item === "UDPWrap";
-          });
-          expect(sockets.length).toBe(0);
-          process.disconnect();
-          resolve();
-        });
-      });
-    });
-  }
-}
-
-//<#END_FILE: test-dgram-unref-in-cluster.js
diff --git a/test/js/node/test/parallel/dgram-unref.test.js b/test/js/node/test/parallel/dgram-unref.test.js
deleted file mode 100644
index ff11989d7b..0000000000
--- a/test/js/node/test/parallel/dgram-unref.test.js
+++ /dev/null
@@ -1,49 +0,0 @@
-//#FILE: test-dgram-unref.js
-//#SHA1: 97b218a9107def7e2cc28e595f84f9a05a606850
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const dgram = require("dgram");
-
-test("unref() a socket with a handle", () => {
-  const s = dgram.createSocket("udp4");
-  s.bind();
-  s.unref();
-  // No assertion needed, just checking that it doesn't throw
-});
-
-test("unref() a socket with no handle", done => {
-  const s = dgram.createSocket("udp4");
-  s.close(() => {
-    s.unref();
-    done();
-  });
-});
-
-test("setTimeout should not be called", () => {
-  const mockCallback = jest.fn();
-  setTimeout(mockCallback, 1000).unref();
-  expect(mockCallback).not.toHaveBeenCalled();
-});
-
-//<#END_FILE: test-dgram-unref.js
diff --git a/test/js/node/test/parallel/diagnostics-channel-has-subscribers.test.js b/test/js/node/test/parallel/diagnostics-channel-has-subscribers.test.js
deleted file mode 100644
index 2e2f119c73..0000000000
--- a/test/js/node/test/parallel/diagnostics-channel-has-subscribers.test.js
+++ /dev/null
@@ -1,18 +0,0 @@
-//#FILE: test-diagnostics-channel-has-subscribers.js
-//#SHA1: 8040abda8d37916d6f6d5f3966e8c531d1770e1a
-//-----------------
-"use strict";
-
-const { channel, hasSubscribers } = require("diagnostics_channel");
-
-describe("diagnostics_channel", () => {
-  test("hasSubscribers returns correct state", () => {
-    const dc = channel("test");
-    expect(hasSubscribers("test")).toBe(false);
-
-    dc.subscribe(() => {});
-    expect(hasSubscribers("test")).toBe(true);
-  });
-});
-
-//<#END_FILE: test-diagnostics-channel-has-subscribers.js
diff --git a/test/js/node/test/parallel/diagnostics-channel-http-server-start.test.js b/test/js/node/test/parallel/diagnostics-channel-http-server-start.test.js
deleted file mode 100644
index a5446eec21..0000000000
--- a/test/js/node/test/parallel/diagnostics-channel-http-server-start.test.js
+++ /dev/null
@@ -1,76 +0,0 @@
-//#FILE: test-diagnostics-channel-http-server-start.js
-//#SHA1: 5540b17246152983b832ddafa0be55502ee83a23
-//-----------------
-"use strict";
-
-const { AsyncLocalStorage } = require("async_hooks");
-const dc = require("diagnostics_channel");
-const http = require("http");
-
-const als = new AsyncLocalStorage();
-let context;
-
-describe("diagnostics_channel http server start", () => {
-  let server;
-  let request;
-  let response;
-
-  beforeAll(() => {
-    // Bind requests to an AsyncLocalStorage context
-    dc.subscribe("http.server.request.start", message => {
-      als.enterWith(message);
-      context = message;
-    });
-
-    // When the request ends, verify the context has been maintained
-    // and that the messages contain the expected data
-    dc.subscribe("http.server.response.finish", message => {
-      const data = {
-        request,
-        response,
-        server,
-        socket: request.socket,
-      };
-
-      // Context is maintained
-      compare(als.getStore(), context);
-
-      compare(context, data);
-      compare(message, data);
-    });
-
-    server = http.createServer((req, res) => {
-      request = req;
-      response = res;
-
-      setTimeout(() => {
-        res.end("done");
-      }, 1);
-    });
-  });
-
-  afterAll(() => {
-    server.close();
-  });
-
-  it("should maintain context and contain expected data", done => {
-    server.listen(() => {
-      const { port } = server.address();
-      http.get(`http://localhost:${port}`, res => {
-        res.resume();
-        res.on("end", () => {
-          done();
-        });
-      });
-    });
-  });
-});
-
-function compare(a, b) {
-  expect(a.request).toBe(b.request);
-  expect(a.response).toBe(b.response);
-  expect(a.socket).toBe(b.socket);
-  expect(a.server).toBe(b.server);
-}
-
-//<#END_FILE: test-diagnostics-channel-http-server-start.js
diff --git a/test/js/node/test/parallel/diagnostics-channel-object-channel-pub-sub.test.js b/test/js/node/test/parallel/diagnostics-channel-object-channel-pub-sub.test.js
deleted file mode 100644
index ae95ea487b..0000000000
--- a/test/js/node/test/parallel/diagnostics-channel-object-channel-pub-sub.test.js
+++ /dev/null
@@ -1,60 +0,0 @@
-//#FILE: test-diagnostics-channel-object-channel-pub-sub.js
-//#SHA1: 185a8134da179dfda5f6b2d1a1a2622752431a90
-//-----------------
-"use strict";
-
-const dc = require("diagnostics_channel");
-const { Channel } = dc;
-
-const input = {
-  foo: "bar",
-};
-
-test("Channel creation and subscription", () => {
-  // Should not have named channel
-  expect(dc.hasSubscribers("test")).toBe(false);
-
-  // Individual channel objects can be created to avoid future lookups
-  const channel = dc.channel("test");
-  expect(channel).toBeInstanceOf(Channel);
-
-  // No subscribers yet, should not publish
-  expect(channel.hasSubscribers).toBe(false);
-
-  const subscriber = jest.fn((message, name) => {
-    expect(name).toBe(channel.name);
-    expect(message).toEqual(input);
-  });
-
-  // Now there's a subscriber, should publish
-  channel.subscribe(subscriber);
-  expect(channel.hasSubscribers).toBe(true);
-
-  // The ActiveChannel prototype swap should not fail instanceof
-  expect(channel).toBeInstanceOf(Channel);
-
-  // Should trigger the subscriber once
-  channel.publish(input);
-  expect(subscriber).toHaveBeenCalledTimes(1);
-
-  // Should not publish after subscriber is unsubscribed
-  expect(channel.unsubscribe(subscriber)).toBe(true);
-  expect(channel.hasSubscribers).toBe(false);
-
-  // unsubscribe() should return false when subscriber is not found
-  expect(channel.unsubscribe(subscriber)).toBe(false);
-});
-
-test("Invalid subscriber", () => {
-  const channel = dc.channel("test");
-  expect(() => {
-    channel.subscribe(null);
-  }).toThrow(
-    expect.objectContaining({
-      code: "ERR_INVALID_ARG_TYPE",
-      message: expect.any(String),
-    }),
-  );
-});
-
-//<#END_FILE: test-diagnostics-channel-object-channel-pub-sub.js
diff --git a/test/js/node/test/parallel/diagnostics-channel-pub-sub.test.js b/test/js/node/test/parallel/diagnostics-channel-pub-sub.test.js
deleted file mode 100644
index f20d19d136..0000000000
--- a/test/js/node/test/parallel/diagnostics-channel-pub-sub.test.js
+++ /dev/null
@@ -1,62 +0,0 @@
-//#FILE: test-diagnostics-channel-pub-sub.js
-//#SHA1: cc5eee7f44117c2fd8446e8050ac19f5341f85a5
-//-----------------
-"use strict";
-
-const dc = require("diagnostics_channel");
-const { Channel } = dc;
-
-const name = "test";
-const input = {
-  foo: "bar",
-};
-
-test("diagnostics_channel pub/sub functionality", () => {
-  // Individual channel objects can be created to avoid future lookups
-  const channel = dc.channel(name);
-  expect(channel).toBeInstanceOf(Channel);
-
-  // No subscribers yet, should not publish
-  expect(channel.hasSubscribers).toBeFalsy();
-
-  const subscriber = jest.fn((message, channelName) => {
-    expect(channelName).toBe(channel.name);
-    expect(message).toEqual(input);
-  });
-
-  // Now there's a subscriber, should publish
-  dc.subscribe(name, subscriber);
-  expect(channel.hasSubscribers).toBeTruthy();
-
-  // The ActiveChannel prototype swap should not fail instanceof
-  expect(channel).toBeInstanceOf(Channel);
-
-  // Should trigger the subscriber once
-  channel.publish(input);
-  expect(subscriber).toHaveBeenCalledTimes(1);
-
-  // Should not publish after subscriber is unsubscribed
-  expect(dc.unsubscribe(name, subscriber)).toBeTruthy();
-  expect(channel.hasSubscribers).toBeFalsy();
-
-  // unsubscribe() should return false when subscriber is not found
-  expect(dc.unsubscribe(name, subscriber)).toBeFalsy();
-
-  expect(() => {
-    dc.subscribe(name, null);
-  }).toThrow(
-    expect.objectContaining({
-      code: "ERR_INVALID_ARG_TYPE",
-      message: expect.any(String),
-    }),
-  );
-
-  // Reaching zero subscribers should not delete from the channels map as there
-  // will be no more weakref to incRef if another subscribe happens while the
-  // channel object itself exists.
-  channel.subscribe(subscriber);
-  channel.unsubscribe(subscriber);
-  channel.subscribe(subscriber);
-});
-
-//<#END_FILE: test-diagnostics-channel-pub-sub.js
diff --git a/test/js/node/test/parallel/diagnostics-channel-symbol-named.test.js b/test/js/node/test/parallel/diagnostics-channel-symbol-named.test.js
deleted file mode 100644
index d2d6065687..0000000000
--- a/test/js/node/test/parallel/diagnostics-channel-symbol-named.test.js
+++ /dev/null
@@ -1,43 +0,0 @@
-//#FILE: test-diagnostics-channel-symbol-named.js
-//#SHA1: e0ae87b803333891439e11fa2306eefd23b507e4
-//-----------------
-"use strict";
-
-const dc = require("diagnostics_channel");
-
-const input = {
-  foo: "bar",
-};
-
-const symbol = Symbol("test");
-
-// Individual channel objects can be created to avoid future lookups
-const channel = dc.channel(symbol);
-
-test("diagnostics channel with symbol name", () => {
-  // Expect two successful publishes later
-  const subscriber = jest.fn((message, name) => {
-    expect(name).toBe(symbol);
-    expect(message).toEqual(input);
-  });
-
-  channel.subscribe(subscriber);
-
-  channel.publish(input);
-
-  expect(subscriber).toHaveBeenCalledTimes(1);
-});
-
-test("channel creation with invalid argument", () => {
-  expect(() => {
-    dc.channel(null);
-  }).toThrow(
-    expect.objectContaining({
-      name: "TypeError",
-      code: "ERR_INVALID_ARG_TYPE",
-      message: expect.any(String),
-    }),
-  );
-});
-
-//<#END_FILE: test-diagnostics-channel-symbol-named.js
diff --git a/test/js/node/test/parallel/diagnostics-channel-sync-unsubscribe.test.js b/test/js/node/test/parallel/diagnostics-channel-sync-unsubscribe.test.js
deleted file mode 100644
index eb5ceea25b..0000000000
--- a/test/js/node/test/parallel/diagnostics-channel-sync-unsubscribe.test.js
+++ /dev/null
@@ -1,24 +0,0 @@
-//#FILE: test-diagnostics-channel-sync-unsubscribe.js
-//#SHA1: 85d73bd9ce82a4293daca05617b2aece359745ff
-//-----------------
-"use strict";
-
-const dc = require("node:diagnostics_channel");
-
-const channel_name = "test:channel";
-const published_data = "some message";
-
-test("diagnostics channel sync unsubscribe", () => {
-  const onMessageHandler = jest.fn(() => dc.unsubscribe(channel_name, onMessageHandler));
-
-  dc.subscribe(channel_name, onMessageHandler);
-
-  // This must not throw.
-  expect(() => {
-    dc.channel(channel_name).publish(published_data);
-  }).not.toThrow();
-
-  expect(onMessageHandler).toHaveBeenCalledTimes(1);
-});
-
-//<#END_FILE: test-diagnostics-channel-sync-unsubscribe.js
diff --git a/test/js/node/test/parallel/diagnostics-channel-tracing-channel-callback-run-stores.test.js b/test/js/node/test/parallel/diagnostics-channel-tracing-channel-callback-run-stores.test.js
deleted file mode 100644
index 15fcdedaf9..0000000000
--- a/test/js/node/test/parallel/diagnostics-channel-tracing-channel-callback-run-stores.test.js
+++ /dev/null
@@ -1,45 +0,0 @@
-//#FILE: test-diagnostics-channel-tracing-channel-callback-run-stores.js
-//#SHA1: 8ed3a87eb9d6c1a3a624245ce5f430b7e3730d2d
-//-----------------
-"use strict";
-
-const { AsyncLocalStorage } = require("async_hooks");
-const dc = require("diagnostics_channel");
-
-const channel = dc.tracingChannel("test");
-const store = new AsyncLocalStorage();
-
-const firstContext = { foo: "bar" };
-const secondContext = { baz: "buz" };
-
-test("tracing channel callback run stores", async () => {
-  const startBindStoreMock = jest.fn(() => firstContext);
-  const asyncStartBindStoreMock = jest.fn(() => secondContext);
-
-  channel.start.bindStore(store, startBindStoreMock);
-  channel.asyncStart.bindStore(store, asyncStartBindStoreMock);
-
-  expect(store.getStore()).toBeUndefined();
-
-  await new Promise(resolve => {
-    channel.traceCallback(
-      cb => {
-        expect(store.getStore()).toEqual(firstContext);
-        setImmediate(cb);
-      },
-      0,
-      {},
-      null,
-      () => {
-        expect(store.getStore()).toEqual(secondContext);
-        resolve();
-      },
-    );
-  });
-
-  expect(store.getStore()).toBeUndefined();
-  expect(startBindStoreMock).toHaveBeenCalledTimes(1);
-  expect(asyncStartBindStoreMock).toHaveBeenCalledTimes(1);
-});
-
-//<#END_FILE: test-diagnostics-channel-tracing-channel-callback-run-stores.js
diff --git a/test/js/node/test/parallel/diagnostics-channel-tracing-channel-promise-run-stores.test.js b/test/js/node/test/parallel/diagnostics-channel-tracing-channel-promise-run-stores.test.js
deleted file mode 100644
index 6c75c54789..0000000000
--- a/test/js/node/test/parallel/diagnostics-channel-tracing-channel-promise-run-stores.test.js
+++ /dev/null
@@ -1,39 +0,0 @@
-//#FILE: test-diagnostics-channel-tracing-channel-promise-run-stores.js
-//#SHA1: 4e5abb65d92cb3e649073803971180493c1a30ca
-//-----------------
-"use strict";
-
-const { setTimeout } = require("node:timers/promises");
-const { AsyncLocalStorage } = require("async_hooks");
-const dc = require("diagnostics_channel");
-
-const channel = dc.tracingChannel("test");
-const store = new AsyncLocalStorage();
-
-const firstContext = { foo: "bar" };
-const secondContext = { baz: "buz" };
-
-test("tracingChannel promise run stores", async () => {
-  const startBindStoreMock = jest.fn(() => firstContext);
-  const asyncStartBindStoreMock = jest.fn(() => secondContext);
-
-  channel.start.bindStore(store, startBindStoreMock);
-  channel.asyncStart.bindStore(store, asyncStartBindStoreMock);
-
-  expect(store.getStore()).toBeUndefined();
-
-  await channel.tracePromise(async () => {
-    expect(store.getStore()).toEqual(firstContext);
-    await setTimeout(1);
-    // Should _not_ switch to second context as promises don't have an "after"
-    // point at which to do a runStores.
-    expect(store.getStore()).toEqual(firstContext);
-  });
-
-  expect(store.getStore()).toBeUndefined();
-
-  expect(startBindStoreMock).toHaveBeenCalledTimes(1);
-  expect(asyncStartBindStoreMock).not.toHaveBeenCalled();
-});
-
-//<#END_FILE: test-diagnostics-channel-tracing-channel-promise-run-stores.js
diff --git a/test/js/node/test/parallel/diagnostics-channel-tracing-channel-promise.test.js b/test/js/node/test/parallel/diagnostics-channel-tracing-channel-promise.test.js
deleted file mode 100644
index 032a552cb6..0000000000
--- a/test/js/node/test/parallel/diagnostics-channel-tracing-channel-promise.test.js
+++ /dev/null
@@ -1,64 +0,0 @@
-//#FILE: test-diagnostics-channel-tracing-channel-promise.js
-//#SHA1: 6a692d8400685da6c930b662562adb3e36b2da9a
-//-----------------
-"use strict";
-
-const dc = require("diagnostics_channel");
-
-const channel = dc.tracingChannel("test");
-
-const expectedResult = { foo: "bar" };
-const input = { foo: "bar" };
-const thisArg = { baz: "buz" };
-
-function check(found) {
-  expect(found).toEqual(input);
-}
-
-function checkAsync(found) {
-  check(found);
-  expect(found.error).toBeUndefined();
-  expect(found.result).toEqual(expectedResult);
-}
-
-const handlers = {
-  start: jest.fn(check),
-  end: jest.fn(check),
-  asyncStart: jest.fn(checkAsync),
-  asyncEnd: jest.fn(checkAsync),
-  error: jest.fn(),
-};
-
-test("diagnostics_channel tracing channel promise", async () => {
-  channel.subscribe(handlers);
-
-  await channel.tracePromise(
-    function (value) {
-      expect(this).toEqual(thisArg);
-      return Promise.resolve(value);
-    },
-    input,
-    thisArg,
-    expectedResult,
-  );
-
-  expect(handlers.start).toHaveBeenCalledTimes(1);
-  expect(handlers.end).toHaveBeenCalledTimes(1);
-  expect(handlers.asyncStart).toHaveBeenCalledTimes(1);
-  expect(handlers.asyncEnd).toHaveBeenCalledTimes(1);
-  expect(handlers.error).not.toHaveBeenCalled();
-
-  const value = await channel.tracePromise(
-    function (value) {
-      expect(this).toEqual(thisArg);
-      return Promise.resolve(value);
-    },
-    input,
-    thisArg,
-    expectedResult,
-  );
-
-  expect(value).toEqual(expectedResult);
-});
-
-//<#END_FILE: test-diagnostics-channel-tracing-channel-promise.js
diff --git a/test/js/node/test/parallel/diagnostics-channel-tracing-channel-sync-error.test.js b/test/js/node/test/parallel/diagnostics-channel-tracing-channel-sync-error.test.js
deleted file mode 100644
index 2906e447cf..0000000000
--- a/test/js/node/test/parallel/diagnostics-channel-tracing-channel-sync-error.test.js
+++ /dev/null
@@ -1,52 +0,0 @@
-//#FILE: test-diagnostics-channel-tracing-channel-sync-error.js
-//#SHA1: faf279d48c76f3c97ddf7e258df9ed49154a4cac
-//-----------------
-"use strict";
-
-const dc = require("diagnostics_channel");
-
-const channel = dc.tracingChannel("test");
-
-const expectedError = new Error("test");
-const input = { foo: "bar" };
-const thisArg = { baz: "buz" };
-
-function check(found) {
-  expect(found).toEqual(input);
-}
-
-test("traceSync with error", () => {
-  const handlers = {
-    start: jest.fn(check),
-    end: jest.fn(check),
-    asyncStart: jest.fn(),
-    asyncEnd: jest.fn(),
-    error: jest.fn(found => {
-      check(found);
-      expect(found.error).toBe(expectedError);
-    }),
-  };
-
-  channel.subscribe(handlers);
-
-  expect(() => {
-    channel.traceSync(
-      function (err) {
-        expect(this).toEqual(thisArg);
-        expect(err).toBe(expectedError);
-        throw err;
-      },
-      input,
-      thisArg,
-      expectedError,
-    );
-  }).toThrow(expectedError);
-
-  expect(handlers.start).toHaveBeenCalledTimes(1);
-  expect(handlers.end).toHaveBeenCalledTimes(1);
-  expect(handlers.asyncStart).not.toHaveBeenCalled();
-  expect(handlers.asyncEnd).not.toHaveBeenCalled();
-  expect(handlers.error).toHaveBeenCalledTimes(1);
-});
-
-//<#END_FILE: test-diagnostics-channel-tracing-channel-sync-error.js
diff --git a/test/js/node/test/parallel/diagnostics-channel-tracing-channel-sync-run-stores.test.js b/test/js/node/test/parallel/diagnostics-channel-tracing-channel-sync-run-stores.test.js
deleted file mode 100644
index ed7212e92d..0000000000
--- a/test/js/node/test/parallel/diagnostics-channel-tracing-channel-sync-run-stores.test.js
+++ /dev/null
@@ -1,32 +0,0 @@
-//#FILE: test-diagnostics-channel-tracing-channel-sync-run-stores.js
-//#SHA1: 51ffe2c7cb7160b565bfe6bbca0d29005a6bf876
-//-----------------
-"use strict";
-
-const { AsyncLocalStorage } = require("async_hooks");
-const dc = require("diagnostics_channel");
-
-const channel = dc.tracingChannel("test");
-const store = new AsyncLocalStorage();
-
-const context = { foo: "bar" };
-
-test("diagnostics channel tracing channel sync run stores", () => {
-  const startCallback = jest.fn(() => context);
-  channel.start.bindStore(store, startCallback);
-
-  expect(store.getStore()).toBeUndefined();
-
-  const traceCallback = jest.fn(() => {
-    expect(store.getStore()).toEqual(context);
-  });
-
-  channel.traceSync(traceCallback);
-
-  expect(store.getStore()).toBeUndefined();
-
-  expect(startCallback).toHaveBeenCalledTimes(1);
-  expect(traceCallback).toHaveBeenCalledTimes(1);
-});
-
-//<#END_FILE: test-diagnostics-channel-tracing-channel-sync-run-stores.js
diff --git a/test/js/node/test/parallel/diagnostics-channel-tracing-channel-sync.test.js b/test/js/node/test/parallel/diagnostics-channel-tracing-channel-sync.test.js
deleted file mode 100644
index f4a4c3b923..0000000000
--- a/test/js/node/test/parallel/diagnostics-channel-tracing-channel-sync.test.js
+++ /dev/null
@@ -1,80 +0,0 @@
-//#FILE: test-diagnostics-channel-tracing-channel-sync.js
-//#SHA1: fad9bfb35032ed67643b026f8e79611d8197a131
-//-----------------
-"use strict";
-
-const dc = require("diagnostics_channel");
-
-const channel = dc.tracingChannel("test");
-
-const expectedResult = { foo: "bar" };
-const input = { foo: "bar" };
-const thisArg = { baz: "buz" };
-const arg = { baz: "buz" };
-
-function check(found) {
-  expect(found).toBe(input);
-}
-
-describe("diagnostics_channel tracing channel sync", () => {
-  const handlers = {
-    start: jest.fn(check),
-    end: jest.fn(found => {
-      check(found);
-      expect(found.result).toBe(expectedResult);
-    }),
-    asyncStart: jest.fn(),
-    asyncEnd: jest.fn(),
-    error: jest.fn(),
-  };
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  test("channel subscription and traceSync", () => {
-    expect(channel.start.hasSubscribers).toBe(false);
-    channel.subscribe(handlers);
-    expect(channel.start.hasSubscribers).toBe(true);
-
-    const result1 = channel.traceSync(
-      function (arg1) {
-        expect(arg1).toBe(arg);
-        expect(this).toBe(thisArg);
-        return expectedResult;
-      },
-      input,
-      thisArg,
-      arg,
-    );
-
-    expect(result1).toBe(expectedResult);
-    expect(handlers.start).toHaveBeenCalledTimes(1);
-    expect(handlers.end).toHaveBeenCalledTimes(1);
-    expect(handlers.asyncStart).not.toHaveBeenCalled();
-    expect(handlers.asyncEnd).not.toHaveBeenCalled();
-    expect(handlers.error).not.toHaveBeenCalled();
-  });
-
-  test("channel unsubscription", () => {
-    channel.unsubscribe(handlers);
-    expect(channel.start.hasSubscribers).toBe(false);
-
-    const result2 = channel.traceSync(
-      function (arg1) {
-        expect(arg1).toBe(arg);
-        expect(this).toBe(thisArg);
-        return expectedResult;
-      },
-      input,
-      thisArg,
-      arg,
-    );
-
-    expect(result2).toBe(expectedResult);
-    expect(handlers.start).not.toHaveBeenCalled();
-    expect(handlers.end).not.toHaveBeenCalled();
-  });
-});
-
-//<#END_FILE: test-diagnostics-channel-tracing-channel-sync.js
diff --git a/test/js/node/test/parallel/diagnostics-channel-udp.test.js b/test/js/node/test/parallel/diagnostics-channel-udp.test.js
deleted file mode 100644
index 449df21666..0000000000
--- a/test/js/node/test/parallel/diagnostics-channel-udp.test.js
+++ /dev/null
@@ -1,26 +0,0 @@
-//#FILE: test-diagnostics-channel-udp.js
-//#SHA1: 13d46f3f2404ee7cd53a551b90fc1ced191d4a81
-//-----------------
-"use strict";
-
-const dgram = require("dgram");
-const dc = require("diagnostics_channel");
-
-const udpSocketChannel = dc.channel("udp.socket");
-
-const isUDPSocket = socket => socket instanceof dgram.Socket;
-
-test("udp.socket channel emits UDP socket", () => {
-  const channelCallback = jest.fn(({ socket }) => {
-    expect(isUDPSocket(socket)).toBe(true);
-  });
-
-  udpSocketChannel.subscribe(channelCallback);
-
-  const socket = dgram.createSocket("udp4");
-  socket.close();
-
-  expect(channelCallback).toHaveBeenCalledTimes(1);
-});
-
-//<#END_FILE: test-diagnostics-channel-udp.js
diff --git a/test/js/node/test/parallel/dns-resolve-promises.test.js b/test/js/node/test/parallel/dns-resolve-promises.test.js
deleted file mode 100644
index 737ae7e467..0000000000
--- a/test/js/node/test/parallel/dns-resolve-promises.test.js
+++ /dev/null
@@ -1,25 +0,0 @@
-//#FILE: test-dns-resolve-promises.js
-//#SHA1: ca56d4fe55a765a3e9db340661c96d8b1fd7a7a9
-//-----------------
-"use strict";
-
-const dns = require("dns");
-
-test("DNS resolve promises error handling", async () => {
-  // Mock the dns.promises.resolve function to simulate an error
-  dns.promises.resolve = jest.fn().mockRejectedValue({
-    code: "EPERM",
-    syscall: "queryA",
-    hostname: "example.org",
-  });
-
-  await expect(dns.promises.resolve("example.org")).rejects.toMatchObject({
-    code: "EPERM",
-    syscall: "queryA",
-    hostname: "example.org",
-  });
-
-  expect(dns.promises.resolve).toHaveBeenCalledWith("example.org");
-});
-
-//<#END_FILE: test-dns-resolve-promises.js
diff --git a/test/js/node/test/parallel/domain-crypto.test.js b/test/js/node/test/parallel/domain-crypto.test.js
deleted file mode 100644
index 406da90236..0000000000
--- a/test/js/node/test/parallel/domain-crypto.test.js
+++ /dev/null
@@ -1,87 +0,0 @@
-//#FILE: test-domain-crypto.js
-//#SHA1: d7d6352f0f2684220baef0cfa1029278c3f05f8f
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-const crypto = require("crypto");
-
-// Pollution of global is intentional as part of test.
-// See https://github.com/nodejs/node/commit/d1eff9ab
-global.domain = require("domain");
-
-describe("domain-crypto", () => {
-  beforeAll(() => {
-    if (!crypto) {
-      test.skip("node compiled without OpenSSL.");
-    }
-  });
-
-  test("crypto.randomBytes should not throw", () => {
-    expect(() => crypto.randomBytes(8)).not.toThrow();
-  });
-
-  test("crypto.randomBytes with callback should succeed", () => {
-    return new Promise(resolve => {
-      crypto.randomBytes(8, (err, buffer) => {
-        expect(err).toBeNull();
-        expect(buffer).toBeInstanceOf(Buffer);
-        expect(buffer.length).toBe(8);
-        resolve();
-      });
-    });
-  });
-
-  test("crypto.randomFillSync should not throw", () => {
-    const buf = Buffer.alloc(8);
-    expect(() => crypto.randomFillSync(buf)).not.toThrow();
-  });
-
-  test("crypto.pseudoRandomBytes should not throw", () => {
-    expect(() => crypto.pseudoRandomBytes(8)).not.toThrow();
-  });
-
-  test("crypto.pseudoRandomBytes with callback should succeed", () => {
-    return new Promise(resolve => {
-      crypto.pseudoRandomBytes(8, (err, buffer) => {
-        expect(err).toBeNull();
-        expect(buffer).toBeInstanceOf(Buffer);
-        expect(buffer.length).toBe(8);
-        resolve();
-      });
-    });
-  });
-
-  test("crypto.pbkdf2 should succeed", () => {
-    return new Promise(resolve => {
-      crypto.pbkdf2("password", "salt", 8, 8, "sha1", (err, derivedKey) => {
-        expect(err).toBeNull();
-        expect(derivedKey).toBeInstanceOf(Buffer);
-        expect(derivedKey.length).toBe(8);
-        resolve();
-      });
-    });
-  });
-});
-
-//<#END_FILE: test-domain-crypto.js
diff --git a/test/js/node/test/parallel/domain-dep0097.test.js b/test/js/node/test/parallel/domain-dep0097.test.js
deleted file mode 100644
index 03a74830e1..0000000000
--- a/test/js/node/test/parallel/domain-dep0097.test.js
+++ /dev/null
@@ -1,32 +0,0 @@
-//#FILE: test-domain-dep0097.js
-//#SHA1: d0eeaeed86d045c8deba99d4ca589d35b368f17d
-//-----------------
-"use strict";
-
-// Skip this test if inspector is disabled
-if (typeof inspector === "undefined") {
-  test.skip("Inspector is disabled", () => {});
-} else {
-  const domain = require("domain");
-  const inspector = require("inspector");
-
-  test("DEP0097 warning is emitted", () => {
-    const warningHandler = jest.fn(warning => {
-      expect(warning.code).toBe("DEP0097");
-      expect(warning.message).toMatch(/Triggered by calling emit on process/);
-    });
-
-    process.on("warning", warningHandler);
-
-    domain.create().run(() => {
-      inspector.open(0);
-    });
-
-    expect(warningHandler).toHaveBeenCalledTimes(1);
-
-    // Clean up
-    process.removeListener("warning", warningHandler);
-  });
-}
-
-//<#END_FILE: test-domain-dep0097.js
diff --git a/test/js/node/test/parallel/domain-thrown-error-handler-stack.test.js b/test/js/node/test/parallel/domain-thrown-error-handler-stack.test.js
deleted file mode 100644
index f3c8d0b8b7..0000000000
--- a/test/js/node/test/parallel/domain-thrown-error-handler-stack.test.js
+++ /dev/null
@@ -1,39 +0,0 @@
-//#FILE: test-domain-thrown-error-handler-stack.js
-//#SHA1: fd9aef2a4c852c0d092708bb6e712ad345cd4d2d
-//-----------------
-"use strict";
-
-const domain = require("domain");
-
-// Make sure that when an error is thrown from a nested domain, its error
-// handler runs outside of that domain, but within the context of any parent
-// domain.
-
-test("nested domain error handling", () => {
-  const d = domain.create();
-  const d2 = domain.create();
-
-  d2.on("error", err => {
-    expect(domain._stack.length).toBe(1);
-    expect(process.domain).toBe(d);
-
-    process.nextTick(() => {
-      expect(domain._stack.length).toBe(1);
-      expect(process.domain).toBe(d);
-    });
-  });
-
-  expect(() => {
-    d.run(() => {
-      d2.run(() => {
-        throw new Error("oops");
-      });
-    });
-  }).toThrow(
-    expect.objectContaining({
-      message: expect.any(String),
-    }),
-  );
-});
-
-//<#END_FILE: test-domain-thrown-error-handler-stack.js
diff --git a/test/js/node/test/parallel/domain-vm-promise-isolation.test.js b/test/js/node/test/parallel/domain-vm-promise-isolation.test.js
deleted file mode 100644
index fe9ef2198e..0000000000
--- a/test/js/node/test/parallel/domain-vm-promise-isolation.test.js
+++ /dev/null
@@ -1,35 +0,0 @@
-//#FILE: test-domain-vm-promise-isolation.js
-//#SHA1: 866cac427030e1696a6583c234815beed16bf5c8
-//-----------------
-"use strict";
-
-const domain = require("domain");
-const vm = require("vm");
-
-// A promise created in a VM should not include a domain field but
-// domains should still be able to propagate through them.
-//
-// See; https://github.com/nodejs/node/issues/40999
-
-const context = vm.createContext({});
-
-function run(code) {
-  const d = domain.createDomain();
-  d.run(() => {
-    const p = vm.runInContext(code, context)();
-    expect(p.domain).toBeUndefined();
-    return p.then(() => {
-      expect(process.domain).toBe(d);
-    });
-  });
-}
-
-test("VM promise isolation and domain propagation", async () => {
-  const runPromises = [];
-  for (let i = 0; i < 1000; i++) {
-    runPromises.push(run("async () => null"));
-  }
-  await Promise.all(runPromises);
-}, 30000); // Increased timeout for multiple iterations
-
-//<#END_FILE: test-domain-vm-promise-isolation.js
diff --git a/test/js/node/test/parallel/error-format-list.test.js b/test/js/node/test/parallel/error-format-list.test.js
deleted file mode 100644
index ea5fb2dfc9..0000000000
--- a/test/js/node/test/parallel/error-format-list.test.js
+++ /dev/null
@@ -1,31 +0,0 @@
-//#FILE: test-error-format-list.js
-//#SHA1: ed33f55f6c42ff9671add8288b1d2984393bdfc1
-//-----------------
-"use strict";
-
-if (!Intl) {
-  test.skip("missing Intl", () => {});
-} else {
-  test("formatList function", () => {
-    const and = new Intl.ListFormat("en", { style: "long", type: "conjunction" });
-    const or = new Intl.ListFormat("en", { style: "long", type: "disjunction" });
-
-    const input = ["apple", "banana", "orange", "pear"];
-    for (let i = 0; i < input.length; i++) {
-      const slicedInput = input.slice(0, i);
-      expect(formatList(slicedInput)).toBe(and.format(slicedInput));
-      expect(formatList(slicedInput, "or")).toBe(or.format(slicedInput));
-    }
-  });
-}
-
-// Helper function to replicate the behavior of internal/errors formatList
-function formatList(list, type = "and") {
-  const formatter = new Intl.ListFormat("en", {
-    style: "long",
-    type: type === "and" ? "conjunction" : "disjunction",
-  });
-  return formatter.format(list);
-}
-
-//<#END_FILE: test-error-format-list.js
diff --git a/test/js/node/test/parallel/errors-systemerror-stacktracelimit-deleted-and-error-sealed.test.js b/test/js/node/test/parallel/errors-systemerror-stacktracelimit-deleted-and-error-sealed.test.js
deleted file mode 100644
index f2b27f0e1f..0000000000
--- a/test/js/node/test/parallel/errors-systemerror-stacktracelimit-deleted-and-error-sealed.test.js
+++ /dev/null
@@ -1,36 +0,0 @@
-//#FILE: test-errors-systemerror-stackTraceLimit-deleted-and-Error-sealed.js
-//#SHA1: 5d9d37ff8651fd7b7ffd5e9ae1b54e4ebc900355
-//-----------------
-"use strict";
-
-test("SystemError with deleted stackTraceLimit and sealed Error", () => {
-  delete Error.stackTraceLimit;
-  Object.seal(Error);
-
-  const ctx = {
-    code: "ETEST",
-    message: "code message",
-    syscall: "syscall_test",
-    path: "/str",
-    dest: "/str2",
-  };
-
-  const errorThrowingFunction = () => {
-    const error = new Error("custom message");
-    error.code = "ERR_TEST";
-    error.name = "SystemError";
-    error.info = ctx;
-    throw error;
-  };
-
-  expect(errorThrowingFunction).toThrow(
-    expect.objectContaining({
-      code: "ERR_TEST",
-      name: "SystemError",
-      info: ctx,
-      message: expect.any(String),
-    }),
-  );
-});
-
-//<#END_FILE: test-errors-systemerror-stackTraceLimit-deleted-and-Error-sealed.js
diff --git a/test/js/node/test/parallel/eval.test.js b/test/js/node/test/parallel/eval.test.js
deleted file mode 100644
index 97bc6069a4..0000000000
--- a/test/js/node/test/parallel/eval.test.js
+++ /dev/null
@@ -1,11 +0,0 @@
-//#FILE: test-eval.js
-//#SHA1: 3ea606b33a3ee4b40ef918317b32008e0f5d5e49
-//-----------------
-"use strict";
-
-// Verify that eval is allowed by default.
-test("eval is allowed by default", () => {
-  expect(eval('"eval"')).toBe("eval");
-});
-
-//<#END_FILE: test-eval.js
diff --git a/test/js/node/test/parallel/event-emitter-add-listeners.test.js b/test/js/node/test/parallel/event-emitter-add-listeners.test.js
deleted file mode 100644
index fec7a8fdd2..0000000000
--- a/test/js/node/test/parallel/event-emitter-add-listeners.test.js
+++ /dev/null
@@ -1,91 +0,0 @@
-//#FILE: test-event-emitter-add-listeners.js
-//#SHA1: 25d8611a8cf3694d26e53bb90f760beeb3bb1946
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const EventEmitter = require("events");
-
-test("EventEmitter addListener functionality", () => {
-  const ee = new EventEmitter();
-  const events_new_listener_emitted = [];
-  const listeners_new_listener_emitted = [];
-
-  // Sanity check
-  expect(ee.addListener).toBe(ee.on);
-
-  ee.on("newListener", function (event, listener) {
-    // Don't track newListener listeners.
-    if (event === "newListener") return;
-
-    events_new_listener_emitted.push(event);
-    listeners_new_listener_emitted.push(listener);
-  });
-
-  const hello = jest.fn((a, b) => {
-    expect(a).toBe("a");
-    expect(b).toBe("b");
-  });
-
-  ee.once("newListener", function (name, listener) {
-    expect(name).toBe("hello");
-    expect(listener).toBe(hello);
-    expect(this.listeners("hello")).toEqual([]);
-  });
-
-  ee.on("hello", hello);
-  ee.once("foo", () => {
-    throw new Error("This should not be called");
-  });
-  expect(events_new_listener_emitted).toEqual(["hello", "foo"]);
-  expect(listeners_new_listener_emitted).toEqual([hello, expect.any(Function)]);
-
-  ee.emit("hello", "a", "b");
-  expect(hello).toHaveBeenCalledTimes(1);
-});
-
-test("setMaxListeners with 0 does not throw", () => {
-  const f = new EventEmitter();
-  expect(() => {
-    f.setMaxListeners(0);
-  }).not.toThrow();
-});
-
-test("newListener event and listener order", () => {
-  const listen1 = () => {};
-  const listen2 = () => {};
-  const ee = new EventEmitter();
-
-  ee.once("newListener", function () {
-    expect(ee.listeners("hello")).toEqual([]);
-    ee.once("newListener", function () {
-      expect(ee.listeners("hello")).toEqual([]);
-    });
-    ee.on("hello", listen2);
-  });
-  ee.on("hello", listen1);
-  // The order of listeners on an event is not always the order in which the
-  // listeners were added.
-  expect(ee.listeners("hello")).toEqual([listen2, listen1]);
-});
-
-//<#END_FILE: test-event-emitter-add-listeners.js
diff --git a/test/js/node/test/parallel/event-emitter-check-listener-leaks.test.js b/test/js/node/test/parallel/event-emitter-check-listener-leaks.test.js
deleted file mode 100644
index 49c67758b6..0000000000
--- a/test/js/node/test/parallel/event-emitter-check-listener-leaks.test.js
+++ /dev/null
@@ -1,103 +0,0 @@
-//#FILE: test-event-emitter-check-listener-leaks.js
-//#SHA1: c9d313a0879cc331d8ad1afafe5b9f482597bc7c
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-const events = require("events");
-
-test("default", () => {
-  const e = new events.EventEmitter();
-
-  for (let i = 0; i < 10; i++) {
-    e.on("default", jest.fn());
-  }
-  expect(Object.hasOwn(e._events.default, "warned")).toBe(false);
-  e.on("default", jest.fn());
-  expect(e._events.default.warned).toBe(true);
-
-  // symbol
-  const symbol = Symbol("symbol");
-  e.setMaxListeners(1);
-  e.on(symbol, jest.fn());
-  expect(Object.hasOwn(e._events[symbol], "warned")).toBe(false);
-  e.on(symbol, jest.fn());
-  expect(Object.hasOwn(e._events[symbol], "warned")).toBe(true);
-
-  // specific
-  e.setMaxListeners(5);
-  for (let i = 0; i < 5; i++) {
-    e.on("specific", jest.fn());
-  }
-  expect(Object.hasOwn(e._events.specific, "warned")).toBe(false);
-  e.on("specific", jest.fn());
-  expect(e._events.specific.warned).toBe(true);
-
-  // only one
-  e.setMaxListeners(1);
-  e.on("only one", jest.fn());
-  expect(Object.hasOwn(e._events["only one"], "warned")).toBe(false);
-  e.on("only one", jest.fn());
-  expect(Object.hasOwn(e._events["only one"], "warned")).toBe(true);
-
-  // unlimited
-  e.setMaxListeners(0);
-  for (let i = 0; i < 1000; i++) {
-    e.on("unlimited", jest.fn());
-  }
-  expect(Object.hasOwn(e._events.unlimited, "warned")).toBe(false);
-});
-
-test("process-wide", () => {
-  events.EventEmitter.defaultMaxListeners = 42;
-  const e = new events.EventEmitter();
-
-  for (let i = 0; i < 42; ++i) {
-    e.on("fortytwo", jest.fn());
-  }
-  expect(Object.hasOwn(e._events.fortytwo, "warned")).toBe(false);
-  e.on("fortytwo", jest.fn());
-  expect(Object.hasOwn(e._events.fortytwo, "warned")).toBe(true);
-  delete e._events.fortytwo.warned;
-
-  events.EventEmitter.defaultMaxListeners = 44;
-  e.on("fortytwo", jest.fn());
-  expect(Object.hasOwn(e._events.fortytwo, "warned")).toBe(false);
-  e.on("fortytwo", jest.fn());
-  expect(Object.hasOwn(e._events.fortytwo, "warned")).toBe(true);
-});
-
-test("_maxListeners precedence over defaultMaxListeners", () => {
-  events.EventEmitter.defaultMaxListeners = 42;
-  const e = new events.EventEmitter();
-  e.setMaxListeners(1);
-  e.on("uno", jest.fn());
-  expect(Object.hasOwn(e._events.uno, "warned")).toBe(false);
-  e.on("uno", jest.fn());
-  expect(Object.hasOwn(e._events.uno, "warned")).toBe(true);
-
-  // chainable
-  expect(e.setMaxListeners(1)).toBe(e);
-});
-
-//<#END_FILE: test-event-emitter-check-listener-leaks.js
diff --git a/test/js/node/test/parallel/event-emitter-emit-context.test.js b/test/js/node/test/parallel/event-emitter-emit-context.test.js
deleted file mode 100644
index b39c26258e..0000000000
--- a/test/js/node/test/parallel/event-emitter-emit-context.test.js
+++ /dev/null
@@ -1,25 +0,0 @@
-//#FILE: test-event-emitter-emit-context.js
-//#SHA1: 66f963c1a1351deff53d036d86f821c5e932c832
-//-----------------
-"use strict";
-const EventEmitter = require("events");
-
-// Test emit called by other context
-const EE = new EventEmitter();
-
-// Works as expected if the context has no `constructor.name`
-test("emit called with context having no constructor.name", () => {
-  const ctx = { __proto__: null };
-  expect(() => EE.emit.call(ctx, "error", new Error("foo"))).toThrow(
-    expect.objectContaining({
-      name: "Error",
-      message: expect.any(String),
-    }),
-  );
-});
-
-test("emit called with empty object context", () => {
-  expect(EE.emit.call({}, "foo")).toBe(false);
-});
-
-//<#END_FILE: test-event-emitter-emit-context.js
diff --git a/test/js/node/test/parallel/event-emitter-get-max-listeners.test.js b/test/js/node/test/parallel/event-emitter-get-max-listeners.test.js
deleted file mode 100644
index 612a3f1323..0000000000
--- a/test/js/node/test/parallel/event-emitter-get-max-listeners.test.js
+++ /dev/null
@@ -1,29 +0,0 @@
-//#FILE: test-event-emitter-get-max-listeners.js
-//#SHA1: ff5c2f7b9525ae4137ea8eddd742572bd399c5ce
-//-----------------
-"use strict";
-
-const EventEmitter = require("events");
-
-test("EventEmitter getMaxListeners", () => {
-  const emitter = new EventEmitter();
-
-  expect(emitter.getMaxListeners()).toBe(EventEmitter.defaultMaxListeners);
-
-  emitter.setMaxListeners(0);
-  expect(emitter.getMaxListeners()).toBe(0);
-
-  emitter.setMaxListeners(3);
-  expect(emitter.getMaxListeners()).toBe(3);
-});
-
-// https://github.com/nodejs/node/issues/523 - second call should not throw.
-test("EventEmitter.prototype.on should not throw on second call", () => {
-  const recv = {};
-  expect(() => {
-    EventEmitter.prototype.on.call(recv, "event", () => {});
-    EventEmitter.prototype.on.call(recv, "event", () => {});
-  }).not.toThrow();
-});
-
-//<#END_FILE: test-event-emitter-get-max-listeners.js
diff --git a/test/js/node/test/parallel/event-emitter-listener-count.test.js b/test/js/node/test/parallel/event-emitter-listener-count.test.js
deleted file mode 100644
index b9772949ad..0000000000
--- a/test/js/node/test/parallel/event-emitter-listener-count.test.js
+++ /dev/null
@@ -1,32 +0,0 @@
-//#FILE: test-event-emitter-listener-count.js
-//#SHA1: 0f4b7f14fe432472b51524b3853db6d8615614f1
-//-----------------
-"use strict";
-
-const EventEmitter = require("events");
-
-describe("EventEmitter.listenerCount and emitter.listenerCount", () => {
-  let emitter;
-
-  beforeEach(() => {
-    emitter = new EventEmitter();
-    emitter.on("foo", () => {});
-    emitter.on("foo", () => {});
-    emitter.on("baz", () => {});
-    // Allow any type
-    emitter.on(123, () => {});
-  });
-
-  test("EventEmitter.listenerCount returns correct count", () => {
-    expect(EventEmitter.listenerCount(emitter, "foo")).toBe(2);
-  });
-
-  test("emitter.listenerCount returns correct counts for various events", () => {
-    expect(emitter.listenerCount("foo")).toBe(2);
-    expect(emitter.listenerCount("bar")).toBe(0);
-    expect(emitter.listenerCount("baz")).toBe(1);
-    expect(emitter.listenerCount(123)).toBe(1);
-  });
-});
-
-//<#END_FILE: test-event-emitter-listener-count.js
diff --git a/test/js/node/test/parallel/event-emitter-modify-in-emit.test.js b/test/js/node/test/parallel/event-emitter-modify-in-emit.test.js
deleted file mode 100644
index 422054923c..0000000000
--- a/test/js/node/test/parallel/event-emitter-modify-in-emit.test.js
+++ /dev/null
@@ -1,89 +0,0 @@
-//#FILE: test-event-emitter-modify-in-emit.js
-//#SHA1: 6d378f9c7700ce7946f7d59bbc32b7cb82efc836
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const events = require("events");
-
-describe("EventEmitter modify in emit", () => {
-  let callbacks_called;
-  let e;
-
-  function callback1() {
-    callbacks_called.push("callback1");
-    e.on("foo", callback2);
-    e.on("foo", callback3);
-    e.removeListener("foo", callback1);
-  }
-
-  function callback2() {
-    callbacks_called.push("callback2");
-    e.removeListener("foo", callback2);
-  }
-
-  function callback3() {
-    callbacks_called.push("callback3");
-    e.removeListener("foo", callback3);
-  }
-
-  beforeEach(() => {
-    callbacks_called = [];
-    e = new events.EventEmitter();
-  });
-
-  test("listeners are modified during emit", () => {
-    e.on("foo", callback1);
-    expect(e.listeners("foo").length).toBe(1);
-
-    e.emit("foo");
-    expect(e.listeners("foo").length).toBe(2);
-    expect(callbacks_called).toEqual(["callback1"]);
-
-    e.emit("foo");
-    expect(e.listeners("foo").length).toBe(0);
-    expect(callbacks_called).toEqual(["callback1", "callback2", "callback3"]);
-
-    e.emit("foo");
-    expect(e.listeners("foo").length).toBe(0);
-    expect(callbacks_called).toEqual(["callback1", "callback2", "callback3"]);
-  });
-
-  test("removeAllListeners removes all listeners", () => {
-    e.on("foo", callback1);
-    e.on("foo", callback2);
-    expect(e.listeners("foo").length).toBe(2);
-    e.removeAllListeners("foo");
-    expect(e.listeners("foo").length).toBe(0);
-  });
-
-  test("removing callbacks during emit allows emits to propagate to all listeners", () => {
-    e.on("foo", callback2);
-    e.on("foo", callback3);
-    expect(e.listeners("foo").length).toBe(2);
-    e.emit("foo");
-    expect(callbacks_called).toEqual(["callback2", "callback3"]);
-    expect(e.listeners("foo").length).toBe(0);
-  });
-});
-
-//<#END_FILE: test-event-emitter-modify-in-emit.js
diff --git a/test/js/node/test/parallel/event-emitter-num-args.test.js b/test/js/node/test/parallel/event-emitter-num-args.test.js
deleted file mode 100644
index e295eb022c..0000000000
--- a/test/js/node/test/parallel/event-emitter-num-args.test.js
+++ /dev/null
@@ -1,64 +0,0 @@
-//#FILE: test-event-emitter-num-args.js
-//#SHA1: b17b5bfd071180f4c53c8c408dc14ec860fd4225
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const events = require("events");
-
-describe("EventEmitter number of arguments", () => {
-  let e;
-  let num_args_emitted;
-
-  beforeEach(() => {
-    e = new events.EventEmitter();
-    num_args_emitted = [];
-
-    e.on("numArgs", function () {
-      const numArgs = arguments.length;
-      num_args_emitted.push(numArgs);
-    });
-
-    e.on("foo", function () {
-      num_args_emitted.push(arguments.length);
-    });
-
-    e.on("foo", function () {
-      num_args_emitted.push(arguments.length);
-    });
-  });
-
-  it("should emit correct number of arguments", () => {
-    e.emit("numArgs");
-    e.emit("numArgs", null);
-    e.emit("numArgs", null, null);
-    e.emit("numArgs", null, null, null);
-    e.emit("numArgs", null, null, null, null);
-    e.emit("numArgs", null, null, null, null, null);
-
-    e.emit("foo", null, null, null, null);
-
-    expect(num_args_emitted).toEqual([0, 1, 2, 3, 4, 5, 4, 4]);
-  });
-});
-
-//<#END_FILE: test-event-emitter-num-args.js
diff --git a/test/js/node/test/parallel/event-emitter-prepend.test.js b/test/js/node/test/parallel/event-emitter-prepend.test.js
deleted file mode 100644
index f8f7d47b8c..0000000000
--- a/test/js/node/test/parallel/event-emitter-prepend.test.js
+++ /dev/null
@@ -1,62 +0,0 @@
-//#FILE: test-event-emitter-prepend.js
-//#SHA1: 9a753f44fc304ff6584a31c20e95037e622579d7
-//-----------------
-"use strict";
-
-const EventEmitter = require("events");
-const stream = require("stream");
-
-describe("EventEmitter prepend", () => {
-  test("prepend listeners in correct order", () => {
-    const myEE = new EventEmitter();
-    let m = 0;
-
-    // This one comes last.
-    myEE.on("foo", () => {
-      expect(m).toBe(2);
-    });
-
-    // This one comes second.
-    myEE.prependListener("foo", () => {
-      expect(m).toBe(1);
-      m++;
-    });
-
-    // This one comes first.
-    myEE.prependOnceListener("foo", () => {
-      expect(m).toBe(0);
-      m++;
-    });
-
-    myEE.emit("foo");
-    expect.assertions(3);
-  });
-
-  test("fallback if prependListener is undefined", () => {
-    // Test fallback if prependListener is undefined.
-    delete EventEmitter.prototype.prependListener;
-
-    function Writable() {
-      this.writable = true;
-      stream.Stream.call(this);
-    }
-    Object.setPrototypeOf(Writable.prototype, stream.Stream.prototype);
-    Object.setPrototypeOf(Writable, stream.Stream);
-
-    function Readable() {
-      this.readable = true;
-      stream.Stream.call(this);
-    }
-    Object.setPrototypeOf(Readable.prototype, stream.Stream.prototype);
-    Object.setPrototypeOf(Readable, stream.Stream);
-
-    const w = new Writable();
-    const r = new Readable();
-    r.pipe(w);
-
-    // If we reach this point without throwing, the test passes
-    expect(true).toBe(true);
-  });
-});
-
-//<#END_FILE: test-event-emitter-prepend.js
diff --git a/test/js/node/test/parallel/event-emitter-set-max-listeners-side-effects.test.js b/test/js/node/test/parallel/event-emitter-set-max-listeners-side-effects.test.js
deleted file mode 100644
index 101ccfa80b..0000000000
--- a/test/js/node/test/parallel/event-emitter-set-max-listeners-side-effects.test.js
+++ /dev/null
@@ -1,37 +0,0 @@
-//#FILE: test-event-emitter-set-max-listeners-side-effects.js
-//#SHA1: 319371e261c5cc46348475cdd789eb9ee56839d8
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const events = require("events");
-
-test("EventEmitter setMaxListeners should not have side effects", () => {
-  const e = new events.EventEmitter();
-
-  expect(e._events).not.toBeInstanceOf(Object);
-  expect(Object.keys(e._events)).toEqual([]);
-  e.setMaxListeners(5);
-  expect(Object.keys(e._events)).toEqual([]);
-});
-
-//<#END_FILE: test-event-emitter-set-max-listeners-side-effects.js
diff --git a/test/js/node/test/parallel/event-emitter-special-event-names.test.js b/test/js/node/test/parallel/event-emitter-special-event-names.test.js
deleted file mode 100644
index 60d8071a33..0000000000
--- a/test/js/node/test/parallel/event-emitter-special-event-names.test.js
+++ /dev/null
@@ -1,53 +0,0 @@
-//#FILE: test-event-emitter-special-event-names.js
-//#SHA1: 3ae93e3a9f5cd01560264a5c297a2fae25c5c18f
-//-----------------
-"use strict";
-
-const EventEmitter = require("events");
-
-describe("EventEmitter with special event names", () => {
-  let ee;
-
-  beforeEach(() => {
-    ee = new EventEmitter();
-  });
-
-  test("initial eventNames() is empty", () => {
-    expect(ee.eventNames()).toEqual([]);
-  });
-
-  test("_events does not have hasOwnProperty or toString", () => {
-    expect(ee._events.hasOwnProperty).toBeUndefined();
-    expect(ee._events.toString).toBeUndefined();
-  });
-
-  test("can add and list special event names", () => {
-    const handler = jest.fn();
-
-    ee.on("__proto__", handler);
-    ee.on("__defineGetter__", handler);
-    ee.on("toString", handler);
-
-    expect(ee.eventNames()).toEqual(["__proto__", "__defineGetter__", "toString"]);
-
-    expect(ee.listeners("__proto__")).toEqual([handler]);
-    expect(ee.listeners("__defineGetter__")).toEqual([handler]);
-    expect(ee.listeners("toString")).toEqual([handler]);
-  });
-
-  test("can emit __proto__ event", () => {
-    const handler = jest.fn();
-    ee.on("__proto__", handler);
-    ee.emit("__proto__", 1);
-    expect(handler).toHaveBeenCalledWith(1);
-  });
-
-  test("process can emit __proto__ event", () => {
-    const handler = jest.fn();
-    process.on("__proto__", handler);
-    process.emit("__proto__", 1);
-    expect(handler).toHaveBeenCalledWith(1);
-  });
-});
-
-//<#END_FILE: test-event-emitter-special-event-names.js
diff --git a/test/js/node/test/parallel/event-emitter-subclass.test.js b/test/js/node/test/parallel/event-emitter-subclass.test.js
deleted file mode 100644
index a48d9e8fdd..0000000000
--- a/test/js/node/test/parallel/event-emitter-subclass.test.js
+++ /dev/null
@@ -1,81 +0,0 @@
-//#FILE: test-event-emitter-subclass.js
-//#SHA1: e7f7e379fcf89318168b9e5d9f38c4af371ada8e
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const EventEmitter = require("events").EventEmitter;
-
-Object.setPrototypeOf(MyEE.prototype, EventEmitter.prototype);
-Object.setPrototypeOf(MyEE, EventEmitter);
-
-function MyEE(cb) {
-  this.once(1, cb);
-  this.emit(1);
-  this.removeAllListeners();
-  EventEmitter.call(this);
-}
-
-test("MyEE callback is called", () => {
-  const callback = jest.fn();
-  const myee = new MyEE(callback);
-  expect(callback).toHaveBeenCalledTimes(1);
-});
-
-Object.setPrototypeOf(ErrorEE.prototype, EventEmitter.prototype);
-Object.setPrototypeOf(ErrorEE, EventEmitter);
-function ErrorEE() {
-  this.emit("error", new Error("blerg"));
-}
-
-test("ErrorEE throws error", () => {
-  expect(() => {
-    new ErrorEE();
-  }).toThrow(
-    expect.objectContaining({
-      message: expect.any(String),
-    }),
-  );
-});
-
-test("MyEE _events is empty after removeAllListeners", () => {
-  const myee = new MyEE(() => {});
-  expect(myee._events).not.toBeInstanceOf(Object);
-  expect(Object.keys(myee._events)).toEqual([]);
-});
-
-function MyEE2() {
-  EventEmitter.call(this);
-}
-
-MyEE2.prototype = new EventEmitter();
-
-test("MyEE2 instances do not share listeners", () => {
-  const ee1 = new MyEE2();
-  const ee2 = new MyEE2();
-
-  ee1.on("x", () => {});
-
-  expect(ee2.listenerCount("x")).toBe(0);
-});
-
-//<#END_FILE: test-event-emitter-subclass.js
diff --git a/test/js/node/test/parallel/event-emitter-symbols.test.js b/test/js/node/test/parallel/event-emitter-symbols.test.js
deleted file mode 100644
index bfb0e2b774..0000000000
--- a/test/js/node/test/parallel/event-emitter-symbols.test.js
+++ /dev/null
@@ -1,29 +0,0 @@
-//#FILE: test-event-emitter-symbols.js
-//#SHA1: c3fa4a8db31f2a88317d3c60fb52aa2921eaa20d
-//-----------------
-"use strict";
-
-const EventEmitter = require("events");
-
-test("EventEmitter with Symbol events", () => {
-  const ee = new EventEmitter();
-  const foo = Symbol("foo");
-  const listener = jest.fn();
-
-  ee.on(foo, listener);
-  expect(ee.listeners(foo)).toEqual([listener]);
-
-  ee.emit(foo);
-  expect(listener).toHaveBeenCalledTimes(1);
-
-  ee.removeAllListeners();
-  expect(ee.listeners(foo)).toEqual([]);
-
-  ee.on(foo, listener);
-  expect(ee.listeners(foo)).toEqual([listener]);
-
-  ee.removeListener(foo, listener);
-  expect(ee.listeners(foo)).toEqual([]);
-});
-
-//<#END_FILE: test-event-emitter-symbols.js
diff --git a/test/js/node/test/parallel/event-target.test.js b/test/js/node/test/parallel/event-target.test.js
deleted file mode 100644
index 0b5fc40712..0000000000
--- a/test/js/node/test/parallel/event-target.test.js
+++ /dev/null
@@ -1,25 +0,0 @@
-//#FILE: test-event-target.js
-//#SHA1: 3e70912640aa5270e13723e1895636bfd238420a
-//-----------------
-"use strict";
-
-const eventPhases = {
-  NONE: 0,
-  CAPTURING_PHASE: 1,
-  AT_TARGET: 2,
-  BUBBLING_PHASE: 3,
-};
-
-describe("Event phases", () => {
-  test.each(Object.entries(eventPhases))("Event.%s should be %d", (prop, value) => {
-    // Check if the value of the property matches the expected value
-    expect(Event[prop]).toBe(value);
-
-    const desc = Object.getOwnPropertyDescriptor(Event, prop);
-    expect(desc.writable).toBe(false);
-    expect(desc.configurable).toBe(false);
-    expect(desc.enumerable).toBe(true);
-  });
-});
-
-//<#END_FILE: test-event-target.js
diff --git a/test/js/node/test/parallel/events-list.test.js b/test/js/node/test/parallel/events-list.test.js
deleted file mode 100644
index bde2b1a0e6..0000000000
--- a/test/js/node/test/parallel/events-list.test.js
+++ /dev/null
@@ -1,29 +0,0 @@
-//#FILE: test-events-list.js
-//#SHA1: 946973d6c9e19c6410b4486cbef3e2ed032715fc
-//-----------------
-"use strict";
-
-const EventEmitter = require("events");
-
-test("EventEmitter.eventNames()", () => {
-  const EE = new EventEmitter();
-  const m = () => {};
-
-  EE.on("foo", () => {});
-  expect(EE.eventNames()).toEqual(["foo"]);
-
-  EE.on("bar", m);
-  expect(EE.eventNames()).toEqual(["foo", "bar"]);
-
-  EE.removeListener("bar", m);
-  expect(EE.eventNames()).toEqual(["foo"]);
-
-  const s = Symbol("s");
-  EE.on(s, m);
-  expect(EE.eventNames()).toEqual(["foo", s]);
-
-  EE.removeListener(s, m);
-  expect(EE.eventNames()).toEqual(["foo"]);
-});
-
-//<#END_FILE: test-events-list.js
diff --git a/test/js/node/test/parallel/eventsource-disabled.test.js b/test/js/node/test/parallel/eventsource-disabled.test.js
deleted file mode 100644
index 0b7c76c1e2..0000000000
--- a/test/js/node/test/parallel/eventsource-disabled.test.js
+++ /dev/null
@@ -1,10 +0,0 @@
-//#FILE: test-eventsource-disabled.js
-//#SHA1: ebb7581b56a8dd86c5385eba1befa9ef984a8065
-//-----------------
-"use strict";
-
-test("EventSource is undefined", () => {
-  expect(typeof EventSource).toBe("undefined");
-});
-
-//<#END_FILE: test-eventsource-disabled.js
diff --git a/test/js/node/test/parallel/eventtarget-once-twice.test.js b/test/js/node/test/parallel/eventtarget-once-twice.test.js
deleted file mode 100644
index 74f19e01b0..0000000000
--- a/test/js/node/test/parallel/eventtarget-once-twice.test.js
+++ /dev/null
@@ -1,24 +0,0 @@
-//#FILE: test-eventtarget-once-twice.js
-//#SHA1: dd2fea0f3c839d77c64423ed3c2cbdd319365141
-//-----------------
-"use strict";
-
-const { once } = require("events");
-
-test("once can be called twice on EventTarget", async () => {
-  const et = new EventTarget();
-
-  const promise = (async () => {
-    await once(et, "foo");
-    await once(et, "foo");
-  })();
-
-  et.dispatchEvent(new Event("foo"));
-  setImmediate(() => {
-    et.dispatchEvent(new Event("foo"));
-  });
-
-  await expect(promise).resolves.toBeUndefined();
-});
-
-//<#END_FILE: test-eventtarget-once-twice.js
diff --git a/test/js/node/test/parallel/fetch-mock.test.js b/test/js/node/test/parallel/fetch-mock.test.js
deleted file mode 100644
index 84bce7c9a7..0000000000
--- a/test/js/node/test/parallel/fetch-mock.test.js
+++ /dev/null
@@ -1,26 +0,0 @@
-//#FILE: test-fetch-mock.js
-//#SHA1: 92268be36b00e63e18a837088b9718344c3bff4f
-//-----------------
-"use strict";
-
-test("should correctly stub globalThis.fetch", async () => {
-  const customFetch = async url => {
-    return {
-      text: async () => "foo",
-    };
-  };
-
-  const originalFetch = globalThis.fetch;
-  globalThis.fetch = jest.fn(customFetch);
-
-  const response = await globalThis.fetch("some-url");
-  const text = await response.text();
-
-  expect(text).toBe("foo");
-  expect(globalThis.fetch).toHaveBeenCalledWith("some-url");
-
-  // Restore the original fetch
-  globalThis.fetch = originalFetch;
-});
-
-//<#END_FILE: test-fetch-mock.js
diff --git a/test/js/node/test/parallel/file-read-noexist.test.js b/test/js/node/test/parallel/file-read-noexist.test.js
deleted file mode 100644
index 199afac796..0000000000
--- a/test/js/node/test/parallel/file-read-noexist.test.js
+++ /dev/null
@@ -1,45 +0,0 @@
-//#FILE: test-file-read-noexist.js
-//#SHA1: c4cbb5dc6abca53c1dd513a4ece2741c1fc2235a
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const fs = require("fs");
-const path = require("path");
-
-const filename = path.join(__dirname, "fixtures", "does_not_exist.txt");
-
-test("fs.readFile with non-existent file", async () => {
-  await expect(
-    new Promise((resolve, reject) => {
-      fs.readFile(filename, "latin1", (err, content) => {
-        if (err) reject(err);
-        else resolve(content);
-      });
-    }),
-  ).rejects.toMatchObject({
-    code: "ENOENT",
-    message: expect.any(String),
-  });
-});
-
-//<#END_FILE: test-file-read-noexist.js
diff --git a/test/js/node/test/parallel/finalization-registry-shutdown.test.js b/test/js/node/test/parallel/finalization-registry-shutdown.test.js
deleted file mode 100644
index 9dfd3c99c2..0000000000
--- a/test/js/node/test/parallel/finalization-registry-shutdown.test.js
+++ /dev/null
@@ -1,40 +0,0 @@
-//#FILE: test-finalization-registry-shutdown.js
-//#SHA1: c5da440f8ea977c501bb5920f55ce69b1da6e28d
-//-----------------
-// Flags: --expose-gc
-"use strict";
-
-// This test verifies that when a V8 FinalizationRegistryCleanupTask is queue
-// at the last moment when JavaScript can be executed, the callback of a
-// FinalizationRegistry will not be invoked and the process should exit
-// normally.
-
-test("FinalizationRegistry callback should not be called during shutdown", () => {
-  const mockCallback = jest.fn();
-  const reg = new FinalizationRegistry(mockCallback);
-
-  function register() {
-    // Create a temporary object in a new function scope to allow it to be GC-ed.
-    reg.register({});
-  }
-
-  const exitHandler = () => {
-    // This is the final chance to execute JavaScript.
-    register();
-    // Queue a FinalizationRegistryCleanupTask by a testing gc request.
-    global.gc();
-  };
-
-  process.on("exit", exitHandler);
-
-  // Simulate the exit process
-  exitHandler();
-
-  // Verify that the callback was not called
-  expect(mockCallback).not.toHaveBeenCalled();
-
-  // Clean up
-  process.removeListener("exit", exitHandler);
-});
-
-//<#END_FILE: test-finalization-registry-shutdown.js
diff --git a/test/js/node/test/parallel/fixed-queue.test.js b/test/js/node/test/parallel/fixed-queue.test.js
deleted file mode 100644
index cfc2884be4..0000000000
--- a/test/js/node/test/parallel/fixed-queue.test.js
+++ /dev/null
@@ -1,58 +0,0 @@
-//#FILE: test-fixed-queue.js
-//#SHA1: cae83f6c0ca385bf63085e571f070bb6acc5a79a
-//-----------------
-"use strict";
-
-// Note: This test originally relied on internals, which is not recommended.
-// We'll implement a simplified FixedQueue for testing purposes.
-
-class FixedQueue {
-  constructor() {
-    this.items = [];
-    this.capacity = 2047;
-  }
-
-  push(item) {
-    this.items.push(item);
-  }
-
-  shift() {
-    return this.items.shift() || null;
-  }
-
-  isEmpty() {
-    return this.items.length === 0;
-  }
-
-  isFull() {
-    return this.items.length === this.capacity;
-  }
-}
-
-test("FixedQueue basic operations", () => {
-  const queue = new FixedQueue();
-  expect(queue.isEmpty()).toBe(true);
-  queue.push("a");
-  expect(queue.isEmpty()).toBe(false);
-  expect(queue.shift()).toBe("a");
-  expect(queue.shift()).toBe(null);
-});
-
-test("FixedQueue capacity and multiple operations", () => {
-  const queue = new FixedQueue();
-  for (let i = 0; i < 2047; i++) {
-    queue.push("a");
-  }
-  expect(queue.isFull()).toBe(true);
-  queue.push("a");
-  expect(queue.isFull()).toBe(false);
-
-  for (let i = 0; i < 2047; i++) {
-    expect(queue.shift()).toBe("a");
-  }
-  expect(queue.isEmpty()).toBe(false);
-  expect(queue.shift()).toBe("a");
-  expect(queue.isEmpty()).toBe(true);
-});
-
-//<#END_FILE: test-fixed-queue.js
diff --git a/test/js/node/test/parallel/fs-chown-type-check.test.js b/test/js/node/test/parallel/fs-chown-type-check.test.js
deleted file mode 100644
index 4a899dd46e..0000000000
--- a/test/js/node/test/parallel/fs-chown-type-check.test.js
+++ /dev/null
@@ -1,60 +0,0 @@
-//#FILE: test-fs-chown-type-check.js
-//#SHA1: 6ecbd3ae2da32793768e64e9252d749ddf36c85a
-//-----------------
-"use strict";
-
-const fs = require("fs");
-
-describe("fs.chown and fs.chownSync type checks", () => {
-  test("invalid path argument", () => {
-    [false, 1, {}, [], null, undefined].forEach(invalidPath => {
-      expect(() => fs.chown(invalidPath, 1, 1, jest.fn())).toThrow(
-        expect.objectContaining({
-          code: "ERR_INVALID_ARG_TYPE",
-          name: "TypeError",
-        }),
-      );
-
-      expect(() => fs.chownSync(invalidPath, 1, 1)).toThrow(
-        expect.objectContaining({
-          code: "ERR_INVALID_ARG_TYPE",
-          name: "TypeError",
-        }),
-      );
-    });
-  });
-
-  test("invalid uid or gid arguments", () => {
-    [false, "test", {}, [], null, undefined].forEach(invalidId => {
-      expect(() => fs.chown("not_a_file_that_exists", invalidId, 1, jest.fn())).toThrow(
-        expect.objectContaining({
-          code: "ERR_INVALID_ARG_TYPE",
-          name: "TypeError",
-        }),
-      );
-
-      expect(() => fs.chown("not_a_file_that_exists", 1, invalidId, jest.fn())).toThrow(
-        expect.objectContaining({
-          code: "ERR_INVALID_ARG_TYPE",
-          name: "TypeError",
-        }),
-      );
-
-      expect(() => fs.chownSync("not_a_file_that_exists", invalidId, 1)).toThrow(
-        expect.objectContaining({
-          code: "ERR_INVALID_ARG_TYPE",
-          name: "TypeError",
-        }),
-      );
-
-      expect(() => fs.chownSync("not_a_file_that_exists", 1, invalidId)).toThrow(
-        expect.objectContaining({
-          code: "ERR_INVALID_ARG_TYPE",
-          name: "TypeError",
-        }),
-      );
-    });
-  });
-});
-
-//<#END_FILE: test-fs-chown-type-check.js
diff --git a/test/js/node/test/parallel/fs-constants.test.js b/test/js/node/test/parallel/fs-constants.test.js
deleted file mode 100644
index 0d1332c1bb..0000000000
--- a/test/js/node/test/parallel/fs-constants.test.js
+++ /dev/null
@@ -1,13 +0,0 @@
-//#FILE: test-fs-constants.js
-//#SHA1: 6113ac0dd5e6b3d59252a25e6ddae61b589ca362
-//-----------------
-"use strict";
-
-const fs = require("fs");
-
-test("fs constants for Windows chmod() are defined", () => {
-  expect(fs.constants.S_IRUSR).toBeDefined();
-  expect(fs.constants.S_IWUSR).toBeDefined();
-});
-
-//<#END_FILE: test-fs-constants.js
diff --git a/test/js/node/test/parallel/fs-exists.test.js b/test/js/node/test/parallel/fs-exists.test.js
deleted file mode 100644
index 3cea91fc1c..0000000000
--- a/test/js/node/test/parallel/fs-exists.test.js
+++ /dev/null
@@ -1,74 +0,0 @@
-//#FILE: test-fs-exists.js
-//#SHA1: b7dcbc226b81e0ae4a111cbab39b87672a02172c
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const fs = require("fs");
-const f = __filename;
-
-test("fs.exists throws with invalid arguments", () => {
-  expect(() => fs.exists(f)).toThrow(expect.objectContaining({ code: "ERR_INVALID_ARG_TYPE" }));
-  expect(() => fs.exists()).toThrow(expect.objectContaining({ code: "ERR_INVALID_ARG_TYPE" }));
-  expect(() => fs.exists(f, {})).toThrow(expect.objectContaining({ code: "ERR_INVALID_ARG_TYPE" }));
-});
-
-test("fs.exists with valid file", done => {
-  fs.exists(f, y => {
-    expect(y).toBe(true);
-    done();
-  });
-});
-
-test("fs.exists with non-existent file", done => {
-  fs.exists(`${f}-NO`, y => {
-    expect(y).toBe(false);
-    done();
-  });
-});
-
-test("fs.exists with invalid path", done => {
-  fs.exists(new URL("https://foo"), y => {
-    expect(y).toBe(false);
-    done();
-  });
-});
-
-test("fs.exists with object as path", done => {
-  fs.exists({}, y => {
-    expect(y).toBe(false);
-    done();
-  });
-});
-
-test("fs.existsSync", () => {
-  expect(fs.existsSync(f)).toBe(true);
-  expect(fs.existsSync(`${f}-NO`)).toBe(false);
-});
-
-test("fs.existsSync never throws", () => {
-  expect(fs.existsSync()).toBe(false);
-  expect(fs.existsSync({})).toBe(false);
-  expect(fs.existsSync(new URL("https://foo"))).toBe(false);
-});
-
-//<#END_FILE: test-fs-exists.js
diff --git a/test/js/node/test/parallel/fs-link.test.js b/test/js/node/test/parallel/fs-link.test.js
deleted file mode 100644
index 4b6be724f2..0000000000
--- a/test/js/node/test/parallel/fs-link.test.js
+++ /dev/null
@@ -1,65 +0,0 @@
-//#FILE: test-fs-link.js
-//#SHA1: 255940f3f953a4bd693b3e475bc466d5f759875f
-//-----------------
-"use strict";
-const fs = require("fs");
-const path = require("path");
-const os = require("os");
-
-const tmpdir = {
-  refresh: () => {
-    // Implement a simple tmpdir.refresh() function
-    const testDir = path.join(os.tmpdir(), "test-fs-link");
-    fs.rmSync(testDir, { recursive: true, force: true });
-    fs.mkdirSync(testDir, { recursive: true });
-    return testDir;
-  },
-  resolve: filename => path.join(tmpdir.refresh(), filename),
-};
-
-test("Test creating and reading hard link", done => {
-  const srcPath = tmpdir.resolve("hardlink-target.txt");
-  const dstPath = tmpdir.resolve("link1.js");
-  fs.writeFileSync(srcPath, "hello world");
-
-  fs.link(srcPath, dstPath, err => {
-    expect(err).toBeFalsy();
-    const dstContent = fs.readFileSync(dstPath, "utf8");
-    expect(dstContent).toBe("hello world");
-    done();
-  });
-});
-
-test("test error outputs", () => {
-  [false, 1, [], {}, null, undefined].forEach(i => {
-    expect(() => fs.link(i, "", () => {})).toThrow(
-      expect.objectContaining({
-        code: "ERR_INVALID_ARG_TYPE",
-        name: "TypeError",
-      }),
-    );
-
-    expect(() => fs.link("", i, () => {})).toThrow(
-      expect.objectContaining({
-        code: "ERR_INVALID_ARG_TYPE",
-        name: "TypeError",
-      }),
-    );
-
-    expect(() => fs.linkSync(i, "")).toThrow(
-      expect.objectContaining({
-        code: "ERR_INVALID_ARG_TYPE",
-        name: "TypeError",
-      }),
-    );
-
-    expect(() => fs.linkSync("", i)).toThrow(
-      expect.objectContaining({
-        code: "ERR_INVALID_ARG_TYPE",
-        name: "TypeError",
-      }),
-    );
-  });
-});
-
-//<#END_FILE: test-fs-link.js
diff --git a/test/js/node/test/parallel/fs-make-callback.test.js b/test/js/node/test/parallel/fs-make-callback.test.js
deleted file mode 100644
index db3860cbd6..0000000000
--- a/test/js/node/test/parallel/fs-make-callback.test.js
+++ /dev/null
@@ -1,37 +0,0 @@
-//#FILE: test-fs-make-callback.js
-//#SHA1: 40bbb673a0865f464a2b9e40110e903b6cc9e0d6
-//-----------------
-"use strict";
-
-const fs = require("fs");
-const { sep } = require("path");
-const tmpdir = require("../common/tmpdir");
-
-const callbackThrowValues = [null, true, false, 0, 1, "foo", /foo/, [], {}];
-
-beforeEach(() => {
-  tmpdir.refresh();
-});
-
-function testMakeCallback(cb) {
-  return function () {
-    // fs.mkdtemp() calls makeCallback() on its third argument
-    return fs.mkdtemp(`${tmpdir.path}${sep}`, {}, cb);
-  };
-}
-
-describe("fs.makeCallback", () => {
-  test("invalid callbacks throw TypeError", () => {
-    callbackThrowValues.forEach(value => {
-      expect(testMakeCallback(value)).toThrow(
-        expect.objectContaining({
-          code: "ERR_INVALID_ARG_TYPE",
-          name: "TypeError",
-          message: expect.any(String),
-        }),
-      );
-    });
-  });
-});
-
-//<#END_FILE: test-fs-make-callback.js
diff --git a/test/js/node/test/parallel/fs-mkdtemp-prefix-check.test.js b/test/js/node/test/parallel/fs-mkdtemp-prefix-check.test.js
deleted file mode 100644
index 81690d9c17..0000000000
--- a/test/js/node/test/parallel/fs-mkdtemp-prefix-check.test.js
+++ /dev/null
@@ -1,37 +0,0 @@
-//#FILE: test-fs-mkdtemp-prefix-check.js
-//#SHA1: f17d58f63200ae9b8c855b9def7da223fc5db531
-//-----------------
-"use strict";
-const fs = require("fs");
-
-const prefixValues = [undefined, null, 0, true, false, 1];
-
-describe("fs.mkdtempSync prefix check", () => {
-  test.each(prefixValues)("should throw for invalid prefix: %p", value => {
-    expect(() => {
-      fs.mkdtempSync(value, {});
-    }).toThrow(
-      expect.objectContaining({
-        code: "ERR_INVALID_ARG_TYPE",
-        name: "TypeError",
-        message: expect.any(String),
-      }),
-    );
-  });
-});
-
-describe("fs.mkdtemp prefix check", () => {
-  test.each(prefixValues)("should throw for invalid prefix: %p", value => {
-    expect(() => {
-      fs.mkdtemp(value, jest.fn());
-    }).toThrow(
-      expect.objectContaining({
-        code: "ERR_INVALID_ARG_TYPE",
-        name: "TypeError",
-        message: expect.any(String),
-      }),
-    );
-  });
-});
-
-//<#END_FILE: test-fs-mkdtemp-prefix-check.js
diff --git a/test/js/node/test/parallel/fs-open-mode-mask.test.js b/test/js/node/test/parallel/fs-open-mode-mask.test.js
deleted file mode 100644
index 798005d296..0000000000
--- a/test/js/node/test/parallel/fs-open-mode-mask.test.js
+++ /dev/null
@@ -1,61 +0,0 @@
-//#FILE: test-fs-open-mode-mask.js
-//#SHA1: d290e7c1bced1fc3a98f27e2aeb463051581376c
-//-----------------
-"use strict";
-
-// This tests that the lower bits of mode > 0o777 still works in fs.open().
-
-const fs = require("fs");
-const path = require("path");
-const os = require("os");
-
-const mode = process.platform === "win32" ? 0o444 : 0o644;
-
-const maskToIgnore = 0o10000;
-
-const tmpdir = path.join(os.tmpdir(), "test-fs-open-mode-mask");
-
-beforeAll(() => {
-  try {
-    fs.mkdirSync(tmpdir, { recursive: true });
-  } catch (err) {
-    // Directory might already exist
-  }
-});
-
-afterAll(() => {
-  try {
-    fs.rmSync(tmpdir, { recursive: true, force: true });
-  } catch (err) {
-    // Ignore errors during cleanup
-  }
-});
-
-function test(mode, asString) {
-  const suffix = asString ? "str" : "num";
-  const input = asString ? (mode | maskToIgnore).toString(8) : mode | maskToIgnore;
-
-  it(`should work with ${suffix} input`, () => {
-    const file = path.join(tmpdir, `openSync-${suffix}.txt`);
-    const fd = fs.openSync(file, "w+", input);
-    expect(fs.fstatSync(fd).mode & 0o777).toBe(mode);
-    fs.closeSync(fd);
-    expect(fs.statSync(file).mode & 0o777).toBe(mode);
-  });
-
-  it(`should work with ${suffix} input using callback`, done => {
-    const file = path.join(tmpdir, `open-${suffix}.txt`);
-    fs.open(file, "w+", input, (err, fd) => {
-      expect(err).toBeNull();
-      expect(fs.fstatSync(fd).mode & 0o777).toBe(mode);
-      fs.closeSync(fd);
-      expect(fs.statSync(file).mode & 0o777).toBe(mode);
-      done();
-    });
-  });
-}
-
-test(mode, true);
-test(mode, false);
-
-//<#END_FILE: test-fs-open-mode-mask.js
diff --git a/test/js/node/test/parallel/fs-open-numeric-flags.test.js b/test/js/node/test/parallel/fs-open-numeric-flags.test.js
deleted file mode 100644
index 4edec0e495..0000000000
--- a/test/js/node/test/parallel/fs-open-numeric-flags.test.js
+++ /dev/null
@@ -1,41 +0,0 @@
-//#FILE: test-fs-open-numeric-flags.js
-//#SHA1: 31a49fd78cbd63ab0b41de5f051d029bbe22fded
-//-----------------
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-const os = require("os");
-
-// Create a temporary directory for our tests
-const tmpdir = path.join(os.tmpdir(), "test-fs-open-numeric-flags");
-
-beforeEach(() => {
-  // Ensure the temporary directory exists and is empty
-  if (fs.existsSync(tmpdir)) {
-    fs.rmSync(tmpdir, { recursive: true, force: true });
-  }
-  fs.mkdirSync(tmpdir, { recursive: true });
-});
-
-afterEach(() => {
-  // Clean up the temporary directory after each test
-  if (fs.existsSync(tmpdir)) {
-    fs.rmSync(tmpdir, { recursive: true, force: true });
-  }
-});
-
-test("O_WRONLY without O_CREAT shall fail with ENOENT", () => {
-  const pathNE = path.join(tmpdir, "file-should-not-exist");
-
-  expect(() => {
-    fs.openSync(pathNE, fs.constants.O_WRONLY);
-  }).toThrow(
-    expect.objectContaining({
-      code: "ENOENT",
-      message: expect.any(String),
-    }),
-  );
-});
-
-//<#END_FILE: test-fs-open-numeric-flags.js
diff --git a/test/js/node/test/parallel/fs-operations-with-surrogate-pairs.test.js b/test/js/node/test/parallel/fs-operations-with-surrogate-pairs.test.js
deleted file mode 100644
index 54c9021472..0000000000
--- a/test/js/node/test/parallel/fs-operations-with-surrogate-pairs.test.js
+++ /dev/null
@@ -1,32 +0,0 @@
-//#FILE: test-fs-operations-with-surrogate-pairs.js
-//#SHA1: c59fe103e9ec4edee50c9186d341f5fdd32e0af4
-//-----------------
-"use strict";
-
-const fs = require("node:fs");
-const path = require("node:path");
-const tmpdir = require("../common/tmpdir");
-
-tmpdir.refresh();
-
-describe("File operations with filenames containing surrogate pairs", () => {
-  it("should write, read, and delete a file with surrogate pairs in the filename", () => {
-    // Create a temporary directory
-    const tempdir = fs.mkdtempSync(tmpdir.resolve("emoji-fruit-🍇 🍈 🍉 🍊 🍋"));
-    expect(fs.existsSync(tempdir)).toBe(true);
-
-    const filename = "🚀🔥🛸.txt";
-    const content = "Test content";
-
-    // Write content to a file
-    fs.writeFileSync(path.join(tempdir, filename), content);
-
-    // Read content from the file
-    const readContent = fs.readFileSync(path.join(tempdir, filename), "utf8");
-
-    // Check if the content matches
-    expect(readContent).toBe(content);
-  });
-});
-
-//<#END_FILE: test-fs-operations-with-surrogate-pairs.js
diff --git a/test/js/node/test/parallel/fs-options-immutable.test.js b/test/js/node/test/parallel/fs-options-immutable.test.js
deleted file mode 100644
index 9beef4c128..0000000000
--- a/test/js/node/test/parallel/fs-options-immutable.test.js
+++ /dev/null
@@ -1,148 +0,0 @@
-//#FILE: test-fs-options-immutable.js
-//#SHA1: 3e986f4e0d29505ada9980c8af5146abd307ddb7
-//-----------------
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-const os = require("os");
-
-// These tests make sure that the `options` object passed to these functions are
-// never altered.
-//
-// Refer: https://github.com/nodejs/node/issues/7655
-
-const originalOptions = {};
-let options;
-
-beforeEach(() => {
-  options = JSON.parse(JSON.stringify(originalOptions));
-});
-
-const tmpdir = {
-  path: path.join(os.tmpdir(), "node-test-fs-options-immutable"),
-  refresh: () => {
-    try {
-      fs.rmSync(tmpdir.path, { recursive: true, force: true });
-    } catch (error) {
-      // Ignore errors
-    }
-    fs.mkdirSync(tmpdir.path, { recursive: true });
-  },
-  resolve: filename => path.join(tmpdir.path, filename),
-};
-
-tmpdir.refresh();
-
-test("fs.readFile", async () => {
-  await fs.promises.readFile(__filename, options);
-  expect(options).toEqual(originalOptions);
-});
-
-test("fs.readFileSync", () => {
-  fs.readFileSync(__filename, options);
-  expect(options).toEqual(originalOptions);
-});
-
-test("fs.readdir", async () => {
-  await fs.promises.readdir(__dirname, options);
-  expect(options).toEqual(originalOptions);
-});
-
-test("fs.readdirSync", () => {
-  fs.readdirSync(__dirname, options);
-  expect(options).toEqual(originalOptions);
-});
-
-test("fs.readlink and fs.readlinkSync", async () => {
-  const canCreateSymLink = await new Promise(resolve => {
-    fs.symlink(__filename, "dummy-symlink", err => {
-      if (err) resolve(false);
-      fs.unlink("dummy-symlink", () => resolve(true));
-    });
-  });
-
-  if (canCreateSymLink) {
-    const sourceFile = tmpdir.resolve("test-readlink");
-    const linkFile = tmpdir.resolve("test-readlink-link");
-
-    await fs.promises.writeFile(sourceFile, "");
-    await fs.promises.symlink(sourceFile, linkFile);
-
-    await fs.promises.readlink(linkFile, options);
-    expect(options).toEqual(originalOptions);
-
-    fs.readlinkSync(linkFile, options);
-    expect(options).toEqual(originalOptions);
-  } else {
-    test.skip("Symlink tests skipped - cannot create symlinks", () => {});
-  }
-});
-
-test("fs.writeFile and fs.writeFileSync", async () => {
-  const fileName = tmpdir.resolve("writeFile");
-  fs.writeFileSync(fileName, "ABCD", options);
-  expect(options).toEqual(originalOptions);
-
-  await fs.promises.writeFile(fileName, "ABCD", options);
-  expect(options).toEqual(originalOptions);
-});
-
-test("fs.appendFile and fs.appendFileSync", async () => {
-  const fileName = tmpdir.resolve("appendFile");
-  fs.appendFileSync(fileName, "ABCD", options);
-  expect(options).toEqual(originalOptions);
-
-  await fs.promises.appendFile(fileName, "ABCD", options);
-  expect(options).toEqual(originalOptions);
-});
-
-test("fs.watch", () => {
-  if (process.platform === "os400") {
-    return test.skip("IBMi does not support fs.watch()");
-  }
-
-  const watch = fs.watch(__filename, options, () => {});
-  watch.close();
-  expect(options).toEqual(originalOptions);
-});
-
-test("fs.watchFile and fs.unwatchFile", () => {
-  fs.watchFile(__filename, options, () => {});
-  fs.unwatchFile(__filename);
-  expect(options).toEqual(originalOptions);
-});
-
-test("fs.realpath and fs.realpathSync", async () => {
-  fs.realpathSync(__filename, options);
-  expect(options).toEqual(originalOptions);
-
-  await fs.promises.realpath(__filename, options);
-  expect(options).toEqual(originalOptions);
-});
-
-test("fs.mkdtemp and fs.mkdtempSync", async () => {
-  const tempFileName = tmpdir.resolve("mkdtemp-");
-  fs.mkdtempSync(tempFileName, options);
-  expect(options).toEqual(originalOptions);
-
-  await fs.promises.mkdtemp(tempFileName, options);
-  expect(options).toEqual(originalOptions);
-});
-
-test("fs.WriteStream and fs.ReadStream", done => {
-  const fileName = tmpdir.resolve("streams");
-  const writeStream = fs.createWriteStream(fileName, options);
-  writeStream.once("open", () => {
-    expect(options).toEqual(originalOptions);
-    const readStream = fs.createReadStream(fileName, options);
-    readStream.once("open", () => {
-      expect(options).toEqual(originalOptions);
-      readStream.destroy();
-      writeStream.end();
-      done();
-    });
-  });
-});
-
-//<#END_FILE: test-fs-options-immutable.js
diff --git a/test/js/node/test/parallel/fs-promises-exists.test.js b/test/js/node/test/parallel/fs-promises-exists.test.js
deleted file mode 100644
index 303718b0ef..0000000000
--- a/test/js/node/test/parallel/fs-promises-exists.test.js
+++ /dev/null
@@ -1,14 +0,0 @@
-//#FILE: test-fs-promises-exists.js
-//#SHA1: 3766c49e29d13338f3124165428e3a8a37d47fab
-//-----------------
-"use strict";
-
-const fs = require("fs");
-const fsPromises = require("fs/promises");
-
-test("fs.promises exists and is correctly linked", () => {
-  expect(fsPromises).toBe(fs.promises);
-  expect(fsPromises.constants).toBe(fs.constants);
-});
-
-//<#END_FILE: test-fs-promises-exists.js
diff --git a/test/js/node/test/parallel/fs-promises-file-handle-chmod.test.js b/test/js/node/test/parallel/fs-promises-file-handle-chmod.test.js
deleted file mode 100644
index 8bd751f1d1..0000000000
--- a/test/js/node/test/parallel/fs-promises-file-handle-chmod.test.js
+++ /dev/null
@@ -1,50 +0,0 @@
-//#FILE: test-fs-promises-file-handle-chmod.js
-//#SHA1: 50a28df8df34deeca4b2f9d7598fb596894d7541
-//-----------------
-"use strict";
-
-const fs = require("fs");
-const { open } = fs.promises;
-const path = require("path");
-const os = require("os");
-
-const tmpDir = os.tmpdir();
-
-beforeEach(() => {
-  jest.spyOn(fs, "statSync");
-});
-
-afterEach(() => {
-  jest.restoreAllMocks();
-});
-
-test("FileHandle.chmod base functionality", async () => {
-  const filePath = path.resolve(tmpDir, "tmp-chmod.txt");
-  const fileHandle = await open(filePath, "w+", 0o444);
-
-  // File created with r--r--r-- 444
-  const statsBeforeMod = fs.statSync(filePath);
-  expect(statsBeforeMod.mode & 0o444).toBe(0o444);
-
-  let expectedAccess;
-  const newPermissions = 0o765;
-
-  if (process.platform === "win32") {
-    // Chmod in Windows will only toggle read only/write access. The
-    // fs.Stats.mode in Windows is computed using read/write
-    // bits (not exec). Read-only at best returns 444; r/w 666.
-    // Refer: /deps/uv/src/win/fs.cfs;
-    expectedAccess = 0o664;
-  } else {
-    expectedAccess = newPermissions;
-  }
-
-  // Change the permissions to rwxr--r-x
-  await fileHandle.chmod(newPermissions);
-  const statsAfterMod = fs.statSync(filePath);
-  expect(statsAfterMod.mode & expectedAccess).toBe(expectedAccess);
-
-  await fileHandle.close();
-});
-
-//<#END_FILE: test-fs-promises-file-handle-chmod.js
diff --git a/test/js/node/test/parallel/fs-promises-readfile-empty.test.js b/test/js/node/test/parallel/fs-promises-readfile-empty.test.js
deleted file mode 100644
index dc9d291e5f..0000000000
--- a/test/js/node/test/parallel/fs-promises-readfile-empty.test.js
+++ /dev/null
@@ -1,27 +0,0 @@
-//#FILE: test-fs-promises-readfile-empty.js
-//#SHA1: 6fcec9b5d3c9617426d46c79fb79244bc236574b
-//-----------------
-"use strict";
-
-const fs = require("fs").promises;
-const path = require("path");
-
-const fixturesPath = path.resolve(__dirname, "..", "fixtures");
-const fn = path.join(fixturesPath, "empty.txt");
-
-test("fs.readFile on empty file", async () => {
-  const content = await fs.readFile(fn);
-  expect(content).toBeTruthy();
-});
-
-test("fs.readFile on empty file with utf8 encoding", async () => {
-  const content = await fs.readFile(fn, "utf8");
-  expect(content).toBe("");
-});
-
-test("fs.readFile on empty file with options object", async () => {
-  const content = await fs.readFile(fn, { encoding: "utf8" });
-  expect(content).toBe("");
-});
-
-//<#END_FILE: test-fs-promises-readfile-empty.js
diff --git a/test/js/node/test/parallel/fs-promises-writefile-typedarray.test.js b/test/js/node/test/parallel/fs-promises-writefile-typedarray.test.js
deleted file mode 100644
index bece880bd3..0000000000
--- a/test/js/node/test/parallel/fs-promises-writefile-typedarray.test.js
+++ /dev/null
@@ -1,39 +0,0 @@
-//#FILE: test-fs-promises-writefile-typedarray.js
-//#SHA1: 718d3827c56ad0b11c59a801bf9529a1e6e5ab89
-//-----------------
-"use strict";
-
-const fs = require("fs");
-const fsPromises = fs.promises;
-const path = require("path");
-const os = require("os");
-
-const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "test-"));
-
-beforeAll(() => {
-  // Ensure the temporary directory is clean
-  fs.rmSync(tmpDir, { recursive: true, force: true });
-  fs.mkdirSync(tmpDir, { recursive: true });
-});
-
-afterAll(() => {
-  // Clean up the temporary directory
-  fs.rmSync(tmpDir, { recursive: true, force: true });
-});
-
-const dest = path.resolve(tmpDir, "tmp.txt");
-// Use a file size larger than `kReadFileMaxChunkSize`.
-const buffer = Buffer.from("012".repeat(2 ** 14));
-
-test("fsPromises.writeFile with TypedArrays", async () => {
-  const constructors = [Uint8Array, Uint16Array, Uint32Array];
-
-  for (const Constructor of constructors) {
-    const array = new Constructor(buffer.buffer);
-    await fsPromises.writeFile(dest, array);
-    const data = await fsPromises.readFile(dest);
-    expect(data).toEqual(buffer);
-  }
-});
-
-//<#END_FILE: test-fs-promises-writefile-typedarray.js
diff --git a/test/js/node/test/parallel/fs-promises-writefile-with-fd.test.js b/test/js/node/test/parallel/fs-promises-writefile-with-fd.test.js
deleted file mode 100644
index 17182bedb6..0000000000
--- a/test/js/node/test/parallel/fs-promises-writefile-with-fd.test.js
+++ /dev/null
@@ -1,43 +0,0 @@
-//#FILE: test-fs-promises-writefile-with-fd.js
-//#SHA1: 55be58e0edcbdc914795c46280459a85071f28eb
-//-----------------
-"use strict";
-
-// This test makes sure that `writeFile()` always writes from the current
-// position of the file, instead of truncating the file.
-
-const fs = require("fs");
-const fsPromises = require("fs").promises;
-const path = require("path");
-const os = require("os");
-
-let tmpdir;
-
-beforeEach(() => {
-  tmpdir = fs.mkdtempSync(path.join(os.tmpdir(), "test-"));
-});
-
-afterEach(() => {
-  fs.rmSync(tmpdir, { recursive: true, force: true });
-});
-
-test("writeFile() writes from current position", async () => {
-  const fn = path.join(tmpdir, "test.txt");
-
-  const handle = await fsPromises.open(fn, "w");
-
-  /* Write only five bytes, so that the position moves to five. */
-  const buf = Buffer.from("Hello");
-  const { bytesWritten } = await handle.write(buf, 0, 5, null);
-  expect(bytesWritten).toBe(5);
-
-  /* Write some more with writeFile(). */
-  await handle.writeFile("World");
-
-  /* New content should be written at position five, instead of zero. */
-  expect(fs.readFileSync(fn, "utf8")).toBe("HelloWorld");
-
-  await handle.close();
-});
-
-//<#END_FILE: test-fs-promises-writefile-with-fd.js
diff --git a/test/js/node/test/parallel/fs-promisified.test.js b/test/js/node/test/parallel/fs-promisified.test.js
deleted file mode 100644
index 3df07cc98e..0000000000
--- a/test/js/node/test/parallel/fs-promisified.test.js
+++ /dev/null
@@ -1,37 +0,0 @@
-//#FILE: test-fs-promisified.js
-//#SHA1: 5366497c2a750295d2c5cf65c2938e27f573e8bb
-//-----------------
-"use strict";
-
-const fs = require("fs");
-const { promisify } = require("util");
-
-const read = promisify(fs.read);
-const write = promisify(fs.write);
-const exists = promisify(fs.exists);
-
-test("promisified fs.read", async () => {
-  const fd = fs.openSync(__filename, "r");
-  const obj = await read(fd, Buffer.alloc(1024), 0, 1024, null);
-  expect(typeof obj.bytesRead).toBe("number");
-  expect(obj.buffer).toBeInstanceOf(Buffer);
-  fs.closeSync(fd);
-});
-
-test("promisified fs.write", async () => {
-  const tmpdir = require("../common/tmpdir");
-  tmpdir.refresh();
-  const filename = tmpdir.resolve("write-promise.txt");
-  const fd = fs.openSync(filename, "w");
-  const obj = await write(fd, Buffer.from("foobar"));
-  expect(typeof obj.bytesWritten).toBe("number");
-  expect(obj.buffer.toString()).toBe("foobar");
-  fs.closeSync(fd);
-});
-
-test("promisified fs.exists", async () => {
-  const result = await exists(__filename);
-  expect(result).toBe(true);
-});
-
-//<#END_FILE: test-fs-promisified.js
diff --git a/test/js/node/test/parallel/fs-read-file-sync-hostname.test.js b/test/js/node/test/parallel/fs-read-file-sync-hostname.test.js
deleted file mode 100644
index 9c4eb90ad8..0000000000
--- a/test/js/node/test/parallel/fs-read-file-sync-hostname.test.js
+++ /dev/null
@@ -1,39 +0,0 @@
-//#FILE: test-fs-read-file-sync-hostname.js
-//#SHA1: 6e8bd1a34277c7b98b985ba23843555b05f80ccb
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const fs = require("fs");
-
-if (process.platform !== "linux") {
-  test.skip("Test is linux specific.", () => {});
-} else {
-  test("reading /proc/sys/kernel/hostname", () => {
-    // Test to make sure reading a file under the /proc directory works. See:
-    // https://groups.google.com/forum/#!topic/nodejs-dev/rxZ_RoH1Gn0
-    const hostname = fs.readFileSync("/proc/sys/kernel/hostname");
-    expect(hostname.length).toBeGreaterThan(0);
-  });
-}
-
-//<#END_FILE: test-fs-read-file-sync-hostname.js
diff --git a/test/js/node/test/parallel/fs-read-optional-params.test.js b/test/js/node/test/parallel/fs-read-optional-params.test.js
deleted file mode 100644
index 8abd08c20e..0000000000
--- a/test/js/node/test/parallel/fs-read-optional-params.test.js
+++ /dev/null
@@ -1,60 +0,0 @@
-//#FILE: test-fs-read-optional-params.js
-//#SHA1: daea619faa084927d87381fc60aedde3068a13ca
-//-----------------
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-const os = require("os");
-
-const filepath = path.join(os.tmpdir(), "x.txt");
-const expected = Buffer.from("xyz\n");
-const defaultBufferAsync = Buffer.alloc(16384);
-const bufferAsOption = Buffer.allocUnsafe(expected.byteLength);
-
-beforeAll(() => {
-  fs.writeFileSync(filepath, expected);
-});
-
-afterAll(() => {
-  fs.unlinkSync(filepath);
-});
-
-function testValid(message, ...options) {
-  test(`${message} (as params)`, async () => {
-    const paramsFilehandle = fs.openSync(filepath, "r");
-    await new Promise(resolve => {
-      fs.read(paramsFilehandle, ...options, (err, bytesRead, buffer) => {
-        expect(err).toBeNull();
-        expect(bytesRead).toBe(expected.byteLength);
-        expect(buffer.byteLength).toBe(defaultBufferAsync.byteLength);
-        fs.closeSync(paramsFilehandle);
-        resolve();
-      });
-    });
-  });
-
-  test(`${message} (as options)`, async () => {
-    const optionsFilehandle = fs.openSync(filepath, "r");
-    await new Promise(resolve => {
-      fs.read(optionsFilehandle, bufferAsOption, ...options, (err, bytesRead, buffer) => {
-        expect(err).toBeNull();
-        expect(bytesRead).toBe(expected.byteLength);
-        expect(buffer.byteLength).toBe(bufferAsOption.byteLength);
-        fs.closeSync(optionsFilehandle);
-        resolve();
-      });
-    });
-  });
-}
-
-testValid("Not passing in any object");
-testValid("Passing in a null", null);
-testValid("Passing in an empty object", {});
-testValid("Passing in an object", {
-  offset: 0,
-  length: bufferAsOption.byteLength,
-  position: 0,
-});
-
-//<#END_FILE: test-fs-read-optional-params.js
diff --git a/test/js/node/test/parallel/fs-read-stream-autoclose.test.js b/test/js/node/test/parallel/fs-read-stream-autoclose.test.js
deleted file mode 100644
index 36ab013cd8..0000000000
--- a/test/js/node/test/parallel/fs-read-stream-autoclose.test.js
+++ /dev/null
@@ -1,32 +0,0 @@
-//#FILE: test-fs-read-stream-autoClose.js
-//#SHA1: 0fbd57ecd5ae02143036c03cdca120bc7c3deea1
-//-----------------
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-const os = require("os");
-
-const writeFile = path.join(os.tmpdir(), "write-autoClose.txt");
-
-beforeEach(() => {
-  // Clean up the temporary directory
-  try {
-    fs.unlinkSync(writeFile);
-  } catch (err) {
-    // Ignore errors if file doesn't exist
-  }
-});
-
-test("fs.createWriteStream with autoClose option", done => {
-  const file = fs.createWriteStream(writeFile, { autoClose: true });
-
-  file.on("finish", () => {
-    expect(file.destroyed).toBe(false);
-    done();
-  });
-
-  file.end("asd");
-});
-
-//<#END_FILE: test-fs-read-stream-autoClose.js
diff --git a/test/js/node/test/parallel/fs-read-stream-fd-leak.test.js b/test/js/node/test/parallel/fs-read-stream-fd-leak.test.js
deleted file mode 100644
index 5c4e0dd55b..0000000000
--- a/test/js/node/test/parallel/fs-read-stream-fd-leak.test.js
+++ /dev/null
@@ -1,66 +0,0 @@
-//#FILE: test-fs-read-stream-fd-leak.js
-//#SHA1: fc07b42f524d6a2f9743a5a7665c92096f58505b
-//-----------------
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-
-let openCount = 0;
-const _fsopen = fs.open;
-const _fsclose = fs.close;
-
-const loopCount = 50;
-const totalCheck = 50;
-const emptyTxt = path.join(__dirname, "../fixtures/empty.txt");
-
-fs.open = function () {
-  openCount++;
-  return _fsopen.apply(null, arguments);
-};
-
-fs.close = function () {
-  openCount--;
-  return _fsclose.apply(null, arguments);
-};
-
-function testLeak(endFn) {
-  return new Promise(resolve => {
-    console.log(`testing for leaks from fs.createReadStream().${endFn}()...`);
-
-    let i = 0;
-    let check = 0;
-
-    function checkFunction() {
-      if (openCount !== 0 && check < totalCheck) {
-        check++;
-        setTimeout(checkFunction, 100);
-        return;
-      }
-
-      expect(openCount).toBe(0);
-      openCount = 0;
-      resolve();
-    }
-
-    const interval = setInterval(() => {
-      const s = fs.createReadStream(emptyTxt);
-      s[endFn]();
-
-      if (++i === loopCount) {
-        clearInterval(interval);
-        setTimeout(checkFunction, 100);
-      }
-    }, 2);
-  });
-}
-
-test("no leaked file descriptors using close()", async () => {
-  await testLeak("close");
-}, 10000);
-
-test("no leaked file descriptors using destroy()", async () => {
-  await testLeak("destroy");
-}, 10000);
-
-//<#END_FILE: test-fs-read-stream-fd-leak.js
diff --git a/test/js/node/test/parallel/fs-read-stream-pos.test.js b/test/js/node/test/parallel/fs-read-stream-pos.test.js
deleted file mode 100644
index bdc551a7c1..0000000000
--- a/test/js/node/test/parallel/fs-read-stream-pos.test.js
+++ /dev/null
@@ -1,103 +0,0 @@
-//#FILE: test-fs-read-stream-pos.js
-//#SHA1: e44b357d8045cfa1e8129a160254dcfb9225d990
-//-----------------
-"use strict";
-
-// Refs: https://github.com/nodejs/node/issues/33940
-
-const fs = require("fs");
-const path = require("path");
-const os = require("os");
-
-const tmpdir = {
-  refresh: () => {
-    // Implement tmpdir.refresh() if needed
-  },
-  resolve: filename => path.join(os.tmpdir(), filename),
-};
-
-tmpdir.refresh();
-
-const file = tmpdir.resolve("read_stream_pos_test.txt");
-
-fs.writeFileSync(file, "");
-
-let counter = 0;
-
-const writeInterval = setInterval(() => {
-  counter = counter + 1;
-  const line = `hello at ${counter}\n`;
-  fs.writeFileSync(file, line, { flag: "a" });
-}, 1);
-
-const hwm = 10;
-let bufs = [];
-let isLow = false;
-let cur = 0;
-let stream;
-
-const readInterval = setInterval(() => {
-  if (stream) return;
-
-  stream = fs.createReadStream(file, {
-    highWaterMark: hwm,
-    start: cur,
-  });
-  stream.on(
-    "data",
-    jest.fn(chunk => {
-      cur += chunk.length;
-      bufs.push(chunk);
-      if (isLow) {
-        const brokenLines = Buffer.concat(bufs)
-          .toString()
-          .split("\n")
-          .filter(line => {
-            const s = "hello at".slice(0, line.length);
-            if (line && !line.startsWith(s)) {
-              return true;
-            }
-            return false;
-          });
-        expect(brokenLines.length).toBe(0);
-        exitTest();
-        return;
-      }
-      if (chunk.length !== hwm) {
-        isLow = true;
-      }
-    }),
-  );
-  stream.on("end", () => {
-    stream = null;
-    isLow = false;
-    bufs = [];
-  });
-}, 10);
-
-// Time longer than 90 seconds to exit safely
-const endTimer = setTimeout(() => {
-  exitTest();
-}, 90000);
-
-const exitTest = () => {
-  clearInterval(readInterval);
-  clearInterval(writeInterval);
-  clearTimeout(endTimer);
-  if (stream && !stream.destroyed) {
-    stream.on("close", () => {
-      process.exit();
-    });
-    stream.destroy();
-  } else {
-    process.exit();
-  }
-};
-
-test("fs read stream position", () => {
-  // This test is mostly about setting up the environment and running the intervals
-  // The actual assertions are made within the intervals
-  expect(true).toBe(true);
-});
-
-//<#END_FILE: test-fs-read-stream-pos.js
diff --git a/test/js/node/test/parallel/fs-readdir-buffer.test.js b/test/js/node/test/parallel/fs-readdir-buffer.test.js
deleted file mode 100644
index 4003405487..0000000000
--- a/test/js/node/test/parallel/fs-readdir-buffer.test.js
+++ /dev/null
@@ -1,23 +0,0 @@
-//#FILE: test-fs-readdir-buffer.js
-//#SHA1: 333645cb13aa3c15d61428ecfa2794e7393ef91c
-//-----------------
-"use strict";
-
-const fs = require("fs");
-
-if (process.platform !== "darwin") {
-  it("skips test on non-MacOS platforms", () => {
-    test.skip("this test works only on MacOS");
-  });
-} else {
-  test("readdir with buffer and withFileTypes options on MacOS", () => {
-    return new Promise(resolve => {
-      fs.readdir(Buffer.from("/dev"), { withFileTypes: true, encoding: "buffer" }, (err, files) => {
-        expect(err).toBeNull();
-        resolve();
-      });
-    });
-  });
-}
-
-//<#END_FILE: test-fs-readdir-buffer.js
diff --git a/test/js/node/test/parallel/fs-readdir-recursive.test.js b/test/js/node/test/parallel/fs-readdir-recursive.test.js
deleted file mode 100644
index 32c284e827..0000000000
--- a/test/js/node/test/parallel/fs-readdir-recursive.test.js
+++ /dev/null
@@ -1,39 +0,0 @@
-//#FILE: test-fs-readdir-recursive.js
-//#SHA1: daa6ac8e46cd3d530e4546354a11f87f1b1c092d
-//-----------------
-"use strict";
-
-const fs = require("fs");
-const net = require("net");
-const path = require("path");
-const os = require("os");
-
-const tmpdir = path.join(os.tmpdir(), "node-test-fs-readdir-recursive");
-
-beforeAll(() => {
-  // Refresh tmpdir
-  if (fs.existsSync(tmpdir)) {
-    fs.rmSync(tmpdir, { recursive: true, force: true });
-  }
-  fs.mkdirSync(tmpdir, { recursive: true });
-});
-
-afterAll(() => {
-  // Clean up tmpdir
-  fs.rmSync(tmpdir, { recursive: true, force: true });
-});
-
-test("fs.readdirSync with recursive option should not crash", done => {
-  const server = net.createServer().listen(path.join(tmpdir, "test.sock"), () => {
-    // The process should not crash
-    // See https://github.com/nodejs/node/issues/52159
-    expect(() => {
-      fs.readdirSync(tmpdir, { recursive: true });
-    }).not.toThrow();
-
-    server.close();
-    done();
-  });
-});
-
-//<#END_FILE: test-fs-readdir-recursive.js
diff --git a/test/js/node/test/parallel/fs-readdir.test.js b/test/js/node/test/parallel/fs-readdir.test.js
deleted file mode 100644
index 1e98f2f1b6..0000000000
--- a/test/js/node/test/parallel/fs-readdir.test.js
+++ /dev/null
@@ -1,90 +0,0 @@
-//#FILE: test-fs-readdir.js
-//#SHA1: ce2c5a12cb271c5023f965afe712e78b1a484ad5
-//-----------------
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-const os = require("os");
-
-const readdirDir = path.join(os.tmpdir(), "test-fs-readdir");
-const files = ["empty", "files", "for", "just", "testing"];
-
-beforeAll(() => {
-  // Make sure tmp directory is clean
-  if (fs.existsSync(readdirDir)) {
-    fs.rmSync(readdirDir, { recursive: true, force: true });
-  }
-  fs.mkdirSync(readdirDir, { recursive: true });
-
-  // Create the necessary files
-  files.forEach(currentFile => {
-    fs.closeSync(fs.openSync(path.join(readdirDir, currentFile), "w"));
-  });
-});
-
-afterAll(() => {
-  // Clean up
-  fs.rmSync(readdirDir, { recursive: true, force: true });
-});
-
-test("fs.readdirSync returns correct files", () => {
-  expect(fs.readdirSync(readdirDir).sort()).toEqual(files);
-});
-
-test("fs.readdir returns correct files", async () => {
-  await new Promise(resolve => {
-    fs.readdir(readdirDir, (err, f) => {
-      expect(err).toBeNull();
-      expect(f.sort()).toEqual(files);
-      resolve();
-    });
-  });
-});
-
-test("fs.readdirSync throws ENOTDIR on file", () => {
-  expect(() => {
-    fs.readdirSync(__filename);
-  }).toThrow(
-    expect.objectContaining({
-      code: "ENOTDIR",
-      message: expect.any(String),
-    }),
-  );
-});
-
-test("fs.readdir throws ENOTDIR on file", async () => {
-  await new Promise(resolve => {
-    fs.readdir(__filename, e => {
-      expect(e).toEqual(
-        expect.objectContaining({
-          code: "ENOTDIR",
-          message: expect.any(String),
-        }),
-      );
-      resolve();
-    });
-  });
-});
-
-test("fs.readdir and fs.readdirSync throw on invalid input", () => {
-  [false, 1, [], {}, null, undefined].forEach(i => {
-    expect(() => fs.readdir(i, () => {})).toThrow(
-      expect.objectContaining({
-        code: "ERR_INVALID_ARG_TYPE",
-        name: "TypeError",
-        message: expect.any(String),
-      }),
-    );
-
-    expect(() => fs.readdirSync(i)).toThrow(
-      expect.objectContaining({
-        code: "ERR_INVALID_ARG_TYPE",
-        name: "TypeError",
-        message: expect.any(String),
-      }),
-    );
-  });
-});
-
-//<#END_FILE: test-fs-readdir.js
diff --git a/test/js/node/test/parallel/fs-readfile-eof.test.js b/test/js/node/test/parallel/fs-readfile-eof.test.js
deleted file mode 100644
index f1b68ffccf..0000000000
--- a/test/js/node/test/parallel/fs-readfile-eof.test.js
+++ /dev/null
@@ -1,54 +0,0 @@
-//#FILE: test-fs-readfile-eof.js
-//#SHA1: 89b7efe6c30d2316249bfae1d01f16f97e32be04
-//-----------------
-"use strict";
-
-const fs = require("fs/promises");
-const { exec } = require("child_process");
-
-const childType = ["child-encoding", "child-non-encoding"];
-
-if (process.argv[2] === childType[0]) {
-  fs.readFile("/dev/stdin", "utf8").then(data => {
-    process.stdout.write(data);
-  });
-} else if (process.argv[2] === childType[1]) {
-  fs.readFile("/dev/stdin").then(data => {
-    process.stdout.write(data);
-  });
-} else {
-  const data1 = "Hello";
-  const data2 = "World";
-  const expected = `${data1}\n${data2}\n`;
-
-  const f = JSON.stringify(__filename);
-  const node = JSON.stringify(process.execPath);
-
-  function testReadFile(child) {
-    return new Promise((resolve, reject) => {
-      const cmd = `(echo ${data1}; sleep 0.5; echo ${data2}) | ${node} ${f} ${child}`;
-      exec(cmd, (error, stdout, stderr) => {
-        if (error) reject(error);
-        else resolve({ stdout, stderr });
-      });
-    });
-  }
-
-  if (process.platform === "win32" || process.platform === "aix" || process.platform === "os400") {
-    test.skip(`No /dev/stdin on ${process.platform}.`, () => {});
-  } else {
-    test("readFile with encoding", async () => {
-      const { stdout, stderr } = await testReadFile(childType[0]);
-      expect(stdout).toBe(expected);
-      expect(stderr).toBe("");
-    });
-
-    test("readFile without encoding", async () => {
-      const { stdout, stderr } = await testReadFile(childType[1]);
-      expect(stdout).toBe(expected);
-      expect(stderr).toBe("");
-    });
-  }
-}
-
-//<#END_FILE: test-fs-readfile-eof.js
diff --git a/test/js/node/test/parallel/fs-readfile-unlink.test.js b/test/js/node/test/parallel/fs-readfile-unlink.test.js
deleted file mode 100644
index 85475f6488..0000000000
--- a/test/js/node/test/parallel/fs-readfile-unlink.test.js
+++ /dev/null
@@ -1,52 +0,0 @@
-//#FILE: test-fs-readfile-unlink.js
-//#SHA1: a7107747d7901dfcc1ffd0e7adbf548412a1016a
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-const os = require("os");
-
-// Test that unlink succeeds immediately after readFile completes.
-
-test("unlink succeeds immediately after readFile completes", async () => {
-  const tmpdir = path.join(os.tmpdir(), "node-test-fs-readfile-unlink");
-  await fs.promises.mkdir(tmpdir, { recursive: true });
-
-  const fileName = path.join(tmpdir, "test.bin");
-  const buf = Buffer.alloc(512 * 1024, 42);
-
-  await fs.promises.writeFile(fileName, buf);
-
-  const data = await fs.promises.readFile(fileName);
-
-  expect(data.length).toBe(buf.length);
-  expect(data[0]).toBe(42);
-
-  // Unlink should not throw. This is part of the test. It used to throw on
-  // Windows due to a bug.
-  await expect(fs.promises.unlink(fileName)).resolves.toBeUndefined();
-});
-
-//<#END_FILE: test-fs-readfile-unlink.js
diff --git a/test/js/node/test/parallel/fs-readfile-zero-byte-liar.test.js b/test/js/node/test/parallel/fs-readfile-zero-byte-liar.test.js
deleted file mode 100644
index 0e3799ec0e..0000000000
--- a/test/js/node/test/parallel/fs-readfile-zero-byte-liar.test.js
+++ /dev/null
@@ -1,61 +0,0 @@
-//#FILE: test-fs-readfile-zero-byte-liar.js
-//#SHA1: ddca2f114cf32b03f36405a21c81058e7a1f0c18
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-const fs = require("fs");
-
-// Test that readFile works even when stat returns size 0.
-
-const dataExpected = fs.readFileSync(__filename, "utf8");
-
-// Sometimes stat returns size=0, but it's a lie.
-fs._fstat = fs.fstat;
-fs._fstatSync = fs.fstatSync;
-
-fs.fstat = (fd, cb) => {
-  fs._fstat(fd, (er, st) => {
-    if (er) return cb(er);
-    st.size = 0;
-    return cb(er, st);
-  });
-};
-
-fs.fstatSync = fd => {
-  const st = fs._fstatSync(fd);
-  st.size = 0;
-  return st;
-};
-
-test("readFileSync works with zero byte liar", () => {
-  const d = fs.readFileSync(__filename, "utf8");
-  expect(d).toBe(dataExpected);
-});
-
-test("readFile works with zero byte liar", async () => {
-  const d = await fs.promises.readFile(__filename, "utf8");
-  expect(d).toBe(dataExpected);
-});
-
-//<#END_FILE: test-fs-readfile-zero-byte-liar.js
diff --git a/test/js/node/test/parallel/fs-readlink-type-check.test.js b/test/js/node/test/parallel/fs-readlink-type-check.test.js
deleted file mode 100644
index c0ee6e8b00..0000000000
--- a/test/js/node/test/parallel/fs-readlink-type-check.test.js
+++ /dev/null
@@ -1,30 +0,0 @@
-//#FILE: test-fs-readlink-type-check.js
-//#SHA1: dd36bda8e12e6c22c342325345dd8d1de2097d9c
-//-----------------
-"use strict";
-
-const fs = require("fs");
-
-[false, 1, {}, [], null, undefined].forEach(i => {
-  test(`fs.readlink throws for invalid input: ${JSON.stringify(i)}`, () => {
-    expect(() => fs.readlink(i, jest.fn())).toThrow(
-      expect.objectContaining({
-        code: "ERR_INVALID_ARG_TYPE",
-        name: "TypeError",
-        message: expect.any(String),
-      }),
-    );
-  });
-
-  test(`fs.readlinkSync throws for invalid input: ${JSON.stringify(i)}`, () => {
-    expect(() => fs.readlinkSync(i)).toThrow(
-      expect.objectContaining({
-        code: "ERR_INVALID_ARG_TYPE",
-        name: "TypeError",
-        message: expect.any(String),
-      }),
-    );
-  });
-});
-
-//<#END_FILE: test-fs-readlink-type-check.js
diff --git a/test/js/node/test/parallel/fs-readv-promises.test.js b/test/js/node/test/parallel/fs-readv-promises.test.js
deleted file mode 100644
index ff66cc9354..0000000000
--- a/test/js/node/test/parallel/fs-readv-promises.test.js
+++ /dev/null
@@ -1,69 +0,0 @@
-//#FILE: test-fs-readv-promises.js
-//#SHA1: 43d801fa8a2eabf438e98f5aa713eb9680fe798b
-//-----------------
-"use strict";
-
-const fs = require("fs").promises;
-const path = require("path");
-const os = require("os");
-
-const expected = "ümlaut. Лорем 運務ホソモ指及 आपको करने विकास 紙読決多密所 أضف";
-const expectedBuff = Buffer.from(expected);
-
-let cnt = 0;
-function getFileName() {
-  return path.join(os.tmpdir(), `readv_promises_${++cnt}.txt`);
-}
-
-const allocateEmptyBuffers = combinedLength => {
-  const bufferArr = [];
-  // Allocate two buffers, each half the size of expectedBuff
-  bufferArr[0] = Buffer.alloc(Math.floor(combinedLength / 2));
-  bufferArr[1] = Buffer.alloc(combinedLength - bufferArr[0].length);
-
-  return bufferArr;
-};
-
-describe("fs.promises.readv", () => {
-  beforeEach(() => {
-    cnt = 0;
-  });
-
-  test("readv with position", async () => {
-    const filename = getFileName();
-    await fs.writeFile(filename, expectedBuff);
-    const handle = await fs.open(filename, "r");
-    const bufferArr = allocateEmptyBuffers(expectedBuff.length);
-    const expectedLength = expectedBuff.length;
-
-    let { bytesRead, buffers } = await handle.readv([Buffer.from("")], null);
-    expect(bytesRead).toBe(0);
-    expect(buffers).toEqual([Buffer.from("")]);
-
-    ({ bytesRead, buffers } = await handle.readv(bufferArr, null));
-    expect(bytesRead).toBe(expectedLength);
-    expect(buffers).toEqual(bufferArr);
-    expect(Buffer.concat(bufferArr)).toEqual(await fs.readFile(filename));
-    await handle.close();
-  });
-
-  test("readv without position", async () => {
-    const filename = getFileName();
-    await fs.writeFile(filename, expectedBuff);
-    const handle = await fs.open(filename, "r");
-    const bufferArr = allocateEmptyBuffers(expectedBuff.length);
-    const expectedLength = expectedBuff.length;
-
-    let { bytesRead, buffers } = await handle.readv([Buffer.from("")]);
-    expect(bytesRead).toBe(0);
-    expect(buffers).toEqual([Buffer.from("")]);
-
-    ({ bytesRead, buffers } = await handle.readv(bufferArr));
-    expect(bytesRead).toBe(expectedLength);
-    expect(buffers).toEqual(bufferArr);
-    expect(Buffer.concat(bufferArr)).toEqual(await fs.readFile(filename));
-    await handle.close();
-  });
-});
-
-//<#END_FILE: test-fs-readv-promises.js
diff --git a/test/js/node/test/parallel/fs-readv-sync.test.js b/test/js/node/test/parallel/fs-readv-sync.test.js
deleted file mode 100644
index f4ab916f05..0000000000
--- a/test/js/node/test/parallel/fs-readv-sync.test.js
+++ /dev/null
@@ -1,104 +0,0 @@
-//#FILE: test-fs-readv-sync.js
-//#SHA1: e9a4527b118e4a814a04c976eaafb5127f7c7c9d
-//-----------------
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-const os = require("os");
-
-const expected = "ümlaut. Лорем 運務ホソモ指及 आपको करने विकास 紙読決多密所 أضف";
-
-const exptectedBuff = Buffer.from(expected);
-const expectedLength = exptectedBuff.length;
-
-let filename;
-let tmpdir;
-
-beforeAll(() => {
-  tmpdir = fs.mkdtempSync(path.join(os.tmpdir(), "test-fs-readv-sync-"));
-  filename = path.join(tmpdir, "readv_sync.txt");
-  fs.writeFileSync(filename, exptectedBuff);
-});
-
-afterAll(() => {
-  fs.rmSync(tmpdir, { recursive: true, force: true });
-});
-
-const allocateEmptyBuffers = combinedLength => {
-  const bufferArr = [];
-  // Allocate two buffers, each half the size of exptectedBuff
-  bufferArr[0] = Buffer.alloc(Math.floor(combinedLength / 2));
-  bufferArr[1] = Buffer.alloc(combinedLength - bufferArr[0].length);
-
-  return bufferArr;
-};
-
-// fs.readvSync with array of buffers with all parameters
-test("fs.readvSync with array of buffers with all parameters", () => {
-  const fd = fs.openSync(filename, "r");
-
-  const bufferArr = allocateEmptyBuffers(exptectedBuff.length);
-
-  let read = fs.readvSync(fd, [Buffer.from("")], 0);
-  expect(read).toBe(0);
-
-  read = fs.readvSync(fd, bufferArr, 0);
-  expect(read).toBe(expectedLength);
-
-  fs.closeSync(fd);
-
-  expect(Buffer.concat(bufferArr)).toEqual(fs.readFileSync(filename));
-});
-
-// fs.readvSync with array of buffers without position
-test("fs.readvSync with array of buffers without position", () => {
-  const fd = fs.openSync(filename, "r");
-
-  const bufferArr = allocateEmptyBuffers(exptectedBuff.length);
-
-  let read = fs.readvSync(fd, [Buffer.from("")]);
-  expect(read).toBe(0);
-
-  read = fs.readvSync(fd, bufferArr);
-  expect(read).toBe(expectedLength);
-
-  fs.closeSync(fd);
-
-  expect(Buffer.concat(bufferArr)).toEqual(fs.readFileSync(filename));
-});
-
-/**
- * Testing with incorrect arguments
- */
-const wrongInputs = [false, "test", {}, [{}], ["sdf"], null, undefined];
-
-test("fs.readvSync with incorrect arguments", () => {
-  const fd = fs.openSync(filename, "r");
-
-  for (const wrongInput of wrongInputs) {
-    expect(() => fs.readvSync(fd, wrongInput, null)).toThrow(
-      expect.objectContaining({
-        code: "ERR_INVALID_ARG_TYPE",
-        name: "TypeError",
-        message: expect.any(String),
-      }),
-    );
-  }
-
-  fs.closeSync(fd);
-});
-
-test("fs.readvSync with wrong fd argument", () => {
-  for (const wrongInput of wrongInputs) {
-    expect(() => fs.readvSync(wrongInput)).toThrow(
-      expect.objectContaining({
-        code: "ERR_INVALID_ARG_TYPE",
-        name: "TypeError",
-        message: expect.any(String),
-      }),
-    );
-  }
-});
-
-//<#END_FILE: test-fs-readv-sync.js
diff --git a/test/js/node/test/parallel/fs-readv.test.js b/test/js/node/test/parallel/fs-readv.test.js
deleted file mode 100644
index 58f9977c3b..0000000000
--- a/test/js/node/test/parallel/fs-readv.test.js
+++ /dev/null
@@ -1,110 +0,0 @@
-//#FILE: test-fs-readv.js
-//#SHA1: 07d6fe434017163aea491c98db8127bc2c942b96
-//-----------------
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-const os = require("os");
-
-const expected = "ümlaut. Лорем 運務ホソモ指及 आपको करने विकास 紙読決多密所 أضف";
-
-let cnt = 0;
-const getFileName = () => path.join(os.tmpdir(), `readv_${++cnt}.txt`);
-const expectedBuff = Buffer.from(expected);
-
-const allocateEmptyBuffers = combinedLength => {
-  const bufferArr = [];
-  // Allocate two buffers, each half the size of expectedBuff
-  bufferArr[0] = Buffer.alloc(Math.floor(combinedLength / 2));
-  bufferArr[1] = Buffer.alloc(combinedLength - bufferArr[0].length);
-
-  return bufferArr;
-};
-
-const getCallback = (fd, bufferArr) => {
-  return (err, bytesRead, buffers) => {
-    expect(err).toBeNull();
-    expect(bufferArr).toEqual(buffers);
-    const expectedLength = expectedBuff.length;
-    expect(bytesRead).toBe(expectedLength);
-    fs.closeSync(fd);
-
-    expect(Buffer.concat(bufferArr).equals(expectedBuff)).toBe(true);
-  };
-};
-
-beforeEach(() => {
-  jest.spyOn(fs, "writeSync");
-  jest.spyOn(fs, "writeFileSync");
-  jest.spyOn(fs, "openSync");
-  jest.spyOn(fs, "closeSync");
-});
-
-afterEach(() => {
-  jest.restoreAllMocks();
-});
-
-test("fs.readv with array of buffers with all parameters", done => {
-  const filename = getFileName();
-  const fd = fs.openSync(filename, "w+");
-  fs.writeSync(fd, expectedBuff);
-
-  const bufferArr = allocateEmptyBuffers(expectedBuff.length);
-  const callback = getCallback(fd, bufferArr);
-
-  fs.readv(fd, bufferArr, 0, (err, bytesRead, buffers) => {
-    callback(err, bytesRead, buffers);
-    done();
-  });
-});
-
-test("fs.readv with array of buffers without position", done => {
-  const filename = getFileName();
-  fs.writeFileSync(filename, expectedBuff);
-  const fd = fs.openSync(filename, "r");
-
-  const bufferArr = allocateEmptyBuffers(expectedBuff.length);
-  const callback = getCallback(fd, bufferArr);
-
-  fs.readv(fd, bufferArr, (err, bytesRead, buffers) => {
-    callback(err, bytesRead, buffers);
-    done();
-  });
-});
-
-describe("Testing with incorrect arguments", () => {
-  const wrongInputs = [false, "test", {}, [{}], ["sdf"], null, undefined];
-
-  test("fs.readv with wrong buffers argument", () => {
-    const filename = getFileName();
-    fs.writeFileSync(filename, expectedBuff);
-    const fd = fs.openSync(filename, "r");
-
-    for (const wrongInput of wrongInputs) {
-      expect(() => fs.readv(fd, wrongInput, null, jest.fn())).toThrow(
-        expect.objectContaining({
-          code: "ERR_INVALID_ARG_TYPE",
-          name: "TypeError",
-          message: expect.any(String),
-        }),
-      );
-    }
-
-    fs.closeSync(fd);
-  });
-
-  test("fs.readv with wrong fd argument", () => {
-    for (const wrongInput of wrongInputs) {
-      expect(() => fs.readv(wrongInput, jest.fn())).toThrow(
-        expect.objectContaining({
-          code: "ERR_INVALID_ARG_TYPE",
-          name: "TypeError",
-          message: expect.any(String),
-        }),
-      );
-    }
-  });
-});
-
-//<#END_FILE: test-fs-readv.js
diff --git a/test/js/node/test/parallel/fs-realpath-pipe.test.js b/test/js/node/test/parallel/fs-realpath-pipe.test.js
deleted file mode 100644
index 6c461e9d36..0000000000
--- a/test/js/node/test/parallel/fs-realpath-pipe.test.js
+++ /dev/null
@@ -1,47 +0,0 @@
-//#FILE: test-fs-realpath-pipe.js
-//#SHA1: 2a876967f5134cd77e2214f2abcbf753d46983cf
-//-----------------
-"use strict";
-
-const { spawnSync } = require("child_process");
-
-// Skip test for Windows, AIX, and IBMi
-const isSkippedPlatform = ["win32", "aix", "os400"].includes(process.platform);
-const testName = `No /dev/stdin on ${process.platform}.`;
-
-(isSkippedPlatform ? test.skip : test)(testName, () => {
-  const testCases = [
-    `require('fs').realpath('/dev/stdin', (err, resolvedPath) => {
-      if (err) {
-        console.error(err);
-        process.exit(1);
-      }
-      if (resolvedPath) {
-        process.exit(2);
-      }
-    });`,
-    `try {
-      if (require('fs').realpathSync('/dev/stdin')) {
-        process.exit(2);
-      }
-    } catch (e) {
-      console.error(e);
-      process.exit(1);
-    }`,
-  ];
-
-  for (const code of testCases) {
-    const child = spawnSync(process.execPath, ["-e", code], {
-      stdio: "pipe",
-    });
-
-    if (child.status !== 2) {
-      console.log(code);
-      console.log(child.stderr.toString());
-    }
-
-    expect(child.status).toBe(2);
-  }
-});
-
-//<#END_FILE: test-fs-realpath-pipe.js
diff --git a/test/js/node/test/parallel/fs-rmdir-type-check.test.js b/test/js/node/test/parallel/fs-rmdir-type-check.test.js
deleted file mode 100644
index 3148f0ba3a..0000000000
--- a/test/js/node/test/parallel/fs-rmdir-type-check.test.js
+++ /dev/null
@@ -1,28 +0,0 @@
-//#FILE: test-fs-rmdir-type-check.js
-//#SHA1: 2a00191160af6f0f76a82dcaef31d13c9b223d3b
-//-----------------
-"use strict";
-
-const fs = require("fs");
-
-test("fs.rmdir and fs.rmdirSync with invalid arguments", () => {
-  [false, 1, [], {}, null, undefined].forEach(i => {
-    expect(() => fs.rmdir(i, jest.fn())).toThrow(
-      expect.objectContaining({
-        code: "ERR_INVALID_ARG_TYPE",
-        name: "TypeError",
-        message: expect.any(String),
-      }),
-    );
-
-    expect(() => fs.rmdirSync(i)).toThrow(
-      expect.objectContaining({
-        code: "ERR_INVALID_ARG_TYPE",
-        name: "TypeError",
-        message: expect.any(String),
-      }),
-    );
-  });
-});
-
-//<#END_FILE: test-fs-rmdir-type-check.js
diff --git a/test/js/node/test/parallel/fs-stat-bigint.test.js b/test/js/node/test/parallel/fs-stat-bigint.test.js
deleted file mode 100644
index d7eb29c3f0..0000000000
--- a/test/js/node/test/parallel/fs-stat-bigint.test.js
+++ /dev/null
@@ -1,209 +0,0 @@
-//#FILE: test-fs-stat-bigint.js
-//#SHA1: c8ba0bacb927432a68a677cd3a304e8e058fb070
-//-----------------
-"use strict";
-
-const fs = require("fs");
-const promiseFs = require("fs").promises;
-const tmpdir = require("../common/tmpdir");
-const { isDate } = require("util").types;
-const { inspect } = require("util");
-
-tmpdir.refresh();
-
-let testIndex = 0;
-
-function getFilename() {
-  const filename = tmpdir.resolve(`test-file-${++testIndex}`);
-  fs.writeFileSync(filename, "test");
-  return filename;
-}
-
-function verifyStats(bigintStats, numStats, allowableDelta) {
-  // allowableDelta: It's possible that the file stats are updated between the
-  // two stat() calls so allow for a small difference.
-  for (const key of Object.keys(numStats)) {
-    const val = numStats[key];
-    if (isDate(val)) {
-      const time = val.getTime();
-      const time2 = bigintStats[key].getTime();
-      expect(time - time2).toBeLessThanOrEqual(allowableDelta);
-    } else if (key === "mode") {
-      expect(bigintStats[key]).toBe(BigInt(val));
-      expect(bigintStats.isBlockDevice()).toBe(numStats.isBlockDevice());
-      expect(bigintStats.isCharacterDevice()).toBe(numStats.isCharacterDevice());
-      expect(bigintStats.isDirectory()).toBe(numStats.isDirectory());
-      expect(bigintStats.isFIFO()).toBe(numStats.isFIFO());
-      expect(bigintStats.isFile()).toBe(numStats.isFile());
-      expect(bigintStats.isSocket()).toBe(numStats.isSocket());
-      expect(bigintStats.isSymbolicLink()).toBe(numStats.isSymbolicLink());
-    } else if (key.endsWith("Ms")) {
-      const nsKey = key.replace("Ms", "Ns");
-      const msFromBigInt = bigintStats[key];
-      const nsFromBigInt = bigintStats[nsKey];
-      const msFromBigIntNs = Number(nsFromBigInt / 10n ** 6n);
-      const msFromNum = numStats[key];
-
-      expect(msFromNum - Number(msFromBigInt)).toBeLessThanOrEqual(allowableDelta);
-      expect(msFromNum - Number(msFromBigIntNs)).toBeLessThanOrEqual(allowableDelta);
-    } else if (Number.isSafeInteger(val)) {
-      expect(bigintStats[key]).toBe(BigInt(val));
-    } else {
-      expect(Number(bigintStats[key]) - val).toBeLessThan(1);
-    }
-  }
-}
-
-const runSyncTest = (func, arg) => {
-  const startTime = process.hrtime.bigint();
-  const bigintStats = func(arg, { bigint: true });
-  const numStats = func(arg);
-  const endTime = process.hrtime.bigint();
-  const allowableDelta = Math.ceil(Number(endTime - startTime) / 1e6);
-  verifyStats(bigintStats, numStats, allowableDelta);
-};
-
-test("fs.statSync", () => {
-  const filename = getFilename();
-  runSyncTest(fs.statSync, filename);
-});
-
-if (!process.platform.startsWith("win")) {
-  test("fs.lstatSync", () => {
-    const filename = getFilename();
-    const link = `${filename}-link`;
-    fs.symlinkSync(filename, link);
-    runSyncTest(fs.lstatSync, link);
-  });
-}
-
-test("fs.fstatSync", () => {
-  const filename = getFilename();
-  const fd = fs.openSync(filename, "r");
-  runSyncTest(fs.fstatSync, fd);
-  fs.closeSync(fd);
-});
-
-test("fs.statSync with non-existent file", () => {
-  expect(() => fs.statSync("does_not_exist")).toThrow(expect.objectContaining({ code: "ENOENT" }));
-  expect(fs.statSync("does_not_exist", { throwIfNoEntry: false })).toBeUndefined();
-});
-
-test("fs.lstatSync with non-existent file", () => {
-  expect(() => fs.lstatSync("does_not_exist")).toThrow(expect.objectContaining({ code: "ENOENT" }));
-  expect(fs.lstatSync("does_not_exist", { throwIfNoEntry: false })).toBeUndefined();
-});
-
-test("fs.fstatSync with invalid file descriptor", () => {
-  expect(() => fs.fstatSync(9999)).toThrow(expect.objectContaining({ code: "EBADF" }));
-  expect(() => fs.fstatSync(9999, { throwIfNoEntry: false })).toThrow(expect.objectContaining({ code: "EBADF" }));
-});
-
-const runCallbackTest = (func, arg) => {
-  return new Promise(resolve => {
-    const startTime = process.hrtime.bigint();
-    func(arg, { bigint: true }, (err, bigintStats) => {
-      expect(err).toBeFalsy();
-      func(arg, (err, numStats) => {
-        expect(err).toBeFalsy();
-        const endTime = process.hrtime.bigint();
-        const allowableDelta = Math.ceil(Number(endTime - startTime) / 1e6);
-        verifyStats(bigintStats, numStats, allowableDelta);
-        resolve();
-      });
-    });
-  });
-};
-
-test("fs.stat callback", async () => {
-  const filename = getFilename();
-  await runCallbackTest(fs.stat, filename);
-});
-
-if (!process.platform.startsWith("win")) {
-  test("fs.lstat callback", async () => {
-    const filename = getFilename();
-    const link = `${filename}-link`;
-    fs.symlinkSync(filename, link);
-    await runCallbackTest(fs.lstat, link);
-  });
-}
-
-test("fs.fstat callback", async () => {
-  const filename = getFilename();
-  const fd = fs.openSync(filename, "r");
-  await runCallbackTest(fs.fstat, fd);
-  fs.closeSync(fd);
-});
-
-const runPromiseTest = async (func, arg) => {
-  const startTime = process.hrtime.bigint();
-  const bigintStats = await func(arg, { bigint: true });
-  const numStats = await func(arg);
-  const endTime = process.hrtime.bigint();
-  const allowableDelta = Math.ceil(Number(endTime - startTime) / 1e6);
-  verifyStats(bigintStats, numStats, allowableDelta);
-};
-
-test("promiseFs.stat", async () => {
-  const filename = getFilename();
-  await runPromiseTest(promiseFs.stat, filename);
-});
-
-if (!process.platform.startsWith("win")) {
-  test("promiseFs.lstat", async () => {
-    const filename = getFilename();
-    const link = `${filename}-link`;
-    fs.symlinkSync(filename, link);
-    await runPromiseTest(promiseFs.lstat, link);
-  });
-}
-
-test("promiseFs handle.stat", async () => {
-  const filename = getFilename();
-  const handle = await promiseFs.open(filename, "r");
-  const startTime = process.hrtime.bigint();
-  const bigintStats = await handle.stat({ bigint: true });
-  const numStats = await handle.stat();
-  const endTime = process.hrtime.bigint();
-  const allowableDelta = Math.ceil(Number(endTime - startTime) / 1e6);
-  verifyStats(bigintStats, numStats, allowableDelta);
-  await handle.close();
-});
-
-test("BigIntStats Date properties can be set before reading them", done => {
-  fs.stat(__filename, { bigint: true }, (err, s) => {
-    expect(err).toBeFalsy();
-    s.atime = 2;
-    s.mtime = 3;
-    s.ctime = 4;
-    s.birthtime = 5;
-
-    expect(s.atime).toBe(2);
-    expect(s.mtime).toBe(3);
-    expect(s.ctime).toBe(4);
-    expect(s.birthtime).toBe(5);
-    done();
-  });
-});
-
-test("BigIntStats Date properties can be set after reading them", done => {
-  fs.stat(__filename, { bigint: true }, (err, s) => {
-    expect(err).toBeFalsy();
-    // eslint-disable-next-line no-unused-expressions
-    s.atime, s.mtime, s.ctime, s.birthtime;
-
-    s.atime = 2;
-    s.mtime = 3;
-    s.ctime = 4;
-    s.birthtime = 5;
-
-    expect(s.atime).toBe(2);
-    expect(s.mtime).toBe(3);
-    expect(s.ctime).toBe(4);
-    expect(s.birthtime).toBe(5);
-    done();
-  });
-});
-
-//<#END_FILE: test-fs-stat-bigint.js
diff --git a/test/js/node/test/parallel/fs-stream-double-close.test.js b/test/js/node/test/parallel/fs-stream-double-close.test.js
deleted file mode 100644
index 0e89c7bf26..0000000000
--- a/test/js/node/test/parallel/fs-stream-double-close.test.js
+++ /dev/null
@@ -1,84 +0,0 @@
-//#FILE: test-fs-stream-double-close.js
-//#SHA1: 25fa219f7ee462e67611751f996393afc1869490
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const fs = require("fs");
-const path = require("path");
-const os = require("os");
-
-const tmpdir = path.join(os.tmpdir(), "node-test-fs-stream-double-close");
-beforeAll(() => {
-  if (!fs.existsSync(tmpdir)) {
-    fs.mkdirSync(tmpdir, { recursive: true });
-  }
-});
-
-afterAll(() => {
-  fs.rmSync(tmpdir, { recursive: true, force: true });
-});
-
-test("test1 with ReadStream", () => {
-  test1(fs.createReadStream(__filename));
-});
-
-test("test2 with ReadStream", () => {
-  test2(fs.createReadStream(__filename));
-});
-
-test("test3 with ReadStream", () => {
-  test3(fs.createReadStream(__filename));
-});
-
-test("test1 with WriteStream", () => {
-  test1(fs.createWriteStream(path.join(tmpdir, "dummy1")));
-});
-
-test("test2 with WriteStream", () => {
-  test2(fs.createWriteStream(path.join(tmpdir, "dummy2")));
-});
-
-test("test3 with WriteStream", () => {
-  test3(fs.createWriteStream(path.join(tmpdir, "dummy3")));
-});
-
-function test1(stream) {
-  stream.destroy();
-  stream.destroy();
-}
-
-function test2(stream) {
-  stream.destroy();
-  stream.on("open", jest.fn());
-}
-
-function test3(stream) {
-  const openHandler = jest.fn();
-  stream.on("open", openHandler);
-  stream.emit("open");
-  expect(openHandler).toHaveBeenCalledTimes(1);
-  stream.destroy();
-  stream.destroy();
-}
-
-//<#END_FILE: test-fs-stream-double-close.js
diff --git a/test/js/node/test/parallel/fs-symlink.test.js b/test/js/node/test/parallel/fs-symlink.test.js
deleted file mode 100644
index c4e68336ba..0000000000
--- a/test/js/node/test/parallel/fs-symlink.test.js
+++ /dev/null
@@ -1,148 +0,0 @@
-//#FILE: test-fs-symlink.js
-//#SHA1: 4861a453e314d789a1b933d7179da96b7a35378c
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const fs = require("fs");
-const path = require("path");
-const os = require("os");
-
-const canCreateSymLink = () => {
-  try {
-    fs.symlinkSync("", "");
-    fs.unlinkSync("");
-    return true;
-  } catch (e) {
-    return false;
-  }
-};
-
-if (!canCreateSymLink()) {
-  it.skip("insufficient privileges", () => {});
-} else {
-  let linkTime;
-  let fileTime;
-  const tmpdir = os.tmpdir();
-
-  beforeEach(() => {
-    jest.spyOn(fs, "symlink");
-    jest.spyOn(fs, "lstat");
-    jest.spyOn(fs, "stat");
-    jest.spyOn(fs, "readlink");
-  });
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  test("Test creating and reading symbolic link", async () => {
-    const linkData = path.resolve(__dirname, "../fixtures/cycles/root.js");
-    const linkPath = path.resolve(tmpdir, "symlink1.js");
-
-    await new Promise(resolve => {
-      fs.symlink(linkData, linkPath, resolve);
-    });
-
-    expect(fs.symlink).toHaveBeenCalled();
-
-    await new Promise(resolve => {
-      fs.lstat(linkPath, (err, stats) => {
-        expect(err).toBeNull();
-        linkTime = stats.mtime.getTime();
-        resolve();
-      });
-    });
-
-    await new Promise(resolve => {
-      fs.stat(linkPath, (err, stats) => {
-        expect(err).toBeNull();
-        fileTime = stats.mtime.getTime();
-        resolve();
-      });
-    });
-
-    await new Promise(resolve => {
-      fs.readlink(linkPath, (err, destination) => {
-        expect(err).toBeNull();
-        expect(destination).toBe(linkData);
-        resolve();
-      });
-    });
-  });
-
-  test("Test invalid symlink", async () => {
-    const linkData = path.resolve(__dirname, "../fixtures/not/exists/file");
-    const linkPath = path.resolve(tmpdir, "symlink2.js");
-
-    await new Promise(resolve => {
-      fs.symlink(linkData, linkPath, resolve);
-    });
-
-    expect(fs.existsSync(linkPath)).toBe(false);
-  });
-
-  test("Test invalid inputs", () => {
-    const invalidInputs = [false, 1, {}, [], null, undefined];
-    const errObj = expect.objectContaining({
-      code: "ERR_INVALID_ARG_TYPE",
-      name: "TypeError",
-      message: expect.stringMatching(/target|path/),
-    });
-
-    invalidInputs.forEach(input => {
-      expect(() => fs.symlink(input, "", () => {})).toThrow(errObj);
-      expect(() => fs.symlinkSync(input, "")).toThrow(errObj);
-
-      expect(() => fs.symlink("", input, () => {})).toThrow(errObj);
-      expect(() => fs.symlinkSync("", input)).toThrow(errObj);
-    });
-  });
-
-  test("Test invalid type inputs", () => {
-    const errObj = expect.objectContaining({
-      code: "ERR_INVALID_ARG_VALUE",
-      name: "TypeError",
-    });
-
-    expect(() => fs.symlink("", "", "🍏", () => {})).toThrow(errObj);
-    expect(() => fs.symlinkSync("", "", "🍏")).toThrow(errObj);
-
-    expect(() => fs.symlink("", "", "nonExistentType", () => {})).toThrow(errObj);
-    expect(() => fs.symlinkSync("", "", "nonExistentType")).toThrow(errObj);
-    expect(fs.promises.symlink("", "", "nonExistentType")).rejects.toMatchObject(errObj);
-
-    expect(() => fs.symlink("", "", false, () => {})).toThrow(errObj);
-    expect(() => fs.symlinkSync("", "", false)).toThrow(errObj);
-    expect(fs.promises.symlink("", "", false)).rejects.toMatchObject(errObj);
-
-    expect(() => fs.symlink("", "", {}, () => {})).toThrow(errObj);
-    expect(() => fs.symlinkSync("", "", {})).toThrow(errObj);
-    expect(fs.promises.symlink("", "", {})).rejects.toMatchObject(errObj);
-  });
-
-  test("Link time should not be equal to file time", () => {
-    expect(linkTime).not.toBe(fileTime);
-  });
-}
-
-//<#END_FILE: test-fs-symlink.js
diff --git a/test/js/node/test/parallel/fs-truncate-clear-file-zero.test.js b/test/js/node/test/parallel/fs-truncate-clear-file-zero.test.js
deleted file mode 100644
index 8dc9566b1f..0000000000
--- a/test/js/node/test/parallel/fs-truncate-clear-file-zero.test.js
+++ /dev/null
@@ -1,67 +0,0 @@
-//#FILE: test-fs-truncate-clear-file-zero.js
-//#SHA1: 28aa057c9903ea2436c340ccecfec093c647714c
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-const os = require("os");
-
-// This test ensures that `fs.truncate` opens the file with `r+` and not `w`,
-// which had earlier resulted in the target file's content getting zeroed out.
-// https://github.com/nodejs/node-v0.x-archive/issues/6233
-
-const filename = path.join(os.tmpdir(), "truncate-file.txt");
-
-beforeEach(() => {
-  // Clean up any existing test file
-  try {
-    fs.unlinkSync(filename);
-  } catch (err) {
-    if (err.code !== "ENOENT") throw err;
-  }
-});
-
-test("fs.truncateSync", () => {
-  fs.writeFileSync(filename, "0123456789");
-  expect(fs.readFileSync(filename, "utf8")).toBe("0123456789");
-  fs.truncateSync(filename, 5);
-  expect(fs.readFileSync(filename, "utf8")).toBe("01234");
-});
-
-test("fs.truncate", async () => {
-  fs.writeFileSync(filename, "0123456789");
-  expect(fs.readFileSync(filename, "utf8")).toBe("0123456789");
-
-  await new Promise((resolve, reject) => {
-    fs.truncate(filename, 5, err => {
-      if (err) reject(err);
-      else resolve();
-    });
-  });
-
-  expect(fs.readFileSync(filename, "utf8")).toBe("01234");
-});
-
-//<#END_FILE: test-fs-truncate-clear-file-zero.js
diff --git a/test/js/node/test/parallel/fs-truncate-sync.test.js b/test/js/node/test/parallel/fs-truncate-sync.test.js
deleted file mode 100644
index cdf9a5f739..0000000000
--- a/test/js/node/test/parallel/fs-truncate-sync.test.js
+++ /dev/null
@@ -1,31 +0,0 @@
-//#FILE: test-fs-truncate-sync.js
-//#SHA1: 6b4ccbf9b9fab199c6b258374cf0a1665b1c21fe
-//-----------------
-"use strict";
-
-const path = require("path");
-const fs = require("fs");
-const tmpdir = require("../common/tmpdir");
-const tmp = tmpdir.path;
-
-describe("fs.truncateSync", () => {
-  beforeEach(() => {
-    tmpdir.refresh();
-  });
-
-  test("truncates file correctly", () => {
-    const filename = path.resolve(tmp, "truncate-sync-file.txt");
-
-    fs.writeFileSync(filename, "hello world", "utf8");
-
-    const fd = fs.openSync(filename, "r+");
-
-    fs.truncateSync(fd, 5);
-    expect(fs.readFileSync(fd)).toEqual(Buffer.from("hello"));
-
-    fs.closeSync(fd);
-    fs.unlinkSync(filename);
-  });
-});
-
-//<#END_FILE: test-fs-truncate-sync.js
diff --git a/test/js/node/test/parallel/fs-unlink-type-check.test.js b/test/js/node/test/parallel/fs-unlink-type-check.test.js
deleted file mode 100644
index 4f819feecd..0000000000
--- a/test/js/node/test/parallel/fs-unlink-type-check.test.js
+++ /dev/null
@@ -1,30 +0,0 @@
-//#FILE: test-fs-unlink-type-check.js
-//#SHA1: 337e42f3b15589a7652c32c0a1c92292abf098d0
-//-----------------
-"use strict";
-
-const fs = require("fs");
-
-test("fs.unlink and fs.unlinkSync with invalid types", () => {
-  const invalidTypes = [false, 1, {}, [], null, undefined];
-
-  invalidTypes.forEach(invalidType => {
-    expect(() => fs.unlink(invalidType, jest.fn())).toThrow(
-      expect.objectContaining({
-        code: "ERR_INVALID_ARG_TYPE",
-        name: "TypeError",
-        message: expect.any(String),
-      }),
-    );
-
-    expect(() => fs.unlinkSync(invalidType)).toThrow(
-      expect.objectContaining({
-        code: "ERR_INVALID_ARG_TYPE",
-        name: "TypeError",
-        message: expect.any(String),
-      }),
-    );
-  });
-});
-
-//<#END_FILE: test-fs-unlink-type-check.js
diff --git a/test/js/node/test/parallel/fs-watch-close-when-destroyed.test.js b/test/js/node/test/parallel/fs-watch-close-when-destroyed.test.js
deleted file mode 100644
index 5749125642..0000000000
--- a/test/js/node/test/parallel/fs-watch-close-when-destroyed.test.js
+++ /dev/null
@@ -1,63 +0,0 @@
-//#FILE: test-fs-watch-close-when-destroyed.js
-//#SHA1: f062b7243d0c42722a289a6228d4c2c1a503be1b
-//-----------------
-"use strict";
-
-// This tests that closing a watcher when the underlying handle is
-// already destroyed will result in a noop instead of a crash.
-
-const fs = require("fs");
-const path = require("path");
-const os = require("os");
-
-// fs-watch on folders have limited capability in AIX.
-// The testcase makes use of folder watching, and causes
-// hang. This behavior is documented. Skip this for AIX.
-
-if (process.platform === "aix") {
-  it.skip("folder watch capability is limited in AIX.");
-} else if (process.platform === "os400") {
-  it.skip("IBMi does not support `fs.watch()`");
-} else {
-  let root;
-
-  beforeEach(() => {
-    root = path.join(os.tmpdir(), "watched-directory-" + Math.random().toString(36).slice(2));
-    fs.mkdirSync(root);
-  });
-
-  afterEach(() => {
-    try {
-      fs.rmdirSync(root);
-    } catch (error) {
-      // Ignore errors, directory might already be removed
-    }
-  });
-
-  it("should not crash when closing watcher after handle is destroyed", done => {
-    const watcher = fs.watch(root, { persistent: false, recursive: false });
-
-    // The following listeners may or may not be invoked.
-
-    watcher.addListener("error", () => {
-      setTimeout(
-        () => {
-          watcher.close();
-        }, // Should not crash if it's invoked
-        10,
-      );
-    });
-
-    watcher.addListener("change", () => {
-      setTimeout(() => {
-        watcher.close();
-      }, 10);
-    });
-
-    fs.rmdirSync(root);
-    // Wait for the listener to hit
-    setTimeout(done, 100);
-  });
-}
-
-//<#END_FILE: test-fs-watch-close-when-destroyed.js
diff --git a/test/js/node/test/parallel/fs-watch-file-enoent-after-deletion.test.js b/test/js/node/test/parallel/fs-watch-file-enoent-after-deletion.test.js
deleted file mode 100644
index ee439c8272..0000000000
--- a/test/js/node/test/parallel/fs-watch-file-enoent-after-deletion.test.js
+++ /dev/null
@@ -1,65 +0,0 @@
-//#FILE: test-fs-watch-file-enoent-after-deletion.js
-//#SHA1: d6c93db608d119bd35fcab0e1e9307bfd6558b68
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-const os = require("os");
-
-// Make sure the deletion event gets reported in the following scenario:
-// 1. Watch a file.
-// 2. The initial stat() goes okay.
-// 3. Something deletes the watched file.
-// 4. The second stat() fails with ENOENT.
-
-// The second stat() translates into the first 'change' event but a logic error
-// stopped it from getting emitted.
-// https://github.com/nodejs/node-v0.x-archive/issues/4027
-
-test("fs.watchFile reports deletion", done => {
-  const tmpdir = fs.mkdtempSync(path.join(os.tmpdir(), "test-"));
-  const filename = path.join(tmpdir, "watched");
-  fs.writeFileSync(filename, "quis custodiet ipsos custodes");
-
-  const watcher = jest.fn();
-  fs.watchFile(filename, { interval: 50 }, watcher);
-
-  setTimeout(() => {
-    fs.unlinkSync(filename);
-
-    setTimeout(() => {
-      expect(watcher).toHaveBeenCalledTimes(1);
-      const [curr, prev] = watcher.mock.calls[0];
-      expect(curr.nlink).toBe(0);
-      expect(prev.nlink).toBe(1);
-
-      fs.unwatchFile(filename);
-      fs.rmdirSync(tmpdir);
-      done();
-    }, 100);
-  }, 100);
-});
-
-//<#END_FILE: test-fs-watch-file-enoent-after-deletion.js
diff --git a/test/js/node/test/parallel/fs-watch-recursive-add-file-with-url.test.js b/test/js/node/test/parallel/fs-watch-recursive-add-file-with-url.test.js
deleted file mode 100644
index 2131b1dbe5..0000000000
--- a/test/js/node/test/parallel/fs-watch-recursive-add-file-with-url.test.js
+++ /dev/null
@@ -1,55 +0,0 @@
-//#FILE: test-fs-watch-recursive-add-file-with-url.js
-//#SHA1: e6498ea80abdf69cb66d888bbd7d631931970c0a
-//-----------------
-"use strict";
-
-const { setTimeout } = require("timers/promises");
-const path = require("path");
-const fs = require("fs");
-const { pathToFileURL } = require("url");
-const os = require("os");
-
-const isIBMi = process.platform === "os400";
-const isAIX = process.platform === "aix";
-
-if (isIBMi) {
-  it.skip("IBMi does not support `fs.watch()`", () => {});
-} else if (isAIX) {
-  it.skip("folder watch capability is limited in AIX.", () => {});
-} else {
-  it("should watch for file changes using URL as path", async () => {
-    const testDir = fs.mkdtempSync(path.join(os.tmpdir(), "test-"));
-
-    // Add a file to already watching folder, and use URL as the path
-    const rootDirectory = fs.mkdtempSync(path.join(testDir, path.sep));
-    const testDirectory = path.join(rootDirectory, "test-5");
-    fs.mkdirSync(testDirectory);
-
-    const filePath = path.join(testDirectory, "file-8.txt");
-    const url = pathToFileURL(testDirectory);
-
-    const watcher = fs.watch(url, { recursive: true });
-    let watcherClosed = false;
-
-    const watchPromise = new Promise(resolve => {
-      watcher.on("change", function (event, filename) {
-        expect(event).toBe("rename");
-
-        if (filename === path.basename(filePath)) {
-          watcher.close();
-          watcherClosed = true;
-          resolve();
-        }
-      });
-    });
-
-    await setTimeout(100);
-    fs.writeFileSync(filePath, "world");
-
-    await watchPromise;
-
-    expect(watcherClosed).toBe(true);
-  }, 10000); // Increase timeout to 10 seconds
-}
-
-//<#END_FILE: test-fs-watch-recursive-add-file-with-url.js
diff --git a/test/js/node/test/parallel/fs-watch-recursive-add-file.test.js b/test/js/node/test/parallel/fs-watch-recursive-add-file.test.js
deleted file mode 100644
index 00c5fcf7e6..0000000000
--- a/test/js/node/test/parallel/fs-watch-recursive-add-file.test.js
+++ /dev/null
@@ -1,63 +0,0 @@
-//#FILE: test-fs-watch-recursive-add-file.js
-//#SHA1: e87d2c9f4789a6e6a83fbdca56e39683625bd0af
-//-----------------
-"use strict";
-
-const path = require("path");
-const fs = require("fs");
-const os = require("os");
-
-const isIBMi = os.platform() === "os400";
-const isAIX = os.platform() === "aix";
-
-if (isIBMi) {
-  it.skip("IBMi does not support `fs.watch()`", () => {});
-} else if (isAIX) {
-  it.skip("folder watch capability is limited in AIX.", () => {});
-} else {
-  const tmpdir = {
-    path: path.join(os.tmpdir(), "jest-test-fs-watch-recursive-add-file"),
-    refresh: () => {
-      if (fs.existsSync(tmpdir.path)) {
-        fs.rmSync(tmpdir.path, { recursive: true, force: true });
-      }
-      fs.mkdirSync(tmpdir.path, { recursive: true });
-    },
-  };
-
-  beforeEach(() => {
-    tmpdir.refresh();
-  });
-
-  it("should detect file added to already watching folder", done => {
-    const rootDirectory = fs.mkdtempSync(tmpdir.path + path.sep);
-    const testDirectory = path.join(rootDirectory, "test-1");
-    fs.mkdirSync(testDirectory);
-
-    const testFile = path.join(testDirectory, "file-1.txt");
-
-    const watcher = fs.watch(testDirectory, { recursive: true });
-    let watcherClosed = false;
-
-    watcher.on("change", function (event, filename) {
-      expect(event).toBe("rename");
-
-      if (filename === path.basename(testFile)) {
-        watcher.close();
-        watcherClosed = true;
-        expect(watcherClosed).toBe(true);
-        done();
-      }
-    });
-
-    // Do the write with a delay to ensure that the OS is ready to notify us.
-    setTimeout(
-      () => {
-        fs.writeFileSync(testFile, "world");
-      },
-      process.platform === "win32" ? 200 : 100,
-    );
-  });
-}
-
-//<#END_FILE: test-fs-watch-recursive-add-file.js
diff --git a/test/js/node/test/parallel/fs-watch-recursive-add-folder.test.js b/test/js/node/test/parallel/fs-watch-recursive-add-folder.test.js
deleted file mode 100644
index dbe75002f5..0000000000
--- a/test/js/node/test/parallel/fs-watch-recursive-add-folder.test.js
+++ /dev/null
@@ -1,59 +0,0 @@
-//#FILE: test-fs-watch-recursive-add-folder.js
-//#SHA1: 4c2908ccc8502f5f760963a9b9a6db6ddadd4c1c
-//-----------------
-"use strict";
-
-const { setTimeout } = require("timers/promises");
-const assert = require("assert");
-const path = require("path");
-const fs = require("fs");
-const os = require("os");
-
-const isIBMi = os.platform() === "os400";
-const isAIX = os.platform() === "aix";
-
-if (isIBMi) {
-  it.skip("IBMi does not support `fs.watch()`", () => {});
-} else if (isAIX) {
-  it.skip("folder watch capability is limited in AIX.", () => {});
-} else {
-  const testDir = fs.mkdtempSync(path.join(os.tmpdir(), "test-"));
-
-  afterAll(() => {
-    fs.rmSync(testDir, { recursive: true, force: true });
-  });
-
-  test("Add a folder to already watching folder", async () => {
-    // Add a folder to already watching folder
-
-    const rootDirectory = fs.mkdtempSync(path.join(testDir, "root-"));
-    const testDirectory = path.join(rootDirectory, "test-2");
-    fs.mkdirSync(testDirectory);
-
-    const testFile = path.join(testDirectory, "folder-2");
-
-    const watcher = fs.watch(testDirectory, { recursive: true });
-    let watcherClosed = false;
-
-    const watchPromise = new Promise(resolve => {
-      watcher.on("change", function (event, filename) {
-        expect(event).toBe("rename");
-
-        if (filename === path.basename(testFile)) {
-          watcher.close();
-          watcherClosed = true;
-          resolve();
-        }
-      });
-    });
-
-    await setTimeout(100);
-    fs.mkdirSync(testFile);
-
-    await watchPromise;
-
-    expect(watcherClosed).toBe(true);
-  });
-}
-
-//<#END_FILE: test-fs-watch-recursive-add-folder.js
diff --git a/test/js/node/test/parallel/fs-watch-recursive-linux-parallel-remove.test.js b/test/js/node/test/parallel/fs-watch-recursive-linux-parallel-remove.test.js
deleted file mode 100644
index b109622f57..0000000000
--- a/test/js/node/test/parallel/fs-watch-recursive-linux-parallel-remove.test.js
+++ /dev/null
@@ -1,59 +0,0 @@
-//#FILE: test-fs-watch-recursive-linux-parallel-remove.js
-//#SHA1: ed10536d8d54febe24a3dcf494a26eab06bc4f66
-//-----------------
-"use strict";
-
-const path = require("node:path");
-const fs = require("node:fs");
-const { spawn } = require("node:child_process");
-const os = require("node:os");
-
-// Skip test if not running on Linux
-if (os.platform() !== "linux") {
-  test.skip("This test can run only on Linux", () => {});
-} else {
-  // Test that the watcher do not crash if the file "disappears" while
-  // watch is being set up.
-
-  let testDir;
-  let watcher;
-
-  beforeEach(() => {
-    testDir = fs.mkdtempSync(path.join(os.tmpdir(), "test-"));
-  });
-
-  afterEach(() => {
-    if (watcher) {
-      watcher.close();
-    }
-    fs.rmSync(testDir, { recursive: true, force: true });
-  });
-
-  test("fs.watch does not crash on parallel file removal", done => {
-    watcher = fs.watch(testDir, { recursive: true });
-    watcher.on("change", function (event, filename) {
-      // This console.log makes the error happen
-      // do not remove
-      console.log(filename, event);
-    });
-
-    const testFile = path.join(testDir, "a");
-    const child = spawn(
-      process.argv[0],
-      [
-        "-e",
-        `const fs = require('node:fs'); for (let i = 0; i < 10000; i++) { const fd = fs.openSync('${testFile}', 'w'); fs.writeSync(fd, Buffer.from('hello')); fs.rmSync('${testFile}') }`,
-      ],
-      {
-        stdio: "inherit",
-      },
-    );
-
-    child.on("exit", function () {
-      watcher.close();
-      done();
-    });
-  });
-}
-
-//<#END_FILE: test-fs-watch-recursive-linux-parallel-remove.js
diff --git a/test/js/node/test/parallel/fs-watch-recursive-validate.test.js b/test/js/node/test/parallel/fs-watch-recursive-validate.test.js
deleted file mode 100644
index aeed19b67d..0000000000
--- a/test/js/node/test/parallel/fs-watch-recursive-validate.test.js
+++ /dev/null
@@ -1,49 +0,0 @@
-//#FILE: test-fs-watch-recursive-validate.js
-//#SHA1: eb5d9ff1caac7f9d4acf694c43e4f634f538befb
-//-----------------
-"use strict";
-
-const path = require("path");
-const fs = require("fs");
-const os = require("os");
-
-const isIBMi = process.platform === "os400";
-const isAIX = process.platform === "aix";
-const isWindows = process.platform === "win32";
-const isOSX = process.platform === "darwin";
-
-if (isIBMi) {
-  test.skip("IBMi does not support `fs.watch()`", () => {});
-} else if (isAIX) {
-  test.skip("folder watch capability is limited in AIX.", () => {});
-} else {
-  const tmpdir = {
-    path: path.join(os.tmpdir(), "jest-fs-watch-recursive-validate"),
-    refresh: () => {
-      if (fs.existsSync(tmpdir.path)) {
-        fs.rmSync(tmpdir.path, { recursive: true, force: true });
-      }
-      fs.mkdirSync(tmpdir.path, { recursive: true });
-    },
-  };
-
-  beforeEach(() => {
-    tmpdir.refresh();
-  });
-
-  test("Handle non-boolean values for options.recursive", async () => {
-    if (!isWindows && !isOSX) {
-      expect(() => {
-        const testsubdir = fs.mkdtempSync(tmpdir.path + path.sep);
-        fs.watch(testsubdir, { recursive: "1" });
-      }).toThrow(
-        expect.objectContaining({
-          code: "ERR_INVALID_ARG_TYPE",
-          message: expect.any(String),
-        }),
-      );
-    }
-  });
-}
-
-//<#END_FILE: test-fs-watch-recursive-validate.js
diff --git a/test/js/node/test/parallel/fs-watch-recursive-watch-file.test.js b/test/js/node/test/parallel/fs-watch-recursive-watch-file.test.js
deleted file mode 100644
index bf7b6e0212..0000000000
--- a/test/js/node/test/parallel/fs-watch-recursive-watch-file.test.js
+++ /dev/null
@@ -1,66 +0,0 @@
-//#FILE: test-fs-watch-recursive-watch-file.js
-//#SHA1: 1f06958f6f645cb5c80b424a24b046f107ab83ae
-//-----------------
-"use strict";
-
-const path = require("path");
-const fs = require("fs");
-const os = require("os");
-
-const isIBMi = os.platform() === "os400";
-const isAIX = os.platform() === "aix";
-
-if (isIBMi) {
-  test.skip("IBMi does not support `fs.watch()`");
-}
-
-// fs-watch on folders have limited capability in AIX.
-// The testcase makes use of folder watching, and causes
-// hang. This behavior is documented. Skip this for AIX.
-
-if (isAIX) {
-  test.skip("folder watch capability is limited in AIX.");
-}
-
-const platformTimeout = ms => ms * (process.platform === "win32" ? 2 : 1);
-
-test("Watch a file (not a folder) using fs.watch", async () => {
-  // Create a temporary directory for testing
-  const testDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "test-"));
-  const rootDirectory = await fs.promises.mkdtemp(path.join(testDir, path.sep));
-  const testDirectory = path.join(rootDirectory, "test-6");
-  await fs.promises.mkdir(testDirectory);
-
-  const filePath = path.join(testDirectory, "only-file.txt");
-  await fs.promises.writeFile(filePath, "hello");
-
-  let watcherClosed = false;
-  let interval;
-
-  const watcher = fs.watch(filePath, { recursive: true });
-
-  const watchPromise = new Promise(resolve => {
-    watcher.on("change", function (event, filename) {
-      expect(event).toBe("change");
-
-      if (filename === path.basename(filePath)) {
-        clearInterval(interval);
-        interval = null;
-        watcher.close();
-        watcherClosed = true;
-        resolve();
-      }
-    });
-  });
-
-  interval = setInterval(() => {
-    fs.writeFileSync(filePath, "world");
-  }, platformTimeout(10));
-
-  await watchPromise;
-
-  expect(watcherClosed).toBe(true);
-  expect(interval).toBeNull();
-});
-
-//<#END_FILE: test-fs-watch-recursive-watch-file.js
diff --git a/test/js/node/test/parallel/fs-watch-ref-unref.test.js b/test/js/node/test/parallel/fs-watch-ref-unref.test.js
deleted file mode 100644
index c8d92a6eaa..0000000000
--- a/test/js/node/test/parallel/fs-watch-ref-unref.test.js
+++ /dev/null
@@ -1,32 +0,0 @@
-//#FILE: test-fs-watch-ref-unref.js
-//#SHA1: ffceabfd7f8fef655b05735b8bba7fb059609980
-//-----------------
-"use strict";
-
-const fs = require("fs");
-
-if (process.platform === "os400") {
-  test.skip("IBMi does not support `fs.watch()`");
-}
-
-test("fs.watch() can be unref()ed and ref()ed", () => {
-  const watcher = fs.watch(__filename, () => {
-    // This callback should not be called
-    expect(true).toBe(false);
-  });
-
-  watcher.unref();
-
-  return new Promise(resolve => {
-    setTimeout(
-      () => {
-        watcher.ref();
-        watcher.unref();
-        resolve();
-      },
-      process.platform === "win32" ? 100 : 50,
-    );
-  });
-});
-
-//<#END_FILE: test-fs-watch-ref-unref.js
diff --git a/test/js/node/test/parallel/fs-watch-stop-sync.test.js b/test/js/node/test/parallel/fs-watch-stop-sync.test.js
deleted file mode 100644
index fe1eae0f1c..0000000000
--- a/test/js/node/test/parallel/fs-watch-stop-sync.test.js
+++ /dev/null
@@ -1,27 +0,0 @@
-//#FILE: test-fs-watch-stop-sync.js
-//#SHA1: 8285d2bd43d2f9be7be525417cf51f9336b2f379
-//-----------------
-"use strict";
-
-// This test checks that the `stop` event is emitted asynchronously.
-//
-// If it isn't asynchronous, then the listener will be called during the
-// execution of `watch.stop()`. That would be a bug.
-//
-// If it is asynchronous, then the listener will be removed before the event is
-// emitted.
-
-const fs = require("fs");
-
-test("stop event is emitted asynchronously", () => {
-  const listener = jest.fn();
-
-  const watch = fs.watchFile(__filename, jest.fn());
-  watch.once("stop", listener);
-  watch.stop();
-  watch.removeListener("stop", listener);
-
-  expect(listener).not.toHaveBeenCalled();
-});
-
-//<#END_FILE: test-fs-watch-stop-sync.js
diff --git a/test/js/node/test/parallel/fs-write-file-buffer.test.js b/test/js/node/test/parallel/fs-write-file-buffer.test.js
deleted file mode 100644
index 774f93cfb8..0000000000
--- a/test/js/node/test/parallel/fs-write-file-buffer.test.js
+++ /dev/null
@@ -1,71 +0,0 @@
-//#FILE: test-fs-write-file-buffer.js
-//#SHA1: f721ad0f6969d6cf1ba78f96ccf9600a7f93458d
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const fs = require("fs");
-const path = require("path");
-
-let data = [
-  "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAUDBAQEAwUEBAQFBQUGBwwIBwcH",
-  "Bw8LCwkMEQ8SEhEPERETFhwXExQaFRERGCEYGh0dHx8fExciJCIeJBweHx7/",
-  "2wBDAQUFBQcGBw4ICA4eFBEUHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4e",
-  "Hh4eHh4eHh4eHh4eHh4eHh4eHh4eHh7/wAARCAAQABADASIAAhEBAxEB/8QA",
-  "HwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUF",
-  "BAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkK",
-  "FhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1",
-  "dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXG",
-  "x8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEB",
-  "AQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAEC",
-  "AxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRom",
-  "JygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOE",
-  "hYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU",
-  "1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwDhfBUFl/wk",
-  "OmPqKJJZw3aiZFBw4z93jnkkc9u9dj8XLfSI/EBt7DTo7ea2Ox5YXVo5FC7g",
-  "Tjq24nJPXNVtO0KATRvNHCIg3zoWJWQHqp+o4pun+EtJ0zxBq8mnLJa2d1L5",
-  "0NvnKRjJBUE5PAx3NYxxUY0pRtvYHSc5Ka2X9d7H/9k=",
-];
-
-data = data.join("\n");
-
-let tmpdir;
-
-beforeEach(() => {
-  tmpdir = fs.mkdtempSync(path.join(process.env.TEST_TMPDIR || "/tmp", "test-fs-write-file-buffer-"));
-});
-
-afterEach(() => {
-  fs.rmSync(tmpdir, { recursive: true, force: true });
-});
-
-test("writeFileSync with Buffer", () => {
-  const buf = Buffer.from(data, "base64");
-  const testFile = path.join(tmpdir, "test.jpg");
-
-  fs.writeFileSync(testFile, buf);
-
-  expect(fs.existsSync(testFile)).toBe(true);
-  expect(fs.readFileSync(testFile)).toEqual(buf);
-});
-
-//<#END_FILE: test-fs-write-file-buffer.js
diff --git a/test/js/node/test/parallel/fs-write-no-fd.test.js b/test/js/node/test/parallel/fs-write-no-fd.test.js
deleted file mode 100644
index 6750c80c46..0000000000
--- a/test/js/node/test/parallel/fs-write-no-fd.test.js
+++ /dev/null
@@ -1,29 +0,0 @@
-//#FILE: test-fs-write-no-fd.js
-//#SHA1: eade06241743a0d7e72b5239633e1ddd947f3a28
-//-----------------
-"use strict";
-const fs = require("fs");
-
-test("fs.write with null fd and Buffer throws TypeError", () => {
-  expect(() => {
-    fs.write(null, Buffer.allocUnsafe(1), 0, 1, () => {});
-  }).toThrow(
-    expect.objectContaining({
-      name: "TypeError",
-      message: expect.any(String),
-    }),
-  );
-});
-
-test("fs.write with null fd and string throws TypeError", () => {
-  expect(() => {
-    fs.write(null, "1", 0, 1, () => {});
-  }).toThrow(
-    expect.objectContaining({
-      name: "TypeError",
-      message: expect.any(String),
-    }),
-  );
-});
-
-//<#END_FILE: test-fs-write-no-fd.js
diff --git a/test/js/node/test/parallel/fs-write-stream-close-without-callback.test.js b/test/js/node/test/parallel/fs-write-stream-close-without-callback.test.js
deleted file mode 100644
index 969a581bb5..0000000000
--- a/test/js/node/test/parallel/fs-write-stream-close-without-callback.test.js
+++ /dev/null
@@ -1,38 +0,0 @@
-//#FILE: test-fs-write-stream-close-without-callback.js
-//#SHA1: 63e0c345b440c8cfb157aa84340f387cf314e20f
-//-----------------
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-const os = require("os");
-
-const tmpdir = path.join(os.tmpdir(), "test-fs-write-stream-close-without-callback");
-
-beforeEach(() => {
-  // Create a fresh temporary directory before each test
-  if (!fs.existsSync(tmpdir)) {
-    fs.mkdirSync(tmpdir, { recursive: true });
-  }
-});
-
-afterEach(() => {
-  // Clean up the temporary directory after each test
-  if (fs.existsSync(tmpdir)) {
-    fs.rmSync(tmpdir, { recursive: true, force: true });
-  }
-});
-
-test("fs.WriteStream can be closed without a callback", () => {
-  const filePath = path.join(tmpdir, "nocallback");
-  const s = fs.createWriteStream(filePath);
-
-  s.end("hello world");
-  s.close();
-
-  // We don't need to assert anything here as the test is checking
-  // that the above operations don't throw an error
-  expect(true).toBe(true);
-});
-
-//<#END_FILE: test-fs-write-stream-close-without-callback.js
diff --git a/test/js/node/test/parallel/fs-write-stream-end.test.js b/test/js/node/test/parallel/fs-write-stream-end.test.js
deleted file mode 100644
index a73488cb3b..0000000000
--- a/test/js/node/test/parallel/fs-write-stream-end.test.js
+++ /dev/null
@@ -1,76 +0,0 @@
-//#FILE: test-fs-write-stream-end.js
-//#SHA1: a4194cfb1f416f5fddd5edc55b7d867db14a5320
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const fs = require("fs");
-const path = require("path");
-
-const tmpdir = path.join(__dirname, "tmp");
-
-beforeAll(() => {
-  if (!fs.existsSync(tmpdir)) {
-    fs.mkdirSync(tmpdir, { recursive: true });
-  }
-});
-
-afterAll(() => {
-  fs.rmSync(tmpdir, { recursive: true, force: true });
-});
-
-test("end without data", done => {
-  const file = path.join(tmpdir, "write-end-test0.txt");
-  const stream = fs.createWriteStream(file);
-  stream.end();
-  stream.on("close", () => {
-    done();
-  });
-});
-
-test("end with data", done => {
-  const file = path.join(tmpdir, "write-end-test1.txt");
-  const stream = fs.createWriteStream(file);
-  stream.end("a\n", "utf8");
-  stream.on("close", () => {
-    const content = fs.readFileSync(file, "utf8");
-    expect(content).toBe("a\n");
-    done();
-  });
-});
-
-test("end triggers open and finish events", done => {
-  const file = path.join(tmpdir, "write-end-test2.txt");
-  const stream = fs.createWriteStream(file);
-  stream.end();
-
-  let calledOpen = false;
-  stream.on("open", () => {
-    calledOpen = true;
-  });
-  stream.on("finish", () => {
-    expect(calledOpen).toBe(true);
-    done();
-  });
-});
-
-//<#END_FILE: test-fs-write-stream-end.js
diff --git a/test/js/node/test/parallel/fs-write-sync.test.js b/test/js/node/test/parallel/fs-write-sync.test.js
deleted file mode 100644
index 5e277e75e5..0000000000
--- a/test/js/node/test/parallel/fs-write-sync.test.js
+++ /dev/null
@@ -1,66 +0,0 @@
-//#FILE: test-fs-write-sync.js
-//#SHA1: 4ae5fa7550eefe258b9c1de798f4a4092e9d15d1
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const fs = require("fs");
-const path = require("path");
-const os = require("os");
-
-const filename = path.join(os.tmpdir(), "write.txt");
-
-beforeEach(() => {
-  try {
-    fs.unlinkSync(filename);
-  } catch (err) {
-    // Ignore errors if file doesn't exist
-  }
-});
-
-test("fs.writeSync with various parameter combinations", () => {
-  const parameters = [Buffer.from("bár"), 0, Buffer.byteLength("bár")];
-
-  // The first time fs.writeSync is called with all parameters provided.
-  // After that, each pop in the cycle removes the final parameter. So:
-  // - The 2nd time fs.writeSync with a buffer, without the length parameter.
-  // - The 3rd time fs.writeSync with a buffer, without the offset and length
-  //   parameters.
-  while (parameters.length > 0) {
-    const fd = fs.openSync(filename, "w");
-
-    let written = fs.writeSync(fd, "");
-    expect(written).toBe(0);
-
-    fs.writeSync(fd, "foo");
-
-    written = fs.writeSync(fd, ...parameters);
-    expect(written).toBeGreaterThan(3);
-    fs.closeSync(fd);
-
-    expect(fs.readFileSync(filename, "utf-8")).toBe("foobár");
-
-    parameters.pop();
-  }
-});
-
-//<#END_FILE: test-fs-write-sync.js
diff --git a/test/js/node/test/parallel/fs-writestream-open-write.test.js b/test/js/node/test/parallel/fs-writestream-open-write.test.js
deleted file mode 100644
index c641c31ce8..0000000000
--- a/test/js/node/test/parallel/fs-writestream-open-write.test.js
+++ /dev/null
@@ -1,43 +0,0 @@
-//#FILE: test-fs-writestream-open-write.js
-//#SHA1: a4cb8508ae1f366c94442a43312a817f00b68de6
-//-----------------
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-const os = require("os");
-
-// Regression test for https://github.com/nodejs/node/issues/51993
-
-let tmpdir;
-
-beforeEach(() => {
-  tmpdir = fs.mkdtempSync(path.join(os.tmpdir(), "test-fs-writestream-open-write-"));
-});
-
-afterEach(() => {
-  fs.rmSync(tmpdir, { recursive: true, force: true });
-});
-
-test("fs.createWriteStream opens and writes correctly", done => {
-  const file = path.join(tmpdir, "test-fs-writestream-open-write.txt");
-
-  const w = fs.createWriteStream(file);
-
-  w.on("open", () => {
-    w.write("hello");
-
-    process.nextTick(() => {
-      w.write("world");
-      w.end();
-    });
-  });
-
-  w.on("close", () => {
-    expect(fs.readFileSync(file, "utf8")).toBe("helloworld");
-    fs.unlinkSync(file);
-    done();
-  });
-});
-
-//<#END_FILE: test-fs-writestream-open-write.js
diff --git a/test/js/node/test/parallel/global-customevent.test.js b/test/js/node/test/parallel/global-customevent.test.js
deleted file mode 100644
index 988e0cd447..0000000000
--- a/test/js/node/test/parallel/global-customevent.test.js
+++ /dev/null
@@ -1,19 +0,0 @@
-//#FILE: test-global-customevent.js
-//#SHA1: 754c1b6babd0e73fa3206c9c9179ff3a034eba9b
-//-----------------
-"use strict";
-
-// Global
-test("CustomEvent is defined globally", () => {
-  expect(CustomEvent).toBeDefined();
-});
-
-test("CustomEvent is the same as internal CustomEvent", () => {
-  // We can't use internal modules in Jest, so we'll skip this test
-  // and add a comment explaining why.
-  console.log("Skipping test for internal CustomEvent comparison");
-  // The original test was:
-  // strictEqual(CustomEvent, internalCustomEvent);
-});
-
-//<#END_FILE: test-global-customevent.js
diff --git a/test/js/node/test/parallel/global-domexception.test.js b/test/js/node/test/parallel/global-domexception.test.js
deleted file mode 100644
index 2ebf63c2fd..0000000000
--- a/test/js/node/test/parallel/global-domexception.test.js
+++ /dev/null
@@ -1,18 +0,0 @@
-//#FILE: test-global-domexception.js
-//#SHA1: 9a8d5eacea5ae98814fa6312b5f10089034c1ef4
-//-----------------
-"use strict";
-
-// This test checks the global availability and behavior of DOMException
-
-test("DOMException is a global function", () => {
-  expect(typeof DOMException).toBe("function");
-});
-
-test("atob throws a DOMException for invalid input", () => {
-  expect(() => {
-    atob("我要抛错！");
-  }).toThrow(DOMException);
-});
-
-//<#END_FILE: test-global-domexception.js
diff --git a/test/js/node/test/parallel/global-encoder.test.js b/test/js/node/test/parallel/global-encoder.test.js
deleted file mode 100644
index a9a928fb17..0000000000
--- a/test/js/node/test/parallel/global-encoder.test.js
+++ /dev/null
@@ -1,13 +0,0 @@
-//#FILE: test-global-encoder.js
-//#SHA1: 7397937d3493488fc47e8ba6ba8fcb4f5bdd97fa
-//-----------------
-"use strict";
-
-test("TextDecoder and TextEncoder are globally available", () => {
-  const util = require("util");
-
-  expect(TextDecoder).toBe(util.TextDecoder);
-  expect(TextEncoder).toBe(util.TextEncoder);
-});
-
-//<#END_FILE: test-global-encoder.js
diff --git a/test/js/node/test/parallel/global-webcrypto.test.js b/test/js/node/test/parallel/global-webcrypto.test.js
deleted file mode 100644
index a936c6b593..0000000000
--- a/test/js/node/test/parallel/global-webcrypto.test.js
+++ /dev/null
@@ -1,27 +0,0 @@
-//#FILE: test-global-webcrypto.js
-//#SHA1: 3ae34178f201f6dfeb3ca5ec6e0914e6de63d64b
-//-----------------
-"use strict";
-
-const crypto = require("crypto");
-
-// Skip the test if crypto is not available
-if (!crypto) {
-  test.skip("missing crypto", () => {});
-} else {
-  describe("Global WebCrypto", () => {
-    test("globalThis.crypto is crypto.webcrypto", () => {
-      expect(globalThis.crypto).toBe(crypto.webcrypto);
-    });
-
-    test("Crypto is the constructor of crypto.webcrypto", () => {
-      expect(Crypto).toBe(crypto.webcrypto.constructor);
-    });
-
-    test("SubtleCrypto is the constructor of crypto.webcrypto.subtle", () => {
-      expect(SubtleCrypto).toBe(crypto.webcrypto.subtle.constructor);
-    });
-  });
-}
-
-//<#END_FILE: test-global-webcrypto.js
diff --git a/test/js/node/test/parallel/heap-prof-exec-argv.test.js b/test/js/node/test/parallel/heap-prof-exec-argv.test.js
deleted file mode 100644
index aa64858dbb..0000000000
--- a/test/js/node/test/parallel/heap-prof-exec-argv.test.js
+++ /dev/null
@@ -1,43 +0,0 @@
-//#FILE: test-heap-prof-exec-argv.js
-//#SHA1: 77c3a447116b06f03f52fd56efe928699ba6d60d
-//-----------------
-"use strict";
-
-// Tests --heap-prof generates a heap profile from worker
-// when execArgv is set.
-
-const fixtures = require("../common/fixtures");
-const assert = require("assert");
-const { spawnSync } = require("child_process");
-const tmpdir = require("../common/tmpdir");
-const { getHeapProfiles, verifyFrames } = require("../common/prof");
-
-// Skip the test if inspector is disabled
-const isInspectorEnabled = process.execArgv.some(arg => arg.startsWith("--inspect"));
-if (!isInspectorEnabled) {
-  test.skip("Inspector is disabled", () => {});
-} else {
-  test("--heap-prof generates a heap profile from worker when execArgv is set", () => {
-    tmpdir.refresh();
-    const output = spawnSync(process.execPath, [fixtures.path("workload", "allocation-worker-argv.js")], {
-      cwd: tmpdir.path,
-      env: {
-        ...process.env,
-        HEAP_PROF_INTERVAL: "128",
-      },
-    });
-
-    if (output.status !== 0) {
-      console.log(output.stderr.toString());
-    }
-
-    expect(output.status).toBe(0);
-
-    const profiles = getHeapProfiles(tmpdir.path);
-    expect(profiles.length).toBe(1);
-
-    verifyFrames(output, profiles[0], "runAllocation");
-  });
-}
-
-//<#END_FILE: test-heap-prof-exec-argv.js
diff --git a/test/js/node/test/parallel/http-abort-before-end.test.js b/test/js/node/test/parallel/http-abort-before-end.test.js
deleted file mode 100644
index 0df59e1fcf..0000000000
--- a/test/js/node/test/parallel/http-abort-before-end.test.js
+++ /dev/null
@@ -1,60 +0,0 @@
-//#FILE: test-http-abort-before-end.js
-//#SHA1: ccb82c66677f07f3ee815846261393edb8bfe5d4
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-
-test("HTTP request abort before end", async () => {
-  const server = http.createServer(jest.fn());
-
-  await new Promise(resolve => {
-    server.listen(0, resolve);
-  });
-
-  const req = http.request({
-    method: "GET",
-    host: "127.0.0.1",
-    port: server.address().port,
-  });
-
-  const abortPromise = new Promise(resolve => {
-    req.on("abort", resolve);
-  });
-
-  req.on("error", jest.fn());
-
-  req.abort();
-  req.end();
-
-  await abortPromise;
-
-  expect(server.listeners("request")[0]).not.toHaveBeenCalled();
-  expect(req.listeners("error")[0]).not.toHaveBeenCalled();
-
-  await new Promise(resolve => {
-    server.close(resolve);
-  });
-});
-
-//<#END_FILE: test-http-abort-before-end.js
diff --git a/test/js/node/test/parallel/http-abort-queued.test.js b/test/js/node/test/parallel/http-abort-queued.test.js
deleted file mode 100644
index d5c7fea669..0000000000
--- a/test/js/node/test/parallel/http-abort-queued.test.js
+++ /dev/null
@@ -1,102 +0,0 @@
-//#FILE: test-http-abort-queued.js
-//#SHA1: e0fcd4a5eb0466a1e218147e8eb53714311a6f42
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-
-let complete;
-
-test("http abort queued request", async () => {
-  const server = http.createServer((req, res) => {
-    // We should not see the queued /thatotherone request within the server
-    // as it should be aborted before it is sent.
-    expect(req.url).toBe("/");
-
-    res.writeHead(200);
-    res.write("foo");
-
-    complete =
-      complete ||
-      function () {
-        res.end();
-      };
-  });
-
-  await new Promise(resolve => server.listen(0, resolve));
-
-  const agent = new http.Agent({ maxSockets: 1 });
-  expect(Object.keys(agent.sockets)).toHaveLength(0);
-
-  const options = {
-    hostname: "localhost",
-    port: server.address().port,
-    method: "GET",
-    path: "/",
-    agent: agent,
-  };
-
-  const req1 = http.request(options);
-  req1.on("response", res1 => {
-    expect(Object.keys(agent.sockets)).toHaveLength(1);
-    expect(Object.keys(agent.requests)).toHaveLength(0);
-
-    const req2 = http.request({
-      method: "GET",
-      host: "localhost",
-      port: server.address().port,
-      path: "/thatotherone",
-      agent: agent,
-    });
-    expect(Object.keys(agent.sockets)).toHaveLength(1);
-    expect(Object.keys(agent.requests)).toHaveLength(1);
-
-    // TODO(jasnell): This event does not appear to currently be triggered.
-    // is this handler actually required?
-    req2.on("error", err => {
-      // This is expected in response to our explicit abort call
-      expect(err.code).toBe("ECONNRESET");
-    });
-
-    req2.end();
-    req2.abort();
-
-    expect(Object.keys(agent.sockets)).toHaveLength(1);
-    expect(Object.keys(agent.requests)).toHaveLength(1);
-
-    res1.on("data", chunk => complete());
-
-    res1.on("end", () => {
-      setTimeout(() => {
-        expect(Object.keys(agent.sockets)).toHaveLength(0);
-        expect(Object.keys(agent.requests)).toHaveLength(0);
-
-        server.close();
-      }, 100);
-    });
-  });
-
-  req1.end();
-});
-
-//<#END_FILE: test-http-abort-queued.js
diff --git a/test/js/node/test/parallel/http-agent-false.test.js b/test/js/node/test/parallel/http-agent-false.test.js
deleted file mode 100644
index c99f236785..0000000000
--- a/test/js/node/test/parallel/http-agent-false.test.js
+++ /dev/null
@@ -1,61 +0,0 @@
-//#FILE: test-http-agent-false.js
-//#SHA1: ba987050ea069a591615a69e341cf6f9c7298e5a
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-
-test("http.request with agent: false and port: null", async () => {
-  // Sending `agent: false` when `port: null` is also passed in (i.e. the result
-  // of a `url.parse()` call with the default port used, 80 or 443), should not
-  // result in an assertion error...
-  const opts = {
-    host: "127.0.0.1",
-    port: null,
-    path: "/",
-    method: "GET",
-    agent: false,
-  };
-
-  // We just want an "error" (no local HTTP server on port 80) or "response"
-  // to happen (user happens ot have HTTP server running on port 80).
-  // As long as the process doesn't crash from a C++ assertion then we're good.
-  const req = http.request(opts);
-
-  // Will be called by either the response event or error event, not both
-  const oneResponse = jest.fn();
-  req.on("response", oneResponse);
-  req.on("error", oneResponse);
-  req.end();
-
-  // Wait for the request to complete
-  await new Promise(resolve => {
-    req.on("response", resolve);
-    req.on("error", resolve);
-  });
-
-  // Check that oneResponse was called exactly once
-  expect(oneResponse).toHaveBeenCalledTimes(1);
-});
-
-//<#END_FILE: test-http-agent-false.js
diff --git a/test/js/node/test/parallel/http-agent-no-protocol.test.js b/test/js/node/test/parallel/http-agent-no-protocol.test.js
deleted file mode 100644
index 99d0acc26f..0000000000
--- a/test/js/node/test/parallel/http-agent-no-protocol.test.js
+++ /dev/null
@@ -1,63 +0,0 @@
-//#FILE: test-http-agent-no-protocol.js
-//#SHA1: f1b40623163271a500c87971bf996466e006130e
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-const url = require("url");
-
-test("http agent with no protocol", async () => {
-  const serverCallback = jest.fn((req, res) => {
-    res.end();
-  });
-
-  const server = http.createServer(serverCallback);
-
-  await new Promise(resolve => {
-    server.listen(0, "127.0.0.1", resolve);
-  });
-
-  const opts = url.parse(`http://127.0.0.1:${server.address().port}/`);
-
-  // Remove the `protocol` field… the `http` module should fall back
-  // to "http:", as defined by the global, default `http.Agent` instance.
-  opts.agent = new http.Agent();
-  opts.agent.protocol = null;
-
-  const responseCallback = jest.fn(res => {
-    res.resume();
-    server.close();
-  });
-
-  await new Promise(resolve => {
-    http.get(opts, res => {
-      responseCallback(res);
-      resolve();
-    });
-  });
-
-  expect(serverCallback).toHaveBeenCalledTimes(1);
-  expect(responseCallback).toHaveBeenCalledTimes(1);
-});
-
-//<#END_FILE: test-http-agent-no-protocol.js
diff --git a/test/js/node/test/parallel/http-agent-null.test.js b/test/js/node/test/parallel/http-agent-null.test.js
deleted file mode 100644
index c44c03f788..0000000000
--- a/test/js/node/test/parallel/http-agent-null.test.js
+++ /dev/null
@@ -1,56 +0,0 @@
-//#FILE: test-http-agent-null.js
-//#SHA1: 65fb22d32bae2a7eecc4242b5b2d2d693849641c
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-
-test("http.get with null agent", async () => {
-  const server = http.createServer((req, res) => {
-    res.end();
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, resolve);
-  });
-
-  const options = {
-    agent: null,
-    port: server.address().port,
-  };
-
-  const responsePromise = new Promise(resolve => {
-    http.get(options, res => {
-      res.resume();
-      resolve(res);
-    });
-  });
-
-  await expect(responsePromise).resolves.toBeDefined();
-
-  await new Promise(resolve => {
-    server.close(resolve);
-  });
-});
-
-//<#END_FILE: test-http-agent-null.js
diff --git a/test/js/node/test/parallel/http-agent-uninitialized-with-handle.test.js b/test/js/node/test/parallel/http-agent-uninitialized-with-handle.test.js
deleted file mode 100644
index b78aacf5b6..0000000000
--- a/test/js/node/test/parallel/http-agent-uninitialized-with-handle.test.js
+++ /dev/null
@@ -1,43 +0,0 @@
-//#FILE: test-http-agent-uninitialized-with-handle.js
-//#SHA1: 828942acbc68f8fd92425ecdf0e754ab13b4baff
-//-----------------
-"use strict";
-
-const http = require("http");
-const net = require("net");
-
-test("http agent with uninitialized socket handle", done => {
-  const agent = new http.Agent({
-    keepAlive: true,
-  });
-  const socket = new net.Socket();
-  // If _handle exists then internals assume a couple methods exist.
-  socket._handle = {
-    ref() {},
-    readStart() {},
-  };
-
-  const server = http.createServer((req, res) => {
-    res.end();
-  });
-
-  server.listen(0, () => {
-    const req = new http.ClientRequest(`http://localhost:${server.address().port}/`);
-
-    // Manually add the socket without a _handle.
-    agent.freeSockets[agent.getName(req)] = [socket];
-    // Now force the agent to use the socket and check that _handle exists before
-    // calling asyncReset().
-    agent.addRequest(req, {});
-    req.on("response", () => {
-      server.close();
-      done();
-    });
-    req.end();
-  });
-
-  expect(server).toHaveProperty("listen");
-  expect(server).toHaveProperty("close");
-});
-
-//<#END_FILE: test-http-agent-uninitialized-with-handle.js
diff --git a/test/js/node/test/parallel/http-agent-uninitialized.test.js b/test/js/node/test/parallel/http-agent-uninitialized.test.js
deleted file mode 100644
index 43e447a063..0000000000
--- a/test/js/node/test/parallel/http-agent-uninitialized.test.js
+++ /dev/null
@@ -1,37 +0,0 @@
-//#FILE: test-http-agent-uninitialized.js
-//#SHA1: 00034f4963a5620af8a58e68c262c92ea9ec982b
-//-----------------
-"use strict";
-
-const http = require("http");
-const net = require("net");
-
-test("http agent handles uninitialized socket", done => {
-  const agent = new http.Agent({
-    keepAlive: true,
-  });
-  const socket = new net.Socket();
-
-  const server = http
-    .createServer((req, res) => {
-      res.end();
-    })
-    .listen(0, () => {
-      const req = new http.ClientRequest(`http://localhost:${server.address().port}/`);
-
-      // Manually add the socket without a _handle.
-      agent.freeSockets[agent.getName(req)] = [socket];
-      // Now force the agent to use the socket and check that _handle exists before
-      // calling asyncReset().
-      agent.addRequest(req, {});
-      req.on("response", () => {
-        server.close();
-        done();
-      });
-      req.end();
-    });
-
-  expect(server).toBeDefined();
-});
-
-//<#END_FILE: test-http-agent-uninitialized.js
diff --git a/test/js/node/test/parallel/http-agent.test.js b/test/js/node/test/parallel/http-agent.test.js
deleted file mode 100644
index 900ad21d17..0000000000
--- a/test/js/node/test/parallel/http-agent.test.js
+++ /dev/null
@@ -1,97 +0,0 @@
-//#FILE: test-http-agent.js
-//#SHA1: c5bb5b1b47100659ac17ae6c4ba084c6974ddaa7
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-
-const N = 4;
-const M = 4;
-
-let server;
-
-beforeEach(() => {
-  server = http.Server((req, res) => {
-    res.writeHead(200);
-    res.end("hello world\n");
-  });
-});
-
-afterEach(() => {
-  server.close();
-});
-
-function makeRequests(outCount, inCount, shouldFail) {
-  return new Promise(resolve => {
-    const totalRequests = outCount * inCount;
-    let completedRequests = 0;
-
-    const onRequest = jest.fn(res => {
-      completedRequests++;
-      if (completedRequests === totalRequests) {
-        resolve();
-      }
-
-      if (!shouldFail) {
-        res.resume();
-      }
-    });
-
-    server.listen(0, () => {
-      const port = server.address().port;
-      for (let i = 0; i < outCount; i++) {
-        setTimeout(() => {
-          for (let j = 0; j < inCount; j++) {
-            const req = http.get({ port: port, path: "/" }, onRequest);
-            if (shouldFail) {
-              req.on("error", onRequest);
-            } else {
-              req.on("error", e => {
-                throw e;
-              });
-            }
-          }
-        }, i);
-      }
-    });
-  });
-}
-
-test("makeRequests successful", async () => {
-  await makeRequests(N, M);
-  expect(server.listenerCount("request")).toBe(1);
-});
-
-test("makeRequests with failing requests", async () => {
-  const originalCreateConnection = http.Agent.prototype.createConnection;
-
-  http.Agent.prototype.createConnection = function createConnection(_, cb) {
-    process.nextTick(cb, new Error("nothing"));
-  };
-
-  await makeRequests(N, M, true);
-
-  http.Agent.prototype.createConnection = originalCreateConnection;
-});
-
-//<#END_FILE: test-http-agent.js
diff --git a/test/js/node/test/parallel/http-bind-twice.test.js b/test/js/node/test/parallel/http-bind-twice.test.js
deleted file mode 100644
index 99917ffc27..0000000000
--- a/test/js/node/test/parallel/http-bind-twice.test.js
+++ /dev/null
@@ -1,55 +0,0 @@
-//#FILE: test-http-bind-twice.js
-//#SHA1: 71319f0a5445d1ea7644e952ec4048d8996be1bc
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-
-test("HTTP server bind twice", async () => {
-  const server1 = http.createServer(jest.fn());
-  const server1ListenPromise = new Promise(resolve => {
-    server1.listen(0, "127.0.0.1", resolve);
-  });
-
-  await server1ListenPromise;
-
-  const server2 = http.createServer(jest.fn());
-  const server2ErrorPromise = new Promise(resolve => {
-    server2.on("error", resolve);
-  });
-
-  server2.listen(server1.address().port, "127.0.0.1");
-
-  const error = await server2ErrorPromise;
-
-  expect(error).toEqual(
-    expect.objectContaining({
-      code: "EADDRINUSE",
-      message: expect.any(String),
-    }),
-  );
-
-  await new Promise(resolve => server1.close(resolve));
-});
-
-//<#END_FILE: test-http-bind-twice.js
diff --git a/test/js/node/test/parallel/http-chunked-smuggling.test.js b/test/js/node/test/parallel/http-chunked-smuggling.test.js
deleted file mode 100644
index e1ab305b10..0000000000
--- a/test/js/node/test/parallel/http-chunked-smuggling.test.js
+++ /dev/null
@@ -1,61 +0,0 @@
-//#FILE: test-http-chunked-smuggling.js
-//#SHA1: c146d9dc37a522ac07d943b4c40b3301923659fa
-//-----------------
-"use strict";
-
-const http = require("http");
-const net = require("net");
-
-// Verify that invalid chunk extensions cannot be used to perform HTTP request
-// smuggling attacks.
-
-describe("HTTP Chunked Smuggling", () => {
-  let server;
-  let serverPort;
-
-  beforeAll(done => {
-    server = http.createServer((request, response) => {
-      expect(request.url).not.toBe("/admin");
-      response.end("hello world");
-    });
-
-    server.listen(0, () => {
-      serverPort = server.address().port;
-      done();
-    });
-  });
-
-  afterAll(done => {
-    server.close(done);
-  });
-
-  test("invalid chunk extensions", done => {
-    const sock = net.connect(serverPort);
-
-    sock.write(
-      "" +
-        "GET / HTTP/1.1\r\n" +
-        "Host: localhost:8080\r\n" +
-        "Transfer-Encoding: chunked\r\n" +
-        "\r\n" +
-        "2;\n" +
-        "xx\r\n" +
-        "4c\r\n" +
-        "0\r\n" +
-        "\r\n" +
-        "GET /admin HTTP/1.1\r\n" +
-        "Host: localhost:8080\r\n" +
-        "Transfer-Encoding: chunked\r\n" +
-        "\r\n" +
-        "0\r\n" +
-        "\r\n",
-    );
-
-    sock.resume();
-    sock.on("end", () => {
-      done();
-    });
-  });
-});
-
-//<#END_FILE: test-http-chunked-smuggling.js
diff --git a/test/js/node/test/parallel/http-client-abort2.test.js b/test/js/node/test/parallel/http-client-abort2.test.js
deleted file mode 100644
index 416be11173..0000000000
--- a/test/js/node/test/parallel/http-client-abort2.test.js
+++ /dev/null
@@ -1,55 +0,0 @@
-//#FILE: test-http-client-abort2.js
-//#SHA1: 9accf5214e90cab96d06a59931e65718616b85f3
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-
-test("http client abort", async () => {
-  const serverHandler = jest.fn((req, res) => {
-    res.end("Hello");
-  });
-
-  const server = http.createServer(serverHandler);
-
-  await new Promise(resolve => {
-    server.listen(0, resolve);
-  });
-
-  const options = { port: server.address().port };
-
-  const req = http.get(options, res => {
-    res.on("data", data => {
-      req.abort();
-      server.close();
-    });
-  });
-
-  await new Promise(resolve => {
-    server.on("close", resolve);
-  });
-
-  expect(serverHandler).toHaveBeenCalledTimes(1);
-});
-
-//<#END_FILE: test-http-client-abort2.js
diff --git a/test/js/node/test/parallel/http-client-defaults.test.js b/test/js/node/test/parallel/http-client-defaults.test.js
deleted file mode 100644
index f527d6ade8..0000000000
--- a/test/js/node/test/parallel/http-client-defaults.test.js
+++ /dev/null
@@ -1,28 +0,0 @@
-//#FILE: test-http-client-defaults.js
-//#SHA1: 7209a7752de52cc378c3b29eda88c82d71e6839d
-//-----------------
-"use strict";
-
-const http = require("http");
-
-describe("ClientRequest defaults", () => {
-  test("default path and method", () => {
-    const req = new http.ClientRequest({ createConnection: () => {} });
-    expect(req.path).toBe("/");
-    expect(req.method).toBe("GET");
-  });
-
-  test("empty method defaults to GET", () => {
-    const req = new http.ClientRequest({ method: "", createConnection: () => {} });
-    expect(req.path).toBe("/");
-    expect(req.method).toBe("GET");
-  });
-
-  test("empty path defaults to /", () => {
-    const req = new http.ClientRequest({ path: "", createConnection: () => {} });
-    expect(req.path).toBe("/");
-    expect(req.method).toBe("GET");
-  });
-});
-
-//<#END_FILE: test-http-client-defaults.js
diff --git a/test/js/node/test/parallel/http-client-encoding.test.js b/test/js/node/test/parallel/http-client-encoding.test.js
deleted file mode 100644
index b0455d81bb..0000000000
--- a/test/js/node/test/parallel/http-client-encoding.test.js
+++ /dev/null
@@ -1,56 +0,0 @@
-//#FILE: test-http-client-encoding.js
-//#SHA1: a3e1a0cc1bf9352602068f323d90071d3c2d5f7d
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-
-test("HTTP client encoding", async () => {
-  const server = http.createServer((req, res) => {
-    res.end("ok");
-    server.close();
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, () => {
-      const port = server.address().port;
-      const req = http.request(
-        {
-          port: port,
-          encoding: "utf8",
-        },
-        res => {
-          let data = "";
-          res.on("data", chunk => (data += chunk));
-          res.on("end", () => {
-            expect(data).toBe("ok");
-            resolve();
-          });
-        },
-      );
-      req.end();
-    });
-  });
-});
-
-//<#END_FILE: test-http-client-encoding.js
diff --git a/test/js/node/test/parallel/http-client-get-url.test.js b/test/js/node/test/parallel/http-client-get-url.test.js
deleted file mode 100644
index e13f87f7d4..0000000000
--- a/test/js/node/test/parallel/http-client-get-url.test.js
+++ /dev/null
@@ -1,78 +0,0 @@
-//#FILE: test-http-client-get-url.js
-//#SHA1: 0329da4beb5be5da0ab6652b246dd912935e56af
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-const url = require("url");
-const testPath = "/foo?bar";
-
-let server;
-let serverAddress;
-
-beforeAll(async () => {
-  server = http.createServer((req, res) => {
-    expect(req.method).toBe("GET");
-    expect(req.url).toBe(testPath);
-    res.writeHead(200, { "Content-Type": "text/plain" });
-    res.write("hello\n");
-    res.end();
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, "127.0.0.1", () => {
-      serverAddress = `http://127.0.0.1:${server.address().port}${testPath}`;
-      resolve();
-    });
-  });
-});
-
-afterAll(() => {
-  server.close();
-});
-
-test("http.get with string URL", async () => {
-  await new Promise(resolve => {
-    http.get(serverAddress, () => {
-      resolve();
-    });
-  });
-});
-
-test("http.get with parsed URL", async () => {
-  await new Promise(resolve => {
-    http.get(url.parse(serverAddress), () => {
-      resolve();
-    });
-  });
-});
-
-test("http.get with URL object", async () => {
-  await new Promise(resolve => {
-    http.get(new URL(serverAddress), () => {
-      resolve();
-    });
-  });
-});
-
-//<#END_FILE: test-http-client-get-url.js
diff --git a/test/js/node/test/parallel/http-client-input-function.test.js b/test/js/node/test/parallel/http-client-input-function.test.js
deleted file mode 100644
index e34ee9a0d5..0000000000
--- a/test/js/node/test/parallel/http-client-input-function.test.js
+++ /dev/null
@@ -1,42 +0,0 @@
-//#FILE: test-http-client-input-function.js
-//#SHA1: 2ca0147b992331ea69803031f33076c685bce264
-//-----------------
-"use strict";
-
-const http = require("http");
-
-test("http.ClientRequest with server response", async () => {
-  const server = http.createServer((req, res) => {
-    res.writeHead(200);
-    res.end("hello world");
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, "127.0.0.1", resolve);
-  });
-
-  const serverAddress = server.address();
-
-  const responsePromise = new Promise(resolve => {
-    const req = new http.ClientRequest(serverAddress, response => {
-      let body = "";
-      response.setEncoding("utf8");
-      response.on("data", chunk => {
-        body += chunk;
-      });
-
-      response.on("end", () => {
-        resolve(body);
-      });
-    });
-
-    req.end();
-  });
-
-  const body = await responsePromise;
-  expect(body).toBe("hello world");
-
-  await new Promise(resolve => server.close(resolve));
-});
-
-//<#END_FILE: test-http-client-input-function.js
diff --git a/test/js/node/test/parallel/http-client-keep-alive-release-before-finish.test.js b/test/js/node/test/parallel/http-client-keep-alive-release-before-finish.test.js
deleted file mode 100644
index 5e7ca84113..0000000000
--- a/test/js/node/test/parallel/http-client-keep-alive-release-before-finish.test.js
+++ /dev/null
@@ -1,57 +0,0 @@
-//#FILE: test-http-client-keep-alive-release-before-finish.js
-//#SHA1: 198cd4a6c28c8a7dda45f003305e8fa80f05469d
-//-----------------
-"use strict";
-
-const http = require("http");
-
-test("HTTP client keep-alive release before finish", done => {
-  const server = http.createServer((req, res) => {
-    res.end();
-  });
-
-  server.listen(0, () => {
-    const agent = new http.Agent({
-      maxSockets: 1,
-      keepAlive: true,
-    });
-
-    const port = server.address().port;
-
-    const post = http.request(
-      {
-        agent,
-        method: "POST",
-        port,
-      },
-      res => {
-        res.resume();
-      },
-    );
-
-    // What happens here is that the server `end`s the response before we send
-    // `something`, and the client thought that this is a green light for sending
-    // next GET request
-    post.write(Buffer.alloc(16 * 1024, "X"));
-    setTimeout(() => {
-      post.end("something");
-    }, 100);
-
-    http
-      .request(
-        {
-          agent,
-          method: "GET",
-          port,
-        },
-        res => {
-          server.close();
-          res.connection.end();
-          done();
-        },
-      )
-      .end();
-  });
-});
-
-//<#END_FILE: test-http-client-keep-alive-release-before-finish.js
diff --git a/test/js/node/test/parallel/http-client-race-2.test.js b/test/js/node/test/parallel/http-client-race-2.test.js
deleted file mode 100644
index bc4c83b4f4..0000000000
--- a/test/js/node/test/parallel/http-client-race-2.test.js
+++ /dev/null
@@ -1,136 +0,0 @@
-//#FILE: test-http-client-race-2.js
-//#SHA1: f1e2a4ecdd401cb9fcf615496d1376ce0a94ad73
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-const url = require("url");
-
-//
-// Slight variation on test-http-client-race to test for another race
-// condition involving the parsers FreeList used internally by http.Client.
-//
-
-const body1_s = "1111111111111111";
-const body2_s = "22222";
-const body3_s = "3333333333333333333";
-
-let server;
-let port;
-
-beforeAll(() => {
-  return new Promise(resolve => {
-    server = http.createServer(function (req, res) {
-      const pathname = url.parse(req.url).pathname;
-
-      let body;
-      switch (pathname) {
-        case "/1":
-          body = body1_s;
-          break;
-        case "/2":
-          body = body2_s;
-          break;
-        default:
-          body = body3_s;
-      }
-
-      res.writeHead(200, {
-        "Content-Type": "text/plain",
-        "Content-Length": body.length,
-      });
-      res.end(body);
-    });
-
-    server.listen(0, () => {
-      port = server.address().port;
-      resolve();
-    });
-  });
-});
-
-afterAll(() => {
-  return new Promise(resolve => {
-    server.close(resolve);
-  });
-});
-
-test("HTTP client race condition", async () => {
-  let body1 = "";
-  let body2 = "";
-  let body3 = "";
-
-  // Client #1 is assigned Parser #1
-  const req1 = http.get({ port, path: "/1" });
-  await new Promise(resolve => {
-    req1.on("response", function (res1) {
-      res1.setEncoding("utf8");
-
-      res1.on("data", function (chunk) {
-        body1 += chunk;
-      });
-
-      res1.on("end", function () {
-        // Delay execution a little to allow the 'close' event to be processed
-        // (required to trigger this bug!)
-        setTimeout(resolve, 500);
-      });
-    });
-  });
-
-  // The bug would introduce itself here: Client #2 would be allocated the
-  // parser that previously belonged to Client #1. But we're not finished
-  // with Client #1 yet!
-  //
-  // At this point, the bug would manifest itself and crash because the
-  // internal state of the parser was no longer valid for use by Client #1
-  const req2 = http.get({ port, path: "/2" });
-  await new Promise(resolve => {
-    req2.on("response", function (res2) {
-      res2.setEncoding("utf8");
-      res2.on("data", function (chunk) {
-        body2 += chunk;
-      });
-      res2.on("end", resolve);
-    });
-  });
-
-  // Just to be really sure we've covered all our bases, execute a
-  // request using client2.
-  const req3 = http.get({ port, path: "/3" });
-  await new Promise(resolve => {
-    req3.on("response", function (res3) {
-      res3.setEncoding("utf8");
-      res3.on("data", function (chunk) {
-        body3 += chunk;
-      });
-      res3.on("end", resolve);
-    });
-  });
-
-  expect(body1).toBe(body1_s);
-  expect(body2).toBe(body2_s);
-  expect(body3).toBe(body3_s);
-});
-
-//<#END_FILE: test-http-client-race-2.js
diff --git a/test/js/node/test/parallel/http-client-race.test.js b/test/js/node/test/parallel/http-client-race.test.js
deleted file mode 100644
index ab780f28d8..0000000000
--- a/test/js/node/test/parallel/http-client-race.test.js
+++ /dev/null
@@ -1,72 +0,0 @@
-//#FILE: test-http-client-race.js
-//#SHA1: 0ad515567d91a194670069b476e166d398543cc0
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-const url = require("url");
-
-const body1_s = "1111111111111111";
-const body2_s = "22222";
-
-test("http client race condition", async () => {
-  const server = http.createServer((req, res) => {
-    const body = url.parse(req.url).pathname === "/1" ? body1_s : body2_s;
-    res.writeHead(200, {
-      "Content-Type": "text/plain",
-      "Content-Length": body.length,
-    });
-    res.end(body);
-  });
-
-  await new Promise(resolve => server.listen(0, resolve));
-
-  let body1 = "";
-  let body2 = "";
-
-  const makeRequest = path => {
-    return new Promise((resolve, reject) => {
-      const req = http.request({ port: server.address().port, path });
-      req.end();
-      req.on("response", res => {
-        res.setEncoding("utf8");
-        let body = "";
-        res.on("data", chunk => {
-          body += chunk;
-        });
-        res.on("end", () => resolve(body));
-      });
-      req.on("error", reject);
-    });
-  };
-
-  body1 = await makeRequest("/1");
-  body2 = await makeRequest("/2");
-
-  await new Promise(resolve => server.close(resolve));
-
-  expect(body1).toBe(body1_s);
-  expect(body2).toBe(body2_s);
-});
-
-//<#END_FILE: test-http-client-race.js
diff --git a/test/js/node/test/parallel/http-client-read-in-error.test.js b/test/js/node/test/parallel/http-client-read-in-error.test.js
deleted file mode 100644
index 2dd33c52de..0000000000
--- a/test/js/node/test/parallel/http-client-read-in-error.test.js
+++ /dev/null
@@ -1,59 +0,0 @@
-//#FILE: test-http-client-read-in-error.js
-//#SHA1: a7bd75283f46ff8f1246208c72bf0773a27f0fb0
-//-----------------
-"use strict";
-
-const net = require("net");
-const http = require("http");
-
-class Agent extends http.Agent {
-  createConnection() {
-    const socket = new net.Socket();
-
-    socket.on("error", function () {
-      socket.push("HTTP/1.1 200\r\n\r\n");
-    });
-
-    let onNewListener;
-    socket.on(
-      "newListener",
-      (onNewListener = name => {
-        if (name !== "error") return;
-        socket.removeListener("newListener", onNewListener);
-
-        // Let other listeners to be set up too
-        process.nextTick(() => {
-          this.breakSocket(socket);
-        });
-      }),
-    );
-
-    return socket;
-  }
-
-  breakSocket(socket) {
-    socket.emit("error", new Error("Intentional error"));
-  }
-}
-
-test("http client read in error", () => {
-  const agent = new Agent();
-  const dataHandler = jest.fn();
-
-  const request = http.request({ agent });
-
-  request.once("error", function () {
-    console.log("ignore");
-    this.on("data", dataHandler);
-  });
-
-  return new Promise(resolve => {
-    // Give some time for the 'data' event to potentially be called
-    setTimeout(() => {
-      expect(dataHandler).not.toHaveBeenCalled();
-      resolve();
-    }, 100);
-  });
-});
-
-//<#END_FILE: test-http-client-read-in-error.js
diff --git a/test/js/node/test/parallel/http-client-res-destroyed.test.js b/test/js/node/test/parallel/http-client-res-destroyed.test.js
deleted file mode 100644
index 7b7662ea52..0000000000
--- a/test/js/node/test/parallel/http-client-res-destroyed.test.js
+++ /dev/null
@@ -1,59 +0,0 @@
-//#FILE: test-http-client-res-destroyed.js
-//#SHA1: 9a7e890355cecb3eb88b6963b0c37df3f01bc8d7
-//-----------------
-"use strict";
-
-const http = require("http");
-
-describe("HTTP Client Response Destroyed", () => {
-  test("Response destruction after manually calling destroy()", async () => {
-    const server = http.createServer((req, res) => {
-      res.end("asd");
-    });
-
-    await new Promise(resolve => {
-      server.listen(0, () => {
-        http.get(
-          {
-            port: server.address().port,
-          },
-          res => {
-            expect(res.destroyed).toBe(false);
-            res.destroy();
-            expect(res.destroyed).toBe(true);
-            res.on("close", () => {
-              server.close(resolve);
-            });
-          },
-        );
-      });
-    });
-  });
-
-  test("Response destruction after end of response", async () => {
-    const server = http.createServer((req, res) => {
-      res.end("asd");
-    });
-
-    await new Promise(resolve => {
-      server.listen(0, () => {
-        http.get(
-          {
-            port: server.address().port,
-          },
-          res => {
-            expect(res.destroyed).toBe(false);
-            res
-              .on("close", () => {
-                expect(res.destroyed).toBe(true);
-                server.close(resolve);
-              })
-              .resume();
-          },
-        );
-      });
-    });
-  });
-});
-
-//<#END_FILE: test-http-client-res-destroyed.js
diff --git a/test/js/node/test/parallel/http-client-timeout-connect-listener.test.js b/test/js/node/test/parallel/http-client-timeout-connect-listener.test.js
deleted file mode 100644
index a70f33512b..0000000000
--- a/test/js/node/test/parallel/http-client-timeout-connect-listener.test.js
+++ /dev/null
@@ -1,73 +0,0 @@
-//#FILE: test-http-client-timeout-connect-listener.js
-//#SHA1: 4311732db4ce9958ec0ed01be68786e522ed6ca8
-//-----------------
-"use strict";
-
-// This test ensures that `ClientRequest.prototype.setTimeout()` does
-// not add a listener for the `'connect'` event to the socket if the
-// socket is already connected.
-
-const http = require("http");
-
-// Maximum allowed value for timeouts.
-const timeout = 2 ** 31 - 1;
-
-let server;
-let agent;
-
-beforeAll(() => {
-  return new Promise(resolve => {
-    server = http.createServer((req, res) => {
-      res.end();
-    });
-
-    server.listen(0, () => {
-      agent = new http.Agent({ keepAlive: true, maxSockets: 1 });
-      resolve();
-    });
-  });
-});
-
-afterAll(() => {
-  return new Promise(resolve => {
-    agent.destroy();
-    server.close(resolve);
-  });
-});
-
-function doRequest(options) {
-  return new Promise(resolve => {
-    const req = http.get(options, res => {
-      res.on("end", resolve);
-      res.resume();
-    });
-
-    req.setTimeout(timeout);
-    return req;
-  });
-}
-
-test("ClientRequest.prototype.setTimeout() does not add connect listener to connected socket", async () => {
-  const options = { port: server.address().port, agent: agent };
-
-  await doRequest(options);
-
-  const req = http.get(options);
-  req.setTimeout(timeout);
-
-  await new Promise(resolve => {
-    req.on("socket", socket => {
-      expect(socket.listenerCount("connect")).toBe(0);
-      resolve();
-    });
-  });
-
-  await new Promise(resolve => {
-    req.on("response", res => {
-      res.on("end", resolve);
-      res.resume();
-    });
-  });
-});
-
-//<#END_FILE: test-http-client-timeout-connect-listener.js
diff --git a/test/js/node/test/parallel/http-client-timeout-event.test.js b/test/js/node/test/parallel/http-client-timeout-event.test.js
deleted file mode 100644
index bfff317e47..0000000000
--- a/test/js/node/test/parallel/http-client-timeout-event.test.js
+++ /dev/null
@@ -1,65 +0,0 @@
-//#FILE: test-http-client-timeout-event.js
-//#SHA1: b4aeb9d5d97b5ffa46c8c281fbc04d052857b08f
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-
-const options = {
-  method: "GET",
-  port: undefined,
-  host: "127.0.0.1",
-  path: "/",
-};
-
-test("http client timeout event", async () => {
-  const server = http.createServer();
-
-  await new Promise(resolve => {
-    server.listen(0, options.host, () => {
-      options.port = server.address().port;
-      const req = http.request(options);
-
-      req.on("error", () => {
-        // This space is intentionally left blank
-      });
-
-      req.on("close", () => {
-        expect(req.destroyed).toBe(true);
-        server.close();
-        resolve();
-      });
-
-      req.setTimeout(1);
-      req.on("timeout", () => {
-        req.end(() => {
-          setTimeout(() => {
-            req.destroy();
-          }, 100);
-        });
-      });
-    });
-  });
-});
-
-//<#END_FILE: test-http-client-timeout-event.js
diff --git a/test/js/node/test/parallel/http-client-timeout.test.js b/test/js/node/test/parallel/http-client-timeout.test.js
deleted file mode 100644
index 557b469490..0000000000
--- a/test/js/node/test/parallel/http-client-timeout.test.js
+++ /dev/null
@@ -1,60 +0,0 @@
-//#FILE: test-http-client-timeout.js
-//#SHA1: f99a3189acb9c566e378f9fa48c66dd503034d0d
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-
-const options = {
-  method: "GET",
-  port: undefined,
-  host: "127.0.0.1",
-  path: "/",
-};
-
-test("http client timeout", done => {
-  const server = http.createServer((req, res) => {
-    // This space intentionally left blank
-  });
-
-  server.listen(0, options.host, () => {
-    options.port = server.address().port;
-    const req = http.request(options, res => {
-      // This space intentionally left blank
-    });
-    req.on("close", () => {
-      expect(req.destroyed).toBe(true);
-      server.close();
-      done();
-    });
-    function destroy() {
-      req.destroy();
-    }
-    const s = req.setTimeout(1, destroy);
-    expect(s).toBeInstanceOf(http.ClientRequest);
-    req.on("error", destroy);
-    req.end();
-  });
-});
-
-//<#END_FILE: test-http-client-timeout.js
diff --git a/test/js/node/test/parallel/http-client-upload-buf.test.js b/test/js/node/test/parallel/http-client-upload-buf.test.js
deleted file mode 100644
index 9891a442dc..0000000000
--- a/test/js/node/test/parallel/http-client-upload-buf.test.js
+++ /dev/null
@@ -1,77 +0,0 @@
-//#FILE: test-http-client-upload-buf.js
-//#SHA1: bbfd7c52e710f53683f5f9a4578f34e451db4eb0
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const assert = require("assert");
-const http = require("http");
-
-const N = 1024;
-
-test("HTTP client upload buffer", async () => {
-  const server = http.createServer((req, res) => {
-    expect(req.method).toBe("POST");
-    let bytesReceived = 0;
-
-    req.on("data", chunk => {
-      bytesReceived += chunk.length;
-    });
-
-    req.on("end", () => {
-      expect(bytesReceived).toBe(N);
-      console.log("request complete from server");
-      res.writeHead(200, { "Content-Type": "text/plain" });
-      res.write("hello\n");
-      res.end();
-    });
-  });
-
-  await new Promise(resolve => server.listen(0, resolve));
-
-  const { port } = server.address();
-
-  const responsePromise = new Promise(resolve => {
-    const req = http.request(
-      {
-        port,
-        method: "POST",
-        path: "/",
-      },
-      res => {
-        res.setEncoding("utf8");
-        res.on("data", chunk => {
-          console.log(chunk);
-        });
-        res.on("end", resolve);
-      },
-    );
-
-    req.write(Buffer.allocUnsafe(N));
-    req.end();
-  });
-
-  await responsePromise;
-  await new Promise(resolve => server.close(resolve));
-});
-
-//<#END_FILE: test-http-client-upload-buf.js
diff --git a/test/js/node/test/parallel/http-client-upload.test.js b/test/js/node/test/parallel/http-client-upload.test.js
deleted file mode 100644
index 6adc480232..0000000000
--- a/test/js/node/test/parallel/http-client-upload.test.js
+++ /dev/null
@@ -1,84 +0,0 @@
-//#FILE: test-http-client-upload.js
-//#SHA1: 328a7e9989cc28daa5996c83fe9e3cfcb0893e01
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-
-test("HTTP client upload", async () => {
-  const serverHandler = jest.fn((req, res) => {
-    expect(req.method).toBe("POST");
-    req.setEncoding("utf8");
-
-    let sent_body = "";
-
-    req.on("data", chunk => {
-      console.log(`server got: ${JSON.stringify(chunk)}`);
-      sent_body += chunk;
-    });
-
-    req.on("end", () => {
-      expect(sent_body).toBe("1\n2\n3\n");
-      console.log("request complete from server");
-      res.writeHead(200, { "Content-Type": "text/plain" });
-      res.write("hello\n");
-      res.end();
-    });
-  });
-
-  const server = http.createServer(serverHandler);
-  await new Promise(resolve => server.listen(0, resolve));
-
-  const { port } = server.address();
-
-  const clientHandler = jest.fn(res => {
-    res.setEncoding("utf8");
-    res.on("data", chunk => {
-      console.log(chunk);
-    });
-    res.on("end", () => {
-      server.close();
-    });
-  });
-
-  const req = http.request(
-    {
-      port,
-      method: "POST",
-      path: "/",
-    },
-    clientHandler,
-  );
-
-  req.write("1\n");
-  req.write("2\n");
-  req.write("3\n");
-  req.end();
-
-  await new Promise(resolve => server.on("close", resolve));
-
-  expect(serverHandler).toHaveBeenCalledTimes(1);
-  expect(clientHandler).toHaveBeenCalledTimes(1);
-});
-
-//<#END_FILE: test-http-client-upload.js
diff --git a/test/js/node/test/parallel/http-contentlength0.test.js b/test/js/node/test/parallel/http-contentlength0.test.js
deleted file mode 100644
index 4a6a7fec72..0000000000
--- a/test/js/node/test/parallel/http-contentlength0.test.js
+++ /dev/null
@@ -1,56 +0,0 @@
-//#FILE: test-http-contentLength0.js
-//#SHA1: d85b0cc3dcfcff522ffbeddacf89111897b80c02
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-
-// Simple test of Node's HTTP Client choking on a response
-// with a 'Content-Length: 0 ' response header.
-// I.E. a space character after the 'Content-Length' throws an `error` event.
-
-test("HTTP Client handles Content-Length: 0 with space", async () => {
-  const server = http.createServer((req, res) => {
-    res.writeHead(200, { "Content-Length": "0 " });
-    res.end();
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, resolve);
-  });
-
-  const { port } = server.address();
-
-  await new Promise(resolve => {
-    const request = http.request({ port }, response => {
-      expect(response.statusCode).toBe(200);
-      server.close();
-      response.resume();
-      resolve();
-    });
-
-    request.end();
-  });
-});
-
-//<#END_FILE: test-http-contentLength0.js
diff --git a/test/js/node/test/parallel/http-date-header.test.js b/test/js/node/test/parallel/http-date-header.test.js
deleted file mode 100644
index b47a7163d9..0000000000
--- a/test/js/node/test/parallel/http-date-header.test.js
+++ /dev/null
@@ -1,65 +0,0 @@
-//#FILE: test-http-date-header.js
-//#SHA1: e4d2a00dad7c6483d9ed328731bb04f5f431afb4
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-
-const testResBody = "other stuff!\n";
-
-test("HTTP Date header", async () => {
-  const server = http.createServer((req, res) => {
-    expect(req.headers).not.toHaveProperty("date");
-    res.writeHead(200, {
-      "Content-Type": "text/plain",
-    });
-    res.end(testResBody);
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, resolve);
-  });
-
-  const { port } = server.address();
-
-  const options = {
-    port,
-    path: "/",
-    method: "GET",
-  };
-
-  const responsePromise = new Promise((resolve, reject) => {
-    const req = http.request(options, res => {
-      expect(res.headers).toHaveProperty("date");
-      res.resume();
-      res.on("end", resolve);
-    });
-    req.on("error", reject);
-    req.end();
-  });
-
-  await responsePromise;
-  await new Promise(resolve => server.close(resolve));
-});
-
-//<#END_FILE: test-http-date-header.js
diff --git a/test/js/node/test/parallel/http-decoded-auth.test.js b/test/js/node/test/parallel/http-decoded-auth.test.js
deleted file mode 100644
index ed117d1954..0000000000
--- a/test/js/node/test/parallel/http-decoded-auth.test.js
+++ /dev/null
@@ -1,57 +0,0 @@
-//#FILE: test-http-decoded-auth.js
-//#SHA1: 70ba85653c7479ce80cf528a07aa85f598f85ef8
-//-----------------
-"use strict";
-
-const http = require("http");
-
-const testCases = [
-  {
-    username: 'test@test"',
-    password: "123456^",
-    expected: "dGVzdEB0ZXN0IjoxMjM0NTZe",
-  },
-  {
-    username: "test%40test",
-    password: "123456",
-    expected: "dGVzdEB0ZXN0OjEyMzQ1Ng==",
-  },
-  {
-    username: "not%3Agood",
-    password: "god",
-    expected: "bm90Omdvb2Q6Z29k",
-  },
-  {
-    username: "not%22good",
-    password: "g%5Eod",
-    expected: "bm90Imdvb2Q6Z15vZA==",
-  },
-  {
-    username: "test1234::::",
-    password: "mypass",
-    expected: "dGVzdDEyMzQ6Ojo6Om15cGFzcw==",
-  },
-];
-
-testCases.forEach((testCase, index) => {
-  test(`HTTP decoded auth - case ${index + 1}`, async () => {
-    const server = http.createServer((request, response) => {
-      // The correct authorization header is be passed
-      expect(request.headers.authorization).toBe(`Basic ${testCase.expected}`);
-      response.writeHead(200, {});
-      response.end("ok");
-      server.close();
-    });
-
-    await new Promise(resolve => {
-      server.listen(0, () => {
-        // make the request
-        const url = new URL(`http://${testCase.username}:${testCase.password}@localhost:${server.address().port}`);
-        http.request(url).end();
-        resolve();
-      });
-    });
-  });
-});
-
-//<#END_FILE: test-http-decoded-auth.js
diff --git a/test/js/node/test/parallel/http-default-encoding.test.js b/test/js/node/test/parallel/http-default-encoding.test.js
deleted file mode 100644
index 30fc083b29..0000000000
--- a/test/js/node/test/parallel/http-default-encoding.test.js
+++ /dev/null
@@ -1,73 +0,0 @@
-//#FILE: test-http-default-encoding.js
-//#SHA1: f5dfdba00ec21efec894e5edf97583c77334a2c3
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-
-const expected = "This is a unicode text: سلام";
-
-test("HTTP server with default encoding", async () => {
-  let result = "";
-
-  const server = http.Server((req, res) => {
-    req.setEncoding("utf8");
-    req
-      .on("data", chunk => {
-        result += chunk;
-      })
-      .on("end", () => {
-        res.writeHead(200);
-        res.end("hello world\n");
-        server.close();
-      });
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, () => {
-      const req = http.request(
-        {
-          port: server.address().port,
-          path: "/",
-          method: "POST",
-        },
-        res => {
-          expect(res.statusCode).toBe(200);
-          res.resume();
-          resolve();
-        },
-      );
-
-      req.on("error", e => {
-        console.log(e.message);
-        process.exit(1);
-      });
-
-      req.end(expected);
-    });
-  });
-
-  expect(result).toBe(expected);
-});
-
-//<#END_FILE: test-http-default-encoding.js
diff --git a/test/js/node/test/parallel/http-eof-on-connect.test.js b/test/js/node/test/parallel/http-eof-on-connect.test.js
deleted file mode 100644
index 0cb4da2217..0000000000
--- a/test/js/node/test/parallel/http-eof-on-connect.test.js
+++ /dev/null
@@ -1,55 +0,0 @@
-//#FILE: test-http-eof-on-connect.js
-//#SHA1: c243d7ad215d84d88b20dfeea40976155f00a2bb
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-const net = require("net");
-const http = require("http");
-
-// This is a regression test for https://github.com/joyent/node/issues/44
-// It is separate from test-http-malformed-request.js because it is only
-// reproducible on the first packet on the first connection to a server.
-
-test("EOF on connect", async () => {
-  const server = http.createServer(jest.fn());
-  server.listen(0);
-
-  await new Promise(resolve => {
-    server.on("listening", () => {
-      const client = net.createConnection(server.address().port);
-
-      client.on("connect", () => {
-        client.destroy();
-      });
-
-      client.on("close", () => {
-        server.close(resolve);
-      });
-    });
-  });
-
-  expect(server.listeners("request")[0]).not.toHaveBeenCalled();
-});
-
-//<#END_FILE: test-http-eof-on-connect.js
diff --git a/test/js/node/test/parallel/http-extra-response.test.js b/test/js/node/test/parallel/http-extra-response.test.js
deleted file mode 100644
index b3e73a341a..0000000000
--- a/test/js/node/test/parallel/http-extra-response.test.js
+++ /dev/null
@@ -1,98 +0,0 @@
-//#FILE: test-http-extra-response.js
-//#SHA1: 0d2dfa2459e54fa9f1b90a609c328afd478f2793
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-const net = require("net");
-
-// If an HTTP server is broken and sends data after the end of the response,
-// node should ignore it and drop the connection.
-// Demos this bug: https://github.com/joyent/node/issues/680
-
-const body = "hello world\r\n";
-const fullResponse =
-  "HTTP/1.1 500 Internal Server Error\r\n" +
-  `Content-Length: ${body.length}\r\n` +
-  "Content-Type: text/plain\r\n" +
-  "Date: Fri + 18 Feb 2011 06:22:45 GMT\r\n" +
-  "Host: 10.20.149.2\r\n" +
-  "Access-Control-Allow-Credentials: true\r\n" +
-  "Server: badly broken/0.1 (OS NAME)\r\n" +
-  "\r\n" +
-  body;
-
-test("HTTP server sending data after response end", async () => {
-  const server = net.createServer(socket => {
-    let postBody = "";
-
-    socket.setEncoding("utf8");
-
-    socket.on("data", chunk => {
-      postBody += chunk;
-
-      if (postBody.includes("\r\n")) {
-        socket.write(fullResponse);
-        socket.end(fullResponse);
-      }
-    });
-
-    socket.on("error", err => {
-      expect(err.code).toBe("ECONNRESET");
-    });
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, resolve);
-  });
-
-  const { port } = server.address();
-
-  const consoleLogSpy = jest.spyOn(console, "log").mockImplementation();
-
-  await new Promise(resolve => {
-    http.get({ port }, res => {
-      let buffer = "";
-      console.log(`Got res code: ${res.statusCode}`);
-
-      res.setEncoding("utf8");
-      res.on("data", chunk => {
-        buffer += chunk;
-      });
-
-      res.on("end", () => {
-        console.log(`Response ended, read ${buffer.length} bytes`);
-        expect(buffer).toBe(body);
-        resolve();
-      });
-    });
-  });
-
-  expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringMatching(/Got res code: \d+/));
-  expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringMatching(/Response ended, read \d+ bytes/));
-
-  consoleLogSpy.mockRestore();
-  await new Promise(resolve => server.close(resolve));
-});
-
-//<#END_FILE: test-http-extra-response.js
diff --git a/test/js/node/test/parallel/http-full-response.test.js b/test/js/node/test/parallel/http-full-response.test.js
deleted file mode 100644
index 8e0a8fcc3b..0000000000
--- a/test/js/node/test/parallel/http-full-response.test.js
+++ /dev/null
@@ -1,104 +0,0 @@
-//#FILE: test-http-full-response.js
-//#SHA1: 3494c79026bf858a01bb497a50a8f2fd3166e62d
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-// This test requires the program 'ab'
-const http = require("http");
-const { exec } = require("child_process");
-
-const bodyLength = 12345;
-
-const body = "c".repeat(bodyLength);
-
-let server;
-
-beforeAll(() => {
-  return new Promise(resolve => {
-    server = http.createServer((req, res) => {
-      res.writeHead(200, {
-        "Content-Length": bodyLength,
-        "Content-Type": "text/plain",
-      });
-      res.end(body);
-    });
-
-    server.listen(0, () => {
-      resolve();
-    });
-  });
-});
-
-afterAll(() => {
-  return new Promise(resolve => {
-    server.close(() => {
-      resolve();
-    });
-  });
-});
-
-function runAb(opts) {
-  return new Promise((resolve, reject) => {
-    const command = `ab ${opts} http://127.0.0.1:${server.address().port}/`;
-    exec(command, (err, stdout, stderr) => {
-      if (err) {
-        if (/ab|apr/i.test(stderr)) {
-          console.log(`Skipping: problem spawning \`ab\`.\n${stderr}`);
-          return resolve();
-        }
-        return reject(err);
-      }
-
-      let m = /Document Length:\s*(\d+) bytes/i.exec(stdout);
-      const documentLength = parseInt(m[1]);
-
-      m = /Complete requests:\s*(\d+)/i.exec(stdout);
-      const completeRequests = parseInt(m[1]);
-
-      m = /HTML transferred:\s*(\d+) bytes/i.exec(stdout);
-      const htmlTransferred = parseInt(m[1]);
-
-      expect(documentLength).toBe(bodyLength);
-      expect(htmlTransferred).toBe(completeRequests * documentLength);
-
-      resolve();
-    });
-  });
-}
-
-test("-c 1 -n 10", async () => {
-  await runAb("-c 1 -n 10");
-  console.log("-c 1 -n 10 okay");
-});
-
-test("-c 1 -n 100", async () => {
-  await runAb("-c 1 -n 100");
-  console.log("-c 1 -n 100 okay");
-});
-
-test("-c 1 -n 1000", async () => {
-  await runAb("-c 1 -n 1000");
-  console.log("-c 1 -n 1000 okay");
-});
-
-//<#END_FILE: test-http-full-response.js
diff --git a/test/js/node/test/parallel/http-get-pipeline-problem.test.js b/test/js/node/test/parallel/http-get-pipeline-problem.test.js
deleted file mode 100644
index ec0750f018..0000000000
--- a/test/js/node/test/parallel/http-get-pipeline-problem.test.js
+++ /dev/null
@@ -1,98 +0,0 @@
-//#FILE: test-http-get-pipeline-problem.js
-//#SHA1: 422a6c8ae8350bb70627efee734652421322b1bd
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-// In previous versions of Node.js (e.g., 0.6.0), this sort of thing would halt
-// after http.globalAgent.maxSockets number of files.
-// See https://groups.google.com/forum/#!topic/nodejs-dev/V5fB69hFa9o
-const fixtures = require("../common/fixtures");
-const http = require("http");
-const fs = require("fs");
-const tmpdir = require("../common/tmpdir");
-
-http.globalAgent.maxSockets = 1;
-
-tmpdir.refresh();
-
-const image = fixtures.readSync("/person.jpg");
-
-console.log(`image.length = ${image.length}`);
-
-const total = 10;
-
-test("HTTP GET pipeline problem", async () => {
-  const server = http.createServer((req, res) => {
-    setTimeout(() => {
-      res.writeHead(200, {
-        "content-type": "image/jpeg",
-        connection: "close",
-        "content-length": image.length,
-      });
-      res.end(image);
-    }, 1);
-  });
-
-  await new Promise(resolve => server.listen(0, resolve));
-
-  const serverAddress = server.address();
-
-  const requests = Array.from({ length: total }, (_, i) => {
-    return new Promise((resolve, reject) => {
-      const opts = {
-        port: serverAddress.port,
-        headers: { connection: "close" },
-      };
-
-      http
-        .get(opts, res => {
-          console.error(`recv ${i}`);
-          const s = fs.createWriteStream(`${tmpdir.path}/${i}.jpg`);
-          res.pipe(s);
-
-          s.on("finish", () => {
-            console.error(`done ${i}`);
-            resolve();
-          });
-        })
-        .on("error", reject);
-    });
-  });
-
-  await Promise.all(requests);
-
-  // Check files
-  const files = fs.readdirSync(tmpdir.path);
-  expect(files.length).toBeGreaterThanOrEqual(total);
-
-  for (let i = 0; i < total; i++) {
-    const fn = `${i}.jpg`;
-    expect(files).toContain(fn);
-    const stat = fs.statSync(`${tmpdir.path}/${fn}`);
-    expect(stat.size).toBe(image.length);
-  }
-
-  server.close();
-});
-
-//<#END_FILE: test-http-get-pipeline-problem.js
diff --git a/test/js/node/test/parallel/http-head-request.test.js b/test/js/node/test/parallel/http-head-request.test.js
deleted file mode 100644
index b2f86c5ac2..0000000000
--- a/test/js/node/test/parallel/http-head-request.test.js
+++ /dev/null
@@ -1,76 +0,0 @@
-//#FILE: test-http-head-request.js
-//#SHA1: ab54d1748aa92e4fa61cf4994e83ddf5e00bf874
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-
-const body = "hello world\n";
-
-async function runTest(headers) {
-  return new Promise((resolve, reject) => {
-    const server = http.createServer((req, res) => {
-      console.error("req: %s headers: %j", req.method, headers);
-      res.writeHead(200, headers);
-      res.end();
-      server.close();
-    });
-
-    server.listen(0, () => {
-      const request = http.request(
-        {
-          port: server.address().port,
-          method: "HEAD",
-          path: "/",
-        },
-        response => {
-          console.error("response start");
-          response.on("end", () => {
-            console.error("response end");
-            resolve();
-          });
-          response.resume();
-        },
-      );
-      request.end();
-    });
-  });
-}
-
-test("HEAD request with Transfer-Encoding: chunked", async () => {
-  await expect(
-    runTest({
-      "Transfer-Encoding": "chunked",
-    }),
-  ).resolves.toBeUndefined();
-});
-
-test("HEAD request with Content-Length", async () => {
-  await expect(
-    runTest({
-      "Content-Length": body.length,
-    }),
-  ).resolves.toBeUndefined();
-});
-
-//<#END_FILE: test-http-head-request.js
diff --git a/test/js/node/test/parallel/http-head-response-has-no-body-end-implicit-headers.test.js b/test/js/node/test/parallel/http-head-response-has-no-body-end-implicit-headers.test.js
deleted file mode 100644
index 46f4f2269d..0000000000
--- a/test/js/node/test/parallel/http-head-response-has-no-body-end-implicit-headers.test.js
+++ /dev/null
@@ -1,36 +0,0 @@
-//#FILE: test-http-head-response-has-no-body-end-implicit-headers.js
-//#SHA1: e2f884b0a99ba30e0e8065596d00af1ed99b4791
-//-----------------
-"use strict";
-const http = require("http");
-
-// This test is to make sure that when the HTTP server
-// responds to a HEAD request with data to res.end,
-// it does not send any body but the response is sent
-// anyway.
-
-test("HTTP HEAD response has no body, end implicit headers", done => {
-  const server = http.createServer((req, res) => {
-    res.end("FAIL"); // broken: sends FAIL from hot path.
-  });
-
-  server.listen(0, () => {
-    const req = http.request(
-      {
-        port: server.address().port,
-        method: "HEAD",
-        path: "/",
-      },
-      res => {
-        res.on("end", () => {
-          server.close();
-          done();
-        });
-        res.resume();
-      },
-    );
-    req.end();
-  });
-});
-
-//<#END_FILE: test-http-head-response-has-no-body-end-implicit-headers.js
diff --git a/test/js/node/test/parallel/http-head-response-has-no-body-end.test.js b/test/js/node/test/parallel/http-head-response-has-no-body-end.test.js
deleted file mode 100644
index 5d18311eb5..0000000000
--- a/test/js/node/test/parallel/http-head-response-has-no-body-end.test.js
+++ /dev/null
@@ -1,62 +0,0 @@
-//#FILE: test-http-head-response-has-no-body-end.js
-//#SHA1: 64091937f68588f23597f106fa906d27380be005
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-
-// This test is to make sure that when the HTTP server
-// responds to a HEAD request with data to res.end,
-// it does not send any body.
-
-test("HTTP server responds to HEAD request without sending body", async () => {
-  const server = http.createServer((req, res) => {
-    res.writeHead(200);
-    res.end("FAIL"); // broken: sends FAIL from hot path.
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, () => {
-      const req = http.request(
-        {
-          port: server.address().port,
-          method: "HEAD",
-          path: "/",
-        },
-        res => {
-          const onEnd = jest.fn();
-          res.on("end", onEnd);
-          res.resume();
-
-          res.on("end", () => {
-            expect(onEnd).toHaveBeenCalledTimes(1);
-            server.close(resolve);
-          });
-        },
-      );
-      req.end();
-    });
-  });
-});
-
-//<#END_FILE: test-http-head-response-has-no-body-end.js
diff --git a/test/js/node/test/parallel/http-head-response-has-no-body.test.js b/test/js/node/test/parallel/http-head-response-has-no-body.test.js
deleted file mode 100644
index f87fece95a..0000000000
--- a/test/js/node/test/parallel/http-head-response-has-no-body.test.js
+++ /dev/null
@@ -1,65 +0,0 @@
-//#FILE: test-http-head-response-has-no-body.js
-//#SHA1: f7df6559885b0465d43994e773c961b525b195a9
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-
-// This test is to make sure that when the HTTP server
-// responds to a HEAD request, it does not send any body.
-// In this case it was sending '0\r\n\r\n'
-
-test("HTTP server responds to HEAD request without body", async () => {
-  const server = http.createServer((req, res) => {
-    res.writeHead(200); // broken: defaults to TE chunked
-    res.end();
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, resolve);
-  });
-
-  const { port } = server.address();
-
-  await new Promise((resolve, reject) => {
-    const req = http.request(
-      {
-        port,
-        method: "HEAD",
-        path: "/",
-      },
-      res => {
-        res.on("end", () => {
-          server.close(() => {
-            resolve();
-          });
-        });
-        res.resume();
-      },
-    );
-    req.on("error", reject);
-    req.end();
-  });
-});
-
-//<#END_FILE: test-http-head-response-has-no-body.js
diff --git a/test/js/node/test/parallel/http-header-obstext.test.js b/test/js/node/test/parallel/http-header-obstext.test.js
deleted file mode 100644
index 55248d91c4..0000000000
--- a/test/js/node/test/parallel/http-header-obstext.test.js
+++ /dev/null
@@ -1,35 +0,0 @@
-//#FILE: test-http-header-obstext.js
-//#SHA1: 031a5230bc91c831407772f2b8cbeba3559ed1d2
-//-----------------
-"use strict";
-
-// This test ensures that the http-parser can handle UTF-8 characters
-// in the http header.
-
-const http = require("http");
-
-test("http-parser can handle UTF-8 characters in http header", async () => {
-  const server = http.createServer((req, res) => {
-    res.end("ok");
-  });
-
-  await new Promise(resolve => server.listen(0, resolve));
-
-  const { port } = server.address();
-
-  const response = await new Promise(resolve => {
-    http.get(
-      {
-        port,
-        headers: { Test: "Düsseldorf" },
-      },
-      resolve,
-    );
-  });
-
-  expect(response.statusCode).toBe(200);
-
-  await new Promise(resolve => server.close(resolve));
-});
-
-//<#END_FILE: test-http-header-obstext.js
diff --git a/test/js/node/test/parallel/http-header-owstext.test.js b/test/js/node/test/parallel/http-header-owstext.test.js
deleted file mode 100644
index cfab935f17..0000000000
--- a/test/js/node/test/parallel/http-header-owstext.test.js
+++ /dev/null
@@ -1,55 +0,0 @@
-//#FILE: test-http-header-owstext.js
-//#SHA1: 339bfcf13a4cc9caa39940de3854eeda01b4500c
-//-----------------
-"use strict";
-
-const http = require("http");
-const net = require("net");
-
-// This test ensures that the http-parser strips leading and trailing OWS from
-// header values. It sends the header values in chunks to force the parser to
-// build the string up through multiple calls to on_header_value().
-
-function check(hdr, snd, rcv) {
-  return new Promise(resolve => {
-    const server = http.createServer((req, res) => {
-      expect(req.headers[hdr]).toBe(rcv);
-      req.pipe(res);
-    });
-
-    server.listen(0, function () {
-      const client = net.connect(this.address().port, start);
-      function start() {
-        client.write("GET / HTTP/1.1\r\n" + hdr + ":", drain);
-      }
-
-      function drain() {
-        if (snd.length === 0) {
-          return client.write("\r\nConnection: close\r\n\r\n");
-        }
-        client.write(snd.shift(), drain);
-      }
-
-      const bufs = [];
-      client.on("data", function (chunk) {
-        bufs.push(chunk);
-      });
-      client.on("end", function () {
-        const head = Buffer.concat(bufs).toString("latin1").split("\r\n")[0];
-        expect(head).toBe("HTTP/1.1 200 OK");
-        server.close();
-        resolve();
-      });
-    });
-  });
-}
-
-test("http header OWS text parsing", async () => {
-  await check("host", [" \t foo.com\t"], "foo.com");
-  await check("host", [" \t foo\tcom\t"], "foo\tcom");
-  await check("host", [" \t", " ", " foo.com\t", "\t "], "foo.com");
-  await check("host", [" \t", " \t".repeat(100), "\t "], "");
-  await check("host", [" \t", " - - - -   ", "\t "], "- - - -");
-});
-
-//<#END_FILE: test-http-header-owstext.js
diff --git a/test/js/node/test/parallel/http-host-headers.test.js b/test/js/node/test/parallel/http-host-headers.test.js
deleted file mode 100644
index cb50ca9b04..0000000000
--- a/test/js/node/test/parallel/http-host-headers.test.js
+++ /dev/null
@@ -1,77 +0,0 @@
-//#FILE: test-http-host-headers.js
-//#SHA1: 256e8b55e2c545a9f9df89607600f18a93c1c67a
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-
-function reqHandler(req, res) {
-  if (req.url === "/setHostFalse5") {
-    expect(req.headers.host).toBeUndefined();
-  } else {
-    expect(req.headers.host).toBe(`localhost:${this.address().port}`);
-  }
-  res.writeHead(200, {});
-  res.end("ok");
-}
-
-const httpServer = http.createServer(reqHandler);
-
-test("HTTP host headers", async () => {
-  await new Promise(resolve => {
-    httpServer.listen(0, async () => {
-      const port = httpServer.address().port;
-      const makeRequest = (method, path) => {
-        return new Promise(resolve => {
-          const req = http.request(
-            {
-              method,
-              path,
-              host: "localhost",
-              port,
-              rejectUnauthorized: false,
-            },
-            res => {
-              res.resume();
-              resolve();
-            },
-          );
-          req.on("error", () => {
-            throw new Error("Request should not fail");
-          });
-          req.end();
-        });
-      };
-
-      await makeRequest("GET", "/0");
-      await makeRequest("GET", "/1");
-      await makeRequest("POST", "/2");
-      await makeRequest("PUT", "/3");
-      await makeRequest("DELETE", "/4");
-
-      httpServer.close(resolve);
-    });
-  });
-});
-
-//<#END_FILE: test-http-host-headers.js
diff --git a/test/js/node/test/parallel/http-keep-alive-timeout-custom.test.js b/test/js/node/test/parallel/http-keep-alive-timeout-custom.test.js
deleted file mode 100644
index 9d0e874e81..0000000000
--- a/test/js/node/test/parallel/http-keep-alive-timeout-custom.test.js
+++ /dev/null
@@ -1,43 +0,0 @@
-//#FILE: test-http-keep-alive-timeout-custom.js
-//#SHA1: 4f7c5a20da7b46bea9198b3854aed7c2042a8691
-//-----------------
-"use strict";
-
-const http = require("http");
-
-test("HTTP Keep-Alive timeout custom", async () => {
-  const server = http.createServer((req, res) => {
-    const body = "hello world\n";
-
-    res.writeHead(200, {
-      "Content-Length": body.length,
-      "Keep-Alive": "timeout=50",
-    });
-    res.write(body);
-    res.end();
-  });
-  server.keepAliveTimeout = 12010;
-
-  const agent = new http.Agent({ maxSockets: 1, keepAlive: true });
-
-  await new Promise(resolve => {
-    server.listen(0, () => {
-      http.get(
-        {
-          path: "/",
-          port: server.address().port,
-          agent: agent,
-        },
-        response => {
-          response.resume();
-          expect(response.headers["keep-alive"]).toBe("timeout=50");
-          server.close();
-          agent.destroy();
-          resolve();
-        },
-      );
-    });
-  });
-});
-
-//<#END_FILE: test-http-keep-alive-timeout-custom.js
diff --git a/test/js/node/test/parallel/http-many-ended-pipelines.test.js b/test/js/node/test/parallel/http-many-ended-pipelines.test.js
deleted file mode 100644
index c142011e0d..0000000000
--- a/test/js/node/test/parallel/http-many-ended-pipelines.test.js
+++ /dev/null
@@ -1,82 +0,0 @@
-//#FILE: test-http-many-ended-pipelines.js
-//#SHA1: 930bb6dc614c68f965c7b31e9a1223386234e389
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-const net = require("net");
-
-const numRequests = 20;
-let first = false;
-
-test("HTTP server handles many ended pipelines", async () => {
-  const server = http.createServer((req, res) => {
-    if (!first) {
-      first = true;
-      req.socket.on("close", () => {
-        server.close();
-      });
-    }
-
-    res.end("ok");
-    // Oh no!  The connection died!
-    req.socket.destroy();
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, () => {
-      const client = net.connect({
-        port: server.address().port,
-        allowHalfOpen: true,
-      });
-
-      client.on("error", err => {
-        // The socket might be destroyed by the other peer while data is still
-        // being written. The `'EPIPE'` and `'ECONNABORTED'` codes might also be
-        // valid but they have not been seen yet.
-        expect(err.code).toBe("ECONNRESET");
-      });
-
-      for (let i = 0; i < numRequests; i++) {
-        client.write("GET / HTTP/1.1\r\n" + "Host: some.host.name\r\n" + "\r\n\r\n");
-      }
-      client.end();
-      client.pipe(process.stdout);
-
-      resolve();
-    });
-  });
-});
-
-const mockWarning = jest.spyOn(process, "emit");
-mockWarning.mockImplementation((event, ...args) => {
-  if (event === "warning") return;
-  return process.emit.apply(process, [event, ...args]);
-});
-
-afterAll(() => {
-  expect(mockWarning).not.toHaveBeenCalledWith("warning", expect.anything());
-  mockWarning.mockRestore();
-});
-
-//<#END_FILE: test-http-many-ended-pipelines.js
diff --git a/test/js/node/test/parallel/http-missing-header-separator-cr.test.js b/test/js/node/test/parallel/http-missing-header-separator-cr.test.js
deleted file mode 100644
index 952d726eed..0000000000
--- a/test/js/node/test/parallel/http-missing-header-separator-cr.test.js
+++ /dev/null
@@ -1,89 +0,0 @@
-//#FILE: test-http-missing-header-separator-cr.js
-//#SHA1: 6e213764778e9edddd0fc6a43c9a3183507054c6
-//-----------------
-"use strict";
-
-const http = require("http");
-const net = require("net");
-
-function serverHandler(server, msg) {
-  const client = net.connect(server.address().port, "localhost");
-
-  let response = "";
-
-  client.on("data", chunk => {
-    response += chunk;
-  });
-
-  client.setEncoding("utf8");
-  client.on("error", () => {
-    throw new Error("Client error should not occur");
-  });
-  client.on("end", () => {
-    expect(response).toBe("HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n");
-    server.close();
-  });
-  client.write(msg);
-  client.resume();
-}
-
-test("GET request with invalid header", async () => {
-  const msg = [
-    "GET / HTTP/1.1",
-    "Host: localhost",
-    "Dummy: x\nContent-Length: 23",
-    "",
-    "GET / HTTP/1.1",
-    "Dummy: GET /admin HTTP/1.1",
-    "Host: localhost",
-    "",
-    "",
-  ].join("\r\n");
-
-  const server = http.createServer(() => {
-    throw new Error("Server should not be called");
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, () => {
-      serverHandler(server, msg);
-      resolve();
-    });
-  });
-});
-
-test("POST request with invalid Transfer-Encoding header", async () => {
-  const msg = ["POST / HTTP/1.1", "Host: localhost", "x:x\nTransfer-Encoding: chunked", "", "1", "A", "0", "", ""].join(
-    "\r\n",
-  );
-
-  const server = http.createServer(() => {
-    throw new Error("Server should not be called");
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, () => {
-      serverHandler(server, msg);
-      resolve();
-    });
-  });
-});
-
-test("POST request with invalid header and Transfer-Encoding", async () => {
-  const msg = ["POST / HTTP/1.1", "Host: localhost", "x:\nTransfer-Encoding: chunked", "", "1", "A", "0", "", ""].join(
-    "\r\n",
-  );
-
-  const server = http.createServer(() => {
-    throw new Error("Server should not be called");
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, () => {
-      serverHandler(server, msg);
-      resolve();
-    });
-  });
-});
-
-//<#END_FILE: test-http-missing-header-separator-cr.js
diff --git a/test/js/node/test/parallel/http-no-read-no-dump.test.js b/test/js/node/test/parallel/http-no-read-no-dump.test.js
deleted file mode 100644
index 2085ea1981..0000000000
--- a/test/js/node/test/parallel/http-no-read-no-dump.test.js
+++ /dev/null
@@ -1,86 +0,0 @@
-//#FILE: test-http-no-read-no-dump.js
-//#SHA1: 8548eb47a6eb8ec151b9c60e74b026d983145d26
-//-----------------
-"use strict";
-
-const http = require("http");
-
-let onPause = null;
-
-describe("HTTP no read no dump", () => {
-  let server;
-  let port;
-
-  beforeAll(done => {
-    server = http
-      .createServer((req, res) => {
-        if (req.method === "GET") return res.end();
-
-        res.writeHead(200);
-        res.flushHeaders();
-
-        req.on("close", () => {
-          expect(() => {
-            req.on("end", () => {});
-          }).not.toThrow();
-        });
-
-        req.connection.on("pause", () => {
-          res.end();
-          onPause();
-        });
-      })
-      .listen(0, () => {
-        port = server.address().port;
-        done();
-      });
-  });
-
-  afterAll(done => {
-    server.close(done);
-  });
-
-  test("should handle POST and GET requests correctly", done => {
-    const agent = new http.Agent({
-      maxSockets: 1,
-      keepAlive: true,
-    });
-
-    const post = http.request(
-      {
-        agent,
-        method: "POST",
-        port,
-      },
-      res => {
-        res.resume();
-
-        post.write(Buffer.alloc(64 * 1024).fill("X"));
-        onPause = () => {
-          post.end("something");
-        };
-      },
-    );
-
-    // What happens here is that the server `end`s the response before we send
-    // `something`, and the client thought that this is a green light for sending
-    // next GET request
-    post.write("initial");
-
-    http
-      .request(
-        {
-          agent,
-          method: "GET",
-          port,
-        },
-        res => {
-          res.connection.end();
-          done();
-        },
-      )
-      .end();
-  });
-});
-
-//<#END_FILE: test-http-no-read-no-dump.js
diff --git a/test/js/node/test/parallel/http-outgoing-finish.test.js b/test/js/node/test/parallel/http-outgoing-finish.test.js
deleted file mode 100644
index fa7aab9a23..0000000000
--- a/test/js/node/test/parallel/http-outgoing-finish.test.js
+++ /dev/null
@@ -1,86 +0,0 @@
-//#FILE: test-http-outgoing-finish.js
-//#SHA1: cd9dbce2b1b26369349c30bcd94979b354316128
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-const http = require("http");
-
-test("http outgoing finish", async () => {
-  const server = http.createServer((req, res) => {
-    req.resume();
-    req.on("end", () => {
-      write(res);
-    });
-    server.close();
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, () => {
-      const req = http.request({
-        port: server.address().port,
-        method: "PUT",
-      });
-      write(req);
-      req.on("response", res => {
-        res.resume();
-      });
-      resolve();
-    });
-  });
-});
-
-const buf = Buffer.alloc(1024 * 16, "x");
-function write(out) {
-  const name = out.constructor.name;
-  let finishEvent = false;
-  let endCb = false;
-
-  // First, write until it gets some backpressure
-  while (out.write(buf));
-
-  // Now end, and make sure that we don't get the 'finish' event
-  // before the tick where the cb gets called.  We give it until
-  // nextTick because this is added as a listener before the endcb
-  // is registered.  The order is not what we're testing here, just
-  // that 'finish' isn't emitted until the stream is fully flushed.
-  out.on("finish", () => {
-    finishEvent = true;
-    console.error(`${name} finish event`);
-    process.nextTick(() => {
-      expect(endCb).toBe(true);
-      console.log(`ok - ${name} finishEvent`);
-    });
-  });
-
-  out.end(buf, () => {
-    endCb = true;
-    console.error(`${name} endCb`);
-    process.nextTick(() => {
-      expect(finishEvent).toBe(true);
-      console.log(`ok - ${name} endCb`);
-    });
-  });
-}
-
-//<#END_FILE: test-http-outgoing-finish.js
diff --git a/test/js/node/test/parallel/http-outgoing-finished.test.js b/test/js/node/test/parallel/http-outgoing-finished.test.js
deleted file mode 100644
index 96363b2382..0000000000
--- a/test/js/node/test/parallel/http-outgoing-finished.test.js
+++ /dev/null
@@ -1,68 +0,0 @@
-//#FILE: test-http-outgoing-finished.js
-//#SHA1: 9c1ce8205b113dbb5b4ddfd06c0c90017b344e15
-//-----------------
-"use strict";
-
-const http = require("http");
-const { finished } = require("stream");
-
-let server;
-
-beforeAll(() => {
-  return new Promise(resolve => {
-    server = http
-      .createServer((req, res) => {
-        let closed = false;
-        res
-          .on("close", () => {
-            closed = true;
-            finished(res, () => {
-              server.close();
-            });
-          })
-          .end();
-        finished(res, () => {
-          expect(closed).toBe(true);
-        });
-      })
-      .listen(0, () => {
-        resolve();
-      });
-  });
-});
-
-afterAll(() => {
-  return new Promise(resolve => {
-    server.close(() => {
-      resolve();
-    });
-  });
-});
-
-test("HTTP outgoing finished", done => {
-  const closeHandler = jest.fn();
-  const finishedHandler = jest.fn();
-
-  server.on("request", (req, res) => {
-    res.on("close", closeHandler);
-    finished(res, finishedHandler);
-  });
-
-  http
-    .request({
-      port: server.address().port,
-      method: "GET",
-    })
-    .on("response", res => {
-      res.resume();
-    })
-    .end();
-
-  setTimeout(() => {
-    expect(closeHandler).toHaveBeenCalledTimes(1);
-    expect(finishedHandler).toHaveBeenCalledTimes(1);
-    done();
-  }, 1000);
-});
-
-//<#END_FILE: test-http-outgoing-finished.js
diff --git a/test/js/node/test/parallel/http-outgoing-writablefinished.test.js b/test/js/node/test/parallel/http-outgoing-writablefinished.test.js
deleted file mode 100644
index 2788589d87..0000000000
--- a/test/js/node/test/parallel/http-outgoing-writablefinished.test.js
+++ /dev/null
@@ -1,42 +0,0 @@
-//#FILE: test-http-outgoing-writableFinished.js
-//#SHA1: f3fbc0d89cd03168f3ee92ed586b62dd5e3b8edb
-//-----------------
-"use strict";
-
-const http = require("http");
-
-test("HTTP server response writableFinished", async () => {
-  const server = http.createServer((req, res) => {
-    expect(res.writableFinished).toBe(false);
-    res.on("finish", () => {
-      expect(res.writableFinished).toBe(true);
-      server.close();
-    });
-    res.end();
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, resolve);
-  });
-
-  const port = server.address().port;
-
-  const clientRequest = http.request({
-    port,
-    method: "GET",
-    path: "/",
-  });
-
-  expect(clientRequest.writableFinished).toBe(false);
-
-  await new Promise(resolve => {
-    clientRequest.on("finish", () => {
-      expect(clientRequest.writableFinished).toBe(true);
-      resolve();
-    });
-    clientRequest.end();
-    expect(clientRequest.writableFinished).toBe(false);
-  });
-});
-
-//<#END_FILE: test-http-outgoing-writableFinished.js
diff --git a/test/js/node/test/parallel/http-outgoing-write-types.test.js b/test/js/node/test/parallel/http-outgoing-write-types.test.js
deleted file mode 100644
index 6870939a90..0000000000
--- a/test/js/node/test/parallel/http-outgoing-write-types.test.js
+++ /dev/null
@@ -1,39 +0,0 @@
-//#FILE: test-http-outgoing-write-types.js
-//#SHA1: bdeac2ab8008bea1c7e0b22f8744176dea0410e2
-//-----------------
-"use strict";
-
-const http = require("http");
-
-test("HTTP outgoing write types", async () => {
-  const httpServer = http.createServer((req, res) => {
-    httpServer.close();
-
-    expect(() => {
-      res.write(["Throws."]);
-    }).toThrow(
-      expect.objectContaining({
-        code: "ERR_INVALID_ARG_TYPE",
-      }),
-    );
-
-    // should not throw
-    expect(() => res.write("1a2b3c")).not.toThrow();
-
-    // should not throw
-    expect(() => res.write(new Uint8Array(1024))).not.toThrow();
-
-    // should not throw
-    expect(() => res.write(Buffer.from("1".repeat(1024)))).not.toThrow();
-
-    res.end();
-  });
-
-  await new Promise(resolve => {
-    httpServer.listen(0, () => {
-      http.get({ port: httpServer.address().port }, resolve);
-    });
-  });
-});
-
-//<#END_FILE: test-http-outgoing-write-types.js
diff --git a/test/js/node/test/parallel/http-pause-no-dump.test.js b/test/js/node/test/parallel/http-pause-no-dump.test.js
deleted file mode 100644
index 1f32f2b0a6..0000000000
--- a/test/js/node/test/parallel/http-pause-no-dump.test.js
+++ /dev/null
@@ -1,41 +0,0 @@
-//#FILE: test-http-pause-no-dump.js
-//#SHA1: 30c3bd27f5edd0ba060a0d6833061d1ce6379cd5
-//-----------------
-"use strict";
-
-const http = require("http");
-
-test("HTTP pause should not dump", done => {
-  const server = http.createServer((req, res) => {
-    req.once("data", () => {
-      req.pause();
-      res.writeHead(200);
-      res.end();
-      res.on("finish", () => {
-        expect(req._dumped).toBeFalsy();
-      });
-    });
-  });
-
-  server.listen(0, () => {
-    const req = http.request(
-      {
-        port: server.address().port,
-        method: "POST",
-        path: "/",
-      },
-      res => {
-        expect(res.statusCode).toBe(200);
-        res.resume();
-        res.on("end", () => {
-          server.close();
-          done();
-        });
-      },
-    );
-
-    req.end(Buffer.allocUnsafe(1024));
-  });
-});
-
-//<#END_FILE: test-http-pause-no-dump.js
diff --git a/test/js/node/test/parallel/http-pause-resume-one-end.test.js b/test/js/node/test/parallel/http-pause-resume-one-end.test.js
deleted file mode 100644
index 52198ee8a3..0000000000
--- a/test/js/node/test/parallel/http-pause-resume-one-end.test.js
+++ /dev/null
@@ -1,70 +0,0 @@
-//#FILE: test-http-pause-resume-one-end.js
-//#SHA1: 69f25ca624d470d640d6366b6df27eba31668e96
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-
-test("HTTP server pause and resume", async () => {
-  const server = http.Server(function (req, res) {
-    res.writeHead(200, { "Content-Type": "text/plain" });
-    res.end("Hello World\n");
-    server.close();
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, resolve);
-  });
-
-  const opts = {
-    port: server.address().port,
-    headers: { connection: "close" },
-  };
-
-  await new Promise(resolve => {
-    http.get(opts, res => {
-      res.on(
-        "data",
-        jest.fn().mockImplementation(() => {
-          res.pause();
-          setImmediate(() => {
-            res.resume();
-          });
-        }),
-      );
-
-      res.on("end", () => {
-        expect(res.destroyed).toBe(false);
-      });
-
-      expect(res.destroyed).toBe(false);
-
-      res.on("close", () => {
-        expect(res.destroyed).toBe(true);
-        resolve();
-      });
-    });
-  });
-});
-
-//<#END_FILE: test-http-pause-resume-one-end.js
diff --git a/test/js/node/test/parallel/http-pause.test.js b/test/js/node/test/parallel/http-pause.test.js
deleted file mode 100644
index 74bca8bc34..0000000000
--- a/test/js/node/test/parallel/http-pause.test.js
+++ /dev/null
@@ -1,87 +0,0 @@
-//#FILE: test-http-pause.js
-//#SHA1: d7712077ebe0493c27ffd7180e73fdd409041bf7
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-
-const expectedServer = "Request Body from Client";
-let resultServer = "";
-const expectedClient = "Response Body from Server";
-let resultClient = "";
-
-test("HTTP pause and resume", async () => {
-  const server = http.createServer((req, res) => {
-    console.error("pause server request");
-    req.pause();
-    setTimeout(() => {
-      console.error("resume server request");
-      req.resume();
-      req.setEncoding("utf8");
-      req.on("data", chunk => {
-        resultServer += chunk;
-      });
-      req.on("end", () => {
-        console.error(resultServer);
-        res.writeHead(200);
-        res.end(expectedClient);
-      });
-    }, 100);
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, function () {
-      // Anonymous function rather than arrow function to test `this` value.
-      expect(this).toBe(server);
-      const req = http.request(
-        {
-          port: this.address().port,
-          path: "/",
-          method: "POST",
-        },
-        res => {
-          console.error("pause client response");
-          res.pause();
-          setTimeout(() => {
-            console.error("resume client response");
-            res.resume();
-            res.on("data", chunk => {
-              resultClient += chunk;
-            });
-            res.on("end", () => {
-              console.error(resultClient);
-              server.close();
-              resolve();
-            });
-          }, 100);
-        },
-      );
-      req.end(expectedServer);
-    });
-  });
-
-  expect(resultServer).toBe(expectedServer);
-  expect(resultClient).toBe(expectedClient);
-});
-
-//<#END_FILE: test-http-pause.js
diff --git a/test/js/node/test/parallel/http-pipe-fs.test.js b/test/js/node/test/parallel/http-pipe-fs.test.js
deleted file mode 100644
index 8db6bebdd3..0000000000
--- a/test/js/node/test/parallel/http-pipe-fs.test.js
+++ /dev/null
@@ -1,90 +0,0 @@
-//#FILE: test-http-pipe-fs.js
-//#SHA1: eb13abd37a9e18b0b28077247a7d336b92b79fbc
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-const fs = require("fs");
-const path = require("path");
-const os = require("os");
-
-const NUMBER_OF_STREAMS = 2;
-
-const tmpdir = path.join(os.tmpdir(), "node-test-http-pipe-fs");
-fs.mkdirSync(tmpdir, { recursive: true });
-
-const file = path.join(tmpdir, "http-pipe-fs-test.txt");
-
-describe("HTTP pipe to fs", () => {
-  let server;
-
-  beforeAll(() => {
-    server = http.createServer((req, res) => {
-      const stream = fs.createWriteStream(file);
-      req.pipe(stream);
-      stream.on("close", () => {
-        res.writeHead(200);
-        res.end();
-      });
-    });
-  });
-
-  afterAll(() => {
-    return new Promise(resolve => server.close(resolve));
-  });
-
-  it("should handle multiple concurrent requests", async () => {
-    await new Promise(resolve => server.listen(0, resolve));
-
-    const port = server.address().port;
-    http.globalAgent.maxSockets = 1;
-
-    const makeRequest = () => {
-      return new Promise(resolve => {
-        const req = http.request(
-          {
-            port: port,
-            method: "POST",
-            headers: {
-              "Content-Length": 5,
-            },
-          },
-          res => {
-            res.on("end", resolve);
-            res.resume();
-          },
-        );
-
-        req.end("12345");
-      });
-    };
-
-    const requests = Array(NUMBER_OF_STREAMS).fill().map(makeRequest);
-    await Promise.all(requests);
-
-    expect.assertions(1);
-    expect(true).toBe(true); // Dummy assertion to ensure the test ran
-  });
-});
-
-//<#END_FILE: test-http-pipe-fs.js
diff --git a/test/js/node/test/parallel/http-proxy.test.js b/test/js/node/test/parallel/http-proxy.test.js
deleted file mode 100644
index dbb116434c..0000000000
--- a/test/js/node/test/parallel/http-proxy.test.js
+++ /dev/null
@@ -1,118 +0,0 @@
-//#FILE: test-http-proxy.js
-//#SHA1: 7b000418a5941e059d64a57b2f0b4fdfb43eb71d
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-const url = require("url");
-
-const cookies = [
-  "session_token=; path=/; expires=Sun, 15-Sep-2030 13:48:52 GMT",
-  "prefers_open_id=; path=/; expires=Thu, 01-Jan-1970 00:00:00 GMT",
-];
-
-const headers = { "content-type": "text/plain", "set-cookie": cookies, hello: "world" };
-
-test("HTTP proxy server", async () => {
-  const backend = http.createServer((req, res) => {
-    console.error("backend request");
-    res.writeHead(200, headers);
-    res.write("hello world\n");
-    res.end();
-  });
-
-  const proxy = http.createServer((req, res) => {
-    console.error(`proxy req headers: ${JSON.stringify(req.headers)}`);
-    http.get(
-      {
-        port: backend.address().port,
-        path: url.parse(req.url).pathname,
-      },
-      proxy_res => {
-        console.error(`proxy res headers: ${JSON.stringify(proxy_res.headers)}`);
-
-        expect(proxy_res.headers.hello).toBe("world");
-        expect(proxy_res.headers["content-type"]).toBe("text/plain");
-        expect(proxy_res.headers["set-cookie"]).toEqual(cookies);
-
-        res.writeHead(proxy_res.statusCode, proxy_res.headers);
-
-        proxy_res.on("data", chunk => {
-          res.write(chunk);
-        });
-
-        proxy_res.on("end", () => {
-          res.end();
-          console.error("proxy res");
-        });
-      },
-    );
-  });
-
-  let body = "";
-
-  await new Promise(resolve => {
-    let nlistening = 0;
-    function startReq() {
-      nlistening++;
-      if (nlistening < 2) return;
-
-      http.get(
-        {
-          port: proxy.address().port,
-          path: "/test",
-        },
-        res => {
-          console.error("got res");
-          expect(res.statusCode).toBe(200);
-
-          expect(res.headers.hello).toBe("world");
-          expect(res.headers["content-type"]).toBe("text/plain");
-          expect(res.headers["set-cookie"]).toEqual(cookies);
-
-          res.setEncoding("utf8");
-          res.on("data", chunk => {
-            body += chunk;
-          });
-          res.on("end", () => {
-            proxy.close();
-            backend.close();
-            console.error("closed both");
-            resolve();
-          });
-        },
-      );
-      console.error("client req");
-    }
-
-    console.error("listen proxy");
-    proxy.listen(0, startReq);
-
-    console.error("listen backend");
-    backend.listen(0, startReq);
-  });
-
-  expect(body).toBe("hello world\n");
-});
-
-//<#END_FILE: test-http-proxy.js
diff --git a/test/js/node/test/parallel/http-request-arguments.test.js b/test/js/node/test/parallel/http-request-arguments.test.js
deleted file mode 100644
index d202ccc5af..0000000000
--- a/test/js/node/test/parallel/http-request-arguments.test.js
+++ /dev/null
@@ -1,26 +0,0 @@
-//#FILE: test-http-request-arguments.js
-//#SHA1: c02b492e2dbf5fa6ffcda8a80c3e4ad41bb0c9e5
-//-----------------
-"use strict";
-
-const http = require("http");
-
-// Test providing both a url and options, with the options partially
-// replacing address and port portions of the URL provided.
-test("http.get with url and options", done => {
-  const server = http.createServer((req, res) => {
-    expect(req.url).toBe("/testpath");
-    res.end();
-    server.close();
-  });
-
-  server.listen(0, () => {
-    const port = server.address().port;
-    http.get("http://example.com/testpath", { hostname: "localhost", port }, res => {
-      res.resume();
-      done();
-    });
-  });
-});
-
-//<#END_FILE: test-http-request-arguments.js
diff --git a/test/js/node/test/parallel/http-request-end-twice.test.js b/test/js/node/test/parallel/http-request-end-twice.test.js
deleted file mode 100644
index b1d2c8a209..0000000000
--- a/test/js/node/test/parallel/http-request-end-twice.test.js
+++ /dev/null
@@ -1,47 +0,0 @@
-//#FILE: test-http-request-end-twice.js
-//#SHA1: c8c502b3bf8a681a7acb9afa603a13cebaf1d00e
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-
-test("http request end twice", async () => {
-  const server = http.Server((req, res) => {
-    res.writeHead(200, { "Content-Type": "text/plain" });
-    res.end("hello world\n");
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, () => {
-      const req = http.get({ port: server.address().port }, res => {
-        res.on("end", () => {
-          expect(req.end()).toBe(req);
-          server.close(resolve);
-        });
-        res.resume();
-      });
-    });
-  });
-});
-
-//<#END_FILE: test-http-request-end-twice.js
diff --git a/test/js/node/test/parallel/http-request-end.test.js b/test/js/node/test/parallel/http-request-end.test.js
deleted file mode 100644
index 9ed911d1ad..0000000000
--- a/test/js/node/test/parallel/http-request-end.test.js
+++ /dev/null
@@ -1,74 +0,0 @@
-//#FILE: test-http-request-end.js
-//#SHA1: e86769441d8d182d32d60d4631e32fbcc2675ed9
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-
-const expected = "Post Body For Test";
-
-test("http request end", async () => {
-  const server = http.Server((req, res) => {
-    let result = "";
-
-    req.setEncoding("utf8");
-    req.on("data", chunk => {
-      result += chunk;
-    });
-
-    req.on("end", () => {
-      expect(result).toBe(expected);
-      res.writeHead(200);
-      res.end("hello world\n");
-      server.close();
-    });
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, () => {
-      const req = http
-        .request(
-          {
-            port: server.address().port,
-            path: "/",
-            method: "POST",
-          },
-          res => {
-            expect(res.statusCode).toBe(200);
-            res.resume();
-            resolve();
-          },
-        )
-        .on("error", e => {
-          console.error(e.message);
-          process.exit(1);
-        });
-
-      const result = req.end(expected);
-
-      expect(req).toBe(result);
-    });
-  });
-});
-
-//<#END_FILE: test-http-request-end.js
diff --git a/test/js/node/test/parallel/http-request-large-payload.test.js b/test/js/node/test/parallel/http-request-large-payload.test.js
deleted file mode 100644
index ea69bdc95a..0000000000
--- a/test/js/node/test/parallel/http-request-large-payload.test.js
+++ /dev/null
@@ -1,33 +0,0 @@
-//#FILE: test-http-request-large-payload.js
-//#SHA1: 236870617a867c47c0767e351433c5deb7c87120
-//-----------------
-"use strict";
-
-// This test ensures Node.js doesn't throw an error when making requests with
-// the payload 16kb or more in size.
-// https://github.com/nodejs/node/issues/2821
-
-const http = require("http");
-
-test("HTTP request with large payload", done => {
-  const server = http.createServer((req, res) => {
-    res.writeHead(200);
-    res.end();
-
-    server.close();
-    done();
-  });
-
-  server.listen(0, function () {
-    const req = http.request({
-      method: "POST",
-      port: this.address().port,
-    });
-
-    const payload = Buffer.alloc(16390, "Й");
-    req.write(payload);
-    req.end();
-  });
-});
-
-//<#END_FILE: test-http-request-large-payload.js
diff --git a/test/js/node/test/parallel/http-res-write-after-end.test.js b/test/js/node/test/parallel/http-res-write-after-end.test.js
deleted file mode 100644
index 45a17ed5e7..0000000000
--- a/test/js/node/test/parallel/http-res-write-after-end.test.js
+++ /dev/null
@@ -1,55 +0,0 @@
-//#FILE: test-http-res-write-after-end.js
-//#SHA1: e579896871bf375190397b4f7e99f37cc156e7c9
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-
-test("HTTP response write after end", async () => {
-  const server = http.Server((req, res) => {
-    res.on("error", error => {
-      expect(error).toMatchObject({
-        code: "ERR_STREAM_WRITE_AFTER_END",
-        name: "Error",
-        message: expect.any(String),
-      });
-    });
-
-    res.write("This should write.");
-    res.end();
-
-    const r = res.write("This should raise an error.");
-    // Write after end should return false
-    expect(r).toBe(false);
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, () => {
-      http.get({ port: server.address().port }, res => {
-        server.close(resolve);
-      });
-    });
-  });
-});
-
-//<#END_FILE: test-http-res-write-after-end.js
diff --git a/test/js/node/test/parallel/http-response-readable.test.js b/test/js/node/test/parallel/http-response-readable.test.js
deleted file mode 100644
index 4af51a42e5..0000000000
--- a/test/js/node/test/parallel/http-response-readable.test.js
+++ /dev/null
@@ -1,49 +0,0 @@
-//#FILE: test-http-response-readable.js
-//#SHA1: bfdd12475c68879668c3019c685001244559fb20
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-
-test("HTTP response readable state", async () => {
-  const testServer = new http.Server((req, res) => {
-    res.writeHead(200);
-    res.end("Hello world");
-  });
-
-  await new Promise(resolve => {
-    testServer.listen(0, () => {
-      const port = testServer.address().port;
-      http.get({ port }, res => {
-        expect(res.readable).toBe(true);
-        res.on("end", () => {
-          expect(res.readable).toBe(false);
-          testServer.close(resolve);
-        });
-        res.resume();
-      });
-    });
-  });
-});
-
-//<#END_FILE: test-http-response-readable.js
diff --git a/test/js/node/test/parallel/http-response-writehead-returns-this.test.js b/test/js/node/test/parallel/http-response-writehead-returns-this.test.js
deleted file mode 100644
index 9418c9e6b0..0000000000
--- a/test/js/node/test/parallel/http-response-writehead-returns-this.test.js
+++ /dev/null
@@ -1,29 +0,0 @@
-//#FILE: test-http-response-writehead-returns-this.js
-//#SHA1: 8a079a3635356290e98a1e7c4eb89b97680b3889
-//-----------------
-"use strict";
-
-const http = require("http");
-
-test("http.ServerResponse.writeHead() returns this", done => {
-  const server = http.createServer((req, res) => {
-    res.writeHead(200, { "a-header": "a-header-value" }).end("abc");
-  });
-
-  server.listen(0, () => {
-    http.get({ port: server.address().port }, res => {
-      expect(res.headers["a-header"]).toBe("a-header-value");
-
-      const chunks = [];
-
-      res.on("data", chunk => chunks.push(chunk));
-      res.on("end", () => {
-        expect(Buffer.concat(chunks).toString()).toBe("abc");
-        server.close();
-        done();
-      });
-    });
-  });
-});
-
-//<#END_FILE: test-http-response-writehead-returns-this.js
diff --git a/test/js/node/test/parallel/http-server-close-idle-wait-response.test.js b/test/js/node/test/parallel/http-server-close-idle-wait-response.test.js
deleted file mode 100644
index 415d32e729..0000000000
--- a/test/js/node/test/parallel/http-server-close-idle-wait-response.test.js
+++ /dev/null
@@ -1,38 +0,0 @@
-//#FILE: test-http-server-close-idle-wait-response.js
-//#SHA1: 04c4c10103faabfd084635c9280824668eb0ba18
-//-----------------
-"use strict";
-
-const { createServer, get } = require("http");
-
-test("HTTP server close idle connections after response", async () => {
-  const server = createServer(
-    jest.fn((req, res) => {
-      req.resume();
-
-      setTimeout(() => {
-        res.writeHead(204, { Connection: "keep-alive", "Keep-Alive": "timeout=1" });
-        res.end();
-      }, 1000);
-    }),
-  );
-
-  await new Promise(resolve => {
-    server.listen(0, () => {
-      const port = server.address().port;
-
-      get(`http://localhost:${port}`, res => {
-        server.close();
-      }).on("finish", () => {
-        setTimeout(() => {
-          server.closeIdleConnections();
-          resolve();
-        }, 500);
-      });
-    });
-  });
-
-  expect(server.listeners("request")[0]).toHaveBeenCalledTimes(1);
-});
-
-//<#END_FILE: test-http-server-close-idle-wait-response.js
diff --git a/test/js/node/test/parallel/http-server-delete-parser.test.js b/test/js/node/test/parallel/http-server-delete-parser.test.js
deleted file mode 100644
index f16d12c848..0000000000
--- a/test/js/node/test/parallel/http-server-delete-parser.test.js
+++ /dev/null
@@ -1,36 +0,0 @@
-//#FILE: test-http-server-delete-parser.js
-//#SHA1: 49465ae50d9dac34e834dcb19c02e75b284acdc2
-//-----------------
-"use strict";
-
-const http = require("http");
-
-test("HTTP server deletes parser after write", async () => {
-  const server = http.createServer((req, res) => {
-    res.writeHead(200, { "Content-Type": "text/plain" });
-    res.write("okay", () => {
-      delete res.socket.parser;
-    });
-    res.end();
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, "127.0.0.1", resolve);
-  });
-
-  const { port } = server.address();
-
-  const req = http.request({
-    port,
-    host: "127.0.0.1",
-    method: "GET",
-  });
-
-  await new Promise(resolve => {
-    req.end(resolve);
-  });
-
-  server.close();
-});
-
-//<#END_FILE: test-http-server-delete-parser.js
diff --git a/test/js/node/test/parallel/http-server-multiheaders.test.js b/test/js/node/test/parallel/http-server-multiheaders.test.js
deleted file mode 100644
index f0ba4b4d61..0000000000
--- a/test/js/node/test/parallel/http-server-multiheaders.test.js
+++ /dev/null
@@ -1,87 +0,0 @@
-//#FILE: test-http-server-multiheaders.js
-//#SHA1: 48e657fa74fb8aeeb2d04661ac760ff0cf5bf12a
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-// Verify that the HTTP server implementation handles multiple instances
-// of the same header as per RFC2616: joining the handful of fields by ', '
-// that support it, and dropping duplicates for other fields.
-
-const http = require("http");
-
-test("HTTP server handles multiple instances of the same header correctly", async () => {
-  const server = http.createServer((req, res) => {
-    expect(req.headers.accept).toBe("abc, def, ghijklmnopqrst");
-    expect(req.headers.host).toBe("foo");
-    expect(req.headers["www-authenticate"]).toBe("foo, bar, baz");
-    expect(req.headers["proxy-authenticate"]).toBe("foo, bar, baz");
-    expect(req.headers["x-foo"]).toBe("bingo");
-    expect(req.headers["x-bar"]).toBe("banjo, bango");
-    expect(req.headers["sec-websocket-protocol"]).toBe("chat, share");
-    expect(req.headers["sec-websocket-extensions"]).toBe("foo; 1, bar; 2, baz");
-    expect(req.headers.constructor).toBe("foo, bar, baz");
-
-    res.writeHead(200, { "Content-Type": "text/plain" });
-    res.end("EOF");
-
-    server.close();
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, () => {
-      http.get({
-        host: "localhost",
-        port: server.address().port,
-        path: "/",
-        headers: [
-          ["accept", "abc"],
-          ["accept", "def"],
-          ["Accept", "ghijklmnopqrst"],
-          ["host", "foo"],
-          ["Host", "bar"],
-          ["hOst", "baz"],
-          ["www-authenticate", "foo"],
-          ["WWW-Authenticate", "bar"],
-          ["WWW-AUTHENTICATE", "baz"],
-          ["proxy-authenticate", "foo"],
-          ["Proxy-Authenticate", "bar"],
-          ["PROXY-AUTHENTICATE", "baz"],
-          ["x-foo", "bingo"],
-          ["x-bar", "banjo"],
-          ["x-bar", "bango"],
-          ["sec-websocket-protocol", "chat"],
-          ["sec-websocket-protocol", "share"],
-          ["sec-websocket-extensions", "foo; 1"],
-          ["sec-websocket-extensions", "bar; 2"],
-          ["sec-websocket-extensions", "baz"],
-          ["constructor", "foo"],
-          ["constructor", "bar"],
-          ["constructor", "baz"],
-        ],
-      });
-      resolve();
-    });
-  });
-});
-
-//<#END_FILE: test-http-server-multiheaders.js
diff --git a/test/js/node/test/parallel/http-server-non-utf8-header.test.js b/test/js/node/test/parallel/http-server-non-utf8-header.test.js
deleted file mode 100644
index de10907234..0000000000
--- a/test/js/node/test/parallel/http-server-non-utf8-header.test.js
+++ /dev/null
@@ -1,67 +0,0 @@
-//#FILE: test-http-server-non-utf8-header.js
-//#SHA1: bc84accb29cf80323d0fb55455a596f36a7933b2
-//-----------------
-"use strict";
-const http = require("http");
-
-const nonUtf8Header = "bår";
-const nonUtf8ToLatin1 = Buffer.from(nonUtf8Header).toString("latin1");
-
-test("HTTP server with non-UTF8 header", async () => {
-  const server = http.createServer((req, res) => {
-    res.writeHead(200, ["content-disposition", Buffer.from(nonUtf8Header).toString("binary")]);
-    res.end("hello");
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, () => {
-      http.get({ port: server.address().port }, res => {
-        expect(res.statusCode).toBe(200);
-        expect(res.headers["content-disposition"]).toBe(nonUtf8ToLatin1);
-        res.resume().on("end", () => {
-          server.close(resolve);
-        });
-      });
-    });
-  });
-});
-
-test("HTTP server with multi-value non-UTF8 header", async () => {
-  const server = http.createServer((req, res) => {
-    res.writeHead(200, ["content-disposition", [Buffer.from(nonUtf8Header).toString("binary")]]);
-    res.end("hello");
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, () => {
-      http.get({ port: server.address().port }, res => {
-        expect(res.statusCode).toBe(200);
-        expect(res.headers["content-disposition"]).toBe(nonUtf8ToLatin1);
-        res.resume().on("end", () => {
-          server.close(resolve);
-        });
-      });
-    });
-  });
-});
-
-test("HTTP server with non-UTF8 header and Content-Length", async () => {
-  const server = http.createServer((req, res) => {
-    res.writeHead(200, ["Content-Length", "5", "content-disposition", Buffer.from(nonUtf8Header).toString("binary")]);
-    res.end("hello");
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, () => {
-      http.get({ port: server.address().port }, res => {
-        expect(res.statusCode).toBe(200);
-        expect(res.headers["content-disposition"]).toBe(nonUtf8ToLatin1);
-        res.resume().on("end", () => {
-          server.close(resolve);
-        });
-      });
-    });
-  });
-});
-
-//<#END_FILE: test-http-server-non-utf8-header.js
diff --git a/test/js/node/test/parallel/http-server-options-incoming-message.test.js b/test/js/node/test/parallel/http-server-options-incoming-message.test.js
deleted file mode 100644
index e8c595a1aa..0000000000
--- a/test/js/node/test/parallel/http-server-options-incoming-message.test.js
+++ /dev/null
@@ -1,54 +0,0 @@
-//#FILE: test-http-server-options-incoming-message.js
-//#SHA1: 5d553fff4a2a29f67836269914e5f33b7e91b64e
-//-----------------
-"use strict";
-
-/**
- * This test covers http.Server({ IncomingMessage }) option:
- * With IncomingMessage option the server should use
- * the new class for creating req Object instead of the default
- * http.IncomingMessage.
- */
-const http = require("http");
-
-class MyIncomingMessage extends http.IncomingMessage {
-  getUserAgent() {
-    return this.headers["user-agent"] || "unknown";
-  }
-}
-
-test("http.Server with custom IncomingMessage", done => {
-  const server = http.createServer(
-    {
-      IncomingMessage: MyIncomingMessage,
-    },
-    (req, res) => {
-      expect(req.getUserAgent()).toBe("node-test");
-      res.statusCode = 200;
-      res.end();
-    },
-  );
-
-  server.listen(() => {
-    const { port } = server.address();
-
-    http.get(
-      {
-        port,
-        headers: {
-          "User-Agent": "node-test",
-        },
-      },
-      res => {
-        expect(res.statusCode).toBe(200);
-        res.on("end", () => {
-          server.close();
-          done();
-        });
-        res.resume();
-      },
-    );
-  });
-});
-
-//<#END_FILE: test-http-server-options-incoming-message.js
diff --git a/test/js/node/test/parallel/http-server-options-server-response.test.js b/test/js/node/test/parallel/http-server-options-server-response.test.js
deleted file mode 100644
index 67155a18ac..0000000000
--- a/test/js/node/test/parallel/http-server-options-server-response.test.js
+++ /dev/null
@@ -1,49 +0,0 @@
-//#FILE: test-http-server-options-server-response.js
-//#SHA1: ae3128a67e671596c2470bb973747640620b807a
-//-----------------
-"use strict";
-
-/**
- * This test covers http.Server({ ServerResponse }) option:
- * With ServerResponse option the server should use
- * the new class for creating res Object instead of the default
- * http.ServerResponse.
- */
-const http = require("http");
-
-class MyServerResponse extends http.ServerResponse {
-  status(code) {
-    return this.writeHead(code, { "Content-Type": "text/plain" });
-  }
-}
-
-test("http.Server with custom ServerResponse", done => {
-  const server = http.Server(
-    {
-      ServerResponse: MyServerResponse,
-    },
-    jest.fn((req, res) => {
-      res.status(200);
-      res.end();
-    }),
-  );
-
-  server.listen(() => {
-    const port = server.address().port;
-
-    http.get({ port }, res => {
-      expect(res.statusCode).toBe(200);
-      res.on("end", () => {
-        server.close();
-        done();
-      });
-      res.resume();
-    });
-  });
-
-  server.on("close", () => {
-    expect(server.listeners("request")[0]).toHaveBeenCalledTimes(1);
-  });
-});
-
-//<#END_FILE: test-http-server-options-server-response.js
diff --git a/test/js/node/test/parallel/http-server-reject-chunked-with-content-length.test.js b/test/js/node/test/parallel/http-server-reject-chunked-with-content-length.test.js
deleted file mode 100644
index 9bd2f8b82b..0000000000
--- a/test/js/node/test/parallel/http-server-reject-chunked-with-content-length.test.js
+++ /dev/null
@@ -1,38 +0,0 @@
-//#FILE: test-http-server-reject-chunked-with-content-length.js
-//#SHA1: e94d6c381c99ba72c2cc2bcbc4c6474a7c63819a
-//-----------------
-"use strict";
-
-const http = require("http");
-const net = require("net");
-
-const reqstr = "POST / HTTP/1.1\r\n" + "Content-Length: 1\r\n" + "Transfer-Encoding: chunked\r\n\r\n";
-
-test("HTTP server rejects chunked with content length", done => {
-  const server = http.createServer(expect.any(Function));
-
-  server.on("clientError", err => {
-    expect(err.message).toMatch(/^Parse Error/);
-    expect(err.code).toBe("HPE_INVALID_TRANSFER_ENCODING");
-    server.close();
-  });
-
-  server.listen(0, () => {
-    const client = net.connect({ port: server.address().port }, () => {
-      client.write(reqstr);
-      client.end();
-    });
-
-    client.on("data", () => {
-      // Should not get to this point because the server should simply
-      // close the connection without returning any data.
-      throw new Error("no data should be returned by the server");
-    });
-
-    client.on("end", () => {
-      done();
-    });
-  });
-});
-
-//<#END_FILE: test-http-server-reject-chunked-with-content-length.js
diff --git a/test/js/node/test/parallel/http-server-stale-close.test.js b/test/js/node/test/parallel/http-server-stale-close.test.js
deleted file mode 100644
index ea0f99dcf0..0000000000
--- a/test/js/node/test/parallel/http-server-stale-close.test.js
+++ /dev/null
@@ -1,65 +0,0 @@
-//#FILE: test-http-server-stale-close.js
-//#SHA1: 5c246ffb442bd9ff61779bc300db12d2f3394be4
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-const fork = require("child_process").fork;
-
-if (process.env.NODE_TEST_FORK_PORT) {
-  const req = http.request(
-    {
-      headers: { "Content-Length": "42" },
-      method: "POST",
-      host: "127.0.0.1",
-      port: +process.env.NODE_TEST_FORK_PORT,
-    },
-    process.exit,
-  );
-  req.write("BAM");
-  req.end();
-} else {
-  test("HTTP server stale close", async () => {
-    const server = http.createServer((req, res) => {
-      res.writeHead(200, { "Content-Length": "42" });
-      req.pipe(res);
-      expect(req.destroyed).toBe(false);
-      req.on("close", () => {
-        expect(req.destroyed).toBe(true);
-        server.close();
-        res.end();
-      });
-    });
-
-    await new Promise(resolve => {
-      server.listen(0, function () {
-        fork(__filename, {
-          env: { ...process.env, NODE_TEST_FORK_PORT: this.address().port },
-        });
-        resolve();
-      });
-    });
-  });
-}
-
-//<#END_FILE: test-http-server-stale-close.js
diff --git a/test/js/node/test/parallel/http-server-write-after-end.test.js b/test/js/node/test/parallel/http-server-write-after-end.test.js
deleted file mode 100644
index c842524c4b..0000000000
--- a/test/js/node/test/parallel/http-server-write-after-end.test.js
+++ /dev/null
@@ -1,39 +0,0 @@
-//#FILE: test-http-server-write-after-end.js
-//#SHA1: cacf983393f707ddefc829a25ce16a5bf6f41c19
-//-----------------
-"use strict";
-
-const http = require("http");
-
-// Fix for https://github.com/nodejs/node/issues/14368
-
-test("HTTP server write after end", done => {
-  const server = http.createServer(handle);
-
-  function handle(req, res) {
-    res.on("error", jest.fn());
-
-    res.write("hello");
-    res.end();
-
-    setImmediate(() => {
-      res.write("world", err => {
-        expect(err).toEqual(
-          expect.objectContaining({
-            code: "ERR_STREAM_WRITE_AFTER_END",
-            name: "Error",
-            message: expect.any(String),
-          }),
-        );
-        server.close();
-        done();
-      });
-    });
-  }
-
-  server.listen(0, () => {
-    http.get(`http://localhost:${server.address().port}`);
-  });
-});
-
-//<#END_FILE: test-http-server-write-after-end.js
diff --git a/test/js/node/test/parallel/http-server-write-end-after-end.test.js b/test/js/node/test/parallel/http-server-write-end-after-end.test.js
deleted file mode 100644
index 836b835e1f..0000000000
--- a/test/js/node/test/parallel/http-server-write-end-after-end.test.js
+++ /dev/null
@@ -1,47 +0,0 @@
-//#FILE: test-http-server-write-end-after-end.js
-//#SHA1: 5b7550b3241cd6b99e607419c3b81d2df519b641
-//-----------------
-"use strict";
-
-const http = require("http");
-
-let server;
-
-beforeAll(() => {
-  server = http.createServer(handle);
-});
-
-afterAll(() => {
-  server.close();
-});
-
-function handle(req, res) {
-  res.on("error", jest.fn());
-
-  res.write("hello");
-  res.end();
-
-  setImmediate(() => {
-    res.end("world");
-    process.nextTick(() => {
-      server.close();
-    });
-    res.write("world", err => {
-      expect(err).toMatchObject({
-        code: "ERR_STREAM_WRITE_AFTER_END",
-        name: "Error",
-        message: expect.any(String),
-      });
-      server.close();
-    });
-  });
-}
-
-test("http server write end after end", done => {
-  server.listen(0, () => {
-    http.get(`http://localhost:${server.address().port}`);
-    done();
-  });
-});
-
-//<#END_FILE: test-http-server-write-end-after-end.js
diff --git a/test/js/node/test/parallel/http-set-header-chain.test.js b/test/js/node/test/parallel/http-set-header-chain.test.js
deleted file mode 100644
index 85aac8f9e1..0000000000
--- a/test/js/node/test/parallel/http-set-header-chain.test.js
+++ /dev/null
@@ -1,40 +0,0 @@
-//#FILE: test-http-set-header-chain.js
-//#SHA1: e009f5ffdce12a659bd2d3402449cd0095d79aa2
-//-----------------
-"use strict";
-
-const http = require("http");
-
-const expected = {
-  __proto__: null,
-  testheader1: "foo",
-  testheader2: "bar",
-  testheader3: "xyz",
-};
-
-test("HTTP setHeader chaining", async () => {
-  const server = http.createServer((req, res) => {
-    let retval = res.setHeader("testheader1", "foo");
-
-    // Test that the setHeader returns the same response object.
-    expect(retval).toBe(res);
-
-    retval = res.setHeader("testheader2", "bar").setHeader("testheader3", "xyz");
-    // Test that chaining works for setHeader.
-    expect(res.getHeaders()).toEqual(expected);
-    res.end("ok");
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, () => {
-      http.get({ port: server.address().port }, res => {
-        res.on("data", () => {});
-        res.on("end", () => {
-          server.close(resolve);
-        });
-      });
-    });
-  });
-});
-
-//<#END_FILE: test-http-set-header-chain.js
diff --git a/test/js/node/test/parallel/http-upgrade-reconsume-stream.test.js b/test/js/node/test/parallel/http-upgrade-reconsume-stream.test.js
deleted file mode 100644
index 57d72bf41d..0000000000
--- a/test/js/node/test/parallel/http-upgrade-reconsume-stream.test.js
+++ /dev/null
@@ -1,36 +0,0 @@
-//#FILE: test-http-upgrade-reconsume-stream.js
-//#SHA1: 4117d0b2212d192173b5bd6bf2ef7fe82f627079
-//-----------------
-"use strict";
-
-const tls = require("tls");
-const http = require("http");
-
-// Tests that, after the HTTP parser stopped owning a socket that emits an
-// 'upgrade' event, another C++ stream can start owning it (e.g. a TLSSocket).
-
-test("HTTP upgrade and TLSSocket creation", done => {
-  const server = http.createServer(expect.any(Function));
-
-  server.on("upgrade", (request, socket, head) => {
-    // This should not crash.
-    new tls.TLSSocket(socket);
-    server.close();
-    socket.destroy();
-    done();
-  });
-
-  server.listen(0, () => {
-    http
-      .get({
-        port: server.address().port,
-        headers: {
-          "Connection": "Upgrade",
-          "Upgrade": "websocket",
-        },
-      })
-      .on("error", () => {});
-  });
-});
-
-//<#END_FILE: test-http-upgrade-reconsume-stream.js
diff --git a/test/js/node/test/parallel/http-url.parse-auth-with-header-in-request.test.js b/test/js/node/test/parallel/http-url.parse-auth-with-header-in-request.test.js
deleted file mode 100644
index a87bfbd3ac..0000000000
--- a/test/js/node/test/parallel/http-url.parse-auth-with-header-in-request.test.js
+++ /dev/null
@@ -1,59 +0,0 @@
-//#FILE: test-http-url.parse-auth-with-header-in-request.js
-//#SHA1: 396adc5e441a57d24b11a42513c834b6b11ea7ff
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-const url = require("url");
-
-test("HTTP request with authorization header in request", async () => {
-  function check(request) {
-    // The correct authorization header is be passed
-    expect(request.headers.authorization).toBe("NoAuthForYOU");
-  }
-
-  const server = http.createServer((request, response) => {
-    // Run the check function
-    check(request);
-    response.writeHead(200, {});
-    response.end("ok");
-    server.close();
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, () => {
-      const testURL = url.parse(`http://asdf:qwer@localhost:${server.address().port}`);
-      // The test here is if you set a specific authorization header in the
-      // request we should not override that with basic auth
-      testURL.headers = {
-        Authorization: "NoAuthForYOU",
-      };
-
-      // make the request
-      http.request(testURL).end();
-      resolve();
-    });
-  });
-});
-
-//<#END_FILE: test-http-url.parse-auth-with-header-in-request.js
diff --git a/test/js/node/test/parallel/http-url.parse-auth.test.js b/test/js/node/test/parallel/http-url.parse-auth.test.js
deleted file mode 100644
index 439d699393..0000000000
--- a/test/js/node/test/parallel/http-url.parse-auth.test.js
+++ /dev/null
@@ -1,56 +0,0 @@
-//#FILE: test-http-url.parse-auth.js
-//#SHA1: 97f9b1c737c705489b2d6402750034291a9f6f63
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-const url = require("url");
-
-test("http url parse auth", async () => {
-  function check(request) {
-    // The correct authorization header is be passed
-    expect(request.headers.authorization).toBe("Basic dXNlcjpwYXNzOg==");
-  }
-
-  const server = http.createServer((request, response) => {
-    // Run the check function
-    check(request);
-    response.writeHead(200, {});
-    response.end("ok");
-    server.close();
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, () => {
-      const port = server.address().port;
-      // username = "user", password = "pass:"
-      const testURL = url.parse(`http://user:pass%3A@localhost:${port}`);
-
-      // make the request
-      http.request(testURL).end();
-      resolve();
-    });
-  });
-});
-
-//<#END_FILE: test-http-url.parse-auth.js
diff --git a/test/js/node/test/parallel/http-url.parse-basic.test.js b/test/js/node/test/parallel/http-url.parse-basic.test.js
deleted file mode 100644
index 9d2d329d3f..0000000000
--- a/test/js/node/test/parallel/http-url.parse-basic.test.js
+++ /dev/null
@@ -1,65 +0,0 @@
-//#FILE: test-http-url.parse-basic.js
-//#SHA1: f2f2841de1c82e38067e73196926090f350d89c6
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-const url = require("url");
-
-let testURL;
-
-// Make sure the basics work
-function check(request) {
-  // Default method should still be 'GET'
-  expect(request.method).toBe("GET");
-  // There are no URL params, so you should not see any
-  expect(request.url).toBe("/");
-  // The host header should use the url.parse.hostname
-  expect(request.headers.host).toBe(`${testURL.hostname}:${testURL.port}`);
-}
-
-test("HTTP URL parsing basics", async () => {
-  const server = http.createServer((request, response) => {
-    // Run the check function
-    check(request);
-    response.writeHead(200, {});
-    response.end("ok");
-    server.close();
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, () => {
-      testURL = url.parse(`http://localhost:${server.address().port}`);
-
-      // make the request
-      const clientRequest = http.request(testURL);
-      // Since there is a little magic with the agent
-      // make sure that an http request uses the http.Agent
-      expect(clientRequest.agent).toBeInstanceOf(http.Agent);
-      clientRequest.end();
-      resolve();
-    });
-  });
-});
-
-//<#END_FILE: test-http-url.parse-basic.js
diff --git a/test/js/node/test/parallel/http-url.parse-https.request.test.js b/test/js/node/test/parallel/http-url.parse-https.request.test.js
deleted file mode 100644
index 6b8a992569..0000000000
--- a/test/js/node/test/parallel/http-url.parse-https.request.test.js
+++ /dev/null
@@ -1,81 +0,0 @@
-//#FILE: test-http-url.parse-https.request.js
-//#SHA1: e9b9e39f28d5d2633f9444150977b748bc8995cb
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-const https = require("https");
-const url = require("url");
-const { readKey } = require("../common/fixtures");
-
-let common;
-try {
-  common = require("../common");
-} catch (e) {
-  // For Bun compatibility
-  common = {
-    hasCrypto: true,
-    skip: console.log,
-  };
-}
-
-if (!common.hasCrypto) {
-  common.skip("missing crypto");
-  process.exit(0);
-}
-
-// https options
-const httpsOptions = {
-  key: readKey("agent1-key.pem"),
-  cert: readKey("agent1-cert.pem"),
-};
-
-function check(request) {
-  // Assert that I'm https
-  expect(request.socket._secureEstablished).toBeTruthy();
-}
-
-test("HTTPS request with URL object", done => {
-  const server = https.createServer(httpsOptions, function (request, response) {
-    // Run the check function
-    check(request);
-    response.writeHead(200, {});
-    response.end("ok");
-    server.close();
-  });
-
-  server.listen(0, function () {
-    const testURL = url.parse(`https://localhost:${this.address().port}`);
-    testURL.rejectUnauthorized = false;
-
-    // make the request
-    const clientRequest = https.request(testURL);
-    // Since there is a little magic with the agent
-    // make sure that the request uses the https.Agent
-    expect(clientRequest.agent).toBeInstanceOf(https.Agent);
-    clientRequest.end();
-    done();
-  });
-});
-
-//<#END_FILE: test-http-url.parse-https.request.js
diff --git a/test/js/node/test/parallel/http-url.parse-path.test.js b/test/js/node/test/parallel/http-url.parse-path.test.js
deleted file mode 100644
index 21b456b66f..0000000000
--- a/test/js/node/test/parallel/http-url.parse-path.test.js
+++ /dev/null
@@ -1,54 +0,0 @@
-//#FILE: test-http-url.parse-path.js
-//#SHA1: 9eb246a6c09b70b76260a83bec4bb25452d38b7d
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-const url = require("url");
-
-test("http request url parsing", async () => {
-  function check(request) {
-    // A path should come over
-    expect(request.url).toBe("/asdf");
-  }
-
-  const server = http.createServer((request, response) => {
-    // Run the check function
-    check(request);
-    response.writeHead(200, {});
-    response.end("ok");
-    server.close();
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, () => {
-      const testURL = url.parse(`http://localhost:${server.address().port}/asdf`);
-
-      // make the request
-      http.request(testURL).end();
-      resolve();
-    });
-  });
-});
-
-//<#END_FILE: test-http-url.parse-path.js
diff --git a/test/js/node/test/parallel/http-url.parse-post.test.js b/test/js/node/test/parallel/http-url.parse-post.test.js
deleted file mode 100644
index 800cde5e39..0000000000
--- a/test/js/node/test/parallel/http-url.parse-post.test.js
+++ /dev/null
@@ -1,61 +0,0 @@
-//#FILE: test-http-url.parse-post.js
-//#SHA1: e0e7f97c725fb9eaa6058365bef5021e9710e857
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-const url = require("url");
-
-let testURL;
-
-function check(request) {
-  // url.parse should not mess with the method
-  expect(request.method).toBe("POST");
-  // Everything else should be right
-  expect(request.url).toBe("/asdf?qwer=zxcv");
-  // The host header should use the url.parse.hostname
-  expect(request.headers.host).toBe(`${testURL.hostname}:${testURL.port}`);
-}
-
-test("http url parse post", async () => {
-  const server = http.createServer((request, response) => {
-    // Run the check function
-    check(request);
-    response.writeHead(200, {});
-    response.end("ok");
-    server.close();
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, () => {
-      testURL = url.parse(`http://localhost:${server.address().port}/asdf?qwer=zxcv`);
-      testURL.method = "POST";
-
-      // make the request
-      http.request(testURL).end();
-      resolve();
-    });
-  });
-});
-
-//<#END_FILE: test-http-url.parse-post.js
diff --git a/test/js/node/test/parallel/http-url.parse-search.test.js b/test/js/node/test/parallel/http-url.parse-search.test.js
deleted file mode 100644
index fe07df2f63..0000000000
--- a/test/js/node/test/parallel/http-url.parse-search.test.js
+++ /dev/null
@@ -1,55 +0,0 @@
-//#FILE: test-http-url.parse-search.js
-//#SHA1: 11d08b9c62625b7b554d5fb46d63c4aaa77c1a7c
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-const url = require("url");
-
-test("HTTP request URL parsing with search params", async () => {
-  function check(request) {
-    // A path should come over with params
-    expect(request.url).toBe("/asdf?qwer=zxcv");
-  }
-
-  const server = http.createServer((request, response) => {
-    // Run the check function
-    check(request);
-    response.writeHead(200, {});
-    response.end("ok");
-    server.close();
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, () => {
-      const port = server.address().port;
-      const testURL = url.parse(`http://localhost:${port}/asdf?qwer=zxcv`);
-
-      // make the request
-      http.request(testURL).end();
-      resolve();
-    });
-  });
-});
-
-//<#END_FILE: test-http-url.parse-search.js
diff --git a/test/js/node/test/parallel/http-write-empty-string.test.js b/test/js/node/test/parallel/http-write-empty-string.test.js
deleted file mode 100644
index 16e1b0def3..0000000000
--- a/test/js/node/test/parallel/http-write-empty-string.test.js
+++ /dev/null
@@ -1,61 +0,0 @@
-//#FILE: test-http-write-empty-string.js
-//#SHA1: 779199784d3142e353324041eeb30924c7e4d5b1
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const http = require("http");
-
-test("http write empty string", async () => {
-  const server = http.createServer(function (request, response) {
-    console.log(`responding to ${request.url}`);
-
-    response.writeHead(200, { "Content-Type": "text/plain" });
-    response.write("1\n");
-    response.write("");
-    response.write("2\n");
-    response.write("");
-    response.end("3\n");
-
-    this.close();
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, () => {
-      http.get({ port: server.address().port }, res => {
-        let response = "";
-
-        expect(res.statusCode).toBe(200);
-        res.setEncoding("ascii");
-        res.on("data", chunk => {
-          response += chunk;
-        });
-        res.on("end", () => {
-          expect(response).toBe("1\n2\n3\n");
-          resolve();
-        });
-      });
-    });
-  });
-});
-
-//<#END_FILE: test-http-write-empty-string.js
diff --git a/test/js/node/test/parallel/http-zerolengthbuffer.test.js b/test/js/node/test/parallel/http-zerolengthbuffer.test.js
deleted file mode 100644
index 8c82c7a82f..0000000000
--- a/test/js/node/test/parallel/http-zerolengthbuffer.test.js
+++ /dev/null
@@ -1,30 +0,0 @@
-//#FILE: test-http-zerolengthbuffer.js
-//#SHA1: 28fff143238744f829f63936c8902047ad2c2fc5
-//-----------------
-"use strict";
-// Serving up a zero-length buffer should work.
-
-const http = require("http");
-
-test("Serve zero-length buffer", done => {
-  const server = http.createServer((req, res) => {
-    const buffer = Buffer.alloc(0);
-    res.writeHead(200, { "Content-Type": "text/html", "Content-Length": buffer.length });
-    res.end(buffer);
-  });
-
-  server.listen(0, () => {
-    http.get({ port: server.address().port }, res => {
-      const dataHandler = jest.fn();
-      res.on("data", dataHandler);
-
-      res.on("end", () => {
-        expect(dataHandler).not.toHaveBeenCalled();
-        server.close();
-        done();
-      });
-    });
-  });
-});
-
-//<#END_FILE: test-http-zerolengthbuffer.js
diff --git a/test/js/node/test/parallel/http2-request-response-proto.test.js b/test/js/node/test/parallel/http2-request-response-proto.test.js
deleted file mode 100644
index 94bab3bce3..0000000000
--- a/test/js/node/test/parallel/http2-request-response-proto.test.js
+++ /dev/null
@@ -1,18 +0,0 @@
-//#FILE: test-http2-request-response-proto.js
-//#SHA1: ffffac0d4d11b6a77ddbfce366c206de8db99446
-//-----------------
-"use strict";
-
-const http2 = require("http2");
-
-const { Http2ServerRequest, Http2ServerResponse } = http2;
-
-test("Http2ServerRequest and Http2ServerResponse prototypes", () => {
-  const protoRequest = { __proto__: Http2ServerRequest.prototype };
-  const protoResponse = { __proto__: Http2ServerResponse.prototype };
-
-  expect(protoRequest).toBeInstanceOf(Http2ServerRequest);
-  expect(protoResponse).toBeInstanceOf(Http2ServerResponse);
-});
-
-//<#END_FILE: test-http2-request-response-proto.js
diff --git a/test/js/node/test/parallel/http2-zero-length-write.test.js b/test/js/node/test/parallel/http2-zero-length-write.test.js
deleted file mode 100644
index 604bbdcf12..0000000000
--- a/test/js/node/test/parallel/http2-zero-length-write.test.js
+++ /dev/null
@@ -1,60 +0,0 @@
-//#FILE: test-http2-zero-length-write.js
-//#SHA1: a948a83af3675490313ff7b33a36d2c12cdd2837
-//-----------------
-"use strict";
-
-const http2 = require("http2");
-const { Readable } = require("stream");
-
-function getSrc() {
-  const chunks = ["", "asdf", "", "foo", "", "bar", ""];
-  return new Readable({
-    read() {
-      const chunk = chunks.shift();
-      if (chunk !== undefined) this.push(chunk);
-      else this.push(null);
-    },
-  });
-}
-
-const expect = "asdffoobar";
-
-test("HTTP/2 zero length write", async () => {
-  if (!("crypto" in process)) {
-    return;
-  }
-
-  const server = http2.createServer();
-  server.on("stream", stream => {
-    let actual = "";
-    stream.respond();
-    stream.resume();
-    stream.setEncoding("utf8");
-    stream.on("data", chunk => (actual += chunk));
-    stream.on("end", () => {
-      getSrc().pipe(stream);
-      expect(actual).toBe(expect);
-    });
-  });
-
-  await new Promise(resolve => server.listen(0, resolve));
-
-  const client = http2.connect(`http://localhost:${server.address().port}`);
-  let actual = "";
-  const req = client.request({ ":method": "POST" });
-  req.on("response", jest.fn());
-  req.setEncoding("utf8");
-  req.on("data", chunk => (actual += chunk));
-
-  await new Promise(resolve => {
-    req.on("end", () => {
-      expect(actual).toBe(expect);
-      server.close();
-      client.close();
-      resolve();
-    });
-    getSrc().pipe(req);
-  });
-});
-
-//<#END_FILE: test-http2-zero-length-write.js
diff --git a/test/js/node/test/parallel/https-agent-constructor.test.js b/test/js/node/test/parallel/https-agent-constructor.test.js
deleted file mode 100644
index dc3079eddd..0000000000
--- a/test/js/node/test/parallel/https-agent-constructor.test.js
+++ /dev/null
@@ -1,17 +0,0 @@
-//#FILE: test-https-agent-constructor.js
-//#SHA1: 6b63dcb4d1a1a60f19fbb26cb555013821af5791
-//-----------------
-"use strict";
-
-if (!process.versions.openssl) {
-  test.skip("missing crypto");
-}
-
-const https = require("https");
-
-test("https.Agent constructor", () => {
-  expect(new https.Agent()).toBeInstanceOf(https.Agent);
-  expect(https.Agent()).toBeInstanceOf(https.Agent);
-});
-
-//<#END_FILE: test-https-agent-constructor.js
diff --git a/test/js/node/test/parallel/https-agent.test.js b/test/js/node/test/parallel/https-agent.test.js
deleted file mode 100644
index 31b1e0ee25..0000000000
--- a/test/js/node/test/parallel/https-agent.test.js
+++ /dev/null
@@ -1,106 +0,0 @@
-//#FILE: test-https-agent.js
-//#SHA1: 1348abc863ae99725dd893838c95b42c5120a052
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-const https = require("https");
-const { readKey } = require("../common/fixtures");
-
-const options = {
-  key: readKey("agent1-key.pem"),
-  cert: readKey("agent1-cert.pem"),
-};
-
-const N = 4;
-const M = 4;
-
-let server;
-let responses = 0;
-
-beforeAll(() => {
-  if (!process.versions.openssl) {
-    return test.skip("missing crypto");
-  }
-});
-
-beforeEach(() => {
-  return new Promise(resolve => {
-    server = https.createServer(options, (req, res) => {
-      res.writeHead(200);
-      res.end("hello world\n");
-    });
-
-    server.listen(0, () => {
-      resolve();
-    });
-  });
-});
-
-afterEach(() => {
-  return new Promise(resolve => {
-    server.close(() => {
-      resolve();
-    });
-  });
-});
-
-test("HTTPS Agent handles multiple concurrent requests", async () => {
-  const makeRequests = i => {
-    return new Promise(resolve => {
-      setTimeout(() => {
-        const requests = Array.from(
-          { length: M },
-          () =>
-            new Promise(innerResolve => {
-              https
-                .get(
-                  {
-                    path: "/",
-                    port: server.address().port,
-                    rejectUnauthorized: false,
-                  },
-                  function (res) {
-                    res.resume();
-                    expect(res.statusCode).toBe(200);
-                    responses++;
-                    innerResolve();
-                  },
-                )
-                .on("error", e => {
-                  throw e;
-                });
-            }),
-        );
-        Promise.all(requests).then(resolve);
-      }, i);
-    });
-  };
-
-  const allRequests = Array.from({ length: N }, (_, i) => makeRequests(i));
-  await Promise.all(allRequests);
-
-  expect(responses).toBe(N * M);
-});
-
-//<#END_FILE: test-https-agent.js
diff --git a/test/js/node/test/parallel/https-byteswritten.test.js b/test/js/node/test/parallel/https-byteswritten.test.js
deleted file mode 100644
index c695fa7027..0000000000
--- a/test/js/node/test/parallel/https-byteswritten.test.js
+++ /dev/null
@@ -1,58 +0,0 @@
-//#FILE: test-https-byteswritten.js
-//#SHA1: 8b808da3e55de553190426095aee298ec7d5df36
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const fixtures = require("../common/fixtures");
-const https = require("https");
-
-const options = {
-  key: fixtures.readKey("agent1-key.pem"),
-  cert: fixtures.readKey("agent1-cert.pem"),
-};
-
-const body = "hello world\n";
-
-test("HTTPS server bytesWritten", async () => {
-  const httpsServer = https.createServer(options, (req, res) => {
-    res.on("finish", () => {
-      expect(typeof req.connection.bytesWritten).toBe("number");
-      expect(req.connection.bytesWritten).toBeGreaterThan(0);
-      httpsServer.close();
-    });
-    res.writeHead(200, { "Content-Type": "text/plain" });
-    res.end(body);
-  });
-
-  await new Promise(resolve => {
-    httpsServer.listen(0, () => {
-      https.get({
-        port: httpsServer.address().port,
-        rejectUnauthorized: false,
-      });
-      resolve();
-    });
-  });
-});
-
-//<#END_FILE: test-https-byteswritten.js
diff --git a/test/js/node/test/parallel/https-foafssl.test.js b/test/js/node/test/parallel/https-foafssl.test.js
deleted file mode 100644
index aac467af04..0000000000
--- a/test/js/node/test/parallel/https-foafssl.test.js
+++ /dev/null
@@ -1,114 +0,0 @@
-//#FILE: test-https-foafssl.js
-//#SHA1: 07ac711f5948207540af7366d06803f2675f04c7
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-const { skip } = require("../common");
-const fixtures = require("../common/fixtures");
-const https = require("https");
-const { spawn } = require("child_process");
-
-if (!process.versions.openssl) {
-  skip("missing crypto");
-}
-
-if (!process.env.NODE_OPENSSL_CERT) {
-  skip("node compiled without OpenSSL CLI.");
-}
-
-const options = {
-  key: fixtures.readKey("rsa_private.pem"),
-  cert: fixtures.readKey("rsa_cert.crt"),
-  requestCert: true,
-  rejectUnauthorized: false,
-};
-
-const webIdUrl = "URI:http://example.com/#me";
-const modulus = fixtures.readKey("rsa_cert_foafssl_b.modulus", "ascii").replace(/\n/g, "");
-const exponent = fixtures.readKey("rsa_cert_foafssl_b.exponent", "ascii").replace(/\n/g, "");
-
-const CRLF = "\r\n";
-const body = "hello world\n";
-let cert;
-
-test("HTTPS FOAFSSL", async () => {
-  const serverHandler = jest.fn((req, res) => {
-    console.log("got request");
-
-    cert = req.connection.getPeerCertificate();
-
-    expect(cert.subjectaltname).toBe(webIdUrl);
-    expect(cert.exponent).toBe(exponent);
-    expect(cert.modulus).toBe(modulus);
-    res.writeHead(200, { "content-type": "text/plain" });
-    res.end(body, () => {
-      console.log("stream finished");
-    });
-    console.log("sent response");
-  });
-
-  const server = https.createServer(options, serverHandler);
-
-  await new Promise(resolve => {
-    server.listen(0, resolve);
-  });
-
-  const { port } = server.address();
-
-  const args = [
-    "s_client",
-    "-quiet",
-    "-connect",
-    `127.0.0.1:${port}`,
-    "-cert",
-    fixtures.path("keys/rsa_cert_foafssl_b.crt"),
-    "-key",
-    fixtures.path("keys/rsa_private_b.pem"),
-  ];
-
-  const client = spawn(process.env.NODE_OPENSSL_CERT, args);
-
-  client.stdout.on("data", data => {
-    console.log("response received");
-    const message = data.toString();
-    const contents = message.split(CRLF + CRLF).pop();
-    expect(contents).toBe(body);
-    server.close(e => {
-      expect(e).toBeFalsy();
-      console.log("server closed");
-    });
-    console.log("server.close() called");
-  });
-
-  client.stdin.write("GET /\r\n\r\n");
-
-  await new Promise((resolve, reject) => {
-    client.on("error", reject);
-    client.on("close", resolve);
-  });
-
-  expect(serverHandler).toHaveBeenCalledTimes(1);
-});
-
-//<#END_FILE: test-https-foafssl.js
diff --git a/test/js/node/test/parallel/https-socket-options.test.js b/test/js/node/test/parallel/https-socket-options.test.js
deleted file mode 100644
index 5e325acc5d..0000000000
--- a/test/js/node/test/parallel/https-socket-options.test.js
+++ /dev/null
@@ -1,102 +0,0 @@
-//#FILE: test-https-socket-options.js
-//#SHA1: 8f63b3c65f69e8b766b159d148e681984c134477
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-const fixtures = require("../common/fixtures");
-const https = require("https");
-const http = require("http");
-
-const options = {
-  key: fixtures.readKey("agent1-key.pem"),
-  cert: fixtures.readKey("agent1-cert.pem"),
-};
-
-const body = "hello world\n";
-
-test("HTTP server socket options", async () => {
-  const server_http = http.createServer((req, res) => {
-    console.log("got HTTP request");
-    res.writeHead(200, { "content-type": "text/plain" });
-    res.end(body);
-  });
-
-  await new Promise(resolve => {
-    server_http.listen(0, () => {
-      const req = http.request(
-        {
-          port: server_http.address().port,
-          rejectUnauthorized: false,
-        },
-        res => {
-          server_http.close();
-          res.resume();
-          resolve();
-        },
-      );
-      // These methods should exist on the request and get passed down to the socket
-      expect(req.setNoDelay).toBeDefined();
-      expect(req.setTimeout).toBeDefined();
-      expect(req.setSocketKeepAlive).toBeDefined();
-      req.setNoDelay(true);
-      req.setTimeout(1000, () => {});
-      req.setSocketKeepAlive(true, 1000);
-      req.end();
-    });
-  });
-});
-
-test("HTTPS server socket options", async () => {
-  const server_https = https.createServer(options, (req, res) => {
-    console.log("got HTTPS request");
-    res.writeHead(200, { "content-type": "text/plain" });
-    res.end(body);
-  });
-
-  await new Promise(resolve => {
-    server_https.listen(0, () => {
-      const req = https.request(
-        {
-          port: server_https.address().port,
-          rejectUnauthorized: false,
-        },
-        res => {
-          server_https.close();
-          res.resume();
-          resolve();
-        },
-      );
-      // These methods should exist on the request and get passed down to the socket
-      expect(req.setNoDelay).toBeDefined();
-      expect(req.setTimeout).toBeDefined();
-      expect(req.setSocketKeepAlive).toBeDefined();
-      req.setNoDelay(true);
-      req.setTimeout(1000, () => {});
-      req.setSocketKeepAlive(true, 1000);
-      req.end();
-    });
-  });
-});
-
-//<#END_FILE: test-https-socket-options.js
diff --git a/test/js/node/test/parallel/inspect-publish-uid.test.js b/test/js/node/test/parallel/inspect-publish-uid.test.js
deleted file mode 100644
index 09ec36dcd3..0000000000
--- a/test/js/node/test/parallel/inspect-publish-uid.test.js
+++ /dev/null
@@ -1,57 +0,0 @@
-//#FILE: test-inspect-publish-uid.js
-//#SHA1: cd6577ea81261e5e89b5ec6272e27f5a0614ffcf
-//-----------------
-"use strict";
-
-const { spawnSync } = require("child_process");
-const inspector = require("inspector");
-const http = require("http");
-const url = require("url");
-
-// Skip the test if inspector is disabled
-if (!inspector.url()) {
-  test.skip("Inspector is disabled", () => {});
-} else {
-  test("Checks stderr", async () => {
-    await testArg("stderr");
-  });
-
-  test("Checks http", async () => {
-    await testArg("http");
-  });
-
-  test("Checks http,stderr", async () => {
-    await testArg("http,stderr");
-  });
-}
-
-async function testArg(argValue) {
-  console.log("Checks " + argValue + "..");
-  const hasHttp = argValue.split(",").includes("http");
-  const hasStderr = argValue.split(",").includes("stderr");
-
-  const nodeProcess = spawnSync(process.execPath, [
-    "--inspect=0",
-    `--inspect-publish-uid=${argValue}`,
-    "-e",
-    `(${scriptMain.toString()})(${hasHttp ? 200 : 404})`,
-  ]);
-  const hasWebSocketInStderr = checkStdError(nodeProcess.stderr.toString("utf8"));
-  expect(hasWebSocketInStderr).toBe(hasStderr);
-}
-
-function checkStdError(data) {
-  const matches = data.toString("utf8").match(/ws:\/\/.+:(\d+)\/.+/);
-  return !!matches;
-}
-
-function scriptMain(code) {
-  const inspectorUrl = inspector.url();
-  const { host } = url.parse(inspectorUrl);
-  http.get("http://" + host + "/json/list", response => {
-    expect(response.statusCode).toBe(code);
-    response.destroy();
-  });
-}
-
-//<#END_FILE: test-inspect-publish-uid.js
diff --git a/test/js/node/test/parallel/inspect-support-for-node_options.test.js b/test/js/node/test/parallel/inspect-support-for-node_options.test.js
deleted file mode 100644
index 77187f7aa6..0000000000
--- a/test/js/node/test/parallel/inspect-support-for-node_options.test.js
+++ /dev/null
@@ -1,46 +0,0 @@
-//#FILE: test-inspect-support-for-node_options.js
-//#SHA1: 622a8cb07922833373b0d88c42c2a7bbfdc7d58e
-//-----------------
-"use strict";
-
-const cluster = require("cluster");
-
-// Skip if inspector is disabled
-if (process.config.variables.v8_enable_inspector === 0) {
-  test.skip("Inspector is disabled", () => {});
-} else {
-  checkForInspectSupport("--inspect");
-}
-
-function checkForInspectSupport(flag) {
-  const nodeOptions = JSON.stringify(flag);
-  const numWorkers = 2;
-  process.env.NODE_OPTIONS = flag;
-
-  test(`Cluster support for NODE_OPTIONS ${nodeOptions}`, () => {
-    if (cluster.isPrimary) {
-      const workerExitPromises = [];
-
-      for (let i = 0; i < numWorkers; i++) {
-        const worker = cluster.fork();
-
-        worker.on("online", () => {
-          worker.disconnect();
-        });
-
-        workerExitPromises.push(
-          new Promise(resolve => {
-            worker.on("exit", (code, signal) => {
-              expect(worker.exitedAfterDisconnect).toBe(true);
-              resolve();
-            });
-          }),
-        );
-      }
-
-      return Promise.all(workerExitPromises);
-    }
-  });
-}
-
-//<#END_FILE: test-inspect-support-for-node_options.js
diff --git a/test/js/node/test/parallel/internal-process-binding.test.js b/test/js/node/test/parallel/internal-process-binding.test.js
deleted file mode 100644
index e3b90d28a4..0000000000
--- a/test/js/node/test/parallel/internal-process-binding.test.js
+++ /dev/null
@@ -1,18 +0,0 @@
-//#FILE: test-internal-process-binding.js
-//#SHA1: e14c48cb6cd21ab499bd5d72cf8c8d0cddccf767
-//-----------------
-"use strict";
-
-test("process internal binding", () => {
-  expect(process._internalBinding).toBeUndefined();
-  expect(process.internalBinding).toBeUndefined();
-  expect(() => {
-    process.binding("module_wrap");
-  }).toThrow(
-    expect.objectContaining({
-      message: expect.any(String),
-    }),
-  );
-});
-
-//<#END_FILE: test-internal-process-binding.js
diff --git a/test/js/node/test/parallel/intl-v8breakiterator.test.js b/test/js/node/test/parallel/intl-v8breakiterator.test.js
deleted file mode 100644
index 7bf86915d2..0000000000
--- a/test/js/node/test/parallel/intl-v8breakiterator.test.js
+++ /dev/null
@@ -1,19 +0,0 @@
-//#FILE: test-intl-v8BreakIterator.js
-//#SHA1: c1592e4a1a3d4971e70d4b2bc30e31bb157f8646
-//-----------------
-"use strict";
-
-if (!globalThis.Intl) {
-  test.skip("missing Intl");
-}
-
-test("v8BreakIterator is not in Intl", () => {
-  expect("v8BreakIterator" in Intl).toBe(false);
-});
-
-test("v8BreakIterator is not in Intl in a new context", () => {
-  const vm = require("vm");
-  expect(vm.runInNewContext('"v8BreakIterator" in Intl')).toBe(false);
-});
-
-//<#END_FILE: test-intl-v8BreakIterator.js
diff --git a/test/js/node/test/parallel/jest.config.js b/test/js/node/test/parallel/jest.config.js
deleted file mode 100644
index 7f2c94ff64..0000000000
--- a/test/js/node/test/parallel/jest.config.js
+++ /dev/null
@@ -1,2 +0,0 @@
-// So jest doesn't try to look up.
-module.exports = {};
diff --git a/test/js/node/test/parallel/js-stream-call-properties.test.js b/test/js/node/test/parallel/js-stream-call-properties.test.js
deleted file mode 100644
index 070bd47e99..0000000000
--- a/test/js/node/test/parallel/js-stream-call-properties.test.js
+++ /dev/null
@@ -1,35 +0,0 @@
-//#FILE: test-js-stream-call-properties.js
-//#SHA1: 491c3447495fadda8e713d00b9621ea31d8fb27d
-//-----------------
-"use strict";
-
-test("JSStream properties can be inspected", () => {
-  // We can't use internal bindings in Jest, so we'll mock the JSStream
-  class MockJSStream {
-    constructor() {
-      // Add some properties that might be inspected
-      this.readableFlowing = null;
-      this.writableFinished = false;
-      // Add more properties as needed
-    }
-  }
-
-  // Mock util.inspect to ensure it's called
-  const mockInspect = jest.fn();
-  jest.spyOn(console, "log").mockImplementation(mockInspect);
-
-  // Create an instance of our mock JSStream
-  const jsStream = new MockJSStream();
-
-  // Call console.log, which will internally call util.inspect
-  console.log(jsStream);
-
-  // Verify that inspect was called
-  expect(mockInspect).toHaveBeenCalledTimes(1);
-  expect(mockInspect).toHaveBeenCalledWith(expect.any(MockJSStream));
-
-  // Clean up
-  console.log.mockRestore();
-});
-
-//<#END_FILE: test-js-stream-call-properties.js
diff --git a/test/js/node/test/parallel/kill-segfault-freebsd.test.js b/test/js/node/test/parallel/kill-segfault-freebsd.test.js
deleted file mode 100644
index 786d3f4dbf..0000000000
--- a/test/js/node/test/parallel/kill-segfault-freebsd.test.js
+++ /dev/null
@@ -1,22 +0,0 @@
-//#FILE: test-kill-segfault-freebsd.js
-//#SHA1: ac3b65d8e5e92ffb9714307d2249b4c3b9240ed9
-//-----------------
-"use strict";
-
-// This test ensures Node.js doesn't crash on hitting Ctrl+C in order to
-// terminate the currently running process (especially on FreeBSD).
-// https://github.com/nodejs/node-v0.x-archive/issues/9326
-
-const child_process = require("child_process");
-
-test("Node.js doesn't crash on SIGINT (FreeBSD issue)", done => {
-  // NOTE: Was crashing on FreeBSD
-  const cp = child_process.spawn(process.execPath, ["-e", 'process.kill(process.pid, "SIGINT")']);
-
-  cp.on("exit", function (code) {
-    expect(code).not.toBe(0);
-    done();
-  });
-});
-
-//<#END_FILE: test-kill-segfault-freebsd.js
diff --git a/test/js/node/test/parallel/memory-usage-emfile.test.js b/test/js/node/test/parallel/memory-usage-emfile.test.js
deleted file mode 100644
index 6e8cb22c8d..0000000000
--- a/test/js/node/test/parallel/memory-usage-emfile.test.js
+++ /dev/null
@@ -1,25 +0,0 @@
-//#FILE: test-memory-usage-emfile.js
-//#SHA1: 062c0483d1da90d9e08bab6a7d006d2da5861bd9
-//-----------------
-"use strict";
-
-// On IBMi, the rss memory always returns zero
-if (process.platform === "os400") {
-  test.skip("On IBMi, the rss memory always returns zero", () => {});
-} else {
-  const fs = require("fs");
-
-  test("memory usage with many open files", () => {
-    const files = [];
-
-    while (files.length < 256) files.push(fs.openSync(__filename, "r"));
-
-    const r = process.memoryUsage.rss();
-    expect(r).toBeGreaterThan(0);
-
-    // Clean up opened files
-    files.forEach(fd => fs.closeSync(fd));
-  });
-}
-
-//<#END_FILE: test-memory-usage-emfile.js
diff --git a/test/js/node/test/parallel/memory-usage.test.js b/test/js/node/test/parallel/memory-usage.test.js
deleted file mode 100644
index 74c73896df..0000000000
--- a/test/js/node/test/parallel/memory-usage.test.js
+++ /dev/null
@@ -1,54 +0,0 @@
-//#FILE: test-memory-usage.js
-//#SHA1: fffba1b4ff9ad7092d9a8f51b2799a0606d769eb
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-// Flags: --predictable-gc-schedule
-"use strict";
-
-const isIBMi = process.platform === "aix" && process.execPath.includes("powerpc");
-
-test("memory usage", () => {
-  const r = process.memoryUsage();
-  // On IBMi, the rss memory always returns zero
-  if (!isIBMi) {
-    expect(r.rss).toBeGreaterThan(0);
-    expect(process.memoryUsage.rss()).toBeGreaterThan(0);
-  }
-
-  expect(r.heapTotal).toBeGreaterThan(0);
-  expect(r.heapUsed).toBeGreaterThan(0);
-  expect(r.external).toBeGreaterThan(0);
-
-  expect(typeof r.arrayBuffers).toBe("number");
-  if (r.arrayBuffers > 0) {
-    const size = 10 * 1024 * 1024;
-    // eslint-disable-next-line no-unused-vars
-    const ab = new ArrayBuffer(size);
-
-    const after = process.memoryUsage();
-    expect(after.external - r.external).toBeGreaterThanOrEqual(size);
-    expect(after.arrayBuffers - r.arrayBuffers).toBe(size);
-  }
-});
-
-//<#END_FILE: test-memory-usage.js
diff --git a/test/js/node/test/parallel/messageevent-brandcheck.test.js b/test/js/node/test/parallel/messageevent-brandcheck.test.js
deleted file mode 100644
index ba2dd9c11a..0000000000
--- a/test/js/node/test/parallel/messageevent-brandcheck.test.js
+++ /dev/null
@@ -1,17 +0,0 @@
-//#FILE: test-messageevent-brandcheck.js
-//#SHA1: 1b04c8b7c45fe0f2fe12018ca10137eefa892b4c
-//-----------------
-"use strict";
-
-test("MessageEvent brand checks", () => {
-  ["data", "origin", "lastEventId", "source", "ports"].forEach(prop => {
-    expect(() => Reflect.get(MessageEvent.prototype, prop, {})).toThrow(
-      expect.objectContaining({
-        name: "TypeError",
-        message: expect.any(String),
-      }),
-    );
-  });
-});
-
-//<#END_FILE: test-messageevent-brandcheck.js
diff --git a/test/js/node/test/parallel/microtask-queue-integration.test.js b/test/js/node/test/parallel/microtask-queue-integration.test.js
deleted file mode 100644
index 7d0dc16d64..0000000000
--- a/test/js/node/test/parallel/microtask-queue-integration.test.js
+++ /dev/null
@@ -1,81 +0,0 @@
-//#FILE: test-microtask-queue-integration.js
-//#SHA1: bc144f7d64d2ed682489718745be5883122cf323
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-const implementations = [
-  function (fn) {
-    Promise.resolve().then(fn);
-  },
-];
-
-let expected = 0;
-let done = 0;
-
-afterAll(() => {
-  expect(done).toBe(expected);
-});
-
-function testMicrotask(scheduleMicrotask) {
-  return new Promise(resolve => {
-    let nextTickCalled = false;
-    expected++;
-
-    scheduleMicrotask(() => {
-      process.nextTick(() => {
-        nextTickCalled = true;
-      });
-
-      setTimeout(() => {
-        expect(nextTickCalled).toBe(true);
-        done++;
-        resolve();
-      }, 0);
-    });
-  });
-}
-
-test("first tick case", async () => {
-  await Promise.all(implementations.map(testMicrotask));
-});
-
-test("tick callback case", async () => {
-  await new Promise(resolve => {
-    setTimeout(async () => {
-      await Promise.all(
-        implementations.map(
-          impl =>
-            new Promise(resolve => {
-              process.nextTick(() => {
-                testMicrotask(impl).then(resolve);
-              });
-            }),
-        ),
-      );
-      resolve();
-    }, 0);
-  });
-});
-
-//<#END_FILE: test-microtask-queue-integration.js
diff --git a/test/js/node/test/parallel/microtask-queue-run-immediate.test.js b/test/js/node/test/parallel/microtask-queue-run-immediate.test.js
deleted file mode 100644
index e64e7022b7..0000000000
--- a/test/js/node/test/parallel/microtask-queue-run-immediate.test.js
+++ /dev/null
@@ -1,60 +0,0 @@
-//#FILE: test-microtask-queue-run-immediate.js
-//#SHA1: 49e5d82cc3467e4e12d0e93629607cd48b3548e4
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-function enqueueMicrotask(fn) {
-  Promise.resolve().then(fn);
-}
-
-test("microtask queue runs in setImmediate", done => {
-  let microtaskExecuted = false;
-
-  setImmediate(() => {
-    enqueueMicrotask(() => {
-      microtaskExecuted = true;
-      expect(microtaskExecuted).toBe(true);
-      done();
-    });
-  });
-});
-
-test("microtask with nextTick runs before next setImmediate", done => {
-  let nextTickCalled = false;
-
-  setImmediate(() => {
-    enqueueMicrotask(() => {
-      process.nextTick(() => {
-        nextTickCalled = true;
-      });
-    });
-
-    setImmediate(() => {
-      expect(nextTickCalled).toBe(true);
-      done();
-    });
-  });
-});
-
-//<#END_FILE: test-microtask-queue-run-immediate.js
diff --git a/test/js/node/test/parallel/microtask-queue-run.test.js b/test/js/node/test/parallel/microtask-queue-run.test.js
deleted file mode 100644
index 8e25e318d2..0000000000
--- a/test/js/node/test/parallel/microtask-queue-run.test.js
+++ /dev/null
@@ -1,67 +0,0 @@
-//#FILE: test-microtask-queue-run.js
-//#SHA1: caf14b2c15bbc84816eb2ce6b9bdb073c009b447
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-function enqueueMicrotask(fn) {
-  Promise.resolve().then(fn);
-}
-
-test("microtask queue runs correctly", async () => {
-  let done = 0;
-
-  // No nextTick, microtask
-  await new Promise(resolve => {
-    setTimeout(() => {
-      enqueueMicrotask(() => {
-        done++;
-        resolve();
-      });
-    }, 0);
-  });
-
-  // No nextTick, microtask with nextTick
-  await new Promise(resolve => {
-    setTimeout(() => {
-      let called = false;
-
-      enqueueMicrotask(() => {
-        process.nextTick(() => {
-          called = true;
-        });
-      });
-
-      setTimeout(() => {
-        if (called) {
-          done++;
-        }
-        resolve();
-      }, 0);
-    }, 0);
-  });
-
-  expect(done).toBe(2);
-});
-
-//<#END_FILE: test-microtask-queue-run.js
diff --git a/test/js/node/test/parallel/module-builtin.test.js b/test/js/node/test/parallel/module-builtin.test.js
deleted file mode 100644
index cc9f208d38..0000000000
--- a/test/js/node/test/parallel/module-builtin.test.js
+++ /dev/null
@@ -1,17 +0,0 @@
-//#FILE: test-module-builtin.js
-//#SHA1: 18114886f66eccc937942a815feca25d9b324a37
-//-----------------
-"use strict";
-
-test("builtinModules", () => {
-  const { builtinModules } = require("module");
-
-  // Includes modules in lib/ (even deprecated ones)
-  expect(builtinModules).toContain("http");
-  expect(builtinModules).toContain("sys");
-
-  // Does not include internal modules
-  expect(builtinModules.filter(mod => mod.startsWith("internal/"))).toEqual([]);
-});
-
-//<#END_FILE: test-module-builtin.js
diff --git a/test/js/node/test/parallel/module-cache.test.js b/test/js/node/test/parallel/module-cache.test.js
deleted file mode 100644
index 605b768808..0000000000
--- a/test/js/node/test/parallel/module-cache.test.js
+++ /dev/null
@@ -1,39 +0,0 @@
-//#FILE: test-module-cache.js
-//#SHA1: ff0f4c6ca37e23c009f98bba966e9daee2dcaef6
-//-----------------
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-const os = require("os");
-
-let tmpdir;
-
-beforeEach(() => {
-  tmpdir = fs.mkdtempSync(path.join(os.tmpdir(), "test-module-cache-"));
-});
-
-afterEach(() => {
-  fs.rmSync(tmpdir, { recursive: true, force: true });
-});
-
-test("throws MODULE_NOT_FOUND when file does not exist", () => {
-  const filePath = path.join(tmpdir, "test-module-cache.json");
-  expect(() => require(filePath)).toThrow(
-    expect.objectContaining({
-      code: "MODULE_NOT_FOUND",
-      message: expect.any(String),
-    }),
-  );
-});
-
-test("requires JSON file successfully after creation", () => {
-  const filePath = path.join(tmpdir, "test-module-cache.json");
-  fs.writeFileSync(filePath, "[]");
-
-  const content = require(filePath);
-  expect(Array.isArray(content)).toBe(true);
-  expect(content.length).toBe(0);
-});
-
-//<#END_FILE: test-module-cache.js
diff --git a/test/js/node/test/parallel/module-main-extension-lookup.test.js b/test/js/node/test/parallel/module-main-extension-lookup.test.js
deleted file mode 100644
index 741f721bc6..0000000000
--- a/test/js/node/test/parallel/module-main-extension-lookup.test.js
+++ /dev/null
@@ -1,23 +0,0 @@
-//#FILE: test-module-main-extension-lookup.js
-//#SHA1: d50be34ba21e1e14de5225ac5d93b6fe20505014
-//-----------------
-"use strict";
-
-const path = require("path");
-const { execFileSync } = require("child_process");
-
-const node = process.argv[0];
-
-test("ES modules extension lookup", () => {
-  const fixturesPath = path.resolve(__dirname, "..", "fixtures");
-
-  expect(() => {
-    execFileSync(node, [path.join(fixturesPath, "es-modules", "test-esm-ok.mjs")]);
-  }).not.toThrow();
-
-  expect(() => {
-    execFileSync(node, [path.join(fixturesPath, "es-modules", "noext")]);
-  }).not.toThrow();
-});
-
-//<#END_FILE: test-module-main-extension-lookup.js
diff --git a/test/js/node/test/parallel/net-autoselectfamily-attempt-timeout-default-value.test.js b/test/js/node/test/parallel/net-autoselectfamily-attempt-timeout-default-value.test.js
deleted file mode 100644
index 5b33636b4d..0000000000
--- a/test/js/node/test/parallel/net-autoselectfamily-attempt-timeout-default-value.test.js
+++ /dev/null
@@ -1,13 +0,0 @@
-//#FILE: test-net-autoselectfamily-attempt-timeout-default-value.js
-//#SHA1: 028b16515c47d987e68ca138e753ed4d255f179c
-//-----------------
-"use strict";
-
-const { platformTimeout } = require("../common");
-const { getDefaultAutoSelectFamilyAttemptTimeout } = require("net");
-
-test("getDefaultAutoSelectFamilyAttemptTimeout returns the correct default value", () => {
-  expect(getDefaultAutoSelectFamilyAttemptTimeout()).toBe(platformTimeout(2500));
-});
-
-//<#END_FILE: test-net-autoselectfamily-attempt-timeout-default-value.js
diff --git a/test/js/node/test/parallel/net-buffersize.test.js b/test/js/node/test/parallel/net-buffersize.test.js
deleted file mode 100644
index 5701356648..0000000000
--- a/test/js/node/test/parallel/net-buffersize.test.js
+++ /dev/null
@@ -1,60 +0,0 @@
-//#FILE: test-net-buffersize.js
-//#SHA1: b6b1298dc9f836252e5fcdcee680116d50da7651
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const net = require("net");
-
-const iter = 10;
-
-test("net buffer size", async () => {
-  const server = net.createServer(socket => {
-    socket.on("readable", () => {
-      socket.read();
-    });
-
-    socket.on("end", () => {
-      server.close();
-    });
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, () => {
-      const client = net.connect(server.address().port);
-
-      client.on("finish", () => {
-        expect(client.bufferSize).toBe(0);
-        resolve();
-      });
-
-      for (let i = 1; i < iter; i++) {
-        client.write("a");
-        expect(client.bufferSize).toBe(i);
-      }
-
-      client.end();
-    });
-  });
-});
-
-//<#END_FILE: test-net-buffersize.js
diff --git a/test/js/node/test/parallel/net-connect-call-socket-connect.test.js b/test/js/node/test/parallel/net-connect-call-socket-connect.test.js
deleted file mode 100644
index 8a74641b74..0000000000
--- a/test/js/node/test/parallel/net-connect-call-socket-connect.test.js
+++ /dev/null
@@ -1,53 +0,0 @@
-//#FILE: test-net-connect-call-socket-connect.js
-//#SHA1: 953a427c411633a029dcf978ea07fb701ae5ed9a
-//-----------------
-"use strict";
-
-const net = require("net");
-const Socket = net.Socket;
-
-// This test checks that calling `net.connect` internally calls
-// `Socket.prototype.connect`.
-//
-// This is important for people who monkey-patch `Socket.prototype.connect`
-// since it's not possible to monkey-patch `net.connect` directly (as the core
-// `connect` function is called internally in Node instead of calling the
-// `exports.connect` function).
-//
-// Monkey-patching of `Socket.prototype.connect` is done by - among others -
-// most APM vendors, the async-listener module and the
-// continuation-local-storage module.
-//
-// Related:
-// - https://github.com/nodejs/node/pull/12342
-// - https://github.com/nodejs/node/pull/12852
-
-test("net.connect calls Socket.prototype.connect", async () => {
-  // Monkey patch Socket.prototype.connect to check that it's called.
-  const orig = Socket.prototype.connect;
-  const connectMock = jest.fn(function () {
-    return orig.apply(this, arguments);
-  });
-  Socket.prototype.connect = connectMock;
-
-  const server = net.createServer();
-
-  await new Promise(resolve => {
-    server.listen(() => {
-      const port = server.address().port;
-      const client = net.connect({ port }, () => {
-        client.end();
-      });
-      client.on("end", () => {
-        server.close(resolve);
-      });
-    });
-  });
-
-  expect(connectMock).toHaveBeenCalledTimes(1);
-
-  // Restore original Socket.prototype.connect
-  Socket.prototype.connect = orig;
-});
-
-//<#END_FILE: test-net-connect-call-socket-connect.js
diff --git a/test/js/node/test/parallel/net-connect-immediate-destroy.test.js b/test/js/node/test/parallel/net-connect-immediate-destroy.test.js
deleted file mode 100644
index 055b18bae4..0000000000
--- a/test/js/node/test/parallel/net-connect-immediate-destroy.test.js
+++ /dev/null
@@ -1,28 +0,0 @@
-//#FILE: test-net-connect-immediate-destroy.js
-//#SHA1: 28ba78fafba37cb07a2ec4b18e3e35bbb78ef699
-//-----------------
-"use strict";
-const net = require("net");
-
-test("net.connect immediate destroy", done => {
-  const server = net.createServer();
-  server.listen(0, () => {
-    const port = server.address().port;
-    const socket = net.connect(port, "127.0.0.1");
-
-    socket.on("connect", () => {
-      throw new Error("Socket should not connect");
-    });
-
-    socket.on("error", () => {
-      throw new Error("Socket should not emit error");
-    });
-
-    server.close(() => {
-      socket.destroy();
-      done();
-    });
-  });
-});
-
-//<#END_FILE: test-net-connect-immediate-destroy.js
diff --git a/test/js/node/test/parallel/net-connect-paused-connection.test.js b/test/js/node/test/parallel/net-connect-paused-connection.test.js
deleted file mode 100644
index 6bfc5f554a..0000000000
--- a/test/js/node/test/parallel/net-connect-paused-connection.test.js
+++ /dev/null
@@ -1,54 +0,0 @@
-//#FILE: test-net-connect-paused-connection.js
-//#SHA1: ab2fae629f3abb5fc4d5e59dd7d1dd2e09b9eb48
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const net = require("net");
-
-test("net connect with paused connection", done => {
-  const server = net.createServer(conn => {
-    conn.unref();
-  });
-
-  server.listen(0, () => {
-    const connection = net.connect(server.address().port, "localhost");
-    connection.pause();
-
-    const timeoutId = setTimeout(() => {
-      done.fail("Should not have called timeout");
-    }, 1000);
-
-    // Unref the timeout to allow the process to exit
-    timeoutId.unref();
-
-    // Allow some time for the test to potentially fail
-    setTimeout(() => {
-      server.close();
-      done();
-    }, 500);
-  });
-
-  server.unref();
-});
-
-//<#END_FILE: test-net-connect-paused-connection.js
diff --git a/test/js/node/test/parallel/net-connect-reset-until-connected.test.js b/test/js/node/test/parallel/net-connect-reset-until-connected.test.js
deleted file mode 100644
index 7e2e77698b..0000000000
--- a/test/js/node/test/parallel/net-connect-reset-until-connected.test.js
+++ /dev/null
@@ -1,48 +0,0 @@
-//#FILE: test-net-connect-reset-until-connected.js
-//#SHA1: b0170103868d4f693e9afda7923e021758393a39
-//-----------------
-"use strict";
-
-const net = require("net");
-
-function barrier(count, cb) {
-  return function () {
-    if (--count === 0) cb();
-  };
-}
-
-test("net connection reset until connected", done => {
-  const server = net.createServer();
-  server.listen(0, () => {
-    const port = server.address().port;
-    const conn = net.createConnection(port);
-    const connok = barrier(2, () => conn.resetAndDestroy());
-
-    conn.on("close", () => {
-      expect(true).toBe(true); // Ensure 'close' event is called
-    });
-
-    server.on("connection", socket => {
-      connok();
-      socket.on("error", err => {
-        expect(err).toEqual(
-          expect.objectContaining({
-            code: "ECONNRESET",
-            name: "Error",
-            message: expect.any(String),
-          }),
-        );
-      });
-      server.close();
-    });
-
-    conn.on("connect", connok);
-  });
-
-  // Ensure the test completes
-  setTimeout(() => {
-    done();
-  }, 1000);
-});
-
-//<#END_FILE: test-net-connect-reset-until-connected.js
diff --git a/test/js/node/test/parallel/net-during-close.test.js b/test/js/node/test/parallel/net-during-close.test.js
deleted file mode 100644
index 9edb7efc92..0000000000
--- a/test/js/node/test/parallel/net-during-close.test.js
+++ /dev/null
@@ -1,52 +0,0 @@
-//#FILE: test-net-during-close.js
-//#SHA1: c5fc5c85760b2c68679f7041ebf737e8204ca8c5
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const net = require("net");
-
-test("accessing client properties during server close", done => {
-  const server = net.createServer(socket => {
-    socket.end();
-  });
-
-  server.listen(0, () => {
-    const client = net.createConnection(server.address().port);
-    server.close();
-
-    // Server connection event has not yet fired client is still attempting to
-    // connect. Accessing properties should not throw in this case.
-    expect(() => {
-      /* eslint-disable no-unused-expressions */
-      client.remoteAddress;
-      client.remoteFamily;
-      client.remotePort;
-      /* eslint-enable no-unused-expressions */
-    }).not.toThrow();
-
-    // Exit now, do not wait for the client error event.
-    done();
-  });
-});
-
-//<#END_FILE: test-net-during-close.js
diff --git a/test/js/node/test/parallel/net-end-destroyed.test.js b/test/js/node/test/parallel/net-end-destroyed.test.js
deleted file mode 100644
index 0ad62bbf17..0000000000
--- a/test/js/node/test/parallel/net-end-destroyed.test.js
+++ /dev/null
@@ -1,34 +0,0 @@
-//#FILE: test-net-end-destroyed.js
-//#SHA1: cf219496c5dd2cb11f3d01750692b61791c7e2f9
-//-----------------
-"use strict";
-
-const net = require("net");
-
-test('socket is not destroyed when the "end" event is emitted', done => {
-  const server = net.createServer();
-
-  server.on("connection", () => {
-    // Connection event handler
-  });
-
-  // Ensure that the socket is not destroyed when the 'end' event is emitted.
-
-  server.listen(() => {
-    const socket = net.createConnection({
-      port: server.address().port,
-    });
-
-    socket.on("connect", () => {
-      socket.on("end", () => {
-        expect(socket.destroyed).toBe(false);
-        server.close();
-        done();
-      });
-
-      socket.end();
-    });
-  });
-});
-
-//<#END_FILE: test-net-end-destroyed.js
diff --git a/test/js/node/test/parallel/net-end-without-connect.test.js b/test/js/node/test/parallel/net-end-without-connect.test.js
deleted file mode 100644
index ffdd987eb0..0000000000
--- a/test/js/node/test/parallel/net-end-without-connect.test.js
+++ /dev/null
@@ -1,36 +0,0 @@
-//#FILE: test-net-end-without-connect.js
-//#SHA1: d13d4a7117c5625fec0c619acc024e705dfb4212
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const net = require("net");
-
-test("Socket.end() without connect", done => {
-  const sock = new net.Socket();
-  sock.end(() => {
-    expect(sock.writable).toBe(false);
-    done();
-  });
-});
-
-//<#END_FILE: test-net-end-without-connect.js
diff --git a/test/js/node/test/parallel/net-isip.test.js b/test/js/node/test/parallel/net-isip.test.js
deleted file mode 100644
index d30b722c22..0000000000
--- a/test/js/node/test/parallel/net-isip.test.js
+++ /dev/null
@@ -1,107 +0,0 @@
-//#FILE: test-net-isip.js
-//#SHA1: 5fb15ec330f4e7489c3e7eb2a74547c44aa5a4dc
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const net = require("net");
-
-test("net.isIP", () => {
-  expect(net.isIP("127.0.0.1")).toBe(4);
-  expect(net.isIP("x127.0.0.1")).toBe(0);
-  expect(net.isIP("example.com")).toBe(0);
-  expect(net.isIP("0000:0000:0000:0000:0000:0000:0000:0000")).toBe(6);
-  expect(net.isIP("0000:0000:0000:0000:0000:0000:0000:0000::0000")).toBe(0);
-  expect(net.isIP("1050:0:0:0:5:600:300c:326b")).toBe(6);
-  expect(net.isIP("2001:252:0:1::2008:6")).toBe(6);
-  expect(net.isIP("2001:dead:beef:1::2008:6")).toBe(6);
-  expect(net.isIP("2001::")).toBe(6);
-  expect(net.isIP("2001:dead::")).toBe(6);
-  expect(net.isIP("2001:dead:beef::")).toBe(6);
-  expect(net.isIP("2001:dead:beef:1::")).toBe(6);
-  expect(net.isIP("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")).toBe(6);
-  expect(net.isIP(":2001:252:0:1::2008:6:")).toBe(0);
-  expect(net.isIP(":2001:252:0:1::2008:6")).toBe(0);
-  expect(net.isIP("2001:252:0:1::2008:6:")).toBe(0);
-  expect(net.isIP("2001:252::1::2008:6")).toBe(0);
-  expect(net.isIP("::2001:252:1:2008:6")).toBe(6);
-  expect(net.isIP("::2001:252:1:1.1.1.1")).toBe(6);
-  expect(net.isIP("::2001:252:1:255.255.255.255")).toBe(6);
-  expect(net.isIP("::2001:252:1:255.255.255.255.76")).toBe(0);
-  expect(net.isIP("fe80::2008%eth0")).toBe(6);
-  expect(net.isIP("fe80::2008%eth0.0")).toBe(6);
-  expect(net.isIP("fe80::2008%eth0@1")).toBe(0);
-  expect(net.isIP("::anything")).toBe(0);
-  expect(net.isIP("::1")).toBe(6);
-  expect(net.isIP("::")).toBe(6);
-  expect(net.isIP("0000:0000:0000:0000:0000:0000:12345:0000")).toBe(0);
-  expect(net.isIP("0")).toBe(0);
-  expect(net.isIP()).toBe(0);
-  expect(net.isIP("")).toBe(0);
-  expect(net.isIP(null)).toBe(0);
-  expect(net.isIP(123)).toBe(0);
-  expect(net.isIP(true)).toBe(0);
-  expect(net.isIP({})).toBe(0);
-  expect(net.isIP({ toString: () => "::2001:252:1:255.255.255.255" })).toBe(6);
-  expect(net.isIP({ toString: () => "127.0.0.1" })).toBe(4);
-  expect(net.isIP({ toString: () => "bla" })).toBe(0);
-});
-
-test("net.isIPv4", () => {
-  expect(net.isIPv4("127.0.0.1")).toBe(true);
-  expect(net.isIPv4("example.com")).toBe(false);
-  expect(net.isIPv4("2001:252:0:1::2008:6")).toBe(false);
-  expect(net.isIPv4()).toBe(false);
-  expect(net.isIPv4("")).toBe(false);
-  expect(net.isIPv4(null)).toBe(false);
-  expect(net.isIPv4(123)).toBe(false);
-  expect(net.isIPv4(true)).toBe(false);
-  expect(net.isIPv4({})).toBe(false);
-  expect(
-    net.isIPv4({
-      toString: () => "::2001:252:1:255.255.255.255",
-    }),
-  ).toBe(false);
-  expect(net.isIPv4({ toString: () => "127.0.0.1" })).toBe(true);
-  expect(net.isIPv4({ toString: () => "bla" })).toBe(false);
-});
-
-test("net.isIPv6", () => {
-  expect(net.isIPv6("127.0.0.1")).toBe(false);
-  expect(net.isIPv6("example.com")).toBe(false);
-  expect(net.isIPv6("2001:252:0:1::2008:6")).toBe(true);
-  expect(net.isIPv6()).toBe(false);
-  expect(net.isIPv6("")).toBe(false);
-  expect(net.isIPv6(null)).toBe(false);
-  expect(net.isIPv6(123)).toBe(false);
-  expect(net.isIPv6(true)).toBe(false);
-  expect(net.isIPv6({})).toBe(false);
-  expect(
-    net.isIPv6({
-      toString: () => "::2001:252:1:255.255.255.255",
-    }),
-  ).toBe(true);
-  expect(net.isIPv6({ toString: () => "127.0.0.1" })).toBe(false);
-  expect(net.isIPv6({ toString: () => "bla" })).toBe(false);
-});
-
-//<#END_FILE: test-net-isip.js
diff --git a/test/js/node/test/parallel/net-isipv4.test.js b/test/js/node/test/parallel/net-isipv4.test.js
deleted file mode 100644
index d76f97e740..0000000000
--- a/test/js/node/test/parallel/net-isipv4.test.js
+++ /dev/null
@@ -1,54 +0,0 @@
-//#FILE: test-net-isipv4.js
-//#SHA1: 2f26a4e5d952b01d6fe2143c1e8f65a19997c974
-//-----------------
-"use strict";
-
-const net = require("net");
-
-const v4 = [
-  "0.0.0.0",
-  "8.8.8.8",
-  "127.0.0.1",
-  "100.100.100.100",
-  "192.168.0.1",
-  "18.101.25.153",
-  "123.23.34.2",
-  "172.26.168.134",
-  "212.58.241.131",
-  "128.0.0.0",
-  "23.71.254.72",
-  "223.255.255.255",
-  "192.0.2.235",
-  "99.198.122.146",
-  "46.51.197.88",
-  "173.194.34.134",
-];
-
-const v4not = [
-  ".100.100.100.100",
-  "100..100.100.100.",
-  "100.100.100.100.",
-  "999.999.999.999",
-  "256.256.256.256",
-  "256.100.100.100.100",
-  "123.123.123",
-  "http://123.123.123",
-  "1000.2.3.4",
-  "999.2.3.4",
-  "0000000192.168.0.200",
-  "192.168.0.2000000000",
-];
-
-test("net.isIPv4 correctly identifies valid IPv4 addresses", () => {
-  for (const ip of v4) {
-    expect(net.isIPv4(ip)).toBe(true);
-  }
-});
-
-test("net.isIPv4 correctly identifies invalid IPv4 addresses", () => {
-  for (const ip of v4not) {
-    expect(net.isIPv4(ip)).toBe(false);
-  }
-});
-
-//<#END_FILE: test-net-isipv4.js
diff --git a/test/js/node/test/parallel/net-isipv6.test.js b/test/js/node/test/parallel/net-isipv6.test.js
deleted file mode 100644
index 62d06daf6b..0000000000
--- a/test/js/node/test/parallel/net-isipv6.test.js
+++ /dev/null
@@ -1,254 +0,0 @@
-//#FILE: test-net-isipv6.js
-//#SHA1: 4c6eea8203876ea65c4496732ee169a8fe0eb574
-//-----------------
-"use strict";
-
-const net = require("net");
-
-const v6 = [
-  "::",
-  "1::",
-  "::1",
-  "1::8",
-  "1::7:8",
-  "1:2:3:4:5:6:7:8",
-  "1:2:3:4:5:6::8",
-  "1:2:3:4:5:6:7::",
-  "1:2:3:4:5::7:8",
-  "1:2:3:4:5::8",
-  "1:2:3::8",
-  "1::4:5:6:7:8",
-  "1::6:7:8",
-  "1::3:4:5:6:7:8",
-  "1:2:3:4::6:7:8",
-  "1:2::4:5:6:7:8",
-  "::2:3:4:5:6:7:8",
-  "1:2::8",
-  "2001:0000:1234:0000:0000:C1C0:ABCD:0876",
-  "3ffe:0b00:0000:0000:0001:0000:0000:000a",
-  "FF02:0000:0000:0000:0000:0000:0000:0001",
-  "0000:0000:0000:0000:0000:0000:0000:0001",
-  "0000:0000:0000:0000:0000:0000:0000:0000",
-  "::ffff:192.168.1.26",
-  "2::10",
-  "ff02::1",
-  "fe80::",
-  "2002::",
-  "2001:db8::",
-  "2001:0db8:1234::",
-  "::ffff:0:0",
-  "::ffff:192.168.1.1",
-  "1:2:3:4::8",
-  "1::2:3:4:5:6:7",
-  "1::2:3:4:5:6",
-  "1::2:3:4:5",
-  "1::2:3:4",
-  "1::2:3",
-  "::2:3:4:5:6:7",
-  "::2:3:4:5:6",
-  "::2:3:4:5",
-  "::2:3:4",
-  "::2:3",
-  "::8",
-  "1:2:3:4:5:6::",
-  "1:2:3:4:5::",
-  "1:2:3:4::",
-  "1:2:3::",
-  "1:2::",
-  "1:2:3:4::7:8",
-  "1:2:3::7:8",
-  "1:2::7:8",
-  "1:2:3:4:5:6:1.2.3.4",
-  "1:2:3:4:5::1.2.3.4",
-  "1:2:3:4::1.2.3.4",
-  "1:2:3::1.2.3.4",
-  "1:2::1.2.3.4",
-  "1::1.2.3.4",
-  "1:2:3:4::5:1.2.3.4",
-  "1:2:3::5:1.2.3.4",
-  "1:2::5:1.2.3.4",
-  "1::5:1.2.3.4",
-  "1::5:11.22.33.44",
-  "fe80::217:f2ff:254.7.237.98",
-  "fe80::217:f2ff:fe07:ed62",
-  "2001:DB8:0:0:8:800:200C:417A",
-  "FF01:0:0:0:0:0:0:101",
-  "0:0:0:0:0:0:0:1",
-  "0:0:0:0:0:0:0:0",
-  "2001:DB8::8:800:200C:417A",
-  "FF01::101",
-  "0:0:0:0:0:0:13.1.68.3",
-  "0:0:0:0:0:FFFF:129.144.52.38",
-  "::13.1.68.3",
-  "::FFFF:129.144.52.38",
-  "fe80:0000:0000:0000:0204:61ff:fe9d:f156",
-  "fe80:0:0:0:204:61ff:fe9d:f156",
-  "fe80::204:61ff:fe9d:f156",
-  "fe80:0:0:0:204:61ff:254.157.241.86",
-  "fe80::204:61ff:254.157.241.86",
-  "fe80::1",
-  "2001:0db8:85a3:0000:0000:8a2e:0370:7334",
-  "2001:db8:85a3:0:0:8a2e:370:7334",
-  "2001:db8:85a3::8a2e:370:7334",
-  "2001:0db8:0000:0000:0000:0000:1428:57ab",
-  "2001:0db8:0000:0000:0000::1428:57ab",
-  "2001:0db8:0:0:0:0:1428:57ab",
-  "2001:0db8:0:0::1428:57ab",
-  "2001:0db8::1428:57ab",
-  "2001:db8::1428:57ab",
-  "::ffff:12.34.56.78",
-  "::ffff:0c22:384e",
-  "2001:0db8:1234:0000:0000:0000:0000:0000",
-  "2001:0db8:1234:ffff:ffff:ffff:ffff:ffff",
-  "2001:db8:a::123",
-  "::ffff:192.0.2.128",
-  "::ffff:c000:280",
-  "a:b:c:d:e:f:f1:f2",
-  "a:b:c::d:e:f:f1",
-  "a:b:c::d:e:f",
-  "a:b:c::d:e",
-  "a:b:c::d",
-  "::a",
-  "::a:b:c",
-  "::a:b:c:d:e:f:f1",
-  "a::",
-  "a:b:c::",
-  "a:b:c:d:e:f:f1::",
-  "a:bb:ccc:dddd:000e:00f:0f::",
-  "0:a:0:a:0:0:0:a",
-  "0:a:0:0:a:0:0:a",
-  "2001:db8:1:1:1:1:0:0",
-  "2001:db8:1:1:1:0:0:0",
-  "2001:db8:1:1:0:0:0:0",
-  "2001:db8:1:0:0:0:0:0",
-  "2001:db8:0:0:0:0:0:0",
-  "2001:0:0:0:0:0:0:0",
-  "A:BB:CCC:DDDD:000E:00F:0F::",
-  "0:0:0:0:0:0:0:a",
-  "0:0:0:0:a:0:0:0",
-  "0:0:0:a:0:0:0:0",
-  "a:0:0:a:0:0:a:a",
-  "a:0:0:a:0:0:0:a",
-  "a:0:0:0:a:0:0:a",
-  "a:0:0:0:a:0:0:0",
-  "a:0:0:0:0:0:0:0",
-  "fe80::7:8%eth0",
-  "fe80::7:8%1",
-];
-
-const v6not = [
-  "",
-  "1:",
-  ":1",
-  "11:36:12",
-  "02001:0000:1234:0000:0000:C1C0:ABCD:0876",
-  "2001:0000:1234:0000:00001:C1C0:ABCD:0876",
-  "2001:0000:1234: 0000:0000:C1C0:ABCD:0876",
-  "2001:1:1:1:1:1:255Z255X255Y255",
-  "3ffe:0b00:0000:0001:0000:0000:000a",
-  "FF02:0000:0000:0000:0000:0000:0000:0000:0001",
-  "3ffe:b00::1::a",
-  "::1111:2222:3333:4444:5555:6666::",
-  "1:2:3::4:5::7:8",
-  "12345::6:7:8",
-  "1::5:400.2.3.4",
-  "1::5:260.2.3.4",
-  "1::5:256.2.3.4",
-  "1::5:1.256.3.4",
-  "1::5:1.2.256.4",
-  "1::5:1.2.3.256",
-  "1::5:300.2.3.4",
-  "1::5:1.300.3.4",
-  "1::5:1.2.300.4",
-  "1::5:1.2.3.300",
-  "1::5:900.2.3.4",
-  "1::5:1.900.3.4",
-  "1::5:1.2.900.4",
-  "1::5:1.2.3.900",
-  "1::5:300.300.300.300",
-  "1::5:3000.30.30.30",
-  "1::400.2.3.4",
-  "1::260.2.3.4",
-  "1::256.2.3.4",
-  "1::1.256.3.4",
-  "1::1.2.256.4",
-  "1::1.2.3.256",
-  "1::300.2.3.4",
-  "1::1.300.3.4",
-  "1::1.2.300.4",
-  "1::1.2.3.300",
-  "1::900.2.3.4",
-  "1::1.900.3.4",
-  "1::1.2.900.4",
-  "1::1.2.3.900",
-  "1::300.300.300.300",
-  "1::3000.30.30.30",
-  "::400.2.3.4",
-  "::260.2.3.4",
-  "::256.2.3.4",
-  "::1.256.3.4",
-  "::1.2.256.4",
-  "::1.2.3.256",
-  "::300.2.3.4",
-  "::1.300.3.4",
-  "::1.2.300.4",
-  "::1.2.3.300",
-  "::900.2.3.4",
-  "::1.900.3.4",
-  "::1.2.900.4",
-  "::1.2.3.900",
-  "::300.300.300.300",
-  "::3000.30.30.30",
-  "2001:DB8:0:0:8:800:200C:417A:221",
-  "FF01::101::2",
-  "1111:2222:3333:4444::5555:",
-  "1111:2222:3333::5555:",
-  "1111:2222::5555:",
-  "1111::5555:",
-  "::5555:",
-  ":::",
-  "1111:",
-  ":",
-  ":1111:2222:3333:4444::5555",
-  ":1111:2222:3333::5555",
-  ":1111:2222::5555",
-  ":1111::5555",
-  ":::5555",
-  "1.2.3.4:1111:2222:3333:4444::5555",
-  "1.2.3.4:1111:2222:3333::5555",
-  "1.2.3.4:1111:2222::5555",
-  "1.2.3.4:1111::5555",
-  "1.2.3.4::5555",
-  "1.2.3.4::",
-  "fe80:0000:0000:0000:0204:61ff:254.157.241.086",
-  "123",
-  "ldkfj",
-  "2001::FFD3::57ab",
-  "2001:db8:85a3::8a2e:37023:7334",
-  "2001:db8:85a3::8a2e:370k:7334",
-  "1:2:3:4:5:6:7:8:9",
-  "1::2::3",
-  "1:::3:4:5",
-  "1:2:3::4:5:6:7:8:9",
-  "::ffff:2.3.4",
-  "::ffff:257.1.2.3",
-  "::ffff:12345678901234567890.1.26",
-  "2001:0000:1234:0000:0000:C1C0:ABCD:0876 0",
-  "02001:0000:1234:0000:0000:C1C0:ABCD:0876",
-];
-
-describe("net.isIPv6", () => {
-  test("valid IPv6 addresses", () => {
-    for (const ip of v6) {
-      expect(net.isIPv6(ip)).toBe(true);
-    }
-  });
-
-  test("invalid IPv6 addresses", () => {
-    for (const ip of v6not) {
-      expect(net.isIPv6(ip)).toBe(false);
-    }
-  });
-});
-
-//<#END_FILE: test-net-isipv6.js
diff --git a/test/js/node/test/parallel/net-listen-after-destroying-stdin.test.js b/test/js/node/test/parallel/net-listen-after-destroying-stdin.test.js
deleted file mode 100644
index 3084568eda..0000000000
--- a/test/js/node/test/parallel/net-listen-after-destroying-stdin.test.js
+++ /dev/null
@@ -1,36 +0,0 @@
-//#FILE: test-net-listen-after-destroying-stdin.js
-//#SHA1: 933b6b80e7babac7189e16f85967b75836efea74
-//-----------------
-"use strict";
-
-// Just test that destroying stdin doesn't mess up listening on a server.
-// This is a regression test for
-// https://github.com/nodejs/node-v0.x-archive/issues/746.
-
-const net = require("net");
-
-test("destroying stdin does not affect server listening", done => {
-  process.stdin.destroy();
-
-  const server = net.createServer(socket => {
-    console.log("accepted...");
-    socket.end(() => {
-      console.log("finished...");
-      expect(true).toBe(true); // Ensure this callback is called
-    });
-    server.close(() => {
-      console.log("closed");
-      expect(true).toBe(true); // Ensure this callback is called
-      done();
-    });
-  });
-
-  server.listen(0, () => {
-    console.log("listening...");
-    expect(server.address().port).toBeGreaterThan(0);
-
-    net.createConnection(server.address().port);
-  });
-});
-
-//<#END_FILE: test-net-listen-after-destroying-stdin.js
diff --git a/test/js/node/test/parallel/net-listen-close-server.test.js b/test/js/node/test/parallel/net-listen-close-server.test.js
deleted file mode 100644
index 519ae0a2cb..0000000000
--- a/test/js/node/test/parallel/net-listen-close-server.test.js
+++ /dev/null
@@ -1,41 +0,0 @@
-//#FILE: test-net-listen-close-server.js
-//#SHA1: e39989e43d691f9cc91a02156112ba681366601b
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const net = require("net");
-
-test("server listen and close without calling callbacks", () => {
-  const server = net.createServer(() => {});
-  const listenSpy = jest.fn();
-  const errorSpy = jest.fn();
-
-  server.listen(0, listenSpy);
-  server.on("error", errorSpy);
-  server.close();
-
-  expect(listenSpy).not.toHaveBeenCalled();
-  expect(errorSpy).not.toHaveBeenCalled();
-});
-
-//<#END_FILE: test-net-listen-close-server.js
diff --git a/test/js/node/test/parallel/net-listening.test.js b/test/js/node/test/parallel/net-listening.test.js
deleted file mode 100644
index ea0b14ab53..0000000000
--- a/test/js/node/test/parallel/net-listening.test.js
+++ /dev/null
@@ -1,22 +0,0 @@
-//#FILE: test-net-listening.js
-//#SHA1: 3c2824f7bd90fec69702e096faba0b4f07353a20
-//-----------------
-"use strict";
-const net = require("net");
-
-test("Server listening state", done => {
-  const server = net.createServer();
-
-  expect(server.listening).toBe(false);
-
-  server.listen(0, () => {
-    expect(server.listening).toBe(true);
-
-    server.close(() => {
-      expect(server.listening).toBe(false);
-      done();
-    });
-  });
-});
-
-//<#END_FILE: test-net-listening.js
diff --git a/test/js/node/test/parallel/net-persistent-nodelay.test.js b/test/js/node/test/parallel/net-persistent-nodelay.test.js
deleted file mode 100644
index 87e9db3e82..0000000000
--- a/test/js/node/test/parallel/net-persistent-nodelay.test.js
+++ /dev/null
@@ -1,54 +0,0 @@
-//#FILE: test-net-persistent-nodelay.js
-//#SHA1: 48ab228711df09f547aa2ef4abaac2735ef4625b
-//-----------------
-"use strict";
-
-const net = require("net");
-
-describe("TCP setNoDelay persistence", () => {
-  let echoServer;
-  let originalSetNoDelay;
-  let callCount;
-
-  beforeAll(() => {
-    echoServer = net.createServer(connection => {
-      connection.end();
-    });
-  });
-
-  afterAll(() => {
-    echoServer.close();
-  });
-
-  beforeEach(() => {
-    callCount = 0;
-    originalSetNoDelay = net.Socket.prototype.setNoDelay;
-    net.Socket.prototype.setNoDelay = function (enable) {
-      const result = originalSetNoDelay.call(this, enable);
-      callCount++;
-      return result;
-    };
-  });
-
-  afterEach(() => {
-    net.Socket.prototype.setNoDelay = originalSetNoDelay;
-  });
-
-  test("setNoDelay is called once when connecting", done => {
-    echoServer.listen(0, () => {
-      const sock1 = new net.Socket();
-
-      // setNoDelay before the handle is created
-      const s = sock1.setNoDelay();
-      expect(s).toBeInstanceOf(net.Socket);
-
-      sock1.connect(echoServer.address().port);
-      sock1.on("end", () => {
-        expect(callCount).toBe(1);
-        done();
-      });
-    });
-  });
-});
-
-//<#END_FILE: test-net-persistent-nodelay.js
diff --git a/test/js/node/test/parallel/net-remote-address.test.js b/test/js/node/test/parallel/net-remote-address.test.js
deleted file mode 100644
index ea145b43d3..0000000000
--- a/test/js/node/test/parallel/net-remote-address.test.js
+++ /dev/null
@@ -1,29 +0,0 @@
-//#FILE: test-net-remote-address.js
-//#SHA1: a4c7e915b2d6465060b3d283c3cc3906ad629531
-//-----------------
-"use strict";
-
-const net = require("net");
-
-test("remote address behavior", done => {
-  const server = net.createServer();
-
-  server.listen(() => {
-    const socket = net.connect({ port: server.address().port });
-
-    expect(socket.connecting).toBe(true);
-    expect(socket.remoteAddress).toBeUndefined();
-
-    socket.on("connect", () => {
-      expect(socket.remoteAddress).toBeDefined();
-      socket.end();
-    });
-
-    socket.on("end", () => {
-      server.close();
-      done();
-    });
-  });
-});
-
-//<#END_FILE: test-net-remote-address.js
diff --git a/test/js/node/test/parallel/net-server-close-before-calling-lookup-callback.test.js b/test/js/node/test/parallel/net-server-close-before-calling-lookup-callback.test.js
deleted file mode 100644
index dd3c3b91d0..0000000000
--- a/test/js/node/test/parallel/net-server-close-before-calling-lookup-callback.test.js
+++ /dev/null
@@ -1,21 +0,0 @@
-//#FILE: test-net-server-close-before-calling-lookup-callback.js
-//#SHA1: 42a269f691f19c53994f939bacf7e0451f065107
-//-----------------
-"use strict";
-
-const net = require("net");
-
-test("server closes before calling lookup callback", () => {
-  // Process should exit because it does not create a real TCP server.
-  // Pass localhost to ensure create TCP handle asynchronously because It causes DNS resolution.
-  const server = net.createServer();
-
-  expect(() => {
-    server.listen(0, "localhost", () => {
-      throw new Error("This callback should not be called");
-    });
-    server.close();
-  }).not.toThrow();
-});
-
-//<#END_FILE: test-net-server-close-before-calling-lookup-callback.js
diff --git a/test/js/node/test/parallel/net-server-unref.test.js b/test/js/node/test/parallel/net-server-unref.test.js
deleted file mode 100644
index 2067d6cbb9..0000000000
--- a/test/js/node/test/parallel/net-server-unref.test.js
+++ /dev/null
@@ -1,39 +0,0 @@
-//#FILE: test-net-server-unref.js
-//#SHA1: bb2f989bf01182d804d6a8a0d0f33950f357c617
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const net = require("net");
-
-test("net server unref", () => {
-  const s = net.createServer();
-  s.listen(0);
-  s.unref();
-
-  const mockCallback = jest.fn();
-  setTimeout(mockCallback, 1000).unref();
-
-  expect(mockCallback).not.toHaveBeenCalled();
-});
-
-//<#END_FILE: test-net-server-unref.js
diff --git a/test/js/node/test/parallel/net-socket-close-after-end.test.js b/test/js/node/test/parallel/net-socket-close-after-end.test.js
deleted file mode 100644
index d0d744a6e3..0000000000
--- a/test/js/node/test/parallel/net-socket-close-after-end.test.js
+++ /dev/null
@@ -1,40 +0,0 @@
-//#FILE: test-net-socket-close-after-end.js
-//#SHA1: d3abfad3599a4245fb35f5589c55bb56a43ca3f7
-//-----------------
-"use strict";
-
-const net = require("net");
-
-test('socket emits "end" before "close"', done => {
-  const server = net.createServer();
-
-  server.on("connection", socket => {
-    let endEmitted = false;
-
-    socket.once("readable", () => {
-      setTimeout(() => {
-        socket.read();
-      }, 100);
-    });
-
-    socket.on("end", () => {
-      endEmitted = true;
-    });
-
-    socket.on("close", () => {
-      expect(endEmitted).toBe(true);
-      server.close();
-      done();
-    });
-
-    socket.end("foo");
-  });
-
-  server.listen(() => {
-    const socket = net.createConnection(server.address().port, () => {
-      socket.end("foo");
-    });
-  });
-});
-
-//<#END_FILE: test-net-socket-close-after-end.js
diff --git a/test/js/node/test/parallel/net-socket-connect-without-cb.test.js b/test/js/node/test/parallel/net-socket-connect-without-cb.test.js
deleted file mode 100644
index 3f47475afc..0000000000
--- a/test/js/node/test/parallel/net-socket-connect-without-cb.test.js
+++ /dev/null
@@ -1,37 +0,0 @@
-//#FILE: test-net-socket-connect-without-cb.js
-//#SHA1: 2441c4dfe4351f2e9a02cd08df36e4703096864a
-//-----------------
-"use strict";
-
-const net = require("net");
-
-// This test ensures that socket.connect can be called without callback
-// which is optional.
-
-test("socket.connect without callback", done => {
-  const server = net
-    .createServer(conn => {
-      conn.end();
-      server.close();
-    })
-    .listen(0, () => {
-      const client = new net.Socket();
-
-      client.on("connect", () => {
-        client.end();
-        done();
-      });
-
-      const address = server.address();
-      if (process.version.startsWith("v") && !process.versions.bun && address.family === "IPv6") {
-        // Necessary to pass CI running inside containers.
-        client.connect(address.port);
-      } else {
-        client.connect(address);
-      }
-    });
-
-  expect(server).toBeDefined();
-});
-
-//<#END_FILE: test-net-socket-connect-without-cb.js
diff --git a/test/js/node/test/parallel/net-socket-timeout-unref.test.js b/test/js/node/test/parallel/net-socket-timeout-unref.test.js
deleted file mode 100644
index 5e05c5cf1c..0000000000
--- a/test/js/node/test/parallel/net-socket-timeout-unref.test.js
+++ /dev/null
@@ -1,65 +0,0 @@
-//#FILE: test-net-socket-timeout-unref.js
-//#SHA1: 1583fd33473989bba11fead2493c70a79d9ff48e
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-// Test that unref'ed sockets with timeouts do not prevent exit.
-
-const net = require("net");
-
-test("unref'ed sockets with timeouts do not prevent exit", () => {
-  const server = net.createServer(c => {
-    c.write("hello");
-    c.unref();
-  });
-  server.listen(0);
-  server.unref();
-
-  let connections = 0;
-  const sockets = [];
-  const delays = [8, 5, 3, 6, 2, 4];
-
-  delays.forEach(T => {
-    const socket = net.createConnection(server.address().port, "localhost");
-    socket.on("connect", () => {
-      if (++connections === delays.length) {
-        sockets.forEach(s => {
-          s.socket.setTimeout(s.timeout, () => {
-            s.socket.destroy();
-            throw new Error("socket timed out unexpectedly");
-          });
-
-          s.socket.unref();
-        });
-      }
-    });
-
-    sockets.push({ socket: socket, timeout: T * 1000 });
-  });
-
-  // We don't need to explicitly assert anything here.
-  // The test will pass if the process exits without throwing an error.
-});
-
-//<#END_FILE: test-net-socket-timeout-unref.js
diff --git a/test/js/node/test/parallel/net-socket-write-error.test.js b/test/js/node/test/parallel/net-socket-write-error.test.js
deleted file mode 100644
index 9621de1ab2..0000000000
--- a/test/js/node/test/parallel/net-socket-write-error.test.js
+++ /dev/null
@@ -1,37 +0,0 @@
-//#FILE: test-net-socket-write-error.js
-//#SHA1: a69bb02fc98fc265ad23ff03e7ae16e9c984202d
-//-----------------
-"use strict";
-
-const net = require("net");
-
-test("net socket write error", done => {
-  const server = net.createServer().listen(0, connectToServer);
-
-  function connectToServer() {
-    const client = net
-      .createConnection(this.address().port, () => {
-        client.on("error", () => {
-          throw new Error("Error event should not be emitted");
-        });
-
-        expect(() => {
-          client.write(1337);
-        }).toThrow(
-          expect.objectContaining({
-            code: "ERR_INVALID_ARG_TYPE",
-            name: "TypeError",
-            message: expect.any(String),
-          }),
-        );
-
-        client.destroy();
-      })
-      .on("close", () => {
-        server.close();
-        done();
-      });
-  }
-});
-
-//<#END_FILE: test-net-socket-write-error.js
diff --git a/test/js/node/test/parallel/net-writable.test.js b/test/js/node/test/parallel/net-writable.test.js
deleted file mode 100644
index 60f10d743b..0000000000
--- a/test/js/node/test/parallel/net-writable.test.js
+++ /dev/null
@@ -1,26 +0,0 @@
-//#FILE: test-net-writable.js
-//#SHA1: dfbbbc883e83311b16b93fc9e06d214552cb6448
-//-----------------
-"use strict";
-
-const net = require("net");
-
-test("net writable after end event", done => {
-  const server = net.createServer(s => {
-    server.close();
-    s.end();
-  });
-
-  server.listen(0, "127.0.0.1", () => {
-    const socket = net.connect(server.address().port, "127.0.0.1");
-    socket.on("end", () => {
-      expect(socket.writable).toBe(true);
-      socket.write("hello world");
-      done();
-    });
-  });
-
-  expect.assertions(1);
-});
-
-//<#END_FILE: test-net-writable.js
diff --git a/test/js/node/test/parallel/net-write-after-end-nt.test.js b/test/js/node/test/parallel/net-write-after-end-nt.test.js
deleted file mode 100644
index 871cf88cab..0000000000
--- a/test/js/node/test/parallel/net-write-after-end-nt.test.js
+++ /dev/null
@@ -1,39 +0,0 @@
-//#FILE: test-net-write-after-end-nt.js
-//#SHA1: 086a5699d5eff4953af4e9f19757b8489e915579
-//-----------------
-"use strict";
-
-const net = require("net");
-
-// This test ensures those errors caused by calling `net.Socket.write()`
-// after sockets ending will be emitted in the next tick.
-test("net.Socket.write() after end emits error in next tick", done => {
-  const server = net
-    .createServer(socket => {
-      socket.end();
-    })
-    .listen(() => {
-      const client = net.connect(server.address().port, () => {
-        let hasError = false;
-        client.on("error", err => {
-          hasError = true;
-          server.close();
-          done();
-        });
-        client.on("end", () => {
-          const ret = client.write("hello");
-
-          expect(ret).toBe(false);
-          expect(hasError).toBe(false);
-
-          // Check that the error is emitted in the next tick
-          setImmediate(() => {
-            expect(hasError).toBe(true);
-          });
-        });
-        client.end();
-      });
-    });
-});
-
-//<#END_FILE: test-net-write-after-end-nt.js
diff --git a/test/js/node/test/parallel/net-write-connect-write.test.js b/test/js/node/test/parallel/net-write-connect-write.test.js
deleted file mode 100644
index bc959534eb..0000000000
--- a/test/js/node/test/parallel/net-write-connect-write.test.js
+++ /dev/null
@@ -1,64 +0,0 @@
-//#FILE: test-net-write-connect-write.js
-//#SHA1: 8d6e9a30cc58bee105db15dc48c8a13c451629be
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const net = require("net");
-
-test("net write connect write", async () => {
-  const server = net.createServer(socket => {
-    socket.pipe(socket);
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, resolve);
-  });
-
-  const conn = net.connect(server.address().port);
-  let received = "";
-
-  conn.setEncoding("utf8");
-  conn.write("before");
-
-  await new Promise(resolve => {
-    conn.on("connect", () => {
-      conn.write(" after");
-      resolve();
-    });
-  });
-
-  await new Promise(resolve => {
-    conn.on("data", buf => {
-      received += buf;
-      conn.end();
-    });
-
-    conn.on("end", () => {
-      server.close();
-      expect(received).toBe("before after");
-      resolve();
-    });
-  });
-});
-
-//<#END_FILE: test-net-write-connect-write.js
diff --git a/test/js/node/test/parallel/net-write-fully-async-buffer.test.js b/test/js/node/test/parallel/net-write-fully-async-buffer.test.js
deleted file mode 100644
index 01771830c8..0000000000
--- a/test/js/node/test/parallel/net-write-fully-async-buffer.test.js
+++ /dev/null
@@ -1,45 +0,0 @@
-//#FILE: test-net-write-fully-async-buffer.js
-//#SHA1: b26773ed4c8c5bafaaa8a4513b25d1806a72ae5f
-//-----------------
-"use strict";
-// Flags: --expose-gc
-
-// Note: This is a variant of test-net-write-fully-async-hex-string.js.
-// This always worked, but it seemed appropriate to add a test that checks the
-// behavior for Buffers, too.
-const net = require("net");
-
-const data = Buffer.alloc(1000000);
-
-test("net write fully async buffer", done => {
-  const server = net
-    .createServer(conn => {
-      conn.resume();
-    })
-    .listen(0, () => {
-      const conn = net.createConnection(server.address().port, () => {
-        let count = 0;
-
-        function writeLoop() {
-          if (count++ === 200) {
-            conn.destroy();
-            server.close();
-            done();
-            return;
-          }
-
-          while (conn.write(Buffer.from(data)));
-          global.gc({ type: "minor" });
-          // The buffer allocated above should still be alive.
-        }
-
-        conn.on("drain", writeLoop);
-
-        writeLoop();
-      });
-    });
-
-  expect(server.listening).toBe(true);
-});
-
-//<#END_FILE: test-net-write-fully-async-buffer.js
diff --git a/test/js/node/test/parallel/next-tick-doesnt-hang.test.js b/test/js/node/test/parallel/next-tick-doesnt-hang.test.js
deleted file mode 100644
index 23fa936de0..0000000000
--- a/test/js/node/test/parallel/next-tick-doesnt-hang.test.js
+++ /dev/null
@@ -1,37 +0,0 @@
-//#FILE: test-next-tick-doesnt-hang.js
-//#SHA1: 6812bb4cd77cd15dd04c4409e34e0c5b605bbb88
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-// This test verifies that having a single nextTick statement and nothing else
-// does not hang the event loop. If this test times out it has failed.
-
-test("nextTick does not hang", done => {
-  process.nextTick(() => {
-    // Nothing
-    done();
-  });
-});
-
-//<#END_FILE: test-next-tick-doesnt-hang.js
diff --git a/test/js/node/test/parallel/next-tick-domain.test.js b/test/js/node/test/parallel/next-tick-domain.test.js
deleted file mode 100644
index d975718da7..0000000000
--- a/test/js/node/test/parallel/next-tick-domain.test.js
+++ /dev/null
@@ -1,36 +0,0 @@
-//#FILE: test-next-tick-domain.js
-//#SHA1: 75db0e440cbc2eb2fc89b4486eb10e398042a88b
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-test("requiring domain should not change process.nextTick", () => {
-  const origNextTick = process.nextTick;
-
-  require("domain");
-
-  // Requiring domain should not change nextTick.
-  expect(process.nextTick).toBe(origNextTick);
-});
-
-//<#END_FILE: test-next-tick-domain.js
diff --git a/test/js/node/test/parallel/next-tick-ordering.test.js b/test/js/node/test/parallel/next-tick-ordering.test.js
deleted file mode 100644
index 3790be15ab..0000000000
--- a/test/js/node/test/parallel/next-tick-ordering.test.js
+++ /dev/null
@@ -1,59 +0,0 @@
-//#FILE: test-next-tick-ordering.js
-//#SHA1: 224023554e0ccd7644d70c5acef5bf3a094409ac
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-test("next tick ordering", async () => {
-  const N = 30;
-  const done = [];
-
-  function get_printer(timeout) {
-    return function () {
-      console.log(`Running from setTimeout ${timeout}`);
-      done.push(timeout);
-    };
-  }
-
-  process.nextTick(function () {
-    console.log("Running from nextTick");
-    done.push("nextTick");
-  });
-
-  for (let i = 0; i < N; i += 1) {
-    setTimeout(get_printer(i), i);
-  }
-
-  console.log("Running from main.");
-
-  // Wait for all timeouts to complete
-  await new Promise(resolve => setTimeout(resolve, N + 100));
-
-  expect(done[0]).toBe("nextTick");
-  // Disabling this test. I don't think we can ensure the order
-  // for (let i = 0; i < N; i += 1) {
-  //  expect(done[i + 1]).toBe(i);
-  // }
-});
-
-//<#END_FILE: test-next-tick-ordering.js
diff --git a/test/js/node/test/parallel/next-tick-ordering2.test.js b/test/js/node/test/parallel/next-tick-ordering2.test.js
deleted file mode 100644
index 233df7aed3..0000000000
--- a/test/js/node/test/parallel/next-tick-ordering2.test.js
+++ /dev/null
@@ -1,46 +0,0 @@
-//#FILE: test-next-tick-ordering2.js
-//#SHA1: 6aa2e4c01b6ff008c2c2c844cb50a75d45af481d
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-test("nextTick and setTimeout ordering", async () => {
-  const order = [];
-
-  await new Promise(resolve => {
-    process.nextTick(() => {
-      setTimeout(() => {
-        order.push("setTimeout");
-        resolve();
-      }, 0);
-
-      process.nextTick(() => {
-        order.push("nextTick");
-      });
-    });
-  });
-
-  expect(order).toEqual(["nextTick", "setTimeout"]);
-});
-
-//<#END_FILE: test-next-tick-ordering2.js
diff --git a/test/js/node/test/parallel/next-tick-when-exiting.test.js b/test/js/node/test/parallel/next-tick-when-exiting.test.js
deleted file mode 100644
index 1684eebc47..0000000000
--- a/test/js/node/test/parallel/next-tick-when-exiting.test.js
+++ /dev/null
@@ -1,21 +0,0 @@
-//#FILE: test-next-tick-when-exiting.js
-//#SHA1: fcca0c205805ee8c1d9e994013d5e3738e3ef6e4
-//-----------------
-"use strict";
-
-test("process.nextTick should not be called when exiting", () => {
-  const exitHandler = jest.fn(() => {
-    expect(process._exiting).toBe(true);
-
-    process.nextTick(jest.fn().mockName("process is exiting, should not be called"));
-  });
-
-  process.on("exit", exitHandler);
-
-  process.exit();
-
-  expect(exitHandler).toHaveBeenCalledTimes(1);
-  expect(exitHandler.mock.calls[0][0]).toBe(undefined);
-});
-
-//<#END_FILE: test-next-tick-when-exiting.js
diff --git a/test/js/node/test/parallel/no-node-snapshot.test.js b/test/js/node/test/parallel/no-node-snapshot.test.js
deleted file mode 100644
index bebaabb1c5..0000000000
--- a/test/js/node/test/parallel/no-node-snapshot.test.js
+++ /dev/null
@@ -1,14 +0,0 @@
-//#FILE: test-no-node-snapshot.js
-//#SHA1: e8e4ecdb2aa4c064a55e1c7b076424d0b0d0a007
-//-----------------
-"use strict";
-
-// Flags: --no-node-snapshot
-
-test("--no-node-snapshot flag", () => {
-  // This test doesn't actually assert anything.
-  // It's merely checking if the script runs without errors when the flag is set.
-  expect(true).toBe(true);
-});
-
-//<#END_FILE: test-no-node-snapshot.js
diff --git a/test/js/node/test/parallel/outgoing-message-destroy.test.js b/test/js/node/test/parallel/outgoing-message-destroy.test.js
deleted file mode 100644
index 6f61032083..0000000000
--- a/test/js/node/test/parallel/outgoing-message-destroy.test.js
+++ /dev/null
@@ -1,19 +0,0 @@
-//#FILE: test-outgoing-message-destroy.js
-//#SHA1: 64f5438a6e8b8315e79f25d8f9e40b7dde6e3c19
-//-----------------
-"use strict";
-
-// Test that http.OutgoingMessage,prototype.destroy() returns `this`.
-
-const http = require("http");
-
-test("http.OutgoingMessage.prototype.destroy() returns `this`", () => {
-  const outgoingMessage = new http.OutgoingMessage();
-
-  expect(outgoingMessage.destroyed).toBe(false);
-  expect(outgoingMessage.destroy()).toBe(outgoingMessage);
-  expect(outgoingMessage.destroyed).toBe(true);
-  expect(outgoingMessage.destroy()).toBe(outgoingMessage);
-});
-
-//<#END_FILE: test-outgoing-message-destroy.js
diff --git a/test/js/node/test/parallel/path-extname.test.js b/test/js/node/test/parallel/path-extname.test.js
deleted file mode 100644
index e8a74c6b2e..0000000000
--- a/test/js/node/test/parallel/path-extname.test.js
+++ /dev/null
@@ -1,115 +0,0 @@
-//#FILE: test-path-extname.js
-//#SHA1: 29d676d507ef80d7e5795db0f2a0265dbc7baf1e
-//-----------------
-"use strict";
-const path = require("path");
-
-const slashRE = /\//g;
-
-const testPaths = [
-  [__filename, ".js"],
-  ["", ""],
-  ["/path/to/file", ""],
-  ["/path/to/file.ext", ".ext"],
-  ["/path.to/file.ext", ".ext"],
-  ["/path.to/file", ""],
-  ["/path.to/.file", ""],
-  ["/path.to/.file.ext", ".ext"],
-  ["/path/to/f.ext", ".ext"],
-  ["/path/to/..ext", ".ext"],
-  ["/path/to/..", ""],
-  ["file", ""],
-  ["file.ext", ".ext"],
-  [".file", ""],
-  [".file.ext", ".ext"],
-  ["/file", ""],
-  ["/file.ext", ".ext"],
-  ["/.file", ""],
-  ["/.file.ext", ".ext"],
-  [".path/file.ext", ".ext"],
-  ["file.ext.ext", ".ext"],
-  ["file.", "."],
-  [".", ""],
-  ["./", ""],
-  [".file.ext", ".ext"],
-  [".file", ""],
-  [".file.", "."],
-  [".file..", "."],
-  ["..", ""],
-  ["../", ""],
-  ["..file.ext", ".ext"],
-  ["..file", ".file"],
-  ["..file.", "."],
-  ["..file..", "."],
-  ["...", "."],
-  ["...ext", ".ext"],
-  ["....", "."],
-  ["file.ext/", ".ext"],
-  ["file.ext//", ".ext"],
-  ["file/", ""],
-  ["file//", ""],
-  ["file./", "."],
-  ["file.//", "."],
-];
-
-describe("path.extname", () => {
-  test("should return correct extensions for various paths", () => {
-    const failures = [];
-
-    for (const testPath of testPaths) {
-      const expected = testPath[1];
-      const extNames = [path.posix.extname, path.win32.extname];
-      for (const extname of extNames) {
-        let input = testPath[0];
-        let os;
-        if (extname === path.win32.extname) {
-          input = input.replace(slashRE, "\\");
-          os = "win32";
-        } else {
-          os = "posix";
-        }
-        const actual = extname(input);
-        const message = `path.${os}.extname(${JSON.stringify(input)})\n  expect=${JSON.stringify(
-          expected,
-        )}\n  actual=${JSON.stringify(actual)}`;
-        if (actual !== expected) failures.push(`\n${message}`);
-      }
-      const input = `C:${testPath[0].replace(slashRE, "\\")}`;
-      const actual = path.win32.extname(input);
-      const message = `path.win32.extname(${JSON.stringify(input)})\n  expect=${JSON.stringify(
-        expected,
-      )}\n  actual=${JSON.stringify(actual)}`;
-      if (actual !== expected) failures.push(`\n${message}`);
-    }
-
-    expect(failures).toHaveLength(0);
-  });
-
-  describe("Windows-specific behavior", () => {
-    test("backslash is a path separator", () => {
-      expect(path.win32.extname(".\\").toString()).toBe("");
-      expect(path.win32.extname("..\\").toString()).toBe("");
-      expect(path.win32.extname("file.ext\\").toString()).toBe(".ext");
-      expect(path.win32.extname("file.ext\\\\").toString()).toBe(".ext");
-      expect(path.win32.extname("file\\").toString()).toBe("");
-      expect(path.win32.extname("file\\\\").toString()).toBe("");
-      expect(path.win32.extname("file.\\").toString()).toBe(".");
-      expect(path.win32.extname("file.\\\\").toString()).toBe(".");
-    });
-  });
-
-  describe("POSIX-specific behavior", () => {
-    test("backslash is a valid name component", () => {
-      expect(path.posix.extname(".\\").toString()).toBe("");
-      expect(path.posix.extname("..\\").toString()).toBe(".\\");
-      expect(path.posix.extname("file.ext\\").toString()).toBe(".ext\\");
-      expect(path.posix.extname("file.ext\\\\").toString()).toBe(".ext\\\\");
-      expect(path.posix.extname("file\\").toString()).toBe("");
-      expect(path.posix.extname("file\\\\").toString()).toBe("");
-      expect(path.posix.extname("file.\\").toString()).toBe(".\\");
-      expect(path.posix.extname("file.\\\\").toString()).toBe(".\\\\");
-    });
-  });
-});
-
-//<#END_FILE: test-path-extname.js
diff --git a/test/js/node/test/parallel/path-isabsolute.test.js b/test/js/node/test/parallel/path-isabsolute.test.js
deleted file mode 100644
index 53604b0d51..0000000000
--- a/test/js/node/test/parallel/path-isabsolute.test.js
+++ /dev/null
@@ -1,36 +0,0 @@
-//#FILE: test-path-isabsolute.js
-//#SHA1: d0ff051a7934f18aed9c435a823ff688e5f782c1
-//-----------------
-"use strict";
-
-const path = require("path");
-
-test("path.win32.isAbsolute", () => {
-  expect(path.win32.isAbsolute("/")).toBe(true);
-  expect(path.win32.isAbsolute("//")).toBe(true);
-  expect(path.win32.isAbsolute("//server")).toBe(true);
-  expect(path.win32.isAbsolute("//server/file")).toBe(true);
-  expect(path.win32.isAbsolute("\\\\server\\file")).toBe(true);
-  expect(path.win32.isAbsolute("\\\\server")).toBe(true);
-  expect(path.win32.isAbsolute("\\\\")).toBe(true);
-  expect(path.win32.isAbsolute("c")).toBe(false);
-  expect(path.win32.isAbsolute("c:")).toBe(false);
-  expect(path.win32.isAbsolute("c:\\")).toBe(true);
-  expect(path.win32.isAbsolute("c:/")).toBe(true);
-  expect(path.win32.isAbsolute("c://")).toBe(true);
-  expect(path.win32.isAbsolute("C:/Users/")).toBe(true);
-  expect(path.win32.isAbsolute("C:\\Users\\")).toBe(true);
-  expect(path.win32.isAbsolute("C:cwd/another")).toBe(false);
-  expect(path.win32.isAbsolute("C:cwd\\another")).toBe(false);
-  expect(path.win32.isAbsolute("directory/directory")).toBe(false);
-  expect(path.win32.isAbsolute("directory\\directory")).toBe(false);
-});
-
-test("path.posix.isAbsolute", () => {
-  expect(path.posix.isAbsolute("/home/foo")).toBe(true);
-  expect(path.posix.isAbsolute("/home/foo/..")).toBe(true);
-  expect(path.posix.isAbsolute("bar/")).toBe(false);
-  expect(path.posix.isAbsolute("./baz")).toBe(false);
-});
-
-//<#END_FILE: test-path-isabsolute.js
diff --git a/test/js/node/test/parallel/path-normalize.test.js b/test/js/node/test/parallel/path-normalize.test.js
deleted file mode 100644
index c1a4bee899..0000000000
--- a/test/js/node/test/parallel/path-normalize.test.js
+++ /dev/null
@@ -1,63 +0,0 @@
-//#FILE: test-path-normalize.js
-//#SHA1: 94c9aec4a962fc0737d7a88610d3c3e17a3b96b5
-//-----------------
-"use strict";
-
-const path = require("path");
-
-describe("path.normalize", () => {
-  describe("win32", () => {
-    test("normalizes various paths correctly", () => {
-      expect(path.win32.normalize("./fixtures///b/../b/c.js")).toBe("fixtures\\b\\c.js");
-      expect(path.win32.normalize("/foo/../../../bar")).toBe("\\bar");
-      expect(path.win32.normalize("a//b//../b")).toBe("a\\b");
-      expect(path.win32.normalize("a//b//./c")).toBe("a\\b\\c");
-      expect(path.win32.normalize("a//b//.")).toBe("a\\b");
-      expect(path.win32.normalize("//server/share/dir/file.ext")).toBe("\\\\server\\share\\dir\\file.ext");
-      expect(path.win32.normalize("/a/b/c/../../../x/y/z")).toBe("\\x\\y\\z");
-      expect(path.win32.normalize("C:")).toBe("C:.");
-      expect(path.win32.normalize("C:..\\abc")).toBe("C:..\\abc");
-      expect(path.win32.normalize("C:..\\..\\abc\\..\\def")).toBe("C:..\\..\\def");
-      expect(path.win32.normalize("C:\\.")).toBe("C:\\");
-      expect(path.win32.normalize("file:stream")).toBe("file:stream");
-      expect(path.win32.normalize("bar\\foo..\\..\\")).toBe("bar\\");
-      expect(path.win32.normalize("bar\\foo..\\..")).toBe("bar");
-      expect(path.win32.normalize("bar\\foo..\\..\\baz")).toBe("bar\\baz");
-      expect(path.win32.normalize("bar\\foo..\\")).toBe("bar\\foo..\\");
-      expect(path.win32.normalize("bar\\foo..")).toBe("bar\\foo..");
-      expect(path.win32.normalize("..\\foo..\\..\\..\\bar")).toBe("..\\..\\bar");
-      expect(path.win32.normalize("..\\...\\..\\.\\...\\..\\..\\bar")).toBe("..\\..\\bar");
-      expect(path.win32.normalize("../../../foo/../../../bar")).toBe("..\\..\\..\\..\\..\\bar");
-      expect(path.win32.normalize("../../../foo/../../../bar/../../")).toBe("..\\..\\..\\..\\..\\..\\");
-      expect(path.win32.normalize("../foobar/barfoo/foo/../../../bar/../../")).toBe("..\\..\\");
-      expect(path.win32.normalize("../.../../foobar/../../../bar/../../baz")).toBe("..\\..\\..\\..\\baz");
-      expect(path.win32.normalize("foo/bar\\baz")).toBe("foo\\bar\\baz");
-    });
-  });
-
-  describe("posix", () => {
-    test("normalizes various paths correctly", () => {
-      expect(path.posix.normalize("./fixtures///b/../b/c.js")).toBe("fixtures/b/c.js");
-      expect(path.posix.normalize("/foo/../../../bar")).toBe("/bar");
-      expect(path.posix.normalize("a//b//../b")).toBe("a/b");
-      expect(path.posix.normalize("a//b//./c")).toBe("a/b/c");
-      expect(path.posix.normalize("a//b//.")).toBe("a/b");
-      expect(path.posix.normalize("/a/b/c/../../../x/y/z")).toBe("/x/y/z");
-      expect(path.posix.normalize("///..//./foo/.//bar")).toBe("/foo/bar");
-      expect(path.posix.normalize("bar/foo../../")).toBe("bar/");
-      expect(path.posix.normalize("bar/foo../..")).toBe("bar");
-      expect(path.posix.normalize("bar/foo../../baz")).toBe("bar/baz");
-      expect(path.posix.normalize("bar/foo../")).toBe("bar/foo../");
-      expect(path.posix.normalize("bar/foo..")).toBe("bar/foo..");
-      expect(path.posix.normalize("../foo../../../bar")).toBe("../../bar");
-      expect(path.posix.normalize("../.../.././.../../../bar")).toBe("../../bar");
-      expect(path.posix.normalize("../../../foo/../../../bar")).toBe("../../../../../bar");
-      expect(path.posix.normalize("../../../foo/../../../bar/../../")).toBe("../../../../../../");
-      expect(path.posix.normalize("../foobar/barfoo/foo/../../../bar/../../")).toBe("../../");
-      expect(path.posix.normalize("../.../../foobar/../../../bar/../../baz")).toBe("../../../../baz");
-      expect(path.posix.normalize("foo/bar\\baz")).toBe("foo/bar\\baz");
-    });
-  });
-});
-
-//<#END_FILE: test-path-normalize.js
diff --git a/test/js/node/test/parallel/path-posix-exists.test.js b/test/js/node/test/parallel/path-posix-exists.test.js
deleted file mode 100644
index 8dfb86ea81..0000000000
--- a/test/js/node/test/parallel/path-posix-exists.test.js
+++ /dev/null
@@ -1,21 +0,0 @@
-//#FILE: test-path-posix-exists.js
-//#SHA1: 4bd4c9ef3ffd03623fefbdedd28732c21fd10956
-//-----------------
-"use strict";
-
-// The original test file used Node.js specific modules and assertions.
-// We'll convert this to use Jest's testing framework while maintaining
-// the same behavior and allowing it to run in both Node.js and Bun.
-
-test("path/posix module exists and is identical to path.posix", () => {
-  // In Jest, we don't need to explicitly require assert
-  // We'll use Jest's expect API instead
-
-  // We still need to require the path module
-  const path = require("path");
-
-  // Check if the path/posix module is the same as path.posix
-  expect(require("path/posix")).toBe(path.posix);
-});
-
-//<#END_FILE: test-path-posix-exists.js
diff --git a/test/js/node/test/parallel/path-posix-relative-on-windows.test.js b/test/js/node/test/parallel/path-posix-relative-on-windows.test.js
deleted file mode 100644
index c1a4e9ea2c..0000000000
--- a/test/js/node/test/parallel/path-posix-relative-on-windows.test.js
+++ /dev/null
@@ -1,15 +0,0 @@
-//#FILE: test-path-posix-relative-on-windows.js
-//#SHA1: 2fb8d86d02eea6a077fbca45828aa2433d6a49e6
-//-----------------
-"use strict";
-
-const path = require("path");
-
-// Refs: https://github.com/nodejs/node/issues/13683
-
-test("path.posix.relative on Windows", () => {
-  const relativePath = path.posix.relative("a/b/c", "../../x");
-  expect(relativePath).toMatch(/^(\.\.\/){3,5}x$/);
-});
-
-//<#END_FILE: test-path-posix-relative-on-windows.js
diff --git a/test/js/node/test/parallel/path-relative.test.js b/test/js/node/test/parallel/path-relative.test.js
deleted file mode 100644
index 86c50968de..0000000000
--- a/test/js/node/test/parallel/path-relative.test.js
+++ /dev/null
@@ -1,75 +0,0 @@
-//#FILE: test-path-relative.js
-//#SHA1: 9f0d03bf451853a369a3b31b94b902ee4f607e51
-//-----------------
-"use strict";
-
-const path = require("path");
-
-describe("path.relative", () => {
-  const relativeTests = [
-    [
-      path.win32.relative,
-      // Arguments                     result
-      [
-        ["c:/blah\\blah", "d:/games", "d:\\games"],
-        ["c:/aaaa/bbbb", "c:/aaaa", ".."],
-        ["c:/aaaa/bbbb", "c:/cccc", "..\\..\\cccc"],
-        ["c:/aaaa/bbbb", "c:/aaaa/bbbb", ""],
-        ["c:/aaaa/bbbb", "c:/aaaa/cccc", "..\\cccc"],
-        ["c:/aaaa/", "c:/aaaa/cccc", "cccc"],
-        ["c:/", "c:\\aaaa\\bbbb", "aaaa\\bbbb"],
-        ["c:/aaaa/bbbb", "d:\\", "d:\\"],
-        ["c:/AaAa/bbbb", "c:/aaaa/bbbb", ""],
-        ["c:/aaaaa/", "c:/aaaa/cccc", "..\\aaaa\\cccc"],
-        ["C:\\foo\\bar\\baz\\quux", "C:\\", "..\\..\\..\\.."],
-        ["C:\\foo\\test", "C:\\foo\\test\\bar\\package.json", "bar\\package.json"],
-        ["C:\\foo\\bar\\baz-quux", "C:\\foo\\bar\\baz", "..\\baz"],
-        ["C:\\foo\\bar\\baz", "C:\\foo\\bar\\baz-quux", "..\\baz-quux"],
-        ["\\\\foo\\bar", "\\\\foo\\bar\\baz", "baz"],
-        ["\\\\foo\\bar\\baz", "\\\\foo\\bar", ".."],
-        ["\\\\foo\\bar\\baz-quux", "\\\\foo\\bar\\baz", "..\\baz"],
-        ["\\\\foo\\bar\\baz", "\\\\foo\\bar\\baz-quux", "..\\baz-quux"],
-        ["C:\\baz-quux", "C:\\baz", "..\\baz"],
-        ["C:\\baz", "C:\\baz-quux", "..\\baz-quux"],
-        ["\\\\foo\\baz-quux", "\\\\foo\\baz", "..\\baz"],
-        ["\\\\foo\\baz", "\\\\foo\\baz-quux", "..\\baz-quux"],
-        ["C:\\baz", "\\\\foo\\bar\\baz", "\\\\foo\\bar\\baz"],
-        ["\\\\foo\\bar\\baz", "C:\\baz", "C:\\baz"],
-      ],
-    ],
-    [
-      path.posix.relative,
-      // Arguments          result
-      [
-        ["/var/lib", "/var", ".."],
-        ["/var/lib", "/bin", "../../bin"],
-        ["/var/lib", "/var/lib", ""],
-        ["/var/lib", "/var/apache", "../apache"],
-        ["/var/", "/var/lib", "lib"],
-        ["/", "/var/lib", "var/lib"],
-        ["/foo/test", "/foo/test/bar/package.json", "bar/package.json"],
-        ["/Users/a/web/b/test/mails", "/Users/a/web/b", "../.."],
-        ["/foo/bar/baz-quux", "/foo/bar/baz", "../baz"],
-        ["/foo/bar/baz", "/foo/bar/baz-quux", "../baz-quux"],
-        ["/baz-quux", "/baz", "../baz"],
-        ["/baz", "/baz-quux", "../baz-quux"],
-        ["/page1/page2/foo", "/", "../../.."],
-      ],
-    ],
-  ];
-
-  relativeTests.forEach(test => {
-    const relative = test[0];
-    const os = relative === path.win32.relative ? "win32" : "posix";
-
-    test[1].forEach(testCase => {
-      it(`path.${os}.relative(${JSON.stringify(testCase[0])}, ${JSON.stringify(testCase[1])})`, () => {
-        const actual = relative(testCase[0], testCase[1]);
-        const expected = testCase[2];
-        expect(actual).toBe(expected);
-      });
-    });
-  });
-});
-
-//<#END_FILE: test-path-relative.js
diff --git a/test/js/node/test/parallel/path-win32-exists.test.js b/test/js/node/test/parallel/path-win32-exists.test.js
deleted file mode 100644
index b3aae0de87..0000000000
--- a/test/js/node/test/parallel/path-win32-exists.test.js
+++ /dev/null
@@ -1,10 +0,0 @@
-//#FILE: test-path-win32-exists.js
-//#SHA1: 7d5cfa1f0fc5a13f9878eddd3b119b9c488fecc5
-//-----------------
-"use strict";
-
-test("path/win32 exists and is the same as path.win32", () => {
-  expect(require("path/win32")).toBe(require("path").win32);
-});
-
-//<#END_FILE: test-path-win32-exists.js
diff --git a/test/js/node/test/parallel/path-zero-length-strings.test.js b/test/js/node/test/parallel/path-zero-length-strings.test.js
deleted file mode 100644
index 0c4766ddd6..0000000000
--- a/test/js/node/test/parallel/path-zero-length-strings.test.js
+++ /dev/null
@@ -1,47 +0,0 @@
-//#FILE: test-path-zero-length-strings.js
-//#SHA1: 2f55f68499f5dcd0b2cbb43e7793c0f45175402f
-//-----------------
-"use strict";
-
-// These testcases are specific to one uncommon behavior in path module. Few
-// of the functions in path module, treat '' strings as current working
-// directory. This test makes sure that the behavior is intact between commits.
-// See: https://github.com/nodejs/node/pull/2106
-
-const path = require("path");
-const pwd = process.cwd();
-
-describe("Path module zero-length strings behavior", () => {
-  test("Join with zero-length strings", () => {
-    expect(path.posix.join("")).toBe(".");
-    expect(path.posix.join("", "")).toBe(".");
-    expect(path.win32.join("")).toBe(".");
-    expect(path.win32.join("", "")).toBe(".");
-    expect(path.join(pwd)).toBe(pwd);
-    expect(path.join(pwd, "")).toBe(pwd);
-  });
-
-  test("Normalize with zero-length strings", () => {
-    expect(path.posix.normalize("")).toBe(".");
-    expect(path.win32.normalize("")).toBe(".");
-    expect(path.normalize(pwd)).toBe(pwd);
-  });
-
-  test("isAbsolute with zero-length strings", () => {
-    expect(path.posix.isAbsolute("")).toBe(false);
-    expect(path.win32.isAbsolute("")).toBe(false);
-  });
-
-  test("Resolve with zero-length strings", () => {
-    expect(path.resolve("")).toBe(pwd);
-    expect(path.resolve("", "")).toBe(pwd);
-  });
-
-  test("Relative with zero-length strings", () => {
-    expect(path.relative("", pwd)).toBe("");
-    expect(path.relative(pwd, "")).toBe("");
-    expect(path.relative(pwd, pwd)).toBe("");
-  });
-});
-
-//<#END_FILE: test-path-zero-length-strings.js
diff --git a/test/js/node/test/parallel/path.test.js b/test/js/node/test/parallel/path.test.js
deleted file mode 100644
index f358ae1a27..0000000000
--- a/test/js/node/test/parallel/path.test.js
+++ /dev/null
@@ -1,88 +0,0 @@
-//#FILE: test-path.js
-//#SHA1: da9d0113e57d9da3983b555973f7835c17657326
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const path = require("path");
-
-// Test thrown TypeErrors
-const typeErrorTests = [true, false, 7, null, {}, undefined, [], NaN];
-
-function fail(fn) {
-  const args = Array.from(arguments).slice(1);
-
-  expect(() => {
-    fn.apply(null, args);
-  }).toThrow(
-    expect.objectContaining({
-      code: "ERR_INVALID_ARG_TYPE",
-      name: "TypeError",
-    }),
-  );
-}
-
-test("Invalid argument types", () => {
-  for (const test of typeErrorTests) {
-    for (const namespace of [path.posix, path.win32]) {
-      fail(namespace.join, test);
-      fail(namespace.resolve, test);
-      fail(namespace.normalize, test);
-      fail(namespace.isAbsolute, test);
-      fail(namespace.relative, test, "foo");
-      fail(namespace.relative, "foo", test);
-      fail(namespace.parse, test);
-      fail(namespace.dirname, test);
-      fail(namespace.basename, test);
-      fail(namespace.extname, test);
-
-      // Undefined is a valid value as the second argument to basename
-      if (test !== undefined) {
-        fail(namespace.basename, "foo", test);
-      }
-    }
-  }
-});
-
-test("path.sep tests", () => {
-  // windows
-  expect(path.win32.sep).toBe("\\");
-  // posix
-  expect(path.posix.sep).toBe("/");
-});
-
-test("path.delimiter tests", () => {
-  // windows
-  expect(path.win32.delimiter).toBe(";");
-  // posix
-  expect(path.posix.delimiter).toBe(":");
-});
-
-test("path module", () => {
-  if (process.platform === "win32") {
-    expect(path).toBe(path.win32);
-  } else {
-    expect(path).toBe(path.posix);
-  }
-});
-
-//<#END_FILE: test-path.js
diff --git a/test/js/node/test/parallel/perf-gc-crash.test.js b/test/js/node/test/parallel/perf-gc-crash.test.js
deleted file mode 100644
index 059bff9b3c..0000000000
--- a/test/js/node/test/parallel/perf-gc-crash.test.js
+++ /dev/null
@@ -1,30 +0,0 @@
-//#FILE: test-perf-gc-crash.js
-//#SHA1: 376f73db023a0e22edee3e715b8b5999213b5c93
-//-----------------
-"use strict";
-
-// Refers to https://github.com/nodejs/node/issues/39548
-
-// The test fails if this crashes. If it closes normally,
-// then all is good.
-
-const { PerformanceObserver } = require("perf_hooks");
-
-test("PerformanceObserver does not crash on multiple observe and disconnect calls", () => {
-  // We don't actually care if the observer callback is called here.
-  const gcObserver = new PerformanceObserver(() => {});
-
-  expect(() => {
-    gcObserver.observe({ entryTypes: ["gc"] });
-    gcObserver.disconnect();
-  }).not.toThrow();
-
-  const gcObserver2 = new PerformanceObserver(() => {});
-
-  expect(() => {
-    gcObserver2.observe({ entryTypes: ["gc"] });
-    gcObserver2.disconnect();
-  }).not.toThrow();
-});
-
-//<#END_FILE: test-perf-gc-crash.js
diff --git a/test/js/node/test/parallel/performance-measure.test.js b/test/js/node/test/parallel/performance-measure.test.js
deleted file mode 100644
index eff0e0d818..0000000000
--- a/test/js/node/test/parallel/performance-measure.test.js
+++ /dev/null
@@ -1,34 +0,0 @@
-//#FILE: test-performance-measure.js
-//#SHA1: f049b29e11ba7864ddf502609caf424eccee7ca5
-//-----------------
-"use strict";
-
-const { PerformanceObserver, performance } = require("perf_hooks");
-
-const DELAY = 1000;
-const ALLOWED_MARGIN = 10;
-
-test("performance measures", done => {
-  const expected = ["Start to Now", "A to Now", "A to B"];
-  const obs = new PerformanceObserver(items => {
-    items.getEntries().forEach(({ name, duration }) => {
-      expect(duration).toBeGreaterThan(DELAY - ALLOWED_MARGIN);
-      expect(expected.shift()).toBe(name);
-    });
-    if (expected.length === 0) {
-      done();
-    }
-  });
-  obs.observe({ entryTypes: ["measure"] });
-
-  performance.mark("A");
-  setTimeout(() => {
-    performance.measure("Start to Now");
-    performance.measure("A to Now", "A");
-
-    performance.mark("B");
-    performance.measure("A to B", "A", "B");
-  }, DELAY);
-});
-
-//<#END_FILE: test-performance-measure.js
diff --git a/test/js/node/test/parallel/performance-nodetiming.test.js b/test/js/node/test/parallel/performance-nodetiming.test.js
deleted file mode 100644
index 9146bc5b05..0000000000
--- a/test/js/node/test/parallel/performance-nodetiming.test.js
+++ /dev/null
@@ -1,63 +0,0 @@
-//#FILE: test-performance-nodetiming.js
-//#SHA1: 7b861bd4f2035688c2cb23ff54525d8e039c2d23
-//-----------------
-"use strict";
-
-const { performance } = require("perf_hooks");
-const { isMainThread } = require("worker_threads");
-
-describe("performance.nodeTiming", () => {
-  const { nodeTiming } = performance;
-
-  test("basic properties", () => {
-    expect(nodeTiming.name).toBe("node");
-    expect(nodeTiming.entryType).toBe("node");
-  });
-
-  test("timing values", () => {
-    expect(nodeTiming.startTime).toBe(0);
-    const now = performance.now();
-    expect(nodeTiming.duration).toBeGreaterThanOrEqual(now);
-  });
-
-  test("milestone values order", () => {
-    const keys = ["nodeStart", "v8Start", "environment", "bootstrapComplete"];
-    for (let idx = 0; idx < keys.length; idx++) {
-      if (idx === 0) {
-        expect(nodeTiming[keys[idx]]).toBeGreaterThanOrEqual(0);
-        continue;
-      }
-      expect(nodeTiming[keys[idx]]).toBeGreaterThan(nodeTiming[keys[idx - 1]]);
-    }
-  });
-
-  test("loop milestones", () => {
-    expect(nodeTiming.idleTime).toBe(0);
-    if (isMainThread) {
-      expect(nodeTiming.loopStart).toBe(-1);
-    } else {
-      expect(nodeTiming.loopStart).toBeGreaterThanOrEqual(nodeTiming.bootstrapComplete);
-    }
-    expect(nodeTiming.loopExit).toBe(-1);
-  });
-
-  test("idle time and loop exit", done => {
-    setTimeout(() => {
-      expect(nodeTiming.idleTime).toBeGreaterThanOrEqual(0);
-      expect(nodeTiming.idleTime + nodeTiming.loopExit).toBeLessThanOrEqual(nodeTiming.duration);
-      expect(nodeTiming.loopStart).toBeGreaterThanOrEqual(nodeTiming.bootstrapComplete);
-      done();
-    }, 1);
-  });
-
-  test("loop exit on process exit", done => {
-    process.on("exit", () => {
-      expect(nodeTiming.loopExit).toBeGreaterThan(0);
-      done();
-    });
-    // Trigger process exit
-    process.exit();
-  });
-});
-
-//<#END_FILE: test-performance-nodetiming.js
diff --git a/test/js/node/test/parallel/performanceobserver-gc.test.js b/test/js/node/test/parallel/performanceobserver-gc.test.js
deleted file mode 100644
index b5e6c913d0..0000000000
--- a/test/js/node/test/parallel/performanceobserver-gc.test.js
+++ /dev/null
@@ -1,22 +0,0 @@
-//#FILE: test-performanceobserver-gc.js
-//#SHA1: 2a18df2fa465d96ec5c9ee5d42052c732c777e2b
-//-----------------
-"use strict";
-
-// Verifies that setting up two observers to listen
-// to gc performance does not crash.
-
-const { PerformanceObserver } = require("perf_hooks");
-
-test("Setting up two observers to listen to gc performance does not crash", () => {
-  // We don't actually care if the callback is ever invoked in this test
-  const obs = new PerformanceObserver(() => {});
-  const obs2 = new PerformanceObserver(() => {});
-
-  expect(() => {
-    obs.observe({ type: "gc" });
-    obs2.observe({ type: "gc" });
-  }).not.toThrow();
-});
-
-//<#END_FILE: test-performanceobserver-gc.js
diff --git a/test/js/node/test/parallel/pipe-abstract-socket.test.js b/test/js/node/test/parallel/pipe-abstract-socket.test.js
deleted file mode 100644
index 57a49d09ae..0000000000
--- a/test/js/node/test/parallel/pipe-abstract-socket.test.js
+++ /dev/null
@@ -1,62 +0,0 @@
-//#FILE: test-pipe-abstract-socket.js
-//#SHA1: 085e51018c26c846b8ea9a2b23da4f45f37fe82f
-//-----------------
-"use strict";
-
-const net = require("net");
-
-const isLinux = process.platform === "linux";
-
-if (!isLinux) {
-  it.skip("Skipping test on non-Linux platforms", () => {});
-} 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";
-
-    test("throws when setting readableAll to true", () => {
-      expect(() => {
-        const server = net.createServer(jest.fn());
-        server.listen({
-          path,
-          readableAll: true,
-        });
-      }).toThrow(
-        expect.objectContaining({
-          message: expect.any(String),
-        }),
-      );
-    });
-
-    test("throws when setting writableAll to true", () => {
-      expect(() => {
-        const server = net.createServer(jest.fn());
-        server.listen({
-          path,
-          writableAll: true,
-        });
-      }).toThrow(
-        expect.objectContaining({
-          message: expect.any(String),
-        }),
-      );
-    });
-
-    test("throws when setting both readableAll and writableAll to true", () => {
-      expect(() => {
-        const server = net.createServer(jest.fn());
-        server.listen({
-          path,
-          readableAll: true,
-          writableAll: true,
-        });
-      }).toThrow(
-        expect.objectContaining({
-          message: expect.any(String),
-        }),
-      );
-    });
-  });
-}
-
-//<#END_FILE: test-pipe-abstract-socket.js
diff --git a/test/js/node/test/parallel/pipe-return-val.test.js b/test/js/node/test/parallel/pipe-return-val.test.js
deleted file mode 100644
index 5027349c9c..0000000000
--- a/test/js/node/test/parallel/pipe-return-val.test.js
+++ /dev/null
@@ -1,38 +0,0 @@
-//#FILE: test-pipe-return-val.js
-//#SHA1: 63e55c62d40a6ea0c652d66b609d89f9f5324ea1
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-// This test ensures SourceStream.pipe(DestStream) returns DestStream
-
-const Stream = require("stream").Stream;
-
-test("SourceStream.pipe(DestStream) returns DestStream", () => {
-  const sourceStream = new Stream();
-  const destStream = new Stream();
-  const result = sourceStream.pipe(destStream);
-
-  expect(result).toBe(destStream);
-});
-
-//<#END_FILE: test-pipe-return-val.js
diff --git a/test/js/node/test/parallel/preload-print-process-argv.test.js b/test/js/node/test/parallel/preload-print-process-argv.test.js
deleted file mode 100644
index 9f26ef5044..0000000000
--- a/test/js/node/test/parallel/preload-print-process-argv.test.js
+++ /dev/null
@@ -1,38 +0,0 @@
-//#FILE: test-preload-print-process-argv.js
-//#SHA1: 071fd007af8342d4f1924da004a6dcc7d419cf9f
-//-----------------
-"use strict";
-
-// This tests that process.argv is the same in the preloaded module
-// and the user module.
-
-const tmpdir = require("../common/tmpdir");
-const { spawnSync } = require("child_process");
-const fs = require("fs");
-const path = require("path");
-
-beforeAll(() => {
-  tmpdir.refresh();
-});
-
-test("process.argv is the same in preloaded and user module", () => {
-  const preloadPath = path.join(tmpdir.path, "preload.js");
-  const mainPath = path.join(tmpdir.path, "main.js");
-
-  fs.writeFileSync(preloadPath, "console.log(JSON.stringify(process.argv));", "utf-8");
-
-  fs.writeFileSync(mainPath, "console.log(JSON.stringify(process.argv));", "utf-8");
-
-  const child = spawnSync(process.execPath, ["-r", "./preload.js", "main.js"], { cwd: tmpdir.path });
-
-  expect(child.status).toBe(0);
-
-  if (child.status !== 0) {
-    console.log(child.stderr.toString());
-  }
-
-  const lines = child.stdout.toString().trim().split("\n");
-  expect(JSON.parse(lines[0])).toEqual(JSON.parse(lines[1]));
-});
-
-//<#END_FILE: test-preload-print-process-argv.js
diff --git a/test/js/node/test/parallel/preload-self-referential.test.js b/test/js/node/test/parallel/preload-self-referential.test.js
deleted file mode 100644
index b050248bd6..0000000000
--- a/test/js/node/test/parallel/preload-self-referential.test.js
+++ /dev/null
@@ -1,27 +0,0 @@
-//#FILE: test-preload-self-referential.js
-//#SHA1: 24bb3def0bae68082aee5280abc5116ebd81c972
-//-----------------
-"use strict";
-
-const path = require("path");
-const { exec } = require("child_process");
-
-const nodeBinary = process.argv[0];
-
-// Skip test if not in main thread
-if (typeof Worker !== "undefined") {
-  test.skip("process.chdir is not available in Workers", () => {});
-} else {
-  test("self-referential module preload", done => {
-    const selfRefModule = path.join(__dirname, "..", "fixtures", "self_ref_module");
-    const fixtureA = path.join(__dirname, "..", "fixtures", "printA.js");
-
-    exec(`"${nodeBinary}" -r self_ref "${fixtureA}"`, { cwd: selfRefModule }, (err, stdout, stderr) => {
-      expect(err).toBeFalsy();
-      expect(stdout).toBe("A\n");
-      done();
-    });
-  });
-}
-
-//<#END_FILE: test-preload-self-referential.js
diff --git a/test/js/node/test/parallel/process-abort.test.js b/test/js/node/test/parallel/process-abort.test.js
deleted file mode 100644
index 24731b9cc3..0000000000
--- a/test/js/node/test/parallel/process-abort.test.js
+++ /dev/null
@@ -1,21 +0,0 @@
-//#FILE: test-process-abort.js
-//#SHA1: ca6e85cb79ad3e78182547bd6be24625268aced4
-//-----------------
-"use strict";
-
-// Skip this test in Workers as process.abort() is not available
-if (typeof Worker !== "undefined") {
-  test.skip("process.abort() is not available in Workers", () => {});
-} else {
-  describe("process.abort", () => {
-    test("should not have a prototype", () => {
-      expect(process.abort.prototype).toBeUndefined();
-    });
-
-    test("should throw TypeError when instantiated", () => {
-      expect(() => new process.abort()).toThrow(TypeError);
-    });
-  });
-}
-
-//<#END_FILE: test-process-abort.js
diff --git a/test/js/node/test/parallel/process-argv-0.test.js b/test/js/node/test/parallel/process-argv-0.test.js
deleted file mode 100644
index 7dee3674eb..0000000000
--- a/test/js/node/test/parallel/process-argv-0.test.js
+++ /dev/null
@@ -1,46 +0,0 @@
-//#FILE: test-process-argv-0.js
-//#SHA1: 849d017b5c8496f1927b0618a55a688f4a7aa982
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const path = require("path");
-const { spawn } = require("child_process");
-
-if (process.argv[2] !== "child") {
-  test("process.argv[0] in child process", async () => {
-    const child = spawn(process.execPath, [__filename, "child"], {
-      cwd: path.dirname(process.execPath),
-    });
-
-    let childArgv0 = "";
-    for await (const chunk of child.stdout) {
-      childArgv0 += chunk;
-    }
-
-    expect(childArgv0).toBe(process.execPath);
-  });
-} else {
-  process.stdout.write(process.argv[0]);
-}
-
-//<#END_FILE: test-process-argv-0.js
diff --git a/test/js/node/test/parallel/process-chdir-errormessage.test.js b/test/js/node/test/parallel/process-chdir-errormessage.test.js
deleted file mode 100644
index 3703d4e1b9..0000000000
--- a/test/js/node/test/parallel/process-chdir-errormessage.test.js
+++ /dev/null
@@ -1,26 +0,0 @@
-//#FILE: test-process-chdir-errormessage.js
-//#SHA1: d0eee0a43892b20221d341b892fa425fe207c506
-//-----------------
-"use strict";
-
-// Skip test in workers where process.chdir is not available
-if (typeof Worker !== "undefined") {
-  test.skip("process.chdir is not available in Workers");
-} else {
-  test("process.chdir throws correct error for non-existent directory", () => {
-    expect(() => {
-      process.chdir("does-not-exist");
-    }).toThrow(
-      expect.objectContaining({
-        name: "Error",
-        code: "ENOENT",
-        message: expect.stringMatching(/ENOENT: no such file or directory, chdir .+ -> 'does-not-exist'/),
-        path: process.cwd(),
-        syscall: "chdir",
-        dest: "does-not-exist",
-      }),
-    );
-  });
-}
-
-//<#END_FILE: test-process-chdir-errormessage.js
diff --git a/test/js/node/test/parallel/process-constants-noatime.test.js b/test/js/node/test/parallel/process-constants-noatime.test.js
deleted file mode 100644
index 319d5ff97a..0000000000
--- a/test/js/node/test/parallel/process-constants-noatime.test.js
+++ /dev/null
@@ -1,17 +0,0 @@
-//#FILE: test-process-constants-noatime.js
-//#SHA1: cc1fb622e4cb1e217a3e7a0662db5050dc2562c2
-//-----------------
-"use strict";
-
-const fs = require("fs");
-
-test("O_NOATIME constant", () => {
-  if (process.platform === "linux") {
-    expect(fs.constants).toHaveProperty("O_NOATIME");
-    expect(fs.constants.O_NOATIME).toBe(0x40000);
-  } else {
-    expect(fs.constants).not.toHaveProperty("O_NOATIME");
-  }
-});
-
-//<#END_FILE: test-process-constants-noatime.js
diff --git a/test/js/node/test/parallel/process-emit.test.js b/test/js/node/test/parallel/process-emit.test.js
deleted file mode 100644
index ca5b2c353e..0000000000
--- a/test/js/node/test/parallel/process-emit.test.js
+++ /dev/null
@@ -1,48 +0,0 @@
-//#FILE: test-process-emit.js
-//#SHA1: a019bda4bcc14ef2e20bad3cc89cf8676ed5bc49
-//-----------------
-"use strict";
-
-const sym = Symbol();
-
-test("process.emit for normal event", () => {
-  const listener = jest.fn();
-  process.on("normal", listener);
-
-  process.emit("normal", "normalData");
-
-  expect(listener).toHaveBeenCalledTimes(1);
-  expect(listener).toHaveBeenCalledWith("normalData");
-
-  process.removeListener("normal", listener);
-});
-
-test("process.emit for symbol event", () => {
-  const listener = jest.fn();
-  process.on(sym, listener);
-
-  process.emit(sym, "symbolData");
-
-  expect(listener).toHaveBeenCalledTimes(1);
-  expect(listener).toHaveBeenCalledWith("symbolData");
-
-  process.removeListener(sym, listener);
-});
-
-test("process.emit for SIGPIPE signal", () => {
-  const listener = jest.fn();
-  process.on("SIGPIPE", listener);
-
-  process.emit("SIGPIPE", "signalData");
-
-  expect(listener).toHaveBeenCalledTimes(1);
-  expect(listener).toHaveBeenCalledWith("signalData");
-
-  process.removeListener("SIGPIPE", listener);
-});
-
-test("process._eventsCount is not NaN", () => {
-  expect(Number.isNaN(process._eventsCount)).toBe(false);
-});
-
-//<#END_FILE: test-process-emit.js
diff --git a/test/js/node/test/parallel/process-env-windows-error-reset.test.js b/test/js/node/test/parallel/process-env-windows-error-reset.test.js
deleted file mode 100644
index 57c703c828..0000000000
--- a/test/js/node/test/parallel/process-env-windows-error-reset.test.js
+++ /dev/null
@@ -1,25 +0,0 @@
-//#FILE: test-process-env-windows-error-reset.js
-//#SHA1: f7e32cc8da8c33ecfa3cddeb13d3dd8689d6af64
-//-----------------
-"use strict";
-
-// This checks that after accessing a missing env var, a subsequent
-// env read will succeed even for empty variables.
-
-test("empty env var after accessing missing env var", () => {
-  process.env.FOO = "";
-  process.env.NONEXISTENT_ENV_VAR; // eslint-disable-line no-unused-expressions
-  const foo = process.env.FOO;
-
-  expect(foo).toBe("");
-});
-
-test("env var existence after accessing missing env var", () => {
-  process.env.FOO = "";
-  process.env.NONEXISTENT_ENV_VAR; // eslint-disable-line no-unused-expressions
-  const hasFoo = "FOO" in process.env;
-
-  expect(hasFoo).toBe(true);
-});
-
-//<#END_FILE: test-process-env-windows-error-reset.js
diff --git a/test/js/node/test/parallel/process-exit.test.js b/test/js/node/test/parallel/process-exit.test.js
deleted file mode 100644
index 53ad68de05..0000000000
--- a/test/js/node/test/parallel/process-exit.test.js
+++ /dev/null
@@ -1,46 +0,0 @@
-//#FILE: test-process-exit.js
-//#SHA1: 6b66cdd7fd70fedb0fab288294724b6ffe7df8c9
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-test('Calling .exit() from within "exit" should not overflow the call stack', () => {
-  let nexits = 0;
-
-  const exitHandler = jest.fn(code => {
-    expect(nexits++).toBe(0);
-    expect(code).toBe(0);
-    process.exit();
-  });
-
-  process.on("exit", exitHandler);
-
-  // Simulate process exit
-  process.emit("exit", 0);
-
-  expect(exitHandler).toHaveBeenCalledTimes(1);
-});
-
-// "exit" should be emitted unprovoked
-
-//<#END_FILE: test-process-exit.js
diff --git a/test/js/node/test/parallel/process-features.test.js b/test/js/node/test/parallel/process-features.test.js
deleted file mode 100644
index ee32335bf1..0000000000
--- a/test/js/node/test/parallel/process-features.test.js
+++ /dev/null
@@ -1,18 +0,0 @@
-//#FILE: test-process-features.js
-//#SHA1: 18e2385d3d69890cd826120906ce495a0bc4ba85
-//-----------------
-"use strict";
-
-test("process.features", () => {
-  const keys = new Set(Object.keys(process.features));
-
-  expect(keys).toEqual(
-    new Set(["inspector", "debug", "uv", "ipv6", "tls_alpn", "tls_sni", "tls_ocsp", "tls", "cached_builtins"]),
-  );
-
-  for (const key of keys) {
-    expect(typeof process.features[key]).toBe("boolean");
-  }
-});
-
-//<#END_FILE: test-process-features.js
diff --git a/test/js/node/test/parallel/process-hrtime-bigint.test.js b/test/js/node/test/parallel/process-hrtime-bigint.test.js
deleted file mode 100644
index 3e8aa3d6fb..0000000000
--- a/test/js/node/test/parallel/process-hrtime-bigint.test.js
+++ /dev/null
@@ -1,18 +0,0 @@
-//#FILE: test-process-hrtime-bigint.js
-//#SHA1: 2fbd7286e22ca2f6d3155f829032524692e4d77c
-//-----------------
-"use strict";
-
-// Tests that process.hrtime.bigint() works.
-
-test("process.hrtime.bigint() works", () => {
-  const start = process.hrtime.bigint();
-  expect(typeof start).toBe("bigint");
-
-  const end = process.hrtime.bigint();
-  expect(typeof end).toBe("bigint");
-
-  expect(end - start).toBeGreaterThanOrEqual(0n);
-});
-
-//<#END_FILE: test-process-hrtime-bigint.js
diff --git a/test/js/node/test/parallel/process-initgroups.test.js b/test/js/node/test/parallel/process-initgroups.test.js
deleted file mode 100644
index 8dac517f1e..0000000000
--- a/test/js/node/test/parallel/process-initgroups.test.js
+++ /dev/null
@@ -1,53 +0,0 @@
-//#FILE: test-process-initgroups.js
-//#SHA1: e7321b3005c066a0b2edbe457e695622b9f2b8e9
-//-----------------
-"use strict";
-
-if (process.platform === "win32") {
-  test("process.initgroups is undefined on Windows", () => {
-    expect(process.initgroups).toBeUndefined();
-  });
-} else if (typeof process.initgroups !== "undefined") {
-  describe("process.initgroups", () => {
-    test("throws TypeError for invalid user argument", () => {
-      [undefined, null, true, {}, [], () => {}].forEach(val => {
-        expect(() => {
-          process.initgroups(val);
-        }).toThrow(
-          expect.objectContaining({
-            code: "ERR_INVALID_ARG_TYPE",
-            name: "TypeError",
-            message: expect.stringContaining('The "user" argument must be one of type number or string.'),
-          }),
-        );
-      });
-    });
-
-    test("throws TypeError for invalid extraGroup argument", () => {
-      [undefined, null, true, {}, [], () => {}].forEach(val => {
-        expect(() => {
-          process.initgroups("foo", val);
-        }).toThrow(
-          expect.objectContaining({
-            code: "ERR_INVALID_ARG_TYPE",
-            name: "TypeError",
-            message: expect.stringContaining('The "extraGroup" argument must be one of type number or string.'),
-          }),
-        );
-      });
-    });
-
-    test("throws ERR_UNKNOWN_CREDENTIAL for non-existent group", () => {
-      expect(() => {
-        process.initgroups("fhqwhgadshgnsdhjsdbkhsdabkfabkveyb", "fhqwhgadshgnsdhjsdbkhsdabkfabkveyb");
-      }).toThrow(
-        expect.objectContaining({
-          code: "ERR_UNKNOWN_CREDENTIAL",
-          message: expect.stringContaining("Group identifier does not exist"),
-        }),
-      );
-    });
-  });
-}
-
-//<#END_FILE: test-process-initgroups.js
diff --git a/test/js/node/test/parallel/process-uptime.test.js b/test/js/node/test/parallel/process-uptime.test.js
deleted file mode 100644
index f776e4d2a0..0000000000
--- a/test/js/node/test/parallel/process-uptime.test.js
+++ /dev/null
@@ -1,44 +0,0 @@
-//#FILE: test-process-uptime.js
-//#SHA1: 98140b3c8b495ef62c519ca900eeb15f1ef5b5aa
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-test("process.uptime() returns a reasonable value", () => {
-  console.error(process.uptime());
-  // Add some wiggle room for different platforms.
-  // Verify that the returned value is in seconds -
-  // 15 seconds should be a good estimate.
-  expect(process.uptime()).toBeLessThanOrEqual(15);
-});
-
-test("process.uptime() increases over time", async () => {
-  const original = process.uptime();
-
-  await new Promise(resolve => setTimeout(resolve, 10));
-
-  const uptime = process.uptime();
-  expect(uptime).toBeGreaterThan(original);
-});
-
-//<#END_FILE: test-process-uptime.js
diff --git a/test/js/node/test/parallel/promise-unhandled-issue-43655.test.js b/test/js/node/test/parallel/promise-unhandled-issue-43655.test.js
deleted file mode 100644
index cdaa2e24a9..0000000000
--- a/test/js/node/test/parallel/promise-unhandled-issue-43655.test.js
+++ /dev/null
@@ -1,29 +0,0 @@
-//#FILE: test-promise-unhandled-issue-43655.js
-//#SHA1: d0726f3e05d7aba39fc84013c63399d915956e30
-//-----------------
-"use strict";
-
-function delay(time) {
-  return new Promise(resolve => {
-    setTimeout(resolve, time);
-  });
-}
-
-test("Promise unhandled rejection performance", async () => {
-  for (let i = 0; i < 100000; i++) {
-    await new Promise((resolve, reject) => {
-      reject("value");
-    }).then(
-      () => {},
-      () => {},
-    );
-  }
-
-  const time0 = Date.now();
-  await delay(0);
-
-  const diff = Date.now() - time0;
-  expect(diff).toBeLessThan(500);
-}, 10000); // Increased timeout to 10 seconds to ensure enough time for the test
-
-//<#END_FILE: test-promise-unhandled-issue-43655.js
diff --git a/test/js/node/test/parallel/querystring-maxkeys-non-finite.test.js b/test/js/node/test/parallel/querystring-maxkeys-non-finite.test.js
deleted file mode 100644
index 10116e91b3..0000000000
--- a/test/js/node/test/parallel/querystring-maxkeys-non-finite.test.js
+++ /dev/null
@@ -1,71 +0,0 @@
-//#FILE: test-querystring-maxKeys-non-finite.js
-//#SHA1: a1b76b45daad6e46e5504d52e5931d9e4a6d745d
-//-----------------
-"use strict";
-
-// This test was originally written to test a regression
-// that was introduced by
-// https://github.com/nodejs/node/pull/2288#issuecomment-179543894
-
-const querystring = require("querystring");
-
-// Taken from express-js/body-parser
-// https://github.com/expressjs/body-parser/blob/ed25264fb494cf0c8bc992b8257092cd4f694d5e/test/urlencoded.js#L636-L651
-function createManyParams(count) {
-  let str = "";
-
-  if (count === 0) {
-    return str;
-  }
-
-  str += "0=0";
-
-  for (let i = 1; i < count; i++) {
-    const n = i.toString(36);
-    str += `&${n}=${n}`;
-  }
-
-  return str;
-}
-
-const count = 10000;
-const originalMaxLength = 1000;
-const params = createManyParams(count);
-
-// thealphanerd
-// 27def4f introduced a change to parse that would cause Infinity
-// to be passed to String.prototype.split as an argument for limit
-// In this instance split will always return an empty array
-// this test confirms that the output of parse is the expected length
-// when passed Infinity as the argument for maxKeys
-describe("querystring.parse with non-finite maxKeys", () => {
-  test("Infinity maxKeys should return the length of input", () => {
-    const resultInfinity = querystring.parse(params, undefined, undefined, {
-      maxKeys: Infinity,
-    });
-    expect(Object.keys(resultInfinity)).toHaveLength(count);
-  });
-
-  test("NaN maxKeys should return the length of input", () => {
-    const resultNaN = querystring.parse(params, undefined, undefined, {
-      maxKeys: NaN,
-    });
-    expect(Object.keys(resultNaN)).toHaveLength(count);
-  });
-
-  test('String "Infinity" maxKeys should return the maxLength defined by parse internals', () => {
-    const resultInfinityString = querystring.parse(params, undefined, undefined, {
-      maxKeys: "Infinity",
-    });
-    expect(Object.keys(resultInfinityString)).toHaveLength(originalMaxLength);
-  });
-
-  test('String "NaN" maxKeys should return the maxLength defined by parse internals', () => {
-    const resultNaNString = querystring.parse(params, undefined, undefined, {
-      maxKeys: "NaN",
-    });
-    expect(Object.keys(resultNaNString)).toHaveLength(originalMaxLength);
-  });
-});
-
-//<#END_FILE: test-querystring-maxKeys-non-finite.js
diff --git a/test/js/node/test/parallel/querystring-multichar-separator.test.js b/test/js/node/test/parallel/querystring-multichar-separator.test.js
deleted file mode 100644
index cba18fc69a..0000000000
--- a/test/js/node/test/parallel/querystring-multichar-separator.test.js
+++ /dev/null
@@ -1,32 +0,0 @@
-//#FILE: test-querystring-multichar-separator.js
-//#SHA1: 22b484432502e6f32fc4517ea91060b983c7be25
-//-----------------
-"use strict";
-
-const qs = require("querystring");
-
-function check(actual, expected) {
-  expect(actual).not.toBeInstanceOf(Object);
-  expect(Object.keys(actual).sort()).toEqual(Object.keys(expected).sort());
-  Object.keys(expected).forEach(function (key) {
-    expect(actual[key]).toEqual(expected[key]);
-  });
-}
-
-test("qs.parse with multi-character separator", () => {
-  check(qs.parse("foo=>bar&&bar=>baz", "&&", "=>"), { foo: "bar", bar: "baz" });
-});
-
-test("qs.stringify with multi-character separator", () => {
-  check(qs.stringify({ foo: "bar", bar: "baz" }, "&&", "=>"), "foo=>bar&&bar=>baz");
-});
-
-test("qs.parse with different multi-character separators", () => {
-  check(qs.parse("foo==>bar, bar==>baz", ", ", "==>"), { foo: "bar", bar: "baz" });
-});
-
-test("qs.stringify with different multi-character separators", () => {
-  check(qs.stringify({ foo: "bar", bar: "baz" }, ", ", "==>"), "foo==>bar, bar==>baz");
-});
-
-//<#END_FILE: test-querystring-multichar-separator.js
diff --git a/test/js/node/test/parallel/quic-internal-endpoint-options.test.js b/test/js/node/test/parallel/quic-internal-endpoint-options.test.js
deleted file mode 100644
index 9a5694dcfd..0000000000
--- a/test/js/node/test/parallel/quic-internal-endpoint-options.test.js
+++ /dev/null
@@ -1,192 +0,0 @@
-//#FILE: test-quic-internal-endpoint-options.js
-//#SHA1: 089ba4358a2a9ed3c5463e59d205ee7854f26f30
-//-----------------
-// Flags: --expose-internals
-"use strict";
-
-const common = require("../common");
-if (!common.hasQuic) common.skip("missing quic");
-
-const { internalBinding } = require("internal/test/binding");
-const quic = internalBinding("quic");
-
-quic.setCallbacks({
-  onEndpointClose() {},
-  onSessionNew() {},
-  onSessionClose() {},
-  onSessionDatagram() {},
-  onSessionDatagramStatus() {},
-  onSessionHandshake() {},
-  onSessionPathValidation() {},
-  onSessionTicket() {},
-  onSessionVersionNegotiation() {},
-  onStreamCreated() {},
-  onStreamBlocked() {},
-  onStreamClose() {},
-  onStreamReset() {},
-  onStreamHeaders() {},
-  onStreamTrailers() {},
-});
-
-test("Invalid Endpoint constructor arguments", () => {
-  expect(() => new quic.Endpoint()).toThrow(
-    expect.objectContaining({
-      code: "ERR_INVALID_ARG_TYPE",
-      message: expect.any(String),
-    }),
-  );
-
-  expect(() => new quic.Endpoint("a")).toThrow(
-    expect.objectContaining({
-      code: "ERR_INVALID_ARG_TYPE",
-      message: expect.any(String),
-    }),
-  );
-
-  expect(() => new quic.Endpoint(null)).toThrow(
-    expect.objectContaining({
-      code: "ERR_INVALID_ARG_TYPE",
-      message: expect.any(String),
-    }),
-  );
-
-  expect(() => new quic.Endpoint(false)).toThrow(
-    expect.objectContaining({
-      code: "ERR_INVALID_ARG_TYPE",
-      message: expect.any(String),
-    }),
-  );
-});
-
-test("Default options work", () => {
-  expect(() => new quic.Endpoint({})).not.toThrow();
-});
-
-const cases = [
-  {
-    key: "retryTokenExpiration",
-    valid: [1, 10, 100, 1000, 10000, 10000n],
-    invalid: [-1, -1n, "a", null, false, true, {}, [], () => {}],
-  },
-  {
-    key: "tokenExpiration",
-    valid: [1, 10, 100, 1000, 10000, 10000n],
-    invalid: [-1, -1n, "a", null, false, true, {}, [], () => {}],
-  },
-  {
-    key: "maxConnectionsPerHost",
-    valid: [1, 10, 100, 1000, 10000, 10000n],
-    invalid: [-1, -1n, "a", null, false, true, {}, [], () => {}],
-  },
-  {
-    key: "maxConnectionsTotal",
-    valid: [1, 10, 100, 1000, 10000, 10000n],
-    invalid: [-1, -1n, "a", null, false, true, {}, [], () => {}],
-  },
-  {
-    key: "maxStatelessResetsPerHost",
-    valid: [1, 10, 100, 1000, 10000, 10000n],
-    invalid: [-1, -1n, "a", null, false, true, {}, [], () => {}],
-  },
-  {
-    key: "addressLRUSize",
-    valid: [1, 10, 100, 1000, 10000, 10000n],
-    invalid: [-1, -1n, "a", null, false, true, {}, [], () => {}],
-  },
-  {
-    key: "maxRetries",
-    valid: [1, 10, 100, 1000, 10000, 10000n],
-    invalid: [-1, -1n, "a", null, false, true, {}, [], () => {}],
-  },
-  {
-    key: "maxPayloadSize",
-    valid: [1, 10, 100, 1000, 10000, 10000n],
-    invalid: [-1, -1n, "a", null, false, true, {}, [], () => {}],
-  },
-  {
-    key: "unacknowledgedPacketThreshold",
-    valid: [1, 10, 100, 1000, 10000, 10000n],
-    invalid: [-1, -1n, "a", null, false, true, {}, [], () => {}],
-  },
-  {
-    key: "validateAddress",
-    valid: [true, false, 0, 1, "a"],
-    invalid: [],
-  },
-  {
-    key: "disableStatelessReset",
-    valid: [true, false, 0, 1, "a"],
-    invalid: [],
-  },
-  {
-    key: "ipv6Only",
-    valid: [true, false, 0, 1, "a"],
-    invalid: [],
-  },
-  {
-    key: "cc",
-    valid: [
-      quic.CC_ALGO_RENO,
-      quic.CC_ALGO_CUBIC,
-      quic.CC_ALGO_BBR,
-      quic.CC_ALGO_BBR2,
-      quic.CC_ALGO_RENO_STR,
-      quic.CC_ALGO_CUBIC_STR,
-      quic.CC_ALGO_BBR_STR,
-      quic.CC_ALGO_BBR2_STR,
-    ],
-    invalid: [-1, 4, 1n, "a", null, false, true, {}, [], () => {}],
-  },
-  {
-    key: "udpReceiveBufferSize",
-    valid: [0, 1, 2, 3, 4, 1000],
-    invalid: [-1, "a", null, false, true, {}, [], () => {}],
-  },
-  {
-    key: "udpSendBufferSize",
-    valid: [0, 1, 2, 3, 4, 1000],
-    invalid: [-1, "a", null, false, true, {}, [], () => {}],
-  },
-  {
-    key: "udpTTL",
-    valid: [0, 1, 2, 3, 4, 255],
-    invalid: [-1, 256, "a", null, false, true, {}, [], () => {}],
-  },
-  {
-    key: "resetTokenSecret",
-    valid: [new Uint8Array(16), new Uint16Array(8), new Uint32Array(4)],
-    invalid: ["a", null, false, true, {}, [], () => {}, new Uint8Array(15), new Uint8Array(17), new ArrayBuffer(16)],
-  },
-  {
-    key: "tokenSecret",
-    valid: [new Uint8Array(16), new Uint16Array(8), new Uint32Array(4)],
-    invalid: ["a", null, false, true, {}, [], () => {}, new Uint8Array(15), new Uint8Array(17), new ArrayBuffer(16)],
-  },
-  {
-    // Unknown options are ignored entirely for any value type
-    key: "ignored",
-    valid: ["a", null, false, true, {}, [], () => {}],
-    invalid: [],
-  },
-];
-
-for (const { key, valid, invalid } of cases) {
-  describe(`Endpoint option: ${key}`, () => {
-    test.each(valid)("valid value: %p", value => {
-      const options = { [key]: value };
-      expect(() => new quic.Endpoint(options)).not.toThrow();
-    });
-
-    test.each(invalid)("invalid value: %p", value => {
-      const options = { [key]: value };
-      expect(() => new quic.Endpoint(options)).toThrow(
-        expect.objectContaining({
-          code: "ERR_INVALID_ARG_VALUE",
-          message: expect.any(String),
-        }),
-      );
-    });
-  });
-}
-
-//<#END_FILE: test-quic-internal-endpoint-options.js
diff --git a/test/js/node/test/parallel/readable-large-hwm.test.js b/test/js/node/test/parallel/readable-large-hwm.test.js
deleted file mode 100644
index 2fc8b24615..0000000000
--- a/test/js/node/test/parallel/readable-large-hwm.test.js
+++ /dev/null
@@ -1,35 +0,0 @@
-//#FILE: test-readable-large-hwm.js
-//#SHA1: 1f1184c10e91262eb541830677abcd3e759d304e
-//-----------------
-"use strict";
-const { Readable } = require("stream");
-
-// Make sure that readable completes
-// even when reading larger buffer.
-test("readable completes when reading larger buffer", done => {
-  const bufferSize = 10 * 1024 * 1024;
-  let n = 0;
-  const r = new Readable({
-    read() {
-      // Try to fill readable buffer piece by piece.
-      r.push(Buffer.alloc(bufferSize / 10));
-
-      if (n++ > 10) {
-        r.push(null);
-      }
-    },
-  });
-
-  r.on("readable", () => {
-    while (true) {
-      const ret = r.read(bufferSize);
-      if (ret === null) break;
-    }
-  });
-
-  r.on("end", () => {
-    done();
-  });
-});
-
-//<#END_FILE: test-readable-large-hwm.js
diff --git a/test/js/node/test/parallel/readable-single-end.test.js b/test/js/node/test/parallel/readable-single-end.test.js
deleted file mode 100644
index f8d6813997..0000000000
--- a/test/js/node/test/parallel/readable-single-end.test.js
+++ /dev/null
@@ -1,33 +0,0 @@
-//#FILE: test-readable-single-end.js
-//#SHA1: eb85fac7020fa4b5bc4a0f17ba287e8ab3c9dd2f
-//-----------------
-"use strict";
-
-const { Readable } = require("stream");
-
-// This test ensures that there will not be an additional empty 'readable'
-// event when stream has ended (only 1 event signalling about end)
-
-test("Readable stream emits only one event when ended", () => {
-  const r = new Readable({
-    read: () => {},
-  });
-
-  r.push(null);
-
-  const readableSpy = jest.fn();
-  const endSpy = jest.fn();
-
-  r.on("readable", readableSpy);
-  r.on("end", endSpy);
-
-  return new Promise(resolve => {
-    setTimeout(() => {
-      expect(readableSpy).toHaveBeenCalledTimes(1);
-      expect(endSpy).toHaveBeenCalledTimes(1);
-      resolve();
-    }, 0);
-  });
-});
-
-//<#END_FILE: test-readable-single-end.js
diff --git a/test/js/node/test/parallel/readline-async-iterators-destroy.test.js b/test/js/node/test/parallel/readline-async-iterators-destroy.test.js
deleted file mode 100644
index 1680fec8d8..0000000000
--- a/test/js/node/test/parallel/readline-async-iterators-destroy.test.js
+++ /dev/null
@@ -1,99 +0,0 @@
-//#FILE: test-readline-async-iterators-destroy.js
-//#SHA1: c082e44d93a4bc199683c7cad216da7bc3f0dc7b
-//-----------------
-"use strict";
-
-const fs = require("fs");
-const { once } = require("events");
-const readline = require("readline");
-const path = require("path");
-const os = require("os");
-
-const tmpdir = os.tmpdir();
-
-const filename = path.join(tmpdir, "test.txt");
-
-const testContents = [
-  "",
-  "\n",
-  "line 1",
-  "line 1\nline 2 南越国是前203年至前111年存在于岭南地区的一个国家\nline 3\ntrailing",
-  "line 1\nline 2\nline 3 ends with newline\n",
-];
-
-async function testSimpleDestroy() {
-  for (const fileContent of testContents) {
-    fs.writeFileSync(filename, fileContent);
-
-    const readable = fs.createReadStream(filename);
-    const rli = readline.createInterface({
-      input: readable,
-      crlfDelay: Infinity,
-    });
-
-    const iteratedLines = [];
-    for await (const k of rli) {
-      iteratedLines.push(k);
-      break;
-    }
-
-    const expectedLines = fileContent.split("\n");
-    if (expectedLines[expectedLines.length - 1] === "") {
-      expectedLines.pop();
-    }
-    expectedLines.splice(1);
-
-    expect(iteratedLines).toEqual(expectedLines);
-
-    rli.close();
-    readable.destroy();
-
-    await once(readable, "close");
-  }
-}
-
-async function testMutualDestroy() {
-  for (const fileContent of testContents) {
-    fs.writeFileSync(filename, fileContent);
-
-    const readable = fs.createReadStream(filename);
-    const rli = readline.createInterface({
-      input: readable,
-      crlfDelay: Infinity,
-    });
-
-    const expectedLines = fileContent.split("\n");
-    if (expectedLines[expectedLines.length - 1] === "") {
-      expectedLines.pop();
-    }
-    expectedLines.splice(2);
-
-    const iteratedLines = [];
-    for await (const k of rli) {
-      iteratedLines.push(k);
-      for await (const l of rli) {
-        iteratedLines.push(l);
-        break;
-      }
-      expect(iteratedLines).toEqual(expectedLines);
-      break;
-    }
-
-    expect(iteratedLines).toEqual(expectedLines);
-
-    rli.close();
-    readable.destroy();
-
-    await once(readable, "close");
-  }
-}
-
-test("Simple destroy", async () => {
-  await testSimpleDestroy();
-});
-
-test("Mutual destroy", async () => {
-  await testMutualDestroy();
-});
-
-//<#END_FILE: test-readline-async-iterators-destroy.js
diff --git a/test/js/node/test/parallel/readline-csi.test.js b/test/js/node/test/parallel/readline-csi.test.js
deleted file mode 100644
index e22cdf3b53..0000000000
--- a/test/js/node/test/parallel/readline-csi.test.js
+++ /dev/null
@@ -1,211 +0,0 @@
-//#FILE: test-readline-csi.js
-//#SHA1: 6c80ba1b15c53086d80064d93c6f4cf56d1056d6
-//-----------------
-"use strict";
-
-const readline = require("readline");
-const { Writable } = require("stream");
-
-// Mock the CSI object
-const CSI = {
-  kClearToLineBeginning: "\x1b[1K",
-  kClearToLineEnd: "\x1b[0K",
-  kClearLine: "\x1b[2K",
-  kClearScreenDown: "\x1b[0J",
-};
-
-test("CSI constants", () => {
-  expect(CSI).toBeDefined();
-  expect(CSI.kClearToLineBeginning).toBe("\x1b[1K");
-  expect(CSI.kClearToLineEnd).toBe("\x1b[0K");
-  expect(CSI.kClearLine).toBe("\x1b[2K");
-  expect(CSI.kClearScreenDown).toBe("\x1b[0J");
-});
-
-class TestWritable extends Writable {
-  constructor() {
-    super();
-    this.data = "";
-  }
-  _write(chunk, encoding, callback) {
-    this.data += chunk.toString();
-    callback();
-  }
-}
-
-let writable;
-
-beforeEach(() => {
-  writable = new TestWritable();
-});
-
-test("clearScreenDown", () => {
-  expect(readline.clearScreenDown(writable)).toBe(true);
-  expect(writable.data).toBe(CSI.kClearScreenDown);
-
-  writable.data = "";
-  expect(readline.clearScreenDown(writable, jest.fn())).toBe(true);
-
-  expect(() => {
-    readline.clearScreenDown(writable, null);
-  }).toThrow(
-    expect.objectContaining({
-      name: "TypeError",
-      code: "ERR_INVALID_ARG_TYPE",
-    }),
-  );
-
-  expect(readline.clearScreenDown(null, jest.fn())).toBe(true);
-  expect(readline.clearScreenDown(undefined, jest.fn())).toBe(true);
-});
-
-test("clearLine", () => {
-  expect(readline.clearLine(writable, -1)).toBe(true);
-  expect(writable.data).toBe(CSI.kClearToLineBeginning);
-
-  writable.data = "";
-  expect(readline.clearLine(writable, 1)).toBe(true);
-  expect(writable.data).toBe(CSI.kClearToLineEnd);
-
-  writable.data = "";
-  expect(readline.clearLine(writable, 0)).toBe(true);
-  expect(writable.data).toBe(CSI.kClearLine);
-
-  writable.data = "";
-  expect(readline.clearLine(writable, -1, jest.fn())).toBe(true);
-  expect(writable.data).toBe(CSI.kClearToLineBeginning);
-
-  expect(() => {
-    readline.clearLine(writable, 0, null);
-  }).toThrow(
-    expect.objectContaining({
-      name: "TypeError",
-      code: "ERR_INVALID_ARG_TYPE",
-    }),
-  );
-
-  expect(readline.clearLine(null, 0)).toBe(true);
-  expect(readline.clearLine(undefined, 0)).toBe(true);
-  expect(readline.clearLine(null, 0, jest.fn())).toBe(true);
-  expect(readline.clearLine(undefined, 0, jest.fn())).toBe(true);
-});
-
-test("moveCursor", () => {
-  const testCases = [
-    [0, 0, ""],
-    [1, 0, "\x1b[1C"],
-    [-1, 0, "\x1b[1D"],
-    [0, 1, "\x1b[1B"],
-    [0, -1, "\x1b[1A"],
-    [1, 1, "\x1b[1C\x1b[1B"],
-    [-1, 1, "\x1b[1D\x1b[1B"],
-    [-1, -1, "\x1b[1D\x1b[1A"],
-    [1, -1, "\x1b[1C\x1b[1A"],
-  ];
-
-  testCases.forEach(([dx, dy, expected]) => {
-    writable.data = "";
-    expect(readline.moveCursor(writable, dx, dy)).toBe(true);
-    expect(writable.data).toBe(expected);
-
-    writable.data = "";
-    expect(readline.moveCursor(writable, dx, dy, jest.fn())).toBe(true);
-    expect(writable.data).toBe(expected);
-  });
-
-  expect(() => {
-    readline.moveCursor(writable, 1, 1, null);
-  }).toThrow(
-    expect.objectContaining({
-      name: "TypeError",
-      code: "ERR_INVALID_ARG_TYPE",
-    }),
-  );
-
-  expect(readline.moveCursor(null, 1, 1)).toBe(true);
-  expect(readline.moveCursor(undefined, 1, 1)).toBe(true);
-  expect(readline.moveCursor(null, 1, 1, jest.fn())).toBe(true);
-  expect(readline.moveCursor(undefined, 1, 1, jest.fn())).toBe(true);
-});
-
-test("cursorTo", () => {
-  expect(readline.cursorTo(null)).toBe(true);
-  expect(readline.cursorTo()).toBe(true);
-  expect(readline.cursorTo(null, 1, 1, jest.fn())).toBe(true);
-  expect(readline.cursorTo(undefined, 1, 1, jest.fn())).toBe(true);
-
-  expect(readline.cursorTo(writable, "a")).toBe(true);
-  expect(writable.data).toBe("");
-
-  writable.data = "";
-  expect(readline.cursorTo(writable, "a", "b")).toBe(true);
-  expect(writable.data).toBe("");
-
-  writable.data = "";
-  expect(() => readline.cursorTo(writable, "a", 1)).toThrow(
-    expect.objectContaining({
-      name: "TypeError",
-      code: "ERR_INVALID_CURSOR_POS",
-      message: "Cannot set cursor row without setting its column",
-    }),
-  );
-  expect(writable.data).toBe("");
-
-  writable.data = "";
-  expect(readline.cursorTo(writable, 1, "a")).toBe(true);
-  expect(writable.data).toBe("\x1b[2G");
-
-  writable.data = "";
-  expect(readline.cursorTo(writable, 1)).toBe(true);
-  expect(writable.data).toBe("\x1b[2G");
-
-  writable.data = "";
-  expect(readline.cursorTo(writable, 1, 2)).toBe(true);
-  expect(writable.data).toBe("\x1b[3;2H");
-
-  writable.data = "";
-  expect(readline.cursorTo(writable, 1, 2, jest.fn())).toBe(true);
-  expect(writable.data).toBe("\x1b[3;2H");
-
-  writable.data = "";
-  expect(readline.cursorTo(writable, 1, jest.fn())).toBe(true);
-  expect(writable.data).toBe("\x1b[2G");
-
-  expect(() => {
-    readline.cursorTo(writable, 1, 1, null);
-  }).toThrow(
-    expect.objectContaining({
-      name: "TypeError",
-      code: "ERR_INVALID_ARG_TYPE",
-    }),
-  );
-
-  expect(() => {
-    readline.cursorTo(writable, NaN);
-  }).toThrow(
-    expect.objectContaining({
-      name: "TypeError",
-      code: "ERR_INVALID_ARG_VALUE",
-    }),
-  );
-
-  expect(() => {
-    readline.cursorTo(writable, 1, NaN);
-  }).toThrow(
-    expect.objectContaining({
-      name: "TypeError",
-      code: "ERR_INVALID_ARG_VALUE",
-    }),
-  );
-
-  expect(() => {
-    readline.cursorTo(writable, NaN, NaN);
-  }).toThrow(
-    expect.objectContaining({
-      name: "TypeError",
-      code: "ERR_INVALID_ARG_VALUE",
-    }),
-  );
-});
-
-//<#END_FILE: test-readline-csi.js
diff --git a/test/js/node/test/parallel/readline-emit-keypress-events.test.js b/test/js/node/test/parallel/readline-emit-keypress-events.test.js
deleted file mode 100644
index 34eaeaa63b..0000000000
--- a/test/js/node/test/parallel/readline-emit-keypress-events.test.js
+++ /dev/null
@@ -1,75 +0,0 @@
-//#FILE: test-readline-emit-keypress-events.js
-//#SHA1: 79b97832d1108222b690320e06d4028f73910125
-//-----------------
-"use strict";
-// emitKeypressEvents is thoroughly tested in test-readline-keys.js.
-// However, that test calls it implicitly. This is just a quick sanity check
-// to verify that it works when called explicitly.
-
-const readline = require("readline");
-const { PassThrough } = require("stream");
-
-const expectedSequence = ["f", "o", "o"];
-const expectedKeys = [
-  { sequence: "f", name: "f", ctrl: false, meta: false, shift: false },
-  { sequence: "o", name: "o", ctrl: false, meta: false, shift: false },
-  { sequence: "o", name: "o", ctrl: false, meta: false, shift: false },
-];
-
-test("emitKeypressEvents with stream", () => {
-  const stream = new PassThrough();
-  const sequence = [];
-  const keys = [];
-
-  readline.emitKeypressEvents(stream);
-  stream.on("keypress", (s, k) => {
-    sequence.push(s);
-    keys.push(k);
-  });
-  stream.write("foo");
-
-  expect(sequence).toEqual(expectedSequence);
-  expect(keys).toEqual(expectedKeys);
-});
-
-test("emitKeypressEvents after attaching listener", () => {
-  const stream = new PassThrough();
-  const sequence = [];
-  const keys = [];
-
-  stream.on("keypress", (s, k) => {
-    sequence.push(s);
-    keys.push(k);
-  });
-  readline.emitKeypressEvents(stream);
-  stream.write("foo");
-
-  expect(sequence).toEqual(expectedSequence);
-  expect(keys).toEqual(expectedKeys);
-});
-
-test("emitKeypressEvents with listener removal", () => {
-  const stream = new PassThrough();
-  const sequence = [];
-  const keys = [];
-  const keypressListener = (s, k) => {
-    sequence.push(s);
-    keys.push(k);
-  };
-
-  stream.on("keypress", keypressListener);
-  readline.emitKeypressEvents(stream);
-  stream.removeListener("keypress", keypressListener);
-  stream.write("foo");
-
-  expect(sequence).toEqual([]);
-  expect(keys).toEqual([]);
-
-  stream.on("keypress", keypressListener);
-  stream.write("foo");
-
-  expect(sequence).toEqual(expectedSequence);
-  expect(keys).toEqual(expectedKeys);
-});
-
-//<#END_FILE: test-readline-emit-keypress-events.js
diff --git a/test/js/node/test/parallel/readline-interface-escapecodetimeout.test.js b/test/js/node/test/parallel/readline-interface-escapecodetimeout.test.js
deleted file mode 100644
index c11f399b5a..0000000000
--- a/test/js/node/test/parallel/readline-interface-escapecodetimeout.test.js
+++ /dev/null
@@ -1,47 +0,0 @@
-//#FILE: test-readline-interface-escapecodetimeout.js
-//#SHA1: 6d32b42ce02228999a37e3f7017ddd747b346d5c
-//-----------------
-"use strict";
-
-const readline = require("readline");
-const EventEmitter = require("events").EventEmitter;
-
-// This test ensures that the escapeCodeTimeout option set correctly
-
-class FakeInput extends EventEmitter {
-  resume() {}
-  pause() {}
-  write() {}
-  end() {}
-}
-
-test("escapeCodeTimeout option is set correctly", () => {
-  const fi = new FakeInput();
-  const rli = new readline.Interface({
-    input: fi,
-    output: fi,
-    escapeCodeTimeout: 50,
-  });
-  expect(rli.escapeCodeTimeout).toBe(50);
-  rli.close();
-});
-
-test.each([null, {}, NaN, "50"])("invalid escapeCodeTimeout input throws TypeError", invalidInput => {
-  const fi = new FakeInput();
-  expect(() => {
-    const rli = new readline.Interface({
-      input: fi,
-      output: fi,
-      escapeCodeTimeout: invalidInput,
-    });
-    rli.close();
-  }).toThrow(
-    expect.objectContaining({
-      name: "TypeError",
-      code: "ERR_INVALID_ARG_VALUE",
-      message: expect.any(String),
-    }),
-  );
-});
-
-//<#END_FILE: test-readline-interface-escapecodetimeout.js
diff --git a/test/js/node/test/parallel/readline-position.test.js b/test/js/node/test/parallel/readline-position.test.js
deleted file mode 100644
index 967f5ba830..0000000000
--- a/test/js/node/test/parallel/readline-position.test.js
+++ /dev/null
@@ -1,49 +0,0 @@
-//#FILE: test-readline-position.js
-//#SHA1: 652d50a766a0728968f155ca650ff2ba9f5c32a8
-//-----------------
-"use strict";
-const { PassThrough } = require("stream");
-const readline = require("readline");
-
-const ctrlU = { ctrl: true, name: "u" };
-
-// Skip test if running in a dumb terminal
-const isDumbTerminal = process.env.TERM === "dumb";
-if (isDumbTerminal) {
-  test.skip("Skipping test in dumb terminal", () => {});
-} else {
-  describe("readline position", () => {
-    let input;
-    let rl;
-
-    beforeEach(() => {
-      input = new PassThrough();
-      rl = readline.createInterface({
-        terminal: true,
-        input: input,
-        prompt: "",
-      });
-    });
-
-    afterEach(() => {
-      rl.close();
-    });
-
-    test.each([
-      [1, "a"],
-      [2, "ab"],
-      [2, "丁"],
-      [0, "\u0301"], // COMBINING ACUTE ACCENT
-      [1, "a\u0301"], // á
-      [0, "\u20DD"], // COMBINING ENCLOSING CIRCLE
-      [2, "a\u20DDb"], // a⃝b
-      [0, "\u200E"], // LEFT-TO-RIGHT MARK
-    ])('cursor position for "%s" should be %i', (expectedCursor, string) => {
-      rl.write(string);
-      expect(rl.getCursorPos().cols).toBe(expectedCursor);
-      rl.write(null, ctrlU);
-    });
-  });
-}
-
-//<#END_FILE: test-readline-position.js
diff --git a/test/js/node/test/parallel/readline-reopen.test.js b/test/js/node/test/parallel/readline-reopen.test.js
deleted file mode 100644
index 490034547d..0000000000
--- a/test/js/node/test/parallel/readline-reopen.test.js
+++ /dev/null
@@ -1,61 +0,0 @@
-//#FILE: test-readline-reopen.js
-//#SHA1: 39894fe94eb8e03222c86db2daa35a7b449447eb
-//-----------------
-"use strict";
-
-// Regression test for https://github.com/nodejs/node/issues/13557
-// Tests that multiple subsequent readline instances can re-use an input stream.
-
-const readline = require("readline");
-const { PassThrough } = require("stream");
-
-test("multiple readline instances can re-use an input stream", async () => {
-  const input = new PassThrough();
-  const output = new PassThrough();
-
-  const rl1 = readline.createInterface({
-    input,
-    output,
-    terminal: true,
-  });
-
-  const rl1LinePromise = new Promise(resolve => {
-    rl1.once("line", line => {
-      expect(line).toBe("foo");
-      resolve();
-    });
-  });
-
-  // Write a line plus the first byte of a UTF-8 multibyte character to make sure
-  // that it doesn't get lost when closing the readline instance.
-  input.write(
-    Buffer.concat([
-      Buffer.from("foo\n"),
-      Buffer.from([0xe2]), // Exactly one third of a ☃ snowman.
-    ]),
-  );
-
-  await rl1LinePromise;
-  rl1.close();
-
-  const rl2 = readline.createInterface({
-    input,
-    output,
-    terminal: true,
-  });
-
-  const rl2LinePromise = new Promise(resolve => {
-    rl2.once("line", line => {
-      expect(line).toBe("☃bar");
-      resolve();
-    });
-  });
-
-  input.write(Buffer.from([0x98, 0x83])); // The rest of the ☃ snowman.
-  input.write("bar\n");
-
-  await rl2LinePromise;
-  rl2.close();
-});
-
-//<#END_FILE: test-readline-reopen.js
diff --git a/test/js/node/test/parallel/ref-unref-return.test.js b/test/js/node/test/parallel/ref-unref-return.test.js
deleted file mode 100644
index c17af7034a..0000000000
--- a/test/js/node/test/parallel/ref-unref-return.test.js
+++ /dev/null
@@ -1,18 +0,0 @@
-//#FILE: test-ref-unref-return.js
-//#SHA1: c7275fa0ca17f1cee96244c48f1044ce4d2e67c1
-//-----------------
-"use strict";
-
-const net = require("net");
-const dgram = require("dgram");
-
-test("ref and unref methods return the same instance", () => {
-  expect(new net.Server().ref()).toBeInstanceOf(net.Server);
-  expect(new net.Server().unref()).toBeInstanceOf(net.Server);
-  expect(new net.Socket().ref()).toBeInstanceOf(net.Socket);
-  expect(new net.Socket().unref()).toBeInstanceOf(net.Socket);
-  expect(new dgram.Socket("udp4").ref()).toBeInstanceOf(dgram.Socket);
-  expect(new dgram.Socket("udp6").unref()).toBeInstanceOf(dgram.Socket);
-});
-
-//<#END_FILE: test-ref-unref-return.js
diff --git a/test/js/node/test/parallel/regression-object-prototype.test.js b/test/js/node/test/parallel/regression-object-prototype.test.js
deleted file mode 100644
index aae31cdf28..0000000000
--- a/test/js/node/test/parallel/regression-object-prototype.test.js
+++ /dev/null
@@ -1,43 +0,0 @@
-//#FILE: test-regression-object-prototype.js
-//#SHA1: 198fbbc217f8034fb1b81ce137b6b09a19acd0de
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-/* eslint-disable node-core/require-common-first, node-core/required-modules */
-"use strict";
-
-test("Object prototype modification regression", () => {
-  const consoleSpy = jest.spyOn(console, "log");
-
-  Object.prototype.xadsadsdasasdxx = function () {};
-
-  expect(consoleSpy).not.toHaveBeenCalled();
-
-  console.log("puts after");
-
-  expect(consoleSpy).toHaveBeenCalledWith("puts after");
-  expect(consoleSpy).toHaveBeenCalledTimes(1);
-
-  consoleSpy.mockRestore();
-});
-
-//<#END_FILE: test-regression-object-prototype.js
diff --git a/test/js/node/test/parallel/require-empty-main.test.js b/test/js/node/test/parallel/require-empty-main.test.js
deleted file mode 100644
index 93e53d4aed..0000000000
--- a/test/js/node/test/parallel/require-empty-main.test.js
+++ /dev/null
@@ -1,31 +0,0 @@
-//#FILE: test-require-empty-main.js
-//#SHA1: 1c03cef0482df2bd119e42f418f54123675b532d
-//-----------------
-"use strict";
-
-const path = require("path");
-const fixtures = require("../common/fixtures");
-
-const where = fixtures.path("require-empty-main");
-const expected = path.join(where, "index.js");
-
-const testRequireResolve = () => {
-  expect(require.resolve(where)).toBe(expected);
-  expect(require(where)).toBe(42);
-  expect(require.resolve(where)).toBe(expected);
-};
-
-test('A package.json with an empty "main" property should use index.js if present', testRequireResolve);
-
-test("require.resolve() should resolve to index.js for the same reason", testRequireResolve);
-
-test('Any "main" property that doesn\'t resolve to a file should result in index.js being used', testRequireResolve);
-
-test("Asynchronous test execution", done => {
-  setImmediate(() => {
-    testRequireResolve();
-    done();
-  });
-});
-
-//<#END_FILE: test-require-empty-main.js
diff --git a/test/js/node/test/parallel/require-extensions-main.test.js b/test/js/node/test/parallel/require-extensions-main.test.js
deleted file mode 100644
index 47dee39446..0000000000
--- a/test/js/node/test/parallel/require-extensions-main.test.js
+++ /dev/null
@@ -1,15 +0,0 @@
-//#FILE: test-require-extensions-main.js
-//#SHA1: c3dd50393bbc3eb542e40c67611fc48707ad3cba
-//-----------------
-"use strict";
-
-const path = require("path");
-
-test("require extensions main", () => {
-  const fixturesPath = path.join(__dirname, "..", "fixtures");
-  const fixturesRequire = require(path.join(fixturesPath, "require-bin", "bin", "req.js"));
-
-  expect(fixturesRequire).toBe("");
-});
-
-//<#END_FILE: test-require-extensions-main.js
diff --git a/test/js/node/test/parallel/require-process.test.js b/test/js/node/test/parallel/require-process.test.js
deleted file mode 100644
index b6efc34c07..0000000000
--- a/test/js/node/test/parallel/require-process.test.js
+++ /dev/null
@@ -1,11 +0,0 @@
-//#FILE: test-require-process.js
-//#SHA1: 699b499b3f906d140de0d550c310085aa0791c95
-//-----------------
-"use strict";
-
-test('require("process") should return global process reference', () => {
-  const nativeProcess = require("process");
-  expect(nativeProcess).toBe(process);
-});
-
-//<#END_FILE: test-require-process.js
diff --git a/test/js/node/test/parallel/require-unicode.test.js b/test/js/node/test/parallel/require-unicode.test.js
deleted file mode 100644
index b4fa1f1f01..0000000000
--- a/test/js/node/test/parallel/require-unicode.test.js
+++ /dev/null
@@ -1,23 +0,0 @@
-//#FILE: test-require-unicode.js
-//#SHA1: 3101d8c9e69745baeed9e6f09f32ca9ab31684a8
-//-----------------
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-
-const tmpdir = require("../common/tmpdir");
-
-test("require with unicode path", () => {
-  tmpdir.refresh();
-
-  const dirname = tmpdir.resolve("\u4e2d\u6587\u76ee\u5f55");
-  fs.mkdirSync(dirname);
-  fs.writeFileSync(path.join(dirname, "file.js"), "module.exports = 42;");
-  fs.writeFileSync(path.join(dirname, "package.json"), JSON.stringify({ name: "test", main: "file.js" }));
-
-  expect(require(dirname)).toBe(42);
-  expect(require(path.join(dirname, "file.js"))).toBe(42);
-});
-
-//<#END_FILE: test-require-unicode.js
diff --git a/test/js/node/test/parallel/runner-filter-warning.test.js b/test/js/node/test/parallel/runner-filter-warning.test.js
deleted file mode 100644
index 56e4817871..0000000000
--- a/test/js/node/test/parallel/runner-filter-warning.test.js
+++ /dev/null
@@ -1,32 +0,0 @@
-//#FILE: test-runner-filter-warning.js
-//#SHA1: c0887965f213c569d83684255054bf9e4bc27c29
-//-----------------
-// Flags: --test-only
-"use strict";
-
-const { defaultMaxListeners } = require("node:events");
-
-// Remove the process.on('warning') listener as it's not needed in Jest
-
-for (let i = 0; i < defaultMaxListeners + 1; ++i) {
-  test(`test ${i + 1}`, () => {
-    // Empty test body, just to create the specified number of tests
-  });
-}
-
-// Add a test to ensure no warnings are emitted
-test("no warnings should be emitted", () => {
-  const warningListener = jest.fn();
-  process.on("warning", warningListener);
-
-  // Run all tests
-  return new Promise(resolve => {
-    setTimeout(() => {
-      expect(warningListener).not.toHaveBeenCalled();
-      process.removeListener("warning", warningListener);
-      resolve();
-    }, 100); // Wait a short time to ensure all tests have run
-  });
-});
-
-//<#END_FILE: test-runner-filter-warning.js
diff --git a/test/js/node/test/parallel/runner-root-after-with-refed-handles.test.js b/test/js/node/test/parallel/runner-root-after-with-refed-handles.test.js
deleted file mode 100644
index 7656ca6ca0..0000000000
--- a/test/js/node/test/parallel/runner-root-after-with-refed-handles.test.js
+++ /dev/null
@@ -1,36 +0,0 @@
-//#FILE: test-runner-root-after-with-refed-handles.js
-//#SHA1: cdfe0c601f7139167bfdc5fb5ab39ecf7b403a10
-//-----------------
-"use strict";
-
-const { createServer } = require("node:http");
-
-let server;
-
-beforeAll(() => {
-  return new Promise((resolve, reject) => {
-    server = createServer();
-    server.listen(0, err => {
-      if (err) {
-        reject(err);
-      } else {
-        resolve();
-      }
-    });
-  });
-});
-
-afterAll(() => {
-  return new Promise(resolve => {
-    server.close(() => {
-      resolve();
-    });
-  });
-});
-
-test("placeholder test", () => {
-  // This is a placeholder test to ensure the test suite runs
-  expect(true).toBe(true);
-});
-
-//<#END_FILE: test-runner-root-after-with-refed-handles.js
diff --git a/test/js/node/test/parallel/safe-get-env.test.js b/test/js/node/test/parallel/safe-get-env.test.js
deleted file mode 100644
index 118585eeab..0000000000
--- a/test/js/node/test/parallel/safe-get-env.test.js
+++ /dev/null
@@ -1,44 +0,0 @@
-//#FILE: test-safe-get-env.js
-//#SHA1: 4d2553ac6bc24242b872b748a62aca05ca6fbcc8
-//-----------------
-"use strict";
-
-// This test has been converted to use Jest's API and removed dependencies on internal bindings.
-// The original functionality of testing safeGetenv is preserved by mocking process.env.
-
-describe("safeGetenv", () => {
-  let originalEnv;
-
-  beforeEach(() => {
-    originalEnv = { ...process.env };
-  });
-
-  afterEach(() => {
-    process.env = originalEnv;
-  });
-
-  test("should return the same values as process.env", () => {
-    // Mock some environment variables
-    process.env = {
-      TEST_VAR1: "value1",
-      TEST_VAR2: "value2",
-      TEST_VAR3: "value3",
-    };
-
-    // In a real scenario, we would use the actual safeGetenv function.
-    // For this test, we'll simulate its behavior by directly accessing process.env
-    const safeGetenv = key => process.env[key];
-
-    for (const oneEnv in process.env) {
-      expect(safeGetenv(oneEnv)).toBe(process.env[oneEnv]);
-    }
-  });
-
-  // Note: The following comment is preserved from the original test file
-  // FIXME(joyeecheung): this test is not entirely useful. To properly
-  // test this we could create a mismatch between the effective/real
-  // group/user id of a Node.js process and see if the environment variables
-  // are no longer available - but that might be tricky to set up reliably.
-});
-
-//<#END_FILE: test-safe-get-env.js
diff --git a/test/js/node/test/parallel/sigint-infinite-loop.test.js b/test/js/node/test/parallel/sigint-infinite-loop.test.js
deleted file mode 100644
index 8c511f99d9..0000000000
--- a/test/js/node/test/parallel/sigint-infinite-loop.test.js
+++ /dev/null
@@ -1,40 +0,0 @@
-//#FILE: test-sigint-infinite-loop.js
-//#SHA1: 9c59ace1c99605bce14768e06d62a29e254e6116
-//-----------------
-"use strict";
-// This test is to assert that we can SIGINT a script which loops forever.
-// Ref(http):
-// groups.google.com/group/nodejs-dev/browse_thread/thread/e20f2f8df0296d3f
-const { spawn } = require("child_process");
-
-test("SIGINT can kill an infinite loop", async () => {
-  console.log("start");
-
-  const c = spawn(process.execPath, ["-e", 'while(true) { console.log("hi"); }']);
-
-  let sentKill = false;
-
-  c.stdout.on("data", function (s) {
-    // Prevent race condition:
-    // Wait for the first bit of output from the child process
-    // so that we're sure that it's in the V8 event loop and not
-    // just in the startup phase of execution.
-    if (!sentKill) {
-      c.kill("SIGINT");
-      console.log("SIGINT infinite-loop.js");
-      sentKill = true;
-    }
-  });
-
-  await new Promise(resolve => {
-    c.on("exit", code => {
-      expect(code).not.toBe(0);
-      console.log("killed infinite-loop.js");
-      resolve();
-    });
-  });
-
-  expect(sentKill).toBe(true);
-});
-
-//<#END_FILE: test-sigint-infinite-loop.js
diff --git a/test/js/node/test/parallel/signal-safety.test.js b/test/js/node/test/parallel/signal-safety.test.js
deleted file mode 100644
index 51f6c19fe8..0000000000
--- a/test/js/node/test/parallel/signal-safety.test.js
+++ /dev/null
@@ -1,30 +0,0 @@
-//#FILE: test-signal-safety.js
-//#SHA1: 49090f0605b0ba01c323138ac8e94d423925cbf2
-//-----------------
-"use strict";
-
-test("Signal `this` safety", () => {
-  // We cannot use internal bindings in Jest, so we'll mock the Signal class
-  class Signal {
-    start() {
-      // This method should be called with the correct 'this' context
-      if (!(this instanceof Signal)) {
-        throw new TypeError("Illegal invocation");
-      }
-    }
-  }
-
-  const s = new Signal();
-  const nots = { start: s.start };
-
-  expect(() => {
-    nots.start(9);
-  }).toThrow(
-    expect.objectContaining({
-      name: "TypeError",
-      message: expect.any(String),
-    }),
-  );
-});
-
-//<#END_FILE: test-signal-safety.js
diff --git a/test/js/node/test/parallel/signal-unregister.test.js b/test/js/node/test/parallel/signal-unregister.test.js
deleted file mode 100644
index 0f7b55ce66..0000000000
--- a/test/js/node/test/parallel/signal-unregister.test.js
+++ /dev/null
@@ -1,27 +0,0 @@
-//#FILE: test-signal-unregister.js
-//#SHA1: 44f7b12e1cb3d5e2bc94cb244f52d5a6a591d8f4
-//-----------------
-"use strict";
-
-const { spawn } = require("child_process");
-const path = require("path");
-
-const fixturesPath = path.resolve(__dirname, "..", "fixtures");
-
-test("Child process exits on SIGINT", () => {
-  const child = spawn(process.argv[0], [path.join(fixturesPath, "should_exit.js")]);
-
-  return new Promise(resolve => {
-    child.stdout.once("data", () => {
-      child.kill("SIGINT");
-    });
-
-    child.on("exit", (exitCode, signalCode) => {
-      expect(exitCode).toBeNull();
-      expect(signalCode).toBe("SIGINT");
-      resolve();
-    });
-  });
-});
-
-//<#END_FILE: test-signal-unregister.js
diff --git a/test/js/node/test/parallel/stdin-from-file-spawn.test.js b/test/js/node/test/parallel/stdin-from-file-spawn.test.js
deleted file mode 100644
index aad7445891..0000000000
--- a/test/js/node/test/parallel/stdin-from-file-spawn.test.js
+++ /dev/null
@@ -1,60 +0,0 @@
-//#FILE: test-stdin-from-file-spawn.js
-//#SHA1: 1f8f432985d08b841ebb2c8142b865ae417737a1
-//-----------------
-"use strict";
-
-const process = require("process");
-const { execSync } = require("child_process");
-const fs = require("fs");
-const path = require("path");
-const os = require("os");
-
-let defaultShell;
-if (process.platform === "linux" || process.platform === "darwin") {
-  defaultShell = "/bin/sh";
-} else if (process.platform === "win32") {
-  defaultShell = "cmd.exe";
-} else {
-  it.skip("This test exists only on Linux/Win32/OSX", () => {});
-}
-
-if (defaultShell) {
-  test("stdin from file spawn", () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "test-"));
-    const tmpCmdFile = path.join(tmpDir, "test-stdin-from-file-spawn-cmd");
-    const tmpJsFile = path.join(tmpDir, "test-stdin-from-file-spawn.js");
-
-    fs.writeFileSync(tmpCmdFile, "echo hello");
-    fs.writeFileSync(
-      tmpJsFile,
-      `
-    'use strict';
-    const { spawn } = require('child_process');
-    // Reference the object to invoke the getter
-    process.stdin;
-    setTimeout(() => {
-      let ok = false;
-      const child = spawn(process.env.SHELL || '${defaultShell}',
-        [], { stdio: ['inherit', 'pipe'] });
-      child.stdout.on('data', () => {
-        ok = true;
-      });
-      child.on('close', () => {
-        process.exit(ok ? 0 : -1);
-      });
-    }, 100);
-    `,
-    );
-
-    expect(() => {
-      execSync(`${process.argv[0]} ${tmpJsFile} < ${tmpCmdFile}`);
-    }).not.toThrow();
-
-    // Clean up
-    fs.unlinkSync(tmpCmdFile);
-    fs.unlinkSync(tmpJsFile);
-    fs.rmdirSync(tmpDir);
-  });
-}
-
-//<#END_FILE: test-stdin-from-file-spawn.js
diff --git a/test/js/node/test/parallel/stdin-hang.test.js b/test/js/node/test/parallel/stdin-hang.test.js
deleted file mode 100644
index b9f9dd71a9..0000000000
--- a/test/js/node/test/parallel/stdin-hang.test.js
+++ /dev/null
@@ -1,49 +0,0 @@
-//#FILE: test-stdin-hang.js
-//#SHA1: f28512893c8d9cd6500247aa87881347638eb616
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-// This test *only* verifies that invoking the stdin getter does not
-// cause node to hang indefinitely.
-// If it does, then the test-runner will nuke it.
-
-test("process.stdin getter does not cause indefinite hang", () => {
-  // invoke the getter.
-  process.stdin; // eslint-disable-line no-unused-expressions
-
-  // If we reach this point, it means the process didn't hang
-  expect(true).toBe(true);
-});
-
-test("Console output", () => {
-  const consoleErrorSpy = jest.spyOn(console, "error").mockImplementation(() => {});
-
-  console.error("Should exit normally now.");
-
-  expect(consoleErrorSpy).toHaveBeenCalledWith("Should exit normally now.");
-
-  consoleErrorSpy.mockRestore();
-});
-
-//<#END_FILE: test-stdin-hang.js
diff --git a/test/js/node/test/parallel/stdin-pause-resume-sync.test.js b/test/js/node/test/parallel/stdin-pause-resume-sync.test.js
deleted file mode 100644
index ed69ac4afe..0000000000
--- a/test/js/node/test/parallel/stdin-pause-resume-sync.test.js
+++ /dev/null
@@ -1,59 +0,0 @@
-//#FILE: test-stdin-pause-resume-sync.js
-//#SHA1: 2256a91336e221a1770b59ebebb4afb406a770dd
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-test("stdin pause and resume", () => {
-  const consoleSpy = jest.spyOn(console, "error");
-  const stdinResumeSpy = jest.spyOn(process.stdin, "resume");
-  const stdinPauseSpy = jest.spyOn(process.stdin, "pause");
-
-  console.error("before opening stdin");
-  process.stdin.resume();
-  console.error("stdin opened");
-  console.error("pausing stdin");
-  process.stdin.pause();
-  console.error("opening again");
-  process.stdin.resume();
-  console.error("pausing again");
-  process.stdin.pause();
-  console.error("should exit now");
-
-  expect(consoleSpy).toHaveBeenCalledTimes(6);
-  expect(consoleSpy).toHaveBeenNthCalledWith(1, "before opening stdin");
-  expect(consoleSpy).toHaveBeenNthCalledWith(2, "stdin opened");
-  expect(consoleSpy).toHaveBeenNthCalledWith(3, "pausing stdin");
-  expect(consoleSpy).toHaveBeenNthCalledWith(4, "opening again");
-  expect(consoleSpy).toHaveBeenNthCalledWith(5, "pausing again");
-  expect(consoleSpy).toHaveBeenNthCalledWith(6, "should exit now");
-
-  expect(stdinResumeSpy).toHaveBeenCalledTimes(2);
-  expect(stdinPauseSpy).toHaveBeenCalledTimes(2);
-
-  consoleSpy.mockRestore();
-  stdinResumeSpy.mockRestore();
-  stdinPauseSpy.mockRestore();
-});
-
-//<#END_FILE: test-stdin-pause-resume-sync.js
diff --git a/test/js/node/test/parallel/stdin-pause-resume.test.js b/test/js/node/test/parallel/stdin-pause-resume.test.js
deleted file mode 100644
index f172615922..0000000000
--- a/test/js/node/test/parallel/stdin-pause-resume.test.js
+++ /dev/null
@@ -1,68 +0,0 @@
-//#FILE: test-stdin-pause-resume.js
-//#SHA1: 941cff7d9e52f178538b4fdd09458bb2fc6a12b7
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-test("stdin pause and resume", async () => {
-  const consoleSpy = jest.spyOn(console, "error");
-  const stdinResumeSpy = jest.spyOn(process.stdin, "resume");
-  const stdinPauseSpy = jest.spyOn(process.stdin, "pause");
-
-  console.error("before opening stdin");
-  process.stdin.resume();
-  console.error("stdin opened");
-
-  await new Promise(resolve => setTimeout(resolve, 1));
-
-  console.error("pausing stdin");
-  process.stdin.pause();
-
-  await new Promise(resolve => setTimeout(resolve, 1));
-
-  console.error("opening again");
-  process.stdin.resume();
-
-  await new Promise(resolve => setTimeout(resolve, 1));
-
-  console.error("pausing again");
-  process.stdin.pause();
-  console.error("should exit now");
-
-  expect(consoleSpy).toHaveBeenCalledTimes(6);
-  expect(consoleSpy).toHaveBeenNthCalledWith(1, "before opening stdin");
-  expect(consoleSpy).toHaveBeenNthCalledWith(2, "stdin opened");
-  expect(consoleSpy).toHaveBeenNthCalledWith(3, "pausing stdin");
-  expect(consoleSpy).toHaveBeenNthCalledWith(4, "opening again");
-  expect(consoleSpy).toHaveBeenNthCalledWith(5, "pausing again");
-  expect(consoleSpy).toHaveBeenNthCalledWith(6, "should exit now");
-
-  expect(stdinResumeSpy).toHaveBeenCalledTimes(2);
-  expect(stdinPauseSpy).toHaveBeenCalledTimes(2);
-
-  consoleSpy.mockRestore();
-  stdinResumeSpy.mockRestore();
-  stdinPauseSpy.mockRestore();
-});
-
-//<#END_FILE: test-stdin-pause-resume.js
diff --git a/test/js/node/test/parallel/stdin-pipe-resume.test.js b/test/js/node/test/parallel/stdin-pipe-resume.test.js
deleted file mode 100644
index 7a38ca23c3..0000000000
--- a/test/js/node/test/parallel/stdin-pipe-resume.test.js
+++ /dev/null
@@ -1,38 +0,0 @@
-//#FILE: test-stdin-pipe-resume.js
-//#SHA1: 6775f16e6a971590e3a5308d4e3678029be47411
-//-----------------
-"use strict";
-
-// This tests that piping stdin will cause it to resume() as well.
-
-const { spawn } = require("child_process");
-
-if (process.argv[2] === "child") {
-  process.stdin.pipe(process.stdout);
-} else {
-  test("piping stdin causes it to resume", done => {
-    const buffers = [];
-    const child = spawn(process.execPath, [__filename, "child"]);
-
-    child.stdout.on("data", c => {
-      buffers.push(c);
-    });
-
-    child.stdout.on("close", () => {
-      const b = Buffer.concat(buffers).toString();
-      expect(b).toBe("Hello, world\n");
-      done();
-    });
-
-    child.stdin.write("Hel");
-    child.stdin.write("lo,");
-    child.stdin.write(" wo");
-
-    setTimeout(() => {
-      child.stdin.write("rld\n");
-      child.stdin.end();
-    }, 10);
-  });
-}
-
-//<#END_FILE: test-stdin-pipe-resume.js
diff --git a/test/js/node/test/parallel/stdin-resume-pause.test.js b/test/js/node/test/parallel/stdin-resume-pause.test.js
deleted file mode 100644
index b455110d35..0000000000
--- a/test/js/node/test/parallel/stdin-resume-pause.test.js
+++ /dev/null
@@ -1,48 +0,0 @@
-//#FILE: test-stdin-resume-pause.js
-//#SHA1: ef96cec1b4e29ec6b96da37fd44e3bbdb50e1393
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-test("process.stdin can be resumed and paused", () => {
-  const originalResume = process.stdin.resume;
-  const originalPause = process.stdin.pause;
-
-  const mockResume = jest.fn();
-  const mockPause = jest.fn();
-
-  process.stdin.resume = mockResume;
-  process.stdin.pause = mockPause;
-
-  process.stdin.resume();
-  process.stdin.pause();
-
-  expect(mockResume).toHaveBeenCalledTimes(1);
-  expect(mockPause).toHaveBeenCalledTimes(1);
-
-  // Restore original methods
-  process.stdin.resume = originalResume;
-  process.stdin.pause = originalPause;
-});
-
-//<#END_FILE: test-stdin-resume-pause.js
diff --git a/test/js/node/test/parallel/stdin-script-child-option.test.js b/test/js/node/test/parallel/stdin-script-child-option.test.js
deleted file mode 100644
index 3dc4f26ce6..0000000000
--- a/test/js/node/test/parallel/stdin-script-child-option.test.js
+++ /dev/null
@@ -1,23 +0,0 @@
-//#FILE: test-stdin-script-child-option.js
-//#SHA1: 80d38c88249e1ceb4ef9b029e6910c91dd08ccc5
-//-----------------
-"use strict";
-
-const { spawn } = require("child_process");
-
-test("child process receives option from command line", done => {
-  const expected = "--option-to-be-seen-on-child";
-  const child = spawn(process.execPath, ["-", expected], { stdio: "pipe" });
-
-  child.stdin.end("console.log(process.argv[2])");
-
-  let actual = "";
-  child.stdout.setEncoding("utf8");
-  child.stdout.on("data", chunk => (actual += chunk));
-  child.stdout.on("end", () => {
-    expect(actual.trim()).toBe(expected);
-    done();
-  });
-});
-
-//<#END_FILE: test-stdin-script-child-option.js
diff --git a/test/js/node/test/parallel/stdio-pipe-access.test.js b/test/js/node/test/parallel/stdio-pipe-access.test.js
deleted file mode 100644
index 026d7ae891..0000000000
--- a/test/js/node/test/parallel/stdio-pipe-access.test.js
+++ /dev/null
@@ -1,40 +0,0 @@
-//#FILE: test-stdio-pipe-access.js
-//#SHA1: a1f6e6c04c96ad54cbbd4270958bcb2934a3ce6b
-//-----------------
-"use strict";
-
-// Test if Node handles accessing process.stdin if it is a redirected
-// pipe without deadlocking
-const { spawn, spawnSync } = require("child_process");
-
-const numTries = 5;
-const who = process.argv.length <= 2 ? "runner" : process.argv[2];
-
-// Skip test for Workers as they don't have process-like stdio
-if (typeof Worker !== "undefined") {
-  test.skip("Workers don't have process-like stdio", () => {});
-} else {
-  test("stdio pipe access", () => {
-    switch (who) {
-      case "runner":
-        for (let num = 0; num < numTries; ++num) {
-          const result = spawnSync(process.argv0, [process.argv[1], "parent"], { stdio: "inherit" });
-          expect(result.status).toBe(0);
-        }
-        break;
-      case "parent": {
-        const middle = spawn(process.argv0, [process.argv[1], "middle"], { stdio: "pipe" });
-        middle.stdout.on("data", () => {});
-        break;
-      }
-      case "middle":
-        spawn(process.argv0, [process.argv[1], "bottom"], { stdio: [process.stdin, process.stdout, process.stderr] });
-        break;
-      case "bottom":
-        process.stdin; // eslint-disable-line no-unused-expressions
-        break;
-    }
-  });
-}
-
-//<#END_FILE: test-stdio-pipe-access.js
diff --git a/test/js/node/test/parallel/stdio-pipe-stderr.test.js b/test/js/node/test/parallel/stdio-pipe-stderr.test.js
deleted file mode 100644
index eaae7ef20c..0000000000
--- a/test/js/node/test/parallel/stdio-pipe-stderr.test.js
+++ /dev/null
@@ -1,54 +0,0 @@
-//#FILE: test-stdio-pipe-stderr.js
-//#SHA1: 5a30748a31ac72c12cd7438b96a8e09c7c8f07f7
-//-----------------
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-const { spawnSync } = require("child_process");
-
-// Test that invoking node with require, and piping stderr to file,
-// does not result in exception,
-// see: https://github.com/nodejs/node/issues/11257
-
-describe("stdio pipe stderr", () => {
-  const tmpdir = path.join(__dirname, "tmp");
-  const fakeModulePath = path.join(tmpdir, "batman.js");
-  const stderrOutputPath = path.join(tmpdir, "stderr-output.txt");
-
-  beforeAll(() => {
-    if (!fs.existsSync(tmpdir)) {
-      fs.mkdirSync(tmpdir, { recursive: true });
-    }
-  });
-
-  afterAll(() => {
-    fs.rmSync(tmpdir, { recursive: true, force: true });
-  });
-
-  test("piping stderr to file should not result in exception", done => {
-    // We need to redirect stderr to a file to produce #11257
-    const stream = fs.createWriteStream(stderrOutputPath);
-
-    // The error described in #11257 only happens when we require a
-    // non-built-in module.
-    fs.writeFileSync(fakeModulePath, "", "utf8");
-
-    stream.on("open", () => {
-      spawnSync(process.execPath, {
-        input: `require(${JSON.stringify(fakeModulePath)})`,
-        stdio: ["pipe", "pipe", stream],
-      });
-
-      const stderr = fs.readFileSync(stderrOutputPath, "utf8").trim();
-      expect(stderr).toBe("");
-
-      stream.end();
-      fs.unlinkSync(stderrOutputPath);
-      fs.unlinkSync(fakeModulePath);
-      done();
-    });
-  });
-});
-
-//<#END_FILE: test-stdio-pipe-stderr.js
diff --git a/test/js/node/test/parallel/stdout-cannot-be-closed-child-process-pipe.test.js b/test/js/node/test/parallel/stdout-cannot-be-closed-child-process-pipe.test.js
deleted file mode 100644
index 1626f01a67..0000000000
--- a/test/js/node/test/parallel/stdout-cannot-be-closed-child-process-pipe.test.js
+++ /dev/null
@@ -1,36 +0,0 @@
-//#FILE: test-stdout-cannot-be-closed-child-process-pipe.js
-//#SHA1: 405380c20ca8313c3f58109a4928d90eae9b79b9
-//-----------------
-"use strict";
-
-const { spawn } = require("child_process");
-
-if (process.argv[2] === "child") {
-  process.stdout.end("foo");
-} else {
-  test("stdout cannot be closed in child process pipe", done => {
-    const child = spawn(process.execPath, [__filename, "child"]);
-    let out = "";
-    let err = "";
-
-    child.stdout.setEncoding("utf8");
-    child.stderr.setEncoding("utf8");
-
-    child.stdout.on("data", c => {
-      out += c;
-    });
-    child.stderr.on("data", c => {
-      err += c;
-    });
-
-    child.on("close", (code, signal) => {
-      expect(code).toBe(0);
-      expect(err).toBe("");
-      expect(out).toBe("foo");
-      console.log("ok");
-      done();
-    });
-  });
-}
-
-//<#END_FILE: test-stdout-cannot-be-closed-child-process-pipe.js
diff --git a/test/js/node/test/parallel/stdout-stderr-write.test.js b/test/js/node/test/parallel/stdout-stderr-write.test.js
deleted file mode 100644
index 3ee9dba103..0000000000
--- a/test/js/node/test/parallel/stdout-stderr-write.test.js
+++ /dev/null
@@ -1,13 +0,0 @@
-//#FILE: test-stdout-stderr-write.js
-//#SHA1: 8811b3e776c91c3300ee6eb32b7d1ccb4d3d5d6a
-//-----------------
-"use strict";
-
-// This test checks if process.stderr.write() and process.stdout.write() return true
-
-test("process.stderr.write() and process.stdout.write() return true", () => {
-  expect(process.stderr.write("asd")).toBe(true);
-  expect(process.stdout.write("asd")).toBe(true);
-});
-
-//<#END_FILE: test-stdout-stderr-write.js
diff --git a/test/js/node/test/parallel/stream-add-abort-signal.test.js b/test/js/node/test/parallel/stream-add-abort-signal.test.js
deleted file mode 100644
index 1a704c5d5b..0000000000
--- a/test/js/node/test/parallel/stream-add-abort-signal.test.js
+++ /dev/null
@@ -1,46 +0,0 @@
-//#FILE: test-stream-add-abort-signal.js
-//#SHA1: 8caf14dd370aac5a01fad14026a78e1994dd3e4e
-//-----------------
-"use strict";
-
-const { addAbortSignal, Readable } = require("stream");
-
-describe("addAbortSignal", () => {
-  test("throws error for invalid signal", () => {
-    expect(() => {
-      addAbortSignal("INVALID_SIGNAL");
-    }).toThrow(
-      expect.objectContaining({
-        code: "ERR_INVALID_ARG_TYPE",
-        message: expect.any(String),
-      }),
-    );
-  });
-
-  test("throws error for invalid stream", () => {
-    const ac = new AbortController();
-    expect(() => {
-      addAbortSignal(ac.signal, "INVALID_STREAM");
-    }).toThrow(
-      expect.objectContaining({
-        code: "ERR_INVALID_ARG_TYPE",
-        message: expect.any(String),
-      }),
-    );
-  });
-});
-
-describe("addAbortSignalNoValidate", () => {
-  test("returns the same readable stream", () => {
-    const r = new Readable({
-      read: () => {},
-    });
-
-    // Since addAbortSignalNoValidate is an internal function,
-    // we'll skip this test in the Jest version.
-    // In a real-world scenario, we'd need to mock or implement this function.
-    expect(true).toBe(true);
-  });
-});
-
-//<#END_FILE: test-stream-add-abort-signal.js
diff --git a/test/js/node/test/parallel/stream-base-prototype-accessors-enumerability.test.js b/test/js/node/test/parallel/stream-base-prototype-accessors-enumerability.test.js
deleted file mode 100644
index d1776dd952..0000000000
--- a/test/js/node/test/parallel/stream-base-prototype-accessors-enumerability.test.js
+++ /dev/null
@@ -1,20 +0,0 @@
-//#FILE: test-stream-base-prototype-accessors-enumerability.js
-//#SHA1: a5423c2b42bae0fbdd1530553de4d40143c010cf
-//-----------------
-"use strict";
-
-// This tests that the prototype accessors added by StreamBase::AddMethods
-// are not enumerable. They could be enumerated when inspecting the prototype
-// with util.inspect or the inspector protocol.
-
-// Or anything that calls StreamBase::AddMethods when setting up its prototype
-const TTY = process.binding("tty_wrap").TTY;
-
-test("StreamBase prototype accessors are not enumerable", () => {
-  const ttyIsEnumerable = Object.prototype.propertyIsEnumerable.bind(TTY);
-  expect(ttyIsEnumerable("bytesRead")).toBe(false);
-  expect(ttyIsEnumerable("fd")).toBe(false);
-  expect(ttyIsEnumerable("_externalStream")).toBe(false);
-});
-
-//<#END_FILE: test-stream-base-prototype-accessors-enumerability.js
diff --git a/test/js/node/test/parallel/stream-big-packet.test.js b/test/js/node/test/parallel/stream-big-packet.test.js
deleted file mode 100644
index 01b34975c9..0000000000
--- a/test/js/node/test/parallel/stream-big-packet.test.js
+++ /dev/null
@@ -1,73 +0,0 @@
-//#FILE: test-stream-big-packet.js
-//#SHA1: ce0f56afc4946041321028a7128eca47765fd53d
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const stream = require("stream");
-
-let passed = false;
-
-class TestStream extends stream.Transform {
-  _transform(chunk, encoding, done) {
-    if (!passed) {
-      // Char 'a' only exists in the last write
-      passed = chunk.toString().includes("a");
-    }
-    done();
-  }
-}
-
-test("Large buffer is handled properly by Writable Stream", done => {
-  const s1 = new stream.Transform({
-    transform(chunk, encoding, cb) {
-      process.nextTick(cb, null, chunk);
-    },
-  });
-  const s2 = new stream.PassThrough();
-  const s3 = new TestStream();
-  s1.pipe(s3);
-  // Don't let s2 auto close which may close s3
-  s2.pipe(s3, { end: false });
-
-  // We must write a buffer larger than highWaterMark
-  const big = Buffer.alloc(s1.writableHighWaterMark + 1, "x");
-
-  // Since big is larger than highWaterMark, it will be buffered internally.
-  expect(s1.write(big)).toBe(false);
-  // 'tiny' is small enough to pass through internal buffer.
-  expect(s2.write("tiny")).toBe(true);
-
-  // Write some small data in next IO loop, which will never be written to s3
-  // Because 'drain' event is not emitted from s1 and s1 is still paused
-  setImmediate(s1.write.bind(s1), "later");
-
-  // Assert after two IO loops when all operations have been done.
-  setImmediate(() => {
-    setImmediate(() => {
-      expect(passed).toBe(true);
-      done();
-    });
-  });
-});
-
-//<#END_FILE: test-stream-big-packet.js
diff --git a/test/js/node/test/parallel/stream-big-push.test.js b/test/js/node/test/parallel/stream-big-push.test.js
deleted file mode 100644
index 664dc59bea..0000000000
--- a/test/js/node/test/parallel/stream-big-push.test.js
+++ /dev/null
@@ -1,87 +0,0 @@
-//#FILE: test-stream-big-push.js
-//#SHA1: 833718bae7463fa469ed5acc9a1c69aa321785b7
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const stream = require("stream");
-const str = "asdfasdfasdfasdfasdf";
-
-test("stream big push", async () => {
-  const r = new stream.Readable({
-    highWaterMark: 5,
-    encoding: "utf8",
-  });
-
-  let reads = 0;
-
-  function _read() {
-    if (reads === 0) {
-      setTimeout(() => {
-        r.push(str);
-      }, 1);
-      reads++;
-    } else if (reads === 1) {
-      const ret = r.push(str);
-      expect(ret).toBe(false);
-      reads++;
-    } else {
-      r.push(null);
-    }
-  }
-
-  r._read = jest.fn(_read);
-
-  const endPromise = new Promise(resolve => {
-    r.on("end", resolve);
-  });
-
-  // Push some data in to start.
-  // We've never gotten any read event at this point.
-  const ret = r.push(str);
-  // Should be false.  > hwm
-  expect(ret).toBe(false);
-  let chunk = r.read();
-  expect(chunk).toBe(str);
-  chunk = r.read();
-  expect(chunk).toBeNull();
-
-  await new Promise(resolve => {
-    r.once("readable", () => {
-      // This time, we'll get *all* the remaining data, because
-      // it's been added synchronously, as the read WOULD take
-      // us below the hwm, and so it triggered a _read() again,
-      // which synchronously added more, which we then return.
-      chunk = r.read();
-      expect(chunk).toBe(str + str);
-
-      chunk = r.read();
-      expect(chunk).toBeNull();
-      resolve();
-    });
-  });
-
-  await endPromise;
-  expect(r._read).toHaveBeenCalledTimes(3);
-});
-
-//<#END_FILE: test-stream-big-push.js
diff --git a/test/js/node/test/parallel/stream-decoder-objectmode.test.js b/test/js/node/test/parallel/stream-decoder-objectmode.test.js
deleted file mode 100644
index a78775aa5d..0000000000
--- a/test/js/node/test/parallel/stream-decoder-objectmode.test.js
+++ /dev/null
@@ -1,25 +0,0 @@
-//#FILE: test-stream-decoder-objectmode.js
-//#SHA1: 373c0c494e625b8264fae296b46f16a5cd5a9ef8
-//-----------------
-"use strict";
-
-const stream = require("stream");
-
-test("stream.Readable with objectMode and utf16le encoding", () => {
-  const readable = new stream.Readable({
-    read: () => {},
-    encoding: "utf16le",
-    objectMode: true,
-  });
-
-  readable.push(Buffer.from("abc", "utf16le"));
-  readable.push(Buffer.from("def", "utf16le"));
-  readable.push(null);
-
-  // Without object mode, these would be concatenated into a single chunk.
-  expect(readable.read()).toBe("abc");
-  expect(readable.read()).toBe("def");
-  expect(readable.read()).toBeNull();
-});
-
-//<#END_FILE: test-stream-decoder-objectmode.js
diff --git a/test/js/node/test/parallel/stream-destroy-event-order.test.js b/test/js/node/test/parallel/stream-destroy-event-order.test.js
deleted file mode 100644
index 480b80267d..0000000000
--- a/test/js/node/test/parallel/stream-destroy-event-order.test.js
+++ /dev/null
@@ -1,37 +0,0 @@
-//#FILE: test-stream-destroy-event-order.js
-//#SHA1: 0d5e12d85e093a1d7c118a2e15cf0c38c1ab96f6
-//-----------------
-"use strict";
-
-const { Readable } = require("stream");
-
-test("Readable stream destroy event order", () => {
-  const rs = new Readable({
-    read() {},
-  });
-
-  let closed = false;
-  let errored = false;
-
-  rs.on("close", () => {
-    closed = true;
-    expect(errored).toBe(true);
-  });
-
-  rs.on("error", () => {
-    errored = true;
-    expect(closed).toBe(false);
-  });
-
-  rs.destroy(new Error("kaboom"));
-
-  return new Promise(resolve => {
-    rs.on("close", () => {
-      expect(closed).toBe(true);
-      expect(errored).toBe(true);
-      resolve();
-    });
-  });
-});
-
-//<#END_FILE: test-stream-destroy-event-order.js
diff --git a/test/js/node/test/parallel/stream-duplex-props.test.js b/test/js/node/test/parallel/stream-duplex-props.test.js
deleted file mode 100644
index 8fbc7f3cff..0000000000
--- a/test/js/node/test/parallel/stream-duplex-props.test.js
+++ /dev/null
@@ -1,34 +0,0 @@
-//#FILE: test-stream-duplex-props.js
-//#SHA1: ae1e09a8b6631f457ad8587544a2a245f3c2ef04
-//-----------------
-"use strict";
-
-const { Duplex } = require("stream");
-
-test("Duplex stream with same object mode and high water mark for readable and writable", () => {
-  const d = new Duplex({
-    objectMode: true,
-    highWaterMark: 100,
-  });
-
-  expect(d.writableObjectMode).toBe(true);
-  expect(d.writableHighWaterMark).toBe(100);
-  expect(d.readableObjectMode).toBe(true);
-  expect(d.readableHighWaterMark).toBe(100);
-});
-
-test("Duplex stream with different object mode and high water mark for readable and writable", () => {
-  const d = new Duplex({
-    readableObjectMode: false,
-    readableHighWaterMark: 10,
-    writableObjectMode: true,
-    writableHighWaterMark: 100,
-  });
-
-  expect(d.writableObjectMode).toBe(true);
-  expect(d.writableHighWaterMark).toBe(100);
-  expect(d.readableObjectMode).toBe(false);
-  expect(d.readableHighWaterMark).toBe(10);
-});
-
-//<#END_FILE: test-stream-duplex-props.js
diff --git a/test/js/node/test/parallel/stream-duplex-readable-end.test.js b/test/js/node/test/parallel/stream-duplex-readable-end.test.js
deleted file mode 100644
index 7ccfe779b6..0000000000
--- a/test/js/node/test/parallel/stream-duplex-readable-end.test.js
+++ /dev/null
@@ -1,37 +0,0 @@
-//#FILE: test-stream-duplex-readable-end.js
-//#SHA1: 8cecff6703e081aeb94abe2b37332bc7aef28b1d
-//-----------------
-"use strict";
-
-// https://github.com/nodejs/node/issues/35926
-const stream = require("stream");
-
-test("stream duplex readable end", done => {
-  let loops = 5;
-
-  const src = new stream.Readable({
-    highWaterMark: 16 * 1024,
-    read() {
-      if (loops--) this.push(Buffer.alloc(20000));
-    },
-  });
-
-  const dst = new stream.Transform({
-    highWaterMark: 16 * 1024,
-    transform(chunk, output, fn) {
-      this.push(null);
-      fn();
-    },
-  });
-
-  src.pipe(dst);
-
-  dst.on("data", () => {});
-  dst.on("end", () => {
-    expect(loops).toBe(3);
-    expect(src.isPaused()).toBe(true);
-    done();
-  });
-});
-
-//<#END_FILE: test-stream-duplex-readable-end.js
diff --git a/test/js/node/test/parallel/stream-duplex-readable-writable.test.js b/test/js/node/test/parallel/stream-duplex-readable-writable.test.js
deleted file mode 100644
index c37a46d6dd..0000000000
--- a/test/js/node/test/parallel/stream-duplex-readable-writable.test.js
+++ /dev/null
@@ -1,95 +0,0 @@
-//#FILE: test-stream-duplex-readable-writable.js
-//#SHA1: d56d29f5fbb8adc3d61708839985f0ea7ffb9b5c
-//-----------------
-"use strict";
-
-const { Duplex } = require("stream");
-
-test("Duplex with readable false", () => {
-  const duplex = new Duplex({
-    readable: false,
-  });
-  expect(duplex.readable).toBe(false);
-  duplex.push("asd");
-
-  const errorHandler = jest.fn();
-  duplex.on("error", errorHandler);
-
-  const dataHandler = jest.fn();
-  duplex.on("data", dataHandler);
-
-  const endHandler = jest.fn();
-  duplex.on("end", endHandler);
-
-  return new Promise(resolve => {
-    setImmediate(() => {
-      expect(errorHandler).toHaveBeenCalledTimes(1);
-      expect(errorHandler).toHaveBeenCalledWith(
-        expect.objectContaining({
-          code: "ERR_STREAM_PUSH_AFTER_EOF",
-          message: expect.any(String),
-        }),
-      );
-      expect(dataHandler).not.toHaveBeenCalled();
-      expect(endHandler).not.toHaveBeenCalled();
-      resolve();
-    });
-  });
-});
-
-test("Duplex with writable false", () => {
-  const writeSpy = jest.fn();
-  const duplex = new Duplex({
-    writable: false,
-    write: writeSpy,
-  });
-  expect(duplex.writable).toBe(false);
-  duplex.write("asd");
-
-  const errorHandler = jest.fn();
-  duplex.on("error", errorHandler);
-
-  const finishHandler = jest.fn();
-  duplex.on("finish", finishHandler);
-
-  return new Promise(resolve => {
-    setImmediate(() => {
-      expect(errorHandler).toHaveBeenCalledTimes(1);
-      expect(errorHandler).toHaveBeenCalledWith(
-        expect.objectContaining({
-          code: "ERR_STREAM_WRITE_AFTER_END",
-          message: expect.any(String),
-        }),
-      );
-      expect(writeSpy).not.toHaveBeenCalled();
-      expect(finishHandler).not.toHaveBeenCalled();
-      resolve();
-    });
-  });
-});
-
-test("Duplex with readable false and async iteration", async () => {
-  const duplex = new Duplex({
-    readable: false,
-  });
-  expect(duplex.readable).toBe(false);
-
-  const dataHandler = jest.fn();
-  duplex.on("data", dataHandler);
-
-  const endHandler = jest.fn();
-  duplex.on("end", endHandler);
-
-  async function run() {
-    for await (const chunk of duplex) {
-      expect(chunk).toBeFalsy(); // This should never be reached
-    }
-  }
-
-  await run();
-
-  expect(dataHandler).not.toHaveBeenCalled();
-  expect(endHandler).not.toHaveBeenCalled();
-});
-
-//<#END_FILE: test-stream-duplex-readable-writable.js
diff --git a/test/js/node/test/parallel/stream-duplex-writable-finished.test.js b/test/js/node/test/parallel/stream-duplex-writable-finished.test.js
deleted file mode 100644
index 0a2400bb78..0000000000
--- a/test/js/node/test/parallel/stream-duplex-writable-finished.test.js
+++ /dev/null
@@ -1,33 +0,0 @@
-//#FILE: test-stream-duplex-writable-finished.js
-//#SHA1: ba8c61c576c3a900076baa134c8a0d6876e84db5
-//-----------------
-"use strict";
-
-const { Duplex } = require("stream");
-
-// basic
-test("Duplex.prototype has writableFinished", () => {
-  expect(Object.hasOwn(Duplex.prototype, "writableFinished")).toBe(true);
-});
-
-// event
-test("writableFinished state changes correctly", done => {
-  const duplex = new Duplex();
-
-  duplex._write = (chunk, encoding, cb) => {
-    // The state finished should start in false.
-    expect(duplex.writableFinished).toBe(false);
-    cb();
-  };
-
-  duplex.on("finish", () => {
-    expect(duplex.writableFinished).toBe(true);
-  });
-
-  duplex.end("testing finished state", () => {
-    expect(duplex.writableFinished).toBe(true);
-    done();
-  });
-});
-
-//<#END_FILE: test-stream-duplex-writable-finished.js
diff --git a/test/js/node/test/parallel/stream-end-of-streams.test.js b/test/js/node/test/parallel/stream-end-of-streams.test.js
deleted file mode 100644
index af768bc70e..0000000000
--- a/test/js/node/test/parallel/stream-end-of-streams.test.js
+++ /dev/null
@@ -1,31 +0,0 @@
-//#FILE: test-stream-end-of-streams.js
-//#SHA1: 3fa13e31cef06059026b0fcf90c151a8a975752c
-//-----------------
-"use strict";
-
-const { Duplex, finished } = require("stream");
-
-test("finished function with invalid stream", () => {
-  // Passing empty object to mock invalid stream
-  // should throw error
-  expect(() => {
-    finished({}, () => {});
-  }).toThrow(
-    expect.objectContaining({
-      code: "ERR_INVALID_ARG_TYPE",
-      message: expect.any(String),
-    }),
-  );
-});
-
-test("finished function with valid stream", () => {
-  const streamObj = new Duplex();
-  streamObj.end();
-  // Below code should not throw any errors as the
-  // streamObj is `Stream`
-  expect(() => {
-    finished(streamObj, () => {});
-  }).not.toThrow();
-});
-
-//<#END_FILE: test-stream-end-of-streams.js
diff --git a/test/js/node/test/parallel/stream-end-paused.test.js b/test/js/node/test/parallel/stream-end-paused.test.js
deleted file mode 100644
index 1022f980ef..0000000000
--- a/test/js/node/test/parallel/stream-end-paused.test.js
+++ /dev/null
@@ -1,53 +0,0 @@
-//#FILE: test-stream-end-paused.js
-//#SHA1: 4ebe901f30ba0469bb75c7f9f7ba5316ceb271a5
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const { Readable } = require("stream");
-
-test("end event for paused 0-length streams", done => {
-  // Make sure we don't miss the end event for paused 0-length streams
-
-  const stream = new Readable();
-  let calledRead = false;
-  stream._read = function () {
-    expect(calledRead).toBe(false);
-    calledRead = true;
-    this.push(null);
-  };
-
-  stream.on("data", () => {
-    throw new Error("should not ever get data");
-  });
-  stream.pause();
-
-  setTimeout(() => {
-    stream.on("end", () => {
-      expect(calledRead).toBe(true);
-      done();
-    });
-    stream.resume();
-  }, 1);
-});
-
-//<#END_FILE: test-stream-end-paused.js
diff --git a/test/js/node/test/parallel/stream-events-prepend.test.js b/test/js/node/test/parallel/stream-events-prepend.test.js
deleted file mode 100644
index 590421f79d..0000000000
--- a/test/js/node/test/parallel/stream-events-prepend.test.js
+++ /dev/null
@@ -1,35 +0,0 @@
-//#FILE: test-stream-events-prepend.js
-//#SHA1: db830318b8c5a2e990a75320319c8fcd96fa760a
-//-----------------
-"use strict";
-const stream = require("stream");
-
-class Writable extends stream.Writable {
-  constructor() {
-    super();
-    this.prependListener = undefined;
-  }
-
-  _write(chunk, end, cb) {
-    cb();
-  }
-}
-
-class Readable extends stream.Readable {
-  _read() {
-    this.push(null);
-  }
-}
-
-test("pipe event is emitted even when prependListener is undefined", () => {
-  const w = new Writable();
-  const pipeSpy = jest.fn();
-  w.on("pipe", pipeSpy);
-
-  const r = new Readable();
-  r.pipe(w);
-
-  expect(pipeSpy).toHaveBeenCalledTimes(1);
-});
-
-//<#END_FILE: test-stream-events-prepend.js
diff --git a/test/js/node/test/parallel/stream-once-readable-pipe.test.js b/test/js/node/test/parallel/stream-once-readable-pipe.test.js
deleted file mode 100644
index 71b0c32698..0000000000
--- a/test/js/node/test/parallel/stream-once-readable-pipe.test.js
+++ /dev/null
@@ -1,75 +0,0 @@
-//#FILE: test-stream-once-readable-pipe.js
-//#SHA1: 4f12e7a8a1c06ba3cef54605469eb67d23306aa3
-//-----------------
-"use strict";
-
-const { Readable, Writable } = require("stream");
-
-// This test ensures that if have 'readable' listener
-// on Readable instance it will not disrupt the pipe.
-
-test("readable listener before pipe", () => {
-  let receivedData = "";
-  const w = new Writable({
-    write: (chunk, env, callback) => {
-      receivedData += chunk;
-      callback();
-    },
-  });
-
-  const data = ["foo", "bar", "baz"];
-  const r = new Readable({
-    read: () => {},
-  });
-
-  const readableSpy = jest.fn();
-  r.once("readable", readableSpy);
-
-  r.pipe(w);
-  r.push(data[0]);
-  r.push(data[1]);
-  r.push(data[2]);
-  r.push(null);
-
-  return new Promise(resolve => {
-    w.on("finish", () => {
-      expect(receivedData).toBe(data.join(""));
-      expect(readableSpy).toHaveBeenCalledTimes(1);
-      resolve();
-    });
-  });
-});
-
-test("readable listener after pipe", () => {
-  let receivedData = "";
-  const w = new Writable({
-    write: (chunk, env, callback) => {
-      receivedData += chunk;
-      callback();
-    },
-  });
-
-  const data = ["foo", "bar", "baz"];
-  const r = new Readable({
-    read: () => {},
-  });
-
-  r.pipe(w);
-  r.push(data[0]);
-  r.push(data[1]);
-  r.push(data[2]);
-  r.push(null);
-
-  const readableSpy = jest.fn();
-  r.once("readable", readableSpy);
-
-  return new Promise(resolve => {
-    w.on("finish", () => {
-      expect(receivedData).toBe(data.join(""));
-      expect(readableSpy).toHaveBeenCalledTimes(1);
-      resolve();
-    });
-  });
-});
-
-//<#END_FILE: test-stream-once-readable-pipe.js
diff --git a/test/js/node/test/parallel/stream-passthrough-drain.test.js b/test/js/node/test/parallel/stream-passthrough-drain.test.js
deleted file mode 100644
index b77fa6daf3..0000000000
--- a/test/js/node/test/parallel/stream-passthrough-drain.test.js
+++ /dev/null
@@ -1,27 +0,0 @@
-//#FILE: test-stream-passthrough-drain.js
-//#SHA1: c17561a8fc9a14d7abc05af3528d0ead32502a57
-//-----------------
-"use strict";
-const { PassThrough } = require("stream");
-
-test("PassThrough stream emits drain event when buffer is emptied", () => {
-  const pt = new PassThrough({ highWaterMark: 0 });
-
-  const drainHandler = jest.fn();
-  pt.on("drain", drainHandler);
-
-  expect(pt.write("hello1")).toBe(false);
-
-  pt.read();
-  pt.read();
-
-  // Use process.nextTick to ensure the drain event has a chance to fire
-  return new Promise(resolve => {
-    process.nextTick(() => {
-      expect(drainHandler).toHaveBeenCalledTimes(1);
-      resolve();
-    });
-  });
-});
-
-//<#END_FILE: test-stream-passthrough-drain.js
diff --git a/test/js/node/test/parallel/stream-pipe-event.test.js b/test/js/node/test/parallel/stream-pipe-event.test.js
deleted file mode 100644
index 5c7c0626f9..0000000000
--- a/test/js/node/test/parallel/stream-pipe-event.test.js
+++ /dev/null
@@ -1,56 +0,0 @@
-//#FILE: test-stream-pipe-event.js
-//#SHA1: 63887b8cce85a4c7cfa27c8111edd14330a2078f
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const stream = require("stream");
-
-function Writable() {
-  this.writable = true;
-  stream.Stream.call(this);
-}
-Object.setPrototypeOf(Writable.prototype, stream.Stream.prototype);
-Object.setPrototypeOf(Writable, stream.Stream);
-
-function Readable() {
-  this.readable = true;
-  stream.Stream.call(this);
-}
-Object.setPrototypeOf(Readable.prototype, stream.Stream.prototype);
-Object.setPrototypeOf(Readable, stream.Stream);
-
-test("pipe event is emitted", () => {
-  let passed = false;
-
-  const w = new Writable();
-  w.on("pipe", function (src) {
-    passed = true;
-  });
-
-  const r = new Readable();
-  r.pipe(w);
-
-  expect(passed).toBe(true);
-});
-
-//<#END_FILE: test-stream-pipe-event.js
diff --git a/test/js/node/test/parallel/stream-pipe-needdrain.test.js b/test/js/node/test/parallel/stream-pipe-needdrain.test.js
deleted file mode 100644
index 42e4b2e9f3..0000000000
--- a/test/js/node/test/parallel/stream-pipe-needdrain.test.js
+++ /dev/null
@@ -1,40 +0,0 @@
-//#FILE: test-stream-pipe-needDrain.js
-//#SHA1: 5c524a253a770fcbb95365aea011a38a665c61da
-//-----------------
-"use strict";
-
-const { Readable, Writable } = require("stream");
-
-// Pipe should pause temporarily if writable needs drain.
-test("Pipe pauses when writable needs drain", done => {
-  const w = new Writable({
-    write(buf, encoding, callback) {
-      process.nextTick(callback);
-    },
-    highWaterMark: 1,
-  });
-
-  while (w.write("asd"));
-
-  expect(w.writableNeedDrain).toBe(true);
-
-  const r = new Readable({
-    read() {
-      this.push("asd");
-      this.push(null);
-    },
-  });
-
-  const pauseSpy = jest.fn();
-  r.on("pause", pauseSpy);
-
-  const endSpy = jest.fn().mockImplementation(() => {
-    expect(pauseSpy).toHaveBeenCalledTimes(2);
-    done();
-  });
-  r.on("end", endSpy);
-
-  r.pipe(w);
-});
-
-//<#END_FILE: test-stream-pipe-needDrain.js
diff --git a/test/js/node/test/parallel/stream-preprocess.test.js b/test/js/node/test/parallel/stream-preprocess.test.js
deleted file mode 100644
index 8c5dd3cc8a..0000000000
--- a/test/js/node/test/parallel/stream-preprocess.test.js
+++ /dev/null
@@ -1,68 +0,0 @@
-//#FILE: test-stream-preprocess.js
-//#SHA1: 4061428f95671f257c4a57a92d77c0dc63a1394a
-//-----------------
-"use strict";
-
-const fs = require("fs");
-const rl = require("readline");
-const fixtures = require("../common/fixtures");
-
-const BOM = "\uFEFF";
-
-// Get the data using a non-stream way to compare with the streamed data.
-const modelData = fixtures.readSync("file-to-read-without-bom.txt", "utf8");
-const modelDataFirstCharacter = modelData[0];
-
-// Detect the number of forthcoming 'line' events for mustCall() 'expected' arg.
-const lineCount = modelData.match(/\n/g).length;
-
-test("Ensure both without-bom and with-bom test files are textwise equal", () => {
-  expect(fixtures.readSync("file-to-read-with-bom.txt", "utf8")).toBe(`${BOM}${modelData}`);
-});
-
-test("An unjustified BOM stripping with a non-BOM character unshifted to a stream", done => {
-  const inputWithoutBOM = fs.createReadStream(fixtures.path("file-to-read-without-bom.txt"), "utf8");
-
-  inputWithoutBOM.once("readable", () => {
-    const maybeBOM = inputWithoutBOM.read(1);
-    expect(maybeBOM).toBe(modelDataFirstCharacter);
-    expect(maybeBOM).not.toBe(BOM);
-
-    inputWithoutBOM.unshift(maybeBOM);
-
-    let streamedData = "";
-    rl.createInterface({
-      input: inputWithoutBOM,
-    })
-      .on("line", line => {
-        streamedData += `${line}\n`;
-      })
-      .on("close", () => {
-        expect(streamedData).toBe(modelData);
-        done();
-      });
-  });
-});
-
-test("A justified BOM stripping", done => {
-  const inputWithBOM = fs.createReadStream(fixtures.path("file-to-read-with-bom.txt"), "utf8");
-
-  inputWithBOM.once("readable", () => {
-    const maybeBOM = inputWithBOM.read(1);
-    expect(maybeBOM).toBe(BOM);
-
-    let streamedData = "";
-    rl.createInterface({
-      input: inputWithBOM,
-    })
-      .on("line", line => {
-        streamedData += `${line}\n`;
-      })
-      .on("close", () => {
-        expect(streamedData).toBe(modelData);
-        done();
-      });
-  });
-});
-
-//<#END_FILE: test-stream-preprocess.js
diff --git a/test/js/node/test/parallel/stream-push-strings.test.js b/test/js/node/test/parallel/stream-push-strings.test.js
deleted file mode 100644
index fecd87ceaa..0000000000
--- a/test/js/node/test/parallel/stream-push-strings.test.js
+++ /dev/null
@@ -1,72 +0,0 @@
-//#FILE: test-stream-push-strings.js
-//#SHA1: d2da34fc74795ea8cc46460ce443d0b30b0e98d8
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-const { Readable } = require("stream");
-
-class MyStream extends Readable {
-  constructor(options) {
-    super(options);
-    this._chunks = 3;
-  }
-
-  _read(n) {
-    switch (this._chunks--) {
-      case 0:
-        return this.push(null);
-      case 1:
-        return setTimeout(() => {
-          this.push("last chunk");
-        }, 100);
-      case 2:
-        return this.push("second to last chunk");
-      case 3:
-        return process.nextTick(() => {
-          this.push("first chunk");
-        });
-      default:
-        throw new Error("?");
-    }
-  }
-}
-
-test("MyStream pushes strings correctly", done => {
-  const ms = new MyStream();
-  const results = [];
-  ms.on("readable", function () {
-    let chunk;
-    while (null !== (chunk = ms.read())) results.push(String(chunk));
-  });
-
-  const expected = ["first chunksecond to last chunk", "last chunk"];
-
-  ms.on("end", () => {
-    expect(ms._chunks).toBe(-1);
-    expect(results).toEqual(expected);
-    done();
-  });
-});
-
-//<#END_FILE: test-stream-push-strings.js
diff --git a/test/js/node/test/parallel/stream-readable-aborted.test.js b/test/js/node/test/parallel/stream-readable-aborted.test.js
deleted file mode 100644
index 3d005e5901..0000000000
--- a/test/js/node/test/parallel/stream-readable-aborted.test.js
+++ /dev/null
@@ -1,66 +0,0 @@
-//#FILE: test-stream-readable-aborted.js
-//#SHA1: b4d59c7cd8eda084bae2d2ff603dd153aff79f98
-//-----------------
-"use strict";
-
-const { Readable, Duplex } = require("stream");
-
-test("Readable stream aborted state", () => {
-  const readable = new Readable({
-    read() {},
-  });
-  expect(readable.readableAborted).toBe(false);
-  readable.destroy();
-  expect(readable.readableAborted).toBe(true);
-});
-
-test("Readable stream aborted state after push(null)", () => {
-  const readable = new Readable({
-    read() {},
-  });
-  expect(readable.readableAborted).toBe(false);
-  readable.push(null);
-  readable.destroy();
-  expect(readable.readableAborted).toBe(true);
-});
-
-test("Readable stream aborted state after push(data)", () => {
-  const readable = new Readable({
-    read() {},
-  });
-  expect(readable.readableAborted).toBe(false);
-  readable.push("asd");
-  readable.destroy();
-  expect(readable.readableAborted).toBe(true);
-});
-
-test("Readable stream aborted state after end event", done => {
-  const readable = new Readable({
-    read() {},
-  });
-  expect(readable.readableAborted).toBe(false);
-  readable.push("asd");
-  readable.push(null);
-  expect(readable.readableAborted).toBe(false);
-  readable.on("end", () => {
-    expect(readable.readableAborted).toBe(false);
-    readable.destroy();
-    expect(readable.readableAborted).toBe(false);
-    queueMicrotask(() => {
-      expect(readable.readableAborted).toBe(false);
-      done();
-    });
-  });
-  readable.resume();
-});
-
-test("Duplex stream with readable false", () => {
-  const duplex = new Duplex({
-    readable: false,
-    write() {},
-  });
-  duplex.destroy();
-  expect(duplex.readableAborted).toBe(false);
-});
-
-//<#END_FILE: test-stream-readable-aborted.js
diff --git a/test/js/node/test/parallel/stream-readable-add-chunk-during-data.test.js b/test/js/node/test/parallel/stream-readable-add-chunk-during-data.test.js
deleted file mode 100644
index 2a75e47cbf..0000000000
--- a/test/js/node/test/parallel/stream-readable-add-chunk-during-data.test.js
+++ /dev/null
@@ -1,28 +0,0 @@
-//#FILE: test-stream-readable-add-chunk-during-data.js
-//#SHA1: f34525f5ea022c837ba1e40e98b1b41da5df50b2
-//-----------------
-"use strict";
-const { Readable } = require("stream");
-
-// Verify that .push() and .unshift() can be called from 'data' listeners.
-
-["push", "unshift"].forEach(method => {
-  test(`Readable ${method} can be called from 'data' listeners`, done => {
-    const r = new Readable({ read() {} });
-
-    r.once("data", chunk => {
-      expect(r.readableLength).toBe(0);
-      r[method](chunk);
-      expect(r.readableLength).toBe(chunk.length);
-
-      r.on("data", newChunk => {
-        expect(newChunk.toString()).toBe("Hello, world");
-        done();
-      });
-    });
-
-    r.push("Hello, world");
-  });
-});
-
-//<#END_FILE: test-stream-readable-add-chunk-during-data.js
diff --git a/test/js/node/test/parallel/stream-readable-data.test.js b/test/js/node/test/parallel/stream-readable-data.test.js
deleted file mode 100644
index b654147c26..0000000000
--- a/test/js/node/test/parallel/stream-readable-data.test.js
+++ /dev/null
@@ -1,32 +0,0 @@
-//#FILE: test-stream-readable-data.js
-//#SHA1: c679a0f31d84cd65d9e85ab0617abfd65a053afc
-//-----------------
-"use strict";
-
-const { Readable } = require("stream");
-
-test("Readable stream emits data event after removing readable listener", done => {
-  const readable = new Readable({
-    read() {},
-  });
-
-  function read() {}
-
-  readable.setEncoding("utf8");
-  readable.on("readable", read);
-  readable.removeListener("readable", read);
-
-  process.nextTick(() => {
-    const dataHandler = jest.fn();
-    readable.on("data", dataHandler);
-    readable.push("hello");
-
-    // Use setImmediate to ensure the data event has time to be emitted
-    setImmediate(() => {
-      expect(dataHandler).toHaveBeenCalledTimes(1);
-      done();
-    });
-  });
-});
-
-//<#END_FILE: test-stream-readable-data.js
diff --git a/test/js/node/test/parallel/stream-readable-emittedreadable.test.js b/test/js/node/test/parallel/stream-readable-emittedreadable.test.js
deleted file mode 100644
index 744dba984c..0000000000
--- a/test/js/node/test/parallel/stream-readable-emittedreadable.test.js
+++ /dev/null
@@ -1,111 +0,0 @@
-//#FILE: test-stream-readable-emittedReadable.js
-//#SHA1: 1c9463d9bb0e7927d8d18949aae849a04cc034fe
-//-----------------
-"use strict";
-const { Readable } = require("stream");
-
-describe("Readable Stream emittedReadable", () => {
-  test("emittedReadable state changes correctly", () => {
-    const readable = new Readable({
-      read: () => {},
-    });
-
-    // Initialized to false.
-    expect(readable._readableState.emittedReadable).toBe(false);
-
-    const expected = [Buffer.from("foobar"), Buffer.from("quo"), null];
-    const readableSpy = jest.fn(() => {
-      // emittedReadable should be true when the readable event is emitted
-      expect(readable._readableState.emittedReadable).toBe(true);
-      expect(readable.read()).toEqual(expected.shift());
-      // emittedReadable is reset to false during read()
-      expect(readable._readableState.emittedReadable).toBe(false);
-    });
-
-    readable.on("readable", readableSpy);
-
-    // When the first readable listener is just attached,
-    // emittedReadable should be false
-    expect(readable._readableState.emittedReadable).toBe(false);
-
-    // These trigger a single 'readable', as things are batched up
-    process.nextTick(() => {
-      readable.push("foo");
-    });
-    process.nextTick(() => {
-      readable.push("bar");
-    });
-
-    // These triggers two readable events
-    setImmediate(() => {
-      readable.push("quo");
-      process.nextTick(() => {
-        readable.push(null);
-      });
-    });
-
-    return new Promise(resolve => {
-      setTimeout(() => {
-        expect(readableSpy).toHaveBeenCalledTimes(3);
-        resolve();
-      }, 100);
-    });
-  });
-
-  test("emittedReadable with read(0)", () => {
-    const noRead = new Readable({
-      read: () => {},
-    });
-
-    const readableSpy = jest.fn(() => {
-      // emittedReadable should be true when the readable event is emitted
-      expect(noRead._readableState.emittedReadable).toBe(true);
-      noRead.read(0);
-      // emittedReadable is not reset during read(0)
-      expect(noRead._readableState.emittedReadable).toBe(true);
-    });
-
-    noRead.on("readable", readableSpy);
-
-    noRead.push("foo");
-    noRead.push(null);
-
-    return new Promise(resolve => {
-      setTimeout(() => {
-        expect(readableSpy).toHaveBeenCalledTimes(1);
-        resolve();
-      }, 100);
-    });
-  });
-
-  test("emittedReadable in flowing mode", () => {
-    const flowing = new Readable({
-      read: () => {},
-    });
-
-    const dataSpy = jest.fn(() => {
-      // When in flowing mode, emittedReadable is always false.
-      expect(flowing._readableState.emittedReadable).toBe(false);
-      flowing.read();
-      expect(flowing._readableState.emittedReadable).toBe(false);
-    });
-
-    flowing.on("data", dataSpy);
-
-    flowing.push("foooo");
-    flowing.push("bar");
-    flowing.push("quo");
-    process.nextTick(() => {
-      flowing.push(null);
-    });
-
-    return new Promise(resolve => {
-      setTimeout(() => {
-        expect(dataSpy).toHaveBeenCalledTimes(3);
-        resolve();
-      }, 100);
-    });
-  });
-});
-
-//<#END_FILE: test-stream-readable-emittedReadable.js
diff --git a/test/js/node/test/parallel/stream-readable-end-destroyed.test.js b/test/js/node/test/parallel/stream-readable-end-destroyed.test.js
deleted file mode 100644
index c8b98db765..0000000000
--- a/test/js/node/test/parallel/stream-readable-end-destroyed.test.js
+++ /dev/null
@@ -1,25 +0,0 @@
-//#FILE: test-stream-readable-end-destroyed.js
-//#SHA1: 20c8bb870db11018d2eaa1c9e4dece071917d03d
-//-----------------
-"use strict";
-
-const { Readable } = require("stream");
-
-test("Don't emit 'end' after 'close'", () => {
-  const r = new Readable();
-
-  const endListener = jest.fn();
-  r.on("end", endListener);
-  r.resume();
-  r.destroy();
-
-  return new Promise(resolve => {
-    r.on("close", () => {
-      r.push(null);
-      expect(endListener).not.toHaveBeenCalled();
-      resolve();
-    });
-  });
-});
-
-//<#END_FILE: test-stream-readable-end-destroyed.js
diff --git a/test/js/node/test/parallel/stream-readable-ended.test.js b/test/js/node/test/parallel/stream-readable-ended.test.js
deleted file mode 100644
index fb6a3c3b64..0000000000
--- a/test/js/node/test/parallel/stream-readable-ended.test.js
+++ /dev/null
@@ -1,57 +0,0 @@
-//#FILE: test-stream-readable-ended.js
-//#SHA1: 93aa267630bb32f94783c5bbdeb8e345c0acd94a
-//-----------------
-"use strict";
-
-const { Readable } = require("stream");
-
-// basic
-test("Readable.prototype has readableEnded property", () => {
-  expect(Object.hasOwn(Readable.prototype, "readableEnded")).toBe(true);
-});
-
-// event
-test("readableEnded state changes correctly", done => {
-  const readable = new Readable();
-
-  readable._read = () => {
-    // The state ended should start in false.
-    expect(readable.readableEnded).toBe(false);
-    readable.push("asd");
-    expect(readable.readableEnded).toBe(false);
-    readable.push(null);
-    expect(readable.readableEnded).toBe(false);
-  };
-
-  readable.on("end", () => {
-    expect(readable.readableEnded).toBe(true);
-    done();
-  });
-
-  readable.on("data", () => {
-    expect(readable.readableEnded).toBe(false);
-  });
-});
-
-// Verifies no `error` triggered on multiple .push(null) invocations
-test("No error triggered on multiple .push(null) invocations", done => {
-  const readable = new Readable();
-
-  readable.on("readable", () => {
-    readable.read();
-  });
-
-  const errorHandler = jest.fn();
-  readable.on("error", errorHandler);
-
-  readable.on("end", () => {
-    expect(errorHandler).not.toHaveBeenCalled();
-    done();
-  });
-
-  readable.push("a");
-  readable.push(null);
-  readable.push(null);
-});
-
-//<#END_FILE: test-stream-readable-ended.js
diff --git a/test/js/node/test/parallel/stream-readable-event.test.js b/test/js/node/test/parallel/stream-readable-event.test.js
deleted file mode 100644
index 688f207d1b..0000000000
--- a/test/js/node/test/parallel/stream-readable-event.test.js
+++ /dev/null
@@ -1,146 +0,0 @@
-//#FILE: test-stream-readable-event.js
-//#SHA1: 8a3da958252097730dcd22e82d325d106d5512a5
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-const { Readable } = require("stream");
-
-test("not reading when the readable is added", done => {
-  const r = new Readable({
-    highWaterMark: 3,
-  });
-
-  r._read = jest.fn();
-
-  // This triggers a 'readable' event, which is lost.
-  r.push(Buffer.from("blerg"));
-
-  setTimeout(() => {
-    // We're testing what we think we are
-    expect(r._readableState.reading).toBe(false);
-    const readableSpy = jest.fn();
-    r.on("readable", readableSpy);
-
-    // Allow time for the 'readable' event to potentially fire
-    setTimeout(() => {
-      expect(readableSpy).toHaveBeenCalled();
-      expect(r._read).not.toHaveBeenCalled();
-      done();
-    }, 10);
-  }, 1);
-});
-
-test("readable is re-emitted if there's already a length, while it IS reading", done => {
-  const r = new Readable({
-    highWaterMark: 3,
-  });
-
-  r._read = jest.fn();
-
-  // This triggers a 'readable' event, which is lost.
-  r.push(Buffer.from("bl"));
-
-  setTimeout(() => {
-    // Assert we're testing what we think we are
-    expect(r._readableState.reading).toBe(true);
-    const readableSpy = jest.fn();
-    r.on("readable", readableSpy);
-
-    // Allow time for the 'readable' event to potentially fire
-    setTimeout(() => {
-      expect(readableSpy).toHaveBeenCalled();
-      expect(r._read).toHaveBeenCalled();
-      done();
-    }, 10);
-  }, 1);
-});
-
-test("not reading when the stream has not passed the highWaterMark but has reached EOF", done => {
-  const r = new Readable({
-    highWaterMark: 30,
-  });
-
-  r._read = jest.fn();
-
-  // This triggers a 'readable' event, which is lost.
-  r.push(Buffer.from("blerg"));
-  r.push(null);
-
-  setTimeout(() => {
-    // Assert we're testing what we think we are
-    expect(r._readableState.reading).toBe(false);
-    const readableSpy = jest.fn();
-    r.on("readable", readableSpy);
-
-    // Allow time for the 'readable' event to potentially fire
-    setTimeout(() => {
-      expect(readableSpy).toHaveBeenCalled();
-      expect(r._read).not.toHaveBeenCalled();
-      done();
-    }, 10);
-  }, 1);
-});
-
-test("Pushing an empty string in non-objectMode should trigger next `read()`", done => {
-  const underlyingData = ["", "x", "y", "", "z"];
-  const expected = underlyingData.filter(data => data);
-  const result = [];
-
-  const r = new Readable({
-    encoding: "utf8",
-  });
-  r._read = function () {
-    process.nextTick(() => {
-      if (!underlyingData.length) {
-        this.push(null);
-      } else {
-        this.push(underlyingData.shift());
-      }
-    });
-  };
-
-  r.on("readable", () => {
-    const data = r.read();
-    if (data !== null) result.push(data);
-  });
-
-  r.on("end", () => {
-    expect(result).toEqual(expected);
-    done();
-  });
-});
-
-test("#20923 - removeAllListeners should clear all event listeners", () => {
-  const r = new Readable();
-  r._read = function () {
-    // Actually doing thing here
-  };
-  r.on("data", function () {});
-
-  r.removeAllListeners();
-
-  expect(r.eventNames().length).toBe(0);
-});
-
-//<#END_FILE: test-stream-readable-event.js
diff --git a/test/js/node/test/parallel/stream-readable-hwm-0-async.test.js b/test/js/node/test/parallel/stream-readable-hwm-0-async.test.js
deleted file mode 100644
index 0d2388c333..0000000000
--- a/test/js/node/test/parallel/stream-readable-hwm-0-async.test.js
+++ /dev/null
@@ -1,46 +0,0 @@
-//#FILE: test-stream-readable-hwm-0-async.js
-//#SHA1: ddaa3718bf6d6ae9258293494ac3449800169768
-//-----------------
-"use strict";
-
-const { Readable } = require("stream");
-
-// This test ensures that Readable stream will continue to call _read
-// for streams with highWaterMark === 0 once the stream returns data
-// by calling push() asynchronously.
-
-test("Readable stream with highWaterMark 0 and async push", async () => {
-  let count = 5;
-  const readMock = jest.fn(() => {
-    process.nextTick(() => {
-      if (count--) {
-        r.push("a");
-      } else {
-        r.push(null);
-      }
-    });
-  });
-
-  const r = new Readable({
-    read: readMock,
-    highWaterMark: 0,
-  });
-
-  const dataHandler = jest.fn();
-  const endHandler = jest.fn();
-
-  r.on("data", dataHandler);
-  r.on("end", endHandler);
-
-  // Consume the stream
-  for await (const chunk of r) {
-    // This loop will iterate 5 times
-  }
-
-  // Called 6 times: First 5 return data, last one signals end of stream.
-  expect(readMock).toHaveBeenCalledTimes(6);
-  expect(dataHandler).toHaveBeenCalledTimes(5);
-  expect(endHandler).toHaveBeenCalledTimes(1);
-});
-
-//<#END_FILE: test-stream-readable-hwm-0-async.js
diff --git a/test/js/node/test/parallel/stream-readable-hwm-0.test.js b/test/js/node/test/parallel/stream-readable-hwm-0.test.js
deleted file mode 100644
index 3d8266581d..0000000000
--- a/test/js/node/test/parallel/stream-readable-hwm-0.test.js
+++ /dev/null
@@ -1,52 +0,0 @@
-//#FILE: test-stream-readable-hwm-0.js
-//#SHA1: 986085294672eff1ba0a13f99633edd30c3fb54a
-//-----------------
-"use strict";
-
-const { Readable } = require("stream");
-
-// This test ensures that Readable stream will call _read() for streams
-// with highWaterMark === 0 upon .read(0) instead of just trying to
-// emit 'readable' event.
-
-test("Readable stream with highWaterMark 0 calls _read()", () => {
-  const mockRead = jest.fn();
-
-  const r = new Readable({
-    // Must be called only once upon setting 'readable' listener
-    read: mockRead,
-    highWaterMark: 0,
-  });
-
-  let pushedNull = false;
-
-  // This will trigger read(0) but must only be called after push(null)
-  // because we haven't pushed any data
-  r.on(
-    "readable",
-    jest.fn(() => {
-      expect(r.read()).toBeNull();
-      expect(pushedNull).toBe(true);
-    }),
-  );
-
-  const endHandler = jest.fn();
-  r.on("end", endHandler);
-
-  return new Promise(resolve => {
-    process.nextTick(() => {
-      expect(r.read()).toBeNull();
-      pushedNull = true;
-      r.push(null);
-
-      // Use setImmediate to ensure all events have been processed
-      setImmediate(() => {
-        expect(mockRead).toHaveBeenCalledTimes(1);
-        expect(endHandler).toHaveBeenCalledTimes(1);
-        resolve();
-      });
-    });
-  });
-});
-
-//<#END_FILE: test-stream-readable-hwm-0.js
diff --git a/test/js/node/test/parallel/stream-readable-needreadable.test.js b/test/js/node/test/parallel/stream-readable-needreadable.test.js
deleted file mode 100644
index 171eeee0df..0000000000
--- a/test/js/node/test/parallel/stream-readable-needreadable.test.js
+++ /dev/null
@@ -1,131 +0,0 @@
-//#FILE: test-stream-readable-needReadable.js
-//#SHA1: 301ca49c86e59196821c0fcd419c71f5ffd4a94d
-//-----------------
-"use strict";
-
-const { Readable } = require("stream");
-
-describe("Readable stream needReadable property", () => {
-  test("Initial state and readable event", () => {
-    const readable = new Readable({
-      read: () => {},
-    });
-
-    // Initialized to false.
-    expect(readable._readableState.needReadable).toBe(false);
-
-    readable.on("readable", () => {
-      // When the readable event fires, needReadable is reset.
-      expect(readable._readableState.needReadable).toBe(false);
-      readable.read();
-    });
-
-    // If a readable listener is attached, then a readable event is needed.
-    expect(readable._readableState.needReadable).toBe(true);
-
-    readable.push("foo");
-    readable.push(null);
-
-    return new Promise(resolve => {
-      readable.on("end", () => {
-        // No need to emit readable anymore when the stream ends.
-        expect(readable._readableState.needReadable).toBe(false);
-        resolve();
-      });
-    });
-  });
-
-  test("Async readable stream", done => {
-    const asyncReadable = new Readable({
-      read: () => {},
-    });
-
-    let readableCallCount = 0;
-    asyncReadable.on("readable", () => {
-      if (asyncReadable.read() !== null) {
-        // After each read(), the buffer is empty.
-        // If the stream doesn't end now,
-        // then we need to notify the reader on future changes.
-        expect(asyncReadable._readableState.needReadable).toBe(true);
-      }
-      readableCallCount++;
-      if (readableCallCount === 2) {
-        done();
-      }
-    });
-
-    process.nextTick(() => {
-      asyncReadable.push("foooo");
-    });
-    process.nextTick(() => {
-      asyncReadable.push("bar");
-    });
-    setImmediate(() => {
-      asyncReadable.push(null);
-      expect(asyncReadable._readableState.needReadable).toBe(false);
-    });
-  });
-
-  test("Flowing mode", done => {
-    const flowing = new Readable({
-      read: () => {},
-    });
-
-    // Notice this must be above the on('data') call.
-    flowing.push("foooo");
-    flowing.push("bar");
-    flowing.push("quo");
-    process.nextTick(() => {
-      flowing.push(null);
-    });
-
-    let dataCallCount = 0;
-    // When the buffer already has enough data, and the stream is
-    // in flowing mode, there is no need for the readable event.
-    flowing.on("data", data => {
-      expect(flowing._readableState.needReadable).toBe(false);
-      dataCallCount++;
-      if (dataCallCount === 3) {
-        done();
-      }
-    });
-  });
-
-  test("Slow producer", done => {
-    const slowProducer = new Readable({
-      read: () => {},
-    });
-
-    let readableCallCount = 0;
-    slowProducer.on("readable", () => {
-      const chunk = slowProducer.read(8);
-      const state = slowProducer._readableState;
-      if (chunk === null) {
-        // The buffer doesn't have enough data, and the stream is not end,
-        // we need to notify the reader when data arrives.
-        expect(state.needReadable).toBe(true);
-      } else {
-        expect(state.needReadable).toBe(false);
-      }
-      readableCallCount++;
-      if (readableCallCount === 4) {
-        done();
-      }
-    });
-
-    process.nextTick(() => {
-      slowProducer.push("foo");
-      process.nextTick(() => {
-        slowProducer.push("foo");
-        process.nextTick(() => {
-          slowProducer.push("foo");
-          process.nextTick(() => {
-            slowProducer.push(null);
-          });
-        });
-      });
-    });
-  });
-});
-
-//<#END_FILE: test-stream-readable-needReadable.js
diff --git a/test/js/node/test/parallel/stream-readable-next-no-null.test.js b/test/js/node/test/parallel/stream-readable-next-no-null.test.js
deleted file mode 100644
index c0129802e9..0000000000
--- a/test/js/node/test/parallel/stream-readable-next-no-null.test.js
+++ /dev/null
@@ -1,47 +0,0 @@
-//#FILE: test-stream-readable-next-no-null.js
-//#SHA1: b3362d071d6f13ce317db2b897ff1146441d1bea
-//-----------------
-"use strict";
-
-const { Readable } = require("stream");
-
-describe("Readable.from with null value", () => {
-  it("should throw ERR_STREAM_NULL_VALUES error", async () => {
-    async function* generate() {
-      yield null;
-    }
-
-    const stream = Readable.from(generate());
-
-    const errorPromise = new Promise(resolve => {
-      stream.on("error", error => {
-        resolve(error);
-      });
-    });
-
-    const dataPromise = new Promise(resolve => {
-      stream.on("data", () => {
-        resolve("data");
-      });
-    });
-
-    const endPromise = new Promise(resolve => {
-      stream.on("end", () => {
-        resolve("end");
-      });
-    });
-
-    await expect(errorPromise).resolves.toEqual(
-      expect.objectContaining({
-        code: "ERR_STREAM_NULL_VALUES",
-        name: "TypeError",
-        message: expect.any(String),
-      }),
-    );
-
-    await expect(Promise.race([dataPromise, endPromise, errorPromise])).resolves.not.toBe("data");
-    await expect(Promise.race([dataPromise, endPromise, errorPromise])).resolves.not.toBe("end");
-  });
-});
-
-//<#END_FILE: test-stream-readable-next-no-null.js
diff --git a/test/js/node/test/parallel/stream-readable-readable-then-resume.test.js b/test/js/node/test/parallel/stream-readable-readable-then-resume.test.js
deleted file mode 100644
index e542119c61..0000000000
--- a/test/js/node/test/parallel/stream-readable-readable-then-resume.test.js
+++ /dev/null
@@ -1,40 +0,0 @@
-//#FILE: test-stream-readable-readable-then-resume.js
-//#SHA1: 79790a4cd766421a6891704bf157072eaef2d5b4
-//-----------------
-"use strict";
-
-const { Readable } = require("stream");
-
-// This test verifies that a stream could be resumed after
-// removing the readable event in the same tick
-
-function check(s) {
-  const readableListener = jest.fn();
-  s.on("readable", readableListener);
-  s.on("end", jest.fn());
-  expect(s.removeListener).toBe(s.off);
-  s.removeListener("readable", readableListener);
-  s.resume();
-
-  expect(readableListener).not.toHaveBeenCalled();
-}
-
-test("Readable stream can be resumed after removing readable event", () => {
-  const s = new Readable({
-    objectMode: true,
-    highWaterMark: 1,
-    read() {
-      if (!this.first) {
-        this.push("hello");
-        this.first = true;
-        return;
-      }
-
-      this.push(null);
-    },
-  });
-
-  check(s);
-});
-
-//<#END_FILE: test-stream-readable-readable-then-resume.js
diff --git a/test/js/node/test/parallel/stream-readable-readable.test.js b/test/js/node/test/parallel/stream-readable-readable.test.js
deleted file mode 100644
index cb0b9c2dba..0000000000
--- a/test/js/node/test/parallel/stream-readable-readable.test.js
+++ /dev/null
@@ -1,59 +0,0 @@
-//#FILE: test-stream-readable-readable.js
-//#SHA1: f2d897473803968b7ee8efb20a8f1f374987980b
-//-----------------
-"use strict";
-
-const { Readable } = require("stream");
-
-describe("Readable.readable", () => {
-  test("readable property is set correctly", () => {
-    const r = new Readable({
-      read() {},
-    });
-    expect(r.readable).toBe(true);
-    r.destroy();
-    expect(r.readable).toBe(false);
-  });
-
-  test("readable property remains true until end event", () => {
-    const r = new Readable({
-      read() {},
-    });
-    expect(r.readable).toBe(true);
-
-    const endHandler = jest.fn();
-    r.on("end", endHandler);
-    r.resume();
-    r.push(null);
-    expect(r.readable).toBe(true);
-    r.off("end", endHandler);
-
-    return new Promise(resolve => {
-      r.on("end", () => {
-        expect(r.readable).toBe(false);
-        resolve();
-      });
-    });
-  });
-
-  test("readable property becomes false on error", () => {
-    const r = new Readable({
-      read: jest.fn(() => {
-        process.nextTick(() => {
-          r.destroy(new Error());
-          expect(r.readable).toBe(false);
-        });
-      }),
-    });
-    r.resume();
-
-    return new Promise(resolve => {
-      r.on("error", () => {
-        expect(r.readable).toBe(false);
-        resolve();
-      });
-    });
-  });
-});
-
-//<#END_FILE: test-stream-readable-readable.js
diff --git a/test/js/node/test/parallel/stream-readable-resume-hwm.test.js b/test/js/node/test/parallel/stream-readable-resume-hwm.test.js
deleted file mode 100644
index 7e18b7f9a0..0000000000
--- a/test/js/node/test/parallel/stream-readable-resume-hwm.test.js
+++ /dev/null
@@ -1,34 +0,0 @@
-//#FILE: test-stream-readable-resume-hwm.js
-//#SHA1: 8149b27327258da89c087856f54e7e7584ddf1e5
-//-----------------
-"use strict";
-const { Readable } = require("stream");
-
-// readable.resume() should not lead to a ._read() call being scheduled
-// when we exceed the high water mark already.
-
-test("readable.resume() should not call _read() when exceeding highWaterMark", () => {
-  const mockRead = jest.fn();
-  const readable = new Readable({
-    read: mockRead,
-    highWaterMark: 100,
-  });
-
-  // Fill up the internal buffer so that we definitely exceed the HWM:
-  for (let i = 0; i < 10; i++) readable.push("a".repeat(200));
-
-  // Call resume, and pause after one chunk.
-  // The .pause() is just so that we don't empty the buffer fully, which would
-  // be a valid reason to call ._read().
-  readable.resume();
-
-  return new Promise(resolve => {
-    readable.once("data", () => {
-      readable.pause();
-      expect(mockRead).not.toHaveBeenCalled();
-      resolve();
-    });
-  });
-});
-
-//<#END_FILE: test-stream-readable-resume-hwm.js
diff --git a/test/js/node/test/parallel/stream-readable-resumescheduled.test.js b/test/js/node/test/parallel/stream-readable-resumescheduled.test.js
deleted file mode 100644
index 499d82925f..0000000000
--- a/test/js/node/test/parallel/stream-readable-resumescheduled.test.js
+++ /dev/null
@@ -1,76 +0,0 @@
-//#FILE: test-stream-readable-resumeScheduled.js
-//#SHA1: 3327b31acfd00e4df0bac4e89d7a764c4de6cb4b
-//-----------------
-"use strict";
-
-const { Readable, Writable } = require("stream");
-
-// Testing Readable Stream resumeScheduled state
-
-describe("Readable Stream resumeScheduled state", () => {
-  test("pipe() test case", done => {
-    const r = new Readable({ read() {} });
-    const w = new Writable();
-
-    // resumeScheduled should start = `false`.
-    expect(r._readableState.resumeScheduled).toBe(false);
-
-    // Calling pipe() should change the state value = true.
-    r.pipe(w);
-    expect(r._readableState.resumeScheduled).toBe(true);
-
-    process.nextTick(() => {
-      expect(r._readableState.resumeScheduled).toBe(false);
-      done();
-    });
-  });
-
-  test("data listener test case", done => {
-    const r = new Readable({ read() {} });
-
-    // resumeScheduled should start = `false`.
-    expect(r._readableState.resumeScheduled).toBe(false);
-
-    r.push(Buffer.from([1, 2, 3]));
-
-    // Adding 'data' listener should change the state value
-    r.on(
-      "data",
-      jest.fn(() => {
-        expect(r._readableState.resumeScheduled).toBe(false);
-      }),
-    );
-    expect(r._readableState.resumeScheduled).toBe(true);
-
-    process.nextTick(() => {
-      expect(r._readableState.resumeScheduled).toBe(false);
-      done();
-    });
-  });
-
-  test("resume() test case", done => {
-    const r = new Readable({ read() {} });
-
-    // resumeScheduled should start = `false`.
-    expect(r._readableState.resumeScheduled).toBe(false);
-
-    // Calling resume() should change the state value.
-    r.resume();
-    expect(r._readableState.resumeScheduled).toBe(true);
-
-    const resumeHandler = jest.fn(() => {
-      // The state value should be `false` again
-      expect(r._readableState.resumeScheduled).toBe(false);
-    });
-
-    r.on("resume", resumeHandler);
-
-    process.nextTick(() => {
-      expect(r._readableState.resumeScheduled).toBe(false);
-      expect(resumeHandler).toHaveBeenCalledTimes(1);
-      done();
-    });
-  });
-});
-
-//<#END_FILE: test-stream-readable-resumeScheduled.js
diff --git a/test/js/node/test/parallel/stream-readable-setencoding-existing-buffers.test.js b/test/js/node/test/parallel/stream-readable-setencoding-existing-buffers.test.js
deleted file mode 100644
index f79124ae7f..0000000000
--- a/test/js/node/test/parallel/stream-readable-setencoding-existing-buffers.test.js
+++ /dev/null
@@ -1,62 +0,0 @@
-//#FILE: test-stream-readable-setEncoding-existing-buffers.js
-//#SHA1: 1b54f93d0be77b949ce81135243cc9ab3318db5b
-//-----------------
-"use strict";
-
-const { Readable } = require("stream");
-
-test("Call .setEncoding() while there are bytes already in the buffer", done => {
-  const r = new Readable({ read() {} });
-
-  r.push(Buffer.from("a"));
-  r.push(Buffer.from("b"));
-
-  r.setEncoding("utf8");
-  const chunks = [];
-  r.on("data", chunk => chunks.push(chunk));
-
-  process.nextTick(() => {
-    expect(chunks).toEqual(["ab"]);
-    done();
-  });
-});
-
-test("Call .setEncoding() while the buffer contains a complete, but chunked character", done => {
-  const r = new Readable({ read() {} });
-
-  r.push(Buffer.from([0xf0]));
-  r.push(Buffer.from([0x9f]));
-  r.push(Buffer.from([0x8e]));
-  r.push(Buffer.from([0x89]));
-
-  r.setEncoding("utf8");
-  const chunks = [];
-  r.on("data", chunk => chunks.push(chunk));
-
-  process.nextTick(() => {
-    expect(chunks).toEqual(["🎉"]);
-    done();
-  });
-});
-
-test("Call .setEncoding() while the buffer contains an incomplete character, and finish the character later", done => {
-  const r = new Readable({ read() {} });
-
-  r.push(Buffer.from([0xf0]));
-  r.push(Buffer.from([0x9f]));
-
-  r.setEncoding("utf8");
-
-  r.push(Buffer.from([0x8e]));
-  r.push(Buffer.from([0x89]));
-
-  const chunks = [];
-  r.on("data", chunk => chunks.push(chunk));
-
-  process.nextTick(() => {
-    expect(chunks).toEqual(["🎉"]);
-    done();
-  });
-});
-
-//<#END_FILE: test-stream-readable-setEncoding-existing-buffers.js
diff --git a/test/js/node/test/parallel/stream-readable-with-unimplemented-_read.test.js b/test/js/node/test/parallel/stream-readable-with-unimplemented-_read.test.js
deleted file mode 100644
index 4160e39091..0000000000
--- a/test/js/node/test/parallel/stream-readable-with-unimplemented-_read.test.js
+++ /dev/null
@@ -1,26 +0,0 @@
-//#FILE: test-stream-readable-with-unimplemented-_read.js
-//#SHA1: ba318da76b4c594580f62650bad861933a59c215
-//-----------------
-"use strict";
-const { Readable } = require("stream");
-
-test("Readable stream with unimplemented _read method", done => {
-  const readable = new Readable();
-
-  readable.read();
-  readable.on("error", error => {
-    expect(error).toEqual(
-      expect.objectContaining({
-        code: "ERR_METHOD_NOT_IMPLEMENTED",
-        name: "Error",
-        message: expect.any(String),
-      }),
-    );
-  });
-
-  readable.on("close", () => {
-    done();
-  });
-});
-
-//<#END_FILE: test-stream-readable-with-unimplemented-_read.js
diff --git a/test/js/node/test/parallel/stream-transform-callback-twice.test.js b/test/js/node/test/parallel/stream-transform-callback-twice.test.js
deleted file mode 100644
index 3be1a53af3..0000000000
--- a/test/js/node/test/parallel/stream-transform-callback-twice.test.js
+++ /dev/null
@@ -1,28 +0,0 @@
-//#FILE: test-stream-transform-callback-twice.js
-//#SHA1: f2ad2048f83461d93a84b8b5696230beb4dba9f2
-//-----------------
-"use strict";
-
-const { Transform } = require("stream");
-
-test("Transform stream callback called twice", done => {
-  const stream = new Transform({
-    transform(chunk, enc, cb) {
-      cb();
-      cb();
-    },
-  });
-
-  stream.on("error", error => {
-    expect(error).toMatchObject({
-      name: "Error",
-      code: "ERR_MULTIPLE_CALLBACK",
-      message: expect.any(String),
-    });
-    done();
-  });
-
-  stream.write("foo");
-});
-
-//<#END_FILE: test-stream-transform-callback-twice.js
diff --git a/test/js/node/test/parallel/stream-transform-constructor-set-methods.test.js b/test/js/node/test/parallel/stream-transform-constructor-set-methods.test.js
deleted file mode 100644
index ec66e53654..0000000000
--- a/test/js/node/test/parallel/stream-transform-constructor-set-methods.test.js
+++ /dev/null
@@ -1,53 +0,0 @@
-//#FILE: test-stream-transform-constructor-set-methods.js
-//#SHA1: a827edab0555cd9f8bd240738812b4d6a48b4e7d
-//-----------------
-"use strict";
-
-const { Transform } = require("stream");
-
-test("Transform constructor throws when _transform is not implemented", () => {
-  const t = new Transform();
-
-  expect(() => {
-    t.end(Buffer.from("blerg"));
-  }).toThrow(
-    expect.objectContaining({
-      name: "Error",
-      code: "ERR_METHOD_NOT_IMPLEMENTED",
-      message: expect.any(String),
-    }),
-  );
-});
-
-test("Transform constructor sets methods correctly", () => {
-  const _transform = jest.fn((chunk, _, next) => {
-    next();
-  });
-
-  const _final = jest.fn(next => {
-    next();
-  });
-
-  const _flush = jest.fn(next => {
-    next();
-  });
-
-  const t2 = new Transform({
-    transform: _transform,
-    flush: _flush,
-    final: _final,
-  });
-
-  expect(t2._transform).toBe(_transform);
-  expect(t2._flush).toBe(_flush);
-  expect(t2._final).toBe(_final);
-
-  t2.end(Buffer.from("blerg"));
-  t2.resume();
-
-  expect(_transform).toHaveBeenCalled();
-  expect(_final).toHaveBeenCalled();
-  expect(_flush).toHaveBeenCalled();
-});
-
-//<#END_FILE: test-stream-transform-constructor-set-methods.js
diff --git a/test/js/node/test/parallel/stream-transform-flush-data.test.js b/test/js/node/test/parallel/stream-transform-flush-data.test.js
deleted file mode 100644
index 6bd8e013c0..0000000000
--- a/test/js/node/test/parallel/stream-transform-flush-data.test.js
+++ /dev/null
@@ -1,31 +0,0 @@
-//#FILE: test-stream-transform-flush-data.js
-//#SHA1: 04d0db2bec19ea79b0914db96fd2c996ab8d67bd
-//-----------------
-"use strict";
-
-const { Transform } = require("stream");
-
-test("Transform flush should emit expected data", done => {
-  const expected = "asdf";
-
-  function _transform(d, e, n) {
-    n();
-  }
-
-  function _flush(n) {
-    n(null, expected);
-  }
-
-  const t = new Transform({
-    transform: _transform,
-    flush: _flush,
-  });
-
-  t.end(Buffer.from("blerg"));
-  t.on("data", data => {
-    expect(data.toString()).toBe(expected);
-    done();
-  });
-});
-
-//<#END_FILE: test-stream-transform-flush-data.js
diff --git a/test/js/node/test/parallel/stream-unpipe-event.test.js b/test/js/node/test/parallel/stream-unpipe-event.test.js
deleted file mode 100644
index 7ad2afc486..0000000000
--- a/test/js/node/test/parallel/stream-unpipe-event.test.js
+++ /dev/null
@@ -1,140 +0,0 @@
-//#FILE: test-stream-unpipe-event.js
-//#SHA1: 17303ffe85d8760f81f6294d9004c98638985bd6
-//-----------------
-"use strict";
-
-const { Writable, Readable } = require("stream");
-
-class NullWriteable extends Writable {
-  _write(chunk, encoding, callback) {
-    return callback();
-  }
-}
-
-class QuickEndReadable extends Readable {
-  _read() {
-    this.push(null);
-  }
-}
-
-class NeverEndReadable extends Readable {
-  _read() {}
-}
-
-test("QuickEndReadable pipes and unpipes", done => {
-  const dest = new NullWriteable();
-  const src = new QuickEndReadable();
-  const pipeSpy = jest.fn();
-  const unpipeSpy = jest.fn();
-
-  dest.on("pipe", pipeSpy);
-  dest.on("unpipe", unpipeSpy);
-
-  src.pipe(dest);
-
-  setImmediate(() => {
-    expect(pipeSpy).toHaveBeenCalledTimes(1);
-    expect(unpipeSpy).toHaveBeenCalledTimes(1);
-    expect(src._readableState.pipes.length).toBe(0);
-    done();
-  });
-});
-
-test("NeverEndReadable pipes but does not unpipe", done => {
-  const dest = new NullWriteable();
-  const src = new NeverEndReadable();
-  const pipeSpy = jest.fn();
-  const unpipeSpy = jest.fn();
-
-  dest.on("pipe", pipeSpy);
-  dest.on("unpipe", unpipeSpy);
-
-  src.pipe(dest);
-
-  setImmediate(() => {
-    expect(pipeSpy).toHaveBeenCalledTimes(1);
-    expect(unpipeSpy).not.toHaveBeenCalled();
-    expect(src._readableState.pipes.length).toBe(1);
-    done();
-  });
-});
-
-test("NeverEndReadable pipes and manually unpipes", done => {
-  const dest = new NullWriteable();
-  const src = new NeverEndReadable();
-  const pipeSpy = jest.fn();
-  const unpipeSpy = jest.fn();
-
-  dest.on("pipe", pipeSpy);
-  dest.on("unpipe", unpipeSpy);
-
-  src.pipe(dest);
-  src.unpipe(dest);
-
-  setImmediate(() => {
-    expect(pipeSpy).toHaveBeenCalledTimes(1);
-    expect(unpipeSpy).toHaveBeenCalledTimes(1);
-    expect(src._readableState.pipes.length).toBe(0);
-    done();
-  });
-});
-
-test("QuickEndReadable pipes and unpipes with end: false", done => {
-  const dest = new NullWriteable();
-  const src = new QuickEndReadable();
-  const pipeSpy = jest.fn();
-  const unpipeSpy = jest.fn();
-
-  dest.on("pipe", pipeSpy);
-  dest.on("unpipe", unpipeSpy);
-
-  src.pipe(dest, { end: false });
-
-  setImmediate(() => {
-    expect(pipeSpy).toHaveBeenCalledTimes(1);
-    expect(unpipeSpy).toHaveBeenCalledTimes(1);
-    expect(src._readableState.pipes.length).toBe(0);
-    done();
-  });
-});
-
-test("NeverEndReadable pipes but does not unpipe with end: false", done => {
-  const dest = new NullWriteable();
-  const src = new NeverEndReadable();
-  const pipeSpy = jest.fn();
-  const unpipeSpy = jest.fn();
-
-  dest.on("pipe", pipeSpy);
-  dest.on("unpipe", unpipeSpy);
-
-  src.pipe(dest, { end: false });
-
-  setImmediate(() => {
-    expect(pipeSpy).toHaveBeenCalledTimes(1);
-    expect(unpipeSpy).not.toHaveBeenCalled();
-    expect(src._readableState.pipes.length).toBe(1);
-    done();
-  });
-});
-
-test("NeverEndReadable pipes and manually unpipes with end: false", done => {
-  const dest = new NullWriteable();
-  const src = new NeverEndReadable();
-  const pipeSpy = jest.fn();
-  const unpipeSpy = jest.fn();
-
-  dest.on("pipe", pipeSpy);
-  dest.on("unpipe", unpipeSpy);
-
-  src.pipe(dest, { end: false });
-  src.unpipe(dest);
-
-  setImmediate(() => {
-    expect(pipeSpy).toHaveBeenCalledTimes(1);
-    expect(unpipeSpy).toHaveBeenCalledTimes(1);
-    expect(src._readableState.pipes.length).toBe(0);
-    done();
-  });
-});
-
-//<#END_FILE: test-stream-unpipe-event.js
diff --git a/test/js/node/test/parallel/stream-unshift-read-race.test.js b/test/js/node/test/parallel/stream-unshift-read-race.test.js
deleted file mode 100644
index 9a03dbb0f0..0000000000
--- a/test/js/node/test/parallel/stream-unshift-read-race.test.js
+++ /dev/null
@@ -1,141 +0,0 @@
-//#FILE: test-stream-unshift-read-race.js
-//#SHA1: 3b6a1e1b0ae4b58251211a49cd8171569cfd86ed
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const stream = require("stream");
-
-// This test verifies that:
-// 1. unshift() does not cause colliding _read() calls.
-// 2. unshift() after the 'end' event is an error, but after the EOF
-//    signalling null, it is ok, and just creates a new readable chunk.
-// 3. push() after the EOF signaling null is an error.
-// 4. _read() is not called after pushing the EOF null chunk.
-
-test("stream unshift read race", done => {
-  const hwm = 10;
-  const r = stream.Readable({ highWaterMark: hwm, autoDestroy: false });
-  const chunks = 10;
-
-  const data = Buffer.allocUnsafe(chunks * hwm + Math.ceil(hwm / 2));
-  for (let i = 0; i < data.length; i++) {
-    const c = "asdf".charCodeAt(i % 4);
-    data[i] = c;
-  }
-
-  let pos = 0;
-  let pushedNull = false;
-  r._read = function (n) {
-    expect(pushedNull).toBe(false);
-
-    // Every third chunk is fast
-    push(!(chunks % 3));
-
-    function push(fast) {
-      expect(pushedNull).toBe(false);
-      const c = pos >= data.length ? null : data.slice(pos, pos + n);
-      pushedNull = c === null;
-      if (fast) {
-        pos += n;
-        r.push(c);
-        if (c === null) pushError();
-      } else {
-        setTimeout(function () {
-          pos += n;
-          r.push(c);
-          if (c === null) pushError();
-        }, 1);
-      }
-    }
-  };
-
-  function pushError() {
-    r.unshift(Buffer.allocUnsafe(1));
-    w.end();
-
-    expect(() => {
-      r.push(Buffer.allocUnsafe(1));
-    }).toThrow(
-      expect.objectContaining({
-        code: "ERR_STREAM_PUSH_AFTER_EOF",
-        name: "Error",
-        message: expect.any(String),
-      }),
-    );
-  }
-
-  const w = stream.Writable();
-  const written = [];
-  w._write = function (chunk, encoding, cb) {
-    written.push(chunk.toString());
-    cb();
-  };
-
-  r.on("end", () => {
-    throw new Error("end event should not be emitted");
-  });
-
-  r.on("readable", function () {
-    let chunk;
-    while (null !== (chunk = r.read(10))) {
-      w.write(chunk);
-      if (chunk.length > 4) r.unshift(Buffer.from("1234"));
-    }
-  });
-
-  w.on("finish", () => {
-    // Each chunk should start with 1234, and then be asfdasdfasdf...
-    // The first got pulled out before the first unshift('1234'), so it's
-    // lacking that piece.
-    expect(written[0]).toBe("asdfasdfas");
-    let asdf = "d";
-    console.error(`0: ${written[0]}`);
-    for (let i = 1; i < written.length; i++) {
-      console.error(`${i.toString(32)}: ${written[i]}`);
-      expect(written[i].slice(0, 4)).toBe("1234");
-      for (let j = 4; j < written[i].length; j++) {
-        const c = written[i].charAt(j);
-        expect(c).toBe(asdf);
-        switch (asdf) {
-          case "a":
-            asdf = "s";
-            break;
-          case "s":
-            asdf = "d";
-            break;
-          case "d":
-            asdf = "f";
-            break;
-          case "f":
-            asdf = "a";
-            break;
-        }
-      }
-    }
-    expect(written).toHaveLength(18);
-    console.log("ok");
-    done();
-  });
-});
-
-//<#END_FILE: test-stream-unshift-read-race.js
diff --git a/test/js/node/test/parallel/stream-wrap.test.js b/test/js/node/test/parallel/stream-wrap.test.js
deleted file mode 100644
index ab020ef2b1..0000000000
--- a/test/js/node/test/parallel/stream-wrap.test.js
+++ /dev/null
@@ -1,59 +0,0 @@
-//#FILE: test-stream-wrap.js
-//#SHA1: 675a22f043e5a5a38cdd7fff376f269f8d341aab
-//-----------------
-"use strict";
-
-const { Duplex } = require("stream");
-
-// Remove internal bindings and StreamWrap import as they're not accessible in a normal environment
-// We'll mock the necessary functionality instead
-
-test("StreamWrap shutdown behavior", done => {
-  const stream = new Duplex({
-    read: function () {},
-    write: function () {},
-  });
-
-  // Mock StreamWrap
-  class MockStreamWrap {
-    constructor(stream) {
-      this.stream = stream;
-      this._handle = {
-        shutdown: jest.fn(req => {
-          // Simulate async completion with error
-          process.nextTick(() => {
-            req.oncomplete(-1);
-          });
-        }),
-      };
-    }
-
-    destroy() {
-      // Simulate handle closure
-    }
-  }
-
-  // Mock ShutdownWrap
-  class MockShutdownWrap {
-    oncomplete = null;
-  }
-
-  function testShutdown(callback) {
-    const wrap = new MockStreamWrap(stream);
-
-    const req = new MockShutdownWrap();
-    req.oncomplete = function (code) {
-      expect(code).toBeLessThan(0);
-      callback();
-    };
-    req.handle = wrap._handle;
-
-    // Close the handle to simulate
-    wrap.destroy();
-    req.handle.shutdown(req);
-  }
-
-  testShutdown(done);
-});
-
-//<#END_FILE: test-stream-wrap.js
diff --git a/test/js/node/test/parallel/stream-writable-aborted.test.js b/test/js/node/test/parallel/stream-writable-aborted.test.js
deleted file mode 100644
index 82c4be4233..0000000000
--- a/test/js/node/test/parallel/stream-writable-aborted.test.js
+++ /dev/null
@@ -1,29 +0,0 @@
-//#FILE: test-stream-writable-aborted.js
-//#SHA1: be315bbc27ad16f13bb6b3022e864c8902265391
-//-----------------
-"use strict";
-
-const { Writable } = require("stream");
-
-describe("Writable stream aborted property", () => {
-  test("writableAborted is false initially and true after destroy", () => {
-    const writable = new Writable({
-      write() {},
-    });
-    expect(writable.writableAborted).toBe(false);
-    writable.destroy();
-    expect(writable.writableAborted).toBe(true);
-  });
-
-  test("writableAborted is false initially and true after end and destroy", () => {
-    const writable = new Writable({
-      write() {},
-    });
-    expect(writable.writableAborted).toBe(false);
-    writable.end();
-    writable.destroy();
-    expect(writable.writableAborted).toBe(true);
-  });
-});
-
-//<#END_FILE: test-stream-writable-aborted.js
diff --git a/test/js/node/test/parallel/stream-writable-change-default-encoding.test.js b/test/js/node/test/parallel/stream-writable-change-default-encoding.test.js
deleted file mode 100644
index 0ccbd29ac5..0000000000
--- a/test/js/node/test/parallel/stream-writable-change-default-encoding.test.js
+++ /dev/null
@@ -1,91 +0,0 @@
-//#FILE: test-stream-writable-change-default-encoding.js
-//#SHA1: 7a4e7c22888d4901899fe5a0ed4604c319f73ff9
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const stream = require("stream");
-
-class MyWritable extends stream.Writable {
-  constructor(fn, options) {
-    super(options);
-    this.fn = fn;
-  }
-
-  _write(chunk, encoding, callback) {
-    this.fn(Buffer.isBuffer(chunk), typeof chunk, encoding);
-    callback();
-  }
-}
-
-test("default encoding is utf8", () => {
-  const m = new MyWritable(
-    (isBuffer, type, enc) => {
-      expect(enc).toBe("utf8");
-    },
-    { decodeStrings: false },
-  );
-  m.write("foo");
-  m.end();
-});
-
-test("change default encoding to ascii", () => {
-  const m = new MyWritable(
-    (isBuffer, type, enc) => {
-      expect(enc).toBe("ascii");
-    },
-    { decodeStrings: false },
-  );
-  m.setDefaultEncoding("ascii");
-  m.write("bar");
-  m.end();
-});
-
-test("change default encoding to invalid value", () => {
-  const m = new MyWritable((isBuffer, type, enc) => {}, { decodeStrings: false });
-
-  expect(() => {
-    m.setDefaultEncoding({});
-    m.write("bar");
-    m.end();
-  }).toThrow(
-    expect.objectContaining({
-      name: "TypeError",
-      code: "ERR_UNKNOWN_ENCODING",
-      message: expect.any(String),
-    }),
-  );
-});
-
-test("check variable case encoding", () => {
-  const m = new MyWritable(
-    (isBuffer, type, enc) => {
-      expect(enc).toBe("ascii");
-    },
-    { decodeStrings: false },
-  );
-  m.setDefaultEncoding("AsCii");
-  m.write("bar");
-  m.end();
-});
-
-//<#END_FILE: test-stream-writable-change-default-encoding.js
diff --git a/test/js/node/test/parallel/stream-writable-clear-buffer.test.js b/test/js/node/test/parallel/stream-writable-clear-buffer.test.js
deleted file mode 100644
index 329e26d512..0000000000
--- a/test/js/node/test/parallel/stream-writable-clear-buffer.test.js
+++ /dev/null
@@ -1,42 +0,0 @@
-//#FILE: test-stream-writable-clear-buffer.js
-//#SHA1: 0088292e626fb952c1777f191acee9a6d92d3f4d
-//-----------------
-"use strict";
-
-const Stream = require("stream");
-
-class StreamWritable extends Stream.Writable {
-  constructor() {
-    super({ objectMode: true });
-  }
-
-  // Refs: https://github.com/nodejs/node/issues/6758
-  // We need a timer like on the original issue thread.
-  // Otherwise the code will never reach our test case.
-  _write(chunk, encoding, cb) {
-    setImmediate(cb);
-  }
-}
-
-test("StreamWritable bufferedRequestCount matches actual buffered request count", done => {
-  const testStream = new StreamWritable();
-  testStream.cork();
-
-  const writeOperations = 5;
-  let completedWrites = 0;
-
-  for (let i = 1; i <= writeOperations; i++) {
-    testStream.write(i, () => {
-      expect(testStream._writableState.bufferedRequestCount).toBe(testStream._writableState.getBuffer().length);
-      completedWrites++;
-
-      if (completedWrites === writeOperations) {
-        done();
-      }
-    });
-  }
-
-  testStream.end();
-});
-
-//<#END_FILE: test-stream-writable-clear-buffer.js
diff --git a/test/js/node/test/parallel/stream-writable-constructor-set-methods.test.js b/test/js/node/test/parallel/stream-writable-constructor-set-methods.test.js
deleted file mode 100644
index 932e14afb6..0000000000
--- a/test/js/node/test/parallel/stream-writable-constructor-set-methods.test.js
+++ /dev/null
@@ -1,51 +0,0 @@
-//#FILE: test-stream-writable-constructor-set-methods.js
-//#SHA1: 5610c9523a02a55898e40f7c72a09973affd133f
-//-----------------
-"use strict";
-
-const { Writable } = require("stream");
-
-const bufferBlerg = Buffer.from("blerg");
-
-test("Writable without _write method throws", () => {
-  const w = new Writable();
-
-  expect(() => {
-    w.end(bufferBlerg);
-  }).toThrow(
-    expect.objectContaining({
-      name: "Error",
-      code: "ERR_METHOD_NOT_IMPLEMENTED",
-      message: expect.any(String),
-    }),
-  );
-});
-
-test("Writable with custom write and writev methods", () => {
-  const _write = jest.fn((chunk, _, next) => {
-    next();
-  });
-
-  const _writev = jest.fn((chunks, next) => {
-    expect(chunks.length).toBe(2);
-    next();
-  });
-
-  const w2 = new Writable({ write: _write, writev: _writev });
-
-  expect(w2._write).toBe(_write);
-  expect(w2._writev).toBe(_writev);
-
-  w2.write(bufferBlerg);
-
-  w2.cork();
-  w2.write(bufferBlerg);
-  w2.write(bufferBlerg);
-
-  w2.end();
-
-  expect(_write).toHaveBeenCalledTimes(1);
-  expect(_writev).toHaveBeenCalledTimes(1);
-});
-
-//<#END_FILE: test-stream-writable-constructor-set-methods.js
diff --git a/test/js/node/test/parallel/stream-writable-end-multiple.test.js b/test/js/node/test/parallel/stream-writable-end-multiple.test.js
deleted file mode 100644
index 71b55c8cc7..0000000000
--- a/test/js/node/test/parallel/stream-writable-end-multiple.test.js
+++ /dev/null
@@ -1,46 +0,0 @@
-//#FILE: test-stream-writable-end-multiple.js
-//#SHA1: db58e265a3eb8bdf7dba1cb959979059ba686f6d
-//-----------------
-"use strict";
-
-const stream = require("stream");
-
-test("stream writable end multiple", async () => {
-  const writable = new stream.Writable();
-  writable._write = (chunk, encoding, cb) => {
-    setTimeout(() => cb(), 10);
-  };
-
-  const endCallback1 = jest.fn();
-  const endCallback2 = jest.fn();
-  const finishCallback = jest.fn();
-  const endCallback3 = jest.fn();
-
-  writable.end("testing ended state", endCallback1);
-  writable.end(endCallback2);
-
-  writable.on("finish", finishCallback);
-
-  await new Promise(resolve => setTimeout(resolve, 20));
-
-  expect(endCallback1).toHaveBeenCalledTimes(1);
-  expect(endCallback2).toHaveBeenCalledTimes(1);
-  expect(finishCallback).toHaveBeenCalledTimes(1);
-
-  let ticked = false;
-  writable.end(endCallback3);
-  ticked = true;
-
-  await new Promise(resolve => setTimeout(resolve, 0));
-
-  expect(endCallback3).toHaveBeenCalledTimes(1);
-  expect(endCallback3).toHaveBeenCalledWith(
-    expect.objectContaining({
-      code: "ERR_STREAM_ALREADY_FINISHED",
-      message: expect.any(String),
-    }),
-  );
-  expect(ticked).toBe(true);
-});
-
-//<#END_FILE: test-stream-writable-end-multiple.js
diff --git a/test/js/node/test/parallel/stream-writable-ended-state.test.js b/test/js/node/test/parallel/stream-writable-ended-state.test.js
deleted file mode 100644
index fb6c3d10c6..0000000000
--- a/test/js/node/test/parallel/stream-writable-ended-state.test.js
+++ /dev/null
@@ -1,45 +0,0 @@
-//#FILE: test-stream-writable-ended-state.js
-//#SHA1: e6a35fad059c742def91bd4cab4786faffa26f5b
-//-----------------
-"use strict";
-
-const stream = require("stream");
-
-describe("Stream Writable Ended State", () => {
-  let writable;
-
-  beforeEach(() => {
-    writable = new stream.Writable();
-
-    writable._write = (chunk, encoding, cb) => {
-      expect(writable._writableState.ended).toBe(false);
-      expect(writable._writableState.writable).toBeUndefined();
-      expect(writable.writableEnded).toBe(false);
-      cb();
-    };
-  });
-
-  test("initial state", () => {
-    expect(writable._writableState.ended).toBe(false);
-    expect(writable._writableState.writable).toBeUndefined();
-    expect(writable.writable).toBe(true);
-    expect(writable.writableEnded).toBe(false);
-  });
-
-  test("ended state after end() call", done => {
-    writable.end("testing ended state", () => {
-      expect(writable._writableState.ended).toBe(true);
-      expect(writable._writableState.writable).toBeUndefined();
-      expect(writable.writable).toBe(false);
-      expect(writable.writableEnded).toBe(true);
-      done();
-    });
-
-    expect(writable._writableState.ended).toBe(true);
-    expect(writable._writableState.writable).toBeUndefined();
-    expect(writable.writable).toBe(false);
-    expect(writable.writableEnded).toBe(true);
-  });
-});
-
-//<#END_FILE: test-stream-writable-ended-state.js
diff --git a/test/js/node/test/parallel/stream-writable-final-destroy.test.js b/test/js/node/test/parallel/stream-writable-final-destroy.test.js
deleted file mode 100644
index 0d3b853b3b..0000000000
--- a/test/js/node/test/parallel/stream-writable-final-destroy.test.js
+++ /dev/null
@@ -1,40 +0,0 @@
-//#FILE: test-stream-writable-final-destroy.js
-//#SHA1: 4213d1382f0e5b950211e183a94adc5f3e7a1468
-//-----------------
-"use strict";
-
-const { Writable } = require("stream");
-
-test("Writable stream with final and destroy", () => {
-  const w = new Writable({
-    write(chunk, encoding, callback) {
-      callback(null);
-    },
-    final(callback) {
-      queueMicrotask(callback);
-    },
-  });
-
-  w.end();
-  w.destroy();
-
-  const prefinishSpy = jest.fn();
-  const finishSpy = jest.fn();
-  const closeSpy = jest.fn();
-
-  w.on("prefinish", prefinishSpy);
-  w.on("finish", finishSpy);
-  w.on("close", closeSpy);
-
-  return new Promise(resolve => {
-    // Use setImmediate to ensure all microtasks have been processed
-    setImmediate(() => {
-      expect(prefinishSpy).not.toHaveBeenCalled();
-      expect(finishSpy).not.toHaveBeenCalled();
-      expect(closeSpy).toHaveBeenCalledTimes(1);
-      resolve();
-    });
-  });
-});
-
-//<#END_FILE: test-stream-writable-final-destroy.js
diff --git a/test/js/node/test/parallel/stream-writable-finished-state.test.js b/test/js/node/test/parallel/stream-writable-finished-state.test.js
deleted file mode 100644
index c2d8e8ab49..0000000000
--- a/test/js/node/test/parallel/stream-writable-finished-state.test.js
+++ /dev/null
@@ -1,27 +0,0 @@
-//#FILE: test-stream-writable-finished-state.js
-//#SHA1: e9ea6f7cc3e0262bf187b9cf08e9a054c93d7b5f
-//-----------------
-"use strict";
-
-const stream = require("stream");
-
-test("Writable stream finished state", done => {
-  const writable = new stream.Writable();
-
-  writable._write = (chunk, encoding, cb) => {
-    // The state finished should start in false.
-    expect(writable._writableState.finished).toBe(false);
-    cb();
-  };
-
-  writable.on("finish", () => {
-    expect(writable._writableState.finished).toBe(true);
-  });
-
-  writable.end("testing finished state", () => {
-    expect(writable._writableState.finished).toBe(true);
-    done();
-  });
-});
-
-//<#END_FILE: test-stream-writable-finished-state.js
diff --git a/test/js/node/test/parallel/stream-writable-finished.test.js b/test/js/node/test/parallel/stream-writable-finished.test.js
deleted file mode 100644
index d7db2acf1d..0000000000
--- a/test/js/node/test/parallel/stream-writable-finished.test.js
+++ /dev/null
@@ -1,97 +0,0 @@
-//#FILE: test-stream-writable-finished.js
-//#SHA1: 20d27885cc10a6787d3e6c6fb877c0aba2310f93
-//-----------------
-"use strict";
-
-const { Writable } = require("stream");
-
-// basic
-test("Writable.prototype has writableFinished", () => {
-  expect(Object.hasOwn(Writable.prototype, "writableFinished")).toBe(true);
-});
-
-// event
-test("writableFinished state changes correctly", done => {
-  const writable = new Writable();
-
-  writable._write = (chunk, encoding, cb) => {
-    // The state finished should start in false.
-    expect(writable.writableFinished).toBe(false);
-    cb();
-  };
-
-  writable.on("finish", () => {
-    expect(writable.writableFinished).toBe(true);
-    done();
-  });
-
-  writable.end("testing finished state", () => {
-    expect(writable.writableFinished).toBe(true);
-  });
-});
-
-test("Emit finish asynchronously", done => {
-  const w = new Writable({
-    write(chunk, encoding, cb) {
-      cb();
-    },
-  });
-
-  w.end();
-  w.on("finish", done);
-});
-
-test("Emit prefinish synchronously", () => {
-  const w = new Writable({
-    write(chunk, encoding, cb) {
-      cb();
-    },
-  });
-
-  let sync = true;
-  w.on("prefinish", () => {
-    expect(sync).toBe(true);
-  });
-  w.end();
-  sync = false;
-});
-
-test("Emit prefinish synchronously w/ final", () => {
-  const w = new Writable({
-    write(chunk, encoding, cb) {
-      cb();
-    },
-    final(cb) {
-      cb();
-    },
-  });
-
-  let sync = true;
-  w.on("prefinish", () => {
-    expect(sync).toBe(true);
-  });
-  w.end();
-  sync = false;
-});
-
-test("Call _final synchronously", () => {
-  let sync = true;
-  const finalMock = jest.fn(cb => {
-    expect(sync).toBe(true);
-    cb();
-  });
-
-  const w = new Writable({
-    write(chunk, encoding, cb) {
-      cb();
-    },
-    final: finalMock,
-  });
-
-  w.end();
-  sync = false;
-
-  expect(finalMock).toHaveBeenCalledTimes(1);
-});
-
-//<#END_FILE: test-stream-writable-finished.js
diff --git a/test/js/node/test/parallel/stream-writable-invalid-chunk.test.js b/test/js/node/test/parallel/stream-writable-invalid-chunk.test.js
deleted file mode 100644
index 259e993173..0000000000
--- a/test/js/node/test/parallel/stream-writable-invalid-chunk.test.js
+++ /dev/null
@@ -1,53 +0,0 @@
-//#FILE: test-stream-writable-invalid-chunk.js
-//#SHA1: 8febb7872aa1c8bfb7ebcb33db7a5fcd2903b2bd
-//-----------------
-"use strict";
-
-const stream = require("stream");
-
-function testWriteType(val, objectMode, code) {
-  const writable = new stream.Writable({
-    objectMode,
-    write: () => {},
-  });
-
-  const writeOperation = () => writable.write(val);
-
-  if (code) {
-    expect(writeOperation).toThrow(
-      expect.objectContaining({
-        code,
-        message: expect.any(String),
-      }),
-    );
-  } else {
-    expect(writeOperation).not.toThrow();
-  }
-}
-
-describe("Writable stream invalid chunk tests", () => {
-  test("non-object mode invalid types", () => {
-    testWriteType([], false, "ERR_INVALID_ARG_TYPE");
-    testWriteType({}, false, "ERR_INVALID_ARG_TYPE");
-    testWriteType(0, false, "ERR_INVALID_ARG_TYPE");
-    testWriteType(true, false, "ERR_INVALID_ARG_TYPE");
-    testWriteType(0.0, false, "ERR_INVALID_ARG_TYPE");
-    testWriteType(undefined, false, "ERR_INVALID_ARG_TYPE");
-    testWriteType(null, false, "ERR_STREAM_NULL_VALUES");
-  });
-
-  test("object mode valid types", () => {
-    testWriteType([], true);
-    testWriteType({}, true);
-    testWriteType(0, true);
-    testWriteType(true, true);
-    testWriteType(0.0, true);
-    testWriteType(undefined, true);
-  });
-
-  test("object mode null value", () => {
-    testWriteType(null, true, "ERR_STREAM_NULL_VALUES");
-  });
-});
-
-//<#END_FILE: test-stream-writable-invalid-chunk.js
diff --git a/test/js/node/test/parallel/stream-writable-needdrain-state.test.js b/test/js/node/test/parallel/stream-writable-needdrain-state.test.js
deleted file mode 100644
index 3cac2829fa..0000000000
--- a/test/js/node/test/parallel/stream-writable-needdrain-state.test.js
+++ /dev/null
@@ -1,31 +0,0 @@
-//#FILE: test-stream-writable-needdrain-state.js
-//#SHA1: c73d65b940e3ea2fe9c94d9c9d0d4ffe36c47397
-//-----------------
-"use strict";
-
-const stream = require("stream");
-
-test("Transform stream needDrain state", done => {
-  const transform = new stream.Transform({
-    transform: _transform,
-    highWaterMark: 1,
-  });
-
-  function _transform(chunk, encoding, cb) {
-    process.nextTick(() => {
-      expect(transform._writableState.needDrain).toBe(true);
-      cb();
-    });
-  }
-
-  expect(transform._writableState.needDrain).toBe(false);
-
-  transform.write("asdasd", () => {
-    expect(transform._writableState.needDrain).toBe(false);
-    done();
-  });
-
-  expect(transform._writableState.needDrain).toBe(true);
-});
-
-//<#END_FILE: test-stream-writable-needdrain-state.js
diff --git a/test/js/node/test/parallel/stream-writable-null.test.js b/test/js/node/test/parallel/stream-writable-null.test.js
deleted file mode 100644
index 6f747df705..0000000000
--- a/test/js/node/test/parallel/stream-writable-null.test.js
+++ /dev/null
@@ -1,58 +0,0 @@
-//#FILE: test-stream-writable-null.js
-//#SHA1: 5a080b117b05a98d0b7bf6895b554892c2690ed8
-//-----------------
-"use strict";
-
-const stream = require("stream");
-
-class MyWritable extends stream.Writable {
-  constructor(options) {
-    super({ autoDestroy: false, ...options });
-  }
-  _write(chunk, encoding, callback) {
-    expect(chunk).not.toBe(null);
-    callback();
-  }
-}
-
-test("MyWritable throws on null in object mode", () => {
-  const m = new MyWritable({ objectMode: true });
-  expect(() => {
-    m.write(null);
-  }).toThrow(
-    expect.objectContaining({
-      code: "ERR_STREAM_NULL_VALUES",
-    }),
-  );
-});
-
-test("MyWritable throws on false in non-object mode", () => {
-  const m = new MyWritable();
-  expect(() => {
-    m.write(false);
-  }).toThrow(
-    expect.objectContaining({
-      code: "ERR_INVALID_ARG_TYPE",
-    }),
-  );
-});
-
-test("MyWritable should not throw on false in object mode", done => {
-  const m = new MyWritable({ objectMode: true });
-  m.write(false, err => {
-    expect(err).toBeFalsy();
-    done();
-  });
-});
-
-test("MyWritable should not throw or emit error on false in object mode", done => {
-  const m = new MyWritable({ objectMode: true }).on("error", e => {
-    done(e || new Error("should not get here"));
-  });
-  m.write(false, err => {
-    expect(err).toBeFalsy();
-    done();
-  });
-});
-
-//<#END_FILE: test-stream-writable-null.js
diff --git a/test/js/node/test/parallel/stream-writable-properties.test.js b/test/js/node/test/parallel/stream-writable-properties.test.js
deleted file mode 100644
index 86bf40656b..0000000000
--- a/test/js/node/test/parallel/stream-writable-properties.test.js
+++ /dev/null
@@ -1,34 +0,0 @@
-//#FILE: test-stream-writable-properties.js
-//#SHA1: 3af7ed348fc81b0a70901cb29735a8778d0a8875
-//-----------------
-"use strict";
-
-const { Writable } = require("stream");
-
-describe("Writable stream properties", () => {
-  test("writableCorked property", () => {
-    const w = new Writable();
-
-    expect(w.writableCorked).toBe(0);
-
-    w.uncork();
-    expect(w.writableCorked).toBe(0);
-
-    w.cork();
-    expect(w.writableCorked).toBe(1);
-
-    w.cork();
-    expect(w.writableCorked).toBe(2);
-
-    w.uncork();
-    expect(w.writableCorked).toBe(1);
-
-    w.uncork();
-    expect(w.writableCorked).toBe(0);
-
-    w.uncork();
-    expect(w.writableCorked).toBe(0);
-  });
-});
-
-//<#END_FILE: test-stream-writable-properties.js
diff --git a/test/js/node/test/parallel/stream-writable-write-error.test.js b/test/js/node/test/parallel/stream-writable-write-error.test.js
deleted file mode 100644
index 6c4a7d0b51..0000000000
--- a/test/js/node/test/parallel/stream-writable-write-error.test.js
+++ /dev/null
@@ -1,88 +0,0 @@
-//#FILE: test-stream-writable-write-error.js
-//#SHA1: 16053b21f2a6c80ae69ae55424550e7213f1f868
-//-----------------
-"use strict";
-
-const { Writable } = require("stream");
-
-function expectError(w, args, code, sync) {
-  if (sync) {
-    if (code) {
-      expect(() => w.write(...args)).toThrow(
-        expect.objectContaining({
-          code,
-          message: expect.any(String),
-        }),
-      );
-    } else {
-      w.write(...args);
-    }
-  } else {
-    let errorCalled = false;
-    let ticked = false;
-    w.write(...args, err => {
-      expect(ticked).toBe(true);
-      expect(errorCalled).toBe(false);
-      expect(err.code).toBe(code);
-    });
-    ticked = true;
-    w.on("error", err => {
-      errorCalled = true;
-      expect(err.code).toBe(code);
-    });
-  }
-}
-
-function runTest(autoDestroy) {
-  test("write after end", () => {
-    const w = new Writable({
-      autoDestroy,
-      write() {},
-    });
-    w.end();
-    expectError(w, ["asd"], "ERR_STREAM_WRITE_AFTER_END");
-  });
-
-  test("write after destroy", () => {
-    const w = new Writable({
-      autoDestroy,
-      write() {},
-    });
-    w.destroy();
-  });
-
-  test("write null values", () => {
-    const w = new Writable({
-      autoDestroy,
-      write() {},
-    });
-    expectError(w, [null], "ERR_STREAM_NULL_VALUES", true);
-  });
-
-  test("write invalid arg type", () => {
-    const w = new Writable({
-      autoDestroy,
-      write() {},
-    });
-    expectError(w, [{}], "ERR_INVALID_ARG_TYPE", true);
-  });
-
-  test("write with unknown encoding", () => {
-    const w = new Writable({
-      decodeStrings: false,
-      autoDestroy,
-      write() {},
-    });
-    expectError(w, ["asd", "noencoding"], "ERR_UNKNOWN_ENCODING", true);
-  });
-}
-
-describe("Writable stream write errors (autoDestroy: false)", () => {
-  runTest(false);
-});
-
-describe("Writable stream write errors (autoDestroy: true)", () => {
-  runTest(true);
-});
-
-//<#END_FILE: test-stream-writable-write-error.js
diff --git a/test/js/node/test/parallel/stream-writablestate-ending.test.js b/test/js/node/test/parallel/stream-writablestate-ending.test.js
deleted file mode 100644
index 43063afed8..0000000000
--- a/test/js/node/test/parallel/stream-writablestate-ending.test.js
+++ /dev/null
@@ -1,48 +0,0 @@
-//#FILE: test-stream-writableState-ending.js
-//#SHA1: 97f5685bff2d1c4507caed842006d83c7317e0c0
-//-----------------
-"use strict";
-
-const stream = require("stream");
-
-describe("Writable Stream State", () => {
-  let writable;
-
-  beforeEach(() => {
-    writable = new stream.Writable();
-  });
-
-  function testStates(ending, finished, ended) {
-    expect(writable._writableState.ending).toBe(ending);
-    expect(writable._writableState.finished).toBe(finished);
-    expect(writable._writableState.ended).toBe(ended);
-  }
-
-  test("Writable state transitions", done => {
-    writable._write = (chunk, encoding, cb) => {
-      // Ending, finished, ended start in false.
-      testStates(false, false, false);
-      cb();
-    };
-
-    writable.on("finish", () => {
-      // Ending, finished, ended = true.
-      testStates(true, true, true);
-      done();
-    });
-
-    const result = writable.end("testing function end()", () => {
-      // Ending, finished, ended = true.
-      testStates(true, true, true);
-    });
-
-    // End returns the writable instance
-    expect(result).toBe(writable);
-
-    // Ending, ended = true.
-    // finished = false.
-    testStates(true, false, true);
-  });
-});
-
-//<#END_FILE: test-stream-writableState-ending.js
diff --git a/test/js/node/test/parallel/stream-writablestate-uncorked-bufferedrequestcount.test.js b/test/js/node/test/parallel/stream-writablestate-uncorked-bufferedrequestcount.test.js
deleted file mode 100644
index 7a9e5b4db1..0000000000
--- a/test/js/node/test/parallel/stream-writablestate-uncorked-bufferedrequestcount.test.js
+++ /dev/null
@@ -1,71 +0,0 @@
-//#FILE: test-stream-writableState-uncorked-bufferedRequestCount.js
-//#SHA1: 39a95157551d47517d4c7aa46d1806b5dbccebcf
-//-----------------
-"use strict";
-
-const stream = require("stream");
-
-describe("Writable stream corking and uncorking", () => {
-  let writable;
-
-  beforeEach(() => {
-    writable = new stream.Writable();
-
-    writable._writev = jest.fn((chunks, cb) => {
-      expect(chunks.length).toBe(2);
-      cb();
-    });
-
-    writable._write = jest.fn((chunk, encoding, cb) => {
-      cb();
-    });
-  });
-
-  test("corking and uncorking behavior", done => {
-    // first cork
-    writable.cork();
-    expect(writable._writableState.corked).toBe(1);
-    expect(writable._writableState.bufferedRequestCount).toBe(0);
-
-    // cork again
-    writable.cork();
-    expect(writable._writableState.corked).toBe(2);
-
-    // The first chunk is buffered
-    writable.write("first chunk");
-    expect(writable._writableState.bufferedRequestCount).toBe(1);
-
-    // First uncork does nothing
-    writable.uncork();
-    expect(writable._writableState.corked).toBe(1);
-    expect(writable._writableState.bufferedRequestCount).toBe(1);
-
-    process.nextTick(() => {
-      // The second chunk is buffered, because we uncork at the end of tick
-      writable.write("second chunk");
-      expect(writable._writableState.corked).toBe(1);
-      expect(writable._writableState.bufferedRequestCount).toBe(2);
-
-      // Second uncork flushes the buffer
-      writable.uncork();
-      expect(writable._writableState.corked).toBe(0);
-      expect(writable._writableState.bufferedRequestCount).toBe(0);
-
-      // Verify that end() uncorks correctly
-      writable.cork();
-      writable.write("third chunk");
-      writable.end();
-
-      // End causes an uncork() as well
-      expect(writable._writableState.corked).toBe(0);
-      expect(writable._writableState.bufferedRequestCount).toBe(0);
-
-      expect(writable._writev).toHaveBeenCalledTimes(1);
-      expect(writable._write).toHaveBeenCalledTimes(1);
-
-      done();
-    });
-  });
-});
-
-//<#END_FILE: test-stream-writableState-uncorked-bufferedRequestCount.js
diff --git a/test/js/node/test/parallel/stream-write-destroy.test.js b/test/js/node/test/parallel/stream-write-destroy.test.js
deleted file mode 100644
index 4fd760ef04..0000000000
--- a/test/js/node/test/parallel/stream-write-destroy.test.js
+++ /dev/null
@@ -1,70 +0,0 @@
-//#FILE: test-stream-write-destroy.js
-//#SHA1: d39354900702b56f19b37407f2e8459ca063fbd6
-//-----------------
-"use strict";
-
-const { Writable } = require("stream");
-
-// Test interaction between calling .destroy() on a writable and pending
-// writes.
-
-describe("Stream write and destroy interaction", () => {
-  for (const withPendingData of [false, true]) {
-    for (const useEnd of [false, true]) {
-      test(`withPendingData: ${withPendingData}, useEnd: ${useEnd}`, () => {
-        const callbacks = [];
-
-        const w = new Writable({
-          write(data, enc, cb) {
-            callbacks.push(cb);
-          },
-          // Effectively disable the HWM to observe 'drain' events more easily.
-          highWaterMark: 1,
-        });
-
-        let chunksWritten = 0;
-        let drains = 0;
-        w.on("drain", () => drains++);
-
-        function onWrite(err) {
-          if (err) {
-            expect(w.destroyed).toBe(true);
-            expect(err.code).toBe("ERR_STREAM_DESTROYED");
-          } else {
-            chunksWritten++;
-          }
-        }
-
-        w.write("abc", onWrite);
-        expect(chunksWritten).toBe(0);
-        expect(drains).toBe(0);
-        callbacks.shift()();
-        expect(chunksWritten).toBe(1);
-        expect(drains).toBe(1);
-
-        if (withPendingData) {
-          // Test 2 cases: There either is or is not data still in the write queue.
-          // (The second write will never actually get executed either way.)
-          w.write("def", onWrite);
-        }
-        if (useEnd) {
-          // Again, test 2 cases: Either we indicate that we want to end the
-          // writable or not.
-          w.end("ghi", onWrite);
-        } else {
-          w.write("ghi", onWrite);
-        }
-
-        expect(chunksWritten).toBe(1);
-        w.destroy();
-        expect(chunksWritten).toBe(1);
-        callbacks.shift()();
-        expect(chunksWritten).toBe(useEnd && !withPendingData ? 1 : 2);
-        expect(callbacks.length).toBe(0);
-        expect(drains).toBe(1);
-      });
-    }
-  }
-});
-
-//<#END_FILE: test-stream-write-destroy.js
diff --git a/test/js/node/test/parallel/stream-write-drain.test.js b/test/js/node/test/parallel/stream-write-drain.test.js
deleted file mode 100644
index d0c89e4302..0000000000
--- a/test/js/node/test/parallel/stream-write-drain.test.js
+++ /dev/null
@@ -1,30 +0,0 @@
-//#FILE: test-stream-write-drain.js
-//#SHA1: 893708699284e105a409388953fae28a836370b2
-//-----------------
-"use strict";
-const { Writable } = require("stream");
-
-// Don't emit 'drain' if ended
-
-test("Writable stream should not emit 'drain' if ended", done => {
-  const w = new Writable({
-    write(data, enc, cb) {
-      process.nextTick(cb);
-    },
-    highWaterMark: 1,
-  });
-
-  const drainSpy = jest.fn();
-  w.on("drain", drainSpy);
-
-  w.write("asd");
-  w.end();
-
-  // Use process.nextTick to ensure that any potential 'drain' event would have been emitted
-  process.nextTick(() => {
-    expect(drainSpy).not.toHaveBeenCalled();
-    done();
-  });
-});
-
-//<#END_FILE: test-stream-write-drain.js
diff --git a/test/js/node/test/parallel/stream2-base64-single-char-read-end.test.js b/test/js/node/test/parallel/stream2-base64-single-char-read-end.test.js
deleted file mode 100644
index bcaae8e2bc..0000000000
--- a/test/js/node/test/parallel/stream2-base64-single-char-read-end.test.js
+++ /dev/null
@@ -1,65 +0,0 @@
-//#FILE: test-stream2-base64-single-char-read-end.js
-//#SHA1: 7d3b8e9ad3f47e915bc265658c0b5639fa4a68cd
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const { Readable: R, Writable: W } = require("stream");
-
-test("stream2 base64 single char read end", async () => {
-  const src = new R({ encoding: "base64" });
-  const dst = new W();
-  let hasRead = false;
-  const accum = [];
-
-  src._read = function (n) {
-    if (!hasRead) {
-      hasRead = true;
-      process.nextTick(function () {
-        src.push(Buffer.from("1"));
-        src.push(null);
-      });
-    }
-  };
-
-  dst._write = function (chunk, enc, cb) {
-    accum.push(chunk);
-    cb();
-  };
-
-  const endPromise = new Promise(resolve => {
-    src.on("end", resolve);
-  });
-
-  src.pipe(dst);
-
-  await Promise.race([
-    endPromise,
-    new Promise((_, reject) => {
-      setTimeout(() => reject(new Error("timed out waiting for _write")), 100);
-    }),
-  ]);
-
-  expect(String(Buffer.concat(accum))).toBe("MQ==");
-});
-
-//<#END_FILE: test-stream2-base64-single-char-read-end.js
diff --git a/test/js/node/test/parallel/stream2-compatibility.test.js b/test/js/node/test/parallel/stream2-compatibility.test.js
deleted file mode 100644
index a06395efa9..0000000000
--- a/test/js/node/test/parallel/stream2-compatibility.test.js
+++ /dev/null
@@ -1,81 +0,0 @@
-//#FILE: test-stream2-compatibility.js
-//#SHA1: 4767fa4655235101bee847c06850d6db3b71d1cd
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const { Readable: R, Writable: W } = require("stream");
-
-let ondataCalled = 0;
-
-class TestReader extends R {
-  constructor() {
-    super();
-    this._buffer = Buffer.alloc(100, "x");
-
-    this.on("data", () => {
-      ondataCalled++;
-    });
-  }
-
-  _read(n) {
-    this.push(this._buffer);
-    this._buffer = Buffer.alloc(0);
-  }
-}
-
-class TestWriter extends W {
-  constructor() {
-    super();
-    this.write("foo");
-    this.end();
-  }
-
-  _write(chunk, enc, cb) {
-    cb();
-  }
-}
-
-test("TestReader emits data once", done => {
-  const reader = new TestReader();
-  setImmediate(() => {
-    expect(ondataCalled).toBe(1);
-    reader.push(null);
-    done();
-  });
-});
-
-test("TestWriter ends correctly", () => {
-  const writer = new TestWriter();
-  expect(writer.writable).toBe(false);
-});
-
-test("TestReader becomes unreadable", done => {
-  const reader = new TestReader();
-  reader.on("end", () => {
-    expect(reader.readable).toBe(false);
-    done();
-  });
-  reader.push(null);
-});
-
-//<#END_FILE: test-stream2-compatibility.js
diff --git a/test/js/node/test/parallel/stream2-decode-partial.test.js b/test/js/node/test/parallel/stream2-decode-partial.test.js
deleted file mode 100644
index 47cbf45918..0000000000
--- a/test/js/node/test/parallel/stream2-decode-partial.test.js
+++ /dev/null
@@ -1,30 +0,0 @@
-//#FILE: test-stream2-decode-partial.js
-//#SHA1: bc4bec1c0be7857c86b9cd75dbb76b939d9619ab
-//-----------------
-"use strict";
-
-const { Readable } = require("stream");
-
-let buf = "";
-const euro = Buffer.from([0xe2, 0x82, 0xac]);
-const cent = Buffer.from([0xc2, 0xa2]);
-const source = Buffer.concat([euro, cent]);
-
-test("Readable stream decodes partial UTF-8 characters correctly", done => {
-  const readable = Readable({ encoding: "utf8" });
-  readable.push(source.slice(0, 2));
-  readable.push(source.slice(2, 4));
-  readable.push(source.slice(4, 6));
-  readable.push(null);
-
-  readable.on("data", function (data) {
-    buf += data;
-  });
-
-  readable.on("end", function () {
-    expect(buf).toBe("€¢");
-    done();
-  });
-});
-
-//<#END_FILE: test-stream2-decode-partial.js
diff --git a/test/js/node/test/parallel/stream2-finish-pipe.test.js b/test/js/node/test/parallel/stream2-finish-pipe.test.js
deleted file mode 100644
index db9e55b8f6..0000000000
--- a/test/js/node/test/parallel/stream2-finish-pipe.test.js
+++ /dev/null
@@ -1,54 +0,0 @@
-//#FILE: test-stream2-finish-pipe.js
-//#SHA1: dfe174476d312542a54b9574955bddf0ad35aa9e
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const stream = require("stream");
-
-test("stream2 finish pipe", done => {
-  const r = new stream.Readable();
-  r._read = function (size) {
-    r.push(Buffer.allocUnsafe(size));
-  };
-
-  const w = new stream.Writable();
-  w._write = function (data, encoding, cb) {
-    process.nextTick(cb, null);
-  };
-
-  r.pipe(w);
-
-  // end() must be called in nextTick or a WRITE_AFTER_END error occurs.
-  process.nextTick(() => {
-    // This might sound unrealistic, but it happens in net.js. When
-    // socket.allowHalfOpen === false, EOF will cause .destroySoon() call which
-    // ends the writable side of net.Socket.
-    w.end();
-    // We need to wait for the 'finish' event to ensure the test completes successfully
-    w.on("finish", () => {
-      done();
-    });
-  });
-});
-
-//<#END_FILE: test-stream2-finish-pipe.js
diff --git a/test/js/node/test/parallel/stream2-large-read-stall.test.js b/test/js/node/test/parallel/stream2-large-read-stall.test.js
deleted file mode 100644
index 9754a67b0a..0000000000
--- a/test/js/node/test/parallel/stream2-large-read-stall.test.js
+++ /dev/null
@@ -1,78 +0,0 @@
-//#FILE: test-stream2-large-read-stall.js
-//#SHA1: c83f78a1c91b12eedd6262c4691bb2e9118c90ae
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-// If everything aligns so that you do a read(n) of exactly the
-// remaining buffer, then make sure that 'end' still emits.
-
-const READSIZE = 100;
-const PUSHSIZE = 20;
-const PUSHCOUNT = 1000;
-const HWM = 50;
-
-const { Readable } = require("stream");
-
-test("large read stall", async () => {
-  const r = new Readable({
-    highWaterMark: HWM,
-  });
-  const rs = r._readableState;
-
-  r._read = push;
-
-  let pushes = 0;
-  function push() {
-    if (pushes > PUSHCOUNT) return;
-
-    if (pushes++ === PUSHCOUNT) {
-      console.error("   push(EOF)");
-      return r.push(null);
-    }
-
-    console.error(`   push #${pushes}`);
-    if (r.push(Buffer.allocUnsafe(PUSHSIZE))) setTimeout(push, 1);
-  }
-
-  r.on("readable", function () {
-    console.error(">> readable");
-    let ret;
-    do {
-      console.error(`  > read(${READSIZE})`);
-      ret = r.read(READSIZE);
-      console.error(`  < ${ret && ret.length} (${rs.length} remain)`);
-    } while (ret && ret.length === READSIZE);
-
-    console.error("<< after read()", ret && ret.length, rs.needReadable, rs.length);
-  });
-
-  await new Promise(resolve => {
-    r.on("end", () => {
-      expect(pushes).toBe(PUSHCOUNT + 1);
-      resolve();
-    });
-  });
-});
-
-//<#END_FILE: test-stream2-large-read-stall.js
diff --git a/test/js/node/test/parallel/stream2-objects.test.js b/test/js/node/test/parallel/stream2-objects.test.js
deleted file mode 100644
index 847802f2db..0000000000
--- a/test/js/node/test/parallel/stream2-objects.test.js
+++ /dev/null
@@ -1,298 +0,0 @@
-//#FILE: test-stream2-objects.js
-//#SHA1: e9aa308270bcb656e33df7deb63c8ce8739c0f35
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-const { Readable, Writable } = require("stream");
-
-function toArray(callback) {
-  const stream = new Writable({ objectMode: true });
-  const list = [];
-  stream.write = function (chunk) {
-    list.push(chunk);
-  };
-
-  stream.end = function () {
-    callback(list);
-  };
-
-  return stream;
-}
-
-function fromArray(list) {
-  const r = new Readable({ objectMode: true });
-  r._read = jest.fn();
-  list.forEach(function (chunk) {
-    r.push(chunk);
-  });
-  r.push(null);
-
-  return r;
-}
-
-test("Verify that objects can be read from the stream", () => {
-  const r = fromArray([{ one: "1" }, { two: "2" }]);
-
-  const v1 = r.read();
-  const v2 = r.read();
-  const v3 = r.read();
-
-  expect(v1).toEqual({ one: "1" });
-  expect(v2).toEqual({ two: "2" });
-  expect(v3).toBeNull();
-});
-
-test("Verify that objects can be piped into the stream", done => {
-  const r = fromArray([{ one: "1" }, { two: "2" }]);
-
-  r.pipe(
-    toArray(list => {
-      expect(list).toEqual([{ one: "1" }, { two: "2" }]);
-      done();
-    }),
-  );
-});
-
-test("Verify that read(n) is ignored", () => {
-  const r = fromArray([{ one: "1" }, { two: "2" }]);
-  const value = r.read(2);
-
-  expect(value).toEqual({ one: "1" });
-});
-
-test("Verify that objects can be synchronously read", done => {
-  const r = new Readable({ objectMode: true });
-  const list = [{ one: "1" }, { two: "2" }];
-  r._read = function (n) {
-    const item = list.shift();
-    r.push(item || null);
-  };
-
-  r.pipe(
-    toArray(list => {
-      expect(list).toEqual([{ one: "1" }, { two: "2" }]);
-      done();
-    }),
-  );
-});
-
-test("Verify that objects can be asynchronously read", done => {
-  const r = new Readable({ objectMode: true });
-  const list = [{ one: "1" }, { two: "2" }];
-  r._read = function (n) {
-    const item = list.shift();
-    process.nextTick(function () {
-      r.push(item || null);
-    });
-  };
-
-  r.pipe(
-    toArray(list => {
-      expect(list).toEqual([{ one: "1" }, { two: "2" }]);
-      done();
-    }),
-  );
-});
-
-test("Verify that strings can be read as objects", done => {
-  const r = new Readable({
-    objectMode: true,
-  });
-  r._read = jest.fn();
-  const list = ["one", "two", "three"];
-  list.forEach(function (str) {
-    r.push(str);
-  });
-  r.push(null);
-
-  r.pipe(
-    toArray(array => {
-      expect(array).toEqual(list);
-      done();
-    }),
-  );
-});
-
-test("Verify read(0) behavior for object streams", done => {
-  const r = new Readable({
-    objectMode: true,
-  });
-  r._read = jest.fn();
-
-  r.push("foobar");
-  r.push(null);
-
-  r.pipe(
-    toArray(array => {
-      expect(array).toEqual(["foobar"]);
-      done();
-    }),
-  );
-});
-
-test("Verify the behavior of pushing falsey values", done => {
-  const r = new Readable({
-    objectMode: true,
-  });
-  r._read = jest.fn();
-
-  r.push(false);
-  r.push(0);
-  r.push("");
-  r.push(null);
-
-  r.pipe(
-    toArray(array => {
-      expect(array).toEqual([false, 0, ""]);
-      done();
-    }),
-  );
-});
-
-test("Verify high watermark _read() behavior", () => {
-  const r = new Readable({
-    highWaterMark: 6,
-    objectMode: true,
-  });
-  let calls = 0;
-  const list = ["1", "2", "3", "4", "5", "6", "7", "8"];
-
-  r._read = function (n) {
-    calls++;
-  };
-
-  list.forEach(function (c) {
-    r.push(c);
-  });
-
-  const v = r.read();
-
-  expect(calls).toBe(0);
-  expect(v).toBe("1");
-
-  const v2 = r.read();
-  expect(v2).toBe("2");
-
-  const v3 = r.read();
-  expect(v3).toBe("3");
-
-  expect(calls).toBe(1);
-});
-
-test("Verify high watermark push behavior", () => {
-  const r = new Readable({
-    highWaterMark: 6,
-    objectMode: true,
-  });
-  r._read = jest.fn();
-  for (let i = 0; i < 6; i++) {
-    const bool = r.push(i);
-    expect(bool).toBe(i !== 5);
-  }
-});
-
-test("Verify that objects can be written to stream", done => {
-  const w = new Writable({ objectMode: true });
-
-  w._write = function (chunk, encoding, cb) {
-    expect(chunk).toEqual({ foo: "bar" });
-    cb();
-  };
-
-  w.on("finish", done);
-  w.write({ foo: "bar" });
-  w.end();
-});
-
-test("Verify that multiple objects can be written to stream", done => {
-  const w = new Writable({ objectMode: true });
-  const list = [];
-
-  w._write = function (chunk, encoding, cb) {
-    list.push(chunk);
-    cb();
-  };
-
-  w.on("finish", () => {
-    expect(list).toEqual([0, 1, 2, 3, 4]);
-    done();
-  });
-
-  w.write(0);
-  w.write(1);
-  w.write(2);
-  w.write(3);
-  w.write(4);
-  w.end();
-});
-
-test("Verify that strings can be written as objects", done => {
-  const w = new Writable({
-    objectMode: true,
-  });
-  const list = [];
-
-  w._write = function (chunk, encoding, cb) {
-    list.push(chunk);
-    process.nextTick(cb);
-  };
-
-  w.on("finish", () => {
-    expect(list).toEqual(["0", "1", "2", "3", "4"]);
-    done();
-  });
-
-  w.write("0");
-  w.write("1");
-  w.write("2");
-  w.write("3");
-  w.write("4");
-  w.end();
-});
-
-test("Verify that stream buffers finish until callback is called", done => {
-  const w = new Writable({
-    objectMode: true,
-  });
-  let called = false;
-
-  w._write = function (chunk, encoding, cb) {
-    expect(chunk).toBe("foo");
-
-    process.nextTick(function () {
-      called = true;
-      cb();
-    });
-  };
-
-  w.on("finish", () => {
-    expect(called).toBe(true);
-    done();
-  });
-
-  w.write("foo");
-  w.end();
-});
-
-//<#END_FILE: test-stream2-objects.js
diff --git a/test/js/node/test/parallel/stream2-pipe-error-handling.test.js b/test/js/node/test/parallel/stream2-pipe-error-handling.test.js
deleted file mode 100644
index 4a482b234a..0000000000
--- a/test/js/node/test/parallel/stream2-pipe-error-handling.test.js
+++ /dev/null
@@ -1,110 +0,0 @@
-//#FILE: test-stream2-pipe-error-handling.js
-//#SHA1: c5e7ad139c64f22b16e8fff8a62f6f91067087c8
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const stream = require("stream");
-
-test("stream pipe error handling with autoDestroy true", () => {
-  let count = 1000;
-
-  const source = new stream.Readable();
-  source._read = function (n) {
-    n = Math.min(count, n);
-    count -= n;
-    source.push(Buffer.allocUnsafe(n));
-  };
-
-  let unpipedDest;
-  source.unpipe = function (dest) {
-    unpipedDest = dest;
-    stream.Readable.prototype.unpipe.call(this, dest);
-  };
-
-  const dest = new stream.Writable();
-  dest._write = function (chunk, encoding, cb) {
-    cb();
-  };
-
-  source.pipe(dest);
-
-  let gotErr = null;
-  dest.on("error", function (err) {
-    gotErr = err;
-  });
-
-  let unpipedSource;
-  dest.on("unpipe", function (src) {
-    unpipedSource = src;
-  });
-
-  const err = new Error("This stream turned into bacon.");
-  dest.emit("error", err);
-  expect(gotErr).toBe(err);
-  expect(unpipedSource).toBe(source);
-  expect(unpipedDest).toBe(dest);
-});
-
-test("stream pipe error handling with autoDestroy false", () => {
-  let count = 1000;
-
-  const source = new stream.Readable();
-  source._read = function (n) {
-    n = Math.min(count, n);
-    count -= n;
-    source.push(Buffer.allocUnsafe(n));
-  };
-
-  let unpipedDest;
-  source.unpipe = function (dest) {
-    unpipedDest = dest;
-    stream.Readable.prototype.unpipe.call(this, dest);
-  };
-
-  const dest = new stream.Writable({ autoDestroy: false });
-  dest._write = function (chunk, encoding, cb) {
-    cb();
-  };
-
-  source.pipe(dest);
-
-  let unpipedSource;
-  dest.on("unpipe", function (src) {
-    unpipedSource = src;
-  });
-
-  const err = new Error("This stream turned into bacon.");
-
-  let gotErr = null;
-  expect(() => {
-    dest.emit("error", err);
-  }).toThrow(
-    expect.objectContaining({
-      message: expect.any(String),
-    }),
-  );
-  expect(unpipedSource).toBe(source);
-  expect(unpipedDest).toBe(dest);
-});
-
-//<#END_FILE: test-stream2-pipe-error-handling.js
diff --git a/test/js/node/test/parallel/stream2-pipe-error-once-listener.test.js b/test/js/node/test/parallel/stream2-pipe-error-once-listener.test.js
deleted file mode 100644
index 4879a847e0..0000000000
--- a/test/js/node/test/parallel/stream2-pipe-error-once-listener.test.js
+++ /dev/null
@@ -1,63 +0,0 @@
-//#FILE: test-stream2-pipe-error-once-listener.js
-//#SHA1: a0bd981aa626f937edb6779bcf0e4dc49b82e69e
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-const stream = require("stream");
-
-class Read extends stream.Readable {
-  _read(size) {
-    this.push("x");
-    this.push(null);
-  }
-}
-
-class Write extends stream.Writable {
-  _write(buffer, encoding, cb) {
-    this.emit("error", new Error("boom"));
-    this.emit("alldone");
-  }
-}
-
-test("stream2 pipe error once listener", done => {
-  const read = new Read();
-  const write = new Write();
-
-  write.once("error", () => {});
-  write.once("alldone", () => {
-    console.log("ok");
-    done();
-  });
-
-  const exitSpy = jest.spyOn(process, "exit").mockImplementation(() => {});
-
-  read.pipe(write);
-
-  process.nextTick(() => {
-    expect(exitSpy).not.toHaveBeenCalled();
-    exitSpy.mockRestore();
-  });
-});
-
-//<#END_FILE: test-stream2-pipe-error-once-listener.js
diff --git a/test/js/node/test/parallel/stream2-push.test.js b/test/js/node/test/parallel/stream2-push.test.js
deleted file mode 100644
index d623f82a98..0000000000
--- a/test/js/node/test/parallel/stream2-push.test.js
+++ /dev/null
@@ -1,139 +0,0 @@
-//#FILE: test-stream2-push.js
-//#SHA1: 9b6aded0c40321f8d2c15dceab98b26033f23adf
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const { Readable, Writable } = require("stream");
-const EE = require("events").EventEmitter;
-
-test("Stream2 push behavior", async () => {
-  const stream = new Readable({
-    highWaterMark: 16,
-    encoding: "utf8",
-  });
-
-  const source = new EE();
-
-  stream._read = function () {
-    console.error("stream._read");
-    readStart();
-  };
-
-  let ended = false;
-  stream.on("end", function () {
-    ended = true;
-  });
-
-  source.on("data", function (chunk) {
-    const ret = stream.push(chunk);
-    console.error("data", stream.readableLength);
-    if (!ret) readStop();
-  });
-
-  source.on("end", function () {
-    stream.push(null);
-  });
-
-  let reading = false;
-
-  function readStart() {
-    console.error("readStart");
-    reading = true;
-  }
-
-  function readStop() {
-    console.error("readStop");
-    reading = false;
-    process.nextTick(function () {
-      const r = stream.read();
-      if (r !== null) writer.write(r);
-    });
-  }
-
-  const writer = new Writable({
-    decodeStrings: false,
-  });
-
-  const written = [];
-
-  const expectWritten = [
-    "asdfgasdfgasdfgasdfg",
-    "asdfgasdfgasdfgasdfg",
-    "asdfgasdfgasdfgasdfg",
-    "asdfgasdfgasdfgasdfg",
-    "asdfgasdfgasdfgasdfg",
-    "asdfgasdfgasdfgasdfg",
-  ];
-
-  writer._write = function (chunk, encoding, cb) {
-    console.error(`WRITE ${chunk}`);
-    written.push(chunk);
-    process.nextTick(cb);
-  };
-
-  const finishPromise = new Promise(resolve => {
-    writer.on("finish", () => {
-      console.error("finish");
-      expect(written).toEqual(expectWritten);
-      console.log("ok");
-      resolve();
-    });
-  });
-
-  // Now emit some chunks.
-  const chunk = "asdfg";
-
-  let set = 0;
-  readStart();
-
-  function data() {
-    expect(reading).toBe(true);
-    source.emit("data", chunk);
-    expect(reading).toBe(true);
-    source.emit("data", chunk);
-    expect(reading).toBe(true);
-    source.emit("data", chunk);
-    expect(reading).toBe(true);
-    source.emit("data", chunk);
-    expect(reading).toBe(false);
-    if (set++ < 5) return new Promise(resolve => setTimeout(() => resolve(data()), 10));
-    else return end();
-  }
-
-  function end() {
-    source.emit("end");
-    expect(reading).toBe(false);
-    writer.end(stream.read());
-    return new Promise(resolve =>
-      setImmediate(() => {
-        expect(ended).toBe(true);
-        resolve();
-      }),
-    );
-  }
-
-  await data();
-  await finishPromise;
-});
-
-//<#END_FILE: test-stream2-push.js
diff --git a/test/js/node/test/parallel/stream2-readable-empty-buffer-no-eof.test.js b/test/js/node/test/parallel/stream2-readable-empty-buffer-no-eof.test.js
deleted file mode 100644
index 5aad62d568..0000000000
--- a/test/js/node/test/parallel/stream2-readable-empty-buffer-no-eof.test.js
+++ /dev/null
@@ -1,107 +0,0 @@
-//#FILE: test-stream2-readable-empty-buffer-no-eof.js
-//#SHA1: 70ef48637116477747867b03a60462fb64331087
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const { Readable } = require("stream");
-
-test("test1", done => {
-  const r = new Readable();
-
-  // Should not end when we get a Buffer.alloc(0) or '' as the _read
-  // result that just means that there is *temporarily* no data, but to
-  // go ahead and try again later.
-  //
-  // note that this is very unusual.  it only works for crypto streams
-  // because the other side of the stream will call read(0) to cycle
-  // data through openssl.  that's why setImmediate() is used to call
-  // r.read(0) again later, otherwise there is no more work being done
-  // and the process just exits.
-
-  const buf = Buffer.alloc(5, "x");
-  let reads = 5;
-  r._read = function (n) {
-    switch (reads--) {
-      case 5:
-        return setImmediate(() => {
-          return r.push(buf);
-        });
-      case 4:
-        setImmediate(() => {
-          return r.push(Buffer.alloc(0));
-        });
-        return setImmediate(r.read.bind(r, 0));
-      case 3:
-        setImmediate(r.read.bind(r, 0));
-        return process.nextTick(() => {
-          return r.push(Buffer.alloc(0));
-        });
-      case 2:
-        setImmediate(r.read.bind(r, 0));
-        return r.push(Buffer.alloc(0)); // Not-EOF!
-      case 1:
-        return r.push(buf);
-      case 0:
-        return r.push(null); // EOF
-      default:
-        throw new Error("unreachable");
-    }
-  };
-
-  const results = [];
-  function flow() {
-    let chunk;
-    while (null !== (chunk = r.read())) results.push(String(chunk));
-  }
-  r.on("readable", flow);
-  r.on("end", () => {
-    results.push("EOF");
-    expect(results).toEqual(["xxxxx", "xxxxx", "EOF"]);
-    done();
-  });
-  flow();
-});
-
-test("test2", done => {
-  const r = new Readable({ encoding: "base64" });
-  let reads = 5;
-  r._read = function (n) {
-    if (!reads--) return r.push(null); // EOF
-    return r.push(Buffer.from("x"));
-  };
-
-  const results = [];
-  function flow() {
-    let chunk;
-    while (null !== (chunk = r.read())) results.push(String(chunk));
-  }
-  r.on("readable", flow);
-  r.on("end", () => {
-    results.push("EOF");
-    expect(results).toEqual(["eHh4", "eHg=", "EOF"]);
-    done();
-  });
-  flow();
-});
-
-//<#END_FILE: test-stream2-readable-empty-buffer-no-eof.js
diff --git a/test/js/node/test/parallel/stream2-readable-legacy-drain.test.js b/test/js/node/test/parallel/stream2-readable-legacy-drain.test.js
deleted file mode 100644
index 137ee20ab6..0000000000
--- a/test/js/node/test/parallel/stream2-readable-legacy-drain.test.js
+++ /dev/null
@@ -1,68 +0,0 @@
-//#FILE: test-stream2-readable-legacy-drain.js
-//#SHA1: 8182fd1e12ce8538106404d39102ea69eee2e467
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const Stream = require("stream");
-const Readable = Stream.Readable;
-
-test("Readable stream with legacy drain", done => {
-  const r = new Readable();
-  const N = 256;
-  let reads = 0;
-  r._read = function (n) {
-    return r.push(++reads === N ? null : Buffer.allocUnsafe(1));
-  };
-
-  const onEnd = jest.fn();
-  r.on("end", onEnd);
-
-  const w = new Stream();
-  w.writable = true;
-  let buffered = 0;
-  w.write = function (c) {
-    buffered += c.length;
-    process.nextTick(drain);
-    return false;
-  };
-
-  function drain() {
-    expect(buffered).toBeLessThanOrEqual(3);
-    buffered = 0;
-    w.emit("drain");
-  }
-
-  const endSpy = jest.fn();
-  w.end = endSpy;
-
-  r.pipe(w);
-
-  // Wait for the 'end' event to be emitted
-  r.on("end", () => {
-    expect(onEnd).toHaveBeenCalledTimes(1);
-    expect(endSpy).toHaveBeenCalledTimes(1);
-    done();
-  });
-});
-
-//<#END_FILE: test-stream2-readable-legacy-drain.js
diff --git a/test/js/node/test/parallel/stream2-readable-wrap-destroy.test.js b/test/js/node/test/parallel/stream2-readable-wrap-destroy.test.js
deleted file mode 100644
index b001ee2a9b..0000000000
--- a/test/js/node/test/parallel/stream2-readable-wrap-destroy.test.js
+++ /dev/null
@@ -1,45 +0,0 @@
-//#FILE: test-stream2-readable-wrap-destroy.js
-//#SHA1: 632a198f6b4fc882942984df461383047f6b78a6
-//-----------------
-"use strict";
-
-const { Readable } = require("stream");
-const EventEmitter = require("events");
-
-test('Readable.wrap should call destroy on "destroy" event', () => {
-  const oldStream = new EventEmitter();
-  oldStream.pause = jest.fn();
-  oldStream.resume = jest.fn();
-
-  const destroyMock = jest.fn();
-
-  const readable = new Readable({
-    autoDestroy: false,
-    destroy: destroyMock,
-  });
-
-  readable.wrap(oldStream);
-  oldStream.emit("destroy");
-
-  expect(destroyMock).toHaveBeenCalledTimes(1);
-});
-
-test('Readable.wrap should call destroy on "close" event', () => {
-  const oldStream = new EventEmitter();
-  oldStream.pause = jest.fn();
-  oldStream.resume = jest.fn();
-
-  const destroyMock = jest.fn();
-
-  const readable = new Readable({
-    autoDestroy: false,
-    destroy: destroyMock,
-  });
-
-  readable.wrap(oldStream);
-  oldStream.emit("close");
-
-  expect(destroyMock).toHaveBeenCalledTimes(1);
-});
-
-//<#END_FILE: test-stream2-readable-wrap-destroy.js
diff --git a/test/js/node/test/parallel/stream2-readable-wrap-empty.test.js b/test/js/node/test/parallel/stream2-readable-wrap-empty.test.js
deleted file mode 100644
index 9735960e5b..0000000000
--- a/test/js/node/test/parallel/stream2-readable-wrap-empty.test.js
+++ /dev/null
@@ -1,46 +0,0 @@
-//#FILE: test-stream2-readable-wrap-empty.js
-//#SHA1: aaac82ec7df0743321f2aaacd9512ecf1b932ad6
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-const { Readable } = require("stream");
-const EventEmitter = require("events");
-
-test("Readable.wrap with empty stream", done => {
-  const oldStream = new EventEmitter();
-  oldStream.pause = jest.fn();
-  oldStream.resume = jest.fn();
-
-  const newStream = new Readable().wrap(oldStream);
-
-  newStream
-    .on("readable", () => {})
-    .on("end", () => {
-      done();
-    });
-
-  oldStream.emit("end");
-});
-
-//<#END_FILE: test-stream2-readable-wrap-empty.js
diff --git a/test/js/node/test/parallel/stream2-unpipe-drain.test.js b/test/js/node/test/parallel/stream2-unpipe-drain.test.js
deleted file mode 100644
index a2ea536ef6..0000000000
--- a/test/js/node/test/parallel/stream2-unpipe-drain.test.js
+++ /dev/null
@@ -1,75 +0,0 @@
-//#FILE: test-stream2-unpipe-drain.js
-//#SHA1: b04d9c383281786f45989d8d7f85f6f1a620bde2
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-const stream = require("stream");
-
-class TestWriter extends stream.Writable {
-  _write(buffer, encoding, callback) {
-    console.log("write called");
-    // Super slow write stream (callback never called)
-  }
-}
-
-class TestReader extends stream.Readable {
-  constructor() {
-    super();
-    this.reads = 0;
-  }
-
-  _read(size) {
-    this.reads += 1;
-    this.push(Buffer.alloc(size));
-  }
-}
-
-test("stream2 unpipe drain", done => {
-  const dest = new TestWriter();
-  const src1 = new TestReader();
-  const src2 = new TestReader();
-
-  src1.pipe(dest);
-
-  src1.once("readable", () => {
-    process.nextTick(() => {
-      src2.pipe(dest);
-
-      src2.once("readable", () => {
-        process.nextTick(() => {
-          src1.unpipe(dest);
-
-          // Use setImmediate to ensure all microtasks have been processed
-          setImmediate(() => {
-            expect(src1.reads).toBe(2);
-            expect(src2.reads).toBe(2);
-            done();
-          });
-        });
-      });
-    });
-  });
-});
-
-//<#END_FILE: test-stream2-unpipe-drain.js
diff --git a/test/js/node/test/parallel/stream3-cork-end.test.js b/test/js/node/test/parallel/stream3-cork-end.test.js
deleted file mode 100644
index 974e12ce1a..0000000000
--- a/test/js/node/test/parallel/stream3-cork-end.test.js
+++ /dev/null
@@ -1,98 +0,0 @@
-//#FILE: test-stream3-cork-end.js
-//#SHA1: 1ac6a2589bee41bc1e9e08ef308bcae3cd999106
-//-----------------
-"use strict";
-
-const stream = require("stream");
-const Writable = stream.Writable;
-
-// Test the buffering behavior of Writable streams.
-//
-// The call to cork() triggers storing chunks which are flushed
-// on calling end() and the stream subsequently ended.
-//
-// node version target: 0.12
-
-test("Writable stream buffering behavior with cork() and end()", done => {
-  const expectedChunks = ["please", "buffer", "me", "kindly"];
-  const inputChunks = expectedChunks.slice(0);
-  let seenChunks = [];
-  let seenEnd = false;
-
-  const w = new Writable();
-  // Let's arrange to store the chunks.
-  w._write = function (chunk, encoding, cb) {
-    // Stream end event is not seen before the last write.
-    expect(seenEnd).toBe(false);
-    // Default encoding given none was specified.
-    expect(encoding).toBe("buffer");
-
-    seenChunks.push(chunk);
-    cb();
-  };
-  // Let's record the stream end event.
-  w.on("finish", () => {
-    seenEnd = true;
-  });
-
-  function writeChunks(remainingChunks, callback) {
-    const writeChunk = remainingChunks.shift();
-    let writeState;
-
-    if (writeChunk) {
-      setImmediate(() => {
-        writeState = w.write(writeChunk);
-        // We were not told to stop writing.
-        expect(writeState).toBe(true);
-
-        writeChunks(remainingChunks, callback);
-      });
-    } else {
-      callback();
-    }
-  }
-
-  // Do an initial write.
-  w.write("stuff");
-  // The write was immediate.
-  expect(seenChunks.length).toBe(1);
-  // Reset the seen chunks.
-  seenChunks = [];
-
-  // Trigger stream buffering.
-  w.cork();
-
-  // Write the bufferedChunks.
-  writeChunks(inputChunks, () => {
-    // Should not have seen anything yet.
-    expect(seenChunks.length).toBe(0);
-
-    // Trigger flush and ending the stream.
-    w.end();
-
-    // Stream should not ended in current tick.
-    expect(seenEnd).toBe(false);
-
-    // Buffered bytes should be seen in current tick.
-    expect(seenChunks.length).toBe(4);
-
-    // Did the chunks match.
-    for (let i = 0, l = expectedChunks.length; i < l; i++) {
-      const seen = seenChunks[i];
-      // There was a chunk.
-      expect(seen).toBeTruthy();
-
-      const expected = Buffer.from(expectedChunks[i]);
-      // It was what we expected.
-      expect(seen.equals(expected)).toBe(true);
-    }
-
-    setImmediate(() => {
-      // Stream should have ended in next tick.
-      expect(seenEnd).toBe(true);
-      done();
-    });
-  });
-});
-
-//<#END_FILE: test-stream3-cork-end.js
diff --git a/test/js/node/test/parallel/stream3-cork-uncork.test.js b/test/js/node/test/parallel/stream3-cork-uncork.test.js
deleted file mode 100644
index 85aa626dec..0000000000
--- a/test/js/node/test/parallel/stream3-cork-uncork.test.js
+++ /dev/null
@@ -1,104 +0,0 @@
-//#FILE: test-stream3-cork-uncork.js
-//#SHA1: d1cc0d9e9be4ae657ab2db8e02589ac485268c63
-//-----------------
-"use strict";
-
-const stream = require("stream");
-const Writable = stream.Writable;
-
-// Test the buffering behavior of Writable streams.
-//
-// The call to cork() triggers storing chunks which are flushed
-// on calling uncork() in the same tick.
-//
-// node version target: 0.12
-
-describe("Writable stream cork and uncork", () => {
-  const expectedChunks = ["please", "buffer", "me", "kindly"];
-  let inputChunks;
-  let seenChunks;
-  let seenEnd;
-  let w;
-
-  beforeEach(() => {
-    inputChunks = expectedChunks.slice(0);
-    seenChunks = [];
-    seenEnd = false;
-
-    w = new Writable();
-    // Let's arrange to store the chunks.
-    w._write = function (chunk, encoding, cb) {
-      // Default encoding given none was specified.
-      expect(encoding).toBe("buffer");
-
-      seenChunks.push(chunk);
-      cb();
-    };
-    // Let's record the stream end event.
-    w.on("finish", () => {
-      seenEnd = true;
-    });
-  });
-
-  function writeChunks(remainingChunks) {
-    return new Promise(resolve => {
-      function write() {
-        const writeChunk = remainingChunks.shift();
-        if (writeChunk) {
-          setImmediate(() => {
-            const writeState = w.write(writeChunk);
-            // We were not told to stop writing.
-            expect(writeState).toBe(true);
-            write();
-          });
-        } else {
-          resolve();
-        }
-      }
-      write();
-    });
-  }
-
-  test("initial write is immediate", () => {
-    w.write("stuff");
-    // The write was immediate.
-    expect(seenChunks.length).toBe(1);
-  });
-
-  test("cork buffers writes and uncork flushes", async () => {
-    // Reset the chunks seen so far.
-    seenChunks = [];
-
-    // Trigger stream buffering.
-    w.cork();
-
-    // Write the bufferedChunks.
-    await writeChunks(inputChunks);
-
-    // Should not have seen anything yet.
-    expect(seenChunks.length).toBe(0);
-
-    // Trigger writing out the buffer.
-    w.uncork();
-
-    // Buffered bytes should be seen in current tick.
-    expect(seenChunks.length).toBe(4);
-
-    // Did the chunks match.
-    for (let i = 0, l = expectedChunks.length; i < l; i++) {
-      const seen = seenChunks[i];
-      // There was a chunk.
-      expect(seen).toBeTruthy();
-
-      const expected = Buffer.from(expectedChunks[i]);
-      // It was what we expected.
-      expect(seen.equals(expected)).toBe(true);
-    }
-
-    await new Promise(resolve => setImmediate(resolve));
-    // The stream should not have been ended.
-    expect(seenEnd).toBe(false);
-  });
-});
-
-//<#END_FILE: test-stream3-cork-uncork.js
diff --git a/test/js/node/test/parallel/stream3-pause-then-read.test.js b/test/js/node/test/parallel/stream3-pause-then-read.test.js
deleted file mode 100644
index f7df831524..0000000000
--- a/test/js/node/test/parallel/stream3-pause-then-read.test.js
+++ /dev/null
@@ -1,187 +0,0 @@
-//#FILE: test-stream3-pause-then-read.js
-//#SHA1: bd44dc04c63140e4b65c0755eec67a55eaf48158
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-const stream = require("stream");
-const Readable = stream.Readable;
-const Writable = stream.Writable;
-
-const totalChunks = 100;
-const chunkSize = 99;
-const expectTotalData = totalChunks * chunkSize;
-let expectEndingData = expectTotalData;
-
-let r, totalPushed;
-
-beforeEach(() => {
-  r = new Readable({ highWaterMark: 1000 });
-  let chunks = totalChunks;
-  r._read = function (n) {
-    console.log("_read called", chunks);
-    if (!(chunks % 2)) setImmediate(push);
-    else if (!(chunks % 3)) process.nextTick(push);
-    else push();
-  };
-
-  totalPushed = 0;
-  function push() {
-    const chunk = chunks-- > 0 ? Buffer.alloc(chunkSize, "x") : null;
-    if (chunk) {
-      totalPushed += chunk.length;
-    }
-    console.log("chunks", chunks);
-    r.push(chunk);
-  }
-});
-
-test("stream3 pause then read", async () => {
-  await read100();
-  await new Promise(resolve => setImmediate(resolve));
-  await pipeLittle();
-  await read1234();
-  await resumePause();
-  await pipe();
-});
-
-// First we read 100 bytes.
-async function read100() {
-  await readn(100);
-}
-
-async function readn(n) {
-  console.error(`read ${n}`);
-  expectEndingData -= n;
-  return new Promise(resolve => {
-    function read() {
-      const c = r.read(n);
-      console.error("c", c);
-      if (!c) r.once("readable", read);
-      else {
-        expect(c.length).toBe(n);
-        expect(r.readableFlowing).toBeFalsy();
-        resolve();
-      }
-    }
-    read();
-  });
-}
-
-// Then we listen to some data events.
-function onData() {
-  return new Promise(resolve => {
-    expectEndingData -= 100;
-    console.error("onData");
-    let seen = 0;
-    r.on("data", function od(c) {
-      seen += c.length;
-      if (seen >= 100) {
-        // Seen enough
-        r.removeListener("data", od);
-        r.pause();
-        if (seen > 100) {
-          // Oh no, seen too much!
-          // Put the extra back.
-          const diff = seen - 100;
-          r.unshift(c.slice(c.length - diff));
-          console.error("seen too much", seen, diff);
-        }
-        resolve();
-      }
-    });
-  });
-}
-
-// Just pipe 200 bytes, then unshift the extra and unpipe.
-async function pipeLittle() {
-  expectEndingData -= 200;
-  console.error("pipe a little");
-  const w = new Writable();
-  let written = 0;
-  await new Promise(resolve => {
-    w.on("finish", () => {
-      expect(written).toBe(200);
-      resolve();
-    });
-    w._write = function (chunk, encoding, cb) {
-      written += chunk.length;
-      if (written >= 200) {
-        r.unpipe(w);
-        w.end();
-        cb();
-        if (written > 200) {
-          const diff = written - 200;
-          written -= diff;
-          r.unshift(chunk.slice(chunk.length - diff));
-        }
-      } else {
-        setImmediate(cb);
-      }
-    };
-    r.pipe(w);
-  });
-}
-
-// Now read 1234 more bytes.
-async function read1234() {
-  await readn(1234);
-}
-
-function resumePause() {
-  console.error("resumePause");
-  // Don't read anything, just resume and re-pause a whole bunch.
-  r.resume();
-  r.pause();
-  r.resume();
-  r.pause();
-  r.resume();
-  r.pause();
-  r.resume();
-  r.pause();
-  r.resume();
-  r.pause();
-  return new Promise(resolve => setImmediate(resolve));
-}
-
-function pipe() {
-  console.error("pipe the rest");
-  const w = new Writable();
-  let written = 0;
-  w._write = function (chunk, encoding, cb) {
-    written += chunk.length;
-    cb();
-  };
-  return new Promise(resolve => {
-    w.on("finish", () => {
-      console.error("written", written, totalPushed);
-      expect(written).toBe(expectEndingData);
-      expect(totalPushed).toBe(expectTotalData);
-      console.log("ok");
-      resolve();
-    });
-    r.pipe(w);
-  });
-}
-
-//<#END_FILE: test-stream3-pause-then-read.js
diff --git a/test/js/node/test/parallel/stream3-pipeline-async-iterator.test.js b/test/js/node/test/parallel/stream3-pipeline-async-iterator.test.js
deleted file mode 100644
index d84b763fcc..0000000000
--- a/test/js/node/test/parallel/stream3-pipeline-async-iterator.test.js
+++ /dev/null
@@ -1,27 +0,0 @@
-//#FILE: test-stream3-pipeline-async-iterator.js
-//#SHA1: db2d5b4cb6c502fdccdfa1ed9384d6baa70b1e0b
-//-----------------
-/* eslint-disable node-core/require-common-first, require-yield */
-"use strict";
-const { pipeline } = require("node:stream/promises");
-
-test("async iterators can act as readable and writable streams", async () => {
-  // Ensure that async iterators can act as readable and writable streams
-  async function* myCustomReadable() {
-    yield "Hello";
-    yield "World";
-  }
-
-  const messages = [];
-  async function* myCustomWritable(stream) {
-    for await (const chunk of stream) {
-      messages.push(chunk);
-    }
-  }
-
-  await pipeline(myCustomReadable, myCustomWritable);
-
-  expect(messages).toEqual(["Hello", "World"]);
-});
-
-//<#END_FILE: test-stream3-pipeline-async-iterator.js
diff --git a/test/js/node/test/parallel/string-decoder-end.test.js b/test/js/node/test/parallel/string-decoder-end.test.js
deleted file mode 100644
index fc12a567f7..0000000000
--- a/test/js/node/test/parallel/string-decoder-end.test.js
+++ /dev/null
@@ -1,124 +0,0 @@
-//#FILE: test-string-decoder-end.js
-//#SHA1: 9b9cd65cf41dc419c54b8c47317aef7fcb251c5c
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-// Verify that the string decoder works getting 1 byte at a time,
-// the whole buffer at once, and that both match the .toString(enc)
-// result of the entire buffer.
-
-const assert = require("assert");
-const SD = require("string_decoder").StringDecoder;
-const encodings = ["base64", "base64url", "hex", "utf8", "utf16le", "ucs2"];
-
-const bufs = ["☃💩", "asdf"].map(b => Buffer.from(b));
-
-// Also test just arbitrary bytes from 0-15.
-for (let i = 1; i <= 16; i++) {
-  const bytes = "."
-    .repeat(i - 1)
-    .split(".")
-    .map((_, j) => j + 0x78);
-  bufs.push(Buffer.from(bytes));
-}
-
-encodings.forEach(testEncoding);
-
-function testEncoding(encoding) {
-  bufs.forEach(buf => {
-    testBuf(encoding, buf);
-  });
-}
-
-function testBuf(encoding, buf) {
-  test(`StringDecoder ${encoding} - ${buf.toString()}`, () => {
-    // Write one byte at a time.
-    let s = new SD(encoding);
-    let res1 = "";
-    for (let i = 0; i < buf.length; i++) {
-      res1 += s.write(buf.slice(i, i + 1));
-    }
-    res1 += s.end();
-
-    // Write the whole buffer at once.
-    let res2 = "";
-    s = new SD(encoding);
-    res2 += s.write(buf);
-    res2 += s.end();
-
-    // .toString() on the buffer
-    const res3 = buf.toString(encoding);
-
-    // One byte at a time should match toString
-    expect(res1).toBe(res3);
-    // All bytes at once should match toString
-    expect(res2).toBe(res3);
-  });
-}
-
-function testEnd(encoding, incomplete, next, expected) {
-  test(`StringDecoder ${encoding} end - ${incomplete.toString("hex")} + ${next.toString("hex")}`, () => {
-    let res = "";
-    const s = new SD(encoding);
-    res += s.write(incomplete);
-    res += s.end();
-    res += s.write(next);
-    res += s.end();
-
-    expect(res).toBe(expected);
-  });
-}
-
-testEnd("utf8", Buffer.of(0xe2), Buffer.of(0x61), "\uFFFDa");
-testEnd("utf8", Buffer.of(0xe2), Buffer.of(0x82), "\uFFFD\uFFFD");
-testEnd("utf8", Buffer.of(0xe2), Buffer.of(0xe2), "\uFFFD\uFFFD");
-testEnd("utf8", Buffer.of(0xe2, 0x82), Buffer.of(0x61), "\uFFFDa");
-testEnd("utf8", Buffer.of(0xe2, 0x82), Buffer.of(0xac), "\uFFFD\uFFFD");
-testEnd("utf8", Buffer.of(0xe2, 0x82), Buffer.of(0xe2), "\uFFFD\uFFFD");
-testEnd("utf8", Buffer.of(0xe2, 0x82, 0xac), Buffer.of(0x61), "€a");
-
-testEnd("utf16le", Buffer.of(0x3d), Buffer.of(0x61, 0x00), "a");
-testEnd("utf16le", Buffer.of(0x3d), Buffer.of(0xd8, 0x4d, 0xdc), "\u4DD8");
-testEnd("utf16le", Buffer.of(0x3d, 0xd8), Buffer.of(), "\uD83D");
-testEnd("utf16le", Buffer.of(0x3d, 0xd8), Buffer.of(0x61, 0x00), "\uD83Da");
-testEnd("utf16le", Buffer.of(0x3d, 0xd8), Buffer.of(0x4d, 0xdc), "\uD83D\uDC4D");
-testEnd("utf16le", Buffer.of(0x3d, 0xd8, 0x4d), Buffer.of(), "\uD83D");
-testEnd("utf16le", Buffer.of(0x3d, 0xd8, 0x4d), Buffer.of(0x61, 0x00), "\uD83Da");
-testEnd("utf16le", Buffer.of(0x3d, 0xd8, 0x4d), Buffer.of(0xdc), "\uD83D");
-testEnd("utf16le", Buffer.of(0x3d, 0xd8, 0x4d, 0xdc), Buffer.of(0x61, 0x00), "👍a");
-
-testEnd("base64", Buffer.of(0x61), Buffer.of(), "YQ==");
-testEnd("base64", Buffer.of(0x61), Buffer.of(0x61), "YQ==YQ==");
-testEnd("base64", Buffer.of(0x61, 0x61), Buffer.of(), "YWE=");
-testEnd("base64", Buffer.of(0x61, 0x61), Buffer.of(0x61), "YWE=YQ==");
-testEnd("base64", Buffer.of(0x61, 0x61, 0x61), Buffer.of(), "YWFh");
-testEnd("base64", Buffer.of(0x61, 0x61, 0x61), Buffer.of(0x61), "YWFhYQ==");
-
-testEnd("base64url", Buffer.of(0x61), Buffer.of(), "YQ");
-testEnd("base64url", Buffer.of(0x61), Buffer.of(0x61), "YQYQ");
-testEnd("base64url", Buffer.of(0x61, 0x61), Buffer.of(), "YWE");
-testEnd("base64url", Buffer.of(0x61, 0x61), Buffer.of(0x61), "YWEYQ");
-testEnd("base64url", Buffer.of(0x61, 0x61, 0x61), Buffer.of(), "YWFh");
-testEnd("base64url", Buffer.of(0x61, 0x61, 0x61), Buffer.of(0x61), "YWFhYQ");
-
-//<#END_FILE: test-string-decoder-end.js
diff --git a/test/js/node/test/parallel/sys.test.js b/test/js/node/test/parallel/sys.test.js
deleted file mode 100644
index eb25bc0689..0000000000
--- a/test/js/node/test/parallel/sys.test.js
+++ /dev/null
@@ -1,34 +0,0 @@
-//#FILE: test-sys.js
-//#SHA1: a7732f65863d5e2856179378dc44f09f2b315650
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-const sys = require("sys"); // eslint-disable-line no-restricted-modules
-const util = require("util");
-
-test("sys module is identical to util module", () => {
-  expect(sys).toBe(util);
-});
-
-//<#END_FILE: test-sys.js
diff --git a/test/js/node/test/parallel/tcp-wrap-connect.test.js b/test/js/node/test/parallel/tcp-wrap-connect.test.js
deleted file mode 100644
index 819fd28e18..0000000000
--- a/test/js/node/test/parallel/tcp-wrap-connect.test.js
+++ /dev/null
@@ -1,53 +0,0 @@
-//#FILE: test-tcp-wrap-connect.js
-//#SHA1: cc302b52d997beac187400587ce2dffc0978a7da
-//-----------------
-"use strict";
-
-const net = require("net");
-
-let connectCount = 0;
-let endCount = 0;
-let shutdownCount = 0;
-
-function makeConnection(server) {
-  return new Promise((resolve, reject) => {
-    const client = new net.Socket();
-
-    client.connect(server.address().port, "127.0.0.1", () => {
-      expect(client.readable).toBe(true);
-      expect(client.writable).toBe(true);
-
-      client.end(() => {
-        shutdownCount++;
-        client.destroy();
-        resolve();
-      });
-    });
-
-    client.on("error", reject);
-  });
-}
-
-test("TCP connection and shutdown", async () => {
-  const server = net.createServer(socket => {
-    connectCount++;
-    socket.resume();
-    socket.on("end", () => {
-      endCount++;
-      socket.destroy();
-      server.close();
-    });
-  });
-
-  await new Promise(resolve => server.listen(0, resolve));
-
-  await makeConnection(server);
-
-  await new Promise(resolve => server.on("close", resolve));
-
-  expect(shutdownCount).toBe(1);
-  expect(connectCount).toBe(1);
-  expect(endCount).toBe(1);
-});
-
-//<#END_FILE: test-tcp-wrap-connect.js
diff --git a/test/js/node/test/parallel/test-arm-math-illegal-instruction.js b/test/js/node/test/parallel/test-arm-math-illegal-instruction.js
new file mode 100644
index 0000000000..4bf881d1b3
--- /dev/null
+++ b/test/js/node/test/parallel/test-arm-math-illegal-instruction.js
@@ -0,0 +1,15 @@
+'use strict';
+require('../common');
+
+// This test ensures Math functions don't fail with an "illegal instruction"
+// error on ARM devices (primarily on the Raspberry Pi 1)
+// See https://github.com/nodejs/node/issues/1376
+// and https://code.google.com/p/v8/issues/detail?id=4019
+
+// Iterate over all Math functions
+Object.getOwnPropertyNames(Math).forEach((functionName) => {
+  if (!/[A-Z]/.test(functionName)) {
+    // The function names don't have capital letters.
+    Math[functionName](-0.5);
+  }
+});
diff --git a/test/js/node/test/parallel/test-assert-builtins-not-read-from-filesystem.js b/test/js/node/test/parallel/test-assert-builtins-not-read-from-filesystem.js
new file mode 100644
index 0000000000..7a713a2ea4
--- /dev/null
+++ b/test/js/node/test/parallel/test-assert-builtins-not-read-from-filesystem.js
@@ -0,0 +1,48 @@
+'use strict';
+
+// Do not read filesystem when creating AssertionError messages for code in
+// builtin modules.
+
+require('../common');
+const assert = require('assert');
+const EventEmitter = require('events');
+const e = new EventEmitter();
+e.on('hello', assert);
+
+if (process.argv[2] !== 'child') {
+  const tmpdir = require('../common/tmpdir');
+  tmpdir.refresh();
+  const { spawnSync } = require('child_process');
+
+  let threw = false;
+  try {
+    e.emit('hello', false);
+  } catch (err) {
+    const frames = err.stack.split('\n');
+    const [, filename, line, column] = frames[1].match(/\((.+):(\d+):(\d+)\)/);
+    // Spawn a child process to avoid the error having been cached in the assert
+    // module's `errorCache` Map.
+
+    const { output, status, error } =
+      spawnSync(process.execPath,
+                [process.argv[1], 'child', filename, line, column],
+                { cwd: tmpdir.path, env: process.env });
+    assert.ifError(error);
+    assert.strictEqual(status, 0, `Exit code: ${status}\n${output}`);
+    threw = true;
+  }
+  assert.ok(threw);
+} else {
+  const { writeFileSync } = require('fs');
+  const [, , , filename, line, column] = process.argv;
+  const data = `${'\n'.repeat(line - 1)}${' '.repeat(column - 1)}` +
+               'ok(failed(badly));';
+
+  writeFileSync(filename, data);
+  assert.throws(
+    () => e.emit('hello', false),
+    {
+      message: 'false == true'
+    }
+  );
+}
diff --git a/test/js/node/test/parallel/test-assert-strict-exists.js b/test/js/node/test/parallel/test-assert-strict-exists.js
new file mode 100644
index 0000000000..50cd8a49a7
--- /dev/null
+++ b/test/js/node/test/parallel/test-assert-strict-exists.js
@@ -0,0 +1,6 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+
+assert.strictEqual(require('assert/strict'), assert.strict);
diff --git a/test/js/node/test/parallel/test-async-hooks-recursive-stack-runInAsyncScope.js b/test/js/node/test/parallel/test-async-hooks-recursive-stack-runInAsyncScope.js
new file mode 100644
index 0000000000..bc4ac86e7f
--- /dev/null
+++ b/test/js/node/test/parallel/test-async-hooks-recursive-stack-runInAsyncScope.js
@@ -0,0 +1,20 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const async_hooks = require('async_hooks');
+
+// This test verifies that the async ID stack can grow indefinitely.
+
+function recurse(n) {
+  const a = new async_hooks.AsyncResource('foobar');
+  a.runInAsyncScope(() => {
+    assert.strictEqual(a.asyncId(), async_hooks.executionAsyncId());
+    assert.strictEqual(a.triggerAsyncId(), async_hooks.triggerAsyncId());
+    if (n >= 0)
+      recurse(n - 1);
+    assert.strictEqual(a.asyncId(), async_hooks.executionAsyncId());
+    assert.strictEqual(a.triggerAsyncId(), async_hooks.triggerAsyncId());
+  });
+}
+
+recurse(1000);
diff --git a/test/js/node/test/parallel/test-async-hooks-run-in-async-scope-caught-exception.js b/test/js/node/test/parallel/test-async-hooks-run-in-async-scope-caught-exception.js
new file mode 100644
index 0000000000..e38cefd20e
--- /dev/null
+++ b/test/js/node/test/parallel/test-async-hooks-run-in-async-scope-caught-exception.js
@@ -0,0 +1,11 @@
+'use strict';
+
+require('../common');
+const { AsyncResource } = require('async_hooks');
+
+try {
+  new AsyncResource('foo').runInAsyncScope(() => { throw new Error('bar'); });
+} catch {
+  // Continue regardless of error.
+}
+// Should abort (fail the case) if async id is not matching.
diff --git a/test/js/node/test/parallel/test-async-hooks-run-in-async-scope-this-arg.js b/test/js/node/test/parallel/test-async-hooks-run-in-async-scope-this-arg.js
new file mode 100644
index 0000000000..a5016da9d5
--- /dev/null
+++ b/test/js/node/test/parallel/test-async-hooks-run-in-async-scope-this-arg.js
@@ -0,0 +1,17 @@
+'use strict';
+
+// Test that passing thisArg to runInAsyncScope() works.
+
+const common = require('../common');
+const assert = require('assert');
+const { AsyncResource } = require('async_hooks');
+
+const thisArg = {};
+
+const res = new AsyncResource('fhqwhgads');
+
+function callback() {
+  assert.strictEqual(this, thisArg);
+}
+
+res.runInAsyncScope(common.mustCall(callback), thisArg);
diff --git a/test/js/node/test/parallel/test-async-hooks-worker-asyncfn-terminate-1.js b/test/js/node/test/parallel/test-async-hooks-worker-asyncfn-terminate-1.js
new file mode 100644
index 0000000000..eb16645913
--- /dev/null
+++ b/test/js/node/test/parallel/test-async-hooks-worker-asyncfn-terminate-1.js
@@ -0,0 +1,15 @@
+'use strict';
+const common = require('../common');
+const { Worker } = require('worker_threads');
+
+const w = new Worker(`
+const { createHook } = require('async_hooks');
+
+setImmediate(async () => {
+  createHook({ init() {} }).enable();
+  await 0;
+  process.exit();
+});
+`, { eval: true });
+
+w.on('exit', common.mustCall());
diff --git a/test/js/node/test/parallel/test-async-hooks-worker-asyncfn-terminate-2.js b/test/js/node/test/parallel/test-async-hooks-worker-asyncfn-terminate-2.js
new file mode 100644
index 0000000000..049264d3e8
--- /dev/null
+++ b/test/js/node/test/parallel/test-async-hooks-worker-asyncfn-terminate-2.js
@@ -0,0 +1,21 @@
+'use strict';
+const common = require('../common');
+const { Worker } = require('worker_threads');
+
+// Like test-async-hooks-worker-promise.js but with the `await` and `createHook`
+// lines switched, because that resulted in different assertion failures
+// (one a Node.js assertion and one a V8 DCHECK) and it seems prudent to
+// cover both of those failures.
+
+const w = new Worker(`
+const { createHook } = require('async_hooks');
+
+setImmediate(async () => {
+  await 0;
+  createHook({ init() {} }).enable();
+  process.exit();
+});
+`, { eval: true });
+
+w.postMessage({});
+w.on('exit', common.mustCall());
diff --git a/test/js/node/test/parallel/test-async-hooks-worker-asyncfn-terminate-3.js b/test/js/node/test/parallel/test-async-hooks-worker-asyncfn-terminate-3.js
new file mode 100644
index 0000000000..40c7d85835
--- /dev/null
+++ b/test/js/node/test/parallel/test-async-hooks-worker-asyncfn-terminate-3.js
@@ -0,0 +1,20 @@
+'use strict';
+const common = require('../common');
+const { Worker } = require('worker_threads');
+
+// Like test-async-hooks-worker-promise.js but with an additional statement
+// after the `process.exit()` call, that shouldn’t really make a difference
+// but apparently does.
+
+const w = new Worker(`
+const { createHook } = require('async_hooks');
+
+setImmediate(async () => {
+  createHook({ init() {} }).enable();
+  await 0;
+  process.exit();
+  process._rawDebug('THIS SHOULD NEVER BE REACHED');
+});
+`, { eval: true });
+
+w.on('exit', common.mustCall());
diff --git a/test/js/node/test/parallel/test-async-hooks-worker-asyncfn-terminate-4.js b/test/js/node/test/parallel/test-async-hooks-worker-asyncfn-terminate-4.js
new file mode 100644
index 0000000000..c522091006
--- /dev/null
+++ b/test/js/node/test/parallel/test-async-hooks-worker-asyncfn-terminate-4.js
@@ -0,0 +1,25 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const { Worker } = require('worker_threads');
+
+// Like test-async-hooks-worker-promise.js but doing a trivial counter increase
+// after process.exit(). This should not make a difference, but apparently it
+// does. This is *also* different from test-async-hooks-worker-promise-3.js,
+// in that the statement is an ArrayBuffer access rather than a full method,
+// which *also* makes a difference even though it shouldn’t.
+
+const workerData = new Int32Array(new SharedArrayBuffer(4));
+const w = new Worker(`
+const { createHook } = require('async_hooks');
+const { workerData } = require('worker_threads');
+
+setImmediate(async () => {
+  createHook({ init() {} }).enable();
+  await 0;
+  process.exit();
+  workerData[0]++;
+});
+`, { eval: true, workerData });
+
+w.on('exit', common.mustCall(() => assert.strictEqual(workerData[0], 0)));
diff --git a/test/js/node/test/parallel/test-async-local-storage-contexts.js b/test/js/node/test/parallel/test-async-local-storage-contexts.js
new file mode 100644
index 0000000000..9a63271337
--- /dev/null
+++ b/test/js/node/test/parallel/test-async-local-storage-contexts.js
@@ -0,0 +1,35 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const vm = require('vm');
+const { AsyncLocalStorage } = require('async_hooks');
+
+// Regression test for https://github.com/nodejs/node/issues/38781
+
+const context = vm.createContext({
+  AsyncLocalStorage,
+  assert
+});
+
+vm.runInContext(`
+  const storage = new AsyncLocalStorage()
+  async function test() {
+    return storage.run({ test: 'vm' }, async () => {
+      assert.strictEqual(storage.getStore().test, 'vm');
+      await 42;
+      assert.strictEqual(storage.getStore().test, 'vm');
+    });
+  }
+  test()
+`, context);
+
+const storage = new AsyncLocalStorage();
+async function test() {
+  return storage.run({ test: 'main context' }, async () => {
+    assert.strictEqual(storage.getStore().test, 'main context');
+    await 42;
+    assert.strictEqual(storage.getStore().test, 'main context');
+  });
+}
+test();
diff --git a/test/js/node/test/parallel/test-async-local-storage-deep-stack.js b/test/js/node/test/parallel/test-async-local-storage-deep-stack.js
new file mode 100644
index 0000000000..b5e1048d94
--- /dev/null
+++ b/test/js/node/test/parallel/test-async-local-storage-deep-stack.js
@@ -0,0 +1,15 @@
+'use strict';
+const common = require('../common');
+const { AsyncLocalStorage } = require('async_hooks');
+
+// Regression test for: https://github.com/nodejs/node/issues/34556
+
+const als = new AsyncLocalStorage();
+
+const done = common.mustCall();
+
+function run(count) {
+  if (count !== 0) return als.run({}, run, --count);
+  done();
+}
+run(1000);
diff --git a/test/js/node/test/parallel/test-async-local-storage-http-multiclients.js b/test/js/node/test/parallel/test-async-local-storage-http-multiclients.js
new file mode 100644
index 0000000000..1903d5825d
--- /dev/null
+++ b/test/js/node/test/parallel/test-async-local-storage-http-multiclients.js
@@ -0,0 +1,65 @@
+'use strict';
+const common = require('../common');
+const Countdown = require('../common/countdown');
+const assert = require('assert');
+const { AsyncLocalStorage } = require('async_hooks');
+const http = require('http');
+const cls = new AsyncLocalStorage();
+const NUM_CLIENTS = 10;
+
+// Run multiple clients that receive data from a server
+// in multiple chunks, in a single non-closure function.
+// Use the AsyncLocalStorage (ALS) APIs to maintain the context
+// and data download. Make sure that individual clients
+// receive their respective data, with no conflicts.
+
+// Set up a server that sends large buffers of data, filled
+// with cardinal numbers, increasing per request
+let index = 0;
+const server = http.createServer((q, r) => {
+  // Send a large chunk as response, otherwise the data
+  // may be sent in a single chunk, and the callback in the
+  // client may be called only once, defeating the purpose of test
+  r.end((index++ % 10).toString().repeat(1024 * 1024));
+});
+
+const countdown = new Countdown(NUM_CLIENTS, () => {
+  server.close();
+});
+
+server.listen(0, common.mustCall(() => {
+  for (let i = 0; i < NUM_CLIENTS; i++) {
+    cls.run(new Map(), common.mustCall(() => {
+      const options = { port: server.address().port };
+      const req = http.get(options, common.mustCall((res) => {
+        const store = cls.getStore();
+        store.set('data', '');
+
+        // Make ondata and onend non-closure
+        // functions and fully dependent on ALS
+        res.setEncoding('utf8');
+        res.on('data', ondata);
+        res.on('end', common.mustCall(onend));
+      }));
+      req.end();
+    }));
+  }
+}));
+
+// Accumulate the current data chunk with the store data
+function ondata(d) {
+  const store = cls.getStore();
+  assert.notStrictEqual(store, undefined);
+  let chunk = store.get('data');
+  chunk += d;
+  store.set('data', chunk);
+}
+
+// Retrieve the store data, and test for homogeneity
+function onend() {
+  const store = cls.getStore();
+  assert.notStrictEqual(store, undefined);
+  const data = store.get('data');
+  assert.strictEqual(data, data[0].repeat(data.length));
+  countdown.dec();
+}
diff --git a/test/js/node/test/parallel/test-async-local-storage-snapshot.js b/test/js/node/test/parallel/test-async-local-storage-snapshot.js
new file mode 100644
index 0000000000..63e47ba3ce
--- /dev/null
+++ b/test/js/node/test/parallel/test-async-local-storage-snapshot.js
@@ -0,0 +1,16 @@
+'use strict';
+
+const common = require('../common');
+const { strictEqual } = require('assert');
+const { AsyncLocalStorage } = require('async_hooks');
+
+const asyncLocalStorage = new AsyncLocalStorage();
+const runInAsyncScope =
+  asyncLocalStorage.run(123, common.mustCall(() => AsyncLocalStorage.snapshot()));
+const result =
+  asyncLocalStorage.run(321, common.mustCall(() => {
+    return runInAsyncScope(() => {
+      return asyncLocalStorage.getStore();
+    });
+  }));
+strictEqual(result, 123);
diff --git a/test/js/node/test/parallel/test-atomics-wake.js b/test/js/node/test/parallel/test-atomics-wake.js
new file mode 100644
index 0000000000..0f38700176
--- /dev/null
+++ b/test/js/node/test/parallel/test-atomics-wake.js
@@ -0,0 +1,7 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+
+// https://github.com/nodejs/node/issues/21219
+assert.strictEqual(Atomics.wake, undefined);
diff --git a/test/js/node/test/parallel/test-bad-unicode.js b/test/js/node/test/parallel/test-bad-unicode.js
new file mode 100644
index 0000000000..b4fccc0644
--- /dev/null
+++ b/test/js/node/test/parallel/test-bad-unicode.js
@@ -0,0 +1,33 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+let exception = null;
+
+try {
+  eval('"\\uc/ef"');
+} catch (e) {
+  exception = e;
+}
+
+assert(exception instanceof SyntaxError);
diff --git a/test/js/node/test/parallel/test-beforeexit-event-exit.js b/test/js/node/test/parallel/test-beforeexit-event-exit.js
new file mode 100644
index 0000000000..4210ad04b6
--- /dev/null
+++ b/test/js/node/test/parallel/test-beforeexit-event-exit.js
@@ -0,0 +1,27 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const { mustNotCall } = require('../common');
+
+process.on('beforeExit', mustNotCall('exit should not allow this to occur'));
+
+process.exit();
diff --git a/test/js/node/test/parallel/test-blob-createobjecturl.js b/test/js/node/test/parallel/test-blob-createobjecturl.js
new file mode 100644
index 0000000000..614b8ae4a6
--- /dev/null
+++ b/test/js/node/test/parallel/test-blob-createobjecturl.js
@@ -0,0 +1,54 @@
+// Flags: --no-warnings
+'use strict';
+
+const common = require('../common');
+
+// Because registering a Blob URL requires generating a random
+// UUID, it can only be done if crypto support is enabled.
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const {
+  URL,
+} = require('url');
+
+const {
+  Blob,
+  resolveObjectURL,
+} = require('buffer');
+
+const assert = require('assert');
+
+(async () => {
+  const blob = new Blob(['hello']);
+  const id = URL.createObjectURL(blob);
+  assert.strictEqual(typeof id, 'string');
+  const otherBlob = resolveObjectURL(id);
+  assert.ok(otherBlob instanceof Blob);
+  assert.strictEqual(otherBlob.constructor, Blob);
+  assert.strictEqual(otherBlob.size, 5);
+  assert.strictEqual(
+    Buffer.from(await otherBlob.arrayBuffer()).toString(),
+    'hello');
+  URL.revokeObjectURL(id);
+
+  // should do nothing
+  URL.revokeObjectURL(id);
+
+  assert.strictEqual(resolveObjectURL(id), undefined);
+
+  // Leaving a Blob registered should not cause an assert
+  // when Node.js exists
+  URL.createObjectURL(new Blob());
+
+})().then(common.mustCall());
+
+['not a url', undefined, 1, 'blob:nodedata:1:wrong', {}].forEach((i) => {
+  assert.strictEqual(resolveObjectURL(i), undefined);
+});
+
+[undefined, 1, '', false, {}].forEach((i) => {
+  assert.throws(() => URL.createObjectURL(i), {
+    code: 'ERR_INVALID_ARG_TYPE',
+  });
+});
diff --git a/test/js/node/test/parallel/test-btoa-atob.js b/test/js/node/test/parallel/test-btoa-atob.js
new file mode 100644
index 0000000000..abf05adeef
--- /dev/null
+++ b/test/js/node/test/parallel/test-btoa-atob.js
@@ -0,0 +1,39 @@
+'use strict';
+
+require('../common');
+
+const { strictEqual, throws } = require('assert');
+const buffer = require('buffer');
+
+// Exported on the global object
+strictEqual(globalThis.atob, buffer.atob);
+strictEqual(globalThis.btoa, buffer.btoa);
+
+// Throws type error on no argument passed
+throws(() => buffer.atob(), /TypeError/);
+throws(() => buffer.btoa(), /TypeError/);
+
+strictEqual(atob(' '), '');
+strictEqual(atob('  Y\fW\tJ\njZ A=\r= '), 'abcd');
+
+strictEqual(atob(null), '\x9Eée');
+strictEqual(atob(NaN), '5£');
+strictEqual(atob(Infinity), '"wâ\x9E+r');
+strictEqual(atob(true), '¶»\x9E');
+strictEqual(atob(1234), '×mø');
+strictEqual(atob([]), '');
+strictEqual(atob({ toString: () => '' }), '');
+strictEqual(atob({ [Symbol.toPrimitive]: () => '' }), '');
+
+throws(() => atob(Symbol()), /TypeError/);
+[
+  undefined, false, () => {}, {}, [1],
+  0, 1, 0n, 1n, -Infinity,
+  'a', 'a\n\n\n', '\ra\r\r', '  a ', '\t\t\ta', 'a\f\f\f', '\ta\r \n\f',
+].forEach((value) =>
+  // See #2 - https://html.spec.whatwg.org/multipage/webappapis.html#dom-atob
+  throws(() => atob(value), {
+    constructor: DOMException,
+    name: 'InvalidCharacterError',
+    code: 5,
+  }));
diff --git a/test/js/node/test/parallel/test-buffer-ascii.js b/test/js/node/test/parallel/test-buffer-ascii.js
new file mode 100644
index 0000000000..afedb7252c
--- /dev/null
+++ b/test/js/node/test/parallel/test-buffer-ascii.js
@@ -0,0 +1,46 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+
+// ASCII conversion in node.js simply masks off the high bits,
+// it doesn't do transliteration.
+assert.strictEqual(Buffer.from('hérité').toString('ascii'), 'hC)ritC)');
+
+// 71 characters, 78 bytes. The ’ character is a triple-byte sequence.
+const input = 'C’est, graphiquement, la réunion d’un accent aigu ' +
+              'et d’un accent grave.';
+
+const expected = 'Cb\u0000\u0019est, graphiquement, la rC)union ' +
+                 'db\u0000\u0019un accent aigu et db\u0000\u0019un ' +
+                 'accent grave.';
+
+const buf = Buffer.from(input);
+
+for (let i = 0; i < expected.length; ++i) {
+  assert.strictEqual(buf.slice(i).toString('ascii'), expected.slice(i));
+
+  // Skip remainder of multi-byte sequence.
+  if (input.charCodeAt(i) > 65535) ++i;
+  if (input.charCodeAt(i) > 127) ++i;
+}
diff --git a/test/js/node/test/parallel/test-buffer-compare-offset.js b/test/js/node/test/parallel/test-buffer-compare-offset.js
new file mode 100644
index 0000000000..9f6f733547
--- /dev/null
+++ b/test/js/node/test/parallel/test-buffer-compare-offset.js
@@ -0,0 +1,94 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+
+const a = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8, 9, 0]);
+const b = Buffer.from([5, 6, 7, 8, 9, 0, 1, 2, 3, 4]);
+
+assert.strictEqual(a.compare(b), -1);
+
+// Equivalent to a.compare(b).
+assert.strictEqual(a.compare(b, 0), -1);
+assert.throws(() => a.compare(b, '0'), { code: 'ERR_INVALID_ARG_TYPE' });
+assert.strictEqual(a.compare(b, undefined), -1);
+
+// Equivalent to a.compare(b).
+assert.strictEqual(a.compare(b, 0, undefined, 0), -1);
+
+// Zero-length target, return 1
+assert.strictEqual(a.compare(b, 0, 0, 0), 1);
+assert.throws(
+  () => a.compare(b, 0, '0', '0'),
+  { code: 'ERR_INVALID_ARG_TYPE' }
+);
+
+// Equivalent to Buffer.compare(a, b.slice(6, 10))
+assert.strictEqual(a.compare(b, 6, 10), 1);
+
+// Zero-length source, return -1
+assert.strictEqual(a.compare(b, 6, 10, 0, 0), -1);
+
+// Zero-length source and target, return 0
+assert.strictEqual(a.compare(b, 0, 0, 0, 0), 0);
+assert.strictEqual(a.compare(b, 1, 1, 2, 2), 0);
+
+// Equivalent to Buffer.compare(a.slice(4), b.slice(0, 5))
+assert.strictEqual(a.compare(b, 0, 5, 4), 1);
+
+// Equivalent to Buffer.compare(a.slice(1), b.slice(5))
+assert.strictEqual(a.compare(b, 5, undefined, 1), 1);
+
+// Equivalent to Buffer.compare(a.slice(2), b.slice(2, 4))
+assert.strictEqual(a.compare(b, 2, 4, 2), -1);
+
+// Equivalent to Buffer.compare(a.slice(4), b.slice(0, 7))
+assert.strictEqual(a.compare(b, 0, 7, 4), -1);
+
+// Equivalent to Buffer.compare(a.slice(4, 6), b.slice(0, 7));
+assert.strictEqual(a.compare(b, 0, 7, 4, 6), -1);
+
+// Null is ambiguous.
+assert.throws(
+  () => a.compare(b, 0, null),
+  { code: 'ERR_INVALID_ARG_TYPE' }
+);
+
+// Values do not get coerced.
+assert.throws(
+  () => a.compare(b, 0, { valueOf: () => 5 }),
+  { code: 'ERR_INVALID_ARG_TYPE' }
+);
+
+// Infinity should not be coerced.
+assert.throws(
+  () => a.compare(b, Infinity, -Infinity),
+  { code: 'ERR_OUT_OF_RANGE' }
+);
+
+// Zero length target because default for targetEnd <= targetSource
+assert.strictEqual(a.compare(b, 0xff), 1);
+
+assert.throws(
+  () => a.compare(b, '0xff'),
+  { code: 'ERR_INVALID_ARG_TYPE' }
+);
+assert.throws(
+  () => a.compare(b, 0, '0xff'),
+  { code: 'ERR_INVALID_ARG_TYPE' }
+);
+
+const oor = { code: 'ERR_OUT_OF_RANGE' };
+
+assert.throws(() => a.compare(b, 0, 100, 0), oor);
+assert.throws(() => a.compare(b, 0, 1, 0, 100), oor);
+assert.throws(() => a.compare(b, -1), oor);
+assert.throws(() => a.compare(b, 0, Infinity), oor);
+assert.throws(() => a.compare(b, 0, 1, -1), oor);
+assert.throws(() => a.compare(b, -Infinity, Infinity), oor);
+assert.throws(() => a.compare(), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  name: 'TypeError',
+  message: 'The "target" argument must be an instance of ' +
+           'Buffer or Uint8Array. Received undefined'
+});
diff --git a/test/js/node/test/parallel/test-buffer-failed-alloc-typed-arrays.js b/test/js/node/test/parallel/test-buffer-failed-alloc-typed-arrays.js
new file mode 100644
index 0000000000..699475ad0a
--- /dev/null
+++ b/test/js/node/test/parallel/test-buffer-failed-alloc-typed-arrays.js
@@ -0,0 +1,33 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const SlowBuffer = require('buffer').SlowBuffer;
+
+// Test failed or zero-sized Buffer allocations not affecting typed arrays.
+// This test exists because of a regression that occurred. Because Buffer
+// instances are allocated with the same underlying allocator as TypedArrays,
+// but Buffer's can optional be non-zero filled, there was a regression that
+// occurred when a Buffer allocated failed, the internal flag specifying
+// whether or not to zero-fill was not being reset, causing TypedArrays to
+// allocate incorrectly.
+const zeroArray = new Uint32Array(10).fill(0);
+const sizes = [1e20, 0, 0.1, -1, 'a', undefined, null, NaN];
+const allocators = [
+  Buffer,
+  SlowBuffer,
+  Buffer.alloc,
+  Buffer.allocUnsafe,
+  Buffer.allocUnsafeSlow,
+];
+for (const allocator of allocators) {
+  for (const size of sizes) {
+    try {
+      // Some of these allocations are known to fail. If they do,
+      // Uint32Array should still produce a zeroed out result.
+      allocator(size);
+    } catch {
+      assert.deepStrictEqual(zeroArray, new Uint32Array(10));
+    }
+  }
+}
diff --git a/test/js/node/test/parallel/test-buffer-fakes.js b/test/js/node/test/parallel/test-buffer-fakes.js
new file mode 100644
index 0000000000..da78fe0895
--- /dev/null
+++ b/test/js/node/test/parallel/test-buffer-fakes.js
@@ -0,0 +1,54 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+
+function FakeBuffer() { }
+Object.setPrototypeOf(FakeBuffer, Buffer);
+Object.setPrototypeOf(FakeBuffer.prototype, Buffer.prototype);
+
+const fb = new FakeBuffer();
+
+assert.throws(function() {
+  Buffer.from(fb);
+}, TypeError);
+
+assert.throws(function() {
+  +Buffer.prototype; // eslint-disable-line no-unused-expressions
+}, TypeError);
+
+assert.throws(function() {
+  Buffer.compare(fb, Buffer.alloc(0));
+}, TypeError);
+
+assert.throws(function() {
+  fb.write('foo');
+}, TypeError);
+
+assert.throws(function() {
+  Buffer.concat([fb, fb]);
+}, TypeError);
+
+assert.throws(function() {
+  fb.toString();
+}, TypeError);
+
+assert.throws(function() {
+  fb.equals(Buffer.alloc(0));
+}, TypeError);
+
+assert.throws(function() {
+  fb.indexOf(5);
+}, TypeError);
+
+assert.throws(function() {
+  fb.readFloatLE(0);
+}, TypeError);
+
+assert.throws(function() {
+  fb.writeFloatLE(0);
+}, TypeError);
+
+assert.throws(function() {
+  fb.fill(0);
+}, TypeError);
diff --git a/test/js/node/test/parallel/test-buffer-inheritance.js b/test/js/node/test/parallel/test-buffer-inheritance.js
new file mode 100644
index 0000000000..4794f56717
--- /dev/null
+++ b/test/js/node/test/parallel/test-buffer-inheritance.js
@@ -0,0 +1,39 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+
+
+function T(n) {
+  const ui8 = new Uint8Array(n);
+  Object.setPrototypeOf(ui8, T.prototype);
+  return ui8;
+}
+Object.setPrototypeOf(T.prototype, Buffer.prototype);
+Object.setPrototypeOf(T, Buffer);
+
+T.prototype.sum = function sum() {
+  let cntr = 0;
+  for (let i = 0; i < this.length; i++)
+    cntr += this[i];
+  return cntr;
+};
+
+
+const vals = [new T(4), T(4)];
+
+vals.forEach(function(t) {
+  assert.strictEqual(t.constructor, T);
+  assert.strictEqual(Object.getPrototypeOf(t), T.prototype);
+  assert.strictEqual(Object.getPrototypeOf(Object.getPrototypeOf(t)),
+                     Buffer.prototype);
+
+  t.fill(5);
+  let cntr = 0;
+  for (let i = 0; i < t.length; i++)
+    cntr += t[i];
+  assert.strictEqual(cntr, t.length * 5);
+
+  // Check this does not throw
+  t.toString();
+});
diff --git a/test/js/node/test/parallel/test-buffer-isascii.js b/test/js/node/test/parallel/test-buffer-isascii.js
new file mode 100644
index 0000000000..b9468ca133
--- /dev/null
+++ b/test/js/node/test/parallel/test-buffer-isascii.js
@@ -0,0 +1,42 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const { isAscii, Buffer } = require('buffer');
+const { TextEncoder } = require('util');
+
+const encoder = new TextEncoder();
+
+assert.strictEqual(isAscii(encoder.encode('hello')), true);
+assert.strictEqual(isAscii(encoder.encode('ğ')), false);
+assert.strictEqual(isAscii(Buffer.from([])), true);
+
+[
+  undefined,
+  '', 'hello',
+  false, true,
+  0, 1,
+  0n, 1n,
+  Symbol(),
+  () => {},
+  {}, [], null,
+].forEach((input) => {
+  assert.throws(
+    () => { isAscii(input); },
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+    },
+  );
+});
+
+{
+  // Test with detached array buffers
+  const arrayBuffer = new ArrayBuffer(1024);
+  structuredClone(arrayBuffer, { transfer: [arrayBuffer] });
+  assert.throws(
+    () => { isAscii(arrayBuffer); },
+    {
+      code: 'ERR_INVALID_STATE'
+    }
+  );
+}
diff --git a/test/js/node/test/parallel/test-buffer-isencoding.js b/test/js/node/test/parallel/test-buffer-isencoding.js
new file mode 100644
index 0000000000..f9150055cc
--- /dev/null
+++ b/test/js/node/test/parallel/test-buffer-isencoding.js
@@ -0,0 +1,38 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+
+[
+  'hex',
+  'utf8',
+  'utf-8',
+  'ascii',
+  'latin1',
+  'binary',
+  'base64',
+  'base64url',
+  'ucs2',
+  'ucs-2',
+  'utf16le',
+  'utf-16le',
+].forEach((enc) => {
+  assert.strictEqual(Buffer.isEncoding(enc), true);
+});
+
+[
+  'utf9',
+  'utf-7',
+  'Unicode-FTW',
+  'new gnu gun',
+  false,
+  NaN,
+  {},
+  Infinity,
+  [],
+  1,
+  0,
+  -1,
+].forEach((enc) => {
+  assert.strictEqual(Buffer.isEncoding(enc), false);
+});
diff --git a/test/js/node/test/parallel/test-buffer-isutf8.js b/test/js/node/test/parallel/test-buffer-isutf8.js
new file mode 100644
index 0000000000..204db3e6a5
--- /dev/null
+++ b/test/js/node/test/parallel/test-buffer-isutf8.js
@@ -0,0 +1,86 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const { isUtf8, Buffer } = require('buffer');
+const { TextEncoder } = require('util');
+
+const encoder = new TextEncoder();
+
+assert.strictEqual(isUtf8(encoder.encode('hello')), true);
+assert.strictEqual(isUtf8(encoder.encode('ğ')), true);
+assert.strictEqual(isUtf8(Buffer.from([])), true);
+
+// Taken from test/fixtures/wpt/encoding/textdecoder-fatal.any.js
+[
+  [0xFF], // 'invalid code'
+  [0xC0], // 'ends early'
+  [0xE0], // 'ends early 2'
+  [0xC0, 0x00], // 'invalid trail'
+  [0xC0, 0xC0], // 'invalid trail 2'
+  [0xE0, 0x00], // 'invalid trail 3'
+  [0xE0, 0xC0], // 'invalid trail 4'
+  [0xE0, 0x80, 0x00], // 'invalid trail 5'
+  [0xE0, 0x80, 0xC0], // 'invalid trail 6'
+  [0xFC, 0x80, 0x80, 0x80, 0x80, 0x80], // '> 0x10FFFF'
+  [0xFE, 0x80, 0x80, 0x80, 0x80, 0x80], // 'obsolete lead byte'
+
+  // Overlong encodings
+  [0xC0, 0x80], // 'overlong U+0000 - 2 bytes'
+  [0xE0, 0x80, 0x80], // 'overlong U+0000 - 3 bytes'
+  [0xF0, 0x80, 0x80, 0x80], // 'overlong U+0000 - 4 bytes'
+  [0xF8, 0x80, 0x80, 0x80, 0x80], // 'overlong U+0000 - 5 bytes'
+  [0xFC, 0x80, 0x80, 0x80, 0x80, 0x80], // 'overlong U+0000 - 6 bytes'
+
+  [0xC1, 0xBF], // 'overlong U+007F - 2 bytes'
+  [0xE0, 0x81, 0xBF], // 'overlong U+007F - 3 bytes'
+  [0xF0, 0x80, 0x81, 0xBF], // 'overlong U+007F - 4 bytes'
+  [0xF8, 0x80, 0x80, 0x81, 0xBF], // 'overlong U+007F - 5 bytes'
+  [0xFC, 0x80, 0x80, 0x80, 0x81, 0xBF], // 'overlong U+007F - 6 bytes'
+
+  [0xE0, 0x9F, 0xBF], // 'overlong U+07FF - 3 bytes'
+  [0xF0, 0x80, 0x9F, 0xBF], // 'overlong U+07FF - 4 bytes'
+  [0xF8, 0x80, 0x80, 0x9F, 0xBF], // 'overlong U+07FF - 5 bytes'
+  [0xFC, 0x80, 0x80, 0x80, 0x9F, 0xBF], // 'overlong U+07FF - 6 bytes'
+
+  [0xF0, 0x8F, 0xBF, 0xBF], // 'overlong U+FFFF - 4 bytes'
+  [0xF8, 0x80, 0x8F, 0xBF, 0xBF], // 'overlong U+FFFF - 5 bytes'
+  [0xFC, 0x80, 0x80, 0x8F, 0xBF, 0xBF], // 'overlong U+FFFF - 6 bytes'
+
+  [0xF8, 0x84, 0x8F, 0xBF, 0xBF], // 'overlong U+10FFFF - 5 bytes'
+  [0xFC, 0x80, 0x84, 0x8F, 0xBF, 0xBF], // 'overlong U+10FFFF - 6 bytes'
+
+  // UTF-16 surrogates encoded as code points in UTF-8
+  [0xED, 0xA0, 0x80], // 'lead surrogate'
+  [0xED, 0xB0, 0x80], // 'trail surrogate'
+  [0xED, 0xA0, 0x80, 0xED, 0xB0, 0x80], // 'surrogate pair'
+].forEach((input) => {
+  assert.strictEqual(isUtf8(Buffer.from(input)), false);
+});
+
+[
+  null,
+  undefined,
+  'hello',
+  true,
+  false,
+].forEach((input) => {
+  assert.throws(
+    () => { isUtf8(input); },
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+    },
+  );
+});
+
+{
+  // Test with detached array buffers
+  const arrayBuffer = new ArrayBuffer(1024);
+  structuredClone(arrayBuffer, { transfer: [arrayBuffer] });
+  assert.throws(
+    () => { isUtf8(arrayBuffer); },
+    {
+      code: 'ERR_INVALID_STATE'
+    }
+  );
+}
diff --git a/test/js/node/test/parallel/test-buffer-iterator.js b/test/js/node/test/parallel/test-buffer-iterator.js
new file mode 100644
index 0000000000..6cf64712c0
--- /dev/null
+++ b/test/js/node/test/parallel/test-buffer-iterator.js
@@ -0,0 +1,62 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+
+const buffer = Buffer.from([1, 2, 3, 4, 5]);
+let arr;
+let b;
+
+// Buffers should be iterable
+
+arr = [];
+
+for (b of buffer)
+  arr.push(b);
+
+assert.deepStrictEqual(arr, [1, 2, 3, 4, 5]);
+
+
+// Buffer iterators should be iterable
+
+arr = [];
+
+for (b of buffer[Symbol.iterator]())
+  arr.push(b);
+
+assert.deepStrictEqual(arr, [1, 2, 3, 4, 5]);
+
+
+// buffer#values() should return iterator for values
+
+arr = [];
+
+for (b of buffer.values())
+  arr.push(b);
+
+assert.deepStrictEqual(arr, [1, 2, 3, 4, 5]);
+
+
+// buffer#keys() should return iterator for keys
+
+arr = [];
+
+for (b of buffer.keys())
+  arr.push(b);
+
+assert.deepStrictEqual(arr, [0, 1, 2, 3, 4]);
+
+
+// buffer#entries() should return iterator for entries
+
+arr = [];
+
+for (b of buffer.entries())
+  arr.push(b);
+
+assert.deepStrictEqual(arr, [
+  [0, 1],
+  [1, 2],
+  [2, 3],
+  [3, 4],
+  [4, 5],
+]);
diff --git a/test/js/node/test/parallel/test-buffer-no-negative-allocation.js b/test/js/node/test/parallel/test-buffer-no-negative-allocation.js
new file mode 100644
index 0000000000..055e2d5dc6
--- /dev/null
+++ b/test/js/node/test/parallel/test-buffer-no-negative-allocation.js
@@ -0,0 +1,37 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const { SlowBuffer } = require('buffer');
+
+const msg = {
+  code: 'ERR_OUT_OF_RANGE',
+  name: 'RangeError',
+};
+
+// Test that negative Buffer length inputs throw errors.
+
+assert.throws(() => Buffer(-Buffer.poolSize), msg);
+assert.throws(() => Buffer(-100), msg);
+assert.throws(() => Buffer(-1), msg);
+assert.throws(() => Buffer(NaN), msg);
+
+assert.throws(() => Buffer.alloc(-Buffer.poolSize), msg);
+assert.throws(() => Buffer.alloc(-100), msg);
+assert.throws(() => Buffer.alloc(-1), msg);
+assert.throws(() => Buffer.alloc(NaN), msg);
+
+assert.throws(() => Buffer.allocUnsafe(-Buffer.poolSize), msg);
+assert.throws(() => Buffer.allocUnsafe(-100), msg);
+assert.throws(() => Buffer.allocUnsafe(-1), msg);
+assert.throws(() => Buffer.allocUnsafe(NaN), msg);
+
+assert.throws(() => Buffer.allocUnsafeSlow(-Buffer.poolSize), msg);
+assert.throws(() => Buffer.allocUnsafeSlow(-100), msg);
+assert.throws(() => Buffer.allocUnsafeSlow(-1), msg);
+assert.throws(() => Buffer.allocUnsafeSlow(NaN), msg);
+
+assert.throws(() => SlowBuffer(-Buffer.poolSize), msg);
+assert.throws(() => SlowBuffer(-100), msg);
+assert.throws(() => SlowBuffer(-1), msg);
+assert.throws(() => SlowBuffer(NaN), msg);
diff --git a/test/js/node/test/parallel/test-buffer-nopendingdep-map.js b/test/js/node/test/parallel/test-buffer-nopendingdep-map.js
new file mode 100644
index 0000000000..c85d184fbc
--- /dev/null
+++ b/test/js/node/test/parallel/test-buffer-nopendingdep-map.js
@@ -0,0 +1,13 @@
+// Flags: --no-warnings --pending-deprecation
+'use strict';
+
+const common = require('../common');
+
+process.on('warning', common.mustNotCall('A warning should not be emitted'));
+
+// With the --pending-deprecation flag, the deprecation warning for
+// new Buffer() should not be emitted when Uint8Array methods are called.
+
+Buffer.from('abc').map((i) => i);
+Buffer.from('abc').filter((i) => i);
+Buffer.from('abc').slice(1, 2);
diff --git a/test/js/node/test/parallel/test-buffer-of-no-deprecation.js b/test/js/node/test/parallel/test-buffer-of-no-deprecation.js
new file mode 100644
index 0000000000..d0ac75b4a3
--- /dev/null
+++ b/test/js/node/test/parallel/test-buffer-of-no-deprecation.js
@@ -0,0 +1,7 @@
+'use strict';
+
+const common = require('../common');
+
+process.on('warning', common.mustNotCall());
+
+Buffer.of(0, 1);
diff --git a/test/js/node/test/parallel/test-buffer-over-max-length.js b/test/js/node/test/parallel/test-buffer-over-max-length.js
new file mode 100644
index 0000000000..f29d6b62d4
--- /dev/null
+++ b/test/js/node/test/parallel/test-buffer-over-max-length.js
@@ -0,0 +1,19 @@
+'use strict';
+require('../common');
+
+const assert = require('assert');
+
+const buffer = require('buffer');
+const SlowBuffer = buffer.SlowBuffer;
+
+const kMaxLength = buffer.kMaxLength;
+const bufferMaxSizeMsg = {
+  code: 'ERR_OUT_OF_RANGE',
+  name: 'RangeError',
+};
+
+assert.throws(() => Buffer(kMaxLength + 1), bufferMaxSizeMsg);
+assert.throws(() => SlowBuffer(kMaxLength + 1), bufferMaxSizeMsg);
+assert.throws(() => Buffer.alloc(kMaxLength + 1), bufferMaxSizeMsg);
+assert.throws(() => Buffer.allocUnsafe(kMaxLength + 1), bufferMaxSizeMsg);
+assert.throws(() => Buffer.allocUnsafeSlow(kMaxLength + 1), bufferMaxSizeMsg);
diff --git a/test/js/node/test/parallel/test-buffer-parent-property.js b/test/js/node/test/parallel/test-buffer-parent-property.js
new file mode 100644
index 0000000000..24cdaade43
--- /dev/null
+++ b/test/js/node/test/parallel/test-buffer-parent-property.js
@@ -0,0 +1,21 @@
+'use strict';
+
+// Fix for https://github.com/nodejs/node/issues/8266
+//
+// Zero length Buffer objects should expose the `buffer` property of the
+// TypedArrays, via the `parent` property.
+require('../common');
+const assert = require('assert');
+
+// If the length of the buffer object is zero
+assert((new Buffer(0)).parent instanceof ArrayBuffer);
+
+// If the length of the buffer object is equal to the underlying ArrayBuffer
+assert((new Buffer(Buffer.poolSize)).parent instanceof ArrayBuffer);
+
+// Same as the previous test, but with user created buffer
+const arrayBuffer = new ArrayBuffer(0);
+assert.strictEqual(new Buffer(arrayBuffer).parent, arrayBuffer);
+assert.strictEqual(new Buffer(arrayBuffer).buffer, arrayBuffer);
+assert.strictEqual(Buffer.from(arrayBuffer).parent, arrayBuffer);
+assert.strictEqual(Buffer.from(arrayBuffer).buffer, arrayBuffer);
diff --git a/test/js/node/test/parallel/test-buffer-safe-unsafe.js b/test/js/node/test/parallel/test-buffer-safe-unsafe.js
new file mode 100644
index 0000000000..9f8b6b7410
--- /dev/null
+++ b/test/js/node/test/parallel/test-buffer-safe-unsafe.js
@@ -0,0 +1,24 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+
+const safe = Buffer.alloc(10);
+
+function isZeroFilled(buf) {
+  for (let n = 0; n < buf.length; n++)
+    if (buf[n] !== 0) return false;
+  return true;
+}
+
+assert(isZeroFilled(safe));
+
+// Test that unsafe allocations doesn't affect subsequent safe allocations
+Buffer.allocUnsafe(10);
+assert(isZeroFilled(new Float64Array(10)));
+
+new Buffer(10);
+assert(isZeroFilled(new Float64Array(10)));
+
+Buffer.allocUnsafe(10);
+assert(isZeroFilled(Buffer.alloc(10)));
diff --git a/test/js/node/test/parallel/test-buffer-set-inspect-max-bytes.js b/test/js/node/test/parallel/test-buffer-set-inspect-max-bytes.js
new file mode 100644
index 0000000000..975c828111
--- /dev/null
+++ b/test/js/node/test/parallel/test-buffer-set-inspect-max-bytes.js
@@ -0,0 +1,34 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const buffer = require('buffer');
+
+const rangeErrorObjs = [NaN, -1];
+const typeErrorObj = 'and even this';
+
+for (const obj of rangeErrorObjs) {
+  assert.throws(
+    () => buffer.INSPECT_MAX_BYTES = obj,
+    {
+      code: 'ERR_OUT_OF_RANGE',
+      name: 'RangeError',
+    }
+  );
+
+  assert.throws(
+    () => buffer.INSPECT_MAX_BYTES = obj,
+    {
+      code: 'ERR_OUT_OF_RANGE',
+      name: 'RangeError',
+    }
+  );
+}
+
+assert.throws(
+  () => buffer.INSPECT_MAX_BYTES = typeErrorObj,
+  {
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError',
+  }
+);
diff --git a/test/js/node/test/parallel/test-buffer-slice.js b/test/js/node/test/parallel/test-buffer-slice.js
new file mode 100644
index 0000000000..52720bb87b
--- /dev/null
+++ b/test/js/node/test/parallel/test-buffer-slice.js
@@ -0,0 +1,129 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+
+require('../common');
+const assert = require('assert');
+
+assert.strictEqual(Buffer.from('hello', 'utf8').slice(0, 0).length, 0);
+assert.strictEqual(Buffer('hello', 'utf8').slice(0, 0).length, 0);
+
+const buf = Buffer.from('0123456789', 'utf8');
+const expectedSameBufs = [
+  [buf.slice(-10, 10), Buffer.from('0123456789', 'utf8')],
+  [buf.slice(-20, 10), Buffer.from('0123456789', 'utf8')],
+  [buf.slice(-20, -10), Buffer.from('', 'utf8')],
+  [buf.slice(), Buffer.from('0123456789', 'utf8')],
+  [buf.slice(0), Buffer.from('0123456789', 'utf8')],
+  [buf.slice(0, 0), Buffer.from('', 'utf8')],
+  [buf.slice(undefined), Buffer.from('0123456789', 'utf8')],
+  [buf.slice('foobar'), Buffer.from('0123456789', 'utf8')],
+  [buf.slice(undefined, undefined), Buffer.from('0123456789', 'utf8')],
+  [buf.slice(2), Buffer.from('23456789', 'utf8')],
+  [buf.slice(5), Buffer.from('56789', 'utf8')],
+  [buf.slice(10), Buffer.from('', 'utf8')],
+  [buf.slice(5, 8), Buffer.from('567', 'utf8')],
+  [buf.slice(8, -1), Buffer.from('8', 'utf8')],
+  [buf.slice(-10), Buffer.from('0123456789', 'utf8')],
+  [buf.slice(0, -9), Buffer.from('0', 'utf8')],
+  [buf.slice(0, -10), Buffer.from('', 'utf8')],
+  [buf.slice(0, -1), Buffer.from('012345678', 'utf8')],
+  [buf.slice(2, -2), Buffer.from('234567', 'utf8')],
+  [buf.slice(0, 65536), Buffer.from('0123456789', 'utf8')],
+  [buf.slice(65536, 0), Buffer.from('', 'utf8')],
+  [buf.slice(-5, -8), Buffer.from('', 'utf8')],
+  [buf.slice(-5, -3), Buffer.from('56', 'utf8')],
+  [buf.slice(-10, 10), Buffer.from('0123456789', 'utf8')],
+  [buf.slice('0', '1'), Buffer.from('0', 'utf8')],
+  [buf.slice('-5', '10'), Buffer.from('56789', 'utf8')],
+  [buf.slice('-10', '10'), Buffer.from('0123456789', 'utf8')],
+  [buf.slice('-10', '-5'), Buffer.from('01234', 'utf8')],
+  [buf.slice('-10', '-0'), Buffer.from('', 'utf8')],
+  [buf.slice('111'), Buffer.from('', 'utf8')],
+  [buf.slice('0', '-111'), Buffer.from('', 'utf8')],
+];
+
+for (let i = 0, s = buf.toString(); i < buf.length; ++i) {
+  expectedSameBufs.push(
+    [buf.slice(i), Buffer.from(s.slice(i))],
+    [buf.slice(0, i), Buffer.from(s.slice(0, i))],
+    [buf.slice(-i), Buffer.from(s.slice(-i))],
+    [buf.slice(0, -i), Buffer.from(s.slice(0, -i))]
+  );
+}
+
+for (const [buf1, buf2] of expectedSameBufs) {
+  assert.strictEqual(Buffer.compare(buf1, buf2), 0);
+}
+
+const utf16Buf = Buffer.from('0123456789', 'utf16le');
+assert.deepStrictEqual(utf16Buf.slice(0, 6), Buffer.from('012', 'utf16le'));
+// Try to slice a zero length Buffer.
+// See https://github.com/joyent/node/issues/5881
+assert.strictEqual(Buffer.alloc(0).slice(0, 1).length, 0);
+
+{
+  // Single argument slice
+  assert.strictEqual(Buffer.from('abcde', 'utf8').slice(1).toString('utf8'),
+                     'bcde');
+}
+
+// slice(0,0).length === 0
+assert.strictEqual(Buffer.from('hello', 'utf8').slice(0, 0).length, 0);
+
+{
+  // Regression tests for https://github.com/nodejs/node/issues/9096
+  const buf = Buffer.from('abcd', 'utf8');
+  assert.strictEqual(buf.slice(buf.length / 3).toString('utf8'), 'bcd');
+  assert.strictEqual(
+    buf.slice(buf.length / 3, buf.length).toString(),
+    'bcd'
+  );
+}
+
+{
+  const buf = Buffer.from('abcdefg', 'utf8');
+  assert.strictEqual(buf.slice(-(-1 >>> 0) - 1).toString('utf8'),
+                     buf.toString('utf8'));
+}
+
+{
+  const buf = Buffer.from('abc', 'utf8');
+  assert.strictEqual(buf.slice(-0.5).toString('utf8'), buf.toString('utf8'));
+}
+
+{
+  const buf = Buffer.from([
+    1, 29, 0, 0, 1, 143, 216, 162, 92, 254, 248, 63, 0,
+    0, 0, 18, 184, 6, 0, 175, 29, 0, 8, 11, 1, 0, 0,
+  ]);
+  const chunk1 = Buffer.from([
+    1, 29, 0, 0, 1, 143, 216, 162, 92, 254, 248, 63, 0,
+  ]);
+  const chunk2 = Buffer.from([
+    0, 0, 18, 184, 6, 0, 175, 29, 0, 8, 11, 1, 0, 0,
+  ]);
+  const middle = buf.length / 2;
+
+  assert.deepStrictEqual(buf.slice(0, middle), chunk1);
+  assert.deepStrictEqual(buf.slice(middle), chunk2);
+}
diff --git a/test/js/node/test/parallel/test-buffer-slow.js b/test/js/node/test/parallel/test-buffer-slow.js
new file mode 100644
index 0000000000..07138d5db0
--- /dev/null
+++ b/test/js/node/test/parallel/test-buffer-slow.js
@@ -0,0 +1,53 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const buffer = require('buffer');
+const SlowBuffer = buffer.SlowBuffer;
+
+const ones = [1, 1, 1, 1];
+
+// Should create a Buffer
+let sb = SlowBuffer(4);
+assert(sb instanceof Buffer);
+assert.strictEqual(sb.length, 4);
+sb.fill(1);
+for (const [key, value] of sb.entries()) {
+  assert.deepStrictEqual(value, ones[key]);
+}
+
+// underlying ArrayBuffer should have the same length
+assert.strictEqual(sb.buffer.byteLength, 4);
+
+// Should work without new
+sb = SlowBuffer(4);
+assert(sb instanceof Buffer);
+assert.strictEqual(sb.length, 4);
+sb.fill(1);
+for (const [key, value] of sb.entries()) {
+  assert.deepStrictEqual(value, ones[key]);
+}
+
+// Should work with edge cases
+assert.strictEqual(SlowBuffer(0).length, 0);
+
+// Should throw with invalid length type
+const bufferInvalidTypeMsg = {
+  code: 'ERR_INVALID_ARG_TYPE',
+  name: 'TypeError',
+  message: /^The "size" argument must be of type number/,
+};
+assert.throws(() => SlowBuffer(), bufferInvalidTypeMsg);
+assert.throws(() => SlowBuffer({}), bufferInvalidTypeMsg);
+assert.throws(() => SlowBuffer('6'), bufferInvalidTypeMsg);
+assert.throws(() => SlowBuffer(true), bufferInvalidTypeMsg);
+
+// Should throw with invalid length value
+const bufferMaxSizeMsg = {
+  code: 'ERR_OUT_OF_RANGE',
+  name: 'RangeError',
+};
+assert.throws(() => SlowBuffer(NaN), bufferMaxSizeMsg);
+assert.throws(() => SlowBuffer(Infinity), bufferMaxSizeMsg);
+assert.throws(() => SlowBuffer(-1), bufferMaxSizeMsg);
+assert.throws(() => SlowBuffer(buffer.kMaxLength + 1), bufferMaxSizeMsg);
diff --git a/test/js/node/test/parallel/test-buffer-swap.js b/test/js/node/test/parallel/test-buffer-swap.js
new file mode 100644
index 0000000000..82b550790e
--- /dev/null
+++ b/test/js/node/test/parallel/test-buffer-swap.js
@@ -0,0 +1,152 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+
+// Test buffers small enough to use the JS implementation
+{
+  const buf = Buffer.from([0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
+                           0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10]);
+
+  assert.strictEqual(buf, buf.swap16());
+  assert.deepStrictEqual(buf, Buffer.from([0x02, 0x01, 0x04, 0x03, 0x06, 0x05,
+                                           0x08, 0x07, 0x0a, 0x09, 0x0c, 0x0b,
+                                           0x0e, 0x0d, 0x10, 0x0f]));
+  buf.swap16(); // restore
+
+  assert.strictEqual(buf, buf.swap32());
+  assert.deepStrictEqual(buf, Buffer.from([0x04, 0x03, 0x02, 0x01, 0x08, 0x07,
+                                           0x06, 0x05, 0x0c, 0x0b, 0x0a, 0x09,
+                                           0x10, 0x0f, 0x0e, 0x0d]));
+  buf.swap32(); // restore
+
+  assert.strictEqual(buf, buf.swap64());
+  assert.deepStrictEqual(buf, Buffer.from([0x08, 0x07, 0x06, 0x05, 0x04, 0x03,
+                                           0x02, 0x01, 0x10, 0x0f, 0x0e, 0x0d,
+                                           0x0c, 0x0b, 0x0a, 0x09]));
+}
+
+// Operates in-place
+{
+  const buf = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]);
+  buf.slice(1, 5).swap32();
+  assert.deepStrictEqual(buf, Buffer.from([0x1, 0x5, 0x4, 0x3, 0x2, 0x6, 0x7]));
+  buf.slice(1, 5).swap16();
+  assert.deepStrictEqual(buf, Buffer.from([0x1, 0x4, 0x5, 0x2, 0x3, 0x6, 0x7]));
+
+  // Length assertions
+  const re16 = /Buffer size must be a multiple of 16-bits/;
+  const re32 = /Buffer size must be a multiple of 32-bits/;
+  const re64 = /Buffer size must be a multiple of 64-bits/;
+
+  assert.throws(() => Buffer.from(buf).swap16(), re16);
+  assert.throws(() => Buffer.alloc(1025).swap16(), re16);
+  assert.throws(() => Buffer.from(buf).swap32(), re32);
+  assert.throws(() => buf.slice(1, 3).swap32(), re32);
+  assert.throws(() => Buffer.alloc(1025).swap32(), re32);
+  assert.throws(() => buf.slice(1, 3).swap64(), re64);
+  assert.throws(() => Buffer.alloc(1025).swap64(), re64);
+}
+
+{
+  const buf = Buffer.from([0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+                           0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
+                           0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+                           0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10]);
+
+  buf.slice(2, 18).swap64();
+
+  assert.deepStrictEqual(buf, Buffer.from([0x01, 0x02, 0x0a, 0x09, 0x08, 0x07,
+                                           0x06, 0x05, 0x04, 0x03, 0x02, 0x01,
+                                           0x10, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b,
+                                           0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+                                           0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
+                                           0x0f, 0x10]));
+}
+
+// Force use of native code (Buffer size above threshold limit for js impl)
+{
+  const bufData = new Uint32Array(256).fill(0x04030201);
+  const buf = Buffer.from(bufData.buffer, bufData.byteOffset);
+  const otherBufData = new Uint32Array(256).fill(0x03040102);
+  const otherBuf = Buffer.from(otherBufData.buffer, otherBufData.byteOffset);
+  buf.swap16();
+  assert.deepStrictEqual(buf, otherBuf);
+}
+
+{
+  const bufData = new Uint32Array(256).fill(0x04030201);
+  const buf = Buffer.from(bufData.buffer);
+  const otherBufData = new Uint32Array(256).fill(0x01020304);
+  const otherBuf = Buffer.from(otherBufData.buffer, otherBufData.byteOffset);
+  buf.swap32();
+  assert.deepStrictEqual(buf, otherBuf);
+}
+
+{
+  const bufData = new Uint8Array(256 * 8);
+  const otherBufData = new Uint8Array(256 * 8);
+  for (let i = 0; i < bufData.length; i++) {
+    bufData[i] = i % 8;
+    otherBufData[otherBufData.length - i - 1] = i % 8;
+  }
+  const buf = Buffer.from(bufData.buffer, bufData.byteOffset);
+  const otherBuf = Buffer.from(otherBufData.buffer, otherBufData.byteOffset);
+  buf.swap64();
+  assert.deepStrictEqual(buf, otherBuf);
+}
+
+// Test native code with buffers that are not memory-aligned
+{
+  const bufData = new Uint8Array(256 * 8);
+  const otherBufData = new Uint8Array(256 * 8 - 2);
+  for (let i = 0; i < bufData.length; i++) {
+    bufData[i] = i % 2;
+  }
+  for (let i = 1; i < otherBufData.length; i++) {
+    otherBufData[otherBufData.length - i] = (i + 1) % 2;
+  }
+  const buf = Buffer.from(bufData.buffer, bufData.byteOffset);
+  // 0|1 0|1 0|1...
+  const otherBuf = Buffer.from(otherBufData.buffer, otherBufData.byteOffset);
+  // 0|0 1|0 1|0...
+
+  buf.slice(1, buf.length - 1).swap16();
+  assert.deepStrictEqual(buf.slice(0, otherBuf.length), otherBuf);
+}
+
+{
+  const bufData = new Uint8Array(256 * 8);
+  const otherBufData = new Uint8Array(256 * 8 - 4);
+  for (let i = 0; i < bufData.length; i++) {
+    bufData[i] = i % 4;
+  }
+  for (let i = 1; i < otherBufData.length; i++) {
+    otherBufData[otherBufData.length - i] = (i + 1) % 4;
+  }
+  const buf = Buffer.from(bufData.buffer, bufData.byteOffset);
+  // 0|1 2 3 0|1 2 3...
+  const otherBuf = Buffer.from(otherBufData.buffer, otherBufData.byteOffset);
+  // 0|0 3 2 1|0 3 2...
+
+  buf.slice(1, buf.length - 3).swap32();
+  assert.deepStrictEqual(buf.slice(0, otherBuf.length), otherBuf);
+}
+
+{
+  const bufData = new Uint8Array(256 * 8);
+  const otherBufData = new Uint8Array(256 * 8 - 8);
+  for (let i = 0; i < bufData.length; i++) {
+    bufData[i] = i % 8;
+  }
+  for (let i = 1; i < otherBufData.length; i++) {
+    otherBufData[otherBufData.length - i] = (i + 1) % 8;
+  }
+  const buf = Buffer.from(bufData.buffer, bufData.byteOffset);
+  // 0|1 2 3 4 5 6 7 0|1 2 3 4...
+  const otherBuf = Buffer.from(otherBufData.buffer, otherBufData.byteOffset);
+  // 0|0 7 6 5 4 3 2 1|0 7 6 5...
+
+  buf.slice(1, buf.length - 7).swap64();
+  assert.deepStrictEqual(buf.slice(0, otherBuf.length), otherBuf);
+}
diff --git a/test/js/node/test/parallel/test-buffer-tojson.js b/test/js/node/test/parallel/test-buffer-tojson.js
new file mode 100644
index 0000000000..d9a4a85e81
--- /dev/null
+++ b/test/js/node/test/parallel/test-buffer-tojson.js
@@ -0,0 +1,35 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+
+{
+  assert.strictEqual(JSON.stringify(Buffer.alloc(0)),
+                     '{"type":"Buffer","data":[]}');
+  assert.strictEqual(JSON.stringify(Buffer.from([1, 2, 3, 4])),
+                     '{"type":"Buffer","data":[1,2,3,4]}');
+}
+
+// issue GH-7849
+{
+  const buf = Buffer.from('test');
+  const json = JSON.stringify(buf);
+  const obj = JSON.parse(json);
+  const copy = Buffer.from(obj);
+
+  assert.deepStrictEqual(buf, copy);
+}
+
+// GH-5110
+{
+  const buffer = Buffer.from('test');
+  const string = JSON.stringify(buffer);
+
+  assert.strictEqual(string, '{"type":"Buffer","data":[116,101,115,116]}');
+
+  function receiver(key, value) {
+    return value && value.type === 'Buffer' ? Buffer.from(value.data) : value;
+  }
+
+  assert.deepStrictEqual(buffer, JSON.parse(string, receiver));
+}
diff --git a/test/js/node/test/parallel/test-buffer-tostring-range.js b/test/js/node/test/parallel/test-buffer-tostring-range.js
new file mode 100644
index 0000000000..f4adf64c8d
--- /dev/null
+++ b/test/js/node/test/parallel/test-buffer-tostring-range.js
@@ -0,0 +1,100 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+
+const rangeBuffer = Buffer.from('abc');
+
+// If start >= buffer's length, empty string will be returned
+assert.strictEqual(rangeBuffer.toString('ascii', 3), '');
+assert.strictEqual(rangeBuffer.toString('ascii', +Infinity), '');
+assert.strictEqual(rangeBuffer.toString('ascii', 3.14, 3), '');
+assert.strictEqual(rangeBuffer.toString('ascii', 'Infinity', 3), '');
+
+// If end <= 0, empty string will be returned
+assert.strictEqual(rangeBuffer.toString('ascii', 1, 0), '');
+assert.strictEqual(rangeBuffer.toString('ascii', 1, -1.2), '');
+assert.strictEqual(rangeBuffer.toString('ascii', 1, -100), '');
+assert.strictEqual(rangeBuffer.toString('ascii', 1, -Infinity), '');
+
+// If start < 0, start will be taken as zero
+assert.strictEqual(rangeBuffer.toString('ascii', -1, 3), 'abc');
+assert.strictEqual(rangeBuffer.toString('ascii', -1.99, 3), 'abc');
+assert.strictEqual(rangeBuffer.toString('ascii', -Infinity, 3), 'abc');
+assert.strictEqual(rangeBuffer.toString('ascii', '-1', 3), 'abc');
+assert.strictEqual(rangeBuffer.toString('ascii', '-1.99', 3), 'abc');
+assert.strictEqual(rangeBuffer.toString('ascii', '-Infinity', 3), 'abc');
+
+// If start is an invalid integer, start will be taken as zero
+assert.strictEqual(rangeBuffer.toString('ascii', 'node.js', 3), 'abc');
+assert.strictEqual(rangeBuffer.toString('ascii', {}, 3), 'abc');
+assert.strictEqual(rangeBuffer.toString('ascii', [], 3), 'abc');
+assert.strictEqual(rangeBuffer.toString('ascii', NaN, 3), 'abc');
+assert.strictEqual(rangeBuffer.toString('ascii', null, 3), 'abc');
+assert.strictEqual(rangeBuffer.toString('ascii', undefined, 3), 'abc');
+assert.strictEqual(rangeBuffer.toString('ascii', false, 3), 'abc');
+assert.strictEqual(rangeBuffer.toString('ascii', '', 3), 'abc');
+
+// But, if start is an integer when coerced, then it will be coerced and used.
+assert.strictEqual(rangeBuffer.toString('ascii', '-1', 3), 'abc');
+assert.strictEqual(rangeBuffer.toString('ascii', '1', 3), 'bc');
+assert.strictEqual(rangeBuffer.toString('ascii', '-Infinity', 3), 'abc');
+assert.strictEqual(rangeBuffer.toString('ascii', '3', 3), '');
+assert.strictEqual(rangeBuffer.toString('ascii', Number(3), 3), '');
+assert.strictEqual(rangeBuffer.toString('ascii', '3.14', 3), '');
+assert.strictEqual(rangeBuffer.toString('ascii', '1.99', 3), 'bc');
+assert.strictEqual(rangeBuffer.toString('ascii', '-1.99', 3), 'abc');
+assert.strictEqual(rangeBuffer.toString('ascii', 1.99, 3), 'bc');
+assert.strictEqual(rangeBuffer.toString('ascii', true, 3), 'bc');
+
+// If end > buffer's length, end will be taken as buffer's length
+assert.strictEqual(rangeBuffer.toString('ascii', 0, 5), 'abc');
+assert.strictEqual(rangeBuffer.toString('ascii', 0, 6.99), 'abc');
+assert.strictEqual(rangeBuffer.toString('ascii', 0, Infinity), 'abc');
+assert.strictEqual(rangeBuffer.toString('ascii', 0, '5'), 'abc');
+assert.strictEqual(rangeBuffer.toString('ascii', 0, '6.99'), 'abc');
+assert.strictEqual(rangeBuffer.toString('ascii', 0, 'Infinity'), 'abc');
+
+// If end is an invalid integer, end will be taken as buffer's length
+assert.strictEqual(rangeBuffer.toString('ascii', 0, 'node.js'), '');
+assert.strictEqual(rangeBuffer.toString('ascii', 0, {}), '');
+assert.strictEqual(rangeBuffer.toString('ascii', 0, NaN), '');
+assert.strictEqual(rangeBuffer.toString('ascii', 0, undefined), 'abc');
+assert.strictEqual(rangeBuffer.toString('ascii', 0), 'abc');
+assert.strictEqual(rangeBuffer.toString('ascii', 0, null), '');
+assert.strictEqual(rangeBuffer.toString('ascii', 0, []), '');
+assert.strictEqual(rangeBuffer.toString('ascii', 0, false), '');
+assert.strictEqual(rangeBuffer.toString('ascii', 0, ''), '');
+
+// But, if end is an integer when coerced, then it will be coerced and used.
+assert.strictEqual(rangeBuffer.toString('ascii', 0, '-1'), '');
+assert.strictEqual(rangeBuffer.toString('ascii', 0, '1'), 'a');
+assert.strictEqual(rangeBuffer.toString('ascii', 0, '-Infinity'), '');
+assert.strictEqual(rangeBuffer.toString('ascii', 0, '3'), 'abc');
+assert.strictEqual(rangeBuffer.toString('ascii', 0, Number(3)), 'abc');
+assert.strictEqual(rangeBuffer.toString('ascii', 0, '3.14'), 'abc');
+assert.strictEqual(rangeBuffer.toString('ascii', 0, '1.99'), 'a');
+assert.strictEqual(rangeBuffer.toString('ascii', 0, '-1.99'), '');
+assert.strictEqual(rangeBuffer.toString('ascii', 0, 1.99), 'a');
+assert.strictEqual(rangeBuffer.toString('ascii', 0, true), 'a');
+
+// Try toString() with an object as an encoding
+assert.strictEqual(rangeBuffer.toString({ toString: function() {
+  return 'ascii';
+} }), 'abc');
+
+// Try toString() with 0 and null as the encoding
+assert.throws(() => {
+  rangeBuffer.toString(0, 1, 2);
+}, {
+  code: 'ERR_UNKNOWN_ENCODING',
+  name: 'TypeError',
+  message: 'Unknown encoding: 0'
+});
+assert.throws(() => {
+  rangeBuffer.toString(null, 1, 2);
+}, {
+  code: 'ERR_UNKNOWN_ENCODING',
+  name: 'TypeError',
+  message: 'Unknown encoding: null'
+});
diff --git a/test/js/node/test/parallel/test-buffer-tostring-rangeerror.js b/test/js/node/test/parallel/test-buffer-tostring-rangeerror.js
new file mode 100644
index 0000000000..0ebea759b5
--- /dev/null
+++ b/test/js/node/test/parallel/test-buffer-tostring-rangeerror.js
@@ -0,0 +1,25 @@
+'use strict';
+require('../common');
+
+// This test ensures that Node.js throws an Error when trying to convert a
+// large buffer into a string.
+// Regression test for https://github.com/nodejs/node/issues/649.
+
+const assert = require('assert');
+const {
+  SlowBuffer,
+  constants: {
+    MAX_STRING_LENGTH,
+  },
+} = require('buffer');
+
+const len = MAX_STRING_LENGTH + 1;
+const message = {
+  code: 'ERR_STRING_TOO_LONG',
+  name: 'Error',
+};
+assert.throws(() => Buffer(len).toString('utf8'), message);
+assert.throws(() => SlowBuffer(len).toString('utf8'), message);
+assert.throws(() => Buffer.alloc(len).toString('utf8'), message);
+assert.throws(() => Buffer.allocUnsafe(len).toString('utf8'), message);
+assert.throws(() => Buffer.allocUnsafeSlow(len).toString('utf8'), message);
diff --git a/test/js/node/test/parallel/test-buffer-tostring.js b/test/js/node/test/parallel/test-buffer-tostring.js
new file mode 100644
index 0000000000..4219649fa3
--- /dev/null
+++ b/test/js/node/test/parallel/test-buffer-tostring.js
@@ -0,0 +1,37 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+
+// utf8, ucs2, ascii, latin1, utf16le
+const encodings = ['utf8', 'utf-8', 'ucs2', 'ucs-2', 'ascii', 'latin1',
+                   'binary', 'utf16le', 'utf-16le'];
+
+encodings
+  .reduce((es, e) => es.concat(e, e.toUpperCase()), [])
+  .forEach((encoding) => {
+    assert.strictEqual(Buffer.from('foo', encoding).toString(encoding), 'foo');
+  });
+
+// base64
+['base64', 'BASE64'].forEach((encoding) => {
+  assert.strictEqual(Buffer.from('Zm9v', encoding).toString(encoding), 'Zm9v');
+});
+
+// hex
+['hex', 'HEX'].forEach((encoding) => {
+  assert.strictEqual(Buffer.from('666f6f', encoding).toString(encoding),
+                     '666f6f');
+});
+
+// Invalid encodings
+for (let i = 1; i < 10; i++) {
+  const encoding = String(i).repeat(i);
+  const error = common.expectsError({
+    code: 'ERR_UNKNOWN_ENCODING',
+    name: 'TypeError',
+    message: `Unknown encoding: ${encoding}`
+  });
+  assert.ok(!Buffer.isEncoding(encoding));
+  assert.throws(() => Buffer.from('foo').toString(encoding), error);
+}
diff --git a/test/js/node/test/parallel/test-buffer-zero-fill-reset.js b/test/js/node/test/parallel/test-buffer-zero-fill-reset.js
new file mode 100644
index 0000000000..334ee1b618
--- /dev/null
+++ b/test/js/node/test/parallel/test-buffer-zero-fill-reset.js
@@ -0,0 +1,19 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+
+
+function testUint8Array(ui) {
+  const length = ui.length;
+  for (let i = 0; i < length; i++)
+    if (ui[i] !== 0) return false;
+  return true;
+}
+
+
+for (let i = 0; i < 100; i++) {
+  Buffer.alloc(0);
+  const ui = new Uint8Array(65);
+  assert.ok(testUint8Array(ui), `Uint8Array is not zero-filled: ${ui}`);
+}
diff --git a/test/js/node/test/parallel/test-buffer-zero-fill.js b/test/js/node/test/parallel/test-buffer-zero-fill.js
new file mode 100644
index 0000000000..7a9f0c1250
--- /dev/null
+++ b/test/js/node/test/parallel/test-buffer-zero-fill.js
@@ -0,0 +1,14 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+
+// Tests deprecated Buffer API on purpose
+const buf1 = Buffer(100);
+const buf2 = new Buffer(100);
+
+for (let n = 0; n < buf1.length; n++)
+  assert.strictEqual(buf1[n], 0);
+
+for (let n = 0; n < buf2.length; n++)
+  assert.strictEqual(buf2[n], 0);
diff --git a/test/js/node/test/parallel/test-child-process-can-write-to-stdout.js b/test/js/node/test/parallel/test-child-process-can-write-to-stdout.js
new file mode 100644
index 0000000000..069e07fb16
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-can-write-to-stdout.js
@@ -0,0 +1,22 @@
+'use strict';
+// Tests that a spawned child process can write to stdout without throwing.
+// See https://github.com/nodejs/node-v0.x-archive/issues/1899.
+
+require('../common');
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+const spawn = require('child_process').spawn;
+
+const child = spawn(process.argv[0], [
+  fixtures.path('GH-1899-output.js'),
+]);
+let output = '';
+
+child.stdout.on('data', function(data) {
+  output += data;
+});
+
+child.on('exit', function(code, signal) {
+  assert.strictEqual(code, 0);
+  assert.strictEqual(output, 'hello, world!\n');
+});
diff --git a/test/js/node/test/parallel/test-child-process-default-options.js b/test/js/node/test/parallel/test-child-process-default-options.js
new file mode 100644
index 0000000000..39f90deaeb
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-default-options.js
@@ -0,0 +1,51 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const { isWindows } = require('../common');
+const assert = require('assert');
+
+const spawn = require('child_process').spawn;
+const debug = require('util').debuglog('test');
+
+process.env.HELLO = 'WORLD';
+
+let child;
+if (isWindows) {
+  child = spawn('cmd.exe', ['/c', 'set'], {});
+} else {
+  child = spawn('/usr/bin/env', [], {});
+}
+
+let response = '';
+
+child.stdout.setEncoding('utf8');
+
+child.stdout.on('data', function(chunk) {
+  debug(`stdout: ${chunk}`);
+  response += chunk;
+});
+
+process.on('exit', function() {
+  assert.ok(response.includes('HELLO=WORLD'),
+            'spawn did not use process.env as default ' +
+            `(process.env.HELLO = ${process.env.HELLO})`);
+});
diff --git a/test/js/node/test/parallel/test-child-process-destroy.js b/test/js/node/test/parallel/test-child-process-destroy.js
new file mode 100644
index 0000000000..50763bb031
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-destroy.js
@@ -0,0 +1,25 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const spawn = require('child_process').spawn;
+const cat = spawn(common.isWindows ? 'cmd' : 'cat');
+
+cat.stdout.on('end', common.mustCall());
+cat.stderr.on('data', common.mustNotCall());
+cat.stderr.on('end', common.mustCall());
+
+cat.on('exit', common.mustCall((code, signal) => {
+  assert.strictEqual(code, null);
+  assert.strictEqual(signal, 'SIGTERM');
+  assert.strictEqual(cat.signalCode, 'SIGTERM');
+}));
+cat.on('exit', common.mustCall((code, signal) => {
+  assert.strictEqual(code, null);
+  assert.strictEqual(signal, 'SIGTERM');
+  assert.strictEqual(cat.signalCode, 'SIGTERM');
+}));
+
+assert.strictEqual(cat.signalCode, null);
+assert.strictEqual(cat.killed, false);
+cat[Symbol.dispose]();
+assert.strictEqual(cat.killed, true);
diff --git a/test/js/node/test/parallel/test-child-process-double-pipe.js b/test/js/node/test/parallel/test-child-process-double-pipe.js
new file mode 100644
index 0000000000..7a432d3892
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-double-pipe.js
@@ -0,0 +1,122 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const {
+  isWindows,
+  mustCall,
+  mustCallAtLeast,
+} = require('../common');
+const assert = require('assert');
+const os = require('os');
+const spawn = require('child_process').spawn;
+const debug = require('util').debuglog('test');
+
+// We're trying to reproduce:
+// $ echo "hello\nnode\nand\nworld" | grep o | sed s/o/a/
+
+let grep, sed, echo;
+
+if (isWindows) {
+  grep = spawn('grep', ['--binary', 'o']);
+  sed = spawn('sed', ['--binary', 's/o/O/']);
+  echo = spawn('cmd.exe',
+               ['/c', 'echo', 'hello&&', 'echo',
+                'node&&', 'echo', 'and&&', 'echo', 'world']);
+} else {
+  grep = spawn('grep', ['o']);
+  sed = spawn('sed', ['s/o/O/']);
+  echo = spawn('echo', ['hello\nnode\nand\nworld\n']);
+}
+
+// If the spawn function leaks file descriptors to subprocesses, grep and sed
+// hang.
+// This happens when calling pipe(2) and then forgetting to set the
+// FD_CLOEXEC flag on the resulting file descriptors.
+//
+// This test checks child processes exit, meaning they don't hang like
+// explained above.
+
+
+// pipe echo | grep
+echo.stdout.on('data', mustCallAtLeast((data) => {
+  debug(`grep stdin write ${data.length}`);
+  if (!grep.stdin.write(data)) {
+    echo.stdout.pause();
+  }
+}));
+
+// TODO(@jasnell): This does not appear to ever be
+// emitted. It's not clear if it is necessary.
+grep.stdin.on('drain', (data) => {
+  echo.stdout.resume();
+});
+
+// Propagate end from echo to grep
+echo.stdout.on('end', mustCall((code) => {
+  grep.stdin.end();
+}));
+
+echo.on('exit', mustCall(() => {
+  debug('echo exit');
+}));
+
+grep.on('exit', mustCall(() => {
+  debug('grep exit');
+}));
+
+sed.on('exit', mustCall(() => {
+  debug('sed exit');
+}));
+
+
+// pipe grep | sed
+grep.stdout.on('data', mustCallAtLeast((data) => {
+  debug(`grep stdout ${data.length}`);
+  if (!sed.stdin.write(data)) {
+    grep.stdout.pause();
+  }
+}));
+
+// TODO(@jasnell): This does not appear to ever be
+// emitted. It's not clear if it is necessary.
+sed.stdin.on('drain', (data) => {
+  grep.stdout.resume();
+});
+
+// Propagate end from grep to sed
+grep.stdout.on('end', mustCall((code) => {
+  debug('grep stdout end');
+  sed.stdin.end();
+}));
+
+
+let result = '';
+
+// print sed's output
+sed.stdout.on('data', mustCallAtLeast((data) => {
+  result += data.toString('utf8', 0, data.length);
+  debug(data);
+}));
+
+sed.stdout.on('end', mustCall((code) => {
+  assert.strictEqual(result, `hellO${os.EOL}nOde${os.EOL}wOrld${os.EOL}`);
+}));
diff --git a/test/js/node/test/parallel/test-child-process-env.js b/test/js/node/test/parallel/test-child-process-env.js
new file mode 100644
index 0000000000..f9815ff015
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-env.js
@@ -0,0 +1,77 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const {
+  isWindows,
+  mustCall,
+  mustCallAtLeast,
+} = require('../common');
+const assert = require('assert');
+const os = require('os');
+const debug = require('util').debuglog('test');
+
+const spawn = require('child_process').spawn;
+
+const env = {
+  ...process.env,
+  'HELLO': 'WORLD',
+  'UNDEFINED': undefined,
+  'NULL': null,
+  'EMPTY': '',
+  'duplicate': 'lowercase',
+  'DUPLICATE': 'uppercase',
+};
+Object.setPrototypeOf(env, {
+  'FOO': 'BAR'
+});
+
+let child;
+if (isWindows) {
+  child = spawn('cmd.exe', ['/c', 'set'], { env });
+} else {
+  child = spawn('/usr/bin/env', [], { env });
+}
+
+
+let response = '';
+
+child.stdout.setEncoding('utf8');
+
+child.stdout.on('data', mustCallAtLeast((chunk) => {
+  debug(`stdout: ${chunk}`);
+  response += chunk;
+}));
+
+child.stdout.on('end', mustCall(() => {
+  assert.ok(response.includes('HELLO=WORLD'));
+  assert.ok(response.includes('FOO=BAR'));
+  assert.ok(!response.includes('UNDEFINED=undefined'));
+  assert.ok(response.includes('NULL=null'));
+  assert.ok(response.includes(`EMPTY=${os.EOL}`));
+  if (isWindows) {
+    assert.ok(response.includes('DUPLICATE=uppercase'));
+    assert.ok(!response.includes('duplicate=lowercase'));
+  } else {
+    assert.ok(response.includes('DUPLICATE=uppercase'));
+    assert.ok(response.includes('duplicate=lowercase'));
+  }
+}));
diff --git a/test/js/node/test/parallel/test-child-process-exec-any-shells-windows.js b/test/js/node/test/parallel/test-child-process-exec-any-shells-windows.js
new file mode 100644
index 0000000000..5c34bc7730
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-exec-any-shells-windows.js
@@ -0,0 +1,67 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const cp = require('child_process');
+const fs = require('fs');
+const tmpdir = require('../common/tmpdir');
+
+// This test is only relevant on Windows.
+if (!common.isWindows)
+  common.skip('Windows specific test.');
+
+// This test ensures that child_process.exec can work with any shells.
+
+tmpdir.refresh();
+const tmpPath = `${tmpdir.path}\\path with spaces`;
+fs.mkdirSync(tmpPath);
+
+const test = (shell) => {
+  cp.exec('echo foo bar', { shell: shell },
+          common.mustSucceed((stdout, stderror) => {
+            assert.ok(!stderror);
+            assert.ok(stdout.includes('foo') && stdout.includes('bar'));
+          }));
+};
+const testCopy = (shellName, shellPath) => {
+  // Symlink the executable to a path with spaces, to ensure there are no issues
+  // related to quoting of argv0
+  const copyPath = `${tmpPath}\\${shellName}`;
+  fs.symlinkSync(shellPath, copyPath);
+  test(copyPath);
+};
+
+const system32 = `${process.env.SystemRoot}\\System32`;
+
+// Test CMD
+test(true);
+test('cmd');
+testCopy('cmd.exe', `${system32}\\cmd.exe`);
+test('cmd.exe');
+test('CMD');
+
+// Test PowerShell
+test('powershell');
+testCopy('powershell.exe',
+         `${system32}\\WindowsPowerShell\\v1.0\\powershell.exe`);
+fs.writeFile(`${tmpPath}\\test file`, 'Test', common.mustSucceed(() => {
+  cp.exec(`Get-ChildItem "${tmpPath}" | Select-Object -Property Name`,
+          { shell: 'PowerShell' },
+          common.mustSucceed((stdout, stderror) => {
+            assert.ok(!stderror);
+            assert.ok(stdout.includes(
+              'test file'));
+          }));
+}));
+
+// Test Bash (from WSL and Git), if available
+cp.exec('where bash', common.mustCall((error, stdout) => {
+  if (error) {
+    return;
+  }
+  const lines = stdout.trim().split(/[\r\n]+/g);
+  for (let i = 0; i < lines.length; ++i) {
+    const bashPath = lines[i].trim();
+    test(bashPath);
+    testCopy(`bash_${i}.exe`, bashPath);
+  }
+}));
diff --git a/test/js/node/test/parallel/test-child-process-exec-cwd.js b/test/js/node/test/parallel/test-child-process-exec-cwd.js
new file mode 100644
index 0000000000..49e56ef551
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-exec-cwd.js
@@ -0,0 +1,39 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const exec = require('child_process').exec;
+
+let pwdcommand, dir;
+
+if (common.isWindows) {
+  pwdcommand = 'echo %cd%';
+  dir = 'c:\\windows';
+} else {
+  pwdcommand = 'pwd';
+  dir = '/dev';
+}
+
+exec(pwdcommand, { cwd: dir }, common.mustSucceed((stdout, stderr) => {
+  assert(stdout.toLowerCase().startsWith(dir));
+}));
diff --git a/test/js/node/test/parallel/test-child-process-exec-encoding.js b/test/js/node/test/parallel/test-child-process-exec-encoding.js
new file mode 100644
index 0000000000..0c3178e3f2
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-exec-encoding.js
@@ -0,0 +1,48 @@
+'use strict';
+const common = require('../common');
+const stdoutData = 'foo';
+const stderrData = 'bar';
+
+if (process.argv[2] === 'child') {
+  // The following console calls are part of the test.
+  console.log(stdoutData);
+  console.error(stderrData);
+} else {
+  const assert = require('assert');
+  const cp = require('child_process');
+  const expectedStdout = `${stdoutData}\n`;
+  const expectedStderr = `${stderrData}\n`;
+  function run(options, callback) {
+    const cmd = `"${process.execPath}" "${__filename}" child`;
+
+    cp.exec(cmd, options, common.mustSucceed((stdout, stderr) => {
+      callback(stdout, stderr);
+    }));
+  }
+
+  // Test default encoding, which should be utf8.
+  run({}, (stdout, stderr) => {
+    assert.strictEqual(typeof stdout, 'string');
+    assert.strictEqual(typeof stderr, 'string');
+    assert.strictEqual(stdout, expectedStdout);
+    assert.strictEqual(stderr, expectedStderr);
+  });
+
+  // Test explicit utf8 encoding.
+  run({ encoding: 'utf8' }, (stdout, stderr) => {
+    assert.strictEqual(typeof stdout, 'string');
+    assert.strictEqual(typeof stderr, 'string');
+    assert.strictEqual(stdout, expectedStdout);
+    assert.strictEqual(stderr, expectedStderr);
+  });
+
+  // Test cases that result in buffer encodings.
+  [undefined, null, 'buffer', 'invalid'].forEach((encoding) => {
+    run({ encoding }, (stdout, stderr) => {
+      assert(stdout instanceof Buffer);
+      assert(stdout instanceof Buffer);
+      assert.strictEqual(stdout.toString(), expectedStdout);
+      assert.strictEqual(stderr.toString(), expectedStderr);
+    });
+  });
+}
diff --git a/test/js/node/test/parallel/test-child-process-exec-env.js b/test/js/node/test/parallel/test-child-process-exec-env.js
new file mode 100644
index 0000000000..f515643619
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-exec-env.js
@@ -0,0 +1,64 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const { isWindows } = require('../common');
+const assert = require('assert');
+const exec = require('child_process').exec;
+const debug = require('util').debuglog('test');
+
+let success_count = 0;
+let error_count = 0;
+let response = '';
+let child;
+
+function after(err, stdout, stderr) {
+  if (err) {
+    error_count++;
+    debug(`error!: ${err.code}`);
+    debug(`stdout: ${JSON.stringify(stdout)}`);
+    debug(`stderr: ${JSON.stringify(stderr)}`);
+    assert.strictEqual(err.killed, false);
+  } else {
+    success_count++;
+    assert.notStrictEqual(stdout, '');
+  }
+}
+
+if (!isWindows) {
+  child = exec('/usr/bin/env', { env: { 'HELLO': 'WORLD' } }, after);
+} else {
+  child = exec('set',
+               { env: { ...process.env, 'HELLO': 'WORLD' } },
+               after);
+}
+
+child.stdout.setEncoding('utf8');
+child.stdout.on('data', function(chunk) {
+  response += chunk;
+});
+
+process.on('exit', function() {
+  debug('response: ', response);
+  assert.strictEqual(success_count, 1);
+  assert.strictEqual(error_count, 0);
+  assert.ok(response.includes('HELLO=WORLD'));
+});
diff --git a/test/js/node/test/parallel/test-child-process-exec-std-encoding.js b/test/js/node/test/parallel/test-child-process-exec-std-encoding.js
new file mode 100644
index 0000000000..0818731672
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-exec-std-encoding.js
@@ -0,0 +1,22 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const cp = require('child_process');
+const stdoutData = 'foo';
+const stderrData = 'bar';
+const expectedStdout = `${stdoutData}\n`;
+const expectedStderr = `${stderrData}\n`;
+
+if (process.argv[2] === 'child') {
+  // The following console calls are part of the test.
+  console.log(stdoutData);
+  console.error(stderrData);
+} else {
+  const cmd = `"${process.execPath}" "${__filename}" child`;
+  const child = cp.exec(cmd, common.mustSucceed((stdout, stderr) => {
+    assert.strictEqual(stdout, expectedStdout);
+    assert.strictEqual(stderr, expectedStderr);
+  }));
+  child.stdout.setEncoding('utf-8');
+  child.stderr.setEncoding('utf-8');
+}
diff --git a/test/js/node/test/parallel/test-child-process-exec-stdout-stderr-data-string.js b/test/js/node/test/parallel/test-child-process-exec-stdout-stderr-data-string.js
new file mode 100644
index 0000000000..1fbdfbf8e4
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-exec-stdout-stderr-data-string.js
@@ -0,0 +1,13 @@
+'use strict';
+// Refs: https://github.com/nodejs/node/issues/7342
+const common = require('../common');
+const assert = require('assert');
+const exec = require('child_process').exec;
+
+const command = common.isWindows ? 'dir' : 'ls';
+
+exec(command).stdout.on('data', common.mustCallAtLeast());
+
+exec('fhqwhgads').stderr.on('data', common.mustCallAtLeast((data) => {
+  assert.strictEqual(typeof data, 'string');
+}));
diff --git a/test/js/node/test/parallel/test-child-process-exec-timeout-expire.js b/test/js/node/test/parallel/test-child-process-exec-timeout-expire.js
new file mode 100644
index 0000000000..6b62d131cb
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-exec-timeout-expire.js
@@ -0,0 +1,50 @@
+'use strict';
+
+// Test exec() with a timeout that expires.
+
+const common = require('../common');
+const assert = require('assert');
+const cp = require('child_process');
+
+const {
+  cleanupStaleProcess,
+  logAfterTime,
+  kExpiringChildRunTime,
+  kExpiringParentTimer
+} = require('../common/child_process');
+
+if (process.argv[2] === 'child') {
+  logAfterTime(kExpiringChildRunTime);
+  return;
+}
+
+const cmd = `"${process.execPath}" "${__filename}" child`;
+
+cp.exec(cmd, {
+  timeout: kExpiringParentTimer,
+}, common.mustCall((err, stdout, stderr) => {
+  console.log('[stdout]', stdout.trim());
+  console.log('[stderr]', stderr.trim());
+
+  let sigterm = 'SIGTERM';
+  assert.strictEqual(err.killed, true);
+  // TODO OpenBSD returns a null signal and 143 for code
+  if (common.isOpenBSD) {
+    assert.strictEqual(err.code, 143);
+    sigterm = null;
+  } else {
+    assert.strictEqual(err.code, null);
+  }
+  // At least starting with Darwin Kernel Version 16.4.0, sending a SIGTERM to a
+  // process that is still starting up kills it with SIGKILL instead of SIGTERM.
+  // See: https://github.com/libuv/libuv/issues/1226
+  if (common.isMacOS)
+    assert.ok(err.signal === 'SIGTERM' || err.signal === 'SIGKILL');
+  else
+    assert.strictEqual(err.signal, sigterm);
+  assert.strictEqual(err.cmd, cmd);
+  assert.strictEqual(stdout.trim(), '');
+  assert.strictEqual(stderr.trim(), '');
+}));
+
+cleanupStaleProcess(__filename);
diff --git a/test/js/node/test/parallel/test-child-process-exec-timeout-kill.js b/test/js/node/test/parallel/test-child-process-exec-timeout-kill.js
new file mode 100644
index 0000000000..845fd1eaec
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-exec-timeout-kill.js
@@ -0,0 +1,39 @@
+'use strict';
+
+// Test exec() with both a timeout and a killSignal.
+
+const common = require('../common');
+const assert = require('assert');
+const cp = require('child_process');
+
+const {
+  cleanupStaleProcess,
+  logAfterTime,
+  kExpiringChildRunTime,
+  kExpiringParentTimer,
+} = require('../common/child_process');
+
+if (process.argv[2] === 'child') {
+  logAfterTime(kExpiringChildRunTime);
+  return;
+}
+
+const cmd = `"${process.execPath}" "${__filename}" child`;
+
+// Test with a different kill signal.
+cp.exec(cmd, {
+  timeout: kExpiringParentTimer,
+  killSignal: 'SIGKILL'
+}, common.mustCall((err, stdout, stderr) => {
+  console.log('[stdout]', stdout.trim());
+  console.log('[stderr]', stderr.trim());
+
+  assert.strictEqual(err.killed, true);
+  assert.strictEqual(err.code, null);
+  assert.strictEqual(err.signal, 'SIGKILL');
+  assert.strictEqual(err.cmd, cmd);
+  assert.strictEqual(stdout.trim(), '');
+  assert.strictEqual(stderr.trim(), '');
+}));
+
+cleanupStaleProcess(__filename);
diff --git a/test/js/node/test/parallel/test-child-process-exec-timeout-not-expired.js b/test/js/node/test/parallel/test-child-process-exec-timeout-not-expired.js
new file mode 100644
index 0000000000..fb0af5fa8f
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-exec-timeout-not-expired.js
@@ -0,0 +1,34 @@
+'use strict';
+
+// Test exec() when a timeout is set, but not expired.
+
+const common = require('../common');
+const assert = require('assert');
+const cp = require('child_process');
+
+const {
+  cleanupStaleProcess,
+  logAfterTime
+} = require('../common/child_process');
+
+const kTimeoutNotSupposedToExpire = 2 ** 30;
+const childRunTime = common.platformTimeout(100);
+
+// The time spent in the child should be smaller than the timeout below.
+assert(childRunTime < kTimeoutNotSupposedToExpire);
+
+if (process.argv[2] === 'child') {
+  logAfterTime(childRunTime);
+  return;
+}
+
+const cmd = `"${process.execPath}" "${__filename}" child`;
+
+cp.exec(cmd, {
+  timeout: kTimeoutNotSupposedToExpire
+}, common.mustSucceed((stdout, stderr) => {
+  assert.strictEqual(stdout.trim(), 'child stdout');
+  assert.strictEqual(stderr.trim(), 'child stderr');
+}));
+
+cleanupStaleProcess(__filename);
diff --git a/test/js/node/test/parallel/test-child-process-execFile-promisified-abortController.js b/test/js/node/test/parallel/test-child-process-execFile-promisified-abortController.js
new file mode 100644
index 0000000000..38c177eb33
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-execFile-promisified-abortController.js
@@ -0,0 +1,56 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { promisify } = require('util');
+const execFile = require('child_process').execFile;
+const fixtures = require('../common/fixtures');
+
+const echoFixture = fixtures.path('echo.js');
+const promisified = promisify(execFile);
+const invalidArgTypeError = {
+  code: 'ERR_INVALID_ARG_TYPE',
+  name: 'TypeError'
+};
+
+{
+  // Verify that the signal option works properly
+  const ac = new AbortController();
+  const signal = ac.signal;
+  const promise = promisified(process.execPath, [echoFixture, 0], { signal });
+
+  ac.abort();
+
+  assert.rejects(
+    promise,
+    { name: 'AbortError' }
+  ).then(common.mustCall());
+}
+
+{
+  // Verify that the signal option works properly when already aborted
+  const signal = AbortSignal.abort();
+
+  assert.rejects(
+    promisified(process.execPath, [echoFixture, 0], { signal }),
+    { name: 'AbortError' }
+  ).then(common.mustCall());
+}
+
+{
+  // Verify that if something different than Abortcontroller.signal
+  // is passed, ERR_INVALID_ARG_TYPE is thrown
+  const signal = {};
+  assert.throws(() => {
+    promisified(process.execPath, [echoFixture, 0], { signal });
+  }, invalidArgTypeError);
+}
+
+{
+  // Verify that if something different than Abortcontroller.signal
+  // is passed, ERR_INVALID_ARG_TYPE is thrown
+  const signal = 'world!';
+  assert.throws(() => {
+    promisified(process.execPath, [echoFixture, 0], { signal });
+  }, invalidArgTypeError);
+}
diff --git a/test/js/node/test/parallel/test-child-process-flush-stdio.js b/test/js/node/test/parallel/test-child-process-flush-stdio.js
new file mode 100644
index 0000000000..7b9a2a049c
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-flush-stdio.js
@@ -0,0 +1,33 @@
+'use strict';
+const common = require('../common');
+const cp = require('child_process');
+const assert = require('assert');
+
+// Windows' `echo` command is a built-in shell command and not an external
+// executable like on *nix
+const opts = { shell: common.isWindows };
+
+const p = cp.spawn('echo', [], opts);
+
+p.on('close', common.mustCall((code, signal) => {
+  assert.strictEqual(code, 0);
+  assert.strictEqual(signal, null);
+  spawnWithReadable();
+}));
+
+p.stdout.read();
+
+const spawnWithReadable = () => {
+  const buffer = [];
+  const p = cp.spawn('echo', ['123'], opts);
+  p.on('close', common.mustCall((code, signal) => {
+    assert.strictEqual(code, 0);
+    assert.strictEqual(signal, null);
+    assert.strictEqual(Buffer.concat(buffer).toString().trim(), '123');
+  }));
+  p.stdout.on('readable', () => {
+    let buf;
+    while ((buf = p.stdout.read()) !== null)
+      buffer.push(buf);
+  });
+};
diff --git a/test/js/node/test/parallel/test-child-process-fork-abort-signal.js b/test/js/node/test/parallel/test-child-process-fork-abort-signal.js
new file mode 100644
index 0000000000..b963306fb1
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-fork-abort-signal.js
@@ -0,0 +1,105 @@
+'use strict';
+
+const { mustCall, mustNotCall } = require('../common');
+const { strictEqual } = require('assert');
+const fixtures = require('../common/fixtures');
+const { fork } = require('child_process');
+
+{
+  // Test aborting a forked child_process after calling fork
+  const ac = new AbortController();
+  const { signal } = ac;
+  const cp = fork(fixtures.path('child-process-stay-alive-forever.js'), {
+    signal
+  });
+  cp.on('exit', mustCall((code, killSignal) => {
+    strictEqual(code, null);
+    strictEqual(killSignal, 'SIGTERM');
+  }));
+  cp.on('error', mustCall((err) => {
+    strictEqual(err.name, 'AbortError');
+  }));
+  process.nextTick(() => ac.abort());
+}
+
+{
+  // Test aborting with custom error
+  const ac = new AbortController();
+  const { signal } = ac;
+  const cp = fork(fixtures.path('child-process-stay-alive-forever.js'), {
+    signal
+  });
+  cp.on('exit', mustCall((code, killSignal) => {
+    strictEqual(code, null);
+    strictEqual(killSignal, 'SIGTERM');
+  }));
+  cp.on('error', mustCall((err) => {
+    strictEqual(err.name, 'AbortError');
+    strictEqual(err.cause.name, 'Error');
+    strictEqual(err.cause.message, 'boom');
+  }));
+  process.nextTick(() => ac.abort(new Error('boom')));
+}
+
+{
+  // Test passing an already aborted signal to a forked child_process
+  const signal = AbortSignal.abort();
+  const cp = fork(fixtures.path('child-process-stay-alive-forever.js'), {
+    signal
+  });
+  cp.on('exit', mustCall((code, killSignal) => {
+    strictEqual(code, null);
+    strictEqual(killSignal, 'SIGTERM');
+  }));
+  cp.on('error', mustCall((err) => {
+    strictEqual(err.name, 'AbortError');
+  }));
+}
+
+{
+  // Test passing an aborted signal with custom error to a forked child_process
+  const signal = AbortSignal.abort(new Error('boom'));
+  const cp = fork(fixtures.path('child-process-stay-alive-forever.js'), {
+    signal
+  });
+  cp.on('exit', mustCall((code, killSignal) => {
+    strictEqual(code, null);
+    strictEqual(killSignal, 'SIGTERM');
+  }));
+  cp.on('error', mustCall((err) => {
+    strictEqual(err.name, 'AbortError');
+    strictEqual(err.cause.name, 'Error');
+    strictEqual(err.cause.message, 'boom');
+  }));
+}
+
+{
+  // Test passing a different kill signal
+  const signal = AbortSignal.abort();
+  const cp = fork(fixtures.path('child-process-stay-alive-forever.js'), {
+    signal,
+    killSignal: 'SIGKILL',
+  });
+  cp.on('exit', mustCall((code, killSignal) => {
+    strictEqual(code, null);
+    strictEqual(killSignal, 'SIGKILL');
+  }));
+  cp.on('error', mustCall((err) => {
+    strictEqual(err.name, 'AbortError');
+  }));
+}
+
+{
+  // Test aborting a cp before close but after exit
+  const ac = new AbortController();
+  const { signal } = ac;
+  const cp = fork(fixtures.path('child-process-stay-alive-forever.js'), {
+    signal
+  });
+  cp.on('exit', mustCall(() => {
+    ac.abort();
+  }));
+  cp.on('error', mustNotCall());
+
+  setTimeout(() => cp.kill(), 1);
+}
diff --git a/test/js/node/test/parallel/test-child-process-fork-and-spawn.js b/test/js/node/test/parallel/test-child-process-fork-and-spawn.js
new file mode 100644
index 0000000000..88e634ba8b
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-fork-and-spawn.js
@@ -0,0 +1,44 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const { fork, spawn } = require('child_process');
+
+// Fork, then spawn. The spawned process should not hang.
+switch (process.argv[2] || '') {
+  case '':
+    fork(__filename, ['fork']).on('exit', common.mustCall(checkExit));
+    break;
+  case 'fork':
+    spawn(process.execPath, [__filename, 'spawn'])
+      .on('exit', common.mustCall(checkExit));
+    break;
+  case 'spawn':
+    break;
+  default:
+    assert.fail();
+}
+
+function checkExit(statusCode) {
+  assert.strictEqual(statusCode, 0);
+}
diff --git a/test/js/node/test/parallel/test-child-process-fork-args.js b/test/js/node/test/parallel/test-child-process-fork-args.js
new file mode 100644
index 0000000000..2ed31fa4e9
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-fork-args.js
@@ -0,0 +1,105 @@
+'use strict';
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+const { fork } = require('child_process');
+
+// This test check the arguments of `fork` method
+// Refs: https://github.com/nodejs/node/issues/20749
+const expectedEnv = { foo: 'bar' };
+
+// Ensure that first argument `modulePath` must be provided
+// and be of type string
+{
+  const invalidModulePath = [
+    0,
+    true,
+    undefined,
+    null,
+    [],
+    {},
+    () => {},
+    Symbol('t'),
+  ];
+  invalidModulePath.forEach((modulePath) => {
+    assert.throws(() => fork(modulePath), {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError',
+      message: /^The "modulePath" argument must be of type string/
+    });
+  });
+
+  const cp = fork(fixtures.path('child-process-echo-options.js'));
+  cp.on(
+    'exit',
+    common.mustCall((code) => {
+      assert.strictEqual(code, 0);
+    })
+  );
+}
+
+// Ensure that the second argument of `fork`
+// and `fork` should parse options
+// correctly if args is undefined or null
+{
+  const invalidSecondArgs = [
+    0,
+    true,
+    () => {},
+    Symbol('t'),
+  ];
+  invalidSecondArgs.forEach((arg) => {
+    assert.throws(
+      () => {
+        fork(fixtures.path('child-process-echo-options.js'), arg);
+      },
+      {
+        code: 'ERR_INVALID_ARG_TYPE',
+        name: 'TypeError'
+      }
+    );
+  });
+
+  const argsLists = [undefined, null, []];
+
+  argsLists.forEach((args) => {
+    const cp = fork(fixtures.path('child-process-echo-options.js'), args, {
+      env: { ...process.env, ...expectedEnv }
+    });
+
+    cp.on(
+      'message',
+      common.mustCall(({ env }) => {
+        assert.strictEqual(env.foo, expectedEnv.foo);
+      })
+    );
+
+    cp.on(
+      'exit',
+      common.mustCall((code) => {
+        assert.strictEqual(code, 0);
+      })
+    );
+  });
+}
+
+// Ensure that the third argument should be type of object if provided
+{
+  const invalidThirdArgs = [
+    0,
+    true,
+    () => {},
+    Symbol('t'),
+  ];
+  invalidThirdArgs.forEach((arg) => {
+    assert.throws(
+      () => {
+        fork(fixtures.path('child-process-echo-options.js'), [], arg);
+      },
+      {
+        code: 'ERR_INVALID_ARG_TYPE',
+        name: 'TypeError'
+      }
+    );
+  });
+}
diff --git a/test/js/node/test/parallel/test-child-process-fork-close.js b/test/js/node/test/parallel/test-child-process-fork-close.js
new file mode 100644
index 0000000000..bfaabd3d2f
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-fork-close.js
@@ -0,0 +1,52 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const fork = require('child_process').fork;
+const fixtures = require('../common/fixtures');
+
+const cp = fork(fixtures.path('child-process-message-and-exit.js'));
+
+let gotMessage = false;
+let gotExit = false;
+let gotClose = false;
+
+cp.on('message', common.mustCall(function(message) {
+  assert(!gotMessage);
+  assert(!gotClose);
+  assert.strictEqual(message, 'hello');
+  gotMessage = true;
+}));
+
+cp.on('exit', common.mustCall(function() {
+  assert(!gotExit);
+  assert(!gotClose);
+  gotExit = true;
+}));
+
+cp.on('close', common.mustCall(function() {
+  assert(gotMessage);
+  assert(gotExit);
+  assert(!gotClose);
+  gotClose = true;
+}));
diff --git a/test/js/node/test/parallel/test-child-process-fork-detached.js b/test/js/node/test/parallel/test-child-process-fork-detached.js
new file mode 100644
index 0000000000..87c1517328
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-fork-detached.js
@@ -0,0 +1,23 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const fork = require('child_process').fork;
+const fixtures = require('../common/fixtures');
+
+const nonPersistentNode = fork(
+  fixtures.path('parent-process-nonpersistent-fork.js'),
+  [],
+  { silent: true });
+
+let childId = -1;
+
+nonPersistentNode.stdout.on('data', (data) => {
+  childId = parseInt(data, 10);
+  nonPersistentNode.kill();
+});
+
+process.on('exit', () => {
+  assert.notStrictEqual(childId, -1);
+  // Killing the child process should not throw an error
+  process.kill(childId);
+});
diff --git a/test/js/node/test/parallel/test-child-process-fork-exec-path.js b/test/js/node/test/parallel/test-child-process-fork-exec-path.js
new file mode 100644
index 0000000000..3417a102c6
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-fork-exec-path.js
@@ -0,0 +1,60 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+
+// Test that `fork()` respects the `execPath` option.
+
+const tmpdir = require('../common/tmpdir');
+const { addLibraryPath } = require('../common/shared-lib-util');
+const assert = require('assert');
+const fs = require('fs');
+const { fork } = require('child_process');
+
+const msg = { test: 'this' };
+const nodePath = process.execPath;
+const copyPath = tmpdir.resolve('node-copy.exe');
+
+addLibraryPath(process.env);
+
+// Child
+if (process.env.FORK) {
+  assert.strictEqual(process.execPath, copyPath);
+  assert.ok(process.send);
+  process.send(msg);
+  return process.exit();
+}
+
+// Parent
+tmpdir.refresh();
+assert.strictEqual(fs.existsSync(copyPath), false);
+fs.copyFileSync(nodePath, copyPath, fs.constants.COPYFILE_FICLONE);
+fs.chmodSync(copyPath, '0755');
+
+const envCopy = { ...process.env, FORK: 'true' };
+const child = fork(__filename, { execPath: copyPath, env: envCopy });
+child.on('message', common.mustCall(function(recv) {
+  assert.deepStrictEqual(recv, msg);
+}));
+child.on('exit', common.mustCall(function(code) {
+  assert.strictEqual(code, 0);
+}));
diff --git a/test/js/node/test/parallel/test-child-process-fork-no-shell.js b/test/js/node/test/parallel/test-child-process-fork-no-shell.js
new file mode 100644
index 0000000000..81ceab61fd
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-fork-no-shell.js
@@ -0,0 +1,20 @@
+'use strict';
+// This test verifies that the shell option is not supported by fork().
+const common = require('../common');
+const assert = require('assert');
+const cp = require('child_process');
+const expected = common.isWindows ? '%foo%' : '$foo';
+
+if (process.argv[2] === undefined) {
+  const child = cp.fork(__filename, [expected], {
+    shell: true,
+    env: { ...process.env, foo: 'bar' }
+  });
+
+  child.on('exit', common.mustCall((code, signal) => {
+    assert.strictEqual(code, 0);
+    assert.strictEqual(signal, null);
+  }));
+} else {
+  assert.strictEqual(process.argv[2], expected);
+}
diff --git a/test/js/node/test/parallel/test-child-process-fork-url.mjs b/test/js/node/test/parallel/test-child-process-fork-url.mjs
new file mode 100644
index 0000000000..9261b87563
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-fork-url.mjs
@@ -0,0 +1,11 @@
+import { mustCall } from '../common/index.mjs';
+import { fork } from 'child_process';
+
+if (process.argv[2] === 'child') {
+  process.disconnect();
+} else {
+  const child = fork(new URL(import.meta.url), ['child']);
+
+  child.on('disconnect', mustCall());
+  child.once('exit', mustCall());
+}
diff --git a/test/js/node/test/parallel/test-child-process-fork3.js b/test/js/node/test/parallel/test-child-process-fork3.js
new file mode 100644
index 0000000000..735a441950
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-fork3.js
@@ -0,0 +1,27 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const child_process = require('child_process');
+const fixtures = require('../common/fixtures');
+
+child_process.fork(fixtures.path('empty.js')); // should not hang
diff --git a/test/js/node/test/parallel/test-child-process-ipc.js b/test/js/node/test/parallel/test-child-process-ipc.js
new file mode 100644
index 0000000000..d776f9594b
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-ipc.js
@@ -0,0 +1,63 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+
+const {
+  mustCall,
+  mustNotCall,
+} = require('../common');
+const assert = require('assert');
+const debug = require('util').debuglog('test');
+
+const { spawn } = require('child_process');
+const fixtures = require('../common/fixtures');
+
+const sub = fixtures.path('echo.js');
+
+const child = spawn(process.argv[0], [sub]);
+
+child.stderr.on('data', mustNotCall());
+
+child.stdout.setEncoding('utf8');
+
+const messages = [
+  'hello world\r\n',
+  'echo me\r\n',
+];
+
+child.stdout.on('data', mustCall((data) => {
+  debug(`child said: ${JSON.stringify(data)}`);
+  const test = messages.shift();
+  debug(`testing for '${test}'`);
+  assert.strictEqual(data, test);
+  if (messages.length) {
+    debug(`writing '${messages[0]}'`);
+    child.stdin.write(messages[0]);
+  } else {
+    assert.strictEqual(messages.length, 0);
+    child.stdin.end();
+  }
+}, messages.length));
+
+child.stdout.on('end', mustCall((data) => {
+  debug('child end');
+}));
diff --git a/test/js/node/test/parallel/test-child-process-kill.js b/test/js/node/test/parallel/test-child-process-kill.js
new file mode 100644
index 0000000000..1025c69ba1
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-kill.js
@@ -0,0 +1,41 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const spawn = require('child_process').spawn;
+const cat = spawn(common.isWindows ? 'cmd' : 'cat');
+
+cat.stdout.on('end', common.mustCall());
+cat.stderr.on('data', common.mustNotCall());
+cat.stderr.on('end', common.mustCall());
+
+cat.on('exit', common.mustCall((code, signal) => {
+  assert.strictEqual(code, null);
+  assert.strictEqual(signal, 'SIGTERM');
+  assert.strictEqual(cat.signalCode, 'SIGTERM');
+}));
+
+assert.strictEqual(cat.signalCode, null);
+assert.strictEqual(cat.killed, false);
+cat.kill();
+assert.strictEqual(cat.killed, true);
diff --git a/test/js/node/test/parallel/test-child-process-no-deprecation.js b/test/js/node/test/parallel/test-child-process-no-deprecation.js
new file mode 100644
index 0000000000..d12e5b882f
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-no-deprecation.js
@@ -0,0 +1,15 @@
+'use strict';
+const common = require('../common');
+process.noDeprecation = true;
+
+if (process.argv[2] === 'child') {
+  process.emitWarning('Something else is deprecated.', 'DeprecationWarning');
+} else {
+  // parent process
+  const spawn = require('child_process').spawn;
+
+  // spawn self as child
+  const child = spawn(process.execPath, [process.argv[1], 'child']);
+
+  child.stderr.on('data', common.mustNotCall());
+}
diff --git a/test/js/node/test/parallel/test-child-process-prototype-tampering.mjs b/test/js/node/test/parallel/test-child-process-prototype-tampering.mjs
new file mode 100644
index 0000000000..d94c4bdbc6
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-prototype-tampering.mjs
@@ -0,0 +1,91 @@
+import * as common from '../common/index.mjs';
+import * as fixtures from '../common/fixtures.mjs';
+import { EOL } from 'node:os';
+import { strictEqual, notStrictEqual, throws } from 'node:assert';
+import cp from 'node:child_process';
+
+// TODO(LiviaMedeiros): test on different platforms
+if (!common.isLinux)
+  common.skip();
+
+const expectedCWD = process.cwd();
+const expectedUID = process.getuid();
+
+for (const tamperedCwd of ['', '/tmp', '/not/existing/malicious/path', 42n]) {
+  Object.prototype.cwd = tamperedCwd;
+
+  cp.exec('pwd', common.mustSucceed((out) => {
+    strictEqual(`${out}`, `${expectedCWD}${EOL}`);
+  }));
+  strictEqual(`${cp.execSync('pwd')}`, `${expectedCWD}${EOL}`);
+  cp.execFile('pwd', common.mustSucceed((out) => {
+    strictEqual(`${out}`, `${expectedCWD}${EOL}`);
+  }));
+  strictEqual(`${cp.execFileSync('pwd')}`, `${expectedCWD}${EOL}`);
+  cp.spawn('pwd').stdout.on('data', common.mustCall((out) => {
+    strictEqual(`${out}`, `${expectedCWD}${EOL}`);
+  }));
+  strictEqual(`${cp.spawnSync('pwd').stdout}`, `${expectedCWD}${EOL}`);
+
+  delete Object.prototype.cwd;
+}
+
+for (const tamperedUID of [0, 1, 999, 1000, 0n, 'gwak']) {
+  Object.prototype.uid = tamperedUID;
+
+  cp.exec('id -u', common.mustSucceed((out) => {
+    strictEqual(`${out}`, `${expectedUID}${EOL}`);
+  }));
+  strictEqual(`${cp.execSync('id -u')}`, `${expectedUID}${EOL}`);
+  cp.execFile('id', ['-u'], common.mustSucceed((out) => {
+    strictEqual(`${out}`, `${expectedUID}${EOL}`);
+  }));
+  strictEqual(`${cp.execFileSync('id', ['-u'])}`, `${expectedUID}${EOL}`);
+  cp.spawn('id', ['-u']).stdout.on('data', common.mustCall((out) => {
+    strictEqual(`${out}`, `${expectedUID}${EOL}`);
+  }));
+  strictEqual(`${cp.spawnSync('id', ['-u']).stdout}`, `${expectedUID}${EOL}`);
+
+  delete Object.prototype.uid;
+}
+
+{
+  Object.prototype.execPath = '/not/existing/malicious/path';
+
+  // Does not throw ENOENT
+  cp.fork(fixtures.path('empty.js'));
+
+  delete Object.prototype.execPath;
+}
+
+for (const shellCommandArgument of ['-L && echo "tampered"']) {
+  Object.prototype.shell = true;
+  const cmd = 'pwd';
+  let cmdExitCode = '';
+
+  const program = cp.spawn(cmd, [shellCommandArgument], { cwd: expectedCWD });
+  program.stderr.on('data', common.mustCall());
+  program.stdout.on('data', common.mustNotCall());
+
+  program.on('exit', common.mustCall((code) => {
+    notStrictEqual(code, 0);
+  }));
+
+  cp.execFile(cmd, [shellCommandArgument], { cwd: expectedCWD },
+              common.mustCall((err) => {
+                notStrictEqual(err.code, 0);
+              })
+  );
+
+  throws(() => {
+    cp.execFileSync(cmd, [shellCommandArgument], { cwd: expectedCWD });
+  }, (e) => {
+    notStrictEqual(e.status, 0);
+    return true;
+  });
+
+  cmdExitCode = cp.spawnSync(cmd, [shellCommandArgument], { cwd: expectedCWD }).status;
+  notStrictEqual(cmdExitCode, 0);
+
+  delete Object.prototype.shell;
+}
diff --git a/test/js/node/test/parallel/test-child-process-send-type-error.js b/test/js/node/test/parallel/test-child-process-send-type-error.js
new file mode 100644
index 0000000000..65c620dd29
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-send-type-error.js
@@ -0,0 +1,29 @@
+'use strict';
+const common = require('../common');
+
+const assert = require('assert');
+const cp = require('child_process');
+
+function fail(proc, args) {
+  assert.throws(() => {
+    proc.send.apply(proc, args);
+  }, { code: 'ERR_INVALID_ARG_TYPE', name: 'TypeError' });
+}
+
+let target = process;
+
+if (process.argv[2] !== 'child') {
+  target = cp.fork(__filename, ['child']);
+  target.on('exit', common.mustCall((code, signal) => {
+    assert.strictEqual(code, 0);
+    assert.strictEqual(signal, null);
+  }));
+}
+
+fail(target, ['msg', null, null]);
+fail(target, ['msg', null, '']);
+fail(target, ['msg', null, 'foo']);
+fail(target, ['msg', null, 0]);
+fail(target, ['msg', null, NaN]);
+fail(target, ['msg', null, 1]);
+fail(target, ['msg', null, null, common.mustNotCall()]);
diff --git a/test/js/node/test/parallel/test-child-process-set-blocking.js b/test/js/node/test/parallel/test-child-process-set-blocking.js
new file mode 100644
index 0000000000..6dcfa93141
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-set-blocking.js
@@ -0,0 +1,36 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const ch = require('child_process');
+
+const SIZE = 100000;
+const python = process.env.PYTHON || (common.isWindows ? 'python' : 'python3');
+
+const cp = ch.spawn(python, ['-c', `print(${SIZE} * "C")`], {
+  stdio: 'inherit'
+});
+
+cp.on('exit', common.mustCall(function(code) {
+  assert.strictEqual(code, 0);
+}));
diff --git a/test/js/node/test/parallel/test-child-process-silent.js b/test/js/node/test/parallel/test-child-process-silent.js
new file mode 100644
index 0000000000..892c4527c9
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-silent.js
@@ -0,0 +1,106 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const childProcess = require('child_process');
+
+// Child pipe test
+if (process.argv[2] === 'pipe') {
+  process.stdout.write('stdout message');
+  process.stderr.write('stderr message');
+
+} else if (process.argv[2] === 'ipc') {
+  // Child IPC test
+  process.send('message from child');
+  process.on('message', function() {
+    process.send('got message from primary');
+  });
+
+} else if (process.argv[2] === 'primary') {
+  // Primary | start child pipe test
+
+  const child = childProcess.fork(process.argv[1], ['pipe'], { silent: true });
+
+  // Allow child process to self terminate
+  child.disconnect();
+
+  child.on('exit', function() {
+    process.exit(0);
+  });
+
+} else {
+  // Testcase | start primary && child IPC test
+
+  // testing: is stderr and stdout piped to primary
+  const args = [process.argv[1], 'primary'];
+  const primary = childProcess.spawn(process.execPath, args);
+
+  // Got any stderr or std data
+  let stdoutData = false;
+  primary.stdout.on('data', function() {
+    stdoutData = true;
+  });
+  let stderrData = false;
+  primary.stderr.on('data', function() {
+    stderrData = true;
+  });
+
+  // testing: do message system work when using silent
+  const child = childProcess.fork(process.argv[1], ['ipc'], { silent: true });
+
+  // Manual pipe so we will get errors
+  child.stderr.pipe(process.stderr, { end: false });
+  child.stdout.pipe(process.stdout, { end: false });
+
+  let childSending = false;
+  let childReceiving = false;
+  child.on('message', function(message) {
+    if (childSending === false) {
+      childSending = (message === 'message from child');
+    }
+
+    if (childReceiving === false) {
+      childReceiving = (message === 'got message from primary');
+    }
+
+    if (childReceiving === true) {
+      child.kill();
+    }
+  });
+  child.send('message to child');
+
+  // Check all values
+  process.on('exit', function() {
+    // clean up
+    child.kill();
+    primary.kill();
+
+    // Check std(out|err) pipes
+    assert.ok(!stdoutData);
+    assert.ok(!stderrData);
+
+    // Check message system
+    assert.ok(childSending);
+    assert.ok(childReceiving);
+  });
+}
diff --git a/test/js/node/test/parallel/test-child-process-spawn-args.js b/test/js/node/test/parallel/test-child-process-spawn-args.js
new file mode 100644
index 0000000000..ec56f409fa
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-spawn-args.js
@@ -0,0 +1,55 @@
+'use strict';
+
+// This test confirms that `undefined`, `null`, and `[]`
+// can be used as a placeholder for the second argument (`args`) of `spawn()`.
+// Previously, there was a bug where using `undefined` for the second argument
+// caused the third argument (`options`) to be ignored.
+// See https://github.com/nodejs/node/issues/24912.
+
+const common = require('../common');
+const tmpdir = require('../common/tmpdir');
+
+const assert = require('assert');
+const { spawn } = require('child_process');
+
+tmpdir.refresh();
+
+const command = common.isWindows ? 'cd' : 'pwd';
+const options = { cwd: tmpdir.path };
+
+if (common.isWindows) {
+  // This test is not the case for Windows based systems
+  // unless the `shell` options equals to `true`
+
+  options.shell = true;
+}
+
+const testCases = [
+  undefined,
+  null,
+  [],
+];
+
+const expectedResult = tmpdir.path.trim().toLowerCase();
+
+(async () => {
+  const results = await Promise.all(
+    testCases.map((testCase) => {
+      return new Promise((resolve) => {
+        const subprocess = spawn(command, testCase, options);
+
+        let accumulatedData = Buffer.alloc(0);
+
+        subprocess.stdout.on('data', common.mustCall((data) => {
+          accumulatedData = Buffer.concat([accumulatedData, data]);
+        }));
+
+        subprocess.stdout.on('end', () => {
+          resolve(accumulatedData.toString().trim().toLowerCase());
+        });
+      });
+    })
+  );
+
+  assert.deepStrictEqual([...new Set(results)], [expectedResult]);
+})().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-child-process-spawn-controller.js b/test/js/node/test/parallel/test-child-process-spawn-controller.js
new file mode 100644
index 0000000000..20facb09b3
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-spawn-controller.js
@@ -0,0 +1,183 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { spawn } = require('child_process');
+const fixtures = require('../common/fixtures');
+
+const aliveScript = fixtures.path('child-process-stay-alive-forever.js');
+{
+  // Verify that passing an AbortSignal works
+  const controller = new AbortController();
+  const { signal } = controller;
+
+  const cp = spawn(process.execPath, [aliveScript], {
+    signal,
+  });
+
+  cp.on('exit', common.mustCall((code, killSignal) => {
+    assert.strictEqual(code, null);
+    assert.strictEqual(killSignal, 'SIGTERM');
+  }));
+
+  cp.on('error', common.mustCall((e) => {
+    assert.strictEqual(e.name, 'AbortError');
+  }));
+
+  controller.abort();
+}
+
+{
+  // Verify that passing an AbortSignal with custom abort error works
+  const controller = new AbortController();
+  const { signal } = controller;
+  const cp = spawn(process.execPath, [aliveScript], {
+    signal,
+  });
+
+  cp.on('exit', common.mustCall((code, killSignal) => {
+    assert.strictEqual(code, null);
+    assert.strictEqual(killSignal, 'SIGTERM');
+  }));
+
+  cp.on('error', common.mustCall((e) => {
+    assert.strictEqual(e.name, 'AbortError');
+    assert.strictEqual(e.cause.name, 'Error');
+    assert.strictEqual(e.cause.message, 'boom');
+  }));
+
+  controller.abort(new Error('boom'));
+}
+
+{
+  const controller = new AbortController();
+  const { signal } = controller;
+  const cp = spawn(process.execPath, [aliveScript], {
+    signal,
+  });
+
+  cp.on('exit', common.mustCall((code, killSignal) => {
+    assert.strictEqual(code, null);
+    assert.strictEqual(killSignal, 'SIGTERM');
+  }));
+
+  cp.on('error', common.mustCall((e) => {
+    assert.strictEqual(e.name, 'AbortError');
+    assert.strictEqual(e.cause, 'boom');
+  }));
+
+  controller.abort('boom');
+}
+
+{
+  // Verify that passing an already-aborted signal works.
+  const signal = AbortSignal.abort();
+
+  const cp = spawn(process.execPath, [aliveScript], {
+    signal,
+  });
+  cp.on('exit', common.mustCall((code, killSignal) => {
+    assert.strictEqual(code, null);
+    assert.strictEqual(killSignal, 'SIGTERM');
+  }));
+
+  cp.on('error', common.mustCall((e) => {
+    assert.strictEqual(e.name, 'AbortError');
+  }));
+}
+
+{
+  // Verify that passing an already-aborted signal with custom abort error
+  // works.
+  const signal = AbortSignal.abort(new Error('boom'));
+  const cp = spawn(process.execPath, [aliveScript], {
+    signal,
+  });
+  cp.on('exit', common.mustCall((code, killSignal) => {
+    assert.strictEqual(code, null);
+    assert.strictEqual(killSignal, 'SIGTERM');
+  }));
+
+  cp.on('error', common.mustCall((e) => {
+    assert.strictEqual(e.name, 'AbortError');
+    assert.strictEqual(e.cause.name, 'Error');
+    assert.strictEqual(e.cause.message, 'boom');
+  }));
+}
+
+{
+  const signal = AbortSignal.abort('boom');
+  const cp = spawn(process.execPath, [aliveScript], {
+    signal,
+  });
+  cp.on('exit', common.mustCall((code, killSignal) => {
+    assert.strictEqual(code, null);
+    assert.strictEqual(killSignal, 'SIGTERM');
+  }));
+
+  cp.on('error', common.mustCall((e) => {
+    assert.strictEqual(e.name, 'AbortError');
+    assert.strictEqual(e.cause, 'boom');
+  }));
+}
+
+{
+  // Verify that waiting a bit and closing works
+  const controller = new AbortController();
+  const { signal } = controller;
+
+  const cp = spawn(process.execPath, [aliveScript], {
+    signal,
+  });
+
+  cp.on('exit', common.mustCall((code, killSignal) => {
+    assert.strictEqual(code, null);
+    assert.strictEqual(killSignal, 'SIGTERM');
+  }));
+
+  cp.on('error', common.mustCall((e) => {
+    assert.strictEqual(e.name, 'AbortError');
+  }));
+
+  setTimeout(() => controller.abort(), 1);
+}
+
+{
+  // Test passing a different killSignal
+  const controller = new AbortController();
+  const { signal } = controller;
+
+  const cp = spawn(process.execPath, [aliveScript], {
+    signal,
+    killSignal: 'SIGKILL',
+  });
+
+  cp.on('exit', common.mustCall((code, killSignal) => {
+    assert.strictEqual(code, null);
+    assert.strictEqual(killSignal, 'SIGKILL');
+  }));
+
+  cp.on('error', common.mustCall((e) => {
+    assert.strictEqual(e.name, 'AbortError');
+  }));
+
+  setTimeout(() => controller.abort(), 1);
+}
+
+{
+  // Test aborting a cp before close but after exit
+  const controller = new AbortController();
+  const { signal } = controller;
+
+  const cp = spawn(process.execPath, [aliveScript], {
+    signal,
+  });
+
+  cp.on('exit', common.mustCall(() => {
+    controller.abort();
+  }));
+
+  cp.on('error', common.mustNotCall());
+
+  setTimeout(() => cp.kill(), 1);
+}
diff --git a/test/js/node/test/parallel/test-child-process-spawn-event.js b/test/js/node/test/parallel/test-child-process-spawn-event.js
new file mode 100644
index 0000000000..c025d86286
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-spawn-event.js
@@ -0,0 +1,27 @@
+'use strict';
+const common = require('../common');
+const spawn = require('child_process').spawn;
+const assert = require('assert');
+
+const subprocess = spawn('echo', ['ok']);
+
+let didSpawn = false;
+subprocess.on('spawn', function() {
+  didSpawn = true;
+});
+function mustCallAfterSpawn() {
+  return common.mustCall(function() {
+    assert.ok(didSpawn);
+  });
+}
+
+subprocess.on('error', common.mustNotCall());
+subprocess.on('spawn', common.mustCall());
+subprocess.stdout.on('data', mustCallAfterSpawn());
+subprocess.stdout.on('end', mustCallAfterSpawn());
+subprocess.stdout.on('close', mustCallAfterSpawn());
+subprocess.stderr.on('data', common.mustNotCall());
+subprocess.stderr.on('end', mustCallAfterSpawn());
+subprocess.stderr.on('close', mustCallAfterSpawn());
+subprocess.on('exit', mustCallAfterSpawn());
+subprocess.on('close', mustCallAfterSpawn());
diff --git a/test/js/node/test/parallel/test-child-process-spawnsync-args.js b/test/js/node/test/parallel/test-child-process-spawnsync-args.js
new file mode 100644
index 0000000000..4e65b22f6e
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-spawnsync-args.js
@@ -0,0 +1,48 @@
+'use strict';
+
+// This test confirms that `undefined`, `null`, and `[]` can be used
+// as a placeholder for the second argument (`args`) of `spawnSync()`.
+// Previously, there was a bug where using `undefined` for the second argument
+// caused the third argument (`options`) to be ignored.
+// See https://github.com/nodejs/node/issues/24912.
+
+const common = require('../common');
+const tmpdir = require('../common/tmpdir');
+
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+
+const command = common.isWindows ? 'cd' : 'pwd';
+const options = { cwd: tmpdir.path };
+
+tmpdir.refresh();
+
+if (common.isWindows) {
+  // This test is not the case for Windows based systems
+  // unless the `shell` options equals to `true`
+
+  options.shell = true;
+}
+
+const testCases = [
+  undefined,
+  null,
+  [],
+];
+
+const expectedResult = tmpdir.path.trim().toLowerCase();
+
+const results = testCases.map((testCase) => {
+  const { stdout, stderr, error } = spawnSync(
+    command,
+    testCase,
+    options
+  );
+
+  assert.ifError(error);
+  assert.deepStrictEqual(stderr, Buffer.alloc(0));
+
+  return stdout.toString().trim().toLowerCase();
+});
+
+assert.deepStrictEqual([...new Set(results)], [expectedResult]);
diff --git a/test/js/node/test/parallel/test-child-process-spawnsync-env.js b/test/js/node/test/parallel/test-child-process-spawnsync-env.js
new file mode 100644
index 0000000000..c8e11b5067
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-spawnsync-env.js
@@ -0,0 +1,36 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const cp = require('child_process');
+
+if (process.argv[2] === 'child') {
+  console.log(process.env.foo);
+} else {
+  const expected = 'bar';
+  const child = cp.spawnSync(process.execPath, [__filename, 'child'], {
+    env: Object.assign(process.env, { foo: expected })
+  });
+
+  assert.strictEqual(child.stdout.toString().trim(), expected);
+}
diff --git a/test/js/node/test/parallel/test-child-process-spawnsync-input.js b/test/js/node/test/parallel/test-child-process-spawnsync-input.js
new file mode 100644
index 0000000000..62ae476ae1
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-spawnsync-input.js
@@ -0,0 +1,125 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+
+const assert = require('assert');
+
+const spawnSync = require('child_process').spawnSync;
+
+const msgOut = 'this is stdout';
+const msgErr = 'this is stderr';
+
+// This is actually not os.EOL?
+const msgOutBuf = Buffer.from(`${msgOut}\n`);
+const msgErrBuf = Buffer.from(`${msgErr}\n`);
+
+const args = [
+  '-e',
+  `console.log("${msgOut}"); console.error("${msgErr}");`,
+];
+
+let ret;
+
+
+function checkSpawnSyncRet(ret) {
+  assert.strictEqual(ret.status, 0);
+  assert.strictEqual(ret.error, undefined);
+}
+
+function verifyBufOutput(ret) {
+  checkSpawnSyncRet(ret);
+  assert.deepStrictEqual(ret.stdout, msgOutBuf);
+  assert.deepStrictEqual(ret.stderr, msgErrBuf);
+}
+
+if (process.argv.includes('spawnchild')) {
+  switch (process.argv[3]) {
+    case '1':
+      ret = spawnSync(process.execPath, args, { stdio: 'inherit' });
+      checkSpawnSyncRet(ret);
+      break;
+    case '2':
+      ret = spawnSync(process.execPath, args, {
+        stdio: ['inherit', 'inherit', 'inherit']
+      });
+      checkSpawnSyncRet(ret);
+      break;
+  }
+  process.exit(0);
+  return;
+}
+
+verifyBufOutput(spawnSync(process.execPath, [__filename, 'spawnchild', 1]));
+verifyBufOutput(spawnSync(process.execPath, [__filename, 'spawnchild', 2]));
+
+let options = {
+  input: 1234
+};
+
+assert.throws(
+  () => spawnSync('cat', [], options),
+  { code: 'ERR_INVALID_ARG_TYPE', name: 'TypeError' });
+
+options = {
+  input: 'hello world'
+};
+
+ret = spawnSync('cat', [], options);
+
+checkSpawnSyncRet(ret);
+assert.strictEqual(ret.stdout.toString('utf8'), options.input);
+assert.strictEqual(ret.stderr.toString('utf8'), '');
+
+options = {
+  input: Buffer.from('hello world')
+};
+
+ret = spawnSync('cat', [], options);
+
+checkSpawnSyncRet(ret);
+assert.deepStrictEqual(ret.stdout, options.input);
+assert.deepStrictEqual(ret.stderr, Buffer.from(''));
+
+// common.getArrayBufferViews expects a buffer
+// with length an multiple of 8
+const msgBuf = Buffer.from('hello world'.repeat(8));
+for (const arrayBufferView of common.getArrayBufferViews(msgBuf)) {
+  options = {
+    input: arrayBufferView
+  };
+
+  ret = spawnSync('cat', [], options);
+
+  checkSpawnSyncRet(ret);
+
+  assert.deepStrictEqual(ret.stdout, msgBuf);
+  assert.deepStrictEqual(ret.stderr, Buffer.from(''));
+}
+
+verifyBufOutput(spawnSync(process.execPath, args));
+
+ret = spawnSync(process.execPath, args, { encoding: 'utf8' });
+
+checkSpawnSyncRet(ret);
+assert.strictEqual(ret.stdout, `${msgOut}\n`);
+assert.strictEqual(ret.stderr, `${msgErr}\n`);
diff --git a/test/js/node/test/parallel/test-child-process-stdin-ipc.js b/test/js/node/test/parallel/test-child-process-stdin-ipc.js
new file mode 100644
index 0000000000..945960b99b
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-stdin-ipc.js
@@ -0,0 +1,40 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+const spawn = require('child_process').spawn;
+
+if (process.argv[2] === 'child') {
+  // Just reference stdin, it should start it
+  process.stdin; // eslint-disable-line no-unused-expressions
+  return;
+}
+
+const proc = spawn(process.execPath, [__filename, 'child'], {
+  stdio: ['ipc', 'inherit', 'inherit']
+});
+
+proc.on('exit', common.mustCall(function(code) {
+  assert.strictEqual(code, 0);
+}));
diff --git a/test/js/node/test/parallel/test-child-process-stdio-big-write-end.js b/test/js/node/test/parallel/test-child-process-stdio-big-write-end.js
new file mode 100644
index 0000000000..85e6a8b321
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-stdio-big-write-end.js
@@ -0,0 +1,86 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const {
+  mustCall,
+  mustCallAtLeast,
+} = require('../common');
+const assert = require('assert');
+const debug = require('util').debuglog('test');
+
+let bufsize = 0;
+
+switch (process.argv[2]) {
+  case undefined:
+    return parent();
+  case 'child':
+    return child();
+  default:
+    throw new Error('invalid');
+}
+
+function parent() {
+  const spawn = require('child_process').spawn;
+  const child = spawn(process.execPath, [__filename, 'child']);
+  let sent = 0;
+
+  let n = '';
+  child.stdout.setEncoding('ascii');
+  child.stdout.on('data', mustCallAtLeast((c) => {
+    n += c;
+  }));
+  child.stdout.on('end', mustCall(() => {
+    assert.strictEqual(+n, sent);
+    debug('ok');
+  }));
+
+  // Write until the buffer fills up.
+  let buf;
+  do {
+    bufsize += 1024;
+    buf = Buffer.alloc(bufsize, '.');
+    sent += bufsize;
+  } while (child.stdin.write(buf));
+
+  // Then write a bunch more times.
+  for (let i = 0; i < 100; i++) {
+    const buf = Buffer.alloc(bufsize, '.');
+    sent += bufsize;
+    child.stdin.write(buf);
+  }
+
+  // Now end, before it's all flushed.
+  child.stdin.end();
+
+  // now we wait...
+}
+
+function child() {
+  let received = 0;
+  process.stdin.on('data', mustCallAtLeast((c) => {
+    received += c.length;
+  }));
+  process.stdin.on('end', mustCall(() => {
+    // This console.log is part of the test.
+    console.log(received);
+  }));
+}
diff --git a/test/js/node/test/parallel/test-child-process-stdio-inherit.js b/test/js/node/test/parallel/test-child-process-stdio-inherit.js
new file mode 100644
index 0000000000..034a077016
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-stdio-inherit.js
@@ -0,0 +1,56 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const spawn = require('child_process').spawn;
+
+if (process.argv[2] === 'parent')
+  parent();
+else
+  grandparent();
+
+function grandparent() {
+  const child = spawn(process.execPath, [__filename, 'parent']);
+  child.stderr.pipe(process.stderr);
+  let output = '';
+  const input = 'asdfasdf';
+
+  child.stdout.on('data', function(chunk) {
+    output += chunk;
+  });
+  child.stdout.setEncoding('utf8');
+
+  child.stdin.end(input);
+
+  child.on('close', function(code, signal) {
+    assert.strictEqual(code, 0);
+    assert.strictEqual(signal, null);
+    // 'cat' on windows adds a \r\n at the end.
+    assert.strictEqual(output.trim(), input.trim());
+  });
+}
+
+function parent() {
+  // Should not immediately exit.
+  spawn('cat', [], { stdio: 'inherit' });
+}
diff --git a/test/js/node/test/parallel/test-child-process-stdio-overlapped.js b/test/js/node/test/parallel/test-child-process-stdio-overlapped.js
new file mode 100644
index 0000000000..5c48e7ee10
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-stdio-overlapped.js
@@ -0,0 +1,79 @@
+// Test for "overlapped" stdio option. This test uses the "overlapped-checker"
+// helper program which basically a specialized echo program.
+//
+// The test has two goals:
+//
+// - Verify that overlapped I/O works on windows. The test program will deadlock
+//   if stdin doesn't have the FILE_FLAG_OVERLAPPED flag set on startup (see
+//   test/overlapped-checker/main_win.c for more details).
+// - Verify that "overlapped" stdio option works transparently as a pipe (on
+//   unix/windows)
+//
+// This is how the test works:
+//
+// - This script assumes only numeric strings are written to the test program
+//   stdout.
+// - The test program will be spawned with "overlapped" set on stdin and "pipe"
+//   set on stdout/stderr and at startup writes a number to its stdout
+// - When this script receives some data, it will parse the number, add 50 and
+//   write to the test program's stdin.
+// - The test program will then echo the number back to us which will repeat the
+//   cycle until the number reaches 200, at which point we send the "exit"
+//   string, which causes the test program to exit.
+// - Extra assertion: Every time the test program writes a string to its stdout,
+//   it will write the number of bytes written to stderr.
+// - If overlapped I/O is not setup correctly, this test is going to hang.
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const path = require('path');
+const child_process = require('child_process');
+
+const exeExtension = process.platform === 'win32' ? '.exe' : '';
+const exe = 'overlapped-checker' + exeExtension;
+const exePath = path.join(path.dirname(process.execPath), exe);
+
+if (!require('fs').existsSync(exePath)) {
+  common.skip(exe + ' binary is not available');
+}
+
+const child = child_process.spawn(exePath, [], {
+  stdio: ['overlapped', 'pipe', 'pipe']
+});
+
+child.stdin.setEncoding('utf8');
+child.stdout.setEncoding('utf8');
+child.stderr.setEncoding('utf8');
+
+function writeNext(n) {
+  child.stdin.write((n + 50).toString());
+}
+
+child.stdout.on('data', (s) => {
+  const n = Number(s);
+  if (n >= 200) {
+    child.stdin.write('exit');
+    return;
+  }
+  writeNext(n);
+});
+
+let stderr = '';
+child.stderr.on('data', (s) => {
+  stderr += s;
+});
+
+child.stderr.on('end', common.mustCall(() => {
+  // This is the sequence of numbers sent to us:
+  // - 0 (1 byte written)
+  // - 50 (2 bytes written)
+  // - 100 (3 bytes written)
+  // - 150 (3 bytes written)
+  // - 200 (3 bytes written)
+  assert.strictEqual(stderr, '12333');
+}));
+
+child.on('exit', common.mustCall((status) => {
+  // The test program will return the number of writes as status code.
+  assert.strictEqual(status, 0);
+}));
diff --git a/test/js/node/test/parallel/test-child-process-stdout-flush-exit.js b/test/js/node/test/parallel/test-child-process-stdout-flush-exit.js
new file mode 100644
index 0000000000..3c5f00d9bb
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-stdout-flush-exit.js
@@ -0,0 +1,56 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+// If child process output to console and exit
+// The console.log statements here are part of the test.
+if (process.argv[2] === 'child') {
+  console.log('hello');
+  for (let i = 0; i < 200; i++) {
+    console.log('filler');
+  }
+  console.log('goodbye');
+  process.exit(0);
+} else {
+  // parent process
+  const spawn = require('child_process').spawn;
+
+  // spawn self as child
+  const child = spawn(process.argv[0], [process.argv[1], 'child']);
+
+  let stdout = '';
+
+  child.stderr.on('data', common.mustNotCall());
+
+  // Check if we receive both 'hello' at start and 'goodbye' at end
+  child.stdout.setEncoding('utf8');
+  child.stdout.on('data', common.mustCallAtLeast((data) => {
+    stdout += data;
+  }));
+
+  child.on('close', common.mustCall(() => {
+    assert.strictEqual(stdout.slice(0, 6), 'hello\n');
+    assert.strictEqual(stdout.slice(stdout.length - 8), 'goodbye\n');
+  }));
+}
diff --git a/test/js/node/test/parallel/test-child-process-stdout-flush.js b/test/js/node/test/parallel/test-child-process-stdout-flush.js
new file mode 100644
index 0000000000..bc549fb6f3
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-stdout-flush.js
@@ -0,0 +1,48 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const spawn = require('child_process').spawn;
+const fixtures = require('../common/fixtures');
+
+const sub = fixtures.path('print-chars.js');
+
+const n = 500000;
+
+const child = spawn(process.argv[0], [sub, n]);
+
+let count = 0;
+
+child.stderr.setEncoding('utf8');
+child.stderr.on('data', common.mustNotCall());
+
+child.stdout.setEncoding('utf8');
+child.stdout.on('data', (data) => {
+  count += data.length;
+});
+
+child.on('close', common.mustCall((code, signal) => {
+  assert.strictEqual(code, 0);
+  assert.strictEqual(signal, null);
+  assert.strictEqual(n, count);
+}));
diff --git a/test/js/node/test/parallel/test-cli-eval-event.js b/test/js/node/test/parallel/test-cli-eval-event.js
new file mode 100644
index 0000000000..df356e50d3
--- /dev/null
+++ b/test/js/node/test/parallel/test-cli-eval-event.js
@@ -0,0 +1,15 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const spawn = require('child_process').spawn;
+
+const child = spawn(process.execPath, ['-e', `
+    const server = require('net').createServer().listen(0);
+    server.once('listening', server.close);
+`]);
+
+child.once('exit', common.mustCall(function(exitCode, signalCode) {
+  assert.strictEqual(exitCode, 0);
+  assert.strictEqual(signalCode, null);
+}));
diff --git a/test/js/node/test/parallel/test-client-request-destroy.js b/test/js/node/test/parallel/test-client-request-destroy.js
new file mode 100644
index 0000000000..2f3efcf812
--- /dev/null
+++ b/test/js/node/test/parallel/test-client-request-destroy.js
@@ -0,0 +1,13 @@
+'use strict';
+
+// Test that http.ClientRequest,prototype.destroy() returns `this`.
+require('../common');
+
+const assert = require('assert');
+const http = require('http');
+const clientRequest = new http.ClientRequest({ createConnection: () => {} });
+
+assert.strictEqual(clientRequest.destroyed, false);
+assert.strictEqual(clientRequest.destroy(), clientRequest);
+assert.strictEqual(clientRequest.destroyed, true);
+assert.strictEqual(clientRequest.destroy(), clientRequest);
diff --git a/test/js/node/test/parallel/test-cluster-advanced-serialization.js b/test/js/node/test/parallel/test-cluster-advanced-serialization.js
new file mode 100644
index 0000000000..ffca3a8f97
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-advanced-serialization.js
@@ -0,0 +1,22 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const cluster = require('cluster');
+
+if (cluster.isPrimary) {
+  cluster.settings.serialization = 'advanced';
+  const worker = cluster.fork();
+  const circular = {};
+  circular.circular = circular;
+
+  worker.on('online', common.mustCall(() => {
+    worker.send(circular);
+
+    worker.on('message', common.mustCall((msg) => {
+      assert.deepStrictEqual(msg, circular);
+      worker.kill();
+    }));
+  }));
+} else {
+  process.on('message', (msg) => process.send(msg));
+}
diff --git a/test/js/node/test/parallel/test-cluster-bind-privileged-port.js b/test/js/node/test/parallel/test-cluster-bind-privileged-port.js
new file mode 100644
index 0000000000..3ac36543a2
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-bind-privileged-port.js
@@ -0,0 +1,65 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const cluster = require('cluster');
+const net = require('net');
+const { readFileSync } = require('fs');
+
+if (common.isLinux) {
+  try {
+    const unprivilegedPortStart = parseInt(readFileSync('/proc/sys/net/ipv4/ip_unprivileged_port_start'));
+    if (unprivilegedPortStart <= 42) {
+      common.skip('Port 42 is unprivileged');
+    }
+  } catch {
+    // Do nothing, feature doesn't exist, minimum is 1024 so 42 is usable.
+    // Continue...
+  }
+}
+
+// Skip on macOS Mojave. https://github.com/nodejs/node/issues/21679
+if (common.isMacOS)
+  common.skip('macOS may allow ordinary processes to use any port');
+
+if (common.isIBMi)
+  common.skip('IBMi may allow ordinary processes to use any port');
+
+if (common.isWindows)
+  common.skip('not reliable on Windows.');
+
+if (process.getuid() === 0)
+  common.skip('Test is not supposed to be run as root.');
+
+if (cluster.isPrimary) {
+  cluster.fork().on('exit', common.mustCall((exitCode) => {
+    assert.strictEqual(exitCode, 0);
+  }));
+} else {
+  const s = net.createServer(common.mustNotCall());
+  s.listen(42, common.mustNotCall('listen should have failed'));
+  s.on('error', common.mustCall((err) => {
+    assert.strictEqual(err.code, 'EACCES');
+    process.disconnect();
+  }));
+}
diff --git a/test/js/node/test/parallel/test-cluster-call-and-destroy.js b/test/js/node/test/parallel/test-cluster-call-and-destroy.js
new file mode 100644
index 0000000000..2ff20cf03a
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-call-and-destroy.js
@@ -0,0 +1,15 @@
+'use strict';
+const common = require('../common');
+const cluster = require('cluster');
+const assert = require('assert');
+
+if (cluster.isPrimary) {
+  const worker = cluster.fork();
+  worker.on('disconnect', common.mustCall(() => {
+    assert.strictEqual(worker.isConnected(), false);
+    worker.destroy();
+  }));
+} else {
+  assert.strictEqual(cluster.worker.isConnected(), true);
+  cluster.worker.disconnect();
+}
diff --git a/test/js/node/test/parallel/test-cluster-child-index-dgram.js b/test/js/node/test/parallel/test-cluster-child-index-dgram.js
new file mode 100644
index 0000000000..0df7bc175b
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-child-index-dgram.js
@@ -0,0 +1,40 @@
+'use strict';
+const common = require('../common');
+const Countdown = require('../common/countdown');
+if (common.isWindows)
+  common.skip('dgram clustering is currently not supported on Windows.');
+
+const cluster = require('cluster');
+const dgram = require('dgram');
+
+// Test an edge case when using `cluster` and `dgram.Socket.bind()`
+// the port of `0`.
+const kPort = 0;
+
+function child() {
+  const kTime = 2;
+  const countdown = new Countdown(kTime * 2, () => {
+    process.exit(0);
+  });
+  for (let i = 0; i < kTime; i += 1) {
+    const socket = new dgram.Socket('udp4');
+    socket.bind(kPort, common.mustCall(() => {
+      // `process.nextTick()` or `socket2.close()` would throw
+      // ERR_SOCKET_DGRAM_NOT_RUNNING
+      process.nextTick(() => {
+        socket.close(countdown.dec());
+        const socket2 = new dgram.Socket('udp4');
+        socket2.bind(kPort, common.mustCall(() => {
+          process.nextTick(() => {
+            socket2.close(countdown.dec());
+          });
+        }));
+      });
+    }));
+  }
+}
+
+if (cluster.isMaster)
+  cluster.fork(__filename);
+else
+  child();
diff --git a/test/js/node/test/parallel/test-cluster-child-index-net.js b/test/js/node/test/parallel/test-cluster-child-index-net.js
new file mode 100644
index 0000000000..d8c3166d1b
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-child-index-net.js
@@ -0,0 +1,31 @@
+'use strict';
+const common = require('../common');
+const Countdown = require('../common/countdown');
+const cluster = require('cluster');
+const net = require('net');
+
+// Test an edge case when using `cluster` and `net.Server.listen()` to
+// the port of `0`.
+const kPort = 0;
+
+function child() {
+  const kTime = 2;
+  const countdown = new Countdown(kTime * 2, () => {
+    process.exit(0);
+  });
+  for (let i = 0; i < kTime; i += 1) {
+    const server = net.createServer();
+    server.listen(kPort, common.mustCall(() => {
+      server.close(countdown.dec());
+      const server2 = net.createServer();
+      server2.listen(kPort, common.mustCall(() => {
+        server2.close(countdown.dec());
+      }));
+    }));
+  }
+}
+
+if (cluster.isMaster)
+  cluster.fork(__filename);
+else
+  child();
diff --git a/test/js/node/test/parallel/test-cluster-concurrent-disconnect.js b/test/js/node/test/parallel/test-cluster-concurrent-disconnect.js
new file mode 100644
index 0000000000..b754fa221a
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-concurrent-disconnect.js
@@ -0,0 +1,52 @@
+'use strict';
+
+// Ref: https://github.com/nodejs/node/issues/32106
+
+const common = require('../common');
+
+const assert = require('assert');
+const cluster = require('cluster');
+const os = require('os');
+
+if (cluster.isPrimary) {
+  const workers = [];
+  const numCPUs = os.availableParallelism();
+  let waitOnline = numCPUs;
+  for (let i = 0; i < numCPUs; i++) {
+    const worker = cluster.fork();
+    workers[i] = worker;
+    worker.once('online', common.mustCall(() => {
+      if (--waitOnline === 0)
+        for (const worker of workers)
+          if (worker.isConnected())
+            worker.send(i % 2 ? 'disconnect' : 'destroy');
+    }));
+
+    // These errors can occur due to the nature of the test, we might be trying
+    // to send messages when the worker is disconnecting.
+    worker.on('error', (err) => {
+      assert.strictEqual(err.syscall, 'write');
+      if (common.isMacOS) {
+        assert(['EPIPE', 'ENOTCONN'].includes(err.code), err);
+      } else {
+        assert(['EPIPE', 'ECONNRESET'].includes(err.code), err);
+      }
+    });
+
+    worker.once('disconnect', common.mustCall(() => {
+      for (const worker of workers)
+        if (worker.isConnected())
+          worker.send('disconnect');
+    }));
+
+    worker.once('exit', common.mustCall((code, signal) => {
+      assert.strictEqual(code, 0);
+      assert.strictEqual(signal, null);
+    }));
+  }
+} else {
+  process.on('message', (msg) => {
+    if (cluster.worker.isConnected())
+      cluster.worker[msg]();
+  });
+}
diff --git a/test/js/node/test/parallel/test-cluster-cwd.js b/test/js/node/test/parallel/test-cluster-cwd.js
new file mode 100644
index 0000000000..c5d47e7301
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-cwd.js
@@ -0,0 +1,23 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const cluster = require('cluster');
+const tmpdir = require('../common/tmpdir');
+
+if (cluster.isPrimary) {
+  tmpdir.refresh();
+
+  assert.strictEqual(cluster.settings.cwd, undefined);
+  cluster.fork().on('message', common.mustCall((msg) => {
+    assert.strictEqual(msg, process.cwd());
+  }));
+
+  cluster.setupPrimary({ cwd: tmpdir.path });
+  assert.strictEqual(cluster.settings.cwd, tmpdir.path);
+  cluster.fork().on('message', common.mustCall((msg) => {
+    assert.strictEqual(msg, tmpdir.path);
+  }));
+} else {
+  process.send(process.cwd());
+  process.disconnect();
+}
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-disconnect-before-exit.js b/test/js/node/test/parallel/test-cluster-disconnect-before-exit.js
similarity index 87%
rename from test/js/node/cluster/upstream/parallel/test-cluster-disconnect-before-exit.js
rename to test/js/node/test/parallel/test-cluster-disconnect-before-exit.js
index bb5dda7aa7..f95f1384d5 100644
--- a/test/js/node/cluster/upstream/parallel/test-cluster-disconnect-before-exit.js
+++ b/test/js/node/test/parallel/test-cluster-disconnect-before-exit.js
@@ -19,12 +19,12 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-"use strict";
-const common = require("../common");
-const cluster = require("cluster");
+'use strict';
+const common = require('../common');
+const cluster = require('cluster');
 
 if (cluster.isPrimary) {
-  const worker = cluster.fork().on("online", common.mustCall(disconnect));
+  const worker = cluster.fork().on('online', common.mustCall(disconnect));
 
   function disconnect() {
     worker.disconnect();
@@ -32,6 +32,6 @@ if (cluster.isPrimary) {
     // Disconnect is supposed to disconnect all workers, but not workers that
     // are already disconnected, since calling disconnect() on an already
     // disconnected worker would error.
-    worker.on("disconnect", common.mustCall(cluster.disconnect));
+    worker.on('disconnect', common.mustCall(cluster.disconnect));
   }
 }
diff --git a/test/js/node/test/parallel/test-cluster-disconnect-exitedAfterDisconnect-race.js b/test/js/node/test/parallel/test-cluster-disconnect-exitedAfterDisconnect-race.js
new file mode 100644
index 0000000000..f1a8dea0a9
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-disconnect-exitedAfterDisconnect-race.js
@@ -0,0 +1,28 @@
+'use strict';
+
+const common = require('../common');
+
+// Test should fail in Node.js 5.4.1 and pass in later versions.
+
+const assert = require('assert');
+const cluster = require('cluster');
+
+if (cluster.isPrimary) {
+  cluster.on('exit', (worker, code) => {
+    assert.strictEqual(code, 0, `worker exited with code: ${code}, expected 0`);
+  });
+
+  return cluster.fork();
+}
+
+let eventFired = false;
+
+cluster.worker.disconnect();
+
+process.nextTick(common.mustCall(() => {
+  assert.ok(!eventFired, 'disconnect event should wait for ack');
+}));
+
+cluster.worker.on('disconnect', common.mustCall(() => {
+  eventFired = true;
+}));
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-disconnect-idle-worker.js b/test/js/node/test/parallel/test-cluster-disconnect-idle-worker.js
similarity index 84%
rename from test/js/node/cluster/upstream/parallel/test-cluster-disconnect-idle-worker.js
rename to test/js/node/test/parallel/test-cluster-disconnect-idle-worker.js
index f20bacdede..566f631312 100644
--- a/test/js/node/cluster/upstream/parallel/test-cluster-disconnect-idle-worker.js
+++ b/test/js/node/test/parallel/test-cluster-disconnect-idle-worker.js
@@ -19,18 +19,16 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-"use strict";
-const common = require("../common");
-const assert = require("assert");
-const cluster = require("cluster");
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const cluster = require('cluster');
 const fork = cluster.fork;
 
 if (cluster.isPrimary) {
   fork(); // It is intentionally called `fork` instead of
   fork(); // `cluster.fork` to test that `this` is not used
-  cluster.disconnect(
-    common.mustCall(() => {
-      assert.deepStrictEqual(Object.keys(cluster.workers), []);
-    }),
-  );
+  cluster.disconnect(common.mustCall(() => {
+    assert.deepStrictEqual(Object.keys(cluster.workers), []);
+  }));
 }
diff --git a/test/js/node/test/parallel/test-cluster-disconnect-leak.js b/test/js/node/test/parallel/test-cluster-disconnect-leak.js
new file mode 100644
index 0000000000..e2a417e5cd
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-disconnect-leak.js
@@ -0,0 +1,27 @@
+'use strict';
+
+// Test fails in Node v5.4.0 and passes in v5.4.1 and newer.
+
+const common = require('../common');
+const net = require('net');
+const cluster = require('cluster');
+
+cluster.schedulingPolicy = cluster.SCHED_NONE;
+
+if (cluster.isPrimary) {
+  const worker = cluster.fork();
+
+  // This is the important part of the test: Confirm that `disconnect` fires.
+  worker.on('disconnect', common.mustCall());
+
+  // These are just some extra stuff we're checking for good measure...
+  worker.on('exit', common.mustCall());
+  cluster.on('exit', common.mustCall());
+
+  cluster.disconnect();
+  return;
+}
+
+const server = net.createServer();
+
+server.listen(0);
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-disconnect-with-no-workers.js b/test/js/node/test/parallel/test-cluster-disconnect-with-no-workers.js
similarity index 88%
rename from test/js/node/cluster/upstream/parallel/test-cluster-disconnect-with-no-workers.js
rename to test/js/node/test/parallel/test-cluster-disconnect-with-no-workers.js
index 865dd25f3f..a34e04973c 100644
--- a/test/js/node/cluster/upstream/parallel/test-cluster-disconnect-with-no-workers.js
+++ b/test/js/node/test/parallel/test-cluster-disconnect-with-no-workers.js
@@ -19,18 +19,18 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-"use strict";
-require("../common");
-const assert = require("assert");
-const cluster = require("cluster");
+'use strict';
+require('../common');
+const assert = require('assert');
+const cluster = require('cluster');
 
 let disconnected;
 
-process.on("exit", function () {
+process.on('exit', function() {
   assert(disconnected);
 });
 
-cluster.disconnect(function () {
+cluster.disconnect(function() {
   disconnected = true;
 });
 
diff --git a/test/js/node/test/parallel/test-cluster-fork-env.js b/test/js/node/test/parallel/test-cluster-fork-env.js
new file mode 100644
index 0000000000..90b456b196
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-fork-env.js
@@ -0,0 +1,70 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+
+// This test checks that arguments provided to cluster.fork() will create
+// new environment variables and override existing environment variables
+// in the created worker process.
+
+const assert = require('assert');
+const cluster = require('cluster');
+
+if (cluster.isWorker) {
+  const result = cluster.worker.send({
+    prop: process.env.cluster_test_prop,
+    overwrite: process.env.cluster_test_overwrite
+  });
+
+  assert.strictEqual(result, true);
+} else if (cluster.isPrimary) {
+
+  const checks = {
+    using: false,
+    overwrite: false
+  };
+
+  // To check that the cluster extend on the process.env we will overwrite a
+  // property
+  process.env.cluster_test_overwrite = 'old';
+
+  // Fork worker
+  const worker = cluster.fork({
+    'cluster_test_prop': 'custom',
+    'cluster_test_overwrite': 'new'
+  });
+
+  // Checks worker env
+  worker.on('message', function(data) {
+    checks.using = (data.prop === 'custom');
+    checks.overwrite = (data.overwrite === 'new');
+    process.exit(0);
+  });
+
+  process.once('exit', function() {
+    assert.ok(checks.using, 'The worker did not receive the correct env.');
+    assert.ok(
+      checks.overwrite,
+      'The custom environment did not overwrite the existing environment.');
+  });
+
+}
diff --git a/test/js/node/test/parallel/test-cluster-fork-windowsHide.js b/test/js/node/test/parallel/test-cluster-fork-windowsHide.js
new file mode 100644
index 0000000000..2b90713ceb
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-fork-windowsHide.js
@@ -0,0 +1,74 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const child_process = require('child_process');
+const cluster = require('cluster');
+
+if (!process.argv[2]) {
+  // It seems Windows only allocate new console window for
+  // attaching processes spawned by detached processes. i.e.
+  // - If process D is spawned by process C with `detached: true`,
+  //   and process W is spawned by process D with `detached: false`,
+  //   W will get a new black console window popped up.
+  // - If D is spawned by C with `detached: false` or W is spawned
+  //   by D with `detached: true`, no console window will pop up for W.
+  //
+  // So, we have to spawn a detached process first to run the actual test.
+  const primary = child_process.spawn(
+    process.argv[0],
+    [process.argv[1], '--cluster'],
+    { detached: true, stdio: ['ignore', 'ignore', 'ignore', 'ipc'] });
+
+  const messageHandlers = {
+    workerOnline: common.mustCall(),
+    mainWindowHandle: common.mustCall((msg) => {
+      assert.match(msg.value, /0\s*/);
+    }),
+    workerExit: common.mustCall((msg) => {
+      assert.strictEqual(msg.code, 0);
+      assert.strictEqual(msg.signal, null);
+    })
+  };
+
+  primary.on('message', (msg) => {
+    const handler = messageHandlers[msg.type];
+    assert.ok(handler);
+    handler(msg);
+  });
+
+  primary.on('exit', common.mustCall((code, signal) => {
+    assert.strictEqual(code, 0);
+    assert.strictEqual(signal, null);
+  }));
+
+} else if (cluster.isPrimary) {
+  cluster.setupPrimary({
+    silent: true,
+    windowsHide: true
+  });
+
+  const worker = cluster.fork();
+  worker.on('exit', (code, signal) => {
+    process.send({ type: 'workerExit', code: code, signal: signal });
+  });
+
+  worker.on('online', (msg) => {
+    process.send({ type: 'workerOnline' });
+
+    let output = '0';
+    if (process.platform === 'win32') {
+      output = child_process.execSync(
+        'powershell -NoProfile -c ' +
+        `"(Get-Process -Id ${worker.process.pid}).MainWindowHandle"`,
+        { windowsHide: true, encoding: 'utf8' });
+    }
+
+    process.send({ type: 'mainWindowHandle', value: output });
+    worker.send('shutdown');
+  });
+
+} else {
+  cluster.worker.on('message', (msg) => {
+    cluster.worker.disconnect();
+  });
+}
diff --git a/test/js/node/test/parallel/test-cluster-http-pipe.js b/test/js/node/test/parallel/test-cluster-http-pipe.js
new file mode 100644
index 0000000000..bdd8fe8c4f
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-http-pipe.js
@@ -0,0 +1,59 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+
+const common = require('../common');
+if (common.isWindows) {
+  common.skip(
+    'It is not possible to send pipe handles over the IPC pipe on Windows');
+}
+
+const assert = require('assert');
+const cluster = require('cluster');
+const http = require('http');
+
+if (cluster.isPrimary) {
+  const tmpdir = require('../common/tmpdir');
+  tmpdir.refresh();
+  const worker = cluster.fork();
+  worker.on('message', common.mustCall((msg) => {
+    assert.strictEqual(msg, 'DONE');
+  }));
+  worker.on('exit', common.mustCall());
+  return;
+}
+
+http.createServer(common.mustCall((req, res) => {
+  assert.strictEqual(req.connection.remoteAddress, undefined);
+  assert.strictEqual(req.connection.localAddress, undefined);
+
+  res.writeHead(200);
+  res.end('OK');
+})).listen(common.PIPE, common.mustCall(() => {
+  http.get({ socketPath: common.PIPE, path: '/' }, common.mustCall((res) => {
+    res.resume();
+    res.on('end', common.mustSucceed(() => {
+      process.send('DONE');
+      process.exit();
+    }));
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-cluster-invalid-message.js b/test/js/node/test/parallel/test-cluster-invalid-message.js
new file mode 100644
index 0000000000..a42f5284db
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-invalid-message.js
@@ -0,0 +1,22 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const cluster = require('cluster');
+
+if (cluster.isPrimary) {
+  const worker = cluster.fork();
+
+  worker.on('exit', common.mustCall((code, signal) => {
+    assert.strictEqual(code, 0);
+    assert.strictEqual(signal, null);
+  }));
+
+  worker.on('online', () => {
+    worker.send({
+      cmd: 'NODE_CLUSTER',
+      ack: -1
+    }, () => {
+      worker.disconnect();
+    });
+  });
+}
diff --git a/test/js/node/test/parallel/test-cluster-ipc-throw.js b/test/js/node/test/parallel/test-cluster-ipc-throw.js
new file mode 100644
index 0000000000..c9640a23fc
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-ipc-throw.js
@@ -0,0 +1,26 @@
+'use strict';
+const common = require('../common');
+const http = require('http');
+const cluster = require('cluster');
+const assert = require('assert');
+
+cluster.schedulingPolicy = cluster.SCHED_RR;
+
+const server = http.createServer();
+
+if (cluster.isPrimary) {
+  server.listen({ port: 0 }, common.mustCall(() => {
+    const worker = cluster.fork({ PORT: server.address().port });
+    worker.on('exit', common.mustCall(() => {
+      server.close();
+    }));
+  }));
+} else {
+  assert(process.env.PORT);
+  process.on('uncaughtException', common.mustCall());
+  server.listen(process.env.PORT);
+  server.on('error', common.mustCall((e) => {
+    cluster.worker.disconnect();
+    throw e;
+  }));
+}
diff --git a/test/js/node/test/parallel/test-cluster-kill-disconnect.js b/test/js/node/test/parallel/test-cluster-kill-disconnect.js
new file mode 100644
index 0000000000..3e1f2f0841
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-kill-disconnect.js
@@ -0,0 +1,28 @@
+'use strict';
+const common = require('../common');
+
+// Check that cluster works perfectly for both `kill` and `disconnect` cases.
+// Also take into account that the `disconnect` event may be received after the
+// `exit` event.
+// https://github.com/nodejs/node/issues/3238
+
+const assert = require('assert');
+const cluster = require('cluster');
+
+if (cluster.isPrimary) {
+  function forkWorker(action) {
+    const worker = cluster.fork({ action });
+    worker.on('disconnect', common.mustCall(() => {
+      assert.strictEqual(worker.exitedAfterDisconnect, true);
+    }));
+
+    worker.on('exit', common.mustCall(() => {
+      assert.strictEqual(worker.exitedAfterDisconnect, true);
+    }));
+  }
+
+  forkWorker('disconnect');
+  forkWorker('kill');
+} else {
+  cluster.worker[process.env.action]();
+}
diff --git a/test/js/node/test/parallel/test-cluster-kill-infinite-loop.js b/test/js/node/test/parallel/test-cluster-kill-infinite-loop.js
new file mode 100644
index 0000000000..57781b6972
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-kill-infinite-loop.js
@@ -0,0 +1,21 @@
+'use strict';
+const common = require('../common');
+const cluster = require('cluster');
+const assert = require('assert');
+
+if (cluster.isPrimary) {
+  const worker = cluster.fork();
+
+  worker.on('online', common.mustCall(() => {
+    // Use worker.process.kill() instead of worker.kill() because the latter
+    // waits for a graceful disconnect, which will never happen.
+    worker.process.kill();
+  }));
+
+  worker.on('exit', common.mustCall((code, signal) => {
+    assert.strictEqual(code, null);
+    assert.strictEqual(signal, 'SIGTERM');
+  }));
+} else {
+  while (true);
+}
diff --git a/test/js/node/test/parallel/test-cluster-listening-port.js b/test/js/node/test/parallel/test-cluster-listening-port.js
new file mode 100644
index 0000000000..c09134e1de
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-listening-port.js
@@ -0,0 +1,19 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const cluster = require('cluster');
+const net = require('net');
+
+if (cluster.isPrimary) {
+  cluster.fork();
+  cluster.on('listening', common.mustCall(function(worker, address) {
+    const port = address.port;
+    // Ensure that the port is not 0 or null
+    assert(port);
+    // Ensure that the port is numerical
+    assert.strictEqual(typeof port, 'number');
+    worker.kill();
+  }));
+} else {
+  net.createServer(common.mustNotCall()).listen(0);
+}
diff --git a/test/js/node/test/parallel/test-cluster-net-listen.js b/test/js/node/test/parallel/test-cluster-net-listen.js
new file mode 100644
index 0000000000..9fa975aaaf
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-net-listen.js
@@ -0,0 +1,36 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const cluster = require('cluster');
+const net = require('net');
+
+if (cluster.isPrimary) {
+  // Ensure that the worker exits peacefully
+  cluster.fork().on('exit', common.mustCall(function(statusCode) {
+    assert.strictEqual(statusCode, 0);
+  }));
+} else {
+  // listen() without port should not trigger a libuv assert
+  net.createServer(common.mustNotCall()).listen(process.exit);
+}
diff --git a/test/js/node/test/parallel/test-cluster-primary-error.js b/test/js/node/test/parallel/test-cluster-primary-error.js
new file mode 100644
index 0000000000..f48682da4e
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-primary-error.js
@@ -0,0 +1,104 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const cluster = require('cluster');
+
+const totalWorkers = 2;
+
+// Cluster setup
+if (cluster.isWorker) {
+  const http = require('http');
+  http.Server(() => {}).listen(0, '127.0.0.1');
+} else if (process.argv[2] === 'cluster') {
+  // Send PID to testcase process
+  let forkNum = 0;
+  cluster.on('fork', common.mustCall(function forkEvent(worker) {
+    // Send PID
+    process.send({
+      cmd: 'worker',
+      workerPID: worker.process.pid
+    });
+
+    // Stop listening when done
+    if (++forkNum === totalWorkers) {
+      cluster.removeListener('fork', forkEvent);
+    }
+  }, totalWorkers));
+
+  // Throw accidental error when all workers are listening
+  let listeningNum = 0;
+  cluster.on('listening', common.mustCall(function listeningEvent() {
+    // When all workers are listening
+    if (++listeningNum === totalWorkers) {
+      // Stop listening
+      cluster.removeListener('listening', listeningEvent);
+
+      // Throw accidental error
+      process.nextTick(() => {
+        throw new Error('accidental error');
+      });
+    }
+  }, totalWorkers));
+
+  // Startup a basic cluster
+  cluster.fork();
+  cluster.fork();
+} else {
+  // This is the testcase
+
+  const fork = require('child_process').fork;
+
+  // List all workers
+  const workers = [];
+
+  // Spawn a cluster process
+  const primary = fork(process.argv[1], ['cluster'], { silent: true });
+
+  // Handle messages from the cluster
+  primary.on('message', common.mustCall((data) => {
+    // Add worker pid to list and progress tracker
+    if (data.cmd === 'worker') {
+      workers.push(data.workerPID);
+    }
+  }, totalWorkers));
+
+  // When cluster is dead
+  primary.on('exit', common.mustCall((code) => {
+    // Check that the cluster died accidentally (non-zero exit code)
+    assert.strictEqual(code, 1);
+
+    // XXX(addaleax): The fact that this uses raw PIDs makes the test inherently
+    // flaky – another process might end up being started right after the
+    // workers finished and receive the same PID.
+    const pollWorkers = () => {
+      // When primary is dead all workers should be dead too
+      if (workers.some((pid) => common.isAlive(pid))) {
+        setTimeout(pollWorkers, 50);
+      }
+    };
+
+    // Loop indefinitely until worker exit
+    pollWorkers();
+  }));
+}
diff --git a/test/js/node/test/parallel/test-cluster-primary-kill.js b/test/js/node/test/parallel/test-cluster-primary-kill.js
new file mode 100644
index 0000000000..08c7809603
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-primary-kill.js
@@ -0,0 +1,89 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const cluster = require('cluster');
+
+if (cluster.isWorker) {
+
+  // Keep the worker alive
+  const http = require('http');
+  http.Server().listen(0, '127.0.0.1');
+
+} else if (process.argv[2] === 'cluster') {
+
+  const worker = cluster.fork();
+
+  // send PID info to testcase process
+  process.send({
+    pid: worker.process.pid
+  });
+
+  // Terminate the cluster process
+  worker.once('listening', common.mustCall(() => {
+    setTimeout(() => {
+      process.exit(0);
+    }, 1000);
+  }));
+
+} else {
+
+  // This is the testcase
+  const fork = require('child_process').fork;
+
+  // Spawn a cluster process
+  const primary = fork(process.argv[1], ['cluster']);
+
+  // get pid info
+  let pid = null;
+  primary.once('message', (data) => {
+    pid = data.pid;
+  });
+
+  // When primary is dead
+  let alive = true;
+  primary.on('exit', common.mustCall((code) => {
+
+    // Make sure that the primary died on purpose
+    assert.strictEqual(code, 0);
+
+    // Check worker process status
+    const pollWorker = () => {
+      alive = common.isAlive(pid);
+      if (alive) {
+        setTimeout(pollWorker, 50);
+      }
+    };
+    // Loop indefinitely until worker exit.
+    pollWorker();
+  }));
+
+  process.once('exit', () => {
+    assert.strictEqual(typeof pid, 'number',
+                       `got ${pid} instead of a worker pid`);
+    assert.strictEqual(alive, false,
+                       `worker was alive after primary died (alive = ${alive})`
+    );
+  });
+
+}
diff --git a/test/js/node/test/parallel/test-cluster-process-disconnect.js b/test/js/node/test/parallel/test-cluster-process-disconnect.js
new file mode 100644
index 0000000000..378c4ef24d
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-process-disconnect.js
@@ -0,0 +1,26 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const cluster = require('cluster');
+
+if (cluster.isPrimary) {
+  const worker = cluster.fork();
+  worker.on('exit', common.mustCall((code, signal) => {
+    assert.strictEqual(
+      code,
+      0,
+      `Worker did not exit normally with code: ${code}`
+    );
+    assert.strictEqual(
+      signal,
+      null,
+      `Worker did not exit normally with signal: ${signal}`
+    );
+  }));
+} else {
+  const net = require('net');
+  const server = net.createServer();
+  server.listen(0, common.mustCall(() => {
+    process.disconnect();
+  }));
+}
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-rr-domain-listen.js b/test/js/node/test/parallel/test-cluster-rr-domain-listen.js
similarity index 85%
rename from test/js/node/cluster/upstream/parallel/test-cluster-rr-domain-listen.js
rename to test/js/node/test/parallel/test-cluster-rr-domain-listen.js
index c48ed0c55c..6043535d3b 100644
--- a/test/js/node/cluster/upstream/parallel/test-cluster-rr-domain-listen.js
+++ b/test/js/node/test/parallel/test-cluster-rr-domain-listen.js
@@ -19,10 +19,10 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-"use strict";
-require("../common");
-const cluster = require("cluster");
-const domain = require("domain");
+'use strict';
+require('../common');
+const cluster = require('cluster');
+const domain = require('domain');
 
 // RR is the default for v0.11.9+ so the following line is redundant:
 // cluster.schedulingPolicy = cluster.SCHED_RR;
@@ -31,16 +31,18 @@ if (cluster.isWorker) {
   const d = domain.create();
   d.run(() => {});
 
-  const http = require("http");
-  http.Server(() => {}).listen(0, "127.0.0.1");
+  const http = require('http');
+  http.Server(() => {}).listen(0, '127.0.0.1');
+
 } else if (cluster.isPrimary) {
+
   // Kill worker when listening
-  cluster.on("listening", function () {
+  cluster.on('listening', function() {
     worker.kill();
   });
 
   // Kill process when worker is killed
-  cluster.on("exit", function () {
+  cluster.on('exit', function() {
     process.exit(0);
   });
 
diff --git a/test/js/node/test/parallel/test-cluster-rr-handle-keep-loop-alive.js b/test/js/node/test/parallel/test-cluster-rr-handle-keep-loop-alive.js
new file mode 100644
index 0000000000..0b18408a19
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-rr-handle-keep-loop-alive.js
@@ -0,0 +1,23 @@
+'use strict';
+
+const common = require('../common');
+const cluster = require('cluster');
+const net = require('net');
+const assert = require('assert');
+
+cluster.schedulingPolicy = cluster.SCHED_RR;
+
+if (cluster.isPrimary) {
+  let exited = false;
+  const worker = cluster.fork();
+  worker.on('exit', () => {
+    exited = true;
+  });
+  setTimeout(() => {
+    assert.ok(!exited);
+    worker.kill();
+  }, 3000);
+} else {
+  const server = net.createServer(common.mustNotCall());
+  server.listen(0, common.mustCall(() => process.channel.unref()));
+}
diff --git a/test/js/node/test/parallel/test-cluster-rr-ref.js b/test/js/node/test/parallel/test-cluster-rr-ref.js
new file mode 100644
index 0000000000..92bb673ccd
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-rr-ref.js
@@ -0,0 +1,20 @@
+'use strict';
+
+const common = require('../common');
+const cluster = require('cluster');
+const net = require('net');
+
+if (cluster.isPrimary) {
+  cluster.fork().on('message', function(msg) {
+    if (msg === 'done') this.kill();
+  });
+} else {
+  const server = net.createServer(common.mustNotCall());
+  server.listen(0, function() {
+    server.unref();
+    server.ref();
+    server.close(function() {
+      process.send('done');
+    });
+  });
+}
diff --git a/test/js/node/test/parallel/test-cluster-send-deadlock.js b/test/js/node/test/parallel/test-cluster-send-deadlock.js
new file mode 100644
index 0000000000..8ddc40c252
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-send-deadlock.js
@@ -0,0 +1,73 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+// Testing mutual send of handles: from primary to worker, and from worker to
+// primary.
+
+require('../common');
+const assert = require('assert');
+const cluster = require('cluster');
+const net = require('net');
+
+if (cluster.isPrimary) {
+  const worker = cluster.fork();
+  worker.on('exit', (code, signal) => {
+    assert.strictEqual(code, 0, `Worker exited with an error code: ${code}`);
+    assert(!signal, `Worker exited by a signal: ${signal}`);
+    server.close();
+  });
+
+  const server = net.createServer((socket) => {
+    worker.send('handle', socket);
+  });
+
+  server.listen(0, () => {
+    worker.send({ message: 'listen', port: server.address().port });
+  });
+} else {
+  process.on('message', (msg, handle) => {
+    if (msg.message && msg.message === 'listen') {
+      assert(msg.port);
+      const client1 = net.connect({
+        host: 'localhost',
+        port: msg.port
+      }, () => {
+        const client2 = net.connect({
+          host: 'localhost',
+          port: msg.port
+        }, () => {
+          client1.on('close', onclose);
+          client2.on('close', onclose);
+          client1.end();
+          client2.end();
+        });
+      });
+      let waiting = 2;
+      const onclose = () => {
+        if (--waiting === 0)
+          cluster.worker.disconnect();
+      };
+    } else {
+      process.send('reply', handle);
+    }
+  });
+}
diff --git a/test/js/node/test/parallel/test-cluster-setup-primary-argv.js b/test/js/node/test/parallel/test-cluster-setup-primary-argv.js
new file mode 100644
index 0000000000..4c465bb72a
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-setup-primary-argv.js
@@ -0,0 +1,39 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const cluster = require('cluster');
+
+setTimeout(common.mustNotCall('setup not emitted'), 1000).unref();
+
+cluster.on('setup', common.mustCall(function() {
+  const clusterArgs = cluster.settings.args;
+  const realArgs = process.argv;
+  assert.strictEqual(clusterArgs[clusterArgs.length - 1],
+                     realArgs[realArgs.length - 1]);
+}));
+
+assert.notStrictEqual(process.argv[process.argv.length - 1], 'OMG,OMG');
+process.argv.push('OMG,OMG');
+process.argv.push('OMG,OMG');
+cluster.setupPrimary();
diff --git a/test/js/node/test/parallel/test-cluster-setup-primary-cumulative.js b/test/js/node/test/parallel/test-cluster-setup-primary-cumulative.js
new file mode 100644
index 0000000000..cf62291e9d
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-setup-primary-cumulative.js
@@ -0,0 +1,62 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const cluster = require('cluster');
+
+assert(cluster.isPrimary);
+
+// cluster.settings should not be initialized until needed
+assert.deepStrictEqual(cluster.settings, {});
+
+cluster.setupPrimary();
+assert.deepStrictEqual(cluster.settings, {
+  args: process.argv.slice(2),
+  exec: process.argv[1],
+  execArgv: process.execArgv,
+  silent: false,
+});
+console.log('ok sets defaults');
+
+cluster.setupPrimary({ exec: 'overridden' });
+assert.strictEqual(cluster.settings.exec, 'overridden');
+console.log('ok overrides defaults');
+
+cluster.setupPrimary({ args: ['foo', 'bar'] });
+assert.strictEqual(cluster.settings.exec, 'overridden');
+assert.deepStrictEqual(cluster.settings.args, ['foo', 'bar']);
+
+cluster.setupPrimary({ execArgv: ['baz', 'bang'] });
+assert.strictEqual(cluster.settings.exec, 'overridden');
+assert.deepStrictEqual(cluster.settings.args, ['foo', 'bar']);
+assert.deepStrictEqual(cluster.settings.execArgv, ['baz', 'bang']);
+console.log('ok preserves unchanged settings on repeated calls');
+
+cluster.setupPrimary();
+assert.deepStrictEqual(cluster.settings, {
+  args: ['foo', 'bar'],
+  exec: 'overridden',
+  execArgv: ['baz', 'bang'],
+  silent: false,
+});
+console.log('ok preserves current settings');
diff --git a/test/js/node/test/parallel/test-cluster-setup-primary-emit.js b/test/js/node/test/parallel/test-cluster-setup-primary-emit.js
new file mode 100644
index 0000000000..08414d5b21
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-setup-primary-emit.js
@@ -0,0 +1,47 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const cluster = require('cluster');
+
+assert(cluster.isPrimary);
+
+function emitAndCatch(next) {
+  cluster.once('setup', common.mustCall(function(settings) {
+    assert.strictEqual(settings.exec, 'new-exec');
+    setImmediate(next);
+  }));
+  cluster.setupPrimary({ exec: 'new-exec' });
+}
+
+function emitAndCatch2(next) {
+  cluster.once('setup', common.mustCall(function(settings) {
+    assert('exec' in settings);
+    setImmediate(next);
+  }));
+  cluster.setupPrimary();
+}
+
+emitAndCatch(common.mustCall(function() {
+  emitAndCatch2(common.mustCall());
+}));
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-setup-primary-multiple.js b/test/js/node/test/parallel/test-cluster-setup-primary-multiple.js
similarity index 83%
rename from test/js/node/cluster/upstream/parallel/test-cluster-setup-primary-multiple.js
rename to test/js/node/test/parallel/test-cluster-setup-primary-multiple.js
index 381642cf58..0fd8c0943c 100644
--- a/test/js/node/cluster/upstream/parallel/test-cluster-setup-primary-multiple.js
+++ b/test/js/node/test/parallel/test-cluster-setup-primary-multiple.js
@@ -19,11 +19,11 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-"use strict";
-require("../common");
-const assert = require("assert");
-const cluster = require("cluster");
-const debug = require("util").debuglog("test");
+'use strict';
+require('../common');
+const assert = require('assert');
+const cluster = require('cluster');
+const debug = require('util').debuglog('test');
 
 assert(cluster.isPrimary);
 
@@ -31,19 +31,23 @@ assert(cluster.isPrimary);
 // makes that unnecessary. This is to make the test less fragile if the
 // implementation ever changes such that cluster.settings is mutated instead of
 // replaced.
-const cheapClone = obj => JSON.parse(JSON.stringify(obj));
+const cheapClone = (obj) => JSON.parse(JSON.stringify(obj));
 
 const configs = [];
 
 // Capture changes
-cluster.on("setup", () => {
+cluster.on('setup', () => {
   debug(`"setup" emitted ${JSON.stringify(cluster.settings)}`);
   configs.push(cheapClone(cluster.settings));
 });
 
-const execs = ["node-next", "node-next-2", "node-next-3"];
+const execs = [
+  'node-next',
+  'node-next-2',
+  'node-next-3',
+];
 
-process.on("exit", () => {
+process.on('exit', () => {
   // Tests that "setup" is emitted for every call to setupPrimary
   assert.strictEqual(configs.length, execs.length);
 
@@ -61,9 +65,6 @@ execs.forEach((v, i) => {
 
 // Cluster emits 'setup' asynchronously, so we must stay alive long
 // enough for that to happen
-setTimeout(
-  () => {
-    debug("cluster setup complete");
-  },
-  (execs.length + 1) * 100,
-);
+setTimeout(() => {
+  debug('cluster setup complete');
+}, (execs.length + 1) * 100);
diff --git a/test/js/node/test/parallel/test-cluster-setup-primary.js b/test/js/node/test/parallel/test-cluster-setup-primary.js
new file mode 100644
index 0000000000..efba017fd7
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-setup-primary.js
@@ -0,0 +1,93 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const cluster = require('cluster');
+
+if (cluster.isWorker) {
+
+  // Just keep the worker alive
+  process.send(process.argv[2]);
+
+} else if (cluster.isPrimary) {
+
+  const checks = {
+    args: false,
+    setupEvent: false,
+    settingsObject: false
+  };
+
+  const totalWorkers = 2;
+  let settings;
+
+  // Setup primary
+  cluster.setupPrimary({
+    args: ['custom argument'],
+    silent: true
+  });
+
+  cluster.once('setup', function() {
+    checks.setupEvent = true;
+
+    settings = cluster.settings;
+    if (settings &&
+        settings.args && settings.args[0] === 'custom argument' &&
+        settings.silent === true &&
+        settings.exec === process.argv[1]) {
+      checks.settingsObject = true;
+    }
+  });
+
+  let correctInput = 0;
+
+  cluster.on('online', common.mustCall(function listener(worker) {
+
+    worker.once('message', function(data) {
+      correctInput += (data === 'custom argument' ? 1 : 0);
+      if (correctInput === totalWorkers) {
+        checks.args = true;
+      }
+      worker.kill();
+    });
+
+  }, totalWorkers));
+
+  // Start all workers
+  cluster.fork();
+  cluster.fork();
+
+  // Check all values
+  process.once('exit', function() {
+    const argsMsg = 'Arguments was not send for one or more worker. ' +
+                    `${correctInput} workers receive argument, ` +
+                    `but ${totalWorkers} were expected.`;
+    assert.ok(checks.args, argsMsg);
+
+    assert.ok(checks.setupEvent, 'The setup event was never emitted');
+
+    const settingObjectMsg = 'The settingsObject do not have correct ' +
+                             `properties : ${JSON.stringify(settings)}`;
+    assert.ok(checks.settingsObject, settingObjectMsg);
+  });
+
+}
diff --git a/test/js/node/test/parallel/test-cluster-shared-handle-bind-privileged-port.js b/test/js/node/test/parallel/test-cluster-shared-handle-bind-privileged-port.js
new file mode 100644
index 0000000000..8bdde0a332
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-shared-handle-bind-privileged-port.js
@@ -0,0 +1,55 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+
+// Skip on macOS Mojave. https://github.com/nodejs/node/issues/21679
+if (common.isMacOS)
+  common.skip('macOS may allow ordinary processes to use any port');
+
+if (common.isIBMi)
+  common.skip('IBMi may allow ordinary processes to use any port');
+
+if (common.isWindows)
+  common.skip('not reliable on Windows');
+
+if (process.getuid() === 0)
+  common.skip('as this test should not be run as `root`');
+
+const assert = require('assert');
+const cluster = require('cluster');
+const net = require('net');
+
+if (cluster.isPrimary) {
+  // Primary opens and binds the socket and shares it with the worker.
+  cluster.schedulingPolicy = cluster.SCHED_NONE;
+  cluster.fork().on('exit', common.mustCall(function(exitCode) {
+    assert.strictEqual(exitCode, 0);
+  }));
+} else {
+  const s = net.createServer(common.mustNotCall());
+  s.listen(42, common.mustNotCall('listen should have failed'));
+  s.on('error', common.mustCall(function(err) {
+    assert.strictEqual(err.code, 'EACCES');
+    process.disconnect();
+  }));
+}
diff --git a/test/js/node/test/parallel/test-cluster-uncaught-exception.js b/test/js/node/test/parallel/test-cluster-uncaught-exception.js
new file mode 100644
index 0000000000..80d1ec6118
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-uncaught-exception.js
@@ -0,0 +1,49 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+// Installing a custom uncaughtException handler should override the default
+// one that the cluster module installs.
+// https://github.com/joyent/node/issues/2556
+
+const common = require('../common');
+const assert = require('assert');
+const cluster = require('cluster');
+const fork = require('child_process').fork;
+
+const MAGIC_EXIT_CODE = 42;
+
+const isTestRunner = process.argv[2] !== 'child';
+
+if (isTestRunner) {
+  const primary = fork(__filename, ['child']);
+  primary.on('exit', common.mustCall((code) => {
+    assert.strictEqual(code, MAGIC_EXIT_CODE);
+  }));
+} else if (cluster.isPrimary) {
+  process.on('uncaughtException', common.mustCall(() => {
+    process.nextTick(() => process.exit(MAGIC_EXIT_CODE));
+  }));
+  cluster.fork();
+  throw new Error('kill primary');
+} else { // worker
+  process.exit();
+}
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-worker-constructor.js b/test/js/node/test/parallel/test-cluster-worker-constructor.js
similarity index 88%
rename from test/js/node/cluster/upstream/parallel/test-cluster-worker-constructor.js
rename to test/js/node/test/parallel/test-cluster-worker-constructor.js
index 904eb2e2ab..c116e622e5 100644
--- a/test/js/node/cluster/upstream/parallel/test-cluster-worker-constructor.js
+++ b/test/js/node/test/parallel/test-cluster-worker-constructor.js
@@ -19,28 +19,28 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-"use strict";
+'use strict';
 // test-cluster-worker-constructor.js
 // validates correct behavior of the cluster.Worker constructor
 
-require("../common");
-const assert = require("assert");
-const cluster = require("cluster");
+require('../common');
+const assert = require('assert');
+const cluster = require('cluster');
 let worker;
 
 worker = new cluster.Worker();
 assert.strictEqual(worker.exitedAfterDisconnect, undefined);
-assert.strictEqual(worker.state, "none");
+assert.strictEqual(worker.state, 'none');
 assert.strictEqual(worker.id, 0);
 assert.strictEqual(worker.process, undefined);
 
 worker = new cluster.Worker({
   id: 3,
-  state: "online",
-  process: process,
+  state: 'online',
+  process: process
 });
 assert.strictEqual(worker.exitedAfterDisconnect, undefined);
-assert.strictEqual(worker.state, "online");
+assert.strictEqual(worker.state, 'online');
 assert.strictEqual(worker.id, 3);
 assert.strictEqual(worker.process, process);
 
diff --git a/test/js/node/test/parallel/test-cluster-worker-death.js b/test/js/node/test/parallel/test-cluster-worker-death.js
new file mode 100644
index 0000000000..700cae7c52
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-worker-death.js
@@ -0,0 +1,38 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const cluster = require('cluster');
+
+if (!cluster.isPrimary) {
+  process.exit(42);
+} else {
+  const worker = cluster.fork();
+  worker.on('exit', common.mustCall(function(exitCode, signalCode) {
+    assert.strictEqual(exitCode, 42);
+    assert.strictEqual(signalCode, null);
+  }));
+  cluster.on('exit', common.mustCall(function(worker_) {
+    assert.strictEqual(worker_, worker);
+  }));
+}
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-worker-destroy.js b/test/js/node/test/parallel/test-cluster-worker-destroy.js
similarity index 85%
rename from test/js/node/cluster/upstream/parallel/test-cluster-worker-destroy.js
rename to test/js/node/test/parallel/test-cluster-worker-destroy.js
index ebffb4fb04..91eee51a5a 100644
--- a/test/js/node/cluster/upstream/parallel/test-cluster-worker-destroy.js
+++ b/test/js/node/test/parallel/test-cluster-worker-destroy.js
@@ -19,7 +19,7 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-"use strict";
+'use strict';
 
 // The goal of this test is to cover the Workers' implementation of
 // Worker.prototype.destroy. Worker.prototype.destroy is called within
@@ -27,22 +27,22 @@
 // primary, and another time when it's not connected to it, so that we cover
 // both code paths.
 
-const common = require("../common");
-const assert = require("assert");
-const cluster = require("cluster");
+const common = require('../common');
+const assert = require('assert');
+const cluster = require('cluster');
 let worker1, worker2;
 
 if (cluster.isPrimary) {
   worker1 = cluster.fork();
   worker2 = cluster.fork();
 
-  [worker1, worker2].forEach(function (worker) {
-    worker.on("disconnect", common.mustCall());
-    worker.on("exit", common.mustCall());
+  [worker1, worker2].forEach(function(worker) {
+    worker.on('disconnect', common.mustCall());
+    worker.on('exit', common.mustCall());
   });
 } else if (cluster.worker.id === 1) {
   // Call destroy when worker is disconnected
-  cluster.worker.process.on("disconnect", function () {
+  cluster.worker.process.on('disconnect', function() {
     cluster.worker.destroy();
   });
 
diff --git a/test/js/node/test/parallel/test-cluster-worker-disconnect-on-error.js b/test/js/node/test/parallel/test-cluster-worker-disconnect-on-error.js
new file mode 100644
index 0000000000..122d31a62e
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-worker-disconnect-on-error.js
@@ -0,0 +1,32 @@
+'use strict';
+const common = require('../common');
+const http = require('http');
+const cluster = require('cluster');
+const assert = require('assert');
+
+cluster.schedulingPolicy = cluster.SCHED_NONE;
+
+const server = http.createServer();
+if (cluster.isPrimary) {
+  let worker;
+
+  server.listen(0, common.mustSucceed(() => {
+    assert(worker);
+
+    worker.send({ port: server.address().port });
+  }));
+
+  worker = cluster.fork();
+  worker.on('exit', common.mustCall(() => {
+    server.close();
+  }));
+} else {
+  process.on('message', common.mustCall((msg) => {
+    assert(msg.port);
+
+    server.listen(msg.port);
+    server.on('error', common.mustCall((e) => {
+      cluster.worker.disconnect();
+    }));
+  }));
+}
diff --git a/test/js/node/test/parallel/test-cluster-worker-disconnect.js b/test/js/node/test/parallel/test-cluster-worker-disconnect.js
new file mode 100644
index 0000000000..b28c0fbd8f
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-worker-disconnect.js
@@ -0,0 +1,106 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const cluster = require('cluster');
+
+if (cluster.isWorker) {
+  const http = require('http');
+  http.Server(() => {
+
+  }).listen(0, '127.0.0.1');
+
+  cluster.worker.on('disconnect', common.mustCall(() => {
+    process.exit(42);
+  }));
+
+} else if (cluster.isPrimary) {
+
+  const checks = {
+    cluster: {
+      emitDisconnect: false,
+      emitExit: false,
+      callback: false
+    },
+    worker: {
+      emitDisconnect: false,
+      emitDisconnectInsideWorker: false,
+      emitExit: false,
+      state: false,
+      voluntaryMode: false,
+      died: false
+    }
+  };
+
+  // start worker
+  const worker = cluster.fork();
+
+  // Disconnect worker when it is ready
+  worker.once('listening', common.mustCall(() => {
+    const w = worker.disconnect();
+    assert.strictEqual(worker, w, `${worker.id} did not return a reference`);
+  }));
+
+  // Check cluster events
+  cluster.once('disconnect', common.mustCall(() => {
+    checks.cluster.emitDisconnect = true;
+  }));
+  cluster.once('exit', common.mustCall(() => {
+    checks.cluster.emitExit = true;
+  }));
+
+  // Check worker events and properties
+  worker.once('disconnect', common.mustCall(() => {
+    checks.worker.emitDisconnect = true;
+    checks.worker.voluntaryMode = worker.exitedAfterDisconnect;
+    checks.worker.state = worker.state;
+  }));
+
+  // Check that the worker died
+  worker.once('exit', common.mustCall((code) => {
+    checks.worker.emitExit = true;
+    checks.worker.died = !common.isAlive(worker.process.pid);
+    checks.worker.emitDisconnectInsideWorker = code === 42;
+  }));
+
+  process.once('exit', () => {
+
+    const w = checks.worker;
+    const c = checks.cluster;
+
+    // events
+    assert.ok(w.emitDisconnect, 'Disconnect event did not emit');
+    assert.ok(w.emitDisconnectInsideWorker,
+              'Disconnect event did not emit inside worker');
+    assert.ok(c.emitDisconnect, 'Disconnect event did not emit');
+    assert.ok(w.emitExit, 'Exit event did not emit');
+    assert.ok(c.emitExit, 'Exit event did not emit');
+
+    // flags
+    assert.strictEqual(w.state, 'disconnected');
+    assert.strictEqual(w.voluntaryMode, true);
+
+    // is process alive
+    assert.ok(w.died, 'The worker did not die');
+  });
+}
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-worker-events.js b/test/js/node/test/parallel/test-cluster-worker-events.js
similarity index 82%
rename from test/js/node/cluster/upstream/parallel/test-cluster-worker-events.js
rename to test/js/node/test/parallel/test-cluster-worker-events.js
index aaf355a581..6c044ace8d 100644
--- a/test/js/node/cluster/upstream/parallel/test-cluster-worker-events.js
+++ b/test/js/node/test/parallel/test-cluster-worker-events.js
@@ -19,22 +19,23 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-"use strict";
-require("../common");
-const assert = require("assert");
-const cluster = require("cluster");
+'use strict';
+require('../common');
+const assert = require('assert');
+const cluster = require('cluster');
 
 const OK = 2;
 
 if (cluster.isPrimary) {
+
   const worker = cluster.fork();
 
-  worker.on("exit", code => {
+  worker.on('exit', (code) => {
     assert.strictEqual(code, OK);
     process.exit(0);
   });
 
-  const result = worker.send("SOME MESSAGE");
+  const result = worker.send('SOME MESSAGE');
   assert.strictEqual(result, true);
 
   return;
@@ -50,28 +51,28 @@ let sawWorker;
 
 const messages = [];
 
-const check = m => {
+const check = (m) => {
   messages.push(m);
 
   if (messages.length < 2) return;
 
   assert.deepStrictEqual(messages[0], messages[1]);
 
-  cluster.worker.once("error", e => {
-    assert.strictEqual(e, "HI");
+  cluster.worker.once('error', (e) => {
+    assert.strictEqual(e, 'HI');
     process.exit(OK);
   });
 
-  process.emit("error", "HI");
+  process.emit('error', 'HI');
 };
 
-process.on("message", m => {
+process.on('message', (m) => {
   assert(!sawProcess);
   sawProcess = true;
   check(m);
 });
 
-cluster.worker.on("message", m => {
+cluster.worker.on('message', (m) => {
   assert(!sawWorker);
   sawWorker = true;
   check(m);
diff --git a/test/js/node/test/parallel/test-cluster-worker-exit.js b/test/js/node/test/parallel/test-cluster-worker-exit.js
new file mode 100644
index 0000000000..09e2a83701
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-worker-exit.js
@@ -0,0 +1,130 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+// test-cluster-worker-exit.js
+// verifies that, when a child process exits (by calling `process.exit(code)`)
+// - the primary receives the proper events in the proper order, no duplicates
+// - the exitCode and signalCode are correct in the 'exit' event
+// - the worker.exitedAfterDisconnect flag, and worker.state are correct
+// - the worker process actually goes away
+
+const common = require('../common');
+const assert = require('assert');
+const cluster = require('cluster');
+
+const EXIT_CODE = 42;
+
+if (cluster.isWorker) {
+  const http = require('http');
+  const server = http.Server(() => { });
+
+  server.once('listening', common.mustCall(() => {
+    process.exit(EXIT_CODE);
+  }));
+  server.listen(0, '127.0.0.1');
+
+} else if (cluster.isPrimary) {
+
+  const expected_results = {
+    cluster_emitDisconnect: [1, "the cluster did not emit 'disconnect'"],
+    cluster_emitExit: [1, "the cluster did not emit 'exit'"],
+    cluster_exitCode: [EXIT_CODE, 'the cluster exited w/ incorrect exitCode'],
+    cluster_signalCode: [null, 'the cluster exited w/ incorrect signalCode'],
+    worker_emitDisconnect: [1, "the worker did not emit 'disconnect'"],
+    worker_emitExit: [1, "the worker did not emit 'exit'"],
+    worker_state: ['disconnected', 'the worker state is incorrect'],
+    worker_exitedAfterDisconnect: [
+      false, 'the .exitedAfterDisconnect flag is incorrect',
+    ],
+    worker_died: [true, 'the worker is still running'],
+    worker_exitCode: [EXIT_CODE, 'the worker exited w/ incorrect exitCode'],
+    worker_signalCode: [null, 'the worker exited w/ incorrect signalCode']
+  };
+  const results = {
+    cluster_emitDisconnect: 0,
+    cluster_emitExit: 0,
+    worker_emitDisconnect: 0,
+    worker_emitExit: 0
+  };
+
+
+  // start worker
+  const worker = cluster.fork();
+
+  // Check cluster events
+  cluster.on('disconnect', common.mustCall(() => {
+    results.cluster_emitDisconnect += 1;
+  }));
+  cluster.on('exit', common.mustCall((worker) => {
+    results.cluster_exitCode = worker.process.exitCode;
+    results.cluster_signalCode = worker.process.signalCode;
+    results.cluster_emitExit += 1;
+  }));
+
+  // Check worker events and properties
+  worker.on('disconnect', common.mustCall(() => {
+    results.worker_emitDisconnect += 1;
+    results.worker_exitedAfterDisconnect = worker.exitedAfterDisconnect;
+    results.worker_state = worker.state;
+    if (results.worker_emitExit > 0) {
+      process.nextTick(() => finish_test());
+    }
+  }));
+
+  // Check that the worker died
+  worker.once('exit', common.mustCall((exitCode, signalCode) => {
+    results.worker_exitCode = exitCode;
+    results.worker_signalCode = signalCode;
+    results.worker_emitExit += 1;
+    results.worker_died = !common.isAlive(worker.process.pid);
+    if (results.worker_emitDisconnect > 0) {
+      process.nextTick(() => finish_test());
+    }
+  }));
+
+  const finish_test = () => {
+    try {
+      checkResults(expected_results, results);
+    } catch (exc) {
+      if (exc.name !== 'AssertionError') {
+        console.trace(exc);
+      }
+
+      process.exit(1);
+      return;
+    }
+    process.exit(0);
+  };
+}
+
+// Some helper functions ...
+
+function checkResults(expected_results, results) {
+  for (const k in expected_results) {
+    const actual = results[k];
+    const expected = expected_results[k];
+
+    assert.strictEqual(
+      actual, expected && expected.length ? expected[0] : expected,
+      `${expected[1] || ''} [expected: ${expected[0]} / actual: ${actual}]`);
+  }
+}
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-worker-forced-exit.js b/test/js/node/test/parallel/test-cluster-worker-forced-exit.js
similarity index 76%
rename from test/js/node/cluster/upstream/parallel/test-cluster-worker-forced-exit.js
rename to test/js/node/test/parallel/test-cluster-worker-forced-exit.js
index 901868973d..6d2bf4f537 100644
--- a/test/js/node/cluster/upstream/parallel/test-cluster-worker-forced-exit.js
+++ b/test/js/node/test/parallel/test-cluster-worker-forced-exit.js
@@ -19,10 +19,10 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-"use strict";
-const common = require("../common");
-const assert = require("assert");
-const cluster = require("cluster");
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const cluster = require('cluster');
 
 const SENTINEL = 42;
 
@@ -37,7 +37,7 @@ const SENTINEL = 42;
 // 3 disconnect worker with child_process's disconnect, confirm
 //   no sentinel value
 if (cluster.isWorker) {
-  process.on("disconnect", msg => {
+  process.on('disconnect', (msg) => {
     setTimeout(() => process.exit(SENTINEL), 10);
   });
   return;
@@ -49,27 +49,15 @@ checkForced();
 function checkUnforced() {
   const worker = cluster.fork();
   worker
-    .on(
-      "online",
-      common.mustCall(() => worker.disconnect()),
-    )
-    .on(
-      "exit",
-      common.mustCall(status => {
-        assert.strictEqual(status, SENTINEL);
-      }),
-    );
+    .on('online', common.mustCall(() => worker.disconnect()))
+    .on('exit', common.mustCall((status) => {
+      assert.strictEqual(status, SENTINEL);
+    }));
 }
 
 function checkForced() {
   const worker = cluster.fork();
   worker
-    .on(
-      "online",
-      common.mustCall(() => worker.process.disconnect()),
-    )
-    .on(
-      "exit",
-      common.mustCall(status => assert.strictEqual(status, 0)),
-    );
+    .on('online', common.mustCall(() => worker.process.disconnect()))
+    .on('exit', common.mustCall((status) => assert.strictEqual(status, 0)));
 }
diff --git a/test/js/node/test/parallel/test-cluster-worker-handle-close.js b/test/js/node/test/parallel/test-cluster-worker-handle-close.js
new file mode 100644
index 0000000000..47a80ef1cd
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-worker-handle-close.js
@@ -0,0 +1,27 @@
+'use strict';
+const common = require('../common');
+const cluster = require('cluster');
+const net = require('net');
+
+if (cluster.isPrimary) {
+  cluster.schedulingPolicy = cluster.SCHED_RR;
+  cluster.fork();
+} else {
+  const server = net.createServer(common.mustNotCall());
+  server.listen(0, common.mustCall(() => {
+    net.connect(server.address().port);
+  }));
+  process.prependListener('internalMessage', common.mustCallAtLeast((message, handle) => {
+    if (message.act !== 'newconn') {
+      return;
+    }
+    // Make the worker drops the connection, see `rr` and `onconnection` in child.js
+    server.close();
+    const close = handle.close;
+    handle.close = common.mustCall(() => {
+      close.call(handle, common.mustCall(() => {
+        process.exit();
+      }));
+    });
+  }));
+}
diff --git a/test/js/node/cluster/upstream/parallel/test-cluster-worker-init.js b/test/js/node/test/parallel/test-cluster-worker-init.js
similarity index 78%
rename from test/js/node/cluster/upstream/parallel/test-cluster-worker-init.js
rename to test/js/node/test/parallel/test-cluster-worker-init.js
index f2dafdf66d..2acc55c148 100644
--- a/test/js/node/cluster/upstream/parallel/test-cluster-worker-init.js
+++ b/test/js/node/test/parallel/test-cluster-worker-init.js
@@ -19,34 +19,31 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-"use strict";
+'use strict';
 // test-cluster-worker-init.js
 // verifies that, when a child process is forked, the cluster.worker
 // object can receive messages as expected
 
-const common = require("../common");
-const assert = require("assert");
-const cluster = require("cluster");
-const msg = "foo";
+const common = require('../common');
+const assert = require('assert');
+const cluster = require('cluster');
+const msg = 'foo';
 
 if (cluster.isPrimary) {
   const worker = cluster.fork();
 
-  worker.on(
-    "message",
-    common.mustCall(message => {
-      assert.strictEqual(message, true);
-      const w = worker.disconnect();
-      assert.strictEqual(worker, w);
-    }),
-  );
+  worker.on('message', common.mustCall((message) => {
+    assert.strictEqual(message, true);
+    const w = worker.disconnect();
+    assert.strictEqual(worker, w);
+  }));
 
-  worker.on("online", () => {
+  worker.on('online', () => {
     worker.send(msg);
   });
 } else {
   // https://github.com/nodejs/node-v0.x-archive/issues/7998
-  cluster.worker.on("message", message => {
+  cluster.worker.on('message', (message) => {
     process.send(message === msg);
   });
 }
diff --git a/test/js/node/test/parallel/test-cluster-worker-isdead.js b/test/js/node/test/parallel/test-cluster-worker-isdead.js
new file mode 100644
index 0000000000..6f2aa3c52e
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-worker-isdead.js
@@ -0,0 +1,32 @@
+'use strict';
+require('../common');
+const cluster = require('cluster');
+const assert = require('assert');
+
+if (cluster.isPrimary) {
+  const worker = cluster.fork();
+  let workerDead = worker.isDead();
+  assert.ok(!workerDead,
+            `isDead() returned ${workerDead}. isDead() should return ` +
+            'false right after the worker has been created.');
+
+  worker.on('exit', function() {
+    workerDead = worker.isDead();
+    assert.ok(workerDead,
+              `isDead() returned ${workerDead}. After an event has been ` +
+              'emitted, isDead should return true');
+  });
+
+  worker.on('message', function(msg) {
+    if (msg === 'readyToDie') {
+      worker.kill();
+    }
+  });
+
+} else if (cluster.isWorker) {
+  const workerDead = cluster.worker.isDead();
+  assert.ok(!workerDead,
+            `isDead() returned ${workerDead}. isDead() should return ` +
+            'false when called from within a worker');
+  process.send('readyToDie');
+}
diff --git a/test/js/node/test/parallel/test-cluster-worker-kill-signal.js b/test/js/node/test/parallel/test-cluster-worker-kill-signal.js
new file mode 100644
index 0000000000..53e3739eba
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-worker-kill-signal.js
@@ -0,0 +1,49 @@
+'use strict';
+// test-cluster-worker-kill-signal.js
+// verifies that when we're killing a worker using Worker.prototype.kill
+// and the worker's process was killed with the given signal (SIGKILL)
+
+
+const common = require('../common');
+const assert = require('assert');
+const cluster = require('cluster');
+
+if (cluster.isWorker) {
+  // Make the worker run something
+  const http = require('http');
+  const server = http.Server(() => { });
+
+  server.once('listening', common.mustCall());
+  server.listen(0, '127.0.0.1');
+
+} else if (cluster.isMaster) {
+  const KILL_SIGNAL = 'SIGKILL';
+
+  // Start worker
+  const worker = cluster.fork();
+
+  // When the worker is up and running, kill it
+  worker.once('listening', common.mustCall(() => {
+    worker.kill(KILL_SIGNAL);
+  }));
+
+  // Check worker events and properties
+  worker.on('disconnect', common.mustCall(() => {
+    assert.strictEqual(worker.exitedAfterDisconnect, false);
+    assert.strictEqual(worker.state, 'disconnected');
+  }, 1));
+
+  // Check that the worker died
+  worker.once('exit', common.mustCall((exitCode, signalCode) => {
+    const isWorkerProcessStillAlive = common.isAlive(worker.process.pid);
+    const numOfRunningWorkers = Object.keys(cluster.workers).length;
+
+    assert.strictEqual(exitCode, null);
+    assert.strictEqual(signalCode, KILL_SIGNAL);
+    assert.strictEqual(isWorkerProcessStillAlive, false);
+    assert.strictEqual(numOfRunningWorkers, 0);
+  }, 1));
+
+  // Check if the cluster was killed as well
+  cluster.on('exit', common.mustCall(1));
+}
diff --git a/test/js/node/test/parallel/test-cluster-worker-kill.js b/test/js/node/test/parallel/test-cluster-worker-kill.js
new file mode 100644
index 0000000000..7307a93e1b
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-worker-kill.js
@@ -0,0 +1,117 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+// test-cluster-worker-kill.js
+// verifies that, when a child process is killed (we use SIGKILL)
+// - the primary receives the proper events in the proper order, no duplicates
+// - the exitCode and signalCode are correct in the 'exit' event
+// - the worker.exitedAfterDisconnect flag, and worker.state are correct
+// - the worker process actually goes away
+
+const common = require('../common');
+const assert = require('assert');
+const cluster = require('cluster');
+
+if (cluster.isWorker) {
+  const http = require('http');
+  const server = http.Server(() => { });
+
+  server.once('listening', common.mustCall());
+  server.listen(0, '127.0.0.1');
+
+} else if (cluster.isPrimary) {
+
+  const KILL_SIGNAL = 'SIGKILL';
+  const expected_results = {
+    cluster_emitDisconnect: [1, "the cluster did not emit 'disconnect'"],
+    cluster_emitExit: [1, "the cluster did not emit 'exit'"],
+    cluster_exitCode: [null, 'the cluster exited w/ incorrect exitCode'],
+    cluster_signalCode: [KILL_SIGNAL,
+                         'the cluster exited w/ incorrect signalCode'],
+    worker_emitDisconnect: [1, "the worker did not emit 'disconnect'"],
+    worker_emitExit: [1, "the worker did not emit 'exit'"],
+    worker_state: ['disconnected', 'the worker state is incorrect'],
+    worker_exitedAfter: [false, 'the .exitedAfterDisconnect flag is incorrect'],
+    worker_died: [true, 'the worker is still running'],
+    worker_exitCode: [null, 'the worker exited w/ incorrect exitCode'],
+    worker_signalCode: [KILL_SIGNAL,
+                        'the worker exited w/ incorrect signalCode']
+  };
+  const results = {
+    cluster_emitDisconnect: 0,
+    cluster_emitExit: 0,
+    worker_emitDisconnect: 0,
+    worker_emitExit: 0
+  };
+
+
+  // start worker
+  const worker = cluster.fork();
+
+  // When the worker is up and running, kill it
+  worker.once('listening', common.mustCall(() => {
+    worker.process.kill(KILL_SIGNAL);
+  }));
+
+
+  // Check cluster events
+  cluster.on('disconnect', common.mustCall(() => {
+    results.cluster_emitDisconnect += 1;
+  }));
+  cluster.on('exit', common.mustCall((worker) => {
+    results.cluster_exitCode = worker.process.exitCode;
+    results.cluster_signalCode = worker.process.signalCode;
+    results.cluster_emitExit += 1;
+  }));
+
+  // Check worker events and properties
+  worker.on('disconnect', common.mustCall(() => {
+    results.worker_emitDisconnect += 1;
+    results.worker_exitedAfter = worker.exitedAfterDisconnect;
+    results.worker_state = worker.state;
+  }));
+
+  // Check that the worker died
+  worker.once('exit', common.mustCall((exitCode, signalCode) => {
+    results.worker_exitCode = exitCode;
+    results.worker_signalCode = signalCode;
+    results.worker_emitExit += 1;
+    results.worker_died = !common.isAlive(worker.process.pid);
+  }));
+
+  process.on('exit', () => {
+    checkResults(expected_results, results);
+  });
+}
+
+// Some helper functions ...
+
+function checkResults(expected_results, results) {
+  for (const k in expected_results) {
+    const actual = results[k];
+    const expected = expected_results[k];
+
+    assert.strictEqual(
+      actual, expected && expected.length ? expected[0] : expected,
+      `${expected[1] || ''} [expected: ${expected[0]} / actual: ${actual}]`);
+  }
+}
diff --git a/test/js/node/test/parallel/test-cluster-worker-no-exit.js b/test/js/node/test/parallel/test-cluster-worker-no-exit.js
new file mode 100644
index 0000000000..e4694a4a3a
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-worker-no-exit.js
@@ -0,0 +1,74 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const cluster = require('cluster');
+const net = require('net');
+
+let destroyed;
+let success;
+let worker;
+let server;
+
+// Workers do not exit on disconnect, they exit under normal node rules: when
+// they have nothing keeping their loop alive, like an active connection
+//
+// test this by:
+//
+// 1 creating a server, so worker can make a connection to something
+// 2 disconnecting worker
+// 3 wait to confirm it did not exit
+// 4 destroy connection
+// 5 confirm it does exit
+if (cluster.isPrimary) {
+  server = net.createServer(function(conn) {
+    server.close();
+    worker.disconnect();
+    worker.once('disconnect', function() {
+      setTimeout(function() {
+        conn.destroy();
+        destroyed = true;
+      }, 1000);
+    }).once('exit', function() {
+      // Worker should not exit while it has a connection
+      assert(destroyed, 'worker exited before connection destroyed');
+      success = true;
+    });
+
+  }).listen(0, function() {
+    const port = this.address().port;
+
+    worker = cluster.fork()
+      .on('online', function() {
+        this.send({ port });
+      });
+  });
+  process.on('exit', function() {
+    assert(success);
+  });
+} else {
+  process.on('message', function(msg) {
+    // We shouldn't exit, not while a network connection exists
+    net.connect(msg.port);
+  });
+}
diff --git a/test/js/node/test/parallel/test-cluster-worker-wait-server-close.js b/test/js/node/test/parallel/test-cluster-worker-wait-server-close.js
new file mode 100644
index 0000000000..71a8cacb52
--- /dev/null
+++ b/test/js/node/test/parallel/test-cluster-worker-wait-server-close.js
@@ -0,0 +1,48 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const cluster = require('cluster');
+const net = require('net');
+
+let serverClosed = false;
+
+if (cluster.isWorker) {
+  const server = net.createServer(function(socket) {
+    // Wait for any data, then close connection
+    socket.write('.');
+    socket.on('data', () => {});
+  }).listen(0, common.localhostIPv4);
+
+  server.once('close', function() {
+    serverClosed = true;
+  });
+
+  // Although not typical, the worker process can exit before the disconnect
+  // event fires. Use this to keep the process open until the event has fired.
+  const keepOpen = setInterval(() => {}, 9999);
+
+  // Check worker events and properties
+  process.once('disconnect', function() {
+    // Disconnect should occur after socket close
+    assert(serverClosed);
+    clearInterval(keepOpen);
+  });
+} else if (cluster.isPrimary) {
+  // start worker
+  const worker = cluster.fork();
+
+  // Disconnect worker when it is ready
+  worker.once('listening', function(address) {
+    const socket = net.createConnection(address.port, common.localhostIPv4);
+
+    socket.on('connect', function() {
+      socket.on('data', function() {
+        console.log('got data from client');
+        // Socket definitely connected to worker if we got data
+        worker.disconnect();
+        socket.end();
+      });
+    });
+  });
+}
diff --git a/test/js/node/test/parallel/test-common-countdown.js b/test/js/node/test/parallel/test-common-countdown.js
new file mode 100644
index 0000000000..d3c0daf599
--- /dev/null
+++ b/test/js/node/test/parallel/test-common-countdown.js
@@ -0,0 +1,33 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const Countdown = require('../common/countdown');
+const fixtures = require('../common/fixtures');
+const { execFile } = require('child_process');
+
+let done = '';
+const countdown = new Countdown(2, () => done = true);
+assert.strictEqual(countdown.remaining, 2);
+countdown.dec();
+assert.strictEqual(countdown.remaining, 1);
+countdown.dec();
+assert.strictEqual(countdown.remaining, 0);
+assert.strictEqual(done, true);
+
+const failFixtures = [
+  [
+    fixtures.path('failcounter.js'),
+    'Mismatched <anonymous> function calls. Expected exactly 1, actual 0.',
+  ],
+];
+
+for (const p of failFixtures) {
+  const [file, expected] = p;
+  execFile(process.argv[0], [file], common.mustCall((ex, stdout, stderr) => {
+    assert.ok(ex);
+    assert.strictEqual(stderr, '');
+    const firstLine = stdout.split('\n').shift();
+    assert.strictEqual(firstLine, expected);
+  }));
+}
diff --git a/test/js/node/test/parallel/test-common-must-not-call.js b/test/js/node/test/parallel/test-common-must-not-call.js
new file mode 100644
index 0000000000..b3c94a2390
--- /dev/null
+++ b/test/js/node/test/parallel/test-common-must-not-call.js
@@ -0,0 +1,56 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const path = require('path');
+const util = require('util');
+
+const message = 'message';
+const testFunction1 = common.mustNotCall(message);
+
+const testFunction2 = common.mustNotCall(message);
+
+const createValidate = (line, args = []) => common.mustCall((e) => {
+  const prefix = `${message} at `;
+  assert.ok(e.message.startsWith(prefix));
+  if (process.platform === 'win32') {
+    e.message = e.message.substring(2); // remove 'C:'
+  }
+  const msg = e.message.substring(prefix.length);
+  const firstColon = msg.indexOf(':');
+  const fileName = msg.substring(0, firstColon);
+  const rest = msg.substring(firstColon + 1);
+  assert.strictEqual(path.basename(fileName), 'test-common-must-not-call.js');
+  const argsInfo = args.length > 0 ?
+    `\ncalled with arguments: ${args.map(util.inspect).join(', ')}` : '';
+  assert.strictEqual(rest, line + argsInfo);
+});
+
+const validate1 = createValidate('9');
+try {
+  testFunction1();
+} catch (e) {
+  validate1(e);
+}
+
+const validate2 = createValidate('11', ['hello', 42]);
+try {
+  testFunction2('hello', 42);
+} catch (e) {
+  validate2(e);
+}
+
+assert.throws(
+  () => new Proxy({ prop: Symbol() }, { get: common.mustNotCall() }).prop,
+  { code: 'ERR_ASSERTION' }
+);
+
+{
+  const { inspect } = util;
+  delete util.inspect;
+  assert.throws(
+    () => common.mustNotCall()(null),
+    { code: 'ERR_ASSERTION' }
+  );
+  util.inspect = inspect;
+}
diff --git a/test/js/node/test/parallel/test-console-assign-undefined.js b/test/js/node/test/parallel/test-console-assign-undefined.js
new file mode 100644
index 0000000000..1021307b3c
--- /dev/null
+++ b/test/js/node/test/parallel/test-console-assign-undefined.js
@@ -0,0 +1,28 @@
+'use strict';
+
+// Patch global.console before importing modules that may modify the console
+// object.
+
+const tmp = global.console;
+global.console = 42;
+
+require('../common');
+const assert = require('assert');
+
+// Originally the console had a getter. Test twice to verify it had no side
+// effect.
+assert.strictEqual(global.console, 42);
+assert.strictEqual(global.console, 42);
+
+assert.throws(
+  () => console.log('foo'),
+  { name: 'TypeError' }
+);
+
+global.console = 1;
+assert.strictEqual(global.console, 1);
+assert.strictEqual(console, 1);
+
+// Reset the console
+global.console = tmp;
+console.log('foo');
diff --git a/test/js/node/test/parallel/test-console-async-write-error.js b/test/js/node/test/parallel/test-console-async-write-error.js
new file mode 100644
index 0000000000..be76c89832
--- /dev/null
+++ b/test/js/node/test/parallel/test-console-async-write-error.js
@@ -0,0 +1,15 @@
+'use strict';
+const common = require('../common');
+const { Console } = require('console');
+const { Writable } = require('stream');
+
+for (const method of ['dir', 'log', 'warn']) {
+  const out = new Writable({
+    write: common.mustCall((chunk, enc, callback) => {
+      process.nextTick(callback, new Error('foobar'));
+    })
+  });
+
+  const c = new Console(out, out, true);
+  c[method]('abc'); // Should not throw.
+}
diff --git a/test/js/node/test/parallel/test-console-issue-43095.js b/test/js/node/test/parallel/test-console-issue-43095.js
new file mode 100644
index 0000000000..647f4af2df
--- /dev/null
+++ b/test/js/node/test/parallel/test-console-issue-43095.js
@@ -0,0 +1,12 @@
+'use strict';
+
+require('../common');
+const { inspect } = require('node:util');
+
+const r = Proxy.revocable({}, {});
+r.revoke();
+
+console.dir(r);
+console.dir(r.proxy);
+console.log(r.proxy);
+console.log(inspect(r.proxy, { showProxy: true }));
diff --git a/test/js/node/test/parallel/test-console-log-stdio-broken-dest.js b/test/js/node/test/parallel/test-console-log-stdio-broken-dest.js
new file mode 100644
index 0000000000..bdd1b79427
--- /dev/null
+++ b/test/js/node/test/parallel/test-console-log-stdio-broken-dest.js
@@ -0,0 +1,24 @@
+'use strict';
+
+const common = require('../common');
+const { Writable } = require('stream');
+const { Console } = require('console');
+const { EventEmitter } = require('events');
+
+const stream = new Writable({
+  write(chunk, enc, cb) {
+    cb();
+  },
+  writev(chunks, cb) {
+    setTimeout(cb, 10, new Error('kaboom'));
+  }
+});
+const myConsole = new Console(stream, stream);
+
+process.on('warning', common.mustNotCall());
+
+stream.cork();
+for (let i = 0; i < EventEmitter.defaultMaxListeners + 1; i++) {
+  myConsole.log('a message');
+}
+stream.uncork();
diff --git a/test/js/node/test/parallel/test-console-log-throw-primitive.js b/test/js/node/test/parallel/test-console-log-throw-primitive.js
new file mode 100644
index 0000000000..a1a9ca2572
--- /dev/null
+++ b/test/js/node/test/parallel/test-console-log-throw-primitive.js
@@ -0,0 +1,14 @@
+'use strict';
+require('../common');
+const { Writable } = require('stream');
+const { Console } = require('console');
+
+const stream = new Writable({
+  write() {
+    throw null; // eslint-disable-line no-throw-literal
+  }
+});
+
+const console = new Console({ stdout: stream });
+
+console.log('test'); // Should not throw
diff --git a/test/js/node/test/parallel/test-console-methods.js b/test/js/node/test/parallel/test-console-methods.js
new file mode 100644
index 0000000000..d338cc1f80
--- /dev/null
+++ b/test/js/node/test/parallel/test-console-methods.js
@@ -0,0 +1,63 @@
+'use strict';
+require('../common');
+
+// This test ensures that console methods cannot be invoked as constructors and
+// that their name is always correct.
+
+const assert = require('assert');
+
+const { Console } = console;
+const newInstance = new Console(process.stdout);
+const err = TypeError;
+
+const methods = [
+  'log',
+  'warn',
+  'dir',
+  'time',
+  'timeEnd',
+  'timeLog',
+  'trace',
+  'assert',
+  'clear',
+  'count',
+  'countReset',
+  'group',
+  'groupEnd',
+  'table',
+  'debug',
+  'info',
+  'dirxml',
+  'error',
+  'groupCollapsed',
+];
+
+const alternateNames = {
+  debug: 'log',
+  info: 'log',
+  dirxml: 'log',
+  error: 'warn',
+  groupCollapsed: 'group'
+};
+
+function assertEqualName(method) {
+  try {
+    assert.strictEqual(console[method].name, method);
+  } catch {
+    assert.strictEqual(console[method].name, alternateNames[method]);
+  }
+  try {
+    assert.strictEqual(newInstance[method].name, method);
+  } catch {
+    assert.strictEqual(newInstance[method].name, alternateNames[method]);
+  }
+}
+
+for (const method of methods) {
+  assertEqualName(method);
+
+  assert.throws(() => new console[method](), err);
+  assert.throws(() => new newInstance[method](), err);
+  assert.throws(() => Reflect.construct({}, [], console[method]), err);
+  assert.throws(() => Reflect.construct({}, [], newInstance[method]), err);
+}
diff --git a/test/js/node/test/parallel/test-console-not-call-toString.js b/test/js/node/test/parallel/test-console-not-call-toString.js
new file mode 100644
index 0000000000..0f6f2624c5
--- /dev/null
+++ b/test/js/node/test/parallel/test-console-not-call-toString.js
@@ -0,0 +1,34 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+
+function func() {}
+let toStringCalled = false;
+func.toString = function() {
+  toStringCalled = true;
+};
+
+require('util').inspect(func);
+
+assert.ok(!toStringCalled);
diff --git a/test/js/node/test/parallel/test-console-self-assign.js b/test/js/node/test/parallel/test-console-self-assign.js
new file mode 100644
index 0000000000..53c54ab9a3
--- /dev/null
+++ b/test/js/node/test/parallel/test-console-self-assign.js
@@ -0,0 +1,6 @@
+'use strict';
+
+require('../common');
+
+// Assigning to itself should not throw.
+global.console = global.console; // eslint-disable-line no-self-assign
diff --git a/test/js/node/test/parallel/test-console-sync-write-error.js b/test/js/node/test/parallel/test-console-sync-write-error.js
new file mode 100644
index 0000000000..bf916ff5b8
--- /dev/null
+++ b/test/js/node/test/parallel/test-console-sync-write-error.js
@@ -0,0 +1,39 @@
+'use strict';
+const common = require('../common');
+const { Console } = require('console');
+const { Writable } = require('stream');
+
+for (const method of ['dir', 'log', 'warn']) {
+  {
+    const out = new Writable({
+      write: common.mustCall((chunk, enc, callback) => {
+        callback(new Error('foobar'));
+      })
+    });
+
+    const c = new Console(out, out, true);
+    c[method]('abc'); // Should not throw.
+  }
+
+  {
+    const out = new Writable({
+      write: common.mustCall((chunk, enc, callback) => {
+        throw new Error('foobar');
+      })
+    });
+
+    const c = new Console(out, out, true);
+    c[method]('abc'); // Should not throw.
+  }
+
+  {
+    const out = new Writable({
+      write: common.mustCall((chunk, enc, callback) => {
+        setImmediate(() => callback(new Error('foobar')));
+      })
+    });
+
+    const c = new Console(out, out, true);
+    c[method]('abc'); // Should not throw.
+  }
+}
diff --git a/test/js/node/test/parallel/test-coverage-with-inspector-disabled.js b/test/js/node/test/parallel/test-coverage-with-inspector-disabled.js
new file mode 100644
index 0000000000..f2ba070859
--- /dev/null
+++ b/test/js/node/test/parallel/test-coverage-with-inspector-disabled.js
@@ -0,0 +1,26 @@
+'use strict';
+
+const common = require('../common');
+if (process.features.inspector) {
+  common.skip('V8 inspector is enabled');
+}
+
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+const env = { ...process.env, NODE_V8_COVERAGE: '/foo/bar' };
+const childPath = fixtures.path('v8-coverage/subprocess');
+const { status, stderr } = spawnSync(
+  process.execPath,
+  [childPath],
+  { env }
+);
+
+const warningMessage = 'The inspector is disabled, ' +
+                        'coverage could not be collected';
+
+assert.strictEqual(status, 0);
+assert.strictEqual(
+  stderr.toString().includes(`Warning: ${warningMessage}`),
+  true
+);
diff --git a/test/js/node/test/parallel/test-crypto-dh-odd-key.js b/test/js/node/test/parallel/test-crypto-dh-odd-key.js
new file mode 100644
index 0000000000..69a1eb56c8
--- /dev/null
+++ b/test/js/node/test/parallel/test-crypto-dh-odd-key.js
@@ -0,0 +1,43 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const crypto = require('crypto');
+
+function test() {
+  const odd = Buffer.alloc(39, 'A');
+
+  const c = crypto.createDiffieHellman(common.hasOpenSSL3 ? 1024 : 32);
+  c.setPrivateKey(odd);
+  c.generateKeys();
+}
+
+// FIPS requires a length of at least 1024
+if (!common.hasFipsCrypto) {
+  test();
+} else {
+  assert.throws(function() { test(); }, /key size too small/);
+}
diff --git a/test/js/node/test/parallel/test-crypto-dh-shared.js b/test/js/node/test/parallel/test-crypto-dh-shared.js
new file mode 100644
index 0000000000..515405034d
--- /dev/null
+++ b/test/js/node/test/parallel/test-crypto-dh-shared.js
@@ -0,0 +1,15 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const crypto = require('crypto');
+
+const alice = crypto.createDiffieHellmanGroup('modp5');
+const bob = crypto.createDiffieHellmanGroup('modp5');
+alice.generateKeys();
+bob.generateKeys();
+const aSecret = alice.computeSecret(bob.getPublicKey()).toString('hex');
+const bSecret = bob.computeSecret(alice.getPublicKey()).toString('hex');
+assert.strictEqual(aSecret, bSecret);
diff --git a/test/js/node/test/parallel/test-crypto-domain.js b/test/js/node/test/parallel/test-crypto-domain.js
new file mode 100644
index 0000000000..62e2be4c0f
--- /dev/null
+++ b/test/js/node/test/parallel/test-crypto-domain.js
@@ -0,0 +1,49 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const crypto = require('crypto');
+const domain = require('domain');
+
+const test = (fn) => {
+  const ex = new Error('BAM');
+  const d = domain.create();
+  d.on('error', common.mustCall(function(err) {
+    assert.strictEqual(err, ex);
+  }));
+  const cb = common.mustCall(function() {
+    throw ex;
+  });
+  d.run(cb);
+};
+
+test(function(cb) {
+  crypto.pbkdf2('password', 'salt', 1, 8, cb);
+});
+
+test(function(cb) {
+  crypto.randomBytes(32, cb);
+});
diff --git a/test/js/node/test/parallel/test-crypto-from-binary.js b/test/js/node/test/parallel/test-crypto-from-binary.js
new file mode 100644
index 0000000000..3b3c6a81ef
--- /dev/null
+++ b/test/js/node/test/parallel/test-crypto-from-binary.js
@@ -0,0 +1,65 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+// This is the same as test/simple/test-crypto, but from before the shift
+// to use buffers by default.
+
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const crypto = require('crypto');
+
+const EXTERN_APEX = 0xFBEE9;
+
+// Manually controlled string for checking binary output
+let ucs2_control = 'a\u0000';
+
+// Grow the strings to proper length
+while (ucs2_control.length <= EXTERN_APEX) {
+  ucs2_control = ucs2_control.repeat(2);
+}
+
+
+// Check resultant buffer and output string
+const b = Buffer.from(ucs2_control + ucs2_control, 'ucs2');
+
+//
+// Test updating from birant data
+//
+{
+  const datum1 = b.slice(700000);
+  const hash1_converted = crypto.createHash('sha1')
+    .update(datum1.toString('base64'), 'base64')
+    .digest('hex');
+  const hash1_direct = crypto.createHash('sha1').update(datum1).digest('hex');
+  assert.strictEqual(hash1_direct, hash1_converted);
+
+  const datum2 = b;
+  const hash2_converted = crypto.createHash('sha1')
+    .update(datum2.toString('base64'), 'base64')
+    .digest('hex');
+  const hash2_direct = crypto.createHash('sha1').update(datum2).digest('hex');
+  assert.strictEqual(hash2_direct, hash2_converted);
+}
diff --git a/test/js/node/test/parallel/test-crypto-keygen-async-elliptic-curve-jwk-rsa.js b/test/js/node/test/parallel/test-crypto-keygen-async-elliptic-curve-jwk-rsa.js
new file mode 100644
index 0000000000..449d1a97f9
--- /dev/null
+++ b/test/js/node/test/parallel/test-crypto-keygen-async-elliptic-curve-jwk-rsa.js
@@ -0,0 +1,38 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const {
+  generateKeyPair,
+} = require('crypto');
+
+// Test async elliptic curve key generation with 'jwk' encoding and RSA.
+{
+  generateKeyPair('rsa', {
+    modulusLength: 1024,
+    publicKeyEncoding: {
+      format: 'jwk'
+    },
+    privateKeyEncoding: {
+      format: 'jwk'
+    }
+  }, common.mustSucceed((publicKey, privateKey) => {
+    assert.strictEqual(typeof publicKey, 'object');
+    assert.strictEqual(typeof privateKey, 'object');
+    assert.strictEqual(publicKey.kty, 'RSA');
+    assert.strictEqual(publicKey.kty, privateKey.kty);
+    assert.strictEqual(typeof publicKey.n, 'string');
+    assert.strictEqual(publicKey.n, privateKey.n);
+    assert.strictEqual(typeof publicKey.e, 'string');
+    assert.strictEqual(publicKey.e, privateKey.e);
+    assert.strictEqual(typeof privateKey.d, 'string');
+    assert.strictEqual(typeof privateKey.p, 'string');
+    assert.strictEqual(typeof privateKey.q, 'string');
+    assert.strictEqual(typeof privateKey.dp, 'string');
+    assert.strictEqual(typeof privateKey.dq, 'string');
+    assert.strictEqual(typeof privateKey.qi, 'string');
+  }));
+}
diff --git a/test/js/node/test/parallel/test-crypto-keygen-async-encrypted-private-key-der.js b/test/js/node/test/parallel/test-crypto-keygen-async-encrypted-private-key-der.js
new file mode 100644
index 0000000000..3203dfe16e
--- /dev/null
+++ b/test/js/node/test/parallel/test-crypto-keygen-async-encrypted-private-key-der.js
@@ -0,0 +1,50 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const {
+  generateKeyPair,
+} = require('crypto');
+const {
+  assertApproximateSize,
+  testEncryptDecrypt,
+  testSignVerify,
+} = require('../common/crypto');
+
+// Test async RSA key generation with an encrypted private key, but encoded as DER.
+{
+  generateKeyPair('rsa', {
+    publicExponent: 0x10001,
+    modulusLength: 512,
+    publicKeyEncoding: {
+      type: 'pkcs1',
+      format: 'der'
+    },
+    privateKeyEncoding: {
+      type: 'pkcs8',
+      format: 'der'
+    }
+  }, common.mustSucceed((publicKeyDER, privateKeyDER) => {
+    assert(Buffer.isBuffer(publicKeyDER));
+    assertApproximateSize(publicKeyDER, 74);
+
+    assert(Buffer.isBuffer(privateKeyDER));
+
+    const publicKey = {
+      key: publicKeyDER,
+      type: 'pkcs1',
+      format: 'der',
+    };
+    const privateKey = {
+      key: privateKeyDER,
+      format: 'der',
+      type: 'pkcs8',
+      passphrase: 'secret'
+    };
+    testEncryptDecrypt(publicKey, privateKey);
+    testSignVerify(publicKey, privateKey);
+  }));
+}
diff --git a/test/js/node/test/parallel/test-crypto-keygen-async-explicit-elliptic-curve.js b/test/js/node/test/parallel/test-crypto-keygen-async-explicit-elliptic-curve.js
new file mode 100644
index 0000000000..46223f08d7
--- /dev/null
+++ b/test/js/node/test/parallel/test-crypto-keygen-async-explicit-elliptic-curve.js
@@ -0,0 +1,39 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const {
+  generateKeyPair,
+} = require('crypto');
+const {
+  testSignVerify,
+  spkiExp,
+  sec1Exp,
+} = require('../common/crypto');
+
+// Test async explicit elliptic curve key generation, e.g. for ECDSA,
+// with a SEC1 private key with paramEncoding explicit.
+{
+  generateKeyPair('ec', {
+    namedCurve: 'prime256v1',
+    paramEncoding: 'explicit',
+    publicKeyEncoding: {
+      type: 'spki',
+      format: 'pem'
+    },
+    privateKeyEncoding: {
+      type: 'sec1',
+      format: 'pem'
+    }
+  }, common.mustSucceed((publicKey, privateKey) => {
+    assert.strictEqual(typeof publicKey, 'string');
+    assert.match(publicKey, spkiExp);
+    assert.strictEqual(typeof privateKey, 'string');
+    assert.match(privateKey, sec1Exp);
+
+    testSignVerify(publicKey, privateKey);
+  }));
+}
diff --git a/test/js/node/test/parallel/test-crypto-keygen-async-named-elliptic-curve.js b/test/js/node/test/parallel/test-crypto-keygen-async-named-elliptic-curve.js
new file mode 100644
index 0000000000..a1dfdbce1f
--- /dev/null
+++ b/test/js/node/test/parallel/test-crypto-keygen-async-named-elliptic-curve.js
@@ -0,0 +1,39 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const {
+  generateKeyPair,
+} = require('crypto');
+const {
+  testSignVerify,
+  spkiExp,
+  sec1Exp,
+} = require('../common/crypto');
+
+// Test async named elliptic curve key generation, e.g. for ECDSA,
+// with a SEC1 private key.
+{
+  generateKeyPair('ec', {
+    namedCurve: 'prime256v1',
+    paramEncoding: 'named',
+    publicKeyEncoding: {
+      type: 'spki',
+      format: 'pem'
+    },
+    privateKeyEncoding: {
+      type: 'sec1',
+      format: 'pem'
+    }
+  }, common.mustSucceed((publicKey, privateKey) => {
+    assert.strictEqual(typeof publicKey, 'string');
+    assert.match(publicKey, spkiExp);
+    assert.strictEqual(typeof privateKey, 'string');
+    assert.match(privateKey, sec1Exp);
+
+    testSignVerify(publicKey, privateKey);
+  }));
+}
diff --git a/test/js/node/test/parallel/test-crypto-keygen-eddsa.js b/test/js/node/test/parallel/test-crypto-keygen-eddsa.js
new file mode 100644
index 0000000000..5a097c2524
--- /dev/null
+++ b/test/js/node/test/parallel/test-crypto-keygen-eddsa.js
@@ -0,0 +1,27 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const {
+  generateKeyPair,
+} = require('crypto');
+
+// Test EdDSA key generation.
+{
+  if (!/^1\.1\.0/.test(process.versions.openssl)) {
+    ['ed25519', 'ed448', 'x25519', 'x448'].forEach((keyType) => {
+      generateKeyPair(keyType, common.mustSucceed((publicKey, privateKey) => {
+        assert.strictEqual(publicKey.type, 'public');
+        assert.strictEqual(publicKey.asymmetricKeyType, keyType);
+        assert.deepStrictEqual(publicKey.asymmetricKeyDetails, {});
+
+        assert.strictEqual(privateKey.type, 'private');
+        assert.strictEqual(privateKey.asymmetricKeyType, keyType);
+        assert.deepStrictEqual(privateKey.asymmetricKeyDetails, {});
+      }));
+    });
+  }
+}
diff --git a/test/js/node/test/parallel/test-crypto-keygen-empty-passphrase-no-error.js b/test/js/node/test/parallel/test-crypto-keygen-empty-passphrase-no-error.js
new file mode 100644
index 0000000000..6c7938f99e
--- /dev/null
+++ b/test/js/node/test/parallel/test-crypto-keygen-empty-passphrase-no-error.js
@@ -0,0 +1,29 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const {
+  generateKeyPair,
+} = require('crypto');
+
+// Passing an empty passphrase string should not throw ERR_OSSL_CRYPTO_MALLOC_FAILURE even on OpenSSL 3.
+// Regression test for https://github.com/nodejs/node/issues/41428.
+generateKeyPair('rsa', {
+  modulusLength: 1024,
+  publicKeyEncoding: {
+    type: 'spki',
+    format: 'pem'
+  },
+  privateKeyEncoding: {
+    type: 'pkcs8',
+    format: 'pem',
+    cipher: 'aes-256-cbc',
+    passphrase: ''
+  }
+}, common.mustSucceed((publicKey, privateKey) => {
+  assert.strictEqual(typeof publicKey, 'string');
+  assert.strictEqual(typeof privateKey, 'string');
+}));
diff --git a/test/js/node/test/parallel/test-crypto-keygen-key-object-without-encoding.js b/test/js/node/test/parallel/test-crypto-keygen-key-object-without-encoding.js
new file mode 100644
index 0000000000..abcd282871
--- /dev/null
+++ b/test/js/node/test/parallel/test-crypto-keygen-key-object-without-encoding.js
@@ -0,0 +1,55 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const {
+  generateKeyPair,
+} = require('crypto');
+const {
+  testEncryptDecrypt,
+  testSignVerify,
+} = require('../common/crypto');
+
+// Tests key objects are returned when key encodings are not specified.
+{
+  // If no publicKeyEncoding is specified, a key object should be returned.
+  generateKeyPair('rsa', {
+    modulusLength: 1024,
+    privateKeyEncoding: {
+      type: 'pkcs1',
+      format: 'pem'
+    }
+  }, common.mustSucceed((publicKey, privateKey) => {
+    assert.strictEqual(typeof publicKey, 'object');
+    assert.strictEqual(publicKey.type, 'public');
+    assert.strictEqual(publicKey.asymmetricKeyType, 'rsa');
+
+    // The private key should still be a string.
+    assert.strictEqual(typeof privateKey, 'string');
+
+    testEncryptDecrypt(publicKey, privateKey);
+    testSignVerify(publicKey, privateKey);
+  }));
+
+  // If no privateKeyEncoding is specified, a key object should be returned.
+  generateKeyPair('rsa', {
+    modulusLength: 1024,
+    publicKeyEncoding: {
+      type: 'pkcs1',
+      format: 'pem'
+    }
+  }, common.mustSucceed((publicKey, privateKey) => {
+    // The public key should still be a string.
+    assert.strictEqual(typeof publicKey, 'string');
+
+    assert.strictEqual(typeof privateKey, 'object');
+    assert.strictEqual(privateKey.type, 'private');
+    assert.strictEqual(privateKey.asymmetricKeyType, 'rsa');
+
+    testEncryptDecrypt(publicKey, privateKey);
+    testSignVerify(publicKey, privateKey);
+  }));
+}
diff --git a/test/js/node/test/parallel/test-crypto-keygen-key-objects.js b/test/js/node/test/parallel/test-crypto-keygen-key-objects.js
new file mode 100644
index 0000000000..a0f1bdf2bc
--- /dev/null
+++ b/test/js/node/test/parallel/test-crypto-keygen-key-objects.js
@@ -0,0 +1,33 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const {
+  generateKeyPairSync,
+} = require('crypto');
+
+// Test sync key generation with key objects.
+{
+  const { publicKey, privateKey } = generateKeyPairSync('rsa', {
+    modulusLength: 512
+  });
+
+  assert.strictEqual(typeof publicKey, 'object');
+  assert.strictEqual(publicKey.type, 'public');
+  assert.strictEqual(publicKey.asymmetricKeyType, 'rsa');
+  assert.deepStrictEqual(publicKey.asymmetricKeyDetails, {
+    modulusLength: 512,
+    publicExponent: 65537n
+  });
+
+  assert.strictEqual(typeof privateKey, 'object');
+  assert.strictEqual(privateKey.type, 'private');
+  assert.strictEqual(privateKey.asymmetricKeyType, 'rsa');
+  assert.deepStrictEqual(privateKey.asymmetricKeyDetails, {
+    modulusLength: 512,
+    publicExponent: 65537n
+  });
+}
diff --git a/test/js/node/test/parallel/test-crypto-keygen-missing-oid.js b/test/js/node/test/parallel/test-crypto-keygen-missing-oid.js
new file mode 100644
index 0000000000..f7fefe1384
--- /dev/null
+++ b/test/js/node/test/parallel/test-crypto-keygen-missing-oid.js
@@ -0,0 +1,43 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const {
+  generateKeyPair,
+  generateKeyPairSync,
+  getCurves,
+} = require('crypto');
+
+// This test creates EC key pairs on curves without associated OIDs.
+// Specifying a key encoding should not crash.
+{
+  if (process.versions.openssl >= '1.1.1i') {
+    for (const namedCurve of ['Oakley-EC2N-3', 'Oakley-EC2N-4']) {
+      if (!getCurves().includes(namedCurve))
+        continue;
+
+      const expectedErrorCode =
+        common.hasOpenSSL3 ? 'ERR_OSSL_MISSING_OID' : 'ERR_OSSL_EC_MISSING_OID';
+      const params = {
+        namedCurve,
+        publicKeyEncoding: {
+          format: 'der',
+          type: 'spki'
+        }
+      };
+
+      assert.throws(() => {
+        generateKeyPairSync('ec', params);
+      }, {
+        code: expectedErrorCode
+      });
+
+      generateKeyPair('ec', params, common.mustCall((err) => {
+        assert.strictEqual(err.code, expectedErrorCode);
+      }));
+    }
+  }
+}
diff --git a/test/js/node/test/parallel/test-crypto-keygen-non-standard-public-exponent.js b/test/js/node/test/parallel/test-crypto-keygen-non-standard-public-exponent.js
new file mode 100644
index 0000000000..f54a9e8a6d
--- /dev/null
+++ b/test/js/node/test/parallel/test-crypto-keygen-non-standard-public-exponent.js
@@ -0,0 +1,35 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const {
+  generateKeyPairSync,
+} = require('crypto');
+
+// Test sync key generation with key objects with a non-standard
+// publicExponent
+{
+  const { publicKey, privateKey } = generateKeyPairSync('rsa', {
+    publicExponent: 3,
+    modulusLength: 512
+  });
+
+  assert.strictEqual(typeof publicKey, 'object');
+  assert.strictEqual(publicKey.type, 'public');
+  assert.strictEqual(publicKey.asymmetricKeyType, 'rsa');
+  assert.deepStrictEqual(publicKey.asymmetricKeyDetails, {
+    modulusLength: 512,
+    publicExponent: 3n
+  });
+
+  assert.strictEqual(typeof privateKey, 'object');
+  assert.strictEqual(privateKey.type, 'private');
+  assert.strictEqual(privateKey.asymmetricKeyType, 'rsa');
+  assert.deepStrictEqual(privateKey.asymmetricKeyDetails, {
+    modulusLength: 512,
+    publicExponent: 3n
+  });
+}
diff --git a/test/js/node/test/parallel/test-crypto-keygen-promisify.js b/test/js/node/test/parallel/test-crypto-keygen-promisify.js
new file mode 100644
index 0000000000..cd6ca7d6e3
--- /dev/null
+++ b/test/js/node/test/parallel/test-crypto-keygen-promisify.js
@@ -0,0 +1,46 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const {
+  generateKeyPair,
+} = require('crypto');
+const {
+  assertApproximateSize,
+  testEncryptDecrypt,
+  testSignVerify,
+  pkcs1PubExp,
+  pkcs1PrivExp,
+} = require('../common/crypto');
+const { promisify } = require('util');
+
+// Test the util.promisified API with async RSA key generation.
+{
+  promisify(generateKeyPair)('rsa', {
+    publicExponent: 0x10001,
+    modulusLength: 512,
+    publicKeyEncoding: {
+      type: 'pkcs1',
+      format: 'pem'
+    },
+    privateKeyEncoding: {
+      type: 'pkcs1',
+      format: 'pem'
+    }
+  }).then(common.mustCall((keys) => {
+    const { publicKey, privateKey } = keys;
+    assert.strictEqual(typeof publicKey, 'string');
+    assert.match(publicKey, pkcs1PubExp);
+    assertApproximateSize(publicKey, 180);
+
+    assert.strictEqual(typeof privateKey, 'string');
+    assert.match(privateKey, pkcs1PrivExp);
+    assertApproximateSize(privateKey, 512);
+
+    testEncryptDecrypt(publicKey, privateKey);
+    testSignVerify(publicKey, privateKey);
+  }));
+}
diff --git a/test/js/node/test/parallel/test-crypto-keygen-sync.js b/test/js/node/test/parallel/test-crypto-keygen-sync.js
new file mode 100644
index 0000000000..a100379e21
--- /dev/null
+++ b/test/js/node/test/parallel/test-crypto-keygen-sync.js
@@ -0,0 +1,47 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const {
+  generateKeyPairSync,
+} = require('crypto');
+const {
+  assertApproximateSize,
+  testEncryptDecrypt,
+  testSignVerify,
+  pkcs1PubExp,
+  pkcs8Exp,
+} = require('../common/crypto');
+
+// To make the test faster, we will only test sync key generation once and
+// with a relatively small key.
+{
+  const ret = generateKeyPairSync('rsa', {
+    publicExponent: 3,
+    modulusLength: 512,
+    publicKeyEncoding: {
+      type: 'pkcs1',
+      format: 'pem'
+    },
+    privateKeyEncoding: {
+      type: 'pkcs8',
+      format: 'pem'
+    }
+  });
+
+  assert.strictEqual(Object.keys(ret).length, 2);
+  const { publicKey, privateKey } = ret;
+
+  assert.strictEqual(typeof publicKey, 'string');
+  assert.match(publicKey, pkcs1PubExp);
+  assertApproximateSize(publicKey, 162);
+  assert.strictEqual(typeof privateKey, 'string');
+  assert.match(privateKey, pkcs8Exp);
+  assertApproximateSize(privateKey, 512);
+
+  testEncryptDecrypt(publicKey, privateKey);
+  testSignVerify(publicKey, privateKey);
+}
diff --git a/test/js/node/test/parallel/test-crypto-lazy-transform-writable.js b/test/js/node/test/parallel/test-crypto-lazy-transform-writable.js
new file mode 100644
index 0000000000..000c6693c8
--- /dev/null
+++ b/test/js/node/test/parallel/test-crypto-lazy-transform-writable.js
@@ -0,0 +1,36 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const crypto = require('crypto');
+const Stream = require('stream');
+
+const hasher1 = crypto.createHash('sha256');
+const hasher2 = crypto.createHash('sha256');
+
+// Calculate the expected result.
+hasher1.write(Buffer.from('hello world'));
+hasher1.end();
+
+const expected = hasher1.read().toString('hex');
+
+class OldStream extends Stream {
+  constructor() {
+    super();
+    this.readable = true;
+  }
+}
+
+const stream = new OldStream();
+
+stream.pipe(hasher2).on('finish', common.mustCall(function() {
+  const hash = hasher2.read().toString('hex');
+  assert.strictEqual(hash, expected);
+}));
+
+stream.emit('data', Buffer.from('hello'));
+stream.emit('data', Buffer.from(' world'));
+stream.emit('end');
diff --git a/test/js/node/test/parallel/test-crypto-no-algorithm.js b/test/js/node/test/parallel/test-crypto-no-algorithm.js
new file mode 100644
index 0000000000..37db38cf61
--- /dev/null
+++ b/test/js/node/test/parallel/test-crypto-no-algorithm.js
@@ -0,0 +1,38 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+if (!common.hasOpenSSL3)
+  common.skip('this test requires OpenSSL 3.x');
+
+const assert = require('node:assert/strict');
+const crypto = require('node:crypto');
+
+if (common.isMainThread) {
+  // TODO(richardlau): Decide if `crypto.setFips` should error if the
+  // provider named "fips" is not available.
+  crypto.setFips(1);
+  crypto.randomBytes(20, common.mustCall((err) => {
+    // crypto.randomBytes should either succeed or fail but not hang.
+    if (err) {
+      assert.match(err.message, /digital envelope routines::unsupported/);
+      const expected = /random number generator::unable to fetch drbg/;
+      assert(err.opensslErrorStack.some((msg) => expected.test(msg)),
+             `did not find ${expected} in ${err.opensslErrorStack}`);
+    }
+  }));
+}
+
+{
+  // Startup test. Should not hang.
+  const { path } = require('../common/fixtures');
+  const { spawnSync } = require('node:child_process');
+  const baseConf = path('openssl3-conf', 'base_only.cnf');
+  const cp = spawnSync(process.execPath,
+                       [ `--openssl-config=${baseConf}`, '-p', '"hello"' ],
+                       { encoding: 'utf8' });
+  assert(common.nodeProcessAborted(cp.status, cp.signal),
+         `process did not abort, code:${cp.status} signal:${cp.signal}`);
+}
diff --git a/test/js/node/test/parallel/test-crypto-op-during-process-exit.js b/test/js/node/test/parallel/test-crypto-op-during-process-exit.js
new file mode 100644
index 0000000000..a9a70c39e0
--- /dev/null
+++ b/test/js/node/test/parallel/test-crypto-op-during-process-exit.js
@@ -0,0 +1,28 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto) { common.skip('missing crypto'); }
+const assert = require('assert');
+const { generateKeyPair } = require('crypto');
+
+if (common.isWindows) {
+  // Remove this conditional once the libuv change is in Node.js.
+  common.skip('crashing due to https://github.com/libuv/libuv/pull/2983');
+}
+
+// Regression test for a race condition: process.exit() might lead to OpenSSL
+// cleaning up state from the exit() call via calling its destructor, but
+// running OpenSSL operations on another thread might lead to them attempting
+// to initialize OpenSSL, leading to a crash.
+// This test crashed consistently on x64 Linux on Node v14.9.0.
+
+generateKeyPair('rsa', {
+  modulusLength: 2048,
+  privateKeyEncoding: {
+    type: 'pkcs1',
+    format: 'pem'
+  }
+}, (err/* , publicKey, privateKey */) => {
+  assert.ifError(err);
+});
+
+setTimeout(() => process.exit(), common.platformTimeout(10));
diff --git a/test/js/node/test/parallel/test-crypto-padding-aes256.js b/test/js/node/test/parallel/test-crypto-padding-aes256.js
new file mode 100644
index 0000000000..14d853bdfd
--- /dev/null
+++ b/test/js/node/test/parallel/test-crypto-padding-aes256.js
@@ -0,0 +1,60 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const crypto = require('crypto');
+
+const iv = Buffer.from('00000000000000000000000000000000', 'hex');
+const key = Buffer.from('0123456789abcdef0123456789abcdef' +
+                        '0123456789abcdef0123456789abcdef', 'hex');
+
+function encrypt(val, pad) {
+  const c = crypto.createCipheriv('aes256', key, iv);
+  c.setAutoPadding(pad);
+  return c.update(val, 'utf8', 'latin1') + c.final('latin1');
+}
+
+function decrypt(val, pad) {
+  const c = crypto.createDecipheriv('aes256', key, iv);
+  c.setAutoPadding(pad);
+  return c.update(val, 'latin1', 'utf8') + c.final('utf8');
+}
+
+// echo 0123456789abcdef0123456789abcdef \
+// | openssl enc -e -aes256 -nopad -K <key> -iv <iv> \
+// | openssl enc -d -aes256 -nopad -K <key> -iv <iv>
+let plaintext = '0123456789abcdef0123456789abcdef'; // Multiple of block size
+let encrypted = encrypt(plaintext, false);
+let decrypted = decrypt(encrypted, false);
+assert.strictEqual(decrypted, plaintext);
+
+// echo 0123456789abcdef0123456789abcde \
+// | openssl enc -e -aes256 -K <key> -iv <iv> \
+// | openssl enc -d -aes256 -K <key> -iv <iv>
+plaintext = '0123456789abcdef0123456789abcde'; // not a multiple
+encrypted = encrypt(plaintext, true);
+decrypted = decrypt(encrypted, true);
+assert.strictEqual(decrypted, plaintext);
diff --git a/test/js/node/test/parallel/test-crypto-publicDecrypt-fails-first-time.js b/test/js/node/test/parallel/test-crypto-publicDecrypt-fails-first-time.js
new file mode 100644
index 0000000000..a60b87dbf6
--- /dev/null
+++ b/test/js/node/test/parallel/test-crypto-publicDecrypt-fails-first-time.js
@@ -0,0 +1,41 @@
+'use strict';
+const common = require('../common');
+
+// Test for https://github.com/nodejs/node/issues/40814
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+if (!common.hasOpenSSL3)
+  common.skip('only openssl3'); // https://github.com/nodejs/node/pull/42793#issuecomment-1107491901
+
+const assert = require('assert');
+const crypto = require('crypto');
+
+const { privateKey, publicKey } = crypto.generateKeyPairSync('rsa', {
+  modulusLength: 2048,
+  publicKeyEncoding: {
+    type: 'spki',
+    format: 'pem'
+  },
+  privateKeyEncoding: {
+    type: 'pkcs8',
+    format: 'pem',
+    cipher: 'aes-128-ecb',
+    passphrase: 'abcdef'
+  }
+});
+assert.notStrictEqual(privateKey.toString(), '');
+
+const msg = 'The quick brown fox jumps over the lazy dog';
+
+const encryptedString = crypto.privateEncrypt({
+  key: privateKey,
+  passphrase: 'abcdef'
+}, Buffer.from(msg)).toString('base64');
+const decryptedString = crypto.publicDecrypt(publicKey, Buffer.from(encryptedString, 'base64')).toString();
+console.log(`Encrypted: ${encryptedString}`);
+console.log(`Decrypted: ${decryptedString}`);
+
+assert.notStrictEqual(encryptedString, '');
+assert.strictEqual(decryptedString, msg);
diff --git a/test/js/node/test/parallel/test-crypto-randomfillsync-regression.js b/test/js/node/test/parallel/test-crypto-randomfillsync-regression.js
new file mode 100644
index 0000000000..7a37864258
--- /dev/null
+++ b/test/js/node/test/parallel/test-crypto-randomfillsync-regression.js
@@ -0,0 +1,18 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const { randomFillSync } = require('crypto');
+const { notStrictEqual } = require('assert');
+
+const ab = new ArrayBuffer(20);
+const buf = Buffer.from(ab, 10);
+
+const before = buf.toString('hex');
+
+randomFillSync(buf);
+
+const after = buf.toString('hex');
+
+notStrictEqual(before, after);
diff --git a/test/js/node/test/parallel/test-crypto-subtle-zero-length.js b/test/js/node/test/parallel/test-crypto-subtle-zero-length.js
new file mode 100644
index 0000000000..f5a84727b0
--- /dev/null
+++ b/test/js/node/test/parallel/test-crypto-subtle-zero-length.js
@@ -0,0 +1,39 @@
+'use strict';
+
+const common = require('../common');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const { subtle } = globalThis.crypto;
+
+(async () => {
+  const k = await subtle.importKey(
+    'raw',
+    new Uint8Array(32),
+    { name: 'AES-GCM' },
+    false,
+    [ 'encrypt', 'decrypt' ]);
+  assert(k instanceof CryptoKey);
+
+  const e = await subtle.encrypt({
+    name: 'AES-GCM',
+    iv: new Uint8Array(12),
+  }, k, new Uint8Array(0));
+  assert(e instanceof ArrayBuffer);
+  assert.deepStrictEqual(
+    Buffer.from(e),
+    Buffer.from([
+      0x53, 0x0f, 0x8a, 0xfb, 0xc7, 0x45, 0x36, 0xb9,
+      0xa9, 0x63, 0xb4, 0xf1, 0xc4, 0xcb, 0x73, 0x8b ]));
+
+  const v = await subtle.decrypt({
+    name: 'AES-GCM',
+    iv: new Uint8Array(12),
+  }, k, e);
+  assert(v instanceof ArrayBuffer);
+  assert.strictEqual(v.byteLength, 0);
+})().then(common.mustCall()).catch((e) => {
+  assert.ifError(e);
+});
diff --git a/test/js/node/test/parallel/test-crypto-update-encoding.js b/test/js/node/test/parallel/test-crypto-update-encoding.js
new file mode 100644
index 0000000000..e1e6d029aa
--- /dev/null
+++ b/test/js/node/test/parallel/test-crypto-update-encoding.js
@@ -0,0 +1,22 @@
+'use strict';
+const common = require('../common');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const crypto = require('crypto');
+
+const zeros = Buffer.alloc;
+const key = zeros(16);
+const iv = zeros(16);
+
+const cipher = () => crypto.createCipheriv('aes-128-cbc', key, iv);
+const decipher = () => crypto.createDecipheriv('aes-128-cbc', key, iv);
+const hash = () => crypto.createSign('sha256');
+const hmac = () => crypto.createHmac('sha256', key);
+const sign = () => crypto.createSign('sha256');
+const verify = () => crypto.createVerify('sha256');
+
+for (const f of [cipher, decipher, hash, hmac, sign, verify])
+  for (const n of [15, 16])
+    f().update(zeros(n), 'hex');  // Should ignore inputEncoding.
diff --git a/test/js/node/test/parallel/test-datetime-change-notify.js b/test/js/node/test/parallel/test-datetime-change-notify.js
new file mode 100644
index 0000000000..0184351190
--- /dev/null
+++ b/test/js/node/test/parallel/test-datetime-change-notify.js
@@ -0,0 +1,37 @@
+'use strict';
+
+const common = require('../common');
+const { isMainThread } = require('worker_threads');
+
+if (!common.hasIntl)
+  common.skip('Intl not present.');
+
+if (!isMainThread)
+  common.skip('Test not support running within a worker');
+
+const assert = require('assert');
+
+const cases = [
+  {
+    timeZone: 'Etc/UTC',
+    expected: /Coordinated Universal Time/,
+  },
+  {
+    timeZone: 'America/New_York',
+    expected: /Eastern (?:Standard|Daylight) Time/,
+  },
+  {
+    timeZone: 'America/Los_Angeles',
+    expected: /Pacific (?:Standard|Daylight) Time/,
+  },
+  {
+    timeZone: 'Europe/Dublin',
+    expected: /Irish Standard Time|Greenwich Mean Time/,
+  },
+];
+
+for (const { timeZone, expected } of cases) {
+  process.env.TZ = timeZone;
+  const date = new Date().toLocaleString('en-US', { timeZoneName: 'long' });
+  assert.match(date, expected);
+}
diff --git a/test/js/node/test/parallel/test-debugger-backtrace.js b/test/js/node/test/parallel/test-debugger-backtrace.js
new file mode 100644
index 0000000000..f66cc11d70
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-backtrace.js
@@ -0,0 +1,33 @@
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
+
+const assert = require('assert');
+const path = require('path');
+
+// Display and navigate backtrace.
+{
+  const scriptFullPath = fixtures.path('debugger', 'backtrace.js');
+  const script = path.relative(process.cwd(), scriptFullPath);
+  const cli = startCLI(['--port=0', script]);
+
+  async function runTest() {
+    try {
+      await cli.waitForInitialBreak();
+      await cli.waitForPrompt();
+      await cli.stepCommand('c');
+      await cli.command('bt');
+      assert.ok(cli.output.includes(`#0 topFn ${script}:7:2`));
+      await cli.command('backtrace');
+      assert.ok(cli.output.includes(`#0 topFn ${script}:7:2`));
+    } finally {
+      await cli.quit();
+    }
+  }
+
+  runTest();
+}
diff --git a/test/js/node/test/parallel/test-debugger-exec.js b/test/js/node/test/parallel/test-debugger-exec.js
new file mode 100644
index 0000000000..51bc749734
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-exec.js
@@ -0,0 +1,68 @@
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
+
+const assert = require('assert');
+
+const cli = startCLI(['--port=0', fixtures.path('debugger/alive.js')]);
+
+async function waitInitialBreak() {
+  try {
+    await cli.waitForInitialBreak();
+    await cli.waitForPrompt();
+    await cli.command('exec [typeof heartbeat, typeof process.exit]');
+    assert.match(cli.output, /\[ 'function', 'function' \]/, 'works w/o paren');
+
+    await cli.command('p [typeof heartbeat, typeof process.exit]');
+    assert.match(
+      cli.output,
+      /\[ 'function', 'function' \]/,
+      'works w/o paren, short'
+    );
+
+    await cli.command('repl');
+    assert.match(
+      cli.output,
+      /Press Ctrl\+C to leave debug repl\n+> /,
+      'shows hint for how to leave repl'
+    );
+    assert.doesNotMatch(cli.output, /debug>/, 'changes the repl style');
+
+    await cli.command('[typeof heartbeat, typeof process.exit]');
+    await cli.waitFor(/function/);
+    await cli.waitForPrompt();
+    assert.match(
+      cli.output,
+      /\[ 'function', 'function' \]/,
+      'can evaluate in the repl'
+    );
+    assert.match(cli.output, /> $/);
+
+    await cli.ctrlC();
+    await cli.waitFor(/debug> $/);
+    await cli.command('exec("[typeof heartbeat, typeof process.exit]")');
+    assert.match(cli.output, /\[ 'function', 'function' \]/, 'works w/ paren');
+    await cli.command('p("[typeof heartbeat, typeof process.exit]")');
+    assert.match(
+      cli.output,
+      /\[ 'function', 'function' \]/,
+      'works w/ paren, short'
+    );
+
+    await cli.command('cont');
+    await cli.command('exec [typeof heartbeat, typeof process.exit]');
+    assert.match(
+      cli.output,
+      /\[ 'undefined', 'function' \]/,
+      'non-paused exec can see global but not module-scope values'
+    );
+  } finally {
+    await cli.quit();
+  }
+}
+
+waitInitialBreak();
diff --git a/test/js/node/test/parallel/test-debugger-invalid-json.mjs b/test/js/node/test/parallel/test-debugger-invalid-json.mjs
new file mode 100644
index 0000000000..e4754a465f
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-invalid-json.mjs
@@ -0,0 +1,46 @@
+import { skipIfInspectorDisabled, mustCall } from '../common/index.mjs';
+
+skipIfInspectorDisabled();
+
+import startCLI from '../common/debugger.js';
+
+import assert from 'assert';
+import http from 'http';
+
+const host = '127.0.0.1';
+
+{
+  const server = http.createServer((req, res) => {
+    res.statusCode = 400;
+    res.end('Bad Request');
+  });
+
+  server.listen(0, mustCall(async () => {
+    const port = server.address().port;
+    const cli = startCLI([`${host}:${port}`]);
+    try {
+      const code = await cli.quit();
+      assert.strictEqual(code, 1);
+    } finally {
+      server.close();
+    }
+  }));
+}
+
+{
+  const server = http.createServer((req, res) => {
+    res.statusCode = 200;
+    res.end('some data that is invalid json');
+  });
+
+  server.listen(0, host, mustCall(async () => {
+    const port = server.address().port;
+    const cli = startCLI([`${host}:${port}`]);
+    try {
+      const code = await cli.quit();
+      assert.strictEqual(code, 1);
+    } finally {
+      server.close();
+    }
+  }));
+}
diff --git a/test/js/node/test/parallel/test-debugger-low-level.js b/test/js/node/test/parallel/test-debugger-low-level.js
new file mode 100644
index 0000000000..31f67849f5
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-low-level.js
@@ -0,0 +1,35 @@
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
+const assert = require('assert');
+
+// Debugger agent direct access.
+{
+  const cli = startCLI(['--port=0', fixtures.path('debugger/three-lines.js')]);
+  const scriptPattern = /^\* (\d+): \S+debugger(?:\/|\\)three-lines\.js/m;
+
+  async function testDebuggerLowLevel() {
+    try {
+      await cli.waitForInitialBreak();
+      await cli.waitForPrompt();
+      await cli.command('scripts');
+      const [, scriptId] = cli.output.match(scriptPattern);
+      await cli.command(
+        `Debugger.getScriptSource({ scriptId: '${scriptId}' })`
+      );
+      assert.match(
+        cli.output,
+        /scriptSource:[ \n]*'(?:\(function \(|let x = 1)/);
+      assert.match(
+        cli.output,
+        /let x = 1;/);
+    } finally {
+      await cli.quit();
+    }
+  }
+  testDebuggerLowLevel();
+}
diff --git a/test/js/node/test/parallel/test-debugger-pid.js b/test/js/node/test/parallel/test-debugger-pid.js
new file mode 100644
index 0000000000..157939c05c
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-pid.js
@@ -0,0 +1,28 @@
+'use strict';
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+if (common.isWindows)
+  common.skip('unsupported function on windows');
+
+const assert = require('assert');
+const spawn = require('child_process').spawn;
+
+let buffer = '';
+
+// Connect to debug agent
+const interfacer = spawn(process.execPath, ['inspect', '-p', '655555']);
+
+interfacer.stdout.setEncoding('utf-8');
+interfacer.stderr.setEncoding('utf-8');
+const onData = (data) => {
+  data = (buffer + data).split('\n');
+  buffer = data.pop();
+  data.forEach((line) => interfacer.emit('line', line));
+};
+interfacer.stdout.on('data', onData);
+interfacer.stderr.on('data', onData);
+
+interfacer.on('line', common.mustCall((line) => {
+  assert.strictEqual(line, 'Target process: 655555 doesn\'t exist.');
+}));
diff --git a/test/js/node/test/parallel/test-debugger-preserve-breaks.js b/test/js/node/test/parallel/test-debugger-preserve-breaks.js
new file mode 100644
index 0000000000..00168c570d
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-preserve-breaks.js
@@ -0,0 +1,47 @@
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
+
+const assert = require('assert');
+const path = require('path');
+
+const scriptFullPath = fixtures.path('debugger', 'three-lines.js');
+const script = path.relative(process.cwd(), scriptFullPath);
+
+// Run after quit.
+const runTest = async () => {
+  const cli = startCLI(['--port=0', script]);
+  try {
+    await cli.waitForInitialBreak();
+    await cli.waitForPrompt();
+    await cli.command('breakpoints');
+    assert.match(cli.output, /No breakpoints yet/);
+    await cli.command('sb(2)');
+    await cli.command('sb(3)');
+    await cli.command('breakpoints');
+    assert.ok(cli.output.includes(`#0 ${script}:2`));
+    assert.ok(cli.output.includes(`#1 ${script}:3`));
+    await cli.stepCommand('c'); // hit line 2
+    await cli.stepCommand('c'); // hit line 3
+    assert.deepStrictEqual(cli.breakInfo, { filename: script, line: 3 });
+    await cli.command('restart');
+    await cli.waitForInitialBreak();
+    assert.deepStrictEqual(cli.breakInfo, { filename: script, line: 1 });
+    await cli.stepCommand('c');
+    assert.deepStrictEqual(cli.breakInfo, { filename: script, line: 2 });
+    await cli.stepCommand('c');
+    assert.deepStrictEqual(cli.breakInfo, { filename: script, line: 3 });
+    await cli.command('breakpoints');
+    const msg = `SCRIPT: ${script}, OUTPUT: ${cli.output}`;
+    assert.ok(cli.output.includes(`#0 ${script}:2`), msg);
+    assert.ok(cli.output.includes(`#1 ${script}:3`), msg);
+  } finally {
+    await cli.quit();
+  }
+};
+
+runTest();
diff --git a/test/js/node/test/parallel/test-debugger-repeat-last.js b/test/js/node/test/parallel/test-debugger-repeat-last.js
new file mode 100644
index 0000000000..9a9b8eecdc
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-repeat-last.js
@@ -0,0 +1,45 @@
+'use strict';
+const common = require('../common');
+common.skipIfInspectorDisabled();
+const path = require('../common/fixtures').path;
+const spawn = require('child_process').spawn;
+const assert = require('assert');
+const fixture = path('debugger-repeat-last.js');
+
+const args = [
+  'inspect',
+  '--port=0',
+  fixture,
+];
+
+const proc = spawn(process.execPath, args, { stdio: 'pipe' });
+proc.stdout.setEncoding('utf8');
+
+let stdout = '';
+
+let sentCommand = false;
+let sentExit = false;
+
+proc.stdout.on('data', (data) => {
+  stdout += data;
+
+  // Send 'n' as the first step.
+  if (!sentCommand && stdout.includes('> 1 ')) {
+    setImmediate(() => { proc.stdin.write('n\n'); });
+    return sentCommand = true;
+  }
+  // Send empty (repeat last command) until we reach line 5.
+  if (sentCommand && !stdout.includes('> 5')) {
+    setImmediate(() => { proc.stdin.write('\n'); });
+    return true;
+  }
+  if (!sentExit && stdout.includes('> 5')) {
+    setTimeout(() => { proc.stdin.write('\n\n\n.exit\n\n\n'); }, 1);
+    return sentExit = true;
+  }
+});
+
+process.on('exit', (exitCode) => {
+  assert.strictEqual(exitCode, 0);
+  console.log(stdout);
+});
diff --git a/test/js/node/test/parallel/test-debugger-restart-message.js b/test/js/node/test/parallel/test-debugger-restart-message.js
new file mode 100644
index 0000000000..e4001b47ee
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-restart-message.js
@@ -0,0 +1,37 @@
+'use strict';
+
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const assert = require('assert');
+
+const RESTARTS = 10;
+
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
+
+// Using `restart` should result in only one "Connect/For help" message.
+{
+  const script = fixtures.path('debugger', 'three-lines.js');
+  const cli = startCLI(['--port=0', script]);
+
+  const listeningRegExp = /Debugger listening on/g;
+
+  async function onWaitForInitialBreak() {
+    try {
+      await cli.waitForInitialBreak();
+      await cli.waitForPrompt();
+      assert.strictEqual(cli.output.match(listeningRegExp).length, 1);
+
+      for (let i = 0; i < RESTARTS; i++) {
+        await cli.stepCommand('restart');
+        assert.strictEqual(cli.output.match(listeningRegExp).length, 1);
+      }
+    } finally {
+      await cli.quit();
+    }
+  }
+
+  onWaitForInitialBreak();
+}
diff --git a/test/js/node/test/parallel/test-delayed-require.js b/test/js/node/test/parallel/test-delayed-require.js
new file mode 100644
index 0000000000..355d503d26
--- /dev/null
+++ b/test/js/node/test/parallel/test-delayed-require.js
@@ -0,0 +1,32 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const fixtures = require('../common/fixtures');
+
+setTimeout(common.mustCall(function() {
+  const a = require(fixtures.path('a'));
+  assert.strictEqual('A' in a, true);
+  assert.strictEqual(a.A(), 'A');
+  assert.strictEqual(a.D(), 'D');
+}), 50);
diff --git a/test/js/node/test/parallel/test-dgram-abort-closed.js b/test/js/node/test/parallel/test-dgram-abort-closed.js
new file mode 100644
index 0000000000..6346b5feae
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-abort-closed.js
@@ -0,0 +1,10 @@
+'use strict';
+require('../common');
+const dgram = require('dgram');
+
+const controller = new AbortController();
+const socket = dgram.createSocket({ type: 'udp4', signal: controller.signal });
+
+socket.close();
+
+controller.abort();
diff --git a/test/js/node/test/parallel/test-dgram-bind-default-address.js b/test/js/node/test/parallel/test-dgram-bind-default-address.js
new file mode 100644
index 0000000000..130d614c58
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-bind-default-address.js
@@ -0,0 +1,53 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+// Skip test in FreeBSD jails since 0.0.0.0 will resolve to default interface
+if (common.inFreeBSDJail)
+  common.skip('In a FreeBSD jail');
+
+const assert = require('assert');
+const dgram = require('dgram');
+
+dgram.createSocket('udp4').bind(0, common.mustCall(function() {
+  assert.strictEqual(typeof this.address().port, 'number');
+  assert.ok(isFinite(this.address().port));
+  assert.ok(this.address().port > 0);
+  assert.strictEqual(this.address().address, '0.0.0.0');
+  this.close();
+}));
+
+if (!common.hasIPv6) {
+  common.printSkipMessage('udp6 part of test, because no IPv6 support');
+  return;
+}
+
+dgram.createSocket('udp6').bind(0, common.mustCall(function() {
+  assert.strictEqual(typeof this.address().port, 'number');
+  assert.ok(isFinite(this.address().port));
+  assert.ok(this.address().port > 0);
+  let address = this.address().address;
+  if (address === '::ffff:0.0.0.0')
+    address = '::';
+  assert.strictEqual(address, '::');
+  this.close();
+}));
diff --git a/test/js/node/test/parallel/test-dgram-bind.js b/test/js/node/test/parallel/test-dgram-bind.js
new file mode 100644
index 0000000000..8ae1213c7f
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-bind.js
@@ -0,0 +1,43 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const dgram = require('dgram');
+
+const socket = dgram.createSocket('udp4');
+
+socket.on('listening', common.mustCall(() => {
+  assert.throws(() => {
+    socket.bind();
+  }, {
+    code: 'ERR_SOCKET_ALREADY_BOUND',
+    name: 'Error',
+    message: /^Socket is already bound$/
+  });
+
+  socket.close();
+}));
+
+const result = socket.bind(); // Should not throw.
+
+assert.strictEqual(result, socket); // Should have returned itself.
diff --git a/test/js/node/test/parallel/test-dgram-bytes-length.js b/test/js/node/test/parallel/test-dgram-bytes-length.js
new file mode 100644
index 0000000000..abf8209b11
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-bytes-length.js
@@ -0,0 +1,39 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const dgram = require('dgram');
+
+const message = Buffer.from('Some bytes');
+const client = dgram.createSocket('udp4');
+client.send(
+  message,
+  0,
+  message.length,
+  41234,
+  'localhost',
+  function(err, bytes) {
+    assert.strictEqual(bytes, message.length);
+    client.close();
+  }
+);
diff --git a/test/js/node/test/parallel/test-dgram-close-in-listening.js b/test/js/node/test/parallel/test-dgram-close-in-listening.js
new file mode 100644
index 0000000000..ae3ab71d7e
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-close-in-listening.js
@@ -0,0 +1,26 @@
+'use strict';
+// Ensure that if a dgram socket is closed before the sendQueue is drained
+// will not crash
+
+const common = require('../common');
+const dgram = require('dgram');
+
+const buf = Buffer.alloc(1024, 42);
+
+const socket = dgram.createSocket('udp4');
+
+socket.on('listening', function() {
+  socket.close();
+});
+
+// Get a random port for send
+const portGetter = dgram.createSocket('udp4')
+  .bind(0, 'localhost', common.mustCall(() => {
+    // Adds a listener to 'listening' to send the data when
+    // the socket is available
+    socket.send(buf, 0, buf.length,
+                portGetter.address().port,
+                portGetter.address().address);
+
+    portGetter.close();
+  }));
diff --git a/test/js/node/test/parallel/test-dgram-close-is-not-callback.js b/test/js/node/test/parallel/test-dgram-close-is-not-callback.js
new file mode 100644
index 0000000000..bfb0bcd2bb
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-close-is-not-callback.js
@@ -0,0 +1,21 @@
+'use strict';
+const common = require('../common');
+const dgram = require('dgram');
+
+const buf = Buffer.alloc(1024, 42);
+
+const socket = dgram.createSocket('udp4');
+
+// Get a random port for send
+const portGetter = dgram.createSocket('udp4')
+  .bind(0, 'localhost', common.mustCall(() => {
+    socket.send(buf, 0, buf.length,
+                portGetter.address().port,
+                portGetter.address().address);
+
+    // If close callback is not function, ignore the argument.
+    socket.close('bad argument');
+    portGetter.close();
+
+    socket.on('close', common.mustCall());
+  }));
diff --git a/test/js/node/test/parallel/test-dgram-close-signal.js b/test/js/node/test/parallel/test-dgram-close-signal.js
new file mode 100644
index 0000000000..26de38b504
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-close-signal.js
@@ -0,0 +1,31 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const dgram = require('dgram');
+
+{
+  // Test bad signal.
+  assert.throws(
+    () => dgram.createSocket({ type: 'udp4', signal: {} }),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError'
+    });
+}
+
+{
+  // Test close.
+  const controller = new AbortController();
+  const { signal } = controller;
+  const server = dgram.createSocket({ type: 'udp4', signal });
+  server.on('close', common.mustCall());
+  controller.abort();
+}
+
+{
+  // Test close with pre-aborted signal.
+  const signal = AbortSignal.abort();
+  const server = dgram.createSocket({ type: 'udp4', signal });
+  server.on('close', common.mustCall());
+}
diff --git a/test/js/node/test/parallel/test-dgram-cluster-close-during-bind.js b/test/js/node/test/parallel/test-dgram-cluster-close-during-bind.js
new file mode 100644
index 0000000000..065ff094f1
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-cluster-close-during-bind.js
@@ -0,0 +1,38 @@
+'use strict';
+const common = require('../common');
+if (common.isWindows)
+  common.skip('dgram clustering is currently not supported on windows.');
+
+const assert = require('assert');
+const cluster = require('cluster');
+const dgram = require('dgram');
+
+if (cluster.isPrimary) {
+  cluster.fork();
+} else {
+  // When the socket attempts to bind, it requests a handle from the cluster.
+  // Close the socket before returning the handle from the cluster.
+  const socket = dgram.createSocket('udp4');
+  const _getServer = cluster._getServer;
+
+  cluster._getServer = common.mustCall(function(self, options, callback) {
+    socket.close(common.mustCall(() => {
+      _getServer.call(this, self, options, common.mustCall((err, handle) => {
+        assert.strictEqual(err, 0);
+
+        // When the socket determines that it was already closed, it will
+        // close the handle. Use handle.close() to terminate the test.
+        const close = handle.close;
+
+        handle.close = common.mustCall(function() {
+          setImmediate(() => cluster.worker.disconnect());
+          return close.call(this);
+        });
+
+        callback(err, handle);
+      }));
+    }));
+  });
+
+  socket.bind(common.mustNotCall('Socket should not bind.'));
+}
diff --git a/test/js/node/test/parallel/test-dgram-cluster-close-in-listening.js b/test/js/node/test/parallel/test-dgram-cluster-close-in-listening.js
new file mode 100644
index 0000000000..8cce540271
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-cluster-close-in-listening.js
@@ -0,0 +1,29 @@
+'use strict';
+// Ensure that closing dgram sockets in 'listening' callbacks of cluster workers
+// won't throw errors.
+
+const common = require('../common');
+const dgram = require('dgram');
+const cluster = require('cluster');
+if (common.isWindows)
+  common.skip('dgram clustering is currently not supported on windows.');
+
+if (cluster.isPrimary) {
+  for (let i = 0; i < 3; i += 1) {
+    cluster.fork();
+  }
+} else {
+  const socket = dgram.createSocket('udp4');
+
+  socket.on('error', common.mustNotCall());
+
+  socket.on('listening', common.mustCall(() => {
+    socket.close();
+  }));
+
+  socket.on('close', common.mustCall(() => {
+    cluster.worker.disconnect();
+  }));
+
+  socket.bind(0);
+}
diff --git a/test/js/node/test/parallel/test-dgram-connect-send-callback-buffer-length.js b/test/js/node/test/parallel/test-dgram-connect-send-callback-buffer-length.js
new file mode 100644
index 0000000000..723b2738e2
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-connect-send-callback-buffer-length.js
@@ -0,0 +1,23 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+
+const dgram = require('dgram');
+const client = dgram.createSocket('udp4');
+
+const buf = Buffer.allocUnsafe(256);
+const offset = 20;
+const len = buf.length - offset;
+
+const messageSent = common.mustSucceed(function messageSent(bytes) {
+  assert.notStrictEqual(bytes, buf.length);
+  assert.strictEqual(bytes, buf.length - offset);
+  client.close();
+});
+
+client.bind(0, common.mustCall(() => {
+  client.connect(client.address().port, common.mustCall(() => {
+    client.send(buf, offset, len, messageSent);
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-dgram-connect-send-callback-buffer.js b/test/js/node/test/parallel/test-dgram-connect-send-callback-buffer.js
new file mode 100644
index 0000000000..d6ef1f510c
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-connect-send-callback-buffer.js
@@ -0,0 +1,20 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const dgram = require('dgram');
+
+const client = dgram.createSocket('udp4');
+
+const buf = Buffer.allocUnsafe(256);
+
+const onMessage = common.mustSucceed((bytes) => {
+  assert.strictEqual(bytes, buf.length);
+  client.close();
+});
+
+client.bind(0, common.mustCall(() => {
+  client.connect(client.address().port, common.mustCall(() => {
+    client.send(buf, onMessage);
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-dgram-connect-send-callback-multi-buffer.js b/test/js/node/test/parallel/test-dgram-connect-send-callback-multi-buffer.js
new file mode 100644
index 0000000000..defc73697c
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-connect-send-callback-multi-buffer.js
@@ -0,0 +1,29 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const dgram = require('dgram');
+
+const client = dgram.createSocket('udp4');
+
+const messageSent = common.mustCall((err, bytes) => {
+  assert.strictEqual(bytes, buf1.length + buf2.length);
+});
+
+const buf1 = Buffer.alloc(256, 'x');
+const buf2 = Buffer.alloc(256, 'y');
+
+client.on('listening', common.mustCall(() => {
+  const port = client.address().port;
+  client.connect(port, common.mustCall(() => {
+    client.send([buf1, buf2], messageSent);
+  }));
+}));
+
+client.on('message', common.mustCall((buf, info) => {
+  const expected = Buffer.concat([buf1, buf2]);
+  assert.ok(buf.equals(expected), 'message was received correctly');
+  client.close();
+}));
+
+client.bind(0);
diff --git a/test/js/node/test/parallel/test-dgram-connect-send-default-host.js b/test/js/node/test/parallel/test-dgram-connect-send-default-host.js
new file mode 100644
index 0000000000..cd22cd2b64
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-connect-send-default-host.js
@@ -0,0 +1,48 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const dgram = require('dgram');
+
+const client = dgram.createSocket('udp4');
+const server = dgram.createSocket('udp4');
+
+const toSend = [Buffer.alloc(256, 'x'),
+                Buffer.alloc(256, 'y'),
+                Buffer.alloc(256, 'z'),
+                'hello'];
+
+const received = [];
+
+server.on('listening', common.mustCall(() => {
+  const port = server.address().port;
+  client.connect(port, (err) => {
+    assert.ifError(err);
+    client.send(toSend[0], 0, toSend[0].length);
+    client.send(toSend[1]);
+    client.send([toSend[2]]);
+    client.send(toSend[3], 0, toSend[3].length);
+
+    client.send(new Uint8Array(toSend[0]), 0, toSend[0].length);
+    client.send(new Uint8Array(toSend[1]));
+    client.send([new Uint8Array(toSend[2])]);
+    client.send(new Uint8Array(Buffer.from(toSend[3])),
+                0, toSend[3].length);
+  });
+}));
+
+server.on('message', common.mustCall((buf, info) => {
+  received.push(buf.toString());
+
+  if (received.length === toSend.length * 2) {
+    // The replies may arrive out of order -> sort them before checking.
+    received.sort();
+
+    const expected = toSend.concat(toSend).map(String).sort();
+    assert.deepStrictEqual(received, expected);
+    client.close();
+    server.close();
+  }
+}, toSend.length * 2));
+
+server.bind(0);
diff --git a/test/js/node/test/parallel/test-dgram-connect-send-empty-array.js b/test/js/node/test/parallel/test-dgram-connect-send-empty-array.js
new file mode 100644
index 0000000000..7727e43041
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-connect-send-empty-array.js
@@ -0,0 +1,22 @@
+'use strict';
+
+const common = require('../common');
+
+const assert = require('assert');
+const dgram = require('dgram');
+
+const client = dgram.createSocket('udp4');
+
+client.on('message', common.mustCall((buf, info) => {
+  const expected = Buffer.alloc(0);
+  assert.ok(buf.equals(expected), `Expected empty message but got ${buf}`);
+  client.close();
+}));
+
+client.on('listening', common.mustCall(() => {
+  client.connect(client.address().port,
+                 common.localhostIPv4,
+                 common.mustCall(() => client.send([])));
+}));
+
+client.bind(0);
diff --git a/test/js/node/test/parallel/test-dgram-connect-send-empty-buffer.js b/test/js/node/test/parallel/test-dgram-connect-send-empty-buffer.js
new file mode 100644
index 0000000000..bce4c82e5c
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-connect-send-empty-buffer.js
@@ -0,0 +1,20 @@
+'use strict';
+const common = require('../common');
+
+const assert = require('assert');
+const dgram = require('dgram');
+
+const client = dgram.createSocket('udp4');
+
+client.bind(0, common.mustCall(function() {
+  const port = this.address().port;
+  client.connect(port, common.mustCall(() => {
+    const buf = Buffer.alloc(0);
+    client.send(buf, 0, 0, common.mustSucceed());
+  }));
+
+  client.on('message', common.mustCall((buffer) => {
+    assert.strictEqual(buffer.length, 0);
+    client.close();
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-dgram-connect-send-empty-packet.js b/test/js/node/test/parallel/test-dgram-connect-send-empty-packet.js
new file mode 100644
index 0000000000..577a9cbefd
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-connect-send-empty-packet.js
@@ -0,0 +1,28 @@
+'use strict';
+const common = require('../common');
+
+const assert = require('assert');
+const dgram = require('dgram');
+
+const client = dgram.createSocket('udp4');
+
+client.bind(0, common.mustCall(function() {
+  client.connect(client.address().port, common.mustCall(() => {
+    client.on('message', common.mustCall(callback));
+    const buf = Buffer.alloc(1);
+
+    const interval = setInterval(function() {
+      client.send(buf, 0, 0, common.mustCall(callback));
+    }, 10);
+
+    function callback(firstArg) {
+      // If client.send() callback, firstArg should be null.
+      // If client.on('message') listener, firstArg should be a 0-length buffer.
+      if (firstArg instanceof Buffer) {
+        assert.strictEqual(firstArg.length, 0);
+        clearInterval(interval);
+        client.close();
+      }
+    }
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-dgram-connect-send-multi-buffer-copy.js b/test/js/node/test/parallel/test-dgram-connect-send-multi-buffer-copy.js
new file mode 100644
index 0000000000..0859a0cf86
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-connect-send-multi-buffer-copy.js
@@ -0,0 +1,29 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const dgram = require('dgram');
+
+const client = dgram.createSocket('udp4');
+
+const onMessage = common.mustCall(common.mustSucceed((bytes) => {
+  assert.strictEqual(bytes, buf1.length + buf2.length);
+}));
+
+const buf1 = Buffer.alloc(256, 'x');
+const buf2 = Buffer.alloc(256, 'y');
+
+client.on('listening', common.mustCall(function() {
+  const toSend = [buf1, buf2];
+  client.connect(client.address().port, common.mustCall(() => {
+    client.send(toSend, onMessage);
+  }));
+}));
+
+client.on('message', common.mustCall(function onMessage(buf, info) {
+  const expected = Buffer.concat([buf1, buf2]);
+  assert.ok(buf.equals(expected), 'message was received correctly');
+  client.close();
+}));
+
+client.bind(0);
diff --git a/test/js/node/test/parallel/test-dgram-connect-send-multi-string-array.js b/test/js/node/test/parallel/test-dgram-connect-send-multi-string-array.js
new file mode 100644
index 0000000000..e69aa82d47
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-connect-send-multi-string-array.js
@@ -0,0 +1,17 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const dgram = require('dgram');
+const socket = dgram.createSocket('udp4');
+const data = ['foo', 'bar', 'baz'];
+
+socket.on('message', common.mustCall((msg, rinfo) => {
+  socket.close();
+  assert.deepStrictEqual(msg.toString(), data.join(''));
+}));
+
+socket.bind(0, () => {
+  socket.connect(socket.address().port, common.mustCall(() => {
+    socket.send(data);
+  }));
+});
diff --git a/test/js/node/test/parallel/test-dgram-implicit-bind.js b/test/js/node/test/parallel/test-dgram-implicit-bind.js
new file mode 100644
index 0000000000..b5aa2781ce
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-implicit-bind.js
@@ -0,0 +1,46 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const dgram = require('dgram');
+
+const source = dgram.createSocket('udp4');
+const target = dgram.createSocket('udp4');
+let messages = 0;
+
+target.on('message', common.mustCall(function(buf) {
+  if (buf.toString() === 'abc') ++messages;
+  if (buf.toString() === 'def') ++messages;
+  if (messages === 2) {
+    source.close();
+    target.close();
+  }
+}, 2));
+
+target.on('listening', common.mustCall(function() {
+  // Second .send() call should not throw a bind error.
+  const port = this.address().port;
+  source.send(Buffer.from('abc'), 0, 3, port, '127.0.0.1');
+  source.send(Buffer.from('def'), 0, 3, port, '127.0.0.1');
+}));
+
+target.bind(0);
diff --git a/test/js/node/test/parallel/test-dgram-listen-after-bind.js b/test/js/node/test/parallel/test-dgram-listen-after-bind.js
new file mode 100644
index 0000000000..a580a2386b
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-listen-after-bind.js
@@ -0,0 +1,45 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const common = require('../common');
+const assert = require('assert');
+const dgram = require('dgram');
+
+const socket = dgram.createSocket('udp4');
+
+socket.bind();
+
+let fired = false;
+const timer = setTimeout(() => {
+  socket.close();
+}, 100);
+
+socket.on('listening', common.mustCall(() => {
+  clearTimeout(timer);
+  fired = true;
+  socket.close();
+}));
+
+socket.on('close', common.mustCall(() => {
+  assert(fired, 'listening should fire after bind');
+}));
diff --git a/test/js/node/test/parallel/test-dgram-oob-buffer.js b/test/js/node/test/parallel/test-dgram-oob-buffer.js
new file mode 100644
index 0000000000..1e71815927
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-oob-buffer.js
@@ -0,0 +1,45 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+// Some operating systems report errors when an UDP message is sent to an
+// unreachable host. This error can be reported by sendto() and even by
+// recvfrom(). Node should not propagate this error to the user.
+
+const common = require('../common');
+const dgram = require('dgram');
+
+const socket = dgram.createSocket('udp4');
+const buf = Buffer.from([1, 2, 3, 4]);
+const portGetter = dgram.createSocket('udp4')
+  .bind(0, 'localhost', common.mustCall(() => {
+    const { address, port } = portGetter.address();
+    portGetter.close(common.mustCall(() => {
+      socket.send(buf, 0, 0, port, address, common.mustNotCall());
+      socket.send(buf, 0, 4, port, address, common.mustNotCall());
+      socket.send(buf, 1, 3, port, address, common.mustNotCall());
+      socket.send(buf, 3, 1, port, address, common.mustNotCall());
+      // Since length of zero means nothing, don't error despite OOB.
+      socket.send(buf, 4, 0, port, address, common.mustNotCall());
+
+      socket.close();
+    }));
+  }));
diff --git a/test/js/node/test/parallel/test-dgram-ref.js b/test/js/node/test/parallel/test-dgram-ref.js
new file mode 100644
index 0000000000..0c5474b118
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-ref.js
@@ -0,0 +1,35 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const dgram = require('dgram');
+
+// Should not hang, see https://github.com/nodejs/node-v0.x-archive/issues/1282
+dgram.createSocket('udp4');
+dgram.createSocket('udp6');
+
+{
+  // Test the case of ref()'ing a socket with no handle.
+  const s = dgram.createSocket('udp4');
+
+  s.close(common.mustCall(() => s.ref()));
+}
diff --git a/test/js/node/test/parallel/test-dgram-send-callback-buffer-empty-address.js b/test/js/node/test/parallel/test-dgram-send-callback-buffer-empty-address.js
new file mode 100644
index 0000000000..f6254ec43e
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-send-callback-buffer-empty-address.js
@@ -0,0 +1,16 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const dgram = require('dgram');
+
+const client = dgram.createSocket('udp4');
+
+const buf = Buffer.alloc(256, 'x');
+
+const onMessage = common.mustSucceed((bytes) => {
+  assert.strictEqual(bytes, buf.length);
+  client.close();
+});
+
+client.bind(0, () => client.send(buf, client.address().port, onMessage));
diff --git a/test/js/node/test/parallel/test-dgram-send-callback-buffer-length-empty-address.js b/test/js/node/test/parallel/test-dgram-send-callback-buffer-length-empty-address.js
new file mode 100644
index 0000000000..a95018d14b
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-send-callback-buffer-length-empty-address.js
@@ -0,0 +1,21 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+
+const dgram = require('dgram');
+const client = dgram.createSocket('udp4');
+
+const buf = Buffer.alloc(256, 'x');
+const offset = 20;
+const len = buf.length - offset;
+
+const onMessage = common.mustSucceed(function messageSent(bytes) {
+  assert.notStrictEqual(bytes, buf.length);
+  assert.strictEqual(bytes, buf.length - offset);
+  client.close();
+});
+
+client.bind(0, () => client.send(buf, offset, len,
+                                 client.address().port,
+                                 onMessage));
diff --git a/test/js/node/test/parallel/test-dgram-send-callback-buffer-length.js b/test/js/node/test/parallel/test-dgram-send-callback-buffer-length.js
new file mode 100644
index 0000000000..f570ecb20d
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-send-callback-buffer-length.js
@@ -0,0 +1,43 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+
+const dgram = require('dgram');
+const client = dgram.createSocket('udp4');
+
+const buf = Buffer.allocUnsafe(256);
+const offset = 20;
+const len = buf.length - offset;
+
+const messageSent = common.mustSucceed(function messageSent(bytes) {
+  assert.notStrictEqual(bytes, buf.length);
+  assert.strictEqual(bytes, buf.length - offset);
+  client.close();
+});
+
+client.bind(0, () => client.send(buf, offset, len,
+                                 client.address().port,
+                                 '127.0.0.1',
+                                 messageSent));
diff --git a/test/js/node/test/parallel/test-dgram-send-callback-buffer.js b/test/js/node/test/parallel/test-dgram-send-callback-buffer.js
new file mode 100644
index 0000000000..11f8208de9
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-send-callback-buffer.js
@@ -0,0 +1,19 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const dgram = require('dgram');
+
+const client = dgram.createSocket('udp4');
+
+const buf = Buffer.allocUnsafe(256);
+
+const onMessage = common.mustSucceed((bytes) => {
+  assert.strictEqual(bytes, buf.length);
+  client.close();
+});
+
+client.bind(0, () => client.send(buf,
+                                 client.address().port,
+                                 common.localhostIPv4,
+                                 onMessage));
diff --git a/test/js/node/test/parallel/test-dgram-send-callback-multi-buffer-empty-address.js b/test/js/node/test/parallel/test-dgram-send-callback-multi-buffer-empty-address.js
new file mode 100644
index 0000000000..37e9e04c44
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-send-callback-multi-buffer-empty-address.js
@@ -0,0 +1,27 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const dgram = require('dgram');
+
+const client = dgram.createSocket('udp4');
+
+const messageSent = common.mustSucceed(function messageSent(bytes) {
+  assert.strictEqual(bytes, buf1.length + buf2.length);
+});
+
+const buf1 = Buffer.alloc(256, 'x');
+const buf2 = Buffer.alloc(256, 'y');
+
+client.on('listening', function() {
+  const port = this.address().port;
+  client.send([buf1, buf2], port, messageSent);
+});
+
+client.on('message', common.mustCall(function onMessage(buf) {
+  const expected = Buffer.concat([buf1, buf2]);
+  assert.ok(buf.equals(expected), 'message was received correctly');
+  client.close();
+}));
+
+client.bind(0);
diff --git a/test/js/node/test/parallel/test-dgram-send-callback-multi-buffer.js b/test/js/node/test/parallel/test-dgram-send-callback-multi-buffer.js
new file mode 100644
index 0000000000..09f01f6e8a
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-send-callback-multi-buffer.js
@@ -0,0 +1,27 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const dgram = require('dgram');
+
+const client = dgram.createSocket('udp4');
+
+const messageSent = common.mustCall((err, bytes) => {
+  assert.strictEqual(bytes, buf1.length + buf2.length);
+});
+
+const buf1 = Buffer.alloc(256, 'x');
+const buf2 = Buffer.alloc(256, 'y');
+
+client.on('listening', () => {
+  const port = client.address().port;
+  client.send([buf1, buf2], port, common.localhostIPv4, messageSent);
+});
+
+client.on('message', common.mustCall((buf, info) => {
+  const expected = Buffer.concat([buf1, buf2]);
+  assert.ok(buf.equals(expected), 'message was received correctly');
+  client.close();
+}));
+
+client.bind(0);
diff --git a/test/js/node/test/parallel/test-dgram-send-callback-recursive.js b/test/js/node/test/parallel/test-dgram-send-callback-recursive.js
new file mode 100644
index 0000000000..1a4c7c84fc
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-send-callback-recursive.js
@@ -0,0 +1,43 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+const dgram = require('dgram');
+const client = dgram.createSocket('udp4');
+const chunk = 'abc';
+let received = 0;
+let sent = 0;
+const limit = 10;
+let async = false;
+let port;
+
+function onsend() {
+  if (sent++ < limit) {
+    client.send(chunk, 0, chunk.length, port, common.localhostIPv4, onsend);
+  } else {
+    assert.strictEqual(async, true);
+  }
+}
+
+client.on('listening', function() {
+  port = this.address().port;
+
+  process.nextTick(() => {
+    async = true;
+  });
+
+  onsend();
+});
+
+client.on('message', (buf, info) => {
+  received++;
+  if (received === limit) {
+    client.close();
+  }
+});
+
+client.on('close', common.mustCall(function() {
+  assert.strictEqual(received, limit);
+}));
+
+client.bind(0);
diff --git a/test/js/node/test/parallel/test-dgram-send-empty-array.js b/test/js/node/test/parallel/test-dgram-send-empty-array.js
new file mode 100644
index 0000000000..178b72bb12
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-send-empty-array.js
@@ -0,0 +1,25 @@
+'use strict';
+
+const common = require('../common');
+
+const assert = require('assert');
+const dgram = require('dgram');
+
+const client = dgram.createSocket('udp4');
+
+let interval;
+
+client.on('message', common.mustCall(function onMessage(buf, info) {
+  const expected = Buffer.alloc(0);
+  assert.ok(buf.equals(expected), `Expected empty message but got ${buf}`);
+  clearInterval(interval);
+  client.close();
+}));
+
+client.on('listening', common.mustCall(function() {
+  interval = setInterval(function() {
+    client.send([], client.address().port, common.localhostIPv4);
+  }, 10);
+}));
+
+client.bind(0);
diff --git a/test/js/node/test/parallel/test-dgram-send-empty-buffer.js b/test/js/node/test/parallel/test-dgram-send-empty-buffer.js
new file mode 100644
index 0000000000..76b014b893
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-send-empty-buffer.js
@@ -0,0 +1,43 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+
+const assert = require('assert');
+const dgram = require('dgram');
+
+const client = dgram.createSocket('udp4');
+
+client.bind(0, common.mustCall(function() {
+  const port = this.address().port;
+
+  client.on('message', common.mustCall(function onMessage(buffer) {
+    assert.strictEqual(buffer.length, 0);
+    clearInterval(interval);
+    client.close();
+  }));
+
+  const buf = Buffer.alloc(0);
+  const interval = setInterval(function() {
+    client.send(buf, 0, 0, port, '127.0.0.1', common.mustCall());
+  }, 10);
+}));
diff --git a/test/js/node/test/parallel/test-dgram-send-empty-packet.js b/test/js/node/test/parallel/test-dgram-send-empty-packet.js
new file mode 100644
index 0000000000..eb4f79e8aa
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-send-empty-packet.js
@@ -0,0 +1,29 @@
+'use strict';
+const common = require('../common');
+
+const assert = require('assert');
+const dgram = require('dgram');
+
+const client = dgram.createSocket('udp4');
+
+client.bind(0, common.mustCall(function() {
+
+  client.on('message', common.mustCall(callback));
+
+  const port = this.address().port;
+  const buf = Buffer.alloc(1);
+
+  const interval = setInterval(function() {
+    client.send(buf, 0, 0, port, '127.0.0.1', common.mustCall(callback));
+  }, 10);
+
+  function callback(firstArg) {
+    // If client.send() callback, firstArg should be null.
+    // If client.on('message') listener, firstArg should be a 0-length buffer.
+    if (firstArg instanceof Buffer) {
+      assert.strictEqual(firstArg.length, 0);
+      clearInterval(interval);
+      client.close();
+    }
+  }
+}));
diff --git a/test/js/node/test/parallel/test-dgram-send-multi-buffer-copy.js b/test/js/node/test/parallel/test-dgram-send-multi-buffer-copy.js
new file mode 100644
index 0000000000..2ee87494b0
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-send-multi-buffer-copy.js
@@ -0,0 +1,28 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const dgram = require('dgram');
+
+const client = dgram.createSocket('udp4');
+
+const onMessage = common.mustCall(function(err, bytes) {
+  assert.strictEqual(bytes, buf1.length + buf2.length);
+});
+
+const buf1 = Buffer.alloc(256, 'x');
+const buf2 = Buffer.alloc(256, 'y');
+
+client.on('listening', function() {
+  const toSend = [buf1, buf2];
+  client.send(toSend, this.address().port, common.localhostIPv4, onMessage);
+  toSend.splice(0, 2);
+});
+
+client.on('message', common.mustCall(function onMessage(buf, info) {
+  const expected = Buffer.concat([buf1, buf2]);
+  assert.ok(buf.equals(expected), 'message was received correctly');
+  client.close();
+}));
+
+client.bind(0);
diff --git a/test/js/node/test/parallel/test-dgram-send-multi-string-array.js b/test/js/node/test/parallel/test-dgram-send-multi-string-array.js
new file mode 100644
index 0000000000..8d73a6d183
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-send-multi-string-array.js
@@ -0,0 +1,13 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const dgram = require('dgram');
+const socket = dgram.createSocket('udp4');
+const data = ['foo', 'bar', 'baz'];
+
+socket.on('message', common.mustCall((msg, rinfo) => {
+  socket.close();
+  assert.deepStrictEqual(msg.toString(), data.join(''));
+}));
+
+socket.bind(() => socket.send(data, socket.address().port, 'localhost'));
diff --git a/test/js/node/test/parallel/test-dgram-udp4.js b/test/js/node/test/parallel/test-dgram-udp4.js
new file mode 100644
index 0000000000..c7ee34b2c1
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-udp4.js
@@ -0,0 +1,52 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const dgram = require('dgram');
+const message_to_send = 'A message to send';
+
+const server = dgram.createSocket('udp4');
+server.on('message', common.mustCall((msg, rinfo) => {
+  assert.strictEqual(rinfo.address, common.localhostIPv4);
+  assert.strictEqual(msg.toString(), message_to_send.toString());
+  server.send(msg, 0, msg.length, rinfo.port, rinfo.address);
+}));
+server.on('listening', common.mustCall(() => {
+  const client = dgram.createSocket('udp4');
+  const port = server.address().port;
+  client.on('message', common.mustCall((msg, rinfo) => {
+    assert.strictEqual(rinfo.address, common.localhostIPv4);
+    assert.strictEqual(rinfo.port, port);
+    assert.strictEqual(msg.toString(), message_to_send.toString());
+    client.close();
+    server.close();
+  }));
+  client.send(message_to_send,
+              0,
+              message_to_send.length,
+              port,
+              'localhost');
+  client.on('close', common.mustCall());
+}));
+server.on('close', common.mustCall());
+server.bind(0);
diff --git a/test/js/node/test/parallel/test-dgram-unref-in-cluster.js b/test/js/node/test/parallel/test-dgram-unref-in-cluster.js
new file mode 100644
index 0000000000..40833a129d
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-unref-in-cluster.js
@@ -0,0 +1,23 @@
+'use strict';
+const common = require('../common');
+const dgram = require('dgram');
+const cluster = require('cluster');
+const assert = require('assert');
+
+if (common.isWindows)
+  common.skip('dgram clustering is currently not supported on Windows.');
+
+if (cluster.isPrimary) {
+  cluster.fork();
+} else {
+  const socket = dgram.createSocket('udp4');
+  socket.unref();
+  socket.bind();
+  socket.on('listening', common.mustCall(() => {
+    const sockets = process.getActiveResourcesInfo().filter((item) => {
+      return item === 'UDPWrap';
+    });
+    assert.ok(sockets.length === 0);
+    process.disconnect();
+  }));
+}
diff --git a/test/js/node/test/parallel/test-dgram-unref.js b/test/js/node/test/parallel/test-dgram-unref.js
new file mode 100644
index 0000000000..930cbf095c
--- /dev/null
+++ b/test/js/node/test/parallel/test-dgram-unref.js
@@ -0,0 +1,40 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const dgram = require('dgram');
+
+{
+  // Test the case of unref()'ing a socket with a handle.
+  const s = dgram.createSocket('udp4');
+  s.bind();
+  s.unref();
+}
+
+{
+  // Test the case of unref()'ing a socket with no handle.
+  const s = dgram.createSocket('udp4');
+
+  s.close(common.mustCall(() => s.unref()));
+}
+
+setTimeout(common.mustNotCall(), 1000).unref();
diff --git a/test/js/node/test/parallel/test-diagnostics-channel-bind-store.js b/test/js/node/test/parallel/test-diagnostics-channel-bind-store.js
new file mode 100644
index 0000000000..81fb299c2f
--- /dev/null
+++ b/test/js/node/test/parallel/test-diagnostics-channel-bind-store.js
@@ -0,0 +1,108 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const dc = require('diagnostics_channel');
+const { AsyncLocalStorage } = require('async_hooks');
+
+let n = 0;
+const thisArg = new Date();
+const inputs = [
+  { foo: 'bar' },
+  { baz: 'buz' },
+];
+
+const channel = dc.channel('test');
+
+// Bind a storage directly to published data
+const store1 = new AsyncLocalStorage();
+channel.bindStore(store1);
+let store1bound = true;
+
+// Bind a store with transformation of published data
+const store2 = new AsyncLocalStorage();
+channel.bindStore(store2, common.mustCall((data) => {
+  assert.strictEqual(data, inputs[n]);
+  return { data };
+}, 4));
+
+// Regular subscribers should see publishes from runStores calls
+channel.subscribe(common.mustCall((data) => {
+  if (store1bound) {
+    assert.deepStrictEqual(data, store1.getStore());
+  }
+  assert.deepStrictEqual({ data }, store2.getStore());
+  assert.strictEqual(data, inputs[n]);
+}, 4));
+
+// Verify stores are empty before run
+assert.strictEqual(store1.getStore(), undefined);
+assert.strictEqual(store2.getStore(), undefined);
+
+channel.runStores(inputs[n], common.mustCall(function(a, b) {
+  // Verify this and argument forwarding
+  assert.strictEqual(this, thisArg);
+  assert.strictEqual(a, 1);
+  assert.strictEqual(b, 2);
+
+  // Verify store 1 state matches input
+  assert.strictEqual(store1.getStore(), inputs[n]);
+
+  // Verify store 2 state has expected transformation
+  assert.deepStrictEqual(store2.getStore(), { data: inputs[n] });
+
+  // Should support nested contexts
+  n++;
+  channel.runStores(inputs[n], common.mustCall(function() {
+    // Verify this and argument forwarding
+    assert.strictEqual(this, undefined);
+
+    // Verify store 1 state matches input
+    assert.strictEqual(store1.getStore(), inputs[n]);
+
+    // Verify store 2 state has expected transformation
+    assert.deepStrictEqual(store2.getStore(), { data: inputs[n] });
+  }));
+  n--;
+
+  // Verify store 1 state matches input
+  assert.strictEqual(store1.getStore(), inputs[n]);
+
+  // Verify store 2 state has expected transformation
+  assert.deepStrictEqual(store2.getStore(), { data: inputs[n] });
+}), thisArg, 1, 2);
+
+// Verify stores are empty after run
+assert.strictEqual(store1.getStore(), undefined);
+assert.strictEqual(store2.getStore(), undefined);
+
+// Verify unbinding works
+assert.ok(channel.unbindStore(store1));
+store1bound = false;
+
+// Verify unbinding a store that is not bound returns false
+assert.ok(!channel.unbindStore(store1));
+
+n++;
+channel.runStores(inputs[n], common.mustCall(() => {
+  // Verify after unbinding store 1 will remain undefined
+  assert.strictEqual(store1.getStore(), undefined);
+
+  // Verify still bound store 2 receives expected data
+  assert.deepStrictEqual(store2.getStore(), { data: inputs[n] });
+}));
+
+// Contain transformer errors and emit on next tick
+const fail = new Error('fail');
+channel.bindStore(store1, () => {
+  throw fail;
+});
+
+let calledRunStores = false;
+process.once('uncaughtException', common.mustCall((err) => {
+  assert.strictEqual(calledRunStores, true);
+  assert.strictEqual(err, fail);
+}));
+
+channel.runStores(inputs[n], common.mustCall());
+calledRunStores = true;
diff --git a/test/js/node/test/parallel/test-diagnostics-channel-has-subscribers.js b/test/js/node/test/parallel/test-diagnostics-channel-has-subscribers.js
new file mode 100644
index 0000000000..de37267555
--- /dev/null
+++ b/test/js/node/test/parallel/test-diagnostics-channel-has-subscribers.js
@@ -0,0 +1,10 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const { channel, hasSubscribers } = require('diagnostics_channel');
+
+const dc = channel('test');
+assert.ok(!hasSubscribers('test'));
+
+dc.subscribe(() => {});
+assert.ok(hasSubscribers('test'));
diff --git a/test/js/node/test/parallel/test-diagnostics-channel-object-channel-pub-sub.js b/test/js/node/test/parallel/test-diagnostics-channel-object-channel-pub-sub.js
new file mode 100644
index 0000000000..9498419b80
--- /dev/null
+++ b/test/js/node/test/parallel/test-diagnostics-channel-object-channel-pub-sub.js
@@ -0,0 +1,46 @@
+'use strict';
+
+const common = require('../common');
+const dc = require('diagnostics_channel');
+const assert = require('assert');
+const { Channel } = dc;
+
+const input = {
+  foo: 'bar'
+};
+
+// Should not have named channel
+assert.ok(!dc.hasSubscribers('test'));
+
+// Individual channel objects can be created to avoid future lookups
+const channel = dc.channel('test');
+assert.ok(channel instanceof Channel);
+
+// No subscribers yet, should not publish
+assert.ok(!channel.hasSubscribers);
+
+const subscriber = common.mustCall((message, name) => {
+  assert.strictEqual(name, channel.name);
+  assert.deepStrictEqual(message, input);
+});
+
+// Now there's a subscriber, should publish
+channel.subscribe(subscriber);
+assert.ok(channel.hasSubscribers);
+
+// The ActiveChannel prototype swap should not fail instanceof
+assert.ok(channel instanceof Channel);
+
+// Should trigger the subscriber once
+channel.publish(input);
+
+// Should not publish after subscriber is unsubscribed
+assert.ok(channel.unsubscribe(subscriber));
+assert.ok(!channel.hasSubscribers);
+
+// unsubscribe() should return false when subscriber is not found
+assert.ok(!channel.unsubscribe(subscriber));
+
+assert.throws(() => {
+  channel.subscribe(null);
+}, { code: 'ERR_INVALID_ARG_TYPE' });
diff --git a/test/js/node/test/parallel/test-diagnostics-channel-pub-sub.js b/test/js/node/test/parallel/test-diagnostics-channel-pub-sub.js
new file mode 100644
index 0000000000..a7232ab58c
--- /dev/null
+++ b/test/js/node/test/parallel/test-diagnostics-channel-pub-sub.js
@@ -0,0 +1,51 @@
+'use strict';
+
+const common = require('../common');
+const dc = require('diagnostics_channel');
+const assert = require('assert');
+const { Channel } = dc;
+
+const name = 'test';
+const input = {
+  foo: 'bar'
+};
+
+// Individual channel objects can be created to avoid future lookups
+const channel = dc.channel(name);
+assert.ok(channel instanceof Channel);
+
+// No subscribers yet, should not publish
+assert.ok(!channel.hasSubscribers);
+
+const subscriber = common.mustCall((message, name) => {
+  assert.strictEqual(name, channel.name);
+  assert.deepStrictEqual(message, input);
+});
+
+// Now there's a subscriber, should publish
+dc.subscribe(name, subscriber);
+assert.ok(channel.hasSubscribers);
+
+// The ActiveChannel prototype swap should not fail instanceof
+assert.ok(channel instanceof Channel);
+
+// Should trigger the subscriber once
+channel.publish(input);
+
+// Should not publish after subscriber is unsubscribed
+assert.ok(dc.unsubscribe(name, subscriber));
+assert.ok(!channel.hasSubscribers);
+
+// unsubscribe() should return false when subscriber is not found
+assert.ok(!dc.unsubscribe(name, subscriber));
+
+assert.throws(() => {
+  dc.subscribe(name, null);
+}, { code: 'ERR_INVALID_ARG_TYPE' });
+
+// Reaching zero subscribers should not delete from the channels map as there
+// will be no more weakref to incRef if another subscribe happens while the
+// channel object itself exists.
+channel.subscribe(subscriber);
+channel.unsubscribe(subscriber);
+channel.subscribe(subscriber);
diff --git a/test/js/node/test/parallel/test-diagnostics-channel-safe-subscriber-errors.js b/test/js/node/test/parallel/test-diagnostics-channel-safe-subscriber-errors.js
new file mode 100644
index 0000000000..b0c5ab2480
--- /dev/null
+++ b/test/js/node/test/parallel/test-diagnostics-channel-safe-subscriber-errors.js
@@ -0,0 +1,29 @@
+'use strict';
+
+const common = require('../common');
+const dc = require('diagnostics_channel');
+const assert = require('assert');
+
+const input = {
+  foo: 'bar'
+};
+
+const channel = dc.channel('fail');
+
+const error = new Error('nope');
+
+process.on('uncaughtException', common.mustCall((err) => {
+  assert.strictEqual(err, error);
+}));
+
+channel.subscribe(common.mustCall((message, name) => {
+  throw error;
+}));
+
+// The failing subscriber should not stop subsequent subscribers from running
+channel.subscribe(common.mustCall());
+
+// Publish should continue without throwing
+const fn = common.mustCall();
+channel.publish(input);
+fn();
diff --git a/test/js/node/test/parallel/test-diagnostics-channel-sync-unsubscribe.js b/test/js/node/test/parallel/test-diagnostics-channel-sync-unsubscribe.js
new file mode 100644
index 0000000000..87bf44249f
--- /dev/null
+++ b/test/js/node/test/parallel/test-diagnostics-channel-sync-unsubscribe.js
@@ -0,0 +1,14 @@
+'use strict';
+
+const common = require('../common');
+const dc = require('node:diagnostics_channel');
+
+const channel_name = 'test:channel';
+const published_data = 'some message';
+
+const onMessageHandler = common.mustCall(() => dc.unsubscribe(channel_name, onMessageHandler));
+
+dc.subscribe(channel_name, onMessageHandler);
+
+// This must not throw.
+dc.channel(channel_name).publish(published_data);
diff --git a/test/js/node/test/parallel/test-diagnostics-channel-tracing-channel-callback-error.js b/test/js/node/test/parallel/test-diagnostics-channel-tracing-channel-callback-error.js
new file mode 100644
index 0000000000..672500e768
--- /dev/null
+++ b/test/js/node/test/parallel/test-diagnostics-channel-tracing-channel-callback-error.js
@@ -0,0 +1,36 @@
+'use strict';
+
+const common = require('../common');
+const dc = require('diagnostics_channel');
+const assert = require('assert');
+
+const channel = dc.tracingChannel('test');
+
+const expectedError = new Error('test');
+const input = { foo: 'bar' };
+const thisArg = { baz: 'buz' };
+
+function check(found) {
+  assert.deepStrictEqual(found, input);
+}
+
+const handlers = {
+  start: common.mustCall(check),
+  end: common.mustCall(check),
+  asyncStart: common.mustCall(check),
+  asyncEnd: common.mustCall(check),
+  error: common.mustCall((found) => {
+    check(found);
+    assert.deepStrictEqual(found.error, expectedError);
+  })
+};
+
+channel.subscribe(handlers);
+
+channel.traceCallback(function(cb, err) {
+  assert.deepStrictEqual(this, thisArg);
+  setImmediate(cb, err);
+}, 0, input, thisArg, common.mustCall((err, res) => {
+  assert.strictEqual(err, expectedError);
+  assert.strictEqual(res, undefined);
+}), expectedError);
diff --git a/test/js/node/test/parallel/test-diagnostics-channel-tracing-channel-callback-run-stores.js b/test/js/node/test/parallel/test-diagnostics-channel-tracing-channel-callback-run-stores.js
new file mode 100644
index 0000000000..874433efd2
--- /dev/null
+++ b/test/js/node/test/parallel/test-diagnostics-channel-tracing-channel-callback-run-stores.js
@@ -0,0 +1,29 @@
+'use strict';
+
+const common = require('../common');
+const { AsyncLocalStorage } = require('async_hooks');
+const dc = require('diagnostics_channel');
+const assert = require('assert');
+
+const channel = dc.tracingChannel('test');
+const store = new AsyncLocalStorage();
+
+const firstContext = { foo: 'bar' };
+const secondContext = { baz: 'buz' };
+
+channel.start.bindStore(store, common.mustCall(() => {
+  return firstContext;
+}));
+
+channel.asyncStart.bindStore(store, common.mustCall(() => {
+  return secondContext;
+}));
+
+assert.strictEqual(store.getStore(), undefined);
+channel.traceCallback(common.mustCall((cb) => {
+  assert.deepStrictEqual(store.getStore(), firstContext);
+  setImmediate(cb);
+}), 0, {}, null, common.mustCall(() => {
+  assert.deepStrictEqual(store.getStore(), secondContext);
+}));
+assert.strictEqual(store.getStore(), undefined);
diff --git a/test/js/node/test/parallel/test-diagnostics-channel-tracing-channel-callback.js b/test/js/node/test/parallel/test-diagnostics-channel-tracing-channel-callback.js
new file mode 100644
index 0000000000..d306f0f51b
--- /dev/null
+++ b/test/js/node/test/parallel/test-diagnostics-channel-tracing-channel-callback.js
@@ -0,0 +1,43 @@
+'use strict';
+
+const common = require('../common');
+const dc = require('diagnostics_channel');
+const assert = require('assert');
+
+const channel = dc.tracingChannel('test');
+
+const expectedResult = { foo: 'bar' };
+const input = { foo: 'bar' };
+const thisArg = { baz: 'buz' };
+
+function check(found) {
+  assert.deepStrictEqual(found, input);
+}
+
+function checkAsync(found) {
+  check(found);
+  assert.strictEqual(found.error, undefined);
+  assert.deepStrictEqual(found.result, expectedResult);
+}
+
+const handlers = {
+  start: common.mustCall(check),
+  end: common.mustCall(check),
+  asyncStart: common.mustCall(checkAsync),
+  asyncEnd: common.mustCall(checkAsync),
+  error: common.mustNotCall()
+};
+
+channel.subscribe(handlers);
+
+channel.traceCallback(function(cb, err, res) {
+  assert.deepStrictEqual(this, thisArg);
+  setImmediate(cb, err, res);
+}, 0, input, thisArg, common.mustCall((err, res) => {
+  assert.strictEqual(err, null);
+  assert.deepStrictEqual(res, expectedResult);
+}), null, expectedResult);
+
+assert.throws(() => {
+  channel.traceCallback(common.mustNotCall(), 0, input, thisArg, 1, 2, 3);
+}, /"callback" argument must be of type function/);
diff --git a/test/js/node/test/parallel/test-diagnostics-channel-tracing-channel-promise-run-stores.js b/test/js/node/test/parallel/test-diagnostics-channel-tracing-channel-promise-run-stores.js
new file mode 100644
index 0000000000..5292a6fe09
--- /dev/null
+++ b/test/js/node/test/parallel/test-diagnostics-channel-tracing-channel-promise-run-stores.js
@@ -0,0 +1,31 @@
+'use strict';
+
+const common = require('../common');
+const { setTimeout } = require('node:timers/promises');
+const { AsyncLocalStorage } = require('async_hooks');
+const dc = require('diagnostics_channel');
+const assert = require('assert');
+
+const channel = dc.tracingChannel('test');
+const store = new AsyncLocalStorage();
+
+const firstContext = { foo: 'bar' };
+const secondContext = { baz: 'buz' };
+
+channel.start.bindStore(store, common.mustCall(() => {
+  return firstContext;
+}));
+
+channel.asyncStart.bindStore(store, common.mustNotCall(() => {
+  return secondContext;
+}));
+
+assert.strictEqual(store.getStore(), undefined);
+channel.tracePromise(common.mustCall(async () => {
+  assert.deepStrictEqual(store.getStore(), firstContext);
+  await setTimeout(1);
+  // Should _not_ switch to second context as promises don't have an "after"
+  // point at which to do a runStores.
+  assert.deepStrictEqual(store.getStore(), firstContext);
+}));
+assert.strictEqual(store.getStore(), undefined);
diff --git a/test/js/node/test/parallel/test-diagnostics-channel-tracing-channel-promise.js b/test/js/node/test/parallel/test-diagnostics-channel-tracing-channel-promise.js
new file mode 100644
index 0000000000..20892ca40f
--- /dev/null
+++ b/test/js/node/test/parallel/test-diagnostics-channel-tracing-channel-promise.js
@@ -0,0 +1,41 @@
+'use strict';
+
+const common = require('../common');
+const dc = require('diagnostics_channel');
+const assert = require('assert');
+
+const channel = dc.tracingChannel('test');
+
+const expectedResult = { foo: 'bar' };
+const input = { foo: 'bar' };
+const thisArg = { baz: 'buz' };
+
+function check(found) {
+  assert.deepStrictEqual(found, input);
+}
+
+function checkAsync(found) {
+  check(found);
+  assert.strictEqual(found.error, undefined);
+  assert.deepStrictEqual(found.result, expectedResult);
+}
+
+const handlers = {
+  start: common.mustCall(check),
+  end: common.mustCall(check),
+  asyncStart: common.mustCall(checkAsync),
+  asyncEnd: common.mustCall(checkAsync),
+  error: common.mustNotCall()
+};
+
+channel.subscribe(handlers);
+
+channel.tracePromise(function(value) {
+  assert.deepStrictEqual(this, thisArg);
+  return Promise.resolve(value);
+}, input, thisArg, expectedResult).then(
+  common.mustCall((value) => {
+    assert.deepStrictEqual(value, expectedResult);
+  }),
+  common.mustNotCall()
+);
diff --git a/test/js/node/test/parallel/test-diagnostics-channel-tracing-channel-sync-error.js b/test/js/node/test/parallel/test-diagnostics-channel-tracing-channel-sync-error.js
new file mode 100644
index 0000000000..0965bf3fb4
--- /dev/null
+++ b/test/js/node/test/parallel/test-diagnostics-channel-tracing-channel-sync-error.js
@@ -0,0 +1,39 @@
+'use strict';
+
+const common = require('../common');
+const dc = require('diagnostics_channel');
+const assert = require('assert');
+
+const channel = dc.tracingChannel('test');
+
+const expectedError = new Error('test');
+const input = { foo: 'bar' };
+const thisArg = { baz: 'buz' };
+
+function check(found) {
+  assert.deepStrictEqual(found, input);
+}
+
+const handlers = {
+  start: common.mustCall(check),
+  end: common.mustCall(check),
+  asyncStart: common.mustNotCall(),
+  asyncEnd: common.mustNotCall(),
+  error: common.mustCall((found) => {
+    check(found);
+    assert.deepStrictEqual(found.error, expectedError);
+  })
+};
+
+channel.subscribe(handlers);
+try {
+  channel.traceSync(function(err) {
+    assert.deepStrictEqual(this, thisArg);
+    assert.strictEqual(err, expectedError);
+    throw err;
+  }, input, thisArg, expectedError);
+
+  throw new Error('It should not reach this error');
+} catch (error) {
+  assert.deepStrictEqual(error, expectedError);
+}
diff --git a/test/js/node/test/parallel/test-diagnostics-channel-tracing-channel-sync-run-stores.js b/test/js/node/test/parallel/test-diagnostics-channel-tracing-channel-sync-run-stores.js
new file mode 100644
index 0000000000..3ffe5e6720
--- /dev/null
+++ b/test/js/node/test/parallel/test-diagnostics-channel-tracing-channel-sync-run-stores.js
@@ -0,0 +1,21 @@
+'use strict';
+
+const common = require('../common');
+const { AsyncLocalStorage } = require('async_hooks');
+const dc = require('diagnostics_channel');
+const assert = require('assert');
+
+const channel = dc.tracingChannel('test');
+const store = new AsyncLocalStorage();
+
+const context = { foo: 'bar' };
+
+channel.start.bindStore(store, common.mustCall(() => {
+  return context;
+}));
+
+assert.strictEqual(store.getStore(), undefined);
+channel.traceSync(common.mustCall(() => {
+  assert.deepStrictEqual(store.getStore(), context);
+}));
+assert.strictEqual(store.getStore(), undefined);
diff --git a/test/js/node/test/parallel/test-diagnostics-channel-tracing-channel-sync.js b/test/js/node/test/parallel/test-diagnostics-channel-tracing-channel-sync.js
new file mode 100644
index 0000000000..b28b47256b
--- /dev/null
+++ b/test/js/node/test/parallel/test-diagnostics-channel-tracing-channel-sync.js
@@ -0,0 +1,46 @@
+'use strict';
+
+const common = require('../common');
+const dc = require('diagnostics_channel');
+const assert = require('assert');
+
+const channel = dc.tracingChannel('test');
+
+const expectedResult = { foo: 'bar' };
+const input = { foo: 'bar' };
+const thisArg = { baz: 'buz' };
+const arg = { baz: 'buz' };
+
+function check(found) {
+  assert.strictEqual(found, input);
+}
+
+const handlers = {
+  start: common.mustCall(check),
+  end: common.mustCall((found) => {
+    check(found);
+    assert.strictEqual(found.result, expectedResult);
+  }),
+  asyncStart: common.mustNotCall(),
+  asyncEnd: common.mustNotCall(),
+  error: common.mustNotCall()
+};
+
+assert.strictEqual(channel.start.hasSubscribers, false);
+channel.subscribe(handlers);
+assert.strictEqual(channel.start.hasSubscribers, true);
+const result1 = channel.traceSync(function(arg1) {
+  assert.strictEqual(arg1, arg);
+  assert.strictEqual(this, thisArg);
+  return expectedResult;
+}, input, thisArg, arg);
+assert.strictEqual(result1, expectedResult);
+
+channel.unsubscribe(handlers);
+assert.strictEqual(channel.start.hasSubscribers, false);
+const result2 = channel.traceSync(function(arg1) {
+  assert.strictEqual(arg1, arg);
+  assert.strictEqual(this, thisArg);
+  return expectedResult;
+}, input, thisArg, arg);
+assert.strictEqual(result2, expectedResult);
diff --git a/test/js/node/test/parallel/test-diagnostics-channel-udp.js b/test/js/node/test/parallel/test-diagnostics-channel-udp.js
new file mode 100644
index 0000000000..79869c6d80
--- /dev/null
+++ b/test/js/node/test/parallel/test-diagnostics-channel-udp.js
@@ -0,0 +1,15 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const dgram = require('dgram');
+const dc = require('diagnostics_channel');
+
+const udpSocketChannel = dc.channel('udp.socket');
+
+const isUDPSocket = (socket) => socket instanceof dgram.Socket;
+
+udpSocketChannel.subscribe(common.mustCall(({ socket }) => {
+  assert.strictEqual(isUDPSocket(socket), true);
+}));
+const socket = dgram.createSocket('udp4');
+socket.close();
diff --git a/test/js/node/test/parallel/test-domain-crypto.js b/test/js/node/test/parallel/test-domain-crypto.js
new file mode 100644
index 0000000000..e0a470bd9d
--- /dev/null
+++ b/test/js/node/test/parallel/test-domain-crypto.js
@@ -0,0 +1,43 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+
+const common = require('../common');
+
+if (!common.hasCrypto)
+  common.skip('node compiled without OpenSSL.');
+
+const crypto = require('crypto');
+
+// Pollution of global is intentional as part of test.
+common.allowGlobals(require('domain'));
+// See https://github.com/nodejs/node/commit/d1eff9ab
+global.domain = require('domain');
+
+// Should not throw a 'TypeError: undefined is not a function' exception
+crypto.randomBytes(8);
+crypto.randomBytes(8, common.mustSucceed());
+const buf = Buffer.alloc(8);
+crypto.randomFillSync(buf);
+crypto.pseudoRandomBytes(8);
+crypto.pseudoRandomBytes(8, common.mustSucceed());
+crypto.pbkdf2('password', 'salt', 8, 8, 'sha1', common.mustSucceed());
diff --git a/test/js/node/test/parallel/test-domain-ee-error-listener.js b/test/js/node/test/parallel/test-domain-ee-error-listener.js
new file mode 100644
index 0000000000..69041c7523
--- /dev/null
+++ b/test/js/node/test/parallel/test-domain-ee-error-listener.js
@@ -0,0 +1,20 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const domain = require('domain').create();
+const EventEmitter = require('events');
+
+domain.on('error', common.mustNotCall());
+
+const ee = new EventEmitter();
+
+const plainObject = { justAn: 'object' };
+ee.once('error', common.mustCall((err) => {
+  assert.deepStrictEqual(err, plainObject);
+}));
+ee.emit('error', plainObject);
+
+const err = new Error('test error');
+ee.once('error', common.expectsError(err));
+ee.emit('error', err);
diff --git a/test/js/node/test/parallel/test-domain-nested-throw.js b/test/js/node/test/parallel/test-domain-nested-throw.js
new file mode 100644
index 0000000000..ec016ada72
--- /dev/null
+++ b/test/js/node/test/parallel/test-domain-nested-throw.js
@@ -0,0 +1,101 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+
+const domain = require('domain');
+
+if (process.argv[2] !== 'child') {
+  parent();
+  return;
+}
+
+function parent() {
+  const node = process.execPath;
+  const spawn = require('child_process').spawn;
+  const opt = { stdio: 'inherit' };
+  const child = spawn(node, [__filename, 'child'], opt);
+  child.on('exit', function(c) {
+    assert(!c);
+    console.log('ok');
+  });
+}
+
+let gotDomain1Error = false;
+let gotDomain2Error = false;
+
+let threw1 = false;
+let threw2 = false;
+
+function throw1() {
+  threw1 = true;
+  throw new Error('handled by domain1');
+}
+
+function throw2() {
+  threw2 = true;
+  throw new Error('handled by domain2');
+}
+
+function inner(throw1, throw2) {
+  const domain1 = domain.createDomain();
+
+  domain1.on('error', function(err) {
+    if (gotDomain1Error) {
+      console.error('got domain 1 twice');
+      process.exit(1);
+    }
+    gotDomain1Error = true;
+    throw2();
+  });
+
+  domain1.run(function() {
+    throw1();
+  });
+}
+
+function outer() {
+  const domain2 = domain.createDomain();
+
+  domain2.on('error', function(err) {
+    if (gotDomain2Error) {
+      console.error('got domain 2 twice');
+      process.exit(1);
+    }
+    gotDomain2Error = true;
+  });
+
+  domain2.run(function() {
+    inner(throw1, throw2);
+  });
+}
+
+process.on('exit', function() {
+  assert(gotDomain1Error);
+  assert(gotDomain2Error);
+  assert(threw1);
+  assert(threw2);
+  console.log('ok');
+});
+
+outer();
diff --git a/test/js/node/test/parallel/test-domain-vm-promise-isolation.js b/test/js/node/test/parallel/test-domain-vm-promise-isolation.js
new file mode 100644
index 0000000000..41aed1ee33
--- /dev/null
+++ b/test/js/node/test/parallel/test-domain-vm-promise-isolation.js
@@ -0,0 +1,28 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const domain = require('domain');
+const vm = require('vm');
+
+// A promise created in a VM should not include a domain field but
+// domains should still be able to propagate through them.
+//
+// See; https://github.com/nodejs/node/issues/40999
+
+const context = vm.createContext({});
+
+function run(code) {
+  const d = domain.createDomain();
+  d.run(common.mustCall(() => {
+    const p = vm.runInContext(code, context)();
+    assert.strictEqual(p.domain, undefined);
+    p.then(common.mustCall(() => {
+      assert.strictEqual(process.domain, d);
+    }));
+  }));
+}
+
+for (let i = 0; i < 1000; i++) {
+  run('async () => null');
+}
diff --git a/test/js/node/test/parallel/test-dsa-fips-invalid-key.js b/test/js/node/test/parallel/test-dsa-fips-invalid-key.js
new file mode 100644
index 0000000000..05cc1d143a
--- /dev/null
+++ b/test/js/node/test/parallel/test-dsa-fips-invalid-key.js
@@ -0,0 +1,19 @@
+'use strict';
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+
+if (!common.hasFipsCrypto)
+  common.skip('node compiled without FIPS OpenSSL.');
+
+const assert = require('assert');
+const crypto = require('crypto');
+
+const input = 'hello';
+
+const dsapri = fixtures.readKey('dsa_private_1025.pem');
+const sign = crypto.createSign('SHA1');
+sign.update(input);
+
+assert.throws(function() {
+  sign.sign(dsapri);
+}, /PEM_read_bio_PrivateKey failed/);
diff --git a/test/js/node/test/parallel/test-error-prepare-stack-trace.js b/test/js/node/test/parallel/test-error-prepare-stack-trace.js
new file mode 100644
index 0000000000..1ad29efb16
--- /dev/null
+++ b/test/js/node/test/parallel/test-error-prepare-stack-trace.js
@@ -0,0 +1,30 @@
+'use strict';
+
+require('../common');
+const { spawnSyncAndExitWithoutError } = require('../common/child_process');
+const assert = require('assert');
+
+// Verify that the default Error.prepareStackTrace is present.
+assert.strictEqual(typeof Error.prepareStackTrace, 'function');
+
+// Error.prepareStackTrace() can be overridden.
+{
+  let prepareCalled = false;
+  Error.prepareStackTrace = (_error, trace) => {
+    prepareCalled = true;
+  };
+  try {
+    throw new Error('foo');
+  } catch (err) {
+    err.stack; // eslint-disable-line no-unused-expressions
+  }
+  assert(prepareCalled);
+}
+
+if (process.argv[2] !== 'child') {
+  // Verify that the above test still passes when source-maps support is
+  // enabled.
+  spawnSyncAndExitWithoutError(
+    process.execPath,
+    ['--enable-source-maps', __filename, 'child']);
+}
diff --git a/test/js/node/test/parallel/test-eslint-alphabetize-errors.js b/test/js/node/test/parallel/test-eslint-alphabetize-errors.js
new file mode 100644
index 0000000000..18c3aed3af
--- /dev/null
+++ b/test/js/node/test/parallel/test-eslint-alphabetize-errors.js
@@ -0,0 +1,63 @@
+'use strict';
+
+const common = require('../common');
+if ((!common.hasCrypto) || (!common.hasIntl)) {
+  common.skip('ESLint tests require crypto and Intl');
+}
+common.skipIfEslintMissing();
+
+const RuleTester = require('../../tools/eslint/node_modules/eslint').RuleTester;
+const rule = require('../../tools/eslint-rules/alphabetize-errors');
+
+new RuleTester().run('alphabetize-errors', rule, {
+  valid: [
+    { code: `
+      E('AAA', 'foo');
+      E('BBB', 'bar');
+      E('CCC', 'baz');
+    `, options: [{ checkErrorDeclarations: true }] },
+    `
+      E('AAA', 'foo');
+      E('CCC', 'baz');
+      E('BBB', 'bar');
+    `,
+    `const {
+      codes: {
+        ERR_A,
+        ERR_B,
+      },
+    } = require("internal/errors")`,
+  ],
+  invalid: [
+    {
+      code: `
+        E('BBB', 'bar');
+        E('AAA', 'foo');
+        E('CCC', 'baz');
+      `,
+      options: [{ checkErrorDeclarations: true }],
+      errors: [{ message: 'Out of ASCIIbetical order - BBB >= AAA', line: 3 }]
+    },
+    {
+      code: `const {
+        codes: {
+          ERR_B,
+          ERR_A,
+        },
+      } = require("internal/errors")`,
+      errors: [{ message: 'Out of ASCIIbetical order - ERR_B >= ERR_A', line: 4 }]
+    },
+    {
+      code: 'const internalErrors = require("internal/errors")',
+      errors: [{ message: /Use destructuring/ }]
+    },
+    {
+      code: 'const {codes} = require("internal/errors")',
+      errors: [{ message: /Use destructuring/ }]
+    },
+    {
+      code: 'const {codes:{ERR_A}} = require("internal/errors")',
+      errors: [{ message: /Use multiline destructuring/ }]
+    },
+  ]
+});
diff --git a/test/js/node/test/parallel/test-eslint-alphabetize-primordials.js b/test/js/node/test/parallel/test-eslint-alphabetize-primordials.js
new file mode 100644
index 0000000000..3f63e1ecbd
--- /dev/null
+++ b/test/js/node/test/parallel/test-eslint-alphabetize-primordials.js
@@ -0,0 +1,54 @@
+'use strict';
+
+const common = require('../common');
+if ((!common.hasCrypto) || (!common.hasIntl)) {
+  common.skip('ESLint tests require crypto and Intl');
+}
+
+common.skipIfEslintMissing();
+
+const RuleTester = require('../../tools/eslint/node_modules/eslint').RuleTester;
+const rule = require('../../tools/eslint-rules/alphabetize-primordials');
+
+new RuleTester()
+  .run('alphabetize-primordials', rule, {
+    valid: [
+      'new Array()',
+      '"use strict";const {\nArray\n} = primordials;',
+      '"use strict";const {\n\tArray,\n\tDate,\n} = primordials',
+      '"use strict";const {\nDate,Array\n} = notPrimordials',
+      '"use strict";const {\nDate,globalThis:{Array}\n} = primordials',
+      '"use strict";const {\nBigInt,globalThis:{Array,Date,SharedArrayBuffer,parseInt}\n} = primordials',
+      '"use strict";const {\nFunctionPrototypeBind,Uint32Array,globalThis:{SharedArrayBuffer}\n} = primordials',
+      {
+        code: '"use strict";const fs = require("fs");const {\nArray\n} = primordials',
+        options: [{ enforceTopPosition: false }],
+      },
+    ],
+    invalid: [
+      {
+        code: '"use strict";const {Array} = primordials;',
+        errors: [{ message: /destructuring from primordials should be multiline/ }],
+      },
+      {
+        code: '"use strict";const fs = require("fs");const {Date,Array} = primordials',
+        errors: [
+          { message: /destructuring from primordials should be multiline/ },
+          { message: /destructuring from primordials should be the first expression/ },
+          { message: /Date >= Array/ },
+        ],
+      },
+      {
+        code: 'function fn() {"use strict";const {\nArray,\n} = primordials}',
+        errors: [{ message: /destructuring from primordials should be the first expression/ }],
+      },
+      {
+        code: '"use strict";const {\nDate,Array} = primordials',
+        errors: [{ message: /Date >= Array/ }],
+      },
+      {
+        code: '"use strict";const {\nglobalThis:{Date, Array}} = primordials',
+        errors: [{ message: /Date >= Array/ }],
+      },
+    ]
+  });
diff --git a/test/js/node/test/parallel/test-eslint-async-iife-no-unused-result.js b/test/js/node/test/parallel/test-eslint-async-iife-no-unused-result.js
new file mode 100644
index 0000000000..9f74b65868
--- /dev/null
+++ b/test/js/node/test/parallel/test-eslint-async-iife-no-unused-result.js
@@ -0,0 +1,48 @@
+'use strict';
+const common = require('../common');
+if ((!common.hasCrypto) || (!common.hasIntl)) {
+  common.skip('ESLint tests require crypto and Intl');
+}
+common.skipIfEslintMissing();
+
+const RuleTester = require('../../tools/eslint/node_modules/eslint').RuleTester;
+const rule = require('../../tools/eslint-rules/async-iife-no-unused-result');
+
+const message = 'The result of an immediately-invoked async function needs ' +
+  'to be used (e.g. with `.then(common.mustCall())`)';
+
+const tester = new RuleTester();
+tester.run('async-iife-no-unused-result', rule, {
+  valid: [
+    '(() => {})()',
+    '(async () => {})',
+    '(async () => {})().then()',
+    '(async () => {})().catch()',
+    '(function () {})()',
+    '(async function () {})',
+    '(async function () {})().then()',
+    '(async function () {})().catch()',
+  ],
+  invalid: [
+    {
+      code: '(async () => {})()',
+      errors: [{ message }],
+    },
+    {
+      code: '(async function() {})()',
+      errors: [{ message }],
+    },
+    {
+      code: "const common = require('../common');(async () => {})()",
+      errors: [{ message }],
+      output: "const common = require('../common');(async () => {})()" +
+        '.then(common.mustCall())',
+    },
+    {
+      code: "const common = require('../common');(async function() {})()",
+      errors: [{ message }],
+      output: "const common = require('../common');(async function() {})()" +
+        '.then(common.mustCall())',
+    },
+  ]
+});
diff --git a/test/js/node/test/parallel/test-eslint-avoid-prototype-pollution.js b/test/js/node/test/parallel/test-eslint-avoid-prototype-pollution.js
new file mode 100644
index 0000000000..c6b0fe6386
--- /dev/null
+++ b/test/js/node/test/parallel/test-eslint-avoid-prototype-pollution.js
@@ -0,0 +1,334 @@
+'use strict';
+
+const common = require('../common');
+if ((!common.hasCrypto) || (!common.hasIntl)) {
+  common.skip('ESLint tests require crypto and Intl');
+}
+
+common.skipIfEslintMissing();
+
+const RuleTester = require('../../tools/eslint/node_modules/eslint').RuleTester;
+const rule = require('../../tools/eslint-rules/avoid-prototype-pollution');
+
+new RuleTester()
+  .run('property-descriptor-no-prototype-pollution', rule, {
+    valid: [
+      'ObjectDefineProperties({}, {})',
+      'ObjectCreate(null, {})',
+      'ObjectDefineProperties({}, { key })',
+      'ObjectCreate(null, { key })',
+      'ObjectDefineProperties({}, { ...spread })',
+      'ObjectCreate(null, { ...spread })',
+      'ObjectDefineProperties({}, { key: valueDescriptor })',
+      'ObjectCreate(null, { key: valueDescriptor })',
+      'ObjectDefineProperties({}, { key: { ...{}, __proto__: null } })',
+      'ObjectCreate(null, { key: { ...{}, __proto__: null } })',
+      'ObjectDefineProperties({}, { key: { __proto__: null } })',
+      'ObjectCreate(null, { key: { __proto__: null } })',
+      'ObjectDefineProperties({}, { key: { __proto__: null, enumerable: true } })',
+      'ObjectCreate(null, { key: { __proto__: null, enumerable: true } })',
+      'ObjectDefineProperties({}, { key: { "__proto__": null } })',
+      'ObjectCreate(null, { key: { "__proto__": null } })',
+      'ObjectDefineProperties({}, { key: { \'__proto__\': null } })',
+      'ObjectCreate(null, { key: { \'__proto__\': null } })',
+      'ObjectDefineProperty({}, "key", ObjectCreate(null))',
+      'ReflectDefineProperty({}, "key", ObjectCreate(null))',
+      'ObjectDefineProperty({}, "key", valueDescriptor)',
+      'ReflectDefineProperty({}, "key", valueDescriptor)',
+      'ObjectDefineProperty({}, "key", { __proto__: null })',
+      'ReflectDefineProperty({}, "key", { __proto__: null })',
+      'ObjectDefineProperty({}, "key", { __proto__: null, enumerable: true })',
+      'ReflectDefineProperty({}, "key", { __proto__: null, enumerable: true })',
+      'ObjectDefineProperty({}, "key", { "__proto__": null })',
+      'ReflectDefineProperty({}, "key", { "__proto__": null })',
+      'ObjectDefineProperty({}, "key", { \'__proto__\': null })',
+      'ReflectDefineProperty({}, "key", { \'__proto__\': null })',
+      'async function myFn() { return { __proto__: null } }',
+      'async function myFn() { function myFn() { return {} } return { __proto__: null } }',
+      'const myFn = async function myFn() { return { __proto__: null } }',
+      'const myFn = async function () { return { __proto__: null } }',
+      'const myFn = async () => { return { __proto__: null } }',
+      'const myFn = async () => ({ __proto__: null })',
+      'function myFn() { return {} }',
+      'const myFn = function myFn() { return {} }',
+      'const myFn = function () { return {} }',
+      'const myFn = () => { return {} }',
+      'const myFn = () => ({})',
+      'StringPrototypeReplace("some string", "some string", "some replacement")',
+      'StringPrototypeReplaceAll("some string", "some string", "some replacement")',
+      'StringPrototypeSplit("some string", "some string")',
+      'new Proxy({}, otherObject)',
+      'new Proxy({}, someFactory())',
+      'new Proxy({}, { __proto__: null })',
+      'new Proxy({}, { __proto__: null, ...{} })',
+      'async function name(){return await SafePromiseAll([])}',
+      'async function name(){const val = await SafePromiseAll([])}',
+    ],
+    invalid: [
+      {
+        code: 'ObjectDefineProperties({}, ObjectGetOwnPropertyDescriptors({}))',
+        errors: [{ message: /prototype pollution/ }],
+      },
+      {
+        code: 'ObjectCreate(null, ObjectGetOwnPropertyDescriptors({}))',
+        errors: [{ message: /prototype pollution/ }],
+      },
+      {
+        code: 'ObjectDefineProperties({}, { key: {} })',
+        errors: [{ message: /null-prototype/ }],
+      },
+      {
+        code: 'ObjectCreate(null, { key: {} })',
+        errors: [{ message: /null-prototype/ }],
+      },
+      {
+        code: 'ObjectDefineProperties({}, { key: { [void 0]: { ...{ __proto__: null } } } })',
+        errors: [{ message: /null-prototype/ }],
+      },
+      {
+        code: 'ObjectCreate(null, { key: { [void 0]: { ...{ __proto__: null } } } })',
+        errors: [{ message: /null-prototype/ }],
+      },
+      {
+        code: 'ObjectDefineProperties({}, { key: { __proto__: Object.prototype } })',
+        errors: [{ message: /null-prototype/ }],
+      },
+      {
+        code: 'ObjectCreate(null, { key: { __proto__: Object.prototype } })',
+        errors: [{ message: /null-prototype/ }],
+      },
+      {
+        code: 'ObjectDefineProperties({}, { key: { [`__proto__`]: null } })',
+        errors: [{ message: /null-prototype/ }],
+      },
+      {
+        code: 'ObjectCreate(null, { key: { [`__proto__`]: null } })',
+        errors: [{ message: /null-prototype/ }],
+      },
+      {
+        code: 'ObjectDefineProperties({}, { key: { enumerable: true } })',
+        errors: [{ message: /null-prototype/ }],
+      },
+      {
+        code: 'ObjectCreate(null, { key: { enumerable: true } })',
+        errors: [{ message: /null-prototype/ }],
+      },
+      {
+        code: 'ObjectDefineProperty({}, "key", {})',
+        errors: [{ message: /null-prototype/ }],
+      },
+      {
+        code: 'ReflectDefineProperty({}, "key", {})',
+        errors: [{ message: /null-prototype/ }],
+      },
+      {
+        code: 'ObjectDefineProperty({}, "key", ObjectGetOwnPropertyDescriptor({}, "key"))',
+        errors: [{
+          message: /prototype pollution/,
+          suggestions: [{
+            desc: 'Wrap the property descriptor in a null-prototype object',
+            output: 'ObjectDefineProperty({}, "key", { __proto__: null,...ObjectGetOwnPropertyDescriptor({}, "key") })',
+          }],
+        }],
+      },
+      {
+        code: 'ReflectDefineProperty({}, "key", ObjectGetOwnPropertyDescriptor({}, "key"))',
+        errors: [{
+          message: /prototype pollution/,
+          suggestions: [{
+            desc: 'Wrap the property descriptor in a null-prototype object',
+            output:
+              'ReflectDefineProperty({}, "key", { __proto__: null,...ObjectGetOwnPropertyDescriptor({}, "key") })',
+          }],
+        }],
+      },
+      {
+        code: 'ObjectDefineProperty({}, "key", ReflectGetOwnPropertyDescriptor({}, "key"))',
+        errors: [{
+          message: /prototype pollution/,
+          suggestions: [{
+            desc: 'Wrap the property descriptor in a null-prototype object',
+            output:
+              'ObjectDefineProperty({}, "key", { __proto__: null,...ReflectGetOwnPropertyDescriptor({}, "key") })',
+          }],
+        }],
+      },
+      {
+        code: 'ReflectDefineProperty({}, "key", ReflectGetOwnPropertyDescriptor({}, "key"))',
+        errors: [{
+          message: /prototype pollution/,
+          suggestions: [{
+            desc: 'Wrap the property descriptor in a null-prototype object',
+            output:
+              'ReflectDefineProperty({}, "key", { __proto__: null,...ReflectGetOwnPropertyDescriptor({}, "key") })',
+          }],
+        }],
+      },
+      {
+        code: 'ObjectDefineProperty({}, "key", { __proto__: Object.prototype })',
+        errors: [{ message: /null-prototype/ }],
+      },
+      {
+        code: 'ReflectDefineProperty({}, "key", { __proto__: Object.prototype })',
+        errors: [{ message: /null-prototype/ }],
+      },
+      {
+        code: 'ObjectDefineProperty({}, "key", { [`__proto__`]: null })',
+        errors: [{ message: /null-prototype/ }],
+      },
+      {
+        code: 'ReflectDefineProperty({}, "key", { [`__proto__`]: null })',
+        errors: [{ message: /null-prototype/ }],
+      },
+      {
+        code: 'ObjectDefineProperty({}, "key", { enumerable: true })',
+        errors: [{ message: /null-prototype/ }],
+      },
+      {
+        code: 'ReflectDefineProperty({}, "key", { enumerable: true })',
+        errors: [{ message: /null-prototype/ }],
+      },
+      {
+        code: 'async function myFn(){ return {} }',
+        errors: [{ message: /null-prototype/ }],
+      },
+      {
+        code: 'async function myFn(){ async function someOtherFn() { return { __proto__: null } } return {} }',
+        errors: [{ message: /null-prototype/ }],
+      },
+      {
+        code: 'async function myFn(){ if (true) { return {} } return { __proto__: null } }',
+        errors: [{ message: /null-prototype/ }],
+      },
+      {
+        code: 'const myFn = async function myFn(){ return {} }',
+        errors: [{ message: /null-prototype/ }],
+      },
+      {
+        code: 'const myFn = async function (){ return {} }',
+        errors: [{ message: /null-prototype/ }],
+      },
+      {
+        code: 'const myFn = async () => { return {} }',
+        errors: [{ message: /null-prototype/ }],
+      },
+      {
+        code: 'const myFn = async () => ({})',
+        errors: [{ message: /null-prototype/ }],
+      },
+      {
+        code: 'RegExpPrototypeTest(/some regex/, "some string")',
+        errors: [{
+          message: /looks up the "exec" property/,
+          suggestions: [{
+            desc: 'Use RegexpPrototypeExec instead',
+            output: 'RegExpPrototypeExec(/some regex/, "some string") !== null',
+          }],
+        }],
+      },
+      {
+        code: 'RegExpPrototypeSymbolMatch(/some regex/, "some string")',
+        errors: [{ message: /looks up the "exec" property/ }],
+      },
+      {
+        code: 'RegExpPrototypeSymbolMatchAll(/some regex/, "some string")',
+        errors: [{ message: /looks up the "exec" property/ }],
+      },
+      {
+        code: 'RegExpPrototypeSymbolSearch(/some regex/, "some string")',
+        errors: [{ message: /SafeStringPrototypeSearch/ }],
+      },
+      {
+        code: 'StringPrototypeMatch("some string", /some regex/)',
+        errors: [{ message: /looks up the Symbol\.match property/ }],
+      },
+      {
+        code: 'let v = StringPrototypeMatch("some string", /some regex/)',
+        errors: [{ message: /looks up the Symbol\.match property/ }],
+      },
+      {
+        code: 'let v = StringPrototypeMatch("some string", new RegExp("some regex"))',
+        errors: [{ message: /looks up the Symbol\.match property/ }],
+      },
+      {
+        code: 'StringPrototypeMatchAll("some string", /some regex/)',
+        errors: [{ message: /looks up the Symbol\.matchAll property/ }],
+      },
+      {
+        code: 'let v = StringPrototypeMatchAll("some string", new RegExp("some regex"))',
+        errors: [{ message: /looks up the Symbol\.matchAll property/ }],
+      },
+      {
+        code: 'StringPrototypeReplace("some string", /some regex/, "some replacement")',
+        errors: [{ message: /looks up the Symbol\.replace property/ }],
+      },
+      {
+        code: 'StringPrototypeReplace("some string", new RegExp("some regex"), "some replacement")',
+        errors: [{ message: /looks up the Symbol\.replace property/ }],
+      },
+      {
+        code: 'StringPrototypeReplaceAll("some string", /some regex/, "some replacement")',
+        errors: [{ message: /looks up the Symbol\.replace property/ }],
+      },
+      {
+        code: 'StringPrototypeReplaceAll("some string", new RegExp("some regex"), "some replacement")',
+        errors: [{ message: /looks up the Symbol\.replace property/ }],
+      },
+      {
+        code: 'StringPrototypeSearch("some string", /some regex/)',
+        errors: [{ message: /SafeStringPrototypeSearch/ }],
+      },
+      {
+        code: 'StringPrototypeSplit("some string", /some regex/)',
+        errors: [{ message: /looks up the Symbol\.split property/ }],
+      },
+      {
+        code: 'new Proxy({}, {})',
+        errors: [{ message: /null-prototype/ }]
+      },
+      {
+        code: 'new Proxy({}, { [`__proto__`]: null })',
+        errors: [{ message: /null-prototype/ }]
+      },
+      {
+        code: 'new Proxy({}, { __proto__: Object.prototype })',
+        errors: [{ message: /null-prototype/ }]
+      },
+      {
+        code: 'new Proxy({}, { ...{ __proto__: null } })',
+        errors: [{ message: /null-prototype/ }]
+      },
+      {
+        code: 'PromisePrototypeCatch(promise, ()=>{})',
+        errors: [{ message: /\bPromisePrototypeThen\b/ }]
+      },
+      {
+        code: 'PromiseAll([])',
+        errors: [{ message: /\bSafePromiseAll\b/ }]
+      },
+      {
+        code: 'async function fn(){await SafePromiseAll([])}',
+        errors: [{ message: /\bSafePromiseAllReturnVoid\b/ }]
+      },
+      {
+        code: 'async function fn(){await SafePromiseAllSettled([])}',
+        errors: [{ message: /\bSafePromiseAllSettledReturnVoid\b/ }]
+      },
+      {
+        code: 'PromiseAllSettled([])',
+        errors: [{ message: /\bSafePromiseAllSettled\b/ }]
+      },
+      {
+        code: 'PromiseAny([])',
+        errors: [{ message: /\bSafePromiseAny\b/ }]
+      },
+      {
+        code: 'PromiseRace([])',
+        errors: [{ message: /\bSafePromiseRace\b/ }]
+      },
+      {
+        code: 'ArrayPrototypeConcat([])',
+        errors: [{ message: /\bisConcatSpreadable\b/ }]
+      },
+    ]
+  });
diff --git a/test/js/node/test/parallel/test-eslint-crypto-check.js b/test/js/node/test/parallel/test-eslint-crypto-check.js
new file mode 100644
index 0000000000..2b2c0c2dd1
--- /dev/null
+++ b/test/js/node/test/parallel/test-eslint-crypto-check.js
@@ -0,0 +1,77 @@
+'use strict';
+
+const common = require('../common');
+if ((!common.hasCrypto) || (!common.hasIntl)) {
+  common.skip('ESLint tests require crypto and Intl');
+}
+
+common.skipIfEslintMissing();
+
+const RuleTester = require('../../tools/eslint/node_modules/eslint').RuleTester;
+const rule = require('../../tools/eslint-rules/crypto-check');
+
+const message = 'Please add a hasCrypto check to allow this test to be ' +
+                'skipped when Node is built "--without-ssl".';
+
+new RuleTester().run('crypto-check', rule, {
+  valid: [
+    'foo',
+    'crypto',
+    `
+    if (!common.hasCrypto) {
+      common.skip("missing crypto");
+    }
+    require("crypto");
+    `,
+    `
+    if (!common.hasCrypto) {
+      common.skip("missing crypto");
+    }
+    internalBinding("crypto");
+    `,
+  ],
+  invalid: [
+    {
+      code: 'require("common")\n' +
+            'require("crypto")\n' +
+            'if (!common.hasCrypto) {\n' +
+            '  common.skip("missing crypto");\n' +
+            '}',
+      errors: [{ message }]
+    },
+    {
+      code: 'require("common")\n' +
+            'require("crypto")',
+      errors: [{ message }],
+      output: 'require("common")\n' +
+              'if (!common.hasCrypto) {' +
+              ' common.skip("missing crypto");' +
+              '}\n' +
+              'require("crypto")'
+    },
+    {
+      code: 'require("common")\n' +
+            'if (common.foo) {}\n' +
+            'require("crypto")',
+      errors: [{ message }],
+      output: 'require("common")\n' +
+              'if (!common.hasCrypto) {' +
+              ' common.skip("missing crypto");' +
+              '}\n' +
+              'if (common.foo) {}\n' +
+              'require("crypto")'
+    },
+    {
+      code: 'require("common")\n' +
+            'if (common.foo) {}\n' +
+            'internalBinding("crypto")',
+      errors: [{ message }],
+      output: 'require("common")\n' +
+              'if (!common.hasCrypto) {' +
+              ' common.skip("missing crypto");' +
+              '}\n' +
+              'if (common.foo) {}\n' +
+              'internalBinding("crypto")'
+    },
+  ]
+});
diff --git a/test/js/node/test/parallel/test-eslint-documented-deprecation-codes.js b/test/js/node/test/parallel/test-eslint-documented-deprecation-codes.js
new file mode 100644
index 0000000000..dc3dc46b7e
--- /dev/null
+++ b/test/js/node/test/parallel/test-eslint-documented-deprecation-codes.js
@@ -0,0 +1,42 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+if (!common.hasIntl)
+  common.skip('missing Intl');
+common.skipIfEslintMissing();
+
+const RuleTester = require('../../tools/eslint/node_modules/eslint').RuleTester;
+const rule = require('../../tools/eslint-rules/documented-deprecation-codes');
+
+const mdFile = 'doc/api/deprecations.md';
+
+const invalidCode = 'UNDOCUMENTED INVALID CODE';
+
+new RuleTester().run('documented-deprecation-codes', rule, {
+  valid: [
+    `
+    deprecate(function() {
+        return this.getHeaders();
+      }, 'OutgoingMessage.prototype._headers is deprecated', 'DEP0066')
+    `,
+  ],
+  invalid: [
+    {
+      code: `
+        deprecate(function foo(){}, 'bar', '${invalidCode}');
+      `,
+      errors: [
+        {
+          message: `"${invalidCode}" does not match the expected pattern`,
+          line: 2
+        },
+        {
+          message: `"${invalidCode}" is not documented in ${mdFile}`,
+          line: 2
+        },
+      ]
+    },
+  ]
+});
diff --git a/test/js/node/test/parallel/test-eslint-documented-errors.js b/test/js/node/test/parallel/test-eslint-documented-errors.js
new file mode 100644
index 0000000000..03131306d7
--- /dev/null
+++ b/test/js/node/test/parallel/test-eslint-documented-errors.js
@@ -0,0 +1,38 @@
+'use strict';
+
+const common = require('../common');
+if ((!common.hasCrypto) || (!common.hasIntl)) {
+  common.skip('ESLint tests require crypto and Intl');
+}
+common.skipIfEslintMissing();
+
+const RuleTester = require('../../tools/eslint/node_modules/eslint').RuleTester;
+const rule = require('../../tools/eslint-rules/documented-errors');
+
+const invalidCode = 'UNDOCUMENTED ERROR CODE';
+
+new RuleTester().run('documented-errors', rule, {
+  valid: [
+    `
+      E('ERR_ASSERTION', 'foo');
+    `,
+  ],
+  invalid: [
+    {
+      code: `
+        E('${invalidCode}', 'bar');
+      `,
+      errors: [
+        {
+          message: `"${invalidCode}" is not documented in doc/api/errors.md`,
+          line: 2
+        },
+        {
+          message:
+            `doc/api/errors.md does not have an anchor for "${invalidCode}"`,
+          line: 2
+        },
+      ]
+    },
+  ]
+});
diff --git a/test/js/node/test/parallel/test-eslint-duplicate-requires.js b/test/js/node/test/parallel/test-eslint-duplicate-requires.js
new file mode 100644
index 0000000000..f2a11b37ca
--- /dev/null
+++ b/test/js/node/test/parallel/test-eslint-duplicate-requires.js
@@ -0,0 +1,32 @@
+'use strict';
+
+const common = require('../common');
+if ((!common.hasCrypto) || (!common.hasIntl)) {
+  common.skip('ESLint tests require crypto and Intl');
+}
+
+common.skipIfEslintMissing();
+
+const { RuleTester } = require('../../tools/eslint/node_modules/eslint');
+const rule = require('../../tools/eslint-rules/no-duplicate-requires');
+
+new RuleTester({
+  languageOptions: {
+    sourceType: 'script',
+  },
+}).run('no-duplicate-requires', rule, {
+  valid: [
+    {
+      code: 'require("a"); require("b"); (function() { require("a"); });',
+    },
+    {
+      code: 'require(a); require(a);',
+    },
+  ],
+  invalid: [
+    {
+      code: 'require("a"); require("a");',
+      errors: [{ message: '\'a\' require is duplicated.' }],
+    },
+  ],
+});
diff --git a/test/js/node/test/parallel/test-eslint-eslint-check.js b/test/js/node/test/parallel/test-eslint-eslint-check.js
new file mode 100644
index 0000000000..ca34497c32
--- /dev/null
+++ b/test/js/node/test/parallel/test-eslint-eslint-check.js
@@ -0,0 +1,34 @@
+'use strict';
+
+const common = require('../common');
+if ((!common.hasCrypto) || (!common.hasIntl)) {
+  common.skip('ESLint tests require crypto and Intl');
+}
+
+common.skipIfEslintMissing();
+
+const RuleTester = require('../../tools/eslint/node_modules/eslint').RuleTester;
+const rule = require('../../tools/eslint-rules/eslint-check');
+
+const message = 'Please add a skipIfEslintMissing() call to allow this ' +
+                'test to be skipped when Node.js is built ' +
+                'from a source tarball.';
+
+new RuleTester().run('eslint-check', rule, {
+  valid: [
+    'foo;',
+    'require("common")\n' +
+      'common.skipIfEslintMissing();\n' +
+      'require("../../tools/eslint/node_modules/eslint")',
+  ],
+  invalid: [
+    {
+      code: 'require("common")\n' +
+            'require("../../tools/eslint/node_modules/eslint").RuleTester',
+      errors: [{ message }],
+      output: 'require("common")\n' +
+              'common.skipIfEslintMissing();\n' +
+              'require("../../tools/eslint/node_modules/eslint").RuleTester'
+    },
+  ]
+});
diff --git a/test/js/node/test/parallel/test-eslint-inspector-check.js b/test/js/node/test/parallel/test-eslint-inspector-check.js
new file mode 100644
index 0000000000..c60dcf0874
--- /dev/null
+++ b/test/js/node/test/parallel/test-eslint-inspector-check.js
@@ -0,0 +1,33 @@
+'use strict';
+
+const common = require('../common');
+if ((!common.hasCrypto) || (!common.hasIntl)) {
+  common.skip('ESLint tests require crypto and Intl');
+}
+common.skipIfEslintMissing();
+
+const RuleTester = require('../../tools/eslint/node_modules/eslint').RuleTester;
+const rule = require('../../tools/eslint-rules/inspector-check');
+
+const message = 'Please add a skipIfInspectorDisabled() call to allow this ' +
+                'test to be skipped when Node is built ' +
+                '\'--without-inspector\'.';
+
+new RuleTester().run('inspector-check', rule, {
+  valid: [
+    'foo;',
+    'require("common")\n' +
+      'common.skipIfInspectorDisabled();\n' +
+      'require("inspector")',
+  ],
+  invalid: [
+    {
+      code: 'require("common")\n' +
+            'require("inspector")',
+      errors: [{ message }],
+      output: 'require("common")\n' +
+              'common.skipIfInspectorDisabled();\n' +
+              'require("inspector")'
+    },
+  ]
+});
diff --git a/test/js/node/test/parallel/test-eslint-lowercase-name-for-primitive.js b/test/js/node/test/parallel/test-eslint-lowercase-name-for-primitive.js
new file mode 100644
index 0000000000..f8029d7c8b
--- /dev/null
+++ b/test/js/node/test/parallel/test-eslint-lowercase-name-for-primitive.js
@@ -0,0 +1,42 @@
+'use strict';
+
+const common = require('../common');
+if ((!common.hasCrypto) || (!common.hasIntl)) {
+  common.skip('ESLint tests require crypto and Intl');
+}
+
+common.skipIfEslintMissing();
+
+const RuleTester = require('../../tools/eslint/node_modules/eslint').RuleTester;
+const rule = require('../../tools/eslint-rules/lowercase-name-for-primitive');
+
+new RuleTester().run('lowercase-name-for-primitive', rule, {
+  valid: [
+    'new errors.TypeError("ERR_INVALID_ARG_TYPE", "a", ["string", "number"])',
+    'new errors.TypeError("ERR_INVALID_ARG_TYPE", "name", "string")',
+    'new errors.TypeError("ERR_INVALID_ARG_TYPE", "name", "number")',
+    'new errors.TypeError("ERR_INVALID_ARG_TYPE", "name", "boolean")',
+    'new errors.TypeError("ERR_INVALID_ARG_TYPE", "name", "null")',
+    'new errors.TypeError("ERR_INVALID_ARG_TYPE", "name", "undefined")',
+  ],
+  invalid: [
+    {
+      code: "new errors.TypeError('ERR_INVALID_ARG_TYPE', 'a', 'Number')",
+      errors: [{ message: 'primitive should use lowercase: Number' }],
+      output: "new errors.TypeError('ERR_INVALID_ARG_TYPE', 'a', 'number')",
+    },
+    {
+      code: "new errors.TypeError('ERR_INVALID_ARG_TYPE', 'a', 'STRING')",
+      errors: [{ message: 'primitive should use lowercase: STRING' }],
+      output: "new errors.TypeError('ERR_INVALID_ARG_TYPE', 'a', 'string')",
+    },
+    {
+      code: "new e.TypeError('ERR_INVALID_ARG_TYPE', a, ['String','Number'])",
+      errors: [
+        { message: 'primitive should use lowercase: String' },
+        { message: 'primitive should use lowercase: Number' },
+      ],
+      output: "new e.TypeError('ERR_INVALID_ARG_TYPE', a, ['string','number'])",
+    },
+  ]
+});
diff --git a/test/js/node/test/parallel/test-eslint-no-array-destructuring.js b/test/js/node/test/parallel/test-eslint-no-array-destructuring.js
new file mode 100644
index 0000000000..3f9b6e0094
--- /dev/null
+++ b/test/js/node/test/parallel/test-eslint-no-array-destructuring.js
@@ -0,0 +1,139 @@
+'use strict';
+
+const common = require('../common');
+if ((!common.hasCrypto) || (!common.hasIntl)) {
+  common.skip('ESLint tests require crypto and Intl');
+}
+
+common.skipIfEslintMissing();
+
+const { RuleTester } = require('../../tools/eslint/node_modules/eslint');
+const rule = require('../../tools/eslint-rules/no-array-destructuring');
+
+const USE_OBJ_DESTRUCTURING =
+  'Use object destructuring instead of array destructuring.';
+const USE_ARRAY_METHODS =
+  'Use primordials.ArrayPrototypeSlice to avoid unsafe array iteration.';
+
+new RuleTester()
+  .run('no-array-destructuring', rule, {
+    valid: [
+      'const first = [1, 2, 3][0];',
+      'const {0:first} = [1, 2, 3];',
+      '({1:elem} = array);',
+      'function name(param, { 0: key, 1: value },) {}',
+    ],
+    invalid: [
+      {
+        code: 'const [Array] = args;',
+        errors: [{ message: USE_OBJ_DESTRUCTURING }],
+        output: 'const {0:Array} = args;'
+      },
+      {
+        code: 'const [ , res] = args;',
+        errors: [{ message: USE_OBJ_DESTRUCTURING }],
+        output: 'const {  1:res} = args;',
+      },
+      {
+        code: '[, elem] = options;',
+        errors: [{ message: USE_OBJ_DESTRUCTURING }],
+        output: '({ 1:elem} = options);',
+      },
+      {
+        code: 'const {values:[elem]} = options;',
+        errors: [{ message: USE_OBJ_DESTRUCTURING }],
+        output: 'const {values:{0:elem}} = options;',
+      },
+      {
+        code: '[[[elem]]] = options;',
+        errors: [
+          { message: USE_OBJ_DESTRUCTURING },
+          { message: USE_OBJ_DESTRUCTURING },
+          { message: USE_OBJ_DESTRUCTURING },
+        ],
+        output: '({0:[[elem]]} = options);',
+      },
+      {
+        code: '[, ...rest] = options;',
+        errors: [{ message: USE_ARRAY_METHODS }],
+      },
+      {
+        code: 'for(const [key, value] of new Map);',
+        errors: [{ message: USE_OBJ_DESTRUCTURING }],
+        output: 'for(const {0:key, 1:value} of new Map);',
+      },
+      {
+        code: 'let [first,,,fourth] = array;',
+        errors: [{ message: USE_OBJ_DESTRUCTURING }],
+        output: 'let {0:first,3:fourth} = array;',
+      },
+      {
+        code: 'let [,second,,fourth] = array;',
+        errors: [{ message: USE_OBJ_DESTRUCTURING }],
+        output: 'let {1:second,3:fourth} = array;',
+      },
+      {
+        code: 'let [ ,,,fourth ] = array;',
+        errors: [{ message: USE_OBJ_DESTRUCTURING }],
+        output: 'let { 3:fourth } = array;',
+      },
+      {
+        code: 'let [,,,fourth, fifth,, minorFall, majorLift,...music] = arr;',
+        errors: [{ message: USE_ARRAY_METHODS }],
+      },
+      {
+        code: 'function map([key, value]) {}',
+        errors: [{ message: USE_OBJ_DESTRUCTURING }],
+        output: 'function map({0:key, 1:value}) {}',
+      },
+      {
+        code: 'function map([key, value],) {}',
+        errors: [{ message: USE_OBJ_DESTRUCTURING }],
+        output: 'function map({0:key, 1:value},) {}',
+      },
+      {
+        code: '(function([key, value]) {})',
+        errors: [{ message: USE_OBJ_DESTRUCTURING }],
+        output: '(function({0:key, 1:value}) {})',
+      },
+      {
+        code: '(function([key, value] = [null, 0]) {})',
+        errors: [{ message: USE_OBJ_DESTRUCTURING }],
+        output: '(function({0:key, 1:value} = [null, 0]) {})',
+      },
+      {
+        code: 'function map([key, ...values]) {}',
+        errors: [{ message: USE_ARRAY_METHODS }],
+      },
+      {
+        code: 'function map([key, value], ...args) {}',
+        errors: [{ message: USE_OBJ_DESTRUCTURING }],
+        output: 'function map({0:key, 1:value}, ...args) {}',
+      },
+      {
+        code: 'async function map([key, value], ...args) {}',
+        errors: [{ message: USE_OBJ_DESTRUCTURING }],
+        output: 'async function map({0:key, 1:value}, ...args) {}',
+      },
+      {
+        code: 'async function* generator([key, value], ...args) {}',
+        errors: [{ message: USE_OBJ_DESTRUCTURING }],
+        output: 'async function* generator({0:key, 1:value}, ...args) {}',
+      },
+      {
+        code: 'function* generator([key, value], ...args) {}',
+        errors: [{ message: USE_OBJ_DESTRUCTURING }],
+        output: 'function* generator({0:key, 1:value}, ...args) {}',
+      },
+      {
+        code: 'const cb = ([key, value], ...args) => {}',
+        errors: [{ message: USE_OBJ_DESTRUCTURING }],
+        output: 'const cb = ({0:key, 1:value}, ...args) => {}',
+      },
+      {
+        code: 'class name{ method([key], ...args){} }',
+        errors: [{ message: USE_OBJ_DESTRUCTURING }],
+        output: 'class name{ method({0:key}, ...args){} }',
+      },
+    ]
+  });
diff --git a/test/js/node/test/parallel/test-eslint-no-unescaped-regexp-dot.js b/test/js/node/test/parallel/test-eslint-no-unescaped-regexp-dot.js
new file mode 100644
index 0000000000..457b76a2fc
--- /dev/null
+++ b/test/js/node/test/parallel/test-eslint-no-unescaped-regexp-dot.js
@@ -0,0 +1,33 @@
+'use strict';
+
+const common = require('../common');
+if ((!common.hasCrypto) || (!common.hasIntl)) {
+  common.skip('ESLint tests require crypto and Intl');
+}
+
+common.skipIfEslintMissing();
+
+const RuleTester = require('../../tools/eslint/node_modules/eslint').RuleTester;
+const rule = require('../../tools/eslint-rules/no-unescaped-regexp-dot');
+
+new RuleTester().run('no-unescaped-regexp-dot', rule, {
+  valid: [
+    '/foo/',
+    String.raw`/foo\./`,
+    '/.+/',
+    '/.*/',
+    '/.?/',
+    '/.{5}/',
+    String.raw`/\\\./`,
+  ],
+  invalid: [
+    {
+      code: '/./',
+      errors: [{ message: 'Unescaped dot character in regular expression' }]
+    },
+    {
+      code: String.raw`/\\./`,
+      errors: [{ message: 'Unescaped dot character in regular expression' }]
+    },
+  ]
+});
diff --git a/test/js/node/test/parallel/test-eslint-non-ascii-character.js b/test/js/node/test/parallel/test-eslint-non-ascii-character.js
new file mode 100644
index 0000000000..2d71fda279
--- /dev/null
+++ b/test/js/node/test/parallel/test-eslint-non-ascii-character.js
@@ -0,0 +1,27 @@
+'use strict';
+
+const common = require('../common');
+if ((!common.hasCrypto) || (!common.hasIntl)) {
+  common.skip('ESLint tests require crypto and Intl');
+}
+
+common.skipIfEslintMissing();
+
+const RuleTester = require('../../tools/eslint/node_modules/eslint').RuleTester;
+const rule = require('../../tools/eslint-rules/non-ascii-character');
+
+new RuleTester().run('non-ascii-characters', rule, {
+  valid: [
+    {
+      code: 'console.log("fhqwhgads")',
+      options: []
+    },
+  ],
+  invalid: [
+    {
+      code: 'console.log("μ")',
+      options: [],
+      errors: [{ message: "Non-ASCII character 'μ' detected." }],
+    },
+  ]
+});
diff --git a/test/js/node/test/parallel/test-eslint-prefer-assert-iferror.js b/test/js/node/test/parallel/test-eslint-prefer-assert-iferror.js
new file mode 100644
index 0000000000..cd8f46146d
--- /dev/null
+++ b/test/js/node/test/parallel/test-eslint-prefer-assert-iferror.js
@@ -0,0 +1,36 @@
+'use strict';
+
+const common = require('../common');
+if ((!common.hasCrypto) || (!common.hasIntl)) {
+  common.skip('ESLint tests require crypto and Intl');
+}
+
+common.skipIfEslintMissing();
+
+const RuleTester = require('../../tools/eslint/node_modules/eslint').RuleTester;
+const rule = require('../../tools/eslint-rules/prefer-assert-iferror');
+
+new RuleTester().run('prefer-assert-iferror', rule, {
+  valid: [
+    'assert.ifError(err);',
+    'if (err) throw somethingElse;',
+    'throw err;',
+    'if (err) { throw somethingElse; }',
+  ],
+  invalid: [
+    {
+      code: 'require("assert");\n' +
+            'if (err) throw err;',
+      errors: [{ message: 'Use assert.ifError(err) instead.' }],
+      output: 'require("assert");\n' +
+              'assert.ifError(err);'
+    },
+    {
+      code: 'require("assert");\n' +
+            'if (error) { throw error; }',
+      errors: [{ message: 'Use assert.ifError(error) instead.' }],
+      output: 'require("assert");\n' +
+              'assert.ifError(error);'
+    },
+  ]
+});
diff --git a/test/js/node/test/parallel/test-eslint-prefer-assert-methods.js b/test/js/node/test/parallel/test-eslint-prefer-assert-methods.js
new file mode 100644
index 0000000000..a77ffd01d4
--- /dev/null
+++ b/test/js/node/test/parallel/test-eslint-prefer-assert-methods.js
@@ -0,0 +1,57 @@
+'use strict';
+
+const common = require('../common');
+if ((!common.hasCrypto) || (!common.hasIntl)) {
+  common.skip('ESLint tests require crypto and Intl');
+}
+
+common.skipIfEslintMissing();
+
+const RuleTester = require('../../tools/eslint/node_modules/eslint').RuleTester;
+const rule = require('../../tools/eslint-rules/prefer-assert-methods');
+
+new RuleTester().run('prefer-assert-methods', rule, {
+  valid: [
+    'assert.strictEqual(foo, bar);',
+    'assert(foo === bar && baz);',
+    'assert.notStrictEqual(foo, bar);',
+    'assert(foo !== bar && baz);',
+    'assert.equal(foo, bar);',
+    'assert(foo == bar && baz);',
+    'assert.notEqual(foo, bar);',
+    'assert(foo != bar && baz);',
+    'assert.ok(foo);',
+    'assert.ok(foo != bar);',
+    'assert.ok(foo === bar && baz);',
+  ],
+  invalid: [
+    {
+      code: 'assert(foo == bar);',
+      errors: [{
+        message: "'assert.equal' should be used instead of '=='"
+      }],
+      output: 'assert.equal(foo, bar);'
+    },
+    {
+      code: 'assert(foo === bar);',
+      errors: [{
+        message: "'assert.strictEqual' should be used instead of '==='"
+      }],
+      output: 'assert.strictEqual(foo, bar);'
+    },
+    {
+      code: 'assert(foo != bar);',
+      errors: [{
+        message: "'assert.notEqual' should be used instead of '!='"
+      }],
+      output: 'assert.notEqual(foo, bar);'
+    },
+    {
+      code: 'assert(foo !== bar);',
+      errors: [{
+        message: "'assert.notStrictEqual' should be used instead of '!=='"
+      }],
+      output: 'assert.notStrictEqual(foo, bar);'
+    },
+  ]
+});
diff --git a/test/js/node/test/parallel/test-eslint-prefer-common-mustnotcall.js b/test/js/node/test/parallel/test-eslint-prefer-common-mustnotcall.js
new file mode 100644
index 0000000000..a805b3c4ae
--- /dev/null
+++ b/test/js/node/test/parallel/test-eslint-prefer-common-mustnotcall.js
@@ -0,0 +1,32 @@
+'use strict';
+
+const common = require('../common');
+if ((!common.hasCrypto) || (!common.hasIntl)) {
+  common.skip('ESLint tests require crypto and Intl');
+}
+
+common.skipIfEslintMissing();
+
+const RuleTester = require('../../tools/eslint/node_modules/eslint').RuleTester;
+const rule = require('../../tools/eslint-rules/prefer-common-mustnotcall');
+
+const message = 'Please use common.mustNotCall(msg) instead of ' +
+                'common.mustCall(fn, 0) or common.mustCall(0).';
+
+new RuleTester().run('prefer-common-mustnotcall', rule, {
+  valid: [
+    'common.mustNotCall(fn)',
+    'common.mustCall(fn)',
+    'common.mustCall(fn, 1)',
+  ],
+  invalid: [
+    {
+      code: 'common.mustCall(fn, 0)',
+      errors: [{ message }]
+    },
+    {
+      code: 'common.mustCall(0)',
+      errors: [{ message }]
+    },
+  ]
+});
diff --git a/test/js/node/test/parallel/test-eslint-prefer-common-mustsucceed.js b/test/js/node/test/parallel/test-eslint-prefer-common-mustsucceed.js
new file mode 100644
index 0000000000..134d8bbc05
--- /dev/null
+++ b/test/js/node/test/parallel/test-eslint-prefer-common-mustsucceed.js
@@ -0,0 +1,51 @@
+'use strict';
+
+const common = require('../common');
+if ((!common.hasCrypto) || (!common.hasIntl)) {
+  common.skip('ESLint tests require crypto and Intl');
+}
+
+common.skipIfEslintMissing();
+
+const RuleTester = require('../../tools/eslint/node_modules/eslint').RuleTester;
+const rule = require('../../tools/eslint-rules/prefer-common-mustsucceed');
+
+const msg1 = 'Please use common.mustSucceed instead of ' +
+             'common.mustCall(assert.ifError).';
+const msg2 = 'Please use common.mustSucceed instead of ' +
+             'common.mustCall with assert.ifError.';
+
+new RuleTester().run('prefer-common-mustsucceed', rule, {
+  valid: [
+    'foo((err) => assert.ifError(err))',
+    'foo(function(err) { assert.ifError(err) })',
+    'foo(assert.ifError)',
+    'common.mustCall((err) => err)',
+  ],
+  invalid: [
+    {
+      code: 'common.mustCall(assert.ifError)',
+      errors: [{ message: msg1 }]
+    },
+    {
+      code: 'common.mustCall((err) => assert.ifError(err))',
+      errors: [{ message: msg2 }]
+    },
+    {
+      code: 'common.mustCall((e) => assert.ifError(e))',
+      errors: [{ message: msg2 }]
+    },
+    {
+      code: 'common.mustCall(function(e) { assert.ifError(e); })',
+      errors: [{ message: msg2 }]
+    },
+    {
+      code: 'common.mustCall(function(e) { return assert.ifError(e); })',
+      errors: [{ message: msg2 }]
+    },
+    {
+      code: 'common.mustCall(function(e) {{ assert.ifError(e); }})',
+      errors: [{ message: msg2 }]
+    },
+  ]
+});
diff --git a/test/js/node/test/parallel/test-eslint-prefer-primordials.js b/test/js/node/test/parallel/test-eslint-prefer-primordials.js
new file mode 100644
index 0000000000..61c84cbadd
--- /dev/null
+++ b/test/js/node/test/parallel/test-eslint-prefer-primordials.js
@@ -0,0 +1,265 @@
+'use strict';
+
+const common = require('../common');
+if ((!common.hasCrypto) || (!common.hasIntl)) {
+  common.skip('ESLint tests require crypto and Intl');
+}
+
+common.skipIfEslintMissing();
+
+const RuleTester = require('../../tools/eslint/node_modules/eslint').RuleTester;
+const rule = require('../../tools/eslint-rules/prefer-primordials');
+
+new RuleTester({
+  languageOptions: {
+    sourceType: 'script',
+  },
+})
+  .run('prefer-primordials', rule, {
+    valid: [
+      'new Array()',
+      'JSON.stringify({})',
+      'class A { *[Symbol.iterator] () { yield "a"; } }',
+      'const a = { *[Symbol.iterator] () { yield "a"; } }',
+      'Object.defineProperty(o, Symbol.toStringTag, { value: "o" })',
+      'parseInt("10")',
+      `
+        const { Reflect } = primordials;
+        module.exports = function() {
+          const { ownKeys } = Reflect;
+        }
+      `,
+      {
+        code: 'const { Array } = primordials; new Array()',
+        options: [{ name: 'Array' }]
+      },
+      {
+        code: 'const { JSONStringify } = primordials; JSONStringify({})',
+        options: [{ name: 'JSON' }]
+      },
+      {
+        code: 'const { SymbolFor } = primordials; SymbolFor("xxx")',
+        options: [{ name: 'Symbol' }]
+      },
+      {
+        code: `
+          const { SymbolIterator } = primordials;
+          class A { *[SymbolIterator] () { yield "a"; } }
+        `,
+        options: [{ name: 'Symbol' }]
+      },
+      {
+        code: `
+          const { Symbol } = primordials;
+          const a = { *[Symbol.iterator] () { yield "a"; } }
+        `,
+        options: [{ name: 'Symbol', ignore: ['iterator'] }]
+      },
+      {
+        code: `
+          const { ObjectDefineProperty, Symbol } = primordials;
+          ObjectDefineProperty(o, Symbol.toStringTag, { value: "o" });
+          const val = Symbol.toStringTag;
+          const { toStringTag } = Symbol;
+        `,
+        options: [{ name: 'Symbol', ignore: ['toStringTag'] }]
+      },
+      {
+        code: 'const { Symbol } = primordials; Symbol.for("xxx")',
+        options: [{ name: 'Symbol', ignore: ['for'] }]
+      },
+      {
+        code: 'const { NumberParseInt } = primordials; NumberParseInt("xxx")',
+        options: [{ name: 'parseInt', into: 'Number' }]
+      },
+      {
+        code: `
+          const { ReflectOwnKeys } = primordials;
+          module.exports = function() {
+            ReflectOwnKeys({})
+          }
+        `,
+        options: [{ name: 'Reflect' }],
+      },
+      {
+        code: 'const { Map } = primordials; new Map()',
+        options: [{ name: 'Map', into: 'Safe' }],
+      },
+      {
+        code: `
+          const { Function } = primordials;
+          const rename = Function;
+          const obj = { rename };
+        `,
+        options: [{ name: 'Function' }],
+      },
+      {
+        code: `
+          const { Function } = primordials;
+          let rename;
+          rename = Function;
+          const obj = { rename };
+        `,
+        options: [{ name: 'Function' }],
+      },
+      {
+        code: 'function identifier() {}',
+        options: [{ name: 'identifier' }]
+      },
+      {
+        code: 'function* identifier() {}',
+        options: [{ name: 'identifier' }]
+      },
+      {
+        code: 'class identifier {}',
+        options: [{ name: 'identifier' }]
+      },
+      {
+        code: 'new class { identifier(){} }',
+        options: [{ name: 'identifier' }]
+      },
+      {
+        code: 'const a = { identifier: \'4\' }',
+        options: [{ name: 'identifier' }]
+      },
+      {
+        code: 'identifier:{const a = 4}',
+        options: [{ name: 'identifier' }]
+      },
+      {
+        code: 'switch(0){case identifier:}',
+        options: [{ name: 'identifier' }]
+      },
+    ],
+    invalid: [
+      {
+        code: 'new Array()',
+        options: [{ name: 'Array' }],
+        errors: [{ message: /const { Array } = primordials/ }]
+      },
+      {
+        code: 'JSON.parse("{}")',
+        options: [{ name: 'JSON' }],
+        errors: [
+          { message: /const { JSONParse } = primordials/ },
+        ]
+      },
+      {
+        code: 'const { JSON } = primordials; JSON.parse("{}")',
+        options: [{ name: 'JSON' }],
+        errors: [{ message: /const { JSONParse } = primordials/ }]
+      },
+      {
+        code: 'Symbol.for("xxx")',
+        options: [{ name: 'Symbol' }],
+        errors: [
+          { message: /const { SymbolFor } = primordials/ },
+        ]
+      },
+      {
+        code: 'const { Symbol } = primordials; Symbol.for("xxx")',
+        options: [{ name: 'Symbol' }],
+        errors: [{ message: /const { SymbolFor } = primordials/ }]
+      },
+      {
+        code: `
+          const { Symbol } = primordials;
+          class A { *[Symbol.iterator] () { yield "a"; } }
+        `,
+        options: [{ name: 'Symbol' }],
+        errors: [{ message: /const { SymbolIterator } = primordials/ }]
+      },
+      {
+        code: `
+          const { Symbol } = primordials;
+          const a = { *[Symbol.iterator] () { yield "a"; } }
+        `,
+        options: [{ name: 'Symbol' }],
+        errors: [{ message: /const { SymbolIterator } = primordials/ }]
+      },
+      {
+        code: `
+          const { ObjectDefineProperty, Symbol } = primordials;
+          ObjectDefineProperty(o, Symbol.toStringTag, { value: "o" })
+        `,
+        options: [{ name: 'Symbol' }],
+        errors: [{ message: /const { SymbolToStringTag } = primordials/ }]
+      },
+      {
+        code: `
+          const { Number } = primordials;
+          Number.parseInt('10')
+        `,
+        options: [{ name: 'Number' }],
+        errors: [{ message: /const { NumberParseInt } = primordials/ }]
+      },
+      {
+        code: 'parseInt("10")',
+        options: [{ name: 'parseInt', into: 'Number' }],
+        errors: [{ message: /const { NumberParseInt } = primordials/ }]
+      },
+      {
+        code: `
+          module.exports = function() {
+            const { ownKeys } = Reflect;
+          }
+        `,
+        options: [{ name: 'Reflect' }],
+        errors: [{ message: /const { ReflectOwnKeys } = primordials/ }]
+      },
+      {
+        code: `
+          const { Reflect } = primordials;
+          module.exports = function() {
+            const { ownKeys } = Reflect;
+          }
+        `,
+        options: [{ name: 'Reflect' }],
+        errors: [{ message: /const { ReflectOwnKeys } = primordials/ }]
+      },
+      {
+        code: 'new Map()',
+        options: [{ name: 'Map', into: 'Safe' }],
+        errors: [{ message: /const { SafeMap } = primordials/ }]
+      },
+      {
+        code: `
+          const { Function } = primordials;
+          const noop = Function.prototype;
+        `,
+        options: [{ name: 'Function' }],
+        errors: [{ message: /const { FunctionPrototype } = primordials/ }]
+      },
+      {
+        code: `
+          const obj = { Function };
+        `,
+        options: [{ name: 'Function' }],
+        errors: [{ message: /const { Function } = primordials/ }]
+      },
+      {
+        code: `
+          const rename = Function;
+        `,
+        options: [{ name: 'Function' }],
+        errors: [{ message: /const { Function } = primordials/ }]
+      },
+      {
+        code: `
+          const rename = Function;
+          const obj = { rename };
+        `,
+        options: [{ name: 'Function' }],
+        errors: [{ message: /const { Function } = primordials/ }]
+      },
+      {
+        code: `
+          let rename;
+          rename = Function;
+          const obj = { rename };
+        `,
+        options: [{ name: 'Function' }],
+        errors: [{ message: /const { Function } = primordials/ }]
+      },
+    ]
+  });
diff --git a/test/js/node/test/parallel/test-eslint-prefer-proto.js b/test/js/node/test/parallel/test-eslint-prefer-proto.js
new file mode 100644
index 0000000000..7e927c967b
--- /dev/null
+++ b/test/js/node/test/parallel/test-eslint-prefer-proto.js
@@ -0,0 +1,69 @@
+'use strict';
+
+const common = require('../common');
+if ((!common.hasCrypto) || (!common.hasIntl)) {
+  common.skip('ESLint tests require crypto and Intl');
+}
+
+common.skipIfEslintMissing();
+
+const RuleTester = require('../../tools/eslint/node_modules/eslint').RuleTester;
+const rule = require('../../tools/eslint-rules/prefer-proto');
+
+new RuleTester().run('prefer-common-mustsucceed', rule, {
+  valid: [
+    '({ __proto__: null })',
+    'const x = { __proto__: null };',
+    `
+        class X {
+            field = { __proto__: null };
+
+            constructor() {
+                this.x = { __proto__: X };
+            }
+        }
+    `,
+    'foo({ __proto__: Array.prototype })',
+    '({ "__proto__": null })',
+    "({ '__proto__': null })",
+    'ObjectCreate(null, undefined)',
+    'Object.create(null, undefined)',
+    'Object.create(null, undefined, undefined)',
+    'ObjectCreate(null, descriptors)',
+    'Object.create(null, descriptors)',
+    'ObjectCreate(Foo.prototype, descriptors)',
+    'Object.create(Foo.prototype, descriptors)',
+  ],
+  invalid: [
+    {
+      code: 'ObjectCreate(null)',
+      output: '{ __proto__: null }',
+      errors: [{ messageId: 'error', data: { value: 'null' } }],
+    },
+    {
+      code: 'Object.create(null)',
+      output: '{ __proto__: null }',
+      errors: [{ messageId: 'error', data: { value: 'null' } }],
+    },
+    {
+      code: 'ObjectCreate(null,)',
+      output: '{ __proto__: null }',
+      errors: [{ messageId: 'error', data: { value: 'null' } }],
+    },
+    {
+      code: 'Object.create(null,)',
+      output: '{ __proto__: null }',
+      errors: [{ messageId: 'error', data: { value: 'null' } }],
+    },
+    {
+      code: 'ObjectCreate(Foo)',
+      output: '{ __proto__: Foo }',
+      errors: [{ messageId: 'error', data: { value: 'Foo' } }],
+    },
+    {
+      code: 'Object.create(Foo)',
+      output: '{ __proto__: Foo }',
+      errors: [{ messageId: 'error', data: { value: 'Foo' } }],
+    },
+  ]
+});
diff --git a/test/js/node/test/parallel/test-eslint-prefer-util-format-errors.js b/test/js/node/test/parallel/test-eslint-prefer-util-format-errors.js
new file mode 100644
index 0000000000..3410265e9f
--- /dev/null
+++ b/test/js/node/test/parallel/test-eslint-prefer-util-format-errors.js
@@ -0,0 +1,32 @@
+'use strict';
+
+/* eslint-disable no-template-curly-in-string */
+
+const common = require('../common');
+if ((!common.hasCrypto) || (!common.hasIntl)) {
+  common.skip('ESLint tests require crypto and Intl');
+}
+
+common.skipIfEslintMissing();
+
+const RuleTester = require('../../tools/eslint/node_modules/eslint').RuleTester;
+const rule = require('../../tools/eslint-rules/prefer-util-format-errors');
+
+new RuleTester()
+  .run('prefer-util-format-errors', rule, {
+    valid: [
+      'E(\'ABC\', \'abc\');',
+      'E(\'ABC\', (arg1, arg2) => `${arg2}${arg1}`);',
+      'E(\'ABC\', (arg1, arg2) => `${arg1}{arg2.something}`);',
+      'E(\'ABC\', (arg1, arg2) => fn(arg1, arg2));',
+    ],
+    invalid: [
+      {
+        code: 'E(\'ABC\', (arg1, arg2) => `${arg1}${arg2}`);',
+        errors: [{
+          message: 'Please use a printf-like formatted string that ' +
+                   'util.format can consume.'
+        }]
+      },
+    ]
+  });
diff --git a/test/js/node/test/parallel/test-eslint-require-common-first.js b/test/js/node/test/parallel/test-eslint-require-common-first.js
new file mode 100644
index 0000000000..ef19f95b97
--- /dev/null
+++ b/test/js/node/test/parallel/test-eslint-require-common-first.js
@@ -0,0 +1,32 @@
+'use strict';
+
+const common = require('../common');
+if ((!common.hasCrypto) || (!common.hasIntl)) {
+  common.skip('ESLint tests require crypto and Intl');
+}
+
+common.skipIfEslintMissing();
+
+const RuleTester = require('../../tools/eslint/node_modules/eslint').RuleTester;
+const rule = require('../../tools/eslint-rules/require-common-first');
+
+new RuleTester({
+  languageOptions: {
+    sourceType: 'script',
+  },
+}).run('require-common-first', rule, {
+  valid: [
+    {
+      code: 'require("common")\n' +
+            'require("assert")'
+    },
+  ],
+  invalid: [
+    {
+      code: 'require("assert")\n' +
+            'require("common")',
+      errors: [{ message: 'Mandatory module "common" must be loaded ' +
+                          'before any other modules.' }]
+    },
+  ]
+});
diff --git a/test/js/node/test/parallel/test-eslint-required-modules.js b/test/js/node/test/parallel/test-eslint-required-modules.js
new file mode 100644
index 0000000000..4704163a38
--- /dev/null
+++ b/test/js/node/test/parallel/test-eslint-required-modules.js
@@ -0,0 +1,56 @@
+'use strict';
+
+const common = require('../common');
+if ((!common.hasCrypto) || (!common.hasIntl)) {
+  common.skip('ESLint tests require crypto and Intl');
+}
+
+common.skipIfEslintMissing();
+
+const RuleTester = require('../../tools/eslint/node_modules/eslint').RuleTester;
+const rule = require('../../tools/eslint-rules/required-modules');
+
+new RuleTester({
+  languageOptions: {
+    sourceType: 'script',
+  },
+}).run('required-modules', rule, {
+  valid: [
+    {
+      code: 'require("common")',
+      options: [{ common: 'common' }]
+    },
+    {
+      code: 'foo',
+      options: []
+    },
+    {
+      code: 'require("common")',
+      options: [{ common: 'common(/index\\.(m)?js)?$' }]
+    },
+    {
+      code: 'require("common/index.js")',
+      options: [{ common: 'common(/index\\.(m)?js)?$' }]
+    },
+  ],
+  invalid: [
+    {
+      code: 'foo',
+      options: [{ common: 'common' }],
+      errors: [{ message: 'Mandatory module "common" must be loaded.' }]
+    },
+    {
+      code: 'require("common/fixtures.js")',
+      options: [{ common: 'common(/index\\.(m)?js)?$' }],
+      errors: [{
+        message:
+          'Mandatory module "common" must be loaded.'
+      }]
+    },
+    {
+      code: 'require("somethingElse")',
+      options: [{ common: 'common' }],
+      errors: [{ message: 'Mandatory module "common" must be loaded.' }]
+    },
+  ]
+});
diff --git a/test/js/node/test/parallel/test-eval-strict-referenceerror.js b/test/js/node/test/parallel/test-eval-strict-referenceerror.js
new file mode 100644
index 0000000000..97f2b15ba0
--- /dev/null
+++ b/test/js/node/test/parallel/test-eval-strict-referenceerror.js
@@ -0,0 +1,27 @@
+/* eslint-disable strict */
+require('../common');
+
+// In Node.js 0.10, a bug existed that caused strict functions to not capture
+// their environment when evaluated. When run in 0.10 `test()` fails with a
+// `ReferenceError`. See https://github.com/nodejs/node/issues/2245 for details.
+
+const assert = require('assert');
+
+function test() {
+
+  const code = [
+    'var foo = {m: 1};',
+    '',
+    'function bar() {',
+    '\'use strict\';',
+    'return foo; // foo isn\'t captured in 0.10',
+    '};',
+  ].join('\n');
+
+  eval(code);
+
+  return bar(); // eslint-disable-line no-undef
+
+}
+
+assert.deepStrictEqual(test(), { m: 1 });
diff --git a/test/js/node/test/parallel/test-eval.js b/test/js/node/test/parallel/test-eval.js
new file mode 100644
index 0000000000..46a4b7c546
--- /dev/null
+++ b/test/js/node/test/parallel/test-eval.js
@@ -0,0 +1,7 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+
+// Verify that eval is allowed by default.
+assert.strictEqual(eval('"eval"'), 'eval');
diff --git a/test/js/node/test/parallel/test-event-emitter-add-listeners.js b/test/js/node/test/parallel/test-event-emitter-add-listeners.js
new file mode 100644
index 0000000000..f42d1f2487
--- /dev/null
+++ b/test/js/node/test/parallel/test-event-emitter-add-listeners.js
@@ -0,0 +1,86 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const EventEmitter = require('events');
+
+{
+  const ee = new EventEmitter();
+  const events_new_listener_emitted = [];
+  const listeners_new_listener_emitted = [];
+
+  // Sanity check
+  assert.strictEqual(ee.addListener, ee.on);
+
+  ee.on('newListener', function(event, listener) {
+    // Don't track newListener listeners.
+    if (event === 'newListener')
+      return;
+
+    events_new_listener_emitted.push(event);
+    listeners_new_listener_emitted.push(listener);
+  });
+
+  const hello = common.mustCall(function(a, b) {
+    assert.strictEqual(a, 'a');
+    assert.strictEqual(b, 'b');
+  });
+
+  ee.once('newListener', function(name, listener) {
+    assert.strictEqual(name, 'hello');
+    assert.strictEqual(listener, hello);
+    assert.deepStrictEqual(this.listeners('hello'), []);
+  });
+
+  ee.on('hello', hello);
+  ee.once('foo', assert.fail);
+  assert.deepStrictEqual(['hello', 'foo'], events_new_listener_emitted);
+  assert.deepStrictEqual([hello, assert.fail], listeners_new_listener_emitted);
+
+  ee.emit('hello', 'a', 'b');
+}
+
+// Just make sure that this doesn't throw:
+{
+  const f = new EventEmitter();
+
+  f.setMaxListeners(0);
+}
+
+{
+  const listen1 = () => {};
+  const listen2 = () => {};
+  const ee = new EventEmitter();
+
+  ee.once('newListener', function() {
+    assert.deepStrictEqual(ee.listeners('hello'), []);
+    ee.once('newListener', function() {
+      assert.deepStrictEqual(ee.listeners('hello'), []);
+    });
+    ee.on('hello', listen2);
+  });
+  ee.on('hello', listen1);
+  // The order of listeners on an event is not always the order in which the
+  // listeners were added.
+  assert.deepStrictEqual(ee.listeners('hello'), [listen2, listen1]);
+}
diff --git a/test/js/node/test/parallel/test-event-emitter-check-listener-leaks.js b/test/js/node/test/parallel/test-event-emitter-check-listener-leaks.js
new file mode 100644
index 0000000000..04ef3ddab1
--- /dev/null
+++ b/test/js/node/test/parallel/test-event-emitter-check-listener-leaks.js
@@ -0,0 +1,103 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const events = require('events');
+
+// default
+{
+  const e = new events.EventEmitter();
+
+  for (let i = 0; i < 10; i++) {
+    e.on('default', common.mustNotCall());
+  }
+  assert.ok(!Object.hasOwn(e._events.default, 'warned'));
+  e.on('default', common.mustNotCall());
+  assert.ok(e._events.default.warned);
+
+  // symbol
+  const symbol = Symbol('symbol');
+  e.setMaxListeners(1);
+  e.on(symbol, common.mustNotCall());
+  assert.ok(!Object.hasOwn(e._events[symbol], 'warned'));
+  e.on(symbol, common.mustNotCall());
+  assert.ok(Object.hasOwn(e._events[symbol], 'warned'));
+
+  // specific
+  e.setMaxListeners(5);
+  for (let i = 0; i < 5; i++) {
+    e.on('specific', common.mustNotCall());
+  }
+  assert.ok(!Object.hasOwn(e._events.specific, 'warned'));
+  e.on('specific', common.mustNotCall());
+  assert.ok(e._events.specific.warned);
+
+  // only one
+  e.setMaxListeners(1);
+  e.on('only one', common.mustNotCall());
+  assert.ok(!Object.hasOwn(e._events['only one'], 'warned'));
+  e.on('only one', common.mustNotCall());
+  assert.ok(Object.hasOwn(e._events['only one'], 'warned'));
+
+  // unlimited
+  e.setMaxListeners(0);
+  for (let i = 0; i < 1000; i++) {
+    e.on('unlimited', common.mustNotCall());
+  }
+  assert.ok(!Object.hasOwn(e._events.unlimited, 'warned'));
+}
+
+// process-wide
+{
+  events.EventEmitter.defaultMaxListeners = 42;
+  const e = new events.EventEmitter();
+
+  for (let i = 0; i < 42; ++i) {
+    e.on('fortytwo', common.mustNotCall());
+  }
+  assert.ok(!Object.hasOwn(e._events.fortytwo, 'warned'));
+  e.on('fortytwo', common.mustNotCall());
+  assert.ok(Object.hasOwn(e._events.fortytwo, 'warned'));
+  delete e._events.fortytwo.warned;
+
+  events.EventEmitter.defaultMaxListeners = 44;
+  e.on('fortytwo', common.mustNotCall());
+  assert.ok(!Object.hasOwn(e._events.fortytwo, 'warned'));
+  e.on('fortytwo', common.mustNotCall());
+  assert.ok(Object.hasOwn(e._events.fortytwo, 'warned'));
+}
+
+// But _maxListeners still has precedence over defaultMaxListeners
+{
+  events.EventEmitter.defaultMaxListeners = 42;
+  const e = new events.EventEmitter();
+  e.setMaxListeners(1);
+  e.on('uno', common.mustNotCall());
+  assert.ok(!Object.hasOwn(e._events.uno, 'warned'));
+  e.on('uno', common.mustNotCall());
+  assert.ok(Object.hasOwn(e._events.uno, 'warned'));
+
+  // chainable
+  assert.strictEqual(e, e.setMaxListeners(1));
+}
diff --git a/test/js/node/test/parallel/test-event-emitter-emit-context.js b/test/js/node/test/parallel/test-event-emitter-emit-context.js
new file mode 100644
index 0000000000..e4c73cadc5
--- /dev/null
+++ b/test/js/node/test/parallel/test-event-emitter-emit-context.js
@@ -0,0 +1,18 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const EventEmitter = require('events');
+
+// Test emit called by other context
+const EE = new EventEmitter();
+
+// Works as expected if the context has no `constructor.name`
+{
+  const ctx = { __proto__: null };
+  assert.throws(
+    () => EE.emit.call(ctx, 'error', new Error('foo')),
+    common.expectsError({ name: 'Error', message: 'foo' })
+  );
+}
+
+assert.strictEqual(EE.emit.call({}, 'foo'), false);
diff --git a/test/js/node/test/parallel/test-event-emitter-error-monitor.js b/test/js/node/test/parallel/test-event-emitter-error-monitor.js
new file mode 100644
index 0000000000..8254fc6254
--- /dev/null
+++ b/test/js/node/test/parallel/test-event-emitter-error-monitor.js
@@ -0,0 +1,32 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const EventEmitter = require('events');
+
+const EE = new EventEmitter();
+const theErr = new Error('MyError');
+
+EE.on(
+  EventEmitter.errorMonitor,
+  common.mustCall(function onErrorMonitor(e) {
+    assert.strictEqual(e, theErr);
+  }, 3)
+);
+
+// Verify with no error listener
+assert.throws(
+  () => EE.emit('error', theErr), theErr
+);
+
+// Verify with error listener
+EE.once('error', common.mustCall((e) => assert.strictEqual(e, theErr)));
+EE.emit('error', theErr);
+
+
+// Verify it works with once
+process.nextTick(() => EE.emit('error', theErr));
+assert.rejects(EventEmitter.once(EE, 'notTriggered'), theErr).then(common.mustCall());
+
+// Only error events trigger error monitor
+EE.on('aEvent', common.mustCall());
+EE.emit('aEvent');
diff --git a/test/js/node/test/parallel/test-event-emitter-get-max-listeners.js b/test/js/node/test/parallel/test-event-emitter-get-max-listeners.js
new file mode 100644
index 0000000000..43f9f0cebc
--- /dev/null
+++ b/test/js/node/test/parallel/test-event-emitter-get-max-listeners.js
@@ -0,0 +1,19 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const EventEmitter = require('events');
+
+const emitter = new EventEmitter();
+
+assert.strictEqual(emitter.getMaxListeners(), EventEmitter.defaultMaxListeners);
+
+emitter.setMaxListeners(0);
+assert.strictEqual(emitter.getMaxListeners(), 0);
+
+emitter.setMaxListeners(3);
+assert.strictEqual(emitter.getMaxListeners(), 3);
+
+// https://github.com/nodejs/node/issues/523 - second call should not throw.
+const recv = {};
+EventEmitter.prototype.on.call(recv, 'event', () => {});
+EventEmitter.prototype.on.call(recv, 'event', () => {});
diff --git a/test/js/node/test/parallel/test-event-emitter-listener-count.js b/test/js/node/test/parallel/test-event-emitter-listener-count.js
new file mode 100644
index 0000000000..117d38f575
--- /dev/null
+++ b/test/js/node/test/parallel/test-event-emitter-listener-count.js
@@ -0,0 +1,18 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const EventEmitter = require('events');
+
+const emitter = new EventEmitter();
+emitter.on('foo', () => {});
+emitter.on('foo', () => {});
+emitter.on('baz', () => {});
+// Allow any type
+emitter.on(123, () => {});
+
+assert.strictEqual(EventEmitter.listenerCount(emitter, 'foo'), 2);
+assert.strictEqual(emitter.listenerCount('foo'), 2);
+assert.strictEqual(emitter.listenerCount('bar'), 0);
+assert.strictEqual(emitter.listenerCount('baz'), 1);
+assert.strictEqual(emitter.listenerCount(123), 1);
diff --git a/test/js/node/test/parallel/test-event-emitter-method-names.js b/test/js/node/test/parallel/test-event-emitter-method-names.js
new file mode 100644
index 0000000000..684024d027
--- /dev/null
+++ b/test/js/node/test/parallel/test-event-emitter-method-names.js
@@ -0,0 +1,35 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const events = require('events');
+
+const E = events.EventEmitter.prototype;
+assert.strictEqual(E.constructor.name, 'EventEmitter');
+assert.strictEqual(E.on, E.addListener);  // Same method.
+assert.strictEqual(E.off, E.removeListener);  // Same method.
+Object.getOwnPropertyNames(E).forEach(function(name) {
+  if (name === 'constructor' || name === 'on' || name === 'off') return;
+  if (typeof E[name] !== 'function') return;
+  assert.strictEqual(E[name].name, name);
+});
diff --git a/test/js/node/test/parallel/test-event-emitter-modify-in-emit.js b/test/js/node/test/parallel/test-event-emitter-modify-in-emit.js
new file mode 100644
index 0000000000..995fa01d11
--- /dev/null
+++ b/test/js/node/test/parallel/test-event-emitter-modify-in-emit.js
@@ -0,0 +1,80 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const events = require('events');
+
+let callbacks_called = [];
+
+const e = new events.EventEmitter();
+
+function callback1() {
+  callbacks_called.push('callback1');
+  e.on('foo', callback2);
+  e.on('foo', callback3);
+  e.removeListener('foo', callback1);
+}
+
+function callback2() {
+  callbacks_called.push('callback2');
+  e.removeListener('foo', callback2);
+}
+
+function callback3() {
+  callbacks_called.push('callback3');
+  e.removeListener('foo', callback3);
+}
+
+e.on('foo', callback1);
+assert.strictEqual(e.listeners('foo').length, 1);
+
+e.emit('foo');
+assert.strictEqual(e.listeners('foo').length, 2);
+assert.deepStrictEqual(['callback1'], callbacks_called);
+
+e.emit('foo');
+assert.strictEqual(e.listeners('foo').length, 0);
+assert.deepStrictEqual(['callback1', 'callback2', 'callback3'],
+                       callbacks_called);
+
+e.emit('foo');
+assert.strictEqual(e.listeners('foo').length, 0);
+assert.deepStrictEqual(['callback1', 'callback2', 'callback3'],
+                       callbacks_called);
+
+e.on('foo', callback1);
+e.on('foo', callback2);
+assert.strictEqual(e.listeners('foo').length, 2);
+e.removeAllListeners('foo');
+assert.strictEqual(e.listeners('foo').length, 0);
+
+// Verify that removing callbacks while in emit allows emits to propagate to
+// all listeners
+callbacks_called = [];
+
+e.on('foo', callback2);
+e.on('foo', callback3);
+assert.strictEqual(e.listeners('foo').length, 2);
+e.emit('foo');
+assert.deepStrictEqual(['callback2', 'callback3'], callbacks_called);
+assert.strictEqual(e.listeners('foo').length, 0);
diff --git a/test/js/node/test/parallel/test-event-emitter-num-args.js b/test/js/node/test/parallel/test-event-emitter-num-args.js
new file mode 100644
index 0000000000..8bb2274303
--- /dev/null
+++ b/test/js/node/test/parallel/test-event-emitter-num-args.js
@@ -0,0 +1,54 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const events = require('events');
+
+const e = new events.EventEmitter();
+const num_args_emitted = [];
+
+e.on('numArgs', function() {
+  const numArgs = arguments.length;
+  num_args_emitted.push(numArgs);
+});
+
+e.on('foo', function() {
+  num_args_emitted.push(arguments.length);
+});
+
+e.on('foo', function() {
+  num_args_emitted.push(arguments.length);
+});
+
+e.emit('numArgs');
+e.emit('numArgs', null);
+e.emit('numArgs', null, null);
+e.emit('numArgs', null, null, null);
+e.emit('numArgs', null, null, null, null);
+e.emit('numArgs', null, null, null, null, null);
+
+e.emit('foo', null, null, null, null);
+
+process.on('exit', function() {
+  assert.deepStrictEqual(num_args_emitted, [0, 1, 2, 3, 4, 5, 4, 4]);
+});
diff --git a/test/js/node/test/parallel/test-event-emitter-prepend.js b/test/js/node/test/parallel/test-event-emitter-prepend.js
new file mode 100644
index 0000000000..ffe8544911
--- /dev/null
+++ b/test/js/node/test/parallel/test-event-emitter-prepend.js
@@ -0,0 +1,42 @@
+'use strict';
+
+const common = require('../common');
+const EventEmitter = require('events');
+const assert = require('assert');
+
+const myEE = new EventEmitter();
+let m = 0;
+// This one comes last.
+myEE.on('foo', common.mustCall(() => assert.strictEqual(m, 2)));
+
+// This one comes second.
+myEE.prependListener('foo', common.mustCall(() => assert.strictEqual(m++, 1)));
+
+// This one comes first.
+myEE.prependOnceListener('foo',
+                         common.mustCall(() => assert.strictEqual(m++, 0)));
+
+myEE.emit('foo');
+
+// Test fallback if prependListener is undefined.
+const stream = require('stream');
+
+delete EventEmitter.prototype.prependListener;
+
+function Writable() {
+  this.writable = true;
+  stream.Stream.call(this);
+}
+Object.setPrototypeOf(Writable.prototype, stream.Stream.prototype);
+Object.setPrototypeOf(Writable, stream.Stream);
+
+function Readable() {
+  this.readable = true;
+  stream.Stream.call(this);
+}
+Object.setPrototypeOf(Readable.prototype, stream.Stream.prototype);
+Object.setPrototypeOf(Readable, stream.Stream);
+
+const w = new Writable();
+const r = new Readable();
+r.pipe(w);
diff --git a/test/js/node/test/parallel/test-event-emitter-set-max-listeners-side-effects.js b/test/js/node/test/parallel/test-event-emitter-set-max-listeners-side-effects.js
new file mode 100644
index 0000000000..8e66e999a5
--- /dev/null
+++ b/test/js/node/test/parallel/test-event-emitter-set-max-listeners-side-effects.js
@@ -0,0 +1,32 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const events = require('events');
+
+const e = new events.EventEmitter();
+
+assert(!(e._events instanceof Object));
+assert.deepStrictEqual(Object.keys(e._events), []);
+e.setMaxListeners(5);
+assert.deepStrictEqual(Object.keys(e._events), []);
diff --git a/test/js/node/test/parallel/test-event-emitter-special-event-names.js b/test/js/node/test/parallel/test-event-emitter-special-event-names.js
new file mode 100644
index 0000000000..f34faba946
--- /dev/null
+++ b/test/js/node/test/parallel/test-event-emitter-special-event-names.js
@@ -0,0 +1,37 @@
+'use strict';
+
+const common = require('../common');
+const EventEmitter = require('events');
+const assert = require('assert');
+
+const ee = new EventEmitter();
+const handler = () => {};
+
+assert.deepStrictEqual(ee.eventNames(), []);
+
+assert.strictEqual(ee._events.hasOwnProperty, undefined);
+assert.strictEqual(ee._events.toString, undefined);
+
+ee.on('__proto__', handler);
+ee.on('__defineGetter__', handler);
+ee.on('toString', handler);
+
+assert.deepStrictEqual(ee.eventNames(), [
+  '__proto__',
+  '__defineGetter__',
+  'toString',
+]);
+
+assert.deepStrictEqual(ee.listeners('__proto__'), [handler]);
+assert.deepStrictEqual(ee.listeners('__defineGetter__'), [handler]);
+assert.deepStrictEqual(ee.listeners('toString'), [handler]);
+
+ee.on('__proto__', common.mustCall(function(val) {
+  assert.strictEqual(val, 1);
+}));
+ee.emit('__proto__', 1);
+
+process.on('__proto__', common.mustCall(function(val) {
+  assert.strictEqual(val, 1);
+}));
+process.emit('__proto__', 1);
diff --git a/test/js/node/test/parallel/test-event-emitter-subclass.js b/test/js/node/test/parallel/test-event-emitter-subclass.js
new file mode 100644
index 0000000000..a6ef54e5fa
--- /dev/null
+++ b/test/js/node/test/parallel/test-event-emitter-subclass.js
@@ -0,0 +1,67 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const EventEmitter = require('events').EventEmitter;
+
+Object.setPrototypeOf(MyEE.prototype, EventEmitter.prototype);
+Object.setPrototypeOf(MyEE, EventEmitter);
+
+function MyEE(cb) {
+  this.once(1, cb);
+  this.emit(1);
+  this.removeAllListeners();
+  EventEmitter.call(this);
+}
+
+const myee = new MyEE(common.mustCall());
+
+Object.setPrototypeOf(ErrorEE.prototype, EventEmitter.prototype);
+Object.setPrototypeOf(ErrorEE, EventEmitter);
+function ErrorEE() {
+  this.emit('error', new Error('blerg'));
+}
+
+assert.throws(function() {
+  new ErrorEE();
+}, /blerg/);
+
+process.on('exit', function() {
+  assert(!(myee._events instanceof Object));
+  assert.deepStrictEqual(Object.keys(myee._events), []);
+  console.log('ok');
+});
+
+
+function MyEE2() {
+  EventEmitter.call(this);
+}
+
+MyEE2.prototype = new EventEmitter();
+
+const ee1 = new MyEE2();
+const ee2 = new MyEE2();
+
+ee1.on('x', () => {});
+
+assert.strictEqual(ee2.listenerCount('x'), 0);
diff --git a/test/js/node/test/parallel/test-event-emitter-symbols.js b/test/js/node/test/parallel/test-event-emitter-symbols.js
new file mode 100644
index 0000000000..98d44ff3fa
--- /dev/null
+++ b/test/js/node/test/parallel/test-event-emitter-symbols.js
@@ -0,0 +1,23 @@
+'use strict';
+
+const common = require('../common');
+const EventEmitter = require('events');
+const assert = require('assert');
+
+const ee = new EventEmitter();
+const foo = Symbol('foo');
+const listener = common.mustCall();
+
+ee.on(foo, listener);
+assert.deepStrictEqual(ee.listeners(foo), [listener]);
+
+ee.emit(foo);
+
+ee.removeAllListeners();
+assert.deepStrictEqual(ee.listeners(foo), []);
+
+ee.on(foo, listener);
+assert.deepStrictEqual(ee.listeners(foo), [listener]);
+
+ee.removeListener(foo, listener);
+assert.deepStrictEqual(ee.listeners(foo), []);
diff --git a/test/js/node/test/parallel/test-event-target.js b/test/js/node/test/parallel/test-event-target.js
new file mode 100644
index 0000000000..12246b15ae
--- /dev/null
+++ b/test/js/node/test/parallel/test-event-target.js
@@ -0,0 +1,21 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+
+const eventPhases = {
+  'NONE': 0,
+  'CAPTURING_PHASE': 1,
+  'AT_TARGET': 2,
+  'BUBBLING_PHASE': 3
+};
+
+for (const [prop, value] of Object.entries(eventPhases)) {
+  // Check if the value of the property matches the expected value
+  assert.strictEqual(Event[prop], value, `Expected Event.${prop} to be ${value}, but got ${Event[prop]}`);
+
+  const desc = Object.getOwnPropertyDescriptor(Event, prop);
+  assert.strictEqual(desc.writable, false, `${prop} should not be writable`);
+  assert.strictEqual(desc.configurable, false, `${prop} should not be configurable`);
+  assert.strictEqual(desc.enumerable, true, `${prop} should be enumerable`);
+}
diff --git a/test/js/node/test/parallel/test-events-getmaxlisteners.js b/test/js/node/test/parallel/test-events-getmaxlisteners.js
new file mode 100644
index 0000000000..05b4e75b72
--- /dev/null
+++ b/test/js/node/test/parallel/test-events-getmaxlisteners.js
@@ -0,0 +1,19 @@
+'use strict';
+
+require('../common');
+const assert = require('node:assert');
+const { getMaxListeners, EventEmitter, defaultMaxListeners, setMaxListeners } = require('node:events');
+
+{
+  const ee = new EventEmitter();
+  assert.strictEqual(getMaxListeners(ee), defaultMaxListeners);
+  setMaxListeners(101, ee);
+  assert.strictEqual(getMaxListeners(ee), 101);
+}
+
+{
+  const et = new EventTarget();
+  assert.strictEqual(getMaxListeners(et), defaultMaxListeners);
+  setMaxListeners(101, et);
+  assert.strictEqual(getMaxListeners(et), 101);
+}
diff --git a/test/js/node/test/parallel/test-events-list.js b/test/js/node/test/parallel/test-events-list.js
new file mode 100644
index 0000000000..4e589b07f2
--- /dev/null
+++ b/test/js/node/test/parallel/test-events-list.js
@@ -0,0 +1,19 @@
+'use strict';
+
+require('../common');
+const EventEmitter = require('events');
+const assert = require('assert');
+
+const EE = new EventEmitter();
+const m = () => {};
+EE.on('foo', () => {});
+assert.deepStrictEqual(['foo'], EE.eventNames());
+EE.on('bar', m);
+assert.deepStrictEqual(['foo', 'bar'], EE.eventNames());
+EE.removeListener('bar', m);
+assert.deepStrictEqual(['foo'], EE.eventNames());
+const s = Symbol('s');
+EE.on(s, m);
+assert.deepStrictEqual(['foo', s], EE.eventNames());
+EE.removeListener(s, m);
+assert.deepStrictEqual(['foo'], EE.eventNames());
diff --git a/test/js/node/test/parallel/test-events-uncaught-exception-stack.js b/test/js/node/test/parallel/test-events-uncaught-exception-stack.js
new file mode 100644
index 0000000000..e330f254ae
--- /dev/null
+++ b/test/js/node/test/parallel/test-events-uncaught-exception-stack.js
@@ -0,0 +1,16 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const EventEmitter = require('events');
+
+// Tests that the error stack where the exception was thrown is *not* appended.
+
+process.on('uncaughtException', common.mustCall((err) => {
+  const lines = err.stack.split('\n');
+  assert.strictEqual(lines[0], 'Error');
+  lines.slice(1).forEach((line) => {
+    assert.match(line, /^ {4}at/);
+  });
+}));
+
+new EventEmitter().emit('error', new Error());
diff --git a/test/js/node/test/parallel/test-eventsource-disabled.js b/test/js/node/test/parallel/test-eventsource-disabled.js
new file mode 100644
index 0000000000..ade4f51d99
--- /dev/null
+++ b/test/js/node/test/parallel/test-eventsource-disabled.js
@@ -0,0 +1,6 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+
+assert.strictEqual(typeof EventSource, 'undefined');
diff --git a/test/js/node/test/parallel/test-eventtarget-once-twice.js b/test/js/node/test/parallel/test-eventtarget-once-twice.js
new file mode 100644
index 0000000000..3358bab90e
--- /dev/null
+++ b/test/js/node/test/parallel/test-eventtarget-once-twice.js
@@ -0,0 +1,14 @@
+'use strict';
+const common = require('../common');
+const { once } = require('events');
+
+const et = new EventTarget();
+(async function() {
+  await once(et, 'foo');
+  await once(et, 'foo');
+})().then(common.mustCall());
+
+et.dispatchEvent(new Event('foo'));
+setImmediate(() => {
+  et.dispatchEvent(new Event('foo'));
+});
diff --git a/test/js/node/test/parallel/test-exception-handler.js b/test/js/node/test/parallel/test-exception-handler.js
new file mode 100644
index 0000000000..ca25ccd6ef
--- /dev/null
+++ b/test/js/node/test/parallel/test-exception-handler.js
@@ -0,0 +1,40 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+const MESSAGE = 'catch me if you can';
+
+process.on('uncaughtException', common.mustCall((e) => {
+  console.log('uncaught exception! 1');
+  assert.strictEqual(MESSAGE, e.message);
+}));
+
+process.on('uncaughtException', common.mustCall((e) => {
+  console.log('uncaught exception! 2');
+  assert.strictEqual(MESSAGE, e.message);
+}));
+
+setTimeout(() => {
+  throw new Error(MESSAGE);
+}, 10);
diff --git a/test/js/node/test/parallel/test-exception-handler2.js b/test/js/node/test/parallel/test-exception-handler2.js
new file mode 100644
index 0000000000..ae95d45245
--- /dev/null
+++ b/test/js/node/test/parallel/test-exception-handler2.js
@@ -0,0 +1,36 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+process.on('uncaughtException', function(err) {
+  console.log(`Caught exception: ${err}`);
+});
+
+setTimeout(common.mustCall(function() {
+  console.log('This will still run.');
+}), 50);
+
+// Intentionally cause an exception, but don't catch it.
+nonexistentFunc(); // eslint-disable-line no-undef
+assert.fail('This will not run.');
diff --git a/test/js/node/test/parallel/test-fetch.mjs b/test/js/node/test/parallel/test-fetch.mjs
new file mode 100644
index 0000000000..bbdb7130ed
--- /dev/null
+++ b/test/js/node/test/parallel/test-fetch.mjs
@@ -0,0 +1,36 @@
+import * as common from '../common/index.mjs';
+
+import assert from 'assert';
+import events from 'events';
+import http from 'http';
+
+assert.strictEqual(typeof globalThis.fetch, 'function');
+assert.strictEqual(typeof globalThis.FormData, 'function');
+assert.strictEqual(typeof globalThis.Headers, 'function');
+assert.strictEqual(typeof globalThis.Request, 'function');
+assert.strictEqual(typeof globalThis.Response, 'function');
+
+{
+  const asyncFunction = async function() {}.constructor;
+
+  assert.ok(!(fetch instanceof asyncFunction));
+  assert.notStrictEqual(Reflect.getPrototypeOf(fetch), Reflect.getPrototypeOf(async function() {}));
+  assert.strictEqual(Reflect.getPrototypeOf(fetch), Reflect.getPrototypeOf(function() {}));
+}
+
+const server = http.createServer(common.mustCall((req, res) => {
+  res.end('Hello world');
+}));
+server.listen(0);
+await events.once(server, 'listening');
+const port = server.address().port;
+
+const response = await fetch(`http://localhost:${port}`);
+
+assert(response instanceof Response);
+assert.strictEqual(response.status, 200);
+assert.strictEqual(response.statusText, 'OK');
+const body = await response.text();
+assert.strictEqual(body, 'Hello world');
+
+server.close();
diff --git a/test/js/node/test/parallel/test-file-read-noexist.js b/test/js/node/test/parallel/test-file-read-noexist.js
new file mode 100644
index 0000000000..7293113f22
--- /dev/null
+++ b/test/js/node/test/parallel/test-file-read-noexist.js
@@ -0,0 +1,32 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+const fs = require('fs');
+
+const filename = fixtures.path('does_not_exist.txt');
+fs.readFile(filename, 'latin1', common.mustCall(function(err, content) {
+  assert.ok(err);
+  assert.strictEqual(err.code, 'ENOENT');
+}));
diff --git a/test/js/node/test/parallel/test-file-validate-mode-flag.js b/test/js/node/test/parallel/test-file-validate-mode-flag.js
new file mode 100644
index 0000000000..62a9ef2ca2
--- /dev/null
+++ b/test/js/node/test/parallel/test-file-validate-mode-flag.js
@@ -0,0 +1,40 @@
+'use strict';
+
+// Checks for crash regression: https://github.com/nodejs/node/issues/37430
+
+const common = require('../common');
+const assert = require('assert');
+const {
+  open,
+  openSync,
+  promises: {
+    open: openPromise,
+  },
+} = require('fs');
+
+// These should throw, not crash.
+const invalid = 4_294_967_296;
+
+assert.throws(() => open(__filename, invalid, common.mustNotCall()), {
+  code: 'ERR_OUT_OF_RANGE'
+});
+
+assert.throws(() => open(__filename, 0, invalid, common.mustNotCall()), {
+  code: 'ERR_OUT_OF_RANGE'
+});
+
+assert.throws(() => openSync(__filename, invalid), {
+  code: 'ERR_OUT_OF_RANGE'
+});
+
+assert.throws(() => openSync(__filename, 0, invalid), {
+  code: 'ERR_OUT_OF_RANGE'
+});
+
+assert.rejects(openPromise(__filename, invalid), {
+  code: 'ERR_OUT_OF_RANGE'
+}).then(common.mustCall());
+
+assert.rejects(openPromise(__filename, 0, invalid), {
+  code: 'ERR_OUT_OF_RANGE'
+}).then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-filehandle-close.js b/test/js/node/test/parallel/test-filehandle-close.js
new file mode 100644
index 0000000000..6e55f3f06d
--- /dev/null
+++ b/test/js/node/test/parallel/test-filehandle-close.js
@@ -0,0 +1,17 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const fs = require('fs');
+
+// Test that using FileHandle.close to close an already-closed fd fails
+// with EBADF.
+
+(async function() {
+  const fh = await fs.promises.open(__filename);
+  fs.closeSync(fh.fd);
+
+  await assert.rejects(() => fh.close(), {
+    code: 'EBADF',
+    syscall: 'close'
+  });
+})().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-fs-buffertype-writesync.js b/test/js/node/test/parallel/test-fs-buffertype-writesync.js
new file mode 100644
index 0000000000..5649a00569
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-buffertype-writesync.js
@@ -0,0 +1,16 @@
+'use strict';
+require('../common');
+
+// This test ensures that writeSync throws for invalid data input.
+
+const assert = require('assert');
+const fs = require('fs');
+
+[
+  true, false, 0, 1, Infinity, () => {}, {}, [], undefined, null,
+].forEach((value) => {
+  assert.throws(
+    () => fs.writeSync(1, value),
+    { message: /"buffer"/, code: 'ERR_INVALID_ARG_TYPE' }
+  );
+});
diff --git a/test/js/node/test/parallel/test-fs-chmod-mask.js b/test/js/node/test/parallel/test-fs-chmod-mask.js
new file mode 100644
index 0000000000..53f1931be4
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-chmod-mask.js
@@ -0,0 +1,89 @@
+'use strict';
+
+// This tests that the lower bits of mode > 0o777 still works in fs APIs.
+
+const common = require('../common');
+const assert = require('assert');
+const fs = require('fs');
+
+let mode;
+// On Windows chmod is only able to manipulate write permission
+if (common.isWindows) {
+  mode = 0o444;  // read-only
+} else {
+  mode = 0o777;
+}
+
+const maskToIgnore = 0o10000;
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+function test(mode, asString) {
+  const suffix = asString ? 'str' : 'num';
+  const input = asString ?
+    (mode | maskToIgnore).toString(8) : (mode | maskToIgnore);
+
+  {
+    const file = tmpdir.resolve(`chmod-async-${suffix}.txt`);
+    fs.writeFileSync(file, 'test', 'utf-8');
+
+    fs.chmod(file, input, common.mustSucceed(() => {
+      assert.strictEqual(fs.statSync(file).mode & 0o777, mode);
+    }));
+  }
+
+  {
+    const file = tmpdir.resolve(`chmodSync-${suffix}.txt`);
+    fs.writeFileSync(file, 'test', 'utf-8');
+
+    fs.chmodSync(file, input);
+    assert.strictEqual(fs.statSync(file).mode & 0o777, mode);
+  }
+
+  {
+    const file = tmpdir.resolve(`fchmod-async-${suffix}.txt`);
+    fs.writeFileSync(file, 'test', 'utf-8');
+    fs.open(file, 'w', common.mustSucceed((fd) => {
+      fs.fchmod(fd, input, common.mustSucceed(() => {
+        assert.strictEqual(fs.fstatSync(fd).mode & 0o777, mode);
+        fs.close(fd, assert.ifError);
+      }));
+    }));
+  }
+
+  {
+    const file = tmpdir.resolve(`fchmodSync-${suffix}.txt`);
+    fs.writeFileSync(file, 'test', 'utf-8');
+    const fd = fs.openSync(file, 'w');
+
+    fs.fchmodSync(fd, input);
+    assert.strictEqual(fs.fstatSync(fd).mode & 0o777, mode);
+
+    fs.close(fd, assert.ifError);
+  }
+
+  if (fs.lchmod) {
+    const link = tmpdir.resolve(`lchmod-src-${suffix}`);
+    const file = tmpdir.resolve(`lchmod-dest-${suffix}`);
+    fs.writeFileSync(file, 'test', 'utf-8');
+    fs.symlinkSync(file, link);
+
+    fs.lchmod(link, input, common.mustSucceed(() => {
+      assert.strictEqual(fs.lstatSync(link).mode & 0o777, mode);
+    }));
+  }
+
+  if (fs.lchmodSync) {
+    const link = tmpdir.resolve(`lchmodSync-src-${suffix}`);
+    const file = tmpdir.resolve(`lchmodSync-dest-${suffix}`);
+    fs.writeFileSync(file, 'test', 'utf-8');
+    fs.symlinkSync(file, link);
+
+    fs.lchmodSync(link, input);
+    assert.strictEqual(fs.lstatSync(link).mode & 0o777, mode);
+  }
+}
+
+test(mode, true);
+test(mode, false);
diff --git a/test/js/node/test/parallel/test-fs-chown-type-check.js b/test/js/node/test/parallel/test-fs-chown-type-check.js
new file mode 100644
index 0000000000..0ca78aa86e
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-chown-type-check.js
@@ -0,0 +1,53 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const fs = require('fs');
+
+[false, 1, {}, [], null, undefined].forEach((i) => {
+  assert.throws(
+    () => fs.chown(i, 1, 1, common.mustNotCall()),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError'
+    }
+  );
+  assert.throws(
+    () => fs.chownSync(i, 1, 1),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError'
+    }
+  );
+});
+
+[false, 'test', {}, [], null, undefined].forEach((i) => {
+  assert.throws(
+    () => fs.chown('not_a_file_that_exists', i, 1, common.mustNotCall()),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError'
+    }
+  );
+  assert.throws(
+    () => fs.chown('not_a_file_that_exists', 1, i, common.mustNotCall()),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError'
+    }
+  );
+  assert.throws(
+    () => fs.chownSync('not_a_file_that_exists', i, 1),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError'
+    }
+  );
+  assert.throws(
+    () => fs.chownSync('not_a_file_that_exists', 1, i),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError'
+    }
+  );
+});
diff --git a/test/js/node/test/parallel/test-fs-constants.js b/test/js/node/test/parallel/test-fs-constants.js
new file mode 100644
index 0000000000..49bcabd808
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-constants.js
@@ -0,0 +1,8 @@
+'use strict';
+require('../common');
+const fs = require('fs');
+const assert = require('assert');
+
+// Check if the two constants accepted by chmod() on Windows are defined.
+assert.notStrictEqual(fs.constants.S_IRUSR, undefined);
+assert.notStrictEqual(fs.constants.S_IWUSR, undefined);
diff --git a/test/js/node/test/parallel/test-fs-copyfile-respect-permissions.js b/test/js/node/test/parallel/test-fs-copyfile-respect-permissions.js
new file mode 100644
index 0000000000..d668ec63ec
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-copyfile-respect-permissions.js
@@ -0,0 +1,58 @@
+'use strict';
+
+// Test that fs.copyFile() respects file permissions.
+// Ref: https://github.com/nodejs/node/issues/26936
+
+const common = require('../common');
+
+if (!common.isWindows && process.getuid() === 0)
+  common.skip('as this test should not be run as `root`');
+
+if (common.isIBMi)
+  common.skip('IBMi has a different access permission mechanism');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+const assert = require('assert');
+const fs = require('fs');
+
+let n = 0;
+
+function beforeEach() {
+  n++;
+  const source = tmpdir.resolve(`source${n}`);
+  const dest = tmpdir.resolve(`dest${n}`);
+  fs.writeFileSync(source, 'source');
+  fs.writeFileSync(dest, 'dest');
+  fs.chmodSync(dest, '444');
+
+  const check = (err) => {
+    const expected = ['EACCES', 'EPERM'];
+    assert(expected.includes(err.code), `${err.code} not in ${expected}`);
+    assert.strictEqual(fs.readFileSync(dest, 'utf8'), 'dest');
+    return true;
+  };
+
+  return { source, dest, check };
+}
+
+// Test synchronous API.
+{
+  const { source, dest, check } = beforeEach();
+  assert.throws(() => { fs.copyFileSync(source, dest); }, check);
+}
+
+// Test promises API.
+{
+  const { source, dest, check } = beforeEach();
+  (async () => {
+    await assert.rejects(fs.promises.copyFile(source, dest), check);
+  })().then(common.mustCall());
+}
+
+// Test callback API.
+{
+  const { source, dest, check } = beforeEach();
+  fs.copyFile(source, dest, common.mustCall(check));
+}
diff --git a/test/js/node/test/parallel/test-fs-empty-readStream.js b/test/js/node/test/parallel/test-fs-empty-readStream.js
new file mode 100644
index 0000000000..7cbe4d5005
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-empty-readStream.js
@@ -0,0 +1,50 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const fs = require('fs');
+const fixtures = require('../common/fixtures');
+
+const emptyFile = fixtures.path('empty.txt');
+
+fs.open(emptyFile, 'r', common.mustSucceed((fd) => {
+  const read = fs.createReadStream(emptyFile, { fd });
+
+  read.once('data', common.mustNotCall('data event should not emit'));
+
+  read.once('end', common.mustCall());
+}));
+
+fs.open(emptyFile, 'r', common.mustSucceed((fd) => {
+  const read = fs.createReadStream(emptyFile, { fd });
+
+  read.pause();
+
+  read.once('data', common.mustNotCall('data event should not emit'));
+
+  read.once('end', common.mustNotCall('end event should not emit'));
+
+  setTimeout(common.mustCall(() => {
+    assert.strictEqual(read.isPaused(), true);
+  }), common.platformTimeout(50));
+}));
diff --git a/test/js/node/test/parallel/test-fs-existssync-false.js b/test/js/node/test/parallel/test-fs-existssync-false.js
new file mode 100644
index 0000000000..e81e6c7a31
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-existssync-false.js
@@ -0,0 +1,34 @@
+'use strict';
+const common = require('../common');
+const tmpdir = require('../common/tmpdir');
+
+// This test ensures that fs.existsSync doesn't incorrectly return false.
+// (especially on Windows)
+// https://github.com/nodejs/node-v0.x-archive/issues/3739
+
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+
+let dir = path.resolve(tmpdir.path);
+
+// Make sure that the tmp directory is clean
+tmpdir.refresh();
+
+// Make a long path.
+for (let i = 0; i < 50; i++) {
+  dir = `${dir}/1234567890`;
+  try {
+    fs.mkdirSync(dir, '0777');
+  } catch (e) {
+    if (e.code !== 'EEXIST') {
+      throw e;
+    }
+  }
+}
+
+// Test if file exists synchronously
+assert(fs.existsSync(dir), 'Directory is not accessible');
+
+// Test if file exists asynchronously
+fs.access(dir, common.mustSucceed());
diff --git a/test/js/node/test/parallel/test-fs-fmap.js b/test/js/node/test/parallel/test-fs-fmap.js
new file mode 100644
index 0000000000..c4298f0d0e
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-fmap.js
@@ -0,0 +1,28 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const fs = require('fs');
+
+const {
+  O_CREAT = 0,
+  O_RDONLY = 0,
+  O_TRUNC = 0,
+  O_WRONLY = 0,
+  UV_FS_O_FILEMAP = 0
+} = fs.constants;
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+// Run this test on all platforms. While UV_FS_O_FILEMAP is only available on
+// Windows, it should be silently ignored on other platforms.
+
+const filename = tmpdir.resolve('fmap.txt');
+const text = 'Memory File Mapping Test';
+
+const mw = UV_FS_O_FILEMAP | O_TRUNC | O_CREAT | O_WRONLY;
+const mr = UV_FS_O_FILEMAP | O_RDONLY;
+
+fs.writeFileSync(filename, text, { flag: mw });
+const r1 = fs.readFileSync(filename, { encoding: 'utf8', flag: mr });
+assert.strictEqual(r1, text);
diff --git a/test/js/node/test/parallel/test-fs-fsync.js b/test/js/node/test/parallel/test-fs-fsync.js
new file mode 100644
index 0000000000..6168c08d5b
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-fsync.js
@@ -0,0 +1,58 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const fixtures = require('../common/fixtures');
+const tmpdir = require('../common/tmpdir');
+
+const fs = require('fs');
+
+const fileFixture = fixtures.path('a.js');
+const fileTemp = tmpdir.resolve('a.js');
+
+// Copy fixtures to temp.
+tmpdir.refresh();
+fs.copyFileSync(fileFixture, fileTemp);
+
+fs.open(fileTemp, 'a', 0o777, common.mustSucceed((fd) => {
+  fs.fdatasyncSync(fd);
+
+  fs.fsyncSync(fd);
+
+  fs.fdatasync(fd, common.mustSucceed(() => {
+    fs.fsync(fd, common.mustSucceed(() => {
+      fs.closeSync(fd);
+    }));
+  }));
+}));
+
+['', false, null, undefined, {}, []].forEach((input) => {
+  const errObj = {
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError'
+  };
+  assert.throws(() => fs.fdatasync(input), errObj);
+  assert.throws(() => fs.fdatasyncSync(input), errObj);
+  assert.throws(() => fs.fsync(input), errObj);
+  assert.throws(() => fs.fsyncSync(input), errObj);
+});
diff --git a/test/js/node/test/parallel/test-fs-link.js b/test/js/node/test/parallel/test-fs-link.js
new file mode 100644
index 0000000000..df5f606d0c
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-link.js
@@ -0,0 +1,53 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const fs = require('fs');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+// Test creating and reading hard link
+const srcPath = tmpdir.resolve('hardlink-target.txt');
+const dstPath = tmpdir.resolve('link1.js');
+fs.writeFileSync(srcPath, 'hello world');
+
+function callback(err) {
+  assert.ifError(err);
+  const dstContent = fs.readFileSync(dstPath, 'utf8');
+  assert.strictEqual(dstContent, 'hello world');
+}
+
+fs.link(srcPath, dstPath, common.mustCall(callback));
+
+// test error outputs
+
+[false, 1, [], {}, null, undefined].forEach((i) => {
+  assert.throws(
+    () => fs.link(i, '', common.mustNotCall()),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError'
+    }
+  );
+  assert.throws(
+    () => fs.link('', i, common.mustNotCall()),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError'
+    }
+  );
+  assert.throws(
+    () => fs.linkSync(i, ''),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError'
+    }
+  );
+  assert.throws(
+    () => fs.linkSync('', i),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError'
+    }
+  );
+});
diff --git a/test/js/node/test/parallel/test-fs-long-path.js b/test/js/node/test/parallel/test-fs-long-path.js
new file mode 100644
index 0000000000..11724a88dc
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-long-path.js
@@ -0,0 +1,52 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+if (!common.isWindows)
+  common.skip('this test is Windows-specific.');
+
+const fs = require('fs');
+const path = require('path');
+
+const tmpdir = require('../common/tmpdir');
+
+// Make a path that will be at least 260 chars long.
+const fileNameLen = Math.max(260 - tmpdir.path.length - 1, 1);
+const fileName = tmpdir.resolve('x'.repeat(fileNameLen));
+const fullPath = path.resolve(fileName);
+
+tmpdir.refresh();
+
+console.log({
+  filenameLength: fileName.length,
+  fullPathLength: fullPath.length
+});
+
+fs.writeFile(fullPath, 'ok', common.mustSucceed(() => {
+  fs.stat(fullPath, common.mustSucceed());
+
+  // Tests https://github.com/nodejs/node/issues/39721
+  fs.realpath.native(fullPath, common.mustSucceed());
+
+  // Tests https://github.com/nodejs/node/issues/51031
+  fs.promises.realpath(fullPath).then(common.mustCall(), common.mustNotCall());
+}));
diff --git a/test/js/node/test/parallel/test-fs-make-callback.js b/test/js/node/test/parallel/test-fs-make-callback.js
new file mode 100644
index 0000000000..d9341ab06f
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-make-callback.js
@@ -0,0 +1,28 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const fs = require('fs');
+const callbackThrowValues = [null, true, false, 0, 1, 'foo', /foo/, [], {}];
+
+const { sep } = require('path');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+function testMakeCallback(cb) {
+  return function() {
+    // fs.mkdtemp() calls makeCallback() on its third argument
+    fs.mkdtemp(`${tmpdir.path}${sep}`, {}, cb);
+  };
+}
+
+function invalidCallbackThrowsTests() {
+  callbackThrowValues.forEach((value) => {
+    assert.throws(testMakeCallback(value), {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError'
+    });
+  });
+}
+
+invalidCallbackThrowsTests();
diff --git a/test/js/node/test/parallel/test-fs-makeStatsCallback.js b/test/js/node/test/parallel/test-fs-makeStatsCallback.js
new file mode 100644
index 0000000000..953fc065e8
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-makeStatsCallback.js
@@ -0,0 +1,26 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const fs = require('fs');
+const callbackThrowValues = [null, true, false, 0, 1, 'foo', /foo/, [], {}];
+
+function testMakeStatsCallback(cb) {
+  return function() {
+    // fs.stat() calls makeStatsCallback() on its second argument
+    fs.stat(__filename, cb);
+  };
+}
+
+// Verify the case where a callback function is provided
+testMakeStatsCallback(common.mustCall())();
+
+function invalidCallbackThrowsTests() {
+  callbackThrowValues.forEach((value) => {
+    assert.throws(testMakeStatsCallback(value), {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError'
+    });
+  });
+}
+
+invalidCallbackThrowsTests();
diff --git a/test/js/node/test/parallel/test-fs-mkdir-recursive-eaccess.js b/test/js/node/test/parallel/test-fs-mkdir-recursive-eaccess.js
new file mode 100644
index 0000000000..034a230948
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-mkdir-recursive-eaccess.js
@@ -0,0 +1,70 @@
+'use strict';
+
+// Test that mkdir with recursive option returns appropriate error
+// when executed on folder it does not have permission to access.
+// Ref: https://github.com/nodejs/node/issues/31481
+
+const common = require('../common');
+
+if (!common.isWindows && process.getuid() === 0)
+  common.skip('as this test should not be run as `root`');
+
+if (common.isIBMi)
+  common.skip('IBMi has a different access permission mechanism');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+const assert = require('assert');
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+let n = 0;
+
+function makeDirectoryReadOnly(dir) {
+  let accessErrorCode = 'EACCES';
+  if (common.isWindows) {
+    accessErrorCode = 'EPERM';
+    execSync(`icacls ${dir} /deny "everyone:(OI)(CI)(DE,DC,AD,WD)"`);
+  } else {
+    fs.chmodSync(dir, '444');
+  }
+  return accessErrorCode;
+}
+
+function makeDirectoryWritable(dir) {
+  if (common.isWindows) {
+    execSync(`icacls ${dir} /remove:d "everyone"`);
+  }
+}
+
+// Synchronous API should return an EACCESS error with path populated.
+{
+  const dir = tmpdir.resolve(`mkdirp_${n++}`);
+  fs.mkdirSync(dir);
+  const codeExpected = makeDirectoryReadOnly(dir);
+  let err = null;
+  try {
+    fs.mkdirSync(path.join(dir, '/foo'), { recursive: true });
+  } catch (_err) {
+    err = _err;
+  }
+  makeDirectoryWritable(dir);
+  assert(err);
+  assert.strictEqual(err.code, codeExpected);
+  assert(err.path);
+}
+
+// Asynchronous API should return an EACCESS error with path populated.
+{
+  const dir = tmpdir.resolve(`mkdirp_${n++}`);
+  fs.mkdirSync(dir);
+  const codeExpected = makeDirectoryReadOnly(dir);
+  fs.mkdir(path.join(dir, '/bar'), { recursive: true }, (err) => {
+    makeDirectoryWritable(dir);
+    assert(err);
+    assert.strictEqual(err.code, codeExpected);
+    assert(err.path);
+  });
+}
diff --git a/test/js/node/test/parallel/test-fs-mkdtemp-prefix-check.js b/test/js/node/test/parallel/test-fs-mkdtemp-prefix-check.js
new file mode 100644
index 0000000000..af5cb6ab7d
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-mkdtemp-prefix-check.js
@@ -0,0 +1,33 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const fs = require('fs');
+
+const prefixValues = [undefined, null, 0, true, false, 1];
+
+function fail(value) {
+  assert.throws(
+    () => {
+      fs.mkdtempSync(value, {});
+    },
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError'
+    });
+}
+
+function failAsync(value) {
+  assert.throws(
+    () => {
+      fs.mkdtemp(value, common.mustNotCall());
+    },
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError'
+    });
+}
+
+for (const prefixValue of prefixValues) {
+  fail(prefixValue);
+  failAsync(prefixValue);
+}
diff --git a/test/js/node/test/parallel/test-fs-non-number-arguments-throw.js b/test/js/node/test/parallel/test-fs-non-number-arguments-throw.js
new file mode 100644
index 0000000000..dbcec683cd
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-non-number-arguments-throw.js
@@ -0,0 +1,47 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const fs = require('fs');
+const tmpdir = require('../common/tmpdir');
+const tempFile = tmpdir.resolve('fs-non-number-arguments-throw');
+
+tmpdir.refresh();
+fs.writeFileSync(tempFile, 'abc\ndef');
+
+// A sanity check when using numbers instead of strings
+const sanity = 'def';
+const saneEmitter = fs.createReadStream(tempFile, { start: 4, end: 6 });
+
+assert.throws(
+  () => {
+    fs.createReadStream(tempFile, { start: '4', end: 6 });
+  },
+  {
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError'
+  });
+
+assert.throws(
+  () => {
+    fs.createReadStream(tempFile, { start: 4, end: '6' });
+  },
+  {
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError'
+  });
+
+assert.throws(
+  () => {
+    fs.createWriteStream(tempFile, { start: '4' });
+  },
+  {
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError'
+  });
+
+saneEmitter.on('data', common.mustCall(function(data) {
+  assert.strictEqual(
+    sanity, data.toString('utf8'),
+    `read ${data.toString('utf8')} instead of ${sanity}`);
+}));
diff --git a/test/js/node/test/parallel/test-fs-open-mode-mask.js b/test/js/node/test/parallel/test-fs-open-mode-mask.js
new file mode 100644
index 0000000000..a79591c0ae
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-open-mode-mask.js
@@ -0,0 +1,40 @@
+'use strict';
+
+// This tests that the lower bits of mode > 0o777 still works in fs.open().
+
+const common = require('../common');
+const assert = require('assert');
+const fs = require('fs');
+
+const mode = common.isWindows ? 0o444 : 0o644;
+
+const maskToIgnore = 0o10000;
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+function test(mode, asString) {
+  const suffix = asString ? 'str' : 'num';
+  const input = asString ?
+    (mode | maskToIgnore).toString(8) : (mode | maskToIgnore);
+
+  {
+    const file = tmpdir.resolve(`openSync-${suffix}.txt`);
+    const fd = fs.openSync(file, 'w+', input);
+    assert.strictEqual(fs.fstatSync(fd).mode & 0o777, mode);
+    fs.closeSync(fd);
+    assert.strictEqual(fs.statSync(file).mode & 0o777, mode);
+  }
+
+  {
+    const file = tmpdir.resolve(`open-${suffix}.txt`);
+    fs.open(file, 'w+', input, common.mustSucceed((fd) => {
+      assert.strictEqual(fs.fstatSync(fd).mode & 0o777, mode);
+      fs.closeSync(fd);
+      assert.strictEqual(fs.statSync(file).mode & 0o777, mode);
+    }));
+  }
+}
+
+test(mode, true);
+test(mode, false);
diff --git a/test/js/node/test/parallel/test-fs-open-no-close.js b/test/js/node/test/parallel/test-fs-open-no-close.js
new file mode 100644
index 0000000000..41b58f5ef7
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-open-no-close.js
@@ -0,0 +1,31 @@
+'use strict';
+
+// Refs: https://github.com/nodejs/node/issues/34266
+// Failing to close a file should not keep the event loop open.
+
+const common = require('../common');
+const assert = require('assert');
+
+const fs = require('fs');
+
+const debuglog = (arg) => {
+  console.log(new Date().toLocaleString(), arg);
+};
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+let openFd;
+
+fs.open(`${tmpdir.path}/dummy`, 'wx+', common.mustCall((err, fd) => {
+  debuglog('fs open() callback');
+  assert.ifError(err);
+  openFd = fd;
+}));
+debuglog('waiting for callback');
+
+process.on('beforeExit', common.mustCall(() => {
+  if (openFd) {
+    fs.closeSync(openFd);
+  }
+}));
diff --git a/test/js/node/test/parallel/test-fs-open-numeric-flags.js b/test/js/node/test/parallel/test-fs-open-numeric-flags.js
new file mode 100644
index 0000000000..3237b2764e
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-open-numeric-flags.js
@@ -0,0 +1,15 @@
+'use strict';
+require('../common');
+
+const assert = require('assert');
+const fs = require('fs');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+// O_WRONLY without O_CREAT shall fail with ENOENT
+const pathNE = tmpdir.resolve('file-should-not-exist');
+assert.throws(
+  () => fs.openSync(pathNE, fs.constants.O_WRONLY),
+  (e) => e.code === 'ENOENT'
+);
diff --git a/test/js/node/test/parallel/test-fs-open.js b/test/js/node/test/parallel/test-fs-open.js
new file mode 100644
index 0000000000..0855e521f7
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-open.js
@@ -0,0 +1,120 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const fs = require('fs');
+
+let caughtException = false;
+
+try {
+  // Should throw ENOENT, not EBADF
+  // see https://github.com/joyent/node/pull/1228
+  fs.openSync('/8hvftyuncxrt/path/to/file/that/does/not/exist', 'r');
+} catch (e) {
+  assert.strictEqual(e.code, 'ENOENT');
+  caughtException = true;
+}
+assert.strictEqual(caughtException, true);
+
+fs.openSync(__filename);
+
+fs.open(__filename, common.mustSucceed());
+
+fs.open(__filename, 'r', common.mustSucceed());
+
+fs.open(__filename, 'rs', common.mustSucceed());
+
+fs.open(__filename, 'r', 0, common.mustSucceed());
+
+fs.open(__filename, 'r', null, common.mustSucceed());
+
+async function promise() {
+  await fs.promises.open(__filename);
+  await fs.promises.open(__filename, 'r');
+}
+
+promise().then(common.mustCall()).catch(common.mustNotCall());
+
+assert.throws(
+  () => fs.open(__filename, 'r', 'boom', common.mustNotCall()),
+  {
+    code: 'ERR_INVALID_ARG_VALUE',
+    name: 'TypeError'
+  }
+);
+
+for (const extra of [[], ['r'], ['r', 0], ['r', 0, 'bad callback']]) {
+  assert.throws(
+    () => fs.open(__filename, ...extra),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError'
+    }
+  );
+}
+
+[false, 1, [], {}, null, undefined].forEach((i) => {
+  assert.throws(
+    () => fs.open(i, 'r', common.mustNotCall()),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError'
+    }
+  );
+  assert.throws(
+    () => fs.openSync(i, 'r', common.mustNotCall()),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError'
+    }
+  );
+  assert.rejects(
+    fs.promises.open(i, 'r'),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError'
+    }
+  ).then(common.mustCall());
+});
+
+// Check invalid modes.
+[false, [], {}].forEach((mode) => {
+  assert.throws(
+    () => fs.open(__filename, 'r', mode, common.mustNotCall()),
+    {
+      code: 'ERR_INVALID_ARG_TYPE'
+    }
+  );
+  assert.throws(
+    () => fs.openSync(__filename, 'r', mode, common.mustNotCall()),
+    {
+      code: 'ERR_INVALID_ARG_TYPE'
+    }
+  );
+  assert.rejects(
+    fs.promises.open(__filename, 'r', mode),
+    {
+      code: 'ERR_INVALID_ARG_TYPE'
+    }
+  ).then(common.mustCall());
+});
diff --git a/test/js/node/test/parallel/test-fs-options-immutable.js b/test/js/node/test/parallel/test-fs-options-immutable.js
new file mode 100644
index 0000000000..fffdecdc87
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-options-immutable.js
@@ -0,0 +1,70 @@
+'use strict';
+const common = require('../common');
+
+// These tests make sure that the `options` object passed to these functions are
+// never altered.
+//
+// Refer: https://github.com/nodejs/node/issues/7655
+
+const fs = require('fs');
+
+const options = common.mustNotMutateObjectDeep({});
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+fs.readFile(__filename, options, common.mustSucceed());
+fs.readFileSync(__filename, options);
+
+fs.readdir(__dirname, options, common.mustSucceed());
+fs.readdirSync(__dirname, options);
+
+if (common.canCreateSymLink()) {
+  const sourceFile = tmpdir.resolve('test-readlink');
+  const linkFile = tmpdir.resolve('test-readlink-link');
+
+  fs.writeFileSync(sourceFile, '');
+  fs.symlinkSync(sourceFile, linkFile);
+
+  fs.readlink(linkFile, options, common.mustSucceed());
+  fs.readlinkSync(linkFile, options);
+}
+
+{
+  const fileName = tmpdir.resolve('writeFile');
+  fs.writeFileSync(fileName, 'ABCD', options);
+  fs.writeFile(fileName, 'ABCD', options, common.mustSucceed());
+}
+
+{
+  const fileName = tmpdir.resolve('appendFile');
+  fs.appendFileSync(fileName, 'ABCD', options);
+  fs.appendFile(fileName, 'ABCD', options, common.mustSucceed());
+}
+
+if (!common.isIBMi) { // IBMi does not support fs.watch()
+  const watch = fs.watch(__filename, options, common.mustNotCall());
+  watch.close();
+}
+
+{
+  fs.watchFile(__filename, options, common.mustNotCall());
+  fs.unwatchFile(__filename);
+}
+
+{
+  fs.realpathSync(__filename, options);
+  fs.realpath(__filename, options, common.mustSucceed());
+}
+
+{
+  const tempFileName = tmpdir.resolve('mkdtemp-');
+  fs.mkdtempSync(tempFileName, options);
+  fs.mkdtemp(tempFileName, options, common.mustSucceed());
+}
+
+{
+  const fileName = tmpdir.resolve('streams');
+  fs.WriteStream(fileName, options).once('open', common.mustCall(() => {
+    fs.ReadStream(fileName, options).destroy();
+  })).end();
+}
diff --git a/test/js/node/test/parallel/test-fs-promises-exists.js b/test/js/node/test/parallel/test-fs-promises-exists.js
new file mode 100644
index 0000000000..b9bbeee1de
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-promises-exists.js
@@ -0,0 +1,9 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const fs = require('fs');
+const fsPromises = require('fs/promises');
+
+assert.strictEqual(fsPromises, fs.promises);
+assert.strictEqual(fsPromises.constants, fs.constants);
diff --git a/test/js/node/test/parallel/test-fs-promises-file-handle-append-file.js b/test/js/node/test/parallel/test-fs-promises-file-handle-append-file.js
new file mode 100644
index 0000000000..90bb6e3925
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-promises-file-handle-append-file.js
@@ -0,0 +1,44 @@
+'use strict';
+
+const common = require('../common');
+
+// The following tests validate base functionality for the fs.promises
+// FileHandle.appendFile method.
+
+const fs = require('fs');
+const { open } = fs.promises;
+const path = require('path');
+const tmpdir = require('../common/tmpdir');
+const assert = require('assert');
+const tmpDir = tmpdir.path;
+
+tmpdir.refresh();
+
+async function validateAppendBuffer() {
+  const filePath = path.resolve(tmpDir, 'tmp-append-file-buffer.txt');
+  const fileHandle = await open(filePath, 'a');
+  const buffer = Buffer.from('a&Dp'.repeat(100), 'utf8');
+
+  await fileHandle.appendFile(buffer);
+  const appendedFileData = fs.readFileSync(filePath);
+  assert.deepStrictEqual(appendedFileData, buffer);
+
+  await fileHandle.close();
+}
+
+async function validateAppendString() {
+  const filePath = path.resolve(tmpDir, 'tmp-append-file-string.txt');
+  const fileHandle = await open(filePath, 'a');
+  const string = 'x~yz'.repeat(100);
+
+  await fileHandle.appendFile(string);
+  const stringAsBuffer = Buffer.from(string, 'utf8');
+  const appendedFileData = fs.readFileSync(filePath);
+  assert.deepStrictEqual(appendedFileData, stringAsBuffer);
+
+  await fileHandle.close();
+}
+
+validateAppendBuffer()
+  .then(validateAppendString)
+  .then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-fs-promises-file-handle-chmod.js b/test/js/node/test/parallel/test-fs-promises-file-handle-chmod.js
new file mode 100644
index 0000000000..5c7414a9b1
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-promises-file-handle-chmod.js
@@ -0,0 +1,45 @@
+'use strict';
+
+const common = require('../common');
+
+// The following tests validate base functionality for the fs.promises
+// FileHandle.chmod method.
+
+const fs = require('fs');
+const { open } = fs.promises;
+const path = require('path');
+const tmpdir = require('../common/tmpdir');
+const assert = require('assert');
+const tmpDir = tmpdir.path;
+
+tmpdir.refresh();
+
+async function validateFilePermission() {
+  const filePath = path.resolve(tmpDir, 'tmp-chmod.txt');
+  const fileHandle = await open(filePath, 'w+', 0o444);
+  // File created with r--r--r-- 444
+  const statsBeforeMod = fs.statSync(filePath);
+  assert.strictEqual(statsBeforeMod.mode & 0o444, 0o444);
+
+  let expectedAccess;
+  const newPermissions = 0o765;
+
+  if (common.isWindows) {
+    // Chmod in Windows will only toggle read only/write access. The
+    // fs.Stats.mode in Windows is computed using read/write
+    // bits (not exec). Read-only at best returns 444; r/w 666.
+    // Refer: /deps/uv/src/win/fs.cfs;
+    expectedAccess = 0o664;
+  } else {
+    expectedAccess = newPermissions;
+  }
+
+  // Change the permissions to rwxr--r-x
+  await fileHandle.chmod(newPermissions);
+  const statsAfterMod = fs.statSync(filePath);
+  assert.deepStrictEqual(statsAfterMod.mode & expectedAccess, expectedAccess);
+
+  await fileHandle.close();
+}
+
+validateFilePermission().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-fs-promises-file-handle-dispose.js b/test/js/node/test/parallel/test-fs-promises-file-handle-dispose.js
new file mode 100644
index 0000000000..406430eef4
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-promises-file-handle-dispose.js
@@ -0,0 +1,12 @@
+'use strict';
+
+const common = require('../common');
+const { promises: fs } = require('fs');
+
+async function doOpen() {
+  const fh = await fs.open(__filename);
+  fh.on('close', common.mustCall());
+  await fh[Symbol.asyncDispose]();
+}
+
+doOpen().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-fs-promises-file-handle-read-worker.js b/test/js/node/test/parallel/test-fs-promises-file-handle-read-worker.js
new file mode 100644
index 0000000000..7ae881801a
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-promises-file-handle-read-worker.js
@@ -0,0 +1,54 @@
+'use strict';
+const common = require('../common');
+const fs = require('fs');
+const assert = require('assert');
+const tmpdir = require('../common/tmpdir');
+const file = tmpdir.resolve('read_stream_filehandle_worker.txt');
+const input = 'hello world';
+const { Worker, isMainThread, workerData } = require('worker_threads');
+
+if (isMainThread || !workerData) {
+  tmpdir.refresh();
+  fs.writeFileSync(file, input);
+
+  fs.promises.open(file, 'r').then((handle) => {
+    handle.on('close', common.mustNotCall());
+    new Worker(__filename, {
+      workerData: { handle },
+      transferList: [handle]
+    });
+  });
+  fs.promises.open(file, 'r').then(async (handle) => {
+    try {
+      fs.createReadStream(null, { fd: handle });
+      assert.throws(() => {
+        new Worker(__filename, {
+          workerData: { handle },
+          transferList: [handle]
+        });
+      }, {
+        code: 25,
+        name: 'DataCloneError',
+      });
+    } finally {
+      await handle.close();
+    }
+  });
+} else {
+  let output = '';
+
+  const handle = workerData.handle;
+  handle.on('close', common.mustCall());
+  const stream = fs.createReadStream(null, { fd: handle });
+
+  stream.on('data', common.mustCallAtLeast((data) => {
+    output += data;
+  }));
+
+  stream.on('end', common.mustCall(() => {
+    handle.close();
+    assert.strictEqual(output, input);
+  }));
+
+  stream.on('close', common.mustCall());
+}
diff --git a/test/js/node/test/parallel/test-fs-promises-file-handle-stat.js b/test/js/node/test/parallel/test-fs-promises-file-handle-stat.js
new file mode 100644
index 0000000000..c989c405c5
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-promises-file-handle-stat.js
@@ -0,0 +1,23 @@
+'use strict';
+
+const common = require('../common');
+
+// The following tests validate base functionality for the fs.promises
+// FileHandle.stat method.
+
+const { open } = require('fs').promises;
+const tmpdir = require('../common/tmpdir');
+const assert = require('assert');
+
+tmpdir.refresh();
+
+async function validateStat() {
+  const filePath = tmpdir.resolve('tmp-read-file.txt');
+  const fileHandle = await open(filePath, 'w+');
+  const stats = await fileHandle.stat();
+  assert.ok(stats.mtime instanceof Date);
+  await fileHandle.close();
+}
+
+validateStat()
+  .then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-fs-promises-file-handle-truncate.js b/test/js/node/test/parallel/test-fs-promises-file-handle-truncate.js
new file mode 100644
index 0000000000..687f8c2725
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-promises-file-handle-truncate.js
@@ -0,0 +1,26 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { open, readFile } = require('fs').promises;
+const tmpdir = require('../common/tmpdir');
+
+tmpdir.refresh();
+
+async function validateTruncate() {
+  const text = 'Hello world';
+  const filename = tmpdir.resolve('truncate-file.txt');
+  const fileHandle = await open(filename, 'w+');
+
+  const buffer = Buffer.from(text, 'utf8');
+  await fileHandle.write(buffer, 0, buffer.length);
+
+  assert.strictEqual((await readFile(filename)).toString(), text);
+
+  await fileHandle.truncate(5);
+  assert.strictEqual((await readFile(filename)).toString(), 'Hello');
+
+  await fileHandle.close();
+}
+
+validateTruncate().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-fs-promises-file-handle-write.js b/test/js/node/test/parallel/test-fs-promises-file-handle-write.js
new file mode 100644
index 0000000000..7f3d12d481
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-promises-file-handle-write.js
@@ -0,0 +1,77 @@
+'use strict';
+
+const common = require('../common');
+
+// The following tests validate base functionality for the fs.promises
+// FileHandle.write method.
+
+const fs = require('fs');
+const { open } = fs.promises;
+const path = require('path');
+const tmpdir = require('../common/tmpdir');
+const assert = require('assert');
+const tmpDir = tmpdir.path;
+
+tmpdir.refresh();
+
+async function validateWrite() {
+  const filePathForHandle = path.resolve(tmpDir, 'tmp-write.txt');
+  const fileHandle = await open(filePathForHandle, 'w+');
+  const buffer = Buffer.from('Hello world'.repeat(100), 'utf8');
+
+  await fileHandle.write(buffer, 0, buffer.length);
+  const readFileData = fs.readFileSync(filePathForHandle);
+  assert.deepStrictEqual(buffer, readFileData);
+
+  await fileHandle.close();
+}
+
+async function validateEmptyWrite() {
+  const filePathForHandle = path.resolve(tmpDir, 'tmp-empty-write.txt');
+  const fileHandle = await open(filePathForHandle, 'w+');
+  const buffer = Buffer.from(''); // empty buffer
+
+  await fileHandle.write(buffer, 0, buffer.length);
+  const readFileData = fs.readFileSync(filePathForHandle);
+  assert.deepStrictEqual(buffer, readFileData);
+
+  await fileHandle.close();
+}
+
+async function validateNonUint8ArrayWrite() {
+  const filePathForHandle = path.resolve(tmpDir, 'tmp-data-write.txt');
+  const fileHandle = await open(filePathForHandle, 'w+');
+  const buffer = Buffer.from('Hello world', 'utf8').toString('base64');
+
+  await fileHandle.write(buffer, 0, buffer.length);
+  const readFileData = fs.readFileSync(filePathForHandle);
+  assert.deepStrictEqual(Buffer.from(buffer, 'utf8'), readFileData);
+
+  await fileHandle.close();
+}
+
+async function validateNonStringValuesWrite() {
+  const filePathForHandle = path.resolve(tmpDir, 'tmp-non-string-write.txt');
+  const fileHandle = await open(filePathForHandle, 'w+');
+  const nonStringValues = [
+    123, {}, new Map(), null, undefined, 0n, () => {}, Symbol(), true,
+    new String('notPrimitive'),
+    { toString() { return 'amObject'; } },
+    { [Symbol.toPrimitive]: (hint) => 'amObject' },
+  ];
+  for (const nonStringValue of nonStringValues) {
+    await assert.rejects(
+      fileHandle.write(nonStringValue),
+      { message: /"buffer"/, code: 'ERR_INVALID_ARG_TYPE' }
+    );
+  }
+
+  await fileHandle.close();
+}
+
+Promise.all([
+  validateWrite(),
+  validateEmptyWrite(),
+  validateNonUint8ArrayWrite(),
+  validateNonStringValuesWrite(),
+]).then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-fs-promises-readfile-empty.js b/test/js/node/test/parallel/test-fs-promises-readfile-empty.js
new file mode 100644
index 0000000000..ef15a26811
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-promises-readfile-empty.js
@@ -0,0 +1,17 @@
+'use strict';
+require('../common');
+
+const assert = require('assert');
+const { promises: fs } = require('fs');
+const fixtures = require('../common/fixtures');
+
+const fn = fixtures.path('empty.txt');
+
+fs.readFile(fn)
+  .then(assert.ok);
+
+fs.readFile(fn, 'utf8')
+  .then(assert.strictEqual.bind(this, ''));
+
+fs.readFile(fn, { encoding: 'utf8' })
+  .then(assert.strictEqual.bind(this, ''));
diff --git a/test/js/node/test/parallel/test-fs-promises-readfile-with-fd.js b/test/js/node/test/parallel/test-fs-promises-readfile-with-fd.js
new file mode 100644
index 0000000000..b5d1c26168
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-promises-readfile-with-fd.js
@@ -0,0 +1,34 @@
+'use strict';
+
+// This test makes sure that `readFile()` always reads from the current
+// position of the file, instead of reading from the beginning of the file.
+
+const common = require('../common');
+const assert = require('assert');
+const { writeFileSync } = require('fs');
+const { open } = require('fs').promises;
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+const fn = tmpdir.resolve('test.txt');
+writeFileSync(fn, 'Hello World');
+
+async function readFileTest() {
+  const handle = await open(fn, 'r');
+
+  /* Read only five bytes, so that the position moves to five. */
+  const buf = Buffer.alloc(5);
+  const { bytesRead } = await handle.read(buf, 0, 5, null);
+  assert.strictEqual(bytesRead, 5);
+  assert.strictEqual(buf.toString(), 'Hello');
+
+  /* readFile() should read from position five, instead of zero. */
+  assert.strictEqual((await handle.readFile()).toString(), ' World');
+
+  await handle.close();
+}
+
+
+readFileTest()
+  .then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-fs-promises-writefile-typedarray.js b/test/js/node/test/parallel/test-fs-promises-writefile-typedarray.js
new file mode 100644
index 0000000000..32d9cffa23
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-promises-writefile-typedarray.js
@@ -0,0 +1,24 @@
+'use strict';
+
+const common = require('../common');
+const fs = require('fs');
+const fsPromises = fs.promises;
+const path = require('path');
+const tmpdir = require('../common/tmpdir');
+const assert = require('assert');
+const tmpDir = tmpdir.path;
+
+tmpdir.refresh();
+
+const dest = path.resolve(tmpDir, 'tmp.txt');
+// Use a file size larger than `kReadFileMaxChunkSize`.
+const buffer = Buffer.from('012'.repeat(2 ** 14));
+
+(async () => {
+  for (const Constructor of [Uint8Array, Uint16Array, Uint32Array]) {
+    const array = new Constructor(buffer.buffer);
+    await fsPromises.writeFile(dest, array);
+    const data = await fsPromises.readFile(dest);
+    assert.deepStrictEqual(data, buffer);
+  }
+})().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-fs-promises-writefile-with-fd.js b/test/js/node/test/parallel/test-fs-promises-writefile-with-fd.js
new file mode 100644
index 0000000000..7cb9eeeca9
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-promises-writefile-with-fd.js
@@ -0,0 +1,35 @@
+'use strict';
+
+// This test makes sure that `writeFile()` always writes from the current
+// position of the file, instead of truncating the file.
+
+const common = require('../common');
+const assert = require('assert');
+const { readFileSync } = require('fs');
+const { open } = require('fs').promises;
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+const fn = tmpdir.resolve('test.txt');
+
+async function writeFileTest() {
+  const handle = await open(fn, 'w');
+
+  /* Write only five bytes, so that the position moves to five. */
+  const buf = Buffer.from('Hello');
+  const { bytesWritten } = await handle.write(buf, 0, 5, null);
+  assert.strictEqual(bytesWritten, 5);
+
+  /* Write some more with writeFile(). */
+  await handle.writeFile('World');
+
+  /* New content should be written at position five, instead of zero. */
+  assert.strictEqual(readFileSync(fn).toString(), 'HelloWorld');
+
+  await handle.close();
+}
+
+
+writeFileTest()
+  .then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-fs-promisified.js b/test/js/node/test/parallel/test-fs-promisified.js
new file mode 100644
index 0000000000..63430f64a8
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-promisified.js
@@ -0,0 +1,36 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const fs = require('fs');
+const { promisify } = require('util');
+
+const read = promisify(fs.read);
+const write = promisify(fs.write);
+const exists = promisify(fs.exists);
+
+{
+  const fd = fs.openSync(__filename, 'r');
+  read(fd, Buffer.alloc(1024), 0, 1024, null).then(common.mustCall((obj) => {
+    assert.strictEqual(typeof obj.bytesRead, 'number');
+    assert(obj.buffer instanceof Buffer);
+    fs.closeSync(fd);
+  }));
+}
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+{
+  const filename = tmpdir.resolve('write-promise.txt');
+  const fd = fs.openSync(filename, 'w');
+  write(fd, Buffer.from('foobar')).then(common.mustCall((obj) => {
+    assert.strictEqual(typeof obj.bytesWritten, 'number');
+    assert.strictEqual(obj.buffer.toString(), 'foobar');
+    fs.closeSync(fd);
+  }));
+}
+
+{
+  exists(__filename).then(common.mustCall((x) => {
+    assert.strictEqual(x, true);
+  }));
+}
diff --git a/test/js/node/test/parallel/test-fs-read-file-assert-encoding.js b/test/js/node/test/parallel/test-fs-read-file-assert-encoding.js
new file mode 100644
index 0000000000..77cd0e3ab1
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-read-file-assert-encoding.js
@@ -0,0 +1,12 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const fs = require('fs');
+
+const encoding = 'foo-8';
+const filename = 'bar.txt';
+assert.throws(
+  () => fs.readFile(filename, { encoding }, common.mustNotCall()),
+  { code: 'ERR_INVALID_ARG_VALUE', name: 'TypeError' }
+);
diff --git a/test/js/node/test/parallel/test-fs-read-file-sync-hostname.js b/test/js/node/test/parallel/test-fs-read-file-sync-hostname.js
new file mode 100644
index 0000000000..599f48b6cc
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-read-file-sync-hostname.js
@@ -0,0 +1,33 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+if (!common.isLinux)
+  common.skip('Test is linux specific.');
+
+const assert = require('assert');
+const fs = require('fs');
+
+// Test to make sure reading a file under the /proc directory works. See:
+// https://groups.google.com/forum/#!topic/nodejs-dev/rxZ_RoH1Gn0
+const hostname = fs.readFileSync('/proc/sys/kernel/hostname');
+assert.ok(hostname.length > 0);
diff --git a/test/js/node/test/parallel/test-fs-read-offset-null.js b/test/js/node/test/parallel/test-fs-read-offset-null.js
new file mode 100644
index 0000000000..012c94e41e
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-read-offset-null.js
@@ -0,0 +1,64 @@
+'use strict';
+
+
+// Test to assert the desired functioning of fs.read
+// when {offset:null} is passed as options parameter
+
+const common = require('../common');
+const assert = require('assert');
+const fs = require('fs');
+const fsPromises = fs.promises;
+const fixtures = require('../common/fixtures');
+const filepath = fixtures.path('x.txt');
+
+const buf = Buffer.alloc(1);
+// Reading only one character, hence buffer of one byte is enough.
+
+// Tests are done by making sure the first letter in buffer is
+// same as first letter in file.
+// 120 is the ascii code of letter x.
+
+// Tests for callback API.
+fs.open(filepath, 'r', common.mustSucceed((fd) => {
+  fs.read(fd, { offset: null, buffer: buf },
+          common.mustSucceed((bytesRead, buffer) => {
+            assert.strictEqual(buffer[0], 120);
+            fs.close(fd, common.mustSucceed(() => {}));
+          }));
+}));
+
+fs.open(filepath, 'r', common.mustSucceed((fd) => {
+  fs.read(fd, buf, { offset: null },
+          common.mustSucceed((bytesRead, buffer) => {
+            assert.strictEqual(buffer[0], 120);
+            fs.close(fd, common.mustSucceed(() => {}));
+          }));
+}));
+
+let filehandle = null;
+
+// Tests for promises api
+(async () => {
+  filehandle = await fsPromises.open(filepath, 'r');
+  const readObject = await filehandle.read(buf, { offset: null });
+  assert.strictEqual(readObject.buffer[0], 120);
+})()
+.finally(() => filehandle?.close())
+.then(common.mustCall());
+
+// Undocumented: omitted position works the same as position === null
+(async () => {
+  filehandle = await fsPromises.open(filepath, 'r');
+  const readObject = await filehandle.read(buf, null, buf.length);
+  assert.strictEqual(readObject.buffer[0], 120);
+})()
+.finally(() => filehandle?.close())
+.then(common.mustCall());
+
+(async () => {
+  filehandle = await fsPromises.open(filepath, 'r');
+  const readObject = await filehandle.read(buf, null, buf.length, 0);
+  assert.strictEqual(readObject.buffer[0], 120);
+})()
+.finally(() => filehandle?.close())
+.then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-fs-read-optional-params.js b/test/js/node/test/parallel/test-fs-read-optional-params.js
new file mode 100644
index 0000000000..e89f86ee5f
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-read-optional-params.js
@@ -0,0 +1,38 @@
+'use strict';
+
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+const fs = require('fs');
+const assert = require('assert');
+const filepath = fixtures.path('x.txt');
+
+const expected = Buffer.from('xyz\n');
+const defaultBufferAsync = Buffer.alloc(16384);
+const bufferAsOption = Buffer.allocUnsafe(expected.byteLength);
+
+function testValid(message, ...options) {
+  const paramsMsg = `${message} (as params)`;
+  const paramsFilehandle = fs.openSync(filepath, 'r');
+  fs.read(paramsFilehandle, ...options, common.mustSucceed((bytesRead, buffer) => {
+    assert.strictEqual(bytesRead, expected.byteLength, paramsMsg);
+    assert.deepStrictEqual(defaultBufferAsync.byteLength, buffer.byteLength, paramsMsg);
+    fs.closeSync(paramsFilehandle);
+  }));
+
+  const optionsMsg = `${message} (as options)`;
+  const optionsFilehandle = fs.openSync(filepath, 'r');
+  fs.read(optionsFilehandle, bufferAsOption, ...options, common.mustSucceed((bytesRead, buffer) => {
+    assert.strictEqual(bytesRead, expected.byteLength, optionsMsg);
+    assert.deepStrictEqual(bufferAsOption.byteLength, buffer.byteLength, optionsMsg);
+    fs.closeSync(optionsFilehandle);
+  }));
+}
+
+testValid('Not passing in any object');
+testValid('Passing in a null', null);
+testValid('Passing in an empty object', common.mustNotMutateObjectDeep({}));
+testValid('Passing in an object', common.mustNotMutateObjectDeep({
+  offset: 0,
+  length: bufferAsOption.byteLength,
+  position: 0,
+}));
diff --git a/test/js/node/test/parallel/test-fs-read-promises-optional-params.js b/test/js/node/test/parallel/test-fs-read-promises-optional-params.js
new file mode 100644
index 0000000000..f9007a69ba
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-read-promises-optional-params.js
@@ -0,0 +1,27 @@
+'use strict';
+
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+const fs = require('fs');
+const read = require('util').promisify(fs.read);
+const assert = require('assert');
+const filepath = fixtures.path('x.txt');
+const fd = fs.openSync(filepath, 'r');
+
+const expected = Buffer.from('xyz\n');
+const defaultBufferAsync = Buffer.alloc(16384);
+const bufferAsOption = Buffer.allocUnsafe(expected.byteLength);
+
+read(fd, common.mustNotMutateObjectDeep({}))
+  .then(function({ bytesRead, buffer }) {
+    assert.strictEqual(bytesRead, expected.byteLength);
+    assert.deepStrictEqual(defaultBufferAsync.byteLength, buffer.byteLength);
+  })
+  .then(common.mustCall());
+
+read(fd, bufferAsOption, common.mustNotMutateObjectDeep({ position: 0 }))
+  .then(function({ bytesRead, buffer }) {
+    assert.strictEqual(bytesRead, expected.byteLength);
+    assert.deepStrictEqual(bufferAsOption.byteLength, buffer.byteLength);
+  })
+  .then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-fs-read-stream-autoClose.js b/test/js/node/test/parallel/test-fs-read-stream-autoClose.js
new file mode 100644
index 0000000000..728d4f5eee
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-read-stream-autoClose.js
@@ -0,0 +1,15 @@
+'use strict';
+
+const common = require('../common');
+const fs = require('fs');
+const assert = require('assert');
+const tmpdir = require('../common/tmpdir');
+const writeFile = tmpdir.resolve('write-autoClose.txt');
+tmpdir.refresh();
+
+const file = fs.createWriteStream(writeFile, { autoClose: true });
+
+file.on('finish', common.mustCall(() => {
+  assert.strictEqual(file.destroyed, false);
+}));
+file.end('asd');
diff --git a/test/js/node/test/parallel/test-fs-read-stream-double-close.js b/test/js/node/test/parallel/test-fs-read-stream-double-close.js
new file mode 100644
index 0000000000..32117a0a1e
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-read-stream-double-close.js
@@ -0,0 +1,19 @@
+'use strict';
+
+const common = require('../common');
+const fs = require('fs');
+
+{
+  const s = fs.createReadStream(__filename);
+
+  s.close(common.mustCall());
+  s.close(common.mustCall());
+}
+
+{
+  const s = fs.createReadStream(__filename);
+
+  // This is a private API, but it is worth testing. close calls this
+  s.destroy(null, common.mustCall());
+  s.destroy(null, common.mustCall());
+}
diff --git a/test/js/node/test/parallel/test-fs-read-stream-encoding.js b/test/js/node/test/parallel/test-fs-read-stream-encoding.js
new file mode 100644
index 0000000000..8eeaee6572
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-read-stream-encoding.js
@@ -0,0 +1,17 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const fs = require('fs');
+const stream = require('stream');
+const fixtures = require('../common/fixtures');
+const encoding = 'base64';
+
+const example = fixtures.path('x.txt');
+const assertStream = new stream.Writable({
+  write: function(chunk, enc, next) {
+    const expected = Buffer.from('xyz');
+    assert(chunk.equals(expected));
+  }
+});
+assertStream.setDefaultEncoding(encoding);
+fs.createReadStream(example, encoding).pipe(assertStream);
diff --git a/test/js/node/test/parallel/test-fs-read-stream-fd-leak.js b/test/js/node/test/parallel/test-fs-read-stream-fd-leak.js
new file mode 100644
index 0000000000..81712def76
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-read-stream-fd-leak.js
@@ -0,0 +1,62 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const fs = require('fs');
+const fixtures = require('../common/fixtures');
+
+let openCount = 0;
+const _fsopen = fs.open;
+const _fsclose = fs.close;
+
+const loopCount = 50;
+const totalCheck = 50;
+const emptyTxt = fixtures.path('empty.txt');
+
+fs.open = function() {
+  openCount++;
+  return _fsopen.apply(null, arguments);
+};
+
+fs.close = function() {
+  openCount--;
+  return _fsclose.apply(null, arguments);
+};
+
+function testLeak(endFn, callback) {
+  console.log(`testing for leaks from fs.createReadStream().${endFn}()...`);
+
+  let i = 0;
+  let check = 0;
+
+  function checkFunction() {
+    if (openCount !== 0 && check < totalCheck) {
+      check++;
+      setTimeout(checkFunction, 100);
+      return;
+    }
+
+    assert.strictEqual(
+      openCount,
+      0,
+      `no leaked file descriptors using ${endFn}() (got ${openCount})`
+    );
+
+    openCount = 0;
+    callback && setTimeout(callback, 100);
+  }
+
+  setInterval(function() {
+    const s = fs.createReadStream(emptyTxt);
+    s[endFn]();
+
+    if (++i === loopCount) {
+      clearTimeout(this);
+      setTimeout(checkFunction, 100);
+    }
+  }, 2);
+}
+
+testLeak('close', function() {
+  testLeak('destroy');
+});
diff --git a/test/js/node/test/parallel/test-fs-read-stream-fd.js b/test/js/node/test/parallel/test-fs-read-stream-fd.js
new file mode 100644
index 0000000000..f40d35b967
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-read-stream-fd.js
@@ -0,0 +1,45 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const fs = require('fs');
+const assert = require('assert');
+const tmpdir = require('../common/tmpdir');
+const file = tmpdir.resolve('read_stream_fd_test.txt');
+const input = 'hello world';
+
+let output = '';
+tmpdir.refresh();
+fs.writeFileSync(file, input);
+
+const fd = fs.openSync(file, 'r');
+const stream = fs.createReadStream(null, { fd: fd, encoding: 'utf8' });
+
+assert.strictEqual(stream.path, undefined);
+
+stream.on('data', common.mustCallAtLeast((data) => {
+  output += data;
+}));
+
+process.on('exit', () => {
+  assert.strictEqual(output, input);
+});
diff --git a/test/js/node/test/parallel/test-fs-read-stream-resume.js b/test/js/node/test/parallel/test-fs-read-stream-resume.js
new file mode 100644
index 0000000000..36e3d809cd
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-read-stream-resume.js
@@ -0,0 +1,52 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+
+const fs = require('fs');
+
+const file = fixtures.path('x.txt');
+let data = '';
+let first = true;
+
+const stream = fs.createReadStream(file);
+stream.setEncoding('utf8');
+stream.on('data', common.mustCallAtLeast(function(chunk) {
+  data += chunk;
+  if (first) {
+    first = false;
+    stream.resume();
+  }
+}));
+
+process.nextTick(function() {
+  stream.pause();
+  setTimeout(function() {
+    stream.resume();
+  }, 100);
+});
+
+process.on('exit', function() {
+  assert.strictEqual(data, 'xyz\n');
+});
diff --git a/test/js/node/test/parallel/test-fs-read-zero-length.js b/test/js/node/test/parallel/test-fs-read-zero-length.js
new file mode 100644
index 0000000000..ac2efc73f5
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-read-zero-length.js
@@ -0,0 +1,18 @@
+'use strict';
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+const fs = require('fs');
+const filepath = fixtures.path('x.txt');
+const fd = fs.openSync(filepath, 'r');
+const bufferAsync = Buffer.alloc(0);
+const bufferSync = Buffer.alloc(0);
+
+fs.read(fd, bufferAsync, 0, 0, 0, common.mustCall((err, bytesRead) => {
+  assert.strictEqual(bytesRead, 0);
+  assert.deepStrictEqual(bufferAsync, Buffer.alloc(0));
+}));
+
+const r = fs.readSync(fd, bufferSync, 0, 0, 0);
+assert.deepStrictEqual(bufferSync, Buffer.alloc(0));
+assert.strictEqual(r, 0);
diff --git a/test/js/node/test/parallel/test-fs-readdir-buffer.js b/test/js/node/test/parallel/test-fs-readdir-buffer.js
new file mode 100644
index 0000000000..54b7353cb1
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-readdir-buffer.js
@@ -0,0 +1,17 @@
+'use strict';
+const common = require('../common');
+const fs = require('fs');
+
+if (!common.isMacOS) {
+  common.skip('this tests works only on MacOS');
+}
+
+const assert = require('assert');
+
+fs.readdir(
+  Buffer.from('/dev'),
+  { withFileTypes: true, encoding: 'buffer' },
+  common.mustCall((e, d) => {
+    assert.strictEqual(e, null);
+  })
+);
diff --git a/test/js/node/test/parallel/test-fs-readdir-recursive.js b/test/js/node/test/parallel/test-fs-readdir-recursive.js
new file mode 100644
index 0000000000..f32e600d2a
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-readdir-recursive.js
@@ -0,0 +1,14 @@
+'use strict';
+const common = require('../common');
+const fs = require('fs');
+const net = require('net');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+const server = net.createServer().listen(common.PIPE, common.mustCall(() => {
+  // The process should not crash
+  // See https://github.com/nodejs/node/issues/52159
+  fs.readdirSync(tmpdir.path, { recursive: true });
+  server.close();
+}));
diff --git a/test/js/node/test/parallel/test-fs-readdir-ucs2.js b/test/js/node/test/parallel/test-fs-readdir-ucs2.js
new file mode 100644
index 0000000000..264858ec6a
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-readdir-ucs2.js
@@ -0,0 +1,31 @@
+'use strict';
+
+const common = require('../common');
+if (!common.isLinux)
+  common.skip('Test is linux specific.');
+
+const path = require('path');
+const fs = require('fs');
+const assert = require('assert');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+const filename = '\uD83D\uDC04';
+const root = Buffer.from(`${tmpdir.path}${path.sep}`);
+const filebuff = Buffer.from(filename, 'ucs2');
+const fullpath = Buffer.concat([root, filebuff]);
+
+try {
+  fs.closeSync(fs.openSync(fullpath, 'w+'));
+} catch (e) {
+  if (e.code === 'EINVAL')
+    common.skip('test requires filesystem that supports UCS2');
+  throw e;
+}
+
+fs.readdir(tmpdir.path, 'ucs2', common.mustSucceed((list) => {
+  assert.strictEqual(list.length, 1);
+  const fn = list[0];
+  assert.deepStrictEqual(Buffer.from(fn, 'ucs2'), filebuff);
+  assert.strictEqual(fn, filename);
+}));
diff --git a/test/js/node/test/parallel/test-fs-readfile-empty.js b/test/js/node/test/parallel/test-fs-readfile-empty.js
new file mode 100644
index 0000000000..f6303777b2
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-readfile-empty.js
@@ -0,0 +1,45 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+
+// Trivial test of fs.readFile on an empty file.
+const common = require('../common');
+const fs = require('fs');
+const assert = require('assert');
+const fixtures = require('../common/fixtures');
+
+const fn = fixtures.path('empty.txt');
+
+fs.readFile(fn, common.mustCall((err, data) => {
+  assert.ok(data);
+}));
+
+fs.readFile(fn, 'utf8', common.mustCall((err, data) => {
+  assert.strictEqual(data, '');
+}));
+
+fs.readFile(fn, { encoding: 'utf8' }, common.mustCall((err, data) => {
+  assert.strictEqual(data, '');
+}));
+
+assert.ok(fs.readFileSync(fn));
+assert.strictEqual(fs.readFileSync(fn, 'utf8'), '');
diff --git a/test/js/node/test/parallel/test-fs-readfile-eof.js b/test/js/node/test/parallel/test-fs-readfile-eof.js
new file mode 100644
index 0000000000..94354b915b
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-readfile-eof.js
@@ -0,0 +1,46 @@
+'use strict';
+const common = require('../common');
+
+if (common.isWindows || common.isAIX || common.isIBMi)
+  common.skip(`No /dev/stdin on ${process.platform}.`);
+
+const assert = require('assert');
+const fs = require('fs/promises');
+const childType = ['child-encoding', 'child-non-encoding'];
+
+if (process.argv[2] === childType[0]) {
+  fs.readFile('/dev/stdin', 'utf8').then((data) => {
+    process.stdout.write(data);
+  });
+  return;
+} else if (process.argv[2] === childType[1]) {
+  fs.readFile('/dev/stdin').then((data) => {
+    process.stdout.write(data);
+  });
+  return;
+}
+
+const data1 = 'Hello';
+const data2 = 'World';
+const expected = `${data1}\n${data2}\n`;
+
+const exec = require('child_process').exec;
+const f = JSON.stringify(__filename);
+const node = JSON.stringify(process.execPath);
+
+function test(child) {
+  const cmd = `(echo ${data1}; sleep 0.5; echo ${data2}) | ${node} ${f} ${child}`;
+  exec(cmd, common.mustSucceed((stdout, stderr) => {
+    assert.strictEqual(
+      stdout,
+      expected,
+      `expected to read(${child === childType[0] ? 'with' : 'without'} encoding): '${expected}' but got: '${stdout}'`);
+    assert.strictEqual(
+      stderr,
+      '',
+      `expected not to read anything from stderr but got: '${stderr}'`);
+  }));
+}
+
+test(childType[0]);
+test(childType[1]);
diff --git a/test/js/node/test/parallel/test-fs-readfile-fd.js b/test/js/node/test/parallel/test-fs-readfile-fd.js
new file mode 100644
index 0000000000..1779d9f97d
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-readfile-fd.js
@@ -0,0 +1,94 @@
+'use strict';
+const common = require('../common');
+
+// Test fs.readFile using a file descriptor.
+
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+const fs = require('fs');
+const fn = fixtures.path('empty.txt');
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+tempFd(function(fd, close) {
+  fs.readFile(fd, function(err, data) {
+    assert.ok(data);
+    close();
+  });
+});
+
+tempFd(function(fd, close) {
+  fs.readFile(fd, 'utf8', function(err, data) {
+    assert.strictEqual(data, '');
+    close();
+  });
+});
+
+tempFdSync(function(fd) {
+  assert.ok(fs.readFileSync(fd));
+});
+
+tempFdSync(function(fd) {
+  assert.strictEqual(fs.readFileSync(fd, 'utf8'), '');
+});
+
+function tempFd(callback) {
+  fs.open(fn, 'r', function(err, fd) {
+    assert.ifError(err);
+    callback(fd, function() {
+      fs.close(fd, function(err) {
+        assert.ifError(err);
+      });
+    });
+  });
+}
+
+function tempFdSync(callback) {
+  const fd = fs.openSync(fn, 'r');
+  callback(fd);
+  fs.closeSync(fd);
+}
+
+{
+  // This test makes sure that `readFile()` always reads from the current
+  // position of the file, instead of reading from the beginning of the file,
+  // when used with file descriptors.
+
+  const filename = tmpdir.resolve('test.txt');
+  fs.writeFileSync(filename, 'Hello World');
+
+  {
+    // Tests the fs.readFileSync().
+    const fd = fs.openSync(filename, 'r');
+
+    // Read only five bytes, so that the position moves to five.
+    const buf = Buffer.alloc(5);
+    assert.strictEqual(fs.readSync(fd, buf, 0, 5), 5);
+    assert.strictEqual(buf.toString(), 'Hello');
+
+    // readFileSync() should read from position five, instead of zero.
+    assert.strictEqual(fs.readFileSync(fd).toString(), ' World');
+
+    fs.closeSync(fd);
+  }
+
+  {
+    // Tests the fs.readFile().
+    fs.open(filename, 'r', common.mustSucceed((fd) => {
+      const buf = Buffer.alloc(5);
+
+      // Read only five bytes, so that the position moves to five.
+      fs.read(fd, buf, 0, 5, null, common.mustSucceed((bytes) => {
+        assert.strictEqual(bytes, 5);
+        assert.strictEqual(buf.toString(), 'Hello');
+
+        fs.readFile(fd, common.mustSucceed((data) => {
+          // readFile() should read from position five, instead of zero.
+          assert.strictEqual(data.toString(), ' World');
+
+          fs.closeSync(fd);
+        }));
+      }));
+    }));
+  }
+}
diff --git a/test/js/node/test/parallel/test-fs-readfile-pipe-large.js b/test/js/node/test/parallel/test-fs-readfile-pipe-large.js
new file mode 100644
index 0000000000..4376774bb4
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-readfile-pipe-large.js
@@ -0,0 +1,43 @@
+'use strict';
+const common = require('../common');
+
+// Simulate `cat readfile.js | node readfile.js`
+
+if (common.isWindows || common.isAIX || common.isIBMi)
+  common.skip(`No /dev/stdin on ${process.platform}.`);
+
+const assert = require('assert');
+const fs = require('fs');
+
+if (process.argv[2] === 'child') {
+  fs.readFile('/dev/stdin', function(er, data) {
+    assert.ifError(er);
+    process.stdout.write(data);
+  });
+  return;
+}
+
+const tmpdir = require('../common/tmpdir');
+
+const filename = tmpdir.resolve('readfile_pipe_large_test.txt');
+const dataExpected = 'a'.repeat(999999);
+tmpdir.refresh();
+fs.writeFileSync(filename, dataExpected);
+
+const exec = require('child_process').exec;
+const f = JSON.stringify(__filename);
+const node = JSON.stringify(process.execPath);
+const cmd = `cat ${filename} | ${node} ${f} child`;
+exec(cmd, { maxBuffer: 1000000 }, common.mustSucceed((stdout, stderr) => {
+  assert.strictEqual(
+    stdout,
+    dataExpected,
+    `expect it reads the file and outputs 999999 'a' but got : ${stdout}`
+  );
+  assert.strictEqual(
+    stderr,
+    '',
+    `expect that it does not write to stderr, but got : ${stderr}`
+  );
+  console.log('ok');
+}));
diff --git a/test/js/node/test/parallel/test-fs-readfile-pipe.js b/test/js/node/test/parallel/test-fs-readfile-pipe.js
new file mode 100644
index 0000000000..79d5699fef
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-readfile-pipe.js
@@ -0,0 +1,59 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+
+// Simulate `cat readfile.js | node readfile.js`
+
+if (common.isWindows || common.isAIX || common.isIBMi)
+  common.skip(`No /dev/stdin on ${process.platform}.`);
+
+const assert = require('assert');
+const fs = require('fs');
+
+if (process.argv[2] === 'child') {
+  fs.readFile('/dev/stdin', common.mustSucceed((data) => {
+    process.stdout.write(data);
+  }));
+  return;
+}
+
+const fixtures = require('../common/fixtures');
+
+const filename = fixtures.path('readfile_pipe_test.txt');
+const dataExpected = fs.readFileSync(filename).toString();
+
+const exec = require('child_process').exec;
+const f = JSON.stringify(__filename);
+const node = JSON.stringify(process.execPath);
+const cmd = `cat ${filename} | ${node} ${f} child`;
+exec(cmd, common.mustSucceed((stdout, stderr) => {
+  assert.strictEqual(
+    stdout,
+    dataExpected,
+    `expected to read: '${dataExpected}' but got: '${stdout}'`);
+  assert.strictEqual(
+    stderr,
+    '',
+    `expected not to read anything from stderr but got: '${stderr}'`);
+  console.log('ok');
+}));
diff --git a/test/js/node/test/parallel/test-fs-readfile-unlink.js b/test/js/node/test/parallel/test-fs-readfile-unlink.js
new file mode 100644
index 0000000000..1688567fd6
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-readfile-unlink.js
@@ -0,0 +1,46 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+
+// Test that unlink succeeds immediately after readFile completes.
+
+const assert = require('assert');
+const fs = require('fs');
+
+const tmpdir = require('../common/tmpdir');
+
+const fileName = tmpdir.resolve('test.bin');
+const buf = Buffer.alloc(512 * 1024, 42);
+
+tmpdir.refresh();
+
+fs.writeFileSync(fileName, buf);
+
+fs.readFile(fileName, common.mustSucceed((data) => {
+  assert.strictEqual(data.length, buf.length);
+  assert.strictEqual(buf[0], 42);
+
+  // Unlink should not throw. This is part of the test. It used to throw on
+  // Windows due to a bug.
+  fs.unlinkSync(fileName);
+}));
diff --git a/test/js/node/test/parallel/test-fs-readfile-zero-byte-liar.js b/test/js/node/test/parallel/test-fs-readfile-zero-byte-liar.js
new file mode 100644
index 0000000000..a3ba3985ab
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-readfile-zero-byte-liar.js
@@ -0,0 +1,55 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+
+// Test that readFile works even when stat returns size 0.
+
+const assert = require('assert');
+const fs = require('fs');
+
+const dataExpected = fs.readFileSync(__filename, 'utf8');
+
+// Sometimes stat returns size=0, but it's a lie.
+fs._fstat = fs.fstat;
+fs._fstatSync = fs.fstatSync;
+
+fs.fstat = (fd, cb) => {
+  fs._fstat(fd, (er, st) => {
+    if (er) return cb(er);
+    st.size = 0;
+    return cb(er, st);
+  });
+};
+
+fs.fstatSync = (fd) => {
+  const st = fs._fstatSync(fd);
+  st.size = 0;
+  return st;
+};
+
+const d = fs.readFileSync(__filename, 'utf8');
+assert.strictEqual(d, dataExpected);
+
+fs.readFile(__filename, 'utf8', common.mustCall((er, d) => {
+  assert.strictEqual(d, dataExpected);
+}));
diff --git a/test/js/node/test/parallel/test-fs-readfilesync-enoent.js b/test/js/node/test/parallel/test-fs-readfilesync-enoent.js
new file mode 100644
index 0000000000..baf87ff990
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-readfilesync-enoent.js
@@ -0,0 +1,32 @@
+'use strict';
+const common = require('../common');
+
+// This test is only relevant on Windows.
+if (!common.isWindows)
+  common.skip('Windows specific test.');
+
+// This test ensures fs.realpathSync works on properly on Windows without
+// throwing ENOENT when the path involves a fileserver.
+// https://github.com/nodejs/node-v0.x-archive/issues/3542
+
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+function test(p) {
+  const result = fs.realpathSync(p);
+  assert.strictEqual(result.toLowerCase(), path.resolve(p).toLowerCase());
+
+  fs.realpath(p, common.mustSucceed((result) => {
+    assert.strictEqual(result.toLowerCase(), path.resolve(p).toLowerCase());
+  }));
+}
+
+test(`//${os.hostname()}/c$/Windows/System32`);
+test(`//${os.hostname()}/c$/Windows`);
+test(`//${os.hostname()}/c$/`);
+test(`\\\\${os.hostname()}\\c$\\`);
+test('C:\\');
+test('C:');
+test(process.env.windir);
diff --git a/test/js/node/test/parallel/test-fs-readfilesync-pipe-large.js b/test/js/node/test/parallel/test-fs-readfilesync-pipe-large.js
new file mode 100644
index 0000000000..5450337c4f
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-readfilesync-pipe-large.js
@@ -0,0 +1,36 @@
+'use strict';
+const common = require('../common');
+
+// Simulate `cat readfile.js | node readfile.js`
+
+if (common.isWindows || common.isAIX || common.isIBMi)
+  common.skip(`No /dev/stdin on ${process.platform}.`);
+
+const assert = require('assert');
+const fs = require('fs');
+
+if (process.argv[2] === 'child') {
+  process.stdout.write(fs.readFileSync('/dev/stdin', 'utf8'));
+  return;
+}
+
+const tmpdir = require('../common/tmpdir');
+
+const filename = tmpdir.resolve('readfilesync_pipe_large_test.txt');
+const dataExpected = 'a'.repeat(999999);
+tmpdir.refresh();
+fs.writeFileSync(filename, dataExpected);
+
+const exec = require('child_process').exec;
+const f = JSON.stringify(__filename);
+const node = JSON.stringify(process.execPath);
+const cmd = `cat ${filename} | ${node} ${f} child`;
+exec(
+  cmd,
+  { maxBuffer: 1000000 },
+  common.mustSucceed((stdout, stderr) => {
+    assert.strictEqual(stdout, dataExpected);
+    assert.strictEqual(stderr, '');
+    console.log('ok');
+  })
+);
diff --git a/test/js/node/test/parallel/test-fs-readlink-type-check.js b/test/js/node/test/parallel/test-fs-readlink-type-check.js
new file mode 100644
index 0000000000..58d431308c
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-readlink-type-check.js
@@ -0,0 +1,22 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const fs = require('fs');
+
+[false, 1, {}, [], null, undefined].forEach((i) => {
+  assert.throws(
+    () => fs.readlink(i, common.mustNotCall()),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError'
+    }
+  );
+  assert.throws(
+    () => fs.readlinkSync(i),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError'
+    }
+  );
+});
diff --git a/test/js/node/test/parallel/test-fs-readv-promises.js b/test/js/node/test/parallel/test-fs-readv-promises.js
new file mode 100644
index 0000000000..cdfc3d3b21
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-readv-promises.js
@@ -0,0 +1,63 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const fs = require('fs').promises;
+const tmpdir = require('../common/tmpdir');
+
+tmpdir.refresh();
+
+const expected = 'ümlaut. Лорем 運務ホソモ指及 आपको करने विकास 紙読決多密所 أضف';
+const exptectedBuff = Buffer.from(expected);
+
+let cnt = 0;
+function getFileName() {
+  return tmpdir.resolve(`readv_promises_${++cnt}.txt`);
+}
+
+const allocateEmptyBuffers = (combinedLength) => {
+  const bufferArr = [];
+  // Allocate two buffers, each half the size of exptectedBuff
+  bufferArr[0] = Buffer.alloc(Math.floor(combinedLength / 2));
+  bufferArr[1] = Buffer.alloc(combinedLength - bufferArr[0].length);
+
+  return bufferArr;
+};
+
+(async () => {
+  {
+    const filename = getFileName();
+    await fs.writeFile(filename, exptectedBuff);
+    const handle = await fs.open(filename, 'r');
+    const bufferArr = allocateEmptyBuffers(exptectedBuff.length);
+    const expectedLength = exptectedBuff.length;
+
+    let { bytesRead, buffers } = await handle.readv([Buffer.from('')],
+                                                    null);
+    assert.strictEqual(bytesRead, 0);
+    assert.deepStrictEqual(buffers, [Buffer.from('')]);
+
+    ({ bytesRead, buffers } = await handle.readv(bufferArr, null));
+    assert.strictEqual(bytesRead, expectedLength);
+    assert.deepStrictEqual(buffers, bufferArr);
+    assert(Buffer.concat(bufferArr).equals(await fs.readFile(filename)));
+    handle.close();
+  }
+
+  {
+    const filename = getFileName();
+    await fs.writeFile(filename, exptectedBuff);
+    const handle = await fs.open(filename, 'r');
+    const bufferArr = allocateEmptyBuffers(exptectedBuff.length);
+    const expectedLength = exptectedBuff.length;
+
+    let { bytesRead, buffers } = await handle.readv([Buffer.from('')]);
+    assert.strictEqual(bytesRead, 0);
+    assert.deepStrictEqual(buffers, [Buffer.from('')]);
+
+    ({ bytesRead, buffers } = await handle.readv(bufferArr));
+    assert.strictEqual(bytesRead, expectedLength);
+    assert.deepStrictEqual(buffers, bufferArr);
+    assert(Buffer.concat(bufferArr).equals(await fs.readFile(filename)));
+    handle.close();
+  }
+})().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-fs-readv-sync.js b/test/js/node/test/parallel/test-fs-readv-sync.js
new file mode 100644
index 0000000000..548f54cbb9
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-readv-sync.js
@@ -0,0 +1,92 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const fs = require('fs');
+const tmpdir = require('../common/tmpdir');
+
+tmpdir.refresh();
+
+const expected = 'ümlaut. Лорем 運務ホソモ指及 आपको करने विकास 紙読決多密所 أضف';
+
+const exptectedBuff = Buffer.from(expected);
+const expectedLength = exptectedBuff.length;
+
+const filename = tmpdir.resolve('readv_sync.txt');
+fs.writeFileSync(filename, exptectedBuff);
+
+const allocateEmptyBuffers = (combinedLength) => {
+  const bufferArr = [];
+  // Allocate two buffers, each half the size of exptectedBuff
+  bufferArr[0] = Buffer.alloc(Math.floor(combinedLength / 2));
+  bufferArr[1] = Buffer.alloc(combinedLength - bufferArr[0].length);
+
+  return bufferArr;
+};
+
+// fs.readvSync with array of buffers with all parameters
+{
+  const fd = fs.openSync(filename, 'r');
+
+  const bufferArr = allocateEmptyBuffers(exptectedBuff.length);
+
+  let read = fs.readvSync(fd, [Buffer.from('')], 0);
+  assert.strictEqual(read, 0);
+
+  read = fs.readvSync(fd, bufferArr, 0);
+  assert.strictEqual(read, expectedLength);
+
+  fs.closeSync(fd);
+
+  assert(Buffer.concat(bufferArr).equals(fs.readFileSync(filename)));
+}
+
+// fs.readvSync with array of buffers without position
+{
+  const fd = fs.openSync(filename, 'r');
+
+  const bufferArr = allocateEmptyBuffers(exptectedBuff.length);
+
+  let read = fs.readvSync(fd, [Buffer.from('')]);
+  assert.strictEqual(read, 0);
+
+  read = fs.readvSync(fd, bufferArr);
+  assert.strictEqual(read, expectedLength);
+
+  fs.closeSync(fd);
+
+  assert(Buffer.concat(bufferArr).equals(fs.readFileSync(filename)));
+}
+
+/**
+ * Testing with incorrect arguments
+ */
+const wrongInputs = [false, 'test', {}, [{}], ['sdf'], null, undefined];
+
+{
+  const fd = fs.openSync(filename, 'r');
+
+  for (const wrongInput of wrongInputs) {
+    assert.throws(
+      () => fs.readvSync(fd, wrongInput, null), {
+        code: 'ERR_INVALID_ARG_TYPE',
+        name: 'TypeError'
+      }
+    );
+  }
+
+  fs.closeSync(fd);
+}
+
+{
+  // fs.readv with wrong fd argument
+  for (const wrongInput of wrongInputs) {
+    assert.throws(
+      () => fs.readvSync(wrongInput),
+      {
+        code: 'ERR_INVALID_ARG_TYPE',
+        name: 'TypeError'
+      }
+    );
+  }
+}
diff --git a/test/js/node/test/parallel/test-fs-readv.js b/test/js/node/test/parallel/test-fs-readv.js
new file mode 100644
index 0000000000..111719a7ef
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-readv.js
@@ -0,0 +1,93 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const fs = require('fs');
+const tmpdir = require('../common/tmpdir');
+
+tmpdir.refresh();
+
+const expected = 'ümlaut. Лорем 運務ホソモ指及 आपको करने विकास 紙読決多密所 أضف';
+
+let cnt = 0;
+const getFileName = () => tmpdir.resolve(`readv_${++cnt}.txt`);
+const exptectedBuff = Buffer.from(expected);
+
+const allocateEmptyBuffers = (combinedLength) => {
+  const bufferArr = [];
+  // Allocate two buffers, each half the size of exptectedBuff
+  bufferArr[0] = Buffer.alloc(Math.floor(combinedLength / 2));
+  bufferArr[1] = Buffer.alloc(combinedLength - bufferArr[0].length);
+
+  return bufferArr;
+};
+
+const getCallback = (fd, bufferArr) => {
+  return common.mustSucceed((bytesRead, buffers) => {
+    assert.deepStrictEqual(bufferArr, buffers);
+    const expectedLength = exptectedBuff.length;
+    assert.deepStrictEqual(bytesRead, expectedLength);
+    fs.closeSync(fd);
+
+    assert(Buffer.concat(bufferArr).equals(exptectedBuff));
+  });
+};
+
+// fs.readv with array of buffers with all parameters
+{
+  const filename = getFileName();
+  const fd = fs.openSync(filename, 'w+');
+  fs.writeSync(fd, exptectedBuff);
+
+  const bufferArr = allocateEmptyBuffers(exptectedBuff.length);
+  const callback = getCallback(fd, bufferArr);
+
+  fs.readv(fd, bufferArr, 0, callback);
+}
+
+// fs.readv with array of buffers without position
+{
+  const filename = getFileName();
+  fs.writeFileSync(filename, exptectedBuff);
+  const fd = fs.openSync(filename, 'r');
+
+  const bufferArr = allocateEmptyBuffers(exptectedBuff.length);
+  const callback = getCallback(fd, bufferArr);
+
+  fs.readv(fd, bufferArr, callback);
+}
+
+/**
+ * Testing with incorrect arguments
+ */
+const wrongInputs = [false, 'test', {}, [{}], ['sdf'], null, undefined];
+
+{
+  const filename = getFileName(2);
+  fs.writeFileSync(filename, exptectedBuff);
+  const fd = fs.openSync(filename, 'r');
+
+  for (const wrongInput of wrongInputs) {
+    assert.throws(
+      () => fs.readv(fd, wrongInput, null, common.mustNotCall()), {
+        code: 'ERR_INVALID_ARG_TYPE',
+        name: 'TypeError'
+      }
+    );
+  }
+
+  fs.closeSync(fd);
+}
+
+{
+  // fs.readv with wrong fd argument
+  for (const wrongInput of wrongInputs) {
+    assert.throws(
+      () => fs.readv(wrongInput, common.mustNotCall()),
+      {
+        code: 'ERR_INVALID_ARG_TYPE',
+        name: 'TypeError'
+      }
+    );
+  }
+}
diff --git a/test/js/node/test/parallel/test-fs-realpath-on-substed-drive.js b/test/js/node/test/parallel/test-fs-realpath-on-substed-drive.js
new file mode 100644
index 0000000000..aea53f642f
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-realpath-on-substed-drive.js
@@ -0,0 +1,51 @@
+'use strict';
+
+const common = require('../common');
+if (!common.isWindows)
+  common.skip('Test for Windows only');
+
+const fixtures = require('../common/fixtures');
+
+const assert = require('assert');
+const fs = require('fs');
+const spawnSync = require('child_process').spawnSync;
+
+let result;
+
+// Create a subst drive
+const driveLetters = 'ABCDEFGHIJKLMNOPQRSTUWXYZ';
+let drive;
+let i;
+for (i = 0; i < driveLetters.length; ++i) {
+  drive = `${driveLetters[i]}:`;
+  result = spawnSync('subst', [drive, fixtures.fixturesDir]);
+  if (result.status === 0)
+    break;
+}
+if (i === driveLetters.length)
+  common.skip('Cannot create subst drive');
+
+// Schedule cleanup (and check if all callbacks where called)
+process.on('exit', function() {
+  spawnSync('subst', ['/d', drive]);
+});
+
+// test:
+const filename = `${drive}\\empty.js`;
+const filenameBuffer = Buffer.from(filename);
+
+result = fs.realpathSync(filename);
+assert.strictEqual(result, filename);
+
+result = fs.realpathSync(filename, 'buffer');
+assert(Buffer.isBuffer(result));
+assert(result.equals(filenameBuffer));
+
+fs.realpath(filename, common.mustSucceed((result) => {
+  assert.strictEqual(result, filename);
+}));
+
+fs.realpath(filename, 'buffer', common.mustSucceed((result) => {
+  assert(Buffer.isBuffer(result));
+  assert(result.equals(filenameBuffer));
+}));
diff --git a/test/js/node/test/parallel/test-fs-realpath-pipe.js b/test/js/node/test/parallel/test-fs-realpath-pipe.js
new file mode 100644
index 0000000000..f637642ca2
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-realpath-pipe.js
@@ -0,0 +1,39 @@
+'use strict';
+
+const common = require('../common');
+
+if (common.isWindows || common.isAIX || common.isIBMi)
+  common.skip(`No /dev/stdin on ${process.platform}.`);
+
+const assert = require('assert');
+
+const { spawnSync } = require('child_process');
+
+for (const code of [
+  `require('fs').realpath('/dev/stdin', (err, resolvedPath) => {
+    if (err) {
+      console.error(err);
+      process.exit(1);
+    }
+    if (resolvedPath) {
+      process.exit(2);
+    }
+  });`,
+  `try {
+    if (require('fs').realpathSync('/dev/stdin')) {
+      process.exit(2);
+    }
+  } catch (e) {
+    console.error(e);
+    process.exit(1);
+  }`,
+]) {
+  const child = spawnSync(process.execPath, ['-e', code], {
+    stdio: 'pipe'
+  });
+  if (child.status !== 2) {
+    console.log(code);
+    console.log(child.stderr.toString());
+  }
+  assert.strictEqual(child.status, 2);
+}
diff --git a/test/js/node/test/parallel/test-fs-rmdir-type-check.js b/test/js/node/test/parallel/test-fs-rmdir-type-check.js
new file mode 100644
index 0000000000..7014ce27f8
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-rmdir-type-check.js
@@ -0,0 +1,22 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const fs = require('fs');
+
+[false, 1, [], {}, null, undefined].forEach((i) => {
+  assert.throws(
+    () => fs.rmdir(i, common.mustNotCall()),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError'
+    }
+  );
+  assert.throws(
+    () => fs.rmdirSync(i),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError'
+    }
+  );
+});
diff --git a/test/js/node/test/parallel/test-fs-sir-writes-alot.js b/test/js/node/test/parallel/test-fs-sir-writes-alot.js
new file mode 100644
index 0000000000..7d213d6c6f
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-sir-writes-alot.js
@@ -0,0 +1,70 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const fs = require('fs');
+const assert = require('assert');
+
+const tmpdir = require('../common/tmpdir');
+
+const filename = tmpdir.resolve('out.txt');
+
+tmpdir.refresh();
+
+const fd = fs.openSync(filename, 'w');
+
+const line = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n';
+
+const N = 10240;
+let complete = 0;
+
+for (let i = 0; i < N; i++) {
+  // Create a new buffer for each write. Before the write is actually
+  // executed by the thread pool, the buffer will be collected.
+  const buffer = Buffer.from(line);
+  fs.write(fd, buffer, 0, buffer.length, null, function(er, written) {
+    complete++;
+    if (complete === N) {
+      fs.closeSync(fd);
+      const s = fs.createReadStream(filename);
+      s.on('data', testBuffer);
+    }
+  });
+}
+
+let bytesChecked = 0;
+
+function testBuffer(b) {
+  for (let i = 0; i < b.length; i++) {
+    bytesChecked++;
+    if (b[i] !== 'a'.charCodeAt(0) && b[i] !== '\n'.charCodeAt(0)) {
+      throw new Error(`invalid char ${i},${b[i]}`);
+    }
+  }
+}
+
+process.on('exit', function() {
+  // Probably some of the writes are going to overlap, so we can't assume
+  // that we get (N * line.length). Let's just make sure we've checked a
+  // few...
+  assert.ok(bytesChecked > 1000);
+});
diff --git a/test/js/node/test/parallel/test-fs-stat-bigint.js b/test/js/node/test/parallel/test-fs-stat-bigint.js
new file mode 100644
index 0000000000..0a2bea92e5
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-stat-bigint.js
@@ -0,0 +1,247 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const fs = require('fs');
+const promiseFs = require('fs').promises;
+const tmpdir = require('../common/tmpdir');
+const { isDate } = require('util').types;
+const { inspect } = require('util');
+
+tmpdir.refresh();
+
+let testIndex = 0;
+
+function getFilename() {
+  const filename = tmpdir.resolve(`test-file-${++testIndex}`);
+  fs.writeFileSync(filename, 'test');
+  return filename;
+}
+
+function verifyStats(bigintStats, numStats, allowableDelta) {
+  // allowableDelta: It's possible that the file stats are updated between the
+  // two stat() calls so allow for a small difference.
+  for (const key of Object.keys(numStats)) {
+    const val = numStats[key];
+    if (isDate(val)) {
+      const time = val.getTime();
+      const time2 = bigintStats[key].getTime();
+      assert(
+        time - time2 <= allowableDelta,
+        `difference of ${key}.getTime() should <= ${allowableDelta}.\n` +
+        `Number version ${time}, BigInt version ${time2}n`);
+    } else if (key === 'mode') {
+      assert.strictEqual(bigintStats[key], BigInt(val));
+      assert.strictEqual(
+        bigintStats.isBlockDevice(),
+        numStats.isBlockDevice()
+      );
+      assert.strictEqual(
+        bigintStats.isCharacterDevice(),
+        numStats.isCharacterDevice()
+      );
+      assert.strictEqual(
+        bigintStats.isDirectory(),
+        numStats.isDirectory()
+      );
+      assert.strictEqual(
+        bigintStats.isFIFO(),
+        numStats.isFIFO()
+      );
+      assert.strictEqual(
+        bigintStats.isFile(),
+        numStats.isFile()
+      );
+      assert.strictEqual(
+        bigintStats.isSocket(),
+        numStats.isSocket()
+      );
+      assert.strictEqual(
+        bigintStats.isSymbolicLink(),
+        numStats.isSymbolicLink()
+      );
+    } else if (key.endsWith('Ms')) {
+      const nsKey = key.replace('Ms', 'Ns');
+      const msFromBigInt = bigintStats[key];
+      const nsFromBigInt = bigintStats[nsKey];
+      const msFromBigIntNs = Number(nsFromBigInt / (10n ** 6n));
+      const msFromNum = numStats[key];
+
+      assert(
+        msFromNum - Number(msFromBigInt) <= allowableDelta,
+        `Number version ${key} = ${msFromNum}, ` +
+        `BigInt version ${key} = ${msFromBigInt}n, ` +
+        `Allowable delta = ${allowableDelta}`);
+
+      assert(
+        msFromNum - Number(msFromBigIntNs) <= allowableDelta,
+        `Number version ${key} = ${msFromNum}, ` +
+        `BigInt version ${nsKey} = ${nsFromBigInt}n` +
+        ` = ${msFromBigIntNs}ms, Allowable delta = ${allowableDelta}`);
+    } else if (Number.isSafeInteger(val)) {
+      assert.strictEqual(
+        bigintStats[key], BigInt(val),
+        `${inspect(bigintStats[key])} !== ${inspect(BigInt(val))}\n` +
+        `key=${key}, val=${val}`
+      );
+    } else {
+      assert(
+        Number(bigintStats[key]) - val < 1,
+        `${key} is not a safe integer, difference should < 1.\n` +
+        `Number version ${val}, BigInt version ${bigintStats[key]}n`);
+    }
+  }
+}
+
+const runSyncTest = (func, arg) => {
+  const startTime = process.hrtime.bigint();
+  const bigintStats = func(arg, common.mustNotMutateObjectDeep({ bigint: true }));
+  const numStats = func(arg);
+  const endTime = process.hrtime.bigint();
+  const allowableDelta = Math.ceil(Number(endTime - startTime) / 1e6);
+  verifyStats(bigintStats, numStats, allowableDelta);
+};
+
+{
+  const filename = getFilename();
+  runSyncTest(fs.statSync, filename);
+}
+
+if (!common.isWindows) {
+  const filename = getFilename();
+  const link = `${filename}-link`;
+  fs.symlinkSync(filename, link);
+  runSyncTest(fs.lstatSync, link);
+}
+
+{
+  const filename = getFilename();
+  const fd = fs.openSync(filename, 'r');
+  runSyncTest(fs.fstatSync, fd);
+  fs.closeSync(fd);
+}
+
+{
+  assert.throws(
+    () => fs.statSync('does_not_exist'),
+    { code: 'ENOENT' });
+  assert.strictEqual(
+    fs.statSync('does_not_exist', common.mustNotMutateObjectDeep({ throwIfNoEntry: false })),
+    undefined);
+}
+
+{
+  assert.throws(
+    () => fs.lstatSync('does_not_exist'),
+    { code: 'ENOENT' });
+  assert.strictEqual(
+    fs.lstatSync('does_not_exist', common.mustNotMutateObjectDeep({ throwIfNoEntry: false })),
+    undefined);
+}
+
+{
+  assert.throws(
+    () => fs.fstatSync(9999),
+    { code: 'EBADF' });
+  assert.throws(
+    () => fs.fstatSync(9999, common.mustNotMutateObjectDeep({ throwIfNoEntry: false })),
+    { code: 'EBADF' });
+}
+
+const runCallbackTest = (func, arg, done) => {
+  const startTime = process.hrtime.bigint();
+  func(arg, common.mustNotMutateObjectDeep({ bigint: true }), common.mustCall((err, bigintStats) => {
+    func(arg, common.mustCall((err, numStats) => {
+      const endTime = process.hrtime.bigint();
+      const allowableDelta = Math.ceil(Number(endTime - startTime) / 1e6);
+      verifyStats(bigintStats, numStats, allowableDelta);
+      if (done) {
+        done();
+      }
+    }));
+  }));
+};
+
+{
+  const filename = getFilename();
+  runCallbackTest(fs.stat, filename);
+}
+
+if (!common.isWindows) {
+  const filename = getFilename();
+  const link = `${filename}-link`;
+  fs.symlinkSync(filename, link);
+  runCallbackTest(fs.lstat, link);
+}
+
+{
+  const filename = getFilename();
+  const fd = fs.openSync(filename, 'r');
+  runCallbackTest(fs.fstat, fd, () => { fs.closeSync(fd); });
+}
+
+const runPromiseTest = async (func, arg) => {
+  const startTime = process.hrtime.bigint();
+  const bigintStats = await func(arg, common.mustNotMutateObjectDeep({ bigint: true }));
+  const numStats = await func(arg);
+  const endTime = process.hrtime.bigint();
+  const allowableDelta = Math.ceil(Number(endTime - startTime) / 1e6);
+  verifyStats(bigintStats, numStats, allowableDelta);
+};
+
+{
+  const filename = getFilename();
+  runPromiseTest(promiseFs.stat, filename);
+}
+
+if (!common.isWindows) {
+  const filename = getFilename();
+  const link = `${filename}-link`;
+  fs.symlinkSync(filename, link);
+  runPromiseTest(promiseFs.lstat, link);
+}
+
+(async function() {
+  const filename = getFilename();
+  const handle = await promiseFs.open(filename, 'r');
+  const startTime = process.hrtime.bigint();
+  const bigintStats = await handle.stat(common.mustNotMutateObjectDeep({ bigint: true }));
+  const numStats = await handle.stat();
+  const endTime = process.hrtime.bigint();
+  const allowableDelta = Math.ceil(Number(endTime - startTime) / 1e6);
+  verifyStats(bigintStats, numStats, allowableDelta);
+  await handle.close();
+})().then(common.mustCall());
+
+{
+  // These two tests have an equivalent in ./test-fs-stat.js
+
+  // BigIntStats Date properties can be set before reading them
+  fs.stat(__filename, { bigint: true }, common.mustSucceed((s) => {
+    s.atime = 2;
+    s.mtime = 3;
+    s.ctime = 4;
+    s.birthtime = 5;
+
+    assert.strictEqual(s.atime, 2);
+    assert.strictEqual(s.mtime, 3);
+    assert.strictEqual(s.ctime, 4);
+    assert.strictEqual(s.birthtime, 5);
+  }));
+
+  // BigIntStats Date properties can be set after reading them
+  fs.stat(__filename, { bigint: true }, common.mustSucceed((s) => {
+    // eslint-disable-next-line no-unused-expressions
+    s.atime, s.mtime, s.ctime, s.birthtime;
+
+    s.atime = 2;
+    s.mtime = 3;
+    s.ctime = 4;
+    s.birthtime = 5;
+
+    assert.strictEqual(s.atime, 2);
+    assert.strictEqual(s.mtime, 3);
+    assert.strictEqual(s.ctime, 4);
+    assert.strictEqual(s.birthtime, 5);
+  }));
+}
diff --git a/test/js/node/test/parallel/test-fs-stream-double-close.js b/test/js/node/test/parallel/test-fs-stream-double-close.js
new file mode 100644
index 0000000000..8c0037b243
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-stream-double-close.js
@@ -0,0 +1,54 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const fs = require('fs');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+test1(fs.createReadStream(__filename));
+test2(fs.createReadStream(__filename));
+test3(fs.createReadStream(__filename));
+
+test1(fs.createWriteStream(`${tmpdir.path}/dummy1`));
+test2(fs.createWriteStream(`${tmpdir.path}/dummy2`));
+test3(fs.createWriteStream(`${tmpdir.path}/dummy3`));
+
+function test1(stream) {
+  stream.destroy();
+  stream.destroy();
+}
+
+function test2(stream) {
+  stream.destroy();
+  stream.on('open', common.mustCall(function(fd) {
+    stream.destroy();
+  }));
+}
+
+function test3(stream) {
+  stream.on('open', common.mustCall(function(fd) {
+    stream.destroy();
+    stream.destroy();
+  }));
+}
diff --git a/test/js/node/test/parallel/test-fs-symlink-buffer-path.js b/test/js/node/test/parallel/test-fs-symlink-buffer-path.js
new file mode 100644
index 0000000000..ecad001d5e
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-symlink-buffer-path.js
@@ -0,0 +1,59 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+if (!common.canCreateSymLink())
+  common.skip('insufficient privileges');
+
+const fixtures = require('../common/fixtures');
+
+const assert = require('assert');
+const fs = require('fs');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+// Test creating and reading symbolic link
+const linkData = fixtures.path('/cycles/root.js');
+const linkPath = tmpdir.resolve('symlink1.js');
+
+let linkTime;
+let fileTime;
+
+// Refs: https://github.com/nodejs/node/issues/34514
+fs.symlinkSync(Buffer.from(linkData), linkPath);
+
+fs.lstat(linkPath, common.mustSucceed((stats) => {
+  linkTime = stats.mtime.getTime();
+}));
+
+fs.stat(linkPath, common.mustSucceed((stats) => {
+  fileTime = stats.mtime.getTime();
+}));
+
+fs.readlink(linkPath, common.mustSucceed((destination) => {
+  assert.strictEqual(destination, linkData);
+}));
+
+process.on('exit', () => {
+  assert.notStrictEqual(linkTime, fileTime);
+});
diff --git a/test/js/node/test/parallel/test-fs-symlink-dir-junction-relative.js b/test/js/node/test/parallel/test-fs-symlink-dir-junction-relative.js
new file mode 100644
index 0000000000..01ef8c8bdc
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-symlink-dir-junction-relative.js
@@ -0,0 +1,58 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+// Test creating and resolving relative junction or symbolic link
+
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+const fs = require('fs');
+
+const tmpdir = require('../common/tmpdir');
+
+const linkPath1 = tmpdir.resolve('junction1');
+const linkPath2 = tmpdir.resolve('junction2');
+const linkTarget = fixtures.fixturesDir;
+const linkData = fixtures.fixturesDir;
+
+tmpdir.refresh();
+
+// Test fs.symlink()
+fs.symlink(linkData, linkPath1, 'junction', common.mustSucceed(() => {
+  verifyLink(linkPath1);
+}));
+
+// Test fs.symlinkSync()
+fs.symlinkSync(linkData, linkPath2, 'junction');
+verifyLink(linkPath2);
+
+function verifyLink(linkPath) {
+  const stats = fs.lstatSync(linkPath);
+  assert.ok(stats.isSymbolicLink());
+
+  const data1 = fs.readFileSync(`${linkPath}/x.txt`, 'ascii');
+  const data2 = fs.readFileSync(`${linkTarget}/x.txt`, 'ascii');
+  assert.strictEqual(data1, data2);
+
+  // Clean up.
+  fs.unlinkSync(linkPath);
+}
diff --git a/test/js/node/test/parallel/test-fs-symlink-dir-junction.js b/test/js/node/test/parallel/test-fs-symlink-dir-junction.js
new file mode 100644
index 0000000000..3990467c6f
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-symlink-dir-junction.js
@@ -0,0 +1,63 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+const fs = require('fs');
+
+const tmpdir = require('../common/tmpdir');
+
+// Test creating and reading symbolic link
+const linkData = fixtures.path('cycles/');
+const linkPath = tmpdir.resolve('cycles_link');
+
+tmpdir.refresh();
+
+fs.symlink(linkData, linkPath, 'junction', common.mustSucceed(() => {
+  fs.lstat(linkPath, common.mustSucceed((stats) => {
+    assert.ok(stats.isSymbolicLink());
+
+    fs.readlink(linkPath, common.mustSucceed((destination) => {
+      assert.strictEqual(destination, linkData);
+
+      fs.unlink(linkPath, common.mustSucceed(() => {
+        assert(!fs.existsSync(linkPath));
+        assert(fs.existsSync(linkData));
+      }));
+    }));
+  }));
+}));
+
+// Test invalid symlink
+{
+  const linkData = fixtures.path('/not/exists/dir');
+  const linkPath = tmpdir.resolve('invalid_junction_link');
+
+  fs.symlink(linkData, linkPath, 'junction', common.mustSucceed(() => {
+    assert(!fs.existsSync(linkPath));
+
+    fs.unlink(linkPath, common.mustSucceed(() => {
+      assert(!fs.existsSync(linkPath));
+    }));
+  }));
+}
diff --git a/test/js/node/test/parallel/test-fs-symlink-dir.js b/test/js/node/test/parallel/test-fs-symlink-dir.js
new file mode 100644
index 0000000000..690e3302ed
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-symlink-dir.js
@@ -0,0 +1,81 @@
+'use strict';
+const common = require('../common');
+
+// Test creating a symbolic link pointing to a directory.
+// Ref: https://github.com/nodejs/node/pull/23724
+// Ref: https://github.com/nodejs/node/issues/23596
+
+
+if (!common.canCreateSymLink())
+  common.skip('insufficient privileges');
+
+const assert = require('assert');
+const path = require('path');
+const fs = require('fs');
+const fsPromises = fs.promises;
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+const linkTargets = [
+  'relative-target',
+  tmpdir.resolve('absolute-target'),
+];
+const linkPaths = [
+  path.relative(process.cwd(), tmpdir.resolve('relative-path')),
+  tmpdir.resolve('absolute-path'),
+];
+
+function testSync(target, path) {
+  fs.symlinkSync(target, path);
+  fs.readdirSync(path);
+}
+
+function testAsync(target, path) {
+  fs.symlink(target, path, common.mustSucceed(() => {
+    fs.readdirSync(path);
+  }));
+}
+
+async function testPromises(target, path) {
+  await fsPromises.symlink(target, path);
+  fs.readdirSync(path);
+}
+
+for (const linkTarget of linkTargets) {
+  fs.mkdirSync(tmpdir.resolve(linkTarget));
+  for (const linkPath of linkPaths) {
+    testSync(linkTarget, `${linkPath}-${path.basename(linkTarget)}-sync`);
+    testAsync(linkTarget, `${linkPath}-${path.basename(linkTarget)}-async`);
+    testPromises(linkTarget, `${linkPath}-${path.basename(linkTarget)}-promises`)
+      .then(common.mustCall());
+  }
+}
+
+// Test invalid symlink
+{
+  function testSync(target, path) {
+    fs.symlinkSync(target, path);
+    assert(!fs.existsSync(path));
+  }
+
+  function testAsync(target, path) {
+    fs.symlink(target, path, common.mustSucceed(() => {
+      assert(!fs.existsSync(path));
+    }));
+  }
+
+  async function testPromises(target, path) {
+    await fsPromises.symlink(target, path);
+    assert(!fs.existsSync(path));
+  }
+
+  for (const linkTarget of linkTargets.map((p) => p + '-broken')) {
+    for (const linkPath of linkPaths) {
+      testSync(linkTarget, `${linkPath}-${path.basename(linkTarget)}-sync`);
+      testAsync(linkTarget, `${linkPath}-${path.basename(linkTarget)}-async`);
+      testPromises(linkTarget, `${linkPath}-${path.basename(linkTarget)}-promises`)
+        .then(common.mustCall());
+    }
+  }
+}
diff --git a/test/js/node/test/parallel/test-fs-symlink-longpath.js b/test/js/node/test/parallel/test-fs-symlink-longpath.js
new file mode 100644
index 0000000000..f3586317c2
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-symlink-longpath.js
@@ -0,0 +1,27 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const path = require('path');
+const fs = require('fs');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+const tmpDir = tmpdir.path;
+const longPath = path.join(...[tmpDir].concat(Array(30).fill('1234567890')));
+fs.mkdirSync(longPath, { recursive: true });
+
+// Test if we can have symlinks to files and folders with long filenames
+const targetDirectory = path.join(longPath, 'target-directory');
+fs.mkdirSync(targetDirectory);
+const pathDirectory = path.join(tmpDir, 'new-directory');
+fs.symlink(targetDirectory, pathDirectory, 'dir', common.mustSucceed(() => {
+  assert(fs.existsSync(pathDirectory));
+}));
+
+const targetFile = path.join(longPath, 'target-file');
+fs.writeFileSync(targetFile, 'data');
+const pathFile = path.join(tmpDir, 'new-file');
+fs.symlink(targetFile, pathFile, common.mustSucceed(() => {
+  assert(fs.existsSync(pathFile));
+}));
diff --git a/test/js/node/test/parallel/test-fs-truncate-clear-file-zero.js b/test/js/node/test/parallel/test-fs-truncate-clear-file-zero.js
new file mode 100644
index 0000000000..234e65e580
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-truncate-clear-file-zero.js
@@ -0,0 +1,56 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const tmpdir = require('../common/tmpdir');
+
+// This test ensures that `fs.truncate` opens the file with `r+` and not `w`,
+// which had earlier resulted in the target file's content getting zeroed out.
+// https://github.com/nodejs/node-v0.x-archive/issues/6233
+
+const assert = require('assert');
+const fs = require('fs');
+
+const filename = `${tmpdir.path}/truncate-file.txt`;
+
+tmpdir.refresh();
+
+// Synchronous test.
+{
+  fs.writeFileSync(filename, '0123456789');
+  assert.strictEqual(fs.readFileSync(filename).toString(), '0123456789');
+  fs.truncateSync(filename, 5);
+  assert.strictEqual(fs.readFileSync(filename).toString(), '01234');
+}
+
+// Asynchronous test.
+{
+  fs.writeFileSync(filename, '0123456789');
+  assert.strictEqual(fs.readFileSync(filename).toString(), '0123456789');
+  fs.truncate(
+    filename,
+    5,
+    common.mustSucceed(() => {
+      assert.strictEqual(fs.readFileSync(filename).toString(), '01234');
+    })
+  );
+}
diff --git a/test/js/node/test/parallel/test-fs-truncate-sync.js b/test/js/node/test/parallel/test-fs-truncate-sync.js
new file mode 100644
index 0000000000..66250cf438
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-truncate-sync.js
@@ -0,0 +1,21 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const path = require('path');
+const fs = require('fs');
+const tmpdir = require('../common/tmpdir');
+const tmp = tmpdir.path;
+
+tmpdir.refresh();
+
+const filename = path.resolve(tmp, 'truncate-sync-file.txt');
+
+fs.writeFileSync(filename, 'hello world', 'utf8');
+
+const fd = fs.openSync(filename, 'r+');
+
+fs.truncateSync(fd, 5);
+assert(fs.readFileSync(fd).equals(Buffer.from('hello')));
+
+fs.closeSync(fd);
+fs.unlinkSync(filename);
diff --git a/test/js/node/test/parallel/test-fs-unlink-type-check.js b/test/js/node/test/parallel/test-fs-unlink-type-check.js
new file mode 100644
index 0000000000..006e9ad734
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-unlink-type-check.js
@@ -0,0 +1,22 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const fs = require('fs');
+
+[false, 1, {}, [], null, undefined].forEach((i) => {
+  assert.throws(
+    () => fs.unlink(i, common.mustNotCall()),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError'
+    }
+  );
+  assert.throws(
+    () => fs.unlinkSync(i),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError'
+    }
+  );
+});
diff --git a/test/js/node/test/parallel/test-fs-utimes-y2K38.js b/test/js/node/test/parallel/test-fs-utimes-y2K38.js
new file mode 100644
index 0000000000..9e42e90feb
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-utimes-y2K38.js
@@ -0,0 +1,66 @@
+'use strict';
+const common = require('../common');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+const assert = require('assert');
+const fs = require('fs');
+
+// Check for Y2K38 support. For Windows, assume it's there. Windows
+// doesn't have `touch` and `date -r` which are used in the check for support.
+if (!common.isWindows) {
+  const testFilePath = `${tmpdir.path}/y2k38-test`;
+  const testFileDate = '204001020304';
+  const { spawnSync } = require('child_process');
+  const touchResult = spawnSync('touch',
+                                ['-t', testFileDate, testFilePath],
+                                { encoding: 'utf8' });
+  if (touchResult.status !== 0) {
+    common.skip('File system appears to lack Y2K38 support (touch failed)');
+  }
+
+  // On some file systems that lack Y2K38 support, `touch` will succeed but
+  // the time will be incorrect.
+  const dateResult = spawnSync('date',
+                               ['-r', testFilePath, '+%Y%m%d%H%M'],
+                               { encoding: 'utf8' });
+  if (dateResult.status === 0) {
+    if (dateResult.stdout.trim() !== testFileDate) {
+      common.skip('File system appears to lack Y2k38 support (date failed)');
+    }
+  } else {
+    // On some platforms `date` may not support the `-r` option. Usually
+    // this will result in a non-zero status and usage information printed.
+    // In this case optimistically proceed -- the earlier `touch` succeeded
+    // but validation that the file has the correct time is not easily possible.
+    assert.match(dateResult.stderr, /[Uu]sage:/);
+  }
+}
+
+// Ref: https://github.com/nodejs/node/issues/13255
+const path = `${tmpdir.path}/test-utimes-precision`;
+fs.writeFileSync(path, '');
+
+const Y2K38_mtime = 2 ** 31;
+fs.utimesSync(path, Y2K38_mtime, Y2K38_mtime);
+const Y2K38_stats = fs.statSync(path);
+assert.strictEqual(Y2K38_stats.mtime.getTime() / 1000, Y2K38_mtime);
+
+if (common.isWindows) {
+  // This value would get converted to (double)1713037251359.9998
+  const truncate_mtime = 1713037251360;
+  fs.utimesSync(path, truncate_mtime / 1000, truncate_mtime / 1000);
+  const truncate_stats = fs.statSync(path);
+  assert.strictEqual(truncate_stats.mtime.getTime(), truncate_mtime);
+
+  // test Y2K38 for windows
+  // This value if treaded as a `signed long` gets converted to -2135622133469.
+  // POSIX systems stores timestamps in {long t_sec, long t_usec}.
+  // NTFS stores times in nanoseconds in a single `uint64_t`, so when libuv
+  // calculates (long)`uv_timespec_t.tv_sec` we get 2's complement.
+  const overflow_mtime = 2159345162531;
+  fs.utimesSync(path, overflow_mtime / 1000, overflow_mtime / 1000);
+  const overflow_stats = fs.statSync(path);
+  assert.strictEqual(overflow_stats.mtime.getTime(), overflow_mtime);
+}
diff --git a/test/js/node/test/parallel/test-fs-watch-abort-signal.js b/test/js/node/test/parallel/test-fs-watch-abort-signal.js
new file mode 100644
index 0000000000..33936d2d49
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-watch-abort-signal.js
@@ -0,0 +1,30 @@
+// Flags: --expose-internals
+'use strict';
+
+// Verify that AbortSignal integration works for fs.watch
+
+const common = require('../common');
+
+if (common.isIBMi)
+  common.skip('IBMi does not support `fs.watch()`');
+
+const fs = require('fs');
+const fixtures = require('../common/fixtures');
+
+
+{
+  // Signal aborted after creating the watcher
+  const file = fixtures.path('empty.js');
+  const ac = new AbortController();
+  const { signal } = ac;
+  const watcher = fs.watch(file, { signal });
+  watcher.once('close', common.mustCall());
+  setImmediate(() => ac.abort());
+}
+{
+  // Signal aborted before creating the watcher
+  const file = fixtures.path('empty.js');
+  const signal = AbortSignal.abort();
+  const watcher = fs.watch(file, { signal });
+  watcher.once('close', common.mustCall());
+}
diff --git a/test/js/node/test/parallel/test-fs-watch-close-when-destroyed.js b/test/js/node/test/parallel/test-fs-watch-close-when-destroyed.js
new file mode 100644
index 0000000000..afa5307e4d
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-watch-close-when-destroyed.js
@@ -0,0 +1,48 @@
+'use strict';
+
+// This tests that closing a watcher when the underlying handle is
+// already destroyed will result in a noop instead of a crash.
+
+const common = require('../common');
+
+// fs-watch on folders have limited capability in AIX.
+// The testcase makes use of folder watching, and causes
+// hang. This behavior is documented. Skip this for AIX.
+
+if (common.isAIX)
+  common.skip('folder watch capability is limited in AIX.');
+
+if (common.isIBMi)
+  common.skip('IBMi does not support `fs.watch()`');
+
+const tmpdir = require('../common/tmpdir');
+const fs = require('fs');
+
+tmpdir.refresh();
+const root = tmpdir.resolve('watched-directory');
+fs.mkdirSync(root);
+
+const watcher = fs.watch(root, { persistent: false, recursive: false });
+
+// The following listeners may or may not be invoked.
+
+watcher.addListener('error', () => {
+  setTimeout(
+    () => { watcher.close(); },  // Should not crash if it's invoked
+    common.platformTimeout(10)
+  );
+});
+
+watcher.addListener('change', () => {
+  setTimeout(
+    () => { watcher.close(); },
+    common.platformTimeout(10)
+  );
+});
+
+fs.rmdirSync(root);
+// Wait for the listener to hit
+setTimeout(
+  common.mustCall(),
+  common.platformTimeout(100)
+);
diff --git a/test/js/node/test/parallel/test-fs-watch-encoding.js b/test/js/node/test/parallel/test-fs-watch-encoding.js
new file mode 100644
index 0000000000..758c6c26be
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-watch-encoding.js
@@ -0,0 +1,95 @@
+'use strict';
+
+// This test is a bit more complicated than it ideally needs to be to work
+// around issues on OS X and SmartOS.
+//
+// On OS X, watch events are subject to peculiar timing oddities such that an
+// event might fire out of order. The synchronous refreshing of the tmp
+// directory might trigger an event on the watchers that are instantiated after
+// it!
+//
+// On SmartOS, the watch events fire but the filename is null.
+
+const common = require('../common');
+
+// fs-watch on folders have limited capability in AIX.
+// The testcase makes use of folder watching, and causes
+// hang. This behavior is documented. Skip this for AIX.
+
+if (common.isAIX)
+  common.skip('folder watch capability is limited in AIX.');
+
+if (common.isIBMi)
+  common.skip('IBMi does not support `fs.watch()`');
+
+const fs = require('fs');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+const fn = '新建文夹件.txt';
+const a = tmpdir.resolve(fn);
+
+const watchers = new Set();
+
+function registerWatcher(watcher) {
+  watchers.add(watcher);
+}
+
+function unregisterWatcher(watcher) {
+  watcher.close();
+  watchers.delete(watcher);
+  if (watchers.size === 0) {
+    clearInterval(interval);
+  }
+}
+
+{
+  // Test that using the `encoding` option has the expected result.
+  const watcher = fs.watch(
+    tmpdir.path,
+    { encoding: 'hex' },
+    (event, filename) => {
+      if (['e696b0e5bbbae69687e5a4b9e4bbb62e747874', null].includes(filename))
+        done(watcher);
+    }
+  );
+  registerWatcher(watcher);
+}
+
+{
+  // Test that in absence of `encoding` option has the expected result.
+  const watcher = fs.watch(
+    tmpdir.path,
+    (event, filename) => {
+      if ([fn, null].includes(filename))
+        done(watcher);
+    }
+  );
+  registerWatcher(watcher);
+}
+
+{
+  // Test that using the `encoding` option has the expected result.
+  const watcher = fs.watch(
+    tmpdir.path,
+    { encoding: 'buffer' },
+    (event, filename) => {
+      if (filename instanceof Buffer && filename.toString('utf8') === fn)
+        done(watcher);
+      else if (filename === null)
+        done(watcher);
+    }
+  );
+  registerWatcher(watcher);
+}
+
+const done = common.mustCall(unregisterWatcher, watchers.size);
+
+// OS X and perhaps other systems can have surprising race conditions with
+// file events. So repeat the operation in case it is missed the first time.
+const interval = setInterval(() => {
+  const fd = fs.openSync(a, 'w+');
+  fs.closeSync(fd);
+  fs.unlinkSync(a);
+}, common.platformTimeout(100));
diff --git a/test/js/node/test/parallel/test-fs-watch-recursive-add-file-to-existing-subfolder.js b/test/js/node/test/parallel/test-fs-watch-recursive-add-file-to-existing-subfolder.js
new file mode 100644
index 0000000000..628ca4b2fd
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-watch-recursive-add-file-to-existing-subfolder.js
@@ -0,0 +1,58 @@
+'use strict';
+
+const common = require('../common');
+
+if (common.isIBMi)
+  common.skip('IBMi does not support `fs.watch()`');
+
+// fs-watch on folders have limited capability in AIX.
+// The testcase makes use of folder watching, and causes
+// hang. This behavior is documented. Skip this for AIX.
+
+if (common.isAIX)
+  common.skip('folder watch capability is limited in AIX.');
+
+const assert = require('assert');
+const path = require('path');
+const fs = require('fs');
+
+const tmpdir = require('../common/tmpdir');
+const testDir = tmpdir.path;
+tmpdir.refresh();
+
+// Add a file to subfolder of a watching folder
+
+const rootDirectory = fs.mkdtempSync(testDir + path.sep);
+const testDirectory = path.join(rootDirectory, 'test-4');
+fs.mkdirSync(testDirectory);
+
+const file = 'folder-5';
+const filePath = path.join(testDirectory, file);
+fs.mkdirSync(filePath);
+
+const subfolderPath = path.join(filePath, 'subfolder-6');
+fs.mkdirSync(subfolderPath);
+
+const childrenFile = 'file-7.txt';
+const childrenAbsolutePath = path.join(subfolderPath, childrenFile);
+const relativePath = path.join(file, path.basename(subfolderPath), childrenFile);
+
+const watcher = fs.watch(testDirectory, { recursive: true });
+let watcherClosed = false;
+watcher.on('change', function(event, filename) {
+  assert.strictEqual(event, 'rename');
+
+  if (filename === relativePath) {
+    watcher.close();
+    watcherClosed = true;
+  }
+});
+
+// Do the write with a delay to ensure that the OS is ready to notify us.
+setTimeout(() => {
+  fs.writeFileSync(childrenAbsolutePath, 'world');
+}, common.platformTimeout(200));
+
+process.once('exit', function() {
+  assert(watcherClosed, 'watcher Object was not closed');
+});
diff --git a/test/js/node/test/parallel/test-fs-watch-recursive-add-file-to-new-folder.js b/test/js/node/test/parallel/test-fs-watch-recursive-add-file-to-new-folder.js
new file mode 100644
index 0000000000..2f91c968f7
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-watch-recursive-add-file-to-new-folder.js
@@ -0,0 +1,55 @@
+'use strict';
+
+const common = require('../common');
+
+if (common.isIBMi)
+  common.skip('IBMi does not support `fs.watch()`');
+
+// fs-watch on folders have limited capability in AIX.
+// The testcase makes use of folder watching, and causes
+// hang. This behavior is documented. Skip this for AIX.
+
+if (common.isAIX)
+  common.skip('folder watch capability is limited in AIX.');
+
+const assert = require('assert');
+const path = require('path');
+const fs = require('fs');
+
+const tmpdir = require('../common/tmpdir');
+const testDir = tmpdir.path;
+tmpdir.refresh();
+
+// Add a file to newly created folder to already watching folder
+
+const rootDirectory = fs.mkdtempSync(testDir + path.sep);
+const testDirectory = path.join(rootDirectory, 'test-3');
+fs.mkdirSync(testDirectory);
+
+const filePath = path.join(testDirectory, 'folder-3');
+
+const childrenFile = 'file-4.txt';
+const childrenAbsolutePath = path.join(filePath, childrenFile);
+const childrenRelativePath = path.join(path.basename(filePath), childrenFile);
+
+const watcher = fs.watch(testDirectory, { recursive: true });
+let watcherClosed = false;
+watcher.on('change', function(event, filename) {
+  assert.strictEqual(event, 'rename');
+  assert.ok(filename === path.basename(filePath) || filename === childrenRelativePath);
+
+  if (filename === childrenRelativePath) {
+    watcher.close();
+    watcherClosed = true;
+  }
+});
+
+// Do the write with a delay to ensure that the OS is ready to notify us.
+setTimeout(() => {
+  fs.mkdirSync(filePath);
+  fs.writeFileSync(childrenAbsolutePath, 'world');
+}, common.platformTimeout(200));
+
+process.once('exit', function() {
+  assert(watcherClosed, 'watcher Object was not closed');
+});
diff --git a/test/js/node/test/parallel/test-fs-watch-recursive-add-file-with-url.js b/test/js/node/test/parallel/test-fs-watch-recursive-add-file-with-url.js
new file mode 100644
index 0000000000..ee726961c4
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-watch-recursive-add-file-with-url.js
@@ -0,0 +1,52 @@
+'use strict';
+
+const common = require('../common');
+const { setTimeout } = require('timers/promises');
+
+if (common.isIBMi)
+  common.skip('IBMi does not support `fs.watch()`');
+
+// fs-watch on folders have limited capability in AIX.
+// The testcase makes use of folder watching, and causes
+// hang. This behavior is documented. Skip this for AIX.
+
+if (common.isAIX)
+  common.skip('folder watch capability is limited in AIX.');
+
+const assert = require('assert');
+const path = require('path');
+const fs = require('fs');
+const { pathToFileURL } = require('url');
+
+const tmpdir = require('../common/tmpdir');
+const testDir = tmpdir.path;
+tmpdir.refresh();
+
+(async () => {
+  // Add a file to already watching folder, and use URL as the path
+
+  const rootDirectory = fs.mkdtempSync(testDir + path.sep);
+  const testDirectory = path.join(rootDirectory, 'test-5');
+  fs.mkdirSync(testDirectory);
+
+  const filePath = path.join(testDirectory, 'file-8.txt');
+  const url = pathToFileURL(testDirectory);
+
+  const watcher = fs.watch(url, { recursive: true });
+  let watcherClosed = false;
+  watcher.on('change', function(event, filename) {
+    assert.strictEqual(event, 'rename');
+
+    if (filename === path.basename(filePath)) {
+      watcher.close();
+      watcherClosed = true;
+    }
+  });
+
+  await setTimeout(common.platformTimeout(100));
+  fs.writeFileSync(filePath, 'world');
+
+  process.on('exit', function() {
+    assert(watcherClosed, 'watcher Object was not closed');
+  });
+})().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-fs-watch-recursive-add-file.js b/test/js/node/test/parallel/test-fs-watch-recursive-add-file.js
new file mode 100644
index 0000000000..27b933871c
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-watch-recursive-add-file.js
@@ -0,0 +1,49 @@
+'use strict';
+
+const common = require('../common');
+
+if (common.isIBMi)
+  common.skip('IBMi does not support `fs.watch()`');
+
+// fs-watch on folders have limited capability in AIX.
+// The testcase makes use of folder watching, and causes
+// hang. This behavior is documented. Skip this for AIX.
+
+if (common.isAIX)
+  common.skip('folder watch capability is limited in AIX.');
+
+const assert = require('assert');
+const path = require('path');
+const fs = require('fs');
+
+const tmpdir = require('../common/tmpdir');
+const testDir = tmpdir.path;
+tmpdir.refresh();
+
+// Add a file to already watching folder
+
+const rootDirectory = fs.mkdtempSync(testDir + path.sep);
+const testDirectory = path.join(rootDirectory, 'test-1');
+fs.mkdirSync(testDirectory);
+
+const testFile = path.join(testDirectory, 'file-1.txt');
+
+const watcher = fs.watch(testDirectory, { recursive: true });
+let watcherClosed = false;
+watcher.on('change', function(event, filename) {
+  assert.strictEqual(event, 'rename');
+
+  if (filename === path.basename(testFile)) {
+    watcher.close();
+    watcherClosed = true;
+  }
+});
+
+// Do the write with a delay to ensure that the OS is ready to notify us.
+setTimeout(() => {
+  fs.writeFileSync(testFile, 'world');
+}, common.platformTimeout(200));
+
+process.once('exit', function() {
+  assert(watcherClosed, 'watcher Object was not closed');
+});
diff --git a/test/js/node/test/parallel/test-fs-watch-recursive-add-folder.js b/test/js/node/test/parallel/test-fs-watch-recursive-add-folder.js
new file mode 100644
index 0000000000..1851a7850f
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-watch-recursive-add-folder.js
@@ -0,0 +1,50 @@
+'use strict';
+
+const common = require('../common');
+const { setTimeout } = require('timers/promises');
+
+if (common.isIBMi)
+  common.skip('IBMi does not support `fs.watch()`');
+
+// fs-watch on folders have limited capability in AIX.
+// The testcase makes use of folder watching, and causes
+// hang. This behavior is documented. Skip this for AIX.
+
+if (common.isAIX)
+  common.skip('folder watch capability is limited in AIX.');
+
+const assert = require('assert');
+const path = require('path');
+const fs = require('fs');
+
+const tmpdir = require('../common/tmpdir');
+const testDir = tmpdir.path;
+tmpdir.refresh();
+
+(async () => {
+  // Add a folder to already watching folder
+
+  const rootDirectory = fs.mkdtempSync(testDir + path.sep);
+  const testDirectory = path.join(rootDirectory, 'test-2');
+  fs.mkdirSync(testDirectory);
+
+  const testFile = path.join(testDirectory, 'folder-2');
+
+  const watcher = fs.watch(testDirectory, { recursive: true });
+  let watcherClosed = false;
+  watcher.on('change', function(event, filename) {
+    assert.strictEqual(event, 'rename');
+
+    if (filename === path.basename(testFile)) {
+      watcher.close();
+      watcherClosed = true;
+    }
+  });
+
+  await setTimeout(common.platformTimeout(100));
+  fs.mkdirSync(testFile);
+
+  process.once('exit', function() {
+    assert(watcherClosed, 'watcher Object was not closed');
+  });
+})().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-fs-watch-recursive-assert-leaks.js b/test/js/node/test/parallel/test-fs-watch-recursive-assert-leaks.js
new file mode 100644
index 0000000000..f5950e38ce
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-watch-recursive-assert-leaks.js
@@ -0,0 +1,50 @@
+'use strict';
+
+const common = require('../common');
+const { setTimeout } = require('timers/promises');
+
+if (common.isIBMi)
+  common.skip('IBMi does not support `fs.watch()`');
+
+// fs-watch on folders have limited capability in AIX.
+// The testcase makes use of folder watching, and causes
+// hang. This behavior is documented. Skip this for AIX.
+
+if (common.isAIX)
+  common.skip('folder watch capability is limited in AIX.');
+
+const assert = require('assert');
+const path = require('path');
+const fs = require('fs');
+
+const tmpdir = require('../common/tmpdir');
+const testDir = tmpdir.path;
+tmpdir.refresh();
+
+// Assert recursive watch does not leak handles
+const rootDirectory = fs.mkdtempSync(testDir + path.sep);
+const testDirectory = path.join(rootDirectory, 'test-7');
+const filePath = path.join(testDirectory, 'only-file.txt');
+fs.mkdirSync(testDirectory);
+
+let watcherClosed = false;
+const watcher = fs.watch(testDirectory, { recursive: true });
+watcher.on('change', common.mustCallAtLeast(async (event, filename) => {
+  await setTimeout(common.platformTimeout(100));
+  if (filename === path.basename(filePath)) {
+    watcher.close();
+    watcherClosed = true;
+  }
+  await setTimeout(common.platformTimeout(100));
+  assert(!process._getActiveHandles().some((handle) => handle.constructor.name === 'StatWatcher'));
+}));
+
+process.on('exit', function() {
+  assert(watcherClosed, 'watcher Object was not closed');
+});
+
+// Do the write with a delay to ensure that the OS is ready to notify us.
+(async () => {
+  await setTimeout(200);
+  fs.writeFileSync(filePath, 'content');
+})().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-fs-watch-recursive-delete.js b/test/js/node/test/parallel/test-fs-watch-recursive-delete.js
new file mode 100644
index 0000000000..8e78ad54d6
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-watch-recursive-delete.js
@@ -0,0 +1,33 @@
+'use strict';
+
+const common = require('../common');
+const tmpdir = require('../common/tmpdir');
+const fs = require('fs');
+
+if (common.isSunOS)
+  common.skip('SunOS behaves differently');
+
+if (common.isIBMi)
+  common.skip('IBMi does not support `fs.watch()`');
+
+tmpdir.refresh();
+
+fs.mkdirSync(tmpdir.resolve('./parent/child'), { recursive: true });
+
+fs.writeFileSync(tmpdir.resolve('./parent/child/test.tmp'), 'test');
+
+const toWatch = tmpdir.resolve('./parent');
+
+const onFileUpdate = common.mustCallAtLeast((eventType, filename) => {
+  // We are only checking for the filename to avoid having Windows, Linux and Mac specific assertions
+  if (fs.readdirSync(tmpdir.resolve('./parent')).length === 0) {
+    watcher.close();
+  }
+}, 1);
+
+const watcher = fs.watch(toWatch, { recursive: true }, onFileUpdate);
+
+// We must wait a bit `fs.rm()` to let the watcher be set up properly
+setTimeout(() => {
+  fs.rm(tmpdir.resolve('./parent/child'), { recursive: true }, common.mustCall());
+}, common.platformTimeout(500));
diff --git a/test/js/node/test/parallel/test-fs-watch-recursive-linux-parallel-remove.js b/test/js/node/test/parallel/test-fs-watch-recursive-linux-parallel-remove.js
new file mode 100644
index 0000000000..145b3314f2
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-watch-recursive-linux-parallel-remove.js
@@ -0,0 +1,33 @@
+'use strict';
+
+const common = require('../common');
+
+if (!common.isLinux)
+  common.skip('This test can run only on Linux');
+
+// Test that the watcher do not crash if the file "disappears" while
+// watch is being set up.
+
+const path = require('node:path');
+const fs = require('node:fs');
+const { spawn } = require('node:child_process');
+
+const tmpdir = require('../common/tmpdir');
+const testDir = tmpdir.path;
+tmpdir.refresh();
+
+const watcher = fs.watch(testDir, { recursive: true });
+watcher.on('change', function(event, filename) {
+  // This console.log makes the error happen
+  // do not remove
+  console.log(filename, event);
+});
+
+const testFile = path.join(testDir, 'a');
+const child = spawn(process.argv[0], ['-e', `const fs = require('node:fs'); for (let i = 0; i < 10000; i++) { const fd = fs.openSync('${testFile}', 'w'); fs.writeSync(fd, Buffer.from('hello')); fs.rmSync('${testFile}') }`], {
+  stdio: 'inherit'
+});
+
+child.on('exit', function() {
+  watcher.close();
+});
diff --git a/test/js/node/test/parallel/test-fs-watch-recursive-symlink.js b/test/js/node/test/parallel/test-fs-watch-recursive-symlink.js
new file mode 100644
index 0000000000..602ec58eab
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-watch-recursive-symlink.js
@@ -0,0 +1,100 @@
+'use strict';
+
+const common = require('../common');
+const { setTimeout } = require('timers/promises');
+
+if (common.isIBMi)
+  common.skip('IBMi does not support `fs.watch()`');
+
+// fs-watch on folders have limited capability in AIX.
+// The testcase makes use of folder watching, and causes
+// hang. This behavior is documented. Skip this for AIX.
+
+if (common.isAIX)
+  common.skip('folder watch capability is limited in AIX.');
+
+const assert = require('assert');
+const path = require('path');
+const fs = require('fs');
+
+const tmpdir = require('../common/tmpdir');
+const testDir = tmpdir.path;
+tmpdir.refresh();
+
+(async () => {
+  // Add a recursive symlink to the parent folder
+
+  const testDirectory = fs.mkdtempSync(testDir + path.sep);
+
+  // Do not use `testDirectory` as base. It will hang the tests.
+  const rootDirectory = path.join(testDirectory, 'test-1');
+  fs.mkdirSync(rootDirectory);
+
+  const filePath = path.join(rootDirectory, 'file.txt');
+
+  const symlinkFolder = path.join(rootDirectory, 'symlink-folder');
+  fs.symlinkSync(rootDirectory, symlinkFolder);
+
+
+  const watcher = fs.watch(rootDirectory, { recursive: true });
+  let watcherClosed = false;
+  watcher.on('change', function(event, filename) {
+    assert.ok(event === 'rename', `Received ${event}`);
+    assert.ok(filename === path.basename(symlinkFolder) || filename === path.basename(filePath), `Received ${filename}`);
+
+    if (filename === path.basename(filePath)) {
+      watcher.close();
+      watcherClosed = true;
+    }
+  });
+
+  await setTimeout(common.platformTimeout(100));
+  fs.writeFileSync(filePath, 'world');
+
+  process.once('exit', function() {
+    assert(watcherClosed, 'watcher Object was not closed');
+  });
+})().then(common.mustCall());
+
+(async () => {
+  // This test checks how a symlink to outside the tracking folder can trigger change
+  // tmp/sub-directory/tracking-folder/symlink-folder -> tmp/sub-directory
+
+  const rootDirectory = fs.mkdtempSync(testDir + path.sep);
+
+  const subDirectory = path.join(rootDirectory, 'sub-directory');
+  fs.mkdirSync(subDirectory);
+
+  const trackingSubDirectory = path.join(subDirectory, 'tracking-folder');
+  fs.mkdirSync(trackingSubDirectory);
+
+  const symlinkFolder = path.join(trackingSubDirectory, 'symlink-folder');
+  fs.symlinkSync(subDirectory, symlinkFolder);
+
+  const forbiddenFile = path.join(subDirectory, 'forbidden.txt');
+  const acceptableFile = path.join(trackingSubDirectory, 'acceptable.txt');
+
+  const watcher = fs.watch(trackingSubDirectory, { recursive: true });
+  let watcherClosed = false;
+  watcher.on('change', function(event, filename) {
+    // macOS will only change the following events:
+    // { event: 'rename', filename: 'symlink-folder' }
+    // { event: 'rename', filename: 'acceptable.txt' }
+    assert.ok(event === 'rename', `Received ${event}`);
+    assert.ok(filename === path.basename(symlinkFolder) || filename === path.basename(acceptableFile), `Received ${filename}`);
+
+    if (filename === path.basename(acceptableFile)) {
+      watcher.close();
+      watcherClosed = true;
+    }
+  });
+
+  await setTimeout(common.platformTimeout(100));
+  fs.writeFileSync(forbiddenFile, 'world');
+  await setTimeout(common.platformTimeout(100));
+  fs.writeFileSync(acceptableFile, 'acceptable');
+
+  process.once('exit', function() {
+    assert(watcherClosed, 'watcher Object was not closed');
+  });
+})().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-fs-watch-recursive-sync-write.js b/test/js/node/test/parallel/test-fs-watch-recursive-sync-write.js
new file mode 100644
index 0000000000..ecc380d190
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-watch-recursive-sync-write.js
@@ -0,0 +1,38 @@
+'use strict';
+
+const common = require('../common');
+const { watch, writeFileSync } = require('node:fs');
+const { join } = require('node:path');
+const tmpdir = require('../common/tmpdir.js');
+const assert = require('assert');
+
+if (common.isIBMi)
+  common.skip('IBMi does not support `fs.watch()`');
+
+// fs-watch on folders have limited capability in AIX.
+// The testcase makes use of folder watching, and causes
+// hang. This behavior is documented. Skip this for AIX.
+
+if (common.isAIX)
+  common.skip('folder watch capability is limited in AIX.');
+
+tmpdir.refresh();
+
+const tmpDir = tmpdir.path;
+const filename = join(tmpDir, 'test.file');
+
+const keepalive = setTimeout(() => {
+  throw new Error('timed out');
+}, common.platformTimeout(30_000));
+
+const watcher = watch(tmpDir, { recursive: true }, common.mustCall((eventType, _filename) => {
+  clearTimeout(keepalive);
+  watcher.close();
+  assert.strictEqual(eventType, 'rename');
+  assert.strictEqual(join(tmpDir, _filename), filename);
+}));
+
+// Do the write with a delay to ensure that the OS is ready to notify us.
+setTimeout(() => {
+  writeFileSync(filename, 'foobar2');
+}, common.platformTimeout(200));
diff --git a/test/js/node/test/parallel/test-fs-watch-recursive-update-file.js b/test/js/node/test/parallel/test-fs-watch-recursive-update-file.js
new file mode 100644
index 0000000000..7100b015ab
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-watch-recursive-update-file.js
@@ -0,0 +1,45 @@
+'use strict';
+
+const common = require('../common');
+
+if (common.isIBMi)
+  common.skip('IBMi does not support `fs.watch()`');
+
+// fs-watch on folders have limited capability in AIX.
+// The testcase makes use of folder watching, and causes
+// hang. This behavior is documented. Skip this for AIX.
+
+if (common.isAIX)
+  common.skip('folder watch capability is limited in AIX.');
+
+const assert = require('assert');
+const path = require('path');
+const fs = require('fs');
+
+const tmpdir = require('../common/tmpdir');
+const testDir = tmpdir.path;
+tmpdir.refresh();
+
+// Watch a folder and update an already existing file in it.
+
+const rootDirectory = fs.mkdtempSync(testDir + path.sep);
+const testDirectory = path.join(rootDirectory, 'test-0');
+fs.mkdirSync(testDirectory);
+
+const testFile = path.join(testDirectory, 'file-1.txt');
+fs.writeFileSync(testFile, 'hello');
+
+const watcher = fs.watch(testDirectory, { recursive: true });
+watcher.on('change', common.mustCallAtLeast(function(event, filename) {
+  // Libuv inconsistenly emits a rename event for the file we are watching
+  assert.ok(event === 'change' || event === 'rename');
+
+  if (filename === path.basename(testFile)) {
+    watcher.close();
+  }
+}));
+
+// Do the write with a delay to ensure that the OS is ready to notify us.
+setTimeout(() => {
+  fs.writeFileSync(testFile, 'hello');
+}, common.platformTimeout(200));
diff --git a/test/js/node/test/parallel/test-fs-watch-recursive-validate.js b/test/js/node/test/parallel/test-fs-watch-recursive-validate.js
new file mode 100644
index 0000000000..09eccc2d7e
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-watch-recursive-validate.js
@@ -0,0 +1,34 @@
+'use strict';
+
+const common = require('../common');
+
+if (common.isIBMi)
+  common.skip('IBMi does not support `fs.watch()`');
+
+// fs-watch on folders have limited capability in AIX.
+// The testcase makes use of folder watching, and causes
+// hang. This behavior is documented. Skip this for AIX.
+
+if (common.isAIX)
+  common.skip('folder watch capability is limited in AIX.');
+
+const assert = require('assert');
+const path = require('path');
+const fs = require('fs');
+
+const tmpdir = require('../common/tmpdir');
+const testDir = tmpdir.path;
+tmpdir.refresh();
+
+(async () => {
+  // Handle non-boolean values for options.recursive
+
+  if (!common.isWindows && !common.isMacOS) {
+    assert.throws(() => {
+      const testsubdir = fs.mkdtempSync(testDir + path.sep);
+      fs.watch(testsubdir, { recursive: '1' });
+    }, {
+      code: 'ERR_INVALID_ARG_TYPE',
+    });
+  }
+})().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-fs-watch-recursive-watch-file.js b/test/js/node/test/parallel/test-fs-watch-recursive-watch-file.js
new file mode 100644
index 0000000000..3449db8e59
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-watch-recursive-watch-file.js
@@ -0,0 +1,55 @@
+'use strict';
+
+const common = require('../common');
+
+if (common.isIBMi)
+  common.skip('IBMi does not support `fs.watch()`');
+
+// fs-watch on folders have limited capability in AIX.
+// The testcase makes use of folder watching, and causes
+// hang. This behavior is documented. Skip this for AIX.
+
+if (common.isAIX)
+  common.skip('folder watch capability is limited in AIX.');
+
+const assert = require('assert');
+const path = require('path');
+const fs = require('fs');
+
+const tmpdir = require('../common/tmpdir');
+const testDir = tmpdir.path;
+tmpdir.refresh();
+
+(async () => {
+  // Watch a file (not a folder) using fs.watch
+
+  const rootDirectory = fs.mkdtempSync(testDir + path.sep);
+  const testDirectory = path.join(rootDirectory, 'test-6');
+  fs.mkdirSync(testDirectory);
+
+  const filePath = path.join(testDirectory, 'only-file.txt');
+  fs.writeFileSync(filePath, 'hello');
+
+  const watcher = fs.watch(filePath, { recursive: true });
+  let watcherClosed = false;
+  let interval;
+  watcher.on('change', function(event, filename) {
+    assert.strictEqual(event, 'change');
+
+    if (filename === path.basename(filePath)) {
+      clearInterval(interval);
+      interval = null;
+      watcher.close();
+      watcherClosed = true;
+    }
+  });
+
+  interval = setInterval(() => {
+    fs.writeFileSync(filePath, 'world');
+  }, common.platformTimeout(10));
+
+  process.on('exit', function() {
+    assert(watcherClosed, 'watcher Object was not closed');
+    assert.strictEqual(interval, null);
+  });
+})().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-fs-watch-ref-unref.js b/test/js/node/test/parallel/test-fs-watch-ref-unref.js
new file mode 100644
index 0000000000..e51ecaf5b2
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-watch-ref-unref.js
@@ -0,0 +1,20 @@
+'use strict';
+
+const common = require('../common');
+
+if (common.isIBMi)
+  common.skip('IBMi does not support `fs.watch()`');
+
+const fs = require('fs');
+
+const watcher = fs.watch(__filename, common.mustNotCall());
+
+watcher.unref();
+
+setTimeout(
+  common.mustCall(() => {
+    watcher.ref();
+    watcher.unref();
+  }),
+  common.platformTimeout(100)
+);
diff --git a/test/js/node/test/parallel/test-fs-watch-stop-sync.js b/test/js/node/test/parallel/test-fs-watch-stop-sync.js
new file mode 100644
index 0000000000..7f0882e489
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-watch-stop-sync.js
@@ -0,0 +1,21 @@
+'use strict';
+const common = require('../common');
+
+// This test checks that the `stop` event is emitted asynchronously.
+//
+// If it isn't asynchronous, then the listener will be called during the
+// execution of `watch.stop()`. That would be a bug.
+//
+// If it is asynchronous, then the listener will be removed before the event is
+// emitted.
+
+const fs = require('fs');
+
+const listener = common.mustNotCall(
+  'listener should have been removed before the event was emitted'
+);
+
+const watch = fs.watchFile(__filename, common.mustNotCall());
+watch.once('stop', listener);
+watch.stop();
+watch.removeListener('stop', listener);
diff --git a/test/js/node/test/parallel/test-fs-watch.js b/test/js/node/test/parallel/test-fs-watch.js
new file mode 100644
index 0000000000..a494b9f8df
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-watch.js
@@ -0,0 +1,98 @@
+'use strict';
+const common = require('../common');
+
+if (common.isIBMi)
+  common.skip('IBMi does not support `fs.watch()`');
+
+// Tests if `filename` is provided to watcher on supported platforms
+
+const fs = require('fs');
+const assert = require('assert');
+const { join } = require('path');
+
+class WatchTestCase {
+  constructor(shouldInclude, dirName, fileName, field) {
+    this.dirName = dirName;
+    this.fileName = fileName;
+    this.field = field;
+    this.shouldSkip = !shouldInclude;
+  }
+  get dirPath() { return tmpdir.resolve(this.dirName); }
+  get filePath() { return join(this.dirPath, this.fileName); }
+}
+
+const cases = [
+  // Watch on a file should callback with a filename on supported systems
+  new WatchTestCase(
+    common.isLinux || common.isMacOS || common.isWindows || common.isAIX,
+    'watch1',
+    'foo',
+    'filePath'
+  ),
+  // Watch on a directory should callback with a filename on supported systems
+  new WatchTestCase(
+    common.isLinux || common.isMacOS || common.isWindows,
+    'watch2',
+    'bar',
+    'dirPath'
+  ),
+];
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+for (const testCase of cases) {
+  if (testCase.shouldSkip) continue;
+  fs.mkdirSync(testCase.dirPath);
+  // Long content so it's actually flushed.
+  const content1 = Date.now() + testCase.fileName.toLowerCase().repeat(1e4);
+  fs.writeFileSync(testCase.filePath, content1);
+
+  let interval;
+  const pathToWatch = testCase[testCase.field];
+  const watcher = fs.watch(pathToWatch);
+  watcher.on('error', (err) => {
+    if (interval) {
+      clearInterval(interval);
+      interval = null;
+    }
+    assert.fail(err);
+  });
+  watcher.on('close', common.mustCall(() => {
+    watcher.close(); // Closing a closed watcher should be a noop
+  }));
+  watcher.on('change', common.mustCall(function(eventType, argFilename) {
+    if (interval) {
+      clearInterval(interval);
+      interval = null;
+    }
+    if (common.isMacOS)
+      assert.strictEqual(['rename', 'change'].includes(eventType), true);
+    else
+      assert.strictEqual(eventType, 'change');
+    assert.strictEqual(argFilename, testCase.fileName);
+
+    watcher.close();
+
+    // We document that watchers cannot be used anymore when it's closed,
+    // here we turn the methods into noops instead of throwing
+    watcher.close(); // Closing a closed watcher should be a noop
+  }));
+
+  // Long content so it's actually flushed. toUpperCase so there's real change.
+  const content2 = Date.now() + testCase.fileName.toUpperCase().repeat(1e4);
+  interval = setInterval(() => {
+    fs.writeFileSync(testCase.filePath, '');
+    fs.writeFileSync(testCase.filePath, content2);
+  }, 100);
+}
+
+[false, 1, {}, [], null, undefined].forEach((input) => {
+  assert.throws(
+    () => fs.watch(input, common.mustNotCall()),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError'
+    }
+  );
+});
diff --git a/test/js/node/test/parallel/test-fs-watchfile-ref-unref.js b/test/js/node/test/parallel/test-fs-watchfile-ref-unref.js
new file mode 100644
index 0000000000..4ac2691ea9
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-watchfile-ref-unref.js
@@ -0,0 +1,35 @@
+'use strict';
+
+const common = require('../common');
+
+const fs = require('fs');
+const assert = require('assert');
+
+const uncalledListener = common.mustNotCall();
+const uncalledListener2 = common.mustNotCall();
+const watcher = fs.watchFile(__filename, uncalledListener);
+
+watcher.unref();
+watcher.unref();
+watcher.ref();
+watcher.unref();
+watcher.ref();
+watcher.ref();
+watcher.unref();
+
+fs.unwatchFile(__filename, uncalledListener);
+
+// Watch the file with two different listeners.
+fs.watchFile(__filename, uncalledListener);
+const watcher2 = fs.watchFile(__filename, uncalledListener2);
+
+setTimeout(
+  common.mustCall(() => {
+    fs.unwatchFile(__filename, common.mustNotCall());
+    assert.strictEqual(watcher2.listenerCount('change'), 2);
+    fs.unwatchFile(__filename, uncalledListener);
+    assert.strictEqual(watcher2.listenerCount('change'), 1);
+    watcher2.unref();
+  }),
+  common.platformTimeout(100)
+);
diff --git a/test/js/node/test/parallel/test-fs-write-file-buffer.js b/test/js/node/test/parallel/test-fs-write-file-buffer.js
new file mode 100644
index 0000000000..ec6c60e1a4
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-write-file-buffer.js
@@ -0,0 +1,54 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const util = require('util');
+const fs = require('fs');
+
+let data = [
+  '/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAUDBAQEAwUEBAQFBQUGBwwIBwcH',
+  'Bw8LCwkMEQ8SEhEPERETFhwXExQaFRERGCEYGh0dHx8fExciJCIeJBweHx7/',
+  '2wBDAQUFBQcGBw4ICA4eFBEUHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4e',
+  'Hh4eHh4eHh4eHh4eHh4eHh4eHh4eHh7/wAARCAAQABADASIAAhEBAxEB/8QA',
+  'HwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUF',
+  'BAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkK',
+  'FhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1',
+  'dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXG',
+  'x8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEB',
+  'AQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAEC',
+  'AxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRom',
+  'JygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOE',
+  'hYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU',
+  '1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwDhfBUFl/wk',
+  'OmPqKJJZw3aiZFBw4z93jnkkc9u9dj8XLfSI/EBt7DTo7ea2Ox5YXVo5FC7g',
+  'Tjq24nJPXNVtO0KATRvNHCIg3zoWJWQHqp+o4pun+EtJ0zxBq8mnLJa2d1L5',
+  '0NvnKRjJBUE5PAx3NYxxUY0pRtvYHSc5Ka2X9d7H/9k='];
+
+data = data.join('\n');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+const buf = Buffer.from(data, 'base64');
+fs.writeFileSync(tmpdir.resolve('test.jpg'), buf);
+
+util.log('Done!');
diff --git a/test/js/node/test/parallel/test-fs-write-file-invalid-path.js b/test/js/node/test/parallel/test-fs-write-file-invalid-path.js
new file mode 100644
index 0000000000..aaa7eacde5
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-write-file-invalid-path.js
@@ -0,0 +1,45 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const fs = require('fs');
+
+if (!common.isWindows)
+  common.skip('This test is for Windows only.');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+const DATA_VALUE = 'hello';
+
+// Refs: https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247(v=vs.85).aspx
+// Ignore '/', '\\' and ':'
+const RESERVED_CHARACTERS = '<>"|?*';
+
+[...RESERVED_CHARACTERS].forEach((ch) => {
+  const pathname = tmpdir.resolve(`somefile_${ch}`);
+  assert.throws(
+    () => {
+      fs.writeFileSync(pathname, DATA_VALUE);
+    },
+    /^Error: ENOENT: no such file or directory, open '.*'$/,
+    `failed with '${ch}'`);
+});
+
+// Test for ':' (NTFS data streams).
+// Refs: https://msdn.microsoft.com/en-us/library/windows/desktop/bb540537.aspx
+const pathname = tmpdir.resolve('foo:bar');
+fs.writeFileSync(pathname, DATA_VALUE);
+
+let content = '';
+const fileDataStream = fs.createReadStream(pathname, {
+  encoding: 'utf8'
+});
+
+fileDataStream.on('data', (data) => {
+  content += data;
+});
+
+fileDataStream.on('end', common.mustCall(() => {
+  assert.strictEqual(content, DATA_VALUE);
+}));
diff --git a/test/js/node/test/parallel/test-fs-write-no-fd.js b/test/js/node/test/parallel/test-fs-write-no-fd.js
new file mode 100644
index 0000000000..576457203e
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-write-no-fd.js
@@ -0,0 +1,12 @@
+'use strict';
+const common = require('../common');
+const fs = require('fs');
+const assert = require('assert');
+
+assert.throws(function() {
+  fs.write(null, Buffer.allocUnsafe(1), 0, 1, common.mustNotCall());
+}, /TypeError/);
+
+assert.throws(function() {
+  fs.write(null, '1', 0, 1, common.mustNotCall());
+}, /TypeError/);
diff --git a/test/js/node/test/parallel/test-fs-write-stream-close-without-callback.js b/test/js/node/test/parallel/test-fs-write-stream-close-without-callback.js
new file mode 100644
index 0000000000..7bf83cd809
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-write-stream-close-without-callback.js
@@ -0,0 +1,12 @@
+'use strict';
+
+require('../common');
+const fs = require('fs');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+const s = fs.createWriteStream(tmpdir.resolve('nocallback'));
+
+s.end('hello world');
+s.close();
diff --git a/test/js/node/test/parallel/test-fs-write-stream-encoding.js b/test/js/node/test/parallel/test-fs-write-stream-encoding.js
new file mode 100644
index 0000000000..f06fae923c
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-write-stream-encoding.js
@@ -0,0 +1,35 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const fixtures = require('../common/fixtures');
+const fs = require('fs');
+const stream = require('stream');
+const tmpdir = require('../common/tmpdir');
+const firstEncoding = 'base64';
+const secondEncoding = 'latin1';
+
+const examplePath = fixtures.path('x.txt');
+const dummyPath = tmpdir.resolve('x.txt');
+
+tmpdir.refresh();
+
+const exampleReadStream = fs.createReadStream(examplePath, {
+  encoding: firstEncoding
+});
+
+const dummyWriteStream = fs.createWriteStream(dummyPath, {
+  encoding: firstEncoding
+});
+
+exampleReadStream.pipe(dummyWriteStream).on('finish', function() {
+  const assertWriteStream = new stream.Writable({
+    write: function(chunk, enc, next) {
+      const expected = Buffer.from('xyz\n');
+      assert(chunk.equals(expected));
+    }
+  });
+  assertWriteStream.setDefaultEncoding(secondEncoding);
+  fs.createReadStream(dummyPath, {
+    encoding: secondEncoding
+  }).pipe(assertWriteStream);
+});
diff --git a/test/js/node/test/parallel/test-fs-write-stream-end.js b/test/js/node/test/parallel/test-fs-write-stream-end.js
new file mode 100644
index 0000000000..7f0cc65540
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-write-stream-end.js
@@ -0,0 +1,59 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const fs = require('fs');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+{
+  const file = tmpdir.resolve('write-end-test0.txt');
+  const stream = fs.createWriteStream(file);
+  stream.end();
+  stream.on('close', common.mustCall());
+}
+
+{
+  const file = tmpdir.resolve('write-end-test1.txt');
+  const stream = fs.createWriteStream(file);
+  stream.end('a\n', 'utf8');
+  stream.on('close', common.mustCall(function() {
+    const content = fs.readFileSync(file, 'utf8');
+    assert.strictEqual(content, 'a\n');
+  }));
+}
+
+{
+  const file = tmpdir.resolve('write-end-test2.txt');
+  const stream = fs.createWriteStream(file);
+  stream.end();
+
+  let calledOpen = false;
+  stream.on('open', () => {
+    calledOpen = true;
+  });
+  stream.on('finish', common.mustCall(() => {
+    assert.strictEqual(calledOpen, true);
+  }));
+}
diff --git a/test/js/node/test/parallel/test-fs-write-stream.js b/test/js/node/test/parallel/test-fs-write-stream.js
new file mode 100644
index 0000000000..a3dccf7cdc
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-write-stream.js
@@ -0,0 +1,66 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const fs = require('fs');
+
+const tmpdir = require('../common/tmpdir');
+
+const file = tmpdir.resolve('write.txt');
+
+tmpdir.refresh();
+
+{
+  const stream = fs.WriteStream(file);
+  const _fs_close = fs.close;
+
+  fs.close = function(fd) {
+    assert.ok(fd, 'fs.close must not be called without an undefined fd.');
+    fs.close = _fs_close;
+    fs.closeSync(fd);
+  };
+  stream.destroy();
+}
+
+{
+  const stream = fs.createWriteStream(file);
+
+  stream.on('drain', function() {
+    assert.fail('\'drain\' event must not be emitted before ' +
+                'stream.write() has been called at least once.');
+  });
+  stream.destroy();
+}
+
+// Throws if data is not of type Buffer.
+{
+  const stream = fs.createWriteStream(file);
+  stream.on('error', common.mustNotCall());
+  assert.throws(() => {
+    stream.write(42);
+  }, {
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError'
+  });
+  stream.destroy();
+}
diff --git a/test/js/node/test/parallel/test-fs-write-sync.js b/test/js/node/test/parallel/test-fs-write-sync.js
new file mode 100644
index 0000000000..733892c35e
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-write-sync.js
@@ -0,0 +1,55 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const fs = require('fs');
+const tmpdir = require('../common/tmpdir');
+const filename = tmpdir.resolve('write.txt');
+
+tmpdir.refresh();
+
+{
+  const parameters = [Buffer.from('bár'), 0, Buffer.byteLength('bár')];
+
+  // The first time fs.writeSync is called with all parameters provided.
+  // After that, each pop in the cycle removes the final parameter. So:
+  // - The 2nd time fs.writeSync with a buffer, without the length parameter.
+  // - The 3rd time fs.writeSync with a buffer, without the offset and length
+  //   parameters.
+  while (parameters.length > 0) {
+    const fd = fs.openSync(filename, 'w');
+
+    let written = fs.writeSync(fd, '');
+    assert.strictEqual(written, 0);
+
+    fs.writeSync(fd, 'foo');
+
+    written = fs.writeSync(fd, ...parameters);
+    assert.ok(written > 3);
+    fs.closeSync(fd);
+
+    assert.strictEqual(fs.readFileSync(filename, 'utf-8'), 'foobár');
+
+    parameters.pop();
+  }
+}
diff --git a/test/js/node/test/parallel/test-fs-writestream-open-write.js b/test/js/node/test/parallel/test-fs-writestream-open-write.js
new file mode 100644
index 0000000000..af02d90ae6
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-writestream-open-write.js
@@ -0,0 +1,28 @@
+'use strict';
+
+const common = require('../common');
+const tmpdir = require('../common/tmpdir');
+const { strictEqual } = require('assert');
+const fs = require('fs');
+
+// Regression test for https://github.com/nodejs/node/issues/51993
+
+tmpdir.refresh();
+
+const file = tmpdir.resolve('test-fs-writestream-open-write.txt');
+
+const w = fs.createWriteStream(file);
+
+w.on('open', common.mustCall(() => {
+  w.write('hello');
+
+  process.nextTick(() => {
+    w.write('world');
+    w.end();
+  });
+}));
+
+w.on('close', common.mustCall(() => {
+  strictEqual(fs.readFileSync(file, 'utf8'), 'helloworld');
+  fs.unlinkSync(file);
+}));
diff --git a/test/js/node/test/parallel/test-global-domexception.js b/test/js/node/test/parallel/test-global-domexception.js
new file mode 100644
index 0000000000..d19b5a5e4f
--- /dev/null
+++ b/test/js/node/test/parallel/test-global-domexception.js
@@ -0,0 +1,11 @@
+'use strict';
+
+require('../common');
+
+const assert = require('assert');
+
+assert.strictEqual(typeof DOMException, 'function');
+
+assert.throws(() => {
+  atob('我要抛错！');
+}, DOMException);
diff --git a/test/js/node/test/parallel/test-global-encoder.js b/test/js/node/test/parallel/test-global-encoder.js
new file mode 100644
index 0000000000..0e98bc806c
--- /dev/null
+++ b/test/js/node/test/parallel/test-global-encoder.js
@@ -0,0 +1,8 @@
+'use strict';
+
+require('../common');
+const { strictEqual } = require('assert');
+const util = require('util');
+
+strictEqual(TextDecoder, util.TextDecoder);
+strictEqual(TextEncoder, util.TextEncoder);
diff --git a/test/js/node/test/parallel/test-global-webcrypto.js b/test/js/node/test/parallel/test-global-webcrypto.js
new file mode 100644
index 0000000000..9eb18ca9d1
--- /dev/null
+++ b/test/js/node/test/parallel/test-global-webcrypto.js
@@ -0,0 +1,13 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const crypto = require('crypto');
+
+/* eslint-disable no-restricted-properties */
+assert.strictEqual(globalThis.crypto, crypto.webcrypto);
+assert.strictEqual(Crypto, crypto.webcrypto.constructor);
+assert.strictEqual(SubtleCrypto, crypto.webcrypto.subtle.constructor);
diff --git a/test/js/node/test/parallel/test-handle-wrap-close-abort.js b/test/js/node/test/parallel/test-handle-wrap-close-abort.js
new file mode 100644
index 0000000000..b91f9dd349
--- /dev/null
+++ b/test/js/node/test/parallel/test-handle-wrap-close-abort.js
@@ -0,0 +1,37 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+
+process.on('uncaughtException', common.mustCall(2));
+
+setTimeout(function() {
+  process.nextTick(function() {
+    const c = setInterval(function() {
+      clearInterval(c);
+      throw new Error('setInterval');
+    }, 1);
+  });
+  setTimeout(function() {
+    throw new Error('setTimeout');
+  }, 1);
+}, 1);
diff --git a/test/js/node/test/parallel/test-http-abort-before-end.js b/test/js/node/test/parallel/test-http-abort-before-end.js
new file mode 100644
index 0000000000..5577f256ca
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-abort-before-end.js
@@ -0,0 +1,43 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const http = require('http');
+
+const server = http.createServer(common.mustNotCall());
+
+server.listen(0, common.mustCall(() => {
+  const req = http.request({
+    method: 'GET',
+    host: '127.0.0.1',
+    port: server.address().port
+  });
+
+  req.on('abort', common.mustCall(() => {
+    server.close();
+  }));
+
+  req.on('error', common.mustNotCall());
+
+  req.abort();
+  req.end();
+}));
diff --git a/test/js/node/test/parallel/test-http-agent-false.js b/test/js/node/test/parallel/test-http-agent-false.js
new file mode 100644
index 0000000000..2f4505ef66
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-agent-false.js
@@ -0,0 +1,46 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const http = require('http');
+
+// Sending `agent: false` when `port: null` is also passed in (i.e. the result
+// of a `url.parse()` call with the default port used, 80 or 443), should not
+// result in an assertion error...
+const opts = {
+  host: '127.0.0.1',
+  port: null,
+  path: '/',
+  method: 'GET',
+  agent: false
+};
+
+// We just want an "error" (no local HTTP server on port 80) or "response"
+// to happen (user happens ot have HTTP server running on port 80).
+// As long as the process doesn't crash from a C++ assertion then we're good.
+const req = http.request(opts);
+
+// Will be called by either the response event or error event, not both
+const oneResponse = common.mustCall();
+req.on('response', oneResponse);
+req.on('error', oneResponse);
+req.end();
diff --git a/test/js/node/test/parallel/test-http-agent-keepalive-delay.js b/test/js/node/test/parallel/test-http-agent-keepalive-delay.js
new file mode 100644
index 0000000000..b5edd78b66
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-agent-keepalive-delay.js
@@ -0,0 +1,36 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const http = require('http');
+const { Agent } = require('_http_agent');
+
+const agent = new Agent({
+  keepAlive: true,
+  keepAliveMsecs: 1000,
+});
+
+const server = http.createServer(common.mustCall((req, res) => {
+  res.end('ok');
+}));
+
+server.listen(0, common.mustCall(() => {
+  const createConnection = agent.createConnection;
+  agent.createConnection = (options, ...args) => {
+    assert.strictEqual(options.keepAlive, true);
+    assert.strictEqual(options.keepAliveInitialDelay, agent.keepAliveMsecs);
+    return createConnection.call(agent, options, ...args);
+  };
+  http.get({
+    host: 'localhost',
+    port: server.address().port,
+    agent: agent,
+    path: '/'
+  }, common.mustCall((res) => {
+    // for emit end event
+    res.on('data', () => {});
+    res.on('end', () => {
+      server.close();
+    });
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http-agent-no-protocol.js b/test/js/node/test/parallel/test-http-agent-no-protocol.js
new file mode 100644
index 0000000000..d1eaf242a5
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-agent-no-protocol.js
@@ -0,0 +1,41 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const http = require('http');
+const url = require('url');
+
+const server = http.createServer(common.mustCall((req, res) => {
+  res.end();
+})).listen(0, '127.0.0.1', common.mustCall(() => {
+  const opts = url.parse(`http://127.0.0.1:${server.address().port}/`);
+
+  // Remove the `protocol` field… the `http` module should fall back
+  // to "http:", as defined by the global, default `http.Agent` instance.
+  opts.agent = new http.Agent();
+  opts.agent.protocol = null;
+
+  http.get(opts, common.mustCall((res) => {
+    res.resume();
+    server.close();
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http-agent-null.js b/test/js/node/test/parallel/test-http-agent-null.js
new file mode 100644
index 0000000000..0f87d09813
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-agent-null.js
@@ -0,0 +1,37 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const http = require('http');
+
+const server = http.createServer(common.mustCall((req, res) => {
+  res.end();
+})).listen(0, common.mustCall(() => {
+  const options = {
+    agent: null,
+    port: server.address().port
+  };
+  http.get(options, common.mustCall((res) => {
+    res.resume();
+    server.close();
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http-agent-uninitialized-with-handle.js b/test/js/node/test/parallel/test-http-agent-uninitialized-with-handle.js
new file mode 100644
index 0000000000..77f0177173
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-agent-uninitialized-with-handle.js
@@ -0,0 +1,31 @@
+'use strict';
+
+const common = require('../common');
+const http = require('http');
+const net = require('net');
+
+const agent = new http.Agent({
+  keepAlive: true,
+});
+const socket = new net.Socket();
+// If _handle exists then internals assume a couple methods exist.
+socket._handle = {
+  ref() { },
+  readStart() { },
+};
+
+const server = http.createServer(common.mustCall((req, res) => {
+  res.end();
+})).listen(0, common.mustCall(() => {
+  const req = new http.ClientRequest(`http://localhost:${server.address().port}/`);
+
+  // Manually add the socket without a _handle.
+  agent.freeSockets[agent.getName(req)] = [socket];
+  // Now force the agent to use the socket and check that _handle exists before
+  // calling asyncReset().
+  agent.addRequest(req, {});
+  req.on('response', common.mustCall(() => {
+    server.close();
+  }));
+  req.end();
+}));
diff --git a/test/js/node/test/parallel/test-http-agent-uninitialized.js b/test/js/node/test/parallel/test-http-agent-uninitialized.js
new file mode 100644
index 0000000000..dbb38e3b0f
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-agent-uninitialized.js
@@ -0,0 +1,26 @@
+'use strict';
+
+const common = require('../common');
+const http = require('http');
+const net = require('net');
+
+const agent = new http.Agent({
+  keepAlive: true,
+});
+const socket = new net.Socket();
+
+const server = http.createServer(common.mustCall((req, res) => {
+  res.end();
+})).listen(0, common.mustCall(() => {
+  const req = new http.ClientRequest(`http://localhost:${server.address().port}/`);
+
+  // Manually add the socket without a _handle.
+  agent.freeSockets[agent.getName(req)] = [socket];
+  // Now force the agent to use the socket and check that _handle exists before
+  // calling asyncReset().
+  agent.addRequest(req, {});
+  req.on('response', common.mustCall(() => {
+    server.close();
+  }));
+  req.end();
+}));
diff --git a/test/js/node/test/parallel/test-http-allow-req-after-204-res.js b/test/js/node/test/parallel/test-http-allow-req-after-204-res.js
new file mode 100644
index 0000000000..84dd876985
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-allow-req-after-204-res.js
@@ -0,0 +1,61 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const http = require('http');
+const assert = require('assert');
+const Countdown = require('../common/countdown');
+
+// first 204 or 304 works, subsequent anything fails
+const codes = [204, 200];
+
+const countdown = new Countdown(codes.length, () => server.close());
+
+const server = http.createServer(common.mustCall((req, res) => {
+  const code = codes.shift();
+  assert.strictEqual(typeof code, 'number');
+  assert.ok(code > 0);
+  res.writeHead(code, {});
+  res.end();
+}, codes.length));
+
+function nextRequest() {
+
+  const request = http.get({
+    port: server.address().port,
+    path: '/'
+  }, common.mustCall((response) => {
+    response.on('end', common.mustCall(() => {
+      if (countdown.dec()) {
+        // throws error:
+        nextRequest();
+        // TODO: investigate why this does not work fine even though it should.
+        // works just fine:
+        // process.nextTick(nextRequest);
+      }
+    }));
+    response.resume();
+  }));
+  request.end();
+}
+
+server.listen(0, nextRequest);
diff --git a/test/js/node/test/parallel/test-http-bind-twice.js b/test/js/node/test/parallel/test-http-bind-twice.js
new file mode 100644
index 0000000000..50834cc5cb
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-bind-twice.js
@@ -0,0 +1,36 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const http = require('http');
+
+const server1 = http.createServer(common.mustNotCall());
+server1.listen(0, '127.0.0.1', common.mustCall(function() {
+  const server2 = http.createServer(common.mustNotCall());
+  server2.listen(this.address().port, '127.0.0.1', common.mustNotCall());
+
+  server2.on('error', common.mustCall(function(e) {
+    assert.strictEqual(e.code, 'EADDRINUSE');
+    server1.close();
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http-buffer-sanity.js b/test/js/node/test/parallel/test-http-buffer-sanity.js
new file mode 100644
index 0000000000..05c027fd48
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-buffer-sanity.js
@@ -0,0 +1,71 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const http = require('http');
+
+const bufferSize = 5 * 1024 * 1024;
+let measuredSize = 0;
+
+const buffer = Buffer.allocUnsafe(bufferSize);
+for (let i = 0; i < buffer.length; i++) {
+  buffer[i] = i % 256;
+}
+
+const server = http.Server(function(req, res) {
+  server.close();
+
+  let i = 0;
+
+  req.on('data', (d) => {
+    measuredSize += d.length;
+    for (let j = 0; j < d.length; j++) {
+      assert.strictEqual(d[j], buffer[i]);
+      i++;
+    }
+  });
+
+  req.on('end', common.mustCall(() => {
+    assert.strictEqual(measuredSize, bufferSize);
+    res.writeHead(200);
+    res.write('thanks');
+    res.end();
+  }));
+});
+
+server.listen(0, common.mustCall(() => {
+  const req = http.request({
+    port: server.address().port,
+    method: 'POST',
+    path: '/',
+    headers: { 'content-length': buffer.length }
+  }, common.mustCall((res) => {
+    res.setEncoding('utf8');
+    let data = '';
+    res.on('data', (chunk) => data += chunk);
+    res.on('end', common.mustCall(() => {
+      assert.strictEqual(data, 'thanks');
+    }));
+  }));
+  req.end(buffer);
+}));
diff --git a/test/js/node/test/parallel/test-http-chunk-problem.js b/test/js/node/test/parallel/test-http-chunk-problem.js
new file mode 100644
index 0000000000..a3c354aecd
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-chunk-problem.js
@@ -0,0 +1,96 @@
+'use strict';
+// http://groups.google.com/group/nodejs/browse_thread/thread/f66cd3c960406919
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+
+if (process.argv[2] === 'request') {
+  const http = require('http');
+  const options = {
+    port: +process.argv[3],
+    path: '/'
+  };
+
+  http.get(options, (res) => {
+    res.pipe(process.stdout);
+  });
+
+  return;
+}
+
+if (process.argv[2] === 'shasum') {
+  const crypto = require('crypto');
+  const shasum = crypto.createHash('sha1');
+  process.stdin.on('data', (d) => {
+    shasum.update(d);
+  });
+
+  process.stdin.on('close', () => {
+    process.stdout.write(shasum.digest('hex'));
+  });
+
+  return;
+}
+
+const http = require('http');
+const cp = require('child_process');
+
+const tmpdir = require('../common/tmpdir');
+
+const filename = tmpdir.resolve('big');
+let server;
+
+function executeRequest(cb) {
+  cp.exec([`"${process.execPath}"`,
+           `"${__filename}"`,
+           'request',
+           server.address().port,
+           '|',
+           `"${process.execPath}"`,
+           `"${__filename}"`,
+           'shasum' ].join(' '),
+          (err, stdout, stderr) => {
+            if (stderr.trim() !== '') {
+              console.log(stderr);
+            }
+            assert.ifError(err);
+            assert.strictEqual(stdout.slice(0, 40),
+                               '8c206a1a87599f532ce68675536f0b1546900d7a');
+            cb();
+          }
+  );
+}
+
+
+tmpdir.refresh();
+
+common.createZeroFilledFile(filename);
+
+server = http.createServer(function(req, res) {
+  res.writeHead(200);
+
+  // Create the subprocess
+  const cat = cp.spawn('cat', [filename]);
+
+  // Stream the data through to the response as binary chunks
+  cat.stdout.on('data', (data) => {
+    res.write(data);
+  });
+
+  cat.stdout.on('end', () => res.end());
+
+  // End the response on exit (and log errors)
+  cat.on('exit', (code) => {
+    if (code !== 0) {
+      console.error(`subprocess exited with code ${code}`);
+      process.exit(1);
+    }
+  });
+
+});
+
+server.listen(0, () => {
+  executeRequest(() => server.close());
+});
diff --git a/test/js/node/test/parallel/test-http-chunked-smuggling.js b/test/js/node/test/parallel/test-http-chunked-smuggling.js
new file mode 100644
index 0000000000..dbad45e1be
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-chunked-smuggling.js
@@ -0,0 +1,43 @@
+'use strict';
+
+const common = require('../common');
+const http = require('http');
+const net = require('net');
+const assert = require('assert');
+
+// Verify that invalid chunk extensions cannot be used to perform HTTP request
+// smuggling attacks.
+
+const server = http.createServer(common.mustCall((request, response) => {
+  assert.notStrictEqual(request.url, '/admin');
+  response.end('hello world');
+}), 1);
+
+server.listen(0, common.mustCall(start));
+
+function start() {
+  const sock = net.connect(server.address().port);
+
+  sock.write('' +
+    'GET / HTTP/1.1\r\n' +
+    'Host: localhost:8080\r\n' +
+    'Transfer-Encoding: chunked\r\n' +
+    '\r\n' +
+    '2;\n' +
+    'xx\r\n' +
+    '4c\r\n' +
+    '0\r\n' +
+    '\r\n' +
+    'GET /admin HTTP/1.1\r\n' +
+    'Host: localhost:8080\r\n' +
+    'Transfer-Encoding: chunked\r\n' +
+    '\r\n' +
+    '0\r\n' +
+    '\r\n'
+  );
+
+  sock.resume();
+  sock.on('end', common.mustCall(function() {
+    server.close();
+  }));
+}
diff --git a/test/js/node/test/parallel/test-http-chunked.js b/test/js/node/test/parallel/test-http-chunked.js
new file mode 100644
index 0000000000..cfa34e3afe
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-chunked.js
@@ -0,0 +1,48 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const http = require('http');
+const fixtures = require('../common/fixtures');
+const UTF8_STRING = fixtures.utf8TestText;
+
+const server = http.createServer(common.mustCall((req, res) => {
+  res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf8' });
+  res.end(UTF8_STRING, 'utf8');
+}));
+server.listen(0, common.mustCall(() => {
+  let data = '';
+  http.get({
+    path: '/',
+    host: 'localhost',
+    port: server.address().port
+  }, common.mustCall((x) => {
+    x.setEncoding('utf8');
+    x.on('data', (c) => data += c);
+    x.on('end', common.mustCall(() => {
+      assert.strictEqual(typeof data, 'string');
+      assert.strictEqual(UTF8_STRING, data);
+      server.close();
+    }));
+  })).end();
+}));
diff --git a/test/js/node/test/parallel/test-http-client-abort2.js b/test/js/node/test/parallel/test-http-client-abort2.js
new file mode 100644
index 0000000000..bc4b0e4083
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-client-abort2.js
@@ -0,0 +1,38 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const http = require('http');
+
+const server = http.createServer(common.mustCall((req, res) => {
+  res.end('Hello');
+}));
+
+server.listen(0, common.mustCall(() => {
+  const options = { port: server.address().port };
+  const req = http.get(options, common.mustCall((res) => {
+    res.on('data', (data) => {
+      req.abort();
+      server.close();
+    });
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http-client-close-with-default-agent.js b/test/js/node/test/parallel/test-http-client-close-with-default-agent.js
new file mode 100644
index 0000000000..ea1e1481ba
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-client-close-with-default-agent.js
@@ -0,0 +1,23 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const http = require('http');
+
+const server = http.createServer(function(req, res) {
+  res.writeHead(200);
+  res.end();
+});
+
+server.listen(0, common.mustCall(() => {
+  const req = http.get({ port: server.address().port }, (res) => {
+    assert.strictEqual(res.statusCode, 200);
+    res.resume();
+    server.close();
+  });
+
+  req.end();
+}));
+
+// This timer should never go off as the server will close the socket
+setTimeout(common.mustNotCall(), common.platformTimeout(1000)).unref();
diff --git a/test/js/node/test/parallel/test-http-client-defaults.js b/test/js/node/test/parallel/test-http-client-defaults.js
new file mode 100644
index 0000000000..43419d1dfd
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-client-defaults.js
@@ -0,0 +1,23 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const ClientRequest = require('http').ClientRequest;
+
+{
+  const req = new ClientRequest({ createConnection: () => {} });
+  assert.strictEqual(req.path, '/');
+  assert.strictEqual(req.method, 'GET');
+}
+
+{
+  const req = new ClientRequest({ method: '', createConnection: () => {} });
+  assert.strictEqual(req.path, '/');
+  assert.strictEqual(req.method, 'GET');
+}
+
+{
+  const req = new ClientRequest({ path: '', createConnection: () => {} });
+  assert.strictEqual(req.path, '/');
+  assert.strictEqual(req.method, 'GET');
+}
diff --git a/test/js/node/test/parallel/test-http-client-encoding.js b/test/js/node/test/parallel/test-http-client-encoding.js
new file mode 100644
index 0000000000..a4701cdbd0
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-client-encoding.js
@@ -0,0 +1,39 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const http = require('http');
+
+const server = http.createServer((req, res) => {
+  res.end('ok');
+  server.close();
+}).listen(0, common.mustCall(() => {
+  http.request({
+    port: server.address().port,
+    encoding: 'utf8'
+  }, common.mustCall((res) => {
+    let data = '';
+    res.on('data', (chunk) => data += chunk);
+    res.on('end', common.mustCall(() => assert.strictEqual(data, 'ok')));
+  })).end();
+}));
diff --git a/test/js/node/test/parallel/test-http-client-get-url.js b/test/js/node/test/parallel/test-http-client-get-url.js
new file mode 100644
index 0000000000..3b091a72ed
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-client-get-url.js
@@ -0,0 +1,46 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const http = require('http');
+const url = require('url');
+const testPath = '/foo?bar';
+
+const server = http.createServer(common.mustCall((req, res) => {
+  assert.strictEqual(req.method, 'GET');
+  assert.strictEqual(req.url, testPath);
+  res.writeHead(200, { 'Content-Type': 'text/plain' });
+  res.write('hello\n');
+  res.end();
+}, 3));
+
+server.listen(0, common.localhostIPv4, common.mustCall(() => {
+  const u = `http://${common.localhostIPv4}:${server.address().port}${testPath}`;
+  http.get(u, common.mustCall(() => {
+    http.get(url.parse(u), common.mustCall(() => {
+      http.get(new URL(u), common.mustCall(() => {
+        server.close();
+      }));
+    }));
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http-client-input-function.js b/test/js/node/test/parallel/test-http-client-input-function.js
new file mode 100644
index 0000000000..3a2f93aa0e
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-client-input-function.js
@@ -0,0 +1,29 @@
+'use strict';
+
+const common = require('../common');
+const http = require('http');
+const assert = require('assert');
+
+{
+  const server = http.createServer(common.mustCall((req, res) => {
+    res.writeHead(200);
+    res.end('hello world');
+  })).listen(0, '127.0.0.1');
+
+  server.on('listening', common.mustCall(() => {
+    const req = new http.ClientRequest(server.address(), common.mustCall((response) => {
+      let body = '';
+      response.setEncoding('utf8');
+      response.on('data', (chunk) => {
+        body += chunk;
+      });
+
+      response.on('end', common.mustCall(() => {
+        assert.strictEqual(body, 'hello world');
+        server.close();
+      }));
+    }));
+
+    req.end();
+  }));
+}
diff --git a/test/js/node/test/parallel/test-http-client-keep-alive-hint.js b/test/js/node/test/parallel/test-http-client-keep-alive-hint.js
new file mode 100644
index 0000000000..2618dfd552
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-client-keep-alive-hint.js
@@ -0,0 +1,27 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const http = require('http');
+
+const server = http.createServer(
+  { keepAliveTimeout: common.platformTimeout(60000) },
+  function(req, res) {
+    req.resume();
+    res.writeHead(200, { 'Connection': 'keep-alive', 'Keep-Alive': 'timeout=1' });
+    res.end('FOO');
+  }
+);
+
+server.listen(0, common.mustCall(() => {
+  http.get({ port: server.address().port }, (res) => {
+    assert.strictEqual(res.statusCode, 200);
+
+    res.resume();
+    server.close();
+  });
+}));
+
+
+// This timer should never go off as the agent will parse the hint and terminate earlier
+setTimeout(common.mustNotCall(), common.platformTimeout(3000)).unref();
diff --git a/test/js/node/test/parallel/test-http-client-keep-alive-release-before-finish.js b/test/js/node/test/parallel/test-http-client-keep-alive-release-before-finish.js
new file mode 100644
index 0000000000..e6e0bac1bb
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-client-keep-alive-release-before-finish.js
@@ -0,0 +1,39 @@
+'use strict';
+const common = require('../common');
+const http = require('http');
+
+const server = http.createServer((req, res) => {
+  res.end();
+}).listen(0, common.mustCall(() => {
+  const agent = new http.Agent({
+    maxSockets: 1,
+    keepAlive: true
+  });
+
+  const port = server.address().port;
+
+  const post = http.request({
+    agent,
+    method: 'POST',
+    port,
+  }, common.mustCall((res) => {
+    res.resume();
+  }));
+
+  // What happens here is that the server `end`s the response before we send
+  // `something`, and the client thought that this is a green light for sending
+  // next GET request
+  post.write(Buffer.alloc(16 * 1024, 'X'));
+  setTimeout(() => {
+    post.end('something');
+  }, 100);
+
+  http.request({
+    agent,
+    method: 'GET',
+    port,
+  }, common.mustCall((res) => {
+    server.close();
+    res.connection.end();
+  })).end();
+}));
diff --git a/test/js/node/test/parallel/test-http-client-pipe-end.js b/test/js/node/test/parallel/test-http-client-pipe-end.js
new file mode 100644
index 0000000000..ee88ce3d96
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-client-pipe-end.js
@@ -0,0 +1,62 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+// See https://github.com/joyent/node/issues/3257
+
+const common = require('../common');
+const http = require('http');
+
+const server = http.createServer(function(req, res) {
+  req.resume();
+  req.once('end', function() {
+    res.writeHead(200);
+    res.end();
+    server.close();
+  });
+});
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+server.listen(common.PIPE, function() {
+  const req = http.request({
+    socketPath: common.PIPE,
+    headers: { 'Content-Length': '1' },
+    method: 'POST',
+    path: '/'
+  });
+
+  req.write('.');
+
+  sched(function() { req.end(); }, 5);
+});
+
+// Schedule a callback after `ticks` event loop ticks
+function sched(cb, ticks) {
+  function fn() {
+    if (--ticks)
+      setImmediate(fn);
+    else
+      cb();
+  }
+  setImmediate(fn);
+}
diff --git a/test/js/node/test/parallel/test-http-client-race-2.js b/test/js/node/test/parallel/test-http-client-race-2.js
new file mode 100644
index 0000000000..951b8e0d74
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-client-race-2.js
@@ -0,0 +1,112 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const http = require('http');
+const url = require('url');
+
+//
+// Slight variation on test-http-client-race to test for another race
+// condition involving the parsers FreeList used internally by http.Client.
+//
+
+const body1_s = '1111111111111111';
+const body2_s = '22222';
+const body3_s = '3333333333333333333';
+
+const server = http.createServer(function(req, res) {
+  const pathname = url.parse(req.url).pathname;
+
+  let body;
+  switch (pathname) {
+    case '/1': body = body1_s; break;
+    case '/2': body = body2_s; break;
+    default: body = body3_s;
+  }
+
+  res.writeHead(200, {
+    'Content-Type': 'text/plain',
+    'Content-Length': body.length
+  });
+  res.end(body);
+});
+server.listen(0);
+
+let body1 = '';
+let body2 = '';
+let body3 = '';
+
+server.on('listening', function() {
+  //
+  // Client #1 is assigned Parser #1
+  //
+  const req1 = http.get({ port: this.address().port, path: '/1' });
+  req1.on('response', function(res1) {
+    res1.setEncoding('utf8');
+
+    res1.on('data', function(chunk) {
+      body1 += chunk;
+    });
+
+    res1.on('end', function() {
+      //
+      // Delay execution a little to allow the 'close' event to be processed
+      // (required to trigger this bug!)
+      //
+      setTimeout(function() {
+        //
+        // The bug would introduce itself here: Client #2 would be allocated the
+        // parser that previously belonged to Client #1. But we're not finished
+        // with Client #1 yet!
+        //
+        // At this point, the bug would manifest itself and crash because the
+        // internal state of the parser was no longer valid for use by Client #1
+        //
+        const req2 = http.get({ port: server.address().port, path: '/2' });
+        req2.on('response', function(res2) {
+          res2.setEncoding('utf8');
+          res2.on('data', function(chunk) { body2 += chunk; });
+          res2.on('end', function() {
+
+            //
+            // Just to be really sure we've covered all our bases, execute a
+            // request using client2.
+            //
+            const req3 = http.get({ port: server.address().port, path: '/3' });
+            req3.on('response', function(res3) {
+              res3.setEncoding('utf8');
+              res3.on('data', function(chunk) { body3 += chunk; });
+              res3.on('end', function() { server.close(); });
+            });
+          });
+        });
+      }, 500);
+    });
+  });
+});
+
+process.on('exit', function() {
+  assert.strictEqual(body1_s, body1);
+  assert.strictEqual(body2_s, body2);
+  assert.strictEqual(body3_s, body3);
+});
diff --git a/test/js/node/test/parallel/test-http-client-race.js b/test/js/node/test/parallel/test-http-client-race.js
new file mode 100644
index 0000000000..60b6b49737
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-client-race.js
@@ -0,0 +1,69 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const http = require('http');
+const url = require('url');
+
+const body1_s = '1111111111111111';
+const body2_s = '22222';
+
+const server = http.createServer(function(req, res) {
+  const body = url.parse(req.url).pathname === '/1' ? body1_s : body2_s;
+  res.writeHead(200, {
+    'Content-Type': 'text/plain',
+    'Content-Length': body.length
+  });
+  res.end(body);
+});
+server.listen(0);
+
+let body1 = '';
+let body2 = '';
+
+server.on('listening', function() {
+  const req1 = http.request({ port: this.address().port, path: '/1' });
+  req1.end();
+  req1.on('response', function(res1) {
+    res1.setEncoding('utf8');
+
+    res1.on('data', function(chunk) {
+      body1 += chunk;
+    });
+
+    res1.on('end', function() {
+      const req2 = http.request({ port: server.address().port, path: '/2' });
+      req2.end();
+      req2.on('response', function(res2) {
+        res2.setEncoding('utf8');
+        res2.on('data', function(chunk) { body2 += chunk; });
+        res2.on('end', function() { server.close(); });
+      });
+    });
+  });
+});
+
+process.on('exit', function() {
+  assert.strictEqual(body1_s, body1);
+  assert.strictEqual(body2_s, body2);
+});
diff --git a/test/js/node/test/parallel/test-http-client-read-in-error.js b/test/js/node/test/parallel/test-http-client-read-in-error.js
new file mode 100644
index 0000000000..5e38e49c1f
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-client-read-in-error.js
@@ -0,0 +1,41 @@
+'use strict';
+const common = require('../common');
+const net = require('net');
+const http = require('http');
+
+class Agent extends http.Agent {
+  createConnection() {
+    const socket = new net.Socket();
+
+    socket.on('error', function() {
+      socket.push('HTTP/1.1 200\r\n\r\n');
+    });
+
+    let onNewListener;
+    socket.on('newListener', onNewListener = (name) => {
+      if (name !== 'error')
+        return;
+      socket.removeListener('newListener', onNewListener);
+
+      // Let other listeners to be set up too
+      process.nextTick(() => {
+        this.breakSocket(socket);
+      });
+    });
+
+    return socket;
+  }
+
+  breakSocket(socket) {
+    socket.emit('error', new Error('Intentional error'));
+  }
+}
+
+const agent = new Agent();
+
+http.request({
+  agent
+}).once('error', function() {
+  console.log('ignore');
+  this.on('data', common.mustNotCall());
+});
diff --git a/test/js/node/test/parallel/test-http-client-res-destroyed.js b/test/js/node/test/parallel/test-http-client-res-destroyed.js
new file mode 100644
index 0000000000..188ab06c15
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-client-res-destroyed.js
@@ -0,0 +1,41 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const http = require('http');
+
+{
+  const server = http.createServer(common.mustCall((req, res) => {
+    res.end('asd');
+  }));
+
+  server.listen(0, common.mustCall(() => {
+    http.get({
+      port: server.address().port
+    }, common.mustCall((res) => {
+      assert.strictEqual(res.destroyed, false);
+      res.destroy();
+      assert.strictEqual(res.destroyed, true);
+      res.on('close', common.mustCall(() => {
+        server.close();
+      }));
+    }));
+  }));
+}
+
+{
+  const server = http.createServer(common.mustCall((req, res) => {
+    res.end('asd');
+  }));
+
+  server.listen(0, common.mustCall(() => {
+    http.get({
+      port: server.address().port
+    }, common.mustCall((res) => {
+      assert.strictEqual(res.destroyed, false);
+      res.on('close', common.mustCall(() => {
+        assert.strictEqual(res.destroyed, true);
+        server.close();
+      })).resume();
+    }));
+  }));
+}
diff --git a/test/js/node/test/parallel/test-http-client-timeout-agent.js b/test/js/node/test/parallel/test-http-client-timeout-agent.js
new file mode 100644
index 0000000000..66c0c0f6b9
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-client-timeout-agent.js
@@ -0,0 +1,94 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const http = require('http');
+
+let requests_sent = 0;
+let requests_done = 0;
+const options = {
+  method: 'GET',
+  port: undefined,
+  host: '127.0.0.1',
+};
+
+const server = http.createServer((req, res) => {
+  const m = /\/(.*)/.exec(req.url);
+  const reqid = parseInt(m[1], 10);
+  if (reqid % 2) {
+    // Do not reply the request
+  } else {
+    res.writeHead(200, { 'Content-Type': 'text/plain' });
+    res.write(reqid.toString());
+    res.end();
+  }
+});
+
+server.listen(0, options.host, function() {
+  options.port = this.address().port;
+
+  for (requests_sent = 0; requests_sent < 30; requests_sent += 1) {
+    options.path = `/${requests_sent}`;
+    const req = http.request(options);
+    req.id = requests_sent;
+    req.on('response', (res) => {
+      res.on('data', function(data) {
+        console.log(`res#${this.req.id} data:${data}`);
+      });
+      res.on('end', function(data) {
+        console.log(`res#${this.req.id} end`);
+        requests_done += 1;
+        req.destroy();
+      });
+    });
+    req.on('close', function() {
+      console.log(`req#${this.id} close`);
+    });
+    req.on('error', function() {
+      console.log(`req#${this.id} error`);
+      this.destroy();
+    });
+    req.setTimeout(50, function() {
+      console.log(`req#${this.id} timeout`);
+      this.abort();
+      requests_done += 1;
+    });
+    req.end();
+  }
+
+  setTimeout(function maybeDone() {
+    if (requests_done >= requests_sent) {
+      setTimeout(() => {
+        server.close();
+      }, 100);
+    } else {
+      setTimeout(maybeDone, 100);
+    }
+  }, 100);
+});
+
+process.on('exit', () => {
+  console.error(`done=${requests_done} sent=${requests_sent}`);
+  // Check that timeout on http request was not called too much
+  assert.strictEqual(requests_done, requests_sent);
+});
diff --git a/test/js/node/test/parallel/test-http-client-timeout-connect-listener.js b/test/js/node/test/parallel/test-http-client-timeout-connect-listener.js
new file mode 100644
index 0000000000..ea09aff718
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-client-timeout-connect-listener.js
@@ -0,0 +1,42 @@
+'use strict';
+const common = require('../common');
+
+// This test ensures that `ClientRequest.prototype.setTimeout()` does
+// not add a listener for the `'connect'` event to the socket if the
+// socket is already connected.
+
+const assert = require('assert');
+const http = require('http');
+
+// Maximum allowed value for timeouts.
+const timeout = 2 ** 31 - 1;
+
+const server = http.createServer((req, res) => {
+  res.end();
+});
+
+server.listen(0, common.mustCall(() => {
+  const agent = new http.Agent({ keepAlive: true, maxSockets: 1 });
+  const options = { port: server.address().port, agent: agent };
+
+  doRequest(options, common.mustCall(() => {
+    const req = doRequest(options, common.mustCall(() => {
+      agent.destroy();
+      server.close();
+    }));
+
+    req.on('socket', common.mustCall((socket) => {
+      assert.strictEqual(socket.listenerCount('connect'), 0);
+    }));
+  }));
+}));
+
+function doRequest(options, callback) {
+  const req = http.get(options, (res) => {
+    res.on('end', callback);
+    res.resume();
+  });
+
+  req.setTimeout(timeout);
+  return req;
+}
diff --git a/test/js/node/test/parallel/test-http-client-timeout.js b/test/js/node/test/parallel/test-http-client-timeout.js
new file mode 100644
index 0000000000..b83bd1ddf0
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-client-timeout.js
@@ -0,0 +1,54 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const http = require('http');
+
+const options = {
+  method: 'GET',
+  port: undefined,
+  host: '127.0.0.1',
+  path: '/'
+};
+
+const server = http.createServer(function(req, res) {
+  // This space intentionally left blank
+});
+
+server.listen(0, options.host, function() {
+  options.port = this.address().port;
+  const req = http.request(options, function(res) {
+    // This space intentionally left blank
+  });
+  req.on('close', function() {
+    assert.strictEqual(req.destroyed, true);
+    server.close();
+  });
+  function destroy() {
+    req.destroy();
+  }
+  const s = req.setTimeout(1, destroy);
+  assert.ok(s instanceof http.ClientRequest);
+  req.on('error', destroy);
+  req.end();
+});
diff --git a/test/js/node/test/parallel/test-http-client-upload-buf.js b/test/js/node/test/parallel/test-http-client-upload-buf.js
new file mode 100644
index 0000000000..1c75612c80
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-client-upload-buf.js
@@ -0,0 +1,64 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const http = require('http');
+
+const N = 1024;
+
+const server = http.createServer(common.mustCall(function(req, res) {
+  assert.strictEqual(req.method, 'POST');
+  let bytesReceived = 0;
+
+  req.on('data', function(chunk) {
+    bytesReceived += chunk.length;
+  });
+
+  req.on('end', common.mustCall(function() {
+    assert.strictEqual(N, bytesReceived);
+    console.log('request complete from server');
+    res.writeHead(200, { 'Content-Type': 'text/plain' });
+    res.write('hello\n');
+    res.end();
+  }));
+}));
+server.listen(0);
+
+server.on('listening', common.mustCall(function() {
+  const req = http.request({
+    port: this.address().port,
+    method: 'POST',
+    path: '/'
+  }, common.mustCall(function(res) {
+    res.setEncoding('utf8');
+    res.on('data', function(chunk) {
+      console.log(chunk);
+    });
+    res.on('end', common.mustCall(function() {
+      server.close();
+    }));
+  }));
+
+  req.write(Buffer.allocUnsafe(N));
+  req.end();
+}));
diff --git a/test/js/node/test/parallel/test-http-client-upload.js b/test/js/node/test/parallel/test-http-client-upload.js
new file mode 100644
index 0000000000..830c37da8e
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-client-upload.js
@@ -0,0 +1,67 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const http = require('http');
+
+const server = http.createServer(common.mustCall(function(req, res) {
+  assert.strictEqual(req.method, 'POST');
+  req.setEncoding('utf8');
+
+  let sent_body = '';
+
+  req.on('data', function(chunk) {
+    console.log(`server got: ${JSON.stringify(chunk)}`);
+    sent_body += chunk;
+  });
+
+  req.on('end', common.mustCall(function() {
+    assert.strictEqual(sent_body, '1\n2\n3\n');
+    console.log('request complete from server');
+    res.writeHead(200, { 'Content-Type': 'text/plain' });
+    res.write('hello\n');
+    res.end();
+  }));
+}));
+server.listen(0);
+
+server.on('listening', common.mustCall(function() {
+  const req = http.request({
+    port: this.address().port,
+    method: 'POST',
+    path: '/'
+  }, common.mustCall(function(res) {
+    res.setEncoding('utf8');
+    res.on('data', function(chunk) {
+      console.log(chunk);
+    });
+    res.on('end', common.mustCall(function() {
+      server.close();
+    }));
+  }));
+
+  req.write('1\n');
+  req.write('2\n');
+  req.write('3\n');
+  req.end();
+}));
diff --git a/test/js/node/test/parallel/test-http-client-with-create-connection.js b/test/js/node/test/parallel/test-http-client-with-create-connection.js
new file mode 100644
index 0000000000..5c99de6c49
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-client-with-create-connection.js
@@ -0,0 +1,55 @@
+'use strict';
+const common = require('../common');
+const http = require('http');
+const net = require('net');
+const tmpdir = require('../common/tmpdir');
+
+tmpdir.refresh();
+
+let count = 0;
+let server1;
+let server2;
+
+function request(options) {
+  count++;
+  http.get({
+    ...options,
+    createConnection: (...args) => {
+      return net.connect(...args);
+    }
+  }, (res) => {
+    res.resume();
+    res.on('end', () => {
+      if (--count === 0) {
+        server1.close();
+        server2.close();
+      }
+    });
+  });
+}
+
+server1 = http.createServer((req, res) => {
+  res.end('ok');
+}).listen(common.PIPE, () => {
+  server2 = http.createServer((req, res) => {
+    res.end('ok');
+  }).listen(() => {
+    request({
+      path: '/',
+      socketPath: common.PIPE,
+    });
+
+    request({
+      socketPath: common.PIPE,
+    });
+
+    request({
+      path: '/',
+      port: server2.address().port,
+    });
+
+    request({
+      port: server2.address().port,
+    });
+  });
+});
diff --git a/test/js/node/test/parallel/test-http-contentLength0.js b/test/js/node/test/parallel/test-http-contentLength0.js
new file mode 100644
index 0000000000..975e2abe88
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-contentLength0.js
@@ -0,0 +1,44 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const http = require('http');
+
+// Simple test of Node's HTTP Client choking on a response
+// with a 'Content-Length: 0 ' response header.
+// I.E. a space character after the 'Content-Length' throws an `error` event.
+
+
+const s = http.createServer(function(req, res) {
+  res.writeHead(200, { 'Content-Length': '0 ' });
+  res.end();
+});
+s.listen(0, function() {
+
+  const request = http.request({ port: this.address().port }, (response) => {
+    console.log(`STATUS: ${response.statusCode}`);
+    s.close();
+    response.resume();
+  });
+
+  request.end();
+});
diff --git a/test/js/node/test/parallel/test-http-date-header.js b/test/js/node/test/parallel/test-http-date-header.js
new file mode 100644
index 0000000000..169af2bf2a
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-date-header.js
@@ -0,0 +1,55 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const http = require('http');
+
+const testResBody = 'other stuff!\n';
+
+const server = http.createServer((req, res) => {
+  assert.ok(!('date' in req.headers),
+            'Request headers contained a Date.');
+  res.writeHead(200, {
+    'Content-Type': 'text/plain'
+  });
+  res.end(testResBody);
+});
+server.listen(0);
+
+
+server.addListener('listening', () => {
+  const options = {
+    port: server.address().port,
+    path: '/',
+    method: 'GET'
+  };
+  const req = http.request(options, (res) => {
+    assert.ok('date' in res.headers,
+              'Response headers didn\'t contain a Date.');
+    res.addListener('end', () => {
+      server.close();
+    });
+    res.resume();
+  });
+  req.end();
+});
diff --git a/test/js/node/test/parallel/test-http-decoded-auth.js b/test/js/node/test/parallel/test-http-decoded-auth.js
new file mode 100644
index 0000000000..7b09f47cc7
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-decoded-auth.js
@@ -0,0 +1,48 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const http = require('http');
+
+const testCases = [
+  {
+    username: 'test@test"',
+    password: '123456^',
+    expected: 'dGVzdEB0ZXN0IjoxMjM0NTZe'
+  },
+  {
+    username: 'test%40test',
+    password: '123456',
+    expected: 'dGVzdEB0ZXN0OjEyMzQ1Ng=='
+  },
+  {
+    username: 'not%3Agood',
+    password: 'god',
+    expected: 'bm90Omdvb2Q6Z29k'
+  },
+  {
+    username: 'not%22good',
+    password: 'g%5Eod',
+    expected: 'bm90Imdvb2Q6Z15vZA=='
+  },
+  {
+    username: 'test1234::::',
+    password: 'mypass',
+    expected: 'dGVzdDEyMzQ6Ojo6Om15cGFzcw=='
+  },
+];
+
+for (const testCase of testCases) {
+  const server = http.createServer(function(request, response) {
+    // The correct authorization header is be passed
+    assert.strictEqual(request.headers.authorization, `Basic ${testCase.expected}`);
+    response.writeHead(200, {});
+    response.end('ok');
+    server.close();
+  });
+
+  server.listen(0, function() {
+    // make the request
+    const url = new URL(`http://${testCase.username}:${testCase.password}@localhost:${this.address().port}`);
+    http.request(url).end();
+  });
+}
diff --git a/test/js/node/test/parallel/test-http-default-encoding.js b/test/js/node/test/parallel/test-http-default-encoding.js
new file mode 100644
index 0000000000..0c0de0808a
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-default-encoding.js
@@ -0,0 +1,58 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const http = require('http');
+
+const expected = 'This is a unicode text: سلام';
+let result = '';
+
+const server = http.Server((req, res) => {
+  req.setEncoding('utf8');
+  req.on('data', (chunk) => {
+    result += chunk;
+  }).on('end', () => {
+    res.writeHead(200);
+    res.end('hello world\n');
+    server.close();
+  });
+
+});
+
+server.listen(0, function() {
+  http.request({
+    port: this.address().port,
+    path: '/',
+    method: 'POST'
+  }, (res) => {
+    console.log(res.statusCode);
+    res.resume();
+  }).on('error', (e) => {
+    console.log(e.message);
+    process.exit(1);
+  }).end(expected);
+});
+
+process.on('exit', () => {
+  assert.strictEqual(result, expected);
+});
diff --git a/test/js/node/test/parallel/test-http-end-throw-socket-handling.js b/test/js/node/test/parallel/test-http-end-throw-socket-handling.js
new file mode 100644
index 0000000000..956096270e
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-end-throw-socket-handling.js
@@ -0,0 +1,53 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const Countdown = require('../common/countdown');
+
+// Make sure that throwing in 'end' handler doesn't lock
+// up the socket forever.
+//
+// This is NOT a good way to handle errors in general, but all
+// the same, we should not be so brittle and easily broken.
+
+const http = require('http');
+const countdown = new Countdown(10, () => server.close());
+
+const server = http.createServer((req, res) => {
+  countdown.dec();
+  res.end('ok');
+});
+
+server.listen(0, common.mustCall(() => {
+  for (let i = 0; i < 10; i++) {
+    const options = { port: server.address().port };
+    const req = http.request(options, (res) => {
+      res.resume();
+      res.on('end', common.mustCall(() => {
+        throw new Error('gleep glorp');
+      }));
+    });
+    req.end();
+  }
+}));
+
+process.on('uncaughtException', common.mustCall(10));
diff --git a/test/js/node/test/parallel/test-http-eof-on-connect.js b/test/js/node/test/parallel/test-http-eof-on-connect.js
new file mode 100644
index 0000000000..5e885bb91a
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-eof-on-connect.js
@@ -0,0 +1,41 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+
+const common = require('../common');
+const net = require('net');
+const http = require('http');
+
+// This is a regression test for https://github.com/joyent/node/issues/44
+// It is separate from test-http-malformed-request.js because it is only
+// reproducible on the first packet on the first connection to a server.
+
+const server = http.createServer(common.mustNotCall());
+server.listen(0);
+
+server.on('listening', function() {
+  net.createConnection(this.address().port).on('connect', function() {
+    this.destroy();
+  }).on('close', function() {
+    server.close();
+  });
+});
diff --git a/test/js/node/test/parallel/test-http-extra-response.js b/test/js/node/test/parallel/test-http-extra-response.js
new file mode 100644
index 0000000000..6d1a770487
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-extra-response.js
@@ -0,0 +1,80 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const http = require('http');
+const net = require('net');
+
+// If an HTTP server is broken and sends data after the end of the response,
+// node should ignore it and drop the connection.
+// Demos this bug: https://github.com/joyent/node/issues/680
+
+const body = 'hello world\r\n';
+const fullResponse =
+    'HTTP/1.1 500 Internal Server Error\r\n' +
+    `Content-Length: ${body.length}\r\n` +
+    'Content-Type: text/plain\r\n' +
+    'Date: Fri + 18 Feb 2011 06:22:45 GMT\r\n' +
+    'Host: 10.20.149.2\r\n' +
+    'Access-Control-Allow-Credentials: true\r\n' +
+    'Server: badly broken/0.1 (OS NAME)\r\n' +
+    '\r\n' +
+    body;
+
+const server = net.createServer(function(socket) {
+  let postBody = '';
+
+  socket.setEncoding('utf8');
+
+  socket.on('data', function(chunk) {
+    postBody += chunk;
+
+    if (postBody.includes('\r\n')) {
+      socket.write(fullResponse);
+      socket.end(fullResponse);
+    }
+  });
+
+  socket.on('error', function(err) {
+    assert.strictEqual(err.code, 'ECONNRESET');
+  });
+});
+
+
+server.listen(0, common.mustCall(function() {
+  http.get({ port: this.address().port }, common.mustCall(function(res) {
+    let buffer = '';
+    console.log(`Got res code: ${res.statusCode}`);
+
+    res.setEncoding('utf8');
+    res.on('data', function(chunk) {
+      buffer += chunk;
+    });
+
+    res.on('end', common.mustCall(function() {
+      console.log(`Response ended, read ${buffer.length} bytes`);
+      assert.strictEqual(body, buffer);
+      server.close();
+    }));
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http-full-response.js b/test/js/node/test/parallel/test-http-full-response.js
new file mode 100644
index 0000000000..d08e091ebd
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-full-response.js
@@ -0,0 +1,81 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+// This test requires the program 'ab'
+const http = require('http');
+const exec = require('child_process').exec;
+
+const bodyLength = 12345;
+
+const body = 'c'.repeat(bodyLength);
+
+const server = http.createServer(function(req, res) {
+  res.writeHead(200, {
+    'Content-Length': bodyLength,
+    'Content-Type': 'text/plain'
+  });
+  res.end(body);
+});
+
+function runAb(opts, callback) {
+  const command = `ab ${opts} http://127.0.0.1:${server.address().port}/`;
+  exec(command, function(err, stdout, stderr) {
+    if (err) {
+      if (/ab|apr/i.test(stderr)) {
+        common.printSkipMessage(`problem spawning \`ab\`.\n${stderr}`);
+        process.reallyExit(0);
+      }
+      throw err;
+    }
+
+    let m = /Document Length:\s*(\d+) bytes/i.exec(stdout);
+    const documentLength = parseInt(m[1]);
+
+    m = /Complete requests:\s*(\d+)/i.exec(stdout);
+    const completeRequests = parseInt(m[1]);
+
+    m = /HTML transferred:\s*(\d+) bytes/i.exec(stdout);
+    const htmlTransferred = parseInt(m[1]);
+
+    assert.strictEqual(bodyLength, documentLength);
+    assert.strictEqual(completeRequests * documentLength, htmlTransferred);
+
+    if (callback) callback();
+  });
+}
+
+server.listen(0, common.mustCall(function() {
+  runAb('-c 1 -n 10', common.mustCall(function() {
+    console.log('-c 1 -n 10 okay');
+
+    runAb('-c 1 -n 100', common.mustCall(function() {
+      console.log('-c 1 -n 100 okay');
+
+      runAb('-c 1 -n 1000', common.mustCall(function() {
+        console.log('-c 1 -n 1000 okay');
+        server.close();
+      }));
+    }));
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http-get-pipeline-problem.js b/test/js/node/test/parallel/test-http-get-pipeline-problem.js
new file mode 100644
index 0000000000..b8b11e7e77
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-get-pipeline-problem.js
@@ -0,0 +1,100 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+// In previous versions of Node.js (e.g., 0.6.0), this sort of thing would halt
+// after http.globalAgent.maxSockets number of files.
+// See https://groups.google.com/forum/#!topic/nodejs-dev/V5fB69hFa9o
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+const http = require('http');
+const fs = require('fs');
+const Countdown = require('../common/countdown');
+
+http.globalAgent.maxSockets = 1;
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+const image = fixtures.readSync('/person.jpg');
+
+console.log(`image.length = ${image.length}`);
+
+const total = 10;
+const responseCountdown = new Countdown(total, common.mustCall(() => {
+  checkFiles();
+  server.close();
+}));
+
+const server = http.Server(function(req, res) {
+  setTimeout(function() {
+    res.writeHead(200, {
+      'content-type': 'image/jpeg',
+      'connection': 'close',
+      'content-length': image.length
+    });
+    res.end(image);
+  }, 1);
+});
+
+
+server.listen(0, function() {
+  for (let i = 0; i < total; i++) {
+    (function() {
+      const x = i;
+
+      const opts = {
+        port: server.address().port,
+        headers: { connection: 'close' }
+      };
+
+      http.get(opts, function(res) {
+        console.error(`recv ${x}`);
+        const s = fs.createWriteStream(`${tmpdir.path}/${x}.jpg`);
+        res.pipe(s);
+
+        s.on('finish', function() {
+          console.error(`done ${x}`);
+          responseCountdown.dec();
+        });
+      }).on('error', function(e) {
+        console.error('error! ', e.message);
+        throw e;
+      });
+    })();
+  }
+});
+
+function checkFiles() {
+  // Should see 1.jpg, 2.jpg, ..., 100.jpg in tmpDir
+  const files = fs.readdirSync(tmpdir.path);
+  assert(total <= files.length);
+
+  for (let i = 0; i < total; i++) {
+    const fn = `${i}.jpg`;
+    assert.ok(files.includes(fn), `couldn't find '${fn}'`);
+    const stat = fs.statSync(`${tmpdir.path}/${fn}`);
+    assert.strictEqual(
+      image.length, stat.size,
+      `size doesn't match on '${fn}'. Got ${stat.size} bytes`);
+  }
+}
diff --git a/test/js/node/test/parallel/test-http-head-request.js b/test/js/node/test/parallel/test-http-head-request.js
new file mode 100644
index 0000000000..26d490d357
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-head-request.js
@@ -0,0 +1,57 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const http = require('http');
+
+const body = 'hello world\n';
+
+function test(headers) {
+  const server = http.createServer(function(req, res) {
+    console.error('req: %s headers: %j', req.method, headers);
+    res.writeHead(200, headers);
+    res.end();
+    server.close();
+  });
+
+  server.listen(0, common.mustCall(function() {
+    const request = http.request({
+      port: this.address().port,
+      method: 'HEAD',
+      path: '/'
+    }, common.mustCall(function(response) {
+      console.error('response start');
+      response.on('end', common.mustCall(function() {
+        console.error('response end');
+      }));
+      response.resume();
+    }));
+    request.end();
+  }));
+}
+
+test({
+  'Transfer-Encoding': 'chunked'
+});
+test({
+  'Content-Length': body.length
+});
diff --git a/test/js/node/test/parallel/test-http-head-response-has-no-body-end-implicit-headers.js b/test/js/node/test/parallel/test-http-head-response-has-no-body-end-implicit-headers.js
new file mode 100644
index 0000000000..5ebd9f8a90
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-head-response-has-no-body-end-implicit-headers.js
@@ -0,0 +1,27 @@
+'use strict';
+const common = require('../common');
+const http = require('http');
+
+// This test is to make sure that when the HTTP server
+// responds to a HEAD request with data to res.end,
+// it does not send any body but the response is sent
+// anyway.
+
+const server = http.createServer(function(req, res) {
+  res.end('FAIL'); // broken: sends FAIL from hot path.
+});
+server.listen(0);
+
+server.on('listening', common.mustCall(function() {
+  const req = http.request({
+    port: this.address().port,
+    method: 'HEAD',
+    path: '/'
+  }, common.mustCall(function(res) {
+    res.on('end', common.mustCall(function() {
+      server.close();
+    }));
+    res.resume();
+  }));
+  req.end();
+}));
diff --git a/test/js/node/test/parallel/test-http-head-response-has-no-body-end.js b/test/js/node/test/parallel/test-http-head-response-has-no-body-end.js
new file mode 100644
index 0000000000..824a1bafe3
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-head-response-has-no-body-end.js
@@ -0,0 +1,48 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const http = require('http');
+
+// This test is to make sure that when the HTTP server
+// responds to a HEAD request with data to res.end,
+// it does not send any body.
+
+const server = http.createServer(function(req, res) {
+  res.writeHead(200);
+  res.end('FAIL'); // broken: sends FAIL from hot path.
+});
+server.listen(0);
+
+server.on('listening', common.mustCall(function() {
+  const req = http.request({
+    port: this.address().port,
+    method: 'HEAD',
+    path: '/'
+  }, common.mustCall(function(res) {
+    res.on('end', common.mustCall(function() {
+      server.close();
+    }));
+    res.resume();
+  }));
+  req.end();
+}));
diff --git a/test/js/node/test/parallel/test-http-head-response-has-no-body.js b/test/js/node/test/parallel/test-http-head-response-has-no-body.js
new file mode 100644
index 0000000000..bd96d7161b
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-head-response-has-no-body.js
@@ -0,0 +1,48 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const http = require('http');
+
+// This test is to make sure that when the HTTP server
+// responds to a HEAD request, it does not send any body.
+// In this case it was sending '0\r\n\r\n'
+
+const server = http.createServer(function(req, res) {
+  res.writeHead(200); // broken: defaults to TE chunked
+  res.end();
+});
+server.listen(0);
+
+server.on('listening', common.mustCall(function() {
+  const req = http.request({
+    port: this.address().port,
+    method: 'HEAD',
+    path: '/'
+  }, common.mustCall(function(res) {
+    res.on('end', common.mustCall(function() {
+      server.close();
+    }));
+    res.resume();
+  }));
+  req.end();
+}));
diff --git a/test/js/node/test/parallel/test-http-header-owstext.js b/test/js/node/test/parallel/test-http-header-owstext.js
new file mode 100644
index 0000000000..bc094137a2
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-header-owstext.js
@@ -0,0 +1,49 @@
+'use strict';
+const common = require('../common');
+
+// This test ensures that the http-parser strips leading and trailing OWS from
+// header values. It sends the header values in chunks to force the parser to
+// build the string up through multiple calls to on_header_value().
+
+const assert = require('assert');
+const http = require('http');
+const net = require('net');
+
+function check(hdr, snd, rcv) {
+  const server = http.createServer(common.mustCall((req, res) => {
+    assert.strictEqual(req.headers[hdr], rcv);
+    req.pipe(res);
+  }));
+
+  server.listen(0, common.mustCall(function() {
+    const client = net.connect(this.address().port, start);
+    function start() {
+      client.write('GET / HTTP/1.1\r\n' + hdr + ':', drain);
+    }
+
+    function drain() {
+      if (snd.length === 0) {
+        return client.write('\r\nConnection: close\r\n\r\n');
+      }
+      client.write(snd.shift(), drain);
+    }
+
+    const bufs = [];
+    client.on('data', function(chunk) {
+      bufs.push(chunk);
+    });
+    client.on('end', common.mustCall(function() {
+      const head = Buffer.concat(bufs)
+        .toString('latin1')
+        .split('\r\n')[0];
+      assert.strictEqual(head, 'HTTP/1.1 200 OK');
+      server.close();
+    }));
+  }));
+}
+
+check('host', [' \t foo.com\t'], 'foo.com');
+check('host', [' \t foo\tcom\t'], 'foo\tcom');
+check('host', [' \t', ' ', ' foo.com\t', '\t '], 'foo.com');
+check('host', [' \t', ' \t'.repeat(100), '\t '], '');
+check('host', [' \t', ' - - - -   ', '\t '], '- - - -');
diff --git a/test/js/node/test/parallel/test-http-highwatermark.js b/test/js/node/test/parallel/test-http-highwatermark.js
new file mode 100644
index 0000000000..79d9c46a55
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-highwatermark.js
@@ -0,0 +1,52 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const net = require('net');
+const http = require('http');
+
+// These test cases to check socketOnDrain where needPause becomes false.
+// When send large response enough to exceed highWaterMark, it expect the socket
+// to be paused and res.write would be failed.
+// And it should be resumed when outgoingData falls below highWaterMark.
+
+let requestReceived = 0;
+
+const server = http.createServer(function(req, res) {
+  const id = ++requestReceived;
+  const enoughToDrain = req.connection.writableHighWaterMark;
+  const body = 'x'.repeat(enoughToDrain * 100);
+
+  if (id === 1) {
+    // Case of needParse = false
+    req.connection.once('pause', common.mustCall(() => {
+      assert(req.connection._paused, '_paused must be true because it exceeds' +
+                                     'highWaterMark by second request');
+    }));
+  } else {
+    // Case of needParse = true
+    const resume = req.connection.parser.resume.bind(req.connection.parser);
+    req.connection.parser.resume = common.mustCall((...args) => {
+      const paused = req.connection._paused;
+      assert(!paused, '_paused must be false because it become false by ' +
+                      'socketOnDrain when outgoingData falls below ' +
+                      'highWaterMark');
+      return resume(...args);
+    });
+  }
+  assert(!res.write(body), 'res.write must return false because it will ' +
+                           'exceed highWaterMark on this call');
+  res.end();
+}).on('listening', () => {
+  const c = net.createConnection(server.address().port, () => {
+    c.write('GET / HTTP/1.1\r\n\r\n');
+    c.write('GET / HTTP/1.1\r\n\r\n',
+            () => setImmediate(() => c.resume()));
+    c.end();
+  });
+
+  c.on('end', () => {
+    server.close();
+  });
+});
+
+server.listen(0);
diff --git a/test/js/node/test/parallel/test-http-host-headers.js b/test/js/node/test/parallel/test-http-host-headers.js
new file mode 100644
index 0000000000..97d200ade1
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-host-headers.js
@@ -0,0 +1,96 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const http = require('http');
+const assert = require('assert');
+const httpServer = http.createServer(reqHandler);
+
+function reqHandler(req, res) {
+  if (req.url === '/setHostFalse5') {
+    assert.strictEqual(req.headers.host, undefined);
+  } else {
+    assert.strictEqual(
+      req.headers.host, `localhost:${this.address().port}`,
+      `Wrong host header for req[${req.url}]: ${req.headers.host}`);
+  }
+  res.writeHead(200, {});
+  res.end('ok');
+}
+
+testHttp();
+
+function testHttp() {
+
+  let counter = 0;
+
+  function cb(res) {
+    counter--;
+    if (counter === 0) {
+      httpServer.close();
+    }
+    res.resume();
+  }
+
+  httpServer.listen(0, (er) => {
+    assert.ifError(er);
+    http.get({
+      method: 'GET',
+      path: `/${counter++}`,
+      host: 'localhost',
+      port: httpServer.address().port,
+      rejectUnauthorized: false
+    }, cb).on('error', common.mustNotCall());
+
+    http.request({
+      method: 'GET',
+      path: `/${counter++}`,
+      host: 'localhost',
+      port: httpServer.address().port,
+      rejectUnauthorized: false
+    }, cb).on('error', common.mustNotCall()).end();
+
+    http.request({
+      method: 'POST',
+      path: `/${counter++}`,
+      host: 'localhost',
+      port: httpServer.address().port,
+      rejectUnauthorized: false
+    }, cb).on('error', common.mustNotCall()).end();
+
+    http.request({
+      method: 'PUT',
+      path: `/${counter++}`,
+      host: 'localhost',
+      port: httpServer.address().port,
+      rejectUnauthorized: false
+    }, cb).on('error', common.mustNotCall()).end();
+
+    http.request({
+      method: 'DELETE',
+      path: `/${counter++}`,
+      host: 'localhost',
+      port: httpServer.address().port,
+      rejectUnauthorized: false
+    }, cb).on('error', common.mustNotCall()).end();
+  });
+}
diff --git a/test/js/node/test/parallel/test-http-keep-alive-timeout-custom.js b/test/js/node/test/parallel/test-http-keep-alive-timeout-custom.js
new file mode 100644
index 0000000000..a74aa5a212
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-keep-alive-timeout-custom.js
@@ -0,0 +1,31 @@
+'use strict';
+
+const common = require('../common');
+const http = require('http');
+const assert = require('assert');
+
+const server = http.createServer(common.mustCall((req, res) => {
+  const body = 'hello world\n';
+
+  res.writeHead(200, {
+    'Content-Length': body.length,
+    'Keep-Alive': 'timeout=50'
+  });
+  res.write(body);
+  res.end();
+}));
+server.keepAliveTimeout = 12010;
+
+const agent = new http.Agent({ maxSockets: 1, keepAlive: true });
+
+server.listen(0, common.mustCall(function() {
+  http.get({
+    path: '/', port: this.address().port, agent: agent
+  }, common.mustCall((response) => {
+    response.resume();
+    assert.strictEqual(
+      response.headers['keep-alive'], 'timeout=50');
+    server.close();
+    agent.destroy();
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http-localaddress-bind-error.js b/test/js/node/test/parallel/test-http-localaddress-bind-error.js
new file mode 100644
index 0000000000..d4bd72bae1
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-localaddress-bind-error.js
@@ -0,0 +1,52 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const http = require('http');
+
+const invalidLocalAddress = '1.2.3.4';
+
+const server = http.createServer(function(req, res) {
+  console.log(`Connect from: ${req.connection.remoteAddress}`);
+
+  req.on('end', function() {
+    res.writeHead(200, { 'Content-Type': 'text/plain' });
+    res.end(`You are from: ${req.connection.remoteAddress}`);
+  });
+  req.resume();
+});
+
+server.listen(0, '127.0.0.1', common.mustCall(function() {
+  http.request({
+    host: 'localhost',
+    port: this.address().port,
+    path: '/',
+    method: 'GET',
+    localAddress: invalidLocalAddress
+  }, function(res) {
+    assert.fail('unexpectedly got response from server');
+  }).on('error', common.mustCall(function(e) {
+    console.log(`client got error: ${e.message}`);
+    server.close();
+  })).end();
+}));
diff --git a/test/js/node/test/parallel/test-http-malformed-request.js b/test/js/node/test/parallel/test-http-malformed-request.js
new file mode 100644
index 0000000000..1f2fecc117
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-malformed-request.js
@@ -0,0 +1,47 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const net = require('net');
+const http = require('http');
+const url = require('url');
+
+// Make sure no exceptions are thrown when receiving malformed HTTP
+// requests.
+const server = http.createServer(common.mustCall((req, res) => {
+  console.log(`req: ${JSON.stringify(url.parse(req.url))}`);
+
+  res.writeHead(200, { 'Content-Type': 'text/plain' });
+  res.write('Hello World');
+  res.end();
+
+  server.close();
+}));
+server.listen(0);
+
+server.on('listening', function() {
+  const c = net.createConnection(this.address().port);
+  c.on('connect', function() {
+    c.write('GET /hello?foo=%99bar HTTP/1.1\r\nHost: example.com\r\n\r\n');
+    c.end();
+  });
+});
diff --git a/test/js/node/test/parallel/test-http-missing-header-separator-cr.js b/test/js/node/test/parallel/test-http-missing-header-separator-cr.js
new file mode 100644
index 0000000000..1129ec4ed9
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-missing-header-separator-cr.js
@@ -0,0 +1,83 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+
+const http = require('http');
+const net = require('net');
+
+function serverHandler(server, msg) {
+  const client = net.connect(server.address().port, 'localhost');
+
+  let response = '';
+
+  client.on('data', common.mustCall((chunk) => {
+    response += chunk;
+  }));
+
+  client.setEncoding('utf8');
+  client.on('error', common.mustNotCall());
+  client.on('end', common.mustCall(() => {
+    assert.strictEqual(
+      response,
+      'HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n'
+    );
+    server.close();
+  }));
+  client.write(msg);
+  client.resume();
+}
+
+{
+  const msg = [
+    'GET / HTTP/1.1',
+    'Host: localhost',
+    'Dummy: x\nContent-Length: 23',
+    '',
+    'GET / HTTP/1.1',
+    'Dummy: GET /admin HTTP/1.1',
+    'Host: localhost',
+    '',
+    '',
+  ].join('\r\n');
+
+  const server = http.createServer(common.mustNotCall());
+
+  server.listen(0, common.mustSucceed(serverHandler.bind(null, server, msg)));
+}
+
+{
+  const msg = [
+    'POST / HTTP/1.1',
+    'Host: localhost',
+    'x:x\nTransfer-Encoding: chunked',
+    '',
+    '1',
+    'A',
+    '0',
+    '',
+    '',
+  ].join('\r\n');
+
+  const server = http.createServer(common.mustNotCall());
+
+  server.listen(0, common.mustSucceed(serverHandler.bind(null, server, msg)));
+}
+
+{
+  const msg = [
+    'POST / HTTP/1.1',
+    'Host: localhost',
+    'x:\nTransfer-Encoding: chunked',
+    '',
+    '1',
+    'A',
+    '0',
+    '',
+    '',
+  ].join('\r\n');
+
+  const server = http.createServer(common.mustNotCall());
+
+  server.listen(0, common.mustSucceed(serverHandler.bind(null, server, msg)));
+}
diff --git a/test/js/node/test/parallel/test-http-no-content-length.js b/test/js/node/test/parallel/test-http-no-content-length.js
new file mode 100644
index 0000000000..a3a51c015e
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-no-content-length.js
@@ -0,0 +1,44 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const net = require('net');
+const http = require('http');
+
+const server = net.createServer(function(socket) {
+  // Neither Content-Length nor Connection
+  socket.end('HTTP/1.1 200 ok\r\n\r\nHello');
+}).listen(0, common.mustCall(function() {
+  http.get({ port: this.address().port }, common.mustCall(function(res) {
+    let body = '';
+
+    res.setEncoding('utf8');
+    res.on('data', function(chunk) {
+      body += chunk;
+    });
+    res.on('end', common.mustCall(function() {
+      assert.strictEqual(body, 'Hello');
+      server.close();
+    }));
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http-outgoing-destroy.js b/test/js/node/test/parallel/test-http-outgoing-destroy.js
new file mode 100644
index 0000000000..47d5e948ab
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-outgoing-destroy.js
@@ -0,0 +1,17 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+const http = require('http');
+const OutgoingMessage = http.OutgoingMessage;
+
+{
+  const msg = new OutgoingMessage();
+  assert.strictEqual(msg.destroyed, false);
+  msg.destroy();
+  assert.strictEqual(msg.destroyed, true);
+  msg.write('asd', common.mustCall((err) => {
+    assert.strictEqual(err.code, 'ERR_STREAM_DESTROYED');
+  }));
+  msg.on('error', common.mustNotCall());
+}
diff --git a/test/js/node/test/parallel/test-http-outgoing-end-types.js b/test/js/node/test/parallel/test-http-outgoing-end-types.js
new file mode 100644
index 0000000000..20b443bff2
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-outgoing-end-types.js
@@ -0,0 +1,18 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const http = require('http');
+
+const httpServer = http.createServer(common.mustCall(function(req, res) {
+  httpServer.close();
+  assert.throws(() => {
+    res.end(['Throws.']);
+  }, {
+    code: 'ERR_INVALID_ARG_TYPE'
+  });
+  res.end();
+}));
+
+httpServer.listen(0, common.mustCall(function() {
+  http.get({ port: this.address().port });
+}));
diff --git a/test/js/node/test/parallel/test-http-outgoing-finish.js b/test/js/node/test/parallel/test-http-outgoing-finish.js
new file mode 100644
index 0000000000..0f71cccdf8
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-outgoing-finish.js
@@ -0,0 +1,76 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+const http = require('http');
+
+http.createServer(function(req, res) {
+  req.resume();
+  req.on('end', function() {
+    write(res);
+  });
+  this.close();
+}).listen(0, function() {
+  const req = http.request({
+    port: this.address().port,
+    method: 'PUT'
+  });
+  write(req);
+  req.on('response', function(res) {
+    res.resume();
+  });
+});
+
+const buf = Buffer.alloc(1024 * 16, 'x');
+function write(out) {
+  const name = out.constructor.name;
+  let finishEvent = false;
+  let endCb = false;
+
+  // First, write until it gets some backpressure
+  while (out.write(buf, common.mustSucceed()));
+
+  // Now end, and make sure that we don't get the 'finish' event
+  // before the tick where the cb gets called.  We give it until
+  // nextTick because this is added as a listener before the endcb
+  // is registered.  The order is not what we're testing here, just
+  // that 'finish' isn't emitted until the stream is fully flushed.
+  out.on('finish', function() {
+    finishEvent = true;
+    console.error(`${name} finish event`);
+    process.nextTick(function() {
+      assert(endCb, `${name} got finish event before endcb!`);
+      console.log(`ok - ${name} finishEvent`);
+    });
+  });
+
+  out.end(buf, common.mustCall(function() {
+    endCb = true;
+    console.error(`${name} endCb`);
+    process.nextTick(function() {
+      assert(finishEvent, `${name} got endCb event before finishEvent!`);
+      console.log(`ok - ${name} endCb`);
+    });
+  }));
+}
diff --git a/test/js/node/test/parallel/test-http-outgoing-finished.js b/test/js/node/test/parallel/test-http-outgoing-finished.js
new file mode 100644
index 0000000000..7da1b7429a
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-outgoing-finished.js
@@ -0,0 +1,32 @@
+'use strict';
+const common = require('../common');
+const { finished } = require('stream');
+
+const http = require('http');
+const assert = require('assert');
+
+const server = http.createServer(function(req, res) {
+  let closed = false;
+  res
+    .on('close', common.mustCall(() => {
+      closed = true;
+      finished(res, common.mustCall(() => {
+        server.close();
+      }));
+    }))
+    .end();
+  finished(res, common.mustCall(() => {
+    assert.strictEqual(closed, true);
+  }));
+
+}).listen(0, function() {
+  http
+    .request({
+      port: this.address().port,
+      method: 'GET'
+    })
+    .on('response', function(res) {
+      res.resume();
+    })
+    .end();
+});
diff --git a/test/js/node/test/parallel/test-http-outgoing-writableFinished.js b/test/js/node/test/parallel/test-http-outgoing-writableFinished.js
new file mode 100644
index 0000000000..6f84d91e71
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-outgoing-writableFinished.js
@@ -0,0 +1,32 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const http = require('http');
+
+const server = http.createServer(common.mustCall(function(req, res) {
+  assert.strictEqual(res.writableFinished, false);
+  res
+    .on('finish', common.mustCall(() => {
+      assert.strictEqual(res.writableFinished, true);
+      server.close();
+    }))
+    .end();
+}));
+
+server.listen(0);
+
+server.on('listening', common.mustCall(function() {
+  const clientRequest = http.request({
+    port: server.address().port,
+    method: 'GET',
+    path: '/'
+  });
+
+  assert.strictEqual(clientRequest.writableFinished, false);
+  clientRequest
+    .on('finish', common.mustCall(() => {
+      assert.strictEqual(clientRequest.writableFinished, true);
+    }))
+    .end();
+  assert.strictEqual(clientRequest.writableFinished, false);
+}));
diff --git a/test/js/node/test/parallel/test-http-outgoing-write-types.js b/test/js/node/test/parallel/test-http-outgoing-write-types.js
new file mode 100644
index 0000000000..6257b87eea
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-outgoing-write-types.js
@@ -0,0 +1,24 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const http = require('http');
+
+const httpServer = http.createServer(common.mustCall(function(req, res) {
+  httpServer.close();
+  assert.throws(() => {
+    res.write(['Throws.']);
+  }, {
+    code: 'ERR_INVALID_ARG_TYPE'
+  });
+  // should not throw
+  res.write('1a2b3c');
+  // should not throw
+  res.write(new Uint8Array(1024));
+  // should not throw
+  res.write(Buffer.from('1'.repeat(1024)));
+  res.end();
+}));
+
+httpServer.listen(0, common.mustCall(function() {
+  http.get({ port: this.address().port });
+}));
diff --git a/test/js/node/test/parallel/test-http-pause-no-dump.js b/test/js/node/test/parallel/test-http-pause-no-dump.js
new file mode 100644
index 0000000000..b794634c48
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-pause-no-dump.js
@@ -0,0 +1,33 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const http = require('http');
+
+const server = http.createServer(common.mustCall(function(req, res) {
+  req.once('data', common.mustCall(() => {
+    req.pause();
+    res.writeHead(200);
+    res.end();
+    res.on('finish', common.mustCall(() => {
+      assert(!req._dumped);
+    }));
+  }));
+}));
+server.listen(0);
+
+server.on('listening', common.mustCall(function() {
+  const req = http.request({
+    port: this.address().port,
+    method: 'POST',
+    path: '/'
+  }, common.mustCall(function(res) {
+    assert.strictEqual(res.statusCode, 200);
+    res.resume();
+    res.on('end', common.mustCall(() => {
+      server.close();
+    }));
+  }));
+
+  req.end(Buffer.allocUnsafe(1024));
+}));
diff --git a/test/js/node/test/parallel/test-http-pause-resume-one-end.js b/test/js/node/test/parallel/test-http-pause-resume-one-end.js
new file mode 100644
index 0000000000..34bf3be478
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-pause-resume-one-end.js
@@ -0,0 +1,55 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const http = require('http');
+const assert = require('assert');
+
+const server = http.Server(function(req, res) {
+  res.writeHead(200, { 'Content-Type': 'text/plain' });
+  res.end('Hello World\n');
+  server.close();
+});
+
+server.listen(0, common.mustCall(function() {
+  const opts = {
+    port: this.address().port,
+    headers: { connection: 'close' }
+  };
+
+  http.get(opts, common.mustCall(function(res) {
+    res.on('data', common.mustCall(function() {
+      res.pause();
+      setImmediate(function() {
+        res.resume();
+      });
+    }));
+
+    res.on('end', common.mustCall(() => {
+      assert.strictEqual(res.destroyed, false);
+    }));
+    assert.strictEqual(res.destroyed, false);
+    res.on('close', common.mustCall(() => {
+      assert.strictEqual(res.destroyed, true);
+    }));
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http-pause.js b/test/js/node/test/parallel/test-http-pause.js
new file mode 100644
index 0000000000..555eece2e3
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-pause.js
@@ -0,0 +1,78 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const http = require('http');
+
+const expectedServer = 'Request Body from Client';
+let resultServer = '';
+const expectedClient = 'Response Body from Server';
+let resultClient = '';
+
+const server = http.createServer((req, res) => {
+  console.error('pause server request');
+  req.pause();
+  setTimeout(() => {
+    console.error('resume server request');
+    req.resume();
+    req.setEncoding('utf8');
+    req.on('data', (chunk) => {
+      resultServer += chunk;
+    });
+    req.on('end', () => {
+      console.error(resultServer);
+      res.writeHead(200);
+      res.end(expectedClient);
+    });
+  }, 100);
+});
+
+server.listen(0, function() {
+  // Anonymous function rather than arrow function to test `this` value.
+  assert.strictEqual(this, server);
+  const req = http.request({
+    port: this.address().port,
+    path: '/',
+    method: 'POST'
+  }, (res) => {
+    console.error('pause client response');
+    res.pause();
+    setTimeout(() => {
+      console.error('resume client response');
+      res.resume();
+      res.on('data', (chunk) => {
+        resultClient += chunk;
+      });
+      res.on('end', () => {
+        console.error(resultClient);
+        server.close();
+      });
+    }, 100);
+  });
+  req.end(expectedServer);
+});
+
+process.on('exit', () => {
+  assert.strictEqual(resultServer, expectedServer);
+  assert.strictEqual(resultClient, expectedClient);
+});
diff --git a/test/js/node/test/parallel/test-http-pipe-fs.js b/test/js/node/test/parallel/test-http-pipe-fs.js
new file mode 100644
index 0000000000..b7c1a02918
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-pipe-fs.js
@@ -0,0 +1,65 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const http = require('http');
+const fs = require('fs');
+const Countdown = require('../common/countdown');
+const NUMBER_OF_STREAMS = 2;
+
+const countdown = new Countdown(NUMBER_OF_STREAMS, () => server.close());
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+const file = tmpdir.resolve('http-pipe-fs-test.txt');
+
+const server = http.createServer(common.mustCall(function(req, res) {
+  const stream = fs.createWriteStream(file);
+  req.pipe(stream);
+  stream.on('close', function() {
+    res.writeHead(200);
+    res.end();
+  });
+}, 2)).listen(0, function() {
+  http.globalAgent.maxSockets = 1;
+
+  for (let i = 0; i < NUMBER_OF_STREAMS; ++i) {
+    const req = http.request({
+      port: server.address().port,
+      method: 'POST',
+      headers: {
+        'Content-Length': 5
+      }
+    }, function(res) {
+      res.on('end', function() {
+        console.error(`res${i + 1} end`);
+        countdown.dec();
+      });
+      res.resume();
+    });
+    req.on('socket', function(s) {
+      console.error(`req${i + 1} start`);
+    });
+    req.end('12345');
+  }
+});
diff --git a/test/js/node/test/parallel/test-http-pipeline-socket-parser-typeerror.js b/test/js/node/test/parallel/test-http-pipeline-socket-parser-typeerror.js
new file mode 100644
index 0000000000..e092154b97
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-pipeline-socket-parser-typeerror.js
@@ -0,0 +1,64 @@
+'use strict';
+require('../common');
+
+// This test ensures that Node.js doesn't crash because of a TypeError by
+// checking in `connectionListener` that the socket still has the parser.
+// https://github.com/nodejs/node/issues/3508
+
+const http = require('http');
+const net = require('net');
+
+let once = false;
+let first = null;
+let second = null;
+
+const chunk = Buffer.alloc(1024, 'X');
+
+let size = 0;
+
+let more;
+let done;
+
+const server = http
+  .createServer((req, res) => {
+    if (!once) server.close();
+    once = true;
+
+    if (first === null) {
+      first = res;
+      return;
+    }
+    if (second === null) {
+      second = res;
+      res.write(chunk);
+    } else {
+      res.end(chunk);
+    }
+    size += res.outputSize;
+    if (size <= req.socket.writableHighWaterMark) {
+      more();
+      return;
+    }
+    done();
+  })
+  .on('upgrade', (req, socket) => {
+    second.end(chunk, () => {
+      socket.end();
+    });
+    first.end('hello');
+  })
+  .listen(0, () => {
+    const s = net.connect(server.address().port);
+    more = () => {
+      s.write('GET / HTTP/1.1\r\nHost: example.com\r\n\r\n');
+    };
+    done = () => {
+      s.write(
+        'GET / HTTP/1.1\r\n\r\n' +
+          'GET / HTTP/1.1\r\nConnection: upgrade\r\nUpgrade: ws\r\n\r\naaa'
+      );
+    };
+    more();
+    more();
+    s.resume();
+  });
diff --git a/test/js/node/test/parallel/test-http-proxy.js b/test/js/node/test/parallel/test-http-proxy.js
new file mode 100644
index 0000000000..af3497630b
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-proxy.js
@@ -0,0 +1,107 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const http = require('http');
+const url = require('url');
+
+const cookies = [
+  'session_token=; path=/; expires=Sun, 15-Sep-2030 13:48:52 GMT',
+  'prefers_open_id=; path=/; expires=Thu, 01-Jan-1970 00:00:00 GMT',
+];
+
+const headers = { 'content-type': 'text/plain',
+                  'set-cookie': cookies,
+                  'hello': 'world' };
+
+const backend = http.createServer(function(req, res) {
+  console.error('backend request');
+  res.writeHead(200, headers);
+  res.write('hello world\n');
+  res.end();
+});
+
+const proxy = http.createServer(function(req, res) {
+  console.error(`proxy req headers: ${JSON.stringify(req.headers)}`);
+  http.get({
+    port: backend.address().port,
+    path: url.parse(req.url).pathname
+  }, function(proxy_res) {
+
+    console.error(`proxy res headers: ${JSON.stringify(proxy_res.headers)}`);
+
+    assert.strictEqual(proxy_res.headers.hello, 'world');
+    assert.strictEqual(proxy_res.headers['content-type'], 'text/plain');
+    assert.deepStrictEqual(proxy_res.headers['set-cookie'], cookies);
+
+    res.writeHead(proxy_res.statusCode, proxy_res.headers);
+
+    proxy_res.on('data', function(chunk) {
+      res.write(chunk);
+    });
+
+    proxy_res.on('end', function() {
+      res.end();
+      console.error('proxy res');
+    });
+  });
+});
+
+let body = '';
+
+let nlistening = 0;
+function startReq() {
+  nlistening++;
+  if (nlistening < 2) return;
+
+  http.get({
+    port: proxy.address().port,
+    path: '/test'
+  }, function(res) {
+    console.error('got res');
+    assert.strictEqual(res.statusCode, 200);
+
+    assert.strictEqual(res.headers.hello, 'world');
+    assert.strictEqual(res.headers['content-type'], 'text/plain');
+    assert.deepStrictEqual(res.headers['set-cookie'], cookies);
+
+    res.setEncoding('utf8');
+    res.on('data', function(chunk) { body += chunk; });
+    res.on('end', function() {
+      proxy.close();
+      backend.close();
+      console.error('closed both');
+    });
+  });
+  console.error('client req');
+}
+
+console.error('listen proxy');
+proxy.listen(0, startReq);
+
+console.error('listen backend');
+backend.listen(0, startReq);
+
+process.on('exit', function() {
+  assert.strictEqual(body, 'hello world\n');
+});
diff --git a/test/js/node/test/parallel/test-http-request-agent.js b/test/js/node/test/parallel/test-http-request-agent.js
new file mode 100644
index 0000000000..453ac380d0
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-request-agent.js
@@ -0,0 +1,40 @@
+'use strict';
+const common = require('../common');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const fixtures = require('../common/fixtures');
+
+// This test ensures that a http request callback is called when the agent
+// option is set.
+// See https://github.com/nodejs/node-v0.x-archive/issues/1531
+
+const https = require('https');
+
+const options = {
+  key: fixtures.readKey('agent1-key.pem'),
+  cert: fixtures.readKey('agent1-cert.pem')
+};
+
+const server = https.createServer(options, function(req, res) {
+  res.writeHead(200);
+  res.end('hello world\n');
+});
+
+server.listen(0, common.mustCall(function() {
+  console.error('listening');
+  https.get({
+    agent: false,
+    path: '/',
+    port: this.address().port,
+    rejectUnauthorized: false
+  }, common.mustCall(function(res) {
+    console.error(res.statusCode, res.headers);
+    res.resume();
+    server.close();
+  })).on('error', function(e) {
+    console.error(e);
+    process.exit(1);
+  });
+}));
diff --git a/test/js/node/test/parallel/test-http-request-arguments.js b/test/js/node/test/parallel/test-http-request-arguments.js
new file mode 100644
index 0000000000..5cdd514fd5
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-request-arguments.js
@@ -0,0 +1,28 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const http = require('http');
+
+// Test providing both a url and options, with the options partially
+// replacing address and port portions of the URL provided.
+{
+  const server = http.createServer(
+    common.mustCall((req, res) => {
+      assert.strictEqual(req.url, '/testpath');
+      res.end();
+      server.close();
+    })
+  );
+  server.listen(
+    0,
+    common.mustCall(() => {
+      http.get(
+        'http://example.com/testpath',
+        { hostname: 'localhost', port: server.address().port },
+        common.mustCall((res) => {
+          res.resume();
+        })
+      );
+    })
+  );
+}
diff --git a/test/js/node/test/parallel/test-http-request-end-twice.js b/test/js/node/test/parallel/test-http-request-end-twice.js
new file mode 100644
index 0000000000..47f08fd6e4
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-request-end-twice.js
@@ -0,0 +1,39 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const http = require('http');
+
+const server = http.Server(function(req, res) {
+  res.writeHead(200, { 'Content-Type': 'text/plain' });
+  res.end('hello world\n');
+});
+server.listen(0, function() {
+  const req = http.get({ port: this.address().port }, function(res) {
+    res.on('end', function() {
+      assert.strictEqual(req.end(), req);
+      server.close();
+    });
+    res.resume();
+  });
+});
diff --git a/test/js/node/test/parallel/test-http-request-end.js b/test/js/node/test/parallel/test-http-request-end.js
new file mode 100644
index 0000000000..6f141fda1e
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-request-end.js
@@ -0,0 +1,60 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const http = require('http');
+
+const expected = 'Post Body For Test';
+const expectedStatusCode = 200;
+
+const server = http.Server(function(req, res) {
+  let result = '';
+
+  req.setEncoding('utf8');
+  req.on('data', function(chunk) {
+    result += chunk;
+  });
+
+  req.on('end', common.mustCall(() => {
+    assert.strictEqual(result, expected);
+    res.writeHead(expectedStatusCode);
+    res.end('hello world\n');
+    server.close();
+  }));
+
+});
+
+server.listen(0, function() {
+  const req = http.request({
+    port: this.address().port,
+    path: '/',
+    method: 'POST'
+  }, function(res) {
+    assert.strictEqual(res.statusCode, expectedStatusCode);
+    res.resume();
+  }).on('error', common.mustNotCall());
+
+  const result = req.end(expected);
+
+  assert.strictEqual(req, result);
+});
diff --git a/test/js/node/test/parallel/test-http-request-large-payload.js b/test/js/node/test/parallel/test-http-request-large-payload.js
new file mode 100644
index 0000000000..3be100b740
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-request-large-payload.js
@@ -0,0 +1,26 @@
+'use strict';
+require('../common');
+
+// This test ensures Node.js doesn't throw an error when making requests with
+// the payload 16kb or more in size.
+// https://github.com/nodejs/node/issues/2821
+
+const http = require('http');
+
+const server = http.createServer(function(req, res) {
+  res.writeHead(200);
+  res.end();
+
+  server.close();
+});
+
+server.listen(0, function() {
+  const req = http.request({
+    method: 'POST',
+    port: this.address().port
+  });
+
+  const payload = Buffer.alloc(16390, 'Й');
+  req.write(payload);
+  req.end();
+});
diff --git a/test/js/node/test/parallel/test-http-request-method-delete-payload.js b/test/js/node/test/parallel/test-http-request-method-delete-payload.js
new file mode 100644
index 0000000000..03728846df
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-request-method-delete-payload.js
@@ -0,0 +1,30 @@
+'use strict';
+const common = require('../common');
+
+const assert = require('assert');
+const http = require('http');
+
+const data = 'PUT / HTTP/1.1\r\n\r\n';
+
+const server = http.createServer(common.mustCall(function(req, res) {
+  req.on('data', function(chunk) {
+    assert.strictEqual(chunk, Buffer.from(data));
+  });
+  res.setHeader('Content-Type', 'text/plain');
+  for (let i = 0; i < req.rawHeaders.length; i += 2) {
+    if (req.rawHeaders[i].toLowerCase() === 'host') continue;
+    if (req.rawHeaders[i].toLowerCase() === 'connection') continue;
+    res.write(`${req.rawHeaders[i]}: ${req.rawHeaders[i + 1]}\r\n`);
+  }
+  res.end();
+})).unref();
+
+server.listen(0, common.mustCall(() => {
+  const port = server.address().port;
+  const req = http.request({ method: 'DELETE', port }, function(res) {
+    res.resume();
+  });
+
+  req.write(data);
+  req.end();
+}));
diff --git a/test/js/node/test/parallel/test-http-request-smuggling-content-length.js b/test/js/node/test/parallel/test-http-request-smuggling-content-length.js
new file mode 100644
index 0000000000..4ae39b93f4
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-request-smuggling-content-length.js
@@ -0,0 +1,31 @@
+'use strict';
+
+const common = require('../common');
+const http = require('http');
+const net = require('net');
+const assert = require('assert');
+
+// Verify that a request with a space before the content length will result
+// in a 400 Bad Request.
+
+const server = http.createServer(common.mustNotCall());
+
+server.listen(0, common.mustCall(start));
+
+function start() {
+  const sock = net.connect(server.address().port);
+
+  sock.write('GET / HTTP/1.1\r\nHost: localhost:5000\r\n' +
+    'Content-Length : 5\r\n\r\nhello');
+
+  let body = '';
+  sock.setEncoding('utf8');
+  sock.on('data', (chunk) => {
+    body += chunk;
+  });
+  sock.on('end', common.mustCall(function() {
+    assert.strictEqual(body, 'HTTP/1.1 400 Bad Request\r\n' +
+      'Connection: close\r\n\r\n');
+    server.close();
+  }));
+}
diff --git a/test/js/node/test/parallel/test-http-res-write-after-end.js b/test/js/node/test/parallel/test-http-res-write-after-end.js
new file mode 100644
index 0000000000..285938c8fe
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-res-write-after-end.js
@@ -0,0 +1,45 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const http = require('http');
+
+const server = http.Server(common.mustCall(function(req, res) {
+  res.on('error', common.expectsError({
+    code: 'ERR_STREAM_WRITE_AFTER_END',
+    name: 'Error'
+  }));
+
+  res.write('This should write.');
+  res.end();
+
+  const r = res.write('This should raise an error.');
+  // Write after end should return false
+  assert.strictEqual(r, false);
+}));
+
+server.listen(0, function() {
+  http.get({ port: this.address().port }, function(res) {
+    server.close();
+  });
+});
diff --git a/test/js/node/test/parallel/test-http-res-write-end-dont-take-array.js b/test/js/node/test/parallel/test-http-res-write-end-dont-take-array.js
new file mode 100644
index 0000000000..8bebfc14e4
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-res-write-end-dont-take-array.js
@@ -0,0 +1,73 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const http = require('http');
+
+const server = http.createServer();
+
+server.once('request', common.mustCall((req, res) => {
+  server.on('request', common.mustCall((req, res) => {
+    res.end(Buffer.from('asdf'));
+  }));
+  // `res.write()` should accept `string`.
+  res.write('string');
+  // `res.write()` should accept `buffer`.
+  res.write(Buffer.from('asdf'));
+
+  const expectedError = {
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError',
+  };
+
+  // `res.write()` should not accept an Array.
+  assert.throws(
+    () => {
+      res.write(['array']);
+    },
+    expectedError
+  );
+
+  // `res.end()` should not accept an Array.
+  assert.throws(
+    () => {
+      res.end(['moo']);
+    },
+    expectedError
+  );
+
+  // `res.end()` should accept `string`.
+  res.end('string');
+}));
+
+server.listen(0, function() {
+  // Just make a request, other tests handle responses.
+  http.get({ port: this.address().port }, (res) => {
+    res.resume();
+    // Do it again to test .end(Buffer);
+    http.get({ port: server.address().port }, (res) => {
+      res.resume();
+      server.close();
+    });
+  });
+});
diff --git a/test/js/node/test/parallel/test-http-response-readable.js b/test/js/node/test/parallel/test-http-response-readable.js
new file mode 100644
index 0000000000..9ecfbc4ca9
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-response-readable.js
@@ -0,0 +1,41 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const http = require('http');
+
+const testServer = new http.Server(function(req, res) {
+  res.writeHead(200);
+  res.end('Hello world');
+});
+
+testServer.listen(0, function() {
+  http.get({ port: this.address().port }, function(res) {
+    assert.strictEqual(res.readable, true);
+    res.on('end', function() {
+      assert.strictEqual(res.readable, false);
+      testServer.close();
+    });
+    res.resume();
+  });
+});
diff --git a/test/js/node/test/parallel/test-http-response-writehead-returns-this.js b/test/js/node/test/parallel/test-http-response-writehead-returns-this.js
new file mode 100644
index 0000000000..a62c2eca03
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-response-writehead-returns-this.js
@@ -0,0 +1,22 @@
+'use strict';
+require('../common');
+const http = require('http');
+const assert = require('assert');
+
+const server = http.createServer((req, res) => {
+  res.writeHead(200, { 'a-header': 'a-header-value' }).end('abc');
+});
+
+server.listen(0, () => {
+  http.get({ port: server.address().port }, (res) => {
+    assert.strictEqual(res.headers['a-header'], 'a-header-value');
+
+    const chunks = [];
+
+    res.on('data', (chunk) => chunks.push(chunk));
+    res.on('end', () => {
+      assert.strictEqual(Buffer.concat(chunks).toString(), 'abc');
+      server.close();
+    });
+  });
+});
diff --git a/test/js/node/test/parallel/test-http-server-delete-parser.js b/test/js/node/test/parallel/test-http-server-delete-parser.js
new file mode 100644
index 0000000000..4215ee2f9d
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-server-delete-parser.js
@@ -0,0 +1,24 @@
+'use strict';
+
+const common = require('../common');
+
+const http = require('http');
+
+const server = http.createServer(common.mustCall((req, res) => {
+  res.writeHead(200, { 'Content-Type': 'text/plain' });
+  res.write('okay', common.mustCall(() => {
+    delete res.socket.parser;
+  }));
+  res.end();
+}));
+
+server.listen(0, '127.0.0.1', common.mustCall(() => {
+  const req = http.request({
+    port: server.address().port,
+    host: '127.0.0.1',
+    method: 'GET',
+  });
+  req.end();
+}));
+
+server.unref();
diff --git a/test/js/node/test/parallel/test-http-server-non-utf8-header.js b/test/js/node/test/parallel/test-http-server-non-utf8-header.js
new file mode 100644
index 0000000000..8ce82ac4ca
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-server-non-utf8-header.js
@@ -0,0 +1,69 @@
+'use strict';
+const common = require('../common');
+const http = require('http');
+const assert = require('assert');
+
+const nonUtf8Header = 'bår';
+const nonUtf8ToLatin1 = Buffer.from(nonUtf8Header).toString('latin1');
+
+{
+  const server = http.createServer(common.mustCall((req, res) => {
+    res.writeHead(200, [
+      'content-disposition',
+      Buffer.from(nonUtf8Header).toString('binary'),
+    ]);
+    res.end('hello');
+  }));
+
+  server.listen(0, common.mustCall(() => {
+    http.get({ port: server.address().port }, (res) => {
+      assert.strictEqual(res.statusCode, 200);
+      assert.strictEqual(res.headers['content-disposition'], nonUtf8ToLatin1);
+      res.resume().on('end', common.mustCall(() => {
+        server.close();
+      }));
+    });
+  }));
+}
+
+{
+  // Test multi-value header
+  const server = http.createServer(common.mustCall((req, res) => {
+    res.writeHead(200, [
+      'content-disposition',
+      [Buffer.from(nonUtf8Header).toString('binary')],
+    ]);
+    res.end('hello');
+  }));
+
+  server.listen(0, common.mustCall(() => {
+    http.get({ port: server.address().port }, (res) => {
+      assert.strictEqual(res.statusCode, 200);
+      assert.strictEqual(res.headers['content-disposition'], nonUtf8ToLatin1);
+      res.resume().on('end', common.mustCall(() => {
+        server.close();
+      }));
+    });
+  }));
+}
+
+{
+  const server = http.createServer(common.mustCall((req, res) => {
+    res.writeHead(200, [
+      'Content-Length', '5',
+      'content-disposition',
+      Buffer.from(nonUtf8Header).toString('binary'),
+    ]);
+    res.end('hello');
+  }));
+
+  server.listen(0, common.mustCall(() => {
+    http.get({ port: server.address().port }, (res) => {
+      assert.strictEqual(res.statusCode, 200);
+      assert.strictEqual(res.headers['content-disposition'], nonUtf8ToLatin1);
+      res.resume().on('end', common.mustCall(() => {
+        server.close();
+      }));
+    });
+  }));
+}
diff --git a/test/js/node/test/parallel/test-http-server-options-incoming-message.js b/test/js/node/test/parallel/test-http-server-options-incoming-message.js
new file mode 100644
index 0000000000..d0f4a769d7
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-server-options-incoming-message.js
@@ -0,0 +1,41 @@
+'use strict';
+
+/**
+ * This test covers http.Server({ IncomingMessage }) option:
+ * With IncomingMessage option the server should use
+ * the new class for creating req Object instead of the default
+ * http.IncomingMessage.
+ */
+const common = require('../common');
+const assert = require('assert');
+const http = require('http');
+
+class MyIncomingMessage extends http.IncomingMessage {
+  getUserAgent() {
+    return this.headers['user-agent'] || 'unknown';
+  }
+}
+
+const server = http.createServer({
+  IncomingMessage: MyIncomingMessage
+}, common.mustCall(function(req, res) {
+  assert.strictEqual(req.getUserAgent(), 'node-test');
+  res.statusCode = 200;
+  res.end();
+}));
+server.listen();
+
+server.on('listening', function makeRequest() {
+  http.get({
+    port: this.address().port,
+    headers: {
+      'User-Agent': 'node-test'
+    }
+  }, (res) => {
+    assert.strictEqual(res.statusCode, 200);
+    res.on('end', () => {
+      server.close();
+    });
+    res.resume();
+  });
+});
diff --git a/test/js/node/test/parallel/test-http-server-options-server-response.js b/test/js/node/test/parallel/test-http-server-options-server-response.js
new file mode 100644
index 0000000000..f5adf39bed
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-server-options-server-response.js
@@ -0,0 +1,35 @@
+'use strict';
+
+/**
+ * This test covers http.Server({ ServerResponse }) option:
+ * With ServerResponse option the server should use
+ * the new class for creating res Object instead of the default
+ * http.ServerResponse.
+ */
+const common = require('../common');
+const assert = require('assert');
+const http = require('http');
+
+class MyServerResponse extends http.ServerResponse {
+  status(code) {
+    return this.writeHead(code, { 'Content-Type': 'text/plain' });
+  }
+}
+
+const server = http.Server({
+  ServerResponse: MyServerResponse
+}, common.mustCall(function(req, res) {
+  res.status(200);
+  res.end();
+}));
+server.listen();
+
+server.on('listening', function makeRequest() {
+  http.get({ port: this.address().port }, (res) => {
+    assert.strictEqual(res.statusCode, 200);
+    res.on('end', () => {
+      server.close();
+    });
+    res.resume();
+  });
+});
diff --git a/test/js/node/test/parallel/test-http-server-stale-close.js b/test/js/node/test/parallel/test-http-server-stale-close.js
new file mode 100644
index 0000000000..b9322ed9fc
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-server-stale-close.js
@@ -0,0 +1,53 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const http = require('http');
+const fork = require('child_process').fork;
+const assert = require('assert');
+
+if (process.env.NODE_TEST_FORK_PORT) {
+  const req = http.request({
+    headers: { 'Content-Length': '42' },
+    method: 'POST',
+    host: '127.0.0.1',
+    port: +process.env.NODE_TEST_FORK_PORT,
+  }, process.exit);
+  req.write('BAM');
+  req.end();
+} else {
+  const server = http.createServer((req, res) => {
+    res.writeHead(200, { 'Content-Length': '42' });
+    req.pipe(res);
+    assert.strictEqual(req.destroyed, false);
+    req.on('close', () => {
+      assert.strictEqual(req.destroyed, true);
+      server.close();
+      res.end();
+    });
+  });
+  server.listen(0, function() {
+    fork(__filename, {
+      env: { ...process.env, NODE_TEST_FORK_PORT: this.address().port }
+    });
+  });
+}
diff --git a/test/js/node/test/parallel/test-http-server-write-after-end.js b/test/js/node/test/parallel/test-http-server-write-after-end.js
new file mode 100644
index 0000000000..ba28771312
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-server-write-after-end.js
@@ -0,0 +1,29 @@
+'use strict';
+
+const common = require('../common');
+const http = require('http');
+
+// Fix for https://github.com/nodejs/node/issues/14368
+
+const server = http.createServer(handle);
+
+function handle(req, res) {
+  res.on('error', common.mustNotCall());
+
+  res.write('hello');
+  res.end();
+
+  setImmediate(common.mustCall(() => {
+    res.write('world', common.mustCall((err) => {
+      common.expectsError({
+        code: 'ERR_STREAM_WRITE_AFTER_END',
+        name: 'Error'
+      })(err);
+      server.close();
+    }));
+  }));
+}
+
+server.listen(0, common.mustCall(() => {
+  http.get(`http://localhost:${server.address().port}`);
+}));
diff --git a/test/js/node/test/parallel/test-http-set-header-chain.js b/test/js/node/test/parallel/test-http-set-header-chain.js
new file mode 100644
index 0000000000..aa9519129a
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-set-header-chain.js
@@ -0,0 +1,29 @@
+'use strict';
+const common = require('../common');
+const http = require('http');
+const assert = require('assert');
+const expected = {
+  '__proto__': null,
+  'testheader1': 'foo',
+  'testheader2': 'bar',
+  'testheader3': 'xyz'
+};
+const server = http.createServer(common.mustCall((req, res) => {
+  let retval = res.setHeader('testheader1', 'foo');
+
+  // Test that the setHeader returns the same response object.
+  assert.strictEqual(retval, res);
+
+  retval = res.setHeader('testheader2', 'bar').setHeader('testheader3', 'xyz');
+  // Test that chaining works for setHeader.
+  assert.deepStrictEqual(res.getHeaders(), expected);
+  res.end('ok');
+}));
+server.listen(0, () => {
+  http.get({ port: server.address().port }, common.mustCall((res) => {
+    res.on('data', () => {});
+    res.on('end', common.mustCall(() => {
+      server.close();
+    }));
+  }));
+});
diff --git a/test/js/node/test/parallel/test-http-status-code.js b/test/js/node/test/parallel/test-http-status-code.js
new file mode 100644
index 0000000000..246d22c131
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-status-code.js
@@ -0,0 +1,58 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const http = require('http');
+const Countdown = require('../common/countdown');
+
+// Simple test of Node's HTTP ServerResponse.statusCode
+// ServerResponse.prototype.statusCode
+
+const tests = [200, 202, 300, 404, 451, 500];
+let test;
+const countdown = new Countdown(tests.length, () => s.close());
+
+const s = http.createServer(function(req, res) {
+  res.writeHead(test, { 'Content-Type': 'text/plain' });
+  console.log(`--\nserver: statusCode after writeHead: ${res.statusCode}`);
+  assert.strictEqual(res.statusCode, test);
+  res.end('hello world\n');
+});
+
+s.listen(0, nextTest);
+
+
+function nextTest() {
+  test = tests.shift();
+
+  http.get({ port: s.address().port }, function(response) {
+    console.log(`client: expected status: ${test}`);
+    console.log(`client: statusCode: ${response.statusCode}`);
+    assert.strictEqual(response.statusCode, test);
+    response.on('end', function() {
+      if (countdown.dec())
+        nextTest();
+    });
+    response.resume();
+  });
+}
diff --git a/test/js/node/test/parallel/test-http-upgrade-reconsume-stream.js b/test/js/node/test/parallel/test-http-upgrade-reconsume-stream.js
new file mode 100644
index 0000000000..e712ea647b
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-upgrade-reconsume-stream.js
@@ -0,0 +1,29 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const tls = require('tls');
+const http = require('http');
+
+// Tests that, after the HTTP parser stopped owning a socket that emits an
+// 'upgrade' event, another C++ stream can start owning it (e.g. a TLSSocket).
+
+const server = http.createServer(common.mustNotCall());
+
+server.on('upgrade', common.mustCall((request, socket, head) => {
+  // This should not crash.
+  new tls.TLSSocket(socket);
+  server.close();
+  socket.destroy();
+}));
+
+server.listen(0, common.mustCall(() => {
+  http.get({
+    port: server.address().port,
+    headers: {
+      'Connection': 'Upgrade',
+      'Upgrade': 'websocket'
+    }
+  }).on('error', () => {});
+}));
diff --git a/test/js/node/test/parallel/test-http-url.parse-auth-with-header-in-request.js b/test/js/node/test/parallel/test-http-url.parse-auth-with-header-in-request.js
new file mode 100644
index 0000000000..ea5793ee18
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-url.parse-auth-with-header-in-request.js
@@ -0,0 +1,52 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const http = require('http');
+const url = require('url');
+
+function check(request) {
+  // The correct authorization header is be passed
+  assert.strictEqual(request.headers.authorization, 'NoAuthForYOU');
+}
+
+const server = http.createServer(function(request, response) {
+  // Run the check function
+  check(request);
+  response.writeHead(200, {});
+  response.end('ok');
+  server.close();
+});
+
+server.listen(0, function() {
+  const testURL =
+    url.parse(`http://asdf:qwer@localhost:${this.address().port}`);
+  // The test here is if you set a specific authorization header in the
+  // request we should not override that with basic auth
+  testURL.headers = {
+    Authorization: 'NoAuthForYOU'
+  };
+
+  // make the request
+  http.request(testURL).end();
+});
diff --git a/test/js/node/test/parallel/test-http-url.parse-auth.js b/test/js/node/test/parallel/test-http-url.parse-auth.js
new file mode 100644
index 0000000000..2bb5311586
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-url.parse-auth.js
@@ -0,0 +1,48 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const http = require('http');
+const url = require('url');
+
+function check(request) {
+  // The correct authorization header is be passed
+  assert.strictEqual(request.headers.authorization, 'Basic dXNlcjpwYXNzOg==');
+}
+
+const server = http.createServer(function(request, response) {
+  // Run the check function
+  check(request);
+  response.writeHead(200, {});
+  response.end('ok');
+  server.close();
+});
+
+server.listen(0, function() {
+  const port = this.address().port;
+  // username = "user", password = "pass:"
+  const testURL = url.parse(`http://user:pass%3A@localhost:${port}`);
+
+  // make the request
+  http.request(testURL).end();
+});
diff --git a/test/js/node/test/parallel/test-http-url.parse-basic.js b/test/js/node/test/parallel/test-http-url.parse-basic.js
new file mode 100644
index 0000000000..71885b4bd0
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-url.parse-basic.js
@@ -0,0 +1,58 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const http = require('http');
+const url = require('url');
+
+let testURL;
+
+// Make sure the basics work
+function check(request) {
+  // Default method should still be 'GET'
+  assert.strictEqual(request.method, 'GET');
+  // There are no URL params, so you should not see any
+  assert.strictEqual(request.url, '/');
+  // The host header should use the url.parse.hostname
+  assert.strictEqual(request.headers.host,
+                     `${testURL.hostname}:${testURL.port}`);
+}
+
+const server = http.createServer(function(request, response) {
+  // Run the check function
+  check(request);
+  response.writeHead(200, {});
+  response.end('ok');
+  server.close();
+});
+
+server.listen(0, function() {
+  testURL = url.parse(`http://localhost:${this.address().port}`);
+
+  // make the request
+  const clientRequest = http.request(testURL);
+  // Since there is a little magic with the agent
+  // make sure that an http request uses the http.Agent
+  assert.ok(clientRequest.agent instanceof http.Agent);
+  clientRequest.end();
+});
diff --git a/test/js/node/test/parallel/test-http-url.parse-only-support-http-https-protocol.js b/test/js/node/test/parallel/test-http-url.parse-only-support-http-https-protocol.js
new file mode 100644
index 0000000000..3f6633075c
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-url.parse-only-support-http-https-protocol.js
@@ -0,0 +1,45 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const http = require('http');
+const url = require('url');
+
+const invalidUrls = [
+  'file:///whatever',
+  'mailto:asdf@asdf.com',
+  'ftp://www.example.com',
+  'javascript:alert(\'hello\');',
+  'xmpp:foo@bar.com',
+  'f://some.host/path',
+];
+
+for (const invalid of invalidUrls) {
+  assert.throws(
+    () => { http.request(url.parse(invalid)); },
+    {
+      code: 'ERR_INVALID_PROTOCOL',
+      name: 'TypeError'
+    }
+  );
+}
diff --git a/test/js/node/test/parallel/test-http-url.parse-path.js b/test/js/node/test/parallel/test-http-url.parse-path.js
new file mode 100644
index 0000000000..25e4838c4a
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-url.parse-path.js
@@ -0,0 +1,46 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const http = require('http');
+const url = require('url');
+
+function check(request) {
+  // A path should come over
+  assert.strictEqual(request.url, '/asdf');
+}
+
+const server = http.createServer(function(request, response) {
+  // Run the check function
+  check(request);
+  response.writeHead(200, {});
+  response.end('ok');
+  server.close();
+});
+
+server.listen(0, function() {
+  const testURL = url.parse(`http://localhost:${this.address().port}/asdf`);
+
+  // make the request
+  http.request(testURL).end();
+});
diff --git a/test/js/node/test/parallel/test-http-url.parse-post.js b/test/js/node/test/parallel/test-http-url.parse-post.js
new file mode 100644
index 0000000000..db5ee78fe6
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-url.parse-post.js
@@ -0,0 +1,54 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const http = require('http');
+const url = require('url');
+
+let testURL;
+
+function check(request) {
+  // url.parse should not mess with the method
+  assert.strictEqual(request.method, 'POST');
+  // Everything else should be right
+  assert.strictEqual(request.url, '/asdf?qwer=zxcv');
+  // The host header should use the url.parse.hostname
+  assert.strictEqual(request.headers.host,
+                     `${testURL.hostname}:${testURL.port}`);
+}
+
+const server = http.createServer(function(request, response) {
+  // Run the check function
+  check(request);
+  response.writeHead(200, {});
+  response.end('ok');
+  server.close();
+});
+
+server.listen(0, function() {
+  testURL = url.parse(`http://localhost:${this.address().port}/asdf?qwer=zxcv`);
+  testURL.method = 'POST';
+
+  // make the request
+  http.request(testURL).end();
+});
diff --git a/test/js/node/test/parallel/test-http-url.parse-search.js b/test/js/node/test/parallel/test-http-url.parse-search.js
new file mode 100644
index 0000000000..0759c779d3
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-url.parse-search.js
@@ -0,0 +1,47 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const http = require('http');
+const url = require('url');
+
+function check(request) {
+  // A path should come over with params
+  assert.strictEqual(request.url, '/asdf?qwer=zxcv');
+}
+
+const server = http.createServer(function(request, response) {
+  // Run the check function
+  check(request);
+  response.writeHead(200, {});
+  response.end('ok');
+  server.close();
+});
+
+server.listen(0, function() {
+  const port = this.address().port;
+  const testURL = url.parse(`http://localhost:${port}/asdf?qwer=zxcv`);
+
+  // make the request
+  http.request(testURL).end();
+});
diff --git a/test/js/node/test/parallel/test-http-write-empty-string.js b/test/js/node/test/parallel/test-http-write-empty-string.js
new file mode 100644
index 0000000000..88eff08f76
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-write-empty-string.js
@@ -0,0 +1,54 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+const http = require('http');
+
+const server = http.createServer(function(request, response) {
+  console.log(`responding to ${request.url}`);
+
+  response.writeHead(200, { 'Content-Type': 'text/plain' });
+  response.write('1\n');
+  response.write('');
+  response.write('2\n');
+  response.write('');
+  response.end('3\n');
+
+  this.close();
+});
+
+server.listen(0, common.mustCall(() => {
+  http.get({ port: server.address().port }, common.mustCall((res) => {
+    let response = '';
+
+    assert.strictEqual(res.statusCode, 200);
+    res.setEncoding('ascii');
+    res.on('data', (chunk) => {
+      response += chunk;
+    });
+    res.on('end', common.mustCall(() => {
+      assert.strictEqual(response, '1\n2\n3\n');
+    }));
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http-zero-length-write.js b/test/js/node/test/parallel/test-http-zero-length-write.js
new file mode 100644
index 0000000000..f765ad0545
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-zero-length-write.js
@@ -0,0 +1,94 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+
+const http = require('http');
+
+const Stream = require('stream');
+
+function getSrc() {
+  // An old-style readable stream.
+  // The Readable class prevents this behavior.
+  const src = new Stream();
+
+  // Start out paused, just so we don't miss anything yet.
+  let paused = false;
+  src.pause = function() {
+    paused = true;
+  };
+  src.resume = function() {
+    paused = false;
+  };
+
+  const chunks = [ '', 'asdf', '', 'foo', '', 'bar', '' ];
+  const interval = setInterval(function() {
+    if (paused)
+      return;
+
+    const chunk = chunks.shift();
+    if (chunk !== undefined) {
+      src.emit('data', chunk);
+    } else {
+      src.emit('end');
+      clearInterval(interval);
+    }
+  }, 1);
+
+  return src;
+}
+
+
+const expect = 'asdffoobar';
+
+const server = http.createServer(function(req, res) {
+  let actual = '';
+  req.setEncoding('utf8');
+  req.on('data', function(c) {
+    actual += c;
+  });
+  req.on('end', function() {
+    assert.strictEqual(actual, expect);
+    getSrc().pipe(res);
+  });
+  server.close();
+});
+
+server.listen(0, function() {
+  const req = http.request({ port: this.address().port, method: 'POST' });
+  let actual = '';
+  req.on('response', function(res) {
+    res.setEncoding('utf8');
+    res.on('data', function(c) {
+      actual += c;
+    });
+    res.on('end', function() {
+      assert.strictEqual(actual, expect);
+    });
+  });
+  getSrc().pipe(req);
+});
+
+process.on('exit', function(c) {
+  if (!c) console.log('ok');
+});
diff --git a/test/js/node/test/parallel/test-http-zerolengthbuffer.js b/test/js/node/test/parallel/test-http-zerolengthbuffer.js
new file mode 100644
index 0000000000..c59fc18108
--- /dev/null
+++ b/test/js/node/test/parallel/test-http-zerolengthbuffer.js
@@ -0,0 +1,23 @@
+'use strict';
+// Serving up a zero-length buffer should work.
+
+const common = require('../common');
+const http = require('http');
+
+const server = http.createServer((req, res) => {
+  const buffer = Buffer.alloc(0);
+  res.writeHead(200, { 'Content-Type': 'text/html',
+                       'Content-Length': buffer.length });
+  res.end(buffer);
+});
+
+server.listen(0, common.mustCall(() => {
+  http.get({ port: server.address().port }, common.mustCall((res) => {
+
+    res.on('data', common.mustNotCall());
+
+    res.on('end', (d) => {
+      server.close();
+    });
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http2-clean-output.js b/test/js/node/test/parallel/test-http2-clean-output.js
new file mode 100644
index 0000000000..27b7c338c9
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-clean-output.js
@@ -0,0 +1,40 @@
+'use strict';
+
+const {
+  hasCrypto,
+  mustCall,
+  skip
+} = require('../common');
+if (!hasCrypto)
+  skip('missing crypto');
+
+const {
+  strictEqual
+} = require('assert');
+const {
+  createServer,
+  connect
+} = require('http2');
+const {
+  spawnSync
+} = require('child_process');
+
+// Validate that there is no unexpected output when
+// using http2
+if (process.argv[2] !== 'child') {
+  const {
+    stdout, stderr, status
+  } = spawnSync(process.execPath, [__filename, 'child'], { encoding: 'utf8' });
+  strictEqual(stderr, '');
+  strictEqual(stdout, '');
+  strictEqual(status, 0);
+} else {
+  const server = createServer();
+  server.listen(0, mustCall(() => {
+    const client = connect(`http://localhost:${server.address().port}`);
+    client.on('connect', mustCall(() => {
+      client.close();
+      server.close();
+    }));
+  }));
+}
diff --git a/test/js/node/test/parallel/test-http2-client-priority-before-connect.js b/test/js/node/test/parallel/test-http2-client-priority-before-connect.js
new file mode 100644
index 0000000000..7aa13a5e45
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-client-priority-before-connect.js
@@ -0,0 +1,28 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const h2 = require('http2');
+
+const server = h2.createServer();
+
+// We use the lower-level API here
+server.on('stream', common.mustCall((stream) => {
+  stream.respond();
+  stream.end('ok');
+}));
+
+server.listen(0, common.mustCall(() => {
+  const client = h2.connect(`http://localhost:${server.address().port}`);
+  const req = client.request();
+  req.priority({});
+
+  req.on('response', common.mustCall());
+  req.resume();
+  req.on('end', common.mustCall());
+  req.on('close', common.mustCall(() => {
+    server.close();
+    client.close();
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http2-client-request-listeners-warning.js b/test/js/node/test/parallel/test-http2-client-request-listeners-warning.js
new file mode 100644
index 0000000000..854e9535fd
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-client-request-listeners-warning.js
@@ -0,0 +1,41 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const http2 = require('http2');
+const EventEmitter = require('events');
+
+// This test ensures that a MaxListenersExceededWarning isn't emitted if
+// more than EventEmitter.defaultMaxListeners requests are started on a
+// ClientHttp2Session before it has finished connecting.
+
+process.on('warning', common.mustNotCall('A warning was emitted'));
+
+const server = http2.createServer();
+server.on('stream', (stream) => {
+  stream.respond();
+  stream.end();
+});
+
+server.listen(common.mustCall(() => {
+  const client = http2.connect(`http://localhost:${server.address().port}`);
+
+  function request() {
+    return new Promise((resolve, reject) => {
+      const stream = client.request();
+      stream.on('error', reject);
+      stream.on('response', resolve);
+      stream.end();
+    });
+  }
+
+  const requests = [];
+  for (let i = 0; i < EventEmitter.defaultMaxListeners + 1; i++) {
+    requests.push(request());
+  }
+
+  Promise.all(requests).then(common.mustCall()).finally(common.mustCall(() => {
+    server.close();
+    client.close();
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http2-client-upload-reject.js b/test/js/node/test/parallel/test-http2-client-upload-reject.js
new file mode 100644
index 0000000000..7234493031
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-client-upload-reject.js
@@ -0,0 +1,49 @@
+'use strict';
+
+// Verifies that uploading data from a client works
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const http2 = require('http2');
+const fs = require('fs');
+const fixtures = require('../common/fixtures');
+
+const loc = fixtures.path('person-large.jpg');
+
+assert(fs.existsSync(loc));
+
+fs.readFile(loc, common.mustSucceed((data) => {
+  const server = http2.createServer();
+
+  server.on('stream', common.mustCall((stream) => {
+    // Wait for some data to come through.
+    setImmediate(() => {
+      stream.on('close', common.mustCall(() => {
+        assert.strictEqual(stream.rstCode, 0);
+      }));
+
+      stream.respond({ ':status': 400 });
+      stream.end();
+    });
+  }));
+
+  server.listen(0, common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+
+    const req = client.request({ ':method': 'POST' });
+    req.on('response', common.mustCall((headers) => {
+      assert.strictEqual(headers[':status'], 400);
+    }));
+
+    req.resume();
+    req.on('end', common.mustCall(() => {
+      server.close();
+      client.close();
+    }));
+
+    const str = fs.createReadStream(loc);
+    str.pipe(req);
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http2-client-upload.js b/test/js/node/test/parallel/test-http2-client-upload.js
new file mode 100644
index 0000000000..d073cd94e6
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-client-upload.js
@@ -0,0 +1,58 @@
+'use strict';
+
+// Verifies that uploading data from a client works
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const http2 = require('http2');
+const fs = require('fs');
+const fixtures = require('../common/fixtures');
+const Countdown = require('../common/countdown');
+
+const loc = fixtures.path('person-large.jpg');
+let fileData;
+
+assert(fs.existsSync(loc));
+
+fs.readFile(loc, common.mustSucceed((data) => {
+  fileData = data;
+
+  const server = http2.createServer();
+  let client;
+
+  const countdown = new Countdown(2, () => {
+    server.close();
+    client.close();
+  });
+
+  server.on('stream', common.mustCall((stream) => {
+    let data = Buffer.alloc(0);
+    stream.on('data', (chunk) => data = Buffer.concat([data, chunk]));
+    stream.on('end', common.mustCall(() => {
+      assert.deepStrictEqual(data, fileData);
+    }));
+    // Waiting on close avoids spurious ECONNRESET seen in windows CI.
+    // Not sure if this is actually a bug; more details at
+    // https://github.com/nodejs/node/issues/20750#issuecomment-511015247
+    stream.on('close', () => countdown.dec());
+    stream.respond();
+    stream.end();
+  }));
+
+  server.listen(0, common.mustCall(() => {
+    client = http2.connect(`http://localhost:${server.address().port}`);
+
+    const req = client.request({ ':method': 'POST' });
+    req.on('response', common.mustCall());
+
+    req.resume();
+    req.on('end', common.mustCall());
+
+    const str = fs.createReadStream(loc);
+    str.on('end', common.mustCall());
+    str.on('close', () => countdown.dec());
+    str.pipe(req);
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http2-client-write-before-connect.js b/test/js/node/test/parallel/test-http2-client-write-before-connect.js
new file mode 100644
index 0000000000..6efefc5870
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-client-write-before-connect.js
@@ -0,0 +1,37 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const h2 = require('http2');
+
+const server = h2.createServer();
+
+// We use the lower-level API here
+server.on('stream', common.mustCall((stream, headers, flags) => {
+  let data = '';
+  stream.setEncoding('utf8');
+  stream.on('data', (chunk) => data += chunk);
+  stream.on('end', common.mustCall(() => {
+    assert.strictEqual(data, 'some data more data');
+  }));
+  stream.respond();
+  stream.end('ok');
+}));
+
+server.listen(0, common.mustCall(() => {
+  const client = h2.connect(`http://localhost:${server.address().port}`);
+
+  const req = client.request({ ':method': 'POST' });
+  req.write('some data ');
+  req.end('more data');
+
+  req.on('response', common.mustCall());
+  req.resume();
+  req.on('end', common.mustCall());
+  req.on('close', common.mustCall(() => {
+    server.close();
+    client.close();
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http2-client-write-empty-string.js b/test/js/node/test/parallel/test-http2-client-write-empty-string.js
new file mode 100644
index 0000000000..f0f0b8f012
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-client-write-empty-string.js
@@ -0,0 +1,54 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const http2 = require('http2');
+
+for (const chunkSequence of [
+  [ '' ],
+  [ '', '' ],
+]) {
+  const server = http2.createServer();
+  server.on('stream', common.mustCall((stream, headers, flags) => {
+    stream.respond({ 'content-type': 'text/html' });
+
+    let data = '';
+    stream.on('data', common.mustNotCall((chunk) => {
+      data += chunk.toString();
+    }));
+    stream.on('end', common.mustCall(() => {
+      stream.end(`"${data}"`);
+    }));
+  }));
+
+  server.listen(0, common.mustCall(() => {
+    const port = server.address().port;
+    const client = http2.connect(`http://localhost:${port}`);
+
+    const req = client.request({
+      ':method': 'POST',
+      ':path': '/'
+    });
+
+    req.on('response', common.mustCall((headers) => {
+      assert.strictEqual(headers[':status'], 200);
+      assert.strictEqual(headers['content-type'], 'text/html');
+    }));
+
+    let data = '';
+    req.setEncoding('utf8');
+    req.on('data', common.mustCallAtLeast((d) => data += d));
+    req.on('end', common.mustCall(() => {
+      assert.strictEqual(data, '""');
+      server.close();
+      client.close();
+    }));
+
+    for (const chunk of chunkSequence)
+      req.write(chunk);
+    req.end();
+  }));
+}
diff --git a/test/js/node/test/parallel/test-http2-compat-errors.js b/test/js/node/test/parallel/test-http2-compat-errors.js
new file mode 100644
index 0000000000..18dc385422
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-compat-errors.js
@@ -0,0 +1,35 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const h2 = require('http2');
+
+// Errors should not be reported both in Http2ServerRequest
+// and Http2ServerResponse
+
+let expected = null;
+
+const server = h2.createServer(common.mustCall(function(req, res) {
+  res.stream.on('error', common.mustCall());
+  req.on('error', common.mustNotCall());
+  res.on('error', common.mustNotCall());
+  req.on('aborted', common.mustCall());
+  res.on('aborted', common.mustNotCall());
+
+  res.write('hello');
+
+  expected = new Error('kaboom');
+  res.stream.destroy(expected);
+  server.close();
+}));
+
+server.listen(0, common.mustCall(function() {
+  const url = `http://localhost:${server.address().port}`;
+  const client = h2.connect(url, common.mustCall(() => {
+    const request = client.request();
+    request.on('data', common.mustCall((chunk) => {
+      client.destroy();
+    }));
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http2-compat-expect-continue.js b/test/js/node/test/parallel/test-http2-compat-expect-continue.js
new file mode 100644
index 0000000000..d0decb1472
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-compat-expect-continue.js
@@ -0,0 +1,95 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const http2 = require('http2');
+
+{
+  const testResBody = 'other stuff!\n';
+
+  // Checks the full 100-continue flow from client sending 'expect: 100-continue'
+  // through server receiving it, sending back :status 100, writing the rest of
+  // the request to finally the client receiving to.
+
+  const server = http2.createServer();
+
+  let sentResponse = false;
+
+  server.on('request', common.mustCall((req, res) => {
+    res.end(testResBody);
+    sentResponse = true;
+  }));
+
+  server.listen(0);
+
+  server.on('listening', common.mustCall(() => {
+    let body = '';
+
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+    const req = client.request({
+      ':method': 'POST',
+      'expect': '100-continue'
+    });
+
+    let gotContinue = false;
+    req.on('continue', common.mustCall(() => {
+      gotContinue = true;
+    }));
+
+    req.on('response', common.mustCall((headers) => {
+      assert.strictEqual(gotContinue, true);
+      assert.strictEqual(sentResponse, true);
+      assert.strictEqual(headers[':status'], 200);
+      req.end();
+    }));
+
+    req.setEncoding('utf8');
+    req.on('data', common.mustCall((chunk) => { body += chunk; }));
+    req.on('end', common.mustCall(() => {
+      assert.strictEqual(body, testResBody);
+      client.close();
+      server.close();
+    }));
+  }));
+}
+
+{
+  // Checks the full 100-continue flow from client sending 'expect: 100-continue'
+  // through server receiving it and ending the request.
+
+  const server = http2.createServer();
+
+  server.on('request', common.mustCall((req, res) => {
+    res.end();
+  }));
+
+  server.listen(0);
+
+  server.on('listening', common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+    const req = client.request({
+      ':path': '/',
+      'expect': '100-continue'
+    });
+
+    let gotContinue = false;
+    req.on('continue', common.mustCall(() => {
+      gotContinue = true;
+    }));
+
+    let gotResponse = false;
+    req.on('response', common.mustCall(() => {
+      gotResponse = true;
+    }));
+
+    req.setEncoding('utf8');
+    req.on('end', common.mustCall(() => {
+      assert.strictEqual(gotContinue, true);
+      assert.strictEqual(gotResponse, true);
+      client.close();
+      server.close();
+    }));
+  }));
+}
diff --git a/test/js/node/test/parallel/test-http2-compat-expect-handling.js b/test/js/node/test/parallel/test-http2-compat-expect-handling.js
new file mode 100644
index 0000000000..77f2275834
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-compat-expect-handling.js
@@ -0,0 +1,45 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const http2 = require('http2');
+
+const expectValue = 'meoww';
+
+const server = http2.createServer(common.mustNotCall());
+
+server.once('checkExpectation', common.mustCall((req, res) => {
+  assert.strictEqual(req.headers.expect, expectValue);
+  res.statusCode = 417;
+  res.end();
+}));
+
+server.listen(0, common.mustCall(() => nextTest(2)));
+
+function nextTest(testsToRun) {
+  if (!testsToRun) {
+    return server.close();
+  }
+
+  const port = server.address().port;
+  const client = http2.connect(`http://localhost:${port}`);
+  const req = client.request({
+    ':path': '/',
+    ':method': 'GET',
+    ':scheme': 'http',
+    ':authority': `localhost:${port}`,
+    'expect': expectValue
+  });
+
+  req.on('response', common.mustCall((headers) => {
+    assert.strictEqual(headers[':status'], 417);
+    req.resume();
+  }));
+
+  req.on('end', common.mustCall(() => {
+    client.close();
+    nextTest(testsToRun - 1);
+  }));
+}
diff --git a/test/js/node/test/parallel/test-http2-compat-method-connect.js b/test/js/node/test/parallel/test-http2-compat-method-connect.js
new file mode 100644
index 0000000000..21ad23e92b
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-compat-method-connect.js
@@ -0,0 +1,40 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const http2 = require('http2');
+
+const server = http2.createServer(common.mustNotCall());
+
+server.listen(0, common.mustCall(() => testMethodConnect(2)));
+
+server.once('connect', common.mustCall((req, res) => {
+  assert.strictEqual(req.headers[':method'], 'CONNECT');
+  res.statusCode = 405;
+  res.end();
+}));
+
+function testMethodConnect(testsToRun) {
+  if (!testsToRun) {
+    return server.close();
+  }
+
+  const port = server.address().port;
+  const client = http2.connect(`http://localhost:${port}`);
+  const req = client.request({
+    ':method': 'CONNECT',
+    ':authority': `localhost:${port}`
+  });
+
+  req.on('response', common.mustCall((headers) => {
+    assert.strictEqual(headers[':status'], 405);
+  }));
+  req.resume();
+  req.on('end', common.mustCall(() => {
+    client.close();
+    testMethodConnect(testsToRun - 1);
+  }));
+  req.end();
+}
diff --git a/test/js/node/test/parallel/test-http2-compat-serverrequest-pause.js b/test/js/node/test/parallel/test-http2-compat-serverrequest-pause.js
new file mode 100644
index 0000000000..2abc9e3da4
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-compat-serverrequest-pause.js
@@ -0,0 +1,52 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const h2 = require('http2');
+
+// Check that pause & resume work as expected with Http2ServerRequest
+
+const testStr = 'Request Body from Client';
+
+const server = h2.createServer();
+
+server.on('request', common.mustCall((req, res) => {
+  let data = '';
+  req.pause();
+  req.setEncoding('utf8');
+  req.on('data', common.mustCall((chunk) => (data += chunk)));
+  setTimeout(common.mustCall(() => {
+    assert.strictEqual(data, '');
+    req.resume();
+  }), common.platformTimeout(100));
+  req.on('end', common.mustCall(() => {
+    assert.strictEqual(data, testStr);
+    res.end();
+  }));
+
+  // Shouldn't throw if underlying Http2Stream no longer exists
+  res.on('finish', common.mustCall(() => process.nextTick(() => {
+    req.pause();
+    req.resume();
+  })));
+}));
+
+server.listen(0, common.mustCall(() => {
+  const port = server.address().port;
+
+  const client = h2.connect(`http://localhost:${port}`);
+  const request = client.request({
+    ':path': '/foobar',
+    ':method': 'POST',
+    ':scheme': 'http',
+    ':authority': `localhost:${port}`
+  });
+  request.resume();
+  request.end(testStr);
+  request.on('end', common.mustCall(function() {
+    client.close();
+    server.close();
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http2-compat-serverrequest-pipe.js b/test/js/node/test/parallel/test-http2-compat-serverrequest-pipe.js
new file mode 100644
index 0000000000..64beb6472b
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-compat-serverrequest-pipe.js
@@ -0,0 +1,49 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+const http2 = require('http2');
+const fs = require('fs');
+
+// Piping should work as expected with createWriteStream
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+const loc = fixtures.path('person-large.jpg');
+const fn = tmpdir.resolve('http2-url-tests.js');
+
+const server = http2.createServer();
+
+server.on('request', common.mustCall((req, res) => {
+  const dest = req.pipe(fs.createWriteStream(fn));
+  dest.on('finish', common.mustCall(() => {
+    assert.strictEqual(req.complete, true);
+    assert.strictEqual(fs.readFileSync(loc).length, fs.readFileSync(fn).length);
+    fs.unlinkSync(fn);
+    res.end();
+  }));
+}));
+
+server.listen(0, common.mustCall(() => {
+  const port = server.address().port;
+  const client = http2.connect(`http://localhost:${port}`);
+
+  let remaining = 2;
+  function maybeClose() {
+    if (--remaining === 0) {
+      server.close();
+      client.close();
+    }
+  }
+
+  const req = client.request({ ':method': 'POST' });
+  req.on('response', common.mustCall());
+  req.resume();
+  req.on('end', common.mustCall(maybeClose));
+  const str = fs.createReadStream(loc);
+  str.on('end', common.mustCall(maybeClose));
+  str.pipe(req);
+}));
diff --git a/test/js/node/test/parallel/test-http2-compat-serverresponse-drain.js b/test/js/node/test/parallel/test-http2-compat-serverresponse-drain.js
new file mode 100644
index 0000000000..7ccbb1f4d2
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-compat-serverresponse-drain.js
@@ -0,0 +1,43 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const h2 = require('http2');
+
+// Check that drain event is passed from Http2Stream
+
+const testString = 'tests';
+
+const server = h2.createServer();
+
+server.on('request', common.mustCall((req, res) => {
+  res.stream._writableState.highWaterMark = testString.length;
+  assert.strictEqual(res.write(testString), false);
+  res.on('drain', common.mustCall(() => res.end(testString)));
+}));
+
+server.listen(0, common.mustCall(() => {
+  const port = server.address().port;
+
+  const client = h2.connect(`http://localhost:${port}`);
+  const request = client.request({
+    ':path': '/foobar',
+    ':method': 'POST',
+    ':scheme': 'http',
+    ':authority': `localhost:${port}`
+  });
+  request.resume();
+  request.end();
+
+  let data = '';
+  request.setEncoding('utf8');
+  request.on('data', (chunk) => (data += chunk));
+
+  request.on('end', common.mustCall(function() {
+    assert.strictEqual(data, testString.repeat(2));
+    client.close();
+    server.close();
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http2-compat-serverresponse-end-after-statuses-without-body.js b/test/js/node/test/parallel/test-http2-compat-serverresponse-end-after-statuses-without-body.js
new file mode 100644
index 0000000000..ce8cbe600c
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-compat-serverresponse-end-after-statuses-without-body.js
@@ -0,0 +1,47 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const h2 = require('http2');
+
+// This test case ensures that calling of res.end after sending
+// 204, 205 and 304 HTTP statuses will not cause an error
+// See issue: https://github.com/nodejs/node/issues/21740
+
+const {
+  HTTP_STATUS_NO_CONTENT,
+  HTTP_STATUS_RESET_CONTENT,
+  HTTP_STATUS_NOT_MODIFIED
+} = h2.constants;
+
+const statusWithoutBody = [
+  HTTP_STATUS_NO_CONTENT,
+  HTTP_STATUS_RESET_CONTENT,
+  HTTP_STATUS_NOT_MODIFIED,
+];
+const STATUS_CODES_COUNT = statusWithoutBody.length;
+
+const server = h2.createServer(common.mustCall(function(req, res) {
+  res.writeHead(statusWithoutBody.pop());
+  res.end();
+}, STATUS_CODES_COUNT));
+
+server.listen(0, common.mustCall(function() {
+  const url = `http://localhost:${server.address().port}`;
+  const client = h2.connect(url, common.mustCall(() => {
+    let responseCount = 0;
+    const closeAfterResponse = () => {
+      if (STATUS_CODES_COUNT === ++responseCount) {
+        client.destroy();
+        server.close();
+      }
+    };
+
+    for (let i = 0; i < STATUS_CODES_COUNT; i++) {
+      const request = client.request();
+      request.on('response', common.mustCall(closeAfterResponse));
+    }
+
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http2-compat-serverresponse-finished.js b/test/js/node/test/parallel/test-http2-compat-serverresponse-finished.js
new file mode 100644
index 0000000000..a42d40227c
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-compat-serverresponse-finished.js
@@ -0,0 +1,49 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const h2 = require('http2');
+const net = require('net');
+
+// Http2ServerResponse.finished
+const server = h2.createServer();
+server.listen(0, common.mustCall(() => {
+  const port = server.address().port;
+  server.once('request', common.mustCall((request, response) => {
+    assert.ok(response.socket instanceof net.Socket);
+    assert.ok(response.connection instanceof net.Socket);
+    assert.strictEqual(response.socket, response.connection);
+
+    response.on('finish', common.mustCall(() => {
+      assert.strictEqual(response.socket, undefined);
+      assert.strictEqual(response.connection, undefined);
+      process.nextTick(common.mustCall(() => {
+        assert.ok(response.stream);
+        server.close();
+      }));
+    }));
+    assert.strictEqual(response.finished, false);
+    assert.strictEqual(response.writableEnded, false);
+    response.end();
+    assert.strictEqual(response.finished, true);
+    assert.strictEqual(response.writableEnded, true);
+  }));
+
+  const url = `http://localhost:${port}`;
+  const client = h2.connect(url, common.mustCall(() => {
+    const headers = {
+      ':path': '/',
+      ':method': 'GET',
+      ':scheme': 'http',
+      ':authority': `localhost:${port}`
+    };
+    const request = client.request(headers);
+    request.on('end', common.mustCall(() => {
+      client.close();
+    }));
+    request.end();
+    request.resume();
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http2-compat-serverresponse-flushheaders.js b/test/js/node/test/parallel/test-http2-compat-serverresponse-flushheaders.js
new file mode 100644
index 0000000000..7760bf8c7d
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-compat-serverresponse-flushheaders.js
@@ -0,0 +1,59 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const h2 = require('http2');
+
+// Http2ServerResponse.flushHeaders
+
+let serverResponse;
+
+const server = h2.createServer();
+server.listen(0, common.mustCall(function() {
+  const port = server.address().port;
+  server.once('request', common.mustCall(function(request, response) {
+    assert.strictEqual(response.headersSent, false);
+    assert.strictEqual(response._header, false); // Alias for headersSent
+    response.flushHeaders();
+    assert.strictEqual(response.headersSent, true);
+    assert.strictEqual(response._header, true);
+    response.flushHeaders(); // Idempotent
+
+    assert.throws(() => {
+      response.writeHead(400, { 'foo-bar': 'abc123' });
+    }, {
+      code: 'ERR_HTTP2_HEADERS_SENT'
+    });
+
+    response.on('finish', common.mustCall(function() {
+      server.close();
+      process.nextTick(() => {
+        response.flushHeaders(); // Idempotent
+      });
+    }));
+    serverResponse = response;
+  }));
+
+  const url = `http://localhost:${port}`;
+  const client = h2.connect(url, common.mustCall(function() {
+    const headers = {
+      ':path': '/',
+      ':method': 'GET',
+      ':scheme': 'http',
+      ':authority': `localhost:${port}`
+    };
+    const request = client.request(headers);
+    request.on('response', common.mustCall(function(headers, flags) {
+      assert.strictEqual(headers['foo-bar'], undefined);
+      assert.strictEqual(headers[':status'], 200);
+      serverResponse.end();
+    }, 1));
+    request.on('end', common.mustCall(function() {
+      client.close();
+    }));
+    request.end();
+    request.resume();
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http2-compat-serverresponse-headers-send-date.js b/test/js/node/test/parallel/test-http2-compat-serverresponse-headers-send-date.js
new file mode 100644
index 0000000000..b22b1f7304
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-compat-serverresponse-headers-send-date.js
@@ -0,0 +1,26 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto) { common.skip('missing crypto'); }
+const assert = require('assert');
+const http2 = require('http2');
+
+const server = http2.createServer(common.mustCall((request, response) => {
+  response.sendDate = false;
+  response.writeHead(200);
+  response.end();
+}));
+
+server.listen(0, common.mustCall(() => {
+  const session = http2.connect(`http://localhost:${server.address().port}`);
+  const req = session.request();
+
+  req.on('response', common.mustCall((headers, flags) => {
+    assert.strictEqual('Date' in headers, false);
+    assert.strictEqual('date' in headers, false);
+  }));
+
+  req.on('end', common.mustCall(() => {
+    session.close();
+    server.close();
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http2-compat-serverresponse-statuscode.js b/test/js/node/test/parallel/test-http2-compat-serverresponse-statuscode.js
new file mode 100644
index 0000000000..6064a5936e
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-compat-serverresponse-statuscode.js
@@ -0,0 +1,76 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const h2 = require('http2');
+
+// Http2ServerResponse should have a statusCode property
+
+const server = h2.createServer();
+server.listen(0, common.mustCall(function() {
+  const port = server.address().port;
+  server.once('request', common.mustCall(function(request, response) {
+    const expectedDefaultStatusCode = 200;
+    const realStatusCodes = {
+      continue: 100,
+      ok: 200,
+      multipleChoices: 300,
+      badRequest: 400,
+      internalServerError: 500
+    };
+    const fakeStatusCodes = {
+      tooLow: 99,
+      tooHigh: 600
+    };
+
+    assert.strictEqual(response.statusCode, expectedDefaultStatusCode);
+
+    // Setting the response.statusCode should not throw.
+    response.statusCode = realStatusCodes.ok;
+    response.statusCode = realStatusCodes.multipleChoices;
+    response.statusCode = realStatusCodes.badRequest;
+    response.statusCode = realStatusCodes.internalServerError;
+
+    assert.throws(() => {
+      response.statusCode = realStatusCodes.continue;
+    }, {
+      code: 'ERR_HTTP2_INFO_STATUS_NOT_ALLOWED',
+      name: 'RangeError'
+    });
+    assert.throws(() => {
+      response.statusCode = fakeStatusCodes.tooLow;
+    }, {
+      code: 'ERR_HTTP2_STATUS_INVALID',
+      name: 'RangeError'
+    });
+    assert.throws(() => {
+      response.statusCode = fakeStatusCodes.tooHigh;
+    }, {
+      code: 'ERR_HTTP2_STATUS_INVALID',
+      name: 'RangeError'
+    });
+
+    response.on('finish', common.mustCall(function() {
+      server.close();
+    }));
+    response.end();
+  }));
+
+  const url = `http://localhost:${port}`;
+  const client = h2.connect(url, common.mustCall(function() {
+    const headers = {
+      ':path': '/',
+      ':method': 'GET',
+      ':scheme': 'http',
+      ':authority': `localhost:${port}`
+    };
+    const request = client.request(headers);
+    request.on('end', common.mustCall(function() {
+      client.close();
+    }));
+    request.end();
+    request.resume();
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http2-compat-serverresponse-writehead-array.js b/test/js/node/test/parallel/test-http2-compat-serverresponse-writehead-array.js
new file mode 100644
index 0000000000..a0cb65d4bf
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-compat-serverresponse-writehead-array.js
@@ -0,0 +1,96 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const http2 = require('http2');
+
+// Http2ServerResponse.writeHead should support arrays and nested arrays
+
+{
+  const server = http2.createServer();
+  server.listen(0, common.mustCall(() => {
+    const port = server.address().port;
+
+    server.once('request', common.mustCall((request, response) => {
+      const returnVal = response.writeHead(200, [
+        ['foo', 'bar'],
+        ['foo', 'baz'],
+        ['ABC', 123],
+      ]);
+      assert.strictEqual(returnVal, response);
+      response.end(common.mustCall(() => { server.close(); }));
+    }));
+
+    const client = http2.connect(`http://localhost:${port}`, common.mustCall(() => {
+      const request = client.request();
+
+      request.on('response', common.mustCall((headers) => {
+        assert.strictEqual(headers.foo, 'bar, baz');
+        assert.strictEqual(headers.abc, '123');
+        assert.strictEqual(headers[':status'], 200);
+      }, 1));
+      request.on('end', common.mustCall(() => {
+        client.close();
+      }));
+      request.end();
+      request.resume();
+    }));
+  }));
+}
+
+{
+  const server = http2.createServer();
+  server.listen(0, common.mustCall(() => {
+    const port = server.address().port;
+
+    server.once('request', common.mustCall((request, response) => {
+      const returnVal = response.writeHead(200, ['foo', 'bar', 'foo', 'baz', 'ABC', 123]);
+      assert.strictEqual(returnVal, response);
+      response.end(common.mustCall(() => { server.close(); }));
+    }));
+
+    const client = http2.connect(`http://localhost:${port}`, common.mustCall(() => {
+      const request = client.request();
+
+      request.on('response', common.mustCall((headers) => {
+        assert.strictEqual(headers.foo, 'bar, baz');
+        assert.strictEqual(headers.abc, '123');
+        assert.strictEqual(headers[':status'], 200);
+      }, 1));
+      request.on('end', common.mustCall(() => {
+        client.close();
+      }));
+      request.end();
+      request.resume();
+    }));
+  }));
+}
+
+{
+  const server = http2.createServer();
+  server.listen(0, common.mustCall(() => {
+    const port = server.address().port;
+
+    server.once('request', common.mustCall((request, response) => {
+      try {
+        response.writeHead(200, ['foo', 'bar', 'ABC', 123, 'extra']);
+      } catch (err) {
+        assert.strictEqual(err.code, 'ERR_INVALID_ARG_VALUE');
+      }
+
+      response.end(common.mustCall(() => { server.close(); }));
+    }));
+
+    const client = http2.connect(`http://localhost:${port}`, common.mustCall(() => {
+      const request = client.request();
+
+      request.on('end', common.mustCall(() => {
+        client.close();
+      }));
+      request.end();
+      request.resume();
+    }));
+  }));
+}
diff --git a/test/js/node/test/parallel/test-http2-compat-serverresponse-writehead.js b/test/js/node/test/parallel/test-http2-compat-serverresponse-writehead.js
new file mode 100644
index 0000000000..8157dcbedd
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-compat-serverresponse-writehead.js
@@ -0,0 +1,56 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const h2 = require('http2');
+
+// Http2ServerResponse.writeHead should override previous headers
+
+const server = h2.createServer();
+server.listen(0, common.mustCall(function() {
+  const port = server.address().port;
+  server.once('request', common.mustCall(function(request, response) {
+    response.setHeader('foo-bar', 'def456');
+
+    // Override
+    const returnVal = response.writeHead(418, { 'foo-bar': 'abc123' });
+
+    assert.strictEqual(returnVal, response);
+
+    assert.throws(() => { response.writeHead(300); }, {
+      code: 'ERR_HTTP2_HEADERS_SENT'
+    });
+
+    response.on('finish', common.mustCall(function() {
+      server.close();
+      process.nextTick(common.mustCall(() => {
+        // The stream is invalid at this point,
+        // and this line verifies this does not throw.
+        response.writeHead(300);
+      }));
+    }));
+    response.end();
+  }));
+
+  const url = `http://localhost:${port}`;
+  const client = h2.connect(url, common.mustCall(function() {
+    const headers = {
+      ':path': '/',
+      ':method': 'GET',
+      ':scheme': 'http',
+      ':authority': `localhost:${port}`
+    };
+    const request = client.request(headers);
+    request.on('response', common.mustCall(function(headers) {
+      assert.strictEqual(headers['foo-bar'], 'abc123');
+      assert.strictEqual(headers[':status'], 418);
+    }, 1));
+    request.on('end', common.mustCall(function() {
+      client.close();
+    }));
+    request.end();
+    request.resume();
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http2-compat-serverresponse.js b/test/js/node/test/parallel/test-http2-compat-serverresponse.js
new file mode 100644
index 0000000000..fbde58693b
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-compat-serverresponse.js
@@ -0,0 +1,43 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const h2 = require('http2');
+
+// Http2ServerResponse should expose convenience properties
+
+const server = h2.createServer();
+server.listen(0, common.mustCall(function() {
+  const port = server.address().port;
+  server.once('request', common.mustCall(function(request, response) {
+    assert.strictEqual(response.req, request);
+
+    // Verify that writing to response.req is allowed.
+    response.req = null;
+
+    response.on('finish', common.mustCall(function() {
+      process.nextTick(() => {
+        server.close();
+      });
+    }));
+    response.end();
+  }));
+
+  const url = `http://localhost:${port}`;
+  const client = h2.connect(url, common.mustCall(function() {
+    const headers = {
+      ':path': '/foobar',
+      ':method': 'GET',
+      ':scheme': 'http',
+      ':authority': `localhost:${port}`
+    };
+    const request = client.request(headers);
+    request.on('end', common.mustCall(function() {
+      client.close();
+    }));
+    request.end();
+    request.resume();
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http2-compat-write-early-hints-invalid-argument-type.js b/test/js/node/test/parallel/test-http2-compat-write-early-hints-invalid-argument-type.js
new file mode 100644
index 0000000000..caf5824e07
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-compat-write-early-hints-invalid-argument-type.js
@@ -0,0 +1,42 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto) common.skip('missing crypto');
+
+const assert = require('node:assert');
+const http2 = require('node:http2');
+const debug = require('node:util').debuglog('test');
+
+const testResBody = 'response content';
+
+{
+  // Invalid object value
+
+  const server = http2.createServer();
+
+  server.on('request', common.mustCall((req, res) => {
+    debug('Server sending early hints...');
+    res.writeEarlyHints('this should not be here');
+
+    debug('Server sending full response...');
+    res.end(testResBody);
+  }));
+
+  server.listen(0);
+
+  server.on('listening', common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+    const req = client.request();
+
+    debug('Client sending request...');
+
+    req.on('headers', common.mustNotCall());
+
+    process.on('uncaughtException', (err) => {
+      debug(`Caught an exception: ${JSON.stringify(err)}`);
+      if (err.name === 'AssertionError') throw err;
+      assert.strictEqual(err.code, 'ERR_INVALID_ARG_TYPE');
+      process.exit(0);
+    });
+  }));
+}
diff --git a/test/js/node/test/parallel/test-http2-compat-write-early-hints-invalid-argument-value.js b/test/js/node/test/parallel/test-http2-compat-write-early-hints-invalid-argument-value.js
new file mode 100644
index 0000000000..d640f13fae
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-compat-write-early-hints-invalid-argument-value.js
@@ -0,0 +1,42 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto) common.skip('missing crypto');
+
+const assert = require('node:assert');
+const http2 = require('node:http2');
+const debug = require('node:util').debuglog('test');
+
+const testResBody = 'response content';
+
+{
+  // Invalid link header value
+
+  const server = http2.createServer();
+
+  server.on('request', common.mustCall((req, res) => {
+    debug('Server sending early hints...');
+    res.writeEarlyHints({ link: BigInt(100) });
+
+    debug('Server sending full response...');
+    res.end(testResBody);
+  }));
+
+  server.listen(0);
+
+  server.on('listening', common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+    const req = client.request();
+
+    debug('Client sending request...');
+
+    req.on('headers', common.mustNotCall());
+
+    process.on('uncaughtException', (err) => {
+      debug(`Caught an exception: ${JSON.stringify(err)}`);
+      if (err.name === 'AssertionError') throw err;
+      assert.strictEqual(err.code, 'ERR_INVALID_ARG_VALUE');
+      process.exit(0);
+    });
+  }));
+}
diff --git a/test/js/node/test/parallel/test-http2-compat-write-head-destroyed.js b/test/js/node/test/parallel/test-http2-compat-write-head-destroyed.js
new file mode 100644
index 0000000000..842bf0e9ab
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-compat-write-head-destroyed.js
@@ -0,0 +1,29 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const http2 = require('http2');
+
+// Check that writeHead, write and end do not crash in compatibility mode
+
+const server = http2.createServer(common.mustCall((req, res) => {
+  // Destroy the stream first
+  req.stream.destroy();
+
+  res.writeHead(200);
+  res.write('hello ');
+  res.end('world');
+}));
+
+server.listen(0, common.mustCall(() => {
+  const client = http2.connect(`http://localhost:${server.address().port}`);
+
+  const req = client.request();
+  req.on('response', common.mustNotCall());
+  req.on('close', common.mustCall((arg) => {
+    client.close();
+    server.close();
+  }));
+  req.resume();
+}));
diff --git a/test/js/node/test/parallel/test-http2-connect-tls-with-delay.js b/test/js/node/test/parallel/test-http2-connect-tls-with-delay.js
new file mode 100644
index 0000000000..0b3753ae38
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-connect-tls-with-delay.js
@@ -0,0 +1,50 @@
+// Flags: --expose-internals
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const http2 = require('http2');
+const tls = require('tls');
+const fixtures = require('../common/fixtures');
+
+const serverOptions = {
+  key: fixtures.readKey('agent1-key.pem'),
+  cert: fixtures.readKey('agent1-cert.pem')
+};
+
+const server = http2.createSecureServer(serverOptions, (req, res) => {
+  res.end();
+});
+
+server.listen(0, '127.0.0.1', common.mustCall(() => {
+  const options = {
+    ALPNProtocols: ['h2'],
+    host: '127.0.0.1',
+    servername: 'localhost',
+    port: server.address().port,
+    rejectUnauthorized: false
+  };
+
+  const socket = tls.connect(options, async () => {
+    socket.once('readable', () => {
+      const client = http2.connect(
+        'https://localhost:' + server.address().port,
+        { ...options, createConnection: () => socket }
+      );
+
+      client.once('remoteSettings', common.mustCall(() => {
+        const req = client.request({
+          ':path': '/'
+        });
+        req.on('data', () => req.resume());
+        req.on('end', common.mustCall(() => {
+          client.close();
+          req.close();
+          server.close();
+        }));
+        req.end();
+      }));
+    });
+  });
+}));
diff --git a/test/js/node/test/parallel/test-http2-cookies.js b/test/js/node/test/parallel/test-http2-cookies.js
new file mode 100644
index 0000000000..a270c1d73b
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-cookies.js
@@ -0,0 +1,60 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const h2 = require('http2');
+
+const server = h2.createServer();
+
+const setCookie = [
+  'a=b',
+  'c=d; Wed, 21 Oct 2015 07:28:00 GMT; Secure; HttpOnly',
+  'e=f',
+];
+
+// We use the lower-level API here
+server.on('stream', common.mustCall(onStream));
+
+function onStream(stream, headers, flags) {
+
+  assert.strictEqual(typeof headers.abc, 'string');
+  assert.strictEqual(headers.abc, '1, 2, 3');
+  assert.strictEqual(typeof headers.cookie, 'string');
+  assert.strictEqual(headers.cookie, 'a=b; c=d; e=f');
+
+  stream.respond({
+    'content-type': 'text/html',
+    ':status': 200,
+    'set-cookie': setCookie
+  });
+
+  stream.end('hello world');
+}
+
+server.listen(0);
+
+server.on('listening', common.mustCall(() => {
+
+  const client = h2.connect(`http://localhost:${server.address().port}`);
+
+  const req = client.request({
+    ':path': '/',
+    'abc': [1, 2, 3],
+    'cookie': ['a=b', 'c=d', 'e=f'],
+  });
+  req.resume();
+
+  req.on('response', common.mustCall((headers) => {
+    assert(Array.isArray(headers['set-cookie']));
+    assert.deepStrictEqual(headers['set-cookie'], setCookie);
+  }));
+
+  req.on('end', common.mustCall(() => {
+    server.close();
+    client.close();
+  }));
+  req.end();
+
+}));
diff --git a/test/js/node/test/parallel/test-http2-date-header.js b/test/js/node/test/parallel/test-http2-date-header.js
new file mode 100644
index 0000000000..2b63e1b789
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-date-header.js
@@ -0,0 +1,29 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const http2 = require('http2');
+
+const server = http2.createServer();
+
+server.on('stream', common.mustCall((stream) => {
+  // Date header is defaulted
+  stream.respond();
+  stream.end();
+}));
+
+server.listen(0, common.mustCall(() => {
+  const client = http2.connect(`http://localhost:${server.address().port}`);
+  const req = client.request();
+  req.on('response', common.mustCall((headers) => {
+    // The date header must be set to a non-invalid value
+    assert.notStrictEqual((new Date()).toString(), 'Invalid Date');
+  }));
+  req.resume();
+  req.on('end', common.mustCall(() => {
+    server.close();
+    client.close();
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http2-dont-override.js b/test/js/node/test/parallel/test-http2-dont-override.js
new file mode 100644
index 0000000000..3f87e14be1
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-dont-override.js
@@ -0,0 +1,49 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const http2 = require('http2');
+
+const options = {};
+
+const server = http2.createServer(options);
+
+// Options are defaulted but the options are not modified
+assert.deepStrictEqual(Object.keys(options), []);
+
+server.on('stream', common.mustCall((stream) => {
+  const headers = {};
+  const options = {};
+  stream.respond(headers, options);
+
+  // The headers are defaulted but the original object is not modified
+  assert.deepStrictEqual(Object.keys(headers), []);
+
+  // Options are defaulted but the original object is not modified
+  assert.deepStrictEqual(Object.keys(options), []);
+
+  stream.end();
+}));
+
+server.listen(0, common.mustCall(() => {
+  const client = http2.connect(`http://localhost:${server.address().port}`);
+
+  const headers = {};
+  const options = {};
+
+  const req = client.request(headers, options);
+
+  // The headers are defaulted but the original object is not modified
+  assert.deepStrictEqual(Object.keys(headers), []);
+
+  // Options are defaulted but the original object is not modified
+  assert.deepStrictEqual(Object.keys(options), []);
+
+  req.resume();
+  req.on('end', common.mustCall(() => {
+    server.close();
+    client.close();
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http2-large-write-close.js b/test/js/node/test/parallel/test-http2-large-write-close.js
new file mode 100644
index 0000000000..f9dee357d6
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-large-write-close.js
@@ -0,0 +1,44 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const fixtures = require('../common/fixtures');
+const http2 = require('http2');
+
+const content = Buffer.alloc(1e5, 0x44);
+
+const server = http2.createSecureServer({
+  key: fixtures.readKey('agent1-key.pem'),
+  cert: fixtures.readKey('agent1-cert.pem')
+});
+server.on('stream', common.mustCall((stream) => {
+  stream.respond({
+    'Content-Type': 'application/octet-stream',
+    'Content-Length': (content.length.toString() * 2),
+    'Vary': 'Accept-Encoding'
+  });
+
+  stream.write(content);
+  stream.write(content);
+  stream.end();
+  stream.close();
+}));
+
+server.listen(0, common.mustCall(() => {
+  const client = http2.connect(`https://localhost:${server.address().port}`,
+                               { rejectUnauthorized: false });
+
+  const req = client.request({ ':path': '/' });
+  req.end();
+
+  let receivedBufferLength = 0;
+  req.on('data', common.mustCallAtLeast((buf) => {
+    receivedBufferLength += buf.length;
+  }, 1));
+  req.on('close', common.mustCall(() => {
+    assert.strictEqual(receivedBufferLength, content.length * 2);
+    client.close();
+    server.close();
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http2-large-write-destroy.js b/test/js/node/test/parallel/test-http2-large-write-destroy.js
new file mode 100644
index 0000000000..b59c66bb04
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-large-write-destroy.js
@@ -0,0 +1,41 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const fixtures = require('../common/fixtures');
+const http2 = require('http2');
+
+// This test will result in a crash due to a missed CHECK in C++ or
+// a straight-up segfault if the C++ doesn't send RST_STREAM through
+// properly when calling destroy.
+
+const content = Buffer.alloc(60000, 0x44);
+
+const server = http2.createSecureServer({
+  key: fixtures.readKey('agent1-key.pem'),
+  cert: fixtures.readKey('agent1-cert.pem')
+});
+server.on('stream', common.mustCall((stream) => {
+  stream.respond({
+    'Content-Type': 'application/octet-stream',
+    'Content-Length': (content.length.toString() * 2),
+    'Vary': 'Accept-Encoding'
+  }, { waitForTrailers: true });
+
+  stream.write(content);
+  stream.destroy();
+}));
+
+server.listen(0, common.mustCall(() => {
+  const client = http2.connect(`https://localhost:${server.address().port}`,
+                               { rejectUnauthorized: false });
+
+  const req = client.request({ ':path': '/' });
+  req.end();
+  req.resume(); // Otherwise close won't be emitted if there's pending data.
+
+  req.on('close', common.mustCall(() => {
+    client.close();
+    server.close();
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http2-large-write-multiple-requests.js b/test/js/node/test/parallel/test-http2-large-write-multiple-requests.js
new file mode 100644
index 0000000000..bcbb1434cb
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-large-write-multiple-requests.js
@@ -0,0 +1,53 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+// This tests that the http2 server sends data early when it accumulates
+// enough from ongoing requests to avoid DoS as mitigation for
+// CVE-2019-9517 and CVE-2019-9511.
+// Added by https://github.com/nodejs/node/commit/8a4a193
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+const http2 = require('http2');
+
+const content = fixtures.readSync('person-large.jpg');
+
+const server = http2.createServer({
+  maxSessionMemory: 1000
+});
+let streamCount = 0;
+server.on('stream', (stream, headers) => {
+  stream.respond({
+    'content-type': 'image/jpeg',
+    ':status': 200
+  });
+  stream.end(content);
+  console.log('server sends content', ++streamCount);
+});
+
+server.listen(0, common.mustCall(() => {
+  const client = http2.connect(`http://localhost:${server.address().port}/`);
+
+  let endCount = 0;
+  let finished = 0;
+  for (let i = 0; i < 100; i++) {
+    const req = client.request({ ':path': '/' }).end();
+    const chunks = [];
+    req.on('data', (chunk) => {
+      chunks.push(chunk);
+    });
+    req.on('end', common.mustCall(() => {
+      console.log('client receives content', ++endCount);
+      assert.deepStrictEqual(Buffer.concat(chunks), content);
+
+      if (++finished === 100) {
+        client.close();
+        server.close();
+      }
+    }));
+    req.on('error', (e) => {
+      console.log('client error', e);
+    });
+  }
+}));
diff --git a/test/js/node/test/parallel/test-http2-large-writes-session-memory-leak.js b/test/js/node/test/parallel/test-http2-large-writes-session-memory-leak.js
new file mode 100644
index 0000000000..641923c06c
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-large-writes-session-memory-leak.js
@@ -0,0 +1,55 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const fixtures = require('../common/fixtures');
+const http2 = require('http2');
+
+// Regression test for https://github.com/nodejs/node/issues/29223.
+// There was a "leak" in the accounting of session memory leading
+// to streams eventually failing with NGHTTP2_ENHANCE_YOUR_CALM.
+
+const server = http2.createSecureServer({
+  key: fixtures.readKey('agent2-key.pem'),
+  cert: fixtures.readKey('agent2-cert.pem'),
+});
+
+// Simple server that sends 200k and closes the stream.
+const data200k = 'a'.repeat(200 * 1024);
+server.on('stream', (stream) => {
+  stream.write(data200k);
+  stream.end();
+});
+
+server.listen(0, common.mustCall(() => {
+  const client = http2.connect(`https://localhost:${server.address().port}`, {
+    ca: fixtures.readKey('agent2-cert.pem'),
+    servername: 'agent2',
+
+    // Set maxSessionMemory to 1MB so the leak causes errors faster.
+    maxSessionMemory: 1
+  });
+
+  // Repeatedly create a new stream and read the incoming data. Even though we
+  // only have one stream active at a time, prior to the fix for #29223,
+  // session memory would steadily increase and we'd eventually hit the 1MB
+  // maxSessionMemory limit and get NGHTTP2_ENHANCE_YOUR_CALM errors trying to
+  // create new streams.
+  let streamsLeft = 50;
+  function newStream() {
+    const stream = client.request({ ':path': '/' });
+
+    stream.on('data', () => { });
+
+    stream.on('close', () => {
+      if (streamsLeft-- > 0) {
+        newStream();
+      } else {
+        client.destroy();
+        server.close();
+      }
+    });
+  }
+
+  newStream();
+}));
diff --git a/test/js/node/test/parallel/test-http2-malformed-altsvc.js b/test/js/node/test/parallel/test-http2-malformed-altsvc.js
new file mode 100644
index 0000000000..28c0fb46b4
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-malformed-altsvc.js
@@ -0,0 +1,39 @@
+'use strict';
+
+const common = require('../common');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const http2 = require('http2');
+const net = require('net');
+const h2test = require('../common/http2');
+
+const server = http2.createServer();
+server.on('stream', common.mustNotCall());
+
+const settings = new h2test.SettingsFrame();
+const settingsAck = new h2test.SettingsFrame(true);
+const altsvc = new h2test.AltSvcFrame((1 << 14) + 1);
+
+server.listen(0, () => {
+  const client = net.connect(server.address().port, () => {
+    client.write(h2test.kClientMagic, () => {
+      client.write(settings.data, () => {
+        client.write(settingsAck.data);
+        // Prior to nghttp2 1.31.1, sending this malformed altsvc frame
+        // would cause a segfault. This test is successful if a segfault
+        // does not occur.
+        client.write(altsvc.data, common.mustCall(() => {
+          client.destroy();
+        }));
+      });
+    });
+  });
+
+  // An error may or may not be emitted on the client side, we don't care
+  // either way if it is, but we don't want to die if it is.
+  client.on('error', () => {});
+  client.on('close', common.mustCall(() => server.close()));
+  client.resume();
+});
diff --git a/test/js/node/test/parallel/test-http2-many-writes-and-destroy.js b/test/js/node/test/parallel/test-http2-many-writes-and-destroy.js
new file mode 100644
index 0000000000..78db76e001
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-many-writes-and-destroy.js
@@ -0,0 +1,30 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const http2 = require('http2');
+
+{
+  const server = http2.createServer((req, res) => {
+    req.pipe(res);
+  });
+
+  server.listen(0, () => {
+    const url = `http://localhost:${server.address().port}`;
+    const client = http2.connect(url);
+    const req = client.request({ ':method': 'POST' });
+
+    for (let i = 0; i < 4000; i++) {
+      req.write(Buffer.alloc(6));
+    }
+
+    req.on('close', common.mustCall(() => {
+      console.log('(req onclose)');
+      server.close();
+      client.close();
+    }));
+
+    req.once('data', common.mustCall(() => req.destroy()));
+  });
+}
diff --git a/test/js/node/test/parallel/test-http2-max-session-memory-leak.js b/test/js/node/test/parallel/test-http2-max-session-memory-leak.js
new file mode 100644
index 0000000000..476c605783
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-max-session-memory-leak.js
@@ -0,0 +1,46 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const http2 = require('http2');
+
+// Regression test for https://github.com/nodejs/node/issues/27416.
+// Check that received data is accounted for correctly in the maxSessionMemory
+// mechanism.
+
+const bodyLength = 8192;
+const maxSessionMemory = 1;  // 1 MiB
+const requestCount = 1000;
+
+const server = http2.createServer({ maxSessionMemory });
+server.on('stream', (stream) => {
+  stream.respond();
+  stream.end();
+});
+
+server.listen(common.mustCall(() => {
+  const client = http2.connect(`http://localhost:${server.address().port}`, {
+    maxSessionMemory
+  });
+
+  function request() {
+    return new Promise((resolve, reject) => {
+      const stream = client.request({
+        ':method': 'POST',
+        'content-length': bodyLength
+      });
+      stream.on('error', reject);
+      stream.on('response', resolve);
+      stream.end('a'.repeat(bodyLength));
+    });
+  }
+
+  (async () => {
+    for (let i = 0; i < requestCount; i++) {
+      await request();
+    }
+
+    client.close();
+    server.close();
+  })().then(common.mustCall());
+}));
diff --git a/test/js/node/test/parallel/test-http2-methods.js b/test/js/node/test/parallel/test-http2-methods.js
new file mode 100644
index 0000000000..936a264e99
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-methods.js
@@ -0,0 +1,49 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const h2 = require('http2');
+
+const server = h2.createServer();
+
+const methods = ['GET', 'POST', 'PATCH', 'FOO', 'A_B_C'];
+let expected = methods.length;
+
+// We use the lower-level API here
+server.on('stream', common.mustCall(onStream, expected));
+
+function onStream(stream, headers, flags) {
+  const method = headers[':method'];
+  assert.notStrictEqual(method, undefined);
+  assert(methods.includes(method), `method ${method} not included`);
+  stream.respond({
+    'content-type': 'text/html',
+    ':status': 200
+  });
+  stream.end('hello world');
+}
+
+server.listen(0);
+
+server.on('listening', common.mustCall(() => {
+
+  const client = h2.connect(`http://localhost:${server.address().port}`);
+
+  const headers = { ':path': '/' };
+
+  methods.forEach((method) => {
+    headers[':method'] = method;
+    const req = client.request(headers);
+    req.on('response', common.mustCall());
+    req.resume();
+    req.on('end', common.mustCall(() => {
+      if (--expected === 0) {
+        server.close();
+        client.close();
+      }
+    }));
+    req.end();
+  });
+}));
diff --git a/test/js/node/test/parallel/test-http2-multiplex.js b/test/js/node/test/parallel/test-http2-multiplex.js
new file mode 100644
index 0000000000..4c157d0ede
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-multiplex.js
@@ -0,0 +1,58 @@
+'use strict';
+
+// Tests opening 100 concurrent simultaneous uploading streams over a single
+// connection and makes sure that the data for each is appropriately echoed.
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const http2 = require('http2');
+const Countdown = require('../common/countdown');
+
+const server = http2.createServer();
+
+const count = 100;
+
+server.on('stream', common.mustCall((stream) => {
+  stream.respond();
+  stream.pipe(stream);
+}, count));
+
+server.listen(0, common.mustCall(() => {
+  const client = http2.connect(`http://localhost:${server.address().port}`);
+  client.setMaxListeners(100);
+
+  const countdown = new Countdown(count, () => {
+    server.close();
+    client.close();
+  });
+
+  function doRequest() {
+    const req = client.request({ ':method': 'POST' });
+
+    let data = '';
+    req.setEncoding('utf8');
+    req.on('data', (chunk) => data += chunk);
+    req.on('end', common.mustCall(() => {
+      assert.strictEqual(data, 'abcdefghij');
+    }));
+    req.on('close', common.mustCall(() => countdown.dec()));
+
+    let n = 0;
+    function writeChunk() {
+      if (n < 10) {
+        req.write(String.fromCharCode(97 + n));
+        setTimeout(writeChunk, 10);
+      } else {
+        req.end();
+      }
+      n++;
+    }
+
+    writeChunk();
+  }
+
+  for (let n = 0; n < count; n++)
+    doRequest();
+}));
diff --git a/test/js/node/test/parallel/test-http2-multistream-destroy-on-read-tls.js b/test/js/node/test/parallel/test-http2-multistream-destroy-on-read-tls.js
new file mode 100644
index 0000000000..91cbec6b2d
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-multistream-destroy-on-read-tls.js
@@ -0,0 +1,47 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const fixtures = require('../common/fixtures');
+const http2 = require('http2');
+
+// Regression test for https://github.com/nodejs/node/issues/29353.
+// Test that it’s okay for an HTTP2 + TLS server to destroy a stream instance
+// while reading it.
+
+const server = http2.createSecureServer({
+  key: fixtures.readKey('agent2-key.pem'),
+  cert: fixtures.readKey('agent2-cert.pem')
+});
+
+const filenames = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'];
+
+server.on('stream', common.mustCall((stream) => {
+  function write() {
+    stream.write('a'.repeat(10240));
+    stream.once('drain', write);
+  }
+  write();
+}, filenames.length));
+
+server.listen(0, common.mustCall(() => {
+  const client = http2.connect(`https://localhost:${server.address().port}`, {
+    ca: fixtures.readKey('agent2-cert.pem'),
+    servername: 'agent2'
+  });
+
+  let destroyed = 0;
+  for (const entry of filenames) {
+    const stream = client.request({
+      ':path': `/${entry}`
+    });
+    stream.once('data', common.mustCall(() => {
+      stream.destroy();
+
+      if (++destroyed === filenames.length) {
+        client.destroy();
+        server.close();
+      }
+    }));
+  }
+}));
diff --git a/test/js/node/test/parallel/test-http2-no-wanttrailers-listener.js b/test/js/node/test/parallel/test-http2-no-wanttrailers-listener.js
new file mode 100644
index 0000000000..09293f2584
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-no-wanttrailers-listener.js
@@ -0,0 +1,32 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const h2 = require('http2');
+
+const server = h2.createServer();
+
+// We use the lower-level API here
+server.on('stream', common.mustCall(onStream));
+
+function onStream(stream, headers, flags) {
+  stream.respond(undefined, { waitForTrailers: true });
+  // There is no wantTrailers handler so this should close naturally
+  // without hanging. If the test completes without timing out, then
+  // it passes.
+  stream.end('ok');
+}
+
+server.listen(0);
+
+server.on('listening', common.mustCall(function() {
+  const client = h2.connect(`http://localhost:${this.address().port}`);
+  const req = client.request();
+  req.resume();
+  req.on('trailers', common.mustNotCall());
+  req.on('close', common.mustCall(() => {
+    server.close();
+    client.close();
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http2-options-server-response.js b/test/js/node/test/parallel/test-http2-options-server-response.js
new file mode 100644
index 0000000000..6f1ae1881d
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-options-server-response.js
@@ -0,0 +1,34 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const h2 = require('http2');
+
+class MyServerResponse extends h2.Http2ServerResponse {
+  status(code) {
+    return this.writeHead(code, { 'Content-Type': 'text/plain' });
+  }
+}
+
+const server = h2.createServer({
+  Http2ServerResponse: MyServerResponse
+}, (req, res) => {
+  res.status(200);
+  res.end();
+});
+server.listen(0);
+
+server.on('listening', common.mustCall(() => {
+
+  const client = h2.connect(`http://localhost:${server.address().port}`);
+  const req = client.request({ ':path': '/' });
+
+  req.on('response', common.mustCall());
+
+  req.resume();
+  req.on('end', common.mustCall(() => {
+    server.close();
+    client.destroy();
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http2-pipe-named-pipe.js b/test/js/node/test/parallel/test-http2-pipe-named-pipe.js
new file mode 100644
index 0000000000..eb9b1b568c
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-pipe-named-pipe.js
@@ -0,0 +1,54 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+const http2 = require('http2');
+const fs = require('fs');
+const net = require('net');
+
+// HTTP/2 servers can listen on a named pipe.
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+const loc = fixtures.path('person-large.jpg');
+const fn = tmpdir.resolve('person-large.jpg');
+
+const server = http2.createServer();
+
+server.on('stream', common.mustCall((stream) => {
+  const dest = stream.pipe(fs.createWriteStream(fn));
+
+  stream.on('end', common.mustCall(() => {
+    stream.respond();
+    stream.end();
+  }));
+
+  dest.on('finish', common.mustCall(() => {
+    assert.strictEqual(fs.readFileSync(fn).length,
+                       fs.readFileSync(loc).length);
+  }));
+}));
+
+server.listen(common.PIPE, common.mustCall(() => {
+  const client = http2.connect('http://localhost', {
+    createConnection(url) {
+      return net.connect(server.address());
+    }
+  });
+
+  const req = client.request({ ':method': 'POST' });
+  req.on('response', common.mustCall());
+  req.resume();
+
+  req.on('close', common.mustCall(() => {
+    server.close();
+    client.close();
+  }));
+
+  const str = fs.createReadStream(loc);
+  str.on('end', common.mustCall());
+  str.pipe(req);
+}));
diff --git a/test/js/node/test/parallel/test-http2-pipe.js b/test/js/node/test/parallel/test-http2-pipe.js
new file mode 100644
index 0000000000..ebd89e23d8
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-pipe.js
@@ -0,0 +1,47 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+const http2 = require('http2');
+const fs = require('fs');
+
+// Piping should work as expected with createWriteStream
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+const loc = fixtures.path('person-large.jpg');
+const fn = tmpdir.resolve('http2-url-tests.js');
+
+const server = http2.createServer();
+
+server.on('stream', common.mustCall((stream) => {
+  const dest = stream.pipe(fs.createWriteStream(fn));
+
+  dest.on('finish', () => {
+    assert.strictEqual(fs.readFileSync(loc).length,
+                       fs.readFileSync(fn).length);
+  });
+  stream.respond();
+  stream.end();
+}));
+
+server.listen(0, common.mustCall(() => {
+  const client = http2.connect(`http://localhost:${server.address().port}`);
+
+  const req = client.request({ ':method': 'POST' });
+
+  req.on('response', common.mustCall());
+  req.resume();
+
+  req.on('close', common.mustCall(() => {
+    server.close();
+    client.close();
+  }));
+
+  const str = fs.createReadStream(loc);
+  str.on('end', common.mustCall());
+  str.pipe(req);
+}));
diff --git a/test/js/node/test/parallel/test-http2-removed-header-stays-removed.js b/test/js/node/test/parallel/test-http2-removed-header-stays-removed.js
new file mode 100644
index 0000000000..663249749a
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-removed-header-stays-removed.js
@@ -0,0 +1,22 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto) { common.skip('missing crypto'); }
+const assert = require('assert');
+const http2 = require('http2');
+
+const server = http2.createServer(common.mustCall((request, response) => {
+  response.setHeader('date', 'snacks o clock');
+  response.end();
+}));
+
+server.listen(0, common.mustCall(() => {
+  const session = http2.connect(`http://localhost:${server.address().port}`);
+  const req = session.request();
+  req.on('response', (headers, flags) => {
+    assert.strictEqual(headers.date, 'snacks o clock');
+  });
+  req.on('end', () => {
+    session.close();
+    server.close();
+  });
+}));
diff --git a/test/js/node/test/parallel/test-http2-request-remove-connect-listener.js b/test/js/node/test/parallel/test-http2-request-remove-connect-listener.js
new file mode 100644
index 0000000000..61de140c22
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-request-remove-connect-listener.js
@@ -0,0 +1,28 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const http2 = require('http2');
+
+
+const server = http2.createServer();
+server.on('stream', common.mustCall((stream) => {
+  stream.respond();
+  stream.end();
+}));
+
+server.listen(0, common.mustCall(() => {
+  const client = http2.connect(`http://localhost:${server.address().port}`);
+  const req = client.request();
+  client.once('connect', common.mustCall());
+
+  req.on('response', common.mustCall(() => {
+    assert.strictEqual(client.listenerCount('connect'), 0);
+  }));
+  req.on('close', common.mustCall(() => {
+    server.close();
+    client.close();
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http2-request-response-proto.js b/test/js/node/test/parallel/test-http2-request-response-proto.js
new file mode 100644
index 0000000000..49b15dfc70
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-request-response-proto.js
@@ -0,0 +1,18 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const http2 = require('http2');
+
+const {
+  Http2ServerRequest,
+  Http2ServerResponse,
+} = http2;
+
+const protoRequest = { __proto__: Http2ServerRequest.prototype };
+const protoResponse = { __proto__: Http2ServerResponse.prototype };
+
+assert.strictEqual(protoRequest instanceof Http2ServerRequest, true);
+assert.strictEqual(protoResponse instanceof Http2ServerResponse, true);
diff --git a/test/js/node/test/parallel/test-http2-res-corked.js b/test/js/node/test/parallel/test-http2-res-corked.js
new file mode 100644
index 0000000000..5a6c623edf
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-res-corked.js
@@ -0,0 +1,54 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto) { common.skip('missing crypto'); }
+
+// Test for Http2ServerResponse#[writableCorked,cork,uncork]
+
+const { strictEqual } = require('assert');
+const http2 = require('http2');
+
+{
+  let corksLeft = 0;
+  const server = http2.createServer(common.mustCall((req, res) => {
+    strictEqual(res.writableCorked, corksLeft);
+    res.write(Buffer.from('1'.repeat(1024)));
+    res.cork();
+    corksLeft++;
+    strictEqual(res.writableCorked, corksLeft);
+    res.write(Buffer.from('1'.repeat(1024)));
+    res.cork();
+    corksLeft++;
+    strictEqual(res.writableCorked, corksLeft);
+    res.write(Buffer.from('1'.repeat(1024)));
+    res.cork();
+    corksLeft++;
+    strictEqual(res.writableCorked, corksLeft);
+    res.write(Buffer.from('1'.repeat(1024)));
+    res.cork();
+    corksLeft++;
+    strictEqual(res.writableCorked, corksLeft);
+    res.uncork();
+    corksLeft--;
+    strictEqual(res.writableCorked, corksLeft);
+    res.uncork();
+    corksLeft--;
+    strictEqual(res.writableCorked, corksLeft);
+    res.uncork();
+    corksLeft--;
+    strictEqual(res.writableCorked, corksLeft);
+    res.uncork();
+    corksLeft--;
+    strictEqual(res.writableCorked, corksLeft);
+    res.end();
+  }));
+  server.listen(0, common.mustCall(() => {
+    const URL = `http://localhost:${server.address().port}`;
+    const client = http2.connect(URL);
+    const req = client.request();
+    req.on('data', common.mustCall(2));
+    req.on('end', common.mustCall(() => {
+      server.close();
+      client.close();
+    }));
+  }));
+}
diff --git a/test/js/node/test/parallel/test-http2-respond-file-204.js b/test/js/node/test/parallel/test-http2-respond-file-204.js
new file mode 100644
index 0000000000..0c59b0e729
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-respond-file-204.js
@@ -0,0 +1,42 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+const http2 = require('http2');
+
+const {
+  HTTP2_HEADER_CONTENT_TYPE,
+  HTTP2_HEADER_STATUS
+} = http2.constants;
+
+const fname = fixtures.path('elipses.txt');
+
+const server = http2.createServer();
+server.on('stream', (stream) => {
+  assert.throws(() => {
+    stream.respondWithFile(fname, {
+      [HTTP2_HEADER_STATUS]: 204,
+      [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain'
+    });
+  }, {
+    code: 'ERR_HTTP2_PAYLOAD_FORBIDDEN',
+    name: 'Error',
+    message: 'Responses with 204 status must not have a payload'
+  });
+  stream.respond({});
+  stream.end();
+});
+server.listen(0, () => {
+  const client = http2.connect(`http://localhost:${server.address().port}`);
+  const req = client.request();
+  req.on('response', common.mustCall());
+  req.on('data', common.mustNotCall());
+  req.on('end', common.mustCall(() => {
+    client.close();
+    server.close();
+  }));
+  req.end();
+});
diff --git a/test/js/node/test/parallel/test-http2-respond-file-compat.js b/test/js/node/test/parallel/test-http2-respond-file-compat.js
new file mode 100644
index 0000000000..0205f2d0d8
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-respond-file-compat.js
@@ -0,0 +1,24 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const http2 = require('http2');
+const fixtures = require('../common/fixtures');
+
+const fname = fixtures.path('elipses.txt');
+
+const server = http2.createServer(common.mustCall((request, response) => {
+  response.stream.respondWithFile(fname);
+}));
+server.listen(0, () => {
+  const client = http2.connect(`http://localhost:${server.address().port}`);
+  const req = client.request();
+  req.on('response', common.mustCall());
+  req.on('end', common.mustCall(() => {
+    client.close();
+    server.close();
+  }));
+  req.end();
+  req.resume();
+});
diff --git a/test/js/node/test/parallel/test-http2-respond-file-error-dir.js b/test/js/node/test/parallel/test-http2-respond-file-error-dir.js
new file mode 100644
index 0000000000..155e005432
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-respond-file-error-dir.js
@@ -0,0 +1,41 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const http2 = require('http2');
+const assert = require('assert');
+
+const server = http2.createServer();
+server.on('stream', (stream) => {
+  stream.respondWithFile(process.cwd(), {
+    'content-type': 'text/plain'
+  }, {
+    onError(err) {
+      common.expectsError({
+        code: 'ERR_HTTP2_SEND_FILE',
+        name: 'Error',
+        message: 'Directories cannot be sent'
+      })(err);
+
+      stream.respond({ ':status': 404 });
+      stream.end();
+    },
+    statCheck: common.mustNotCall()
+  });
+});
+server.listen(0, () => {
+
+  const client = http2.connect(`http://localhost:${server.address().port}`);
+  const req = client.request();
+
+  req.on('response', common.mustCall((headers) => {
+    assert.strictEqual(headers[':status'], 404);
+  }));
+  req.on('data', common.mustNotCall());
+  req.on('end', common.mustCall(() => {
+    client.close();
+    server.close();
+  }));
+  req.end();
+});
diff --git a/test/js/node/test/parallel/test-http2-respond-file-error-pipe-offset.js b/test/js/node/test/parallel/test-http2-respond-file-error-pipe-offset.js
new file mode 100644
index 0000000000..bd043e42f4
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-respond-file-error-pipe-offset.js
@@ -0,0 +1,65 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+if (common.isWindows)
+  common.skip('no mkfifo on Windows');
+const child_process = require('child_process');
+const fs = require('fs');
+const http2 = require('http2');
+const assert = require('assert');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+const pipeName = tmpdir.resolve('pipe');
+
+const mkfifo = child_process.spawnSync('mkfifo', [ pipeName ]);
+if (mkfifo.error && mkfifo.error.code === 'ENOENT') {
+  common.skip('missing mkfifo');
+}
+
+const server = http2.createServer();
+server.on('stream', (stream) => {
+  stream.respondWithFile(pipeName, {
+    'content-type': 'text/plain'
+  }, {
+    offset: 10,
+    onError(err) {
+      common.expectsError({
+        code: 'ERR_HTTP2_SEND_FILE_NOSEEK',
+        name: 'Error',
+        message: 'Offset or length can only be specified for regular files'
+      })(err);
+
+      stream.respond({ ':status': 404 });
+      stream.end();
+    },
+    statCheck: common.mustNotCall()
+  });
+});
+server.listen(0, () => {
+
+  const client = http2.connect(`http://localhost:${server.address().port}`);
+  const req = client.request();
+
+  req.on('response', common.mustCall((headers) => {
+    assert.strictEqual(headers[':status'], 404);
+  }));
+  req.on('data', common.mustNotCall());
+  req.on('end', common.mustCall(() => {
+    client.close();
+    server.close();
+  }));
+  req.end();
+});
+
+fs.writeFile(pipeName, 'Hello, world!\n', common.mustCall((err) => {
+  // It's possible for the reading end of the pipe to get the expected error
+  // and break everything down before we're finished, so allow `EPIPE` but
+  // no other errors.
+  if (err?.code !== 'EPIPE') {
+    assert.ifError(err);
+  }
+}));
diff --git a/test/js/node/test/parallel/test-http2-respond-with-file-connection-abort.js b/test/js/node/test/parallel/test-http2-respond-with-file-connection-abort.js
new file mode 100644
index 0000000000..d5ed364570
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-respond-with-file-connection-abort.js
@@ -0,0 +1,32 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const http2 = require('http2');
+const net = require('net');
+
+const {
+  HTTP2_HEADER_CONTENT_TYPE
+} = http2.constants;
+
+const server = http2.createServer();
+server.on('stream', common.mustCall((stream) => {
+  stream.on('error', (err) => assert.strictEqual(err.code, 'ECONNRESET'));
+  stream.respondWithFile(process.execPath, {
+    [HTTP2_HEADER_CONTENT_TYPE]: 'application/octet-stream'
+  });
+}));
+
+server.listen(0, common.mustCall(() => {
+  const client = http2.connect(`http://localhost:${server.address().port}`);
+  const req = client.request();
+
+  req.on('response', common.mustCall());
+  req.once('data', common.mustCall(() => {
+    net.Socket.prototype.destroy.call(client.socket);
+    server.close();
+  }));
+  req.end();
+}));
diff --git a/test/js/node/test/parallel/test-http2-serve-file.js b/test/js/node/test/parallel/test-http2-serve-file.js
new file mode 100644
index 0000000000..7b73fe639e
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-serve-file.js
@@ -0,0 +1,79 @@
+'use strict';
+
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const http2 = require('http2');
+const fs = require('fs');
+const tls = require('tls');
+
+const ajs_data = fixtures.readSync('a.js', 'utf8');
+
+const {
+  HTTP2_HEADER_PATH,
+  HTTP2_HEADER_STATUS
+} = http2.constants;
+
+const key = fixtures.readKey('agent8-key.pem', 'binary');
+const cert = fixtures.readKey('agent8-cert.pem', 'binary');
+const ca = fixtures.readKey('fake-startcom-root-cert.pem', 'binary');
+
+const server = http2.createSecureServer({ key, cert });
+
+server.on('stream', (stream, headers) => {
+  const name = headers[HTTP2_HEADER_PATH].slice(1);
+  const file = fixtures.path(name);
+  fs.stat(file, (err, stat) => {
+    if (err != null || stat.isDirectory()) {
+      stream.respond({ [HTTP2_HEADER_STATUS]: 404 });
+      stream.end();
+    } else {
+      stream.respond({ [HTTP2_HEADER_STATUS]: 200 });
+      const str = fs.createReadStream(file);
+      str.pipe(stream);
+    }
+  });
+});
+
+server.listen(0, () => {
+
+  const secureContext = tls.createSecureContext({ ca });
+  const client = http2.connect(`https://localhost:${server.address().port}`,
+                               { secureContext });
+
+  let remaining = 2;
+  function maybeClose() {
+    if (--remaining === 0) {
+      client.close();
+      server.close();
+    }
+  }
+
+  // Request for a file that does exist, response is 200
+  const req1 = client.request({ [HTTP2_HEADER_PATH]: '/a.js' },
+                              { endStream: true });
+  req1.on('response', common.mustCall((headers) => {
+    assert.strictEqual(headers[HTTP2_HEADER_STATUS], 200);
+  }));
+  let req1_data = '';
+  req1.setEncoding('utf8');
+  req1.on('data', (chunk) => req1_data += chunk);
+  req1.on('end', common.mustCall(() => {
+    assert.strictEqual(req1_data, ajs_data);
+    maybeClose();
+  }));
+
+  // Request for a file that does not exist, response is 404
+  const req2 = client.request({ [HTTP2_HEADER_PATH]: '/does_not_exist' },
+                              { endStream: true });
+  req2.on('response', common.mustCall((headers) => {
+    assert.strictEqual(headers[HTTP2_HEADER_STATUS], 404);
+  }));
+  req2.on('data', common.mustNotCall());
+  req2.on('end', common.mustCall(() => maybeClose()));
+
+});
diff --git a/test/js/node/test/parallel/test-http2-server-async-dispose.js b/test/js/node/test/parallel/test-http2-server-async-dispose.js
new file mode 100644
index 0000000000..4782e12e41
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-server-async-dispose.js
@@ -0,0 +1,15 @@
+'use strict';
+
+const common = require('../common');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const http2 = require('http2');
+
+const server = http2.createServer();
+
+server.listen(0, common.mustCall(() => {
+  server.on('close', common.mustCall());
+  server[Symbol.asyncDispose]().then(common.mustCall());
+}));
diff --git a/test/js/node/test/parallel/test-http2-server-close-callback.js b/test/js/node/test/parallel/test-http2-server-close-callback.js
new file mode 100644
index 0000000000..e4cd24ce20
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-server-close-callback.js
@@ -0,0 +1,27 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const Countdown = require('../common/countdown');
+const http2 = require('http2');
+
+const server = http2.createServer();
+
+let session;
+
+const countdown = new Countdown(2, () => {
+  server.close(common.mustSucceed());
+  session.close();
+});
+
+server.listen(0, common.mustCall(() => {
+  const client = http2.connect(`http://localhost:${server.address().port}`);
+  client.on('connect', common.mustCall(() => countdown.dec()));
+}));
+
+server.on('session', common.mustCall((s) => {
+  session = s;
+  countdown.dec();
+}));
diff --git a/test/js/node/test/parallel/test-http2-server-errors.js b/test/js/node/test/parallel/test-http2-server-errors.js
new file mode 100644
index 0000000000..959ddccdc7
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-server-errors.js
@@ -0,0 +1,88 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const h2 = require('http2');
+
+// Errors should not be reported both in Http2ServerRequest
+// and Http2ServerResponse
+
+{
+  let expected = null;
+
+  const server = h2.createServer();
+
+  server.on('stream', common.mustCall(function(stream) {
+    stream.on('error', common.mustCall(function(err) {
+      assert.strictEqual(err, expected);
+    }));
+
+    stream.resume();
+    stream.write('hello');
+
+    expected = new Error('kaboom');
+    stream.destroy(expected);
+    server.close();
+  }));
+
+  server.listen(0, common.mustCall(function() {
+    const port = server.address().port;
+
+    const url = `http://localhost:${port}`;
+    const client = h2.connect(url, common.mustCall(function() {
+      const headers = {
+        ':path': '/foobar',
+        ':method': 'GET',
+        ':scheme': 'http',
+        ':authority': `localhost:${port}`,
+      };
+      const request = client.request(headers);
+      request.on('data', common.mustCall(function(chunk) {
+        // Cause an error on the server side
+        client.destroy();
+      }));
+      request.end();
+    }));
+  }));
+}
+
+{
+  let expected = null;
+
+  const server = h2.createServer();
+
+  process.on('uncaughtException', common.mustCall(function(err) {
+    assert.strictEqual(err.message, 'kaboom no handler');
+  }));
+
+  server.on('stream', common.mustCall(function(stream) {
+    // There is no 'error'  handler, and this will crash
+    stream.write('hello');
+    stream.resume();
+
+    expected = new Error('kaboom no handler');
+    stream.destroy(expected);
+    server.close();
+  }));
+
+  server.listen(0, common.mustCall(function() {
+    const port = server.address().port;
+
+    const url = `http://localhost:${port}`;
+    const client = h2.connect(url, common.mustCall(function() {
+      const headers = {
+        ':path': '/foobar',
+        ':method': 'GET',
+        ':scheme': 'http',
+        ':authority': `localhost:${port}`,
+      };
+      const request = client.request(headers);
+      request.on('data', common.mustCall(function(chunk) {
+        // Cause an error on the server side
+        client.destroy();
+      }));
+      request.end();
+    }));
+  }));
+}
diff --git a/test/js/node/test/parallel/test-http2-server-rst-before-respond.js b/test/js/node/test/parallel/test-http2-server-rst-before-respond.js
new file mode 100644
index 0000000000..d551c7121f
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-server-rst-before-respond.js
@@ -0,0 +1,37 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const h2 = require('http2');
+
+const server = h2.createServer();
+
+// We use the lower-level API here
+server.on('stream', common.mustCall(onStream));
+
+function onStream(stream, headers, flags) {
+  stream.close();
+
+  assert.throws(() => {
+    stream.additionalHeaders({
+      ':status': 123,
+      'abc': 123
+    });
+  }, { code: 'ERR_HTTP2_INVALID_STREAM' });
+}
+
+server.listen(0);
+
+server.on('listening', common.mustCall(() => {
+  const client = h2.connect(`http://localhost:${server.address().port}`);
+  const req = client.request();
+  req.on('headers', common.mustNotCall());
+  req.on('close', common.mustCall(() => {
+    assert.strictEqual(h2.constants.NGHTTP2_NO_ERROR, req.rstCode);
+    server.close();
+    client.close();
+  }));
+  req.on('response', common.mustNotCall());
+}));
diff --git a/test/js/node/test/parallel/test-http2-session-timeout.js b/test/js/node/test/parallel/test-http2-session-timeout.js
new file mode 100644
index 0000000000..c1dacdcb45
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-session-timeout.js
@@ -0,0 +1,64 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const http2 = require('http2');
+const hrtime = process.hrtime.bigint;
+const NS_PER_MS = 1_000_000n;
+
+let requests = 0;
+const mustNotCall = () => {
+  assert.fail(`Timeout after ${requests} request(s)`);
+};
+
+const server = http2.createServer();
+// Disable server timeout until first request. We will set the timeout based on
+// how long the first request takes.
+server.timeout = 0n;
+
+server.on('request', (req, res) => res.end());
+server.on('timeout', mustNotCall);
+
+server.listen(0, common.mustCall(() => {
+  const port = server.address().port;
+
+  const url = `http://localhost:${port}`;
+  const client = http2.connect(url);
+  let startTime = hrtime();
+  makeReq();
+
+  function makeReq() {
+    const request = client.request({
+      ':path': '/foobar',
+      ':method': 'GET',
+      ':scheme': 'http',
+      ':authority': `localhost:${port}`,
+    });
+    request.resume();
+    request.end();
+
+    requests += 1;
+
+    request.on('end', () => {
+      const diff = hrtime() - startTime;
+      const milliseconds = diff / NS_PER_MS;
+      if (server.timeout === 0n) {
+        // Set the timeout now. First connection will take significantly longer
+        // than subsequent connections, so using the duration of the first
+        // connection as the timeout should be robust. Double it anyway for good
+        // measure.
+        server.timeout = milliseconds * 2n;
+        startTime = hrtime();
+        makeReq();
+      } else if (milliseconds < server.timeout * 2n) {
+        makeReq();
+      } else {
+        server.removeListener('timeout', mustNotCall);
+        server.close();
+        client.close();
+      }
+    });
+  }
+}));
diff --git a/test/js/node/test/parallel/test-http2-socket-proxy-handler-for-has.js b/test/js/node/test/parallel/test-http2-socket-proxy-handler-for-has.js
new file mode 100644
index 0000000000..a8dfbfe07a
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-socket-proxy-handler-for-has.js
@@ -0,0 +1,38 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto) {
+  common.skip('missing crypto');
+}
+
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+const http2 = require('http2');
+
+const serverOptions = {
+  key: fixtures.readKey('agent1-key.pem'),
+  cert: fixtures.readKey('agent1-cert.pem')
+};
+const server = http2.createSecureServer(serverOptions, common.mustCall(
+  (req, res) => {
+    const request = req;
+    assert.strictEqual(request.socket.encrypted, true);
+    assert.ok('encrypted' in request.socket);
+    res.end();
+  }
+));
+server.listen(common.mustCall(() => {
+  const port = server.address().port;
+  const client = http2.connect('https://localhost:' + port, {
+    ca: fixtures.readKey('agent1-cert.pem'),
+    rejectUnauthorized: false
+  });
+  const req = client.request({});
+  req.on('response', common.mustCall((headers, flags) => {
+    console.log(headers);
+    server.close(common.mustCall());
+  }));
+  req.on('end', common.mustCall(() => {
+    client.close();
+  }));
+  req.end();
+}));
diff --git a/test/js/node/test/parallel/test-http2-status-code.js b/test/js/node/test/parallel/test-http2-status-code.js
new file mode 100644
index 0000000000..d3642b4ff0
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-status-code.js
@@ -0,0 +1,41 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const http2 = require('http2');
+
+const codes = [ 200, 202, 300, 400, 404, 451, 500 ];
+let test = 0;
+
+const server = http2.createServer();
+
+server.on('stream', common.mustCall((stream) => {
+  const status = codes[test++];
+  stream.respond({ ':status': status }, { endStream: true });
+}, 7));
+
+server.listen(0, common.mustCall(() => {
+  const client = http2.connect(`http://localhost:${server.address().port}`);
+
+  let remaining = codes.length;
+  function maybeClose() {
+    if (--remaining === 0) {
+      client.close();
+      server.close();
+    }
+  }
+
+  function doTest(expected) {
+    const req = client.request();
+    req.on('response', common.mustCall((headers) => {
+      assert.strictEqual(headers[':status'], expected);
+    }));
+    req.resume();
+    req.on('end', common.mustCall(maybeClose));
+  }
+
+  for (let n = 0; n < codes.length; n++)
+    doTest(codes[n]);
+}));
diff --git a/test/js/node/test/parallel/test-http2-trailers-after-session-close.js b/test/js/node/test/parallel/test-http2-trailers-after-session-close.js
new file mode 100644
index 0000000000..f7c7387eb0
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-trailers-after-session-close.js
@@ -0,0 +1,51 @@
+'use strict';
+
+// Fixes: https://github.com/nodejs/node/issues/42713
+const common = require('../common');
+if (!common.hasCrypto) {
+  common.skip('missing crypto');
+}
+const assert = require('assert');
+const http2 = require('http2');
+
+const {
+  HTTP2_HEADER_PATH,
+  HTTP2_HEADER_STATUS,
+  HTTP2_HEADER_METHOD,
+} = http2.constants;
+
+const server = http2.createServer();
+server.on('stream', common.mustCall((stream) => {
+  server.close();
+  stream.session.close();
+  stream.on('wantTrailers', common.mustCall(() => {
+    stream.sendTrailers({ xyz: 'abc' });
+  }));
+
+  stream.respond({ [HTTP2_HEADER_STATUS]: 200 }, { waitForTrailers: true });
+  stream.write('some data');
+  stream.end();
+}));
+
+server.listen(0, common.mustCall(() => {
+  const port = server.address().port;
+  const client = http2.connect(`http://localhost:${port}`);
+  client.socket.on('close', common.mustCall());
+  const req = client.request({
+    [HTTP2_HEADER_PATH]: '/',
+    [HTTP2_HEADER_METHOD]: 'POST',
+  });
+  req.end();
+  req.on('response', common.mustCall());
+  let data = '';
+  req.on('data', (chunk) => {
+    data += chunk;
+  });
+  req.on('end', common.mustCall(() => {
+    assert.strictEqual(data, 'some data');
+  }));
+  req.on('trailers', common.mustCall((headers) => {
+    assert.strictEqual(headers.xyz, 'abc');
+  }));
+  req.on('close', common.mustCall());
+}));
diff --git a/test/js/node/test/parallel/test-http2-trailers.js b/test/js/node/test/parallel/test-http2-trailers.js
new file mode 100644
index 0000000000..dba9aac12d
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-trailers.js
@@ -0,0 +1,73 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const h2 = require('http2');
+const body =
+  '<html><head></head><body><h1>this is some data</h2></body></html>';
+const trailerKey = 'test-trailer';
+const trailerValue = 'testing';
+
+const server = h2.createServer();
+
+// We use the lower-level API here
+server.on('stream', common.mustCall(onStream));
+
+function onStream(stream, headers, flags) {
+  stream.on('trailers', common.mustCall((headers) => {
+    assert.strictEqual(headers[trailerKey], trailerValue);
+    stream.end(body);
+  }));
+  stream.respond({
+    'content-type': 'text/html',
+    ':status': 200
+  }, { waitForTrailers: true });
+  stream.on('wantTrailers', () => {
+    stream.sendTrailers({ [trailerKey]: trailerValue });
+    assert.throws(
+      () => stream.sendTrailers({}),
+      {
+        code: 'ERR_HTTP2_TRAILERS_ALREADY_SENT',
+        name: 'Error'
+      }
+    );
+  });
+
+  assert.throws(
+    () => stream.sendTrailers({}),
+    {
+      code: 'ERR_HTTP2_TRAILERS_NOT_READY',
+      name: 'Error'
+    }
+  );
+}
+
+server.listen(0);
+
+server.on('listening', common.mustCall(function() {
+  const client = h2.connect(`http://localhost:${this.address().port}`);
+  const req = client.request({ ':path': '/', ':method': 'POST' },
+                             { waitForTrailers: true });
+  req.on('wantTrailers', () => {
+    req.sendTrailers({ [trailerKey]: trailerValue });
+  });
+  req.on('data', common.mustCall());
+  req.on('trailers', common.mustCall((headers) => {
+    assert.strictEqual(headers[trailerKey], trailerValue);
+  }));
+  req.on('close', common.mustCall(() => {
+    assert.throws(
+      () => req.sendTrailers({}),
+      {
+        code: 'ERR_HTTP2_INVALID_STREAM',
+        name: 'Error'
+      }
+    );
+    server.close();
+    client.close();
+  }));
+  req.end('data');
+
+}));
diff --git a/test/js/node/test/parallel/test-http2-unbound-socket-proxy.js b/test/js/node/test/parallel/test-http2-unbound-socket-proxy.js
new file mode 100644
index 0000000000..74ca016944
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-unbound-socket-proxy.js
@@ -0,0 +1,46 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const http2 = require('http2');
+const net = require('net');
+
+const server = http2.createServer();
+server.on('stream', common.mustCall((stream) => {
+  stream.respond();
+  stream.end('ok');
+}));
+
+server.listen(0, common.mustCall(() => {
+  const client = http2.connect(`http://localhost:${server.address().port}`);
+  const socket = client.socket;
+  const req = client.request();
+  req.resume();
+  req.on('close', common.mustCall(() => {
+    client.close();
+    server.close();
+
+    // Tests to make sure accessing the socket proxy fails with an
+    // informative error.
+    setImmediate(common.mustCall(() => {
+      assert.throws(() => {
+        socket.example; // eslint-disable-line no-unused-expressions
+      }, {
+        code: 'ERR_HTTP2_SOCKET_UNBOUND'
+      });
+      assert.throws(() => {
+        socket.example = 1;
+      }, {
+        code: 'ERR_HTTP2_SOCKET_UNBOUND'
+      });
+      assert.throws(() => {
+        // eslint-disable-next-line no-unused-expressions
+        socket instanceof net.Socket;
+      }, {
+        code: 'ERR_HTTP2_SOCKET_UNBOUND'
+      });
+    }));
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http2-write-callbacks.js b/test/js/node/test/parallel/test-http2-write-callbacks.js
new file mode 100644
index 0000000000..eca7f00ea7
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-write-callbacks.js
@@ -0,0 +1,37 @@
+'use strict';
+
+// Verifies that write callbacks are called
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const http2 = require('http2');
+
+const server = http2.createServer();
+
+server.on('stream', common.mustCall((stream) => {
+  stream.write('abc', common.mustCall(() => {
+    stream.end('xyz');
+  }));
+  let actual = '';
+  stream.setEncoding('utf8');
+  stream.on('data', (chunk) => actual += chunk);
+  stream.on('end', common.mustCall(() => assert.strictEqual(actual, 'abcxyz')));
+}));
+
+server.listen(0, common.mustCall(() => {
+  const client = http2.connect(`http://localhost:${server.address().port}`);
+  const req = client.request({ ':method': 'POST' });
+  req.write('abc', common.mustCall(() => {
+    req.end('xyz');
+  }));
+  let actual = '';
+  req.setEncoding('utf8');
+  req.on('data', (chunk) => actual += chunk);
+  req.on('end', common.mustCall(() => assert.strictEqual(actual, 'abcxyz')));
+  req.on('close', common.mustCall(() => {
+    client.close();
+    server.close();
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-http2-write-empty-string.js b/test/js/node/test/parallel/test-http2-write-empty-string.js
new file mode 100644
index 0000000000..ea591176a4
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-write-empty-string.js
@@ -0,0 +1,41 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const http2 = require('http2');
+
+const server = http2.createServer(function(request, response) {
+  response.writeHead(200, { 'Content-Type': 'text/plain' });
+  response.write('1\n');
+  response.write('');
+  response.write('2\n');
+  response.write('');
+  response.end('3\n');
+
+  this.close();
+});
+
+server.listen(0, common.mustCall(function() {
+  const client = http2.connect(`http://localhost:${this.address().port}`);
+  const headers = { ':path': '/' };
+  const req = client.request(headers).setEncoding('ascii');
+
+  let res = '';
+
+  req.on('response', common.mustCall(function(headers) {
+    assert.strictEqual(headers[':status'], 200);
+  }));
+
+  req.on('data', (chunk) => {
+    res += chunk;
+  });
+
+  req.on('end', common.mustCall(function() {
+    assert.strictEqual(res, '1\n2\n3\n');
+    client.close();
+  }));
+
+  req.end();
+}));
diff --git a/test/js/node/test/parallel/test-http2-zero-length-header.js b/test/js/node/test/parallel/test-http2-zero-length-header.js
new file mode 100644
index 0000000000..2e7876858a
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-zero-length-header.js
@@ -0,0 +1,26 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const http2 = require('http2');
+
+const server = http2.createServer();
+server.on('stream', (stream, headers) => {
+  assert.deepStrictEqual(headers, {
+    ':scheme': 'http',
+    ':authority': `localhost:${server.address().port}`,
+    ':method': 'GET',
+    ':path': '/',
+    'bar': '',
+    '__proto__': null,
+    [http2.sensitiveHeaders]: []
+  });
+  stream.session.destroy();
+  server.close();
+});
+server.listen(0, common.mustCall(() => {
+  const client = http2.connect(`http://localhost:${server.address().port}/`);
+  client.request({ ':path': '/', '': 'foo', 'bar': '' }).end();
+}));
diff --git a/test/js/node/test/parallel/test-http2-zero-length-write.js b/test/js/node/test/parallel/test-http2-zero-length-write.js
new file mode 100644
index 0000000000..0b50715330
--- /dev/null
+++ b/test/js/node/test/parallel/test-http2-zero-length-write.js
@@ -0,0 +1,52 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const http2 = require('http2');
+
+const { Readable } = require('stream');
+
+function getSrc() {
+  const chunks = [ '', 'asdf', '', 'foo', '', 'bar', '' ];
+  return new Readable({
+    read() {
+      const chunk = chunks.shift();
+      if (chunk !== undefined)
+        this.push(chunk);
+      else
+        this.push(null);
+    }
+  });
+}
+
+const expect = 'asdffoobar';
+
+const server = http2.createServer();
+server.on('stream', common.mustCall((stream) => {
+  let actual = '';
+  stream.respond();
+  stream.resume();
+  stream.setEncoding('utf8');
+  stream.on('data', (chunk) => actual += chunk);
+  stream.on('end', common.mustCall(() => {
+    getSrc().pipe(stream);
+    assert.strictEqual(actual, expect);
+  }));
+}));
+
+server.listen(0, common.mustCall(() => {
+  const client = http2.connect(`http://localhost:${server.address().port}`);
+  let actual = '';
+  const req = client.request({ ':method': 'POST' });
+  req.on('response', common.mustCall());
+  req.setEncoding('utf8');
+  req.on('data', (chunk) => actual += chunk);
+  req.on('end', common.mustCall(() => {
+    assert.strictEqual(actual, expect);
+    server.close();
+    client.close();
+  }));
+  getSrc().pipe(req);
+}));
diff --git a/test/js/node/test/parallel/test-https-agent-constructor.js b/test/js/node/test/parallel/test-https-agent-constructor.js
new file mode 100644
index 0000000000..69156ba0f6
--- /dev/null
+++ b/test/js/node/test/parallel/test-https-agent-constructor.js
@@ -0,0 +1,9 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const https = require('https');
+
+assert.ok(https.Agent() instanceof https.Agent);
diff --git a/test/js/node/test/parallel/test-https-agent-session-eviction.js b/test/js/node/test/parallel/test-https-agent-session-eviction.js
new file mode 100644
index 0000000000..da56007105
--- /dev/null
+++ b/test/js/node/test/parallel/test-https-agent-session-eviction.js
@@ -0,0 +1,73 @@
+// Flags: --tls-min-v1.0
+'use strict';
+
+const common = require('../common');
+const { readKey } = require('../common/fixtures');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const https = require('https');
+const { SSL_OP_NO_TICKET } = require('crypto').constants;
+
+const options = {
+  key: readKey('agent1-key.pem'),
+  cert: readKey('agent1-cert.pem'),
+  secureOptions: SSL_OP_NO_TICKET,
+  ciphers: 'RSA@SECLEVEL=0'
+};
+
+// Create TLS1.2 server
+https.createServer(options, function(req, res) {
+  res.writeHead(200, { 'Connection': 'close' });
+  res.end('ohai');
+}).listen(0, function() {
+  first(this);
+});
+
+// Do request and let agent cache the session
+function first(server) {
+  const port = server.address().port;
+  const req = https.request({
+    port: port,
+    rejectUnauthorized: false
+  }, function(res) {
+    res.resume();
+
+    server.close(function() {
+      faultyServer(port);
+    });
+  });
+  req.end();
+}
+
+// Create TLS1 server
+function faultyServer(port) {
+  options.secureProtocol = 'TLSv1_method';
+  https.createServer(options, function(req, res) {
+    res.writeHead(200, { 'Connection': 'close' });
+    res.end('hello faulty');
+  }).listen(port, function() {
+    second(this);
+  });
+}
+
+// Attempt to request using cached session
+function second(server, session) {
+  const req = https.request({
+    port: server.address().port,
+    ciphers: (common.hasOpenSSL31 ? 'DEFAULT:@SECLEVEL=0' : 'DEFAULT'),
+    rejectUnauthorized: false
+  }, function(res) {
+    res.resume();
+  });
+
+  // Although we have a TLS 1.2 session to offer to the TLS 1.0 server,
+  // connection to the TLS 1.0 server should work.
+  req.on('response', common.mustCall(function(res) {
+    // The test is now complete for OpenSSL 1.1.0.
+    server.close();
+  }));
+
+  req.end();
+}
diff --git a/test/js/node/test/parallel/test-https-agent.js b/test/js/node/test/parallel/test-https-agent.js
new file mode 100644
index 0000000000..ce4bc6e5bd
--- /dev/null
+++ b/test/js/node/test/parallel/test-https-agent.js
@@ -0,0 +1,72 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+const https = require('https');
+
+const options = {
+  key: fixtures.readKey('agent1-key.pem'),
+  cert: fixtures.readKey('agent1-cert.pem')
+};
+
+
+const server = https.Server(options, (req, res) => {
+  res.writeHead(200);
+  res.end('hello world\n');
+});
+
+
+let responses = 0;
+const N = 4;
+const M = 4;
+
+
+server.listen(0, () => {
+  for (let i = 0; i < N; i++) {
+    setTimeout(() => {
+      for (let j = 0; j < M; j++) {
+        https.get({
+          path: '/',
+          port: server.address().port,
+          rejectUnauthorized: false
+        }, function(res) {
+          res.resume();
+          assert.strictEqual(res.statusCode, 200);
+          if (++responses === N * M) server.close();
+        }).on('error', (e) => {
+          throw e;
+        });
+      }
+    }, i);
+  }
+});
+
+
+process.on('exit', () => {
+  assert.strictEqual(responses, N * M);
+});
diff --git a/test/js/node/test/parallel/test-https-client-get-url.js b/test/js/node/test/parallel/test-https-client-get-url.js
new file mode 100644
index 0000000000..fb91a4f1e7
--- /dev/null
+++ b/test/js/node/test/parallel/test-https-client-get-url.js
@@ -0,0 +1,57 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+// Disable strict server certificate validation by the client
+process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+
+const assert = require('assert');
+const https = require('https');
+const url = require('url');
+
+const options = {
+  key: fixtures.readKey('agent1-key.pem'),
+  cert: fixtures.readKey('agent1-cert.pem')
+};
+
+const server = https.createServer(options, common.mustCall((req, res) => {
+  assert.strictEqual(req.method, 'GET');
+  assert.strictEqual(req.url, '/foo?bar');
+  res.writeHead(200, { 'Content-Type': 'text/plain' });
+  res.write('hello\n');
+  res.end();
+}, 3));
+
+server.listen(0, common.mustCall(() => {
+  const u = `https://${common.localhostIPv4}:${server.address().port}/foo?bar`;
+  https.get(u, common.mustCall(() => {
+    https.get(url.parse(u), common.mustCall(() => {
+      https.get(new URL(u), common.mustCall(() => {
+        server.close();
+      }));
+    }));
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-https-client-renegotiation-limit.js b/test/js/node/test/parallel/test-https-client-renegotiation-limit.js
new file mode 100644
index 0000000000..35fcc6bfcc
--- /dev/null
+++ b/test/js/node/test/parallel/test-https-client-renegotiation-limit.js
@@ -0,0 +1,111 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+if (!common.opensslCli)
+  common.skip('node compiled without OpenSSL CLI.');
+
+const assert = require('assert');
+const tls = require('tls');
+const https = require('https');
+const fixtures = require('../common/fixtures');
+
+// Renegotiation as a protocol feature was dropped after TLS1.2.
+tls.DEFAULT_MAX_VERSION = 'TLSv1.2';
+
+// Renegotiation limits to test
+const LIMITS = [0, 1, 2, 3, 5, 10, 16];
+
+{
+  let n = 0;
+  function next() {
+    if (n >= LIMITS.length) return;
+    tls.CLIENT_RENEG_LIMIT = LIMITS[n++];
+    test(next);
+  }
+  next();
+}
+
+function test(next) {
+  const options = {
+    cert: fixtures.readKey('rsa_cert.crt'),
+    key: fixtures.readKey('rsa_private.pem'),
+  };
+
+  const server = https.createServer(options, (req, res) => {
+    const conn = req.connection;
+    conn.on('error', (err) => {
+      console.error(`Caught exception: ${err}`);
+      assert.match(err.message, /TLS session renegotiation attack/);
+      conn.destroy();
+    });
+    res.end('ok');
+  });
+
+  server.listen(0, () => {
+    const agent = https.Agent({
+      keepAlive: true,
+    });
+
+    let client;
+    let renegs = 0;
+
+    const options = {
+      rejectUnauthorized: false,
+      agent,
+    };
+
+    const { port } = server.address();
+
+    https.get(`https://localhost:${port}/`, options, (res) => {
+      client = res.socket;
+
+      client.on('close', (hadErr) => {
+        assert.strictEqual(hadErr, false);
+        assert.strictEqual(renegs, tls.CLIENT_RENEG_LIMIT + 1);
+        server.close();
+        process.nextTick(next);
+      });
+
+      client.on('error', (err) => {
+        console.log('CLIENT ERR', err);
+        throw err;
+      });
+
+      spam();
+
+      // Simulate renegotiation attack
+      function spam() {
+        client.renegotiate({}, (err) => {
+          assert.ifError(err);
+          assert.ok(renegs <= tls.CLIENT_RENEG_LIMIT);
+          setImmediate(spam);
+        });
+        renegs++;
+      }
+    });
+
+  });
+}
diff --git a/test/js/node/test/parallel/test-https-connecting-to-http.js b/test/js/node/test/parallel/test-https-connecting-to-http.js
new file mode 100644
index 0000000000..195ad38ed4
--- /dev/null
+++ b/test/js/node/test/parallel/test-https-connecting-to-http.js
@@ -0,0 +1,40 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+// This tests the situation where you try to connect a https client
+// to an http server. You should get an error and exit.
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const http = require('http');
+const https = require('https');
+const server = http.createServer(common.mustNotCall());
+
+server.listen(0, common.mustCall(function() {
+  const req = https.get({ port: this.address().port }, common.mustNotCall());
+
+  req.on('error', common.mustCall(function(e) {
+    console.log('Got expected error: ', e.message);
+    server.close();
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-https-foafssl.js b/test/js/node/test/parallel/test-https-foafssl.js
new file mode 100644
index 0000000000..d6dde97a41
--- /dev/null
+++ b/test/js/node/test/parallel/test-https-foafssl.js
@@ -0,0 +1,89 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+if (!common.opensslCli)
+  common.skip('node compiled without OpenSSL CLI.');
+
+const assert = require('assert');
+const fixtures = require('../common/fixtures');
+const https = require('https');
+const spawn = require('child_process').spawn;
+
+const options = {
+  key: fixtures.readKey('rsa_private.pem'),
+  cert: fixtures.readKey('rsa_cert.crt'),
+  requestCert: true,
+  rejectUnauthorized: false
+};
+
+const webIdUrl = 'URI:http://example.com/#me';
+const modulus = fixtures.readKey('rsa_cert_foafssl_b.modulus', 'ascii').replace(/\n/g, '');
+const exponent = fixtures.readKey('rsa_cert_foafssl_b.exponent', 'ascii').replace(/\n/g, '');
+
+const CRLF = '\r\n';
+const body = 'hello world\n';
+let cert;
+
+const server = https.createServer(options, common.mustCall(function(req, res) {
+  console.log('got request');
+
+  cert = req.connection.getPeerCertificate();
+
+  assert.strictEqual(cert.subjectaltname, webIdUrl);
+  assert.strictEqual(cert.exponent, exponent);
+  assert.strictEqual(cert.modulus, modulus);
+  res.writeHead(200, { 'content-type': 'text/plain' });
+  res.end(body, () => { console.log('stream finished'); });
+  console.log('sent response');
+}));
+
+server.listen(0, function() {
+  const args = ['s_client',
+                '-quiet',
+                '-connect', `127.0.0.1:${this.address().port}`,
+                '-cert', fixtures.path('keys/rsa_cert_foafssl_b.crt'),
+                '-key', fixtures.path('keys/rsa_private_b.pem')];
+
+  const client = spawn(common.opensslCli, args);
+
+  client.stdout.on('data', function(data) {
+    console.log('response received');
+    const message = data.toString();
+    const contents = message.split(CRLF + CRLF).pop();
+    assert.strictEqual(body, contents);
+    server.close((e) => {
+      assert.ifError(e);
+      console.log('server closed');
+    });
+    console.log('server.close() called');
+  });
+
+  client.stdin.write('GET /\r\n\r\n');
+
+  client.on('error', function(error) {
+    throw error;
+  });
+});
diff --git a/test/js/node/test/parallel/test-https-localaddress-bind-error.js b/test/js/node/test/parallel/test-https-localaddress-bind-error.js
new file mode 100644
index 0000000000..57e4dd054d
--- /dev/null
+++ b/test/js/node/test/parallel/test-https-localaddress-bind-error.js
@@ -0,0 +1,62 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const https = require('https');
+
+const fixtures = require('../common/fixtures');
+
+const options = {
+  key: fixtures.readKey('agent1-key.pem'),
+  cert: fixtures.readKey('agent1-cert.pem')
+};
+
+const invalidLocalAddress = '1.2.3.4';
+
+const server = https.createServer(options, function(req, res) {
+  console.log(`Connect from: ${req.connection.remoteAddress}`);
+
+  req.on('end', function() {
+    res.writeHead(200, { 'Content-Type': 'text/plain' });
+    res.end(`You are from: ${req.connection.remoteAddress}`);
+  });
+  req.resume();
+});
+
+server.listen(0, '127.0.0.1', common.mustCall(function() {
+  https.request({
+    host: 'localhost',
+    port: this.address().port,
+    path: '/',
+    method: 'GET',
+    localAddress: invalidLocalAddress
+  }, function(res) {
+    assert.fail('unexpectedly got response from server');
+  }).on('error', common.mustCall(function(e) {
+    console.log(`client got error: ${e.message}`);
+    server.close();
+  })).end();
+}));
diff --git a/test/js/node/test/parallel/test-https-selfsigned-no-keycertsign-no-crash.js b/test/js/node/test/parallel/test-https-selfsigned-no-keycertsign-no-crash.js
new file mode 100644
index 0000000000..2dd46ac878
--- /dev/null
+++ b/test/js/node/test/parallel/test-https-selfsigned-no-keycertsign-no-crash.js
@@ -0,0 +1,63 @@
+'use strict';
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+
+// This test starts an https server and tries
+// to connect to it using a self-signed certificate.
+// This certificate´s keyUsage does not include the keyCertSign
+// bit, which used to crash node. The test ensures node
+// will not crash. Key and certificate are from #37889.
+// Note: This test assumes that the connection will succeed.
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const crypto = require('crypto');
+
+// See #37990 for details on why this is problematic with FIPS.
+if (process.config.variables.openssl_is_fips)
+  common.skip('Skipping as test uses non-fips compliant EC curve');
+
+// This test will fail for OpenSSL < 1.1.1h
+const minOpenSSL = 269488271;
+
+if (crypto.constants.OPENSSL_VERSION_NUMBER < minOpenSSL)
+  common.skip('OpenSSL < 1.1.1h');
+
+const https = require('https');
+const path = require('path');
+
+const key =
+  fixtures.readKey(path.join('selfsigned-no-keycertsign', 'key.pem'));
+
+const cert =
+  fixtures.readKey(path.join('selfsigned-no-keycertsign', 'cert.pem'));
+
+const serverOptions = {
+  key: key,
+  cert: cert
+};
+
+// Start the server
+const httpsServer = https.createServer(serverOptions, (req, res) => {
+  res.writeHead(200);
+  res.end('hello world\n');
+});
+httpsServer.listen(0);
+
+httpsServer.on('listening', () => {
+  // Once the server started listening, built the client config
+  // with the server´s used port
+  const clientOptions = {
+    hostname: '127.0.0.1',
+    port: httpsServer.address().port,
+    ca: cert
+  };
+  // Try to connect
+  const req = https.request(clientOptions, common.mustCall((res) => {
+    httpsServer.close();
+  }));
+
+  req.on('error', common.mustNotCall());
+  req.end();
+});
diff --git a/test/js/node/test/parallel/test-https-socket-options.js b/test/js/node/test/parallel/test-https-socket-options.js
new file mode 100644
index 0000000000..b41054d5aa
--- /dev/null
+++ b/test/js/node/test/parallel/test-https-socket-options.js
@@ -0,0 +1,85 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const fixtures = require('../common/fixtures');
+const https = require('https');
+const http = require('http');
+
+const options = {
+  key: fixtures.readKey('agent1-key.pem'),
+  cert: fixtures.readKey('agent1-cert.pem')
+};
+
+const body = 'hello world\n';
+
+// Try first with http server
+
+const server_http = http.createServer(function(req, res) {
+  console.log('got HTTP request');
+  res.writeHead(200, { 'content-type': 'text/plain' });
+  res.end(body);
+});
+
+
+server_http.listen(0, function() {
+  const req = http.request({
+    port: this.address().port,
+    rejectUnauthorized: false
+  }, function(res) {
+    server_http.close();
+    res.resume();
+  });
+  // These methods should exist on the request and get passed down to the socket
+  req.setNoDelay(true);
+  req.setTimeout(1000, () => {});
+  req.setSocketKeepAlive(true, 1000);
+  req.end();
+});
+
+// Then try https server (requires functions to be
+// mirrored in tls.js's CryptoStream)
+
+const server_https = https.createServer(options, function(req, res) {
+  console.log('got HTTPS request');
+  res.writeHead(200, { 'content-type': 'text/plain' });
+  res.end(body);
+});
+
+server_https.listen(0, function() {
+  const req = https.request({
+    port: this.address().port,
+    rejectUnauthorized: false
+  }, function(res) {
+    server_https.close();
+    res.resume();
+  });
+  // These methods should exist on the request and get passed down to the socket
+  req.setNoDelay(true);
+  req.setTimeout(1000, () => {});
+  req.setSocketKeepAlive(true, 1000);
+  req.end();
+});
diff --git a/test/js/node/test/parallel/test-https-truncate.js b/test/js/node/test/parallel/test-https-truncate.js
new file mode 100644
index 0000000000..beed36cd7c
--- /dev/null
+++ b/test/js/node/test/parallel/test-https-truncate.js
@@ -0,0 +1,72 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const fixtures = require('../common/fixtures');
+const https = require('https');
+
+const key = fixtures.readKey('agent1-key.pem');
+const cert = fixtures.readKey('agent1-cert.pem');
+
+// Number of bytes discovered empirically to trigger the bug
+const data = Buffer.alloc(1024 * 32 + 1);
+
+httpsTest();
+
+function httpsTest() {
+  const sopt = { key, cert };
+
+  const server = https.createServer(sopt, function(req, res) {
+    res.setHeader('content-length', data.length);
+    res.end(data);
+    server.close();
+  });
+
+  server.listen(0, function() {
+    const opts = { port: this.address().port, rejectUnauthorized: false };
+    https.get(opts).on('response', function(res) {
+      test(res);
+    });
+  });
+}
+
+
+const test = common.mustCall(function(res) {
+  res.on('end', common.mustCall(function() {
+    assert.strictEqual(res.readableLength, 0);
+    assert.strictEqual(bytes, data.length);
+  }));
+
+  // Pause and then resume on each chunk, to ensure that there will be
+  // a lone byte hanging out at the very end.
+  let bytes = 0;
+  res.on('data', function(chunk) {
+    bytes += chunk.length;
+    this.pause();
+    setTimeout(() => { this.resume(); }, 1);
+  });
+});
diff --git a/test/js/node/test/parallel/test-https-unix-socket-self-signed.js b/test/js/node/test/parallel/test-https-unix-socket-self-signed.js
new file mode 100644
index 0000000000..9db92ac2ae
--- /dev/null
+++ b/test/js/node/test/parallel/test-https-unix-socket-self-signed.js
@@ -0,0 +1,27 @@
+'use strict';
+const common = require('../common');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+const fixtures = require('../common/fixtures');
+const https = require('https');
+const options = {
+  cert: fixtures.readKey('rsa_cert.crt'),
+  key: fixtures.readKey('rsa_private.pem')
+};
+
+const server = https.createServer(options, common.mustCall((req, res) => {
+  res.end('bye\n');
+  server.close();
+}));
+
+server.listen(common.PIPE, common.mustCall(() => {
+  https.get({
+    socketPath: common.PIPE,
+    rejectUnauthorized: false
+  });
+}));
diff --git a/test/js/node/test/parallel/test-icu-env.js b/test/js/node/test/parallel/test-icu-env.js
new file mode 100644
index 0000000000..45b9fea8db
--- /dev/null
+++ b/test/js/node/test/parallel/test-icu-env.js
@@ -0,0 +1,288 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const { execFileSync } = require('child_process');
+
+// system-icu should not be tested
+const hasBuiltinICU = process.config.variables.icu_gyp_path === 'tools/icu/icu-generic.gyp';
+if (!hasBuiltinICU)
+  common.skip('system ICU');
+
+// small-icu doesn't support non-English locales
+const hasFullICU = (() => {
+  try {
+    const january = new Date(9e8);
+    const spanish = new Intl.DateTimeFormat('es', { month: 'long' });
+    return spanish.format(january) === 'enero';
+  } catch {
+    return false;
+  }
+})();
+if (!hasFullICU)
+  common.skip('small ICU');
+
+const icuVersionMajor = Number(process.config.variables.icu_ver_major ?? 0);
+if (icuVersionMajor < 71)
+  common.skip('ICU too old');
+
+
+function runEnvOutside(addEnv, code, ...args) {
+  return execFileSync(
+    process.execPath,
+    ['-e', `process.stdout.write(String(${code}));`],
+    { env: { ...process.env, ...addEnv }, encoding: 'utf8' }
+  );
+}
+
+function runEnvInside(addEnv, func, ...args) {
+  Object.assign(process.env, addEnv); // side effects!
+  return func(...args);
+}
+
+function isPack(array) {
+  const firstItem = array[0];
+  return array.every((item) => item === firstItem);
+}
+
+function isSet(array) {
+  const deduped = new Set(array);
+  return array.length === deduped.size;
+}
+
+
+const localesISO639 = [
+  'eng', 'cmn', 'hin', 'spa',
+  'fra', 'arb', 'ben', 'rus',
+  'por', 'urd', 'ind', 'deu',
+  'jpn', 'pcm', 'mar', 'tel',
+];
+
+const locales = [
+  'en', 'zh', 'hi', 'es',
+  'fr', 'ar', 'bn', 'ru',
+  'pt', 'ur', 'id', 'de',
+  'ja', 'pcm', 'mr', 'te',
+];
+
+// These must not overlap
+const zones = [
+  'America/New_York',
+  'UTC',
+  'Asia/Irkutsk',
+  'Australia/North',
+  'Antarctica/South_Pole',
+];
+
+
+assert.deepStrictEqual(Intl.getCanonicalLocales(localesISO639), locales);
+
+
+// On some platforms these keep original locale (for example, 'January')
+const enero = runEnvOutside(
+  { LANG: 'es' },
+  'new Intl.DateTimeFormat(undefined, { month: "long" } ).format(new Date(9e8))'
+);
+const janvier = runEnvOutside(
+  { LANG: 'fr' },
+  'new Intl.DateTimeFormat(undefined, { month: "long" } ).format(new Date(9e8))'
+);
+const isMockable = enero !== janvier;
+
+// Tests with mocked env
+if (isMockable) {
+  assert.strictEqual(
+    isSet(zones.map((TZ) => runEnvOutside({ TZ }, 'new Date(333333333333).toString()'))),
+    true
+  );
+  assert.strictEqual(
+    isSet(zones.map((TZ) => runEnvOutside({ TZ }, 'new Date(333333333333).toLocaleString()'))),
+    true
+  );
+  assert.deepStrictEqual(
+    locales.map((LANG) => runEnvOutside({ LANG, TZ: 'Europe/Zurich' }, 'new Date(333333333333).toString()')),
+    [
+      'Fri Jul 25 1980 01:35:33 GMT+0100 (Central European Standard Time)',
+      'Fri Jul 25 1980 01:35:33 GMT+0100 (中欧标准时间)',
+      'Fri Jul 25 1980 01:35:33 GMT+0100 (मध्य यूरोपीय मानक समय)',
+      'Fri Jul 25 1980 01:35:33 GMT+0100 (hora estándar de Europa central)',
+      'Fri Jul 25 1980 01:35:33 GMT+0100 (heure normale d’Europe centrale)',
+      'Fri Jul 25 1980 01:35:33 GMT+0100 (توقيت وسط أوروبا الرسمي)',
+      'Fri Jul 25 1980 01:35:33 GMT+0100 (মধ্য ইউরোপীয় মানক সময়)',
+      'Fri Jul 25 1980 01:35:33 GMT+0100 (Центральная Европа, стандартное время)',
+      'Fri Jul 25 1980 01:35:33 GMT+0100 (Horário Padrão da Europa Central)',
+      'Fri Jul 25 1980 01:35:33 GMT+0100 (وسطی یورپ کا معیاری وقت)',
+      'Fri Jul 25 1980 01:35:33 GMT+0100 (Waktu Standar Eropa Tengah)',
+      'Fri Jul 25 1980 01:35:33 GMT+0100 (Mitteleuropäische Normalzeit)',
+      'Fri Jul 25 1980 01:35:33 GMT+0100 (中央ヨーロッパ標準時)',
+      'Fri Jul 25 1980 01:35:33 GMT+0100 (Mídúl Yúrop Fíksd Taim)',
+      'Fri Jul 25 1980 01:35:33 GMT+0100 (मध्‍य युरोपियन प्रमाण वेळ)',
+      'Fri Jul 25 1980 01:35:33 GMT+0100 (సెంట్రల్ యూరోపియన్ ప్రామాణిక సమయం)',
+    ]
+  );
+  assert.deepStrictEqual(
+    locales.map((LANG) => runEnvOutside({ LANG, TZ: 'Europe/Zurich' }, 'new Date(333333333333).toLocaleString()')),
+    [
+      '7/25/1980, 1:35:33 AM',
+      '1980/7/25 01:35:33',
+      '25/7/1980, 1:35:33 am',
+      '25/7/1980, 1:35:33',
+      '25/07/1980 01:35:33',
+      '٢٥‏/٧‏/١٩٨٠، ١:٣٥:٣٣ ص',
+      '২৫/৭/১৯৮০, ১:৩৫:৩৩ AM',
+      '25.07.1980, 01:35:33',
+      '25/07/1980, 01:35:33',
+      '25/7/1980، 1:35:33 AM',
+      '25/7/1980, 01.35.33',
+      '25.7.1980, 01:35:33',
+      '1980/7/25 1:35:33',
+      '25/7/1980 01:35:33',
+      '२५/७/१९८०, १:३५:३३ AM',
+      '25/7/1980 1:35:33 AM',
+    ]
+  );
+  assert.strictEqual(
+    runEnvOutside({ LANG: 'en' }, '["z", "ä"].sort(new Intl.Collator().compare)'),
+    'ä,z'
+  );
+  assert.strictEqual(
+    runEnvOutside({ LANG: 'sv' }, '["z", "ä"].sort(new Intl.Collator().compare)'),
+    'z,ä'
+  );
+  assert.deepStrictEqual(
+    locales.map(
+      (LANG) => runEnvOutside({ LANG, TZ: 'Europe/Zurich' }, 'new Intl.DateTimeFormat().format(333333333333)')
+    ),
+    [
+      '7/25/1980', '1980/7/25',
+      '25/7/1980', '25/7/1980',
+      '25/07/1980', '٢٥‏/٧‏/١٩٨٠',
+      '২৫/৭/১৯৮০', '25.07.1980',
+      '25/07/1980', '25/7/1980',
+      '25/7/1980', '25.7.1980',
+      '1980/7/25', '25/7/1980',
+      '२५/७/१९८०', '25/7/1980',
+    ]
+  );
+  assert.deepStrictEqual(
+    locales.map((LANG) => runEnvOutside({ LANG }, 'new Intl.DisplayNames(undefined, { type: "region" }).of("CH")')),
+    [
+      'Switzerland', '瑞士',
+      'स्विट्ज़रलैंड', 'Suiza',
+      'Suisse', 'سويسرا',
+      'সুইজারল্যান্ড', 'Швейцария',
+      'Suíça', 'سوئٹزر لینڈ',
+      'Swiss', 'Schweiz',
+      'スイス', 'Swítsaland',
+      'स्वित्झर्लंड', 'స్విట్జర్లాండ్',
+    ]
+  );
+  assert.deepStrictEqual(
+    locales.map((LANG) => runEnvOutside({ LANG }, 'new Intl.NumberFormat().format(275760.913)')),
+    [
+      '275,760.913', '275,760.913',
+      '2,75,760.913', '275.760,913',
+      '275 760,913', '٢٧٥٬٧٦٠٫٩١٣',
+      '২,৭৫,৭৬০.৯১৩', '275 760,913',
+      '275.760,913', '275,760.913',
+      '275.760,913', '275.760,913',
+      '275,760.913', '275,760.913',
+      '२,७५,७६०.९१३', '2,75,760.913',
+    ]
+  );
+  assert.deepStrictEqual(
+    locales.map((LANG) => runEnvOutside({ LANG }, 'new Intl.PluralRules().select(0)')),
+    [
+      'other', 'other', 'one', 'other',
+      'one', 'zero', 'one', 'many',
+      'one', 'other', 'other', 'other',
+      'other', 'one', 'other', 'other',
+    ]
+  );
+  assert.deepStrictEqual(
+    locales.map((LANG) => runEnvOutside({ LANG }, 'new Intl.RelativeTimeFormat().format(-586920.617, "hour")')),
+    [
+      '586,920.617 hours ago',
+      '586,920.617小时前',
+      '5,86,920.617 घंटे पहले',
+      'hace 586.920,617 horas',
+      'il y a 586 920,617 heures',
+      'قبل ٥٨٦٬٩٢٠٫٦١٧ ساعة',
+      '৫,৮৬,৯২০.৬১৭ ঘন্টা আগে',
+      '586 920,617 часа назад',
+      'há 586.920,617 horas',
+      '586,920.617 گھنٹے پہلے',
+      '586.920,617 jam yang lalu',
+      'vor 586.920,617 Stunden',
+      '586,920.617 時間前',
+      '586,920.617 áwa wé dọ́n pas',
+      '५,८६,९२०.६१७ तासांपूर्वी',
+      '5,86,920.617 గంటల క్రితం',
+    ]
+  );
+}
+
+
+// Tests with process.env mutated inside
+{
+  // process.env.TZ is not intercepted in Workers
+  if (common.isMainThread) {
+    assert.strictEqual(
+      isSet(zones.map((TZ) => runEnvInside({ TZ }, () => new Date(333333333333).toString()))),
+      true
+    );
+    assert.strictEqual(
+      isSet(zones.map((TZ) => runEnvInside({ TZ }, () => new Date(333333333333).toLocaleString()))),
+      true
+    );
+  } else {
+    assert.strictEqual(
+      isPack(zones.map((TZ) => runEnvInside({ TZ }, () => new Date(333333333333).toString()))),
+      true
+    );
+    assert.strictEqual(
+      isPack(zones.map((TZ) => runEnvInside({ TZ }, () => new Date(333333333333).toLocaleString()))),
+      true
+    );
+  }
+
+  assert.strictEqual(
+    isPack(locales.map((LANG) => runEnvInside({ LANG, TZ: 'Europe/Zurich' }, () => new Date(333333333333).toString()))),
+    true
+  );
+  assert.strictEqual(
+    isPack(locales.map(
+      (LANG) => runEnvInside({ LANG, TZ: 'Europe/Zurich' }, () => new Date(333333333333).toLocaleString())
+    )),
+    true
+  );
+  assert.deepStrictEqual(
+    runEnvInside({ LANG: 'en' }, () => ['z', 'ä'].sort(new Intl.Collator().compare)),
+    runEnvInside({ LANG: 'sv' }, () => ['z', 'ä'].sort(new Intl.Collator().compare))
+  );
+  assert.strictEqual(
+    isPack(locales.map(
+      (LANG) => runEnvInside({ LANG, TZ: 'Europe/Zurich' }, () => new Intl.DateTimeFormat().format(333333333333))
+    )),
+    true
+  );
+  assert.strictEqual(
+    isPack(locales.map(
+      (LANG) => runEnvInside({ LANG }, () => new Intl.DisplayNames(undefined, { type: 'region' }).of('CH'))
+    )),
+    true
+  );
+  assert.strictEqual(
+    isPack(locales.map((LANG) => runEnvInside({ LANG }, () => new Intl.NumberFormat().format(275760.913)))),
+    true
+  );
+  assert.strictEqual(
+    isPack(locales.map((LANG) => runEnvInside({ LANG }, () => new Intl.PluralRules().select(0)))),
+    true
+  );
+  assert.strictEqual(
+    isPack(locales.map(
+      (LANG) => runEnvInside({ LANG }, () => new Intl.RelativeTimeFormat().format(-586920.617, 'hour'))
+    )),
+    true
+  );
+}
diff --git a/test/js/node/test/parallel/test-icu-punycode.js b/test/js/node/test/parallel/test-icu-punycode.js
new file mode 100644
index 0000000000..29e88f9b9a
--- /dev/null
+++ b/test/js/node/test/parallel/test-icu-punycode.js
@@ -0,0 +1,57 @@
+'use strict';
+// Flags: --expose-internals
+const common = require('../common');
+
+if (!common.hasIntl)
+  common.skip('missing Intl');
+
+const { internalBinding } = require('internal/test/binding');
+const icu = internalBinding('icu');
+const assert = require('assert');
+
+// Test hasConverter method
+assert(icu.hasConverter('utf-8'),
+       'hasConverter should report converter exists for utf-8');
+assert(!icu.hasConverter('x'),
+       'hasConverter should report converter does not exist for x');
+
+const tests = require('../fixtures/url-idna.js');
+const fixtures = require('../fixtures/icu-punycode-toascii.json');
+
+{
+  for (const [i, { ascii, unicode }] of tests.entries()) {
+    assert.strictEqual(ascii, icu.toASCII(unicode), `toASCII(${i + 1})`);
+    assert.strictEqual(unicode, icu.toUnicode(ascii), `toUnicode(${i + 1})`);
+    assert.strictEqual(ascii, icu.toASCII(icu.toUnicode(ascii)),
+                       `toASCII(toUnicode(${i + 1}))`);
+    assert.strictEqual(unicode, icu.toUnicode(icu.toASCII(unicode)),
+                       `toUnicode(toASCII(${i + 1}))`);
+  }
+}
+
+{
+  for (const [i, test] of fixtures.entries()) {
+    if (typeof test === 'string')
+      continue; // skip comments
+    const { comment, input, output } = test;
+    let caseComment = `case ${i + 1}`;
+    if (comment)
+      caseComment += ` (${comment})`;
+    if (output === null) {
+      assert.throws(
+        () => icu.toASCII(input),
+        {
+          code: 'ERR_INVALID_ARG_VALUE',
+          name: 'TypeError',
+          message: 'Cannot convert name to ASCII'
+        }
+      );
+      icu.toASCII(input, true); // Should not throw.
+    } else {
+      assert.strictEqual(icu.toASCII(input), output, `ToASCII ${caseComment}`);
+      assert.strictEqual(icu.toASCII(input, true), output,
+                         `ToASCII ${caseComment} in lenient mode`);
+    }
+    icu.toUnicode(input); // Should not throw.
+  }
+}
diff --git a/test/js/node/test/parallel/test-icu-transcode.js b/test/js/node/test/parallel/test-icu-transcode.js
new file mode 100644
index 0000000000..e9aced128e
--- /dev/null
+++ b/test/js/node/test/parallel/test-icu-transcode.js
@@ -0,0 +1,90 @@
+'use strict';
+
+const common = require('../common');
+
+if (!common.hasIntl)
+  common.skip('missing Intl');
+
+const buffer = require('buffer');
+const assert = require('assert');
+const orig = Buffer.from('těst ☕', 'utf8');
+
+// Test Transcoding
+const tests = {
+  'latin1': [0x74, 0x3f, 0x73, 0x74, 0x20, 0x3f],
+  'ascii': [0x74, 0x3f, 0x73, 0x74, 0x20, 0x3f],
+  'ucs2': [0x74, 0x00, 0x1b, 0x01, 0x73,
+           0x00, 0x74, 0x00, 0x20, 0x00,
+           0x15, 0x26]
+};
+
+for (const test in tests) {
+  const dest = buffer.transcode(orig, 'utf8', test);
+  assert.strictEqual(dest.length, tests[test].length, `utf8->${test} length`);
+  for (let n = 0; n < tests[test].length; n++)
+    assert.strictEqual(dest[n], tests[test][n], `utf8->${test} char ${n}`);
+}
+
+{
+  const dest = buffer.transcode(Buffer.from(tests.ucs2), 'ucs2', 'utf8');
+  assert.strictEqual(dest.toString(), orig.toString());
+}
+
+{
+  const utf8 = Buffer.from('€'.repeat(4000), 'utf8');
+  const ucs2 = Buffer.from('€'.repeat(4000), 'ucs2');
+  const utf8_to_ucs2 = buffer.transcode(utf8, 'utf8', 'ucs2');
+  const ucs2_to_utf8 = buffer.transcode(ucs2, 'ucs2', 'utf8');
+  assert.deepStrictEqual(utf8, ucs2_to_utf8);
+  assert.deepStrictEqual(ucs2, utf8_to_ucs2);
+  assert.strictEqual(ucs2_to_utf8.toString('utf8'),
+                     utf8_to_ucs2.toString('ucs2'));
+}
+
+assert.throws(
+  () => buffer.transcode(null, 'utf8', 'ascii'),
+  {
+    name: 'TypeError',
+    code: 'ERR_INVALID_ARG_TYPE',
+    message: 'The "source" argument must be an instance of Buffer ' +
+             'or Uint8Array. Received null'
+  }
+);
+
+assert.throws(
+  () => buffer.transcode(Buffer.from('a'), 'b', 'utf8'),
+  /^Error: Unable to transcode Buffer \[U_ILLEGAL_ARGUMENT_ERROR\]/
+);
+
+assert.throws(
+  () => buffer.transcode(Buffer.from('a'), 'uf8', 'b'),
+  /^Error: Unable to transcode Buffer \[U_ILLEGAL_ARGUMENT_ERROR\]$/
+);
+
+assert.deepStrictEqual(
+  buffer.transcode(Buffer.from('hi', 'ascii'), 'ascii', 'utf16le'),
+  Buffer.from('hi', 'utf16le'));
+assert.deepStrictEqual(
+  buffer.transcode(Buffer.from('hi', 'latin1'), 'latin1', 'utf16le'),
+  Buffer.from('hi', 'utf16le'));
+assert.deepStrictEqual(
+  buffer.transcode(Buffer.from('hä', 'latin1'), 'latin1', 'utf16le'),
+  Buffer.from('hä', 'utf16le'));
+
+// Test that Uint8Array arguments are okay.
+{
+  const uint8array = new Uint8Array([...Buffer.from('hä', 'latin1')]);
+  assert.deepStrictEqual(
+    buffer.transcode(uint8array, 'latin1', 'utf16le'),
+    Buffer.from('hä', 'utf16le'));
+}
+
+{
+  const dest = buffer.transcode(new Uint8Array(), 'utf8', 'latin1');
+  assert.strictEqual(dest.length, 0);
+}
+
+// Test that it doesn't crash
+{
+  buffer.transcode(new buffer.SlowBuffer(1), 'utf16le', 'ucs2');
+}
diff --git a/test/js/node/test/parallel/test-inspect-support-for-node_options.js b/test/js/node/test/parallel/test-inspect-support-for-node_options.js
new file mode 100644
index 0000000000..05bb3b2c42
--- /dev/null
+++ b/test/js/node/test/parallel/test-inspect-support-for-node_options.js
@@ -0,0 +1,30 @@
+'use strict';
+const common = require('../common');
+const cluster = require('cluster');
+const assert = require('assert');
+
+common.skipIfInspectorDisabled();
+
+checkForInspectSupport('--inspect');
+
+function checkForInspectSupport(flag) {
+
+  const nodeOptions = JSON.stringify(flag);
+  const numWorkers = 2;
+  process.env.NODE_OPTIONS = flag;
+
+  if (cluster.isPrimary) {
+    for (let i = 0; i < numWorkers; i++) {
+      cluster.fork();
+    }
+
+    cluster.on('online', (worker) => {
+      worker.disconnect();
+    });
+
+    cluster.on('exit', common.mustCall((worker, code, signal) => {
+      const errMsg = `For NODE_OPTIONS ${nodeOptions}, failed to start cluster`;
+      assert.strictEqual(worker.exitedAfterDisconnect, true, errMsg);
+    }, numWorkers));
+  }
+}
diff --git a/test/js/node/test/parallel/test-inspector-has-inspector-false.js b/test/js/node/test/parallel/test-inspector-has-inspector-false.js
new file mode 100644
index 0000000000..56a50408bb
--- /dev/null
+++ b/test/js/node/test/parallel/test-inspector-has-inspector-false.js
@@ -0,0 +1,15 @@
+// Flags: --expose-internals
+'use strict';
+
+const common = require('../common');
+
+if (process.features.inspector) {
+  common.skip('V8 inspector is enabled');
+}
+
+const inspector = require('internal/util/inspector');
+
+inspector.sendInspectorCommand(
+  common.mustNotCall('Inspector callback should not be called'),
+  common.mustCall(1),
+);
diff --git a/test/js/node/test/parallel/test-inspector-stops-no-file.js b/test/js/node/test/parallel/test-inspector-stops-no-file.js
new file mode 100644
index 0000000000..9ec09fb15d
--- /dev/null
+++ b/test/js/node/test/parallel/test-inspector-stops-no-file.js
@@ -0,0 +1,16 @@
+'use strict';
+require('../common');
+
+const spawn = require('child_process').spawn;
+
+const child = spawn(process.execPath,
+                    [ '--inspect', 'no-such-script.js' ],
+                    { 'stdio': 'inherit' });
+
+function signalHandler() {
+  child.kill();
+  process.exit(1);
+}
+
+process.on('SIGINT', signalHandler);
+process.on('SIGTERM', signalHandler);
diff --git a/test/js/node/test/parallel/test-instanceof.js b/test/js/node/test/parallel/test-instanceof.js
new file mode 100644
index 0000000000..5a8b588e7d
--- /dev/null
+++ b/test/js/node/test/parallel/test-instanceof.js
@@ -0,0 +1,11 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+
+
+// Regression test for instanceof, see
+// https://github.com/nodejs/node/issues/7592
+const F = () => {};
+F.prototype = {};
+assert({ __proto__: F.prototype } instanceof F);
diff --git a/test/js/node/test/parallel/test-internal-module-require.js b/test/js/node/test/parallel/test-internal-module-require.js
new file mode 100644
index 0000000000..c6e2057d3d
--- /dev/null
+++ b/test/js/node/test/parallel/test-internal-module-require.js
@@ -0,0 +1,112 @@
+'use strict';
+
+// Flags: --expose-internals
+// This verifies that
+// 1. We do not leak internal modules unless the --require-internals option
+//    is on.
+// 2. We do not accidentally leak any modules to the public global scope.
+// 3. Deprecated modules are properly deprecated.
+
+const common = require('../common');
+
+if (!common.isMainThread) {
+  common.skip('Cannot test the existence of --expose-internals from worker');
+}
+
+const assert = require('assert');
+const fork = require('child_process').fork;
+
+const expectedPublicModules = new Set([
+  '_http_agent',
+  '_http_client',
+  '_http_common',
+  '_http_incoming',
+  '_http_outgoing',
+  '_http_server',
+  '_stream_duplex',
+  '_stream_passthrough',
+  '_stream_readable',
+  '_stream_transform',
+  '_stream_wrap',
+  '_stream_writable',
+  '_tls_common',
+  '_tls_wrap',
+  'assert',
+  'async_hooks',
+  'buffer',
+  'child_process',
+  'cluster',
+  'console',
+  'constants',
+  'crypto',
+  'dgram',
+  'dns',
+  'domain',
+  'events',
+  'fs',
+  'http',
+  'http2',
+  'https',
+  'inspector',
+  'module',
+  'net',
+  'os',
+  'path',
+  'perf_hooks',
+  'process',
+  'punycode',
+  'querystring',
+  'readline',
+  'repl',
+  'stream',
+  'string_decoder',
+  'sys',
+  'timers',
+  'tls',
+  'trace_events',
+  'tty',
+  'url',
+  'util',
+  'v8',
+  'vm',
+  'worker_threads',
+  'zlib',
+]);
+
+if (process.argv[2] === 'child') {
+  assert(!process.execArgv.includes('--expose-internals'));
+  process.once('message', ({ allBuiltins }) => {
+    const publicModules = new Set();
+    for (const id of allBuiltins) {
+      if (id.startsWith('internal/')) {
+        assert.throws(() => {
+          require(id);
+        }, {
+          code: 'MODULE_NOT_FOUND',
+          message: `Cannot find module '${id}'`
+        });
+      } else {
+        require(id);
+        publicModules.add(id);
+      }
+    }
+    assert(allBuiltins.length > publicModules.size);
+    // Make sure all the public modules are available through
+    // require('module').builtinModules
+    assert.deepStrictEqual(
+      publicModules,
+      new Set(require('module').builtinModules)
+    );
+    assert.deepStrictEqual(publicModules, expectedPublicModules);
+  });
+} else {
+  assert(process.execArgv.includes('--expose-internals'));
+  const child = fork(__filename, ['child'], {
+    execArgv: []
+  });
+  const { builtinModules } = require('module');
+  // When --expose-internals is on, require('module').builtinModules
+  // contains internal modules.
+  const message = { allBuiltins: builtinModules };
+  child.send(message);
+}
diff --git a/test/js/node/test/parallel/test-internal-process-binding.js b/test/js/node/test/parallel/test-internal-process-binding.js
new file mode 100644
index 0000000000..09e3f31096
--- /dev/null
+++ b/test/js/node/test/parallel/test-internal-process-binding.js
@@ -0,0 +1,10 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+
+assert.strictEqual(undefined, process._internalBinding);
+assert.strictEqual(undefined, process.internalBinding);
+assert.throws(() => {
+  process.binding('module_wrap');
+}, /No such module/);
diff --git a/test/js/node/test/parallel/test-intl-v8BreakIterator.js b/test/js/node/test/parallel/test-intl-v8BreakIterator.js
new file mode 100644
index 0000000000..257d6b2a76
--- /dev/null
+++ b/test/js/node/test/parallel/test-intl-v8BreakIterator.js
@@ -0,0 +1,10 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const vm = require('vm');
+
+if (!common.hasIntl)
+  common.skip('missing Intl');
+
+assert(!('v8BreakIterator' in Intl));
+assert(!vm.runInNewContext('"v8BreakIterator" in Intl'));
diff --git a/test/js/node/test/parallel/test-intl.js b/test/js/node/test/parallel/test-intl.js
new file mode 100644
index 0000000000..7d1742f2c7
--- /dev/null
+++ b/test/js/node/test/parallel/test-intl.js
@@ -0,0 +1,163 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const { execFile } = require('child_process');
+
+// Does node think that i18n was enabled?
+let enablei18n = process.config.variables.v8_enable_i18n_support;
+if (enablei18n === undefined) {
+  enablei18n = 0;
+}
+
+// Returns true if no specific locale ids were configured (i.e. "all")
+// Else, returns true if loc is in the configured list
+// Else, returns false
+function haveLocale(loc) {
+  const locs = process.config.variables.icu_locales.split(',');
+  return locs.includes(loc);
+}
+
+// Always run these. They should always pass, even if the locale
+// param is ignored.
+assert.strictEqual('Ç'.toLocaleLowerCase('el'), 'ç');
+assert.strictEqual('Ç'.toLocaleLowerCase('tr'), 'ç');
+assert.strictEqual('Ç'.toLowerCase(), 'ç');
+
+assert.strictEqual('ç'.toLocaleUpperCase('el'), 'Ç');
+assert.strictEqual('ç'.toLocaleUpperCase('tr'), 'Ç');
+assert.strictEqual('ç'.toUpperCase(), 'Ç');
+
+if (!common.hasIntl) {
+  const erMsg =
+    `"Intl" object is NOT present but v8_enable_i18n_support is ${enablei18n}`;
+  assert.strictEqual(enablei18n, 0, erMsg);
+  common.skip('Intl tests because Intl object not present.');
+} else {
+  const erMsg =
+    `"Intl" object is present but v8_enable_i18n_support is ${
+      enablei18n}. Is this test out of date?`;
+  assert.strictEqual(enablei18n, 1, erMsg);
+
+  // Construct a new date at the beginning of Unix time
+  const date0 = new Date(0);
+
+  // Use the GMT time zone
+  const GMT = 'Etc/GMT';
+
+  // Construct an English formatter. Should format to "Jan 70"
+  const dtf = new Intl.DateTimeFormat(['en'], {
+    timeZone: GMT,
+    month: 'short',
+    year: '2-digit'
+  });
+
+  // If list is specified and doesn't contain 'en' then return.
+  if (process.config.variables.icu_locales && !haveLocale('en')) {
+    common.printSkipMessage(
+      'detailed Intl tests because English is not listed as supported.');
+    // Smoke test. Does it format anything, or fail?
+    console.log(`Date(0) formatted to: ${dtf.format(date0)}`);
+    return;
+  }
+
+  // Check casing
+  {
+    assert.strictEqual('I'.toLocaleLowerCase('tr'), 'ı');
+  }
+
+  // Check with toLocaleString
+  {
+    const localeString = dtf.format(date0);
+    assert.strictEqual(localeString, 'Jan 70');
+  }
+  // Options to request GMT
+  const optsGMT = { timeZone: GMT };
+
+  // Test format
+  {
+    const localeString = date0.toLocaleString(['en'], optsGMT);
+    assert.strictEqual(localeString, '1/1/1970, 12:00:00 AM');
+  }
+  // number format
+  {
+    const numberFormat = new Intl.NumberFormat(['en']).format(12345.67890);
+    assert.strictEqual(numberFormat, '12,345.679');
+  }
+  // If list is specified and doesn't contain 'en-US' then return.
+  if (process.config.variables.icu_locales && !haveLocale('en-US')) {
+    common.printSkipMessage('detailed Intl tests because American English is ' +
+                            'not listed as supported.');
+    return;
+  }
+  // Number format resolved options
+  {
+    const numberFormat = new Intl.NumberFormat('en-US', { style: 'percent' });
+    const resolvedOptions = numberFormat.resolvedOptions();
+    assert.strictEqual(resolvedOptions.locale, 'en-US');
+    assert.strictEqual(resolvedOptions.style, 'percent');
+  }
+  // Significant Digits
+  {
+    const loc = ['en-US'];
+    const opts = { maximumSignificantDigits: 4 };
+    const num = 10.001;
+    const numberFormat = new Intl.NumberFormat(loc, opts).format(num);
+    assert.strictEqual(numberFormat, '10');
+  }
+
+  const collOpts = { sensitivity: 'base', ignorePunctuation: true };
+  const coll = new Intl.Collator(['en'], collOpts);
+
+  // Ignore punctuation
+  assert.strictEqual(coll.compare('blackbird', 'black-bird'), 0);
+  // Compare less
+  assert.strictEqual(coll.compare('blackbird', 'red-bird'), -1);
+  // Compare greater
+  assert.strictEqual(coll.compare('bluebird', 'blackbird'), 1);
+  // Ignore case
+  assert.strictEqual(coll.compare('Bluebird', 'bluebird'), 0);
+  // `ffi` ligature (contraction)
+  assert.strictEqual(coll.compare('\ufb03', 'ffi'), 0);
+
+  {
+    // Regression test for https://github.com/nodejs/node/issues/27379
+    const env = { ...process.env, LC_ALL: 'ja' };
+    execFile(
+      process.execPath, ['-p', 'new Date().toLocaleString()'],
+      { env },
+      common.mustSucceed()
+    );
+  }
+
+  {
+    // Regression test for https://github.com/nodejs/node/issues/27418
+    const env = { ...process.env, LC_ALL: 'fr@EURO' };
+    execFile(
+      process.execPath,
+      ['-p', 'new Intl.NumberFormat().resolvedOptions().locale'],
+      { env },
+      common.mustSucceed()
+    );
+  }
+}
diff --git a/test/js/node/test/parallel/test-kill-segfault-freebsd.js b/test/js/node/test/parallel/test-kill-segfault-freebsd.js
new file mode 100644
index 0000000000..e17b00741b
--- /dev/null
+++ b/test/js/node/test/parallel/test-kill-segfault-freebsd.js
@@ -0,0 +1,19 @@
+'use strict';
+require('../common');
+
+// This test ensures Node.js doesn't crash on hitting Ctrl+C in order to
+// terminate the currently running process (especially on FreeBSD).
+// https://github.com/nodejs/node-v0.x-archive/issues/9326
+
+const assert = require('assert');
+const child_process = require('child_process');
+
+// NOTE: Was crashing on FreeBSD
+const cp = child_process.spawn(process.execPath, [
+  '-e',
+  'process.kill(process.pid, "SIGINT")',
+]);
+
+cp.on('exit', function(code) {
+  assert.notStrictEqual(code, 0);
+});
diff --git a/test/js/node/test/parallel/test-listen-fd-detached-inherit.js b/test/js/node/test/parallel/test-listen-fd-detached-inherit.js
new file mode 100644
index 0000000000..2a8e70f0f9
--- /dev/null
+++ b/test/js/node/test/parallel/test-listen-fd-detached-inherit.js
@@ -0,0 +1,118 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+if (common.isWindows)
+  common.skip('This test is disabled on windows.');
+
+const assert = require('assert');
+const http = require('http');
+const net = require('net');
+const spawn = require('child_process').spawn;
+
+switch (process.argv[2]) {
+  case 'child': return child();
+  case 'parent': return parent();
+  default: return test();
+}
+
+// Spawn the parent, and listen for it to tell us the pid of the child.
+// WARNING: This is an example of listening on some arbitrary FD number
+// that has already been bound elsewhere in advance.  However, binding
+// server handles to stdio fd's is NOT a good or reliable way to do
+// concurrency in HTTP servers!  Use the cluster module, or if you want
+// a more low-level approach, use child process IPC manually.
+function test() {
+  const parent = spawn(process.execPath, [__filename, 'parent'], {
+    stdio: [ 0, 'pipe', 2 ]
+  });
+  let json = '';
+  parent.stdout.on('data', function(c) {
+    json += c.toString();
+    if (json.includes('\n')) next();
+  });
+  function next() {
+    console.error('output from parent = %s', json);
+    const child = JSON.parse(json);
+    // Now make sure that we can request to the subprocess, then kill it.
+    http.get({
+      server: 'localhost',
+      port: child.port,
+      path: '/',
+    }).on('response', function(res) {
+      let s = '';
+      res.on('data', function(c) {
+        s += c.toString();
+      });
+      res.on('end', function() {
+        // Kill the subprocess before we start doing asserts.
+        // It's really annoying when tests leave orphans!
+        process.kill(child.pid, 'SIGKILL');
+        try {
+          parent.kill();
+        } catch {
+          // Continue regardless of error.
+        }
+
+        assert.strictEqual(s, 'hello from child\n');
+        assert.strictEqual(res.statusCode, 200);
+      });
+    });
+  }
+}
+
+// Listen on port, and then pass the handle to the detached child.
+// Then output the child's pid, and immediately exit.
+function parent() {
+  const server = net.createServer(function(conn) {
+    conn.end('HTTP/1.1 403 Forbidden\r\n\r\nI got problems.\r\n');
+    throw new Error('Should not see connections on parent');
+  }).listen(0, function() {
+    console.error('server listening on %d', this.address().port);
+
+    const child = spawn(process.execPath, [__filename, 'child'], {
+      stdio: [ 0, 1, 2, server._handle ],
+      detached: true
+    });
+
+    console.log('%j\n', { pid: child.pid, port: this.address().port });
+
+    // Now close the parent, so that the child is the only thing
+    // referencing that handle.  Note that connections will still
+    // be accepted, because the child has the fd open, but the parent
+    // will exit gracefully.
+    server.close();
+    child.unref();
+  });
+}
+
+// Run as a child of the parent() mode.
+function child() {
+  // Start a server on fd=3
+  http.createServer(function(req, res) {
+    console.error('request on child');
+    console.error('%s %s', req.method, req.url, req.headers);
+    res.end('hello from child\n');
+  }).listen({ fd: 3 }, function() {
+    console.error('child listening on fd=3');
+  });
+}
diff --git a/test/js/node/test/parallel/test-listen-fd-detached.js b/test/js/node/test/parallel/test-listen-fd-detached.js
new file mode 100644
index 0000000000..fba96a112f
--- /dev/null
+++ b/test/js/node/test/parallel/test-listen-fd-detached.js
@@ -0,0 +1,115 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+if (common.isWindows)
+  common.skip('This test is disabled on windows.');
+
+const assert = require('assert');
+const http = require('http');
+const net = require('net');
+const spawn = require('child_process').spawn;
+
+switch (process.argv[2]) {
+  case 'child': return child();
+  case 'parent': return parent();
+  default: return test();
+}
+
+// Spawn the parent, and listen for it to tell us the pid of the child.
+// WARNING: This is an example of listening on some arbitrary FD number
+// that has already been bound elsewhere in advance.  However, binding
+// server handles to stdio fd's is NOT a good or reliable way to do
+// concurrency in HTTP servers!  Use the cluster module, or if you want
+// a more low-level approach, use child process IPC manually.
+function test() {
+  const parent = spawn(process.execPath, [__filename, 'parent'], {
+    stdio: [ 0, 'pipe', 2 ]
+  });
+  let json = '';
+  parent.stdout.on('data', function(c) {
+    json += c.toString();
+    if (json.includes('\n')) next();
+  });
+  function next() {
+    console.error('output from parent = %s', json);
+    const child = JSON.parse(json);
+    // Now make sure that we can request to the subprocess, then kill it.
+    http.get({
+      server: 'localhost',
+      port: child.port,
+      path: '/',
+    }).on('response', function(res) {
+      let s = '';
+      res.on('data', function(c) {
+        s += c.toString();
+      });
+      res.on('end', function() {
+        // Kill the subprocess before we start doing asserts.
+        // it's really annoying when tests leave orphans!
+        process.kill(child.pid, 'SIGKILL');
+        try {
+          parent.kill();
+        } catch {
+          // Continue regardless of error.
+        }
+
+        assert.strictEqual(s, 'hello from child\n');
+        assert.strictEqual(res.statusCode, 200);
+      });
+    });
+  }
+}
+
+function parent() {
+  const server = net.createServer(function(conn) {
+    console.error('connection on parent');
+    conn.end('hello from parent\n');
+  }).listen(0, function() {
+    console.error('server listening on %d', this.address().port);
+
+    const child = spawn(process.execPath, [__filename, 'child'], {
+      stdio: [ 'ignore', 'ignore', 'ignore', server._handle ],
+      detached: true
+    });
+
+    console.log('%j\n', { pid: child.pid, port: this.address().port });
+
+    // Now close the parent, so that the child is the only thing
+    // referencing that handle.  Note that connections will still
+    // be accepted, because the child has the fd open, but the parent
+    // will exit gracefully.
+    server.close();
+    child.unref();
+  });
+}
+
+function child() {
+  // Start a server on fd=3
+  http.createServer(function(req, res) {
+    console.error('request on child');
+    console.error('%s %s', req.method, req.url, req.headers);
+    res.end('hello from child\n');
+  }).listen({ fd: 3 }, function() {
+    console.error('child listening on fd=3');
+  });
+}
diff --git a/test/js/node/test/parallel/test-memory-usage-emfile.js b/test/js/node/test/parallel/test-memory-usage-emfile.js
new file mode 100644
index 0000000000..05b112e918
--- /dev/null
+++ b/test/js/node/test/parallel/test-memory-usage-emfile.js
@@ -0,0 +1,18 @@
+'use strict';
+const common = require('../common');
+
+// On IBMi, the rss memory always returns zero
+if (common.isIBMi)
+  common.skip('On IBMi, the rss memory always returns zero');
+
+const assert = require('assert');
+
+const fs = require('fs');
+
+const files = [];
+
+while (files.length < 256)
+  files.push(fs.openSync(__filename, 'r'));
+
+const r = process.memoryUsage.rss();
+assert.strictEqual(r > 0, true);
diff --git a/test/js/node/test/parallel/test-memory-usage.js b/test/js/node/test/parallel/test-memory-usage.js
new file mode 100644
index 0000000000..8e5ea4de5b
--- /dev/null
+++ b/test/js/node/test/parallel/test-memory-usage.js
@@ -0,0 +1,49 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// Flags: --predictable-gc-schedule
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+const r = process.memoryUsage();
+// On IBMi, the rss memory always returns zero
+if (!common.isIBMi) {
+  assert.ok(r.rss > 0);
+  assert.ok(process.memoryUsage.rss() > 0);
+}
+
+assert.ok(r.heapTotal > 0);
+assert.ok(r.heapUsed > 0);
+assert.ok(r.external > 0);
+
+assert.strictEqual(typeof r.arrayBuffers, 'number');
+if (r.arrayBuffers > 0) {
+  const size = 10 * 1024 * 1024;
+  // eslint-disable-next-line no-unused-vars
+  const ab = new ArrayBuffer(size);
+
+  const after = process.memoryUsage();
+  assert.ok(after.external - r.external >= size,
+            `${after.external} - ${r.external} >= ${size}`);
+  assert.strictEqual(after.arrayBuffers - r.arrayBuffers, size,
+                     `${after.arrayBuffers} - ${r.arrayBuffers} === ${size}`);
+}
diff --git a/test/js/node/test/parallel/test-messagechannel.js b/test/js/node/test/parallel/test-messagechannel.js
new file mode 100644
index 0000000000..4f92924daa
--- /dev/null
+++ b/test/js/node/test/parallel/test-messagechannel.js
@@ -0,0 +1,12 @@
+'use strict';
+
+const common = require('../common');
+
+// See: https://github.com/nodejs/node/issues/49940
+(async () => {
+  new MessageChannel().port1.postMessage({}, {
+    transfer: {
+      *[Symbol.iterator]() {}
+    }
+  });
+})().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-messageevent-brandcheck.js b/test/js/node/test/parallel/test-messageevent-brandcheck.js
new file mode 100644
index 0000000000..17f2b708cc
--- /dev/null
+++ b/test/js/node/test/parallel/test-messageevent-brandcheck.js
@@ -0,0 +1,14 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+
+[
+  'data',
+  'origin',
+  'lastEventId',
+  'source',
+  'ports',
+].forEach((i) => {
+  assert.throws(() => Reflect.get(MessageEvent.prototype, i, {}), TypeError);
+});
diff --git a/test/js/node/test/parallel/test-microtask-queue-integration.js b/test/js/node/test/parallel/test-microtask-queue-integration.js
new file mode 100644
index 0000000000..69d55253a2
--- /dev/null
+++ b/test/js/node/test/parallel/test-microtask-queue-integration.js
@@ -0,0 +1,63 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+
+const implementations = [
+  function(fn) {
+    Promise.resolve().then(fn);
+  },
+];
+
+let expected = 0;
+let done = 0;
+
+process.on('exit', function() {
+  assert.strictEqual(done, expected);
+});
+
+function test(scheduleMicrotask) {
+  let nextTickCalled = false;
+  expected++;
+
+  scheduleMicrotask(function() {
+    process.nextTick(function() {
+      nextTickCalled = true;
+    });
+
+    setTimeout(function() {
+      assert(nextTickCalled);
+      done++;
+    }, 0);
+  });
+}
+
+// first tick case
+implementations.forEach(test);
+
+// tick callback case
+setTimeout(function() {
+  implementations.forEach(function(impl) {
+    process.nextTick(test.bind(null, impl));
+  });
+}, 0);
diff --git a/test/js/node/test/parallel/test-microtask-queue-run-immediate.js b/test/js/node/test/parallel/test-microtask-queue-run-immediate.js
new file mode 100644
index 0000000000..577391993b
--- /dev/null
+++ b/test/js/node/test/parallel/test-microtask-queue-run-immediate.js
@@ -0,0 +1,59 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+
+function enqueueMicrotask(fn) {
+  Promise.resolve().then(fn);
+}
+
+let done = 0;
+
+process.on('exit', function() {
+  assert.strictEqual(done, 2);
+});
+
+// No nextTick, microtask
+setImmediate(function() {
+  enqueueMicrotask(function() {
+    done++;
+  });
+});
+
+
+// No nextTick, microtask with nextTick
+setImmediate(function() {
+  let called = false;
+
+  enqueueMicrotask(function() {
+    process.nextTick(function() {
+      called = true;
+    });
+  });
+
+  setImmediate(function() {
+    if (called)
+      done++;
+  });
+
+});
diff --git a/test/js/node/test/parallel/test-microtask-queue-run.js b/test/js/node/test/parallel/test-microtask-queue-run.js
new file mode 100644
index 0000000000..5281cb4f3c
--- /dev/null
+++ b/test/js/node/test/parallel/test-microtask-queue-run.js
@@ -0,0 +1,59 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+
+function enqueueMicrotask(fn) {
+  Promise.resolve().then(fn);
+}
+
+let done = 0;
+
+process.on('exit', function() {
+  assert.strictEqual(done, 2);
+});
+
+// No nextTick, microtask
+setTimeout(function() {
+  enqueueMicrotask(function() {
+    done++;
+  });
+}, 0);
+
+
+// No nextTick, microtask with nextTick
+setTimeout(function() {
+  let called = false;
+
+  enqueueMicrotask(function() {
+    process.nextTick(function() {
+      called = true;
+    });
+  });
+
+  setTimeout(function() {
+    if (called)
+      done++;
+  }, 0);
+
+}, 0);
diff --git a/test/js/node/test/parallel/test-module-builtin.js b/test/js/node/test/parallel/test-module-builtin.js
new file mode 100644
index 0000000000..3897d71ecf
--- /dev/null
+++ b/test/js/node/test/parallel/test-module-builtin.js
@@ -0,0 +1,14 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const { builtinModules } = require('module');
+
+// Includes modules in lib/ (even deprecated ones)
+assert(builtinModules.includes('http'));
+assert(builtinModules.includes('sys'));
+
+// Does not include internal modules
+assert.deepStrictEqual(
+  builtinModules.filter((mod) => mod.startsWith('internal/')),
+  []
+);
diff --git a/test/js/node/test/parallel/test-module-cache.js b/test/js/node/test/parallel/test-module-cache.js
new file mode 100644
index 0000000000..87913c72cc
--- /dev/null
+++ b/test/js/node/test/parallel/test-module-cache.js
@@ -0,0 +1,18 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const fs = require('fs');
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+const filePath = tmpdir.resolve('test-module-cache.json');
+assert.throws(
+  () => require(filePath),
+  { code: 'MODULE_NOT_FOUND' }
+);
+
+fs.writeFileSync(filePath, '[]');
+
+const content = require(filePath);
+assert.strictEqual(Array.isArray(content), true);
+assert.strictEqual(content.length, 0);
diff --git a/test/js/node/test/parallel/test-module-circular-symlinks.js b/test/js/node/test/parallel/test-module-circular-symlinks.js
new file mode 100644
index 0000000000..e8d80640df
--- /dev/null
+++ b/test/js/node/test/parallel/test-module-circular-symlinks.js
@@ -0,0 +1,68 @@
+'use strict';
+
+// This tests to make sure that modules with symlinked circular dependencies
+// do not blow out the module cache and recurse forever. See issue
+// https://github.com/nodejs/node/pull/5950 for context. PR #5950 attempted
+// to solve a problem with symlinked peer dependencies by caching using the
+// symlink path. Unfortunately, that breaks the case tested in this module
+// because each symlinked module, despite pointing to the same code on disk,
+// is loaded and cached as a separate module instance, which blows up the
+// cache and leads to a recursion bug.
+
+// This test should pass in Node.js v4 and v5. It should pass in Node.js v6
+// after https://github.com/nodejs/node/pull/5950 has been reverted.
+
+const common = require('../common');
+const assert = require('assert');
+const path = require('path');
+const fs = require('fs');
+
+// {tmpDir}
+// ├── index.js
+// └── node_modules
+//     ├── moduleA
+//     │   ├── index.js
+//     │   └── node_modules
+//     │       └── moduleB -> {tmpDir}/node_modules/moduleB
+//     └── moduleB
+//         ├── index.js
+//         └── node_modules
+//         └── moduleA -> {tmpDir}/node_modules/moduleA
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+const tmpDir = tmpdir.path;
+
+const node_modules = path.join(tmpDir, 'node_modules');
+const moduleA = path.join(node_modules, 'moduleA');
+const moduleB = path.join(node_modules, 'moduleB');
+const moduleA_link = path.join(moduleB, 'node_modules', 'moduleA');
+const moduleB_link = path.join(moduleA, 'node_modules', 'moduleB');
+
+fs.mkdirSync(node_modules);
+fs.mkdirSync(moduleA);
+fs.mkdirSync(moduleB);
+fs.mkdirSync(path.join(moduleA, 'node_modules'));
+fs.mkdirSync(path.join(moduleB, 'node_modules'));
+
+try {
+  fs.symlinkSync(moduleA, moduleA_link);
+  fs.symlinkSync(moduleB, moduleB_link);
+} catch (err) {
+  if (err.code !== 'EPERM') throw err;
+  common.skip('insufficient privileges for symlinks');
+}
+
+fs.writeFileSync(path.join(tmpDir, 'index.js'),
+                 'module.exports = require(\'moduleA\');', 'utf8');
+fs.writeFileSync(path.join(moduleA, 'index.js'),
+                 'module.exports = {b: require(\'moduleB\')};', 'utf8');
+fs.writeFileSync(path.join(moduleB, 'index.js'),
+                 'module.exports = {a: require(\'moduleA\')};', 'utf8');
+
+// Ensure that the symlinks are not followed forever...
+const obj = require(path.join(tmpDir, 'index'));
+assert.ok(obj);
+assert.ok(obj.b);
+assert.ok(obj.b.a);
+assert.ok(!obj.b.a.b);
diff --git a/test/js/node/test/parallel/test-module-main-extension-lookup.js b/test/js/node/test/parallel/test-module-main-extension-lookup.js
new file mode 100644
index 0000000000..58d78e09b1
--- /dev/null
+++ b/test/js/node/test/parallel/test-module-main-extension-lookup.js
@@ -0,0 +1,9 @@
+'use strict';
+require('../common');
+const fixtures = require('../common/fixtures');
+const { execFileSync } = require('child_process');
+
+const node = process.argv[0];
+
+execFileSync(node, [fixtures.path('es-modules', 'test-esm-ok.mjs')]);
+execFileSync(node, [fixtures.path('es-modules', 'noext')]);
diff --git a/test/js/node/test/parallel/test-module-readonly.js b/test/js/node/test/parallel/test-module-readonly.js
new file mode 100644
index 0000000000..ad9fbf7d21
--- /dev/null
+++ b/test/js/node/test/parallel/test-module-readonly.js
@@ -0,0 +1,48 @@
+'use strict';
+
+const common = require('../common');
+
+if (!common.isWindows) {
+  // TODO: Similar checks on *nix-like systems (e.g using chmod or the like)
+  common.skip('test only runs on Windows');
+}
+
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const cp = require('child_process');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+// Create readOnlyMod.js and set to read only
+const readOnlyMod = tmpdir.resolve('readOnlyMod');
+const readOnlyModRelative = path.relative(__dirname, readOnlyMod);
+const readOnlyModFullPath = `${readOnlyMod}.js`;
+
+fs.writeFileSync(readOnlyModFullPath, 'module.exports = 42;');
+
+// Removed any inherited ACEs, and any explicitly granted ACEs for the
+// current user
+cp.execSync(
+  `icacls.exe "${readOnlyModFullPath}" /inheritance:r /remove "%USERNAME%"`);
+
+// Grant the current user read & execute only
+cp.execSync(`icacls.exe "${readOnlyModFullPath}" /grant "%USERNAME%":RX`);
+
+let except = null;
+try {
+  // Attempt to load the module. Will fail if write access is required
+  require(readOnlyModRelative);
+} catch (err) {
+  except = err;
+}
+
+// Remove the explicitly granted rights, and re-enable inheritance
+cp.execSync(
+  `icacls.exe "${readOnlyModFullPath}" /remove "%USERNAME%" /inheritance:e`);
+
+// Delete the test module (note: tmpdir should get cleaned anyway)
+fs.unlinkSync(readOnlyModFullPath);
+
+assert.ifError(except);
diff --git a/test/js/node/test/parallel/test-module-relative-lookup.js b/test/js/node/test/parallel/test-module-relative-lookup.js
new file mode 100644
index 0000000000..1bd505392c
--- /dev/null
+++ b/test/js/node/test/parallel/test-module-relative-lookup.js
@@ -0,0 +1,24 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const _module = require('module'); // Avoid collision with global.module
+
+// Current directory gets highest priority for local modules
+function testFirstInPath(moduleName, isLocalModule) {
+  const assertFunction = isLocalModule ?
+    assert.strictEqual :
+    assert.notStrictEqual;
+
+  let paths = _module._resolveLookupPaths(moduleName);
+
+  assertFunction(paths[0], '.');
+
+  paths = _module._resolveLookupPaths(moduleName, null);
+  assertFunction(paths && paths[0], '.');
+}
+
+testFirstInPath('./lodash', true);
+
+// Relative path on Windows, but a regular file name elsewhere
+testFirstInPath('.\\lodash', common.isWindows);
diff --git a/test/js/node/test/parallel/test-net-autoselectfamily-attempt-timeout-default-value.js b/test/js/node/test/parallel/test-net-autoselectfamily-attempt-timeout-default-value.js
new file mode 100644
index 0000000000..7822769527
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-autoselectfamily-attempt-timeout-default-value.js
@@ -0,0 +1,8 @@
+'use strict';
+
+const { platformTimeout } = require('../common');
+
+const assert = require('assert');
+const { getDefaultAutoSelectFamilyAttemptTimeout } = require('net');
+
+assert.strictEqual(getDefaultAutoSelectFamilyAttemptTimeout(), platformTimeout(2500));
diff --git a/test/js/node/test/parallel/test-net-bind-twice.js b/test/js/node/test/parallel/test-net-bind-twice.js
new file mode 100644
index 0000000000..f59818a1e8
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-bind-twice.js
@@ -0,0 +1,36 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const net = require('net');
+
+const server1 = net.createServer(common.mustNotCall());
+server1.listen(0, '127.0.0.1', common.mustCall(function() {
+  const server2 = net.createServer(common.mustNotCall());
+  server2.listen(this.address().port, '127.0.0.1', common.mustNotCall());
+
+  server2.on('error', common.mustCall(function(e) {
+    assert.strictEqual(e.code, 'EADDRINUSE');
+    server1.close();
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-net-buffersize.js b/test/js/node/test/parallel/test-net-buffersize.js
new file mode 100644
index 0000000000..7225d70af3
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-buffersize.js
@@ -0,0 +1,52 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const net = require('net');
+
+const iter = 10;
+
+const server = net.createServer(function(socket) {
+  socket.on('readable', function() {
+    socket.read();
+  });
+
+  socket.on('end', function() {
+    server.close();
+  });
+});
+
+server.listen(0, common.mustCall(function() {
+  const client = net.connect(this.address().port);
+
+  client.on('finish', common.mustCall(() => {
+    assert.strictEqual(client.bufferSize, 0);
+  }));
+
+  for (let i = 1; i < iter; i++) {
+    client.write('a');
+    assert.strictEqual(client.bufferSize, i);
+  }
+
+  client.end();
+}));
diff --git a/test/js/node/test/parallel/test-net-connect-call-socket-connect.js b/test/js/node/test/parallel/test-net-connect-call-socket-connect.js
new file mode 100644
index 0000000000..88551889fe
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-connect-call-socket-connect.js
@@ -0,0 +1,39 @@
+'use strict';
+const common = require('../common');
+
+// This test checks that calling `net.connect` internally calls
+// `Socket.prototype.connect`.
+//
+// This is important for people who monkey-patch `Socket.prototype.connect`
+// since it's not possible to monkey-patch `net.connect` directly (as the core
+// `connect` function is called internally in Node instead of calling the
+// `exports.connect` function).
+//
+// Monkey-patching of `Socket.prototype.connect` is done by - among others -
+// most APM vendors, the async-listener module and the
+// continuation-local-storage module.
+//
+// Related:
+// - https://github.com/nodejs/node/pull/12342
+// - https://github.com/nodejs/node/pull/12852
+
+const net = require('net');
+const Socket = net.Socket;
+
+// Monkey patch Socket.prototype.connect to check that it's called.
+const orig = Socket.prototype.connect;
+Socket.prototype.connect = common.mustCall(function() {
+  return orig.apply(this, arguments);
+});
+
+const server = net.createServer();
+
+server.listen(common.mustCall(function() {
+  const port = server.address().port;
+  const client = net.connect({ port }, common.mustCall(function() {
+    client.end();
+  }));
+  client.on('end', common.mustCall(function() {
+    server.close();
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-net-connect-destroy.js b/test/js/node/test/parallel/test-net-connect-destroy.js
new file mode 100644
index 0000000000..73fdb988f9
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-connect-destroy.js
@@ -0,0 +1,7 @@
+'use strict';
+const common = require('../common');
+const net = require('net');
+
+const socket = new net.Socket();
+socket.on('close', common.mustCall());
+socket.destroy();
diff --git a/test/js/node/test/parallel/test-net-connect-immediate-destroy.js b/test/js/node/test/parallel/test-net-connect-immediate-destroy.js
new file mode 100644
index 0000000000..3ca58c356b
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-connect-immediate-destroy.js
@@ -0,0 +1,11 @@
+'use strict';
+const common = require('../common');
+const net = require('net');
+
+const server = net.createServer();
+server.listen(0);
+const port = server.address().port;
+const socket = net.connect(port, common.localhostIPv4, common.mustNotCall());
+socket.on('error', common.mustNotCall());
+server.close();
+socket.destroy();
diff --git a/test/js/node/test/parallel/test-net-connect-options-path.js b/test/js/node/test/parallel/test-net-connect-options-path.js
new file mode 100644
index 0000000000..61de8caab1
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-connect-options-path.js
@@ -0,0 +1,59 @@
+'use strict';
+const common = require('../common');
+const net = require('net');
+
+// This file tests the option handling of net.connect,
+// net.createConnect, and new Socket().connect
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+const CLIENT_VARIANTS = 12;
+
+// Test connect(path)
+{
+  const prefix = `${common.PIPE}-net-connect-options-path`;
+  const serverPath = `${prefix}-server`;
+  let counter = 0;
+  const server = net.createServer()
+  .on('connection', common.mustCall(function(socket) {
+    socket.end('ok');
+  }, CLIENT_VARIANTS))
+  .listen(serverPath, common.mustCall(function() {
+    const getConnectCb = () => common.mustCall(function() {
+      this.end();
+      this.on('close', common.mustCall(function() {
+        counter++;
+        if (counter === CLIENT_VARIANTS) {
+          server.close();
+        }
+      }));
+    });
+
+    // CLIENT_VARIANTS depends on the following code
+    net.connect(serverPath, getConnectCb()).resume();
+    net.connect(serverPath)
+      .on('connect', getConnectCb())
+      .resume();
+    net.createConnection(serverPath, getConnectCb()).resume();
+    net.createConnection(serverPath)
+      .on('connect', getConnectCb())
+      .resume();
+    new net.Socket().connect(serverPath, getConnectCb()).resume();
+    new net.Socket().connect(serverPath)
+      .on('connect', getConnectCb())
+      .resume();
+    net.connect({ path: serverPath }, getConnectCb()).resume();
+    net.connect({ path: serverPath })
+      .on('connect', getConnectCb())
+      .resume();
+    net.createConnection({ path: serverPath }, getConnectCb()).resume();
+    net.createConnection({ path: serverPath })
+      .on('connect', getConnectCb())
+      .resume();
+    new net.Socket().connect({ path: serverPath }, getConnectCb()).resume();
+    new net.Socket().connect({ path: serverPath })
+      .on('connect', getConnectCb())
+      .resume();
+  }));
+}
diff --git a/test/js/node/test/parallel/test-net-dns-lookup-skip.js b/test/js/node/test/parallel/test-net-dns-lookup-skip.js
new file mode 100644
index 0000000000..06dbd5932b
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-dns-lookup-skip.js
@@ -0,0 +1,19 @@
+'use strict';
+const common = require('../common');
+const net = require('net');
+
+function check(addressType) {
+  const server = net.createServer(function(client) {
+    client.end();
+    server.close();
+  });
+
+  const address = addressType === 4 ? '127.0.0.1' : '::1';
+  server.listen(0, address, function() {
+    net.connect(this.address().port, address)
+      .on('lookup', common.mustNotCall());
+  });
+}
+
+check(4);
+common.hasIPv6 && check(6);
diff --git a/test/js/node/test/parallel/test-net-during-close.js b/test/js/node/test/parallel/test-net-during-close.js
new file mode 100644
index 0000000000..3670ed9c27
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-during-close.js
@@ -0,0 +1,42 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const net = require('net');
+
+const server = net.createServer(function(socket) {
+  socket.end();
+});
+
+server.listen(0, common.mustCall(function() {
+  /* eslint-disable no-unused-expressions */
+  const client = net.createConnection(this.address().port);
+  server.close();
+  // Server connection event has not yet fired client is still attempting to
+  // connect. Accessing properties should not throw in this case.
+  client.remoteAddress;
+  client.remoteFamily;
+  client.remotePort;
+  // Exit now, do not wait for the client error event.
+  process.exit(0);
+  /* eslint-enable no-unused-expressions */
+}));
diff --git a/test/js/node/test/parallel/test-net-end-without-connect.js b/test/js/node/test/parallel/test-net-end-without-connect.js
new file mode 100644
index 0000000000..45d0b5477e
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-end-without-connect.js
@@ -0,0 +1,30 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const net = require('net');
+const assert = require('assert');
+
+const sock = new net.Socket();
+sock.end(common.mustCall(() => {
+  assert.strictEqual(sock.writable, false);
+}));
diff --git a/test/js/node/test/parallel/test-net-isip.js b/test/js/node/test/parallel/test-net-isip.js
new file mode 100644
index 0000000000..840ffe76af
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-isip.js
@@ -0,0 +1,96 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const net = require('net');
+
+assert.strictEqual(net.isIP('127.0.0.1'), 4);
+assert.strictEqual(net.isIP('x127.0.0.1'), 0);
+assert.strictEqual(net.isIP('example.com'), 0);
+assert.strictEqual(net.isIP('0000:0000:0000:0000:0000:0000:0000:0000'), 6);
+assert.strictEqual(net.isIP('0000:0000:0000:0000:0000:0000:0000:0000::0000'),
+                   0);
+assert.strictEqual(net.isIP('1050:0:0:0:5:600:300c:326b'), 6);
+assert.strictEqual(net.isIP('2001:252:0:1::2008:6'), 6);
+assert.strictEqual(net.isIP('2001:dead:beef:1::2008:6'), 6);
+assert.strictEqual(net.isIP('2001::'), 6);
+assert.strictEqual(net.isIP('2001:dead::'), 6);
+assert.strictEqual(net.isIP('2001:dead:beef::'), 6);
+assert.strictEqual(net.isIP('2001:dead:beef:1::'), 6);
+assert.strictEqual(net.isIP('ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff'), 6);
+assert.strictEqual(net.isIP(':2001:252:0:1::2008:6:'), 0);
+assert.strictEqual(net.isIP(':2001:252:0:1::2008:6'), 0);
+assert.strictEqual(net.isIP('2001:252:0:1::2008:6:'), 0);
+assert.strictEqual(net.isIP('2001:252::1::2008:6'), 0);
+assert.strictEqual(net.isIP('::2001:252:1:2008:6'), 6);
+assert.strictEqual(net.isIP('::2001:252:1:1.1.1.1'), 6);
+assert.strictEqual(net.isIP('::2001:252:1:255.255.255.255'), 6);
+assert.strictEqual(net.isIP('::2001:252:1:255.255.255.255.76'), 0);
+assert.strictEqual(net.isIP('fe80::2008%eth0'), 6);
+assert.strictEqual(net.isIP('fe80::2008%eth0.0'), 6);
+assert.strictEqual(net.isIP('fe80::2008%eth0@1'), 0);
+assert.strictEqual(net.isIP('::anything'), 0);
+assert.strictEqual(net.isIP('::1'), 6);
+assert.strictEqual(net.isIP('::'), 6);
+assert.strictEqual(net.isIP('0000:0000:0000:0000:0000:0000:12345:0000'), 0);
+assert.strictEqual(net.isIP('0'), 0);
+assert.strictEqual(net.isIP(), 0);
+assert.strictEqual(net.isIP(''), 0);
+assert.strictEqual(net.isIP(null), 0);
+assert.strictEqual(net.isIP(123), 0);
+assert.strictEqual(net.isIP(true), 0);
+assert.strictEqual(net.isIP({}), 0);
+assert.strictEqual(net.isIP({ toString: () => '::2001:252:1:255.255.255.255' }),
+                   6);
+assert.strictEqual(net.isIP({ toString: () => '127.0.0.1' }), 4);
+assert.strictEqual(net.isIP({ toString: () => 'bla' }), 0);
+
+assert.strictEqual(net.isIPv4('127.0.0.1'), true);
+assert.strictEqual(net.isIPv4('example.com'), false);
+assert.strictEqual(net.isIPv4('2001:252:0:1::2008:6'), false);
+assert.strictEqual(net.isIPv4(), false);
+assert.strictEqual(net.isIPv4(''), false);
+assert.strictEqual(net.isIPv4(null), false);
+assert.strictEqual(net.isIPv4(123), false);
+assert.strictEqual(net.isIPv4(true), false);
+assert.strictEqual(net.isIPv4({}), false);
+assert.strictEqual(net.isIPv4({
+  toString: () => '::2001:252:1:255.255.255.255'
+}), false);
+assert.strictEqual(net.isIPv4({ toString: () => '127.0.0.1' }), true);
+assert.strictEqual(net.isIPv4({ toString: () => 'bla' }), false);
+
+assert.strictEqual(net.isIPv6('127.0.0.1'), false);
+assert.strictEqual(net.isIPv6('example.com'), false);
+assert.strictEqual(net.isIPv6('2001:252:0:1::2008:6'), true);
+assert.strictEqual(net.isIPv6(), false);
+assert.strictEqual(net.isIPv6(''), false);
+assert.strictEqual(net.isIPv6(null), false);
+assert.strictEqual(net.isIPv6(123), false);
+assert.strictEqual(net.isIPv6(true), false);
+assert.strictEqual(net.isIPv6({}), false);
+assert.strictEqual(net.isIPv6({
+  toString: () => '::2001:252:1:255.255.255.255'
+}), true);
+assert.strictEqual(net.isIPv6({ toString: () => '127.0.0.1' }), false);
+assert.strictEqual(net.isIPv6({ toString: () => 'bla' }), false);
diff --git a/test/js/node/test/parallel/test-net-isipv4.js b/test/js/node/test/parallel/test-net-isipv4.js
new file mode 100644
index 0000000000..2c478e6ac6
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-isipv4.js
@@ -0,0 +1,46 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const net = require('net');
+
+const v4 = [
+  '0.0.0.0',
+  '8.8.8.8',
+  '127.0.0.1',
+  '100.100.100.100',
+  '192.168.0.1',
+  '18.101.25.153',
+  '123.23.34.2',
+  '172.26.168.134',
+  '212.58.241.131',
+  '128.0.0.0',
+  '23.71.254.72',
+  '223.255.255.255',
+  '192.0.2.235',
+  '99.198.122.146',
+  '46.51.197.88',
+  '173.194.34.134',
+];
+
+const v4not = [
+  '.100.100.100.100',
+  '100..100.100.100.',
+  '100.100.100.100.',
+  '999.999.999.999',
+  '256.256.256.256',
+  '256.100.100.100.100',
+  '123.123.123',
+  'http://123.123.123',
+  '1000.2.3.4',
+  '999.2.3.4',
+  '0000000192.168.0.200',
+  '192.168.0.2000000000',
+];
+
+for (const ip of v4) {
+  assert.strictEqual(net.isIPv4(ip), true);
+}
+
+for (const ip of v4not) {
+  assert.strictEqual(net.isIPv4(ip), false);
+}
diff --git a/test/js/node/test/parallel/test-net-isipv6.js b/test/js/node/test/parallel/test-net-isipv6.js
new file mode 100644
index 0000000000..dbb8d80b7b
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-isipv6.js
@@ -0,0 +1,244 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const net = require('net');
+
+const v6 = [
+  '::',
+  '1::',
+  '::1',
+  '1::8',
+  '1::7:8',
+  '1:2:3:4:5:6:7:8',
+  '1:2:3:4:5:6::8',
+  '1:2:3:4:5:6:7::',
+  '1:2:3:4:5::7:8',
+  '1:2:3:4:5::8',
+  '1:2:3::8',
+  '1::4:5:6:7:8',
+  '1::6:7:8',
+  '1::3:4:5:6:7:8',
+  '1:2:3:4::6:7:8',
+  '1:2::4:5:6:7:8',
+  '::2:3:4:5:6:7:8',
+  '1:2::8',
+  '2001:0000:1234:0000:0000:C1C0:ABCD:0876',
+  '3ffe:0b00:0000:0000:0001:0000:0000:000a',
+  'FF02:0000:0000:0000:0000:0000:0000:0001',
+  '0000:0000:0000:0000:0000:0000:0000:0001',
+  '0000:0000:0000:0000:0000:0000:0000:0000',
+  '::ffff:192.168.1.26',
+  '2::10',
+  'ff02::1',
+  'fe80::',
+  '2002::',
+  '2001:db8::',
+  '2001:0db8:1234::',
+  '::ffff:0:0',
+  '::ffff:192.168.1.1',
+  '1:2:3:4::8',
+  '1::2:3:4:5:6:7',
+  '1::2:3:4:5:6',
+  '1::2:3:4:5',
+  '1::2:3:4',
+  '1::2:3',
+  '::2:3:4:5:6:7',
+  '::2:3:4:5:6',
+  '::2:3:4:5',
+  '::2:3:4',
+  '::2:3',
+  '::8',
+  '1:2:3:4:5:6::',
+  '1:2:3:4:5::',
+  '1:2:3:4::',
+  '1:2:3::',
+  '1:2::',
+  '1:2:3:4::7:8',
+  '1:2:3::7:8',
+  '1:2::7:8',
+  '1:2:3:4:5:6:1.2.3.4',
+  '1:2:3:4:5::1.2.3.4',
+  '1:2:3:4::1.2.3.4',
+  '1:2:3::1.2.3.4',
+  '1:2::1.2.3.4',
+  '1::1.2.3.4',
+  '1:2:3:4::5:1.2.3.4',
+  '1:2:3::5:1.2.3.4',
+  '1:2::5:1.2.3.4',
+  '1::5:1.2.3.4',
+  '1::5:11.22.33.44',
+  'fe80::217:f2ff:254.7.237.98',
+  'fe80::217:f2ff:fe07:ed62',
+  '2001:DB8:0:0:8:800:200C:417A',
+  'FF01:0:0:0:0:0:0:101',
+  '0:0:0:0:0:0:0:1',
+  '0:0:0:0:0:0:0:0',
+  '2001:DB8::8:800:200C:417A',
+  'FF01::101',
+  '0:0:0:0:0:0:13.1.68.3',
+  '0:0:0:0:0:FFFF:129.144.52.38',
+  '::13.1.68.3',
+  '::FFFF:129.144.52.38',
+  'fe80:0000:0000:0000:0204:61ff:fe9d:f156',
+  'fe80:0:0:0:204:61ff:fe9d:f156',
+  'fe80::204:61ff:fe9d:f156',
+  'fe80:0:0:0:204:61ff:254.157.241.86',
+  'fe80::204:61ff:254.157.241.86',
+  'fe80::1',
+  '2001:0db8:85a3:0000:0000:8a2e:0370:7334',
+  '2001:db8:85a3:0:0:8a2e:370:7334',
+  '2001:db8:85a3::8a2e:370:7334',
+  '2001:0db8:0000:0000:0000:0000:1428:57ab',
+  '2001:0db8:0000:0000:0000::1428:57ab',
+  '2001:0db8:0:0:0:0:1428:57ab',
+  '2001:0db8:0:0::1428:57ab',
+  '2001:0db8::1428:57ab',
+  '2001:db8::1428:57ab',
+  '::ffff:12.34.56.78',
+  '::ffff:0c22:384e',
+  '2001:0db8:1234:0000:0000:0000:0000:0000',
+  '2001:0db8:1234:ffff:ffff:ffff:ffff:ffff',
+  '2001:db8:a::123',
+  '::ffff:192.0.2.128',
+  '::ffff:c000:280',
+  'a:b:c:d:e:f:f1:f2',
+  'a:b:c::d:e:f:f1',
+  'a:b:c::d:e:f',
+  'a:b:c::d:e',
+  'a:b:c::d',
+  '::a',
+  '::a:b:c',
+  '::a:b:c:d:e:f:f1',
+  'a::',
+  'a:b:c::',
+  'a:b:c:d:e:f:f1::',
+  'a:bb:ccc:dddd:000e:00f:0f::',
+  '0:a:0:a:0:0:0:a',
+  '0:a:0:0:a:0:0:a',
+  '2001:db8:1:1:1:1:0:0',
+  '2001:db8:1:1:1:0:0:0',
+  '2001:db8:1:1:0:0:0:0',
+  '2001:db8:1:0:0:0:0:0',
+  '2001:db8:0:0:0:0:0:0',
+  '2001:0:0:0:0:0:0:0',
+  'A:BB:CCC:DDDD:000E:00F:0F::',
+  '0:0:0:0:0:0:0:a',
+  '0:0:0:0:a:0:0:0',
+  '0:0:0:a:0:0:0:0',
+  'a:0:0:a:0:0:a:a',
+  'a:0:0:a:0:0:0:a',
+  'a:0:0:0:a:0:0:a',
+  'a:0:0:0:a:0:0:0',
+  'a:0:0:0:0:0:0:0',
+  'fe80::7:8%eth0',
+  'fe80::7:8%1',
+];
+
+const v6not = [
+  '',
+  '1:',
+  ':1',
+  '11:36:12',
+  '02001:0000:1234:0000:0000:C1C0:ABCD:0876',
+  '2001:0000:1234:0000:00001:C1C0:ABCD:0876',
+  '2001:0000:1234: 0000:0000:C1C0:ABCD:0876',
+  '2001:1:1:1:1:1:255Z255X255Y255',
+  '3ffe:0b00:0000:0001:0000:0000:000a',
+  'FF02:0000:0000:0000:0000:0000:0000:0000:0001',
+  '3ffe:b00::1::a',
+  '::1111:2222:3333:4444:5555:6666::',
+  '1:2:3::4:5::7:8',
+  '12345::6:7:8',
+  '1::5:400.2.3.4',
+  '1::5:260.2.3.4',
+  '1::5:256.2.3.4',
+  '1::5:1.256.3.4',
+  '1::5:1.2.256.4',
+  '1::5:1.2.3.256',
+  '1::5:300.2.3.4',
+  '1::5:1.300.3.4',
+  '1::5:1.2.300.4',
+  '1::5:1.2.3.300',
+  '1::5:900.2.3.4',
+  '1::5:1.900.3.4',
+  '1::5:1.2.900.4',
+  '1::5:1.2.3.900',
+  '1::5:300.300.300.300',
+  '1::5:3000.30.30.30',
+  '1::400.2.3.4',
+  '1::260.2.3.4',
+  '1::256.2.3.4',
+  '1::1.256.3.4',
+  '1::1.2.256.4',
+  '1::1.2.3.256',
+  '1::300.2.3.4',
+  '1::1.300.3.4',
+  '1::1.2.300.4',
+  '1::1.2.3.300',
+  '1::900.2.3.4',
+  '1::1.900.3.4',
+  '1::1.2.900.4',
+  '1::1.2.3.900',
+  '1::300.300.300.300',
+  '1::3000.30.30.30',
+  '::400.2.3.4',
+  '::260.2.3.4',
+  '::256.2.3.4',
+  '::1.256.3.4',
+  '::1.2.256.4',
+  '::1.2.3.256',
+  '::300.2.3.4',
+  '::1.300.3.4',
+  '::1.2.300.4',
+  '::1.2.3.300',
+  '::900.2.3.4',
+  '::1.900.3.4',
+  '::1.2.900.4',
+  '::1.2.3.900',
+  '::300.300.300.300',
+  '::3000.30.30.30',
+  '2001:DB8:0:0:8:800:200C:417A:221',
+  'FF01::101::2',
+  '1111:2222:3333:4444::5555:',
+  '1111:2222:3333::5555:',
+  '1111:2222::5555:',
+  '1111::5555:',
+  '::5555:',
+  ':::',
+  '1111:',
+  ':',
+  ':1111:2222:3333:4444::5555',
+  ':1111:2222:3333::5555',
+  ':1111:2222::5555',
+  ':1111::5555',
+  ':::5555',
+  '1.2.3.4:1111:2222:3333:4444::5555',
+  '1.2.3.4:1111:2222:3333::5555',
+  '1.2.3.4:1111:2222::5555',
+  '1.2.3.4:1111::5555',
+  '1.2.3.4::5555',
+  '1.2.3.4::',
+  'fe80:0000:0000:0000:0204:61ff:254.157.241.086',
+  '123',
+  'ldkfj',
+  '2001::FFD3::57ab',
+  '2001:db8:85a3::8a2e:37023:7334',
+  '2001:db8:85a3::8a2e:370k:7334',
+  '1:2:3:4:5:6:7:8:9',
+  '1::2::3',
+  '1:::3:4:5',
+  '1:2:3::4:5:6:7:8:9',
+  '::ffff:2.3.4',
+  '::ffff:257.1.2.3',
+  '::ffff:12345678901234567890.1.26',
+  '2001:0000:1234:0000:0000:C1C0:ABCD:0876 0',
+  '02001:0000:1234:0000:0000:C1C0:ABCD:0876',
+];
+
+for (const ip of v6) {
+  assert.strictEqual(net.isIPv6(ip), true);
+}
+
+for (const ip of v6not) {
+  assert.strictEqual(net.isIPv6(ip), false);
+}
diff --git a/test/js/node/test/parallel/test-net-listen-after-destroying-stdin.js b/test/js/node/test/parallel/test-net-listen-after-destroying-stdin.js
new file mode 100644
index 0000000000..4ffec304be
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-listen-after-destroying-stdin.js
@@ -0,0 +1,22 @@
+'use strict';
+// Just test that destroying stdin doesn't mess up listening on a server.
+// This is a regression test for
+// https://github.com/nodejs/node-v0.x-archive/issues/746.
+
+const common = require('../common');
+const net = require('net');
+
+process.stdin.destroy();
+
+const server = net.createServer(common.mustCall((socket) => {
+  console.log('accepted...');
+  socket.end(common.mustCall(() => { console.log('finished...'); }));
+  server.close(common.mustCall(() => { console.log('closed'); }));
+}));
+
+
+server.listen(0, common.mustCall(() => {
+  console.log('listening...');
+
+  net.createConnection(server.address().port);
+}));
diff --git a/test/js/node/test/parallel/test-net-listen-error.js b/test/js/node/test/parallel/test-net-listen-error.js
new file mode 100644
index 0000000000..05ca799d3e
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-listen-error.js
@@ -0,0 +1,29 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const net = require('net');
+
+const server = net.createServer(function(socket) {
+});
+server.listen(1, '1.1.1.1', common.mustNotCall()); // EACCES or EADDRNOTAVAIL
+server.on('error', common.mustCall());
diff --git a/test/js/node/test/parallel/test-net-listen-exclusive-random-ports.js b/test/js/node/test/parallel/test-net-listen-exclusive-random-ports.js
new file mode 100644
index 0000000000..66dfb59820
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-listen-exclusive-random-ports.js
@@ -0,0 +1,37 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const cluster = require('cluster');
+const net = require('net');
+
+if (cluster.isPrimary) {
+  const worker1 = cluster.fork();
+
+  worker1.on('message', function(port1) {
+    assert.strictEqual(port1, port1 | 0,
+                       `first worker could not listen on port ${port1}`);
+    const worker2 = cluster.fork();
+
+    worker2.on('message', function(port2) {
+      assert.strictEqual(port2, port2 | 0,
+                         `second worker could not listen on port ${port2}`);
+      assert.notStrictEqual(port1, port2, 'ports should not be equal');
+      worker1.kill();
+      worker2.kill();
+    });
+  });
+} else {
+  const server = net.createServer(() => {});
+
+  server.on('error', function(err) {
+    process.send(err.code);
+  });
+
+  server.listen({
+    port: 0,
+    exclusive: true
+  }, function() {
+    process.send(server.address().port);
+  });
+}
diff --git a/test/js/node/test/parallel/test-net-listen-handle-in-cluster-1.js b/test/js/node/test/parallel/test-net-listen-handle-in-cluster-1.js
new file mode 100644
index 0000000000..07e002bf2a
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-listen-handle-in-cluster-1.js
@@ -0,0 +1,27 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const net = require('net');
+const cluster = require('cluster');
+
+// Test if the worker can listen with handle successfully
+if (cluster.isPrimary) {
+  const worker = cluster.fork();
+  const server = net.createServer();
+  worker.on('online', common.mustCall(() => {
+    server.listen(common.mustCall(() => {
+      // Send the server to worker
+      worker.send(null, server);
+    }));
+  }));
+  worker.on('exit', common.mustCall(() => {
+    server.close();
+  }));
+} else {
+  // The `got` function of net.Server will create a TCP server by listen(handle)
+  // See lib/internal/child_process.js
+  process.on('message', common.mustCall((_, server) => {
+    assert.strictEqual(server instanceof net.Server, true);
+    process.exit(0);
+  }));
+}
diff --git a/test/js/node/test/parallel/test-net-listening.js b/test/js/node/test/parallel/test-net-listening.js
new file mode 100644
index 0000000000..8f2880b0bf
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-listening.js
@@ -0,0 +1,16 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const net = require('net');
+
+const server = net.createServer();
+
+assert.strictEqual(server.listening, false);
+
+server.listen(0, common.mustCall(() => {
+  assert.strictEqual(server.listening, true);
+
+  server.close(common.mustCall(() => {
+    assert.strictEqual(server.listening, false);
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-net-local-address-port.js b/test/js/node/test/parallel/test-net-local-address-port.js
new file mode 100644
index 0000000000..cfc6f61ef3
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-local-address-port.js
@@ -0,0 +1,43 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const net = require('net');
+
+const server = net.createServer(common.mustCall(function(socket) {
+  assert.strictEqual(socket.localAddress, common.localhostIPv4);
+  assert.strictEqual(socket.localPort, this.address().port);
+  assert.strictEqual(socket.localFamily, this.address().family);
+  socket.on('end', function() {
+    server.close();
+  });
+  socket.resume();
+}));
+
+server.listen(0, common.localhostIPv4, function() {
+  const client = net.createConnection(this.address()
+                    .port, common.localhostIPv4);
+  client.on('connect', function() {
+    client.end();
+  });
+});
diff --git a/test/js/node/test/parallel/test-net-remote-address.js b/test/js/node/test/parallel/test-net-remote-address.js
new file mode 100644
index 0000000000..a116cb99d3
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-remote-address.js
@@ -0,0 +1,23 @@
+'use strict';
+
+const common = require('../common');
+const net = require('net');
+const { strictEqual } = require('assert');
+
+const server = net.createServer();
+
+server.listen(common.mustCall(function() {
+  const socket = net.connect({ port: server.address().port });
+
+  strictEqual(socket.connecting, true);
+  strictEqual(socket.remoteAddress, undefined);
+
+  socket.on('connect', common.mustCall(function() {
+    strictEqual(socket.remoteAddress !== undefined, true);
+    socket.end();
+  }));
+
+  socket.on('end', common.mustCall(function() {
+    server.close();
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-net-server-close-before-ipc-response.js b/test/js/node/test/parallel/test-net-server-close-before-ipc-response.js
new file mode 100644
index 0000000000..e85bc96ee6
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-server-close-before-ipc-response.js
@@ -0,0 +1,22 @@
+'use strict';
+
+const common = require('../common');
+const net = require('net');
+const cluster = require('cluster');
+
+// Process should exit
+if (cluster.isPrimary) {
+  cluster.fork();
+} else {
+  const send = process.send;
+  process.send = function(message) {
+    // listenOnPrimaryHandle in net.js should call handle.close()
+    if (message.act === 'close') {
+      setImmediate(() => {
+        process.disconnect();
+      });
+    }
+    return send.apply(this, arguments);
+  };
+  net.createServer().listen(0, common.mustNotCall()).close();
+}
diff --git a/test/js/node/test/parallel/test-net-server-close.js b/test/js/node/test/parallel/test-net-server-close.js
new file mode 100644
index 0000000000..8291f70432
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-server-close.js
@@ -0,0 +1,45 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const net = require('net');
+
+const sockets = [];
+
+const server = net.createServer(function(c) {
+  c.on('close', common.mustCall());
+
+  sockets.push(c);
+
+  if (sockets.length === 2) {
+    assert.strictEqual(server.close(), server);
+    sockets.forEach((c) => c.destroy());
+  }
+});
+
+server.on('close', common.mustCall());
+
+assert.strictEqual(server, server.listen(0, () => {
+  net.createConnection(server.address().port);
+  net.createConnection(server.address().port);
+}));
diff --git a/test/js/node/test/parallel/test-net-server-listen-remove-callback.js b/test/js/node/test/parallel/test-net-server-listen-remove-callback.js
new file mode 100644
index 0000000000..a874099fb8
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-server-listen-remove-callback.js
@@ -0,0 +1,44 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const net = require('net');
+
+// Server should only fire listen callback once
+const server = net.createServer();
+
+server.on('close', function() {
+  const listeners = server.listeners('listening');
+  console.log('Closed, listeners:', listeners.length);
+  assert.strictEqual(listeners.length, 0);
+});
+
+server.listen(0, function() {
+  server.close();
+});
+
+server.once('close', function() {
+  server.listen(0, function() {
+    server.close();
+  });
+});
diff --git a/test/js/node/test/parallel/test-net-server-unref.js b/test/js/node/test/parallel/test-net-server-unref.js
new file mode 100644
index 0000000000..935ba5d639
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-server-unref.js
@@ -0,0 +1,30 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const net = require('net');
+
+const s = net.createServer();
+s.listen(0);
+s.unref();
+
+setTimeout(common.mustNotCall(), 1000).unref();
diff --git a/test/js/node/test/parallel/test-net-socket-byteswritten.js b/test/js/node/test/parallel/test-net-socket-byteswritten.js
new file mode 100644
index 0000000000..b7b7af89e2
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-socket-byteswritten.js
@@ -0,0 +1,35 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const net = require('net');
+
+const server = net.createServer(function(socket) {
+  socket.end();
+});
+
+server.listen(0, common.mustCall(function() {
+  const socket = net.connect(server.address().port);
+
+  // Cork the socket, then write twice; this should cause a writev, which
+  // previously caused an err in the bytesWritten count.
+  socket.cork();
+
+  socket.write('one');
+  socket.write(Buffer.from('twø', 'utf8'));
+
+  socket.uncork();
+
+  // one = 3 bytes, twø = 4 bytes
+  assert.strictEqual(socket.bytesWritten, 3 + 4);
+
+  socket.on('connect', common.mustCall(function() {
+    assert.strictEqual(socket.bytesWritten, 3 + 4);
+  }));
+
+  socket.on('end', common.mustCall(function() {
+    assert.strictEqual(socket.bytesWritten, 3 + 4);
+
+    server.close();
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-net-socket-close-after-end.js b/test/js/node/test/parallel/test-net-socket-close-after-end.js
new file mode 100644
index 0000000000..06bf55f89d
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-socket-close-after-end.js
@@ -0,0 +1,31 @@
+'use strict';
+const common = require('../common');
+
+const assert = require('assert');
+const net = require('net');
+
+const server = net.createServer();
+
+server.on('connection', (socket) => {
+  let endEmitted = false;
+
+  socket.once('readable', () => {
+    setTimeout(() => {
+      socket.read();
+    }, common.platformTimeout(100));
+  });
+  socket.on('end', () => {
+    endEmitted = true;
+  });
+  socket.on('close', () => {
+    assert(endEmitted);
+    server.close();
+  });
+  socket.end('foo');
+});
+
+server.listen(common.mustCall(() => {
+  const socket = net.createConnection(server.address().port, () => {
+    socket.end('foo');
+  });
+}));
diff --git a/test/js/node/test/parallel/test-net-socket-connect-without-cb.js b/test/js/node/test/parallel/test-net-socket-connect-without-cb.js
new file mode 100644
index 0000000000..274083eb29
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-socket-connect-without-cb.js
@@ -0,0 +1,26 @@
+'use strict';
+const common = require('../common');
+
+// This test ensures that socket.connect can be called without callback
+// which is optional.
+
+const net = require('net');
+
+const server = net.createServer(common.mustCall(function(conn) {
+  conn.end();
+  server.close();
+})).listen(0, common.mustCall(function() {
+  const client = new net.Socket();
+
+  client.on('connect', common.mustCall(function() {
+    client.end();
+  }));
+
+  const address = server.address();
+  if (!common.hasIPv6 && address.family === 'IPv6') {
+    // Necessary to pass CI running inside containers.
+    client.connect(address.port);
+  } else {
+    client.connect(address);
+  }
+}));
diff --git a/test/js/node/test/parallel/test-net-socket-connecting.js b/test/js/node/test/parallel/test-net-socket-connecting.js
new file mode 100644
index 0000000000..21aa261192
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-socket-connecting.js
@@ -0,0 +1,21 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const net = require('net');
+
+const server = net.createServer((conn) => {
+  conn.end();
+  server.close();
+}).listen(0, () => {
+  const client = net.connect(server.address().port, () => {
+    assert.strictEqual(client.connecting, false);
+
+    // Legacy getter
+    assert.strictEqual(client._connecting, false);
+    client.end();
+  });
+  assert.strictEqual(client.connecting, true);
+
+  // Legacy getter
+  assert.strictEqual(client._connecting, true);
+});
diff --git a/test/js/node/test/parallel/test-net-socket-end-before-connect.js b/test/js/node/test/parallel/test-net-socket-end-before-connect.js
new file mode 100644
index 0000000000..d40c90620e
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-socket-end-before-connect.js
@@ -0,0 +1,13 @@
+'use strict';
+
+const common = require('../common');
+
+const net = require('net');
+
+const server = net.createServer();
+
+server.listen(common.mustCall(() => {
+  const socket = net.createConnection(server.address().port);
+  socket.on('close', common.mustCall(() => server.close()));
+  socket.end();
+}));
diff --git a/test/js/node/test/parallel/test-net-socket-ready-without-cb.js b/test/js/node/test/parallel/test-net-socket-ready-without-cb.js
new file mode 100644
index 0000000000..29da68e173
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-socket-ready-without-cb.js
@@ -0,0 +1,20 @@
+'use strict';
+const common = require('../common');
+
+// This test ensures that socket.connect can be called without callback
+// which is optional.
+
+const net = require('net');
+
+const server = net.createServer(common.mustCall(function(conn) {
+  conn.end();
+  server.close();
+})).listen(0, 'localhost', common.mustCall(function() {
+  const client = new net.Socket();
+
+  client.on('ready', common.mustCall(function() {
+    client.end();
+  }));
+
+  client.connect(server.address());
+}));
diff --git a/test/js/node/test/parallel/test-net-socket-timeout-unref.js b/test/js/node/test/parallel/test-net-socket-timeout-unref.js
new file mode 100644
index 0000000000..ae6bde49ab
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-socket-timeout-unref.js
@@ -0,0 +1,56 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+
+// Test that unref'ed sockets with timeouts do not prevent exit.
+
+const common = require('../common');
+const net = require('net');
+
+const server = net.createServer(function(c) {
+  c.write('hello');
+  c.unref();
+});
+server.listen(0);
+server.unref();
+
+let connections = 0;
+const sockets = [];
+const delays = [8, 5, 3, 6, 2, 4];
+
+delays.forEach(function(T) {
+  const socket = net.createConnection(server.address().port, 'localhost');
+  socket.on('connect', common.mustCall(function() {
+    if (++connections === delays.length) {
+      sockets.forEach(function(s) {
+        s.socket.setTimeout(s.timeout, function() {
+          s.socket.destroy();
+          throw new Error('socket timed out unexpectedly');
+        });
+
+        s.socket.unref();
+      });
+    }
+  }));
+
+  sockets.push({ socket: socket, timeout: T * 1000 });
+});
diff --git a/test/js/node/test/parallel/test-net-socket-write-error.js b/test/js/node/test/parallel/test-net-socket-write-error.js
new file mode 100644
index 0000000000..e68db68c0d
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-socket-write-error.js
@@ -0,0 +1,22 @@
+'use strict';
+
+const common = require('../common');
+const net = require('net');
+const assert = require('assert');
+
+const server = net.createServer().listen(0, connectToServer);
+
+function connectToServer() {
+  const client = net.createConnection(this.address().port, () => {
+    client.on('error', common.mustNotCall());
+    assert.throws(() => {
+      client.write(1337);
+    }, {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError'
+    });
+
+    client.destroy();
+  })
+  .on('close', () => server.close());
+}
diff --git a/test/js/node/test/parallel/test-net-sync-cork.js b/test/js/node/test/parallel/test-net-sync-cork.js
new file mode 100644
index 0000000000..447f42ca91
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-sync-cork.js
@@ -0,0 +1,33 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const net = require('net');
+
+const server = net.createServer(handle);
+
+const N = 100;
+const buf = Buffer.alloc(2, 'a');
+
+server.listen(0, function() {
+  const conn = net.connect(this.address().port);
+
+  conn.on('connect', () => {
+    let res = true;
+    let i = 0;
+    for (; i < N && res; i++) {
+      conn.cork();
+      conn.write(buf);
+      res = conn.write(buf);
+      conn.uncork();
+    }
+    assert.strictEqual(i, N);
+    conn.end();
+  });
+});
+
+function handle(socket) {
+  socket.resume();
+  socket.on('error', common.mustNotCall())
+        .on('close', common.mustCall(() => server.close()));
+}
diff --git a/test/js/node/test/parallel/test-net-writable.js b/test/js/node/test/parallel/test-net-writable.js
new file mode 100644
index 0000000000..3659869efb
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-writable.js
@@ -0,0 +1,15 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const net = require('net');
+
+const server = net.createServer(common.mustCall(function(s) {
+  server.close();
+  s.end();
+})).listen(0, '127.0.0.1', common.mustCall(function() {
+  const socket = net.connect(this.address().port, '127.0.0.1');
+  socket.on('end', common.mustCall(() => {
+    assert.strictEqual(socket.writable, true);
+    socket.write('hello world');
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-net-write-cb-on-destroy-before-connect.js b/test/js/node/test/parallel/test-net-write-cb-on-destroy-before-connect.js
new file mode 100644
index 0000000000..99efb66034
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-write-cb-on-destroy-before-connect.js
@@ -0,0 +1,26 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const net = require('net');
+
+const server = net.createServer();
+server.listen(0, common.mustCall(() => {
+  const socket = new net.Socket();
+
+  socket.on('connect', common.mustNotCall());
+
+  socket.connect({
+    port: server.address().port,
+  });
+
+  assert(socket.connecting);
+
+  socket.write('foo', common.expectsError({
+    code: 'ERR_SOCKET_CLOSED_BEFORE_CONNECTION',
+    name: 'Error'
+  }));
+
+  socket.destroy();
+  server.close();
+}));
diff --git a/test/js/node/test/parallel/test-net-write-connect-write.js b/test/js/node/test/parallel/test-net-write-connect-write.js
new file mode 100644
index 0000000000..1f09b04f17
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-write-connect-write.js
@@ -0,0 +1,46 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const net = require('net');
+
+const server = net.createServer(function(socket) {
+  socket.pipe(socket);
+}).listen(0, common.mustCall(function() {
+  const conn = net.connect(this.address().port);
+  let received = '';
+
+  conn.setEncoding('utf8');
+  conn.write('before');
+  conn.on('connect', function() {
+    conn.write(' after');
+  });
+  conn.on('data', function(buf) {
+    received += buf;
+    conn.end();
+  });
+  conn.on('end', common.mustCall(function() {
+    server.close();
+    assert.strictEqual(received, 'before after');
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-net-write-slow.js b/test/js/node/test/parallel/test-net-write-slow.js
new file mode 100644
index 0000000000..cf2d5790d9
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-write-slow.js
@@ -0,0 +1,63 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const net = require('net');
+
+const SIZE = 2E5;
+const N = 10;
+let flushed = 0;
+let received = 0;
+const buf = Buffer.alloc(SIZE, 'a');
+
+const server = net.createServer(function(socket) {
+  socket.setNoDelay();
+  socket.setTimeout(9999);
+  socket.on('timeout', function() {
+    assert.fail(`flushed: ${flushed}, received: ${received}/${SIZE * N}`);
+  });
+
+  for (let i = 0; i < N; ++i) {
+    socket.write(buf, function() {
+      ++flushed;
+      if (flushed === N) {
+        socket.setTimeout(0);
+      }
+    });
+  }
+  socket.end();
+
+}).listen(0, common.mustCall(function() {
+  const conn = net.connect(this.address().port);
+  conn.on('data', function(buf) {
+    received += buf.length;
+    conn.pause();
+    setTimeout(function() {
+      conn.resume();
+    }, 20);
+  });
+  conn.on('end', common.mustCall(function() {
+    server.close();
+    assert.strictEqual(received, SIZE * N);
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-next-tick-doesnt-hang.js b/test/js/node/test/parallel/test-next-tick-doesnt-hang.js
new file mode 100644
index 0000000000..36c1740bbf
--- /dev/null
+++ b/test/js/node/test/parallel/test-next-tick-doesnt-hang.js
@@ -0,0 +1,30 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+
+// This test verifies that having a single nextTick statement and nothing else
+// does not hang the event loop. If this test times out it has failed.
+
+require('../common');
+process.nextTick(function() {
+  // Nothing
+});
diff --git a/test/js/node/test/parallel/test-next-tick-domain.js b/test/js/node/test/parallel/test-next-tick-domain.js
new file mode 100644
index 0000000000..3e55ef3225
--- /dev/null
+++ b/test/js/node/test/parallel/test-next-tick-domain.js
@@ -0,0 +1,31 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+
+const origNextTick = process.nextTick;
+
+require('domain');
+
+// Requiring domain should not change nextTick.
+assert.strictEqual(origNextTick, process.nextTick);
diff --git a/test/js/node/test/parallel/test-next-tick-errors.js b/test/js/node/test/parallel/test-next-tick-errors.js
new file mode 100644
index 0000000000..6fd079625a
--- /dev/null
+++ b/test/js/node/test/parallel/test-next-tick-errors.js
@@ -0,0 +1,74 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+
+const order = [];
+let exceptionHandled = false;
+
+// This nextTick function will throw an error.  It should only be called once.
+// When it throws an error, it should still get removed from the queue.
+process.nextTick(function() {
+  order.push('A');
+  // cause an error
+  what(); // eslint-disable-line no-undef
+});
+
+// This nextTick function should remain in the queue when the first one
+// is removed.  It should be called if the error in the first one is
+// caught (which we do in this test).
+process.nextTick(function() {
+  order.push('C');
+});
+
+function testNextTickWith(val) {
+  assert.throws(() => {
+    process.nextTick(val);
+  }, {
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError'
+  });
+}
+
+testNextTickWith(false);
+testNextTickWith(true);
+testNextTickWith(1);
+testNextTickWith('str');
+testNextTickWith({});
+testNextTickWith([]);
+
+process.on('uncaughtException', function(err, errorOrigin) {
+  assert.strictEqual(errorOrigin, 'uncaughtException');
+
+  if (!exceptionHandled) {
+    exceptionHandled = true;
+    order.push('B');
+  } else {
+    // If we get here then the first process.nextTick got called twice
+    order.push('OOPS!');
+  }
+});
+
+process.on('exit', function() {
+  assert.deepStrictEqual(order, ['A', 'B', 'C']);
+});
diff --git a/test/js/node/test/parallel/test-next-tick-fixed-queue-regression.js b/test/js/node/test/parallel/test-next-tick-fixed-queue-regression.js
new file mode 100644
index 0000000000..1fe82d02b1
--- /dev/null
+++ b/test/js/node/test/parallel/test-next-tick-fixed-queue-regression.js
@@ -0,0 +1,18 @@
+'use strict';
+
+const common = require('../common');
+
+// This tests a highly specific regression tied to the FixedQueue size, which
+// was introduced in Node.js 9.7.0: https://github.com/nodejs/node/pull/18617
+// More specifically, a nextTick list could potentially end up not fully
+// clearing in one run through if exactly 2048 ticks were added after
+// microtasks were executed within the nextTick loop.
+
+process.nextTick(() => {
+  Promise.resolve(1).then(() => {
+    for (let i = 0; i < 2047; i++)
+      process.nextTick(common.mustCall());
+    const immediate = setImmediate(common.mustNotCall());
+    process.nextTick(common.mustCall(() => clearImmediate(immediate)));
+  });
+});
diff --git a/test/js/node/test/parallel/test-next-tick-intentional-starvation.js b/test/js/node/test/parallel/test-next-tick-intentional-starvation.js
new file mode 100644
index 0000000000..ed357cb233
--- /dev/null
+++ b/test/js/node/test/parallel/test-next-tick-intentional-starvation.js
@@ -0,0 +1,61 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+
+// This is the inverse of test-next-tick-starvation. it verifies
+// that process.nextTick will *always* come before other events
+
+let ran = false;
+let starved = false;
+const start = +new Date();
+let timerRan = false;
+
+function spin() {
+  ran = true;
+  const now = +new Date();
+  if (now - start > 100) {
+    console.log('The timer is starving, just as we planned.');
+    starved = true;
+
+    // now let it out.
+    return;
+  }
+
+  process.nextTick(spin);
+}
+
+function onTimeout() {
+  if (!starved) throw new Error('The timer escaped!');
+  console.log('The timer ran once the ban was lifted');
+  timerRan = true;
+}
+
+spin();
+setTimeout(onTimeout, 50);
+
+process.on('exit', function() {
+  assert.ok(ran);
+  assert.ok(starved);
+  assert.ok(timerRan);
+});
diff --git a/test/js/node/test/parallel/test-next-tick-ordering.js b/test/js/node/test/parallel/test-next-tick-ordering.js
new file mode 100644
index 0000000000..8d3ee6488c
--- /dev/null
+++ b/test/js/node/test/parallel/test-next-tick-ordering.js
@@ -0,0 +1,55 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+let i;
+
+const N = 30;
+const done = [];
+
+function get_printer(timeout) {
+  return function() {
+    console.log(`Running from setTimeout ${timeout}`);
+    done.push(timeout);
+  };
+}
+
+process.nextTick(function() {
+  console.log('Running from nextTick');
+  done.push('nextTick');
+});
+
+for (i = 0; i < N; i += 1) {
+  setTimeout(get_printer(i), i);
+}
+
+console.log('Running from main.');
+
+
+process.on('exit', function() {
+  assert.strictEqual(done[0], 'nextTick');
+  // Disabling this test. I don't think we can ensure the order
+  // for (i = 0; i < N; i += 1) {
+  //  assert.strictEqual(i, done[i + 1]);
+  // }
+});
diff --git a/test/js/node/test/parallel/test-next-tick-ordering2.js b/test/js/node/test/parallel/test-next-tick-ordering2.js
new file mode 100644
index 0000000000..6c42bd8e57
--- /dev/null
+++ b/test/js/node/test/parallel/test-next-tick-ordering2.js
@@ -0,0 +1,39 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+
+const order = [];
+process.nextTick(function() {
+  setTimeout(function() {
+    order.push('setTimeout');
+  }, 0);
+
+  process.nextTick(function() {
+    order.push('nextTick');
+  });
+});
+
+process.on('exit', function() {
+  assert.deepStrictEqual(order, ['nextTick', 'setTimeout']);
+});
diff --git a/test/js/node/test/parallel/test-next-tick-when-exiting.js b/test/js/node/test/parallel/test-next-tick-when-exiting.js
new file mode 100644
index 0000000000..36dc296646
--- /dev/null
+++ b/test/js/node/test/parallel/test-next-tick-when-exiting.js
@@ -0,0 +1,14 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+
+process.on('exit', () => {
+  assert.strictEqual(process._exiting, true);
+
+  process.nextTick(
+    common.mustNotCall('process is exiting, should not be called')
+  );
+});
+
+process.exit();
diff --git a/test/js/node/test/parallel/test-next-tick.js b/test/js/node/test/parallel/test-next-tick.js
new file mode 100644
index 0000000000..47823f45bc
--- /dev/null
+++ b/test/js/node/test/parallel/test-next-tick.js
@@ -0,0 +1,63 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+
+const assert = require('assert');
+
+process.nextTick(common.mustCall(function() {
+  process.nextTick(common.mustCall(function() {
+    process.nextTick(common.mustCall());
+  }));
+}));
+
+setTimeout(common.mustCall(function() {
+  process.nextTick(common.mustCall());
+}), 50);
+
+process.nextTick(common.mustCall());
+
+const obj = {};
+
+process.nextTick(function(a, b) {
+  assert.strictEqual(a, 42);
+  assert.strictEqual(b, obj);
+  assert.strictEqual(this, undefined);
+}, 42, obj);
+
+process.nextTick((a, b) => {
+  assert.strictEqual(a, 42);
+  assert.strictEqual(b, obj);
+  assert.deepStrictEqual(this, {});
+}, 42, obj);
+
+process.nextTick(function() {
+  assert.strictEqual(this, undefined);
+}, 1, 2, 3, 4);
+
+process.nextTick(() => {
+  assert.deepStrictEqual(this, {});
+}, 1, 2, 3, 4);
+
+process.on('exit', function() {
+  process.nextTick(common.mustNotCall());
+});
diff --git a/test/js/node/test/parallel/test-no-node-snapshot.js b/test/js/node/test/parallel/test-no-node-snapshot.js
new file mode 100644
index 0000000000..a636040a4c
--- /dev/null
+++ b/test/js/node/test/parallel/test-no-node-snapshot.js
@@ -0,0 +1,5 @@
+'use strict';
+
+// Flags: --no-node-snapshot
+
+require('../common');
diff --git a/test/js/node/test/parallel/test-outgoing-message-destroy.js b/test/js/node/test/parallel/test-outgoing-message-destroy.js
new file mode 100644
index 0000000000..0ee7b5f40e
--- /dev/null
+++ b/test/js/node/test/parallel/test-outgoing-message-destroy.js
@@ -0,0 +1,13 @@
+'use strict';
+
+// Test that http.OutgoingMessage,prototype.destroy() returns `this`.
+require('../common');
+
+const assert = require('assert');
+const http = require('http');
+const outgoingMessage = new http.OutgoingMessage();
+
+assert.strictEqual(outgoingMessage.destroyed, false);
+assert.strictEqual(outgoingMessage.destroy(), outgoingMessage);
+assert.strictEqual(outgoingMessage.destroyed, true);
+assert.strictEqual(outgoingMessage.destroy(), outgoingMessage);
diff --git a/test/js/node/test/parallel/test-path-basename.js b/test/js/node/test/parallel/test-path-basename.js
new file mode 100644
index 0000000000..b16f9e5d63
--- /dev/null
+++ b/test/js/node/test/parallel/test-path-basename.js
@@ -0,0 +1,76 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const path = require('path');
+
+assert.strictEqual(path.basename(__filename), 'test-path-basename.js');
+assert.strictEqual(path.basename(__filename, '.js'), 'test-path-basename');
+assert.strictEqual(path.basename('.js', '.js'), '');
+assert.strictEqual(path.basename('js', '.js'), 'js');
+assert.strictEqual(path.basename('file.js', '.ts'), 'file.js');
+assert.strictEqual(path.basename('file', '.js'), 'file');
+assert.strictEqual(path.basename('file.js.old', '.js.old'), 'file');
+assert.strictEqual(path.basename(''), '');
+assert.strictEqual(path.basename('/dir/basename.ext'), 'basename.ext');
+assert.strictEqual(path.basename('/basename.ext'), 'basename.ext');
+assert.strictEqual(path.basename('basename.ext'), 'basename.ext');
+assert.strictEqual(path.basename('basename.ext/'), 'basename.ext');
+assert.strictEqual(path.basename('basename.ext//'), 'basename.ext');
+assert.strictEqual(path.basename('aaa/bbb', '/bbb'), 'bbb');
+assert.strictEqual(path.basename('aaa/bbb', 'a/bbb'), 'bbb');
+assert.strictEqual(path.basename('aaa/bbb', 'bbb'), 'bbb');
+assert.strictEqual(path.basename('aaa/bbb//', 'bbb'), 'bbb');
+assert.strictEqual(path.basename('aaa/bbb', 'bb'), 'b');
+assert.strictEqual(path.basename('aaa/bbb', 'b'), 'bb');
+assert.strictEqual(path.basename('/aaa/bbb', '/bbb'), 'bbb');
+assert.strictEqual(path.basename('/aaa/bbb', 'a/bbb'), 'bbb');
+assert.strictEqual(path.basename('/aaa/bbb', 'bbb'), 'bbb');
+assert.strictEqual(path.basename('/aaa/bbb//', 'bbb'), 'bbb');
+assert.strictEqual(path.basename('/aaa/bbb', 'bb'), 'b');
+assert.strictEqual(path.basename('/aaa/bbb', 'b'), 'bb');
+assert.strictEqual(path.basename('/aaa/bbb'), 'bbb');
+assert.strictEqual(path.basename('/aaa/'), 'aaa');
+assert.strictEqual(path.basename('/aaa/b'), 'b');
+assert.strictEqual(path.basename('/a/b'), 'b');
+assert.strictEqual(path.basename('//a'), 'a');
+assert.strictEqual(path.basename('a', 'a'), '');
+
+// On Windows a backslash acts as a path separator.
+assert.strictEqual(path.win32.basename('\\dir\\basename.ext'), 'basename.ext');
+assert.strictEqual(path.win32.basename('\\basename.ext'), 'basename.ext');
+assert.strictEqual(path.win32.basename('basename.ext'), 'basename.ext');
+assert.strictEqual(path.win32.basename('basename.ext\\'), 'basename.ext');
+assert.strictEqual(path.win32.basename('basename.ext\\\\'), 'basename.ext');
+assert.strictEqual(path.win32.basename('foo'), 'foo');
+assert.strictEqual(path.win32.basename('aaa\\bbb', '\\bbb'), 'bbb');
+assert.strictEqual(path.win32.basename('aaa\\bbb', 'a\\bbb'), 'bbb');
+assert.strictEqual(path.win32.basename('aaa\\bbb', 'bbb'), 'bbb');
+assert.strictEqual(path.win32.basename('aaa\\bbb\\\\\\\\', 'bbb'), 'bbb');
+assert.strictEqual(path.win32.basename('aaa\\bbb', 'bb'), 'b');
+assert.strictEqual(path.win32.basename('aaa\\bbb', 'b'), 'bb');
+assert.strictEqual(path.win32.basename('C:'), '');
+assert.strictEqual(path.win32.basename('C:.'), '.');
+assert.strictEqual(path.win32.basename('C:\\'), '');
+assert.strictEqual(path.win32.basename('C:\\dir\\base.ext'), 'base.ext');
+assert.strictEqual(path.win32.basename('C:\\basename.ext'), 'basename.ext');
+assert.strictEqual(path.win32.basename('C:basename.ext'), 'basename.ext');
+assert.strictEqual(path.win32.basename('C:basename.ext\\'), 'basename.ext');
+assert.strictEqual(path.win32.basename('C:basename.ext\\\\'), 'basename.ext');
+assert.strictEqual(path.win32.basename('C:foo'), 'foo');
+assert.strictEqual(path.win32.basename('file:stream'), 'file:stream');
+assert.strictEqual(path.win32.basename('a', 'a'), '');
+
+// On unix a backslash is just treated as any other character.
+assert.strictEqual(path.posix.basename('\\dir\\basename.ext'),
+                   '\\dir\\basename.ext');
+assert.strictEqual(path.posix.basename('\\basename.ext'), '\\basename.ext');
+assert.strictEqual(path.posix.basename('basename.ext'), 'basename.ext');
+assert.strictEqual(path.posix.basename('basename.ext\\'), 'basename.ext\\');
+assert.strictEqual(path.posix.basename('basename.ext\\\\'), 'basename.ext\\\\');
+assert.strictEqual(path.posix.basename('foo'), 'foo');
+
+// POSIX filenames may include control characters
+// c.f. http://www.dwheeler.com/essays/fixing-unix-linux-filenames.html
+const controlCharFilename = `Icon${String.fromCharCode(13)}`;
+assert.strictEqual(path.posix.basename(`/a/b/${controlCharFilename}`),
+                   controlCharFilename);
diff --git a/test/js/node/test/parallel/test-path-dirname.js b/test/js/node/test/parallel/test-path-dirname.js
new file mode 100644
index 0000000000..0d4a182884
--- /dev/null
+++ b/test/js/node/test/parallel/test-path-dirname.js
@@ -0,0 +1,59 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const path = require('path');
+
+assert.strictEqual(path.dirname(__filename).slice(-13),
+                   common.isWindows ? 'test\\parallel' : 'test/parallel');
+
+assert.strictEqual(path.posix.dirname('/a/b/'), '/a');
+assert.strictEqual(path.posix.dirname('/a/b'), '/a');
+assert.strictEqual(path.posix.dirname('/a'), '/');
+assert.strictEqual(path.posix.dirname(''), '.');
+assert.strictEqual(path.posix.dirname('/'), '/');
+assert.strictEqual(path.posix.dirname('////'), '/');
+assert.strictEqual(path.posix.dirname('//a'), '//');
+assert.strictEqual(path.posix.dirname('foo'), '.');
+
+assert.strictEqual(path.win32.dirname('c:\\'), 'c:\\');
+assert.strictEqual(path.win32.dirname('c:\\foo'), 'c:\\');
+assert.strictEqual(path.win32.dirname('c:\\foo\\'), 'c:\\');
+assert.strictEqual(path.win32.dirname('c:\\foo\\bar'), 'c:\\foo');
+assert.strictEqual(path.win32.dirname('c:\\foo\\bar\\'), 'c:\\foo');
+assert.strictEqual(path.win32.dirname('c:\\foo\\bar\\baz'), 'c:\\foo\\bar');
+assert.strictEqual(path.win32.dirname('c:\\foo bar\\baz'), 'c:\\foo bar');
+assert.strictEqual(path.win32.dirname('\\'), '\\');
+assert.strictEqual(path.win32.dirname('\\foo'), '\\');
+assert.strictEqual(path.win32.dirname('\\foo\\'), '\\');
+assert.strictEqual(path.win32.dirname('\\foo\\bar'), '\\foo');
+assert.strictEqual(path.win32.dirname('\\foo\\bar\\'), '\\foo');
+assert.strictEqual(path.win32.dirname('\\foo\\bar\\baz'), '\\foo\\bar');
+assert.strictEqual(path.win32.dirname('\\foo bar\\baz'), '\\foo bar');
+assert.strictEqual(path.win32.dirname('c:'), 'c:');
+assert.strictEqual(path.win32.dirname('c:foo'), 'c:');
+assert.strictEqual(path.win32.dirname('c:foo\\'), 'c:');
+assert.strictEqual(path.win32.dirname('c:foo\\bar'), 'c:foo');
+assert.strictEqual(path.win32.dirname('c:foo\\bar\\'), 'c:foo');
+assert.strictEqual(path.win32.dirname('c:foo\\bar\\baz'), 'c:foo\\bar');
+assert.strictEqual(path.win32.dirname('c:foo bar\\baz'), 'c:foo bar');
+assert.strictEqual(path.win32.dirname('file:stream'), '.');
+assert.strictEqual(path.win32.dirname('dir\\file:stream'), 'dir');
+assert.strictEqual(path.win32.dirname('\\\\unc\\share'),
+                   '\\\\unc\\share');
+assert.strictEqual(path.win32.dirname('\\\\unc\\share\\foo'),
+                   '\\\\unc\\share\\');
+assert.strictEqual(path.win32.dirname('\\\\unc\\share\\foo\\'),
+                   '\\\\unc\\share\\');
+assert.strictEqual(path.win32.dirname('\\\\unc\\share\\foo\\bar'),
+                   '\\\\unc\\share\\foo');
+assert.strictEqual(path.win32.dirname('\\\\unc\\share\\foo\\bar\\'),
+                   '\\\\unc\\share\\foo');
+assert.strictEqual(path.win32.dirname('\\\\unc\\share\\foo\\bar\\baz'),
+                   '\\\\unc\\share\\foo\\bar');
+assert.strictEqual(path.win32.dirname('/a/b/'), '/a');
+assert.strictEqual(path.win32.dirname('/a/b'), '/a');
+assert.strictEqual(path.win32.dirname('/a'), '/');
+assert.strictEqual(path.win32.dirname(''), '.');
+assert.strictEqual(path.win32.dirname('/'), '/');
+assert.strictEqual(path.win32.dirname('////'), '/');
+assert.strictEqual(path.win32.dirname('foo'), '.');
diff --git a/test/js/node/test/parallel/test-path-extname.js b/test/js/node/test/parallel/test-path-extname.js
new file mode 100644
index 0000000000..be5a6316b0
--- /dev/null
+++ b/test/js/node/test/parallel/test-path-extname.js
@@ -0,0 +1,100 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const path = require('path');
+
+const failures = [];
+const slashRE = /\//g;
+
+const testPaths = [
+  [__filename, '.js'],
+  ['', ''],
+  ['/path/to/file', ''],
+  ['/path/to/file.ext', '.ext'],
+  ['/path.to/file.ext', '.ext'],
+  ['/path.to/file', ''],
+  ['/path.to/.file', ''],
+  ['/path.to/.file.ext', '.ext'],
+  ['/path/to/f.ext', '.ext'],
+  ['/path/to/..ext', '.ext'],
+  ['/path/to/..', ''],
+  ['file', ''],
+  ['file.ext', '.ext'],
+  ['.file', ''],
+  ['.file.ext', '.ext'],
+  ['/file', ''],
+  ['/file.ext', '.ext'],
+  ['/.file', ''],
+  ['/.file.ext', '.ext'],
+  ['.path/file.ext', '.ext'],
+  ['file.ext.ext', '.ext'],
+  ['file.', '.'],
+  ['.', ''],
+  ['./', ''],
+  ['.file.ext', '.ext'],
+  ['.file', ''],
+  ['.file.', '.'],
+  ['.file..', '.'],
+  ['..', ''],
+  ['../', ''],
+  ['..file.ext', '.ext'],
+  ['..file', '.file'],
+  ['..file.', '.'],
+  ['..file..', '.'],
+  ['...', '.'],
+  ['...ext', '.ext'],
+  ['....', '.'],
+  ['file.ext/', '.ext'],
+  ['file.ext//', '.ext'],
+  ['file/', ''],
+  ['file//', ''],
+  ['file./', '.'],
+  ['file.//', '.'],
+];
+
+for (const testPath of testPaths) {
+  const expected = testPath[1];
+  const extNames = [path.posix.extname, path.win32.extname];
+  for (const extname of extNames) {
+    let input = testPath[0];
+    let os;
+    if (extname === path.win32.extname) {
+      input = input.replace(slashRE, '\\');
+      os = 'win32';
+    } else {
+      os = 'posix';
+    }
+    const actual = extname(input);
+    const message = `path.${os}.extname(${JSON.stringify(input)})\n  expect=${
+      JSON.stringify(expected)}\n  actual=${JSON.stringify(actual)}`;
+    if (actual !== expected)
+      failures.push(`\n${message}`);
+  }
+  const input = `C:${testPath[0].replace(slashRE, '\\')}`;
+  const actual = path.win32.extname(input);
+  const message = `path.win32.extname(${JSON.stringify(input)})\n  expect=${
+    JSON.stringify(expected)}\n  actual=${JSON.stringify(actual)}`;
+  if (actual !== expected)
+    failures.push(`\n${message}`);
+}
+assert.strictEqual(failures.length, 0, failures.join(''));
+
+// On Windows, backslash is a path separator.
+assert.strictEqual(path.win32.extname('.\\'), '');
+assert.strictEqual(path.win32.extname('..\\'), '');
+assert.strictEqual(path.win32.extname('file.ext\\'), '.ext');
+assert.strictEqual(path.win32.extname('file.ext\\\\'), '.ext');
+assert.strictEqual(path.win32.extname('file\\'), '');
+assert.strictEqual(path.win32.extname('file\\\\'), '');
+assert.strictEqual(path.win32.extname('file.\\'), '.');
+assert.strictEqual(path.win32.extname('file.\\\\'), '.');
+
+// On *nix, backslash is a valid name component like any other character.
+assert.strictEqual(path.posix.extname('.\\'), '');
+assert.strictEqual(path.posix.extname('..\\'), '.\\');
+assert.strictEqual(path.posix.extname('file.ext\\'), '.ext\\');
+assert.strictEqual(path.posix.extname('file.ext\\\\'), '.ext\\\\');
+assert.strictEqual(path.posix.extname('file\\'), '');
+assert.strictEqual(path.posix.extname('file\\\\'), '');
+assert.strictEqual(path.posix.extname('file.\\'), '.\\');
+assert.strictEqual(path.posix.extname('file.\\\\'), '.\\\\');
diff --git a/test/js/node/test/parallel/test-path-isabsolute.js b/test/js/node/test/parallel/test-path-isabsolute.js
new file mode 100644
index 0000000000..66b4f1ee51
--- /dev/null
+++ b/test/js/node/test/parallel/test-path-isabsolute.js
@@ -0,0 +1,28 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const path = require('path');
+
+assert.strictEqual(path.win32.isAbsolute('/'), true);
+assert.strictEqual(path.win32.isAbsolute('//'), true);
+assert.strictEqual(path.win32.isAbsolute('//server'), true);
+assert.strictEqual(path.win32.isAbsolute('//server/file'), true);
+assert.strictEqual(path.win32.isAbsolute('\\\\server\\file'), true);
+assert.strictEqual(path.win32.isAbsolute('\\\\server'), true);
+assert.strictEqual(path.win32.isAbsolute('\\\\'), true);
+assert.strictEqual(path.win32.isAbsolute('c'), false);
+assert.strictEqual(path.win32.isAbsolute('c:'), false);
+assert.strictEqual(path.win32.isAbsolute('c:\\'), true);
+assert.strictEqual(path.win32.isAbsolute('c:/'), true);
+assert.strictEqual(path.win32.isAbsolute('c://'), true);
+assert.strictEqual(path.win32.isAbsolute('C:/Users/'), true);
+assert.strictEqual(path.win32.isAbsolute('C:\\Users\\'), true);
+assert.strictEqual(path.win32.isAbsolute('C:cwd/another'), false);
+assert.strictEqual(path.win32.isAbsolute('C:cwd\\another'), false);
+assert.strictEqual(path.win32.isAbsolute('directory/directory'), false);
+assert.strictEqual(path.win32.isAbsolute('directory\\directory'), false);
+
+assert.strictEqual(path.posix.isAbsolute('/home/foo'), true);
+assert.strictEqual(path.posix.isAbsolute('/home/foo/..'), true);
+assert.strictEqual(path.posix.isAbsolute('bar/'), false);
+assert.strictEqual(path.posix.isAbsolute('./baz'), false);
diff --git a/test/js/node/test/parallel/test-path-join.js b/test/js/node/test/parallel/test-path-join.js
new file mode 100644
index 0000000000..d6d1839996
--- /dev/null
+++ b/test/js/node/test/parallel/test-path-join.js
@@ -0,0 +1,143 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const path = require('path');
+
+const failures = [];
+const backslashRE = /\\/g;
+
+const joinTests = [
+  [ [path.posix.join, path.win32.join],
+    // Arguments                     result
+    [[['.', 'x/b', '..', '/b/c.js'], 'x/b/c.js'],
+     [[], '.'],
+     [['/.', 'x/b', '..', '/b/c.js'], '/x/b/c.js'],
+     [['/foo', '../../../bar'], '/bar'],
+     [['foo', '../../../bar'], '../../bar'],
+     [['foo/', '../../../bar'], '../../bar'],
+     [['foo/x', '../../../bar'], '../bar'],
+     [['foo/x', './bar'], 'foo/x/bar'],
+     [['foo/x/', './bar'], 'foo/x/bar'],
+     [['foo/x/', '.', 'bar'], 'foo/x/bar'],
+     [['./'], './'],
+     [['.', './'], './'],
+     [['.', '.', '.'], '.'],
+     [['.', './', '.'], '.'],
+     [['.', '/./', '.'], '.'],
+     [['.', '/////./', '.'], '.'],
+     [['.'], '.'],
+     [['', '.'], '.'],
+     [['', 'foo'], 'foo'],
+     [['foo', '/bar'], 'foo/bar'],
+     [['', '/foo'], '/foo'],
+     [['', '', '/foo'], '/foo'],
+     [['', '', 'foo'], 'foo'],
+     [['foo', ''], 'foo'],
+     [['foo/', ''], 'foo/'],
+     [['foo', '', '/bar'], 'foo/bar'],
+     [['./', '..', '/foo'], '../foo'],
+     [['./', '..', '..', '/foo'], '../../foo'],
+     [['.', '..', '..', '/foo'], '../../foo'],
+     [['', '..', '..', '/foo'], '../../foo'],
+     [['/'], '/'],
+     [['/', '.'], '/'],
+     [['/', '..'], '/'],
+     [['/', '..', '..'], '/'],
+     [[''], '.'],
+     [['', ''], '.'],
+     [[' /foo'], ' /foo'],
+     [[' ', 'foo'], ' /foo'],
+     [[' ', '.'], ' '],
+     [[' ', '/'], ' /'],
+     [[' ', ''], ' '],
+     [['/', 'foo'], '/foo'],
+     [['/', '/foo'], '/foo'],
+     [['/', '//foo'], '/foo'],
+     [['/', '', '/foo'], '/foo'],
+     [['', '/', 'foo'], '/foo'],
+     [['', '/', '/foo'], '/foo'],
+    ],
+  ],
+];
+
+// Windows-specific join tests
+joinTests.push([
+  path.win32.join,
+  joinTests[0][1].slice(0).concat(
+    [// Arguments                     result
+      // UNC path expected
+      [['//foo/bar'], '\\\\foo\\bar\\'],
+      [['\\/foo/bar'], '\\\\foo\\bar\\'],
+      [['\\\\foo/bar'], '\\\\foo\\bar\\'],
+      // UNC path expected - server and share separate
+      [['//foo', 'bar'], '\\\\foo\\bar\\'],
+      [['//foo/', 'bar'], '\\\\foo\\bar\\'],
+      [['//foo', '/bar'], '\\\\foo\\bar\\'],
+      // UNC path expected - questionable
+      [['//foo', '', 'bar'], '\\\\foo\\bar\\'],
+      [['//foo/', '', 'bar'], '\\\\foo\\bar\\'],
+      [['//foo/', '', '/bar'], '\\\\foo\\bar\\'],
+      // UNC path expected - even more questionable
+      [['', '//foo', 'bar'], '\\\\foo\\bar\\'],
+      [['', '//foo/', 'bar'], '\\\\foo\\bar\\'],
+      [['', '//foo/', '/bar'], '\\\\foo\\bar\\'],
+      // No UNC path expected (no double slash in first component)
+      [['\\', 'foo/bar'], '\\foo\\bar'],
+      [['\\', '/foo/bar'], '\\foo\\bar'],
+      [['', '/', '/foo/bar'], '\\foo\\bar'],
+      // No UNC path expected (no non-slashes in first component -
+      // questionable)
+      [['//', 'foo/bar'], '\\foo\\bar'],
+      [['//', '/foo/bar'], '\\foo\\bar'],
+      [['\\\\', '/', '/foo/bar'], '\\foo\\bar'],
+      [['//'], '\\'],
+      // No UNC path expected (share name missing - questionable).
+      [['//foo'], '\\foo'],
+      [['//foo/'], '\\foo\\'],
+      [['//foo', '/'], '\\foo\\'],
+      [['//foo', '', '/'], '\\foo\\'],
+      // No UNC path expected (too many leading slashes - questionable)
+      [['///foo/bar'], '\\foo\\bar'],
+      [['////foo', 'bar'], '\\foo\\bar'],
+      [['\\\\\\/foo/bar'], '\\foo\\bar'],
+      // Drive-relative vs drive-absolute paths. This merely describes the
+      // status quo, rather than being obviously right
+      [['c:'], 'c:.'],
+      [['c:.'], 'c:.'],
+      [['c:', ''], 'c:.'],
+      [['', 'c:'], 'c:.'],
+      [['c:.', '/'], 'c:.\\'],
+      [['c:.', 'file'], 'c:file'],
+      [['c:', '/'], 'c:\\'],
+      [['c:', 'file'], 'c:\\file'],
+    ]
+  ),
+]);
+joinTests.forEach((test) => {
+  if (!Array.isArray(test[0]))
+    test[0] = [test[0]];
+  test[0].forEach((join) => {
+    test[1].forEach((test) => {
+      const actual = join.apply(null, test[0]);
+      const expected = test[1];
+      // For non-Windows specific tests with the Windows join(), we need to try
+      // replacing the slashes since the non-Windows specific tests' `expected`
+      // use forward slashes
+      let actualAlt;
+      let os;
+      if (join === path.win32.join) {
+        actualAlt = actual.replace(backslashRE, '/');
+        os = 'win32';
+      } else {
+        os = 'posix';
+      }
+      if (actual !== expected && actualAlt !== expected) {
+        const delimiter = test[0].map(JSON.stringify).join(',');
+        const message = `path.${os}.join(${delimiter})\n  expect=${
+          JSON.stringify(expected)}\n  actual=${JSON.stringify(actual)}`;
+        failures.push(`\n${message}`);
+      }
+    });
+  });
+});
+assert.strictEqual(failures.length, 0, failures.join(''));
diff --git a/test/js/node/test/parallel/test-path-makelong.js b/test/js/node/test/parallel/test-path-makelong.js
new file mode 100644
index 0000000000..7a4783953c
--- /dev/null
+++ b/test/js/node/test/parallel/test-path-makelong.js
@@ -0,0 +1,88 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+const path = require('path');
+
+if (common.isWindows) {
+  const file = fixtures.path('a.js');
+  const resolvedFile = path.resolve(file);
+
+  assert.strictEqual(path.toNamespacedPath(file),
+                     `\\\\?\\${resolvedFile}`);
+  assert.strictEqual(path.toNamespacedPath(`\\\\?\\${file}`),
+                     `\\\\?\\${resolvedFile}`);
+  assert.strictEqual(path.toNamespacedPath(
+    '\\\\someserver\\someshare\\somefile'),
+                     '\\\\?\\UNC\\someserver\\someshare\\somefile');
+  assert.strictEqual(path.toNamespacedPath(
+    '\\\\?\\UNC\\someserver\\someshare\\somefile'),
+                     '\\\\?\\UNC\\someserver\\someshare\\somefile');
+  assert.strictEqual(path.toNamespacedPath('\\\\.\\pipe\\somepipe'),
+                     '\\\\.\\pipe\\somepipe');
+}
+
+assert.strictEqual(path.toNamespacedPath(''), '');
+assert.strictEqual(path.toNamespacedPath(null), null);
+assert.strictEqual(path.toNamespacedPath(100), 100);
+assert.strictEqual(path.toNamespacedPath(path), path);
+assert.strictEqual(path.toNamespacedPath(false), false);
+assert.strictEqual(path.toNamespacedPath(true), true);
+
+const emptyObj = {};
+assert.strictEqual(path.posix.toNamespacedPath('/foo/bar'), '/foo/bar');
+assert.strictEqual(path.posix.toNamespacedPath('foo/bar'), 'foo/bar');
+assert.strictEqual(path.posix.toNamespacedPath(null), null);
+assert.strictEqual(path.posix.toNamespacedPath(true), true);
+assert.strictEqual(path.posix.toNamespacedPath(1), 1);
+assert.strictEqual(path.posix.toNamespacedPath(), undefined);
+assert.strictEqual(path.posix.toNamespacedPath(emptyObj), emptyObj);
+if (common.isWindows) {
+  // These tests cause resolve() to insert the cwd, so we cannot test them from
+  // non-Windows platforms (easily)
+  assert.strictEqual(path.toNamespacedPath(''), '');
+  assert.strictEqual(path.win32.toNamespacedPath('foo\\bar').toLowerCase(),
+                     `\\\\?\\${process.cwd().toLowerCase()}\\foo\\bar`);
+  assert.strictEqual(path.win32.toNamespacedPath('foo/bar').toLowerCase(),
+                     `\\\\?\\${process.cwd().toLowerCase()}\\foo\\bar`);
+  const currentDeviceLetter = path.parse(process.cwd()).root.substring(0, 2);
+  assert.strictEqual(
+    path.win32.toNamespacedPath(currentDeviceLetter).toLowerCase(),
+    `\\\\?\\${process.cwd().toLowerCase()}`);
+  assert.strictEqual(path.win32.toNamespacedPath('C').toLowerCase(),
+                     `\\\\?\\${process.cwd().toLowerCase()}\\c`);
+}
+assert.strictEqual(path.win32.toNamespacedPath('C:\\foo'), '\\\\?\\C:\\foo');
+assert.strictEqual(path.win32.toNamespacedPath('C:/foo'), '\\\\?\\C:\\foo');
+assert.strictEqual(path.win32.toNamespacedPath('\\\\foo\\bar'),
+                   '\\\\?\\UNC\\foo\\bar\\');
+assert.strictEqual(path.win32.toNamespacedPath('//foo//bar'),
+                   '\\\\?\\UNC\\foo\\bar\\');
+assert.strictEqual(path.win32.toNamespacedPath('\\\\?\\foo'), '\\\\?\\foo\\');
+assert.strictEqual(path.win32.toNamespacedPath('\\\\?\\c:\\Windows/System'), '\\\\?\\c:\\Windows\\System');
+assert.strictEqual(path.win32.toNamespacedPath(null), null);
+assert.strictEqual(path.win32.toNamespacedPath(true), true);
+assert.strictEqual(path.win32.toNamespacedPath(1), 1);
+assert.strictEqual(path.win32.toNamespacedPath(), undefined);
+assert.strictEqual(path.win32.toNamespacedPath(emptyObj), emptyObj);
diff --git a/test/js/node/test/parallel/test-path-normalize.js b/test/js/node/test/parallel/test-path-normalize.js
new file mode 100644
index 0000000000..e1d3b9ce1e
--- /dev/null
+++ b/test/js/node/test/parallel/test-path-normalize.js
@@ -0,0 +1,72 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const path = require('path');
+
+assert.strictEqual(path.win32.normalize('./fixtures///b/../b/c.js'),
+                   'fixtures\\b\\c.js');
+assert.strictEqual(path.win32.normalize('/foo/../../../bar'), '\\bar');
+assert.strictEqual(path.win32.normalize('a//b//../b'), 'a\\b');
+assert.strictEqual(path.win32.normalize('a//b//./c'), 'a\\b\\c');
+assert.strictEqual(path.win32.normalize('a//b//.'), 'a\\b');
+assert.strictEqual(path.win32.normalize('//server/share/dir/file.ext'),
+                   '\\\\server\\share\\dir\\file.ext');
+assert.strictEqual(path.win32.normalize('/a/b/c/../../../x/y/z'), '\\x\\y\\z');
+assert.strictEqual(path.win32.normalize('C:'), 'C:.');
+assert.strictEqual(path.win32.normalize('C:..\\abc'), 'C:..\\abc');
+assert.strictEqual(path.win32.normalize('C:..\\..\\abc\\..\\def'),
+                   'C:..\\..\\def');
+assert.strictEqual(path.win32.normalize('C:\\.'), 'C:\\');
+assert.strictEqual(path.win32.normalize('file:stream'), 'file:stream');
+assert.strictEqual(path.win32.normalize('bar\\foo..\\..\\'), 'bar\\');
+assert.strictEqual(path.win32.normalize('bar\\foo..\\..'), 'bar');
+assert.strictEqual(path.win32.normalize('bar\\foo..\\..\\baz'), 'bar\\baz');
+assert.strictEqual(path.win32.normalize('bar\\foo..\\'), 'bar\\foo..\\');
+assert.strictEqual(path.win32.normalize('bar\\foo..'), 'bar\\foo..');
+assert.strictEqual(path.win32.normalize('..\\foo..\\..\\..\\bar'),
+                   '..\\..\\bar');
+assert.strictEqual(path.win32.normalize('..\\...\\..\\.\\...\\..\\..\\bar'),
+                   '..\\..\\bar');
+assert.strictEqual(path.win32.normalize('../../../foo/../../../bar'),
+                   '..\\..\\..\\..\\..\\bar');
+assert.strictEqual(path.win32.normalize('../../../foo/../../../bar/../../'),
+                   '..\\..\\..\\..\\..\\..\\');
+assert.strictEqual(
+  path.win32.normalize('../foobar/barfoo/foo/../../../bar/../../'),
+  '..\\..\\'
+);
+assert.strictEqual(
+  path.win32.normalize('../.../../foobar/../../../bar/../../baz'),
+  '..\\..\\..\\..\\baz'
+);
+assert.strictEqual(path.win32.normalize('foo/bar\\baz'), 'foo\\bar\\baz');
+
+assert.strictEqual(path.posix.normalize('./fixtures///b/../b/c.js'),
+                   'fixtures/b/c.js');
+assert.strictEqual(path.posix.normalize('/foo/../../../bar'), '/bar');
+assert.strictEqual(path.posix.normalize('a//b//../b'), 'a/b');
+assert.strictEqual(path.posix.normalize('a//b//./c'), 'a/b/c');
+assert.strictEqual(path.posix.normalize('a//b//.'), 'a/b');
+assert.strictEqual(path.posix.normalize('/a/b/c/../../../x/y/z'), '/x/y/z');
+assert.strictEqual(path.posix.normalize('///..//./foo/.//bar'), '/foo/bar');
+assert.strictEqual(path.posix.normalize('bar/foo../../'), 'bar/');
+assert.strictEqual(path.posix.normalize('bar/foo../..'), 'bar');
+assert.strictEqual(path.posix.normalize('bar/foo../../baz'), 'bar/baz');
+assert.strictEqual(path.posix.normalize('bar/foo../'), 'bar/foo../');
+assert.strictEqual(path.posix.normalize('bar/foo..'), 'bar/foo..');
+assert.strictEqual(path.posix.normalize('../foo../../../bar'), '../../bar');
+assert.strictEqual(path.posix.normalize('../.../.././.../../../bar'),
+                   '../../bar');
+assert.strictEqual(path.posix.normalize('../../../foo/../../../bar'),
+                   '../../../../../bar');
+assert.strictEqual(path.posix.normalize('../../../foo/../../../bar/../../'),
+                   '../../../../../../');
+assert.strictEqual(
+  path.posix.normalize('../foobar/barfoo/foo/../../../bar/../../'),
+  '../../'
+);
+assert.strictEqual(
+  path.posix.normalize('../.../../foobar/../../../bar/../../baz'),
+  '../../../../baz'
+);
+assert.strictEqual(path.posix.normalize('foo/bar\\baz'), 'foo/bar\\baz');
diff --git a/test/js/node/test/parallel/test-path-posix-exists.js b/test/js/node/test/parallel/test-path-posix-exists.js
new file mode 100644
index 0000000000..dc12ed6daf
--- /dev/null
+++ b/test/js/node/test/parallel/test-path-posix-exists.js
@@ -0,0 +1,6 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+
+assert.strictEqual(require('path/posix'), require('path').posix);
diff --git a/test/js/node/test/parallel/test-path-posix-relative-on-windows.js b/test/js/node/test/parallel/test-path-posix-relative-on-windows.js
new file mode 100644
index 0000000000..bcaaca8b18
--- /dev/null
+++ b/test/js/node/test/parallel/test-path-posix-relative-on-windows.js
@@ -0,0 +1,10 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const path = require('path');
+
+// Refs: https://github.com/nodejs/node/issues/13683
+
+const relativePath = path.posix.relative('a/b/c', '../../x');
+assert.match(relativePath, /^(\.\.\/){3,5}x$/);
diff --git a/test/js/node/test/parallel/test-path-relative.js b/test/js/node/test/parallel/test-path-relative.js
new file mode 100644
index 0000000000..f6a9f5662a
--- /dev/null
+++ b/test/js/node/test/parallel/test-path-relative.js
@@ -0,0 +1,69 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const path = require('path');
+
+const failures = [];
+
+const relativeTests = [
+  [ path.win32.relative,
+    // Arguments                     result
+    [['c:/blah\\blah', 'd:/games', 'd:\\games'],
+     ['c:/aaaa/bbbb', 'c:/aaaa', '..'],
+     ['c:/aaaa/bbbb', 'c:/cccc', '..\\..\\cccc'],
+     ['c:/aaaa/bbbb', 'c:/aaaa/bbbb', ''],
+     ['c:/aaaa/bbbb', 'c:/aaaa/cccc', '..\\cccc'],
+     ['c:/aaaa/', 'c:/aaaa/cccc', 'cccc'],
+     ['c:/', 'c:\\aaaa\\bbbb', 'aaaa\\bbbb'],
+     ['c:/aaaa/bbbb', 'd:\\', 'd:\\'],
+     ['c:/AaAa/bbbb', 'c:/aaaa/bbbb', ''],
+     ['c:/aaaaa/', 'c:/aaaa/cccc', '..\\aaaa\\cccc'],
+     ['C:\\foo\\bar\\baz\\quux', 'C:\\', '..\\..\\..\\..'],
+     ['C:\\foo\\test', 'C:\\foo\\test\\bar\\package.json', 'bar\\package.json'],
+     ['C:\\foo\\bar\\baz-quux', 'C:\\foo\\bar\\baz', '..\\baz'],
+     ['C:\\foo\\bar\\baz', 'C:\\foo\\bar\\baz-quux', '..\\baz-quux'],
+     ['\\\\foo\\bar', '\\\\foo\\bar\\baz', 'baz'],
+     ['\\\\foo\\bar\\baz', '\\\\foo\\bar', '..'],
+     ['\\\\foo\\bar\\baz-quux', '\\\\foo\\bar\\baz', '..\\baz'],
+     ['\\\\foo\\bar\\baz', '\\\\foo\\bar\\baz-quux', '..\\baz-quux'],
+     ['C:\\baz-quux', 'C:\\baz', '..\\baz'],
+     ['C:\\baz', 'C:\\baz-quux', '..\\baz-quux'],
+     ['\\\\foo\\baz-quux', '\\\\foo\\baz', '..\\baz'],
+     ['\\\\foo\\baz', '\\\\foo\\baz-quux', '..\\baz-quux'],
+     ['C:\\baz', '\\\\foo\\bar\\baz', '\\\\foo\\bar\\baz'],
+     ['\\\\foo\\bar\\baz', 'C:\\baz', 'C:\\baz'],
+    ],
+  ],
+  [ path.posix.relative,
+    // Arguments          result
+    [['/var/lib', '/var', '..'],
+     ['/var/lib', '/bin', '../../bin'],
+     ['/var/lib', '/var/lib', ''],
+     ['/var/lib', '/var/apache', '../apache'],
+     ['/var/', '/var/lib', 'lib'],
+     ['/', '/var/lib', 'var/lib'],
+     ['/foo/test', '/foo/test/bar/package.json', 'bar/package.json'],
+     ['/Users/a/web/b/test/mails', '/Users/a/web/b', '../..'],
+     ['/foo/bar/baz-quux', '/foo/bar/baz', '../baz'],
+     ['/foo/bar/baz', '/foo/bar/baz-quux', '../baz-quux'],
+     ['/baz-quux', '/baz', '../baz'],
+     ['/baz', '/baz-quux', '../baz-quux'],
+     ['/page1/page2/foo', '/', '../../..'],
+    ],
+  ],
+];
+relativeTests.forEach((test) => {
+  const relative = test[0];
+  test[1].forEach((test) => {
+    const actual = relative(test[0], test[1]);
+    const expected = test[2];
+    if (actual !== expected) {
+      const os = relative === path.win32.relative ? 'win32' : 'posix';
+      const message = `path.${os}.relative(${
+        test.slice(0, 2).map(JSON.stringify).join(',')})\n  expect=${
+        JSON.stringify(expected)}\n  actual=${JSON.stringify(actual)}`;
+      failures.push(`\n${message}`);
+    }
+  });
+});
+assert.strictEqual(failures.length, 0, failures.join(''));
diff --git a/test/js/node/test/parallel/test-path-win32-exists.js b/test/js/node/test/parallel/test-path-win32-exists.js
new file mode 100644
index 0000000000..c9efa74dbd
--- /dev/null
+++ b/test/js/node/test/parallel/test-path-win32-exists.js
@@ -0,0 +1,6 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+
+assert.strictEqual(require('path/win32'), require('path').win32);
diff --git a/test/js/node/test/parallel/test-path-zero-length-strings.js b/test/js/node/test/parallel/test-path-zero-length-strings.js
new file mode 100644
index 0000000000..f6516ffff8
--- /dev/null
+++ b/test/js/node/test/parallel/test-path-zero-length-strings.js
@@ -0,0 +1,39 @@
+'use strict';
+
+// These testcases are specific to one uncommon behavior in path module. Few
+// of the functions in path module, treat '' strings as current working
+// directory. This test makes sure that the behavior is intact between commits.
+// See: https://github.com/nodejs/node/pull/2106
+
+require('../common');
+const assert = require('assert');
+const path = require('path');
+const pwd = process.cwd();
+
+// Join will internally ignore all the zero-length strings and it will return
+// '.' if the joined string is a zero-length string.
+assert.strictEqual(path.posix.join(''), '.');
+assert.strictEqual(path.posix.join('', ''), '.');
+assert.strictEqual(path.win32.join(''), '.');
+assert.strictEqual(path.win32.join('', ''), '.');
+assert.strictEqual(path.join(pwd), pwd);
+assert.strictEqual(path.join(pwd, ''), pwd);
+
+// Normalize will return '.' if the input is a zero-length string
+assert.strictEqual(path.posix.normalize(''), '.');
+assert.strictEqual(path.win32.normalize(''), '.');
+assert.strictEqual(path.normalize(pwd), pwd);
+
+// Since '' is not a valid path in any of the common environments, return false
+assert.strictEqual(path.posix.isAbsolute(''), false);
+assert.strictEqual(path.win32.isAbsolute(''), false);
+
+// Resolve, internally ignores all the zero-length strings and returns the
+// current working directory
+assert.strictEqual(path.resolve(''), pwd);
+assert.strictEqual(path.resolve('', ''), pwd);
+
+// Relative, internally calls resolve. So, '' is actually the current directory
+assert.strictEqual(path.relative('', pwd), '');
+assert.strictEqual(path.relative(pwd, ''), '');
+assert.strictEqual(path.relative(pwd, pwd), '');
diff --git a/test/js/node/test/parallel/test-path.js b/test/js/node/test/parallel/test-path.js
new file mode 100644
index 0000000000..0cb55d42aa
--- /dev/null
+++ b/test/js/node/test/parallel/test-path.js
@@ -0,0 +1,73 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const path = require('path');
+
+// Test thrown TypeErrors
+const typeErrorTests = [true, false, 7, null, {}, undefined, [], NaN];
+
+function fail(fn) {
+  const args = Array.from(arguments).slice(1);
+
+  assert.throws(() => {
+    fn.apply(null, args);
+  }, { code: 'ERR_INVALID_ARG_TYPE', name: 'TypeError' });
+}
+
+for (const test of typeErrorTests) {
+  for (const namespace of [path.posix, path.win32]) {
+    fail(namespace.join, test);
+    fail(namespace.resolve, test);
+    fail(namespace.normalize, test);
+    fail(namespace.isAbsolute, test);
+    fail(namespace.relative, test, 'foo');
+    fail(namespace.relative, 'foo', test);
+    fail(namespace.parse, test);
+    fail(namespace.dirname, test);
+    fail(namespace.basename, test);
+    fail(namespace.extname, test);
+
+    // Undefined is a valid value as the second argument to basename
+    if (test !== undefined) {
+      fail(namespace.basename, 'foo', test);
+    }
+  }
+}
+
+// path.sep tests
+// windows
+assert.strictEqual(path.win32.sep, '\\');
+// posix
+assert.strictEqual(path.posix.sep, '/');
+
+// path.delimiter tests
+// windows
+assert.strictEqual(path.win32.delimiter, ';');
+// posix
+assert.strictEqual(path.posix.delimiter, ':');
+
+if (common.isWindows)
+  assert.strictEqual(path, path.win32);
+else
+  assert.strictEqual(path, path.posix);
diff --git a/test/js/node/test/parallel/test-perf-gc-crash.js b/test/js/node/test/parallel/test-perf-gc-crash.js
new file mode 100644
index 0000000000..d980e91a2f
--- /dev/null
+++ b/test/js/node/test/parallel/test-perf-gc-crash.js
@@ -0,0 +1,25 @@
+'use strict';
+
+require('../common');
+
+// Refers to https://github.com/nodejs/node/issues/39548
+
+// The test fails if this crashes. If it closes normally,
+// then all is good.
+
+const {
+  PerformanceObserver,
+} = require('perf_hooks');
+
+// We don't actually care if the observer callback is called here.
+const gcObserver = new PerformanceObserver(() => {});
+
+gcObserver.observe({ entryTypes: ['gc'] });
+
+gcObserver.disconnect();
+
+const gcObserver2 = new PerformanceObserver(() => {});
+
+gcObserver2.observe({ entryTypes: ['gc'] });
+
+gcObserver2.disconnect();
diff --git a/test/js/node/test/parallel/test-performance-measure.js b/test/js/node/test/parallel/test-performance-measure.js
new file mode 100644
index 0000000000..949258f96e
--- /dev/null
+++ b/test/js/node/test/parallel/test-performance-measure.js
@@ -0,0 +1,26 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+
+const { PerformanceObserver, performance } = require('perf_hooks');
+const DELAY = 1000;
+const ALLOWED_MARGIN = 10;
+
+const expected = ['Start to Now', 'A to Now', 'A to B'];
+const obs = new PerformanceObserver(common.mustCall((items) => {
+  items.getEntries().forEach(({ name, duration }) => {
+    assert.ok(duration > (DELAY - ALLOWED_MARGIN));
+    assert.strictEqual(expected.shift(), name);
+  });
+}));
+obs.observe({ entryTypes: ['measure'] });
+
+performance.mark('A');
+setTimeout(common.mustCall(() => {
+  performance.measure('Start to Now');
+  performance.measure('A to Now', 'A');
+
+  performance.mark('B');
+  performance.measure('A to B', 'A', 'B');
+}), DELAY);
diff --git a/test/js/node/test/parallel/test-performanceobserver-gc.js b/test/js/node/test/parallel/test-performanceobserver-gc.js
new file mode 100644
index 0000000000..fe9397631c
--- /dev/null
+++ b/test/js/node/test/parallel/test-performanceobserver-gc.js
@@ -0,0 +1,17 @@
+'use strict';
+
+require('../common');
+
+// Verifies that setting up two observers to listen
+// to gc performance does not crash.
+
+const {
+  PerformanceObserver,
+} = require('perf_hooks');
+
+// We don't actually care if the callback is ever invoked in this test
+const obs = new PerformanceObserver(() => {});
+const obs2 = new PerformanceObserver(() => {});
+
+obs.observe({ type: 'gc' });
+obs2.observe({ type: 'gc' });
diff --git a/test/js/node/test/parallel/test-permission-fs-windows-path.js b/test/js/node/test/parallel/test-permission-fs-windows-path.js
new file mode 100644
index 0000000000..552f8e1c21
--- /dev/null
+++ b/test/js/node/test/parallel/test-permission-fs-windows-path.js
@@ -0,0 +1,49 @@
+// Flags: --experimental-permission --allow-fs-read=* --allow-child-process
+'use strict';
+
+const common = require('../common');
+common.skipIfWorker();
+
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+
+if (!common.isWindows) {
+  common.skip('windows UNC path test');
+}
+
+{
+  const { stdout, status } = spawnSync(process.execPath, [
+    '--experimental-permission', '--allow-fs-write', 'C:\\\\', '-e',
+    'console.log(process.permission.has("fs.write", "C:\\\\"))',
+  ]);
+  assert.strictEqual(stdout.toString(), 'true\n');
+  assert.strictEqual(status, 0);
+}
+
+{
+  const { stdout, status, stderr } = spawnSync(process.execPath, [
+    '--experimental-permission', '--allow-fs-write="\\\\?\\C:\\"', '-e',
+    'console.log(process.permission.has("fs.write", "C:\\\\"))',
+  ]);
+  assert.strictEqual(stdout.toString(), 'false\n', stderr.toString());
+  assert.strictEqual(status, 0);
+}
+
+{
+  const { stdout, status, stderr } = spawnSync(process.execPath, [
+    '--experimental-permission', '--allow-fs-write', 'C:\\', '-e',
+    `const path = require('path');
+     console.log(process.permission.has('fs.write', path.toNamespacedPath('C:\\\\')))`,
+  ]);
+  assert.strictEqual(stdout.toString(), 'true\n', stderr.toString());
+  assert.strictEqual(status, 0);
+}
+
+{
+  const { stdout, status, stderr } = spawnSync(process.execPath, [
+    '--experimental-permission', '--allow-fs-write', 'C:\\*', '-e',
+    "console.log(process.permission.has('fs.write', '\\\\\\\\A\\\\C:\\Users'))",
+  ]);
+  assert.strictEqual(stdout.toString(), 'false\n', stderr.toString());
+  assert.strictEqual(status, 0);
+}
diff --git a/test/js/node/test/parallel/test-pipe-abstract-socket-http.js b/test/js/node/test/parallel/test-pipe-abstract-socket-http.js
new file mode 100644
index 0000000000..6d3beb44d1
--- /dev/null
+++ b/test/js/node/test/parallel/test-pipe-abstract-socket-http.js
@@ -0,0 +1,27 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const http = require('http');
+
+if (!common.isLinux) common.skip();
+
+const server = http.createServer(
+  common.mustCall((req, res) => {
+    res.end('ok');
+  })
+);
+
+server.listen(
+  '\0abstract',
+  common.mustCall(() => {
+    http.get(
+      {
+        socketPath: server.address(),
+      },
+      common.mustCall((res) => {
+        assert.strictEqual(res.statusCode, 200);
+        server.close();
+      })
+    );
+  })
+);
diff --git a/test/js/node/test/parallel/test-pipe-abstract-socket.js b/test/js/node/test/parallel/test-pipe-abstract-socket.js
new file mode 100644
index 0000000000..baf76d6b82
--- /dev/null
+++ b/test/js/node/test/parallel/test-pipe-abstract-socket.js
@@ -0,0 +1,34 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const net = require('net');
+
+if (!common.isLinux) common.skip();
+
+const path = '\0abstract';
+const message = /can not set readableAll or writableAllt to true when path is abstract unix socket/;
+
+assert.throws(() => {
+  const server = net.createServer(common.mustNotCall());
+  server.listen({
+    path,
+    readableAll: true
+  });
+}, message);
+
+assert.throws(() => {
+  const server = net.createServer(common.mustNotCall());
+  server.listen({
+    path,
+    writableAll: true
+  });
+}, message);
+
+assert.throws(() => {
+  const server = net.createServer(common.mustNotCall());
+  server.listen({
+    path,
+    readableAll: true,
+    writableAll: true
+  });
+}, message);
diff --git a/test/js/node/test/parallel/test-pipe-address.js b/test/js/node/test/parallel/test-pipe-address.js
new file mode 100644
index 0000000000..3550434932
--- /dev/null
+++ b/test/js/node/test/parallel/test-pipe-address.js
@@ -0,0 +1,13 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const net = require('net');
+const server = net.createServer(common.mustNotCall());
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+server.listen(common.PIPE, common.mustCall(function() {
+  assert.strictEqual(server.address(), common.PIPE);
+  server.close();
+}));
diff --git a/test/js/node/test/parallel/test-pipe-file-to-http.js b/test/js/node/test/parallel/test-pipe-file-to-http.js
new file mode 100644
index 0000000000..6c1244427d
--- /dev/null
+++ b/test/js/node/test/parallel/test-pipe-file-to-http.js
@@ -0,0 +1,83 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const fs = require('fs');
+const http = require('http');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+const filename = tmpdir.resolve('big');
+let count = 0;
+
+const server = http.createServer((req, res) => {
+  let timeoutId;
+  assert.strictEqual(req.method, 'POST');
+  req.pause();
+
+  setTimeout(() => {
+    req.resume();
+  }, 1000);
+
+  req.on('data', (chunk) => {
+    count += chunk.length;
+  });
+
+  req.on('end', () => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    res.writeHead(200, { 'Content-Type': 'text/plain' });
+    res.end();
+  });
+});
+server.listen(0);
+
+server.on('listening', () => {
+  common.createZeroFilledFile(filename);
+  makeRequest();
+});
+
+function makeRequest() {
+  const req = http.request({
+    port: server.address().port,
+    path: '/',
+    method: 'POST'
+  });
+
+  const s = fs.ReadStream(filename);
+  s.pipe(req);
+  s.on('close', common.mustSucceed());
+
+  req.on('response', (res) => {
+    res.resume();
+    res.on('end', () => {
+      server.close();
+    });
+  });
+}
+
+process.on('exit', () => {
+  assert.strictEqual(count, 1024 * 10240);
+});
diff --git a/test/js/node/test/parallel/test-pipe-head.js b/test/js/node/test/parallel/test-pipe-head.js
new file mode 100644
index 0000000000..1e79249c29
--- /dev/null
+++ b/test/js/node/test/parallel/test-pipe-head.js
@@ -0,0 +1,16 @@
+'use strict';
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+
+const exec = require('child_process').exec;
+
+const nodePath = process.argv[0];
+const script = fixtures.path('print-10-lines.js');
+
+const cmd = `"${nodePath}" "${script}" | head -2`;
+
+exec(cmd, common.mustSucceed((stdout, stderr) => {
+  const lines = stdout.split('\n');
+  assert.strictEqual(lines.length, 3);
+}));
diff --git a/test/js/node/test/parallel/test-pipe-return-val.js b/test/js/node/test/parallel/test-pipe-return-val.js
new file mode 100644
index 0000000000..f2a7f573ec
--- /dev/null
+++ b/test/js/node/test/parallel/test-pipe-return-val.js
@@ -0,0 +1,33 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+// This test ensures SourceStream.pipe(DestStream) returns DestStream
+
+require('../common');
+const Stream = require('stream').Stream;
+const assert = require('assert');
+
+const sourceStream = new Stream();
+const destStream = new Stream();
+const result = sourceStream.pipe(destStream);
+
+assert.strictEqual(result, destStream);
diff --git a/test/js/node/test/parallel/test-pipe-writev.js b/test/js/node/test/parallel/test-pipe-writev.js
new file mode 100644
index 0000000000..5e5b42e6a7
--- /dev/null
+++ b/test/js/node/test/parallel/test-pipe-writev.js
@@ -0,0 +1,45 @@
+'use strict';
+
+const common = require('../common');
+if (common.isWindows)
+  common.skip('Unix-specific test');
+
+const assert = require('assert');
+const net = require('net');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+const server = net.createServer((connection) => {
+  connection.on('error', (err) => {
+    throw err;
+  });
+
+  const writev = connection._writev.bind(connection);
+  connection._writev = common.mustCall(writev);
+
+  connection.cork();
+  connection.write('pi');
+  connection.write('ng');
+  connection.end();
+});
+
+server.on('error', (err) => {
+  throw err;
+});
+
+server.listen(common.PIPE, () => {
+  const client = net.connect(common.PIPE);
+
+  client.on('error', (err) => {
+    throw err;
+  });
+
+  client.on('data', common.mustCall((data) => {
+    assert.strictEqual(data.toString(), 'ping');
+  }));
+
+  client.on('end', () => {
+    server.close();
+  });
+});
diff --git a/test/js/node/test/parallel/test-preload-print-process-argv.js b/test/js/node/test/parallel/test-preload-print-process-argv.js
new file mode 100644
index 0000000000..9d2774f8a4
--- /dev/null
+++ b/test/js/node/test/parallel/test-preload-print-process-argv.js
@@ -0,0 +1,34 @@
+'use strict';
+
+// This tests that process.argv is the same in the preloaded module
+// and the user module.
+
+require('../common');
+
+const tmpdir = require('../common/tmpdir');
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+
+tmpdir.refresh();
+
+fs.writeFileSync(
+  tmpdir.resolve('preload.js'),
+  'console.log(JSON.stringify(process.argv));',
+  'utf-8');
+
+fs.writeFileSync(
+  tmpdir.resolve('main.js'),
+  'console.log(JSON.stringify(process.argv));',
+  'utf-8');
+
+const child = spawnSync(process.execPath, ['-r', './preload.js', 'main.js'],
+                        { cwd: tmpdir.path });
+
+if (child.status !== 0) {
+  console.log(child.stderr.toString());
+  assert.strictEqual(child.status, 0);
+}
+
+const lines = child.stdout.toString().trim().split('\n');
+assert.deepStrictEqual(JSON.parse(lines[0]), JSON.parse(lines[1]));
diff --git a/test/js/node/test/parallel/test-preload-self-referential.js b/test/js/node/test/parallel/test-preload-self-referential.js
new file mode 100644
index 0000000000..2624527deb
--- /dev/null
+++ b/test/js/node/test/parallel/test-preload-self-referential.js
@@ -0,0 +1,20 @@
+'use strict';
+
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+const { exec } = require('child_process');
+
+const nodeBinary = process.argv[0];
+
+if (!common.isMainThread)
+  common.skip('process.chdir is not available in Workers');
+
+const selfRefModule = fixtures.path('self_ref_module');
+const fixtureA = fixtures.path('printA.js');
+
+exec(`"${nodeBinary}" -r self_ref "${fixtureA}"`, { cwd: selfRefModule },
+     (err, stdout, stderr) => {
+       assert.ifError(err);
+       assert.strictEqual(stdout, 'A\n');
+     });
diff --git a/test/js/node/test/parallel/test-process-abort.js b/test/js/node/test/parallel/test-process-abort.js
new file mode 100644
index 0000000000..665e1399a3
--- /dev/null
+++ b/test/js/node/test/parallel/test-process-abort.js
@@ -0,0 +1,12 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+
+if (!common.isMainThread)
+  common.skip('process.abort() is not available in Workers');
+
+// Check that our built-in methods do not have a prototype/constructor behaviour
+// if they don't need to. This could be tested for any of our C++ methods.
+assert.strictEqual(process.abort.prototype, undefined);
+assert.throws(() => new process.abort(), TypeError);
diff --git a/test/js/node/test/parallel/test-process-argv-0.js b/test/js/node/test/parallel/test-process-argv-0.js
new file mode 100644
index 0000000000..21b406873f
--- /dev/null
+++ b/test/js/node/test/parallel/test-process-argv-0.js
@@ -0,0 +1,42 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const path = require('path');
+const assert = require('assert');
+const spawn = require('child_process').spawn;
+
+if (process.argv[2] !== 'child') {
+  const child = spawn(process.execPath, [__filename, 'child'], {
+    cwd: path.dirname(process.execPath)
+  });
+
+  let childArgv0 = '';
+  child.stdout.on('data', function(chunk) {
+    childArgv0 += chunk;
+  });
+  process.on('exit', function() {
+    assert.strictEqual(childArgv0, process.execPath);
+  });
+} else {
+  process.stdout.write(process.argv[0]);
+}
diff --git a/test/js/node/test/parallel/test-process-constants-noatime.js b/test/js/node/test/parallel/test-process-constants-noatime.js
new file mode 100644
index 0000000000..bd1a848ed7
--- /dev/null
+++ b/test/js/node/test/parallel/test-process-constants-noatime.js
@@ -0,0 +1,12 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const constants = require('fs').constants;
+
+if (common.isLinux) {
+  assert('O_NOATIME' in constants);
+  assert.strictEqual(constants.O_NOATIME, 0x40000);
+} else {
+  assert(!('O_NOATIME' in constants));
+}
diff --git a/test/js/node/test/parallel/test-process-dlopen-undefined-exports.js b/test/js/node/test/parallel/test-process-dlopen-undefined-exports.js
new file mode 100644
index 0000000000..3766a73a45
--- /dev/null
+++ b/test/js/node/test/parallel/test-process-dlopen-undefined-exports.js
@@ -0,0 +1,10 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+
+const someBindingPath = './test/addons/hello-world/build/Release/binding.node';
+
+assert.throws(() => {
+  process.dlopen({ exports: undefined }, someBindingPath);
+}, Error);
diff --git a/test/js/node/test/parallel/test-process-domain-segfault.js b/test/js/node/test/parallel/test-process-domain-segfault.js
new file mode 100644
index 0000000000..78009f4687
--- /dev/null
+++ b/test/js/node/test/parallel/test-process-domain-segfault.js
@@ -0,0 +1,32 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+
+// This test ensures that setting `process.domain` to `null` does not result in
+// node crashing with a segfault.
+// https://github.com/nodejs/node-v0.x-archive/issues/4256
+
+process.domain = null;
+setTimeout(function() {
+  console.log('this console.log statement should not make node crash');
+}, 1);
diff --git a/test/js/node/test/parallel/test-process-emit.js b/test/js/node/test/parallel/test-process-emit.js
new file mode 100644
index 0000000000..8c2ad675cf
--- /dev/null
+++ b/test/js/node/test/parallel/test-process-emit.js
@@ -0,0 +1,22 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const sym = Symbol();
+
+process.on('normal', common.mustCall((data) => {
+  assert.strictEqual(data, 'normalData');
+}));
+
+process.on(sym, common.mustCall((data) => {
+  assert.strictEqual(data, 'symbolData');
+}));
+
+process.on('SIGPIPE', common.mustCall((data) => {
+  assert.strictEqual(data, 'signalData');
+}));
+
+process.emit('normal', 'normalData');
+process.emit(sym, 'symbolData');
+process.emit('SIGPIPE', 'signalData');
+
+assert.strictEqual(Number.isNaN(process._eventsCount), false);
diff --git a/test/js/node/test/parallel/test-process-env-windows-error-reset.js b/test/js/node/test/parallel/test-process-env-windows-error-reset.js
new file mode 100644
index 0000000000..881da06d29
--- /dev/null
+++ b/test/js/node/test/parallel/test-process-env-windows-error-reset.js
@@ -0,0 +1,22 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+
+// This checks that after accessing a missing env var, a subsequent
+// env read will succeed even for empty variables.
+
+{
+  process.env.FOO = '';
+  process.env.NONEXISTENT_ENV_VAR; // eslint-disable-line no-unused-expressions
+  const foo = process.env.FOO;
+
+  assert.strictEqual(foo, '');
+}
+
+{
+  process.env.FOO = '';
+  process.env.NONEXISTENT_ENV_VAR; // eslint-disable-line no-unused-expressions
+  const hasFoo = 'FOO' in process.env;
+
+  assert.strictEqual(hasFoo, true);
+}
diff --git a/test/js/node/test/parallel/test-process-exception-capture-should-abort-on-uncaught.js b/test/js/node/test/parallel/test-process-exception-capture-should-abort-on-uncaught.js
new file mode 100644
index 0000000000..f9e685a86e
--- /dev/null
+++ b/test/js/node/test/parallel/test-process-exception-capture-should-abort-on-uncaught.js
@@ -0,0 +1,12 @@
+// Flags: --abort-on-uncaught-exception
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+assert.strictEqual(process.hasUncaughtExceptionCaptureCallback(), false);
+
+// This should make the process not crash even though the flag was passed.
+process.setUncaughtExceptionCaptureCallback(common.mustCall((err) => {
+  assert.strictEqual(err.message, 'foo');
+}));
+throw new Error('foo');
diff --git a/test/js/node/test/parallel/test-process-exception-capture.js b/test/js/node/test/parallel/test-process-exception-capture.js
new file mode 100644
index 0000000000..c84d3459e2
--- /dev/null
+++ b/test/js/node/test/parallel/test-process-exception-capture.js
@@ -0,0 +1,13 @@
+// Flags: --abort-on-uncaught-exception
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+assert.strictEqual(process.hasUncaughtExceptionCaptureCallback(), false);
+
+// This should make the process not crash even though the flag was passed.
+process.setUncaughtExceptionCaptureCallback(common.mustCall((err) => {
+  assert.strictEqual(err.message, 'foo');
+}));
+process.on('uncaughtException', common.mustNotCall());
+throw new Error('foo');
diff --git a/test/js/node/test/parallel/test-process-execpath.js b/test/js/node/test/parallel/test-process-execpath.js
new file mode 100644
index 0000000000..0fce35e264
--- /dev/null
+++ b/test/js/node/test/parallel/test-process-execpath.js
@@ -0,0 +1,26 @@
+'use strict';
+const common = require('../common');
+if (common.isWindows)
+  common.skip('symlinks are weird on windows');
+
+const assert = require('assert');
+const child_process = require('child_process');
+const fs = require('fs');
+
+assert.strictEqual(process.execPath, fs.realpathSync(process.execPath));
+
+if (process.argv[2] === 'child') {
+  // The console.log() output is part of the test here.
+  console.log(process.execPath);
+} else {
+  const tmpdir = require('../common/tmpdir');
+  tmpdir.refresh();
+
+  const symlinkedNode = tmpdir.resolve('symlinked-node');
+  fs.symlinkSync(process.execPath, symlinkedNode);
+
+  const proc = child_process.spawnSync(symlinkedNode, [__filename, 'child']);
+  assert.strictEqual(proc.stderr.toString(), '');
+  assert.strictEqual(proc.stdout.toString(), `${process.execPath}\n`);
+  assert.strictEqual(proc.status, 0);
+}
diff --git a/test/js/node/test/parallel/test-process-exit-from-before-exit.js b/test/js/node/test/parallel/test-process-exit-from-before-exit.js
new file mode 100644
index 0000000000..7f20c22f0b
--- /dev/null
+++ b/test/js/node/test/parallel/test-process-exit-from-before-exit.js
@@ -0,0 +1,30 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+process.on('beforeExit', common.mustCall(function() {
+  setTimeout(common.mustNotCall(), 5);
+  process.exit(0);  // Should execute immediately even if we schedule new work.
+  assert.fail();
+}));
diff --git a/test/js/node/test/parallel/test-process-exit-handler.js b/test/js/node/test/parallel/test-process-exit-handler.js
new file mode 100644
index 0000000000..d74e320fe6
--- /dev/null
+++ b/test/js/node/test/parallel/test-process-exit-handler.js
@@ -0,0 +1,14 @@
+'use strict';
+const common = require('../common');
+
+if (!common.isMainThread)
+  common.skip('execArgv does not affect Workers');
+
+// This test ensures that no asynchronous operations are performed in the 'exit'
+// handler.
+// https://github.com/nodejs/node/issues/12322
+
+process.on('exit', () => {
+  setTimeout(() => process.abort(), 0); // Should not run.
+  for (const start = Date.now(); Date.now() - start < 10;);
+});
diff --git a/test/js/node/test/parallel/test-process-exit-recursive.js b/test/js/node/test/parallel/test-process-exit-recursive.js
new file mode 100644
index 0000000000..727aa4abe7
--- /dev/null
+++ b/test/js/node/test/parallel/test-process-exit-recursive.js
@@ -0,0 +1,37 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+
+// Recursively calling .exit() should not overflow the call stack
+let nexits = 0;
+
+process.on('exit', function(code) {
+  assert.strictEqual(nexits++, 0);
+  assert.strictEqual(code, 1);
+
+  // Now override the exit code of 1 with 0 so that the test passes
+  process.exit(0);
+});
+
+process.exit(1);
diff --git a/test/js/node/test/parallel/test-process-exit.js b/test/js/node/test/parallel/test-process-exit.js
new file mode 100644
index 0000000000..cd605949af
--- /dev/null
+++ b/test/js/node/test/parallel/test-process-exit.js
@@ -0,0 +1,35 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+
+// Calling .exit() from within "exit" should not overflow the call stack
+let nexits = 0;
+
+process.on('exit', function(code) {
+  assert.strictEqual(nexits++, 0);
+  assert.strictEqual(code, 0);
+  process.exit();
+});
+
+// "exit" should be emitted unprovoked
diff --git a/test/js/node/test/parallel/test-process-features.js b/test/js/node/test/parallel/test-process-features.js
new file mode 100644
index 0000000000..3b4677c561
--- /dev/null
+++ b/test/js/node/test/parallel/test-process-features.js
@@ -0,0 +1,22 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+
+const keys = new Set(Object.keys(process.features));
+
+assert.deepStrictEqual(keys, new Set([
+  'inspector',
+  'debug',
+  'uv',
+  'ipv6',
+  'tls_alpn',
+  'tls_sni',
+  'tls_ocsp',
+  'tls',
+  'cached_builtins',
+]));
+
+for (const key of keys) {
+  assert.strictEqual(typeof process.features[key], 'boolean');
+}
diff --git a/test/js/node/test/parallel/test-process-getgroups.js b/test/js/node/test/parallel/test-process-getgroups.js
new file mode 100644
index 0000000000..28df13205f
--- /dev/null
+++ b/test/js/node/test/parallel/test-process-getgroups.js
@@ -0,0 +1,52 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+
+// Check `id -G` and `process.getgroups()` return same groups.
+
+if (common.isMacOS)
+  common.skip('Output of `id -G` is unreliable on Darwin.');
+
+const assert = require('assert');
+const exec = require('child_process').exec;
+
+if (typeof process.getgroups === 'function') {
+  const groups = unique(process.getgroups());
+  assert(Array.isArray(groups));
+  assert(groups.length > 0);
+  exec('id -G', function(err, stdout) {
+    assert.ifError(err);
+    const real_groups = unique(stdout.match(/\d+/g).map(Number));
+    assert.deepStrictEqual(groups, real_groups);
+    check(groups, real_groups);
+    check(real_groups, groups);
+  });
+}
+
+function check(a, b) {
+  for (let i = 0; i < a.length; ++i) assert(b.includes(a[i]));
+}
+
+function unique(groups) {
+  return [...new Set(groups)].sort();
+}
diff --git a/test/js/node/test/parallel/test-process-hrtime-bigint.js b/test/js/node/test/parallel/test-process-hrtime-bigint.js
new file mode 100644
index 0000000000..e5ce40a994
--- /dev/null
+++ b/test/js/node/test/parallel/test-process-hrtime-bigint.js
@@ -0,0 +1,14 @@
+'use strict';
+
+// Tests that process.hrtime.bigint() works.
+
+require('../common');
+const assert = require('assert');
+
+const start = process.hrtime.bigint();
+assert.strictEqual(typeof start, 'bigint');
+
+const end = process.hrtime.bigint();
+assert.strictEqual(typeof end, 'bigint');
+
+assert(end - start >= 0n);
diff --git a/test/js/node/test/parallel/test-process-kill-null.js b/test/js/node/test/parallel/test-process-kill-null.js
new file mode 100644
index 0000000000..88fc677454
--- /dev/null
+++ b/test/js/node/test/parallel/test-process-kill-null.js
@@ -0,0 +1,42 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const { mustCall } = require('../common');
+const assert = require('assert');
+const { spawn } = require('child_process');
+
+const cat = spawn('cat');
+
+assert.ok(process.kill(cat.pid, 0));
+
+cat.on('exit', mustCall(function() {
+  assert.throws(function() {
+    process.kill(cat.pid, 0);
+  }, Error);
+}));
+
+cat.stdout.on('data', mustCall(function() {
+  process.kill(cat.pid, 'SIGKILL');
+}));
+
+// EPIPE when null sig fails
+cat.stdin.write('test');
diff --git a/test/js/node/test/parallel/test-process-next-tick.js b/test/js/node/test/parallel/test-process-next-tick.js
new file mode 100644
index 0000000000..66913beebf
--- /dev/null
+++ b/test/js/node/test/parallel/test-process-next-tick.js
@@ -0,0 +1,49 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const N = 2;
+
+function cb() {
+  throw new Error();
+}
+
+for (let i = 0; i < N; ++i) {
+  process.nextTick(common.mustCall(cb));
+}
+
+process.on('uncaughtException', common.mustCall(N));
+
+process.on('exit', function() {
+  process.removeAllListeners('uncaughtException');
+});
+
+[null, 1, 'test', {}, [], Infinity, true].forEach((i) => {
+  assert.throws(
+    () => process.nextTick(i),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError',
+    }
+  );
+});
diff --git a/test/js/node/test/parallel/test-process-ppid.js b/test/js/node/test/parallel/test-process-ppid.js
new file mode 100644
index 0000000000..d78ef3a2dd
--- /dev/null
+++ b/test/js/node/test/parallel/test-process-ppid.js
@@ -0,0 +1,16 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const cp = require('child_process');
+
+if (process.argv[2] === 'child') {
+  // The following console.log() call is part of the test's functionality.
+  console.log(process.ppid);
+} else {
+  const child = cp.spawnSync(process.execPath, [__filename, 'child']);
+
+  assert.strictEqual(child.status, 0);
+  assert.strictEqual(child.signal, null);
+  assert.strictEqual(+child.stdout.toString().trim(), process.pid);
+  assert.strictEqual(child.stderr.toString().trim(), '');
+}
diff --git a/test/js/node/test/parallel/test-process-remove-all-signal-listeners.js b/test/js/node/test/parallel/test-process-remove-all-signal-listeners.js
new file mode 100644
index 0000000000..afd574daaa
--- /dev/null
+++ b/test/js/node/test/parallel/test-process-remove-all-signal-listeners.js
@@ -0,0 +1,34 @@
+'use strict';
+
+const common = require('../common');
+if (common.isWindows)
+  common.skip('Win32 does not support signals.');
+
+const assert = require('assert');
+const spawn = require('child_process').spawn;
+
+if (process.argv[2] !== '--do-test') {
+  // We are the primary, fork a child so we can verify it exits with correct
+  // status.
+  process.env.DOTEST = 'y';
+  const child = spawn(process.execPath, [__filename, '--do-test']);
+
+  child.once('exit', common.mustCall(function(code, signal) {
+    assert.strictEqual(signal, 'SIGINT');
+  }));
+
+  return;
+}
+
+process.on('SIGINT', function() {
+  // Remove all handlers and kill ourselves. We should terminate by SIGINT
+  // now that we have no handlers.
+  process.removeAllListeners('SIGINT');
+  process.kill(process.pid, 'SIGINT');
+});
+
+// Signal handlers aren't sufficient to keep node alive, so resume stdin
+process.stdin.resume();
+
+// Demonstrate that signals are being handled
+process.kill(process.pid, 'SIGINT');
diff --git a/test/js/node/test/parallel/test-process-setuid-io-uring.js b/test/js/node/test/parallel/test-process-setuid-io-uring.js
new file mode 100644
index 0000000000..93193ac2f8
--- /dev/null
+++ b/test/js/node/test/parallel/test-process-setuid-io-uring.js
@@ -0,0 +1,43 @@
+'use strict';
+const common = require('../common');
+
+const assert = require('node:assert');
+const { execFileSync } = require('node:child_process');
+
+if (!common.isLinux) {
+  common.skip('test is Linux specific');
+}
+
+if (process.arch !== 'x64' && process.arch !== 'arm64') {
+  common.skip('io_uring support on this architecture is uncertain');
+}
+
+const kv = /^(\d+)\.(\d+)\.(\d+)/.exec(execFileSync('uname', ['-r'])).slice(1).map((n) => parseInt(n, 10));
+if (((kv[0] << 16) | (kv[1] << 8) | kv[2]) < 0x050ABA) {
+  common.skip('io_uring is likely buggy due to old kernel');
+}
+
+const userIdentitySetters = [
+  ['setuid', [1000]],
+  ['seteuid', [1000]],
+  ['setgid', [1000]],
+  ['setegid', [1000]],
+  ['setgroups', [[1000]]],
+  ['initgroups', ['nodeuser', 1000]],
+];
+
+for (const [fnName, args] of userIdentitySetters) {
+  const call = `process.${fnName}(${args.map((a) => JSON.stringify(a)).join(', ')})`;
+  const code = `try { ${call}; } catch (err) { console.log(err); }`;
+
+  const stdout = execFileSync(process.execPath, ['-e', code], {
+    encoding: 'utf8',
+    env: { ...process.env, UV_USE_IO_URING: '1' },
+  });
+
+  const msg = new RegExp(`^Error: ${fnName}\\(\\) disabled: io_uring may be enabled\\. See CVE-[X0-9]{4}-`);
+  assert.match(stdout, msg);
+  assert.match(stdout, /code: 'ERR_INVALID_STATE'/);
+
+  console.log(call, stdout.slice(0, stdout.indexOf('\n')));
+}
diff --git a/test/js/node/test/parallel/test-process-uptime.js b/test/js/node/test/parallel/test-process-uptime.js
new file mode 100644
index 0000000000..eabb6cf266
--- /dev/null
+++ b/test/js/node/test/parallel/test-process-uptime.js
@@ -0,0 +1,37 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+
+console.error(process.uptime());
+// Add some wiggle room for different platforms.
+// Verify that the returned value is in seconds -
+// 15 seconds should be a good estimate.
+assert.ok(process.uptime() <= 15);
+
+const original = process.uptime();
+
+setTimeout(function() {
+  const uptime = process.uptime();
+  assert.ok(original < uptime);
+}, 10);
diff --git a/test/js/node/test/parallel/test-promise-handled-rejection-no-warning.js b/test/js/node/test/parallel/test-promise-handled-rejection-no-warning.js
new file mode 100644
index 0000000000..8878d67fab
--- /dev/null
+++ b/test/js/node/test/parallel/test-promise-handled-rejection-no-warning.js
@@ -0,0 +1,7 @@
+'use strict';
+const common = require('../common');
+
+// This test verifies that DEP0018 does not occur when rejections are handled.
+process.on('warning', common.mustNotCall());
+process.on('unhandledRejection', common.mustCall());
+Promise.reject(new Error());
diff --git a/test/js/node/test/parallel/test-promise-unhandled-issue-43655.js b/test/js/node/test/parallel/test-promise-unhandled-issue-43655.js
new file mode 100644
index 0000000000..4fd2c1a711
--- /dev/null
+++ b/test/js/node/test/parallel/test-promise-unhandled-issue-43655.js
@@ -0,0 +1,27 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+
+function delay(time) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, time);
+  });
+}
+
+async function test() {
+  for (let i = 0; i < 100000; i++) {
+    await new Promise((resolve, reject) => {
+      reject('value');
+    })
+      .then(() => { }, () => { });
+  }
+
+  const time0 = Date.now();
+  await delay(0);
+
+  const diff = Date.now() - time0;
+  assert.ok(Date.now() - time0 < 500, `Expected less than 500ms, got ${diff}ms`);
+}
+
+test();
diff --git a/test/js/node/test/parallel/test-promise-unhandled-silent.js b/test/js/node/test/parallel/test-promise-unhandled-silent.js
new file mode 100644
index 0000000000..edf5111eae
--- /dev/null
+++ b/test/js/node/test/parallel/test-promise-unhandled-silent.js
@@ -0,0 +1,21 @@
+// Flags: --unhandled-rejections=none
+'use strict';
+
+const common = require('../common');
+
+// Verify that ignoring unhandled rejection works fine and that no warning is
+// logged.
+
+new Promise(() => {
+  throw new Error('One');
+});
+
+Promise.reject('test');
+
+process.on('warning', common.mustNotCall('warning'));
+process.on('uncaughtException', common.mustNotCall('uncaughtException'));
+process.on('rejectionHandled', common.mustNotCall('rejectionHandled'));
+
+process.on('unhandledRejection', common.mustCall(2));
+
+setTimeout(common.mustCall(), 2);
diff --git a/test/js/node/test/parallel/test-promise-unhandled-throw-handler.js b/test/js/node/test/parallel/test-promise-unhandled-throw-handler.js
new file mode 100644
index 0000000000..26a1d2f85c
--- /dev/null
+++ b/test/js/node/test/parallel/test-promise-unhandled-throw-handler.js
@@ -0,0 +1,36 @@
+// Flags: --unhandled-rejections=throw
+'use strict';
+
+const common = require('../common');
+const Countdown = require('../common/countdown');
+const assert = require('assert');
+
+// Verify that the unhandledRejection handler prevents triggering
+// uncaught exceptions
+
+const err1 = new Error('One');
+
+const errors = [err1, null];
+
+const ref = new Promise(() => {
+  throw err1;
+});
+// Explicitly reject `null`.
+Promise.reject(null);
+
+process.on('warning', common.mustNotCall('warning'));
+process.on('rejectionHandled', common.mustNotCall('rejectionHandled'));
+process.on('exit', assert.strictEqual.bind(null, 0));
+process.on('uncaughtException', common.mustNotCall('uncaughtException'));
+
+const timer = setTimeout(() => console.log(ref), 1000);
+
+const counter = new Countdown(2, () => {
+  clearTimeout(timer);
+});
+
+process.on('unhandledRejection', common.mustCall((err) => {
+  counter.dec();
+  const knownError = errors.shift();
+  assert.deepStrictEqual(err, knownError);
+}, 2));
diff --git a/test/js/node/test/parallel/test-querystring-maxKeys-non-finite.js b/test/js/node/test/parallel/test-querystring-maxKeys-non-finite.js
new file mode 100644
index 0000000000..610c30c7a3
--- /dev/null
+++ b/test/js/node/test/parallel/test-querystring-maxKeys-non-finite.js
@@ -0,0 +1,58 @@
+'use strict';
+// This test was originally written to test a regression
+// that was introduced by
+// https://github.com/nodejs/node/pull/2288#issuecomment-179543894
+require('../common');
+
+const assert = require('assert');
+const parse = require('querystring').parse;
+
+// Taken from express-js/body-parser
+// https://github.com/expressjs/body-parser/blob/ed25264fb494cf0c8bc992b8257092cd4f694d5e/test/urlencoded.js#L636-L651
+function createManyParams(count) {
+  let str = '';
+
+  if (count === 0) {
+    return str;
+  }
+
+  str += '0=0';
+
+  for (let i = 1; i < count; i++) {
+    const n = i.toString(36);
+    str += `&${n}=${n}`;
+  }
+
+  return str;
+}
+
+const count = 10000;
+const originalMaxLength = 1000;
+const params = createManyParams(count);
+
+// thealphanerd
+// 27def4f introduced a change to parse that would cause Infinity
+// to be passed to String.prototype.split as an argument for limit
+// In this instance split will always return an empty array
+// this test confirms that the output of parse is the expected length
+// when passed Infinity as the argument for maxKeys
+const resultInfinity = parse(params, undefined, undefined, {
+  maxKeys: Infinity
+});
+const resultNaN = parse(params, undefined, undefined, {
+  maxKeys: NaN
+});
+const resultInfinityString = parse(params, undefined, undefined, {
+  maxKeys: 'Infinity'
+});
+const resultNaNString = parse(params, undefined, undefined, {
+  maxKeys: 'NaN'
+});
+
+// Non Finite maxKeys should return the length of input
+assert.strictEqual(Object.keys(resultInfinity).length, count);
+assert.strictEqual(Object.keys(resultNaN).length, count);
+// Strings maxKeys should return the maxLength
+// defined by parses internals
+assert.strictEqual(Object.keys(resultInfinityString).length, originalMaxLength);
+assert.strictEqual(Object.keys(resultNaNString).length, originalMaxLength);
diff --git a/test/js/node/test/parallel/test-querystring-multichar-separator.js b/test/js/node/test/parallel/test-querystring-multichar-separator.js
new file mode 100644
index 0000000000..720733b1e2
--- /dev/null
+++ b/test/js/node/test/parallel/test-querystring-multichar-separator.js
@@ -0,0 +1,25 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const qs = require('querystring');
+
+function check(actual, expected) {
+  assert(!(actual instanceof Object));
+  assert.deepStrictEqual(Object.keys(actual).sort(),
+                         Object.keys(expected).sort());
+  Object.keys(expected).forEach(function(key) {
+    assert.deepStrictEqual(actual[key], expected[key]);
+  });
+}
+
+check(qs.parse('foo=>bar&&bar=>baz', '&&', '=>'),
+      { foo: 'bar', bar: 'baz' });
+
+check(qs.stringify({ foo: 'bar', bar: 'baz' }, '&&', '=>'),
+      'foo=>bar&&bar=>baz');
+
+check(qs.parse('foo==>bar, bar==>baz', ', ', '==>'),
+      { foo: 'bar', bar: 'baz' });
+
+check(qs.stringify({ foo: 'bar', bar: 'baz' }, ', ', '==>'),
+      'foo==>bar, bar==>baz');
diff --git a/test/js/node/test/parallel/test-queue-microtask-uncaught-asynchooks.js b/test/js/node/test/parallel/test-queue-microtask-uncaught-asynchooks.js
new file mode 100644
index 0000000000..35b3d9fa30
--- /dev/null
+++ b/test/js/node/test/parallel/test-queue-microtask-uncaught-asynchooks.js
@@ -0,0 +1,36 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const async_hooks = require('async_hooks');
+
+// Regression test for https://github.com/nodejs/node/issues/30080:
+// An uncaught exception inside a queueMicrotask callback should not lead
+// to multiple after() calls for it.
+
+let µtaskId;
+const events = [];
+
+async_hooks.createHook({
+  init(id, type, triggerId, resource) {
+    if (type === 'Microtask') {
+      µtaskId = id;
+      events.push('init');
+    }
+  },
+  before(id) {
+    if (id === µtaskId) events.push('before');
+  },
+  after(id) {
+    if (id === µtaskId) events.push('after');
+  },
+  destroy(id) {
+    if (id === µtaskId) events.push('destroy');
+  }
+}).enable();
+
+queueMicrotask(() => { throw new Error(); });
+
+process.on('uncaughtException', common.mustCall());
+process.on('exit', () => {
+  assert.deepStrictEqual(events, ['init', 'after', 'before', 'destroy']);
+});
diff --git a/test/js/node/test/parallel/test-quic-internal-endpoint-listen-defaults.js b/test/js/node/test/parallel/test-quic-internal-endpoint-listen-defaults.js
new file mode 100644
index 0000000000..9fb9f9461c
--- /dev/null
+++ b/test/js/node/test/parallel/test-quic-internal-endpoint-listen-defaults.js
@@ -0,0 +1,76 @@
+// Flags: --expose-internals
+'use strict';
+
+const common = require('../common');
+if (!common.hasQuic)
+  common.skip('missing quic');
+
+const { internalBinding } = require('internal/test/binding');
+const {
+  ok,
+  strictEqual,
+  deepStrictEqual,
+} = require('node:assert');
+
+const {
+  SocketAddress: _SocketAddress,
+  AF_INET,
+} = internalBinding('block_list');
+const quic = internalBinding('quic');
+
+quic.setCallbacks({
+  onEndpointClose: common.mustCall((...args) => {
+    deepStrictEqual(args, [0, 0]);
+  }),
+
+  // The following are unused in this test
+  onSessionNew() {},
+  onSessionClose() {},
+  onSessionDatagram() {},
+  onSessionDatagramStatus() {},
+  onSessionHandshake() {},
+  onSessionPathValidation() {},
+  onSessionTicket() {},
+  onSessionVersionNegotiation() {},
+  onStreamCreated() {},
+  onStreamBlocked() {},
+  onStreamClose() {},
+  onStreamReset() {},
+  onStreamHeaders() {},
+  onStreamTrailers() {},
+});
+
+const endpoint = new quic.Endpoint({});
+
+const state = new DataView(endpoint.state);
+ok(!state.getUint8(quic.IDX_STATE_ENDPOINT_LISTENING));
+ok(!state.getUint8(quic.IDX_STATE_ENDPOINT_RECEIVING));
+ok(!state.getUint8(quic.IDX_STATE_ENDPOINT_BOUND));
+strictEqual(endpoint.address(), undefined);
+
+endpoint.listen({});
+
+ok(state.getUint8(quic.IDX_STATE_ENDPOINT_LISTENING));
+ok(state.getUint8(quic.IDX_STATE_ENDPOINT_RECEIVING));
+ok(state.getUint8(quic.IDX_STATE_ENDPOINT_BOUND));
+const address = endpoint.address();
+ok(address instanceof _SocketAddress);
+
+const detail = address.detail({
+  address: undefined,
+  port: undefined,
+  family: undefined,
+  flowlabel: undefined,
+});
+
+strictEqual(detail.address, '127.0.0.1');
+strictEqual(detail.family, AF_INET);
+strictEqual(detail.flowlabel, 0);
+ok(detail.port !== 0);
+
+endpoint.closeGracefully();
+
+ok(!state.getUint8(quic.IDX_STATE_ENDPOINT_LISTENING));
+ok(!state.getUint8(quic.IDX_STATE_ENDPOINT_RECEIVING));
+ok(!state.getUint8(quic.IDX_STATE_ENDPOINT_BOUND));
+strictEqual(endpoint.address(), undefined);
diff --git a/test/js/node/test/parallel/test-quic-internal-endpoint-options.js b/test/js/node/test/parallel/test-quic-internal-endpoint-options.js
new file mode 100644
index 0000000000..672fac18b4
--- /dev/null
+++ b/test/js/node/test/parallel/test-quic-internal-endpoint-options.js
@@ -0,0 +1,215 @@
+// Flags: --expose-internals
+'use strict';
+
+const common = require('../common');
+if (!common.hasQuic)
+  common.skip('missing quic');
+const {
+  throws,
+} = require('node:assert');
+
+const { internalBinding } = require('internal/test/binding');
+const quic = internalBinding('quic');
+
+quic.setCallbacks({
+  onEndpointClose() {},
+  onSessionNew() {},
+  onSessionClose() {},
+  onSessionDatagram() {},
+  onSessionDatagramStatus() {},
+  onSessionHandshake() {},
+  onSessionPathValidation() {},
+  onSessionTicket() {},
+  onSessionVersionNegotiation() {},
+  onStreamCreated() {},
+  onStreamBlocked() {},
+  onStreamClose() {},
+  onStreamReset() {},
+  onStreamHeaders() {},
+  onStreamTrailers() {},
+});
+
+throws(() => new quic.Endpoint(), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  message: 'options must be an object'
+});
+
+throws(() => new quic.Endpoint('a'), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  message: 'options must be an object'
+});
+
+throws(() => new quic.Endpoint(null), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  message: 'options must be an object'
+});
+
+throws(() => new quic.Endpoint(false), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  message: 'options must be an object'
+});
+
+{
+  // Just Works... using all defaults
+  new quic.Endpoint({});
+}
+
+const cases = [
+  {
+    key: 'retryTokenExpiration',
+    valid: [
+      1, 10, 100, 1000, 10000, 10000n,
+    ],
+    invalid: [-1, -1n, 'a', null, false, true, {}, [], () => {}]
+  },
+  {
+    key: 'tokenExpiration',
+    valid: [
+      1, 10, 100, 1000, 10000, 10000n,
+    ],
+    invalid: [-1, -1n, 'a', null, false, true, {}, [], () => {}]
+  },
+  {
+    key: 'maxConnectionsPerHost',
+    valid: [
+      1, 10, 100, 1000, 10000, 10000n,
+    ],
+    invalid: [-1, -1n, 'a', null, false, true, {}, [], () => {}]
+  },
+  {
+    key: 'maxConnectionsTotal',
+    valid: [
+      1, 10, 100, 1000, 10000, 10000n,
+    ],
+    invalid: [-1, -1n, 'a', null, false, true, {}, [], () => {}]
+  },
+  {
+    key: 'maxStatelessResetsPerHost',
+    valid: [
+      1, 10, 100, 1000, 10000, 10000n,
+    ],
+    invalid: [-1, -1n, 'a', null, false, true, {}, [], () => {}]
+  },
+  {
+    key: 'addressLRUSize',
+    valid: [
+      1, 10, 100, 1000, 10000, 10000n,
+    ],
+    invalid: [-1, -1n, 'a', null, false, true, {}, [], () => {}]
+  },
+  {
+    key: 'maxRetries',
+    valid: [
+      1, 10, 100, 1000, 10000, 10000n,
+    ],
+    invalid: [-1, -1n, 'a', null, false, true, {}, [], () => {}]
+  },
+  {
+    key: 'maxPayloadSize',
+    valid: [
+      1, 10, 100, 1000, 10000, 10000n,
+    ],
+    invalid: [-1, -1n, 'a', null, false, true, {}, [], () => {}]
+  },
+  {
+    key: 'unacknowledgedPacketThreshold',
+    valid: [
+      1, 10, 100, 1000, 10000, 10000n,
+    ],
+    invalid: [-1, -1n, 'a', null, false, true, {}, [], () => {}]
+  },
+  {
+    key: 'validateAddress',
+    valid: [true, false, 0, 1, 'a'],
+    invalid: [],
+  },
+  {
+    key: 'disableStatelessReset',
+    valid: [true, false, 0, 1, 'a'],
+    invalid: [],
+  },
+  {
+    key: 'ipv6Only',
+    valid: [true, false, 0, 1, 'a'],
+    invalid: [],
+  },
+  {
+    key: 'cc',
+    valid: [
+      quic.CC_ALGO_RENO,
+      quic.CC_ALGO_CUBIC,
+      quic.CC_ALGO_BBR,
+      quic.CC_ALGO_BBR2,
+      quic.CC_ALGO_RENO_STR,
+      quic.CC_ALGO_CUBIC_STR,
+      quic.CC_ALGO_BBR_STR,
+      quic.CC_ALGO_BBR2_STR,
+    ],
+    invalid: [-1, 4, 1n, 'a', null, false, true, {}, [], () => {}],
+  },
+  {
+    key: 'udpReceiveBufferSize',
+    valid: [0, 1, 2, 3, 4, 1000],
+    invalid: [-1, 'a', null, false, true, {}, [], () => {}],
+  },
+  {
+    key: 'udpSendBufferSize',
+    valid: [0, 1, 2, 3, 4, 1000],
+    invalid: [-1, 'a', null, false, true, {}, [], () => {}],
+  },
+  {
+    key: 'udpTTL',
+    valid: [0, 1, 2, 3, 4, 255],
+    invalid: [-1, 256, 'a', null, false, true, {}, [], () => {}],
+  },
+  {
+    key: 'resetTokenSecret',
+    valid: [
+      new Uint8Array(16),
+      new Uint16Array(8),
+      new Uint32Array(4),
+    ],
+    invalid: [
+      'a', null, false, true, {}, [], () => {},
+      new Uint8Array(15),
+      new Uint8Array(17),
+      new ArrayBuffer(16),
+    ],
+  },
+  {
+    key: 'tokenSecret',
+    valid: [
+      new Uint8Array(16),
+      new Uint16Array(8),
+      new Uint32Array(4),
+    ],
+    invalid: [
+      'a', null, false, true, {}, [], () => {},
+      new Uint8Array(15),
+      new Uint8Array(17),
+      new ArrayBuffer(16),
+    ],
+  },
+  {
+    // Unknown options are ignored entirely for any value type
+    key: 'ignored',
+    valid: ['a', null, false, true, {}, [], () => {}],
+    invalid: [],
+  },
+];
+
+for (const { key, valid, invalid } of cases) {
+  for (const value of valid) {
+    const options = {};
+    options[key] = value;
+    new quic.Endpoint(options);
+  }
+
+  for (const value of invalid) {
+    const options = {};
+    options[key] = value;
+    throws(() => new quic.Endpoint(options), {
+      code: 'ERR_INVALID_ARG_VALUE',
+    });
+  }
+}
diff --git a/test/js/node/test/parallel/test-quic-internal-endpoint-stats-state.js b/test/js/node/test/parallel/test-quic-internal-endpoint-stats-state.js
new file mode 100644
index 0000000000..566dd675d7
--- /dev/null
+++ b/test/js/node/test/parallel/test-quic-internal-endpoint-stats-state.js
@@ -0,0 +1,79 @@
+// Flags: --expose-internals
+'use strict';
+
+const common = require('../common');
+if (!common.hasQuic)
+  common.skip('missing quic');
+const {
+  strictEqual,
+} = require('node:assert');
+
+const { internalBinding } = require('internal/test/binding');
+const quic = internalBinding('quic');
+
+const {
+  IDX_STATS_ENDPOINT_CREATED_AT,
+  IDX_STATS_ENDPOINT_DESTROYED_AT,
+  IDX_STATS_ENDPOINT_BYTES_RECEIVED,
+  IDX_STATS_ENDPOINT_BYTES_SENT,
+  IDX_STATS_ENDPOINT_PACKETS_RECEIVED,
+  IDX_STATS_ENDPOINT_PACKETS_SENT,
+  IDX_STATS_ENDPOINT_SERVER_SESSIONS,
+  IDX_STATS_ENDPOINT_CLIENT_SESSIONS,
+  IDX_STATS_ENDPOINT_SERVER_BUSY_COUNT,
+  IDX_STATS_ENDPOINT_RETRY_COUNT,
+  IDX_STATS_ENDPOINT_VERSION_NEGOTIATION_COUNT,
+  IDX_STATS_ENDPOINT_STATELESS_RESET_COUNT,
+  IDX_STATS_ENDPOINT_IMMEDIATE_CLOSE_COUNT,
+  IDX_STATS_ENDPOINT_COUNT,
+  IDX_STATE_ENDPOINT_BOUND,
+  IDX_STATE_ENDPOINT_BOUND_SIZE,
+  IDX_STATE_ENDPOINT_RECEIVING,
+  IDX_STATE_ENDPOINT_RECEIVING_SIZE,
+  IDX_STATE_ENDPOINT_LISTENING,
+  IDX_STATE_ENDPOINT_LISTENING_SIZE,
+  IDX_STATE_ENDPOINT_CLOSING,
+  IDX_STATE_ENDPOINT_CLOSING_SIZE,
+  IDX_STATE_ENDPOINT_BUSY,
+  IDX_STATE_ENDPOINT_BUSY_SIZE,
+  IDX_STATE_ENDPOINT_PENDING_CALLBACKS,
+  IDX_STATE_ENDPOINT_PENDING_CALLBACKS_SIZE,
+} = quic;
+
+const endpoint = new quic.Endpoint({});
+
+const state = new DataView(endpoint.state);
+strictEqual(IDX_STATE_ENDPOINT_BOUND_SIZE, 1);
+strictEqual(IDX_STATE_ENDPOINT_RECEIVING_SIZE, 1);
+strictEqual(IDX_STATE_ENDPOINT_LISTENING_SIZE, 1);
+strictEqual(IDX_STATE_ENDPOINT_CLOSING_SIZE, 1);
+strictEqual(IDX_STATE_ENDPOINT_BUSY_SIZE, 1);
+strictEqual(IDX_STATE_ENDPOINT_PENDING_CALLBACKS_SIZE, 8);
+
+strictEqual(state.getUint8(IDX_STATE_ENDPOINT_BOUND), 0);
+strictEqual(state.getUint8(IDX_STATE_ENDPOINT_RECEIVING), 0);
+strictEqual(state.getUint8(IDX_STATE_ENDPOINT_LISTENING), 0);
+strictEqual(state.getUint8(IDX_STATE_ENDPOINT_CLOSING), 0);
+strictEqual(state.getUint8(IDX_STATE_ENDPOINT_BUSY), 0);
+strictEqual(state.getBigUint64(IDX_STATE_ENDPOINT_PENDING_CALLBACKS), 0n);
+
+endpoint.markBusy(true);
+strictEqual(state.getUint8(IDX_STATE_ENDPOINT_BUSY), 1);
+endpoint.markBusy(false);
+strictEqual(state.getUint8(IDX_STATE_ENDPOINT_BUSY), 0);
+
+const stats = new BigUint64Array(endpoint.stats);
+strictEqual(stats[IDX_STATS_ENDPOINT_CREATED_AT], 0n);
+strictEqual(stats[IDX_STATS_ENDPOINT_DESTROYED_AT], 0n);
+strictEqual(stats[IDX_STATS_ENDPOINT_BYTES_RECEIVED], 0n);
+strictEqual(stats[IDX_STATS_ENDPOINT_BYTES_SENT], 0n);
+strictEqual(stats[IDX_STATS_ENDPOINT_PACKETS_RECEIVED], 0n);
+strictEqual(stats[IDX_STATS_ENDPOINT_PACKETS_SENT], 0n);
+strictEqual(stats[IDX_STATS_ENDPOINT_SERVER_SESSIONS], 0n);
+strictEqual(stats[IDX_STATS_ENDPOINT_CLIENT_SESSIONS], 0n);
+strictEqual(stats[IDX_STATS_ENDPOINT_SERVER_BUSY_COUNT], 0n);
+strictEqual(stats[IDX_STATS_ENDPOINT_RETRY_COUNT], 0n);
+strictEqual(stats[IDX_STATS_ENDPOINT_VERSION_NEGOTIATION_COUNT], 0n);
+strictEqual(stats[IDX_STATS_ENDPOINT_STATELESS_RESET_COUNT], 0n);
+strictEqual(stats[IDX_STATS_ENDPOINT_IMMEDIATE_CLOSE_COUNT], 0n);
+strictEqual(IDX_STATS_ENDPOINT_COUNT, 13);
diff --git a/test/js/node/test/parallel/test-quic-internal-setcallbacks.js b/test/js/node/test/parallel/test-quic-internal-setcallbacks.js
new file mode 100644
index 0000000000..881e9161ca
--- /dev/null
+++ b/test/js/node/test/parallel/test-quic-internal-setcallbacks.js
@@ -0,0 +1,38 @@
+// Flags: --expose-internals
+'use strict';
+
+const common = require('../common');
+if (!common.hasQuic)
+  common.skip('missing quic');
+const { internalBinding } = require('internal/test/binding');
+const quic = internalBinding('quic');
+
+const { throws } = require('assert');
+
+const callbacks = {
+  onEndpointClose() {},
+  onSessionNew() {},
+  onSessionClose() {},
+  onSessionDatagram() {},
+  onSessionDatagramStatus() {},
+  onSessionHandshake() {},
+  onSessionPathValidation() {},
+  onSessionTicket() {},
+  onSessionVersionNegotiation() {},
+  onStreamCreated() {},
+  onStreamBlocked() {},
+  onStreamClose() {},
+  onStreamReset() {},
+  onStreamHeaders() {},
+  onStreamTrailers() {},
+};
+// Fail if any callback is missing
+for (const fn of Object.keys(callbacks)) {
+  // eslint-disable-next-line no-unused-vars
+  const { [fn]: _, ...rest } = callbacks;
+  throws(() => quic.setCallbacks(rest), {
+    code: 'ERR_MISSING_ARGS',
+  });
+}
+// If all callbacks are present it should work
+quic.setCallbacks(callbacks);
diff --git a/test/js/node/test/parallel/test-readable-from-iterator-closing.js b/test/js/node/test/parallel/test-readable-from-iterator-closing.js
new file mode 100644
index 0000000000..02252ffe56
--- /dev/null
+++ b/test/js/node/test/parallel/test-readable-from-iterator-closing.js
@@ -0,0 +1,197 @@
+'use strict';
+
+const { mustCall, mustNotCall } = require('../common');
+const { Readable } = require('stream');
+const { strictEqual } = require('assert');
+
+async function asyncSupport() {
+  const finallyMustCall = mustCall();
+  const bodyMustCall = mustCall();
+
+  async function* infiniteGenerate() {
+    try {
+      while (true) yield 'a';
+    } finally {
+      finallyMustCall();
+    }
+  }
+
+  const stream = Readable.from(infiniteGenerate());
+
+  for await (const chunk of stream) {
+    bodyMustCall();
+    strictEqual(chunk, 'a');
+    break;
+  }
+}
+
+async function syncSupport() {
+  const finallyMustCall = mustCall();
+  const bodyMustCall = mustCall();
+
+  function* infiniteGenerate() {
+    try {
+      while (true) yield 'a';
+    } finally {
+      finallyMustCall();
+    }
+  }
+
+  const stream = Readable.from(infiniteGenerate());
+
+  for await (const chunk of stream) {
+    bodyMustCall();
+    strictEqual(chunk, 'a');
+    break;
+  }
+}
+
+async function syncPromiseSupport() {
+  const returnMustBeAwaited = mustCall();
+  const bodyMustCall = mustCall();
+
+  function* infiniteGenerate() {
+    try {
+      while (true) yield Promise.resolve('a');
+    } finally {
+      // eslint-disable-next-line no-unsafe-finally
+      return { then(cb) {
+        returnMustBeAwaited();
+        cb();
+      } };
+    }
+  }
+
+  const stream = Readable.from(infiniteGenerate());
+
+  for await (const chunk of stream) {
+    bodyMustCall();
+    strictEqual(chunk, 'a');
+    break;
+  }
+}
+
+async function syncRejectedSupport() {
+  const returnMustBeAwaited = mustCall();
+  const bodyMustNotCall = mustNotCall();
+  const catchMustCall = mustCall();
+  const secondNextMustNotCall = mustNotCall();
+
+  function* generate() {
+    try {
+      yield Promise.reject('a');
+      secondNextMustNotCall();
+    } finally {
+      // eslint-disable-next-line no-unsafe-finally
+      return { then(cb) {
+        returnMustBeAwaited();
+        cb();
+      } };
+    }
+  }
+
+  const stream = Readable.from(generate());
+
+  try {
+    for await (const chunk of stream) {
+      bodyMustNotCall(chunk);
+    }
+  } catch {
+    catchMustCall();
+  }
+}
+
+async function noReturnAfterThrow() {
+  const returnMustNotCall = mustNotCall();
+  const bodyMustNotCall = mustNotCall();
+  const catchMustCall = mustCall();
+  const nextMustCall = mustCall();
+
+  const stream = Readable.from({
+    [Symbol.asyncIterator]() { return this; },
+    async next() {
+      nextMustCall();
+      throw new Error('a');
+    },
+    async return() {
+      returnMustNotCall();
+      return { done: true };
+    },
+  });
+
+  try {
+    for await (const chunk of stream) {
+      bodyMustNotCall(chunk);
+    }
+  } catch {
+    catchMustCall();
+  }
+}
+
+async function closeStreamWhileNextIsPending() {
+  const finallyMustCall = mustCall();
+  const dataMustCall = mustCall();
+
+  let resolveDestroy;
+  const destroyed =
+    new Promise((resolve) => { resolveDestroy = mustCall(resolve); });
+  let resolveYielded;
+  const yielded =
+    new Promise((resolve) => { resolveYielded = mustCall(resolve); });
+
+  async function* infiniteGenerate() {
+    try {
+      while (true) {
+        yield 'a';
+        resolveYielded();
+        await destroyed;
+      }
+    } finally {
+      finallyMustCall();
+    }
+  }
+
+  const stream = Readable.from(infiniteGenerate());
+
+  stream.on('data', (data) => {
+    dataMustCall();
+    strictEqual(data, 'a');
+  });
+
+  yielded.then(() => {
+    stream.destroy();
+    resolveDestroy();
+  });
+}
+
+async function closeAfterNullYielded() {
+  const finallyMustCall = mustCall();
+  const dataMustCall = mustCall(3);
+
+  function* generate() {
+    try {
+      yield 'a';
+      yield 'a';
+      yield 'a';
+    } finally {
+      finallyMustCall();
+    }
+  }
+
+  const stream = Readable.from(generate());
+
+  stream.on('data', (chunk) => {
+    dataMustCall();
+    strictEqual(chunk, 'a');
+  });
+}
+
+Promise.all([
+  asyncSupport(),
+  syncSupport(),
+  syncPromiseSupport(),
+  syncRejectedSupport(),
+  noReturnAfterThrow(),
+  closeStreamWhileNextIsPending(),
+  closeAfterNullYielded(),
+]).then(mustCall());
diff --git a/test/js/node/test/parallel/test-readable-from.js b/test/js/node/test/parallel/test-readable-from.js
new file mode 100644
index 0000000000..b844574dc9
--- /dev/null
+++ b/test/js/node/test/parallel/test-readable-from.js
@@ -0,0 +1,223 @@
+'use strict';
+
+const { mustCall } = require('../common');
+const { once } = require('events');
+const { Readable } = require('stream');
+const { strictEqual, throws } = require('assert');
+const common = require('../common');
+
+{
+  throws(() => {
+    Readable.from(null);
+  }, /ERR_INVALID_ARG_TYPE/);
+}
+
+async function toReadableBasicSupport() {
+  async function* generate() {
+    yield 'a';
+    yield 'b';
+    yield 'c';
+  }
+
+  const stream = Readable.from(generate());
+
+  const expected = ['a', 'b', 'c'];
+
+  for await (const chunk of stream) {
+    strictEqual(chunk, expected.shift());
+  }
+}
+
+async function toReadableSyncIterator() {
+  function* generate() {
+    yield 'a';
+    yield 'b';
+    yield 'c';
+  }
+
+  const stream = Readable.from(generate());
+
+  const expected = ['a', 'b', 'c'];
+
+  for await (const chunk of stream) {
+    strictEqual(chunk, expected.shift());
+  }
+}
+
+async function toReadablePromises() {
+  const promises = [
+    Promise.resolve('a'),
+    Promise.resolve('b'),
+    Promise.resolve('c'),
+  ];
+
+  const stream = Readable.from(promises);
+
+  const expected = ['a', 'b', 'c'];
+
+  for await (const chunk of stream) {
+    strictEqual(chunk, expected.shift());
+  }
+}
+
+async function toReadableString() {
+  const stream = Readable.from('abc');
+
+  const expected = ['abc'];
+
+  for await (const chunk of stream) {
+    strictEqual(chunk, expected.shift());
+  }
+}
+
+async function toReadableBuffer() {
+  const stream = Readable.from(Buffer.from('abc'));
+
+  const expected = ['abc'];
+
+  for await (const chunk of stream) {
+    strictEqual(chunk.toString(), expected.shift());
+  }
+}
+
+async function toReadableOnData() {
+  async function* generate() {
+    yield 'a';
+    yield 'b';
+    yield 'c';
+  }
+
+  const stream = Readable.from(generate());
+
+  let iterations = 0;
+  const expected = ['a', 'b', 'c'];
+
+  stream.on('data', (chunk) => {
+    iterations++;
+    strictEqual(chunk, expected.shift());
+  });
+
+  await once(stream, 'end');
+
+  strictEqual(iterations, 3);
+}
+
+async function toReadableOnDataNonObject() {
+  async function* generate() {
+    yield 'a';
+    yield 'b';
+    yield 'c';
+  }
+
+  const stream = Readable.from(generate(), { objectMode: false });
+
+  let iterations = 0;
+  const expected = ['a', 'b', 'c'];
+
+  stream.on('data', (chunk) => {
+    iterations++;
+    strictEqual(chunk instanceof Buffer, true);
+    strictEqual(chunk.toString(), expected.shift());
+  });
+
+  await once(stream, 'end');
+
+  strictEqual(iterations, 3);
+}
+
+async function destroysTheStreamWhenThrowing() {
+  async function* generate() { // eslint-disable-line require-yield
+    throw new Error('kaboom');
+  }
+
+  const stream = Readable.from(generate());
+
+  stream.read();
+
+  const [err] = await once(stream, 'error');
+  strictEqual(err.message, 'kaboom');
+  strictEqual(stream.destroyed, true);
+
+}
+
+async function asTransformStream() {
+  async function* generate(stream) {
+    for await (const chunk of stream) {
+      yield chunk.toUpperCase();
+    }
+  }
+
+  const source = new Readable({
+    objectMode: true,
+    read() {
+      this.push('a');
+      this.push('b');
+      this.push('c');
+      this.push(null);
+    }
+  });
+
+  const stream = Readable.from(generate(source));
+
+  const expected = ['A', 'B', 'C'];
+
+  for await (const chunk of stream) {
+    strictEqual(chunk, expected.shift());
+  }
+}
+
+async function endWithError() {
+  async function* generate() {
+    yield 1;
+    yield 2;
+    yield Promise.reject('Boum');
+  }
+
+  const stream = Readable.from(generate());
+
+  const expected = [1, 2];
+
+  try {
+    for await (const chunk of stream) {
+      strictEqual(chunk, expected.shift());
+    }
+    throw new Error();
+  } catch (err) {
+    strictEqual(expected.length, 0);
+    strictEqual(err, 'Boum');
+  }
+}
+
+async function destroyingStreamWithErrorThrowsInGenerator() {
+  const validateError = common.mustCall((e) => {
+    strictEqual(e, 'Boum');
+  });
+  async function* generate() {
+    try {
+      yield 1;
+      yield 2;
+      yield 3;
+      throw new Error();
+    } catch (e) {
+      validateError(e);
+    }
+  }
+  const stream = Readable.from(generate());
+  stream.read();
+  stream.once('error', common.mustCall());
+  stream.destroy('Boum');
+}
+
+Promise.all([
+  toReadableBasicSupport(),
+  toReadableSyncIterator(),
+  toReadablePromises(),
+  toReadableString(),
+  toReadableBuffer(),
+  toReadableOnData(),
+  toReadableOnDataNonObject(),
+  destroysTheStreamWhenThrowing(),
+  asTransformStream(),
+  endWithError(),
+  destroyingStreamWithErrorThrowsInGenerator(),
+]).then(mustCall());
diff --git a/test/js/node/test/parallel/test-readable-large-hwm.js b/test/js/node/test/parallel/test-readable-large-hwm.js
new file mode 100644
index 0000000000..d5bf25bc0e
--- /dev/null
+++ b/test/js/node/test/parallel/test-readable-large-hwm.js
@@ -0,0 +1,27 @@
+'use strict';
+const common = require('../common');
+const { Readable } = require('stream');
+
+// Make sure that readable completes
+// even when reading larger buffer.
+const bufferSize = 10 * 1024 * 1024;
+let n = 0;
+const r = new Readable({
+  read() {
+    // Try to fill readable buffer piece by piece.
+    r.push(Buffer.alloc(bufferSize / 10));
+
+    if (n++ > 10) {
+      r.push(null);
+    }
+  }
+});
+
+r.on('readable', () => {
+  while (true) {
+    const ret = r.read(bufferSize);
+    if (ret === null)
+      break;
+  }
+});
+r.on('end', common.mustCall());
diff --git a/test/js/node/test/parallel/test-readable-single-end.js b/test/js/node/test/parallel/test-readable-single-end.js
new file mode 100644
index 0000000000..0969d49aa4
--- /dev/null
+++ b/test/js/node/test/parallel/test-readable-single-end.js
@@ -0,0 +1,16 @@
+'use strict';
+
+const common = require('../common');
+const { Readable } = require('stream');
+
+// This test ensures that there will not be an additional empty 'readable'
+// event when stream has ended (only 1 event signalling about end)
+
+const r = new Readable({
+  read: () => {},
+});
+
+r.push(null);
+
+r.on('readable', common.mustCall());
+r.on('end', common.mustCall());
diff --git a/test/js/node/test/parallel/test-readline-async-iterators-destroy.js b/test/js/node/test/parallel/test-readline-async-iterators-destroy.js
new file mode 100644
index 0000000000..0a3fb01890
--- /dev/null
+++ b/test/js/node/test/parallel/test-readline-async-iterators-destroy.js
@@ -0,0 +1,89 @@
+'use strict';
+
+const common = require('../common');
+const fs = require('fs');
+const { once } = require('events');
+const readline = require('readline');
+const assert = require('assert');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+const filename = tmpdir.resolve('test.txt');
+
+const testContents = [
+  '',
+  '\n',
+  'line 1',
+  'line 1\nline 2 南越国是前203年至前111年存在于岭南地区的一个国家\nline 3\ntrailing',
+  'line 1\nline 2\nline 3 ends with newline\n',
+];
+
+async function testSimpleDestroy() {
+  for (const fileContent of testContents) {
+    fs.writeFileSync(filename, fileContent);
+
+    const readable = fs.createReadStream(filename);
+    const rli = readline.createInterface({
+      input: readable,
+      crlfDelay: Infinity
+    });
+
+    const iteratedLines = [];
+    for await (const k of rli) {
+      iteratedLines.push(k);
+      break;
+    }
+
+    const expectedLines = fileContent.split('\n');
+    if (expectedLines[expectedLines.length - 1] === '') {
+      expectedLines.pop();
+    }
+    expectedLines.splice(1);
+
+    assert.deepStrictEqual(iteratedLines, expectedLines);
+
+    rli.close();
+    readable.destroy();
+
+    await once(readable, 'close');
+  }
+}
+
+async function testMutualDestroy() {
+  for (const fileContent of testContents) {
+    fs.writeFileSync(filename, fileContent);
+
+    const readable = fs.createReadStream(filename);
+    const rli = readline.createInterface({
+      input: readable,
+      crlfDelay: Infinity
+    });
+
+    const expectedLines = fileContent.split('\n');
+    if (expectedLines[expectedLines.length - 1] === '') {
+      expectedLines.pop();
+    }
+    expectedLines.splice(2);
+
+    const iteratedLines = [];
+    for await (const k of rli) {
+      iteratedLines.push(k);
+      for await (const l of rli) {
+        iteratedLines.push(l);
+        break;
+      }
+      assert.deepStrictEqual(iteratedLines, expectedLines);
+      break;
+    }
+
+    assert.deepStrictEqual(iteratedLines, expectedLines);
+
+    rli.close();
+    readable.destroy();
+
+    await once(readable, 'close');
+  }
+}
+
+testSimpleDestroy().then(testMutualDestroy).then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-readline-async-iterators.js b/test/js/node/test/parallel/test-readline-async-iterators.js
new file mode 100644
index 0000000000..32fa32a128
--- /dev/null
+++ b/test/js/node/test/parallel/test-readline-async-iterators.js
@@ -0,0 +1,120 @@
+'use strict';
+
+const common = require('../common');
+const fs = require('fs');
+const readline = require('readline');
+const { Readable } = require('stream');
+const assert = require('assert');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+const filename = tmpdir.resolve('test.txt');
+
+const testContents = [
+  '',
+  '\n',
+  'line 1',
+  'line 1\nline 2 南越国是前203年至前111年存在于岭南地区的一个国家\nline 3\ntrailing',
+  'line 1\nline 2\nline 3 ends with newline\n',
+];
+
+async function testSimple() {
+  for (const fileContent of testContents) {
+    fs.writeFileSync(filename, fileContent);
+
+    const readable = fs.createReadStream(filename);
+    const rli = readline.createInterface({
+      input: readable,
+      crlfDelay: Infinity
+    });
+
+    const iteratedLines = [];
+    for await (const k of rli) {
+      iteratedLines.push(k);
+    }
+
+    const expectedLines = fileContent.split('\n');
+    if (expectedLines[expectedLines.length - 1] === '') {
+      expectedLines.pop();
+    }
+    assert.deepStrictEqual(iteratedLines, expectedLines);
+    assert.strictEqual(iteratedLines.join(''), fileContent.replace(/\n/g, ''));
+  }
+}
+
+async function testMutual() {
+  for (const fileContent of testContents) {
+    fs.writeFileSync(filename, fileContent);
+
+    const readable = fs.createReadStream(filename);
+    const rli = readline.createInterface({
+      input: readable,
+      crlfDelay: Infinity
+    });
+
+    const expectedLines = fileContent.split('\n');
+    if (expectedLines[expectedLines.length - 1] === '') {
+      expectedLines.pop();
+    }
+    const iteratedLines = [];
+    let iterated = false;
+    for await (const k of rli) {
+      // This outer loop should only iterate once.
+      assert.strictEqual(iterated, false);
+      iterated = true;
+      iteratedLines.push(k);
+      for await (const l of rli) {
+        iteratedLines.push(l);
+      }
+      assert.deepStrictEqual(iteratedLines, expectedLines);
+    }
+    assert.deepStrictEqual(iteratedLines, expectedLines);
+  }
+}
+
+async function testSlowStreamForLeaks() {
+  const message = 'a\nb\nc\n';
+  const DELAY = 1;
+  const REPETITIONS = 100;
+  const warningCallback = common.mustNotCall();
+  process.on('warning', warningCallback);
+
+  function getStream() {
+    const readable = Readable({
+      objectMode: true,
+    });
+    readable._read = () => {};
+    let i = REPETITIONS;
+    function schedule() {
+      setTimeout(() => {
+        i--;
+        if (i < 0) {
+          readable.push(null);
+        } else {
+          readable.push(message);
+          schedule();
+        }
+      }, DELAY);
+    }
+    schedule();
+    return readable;
+  }
+  const iterable = readline.createInterface({
+    input: getStream(),
+  });
+
+  let lines = 0;
+  // eslint-disable-next-line no-unused-vars
+  for await (const _ of iterable) {
+    lines++;
+  }
+
+  assert.strictEqual(lines, 3 * REPETITIONS);
+  process.off('warning', warningCallback);
+}
+
+testSimple()
+  .then(testMutual)
+  .then(testSlowStreamForLeaks)
+  .then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-readline-emit-keypress-events.js b/test/js/node/test/parallel/test-readline-emit-keypress-events.js
new file mode 100644
index 0000000000..a9ffd3276c
--- /dev/null
+++ b/test/js/node/test/parallel/test-readline-emit-keypress-events.js
@@ -0,0 +1,72 @@
+'use strict';
+// emitKeypressEvents is thoroughly tested in test-readline-keys.js.
+// However, that test calls it implicitly. This is just a quick sanity check
+// to verify that it works when called explicitly.
+
+require('../common');
+const assert = require('assert');
+const readline = require('readline');
+const PassThrough = require('stream').PassThrough;
+
+const expectedSequence = ['f', 'o', 'o'];
+const expectedKeys = [
+  { sequence: 'f', name: 'f', ctrl: false, meta: false, shift: false },
+  { sequence: 'o', name: 'o', ctrl: false, meta: false, shift: false },
+  { sequence: 'o', name: 'o', ctrl: false, meta: false, shift: false },
+];
+
+{
+  const stream = new PassThrough();
+  const sequence = [];
+  const keys = [];
+
+  readline.emitKeypressEvents(stream);
+  stream.on('keypress', (s, k) => {
+    sequence.push(s);
+    keys.push(k);
+  });
+  stream.write('foo');
+
+  assert.deepStrictEqual(sequence, expectedSequence);
+  assert.deepStrictEqual(keys, expectedKeys);
+}
+
+{
+  const stream = new PassThrough();
+  const sequence = [];
+  const keys = [];
+
+  stream.on('keypress', (s, k) => {
+    sequence.push(s);
+    keys.push(k);
+  });
+  readline.emitKeypressEvents(stream);
+  stream.write('foo');
+
+  assert.deepStrictEqual(sequence, expectedSequence);
+  assert.deepStrictEqual(keys, expectedKeys);
+}
+
+{
+  const stream = new PassThrough();
+  const sequence = [];
+  const keys = [];
+  const keypressListener = (s, k) => {
+    sequence.push(s);
+    keys.push(k);
+  };
+
+  stream.on('keypress', keypressListener);
+  readline.emitKeypressEvents(stream);
+  stream.removeListener('keypress', keypressListener);
+  stream.write('foo');
+
+  assert.deepStrictEqual(sequence, []);
+  assert.deepStrictEqual(keys, []);
+
+  stream.on('keypress', keypressListener);
+  stream.write('foo');
+
+  assert.deepStrictEqual(sequence, expectedSequence);
+  assert.deepStrictEqual(keys, expectedKeys);
+}
diff --git a/test/js/node/test/parallel/test-readline-interface-escapecodetimeout.js b/test/js/node/test/parallel/test-readline-interface-escapecodetimeout.js
new file mode 100644
index 0000000000..a0c0e77cb8
--- /dev/null
+++ b/test/js/node/test/parallel/test-readline-interface-escapecodetimeout.js
@@ -0,0 +1,46 @@
+'use strict';
+require('../common');
+
+// This test ensures that the escapeCodeTimeout option set correctly
+
+const assert = require('assert');
+const readline = require('readline');
+const EventEmitter = require('events').EventEmitter;
+
+class FakeInput extends EventEmitter {
+  resume() {}
+  pause() {}
+  write() {}
+  end() {}
+}
+
+{
+  const fi = new FakeInput();
+  const rli = new readline.Interface({
+    input: fi,
+    output: fi,
+    escapeCodeTimeout: 50
+  });
+  assert.strictEqual(rli.escapeCodeTimeout, 50);
+  rli.close();
+}
+
+[
+  null,
+  {},
+  NaN,
+  '50',
+].forEach((invalidInput) => {
+  assert.throws(() => {
+    const fi = new FakeInput();
+    const rli = new readline.Interface({
+      input: fi,
+      output: fi,
+      escapeCodeTimeout: invalidInput
+    });
+    rli.close();
+  }, {
+    name: 'TypeError',
+    code: 'ERR_INVALID_ARG_VALUE'
+  });
+});
diff --git a/test/js/node/test/parallel/test-readline-position.js b/test/js/node/test/parallel/test-readline-position.js
new file mode 100644
index 0000000000..3603a42ece
--- /dev/null
+++ b/test/js/node/test/parallel/test-readline-position.js
@@ -0,0 +1,36 @@
+// Flags: --expose-internals
+'use strict';
+const common = require('../common');
+const { PassThrough } = require('stream');
+const readline = require('readline');
+const assert = require('assert');
+
+const ctrlU = { ctrl: true, name: 'u' };
+
+common.skipIfDumbTerminal();
+
+{
+  const input = new PassThrough();
+  const rl = readline.createInterface({
+    terminal: true,
+    input: input,
+    prompt: ''
+  });
+
+  const tests = [
+    [1, 'a'],
+    [2, 'ab'],
+    [2, '丁'],
+    [0, '\u0301'],   // COMBINING ACUTE ACCENT
+    [1, 'a\u0301'],  // á
+    [0, '\u20DD'],   // COMBINING ENCLOSING CIRCLE
+    [2, 'a\u20DDb'], // a⃝b
+    [0, '\u200E'],   // LEFT-TO-RIGHT MARK
+  ];
+
+  for (const [cursor, string] of tests) {
+    rl.write(string);
+    assert.strictEqual(rl.getCursorPos().cols, cursor);
+    rl.write(null, ctrlU);
+  }
+}
diff --git a/test/js/node/test/parallel/test-readline-reopen.js b/test/js/node/test/parallel/test-readline-reopen.js
new file mode 100644
index 0000000000..fd305fee3e
--- /dev/null
+++ b/test/js/node/test/parallel/test-readline-reopen.js
@@ -0,0 +1,44 @@
+'use strict';
+
+// Regression test for https://github.com/nodejs/node/issues/13557
+// Tests that multiple subsequent readline instances can re-use an input stream.
+
+const common = require('../common');
+const assert = require('assert');
+const readline = require('readline');
+const { PassThrough } = require('stream');
+
+const input = new PassThrough();
+const output = new PassThrough();
+
+const rl1 = readline.createInterface({
+  input,
+  output,
+  terminal: true
+});
+
+rl1.on('line', common.mustCall(rl1OnLine));
+
+// Write a line plus the first byte of a UTF-8 multibyte character to make sure
+// that it doesn’t get lost when closing the readline instance.
+input.write(Buffer.concat([
+  Buffer.from('foo\n'),
+  Buffer.from([ 0xe2 ]),  // Exactly one third of a ☃ snowman.
+]));
+
+function rl1OnLine(line) {
+  assert.strictEqual(line, 'foo');
+  rl1.close();
+  const rl2 = readline.createInterface({
+    input,
+    output,
+    terminal: true
+  });
+
+  rl2.on('line', common.mustCall((line) => {
+    assert.strictEqual(line, '☃bar');
+    rl2.close();
+  }));
+  input.write(Buffer.from([0x98, 0x83])); // The rest of the ☃ snowman.
+  input.write('bar\n');
+}
diff --git a/test/js/node/test/parallel/test-readline-undefined-columns.js b/test/js/node/test/parallel/test-readline-undefined-columns.js
new file mode 100644
index 0000000000..25bafe957f
--- /dev/null
+++ b/test/js/node/test/parallel/test-readline-undefined-columns.js
@@ -0,0 +1,46 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const PassThrough = require('stream').PassThrough;
+const readline = require('readline');
+
+common.skipIfDumbTerminal();
+
+// Checks that tab completion still works
+// when output column size is undefined
+
+const iStream = new PassThrough();
+const oStream = new PassThrough();
+
+readline.createInterface({
+  terminal: true,
+  input: iStream,
+  output: oStream,
+  completer: function(line, cb) {
+    cb(null, [['process.stdout', 'process.stdin', 'process.stderr'], line]);
+  }
+});
+
+let output = '';
+
+oStream.on('data', function(data) {
+  output += data;
+});
+
+oStream.on('end', common.mustCall(() => {
+  const expect = 'process.stdout\r\n' +
+                 'process.stdin\r\n' +
+                 'process.stderr';
+  assert.match(output, new RegExp(expect));
+}));
+
+iStream.write('process.s\t');
+
+// Completion works.
+assert.match(output, /process\.std\b/);
+// Completion doesn’t show all results yet.
+assert.doesNotMatch(output, /stdout/);
+
+iStream.write('\t');
+oStream.end();
diff --git a/test/js/node/test/parallel/test-readline.js b/test/js/node/test/parallel/test-readline.js
new file mode 100644
index 0000000000..77799fc14c
--- /dev/null
+++ b/test/js/node/test/parallel/test-readline.js
@@ -0,0 +1,151 @@
+'use strict';
+const common = require('../common');
+const { PassThrough } = require('stream');
+const readline = require('readline');
+const assert = require('assert');
+
+common.skipIfDumbTerminal();
+
+{
+  const input = new PassThrough();
+  const rl = readline.createInterface({
+    terminal: true,
+    input: input
+  });
+
+  rl.on('line', common.mustCall((data) => {
+    assert.strictEqual(data, 'abc');
+  }));
+
+  input.end('abc');
+}
+
+{
+  const input = new PassThrough();
+  const rl = readline.createInterface({
+    terminal: true,
+    input: input
+  });
+
+  rl.on('line', common.mustNotCall('must not be called before newline'));
+
+  input.write('abc');
+}
+
+{
+  const input = new PassThrough();
+  const rl = readline.createInterface({
+    terminal: true,
+    input: input
+  });
+
+  rl.on('line', common.mustCall((data) => {
+    assert.strictEqual(data, 'abc');
+  }));
+
+  input.write('abc\n');
+}
+
+{
+  const input = new PassThrough();
+  const rl = readline.createInterface({
+    terminal: true,
+    input: input
+  });
+
+  rl.write('foo');
+  assert.strictEqual(rl.cursor, 3);
+
+  const key = {
+    xterm: {
+      home: ['\x1b[H', { ctrl: true, name: 'a' }],
+      end: ['\x1b[F', { ctrl: true, name: 'e' }],
+    },
+    gnome: {
+      home: ['\x1bOH', { ctrl: true, name: 'a' }],
+      end: ['\x1bOF', { ctrl: true, name: 'e' }]
+    },
+    rxvt: {
+      home: ['\x1b[7', { ctrl: true, name: 'a' }],
+      end: ['\x1b[8', { ctrl: true, name: 'e' }]
+    },
+    putty: {
+      home: ['\x1b[1~', { ctrl: true, name: 'a' }],
+      end: ['\x1b[>~', { ctrl: true, name: 'e' }]
+    }
+  };
+
+  [key.xterm, key.gnome, key.rxvt, key.putty].forEach(function(key) {
+    rl.write.apply(rl, key.home);
+    assert.strictEqual(rl.cursor, 0);
+    rl.write.apply(rl, key.end);
+    assert.strictEqual(rl.cursor, 3);
+  });
+
+}
+
+{
+  const input = new PassThrough();
+  const rl = readline.createInterface({
+    terminal: true,
+    input: input
+  });
+
+  const key = {
+    xterm: {
+      home: ['\x1b[H', { ctrl: true, name: 'a' }],
+      metab: ['\x1bb', { meta: true, name: 'b' }],
+      metaf: ['\x1bf', { meta: true, name: 'f' }],
+    }
+  };
+
+  rl.write('foo bar.hop/zoo');
+  rl.write.apply(rl, key.xterm.home);
+  [
+    { cursor: 4, key: key.xterm.metaf },
+    { cursor: 7, key: key.xterm.metaf },
+    { cursor: 8, key: key.xterm.metaf },
+    { cursor: 11, key: key.xterm.metaf },
+    { cursor: 12, key: key.xterm.metaf },
+    { cursor: 15, key: key.xterm.metaf },
+    { cursor: 12, key: key.xterm.metab },
+    { cursor: 11, key: key.xterm.metab },
+    { cursor: 8, key: key.xterm.metab },
+    { cursor: 7, key: key.xterm.metab },
+    { cursor: 4, key: key.xterm.metab },
+    { cursor: 0, key: key.xterm.metab },
+  ].forEach(function(action) {
+    rl.write.apply(rl, action.key);
+    assert.strictEqual(rl.cursor, action.cursor);
+  });
+}
+
+{
+  const input = new PassThrough();
+  const rl = readline.createInterface({
+    terminal: true,
+    input: input
+  });
+
+  const key = {
+    xterm: {
+      home: ['\x1b[H', { ctrl: true, name: 'a' }],
+      metad: ['\x1bd', { meta: true, name: 'd' }]
+    }
+  };
+
+  rl.write('foo bar.hop/zoo');
+  rl.write.apply(rl, key.xterm.home);
+  [
+    'bar.hop/zoo',
+    '.hop/zoo',
+    'hop/zoo',
+    '/zoo',
+    'zoo',
+    '',
+  ].forEach(function(expectedLine) {
+    rl.write.apply(rl, key.xterm.metad);
+    assert.strictEqual(rl.cursor, 0);
+    assert.strictEqual(rl.line, expectedLine);
+  });
+}
diff --git a/test/js/node/test/parallel/test-ref-unref-return.js b/test/js/node/test/parallel/test-ref-unref-return.js
new file mode 100644
index 0000000000..aec2fff5ce
--- /dev/null
+++ b/test/js/node/test/parallel/test-ref-unref-return.js
@@ -0,0 +1,12 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const net = require('net');
+const dgram = require('dgram');
+
+assert.ok((new net.Server()).ref() instanceof net.Server);
+assert.ok((new net.Server()).unref() instanceof net.Server);
+assert.ok((new net.Socket()).ref() instanceof net.Socket);
+assert.ok((new net.Socket()).unref() instanceof net.Socket);
+assert.ok((new dgram.Socket('udp4')).ref() instanceof dgram.Socket);
+assert.ok((new dgram.Socket('udp6')).unref() instanceof dgram.Socket);
diff --git a/test/js/node/test/parallel/test-regression-object-prototype.js b/test/js/node/test/parallel/test-regression-object-prototype.js
new file mode 100644
index 0000000000..2ea1ba858a
--- /dev/null
+++ b/test/js/node/test/parallel/test-regression-object-prototype.js
@@ -0,0 +1,28 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+/* eslint-disable node-core/require-common-first, node-core/required-modules */
+'use strict';
+
+Object.prototype.xadsadsdasasdxx = function() {
+};
+
+console.log('puts after');
diff --git a/test/js/node/test/parallel/test-repl-clear-immediate-crash.js b/test/js/node/test/parallel/test-repl-clear-immediate-crash.js
new file mode 100644
index 0000000000..ce8aaf48e7
--- /dev/null
+++ b/test/js/node/test/parallel/test-repl-clear-immediate-crash.js
@@ -0,0 +1,12 @@
+'use strict';
+const common = require('../common');
+const child_process = require('child_process');
+const assert = require('assert');
+
+// Regression test for https://github.com/nodejs/node/issues/37806:
+const proc = child_process.spawn(process.execPath, ['-i']);
+proc.on('error', common.mustNotCall());
+proc.on('exit', common.mustCall((code) => {
+  assert.strictEqual(code, 0);
+}));
+proc.stdin.write('clearImmediate({});\n.exit\n');
diff --git a/test/js/node/test/parallel/test-repl-dynamic-import.js b/test/js/node/test/parallel/test-repl-dynamic-import.js
new file mode 100644
index 0000000000..a043e31bf5
--- /dev/null
+++ b/test/js/node/test/parallel/test-repl-dynamic-import.js
@@ -0,0 +1,20 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const child_process = require('child_process');
+const child = child_process.spawn(process.execPath, [
+  '--interactive',
+  '--expose-gc',
+], {
+  stdio: 'pipe'
+});
+child.stdin.write('\nimport("fs");\n_.then(gc);\n');
+// Wait for concurrent GC to finish
+setTimeout(() => {
+  child.stdin.write('\nimport("fs");\n');
+  child.stdin.write('\nprocess.exit(0);\n');
+}, common.platformTimeout(50));
+child.on('exit', (code, signal) => {
+  assert.strictEqual(code, 0);
+  assert.strictEqual(signal, null);
+});
diff --git a/test/js/node/test/parallel/test-repl-preview-without-inspector.js b/test/js/node/test/parallel/test-repl-preview-without-inspector.js
new file mode 100644
index 0000000000..8905d21483
--- /dev/null
+++ b/test/js/node/test/parallel/test-repl-preview-without-inspector.js
@@ -0,0 +1,161 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { REPLServer } = require('repl');
+const { Stream } = require('stream');
+
+if (process.features.inspector)
+  common.skip('test is for node compiled with --without-inspector only');
+
+// Ignore terminal settings. This is so the test can be run intact if TERM=dumb.
+process.env.TERM = '';
+const PROMPT = 'repl > ';
+
+class REPLStream extends Stream {
+  readable = true;
+  writable = true;
+
+  constructor() {
+    super();
+    this.lines = [''];
+  }
+  run(data) {
+    for (const entry of data) {
+      this.emit('data', entry);
+    }
+    this.emit('data', '\n');
+  }
+  write(chunk) {
+    const chunkLines = chunk.toString('utf8').split('\n');
+    this.lines[this.lines.length - 1] += chunkLines[0];
+    if (chunkLines.length > 1) {
+      this.lines.push(...chunkLines.slice(1));
+    }
+    this.emit('line');
+    return true;
+  }
+  wait() {
+    this.lines = [''];
+    return new Promise((resolve, reject) => {
+      const onError = (err) => {
+        this.removeListener('line', onLine);
+        reject(err);
+      };
+      const onLine = () => {
+        if (this.lines[this.lines.length - 1].includes(PROMPT)) {
+          this.removeListener('error', onError);
+          this.removeListener('line', onLine);
+          resolve(this.lines);
+        }
+      };
+      this.once('error', onError);
+      this.on('line', onLine);
+    });
+  }
+  pause() { }
+  resume() { }
+}
+
+function runAndWait(cmds, repl) {
+  const promise = repl.inputStream.wait();
+  for (const cmd of cmds) {
+    repl.inputStream.run(cmd);
+  }
+  return promise;
+}
+
+const repl = REPLServer({
+  prompt: PROMPT,
+  stream: new REPLStream(),
+  ignoreUndefined: true,
+  useColors: true,
+  terminal: true,
+});
+
+repl.inputStream.run([
+  'function foo(x) { return x; }',
+  'function koo() { console.log("abc"); }',
+  'a = undefined;',
+  'const r = 5;',
+]);
+
+const testCases = [{
+  input: 'foo',
+  preview: [
+    'foo\r',
+    '\x1B[36m[Function: foo]\x1B[39m',
+  ]
+}, {
+  input: 'r',
+  preview: [
+    'r\r',
+    '\x1B[33m5\x1B[39m',
+  ]
+}, {
+  input: 'koo',
+  preview: [
+    'koo\r',
+    '\x1B[36m[Function: koo]\x1B[39m',
+  ]
+}, {
+  input: 'a',
+  preview: ['a\r'] // No "undefined" preview.
+}, {
+  input: " { b: 1 }['b'] === 1",
+  preview: [
+    " { b: 1 }['b'] === 1\r",
+    '\x1B[33mtrue\x1B[39m',
+  ]
+}, {
+  input: "{ b: 1 }['b'] === 1;",
+  preview: [
+    "{ b: 1 }['b'] === 1;\r",
+    '\x1B[33mfalse\x1B[39m',
+  ]
+}, {
+  input: '{ a: true }',
+  preview: [
+    '{ a: true }\r',
+    '{ a: \x1B[33mtrue\x1B[39m }',
+  ]
+}, {
+  input: '{ a: true };',
+  preview: [
+    '{ a: true };\r',
+    '\x1B[33mtrue\x1B[39m',
+  ]
+}, {
+  input: ' \t { a: true};',
+  preview: [
+    '  { a: true};\r',
+    '\x1B[33mtrue\x1B[39m',
+  ]
+}, {
+  input: '1n + 2n',
+  preview: [
+    '1n + 2n\r',
+    '\x1B[33m3n\x1B[39m',
+  ]
+}, {
+  input: '{};1',
+  preview: [
+    '{};1\r',
+    '\x1B[33m1\x1B[39m',
+  ],
+}];
+
+async function runTest() {
+  for (const { input, preview } of testCases) {
+    const toBeRun = input.split('\n');
+    let lines = await runAndWait(toBeRun, repl);
+    // Remove error messages. That allows the code to run in different
+    // engines.
+    // eslint-disable-next-line no-control-regex
+    lines = lines.map((line) => line.replace(/Error: .+?\x1B/, ''));
+    assert.strictEqual(lines.pop(), '\x1B[1G\x1B[0Jrepl > \x1B[8G');
+    assert.deepStrictEqual(lines, preview);
+  }
+}
+
+runTest().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-repl-syntax-error-handling.js b/test/js/node/test/parallel/test-repl-syntax-error-handling.js
new file mode 100644
index 0000000000..91a8614d1d
--- /dev/null
+++ b/test/js/node/test/parallel/test-repl-syntax-error-handling.js
@@ -0,0 +1,71 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+
+switch (process.argv[2]) {
+  case 'child':
+    return child();
+  case undefined:
+    return parent();
+  default:
+    throw new Error('invalid');
+}
+
+function parent() {
+  const spawn = require('child_process').spawn;
+  const child = spawn(process.execPath, [__filename, 'child']);
+
+  child.stderr.setEncoding('utf8');
+  child.stderr.on('data', function(c) {
+    console.error(`${c}`);
+    throw new Error('should not get stderr data');
+  });
+
+  child.stdout.setEncoding('utf8');
+  let out = '';
+  child.stdout.on('data', function(c) {
+    out += c;
+  });
+  child.stdout.on('end', function() {
+    assert.strictEqual(out, '10\n');
+    console.log('ok - got expected output');
+  });
+
+  child.on('exit', function(c) {
+    assert(!c);
+    console.log('ok - exit success');
+  });
+}
+
+function child() {
+  const vm = require('vm');
+  let caught;
+  try {
+    vm.runInThisContext('haf!@##&$!@$*!@', { displayErrors: false });
+  } catch {
+    caught = true;
+  }
+  assert(caught);
+  vm.runInThisContext('console.log(10)', { displayErrors: false });
+}
diff --git a/test/js/node/test/parallel/test-require-cache.js b/test/js/node/test/parallel/test-require-cache.js
new file mode 100644
index 0000000000..7b62ab5764
--- /dev/null
+++ b/test/js/node/test/parallel/test-require-cache.js
@@ -0,0 +1,44 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+
+{
+  const relativePath = '../fixtures/semicolon';
+  const absolutePath = require.resolve(relativePath);
+  const fakeModule = {};
+
+  require.cache[absolutePath] = { exports: fakeModule };
+
+  assert.strictEqual(require(relativePath), fakeModule);
+}
+
+
+{
+  const relativePath = 'fs';
+  const fakeModule = {};
+
+  require.cache[relativePath] = { exports: fakeModule };
+
+  assert.strictEqual(require(relativePath), fakeModule);
+}
diff --git a/test/js/node/test/parallel/test-require-dot.js b/test/js/node/test/parallel/test-require-dot.js
new file mode 100644
index 0000000000..7145e688d4
--- /dev/null
+++ b/test/js/node/test/parallel/test-require-dot.js
@@ -0,0 +1,23 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const m = require('module');
+const fixtures = require('../common/fixtures');
+
+const a = require(fixtures.path('module-require', 'relative', 'dot.js'));
+const b = require(fixtures.path('module-require', 'relative', 'dot-slash.js'));
+
+assert.strictEqual(a.value, 42);
+// require(".") should resolve like require("./")
+assert.strictEqual(a, b);
+
+process.env.NODE_PATH = fixtures.path('module-require', 'relative');
+m._initPaths();
+
+assert.throws(
+  () => require('.'),
+  {
+    message: /Cannot find module '\.'/,
+    code: 'MODULE_NOT_FOUND'
+  }
+);
diff --git a/test/js/node/test/parallel/test-require-empty-main.js b/test/js/node/test/parallel/test-require-empty-main.js
new file mode 100644
index 0000000000..73f141d1f9
--- /dev/null
+++ b/test/js/node/test/parallel/test-require-empty-main.js
@@ -0,0 +1,25 @@
+'use strict';
+require('../common');
+
+// A package.json with an empty "main" property should use index.js if present.
+// require.resolve() should resolve to index.js for the same reason.
+//
+// In fact, any "main" property that doesn't resolve to a file should result
+// in index.js being used, but that's already checked for by other tests.
+// This test only concerns itself with the empty string.
+
+const assert = require('assert');
+const path = require('path');
+const fixtures = require('../common/fixtures');
+
+const where = fixtures.path('require-empty-main');
+const expected = path.join(where, 'index.js');
+
+test();
+setImmediate(test);
+
+function test() {
+  assert.strictEqual(require.resolve(where), expected);
+  assert.strictEqual(require(where), 42);
+  assert.strictEqual(require.resolve(where), expected);
+}
diff --git a/test/js/node/test/parallel/test-require-extensions-main.js b/test/js/node/test/parallel/test-require-extensions-main.js
new file mode 100644
index 0000000000..16fbad6cf7
--- /dev/null
+++ b/test/js/node/test/parallel/test-require-extensions-main.js
@@ -0,0 +1,13 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const fixtures = require('../common/fixtures');
+
+const fixturesRequire = require(fixtures.path('require-bin', 'bin', 'req.js'));
+
+assert.strictEqual(
+  fixturesRequire,
+  '',
+  'test-require-extensions-main failed to import fixture requirements: ' +
+    fixturesRequire
+);
diff --git a/test/js/node/test/parallel/test-require-extensions-same-filename-as-dir-trailing-slash.js b/test/js/node/test/parallel/test-require-extensions-same-filename-as-dir-trailing-slash.js
new file mode 100644
index 0000000000..2461ece860
--- /dev/null
+++ b/test/js/node/test/parallel/test-require-extensions-same-filename-as-dir-trailing-slash.js
@@ -0,0 +1,35 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const fixtures = require('../common/fixtures');
+
+const content =
+  require(fixtures.path('json-with-directory-name-module',
+                        'module-stub',
+                        'one-trailing-slash',
+                        'two',
+                        'three.js'));
+
+assert.notStrictEqual(content.rocko, 'artischocko');
+assert.strictEqual(content, 'hello from module-stub!');
diff --git a/test/js/node/test/parallel/test-require-long-path.js b/test/js/node/test/parallel/test-require-long-path.js
new file mode 100644
index 0000000000..abc75176bc
--- /dev/null
+++ b/test/js/node/test/parallel/test-require-long-path.js
@@ -0,0 +1,28 @@
+'use strict';
+const common = require('../common');
+if (!common.isWindows)
+  common.skip('this test is Windows-specific.');
+
+const fs = require('fs');
+const path = require('path');
+
+const tmpdir = require('../common/tmpdir');
+
+// Make a path that is more than 260 chars long.
+const dirNameLen = Math.max(260 - tmpdir.path.length, 1);
+const dirName = tmpdir.resolve('x'.repeat(dirNameLen));
+const fullDirPath = path.resolve(dirName);
+
+const indexFile = path.join(fullDirPath, 'index.js');
+const otherFile = path.join(fullDirPath, 'other.js');
+
+tmpdir.refresh();
+
+fs.mkdirSync(fullDirPath);
+fs.writeFileSync(indexFile, 'require("./other");');
+fs.writeFileSync(otherFile, '');
+
+require(indexFile);
+require(otherFile);
+
+tmpdir.refresh();
diff --git a/test/js/node/test/parallel/test-require-process.js b/test/js/node/test/parallel/test-require-process.js
new file mode 100644
index 0000000000..57af1508f0
--- /dev/null
+++ b/test/js/node/test/parallel/test-require-process.js
@@ -0,0 +1,7 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+
+const nativeProcess = require('process');
+// require('process') should return global process reference
+assert.strictEqual(nativeProcess, process);
diff --git a/test/js/node/test/parallel/test-require-unicode.js b/test/js/node/test/parallel/test-require-unicode.js
new file mode 100644
index 0000000000..362ec6487a
--- /dev/null
+++ b/test/js/node/test/parallel/test-require-unicode.js
@@ -0,0 +1,17 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+const dirname = tmpdir.resolve('\u4e2d\u6587\u76ee\u5f55');
+fs.mkdirSync(dirname);
+fs.writeFileSync(path.join(dirname, 'file.js'), 'module.exports = 42;');
+fs.writeFileSync(path.join(dirname, 'package.json'),
+                 JSON.stringify({ name: 'test', main: 'file.js' }));
+assert.strictEqual(require(dirname), 42);
+assert.strictEqual(require(path.join(dirname, 'file.js')), 42);
diff --git a/test/js/node/test/parallel/test-sigint-infinite-loop.js b/test/js/node/test/parallel/test-sigint-infinite-loop.js
new file mode 100644
index 0000000000..30eb98ecb8
--- /dev/null
+++ b/test/js/node/test/parallel/test-sigint-infinite-loop.js
@@ -0,0 +1,34 @@
+'use strict';
+// This test is to assert that we can SIGINT a script which loops forever.
+// Ref(http):
+// groups.google.com/group/nodejs-dev/browse_thread/thread/e20f2f8df0296d3f
+const common = require('../common');
+const assert = require('assert');
+const spawn = require('child_process').spawn;
+
+console.log('start');
+
+const c = spawn(process.execPath, ['-e', 'while(true) { console.log("hi"); }']);
+
+let sentKill = false;
+
+c.stdout.on('data', function(s) {
+  // Prevent race condition:
+  // Wait for the first bit of output from the child process
+  // so that we're sure that it's in the V8 event loop and not
+  // just in the startup phase of execution.
+  if (!sentKill) {
+    c.kill('SIGINT');
+    console.log('SIGINT infinite-loop.js');
+    sentKill = true;
+  }
+});
+
+c.on('exit', common.mustCall(function(code) {
+  assert.ok(code !== 0);
+  console.log('killed infinite-loop.js');
+}));
+
+process.on('exit', function() {
+  assert.ok(sentKill);
+});
diff --git a/test/js/node/test/parallel/test-signal-args.js b/test/js/node/test/parallel/test-signal-args.js
new file mode 100644
index 0000000000..7b72ed6dcb
--- /dev/null
+++ b/test/js/node/test/parallel/test-signal-args.js
@@ -0,0 +1,25 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+
+if (common.isWindows)
+  common.skip('Sending signals with process.kill is not supported on Windows');
+if (!common.isMainThread)
+  common.skip('No signal handling available in Workers');
+
+process.once('SIGINT', common.mustCall((signal) => {
+  assert.strictEqual(signal, 'SIGINT');
+}));
+
+process.kill(process.pid, 'SIGINT');
+
+process.once('SIGTERM', common.mustCall((signal) => {
+  assert.strictEqual(signal, 'SIGTERM');
+}));
+
+process.kill(process.pid, 'SIGTERM');
+
+// Prevent Node.js from exiting due to empty event loop before signal handlers
+// are fired
+setImmediate(() => {});
diff --git a/test/js/node/test/parallel/test-signal-handler-remove-on-exit.js b/test/js/node/test/parallel/test-signal-handler-remove-on-exit.js
new file mode 100644
index 0000000000..1c87497172
--- /dev/null
+++ b/test/js/node/test/parallel/test-signal-handler-remove-on-exit.js
@@ -0,0 +1,9 @@
+'use strict';
+require('../common');
+
+// Regression test for https://github.com/nodejs/node/issues/30581
+// This script should not crash.
+
+function dummy() {}
+process.on('SIGINT', dummy);
+process.on('exit', () => process.removeListener('SIGINT', dummy));
diff --git a/test/js/node/test/parallel/test-signal-handler.js b/test/js/node/test/parallel/test-signal-handler.js
new file mode 100644
index 0000000000..05ec4e7f73
--- /dev/null
+++ b/test/js/node/test/parallel/test-signal-handler.js
@@ -0,0 +1,56 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+
+const common = require('../common');
+
+if (common.isWindows)
+  common.skip('SIGUSR1 and SIGHUP signals are not supported');
+if (!common.isMainThread)
+  common.skip('Signal handling in Workers is not supported');
+
+console.log(`process.pid: ${process.pid}`);
+
+process.on('SIGUSR1', common.mustCall());
+
+process.on('SIGUSR1', common.mustCall(function() {
+  setTimeout(function() {
+    console.log('End.');
+    process.exit(0);
+  }, 5);
+}));
+
+let i = 0;
+setInterval(function() {
+  console.log(`running process...${++i}`);
+
+  if (i === 5) {
+    process.kill(process.pid, 'SIGUSR1');
+  }
+}, 1);
+
+// Test on condition where a watcher for SIGNAL
+// has been previously registered, and `process.listeners(SIGNAL).length === 1`
+process.on('SIGHUP', common.mustNotCall());
+process.removeAllListeners('SIGHUP');
+process.on('SIGHUP', common.mustCall());
+process.kill(process.pid, 'SIGHUP');
diff --git a/test/js/node/test/parallel/test-signal-unregister.js b/test/js/node/test/parallel/test-signal-unregister.js
new file mode 100644
index 0000000000..2c4d312942
--- /dev/null
+++ b/test/js/node/test/parallel/test-signal-unregister.js
@@ -0,0 +1,14 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const spawn = require('child_process').spawn;
+const fixtures = require('../common/fixtures');
+
+const child = spawn(process.argv[0], [fixtures.path('should_exit.js')]);
+child.stdout.once('data', function() {
+  child.kill('SIGINT');
+});
+child.on('exit', common.mustCall(function(exitCode, signalCode) {
+  assert.strictEqual(exitCode, null);
+  assert.strictEqual(signalCode, 'SIGINT');
+}));
diff --git a/test/js/node/test/parallel/test-spawn-cmd-named-pipe.js b/test/js/node/test/parallel/test-spawn-cmd-named-pipe.js
new file mode 100644
index 0000000000..4e7ad185a5
--- /dev/null
+++ b/test/js/node/test/parallel/test-spawn-cmd-named-pipe.js
@@ -0,0 +1,50 @@
+'use strict';
+const common = require('../common');
+// This test is intended for Windows only
+if (!common.isWindows)
+  common.skip('this test is Windows-specific.');
+
+const assert = require('assert');
+
+if (!process.argv[2]) {
+  // parent
+  const net = require('net');
+  const spawn = require('child_process').spawn;
+  const path = require('path');
+
+  const pipeNamePrefix = `${path.basename(__filename)}.${process.pid}`;
+  const stdinPipeName = `\\\\.\\pipe\\${pipeNamePrefix}.stdin`;
+  const stdoutPipeName = `\\\\.\\pipe\\${pipeNamePrefix}.stdout`;
+
+  const stdinPipeServer = net.createServer(function(c) {
+    c.on('end', common.mustCall());
+    c.end('hello');
+  });
+  stdinPipeServer.listen(stdinPipeName);
+
+  const output = [];
+
+  const stdoutPipeServer = net.createServer(function(c) {
+    c.on('data', function(x) {
+      output.push(x);
+    });
+    c.on('end', common.mustCall(function() {
+      assert.strictEqual(output.join(''), 'hello');
+    }));
+  });
+  stdoutPipeServer.listen(stdoutPipeName);
+
+  const args =
+    [`"${__filename}"`, 'child', '<', stdinPipeName, '>', stdoutPipeName];
+
+  const child = spawn(`"${process.execPath}"`, args, { shell: true });
+
+  child.on('exit', common.mustCall(function(exitCode) {
+    stdinPipeServer.close();
+    stdoutPipeServer.close();
+    assert.strictEqual(exitCode, 0);
+  }));
+} else {
+  // child
+  process.stdin.pipe(process.stdout);
+}
diff --git a/test/js/node/test/parallel/test-stdin-child-proc.js b/test/js/node/test/parallel/test-stdin-child-proc.js
new file mode 100644
index 0000000000..bbb6a29cd7
--- /dev/null
+++ b/test/js/node/test/parallel/test-stdin-child-proc.js
@@ -0,0 +1,15 @@
+'use strict';
+// This tests that pausing and resuming stdin does not hang and timeout
+// when done in a child process.  See test/parallel/test-stdin-pause-resume.js
+const common = require('../common');
+const assert = require('assert');
+const child_process = require('child_process');
+const path = require('path');
+const cp = child_process.spawn(
+  process.execPath,
+  [path.resolve(__dirname, 'test-stdin-pause-resume.js')]
+);
+
+cp.on('exit', common.mustCall((code) => {
+  assert.strictEqual(code, 0);
+}));
diff --git a/test/js/node/test/parallel/test-stdin-from-file-spawn.js b/test/js/node/test/parallel/test-stdin-from-file-spawn.js
new file mode 100644
index 0000000000..3830ac124a
--- /dev/null
+++ b/test/js/node/test/parallel/test-stdin-from-file-spawn.js
@@ -0,0 +1,42 @@
+'use strict';
+const common = require('../common');
+const process = require('process');
+
+let defaultShell;
+if (process.platform === 'linux' || process.platform === 'darwin') {
+  defaultShell = '/bin/sh';
+} else if (process.platform === 'win32') {
+  defaultShell = 'cmd.exe';
+} else {
+  common.skip('This is test exists only on Linux/Win32/macOS');
+}
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const tmpdir = require('../common/tmpdir');
+
+const tmpDir = tmpdir.path;
+tmpdir.refresh();
+const tmpCmdFile = path.join(tmpDir, 'test-stdin-from-file-spawn-cmd');
+const tmpJsFile = path.join(tmpDir, 'test-stdin-from-file-spawn.js');
+fs.writeFileSync(tmpCmdFile, 'echo hello');
+fs.writeFileSync(tmpJsFile, `
+'use strict';
+const { spawn } = require('child_process');
+// Reference the object to invoke the getter
+process.stdin;
+setTimeout(() => {
+  let ok = false;
+  const child = spawn(process.env.SHELL || '${defaultShell}',
+    [], { stdio: ['inherit', 'pipe'] });
+  child.stdout.on('data', () => {
+    ok = true;
+  });
+  child.on('close', () => {
+    process.exit(ok ? 0 : -1);
+  });
+}, 100);
+`);
+
+execSync(`${process.argv[0]} ${tmpJsFile} < ${tmpCmdFile}`);
diff --git a/test/js/node/test/parallel/test-stdin-hang.js b/test/js/node/test/parallel/test-stdin-hang.js
new file mode 100644
index 0000000000..887f31fdb7
--- /dev/null
+++ b/test/js/node/test/parallel/test-stdin-hang.js
@@ -0,0 +1,32 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+
+// This test *only* verifies that invoking the stdin getter does not
+// cause node to hang indefinitely.
+// If it does, then the test-runner will nuke it.
+
+// invoke the getter.
+process.stdin; // eslint-disable-line no-unused-expressions
+
+console.error('Should exit normally now.');
diff --git a/test/js/node/test/parallel/test-stdin-pause-resume.js b/test/js/node/test/parallel/test-stdin-pause-resume.js
new file mode 100644
index 0000000000..459256099e
--- /dev/null
+++ b/test/js/node/test/parallel/test-stdin-pause-resume.js
@@ -0,0 +1,39 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+console.error('before opening stdin');
+process.stdin.resume();
+console.error('stdin opened');
+setTimeout(function() {
+  console.error('pausing stdin');
+  process.stdin.pause();
+  setTimeout(function() {
+    console.error('opening again');
+    process.stdin.resume();
+    setTimeout(function() {
+      console.error('pausing again');
+      process.stdin.pause();
+      console.error('should exit now');
+    }, 1);
+  }, 1);
+}, 1);
diff --git a/test/js/node/test/parallel/test-stdin-pipe-large.js b/test/js/node/test/parallel/test-stdin-pipe-large.js
new file mode 100644
index 0000000000..5f4a2f10c8
--- /dev/null
+++ b/test/js/node/test/parallel/test-stdin-pipe-large.js
@@ -0,0 +1,23 @@
+'use strict';
+// See https://github.com/nodejs/node/issues/5927
+
+const common = require('../common');
+const assert = require('assert');
+const spawn = require('child_process').spawn;
+
+if (process.argv[2] === 'child') {
+  process.stdin.pipe(process.stdout);
+  return;
+}
+
+const child = spawn(process.execPath, [__filename, 'child'], { stdio: 'pipe' });
+
+const expectedBytes = 1024 * 1024;
+let readBytes = 0;
+
+child.stdin.end(Buffer.alloc(expectedBytes));
+
+child.stdout.on('data', (chunk) => readBytes += chunk.length);
+child.stdout.on('end', common.mustCall(() => {
+  assert.strictEqual(readBytes, expectedBytes);
+}));
diff --git a/test/js/node/test/parallel/test-stdin-pipe-resume.js b/test/js/node/test/parallel/test-stdin-pipe-resume.js
new file mode 100644
index 0000000000..e9000933a3
--- /dev/null
+++ b/test/js/node/test/parallel/test-stdin-pipe-resume.js
@@ -0,0 +1,27 @@
+'use strict';
+// This tests that piping stdin will cause it to resume() as well.
+require('../common');
+const assert = require('assert');
+
+if (process.argv[2] === 'child') {
+  process.stdin.pipe(process.stdout);
+} else {
+  const spawn = require('child_process').spawn;
+  const buffers = [];
+  const child = spawn(process.execPath, [__filename, 'child']);
+  child.stdout.on('data', function(c) {
+    buffers.push(c);
+  });
+  child.stdout.on('close', function() {
+    const b = Buffer.concat(buffers).toString();
+    assert.strictEqual(b, 'Hello, world\n');
+    console.log('ok');
+  });
+  child.stdin.write('Hel');
+  child.stdin.write('lo,');
+  child.stdin.write(' wo');
+  setTimeout(function() {
+    child.stdin.write('rld\n');
+    child.stdin.end();
+  }, 10);
+}
diff --git a/test/js/node/test/parallel/test-stdin-script-child-option.js b/test/js/node/test/parallel/test-stdin-script-child-option.js
new file mode 100644
index 0000000000..5526d66f3f
--- /dev/null
+++ b/test/js/node/test/parallel/test-stdin-script-child-option.js
@@ -0,0 +1,17 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+const expected = '--option-to-be-seen-on-child';
+
+const { spawn } = require('child_process');
+const child = spawn(process.execPath, ['-', expected], { stdio: 'pipe' });
+
+child.stdin.end('console.log(process.argv[2])');
+
+let actual = '';
+child.stdout.setEncoding('utf8');
+child.stdout.on('data', (chunk) => actual += chunk);
+child.stdout.on('end', common.mustCall(() => {
+  assert.strictEqual(actual.trim(), expected);
+}));
diff --git a/test/js/node/test/parallel/test-stdio-closed.js b/test/js/node/test/parallel/test-stdio-closed.js
new file mode 100644
index 0000000000..cc9f1e86cc
--- /dev/null
+++ b/test/js/node/test/parallel/test-stdio-closed.js
@@ -0,0 +1,37 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const spawn = require('child_process').spawn;
+const fs = require('fs');
+const fixtures = require('../common/fixtures');
+
+if (common.isWindows) {
+  if (process.argv[2] === 'child') {
+    /* eslint-disable no-unused-expressions */
+    process.stdin;
+    process.stdout;
+    process.stderr;
+    return;
+    /* eslint-enable no-unused-expressions */
+  }
+  const python = process.env.PYTHON || 'python';
+  const script = fixtures.path('spawn_closed_stdio.py');
+  const proc = spawn(python, [script, process.execPath, __filename, 'child']);
+  proc.on('exit', common.mustCall(function(exitCode) {
+    assert.strictEqual(exitCode, 0);
+  }));
+  return;
+}
+
+if (process.argv[2] === 'child') {
+  [0, 1, 2].forEach((i) => fs.fstatSync(i));
+  return;
+}
+
+// Run the script in a shell but close stdout and stderr.
+const cmd = `"${process.execPath}" "${__filename}" child 1>&- 2>&-`;
+const proc = spawn('/bin/sh', ['-c', cmd], { stdio: 'inherit' });
+
+proc.on('exit', common.mustCall(function(exitCode) {
+  assert.strictEqual(exitCode, 0);
+}));
diff --git a/test/js/node/test/parallel/test-stdio-pipe-stderr.js b/test/js/node/test/parallel/test-stdio-pipe-stderr.js
new file mode 100644
index 0000000000..c914877062
--- /dev/null
+++ b/test/js/node/test/parallel/test-stdio-pipe-stderr.js
@@ -0,0 +1,36 @@
+'use strict';
+require('../common');
+const tmpdir = require('../common/tmpdir');
+const assert = require('assert');
+const fs = require('fs');
+const { spawnSync } = require('child_process');
+
+// Test that invoking node with require, and piping stderr to file,
+// does not result in exception,
+// see: https://github.com/nodejs/node/issues/11257
+
+tmpdir.refresh();
+const fakeModulePath = tmpdir.resolve('batman.js');
+const stderrOutputPath = tmpdir.resolve('stderr-output.txt');
+// We need to redirect stderr to a file to produce #11257
+const stream = fs.createWriteStream(stderrOutputPath);
+
+// The error described in #11257 only happens when we require a
+// non-built-in module.
+fs.writeFileSync(fakeModulePath, '', 'utf8');
+
+stream.on('open', () => {
+  spawnSync(process.execPath, {
+    input: `require(${JSON.stringify(fakeModulePath)})`,
+    stdio: ['pipe', 'pipe', stream]
+  });
+  const stderr = fs.readFileSync(stderrOutputPath, 'utf8').trim();
+  assert.strictEqual(
+    stderr,
+    '',
+    `piping stderr to file should not result in exception: ${stderr}`
+  );
+  stream.end();
+  fs.unlinkSync(stderrOutputPath);
+  fs.unlinkSync(fakeModulePath);
+});
diff --git a/test/js/node/test/parallel/test-stdio-undestroy.js b/test/js/node/test/parallel/test-stdio-undestroy.js
new file mode 100644
index 0000000000..b525672db2
--- /dev/null
+++ b/test/js/node/test/parallel/test-stdio-undestroy.js
@@ -0,0 +1,36 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const spawn = require('child_process').spawn;
+
+if (process.argv[2] === 'child') {
+  process.stdout.destroy();
+  process.stderr.destroy();
+  console.log('stdout');
+  process.stdout.write('rocks\n');
+  console.error('stderr');
+  setTimeout(function() {
+    process.stderr.write('rocks too\n');
+  }, 10);
+  return;
+}
+
+const proc = spawn(process.execPath, [__filename, 'child'], { stdio: 'pipe' });
+
+let stdout = '';
+proc.stdout.setEncoding('utf8');
+proc.stdout.on('data', common.mustCallAtLeast(function(chunk) {
+  stdout += chunk;
+}, 1));
+
+let stderr = '';
+proc.stderr.setEncoding('utf8');
+proc.stderr.on('data', common.mustCallAtLeast(function(chunk) {
+  stderr += chunk;
+}, 1));
+
+proc.on('exit', common.mustCall(function(exitCode) {
+  assert.strictEqual(exitCode, 0);
+  assert.strictEqual(stdout, 'stdout\nrocks\n');
+  assert.strictEqual(stderr, 'stderr\nrocks too\n');
+}));
diff --git a/test/js/node/test/parallel/test-stdout-cannot-be-closed-child-process-pipe.js b/test/js/node/test/parallel/test-stdout-cannot-be-closed-child-process-pipe.js
new file mode 100644
index 0000000000..7cd4b90c00
--- /dev/null
+++ b/test/js/node/test/parallel/test-stdout-cannot-be-closed-child-process-pipe.js
@@ -0,0 +1,32 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+
+if (process.argv[2] === 'child')
+  process.stdout.end('foo');
+else
+  parent();
+
+function parent() {
+  const spawn = require('child_process').spawn;
+  const child = spawn(process.execPath, [__filename, 'child']);
+  let out = '';
+  let err = '';
+
+  child.stdout.setEncoding('utf8');
+  child.stderr.setEncoding('utf8');
+
+  child.stdout.on('data', function(c) {
+    out += c;
+  });
+  child.stderr.on('data', function(c) {
+    err += c;
+  });
+
+  child.on('close', function(code, signal) {
+    assert.strictEqual(code, 0);
+    assert.strictEqual(err, '');
+    assert.strictEqual(out, 'foo');
+    console.log('ok');
+  });
+}
diff --git a/test/js/node/test/parallel/test-stdout-pipeline-destroy.js b/test/js/node/test/parallel/test-stdout-pipeline-destroy.js
new file mode 100644
index 0000000000..291579cf69
--- /dev/null
+++ b/test/js/node/test/parallel/test-stdout-pipeline-destroy.js
@@ -0,0 +1,31 @@
+'use strict';
+
+const common = require('../common');
+const { Transform, Readable, pipeline } = require('stream');
+const assert = require('assert');
+
+const reader = new Readable({
+  read(size) { this.push('foo'); }
+});
+
+let count = 0;
+
+const err = new Error('this-error-gets-hidden');
+
+const transform = new Transform({
+  transform(chunk, enc, cb) {
+    if (count++ >= 5)
+      this.emit('error', err);
+    else
+      cb(null, count.toString() + '\n');
+  }
+});
+
+pipeline(
+  reader,
+  transform,
+  process.stdout,
+  common.mustCall((e) => {
+    assert.strictEqual(e, err);
+  })
+);
diff --git a/test/js/node/test/parallel/test-stdout-stderr-reading.js b/test/js/node/test/parallel/test-stdout-stderr-reading.js
new file mode 100644
index 0000000000..57bfffa272
--- /dev/null
+++ b/test/js/node/test/parallel/test-stdout-stderr-reading.js
@@ -0,0 +1,67 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+// Verify that stdout is never read from.
+const net = require('net');
+const read = net.Socket.prototype.read;
+
+net.Socket.prototype.read = function() {
+  if (this.fd === 1)
+    throw new Error('reading from stdout!');
+  if (this.fd === 2)
+    throw new Error('reading from stderr!');
+  return read.apply(this, arguments);
+};
+
+if (process.argv[2] === 'child')
+  child();
+else
+  parent();
+
+function parent() {
+  const spawn = require('child_process').spawn;
+  const node = process.execPath;
+
+  const c1 = spawn(node, [__filename, 'child']);
+  let c1out = '';
+  c1.stdout.setEncoding('utf8');
+  c1.stdout.on('data', function(chunk) {
+    c1out += chunk;
+  });
+  c1.stderr.setEncoding('utf8');
+  c1.stderr.on('data', function(chunk) {
+    console.error(`c1err: ${chunk.split('\n').join('\nc1err: ')}`);
+  });
+  c1.on('close', common.mustCall(function(code, signal) {
+    assert(!code);
+    assert(!signal);
+    assert.strictEqual(c1out, 'ok\n');
+    console.log('ok');
+  }));
+
+  const c2 = spawn(node, ['-e', 'console.log("ok")']);
+  let c2out = '';
+  c2.stdout.setEncoding('utf8');
+  c2.stdout.on('data', function(chunk) {
+    c2out += chunk;
+  });
+  c1.stderr.setEncoding('utf8');
+  c1.stderr.on('data', function(chunk) {
+    console.error(`c1err: ${chunk.split('\n').join('\nc1err: ')}`);
+  });
+  c2.on('close', common.mustCall(function(code, signal) {
+    assert(!code);
+    assert(!signal);
+    assert.strictEqual(c2out, 'ok\n');
+    console.log('ok');
+  }));
+}
+
+function child() {
+  // Should not be reading *ever* in here.
+  net.Socket.prototype.read = function() {
+    throw new Error('no reading allowed in child');
+  };
+  console.log('ok');
+}
diff --git a/test/js/node/test/parallel/test-stdout-stderr-write.js b/test/js/node/test/parallel/test-stdout-stderr-write.js
new file mode 100644
index 0000000000..803fc70536
--- /dev/null
+++ b/test/js/node/test/parallel/test-stdout-stderr-write.js
@@ -0,0 +1,8 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+
+// https://github.com/nodejs/node/pull/39246
+assert.strictEqual(process.stderr.write('asd'), true);
+assert.strictEqual(process.stdout.write('asd'), true);
diff --git a/test/js/node/test/parallel/test-stdout-to-file.js b/test/js/node/test/parallel/test-stdout-to-file.js
new file mode 100644
index 0000000000..9114f22443
--- /dev/null
+++ b/test/js/node/test/parallel/test-stdout-to-file.js
@@ -0,0 +1,46 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const childProcess = require('child_process');
+const fs = require('fs');
+const fixtures = require('../common/fixtures');
+const tmpdir = require('../common/tmpdir');
+
+const scriptString = fixtures.path('print-chars.js');
+const scriptBuffer = fixtures.path('print-chars-from-buffer.js');
+const tmpFile = tmpdir.resolve('stdout.txt');
+
+tmpdir.refresh();
+
+function test(size, useBuffer, cb) {
+  const cmd = `"${process.argv[0]}" "${
+    useBuffer ? scriptBuffer : scriptString}" ${size} > "${tmpFile}"`;
+
+  try {
+    fs.unlinkSync(tmpFile);
+  } catch {
+    // Continue regardless of error.
+  }
+
+  console.log(`${size} chars to ${tmpFile}...`);
+
+  childProcess.exec(cmd, common.mustSucceed(() => {
+    console.log('done!');
+
+    const stat = fs.statSync(tmpFile);
+
+    console.log(`${tmpFile} has ${stat.size} bytes`);
+
+    assert.strictEqual(size, stat.size);
+    fs.unlinkSync(tmpFile);
+
+    cb();
+  }));
+}
+
+test(1024 * 1024, false, common.mustCall(function() {
+  console.log('Done printing with string');
+  test(1024 * 1024, true, common.mustCall(function() {
+    console.log('Done printing with buffer');
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-strace-openat-openssl.js b/test/js/node/test/parallel/test-strace-openat-openssl.js
new file mode 100644
index 0000000000..13882e67ae
--- /dev/null
+++ b/test/js/node/test/parallel/test-strace-openat-openssl.js
@@ -0,0 +1,61 @@
+'use strict';
+
+const common = require('../common');
+const { spawn, spawnSync } = require('node:child_process');
+const { createInterface } = require('node:readline');
+const assert = require('node:assert');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+if (!common.isLinux)
+  common.skip('linux only');
+if (common.isASan)
+  common.skip('strace does not work well with address sanitizer builds');
+if (spawnSync('strace').error !== undefined) {
+  common.skip('missing strace');
+}
+
+{
+  const allowedOpenCalls = new Set([
+    '/etc/ssl/openssl.cnf',
+  ]);
+  const strace = spawn('strace', [
+    '-f', '-ff',
+    '-e', 'trace=open,openat',
+    '-s', '512',
+    '-D', process.execPath, '-e', 'require("crypto")',
+  ]);
+
+  // stderr is the default for strace
+  const rl = createInterface({ input: strace.stderr });
+  rl.on('line', (line) => {
+    if (!line.startsWith('open')) {
+      return;
+    }
+
+    const file = line.match(/"(.*?)"/)[1];
+    // skip .so reading attempt
+    if (file.match(/.+\.so(\.?)/) !== null) {
+      return;
+    }
+    // skip /proc/*
+    if (file.match(/\/proc\/.+/) !== null) {
+      return;
+    }
+
+    assert(allowedOpenCalls.delete(file), `${file} is not in the list of allowed openat calls`);
+  });
+  const debugOutput = [];
+  strace.stderr.setEncoding('utf8');
+  strace.stderr.on('data', (chunk) => {
+    debugOutput.push(chunk.toString());
+  });
+  strace.on('error', common.mustNotCall());
+  strace.on('exit', common.mustCall((code) => {
+    assert.strictEqual(code, 0, debugOutput);
+    const missingKeys = Array.from(allowedOpenCalls.keys());
+    if (missingKeys.length) {
+      assert.fail(`The following openat call are missing: ${missingKeys.join(',')}`);
+    }
+  }));
+}
diff --git a/test/js/node/test/parallel/test-stream-auto-destroy.js b/test/js/node/test/parallel/test-stream-auto-destroy.js
new file mode 100644
index 0000000000..2a1a5190de
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-auto-destroy.js
@@ -0,0 +1,112 @@
+'use strict';
+const common = require('../common');
+const stream = require('stream');
+const assert = require('assert');
+
+{
+  const r = new stream.Readable({
+    autoDestroy: true,
+    read() {
+      this.push('hello');
+      this.push('world');
+      this.push(null);
+    },
+    destroy: common.mustCall((err, cb) => cb())
+  });
+
+  let ended = false;
+
+  r.resume();
+
+  r.on('end', common.mustCall(() => {
+    ended = true;
+  }));
+
+  r.on('close', common.mustCall(() => {
+    assert(ended);
+  }));
+}
+
+{
+  const w = new stream.Writable({
+    autoDestroy: true,
+    write(data, enc, cb) {
+      cb(null);
+    },
+    destroy: common.mustCall((err, cb) => cb())
+  });
+
+  let finished = false;
+
+  w.write('hello');
+  w.write('world');
+  w.end();
+
+  w.on('finish', common.mustCall(() => {
+    finished = true;
+  }));
+
+  w.on('close', common.mustCall(() => {
+    assert(finished);
+  }));
+}
+
+{
+  const t = new stream.Transform({
+    autoDestroy: true,
+    transform(data, enc, cb) {
+      cb(null, data);
+    },
+    destroy: common.mustCall((err, cb) => cb())
+  });
+
+  let ended = false;
+  let finished = false;
+
+  t.write('hello');
+  t.write('world');
+  t.end();
+
+  t.resume();
+
+  t.on('end', common.mustCall(() => {
+    ended = true;
+  }));
+
+  t.on('finish', common.mustCall(() => {
+    finished = true;
+  }));
+
+  t.on('close', common.mustCall(() => {
+    assert(ended);
+    assert(finished);
+  }));
+}
+
+{
+  const r = new stream.Readable({
+    read() {
+      r2.emit('error', new Error('fail'));
+    }
+  });
+  const r2 = new stream.Readable({
+    autoDestroy: true,
+    destroy: common.mustCall((err, cb) => cb())
+  });
+
+  r.pipe(r2);
+}
+
+{
+  const r = new stream.Readable({
+    read() {
+      w.emit('error', new Error('fail'));
+    }
+  });
+  const w = new stream.Writable({
+    autoDestroy: true,
+    destroy: common.mustCall((err, cb) => cb())
+  });
+
+  r.pipe(w);
+}
diff --git a/test/js/node/test/parallel/test-stream-await-drain-writers-in-synchronously-recursion-write.js b/test/js/node/test/parallel/test-stream-await-drain-writers-in-synchronously-recursion-write.js
new file mode 100644
index 0000000000..110d46bb9f
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-await-drain-writers-in-synchronously-recursion-write.js
@@ -0,0 +1,28 @@
+'use strict';
+const common = require('../common');
+const { PassThrough } = require('stream');
+
+const encode = new PassThrough({
+  highWaterMark: 1
+});
+
+const decode = new PassThrough({
+  highWaterMark: 1
+});
+
+const send = common.mustCall((buf) => {
+  encode.write(buf);
+}, 4);
+
+let i = 0;
+const onData = common.mustCall(() => {
+  if (++i === 2) {
+    send(Buffer.from([0x3]));
+    send(Buffer.from([0x4]));
+  }
+}, 4);
+
+encode.pipe(decode).on('data', onData);
+
+send(Buffer.from([0x1]));
+send(Buffer.from([0x2]));
diff --git a/test/js/node/test/parallel/test-stream-backpressure.js b/test/js/node/test/parallel/test-stream-backpressure.js
new file mode 100644
index 0000000000..03bcc233c8
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-backpressure.js
@@ -0,0 +1,39 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const stream = require('stream');
+
+let pushes = 0;
+const total = 65500 + 40 * 1024;
+const rs = new stream.Readable({
+  read: common.mustCall(function() {
+    if (pushes++ === 10) {
+      this.push(null);
+      return;
+    }
+
+    const length = this._readableState.length;
+
+    // We are at most doing two full runs of _reads
+    // before stopping, because Readable is greedy
+    // to keep its buffer full
+    assert(length <= total);
+
+    this.push(Buffer.alloc(65500));
+    for (let i = 0; i < 40; i++) {
+      this.push(Buffer.alloc(1024));
+    }
+
+    // We will be over highWaterMark at this point
+    // but a new call to _read is scheduled anyway.
+  }, 11)
+});
+
+const ws = stream.Writable({
+  write: common.mustCall(function(data, enc, cb) {
+    setImmediate(cb);
+  }, 41 * 10)
+});
+
+rs.pipe(ws);
diff --git a/test/js/node/test/parallel/test-stream-big-packet.js b/test/js/node/test/parallel/test-stream-big-packet.js
new file mode 100644
index 0000000000..fdbe3cd211
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-big-packet.js
@@ -0,0 +1,65 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const stream = require('stream');
+
+let passed = false;
+
+class TestStream extends stream.Transform {
+  _transform(chunk, encoding, done) {
+    if (!passed) {
+      // Char 'a' only exists in the last write
+      passed = chunk.toString().includes('a');
+    }
+    done();
+  }
+}
+
+const s1 = new stream.Transform({
+  transform(chunk, encoding, cb) {
+    process.nextTick(cb, null, chunk);
+  }
+});
+const s2 = new stream.PassThrough();
+const s3 = new TestStream();
+s1.pipe(s3);
+// Don't let s2 auto close which may close s3
+s2.pipe(s3, { end: false });
+
+// We must write a buffer larger than highWaterMark
+const big = Buffer.alloc(s1.writableHighWaterMark + 1, 'x');
+
+// Since big is larger than highWaterMark, it will be buffered internally.
+assert(!s1.write(big));
+// 'tiny' is small enough to pass through internal buffer.
+assert(s2.write('tiny'));
+
+// Write some small data in next IO loop, which will never be written to s3
+// Because 'drain' event is not emitted from s1 and s1 is still paused
+setImmediate(s1.write.bind(s1), 'later');
+
+// Assert after two IO loops when all operations have been done.
+process.on('exit', function() {
+  assert(passed, 'Large buffer is not handled properly by Writable Stream');
+});
diff --git a/test/js/node/test/parallel/test-stream-big-push.js b/test/js/node/test/parallel/test-stream-big-push.js
new file mode 100644
index 0000000000..f9e75edd3f
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-big-push.js
@@ -0,0 +1,74 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const stream = require('stream');
+const str = 'asdfasdfasdfasdfasdf';
+
+const r = new stream.Readable({
+  highWaterMark: 5,
+  encoding: 'utf8'
+});
+
+let reads = 0;
+
+function _read() {
+  if (reads === 0) {
+    setTimeout(() => {
+      r.push(str);
+    }, 1);
+    reads++;
+  } else if (reads === 1) {
+    const ret = r.push(str);
+    assert.strictEqual(ret, false);
+    reads++;
+  } else {
+    r.push(null);
+  }
+}
+
+r._read = common.mustCall(_read, 3);
+
+r.on('end', common.mustCall());
+
+// Push some data in to start.
+// We've never gotten any read event at this point.
+const ret = r.push(str);
+// Should be false.  > hwm
+assert(!ret);
+let chunk = r.read();
+assert.strictEqual(chunk, str);
+chunk = r.read();
+assert.strictEqual(chunk, null);
+
+r.once('readable', () => {
+  // This time, we'll get *all* the remaining data, because
+  // it's been added synchronously, as the read WOULD take
+  // us below the hwm, and so it triggered a _read() again,
+  // which synchronously added more, which we then return.
+  chunk = r.read();
+  assert.strictEqual(chunk, str + str);
+
+  chunk = r.read();
+  assert.strictEqual(chunk, null);
+});
diff --git a/test/js/node/test/parallel/test-stream-catch-rejections.js b/test/js/node/test/parallel/test-stream-catch-rejections.js
new file mode 100644
index 0000000000..81427c3575
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-catch-rejections.js
@@ -0,0 +1,51 @@
+'use strict';
+
+const common = require('../common');
+const stream = require('stream');
+const assert = require('assert');
+
+{
+  const r = new stream.Readable({
+    captureRejections: true,
+    read() {
+    }
+  });
+  r.push('hello');
+  r.push('world');
+
+  const err = new Error('kaboom');
+
+  r.on('error', common.mustCall((_err) => {
+    assert.strictEqual(err, _err);
+    assert.strictEqual(r.destroyed, true);
+  }));
+
+  r.on('data', async () => {
+    throw err;
+  });
+}
+
+{
+  const w = new stream.Writable({
+    captureRejections: true,
+    highWaterMark: 1,
+    write(chunk, enc, cb) {
+      process.nextTick(cb);
+    }
+  });
+
+  const err = new Error('kaboom');
+
+  w.write('hello', () => {
+    w.write('world');
+  });
+
+  w.on('error', common.mustCall((_err) => {
+    assert.strictEqual(err, _err);
+    assert.strictEqual(w.destroyed, true);
+  }));
+
+  w.on('drain', common.mustCall(async () => {
+    throw err;
+  }, 2));
+}
diff --git a/test/js/node/test/parallel/test-stream-construct.js b/test/js/node/test/parallel/test-stream-construct.js
new file mode 100644
index 0000000000..907b9aa0e3
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-construct.js
@@ -0,0 +1,280 @@
+'use strict';
+
+const common = require('../common');
+const { Writable, Readable, Duplex } = require('stream');
+const assert = require('assert');
+
+{
+  // Multiple callback.
+  new Writable({
+    construct: common.mustCall((callback) => {
+      callback();
+      callback();
+    })
+  }).on('error', common.expectsError({
+    name: 'Error',
+    code: 'ERR_MULTIPLE_CALLBACK'
+  }));
+}
+
+{
+  // Multiple callback.
+  new Readable({
+    construct: common.mustCall((callback) => {
+      callback();
+      callback();
+    })
+  }).on('error', common.expectsError({
+    name: 'Error',
+    code: 'ERR_MULTIPLE_CALLBACK'
+  }));
+}
+
+{
+  // Synchronous error.
+
+  new Writable({
+    construct: common.mustCall((callback) => {
+      callback(new Error('test'));
+    })
+  }).on('error', common.expectsError({
+    name: 'Error',
+    message: 'test'
+  }));
+}
+
+{
+  // Synchronous error.
+
+  new Readable({
+    construct: common.mustCall((callback) => {
+      callback(new Error('test'));
+    })
+  }).on('error', common.expectsError({
+    name: 'Error',
+    message: 'test'
+  }));
+}
+
+{
+  // Asynchronous error.
+
+  new Writable({
+    construct: common.mustCall((callback) => {
+      process.nextTick(callback, new Error('test'));
+    })
+  }).on('error', common.expectsError({
+    name: 'Error',
+    message: 'test'
+  }));
+}
+
+{
+  // Asynchronous error.
+
+  new Readable({
+    construct: common.mustCall((callback) => {
+      process.nextTick(callback, new Error('test'));
+    })
+  }).on('error', common.expectsError({
+    name: 'Error',
+    message: 'test'
+  }));
+}
+
+function testDestroy(factory) {
+  {
+    let constructed = false;
+    const s = factory({
+      construct: common.mustCall((cb) => {
+        constructed = true;
+        process.nextTick(cb);
+      })
+    });
+    s.on('close', common.mustCall(() => {
+      assert.strictEqual(constructed, true);
+    }));
+    s.destroy();
+  }
+
+  {
+    let constructed = false;
+    const s = factory({
+      construct: common.mustCall((cb) => {
+        constructed = true;
+        process.nextTick(cb);
+      })
+    });
+    s.on('close', common.mustCall(() => {
+      assert.strictEqual(constructed, true);
+    }));
+    s.destroy(null, () => {
+      assert.strictEqual(constructed, true);
+    });
+  }
+
+  {
+    let constructed = false;
+    const s = factory({
+      construct: common.mustCall((cb) => {
+        constructed = true;
+        process.nextTick(cb);
+      })
+    });
+    s.on('close', common.mustCall(() => {
+      assert.strictEqual(constructed, true);
+    }));
+    s.destroy();
+  }
+
+
+  {
+    let constructed = false;
+    const s = factory({
+      construct: common.mustCall((cb) => {
+        constructed = true;
+        process.nextTick(cb);
+      })
+    });
+    s.on('close', common.mustCall(() => {
+      assert.strictEqual(constructed, true);
+    }));
+    s.on('error', common.mustCall((err) => {
+      assert.strictEqual(err.message, 'kaboom');
+    }));
+    s.destroy(new Error('kaboom'), (err) => {
+      assert.strictEqual(err.message, 'kaboom');
+      assert.strictEqual(constructed, true);
+    });
+  }
+
+  {
+    let constructed = false;
+    const s = factory({
+      construct: common.mustCall((cb) => {
+        constructed = true;
+        process.nextTick(cb);
+      })
+    });
+    s.on('error', common.mustCall(() => {
+      assert.strictEqual(constructed, true);
+    }));
+    s.on('close', common.mustCall(() => {
+      assert.strictEqual(constructed, true);
+    }));
+    s.destroy(new Error());
+  }
+}
+testDestroy((opts) => new Readable({
+  read: common.mustNotCall(),
+  ...opts
+}));
+testDestroy((opts) => new Writable({
+  write: common.mustNotCall(),
+  final: common.mustNotCall(),
+  ...opts
+}));
+
+{
+  let constructed = false;
+  const r = new Readable({
+    autoDestroy: true,
+    construct: common.mustCall((cb) => {
+      constructed = true;
+      process.nextTick(cb);
+    }),
+    read: common.mustCall(() => {
+      assert.strictEqual(constructed, true);
+      r.push(null);
+    })
+  });
+  r.on('close', common.mustCall(() => {
+    assert.strictEqual(constructed, true);
+  }));
+  r.on('data', common.mustNotCall());
+}
+
+{
+  let constructed = false;
+  const w = new Writable({
+    autoDestroy: true,
+    construct: common.mustCall((cb) => {
+      constructed = true;
+      process.nextTick(cb);
+    }),
+    write: common.mustCall((chunk, encoding, cb) => {
+      assert.strictEqual(constructed, true);
+      process.nextTick(cb);
+    }),
+    final: common.mustCall((cb) => {
+      assert.strictEqual(constructed, true);
+      process.nextTick(cb);
+    })
+  });
+  w.on('close', common.mustCall(() => {
+    assert.strictEqual(constructed, true);
+  }));
+  w.end('data');
+}
+
+{
+  let constructed = false;
+  const w = new Writable({
+    autoDestroy: true,
+    construct: common.mustCall((cb) => {
+      constructed = true;
+      process.nextTick(cb);
+    }),
+    write: common.mustNotCall(),
+    final: common.mustCall((cb) => {
+      assert.strictEqual(constructed, true);
+      process.nextTick(cb);
+    })
+  });
+  w.on('close', common.mustCall(() => {
+    assert.strictEqual(constructed, true);
+  }));
+  w.end();
+}
+
+{
+  new Duplex({
+    construct: common.mustCall()
+  });
+}
+
+{
+  // https://github.com/nodejs/node/issues/34448
+
+  let constructed = false;
+  const d = new Duplex({
+    readable: false,
+    construct: common.mustCall((callback) => {
+      setImmediate(common.mustCall(() => {
+        constructed = true;
+        callback();
+      }));
+    }),
+    write(chunk, encoding, callback) {
+      callback();
+    },
+    read() {
+      this.push(null);
+    }
+  });
+  d.resume();
+  d.end('foo');
+  d.on('close', common.mustCall(() => {
+    assert.strictEqual(constructed, true);
+  }));
+}
+
+{
+  // Construct should not cause stream to read.
+  new Readable({
+    construct: common.mustCall((callback) => {
+      callback();
+    }),
+    read: common.mustNotCall()
+  });
+}
diff --git a/test/js/node/test/parallel/test-stream-decoder-objectmode.js b/test/js/node/test/parallel/test-stream-decoder-objectmode.js
new file mode 100644
index 0000000000..4c572fed6b
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-decoder-objectmode.js
@@ -0,0 +1,20 @@
+'use strict';
+
+require('../common');
+const stream = require('stream');
+const assert = require('assert');
+
+const readable = new stream.Readable({
+  read: () => {},
+  encoding: 'utf16le',
+  objectMode: true
+});
+
+readable.push(Buffer.from('abc', 'utf16le'));
+readable.push(Buffer.from('def', 'utf16le'));
+readable.push(null);
+
+// Without object mode, these would be concatenated into a single chunk.
+assert.strictEqual(readable.read(), 'abc');
+assert.strictEqual(readable.read(), 'def');
+assert.strictEqual(readable.read(), null);
diff --git a/test/js/node/test/parallel/test-stream-destroy-event-order.js b/test/js/node/test/parallel/test-stream-destroy-event-order.js
new file mode 100644
index 0000000000..a88fff820d
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-destroy-event-order.js
@@ -0,0 +1,24 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { Readable } = require('stream');
+
+const rs = new Readable({
+  read() {}
+});
+
+let closed = false;
+let errored = false;
+
+rs.on('close', common.mustCall(() => {
+  closed = true;
+  assert(errored);
+}));
+
+rs.on('error', common.mustCall((err) => {
+  errored = true;
+  assert(!closed);
+}));
+
+rs.destroy(new Error('kaboom'));
diff --git a/test/js/node/test/parallel/test-stream-duplex-end.js b/test/js/node/test/parallel/test-stream-duplex-end.js
new file mode 100644
index 0000000000..2c7706146e
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-duplex-end.js
@@ -0,0 +1,41 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const Duplex = require('stream').Duplex;
+
+{
+  const stream = new Duplex({
+    read() {}
+  });
+  assert.strictEqual(stream.allowHalfOpen, true);
+  stream.on('finish', common.mustNotCall());
+  assert.strictEqual(stream.listenerCount('end'), 0);
+  stream.resume();
+  stream.push(null);
+}
+
+{
+  const stream = new Duplex({
+    read() {},
+    allowHalfOpen: false
+  });
+  assert.strictEqual(stream.allowHalfOpen, false);
+  stream.on('finish', common.mustCall());
+  assert.strictEqual(stream.listenerCount('end'), 0);
+  stream.resume();
+  stream.push(null);
+}
+
+{
+  const stream = new Duplex({
+    read() {},
+    allowHalfOpen: false
+  });
+  assert.strictEqual(stream.allowHalfOpen, false);
+  stream._writableState.ended = true;
+  stream.on('finish', common.mustNotCall());
+  assert.strictEqual(stream.listenerCount('end'), 0);
+  stream.resume();
+  stream.push(null);
+}
diff --git a/test/js/node/test/parallel/test-stream-duplex-props.js b/test/js/node/test/parallel/test-stream-duplex-props.js
new file mode 100644
index 0000000000..aa6b23125a
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-duplex-props.js
@@ -0,0 +1,31 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const { Duplex } = require('stream');
+
+{
+  const d = new Duplex({
+    objectMode: true,
+    highWaterMark: 100
+  });
+
+  assert.strictEqual(d.writableObjectMode, true);
+  assert.strictEqual(d.writableHighWaterMark, 100);
+  assert.strictEqual(d.readableObjectMode, true);
+  assert.strictEqual(d.readableHighWaterMark, 100);
+}
+
+{
+  const d = new Duplex({
+    readableObjectMode: false,
+    readableHighWaterMark: 10,
+    writableObjectMode: true,
+    writableHighWaterMark: 100
+  });
+
+  assert.strictEqual(d.writableObjectMode, true);
+  assert.strictEqual(d.writableHighWaterMark, 100);
+  assert.strictEqual(d.readableObjectMode, false);
+  assert.strictEqual(d.readableHighWaterMark, 10);
+}
diff --git a/test/js/node/test/parallel/test-stream-duplex-readable-end.js b/test/js/node/test/parallel/test-stream-duplex-readable-end.js
new file mode 100644
index 0000000000..3b1d4d21ce
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-duplex-readable-end.js
@@ -0,0 +1,31 @@
+'use strict';
+// https://github.com/nodejs/node/issues/35926
+const common = require('../common');
+const assert = require('assert');
+const stream = require('stream');
+
+let loops = 5;
+
+const src = new stream.Readable({
+  highWaterMark: 16 * 1024,
+  read() {
+    if (loops--)
+      this.push(Buffer.alloc(20000));
+  }
+});
+
+const dst = new stream.Transform({
+  highWaterMark: 16 * 1024,
+  transform(chunk, output, fn) {
+    this.push(null);
+    fn();
+  }
+});
+
+src.pipe(dst);
+
+dst.on('data', () => { });
+dst.on('end', common.mustCall(() => {
+  assert.strictEqual(loops, 3);
+  assert.ok(src.isPaused());
+}));
diff --git a/test/js/node/test/parallel/test-stream-duplex-readable-writable.js b/test/js/node/test/parallel/test-stream-duplex-readable-writable.js
new file mode 100644
index 0000000000..aec88fc120
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-duplex-readable-writable.js
@@ -0,0 +1,46 @@
+'use strict';
+
+const common = require('../common');
+const { Duplex } = require('stream');
+const assert = require('assert');
+
+{
+  const duplex = new Duplex({
+    readable: false
+  });
+  assert.strictEqual(duplex.readable, false);
+  duplex.push('asd');
+  duplex.on('error', common.mustCall((err) => {
+    assert.strictEqual(err.code, 'ERR_STREAM_PUSH_AFTER_EOF');
+  }));
+  duplex.on('data', common.mustNotCall());
+  duplex.on('end', common.mustNotCall());
+}
+
+{
+  const duplex = new Duplex({
+    writable: false,
+    write: common.mustNotCall()
+  });
+  assert.strictEqual(duplex.writable, false);
+  duplex.write('asd');
+  duplex.on('error', common.mustCall((err) => {
+    assert.strictEqual(err.code, 'ERR_STREAM_WRITE_AFTER_END');
+  }));
+  duplex.on('finish', common.mustNotCall());
+}
+
+{
+  const duplex = new Duplex({
+    readable: false
+  });
+  assert.strictEqual(duplex.readable, false);
+  duplex.on('data', common.mustNotCall());
+  duplex.on('end', common.mustNotCall());
+  async function run() {
+    for await (const chunk of duplex) {
+      assert(false, chunk);
+    }
+  }
+  run().then(common.mustCall());
+}
diff --git a/test/js/node/test/parallel/test-stream-duplex-writable-finished.js b/test/js/node/test/parallel/test-stream-duplex-writable-finished.js
new file mode 100644
index 0000000000..20c0781a22
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-duplex-writable-finished.js
@@ -0,0 +1,30 @@
+'use strict';
+
+const common = require('../common');
+const { Duplex } = require('stream');
+const assert = require('assert');
+
+// basic
+{
+  // Find it on Duplex.prototype
+  assert(Object.hasOwn(Duplex.prototype, 'writableFinished'));
+}
+
+// event
+{
+  const duplex = new Duplex();
+
+  duplex._write = (chunk, encoding, cb) => {
+    // The state finished should start in false.
+    assert.strictEqual(duplex.writableFinished, false);
+    cb();
+  };
+
+  duplex.on('finish', common.mustCall(() => {
+    assert.strictEqual(duplex.writableFinished, true);
+  }));
+
+  duplex.end('testing finished state', common.mustCall(() => {
+    assert.strictEqual(duplex.writableFinished, true);
+  }));
+}
diff --git a/test/js/node/test/parallel/test-stream-end-of-streams.js b/test/js/node/test/parallel/test-stream-end-of-streams.js
new file mode 100644
index 0000000000..80a39d052b
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-end-of-streams.js
@@ -0,0 +1,20 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+
+const { Duplex, finished } = require('stream');
+
+assert.throws(
+  () => {
+    // Passing empty object to mock invalid stream
+    // should throw error
+    finished({}, () => {});
+  },
+  { code: 'ERR_INVALID_ARG_TYPE' }
+);
+
+const streamObj = new Duplex();
+streamObj.end();
+// Below code should not throw any errors as the
+// streamObj is `Stream`
+finished(streamObj, () => {});
diff --git a/test/js/node/test/parallel/test-stream-end-paused.js b/test/js/node/test/parallel/test-stream-end-paused.js
new file mode 100644
index 0000000000..f29c82f532
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-end-paused.js
@@ -0,0 +1,50 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+// Make sure we don't miss the end event for paused 0-length streams
+
+const Readable = require('stream').Readable;
+const stream = new Readable();
+let calledRead = false;
+stream._read = function() {
+  assert(!calledRead);
+  calledRead = true;
+  this.push(null);
+};
+
+stream.on('data', function() {
+  throw new Error('should not ever get data');
+});
+stream.pause();
+
+setTimeout(common.mustCall(function() {
+  stream.on('end', common.mustCall());
+  stream.resume();
+}), 1);
+
+process.on('exit', function() {
+  assert(calledRead);
+  console.log('ok');
+});
diff --git a/test/js/node/test/parallel/test-stream-err-multiple-callback-construction.js b/test/js/node/test/parallel/test-stream-err-multiple-callback-construction.js
new file mode 100644
index 0000000000..829af3ffe7
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-err-multiple-callback-construction.js
@@ -0,0 +1,25 @@
+'use strict';
+const common = require('../common');
+const stream = require('stream');
+const assert = require('assert');
+
+class TestWritable extends stream.Writable {
+  _write(_chunk, _encoding, callback) {
+    callback();
+  }
+
+  _final(callback) {
+    process.nextTick(callback);
+    process.nextTick(callback);
+  }
+}
+
+const writable = new TestWritable();
+
+writable.on('finish', common.mustCall());
+writable.on('error', common.mustCall((error) => {
+  assert.strictEqual(error.message, 'Callback called multiple times');
+}));
+
+writable.write('some data');
+writable.end();
diff --git a/test/js/node/test/parallel/test-stream-error-once.js b/test/js/node/test/parallel/test-stream-error-once.js
new file mode 100644
index 0000000000..71f268cfa4
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-error-once.js
@@ -0,0 +1,19 @@
+'use strict';
+const common = require('../common');
+const { Writable, Readable } = require('stream');
+
+{
+  const writable = new Writable();
+  writable.on('error', common.mustCall());
+  writable.end();
+  writable.write('h');
+  writable.write('h');
+}
+
+{
+  const readable = new Readable();
+  readable.on('error', common.mustCall());
+  readable.push(null);
+  readable.push('h');
+  readable.push('h');
+}
diff --git a/test/js/node/test/parallel/test-stream-events-prepend.js b/test/js/node/test/parallel/test-stream-events-prepend.js
new file mode 100644
index 0000000000..80fedf8fae
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-events-prepend.js
@@ -0,0 +1,26 @@
+'use strict';
+const common = require('../common');
+const stream = require('stream');
+
+class Writable extends stream.Writable {
+  constructor() {
+    super();
+    this.prependListener = undefined;
+  }
+
+  _write(chunk, end, cb) {
+    cb();
+  }
+}
+
+class Readable extends stream.Readable {
+  _read() {
+    this.push(null);
+  }
+}
+
+const w = new Writable();
+w.on('pipe', common.mustCall());
+
+const r = new Readable();
+r.pipe(w);
diff --git a/test/js/node/test/parallel/test-stream-inheritance.js b/test/js/node/test/parallel/test-stream-inheritance.js
new file mode 100644
index 0000000000..658bd2be33
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-inheritance.js
@@ -0,0 +1,63 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const { Readable, Writable, Duplex, Transform } = require('stream');
+
+const readable = new Readable({ read() {} });
+const writable = new Writable({ write() {} });
+const duplex = new Duplex({ read() {}, write() {} });
+const transform = new Transform({ transform() {} });
+
+assert.ok(readable instanceof Readable);
+assert.ok(!(writable instanceof Readable));
+assert.ok(duplex instanceof Readable);
+assert.ok(transform instanceof Readable);
+
+assert.ok(!(readable instanceof Writable));
+assert.ok(writable instanceof Writable);
+assert.ok(duplex instanceof Writable);
+assert.ok(transform instanceof Writable);
+
+assert.ok(!(readable instanceof Duplex));
+assert.ok(!(writable instanceof Duplex));
+assert.ok(duplex instanceof Duplex);
+assert.ok(transform instanceof Duplex);
+
+assert.ok(!(readable instanceof Transform));
+assert.ok(!(writable instanceof Transform));
+assert.ok(!(duplex instanceof Transform));
+assert.ok(transform instanceof Transform);
+
+assert.ok(!(null instanceof Writable));
+assert.ok(!(undefined instanceof Writable));
+
+// Simple inheritance check for `Writable` works fine in a subclass constructor.
+function CustomWritable() {
+  assert.ok(
+    this instanceof CustomWritable,
+    `${this} does not inherit from CustomWritable`
+  );
+  assert.ok(
+    this instanceof Writable,
+    `${this} does not inherit from Writable`
+  );
+}
+
+Object.setPrototypeOf(CustomWritable, Writable);
+Object.setPrototypeOf(CustomWritable.prototype, Writable.prototype);
+
+new CustomWritable();
+
+assert.throws(
+  CustomWritable,
+  {
+    code: 'ERR_ASSERTION',
+    constructor: assert.AssertionError,
+    message: 'undefined does not inherit from CustomWritable'
+  }
+);
+
+class OtherCustomWritable extends Writable {}
+
+assert(!(new OtherCustomWritable() instanceof CustomWritable));
+assert(!(new CustomWritable() instanceof OtherCustomWritable));
diff --git a/test/js/node/test/parallel/test-stream-iterator-helpers-test262-tests.mjs b/test/js/node/test/parallel/test-stream-iterator-helpers-test262-tests.mjs
new file mode 100644
index 0000000000..59bcfdc565
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-iterator-helpers-test262-tests.mjs
@@ -0,0 +1,146 @@
+import { mustCall } from '../common/index.mjs';
+import { Readable } from 'stream';
+import assert from 'assert';
+
+// These tests are manually ported from the draft PR for the test262 test suite
+// Authored by Rick Waldron in https://github.com/tc39/test262/pull/2818/files
+
+// test262 license:
+// The << Software identified by reference to the Ecma Standard* ("Software)">>
+// is protected by copyright and is being made available under the
+// "BSD License", included below. This Software may be subject to third party
+// rights (rights from parties other than Ecma International), including patent
+// rights, and no licenses under such third party rights are granted under this
+// license even if the third party concerned is a member of Ecma International.
+// SEE THE ECMA CODE OF CONDUCT IN PATENT MATTERS AVAILABLE AT
+// http://www.ecma-international.org/memento/codeofconduct.htm FOR INFORMATION
+// REGARDING THE LICENSING OF PATENT CLAIMS THAT ARE REQUIRED TO IMPLEMENT ECMA
+// INTERNATIONAL STANDARDS*
+
+// Copyright (C) 2012-2013 Ecma International
+// All rights reserved.
+
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// 1.   Redistributions of source code must retain the above copyright notice,
+//      this list of conditions and the following disclaimer.
+// 2.   Redistributions in binary form must reproduce the above copyright
+//      notice, this list of conditions and the following disclaimer in the
+//      documentation and/or other materials provided with the distribution.
+// 3.   Neither the name of the authors nor Ecma International may be used to
+//      endorse or promote products derived from this software without specific
+//      prior written permission.
+
+// THIS SOFTWARE IS PROVIDED BY THE ECMA INTERNATIONAL "AS IS" AND ANY EXPRESS
+// OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
+// NO EVENT SHALL ECMA INTERNATIONAL BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+// OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// * Ecma International Standards hereafter means Ecma International Standards
+// as well as Ecma Technical Reports
+
+
+// Note all the tests that check AsyncIterator's prototype itself and things
+// that happen before stream conversion were not ported.
+{
+  // drop/length
+  assert.strictEqual(Readable.prototype.drop.length, 1);
+  const descriptor = Object.getOwnPropertyDescriptor(
+    Readable.prototype,
+    'drop'
+  );
+  assert.strictEqual(descriptor.enumerable, false);
+  assert.strictEqual(descriptor.configurable, true);
+  assert.strictEqual(descriptor.writable, true);
+  // drop/limit-equals-total
+  const iterator = Readable.from([1, 2]).drop(2);
+  const result = await iterator[Symbol.asyncIterator]().next();
+  assert.deepStrictEqual(result, { done: true, value: undefined });
+  // drop/limit-greater-than-total.js
+  const iterator2 = Readable.from([1, 2]).drop(3);
+  const result2 = await iterator2[Symbol.asyncIterator]().next();
+  assert.deepStrictEqual(result2, { done: true, value: undefined });
+  // drop/limit-less-than-total.js
+  const iterator3 = Readable.from([1, 2]).drop(1);
+  const result3 = await iterator3[Symbol.asyncIterator]().next();
+  assert.deepStrictEqual(result3, { done: false, value: 2 });
+  // drop/limit-rangeerror
+  assert.throws(() => Readable.from([1]).drop(-1), RangeError);
+  assert.throws(() => {
+    Readable.from([1]).drop({
+      valueOf() {
+        throw new Error('boom');
+      }
+    });
+  }, /boom/);
+  // drop/limit-tointeger
+  const two = await Readable.from([1, 2]).drop({ valueOf: () => 1 }).toArray();
+  assert.deepStrictEqual(two, [2]);
+  // drop/name
+  assert.strictEqual(Readable.prototype.drop.name, 'drop');
+  // drop/non-constructible
+  assert.throws(() => new Readable.prototype.drop(1), TypeError);
+  // drop/proto
+  const proto = Object.getPrototypeOf(Readable.prototype.drop);
+  assert.strictEqual(proto, Function.prototype);
+}
+{
+  // every/abrupt-iterator-close
+  const stream = Readable.from([1, 2, 3]);
+  const e = new Error();
+  await assert.rejects(stream.every(mustCall(() => {
+    throw e;
+  }, 1)), e);
+}
+{
+  // every/callable-fn
+  await assert.rejects(Readable.from([1, 2]).every({}), TypeError);
+}
+{
+  // every/callable
+  Readable.prototype.every.call(Readable.from([]), () => {});
+  // eslint-disable-next-line array-callback-return
+  Readable.from([]).every(() => {});
+  assert.throws(() => {
+    const r = Readable.from([]);
+    new r.every(() => {});
+  }, TypeError);
+}
+
+{
+  // every/false
+  const iterator = Readable.from([1, 2, 3]);
+  const result = await iterator.every((v) => v === 1);
+  assert.strictEqual(result, false);
+}
+{
+  // every/every
+  const iterator = Readable.from([1, 2, 3]);
+  const result = await iterator.every((v) => true);
+  assert.strictEqual(result, true);
+}
+
+{
+  // every/is-function
+  assert.strictEqual(typeof Readable.prototype.every, 'function');
+}
+{
+  // every/length
+  assert.strictEqual(Readable.prototype.every.length, 1);
+  // every/name
+  assert.strictEqual(Readable.prototype.every.name, 'every');
+  // every/propdesc
+  const descriptor = Object.getOwnPropertyDescriptor(
+    Readable.prototype,
+    'every'
+  );
+  assert.strictEqual(descriptor.enumerable, false);
+  assert.strictEqual(descriptor.configurable, true);
+  assert.strictEqual(descriptor.writable, true);
+}
diff --git a/test/js/node/test/parallel/test-stream-once-readable-pipe.js b/test/js/node/test/parallel/test-stream-once-readable-pipe.js
new file mode 100644
index 0000000000..e8f4e9422d
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-once-readable-pipe.js
@@ -0,0 +1,61 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { Readable, Writable } = require('stream');
+
+// This test ensures that if have 'readable' listener
+// on Readable instance it will not disrupt the pipe.
+
+{
+  let receivedData = '';
+  const w = new Writable({
+    write: (chunk, env, callback) => {
+      receivedData += chunk;
+      callback();
+    },
+  });
+
+  const data = ['foo', 'bar', 'baz'];
+  const r = new Readable({
+    read: () => {},
+  });
+
+  r.once('readable', common.mustCall());
+
+  r.pipe(w);
+  r.push(data[0]);
+  r.push(data[1]);
+  r.push(data[2]);
+  r.push(null);
+
+  w.on('finish', common.mustCall(() => {
+    assert.strictEqual(receivedData, data.join(''));
+  }));
+}
+
+{
+  let receivedData = '';
+  const w = new Writable({
+    write: (chunk, env, callback) => {
+      receivedData += chunk;
+      callback();
+    },
+  });
+
+  const data = ['foo', 'bar', 'baz'];
+  const r = new Readable({
+    read: () => {},
+  });
+
+  r.pipe(w);
+  r.push(data[0]);
+  r.push(data[1]);
+  r.push(data[2]);
+  r.push(null);
+  r.once('readable', common.mustCall());
+
+  w.on('finish', common.mustCall(() => {
+    assert.strictEqual(receivedData, data.join(''));
+  }));
+}
diff --git a/test/js/node/test/parallel/test-stream-passthrough-drain.js b/test/js/node/test/parallel/test-stream-passthrough-drain.js
new file mode 100644
index 0000000000..244bf87407
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-passthrough-drain.js
@@ -0,0 +1,10 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const { PassThrough } = require('stream');
+
+const pt = new PassThrough({ highWaterMark: 0 });
+pt.on('drain', common.mustCall());
+assert(!pt.write('hello1'));
+pt.read();
+pt.read();
diff --git a/test/js/node/test/parallel/test-stream-pipe-after-end.js b/test/js/node/test/parallel/test-stream-pipe-after-end.js
new file mode 100644
index 0000000000..045d27e085
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-pipe-after-end.js
@@ -0,0 +1,69 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const { Readable, Writable } = require('stream');
+
+class TestReadable extends Readable {
+  constructor(opt) {
+    super(opt);
+    this._ended = false;
+  }
+
+  _read() {
+    if (this._ended)
+      this.emit('error', new Error('_read called twice'));
+    this._ended = true;
+    this.push(null);
+  }
+}
+
+class TestWritable extends Writable {
+  constructor(opt) {
+    super(opt);
+    this._written = [];
+  }
+
+  _write(chunk, encoding, cb) {
+    this._written.push(chunk);
+    cb();
+  }
+}
+
+// This one should not emit 'end' until we read() from it later.
+const ender = new TestReadable();
+
+// What happens when you pipe() a Readable that's already ended?
+const piper = new TestReadable();
+// pushes EOF null, and length=0, so this will trigger 'end'
+piper.read();
+
+setTimeout(common.mustCall(function() {
+  ender.on('end', common.mustCall());
+  const c = ender.read();
+  assert.strictEqual(c, null);
+
+  const w = new TestWritable();
+  w.on('finish', common.mustCall());
+  piper.pipe(w);
+}), 1);
diff --git a/test/js/node/test/parallel/test-stream-pipe-await-drain-manual-resume.js b/test/js/node/test/parallel/test-stream-pipe-await-drain-manual-resume.js
new file mode 100644
index 0000000000..a95a5e05ae
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-pipe-await-drain-manual-resume.js
@@ -0,0 +1,75 @@
+'use strict';
+const common = require('../common');
+const stream = require('stream');
+const assert = require('assert');
+
+// A consumer stream with a very low highWaterMark, which starts in a state
+// where it buffers the chunk it receives rather than indicating that they
+// have been consumed.
+const writable = new stream.Writable({
+  highWaterMark: 5
+});
+
+let isCurrentlyBufferingWrites = true;
+const queue = [];
+
+writable._write = (chunk, encoding, cb) => {
+  if (isCurrentlyBufferingWrites)
+    queue.push({ chunk, cb });
+  else
+    cb();
+};
+
+const readable = new stream.Readable({
+  read() {}
+});
+
+readable.pipe(writable);
+
+readable.once('pause', common.mustCall(() => {
+  assert.strictEqual(
+    readable._readableState.awaitDrainWriters,
+    writable,
+    'Expected awaitDrainWriters to be a Writable but instead got ' +
+    `${readable._readableState.awaitDrainWriters}`
+  );
+  // First pause, resume manually. The next write() to writable will still
+  // return false, because chunks are still being buffered, so it will increase
+  // the awaitDrain counter again.
+
+  process.nextTick(common.mustCall(() => {
+    readable.resume();
+  }));
+
+  readable.once('pause', common.mustCall(() => {
+    assert.strictEqual(
+      readable._readableState.awaitDrainWriters,
+      writable,
+      '.resume() should not reset the awaitDrainWriters, but instead got ' +
+      `${readable._readableState.awaitDrainWriters}`
+    );
+    // Second pause, handle all chunks from now on. Once all callbacks that
+    // are currently queued up are handled, the awaitDrain drain counter should
+    // fall back to 0 and all chunks that are pending on the readable side
+    // should be flushed.
+    isCurrentlyBufferingWrites = false;
+    for (const queued of queue)
+      queued.cb();
+  }));
+}));
+
+readable.push(Buffer.alloc(100));  // Fill the writable HWM, first 'pause'.
+readable.push(Buffer.alloc(100));  // Second 'pause'.
+readable.push(Buffer.alloc(100));  // Should get through to the writable.
+readable.push(null);
+
+writable.on('finish', common.mustCall(() => {
+  assert.strictEqual(
+    readable._readableState.awaitDrainWriters,
+    null,
+    `awaitDrainWriters should be reset to null
+    after all chunks are written but instead got
+    ${readable._readableState.awaitDrainWriters}`
+  );
+  // Everything okay, all chunks were written.
+}));
diff --git a/test/js/node/test/parallel/test-stream-pipe-await-drain-push-while-write.js b/test/js/node/test/parallel/test-stream-pipe-await-drain-push-while-write.js
new file mode 100644
index 0000000000..089767166c
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-pipe-await-drain-push-while-write.js
@@ -0,0 +1,38 @@
+'use strict';
+const common = require('../common');
+const stream = require('stream');
+const assert = require('assert');
+
+const writable = new stream.Writable({
+  highWaterMark: 16 * 1024,
+  write: common.mustCall(function(chunk, encoding, cb) {
+    assert.strictEqual(
+      readable._readableState.awaitDrainWriters,
+      null,
+    );
+
+    if (chunk.length === 32 * 1024) { // first chunk
+      readable.push(Buffer.alloc(34 * 1024)); // above hwm
+      // We should check if awaitDrain counter is increased in the next
+      // tick, because awaitDrain is incremented after this method finished
+      process.nextTick(() => {
+        assert.strictEqual(readable._readableState.awaitDrainWriters, writable);
+      });
+    }
+
+    process.nextTick(cb);
+  }, 3)
+});
+
+// A readable stream which produces two buffers.
+const bufs = [Buffer.alloc(32 * 1024), Buffer.alloc(33 * 1024)]; // above hwm
+const readable = new stream.Readable({
+  highWaterMark: 16 * 1024,
+  read: function() {
+    while (bufs.length > 0) {
+      this.push(bufs.shift());
+    }
+  }
+});
+
+readable.pipe(writable);
diff --git a/test/js/node/test/parallel/test-stream-pipe-await-drain.js b/test/js/node/test/parallel/test-stream-pipe-await-drain.js
new file mode 100644
index 0000000000..35b86f67f9
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-pipe-await-drain.js
@@ -0,0 +1,67 @@
+'use strict';
+const common = require('../common');
+const stream = require('stream');
+const assert = require('assert');
+
+// This is very similar to test-stream-pipe-cleanup-pause.js.
+
+const reader = new stream.Readable();
+const writer1 = new stream.Writable();
+const writer2 = new stream.Writable();
+const writer3 = new stream.Writable();
+
+// 560000 is chosen here because it is larger than the (default) highWaterMark
+// and will cause `.write()` to return false
+// See: https://github.com/nodejs/node/issues/5820
+const buffer = Buffer.allocUnsafe(560000);
+
+reader._read = () => {};
+
+writer1._write = common.mustCall(function(chunk, encoding, cb) {
+  this.emit('chunk-received');
+  process.nextTick(cb);
+}, 1);
+
+writer1.once('chunk-received', () => {
+  assert.strictEqual(
+    reader._readableState.awaitDrainWriters.size,
+    0,
+    'awaitDrain initial value should be 0, actual is ' +
+    reader._readableState.awaitDrainWriters.size
+  );
+  setImmediate(() => {
+    // This one should *not* get through to writer1 because writer2 is not
+    // "done" processing.
+    reader.push(buffer);
+  });
+});
+
+// A "slow" consumer:
+writer2._write = common.mustCall((chunk, encoding, cb) => {
+  assert.strictEqual(
+    reader._readableState.awaitDrainWriters.size,
+    1,
+    'awaitDrain should be 1 after first push, actual is ' +
+    reader._readableState.awaitDrainWriters.size
+  );
+  // Not calling cb here to "simulate" slow stream.
+  // This should be called exactly once, since the first .write() call
+  // will return false.
+}, 1);
+
+writer3._write = common.mustCall((chunk, encoding, cb) => {
+  assert.strictEqual(
+    reader._readableState.awaitDrainWriters.size,
+    2,
+    'awaitDrain should be 2 after second push, actual is ' +
+    reader._readableState.awaitDrainWriters.size
+  );
+  // Not calling cb here to "simulate" slow stream.
+  // This should be called exactly once, since the first .write() call
+  // will return false.
+}, 1);
+
+reader.pipe(writer1);
+reader.pipe(writer2);
+reader.pipe(writer3);
+reader.push(buffer);
diff --git a/test/js/node/test/parallel/test-stream-pipe-cleanup-pause.js b/test/js/node/test/parallel/test-stream-pipe-cleanup-pause.js
new file mode 100644
index 0000000000..3cdab94648
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-pipe-cleanup-pause.js
@@ -0,0 +1,37 @@
+'use strict';
+const common = require('../common');
+const stream = require('stream');
+
+const reader = new stream.Readable();
+const writer1 = new stream.Writable();
+const writer2 = new stream.Writable();
+
+// 560000 is chosen here because it is larger than the (default) highWaterMark
+// and will cause `.write()` to return false
+// See: https://github.com/nodejs/node/issues/2323
+const buffer = Buffer.allocUnsafe(560000);
+
+reader._read = () => {};
+
+writer1._write = common.mustCall(function(chunk, encoding, cb) {
+  this.emit('chunk-received');
+  cb();
+}, 1);
+writer1.once('chunk-received', function() {
+  reader.unpipe(writer1);
+  reader.pipe(writer2);
+  reader.push(buffer);
+  setImmediate(function() {
+    reader.push(buffer);
+    setImmediate(function() {
+      reader.push(buffer);
+    });
+  });
+});
+
+writer2._write = common.mustCall(function(chunk, encoding, cb) {
+  cb();
+}, 3);
+
+reader.pipe(writer1);
+reader.push(buffer);
diff --git a/test/js/node/test/parallel/test-stream-pipe-cleanup.js b/test/js/node/test/parallel/test-stream-pipe-cleanup.js
new file mode 100644
index 0000000000..cdb4d503d6
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-pipe-cleanup.js
@@ -0,0 +1,125 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+// This test asserts that Stream.prototype.pipe does not leave listeners
+// hanging on the source or dest.
+require('../common');
+const stream = require('stream');
+const assert = require('assert');
+
+function Writable() {
+  this.writable = true;
+  this.endCalls = 0;
+  stream.Stream.call(this);
+}
+Object.setPrototypeOf(Writable.prototype, stream.Stream.prototype);
+Object.setPrototypeOf(Writable, stream.Stream);
+Writable.prototype.end = function() {
+  this.endCalls++;
+};
+
+Writable.prototype.destroy = function() {
+  this.endCalls++;
+};
+
+function Readable() {
+  this.readable = true;
+  stream.Stream.call(this);
+}
+Object.setPrototypeOf(Readable.prototype, stream.Stream.prototype);
+Object.setPrototypeOf(Readable, stream.Stream);
+
+function Duplex() {
+  this.readable = true;
+  Writable.call(this);
+}
+Object.setPrototypeOf(Duplex.prototype, Writable.prototype);
+Object.setPrototypeOf(Duplex, Writable);
+
+let i = 0;
+const limit = 100;
+
+let w = new Writable();
+
+let r;
+
+for (i = 0; i < limit; i++) {
+  r = new Readable();
+  r.pipe(w);
+  r.emit('end');
+}
+assert.strictEqual(r.listeners('end').length, 0);
+assert.strictEqual(w.endCalls, limit);
+
+w.endCalls = 0;
+
+for (i = 0; i < limit; i++) {
+  r = new Readable();
+  r.pipe(w);
+  r.emit('close');
+}
+assert.strictEqual(r.listeners('close').length, 0);
+assert.strictEqual(w.endCalls, limit);
+
+w.endCalls = 0;
+
+r = new Readable();
+
+for (i = 0; i < limit; i++) {
+  w = new Writable();
+  r.pipe(w);
+  w.emit('close');
+}
+assert.strictEqual(w.listeners('close').length, 0);
+
+r = new Readable();
+w = new Writable();
+const d = new Duplex();
+r.pipe(d); // pipeline A
+d.pipe(w); // pipeline B
+assert.strictEqual(r.listeners('end').length, 2);   // A.onend, A.cleanup
+assert.strictEqual(r.listeners('close').length, 2); // A.onclose, A.cleanup
+assert.strictEqual(d.listeners('end').length, 2);   // B.onend, B.cleanup
+// A.cleanup, B.onclose, B.cleanup
+assert.strictEqual(d.listeners('close').length, 3);
+assert.strictEqual(w.listeners('end').length, 0);
+assert.strictEqual(w.listeners('close').length, 1); // B.cleanup
+
+r.emit('end');
+assert.strictEqual(d.endCalls, 1);
+assert.strictEqual(w.endCalls, 0);
+assert.strictEqual(r.listeners('end').length, 0);
+assert.strictEqual(r.listeners('close').length, 0);
+assert.strictEqual(d.listeners('end').length, 2);   // B.onend, B.cleanup
+assert.strictEqual(d.listeners('close').length, 2); // B.onclose, B.cleanup
+assert.strictEqual(w.listeners('end').length, 0);
+assert.strictEqual(w.listeners('close').length, 1); // B.cleanup
+
+d.emit('end');
+assert.strictEqual(d.endCalls, 1);
+assert.strictEqual(w.endCalls, 1);
+assert.strictEqual(r.listeners('end').length, 0);
+assert.strictEqual(r.listeners('close').length, 0);
+assert.strictEqual(d.listeners('end').length, 0);
+assert.strictEqual(d.listeners('close').length, 0);
+assert.strictEqual(w.listeners('end').length, 0);
+assert.strictEqual(w.listeners('close').length, 0);
diff --git a/test/js/node/test/parallel/test-stream-pipe-error-handling.js b/test/js/node/test/parallel/test-stream-pipe-error-handling.js
new file mode 100644
index 0000000000..cf3a3699d0
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-pipe-error-handling.js
@@ -0,0 +1,124 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const { Stream, PassThrough } = require('stream');
+
+{
+  const source = new Stream();
+  const dest = new Stream();
+
+  source.pipe(dest);
+
+  let gotErr = null;
+  source.on('error', function(err) {
+    gotErr = err;
+  });
+
+  const err = new Error('This stream turned into bacon.');
+  source.emit('error', err);
+  assert.strictEqual(gotErr, err);
+}
+
+{
+  const source = new Stream();
+  const dest = new Stream();
+
+  source.pipe(dest);
+
+  const err = new Error('This stream turned into bacon.');
+
+  let gotErr = null;
+  try {
+    source.emit('error', err);
+  } catch (e) {
+    gotErr = e;
+  }
+
+  assert.strictEqual(gotErr, err);
+}
+
+{
+  const R = Stream.Readable;
+  const W = Stream.Writable;
+
+  const r = new R({ autoDestroy: false });
+  const w = new W({ autoDestroy: false });
+  let removed = false;
+
+  r._read = common.mustCall(function() {
+    setTimeout(common.mustCall(function() {
+      assert(removed);
+      assert.throws(function() {
+        w.emit('error', new Error('fail'));
+      }, /^Error: fail$/);
+    }), 1);
+  });
+
+  w.on('error', myOnError);
+  r.pipe(w);
+  w.removeListener('error', myOnError);
+  removed = true;
+
+  function myOnError() {
+    throw new Error('this should not happen');
+  }
+}
+
+{
+  const R = Stream.Readable;
+  const W = Stream.Writable;
+
+  const r = new R();
+  const w = new W();
+  let removed = false;
+
+  r._read = common.mustCall(function() {
+    setTimeout(common.mustCall(function() {
+      assert(removed);
+      w.emit('error', new Error('fail'));
+    }), 1);
+  });
+
+  w.on('error', common.mustCall());
+  w._write = () => {};
+
+  r.pipe(w);
+  // Removing some OTHER random listener should not do anything
+  w.removeListener('error', () => {});
+  removed = true;
+}
+
+{
+  const _err = new Error('this should be handled');
+  const destination = new PassThrough();
+  destination.once('error', common.mustCall((err) => {
+    assert.strictEqual(err, _err);
+  }));
+
+  const stream = new Stream();
+  stream
+    .pipe(destination);
+
+  destination.destroy(_err);
+}
diff --git a/test/js/node/test/parallel/test-stream-pipe-error-unhandled.js b/test/js/node/test/parallel/test-stream-pipe-error-unhandled.js
new file mode 100644
index 0000000000..42c1ce77fe
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-pipe-error-unhandled.js
@@ -0,0 +1,21 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const { Readable, Writable } = require('stream');
+
+process.on('uncaughtException', common.mustCall((err) => {
+  assert.strictEqual(err.message, 'asd');
+}));
+
+const r = new Readable({
+  read() {
+    this.push('asd');
+  }
+});
+const w = new Writable({
+  autoDestroy: true,
+  write() {}
+});
+
+r.pipe(w);
+w.destroy(new Error('asd'));
diff --git a/test/js/node/test/parallel/test-stream-pipe-event.js b/test/js/node/test/parallel/test-stream-pipe-event.js
new file mode 100644
index 0000000000..d7772df6a1
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-pipe-event.js
@@ -0,0 +1,51 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const stream = require('stream');
+const assert = require('assert');
+
+function Writable() {
+  this.writable = true;
+  stream.Stream.call(this);
+}
+Object.setPrototypeOf(Writable.prototype, stream.Stream.prototype);
+Object.setPrototypeOf(Writable, stream.Stream);
+
+function Readable() {
+  this.readable = true;
+  stream.Stream.call(this);
+}
+Object.setPrototypeOf(Readable.prototype, stream.Stream.prototype);
+Object.setPrototypeOf(Readable, stream.Stream);
+
+let passed = false;
+
+const w = new Writable();
+w.on('pipe', function(src) {
+  passed = true;
+});
+
+const r = new Readable();
+r.pipe(w);
+
+assert.ok(passed);
diff --git a/test/js/node/test/parallel/test-stream-pipe-flow-after-unpipe.js b/test/js/node/test/parallel/test-stream-pipe-flow-after-unpipe.js
new file mode 100644
index 0000000000..048b7ea5e5
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-pipe-flow-after-unpipe.js
@@ -0,0 +1,29 @@
+'use strict';
+const common = require('../common');
+const { Readable, Writable } = require('stream');
+
+// Tests that calling .unpipe() un-blocks a stream that is paused because
+// it is waiting on the writable side to finish a write().
+
+const rs = new Readable({
+  highWaterMark: 1,
+  // That this gets called at least 20 times is the real test here.
+  read: common.mustCallAtLeast(() => rs.push('foo'), 20)
+});
+
+const ws = new Writable({
+  highWaterMark: 1,
+  write: common.mustCall(() => {
+    // Ignore the callback, this write() simply never finishes.
+    setImmediate(() => rs.unpipe(ws));
+  })
+});
+
+let chunks = 0;
+rs.on('data', common.mustCallAtLeast(() => {
+  chunks++;
+  if (chunks >= 20)
+    rs.pause();  // Finish this test.
+}));
+
+rs.pipe(ws);
diff --git a/test/js/node/test/parallel/test-stream-pipe-flow.js b/test/js/node/test/parallel/test-stream-pipe-flow.js
new file mode 100644
index 0000000000..1f2e8f54ce
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-pipe-flow.js
@@ -0,0 +1,90 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const { Readable, Writable, PassThrough } = require('stream');
+
+{
+  let ticks = 17;
+
+  const rs = new Readable({
+    objectMode: true,
+    read: () => {
+      if (ticks-- > 0)
+        return process.nextTick(() => rs.push({}));
+      rs.push({});
+      rs.push(null);
+    }
+  });
+
+  const ws = new Writable({
+    highWaterMark: 0,
+    objectMode: true,
+    write: (data, end, cb) => setImmediate(cb)
+  });
+
+  rs.on('end', common.mustCall());
+  ws.on('finish', common.mustCall());
+  rs.pipe(ws);
+}
+
+{
+  let missing = 8;
+
+  const rs = new Readable({
+    objectMode: true,
+    read: () => {
+      if (missing--) rs.push({});
+      else rs.push(null);
+    }
+  });
+
+  const pt = rs
+    .pipe(new PassThrough({ objectMode: true, highWaterMark: 2 }))
+    .pipe(new PassThrough({ objectMode: true, highWaterMark: 2 }));
+
+  pt.on('end', () => {
+    wrapper.push(null);
+  });
+
+  const wrapper = new Readable({
+    objectMode: true,
+    read: () => {
+      process.nextTick(() => {
+        let data = pt.read();
+        if (data === null) {
+          pt.once('readable', () => {
+            data = pt.read();
+            if (data !== null) wrapper.push(data);
+          });
+        } else {
+          wrapper.push(data);
+        }
+      });
+    }
+  });
+
+  wrapper.resume();
+  wrapper.on('end', common.mustCall());
+}
+
+{
+  // Only register drain if there is backpressure.
+  const rs = new Readable({ read() {} });
+
+  const pt = rs
+    .pipe(new PassThrough({ objectMode: true, highWaterMark: 2 }));
+  assert.strictEqual(pt.listenerCount('drain'), 0);
+  pt.on('finish', () => {
+    assert.strictEqual(pt.listenerCount('drain'), 0);
+  });
+
+  rs.push('asd');
+  assert.strictEqual(pt.listenerCount('drain'), 0);
+
+  process.nextTick(() => {
+    rs.push('asd');
+    assert.strictEqual(pt.listenerCount('drain'), 0);
+    rs.push(null);
+    assert.strictEqual(pt.listenerCount('drain'), 0);
+  });
+}
diff --git a/test/js/node/test/parallel/test-stream-pipe-manual-resume.js b/test/js/node/test/parallel/test-stream-pipe-manual-resume.js
new file mode 100644
index 0000000000..08269acfd3
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-pipe-manual-resume.js
@@ -0,0 +1,35 @@
+'use strict';
+const common = require('../common');
+const stream = require('stream');
+
+function test(throwCodeInbetween) {
+  // Check that a pipe does not stall if .read() is called unexpectedly
+  // (i.e. the stream is not resumed by the pipe).
+
+  const n = 1000;
+  let counter = n;
+  const rs = stream.Readable({
+    objectMode: true,
+    read: common.mustCallAtLeast(() => {
+      if (--counter >= 0)
+        rs.push({ counter });
+      else
+        rs.push(null);
+    }, n)
+  });
+
+  const ws = stream.Writable({
+    objectMode: true,
+    write: common.mustCall((data, enc, cb) => {
+      setImmediate(cb);
+    }, n)
+  });
+
+  setImmediate(() => throwCodeInbetween(rs, ws));
+
+  rs.pipe(ws);
+}
+
+test((rs) => rs.read());
+test((rs) => rs.resume());
+test(() => 0);
diff --git a/test/js/node/test/parallel/test-stream-pipe-multiple-pipes.js b/test/js/node/test/parallel/test-stream-pipe-multiple-pipes.js
new file mode 100644
index 0000000000..890c274b9d
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-pipe-multiple-pipes.js
@@ -0,0 +1,51 @@
+'use strict';
+const common = require('../common');
+const stream = require('stream');
+const assert = require('assert');
+
+const readable = new stream.Readable({
+  read: () => {}
+});
+
+const writables = [];
+
+for (let i = 0; i < 5; i++) {
+  const target = new stream.Writable({
+    write: common.mustCall((chunk, encoding, callback) => {
+      target.output.push(chunk);
+      callback();
+    }, 1)
+  });
+  target.output = [];
+
+  target.on('pipe', common.mustCall());
+  readable.pipe(target);
+
+
+  writables.push(target);
+}
+
+const input = Buffer.from([1, 2, 3, 4, 5]);
+
+readable.push(input);
+
+// The pipe() calls will postpone emission of the 'resume' event using nextTick,
+// so no data will be available to the writable streams until then.
+process.nextTick(common.mustCall(() => {
+  for (const target of writables) {
+    assert.deepStrictEqual(target.output, [input]);
+
+    target.on('unpipe', common.mustCall());
+    readable.unpipe(target);
+  }
+
+  readable.push('something else'); // This does not get through.
+  readable.push(null);
+  readable.resume(); // Make sure the 'end' event gets emitted.
+}));
+
+readable.on('end', common.mustCall(() => {
+  for (const target of writables) {
+    assert.deepStrictEqual(target.output, [input]);
+  }
+}));
diff --git a/test/js/node/test/parallel/test-stream-pipe-needDrain.js b/test/js/node/test/parallel/test-stream-pipe-needDrain.js
new file mode 100644
index 0000000000..7faf45417a
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-pipe-needDrain.js
@@ -0,0 +1,31 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { Readable, Writable } = require('stream');
+
+// Pipe should pause temporarily if writable needs drain.
+{
+  const w = new Writable({
+    write(buf, encoding, callback) {
+      process.nextTick(callback);
+    },
+    highWaterMark: 1
+  });
+
+  while (w.write('asd'));
+
+  assert.strictEqual(w.writableNeedDrain, true);
+
+  const r = new Readable({
+    read() {
+      this.push('asd');
+      this.push(null);
+    }
+  });
+
+  r.on('pause', common.mustCall(2));
+  r.on('end', common.mustCall());
+
+  r.pipe(w);
+}
diff --git a/test/js/node/test/parallel/test-stream-pipe-same-destination-twice.js b/test/js/node/test/parallel/test-stream-pipe-same-destination-twice.js
new file mode 100644
index 0000000000..ff71639588
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-pipe-same-destination-twice.js
@@ -0,0 +1,78 @@
+'use strict';
+const common = require('../common');
+
+// Regression test for https://github.com/nodejs/node/issues/12718.
+// Tests that piping a source stream twice to the same destination stream
+// works, and that a subsequent unpipe() call only removes the pipe *once*.
+const assert = require('assert');
+const { PassThrough, Writable } = require('stream');
+
+{
+  const passThrough = new PassThrough();
+  const dest = new Writable({
+    write: common.mustCall((chunk, encoding, cb) => {
+      assert.strictEqual(`${chunk}`, 'foobar');
+      cb();
+    })
+  });
+
+  passThrough.pipe(dest);
+  passThrough.pipe(dest);
+
+  assert.strictEqual(passThrough._events.data.length, 2);
+  assert.strictEqual(passThrough._readableState.pipes.length, 2);
+  assert.strictEqual(passThrough._readableState.pipes[0], dest);
+  assert.strictEqual(passThrough._readableState.pipes[1], dest);
+
+  passThrough.unpipe(dest);
+
+  assert.strictEqual(passThrough._events.data.length, 1);
+  assert.strictEqual(passThrough._readableState.pipes.length, 1);
+  assert.deepStrictEqual(passThrough._readableState.pipes, [dest]);
+
+  passThrough.write('foobar');
+  passThrough.pipe(dest);
+}
+
+{
+  const passThrough = new PassThrough();
+  const dest = new Writable({
+    write: common.mustCall((chunk, encoding, cb) => {
+      assert.strictEqual(`${chunk}`, 'foobar');
+      cb();
+    }, 2)
+  });
+
+  passThrough.pipe(dest);
+  passThrough.pipe(dest);
+
+  assert.strictEqual(passThrough._events.data.length, 2);
+  assert.strictEqual(passThrough._readableState.pipes.length, 2);
+  assert.strictEqual(passThrough._readableState.pipes[0], dest);
+  assert.strictEqual(passThrough._readableState.pipes[1], dest);
+
+  passThrough.write('foobar');
+}
+
+{
+  const passThrough = new PassThrough();
+  const dest = new Writable({
+    write: common.mustNotCall()
+  });
+
+  passThrough.pipe(dest);
+  passThrough.pipe(dest);
+
+  assert.strictEqual(passThrough._events.data.length, 2);
+  assert.strictEqual(passThrough._readableState.pipes.length, 2);
+  assert.strictEqual(passThrough._readableState.pipes[0], dest);
+  assert.strictEqual(passThrough._readableState.pipes[1], dest);
+
+  passThrough.unpipe(dest);
+  passThrough.unpipe(dest);
+
+  assert.strictEqual(passThrough._events.data, undefined);
+  assert.strictEqual(passThrough._readableState.pipes.length, 0);
+
+  passThrough.write('foobar');
+}
diff --git a/test/js/node/test/parallel/test-stream-pipe-unpipe-streams.js b/test/js/node/test/parallel/test-stream-pipe-unpipe-streams.js
new file mode 100644
index 0000000000..74c4353993
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-pipe-unpipe-streams.js
@@ -0,0 +1,95 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+const { Readable, Writable } = require('stream');
+
+const source = Readable({ read: () => {} });
+const dest1 = Writable({ write: () => {} });
+const dest2 = Writable({ write: () => {} });
+
+source.pipe(dest1);
+source.pipe(dest2);
+
+dest1.on('unpipe', common.mustCall());
+dest2.on('unpipe', common.mustCall());
+
+assert.strictEqual(source._readableState.pipes[0], dest1);
+assert.strictEqual(source._readableState.pipes[1], dest2);
+assert.strictEqual(source._readableState.pipes.length, 2);
+
+// Should be able to unpipe them in the reverse order that they were piped.
+
+source.unpipe(dest2);
+
+assert.deepStrictEqual(source._readableState.pipes, [dest1]);
+assert.notStrictEqual(source._readableState.pipes, dest2);
+
+dest2.on('unpipe', common.mustNotCall());
+source.unpipe(dest2);
+
+source.unpipe(dest1);
+
+assert.strictEqual(source._readableState.pipes.length, 0);
+
+{
+  // Test `cleanup()` if we unpipe all streams.
+  const source = Readable({ read: () => {} });
+  const dest1 = Writable({ write: () => {} });
+  const dest2 = Writable({ write: () => {} });
+
+  let destCount = 0;
+  const srcCheckEventNames = ['end', 'data'];
+  const destCheckEventNames = ['close', 'finish', 'drain', 'error', 'unpipe'];
+
+  const checkSrcCleanup = common.mustCall(() => {
+    assert.strictEqual(source._readableState.pipes.length, 0);
+    assert.strictEqual(source._readableState.flowing, false);
+    for (const eventName of srcCheckEventNames) {
+      assert.strictEqual(
+        source.listenerCount(eventName), 0,
+        `source's '${eventName}' event listeners not removed`
+      );
+    }
+  });
+
+  function checkDestCleanup(dest) {
+    const currentDestId = ++destCount;
+    source.pipe(dest);
+
+    const unpipeChecker = common.mustCall(() => {
+      assert.deepStrictEqual(
+        dest.listeners('unpipe'), [unpipeChecker],
+        `destination{${currentDestId}} should have a 'unpipe' event ` +
+        'listener which is `unpipeChecker`'
+      );
+      dest.removeListener('unpipe', unpipeChecker);
+      for (const eventName of destCheckEventNames) {
+        assert.strictEqual(
+          dest.listenerCount(eventName), 0,
+          `destination{${currentDestId}}'s '${eventName}' event ` +
+          'listeners not removed'
+        );
+      }
+
+      if (--destCount === 0)
+        checkSrcCleanup();
+    });
+
+    dest.on('unpipe', unpipeChecker);
+  }
+
+  checkDestCleanup(dest1);
+  checkDestCleanup(dest2);
+  source.unpipe();
+}
+
+{
+  const src = Readable({ read: () => {} });
+  const dst = Writable({ write: () => {} });
+  src.pipe(dst);
+  src.on('resume', common.mustCall(() => {
+    src.on('pause', common.mustCall());
+    src.unpipe(dst);
+  }));
+}
diff --git a/test/js/node/test/parallel/test-stream-pipeline-async-iterator.js b/test/js/node/test/parallel/test-stream-pipeline-async-iterator.js
new file mode 100644
index 0000000000..06a2ed6ca8
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-pipeline-async-iterator.js
@@ -0,0 +1,31 @@
+'use strict';
+
+const common = require('../common');
+const { Readable, PassThrough, pipeline } = require('stream');
+const assert = require('assert');
+
+const _err = new Error('kaboom');
+
+async function run() {
+  const source = new Readable({
+    read() {
+    }
+  });
+  source.push('hello');
+  source.push('world');
+
+  setImmediate(() => { source.destroy(_err); });
+
+  const iterator = pipeline(
+    source,
+    new PassThrough(),
+    () => {});
+
+  iterator.setEncoding('utf8');
+
+  for await (const k of iterator) {
+    assert.strictEqual(k, 'helloworld');
+  }
+}
+
+run().catch(common.mustCall((err) => assert.strictEqual(err, _err)));
diff --git a/test/js/node/test/parallel/test-stream-pipeline-listeners.js b/test/js/node/test/parallel/test-stream-pipeline-listeners.js
new file mode 100644
index 0000000000..81e287b77c
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-pipeline-listeners.js
@@ -0,0 +1,76 @@
+'use strict';
+
+const common = require('../common');
+const { pipeline, Duplex, PassThrough, Writable } = require('stream');
+const assert = require('assert');
+
+process.on('uncaughtException', common.mustCall((err) => {
+  assert.strictEqual(err.message, 'no way');
+}, 2));
+
+// Ensure that listeners is removed if last stream is readable
+// And other stream's listeners unchanged
+const a = new PassThrough();
+a.end('foobar');
+const b = new Duplex({
+  write(chunk, encoding, callback) {
+    callback();
+  }
+});
+pipeline(a, b, common.mustCall((error) => {
+  if (error) {
+    assert.ifError(error);
+  }
+
+  assert(a.listenerCount('error') > 0);
+  assert.strictEqual(b.listenerCount('error'), 0);
+  setTimeout(() => {
+    assert.strictEqual(b.listenerCount('error'), 0);
+    b.destroy(new Error('no way'));
+  }, 100);
+}));
+
+// Async generators
+const c = new PassThrough();
+c.end('foobar');
+const d = pipeline(
+  c,
+  async function* (source) {
+    for await (const chunk of source) {
+      yield String(chunk).toUpperCase();
+    }
+  },
+  common.mustCall((error) => {
+    if (error) {
+      assert.ifError(error);
+    }
+
+    assert(c.listenerCount('error') > 0);
+    assert.strictEqual(d.listenerCount('error'), 0);
+    setTimeout(() => {
+      assert.strictEqual(b.listenerCount('error'), 0);
+      d.destroy(new Error('no way'));
+    }, 100);
+  })
+);
+
+// If last stream is not readable, will not throw and remove listeners
+const e = new PassThrough();
+e.end('foobar');
+const f = new Writable({
+  write(chunk, encoding, callback) {
+    callback();
+  }
+});
+pipeline(e, f, common.mustCall((error) => {
+  if (error) {
+    assert.ifError(error);
+  }
+
+  assert(e.listenerCount('error') > 0);
+  assert(f.listenerCount('error') > 0);
+  setTimeout(() => {
+    assert(f.listenerCount('error') > 0);
+    f.destroy(new Error('no way'));
+  }, 100);
+}));
diff --git a/test/js/node/test/parallel/test-stream-pipeline-process.js b/test/js/node/test/parallel/test-stream-pipeline-process.js
new file mode 100644
index 0000000000..a535e7263e
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-pipeline-process.js
@@ -0,0 +1,26 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const os = require('os');
+
+if (process.argv[2] === 'child') {
+  const { pipeline } = require('stream');
+  pipeline(
+    process.stdin,
+    process.stdout,
+    common.mustSucceed()
+  );
+} else {
+  const cp = require('child_process');
+  cp.exec([
+    'echo',
+    'hello',
+    '|',
+    `"${process.execPath}"`,
+    `"${__filename}"`,
+    'child',
+  ].join(' '), common.mustSucceed((stdout) => {
+    assert.strictEqual(stdout.split(os.EOL).shift().trim(), 'hello');
+  }));
+}
diff --git a/test/js/node/test/parallel/test-stream-pipeline-queued-end-in-destroy.js b/test/js/node/test/parallel/test-stream-pipeline-queued-end-in-destroy.js
new file mode 100644
index 0000000000..480e5b7f72
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-pipeline-queued-end-in-destroy.js
@@ -0,0 +1,39 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const { Readable, Duplex, pipeline } = require('stream');
+
+// Test that the callback for pipeline() is called even when the ._destroy()
+// method of the stream places an .end() request to itself that does not
+// get processed before the destruction of the stream (i.e. the 'close' event).
+// Refs: https://github.com/nodejs/node/issues/24456
+
+const readable = new Readable({
+  read: common.mustCall()
+});
+
+const duplex = new Duplex({
+  write(chunk, enc, cb) {
+    // Simulate messages queueing up.
+  },
+  read() {},
+  destroy(err, cb) {
+    // Call end() from inside the destroy() method, like HTTP/2 streams
+    // do at the time of writing.
+    this.end();
+    cb(err);
+  }
+});
+
+duplex.on('finished', common.mustNotCall());
+
+pipeline(readable, duplex, common.mustCall((err) => {
+  assert.strictEqual(err.code, 'ERR_STREAM_PREMATURE_CLOSE');
+}));
+
+// Write one chunk of data, and destroy the stream later.
+// That should trigger the pipeline destruction.
+readable.push('foo');
+setImmediate(() => {
+  readable.destroy();
+});
diff --git a/test/js/node/test/parallel/test-stream-pipeline-uncaught.js b/test/js/node/test/parallel/test-stream-pipeline-uncaught.js
new file mode 100644
index 0000000000..8aa1c47b7f
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-pipeline-uncaught.js
@@ -0,0 +1,22 @@
+'use strict';
+
+const common = require('../common');
+const {
+  pipeline,
+  PassThrough
+} = require('stream');
+const assert = require('assert');
+
+process.on('uncaughtException', common.mustCall((err) => {
+  assert.strictEqual(err.message, 'error');
+}));
+
+// Ensure that pipeline that ends with Promise
+// still propagates error to uncaughtException.
+const s = new PassThrough();
+s.end('data');
+pipeline(s, async function(source) {
+  for await (const chunk of source) { } // eslint-disable-line no-unused-vars, no-empty
+}, common.mustSucceed(() => {
+  throw new Error('error');
+}));
diff --git a/test/js/node/test/parallel/test-stream-pipeline-with-empty-string.js b/test/js/node/test/parallel/test-stream-pipeline-with-empty-string.js
new file mode 100644
index 0000000000..5df1ff9edf
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-pipeline-with-empty-string.js
@@ -0,0 +1,18 @@
+'use strict';
+
+const common = require('../common');
+const {
+  pipeline,
+  PassThrough
+} = require('stream');
+
+
+async function runTest() {
+  await pipeline(
+    '',
+    new PassThrough({ objectMode: true }),
+    common.mustCall(),
+  );
+}
+
+runTest().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-stream-preprocess.js b/test/js/node/test/parallel/test-stream-preprocess.js
new file mode 100644
index 0000000000..d42c2fd63e
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-preprocess.js
@@ -0,0 +1,60 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+const fs = require('fs');
+const rl = require('readline');
+const fixtures = require('../common/fixtures');
+
+const BOM = '\uFEFF';
+
+// Get the data using a non-stream way to compare with the streamed data.
+const modelData = fixtures.readSync('file-to-read-without-bom.txt', 'utf8');
+const modelDataFirstCharacter = modelData[0];
+
+// Detect the number of forthcoming 'line' events for mustCall() 'expected' arg.
+const lineCount = modelData.match(/\n/g).length;
+
+// Ensure both without-bom and with-bom test files are textwise equal.
+assert.strictEqual(fixtures.readSync('file-to-read-with-bom.txt', 'utf8'),
+                   `${BOM}${modelData}`
+);
+
+// An unjustified BOM stripping with a non-BOM character unshifted to a stream.
+const inputWithoutBOM =
+  fs.createReadStream(fixtures.path('file-to-read-without-bom.txt'), 'utf8');
+
+inputWithoutBOM.once('readable', common.mustCall(() => {
+  const maybeBOM = inputWithoutBOM.read(1);
+  assert.strictEqual(maybeBOM, modelDataFirstCharacter);
+  assert.notStrictEqual(maybeBOM, BOM);
+
+  inputWithoutBOM.unshift(maybeBOM);
+
+  let streamedData = '';
+  rl.createInterface({
+    input: inputWithoutBOM,
+  }).on('line', common.mustCall((line) => {
+    streamedData += `${line}\n`;
+  }, lineCount)).on('close', common.mustCall(() => {
+    assert.strictEqual(streamedData, modelData);
+  }));
+}));
+
+// A justified BOM stripping.
+const inputWithBOM =
+  fs.createReadStream(fixtures.path('file-to-read-with-bom.txt'), 'utf8');
+
+inputWithBOM.once('readable', common.mustCall(() => {
+  const maybeBOM = inputWithBOM.read(1);
+  assert.strictEqual(maybeBOM, BOM);
+
+  let streamedData = '';
+  rl.createInterface({
+    input: inputWithBOM,
+  }).on('line', common.mustCall((line) => {
+    streamedData += `${line}\n`;
+  }, lineCount)).on('close', common.mustCall(() => {
+    assert.strictEqual(streamedData, modelData);
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-stream-push-order.js b/test/js/node/test/parallel/test-stream-push-order.js
new file mode 100644
index 0000000000..f026cb5b8a
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-push-order.js
@@ -0,0 +1,52 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const Readable = require('stream').Readable;
+const assert = require('assert');
+
+const s = new Readable({
+  highWaterMark: 20,
+  encoding: 'ascii'
+});
+
+const list = ['1', '2', '3', '4', '5', '6'];
+
+s._read = function(n) {
+  const one = list.shift();
+  if (!one) {
+    s.push(null);
+  } else {
+    const two = list.shift();
+    s.push(one);
+    s.push(two);
+  }
+};
+
+s.read(0);
+
+// ACTUALLY [1, 3, 5, 6, 4, 2]
+
+process.on('exit', function() {
+  assert.strictEqual(s.readableBuffer.join(','), '1,2,3,4,5,6');
+  console.log('ok');
+});
diff --git a/test/js/node/test/parallel/test-stream-push-strings.js b/test/js/node/test/parallel/test-stream-push-strings.js
new file mode 100644
index 0000000000..d582c8add0
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-push-strings.js
@@ -0,0 +1,67 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+
+const Readable = require('stream').Readable;
+
+class MyStream extends Readable {
+  constructor(options) {
+    super(options);
+    this._chunks = 3;
+  }
+
+  _read(n) {
+    switch (this._chunks--) {
+      case 0:
+        return this.push(null);
+      case 1:
+        return setTimeout(() => {
+          this.push('last chunk');
+        }, 100);
+      case 2:
+        return this.push('second to last chunk');
+      case 3:
+        return process.nextTick(() => {
+          this.push('first chunk');
+        });
+      default:
+        throw new Error('?');
+    }
+  }
+}
+
+const ms = new MyStream();
+const results = [];
+ms.on('readable', function() {
+  let chunk;
+  while (null !== (chunk = ms.read()))
+    results.push(String(chunk));
+});
+
+const expect = [ 'first chunksecond to last chunk', 'last chunk' ];
+process.on('exit', function() {
+  assert.strictEqual(ms._chunks, -1);
+  assert.deepStrictEqual(results, expect);
+  console.log('ok');
+});
diff --git a/test/js/node/test/parallel/test-stream-readable-aborted.js b/test/js/node/test/parallel/test-stream-readable-aborted.js
new file mode 100644
index 0000000000..9badffc51f
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-readable-aborted.js
@@ -0,0 +1,66 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { Readable, Duplex } = require('stream');
+
+{
+  const readable = new Readable({
+    read() {
+    }
+  });
+  assert.strictEqual(readable.readableAborted, false);
+  readable.destroy();
+  assert.strictEqual(readable.readableAborted, true);
+}
+
+{
+  const readable = new Readable({
+    read() {
+    }
+  });
+  assert.strictEqual(readable.readableAborted, false);
+  readable.push(null);
+  readable.destroy();
+  assert.strictEqual(readable.readableAborted, true);
+}
+
+{
+  const readable = new Readable({
+    read() {
+    }
+  });
+  assert.strictEqual(readable.readableAborted, false);
+  readable.push('asd');
+  readable.destroy();
+  assert.strictEqual(readable.readableAborted, true);
+}
+
+{
+  const readable = new Readable({
+    read() {
+    }
+  });
+  assert.strictEqual(readable.readableAborted, false);
+  readable.push('asd');
+  readable.push(null);
+  assert.strictEqual(readable.readableAborted, false);
+  readable.on('end', common.mustCall(() => {
+    assert.strictEqual(readable.readableAborted, false);
+    readable.destroy();
+    assert.strictEqual(readable.readableAborted, false);
+    queueMicrotask(() => {
+      assert.strictEqual(readable.readableAborted, false);
+    });
+  }));
+  readable.resume();
+}
+
+{
+  const duplex = new Duplex({
+    readable: false,
+    write() {}
+  });
+  duplex.destroy();
+  assert.strictEqual(duplex.readableAborted, false);
+}
diff --git a/test/js/node/test/parallel/test-stream-readable-add-chunk-during-data.js b/test/js/node/test/parallel/test-stream-readable-add-chunk-during-data.js
new file mode 100644
index 0000000000..6c36359790
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-readable-add-chunk-during-data.js
@@ -0,0 +1,21 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const { Readable } = require('stream');
+
+// Verify that .push() and .unshift() can be called from 'data' listeners.
+
+for (const method of ['push', 'unshift']) {
+  const r = new Readable({ read() {} });
+  r.once('data', common.mustCall((chunk) => {
+    assert.strictEqual(r.readableLength, 0);
+    r[method](chunk);
+    assert.strictEqual(r.readableLength, chunk.length);
+
+    r.on('data', common.mustCall((chunk) => {
+      assert.strictEqual(chunk.toString(), 'Hello, world');
+    }));
+  }));
+
+  r.push('Hello, world');
+}
diff --git a/test/js/node/test/parallel/test-stream-readable-constructor-set-methods.js b/test/js/node/test/parallel/test-stream-readable-constructor-set-methods.js
new file mode 100644
index 0000000000..1b9f0496b9
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-readable-constructor-set-methods.js
@@ -0,0 +1,11 @@
+'use strict';
+const common = require('../common');
+
+const Readable = require('stream').Readable;
+
+const _read = common.mustCall(function _read(n) {
+  this.push(null);
+});
+
+const r = new Readable({ read: _read });
+r.resume();
diff --git a/test/js/node/test/parallel/test-stream-readable-data.js b/test/js/node/test/parallel/test-stream-readable-data.js
new file mode 100644
index 0000000000..277adddde6
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-readable-data.js
@@ -0,0 +1,19 @@
+'use strict';
+const common = require('../common');
+
+const { Readable } = require('stream');
+
+const readable = new Readable({
+  read() {}
+});
+
+function read() {}
+
+readable.setEncoding('utf8');
+readable.on('readable', read);
+readable.removeListener('readable', read);
+
+process.nextTick(function() {
+  readable.on('data', common.mustCall());
+  readable.push('hello');
+});
diff --git a/test/js/node/test/parallel/test-stream-readable-destroy.js b/test/js/node/test/parallel/test-stream-readable-destroy.js
new file mode 100644
index 0000000000..fb7da632f7
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-readable-destroy.js
@@ -0,0 +1,405 @@
+'use strict';
+
+const common = require('../common');
+const { Readable, addAbortSignal } = require('stream');
+const assert = require('assert');
+
+{
+  const read = new Readable({
+    read() {}
+  });
+  read.resume();
+
+  read.on('close', common.mustCall());
+
+  read.destroy();
+  assert.strictEqual(read.errored, null);
+  assert.strictEqual(read.destroyed, true);
+}
+
+{
+  const read = new Readable({
+    read() {}
+  });
+  read.resume();
+
+  const expected = new Error('kaboom');
+
+  read.on('end', common.mustNotCall('no end event'));
+  read.on('close', common.mustCall());
+  read.on('error', common.mustCall((err) => {
+    assert.strictEqual(err, expected);
+  }));
+
+  read.destroy(expected);
+  assert.strictEqual(read.errored, expected);
+  assert.strictEqual(read.destroyed, true);
+}
+
+{
+  const read = new Readable({
+    read() {}
+  });
+
+  read._destroy = common.mustCall(function(err, cb) {
+    assert.strictEqual(err, expected);
+    cb(err);
+  });
+
+  const expected = new Error('kaboom');
+
+  read.on('end', common.mustNotCall('no end event'));
+  read.on('close', common.mustCall());
+  read.on('error', common.mustCall((err) => {
+    assert.strictEqual(err, expected);
+  }));
+
+  read.destroy(expected);
+  assert.strictEqual(read.destroyed, true);
+}
+
+{
+  const read = new Readable({
+    read() {},
+    destroy: common.mustCall(function(err, cb) {
+      assert.strictEqual(err, expected);
+      cb();
+    })
+  });
+
+  const expected = new Error('kaboom');
+
+  read.on('end', common.mustNotCall('no end event'));
+
+  // Error is swallowed by the custom _destroy
+  read.on('error', common.mustNotCall('no error event'));
+  read.on('close', common.mustCall());
+
+  read.destroy(expected);
+  assert.strictEqual(read.destroyed, true);
+}
+
+{
+  const read = new Readable({
+    read() {}
+  });
+
+  read._destroy = common.mustCall(function(err, cb) {
+    assert.strictEqual(err, null);
+    cb();
+  });
+
+  read.destroy();
+  assert.strictEqual(read.destroyed, true);
+}
+
+{
+  const read = new Readable({
+    read() {}
+  });
+  read.resume();
+
+  read._destroy = common.mustCall(function(err, cb) {
+    assert.strictEqual(err, null);
+    process.nextTick(() => {
+      this.push(null);
+      cb();
+    });
+  });
+
+  const fail = common.mustNotCall('no end event');
+
+  read.on('end', fail);
+  read.on('close', common.mustCall());
+
+  read.destroy();
+
+  read.removeListener('end', fail);
+  read.on('end', common.mustNotCall());
+  assert.strictEqual(read.destroyed, true);
+}
+
+{
+  const read = new Readable({
+    read() {}
+  });
+
+  const expected = new Error('kaboom');
+
+  read._destroy = common.mustCall(function(err, cb) {
+    assert.strictEqual(err, null);
+    cb(expected);
+  });
+
+  let ticked = false;
+  read.on('end', common.mustNotCall('no end event'));
+  read.on('error', common.mustCall((err) => {
+    assert.strictEqual(ticked, true);
+    assert.strictEqual(read._readableState.errorEmitted, true);
+    assert.strictEqual(read._readableState.errored, expected);
+    assert.strictEqual(err, expected);
+  }));
+
+  read.destroy();
+  assert.strictEqual(read._readableState.errorEmitted, false);
+  assert.strictEqual(read._readableState.errored, expected);
+  assert.strictEqual(read.destroyed, true);
+  ticked = true;
+}
+
+{
+  const read = new Readable({
+    read() {}
+  });
+  read.resume();
+
+  read.destroyed = true;
+  assert.strictEqual(read.destroyed, true);
+
+  // The internal destroy() mechanism should not be triggered
+  read.on('end', common.mustNotCall());
+  read.destroy();
+}
+
+{
+  function MyReadable() {
+    assert.strictEqual(this.destroyed, false);
+    this.destroyed = false;
+    Readable.call(this);
+  }
+
+  Object.setPrototypeOf(MyReadable.prototype, Readable.prototype);
+  Object.setPrototypeOf(MyReadable, Readable);
+
+  new MyReadable();
+}
+
+{
+  // Destroy and destroy callback
+  const read = new Readable({
+    read() {}
+  });
+  read.resume();
+
+  const expected = new Error('kaboom');
+
+  let ticked = false;
+  read.on('close', common.mustCall(() => {
+    assert.strictEqual(read._readableState.errorEmitted, true);
+    assert.strictEqual(ticked, true);
+  }));
+  read.on('error', common.mustCall((err) => {
+    assert.strictEqual(err, expected);
+  }));
+
+  assert.strictEqual(read._readableState.errored, null);
+  assert.strictEqual(read._readableState.errorEmitted, false);
+
+  read.destroy(expected, common.mustCall(function(err) {
+    assert.strictEqual(read._readableState.errored, expected);
+    assert.strictEqual(err, expected);
+  }));
+  assert.strictEqual(read._readableState.errorEmitted, false);
+  assert.strictEqual(read._readableState.errored, expected);
+  ticked = true;
+}
+
+{
+  const readable = new Readable({
+    destroy: common.mustCall(function(err, cb) {
+      process.nextTick(cb, new Error('kaboom 1'));
+    }),
+    read() {}
+  });
+
+  let ticked = false;
+  readable.on('close', common.mustCall(() => {
+    assert.strictEqual(ticked, true);
+    assert.strictEqual(readable._readableState.errorEmitted, true);
+  }));
+  readable.on('error', common.mustCall((err) => {
+    assert.strictEqual(ticked, true);
+    assert.strictEqual(err.message, 'kaboom 1');
+    assert.strictEqual(readable._readableState.errorEmitted, true);
+  }));
+
+  readable.destroy();
+  assert.strictEqual(readable.destroyed, true);
+  assert.strictEqual(readable._readableState.errored, null);
+  assert.strictEqual(readable._readableState.errorEmitted, false);
+
+  // Test case where `readable.destroy()` is called again with an error before
+  // the `_destroy()` callback is called.
+  readable.destroy(new Error('kaboom 2'));
+  assert.strictEqual(readable._readableState.errorEmitted, false);
+  assert.strictEqual(readable._readableState.errored, null);
+
+  ticked = true;
+}
+
+{
+  const read = new Readable({
+    read() {}
+  });
+
+  read.destroy();
+  read.push('hi');
+  read.on('data', common.mustNotCall());
+}
+
+{
+  const read = new Readable({
+    read: common.mustNotCall()
+  });
+  read.destroy();
+  assert.strictEqual(read.destroyed, true);
+  read.read();
+}
+
+{
+  const read = new Readable({
+    autoDestroy: false,
+    read() {
+      this.push(null);
+      this.push('asd');
+    }
+  });
+
+  read.on('error', common.mustCall(() => {
+    assert(read._readableState.errored);
+  }));
+  read.resume();
+}
+
+{
+  const controller = new AbortController();
+  const read = addAbortSignal(controller.signal, new Readable({
+    read() {
+      this.push('asd');
+    },
+  }));
+
+  read.on('error', common.mustCall((e) => {
+    assert.strictEqual(e.name, 'AbortError');
+  }));
+  controller.abort();
+  read.on('data', common.mustNotCall());
+}
+
+{
+  const controller = new AbortController();
+  const read = new Readable({
+    signal: controller.signal,
+    read() {
+      this.push('asd');
+    },
+  });
+
+  read.on('error', common.mustCall((e) => {
+    assert.strictEqual(e.name, 'AbortError');
+  }));
+  controller.abort();
+  read.on('data', common.mustNotCall());
+}
+
+{
+  const controller = new AbortController();
+  const read = addAbortSignal(controller.signal, new Readable({
+    objectMode: true,
+    read() {
+      return false;
+    }
+  }));
+  read.push('asd');
+
+  read.on('error', common.mustCall((e) => {
+    assert.strictEqual(e.name, 'AbortError');
+  }));
+  assert.rejects((async () => {
+    // eslint-disable-next-line no-unused-vars, no-empty
+    for await (const chunk of read) { }
+  })(), /AbortError/).then(common.mustCall());
+  setTimeout(() => controller.abort(), 0);
+}
+
+{
+  const read = new Readable({
+    read() {
+    },
+  });
+
+  read.on('data', common.mustNotCall());
+  read.on('error', common.mustCall((e) => {
+    read.push('asd');
+    read.read();
+  }));
+  read.on('close', common.mustCall((e) => {
+    read.push('asd');
+    read.read();
+  }));
+  read.destroy(new Error('asd'));
+}
+
+{
+  const read = new Readable({
+    read() {
+    },
+  });
+
+  read.on('data', common.mustNotCall());
+  read.on('close', common.mustCall((e) => {
+    read.push('asd');
+    read.read();
+  }));
+  read.destroy();
+}
+
+{
+  const read = new Readable({
+    read() {
+    },
+  });
+
+  read.on('data', common.mustNotCall());
+  read.on('close', common.mustCall((e) => {
+    read.push('asd');
+    read.unshift('asd');
+  }));
+  read.destroy();
+}
+
+{
+  const read = new Readable({
+    read() {
+    },
+  });
+
+  read.on('data', common.mustNotCall());
+  read.destroy();
+  read.unshift('asd');
+}
+
+{
+  const read = new Readable({
+    read() {
+    },
+  });
+
+  read.resume();
+  read.on('data', common.mustNotCall());
+  read.on('close', common.mustCall((e) => {
+    read.push('asd');
+  }));
+  read.destroy();
+}
+
+{
+  const read = new Readable({
+    read() {
+    },
+  });
+
+  read.on('data', common.mustNotCall());
+  read.destroy();
+  read.push('asd');
+}
diff --git a/test/js/node/test/parallel/test-stream-readable-didRead.js b/test/js/node/test/parallel/test-stream-readable-didRead.js
new file mode 100644
index 0000000000..878340ba19
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-readable-didRead.js
@@ -0,0 +1,111 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const { isDisturbed, isErrored, Readable } = require('stream');
+
+function noop() {}
+
+function check(readable, data, fn) {
+  assert.strictEqual(readable.readableDidRead, false);
+  assert.strictEqual(isDisturbed(readable), false);
+  assert.strictEqual(isErrored(readable), false);
+  if (data === -1) {
+    readable.on('error', common.mustCall(() => {
+      assert.strictEqual(isErrored(readable), true);
+    }));
+    readable.on('data', common.mustNotCall());
+    readable.on('end', common.mustNotCall());
+  } else {
+    readable.on('error', common.mustNotCall());
+    if (data === -2) {
+      readable.on('end', common.mustNotCall());
+    } else {
+      readable.on('end', common.mustCall());
+    }
+    if (data > 0) {
+      readable.on('data', common.mustCallAtLeast(data));
+    } else {
+      readable.on('data', common.mustNotCall());
+    }
+  }
+  readable.on('close', common.mustCall());
+  fn();
+  setImmediate(() => {
+    assert.strictEqual(readable.readableDidRead, data > 0);
+    if (data > 0) {
+      assert.strictEqual(isDisturbed(readable), true);
+    }
+  });
+}
+
+{
+  const readable = new Readable({
+    read() {
+      this.push(null);
+    }
+  });
+  check(readable, 0, () => {
+    readable.read();
+  });
+}
+
+{
+  const readable = new Readable({
+    read() {
+      this.push(null);
+    }
+  });
+  check(readable, 0, () => {
+    readable.resume();
+  });
+}
+
+{
+  const readable = new Readable({
+    read() {
+      this.push(null);
+    }
+  });
+  check(readable, -2, () => {
+    readable.destroy();
+  });
+}
+
+{
+  const readable = new Readable({
+    read() {
+      this.push(null);
+    }
+  });
+
+  check(readable, -1, () => {
+    readable.destroy(new Error());
+  });
+}
+
+{
+  const readable = new Readable({
+    read() {
+      this.push('data');
+      this.push(null);
+    }
+  });
+
+  check(readable, 1, () => {
+    readable.on('data', noop);
+  });
+}
+
+{
+  const readable = new Readable({
+    read() {
+      this.push('data');
+      this.push(null);
+    }
+  });
+
+  check(readable, 1, () => {
+    readable.on('data', noop);
+    readable.off('data', noop);
+  });
+}
diff --git a/test/js/node/test/parallel/test-stream-readable-emit-readable-short-stream.js b/test/js/node/test/parallel/test-stream-readable-emit-readable-short-stream.js
new file mode 100644
index 0000000000..d8b84bfbe7
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-readable-emit-readable-short-stream.js
@@ -0,0 +1,146 @@
+'use strict';
+
+const common = require('../common');
+const stream = require('stream');
+const assert = require('assert');
+
+{
+  const r = new stream.Readable({
+    read: common.mustCall(function() {
+      this.push('content');
+      this.push(null);
+    })
+  });
+
+  const t = new stream.Transform({
+    transform: common.mustCall(function(chunk, encoding, callback) {
+      this.push(chunk);
+      return callback();
+    }),
+    flush: common.mustCall(function(callback) {
+      return callback();
+    })
+  });
+
+  r.pipe(t);
+  t.on('readable', common.mustCall(function() {
+    while (true) {
+      const chunk = t.read();
+      if (!chunk)
+        break;
+
+      assert.strictEqual(chunk.toString(), 'content');
+    }
+  }, 2));
+}
+
+{
+  const t = new stream.Transform({
+    transform: common.mustCall(function(chunk, encoding, callback) {
+      this.push(chunk);
+      return callback();
+    }),
+    flush: common.mustCall(function(callback) {
+      return callback();
+    })
+  });
+
+  t.end('content');
+
+  t.on('readable', common.mustCall(function() {
+    while (true) {
+      const chunk = t.read();
+      if (!chunk)
+        break;
+      assert.strictEqual(chunk.toString(), 'content');
+    }
+  }));
+}
+
+{
+  const t = new stream.Transform({
+    transform: common.mustCall(function(chunk, encoding, callback) {
+      this.push(chunk);
+      return callback();
+    }),
+    flush: common.mustCall(function(callback) {
+      return callback();
+    })
+  });
+
+  t.write('content');
+  t.end();
+
+  t.on('readable', common.mustCall(function() {
+    while (true) {
+      const chunk = t.read();
+      if (!chunk)
+        break;
+      assert.strictEqual(chunk.toString(), 'content');
+    }
+  }));
+}
+
+{
+  const t = new stream.Readable({
+    read() {
+    }
+  });
+
+  t.on('readable', common.mustCall(function() {
+    while (true) {
+      const chunk = t.read();
+      if (!chunk)
+        break;
+      assert.strictEqual(chunk.toString(), 'content');
+    }
+  }));
+
+  t.push('content');
+  t.push(null);
+}
+
+{
+  const t = new stream.Readable({
+    read() {
+    }
+  });
+
+  t.on('readable', common.mustCall(function() {
+    while (true) {
+      const chunk = t.read();
+      if (!chunk)
+        break;
+      assert.strictEqual(chunk.toString(), 'content');
+    }
+  }, 2));
+
+  process.nextTick(() => {
+    t.push('content');
+    t.push(null);
+  });
+}
+
+{
+  const t = new stream.Transform({
+    transform: common.mustCall(function(chunk, encoding, callback) {
+      this.push(chunk);
+      return callback();
+    }),
+    flush: common.mustCall(function(callback) {
+      return callback();
+    })
+  });
+
+  t.on('readable', common.mustCall(function() {
+    while (true) {
+      const chunk = t.read();
+      if (!chunk)
+        break;
+      assert.strictEqual(chunk.toString(), 'content');
+    }
+  }, 2));
+
+  t.write('content');
+  t.end();
+}
diff --git a/test/js/node/test/parallel/test-stream-readable-emittedReadable.js b/test/js/node/test/parallel/test-stream-readable-emittedReadable.js
new file mode 100644
index 0000000000..ba613f9e9f
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-readable-emittedReadable.js
@@ -0,0 +1,73 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const Readable = require('stream').Readable;
+
+const readable = new Readable({
+  read: () => {}
+});
+
+// Initialized to false.
+assert.strictEqual(readable._readableState.emittedReadable, false);
+
+const expected = [Buffer.from('foobar'), Buffer.from('quo'), null];
+readable.on('readable', common.mustCall(() => {
+  // emittedReadable should be true when the readable event is emitted
+  assert.strictEqual(readable._readableState.emittedReadable, true);
+  assert.deepStrictEqual(readable.read(), expected.shift());
+  // emittedReadable is reset to false during read()
+  assert.strictEqual(readable._readableState.emittedReadable, false);
+}, 3));
+
+// When the first readable listener is just attached,
+// emittedReadable should be false
+assert.strictEqual(readable._readableState.emittedReadable, false);
+
+// These trigger a single 'readable', as things are batched up
+process.nextTick(common.mustCall(() => {
+  readable.push('foo');
+}));
+process.nextTick(common.mustCall(() => {
+  readable.push('bar');
+}));
+
+// These triggers two readable events
+setImmediate(common.mustCall(() => {
+  readable.push('quo');
+  process.nextTick(common.mustCall(() => {
+    readable.push(null);
+  }));
+}));
+
+const noRead = new Readable({
+  read: () => {}
+});
+
+noRead.on('readable', common.mustCall(() => {
+  // emittedReadable should be true when the readable event is emitted
+  assert.strictEqual(noRead._readableState.emittedReadable, true);
+  noRead.read(0);
+  // emittedReadable is not reset during read(0)
+  assert.strictEqual(noRead._readableState.emittedReadable, true);
+}));
+
+noRead.push('foo');
+noRead.push(null);
+
+const flowing = new Readable({
+  read: () => {}
+});
+
+flowing.on('data', common.mustCall(() => {
+  // When in flowing mode, emittedReadable is always false.
+  assert.strictEqual(flowing._readableState.emittedReadable, false);
+  flowing.read();
+  assert.strictEqual(flowing._readableState.emittedReadable, false);
+}, 3));
+
+flowing.push('foooo');
+flowing.push('bar');
+flowing.push('quo');
+process.nextTick(common.mustCall(() => {
+  flowing.push(null);
+}));
diff --git a/test/js/node/test/parallel/test-stream-readable-end-destroyed.js b/test/js/node/test/parallel/test-stream-readable-end-destroyed.js
new file mode 100644
index 0000000000..4b60bf4614
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-readable-end-destroyed.js
@@ -0,0 +1,17 @@
+'use strict';
+
+const common = require('../common');
+const { Readable } = require('stream');
+
+{
+  // Don't emit 'end' after 'close'.
+
+  const r = new Readable();
+
+  r.on('end', common.mustNotCall());
+  r.resume();
+  r.destroy();
+  r.on('close', common.mustCall(() => {
+    r.push(null);
+  }));
+}
diff --git a/test/js/node/test/parallel/test-stream-readable-ended.js b/test/js/node/test/parallel/test-stream-readable-ended.js
new file mode 100644
index 0000000000..bdd714c955
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-readable-ended.js
@@ -0,0 +1,46 @@
+'use strict';
+
+const common = require('../common');
+const { Readable } = require('stream');
+const assert = require('assert');
+
+// basic
+{
+  // Find it on Readable.prototype
+  assert(Object.hasOwn(Readable.prototype, 'readableEnded'));
+}
+
+// event
+{
+  const readable = new Readable();
+
+  readable._read = () => {
+    // The state ended should start in false.
+    assert.strictEqual(readable.readableEnded, false);
+    readable.push('asd');
+    assert.strictEqual(readable.readableEnded, false);
+    readable.push(null);
+    assert.strictEqual(readable.readableEnded, false);
+  };
+
+  readable.on('end', common.mustCall(() => {
+    assert.strictEqual(readable.readableEnded, true);
+  }));
+
+  readable.on('data', common.mustCall(() => {
+    assert.strictEqual(readable.readableEnded, false);
+  }));
+}
+
+// Verifies no `error` triggered on multiple .push(null) invocations
+{
+  const readable = new Readable();
+
+  readable.on('readable', () => { readable.read(); });
+  readable.on('error', common.mustNotCall());
+  readable.on('end', common.mustCall());
+
+  readable.push('a');
+  readable.push(null);
+  readable.push(null);
+}
diff --git a/test/js/node/test/parallel/test-stream-readable-error-end.js b/test/js/node/test/parallel/test-stream-readable-error-end.js
new file mode 100644
index 0000000000..b46fd7f32c
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-readable-error-end.js
@@ -0,0 +1,15 @@
+'use strict';
+
+const common = require('../common');
+const { Readable } = require('stream');
+
+{
+  const r = new Readable({ read() {} });
+
+  r.on('end', common.mustNotCall());
+  r.on('data', common.mustCall());
+  r.on('error', common.mustCall());
+  r.push('asd');
+  r.push(null);
+  r.destroy(new Error('kaboom'));
+}
diff --git a/test/js/node/test/parallel/test-stream-readable-event.js b/test/js/node/test/parallel/test-stream-readable-event.js
new file mode 100644
index 0000000000..4f2383508a
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-readable-event.js
@@ -0,0 +1,128 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+const Readable = require('stream').Readable;
+
+{
+  // First test, not reading when the readable is added.
+  // make sure that on('readable', ...) triggers a readable event.
+  const r = new Readable({
+    highWaterMark: 3
+  });
+
+  r._read = common.mustNotCall();
+
+  // This triggers a 'readable' event, which is lost.
+  r.push(Buffer.from('blerg'));
+
+  setTimeout(function() {
+    // We're testing what we think we are
+    assert(!r._readableState.reading);
+    r.on('readable', common.mustCall());
+  }, 1);
+}
+
+{
+  // Second test, make sure that readable is re-emitted if there's
+  // already a length, while it IS reading.
+
+  const r = new Readable({
+    highWaterMark: 3
+  });
+
+  r._read = common.mustCall();
+
+  // This triggers a 'readable' event, which is lost.
+  r.push(Buffer.from('bl'));
+
+  setTimeout(function() {
+    // Assert we're testing what we think we are
+    assert(r._readableState.reading);
+    r.on('readable', common.mustCall());
+  }, 1);
+}
+
+{
+  // Third test, not reading when the stream has not passed
+  // the highWaterMark but *has* reached EOF.
+  const r = new Readable({
+    highWaterMark: 30
+  });
+
+  r._read = common.mustNotCall();
+
+  // This triggers a 'readable' event, which is lost.
+  r.push(Buffer.from('blerg'));
+  r.push(null);
+
+  setTimeout(function() {
+    // Assert we're testing what we think we are
+    assert(!r._readableState.reading);
+    r.on('readable', common.mustCall());
+  }, 1);
+}
+
+{
+  // Pushing an empty string in non-objectMode should
+  // trigger next `read()`.
+  const underlyingData = ['', 'x', 'y', '', 'z'];
+  const expected = underlyingData.filter((data) => data);
+  const result = [];
+
+  const r = new Readable({
+    encoding: 'utf8',
+  });
+  r._read = function() {
+    process.nextTick(() => {
+      if (!underlyingData.length) {
+        this.push(null);
+      } else {
+        this.push(underlyingData.shift());
+      }
+    });
+  };
+
+  r.on('readable', () => {
+    const data = r.read();
+    if (data !== null) result.push(data);
+  });
+
+  r.on('end', common.mustCall(() => {
+    assert.deepStrictEqual(result, expected);
+  }));
+}
+
+{
+  // #20923
+  const r = new Readable();
+  r._read = function() {
+    // Actually doing thing here
+  };
+  r.on('data', function() {});
+
+  r.removeAllListeners();
+
+  assert.strictEqual(r.eventNames().length, 0);
+}
diff --git a/test/js/node/test/parallel/test-stream-readable-flow-recursion.js b/test/js/node/test/parallel/test-stream-readable-flow-recursion.js
new file mode 100644
index 0000000000..bac6427fb0
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-readable-flow-recursion.js
@@ -0,0 +1,77 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+
+// This test verifies that passing a huge number to read(size)
+// will push up the highWaterMark, and cause the stream to read
+// more data continuously, but without triggering a nextTick
+// warning or RangeError.
+
+const Readable = require('stream').Readable;
+
+// Throw an error if we trigger a nextTick warning.
+process.throwDeprecation = true;
+
+const stream = new Readable({ highWaterMark: 2 });
+let reads = 0;
+let total = 5000;
+stream._read = function(size) {
+  reads++;
+  size = Math.min(size, total);
+  total -= size;
+  if (size === 0)
+    stream.push(null);
+  else
+    stream.push(Buffer.allocUnsafe(size));
+};
+
+let depth = 0;
+
+function flow(stream, size, callback) {
+  depth += 1;
+  const chunk = stream.read(size);
+
+  if (!chunk)
+    stream.once('readable', flow.bind(null, stream, size, callback));
+  else
+    callback(chunk);
+
+  depth -= 1;
+  console.log(`flow(${depth}): exit`);
+}
+
+flow(stream, 5000, function() {
+  console.log(`complete (${depth})`);
+});
+
+process.on('exit', function(code) {
+  assert.strictEqual(reads, 2);
+  // We pushed up the high water mark
+  assert.strictEqual(stream.readableHighWaterMark, 8192);
+  // Length is 0 right now, because we pulled it all out.
+  assert.strictEqual(stream.readableLength, 0);
+  assert(!code);
+  assert.strictEqual(depth, 0);
+  console.log('ok');
+});
diff --git a/test/js/node/test/parallel/test-stream-readable-hwm-0-async.js b/test/js/node/test/parallel/test-stream-readable-hwm-0-async.js
new file mode 100644
index 0000000000..866b524893
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-readable-hwm-0-async.js
@@ -0,0 +1,27 @@
+'use strict';
+
+const common = require('../common');
+
+// This test ensures that Readable stream will continue to call _read
+// for streams with highWaterMark === 0 once the stream returns data
+// by calling push() asynchronously.
+
+const { Readable } = require('stream');
+
+let count = 5;
+
+const r = new Readable({
+  // Called 6 times: First 5 return data, last one signals end of stream.
+  read: common.mustCall(() => {
+    process.nextTick(common.mustCall(() => {
+      if (count--)
+        r.push('a');
+      else
+        r.push(null);
+    }));
+  }, 6),
+  highWaterMark: 0,
+});
+
+r.on('end', common.mustCall());
+r.on('data', common.mustCall(5));
diff --git a/test/js/node/test/parallel/test-stream-readable-hwm-0-no-flow-data.js b/test/js/node/test/parallel/test-stream-readable-hwm-0-no-flow-data.js
new file mode 100644
index 0000000000..5f0186d720
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-readable-hwm-0-no-flow-data.js
@@ -0,0 +1,104 @@
+'use strict';
+
+const common = require('../common');
+
+// Ensure that subscribing the 'data' event will not make the stream flow.
+// The 'data' event will require calling read() by hand.
+//
+// The test is written for the (somewhat rare) highWaterMark: 0 streams to
+// specifically catch any regressions that might occur with these streams.
+
+const assert = require('assert');
+const { Readable } = require('stream');
+
+const streamData = [ 'a', null ];
+
+// Track the calls so we can assert their order later.
+const calls = [];
+const r = new Readable({
+  read: common.mustCall(() => {
+    calls.push('_read:' + streamData[0]);
+    process.nextTick(() => {
+      calls.push('push:' + streamData[0]);
+      r.push(streamData.shift());
+    });
+  }, streamData.length),
+  highWaterMark: 0,
+
+  // Object mode is used here just for testing convenience. It really
+  // shouldn't affect the order of events. Just the data and its format.
+  objectMode: true,
+});
+
+assert.strictEqual(r.readableFlowing, null);
+r.on('readable', common.mustCall(() => {
+  calls.push('readable');
+}, 2));
+assert.strictEqual(r.readableFlowing, false);
+r.on('data', common.mustCall((data) => {
+  calls.push('data:' + data);
+}, 1));
+r.on('end', common.mustCall(() => {
+  calls.push('end');
+}));
+assert.strictEqual(r.readableFlowing, false);
+
+// The stream emits the events asynchronously but that's not guaranteed to
+// happen on the next tick (especially since the _read implementation above
+// uses process.nextTick).
+//
+// We use setImmediate here to give the stream enough time to emit all the
+// events it's about to emit.
+setImmediate(() => {
+
+  // Only the _read, push, readable calls have happened. No data must be
+  // emitted yet.
+  assert.deepStrictEqual(calls, ['_read:a', 'push:a', 'readable']);
+
+  // Calling 'r.read()' should trigger the data event.
+  assert.strictEqual(r.read(), 'a');
+  assert.deepStrictEqual(
+    calls,
+    ['_read:a', 'push:a', 'readable', 'data:a']);
+
+  // The next 'read()' will return null because hwm: 0 does not buffer any
+  // data and the _read implementation above does the push() asynchronously.
+  //
+  // Note: This 'null' signals "no data available". It isn't the end-of-stream
+  // null value as the stream doesn't know yet that it is about to reach the
+  // end.
+  //
+  // Using setImmediate again to give the stream enough time to emit all the
+  // events it wants to emit.
+  assert.strictEqual(r.read(), null);
+  setImmediate(() => {
+
+    // There's a new 'readable' event after the data has been pushed.
+    // The 'end' event will be emitted only after a 'read()'.
+    //
+    // This is somewhat special for the case where the '_read' implementation
+    // calls 'push' asynchronously. If 'push' was synchronous, the 'end' event
+    // would be emitted here _before_ we call read().
+    assert.deepStrictEqual(
+      calls,
+      ['_read:a', 'push:a', 'readable', 'data:a',
+       '_read:null', 'push:null', 'readable']);
+
+    assert.strictEqual(r.read(), null);
+
+    // While it isn't really specified whether the 'end' event should happen
+    // synchronously with read() or not, we'll assert the current behavior
+    // ('end' event happening on the next tick after read()) so any changes
+    // to it are noted and acknowledged in the future.
+    assert.deepStrictEqual(
+      calls,
+      ['_read:a', 'push:a', 'readable', 'data:a',
+       '_read:null', 'push:null', 'readable']);
+    process.nextTick(() => {
+      assert.deepStrictEqual(
+        calls,
+        ['_read:a', 'push:a', 'readable', 'data:a',
+         '_read:null', 'push:null', 'readable', 'end']);
+    });
+  });
+});
diff --git a/test/js/node/test/parallel/test-stream-readable-hwm-0.js b/test/js/node/test/parallel/test-stream-readable-hwm-0.js
new file mode 100644
index 0000000000..5bb17882db
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-readable-hwm-0.js
@@ -0,0 +1,30 @@
+'use strict';
+
+const common = require('../common');
+
+// This test ensures that Readable stream will call _read() for streams
+// with highWaterMark === 0 upon .read(0) instead of just trying to
+// emit 'readable' event.
+
+const assert = require('assert');
+const { Readable } = require('stream');
+
+const r = new Readable({
+  // Must be called only once upon setting 'readable' listener
+  read: common.mustCall(),
+  highWaterMark: 0,
+});
+
+let pushedNull = false;
+// This will trigger read(0) but must only be called after push(null)
+// because the we haven't pushed any data
+r.on('readable', common.mustCall(() => {
+  assert.strictEqual(r.read(), null);
+  assert.strictEqual(pushedNull, true);
+}));
+r.on('end', common.mustCall());
+process.nextTick(() => {
+  assert.strictEqual(r.read(), null);
+  pushedNull = true;
+  r.push(null);
+});
diff --git a/test/js/node/test/parallel/test-stream-readable-infinite-read.js b/test/js/node/test/parallel/test-stream-readable-infinite-read.js
new file mode 100644
index 0000000000..df88d78b74
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-readable-infinite-read.js
@@ -0,0 +1,33 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { Readable } = require('stream');
+
+const buf = Buffer.alloc(8192);
+
+const readable = new Readable({
+  highWaterMark: 16 * 1024,
+  read: common.mustCall(function() {
+    this.push(buf);
+  }, 31)
+});
+
+let i = 0;
+
+readable.on('readable', common.mustCall(function() {
+  if (i++ === 10) {
+    // We will just terminate now.
+    process.removeAllListeners('readable');
+    return;
+  }
+
+  const data = readable.read();
+  // TODO(mcollina): there is something odd in the highWaterMark logic
+  // investigate.
+  if (i === 1) {
+    assert.strictEqual(data.length, 8192 * 2);
+  } else {
+    assert.strictEqual(data.length, 8192 * 3);
+  }
+}, 11));
diff --git a/test/js/node/test/parallel/test-stream-readable-invalid-chunk.js b/test/js/node/test/parallel/test-stream-readable-invalid-chunk.js
new file mode 100644
index 0000000000..0fcc76ae73
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-readable-invalid-chunk.js
@@ -0,0 +1,34 @@
+'use strict';
+
+const common = require('../common');
+const stream = require('stream');
+
+function testPushArg(val) {
+  const readable = new stream.Readable({
+    read: () => {}
+  });
+  readable.on('error', common.expectsError({
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError'
+  }));
+  readable.push(val);
+}
+
+testPushArg([]);
+testPushArg({});
+testPushArg(0);
+
+function testUnshiftArg(val) {
+  const readable = new stream.Readable({
+    read: () => {}
+  });
+  readable.on('error', common.expectsError({
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError'
+  }));
+  readable.unshift(val);
+}
+
+testUnshiftArg([]);
+testUnshiftArg({});
+testUnshiftArg(0);
diff --git a/test/js/node/test/parallel/test-stream-readable-needReadable.js b/test/js/node/test/parallel/test-stream-readable-needReadable.js
new file mode 100644
index 0000000000..c4bc90bb19
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-readable-needReadable.js
@@ -0,0 +1,99 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const Readable = require('stream').Readable;
+
+const readable = new Readable({
+  read: () => {}
+});
+
+// Initialized to false.
+assert.strictEqual(readable._readableState.needReadable, false);
+
+readable.on('readable', common.mustCall(() => {
+  // When the readable event fires, needReadable is reset.
+  assert.strictEqual(readable._readableState.needReadable, false);
+  readable.read();
+}));
+
+// If a readable listener is attached, then a readable event is needed.
+assert.strictEqual(readable._readableState.needReadable, true);
+
+readable.push('foo');
+readable.push(null);
+
+readable.on('end', common.mustCall(() => {
+  // No need to emit readable anymore when the stream ends.
+  assert.strictEqual(readable._readableState.needReadable, false);
+}));
+
+const asyncReadable = new Readable({
+  read: () => {}
+});
+
+asyncReadable.on('readable', common.mustCall(() => {
+  if (asyncReadable.read() !== null) {
+    // After each read(), the buffer is empty.
+    // If the stream doesn't end now,
+    // then we need to notify the reader on future changes.
+    assert.strictEqual(asyncReadable._readableState.needReadable, true);
+  }
+}, 2));
+
+process.nextTick(common.mustCall(() => {
+  asyncReadable.push('foooo');
+}));
+process.nextTick(common.mustCall(() => {
+  asyncReadable.push('bar');
+}));
+setImmediate(common.mustCall(() => {
+  asyncReadable.push(null);
+  assert.strictEqual(asyncReadable._readableState.needReadable, false);
+}));
+
+const flowing = new Readable({
+  read: () => {}
+});
+
+// Notice this must be above the on('data') call.
+flowing.push('foooo');
+flowing.push('bar');
+flowing.push('quo');
+process.nextTick(common.mustCall(() => {
+  flowing.push(null);
+}));
+
+// When the buffer already has enough data, and the stream is
+// in flowing mode, there is no need for the readable event.
+flowing.on('data', common.mustCall(function(data) {
+  assert.strictEqual(flowing._readableState.needReadable, false);
+}, 3));
+
+const slowProducer = new Readable({
+  read: () => {}
+});
+
+slowProducer.on('readable', common.mustCall(() => {
+  const chunk = slowProducer.read(8);
+  const state = slowProducer._readableState;
+  if (chunk === null) {
+    // The buffer doesn't have enough data, and the stream is not need,
+    // we need to notify the reader when data arrives.
+    assert.strictEqual(state.needReadable, true);
+  } else {
+    assert.strictEqual(state.needReadable, false);
+  }
+}, 4));
+
+process.nextTick(common.mustCall(() => {
+  slowProducer.push('foo');
+  process.nextTick(common.mustCall(() => {
+    slowProducer.push('foo');
+    process.nextTick(common.mustCall(() => {
+      slowProducer.push('foo');
+      process.nextTick(common.mustCall(() => {
+        slowProducer.push(null);
+      }));
+    }));
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-stream-readable-next-no-null.js b/test/js/node/test/parallel/test-stream-readable-next-no-null.js
new file mode 100644
index 0000000000..7599e386ca
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-readable-next-no-null.js
@@ -0,0 +1,19 @@
+'use strict';
+const { mustNotCall, expectsError } = require('../common');
+const { Readable } = require('stream');
+
+async function* generate() {
+  yield null;
+}
+
+const stream = Readable.from(generate());
+
+stream.on('error', expectsError({
+  code: 'ERR_STREAM_NULL_VALUES',
+  name: 'TypeError',
+  message: 'May not write null values to stream'
+}));
+
+stream.on('data', mustNotCall());
+
+stream.on('end', mustNotCall());
diff --git a/test/js/node/test/parallel/test-stream-readable-no-unneeded-readable.js b/test/js/node/test/parallel/test-stream-readable-no-unneeded-readable.js
new file mode 100644
index 0000000000..20092b57d9
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-readable-no-unneeded-readable.js
@@ -0,0 +1,62 @@
+'use strict';
+const common = require('../common');
+const { Readable, PassThrough } = require('stream');
+
+function test(r) {
+  const wrapper = new Readable({
+    read: () => {
+      let data = r.read();
+
+      if (data) {
+        wrapper.push(data);
+        return;
+      }
+
+      r.once('readable', function() {
+        data = r.read();
+        if (data) {
+          wrapper.push(data);
+        }
+        // else: the end event should fire
+      });
+    },
+  });
+
+  r.once('end', function() {
+    wrapper.push(null);
+  });
+
+  wrapper.resume();
+  wrapper.once('end', common.mustCall());
+}
+
+{
+  const source = new Readable({
+    read: () => {}
+  });
+  source.push('foo');
+  source.push('bar');
+  source.push(null);
+
+  const pt = source.pipe(new PassThrough());
+  test(pt);
+}
+
+{
+  // This is the underlying cause of the above test case.
+  const pushChunks = ['foo', 'bar'];
+  const r = new Readable({
+    read: () => {
+      const chunk = pushChunks.shift();
+      if (chunk) {
+        // synchronous call
+        r.push(chunk);
+      } else {
+        // asynchronous call
+        process.nextTick(() => r.push(null));
+      }
+    },
+  });
+
+  test(r);
+}
diff --git a/test/js/node/test/parallel/test-stream-readable-object-multi-push-async.js b/test/js/node/test/parallel/test-stream-readable-object-multi-push-async.js
new file mode 100644
index 0000000000..3bdbe4d351
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-readable-object-multi-push-async.js
@@ -0,0 +1,183 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { Readable } = require('stream');
+
+const MAX = 42;
+const BATCH = 10;
+
+{
+  const readable = new Readable({
+    objectMode: true,
+    read: common.mustCall(function() {
+      console.log('>> READ');
+      fetchData((err, data) => {
+        if (err) {
+          this.destroy(err);
+          return;
+        }
+
+        if (data.length === 0) {
+          console.log('pushing null');
+          this.push(null);
+          return;
+        }
+
+        console.log('pushing');
+        data.forEach((d) => this.push(d));
+      });
+    }, Math.floor(MAX / BATCH) + 2)
+  });
+
+  let i = 0;
+  function fetchData(cb) {
+    if (i > MAX) {
+      setTimeout(cb, 10, null, []);
+    } else {
+      const array = [];
+      const max = i + BATCH;
+      for (; i < max; i++) {
+        array.push(i);
+      }
+      setTimeout(cb, 10, null, array);
+    }
+  }
+
+  readable.on('readable', () => {
+    let data;
+    console.log('readable emitted');
+    while ((data = readable.read()) !== null) {
+      console.log(data);
+    }
+  });
+
+  readable.on('end', common.mustCall(() => {
+    assert.strictEqual(i, (Math.floor(MAX / BATCH) + 1) * BATCH);
+  }));
+}
+
+{
+  const readable = new Readable({
+    objectMode: true,
+    read: common.mustCall(function() {
+      console.log('>> READ');
+      fetchData((err, data) => {
+        if (err) {
+          this.destroy(err);
+          return;
+        }
+
+        if (data.length === 0) {
+          console.log('pushing null');
+          this.push(null);
+          return;
+        }
+
+        console.log('pushing');
+        data.forEach((d) => this.push(d));
+      });
+    }, Math.floor(MAX / BATCH) + 2)
+  });
+
+  let i = 0;
+  function fetchData(cb) {
+    if (i > MAX) {
+      setTimeout(cb, 10, null, []);
+    } else {
+      const array = [];
+      const max = i + BATCH;
+      for (; i < max; i++) {
+        array.push(i);
+      }
+      setTimeout(cb, 10, null, array);
+    }
+  }
+
+  readable.on('data', (data) => {
+    console.log('data emitted', data);
+  });
+
+  readable.on('end', common.mustCall(() => {
+    assert.strictEqual(i, (Math.floor(MAX / BATCH) + 1) * BATCH);
+  }));
+}
+
+{
+  const readable = new Readable({
+    objectMode: true,
+    read: common.mustCall(function() {
+      console.log('>> READ');
+      fetchData((err, data) => {
+        if (err) {
+          this.destroy(err);
+          return;
+        }
+
+        console.log('pushing');
+        data.forEach((d) => this.push(d));
+
+        if (data[BATCH - 1] >= MAX) {
+          console.log('pushing null');
+          this.push(null);
+        }
+      });
+    }, Math.floor(MAX / BATCH) + 1)
+  });
+
+  let i = 0;
+  function fetchData(cb) {
+    const array = [];
+    const max = i + BATCH;
+    for (; i < max; i++) {
+      array.push(i);
+    }
+    setTimeout(cb, 10, null, array);
+  }
+
+  readable.on('data', (data) => {
+    console.log('data emitted', data);
+  });
+
+  readable.on('end', common.mustCall(() => {
+    assert.strictEqual(i, (Math.floor(MAX / BATCH) + 1) * BATCH);
+  }));
+}
+
+{
+  const readable = new Readable({
+    objectMode: true,
+    read: common.mustNotCall()
+  });
+
+  readable.on('data', common.mustNotCall());
+
+  readable.push(null);
+
+  let nextTickPassed = false;
+  process.nextTick(() => {
+    nextTickPassed = true;
+  });
+
+  readable.on('end', common.mustCall(() => {
+    assert.strictEqual(nextTickPassed, true);
+  }));
+}
+
+{
+  const readable = new Readable({
+    objectMode: true,
+    read: common.mustCall()
+  });
+
+  readable.on('data', (data) => {
+    console.log('data emitted', data);
+  });
+
+  readable.on('end', common.mustCall());
+
+  setImmediate(() => {
+    readable.push('aaa');
+    readable.push(null);
+  });
+}
diff --git a/test/js/node/test/parallel/test-stream-readable-readable.js b/test/js/node/test/parallel/test-stream-readable-readable.js
new file mode 100644
index 0000000000..6e1a7fb32e
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-readable-readable.js
@@ -0,0 +1,45 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+const { Readable } = require('stream');
+
+{
+  const r = new Readable({
+    read() {}
+  });
+  assert.strictEqual(r.readable, true);
+  r.destroy();
+  assert.strictEqual(r.readable, false);
+}
+
+{
+  const mustNotCall = common.mustNotCall();
+  const r = new Readable({
+    read() {}
+  });
+  assert.strictEqual(r.readable, true);
+  r.on('end', mustNotCall);
+  r.resume();
+  r.push(null);
+  assert.strictEqual(r.readable, true);
+  r.off('end', mustNotCall);
+  r.on('end', common.mustCall(() => {
+    assert.strictEqual(r.readable, false);
+  }));
+}
+
+{
+  const r = new Readable({
+    read: common.mustCall(() => {
+      process.nextTick(() => {
+        r.destroy(new Error());
+        assert.strictEqual(r.readable, false);
+      });
+    })
+  });
+  r.resume();
+  r.on('error', common.mustCall(() => {
+    assert.strictEqual(r.readable, false);
+  }));
+}
diff --git a/test/js/node/test/parallel/test-stream-readable-reading-readingMore.js b/test/js/node/test/parallel/test-stream-readable-reading-readingMore.js
new file mode 100644
index 0000000000..5e39c86dcb
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-readable-reading-readingMore.js
@@ -0,0 +1,171 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const Readable = require('stream').Readable;
+
+{
+  const readable = new Readable({
+    read(size) {}
+  });
+
+  const state = readable._readableState;
+
+  // Starting off with false initially.
+  assert.strictEqual(state.reading, false);
+  assert.strictEqual(state.readingMore, false);
+
+  readable.on('data', common.mustCall((data) => {
+    // While in a flowing state with a 'readable' listener
+    // we should not be reading more
+    if (readable.readableFlowing)
+      assert.strictEqual(state.readingMore, true);
+
+    // Reading as long as we've not ended
+    assert.strictEqual(state.reading, !state.ended);
+  }, 2));
+
+  function onStreamEnd() {
+    // End of stream; state.reading is false
+    // And so should be readingMore.
+    assert.strictEqual(state.readingMore, false);
+    assert.strictEqual(state.reading, false);
+  }
+
+  const expectedReadingMore = [true, true, false];
+  readable.on('readable', common.mustCall(() => {
+    // There is only one readingMore scheduled from on('data'),
+    // after which everything is governed by the .read() call
+    assert.strictEqual(state.readingMore, expectedReadingMore.shift());
+
+    // If the stream has ended, we shouldn't be reading
+    assert.strictEqual(state.ended, !state.reading);
+
+    // Consume all the data
+    while (readable.read() !== null);
+
+    if (expectedReadingMore.length === 0) // Reached end of stream
+      process.nextTick(common.mustCall(onStreamEnd, 1));
+  }, 3));
+
+  readable.on('end', common.mustCall(onStreamEnd));
+  readable.push('pushed');
+
+  readable.read(6);
+
+  // reading
+  assert.strictEqual(state.reading, true);
+  assert.strictEqual(state.readingMore, true);
+
+  // add chunk to front
+  readable.unshift('unshifted');
+
+  // end
+  readable.push(null);
+}
+
+{
+  const readable = new Readable({
+    read(size) {}
+  });
+
+  const state = readable._readableState;
+
+  // Starting off with false initially.
+  assert.strictEqual(state.reading, false);
+  assert.strictEqual(state.readingMore, false);
+
+  readable.on('data', common.mustCall((data) => {
+    // While in a flowing state without a 'readable' listener
+    // we should be reading more
+    if (readable.readableFlowing)
+      assert.strictEqual(state.readingMore, true);
+
+    // Reading as long as we've not ended
+    assert.strictEqual(state.reading, !state.ended);
+  }, 2));
+
+  function onStreamEnd() {
+    // End of stream; state.reading is false
+    // And so should be readingMore.
+    assert.strictEqual(state.readingMore, false);
+    assert.strictEqual(state.reading, false);
+  }
+
+  readable.on('end', common.mustCall(onStreamEnd));
+  readable.push('pushed');
+
+  // Stop emitting 'data' events
+  assert.strictEqual(state.flowing, true);
+  readable.pause();
+
+  // paused
+  assert.strictEqual(state.reading, false);
+  assert.strictEqual(state.flowing, false);
+
+  readable.resume();
+  assert.strictEqual(state.reading, false);
+  assert.strictEqual(state.flowing, true);
+
+  // add chunk to front
+  readable.unshift('unshifted');
+
+  // end
+  readable.push(null);
+}
+
+{
+  const readable = new Readable({
+    read(size) {}
+  });
+
+  const state = readable._readableState;
+
+  // Starting off with false initially.
+  assert.strictEqual(state.reading, false);
+  assert.strictEqual(state.readingMore, false);
+
+  const onReadable = common.mustNotCall();
+
+  readable.on('readable', onReadable);
+
+  readable.on('data', common.mustCall((data) => {
+    // Reading as long as we've not ended
+    assert.strictEqual(state.reading, !state.ended);
+  }, 2));
+
+  readable.removeListener('readable', onReadable);
+
+  function onStreamEnd() {
+    // End of stream; state.reading is false
+    // And so should be readingMore.
+    assert.strictEqual(state.readingMore, false);
+    assert.strictEqual(state.reading, false);
+  }
+
+  readable.on('end', common.mustCall(onStreamEnd));
+  readable.push('pushed');
+
+  // We are still not flowing, we will be resuming in the next tick
+  assert.strictEqual(state.flowing, false);
+
+  // Wait for nextTick, so the readableListener flag resets
+  process.nextTick(function() {
+    readable.resume();
+
+    // Stop emitting 'data' events
+    assert.strictEqual(state.flowing, true);
+    readable.pause();
+
+    // paused
+    assert.strictEqual(state.flowing, false);
+
+    readable.resume();
+    assert.strictEqual(state.flowing, true);
+
+    // add chunk to front
+    readable.unshift('unshifted');
+
+    // end
+    readable.push(null);
+  });
+}
diff --git a/test/js/node/test/parallel/test-stream-readable-resume-hwm.js b/test/js/node/test/parallel/test-stream-readable-resume-hwm.js
new file mode 100644
index 0000000000..3f0bbad243
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-readable-resume-hwm.js
@@ -0,0 +1,21 @@
+'use strict';
+const common = require('../common');
+const { Readable } = require('stream');
+
+// readable.resume() should not lead to a ._read() call being scheduled
+// when we exceed the high water mark already.
+
+const readable = new Readable({
+  read: common.mustNotCall(),
+  highWaterMark: 100
+});
+
+// Fill up the internal buffer so that we definitely exceed the HWM:
+for (let i = 0; i < 10; i++)
+  readable.push('a'.repeat(200));
+
+// Call resume, and pause after one chunk.
+// The .pause() is just so that we don’t empty the buffer fully, which would
+// be a valid reason to call ._read().
+readable.resume();
+readable.once('data', common.mustCall(() => readable.pause()));
diff --git a/test/js/node/test/parallel/test-stream-readable-resumeScheduled.js b/test/js/node/test/parallel/test-stream-readable-resumeScheduled.js
new file mode 100644
index 0000000000..aa521629b6
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-readable-resumeScheduled.js
@@ -0,0 +1,65 @@
+'use strict';
+const common = require('../common');
+
+// Testing Readable Stream resumeScheduled state
+
+const assert = require('assert');
+const { Readable, Writable } = require('stream');
+
+{
+  // pipe() test case
+  const r = new Readable({ read() {} });
+  const w = new Writable();
+
+  // resumeScheduled should start = `false`.
+  assert.strictEqual(r._readableState.resumeScheduled, false);
+
+  // Calling pipe() should change the state value = true.
+  r.pipe(w);
+  assert.strictEqual(r._readableState.resumeScheduled, true);
+
+  process.nextTick(common.mustCall(() => {
+    assert.strictEqual(r._readableState.resumeScheduled, false);
+  }));
+}
+
+{
+  // 'data' listener test case
+  const r = new Readable({ read() {} });
+
+  // resumeScheduled should start = `false`.
+  assert.strictEqual(r._readableState.resumeScheduled, false);
+
+  r.push(Buffer.from([1, 2, 3]));
+
+  // Adding 'data' listener should change the state value
+  r.on('data', common.mustCall(() => {
+    assert.strictEqual(r._readableState.resumeScheduled, false);
+  }));
+  assert.strictEqual(r._readableState.resumeScheduled, true);
+
+  process.nextTick(common.mustCall(() => {
+    assert.strictEqual(r._readableState.resumeScheduled, false);
+  }));
+}
+
+{
+  // resume() test case
+  const r = new Readable({ read() {} });
+
+  // resumeScheduled should start = `false`.
+  assert.strictEqual(r._readableState.resumeScheduled, false);
+
+  // Calling resume() should change the state value.
+  r.resume();
+  assert.strictEqual(r._readableState.resumeScheduled, true);
+
+  r.on('resume', common.mustCall(() => {
+    // The state value should be `false` again
+    assert.strictEqual(r._readableState.resumeScheduled, false);
+  }));
+
+  process.nextTick(common.mustCall(() => {
+    assert.strictEqual(r._readableState.resumeScheduled, false);
+  }));
+}
diff --git a/test/js/node/test/parallel/test-stream-readable-setEncoding-existing-buffers.js b/test/js/node/test/parallel/test-stream-readable-setEncoding-existing-buffers.js
new file mode 100644
index 0000000000..eb75260bac
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-readable-setEncoding-existing-buffers.js
@@ -0,0 +1,60 @@
+'use strict';
+require('../common');
+const { Readable } = require('stream');
+const assert = require('assert');
+
+{
+  // Call .setEncoding() while there are bytes already in the buffer.
+  const r = new Readable({ read() {} });
+
+  r.push(Buffer.from('a'));
+  r.push(Buffer.from('b'));
+
+  r.setEncoding('utf8');
+  const chunks = [];
+  r.on('data', (chunk) => chunks.push(chunk));
+
+  process.nextTick(() => {
+    assert.deepStrictEqual(chunks, ['ab']);
+  });
+}
+
+{
+  // Call .setEncoding() while the buffer contains a complete,
+  // but chunked character.
+  const r = new Readable({ read() {} });
+
+  r.push(Buffer.from([0xf0]));
+  r.push(Buffer.from([0x9f]));
+  r.push(Buffer.from([0x8e]));
+  r.push(Buffer.from([0x89]));
+
+  r.setEncoding('utf8');
+  const chunks = [];
+  r.on('data', (chunk) => chunks.push(chunk));
+
+  process.nextTick(() => {
+    assert.deepStrictEqual(chunks, ['🎉']);
+  });
+}
+
+{
+  // Call .setEncoding() while the buffer contains an incomplete character,
+  // and finish the character later.
+  const r = new Readable({ read() {} });
+
+  r.push(Buffer.from([0xf0]));
+  r.push(Buffer.from([0x9f]));
+
+  r.setEncoding('utf8');
+
+  r.push(Buffer.from([0x8e]));
+  r.push(Buffer.from([0x89]));
+
+  const chunks = [];
+  r.on('data', (chunk) => chunks.push(chunk));
+
+  process.nextTick(() => {
+    assert.deepStrictEqual(chunks, ['🎉']);
+  });
+}
diff --git a/test/js/node/test/parallel/test-stream-readable-strategy-option.js b/test/js/node/test/parallel/test-stream-readable-strategy-option.js
new file mode 100644
index 0000000000..a32e70ef21
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-readable-strategy-option.js
@@ -0,0 +1,75 @@
+'use strict';
+const common = require('../common');
+const { Readable } = require('stream');
+const assert = require('assert');
+const { strictEqual } = require('assert');
+
+{
+  // Strategy 2
+  const streamData = ['a', 'b', 'c', null];
+
+  // Fulfill a Readable object
+  const readable = new Readable({
+    read: common.mustCall(() => {
+      process.nextTick(() => {
+        readable.push(streamData.shift());
+      });
+    }, streamData.length),
+  });
+
+  // Use helper to convert it to a Web ReadableStream using ByteLength strategy
+  const readableStream = Readable.toWeb(readable, {
+    strategy: new ByteLengthQueuingStrategy({ highWaterMark: 1 }),
+  });
+
+  assert(!readableStream.locked);
+  readableStream.getReader().read().then(common.mustCall());
+}
+
+{
+  // Strategy 2
+  const streamData = ['a', 'b', 'c', null];
+
+  // Fulfill a Readable object
+  const readable = new Readable({
+    read: common.mustCall(() => {
+      process.nextTick(() => {
+        readable.push(streamData.shift());
+      });
+    }, streamData.length),
+  });
+
+  // Use helper to convert it to a Web ReadableStream using Count strategy
+  const readableStream = Readable.toWeb(readable, {
+    strategy: new CountQueuingStrategy({ highWaterMark: 1 }),
+  });
+
+  assert(!readableStream.locked);
+  readableStream.getReader().read().then(common.mustCall());
+}
+
+{
+  const desireSizeExpected = 2;
+
+  const stringStream = new ReadableStream(
+    {
+      start(controller) {
+        // Check if the strategy is being assigned on the init of the ReadableStream
+        strictEqual(controller.desiredSize, desireSizeExpected);
+        controller.enqueue('a');
+        controller.enqueue('b');
+        controller.close();
+      },
+    },
+    new CountQueuingStrategy({ highWaterMark: desireSizeExpected })
+  );
+
+  const reader = stringStream.getReader();
+
+  reader.read().then(common.mustCall());
+  reader.read().then(common.mustCall());
+  reader.read().then(({ value, done }) => {
+    strictEqual(value, undefined);
+    strictEqual(done, true);
+  });
+}
diff --git a/test/js/node/test/parallel/test-stream-readable-with-unimplemented-_read.js b/test/js/node/test/parallel/test-stream-readable-with-unimplemented-_read.js
new file mode 100644
index 0000000000..85e83aa3b6
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-readable-with-unimplemented-_read.js
@@ -0,0 +1,13 @@
+'use strict';
+const common = require('../common');
+const { Readable } = require('stream');
+
+const readable = new Readable();
+
+readable.read();
+readable.on('error', common.expectsError({
+  code: 'ERR_METHOD_NOT_IMPLEMENTED',
+  name: 'Error',
+  message: 'The _read() method is not implemented'
+}));
+readable.on('close', common.mustCall());
diff --git a/test/js/node/test/parallel/test-stream-readableListening-state.js b/test/js/node/test/parallel/test-stream-readableListening-state.js
new file mode 100644
index 0000000000..5e3071faf3
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-readableListening-state.js
@@ -0,0 +1,34 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const stream = require('stream');
+
+const r = new stream.Readable({
+  read: () => {}
+});
+
+// readableListening state should start in `false`.
+assert.strictEqual(r._readableState.readableListening, false);
+
+r.on('readable', common.mustCall(() => {
+  // Inside the readable event this state should be true.
+  assert.strictEqual(r._readableState.readableListening, true);
+}));
+
+r.push(Buffer.from('Testing readableListening state'));
+
+const r2 = new stream.Readable({
+  read: () => {}
+});
+
+// readableListening state should start in `false`.
+assert.strictEqual(r2._readableState.readableListening, false);
+
+r2.on('data', common.mustCall((chunk) => {
+  // readableListening should be false because we don't have
+  // a `readable` listener
+  assert.strictEqual(r2._readableState.readableListening, false);
+}));
+
+r2.push(Buffer.from('Testing readableListening state'));
diff --git a/test/js/node/test/parallel/test-stream-set-default-hwm.js b/test/js/node/test/parallel/test-stream-set-default-hwm.js
new file mode 100644
index 0000000000..3d78907b74
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-set-default-hwm.js
@@ -0,0 +1,36 @@
+'use strict';
+
+require('../common');
+
+const assert = require('node:assert');
+const {
+  setDefaultHighWaterMark,
+  getDefaultHighWaterMark,
+  Writable,
+  Readable,
+  Transform
+} = require('stream');
+
+assert.notStrictEqual(getDefaultHighWaterMark(false), 32 * 1000);
+setDefaultHighWaterMark(false, 32 * 1000);
+assert.strictEqual(getDefaultHighWaterMark(false), 32 * 1000);
+
+assert.notStrictEqual(getDefaultHighWaterMark(true), 32);
+setDefaultHighWaterMark(true, 32);
+assert.strictEqual(getDefaultHighWaterMark(true), 32);
+
+const w = new Writable({
+  write() {}
+});
+assert.strictEqual(w.writableHighWaterMark, 32 * 1000);
+
+const r = new Readable({
+  read() {}
+});
+assert.strictEqual(r.readableHighWaterMark, 32 * 1000);
+
+const t = new Transform({
+  transform() {}
+});
+assert.strictEqual(t.writableHighWaterMark, 32 * 1000);
+assert.strictEqual(t.readableHighWaterMark, 32 * 1000);
diff --git a/test/js/node/test/parallel/test-stream-transform-callback-twice.js b/test/js/node/test/parallel/test-stream-transform-callback-twice.js
new file mode 100644
index 0000000000..bf2ccdcde4
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-transform-callback-twice.js
@@ -0,0 +1,14 @@
+'use strict';
+const common = require('../common');
+const { Transform } = require('stream');
+const stream = new Transform({
+  transform(chunk, enc, cb) { cb(); cb(); }
+});
+
+stream.on('error', common.expectsError({
+  name: 'Error',
+  message: 'Callback called multiple times',
+  code: 'ERR_MULTIPLE_CALLBACK'
+}));
+
+stream.write('foo');
diff --git a/test/js/node/test/parallel/test-stream-transform-constructor-set-methods.js b/test/js/node/test/parallel/test-stream-transform-constructor-set-methods.js
new file mode 100644
index 0000000000..a20a1a07cf
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-transform-constructor-set-methods.js
@@ -0,0 +1,43 @@
+'use strict';
+const common = require('../common');
+
+const assert = require('assert');
+const { Transform } = require('stream');
+
+const t = new Transform();
+
+assert.throws(
+  () => {
+    t.end(Buffer.from('blerg'));
+  },
+  {
+    name: 'Error',
+    code: 'ERR_METHOD_NOT_IMPLEMENTED',
+    message: 'The _transform() method is not implemented'
+  }
+);
+
+const _transform = common.mustCall((chunk, _, next) => {
+  next();
+});
+
+const _final = common.mustCall((next) => {
+  next();
+});
+
+const _flush = common.mustCall((next) => {
+  next();
+});
+
+const t2 = new Transform({
+  transform: _transform,
+  flush: _flush,
+  final: _final
+});
+
+assert.strictEqual(t2._transform, _transform);
+assert.strictEqual(t2._flush, _flush);
+assert.strictEqual(t2._final, _final);
+
+t2.end(Buffer.from('blerg'));
+t2.resume();
diff --git a/test/js/node/test/parallel/test-stream-transform-final-sync.js b/test/js/node/test/parallel/test-stream-transform-final-sync.js
new file mode 100644
index 0000000000..5cc80703ee
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-transform-final-sync.js
@@ -0,0 +1,110 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+const stream = require('stream');
+let state = 0;
+
+
+// What you do
+//
+// const stream = new stream.Transform({
+//   transform: function transformCallback(chunk, _, next) {
+//     // part 1
+//     this.push(chunk);
+//     //part 2
+//     next();
+//   },
+//   final: function endCallback(done) {
+//     // part 1
+//     process.nextTick(function () {
+//       // part 2
+//       done();
+//     });
+//   },
+//   flush: function flushCallback(done) {
+//     // part 1
+//     process.nextTick(function () {
+//       // part 2
+//       done();
+//     });
+//   }
+// });
+// t.on('data', dataListener);
+// t.on('end', endListener);
+// t.on('finish', finishListener);
+// t.write(1);
+// t.write(4);
+// t.end(7, endMethodCallback);
+//
+// The order things are called
+//
+// 1. transformCallback part 1
+// 2. dataListener
+// 3. transformCallback part 2
+// 4. transformCallback part 1
+// 5. dataListener
+// 6. transformCallback part 2
+// 7. transformCallback part 1
+// 8. dataListener
+// 9. transformCallback part 2
+// 10. finalCallback part 1
+// 11. finalCallback part 2
+// 12. flushCallback part 1
+// 13. finishListener
+// 14. endMethodCallback
+// 15. flushCallback part 2
+// 16. endListener
+
+const t = new stream.Transform({
+  objectMode: true,
+  transform: common.mustCall(function(chunk, _, next) {
+    // transformCallback part 1
+    assert.strictEqual(++state, chunk);
+    this.push(state);
+    // transformCallback part 2
+    assert.strictEqual(++state, chunk + 2);
+    process.nextTick(next);
+  }, 3),
+  final: common.mustCall(function(done) {
+    state++;
+    // finalCallback part 1
+    assert.strictEqual(state, 10);
+    state++;
+    // finalCallback part 2
+    assert.strictEqual(state, 11);
+    done();
+  }, 1),
+  flush: common.mustCall(function(done) {
+    state++;
+    // fluchCallback part 1
+    assert.strictEqual(state, 12);
+    process.nextTick(function() {
+      state++;
+      // fluchCallback part 2
+      assert.strictEqual(state, 13);
+      done();
+    });
+  }, 1)
+});
+t.on('finish', common.mustCall(function() {
+  state++;
+  // finishListener
+  assert.strictEqual(state, 15);
+}, 1));
+t.on('end', common.mustCall(function() {
+  state++;
+  // endEvent
+  assert.strictEqual(state, 16);
+}, 1));
+t.on('data', common.mustCall(function(d) {
+  // dataListener
+  assert.strictEqual(++state, d + 1);
+}, 3));
+t.write(1);
+t.write(4);
+t.end(7, common.mustCall(function() {
+  state++;
+  // endMethodCallback
+  assert.strictEqual(state, 14);
+}, 1));
diff --git a/test/js/node/test/parallel/test-stream-transform-final.js b/test/js/node/test/parallel/test-stream-transform-final.js
new file mode 100644
index 0000000000..e0b2b7e40f
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-transform-final.js
@@ -0,0 +1,112 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+const stream = require('stream');
+let state = 0;
+
+
+// What you do:
+//
+// const stream = new stream.Transform({
+//   transform: function transformCallback(chunk, _, next) {
+//     // part 1
+//     this.push(chunk);
+//     //part 2
+//     next();
+//   },
+//   final: function endCallback(done) {
+//     // part 1
+//     process.nextTick(function () {
+//       // part 2
+//       done();
+//     });
+//   },
+//   flush: function flushCallback(done) {
+//     // part 1
+//     process.nextTick(function () {
+//       // part 2
+//       done();
+//     });
+//   }
+// });
+// t.on('data', dataListener);
+// t.on('end', endListener);
+// t.on('finish', finishListener);
+// t.write(1);
+// t.write(4);
+// t.end(7, endMethodCallback);
+//
+// The order things are called
+
+// 1. transformCallback part 1
+// 2. dataListener
+// 3. transformCallback part 2
+// 4. transformCallback part 1
+// 5. dataListener
+// 6. transformCallback part 2
+// 7. transformCallback part 1
+// 8. dataListener
+// 9. transformCallback part 2
+// 10. finalCallback part 1
+// 11. finalCallback part 2
+// 12. flushCallback part 1
+// 13. finishListener
+// 14. endMethodCallback
+// 15. flushCallback part 2
+// 16. endListener
+
+const t = new stream.Transform({
+  objectMode: true,
+  transform: common.mustCall(function(chunk, _, next) {
+    // transformCallback part 1
+    assert.strictEqual(++state, chunk);
+    this.push(state);
+    // transformCallback part 2
+    assert.strictEqual(++state, chunk + 2);
+    process.nextTick(next);
+  }, 3),
+  final: common.mustCall(function(done) {
+    state++;
+    // finalCallback part 1
+    assert.strictEqual(state, 10);
+    setTimeout(function() {
+      state++;
+      // finalCallback part 2
+      assert.strictEqual(state, 11);
+      done();
+    }, 100);
+  }, 1),
+  flush: common.mustCall(function(done) {
+    state++;
+    // flushCallback part 1
+    assert.strictEqual(state, 12);
+    process.nextTick(function() {
+      state++;
+      // flushCallback part 2
+      assert.strictEqual(state, 13);
+      done();
+    });
+  }, 1)
+});
+t.on('finish', common.mustCall(function() {
+  state++;
+  // finishListener
+  assert.strictEqual(state, 15);
+}, 1));
+t.on('end', common.mustCall(function() {
+  state++;
+  // end event
+  assert.strictEqual(state, 16);
+}, 1));
+t.on('data', common.mustCall(function(d) {
+  // dataListener
+  assert.strictEqual(++state, d + 1);
+}, 3));
+t.write(1);
+t.write(4);
+t.end(7, common.mustCall(function() {
+  state++;
+  // endMethodCallback
+  assert.strictEqual(state, 14);
+}, 1));
diff --git a/test/js/node/test/parallel/test-stream-transform-flush-data.js b/test/js/node/test/parallel/test-stream-transform-flush-data.js
new file mode 100644
index 0000000000..51e2c8bc52
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-transform-flush-data.js
@@ -0,0 +1,28 @@
+'use strict';
+
+require('../common');
+
+const assert = require('assert');
+const Transform = require('stream').Transform;
+
+
+const expected = 'asdf';
+
+
+function _transform(d, e, n) {
+  n();
+}
+
+function _flush(n) {
+  n(null, expected);
+}
+
+const t = new Transform({
+  transform: _transform,
+  flush: _flush
+});
+
+t.end(Buffer.from('blerg'));
+t.on('data', (data) => {
+  assert.strictEqual(data.toString(), expected);
+});
diff --git a/test/js/node/test/parallel/test-stream-transform-objectmode-falsey-value.js b/test/js/node/test/parallel/test-stream-transform-objectmode-falsey-value.js
new file mode 100644
index 0000000000..78ede5d100
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-transform-objectmode-falsey-value.js
@@ -0,0 +1,51 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+const stream = require('stream');
+const PassThrough = stream.PassThrough;
+
+const src = new PassThrough({ objectMode: true });
+const tx = new PassThrough({ objectMode: true });
+const dest = new PassThrough({ objectMode: true });
+
+const expect = [ -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
+const results = [];
+
+dest.on('data', common.mustCall(function(x) {
+  results.push(x);
+}, expect.length));
+
+src.pipe(tx).pipe(dest);
+
+let i = -1;
+const int = setInterval(common.mustCall(function() {
+  if (results.length === expect.length) {
+    src.end();
+    clearInterval(int);
+    assert.deepStrictEqual(results, expect);
+  } else {
+    src.write(i++);
+  }
+}, expect.length + 1), 1);
diff --git a/test/js/node/test/parallel/test-stream-unpipe-event.js b/test/js/node/test/parallel/test-stream-unpipe-event.js
new file mode 100644
index 0000000000..46cc8e8cb0
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-unpipe-event.js
@@ -0,0 +1,85 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const { Writable, Readable } = require('stream');
+class NullWriteable extends Writable {
+  _write(chunk, encoding, callback) {
+    return callback();
+  }
+}
+class QuickEndReadable extends Readable {
+  _read() {
+    this.push(null);
+  }
+}
+class NeverEndReadable extends Readable {
+  _read() {}
+}
+
+{
+  const dest = new NullWriteable();
+  const src = new QuickEndReadable();
+  dest.on('pipe', common.mustCall());
+  dest.on('unpipe', common.mustCall());
+  src.pipe(dest);
+  setImmediate(() => {
+    assert.strictEqual(src._readableState.pipes.length, 0);
+  });
+}
+
+{
+  const dest = new NullWriteable();
+  const src = new NeverEndReadable();
+  dest.on('pipe', common.mustCall());
+  dest.on('unpipe', common.mustNotCall('unpipe should not have been emitted'));
+  src.pipe(dest);
+  setImmediate(() => {
+    assert.strictEqual(src._readableState.pipes.length, 1);
+  });
+}
+
+{
+  const dest = new NullWriteable();
+  const src = new NeverEndReadable();
+  dest.on('pipe', common.mustCall());
+  dest.on('unpipe', common.mustCall());
+  src.pipe(dest);
+  src.unpipe(dest);
+  setImmediate(() => {
+    assert.strictEqual(src._readableState.pipes.length, 0);
+  });
+}
+
+{
+  const dest = new NullWriteable();
+  const src = new QuickEndReadable();
+  dest.on('pipe', common.mustCall());
+  dest.on('unpipe', common.mustCall());
+  src.pipe(dest, { end: false });
+  setImmediate(() => {
+    assert.strictEqual(src._readableState.pipes.length, 0);
+  });
+}
+
+{
+  const dest = new NullWriteable();
+  const src = new NeverEndReadable();
+  dest.on('pipe', common.mustCall());
+  dest.on('unpipe', common.mustNotCall('unpipe should not have been emitted'));
+  src.pipe(dest, { end: false });
+  setImmediate(() => {
+    assert.strictEqual(src._readableState.pipes.length, 1);
+  });
+}
+
+{
+  const dest = new NullWriteable();
+  const src = new NeverEndReadable();
+  dest.on('pipe', common.mustCall());
+  dest.on('unpipe', common.mustCall());
+  src.pipe(dest, { end: false });
+  src.unpipe(dest);
+  setImmediate(() => {
+    assert.strictEqual(src._readableState.pipes.length, 0);
+  });
+}
diff --git a/test/js/node/test/parallel/test-stream-unshift-empty-chunk.js b/test/js/node/test/parallel/test-stream-unshift-empty-chunk.js
new file mode 100644
index 0000000000..e8136a68e9
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-unshift-empty-chunk.js
@@ -0,0 +1,80 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+
+// This test verifies that stream.unshift(Buffer.alloc(0)) or
+// stream.unshift('') does not set state.reading=false.
+const Readable = require('stream').Readable;
+
+const r = new Readable();
+let nChunks = 10;
+const chunk = Buffer.alloc(10, 'x');
+
+r._read = function(n) {
+  setImmediate(() => {
+    r.push(--nChunks === 0 ? null : chunk);
+  });
+};
+
+let readAll = false;
+const seen = [];
+r.on('readable', () => {
+  let chunk;
+  while ((chunk = r.read()) !== null) {
+    seen.push(chunk.toString());
+    // Simulate only reading a certain amount of the data,
+    // and then putting the rest of the chunk back into the
+    // stream, like a parser might do.  We just fill it with
+    // 'y' so that it's easy to see which bits were touched,
+    // and which were not.
+    const putBack = Buffer.alloc(readAll ? 0 : 5, 'y');
+    readAll = !readAll;
+    r.unshift(putBack);
+  }
+});
+
+const expect =
+  [ 'xxxxxxxxxx',
+    'yyyyy',
+    'xxxxxxxxxx',
+    'yyyyy',
+    'xxxxxxxxxx',
+    'yyyyy',
+    'xxxxxxxxxx',
+    'yyyyy',
+    'xxxxxxxxxx',
+    'yyyyy',
+    'xxxxxxxxxx',
+    'yyyyy',
+    'xxxxxxxxxx',
+    'yyyyy',
+    'xxxxxxxxxx',
+    'yyyyy',
+    'xxxxxxxxxx',
+    'yyyyy' ];
+
+r.on('end', () => {
+  assert.deepStrictEqual(seen, expect);
+  console.log('ok');
+});
diff --git a/test/js/node/test/parallel/test-stream-unshift-read-race.js b/test/js/node/test/parallel/test-stream-unshift-read-race.js
new file mode 100644
index 0000000000..fe110ea285
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-unshift-read-race.js
@@ -0,0 +1,128 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+// This test verifies that:
+// 1. unshift() does not cause colliding _read() calls.
+// 2. unshift() after the 'end' event is an error, but after the EOF
+//    signalling null, it is ok, and just creates a new readable chunk.
+// 3. push() after the EOF signaling null is an error.
+// 4. _read() is not called after pushing the EOF null chunk.
+
+const stream = require('stream');
+const hwm = 10;
+const r = stream.Readable({ highWaterMark: hwm, autoDestroy: false });
+const chunks = 10;
+
+const data = Buffer.allocUnsafe(chunks * hwm + Math.ceil(hwm / 2));
+for (let i = 0; i < data.length; i++) {
+  const c = 'asdf'.charCodeAt(i % 4);
+  data[i] = c;
+}
+
+let pos = 0;
+let pushedNull = false;
+r._read = function(n) {
+  assert(!pushedNull, '_read after null push');
+
+  // Every third chunk is fast
+  push(!(chunks % 3));
+
+  function push(fast) {
+    assert(!pushedNull, 'push() after null push');
+    const c = pos >= data.length ? null : data.slice(pos, pos + n);
+    pushedNull = c === null;
+    if (fast) {
+      pos += n;
+      r.push(c);
+      if (c === null) pushError();
+    } else {
+      setTimeout(function() {
+        pos += n;
+        r.push(c);
+        if (c === null) pushError();
+      }, 1);
+    }
+  }
+};
+
+function pushError() {
+  r.unshift(Buffer.allocUnsafe(1));
+  w.end();
+
+  assert.throws(() => {
+    r.push(Buffer.allocUnsafe(1));
+  }, {
+    code: 'ERR_STREAM_PUSH_AFTER_EOF',
+    name: 'Error',
+    message: 'stream.push() after EOF'
+  });
+}
+
+
+const w = stream.Writable();
+const written = [];
+w._write = function(chunk, encoding, cb) {
+  written.push(chunk.toString());
+  cb();
+};
+
+r.on('end', common.mustNotCall());
+
+r.on('readable', function() {
+  let chunk;
+  while (null !== (chunk = r.read(10))) {
+    w.write(chunk);
+    if (chunk.length > 4)
+      r.unshift(Buffer.from('1234'));
+  }
+});
+
+w.on('finish', common.mustCall(function() {
+  // Each chunk should start with 1234, and then be asfdasdfasdf...
+  // The first got pulled out before the first unshift('1234'), so it's
+  // lacking that piece.
+  assert.strictEqual(written[0], 'asdfasdfas');
+  let asdf = 'd';
+  console.error(`0: ${written[0]}`);
+  for (let i = 1; i < written.length; i++) {
+    console.error(`${i.toString(32)}: ${written[i]}`);
+    assert.strictEqual(written[i].slice(0, 4), '1234');
+    for (let j = 4; j < written[i].length; j++) {
+      const c = written[i].charAt(j);
+      assert.strictEqual(c, asdf);
+      switch (asdf) {
+        case 'a': asdf = 's'; break;
+        case 's': asdf = 'd'; break;
+        case 'd': asdf = 'f'; break;
+        case 'f': asdf = 'a'; break;
+      }
+    }
+  }
+}));
+
+process.on('exit', function() {
+  assert.strictEqual(written.length, 18);
+  console.log('ok');
+});
diff --git a/test/js/node/test/parallel/test-stream-writable-aborted.js b/test/js/node/test/parallel/test-stream-writable-aborted.js
new file mode 100644
index 0000000000..01d638115b
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-writable-aborted.js
@@ -0,0 +1,26 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const { Writable } = require('stream');
+
+{
+  const writable = new Writable({
+    write() {
+    }
+  });
+  assert.strictEqual(writable.writableAborted, false);
+  writable.destroy();
+  assert.strictEqual(writable.writableAborted, true);
+}
+
+{
+  const writable = new Writable({
+    write() {
+    }
+  });
+  assert.strictEqual(writable.writableAborted, false);
+  writable.end();
+  writable.destroy();
+  assert.strictEqual(writable.writableAborted, true);
+}
diff --git a/test/js/node/test/parallel/test-stream-writable-change-default-encoding.js b/test/js/node/test/parallel/test-stream-writable-change-default-encoding.js
new file mode 100644
index 0000000000..94a892567c
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-writable-change-default-encoding.js
@@ -0,0 +1,78 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+
+const stream = require('stream');
+
+class MyWritable extends stream.Writable {
+  constructor(fn, options) {
+    super(options);
+    this.fn = fn;
+  }
+
+  _write(chunk, encoding, callback) {
+    this.fn(Buffer.isBuffer(chunk), typeof chunk, encoding);
+    callback();
+  }
+}
+
+(function defaultCondingIsUtf8() {
+  const m = new MyWritable(function(isBuffer, type, enc) {
+    assert.strictEqual(enc, 'utf8');
+  }, { decodeStrings: false });
+  m.write('foo');
+  m.end();
+}());
+
+(function changeDefaultEncodingToAscii() {
+  const m = new MyWritable(function(isBuffer, type, enc) {
+    assert.strictEqual(enc, 'ascii');
+  }, { decodeStrings: false });
+  m.setDefaultEncoding('ascii');
+  m.write('bar');
+  m.end();
+}());
+
+// Change default encoding to invalid value.
+assert.throws(() => {
+  const m = new MyWritable(
+    (isBuffer, type, enc) => {},
+    { decodeStrings: false });
+  m.setDefaultEncoding({});
+  m.write('bar');
+  m.end();
+}, {
+  name: 'TypeError',
+  code: 'ERR_UNKNOWN_ENCODING',
+  message: 'Unknown encoding: {}'
+});
+
+(function checkVariableCaseEncoding() {
+  const m = new MyWritable(function(isBuffer, type, enc) {
+    assert.strictEqual(enc, 'ascii');
+  }, { decodeStrings: false });
+  m.setDefaultEncoding('AsCii');
+  m.write('bar');
+  m.end();
+}());
diff --git a/test/js/node/test/parallel/test-stream-writable-clear-buffer.js b/test/js/node/test/parallel/test-stream-writable-clear-buffer.js
new file mode 100644
index 0000000000..c4d7ae151a
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-writable-clear-buffer.js
@@ -0,0 +1,35 @@
+'use strict';
+
+// This test ensures that the _writeableState.bufferedRequestCount and
+// the actual buffered request count are the same.
+
+const common = require('../common');
+const Stream = require('stream');
+const assert = require('assert');
+
+class StreamWritable extends Stream.Writable {
+  constructor() {
+    super({ objectMode: true });
+  }
+
+  // Refs: https://github.com/nodejs/node/issues/6758
+  // We need a timer like on the original issue thread.
+  // Otherwise the code will never reach our test case.
+  _write(chunk, encoding, cb) {
+    setImmediate(cb);
+  }
+}
+
+const testStream = new StreamWritable();
+testStream.cork();
+
+for (let i = 1; i <= 5; i++) {
+  testStream.write(i, common.mustCall(() => {
+    assert.strictEqual(
+      testStream._writableState.bufferedRequestCount,
+      testStream._writableState.getBuffer().length
+    );
+  }));
+}
+
+testStream.end();
diff --git a/test/js/node/test/parallel/test-stream-writable-constructor-set-methods.js b/test/js/node/test/parallel/test-stream-writable-constructor-set-methods.js
new file mode 100644
index 0000000000..34fda8edda
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-writable-constructor-set-methods.js
@@ -0,0 +1,41 @@
+'use strict';
+const common = require('../common');
+
+const assert = require('assert');
+const { Writable } = require('stream');
+
+const bufferBlerg = Buffer.from('blerg');
+const w = new Writable();
+
+assert.throws(
+  () => {
+    w.end(bufferBlerg);
+  },
+  {
+    name: 'Error',
+    code: 'ERR_METHOD_NOT_IMPLEMENTED',
+    message: 'The _write() method is not implemented'
+  }
+);
+
+const _write = common.mustCall((chunk, _, next) => {
+  next();
+});
+
+const _writev = common.mustCall((chunks, next) => {
+  assert.strictEqual(chunks.length, 2);
+  next();
+});
+
+const w2 = new Writable({ write: _write, writev: _writev });
+
+assert.strictEqual(w2._write, _write);
+assert.strictEqual(w2._writev, _writev);
+
+w2.write(bufferBlerg);
+
+w2.cork();
+w2.write(bufferBlerg);
+w2.write(bufferBlerg);
+
+w2.end();
diff --git a/test/js/node/test/parallel/test-stream-writable-end-cb-uncaught.js b/test/js/node/test/parallel/test-stream-writable-end-cb-uncaught.js
new file mode 100644
index 0000000000..02586b45d9
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-writable-end-cb-uncaught.js
@@ -0,0 +1,24 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const stream = require('stream');
+
+process.on('uncaughtException', common.mustCall((err) => {
+  assert.strictEqual(err.message, 'kaboom');
+}));
+
+const writable = new stream.Writable();
+const _err = new Error('kaboom');
+
+writable._write = (chunk, encoding, cb) => {
+  cb();
+};
+writable._final = (cb) => {
+  cb(_err);
+};
+
+writable.write('asd');
+writable.end(common.mustCall((err) => {
+  assert.strictEqual(err, _err);
+}));
diff --git a/test/js/node/test/parallel/test-stream-writable-end-multiple.js b/test/js/node/test/parallel/test-stream-writable-end-multiple.js
new file mode 100644
index 0000000000..000f5b07f5
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-writable-end-multiple.js
@@ -0,0 +1,22 @@
+'use strict';
+
+const common = require('../common');
+
+const assert = require('assert');
+const stream = require('stream');
+
+const writable = new stream.Writable();
+writable._write = (chunk, encoding, cb) => {
+  setTimeout(() => cb(), 10);
+};
+
+writable.end('testing ended state', common.mustCall());
+writable.end(common.mustCall());
+writable.on('finish', common.mustCall(() => {
+  let ticked = false;
+  writable.end(common.mustCall((err) => {
+    assert.strictEqual(ticked, true);
+    assert.strictEqual(err.code, 'ERR_STREAM_ALREADY_FINISHED');
+  }));
+  ticked = true;
+}));
diff --git a/test/js/node/test/parallel/test-stream-writable-ended-state.js b/test/js/node/test/parallel/test-stream-writable-ended-state.js
new file mode 100644
index 0000000000..2c40c62a9e
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-writable-ended-state.js
@@ -0,0 +1,32 @@
+'use strict';
+
+const common = require('../common');
+
+const assert = require('assert');
+const stream = require('stream');
+
+const writable = new stream.Writable();
+
+writable._write = (chunk, encoding, cb) => {
+  assert.strictEqual(writable._writableState.ended, false);
+  assert.strictEqual(writable._writableState.writable, undefined);
+  assert.strictEqual(writable.writableEnded, false);
+  cb();
+};
+
+assert.strictEqual(writable._writableState.ended, false);
+assert.strictEqual(writable._writableState.writable, undefined);
+assert.strictEqual(writable.writable, true);
+assert.strictEqual(writable.writableEnded, false);
+
+writable.end('testing ended state', common.mustCall(() => {
+  assert.strictEqual(writable._writableState.ended, true);
+  assert.strictEqual(writable._writableState.writable, undefined);
+  assert.strictEqual(writable.writable, false);
+  assert.strictEqual(writable.writableEnded, true);
+}));
+
+assert.strictEqual(writable._writableState.ended, true);
+assert.strictEqual(writable._writableState.writable, undefined);
+assert.strictEqual(writable.writable, false);
+assert.strictEqual(writable.writableEnded, true);
diff --git a/test/js/node/test/parallel/test-stream-writable-final-async.js b/test/js/node/test/parallel/test-stream-writable-final-async.js
new file mode 100644
index 0000000000..c17b843322
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-writable-final-async.js
@@ -0,0 +1,25 @@
+'use strict';
+
+const common = require('../common');
+const {
+  Duplex,
+} = require('stream');
+const { setTimeout } = require('timers/promises');
+
+{
+  class Foo extends Duplex {
+    async _final(callback) {
+      await setTimeout(common.platformTimeout(1));
+      callback();
+    }
+
+    _read() {}
+  }
+
+  const foo = new Foo();
+  foo._write = common.mustCall((chunk, encoding, cb) => {
+    cb();
+  });
+  foo.end('test', common.mustCall());
+  foo.on('error', common.mustNotCall());
+}
diff --git a/test/js/node/test/parallel/test-stream-writable-final-destroy.js b/test/js/node/test/parallel/test-stream-writable-final-destroy.js
new file mode 100644
index 0000000000..8d3bf72c89
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-writable-final-destroy.js
@@ -0,0 +1,21 @@
+'use strict';
+const common = require('../common');
+
+const { Writable } = require('stream');
+
+{
+  const w = new Writable({
+    write(chunk, encoding, callback) {
+      callback(null);
+    },
+    final(callback) {
+      queueMicrotask(callback);
+    }
+  });
+  w.end();
+  w.destroy();
+
+  w.on('prefinish', common.mustNotCall());
+  w.on('finish', common.mustNotCall());
+  w.on('close', common.mustCall());
+}
diff --git a/test/js/node/test/parallel/test-stream-writable-final-throw.js b/test/js/node/test/parallel/test-stream-writable-final-throw.js
new file mode 100644
index 0000000000..e7dd21abc3
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-writable-final-throw.js
@@ -0,0 +1,23 @@
+'use strict';
+
+const common = require('../common');
+const {
+  Duplex,
+} = require('stream');
+
+{
+  class Foo extends Duplex {
+    _final(callback) {
+      throw new Error('fhqwhgads');
+    }
+
+    _read() {}
+  }
+
+  const foo = new Foo();
+  foo._write = common.mustCall((chunk, encoding, cb) => {
+    cb();
+  });
+  foo.end('test', common.expectsError({ message: 'fhqwhgads' }));
+  foo.on('error', common.mustCall());
+}
diff --git a/test/js/node/test/parallel/test-stream-writable-finish-destroyed.js b/test/js/node/test/parallel/test-stream-writable-finish-destroyed.js
new file mode 100644
index 0000000000..22657a170f
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-writable-finish-destroyed.js
@@ -0,0 +1,43 @@
+'use strict';
+
+const common = require('../common');
+const { Writable } = require('stream');
+
+{
+  const w = new Writable({
+    write: common.mustCall((chunk, encoding, cb) => {
+      w.on('close', common.mustCall(() => {
+        cb();
+      }));
+    })
+  });
+
+  w.on('finish', common.mustNotCall());
+  w.end('asd');
+  w.destroy();
+}
+
+{
+  const w = new Writable({
+    write: common.mustCall((chunk, encoding, cb) => {
+      w.on('close', common.mustCall(() => {
+        cb();
+        w.end();
+      }));
+    })
+  });
+
+  w.on('finish', common.mustNotCall());
+  w.write('asd');
+  w.destroy();
+}
+
+{
+  const w = new Writable({
+    write() {
+    }
+  });
+  w.on('finish', common.mustNotCall());
+  w.end();
+  w.destroy();
+}
diff --git a/test/js/node/test/parallel/test-stream-writable-finished-state.js b/test/js/node/test/parallel/test-stream-writable-finished-state.js
new file mode 100644
index 0000000000..b42137ed0b
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-writable-finished-state.js
@@ -0,0 +1,22 @@
+'use strict';
+
+const common = require('../common');
+
+const assert = require('assert');
+const stream = require('stream');
+
+const writable = new stream.Writable();
+
+writable._write = (chunk, encoding, cb) => {
+  // The state finished should start in false.
+  assert.strictEqual(writable._writableState.finished, false);
+  cb();
+};
+
+writable.on('finish', common.mustCall(() => {
+  assert.strictEqual(writable._writableState.finished, true);
+}));
+
+writable.end('testing finished state', common.mustCall(() => {
+  assert.strictEqual(writable._writableState.finished, true);
+}));
diff --git a/test/js/node/test/parallel/test-stream-writable-finished.js b/test/js/node/test/parallel/test-stream-writable-finished.js
new file mode 100644
index 0000000000..933a80a2f9
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-writable-finished.js
@@ -0,0 +1,99 @@
+'use strict';
+
+const common = require('../common');
+const { Writable } = require('stream');
+const assert = require('assert');
+
+// basic
+{
+  // Find it on Writable.prototype
+  assert(Object.hasOwn(Writable.prototype, 'writableFinished'));
+}
+
+// event
+{
+  const writable = new Writable();
+
+  writable._write = (chunk, encoding, cb) => {
+    // The state finished should start in false.
+    assert.strictEqual(writable.writableFinished, false);
+    cb();
+  };
+
+  writable.on('finish', common.mustCall(() => {
+    assert.strictEqual(writable.writableFinished, true);
+  }));
+
+  writable.end('testing finished state', common.mustCall(() => {
+    assert.strictEqual(writable.writableFinished, true);
+  }));
+}
+
+{
+  // Emit finish asynchronously.
+
+  const w = new Writable({
+    write(chunk, encoding, cb) {
+      cb();
+    }
+  });
+
+  w.end();
+  w.on('finish', common.mustCall());
+}
+
+{
+  // Emit prefinish synchronously.
+
+  const w = new Writable({
+    write(chunk, encoding, cb) {
+      cb();
+    }
+  });
+
+  let sync = true;
+  w.on('prefinish', common.mustCall(() => {
+    assert.strictEqual(sync, true);
+  }));
+  w.end();
+  sync = false;
+}
+
+{
+  // Emit prefinish synchronously w/ final.
+
+  const w = new Writable({
+    write(chunk, encoding, cb) {
+      cb();
+    },
+    final(cb) {
+      cb();
+    }
+  });
+
+  let sync = true;
+  w.on('prefinish', common.mustCall(() => {
+    assert.strictEqual(sync, true);
+  }));
+  w.end();
+  sync = false;
+}
+
+
+{
+  // Call _final synchronously.
+
+  let sync = true;
+  const w = new Writable({
+    write(chunk, encoding, cb) {
+      cb();
+    },
+    final: common.mustCall((cb) => {
+      assert.strictEqual(sync, true);
+      cb();
+    })
+  });
+
+  w.end();
+  sync = false;
+}
diff --git a/test/js/node/test/parallel/test-stream-writable-invalid-chunk.js b/test/js/node/test/parallel/test-stream-writable-invalid-chunk.js
new file mode 100644
index 0000000000..09032c07c5
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-writable-invalid-chunk.js
@@ -0,0 +1,36 @@
+'use strict';
+
+const common = require('../common');
+const stream = require('stream');
+const assert = require('assert');
+
+function testWriteType(val, objectMode, code) {
+  const writable = new stream.Writable({
+    objectMode,
+    write: () => {}
+  });
+  writable.on('error', common.mustNotCall());
+  if (code) {
+    assert.throws(() => {
+      writable.write(val);
+    }, { code });
+  } else {
+    writable.write(val);
+  }
+}
+
+testWriteType([], false, 'ERR_INVALID_ARG_TYPE');
+testWriteType({}, false, 'ERR_INVALID_ARG_TYPE');
+testWriteType(0, false, 'ERR_INVALID_ARG_TYPE');
+testWriteType(true, false, 'ERR_INVALID_ARG_TYPE');
+testWriteType(0.0, false, 'ERR_INVALID_ARG_TYPE');
+testWriteType(undefined, false, 'ERR_INVALID_ARG_TYPE');
+testWriteType(null, false, 'ERR_STREAM_NULL_VALUES');
+
+testWriteType([], true);
+testWriteType({}, true);
+testWriteType(0, true);
+testWriteType(true, true);
+testWriteType(0.0, true);
+testWriteType(undefined, true);
+testWriteType(null, true, 'ERR_STREAM_NULL_VALUES');
diff --git a/test/js/node/test/parallel/test-stream-writable-needdrain-state.js b/test/js/node/test/parallel/test-stream-writable-needdrain-state.js
new file mode 100644
index 0000000000..0e72d832bc
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-writable-needdrain-state.js
@@ -0,0 +1,25 @@
+'use strict';
+
+const common = require('../common');
+const stream = require('stream');
+const assert = require('assert');
+
+const transform = new stream.Transform({
+  transform: _transform,
+  highWaterMark: 1
+});
+
+function _transform(chunk, encoding, cb) {
+  process.nextTick(() => {
+    assert.strictEqual(transform._writableState.needDrain, true);
+    cb();
+  });
+}
+
+assert.strictEqual(transform._writableState.needDrain, false);
+
+transform.write('asdasd', common.mustCall(() => {
+  assert.strictEqual(transform._writableState.needDrain, false);
+}));
+
+assert.strictEqual(transform._writableState.needDrain, true);
diff --git a/test/js/node/test/parallel/test-stream-writable-null.js b/test/js/node/test/parallel/test-stream-writable-null.js
new file mode 100644
index 0000000000..99419f1cf9
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-writable-null.js
@@ -0,0 +1,47 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+const stream = require('stream');
+
+class MyWritable extends stream.Writable {
+  constructor(options) {
+    super({ autoDestroy: false, ...options });
+  }
+  _write(chunk, encoding, callback) {
+    assert.notStrictEqual(chunk, null);
+    callback();
+  }
+}
+
+{
+  const m = new MyWritable({ objectMode: true });
+  m.on('error', common.mustNotCall());
+  assert.throws(() => {
+    m.write(null);
+  }, {
+    code: 'ERR_STREAM_NULL_VALUES'
+  });
+}
+
+{
+  const m = new MyWritable();
+  m.on('error', common.mustNotCall());
+  assert.throws(() => {
+    m.write(false);
+  }, {
+    code: 'ERR_INVALID_ARG_TYPE'
+  });
+}
+
+{ // Should not throw.
+  const m = new MyWritable({ objectMode: true });
+  m.write(false, assert.ifError);
+}
+
+{ // Should not throw.
+  const m = new MyWritable({ objectMode: true }).on('error', (e) => {
+    assert.ifError(e || new Error('should not get here'));
+  });
+  m.write(false, assert.ifError);
+}
diff --git a/test/js/node/test/parallel/test-stream-writable-properties.js b/test/js/node/test/parallel/test-stream-writable-properties.js
new file mode 100644
index 0000000000..424bb58710
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-writable-properties.js
@@ -0,0 +1,22 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+
+const { Writable } = require('stream');
+
+{
+  const w = new Writable();
+  assert.strictEqual(w.writableCorked, 0);
+  w.uncork();
+  assert.strictEqual(w.writableCorked, 0);
+  w.cork();
+  assert.strictEqual(w.writableCorked, 1);
+  w.cork();
+  assert.strictEqual(w.writableCorked, 2);
+  w.uncork();
+  assert.strictEqual(w.writableCorked, 1);
+  w.uncork();
+  assert.strictEqual(w.writableCorked, 0);
+  w.uncork();
+  assert.strictEqual(w.writableCorked, 0);
+}
diff --git a/test/js/node/test/parallel/test-stream-writable-writable.js b/test/js/node/test/parallel/test-stream-writable-writable.js
new file mode 100644
index 0000000000..ef5454dc52
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-writable-writable.js
@@ -0,0 +1,48 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+const { Writable } = require('stream');
+
+{
+  const w = new Writable({
+    write() {}
+  });
+  assert.strictEqual(w.writable, true);
+  w.destroy();
+  assert.strictEqual(w.writable, false);
+}
+
+{
+  const w = new Writable({
+    write: common.mustCall((chunk, encoding, callback) => {
+      callback(new Error());
+    })
+  });
+  assert.strictEqual(w.writable, true);
+  w.write('asd');
+  assert.strictEqual(w.writable, false);
+  w.on('error', common.mustCall());
+}
+
+{
+  const w = new Writable({
+    write: common.mustCall((chunk, encoding, callback) => {
+      process.nextTick(() => {
+        callback(new Error());
+        assert.strictEqual(w.writable, false);
+      });
+    })
+  });
+  w.write('asd');
+  w.on('error', common.mustCall());
+}
+
+{
+  const w = new Writable({
+    write: common.mustNotCall()
+  });
+  assert.strictEqual(w.writable, true);
+  w.end();
+  assert.strictEqual(w.writable, false);
+}
diff --git a/test/js/node/test/parallel/test-stream-writable-write-cb-error.js b/test/js/node/test/parallel/test-stream-writable-write-cb-error.js
new file mode 100644
index 0000000000..72db1b7e3f
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-writable-write-cb-error.js
@@ -0,0 +1,58 @@
+'use strict';
+const common = require('../common');
+const { Writable } = require('stream');
+const assert = require('assert');
+
+// Ensure callback is always invoked before
+// error is emitted. Regardless if error was
+// sync or async.
+
+{
+  let callbackCalled = false;
+  // Sync Error
+  const writable = new Writable({
+    write: common.mustCall((buf, enc, cb) => {
+      cb(new Error());
+    })
+  });
+  writable.on('error', common.mustCall(() => {
+    assert.strictEqual(callbackCalled, true);
+  }));
+  writable.write('hi', common.mustCall(() => {
+    callbackCalled = true;
+  }));
+}
+
+{
+  let callbackCalled = false;
+  // Async Error
+  const writable = new Writable({
+    write: common.mustCall((buf, enc, cb) => {
+      process.nextTick(cb, new Error());
+    })
+  });
+  writable.on('error', common.mustCall(() => {
+    assert.strictEqual(callbackCalled, true);
+  }));
+  writable.write('hi', common.mustCall(() => {
+    callbackCalled = true;
+  }));
+}
+
+{
+  // Sync Error
+  const writable = new Writable({
+    write: common.mustCall((buf, enc, cb) => {
+      cb(new Error());
+    })
+  });
+
+  writable.on('error', common.mustCall());
+
+  let cnt = 0;
+  // Ensure we don't live lock on sync error
+  while (writable.write('a'))
+    cnt++;
+
+  assert.strictEqual(cnt, 0);
+}
diff --git a/test/js/node/test/parallel/test-stream-writable-write-cb-twice.js b/test/js/node/test/parallel/test-stream-writable-write-cb-twice.js
new file mode 100644
index 0000000000..244698c522
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-writable-write-cb-twice.js
@@ -0,0 +1,52 @@
+'use strict';
+const common = require('../common');
+const { Writable } = require('stream');
+
+{
+  // Sync + Sync
+  const writable = new Writable({
+    write: common.mustCall((buf, enc, cb) => {
+      cb();
+      cb();
+    })
+  });
+  writable.write('hi');
+  writable.on('error', common.expectsError({
+    code: 'ERR_MULTIPLE_CALLBACK',
+    name: 'Error'
+  }));
+}
+
+{
+  // Sync + Async
+  const writable = new Writable({
+    write: common.mustCall((buf, enc, cb) => {
+      cb();
+      process.nextTick(() => {
+        cb();
+      });
+    })
+  });
+  writable.write('hi');
+  writable.on('error', common.expectsError({
+    code: 'ERR_MULTIPLE_CALLBACK',
+    name: 'Error'
+  }));
+}
+
+{
+  // Async + Async
+  const writable = new Writable({
+    write: common.mustCall((buf, enc, cb) => {
+      process.nextTick(cb);
+      process.nextTick(() => {
+        cb();
+      });
+    })
+  });
+  writable.write('hi');
+  writable.on('error', common.expectsError({
+    code: 'ERR_MULTIPLE_CALLBACK',
+    name: 'Error'
+  }));
+}
diff --git a/test/js/node/test/parallel/test-stream-writable-write-error.js b/test/js/node/test/parallel/test-stream-writable-write-error.js
new file mode 100644
index 0000000000..069e32e1be
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-writable-write-error.js
@@ -0,0 +1,75 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+const { Writable } = require('stream');
+
+function expectError(w, args, code, sync) {
+  if (sync) {
+    if (code) {
+      assert.throws(() => w.write(...args), { code });
+    } else {
+      w.write(...args);
+    }
+  } else {
+    let errorCalled = false;
+    let ticked = false;
+    w.write(...args, common.mustCall((err) => {
+      assert.strictEqual(ticked, true);
+      assert.strictEqual(errorCalled, false);
+      assert.strictEqual(err.code, code);
+    }));
+    ticked = true;
+    w.on('error', common.mustCall((err) => {
+      errorCalled = true;
+      assert.strictEqual(err.code, code);
+    }));
+  }
+}
+
+function test(autoDestroy) {
+  {
+    const w = new Writable({
+      autoDestroy,
+      _write() {}
+    });
+    w.end();
+    expectError(w, ['asd'], 'ERR_STREAM_WRITE_AFTER_END');
+  }
+
+  {
+    const w = new Writable({
+      autoDestroy,
+      _write() {}
+    });
+    w.destroy();
+  }
+
+  {
+    const w = new Writable({
+      autoDestroy,
+      _write() {}
+    });
+    expectError(w, [null], 'ERR_STREAM_NULL_VALUES', true);
+  }
+
+  {
+    const w = new Writable({
+      autoDestroy,
+      _write() {}
+    });
+    expectError(w, [{}], 'ERR_INVALID_ARG_TYPE', true);
+  }
+
+  {
+    const w = new Writable({
+      decodeStrings: false,
+      autoDestroy,
+      _write() {}
+    });
+    expectError(w, ['asd', 'noencoding'], 'ERR_UNKNOWN_ENCODING', true);
+  }
+}
+
+test(false);
+test(true);
diff --git a/test/js/node/test/parallel/test-stream-writable-write-writev-finish.js b/test/js/node/test/parallel/test-stream-writable-write-writev-finish.js
new file mode 100644
index 0000000000..9fce315f8b
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-writable-write-writev-finish.js
@@ -0,0 +1,152 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const stream = require('stream');
+
+// Ensure consistency between the finish event when using cork()
+// and writev and when not using them
+
+{
+  const writable = new stream.Writable();
+
+  writable._write = (chunks, encoding, cb) => {
+    cb(new Error('write test error'));
+  };
+
+  writable.on('finish', common.mustNotCall());
+  writable.on('prefinish', common.mustNotCall());
+  writable.on('error', common.mustCall((er) => {
+    assert.strictEqual(er.message, 'write test error');
+  }));
+
+  writable.end('test');
+}
+
+{
+  const writable = new stream.Writable();
+
+  writable._write = (chunks, encoding, cb) => {
+    setImmediate(cb, new Error('write test error'));
+  };
+
+  writable.on('finish', common.mustNotCall());
+  writable.on('prefinish', common.mustNotCall());
+  writable.on('error', common.mustCall((er) => {
+    assert.strictEqual(er.message, 'write test error');
+  }));
+
+  writable.end('test');
+}
+
+{
+  const writable = new stream.Writable();
+
+  writable._write = (chunks, encoding, cb) => {
+    cb(new Error('write test error'));
+  };
+
+  writable._writev = (chunks, cb) => {
+    cb(new Error('writev test error'));
+  };
+
+  writable.on('finish', common.mustNotCall());
+  writable.on('prefinish', common.mustNotCall());
+  writable.on('error', common.mustCall((er) => {
+    assert.strictEqual(er.message, 'writev test error');
+  }));
+
+  writable.cork();
+  writable.write('test');
+
+  setImmediate(function() {
+    writable.end('test');
+  });
+}
+
+{
+  const writable = new stream.Writable();
+
+  writable._write = (chunks, encoding, cb) => {
+    setImmediate(cb, new Error('write test error'));
+  };
+
+  writable._writev = (chunks, cb) => {
+    setImmediate(cb, new Error('writev test error'));
+  };
+
+  writable.on('finish', common.mustNotCall());
+  writable.on('prefinish', common.mustNotCall());
+  writable.on('error', common.mustCall((er) => {
+    assert.strictEqual(er.message, 'writev test error');
+  }));
+
+  writable.cork();
+  writable.write('test');
+
+  setImmediate(function() {
+    writable.end('test');
+  });
+}
+
+// Regression test for
+// https://github.com/nodejs/node/issues/13812
+
+{
+  const rs = new stream.Readable();
+  rs.push('ok');
+  rs.push(null);
+  rs._read = () => {};
+
+  const ws = new stream.Writable();
+
+  ws.on('finish', common.mustNotCall());
+  ws.on('error', common.mustCall());
+
+  ws._write = (chunk, encoding, done) => {
+    setImmediate(done, new Error());
+  };
+  rs.pipe(ws);
+}
+
+{
+  const rs = new stream.Readable();
+  rs.push('ok');
+  rs.push(null);
+  rs._read = () => {};
+
+  const ws = new stream.Writable();
+
+  ws.on('finish', common.mustNotCall());
+  ws.on('error', common.mustCall());
+
+  ws._write = (chunk, encoding, done) => {
+    done(new Error());
+  };
+  rs.pipe(ws);
+}
+
+{
+  const w = new stream.Writable();
+  w._write = (chunk, encoding, cb) => {
+    process.nextTick(cb);
+  };
+  w.on('error', common.mustCall());
+  w.on('finish', common.mustNotCall());
+  w.on('prefinish', () => {
+    w.write("shouldn't write in prefinish listener");
+  });
+  w.end();
+}
+
+{
+  const w = new stream.Writable();
+  w._write = (chunk, encoding, cb) => {
+    process.nextTick(cb);
+  };
+  w.on('error', common.mustCall());
+  w.on('finish', () => {
+    w.write("shouldn't write in finish listener");
+  });
+  w.end();
+}
diff --git a/test/js/node/test/parallel/test-stream-writableState-ending.js b/test/js/node/test/parallel/test-stream-writableState-ending.js
new file mode 100644
index 0000000000..d301d355cc
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-writableState-ending.js
@@ -0,0 +1,37 @@
+'use strict';
+
+require('../common');
+
+const assert = require('assert');
+const stream = require('stream');
+
+const writable = new stream.Writable();
+
+function testStates(ending, finished, ended) {
+  assert.strictEqual(writable._writableState.ending, ending);
+  assert.strictEqual(writable._writableState.finished, finished);
+  assert.strictEqual(writable._writableState.ended, ended);
+}
+
+writable._write = (chunk, encoding, cb) => {
+  // Ending, finished, ended start in false.
+  testStates(false, false, false);
+  cb();
+};
+
+writable.on('finish', () => {
+  // Ending, finished, ended = true.
+  testStates(true, true, true);
+});
+
+const result = writable.end('testing function end()', () => {
+  // Ending, finished, ended = true.
+  testStates(true, true, true);
+});
+
+// End returns the writable instance
+assert.strictEqual(result, writable);
+
+// Ending, ended = true.
+// finished = false.
+testStates(true, false, true);
diff --git a/test/js/node/test/parallel/test-stream-writableState-uncorked-bufferedRequestCount.js b/test/js/node/test/parallel/test-stream-writableState-uncorked-bufferedRequestCount.js
new file mode 100644
index 0000000000..b7375b9fa2
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-writableState-uncorked-bufferedRequestCount.js
@@ -0,0 +1,57 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const stream = require('stream');
+
+const writable = new stream.Writable();
+
+writable._writev = common.mustCall((chunks, cb) => {
+  assert.strictEqual(chunks.length, 2);
+  cb();
+}, 1);
+
+writable._write = common.mustCall((chunk, encoding, cb) => {
+  cb();
+}, 1);
+
+// first cork
+writable.cork();
+assert.strictEqual(writable._writableState.corked, 1);
+assert.strictEqual(writable._writableState.bufferedRequestCount, 0);
+
+// cork again
+writable.cork();
+assert.strictEqual(writable._writableState.corked, 2);
+
+// The first chunk is buffered
+writable.write('first chunk');
+assert.strictEqual(writable._writableState.bufferedRequestCount, 1);
+
+// First uncork does nothing
+writable.uncork();
+assert.strictEqual(writable._writableState.corked, 1);
+assert.strictEqual(writable._writableState.bufferedRequestCount, 1);
+
+process.nextTick(uncork);
+
+// The second chunk is buffered, because we uncork at the end of tick
+writable.write('second chunk');
+assert.strictEqual(writable._writableState.corked, 1);
+assert.strictEqual(writable._writableState.bufferedRequestCount, 2);
+
+function uncork() {
+  // Second uncork flushes the buffer
+  writable.uncork();
+  assert.strictEqual(writable._writableState.corked, 0);
+  assert.strictEqual(writable._writableState.bufferedRequestCount, 0);
+
+  // Verify that end() uncorks correctly
+  writable.cork();
+  writable.write('third chunk');
+  writable.end();
+
+  // End causes an uncork() as well
+  assert.strictEqual(writable._writableState.corked, 0);
+  assert.strictEqual(writable._writableState.bufferedRequestCount, 0);
+}
diff --git a/test/js/node/test/parallel/test-stream-write-destroy.js b/test/js/node/test/parallel/test-stream-write-destroy.js
new file mode 100644
index 0000000000..d436b98f84
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-write-destroy.js
@@ -0,0 +1,62 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const { Writable } = require('stream');
+
+// Test interaction between calling .destroy() on a writable and pending
+// writes.
+
+for (const withPendingData of [ false, true ]) {
+  for (const useEnd of [ false, true ]) {
+    const callbacks = [];
+
+    const w = new Writable({
+      write(data, enc, cb) {
+        callbacks.push(cb);
+      },
+      // Effectively disable the HWM to observe 'drain' events more easily.
+      highWaterMark: 1
+    });
+
+    let chunksWritten = 0;
+    let drains = 0;
+    w.on('drain', () => drains++);
+
+    function onWrite(err) {
+      if (err) {
+        assert.strictEqual(w.destroyed, true);
+        assert.strictEqual(err.code, 'ERR_STREAM_DESTROYED');
+      } else {
+        chunksWritten++;
+      }
+    }
+
+    w.write('abc', onWrite);
+    assert.strictEqual(chunksWritten, 0);
+    assert.strictEqual(drains, 0);
+    callbacks.shift()();
+    assert.strictEqual(chunksWritten, 1);
+    assert.strictEqual(drains, 1);
+
+    if (withPendingData) {
+      // Test 2 cases: There either is or is not data still in the write queue.
+      // (The second write will never actually get executed either way.)
+      w.write('def', onWrite);
+    }
+    if (useEnd) {
+      // Again, test 2 cases: Either we indicate that we want to end the
+      // writable or not.
+      w.end('ghi', onWrite);
+    } else {
+      w.write('ghi', onWrite);
+    }
+
+    assert.strictEqual(chunksWritten, 1);
+    w.destroy();
+    assert.strictEqual(chunksWritten, 1);
+    callbacks.shift()();
+    assert.strictEqual(chunksWritten, useEnd && !withPendingData ? 1 : 2);
+    assert.strictEqual(callbacks.length, 0);
+    assert.strictEqual(drains, 1);
+  }
+}
diff --git a/test/js/node/test/parallel/test-stream-write-drain.js b/test/js/node/test/parallel/test-stream-write-drain.js
new file mode 100644
index 0000000000..bd65c1fdbb
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-write-drain.js
@@ -0,0 +1,16 @@
+'use strict';
+const common = require('../common');
+const { Writable } = require('stream');
+
+// Don't emit 'drain' if ended
+
+const w = new Writable({
+  write(data, enc, cb) {
+    process.nextTick(cb);
+  },
+  highWaterMark: 1
+});
+
+w.on('drain', common.mustNotCall());
+w.write('asd');
+w.end();
diff --git a/test/js/node/test/parallel/test-stream-write-final.js b/test/js/node/test/parallel/test-stream-write-final.js
new file mode 100644
index 0000000000..56537bd7fa
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-write-final.js
@@ -0,0 +1,24 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+const stream = require('stream');
+let shutdown = false;
+
+const w = new stream.Writable({
+  final: common.mustCall(function(cb) {
+    assert.strictEqual(this, w);
+    setTimeout(function() {
+      shutdown = true;
+      cb();
+    }, 100);
+  }),
+  write: function(chunk, e, cb) {
+    process.nextTick(cb);
+  }
+});
+w.on('finish', common.mustCall(function() {
+  assert(shutdown);
+}));
+w.write(Buffer.allocUnsafe(1));
+w.end(Buffer.allocUnsafe(0));
diff --git a/test/js/node/test/parallel/test-stream-writev.js b/test/js/node/test/parallel/test-stream-writev.js
new file mode 100644
index 0000000000..5a42411c6f
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream-writev.js
@@ -0,0 +1,130 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+const stream = require('stream');
+
+const queue = [];
+for (let decode = 0; decode < 2; decode++) {
+  for (let uncork = 0; uncork < 2; uncork++) {
+    for (let multi = 0; multi < 2; multi++) {
+      queue.push([!!decode, !!uncork, !!multi]);
+    }
+  }
+}
+
+run();
+
+function run() {
+  const t = queue.pop();
+  if (t)
+    test(t[0], t[1], t[2], run);
+  else
+    console.log('ok');
+}
+
+function test(decode, uncork, multi, next) {
+  console.log(`# decode=${decode} uncork=${uncork} multi=${multi}`);
+  let counter = 0;
+  let expectCount = 0;
+  function cnt(msg) {
+    expectCount++;
+    const expect = expectCount;
+    return function(er) {
+      assert.ifError(er);
+      counter++;
+      assert.strictEqual(counter, expect);
+    };
+  }
+
+  const w = new stream.Writable({ decodeStrings: decode });
+  w._write = common.mustNotCall('Should not call _write');
+
+  const expectChunks = decode ? [
+    { encoding: 'buffer',
+      chunk: [104, 101, 108, 108, 111, 44, 32] },
+    { encoding: 'buffer',
+      chunk: [119, 111, 114, 108, 100] },
+    { encoding: 'buffer',
+      chunk: [33] },
+    { encoding: 'buffer',
+      chunk: [10, 97, 110, 100, 32, 116, 104, 101, 110, 46, 46, 46] },
+    { encoding: 'buffer',
+      chunk: [250, 206, 190, 167, 222, 173, 190, 239, 222, 202, 251, 173] },
+  ] : [
+    { encoding: 'ascii', chunk: 'hello, ' },
+    { encoding: 'utf8', chunk: 'world' },
+    { encoding: 'buffer', chunk: [33] },
+    { encoding: 'latin1', chunk: '\nand then...' },
+    { encoding: 'hex', chunk: 'facebea7deadbeefdecafbad' },
+  ];
+
+  let actualChunks;
+  w._writev = function(chunks, cb) {
+    actualChunks = chunks.map(function(chunk) {
+      return {
+        encoding: chunk.encoding,
+        chunk: Buffer.isBuffer(chunk.chunk) ?
+          Array.prototype.slice.call(chunk.chunk) : chunk.chunk
+      };
+    });
+    cb();
+  };
+
+  w.cork();
+  w.write('hello, ', 'ascii', cnt('hello'));
+  w.write('world', 'utf8', cnt('world'));
+
+  if (multi)
+    w.cork();
+
+  w.write(Buffer.from('!'), 'buffer', cnt('!'));
+  w.write('\nand then...', 'latin1', cnt('and then'));
+
+  if (multi)
+    w.uncork();
+
+  w.write('facebea7deadbeefdecafbad', 'hex', cnt('hex'));
+
+  if (uncork)
+    w.uncork();
+
+  w.end(cnt('end'));
+
+  w.on('finish', function() {
+    // Make sure finish comes after all the write cb
+    cnt('finish')();
+    assert.deepStrictEqual(actualChunks, expectChunks);
+    next();
+  });
+}
+
+{
+  const w = new stream.Writable({
+    writev: common.mustCall(function(chunks, cb) {
+      cb();
+    })
+  });
+  w.write('asd', common.mustCall());
+}
diff --git a/test/js/node/test/parallel/test-stream2-base64-single-char-read-end.js b/test/js/node/test/parallel/test-stream2-base64-single-char-read-end.js
new file mode 100644
index 0000000000..2e1eb15f9f
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream2-base64-single-char-read-end.js
@@ -0,0 +1,56 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const { Readable: R, Writable: W } = require('stream');
+const assert = require('assert');
+
+const src = new R({ encoding: 'base64' });
+const dst = new W();
+let hasRead = false;
+const accum = [];
+
+src._read = function(n) {
+  if (!hasRead) {
+    hasRead = true;
+    process.nextTick(function() {
+      src.push(Buffer.from('1'));
+      src.push(null);
+    });
+  }
+};
+
+dst._write = function(chunk, enc, cb) {
+  accum.push(chunk);
+  cb();
+};
+
+src.on('end', function() {
+  assert.strictEqual(String(Buffer.concat(accum)), 'MQ==');
+  clearTimeout(timeout);
+});
+
+src.pipe(dst);
+
+const timeout = setTimeout(function() {
+  assert.fail('timed out waiting for _write');
+}, 100);
diff --git a/test/js/node/test/parallel/test-stream2-basic.js b/test/js/node/test/parallel/test-stream2-basic.js
new file mode 100644
index 0000000000..2670deda53
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream2-basic.js
@@ -0,0 +1,445 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+
+const common = require('../common');
+const { Readable: R, Writable: W } = require('stream');
+const assert = require('assert');
+
+const EE = require('events').EventEmitter;
+
+class TestReader extends R {
+  constructor(n) {
+    super();
+    this._buffer = Buffer.alloc(n || 100, 'x');
+    this._pos = 0;
+    this._bufs = 10;
+  }
+
+  _read(n) {
+    const max = this._buffer.length - this._pos;
+    n = Math.max(n, 0);
+    const toRead = Math.min(n, max);
+    if (toRead === 0) {
+      // Simulate the read buffer filling up with some more bytes some time
+      // in the future.
+      setTimeout(() => {
+        this._pos = 0;
+        this._bufs -= 1;
+        if (this._bufs <= 0) {
+          // read them all!
+          if (!this.ended)
+            this.push(null);
+        } else {
+          // now we have more.
+          // kinda cheating by calling _read, but whatever,
+          // it's just fake anyway.
+          this._read(n);
+        }
+      }, 10);
+      return;
+    }
+
+    const ret = this._buffer.slice(this._pos, this._pos + toRead);
+    this._pos += toRead;
+    this.push(ret);
+  }
+}
+
+class TestWriter extends EE {
+  constructor() {
+    super();
+    this.received = [];
+    this.flush = false;
+  }
+
+  write(c) {
+    this.received.push(c.toString());
+    this.emit('write', c);
+    return true;
+  }
+
+  end(c) {
+    if (c) this.write(c);
+    this.emit('end', this.received);
+  }
+}
+
+{
+  // Test basic functionality
+  const r = new TestReader(20);
+
+  const reads = [];
+  const expect = [ 'x',
+                   'xx',
+                   'xxx',
+                   'xxxx',
+                   'xxxxx',
+                   'xxxxxxxxx',
+                   'xxxxxxxxxx',
+                   'xxxxxxxxxxxx',
+                   'xxxxxxxxxxxxx',
+                   'xxxxxxxxxxxxxxx',
+                   'xxxxxxxxxxxxxxxxx',
+                   'xxxxxxxxxxxxxxxxxxx',
+                   'xxxxxxxxxxxxxxxxxxxxx',
+                   'xxxxxxxxxxxxxxxxxxxxxxx',
+                   'xxxxxxxxxxxxxxxxxxxxxxxxx',
+                   'xxxxxxxxxxxxxxxxxxxxx' ];
+
+  r.on('end', common.mustCall(function() {
+    assert.deepStrictEqual(reads, expect);
+  }));
+
+  let readSize = 1;
+  function flow() {
+    let res;
+    while (null !== (res = r.read(readSize++))) {
+      reads.push(res.toString());
+    }
+    r.once('readable', flow);
+  }
+
+  flow();
+}
+
+{
+  // Verify pipe
+  const r = new TestReader(5);
+
+  const expect = [ 'xxxxx',
+                   'xxxxx',
+                   'xxxxx',
+                   'xxxxx',
+                   'xxxxx',
+                   'xxxxx',
+                   'xxxxx',
+                   'xxxxx',
+                   'xxxxx',
+                   'xxxxx' ];
+
+  const w = new TestWriter();
+
+  w.on('end', common.mustCall(function(received) {
+    assert.deepStrictEqual(received, expect);
+  }));
+
+  r.pipe(w);
+}
+
+
+[1, 2, 3, 4, 5, 6, 7, 8, 9].forEach(function(SPLIT) {
+  // Verify unpipe
+  const r = new TestReader(5);
+
+  // Unpipe after 3 writes, then write to another stream instead.
+  let expect = [ 'xxxxx',
+                 'xxxxx',
+                 'xxxxx',
+                 'xxxxx',
+                 'xxxxx',
+                 'xxxxx',
+                 'xxxxx',
+                 'xxxxx',
+                 'xxxxx',
+                 'xxxxx' ];
+  expect = [ expect.slice(0, SPLIT), expect.slice(SPLIT) ];
+
+  const w = [ new TestWriter(), new TestWriter() ];
+
+  let writes = SPLIT;
+  w[0].on('write', function() {
+    if (--writes === 0) {
+      r.unpipe();
+      assert.deepStrictEqual(r._readableState.pipes, []);
+      w[0].end();
+      r.pipe(w[1]);
+      assert.deepStrictEqual(r._readableState.pipes, [w[1]]);
+    }
+  });
+
+  let ended = 0;
+
+  w[0].on('end', common.mustCall(function(results) {
+    ended++;
+    assert.strictEqual(ended, 1);
+    assert.deepStrictEqual(results, expect[0]);
+  }));
+
+  w[1].on('end', common.mustCall(function(results) {
+    ended++;
+    assert.strictEqual(ended, 2);
+    assert.deepStrictEqual(results, expect[1]);
+  }));
+
+  r.pipe(w[0]);
+});
+
+
+{
+  // Verify both writers get the same data when piping to destinations
+  const r = new TestReader(5);
+  const w = [ new TestWriter(), new TestWriter() ];
+
+  const expect = [ 'xxxxx',
+                   'xxxxx',
+                   'xxxxx',
+                   'xxxxx',
+                   'xxxxx',
+                   'xxxxx',
+                   'xxxxx',
+                   'xxxxx',
+                   'xxxxx',
+                   'xxxxx' ];
+
+  w[0].on('end', common.mustCall(function(received) {
+    assert.deepStrictEqual(received, expect);
+  }));
+  w[1].on('end', common.mustCall(function(received) {
+    assert.deepStrictEqual(received, expect);
+  }));
+
+  r.pipe(w[0]);
+  r.pipe(w[1]);
+}
+
+
+[1, 2, 3, 4, 5, 6, 7, 8, 9].forEach(function(SPLIT) {
+  // Verify multi-unpipe
+  const r = new TestReader(5);
+
+  // Unpipe after 3 writes, then write to another stream instead.
+  let expect = [ 'xxxxx',
+                 'xxxxx',
+                 'xxxxx',
+                 'xxxxx',
+                 'xxxxx',
+                 'xxxxx',
+                 'xxxxx',
+                 'xxxxx',
+                 'xxxxx',
+                 'xxxxx' ];
+  expect = [ expect.slice(0, SPLIT), expect.slice(SPLIT) ];
+
+  const w = [ new TestWriter(), new TestWriter(), new TestWriter() ];
+
+  let writes = SPLIT;
+  w[0].on('write', function() {
+    if (--writes === 0) {
+      r.unpipe();
+      w[0].end();
+      r.pipe(w[1]);
+    }
+  });
+
+  let ended = 0;
+
+  w[0].on('end', common.mustCall(function(results) {
+    ended++;
+    assert.strictEqual(ended, 1);
+    assert.deepStrictEqual(results, expect[0]);
+  }));
+
+  w[1].on('end', common.mustCall(function(results) {
+    ended++;
+    assert.strictEqual(ended, 2);
+    assert.deepStrictEqual(results, expect[1]);
+  }));
+
+  r.pipe(w[0]);
+  r.pipe(w[2]);
+});
+
+{
+  // Verify that back pressure is respected
+  const r = new R({ objectMode: true });
+  r._read = common.mustNotCall();
+  let counter = 0;
+  r.push(['one']);
+  r.push(['two']);
+  r.push(['three']);
+  r.push(['four']);
+  r.push(null);
+
+  const w1 = new R();
+  w1.write = function(chunk) {
+    assert.strictEqual(chunk[0], 'one');
+    w1.emit('close');
+    process.nextTick(function() {
+      r.pipe(w2);
+      r.pipe(w3);
+    });
+  };
+  w1.end = common.mustNotCall();
+
+  r.pipe(w1);
+
+  const expected = ['two', 'two', 'three', 'three', 'four', 'four'];
+
+  const w2 = new R();
+  w2.write = function(chunk) {
+    assert.strictEqual(chunk[0], expected.shift());
+    assert.strictEqual(counter, 0);
+
+    counter++;
+
+    if (chunk[0] === 'four') {
+      return true;
+    }
+
+    setTimeout(function() {
+      counter--;
+      w2.emit('drain');
+    }, 10);
+
+    return false;
+  };
+  w2.end = common.mustCall();
+
+  const w3 = new R();
+  w3.write = function(chunk) {
+    assert.strictEqual(chunk[0], expected.shift());
+    assert.strictEqual(counter, 1);
+
+    counter++;
+
+    if (chunk[0] === 'four') {
+      return true;
+    }
+
+    setTimeout(function() {
+      counter--;
+      w3.emit('drain');
+    }, 50);
+
+    return false;
+  };
+  w3.end = common.mustCall(function() {
+    assert.strictEqual(counter, 2);
+    assert.strictEqual(expected.length, 0);
+  });
+}
+
+{
+  // Verify read(0) behavior for ended streams
+  const r = new R();
+  let written = false;
+  let ended = false;
+  r._read = common.mustNotCall();
+
+  r.push(Buffer.from('foo'));
+  r.push(null);
+
+  const v = r.read(0);
+
+  assert.strictEqual(v, null);
+
+  const w = new R();
+  w.write = function(buffer) {
+    written = true;
+    assert.strictEqual(ended, false);
+    assert.strictEqual(buffer.toString(), 'foo');
+  };
+
+  w.end = common.mustCall(function() {
+    ended = true;
+    assert.strictEqual(written, true);
+  });
+
+  r.pipe(w);
+}
+
+{
+  // Verify synchronous _read ending
+  const r = new R();
+  let called = false;
+  r._read = function(n) {
+    r.push(null);
+  };
+
+  r.once('end', function() {
+    // Verify that this is called before the next tick
+    called = true;
+  });
+
+  r.read();
+
+  process.nextTick(function() {
+    assert.strictEqual(called, true);
+  });
+}
+
+{
+  // Verify that adding readable listeners trigger data flow
+  const r = new R({ highWaterMark: 5 });
+  let onReadable = false;
+  let readCalled = 0;
+
+  r._read = function(n) {
+    if (readCalled++ === 2)
+      r.push(null);
+    else
+      r.push(Buffer.from('asdf'));
+  };
+
+  r.on('readable', function() {
+    onReadable = true;
+    r.read();
+  });
+
+  r.on('end', common.mustCall(function() {
+    assert.strictEqual(readCalled, 3);
+    assert.ok(onReadable);
+  }));
+}
+
+{
+  // Verify that streams are chainable
+  const r = new R();
+  r._read = common.mustCall();
+  const r2 = r.setEncoding('utf8').pause().resume().pause();
+  assert.strictEqual(r, r2);
+}
+
+{
+  // Verify readableEncoding property
+  assert(Object.hasOwn(R.prototype, 'readableEncoding'));
+
+  const r = new R({ encoding: 'utf8' });
+  assert.strictEqual(r.readableEncoding, 'utf8');
+}
+
+{
+  // Verify readableObjectMode property
+  assert(Object.hasOwn(R.prototype, 'readableObjectMode'));
+
+  const r = new R({ objectMode: true });
+  assert.strictEqual(r.readableObjectMode, true);
+}
+
+{
+  // Verify writableObjectMode property
+  assert(Object.hasOwn(W.prototype, 'writableObjectMode'));
+
+  const w = new W({ objectMode: true });
+  assert.strictEqual(w.writableObjectMode, true);
+}
diff --git a/test/js/node/test/parallel/test-stream2-compatibility.js b/test/js/node/test/parallel/test-stream2-compatibility.js
new file mode 100644
index 0000000000..d760db8b32
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream2-compatibility.js
@@ -0,0 +1,70 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const { Readable: R, Writable: W } = require('stream');
+const assert = require('assert');
+
+let ondataCalled = 0;
+
+class TestReader extends R {
+  constructor() {
+    super();
+    this._buffer = Buffer.alloc(100, 'x');
+
+    this.on('data', () => {
+      ondataCalled++;
+    });
+  }
+
+  _read(n) {
+    this.push(this._buffer);
+    this._buffer = Buffer.alloc(0);
+  }
+}
+
+const reader = new TestReader();
+setImmediate(function() {
+  assert.strictEqual(ondataCalled, 1);
+  console.log('ok');
+  reader.push(null);
+});
+
+class TestWriter extends W {
+  constructor() {
+    super();
+    this.write('foo');
+    this.end();
+  }
+
+  _write(chunk, enc, cb) {
+    cb();
+  }
+}
+
+const writer = new TestWriter();
+
+process.on('exit', function() {
+  assert.strictEqual(reader.readable, false);
+  assert.strictEqual(writer.writable, false);
+  console.log('ok');
+});
diff --git a/test/js/node/test/parallel/test-stream2-decode-partial.js b/test/js/node/test/parallel/test-stream2-decode-partial.js
new file mode 100644
index 0000000000..9d9ae21bfe
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream2-decode-partial.js
@@ -0,0 +1,23 @@
+'use strict';
+require('../common');
+const { Readable } = require('stream');
+const assert = require('assert');
+
+let buf = '';
+const euro = Buffer.from([0xE2, 0x82, 0xAC]);
+const cent = Buffer.from([0xC2, 0xA2]);
+const source = Buffer.concat([euro, cent]);
+
+const readable = Readable({ encoding: 'utf8' });
+readable.push(source.slice(0, 2));
+readable.push(source.slice(2, 4));
+readable.push(source.slice(4, 6));
+readable.push(null);
+
+readable.on('data', function(data) {
+  buf += data;
+});
+
+process.on('exit', function() {
+  assert.strictEqual(buf, '€¢');
+});
diff --git a/test/js/node/test/parallel/test-stream2-finish-pipe-error.js b/test/js/node/test/parallel/test-stream2-finish-pipe-error.js
new file mode 100644
index 0000000000..a603e154b9
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream2-finish-pipe-error.js
@@ -0,0 +1,20 @@
+'use strict';
+const common = require('../common');
+const stream = require('stream');
+
+process.on('uncaughtException', common.mustCall());
+
+const r = new stream.Readable();
+r._read = function(size) {
+  r.push(Buffer.allocUnsafe(size));
+};
+
+const w = new stream.Writable();
+w._write = function(data, encoding, cb) {
+  cb(null);
+};
+
+r.pipe(w);
+
+// end() after pipe should cause unhandled exception
+w.end();
diff --git a/test/js/node/test/parallel/test-stream2-finish-pipe.js b/test/js/node/test/parallel/test-stream2-finish-pipe.js
new file mode 100644
index 0000000000..5e2969aad4
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream2-finish-pipe.js
@@ -0,0 +1,44 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const stream = require('stream');
+
+const r = new stream.Readable();
+r._read = function(size) {
+  r.push(Buffer.allocUnsafe(size));
+};
+
+const w = new stream.Writable();
+w._write = function(data, encoding, cb) {
+  process.nextTick(cb, null);
+};
+
+r.pipe(w);
+
+// end() must be called in nextTick or a WRITE_AFTER_END error occurs.
+process.nextTick(() => {
+  // This might sound unrealistic, but it happens in net.js. When
+  // socket.allowHalfOpen === false, EOF will cause .destroySoon() call which
+  // ends the writable side of net.Socket.
+  w.end();
+});
diff --git a/test/js/node/test/parallel/test-stream2-large-read-stall.js b/test/js/node/test/parallel/test-stream2-large-read-stall.js
new file mode 100644
index 0000000000..2d44bb7f78
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream2-large-read-stall.js
@@ -0,0 +1,74 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+// If everything aligns so that you do a read(n) of exactly the
+// remaining buffer, then make sure that 'end' still emits.
+
+const READSIZE = 100;
+const PUSHSIZE = 20;
+const PUSHCOUNT = 1000;
+const HWM = 50;
+
+const Readable = require('stream').Readable;
+const r = new Readable({
+  highWaterMark: HWM
+});
+const rs = r._readableState;
+
+r._read = push;
+
+r.on('readable', function() {
+  console.error('>> readable');
+  let ret;
+  do {
+    console.error(`  > read(${READSIZE})`);
+    ret = r.read(READSIZE);
+    console.error(`  < ${ret && ret.length} (${rs.length} remain)`);
+  } while (ret && ret.length === READSIZE);
+
+  console.error('<< after read()',
+                ret && ret.length,
+                rs.needReadable,
+                rs.length);
+});
+
+r.on('end', common.mustCall(function() {
+  assert.strictEqual(pushes, PUSHCOUNT + 1);
+}));
+
+let pushes = 0;
+function push() {
+  if (pushes > PUSHCOUNT)
+    return;
+
+  if (pushes++ === PUSHCOUNT) {
+    console.error('   push(EOF)');
+    return r.push(null);
+  }
+
+  console.error(`   push #${pushes}`);
+  if (r.push(Buffer.allocUnsafe(PUSHSIZE)))
+    setTimeout(push, 1);
+}
diff --git a/test/js/node/test/parallel/test-stream2-objects.js b/test/js/node/test/parallel/test-stream2-objects.js
new file mode 100644
index 0000000000..b7ad074628
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream2-objects.js
@@ -0,0 +1,297 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+
+const common = require('../common');
+const { Readable, Writable } = require('stream');
+const assert = require('assert');
+
+function toArray(callback) {
+  const stream = new Writable({ objectMode: true });
+  const list = [];
+  stream.write = function(chunk) {
+    list.push(chunk);
+  };
+
+  stream.end = common.mustCall(function() {
+    callback(list);
+  });
+
+  return stream;
+}
+
+function fromArray(list) {
+  const r = new Readable({ objectMode: true });
+  r._read = common.mustNotCall();
+  list.forEach(function(chunk) {
+    r.push(chunk);
+  });
+  r.push(null);
+
+  return r;
+}
+
+{
+  // Verify that objects can be read from the stream
+  const r = fromArray([{ one: '1' }, { two: '2' }]);
+
+  const v1 = r.read();
+  const v2 = r.read();
+  const v3 = r.read();
+
+  assert.deepStrictEqual(v1, { one: '1' });
+  assert.deepStrictEqual(v2, { two: '2' });
+  assert.strictEqual(v3, null);
+}
+
+{
+  // Verify that objects can be piped into the stream
+  const r = fromArray([{ one: '1' }, { two: '2' }]);
+
+  r.pipe(toArray(common.mustCall(function(list) {
+    assert.deepStrictEqual(list, [
+      { one: '1' },
+      { two: '2' },
+    ]);
+  })));
+}
+
+{
+  // Verify that read(n) is ignored
+  const r = fromArray([{ one: '1' }, { two: '2' }]);
+  const value = r.read(2);
+
+  assert.deepStrictEqual(value, { one: '1' });
+}
+
+{
+  // Verify that objects can be synchronously read
+  const r = new Readable({ objectMode: true });
+  const list = [{ one: '1' }, { two: '2' }];
+  r._read = function(n) {
+    const item = list.shift();
+    r.push(item || null);
+  };
+
+  r.pipe(toArray(common.mustCall(function(list) {
+    assert.deepStrictEqual(list, [
+      { one: '1' },
+      { two: '2' },
+    ]);
+  })));
+}
+
+{
+  // Verify that objects can be asynchronously read
+  const r = new Readable({ objectMode: true });
+  const list = [{ one: '1' }, { two: '2' }];
+  r._read = function(n) {
+    const item = list.shift();
+    process.nextTick(function() {
+      r.push(item || null);
+    });
+  };
+
+  r.pipe(toArray(common.mustCall(function(list) {
+    assert.deepStrictEqual(list, [
+      { one: '1' },
+      { two: '2' },
+    ]);
+  })));
+}
+
+{
+  // Verify that strings can be read as objects
+  const r = new Readable({
+    objectMode: true
+  });
+  r._read = common.mustNotCall();
+  const list = ['one', 'two', 'three'];
+  list.forEach(function(str) {
+    r.push(str);
+  });
+  r.push(null);
+
+  r.pipe(toArray(common.mustCall(function(array) {
+    assert.deepStrictEqual(array, list);
+  })));
+}
+
+{
+  // Verify read(0) behavior for object streams
+  const r = new Readable({
+    objectMode: true
+  });
+  r._read = common.mustNotCall();
+
+  r.push('foobar');
+  r.push(null);
+
+  r.pipe(toArray(common.mustCall(function(array) {
+    assert.deepStrictEqual(array, ['foobar']);
+  })));
+}
+
+{
+  // Verify the behavior of pushing falsey values
+  const r = new Readable({
+    objectMode: true
+  });
+  r._read = common.mustNotCall();
+
+  r.push(false);
+  r.push(0);
+  r.push('');
+  r.push(null);
+
+  r.pipe(toArray(common.mustCall(function(array) {
+    assert.deepStrictEqual(array, [false, 0, '']);
+  })));
+}
+
+{
+  // Verify high watermark _read() behavior
+  const r = new Readable({
+    highWaterMark: 6,
+    objectMode: true
+  });
+  let calls = 0;
+  const list = ['1', '2', '3', '4', '5', '6', '7', '8'];
+
+  r._read = function(n) {
+    calls++;
+  };
+
+  list.forEach(function(c) {
+    r.push(c);
+  });
+
+  const v = r.read();
+
+  assert.strictEqual(calls, 0);
+  assert.strictEqual(v, '1');
+
+  const v2 = r.read();
+  assert.strictEqual(v2, '2');
+
+  const v3 = r.read();
+  assert.strictEqual(v3, '3');
+
+  assert.strictEqual(calls, 1);
+}
+
+{
+  // Verify high watermark push behavior
+  const r = new Readable({
+    highWaterMark: 6,
+    objectMode: true
+  });
+  r._read = common.mustNotCall();
+  for (let i = 0; i < 6; i++) {
+    const bool = r.push(i);
+    assert.strictEqual(bool, i !== 5);
+  }
+}
+
+{
+  // Verify that objects can be written to stream
+  const w = new Writable({ objectMode: true });
+
+  w._write = function(chunk, encoding, cb) {
+    assert.deepStrictEqual(chunk, { foo: 'bar' });
+    cb();
+  };
+
+  w.on('finish', common.mustCall());
+  w.write({ foo: 'bar' });
+  w.end();
+}
+
+{
+  // Verify that multiple objects can be written to stream
+  const w = new Writable({ objectMode: true });
+  const list = [];
+
+  w._write = function(chunk, encoding, cb) {
+    list.push(chunk);
+    cb();
+  };
+
+  w.on('finish', common.mustCall(function() {
+    assert.deepStrictEqual(list, [0, 1, 2, 3, 4]);
+  }));
+
+  w.write(0);
+  w.write(1);
+  w.write(2);
+  w.write(3);
+  w.write(4);
+  w.end();
+}
+
+{
+  // Verify that strings can be written as objects
+  const w = new Writable({
+    objectMode: true
+  });
+  const list = [];
+
+  w._write = function(chunk, encoding, cb) {
+    list.push(chunk);
+    process.nextTick(cb);
+  };
+
+  w.on('finish', common.mustCall(function() {
+    assert.deepStrictEqual(list, ['0', '1', '2', '3', '4']);
+  }));
+
+  w.write('0');
+  w.write('1');
+  w.write('2');
+  w.write('3');
+  w.write('4');
+  w.end();
+}
+
+{
+  // Verify that stream buffers finish until callback is called
+  const w = new Writable({
+    objectMode: true
+  });
+  let called = false;
+
+  w._write = function(chunk, encoding, cb) {
+    assert.strictEqual(chunk, 'foo');
+
+    process.nextTick(function() {
+      called = true;
+      cb();
+    });
+  };
+
+  w.on('finish', common.mustCall(function() {
+    assert.strictEqual(called, true);
+  }));
+
+  w.write('foo');
+  w.end();
+}
diff --git a/test/js/node/test/parallel/test-stream2-pipe-error-handling.js b/test/js/node/test/parallel/test-stream2-pipe-error-handling.js
new file mode 100644
index 0000000000..d3f4838105
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream2-pipe-error-handling.js
@@ -0,0 +1,106 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const stream = require('stream');
+
+{
+  let count = 1000;
+
+  const source = new stream.Readable();
+  source._read = function(n) {
+    n = Math.min(count, n);
+    count -= n;
+    source.push(Buffer.allocUnsafe(n));
+  };
+
+  let unpipedDest;
+  source.unpipe = function(dest) {
+    unpipedDest = dest;
+    stream.Readable.prototype.unpipe.call(this, dest);
+  };
+
+  const dest = new stream.Writable();
+  dest._write = function(chunk, encoding, cb) {
+    cb();
+  };
+
+  source.pipe(dest);
+
+  let gotErr = null;
+  dest.on('error', function(err) {
+    gotErr = err;
+  });
+
+  let unpipedSource;
+  dest.on('unpipe', function(src) {
+    unpipedSource = src;
+  });
+
+  const err = new Error('This stream turned into bacon.');
+  dest.emit('error', err);
+  assert.strictEqual(gotErr, err);
+  assert.strictEqual(unpipedSource, source);
+  assert.strictEqual(unpipedDest, dest);
+}
+
+{
+  let count = 1000;
+
+  const source = new stream.Readable();
+  source._read = function(n) {
+    n = Math.min(count, n);
+    count -= n;
+    source.push(Buffer.allocUnsafe(n));
+  };
+
+  let unpipedDest;
+  source.unpipe = function(dest) {
+    unpipedDest = dest;
+    stream.Readable.prototype.unpipe.call(this, dest);
+  };
+
+  const dest = new stream.Writable({ autoDestroy: false });
+  dest._write = function(chunk, encoding, cb) {
+    cb();
+  };
+
+  source.pipe(dest);
+
+  let unpipedSource;
+  dest.on('unpipe', function(src) {
+    unpipedSource = src;
+  });
+
+  const err = new Error('This stream turned into bacon.');
+
+  let gotErr = null;
+  try {
+    dest.emit('error', err);
+  } catch (e) {
+    gotErr = e;
+  }
+  assert.strictEqual(gotErr, err);
+  assert.strictEqual(unpipedSource, source);
+  assert.strictEqual(unpipedDest, dest);
+}
diff --git a/test/js/node/test/parallel/test-stream2-pipe-error-once-listener.js b/test/js/node/test/parallel/test-stream2-pipe-error-once-listener.js
new file mode 100644
index 0000000000..003e78e64f
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream2-pipe-error-once-listener.js
@@ -0,0 +1,53 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+
+require('../common');
+const stream = require('stream');
+
+class Read extends stream.Readable {
+  _read(size) {
+    this.push('x');
+    this.push(null);
+  }
+}
+
+class Write extends stream.Writable {
+  _write(buffer, encoding, cb) {
+    this.emit('error', new Error('boom'));
+    this.emit('alldone');
+  }
+}
+
+const read = new Read();
+const write = new Write();
+
+write.once('error', () => {});
+write.once('alldone', function(err) {
+  console.log('ok');
+});
+
+process.on('exit', function(c) {
+  console.error('error thrown even with listener');
+});
+
+read.pipe(write);
diff --git a/test/js/node/test/parallel/test-stream2-push.js b/test/js/node/test/parallel/test-stream2-push.js
new file mode 100644
index 0000000000..748a77b9c4
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream2-push.js
@@ -0,0 +1,136 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const { Readable, Writable } = require('stream');
+
+const EE = require('events').EventEmitter;
+
+
+// A mock thing a bit like the net.Socket/tcp_wrap.handle interaction
+
+const stream = new Readable({
+  highWaterMark: 16,
+  encoding: 'utf8'
+});
+
+const source = new EE();
+
+stream._read = function() {
+  console.error('stream._read');
+  readStart();
+};
+
+let ended = false;
+stream.on('end', function() {
+  ended = true;
+});
+
+source.on('data', function(chunk) {
+  const ret = stream.push(chunk);
+  console.error('data', stream.readableLength);
+  if (!ret)
+    readStop();
+});
+
+source.on('end', function() {
+  stream.push(null);
+});
+
+let reading = false;
+
+function readStart() {
+  console.error('readStart');
+  reading = true;
+}
+
+function readStop() {
+  console.error('readStop');
+  reading = false;
+  process.nextTick(function() {
+    const r = stream.read();
+    if (r !== null)
+      writer.write(r);
+  });
+}
+
+const writer = new Writable({
+  decodeStrings: false
+});
+
+const written = [];
+
+const expectWritten =
+  [ 'asdfgasdfgasdfgasdfg',
+    'asdfgasdfgasdfgasdfg',
+    'asdfgasdfgasdfgasdfg',
+    'asdfgasdfgasdfgasdfg',
+    'asdfgasdfgasdfgasdfg',
+    'asdfgasdfgasdfgasdfg' ];
+
+writer._write = function(chunk, encoding, cb) {
+  console.error(`WRITE ${chunk}`);
+  written.push(chunk);
+  process.nextTick(cb);
+};
+
+writer.on('finish', finish);
+
+
+// Now emit some chunks.
+
+const chunk = 'asdfg';
+
+let set = 0;
+readStart();
+data();
+function data() {
+  assert(reading);
+  source.emit('data', chunk);
+  assert(reading);
+  source.emit('data', chunk);
+  assert(reading);
+  source.emit('data', chunk);
+  assert(reading);
+  source.emit('data', chunk);
+  assert(!reading);
+  if (set++ < 5)
+    setTimeout(data, 10);
+  else
+    end();
+}
+
+function finish() {
+  console.error('finish');
+  assert.deepStrictEqual(written, expectWritten);
+  console.log('ok');
+}
+
+function end() {
+  source.emit('end');
+  assert(!reading);
+  writer.end(stream.read());
+  setImmediate(function() {
+    assert(ended);
+  });
+}
diff --git a/test/js/node/test/parallel/test-stream2-read-sync-stack.js b/test/js/node/test/parallel/test-stream2-read-sync-stack.js
new file mode 100644
index 0000000000..e6a5ea7e52
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream2-read-sync-stack.js
@@ -0,0 +1,46 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const Readable = require('stream').Readable;
+
+// This tests synchronous read callbacks and verifies that even if they nest
+// heavily the process handles it without an error
+
+const r = new Readable();
+const N = 256 * 1024;
+
+let reads = 0;
+r._read = function(n) {
+  const chunk = reads++ === N ? null : Buffer.allocUnsafe(1);
+  r.push(chunk);
+};
+
+r.on('readable', function onReadable() {
+  if (!(r.readableLength % 256))
+    console.error('readable', r.readableLength);
+  r.read(N * 2);
+});
+
+r.on('end', common.mustCall());
+
+r.read(0);
diff --git a/test/js/node/test/parallel/test-stream2-readable-empty-buffer-no-eof.js b/test/js/node/test/parallel/test-stream2-readable-empty-buffer-no-eof.js
new file mode 100644
index 0000000000..7be2c358ee
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream2-readable-empty-buffer-no-eof.js
@@ -0,0 +1,117 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+
+const Readable = require('stream').Readable;
+
+test1();
+test2();
+
+function test1() {
+  const r = new Readable();
+
+  // Should not end when we get a Buffer.alloc(0) or '' as the _read
+  // result that just means that there is *temporarily* no data, but to
+  // go ahead and try again later.
+  //
+  // note that this is very unusual.  it only works for crypto streams
+  // because the other side of the stream will call read(0) to cycle
+  // data through openssl.  that's why setImmediate() is used to call
+  // r.read(0) again later, otherwise there is no more work being done
+  // and the process just exits.
+
+  const buf = Buffer.alloc(5, 'x');
+  let reads = 5;
+  r._read = function(n) {
+    switch (reads--) {
+      case 5:
+        return setImmediate(() => {
+          return r.push(buf);
+        });
+      case 4:
+        setImmediate(() => {
+          return r.push(Buffer.alloc(0));
+        });
+        return setImmediate(r.read.bind(r, 0));
+      case 3:
+        setImmediate(r.read.bind(r, 0));
+        return process.nextTick(() => {
+          return r.push(Buffer.alloc(0));
+        });
+      case 2:
+        setImmediate(r.read.bind(r, 0));
+        return r.push(Buffer.alloc(0)); // Not-EOF!
+      case 1:
+        return r.push(buf);
+      case 0:
+        return r.push(null); // EOF
+      default:
+        throw new Error('unreachable');
+    }
+  };
+
+  const results = [];
+  function flow() {
+    let chunk;
+    while (null !== (chunk = r.read()))
+      results.push(String(chunk));
+  }
+  r.on('readable', flow);
+  r.on('end', () => {
+    results.push('EOF');
+  });
+  flow();
+
+  process.on('exit', () => {
+    assert.deepStrictEqual(results, [ 'xxxxx', 'xxxxx', 'EOF' ]);
+    console.log('ok');
+  });
+}
+
+function test2() {
+  const r = new Readable({ encoding: 'base64' });
+  let reads = 5;
+  r._read = function(n) {
+    if (!reads--)
+      return r.push(null); // EOF
+    return r.push(Buffer.from('x'));
+  };
+
+  const results = [];
+  function flow() {
+    let chunk;
+    while (null !== (chunk = r.read()))
+      results.push(String(chunk));
+  }
+  r.on('readable', flow);
+  r.on('end', () => {
+    results.push('EOF');
+  });
+  flow();
+
+  process.on('exit', () => {
+    assert.deepStrictEqual(results, [ 'eHh4', 'eHg=', 'EOF' ]);
+    console.log('ok');
+  });
+}
diff --git a/test/js/node/test/parallel/test-stream2-readable-legacy-drain.js b/test/js/node/test/parallel/test-stream2-readable-legacy-drain.js
new file mode 100644
index 0000000000..beb3657776
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream2-readable-legacy-drain.js
@@ -0,0 +1,55 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+const Stream = require('stream');
+const Readable = Stream.Readable;
+
+const r = new Readable();
+const N = 256;
+let reads = 0;
+r._read = function(n) {
+  return r.push(++reads === N ? null : Buffer.allocUnsafe(1));
+};
+
+r.on('end', common.mustCall());
+
+const w = new Stream();
+w.writable = true;
+let buffered = 0;
+w.write = function(c) {
+  buffered += c.length;
+  process.nextTick(drain);
+  return false;
+};
+
+function drain() {
+  assert(buffered <= 3);
+  buffered = 0;
+  w.emit('drain');
+}
+
+w.end = common.mustCall();
+
+r.pipe(w);
diff --git a/test/js/node/test/parallel/test-stream2-readable-non-empty-end.js b/test/js/node/test/parallel/test-stream2-readable-non-empty-end.js
new file mode 100644
index 0000000000..417f2c3b0e
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream2-readable-non-empty-end.js
@@ -0,0 +1,72 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const { Readable } = require('stream');
+
+let len = 0;
+const chunks = new Array(10);
+for (let i = 1; i <= 10; i++) {
+  chunks[i - 1] = Buffer.allocUnsafe(i);
+  len += i;
+}
+
+const test = new Readable();
+let n = 0;
+test._read = function(size) {
+  const chunk = chunks[n++];
+  setTimeout(function() {
+    test.push(chunk === undefined ? null : chunk);
+  }, 1);
+};
+
+test.on('end', thrower);
+function thrower() {
+  throw new Error('this should not happen!');
+}
+
+let bytesread = 0;
+test.on('readable', function() {
+  const b = len - bytesread - 1;
+  const res = test.read(b);
+  if (res) {
+    bytesread += res.length;
+    console.error(`br=${bytesread} len=${len}`);
+    setTimeout(next, 1);
+  }
+  test.read(0);
+});
+test.read(0);
+
+function next() {
+  // Now let's make 'end' happen
+  test.removeListener('end', thrower);
+  test.on('end', common.mustCall());
+
+  // One to get the last byte
+  let r = test.read();
+  assert(r);
+  assert.strictEqual(r.length, 1);
+  r = test.read();
+  assert.strictEqual(r, null);
+}
diff --git a/test/js/node/test/parallel/test-stream2-readable-wrap-destroy.js b/test/js/node/test/parallel/test-stream2-readable-wrap-destroy.js
new file mode 100644
index 0000000000..e310ae09e6
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream2-readable-wrap-destroy.js
@@ -0,0 +1,27 @@
+'use strict';
+const common = require('../common');
+
+const { Readable } = require('stream');
+const EE = require('events').EventEmitter;
+
+const oldStream = new EE();
+oldStream.pause = () => {};
+oldStream.resume = () => {};
+
+{
+  new Readable({
+    autoDestroy: false,
+    destroy: common.mustCall()
+  })
+    .wrap(oldStream);
+  oldStream.emit('destroy');
+}
+
+{
+  new Readable({
+    autoDestroy: false,
+    destroy: common.mustCall()
+  })
+    .wrap(oldStream);
+  oldStream.emit('close');
+}
diff --git a/test/js/node/test/parallel/test-stream2-readable-wrap-empty.js b/test/js/node/test/parallel/test-stream2-readable-wrap-empty.js
new file mode 100644
index 0000000000..3dbbdaa9b5
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream2-readable-wrap-empty.js
@@ -0,0 +1,38 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+
+const { Readable } = require('stream');
+const EE = require('events').EventEmitter;
+
+const oldStream = new EE();
+oldStream.pause = () => {};
+oldStream.resume = () => {};
+
+const newStream = new Readable().wrap(oldStream);
+
+newStream
+  .on('readable', () => {})
+  .on('end', common.mustCall());
+
+oldStream.emit('end');
diff --git a/test/js/node/test/parallel/test-stream2-readable-wrap-error.js b/test/js/node/test/parallel/test-stream2-readable-wrap-error.js
new file mode 100644
index 0000000000..2d2c26e2ca
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream2-readable-wrap-error.js
@@ -0,0 +1,37 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+const { Readable } = require('stream');
+const EE = require('events').EventEmitter;
+
+class LegacyStream extends EE {
+  pause() {}
+  resume() {}
+}
+
+{
+  const err = new Error();
+  const oldStream = new LegacyStream();
+  const r = new Readable({ autoDestroy: true })
+    .wrap(oldStream)
+    .on('error', common.mustCall(() => {
+      assert.strictEqual(r._readableState.errorEmitted, true);
+      assert.strictEqual(r._readableState.errored, err);
+      assert.strictEqual(r.destroyed, true);
+    }));
+  oldStream.emit('error', err);
+}
+
+{
+  const err = new Error();
+  const oldStream = new LegacyStream();
+  const r = new Readable({ autoDestroy: false })
+    .wrap(oldStream)
+    .on('error', common.mustCall(() => {
+      assert.strictEqual(r._readableState.errorEmitted, true);
+      assert.strictEqual(r._readableState.errored, err);
+      assert.strictEqual(r.destroyed, false);
+    }));
+  oldStream.emit('error', err);
+}
diff --git a/test/js/node/test/parallel/test-stream2-readable-wrap.js b/test/js/node/test/parallel/test-stream2-readable-wrap.js
new file mode 100644
index 0000000000..eebe72bc0d
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream2-readable-wrap.js
@@ -0,0 +1,100 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const { Readable, Writable } = require('stream');
+const EE = require('events').EventEmitter;
+
+function runTest(highWaterMark, objectMode, produce) {
+
+  const old = new EE();
+  const r = new Readable({ highWaterMark, objectMode });
+  assert.strictEqual(r, r.wrap(old));
+
+  r.on('end', common.mustCall());
+
+  old.pause = function() {
+    old.emit('pause');
+    flowing = false;
+  };
+
+  old.resume = function() {
+    old.emit('resume');
+    flow();
+  };
+
+  // Make sure pause is only emitted once.
+  let pausing = false;
+  r.on('pause', () => {
+    assert.strictEqual(pausing, false);
+    pausing = true;
+    process.nextTick(() => {
+      pausing = false;
+    });
+  });
+
+  let flowing;
+  let chunks = 10;
+  let oldEnded = false;
+  const expected = [];
+  function flow() {
+    flowing = true;
+    while (flowing && chunks-- > 0) {
+      const item = produce();
+      expected.push(item);
+      old.emit('data', item);
+    }
+    if (chunks <= 0) {
+      oldEnded = true;
+      old.emit('end');
+    }
+  }
+
+  const w = new Writable({ highWaterMark: highWaterMark * 2,
+                           objectMode });
+  const written = [];
+  w._write = function(chunk, encoding, cb) {
+    written.push(chunk);
+    setTimeout(cb, 1);
+  };
+
+  w.on('finish', common.mustCall(function() {
+    performAsserts();
+  }));
+
+  r.pipe(w);
+
+  flow();
+
+  function performAsserts() {
+    assert(oldEnded);
+    assert.deepStrictEqual(written, expected);
+  }
+}
+
+runTest(100, false, function() { return Buffer.allocUnsafe(100); });
+runTest(10, false, function() { return Buffer.from('xxxxxxxxxx'); });
+runTest(1, true, function() { return { foo: 'bar' }; });
+
+const objectChunks = [ 5, 'a', false, 0, '', 'xyz', { x: 4 }, 7, [], 555 ];
+runTest(1, true, function() { return objectChunks.shift(); });
diff --git a/test/js/node/test/parallel/test-stream2-set-encoding.js b/test/js/node/test/parallel/test-stream2-set-encoding.js
new file mode 100644
index 0000000000..2d35b161bf
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream2-set-encoding.js
@@ -0,0 +1,323 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const { Readable: R } = require('stream');
+
+class TestReader extends R {
+  constructor(n, opts) {
+    super(opts);
+    this.pos = 0;
+    this.len = n || 100;
+  }
+
+  _read(n) {
+    setTimeout(() => {
+      if (this.pos >= this.len) {
+        // Double push(null) to test eos handling
+        this.push(null);
+        return this.push(null);
+      }
+
+      n = Math.min(n, this.len - this.pos);
+      if (n <= 0) {
+        // Double push(null) to test eos handling
+        this.push(null);
+        return this.push(null);
+      }
+
+      this.pos += n;
+      const ret = Buffer.alloc(n, 'a');
+
+      return this.push(ret);
+    }, 1);
+  }
+}
+
+{
+  // Verify utf8 encoding
+  const tr = new TestReader(100);
+  tr.setEncoding('utf8');
+  const out = [];
+  const expect =
+    [ 'aaaaaaaaaa',
+      'aaaaaaaaaa',
+      'aaaaaaaaaa',
+      'aaaaaaaaaa',
+      'aaaaaaaaaa',
+      'aaaaaaaaaa',
+      'aaaaaaaaaa',
+      'aaaaaaaaaa',
+      'aaaaaaaaaa',
+      'aaaaaaaaaa' ];
+
+  tr.on('readable', function flow() {
+    let chunk;
+    while (null !== (chunk = tr.read(10)))
+      out.push(chunk);
+  });
+
+  tr.on('end', common.mustCall(function() {
+    assert.deepStrictEqual(out, expect);
+  }));
+}
+
+
+{
+  // Verify hex encoding
+  const tr = new TestReader(100);
+  tr.setEncoding('hex');
+  const out = [];
+  const expect =
+    [ '6161616161',
+      '6161616161',
+      '6161616161',
+      '6161616161',
+      '6161616161',
+      '6161616161',
+      '6161616161',
+      '6161616161',
+      '6161616161',
+      '6161616161',
+      '6161616161',
+      '6161616161',
+      '6161616161',
+      '6161616161',
+      '6161616161',
+      '6161616161',
+      '6161616161',
+      '6161616161',
+      '6161616161',
+      '6161616161' ];
+
+  tr.on('readable', function flow() {
+    let chunk;
+    while (null !== (chunk = tr.read(10)))
+      out.push(chunk);
+  });
+
+  tr.on('end', common.mustCall(function() {
+    assert.deepStrictEqual(out, expect);
+  }));
+}
+
+{
+  // Verify hex encoding with read(13)
+  const tr = new TestReader(100);
+  tr.setEncoding('hex');
+  const out = [];
+  const expect =
+    [ '6161616161616',
+      '1616161616161',
+      '6161616161616',
+      '1616161616161',
+      '6161616161616',
+      '1616161616161',
+      '6161616161616',
+      '1616161616161',
+      '6161616161616',
+      '1616161616161',
+      '6161616161616',
+      '1616161616161',
+      '6161616161616',
+      '1616161616161',
+      '6161616161616',
+      '16161' ];
+
+  tr.on('readable', function flow() {
+    let chunk;
+    while (null !== (chunk = tr.read(13)))
+      out.push(chunk);
+  });
+
+  tr.on('end', common.mustCall(function() {
+    assert.deepStrictEqual(out, expect);
+  }));
+}
+
+{
+  // Verify base64 encoding
+  const tr = new TestReader(100);
+  tr.setEncoding('base64');
+  const out = [];
+  const expect =
+    [ 'YWFhYWFhYW',
+      'FhYWFhYWFh',
+      'YWFhYWFhYW',
+      'FhYWFhYWFh',
+      'YWFhYWFhYW',
+      'FhYWFhYWFh',
+      'YWFhYWFhYW',
+      'FhYWFhYWFh',
+      'YWFhYWFhYW',
+      'FhYWFhYWFh',
+      'YWFhYWFhYW',
+      'FhYWFhYWFh',
+      'YWFhYWFhYW',
+      'FhYQ==' ];
+
+  tr.on('readable', function flow() {
+    let chunk;
+    while (null !== (chunk = tr.read(10)))
+      out.push(chunk);
+  });
+
+  tr.on('end', common.mustCall(function() {
+    assert.deepStrictEqual(out, expect);
+  }));
+}
+
+{
+  // Verify utf8 encoding
+  const tr = new TestReader(100, { encoding: 'utf8' });
+  const out = [];
+  const expect =
+    [ 'aaaaaaaaaa',
+      'aaaaaaaaaa',
+      'aaaaaaaaaa',
+      'aaaaaaaaaa',
+      'aaaaaaaaaa',
+      'aaaaaaaaaa',
+      'aaaaaaaaaa',
+      'aaaaaaaaaa',
+      'aaaaaaaaaa',
+      'aaaaaaaaaa' ];
+
+  tr.on('readable', function flow() {
+    let chunk;
+    while (null !== (chunk = tr.read(10)))
+      out.push(chunk);
+  });
+
+  tr.on('end', common.mustCall(function() {
+    assert.deepStrictEqual(out, expect);
+  }));
+}
+
+
+{
+  // Verify hex encoding
+  const tr = new TestReader(100, { encoding: 'hex' });
+  const out = [];
+  const expect =
+    [ '6161616161',
+      '6161616161',
+      '6161616161',
+      '6161616161',
+      '6161616161',
+      '6161616161',
+      '6161616161',
+      '6161616161',
+      '6161616161',
+      '6161616161',
+      '6161616161',
+      '6161616161',
+      '6161616161',
+      '6161616161',
+      '6161616161',
+      '6161616161',
+      '6161616161',
+      '6161616161',
+      '6161616161',
+      '6161616161' ];
+
+  tr.on('readable', function flow() {
+    let chunk;
+    while (null !== (chunk = tr.read(10)))
+      out.push(chunk);
+  });
+
+  tr.on('end', common.mustCall(function() {
+    assert.deepStrictEqual(out, expect);
+  }));
+}
+
+{
+  // Verify hex encoding with read(13)
+  const tr = new TestReader(100, { encoding: 'hex' });
+  const out = [];
+  const expect =
+    [ '6161616161616',
+      '1616161616161',
+      '6161616161616',
+      '1616161616161',
+      '6161616161616',
+      '1616161616161',
+      '6161616161616',
+      '1616161616161',
+      '6161616161616',
+      '1616161616161',
+      '6161616161616',
+      '1616161616161',
+      '6161616161616',
+      '1616161616161',
+      '6161616161616',
+      '16161' ];
+
+  tr.on('readable', function flow() {
+    let chunk;
+    while (null !== (chunk = tr.read(13)))
+      out.push(chunk);
+  });
+
+  tr.on('end', common.mustCall(function() {
+    assert.deepStrictEqual(out, expect);
+  }));
+}
+
+{
+  // Verify base64 encoding
+  const tr = new TestReader(100, { encoding: 'base64' });
+  const out = [];
+  const expect =
+    [ 'YWFhYWFhYW',
+      'FhYWFhYWFh',
+      'YWFhYWFhYW',
+      'FhYWFhYWFh',
+      'YWFhYWFhYW',
+      'FhYWFhYWFh',
+      'YWFhYWFhYW',
+      'FhYWFhYWFh',
+      'YWFhYWFhYW',
+      'FhYWFhYWFh',
+      'YWFhYWFhYW',
+      'FhYWFhYWFh',
+      'YWFhYWFhYW',
+      'FhYQ==' ];
+
+  tr.on('readable', function flow() {
+    let chunk;
+    while (null !== (chunk = tr.read(10)))
+      out.push(chunk);
+  });
+
+  tr.on('end', common.mustCall(function() {
+    assert.deepStrictEqual(out, expect);
+  }));
+}
+
+{
+  // Verify chaining behavior
+  const tr = new TestReader(100);
+  assert.deepStrictEqual(tr.setEncoding('utf8'), tr);
+}
diff --git a/test/js/node/test/parallel/test-stream2-unpipe-drain.js b/test/js/node/test/parallel/test-stream2-unpipe-drain.js
new file mode 100644
index 0000000000..4c283df680
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream2-unpipe-drain.js
@@ -0,0 +1,72 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+
+const stream = require('stream');
+
+class TestWriter extends stream.Writable {
+  _write(buffer, encoding, callback) {
+    console.log('write called');
+    // Super slow write stream (callback never called)
+  }
+}
+
+const dest = new TestWriter();
+
+class TestReader extends stream.Readable {
+  constructor() {
+    super();
+    this.reads = 0;
+  }
+
+  _read(size) {
+    this.reads += 1;
+    this.push(Buffer.alloc(size));
+  }
+}
+
+const src1 = new TestReader();
+const src2 = new TestReader();
+
+src1.pipe(dest);
+
+src1.once('readable', () => {
+  process.nextTick(() => {
+
+    src2.pipe(dest);
+
+    src2.once('readable', () => {
+      process.nextTick(() => {
+
+        src1.unpipe(dest);
+      });
+    });
+  });
+});
+
+
+process.on('exit', () => {
+  assert.strictEqual(src1.reads, 2);
+  assert.strictEqual(src2.reads, 2);
+});
diff --git a/test/js/node/test/parallel/test-stream3-cork-end.js b/test/js/node/test/parallel/test-stream3-cork-end.js
new file mode 100644
index 0000000000..0cbc033a2e
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream3-cork-end.js
@@ -0,0 +1,91 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const stream = require('stream');
+const Writable = stream.Writable;
+
+// Test the buffering behavior of Writable streams.
+//
+// The call to cork() triggers storing chunks which are flushed
+// on calling end() and the stream subsequently ended.
+//
+// node version target: 0.12
+
+const expectedChunks = ['please', 'buffer', 'me', 'kindly'];
+const inputChunks = expectedChunks.slice(0);
+let seenChunks = [];
+let seenEnd = false;
+
+const w = new Writable();
+// Let's arrange to store the chunks.
+w._write = function(chunk, encoding, cb) {
+  // Stream end event is not seen before the last write.
+  assert.ok(!seenEnd);
+  // Default encoding given none was specified.
+  assert.strictEqual(encoding, 'buffer');
+
+  seenChunks.push(chunk);
+  cb();
+};
+// Let's record the stream end event.
+w.on('finish', () => {
+  seenEnd = true;
+});
+
+function writeChunks(remainingChunks, callback) {
+  const writeChunk = remainingChunks.shift();
+  let writeState;
+
+  if (writeChunk) {
+    setImmediate(() => {
+      writeState = w.write(writeChunk);
+      // We were not told to stop writing.
+      assert.ok(writeState);
+
+      writeChunks(remainingChunks, callback);
+    });
+  } else {
+    callback();
+  }
+}
+
+// Do an initial write.
+w.write('stuff');
+// The write was immediate.
+assert.strictEqual(seenChunks.length, 1);
+// Reset the seen chunks.
+seenChunks = [];
+
+// Trigger stream buffering.
+w.cork();
+
+// Write the bufferedChunks.
+writeChunks(inputChunks, () => {
+  // Should not have seen anything yet.
+  assert.strictEqual(seenChunks.length, 0);
+
+  // Trigger flush and ending the stream.
+  w.end();
+
+  // Stream should not ended in current tick.
+  assert.ok(!seenEnd);
+
+  // Buffered bytes should be seen in current tick.
+  assert.strictEqual(seenChunks.length, 4);
+
+  // Did the chunks match.
+  for (let i = 0, l = expectedChunks.length; i < l; i++) {
+    const seen = seenChunks[i];
+    // There was a chunk.
+    assert.ok(seen);
+
+    const expected = Buffer.from(expectedChunks[i]);
+    // It was what we expected.
+    assert.ok(seen.equals(expected));
+  }
+
+  setImmediate(() => {
+    // Stream should have ended in next tick.
+    assert.ok(seenEnd);
+  });
+});
diff --git a/test/js/node/test/parallel/test-stream3-cork-uncork.js b/test/js/node/test/parallel/test-stream3-cork-uncork.js
new file mode 100644
index 0000000000..dfb901af41
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream3-cork-uncork.js
@@ -0,0 +1,86 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const stream = require('stream');
+const Writable = stream.Writable;
+
+// Test the buffering behavior of Writable streams.
+//
+// The call to cork() triggers storing chunks which are flushed
+// on calling uncork() in the same tick.
+//
+// node version target: 0.12
+
+const expectedChunks = ['please', 'buffer', 'me', 'kindly'];
+const inputChunks = expectedChunks.slice(0);
+let seenChunks = [];
+let seenEnd = false;
+
+const w = new Writable();
+// Let's arrange to store the chunks.
+w._write = function(chunk, encoding, cb) {
+  // Default encoding given none was specified.
+  assert.strictEqual(encoding, 'buffer');
+
+  seenChunks.push(chunk);
+  cb();
+};
+// Let's record the stream end event.
+w.on('finish', () => {
+  seenEnd = true;
+});
+
+function writeChunks(remainingChunks, callback) {
+  const writeChunk = remainingChunks.shift();
+  let writeState;
+
+  if (writeChunk) {
+    setImmediate(() => {
+      writeState = w.write(writeChunk);
+      // We were not told to stop writing.
+      assert.ok(writeState);
+
+      writeChunks(remainingChunks, callback);
+    });
+  } else {
+    callback();
+  }
+}
+
+// Do an initial write.
+w.write('stuff');
+// The write was immediate.
+assert.strictEqual(seenChunks.length, 1);
+// Reset the chunks seen so far.
+seenChunks = [];
+
+// Trigger stream buffering.
+w.cork();
+
+// Write the bufferedChunks.
+writeChunks(inputChunks, () => {
+  // Should not have seen anything yet.
+  assert.strictEqual(seenChunks.length, 0);
+
+  // Trigger writing out the buffer.
+  w.uncork();
+
+  // Buffered bytes should be seen in current tick.
+  assert.strictEqual(seenChunks.length, 4);
+
+  // Did the chunks match.
+  for (let i = 0, l = expectedChunks.length; i < l; i++) {
+    const seen = seenChunks[i];
+    // There was a chunk.
+    assert.ok(seen);
+
+    const expected = Buffer.from(expectedChunks[i]);
+    // It was what we expected.
+    assert.ok(seen.equals(expected));
+  }
+
+  setImmediate(() => {
+    // The stream should not have been ended.
+    assert.ok(!seenEnd);
+  });
+});
diff --git a/test/js/node/test/parallel/test-stream3-pause-then-read.js b/test/js/node/test/parallel/test-stream3-pause-then-read.js
new file mode 100644
index 0000000000..1a38547220
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream3-pause-then-read.js
@@ -0,0 +1,170 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+
+const stream = require('stream');
+const Readable = stream.Readable;
+const Writable = stream.Writable;
+
+const totalChunks = 100;
+const chunkSize = 99;
+const expectTotalData = totalChunks * chunkSize;
+let expectEndingData = expectTotalData;
+
+const r = new Readable({ highWaterMark: 1000 });
+let chunks = totalChunks;
+r._read = function(n) {
+  console.log('_read called', chunks);
+  if (!(chunks % 2))
+    setImmediate(push);
+  else if (!(chunks % 3))
+    process.nextTick(push);
+  else
+    push();
+};
+
+let totalPushed = 0;
+function push() {
+  const chunk = chunks-- > 0 ? Buffer.alloc(chunkSize, 'x') : null;
+  if (chunk) {
+    totalPushed += chunk.length;
+  }
+  console.log('chunks', chunks);
+  r.push(chunk);
+}
+
+read100();
+
+// First we read 100 bytes.
+function read100() {
+  readn(100, onData);
+}
+
+function readn(n, then) {
+  console.error(`read ${n}`);
+  expectEndingData -= n;
+  (function read() {
+    const c = r.read(n);
+    console.error('c', c);
+    if (!c)
+      r.once('readable', read);
+    else {
+      assert.strictEqual(c.length, n);
+      assert(!r.readableFlowing);
+      then();
+    }
+  })();
+}
+
+// Then we listen to some data events.
+function onData() {
+  expectEndingData -= 100;
+  console.error('onData');
+  let seen = 0;
+  r.on('data', function od(c) {
+    seen += c.length;
+    if (seen >= 100) {
+      // Seen enough
+      r.removeListener('data', od);
+      r.pause();
+      if (seen > 100) {
+        // Oh no, seen too much!
+        // Put the extra back.
+        const diff = seen - 100;
+        r.unshift(c.slice(c.length - diff));
+        console.error('seen too much', seen, diff);
+      }
+
+      // Nothing should be lost in-between.
+      setImmediate(pipeLittle);
+    }
+  });
+}
+
+// Just pipe 200 bytes, then unshift the extra and unpipe.
+function pipeLittle() {
+  expectEndingData -= 200;
+  console.error('pipe a little');
+  const w = new Writable();
+  let written = 0;
+  w.on('finish', () => {
+    assert.strictEqual(written, 200);
+    setImmediate(read1234);
+  });
+  w._write = function(chunk, encoding, cb) {
+    written += chunk.length;
+    if (written >= 200) {
+      r.unpipe(w);
+      w.end();
+      cb();
+      if (written > 200) {
+        const diff = written - 200;
+        written -= diff;
+        r.unshift(chunk.slice(chunk.length - diff));
+      }
+    } else {
+      setImmediate(cb);
+    }
+  };
+  r.pipe(w);
+}
+
+// Now read 1234 more bytes.
+function read1234() {
+  readn(1234, resumePause);
+}
+
+function resumePause() {
+  console.error('resumePause');
+  // Don't read anything, just resume and re-pause a whole bunch.
+  r.resume();
+  r.pause();
+  r.resume();
+  r.pause();
+  r.resume();
+  r.pause();
+  r.resume();
+  r.pause();
+  r.resume();
+  r.pause();
+  setImmediate(pipe);
+}
+
+
+function pipe() {
+  console.error('pipe the rest');
+  const w = new Writable();
+  let written = 0;
+  w._write = function(chunk, encoding, cb) {
+    written += chunk.length;
+    cb();
+  };
+  w.on('finish', () => {
+    console.error('written', written, totalPushed);
+    assert.strictEqual(written, expectEndingData);
+    assert.strictEqual(totalPushed, expectTotalData);
+    console.log('ok');
+  });
+  r.pipe(w);
+}
diff --git a/test/js/node/test/parallel/test-stream3-pipeline-async-iterator.js b/test/js/node/test/parallel/test-stream3-pipeline-async-iterator.js
new file mode 100644
index 0000000000..ad1e464777
--- /dev/null
+++ b/test/js/node/test/parallel/test-stream3-pipeline-async-iterator.js
@@ -0,0 +1,27 @@
+/* eslint-disable node-core/require-common-first, require-yield */
+'use strict';
+const { pipeline } = require('node:stream/promises');
+{
+  // Ensure that async iterators can act as readable and writable streams
+  async function* myCustomReadable() {
+    yield 'Hello';
+    yield 'World';
+  }
+
+  const messages = [];
+  async function* myCustomWritable(stream) {
+    for await (const chunk of stream) {
+      messages.push(chunk);
+    }
+  }
+
+  (async () => {
+    await pipeline(
+      myCustomReadable,
+      myCustomWritable,
+    );
+    // Importing here to avoid initializing streams
+    require('assert').deepStrictEqual(messages, ['Hello', 'World']);
+  })()
+  .then(require('../common').mustCall());
+}
diff --git a/test/js/node/test/parallel/test-string-decoder-end.js b/test/js/node/test/parallel/test-string-decoder-end.js
new file mode 100644
index 0000000000..5a3c5cc720
--- /dev/null
+++ b/test/js/node/test/parallel/test-string-decoder-end.js
@@ -0,0 +1,128 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+// Verify that the string decoder works getting 1 byte at a time,
+// the whole buffer at once, and that both match the .toString(enc)
+// result of the entire buffer.
+
+require('../common');
+const assert = require('assert');
+const SD = require('string_decoder').StringDecoder;
+const encodings = ['base64', 'base64url', 'hex', 'utf8', 'utf16le', 'ucs2'];
+
+const bufs = [ '☃💩', 'asdf' ].map((b) => Buffer.from(b));
+
+// Also test just arbitrary bytes from 0-15.
+for (let i = 1; i <= 16; i++) {
+  const bytes = '.'.repeat(i - 1).split('.').map((_, j) => j + 0x78);
+  bufs.push(Buffer.from(bytes));
+}
+
+encodings.forEach(testEncoding);
+
+testEnd('utf8', Buffer.of(0xE2), Buffer.of(0x61), '\uFFFDa');
+testEnd('utf8', Buffer.of(0xE2), Buffer.of(0x82), '\uFFFD\uFFFD');
+testEnd('utf8', Buffer.of(0xE2), Buffer.of(0xE2), '\uFFFD\uFFFD');
+testEnd('utf8', Buffer.of(0xE2, 0x82), Buffer.of(0x61), '\uFFFDa');
+testEnd('utf8', Buffer.of(0xE2, 0x82), Buffer.of(0xAC), '\uFFFD\uFFFD');
+testEnd('utf8', Buffer.of(0xE2, 0x82), Buffer.of(0xE2), '\uFFFD\uFFFD');
+testEnd('utf8', Buffer.of(0xE2, 0x82, 0xAC), Buffer.of(0x61), '€a');
+
+testEnd('utf16le', Buffer.of(0x3D), Buffer.of(0x61, 0x00), 'a');
+testEnd('utf16le', Buffer.of(0x3D), Buffer.of(0xD8, 0x4D, 0xDC), '\u4DD8');
+testEnd('utf16le', Buffer.of(0x3D, 0xD8), Buffer.of(), '\uD83D');
+testEnd('utf16le', Buffer.of(0x3D, 0xD8), Buffer.of(0x61, 0x00), '\uD83Da');
+testEnd(
+  'utf16le',
+  Buffer.of(0x3D, 0xD8),
+  Buffer.of(0x4D, 0xDC),
+  '\uD83D\uDC4D'
+);
+testEnd('utf16le', Buffer.of(0x3D, 0xD8, 0x4D), Buffer.of(), '\uD83D');
+testEnd(
+  'utf16le',
+  Buffer.of(0x3D, 0xD8, 0x4D),
+  Buffer.of(0x61, 0x00),
+  '\uD83Da'
+);
+testEnd('utf16le', Buffer.of(0x3D, 0xD8, 0x4D), Buffer.of(0xDC), '\uD83D');
+testEnd(
+  'utf16le',
+  Buffer.of(0x3D, 0xD8, 0x4D, 0xDC),
+  Buffer.of(0x61, 0x00),
+  '👍a'
+);
+
+testEnd('base64', Buffer.of(0x61), Buffer.of(), 'YQ==');
+testEnd('base64', Buffer.of(0x61), Buffer.of(0x61), 'YQ==YQ==');
+testEnd('base64', Buffer.of(0x61, 0x61), Buffer.of(), 'YWE=');
+testEnd('base64', Buffer.of(0x61, 0x61), Buffer.of(0x61), 'YWE=YQ==');
+testEnd('base64', Buffer.of(0x61, 0x61, 0x61), Buffer.of(), 'YWFh');
+testEnd('base64', Buffer.of(0x61, 0x61, 0x61), Buffer.of(0x61), 'YWFhYQ==');
+
+testEnd('base64url', Buffer.of(0x61), Buffer.of(), 'YQ');
+testEnd('base64url', Buffer.of(0x61), Buffer.of(0x61), 'YQYQ');
+testEnd('base64url', Buffer.of(0x61, 0x61), Buffer.of(), 'YWE');
+testEnd('base64url', Buffer.of(0x61, 0x61), Buffer.of(0x61), 'YWEYQ');
+testEnd('base64url', Buffer.of(0x61, 0x61, 0x61), Buffer.of(), 'YWFh');
+testEnd('base64url', Buffer.of(0x61, 0x61, 0x61), Buffer.of(0x61), 'YWFhYQ');
+
+function testEncoding(encoding) {
+  bufs.forEach((buf) => {
+    testBuf(encoding, buf);
+  });
+}
+
+function testBuf(encoding, buf) {
+  // Write one byte at a time.
+  let s = new SD(encoding);
+  let res1 = '';
+  for (let i = 0; i < buf.length; i++) {
+    res1 += s.write(buf.slice(i, i + 1));
+  }
+  res1 += s.end();
+
+  // Write the whole buffer at once.
+  let res2 = '';
+  s = new SD(encoding);
+  res2 += s.write(buf);
+  res2 += s.end();
+
+  // .toString() on the buffer
+  const res3 = buf.toString(encoding);
+
+  // One byte at a time should match toString
+  assert.strictEqual(res1, res3);
+  // All bytes at once should match toString
+  assert.strictEqual(res2, res3);
+}
+
+function testEnd(encoding, incomplete, next, expected) {
+  let res = '';
+  const s = new SD(encoding);
+  res += s.write(incomplete);
+  res += s.end();
+  res += s.write(next);
+  res += s.end();
+
+  assert.strictEqual(res, expected);
+}
diff --git a/test/js/node/test/parallel/test-stringbytes-external.js b/test/js/node/test/parallel/test-stringbytes-external.js
new file mode 100644
index 0000000000..d64312f525
--- /dev/null
+++ b/test/js/node/test/parallel/test-stringbytes-external.js
@@ -0,0 +1,143 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+// Minimum string size to overflow into external string space
+const EXTERN_APEX = 0xFBEE9;
+
+// Manually controlled string for checking binary output
+let ucs2_control = 'a\u0000';
+let write_str = 'a';
+
+
+// First do basic checks
+let b = Buffer.from(write_str, 'ucs2');
+// first check latin1
+let c = b.toString('latin1');
+assert.strictEqual(b[0], 0x61);
+assert.strictEqual(b[1], 0);
+assert.strictEqual(ucs2_control, c);
+// now check binary
+c = b.toString('binary');
+assert.strictEqual(b[0], 0x61);
+assert.strictEqual(b[1], 0);
+assert.strictEqual(ucs2_control, c);
+
+// Now create big strings
+const size = 1 << 20;
+write_str = write_str.repeat(size);
+ucs2_control = ucs2_control.repeat(size);
+
+// Check resultant buffer and output string
+b = Buffer.from(write_str, 'ucs2');
+// Check fist Buffer created from write string
+for (let i = 0; i < b.length; i += 2) {
+  assert.strictEqual(b[i], 0x61);
+  assert.strictEqual(b[i + 1], 0);
+}
+
+// Create another string to create an external string
+const b_ucs = b.toString('ucs2');
+
+// Check control against external binary string
+const l_bin = b.toString('latin1');
+assert.strictEqual(ucs2_control, l_bin);
+
+// Check control against external binary string
+const b_bin = b.toString('binary');
+assert.strictEqual(ucs2_control, b_bin);
+
+// Create buffer copy from external
+const c_bin = Buffer.from(l_bin, 'latin1');
+const c_ucs = Buffer.from(b_ucs, 'ucs2');
+// Make sure they're the same length
+assert.strictEqual(c_bin.length, c_ucs.length);
+// Make sure Buffers from externals are the same
+for (let i = 0; i < c_bin.length; i++) {
+  assert.strictEqual(c_bin[i], c_ucs[i]);
+}
+// Check resultant strings
+assert.strictEqual(c_bin.toString('ucs2'), c_ucs.toString('ucs2'));
+assert.strictEqual(c_bin.toString('latin1'), ucs2_control);
+assert.strictEqual(c_ucs.toString('latin1'), ucs2_control);
+
+
+// Now let's test BASE64 and HEX encoding/decoding
+const RADIOS = 2;
+const PRE_HALF_APEX = Math.ceil(EXTERN_APEX / 2) - RADIOS;
+const PRE_3OF4_APEX = Math.ceil((EXTERN_APEX / 4) * 3) - RADIOS;
+
+{
+  for (let j = 0; j < RADIOS * 2; j += 1) {
+    const datum = b;
+    const slice = datum.slice(0, PRE_HALF_APEX + j);
+    const slice2 = datum.slice(0, PRE_HALF_APEX + j + 2);
+    const pumped_string = slice.toString('hex');
+    const pumped_string2 = slice2.toString('hex');
+    const decoded = Buffer.from(pumped_string, 'hex');
+
+    // The string are the same?
+    for (let k = 0; k < pumped_string.length; ++k) {
+      assert.strictEqual(pumped_string[k], pumped_string2[k]);
+    }
+
+    // The recoded buffer is the same?
+    for (let i = 0; i < decoded.length; ++i) {
+      assert.strictEqual(datum[i], decoded[i]);
+    }
+  }
+}
+
+{
+  for (let j = 0; j < RADIOS * 2; j += 1) {
+    const datum = b;
+    const slice = datum.slice(0, PRE_3OF4_APEX + j);
+    const slice2 = datum.slice(0, PRE_3OF4_APEX + j + 2);
+    const pumped_string = slice.toString('base64');
+    const pumped_string2 = slice2.toString('base64');
+    const decoded = Buffer.from(pumped_string, 'base64');
+
+    // The string are the same?
+    for (let k = 0; k < pumped_string.length - 3; ++k) {
+      assert.strictEqual(pumped_string[k], pumped_string2[k]);
+    }
+
+    // The recoded buffer is the same?
+    for (let i = 0; i < decoded.length; ++i) {
+      assert.strictEqual(datum[i], decoded[i]);
+    }
+  }
+}
+
+// https://github.com/nodejs/node/issues/1024
+{
+  const a = 'x'.repeat(1 << 20 - 1);
+  const b = Buffer.from(a, 'ucs2').toString('ucs2');
+  const c = Buffer.from(b, 'utf8').toString('utf8');
+
+  assert.strictEqual(a.length, b.length);
+  assert.strictEqual(b.length, c.length);
+
+  assert.strictEqual(a, b);
+  assert.strictEqual(b, c);
+}
diff --git a/test/js/node/test/parallel/test-sync-fileread.js b/test/js/node/test/parallel/test-sync-fileread.js
new file mode 100644
index 0000000000..826f62d220
--- /dev/null
+++ b/test/js/node/test/parallel/test-sync-fileread.js
@@ -0,0 +1,7 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const fs = require('fs');
+const fixtures = require('../common/fixtures');
+
+assert.strictEqual(fs.readFileSync(fixtures.path('x.txt')).toString(), 'xyz\n');
diff --git a/test/js/node/test/parallel/test-sys.js b/test/js/node/test/parallel/test-sys.js
new file mode 100644
index 0000000000..a7a77b8e1c
--- /dev/null
+++ b/test/js/node/test/parallel/test-sys.js
@@ -0,0 +1,28 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const sys = require('sys'); // eslint-disable-line no-restricted-modules
+const util = require('util');
+
+assert.strictEqual(sys, util);
diff --git a/test/js/node/test/parallel/test-timers-api-refs.js b/test/js/node/test/parallel/test-timers-api-refs.js
new file mode 100644
index 0000000000..3c55a05ac4
--- /dev/null
+++ b/test/js/node/test/parallel/test-timers-api-refs.js
@@ -0,0 +1,21 @@
+'use strict';
+const common = require('../common');
+const timers = require('timers');
+
+// Delete global APIs to make sure they're not relied on by the internal timers
+// code
+delete global.setTimeout;
+delete global.clearTimeout;
+delete global.setInterval;
+delete global.clearInterval;
+delete global.setImmediate;
+delete global.clearImmediate;
+
+const timeoutCallback = () => { timers.clearTimeout(timeout); };
+const timeout = timers.setTimeout(common.mustCall(timeoutCallback), 1);
+
+const intervalCallback = () => { timers.clearInterval(interval); };
+const interval = timers.setInterval(common.mustCall(intervalCallback), 1);
+
+const immediateCallback = () => { timers.clearImmediate(immediate); };
+const immediate = timers.setImmediate(immediateCallback);
diff --git a/test/js/node/test/parallel/test-timers-args.js b/test/js/node/test/parallel/test-timers-args.js
new file mode 100644
index 0000000000..1ba44d8bcf
--- /dev/null
+++ b/test/js/node/test/parallel/test-timers-args.js
@@ -0,0 +1,31 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+
+function range(n) {
+  return 'x'.repeat(n + 1).split('').map(function(_, i) { return i; });
+}
+
+function timeout(nargs) {
+  const args = range(nargs);
+  setTimeout.apply(null, [callback, 1].concat(args));
+
+  function callback() {
+    assert.deepStrictEqual([].slice.call(arguments), args);
+    if (nargs < 128) timeout(nargs + 1);
+  }
+}
+
+function interval(nargs) {
+  const args = range(nargs);
+  const timer = setTimeout.apply(null, [callback, 1].concat(args));
+
+  function callback() {
+    clearInterval(timer);
+    assert.deepStrictEqual([].slice.call(arguments), args);
+    if (nargs < 128) interval(nargs + 1);
+  }
+}
+
+timeout(0);
+interval(0);
diff --git a/test/js/node/test/parallel/test-timers-clear-object-does-not-throw-error.js b/test/js/node/test/parallel/test-timers-clear-object-does-not-throw-error.js
new file mode 100644
index 0000000000..9752f53abd
--- /dev/null
+++ b/test/js/node/test/parallel/test-timers-clear-object-does-not-throw-error.js
@@ -0,0 +1,8 @@
+'use strict';
+require('../common');
+
+// This test makes sure clearing timers with
+// objects doesn't throw
+clearImmediate({});
+clearTimeout({});
+clearInterval({});
diff --git a/test/js/node/test/parallel/test-timers-clear-timeout-interval-equivalent.js b/test/js/node/test/parallel/test-timers-clear-timeout-interval-equivalent.js
new file mode 100644
index 0000000000..94611b7070
--- /dev/null
+++ b/test/js/node/test/parallel/test-timers-clear-timeout-interval-equivalent.js
@@ -0,0 +1,18 @@
+'use strict';
+const common = require('../common');
+
+// This test makes sure that timers created with setTimeout can be disarmed by
+// clearInterval and that timers created with setInterval can be disarmed by
+// clearTimeout.
+//
+// This behavior is documented in the HTML Living Standard:
+//
+// * Refs: https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-setinterval
+
+// Disarm interval with clearTimeout.
+const interval = setInterval(common.mustNotCall(), 1);
+clearTimeout(interval);
+
+// Disarm timeout with clearInterval.
+const timeout = setTimeout(common.mustNotCall(), 1);
+clearInterval(timeout);
diff --git a/test/js/node/test/parallel/test-timers-clearImmediate.js b/test/js/node/test/parallel/test-timers-clearImmediate.js
new file mode 100644
index 0000000000..ccd9826bb0
--- /dev/null
+++ b/test/js/node/test/parallel/test-timers-clearImmediate.js
@@ -0,0 +1,13 @@
+'use strict';
+const common = require('../common');
+
+const N = 3;
+
+function next() {
+  const fn = common.mustCall(() => clearImmediate(immediate));
+  const immediate = setImmediate(fn);
+}
+
+for (let i = 0; i < N; i++) {
+  next();
+}
diff --git a/test/js/node/test/parallel/test-timers-immediate-queue.js b/test/js/node/test/parallel/test-timers-immediate-queue.js
new file mode 100644
index 0000000000..8b433ddedb
--- /dev/null
+++ b/test/js/node/test/parallel/test-timers-immediate-queue.js
@@ -0,0 +1,56 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+
+// setImmediate should run clear its queued cbs once per event loop turn
+// but immediates queued while processing the current queue should happen
+// on the next turn of the event loop.
+
+// hit should be the exact same size of QUEUE, if we're letting things
+// recursively add to the immediate QUEUE hit will be > QUEUE
+
+let ticked = false;
+
+let hit = 0;
+const QUEUE = 10;
+
+function run() {
+  if (hit === 0) {
+    setTimeout(() => { ticked = true; }, 1);
+    const now = Date.now();
+    while (Date.now() - now < 2);
+  }
+
+  if (ticked) return;
+
+  hit += 1;
+  setImmediate(run);
+}
+
+for (let i = 0; i < QUEUE; i++)
+  setImmediate(run);
+
+process.on('exit', function() {
+  assert.strictEqual(hit, QUEUE);
+});
diff --git a/test/js/node/test/parallel/test-timers-immediate.js b/test/js/node/test/parallel/test-timers-immediate.js
new file mode 100644
index 0000000000..0227e38efa
--- /dev/null
+++ b/test/js/node/test/parallel/test-timers-immediate.js
@@ -0,0 +1,43 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+let mainFinished = false;
+
+setImmediate(common.mustCall(function() {
+  assert.strictEqual(mainFinished, true);
+  clearImmediate(immediateB);
+}));
+
+const immediateB = setImmediate(common.mustNotCall());
+
+setImmediate(common.mustCall((...args) => {
+  assert.deepStrictEqual(args, [1, 2, 3]);
+}), 1, 2, 3);
+
+setImmediate(common.mustCall((...args) => {
+  assert.deepStrictEqual(args, [1, 2, 3, 4, 5]);
+}), 1, 2, 3, 4, 5);
+
+mainFinished = true;
diff --git a/test/js/node/test/parallel/test-timers-interval-throw.js b/test/js/node/test/parallel/test-timers-interval-throw.js
new file mode 100644
index 0000000000..876f0de55a
--- /dev/null
+++ b/test/js/node/test/parallel/test-timers-interval-throw.js
@@ -0,0 +1,17 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+
+// To match browser behaviour, interval should continue
+// being rescheduled even if it throws.
+
+let count = 2;
+const interval = setInterval(() => { throw new Error('IntervalError'); }, 1);
+
+process.on('uncaughtException', common.mustCall((err) => {
+  assert.strictEqual(err.message, 'IntervalError');
+  if (--count === 0) {
+    clearInterval(interval);
+  }
+}, 2));
diff --git a/test/js/node/test/parallel/test-timers-non-integer-delay.js b/test/js/node/test/parallel/test-timers-non-integer-delay.js
new file mode 100644
index 0000000000..089c1fee8b
--- /dev/null
+++ b/test/js/node/test/parallel/test-timers-non-integer-delay.js
@@ -0,0 +1,81 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+// This test makes sure that non-integer timer delays do not make the process
+// hang. See https://github.com/joyent/node/issues/8065 and
+// https://github.com/joyent/node/issues/8068 which have been fixed by
+// https://github.com/joyent/node/pull/8073.
+//
+// If the process hangs, this test will make the tests suite timeout,
+// otherwise it will exit very quickly (after 50 timers with a short delay
+// fire).
+//
+// We have to set at least several timers with a non-integer delay to
+// reproduce the issue. Sometimes, a timer with a non-integer delay will
+// expire correctly. 50 timers has always been more than enough to reproduce
+// it 100%.
+
+const TIMEOUT_DELAY = 1.1;
+let N = 50;
+
+const interval = setInterval(common.mustCall(() => {
+  if (--N === 0) {
+    clearInterval(interval);
+  }
+}, N), TIMEOUT_DELAY);
+
+// Test non-integer delay ordering
+{
+  const ordering = [];
+
+  setTimeout(common.mustCall(() => {
+    ordering.push(1);
+  }), 1);
+
+  setTimeout(common.mustCall(() => {
+    ordering.push(2);
+  }), 1.8);
+
+  setTimeout(common.mustCall(() => {
+    ordering.push(3);
+  }), 1.1);
+
+  setTimeout(common.mustCall(() => {
+    ordering.push(4);
+  }), 1);
+
+  setTimeout(common.mustCall(() => {
+    const expected = [1, 2, 3, 4];
+
+    assert.deepStrictEqual(
+      ordering,
+      expected,
+      `Non-integer delay ordering should be ${expected}, but got ${ordering}`
+    );
+
+    // 2 should always be last of these delays due to ordering guarantees by
+    // the implementation.
+  }), 2);
+}
diff --git a/test/js/node/test/parallel/test-timers-process-tampering.js b/test/js/node/test/parallel/test-timers-process-tampering.js
new file mode 100644
index 0000000000..766cc9f356
--- /dev/null
+++ b/test/js/node/test/parallel/test-timers-process-tampering.js
@@ -0,0 +1,8 @@
+// Check that setImmediate works even if process is tampered with.
+// This is a regression test for https://github.com/nodejs/node/issues/17681.
+
+'use strict';
+const common = require('../common');
+global.process = {};  // Boom!
+common.allowGlobals(global.process);
+setImmediate(common.mustCall());
diff --git a/test/js/node/test/parallel/test-timers-promises-scheduler.js b/test/js/node/test/parallel/test-timers-promises-scheduler.js
new file mode 100644
index 0000000000..7caf92fdf6
--- /dev/null
+++ b/test/js/node/test/parallel/test-timers-promises-scheduler.js
@@ -0,0 +1,50 @@
+'use strict';
+
+const common = require('../common');
+
+const { scheduler } = require('timers/promises');
+const { setTimeout } = require('timers');
+const {
+  strictEqual,
+  rejects,
+} = require('assert');
+
+async function testYield() {
+  await scheduler.yield();
+  process.emit('foo');
+}
+testYield().then(common.mustCall());
+queueMicrotask(common.mustCall(() => {
+  process.addListener('foo', common.mustCall());
+}));
+
+async function testWait() {
+  let value = 0;
+  setTimeout(() => value++, 10);
+  await scheduler.wait(15);
+  strictEqual(value, 1);
+}
+
+testWait().then(common.mustCall());
+
+async function testCancelableWait1() {
+  const ac = new AbortController();
+  const wait = scheduler.wait(1e6, { signal: ac.signal });
+  ac.abort();
+  await rejects(wait, {
+    code: 'ABORT_ERR',
+    message: 'The operation was aborted',
+  });
+}
+
+testCancelableWait1().then(common.mustCall());
+
+async function testCancelableWait2() {
+  const wait = scheduler.wait(10000, { signal: AbortSignal.abort() });
+  await rejects(wait, {
+    code: 'ABORT_ERR',
+    message: 'The operation was aborted',
+  });
+}
+
+testCancelableWait2().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-timers-refresh-in-callback.js b/test/js/node/test/parallel/test-timers-refresh-in-callback.js
new file mode 100644
index 0000000000..df62512acd
--- /dev/null
+++ b/test/js/node/test/parallel/test-timers-refresh-in-callback.js
@@ -0,0 +1,14 @@
+'use strict';
+
+const common = require('../common');
+
+// This test checks whether a refresh called inside the callback will keep
+// the event loop alive to run the timer again.
+
+let didCall = false;
+const timer = setTimeout(common.mustCall(() => {
+  if (!didCall) {
+    didCall = true;
+    timer.refresh();
+  }
+}, 2), 1);
diff --git a/test/js/node/test/parallel/test-timers-same-timeout-wrong-list-deleted.js b/test/js/node/test/parallel/test-timers-same-timeout-wrong-list-deleted.js
new file mode 100644
index 0000000000..f02603ad88
--- /dev/null
+++ b/test/js/node/test/parallel/test-timers-same-timeout-wrong-list-deleted.js
@@ -0,0 +1,34 @@
+'use strict';
+
+// This is a regression test for https://github.com/nodejs/node/issues/7722.
+//
+// When nested timers have the same timeout, calling clearTimeout on the
+// older timer after it has fired causes the list the newer timer is in
+// to be deleted. Since the newer timer was not cleared, it still blocks
+// the event loop completing for the duration of its timeout, however, since
+// no reference exists to it in its list, it cannot be canceled and its
+// callback is not called when the timeout elapses.
+
+const common = require('../common');
+
+const TIMEOUT = common.platformTimeout(100);
+
+const handle1 = setTimeout(common.mustCall(function() {
+  // Cause the old TIMEOUT list to be deleted
+  clearTimeout(handle1);
+
+  // Cause a new list with the same key (TIMEOUT) to be created for this timer
+  const handle2 = setTimeout(common.mustNotCall(), TIMEOUT);
+
+  setTimeout(common.mustCall(function() {
+    // Attempt to cancel the second timer. Fix for this bug will keep the
+    // newer timer from being dereferenced by keeping its list from being
+    // erroneously deleted. If we are able to cancel the timer successfully,
+    // the bug is fixed.
+    clearTimeout(handle2);
+  }), 1);
+
+  // When this callback completes, `listOnTimeout` should now look at the
+  // correct list and refrain from removing the new TIMEOUT list which
+  // contains the reference to the newer timer.
+}), TIMEOUT);
diff --git a/test/js/node/test/parallel/test-timers-setimmediate-infinite-loop.js b/test/js/node/test/parallel/test-timers-setimmediate-infinite-loop.js
new file mode 100644
index 0000000000..49adc390fa
--- /dev/null
+++ b/test/js/node/test/parallel/test-timers-setimmediate-infinite-loop.js
@@ -0,0 +1,19 @@
+'use strict';
+const common = require('../common');
+
+// This test ensures that if an Immediate callback clears subsequent
+// immediates we don't get stuck in an infinite loop.
+//
+// If the process does get stuck, it will be timed out by the test
+// runner.
+//
+// Ref: https://github.com/nodejs/node/issues/9756
+
+setImmediate(common.mustCall(function() {
+  clearImmediate(i2);
+  clearImmediate(i3);
+}));
+
+const i2 = setImmediate(common.mustNotCall());
+
+const i3 = setImmediate(common.mustNotCall());
diff --git a/test/js/node/test/parallel/test-timers-this.js b/test/js/node/test/parallel/test-timers-this.js
new file mode 100644
index 0000000000..a2a028fb06
--- /dev/null
+++ b/test/js/node/test/parallel/test-timers-this.js
@@ -0,0 +1,50 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+const immediateHandler = setImmediate(common.mustCall(function() {
+  assert.strictEqual(this, immediateHandler);
+}));
+
+const immediateArgsHandler = setImmediate(common.mustCall(function() {
+  assert.strictEqual(this, immediateArgsHandler);
+}), 'args ...');
+
+const intervalHandler = setInterval(common.mustCall(function() {
+  clearInterval(intervalHandler);
+  assert.strictEqual(this, intervalHandler);
+}), 1);
+
+const intervalArgsHandler = setInterval(common.mustCall(function() {
+  clearInterval(intervalArgsHandler);
+  assert.strictEqual(this, intervalArgsHandler);
+}), 1, 'args ...');
+
+const timeoutHandler = setTimeout(common.mustCall(function() {
+  assert.strictEqual(this, timeoutHandler);
+}), 1);
+
+const timeoutArgsHandler = setTimeout(common.mustCall(function() {
+  assert.strictEqual(this, timeoutArgsHandler);
+}), 1, 'args ...');
diff --git a/test/js/node/test/parallel/test-timers-timeout-with-non-integer.js b/test/js/node/test/parallel/test-timers-timeout-with-non-integer.js
new file mode 100644
index 0000000000..96efc69e50
--- /dev/null
+++ b/test/js/node/test/parallel/test-timers-timeout-with-non-integer.js
@@ -0,0 +1,15 @@
+'use strict';
+const common = require('../common');
+
+/**
+ * This test is for https://github.com/nodejs/node/issues/24203
+ */
+let count = 50;
+const time = 1.00000000000001;
+const exec = common.mustCall(() => {
+  if (--count === 0) {
+    return;
+  }
+  setTimeout(exec, time);
+}, count);
+exec();
diff --git a/test/js/node/test/parallel/test-timers-uncaught-exception.js b/test/js/node/test/parallel/test-timers-uncaught-exception.js
new file mode 100644
index 0000000000..8bcf72e36c
--- /dev/null
+++ b/test/js/node/test/parallel/test-timers-uncaught-exception.js
@@ -0,0 +1,39 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const errorMsg = 'BAM!';
+
+// The first timer throws...
+setTimeout(common.mustCall(function() {
+  throw new Error(errorMsg);
+}), 1);
+
+// ...but the second one should still run
+setTimeout(common.mustCall(), 1);
+
+function uncaughtException(err) {
+  assert.strictEqual(err.message, errorMsg);
+}
+
+process.on('uncaughtException', common.mustCall(uncaughtException));
diff --git a/test/js/node/test/parallel/test-timers-unref-throw-then-ref.js b/test/js/node/test/parallel/test-timers-unref-throw-then-ref.js
new file mode 100644
index 0000000000..1dd5fdd0ad
--- /dev/null
+++ b/test/js/node/test/parallel/test-timers-unref-throw-then-ref.js
@@ -0,0 +1,19 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+process.once('uncaughtException', common.mustCall((err) => {
+  common.expectsError({
+    message: 'Timeout Error'
+  })(err);
+}));
+
+let called = false;
+const t = setTimeout(() => {
+  assert(!called);
+  called = true;
+  t.ref();
+  throw new Error('Timeout Error');
+}, 1).unref();
+
+setTimeout(common.mustCall(), 1);
diff --git a/test/js/node/test/parallel/test-timers-unrefd-interval-still-fires.js b/test/js/node/test/parallel/test-timers-unrefd-interval-still-fires.js
new file mode 100644
index 0000000000..98172d18bc
--- /dev/null
+++ b/test/js/node/test/parallel/test-timers-unrefd-interval-still-fires.js
@@ -0,0 +1,22 @@
+'use strict';
+// Regression test for https://github.com/nodejs/node-v0.x-archive/issues/8900.
+const common = require('../common');
+
+const TEST_DURATION = common.platformTimeout(1000);
+let N = 3;
+
+const keepOpen =
+  setTimeout(
+    common.mustNotCall('Test timed out. keepOpen was not canceled.'),
+    TEST_DURATION);
+
+const timer = setInterval(common.mustCall(() => {
+  if (--N === 0) {
+    clearInterval(timer);
+    timer._onTimeout =
+      common.mustNotCall('Unrefd interval fired after being cleared');
+    clearTimeout(keepOpen);
+  }
+}, N), 1);
+
+timer.unref();
diff --git a/test/js/node/test/parallel/test-timers-unrefed-in-beforeexit.js b/test/js/node/test/parallel/test-timers-unrefed-in-beforeexit.js
new file mode 100644
index 0000000000..a38b55bf45
--- /dev/null
+++ b/test/js/node/test/parallel/test-timers-unrefed-in-beforeexit.js
@@ -0,0 +1,7 @@
+'use strict';
+
+const common = require('../common');
+
+process.on('beforeExit', common.mustCall(() => {
+  setTimeout(common.mustNotCall(), 1).unref();
+}));
diff --git a/test/js/node/test/parallel/test-timers-user-call.js b/test/js/node/test/parallel/test-timers-user-call.js
new file mode 100644
index 0000000000..4ff24e688b
--- /dev/null
+++ b/test/js/node/test/parallel/test-timers-user-call.js
@@ -0,0 +1,40 @@
+// Make sure `setTimeout()` and friends don't throw if the user-supplied
+// function has .call() and .apply() monkey-patched to undesirable values.
+
+// Refs: https://github.com/nodejs/node/issues/12956
+
+'use strict';
+
+const common = require('../common');
+
+{
+  const fn = common.mustCall(10);
+  fn.call = 'not a function';
+  fn.apply = 'also not a function';
+  setTimeout(fn, 1);
+  setTimeout(fn, 1, 'oneArg');
+  setTimeout(fn, 1, 'two', 'args');
+  setTimeout(fn, 1, 'three', '(3)', 'args');
+  setTimeout(fn, 1, 'more', 'than', 'three', 'args');
+
+  setImmediate(fn, 1);
+  setImmediate(fn, 1, 'oneArg');
+  setImmediate(fn, 1, 'two', 'args');
+  setImmediate(fn, 1, 'three', '(3)', 'args');
+  setImmediate(fn, 1, 'more', 'than', 'three', 'args');
+}
+
+{
+  const testInterval = (...args) => {
+    const fn = common.mustCall(() => { clearInterval(interval); });
+    fn.call = 'not a function';
+    fn.apply = 'also not a function';
+    const interval = setInterval(fn, 1, ...args);
+  };
+
+  testInterval();
+  testInterval('oneArg');
+  testInterval('two', 'args');
+  testInterval('three', '(3)', 'args');
+  testInterval('more', 'than', 'three', 'args');
+}
diff --git a/test/js/node/test/parallel/test-timers-zero-timeout.js b/test/js/node/test/parallel/test-timers-zero-timeout.js
new file mode 100644
index 0000000000..61a5b2131b
--- /dev/null
+++ b/test/js/node/test/parallel/test-timers-zero-timeout.js
@@ -0,0 +1,49 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+// https://github.com/joyent/node/issues/2079 - zero timeout drops extra args
+{
+  setTimeout(common.mustCall(f), 0, 'foo', 'bar', 'baz');
+  setTimeout(() => {}, 0);
+
+  function f(a, b, c) {
+    assert.strictEqual(a, 'foo');
+    assert.strictEqual(b, 'bar');
+    assert.strictEqual(c, 'baz');
+  }
+}
+
+{
+  let ncalled = 3;
+
+  const f = common.mustCall((a, b, c) => {
+    assert.strictEqual(a, 'foo');
+    assert.strictEqual(b, 'bar');
+    assert.strictEqual(c, 'baz');
+    if (--ncalled === 0) clearTimeout(iv);
+  }, ncalled);
+
+  const iv = setInterval(f, 0, 'foo', 'bar', 'baz');
+}
diff --git a/test/js/node/test/parallel/test-tls-add-context.js b/test/js/node/test/parallel/test-tls-add-context.js
new file mode 100644
index 0000000000..8d02866ce5
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-add-context.js
@@ -0,0 +1,75 @@
+'use strict';
+const common = require('../common');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+const tls = require('tls');
+
+function loadPEM(n) {
+  return fixtures.readKey(`${n}.pem`);
+}
+
+const serverOptions = {
+  key: loadPEM('agent2-key'),
+  cert: loadPEM('agent2-cert'),
+  ca: [ loadPEM('ca2-cert') ],
+  requestCert: true,
+  rejectUnauthorized: false,
+};
+
+let connections = 0;
+
+const server = tls.createServer(serverOptions, (c) => {
+  if (++connections === 3) {
+    server.close();
+  }
+  if (c.servername === 'unknowncontext') {
+    assert.strictEqual(c.authorized, false);
+    return;
+  }
+  assert.strictEqual(c.authorized, true);
+});
+
+const secureContext = {
+  key: loadPEM('agent1-key'),
+  cert: loadPEM('agent1-cert'),
+  ca: [ loadPEM('ca1-cert') ],
+};
+server.addContext('context1', secureContext);
+server.addContext('context2', tls.createSecureContext(secureContext));
+
+const clientOptionsBase = {
+  key: loadPEM('agent1-key'),
+  cert: loadPEM('agent1-cert'),
+  ca: [ loadPEM('ca1-cert') ],
+  rejectUnauthorized: false,
+};
+
+server.listen(0, common.mustCall(() => {
+  const client1 = tls.connect({
+    ...clientOptionsBase,
+    port: server.address().port,
+    servername: 'context1',
+  }, common.mustCall(() => {
+    client1.end();
+  }));
+
+  const client2 = tls.connect({
+    ...clientOptionsBase,
+    port: server.address().port,
+    servername: 'context2',
+  }, common.mustCall(() => {
+    client2.end();
+  }));
+
+  const client3 = tls.connect({
+    ...clientOptionsBase,
+    port: server.address().port,
+    servername: 'unknowncontext',
+  }, common.mustCall(() => {
+    client3.end();
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-tls-alert-handling.js b/test/js/node/test/parallel/test-tls-alert-handling.js
new file mode 100644
index 0000000000..bd86149bc5
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-alert-handling.js
@@ -0,0 +1,96 @@
+'use strict';
+const common = require('../common');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+if (!common.opensslCli)
+  common.skip('node compiled without OpenSSL CLI');
+
+const assert = require('assert');
+const net = require('net');
+const tls = require('tls');
+const fixtures = require('../common/fixtures');
+
+let clientClosed = false;
+let errorReceived = false;
+function canCloseServer() {
+  return clientClosed && errorReceived;
+}
+
+function loadPEM(n) {
+  return fixtures.readKey(`${n}.pem`, 'utf-8');
+}
+
+const opts = {
+  key: loadPEM('agent2-key'),
+  cert: loadPEM('agent2-cert')
+};
+
+const max_iter = 20;
+let iter = 0;
+
+const errorHandler = common.mustCall((err) => {
+  assert.strictEqual(err.code, 'ERR_SSL_WRONG_VERSION_NUMBER');
+  assert.strictEqual(err.library, 'SSL routines');
+  if (!common.hasOpenSSL3) assert.strictEqual(err.function, 'ssl3_get_record');
+  assert.strictEqual(err.reason, 'wrong version number');
+  errorReceived = true;
+  if (canCloseServer())
+    server.close();
+});
+const server = tls.createServer(opts, common.mustCall(function(s) {
+  s.pipe(s);
+  s.on('error', errorHandler);
+}, 2));
+
+server.listen(0, common.mustCall(function() {
+  sendClient();
+}));
+
+server.on('tlsClientError', common.mustNotCall());
+
+server.on('error', common.mustNotCall());
+
+function sendClient() {
+  const client = tls.connect(server.address().port, {
+    rejectUnauthorized: false
+  });
+  client.on('data', common.mustCall(function() {
+    if (iter++ === 2) sendBADTLSRecord();
+    if (iter < max_iter) {
+      client.write('a');
+      return;
+    }
+    client.end();
+  }, max_iter));
+  client.write('a', common.mustCall());
+  client.on('error', common.mustNotCall());
+  client.on('close', common.mustCall(function() {
+    clientClosed = true;
+    if (canCloseServer())
+      server.close();
+  }));
+}
+
+
+function sendBADTLSRecord() {
+  const BAD_RECORD = Buffer.from([0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
+  const socket = net.connect(server.address().port);
+  const client = tls.connect({
+    socket: socket,
+    rejectUnauthorized: false
+  }, common.mustCall(function() {
+    client.write('x');
+    client.on('data', (data) => {
+      socket.end(BAD_RECORD);
+    });
+  }));
+  client.on('error', common.mustCall((err) => {
+    assert.strictEqual(err.code, 'ERR_SSL_TLSV1_ALERT_PROTOCOL_VERSION');
+    assert.strictEqual(err.library, 'SSL routines');
+    if (!common.hasOpenSSL3)
+      assert.strictEqual(err.function, 'ssl3_read_bytes');
+    assert.strictEqual(err.reason, 'tlsv1 alert protocol version');
+  }));
+}
diff --git a/test/js/node/test/parallel/test-tls-alert.js b/test/js/node/test/parallel/test-tls-alert.js
new file mode 100644
index 0000000000..04000771aa
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-alert.js
@@ -0,0 +1,53 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+if (!common.opensslCli)
+  common.skip('node compiled without OpenSSL CLI.');
+
+const assert = require('assert');
+const { execFile } = require('child_process');
+const tls = require('tls');
+const fixtures = require('../common/fixtures');
+
+function loadPEM(n) {
+  return fixtures.readKey(`${n}.pem`);
+}
+
+const server = tls.Server({
+  secureProtocol: 'TLSv1_2_server_method',
+  key: loadPEM('agent2-key'),
+  cert: loadPEM('agent2-cert')
+}, null).listen(0, common.mustCall(() => {
+  const args = ['s_client', '-quiet', '-tls1_1',
+                '-cipher', (common.hasOpenSSL31 ? 'DEFAULT:@SECLEVEL=0' : 'DEFAULT'),
+                '-connect', `127.0.0.1:${server.address().port}`];
+
+  execFile(common.opensslCli, args, common.mustCall((err, _, stderr) => {
+    assert.strictEqual(err.code, 1);
+    assert.match(stderr, /SSL alert number 70/);
+    server.close();
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-tls-ca-concat.js b/test/js/node/test/parallel/test-tls-ca-concat.js
new file mode 100644
index 0000000000..38a6a4dfec
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-ca-concat.js
@@ -0,0 +1,23 @@
+'use strict';
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+
+// Check ca option can contain concatenated certs by prepending an unrelated
+// non-CA cert and showing that agent6's CA root is still found.
+
+const {
+  connect, keys
+} = require(fixtures.path('tls-connect'));
+
+connect({
+  client: {
+    checkServerIdentity: (servername, cert) => { },
+    ca: `${keys.agent1.cert}\n${keys.agent6.ca}`,
+  },
+  server: {
+    cert: keys.agent6.cert,
+    key: keys.agent6.key,
+  },
+}, common.mustSucceed((pair, cleanup) => {
+  return cleanup();
+}));
diff --git a/test/js/node/test/parallel/test-tls-cert-ext-encoding.js b/test/js/node/test/parallel/test-tls-cert-ext-encoding.js
new file mode 100644
index 0000000000..4556b57918
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-cert-ext-encoding.js
@@ -0,0 +1,89 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+if (common.hasOpenSSL3)
+  // TODO(danbev) This test fails with the following error:
+  // error:0D00008F:asn1 encoding routines::no matching choice type
+  //
+  // I've not been able to figure out the reason for this but there
+  // is a note in https://wiki.openssl.org/index.php/OpenSSL_3.0 which
+  // indicates that this might not work at the moment:
+  // "OCSP, PEM, ASN.1 have some very limited library context support"
+  common.skip('when using OpenSSL 3.x');
+
+// NOTE: This certificate is hand-generated, hence it is not located in
+// `test/fixtures/keys` to avoid confusion.
+//
+// The key property of this cert is that subjectAltName contains a string with
+// a type `23` which cannot be encoded into string by `X509V3_EXT_print`.
+const pem = `
+-----BEGIN RSA PRIVATE KEY-----
+MIIEowIBAAKCAQEAzrmfPz5M3wTq2/CwMeSQr/N+R1FCJ+O5n+SMleKvBqaK63eJ
+kL4BnySMc+ZLKCt4UQSsPFIBK63QFq8n6/vjuTDMJiBTsvzytw8zJt1Zr2HA71N3
+VIPt6NdJ/w5lgddTYxR7XudJZJ5lk3PkG8ZgrhuenPYP80UJYVzAC2YZ9KYe3r2B
+rVbut1j+8h0TwVcx2Zg5PorsC/EVxHwo4dCmIHceodikr3UVqHneRcrDBytdG6Mo
+IqHhZJwBeii/EES9tpWwWbzYYh+38aGGLIF2h5UlVpr0bdBVVUg+uVX3y/Qmu2Qv
+4CrAO2IPV6JER9Niwl3ktzNjOMAUQG6BCRSqRQIDAQABAoIBAAmB0+cOsG5ZRYvT
+5+aDgnv1EMuq2wYGnRTTZ/vErxP5OM5XcwYrFtwAzEzQPIieZywisOEdTFx74+QH
+LijWLsTnj5v5RKAorejpVArnhyZfsoXPKt/CKYDZ1ddbDCQKiRU3be0RafisqDM9
+0zHLz8pyDrtdPaKMfD/0Cgj8KxlrLTmfD4otPXds8fZpQe1hR1y12XKVp47l1siW
+qFGTaUPDJpQ67xybR08x5DOqmyo4cNMOuReRWrc/qRbWint9U1882eOH09gVfpJZ
+Gp6FZVPSgz10MZdLSPLhXqZkY4IxIvNltjBDqkmivd12CD+GVr0qUmTJHzTpk+kG
+/CWuRQkCgYEA4EFf8SJHEl0fLDJnOQFyUPY3MalMuopUkQ5CBUe3QXjQhHXsRDfj
+Ci/lyzShJkHPbMDHb/rx3lYZB0xNhwnMWKS1gCFVgOCOTZLfD0K1Anxc1hOSgVxI
+y5FdO9VW7oQNlsMH/WuDHps0HhJW/00lcrmdyoUM1+fE/3yPQndhUmMCgYEA6/z6
+8Gq4PHHNql+gwunAH2cZKNdmcP4Co8MvXCZwIJsLenUuLIZQ/YBKZoM/y5X/cFAG
+WFJJuUe6KFetPaDm6NgZgpOmawyUwd5czDjJ6wWgsRywiTISInfJlgWLBVMOuba7
+iBL9Xuy0hmcbj0ByoRW9l3gCiBX3yJw3I6wqXTcCgYBnjei22eRF15iIeTHvQfq+
+5iNwnEQhM7V/Uj0sYQR/iEGJmUaj7ca6somDf2cW2nblOlQeIpxD1jAyjYqTW/Pv
+zwc9BqeMHqW3rqWwT1Z0smbQODOD5tB6qEKMWaSN+Y6o2qC65kWjAXpclI110PME
++i+iEDRxEsaGT8d7otLfDwKBgQCs+xBaQG/x5p2SAGzP0xYALstzc4jk1FzM+5rw
+mkBgtiXQyqpg+sfNOkfPIvAVZEsMYax0+0SNKrWbMsGLRjFchmMUovQ+zccQ4NT2
+4b2op8Rlbxk8R9ahK1s5u7Bu47YMjZSjJwBQn4OobVX3SI994njJ2a9JX4j0pQWK
+AX5AOwKBgAfOsr8HSHTcxSW4F9gegj+hXsRYbdA+eUkFhEGrYyRJgIlQrk/HbuZC
+mKd/bQ5R/vwd1cxgV6A0APzpZtbwdhvP0RWji+WnPPovgGcfK0AHFstHnga67/uu
+h2LHnKQZ1qWHn+BXWo5d7hBRwWVaK66g3GDN0blZpSz1kKcpy1Pl
+-----END RSA PRIVATE KEY-----
+-----BEGIN CERTIFICATE-----
+MIICwjCCAaqgAwIBAgIDAQABMA0GCSqGSIb3DQEBDQUAMBUxEzARBgNVBAMWCmxv
+Y2FsLmhvc3QwHhcNMTkxMjA1MDQyODMzWhcNNDQxMTI5MDQyODMzWjAVMRMwEQYD
+VQQDFgpsb2NhbC5ob3N0MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA
+zrmfPz5M3wTq2/CwMeSQr/N+R1FCJ+O5n+SMleKvBqaK63eJkL4BnySMc+ZLKCt4
+UQSsPFIBK63QFq8n6/vjuTDMJiBTsvzytw8zJt1Zr2HA71N3VIPt6NdJ/w5lgddT
+YxR7XudJZJ5lk3PkG8ZgrhuenPYP80UJYVzAC2YZ9KYe3r2BrVbut1j+8h0TwVcx
+2Zg5PorsC/EVxHwo4dCmIHceodikr3UVqHneRcrDBytdG6MoIqHhZJwBeii/EES9
+tpWwWbzYYh+38aGGLIF2h5UlVpr0bdBVVUg+uVX3y/Qmu2Qv4CrAO2IPV6JER9Ni
+wl3ktzNjOMAUQG6BCRSqRQIDAQABoxswGTAXBgNVHREEEDAOlwwqLmxvY2FsLmhv
+c3QwDQYJKoZIhvcNAQENBQADggEBAH5ThRLDLwOGuhKsifyiq7k8gbx1FqRegO7H
+SIiIYYB35v5Pk0ZPN8QBJwNQzJEjUMjCpHXNdBxknBXRaA8vkbnryMfJm37gPTwA
+m6r0uEG78WgcEAe8bgf9iKtQGP/iydKXpSSpDgKoHbswIxD5qtzT+o6VNnkRTSfK
+/OGwakluFSoJ/Q9rLpR8lKjA01BhetXMmHbETiY8LSkxOymMldXSzUTD1WdrVn8U
+L3dobxT//R/0GraKXG02mf3gZNlb0MMTvW0pVwVy39YmcPEGh8L0hWh1rpAA/VXC
+f79uOowv3lLTzQ9na5EThA0tp8d837hdYrrIHh5cfTqBDxG0Tu8=
+-----END CERTIFICATE-----
+`;
+
+const tls = require('tls');
+
+const options = {
+  key: pem,
+  cert: pem,
+};
+
+const server = tls.createServer(options, (socket) => {
+  socket.end();
+});
+server.listen(0, common.mustCall(function() {
+  const client = tls.connect({
+    port: this.address().port,
+    rejectUnauthorized: false
+  }, common.mustCall(() => {
+    // This should not crash process:
+    client.getPeerCertificate();
+
+    server.close();
+    client.end();
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-tls-cert-regression.js b/test/js/node/test/parallel/test-tls-cert-regression.js
new file mode 100644
index 0000000000..478402772e
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-cert-regression.js
@@ -0,0 +1,80 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const tls = require('tls');
+
+const cert =
+`-----BEGIN CERTIFICATE-----
+MIIDNDCCAp2gAwIBAgIJAJvXLQpGPpm7MA0GCSqGSIb3DQEBBQUAMHAxCzAJBgNV
+BAYTAkdCMRAwDgYDVQQIEwdHd3luZWRkMREwDwYDVQQHEwhXYXVuZmF3cjEUMBIG
+A1UEChMLQWNrbmFjayBMdGQxEjAQBgNVBAsTCVRlc3QgQ2VydDESMBAGA1UEAxMJ
+bG9jYWxob3N0MB4XDTA5MTEwMjE5MzMwNVoXDTEwMTEwMjE5MzMwNVowcDELMAkG
+A1UEBhMCR0IxEDAOBgNVBAgTB0d3eW5lZGQxETAPBgNVBAcTCFdhdW5mYXdyMRQw
+EgYDVQQKEwtBY2tuYWNrIEx0ZDESMBAGA1UECxMJVGVzdCBDZXJ0MRIwEAYDVQQD
+Ewlsb2NhbGhvc3QwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBANdym7nGe2yw
+6LlJfJrQtC5TmKOGrSXiyolYCbGOy4xZI4KD31d3097jhlQFJyF+10gwkE62DuJe
+fLvBZDUsvLe1R8bzlVhZnBVn+3QJyUIWQAL+DsRj8P3KoD7k363QN5dIaA1GOAg2
+vZcPy1HCUsvOgvDXGRUCZqNLAyt+h/cpAgMBAAGjgdUwgdIwHQYDVR0OBBYEFK4s
+VBV4shKUj3UX/fvSJnFaaPBjMIGiBgNVHSMEgZowgZeAFK4sVBV4shKUj3UX/fvS
+JnFaaPBjoXSkcjBwMQswCQYDVQQGEwJHQjEQMA4GA1UECBMHR3d5bmVkZDERMA8G
+A1UEBxMIV2F1bmZhd3IxFDASBgNVBAoTC0Fja25hY2sgTHRkMRIwEAYDVQQLEwlU
+ZXN0IENlcnQxEjAQBgNVBAMTCWxvY2FsaG9zdIIJAJvXLQpGPpm7MAwGA1UdEwQF
+MAMBAf8wDQYJKoZIhvcNAQEFBQADgYEAFxR7BA1mUlsYqPiogtxSIfLzHWh+s0bJ
+SBuhNrHes4U8QxS8+x/KWjd/81gzsf9J1C2VzTlFaydAgigz3SkQYgs+TMnFkT2o
+9jqoJrcdf4WpZ2DQXUALaZgwNzPumMUSx8Ac5gO+BY/RHyP6fCodYvdNwyKslnI3
+US7eCSHZsVo=
+-----END CERTIFICATE-----`;
+
+const key =
+`-----BEGIN RSA PRIVATE KEY-----
+MIICXgIBAAKBgQDXcpu5xntssOi5SXya0LQuU5ijhq0l4sqJWAmxjsuMWSOCg99X
+d9Pe44ZUBSchftdIMJBOtg7iXny7wWQ1LLy3tUfG85VYWZwVZ/t0CclCFkAC/g7E
+Y/D9yqA+5N+t0DeXSGgNRjgINr2XD8tRwlLLzoLw1xkVAmajSwMrfof3KQIDAQAB
+AoGBAIBHR/tT93ce2mJAJAXV0AJpWc+7x2pwX2FpXtQujnlxNZhnRlrBCRCD7h4m
+t0bVS/86kyGaesBDvAbavfx/N5keYzzmmSp5Ht8IPqKPydGWdigk4x90yWvktai7
+dWuRKF94FXr0GUuBONb/dfHdp4KBtzN7oIF9WydYGGXA9ZmBAkEA8/k01bfwQZIu
+AgcdNEM94Zcug1gSspXtUu8exNQX4+PNVbadghZb1+OnUO4d3gvWfqvAnaXD3KV6
+N4OtUhQQ0QJBAOIRbKMfaymQ9yE3CQQxYfKmEhHXWARXVwuYqIFqjmhSjSXx0l/P
+7mSHz1I9uDvxkJev8sQgu1TKIyTOdqPH1tkCQQDPa6H1yYoj1Un0Q2Qa2Mg1kTjk
+Re6vkjPQ/KcmJEOjZjtekgFbZfLzmwLXFXqjG2FjFFaQMSxR3QYJSJQEYjbhAkEA
+sy7OZcjcXnjZeEkv61Pc57/7qIp/6Aj2JGnefZ1gvI1Z9Q5kCa88rA/9Iplq8pA4
+ZBKAoDW1ZbJGAsFmxc/6mQJAdPilhci0qFN86IGmf+ZBnwsDflIwHKDaVofti4wQ
+sPWhSOb9VQjMXekI4Y2l8fqAVTS2Fn6+8jkVKxXBywSVCw==
+-----END RSA PRIVATE KEY-----`;
+
+function test(cert, key, cb) {
+  const server = tls.createServer({
+    cert,
+    key
+  }).listen(0, function() {
+    server.close(cb);
+  });
+}
+
+test(cert, key, common.mustCall(function() {
+  test(Buffer.from(cert), Buffer.from(key), common.mustCall());
+}));
diff --git a/test/js/node/test/parallel/test-tls-client-abort.js b/test/js/node/test/parallel/test-tls-client-abort.js
new file mode 100644
index 0000000000..50c9a4b324
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-client-abort.js
@@ -0,0 +1,35 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const tls = require('tls');
+const fixtures = require('../common/fixtures');
+
+const cert = fixtures.readKey('rsa_cert.crt');
+const key = fixtures.readKey('rsa_private.pem');
+
+const conn = tls.connect({ cert, key, port: 0 }, common.mustNotCall());
+conn.on('error', function() {});
+conn.destroy();
diff --git a/test/js/node/test/parallel/test-tls-client-destroy-soon.js b/test/js/node/test/parallel/test-tls-client-destroy-soon.js
new file mode 100644
index 0000000000..1d49a6094b
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-client-destroy-soon.js
@@ -0,0 +1,67 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+// Create an ssl server.  First connection, validate that not resume.
+// Cache session and close connection.  Use session on second connection.
+// ASSERT resumption.
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const tls = require('tls');
+const fixtures = require('../common/fixtures');
+
+const options = {
+  key: fixtures.readKey('agent2-key.pem'),
+  cert: fixtures.readKey('agent2-cert.pem')
+};
+
+const big = Buffer.alloc(2 * 1024 * 1024, 'Y');
+
+// create server
+const server = tls.createServer(options, common.mustCall(function(socket) {
+  socket.end(big);
+  socket.destroySoon();
+}));
+
+// start listening
+server.listen(0, common.mustCall(function() {
+  const client = tls.connect({
+    port: this.address().port,
+    rejectUnauthorized: false
+  }, common.mustCall(function() {
+    let bytesRead = 0;
+
+    client.on('readable', function() {
+      const d = client.read();
+      if (d)
+        bytesRead += d.length;
+    });
+
+    client.on('end', common.mustCall(function() {
+      server.close();
+      assert.strictEqual(big.length, bytesRead);
+    }));
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-tls-client-renegotiation-limit.js b/test/js/node/test/parallel/test-tls-client-renegotiation-limit.js
new file mode 100644
index 0000000000..71d7a85bae
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-client-renegotiation-limit.js
@@ -0,0 +1,101 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+if (!common.opensslCli)
+  common.skip('node compiled without OpenSSL CLI.');
+
+const assert = require('assert');
+const tls = require('tls');
+const fixtures = require('../common/fixtures');
+
+// Renegotiation as a protocol feature was dropped after TLS1.2.
+tls.DEFAULT_MAX_VERSION = 'TLSv1.2';
+
+// Renegotiation limits to test
+const LIMITS = [0, 1, 2, 3, 5, 10, 16];
+
+{
+  let n = 0;
+  function next() {
+    if (n >= LIMITS.length) return;
+    tls.CLIENT_RENEG_LIMIT = LIMITS[n++];
+    test(next);
+  }
+  next();
+}
+
+function test(next) {
+  const options = {
+    cert: fixtures.readKey('rsa_cert.crt'),
+    key: fixtures.readKey('rsa_private.pem'),
+  };
+
+  const server = tls.createServer(options, (conn) => {
+    conn.on('error', (err) => {
+      console.error(`Caught exception: ${err}`);
+      assert.match(err.message, /TLS session renegotiation attack/);
+      conn.destroy();
+    });
+    conn.pipe(conn);
+  });
+
+  server.listen(0, () => {
+    const options = {
+      host: server.address().host,
+      port: server.address().port,
+      rejectUnauthorized: false,
+    };
+    const client = tls.connect(options, spam);
+
+    let renegs = 0;
+
+    client.on('close', () => {
+      assert.strictEqual(renegs, tls.CLIENT_RENEG_LIMIT + 1);
+      server.close();
+      process.nextTick(next);
+    });
+
+    client.on('error', (err) => {
+      console.log('CLIENT ERR', err);
+      throw err;
+    });
+
+    client.on('close', (hadErr) => {
+      assert.strictEqual(hadErr, false);
+    });
+
+    // Simulate renegotiation attack
+    function spam() {
+      client.write('');
+      client.renegotiate({}, (err) => {
+        assert.ifError(err);
+        assert.ok(renegs <= tls.CLIENT_RENEG_LIMIT);
+        spam();
+      });
+      renegs++;
+    }
+  });
+}
diff --git a/test/js/node/test/parallel/test-tls-client-verify.js b/test/js/node/test/parallel/test-tls-client-verify.js
new file mode 100644
index 0000000000..a8de1078bf
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-client-verify.js
@@ -0,0 +1,144 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const tls = require('tls');
+const fixtures = require('../common/fixtures');
+
+const testCases = [
+  { ca: ['ca1-cert'],
+    key: 'agent2-key',
+    cert: 'agent2-cert',
+    servers: [
+      { ok: true, key: 'agent1-key', cert: 'agent1-cert' },
+      { ok: false, key: 'agent2-key', cert: 'agent2-cert' },
+      { ok: false, key: 'agent3-key', cert: 'agent3-cert' },
+    ] },
+
+  { ca: [],
+    key: 'agent2-key',
+    cert: 'agent2-cert',
+    servers: [
+      { ok: false, key: 'agent1-key', cert: 'agent1-cert' },
+      { ok: false, key: 'agent2-key', cert: 'agent2-cert' },
+      { ok: false, key: 'agent3-key', cert: 'agent3-cert' },
+    ] },
+
+  { ca: ['ca1-cert', 'ca2-cert'],
+    key: 'agent2-key',
+    cert: 'agent2-cert',
+    servers: [
+      { ok: true, key: 'agent1-key', cert: 'agent1-cert' },
+      { ok: false, key: 'agent2-key', cert: 'agent2-cert' },
+      { ok: true, key: 'agent3-key', cert: 'agent3-cert' },
+    ] },
+];
+
+
+function loadPEM(n) {
+  return fixtures.readKey(`${n}.pem`);
+}
+
+let successfulTests = 0;
+
+function testServers(index, servers, clientOptions, cb) {
+  const serverOptions = servers[index];
+  if (!serverOptions) {
+    cb();
+    return;
+  }
+
+  const ok = serverOptions.ok;
+
+  if (serverOptions.key) {
+    serverOptions.key = loadPEM(serverOptions.key);
+  }
+
+  if (serverOptions.cert) {
+    serverOptions.cert = loadPEM(serverOptions.cert);
+  }
+
+  const server = tls.createServer(serverOptions, common.mustCall(function(s) {
+    s.end('hello world\n');
+  }));
+
+  server.listen(0, common.mustCall(function() {
+    let b = '';
+
+    console.error('connecting...');
+    clientOptions.port = this.address().port;
+    const client = tls.connect(clientOptions, common.mustCall(function() {
+      const authorized = client.authorized ||
+          (client.authorizationError === 'ERR_TLS_CERT_ALTNAME_INVALID');
+
+      console.error(`expected: ${ok} authed: ${authorized}`);
+
+      assert.strictEqual(authorized, ok);
+      server.close();
+    }));
+
+    client.on('data', function(d) {
+      b += d.toString();
+    });
+
+    client.on('end', common.mustCall(function() {
+      assert.strictEqual(b, 'hello world\n');
+    }));
+
+    client.on('close', common.mustCall(function() {
+      testServers(index + 1, servers, clientOptions, cb);
+    }));
+  }));
+}
+
+
+function runTest(testIndex) {
+  const tcase = testCases[testIndex];
+  if (!tcase) return;
+
+  const clientOptions = {
+    port: undefined,
+    ca: tcase.ca.map(loadPEM),
+    key: loadPEM(tcase.key),
+    cert: loadPEM(tcase.cert),
+    rejectUnauthorized: false
+  };
+
+
+  testServers(0, tcase.servers, clientOptions, common.mustCall(function() {
+    successfulTests++;
+    runTest(testIndex + 1);
+  }));
+}
+
+
+runTest(0);
+
+
+process.on('exit', function() {
+  console.log(`successful tests: ${successfulTests}`);
+  assert.strictEqual(successfulTests, testCases.length);
+});
diff --git a/test/js/node/test/parallel/test-tls-connect-address-family.js b/test/js/node/test/parallel/test-tls-connect-address-family.js
new file mode 100644
index 0000000000..083208cc1d
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-connect-address-family.js
@@ -0,0 +1,49 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+if (!common.hasIPv6)
+  common.skip('no IPv6 support');
+
+const assert = require('assert');
+const fixtures = require('../common/fixtures');
+const tls = require('tls');
+const dns = require('dns');
+
+function runTest() {
+  tls.createServer({
+    cert: fixtures.readKey('agent1-cert.pem'),
+    key: fixtures.readKey('agent1-key.pem'),
+  }).on('connection', common.mustCall(function() {
+    this.close();
+  })).listen(0, '::1', common.mustCall(function() {
+    const options = {
+      host: 'localhost',
+      port: this.address().port,
+      family: 6,
+      rejectUnauthorized: false,
+    };
+    // Will fail with ECONNREFUSED if the address family is not honored.
+    tls.connect(options).once('secureConnect', common.mustCall(function() {
+      assert.strictEqual(this.remoteAddress, '::1');
+      this.destroy();
+    }));
+  }));
+}
+
+dns.lookup('localhost', {
+  family: 6, all: true
+}, common.mustCall((err, addresses) => {
+  if (err) {
+    if (err.code === 'ENOTFOUND' || err.code === 'EAI_AGAIN')
+      common.skip('localhost does not resolve to ::1');
+
+    throw err;
+  }
+
+  if (addresses.some((val) => val.address === '::1'))
+    runTest();
+  else
+    common.skip('localhost does not resolve to ::1');
+}));
diff --git a/test/js/node/test/parallel/test-tls-connect-no-host.js b/test/js/node/test/parallel/test-tls-connect-no-host.js
new file mode 100644
index 0000000000..97b95332c4
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-connect-no-host.js
@@ -0,0 +1,33 @@
+'use strict';
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const tls = require('tls');
+const assert = require('assert');
+
+const cert = fixtures.readKey('rsa_cert.crt');
+const key = fixtures.readKey('rsa_private.pem');
+
+// https://github.com/nodejs/node/issues/1489
+// tls.connect(options) with no options.host should accept a cert with
+//   CN:'localhost'
+const server = tls.createServer({
+  key,
+  cert
+}).listen(0, common.mustCall(function() {
+  const socket = tls.connect({
+    port: this.address().port,
+    ca: cert,
+    // No host set here. 'localhost' is the default,
+    // but tls.checkServerIdentity() breaks before the fix with:
+    // Error: Hostname/IP doesn't match certificate's altnames:
+    //   "Host: undefined. is not cert's CN: localhost"
+  }, common.mustCall(function() {
+    assert(socket.authorized);
+    socket.destroy();
+    server.close();
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-tls-connect-secure-context.js b/test/js/node/test/parallel/test-tls-connect-secure-context.js
new file mode 100644
index 0000000000..31941656c0
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-connect-secure-context.js
@@ -0,0 +1,53 @@
+'use strict';
+require('../common');
+
+// Verify connection with explicitly created client SecureContext.
+
+const fixtures = require('../common/fixtures');
+const {
+  assert, connect, keys, tls
+} = require(fixtures.path('tls-connect'));
+
+connect({
+  client: {
+    servername: 'agent1',
+    secureContext: tls.createSecureContext({
+      ca: keys.agent1.ca,
+    }),
+  },
+  server: {
+    cert: keys.agent1.cert,
+    key: keys.agent1.key,
+  },
+}, function(err, pair, cleanup) {
+  assert.ifError(err);
+  return cleanup();
+});
+
+connect({
+  client: {
+    servername: 'agent1',
+    secureContext: tls.createSecureContext({
+      ca: keys.agent1.ca,
+      ciphers: null,
+      clientCertEngine: null,
+      crl: null,
+      dhparam: null,
+      passphrase: null,
+      pfx: null,
+      privateKeyIdentifier: null,
+      privateKeyEngine: null,
+      sessionIdContext: null,
+      sessionTimeout: null,
+      sigalgs: null,
+      ticketKeys: null,
+    }),
+  },
+  server: {
+    cert: keys.agent1.cert,
+    key: keys.agent1.key,
+  },
+}, function(err, pair, cleanup) {
+  assert.ifError(err);
+  return cleanup();
+});
diff --git a/test/js/node/test/parallel/test-tls-dhe.js b/test/js/node/test/parallel/test-tls-dhe.js
new file mode 100644
index 0000000000..46779b09ff
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-dhe.js
@@ -0,0 +1,112 @@
+// Flags: --no-warnings
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+if (!common.opensslCli)
+  common.skip('missing openssl-cli');
+
+const assert = require('assert');
+const { X509Certificate } = require('crypto');
+const { once } = require('events');
+const tls = require('tls');
+const { execFile } = require('child_process');
+const fixtures = require('../common/fixtures');
+
+const key = fixtures.readKey('agent2-key.pem');
+const cert = fixtures.readKey('agent2-cert.pem');
+
+// Prefer DHE over ECDHE when possible.
+const dheCipher = 'DHE-RSA-AES128-SHA256';
+const ecdheCipher = 'ECDHE-RSA-AES128-SHA256';
+const ciphers = `${dheCipher}:${ecdheCipher}`;
+
+// Test will emit a warning because the DH parameter size is < 2048 bits
+common.expectWarning('SecurityWarning',
+                     'DH parameter is less than 2048 bits');
+
+function loadDHParam(n) {
+  const keyname = `dh${n}.pem`;
+  return fixtures.readKey(keyname);
+}
+
+function test(dhparam, keylen, expectedCipher) {
+  const options = {
+    key,
+    cert,
+    ciphers,
+    dhparam,
+    maxVersion: 'TLSv1.2',
+  };
+
+  const server = tls.createServer(options, (conn) => conn.end());
+
+  server.listen(0, '127.0.0.1', common.mustCall(() => {
+    const args = ['s_client', '-connect', `127.0.0.1:${server.address().port}`,
+                  '-cipher', `${ciphers}:@SECLEVEL=1`];
+
+    execFile(common.opensslCli, args, common.mustSucceed((stdout) => {
+      assert(keylen === null ||
+             stdout.includes(`Server Temp Key: DH, ${keylen} bits`));
+      assert(stdout.includes(`Cipher    : ${expectedCipher}`));
+      server.close();
+    }));
+  }));
+
+  return once(server, 'close');
+}
+
+function testCustomParam(keylen, expectedCipher) {
+  const dhparam = loadDHParam(keylen);
+  if (keylen === 'error') keylen = null;
+  return test(dhparam, keylen, expectedCipher);
+}
+
+(async () => {
+  // By default, DHE is disabled while ECDHE is enabled.
+  for (const dhparam of [undefined, null]) {
+    await test(dhparam, null, ecdheCipher);
+  }
+
+  // The DHE parameters selected by OpenSSL depend on the strength of the
+  // certificate's key. For this test, we can assume that the modulus length
+  // of the certificate's key is equal to the size of the DHE parameter, but
+  // that is really only true for a few modulus lengths.
+  const {
+    publicKey: { asymmetricKeyDetails: { modulusLength } }
+  } = new X509Certificate(cert);
+  await test('auto', modulusLength, dheCipher);
+
+  assert.throws(() => {
+    testCustomParam(512);
+  }, /DH parameter is less than 1024 bits/);
+
+  // Custom DHE parameters are supported (but discouraged).
+  await testCustomParam(1024, dheCipher);
+  await testCustomParam(2048, dheCipher);
+
+  // Invalid DHE parameters are discarded. ECDHE remains enabled.
+  await testCustomParam('error', ecdheCipher);
+})().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-tls-ecdh-auto.js b/test/js/node/test/parallel/test-tls-ecdh-auto.js
new file mode 100644
index 0000000000..11c588d8ac
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-ecdh-auto.js
@@ -0,0 +1,43 @@
+'use strict';
+const common = require('../common');
+
+// This test ensures that the value "auto" on ecdhCurve option is
+// supported to enable automatic curve selection in TLS server.
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+if (!common.opensslCli)
+  common.skip('missing openssl-cli');
+
+const assert = require('assert');
+const tls = require('tls');
+const { execFile } = require('child_process');
+const fixtures = require('../common/fixtures');
+
+function loadPEM(n) {
+  return fixtures.readKey(`${n}.pem`);
+}
+
+const options = {
+  key: loadPEM('agent2-key'),
+  cert: loadPEM('agent2-cert'),
+  ciphers: '-ALL:ECDHE-RSA-AES128-SHA256',
+  ecdhCurve: 'auto',
+  maxVersion: 'TLSv1.2',
+};
+
+const reply = 'I AM THE WALRUS'; // Something recognizable
+
+const server = tls.createServer(options, (conn) => {
+  conn.end(reply);
+}).listen(0, common.mustCall(() => {
+  const args = ['s_client',
+                '-cipher', `${options.ciphers}`,
+                '-connect', `127.0.0.1:${server.address().port}`];
+
+  execFile(common.opensslCli, args, common.mustSucceed((stdout) => {
+    assert(stdout.includes(reply));
+    server.close();
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-tls-ecdh-multiple.js b/test/js/node/test/parallel/test-tls-ecdh-multiple.js
new file mode 100644
index 0000000000..5bf119f48b
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-ecdh-multiple.js
@@ -0,0 +1,61 @@
+'use strict';
+const common = require('../common');
+
+// This test ensures that ecdhCurve option of TLS server supports colon
+// separated ECDH curve names as value.
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+if (!common.opensslCli)
+  common.skip('missing openssl-cli');
+
+const assert = require('assert');
+const tls = require('tls');
+const { execFile } = require('child_process');
+const fixtures = require('../common/fixtures');
+
+function loadPEM(n) {
+  return fixtures.readKey(`${n}.pem`);
+}
+
+const options = {
+  key: loadPEM('agent2-key'),
+  cert: loadPEM('agent2-cert'),
+  ciphers: '-ALL:ECDHE-RSA-AES128-SHA256',
+  ecdhCurve: 'secp256k1:prime256v1:secp521r1',
+  maxVersion: 'TLSv1.2',
+};
+
+const reply = 'I AM THE WALRUS'; // Something recognizable
+
+const server = tls.createServer(options, (conn) => {
+  conn.end(reply);
+}).listen(0, common.mustCall(() => {
+  const args = ['s_client',
+                '-cipher', `${options.ciphers}`,
+                '-connect', `127.0.0.1:${server.address().port}`];
+
+  execFile(common.opensslCli, args, common.mustSucceed((stdout) => {
+    assert(stdout.includes(reply));
+    server.close();
+  }));
+}));
+
+{
+  // Some unsupported curves.
+  const unsupportedCurves = [
+    'wap-wsg-idm-ecid-wtls1',
+    'c2pnb163v1',
+    'prime192v3',
+  ];
+
+  // Brainpool is not supported in FIPS mode.
+  if (common.hasFipsCrypto)
+    unsupportedCurves.push('brainpoolP256r1');
+
+  unsupportedCurves.forEach((ecdhCurve) => {
+    assert.throws(() => tls.createServer({ ecdhCurve }),
+                  /Error: Failed to set ECDH curve/);
+  });
+}
diff --git a/test/js/node/test/parallel/test-tls-ecdh.js b/test/js/node/test/parallel/test-tls-ecdh.js
new file mode 100644
index 0000000000..8c879f850c
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-ecdh.js
@@ -0,0 +1,59 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+if (!common.opensslCli)
+  common.skip('missing openssl-cli');
+
+const assert = require('assert');
+const tls = require('tls');
+
+const exec = require('child_process').exec;
+
+const options = {
+  key: fixtures.readKey('agent2-key.pem'),
+  cert: fixtures.readKey('agent2-cert.pem'),
+  ciphers: '-ALL:ECDHE-RSA-AES128-SHA256',
+  ecdhCurve: 'prime256v1',
+  maxVersion: 'TLSv1.2'
+};
+
+const reply = 'I AM THE WALRUS'; // Something recognizable
+
+const server = tls.createServer(options, common.mustCall(function(conn) {
+  conn.end(reply);
+}));
+
+server.listen(0, '127.0.0.1', common.mustCall(function() {
+  const cmd = `"${common.opensslCli}" s_client -cipher ${
+    options.ciphers} -connect 127.0.0.1:${this.address().port}`;
+
+  exec(cmd, common.mustSucceed((stdout, stderr) => {
+    assert(stdout.includes(reply));
+    server.close();
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-tls-env-extra-ca-no-crypto.js b/test/js/node/test/parallel/test-tls-env-extra-ca-no-crypto.js
new file mode 100644
index 0000000000..6f2aca505e
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-env-extra-ca-no-crypto.js
@@ -0,0 +1,22 @@
+'use strict';
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+const { fork } = require('child_process');
+
+// This test ensures that trying to load extra certs won't throw even when
+// there is no crypto support, i.e., built with "./configure --without-ssl".
+if (process.argv[2] === 'child') {
+  // exit
+} else {
+  const NODE_EXTRA_CA_CERTS = fixtures.path('keys', 'ca1-cert.pem');
+
+  fork(
+    __filename,
+    ['child'],
+    { env: { ...process.env, NODE_EXTRA_CA_CERTS } },
+  ).on('exit', common.mustCall(function(status) {
+    // Client did not succeed in connecting
+    assert.strictEqual(status, 0);
+  }));
+}
diff --git a/test/js/node/test/parallel/test-tls-fast-writing.js b/test/js/node/test/parallel/test-tls-fast-writing.js
new file mode 100644
index 0000000000..4718acf285
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-fast-writing.js
@@ -0,0 +1,76 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+const tls = require('tls');
+
+const options = { key: fixtures.readKey('rsa_private.pem'),
+                  cert: fixtures.readKey('rsa_cert.crt'),
+                  ca: [ fixtures.readKey('rsa_ca.crt') ] };
+
+const server = tls.createServer(options, onconnection);
+let gotChunk = false;
+let gotDrain = false;
+
+function onconnection(conn) {
+  conn.on('data', function(c) {
+    if (!gotChunk) {
+      gotChunk = true;
+      console.log('ok - got chunk');
+    }
+
+    // Just some basic sanity checks.
+    assert(c.length);
+    assert(Buffer.isBuffer(c));
+
+    if (gotDrain)
+      process.exit(0);
+  });
+}
+
+server.listen(0, function() {
+  const chunk = Buffer.alloc(1024, 'x');
+  const opt = { port: this.address().port, rejectUnauthorized: false };
+  const conn = tls.connect(opt, function() {
+    conn.on('drain', ondrain);
+    write();
+  });
+  function ondrain() {
+    if (!gotDrain) {
+      gotDrain = true;
+      console.log('ok - got drain');
+    }
+    if (gotChunk)
+      process.exit(0);
+    write();
+  }
+
+  function write() {
+    // This needs to return false eventually
+    while (false !== conn.write(chunk));
+  }
+});
diff --git a/test/js/node/test/parallel/test-tls-inception.js b/test/js/node/test/parallel/test-tls-inception.js
new file mode 100644
index 0000000000..7310308e6f
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-inception.js
@@ -0,0 +1,86 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const tls = require('tls');
+
+const net = require('net');
+
+const options = {
+  key: fixtures.readKey('rsa_private.pem'),
+  cert: fixtures.readKey('rsa_cert.crt')
+};
+
+const body = 'A'.repeat(40000);
+
+// the "proxy" server
+const a = tls.createServer(options, function(socket) {
+  const myOptions = {
+    host: '127.0.0.1',
+    port: b.address().port,
+    rejectUnauthorized: false
+  };
+  const dest = net.connect(myOptions);
+  dest.pipe(socket);
+  socket.pipe(dest);
+
+  dest.on('end', function() {
+    socket.destroy();
+  });
+});
+
+// the "target" server
+const b = tls.createServer(options, function(socket) {
+  socket.end(body);
+});
+
+a.listen(0, function() {
+  b.listen(0, function() {
+    const myOptions = {
+      host: '127.0.0.1',
+      port: a.address().port,
+      rejectUnauthorized: false
+    };
+    const socket = tls.connect(myOptions);
+    const ssl = tls.connect({
+      socket: socket,
+      rejectUnauthorized: false
+    });
+    ssl.setEncoding('utf8');
+    let buf = '';
+    ssl.on('data', function(data) {
+      buf += data;
+    });
+    ssl.on('end', common.mustCall(function() {
+      assert.strictEqual(buf, body);
+      ssl.end();
+      a.close();
+      b.close();
+    }));
+  });
+});
diff --git a/test/js/node/test/parallel/test-tls-multiple-cas-as-string.js b/test/js/node/test/parallel/test-tls-multiple-cas-as-string.js
new file mode 100644
index 0000000000..679d6b6c4c
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-multiple-cas-as-string.js
@@ -0,0 +1,43 @@
+'use strict';
+const common = require('../common');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+// Verify that multiple CA certificates can be provided, and that for
+// convenience that can also be in newline-separated strings.
+
+const tls = require('tls');
+const fixtures = require('../common/fixtures');
+
+const ca1 = fixtures.readKey('ca1-cert.pem', 'utf8');
+const ca2 = fixtures.readKey('ca2-cert.pem', 'utf8');
+const cert = fixtures.readKey('agent3-cert.pem', 'utf8');
+const key = fixtures.readKey('agent3-key.pem', 'utf8');
+
+function test(ca) {
+  const server = tls.createServer({ ca, cert, key });
+
+  server.addContext('agent3', { ca, cert, key });
+
+  const host = common.localhostIPv4;
+  server.listen(0, host, common.mustCall(() => {
+    const socket = tls.connect({
+      servername: 'agent3',
+      host,
+      port: server.address().port,
+      ca
+    }, common.mustCall(() => {
+      socket.end();
+    }));
+
+    socket.on('close', () => {
+      server.close();
+    });
+  }));
+}
+
+// `ca1` is not actually necessary for the certificate validation -- maybe
+// the fixtures should be written in a way that requires it?
+test([ca1, ca2]);
+test(`${ca1}\n${ca2}`);
diff --git a/test/js/node/test/parallel/test-tls-net-connect-prefer-path.js b/test/js/node/test/parallel/test-tls-net-connect-prefer-path.js
new file mode 100644
index 0000000000..cefeb5d471
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-net-connect-prefer-path.js
@@ -0,0 +1,65 @@
+'use strict';
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+
+// This tests that both tls and net will ignore host and port if path is
+// provided.
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+const tls = require('tls');
+const net = require('net');
+const assert = require('assert');
+
+function libName(lib) {
+  return lib === net ? 'net' : 'tls';
+}
+
+function mkServer(lib, tcp, cb) {
+  const handler = (socket) => {
+    socket.write(`${libName(lib)}:${
+      server.address().port || server.address()
+    }`);
+    socket.end();
+  };
+  const args = [handler];
+  if (lib === tls) {
+    args.unshift({
+      cert: fixtures.readKey('rsa_cert.crt'),
+      key: fixtures.readKey('rsa_private.pem')
+    });
+  }
+  const server = lib.createServer(...args);
+  server.listen(tcp ? 0 : common.PIPE, common.mustCall(() => cb(server)));
+}
+
+function testLib(lib, cb) {
+  mkServer(lib, true, (tcpServer) => {
+    mkServer(lib, false, (unixServer) => {
+      const client = lib.connect({
+        path: unixServer.address(),
+        port: tcpServer.address().port,
+        host: 'localhost',
+        rejectUnauthorized: false
+      }, () => {
+        const bufs = [];
+        client.on('data', common.mustCall((d) => {
+          bufs.push(d);
+        }));
+        client.on('end', common.mustCall(() => {
+          const resp = Buffer.concat(bufs).toString();
+          assert.strictEqual(resp, `${libName(lib)}:${unixServer.address()}`);
+          tcpServer.close();
+          unixServer.close();
+          cb();
+        }));
+      });
+    });
+  });
+}
+
+testLib(net, common.mustCall(() => testLib(tls, common.mustCall())));
diff --git a/test/js/node/test/parallel/test-tls-no-sslv3.js b/test/js/node/test/parallel/test-tls-no-sslv3.js
new file mode 100644
index 0000000000..9282beb4bd
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-no-sslv3.js
@@ -0,0 +1,47 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+if (common.opensslCli === false)
+  common.skip('node compiled without OpenSSL CLI.');
+
+const assert = require('assert');
+const tls = require('tls');
+const spawn = require('child_process').spawn;
+const fixtures = require('../common/fixtures');
+
+const cert = fixtures.readKey('rsa_cert.crt');
+const key = fixtures.readKey('rsa_private.pem');
+const server = tls.createServer({ cert, key }, common.mustNotCall());
+const errors = [];
+let stderr = '';
+
+server.listen(0, '127.0.0.1', function() {
+  const address = `${this.address().address}:${this.address().port}`;
+  const args = ['s_client',
+                '-ssl3',
+                '-connect', address];
+
+  const client = spawn(common.opensslCli, args, { stdio: 'pipe' });
+  client.stdout.pipe(process.stdout);
+  client.stderr.pipe(process.stderr);
+  client.stderr.setEncoding('utf8');
+  client.stderr.on('data', (data) => stderr += data);
+
+  client.once('exit', common.mustCall(function(exitCode) {
+    assert.strictEqual(exitCode, 1);
+    server.close();
+  }));
+});
+
+server.on('tlsClientError', (err) => errors.push(err));
+
+process.on('exit', function() {
+  if (/[Uu]nknown option:? -ssl3/.test(stderr)) {
+    common.printSkipMessage('`openssl s_client -ssl3` not supported.');
+  } else {
+    assert.strictEqual(errors.length, 1);
+    assert(/:version too low/.test(errors[0].message));
+  }
+});
diff --git a/test/js/node/test/parallel/test-tls-ocsp-callback.js b/test/js/node/test/parallel/test-tls-ocsp-callback.js
new file mode 100644
index 0000000000..04a60a0890
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-ocsp-callback.js
@@ -0,0 +1,113 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+
+if (!common.opensslCli)
+  common.skip('node compiled without OpenSSL CLI.');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const tls = require('tls');
+const fixtures = require('../common/fixtures');
+
+const assert = require('assert');
+
+const SSL_OP_NO_TICKET = require('crypto').constants.SSL_OP_NO_TICKET;
+
+const pfx = fixtures.readKey('agent1.pfx');
+const key = fixtures.readKey('agent1-key.pem');
+const cert = fixtures.readKey('agent1-cert.pem');
+const ca = fixtures.readKey('ca1-cert.pem');
+
+function test(testOptions, cb) {
+  const options = {
+    key,
+    cert,
+    ca: [ca]
+  };
+  const requestCount = testOptions.response ? 0 : 1;
+
+  if (!testOptions.ocsp)
+    assert.strictEqual(testOptions.response, undefined);
+
+  if (testOptions.pfx) {
+    delete options.key;
+    delete options.cert;
+    options.pfx = testOptions.pfx;
+    options.passphrase = testOptions.passphrase;
+  }
+
+  const server = tls.createServer(options, common.mustCall((cleartext) => {
+    cleartext.on('error', function(er) {
+      // We're ok with getting ECONNRESET in this test, but it's
+      // timing-dependent, and thus unreliable. Any other errors
+      // are just failures, though.
+      if (er.code !== 'ECONNRESET')
+        throw er;
+    });
+    cleartext.end();
+  }, requestCount));
+
+  if (!testOptions.ocsp)
+    server.on('OCSPRequest', common.mustNotCall());
+  else
+    server.on('OCSPRequest', common.mustCall((cert, issuer, callback) => {
+      assert.ok(Buffer.isBuffer(cert));
+      assert.ok(Buffer.isBuffer(issuer));
+
+      // Callback a little later to ensure that async really works.
+      return setTimeout(callback, 100, null, testOptions.response ?
+        Buffer.from(testOptions.response) : null);
+    }));
+
+  server.listen(0, function() {
+    const client = tls.connect({
+      port: this.address().port,
+      requestOCSP: testOptions.ocsp,
+      secureOptions: testOptions.ocsp ? 0 : SSL_OP_NO_TICKET,
+      rejectUnauthorized: false
+    }, common.mustCall(requestCount));
+
+    client.on('OCSPResponse', common.mustCall((resp) => {
+      if (testOptions.response) {
+        assert.strictEqual(resp.toString(), testOptions.response);
+        client.destroy();
+      } else {
+        assert.strictEqual(resp, null);
+      }
+    }, testOptions.ocsp === false ? 0 : 1));
+
+    client.on('close', common.mustCall(() => {
+      server.close(cb);
+    }));
+  });
+}
+
+test({ ocsp: true, response: false });
+test({ ocsp: true, response: 'hello world' });
+test({ ocsp: false });
+
+if (!common.hasFipsCrypto) {
+  test({ ocsp: true, response: 'hello pfx', pfx: pfx, passphrase: 'sample' });
+}
diff --git a/test/js/node/test/parallel/test-tls-on-empty-socket.js b/test/js/node/test/parallel/test-tls-on-empty-socket.js
new file mode 100644
index 0000000000..87d51a81bb
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-on-empty-socket.js
@@ -0,0 +1,40 @@
+'use strict';
+const common = require('../common');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const tls = require('tls');
+const net = require('net');
+const fixtures = require('../common/fixtures');
+
+let out = '';
+
+const server = tls.createServer({
+  key: fixtures.readKey('agent1-key.pem'),
+  cert: fixtures.readKey('agent1-cert.pem')
+}, function(c) {
+  c.end('hello');
+}).listen(0, function() {
+  const socket = new net.Socket();
+
+  const s = tls.connect({
+    socket: socket,
+    rejectUnauthorized: false
+  }, function() {
+    s.on('data', function(chunk) {
+      out += chunk;
+    });
+    s.on('end', function() {
+      s.destroy();
+      server.close();
+    });
+  });
+
+  socket.connect(this.address().port);
+});
+
+process.on('exit', function() {
+  assert.strictEqual(out, 'hello');
+});
diff --git a/test/js/node/test/parallel/test-tls-peer-certificate-encoding.js b/test/js/node/test/parallel/test-tls-peer-certificate-encoding.js
new file mode 100644
index 0000000000..154c31c0a1
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-peer-certificate-encoding.js
@@ -0,0 +1,53 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const tls = require('tls');
+const util = require('util');
+const fixtures = require('../common/fixtures');
+
+const options = {
+  key: fixtures.readKey('agent5-key.pem'),
+  cert: fixtures.readKey('agent5-cert.pem'),
+  ca: [ fixtures.readKey('ca2-cert.pem') ]
+};
+
+const server = tls.createServer(options, (cleartext) => {
+  cleartext.end('World');
+});
+server.listen(0, common.mustCall(function() {
+  const socket = tls.connect({
+    port: this.address().port,
+    rejectUnauthorized: false
+  }, common.mustCall(() => {
+    const peerCert = socket.getPeerCertificate();
+
+    console.error(util.inspect(peerCert));
+    assert.strictEqual(peerCert.subject.CN, 'Ádám Lippai');
+    server.close();
+  }));
+  socket.end('Hello');
+}));
diff --git a/test/js/node/test/parallel/test-tls-peer-certificate-multi-keys.js b/test/js/node/test/parallel/test-tls-peer-certificate-multi-keys.js
new file mode 100644
index 0000000000..ce4a0d406f
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-peer-certificate-multi-keys.js
@@ -0,0 +1,62 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const tls = require('tls');
+const fixtures = require('../common/fixtures');
+
+const options = {
+  key: fixtures.readKey('rsa_private.pem'),
+  cert: fixtures.readKey('rsa_cert.crt')
+};
+
+const server = tls.createServer(options, function(cleartext) {
+  cleartext.end('World');
+});
+
+server.once('secureConnection', common.mustCall(function(socket) {
+  const cert = socket.getCertificate();
+  // The server's local cert is the client's peer cert.
+  assert.deepStrictEqual(
+    cert.subject.OU,
+    ['Test TLS Certificate', 'Engineering']
+  );
+}));
+
+server.listen(0, common.mustCall(function() {
+  const socket = tls.connect({
+    port: this.address().port,
+    rejectUnauthorized: false
+  }, common.mustCall(function() {
+    const peerCert = socket.getPeerCertificate();
+    assert.deepStrictEqual(
+      peerCert.subject.OU,
+      ['Test TLS Certificate', 'Engineering']
+    );
+    server.close();
+  }));
+  socket.end('Hello');
+}));
diff --git a/test/js/node/test/parallel/test-tls-psk-server.js b/test/js/node/test/parallel/test-tls-psk-server.js
new file mode 100644
index 0000000000..b926095840
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-psk-server.js
@@ -0,0 +1,77 @@
+'use strict';
+const common = require('../common');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+if (!common.opensslCli)
+  common.skip('missing openssl cli');
+
+const assert = require('assert');
+
+const tls = require('tls');
+const spawn = require('child_process').spawn;
+
+const CIPHERS = 'PSK+HIGH';
+const KEY = 'd731ef57be09e5204f0b205b60627028';
+const IDENTITY = 'TestUser';
+
+const server = tls.createServer({
+  ciphers: CIPHERS,
+  pskIdentityHint: IDENTITY,
+  pskCallback(socket, identity) {
+    assert.ok(socket instanceof tls.TLSSocket);
+    assert.ok(typeof identity === 'string');
+    if (identity === IDENTITY)
+      return Buffer.from(KEY, 'hex');
+  }
+});
+
+server.on('connection', common.mustCall());
+
+server.on('secureConnection', (socket) => {
+  socket.write('hello\r\n');
+
+  socket.on('data', (data) => {
+    socket.write(data);
+  });
+});
+
+let gotHello = false;
+let sentWorld = false;
+let gotWorld = false;
+
+server.listen(0, () => {
+  const client = spawn(common.opensslCli, [
+    's_client',
+    '-connect', `127.0.0.1:${server.address().port}`,
+    '-cipher', CIPHERS,
+    '-psk', KEY,
+    '-psk_identity', IDENTITY,
+  ]);
+
+  let out = '';
+
+  client.stdout.setEncoding('utf8');
+  client.stdout.on('data', (d) => {
+    out += d;
+
+    if (!gotHello && /hello/.test(out)) {
+      gotHello = true;
+      client.stdin.write('world\r\n');
+      sentWorld = true;
+    }
+
+    if (!gotWorld && /world/.test(out)) {
+      gotWorld = true;
+      client.stdin.end();
+    }
+  });
+
+  client.on('exit', common.mustCall((code) => {
+    assert.ok(gotHello);
+    assert.ok(sentWorld);
+    assert.ok(gotWorld);
+    assert.strictEqual(code, 0);
+    server.close();
+  }));
+});
diff --git a/test/js/node/test/parallel/test-tls-reuse-host-from-socket.js b/test/js/node/test/parallel/test-tls-reuse-host-from-socket.js
new file mode 100644
index 0000000000..1a7705d911
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-reuse-host-from-socket.js
@@ -0,0 +1,43 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const net = require('net');
+const tls = require('tls');
+const fixtures = require('../common/fixtures');
+
+const server = tls.createServer({
+  key: fixtures.readKey('agent1-key.pem'),
+  cert: fixtures.readKey('agent1-cert.pem')
+}).listen(0, common.mustCall(() => {
+  const socket = net.connect(server.address().port, common.mustCall(() => {
+    const opts = { socket, rejectUnauthorized: false };
+    const secureSocket = tls.connect(opts, common.mustCall(() => {
+      secureSocket.destroy();
+      server.close();
+    }));
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-tls-secure-context-usage-order.js b/test/js/node/test/parallel/test-tls-secure-context-usage-order.js
new file mode 100644
index 0000000000..c79a3eac77
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-secure-context-usage-order.js
@@ -0,0 +1,99 @@
+'use strict';
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+// This test ensures that when a TLS connection is established, the server
+// selects the most recently added SecureContext that matches the servername.
+
+const assert = require('assert');
+const tls = require('tls');
+
+function loadPEM(n) {
+  return fixtures.readKey(`${n}.pem`);
+}
+
+const serverOptions = {
+  key: loadPEM('agent2-key'),
+  cert: loadPEM('agent2-cert'),
+  requestCert: true,
+  rejectUnauthorized: false,
+};
+
+const badSecureContext = {
+  key: loadPEM('agent1-key'),
+  cert: loadPEM('agent1-cert'),
+  ca: [ loadPEM('ca2-cert') ]
+};
+
+const goodSecureContext = {
+  key: loadPEM('agent1-key'),
+  cert: loadPEM('agent1-cert'),
+  ca: [ loadPEM('ca1-cert') ]
+};
+
+const server = tls.createServer(serverOptions, (c) => {
+  // The 'a' and 'b' subdomains are used to distinguish between client
+  // connections.
+  // Connection to subdomain 'a' is made when the 'bad' secure context is
+  // the only one in use.
+  if ('a.example.com' === c.servername) {
+    assert.strictEqual(c.authorized, false);
+  }
+  // Connection to subdomain 'b' is made after the 'good' context has been
+  // added.
+  if ('b.example.com' === c.servername) {
+    assert.strictEqual(c.authorized, true);
+  }
+});
+
+// 1. Add the 'bad' secure context. A connection using this context will not be
+// authorized.
+server.addContext('*.example.com', badSecureContext);
+
+server.listen(0, () => {
+  const options = {
+    port: server.address().port,
+    key: loadPEM('agent1-key'),
+    cert: loadPEM('agent1-cert'),
+    ca: [loadPEM('ca1-cert')],
+    servername: 'a.example.com',
+    rejectUnauthorized: false,
+  };
+
+  // 2. Make a connection using servername 'a.example.com'. Since a 'bad'
+  // secure context is used, this connection should not be authorized.
+  const client = tls.connect(options, () => {
+    client.end();
+  });
+
+  client.on('close', common.mustCall(() => {
+    // 3. Add a 'good' secure context.
+    server.addContext('*.example.com', goodSecureContext);
+
+    options.servername = 'b.example.com';
+    // 4. Make a connection using servername 'b.example.com'. This connection
+    // should be authorized because the 'good' secure context is the most
+    // recently added matching context.
+
+    const other = tls.connect(options, () => {
+      other.end();
+    });
+
+    other.on('close', common.mustCall(() => {
+      // 5. Make another connection using servername 'b.example.com' to ensure
+      // that the array of secure contexts is not reversed in place with each
+      // SNICallback call, as someone might be tempted to refactor this piece of
+      // code by using Array.prototype.reverse() method.
+      const onemore = tls.connect(options, () => {
+        onemore.end();
+      });
+
+      onemore.on('close', common.mustCall(() => {
+        server.close();
+      }));
+    }));
+  }));
+});
diff --git a/test/js/node/test/parallel/test-tls-securepair-server.js b/test/js/node/test/parallel/test-tls-securepair-server.js
new file mode 100644
index 0000000000..78cd9f7254
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-securepair-server.js
@@ -0,0 +1,145 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+if (!common.opensslCli)
+  common.skip('missing openssl-cli');
+
+const assert = require('assert');
+const tls = require('tls');
+const net = require('net');
+const spawn = require('child_process').spawn;
+const fixtures = require('../common/fixtures');
+
+const key = fixtures.readKey('rsa_private.pem');
+const cert = fixtures.readKey('rsa_cert.crt');
+
+function log(a) {
+  console.error('***server***', a);
+}
+
+const server = net.createServer(common.mustCall(function(socket) {
+  log(`connection fd=${socket.fd}`);
+  const sslcontext = tls.createSecureContext({ key, cert });
+  sslcontext.context.setCiphers('RC4-SHA:AES128-SHA:AES256-SHA');
+
+  const pair = tls.createSecurePair(sslcontext, true);
+
+  assert.ok(pair.encrypted.writable);
+  assert.ok(pair.cleartext.writable);
+
+  pair.encrypted.pipe(socket);
+  socket.pipe(pair.encrypted);
+
+  log('i set it secure');
+
+  pair.on('secure', function() {
+    log('connected+secure!');
+    pair.cleartext.write('hello\r\n');
+    log(pair.cleartext.getPeerCertificate());
+    log(pair.cleartext.getCipher());
+  });
+
+  pair.cleartext.on('data', function(data) {
+    log(`read bytes ${data.length}`);
+    pair.cleartext.write(data);
+  });
+
+  socket.on('end', function() {
+    log('socket end');
+  });
+
+  pair.cleartext.on('error', function(err) {
+    log('got error: ');
+    log(err);
+    socket.destroy();
+  });
+
+  pair.encrypted.on('error', function(err) {
+    log('encrypted error: ');
+    log(err);
+    socket.destroy();
+  });
+
+  socket.on('error', function(err) {
+    log('socket error: ');
+    log(err);
+    socket.destroy();
+  });
+
+  socket.on('close', function(err) {
+    log('socket closed');
+  });
+
+  pair.on('error', function(err) {
+    log('secure error: ');
+    log(err);
+    socket.destroy();
+  });
+}));
+
+let gotHello = false;
+let sentWorld = false;
+let gotWorld = false;
+
+server.listen(0, common.mustCall(function() {
+  // To test use: openssl s_client -connect localhost:8000
+
+  const args = ['s_client', '-connect', `127.0.0.1:${this.address().port}`];
+
+  const client = spawn(common.opensslCli, args);
+
+
+  let out = '';
+
+  client.stdout.setEncoding('utf8');
+  client.stdout.on('data', function(d) {
+    out += d;
+
+    if (!gotHello && /hello/.test(out)) {
+      gotHello = true;
+      client.stdin.write('world\r\n');
+      sentWorld = true;
+    }
+
+    if (!gotWorld && /world/.test(out)) {
+      gotWorld = true;
+      client.stdin.end();
+    }
+  });
+
+  client.stdout.pipe(process.stdout, { end: false });
+
+  client.on('exit', common.mustCall(function(code) {
+    assert.strictEqual(code, 0);
+    server.close();
+  }));
+}));
+
+process.on('exit', function() {
+  assert.ok(gotHello);
+  assert.ok(sentWorld);
+  assert.ok(gotWorld);
+});
diff --git a/test/js/node/test/parallel/test-tls-server-connection-server.js b/test/js/node/test/parallel/test-tls-server-connection-server.js
new file mode 100644
index 0000000000..7fb2c74996
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-server-connection-server.js
@@ -0,0 +1,32 @@
+'use strict';
+const common = require('../common');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const tls = require('tls');
+const fixtures = require('../common/fixtures');
+
+const options = {
+  key: fixtures.readKey('agent1-key.pem'),
+  cert: fixtures.readKey('agent1-cert.pem')
+};
+
+const server = tls.createServer(options, function(s) {
+  s.end('hello');
+}).listen(0, function() {
+  const opts = {
+    port: this.address().port,
+    rejectUnauthorized: false
+  };
+
+  server.on('connection', common.mustCall(function(socket) {
+    assert.strictEqual(socket.server, server);
+    server.close();
+  }));
+
+  const client = tls.connect(opts, function() {
+    client.end();
+  });
+});
diff --git a/test/js/node/test/parallel/test-tls-server-verify.js b/test/js/node/test/parallel/test-tls-server-verify.js
new file mode 100644
index 0000000000..51ccd0d747
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-server-verify.js
@@ -0,0 +1,348 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+if (!common.opensslCli)
+  common.skip('node compiled without OpenSSL CLI.');
+
+// This is a rather complex test which sets up various TLS servers with node
+// and connects to them using the 'openssl s_client' command line utility
+// with various keys. Depending on the certificate authority and other
+// parameters given to the server, the various clients are
+// - rejected,
+// - accepted and "unauthorized", or
+// - accepted and "authorized".
+
+const assert = require('assert');
+const { spawn } = require('child_process');
+const { SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION } =
+  require('crypto').constants;
+const tls = require('tls');
+const fixtures = require('../common/fixtures');
+
+const testCases =
+  [{ title: 'Do not request certs. Everyone is unauthorized.',
+     requestCert: false,
+     rejectUnauthorized: false,
+     renegotiate: false,
+     CAs: ['ca1-cert'],
+     clients:
+     [{ name: 'agent1', shouldReject: false, shouldAuth: false },
+      { name: 'agent2', shouldReject: false, shouldAuth: false },
+      { name: 'agent3', shouldReject: false, shouldAuth: false },
+      { name: 'nocert', shouldReject: false, shouldAuth: false },
+     ] },
+
+   { title: 'Allow both authed and unauthed connections with CA1',
+     requestCert: true,
+     rejectUnauthorized: false,
+     renegotiate: false,
+     CAs: ['ca1-cert'],
+     clients:
+    [{ name: 'agent1', shouldReject: false, shouldAuth: true },
+     { name: 'agent2', shouldReject: false, shouldAuth: false },
+     { name: 'agent3', shouldReject: false, shouldAuth: false },
+     { name: 'nocert', shouldReject: false, shouldAuth: false },
+    ] },
+
+   { title: 'Do not request certs at connection. Do that later',
+     requestCert: false,
+     rejectUnauthorized: false,
+     renegotiate: true,
+     CAs: ['ca1-cert'],
+     clients:
+    [{ name: 'agent1', shouldReject: false, shouldAuth: true },
+     { name: 'agent2', shouldReject: false, shouldAuth: false },
+     { name: 'agent3', shouldReject: false, shouldAuth: false },
+     { name: 'nocert', shouldReject: false, shouldAuth: false },
+    ] },
+
+   { title: 'Allow only authed connections with CA1',
+     requestCert: true,
+     rejectUnauthorized: true,
+     renegotiate: false,
+     CAs: ['ca1-cert'],
+     clients:
+    [{ name: 'agent1', shouldReject: false, shouldAuth: true },
+     { name: 'agent2', shouldReject: true },
+     { name: 'agent3', shouldReject: true },
+     { name: 'nocert', shouldReject: true },
+    ] },
+
+   { title: 'Allow only authed connections with CA1 and CA2',
+     requestCert: true,
+     rejectUnauthorized: true,
+     renegotiate: false,
+     CAs: ['ca1-cert', 'ca2-cert'],
+     clients:
+    [{ name: 'agent1', shouldReject: false, shouldAuth: true },
+     { name: 'agent2', shouldReject: true },
+     { name: 'agent3', shouldReject: false, shouldAuth: true },
+     { name: 'nocert', shouldReject: true },
+    ] },
+
+
+   { title: 'Allow only certs signed by CA2 but not in the CRL',
+     requestCert: true,
+     rejectUnauthorized: true,
+     renegotiate: false,
+     CAs: ['ca2-cert'],
+     crl: 'ca2-crl',
+     clients: [
+       { name: 'agent1', shouldReject: true, shouldAuth: false },
+       { name: 'agent2', shouldReject: true, shouldAuth: false },
+       { name: 'agent3', shouldReject: false, shouldAuth: true },
+       // Agent4 has a cert in the CRL.
+       { name: 'agent4', shouldReject: true, shouldAuth: false },
+       { name: 'nocert', shouldReject: true },
+     ] },
+  ];
+
+function filenamePEM(n) {
+  return fixtures.path('keys', `${n}.pem`);
+}
+
+function loadPEM(n) {
+  return fixtures.readKey(`${n}.pem`);
+}
+
+
+const serverKey = loadPEM('agent2-key');
+const serverCert = loadPEM('agent2-cert');
+
+
+function runClient(prefix, port, options, cb) {
+
+  // Client can connect in three ways:
+  // - Self-signed cert
+  // - Certificate, but not signed by CA.
+  // - Certificate signed by CA.
+
+  const args = ['s_client', '-connect', `127.0.0.1:${port}`];
+
+  console.log(`${prefix}  connecting with`, options.name);
+
+  switch (options.name) {
+    case 'agent1':
+      // Signed by CA1
+      args.push('-key');
+      args.push(filenamePEM('agent1-key'));
+      args.push('-cert');
+      args.push(filenamePEM('agent1-cert'));
+      break;
+
+    case 'agent2':
+      // Self-signed
+      // This is also the key-cert pair that the server will use.
+      args.push('-key');
+      args.push(filenamePEM('agent2-key'));
+      args.push('-cert');
+      args.push(filenamePEM('agent2-cert'));
+      break;
+
+    case 'agent3':
+      // Signed by CA2
+      args.push('-key');
+      args.push(filenamePEM('agent3-key'));
+      args.push('-cert');
+      args.push(filenamePEM('agent3-cert'));
+      break;
+
+    case 'agent4':
+      // Signed by CA2 (rejected by ca2-crl)
+      args.push('-key');
+      args.push(filenamePEM('agent4-key'));
+      args.push('-cert');
+      args.push(filenamePEM('agent4-cert'));
+      break;
+
+    case 'nocert':
+      // Do not send certificate
+      break;
+
+    default:
+      throw new Error(`${prefix}Unknown agent name`);
+  }
+
+  // To test use: openssl s_client -connect localhost:8000
+  const client = spawn(common.opensslCli, args);
+
+  let out = '';
+
+  let rejected = true;
+  let authed = false;
+  let goodbye = false;
+
+  client.stdout.setEncoding('utf8');
+  client.stdout.on('data', function(d) {
+    out += d;
+
+    if (!goodbye && /_unauthed/.test(out)) {
+      console.error(`${prefix}  * unauthed`);
+      goodbye = true;
+      client.kill();
+      authed = false;
+      rejected = false;
+    }
+
+    if (!goodbye && /_authed/.test(out)) {
+      console.error(`${prefix}  * authed`);
+      goodbye = true;
+      client.kill();
+      authed = true;
+      rejected = false;
+    }
+  });
+
+  client.on('exit', function(code) {
+    if (options.shouldReject) {
+      assert.strictEqual(
+        rejected, true,
+        `${prefix}${options.name} NOT rejected, but should have been`);
+    } else {
+      assert.strictEqual(
+        rejected, false,
+        `${prefix}${options.name} rejected, but should NOT have been`);
+      assert.strictEqual(
+        authed, options.shouldAuth,
+        `${prefix}${options.name} authed is ${authed} but should have been ${
+          options.shouldAuth}`);
+    }
+
+    cb();
+  });
+}
+
+
+// Run the tests
+let successfulTests = 0;
+function runTest(port, testIndex) {
+  const prefix = `${testIndex} `;
+  const tcase = testCases[testIndex];
+  if (!tcase) return;
+
+  console.error(`${prefix}Running '${tcase.title}'`);
+
+  const cas = tcase.CAs.map(loadPEM);
+
+  const crl = tcase.crl ? loadPEM(tcase.crl) : null;
+
+  const serverOptions = {
+    key: serverKey,
+    cert: serverCert,
+    ca: cas,
+    crl: crl,
+    requestCert: tcase.requestCert,
+    rejectUnauthorized: tcase.rejectUnauthorized
+  };
+
+  // If renegotiating - session might be resumed and openssl won't request
+  // client's certificate (probably because of bug in the openssl)
+  if (tcase.renegotiate) {
+    serverOptions.secureOptions =
+        SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION;
+    // Renegotiation as a protocol feature was dropped after TLS1.2.
+    serverOptions.maxVersion = 'TLSv1.2';
+  }
+
+  let renegotiated = false;
+  const server = tls.Server(serverOptions, function handleConnection(c) {
+    c.on('error', function(e) {
+      // child.kill() leads ECONNRESET error in the TLS connection of
+      // openssl s_client via spawn(). A test result is already
+      // checked by the data of client.stdout before child.kill() so
+      // these tls errors can be ignored.
+    });
+    if (tcase.renegotiate && !renegotiated) {
+      renegotiated = true;
+      setTimeout(function() {
+        console.error(`${prefix}- connected, renegotiating`);
+        c.write('\n_renegotiating\n');
+        return c.renegotiate({
+          requestCert: true,
+          rejectUnauthorized: false
+        }, function(err) {
+          assert.ifError(err);
+          c.write('\n_renegotiated\n');
+          handleConnection(c);
+        });
+      }, 200);
+      return;
+    }
+
+    if (c.authorized) {
+      console.error(`${prefix}- authed connection: ${
+        c.getPeerCertificate().subject.CN}`);
+      c.write('\n_authed\n');
+    } else {
+      console.error(`${prefix}- unauthed connection: %s`, c.authorizationError);
+      c.write('\n_unauthed\n');
+    }
+  });
+
+  function runNextClient(clientIndex) {
+    const options = tcase.clients[clientIndex];
+    if (options) {
+      runClient(`${prefix}${clientIndex} `, port, options, function() {
+        runNextClient(clientIndex + 1);
+      });
+    } else {
+      server.close();
+      successfulTests++;
+      runTest(0, nextTest++);
+    }
+  }
+
+  server.listen(port, function() {
+    port = server.address().port;
+    if (tcase.debug) {
+      console.error(`${prefix}TLS server running on port ${port}`);
+    } else if (tcase.renegotiate) {
+      runNextClient(0);
+    } else {
+      let clientsCompleted = 0;
+      for (let i = 0; i < tcase.clients.length; i++) {
+        runClient(`${prefix}${i} `, port, tcase.clients[i], function() {
+          clientsCompleted++;
+          if (clientsCompleted === tcase.clients.length) {
+            server.close();
+            successfulTests++;
+            runTest(0, nextTest++);
+          }
+        });
+      }
+    }
+  });
+}
+
+
+let nextTest = 0;
+runTest(0, nextTest++);
+
+
+process.on('exit', function() {
+  assert.strictEqual(successfulTests, testCases.length);
+});
diff --git a/test/js/node/test/parallel/test-tls-session-cache.js b/test/js/node/test/parallel/test-tls-session-cache.js
new file mode 100644
index 0000000000..e4ecb53282
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-session-cache.js
@@ -0,0 +1,164 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+const tls = require('tls');
+const { spawn } = require('child_process');
+
+if (!common.opensslCli)
+  common.skip('node compiled without OpenSSL CLI.');
+
+
+doTest({ tickets: false }, function() {
+  doTest({ tickets: true }, function() {
+    doTest({ tickets: false, invalidSession: true }, function() {
+      console.error('all done');
+    });
+  });
+});
+
+function doTest(testOptions, callback) {
+  const key = fixtures.readKey('rsa_private.pem');
+  const cert = fixtures.readKey('rsa_cert.crt');
+  const options = {
+    key,
+    cert,
+    ca: [cert],
+    requestCert: true,
+    rejectUnauthorized: false,
+    secureProtocol: 'TLS_method',
+    ciphers: 'RSA@SECLEVEL=0'
+  };
+  let requestCount = 0;
+  let resumeCount = 0;
+  let newSessionCount = 0;
+  let session;
+
+  const server = tls.createServer(options, function(cleartext) {
+    cleartext.on('error', function(er) {
+      // We're ok with getting ECONNRESET in this test, but it's
+      // timing-dependent, and thus unreliable. Any other errors
+      // are just failures, though.
+      if (er.code !== 'ECONNRESET')
+        throw er;
+    });
+    ++requestCount;
+    cleartext.end('');
+  });
+  server.on('newSession', function(id, data, cb) {
+    ++newSessionCount;
+    // Emulate asynchronous store
+    setImmediate(() => {
+      assert.ok(!session);
+      session = { id, data };
+      cb();
+    });
+  });
+  server.on('resumeSession', function(id, callback) {
+    ++resumeCount;
+    assert.ok(session);
+    assert.strictEqual(session.id.toString('hex'), id.toString('hex'));
+
+    let data = session.data;
+
+    // Return an invalid session to test Node does not crash.
+    if (testOptions.invalidSession) {
+      data = Buffer.from('INVALID SESSION');
+      session = null;
+    }
+
+    // Just to check that async really works there
+    setImmediate(() => {
+      callback(null, data);
+    });
+  });
+
+  server.listen(0, function() {
+    const args = [
+      's_client',
+      '-tls1',
+      '-cipher', (common.hasOpenSSL31 ? 'DEFAULT:@SECLEVEL=0' : 'DEFAULT'),
+      '-connect', `localhost:${this.address().port}`,
+      '-servername', 'ohgod',
+      '-key', fixtures.path('keys/rsa_private.pem'),
+      '-cert', fixtures.path('keys/rsa_cert.crt'),
+      '-reconnect',
+    ].concat(testOptions.tickets ? [] : '-no_ticket');
+
+    function spawnClient() {
+      const client = spawn(common.opensslCli, args, {
+        stdio: [ 0, 1, 'pipe' ]
+      });
+      let err = '';
+      client.stderr.setEncoding('utf8');
+      client.stderr.on('data', function(chunk) {
+        err += chunk;
+      });
+
+      client.on('exit', common.mustCall(function(code, signal) {
+        if (code !== 0) {
+          // If SmartOS and connection refused, then retry. See
+          // https://github.com/nodejs/node/issues/2663.
+          if (common.isSunOS && err.includes('Connection refused')) {
+            requestCount = 0;
+            spawnClient();
+            return;
+          }
+          assert.fail(`code: ${code}, signal: ${signal}, output: ${err}`);
+        }
+        assert.strictEqual(code, 0);
+        server.close(common.mustCall(function() {
+          setImmediate(callback);
+        }));
+      }));
+    }
+
+    spawnClient();
+  });
+
+  process.on('exit', function() {
+    // Each test run connects 6 times: an initial request and 5 reconnect
+    // requests.
+    assert.strictEqual(requestCount, 6);
+
+    if (testOptions.tickets) {
+      // No session cache callbacks are called.
+      assert.strictEqual(resumeCount, 0);
+      assert.strictEqual(newSessionCount, 0);
+    } else if (testOptions.invalidSession) {
+      // The resume callback was called, but each connection established a
+      // fresh session.
+      assert.strictEqual(resumeCount, 5);
+      assert.strictEqual(newSessionCount, 6);
+    } else {
+      // The resume callback was called, and only the initial connection
+      // establishes a fresh session.
+      assert.ok(session);
+      assert.strictEqual(resumeCount, 5);
+      assert.strictEqual(newSessionCount, 1);
+    }
+  });
+}
diff --git a/test/js/node/test/parallel/test-tls-set-ciphers.js b/test/js/node/test/parallel/test-tls-set-ciphers.js
new file mode 100644
index 0000000000..313c5e2389
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-set-ciphers.js
@@ -0,0 +1,131 @@
+'use strict';
+const common = require('../common');
+if (!common.hasOpenSSL3)
+  common.skip('missing crypto, or OpenSSL version lower than 3');
+
+const fixtures = require('../common/fixtures');
+const { inspect } = require('util');
+
+// Test cipher: option for TLS.
+
+const {
+  assert, connect, keys
+} = require(fixtures.path('tls-connect'));
+
+
+function test(cciphers, sciphers, cipher, cerr, serr, options) {
+  assert(cipher || cerr || serr, 'test missing any expectations');
+  const where = inspect(new Error()).split('\n')[2].replace(/[^(]*/, '');
+
+  const max_tls_ver = (ciphers, options) => {
+    if (options instanceof Object && Object.hasOwn(options, 'maxVersion'))
+      return options.maxVersion;
+    if ((typeof ciphers === 'string' || ciphers instanceof String) && ciphers.length > 0 && !ciphers.includes('TLS_'))
+      return 'TLSv1.2';
+
+    return 'TLSv1.3';
+  };
+
+  connect({
+    client: {
+      checkServerIdentity: (servername, cert) => { },
+      ca: `${keys.agent1.cert}\n${keys.agent6.ca}`,
+      ciphers: cciphers,
+      maxVersion: max_tls_ver(cciphers, options),
+    },
+    server: {
+      cert: keys.agent6.cert,
+      key: keys.agent6.key,
+      ciphers: sciphers,
+      maxVersion: max_tls_ver(sciphers, options),
+    },
+  }, common.mustCall((err, pair, cleanup) => {
+    function u(_) { return _ === undefined ? 'U' : _; }
+    console.log('test:', u(cciphers), u(sciphers),
+                'expect', u(cipher), u(cerr), u(serr));
+    console.log('  ', where);
+    if (!cipher) {
+      console.log('client', pair.client.err ? pair.client.err.code : undefined);
+      console.log('server', pair.server.err ? pair.server.err.code : undefined);
+      if (cerr) {
+        assert(pair.client.err);
+        assert.strictEqual(pair.client.err.code, cerr);
+      }
+      if (serr) {
+        assert(pair.server.err);
+        assert.strictEqual(pair.server.err.code, serr);
+      }
+      return cleanup();
+    }
+
+    const reply = 'So long and thanks for all the fish.';
+
+    assert.ifError(err);
+    assert.ifError(pair.server.err);
+    assert.ifError(pair.client.err);
+    assert(pair.server.conn);
+    assert(pair.client.conn);
+    assert.strictEqual(pair.client.conn.getCipher().name, cipher);
+    assert.strictEqual(pair.server.conn.getCipher().name, cipher);
+
+    pair.server.conn.write(reply);
+
+    pair.client.conn.on('data', common.mustCall((data) => {
+      assert.strictEqual(data.toString(), reply);
+      return cleanup();
+    }));
+  }));
+}
+
+const U = undefined;
+
+// Have shared ciphers.
+test(U, 'AES256-SHA', 'AES256-SHA');
+test('AES256-SHA', U, 'AES256-SHA');
+
+test(U, 'TLS_AES_256_GCM_SHA384', 'TLS_AES_256_GCM_SHA384');
+test('TLS_AES_256_GCM_SHA384', U, 'TLS_AES_256_GCM_SHA384');
+test('TLS_AES_256_GCM_SHA384:!TLS_CHACHA20_POLY1305_SHA256', U, 'TLS_AES_256_GCM_SHA384');
+
+// Do not have shared ciphers.
+test('TLS_AES_256_GCM_SHA384', 'TLS_CHACHA20_POLY1305_SHA256',
+     U, 'ERR_SSL_SSLV3_ALERT_HANDSHAKE_FAILURE', 'ERR_SSL_NO_SHARED_CIPHER');
+
+test('AES128-SHA', 'AES256-SHA', U, 'ERR_SSL_SSLV3_ALERT_HANDSHAKE_FAILURE',
+     'ERR_SSL_NO_SHARED_CIPHER');
+test('AES128-SHA:TLS_AES_256_GCM_SHA384',
+     'TLS_CHACHA20_POLY1305_SHA256:AES256-SHA',
+     U, 'ERR_SSL_SSLV3_ALERT_HANDSHAKE_FAILURE', 'ERR_SSL_NO_SHARED_CIPHER');
+
+// Cipher order ignored, TLS1.3 chosen before TLS1.2.
+test('AES256-SHA:TLS_AES_256_GCM_SHA384', U, 'TLS_AES_256_GCM_SHA384');
+test(U, 'AES256-SHA:TLS_AES_256_GCM_SHA384', 'TLS_AES_256_GCM_SHA384');
+
+// Cipher order ignored, TLS1.3 before TLS1.2 and
+// cipher suites are not disabled if TLS ciphers are set only
+// TODO: maybe these tests should be reworked so maxVersion clamping
+// is done explicitly and not implicitly in the test() function
+test('AES256-SHA', U, 'TLS_AES_256_GCM_SHA384', U, U, { maxVersion: 'TLSv1.3' });
+test(U, 'AES256-SHA', 'TLS_AES_256_GCM_SHA384', U, U, { maxVersion: 'TLSv1.3' });
+
+// TLS_AES_128_CCM_8_SHA256 & TLS_AES_128_CCM_SHA256 are not enabled by
+// default, but work.
+test('TLS_AES_128_CCM_8_SHA256', U,
+     U, 'ERR_SSL_SSLV3_ALERT_HANDSHAKE_FAILURE', 'ERR_SSL_NO_SHARED_CIPHER');
+
+test('TLS_AES_128_CCM_8_SHA256', 'TLS_AES_128_CCM_8_SHA256',
+     'TLS_AES_128_CCM_8_SHA256');
+
+// Invalid cipher values
+test(9, 'AES256-SHA', U, 'ERR_INVALID_ARG_TYPE', U);
+test('AES256-SHA', 9, U, U, 'ERR_INVALID_ARG_TYPE');
+test(':', 'AES256-SHA', U, 'ERR_INVALID_ARG_VALUE', U);
+test('AES256-SHA', ':', U, U, 'ERR_INVALID_ARG_VALUE');
+
+// Using '' is synonymous for "use default ciphers"
+test('TLS_AES_256_GCM_SHA384', '', 'TLS_AES_256_GCM_SHA384');
+test('', 'TLS_AES_256_GCM_SHA384', 'TLS_AES_256_GCM_SHA384');
+
+// Using null should be treated the same as undefined.
+test(null, 'AES256-SHA', 'AES256-SHA');
+test('AES256-SHA', null, 'AES256-SHA');
diff --git a/test/js/node/test/parallel/test-tls-startcom-wosign-whitelist.js b/test/js/node/test/parallel/test-tls-startcom-wosign-whitelist.js
new file mode 100644
index 0000000000..56ffd73aac
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-startcom-wosign-whitelist.js
@@ -0,0 +1,84 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const tls = require('tls');
+const fixtures = require('../common/fixtures');
+
+let finished = 0;
+
+function loadPEM(n) {
+  return fixtures.readKey(`${n}.pem`);
+}
+
+const testCases = [
+  { // agent8 is signed by fake-startcom-root with notBefore of
+    // Oct 20 23:59:59 2016 GMT. It passes StartCom/WoSign check.
+    serverOpts: {
+      key: loadPEM('agent8-key'),
+      cert: loadPEM('agent8-cert')
+    },
+    clientOpts: {
+      ca: loadPEM('fake-startcom-root-cert'),
+      port: undefined,
+      rejectUnauthorized: true
+    },
+    errorCode: 'CERT_REVOKED'
+  },
+  { // agent9 is signed by fake-startcom-root with notBefore of
+    // Oct 21 00:00:01 2016 GMT. It fails StartCom/WoSign check.
+    serverOpts: {
+      key: loadPEM('agent9-key'),
+      cert: loadPEM('agent9-cert')
+    },
+    clientOpts: {
+      ca: loadPEM('fake-startcom-root-cert'),
+      port: undefined,
+      rejectUnauthorized: true
+    },
+    errorCode: 'CERT_REVOKED'
+  },
+];
+
+
+function runNextTest(server, tindex) {
+  server.close(function() {
+    finished++;
+    runTest(tindex + 1);
+  });
+}
+
+
+function runTest(tindex) {
+  const tcase = testCases[tindex];
+
+  if (!tcase) return;
+
+  const server = tls.createServer(tcase.serverOpts, function(s) {
+    s.resume();
+  }).listen(0, function() {
+    tcase.clientOpts.port = this.address().port;
+    const client = tls.connect(tcase.clientOpts);
+    client.on('error', function(e) {
+      assert.strictEqual(e.code, tcase.errorCode);
+      runNextTest(server, tindex);
+    });
+
+    client.on('secureConnect', function() {
+      // agent8 can pass StartCom/WoSign check so that the secureConnect
+      // is established.
+      assert.strictEqual(tcase.errorCode, 'CERT_REVOKED');
+      client.end();
+      runNextTest(server, tindex);
+    });
+  });
+}
+
+
+runTest(0);
+
+process.on('exit', function() {
+  assert.strictEqual(finished, testCases.length);
+});
diff --git a/test/js/node/test/parallel/test-tls-tlswrap-segfault-2.js b/test/js/node/test/parallel/test-tls-tlswrap-segfault-2.js
new file mode 100644
index 0000000000..d4f3b12b99
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-tlswrap-segfault-2.js
@@ -0,0 +1,22 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+// This test ensures that Node.js doesn't incur a segfault while
+// adding session or keylog listeners after destroy.
+// https://github.com/nodejs/node/issues/38133
+// https://github.com/nodejs/node/issues/38135
+
+const tls = require('tls');
+const tlsSocketKeyLog = tls.connect('cause-error');
+tlsSocketKeyLog.on('error', common.mustCall());
+tlsSocketKeyLog.on('close', common.mustCall(() => {
+  tlsSocketKeyLog.on('keylog', common.mustNotCall());
+}));
+
+const tlsSocketSession = tls.connect('cause-error-2');
+tlsSocketSession.on('error', common.mustCall());
+tlsSocketSession.on('close', common.mustCall(() => {
+  tlsSocketSession.on('session', common.mustNotCall());
+}));
diff --git a/test/js/node/test/parallel/test-tls-tlswrap-segfault.js b/test/js/node/test/parallel/test-tls-tlswrap-segfault.js
new file mode 100644
index 0000000000..a36016efa4
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-tlswrap-segfault.js
@@ -0,0 +1,42 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const fixtures = require('../common/fixtures');
+
+// This test ensures that Node.js doesn't incur a segfault while accessing
+// TLSWrap fields after the parent handle was destroyed.
+// https://github.com/nodejs/node/issues/5108
+
+const assert = require('assert');
+const tls = require('tls');
+
+const options = {
+  key: fixtures.readKey('agent1-key.pem'),
+  cert: fixtures.readKey('agent1-cert.pem')
+};
+
+const server = tls.createServer(options, function(s) {
+  s.end('hello');
+}).listen(0, function() {
+  const opts = {
+    port: this.address().port,
+    rejectUnauthorized: false
+  };
+  const client = tls.connect(opts, function() {
+    putImmediate(client);
+  });
+  client.resume();
+});
+
+function putImmediate(client) {
+  setImmediate(function() {
+    if (client.ssl) {
+      const fd = client.ssl.fd;
+      assert(!!fd);
+      putImmediate(client);
+    } else {
+      server.close();
+    }
+  });
+}
diff --git a/test/js/node/test/parallel/test-tls-wrap-econnreset-socket.js b/test/js/node/test/parallel/test-tls-wrap-econnreset-socket.js
new file mode 100644
index 0000000000..ec305b785e
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-wrap-econnreset-socket.js
@@ -0,0 +1,34 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const net = require('net');
+const tls = require('tls');
+
+const server = net.createServer((c) => {
+  c.end();
+}).listen(common.mustCall(() => {
+  const port = server.address().port;
+
+  const socket = new net.Socket();
+
+  let errored = false;
+  tls.connect({ socket })
+    .once('error', common.mustCall((e) => {
+      assert.strictEqual(e.code, 'ECONNRESET');
+      assert.strictEqual(e.path, undefined);
+      assert.strictEqual(e.host, undefined);
+      assert.strictEqual(e.port, undefined);
+      assert.strictEqual(e.localAddress, undefined);
+      errored = true;
+      server.close();
+    }))
+    .on('close', common.mustCall(() => {
+      assert.strictEqual(errored, true);
+    }));
+
+  socket.connect(port);
+}));
diff --git a/test/js/node/test/parallel/test-tls-zero-clear-in.js b/test/js/node/test/parallel/test-tls-zero-clear-in.js
new file mode 100644
index 0000000000..f24fb6f992
--- /dev/null
+++ b/test/js/node/test/parallel/test-tls-zero-clear-in.js
@@ -0,0 +1,60 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const tls = require('tls');
+const fixtures = require('../common/fixtures');
+
+const cert = fixtures.readKey('rsa_cert.crt');
+const key = fixtures.readKey('rsa_private.pem');
+
+const server = tls.createServer({
+  cert,
+  key
+}, function(c) {
+  // Nop
+  setTimeout(function() {
+    c.end();
+    server.close();
+  }, 20);
+}).listen(0, common.mustCall(function() {
+  const conn = tls.connect({
+    cert: cert,
+    key: key,
+    rejectUnauthorized: false,
+    port: this.address().port
+  }, function() {
+    setTimeout(function() {
+      conn.destroy();
+    }, 20);
+  });
+
+  // SSL_write() call's return value, when called 0 bytes, should not be
+  // treated as error.
+  conn.end('');
+
+  conn.on('error', common.mustNotCall());
+}));
diff --git a/test/js/node/test/parallel/test-trace-events-net-abstract-socket.js b/test/js/node/test/parallel/test-trace-events-net-abstract-socket.js
new file mode 100644
index 0000000000..d2e1546743
--- /dev/null
+++ b/test/js/node/test/parallel/test-trace-events-net-abstract-socket.js
@@ -0,0 +1,43 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const cp = require('child_process');
+const fs = require('fs');
+const tmpdir = require('../common/tmpdir');
+
+if (!common.isLinux) common.skip();
+
+const CODE = `
+  const net = require('net');
+  net.connect('${common.PIPE}').on('error', () => {});
+  net.connect('\\0${common.PIPE}').on('error', () => {});
+`;
+
+tmpdir.refresh();
+const FILE_NAME = tmpdir.resolve('node_trace.1.log');
+
+const proc = cp.spawn(process.execPath,
+                      [ '--trace-events-enabled',
+                        '--trace-event-categories', 'node.net.native',
+                        '-e', CODE ],
+                      { cwd: tmpdir.path });
+
+proc.once('exit', common.mustCall(() => {
+  assert(fs.existsSync(FILE_NAME));
+  fs.readFile(FILE_NAME, common.mustCall((err, data) => {
+    const traces = JSON.parse(data.toString()).traceEvents;
+    assert(traces.length > 0);
+    let count = 0;
+    traces.forEach((trace) => {
+      if (trace.cat === 'node,node.net,node.net.native' &&
+          trace.name === 'connect') {
+        count++;
+        if (trace.ph === 'b') {
+          assert.ok(!!trace.args.path_type);
+          assert.ok(!!trace.args.pipe_path);
+        }
+      }
+    });
+    assert.strictEqual(count, 4);
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-tty-stdin-end.js b/test/js/node/test/parallel/test-tty-stdin-end.js
new file mode 100644
index 0000000000..c78f58446d
--- /dev/null
+++ b/test/js/node/test/parallel/test-tty-stdin-end.js
@@ -0,0 +1,7 @@
+'use strict';
+require('../common');
+
+// This test ensures that Node.js doesn't crash on `process.stdin.emit("end")`.
+// https://github.com/nodejs/node/issues/1068
+
+process.stdin.emit('end');
diff --git a/test/js/node/test/parallel/test-tz-version.js b/test/js/node/test/parallel/test-tz-version.js
new file mode 100644
index 0000000000..6e4b14e1ac
--- /dev/null
+++ b/test/js/node/test/parallel/test-tz-version.js
@@ -0,0 +1,28 @@
+'use strict';
+
+const common = require('../common');
+
+if (!common.hasIntl) {
+  common.skip('missing Intl');
+}
+
+// Refs: https://github.com/nodejs/node/blob/1af63a90ca3a59ca05b3a12ad7dbea04008db7d9/configure.py#L1694-L1711
+if (process.config.variables.icu_path !== 'deps/icu-small') {
+  // If Node.js is configured to use its built-in ICU, it uses a strict subset
+  // of ICU formed using `tools/icu/shrink-icu-src.py`, which is present in
+  // `deps/icu-small`. It is not the same as configuring the build with
+  // `./configure --with-intl=small-icu`. The latter only uses a subset of the
+  // locales, i.e., it uses the English locale, `root,en`, by default and other
+  // locales can also be specified using the `--with-icu-locales` option.
+  common.skip('not using the icu data file present in deps/icu-small/source/data/in/icudt##l.dat.bz2');
+}
+
+const fixtures = require('../common/fixtures');
+
+// This test ensures the correctness of the automated timezone upgrade PRs.
+
+const { strictEqual } = require('assert');
+const { readFileSync } = require('fs');
+
+const expectedVersion = readFileSync(fixtures.path('tz-version.txt'), 'utf8').trim();
+strictEqual(process.versions.tz, expectedVersion);
diff --git a/test/js/node/test/parallel/test-unhandled-exception-with-worker-inuse.js b/test/js/node/test/parallel/test-unhandled-exception-with-worker-inuse.js
new file mode 100644
index 0000000000..a3e823ca70
--- /dev/null
+++ b/test/js/node/test/parallel/test-unhandled-exception-with-worker-inuse.js
@@ -0,0 +1,32 @@
+'use strict';
+const common = require('../common');
+
+// https://github.com/nodejs/node/issues/45421
+//
+// Check that node will NOT call v8::Isolate::SetIdle() when exiting
+// due to an unhandled exception, otherwise the assertion(enabled in
+// debug build only) in the SetIdle(), which checks that the vm state
+// is either EXTERNAL or IDLE will fail.
+//
+// The root cause of this issue is that before PerIsolateMessageListener()
+// is invoked by v8, v8 preserves the JS vm state, although it should
+// switch to EXTERNEL. https://bugs.chromium.org/p/v8/issues/detail?id=13464
+//
+// Therefore, this commit can be considered as an workaround of the v8 bug,
+// but we also find it not useful to call SetIdle() when terminating.
+
+if (process.argv[2] === 'child') {
+  const { Worker } = require('worker_threads');
+  new Worker('', { eval: true });
+  throw new Error('xxx');
+} else {
+  const assert = require('assert');
+  const { spawnSync } = require('child_process');
+  const result = spawnSync(process.execPath, [__filename, 'child']);
+
+  const stderr = result.stderr.toString().trim();
+  // Expect error message to be preserved
+  assert.match(stderr, /xxx/);
+  // Expect no crash
+  assert(!common.nodeProcessAborted(result.status, result.signal), stderr);
+}
diff --git a/test/js/node/test/parallel/test-url-canParse-whatwg.js b/test/js/node/test/parallel/test-url-canParse-whatwg.js
new file mode 100644
index 0000000000..d5ffee7053
--- /dev/null
+++ b/test/js/node/test/parallel/test-url-canParse-whatwg.js
@@ -0,0 +1,19 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+
+// One argument is required
+assert.throws(() => {
+  URL.canParse();
+}, {
+  code: 'ERR_MISSING_ARGS',
+  name: 'TypeError',
+});
+
+{
+  // This test is to ensure that the v8 fast api works.
+  for (let i = 0; i < 1e5; i++) {
+    assert(URL.canParse('https://www.example.com/path/?query=param#hash'));
+  }
+}
diff --git a/test/js/node/test/parallel/test-url-domain-ascii-unicode.js b/test/js/node/test/parallel/test-url-domain-ascii-unicode.js
new file mode 100644
index 0000000000..737294c241
--- /dev/null
+++ b/test/js/node/test/parallel/test-url-domain-ascii-unicode.js
@@ -0,0 +1,31 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasIntl)
+  common.skip('missing Intl');
+
+const strictEqual = require('assert').strictEqual;
+const url = require('url');
+
+const domainToASCII = url.domainToASCII;
+const domainToUnicode = url.domainToUnicode;
+
+const domainWithASCII = [
+  ['ıíd', 'xn--d-iga7r'],
+  ['يٴ', 'xn--mhb8f'],
+  ['www.ϧƽəʐ.com', 'www.xn--cja62apfr6c.com'],
+  ['новини.com', 'xn--b1amarcd.com'],
+  ['名がドメイン.com', 'xn--v8jxj3d1dzdz08w.com'],
+  ['افغانستا.icom.museum', 'xn--mgbaal8b0b9b2b.icom.museum'],
+  ['الجزائر.icom.fake', 'xn--lgbbat1ad8j.icom.fake'],
+  ['भारत.org', 'xn--h2brj9c.org'],
+];
+
+domainWithASCII.forEach((pair) => {
+  const domain = pair[0];
+  const ascii = pair[1];
+  const domainConvertedToASCII = domainToASCII(domain);
+  strictEqual(domainConvertedToASCII, ascii);
+  const asciiConvertedToUnicode = domainToUnicode(ascii);
+  strictEqual(asciiConvertedToUnicode, domain);
+});
diff --git a/test/js/node/test/parallel/test-url-format-whatwg.js b/test/js/node/test/parallel/test-url-format-whatwg.js
new file mode 100644
index 0000000000..bf9f8eaac6
--- /dev/null
+++ b/test/js/node/test/parallel/test-url-format-whatwg.js
@@ -0,0 +1,147 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasIntl)
+  common.skip('missing Intl');
+
+const assert = require('assert');
+const url = require('url');
+
+const myURL = new URL('http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b#c');
+
+assert.strictEqual(
+  url.format(myURL),
+  'http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b#c'
+);
+
+assert.strictEqual(
+  url.format(myURL, {}),
+  'http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b#c'
+);
+
+{
+  [true, 1, 'test', Infinity].forEach((value) => {
+    assert.throws(
+      () => url.format(myURL, value),
+      {
+        code: 'ERR_INVALID_ARG_TYPE',
+        name: 'TypeError',
+        message: 'The "options" argument must be of type object.' +
+                 common.invalidArgTypeHelper(value)
+      }
+    );
+  });
+}
+
+// Any falsy value other than undefined will be treated as false.
+// Any truthy value will be treated as true.
+
+assert.strictEqual(
+  url.format(myURL, { auth: false }),
+  'http://xn--lck1c3crb1723bpq4a.com/a?a=b#c'
+);
+
+assert.strictEqual(
+  url.format(myURL, { auth: '' }),
+  'http://xn--lck1c3crb1723bpq4a.com/a?a=b#c'
+);
+
+assert.strictEqual(
+  url.format(myURL, { auth: 0 }),
+  'http://xn--lck1c3crb1723bpq4a.com/a?a=b#c'
+);
+
+assert.strictEqual(
+  url.format(myURL, { auth: 1 }),
+  'http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b#c'
+);
+
+assert.strictEqual(
+  url.format(myURL, { auth: {} }),
+  'http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b#c'
+);
+
+assert.strictEqual(
+  url.format(myURL, { fragment: false }),
+  'http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b'
+);
+
+assert.strictEqual(
+  url.format(myURL, { fragment: '' }),
+  'http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b'
+);
+
+assert.strictEqual(
+  url.format(myURL, { fragment: 0 }),
+  'http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b'
+);
+
+assert.strictEqual(
+  url.format(myURL, { fragment: 1 }),
+  'http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b#c'
+);
+
+assert.strictEqual(
+  url.format(myURL, { fragment: {} }),
+  'http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b#c'
+);
+
+assert.strictEqual(
+  url.format(myURL, { search: false }),
+  'http://user:pass@xn--lck1c3crb1723bpq4a.com/a#c'
+);
+
+assert.strictEqual(
+  url.format(myURL, { search: '' }),
+  'http://user:pass@xn--lck1c3crb1723bpq4a.com/a#c'
+);
+
+assert.strictEqual(
+  url.format(myURL, { search: 0 }),
+  'http://user:pass@xn--lck1c3crb1723bpq4a.com/a#c'
+);
+
+assert.strictEqual(
+  url.format(myURL, { search: 1 }),
+  'http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b#c'
+);
+
+assert.strictEqual(
+  url.format(myURL, { search: {} }),
+  'http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b#c'
+);
+
+assert.strictEqual(
+  url.format(myURL, { unicode: true }),
+  'http://user:pass@理容ナカムラ.com/a?a=b#c'
+);
+
+assert.strictEqual(
+  url.format(myURL, { unicode: 1 }),
+  'http://user:pass@理容ナカムラ.com/a?a=b#c'
+);
+
+assert.strictEqual(
+  url.format(myURL, { unicode: {} }),
+  'http://user:pass@理容ナカムラ.com/a?a=b#c'
+);
+
+assert.strictEqual(
+  url.format(myURL, { unicode: false }),
+  'http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b#c'
+);
+
+assert.strictEqual(
+  url.format(myURL, { unicode: 0 }),
+  'http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b#c'
+);
+
+assert.strictEqual(
+  url.format(new URL('http://user:pass@xn--0zwm56d.com:8080/path'), { unicode: true }),
+  'http://user:pass@测试.com:8080/path'
+);
+
+assert.strictEqual(
+  url.format(new URL('tel:123')),
+  url.format(new URL('tel:123'), { unicode: true })
+);
diff --git a/test/js/node/test/parallel/test-url-format.js b/test/js/node/test/parallel/test-url-format.js
new file mode 100644
index 0000000000..883d060ac2
--- /dev/null
+++ b/test/js/node/test/parallel/test-url-format.js
@@ -0,0 +1,277 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const url = require('url');
+
+if (!common.hasIntl)
+  common.skip('missing Intl');
+
+// Formatting tests to verify that it'll format slightly wonky content to a
+// valid URL.
+const formatTests = {
+  'http://example.com?': {
+    href: 'http://example.com/?',
+    protocol: 'http:',
+    slashes: true,
+    host: 'example.com',
+    hostname: 'example.com',
+    search: '?',
+    query: {},
+    pathname: '/'
+  },
+  'http://example.com?foo=bar#frag': {
+    href: 'http://example.com/?foo=bar#frag',
+    protocol: 'http:',
+    host: 'example.com',
+    hostname: 'example.com',
+    hash: '#frag',
+    search: '?foo=bar',
+    query: 'foo=bar',
+    pathname: '/'
+  },
+  'http://example.com?foo=@bar#frag': {
+    href: 'http://example.com/?foo=@bar#frag',
+    protocol: 'http:',
+    host: 'example.com',
+    hostname: 'example.com',
+    hash: '#frag',
+    search: '?foo=@bar',
+    query: 'foo=@bar',
+    pathname: '/'
+  },
+  'http://example.com?foo=/bar/#frag': {
+    href: 'http://example.com/?foo=/bar/#frag',
+    protocol: 'http:',
+    host: 'example.com',
+    hostname: 'example.com',
+    hash: '#frag',
+    search: '?foo=/bar/',
+    query: 'foo=/bar/',
+    pathname: '/'
+  },
+  'http://example.com?foo=?bar/#frag': {
+    href: 'http://example.com/?foo=?bar/#frag',
+    protocol: 'http:',
+    host: 'example.com',
+    hostname: 'example.com',
+    hash: '#frag',
+    search: '?foo=?bar/',
+    query: 'foo=?bar/',
+    pathname: '/'
+  },
+  'http://example.com#frag=?bar/#frag': {
+    href: 'http://example.com/#frag=?bar/#frag',
+    protocol: 'http:',
+    host: 'example.com',
+    hostname: 'example.com',
+    hash: '#frag=?bar/#frag',
+    pathname: '/'
+  },
+  'http://google.com" onload="alert(42)/': {
+    href: 'http://google.com/%22%20onload=%22alert(42)/',
+    protocol: 'http:',
+    host: 'google.com',
+    pathname: '/%22%20onload=%22alert(42)/'
+  },
+  'http://a.com/a/b/c?s#h': {
+    href: 'http://a.com/a/b/c?s#h',
+    protocol: 'http',
+    host: 'a.com',
+    pathname: 'a/b/c',
+    hash: 'h',
+    search: 's'
+  },
+  'xmpp:isaacschlueter@jabber.org': {
+    href: 'xmpp:isaacschlueter@jabber.org',
+    protocol: 'xmpp:',
+    host: 'jabber.org',
+    auth: 'isaacschlueter',
+    hostname: 'jabber.org'
+  },
+  'http://atpass:foo%40bar@127.0.0.1/': {
+    href: 'http://atpass:foo%40bar@127.0.0.1/',
+    auth: 'atpass:foo@bar',
+    hostname: '127.0.0.1',
+    protocol: 'http:',
+    pathname: '/'
+  },
+  'http://atslash%2F%40:%2F%40@foo/': {
+    href: 'http://atslash%2F%40:%2F%40@foo/',
+    auth: 'atslash/@:/@',
+    hostname: 'foo',
+    protocol: 'http:',
+    pathname: '/'
+  },
+  'svn+ssh://foo/bar': {
+    href: 'svn+ssh://foo/bar',
+    hostname: 'foo',
+    protocol: 'svn+ssh:',
+    pathname: '/bar',
+    slashes: true
+  },
+  'dash-test://foo/bar': {
+    href: 'dash-test://foo/bar',
+    hostname: 'foo',
+    protocol: 'dash-test:',
+    pathname: '/bar',
+    slashes: true
+  },
+  'dash-test:foo/bar': {
+    href: 'dash-test:foo/bar',
+    hostname: 'foo',
+    protocol: 'dash-test:',
+    pathname: '/bar'
+  },
+  'dot.test://foo/bar': {
+    href: 'dot.test://foo/bar',
+    hostname: 'foo',
+    protocol: 'dot.test:',
+    pathname: '/bar',
+    slashes: true
+  },
+  'dot.test:foo/bar': {
+    href: 'dot.test:foo/bar',
+    hostname: 'foo',
+    protocol: 'dot.test:',
+    pathname: '/bar'
+  },
+  // IPv6 support
+  'coap:u:p@[::1]:61616/.well-known/r?n=Temperature': {
+    href: 'coap:u:p@[::1]:61616/.well-known/r?n=Temperature',
+    protocol: 'coap:',
+    auth: 'u:p',
+    hostname: '::1',
+    port: '61616',
+    pathname: '/.well-known/r',
+    search: 'n=Temperature'
+  },
+  'coap:[fedc:ba98:7654:3210:fedc:ba98:7654:3210]:61616/s/stopButton': {
+    href: 'coap:[fedc:ba98:7654:3210:fedc:ba98:7654:3210]:61616/s/stopButton',
+    protocol: 'coap',
+    host: '[fedc:ba98:7654:3210:fedc:ba98:7654:3210]:61616',
+    pathname: '/s/stopButton'
+  },
+  'http://[::]/': {
+    href: 'http://[::]/',
+    protocol: 'http:',
+    hostname: '[::]',
+    pathname: '/'
+  },
+
+  // Encode context-specific delimiters in path and query, but do not touch
+  // other non-delimiter chars like `%`.
+  // <https://github.com/nodejs/node-v0.x-archive/issues/4082>
+
+  // `#`,`?` in path
+  '/path/to/%%23%3F+=&.txt?foo=theA1#bar': {
+    href: '/path/to/%%23%3F+=&.txt?foo=theA1#bar',
+    pathname: '/path/to/%#?+=&.txt',
+    query: {
+      foo: 'theA1'
+    },
+    hash: '#bar'
+  },
+
+  // `#`,`?` in path + `#` in query
+  '/path/to/%%23%3F+=&.txt?foo=the%231#bar': {
+    href: '/path/to/%%23%3F+=&.txt?foo=the%231#bar',
+    pathname: '/path/to/%#?+=&.txt',
+    query: {
+      foo: 'the#1'
+    },
+    hash: '#bar'
+  },
+
+  // `#` in path end + `#` in query
+  '/path/to/%%23?foo=the%231#bar': {
+    href: '/path/to/%%23?foo=the%231#bar',
+    pathname: '/path/to/%#',
+    query: {
+      foo: 'the#1'
+    },
+    hash: '#bar'
+  },
+
+  // `?` and `#` in path and search
+  'http://ex.com/foo%3F100%m%23r?abc=the%231?&foo=bar#frag': {
+    href: 'http://ex.com/foo%3F100%m%23r?abc=the%231?&foo=bar#frag',
+    protocol: 'http:',
+    hostname: 'ex.com',
+    hash: '#frag',
+    search: '?abc=the#1?&foo=bar',
+    pathname: '/foo?100%m#r',
+  },
+
+  // `?` and `#` in search only
+  'http://ex.com/fooA100%mBr?abc=the%231?&foo=bar#frag': {
+    href: 'http://ex.com/fooA100%mBr?abc=the%231?&foo=bar#frag',
+    protocol: 'http:',
+    hostname: 'ex.com',
+    hash: '#frag',
+    search: '?abc=the#1?&foo=bar',
+    pathname: '/fooA100%mBr',
+  },
+
+  // Multiple `#` in search
+  'http://example.com/?foo=bar%231%232%233&abc=%234%23%235#frag': {
+    href: 'http://example.com/?foo=bar%231%232%233&abc=%234%23%235#frag',
+    protocol: 'http:',
+    slashes: true,
+    host: 'example.com',
+    hostname: 'example.com',
+    hash: '#frag',
+    search: '?foo=bar#1#2#3&abc=#4##5',
+    query: {},
+    pathname: '/'
+  },
+
+  // More than 255 characters in hostname which exceeds the limit
+  [`http://${'a'.repeat(255)}.com/node`]: {
+    href: 'http:///node',
+    protocol: 'http:',
+    slashes: true,
+    host: '',
+    hostname: '',
+    pathname: '/node',
+    path: '/node'
+  },
+
+  // Greater than or equal to 63 characters after `.` in hostname
+  [`http://www.${'z'.repeat(63)}example.com/node`]: {
+    href: `http://www.${'z'.repeat(63)}example.com/node`,
+    protocol: 'http:',
+    slashes: true,
+    host: `www.${'z'.repeat(63)}example.com`,
+    hostname: `www.${'z'.repeat(63)}example.com`,
+    pathname: '/node',
+    path: '/node'
+  },
+
+  // https://github.com/nodejs/node/issues/3361
+  'file:///home/user': {
+    href: 'file:///home/user',
+    protocol: 'file',
+    pathname: '/home/user',
+    path: '/home/user'
+  },
+
+  // surrogate in auth
+  'http://%F0%9F%98%80@www.example.com/': {
+    href: 'http://%F0%9F%98%80@www.example.com/',
+    protocol: 'http:',
+    auth: '\uD83D\uDE00',
+    hostname: 'www.example.com',
+    pathname: '/'
+  }
+};
+for (const u in formatTests) {
+  const expect = formatTests[u].href;
+  delete formatTests[u].href;
+  const actual = url.format(u);
+  const actualObj = url.format(formatTests[u]);
+  assert.strictEqual(actual, expect,
+                     `wonky format(${u}) == ${expect}\nactual:${actual}`);
+  assert.strictEqual(actualObj, expect,
+                     `wonky format(${JSON.stringify(formatTests[u])}) == ${
+                       expect}\nactual: ${actualObj}`);
+}
diff --git a/test/js/node/test/parallel/test-url-parse-format.js b/test/js/node/test/parallel/test-url-parse-format.js
new file mode 100644
index 0000000000..f8761514a3
--- /dev/null
+++ b/test/js/node/test/parallel/test-url-parse-format.js
@@ -0,0 +1,1077 @@
+'use strict';
+const common = require('../common');
+
+if (!common.hasIntl)
+  common.skip('missing Intl');
+
+const assert = require('assert');
+const inspect = require('util').inspect;
+
+const url = require('url');
+
+// URLs to parse, and expected data
+// { url : parsed }
+const parseTests = {
+  '//some_path': {
+    href: '//some_path',
+    pathname: '//some_path',
+    path: '//some_path'
+  },
+
+  'http:\\\\evil-phisher\\foo.html#h\\a\\s\\h': {
+    protocol: 'http:',
+    slashes: true,
+    host: 'evil-phisher',
+    hostname: 'evil-phisher',
+    pathname: '/foo.html',
+    path: '/foo.html',
+    hash: '#h%5Ca%5Cs%5Ch',
+    href: 'http://evil-phisher/foo.html#h%5Ca%5Cs%5Ch'
+  },
+
+  'http:\\\\evil-phisher\\foo.html?json="\\"foo\\""#h\\a\\s\\h': {
+    protocol: 'http:',
+    slashes: true,
+    host: 'evil-phisher',
+    hostname: 'evil-phisher',
+    pathname: '/foo.html',
+    search: '?json=%22%5C%22foo%5C%22%22',
+    query: 'json=%22%5C%22foo%5C%22%22',
+    path: '/foo.html?json=%22%5C%22foo%5C%22%22',
+    hash: '#h%5Ca%5Cs%5Ch',
+    href: 'http://evil-phisher/foo.html?json=%22%5C%22foo%5C%22%22#h%5Ca%5Cs%5Ch'
+  },
+
+  'http:\\\\evil-phisher\\foo.html#h\\a\\s\\h?blarg': {
+    protocol: 'http:',
+    slashes: true,
+    host: 'evil-phisher',
+    hostname: 'evil-phisher',
+    pathname: '/foo.html',
+    path: '/foo.html',
+    hash: '#h%5Ca%5Cs%5Ch?blarg',
+    href: 'http://evil-phisher/foo.html#h%5Ca%5Cs%5Ch?blarg'
+  },
+
+
+  'http:\\\\evil-phisher\\foo.html': {
+    protocol: 'http:',
+    slashes: true,
+    host: 'evil-phisher',
+    hostname: 'evil-phisher',
+    pathname: '/foo.html',
+    path: '/foo.html',
+    href: 'http://evil-phisher/foo.html'
+  },
+
+  'HTTP://www.example.com/': {
+    href: 'http://www.example.com/',
+    protocol: 'http:',
+    slashes: true,
+    host: 'www.example.com',
+    hostname: 'www.example.com',
+    pathname: '/',
+    path: '/'
+  },
+
+  'HTTP://www.example.com': {
+    href: 'http://www.example.com/',
+    protocol: 'http:',
+    slashes: true,
+    host: 'www.example.com',
+    hostname: 'www.example.com',
+    pathname: '/',
+    path: '/'
+  },
+
+  'http://www.ExAmPlE.com/': {
+    href: 'http://www.example.com/',
+    protocol: 'http:',
+    slashes: true,
+    host: 'www.example.com',
+    hostname: 'www.example.com',
+    pathname: '/',
+    path: '/'
+  },
+
+  'http://user:pw@www.ExAmPlE.com/': {
+    href: 'http://user:pw@www.example.com/',
+    protocol: 'http:',
+    slashes: true,
+    auth: 'user:pw',
+    host: 'www.example.com',
+    hostname: 'www.example.com',
+    pathname: '/',
+    path: '/'
+  },
+
+  'http://USER:PW@www.ExAmPlE.com/': {
+    href: 'http://USER:PW@www.example.com/',
+    protocol: 'http:',
+    slashes: true,
+    auth: 'USER:PW',
+    host: 'www.example.com',
+    hostname: 'www.example.com',
+    pathname: '/',
+    path: '/'
+  },
+
+  'http://user@www.example.com/': {
+    href: 'http://user@www.example.com/',
+    protocol: 'http:',
+    slashes: true,
+    auth: 'user',
+    host: 'www.example.com',
+    hostname: 'www.example.com',
+    pathname: '/',
+    path: '/'
+  },
+
+  'http://user%3Apw@www.example.com/': {
+    href: 'http://user:pw@www.example.com/',
+    protocol: 'http:',
+    slashes: true,
+    auth: 'user:pw',
+    host: 'www.example.com',
+    hostname: 'www.example.com',
+    pathname: '/',
+    path: '/'
+  },
+
+  'http://x.com/path?that\'s#all, folks': {
+    href: 'http://x.com/path?that%27s#all,%20folks',
+    protocol: 'http:',
+    slashes: true,
+    host: 'x.com',
+    hostname: 'x.com',
+    search: '?that%27s',
+    query: 'that%27s',
+    pathname: '/path',
+    hash: '#all,%20folks',
+    path: '/path?that%27s'
+  },
+
+  'HTTP://X.COM/Y': {
+    href: 'http://x.com/Y',
+    protocol: 'http:',
+    slashes: true,
+    host: 'x.com',
+    hostname: 'x.com',
+    pathname: '/Y',
+    path: '/Y'
+  },
+
+  // Whitespace in the front
+  ' http://www.example.com/': {
+    href: 'http://www.example.com/',
+    protocol: 'http:',
+    slashes: true,
+    host: 'www.example.com',
+    hostname: 'www.example.com',
+    pathname: '/',
+    path: '/'
+  },
+
+  // + not an invalid host character
+  // per https://url.spec.whatwg.org/#host-parsing
+  'http://x.y.com+a/b/c': {
+    href: 'http://x.y.com+a/b/c',
+    protocol: 'http:',
+    slashes: true,
+    host: 'x.y.com+a',
+    hostname: 'x.y.com+a',
+    pathname: '/b/c',
+    path: '/b/c'
+  },
+
+  // An unexpected invalid char in the hostname.
+  'HtTp://x.y.cOm;a/b/c?d=e#f g<h>i': {
+    href: 'http://x.y.com/;a/b/c?d=e#f%20g%3Ch%3Ei',
+    protocol: 'http:',
+    slashes: true,
+    host: 'x.y.com',
+    hostname: 'x.y.com',
+    pathname: ';a/b/c',
+    search: '?d=e',
+    query: 'd=e',
+    hash: '#f%20g%3Ch%3Ei',
+    path: ';a/b/c?d=e'
+  },
+
+  // Make sure that we don't accidentally lcast the path parts.
+  'HtTp://x.y.cOm;A/b/c?d=e#f g<h>i': {
+    href: 'http://x.y.com/;A/b/c?d=e#f%20g%3Ch%3Ei',
+    protocol: 'http:',
+    slashes: true,
+    host: 'x.y.com',
+    hostname: 'x.y.com',
+    pathname: ';A/b/c',
+    search: '?d=e',
+    query: 'd=e',
+    hash: '#f%20g%3Ch%3Ei',
+    path: ';A/b/c?d=e'
+  },
+
+  'http://x...y...#p': {
+    href: 'http://x...y.../#p',
+    protocol: 'http:',
+    slashes: true,
+    host: 'x...y...',
+    hostname: 'x...y...',
+    hash: '#p',
+    pathname: '/',
+    path: '/'
+  },
+
+  'http://x/p/"quoted"': {
+    href: 'http://x/p/%22quoted%22',
+    protocol: 'http:',
+    slashes: true,
+    host: 'x',
+    hostname: 'x',
+    pathname: '/p/%22quoted%22',
+    path: '/p/%22quoted%22'
+  },
+
+  '<http://goo.corn/bread> Is a URL!': {
+    href: '%3Chttp://goo.corn/bread%3E%20Is%20a%20URL!',
+    pathname: '%3Chttp://goo.corn/bread%3E%20Is%20a%20URL!',
+    path: '%3Chttp://goo.corn/bread%3E%20Is%20a%20URL!'
+  },
+
+  'http://www.narwhaljs.org/blog/categories?id=news': {
+    href: 'http://www.narwhaljs.org/blog/categories?id=news',
+    protocol: 'http:',
+    slashes: true,
+    host: 'www.narwhaljs.org',
+    hostname: 'www.narwhaljs.org',
+    search: '?id=news',
+    query: 'id=news',
+    pathname: '/blog/categories',
+    path: '/blog/categories?id=news'
+  },
+
+  'http://mt0.google.com/vt/lyrs=m@114&hl=en&src=api&x=2&y=2&z=3&s=': {
+    href: 'http://mt0.google.com/vt/lyrs=m@114&hl=en&src=api&x=2&y=2&z=3&s=',
+    protocol: 'http:',
+    slashes: true,
+    host: 'mt0.google.com',
+    hostname: 'mt0.google.com',
+    pathname: '/vt/lyrs=m@114&hl=en&src=api&x=2&y=2&z=3&s=',
+    path: '/vt/lyrs=m@114&hl=en&src=api&x=2&y=2&z=3&s='
+  },
+
+  'http://mt0.google.com/vt/lyrs=m@114???&hl=en&src=api&x=2&y=2&z=3&s=': {
+    href: 'http://mt0.google.com/vt/lyrs=m@114???&hl=en&src=api' +
+          '&x=2&y=2&z=3&s=',
+    protocol: 'http:',
+    slashes: true,
+    host: 'mt0.google.com',
+    hostname: 'mt0.google.com',
+    search: '???&hl=en&src=api&x=2&y=2&z=3&s=',
+    query: '??&hl=en&src=api&x=2&y=2&z=3&s=',
+    pathname: '/vt/lyrs=m@114',
+    path: '/vt/lyrs=m@114???&hl=en&src=api&x=2&y=2&z=3&s='
+  },
+
+  'http://user:pass@mt0.google.com/vt/lyrs=m@114???&hl=en&src=api&x=2&y=2&z=3&s=': {
+    href: 'http://user:pass@mt0.google.com/vt/lyrs=m@114???&hl=en&src=api&x=2&y=2&z=3&s=',
+    protocol: 'http:',
+    slashes: true,
+    host: 'mt0.google.com',
+    auth: 'user:pass',
+    hostname: 'mt0.google.com',
+    search: '???&hl=en&src=api&x=2&y=2&z=3&s=',
+    query: '??&hl=en&src=api&x=2&y=2&z=3&s=',
+    pathname: '/vt/lyrs=m@114',
+    path: '/vt/lyrs=m@114???&hl=en&src=api&x=2&y=2&z=3&s='
+  },
+
+  'file:///etc/passwd': {
+    href: 'file:///etc/passwd',
+    slashes: true,
+    protocol: 'file:',
+    pathname: '/etc/passwd',
+    hostname: '',
+    host: '',
+    path: '/etc/passwd'
+  },
+
+  'file://localhost/etc/passwd': {
+    href: 'file://localhost/etc/passwd',
+    protocol: 'file:',
+    slashes: true,
+    pathname: '/etc/passwd',
+    hostname: 'localhost',
+    host: 'localhost',
+    path: '/etc/passwd'
+  },
+
+  'file://foo/etc/passwd': {
+    href: 'file://foo/etc/passwd',
+    protocol: 'file:',
+    slashes: true,
+    pathname: '/etc/passwd',
+    hostname: 'foo',
+    host: 'foo',
+    path: '/etc/passwd'
+  },
+
+  'file:///etc/node/': {
+    href: 'file:///etc/node/',
+    slashes: true,
+    protocol: 'file:',
+    pathname: '/etc/node/',
+    hostname: '',
+    host: '',
+    path: '/etc/node/'
+  },
+
+  'file://localhost/etc/node/': {
+    href: 'file://localhost/etc/node/',
+    protocol: 'file:',
+    slashes: true,
+    pathname: '/etc/node/',
+    hostname: 'localhost',
+    host: 'localhost',
+    path: '/etc/node/'
+  },
+
+  'file://foo/etc/node/': {
+    href: 'file://foo/etc/node/',
+    protocol: 'file:',
+    slashes: true,
+    pathname: '/etc/node/',
+    hostname: 'foo',
+    host: 'foo',
+    path: '/etc/node/'
+  },
+
+  'http:/baz/../foo/bar': {
+    href: 'http:/baz/../foo/bar',
+    protocol: 'http:',
+    pathname: '/baz/../foo/bar',
+    path: '/baz/../foo/bar'
+  },
+
+  'http://user:pass@example.com:8000/foo/bar?baz=quux#frag': {
+    href: 'http://user:pass@example.com:8000/foo/bar?baz=quux#frag',
+    protocol: 'http:',
+    slashes: true,
+    host: 'example.com:8000',
+    auth: 'user:pass',
+    port: '8000',
+    hostname: 'example.com',
+    hash: '#frag',
+    search: '?baz=quux',
+    query: 'baz=quux',
+    pathname: '/foo/bar',
+    path: '/foo/bar?baz=quux'
+  },
+
+  '//user:pass@example.com:8000/foo/bar?baz=quux#frag': {
+    href: '//user:pass@example.com:8000/foo/bar?baz=quux#frag',
+    slashes: true,
+    host: 'example.com:8000',
+    auth: 'user:pass',
+    port: '8000',
+    hostname: 'example.com',
+    hash: '#frag',
+    search: '?baz=quux',
+    query: 'baz=quux',
+    pathname: '/foo/bar',
+    path: '/foo/bar?baz=quux'
+  },
+
+  '/foo/bar?baz=quux#frag': {
+    href: '/foo/bar?baz=quux#frag',
+    hash: '#frag',
+    search: '?baz=quux',
+    query: 'baz=quux',
+    pathname: '/foo/bar',
+    path: '/foo/bar?baz=quux'
+  },
+
+  'http:/foo/bar?baz=quux#frag': {
+    href: 'http:/foo/bar?baz=quux#frag',
+    protocol: 'http:',
+    hash: '#frag',
+    search: '?baz=quux',
+    query: 'baz=quux',
+    pathname: '/foo/bar',
+    path: '/foo/bar?baz=quux'
+  },
+
+  'mailto:foo@bar.com?subject=hello': {
+    href: 'mailto:foo@bar.com?subject=hello',
+    protocol: 'mailto:',
+    host: 'bar.com',
+    auth: 'foo',
+    hostname: 'bar.com',
+    search: '?subject=hello',
+    query: 'subject=hello',
+    path: '?subject=hello'
+  },
+
+  'javascript:alert(\'hello\');': {
+    href: 'javascript:alert(\'hello\');',
+    protocol: 'javascript:',
+    pathname: 'alert(\'hello\');',
+    path: 'alert(\'hello\');'
+  },
+
+  'xmpp:isaacschlueter@jabber.org': {
+    href: 'xmpp:isaacschlueter@jabber.org',
+    protocol: 'xmpp:',
+    host: 'jabber.org',
+    auth: 'isaacschlueter',
+    hostname: 'jabber.org'
+  },
+
+  'http://atpass:foo%40bar@127.0.0.1:8080/path?search=foo#bar': {
+    href: 'http://atpass:foo%40bar@127.0.0.1:8080/path?search=foo#bar',
+    protocol: 'http:',
+    slashes: true,
+    host: '127.0.0.1:8080',
+    auth: 'atpass:foo@bar',
+    hostname: '127.0.0.1',
+    port: '8080',
+    pathname: '/path',
+    search: '?search=foo',
+    query: 'search=foo',
+    hash: '#bar',
+    path: '/path?search=foo'
+  },
+
+  'svn+ssh://foo/bar': {
+    href: 'svn+ssh://foo/bar',
+    host: 'foo',
+    hostname: 'foo',
+    protocol: 'svn+ssh:',
+    pathname: '/bar',
+    path: '/bar',
+    slashes: true
+  },
+
+  'dash-test://foo/bar': {
+    href: 'dash-test://foo/bar',
+    host: 'foo',
+    hostname: 'foo',
+    protocol: 'dash-test:',
+    pathname: '/bar',
+    path: '/bar',
+    slashes: true
+  },
+
+  'dash-test:foo/bar': {
+    href: 'dash-test:foo/bar',
+    host: 'foo',
+    hostname: 'foo',
+    protocol: 'dash-test:',
+    pathname: '/bar',
+    path: '/bar'
+  },
+
+  'dot.test://foo/bar': {
+    href: 'dot.test://foo/bar',
+    host: 'foo',
+    hostname: 'foo',
+    protocol: 'dot.test:',
+    pathname: '/bar',
+    path: '/bar',
+    slashes: true
+  },
+
+  'dot.test:foo/bar': {
+    href: 'dot.test:foo/bar',
+    host: 'foo',
+    hostname: 'foo',
+    protocol: 'dot.test:',
+    pathname: '/bar',
+    path: '/bar'
+  },
+
+  // IDNA tests
+  'http://www.日本語.com/': {
+    href: 'http://www.xn--wgv71a119e.com/',
+    protocol: 'http:',
+    slashes: true,
+    host: 'www.xn--wgv71a119e.com',
+    hostname: 'www.xn--wgv71a119e.com',
+    pathname: '/',
+    path: '/'
+  },
+
+  'http://example.Bücher.com/': {
+    href: 'http://example.xn--bcher-kva.com/',
+    protocol: 'http:',
+    slashes: true,
+    host: 'example.xn--bcher-kva.com',
+    hostname: 'example.xn--bcher-kva.com',
+    pathname: '/',
+    path: '/'
+  },
+
+  'http://www.Äffchen.com/': {
+    href: 'http://www.xn--ffchen-9ta.com/',
+    protocol: 'http:',
+    slashes: true,
+    host: 'www.xn--ffchen-9ta.com',
+    hostname: 'www.xn--ffchen-9ta.com',
+    pathname: '/',
+    path: '/'
+  },
+
+  'http://www.Äffchen.cOm;A/b/c?d=e#f g<h>i': {
+    href: 'http://www.xn--ffchen-9ta.com/;A/b/c?d=e#f%20g%3Ch%3Ei',
+    protocol: 'http:',
+    slashes: true,
+    host: 'www.xn--ffchen-9ta.com',
+    hostname: 'www.xn--ffchen-9ta.com',
+    pathname: ';A/b/c',
+    search: '?d=e',
+    query: 'd=e',
+    hash: '#f%20g%3Ch%3Ei',
+    path: ';A/b/c?d=e'
+  },
+
+  'http://SÉLIER.COM/': {
+    href: 'http://xn--slier-bsa.com/',
+    protocol: 'http:',
+    slashes: true,
+    host: 'xn--slier-bsa.com',
+    hostname: 'xn--slier-bsa.com',
+    pathname: '/',
+    path: '/'
+  },
+
+  'http://ليهمابتكلموشعربي؟.ي؟/': {
+    href: 'http://xn--egbpdaj6bu4bxfgehfvwxn.xn--egb9f/',
+    protocol: 'http:',
+    slashes: true,
+    host: 'xn--egbpdaj6bu4bxfgehfvwxn.xn--egb9f',
+    hostname: 'xn--egbpdaj6bu4bxfgehfvwxn.xn--egb9f',
+    pathname: '/',
+    path: '/'
+  },
+
+  'http://➡.ws/➡': {
+    href: 'http://xn--hgi.ws/➡',
+    protocol: 'http:',
+    slashes: true,
+    host: 'xn--hgi.ws',
+    hostname: 'xn--hgi.ws',
+    pathname: '/➡',
+    path: '/➡'
+  },
+
+  'http://bucket_name.s3.amazonaws.com/image.jpg': {
+    protocol: 'http:',
+    slashes: true,
+    host: 'bucket_name.s3.amazonaws.com',
+    hostname: 'bucket_name.s3.amazonaws.com',
+    pathname: '/image.jpg',
+    href: 'http://bucket_name.s3.amazonaws.com/image.jpg',
+    path: '/image.jpg'
+  },
+
+  'git+http://github.com/joyent/node.git': {
+    protocol: 'git+http:',
+    slashes: true,
+    host: 'github.com',
+    hostname: 'github.com',
+    pathname: '/joyent/node.git',
+    path: '/joyent/node.git',
+    href: 'git+http://github.com/joyent/node.git'
+  },
+
+  // If local1@domain1 is uses as a relative URL it may
+  // be parse into auth@hostname, but here there is no
+  // way to make it work in url.parse, I add the test to be explicit
+  'local1@domain1': {
+    pathname: 'local1@domain1',
+    path: 'local1@domain1',
+    href: 'local1@domain1'
+  },
+
+  // While this may seem counter-intuitive, a browser will parse
+  // <a href='www.google.com'> as a path.
+  'www.example.com': {
+    href: 'www.example.com',
+    pathname: 'www.example.com',
+    path: 'www.example.com'
+  },
+
+  // ipv6 support
+  '[fe80::1]': {
+    href: '[fe80::1]',
+    pathname: '[fe80::1]',
+    path: '[fe80::1]'
+  },
+
+  'coap://[FEDC:BA98:7654:3210:FEDC:BA98:7654:3210]': {
+    protocol: 'coap:',
+    slashes: true,
+    host: '[fedc:ba98:7654:3210:fedc:ba98:7654:3210]',
+    hostname: 'fedc:ba98:7654:3210:fedc:ba98:7654:3210',
+    href: 'coap://[fedc:ba98:7654:3210:fedc:ba98:7654:3210]/',
+    pathname: '/',
+    path: '/'
+  },
+
+  'coap://[1080:0:0:0:8:800:200C:417A]:61616/': {
+    protocol: 'coap:',
+    slashes: true,
+    host: '[1080:0:0:0:8:800:200c:417a]:61616',
+    port: '61616',
+    hostname: '1080:0:0:0:8:800:200c:417a',
+    href: 'coap://[1080:0:0:0:8:800:200c:417a]:61616/',
+    pathname: '/',
+    path: '/'
+  },
+
+  'http://user:password@[3ffe:2a00:100:7031::1]:8080': {
+    protocol: 'http:',
+    slashes: true,
+    auth: 'user:password',
+    host: '[3ffe:2a00:100:7031::1]:8080',
+    port: '8080',
+    hostname: '3ffe:2a00:100:7031::1',
+    href: 'http://user:password@[3ffe:2a00:100:7031::1]:8080/',
+    pathname: '/',
+    path: '/'
+  },
+
+  'coap://u:p@[::192.9.5.5]:61616/.well-known/r?n=Temperature': {
+    protocol: 'coap:',
+    slashes: true,
+    auth: 'u:p',
+    host: '[::192.9.5.5]:61616',
+    port: '61616',
+    hostname: '::192.9.5.5',
+    href: 'coap://u:p@[::192.9.5.5]:61616/.well-known/r?n=Temperature',
+    search: '?n=Temperature',
+    query: 'n=Temperature',
+    pathname: '/.well-known/r',
+    path: '/.well-known/r?n=Temperature'
+  },
+
+  // empty port
+  'http://example.com:': {
+    protocol: 'http:',
+    slashes: true,
+    host: 'example.com',
+    hostname: 'example.com',
+    href: 'http://example.com/',
+    pathname: '/',
+    path: '/'
+  },
+
+  'http://example.com:/a/b.html': {
+    protocol: 'http:',
+    slashes: true,
+    host: 'example.com',
+    hostname: 'example.com',
+    href: 'http://example.com/a/b.html',
+    pathname: '/a/b.html',
+    path: '/a/b.html'
+  },
+
+  'http://example.com:?a=b': {
+    protocol: 'http:',
+    slashes: true,
+    host: 'example.com',
+    hostname: 'example.com',
+    href: 'http://example.com/?a=b',
+    search: '?a=b',
+    query: 'a=b',
+    pathname: '/',
+    path: '/?a=b'
+  },
+
+  'http://example.com:#abc': {
+    protocol: 'http:',
+    slashes: true,
+    host: 'example.com',
+    hostname: 'example.com',
+    href: 'http://example.com/#abc',
+    hash: '#abc',
+    pathname: '/',
+    path: '/'
+  },
+
+  'http://[fe80::1]:/a/b?a=b#abc': {
+    protocol: 'http:',
+    slashes: true,
+    host: '[fe80::1]',
+    hostname: 'fe80::1',
+    href: 'http://[fe80::1]/a/b?a=b#abc',
+    search: '?a=b',
+    query: 'a=b',
+    hash: '#abc',
+    pathname: '/a/b',
+    path: '/a/b?a=b'
+  },
+
+  'http://-lovemonsterz.tumblr.com/rss': {
+    protocol: 'http:',
+    slashes: true,
+    host: '-lovemonsterz.tumblr.com',
+    hostname: '-lovemonsterz.tumblr.com',
+    href: 'http://-lovemonsterz.tumblr.com/rss',
+    pathname: '/rss',
+    path: '/rss',
+  },
+
+  'http://-lovemonsterz.tumblr.com:80/rss': {
+    protocol: 'http:',
+    slashes: true,
+    port: '80',
+    host: '-lovemonsterz.tumblr.com:80',
+    hostname: '-lovemonsterz.tumblr.com',
+    href: 'http://-lovemonsterz.tumblr.com:80/rss',
+    pathname: '/rss',
+    path: '/rss',
+  },
+
+  'http://user:pass@-lovemonsterz.tumblr.com/rss': {
+    protocol: 'http:',
+    slashes: true,
+    auth: 'user:pass',
+    host: '-lovemonsterz.tumblr.com',
+    hostname: '-lovemonsterz.tumblr.com',
+    href: 'http://user:pass@-lovemonsterz.tumblr.com/rss',
+    pathname: '/rss',
+    path: '/rss',
+  },
+
+  'http://user:pass@-lovemonsterz.tumblr.com:80/rss': {
+    protocol: 'http:',
+    slashes: true,
+    auth: 'user:pass',
+    port: '80',
+    host: '-lovemonsterz.tumblr.com:80',
+    hostname: '-lovemonsterz.tumblr.com',
+    href: 'http://user:pass@-lovemonsterz.tumblr.com:80/rss',
+    pathname: '/rss',
+    path: '/rss',
+  },
+
+  'http://_jabber._tcp.google.com/test': {
+    protocol: 'http:',
+    slashes: true,
+    host: '_jabber._tcp.google.com',
+    hostname: '_jabber._tcp.google.com',
+    href: 'http://_jabber._tcp.google.com/test',
+    pathname: '/test',
+    path: '/test',
+  },
+
+  'http://user:pass@_jabber._tcp.google.com/test': {
+    protocol: 'http:',
+    slashes: true,
+    auth: 'user:pass',
+    host: '_jabber._tcp.google.com',
+    hostname: '_jabber._tcp.google.com',
+    href: 'http://user:pass@_jabber._tcp.google.com/test',
+    pathname: '/test',
+    path: '/test',
+  },
+
+  'http://_jabber._tcp.google.com:80/test': {
+    protocol: 'http:',
+    slashes: true,
+    port: '80',
+    host: '_jabber._tcp.google.com:80',
+    hostname: '_jabber._tcp.google.com',
+    href: 'http://_jabber._tcp.google.com:80/test',
+    pathname: '/test',
+    path: '/test',
+  },
+
+  'http://user:pass@_jabber._tcp.google.com:80/test': {
+    protocol: 'http:',
+    slashes: true,
+    auth: 'user:pass',
+    port: '80',
+    host: '_jabber._tcp.google.com:80',
+    hostname: '_jabber._tcp.google.com',
+    href: 'http://user:pass@_jabber._tcp.google.com:80/test',
+    pathname: '/test',
+    path: '/test',
+  },
+
+  'http://x:1/\' <>"`/{}|\\^~`/': {
+    protocol: 'http:',
+    slashes: true,
+    host: 'x:1',
+    port: '1',
+    hostname: 'x',
+    pathname: '/%27%20%3C%3E%22%60/%7B%7D%7C/%5E~%60/',
+    path: '/%27%20%3C%3E%22%60/%7B%7D%7C/%5E~%60/',
+    href: 'http://x:1/%27%20%3C%3E%22%60/%7B%7D%7C/%5E~%60/'
+  },
+
+  'http://a@b@c/': {
+    protocol: 'http:',
+    slashes: true,
+    auth: 'a@b',
+    host: 'c',
+    hostname: 'c',
+    href: 'http://a%40b@c/',
+    path: '/',
+    pathname: '/'
+  },
+
+  'http://a@b?@c': {
+    protocol: 'http:',
+    slashes: true,
+    auth: 'a',
+    host: 'b',
+    hostname: 'b',
+    href: 'http://a@b/?@c',
+    path: '/?@c',
+    pathname: '/',
+    search: '?@c',
+    query: '@c'
+  },
+
+  'http://a.b/\tbc\ndr\ref g"hq\'j<kl>?mn\\op^q=r`99{st|uv}wz': {
+    protocol: 'http:',
+    slashes: true,
+    host: 'a.b',
+    port: null,
+    hostname: 'a.b',
+    hash: null,
+    pathname: '/%09bc%0Adr%0Def%20g%22hq%27j%3Ckl%3E',
+    path: '/%09bc%0Adr%0Def%20g%22hq%27j%3Ckl%3E?mn%5Cop%5Eq=r%6099%7Bst%7Cuv%7Dwz',
+    search: '?mn%5Cop%5Eq=r%6099%7Bst%7Cuv%7Dwz',
+    query: 'mn%5Cop%5Eq=r%6099%7Bst%7Cuv%7Dwz',
+    href: 'http://a.b/%09bc%0Adr%0Def%20g%22hq%27j%3Ckl%3E?mn%5Cop%5Eq=r%6099%7Bst%7Cuv%7Dwz'
+  },
+
+  'http://a\r" \t\n<\'b:b@c\r\nd/e?f': {
+    protocol: 'http:',
+    slashes: true,
+    auth: 'a" <\'b:b',
+    host: 'cd',
+    port: null,
+    hostname: 'cd',
+    hash: null,
+    search: '?f',
+    query: 'f',
+    pathname: '/e',
+    path: '/e?f',
+    href: 'http://a%22%20%3C\'b:b@cd/e?f'
+  },
+
+  // Git urls used by npm
+  'git+ssh://git@github.com:npm/npm': {
+    protocol: 'git+ssh:',
+    slashes: true,
+    auth: 'git',
+    host: 'github.com',
+    port: null,
+    hostname: 'github.com',
+    hash: null,
+    search: null,
+    query: null,
+    pathname: '/:npm/npm',
+    path: '/:npm/npm',
+    href: 'git+ssh://git@github.com/:npm/npm'
+  },
+
+  'https://*': {
+    protocol: 'https:',
+    slashes: true,
+    auth: null,
+    host: '*',
+    port: null,
+    hostname: '*',
+    hash: null,
+    search: null,
+    query: null,
+    pathname: '/',
+    path: '/',
+    href: 'https://*/'
+  },
+
+  // The following two URLs are the same, but they differ for a capital A.
+  // Verify that the protocol is checked in a case-insensitive manner.
+  'javascript:alert(1);a=\x27@white-listed.com\x27': {
+    protocol: 'javascript:',
+    slashes: null,
+    auth: null,
+    host: null,
+    port: null,
+    hostname: null,
+    hash: null,
+    search: null,
+    query: null,
+    pathname: "alert(1);a='@white-listed.com'",
+    path: "alert(1);a='@white-listed.com'",
+    href: "javascript:alert(1);a='@white-listed.com'"
+  },
+
+  'javAscript:alert(1);a=\x27@white-listed.com\x27': {
+    protocol: 'javascript:',
+    slashes: null,
+    auth: null,
+    host: null,
+    port: null,
+    hostname: null,
+    hash: null,
+    search: null,
+    query: null,
+    pathname: "alert(1);a='@white-listed.com'",
+    path: "alert(1);a='@white-listed.com'",
+    href: "javascript:alert(1);a='@white-listed.com'"
+  },
+
+  'ws://www.example.com': {
+    protocol: 'ws:',
+    slashes: true,
+    hostname: 'www.example.com',
+    host: 'www.example.com',
+    pathname: '/',
+    path: '/',
+    href: 'ws://www.example.com/'
+  },
+
+  'wss://www.example.com': {
+    protocol: 'wss:',
+    slashes: true,
+    hostname: 'www.example.com',
+    host: 'www.example.com',
+    pathname: '/',
+    path: '/',
+    href: 'wss://www.example.com/'
+  },
+
+  '//fhqwhgads@example.com/everybody-to-the-limit': {
+    protocol: null,
+    slashes: true,
+    auth: 'fhqwhgads',
+    host: 'example.com',
+    port: null,
+    hostname: 'example.com',
+    hash: null,
+    search: null,
+    query: null,
+    pathname: '/everybody-to-the-limit',
+    path: '/everybody-to-the-limit',
+    href: '//fhqwhgads@example.com/everybody-to-the-limit'
+  },
+
+  '//fhqwhgads@example.com/everybody#to-the-limit': {
+    protocol: null,
+    slashes: true,
+    auth: 'fhqwhgads',
+    host: 'example.com',
+    port: null,
+    hostname: 'example.com',
+    hash: '#to-the-limit',
+    search: null,
+    query: null,
+    pathname: '/everybody',
+    path: '/everybody',
+    href: '//fhqwhgads@example.com/everybody#to-the-limit'
+  },
+
+  '\bhttp://example.com/\b': {
+    protocol: 'http:',
+    slashes: true,
+    auth: null,
+    host: 'example.com',
+    port: null,
+    hostname: 'example.com',
+    hash: null,
+    search: null,
+    query: null,
+    pathname: '/',
+    path: '/',
+    href: 'http://example.com/'
+  },
+
+  'https://evil.com$.example.com': {
+    protocol: 'https:',
+    slashes: true,
+    auth: null,
+    host: 'evil.com$.example.com',
+    port: null,
+    hostname: 'evil.com$.example.com',
+    hash: null,
+    search: null,
+    query: null,
+    pathname: '/',
+    path: '/',
+    href: 'https://evil.com$.example.com/'
+  },
+
+  // Validate the output of hostname with commas.
+  'x://0.0,1.1/': {
+    protocol: 'x:',
+    slashes: true,
+    auth: null,
+    host: '0.0,1.1',
+    port: null,
+    hostname: '0.0,1.1',
+    hash: null,
+    search: null,
+    query: null,
+    pathname: '/',
+    path: '/',
+    href: 'x://0.0,1.1/'
+  }
+};
+
+for (const u in parseTests) {
+  let actual = url.parse(u);
+  const spaced = url.parse(`     \t  ${u}\n\t`);
+  let expected = Object.assign(new url.Url(), parseTests[u]);
+
+  Object.keys(actual).forEach(function(i) {
+    if (expected[i] === undefined && actual[i] === null) {
+      expected[i] = null;
+    }
+  });
+
+  assert.deepStrictEqual(
+    actual,
+    expected,
+    `parsing ${u} and expected ${inspect(expected)} but got ${inspect(actual)}`
+  );
+  assert.deepStrictEqual(
+    spaced,
+    expected,
+    `expected ${inspect(expected)}, got ${inspect(spaced)}`
+  );
+
+  expected = parseTests[u].href;
+  actual = url.format(parseTests[u]);
+
+  assert.strictEqual(actual, expected,
+                     `format(${u}) == ${u}\nactual:${actual}`);
+}
+
+{
+  const parsed = url.parse('http://nodejs.org/')
+    .resolveObject('jAvascript:alert(1);a=\x27@white-listed.com\x27');
+
+  const expected = Object.assign(new url.Url(), {
+    protocol: 'javascript:',
+    slashes: null,
+    auth: null,
+    host: null,
+    port: null,
+    hostname: null,
+    hash: null,
+    search: null,
+    query: null,
+    pathname: "alert(1);a='@white-listed.com'",
+    path: "alert(1);a='@white-listed.com'",
+    href: "javascript:alert(1);a='@white-listed.com'"
+  });
+
+  assert.deepStrictEqual(parsed, expected);
+}
diff --git a/test/js/node/test/parallel/test-url-revokeobjecturl.js b/test/js/node/test/parallel/test-url-revokeobjecturl.js
new file mode 100644
index 0000000000..dae980c4d0
--- /dev/null
+++ b/test/js/node/test/parallel/test-url-revokeobjecturl.js
@@ -0,0 +1,14 @@
+'use strict';
+
+require('../common');
+
+// Test ensures that the function receives the url argument.
+
+const assert = require('node:assert');
+
+assert.throws(() => {
+  URL.revokeObjectURL();
+}, {
+  code: 'ERR_MISSING_ARGS',
+  name: 'TypeError',
+});
diff --git a/test/js/node/test/parallel/test-url-urltooptions.js b/test/js/node/test/parallel/test-url-urltooptions.js
new file mode 100644
index 0000000000..cc4838eeec
--- /dev/null
+++ b/test/js/node/test/parallel/test-url-urltooptions.js
@@ -0,0 +1,37 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const { urlToHttpOptions } = require('url');
+
+// Test urlToHttpOptions
+const urlObj = new URL('http://user:pass@foo.bar.com:21/aaa/zzz?l=24#test');
+const opts = urlToHttpOptions(urlObj);
+assert.strictEqual(opts instanceof URL, false);
+assert.strictEqual(opts.protocol, 'http:');
+assert.strictEqual(opts.auth, 'user:pass');
+assert.strictEqual(opts.hostname, 'foo.bar.com');
+assert.strictEqual(opts.port, 21);
+assert.strictEqual(opts.path, '/aaa/zzz?l=24');
+assert.strictEqual(opts.pathname, '/aaa/zzz');
+assert.strictEqual(opts.search, '?l=24');
+assert.strictEqual(opts.hash, '#test');
+
+const { hostname } = urlToHttpOptions(new URL('http://[::1]:21'));
+assert.strictEqual(hostname, '::1');
+
+// If a WHATWG URL object is copied, it is possible that the resulting copy
+// contains the Symbols that Node uses for brand checking, but not the data
+// properties, which are getters. Verify that urlToHttpOptions() can handle
+// such a case.
+const copiedUrlObj = { ...urlObj };
+const copiedOpts = urlToHttpOptions(copiedUrlObj);
+assert.strictEqual(copiedOpts instanceof URL, false);
+assert.strictEqual(copiedOpts.protocol, undefined);
+assert.strictEqual(copiedOpts.auth, undefined);
+assert.strictEqual(copiedOpts.hostname, undefined);
+assert.strictEqual(copiedOpts.port, NaN);
+assert.strictEqual(copiedOpts.path, '');
+assert.strictEqual(copiedOpts.pathname, undefined);
+assert.strictEqual(copiedOpts.search, undefined);
+assert.strictEqual(copiedOpts.hash, undefined);
+assert.strictEqual(copiedOpts.href, undefined);
diff --git a/test/js/node/test/parallel/test-utf8-scripts.js b/test/js/node/test/parallel/test-utf8-scripts.js
new file mode 100644
index 0000000000..4bf5b0cd5b
--- /dev/null
+++ b/test/js/node/test/parallel/test-utf8-scripts.js
@@ -0,0 +1,30 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+
+// üäö
+
+console.log('Σὲ γνωρίζω ἀπὸ τὴν κόψη');
+
+assert.match('Hellö Wörld', /Hellö Wörld/);
diff --git a/test/js/node/test/parallel/test-util-inspect-getters-accessing-this.js b/test/js/node/test/parallel/test-util-inspect-getters-accessing-this.js
new file mode 100644
index 0000000000..998cd82db8
--- /dev/null
+++ b/test/js/node/test/parallel/test-util-inspect-getters-accessing-this.js
@@ -0,0 +1,67 @@
+'use strict';
+
+require('../common');
+
+// This test ensures that util.inspect logs getters
+// which access this.
+
+const assert = require('assert');
+
+const { inspect } = require('util');
+
+{
+  class X {
+    constructor() {
+      this._y = 123;
+    }
+
+    get y() {
+      return this._y;
+    }
+  }
+
+  const result = inspect(new X(), {
+    getters: true,
+    showHidden: true
+  });
+
+  assert.strictEqual(
+    result,
+    'X { _y: 123, [y]: [Getter: 123] }'
+  );
+}
+
+// Regression test for https://github.com/nodejs/node/issues/37054
+{
+  class A {
+    constructor(B) {
+      this.B = B;
+    }
+    get b() {
+      return this.B;
+    }
+  }
+
+  class B {
+    constructor() {
+      this.A = new A(this);
+    }
+    get a() {
+      return this.A;
+    }
+  }
+
+  const result = inspect(new B(), {
+    depth: 1,
+    getters: true,
+    showHidden: true
+  });
+
+  assert.strictEqual(
+    result,
+    '<ref *1> B {\n' +
+    '  A: A { B: [Circular *1], [b]: [Getter] [Circular *1] },\n' +
+    '  [a]: [Getter] A { B: [Circular *1], [b]: [Getter] [Circular *1] }\n' +
+    '}',
+  );
+}
diff --git a/test/js/node/test/parallel/test-util-primordial-monkeypatching.js b/test/js/node/test/parallel/test-util-primordial-monkeypatching.js
new file mode 100644
index 0000000000..bf282a1212
--- /dev/null
+++ b/test/js/node/test/parallel/test-util-primordial-monkeypatching.js
@@ -0,0 +1,11 @@
+'use strict';
+
+// Monkeypatch Object.keys() so that it throws an unexpected error. This tests
+// that `util.inspect()` is unaffected by monkey-patching `Object`.
+
+require('../common');
+const assert = require('assert');
+const util = require('util');
+
+Object.keys = () => { throw new Error('fhqwhgads'); };
+assert.strictEqual(util.inspect({}), '{}');
diff --git a/test/js/node/test/parallel/test-v8-deserialize-buffer.js b/test/js/node/test/parallel/test-v8-deserialize-buffer.js
new file mode 100644
index 0000000000..f05631a72a
--- /dev/null
+++ b/test/js/node/test/parallel/test-v8-deserialize-buffer.js
@@ -0,0 +1,7 @@
+'use strict';
+
+const common = require('../common');
+const v8 = require('v8');
+
+process.on('warning', common.mustNotCall());
+v8.deserialize(v8.serialize(Buffer.alloc(0)));
diff --git a/test/js/node/test/parallel/test-v8-global-setter.js b/test/js/node/test/parallel/test-v8-global-setter.js
new file mode 100644
index 0000000000..1cb0898e61
--- /dev/null
+++ b/test/js/node/test/parallel/test-v8-global-setter.js
@@ -0,0 +1,29 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+
+// This test ensures v8 correctly sets a property on the global object if it
+// has a setter interceptor in strict mode.
+// https://github.com/nodejs/node-v0.x-archive/issues/6235
+
+require('vm').runInNewContext('"use strict"; var v = 1; v = 2');
diff --git a/test/js/node/test/parallel/test-vm-access-process-env.js b/test/js/node/test/parallel/test-vm-access-process-env.js
new file mode 100644
index 0000000000..c6b18ec902
--- /dev/null
+++ b/test/js/node/test/parallel/test-vm-access-process-env.js
@@ -0,0 +1,33 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+// Tests that node does neither crash nor throw an error when accessing
+// process.env when inside a VM context.
+// See https://github.com/nodejs/node-v0.x-archive/issues/7511.
+
+require('../common');
+const assert = require('assert');
+const vm = require('vm');
+
+const context = vm.createContext({ process });
+const result = vm.runInContext('process.env["PATH"]', context);
+assert.notStrictEqual(undefined, result);
diff --git a/test/js/node/test/parallel/test-vm-attributes-property-not-on-sandbox.js b/test/js/node/test/parallel/test-vm-attributes-property-not-on-sandbox.js
new file mode 100644
index 0000000000..313dd71e47
--- /dev/null
+++ b/test/js/node/test/parallel/test-vm-attributes-property-not-on-sandbox.js
@@ -0,0 +1,18 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const vm = require('vm');
+
+// Assert that accessor descriptors are not flattened on the sandbox.
+// Issue: https://github.com/nodejs/node/issues/2734
+const sandbox = {};
+vm.createContext(sandbox);
+const code = `Object.defineProperty(
+               this,
+               'foo',
+               { get: function() {return 17} }
+             );
+             var desc = Object.getOwnPropertyDescriptor(this, 'foo');`;
+
+vm.runInContext(code, sandbox);
+assert.strictEqual(typeof sandbox.desc.get, 'function');
diff --git a/test/js/node/test/parallel/test-vm-context-async-script.js b/test/js/node/test/parallel/test-vm-context-async-script.js
new file mode 100644
index 0000000000..879315e37b
--- /dev/null
+++ b/test/js/node/test/parallel/test-vm-context-async-script.js
@@ -0,0 +1,35 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const vm = require('vm');
+
+const sandbox = { setTimeout };
+
+const ctx = vm.createContext(sandbox);
+
+vm.runInContext('setTimeout(function() { x = 3; }, 0);', ctx);
+setTimeout(common.mustCall(() => {
+  assert.strictEqual(sandbox.x, 3);
+  assert.strictEqual(ctx.x, 3);
+}), 1);
diff --git a/test/js/node/test/parallel/test-vm-context-property-forwarding.js b/test/js/node/test/parallel/test-vm-context-property-forwarding.js
new file mode 100644
index 0000000000..53d38c1467
--- /dev/null
+++ b/test/js/node/test/parallel/test-vm-context-property-forwarding.js
@@ -0,0 +1,65 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const vm = require('vm');
+
+const sandbox = { x: 3 };
+
+const ctx = vm.createContext(sandbox);
+
+assert.strictEqual(vm.runInContext('x;', ctx), 3);
+vm.runInContext('y = 4;', ctx);
+assert.strictEqual(sandbox.y, 4);
+assert.strictEqual(ctx.y, 4);
+
+// Test `IndexedPropertyGetterCallback` and `IndexedPropertyDeleterCallback`
+const x = { get 1() { return 5; } };
+const pd_expected = Object.getOwnPropertyDescriptor(x, 1);
+const ctx2 = vm.createContext(x);
+const pd_actual = Object.getOwnPropertyDescriptor(ctx2, 1);
+
+assert.deepStrictEqual(pd_actual, pd_expected);
+assert.strictEqual(ctx2[1], 5);
+delete ctx2[1];
+assert.strictEqual(ctx2[1], undefined);
+
+// https://github.com/nodejs/node/issues/33806
+{
+  const ctx = vm.createContext();
+
+  Object.defineProperty(ctx, 'prop', {
+    get() {
+      return undefined;
+    },
+    set(val) {
+      throw new Error('test error');
+    },
+  });
+
+  assert.throws(() => {
+    vm.runInContext('prop = 42', ctx);
+  }, {
+    message: 'test error',
+  });
+}
diff --git a/test/js/node/test/parallel/test-vm-create-context-accessors.js b/test/js/node/test/parallel/test-vm-create-context-accessors.js
new file mode 100644
index 0000000000..39fc5c4eec
--- /dev/null
+++ b/test/js/node/test/parallel/test-vm-create-context-accessors.js
@@ -0,0 +1,49 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const vm = require('vm');
+
+let ctx = {};
+
+Object.defineProperty(ctx, 'getter', {
+  get: function() {
+    return 'ok';
+  }
+});
+
+let val;
+Object.defineProperty(ctx, 'setter', {
+  set: function(_val) {
+    val = _val;
+  },
+  get: function() {
+    return `ok=${val}`;
+  }
+});
+
+ctx = vm.createContext(ctx);
+
+const result = vm.runInContext('setter = "test";[getter,setter]', ctx);
+assert.strictEqual(result[0], 'ok');
+assert.strictEqual(result[1], 'ok=test');
diff --git a/test/js/node/test/parallel/test-vm-create-context-circular-reference.js b/test/js/node/test/parallel/test-vm-create-context-circular-reference.js
new file mode 100644
index 0000000000..7ea22781bd
--- /dev/null
+++ b/test/js/node/test/parallel/test-vm-create-context-circular-reference.js
@@ -0,0 +1,34 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const vm = require('vm');
+
+let sbx = {};
+sbx.window = sbx;
+
+sbx = vm.createContext(sbx);
+
+sbx.test = 123;
+
+assert.strictEqual(sbx.window.window.window.window.window.test, 123);
diff --git a/test/js/node/test/parallel/test-vm-cross-context.js b/test/js/node/test/parallel/test-vm-cross-context.js
new file mode 100644
index 0000000000..b7cf1309d3
--- /dev/null
+++ b/test/js/node/test/parallel/test-vm-cross-context.js
@@ -0,0 +1,29 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+
+const vm = require('vm');
+const ctx = vm.createContext(global);
+
+// Should not throw.
+vm.runInContext('!function() { var x = console.log; }()', ctx);
diff --git a/test/js/node/test/parallel/test-vm-data-property-writable.js b/test/js/node/test/parallel/test-vm-data-property-writable.js
new file mode 100644
index 0000000000..00937ae412
--- /dev/null
+++ b/test/js/node/test/parallel/test-vm-data-property-writable.js
@@ -0,0 +1,28 @@
+'use strict';
+// Refs: https://github.com/nodejs/node/issues/10223
+
+require('../common');
+const vm = require('vm');
+const assert = require('assert');
+
+const context = vm.createContext({});
+
+let code = `
+   Object.defineProperty(this, 'foo', {value: 5});
+   Object.getOwnPropertyDescriptor(this, 'foo');
+`;
+
+let desc = vm.runInContext(code, context);
+
+assert.strictEqual(desc.writable, false);
+
+// Check that interceptors work for symbols.
+code = `
+   const bar = Symbol('bar');
+   Object.defineProperty(this, bar, {value: 6});
+   Object.getOwnPropertyDescriptor(this, bar);
+`;
+
+desc = vm.runInContext(code, context);
+
+assert.strictEqual(desc.value, 6);
diff --git a/test/js/node/test/parallel/test-vm-deleting-property.js b/test/js/node/test/parallel/test-vm-deleting-property.js
new file mode 100644
index 0000000000..994aa0aff9
--- /dev/null
+++ b/test/js/node/test/parallel/test-vm-deleting-property.js
@@ -0,0 +1,15 @@
+'use strict';
+// Refs: https://github.com/nodejs/node/issues/6287
+
+require('../common');
+const assert = require('assert');
+const vm = require('vm');
+
+const context = vm.createContext();
+const res = vm.runInContext(`
+  this.x = 'prop';
+  delete this.x;
+  Object.getOwnPropertyDescriptor(this, 'x');
+`, context);
+
+assert.strictEqual(res, undefined);
diff --git a/test/js/node/test/parallel/test-vm-function-declaration.js b/test/js/node/test/parallel/test-vm-function-declaration.js
new file mode 100644
index 0000000000..766e5ec78b
--- /dev/null
+++ b/test/js/node/test/parallel/test-vm-function-declaration.js
@@ -0,0 +1,49 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+
+const vm = require('vm');
+const o = vm.createContext({ console });
+
+// Function declaration and expression should both be copied to the
+// sandboxed context.
+let code = 'let a = function() {};\n';
+code += 'function b(){}\n';
+code += 'var c = function() {};\n';
+code += 'var d = () => {};\n';
+code += 'let e = () => {};\n';
+
+// Grab the global b function as the completion value, to ensure that
+// we are getting the global function, and not some other thing
+code += '(function(){return this})().b;\n';
+
+const res = vm.runInContext(code, o, 'test');
+assert.strictEqual(typeof res, 'function');
+assert.strictEqual(res.name, 'b');
+assert.strictEqual(typeof o.a, 'undefined');
+assert.strictEqual(typeof o.b, 'function');
+assert.strictEqual(typeof o.c, 'function');
+assert.strictEqual(typeof o.d, 'function');
+assert.strictEqual(typeof o.e, 'undefined');
+assert.strictEqual(res, o.b);
diff --git a/test/js/node/test/parallel/test-vm-function-redefinition.js b/test/js/node/test/parallel/test-vm-function-redefinition.js
new file mode 100644
index 0000000000..fa1ddde389
--- /dev/null
+++ b/test/js/node/test/parallel/test-vm-function-redefinition.js
@@ -0,0 +1,11 @@
+'use strict';
+// Refs: https://github.com/nodejs/node/issues/548
+require('../common');
+const assert = require('assert');
+const vm = require('vm');
+const context = vm.createContext();
+
+vm.runInContext('function test() { return 0; }', context);
+vm.runInContext('function test() { return 1; }', context);
+const result = vm.runInContext('test()', context);
+assert.strictEqual(result, 1);
diff --git a/test/js/node/test/parallel/test-vm-global-assignment.js b/test/js/node/test/parallel/test-vm-global-assignment.js
new file mode 100644
index 0000000000..3fb3470b4c
--- /dev/null
+++ b/test/js/node/test/parallel/test-vm-global-assignment.js
@@ -0,0 +1,15 @@
+'use strict';
+// Regression test for https://github.com/nodejs/node/issues/10806
+
+require('../common');
+const assert = require('assert');
+const vm = require('vm');
+const ctx = vm.createContext({ open() { } });
+const window = vm.runInContext('this', ctx);
+const other = 123;
+
+assert.notStrictEqual(window.open, other);
+window.open = other;
+assert.strictEqual(window.open, other);
+window.open = other;
+assert.strictEqual(window.open, other);
diff --git a/test/js/node/test/parallel/test-vm-global-configurable-properties.js b/test/js/node/test/parallel/test-vm-global-configurable-properties.js
new file mode 100644
index 0000000000..4428e747ea
--- /dev/null
+++ b/test/js/node/test/parallel/test-vm-global-configurable-properties.js
@@ -0,0 +1,15 @@
+'use strict';
+// https://github.com/nodejs/node/issues/47799
+
+require('../common');
+const assert = require('assert');
+const vm = require('vm');
+
+const ctx = vm.createContext();
+
+const window = vm.runInContext('this', ctx);
+
+Object.defineProperty(window, 'x', { value: '1', configurable: true });
+assert.strictEqual(window.x, '1');
+Object.defineProperty(window, 'x', { value: '2', configurable: true });
+assert.strictEqual(window.x, '2');
diff --git a/test/js/node/test/parallel/test-vm-global-get-own.js b/test/js/node/test/parallel/test-vm-global-get-own.js
new file mode 100644
index 0000000000..246fcbf866
--- /dev/null
+++ b/test/js/node/test/parallel/test-vm-global-get-own.js
@@ -0,0 +1,105 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const vm = require('vm');
+
+// These assertions check that we can set new keys to the global context,
+// get them back and also list them via getOwnProperty* or in.
+//
+// Related to:
+// - https://github.com/nodejs/node/issues/45983
+
+const global = vm.runInContext('this', vm.createContext());
+
+function runAssertions(data, property, viaDefine, value1, value2, value3) {
+  // Define the property for the first time
+  setPropertyAndAssert(data, property, viaDefine, value1);
+  // Update the property
+  setPropertyAndAssert(data, property, viaDefine, value2);
+  // Delete the property
+  deletePropertyAndAssert(data, property);
+  // Re-define the property
+  setPropertyAndAssert(data, property, viaDefine, value3);
+  // Delete the property again
+  deletePropertyAndAssert(data, property);
+}
+
+const fun1 = () => 1;
+const fun2 = () => 2;
+const fun3 = () => 3;
+
+function runAssertionsOnSandbox(builder) {
+  const sandboxContext = vm.createContext({ runAssertions, fun1, fun2, fun3 });
+  vm.runInContext(builder('this'), sandboxContext);
+  vm.runInContext(builder('{}'), sandboxContext);
+}
+
+// Assertions on: define property
+runAssertions(global, 'toto', true, 1, 2, 3);
+runAssertions(global, Symbol.for('toto'), true, 1, 2, 3);
+runAssertions(global, 'tutu', true, fun1, fun2, fun3);
+runAssertions(global, Symbol.for('tutu'), true, fun1, fun2, fun3);
+runAssertions(global, 'tyty', true, fun1, 2, 3);
+runAssertions(global, Symbol.for('tyty'), true, fun1, 2, 3);
+
+// Assertions on: direct assignment
+runAssertions(global, 'titi', false, 1, 2, 3);
+runAssertions(global, Symbol.for('titi'), false, 1, 2, 3);
+runAssertions(global, 'tata', false, fun1, fun2, fun3);
+runAssertions(global, Symbol.for('tata'), false, fun1, fun2, fun3);
+runAssertions(global, 'tztz', false, fun1, 2, 3);
+runAssertions(global, Symbol.for('tztz'), false, fun1, 2, 3);
+
+// Assertions on: define property from sandbox
+runAssertionsOnSandbox(
+  (variable) => `
+    runAssertions(${variable}, 'toto', true, 1, 2, 3);
+    runAssertions(${variable}, Symbol.for('toto'), true, 1, 2, 3);
+    runAssertions(${variable}, 'tutu', true, fun1, fun2, fun3);
+    runAssertions(${variable}, Symbol.for('tutu'), true, fun1, fun2, fun3);
+    runAssertions(${variable}, 'tyty', true, fun1, 2, 3);
+    runAssertions(${variable}, Symbol.for('tyty'), true, fun1, 2, 3);`
+);
+
+// Assertions on: direct assignment from sandbox
+runAssertionsOnSandbox(
+  (variable) => `
+    runAssertions(${variable}, 'titi', false, 1, 2, 3);
+    runAssertions(${variable}, Symbol.for('titi'), false, 1, 2, 3);
+    runAssertions(${variable}, 'tata', false, fun1, fun2, fun3);
+    runAssertions(${variable}, Symbol.for('tata'), false, fun1, fun2, fun3);
+    runAssertions(${variable}, 'tztz', false, fun1, 2, 3);
+    runAssertions(${variable}, Symbol.for('tztz'), false, fun1, 2, 3);`
+);
+
+// Helpers
+
+// Set the property on data and assert it worked
+function setPropertyAndAssert(data, property, viaDefine, value) {
+  if (viaDefine) {
+    Object.defineProperty(data, property, {
+      enumerable: true,
+      writable: true,
+      value: value,
+      configurable: true,
+    });
+  } else {
+    data[property] = value;
+  }
+  assert.strictEqual(data[property], value);
+  assert.ok(property in data);
+  if (typeof property === 'string') {
+    assert.ok(Object.getOwnPropertyNames(data).includes(property));
+  } else {
+    assert.ok(Object.getOwnPropertySymbols(data).includes(property));
+  }
+}
+
+// Delete the property from data and assert it worked
+function deletePropertyAndAssert(data, property) {
+  delete data[property];
+  assert.strictEqual(data[property], undefined);
+  assert.ok(!(property in data));
+  assert.ok(!Object.getOwnPropertyNames(data).includes(property));
+  assert.ok(!Object.getOwnPropertySymbols(data).includes(property));
+}
diff --git a/test/js/node/test/parallel/test-vm-harmony-symbols.js b/test/js/node/test/parallel/test-vm-harmony-symbols.js
new file mode 100644
index 0000000000..5936025070
--- /dev/null
+++ b/test/js/node/test/parallel/test-vm-harmony-symbols.js
@@ -0,0 +1,37 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const vm = require('vm');
+
+// The sandbox should have its own Symbol constructor.
+let sandbox = {};
+vm.runInNewContext('this.Symbol = Symbol', sandbox);
+assert.strictEqual(typeof sandbox.Symbol, 'function');
+assert.notStrictEqual(sandbox.Symbol, Symbol);
+
+// Unless we copy the Symbol constructor explicitly, of course.
+sandbox = { Symbol };
+vm.runInNewContext('this.Symbol = Symbol', sandbox);
+assert.strictEqual(typeof sandbox.Symbol, 'function');
+assert.strictEqual(sandbox.Symbol, Symbol);
diff --git a/test/js/node/test/parallel/test-vm-indexed-properties.js b/test/js/node/test/parallel/test-vm-indexed-properties.js
new file mode 100644
index 0000000000..34ef8d020b
--- /dev/null
+++ b/test/js/node/test/parallel/test-vm-indexed-properties.js
@@ -0,0 +1,17 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const vm = require('vm');
+
+const code = `Object.defineProperty(this, 99, {
+      value: 20,
+      enumerable: true
+ });`;
+
+
+const sandbox = {};
+const ctx = vm.createContext(sandbox);
+vm.runInContext(code, ctx);
+
+assert.strictEqual(sandbox[99], 20);
diff --git a/test/js/node/test/parallel/test-vm-low-stack-space.js b/test/js/node/test/parallel/test-vm-low-stack-space.js
new file mode 100644
index 0000000000..6a49a983d5
--- /dev/null
+++ b/test/js/node/test/parallel/test-vm-low-stack-space.js
@@ -0,0 +1,26 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const vm = require('vm');
+
+function a() {
+  try {
+    return a();
+  } catch {
+    // Throw an exception as near to the recursion-based RangeError as possible.
+    return vm.runInThisContext('() => 42')();
+  }
+}
+
+assert.strictEqual(a(), 42);
+
+function b() {
+  try {
+    return b();
+  } catch {
+    // This writes a lot of noise to stderr, but it still works.
+    return vm.runInNewContext('() => 42')();
+  }
+}
+
+assert.strictEqual(b(), 42);
diff --git a/test/js/node/test/parallel/test-vm-new-script-this-context.js b/test/js/node/test/parallel/test-vm-new-script-this-context.js
new file mode 100644
index 0000000000..18f39f9086
--- /dev/null
+++ b/test/js/node/test/parallel/test-vm-new-script-this-context.js
@@ -0,0 +1,68 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const Script = require('vm').Script;
+
+// Run a string
+let script = new Script('\'passed\';');
+const result = script.runInThisContext(script);
+assert.strictEqual(result, 'passed');
+
+// Thrown error
+script = new Script('throw new Error(\'test\');');
+assert.throws(() => {
+  script.runInThisContext(script);
+}, /^Error: test$/);
+
+global.hello = 5;
+script = new Script('hello = 2');
+script.runInThisContext(script);
+assert.strictEqual(global.hello, 2);
+
+
+// Pass values
+global.code = 'foo = 1;' +
+              'bar = 2;' +
+              'if (typeof baz !== "undefined") throw new Error("test fail");';
+global.foo = 2;
+global.obj = { foo: 0, baz: 3 };
+script = new Script(global.code);
+script.runInThisContext(script);
+assert.strictEqual(global.obj.foo, 0);
+assert.strictEqual(global.bar, 2);
+assert.strictEqual(global.foo, 1);
+
+// Call a function
+global.f = function() { global.foo = 100; };
+script = new Script('f()');
+script.runInThisContext(script);
+assert.strictEqual(global.foo, 100);
+
+common.allowGlobals(
+  global.hello,
+  global.code,
+  global.foo,
+  global.obj,
+  global.f
+);
diff --git a/test/js/node/test/parallel/test-vm-parse-abort-on-uncaught-exception.js b/test/js/node/test/parallel/test-vm-parse-abort-on-uncaught-exception.js
new file mode 100644
index 0000000000..64bbb4dd4f
--- /dev/null
+++ b/test/js/node/test/parallel/test-vm-parse-abort-on-uncaught-exception.js
@@ -0,0 +1,18 @@
+// Flags: --abort-on-uncaught-exception
+'use strict';
+require('../common');
+const vm = require('vm');
+
+// Regression test for https://github.com/nodejs/node/issues/13258
+
+try {
+  new vm.Script({ toString() { throw new Error('foo'); } }, {});
+} catch {
+  // Continue regardless of error.
+}
+
+try {
+  new vm.Script('[', {});
+} catch {
+  // Continue regardless of error.
+}
diff --git a/test/js/node/test/parallel/test-vm-proxies.js b/test/js/node/test/parallel/test-vm-proxies.js
new file mode 100644
index 0000000000..405f730577
--- /dev/null
+++ b/test/js/node/test/parallel/test-vm-proxies.js
@@ -0,0 +1,18 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const vm = require('vm');
+
+// src/node_contextify.cc filters out the Proxy object from the parent
+// context.  Make sure that the new context has a Proxy object of its own.
+let sandbox = {};
+vm.runInNewContext('this.Proxy = Proxy', sandbox);
+assert.strictEqual(typeof sandbox.Proxy, 'function');
+assert.notStrictEqual(sandbox.Proxy, Proxy);
+
+// Unless we copy the Proxy object explicitly, of course.
+sandbox = { Proxy };
+vm.runInNewContext('this.Proxy = Proxy', sandbox);
+assert.strictEqual(typeof sandbox.Proxy, 'function');
+assert.strictEqual(sandbox.Proxy, Proxy);
diff --git a/test/js/node/test/parallel/test-vm-proxy-failure-CP.js b/test/js/node/test/parallel/test-vm-proxy-failure-CP.js
new file mode 100644
index 0000000000..93027576d8
--- /dev/null
+++ b/test/js/node/test/parallel/test-vm-proxy-failure-CP.js
@@ -0,0 +1,15 @@
+'use strict';
+require('../common');
+const vm = require('vm');
+
+// Check that we do not accidentally query attributes.
+// Issue: https://github.com/nodejs/node/issues/11902
+const handler = {
+  getOwnPropertyDescriptor: (target, prop) => {
+    throw new Error('whoops');
+  }
+};
+const sandbox = new Proxy({ foo: 'bar' }, handler);
+const context = vm.createContext(sandbox);
+
+vm.runInContext('', context);
diff --git a/test/js/node/test/parallel/test-vm-script-throw-in-tostring.js b/test/js/node/test/parallel/test-vm-script-throw-in-tostring.js
new file mode 100644
index 0000000000..20e7a75079
--- /dev/null
+++ b/test/js/node/test/parallel/test-vm-script-throw-in-tostring.js
@@ -0,0 +1,14 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+
+const vm = require('vm');
+
+assert.throws(() => {
+  new vm.Script({
+    toString() {
+      throw new Error();
+    }
+  });
+}, Error);
diff --git a/test/js/node/test/parallel/test-vm-static-this.js b/test/js/node/test/parallel/test-vm-static-this.js
new file mode 100644
index 0000000000..e9382d6c3b
--- /dev/null
+++ b/test/js/node/test/parallel/test-vm-static-this.js
@@ -0,0 +1,65 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+/* eslint-disable strict */
+const common = require('../common');
+const assert = require('assert');
+const vm = require('vm');
+
+// Run a string
+const result = vm.runInThisContext('\'passed\';');
+assert.strictEqual(result, 'passed');
+
+// thrown error
+assert.throws(function() {
+  vm.runInThisContext('throw new Error(\'test\');');
+}, /test/);
+
+global.hello = 5;
+vm.runInThisContext('hello = 2');
+assert.strictEqual(global.hello, 2);
+
+
+// pass values
+const code = 'foo = 1;' +
+             'bar = 2;' +
+             'if (typeof baz !== \'undefined\')' +
+             'throw new Error(\'test fail\');';
+global.foo = 2;
+global.obj = { foo: 0, baz: 3 };
+/* eslint-disable no-unused-vars */
+const baz = vm.runInThisContext(code);
+/* eslint-enable no-unused-vars */
+assert.strictEqual(global.obj.foo, 0);
+assert.strictEqual(global.bar, 2);
+assert.strictEqual(global.foo, 1);
+
+// call a function
+global.f = function() { global.foo = 100; };
+vm.runInThisContext('f()');
+assert.strictEqual(global.foo, 100);
+
+common.allowGlobals(
+  global.hello,
+  global.foo,
+  global.obj,
+  global.f
+);
diff --git a/test/js/node/test/parallel/test-vm-strict-mode.js b/test/js/node/test/parallel/test-vm-strict-mode.js
new file mode 100644
index 0000000000..b1b233664d
--- /dev/null
+++ b/test/js/node/test/parallel/test-vm-strict-mode.js
@@ -0,0 +1,14 @@
+'use strict';
+// https://github.com/nodejs/node/issues/12300
+
+require('../common');
+const assert = require('assert');
+const vm = require('vm');
+
+const ctx = vm.createContext({ x: 42 });
+
+// This might look as if x has not been declared, but x is defined on the
+// sandbox and the assignment should not throw.
+vm.runInContext('"use strict"; x = 1', ctx);
+
+assert.strictEqual(ctx.x, 1);
diff --git a/test/js/node/test/parallel/test-vm-syntax-error-message.js b/test/js/node/test/parallel/test-vm-syntax-error-message.js
new file mode 100644
index 0000000000..c49ff6aeb1
--- /dev/null
+++ b/test/js/node/test/parallel/test-vm-syntax-error-message.js
@@ -0,0 +1,22 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const child_process = require('child_process');
+
+const p = child_process.spawn(process.execPath, [
+  '-e',
+  'vm = require("vm");' +
+      'context = vm.createContext({});' +
+      'try { vm.runInContext("throw new Error(\'boo\')", context); } ' +
+      'catch (e) { console.log(e.message); }',
+]);
+
+p.stderr.on('data', common.mustNotCall());
+
+let output = '';
+
+p.stdout.on('data', (data) => output += data);
+
+p.stdout.on('end', common.mustCall(() => {
+  assert.strictEqual(output.replace(/[\r\n]+/g, ''), 'boo');
+}));
diff --git a/test/js/node/test/parallel/test-webcrypto-encrypt-decrypt.js b/test/js/node/test/parallel/test-webcrypto-encrypt-decrypt.js
new file mode 100644
index 0000000000..cba193b8c7
--- /dev/null
+++ b/test/js/node/test/parallel/test-webcrypto-encrypt-decrypt.js
@@ -0,0 +1,124 @@
+'use strict';
+
+const common = require('../common');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const { subtle } = globalThis.crypto;
+
+// This is only a partial test. The WebCrypto Web Platform Tests
+// will provide much greater coverage.
+
+// Test Encrypt/Decrypt RSA-OAEP
+{
+  const buf = globalThis.crypto.getRandomValues(new Uint8Array(50));
+
+  async function test() {
+    const ec = new TextEncoder();
+    const { publicKey, privateKey } = await subtle.generateKey({
+      name: 'RSA-OAEP',
+      modulusLength: 2048,
+      publicExponent: new Uint8Array([1, 0, 1]),
+      hash: 'SHA-384',
+    }, true, ['encrypt', 'decrypt']);
+
+    const ciphertext = await subtle.encrypt({
+      name: 'RSA-OAEP',
+      label: ec.encode('a label')
+    }, publicKey, buf);
+
+    const plaintext = await subtle.decrypt({
+      name: 'RSA-OAEP',
+      label: ec.encode('a label')
+    }, privateKey, ciphertext);
+
+    assert.strictEqual(
+      Buffer.from(plaintext).toString('hex'),
+      Buffer.from(buf).toString('hex'));
+  }
+
+  test().then(common.mustCall());
+}
+
+// Test Encrypt/Decrypt AES-CTR
+{
+  const buf = globalThis.crypto.getRandomValues(new Uint8Array(50));
+  const counter = globalThis.crypto.getRandomValues(new Uint8Array(16));
+
+  async function test() {
+    const key = await subtle.generateKey({
+      name: 'AES-CTR',
+      length: 256
+    }, true, ['encrypt', 'decrypt']);
+
+    const ciphertext = await subtle.encrypt(
+      { name: 'AES-CTR', counter, length: 64 }, key, buf,
+    );
+
+    const plaintext = await subtle.decrypt(
+      { name: 'AES-CTR', counter, length: 64 }, key, ciphertext,
+    );
+
+    assert.strictEqual(
+      Buffer.from(plaintext).toString('hex'),
+      Buffer.from(buf).toString('hex'));
+  }
+
+  test().then(common.mustCall());
+}
+
+// Test Encrypt/Decrypt AES-CBC
+{
+  const buf = globalThis.crypto.getRandomValues(new Uint8Array(50));
+  const iv = globalThis.crypto.getRandomValues(new Uint8Array(16));
+
+  async function test() {
+    const key = await subtle.generateKey({
+      name: 'AES-CBC',
+      length: 256
+    }, true, ['encrypt', 'decrypt']);
+
+    const ciphertext = await subtle.encrypt(
+      { name: 'AES-CBC', iv }, key, buf,
+    );
+
+    const plaintext = await subtle.decrypt(
+      { name: 'AES-CBC', iv }, key, ciphertext,
+    );
+
+    assert.strictEqual(
+      Buffer.from(plaintext).toString('hex'),
+      Buffer.from(buf).toString('hex'));
+  }
+
+  test().then(common.mustCall());
+}
+
+// Test Encrypt/Decrypt AES-GCM
+{
+  const buf = globalThis.crypto.getRandomValues(new Uint8Array(50));
+  const iv = globalThis.crypto.getRandomValues(new Uint8Array(12));
+
+  async function test() {
+    const key = await subtle.generateKey({
+      name: 'AES-GCM',
+      length: 256
+    }, true, ['encrypt', 'decrypt']);
+
+    const ciphertext = await subtle.encrypt(
+      { name: 'AES-GCM', iv }, key, buf,
+    );
+
+    const plaintext = await subtle.decrypt(
+      { name: 'AES-GCM', iv }, key, ciphertext,
+    );
+
+    assert.strictEqual(
+      Buffer.from(plaintext).toString('hex'),
+      Buffer.from(buf).toString('hex'));
+  }
+
+  test().then(common.mustCall());
+}
diff --git a/test/js/node/test/parallel/test-webcrypto-getRandomValues.js b/test/js/node/test/parallel/test-webcrypto-getRandomValues.js
new file mode 100644
index 0000000000..f0fbe61a20
--- /dev/null
+++ b/test/js/node/test/parallel/test-webcrypto-getRandomValues.js
@@ -0,0 +1,11 @@
+'use strict';
+
+const common = require('../common');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const { getRandomValues } = globalThis.crypto;
+
+assert.throws(() => getRandomValues(new Uint8Array()), { code: 'ERR_INVALID_THIS' });
diff --git a/test/js/node/test/parallel/test-websocket.js b/test/js/node/test/parallel/test-websocket.js
new file mode 100644
index 0000000000..c595ec12bf
--- /dev/null
+++ b/test/js/node/test/parallel/test-websocket.js
@@ -0,0 +1,6 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+
+assert.strictEqual(typeof WebSocket, 'function');
diff --git a/test/js/node/test/parallel/test-webstream-string-tag.js b/test/js/node/test/parallel/test-webstream-string-tag.js
new file mode 100644
index 0000000000..980a204a9b
--- /dev/null
+++ b/test/js/node/test/parallel/test-webstream-string-tag.js
@@ -0,0 +1,18 @@
+'use strict';
+
+require('../common');
+
+const assert = require('assert');
+
+const classesToBeTested = [ WritableStream, WritableStreamDefaultWriter, WritableStreamDefaultController,
+                            ReadableStream, ReadableStreamBYOBRequest, ReadableStreamDefaultReader,
+                            ReadableStreamBYOBReader, ReadableStreamDefaultController, ReadableByteStreamController,
+                            ByteLengthQueuingStrategy, CountQueuingStrategy, TransformStream,
+                            TransformStreamDefaultController];
+
+
+classesToBeTested.forEach((cls) => {
+  assert.strictEqual(cls.prototype[Symbol.toStringTag], cls.name);
+  assert.deepStrictEqual(Object.getOwnPropertyDescriptor(cls.prototype, Symbol.toStringTag),
+                         { configurable: true, enumerable: false, value: cls.name, writable: false });
+});
diff --git a/test/js/node/test/parallel/test-whatwg-encoding-custom-api-basics.js b/test/js/node/test/parallel/test-whatwg-encoding-custom-api-basics.js
new file mode 100644
index 0000000000..71b573a8df
--- /dev/null
+++ b/test/js/node/test/parallel/test-whatwg-encoding-custom-api-basics.js
@@ -0,0 +1,61 @@
+'use strict';
+
+// From: https://github.com/w3c/web-platform-tests/blob/master/encoding/api-basics.html
+// This is the part that can be run without ICU
+
+require('../common');
+
+const assert = require('assert');
+
+function testDecodeSample(encoding, string, bytes) {
+  assert.strictEqual(
+    new TextDecoder(encoding).decode(new Uint8Array(bytes)),
+    string);
+  assert.strictEqual(
+    new TextDecoder(encoding).decode(new Uint8Array(bytes).buffer),
+    string);
+}
+
+// `z` (ASCII U+007A), cent (Latin-1 U+00A2), CJK water (BMP U+6C34),
+// G-Clef (non-BMP U+1D11E), PUA (BMP U+F8FF), PUA (non-BMP U+10FFFD)
+// byte-swapped BOM (non-character U+FFFE)
+const sample = 'z\xA2\u6C34\uD834\uDD1E\uF8FF\uDBFF\uDFFD\uFFFE';
+
+{
+  const encoding = 'utf-8';
+  const string = sample;
+  const bytes = [
+    0x7A, 0xC2, 0xA2, 0xE6, 0xB0, 0xB4,
+    0xF0, 0x9D, 0x84, 0x9E, 0xEF, 0xA3,
+    0xBF, 0xF4, 0x8F, 0xBF, 0xBD, 0xEF,
+    0xBF, 0xBE,
+  ];
+  const encoded = new TextEncoder().encode(string);
+  assert.deepStrictEqual([].slice.call(encoded), bytes);
+  assert.strictEqual(
+    new TextDecoder(encoding).decode(new Uint8Array(bytes)),
+    string);
+  assert.strictEqual(
+    new TextDecoder(encoding).decode(new Uint8Array(bytes).buffer),
+    string);
+}
+
+testDecodeSample(
+  'utf-16le',
+  sample,
+  [
+    0x7A, 0x00, 0xA2, 0x00, 0x34, 0x6C,
+    0x34, 0xD8, 0x1E, 0xDD, 0xFF, 0xF8,
+    0xFF, 0xDB, 0xFD, 0xDF, 0xFE, 0xFF,
+  ]
+);
+
+testDecodeSample(
+  'utf-16',
+  sample,
+  [
+    0x7A, 0x00, 0xA2, 0x00, 0x34, 0x6C,
+    0x34, 0xD8, 0x1E, 0xDD, 0xFF, 0xF8,
+    0xFF, 0xDB, 0xFD, 0xDF, 0xFE, 0xFF,
+  ]
+);
diff --git a/test/js/node/test/parallel/test-whatwg-encoding-custom-fatal-streaming.js b/test/js/node/test/parallel/test-whatwg-encoding-custom-fatal-streaming.js
new file mode 100644
index 0000000000..164088270c
--- /dev/null
+++ b/test/js/node/test/parallel/test-whatwg-encoding-custom-fatal-streaming.js
@@ -0,0 +1,61 @@
+'use strict';
+
+// From: https://github.com/w3c/web-platform-tests/blob/d74324b53c/encoding/textdecoder-fatal-streaming.html
+// With the twist that we specifically test for Node.js error codes
+
+const common = require('../common');
+const assert = require('assert');
+
+if (!common.hasIntl)
+  common.skip('missing Intl');
+
+{
+  [
+    { encoding: 'utf-8', sequence: [0xC0] },
+    { encoding: 'utf-16le', sequence: [0x00] },
+    { encoding: 'utf-16be', sequence: [0x00] },
+  ].forEach((testCase) => {
+    const data = new Uint8Array([testCase.sequence]);
+    assert.throws(
+      () => {
+        const decoder = new TextDecoder(testCase.encoding, { fatal: true });
+        decoder.decode(data);
+      }, {
+        code: 'ERR_ENCODING_INVALID_ENCODED_DATA',
+        name: 'TypeError',
+        message:
+          `The encoded data was not valid for encoding ${testCase.encoding}`
+      }
+    );
+  });
+}
+
+{
+  const decoder = new TextDecoder('utf-16le', { fatal: true });
+  const odd = new Uint8Array([0x00]);
+  const even = new Uint8Array([0x00, 0x00]);
+
+  assert.throws(
+    () => {
+      decoder.decode(even, { stream: true });
+      decoder.decode(odd);
+    }, {
+      code: 'ERR_ENCODING_INVALID_ENCODED_DATA',
+      name: 'TypeError',
+      message:
+        'The encoded data was not valid for encoding utf-16le'
+    }
+  );
+
+  assert.throws(
+    () => {
+      decoder.decode(odd, { stream: true });
+      decoder.decode(even);
+    }, {
+      code: 'ERR_ENCODING_INVALID_ENCODED_DATA',
+      name: 'TypeError',
+      message:
+        'The encoded data was not valid for encoding utf-16le'
+    }
+  );
+}
diff --git a/test/js/node/test/parallel/test-whatwg-encoding-custom-textdecoder-fatal.js b/test/js/node/test/parallel/test-whatwg-encoding-custom-textdecoder-fatal.js
new file mode 100644
index 0000000000..8778fa018e
--- /dev/null
+++ b/test/js/node/test/parallel/test-whatwg-encoding-custom-textdecoder-fatal.js
@@ -0,0 +1,84 @@
+'use strict';
+
+// From: https://github.com/w3c/web-platform-tests/blob/39a67e2fff/encoding/textdecoder-fatal.html
+// With the twist that we specifically test for Node.js error codes
+
+const common = require('../common');
+
+if (!common.hasIntl)
+  common.skip('missing Intl');
+
+const assert = require('assert');
+
+const bad = [
+  { encoding: 'utf-8', input: [0xFF], name: 'invalid code' },
+  { encoding: 'utf-8', input: [0xC0], name: 'ends early' },
+  { encoding: 'utf-8', input: [0xE0], name: 'ends early 2' },
+  { encoding: 'utf-8', input: [0xC0, 0x00], name: 'invalid trail' },
+  { encoding: 'utf-8', input: [0xC0, 0xC0], name: 'invalid trail 2' },
+  { encoding: 'utf-8', input: [0xE0, 0x00], name: 'invalid trail 3' },
+  { encoding: 'utf-8', input: [0xE0, 0xC0], name: 'invalid trail 4' },
+  { encoding: 'utf-8', input: [0xE0, 0x80, 0x00], name: 'invalid trail 5' },
+  { encoding: 'utf-8', input: [0xE0, 0x80, 0xC0], name: 'invalid trail 6' },
+  { encoding: 'utf-8', input: [0xFC, 0x80, 0x80, 0x80, 0x80, 0x80],
+    name: '> 0x10FFFF' },
+  { encoding: 'utf-8', input: [0xFE, 0x80, 0x80, 0x80, 0x80, 0x80],
+    name: 'obsolete lead byte' },
+  // Overlong encodings
+  { encoding: 'utf-8', input: [0xC0, 0x80], name: 'overlong U+0000 - 2 bytes' },
+  { encoding: 'utf-8', input: [0xE0, 0x80, 0x80],
+    name: 'overlong U+0000 - 3 bytes' },
+  { encoding: 'utf-8', input: [0xF0, 0x80, 0x80, 0x80],
+    name: 'overlong U+0000 - 4 bytes' },
+  { encoding: 'utf-8', input: [0xF8, 0x80, 0x80, 0x80, 0x80],
+    name: 'overlong U+0000 - 5 bytes' },
+  { encoding: 'utf-8', input: [0xFC, 0x80, 0x80, 0x80, 0x80, 0x80],
+    name: 'overlong U+0000 - 6 bytes' },
+  { encoding: 'utf-8', input: [0xC1, 0xBF], name: 'overlong U+007F - 2 bytes' },
+  { encoding: 'utf-8', input: [0xE0, 0x81, 0xBF],
+    name: 'overlong U+007F - 3 bytes' },
+  { encoding: 'utf-8', input: [0xF0, 0x80, 0x81, 0xBF],
+    name: 'overlong U+007F - 4 bytes' },
+  { encoding: 'utf-8', input: [0xF8, 0x80, 0x80, 0x81, 0xBF],
+    name: 'overlong U+007F - 5 bytes' },
+  { encoding: 'utf-8', input: [0xFC, 0x80, 0x80, 0x80, 0x81, 0xBF],
+    name: 'overlong U+007F - 6 bytes' },
+  { encoding: 'utf-8', input: [0xE0, 0x9F, 0xBF],
+    name: 'overlong U+07FF - 3 bytes' },
+  { encoding: 'utf-8', input: [0xF0, 0x80, 0x9F, 0xBF],
+    name: 'overlong U+07FF - 4 bytes' },
+  { encoding: 'utf-8', input: [0xF8, 0x80, 0x80, 0x9F, 0xBF],
+    name: 'overlong U+07FF - 5 bytes' },
+  { encoding: 'utf-8', input: [0xFC, 0x80, 0x80, 0x80, 0x9F, 0xBF],
+    name: 'overlong U+07FF - 6 bytes' },
+  { encoding: 'utf-8', input: [0xF0, 0x8F, 0xBF, 0xBF],
+    name: 'overlong U+FFFF - 4 bytes' },
+  { encoding: 'utf-8', input: [0xF8, 0x80, 0x8F, 0xBF, 0xBF],
+    name: 'overlong U+FFFF - 5 bytes' },
+  { encoding: 'utf-8', input: [0xFC, 0x80, 0x80, 0x8F, 0xBF, 0xBF],
+    name: 'overlong U+FFFF - 6 bytes' },
+  { encoding: 'utf-8', input: [0xF8, 0x84, 0x8F, 0xBF, 0xBF],
+    name: 'overlong U+10FFFF - 5 bytes' },
+  { encoding: 'utf-8', input: [0xFC, 0x80, 0x84, 0x8F, 0xBF, 0xBF],
+    name: 'overlong U+10FFFF - 6 bytes' },
+  // UTF-16 surrogates encoded as code points in UTF-8
+  { encoding: 'utf-8', input: [0xED, 0xA0, 0x80], name: 'lead surrogate' },
+  { encoding: 'utf-8', input: [0xED, 0xB0, 0x80], name: 'trail surrogate' },
+  { encoding: 'utf-8', input: [0xED, 0xA0, 0x80, 0xED, 0xB0, 0x80],
+    name: 'surrogate pair' },
+  { encoding: 'utf-16le', input: [0x00], name: 'truncated code unit' },
+  // Mismatched UTF-16 surrogates are exercised in utf16-surrogates.html
+  // FIXME: Add legacy encoding cases
+];
+
+bad.forEach((t) => {
+  assert.throws(
+    () => {
+      new TextDecoder(t.encoding, { fatal: true })
+        .decode(new Uint8Array(t.input));
+    }, {
+      code: 'ERR_ENCODING_INVALID_ENCODED_DATA',
+      name: 'TypeError'
+    }
+  );
+});
diff --git a/test/js/node/test/parallel/test-whatwg-encoding-custom-textdecoder-ignorebom.js b/test/js/node/test/parallel/test-whatwg-encoding-custom-textdecoder-ignorebom.js
new file mode 100644
index 0000000000..94fc3318d1
--- /dev/null
+++ b/test/js/node/test/parallel/test-whatwg-encoding-custom-textdecoder-ignorebom.js
@@ -0,0 +1,30 @@
+'use strict';
+
+// From: https://github.com/w3c/web-platform-tests/blob/7f567fa29c/encoding/textdecoder-ignorebom.html
+// This is the part that can be run without ICU
+
+require('../common');
+
+const assert = require('assert');
+
+const cases = [
+  {
+    encoding: 'utf-8',
+    bytes: [0xEF, 0xBB, 0xBF, 0x61, 0x62, 0x63]
+  },
+  {
+    encoding: 'utf-16le',
+    bytes: [0xFF, 0xFE, 0x61, 0x00, 0x62, 0x00, 0x63, 0x00]
+  },
+];
+
+cases.forEach((testCase) => {
+  const BOM = '\uFEFF';
+  let decoder = new TextDecoder(testCase.encoding, { ignoreBOM: true });
+  const bytes = new Uint8Array(testCase.bytes);
+  assert.strictEqual(decoder.decode(bytes), `${BOM}abc`);
+  decoder = new TextDecoder(testCase.encoding, { ignoreBOM: false });
+  assert.strictEqual(decoder.decode(bytes), 'abc');
+  decoder = new TextDecoder(testCase.encoding);
+  assert.strictEqual(decoder.decode(bytes), 'abc');
+});
diff --git a/test/js/node/test/parallel/test-whatwg-encoding-custom-textdecoder-invalid-arg.js b/test/js/node/test/parallel/test-whatwg-encoding-custom-textdecoder-invalid-arg.js
new file mode 100644
index 0000000000..5c8a9837f6
--- /dev/null
+++ b/test/js/node/test/parallel/test-whatwg-encoding-custom-textdecoder-invalid-arg.js
@@ -0,0 +1,19 @@
+'use strict';
+
+// This tests that ERR_INVALID_ARG_TYPE are thrown when
+// invalid arguments are passed to TextDecoder.
+
+require('../common');
+const assert = require('assert');
+
+{
+  const notArrayBufferViewExamples = [false, {}, 1, '', new Error()];
+  notArrayBufferViewExamples.forEach((invalidInputType) => {
+    assert.throws(() => {
+      new TextDecoder(undefined, null).decode(invalidInputType);
+    }, {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError'
+    });
+  });
+}
diff --git a/test/js/node/test/parallel/test-whatwg-encoding-custom-textdecoder-streaming.js b/test/js/node/test/parallel/test-whatwg-encoding-custom-textdecoder-streaming.js
new file mode 100644
index 0000000000..5484929326
--- /dev/null
+++ b/test/js/node/test/parallel/test-whatwg-encoding-custom-textdecoder-streaming.js
@@ -0,0 +1,38 @@
+'use strict';
+
+// From: https://github.com/w3c/web-platform-tests/blob/fa9436d12c/encoding/textdecoder-streaming.html
+// This is the part that can be run without ICU
+
+require('../common');
+
+const assert = require('assert');
+
+const string =
+  '\x00123ABCabc\x80\xFF\u0100\u1000\uFFFD\uD800\uDC00\uDBFF\uDFFF';
+const octets = {
+  'utf-8': [
+    0x00, 0x31, 0x32, 0x33, 0x41, 0x42, 0x43, 0x61, 0x62, 0x63, 0xc2, 0x80,
+    0xc3, 0xbf, 0xc4, 0x80, 0xe1, 0x80, 0x80, 0xef, 0xbf, 0xbd, 0xf0, 0x90,
+    0x80, 0x80, 0xf4, 0x8f, 0xbf, 0xbf],
+  'utf-16le': [
+    0x00, 0x00, 0x31, 0x00, 0x32, 0x00, 0x33, 0x00, 0x41, 0x00, 0x42, 0x00,
+    0x43, 0x00, 0x61, 0x00, 0x62, 0x00, 0x63, 0x00, 0x80, 0x00, 0xFF, 0x00,
+    0x00, 0x01, 0x00, 0x10, 0xFD, 0xFF, 0x00, 0xD8, 0x00, 0xDC, 0xFF, 0xDB,
+    0xFF, 0xDF]
+};
+
+Object.keys(octets).forEach((encoding) => {
+  for (let len = 1; len <= 5; ++len) {
+    const encoded = octets[encoding];
+    const decoder = new TextDecoder(encoding);
+    let out = '';
+    for (let i = 0; i < encoded.length; i += len) {
+      const sub = [];
+      for (let j = i; j < encoded.length && j < i + len; ++j)
+        sub.push(encoded[j]);
+      out += decoder.decode(new Uint8Array(sub), { stream: true });
+    }
+    out += decoder.decode();
+    assert.strictEqual(out, string);
+  }
+});
diff --git a/test/js/node/test/parallel/test-whatwg-encoding-custom-textdecoder-utf16-surrogates.js b/test/js/node/test/parallel/test-whatwg-encoding-custom-textdecoder-utf16-surrogates.js
new file mode 100644
index 0000000000..a2a31af28c
--- /dev/null
+++ b/test/js/node/test/parallel/test-whatwg-encoding-custom-textdecoder-utf16-surrogates.js
@@ -0,0 +1,56 @@
+'use strict';
+
+// From: https://github.com/w3c/web-platform-tests/blob/39a67e2fff/encoding/textdecoder-utf16-surrogates.html
+// With the twist that we specifically test for Node.js error codes
+
+const common = require('../common');
+
+if (!common.hasIntl)
+  common.skip('missing Intl');
+
+const assert = require('assert');
+
+const bad = [
+  {
+    encoding: 'utf-16le',
+    input: [0x00, 0xd8],
+    expected: '\uFFFD',
+    name: 'lone surrogate lead'
+  },
+  {
+    encoding: 'utf-16le',
+    input: [0x00, 0xdc],
+    expected: '\uFFFD',
+    name: 'lone surrogate trail'
+  },
+  {
+    encoding: 'utf-16le',
+    input: [0x00, 0xd8, 0x00, 0x00],
+    expected: '\uFFFD\u0000',
+    name: 'unmatched surrogate lead'
+  },
+  {
+    encoding: 'utf-16le',
+    input: [0x00, 0xdc, 0x00, 0x00],
+    expected: '\uFFFD\u0000',
+    name: 'unmatched surrogate trail'
+  },
+  {
+    encoding: 'utf-16le',
+    input: [0x00, 0xdc, 0x00, 0xd8],
+    expected: '\uFFFD\uFFFD',
+    name: 'swapped surrogate pair'
+  },
+];
+
+for (const t of bad) {
+  assert.throws(
+    () => {
+      new TextDecoder(t.encoding, { fatal: true })
+        .decode(new Uint8Array(t.input));
+    }, {
+      code: 'ERR_ENCODING_INVALID_ENCODED_DATA',
+      name: 'TypeError'
+    }
+  );
+}
diff --git a/test/js/node/test/parallel/test-whatwg-events-add-event-listener-options-passive.js b/test/js/node/test/parallel/test-whatwg-events-add-event-listener-options-passive.js
new file mode 100644
index 0000000000..97984bd9af
--- /dev/null
+++ b/test/js/node/test/parallel/test-whatwg-events-add-event-listener-options-passive.js
@@ -0,0 +1,65 @@
+'use strict';
+
+const common = require('../common');
+
+// Manually converted from https://github.com/web-platform-tests/wpt/blob/master/dom/events/AddEventListenerOptions-passive.html
+// in order to define the `document` ourselves
+
+const {
+  fail,
+  ok,
+  strictEqual
+} = require('assert');
+
+{
+  const document = new EventTarget();
+  let supportsPassive = false;
+  const query_options = {
+    get passive() {
+      supportsPassive = true;
+      return false;
+    },
+    get dummy() {
+      fail('dummy value getter invoked');
+      return false;
+    }
+  };
+
+  document.addEventListener('test_event', null, query_options);
+  ok(supportsPassive);
+
+  supportsPassive = false;
+  document.removeEventListener('test_event', null, query_options);
+  strictEqual(supportsPassive, false);
+}
+{
+  function testPassiveValue(optionsValue, expectedDefaultPrevented) {
+    const document = new EventTarget();
+    let defaultPrevented;
+    function handler(e) {
+      if (e.defaultPrevented) {
+        fail('Event prematurely marked defaultPrevented');
+      }
+      e.preventDefault();
+      defaultPrevented = e.defaultPrevented;
+    }
+    document.addEventListener('test', handler, optionsValue);
+    // TODO the WHATWG test is more extensive here and tests dispatching on
+    // document.body, if we ever support getParent we should amend this
+    const ev = new Event('test', { bubbles: true, cancelable: true });
+    const uncanceled = document.dispatchEvent(ev);
+
+    strictEqual(defaultPrevented, expectedDefaultPrevented);
+    strictEqual(uncanceled, !expectedDefaultPrevented);
+
+    document.removeEventListener('test', handler, optionsValue);
+  }
+  testPassiveValue(undefined, true);
+  testPassiveValue({}, true);
+  testPassiveValue({ passive: false }, true);
+
+  common.skip('TODO: passive listeners is still broken');
+  testPassiveValue({ passive: 1 }, false);
+  testPassiveValue({ passive: true }, false);
+  testPassiveValue({ passive: 0 }, true);
+}
diff --git a/test/js/node/test/parallel/test-whatwg-events-add-event-listener-options-signal.js b/test/js/node/test/parallel/test-whatwg-events-add-event-listener-options-signal.js
new file mode 100644
index 0000000000..460d2ee3f2
--- /dev/null
+++ b/test/js/node/test/parallel/test-whatwg-events-add-event-listener-options-signal.js
@@ -0,0 +1,168 @@
+'use strict';
+
+require('../common');
+
+const {
+  strictEqual,
+  throws,
+} = require('assert');
+
+// Manually ported from: wpt@dom/events/AddEventListenerOptions-signal.any.js
+
+{
+  // Passing an AbortSignal to addEventListener does not prevent
+  // removeEventListener
+  let count = 0;
+  function handler() {
+    count++;
+  }
+  const et = new EventTarget();
+  const controller = new AbortController();
+  et.addEventListener('test', handler, { signal: controller.signal });
+  et.dispatchEvent(new Event('test'));
+  strictEqual(count, 1, 'Adding a signal still adds a listener');
+  et.dispatchEvent(new Event('test'));
+  strictEqual(count, 2, 'The listener was not added with the once flag');
+  controller.abort();
+  et.dispatchEvent(new Event('test'));
+  strictEqual(count, 2, 'Aborting on the controller removes the listener');
+  // See: https://github.com/nodejs/node/pull/37696 , adding an event listener
+  // should always return undefined.
+  strictEqual(
+    et.addEventListener('test', handler, { signal: controller.signal }),
+    undefined);
+  et.dispatchEvent(new Event('test'));
+  strictEqual(count, 2, 'Passing an aborted signal never adds the handler');
+}
+
+{
+  // Passing an AbortSignal to addEventListener works with the once flag
+  let count = 0;
+  function handler() {
+    count++;
+  }
+  const et = new EventTarget();
+  const controller = new AbortController();
+  et.addEventListener('test', handler, { signal: controller.signal });
+  et.removeEventListener('test', handler);
+  et.dispatchEvent(new Event('test'));
+  strictEqual(count, 0, 'The listener was still removed');
+}
+
+{
+  // Removing a once listener works with a passed signal
+  let count = 0;
+  function handler() {
+    count++;
+  }
+  const et = new EventTarget();
+  const controller = new AbortController();
+  const options = { signal: controller.signal, once: true };
+  et.addEventListener('test', handler, options);
+  controller.abort();
+  et.dispatchEvent(new Event('test'));
+  strictEqual(count, 0, 'The listener was still removed');
+}
+
+{
+  let count = 0;
+  function handler() {
+    count++;
+  }
+  const et = new EventTarget();
+  const controller = new AbortController();
+  const options = { signal: controller.signal, once: true };
+  et.addEventListener('test', handler, options);
+  et.removeEventListener('test', handler);
+  et.dispatchEvent(new Event('test'));
+  strictEqual(count, 0, 'The listener was still removed');
+}
+
+{
+  // Passing an AbortSignal to multiple listeners
+  let count = 0;
+  function handler() {
+    count++;
+  }
+  const et = new EventTarget();
+  const controller = new AbortController();
+  const options = { signal: controller.signal, once: true };
+  et.addEventListener('first', handler, options);
+  et.addEventListener('second', handler, options);
+  controller.abort();
+  et.dispatchEvent(new Event('first'));
+  et.dispatchEvent(new Event('second'));
+  strictEqual(count, 0, 'The listener was still removed');
+}
+
+{
+  // Passing an AbortSignal to addEventListener works with the capture flag
+  let count = 0;
+  function handler() {
+    count++;
+  }
+  const et = new EventTarget();
+  const controller = new AbortController();
+  const options = { signal: controller.signal, capture: true };
+  et.addEventListener('test', handler, options);
+  controller.abort();
+  et.dispatchEvent(new Event('test'));
+  strictEqual(count, 0, 'The listener was still removed');
+}
+
+{
+  // Aborting from a listener does not call future listeners
+  let count = 0;
+  function handler() {
+    count++;
+  }
+  const et = new EventTarget();
+  const controller = new AbortController();
+  const options = { signal: controller.signal };
+  et.addEventListener('test', () => {
+    controller.abort();
+  }, options);
+  et.addEventListener('test', handler, options);
+  et.dispatchEvent(new Event('test'));
+  strictEqual(count, 0, 'The listener was still removed');
+}
+
+{
+  // Adding then aborting a listener in another listener does not call it
+  let count = 0;
+  function handler() {
+    count++;
+  }
+  const et = new EventTarget();
+  const controller = new AbortController();
+  et.addEventListener('test', () => {
+    et.addEventListener('test', handler, { signal: controller.signal });
+    controller.abort();
+  }, { signal: controller.signal });
+  et.dispatchEvent(new Event('test'));
+  strictEqual(count, 0, 'The listener was still removed');
+}
+
+{
+  // Aborting from a nested listener should remove it
+  const et = new EventTarget();
+  const ac = new AbortController();
+  let count = 0;
+  et.addEventListener('foo', () => {
+    et.addEventListener('foo', () => {
+      count++;
+      if (count > 5) ac.abort();
+      et.dispatchEvent(new Event('foo'));
+    }, { signal: ac.signal });
+    et.dispatchEvent(new Event('foo'));
+  }, { once: true });
+  et.dispatchEvent(new Event('foo'));
+}
+{
+  const et = new EventTarget();
+  [1, 1n, {}, [], null, true, 'hi', Symbol(), () => {}].forEach((signal) => {
+    throws(() => et.addEventListener('foo', () => {}, { signal }), {
+      name: 'TypeError',
+    });
+  });
+}
diff --git a/test/js/node/test/parallel/test-whatwg-events-customevent.js b/test/js/node/test/parallel/test-whatwg-events-customevent.js
new file mode 100644
index 0000000000..e21ea1783f
--- /dev/null
+++ b/test/js/node/test/parallel/test-whatwg-events-customevent.js
@@ -0,0 +1,33 @@
+'use strict';
+
+const common = require('../common');
+
+const { strictEqual, throws, equal } = require('assert');
+
+// Manually converted from https://github.com/web-platform-tests/wpt/blob/master/dom/events/CustomEvent.html
+// in order to define the `document` ourselves
+
+{
+  const type = 'foo';
+  const target = new EventTarget();
+
+  target.addEventListener(type, common.mustCall((evt) => {
+    strictEqual(evt.type, type);
+  }));
+
+  target.dispatchEvent(new Event(type));
+}
+
+{
+  throws(() => {
+    new Event();
+  }, TypeError);
+}
+
+{
+  const event = new Event('foo');
+  equal(event.type, 'foo');
+  equal(event.bubbles, false);
+  equal(event.cancelable, false);
+  equal(event.detail, null);
+}
diff --git a/test/js/node/test/parallel/test-whatwg-events-event-constructors.js b/test/js/node/test/parallel/test-whatwg-events-event-constructors.js
new file mode 100644
index 0000000000..7880b10043
--- /dev/null
+++ b/test/js/node/test/parallel/test-whatwg-events-event-constructors.js
@@ -0,0 +1,29 @@
+'use strict';
+
+require('../common');
+const { test, assert_equals, assert_array_equals } =
+  require('../common/wpt').harness;
+
+// Source: https://github.com/web-platform-tests/wpt/blob/6cef1d2087d6a07d7cc6cee8cf207eec92e27c5f/dom/events/Event-constructors.any.js#L91-L112
+test(function() {
+  const called = [];
+  const ev = new Event('Xx', {
+    get cancelable() {
+      called.push('cancelable');
+      return false;
+    },
+    get bubbles() {
+      called.push('bubbles');
+      return true;
+    },
+    get sweet() {
+      called.push('sweet');
+      return 'x';
+    },
+  });
+  assert_array_equals(called, ['bubbles', 'cancelable']);
+  assert_equals(ev.type, 'Xx');
+  assert_equals(ev.bubbles, true);
+  assert_equals(ev.cancelable, false);
+  assert_equals(ev.sweet, undefined);
+});
diff --git a/test/js/node/test/parallel/test-whatwg-events-eventtarget-this-of-listener.js b/test/js/node/test/parallel/test-whatwg-events-eventtarget-this-of-listener.js
new file mode 100644
index 0000000000..16ee14feab
--- /dev/null
+++ b/test/js/node/test/parallel/test-whatwg-events-eventtarget-this-of-listener.js
@@ -0,0 +1,119 @@
+'use strict';
+
+require('../common');
+const { test, assert_equals, assert_unreached } =
+  require('../common/wpt').harness;
+
+// Manually ported from: https://github.com/web-platform-tests/wpt/blob/6cef1d2087d6a07d7cc6cee8cf207eec92e27c5f/dom/events/EventTarget-this-of-listener.html
+
+// Mock document
+const document = {
+  createElement: () => new EventTarget(),
+  createTextNode: () => new EventTarget(),
+  createDocumentFragment: () => new EventTarget(),
+  createComment: () => new EventTarget(),
+  createProcessingInstruction: () => new EventTarget(),
+};
+
+test(() => {
+  const nodes = [
+    document.createElement('p'),
+    document.createTextNode('some text'),
+    document.createDocumentFragment(),
+    document.createComment('a comment'),
+    document.createProcessingInstruction('target', 'data'),
+  ];
+
+  let callCount = 0;
+  for (const node of nodes) {
+    node.addEventListener('someevent', function() {
+      ++callCount;
+      assert_equals(this, node);
+    });
+
+    node.dispatchEvent(new Event('someevent'));
+  }
+
+  assert_equals(callCount, nodes.length);
+}, 'the this value inside the event listener callback should be the node');
+
+test(() => {
+  const nodes = [
+    document.createElement('p'),
+    document.createTextNode('some text'),
+    document.createDocumentFragment(),
+    document.createComment('a comment'),
+    document.createProcessingInstruction('target', 'data'),
+  ];
+
+  let callCount = 0;
+  for (const node of nodes) {
+    const handler = {};
+
+    node.addEventListener('someevent', handler);
+    handler.handleEvent = function() {
+      ++callCount;
+      assert_equals(this, handler);
+    };
+
+    node.dispatchEvent(new Event('someevent'));
+  }
+
+  assert_equals(callCount, nodes.length);
+}, 'addEventListener should not require handleEvent to be defined on object listeners');
+
+test(() => {
+  const nodes = [
+    document.createElement('p'),
+    document.createTextNode('some text'),
+    document.createDocumentFragment(),
+    document.createComment('a comment'),
+    document.createProcessingInstruction('target', 'data'),
+  ];
+
+  let callCount = 0;
+  for (const node of nodes) {
+    function handler() {
+      ++callCount;
+      assert_equals(this, node);
+    }
+
+    handler.handleEvent = () => {
+      assert_unreached('should not call the handleEvent method on a function');
+    };
+
+    node.addEventListener('someevent', handler);
+
+    node.dispatchEvent(new Event('someevent'));
+  }
+
+  assert_equals(callCount, nodes.length);
+}, 'handleEvent properties added to a function before addEventListener are not reached');
+
+test(() => {
+  const nodes = [
+    document.createElement('p'),
+    document.createTextNode('some text'),
+    document.createDocumentFragment(),
+    document.createComment('a comment'),
+    document.createProcessingInstruction('target', 'data'),
+  ];
+
+  let callCount = 0;
+  for (const node of nodes) {
+    function handler() {
+      ++callCount;
+      assert_equals(this, node);
+    }
+
+    node.addEventListener('someevent', handler);
+
+    handler.handleEvent = () => {
+      assert_unreached('should not call the handleEvent method on a function');
+    };
+
+    node.dispatchEvent(new Event('someevent'));
+  }
+
+  assert_equals(callCount, nodes.length);
+}, 'handleEvent properties added to a function after addEventListener are not reached');
diff --git a/test/js/node/test/parallel/test-whatwg-readablestream.mjs b/test/js/node/test/parallel/test-whatwg-readablestream.mjs
new file mode 100644
index 0000000000..57ebed6045
--- /dev/null
+++ b/test/js/node/test/parallel/test-whatwg-readablestream.mjs
@@ -0,0 +1,70 @@
+import { mustCall } from '../common/index.mjs';
+import { ReadableStream } from 'stream/web';
+import assert from 'assert';
+
+{
+  // Test tee() with close in the nextTick after enqueue
+  async function read(stream) {
+    const chunks = [];
+    for await (const chunk of stream)
+      chunks.push(chunk);
+    return Buffer.concat(chunks).toString();
+  }
+
+  const [r1, r2] = new ReadableStream({
+    start(controller) {
+      process.nextTick(() => {
+        controller.enqueue(new Uint8Array([102, 111, 111, 98, 97, 114]));
+
+        process.nextTick(() => {
+          controller.close();
+        });
+      });
+    }
+  }).tee();
+
+  (async () => {
+    const [dataReader1, dataReader2] = await Promise.all([
+      read(r1),
+      read(r2),
+    ]);
+
+    assert.strictEqual(dataReader1, dataReader2);
+    assert.strictEqual(dataReader1, 'foobar');
+    assert.strictEqual(dataReader2, 'foobar');
+  })().then(mustCall());
+}
+
+{
+  // Test ReadableByteStream.tee() with close in the nextTick after enqueue
+  async function read(stream) {
+    const chunks = [];
+    for await (const chunk of stream)
+      chunks.push(chunk);
+    return Buffer.concat(chunks).toString();
+  }
+
+  const [r1, r2] = new ReadableStream({
+    type: 'bytes',
+    start(controller) {
+      process.nextTick(() => {
+        controller.enqueue(new Uint8Array([102, 111, 111, 98, 97, 114]));
+
+        process.nextTick(() => {
+          controller.close();
+        });
+      });
+    }
+  }).tee();
+
+  (async () => {
+    const [dataReader1, dataReader2] = await Promise.all([
+      read(r1),
+      read(r2),
+    ]);
+
+    assert.strictEqual(dataReader1, dataReader2);
+    assert.strictEqual(dataReader1, 'foobar');
+    assert.strictEqual(dataReader2, 'foobar');
+  })().then(mustCall());
+}
diff --git a/test/js/node/test/parallel/test-whatwg-url-custom-deepequal.js b/test/js/node/test/parallel/test-whatwg-url-custom-deepequal.js
new file mode 100644
index 0000000000..9150b1561b
--- /dev/null
+++ b/test/js/node/test/parallel/test-whatwg-url-custom-deepequal.js
@@ -0,0 +1,18 @@
+'use strict';
+// This tests that the internal flags in URL objects are consistent, as manifest
+// through assert libraries.
+// See https://github.com/nodejs/node/issues/24211
+
+// Tests below are not from WPT.
+
+require('../common');
+const assert = require('assert');
+
+assert.deepStrictEqual(
+  new URL('./foo', 'https://example.com/'),
+  new URL('https://example.com/foo')
+);
+assert.deepStrictEqual(
+  new URL('./foo', 'https://user:pass@example.com/'),
+  new URL('https://user:pass@example.com/foo')
+);
diff --git a/test/js/node/test/parallel/test-whatwg-url-custom-domainto.js b/test/js/node/test/parallel/test-whatwg-url-custom-domainto.js
new file mode 100644
index 0000000000..b7458d7a8e
--- /dev/null
+++ b/test/js/node/test/parallel/test-whatwg-url-custom-domainto.js
@@ -0,0 +1,57 @@
+'use strict';
+
+// Tests below are not from WPT.
+
+const common = require('../common');
+
+if (!common.hasIntl)
+  common.skip('missing Intl');
+
+const assert = require('assert');
+const { domainToASCII, domainToUnicode } = require('url');
+
+const tests = require('../fixtures/url-idna');
+const fixtures = require('../common/fixtures');
+const wptToASCIITests = require(
+  fixtures.path('wpt', 'url', 'resources', 'toascii.json')
+);
+
+{
+  const expectedError = { code: 'ERR_MISSING_ARGS', name: 'TypeError' };
+  assert.throws(() => domainToASCII(), expectedError);
+  assert.throws(() => domainToUnicode(), expectedError);
+  assert.strictEqual(domainToASCII(undefined), 'undefined');
+  assert.strictEqual(domainToUnicode(undefined), 'undefined');
+}
+
+{
+  for (const [i, { ascii, unicode }] of tests.entries()) {
+    assert.strictEqual(ascii, domainToASCII(unicode),
+                       `domainToASCII(${i + 1})`);
+    assert.strictEqual(unicode, domainToUnicode(ascii),
+                       `domainToUnicode(${i + 1})`);
+    assert.strictEqual(ascii, domainToASCII(domainToUnicode(ascii)),
+                       `domainToASCII(domainToUnicode(${i + 1}))`);
+    assert.strictEqual(unicode, domainToUnicode(domainToASCII(unicode)),
+                       `domainToUnicode(domainToASCII(${i + 1}))`);
+  }
+}
+
+{
+  for (const [i, test] of wptToASCIITests.entries()) {
+    if (typeof test === 'string')
+      continue; // skip comments
+    const { comment, input, output } = test;
+    let caseComment = `Case ${i + 1}`;
+    if (comment)
+      caseComment += ` (${comment})`;
+    if (output === null) {
+      assert.strictEqual(domainToASCII(input), '', caseComment);
+      assert.strictEqual(domainToUnicode(input), '', caseComment);
+    } else {
+      assert.strictEqual(domainToASCII(input), output, caseComment);
+      const roundtripped = domainToASCII(domainToUnicode(input));
+      assert.strictEqual(roundtripped, output, caseComment);
+    }
+  }
+}
diff --git a/test/js/node/test/parallel/test-whatwg-url-custom-href-side-effect.js b/test/js/node/test/parallel/test-whatwg-url-custom-href-side-effect.js
new file mode 100644
index 0000000000..30967d9fea
--- /dev/null
+++ b/test/js/node/test/parallel/test-whatwg-url-custom-href-side-effect.js
@@ -0,0 +1,15 @@
+'use strict';
+
+// Tests below are not from WPT.
+require('../common');
+const assert = require('assert');
+
+const ref = new URL('http://example.com/path');
+const url = new URL('http://example.com/path');
+assert.throws(() => {
+  url.href = '';
+}, {
+  name: 'TypeError'
+});
+
+assert.deepStrictEqual(url, ref);
diff --git a/test/js/node/test/parallel/test-whatwg-url-custom-inspect.js b/test/js/node/test/parallel/test-whatwg-url-custom-inspect.js
new file mode 100644
index 0000000000..946c097eac
--- /dev/null
+++ b/test/js/node/test/parallel/test-whatwg-url-custom-inspect.js
@@ -0,0 +1,70 @@
+'use strict';
+
+// Tests below are not from WPT.
+
+const common = require('../common');
+if (!common.hasIntl) {
+  // A handful of the tests fail when ICU is not included.
+  common.skip('missing Intl');
+}
+
+const util = require('util');
+const assert = require('assert');
+
+const url = new URL('https://username:password@host.name:8080/path/name/?que=ry#hash');
+
+assert.strictEqual(
+  util.inspect(url),
+  `URL {
+  href: 'https://username:password@host.name:8080/path/name/?que=ry#hash',
+  origin: 'https://host.name:8080',
+  protocol: 'https:',
+  username: 'username',
+  password: 'password',
+  host: 'host.name:8080',
+  hostname: 'host.name',
+  port: '8080',
+  pathname: '/path/name/',
+  search: '?que=ry',
+  searchParams: URLSearchParams { 'que' => 'ry' },
+  hash: '#hash'
+}`);
+
+assert.strictEqual(
+  util.inspect(url, { showHidden: true }),
+  `URL {
+  href: 'https://username:password@host.name:8080/path/name/?que=ry#hash',
+  origin: 'https://host.name:8080',
+  protocol: 'https:',
+  username: 'username',
+  password: 'password',
+  host: 'host.name:8080',
+  hostname: 'host.name',
+  port: '8080',
+  pathname: '/path/name/',
+  search: '?que=ry',
+  searchParams: URLSearchParams { 'que' => 'ry' },
+  hash: '#hash',
+  [Symbol(context)]: URLContext {
+    href: 'https://username:password@host.name:8080/path/name/?que=ry#hash',
+    protocol_end: 6,
+    username_end: 16,
+    host_start: 25,
+    host_end: 35,
+    pathname_start: 40,
+    search_start: 51,
+    hash_start: 58,
+    port: 8080,
+    scheme_type: 2,
+    [hasPort]: [Getter],
+    [hasSearch]: [Getter],
+    [hasHash]: [Getter]
+  }
+}`);
+
+assert.strictEqual(
+  util.inspect({ a: url }, { depth: 0 }),
+  '{ a: URL {} }');
+
+class MyURL extends URL {}
+assert(util.inspect(new MyURL(url.href)).startsWith('MyURL {'));
diff --git a/test/js/node/test/parallel/test-whatwg-url-custom-parsing.js b/test/js/node/test/parallel/test-whatwg-url-custom-parsing.js
new file mode 100644
index 0000000000..cdeda59eec
--- /dev/null
+++ b/test/js/node/test/parallel/test-whatwg-url-custom-parsing.js
@@ -0,0 +1,87 @@
+'use strict';
+
+// Tests below are not from WPT.
+
+const common = require('../common');
+if (!common.hasIntl) {
+  // A handful of the tests fail when ICU is not included.
+  common.skip('missing Intl');
+}
+
+const assert = require('assert');
+const fixtures = require('../common/fixtures');
+
+const tests = require(
+  fixtures.path('wpt', 'url', 'resources', 'urltestdata.json')
+);
+
+const originalFailures = tests.filter((test) => test.failure);
+
+const typeFailures = [
+  { input: '' },
+  { input: 'test' },
+  { input: undefined },
+  { input: 0 },
+  { input: true },
+  { input: false },
+  { input: null },
+  { input: new Date() },
+  { input: new RegExp() },
+  { input: 'test', base: null },
+  { input: 'http://nodejs.org', base: null },
+  { input: () => {} },
+];
+
+// See https://github.com/w3c/web-platform-tests/pull/10955
+// > If `failure` is true, parsing `about:blank` against `base`
+// > must give failure. This tests that the logic for converting
+// > base URLs into strings properly fails the whole parsing
+// > algorithm if the base URL cannot be parsed.
+const aboutBlankFailures = originalFailures
+  .map((test) => ({
+    input: 'about:blank',
+    base: test.input,
+    failure: true
+  }));
+
+const failureTests = originalFailures
+  .concat(typeFailures)
+  .concat(aboutBlankFailures);
+
+const expectedError = { code: 'ERR_INVALID_URL', name: 'TypeError' };
+
+for (const test of failureTests) {
+  assert.throws(
+    () => new URL(test.input, test.base),
+    (error) => {
+      assert.throws(() => { throw error; }, expectedError);
+      assert.strictEqual(`${error}`, 'TypeError: Invalid URL');
+      assert.strictEqual(error.message, 'Invalid URL');
+      return true;
+    });
+}
+
+const additional_tests =
+  require(fixtures.path('url-tests-additional.js'));
+
+for (const test of additional_tests) {
+  const url = new URL(test.url);
+  if (test.href) assert.strictEqual(url.href, test.href);
+  if (test.origin) assert.strictEqual(url.origin, test.origin);
+  if (test.protocol) assert.strictEqual(url.protocol, test.protocol);
+  if (test.username) assert.strictEqual(url.username, test.username);
+  if (test.password) assert.strictEqual(url.password, test.password);
+  if (test.hostname) assert.strictEqual(url.hostname, test.hostname);
+  if (test.host) assert.strictEqual(url.host, test.host);
+  if (test.port !== undefined) assert.strictEqual(url.port, test.port);
+  if (test.pathname) assert.strictEqual(url.pathname, test.pathname);
+  if (test.search) assert.strictEqual(url.search, test.search);
+  if (test.hash) assert.strictEqual(url.hash, test.hash);
+}
+
+assert.throws(() => {
+  new URL();
+}, {
+  name: 'TypeError',
+  code: 'ERR_MISSING_ARGS',
+});
diff --git a/test/js/node/test/parallel/test-whatwg-url-custom-searchparams-sort.js b/test/js/node/test/parallel/test-whatwg-url-custom-searchparams-sort.js
new file mode 100644
index 0000000000..e0b0c5c1ed
--- /dev/null
+++ b/test/js/node/test/parallel/test-whatwg-url-custom-searchparams-sort.js
@@ -0,0 +1,51 @@
+'use strict';
+
+// Tests below are not from WPT.
+
+require('../common');
+const { test, assert_array_equals } = require('../common/wpt').harness;
+
+// TODO(joyeecheung): upstream this to WPT, if possible - even
+// just as a test for large inputs. Other implementations may
+// have a similar cutoff anyway.
+
+// Test bottom-up iterative stable merge sort because we only use that
+// algorithm to sort > 100 search params.
+const tests = [{ input: '', output: [] }];
+const pairs = [];
+for (let i = 10; i < 100; i++) {
+  pairs.push([`a${i}`, 'b']);
+  tests[0].output.push([`a${i}`, 'b']);
+}
+tests[0].input = pairs.sort(() => Math.random() > 0.5)
+  .map((pair) => pair.join('=')).join('&');
+
+tests.push(
+  {
+    'input': 'z=a&=b&c=d',
+    'output': [['', 'b'], ['c', 'd'], ['z', 'a']]
+  }
+);
+
+tests.forEach((val) => {
+  test(() => {
+    const params = new URLSearchParams(val.input);
+    let i = 0;
+    params.sort();
+    for (const param of params) {
+      assert_array_equals(param, val.output[i]);
+      i++;
+    }
+  }, `Parse and sort: ${val.input}`);
+
+  test(() => {
+    const url = new URL(`?${val.input}`, 'https://example/');
+    url.searchParams.sort();
+    const params = new URLSearchParams(url.search);
+    let i = 0;
+    for (const param of params) {
+      assert_array_equals(param, val.output[i]);
+      i++;
+    }
+  }, `URL parse and sort: ${val.input}`);
+});
diff --git a/test/js/node/test/parallel/test-whatwg-url-custom-searchparams.js b/test/js/node/test/parallel/test-whatwg-url-custom-searchparams.js
new file mode 100644
index 0000000000..faec86e017
--- /dev/null
+++ b/test/js/node/test/parallel/test-whatwg-url-custom-searchparams.js
@@ -0,0 +1,147 @@
+'use strict';
+
+// Tests below are not from WPT.
+
+require('../common');
+const assert = require('assert');
+const fixtures = require('../common/fixtures');
+
+const serialized = 'a=a&a=1&a=true&a=undefined&a=null&a=%EF%BF%BD' +
+                   '&a=%EF%BF%BD&a=%F0%9F%98%80&a=%EF%BF%BD%EF%BF%BD' +
+                   '&a=%5Bobject+Object%5D';
+const values = ['a', 1, true, undefined, null, '\uD83D', '\uDE00',
+                '\uD83D\uDE00', '\uDE00\uD83D', {}];
+const normalizedValues = ['a', '1', 'true', 'undefined', 'null', '\uFFFD',
+                          '\uFFFD', '\uD83D\uDE00', '\uFFFD\uFFFD',
+                          '[object Object]'];
+
+const m = new URL('http://example.org');
+const ownSymbolsBeforeGetterAccess = Object.getOwnPropertySymbols(m);
+const sp = m.searchParams;
+assert.deepStrictEqual(Object.getOwnPropertySymbols(m), ownSymbolsBeforeGetterAccess);
+
+assert(sp);
+assert.strictEqual(sp.toString(), '');
+assert.strictEqual(m.search, '');
+
+assert(!sp.has('a'));
+values.forEach((i) => sp.set('a', i));
+assert(sp.has('a'));
+assert.strictEqual(sp.get('a'), '[object Object]');
+sp.delete('a');
+assert(!sp.has('a'));
+
+m.search = '';
+assert.strictEqual(sp.toString(), '');
+
+values.forEach((i) => sp.append('a', i));
+assert(sp.has('a'));
+assert.strictEqual(sp.getAll('a').length, values.length);
+assert.strictEqual(sp.get('a'), 'a');
+
+assert.strictEqual(sp.toString(), serialized);
+
+assert.strictEqual(m.search, `?${serialized}`);
+
+sp.delete('a');
+values.forEach((i) => sp.append('a', i));
+assert.strictEqual(m.href, `http://example.org/?${serialized}`);
+
+sp.delete('a');
+values.forEach((i) => sp.append('a', i));
+assert.strictEqual(m.toString(), `http://example.org/?${serialized}`);
+
+sp.delete('a');
+values.forEach((i) => sp.append('a', i));
+assert.strictEqual(m.toJSON(), `http://example.org/?${serialized}`);
+
+sp.delete('a');
+values.forEach((i) => sp.append('a', i));
+m.href = 'http://example.org';
+assert.strictEqual(m.href, 'http://example.org/');
+assert.strictEqual(sp.size, 0);
+
+sp.delete('a');
+values.forEach((i) => sp.append('a', i));
+m.search = '';
+assert.strictEqual(m.href, 'http://example.org/');
+assert.strictEqual(sp.size, 0);
+
+sp.delete('a');
+values.forEach((i) => sp.append('a', i));
+m.pathname = '/test';
+assert.strictEqual(m.href, `http://example.org/test?${serialized}`);
+m.pathname = '';
+
+sp.delete('a');
+values.forEach((i) => sp.append('a', i));
+m.hash = '#test';
+assert.strictEqual(m.href, `http://example.org/?${serialized}#test`);
+m.hash = '';
+
+assert.strictEqual(sp[Symbol.iterator], sp.entries);
+
+let key, val;
+let n = 0;
+for ([key, val] of sp) {
+  assert.strictEqual(key, 'a', n);
+  assert.strictEqual(val, normalizedValues[n], n);
+  n++;
+}
+n = 0;
+for (key of sp.keys()) {
+  assert.strictEqual(key, 'a', n);
+  n++;
+}
+n = 0;
+for (val of sp.values()) {
+  assert.strictEqual(val, normalizedValues[n], n);
+  n++;
+}
+n = 0;
+sp.forEach(function(val, key, obj) {
+  assert.strictEqual(this, undefined, n);
+  assert.strictEqual(key, 'a', n);
+  assert.strictEqual(val, normalizedValues[n], n);
+  assert.strictEqual(obj, sp, n);
+  n++;
+});
+sp.forEach(function() {
+  assert.strictEqual(this, m);
+}, m);
+
+{
+  const callbackErr = {
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError'
+  };
+  assert.throws(() => sp.forEach(), callbackErr);
+  assert.throws(() => sp.forEach(1), callbackErr);
+}
+
+m.search = '?a=a&b=b';
+assert.strictEqual(sp.toString(), 'a=a&b=b');
+
+const tests = require(fixtures.path('url-searchparams.js'));
+
+for (const [input, expected, parsed] of tests) {
+  if (input[0] !== '?') {
+    const sp = new URLSearchParams(input);
+    assert.strictEqual(String(sp), expected);
+    assert.deepStrictEqual(Array.from(sp), parsed);
+
+    m.search = input;
+    assert.strictEqual(String(m.searchParams), expected);
+    assert.deepStrictEqual(Array.from(m.searchParams), parsed);
+  }
+
+  {
+    const sp = new URLSearchParams(`?${input}`);
+    assert.strictEqual(String(sp), expected);
+    assert.deepStrictEqual(Array.from(sp), parsed);
+
+    m.search = `?${input}`;
+    assert.strictEqual(String(m.searchParams), expected);
+    assert.deepStrictEqual(Array.from(m.searchParams), parsed);
+  }
+}
diff --git a/test/js/node/test/parallel/test-whatwg-url-custom-setters.js b/test/js/node/test/parallel/test-whatwg-url-custom-setters.js
new file mode 100644
index 0000000000..b98bf5d8d3
--- /dev/null
+++ b/test/js/node/test/parallel/test-whatwg-url-custom-setters.js
@@ -0,0 +1,60 @@
+'use strict';
+
+// Tests below are not from WPT.
+
+const common = require('../common');
+if (!common.hasIntl) {
+  // A handful of the tests fail when ICU is not included.
+  common.skip('missing Intl');
+}
+
+const assert = require('assert');
+const { test, assert_equals } = require('../common/wpt').harness;
+const fixtures = require('../common/fixtures');
+
+// TODO(joyeecheung): we should submit these to the upstream
+const additionalTestCases =
+  require(fixtures.path('url-setter-tests-additional.js'));
+
+{
+  for (const attributeToBeSet in additionalTestCases) {
+    if (attributeToBeSet === 'comment') {
+      continue;
+    }
+    const testCases = additionalTestCases[attributeToBeSet];
+    for (const testCase of testCases) {
+      let name = `Setting <${testCase.href}>.${attributeToBeSet}` +
+                 ` = "${testCase.new_value}"`;
+      if ('comment' in testCase) {
+        name += ` ${testCase.comment}`;
+      }
+      test(function() {
+        const url = new URL(testCase.href);
+        url[attributeToBeSet] = testCase.new_value;
+        for (const attribute in testCase.expected) {
+          assert_equals(url[attribute], testCase.expected[attribute]);
+        }
+      }, `URL: ${name}`);
+    }
+  }
+}
+
+{
+  const url = new URL('http://example.com/');
+  const obj = {
+    toString() { throw new Error('toString'); },
+    valueOf() { throw new Error('valueOf'); }
+  };
+  const sym = Symbol();
+  const props = Object.getOwnPropertyDescriptors(Object.getPrototypeOf(url));
+  for (const [name, { set }] of Object.entries(props)) {
+    if (set) {
+      assert.throws(() => url[name] = obj,
+                    /^Error: toString$/,
+                    `url.${name} = { toString() { throw ... } }`);
+      assert.throws(() => url[name] = sym,
+                    /^TypeError: Cannot convert a Symbol value to a string$/,
+                    `url.${name} = ${String(sym)}`);
+    }
+  }
+}
diff --git a/test/js/node/test/parallel/test-whatwg-url-custom-tostringtag.js b/test/js/node/test/parallel/test-whatwg-url-custom-tostringtag.js
new file mode 100644
index 0000000000..54e5850a8f
--- /dev/null
+++ b/test/js/node/test/parallel/test-whatwg-url-custom-tostringtag.js
@@ -0,0 +1,32 @@
+'use strict';
+
+// Tests below are not from WPT.
+
+require('../common');
+const assert = require('assert');
+
+const toString = Object.prototype.toString;
+
+const url = new URL('http://example.org');
+const sp = url.searchParams;
+const spIterator = sp.entries();
+
+const test = [
+  [url, 'URL'],
+  [sp, 'URLSearchParams'],
+  [spIterator, 'URLSearchParams Iterator'],
+  // Web IDL spec says we have to return 'URLPrototype', but it is too
+  // expensive to implement; therefore, use Chrome's behavior for now, until
+  // spec is changed.
+  [Object.getPrototypeOf(url), 'URL'],
+  [Object.getPrototypeOf(sp), 'URLSearchParams'],
+  [Object.getPrototypeOf(spIterator), 'URLSearchParams Iterator'],
+];
+
+test.forEach(([obj, expected]) => {
+  assert.strictEqual(obj[Symbol.toStringTag], expected,
+                     `${obj[Symbol.toStringTag]} !== ${expected}`);
+  const str = toString.call(obj);
+  assert.strictEqual(str, `[object ${expected}]`,
+                     `${str} !== [object ${expected}]`);
+});
diff --git a/test/js/node/test/parallel/test-whatwg-url-override-hostname.js b/test/js/node/test/parallel/test-whatwg-url-override-hostname.js
new file mode 100644
index 0000000000..61e3412c6b
--- /dev/null
+++ b/test/js/node/test/parallel/test-whatwg-url-override-hostname.js
@@ -0,0 +1,20 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+
+{
+  const url = new (class extends URL { get hostname() { return 'bar.com'; } })('http://foo.com/');
+  assert.strictEqual(url.href, 'http://foo.com/');
+  assert.strictEqual(url.toString(), 'http://foo.com/');
+  assert.strictEqual(url.toJSON(), 'http://foo.com/');
+  assert.strictEqual(url.hash, '');
+  assert.strictEqual(url.host, 'foo.com');
+  assert.strictEqual(url.hostname, 'bar.com');
+  assert.strictEqual(url.origin, 'http://foo.com');
+  assert.strictEqual(url.password, '');
+  assert.strictEqual(url.protocol, 'http:');
+  assert.strictEqual(url.username, '');
+  assert.strictEqual(url.search, '');
+  assert.strictEqual(url.searchParams.toString(), '');
+}
diff --git a/test/js/node/test/parallel/test-whatwg-url-toascii.js b/test/js/node/test/parallel/test-whatwg-url-toascii.js
new file mode 100644
index 0000000000..e5180bfb34
--- /dev/null
+++ b/test/js/node/test/parallel/test-whatwg-url-toascii.js
@@ -0,0 +1,86 @@
+'use strict';
+const common = require('../common');
+if (!common.hasIntl) {
+  // A handful of the tests fail when ICU is not included.
+  common.skip('missing Intl');
+}
+
+const fixtures = require('../common/fixtures');
+const { test, assert_equals, assert_throws } = require('../common/wpt').harness;
+
+const request = {
+  response: require(
+    fixtures.path('wpt', 'url', 'resources', 'toascii.json')
+  )
+};
+
+// The following tests are copied from WPT. Modifications to them should be
+// upstreamed first.
+// Refs: https://github.com/w3c/web-platform-tests/blob/4839a0a804/url/toascii.window.js
+// License: http://www.w3.org/Consortium/Legal/2008/04-testsuite-copyright.html
+
+/* eslint-disable */
+// async_test(t => {
+//   const request = new XMLHttpRequest()
+//   request.open("GET", "toascii.json")
+//   request.send()
+//   request.responseType = "json"
+//   request.onload = t.step_func_done(() => {
+    runTests(request.response)
+//   })
+// }, "Loading data…")
+
+function makeURL(type, input) {
+  input = "https://" + input + "/x"
+  if(type === "url") {
+    return new URL(input)
+  } else {
+    const url = document.createElement(type)
+    url.href = input
+    return url
+  }
+}
+
+function runTests(tests) {
+  for(var i = 0, l = tests.length; i < l; i++) {
+    let hostTest = tests[i]
+    if (typeof hostTest === "string") {
+      continue // skip comments
+    }
+    const typeName = { "url": "URL", "a": "<a>", "area": "<area>" }
+    // ;["url", "a", "area"].forEach((type) => {
+    ;["url"].forEach((type) => {
+      test(() => {
+        if(hostTest.output !== null) {
+          const url = makeURL("url", hostTest.input)
+          assert_equals(url.host, hostTest.output)
+          assert_equals(url.hostname, hostTest.output)
+          assert_equals(url.pathname, "/x")
+          assert_equals(url.href, "https://" + hostTest.output + "/x")
+        } else {
+          if(type === "url") {
+            assert_throws(new TypeError, () => makeURL("url", hostTest.input))
+          } else {
+            const url = makeURL(type, hostTest.input)
+            assert_equals(url.host, "")
+            assert_equals(url.hostname, "")
+            assert_equals(url.pathname, "")
+            assert_equals(url.href, "https://" + hostTest.input + "/x")
+          }
+        }
+      }, hostTest.input + " (using " + typeName[type] + ")")
+      ;["host", "hostname"].forEach((val) => {
+        test(() => {
+          const url = makeURL(type, "x")
+          url[val] = hostTest.input
+          if(hostTest.output !== null) {
+            assert_equals(url[val], hostTest.output)
+          } else {
+            assert_equals(url[val], "x")
+          }
+        }, hostTest.input + " (using " + typeName[type] + "." + val + ")")
+      })
+    })
+  }
+}
+/* eslint-enable */
diff --git a/test/js/node/test/parallel/test-windows-abort-exitcode.js b/test/js/node/test/parallel/test-windows-abort-exitcode.js
new file mode 100644
index 0000000000..e2e6570c1c
--- /dev/null
+++ b/test/js/node/test/parallel/test-windows-abort-exitcode.js
@@ -0,0 +1,22 @@
+'use strict';
+const common = require('../common');
+if (!common.isWindows)
+  common.skip('test is windows specific');
+
+const assert = require('assert');
+const spawn = require('child_process').spawn;
+
+// This test makes sure that an aborted node process
+// exits with code 3 on Windows.
+// Spawn a child, force an abort, and then check the
+// exit code in the parent.
+
+if (process.argv[2] === 'child') {
+  process.abort();
+} else {
+  const child = spawn(process.execPath, [__filename, 'child']);
+  child.on('exit', common.mustCall((code, signal) => {
+    assert.strictEqual(code, 134);
+    assert.strictEqual(signal, null);
+  }));
+}
diff --git a/test/js/node/test/parallel/test-windows-failed-heap-allocation.js b/test/js/node/test/parallel/test-windows-failed-heap-allocation.js
new file mode 100644
index 0000000000..be901b7dc2
--- /dev/null
+++ b/test/js/node/test/parallel/test-windows-failed-heap-allocation.js
@@ -0,0 +1,28 @@
+'use strict';
+const common = require('../common');
+
+// This test ensures that an out of memory error exits with code 134 on Windows
+
+if (!common.isWindows) return common.skip('Windows-only');
+
+const assert = require('assert');
+const { exec } = require('child_process');
+
+if (process.argv[2] === 'heapBomb') {
+  // Heap bomb, imitates a memory leak quickly
+  const fn = (nM) => [...Array(nM)].map((i) => fn(nM * 2));
+  fn(2);
+}
+
+// Run child in tmpdir to avoid report files in repo
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+// --max-old-space-size=3 is the min 'old space' in V8, explodes fast
+const cmd = `"${process.execPath}" --max-old-space-size=30 "${__filename}"`;
+exec(`${cmd} heapBomb`, { cwd: tmpdir.path }, common.mustCall((err, stdout, stderr) => {
+  const msg = `Wrong exit code of ${err.code}! Expected 134 for abort`;
+  // Note: common.nodeProcessAborted() is not asserted here because it
+  // returns true on 134 as well as 0x80000003 (V8's base::OS::Abort)
+  assert.strictEqual(err.code, 134, msg);
+}));
diff --git a/test/js/node/test/parallel/test-worker-arraybuffer-zerofill.js b/test/js/node/test/parallel/test-worker-arraybuffer-zerofill.js
new file mode 100644
index 0000000000..3dcf4c006e
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker-arraybuffer-zerofill.js
@@ -0,0 +1,33 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const { Worker } = require('worker_threads');
+
+// Make sure that allocating uninitialized ArrayBuffers in one thread does not
+// affect the zero-initialization in other threads.
+
+const w = new Worker(`
+const { parentPort } = require('worker_threads');
+
+function post() {
+  const uint32array = new Uint32Array(64);
+  parentPort.postMessage(uint32array.reduce((a, b) => a + b));
+}
+
+setInterval(post, 0);
+`, { eval: true });
+
+function allocBuffers() {
+  Buffer.allocUnsafe(32 * 1024 * 1024);
+}
+
+const interval = setInterval(allocBuffers, 0);
+
+let messages = 0;
+w.on('message', (sum) => {
+  assert.strictEqual(sum, 0);
+  if (messages++ === 100) {
+    clearInterval(interval);
+    w.terminate();
+  }
+});
diff --git a/test/js/node/test/parallel/test-worker-cjs-workerdata.js b/test/js/node/test/parallel/test-worker-cjs-workerdata.js
new file mode 100644
index 0000000000..949011fee8
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker-cjs-workerdata.js
@@ -0,0 +1,15 @@
+'use strict';
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+const { Worker } = require('worker_threads');
+
+const workerData = 'Hello from main thread';
+
+const worker = new Worker(fixtures.path('worker-data.cjs'), {
+  workerData
+});
+
+worker.on('message', common.mustCall((message) => {
+  assert.strictEqual(message, workerData);
+}));
diff --git a/test/js/node/test/parallel/test-worker-cleanexit-with-js.js b/test/js/node/test/parallel/test-worker-cleanexit-with-js.js
new file mode 100644
index 0000000000..b4725e297a
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker-cleanexit-with-js.js
@@ -0,0 +1,21 @@
+'use strict';
+const common = require('../common');
+
+// Harden the thread interactions on the exit path.
+// Ensure workers are able to bail out safe at
+// arbitrary execution points. By running a lot of
+// JS code in a tight loop, the expectation
+// is that those will be at various control flow points
+// preferably in the JS land.
+
+const { Worker } = require('worker_threads');
+const code = 'setInterval(() => {' +
+      "require('v8').deserialize(require('v8').serialize({ foo: 'bar' }));" +
+      "require('vm').runInThisContext('x = \"foo\";');" +
+      "eval('const y = \"vm\";');}, 10);";
+for (let i = 0; i < 9; i++) {
+  new Worker(code, { eval: true });
+}
+new Worker(code, { eval: true }).on('online', common.mustCall((msg) => {
+  process.exit(0);
+}));
diff --git a/test/js/node/test/parallel/test-worker-cleanexit-with-moduleload.js b/test/js/node/test/parallel/test-worker-cleanexit-with-moduleload.js
new file mode 100644
index 0000000000..f2e8ad786f
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker-cleanexit-with-moduleload.js
@@ -0,0 +1,29 @@
+'use strict';
+const common = require('../common');
+
+// Harden the thread interactions on the exit path.
+// Ensure workers are able to bail out safe at
+// arbitrary execution points. By using a number of
+// internal modules as load candidates, the expectation
+// is that those will be at various control flow points
+// preferably in the C++ land.
+
+const { Worker } = require('worker_threads');
+const modules = [ 'fs', 'assert', 'async_hooks', 'buffer', 'child_process',
+                  'net', 'http', 'os', 'path', 'v8', 'vm',
+];
+if (common.hasCrypto) {
+  modules.push('https');
+}
+
+for (let i = 0; i < 10; i++) {
+  new Worker(`const modules = [${modules.map((m) => `'${m}'`)}];` +
+    'modules.forEach((module) => {' +
+    'const m = require(module);' +
+    '});', { eval: true });
+}
+
+// Allow workers to go live.
+setTimeout(() => {
+  process.exit(0);
+}, 200);
diff --git a/test/js/node/test/parallel/test-worker-esm-exit.js b/test/js/node/test/parallel/test-worker-esm-exit.js
new file mode 100644
index 0000000000..8c38faf3b7
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker-esm-exit.js
@@ -0,0 +1,11 @@
+'use strict';
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+const { Worker } = require('worker_threads');
+
+const w = new Worker(fixtures.path('es-modules/import-process-exit.mjs'));
+w.on('error', common.mustNotCall());
+w.on('exit',
+     common.mustCall((code) => assert.strictEqual(code, 42))
+);
diff --git a/test/js/node/test/parallel/test-worker-esmodule.js b/test/js/node/test/parallel/test-worker-esmodule.js
new file mode 100644
index 0000000000..e7f9bd7aea
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker-esmodule.js
@@ -0,0 +1,10 @@
+'use strict';
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+const { Worker } = require('worker_threads');
+
+const w = new Worker(fixtures.path('worker-script.mjs'));
+w.on('message', common.mustCall((message) => {
+  assert.strictEqual(message, 'Hello, world!');
+}));
diff --git a/test/js/node/test/parallel/test-worker-exit-event-error.js b/test/js/node/test/parallel/test-worker-exit-event-error.js
new file mode 100644
index 0000000000..e2427c7dff
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker-exit-event-error.js
@@ -0,0 +1,8 @@
+'use strict';
+const common = require('../common');
+const { Worker } = require('worker_threads');
+
+process.on('uncaughtException', common.mustCall());
+
+new Worker('', { eval: true })
+  .on('exit', common.mustCall(() => { throw new Error('foo'); }));
diff --git a/test/js/node/test/parallel/test-worker-exit-from-uncaught-exception.js b/test/js/node/test/parallel/test-worker-exit-from-uncaught-exception.js
new file mode 100644
index 0000000000..b9f8aeee97
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker-exit-from-uncaught-exception.js
@@ -0,0 +1,23 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const { Worker } = require('worker_threads');
+
+// Check that `process.exit()` can be called inside a Worker from an uncaught
+// exception handler.
+
+// Do not use isMainThread so that this test itself can be run inside a Worker.
+if (!process.env.HAS_STARTED_WORKER) {
+  process.env.HAS_STARTED_WORKER = 1;
+  const w = new Worker(__filename);
+  w.on('exit', common.mustCall((code) => {
+    assert.strictEqual(code, 42);
+  }));
+  return;
+}
+
+process.on('uncaughtException', () => {
+  process.exit(42);
+});
+
+throw new Error();
diff --git a/test/js/node/test/parallel/test-worker-fs-stat-watcher.js b/test/js/node/test/parallel/test-worker-fs-stat-watcher.js
new file mode 100644
index 0000000000..c648792af7
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker-fs-stat-watcher.js
@@ -0,0 +1,17 @@
+'use strict';
+const common = require('../common');
+const { Worker, parentPort } = require('worker_threads');
+const fs = require('fs');
+
+// Checks that terminating Workers does not crash the process if fs.watchFile()
+// has active handles.
+
+// Do not use isMainThread so that this test itself can be run inside a Worker.
+if (!process.env.HAS_STARTED_WORKER) {
+  process.env.HAS_STARTED_WORKER = 1;
+  const worker = new Worker(__filename);
+  worker.on('message', common.mustCall(() => worker.terminate()));
+} else {
+  fs.watchFile(__filename, () => {});
+  parentPort.postMessage('running');
+}
diff --git a/test/js/node/test/parallel/test-worker-http2-generic-streams-terminate.js b/test/js/node/test/parallel/test-worker-http2-generic-streams-terminate.js
new file mode 100644
index 0000000000..234697fb4d
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker-http2-generic-streams-terminate.js
@@ -0,0 +1,39 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const http2 = require('http2');
+const { Duplex } = require('stream');
+const { Worker, workerData } = require('worker_threads');
+
+// Tests the interaction between terminating a Worker thread and running
+// the native SetImmediate queue, which may attempt to perform multiple
+// calls into JS even though one already terminates the Worker.
+
+if (!workerData) {
+  const counter = new Int32Array(new SharedArrayBuffer(4));
+  const worker = new Worker(__filename, { workerData: { counter } });
+  worker.on('exit', common.mustCall(() => {
+    assert.strictEqual(counter[0], 1);
+  }));
+} else {
+  const { counter } = workerData;
+
+  // Start two HTTP/2 connections. This will trigger write()s call from inside
+  // the SetImmediate queue.
+  for (let i = 0; i < 2; i++) {
+    http2.connect('http://localhost', {
+      createConnection() {
+        return new Duplex({
+          write(chunk, enc, cb) {
+            Atomics.add(counter, 0, 1);
+            process.exit();
+          },
+          read() { }
+        });
+      }
+    });
+  }
+}
diff --git a/test/js/node/test/parallel/test-worker-invalid-workerdata.js b/test/js/node/test/parallel/test-worker-invalid-workerdata.js
new file mode 100644
index 0000000000..08fd78bdc0
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker-invalid-workerdata.js
@@ -0,0 +1,14 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const { Worker } = require('worker_threads');
+
+// This tests verifies that failing to serialize workerData does not keep
+// the process alive.
+// Refs: https://github.com/nodejs/node/issues/22736
+
+assert.throws(() => {
+  new Worker('./worker.js', {
+    workerData: { fn: () => {} }
+  });
+}, /DataCloneError/);
diff --git a/test/js/node/test/parallel/test-worker-load-file-with-extension-other-than-js.js b/test/js/node/test/parallel/test-worker-load-file-with-extension-other-than-js.js
new file mode 100644
index 0000000000..5dca297576
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker-load-file-with-extension-other-than-js.js
@@ -0,0 +1,9 @@
+'use strict';
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+
+const { Worker } = require('worker_threads');
+
+(common.mustCall(() => {
+  new Worker(fixtures.path('worker-script.ts'));
+}))();
diff --git a/test/js/node/test/parallel/test-worker-message-port-infinite-message-loop.js b/test/js/node/test/parallel/test-worker-message-port-infinite-message-loop.js
new file mode 100644
index 0000000000..0cd1cc0680
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker-message-port-infinite-message-loop.js
@@ -0,0 +1,29 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+const { MessageChannel } = require('worker_threads');
+
+// Make sure that an infinite asynchronous .on('message')/postMessage loop
+// does not lead to a stack overflow and does not starve the event loop.
+// We schedule timeouts both from before the .on('message') handler and
+// inside of it, which both should run.
+
+const { port1, port2 } = new MessageChannel();
+let count = 0;
+port1.on('message', () => {
+  if (count === 0) {
+    setTimeout(common.mustCall(() => {
+      port1.close();
+    }), 0);
+  }
+
+  port2.postMessage(0);
+  assert(count++ < 10000, `hit ${count} loop iterations`);
+});
+
+port2.postMessage(0);
+
+// This is part of the test -- the event loop should be available and not stall
+// out due to the recursive .postMessage() calls.
+setTimeout(common.mustCall(), 0);
diff --git a/test/js/node/test/parallel/test-worker-message-port-transfer-terminate.js b/test/js/node/test/parallel/test-worker-message-port-transfer-terminate.js
new file mode 100644
index 0000000000..dddf91e3f3
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker-message-port-transfer-terminate.js
@@ -0,0 +1,17 @@
+'use strict';
+require('../common');
+const { Worker, MessageChannel } = require('worker_threads');
+
+// Check the interaction of calling .terminate() while transferring
+// MessagePort objects; in particular, that it does not crash the process.
+
+for (let i = 0; i < 10; ++i) {
+  const w = new Worker(
+    "require('worker_threads').parentPort.on('message', () => {})",
+    { eval: true });
+  setImmediate(() => {
+    const port = new MessageChannel().port1;
+    w.postMessage({ port }, [ port ]);
+    w.terminate();
+  });
+}
diff --git a/test/js/node/test/parallel/test-worker-message-port-wasm-module.js b/test/js/node/test/parallel/test-worker-message-port-wasm-module.js
new file mode 100644
index 0000000000..b1aa522dc4
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker-message-port-wasm-module.js
@@ -0,0 +1,18 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const fixtures = require('../common/fixtures');
+
+const { Worker } = require('worker_threads');
+const wasmModule = new WebAssembly.Module(fixtures.readSync('simple.wasm'));
+
+const worker = new Worker(`
+const { parentPort } = require('worker_threads');
+parentPort.once('message', ({ wasmModule }) => {
+  const instance = new WebAssembly.Instance(wasmModule);
+  parentPort.postMessage(instance.exports.add(10, 20));
+});
+`, { eval: true });
+
+worker.once('message', common.mustCall((num) => assert.strictEqual(num, 30)));
+worker.postMessage({ wasmModule });
diff --git a/test/js/node/test/parallel/test-worker-mjs-workerdata.js b/test/js/node/test/parallel/test-worker-mjs-workerdata.js
new file mode 100644
index 0000000000..b0a65e2e80
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker-mjs-workerdata.js
@@ -0,0 +1,15 @@
+'use strict';
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+const { Worker } = require('worker_threads');
+
+const workerData = 'Hello from main thread';
+
+const worker = new Worker(fixtures.path('worker-data.mjs'), {
+  workerData
+});
+
+worker.on('message', common.mustCall((message) => {
+  assert.strictEqual(message, workerData);
+}));
diff --git a/test/js/node/test/parallel/test-worker-nested-on-process-exit.js b/test/js/node/test/parallel/test-worker-nested-on-process-exit.js
new file mode 100644
index 0000000000..aa544fa328
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker-nested-on-process-exit.js
@@ -0,0 +1,20 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const { Worker, workerData } = require('worker_threads');
+
+// Test that 'exit' events for nested Workers are not received when a Worker
+// terminates itself through process.exit().
+
+if (workerData === null) {
+  const nestedWorkerExitCounter = new Int32Array(new SharedArrayBuffer(4));
+  const w = new Worker(__filename, { workerData: nestedWorkerExitCounter });
+  w.on('exit', common.mustCall(() => {
+    assert.strictEqual(nestedWorkerExitCounter[0], 0);
+  }));
+} else {
+  const nestedWorker = new Worker('setInterval(() => {}, 100)', { eval: true });
+  // The counter should never be increased here.
+  nestedWorker.on('exit', () => workerData[0]++);
+  nestedWorker.on('online', () => process.exit());
+}
diff --git a/test/js/node/test/parallel/test-worker-no-sab.js b/test/js/node/test/parallel/test-worker-no-sab.js
new file mode 100644
index 0000000000..e96c987484
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker-no-sab.js
@@ -0,0 +1,21 @@
+// Flags: --enable-sharedarraybuffer-per-context
+
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { Worker } = require('worker_threads');
+
+// Regression test for https://github.com/nodejs/node/issues/39717.
+
+// Do not use isMainThread so that this test itself can be run inside a Worker.
+if (!process.env.HAS_STARTED_WORKER) {
+  process.env.HAS_STARTED_WORKER = 1;
+  const w = new Worker(__filename);
+
+  w.on('exit', common.mustCall((status) => {
+    assert.strictEqual(status, 2);
+  }));
+} else {
+  process.exit(2);
+}
diff --git a/test/js/node/test/parallel/test-worker-non-fatal-uncaught-exception.js b/test/js/node/test/parallel/test-worker-non-fatal-uncaught-exception.js
new file mode 100644
index 0000000000..01df55eec1
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker-non-fatal-uncaught-exception.js
@@ -0,0 +1,25 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const { Worker } = require('worker_threads');
+
+// Check that `process._fatalException()` returns a boolean when run inside a
+// worker.
+
+// Do not use isMainThread so that this test itself can be run inside a Worker.
+if (!process.env.HAS_STARTED_WORKER) {
+  process.env.HAS_STARTED_WORKER = 1;
+  const w = new Worker(__filename);
+  w.on('exit', common.mustCall((code) => {
+    assert.strictEqual(code, 0);
+  }));
+  return;
+}
+
+process.once('uncaughtException', () => {
+  process.nextTick(() => {
+    assert.strictEqual(res, true);
+  });
+});
+
+const res = process._fatalException(new Error());
diff --git a/test/js/node/test/parallel/test-worker-on-process-exit.js b/test/js/node/test/parallel/test-worker-on-process-exit.js
new file mode 100644
index 0000000000..ec1c4affd1
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker-on-process-exit.js
@@ -0,0 +1,22 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+const { Worker } = require('worker_threads');
+
+// Test that 'exit' events for Workers are not received when the main thread
+// terminates itself through process.exit().
+
+if (process.argv[2] !== 'child') {
+  const {
+    stdout, stderr, status
+  } = spawnSync(process.execPath, [__filename, 'child'], { encoding: 'utf8' });
+  assert.strictEqual(stderr, '');
+  assert.strictEqual(stdout, '');
+  assert.strictEqual(status, 0);
+} else {
+  const nestedWorker = new Worker('setInterval(() => {}, 100)', { eval: true });
+  // This console.log() should never fire.
+  nestedWorker.on('exit', () => console.log('exit event received'));
+  nestedWorker.on('online', () => process.exit());
+}
diff --git a/test/js/node/test/parallel/test-worker-onmessage-not-a-function.js b/test/js/node/test/parallel/test-worker-onmessage-not-a-function.js
new file mode 100644
index 0000000000..df07353075
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker-onmessage-not-a-function.js
@@ -0,0 +1,25 @@
+// When MessagePort.onmessage is set to a value that is not a function, the
+// setter should call .unref() and .stop(), clearing a previous onmessage
+// listener from holding the event loop open. This test confirms that
+// functionality.
+
+'use strict';
+const common = require('../common');
+const { Worker, parentPort } = require('worker_threads');
+
+// Do not use isMainThread so that this test itself can be run inside a Worker.
+if (!process.env.HAS_STARTED_WORKER) {
+  process.env.HAS_STARTED_WORKER = 1;
+  const w = new Worker(__filename);
+  w.postMessage(2);
+} else {
+  // .onmessage uses a setter. Set .onmessage to a function that ultimately
+  // should not be called. This will call .ref() and .start() which will keep
+  // the event loop open (and prevent this from exiting) if the subsequent
+  // assignment of a value to .onmessage doesn't call .unref() and .stop().
+  parentPort.onmessage = common.mustNotCall();
+  // Setting `onmessage` to a value that is not a function should clear the
+  // previous value and also should allow the event loop to exit. (In other
+  // words, this test should exit rather than run indefinitely.)
+  parentPort.onmessage = 'fhqwhgads';
+}
diff --git a/test/js/node/test/parallel/test-worker-onmessage.js b/test/js/node/test/parallel/test-worker-onmessage.js
new file mode 100644
index 0000000000..3ed10755ce
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker-onmessage.js
@@ -0,0 +1,26 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const { Worker, parentPort } = require('worker_threads');
+
+// Do not use isMainThread so that this test itself can be run inside a Worker.
+if (!process.env.HAS_STARTED_WORKER) {
+  process.env.HAS_STARTED_WORKER = 1;
+  const w = new Worker(__filename);
+  const expectation = [ 4, undefined, null ];
+  const actual = [];
+  w.on('message', common.mustCall((message) => {
+    actual.push(message);
+    if (actual.length === expectation.length) {
+      assert.deepStrictEqual(expectation, actual);
+      w.terminate();
+    }
+  }, expectation.length));
+  w.postMessage(2);
+} else {
+  parentPort.onmessage = common.mustCall((message) => {
+    parentPort.postMessage(message.data * 2);
+    parentPort.postMessage(undefined);
+    parentPort.postMessage(null);
+  });
+}
diff --git a/test/js/node/test/parallel/test-worker-parent-port-ref.js b/test/js/node/test/parallel/test-worker-parent-port-ref.js
new file mode 100644
index 0000000000..c1e79b9faa
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker-parent-port-ref.js
@@ -0,0 +1,24 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const { isMainThread, parentPort, Worker } = require('worker_threads');
+
+// This test makes sure that we manipulate the references of
+// `parentPort` correctly so that any worker threads will
+// automatically exit when there are no any other references.
+{
+  if (isMainThread) {
+    const worker = new Worker(__filename);
+
+    worker.on('exit', common.mustCall((code) => {
+      assert.strictEqual(code, 0);
+    }), 1);
+
+    worker.on('online', common.mustCall());
+  } else {
+    const messageCallback = () => {};
+    parentPort.on('message', messageCallback);
+    // The thread won't exit if we don't make the 'message' listener off.
+    parentPort.off('message', messageCallback);
+  }
+}
diff --git a/test/js/node/test/parallel/test-worker-process-exit-async-module.js b/test/js/node/test/parallel/test-worker-process-exit-async-module.js
new file mode 100644
index 0000000000..38d4ad74c7
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker-process-exit-async-module.js
@@ -0,0 +1,11 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { Worker } = require('worker_threads');
+
+// Regression for https://github.com/nodejs/node/issues/43182.
+const w = new Worker(new URL('data:text/javascript,process.exit(1);await new Promise(()=>{ process.exit(2); })'));
+w.on('exit', common.mustCall((code) => {
+  assert.strictEqual(code, 1);
+}));
diff --git a/test/js/node/test/parallel/test-worker-ref-onexit.js b/test/js/node/test/parallel/test-worker-ref-onexit.js
new file mode 100644
index 0000000000..24c940f8c8
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker-ref-onexit.js
@@ -0,0 +1,12 @@
+'use strict';
+const common = require('../common');
+const { Worker } = require('worker_threads');
+
+// Check that worker.unref() makes the 'exit' event not be emitted, if it is
+// the only thing we would otherwise be waiting for.
+
+// Use `setInterval()` to make sure the worker is alive until the end of the
+// event loop turn.
+const w = new Worker('setInterval(() => {}, 100);', { eval: true });
+w.unref();
+w.on('exit', common.mustNotCall());
diff --git a/test/js/node/test/parallel/test-worker-ref.js b/test/js/node/test/parallel/test-worker-ref.js
new file mode 100644
index 0000000000..645fc0fbad
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker-ref.js
@@ -0,0 +1,29 @@
+'use strict';
+const common = require('../common');
+const { Worker } = require('worker_threads');
+
+// Test that calling worker.unref() leads to 'beforeExit' being emitted, and
+// that we can resurrect the worker using worker.ref() from there.
+
+const w = new Worker(`
+const { parentPort } = require('worker_threads');
+parentPort.once('message', (msg) => {
+  parentPort.postMessage(msg);
+});
+`, { eval: true });
+
+process.once('beforeExit', common.mustCall(() => {
+  console.log('beforeExit');
+  w.ref();
+  w.postMessage({ hello: 'world' });
+}));
+
+w.once('message', common.mustCall((msg) => {
+  console.log('message', msg);
+}));
+
+w.on('exit', common.mustCall(() => {
+  console.log('exit');
+}));
+
+w.unref();
diff --git a/test/js/node/test/parallel/test-worker-relative-path-double-dot.js b/test/js/node/test/parallel/test-worker-relative-path-double-dot.js
new file mode 100644
index 0000000000..86707c1590
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker-relative-path-double-dot.js
@@ -0,0 +1,16 @@
+'use strict';
+const common = require('../common');
+const path = require('path');
+const assert = require('assert');
+const { Worker, isMainThread, parentPort } = require('worker_threads');
+
+if (isMainThread) {
+  const cwdName = path.relative('../', '.');
+  const relativePath = path.relative('.', __filename);
+  const w = new Worker(path.join('..', cwdName, relativePath));
+  w.on('message', common.mustCall((message) => {
+    assert.strictEqual(message, 'Hello, world!');
+  }));
+} else {
+  parentPort.postMessage('Hello, world!');
+}
diff --git a/test/js/node/test/parallel/test-worker-relative-path.js b/test/js/node/test/parallel/test-worker-relative-path.js
new file mode 100644
index 0000000000..73dc5b3637
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker-relative-path.js
@@ -0,0 +1,14 @@
+'use strict';
+const common = require('../common');
+const path = require('path');
+const assert = require('assert');
+const { Worker, isMainThread, parentPort } = require('worker_threads');
+
+if (isMainThread) {
+  const w = new Worker(`./${path.relative('.', __filename)}`);
+  w.on('message', common.mustCall((message) => {
+    assert.strictEqual(message, 'Hello, world!');
+  }));
+} else {
+  parentPort.postMessage('Hello, world!');
+}
diff --git a/test/js/node/test/parallel/test-worker-safe-getters.js b/test/js/node/test/parallel/test-worker-safe-getters.js
new file mode 100644
index 0000000000..69856659a5
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker-safe-getters.js
@@ -0,0 +1,34 @@
+'use strict';
+
+const common = require('../common');
+
+const assert = require('assert');
+const { Worker, isMainThread } = require('worker_threads');
+
+if (isMainThread) {
+  const w = new Worker(__filename, {
+    stdin: true,
+    stdout: true,
+    stderr: true
+  });
+
+  const { stdin, stdout, stderr } = w;
+
+  w.on('exit', common.mustCall((code) => {
+    assert.strictEqual(code, 0);
+
+    // `postMessage` should not throw after termination
+    // (this mimics the browser behavior).
+    w.postMessage('foobar');
+    w.ref();
+    w.unref();
+
+    // Sanity check.
+    assert.strictEqual(w.threadId, -1);
+    assert.strictEqual(w.stdin, stdin);
+    assert.strictEqual(w.stdout, stdout);
+    assert.strictEqual(w.stderr, stderr);
+  }));
+} else {
+  process.exit(0);
+}
diff --git a/test/js/node/test/parallel/test-worker-sharedarraybuffer-from-worker-thread.js b/test/js/node/test/parallel/test-worker-sharedarraybuffer-from-worker-thread.js
new file mode 100644
index 0000000000..ce8410f6dd
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker-sharedarraybuffer-from-worker-thread.js
@@ -0,0 +1,28 @@
+// Flags: --debug-arraybuffer-allocations
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const { Worker } = require('worker_threads');
+
+// Regression test for https://github.com/nodejs/node/issues/28777
+// Make sure that SharedArrayBuffers and transferred ArrayBuffers created in
+// Worker threads are accessible after the creating thread ended.
+
+for (const ctor of ['ArrayBuffer', 'SharedArrayBuffer']) {
+  const w = new Worker(`
+  const { parentPort } = require('worker_threads');
+  const arrayBuffer = new ${ctor}(4);
+  parentPort.postMessage(
+    arrayBuffer,
+    '${ctor}' === 'SharedArrayBuffer' ? [] : [arrayBuffer]);
+  `, { eval: true });
+
+  let arrayBuffer;
+  w.once('message', common.mustCall((message) => arrayBuffer = message));
+  w.once('exit', common.mustCall(() => {
+    assert.strictEqual(arrayBuffer.constructor.name, ctor);
+    const uint8array = new Uint8Array(arrayBuffer);
+    uint8array[0] = 42;
+    assert.deepStrictEqual(uint8array, new Uint8Array([42, 0, 0, 0]));
+  }));
+}
diff --git a/test/js/node/test/parallel/test-worker-terminate-nested.js b/test/js/node/test/parallel/test-worker-terminate-nested.js
new file mode 100644
index 0000000000..3924528cea
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker-terminate-nested.js
@@ -0,0 +1,15 @@
+'use strict';
+const common = require('../common');
+const { Worker } = require('worker_threads');
+
+// Check that a Worker that's running another Worker can be terminated.
+
+const worker = new Worker(`
+const { Worker, parentPort } = require('worker_threads');
+const worker = new Worker('setInterval(() => {}, 10);', { eval: true });
+worker.on('online', () => {
+  parentPort.postMessage({});
+});
+`, { eval: true });
+
+worker.on('message', common.mustCall(() => worker.terminate()));
diff --git a/test/js/node/test/parallel/test-worker-terminate-null-handler.js b/test/js/node/test/parallel/test-worker-terminate-null-handler.js
new file mode 100644
index 0000000000..9db2e38b5c
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker-terminate-null-handler.js
@@ -0,0 +1,23 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const { Worker } = require('worker_threads');
+
+// Test that calling worker.terminate() if kHandler is null should return an
+// empty promise that resolves to undefined, even when a callback is passed
+
+const worker = new Worker(`
+const { parentPort } = require('worker_threads');
+parentPort.postMessage({ hello: 'world' });
+`, { eval: true });
+
+process.once('beforeExit', common.mustCall(() => worker.ref()));
+
+worker.on('exit', common.mustCall(() => {
+  worker.terminate().then((res) => assert.strictEqual(res, undefined));
+  worker.terminate(() => null).then(
+    (res) => assert.strictEqual(res, undefined)
+  );
+}));
+
+worker.unref();
diff --git a/test/js/node/test/parallel/test-worker-terminate-timers.js b/test/js/node/test/parallel/test-worker-terminate-timers.js
new file mode 100644
index 0000000000..62360a6cdb
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker-terminate-timers.js
@@ -0,0 +1,18 @@
+'use strict';
+const common = require('../common');
+const { Worker } = require('worker_threads');
+
+// Test that calling .terminate() during a timer callback works fine.
+
+for (const fn of ['setTimeout', 'setImmediate', 'setInterval']) {
+  const worker = new Worker(`
+  const { parentPort } = require('worker_threads');
+  ${fn}(() => {
+    require('worker_threads').parentPort.postMessage({});
+    while (true);
+  });`, { eval: true });
+
+  worker.on('message', common.mustCallAtLeast(() => {
+    worker.terminate();
+  }));
+}
diff --git a/test/js/node/test/parallel/test-worker-unref-from-message-during-exit.js b/test/js/node/test/parallel/test-worker-unref-from-message-during-exit.js
new file mode 100644
index 0000000000..3e696f369e
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker-unref-from-message-during-exit.js
@@ -0,0 +1,16 @@
+'use strict';
+const common = require('../common');
+const { Worker } = require('worker_threads');
+
+// This used to crash because the `.unref()` was unexpected while the Worker
+// was exiting.
+
+const w = new Worker(`
+require('worker_threads').parentPort.postMessage({});
+`, { eval: true });
+w.on('message', common.mustCall(() => {
+  w.unref();
+}));
+
+// Wait a bit so that the 'message' event is emitted while the Worker exits.
+Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 100);
diff --git a/test/js/node/test/parallel/test-worker.js b/test/js/node/test/parallel/test-worker.js
new file mode 100644
index 0000000000..9154aaa12b
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker.js
@@ -0,0 +1,19 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const { Worker, isMainThread, parentPort } = require('worker_threads');
+
+const kTestString = 'Hello, world!';
+
+if (isMainThread) {
+  const w = new Worker(__filename);
+  w.on('message', common.mustCall((message) => {
+    assert.strictEqual(message, kTestString);
+  }));
+} else {
+  setImmediate(() => {
+    process.nextTick(() => {
+      parentPort.postMessage(kTestString);
+    });
+  });
+}
diff --git a/test/js/node/test/parallel/test-worker.mjs b/test/js/node/test/parallel/test-worker.mjs
new file mode 100644
index 0000000000..4ee3f7dc96
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker.mjs
@@ -0,0 +1,18 @@
+import { mustCall } from '../common/index.mjs';
+import assert from 'assert';
+import { Worker, isMainThread, parentPort } from 'worker_threads';
+
+const kTestString = 'Hello, world!';
+
+if (isMainThread) {
+  const w = new Worker(new URL(import.meta.url));
+  w.on('message', mustCall((message) => {
+    assert.strictEqual(message, kTestString);
+  }));
+} else {
+  setImmediate(() => {
+    process.nextTick(() => {
+      parentPort.postMessage(kTestString);
+    });
+  });
+}
diff --git a/test/js/node/test/parallel/test-zlib-brotli-16GB.js b/test/js/node/test/parallel/test-zlib-brotli-16GB.js
new file mode 100644
index 0000000000..9b894320e9
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-brotli-16GB.js
@@ -0,0 +1,23 @@
+'use strict';
+
+const common = require('../common');
+const { createBrotliDecompress } = require('node:zlib');
+const strictEqual = require('node:assert').strictEqual;
+const { getDefaultHighWaterMark } = require('stream');
+
+// This tiny HEX string is a 16GB file.
+// This test verifies that the stream actually stops.
+/* eslint-disable @stylistic/js/max-len */
+const content = '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';
+
+const buf = Buffer.from(content, 'hex');
+
+const decoder = createBrotliDecompress();
+decoder.end(buf);
+
+// We need to wait to verify that the libuv thread pool had time
+// to process the data and the buffer is not empty.
+setTimeout(common.mustCall(() => {
+  // There is only one chunk in the buffer
+  strictEqual(decoder._readableState.buffer.length, getDefaultHighWaterMark() / (16 * 1024));
+}), common.platformTimeout(500));
diff --git a/test/js/node/test/parallel/test-zlib-brotli-flush.js b/test/js/node/test/parallel/test-zlib-brotli-flush.js
new file mode 100644
index 0000000000..fd730bfacd
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-brotli-flush.js
@@ -0,0 +1,27 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const zlib = require('zlib');
+const fixtures = require('../common/fixtures');
+
+const file = fixtures.readSync('person.jpg');
+const chunkSize = 16;
+const deflater = new zlib.BrotliCompress();
+
+const chunk = file.slice(0, chunkSize);
+const expectedFull = Buffer.from('iweA/9j/4AAQSkZJRgABAQEASA==', 'base64');
+let actualFull;
+
+deflater.write(chunk, function() {
+  deflater.flush(function() {
+    const bufs = [];
+    let buf;
+    while ((buf = deflater.read()) !== null)
+      bufs.push(buf);
+    actualFull = Buffer.concat(bufs);
+  });
+});
+
+process.once('exit', function() {
+  assert.deepStrictEqual(actualFull, expectedFull);
+});
diff --git a/test/js/node/test/parallel/test-zlib-brotli-from-brotli.js b/test/js/node/test/parallel/test-zlib-brotli-from-brotli.js
new file mode 100644
index 0000000000..7e6bfb419e
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-brotli-from-brotli.js
@@ -0,0 +1,31 @@
+'use strict';
+// Test unzipping a file that was created with a non-node brotli lib,
+// piped in as fast as possible.
+
+const common = require('../common');
+const assert = require('assert');
+const zlib = require('zlib');
+const fixtures = require('../common/fixtures');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+const decompress = new zlib.BrotliDecompress();
+
+const fs = require('fs');
+
+const fixture = fixtures.path('person.jpg.br');
+const unzippedFixture = fixtures.path('person.jpg');
+const outputFile = tmpdir.resolve('person.jpg');
+const expect = fs.readFileSync(unzippedFixture);
+const inp = fs.createReadStream(fixture);
+const out = fs.createWriteStream(outputFile);
+
+inp.pipe(decompress).pipe(out);
+out.on('close', common.mustCall(() => {
+  const actual = fs.readFileSync(outputFile);
+  assert.strictEqual(actual.length, expect.length);
+  for (let i = 0, l = actual.length; i < l; i++) {
+    assert.strictEqual(actual[i], expect[i], `byte[${i}]`);
+  }
+}));
diff --git a/test/js/node/test/parallel/test-zlib-brotli-from-string.js b/test/js/node/test/parallel/test-zlib-brotli-from-string.js
new file mode 100644
index 0000000000..30be44517a
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-brotli-from-string.js
@@ -0,0 +1,38 @@
+'use strict';
+// Test compressing and uncompressing a string with brotli
+
+const common = require('../common');
+const assert = require('assert');
+const zlib = require('zlib');
+
+const inputString = 'ΩΩLorem ipsum dolor sit amet, consectetur adipiscing eli' +
+                    't. Morbi faucibus, purus at gravida dictum, libero arcu ' +
+                    'convallis lacus, in commodo libero metus eu nisi. Nullam' +
+                    ' commodo, neque nec porta placerat, nisi est fermentum a' +
+                    'ugue, vitae gravida tellus sapien sit amet tellus. Aenea' +
+                    'n non diam orci. Proin quis elit turpis. Suspendisse non' +
+                    ' diam ipsum. Suspendisse nec ullamcorper odio. Vestibulu' +
+                    'm arcu mi, sodales non suscipit id, ultrices ut massa. S' +
+                    'ed ac sem sit amet arcu malesuada fermentum. Nunc sed. ';
+const compressedString = 'G/gBQBwHdky2aHV5KK9Snf05//1pPdmNw/7232fnIm1IB' +
+                         'K1AA8RsN8OB8Nb7Lpgk3UWWUlzQXZyHQeBBbXMTQXC1j7' +
+                         'wg3LJs9LqOGHRH2bj/a2iCTLLx8hBOyTqgoVuD1e+Qqdn' +
+                         'f1rkUNyrWq6LtOhWgxP3QUwdhKGdZm3rJWaDDBV7+pDk1' +
+                         'MIkrmjp4ma2xVi5MsgJScA3tP1I7mXeby6MELozrwoBQD' +
+                         'mVTnEAicZNj4lkGqntJe2qSnGyeMmcFgraK94vCg/4iLu' +
+                         'Tw5RhKhnVY++dZ6niUBmRqIutsjf5TzwF5iAg8a9UkjF5' +
+                         '2eZ0tB2vo6v8SqVfNMkBmmhxr0NT9LkYF69aEjlYzj7IE' +
+                         'KmEUQf1HBogRYhFIt4ymRNEgHAIzOyNEsQM=';
+
+zlib.brotliCompress(inputString, common.mustCall((err, buffer) => {
+  assert(inputString.length > buffer.length);
+
+  zlib.brotliDecompress(buffer, common.mustCall((err, buffer) => {
+    assert.strictEqual(buffer.toString(), inputString);
+  }));
+}));
+
+const buffer = Buffer.from(compressedString, 'base64');
+zlib.brotliDecompress(buffer, common.mustCall((err, buffer) => {
+  assert.strictEqual(buffer.toString(), inputString);
+}));
diff --git a/test/js/node/test/parallel/test-zlib-brotli-kmaxlength-rangeerror.js b/test/js/node/test/parallel/test-zlib-brotli-kmaxlength-rangeerror.js
new file mode 100644
index 0000000000..6a59ad34b0
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-brotli-kmaxlength-rangeerror.js
@@ -0,0 +1,28 @@
+'use strict';
+require('../common');
+
+// This test ensures that zlib throws a RangeError if the final buffer needs to
+// be larger than kMaxLength and concatenation fails.
+// https://github.com/nodejs/node/pull/1811
+
+const assert = require('assert');
+
+// Change kMaxLength for zlib to trigger the error without having to allocate
+// large Buffers.
+const buffer = require('buffer');
+const oldkMaxLength = buffer.kMaxLength;
+buffer.kMaxLength = 64;
+const zlib = require('zlib');
+buffer.kMaxLength = oldkMaxLength;
+
+const encoded = Buffer.from('G38A+CXCIrFAIAM=', 'base64');
+
+// Async
+zlib.brotliDecompress(encoded, function(err) {
+  assert.ok(err instanceof RangeError);
+});
+
+// Sync
+assert.throws(function() {
+  zlib.brotliDecompressSync(encoded);
+}, RangeError);
diff --git a/test/js/node/test/parallel/test-zlib-brotli.js b/test/js/node/test/parallel/test-zlib-brotli.js
new file mode 100644
index 0000000000..ef31db3dd6
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-brotli.js
@@ -0,0 +1,94 @@
+'use strict';
+require('../common');
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+const zlib = require('zlib');
+
+// Test some brotli-specific properties of the brotli streams that can not
+// be easily covered through expanding zlib-only tests.
+
+const sampleBuffer = fixtures.readSync('/pss-vectors.json');
+
+{
+  // Test setting the quality parameter at stream creation:
+  const sizes = [];
+  for (let quality = zlib.constants.BROTLI_MIN_QUALITY;
+    quality <= zlib.constants.BROTLI_MAX_QUALITY;
+    quality++) {
+    const encoded = zlib.brotliCompressSync(sampleBuffer, {
+      params: {
+        [zlib.constants.BROTLI_PARAM_QUALITY]: quality
+      }
+    });
+    sizes.push(encoded.length);
+  }
+
+  // Increasing quality should roughly correspond to decreasing compressed size:
+  for (let i = 0; i < sizes.length - 1; i++) {
+    assert(sizes[i + 1] <= sizes[i] * 1.05, sizes);  // 5 % margin of error.
+  }
+  assert(sizes[0] > sizes[sizes.length - 1], sizes);
+}
+
+{
+  // Test that setting out-of-bounds option values or keys fails.
+  assert.throws(() => {
+    zlib.createBrotliCompress({
+      params: {
+        10000: 0
+      }
+    });
+  }, {
+    code: 'ERR_BROTLI_INVALID_PARAM',
+    name: 'RangeError',
+    message: '10000 is not a valid Brotli parameter'
+  });
+
+  // Test that accidentally using duplicate keys fails.
+  assert.throws(() => {
+    zlib.createBrotliCompress({
+      params: {
+        '0': 0,
+        '00': 0
+      }
+    });
+  }, {
+    code: 'ERR_BROTLI_INVALID_PARAM',
+    name: 'RangeError',
+    message: '00 is not a valid Brotli parameter'
+  });
+
+  assert.throws(() => {
+    zlib.createBrotliCompress({
+      params: {
+        // This is a boolean flag
+        [zlib.constants.BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING]: 42
+      }
+    });
+  }, {
+    code: 'ERR_ZLIB_INITIALIZATION_FAILED',
+    name: 'Error',
+    message: 'Initialization failed'
+  });
+}
+
+{
+  // Test options.flush range
+  assert.throws(() => {
+    zlib.brotliCompressSync('', { flush: zlib.constants.Z_FINISH });
+  }, {
+    code: 'ERR_OUT_OF_RANGE',
+    name: 'RangeError',
+    message: 'The value of "options.flush" is out of range. It must be >= 0 ' +
+      'and <= 3. Received 4',
+  });
+
+  assert.throws(() => {
+    zlib.brotliCompressSync('', { finishFlush: zlib.constants.Z_FINISH });
+  }, {
+    code: 'ERR_OUT_OF_RANGE',
+    name: 'RangeError',
+    message: 'The value of "options.finishFlush" is out of range. It must be ' +
+      '>= 0 and <= 3. Received 4',
+  });
+}
diff --git a/test/js/node/test/parallel/test-zlib-close-after-error.js b/test/js/node/test/parallel/test-zlib-close-after-error.js
new file mode 100644
index 0000000000..63d418be09
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-close-after-error.js
@@ -0,0 +1,16 @@
+'use strict';
+// https://github.com/nodejs/node/issues/6034
+
+const common = require('../common');
+const assert = require('assert');
+const zlib = require('zlib');
+
+const decompress = zlib.createGunzip(15);
+
+decompress.on('error', common.mustCall((err) => {
+  assert.strictEqual(decompress._closed, true);
+  decompress.close();
+}));
+
+assert.strictEqual(decompress._closed, false);
+decompress.write('something invalid');
diff --git a/test/js/node/test/parallel/test-zlib-close-after-write.js b/test/js/node/test/parallel/test-zlib-close-after-write.js
new file mode 100644
index 0000000000..211318dc5a
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-close-after-write.js
@@ -0,0 +1,30 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const zlib = require('zlib');
+
+zlib.gzip('hello', common.mustCall((err, out) => {
+  const unzip = zlib.createGunzip();
+  unzip.write(out);
+  unzip.close(common.mustCall());
+}));
diff --git a/test/js/node/test/parallel/test-zlib-close-in-ondata.js b/test/js/node/test/parallel/test-zlib-close-in-ondata.js
new file mode 100644
index 0000000000..44d996311d
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-close-in-ondata.js
@@ -0,0 +1,10 @@
+'use strict';
+
+const common = require('../common');
+const zlib = require('zlib');
+
+const ts = zlib.createGzip();
+const buf = Buffer.alloc(1024 * 1024 * 20);
+
+ts.on('data', common.mustCall(() => ts.close()));
+ts.end(buf);
diff --git a/test/js/node/test/parallel/test-zlib-const.js b/test/js/node/test/parallel/test-zlib-const.js
new file mode 100644
index 0000000000..342c8c712a
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-const.js
@@ -0,0 +1,38 @@
+/* eslint-disable strict */
+require('../common');
+const assert = require('assert');
+
+const zlib = require('zlib');
+
+assert.strictEqual(zlib.constants.Z_OK, 0,
+                   [
+                     'Expected Z_OK to be 0;',
+                     `got ${zlib.constants.Z_OK}`,
+                   ].join(' '));
+zlib.constants.Z_OK = 1;
+assert.strictEqual(zlib.constants.Z_OK, 0,
+                   [
+                     'Z_OK should be immutable.',
+                     `Expected to get 0, got ${zlib.constants.Z_OK}`,
+                   ].join(' '));
+
+assert.strictEqual(zlib.codes.Z_OK, 0,
+                   `Expected Z_OK to be 0; got ${zlib.codes.Z_OK}`);
+zlib.codes.Z_OK = 1;
+assert.strictEqual(zlib.codes.Z_OK, 0,
+                   [
+                     'Z_OK should be immutable.',
+                     `Expected to get 0, got ${zlib.codes.Z_OK}`,
+                   ].join(' '));
+zlib.codes = { Z_OK: 1 };
+assert.strictEqual(zlib.codes.Z_OK, 0,
+                   [
+                     'Z_OK should be immutable.',
+                     `Expected to get 0, got ${zlib.codes.Z_OK}`,
+                   ].join(' '));
+
+assert.ok(Object.isFrozen(zlib.codes),
+          [
+            'Expected zlib.codes to be frozen, but Object.isFrozen',
+            `returned ${Object.isFrozen(zlib.codes)}`,
+          ].join(' '));
diff --git a/test/js/node/test/parallel/test-zlib-convenience-methods.js b/test/js/node/test/parallel/test-zlib-convenience-methods.js
new file mode 100644
index 0000000000..01ec7e211b
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-convenience-methods.js
@@ -0,0 +1,133 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+// Test convenience methods with and without options supplied
+
+const common = require('../common');
+const assert = require('assert');
+const zlib = require('zlib');
+
+// Must be a multiple of 4 characters in total to test all ArrayBufferView
+// types.
+const expectStr = 'blah'.repeat(8);
+const expectBuf = Buffer.from(expectStr);
+
+const opts = {
+  level: 9,
+  chunkSize: 1024,
+};
+
+const optsInfo = {
+  info: true
+};
+
+for (const [type, expect] of [
+  ['string', expectStr],
+  ['Buffer', expectBuf],
+  ...common.getBufferSources(expectBuf).map((obj) =>
+    [obj[Symbol.toStringTag], obj]
+  ),
+]) {
+  for (const method of [
+    ['gzip', 'gunzip', 'Gzip', 'Gunzip'],
+    ['gzip', 'unzip', 'Gzip', 'Unzip'],
+    ['deflate', 'inflate', 'Deflate', 'Inflate'],
+    ['deflateRaw', 'inflateRaw', 'DeflateRaw', 'InflateRaw'],
+    ['brotliCompress', 'brotliDecompress',
+     'BrotliCompress', 'BrotliDecompress'],
+  ]) {
+    zlib[method[0]](expect, opts, common.mustCall((err, result) => {
+      zlib[method[1]](result, opts, common.mustCall((err, result) => {
+        assert.strictEqual(result.toString(), expectStr,
+                           `Should get original string after ${method[0]}/` +
+                           `${method[1]} ${type} with options.`);
+      }));
+    }));
+
+    zlib[method[0]](expect, common.mustCall((err, result) => {
+      zlib[method[1]](result, common.mustCall((err, result) => {
+        assert.strictEqual(result.toString(), expectStr,
+                           `Should get original string after ${method[0]}/` +
+                           `${method[1]} ${type} without options.`);
+      }));
+    }));
+
+    zlib[method[0]](expect, optsInfo, common.mustCall((err, result) => {
+      assert.ok(result.engine instanceof zlib[method[2]],
+                `Should get engine ${method[2]} after ${method[0]} ` +
+                `${type} with info option.`);
+
+      const compressed = result.buffer;
+      zlib[method[1]](compressed, optsInfo, common.mustCall((err, result) => {
+        assert.strictEqual(result.buffer.toString(), expectStr,
+                           `Should get original string after ${method[0]}/` +
+                           `${method[1]} ${type} with info option.`);
+        assert.ok(result.engine instanceof zlib[method[3]],
+                  `Should get engine ${method[3]} after ${method[0]} ` +
+                  `${type} with info option.`);
+      }));
+    }));
+
+    {
+      const compressed = zlib[`${method[0]}Sync`](expect, opts);
+      const decompressed = zlib[`${method[1]}Sync`](compressed, opts);
+      assert.strictEqual(decompressed.toString(), expectStr,
+                         `Should get original string after ${method[0]}Sync/` +
+                         `${method[1]}Sync ${type} with options.`);
+    }
+
+
+    {
+      const compressed = zlib[`${method[0]}Sync`](expect);
+      const decompressed = zlib[`${method[1]}Sync`](compressed);
+      assert.strictEqual(decompressed.toString(), expectStr,
+                         `Should get original string after ${method[0]}Sync/` +
+                         `${method[1]}Sync ${type} without options.`);
+    }
+
+
+    {
+      const compressed = zlib[`${method[0]}Sync`](expect, optsInfo);
+      assert.ok(compressed.engine instanceof zlib[method[2]],
+                `Should get engine ${method[2]} after ${method[0]} ` +
+                `${type} with info option.`);
+      const decompressed = zlib[`${method[1]}Sync`](compressed.buffer,
+                                                    optsInfo);
+      assert.strictEqual(decompressed.buffer.toString(), expectStr,
+                         `Should get original string after ${method[0]}Sync/` +
+                         `${method[1]}Sync ${type} without options.`);
+      assert.ok(decompressed.engine instanceof zlib[method[3]],
+                `Should get engine ${method[3]} after ${method[0]} ` +
+                `${type} with info option.`);
+    }
+  }
+}
+
+assert.throws(
+  () => zlib.gzip('abc'),
+  {
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError',
+    message: 'The "callback" argument must be of type function. ' +
+             'Received undefined'
+  }
+);
diff --git a/test/js/node/test/parallel/test-zlib-crc32.js b/test/js/node/test/parallel/test-zlib-crc32.js
new file mode 100644
index 0000000000..fb8d4958ec
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-crc32.js
@@ -0,0 +1,211 @@
+'use strict';
+
+require('../common');
+const zlib = require('zlib');
+const assert = require('assert');
+const { Buffer } = require('buffer');
+
+// The following test data comes from
+// https://github.com/zlib-ng/zlib-ng/blob/5401b24/test/test_crc32.cc
+// test_crc32.cc -- crc32 unit test
+// Copyright (C) 2019-2021 IBM Corporation
+// Authors: Rogerio Alves    <rogealve@br.ibm.com>
+//          Matheus Castanho <msc@linux.ibm.com>
+// For conditions of distribution and use, see copyright notice in zlib.h
+//
+const tests = [
+  [0x0, 0x0, 0, 0x0],
+  [0xffffffff, 0x0, 0, 0x0],
+  [0x0, 0x0, 255, 0x0], /*  BZ 174799.  */
+  [0x0, 0x0, 256, 0x0],
+  [0x0, 0x0, 257, 0x0],
+  [0x0, 0x0, 32767, 0x0],
+  [0x0, 0x0, 32768, 0x0],
+  [0x0, 0x0, 32769, 0x0],
+  [0x0, '', 0, 0x0],
+  [0xffffffff, '', 0, 0xffffffff],
+  [0x0, 'abacus', 6, 0xc3d7115b],
+  [0x0, 'backlog', 7, 0x269205],
+  [0x0, 'campfire', 8, 0x22a515f8],
+  [0x0, 'delta', 5, 0x9643fed9],
+  [0x0, 'executable', 10, 0xd68eda01],
+  [0x0, 'file', 4, 0x8c9f3610],
+  [0x0, 'greatest', 8, 0xc1abd6cd],
+  [0x0, 'hello', 5, 0x3610a686],
+  [0x0, 'inverter', 8, 0xc9e962c9],
+  [0x0, 'jigsaw', 6, 0xce4e3f69],
+  [0x0, 'karate', 6, 0x890be0e2],
+  [0x0, 'landscape', 9, 0xc4e0330b],
+  [0x0, 'machine', 7, 0x1505df84],
+  [0x0, 'nanometer', 9, 0xd4e19f39],
+  [0x0, 'oblivion', 8, 0xdae9de77],
+  [0x0, 'panama', 6, 0x66b8979c],
+  [0x0, 'quest', 5, 0x4317f817],
+  [0x0, 'resource', 8, 0xbc91f416],
+  [0x0, 'secret', 6, 0x5ca2e8e5],
+  [0x0, 'test', 4, 0xd87f7e0c],
+  [0x0, 'ultimate', 8, 0x3fc79b0b],
+  [0x0, 'vector', 6, 0x1b6e485b],
+  [0x0, 'walrus', 6, 0xbe769b97],
+  [0x0, 'xeno', 4, 0xe7a06444],
+  [0x0, 'yelling', 7, 0xfe3944e5],
+  [0x0, 'zlib', 4, 0x73887d3a],
+  [0x0, '4BJD7PocN1VqX0jXVpWB', 20, 0xd487a5a1],
+  [0x0, 'F1rPWI7XvDs6nAIRx41l', 20, 0x61a0132e],
+  [0x0, 'ldhKlsVkPFOveXgkGtC2', 20, 0xdf02f76],
+  [0x0, '5KKnGOOrs8BvJ35iKTOS', 20, 0x579b2b0a],
+  [0x0, '0l1tw7GOcem06Ddu7yn4', 20, 0xf7d16e2d],
+  [0x0, 'MCr47CjPIn9R1IvE1Tm5', 20, 0x731788f5],
+  [0x0, 'UcixbzPKTIv0SvILHVdO', 20, 0x7112bb11],
+  [0x0, 'dGnAyAhRQDsWw0ESou24', 20, 0xf32a0dac],
+  [0x0, 'di0nvmY9UYMYDh0r45XT', 20, 0x625437bb],
+  [0x0, '2XKDwHfAhFsV0RhbqtvH', 20, 0x896930f9],
+  [0x0, 'ZhrANFIiIvRnqClIVyeD', 20, 0x8579a37],
+  [0x0, 'v7Q9ehzioTOVeDIZioT1', 20, 0x632aa8e0],
+  [0x0, 'Yod5hEeKcYqyhfXbhxj2', 20, 0xc829af29],
+  [0x0, 'GehSWY2ay4uUKhehXYb0', 20, 0x1b08b7e8],
+  [0x0, 'kwytJmq6UqpflV8Y8GoE', 20, 0x4e33b192],
+  [0x0, '70684206568419061514', 20, 0x59a179f0],
+  [0x0, '42015093765128581010', 20, 0xcd1013d7],
+  [0x0, '88214814356148806939', 20, 0xab927546],
+  [0x0, '43472694284527343838', 20, 0x11f3b20c],
+  [0x0, '49769333513942933689', 20, 0xd562d4ca],
+  [0x0, '54979784887993251199', 20, 0x233395f7],
+  [0x0, '58360544869206793220', 20, 0x2d167fd5],
+  [0x0, '27347953487840714234', 20, 0x8b5108ba],
+  [0x0, '07650690295365319082', 20, 0xc46b3cd8],
+  [0x0, '42655507906821911703', 20, 0xc10b2662],
+  [0x0, '29977409200786225655', 20, 0xc9a0f9d2],
+  [0x0, '85181542907229116674', 20, 0x9341357b],
+  [0x0, '87963594337989416799', 20, 0xf0424937],
+  [0x0, '21395988329504168551', 20, 0xd7c4c31f],
+  [0x0, '51991013580943379423', 20, 0xf11edcc4],
+  [0x0, '*]+@!);({_$;}[_},?{?;(_?,=-][@', 30, 0x40795df4],
+  [0x0, '_@:_).&(#.[:[{[:)$++-($_;@[)}+', 30, 0xdd61a631],
+  [0x0, '&[!,[$_==}+.]@!;*(+},[;:)$;)-@', 30, 0xca907a99],
+  [0x0, ']{.[.+?+[[=;[?}_#&;[=)__$$:+=_', 30, 0xf652deac],
+  [0x0, '-%.)=/[@].:.(:,()$;=%@-$?]{%+%', 30, 0xaf39a5a9],
+  [0x0, '+]#$(@&.=:,*];/.!]%/{:){:@(;)$', 30, 0x6bebb4cf],
+  // eslint-disable-next-line no-template-curly-in-string
+  [0x0, ')-._.:?[&:.=+}(*$/=!.${;(=$@!}', 30, 0x76430bac],
+  [0x0, ':(_*&%/[[}+,?#$&*+#[([*-/#;%(]', 30, 0x6c80c388],
+  [0x0, '{[#-;:$/{)(+[}#]/{&!%(@)%:@-$:', 30, 0xd54d977d],
+  [0x0, '_{$*,}(&,@.)):=!/%(&(,,-?$}}}!', 30, 0xe3966ad5],
+  [0x0,
+   'e$98KNzqaV)Y:2X?]77].{gKRD4G5{mHZk,Z)SpU%L3FSgv!Wb8MLAFdi{+fp)c,@8m6v)yXg@]HBDFk?.4&}g5_udE*JHCiH=aL',
+   100, 0xe7c71db9],
+  [0x0,
+   'r*Fd}ef+5RJQ;+W=4jTR9)R*p!B;]Ed7tkrLi;88U7g@3v!5pk2X6D)vt,.@N8c]@yyEcKi[vwUu@.Ppm@C6%Mv*3Nw}Y,58_aH)',
+   100, 0xeaa52777],
+  [0x0,
+   'h{bcmdC+a;t+Cf{6Y_dFq-{X4Yu&7uNfVDh?q&_u.UWJU],-GiH7ADzb7-V.Q%4=+v!$L9W+T=bP]$_:]Vyg}A.ygD.r;h-D]m%&',
+   100, 0xcd472048],
+  [0x7a30360d, 'abacus', 6, 0xf8655a84],
+  [0x6fd767ee, 'backlog', 7, 0x1ed834b1],
+  [0xefeb7589, 'campfire', 8, 0x686cfca],
+  [0x61cf7e6b, 'delta', 5, 0x1554e4b1],
+  [0xdc712e2, 'executable', 10, 0x761b4254],
+  [0xad23c7fd, 'file', 4, 0x7abdd09b],
+  [0x85cb2317, 'greatest', 8, 0x4ba91c6b],
+  [0x9eed31b0, 'inverter', 8, 0xd5e78ba5],
+  [0xb94f34ca, 'jigsaw', 6, 0x23649109],
+  [0xab058a2, 'karate', 6, 0xc5591f41],
+  [0x5bff2b7a, 'landscape', 9, 0xf10eb644],
+  [0x605c9a5f, 'machine', 7, 0xbaa0a636],
+  [0x51bdeea5, 'nanometer', 9, 0x6af89afb],
+  [0x85c21c79, 'oblivion', 8, 0xecae222b],
+  [0x97216f56, 'panama', 6, 0x47dffac4],
+  [0x18444af2, 'quest', 5, 0x70c2fe36],
+  [0xbe6ce359, 'resource', 8, 0x1471d925],
+  [0x843071f1, 'secret', 6, 0x50c9a0db],
+  [0xf2480c60, 'ultimate', 8, 0xf973daf8],
+  [0x2d2feb3d, 'vector', 6, 0x344ac03d],
+  [0x7490310a, 'walrus', 6, 0x6d1408ef],
+  [0x97d247d4, 'xeno', 4, 0xe62670b5],
+  [0x93cf7599, 'yelling', 7, 0x1b36da38],
+  [0x73c84278, 'zlib', 4, 0x6432d127],
+  [0x228a87d1, '4BJD7PocN1VqX0jXVpWB', 20, 0x997107d0],
+  [0xa7a048d0, 'F1rPWI7XvDs6nAIRx41l', 20, 0xdc567274],
+  [0x1f0ded40, 'ldhKlsVkPFOveXgkGtC2', 20, 0xdcc63870],
+  [0xa804a62f, '5KKnGOOrs8BvJ35iKTOS', 20, 0x6926cffd],
+  [0x508fae6a, '0l1tw7GOcem06Ddu7yn4', 20, 0xb52b38bc],
+  [0xe5adaf4f, 'MCr47CjPIn9R1IvE1Tm5', 20, 0xf83b8178],
+  [0x67136a40, 'UcixbzPKTIv0SvILHVdO', 20, 0xc5213070],
+  [0xb00c4a10, 'dGnAyAhRQDsWw0ESou24', 20, 0xbc7648b0],
+  [0x2e0c84b5, 'di0nvmY9UYMYDh0r45XT', 20, 0xd8123a72],
+  [0x81238d44, '2XKDwHfAhFsV0RhbqtvH', 20, 0xd5ac5620],
+  [0xf853aa92, 'ZhrANFIiIvRnqClIVyeD', 20, 0xceae099d],
+  [0x5a692325, 'v7Q9ehzioTOVeDIZioT1', 20, 0xb07d2b24],
+  [0x3275b9f, 'Yod5hEeKcYqyhfXbhxj2', 20, 0x24ce91df],
+  [0x38371feb, 'GehSWY2ay4uUKhehXYb0', 20, 0x707b3b30],
+  [0xafc8bf62, 'kwytJmq6UqpflV8Y8GoE', 20, 0x16abc6a9],
+  [0x9b07db73, '70684206568419061514', 20, 0xae1fb7b7],
+  [0xe75b214, '42015093765128581010', 20, 0xd4eecd2d],
+  [0x72d0fe6f, '88214814356148806939', 20, 0x4660ec7],
+  [0xf857a4b1, '43472694284527343838', 20, 0xfd8afdf7],
+  [0x54b8e14, '49769333513942933689', 20, 0xc6d1b5f2],
+  [0xd6aa5616, '54979784887993251199', 20, 0x32476461],
+  [0x11e63098, '58360544869206793220', 20, 0xd917cf1a],
+  [0xbe92385, '27347953487840714234', 20, 0x4ad14a12],
+  [0x49511de0, '07650690295365319082', 20, 0xe37b5c6c],
+  [0x3db13bc1, '42655507906821911703', 20, 0x7cc497f1],
+  [0xbb899bea, '29977409200786225655', 20, 0x99781bb2],
+  [0xf6cd9436, '85181542907229116674', 20, 0x132256a1],
+  [0x9109e6c3, '87963594337989416799', 20, 0xbfdb2c83],
+  [0x75770fc, '21395988329504168551', 20, 0x8d9d1e81],
+  [0x69b1d19b, '51991013580943379423', 20, 0x7b6d4404],
+  [0xc6132975, '*]+@!);({_$;}[_},?{?;(_?,=-][@', 30, 0x8619f010],
+  [0xd58cb00c, '_@:_).&(#.[:[{[:)$++-($_;@[)}+', 30, 0x15746ac3],
+  [0xb63b8caa, '&[!,[$_==}+.]@!;*(+},[;:)$;)-@', 30, 0xaccf812f],
+  [0x8a45a2b8, ']{.[.+?+[[=;[?}_#&;[=)__$$:+=_', 30, 0x78af45de],
+  [0xcbe95b78, '-%.)=/[@].:.(:,()$;=%@-$?]{%+%', 30, 0x25b06b59],
+  [0x4ef8a54b, '+]#$(@&.=:,*];/.!]%/{:){:@(;)$', 30, 0x4ba0d08f],
+  // eslint-disable-next-line no-template-curly-in-string
+  [0x76ad267a, ')-._.:?[&:.=+}(*$/=!.${;(=$@!}', 30, 0xe26b6aac],
+  [0x569e613c, ':(_*&%/[[}+,?#$&*+#[([*-/#;%(]', 30, 0x7e2b0a66],
+  [0x36aa61da, '{[#-;:$/{)(+[}#]/{&!%(@)%:@-$:', 30, 0xb3430dc7],
+  [0xf67222df, '_{$*,}(&,@.)):=!/%(&(,,-?$}}}!', 30, 0x626c17a],
+  [0x74b34fd3,
+   'e$98KNzqaV)Y:2X?]77].{gKRD4G5{mHZk,Z)SpU%L3FSgv!Wb8MLAFdi{+fp)c,@8m6v)yXg@]HBDFk?.4&}g5_udE*JHCiH=aL',
+   100, 0xccf98060],
+  [0x351fd770,
+   'r*Fd}ef+5RJQ;+W=4jTR9)R*p!B;]Ed7tkrLi;88U7g@3v!5pk2X6D)vt,.@N8c]@yyEcKi[vwUu@.Ppm@C6%Mv*3Nw}Y,58_aH)',
+   100, 0xd8b95312],
+  [0xc45aef77,
+   'h{bcmdC+a;t+Cf{6Y_dFq-{X4Yu&7uNfVDh?q&_u.UWJU],-GiH7ADzb7-V.Q%4=+v!$L9W+T=bP]$_:]Vyg}A.ygD.r;h-D]m%&',
+   100, 0xbb1c9912],
+  [0xc45aef77,
+   'h{bcmdC+a;t+Cf{6Y_dFq-{X4Yu&7uNfVDh?q&_u.UWJU],-GiH7ADzb7-V.Q%4=+v!$L9W+T=bP]$_:]Vyg}A.ygD.r;h-D]m%&' +
+    'h{bcmdC+a;t+Cf{6Y_dFq-{X4Yu&7uNfVDh?q&_u.UWJU],-GiH7ADzb7-V.Q%4=+v!$L9W+T=bP]$_:]Vyg}A.ygD.r;h-D]m%&' +
+    'h{bcmdC+a;t+Cf{6Y_dFq-{X4Yu&7uNfVDh?q&_u.UWJU],-GiH7ADzb7-V.Q%4=+v!$L9W+T=bP]$_:]Vyg}A.ygD.r;h-D]m%&' +
+    'h{bcmdC+a;t+Cf{6Y_dFq-{X4Yu&7uNfVDh?q&_u.UWJU],-GiH7ADzb7-V.Q%4=+v!$L9W+T=bP]$_:]Vyg}A.ygD.r;h-D]m%&' +
+    'h{bcmdC+a;t+Cf{6Y_dFq-{X4Yu&7uNfVDh?q&_u.UWJU],-GiH7ADzb7-V.Q%4=+v!$L9W+T=bP]$_:]Vyg}A.ygD.r;h-D]m%&' +
+    'h{bcmdC+a;t+Cf{6Y_dFq-{X4Yu&7uNfVDh?q&_u.UWJU],-GiH7ADzb7-V.Q%4=+v!$L9W+T=bP]$_:]Vyg}A.ygD.r;h-D]m%&',
+   600, 0x888AFA5B],
+];
+
+for (const [ crc, data, len, expected ] of tests) {
+  if (data === 0) {
+    continue;
+  }
+  const buf = Buffer.from(data, 'utf8');
+  assert.strictEqual(buf.length, len);
+  assert.strictEqual(zlib.crc32(buf, crc), expected,
+                     `crc32('${data}', ${crc}) in buffer is not ${expected}`);
+  assert.strictEqual(zlib.crc32(buf.toString(), crc), expected,
+                     `crc32('${data}', ${crc}) in string is not ${expected}`);
+  if (crc === 0) {
+    assert.strictEqual(zlib.crc32(buf), expected,
+                       `crc32('${data}') in buffer is not ${expected}`);
+    assert.strictEqual(zlib.crc32(buf.toString()), expected,
+                       `crc32('${data}') in string is not ${expected}`);
+  }
+}
+
+[undefined, null, true, 1, () => {}, {}].forEach((invalid) => {
+  assert.throws(() => { zlib.crc32(invalid); }, { code: 'ERR_INVALID_ARG_TYPE' });
+});
+
+[null, true, () => {}, {}].forEach((invalid) => {
+  assert.throws(() => { zlib.crc32('test', invalid); }, { code: 'ERR_INVALID_ARG_TYPE' });
+});
diff --git a/test/js/node/test/parallel/test-zlib-create-raw.js b/test/js/node/test/parallel/test-zlib-create-raw.js
new file mode 100644
index 0000000000..92e21545e4
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-create-raw.js
@@ -0,0 +1,15 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const zlib = require('zlib');
+
+{
+  const inflateRaw = zlib.createInflateRaw();
+  assert(inflateRaw instanceof zlib.InflateRaw);
+}
+
+{
+  const deflateRaw = zlib.createDeflateRaw();
+  assert(deflateRaw instanceof zlib.DeflateRaw);
+}
diff --git a/test/js/node/test/parallel/test-zlib-deflate-raw-inherits.js b/test/js/node/test/parallel/test-zlib-deflate-raw-inherits.js
new file mode 100644
index 0000000000..34bf31058a
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-deflate-raw-inherits.js
@@ -0,0 +1,27 @@
+'use strict';
+
+require('../common');
+const { DeflateRaw } = require('zlib');
+const { Readable } = require('stream');
+
+// Validates that zlib.DeflateRaw can be inherited
+// with Object.setPrototypeOf
+
+function NotInitialized(options) {
+  DeflateRaw.call(this, options);
+  this.prop = true;
+}
+Object.setPrototypeOf(NotInitialized.prototype, DeflateRaw.prototype);
+Object.setPrototypeOf(NotInitialized, DeflateRaw);
+
+const dest = new NotInitialized();
+
+const read = new Readable({
+  read() {
+    this.push(Buffer.from('a test string'));
+    this.push(null);
+  }
+});
+
+read.pipe(dest);
+dest.resume();
diff --git a/test/js/node/test/parallel/test-zlib-destroy-pipe.js b/test/js/node/test/parallel/test-zlib-destroy-pipe.js
new file mode 100644
index 0000000000..67821a21b6
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-destroy-pipe.js
@@ -0,0 +1,21 @@
+'use strict';
+
+const common = require('../common');
+const zlib = require('zlib');
+const { Writable } = require('stream');
+
+// Verify that the zlib transform does not error in case
+// it is destroyed with data still in flight
+
+const ts = zlib.createGzip();
+
+const ws = new Writable({
+  write: common.mustCall((chunk, enc, cb) => {
+    setImmediate(cb);
+    ts.destroy();
+  })
+});
+
+const buf = Buffer.allocUnsafe(1024 * 1024 * 20);
+ts.end(buf);
+ts.pipe(ws);
diff --git a/test/js/node/test/parallel/test-zlib-destroy.js b/test/js/node/test/parallel/test-zlib-destroy.js
new file mode 100644
index 0000000000..775b7020b4
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-destroy.js
@@ -0,0 +1,31 @@
+'use strict';
+
+const common = require('../common');
+
+const assert = require('assert');
+const zlib = require('zlib');
+
+// Verify that the zlib transform does clean up
+// the handle when calling destroy.
+
+{
+  const ts = zlib.createGzip();
+  ts.destroy();
+  assert.strictEqual(ts._handle, null);
+
+  ts.on('close', common.mustCall(() => {
+    ts.close(common.mustCall());
+  }));
+}
+
+{
+  // Ensure 'error' is only emitted once.
+  const decompress = zlib.createGunzip(15);
+
+  decompress.on('error', common.mustCall((err) => {
+    decompress.close();
+  }));
+
+  decompress.write('something invalid');
+  decompress.destroy(new Error('asd'));
+}
diff --git a/test/js/node/test/parallel/test-zlib-dictionary-fail.js b/test/js/node/test/parallel/test-zlib-dictionary-fail.js
new file mode 100644
index 0000000000..9546954841
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-dictionary-fail.js
@@ -0,0 +1,60 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const zlib = require('zlib');
+
+// String "test" encoded with dictionary "dict".
+const input = Buffer.from([0x78, 0xBB, 0x04, 0x09, 0x01, 0xA5]);
+
+{
+  const stream = zlib.createInflate();
+
+  stream.on('error', common.mustCall(function(err) {
+    assert.match(err.message, /Missing dictionary/);
+  }));
+
+  stream.write(input);
+}
+
+{
+  const stream = zlib.createInflate({ dictionary: Buffer.from('fail') });
+
+  stream.on('error', common.mustCall(function(err) {
+    assert.match(err.message, /Bad dictionary/);
+  }));
+
+  stream.write(input);
+}
+
+{
+  const stream = zlib.createInflateRaw({ dictionary: Buffer.from('fail') });
+
+  stream.on('error', common.mustCall(function(err) {
+    // It's not possible to separate invalid dict and invalid data when using
+    // the raw format
+    assert.match(err.message, /(invalid|Operation-Ending-Supplemental Code is 0x12)/);
+  }));
+
+  stream.write(input);
+}
diff --git a/test/js/node/test/parallel/test-zlib-dictionary.js b/test/js/node/test/parallel/test-zlib-dictionary.js
new file mode 100644
index 0000000000..49a01d5a03
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-dictionary.js
@@ -0,0 +1,175 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+// Test compression/decompression with dictionary
+
+const common = require('../common');
+const assert = require('assert');
+const zlib = require('zlib');
+
+const spdyDict = Buffer.from([
+  'optionsgetheadpostputdeletetraceacceptaccept-charsetaccept-encodingaccept-',
+  'languageauthorizationexpectfromhostif-modified-sinceif-matchif-none-matchi',
+  'f-rangeif-unmodifiedsincemax-forwardsproxy-authorizationrangerefererteuser',
+  '-agent10010120020120220320420520630030130230330430530630740040140240340440',
+  '5406407408409410411412413414415416417500501502503504505accept-rangesageeta',
+  'glocationproxy-authenticatepublicretry-afterservervarywarningwww-authentic',
+  'ateallowcontent-basecontent-encodingcache-controlconnectiondatetrailertran',
+  'sfer-encodingupgradeviawarningcontent-languagecontent-lengthcontent-locati',
+  'oncontent-md5content-rangecontent-typeetagexpireslast-modifiedset-cookieMo',
+  'ndayTuesdayWednesdayThursdayFridaySaturdaySundayJanFebMarAprMayJunJulAugSe',
+  'pOctNovDecchunkedtext/htmlimage/pngimage/jpgimage/gifapplication/xmlapplic',
+  'ation/xhtmltext/plainpublicmax-agecharset=iso-8859-1utf-8gzipdeflateHTTP/1',
+  '.1statusversionurl\0',
+].join(''));
+
+const input = [
+  'HTTP/1.1 200 Ok',
+  'Server: node.js',
+  'Content-Length: 0',
+  '',
+].join('\r\n');
+
+function basicDictionaryTest(spdyDict) {
+  let output = '';
+  const deflate = zlib.createDeflate({ dictionary: spdyDict });
+  const inflate = zlib.createInflate({ dictionary: spdyDict });
+  inflate.setEncoding('utf-8');
+
+  deflate.on('data', function(chunk) {
+    inflate.write(chunk);
+  });
+
+  inflate.on('data', function(chunk) {
+    output += chunk;
+  });
+
+  deflate.on('end', function() {
+    inflate.end();
+  });
+
+  inflate.on('end', common.mustCall(function() {
+    assert.strictEqual(input, output);
+  }));
+
+  deflate.write(input);
+  deflate.end();
+}
+
+function deflateResetDictionaryTest(spdyDict) {
+  let doneReset = false;
+  let output = '';
+  const deflate = zlib.createDeflate({ dictionary: spdyDict });
+  const inflate = zlib.createInflate({ dictionary: spdyDict });
+  inflate.setEncoding('utf-8');
+
+  deflate.on('data', function(chunk) {
+    if (doneReset)
+      inflate.write(chunk);
+  });
+
+  inflate.on('data', function(chunk) {
+    output += chunk;
+  });
+
+  deflate.on('end', function() {
+    inflate.end();
+  });
+
+  inflate.on('end', common.mustCall(function() {
+    assert.strictEqual(input, output);
+  }));
+
+  deflate.write(input);
+  deflate.flush(function() {
+    deflate.reset();
+    doneReset = true;
+    deflate.write(input);
+    deflate.end();
+  });
+}
+
+function rawDictionaryTest(spdyDict) {
+  let output = '';
+  const deflate = zlib.createDeflateRaw({ dictionary: spdyDict });
+  const inflate = zlib.createInflateRaw({ dictionary: spdyDict });
+  inflate.setEncoding('utf-8');
+
+  deflate.on('data', function(chunk) {
+    inflate.write(chunk);
+  });
+
+  inflate.on('data', function(chunk) {
+    output += chunk;
+  });
+
+  deflate.on('end', function() {
+    inflate.end();
+  });
+
+  inflate.on('end', common.mustCall(function() {
+    assert.strictEqual(input, output);
+  }));
+
+  deflate.write(input);
+  deflate.end();
+}
+
+function deflateRawResetDictionaryTest(spdyDict) {
+  let doneReset = false;
+  let output = '';
+  const deflate = zlib.createDeflateRaw({ dictionary: spdyDict });
+  const inflate = zlib.createInflateRaw({ dictionary: spdyDict });
+  inflate.setEncoding('utf-8');
+
+  deflate.on('data', function(chunk) {
+    if (doneReset)
+      inflate.write(chunk);
+  });
+
+  inflate.on('data', function(chunk) {
+    output += chunk;
+  });
+
+  deflate.on('end', function() {
+    inflate.end();
+  });
+
+  inflate.on('end', common.mustCall(function() {
+    assert.strictEqual(input, output);
+  }));
+
+  deflate.write(input);
+  deflate.flush(function() {
+    deflate.reset();
+    doneReset = true;
+    deflate.write(input);
+    deflate.end();
+  });
+}
+
+for (const dict of [spdyDict, ...common.getBufferSources(spdyDict)]) {
+  basicDictionaryTest(dict);
+  deflateResetDictionaryTest(dict);
+  rawDictionaryTest(dict);
+  deflateRawResetDictionaryTest(dict);
+}
diff --git a/test/js/node/test/parallel/test-zlib-empty-buffer.js b/test/js/node/test/parallel/test-zlib-empty-buffer.js
new file mode 100644
index 0000000000..27fd1340fd
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-empty-buffer.js
@@ -0,0 +1,26 @@
+'use strict';
+const common = require('../common');
+const zlib = require('zlib');
+const { inspect, promisify } = require('util');
+const assert = require('assert');
+const emptyBuffer = Buffer.alloc(0);
+
+(async function() {
+  for (const [ compress, decompress, method ] of [
+    [ zlib.deflateRawSync, zlib.inflateRawSync, 'raw sync' ],
+    [ zlib.deflateSync, zlib.inflateSync, 'deflate sync' ],
+    [ zlib.gzipSync, zlib.gunzipSync, 'gzip sync' ],
+    [ zlib.brotliCompressSync, zlib.brotliDecompressSync, 'br sync' ],
+    [ promisify(zlib.deflateRaw), promisify(zlib.inflateRaw), 'raw' ],
+    [ promisify(zlib.deflate), promisify(zlib.inflate), 'deflate' ],
+    [ promisify(zlib.gzip), promisify(zlib.gunzip), 'gzip' ],
+    [ promisify(zlib.brotliCompress), promisify(zlib.brotliDecompress), 'br' ],
+  ]) {
+    const compressed = await compress(emptyBuffer);
+    const decompressed = await decompress(compressed);
+    assert.deepStrictEqual(
+      emptyBuffer, decompressed,
+      `Expected ${inspect(compressed)} to match ${inspect(decompressed)} ` +
+      `to match for ${method}`);
+  }
+})().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-zlib-flush-drain-longblock.js b/test/js/node/test/parallel/test-zlib-flush-drain-longblock.js
new file mode 100644
index 0000000000..e2f56ec762
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-flush-drain-longblock.js
@@ -0,0 +1,27 @@
+'use strict';
+
+// Regression test for https://github.com/nodejs/node/issues/14523.
+// Checks that flushes interact properly with writableState.needDrain,
+// even if no flush callback was passed.
+
+const common = require('../common');
+const assert = require('assert');
+const zlib = require('zlib');
+
+const zipper = zlib.createGzip({ highWaterMark: 16384 });
+const unzipper = zlib.createGunzip();
+zipper.pipe(unzipper);
+
+zipper.write('A'.repeat(17000));
+zipper.flush();
+
+let received = 0;
+unzipper.on('data', common.mustCallAtLeast((d) => {
+  received += d.length;
+}, 2));
+
+// Properly `.end()`ing the streams would interfere with checking that
+// `.flush()` works.
+process.on('exit', () => {
+  assert.strictEqual(received, 17000);
+});
diff --git a/test/js/node/test/parallel/test-zlib-flush-drain.js b/test/js/node/test/parallel/test-zlib-flush-drain.js
new file mode 100644
index 0000000000..6993d2c9fe
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-flush-drain.js
@@ -0,0 +1,51 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const zlib = require('zlib');
+
+const bigData = Buffer.alloc(10240, 'x');
+
+const opts = {
+  level: 0,
+  highWaterMark: 16
+};
+
+const deflater = zlib.createDeflate(opts);
+
+// Shim deflater.flush so we can count times executed
+let flushCount = 0;
+let drainCount = 0;
+
+const flush = deflater.flush;
+deflater.flush = function(kind, callback) {
+  flushCount++;
+  flush.call(this, kind, callback);
+};
+
+deflater.write(bigData);
+
+const ws = deflater._writableState;
+const beforeFlush = ws.needDrain;
+let afterFlush = ws.needDrain;
+
+deflater.on('data', () => {
+});
+
+deflater.flush(function(err) {
+  afterFlush = ws.needDrain;
+});
+
+deflater.on('drain', function() {
+  drainCount++;
+});
+
+process.once('exit', function() {
+  assert.strictEqual(
+    beforeFlush, true);
+  assert.strictEqual(
+    afterFlush, false);
+  assert.strictEqual(
+    drainCount, 1);
+  assert.strictEqual(
+    flushCount, 1);
+});
diff --git a/test/js/node/test/parallel/test-zlib-flush-write-sync-interleaved.js b/test/js/node/test/parallel/test-zlib-flush-write-sync-interleaved.js
new file mode 100644
index 0000000000..f8387f4006
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-flush-write-sync-interleaved.js
@@ -0,0 +1,57 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const { createGzip, createGunzip, Z_PARTIAL_FLUSH } = require('zlib');
+
+// Verify that .flush() behaves like .write() in terms of ordering, e.g. in
+// a sequence like .write() + .flush() + .write() + .flush() each .flush() call
+// only affects the data written before it.
+// Refs: https://github.com/nodejs/node/issues/28478
+
+const compress = createGzip();
+const decompress = createGunzip();
+decompress.setEncoding('utf8');
+
+const events = [];
+const compressedChunks = [];
+
+for (const chunk of ['abc', 'def', 'ghi']) {
+  compress.write(chunk, common.mustCall(() => events.push({ written: chunk })));
+  compress.flush(Z_PARTIAL_FLUSH, common.mustCall(() => {
+    events.push('flushed');
+    const chunk = compress.read();
+    if (chunk !== null)
+      compressedChunks.push(chunk);
+  }));
+}
+
+compress.end(common.mustCall(() => {
+  events.push('compress end');
+  writeToDecompress();
+}));
+
+function writeToDecompress() {
+  // Write the compressed chunks to a decompressor, one by one, in order to
+  // verify that the flushes actually worked.
+  const chunk = compressedChunks.shift();
+  if (chunk === undefined) return decompress.end();
+  decompress.write(chunk, common.mustCall(() => {
+    events.push({ read: decompress.read() });
+    writeToDecompress();
+  }));
+}
+
+process.on('exit', () => {
+  assert.deepStrictEqual(events, [
+    { written: 'abc' },
+    'flushed',
+    { written: 'def' },
+    'flushed',
+    { written: 'ghi' },
+    'flushed',
+    'compress end',
+    { read: 'abc' },
+    { read: 'def' },
+    { read: 'ghi' },
+  ]);
+});
diff --git a/test/js/node/test/parallel/test-zlib-flush.js b/test/js/node/test/parallel/test-zlib-flush.js
new file mode 100644
index 0000000000..557775d509
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-flush.js
@@ -0,0 +1,36 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const zlib = require('zlib');
+const fixtures = require('../common/fixtures');
+
+const file = fixtures.readSync('person.jpg');
+const chunkSize = 16;
+const opts = { level: 0 };
+const deflater = zlib.createDeflate(opts);
+
+const chunk = file.slice(0, chunkSize);
+const expectedNone = Buffer.from([0x78, 0x01]);
+const blkhdr = Buffer.from([0x00, 0x10, 0x00, 0xef, 0xff]);
+const adler32 = Buffer.from([0x00, 0x00, 0x00, 0xff, 0xff]);
+const expectedFull = Buffer.concat([blkhdr, chunk, adler32]);
+let actualNone;
+let actualFull;
+
+deflater.write(chunk, function() {
+  deflater.flush(zlib.constants.Z_NO_FLUSH, function() {
+    actualNone = deflater.read();
+    deflater.flush(function() {
+      const bufs = [];
+      let buf;
+      while ((buf = deflater.read()) !== null)
+        bufs.push(buf);
+      actualFull = Buffer.concat(bufs);
+    });
+  });
+});
+
+process.once('exit', function() {
+  assert.deepStrictEqual(actualNone, expectedNone);
+  assert.deepStrictEqual(actualFull, expectedFull);
+});
diff --git a/test/js/node/test/parallel/test-zlib-from-concatenated-gzip.js b/test/js/node/test/parallel/test-zlib-from-concatenated-gzip.js
new file mode 100644
index 0000000000..1de36dacf9
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-from-concatenated-gzip.js
@@ -0,0 +1,83 @@
+'use strict';
+// Test unzipping a gzip file that contains multiple concatenated "members"
+
+const common = require('../common');
+const assert = require('assert');
+const zlib = require('zlib');
+const fs = require('fs');
+const fixtures = require('../common/fixtures');
+
+const abc = 'abc';
+const def = 'def';
+
+const abcEncoded = zlib.gzipSync(abc);
+const defEncoded = zlib.gzipSync(def);
+
+const data = Buffer.concat([
+  abcEncoded,
+  defEncoded,
+]);
+
+assert.strictEqual(zlib.gunzipSync(data).toString(), (abc + def));
+
+zlib.gunzip(data, common.mustSucceed((result) => {
+  assert.strictEqual(result.toString(), (abc + def));
+}));
+
+zlib.unzip(data, common.mustSucceed((result) => {
+  assert.strictEqual(result.toString(), (abc + def));
+}));
+
+// Multi-member support does not apply to zlib inflate/deflate.
+zlib.unzip(Buffer.concat([
+  zlib.deflateSync('abc'),
+  zlib.deflateSync('def'),
+]), common.mustSucceed((result) => {
+  assert.strictEqual(result.toString(), abc);
+}));
+
+// Files that have the "right" magic bytes for starting a new gzip member
+// in the middle of themselves, even if they are part of a single
+// regularly compressed member
+const pmmFileZlib = fixtures.path('pseudo-multimember-gzip.z');
+const pmmFileGz = fixtures.path('pseudo-multimember-gzip.gz');
+
+const pmmExpected = zlib.inflateSync(fs.readFileSync(pmmFileZlib));
+const pmmResultBuffers = [];
+
+fs.createReadStream(pmmFileGz)
+  .pipe(zlib.createGunzip())
+  .on('error', (err) => {
+    assert.ifError(err);
+  })
+  .on('data', (data) => pmmResultBuffers.push(data))
+  .on('finish', common.mustCall(() => {
+    // Result should match original random garbage
+    assert.deepStrictEqual(Buffer.concat(pmmResultBuffers), pmmExpected);
+  }));
+
+// Test that the next gzip member can wrap around the input buffer boundary
+[0, 1, 2, 3, 4, defEncoded.length].forEach((offset) => {
+  const resultBuffers = [];
+
+  const unzip = zlib.createGunzip()
+    .on('error', (err) => {
+      assert.ifError(err);
+    })
+    .on('data', (data) => resultBuffers.push(data))
+    .on('finish', common.mustCall(() => {
+      assert.strictEqual(
+        Buffer.concat(resultBuffers).toString(),
+        'abcdef',
+        `result should match original input (offset = ${offset})`
+      );
+    }));
+
+  // First write: write "abc" + the first bytes of "def"
+  unzip.write(Buffer.concat([
+    abcEncoded, defEncoded.slice(0, offset),
+  ]));
+
+  // Write remaining bytes of "def"
+  unzip.end(defEncoded.slice(offset));
+});
diff --git a/test/js/node/test/parallel/test-zlib-from-gzip.js b/test/js/node/test/parallel/test-zlib-from-gzip.js
new file mode 100644
index 0000000000..f8fbe16764
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-from-gzip.js
@@ -0,0 +1,52 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+// Test unzipping a file that was created with a non-node gzip lib,
+// piped in as fast as possible.
+
+const common = require('../common');
+const assert = require('assert');
+const zlib = require('zlib');
+const fixtures = require('../common/fixtures');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+const gunzip = zlib.createGunzip();
+
+const fs = require('fs');
+
+const fixture = fixtures.path('person.jpg.gz');
+const unzippedFixture = fixtures.path('person.jpg');
+const outputFile = tmpdir.resolve('person.jpg');
+const expect = fs.readFileSync(unzippedFixture);
+const inp = fs.createReadStream(fixture);
+const out = fs.createWriteStream(outputFile);
+
+inp.pipe(gunzip).pipe(out);
+out.on('close', common.mustCall(() => {
+  const actual = fs.readFileSync(outputFile);
+  assert.strictEqual(actual.length, expect.length);
+  for (let i = 0, l = actual.length; i < l; i++) {
+    assert.strictEqual(actual[i], expect[i], `byte[${i}]`);
+  }
+}));
diff --git a/test/js/node/test/parallel/test-zlib-from-string.js b/test/js/node/test/parallel/test-zlib-from-string.js
new file mode 100644
index 0000000000..92b6f86646
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-from-string.js
@@ -0,0 +1,83 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+// Test compressing and uncompressing a string with zlib
+
+const common = require('../common');
+const assert = require('assert');
+const zlib = require('zlib');
+
+const inputString = 'ΩΩLorem ipsum dolor sit amet, consectetur adipiscing eli' +
+                    't. Morbi faucibus, purus at gravida dictum, libero arcu ' +
+                    'convallis lacus, in commodo libero metus eu nisi. Nullam' +
+                    ' commodo, neque nec porta placerat, nisi est fermentum a' +
+                    'ugue, vitae gravida tellus sapien sit amet tellus. Aenea' +
+                    'n non diam orci. Proin quis elit turpis. Suspendisse non' +
+                    ' diam ipsum. Suspendisse nec ullamcorper odio. Vestibulu' +
+                    'm arcu mi, sodales non suscipit id, ultrices ut massa. S' +
+                    'ed ac sem sit amet arcu malesuada fermentum. Nunc sed. ';
+const expectedBase64Deflate = 'eJxdUUtOQzEMvMoc4OndgT0gJCT2buJWlpI4jePeqZfpmX' +
+                              'AKLRKbLOzx/HK73q6vOrhCunlF1qIDJhNUeW5I2ozT5OkD' +
+                              'lKWLJWkncJG5403HQXAkT3Jw29B9uIEmToMukglZ0vS6oc' +
+                              'iBh4JG8sV4oVLEUCitK2kxq1WzPnChHDzsaGKy491LofoA' +
+                              'bWh8do43oeuYhB5EPCjcLjzYJo48KrfQBvnJecNFJvHT1+' +
+                              'RSQsGoC7dn2t/xjhduTA1NWyQIZR0pbHwMDatnD+crPqKS' +
+                              'qGPHp1vnlsWM/07ubf7bheF7kqSj84Bm0R1fYTfaK8vqqq' +
+                              'fKBtNMhe3OZh6N95CTvMX5HJJi4xOVzCgUOIMSLH7wmeOH' +
+                              'aFE4RdpnGavKtrB5xzfO/Ll9';
+const expectedBase64Gzip = 'H4sIAAAAAAAAA11RS05DMQy8yhzg6d2BPSAkJPZu4laWkjiN4' +
+                           '96pl+mZcAotEpss7PH8crverq86uEK6eUXWogMmE1R5bkjajN' +
+                           'Pk6QOUpYslaSdwkbnjTcdBcCRPcnDb0H24gSZOgy6SCVnS9Lq' +
+                           'hyIGHgkbyxXihUsRQKK0raTGrVbM+cKEcPOxoYrLj3Uuh+gBt' +
+                           'aHx2jjeh65iEHkQ8KNwuPNgmjjwqt9AG+cl5w0Um8dPX5FJCw' +
+                           'agLt2fa3/GOF25MDU1bJAhlHSlsfAwNq2cP5ys+opKoY8enW+' +
+                           'eWxYz/Tu5t/tuF4XuSpKPzgGbRHV9hN9ory+qqp8oG00yF7c5' +
+                           'mHo33kJO8xfkckmLjE5XMKBQ4gxIsfvCZ44doUThF2mcZq8q2' +
+                           'sHnHNzRtagj5AQAA';
+
+zlib.deflate(inputString, common.mustCall((err, buffer) => {
+  zlib.inflate(buffer, common.mustCall((err, inflated) => {
+    assert.strictEqual(inflated.toString(), inputString);
+  }));
+}));
+
+zlib.gzip(inputString, common.mustCall((err, buffer) => {
+  // Can't actually guarantee that we'll get exactly the same
+  // deflated bytes when we compress a string, since the header
+  // depends on stuff other than the input string itself.
+  // However, decrypting it should definitely yield the same
+  // result that we're expecting, and this should match what we get
+  // from inflating the known valid deflate data.
+  zlib.gunzip(buffer, common.mustCall((err, gunzipped) => {
+    assert.strictEqual(gunzipped.toString(), inputString);
+  }));
+}));
+
+let buffer = Buffer.from(expectedBase64Deflate, 'base64');
+zlib.unzip(buffer, common.mustCall((err, buffer) => {
+  assert.strictEqual(buffer.toString(), inputString);
+}));
+
+buffer = Buffer.from(expectedBase64Gzip, 'base64');
+zlib.unzip(buffer, common.mustCall((err, buffer) => {
+  assert.strictEqual(buffer.toString(), inputString);
+}));
diff --git a/test/js/node/test/parallel/test-zlib-invalid-arg-value-brotli-compress.js b/test/js/node/test/parallel/test-zlib-invalid-arg-value-brotli-compress.js
new file mode 100644
index 0000000000..688acddd16
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-invalid-arg-value-brotli-compress.js
@@ -0,0 +1,20 @@
+'use strict';
+
+require('../common');
+
+// This test ensures that the BrotliCompress function throws
+// ERR_INVALID_ARG_TYPE when the values of the `params` key-value object are
+// neither numbers nor booleans.
+
+const assert = require('assert');
+const { BrotliCompress, constants } = require('zlib');
+
+const opts = {
+  params: {
+    [constants.BROTLI_PARAM_MODE]: 'lol'
+  }
+};
+
+assert.throws(() => BrotliCompress(opts), {
+  code: 'ERR_INVALID_ARG_TYPE'
+});
diff --git a/test/js/node/test/parallel/test-zlib-invalid-input.js b/test/js/node/test/parallel/test-zlib-invalid-input.js
new file mode 100644
index 0000000000..7aa44dfe70
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-invalid-input.js
@@ -0,0 +1,60 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+// Test uncompressing invalid input
+
+const common = require('../common');
+const assert = require('assert');
+const zlib = require('zlib');
+
+const nonStringInputs = [
+  1,
+  true,
+  { a: 1 },
+  ['a'],
+];
+
+// zlib.Unzip classes need to get valid data, or else they'll throw.
+const unzips = [
+  zlib.Unzip(),
+  zlib.Gunzip(),
+  zlib.Inflate(),
+  zlib.InflateRaw(),
+  zlib.BrotliDecompress(),
+];
+
+nonStringInputs.forEach(common.mustCall((input) => {
+  assert.throws(() => {
+    zlib.gunzip(input);
+  }, {
+    name: 'TypeError',
+    code: 'ERR_INVALID_ARG_TYPE'
+  });
+}, nonStringInputs.length));
+
+unzips.forEach(common.mustCall((uz, i) => {
+  uz.on('error', common.mustCall());
+  uz.on('end', common.mustNotCall());
+
+  // This will trigger error event
+  uz.write('this is not valid compressed data.');
+}, unzips.length));
diff --git a/test/js/node/test/parallel/test-zlib-kmaxlength-rangeerror.js b/test/js/node/test/parallel/test-zlib-kmaxlength-rangeerror.js
new file mode 100644
index 0000000000..9803630214
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-kmaxlength-rangeerror.js
@@ -0,0 +1,28 @@
+'use strict';
+require('../common');
+
+// This test ensures that zlib throws a RangeError if the final buffer needs to
+// be larger than kMaxLength and concatenation fails.
+// https://github.com/nodejs/node/pull/1811
+
+const assert = require('assert');
+
+// Change kMaxLength for zlib to trigger the error without having to allocate
+// large Buffers.
+const buffer = require('buffer');
+const oldkMaxLength = buffer.kMaxLength;
+buffer.kMaxLength = 64;
+const zlib = require('zlib');
+buffer.kMaxLength = oldkMaxLength;
+
+const encoded = Buffer.from('H4sIAAAAAAAAA0tMHFgAAIw2K/GAAAAA', 'base64');
+
+// Async
+zlib.gunzip(encoded, function(err) {
+  assert.ok(err instanceof RangeError);
+});
+
+// Sync
+assert.throws(function() {
+  zlib.gunzipSync(encoded);
+}, RangeError);
diff --git a/test/js/node/test/parallel/test-zlib-maxOutputLength.js b/test/js/node/test/parallel/test-zlib-maxOutputLength.js
new file mode 100644
index 0000000000..9af0b3736f
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-maxOutputLength.js
@@ -0,0 +1,25 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const zlib = require('zlib');
+
+const encoded = Buffer.from('G38A+CXCIrFAIAM=', 'base64');
+
+// Async
+zlib.brotliDecompress(encoded, { maxOutputLength: 64 }, common.expectsError({
+  code: 'ERR_BUFFER_TOO_LARGE',
+  message: 'Cannot create a Buffer larger than 64 bytes'
+}));
+
+// Sync
+assert.throws(function() {
+  zlib.brotliDecompressSync(encoded, { maxOutputLength: 64 });
+}, RangeError);
+
+// Async
+zlib.brotliDecompress(encoded, { maxOutputLength: 256 }, function(err) {
+  assert.strictEqual(err, null);
+});
+
+// Sync
+zlib.brotliDecompressSync(encoded, { maxOutputLength: 256 });
diff --git a/test/js/node/test/parallel/test-zlib-no-stream.js b/test/js/node/test/parallel/test-zlib-no-stream.js
new file mode 100644
index 0000000000..68da269ab8
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-no-stream.js
@@ -0,0 +1,14 @@
+/* eslint-disable node-core/required-modules */
+/* eslint-disable node-core/require-common-first */
+
+'use strict';
+
+// We are not loading common because it will load the stream module,
+// defeating the purpose of this test.
+
+const { gzipSync } = require('zlib');
+
+// Avoid regressions such as https://github.com/nodejs/node/issues/36615
+
+// This must not throw
+gzipSync('fooobar');
diff --git a/test/js/node/test/parallel/test-zlib-object-write.js b/test/js/node/test/parallel/test-zlib-object-write.js
new file mode 100644
index 0000000000..2be5edab89
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-object-write.js
@@ -0,0 +1,14 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { Gunzip } = require('zlib');
+
+const gunzip = new Gunzip({ objectMode: true });
+gunzip.on('error', common.mustNotCall());
+assert.throws(() => {
+  gunzip.write({});
+}, {
+  name: 'TypeError',
+  code: 'ERR_INVALID_ARG_TYPE'
+});
diff --git a/test/js/node/test/parallel/test-zlib-params.js b/test/js/node/test/parallel/test-zlib-params.js
new file mode 100644
index 0000000000..18271fe022
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-params.js
@@ -0,0 +1,40 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const zlib = require('zlib');
+const fixtures = require('../common/fixtures');
+
+const file = fixtures.readSync('person.jpg');
+const chunkSize = 12 * 1024;
+const opts = { level: 9, strategy: zlib.constants.Z_DEFAULT_STRATEGY };
+const deflater = zlib.createDeflate(opts);
+
+const chunk1 = file.slice(0, chunkSize);
+const chunk2 = file.slice(chunkSize);
+const blkhdr = Buffer.from([0x00, 0x5a, 0x82, 0xa5, 0x7d]);
+const blkftr = Buffer.from('010000ffff7dac3072', 'hex');
+const expected = Buffer.concat([blkhdr, chunk2, blkftr]);
+const bufs = [];
+
+function read() {
+  let buf;
+  while ((buf = deflater.read()) !== null) {
+    bufs.push(buf);
+  }
+}
+
+deflater.write(chunk1, function() {
+  deflater.params(0, zlib.constants.Z_DEFAULT_STRATEGY, function() {
+    while (deflater.read());
+
+    deflater.on('readable', read);
+
+    deflater.end(chunk2);
+  });
+  while (deflater.read());
+});
+
+process.once('exit', function() {
+  const actual = Buffer.concat(bufs);
+  assert.deepStrictEqual(actual, expected);
+});
diff --git a/test/js/node/test/parallel/test-zlib-premature-end.js b/test/js/node/test/parallel/test-zlib-premature-end.js
new file mode 100644
index 0000000000..17446c907d
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-premature-end.js
@@ -0,0 +1,33 @@
+'use strict';
+const common = require('../common');
+const zlib = require('zlib');
+const assert = require('assert');
+
+const input = '0123456789'.repeat(4);
+
+for (const [ compress, decompressor ] of [
+  [ zlib.deflateRawSync, zlib.createInflateRaw ],
+  [ zlib.deflateSync, zlib.createInflate ],
+  [ zlib.brotliCompressSync, zlib.createBrotliDecompress ],
+]) {
+  const compressed = compress(input);
+  const trailingData = Buffer.from('not valid compressed data');
+
+  for (const variant of [
+    (stream) => { stream.end(compressed); },
+    (stream) => { stream.write(compressed); stream.write(trailingData); },
+    (stream) => { stream.write(compressed); stream.end(trailingData); },
+    (stream) => { stream.write(Buffer.concat([compressed, trailingData])); },
+    (stream) => { stream.end(Buffer.concat([compressed, trailingData])); },
+  ]) {
+    let output = '';
+    const stream = decompressor();
+    stream.setEncoding('utf8');
+    stream.on('data', (chunk) => output += chunk);
+    stream.on('end', common.mustCall(() => {
+      assert.strictEqual(output, input);
+      assert.strictEqual(stream.bytesWritten, compressed.length);
+    }));
+    variant(stream);
+  }
+}
diff --git a/test/js/node/test/parallel/test-zlib-random-byte-pipes.js b/test/js/node/test/parallel/test-zlib-random-byte-pipes.js
new file mode 100644
index 0000000000..d8d039a6d6
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-random-byte-pipes.js
@@ -0,0 +1,158 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const crypto = require('crypto');
+const stream = require('stream');
+const zlib = require('zlib');
+
+const Stream = stream.Stream;
+
+// Emit random bytes, and keep a shasum
+class RandomReadStream extends Stream {
+  constructor(opt) {
+    super();
+
+    this.readable = true;
+    this._paused = false;
+    this._processing = false;
+
+    this._hasher = crypto.createHash('sha1');
+    opt = opt || {};
+
+    // base block size.
+    opt.block = opt.block || 256 * 1024;
+
+    // Total number of bytes to emit
+    opt.total = opt.total || 256 * 1024 * 1024;
+    this._remaining = opt.total;
+
+    // How variable to make the block sizes
+    opt.jitter = opt.jitter || 1024;
+
+    this._opt = opt;
+
+    this._process = this._process.bind(this);
+
+    process.nextTick(this._process);
+  }
+
+  pause() {
+    this._paused = true;
+    this.emit('pause');
+  }
+
+  resume() {
+    // console.error("rrs resume");
+    this._paused = false;
+    this.emit('resume');
+    this._process();
+  }
+
+  _process() {
+    if (this._processing) return;
+    if (this._paused) return;
+
+    this._processing = true;
+
+    if (!this._remaining) {
+      this._hash = this._hasher.digest('hex').toLowerCase().trim();
+      this._processing = false;
+
+      this.emit('end');
+      return;
+    }
+
+    // Figure out how many bytes to output
+    // if finished, then just emit end.
+    let block = this._opt.block;
+    const jitter = this._opt.jitter;
+    if (jitter) {
+      block += Math.ceil(Math.random() * jitter - (jitter / 2));
+    }
+    block = Math.min(block, this._remaining);
+    const buf = Buffer.allocUnsafe(block);
+    for (let i = 0; i < block; i++) {
+      buf[i] = Math.random() * 256;
+    }
+
+    this._hasher.update(buf);
+
+    this._remaining -= block;
+
+    this._processing = false;
+
+    this.emit('data', buf);
+    process.nextTick(this._process);
+  }
+}
+
+// A filter that just verifies a shasum
+class HashStream extends Stream {
+  constructor() {
+    super();
+    this.readable = this.writable = true;
+    this._hasher = crypto.createHash('sha1');
+  }
+
+  write(c) {
+    // Simulate the way that an fs.ReadStream returns false
+    // on *every* write, only to resume a moment later.
+    this._hasher.update(c);
+    process.nextTick(() => this.resume());
+    return false;
+  }
+
+  resume() {
+    this.emit('resume');
+    process.nextTick(() => this.emit('drain'));
+  }
+
+  end(c) {
+    if (c) {
+      this.write(c);
+    }
+    this._hash = this._hasher.digest('hex').toLowerCase().trim();
+    this.emit('data', this._hash);
+    this.emit('end');
+  }
+}
+
+for (const [ createCompress, createDecompress ] of [
+  [ zlib.createGzip, zlib.createGunzip ],
+  [ zlib.createBrotliCompress, zlib.createBrotliDecompress ],
+]) {
+  const inp = new RandomReadStream({ total: 1024, block: 256, jitter: 16 });
+  const out = new HashStream();
+  const gzip = createCompress();
+  const gunz = createDecompress();
+
+  inp.pipe(gzip).pipe(gunz).pipe(out);
+
+  out.on('data', common.mustCall((c) => {
+    assert.strictEqual(c, inp._hash, `Hash '${c}' equals '${inp._hash}'.`);
+  }));
+}
diff --git a/test/js/node/test/parallel/test-zlib-reset-before-write.js b/test/js/node/test/parallel/test-zlib-reset-before-write.js
new file mode 100644
index 0000000000..afa207f12c
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-reset-before-write.js
@@ -0,0 +1,37 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const zlib = require('zlib');
+
+// Tests that zlib streams support .reset() and .params()
+// before the first write. That is important to ensure that
+// lazy init of zlib native library handles these cases.
+
+for (const fn of [
+  (z, cb) => {
+    z.reset();
+    cb();
+  },
+  (z, cb) => z.params(0, zlib.constants.Z_DEFAULT_STRATEGY, cb),
+]) {
+  const deflate = zlib.createDeflate();
+  const inflate = zlib.createInflate();
+
+  deflate.pipe(inflate);
+
+  const output = [];
+  inflate
+    .on('error', (err) => {
+      assert.ifError(err);
+    })
+    .on('data', (chunk) => output.push(chunk))
+    .on('end', common.mustCall(
+      () => assert.strictEqual(Buffer.concat(output).toString(), 'abc')));
+
+  fn(deflate, () => {
+    fn(inflate, () => {
+      deflate.write('abc');
+      deflate.end();
+    });
+  });
+}
diff --git a/test/js/node/test/parallel/test-zlib-sync-no-event.js b/test/js/node/test/parallel/test-zlib-sync-no-event.js
new file mode 100644
index 0000000000..e7f25c8476
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-sync-no-event.js
@@ -0,0 +1,19 @@
+'use strict';
+const common = require('../common');
+const zlib = require('zlib');
+const assert = require('assert');
+
+const message = 'Come on, Fhqwhgads.';
+const buffer = Buffer.from(message);
+
+const zipper = new zlib.Gzip();
+zipper.on('close', common.mustNotCall());
+
+const zipped = zipper._processChunk(buffer, zlib.constants.Z_FINISH);
+
+const unzipper = new zlib.Gunzip();
+unzipper.on('close', common.mustNotCall());
+
+const unzipped = unzipper._processChunk(zipped, zlib.constants.Z_FINISH);
+assert.notStrictEqual(zipped.toString(), message);
+assert.strictEqual(unzipped.toString(), message);
diff --git a/test/js/node/test/parallel/test-zlib-truncated.js b/test/js/node/test/parallel/test-zlib-truncated.js
new file mode 100644
index 0000000000..94bc0e21cb
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-truncated.js
@@ -0,0 +1,64 @@
+'use strict';
+// Tests zlib streams with truncated compressed input
+
+require('../common');
+const assert = require('assert');
+const zlib = require('zlib');
+
+const inputString = 'ΩΩLorem ipsum dolor sit amet, consectetur adipiscing eli' +
+                    't. Morbi faucibus, purus at gravida dictum, libero arcu ' +
+                    'convallis lacus, in commodo libero metus eu nisi. Nullam' +
+                    ' commodo, neque nec porta placerat, nisi est fermentum a' +
+                    'ugue, vitae gravida tellus sapien sit amet tellus. Aenea' +
+                    'n non diam orci. Proin quis elit turpis. Suspendisse non' +
+                    ' diam ipsum. Suspendisse nec ullamcorper odio. Vestibulu' +
+                    'm arcu mi, sodales non suscipit id, ultrices ut massa. S' +
+                    'ed ac sem sit amet arcu malesuada fermentum. Nunc sed. ';
+
+const errMessage = /unexpected end of file/;
+
+[
+  { comp: 'gzip', decomp: 'gunzip', decompSync: 'gunzipSync' },
+  { comp: 'gzip', decomp: 'unzip', decompSync: 'unzipSync' },
+  { comp: 'deflate', decomp: 'inflate', decompSync: 'inflateSync' },
+  { comp: 'deflateRaw', decomp: 'inflateRaw', decompSync: 'inflateRawSync' },
+].forEach(function(methods) {
+  zlib[methods.comp](inputString, function(err, compressed) {
+    assert.ifError(err);
+    const truncated = compressed.slice(0, compressed.length / 2);
+    const toUTF8 = (buffer) => buffer.toString('utf-8');
+
+    // sync sanity
+    const decompressed = zlib[methods.decompSync](compressed);
+    assert.strictEqual(toUTF8(decompressed), inputString);
+
+    // async sanity
+    zlib[methods.decomp](compressed, function(err, result) {
+      assert.ifError(err);
+      assert.strictEqual(toUTF8(result), inputString);
+    });
+
+    // Sync truncated input test
+    assert.throws(function() {
+      zlib[methods.decompSync](truncated);
+    }, errMessage);
+
+    // Async truncated input test
+    zlib[methods.decomp](truncated, function(err, result) {
+      assert.match(err.message, errMessage);
+    });
+
+    const syncFlushOpt = { finishFlush: zlib.constants.Z_SYNC_FLUSH };
+
+    // Sync truncated input test, finishFlush = Z_SYNC_FLUSH
+    const result = toUTF8(zlib[methods.decompSync](truncated, syncFlushOpt));
+    assert.strictEqual(result, inputString.slice(0, result.length));
+
+    // Async truncated input test, finishFlush = Z_SYNC_FLUSH
+    zlib[methods.decomp](truncated, syncFlushOpt, function(err, decompressed) {
+      assert.ifError(err);
+      const result = toUTF8(decompressed);
+      assert.strictEqual(result, inputString.slice(0, result.length));
+    });
+  });
+});
diff --git a/test/js/node/test/parallel/test-zlib-unzip-one-byte-chunks.js b/test/js/node/test/parallel/test-zlib-unzip-one-byte-chunks.js
new file mode 100644
index 0000000000..51af5153a4
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-unzip-one-byte-chunks.js
@@ -0,0 +1,30 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const zlib = require('zlib');
+
+const data = Buffer.concat([
+  zlib.gzipSync('abc'),
+  zlib.gzipSync('def'),
+]);
+
+const resultBuffers = [];
+
+const unzip = zlib.createUnzip()
+  .on('error', (err) => {
+    assert.ifError(err);
+  })
+  .on('data', (data) => resultBuffers.push(data))
+  .on('finish', common.mustCall(() => {
+    const unzipped = Buffer.concat(resultBuffers).toString();
+    assert.strictEqual(unzipped, 'abcdef',
+                       `'${unzipped}' should match 'abcdef' after zipping ` +
+                       'and unzipping');
+  }));
+
+for (let i = 0; i < data.length; i++) {
+  // Write each single byte individually.
+  unzip.write(Buffer.from([data[i]]));
+}
+
+unzip.end();
diff --git a/test/js/node/test/parallel/test-zlib-write-after-close.js b/test/js/node/test/parallel/test-zlib-write-after-close.js
new file mode 100644
index 0000000000..eb8ff43539
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-write-after-close.js
@@ -0,0 +1,34 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const zlib = require('zlib');
+
+zlib.gzip('hello', common.mustCall(function(err, out) {
+  const unzip = zlib.createGunzip();
+  unzip.close(common.mustCall());
+  unzip.write('asd', common.expectsError({
+    code: 'ERR_STREAM_DESTROYED',
+    name: 'Error',
+    message: 'Cannot call write after a stream was destroyed'
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-zlib-write-after-end.js b/test/js/node/test/parallel/test-zlib-write-after-end.js
new file mode 100644
index 0000000000..2b31ff30dc
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-write-after-end.js
@@ -0,0 +1,16 @@
+'use strict';
+const common = require('../common');
+const zlib = require('zlib');
+
+// Regression test for https://github.com/nodejs/node/issues/30976
+// Writes to a stream should finish even after the readable side has been ended.
+
+const data = zlib.deflateRawSync('Welcome');
+
+const inflate = zlib.createInflateRaw();
+
+inflate.resume();
+inflate.write(data, common.mustCall());
+inflate.write(Buffer.from([0x00]), common.mustCall());
+inflate.write(Buffer.from([0x00]), common.mustCall());
+inflate.flush(common.mustCall());
diff --git a/test/js/node/test/parallel/test-zlib-write-after-flush.js b/test/js/node/test/parallel/test-zlib-write-after-flush.js
new file mode 100644
index 0000000000..6edcae2e2f
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-write-after-flush.js
@@ -0,0 +1,49 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const zlib = require('zlib');
+
+for (const [ createCompress, createDecompress ] of [
+  [ zlib.createGzip, zlib.createGunzip ],
+  [ zlib.createBrotliCompress, zlib.createBrotliDecompress ],
+]) {
+  const gzip = createCompress();
+  const gunz = createDecompress();
+
+  gzip.pipe(gunz);
+
+  let output = '';
+  const input = 'A line of data\n';
+  gunz.setEncoding('utf8');
+  gunz.on('data', (c) => output += c);
+  gunz.on('end', common.mustCall(() => {
+    assert.strictEqual(output, input);
+  }));
+
+  // Make sure that flush/write doesn't trigger an assert failure
+  gzip.flush();
+  gzip.write(input);
+  gzip.end();
+  gunz.read(0);
+}
diff --git a/test/js/node/test/parallel/test-zlib-zero-byte.js b/test/js/node/test/parallel/test-zlib-zero-byte.js
new file mode 100644
index 0000000000..fc57960f1e
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-zero-byte.js
@@ -0,0 +1,43 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const zlib = require('zlib');
+
+for (const Compressor of [ zlib.Gzip, zlib.BrotliCompress ]) {
+  const gz = Compressor();
+  const emptyBuffer = Buffer.alloc(0);
+  let received = 0;
+  gz.on('data', function(c) {
+    received += c.length;
+  });
+
+  gz.on('end', common.mustCall(function() {
+    const expected = Compressor === zlib.Gzip ? 20 : 1;
+    assert.strictEqual(received, expected,
+                       `${received}, ${expected}, ${Compressor.name}`);
+  }));
+  gz.on('finish', common.mustCall());
+  gz.write(emptyBuffer);
+  gz.end();
+}
diff --git a/test/js/node/test/parallel/test-zlib-zero-windowBits.js b/test/js/node/test/parallel/test-zlib-zero-windowBits.js
new file mode 100644
index 0000000000..a27fd6734a
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib-zero-windowBits.js
@@ -0,0 +1,33 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const zlib = require('zlib');
+
+
+// windowBits is a special case in zlib. On the compression side, 0 is invalid.
+// On the decompression side, it indicates that zlib should use the value from
+// the header of the compressed stream.
+{
+  const inflate = zlib.createInflate({ windowBits: 0 });
+  assert(inflate instanceof zlib.Inflate);
+}
+
+{
+  const gunzip = zlib.createGunzip({ windowBits: 0 });
+  assert(gunzip instanceof zlib.Gunzip);
+}
+
+{
+  const unzip = zlib.createUnzip({ windowBits: 0 });
+  assert(unzip instanceof zlib.Unzip);
+}
+
+{
+  assert.throws(() => zlib.createGzip({ windowBits: 0 }), {
+    code: 'ERR_OUT_OF_RANGE',
+    name: 'RangeError',
+    message: 'The value of "options.windowBits" is out of range. ' +
+             'It must be >= 9 and <= 15. Received 0'
+  });
+}
diff --git a/test/js/node/test/parallel/test-zlib.js b/test/js/node/test/parallel/test-zlib.js
new file mode 100644
index 0000000000..65050b85a0
--- /dev/null
+++ b/test/js/node/test/parallel/test-zlib.js
@@ -0,0 +1,232 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const zlib = require('zlib');
+const stream = require('stream');
+const fs = require('fs');
+const fixtures = require('../common/fixtures');
+
+// Should not segfault.
+assert.throws(() => zlib.gzipSync(Buffer.alloc(0), { windowBits: 8 }), {
+  code: 'ERR_OUT_OF_RANGE',
+  name: 'RangeError',
+  message: 'The value of "options.windowBits" is out of range. ' +
+           'It must be >= 9 and <= 15. Received 8',
+});
+
+let zlibPairs = [
+  [zlib.Deflate, zlib.Inflate],
+  [zlib.Gzip, zlib.Gunzip],
+  [zlib.Deflate, zlib.Unzip],
+  [zlib.Gzip, zlib.Unzip],
+  [zlib.DeflateRaw, zlib.InflateRaw],
+  [zlib.BrotliCompress, zlib.BrotliDecompress],
+];
+
+// How fast to trickle through the slowstream
+let trickle = [128, 1024, 1024 * 1024];
+
+// Tunable options for zlib classes.
+
+// several different chunk sizes
+let chunkSize = [128, 1024, 1024 * 16, 1024 * 1024];
+
+// This is every possible value.
+let level = [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+let windowBits = [8, 9, 10, 11, 12, 13, 14, 15];
+let memLevel = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+let strategy = [0, 1, 2, 3, 4];
+
+// It's nice in theory to test every combination, but it
+// takes WAY too long.  Maybe a pummel test could do this?
+if (!process.env.PUMMEL) {
+  trickle = [1024];
+  chunkSize = [1024 * 16];
+  level = [6];
+  memLevel = [8];
+  windowBits = [15];
+  strategy = [0];
+}
+
+let testFiles = ['person.jpg', 'elipses.txt', 'empty.txt'];
+
+if (process.env.FAST) {
+  zlibPairs = [[zlib.Gzip, zlib.Unzip]];
+  testFiles = ['person.jpg'];
+}
+
+const tests = {};
+testFiles.forEach(common.mustCall((file) => {
+  tests[file] = fixtures.readSync(file);
+}, testFiles.length));
+
+
+// Stream that saves everything
+class BufferStream extends stream.Stream {
+  constructor() {
+    super();
+    this.chunks = [];
+    this.length = 0;
+    this.writable = true;
+    this.readable = true;
+  }
+
+  write(c) {
+    this.chunks.push(c);
+    this.length += c.length;
+    return true;
+  }
+
+  end(c) {
+    if (c) this.write(c);
+    // flatten
+    const buf = Buffer.allocUnsafe(this.length);
+    let i = 0;
+    this.chunks.forEach((c) => {
+      c.copy(buf, i);
+      i += c.length;
+    });
+    this.emit('data', buf);
+    this.emit('end');
+    return true;
+  }
+}
+
+class SlowStream extends stream.Stream {
+  constructor(trickle) {
+    super();
+    this.trickle = trickle;
+    this.offset = 0;
+    this.readable = this.writable = true;
+  }
+
+  write() {
+    throw new Error('not implemented, just call ss.end(chunk)');
+  }
+
+  pause() {
+    this.paused = true;
+    this.emit('pause');
+  }
+
+  resume() {
+    const emit = () => {
+      if (this.paused) return;
+      if (this.offset >= this.length) {
+        this.ended = true;
+        return this.emit('end');
+      }
+      const end = Math.min(this.offset + this.trickle, this.length);
+      const c = this.chunk.slice(this.offset, end);
+      this.offset += c.length;
+      this.emit('data', c);
+      process.nextTick(emit);
+    };
+
+    if (this.ended) return;
+    this.emit('resume');
+    if (!this.chunk) return;
+    this.paused = false;
+    emit();
+  }
+
+  end(chunk) {
+    // Walk over the chunk in blocks.
+    this.chunk = chunk;
+    this.length = chunk.length;
+    this.resume();
+    return this.ended;
+  }
+}
+
+// windowBits: 8 shouldn't throw
+zlib.createDeflateRaw({ windowBits: 8 });
+
+{
+  const node = fs.createReadStream(fixtures.path('person.jpg'));
+  const raw = [];
+  const reinflated = [];
+  node.on('data', (chunk) => raw.push(chunk));
+
+  // Usually, the inflate windowBits parameter needs to be at least the
+  // value of the matching deflate’s windowBits. However, inflate raw with
+  // windowBits = 8 should be able to handle compressed data from a source
+  // that does not know about the silent 8-to-9 upgrade of windowBits
+  // that most versions of zlib/Node perform, and which *still* results in
+  // a valid 8-bit-window zlib stream.
+  node.pipe(zlib.createDeflateRaw({ windowBits: 9 }))
+      .pipe(zlib.createInflateRaw({ windowBits: 8 }))
+      .on('data', (chunk) => reinflated.push(chunk))
+      .on('end', common.mustCall(
+        () => assert(Buffer.concat(raw).equals(Buffer.concat(reinflated)))))
+      .on('close', common.mustCall(1));
+}
+
+// For each of the files, make sure that compressing and
+// decompressing results in the same data, for every combination
+// of the options set above.
+
+const testKeys = Object.keys(tests);
+testKeys.forEach(common.mustCall((file) => {
+  const test = tests[file];
+  chunkSize.forEach(common.mustCall((chunkSize) => {
+    trickle.forEach(common.mustCall((trickle) => {
+      windowBits.forEach(common.mustCall((windowBits) => {
+        level.forEach(common.mustCall((level) => {
+          memLevel.forEach(common.mustCall((memLevel) => {
+            strategy.forEach(common.mustCall((strategy) => {
+              zlibPairs.forEach(common.mustCall((pair) => {
+                const Def = pair[0];
+                const Inf = pair[1];
+                const opts = { level, windowBits, memLevel, strategy };
+
+                const def = new Def(opts);
+                const inf = new Inf(opts);
+                const ss = new SlowStream(trickle);
+                const buf = new BufferStream();
+
+                // Verify that the same exact buffer comes out the other end.
+                buf.on('data', common.mustCall((c) => {
+                  const msg = `${file} ${chunkSize} ${
+                    JSON.stringify(opts)} ${Def.name} -> ${Inf.name}`;
+                  let i;
+                  for (i = 0; i < Math.max(c.length, test.length); i++) {
+                    if (c[i] !== test[i]) {
+                      assert.fail(msg);
+                      break;
+                    }
+                  }
+                }));
+
+                // The magic happens here.
+                ss.pipe(def).pipe(inf).pipe(buf);
+                ss.end(test);
+              }, zlibPairs.length));
+            }, strategy.length));
+          }, memLevel.length));
+        }, level.length));
+      }, windowBits.length));
+    }, trickle.length));
+  }, chunkSize.length));
+}, testKeys.length));
diff --git a/test/js/node/test/parallel/timer-immediate.test.js b/test/js/node/test/parallel/timer-immediate.test.js
deleted file mode 100644
index 1f74aa8bde..0000000000
--- a/test/js/node/test/parallel/timer-immediate.test.js
+++ /dev/null
@@ -1,19 +0,0 @@
-//#FILE: test-timer-immediate.js
-//#SHA1: 00e4e451b5feda969bd3352a194ba0ee0e5bab85
-//-----------------
-"use strict";
-
-// Note: We're not using the 'common' module as it's not necessary for this test
-
-test("setImmediate should be called", done => {
-  // Recreate the global.process object
-  global.process = {};
-
-  // Use setImmediate and expect it to be called
-  setImmediate(() => {
-    expect(true).toBe(true); // This assertion is just to ensure the callback is called
-    done();
-  });
-});
-
-//<#END_FILE: test-timer-immediate.js
diff --git a/test/js/node/test/parallel/timers-args.test.js b/test/js/node/test/parallel/timers-args.test.js
deleted file mode 100644
index ca38fd5b37..0000000000
--- a/test/js/node/test/parallel/timers-args.test.js
+++ /dev/null
@@ -1,52 +0,0 @@
-//#FILE: test-timers-args.js
-//#SHA1: 27f971d534c9bb3a1c14ae176ee8f34b0cdbed6f
-//-----------------
-"use strict";
-
-function range(n) {
-  return "x"
-    .repeat(n + 1)
-    .split("")
-    .map(function (_, i) {
-      return i;
-    });
-}
-
-test("setTimeout with increasing number of arguments", done => {
-  function timeout(nargs) {
-    const args = range(nargs);
-    setTimeout(callback, 1, ...args);
-
-    function callback(...receivedArgs) {
-      expect(receivedArgs).toEqual(args);
-      if (nargs < 128) {
-        timeout(nargs + 1);
-      } else {
-        done();
-      }
-    }
-  }
-
-  timeout(0);
-});
-
-test("setInterval with increasing number of arguments", done => {
-  function interval(nargs) {
-    const args = range(nargs);
-    const timer = setInterval(callback, 1, ...args);
-
-    function callback(...receivedArgs) {
-      clearInterval(timer);
-      expect(receivedArgs).toEqual(args);
-      if (nargs < 128) {
-        interval(nargs + 1);
-      } else {
-        done();
-      }
-    }
-  }
-
-  interval(0);
-});
-
-//<#END_FILE: test-timers-args.js
diff --git a/test/js/node/test/parallel/timers-clear-timeout-interval-equivalent.test.js b/test/js/node/test/parallel/timers-clear-timeout-interval-equivalent.test.js
deleted file mode 100644
index 1fc88ba7ef..0000000000
--- a/test/js/node/test/parallel/timers-clear-timeout-interval-equivalent.test.js
+++ /dev/null
@@ -1,40 +0,0 @@
-//#FILE: test-timers-clear-timeout-interval-equivalent.js
-//#SHA1: 2c98894fc8abe7d6e800533325274f39f9a16ff4
-//-----------------
-"use strict";
-
-// This test makes sure that timers created with setTimeout can be disarmed by
-// clearInterval and that timers created with setInterval can be disarmed by
-// clearTimeout.
-//
-// This behavior is documented in the HTML Living Standard:
-//
-// * Refs: https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-setinterval
-
-test("Disarm interval with clearTimeout", () => {
-  const mockCallback = jest.fn();
-  const interval = setInterval(mockCallback, 1);
-  clearTimeout(interval);
-
-  return new Promise(resolve => {
-    setTimeout(() => {
-      expect(mockCallback).not.toHaveBeenCalled();
-      resolve();
-    }, 10);
-  });
-});
-
-test("Disarm timeout with clearInterval", () => {
-  const mockCallback = jest.fn();
-  const timeout = setTimeout(mockCallback, 1);
-  clearInterval(timeout);
-
-  return new Promise(resolve => {
-    setTimeout(() => {
-      expect(mockCallback).not.toHaveBeenCalled();
-      resolve();
-    }, 10);
-  });
-});
-
-//<#END_FILE: test-timers-clear-timeout-interval-equivalent.js
diff --git a/test/js/node/test/parallel/timers-clearimmediate.test.js b/test/js/node/test/parallel/timers-clearimmediate.test.js
deleted file mode 100644
index d29f715d38..0000000000
--- a/test/js/node/test/parallel/timers-clearimmediate.test.js
+++ /dev/null
@@ -1,21 +0,0 @@
-//#FILE: test-timers-clearImmediate.js
-//#SHA1: 819914471d2e9d0a4629df9ef4b96e8e87ae7606
-//-----------------
-"use strict";
-
-const N = 3;
-
-function next() {
-  const fn = jest.fn();
-  const immediate = setImmediate(fn);
-  clearImmediate(immediate);
-  expect(fn).not.toHaveBeenCalled();
-}
-
-test("clearImmediate cancels setImmediate", () => {
-  for (let i = 0; i < N; i++) {
-    next();
-  }
-});
-
-//<#END_FILE: test-timers-clearImmediate.js
diff --git a/test/js/node/test/parallel/timers-immediate-queue.test.js b/test/js/node/test/parallel/timers-immediate-queue.test.js
deleted file mode 100644
index 92aefa2084..0000000000
--- a/test/js/node/test/parallel/timers-immediate-queue.test.js
+++ /dev/null
@@ -1,63 +0,0 @@
-//#FILE: test-timers-immediate-queue.js
-//#SHA1: 04dace9bcd1a7634224efafb4fdd5a953bfc28f6
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-// setImmediate should run clear its queued cbs once per event loop turn
-// but immediates queued while processing the current queue should happen
-// on the next turn of the event loop.
-
-// hit should be the exact same size of QUEUE, if we're letting things
-// recursively add to the immediate QUEUE hit will be > QUEUE
-
-test("setImmediate queue processing", done => {
-  let ticked = false;
-  let hit = 0;
-  const QUEUE = 10;
-
-  function run() {
-    if (hit === 0) {
-      setTimeout(() => {
-        ticked = true;
-      }, 1);
-      const now = Date.now();
-      while (Date.now() - now < 2);
-    }
-
-    if (ticked) return;
-
-    hit += 1;
-    setImmediate(run);
-  }
-
-  for (let i = 0; i < QUEUE; i++) setImmediate(run);
-
-  // Use setImmediate to ensure all other immediates have run
-  setImmediate(() => {
-    expect(hit).toBe(QUEUE);
-    done();
-  });
-});
-
-//<#END_FILE: test-timers-immediate-queue.js
diff --git a/test/js/node/test/parallel/timers-next-tick.test.js b/test/js/node/test/parallel/timers-next-tick.test.js
deleted file mode 100644
index eced9d48cc..0000000000
--- a/test/js/node/test/parallel/timers-next-tick.test.js
+++ /dev/null
@@ -1,50 +0,0 @@
-//#FILE: test-timers-next-tick.js
-//#SHA1: c6c6f667dac048dd0aed0a244e484ae1f0127d53
-//-----------------
-"use strict";
-
-// This test verifies that the next tick queue runs after each
-// individual Timeout, as well as each individual Immediate.
-
-test("next tick queue runs after each Timeout and Immediate", async () => {
-  const timeoutSpy1 = jest.fn();
-  const timeoutSpy2 = jest.fn();
-  const immediateSpy1 = jest.fn();
-  const immediateSpy2 = jest.fn();
-
-  setTimeout(timeoutSpy1, 1);
-  const t2 = setTimeout(jest.fn(), 1);
-  const t3 = setTimeout(jest.fn(), 1);
-  setTimeout(timeoutSpy2, 1);
-
-  await new Promise(resolve => setTimeout(resolve, 5));
-
-  setImmediate(immediateSpy1);
-  const i2 = setImmediate(jest.fn());
-  const i3 = setImmediate(jest.fn());
-  setImmediate(immediateSpy2);
-
-  await new Promise(resolve => setImmediate(resolve));
-
-  expect(timeoutSpy1).toHaveBeenCalledTimes(1);
-  expect(timeoutSpy2).toHaveBeenCalledTimes(1);
-  expect(immediateSpy1).toHaveBeenCalledTimes(1);
-  expect(immediateSpy2).toHaveBeenCalledTimes(1);
-
-  // Confirm that clearing Timeouts from a next tick doesn't explode.
-  process.nextTick(() => {
-    clearTimeout(t2);
-    clearTimeout(t3);
-  });
-
-  // Confirm that clearing Immediates from a next tick doesn't explode.
-  process.nextTick(() => {
-    clearImmediate(i2);
-    clearImmediate(i3);
-  });
-
-  // Wait for next tick to complete
-  await new Promise(process.nextTick);
-});
-
-//<#END_FILE: test-timers-next-tick.js
diff --git a/test/js/node/test/parallel/timers-now.test.js b/test/js/node/test/parallel/timers-now.test.js
deleted file mode 100644
index 1a0e58d2eb..0000000000
--- a/test/js/node/test/parallel/timers-now.test.js
+++ /dev/null
@@ -1,27 +0,0 @@
-//#FILE: test-timers-now.js
-//#SHA1: 6d35fc8681a7698d480f851c3c4ba5bfca7fb0b9
-//-----------------
-"use strict";
-// Flags: --expose-internals
-
-test("getLibuvNow() return value fits in a SMI after start-up", () => {
-  // We can't use internal bindings in Jest, so we'll need to mock this behavior
-  // For the purpose of this test, we'll create a mock function that returns a small number
-  const mockGetLibuvNow = jest.fn(() => 1000);
-
-  // Simulate the binding object
-  const binding = {
-    getLibuvNow: mockGetLibuvNow,
-  };
-
-  // Call the function and check the result
-  const result = binding.getLibuvNow();
-
-  // Check if the result is less than 0x3ffffff (67108863 in decimal)
-  expect(result).toBeLessThan(0x3ffffff);
-
-  // Ensure the mock function was called
-  expect(mockGetLibuvNow).toHaveBeenCalledTimes(1);
-});
-
-//<#END_FILE: test-timers-now.js
diff --git a/test/js/node/test/parallel/timers-ordering.test.js b/test/js/node/test/parallel/timers-ordering.test.js
deleted file mode 100644
index bd3769d4fc..0000000000
--- a/test/js/node/test/parallel/timers-ordering.test.js
+++ /dev/null
@@ -1,56 +0,0 @@
-//#FILE: test-timers-ordering.js
-//#SHA1: b2be662b4e86125b4dcd87ced4316d84acf57912
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-const N = 30;
-
-test("Timer ordering and timing", async () => {
-  let last_i = 0;
-  let last_ts = 0;
-
-  function f(i) {
-    return new Promise(resolve => {
-      if (i <= N) {
-        // check order
-        expect(i).toBe(last_i + 1);
-        last_i = i;
-
-        // Check that this iteration is fired at least 1ms later than the previous
-        const now = Date.now();
-        expect(now).toBeGreaterThanOrEqual(last_ts + 1);
-        last_ts = now;
-
-        // Schedule next iteration
-        setTimeout(() => resolve(f(i + 1)), 1);
-      } else {
-        resolve();
-      }
-    });
-  }
-
-  await f(1);
-}, 10000); // Increased timeout to ensure all iterations complete
-
-//<#END_FILE: test-timers-ordering.js
diff --git a/test/js/node/test/parallel/timers-setimmediate-infinite-loop.test.js b/test/js/node/test/parallel/timers-setimmediate-infinite-loop.test.js
deleted file mode 100644
index d034693ae2..0000000000
--- a/test/js/node/test/parallel/timers-setimmediate-infinite-loop.test.js
+++ /dev/null
@@ -1,37 +0,0 @@
-//#FILE: test-timers-setimmediate-infinite-loop.js
-//#SHA1: cd4dd01a6d06097758004eaa8d36d8712977d49d
-//-----------------
-"use strict";
-
-// This test ensures that if an Immediate callback clears subsequent
-// immediates we don't get stuck in an infinite loop.
-//
-// If the process does get stuck, it will be timed out by the test
-// runner.
-//
-// Ref: https://github.com/nodejs/node/issues/9756
-
-test("setImmediate clears subsequent immediates without infinite loop", done => {
-  const firstCallback = jest.fn(() => {
-    clearImmediate(i2);
-    clearImmediate(i3);
-  });
-
-  const secondCallback = jest.fn();
-  const thirdCallback = jest.fn();
-
-  setImmediate(firstCallback);
-
-  const i2 = setImmediate(secondCallback);
-  const i3 = setImmediate(thirdCallback);
-
-  // Use a timeout to ensure all immediates have been processed
-  setTimeout(() => {
-    expect(firstCallback).toHaveBeenCalledTimes(1);
-    expect(secondCallback).not.toHaveBeenCalled();
-    expect(thirdCallback).not.toHaveBeenCalled();
-    done();
-  }, 100);
-});
-
-//<#END_FILE: test-timers-setimmediate-infinite-loop.js
diff --git a/test/js/node/test/parallel/timers-timeout-with-non-integer.test.js b/test/js/node/test/parallel/timers-timeout-with-non-integer.test.js
deleted file mode 100644
index 2207d34ec6..0000000000
--- a/test/js/node/test/parallel/timers-timeout-with-non-integer.test.js
+++ /dev/null
@@ -1,25 +0,0 @@
-//#FILE: test-timers-timeout-with-non-integer.js
-//#SHA1: 371503ab8a31c6749ef77eabac3054e5a43ab231
-//-----------------
-"use strict";
-
-/**
- * This test is for https://github.com/nodejs/node/issues/24203
- */
-test("setTimeout with non-integer time", done => {
-  let count = 50;
-  const time = 1.00000000000001;
-
-  const exec = jest.fn(() => {
-    if (--count === 0) {
-      expect(exec).toHaveBeenCalledTimes(50);
-      done();
-      return;
-    }
-    setTimeout(exec, time);
-  });
-
-  exec();
-}, 10000); // Increased timeout to ensure all iterations complete
-
-//<#END_FILE: test-timers-timeout-with-non-integer.js
diff --git a/test/js/node/test/parallel/timers-to-primitive.test.js b/test/js/node/test/parallel/timers-to-primitive.test.js
deleted file mode 100644
index a47b84132c..0000000000
--- a/test/js/node/test/parallel/timers-to-primitive.test.js
+++ /dev/null
@@ -1,30 +0,0 @@
-//#FILE: test-timers-to-primitive.js
-//#SHA1: 87671c76fb38458f9d4f68aa747b2d95076f6bb4
-//-----------------
-"use strict";
-
-test("Timeout and Interval primitives", () => {
-  const timeouts = [setTimeout(() => {}, 1), setInterval(() => {}, 1)];
-
-  timeouts.forEach(timeout => {
-    expect(Number.isNaN(+timeout)).toBe(false);
-    expect(+timeout).toBe(timeout[Symbol.toPrimitive]());
-    expect(`${timeout}`).toBe(timeout[Symbol.toPrimitive]().toString());
-    expect(Object.keys({ [timeout]: timeout })).toEqual([`${timeout}`]);
-    clearTimeout(+timeout);
-  });
-});
-
-test("clearTimeout works with number id", () => {
-  const timeout = setTimeout(() => {}, 1);
-  const id = +timeout;
-  expect(() => clearTimeout(id)).not.toThrow();
-});
-
-test("clearTimeout works with string id", () => {
-  const timeout = setTimeout(() => {}, 1);
-  const id = `${timeout}`;
-  expect(() => clearTimeout(id)).not.toThrow();
-});
-
-//<#END_FILE: test-timers-to-primitive.js
diff --git a/test/js/node/test/parallel/timers-unrefed-in-beforeexit.test.js b/test/js/node/test/parallel/timers-unrefed-in-beforeexit.test.js
deleted file mode 100644
index 79967d0376..0000000000
--- a/test/js/node/test/parallel/timers-unrefed-in-beforeexit.test.js
+++ /dev/null
@@ -1,22 +0,0 @@
-//#FILE: test-timers-unrefed-in-beforeexit.js
-//#SHA1: c873b545965c8b223c0bc38f2acdd4bc952427ea
-//-----------------
-"use strict";
-
-test("unrefed timer in beforeExit should not prevent exit", () => {
-  const beforeExitHandler = jest.fn(() => {
-    setTimeout(jest.fn(), 1).unref();
-  });
-
-  process.on("beforeExit", beforeExitHandler);
-
-  // Simulate process exit
-  process.emit("beforeExit");
-
-  expect(beforeExitHandler).toHaveBeenCalledTimes(1);
-
-  // Clean up the event listener
-  process.removeListener("beforeExit", beforeExitHandler);
-});
-
-//<#END_FILE: test-timers-unrefed-in-beforeexit.js
diff --git a/test/js/node/test/parallel/timers-zero-timeout.test.js b/test/js/node/test/parallel/timers-zero-timeout.test.js
deleted file mode 100644
index 3f16eaf6ae..0000000000
--- a/test/js/node/test/parallel/timers-zero-timeout.test.js
+++ /dev/null
@@ -1,57 +0,0 @@
-//#FILE: test-timers-zero-timeout.js
-//#SHA1: f6d7cfab9ecf6f2f94001a4e153baf29dd3203b1
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-// https://github.com/joyent/node/issues/2079 - zero timeout drops extra args
-test("setTimeout with zero timeout and extra args", done => {
-  const f = jest.fn((a, b, c) => {
-    expect(a).toBe("foo");
-    expect(b).toBe("bar");
-    expect(c).toBe("baz");
-    done();
-  });
-
-  setTimeout(f, 0, "foo", "bar", "baz");
-  setTimeout(() => {}, 0);
-});
-
-test("setInterval with zero timeout and extra args", done => {
-  let ncalled = 3;
-
-  const f = jest.fn((a, b, c) => {
-    expect(a).toBe("foo");
-    expect(b).toBe("bar");
-    expect(c).toBe("baz");
-    if (--ncalled === 0) {
-      clearTimeout(iv);
-      expect(f).toHaveBeenCalledTimes(3);
-      done();
-    }
-  });
-
-  const iv = setInterval(f, 0, "foo", "bar", "baz");
-});
-
-//<#END_FILE: test-timers-zero-timeout.js
diff --git a/test/js/node/test/parallel/tls-add-context.test.js b/test/js/node/test/parallel/tls-add-context.test.js
deleted file mode 100644
index ca3d03c578..0000000000
--- a/test/js/node/test/parallel/tls-add-context.test.js
+++ /dev/null
@@ -1,93 +0,0 @@
-//#FILE: test-tls-add-context.js
-//#SHA1: 61f134fe8c8fb63a00278b2d70dfecf11efb5df9
-//-----------------
-"use strict";
-
-const crypto = require("crypto");
-const fixtures = require("../common/fixtures");
-const tls = require("tls");
-
-// Skip test if crypto is not available
-if (!crypto) {
-  test.skip("missing crypto", () => {});
-} else {
-  function loadPEM(n) {
-    return fixtures.readKey(`${n}.pem`);
-  }
-
-  const serverOptions = {
-    key: loadPEM("agent2-key"),
-    cert: loadPEM("agent2-cert"),
-    ca: [loadPEM("ca2-cert")],
-    requestCert: true,
-    rejectUnauthorized: false,
-  };
-
-  let connections = 0;
-
-  test("TLS add context", done => {
-    const server = tls.createServer(serverOptions, c => {
-      if (++connections === 3) {
-        server.close();
-      }
-      if (c.servername === "unknowncontext") {
-        expect(c.authorized).toBe(false);
-        return;
-      }
-      expect(c.authorized).toBe(true);
-    });
-
-    const secureContext = {
-      key: loadPEM("agent1-key"),
-      cert: loadPEM("agent1-cert"),
-      ca: [loadPEM("ca1-cert")],
-    };
-    server.addContext("context1", secureContext);
-    server.addContext("context2", tls.createSecureContext(secureContext));
-
-    const clientOptionsBase = {
-      key: loadPEM("agent1-key"),
-      cert: loadPEM("agent1-cert"),
-      ca: [loadPEM("ca1-cert")],
-      rejectUnauthorized: false,
-    };
-
-    server.listen(0, () => {
-      const client1 = tls.connect(
-        {
-          ...clientOptionsBase,
-          port: server.address().port,
-          servername: "context1",
-        },
-        () => {
-          client1.end();
-        },
-      );
-
-      const client2 = tls.connect(
-        {
-          ...clientOptionsBase,
-          port: server.address().port,
-          servername: "context2",
-        },
-        () => {
-          client2.end();
-        },
-      );
-
-      const client3 = tls.connect(
-        {
-          ...clientOptionsBase,
-          port: server.address().port,
-          servername: "unknowncontext",
-        },
-        () => {
-          client3.end();
-          done();
-        },
-      );
-    });
-  });
-}
-
-//<#END_FILE: test-tls-add-context.js
diff --git a/test/js/node/test/parallel/tls-ca-concat.test.js b/test/js/node/test/parallel/tls-ca-concat.test.js
deleted file mode 100644
index dcee3b9522..0000000000
--- a/test/js/node/test/parallel/tls-ca-concat.test.js
+++ /dev/null
@@ -1,39 +0,0 @@
-//#FILE: test-tls-ca-concat.js
-//#SHA1: 23b19f45d7777ee95a3c8d8ba4a727b149ea7409
-//-----------------
-"use strict";
-
-const fixtures = require("../common/fixtures");
-
-// Check ca option can contain concatenated certs by prepending an unrelated
-// non-CA cert and showing that agent6's CA root is still found.
-
-const { connect, keys } = require(fixtures.path("tls-connect"));
-
-test("ca option can contain concatenated certs", async () => {
-  await new Promise((resolve, reject) => {
-    connect(
-      {
-        client: {
-          checkServerIdentity: (servername, cert) => {},
-          ca: `${keys.agent1.cert}\n${keys.agent6.ca}`,
-        },
-        server: {
-          cert: keys.agent6.cert,
-          key: keys.agent6.key,
-        },
-      },
-      (err, pair, cleanup) => {
-        if (err) {
-          cleanup();
-          reject(err);
-        } else {
-          cleanup();
-          resolve();
-        }
-      },
-    );
-  });
-});
-
-//<#END_FILE: test-tls-ca-concat.js
diff --git a/test/js/node/test/parallel/tls-cert-ext-encoding.test.js b/test/js/node/test/parallel/tls-cert-ext-encoding.test.js
deleted file mode 100644
index ed33875b57..0000000000
--- a/test/js/node/test/parallel/tls-cert-ext-encoding.test.js
+++ /dev/null
@@ -1,90 +0,0 @@
-//#FILE: test-tls-cert-ext-encoding.js
-//#SHA1: 235c886145290bd46f4f40110eace31e4cbcf55f
-//-----------------
-"use strict";
-
-const tls = require("tls");
-
-// NOTE: This certificate is hand-generated, hence it is not located in
-// `test/fixtures/keys` to avoid confusion.
-//
-// The key property of this cert is that subjectAltName contains a string with
-// a type `23` which cannot be encoded into string by `X509V3_EXT_print`.
-const pem = `
------BEGIN RSA PRIVATE KEY-----
-MIIEowIBAAKCAQEAzrmfPz5M3wTq2/CwMeSQr/N+R1FCJ+O5n+SMleKvBqaK63eJ
-kL4BnySMc+ZLKCt4UQSsPFIBK63QFq8n6/vjuTDMJiBTsvzytw8zJt1Zr2HA71N3
-VIPt6NdJ/w5lgddTYxR7XudJZJ5lk3PkG8ZgrhuenPYP80UJYVzAC2YZ9KYe3r2B
-rVbut1j+8h0TwVcx2Zg5PorsC/EVxHwo4dCmIHceodikr3UVqHneRcrDBytdG6Mo
-IqHhZJwBeii/EES9tpWwWbzYYh+38aGGLIF2h5UlVpr0bdBVVUg+uVX3y/Qmu2Qv
-4CrAO2IPV6JER9Niwl3ktzNjOMAUQG6BCRSqRQIDAQABAoIBAAmB0+cOsG5ZRYvT
-5+aDgnv1EMuq2wYGnRTTZ/vErxP5OM5XcwYrFtwAzEzQPIieZywisOEdTFx74+QH
-LijWLsTnj5v5RKAorejpVArnhyZfsoXPKt/CKYDZ1ddbDCQKiRU3be0RafisqDM9
-0zHLz8pyDrtdPaKMfD/0Cgj8KxlrLTmfD4otPXds8fZpQe1hR1y12XKVp47l1siW
-qFGTaUPDJpQ67xybR08x5DOqmyo4cNMOuReRWrc/qRbWint9U1882eOH09gVfpJZ
-Gp6FZVPSgz10MZdLSPLhXqZkY4IxIvNltjBDqkmivd12CD+GVr0qUmTJHzTpk+kG
-/CWuRQkCgYEA4EFf8SJHEl0fLDJnOQFyUPY3MalMuopUkQ5CBUe3QXjQhHXsRDfj
-Ci/lyzShJkHPbMDHb/rx3lYZB0xNhwnMWKS1gCFVgOCOTZLfD0K1Anxc1hOSgVxI
-y5FdO9VW7oQNlsMH/WuDHps0HhJW/00lcrmdyoUM1+fE/3yPQndhUmMCgYEA6/z6
-8Gq4PHHNql+gwunAH2cZKNdmcP4Co8MvXCZwIJsLenUuLIZQ/YBKZoM/y5X/cFAG
-WFJJuUe6KFetPaDm6NgZgpOmawyUwd5czDjJ6wWgsRywiTISInfJlgWLBVMOuba7
-iBL9Xuy0hmcbj0ByoRW9l3gCiBX3yJw3I6wqXTcCgYBnjei22eRF15iIeTHvQfq+
-5iNwnEQhM7V/Uj0sYQR/iEGJmUaj7ca6somDf2cW2nblOlQeIpxD1jAyjYqTW/Pv
-zwc9BqeMHqW3rqWwT1Z0smbQODOD5tB6qEKMWaSN+Y6o2qC65kWjAXpclI110PME
-+i+iEDRxEsaGT8d7otLfDwKBgQCs+xBaQG/x5p2SAGzP0xYALstzc4jk1FzM+5rw
-mkBgtiXQyqpg+sfNOkfPIvAVZEsMYax0+0SNKrWbMsGLRjFchmMUovQ+zccQ4NT2
-4b2op8Rlbxk8R9ahK1s5u7Bu47YMjZSjJwBQn4OobVX3SI994njJ2a9JX4j0pQWK
-AX5AOwKBgAfOsr8HSHTcxSW4F9gegj+hXsRYbdA+eUkFhEGrYyRJgIlQrk/HbuZC
-mKd/bQ5R/vwd1cxgV6A0APzpZtbwdhvP0RWji+WnPPovgGcfK0AHFstHnga67/uu
-h2LHnKQZ1qWHn+BXWo5d7hBRwWVaK66g3GDN0blZpSz1kKcpy1Pl
------END RSA PRIVATE KEY-----
------BEGIN CERTIFICATE-----
-MIICwjCCAaqgAwIBAgIDAQABMA0GCSqGSIb3DQEBDQUAMBUxEzARBgNVBAMWCmxv
-Y2FsLmhvc3QwHhcNMTkxMjA1MDQyODMzWhcNNDQxMTI5MDQyODMzWjAVMRMwEQYD
-VQQDFgpsb2NhbC5ob3N0MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA
-zrmfPz5M3wTq2/CwMeSQr/N+R1FCJ+O5n+SMleKvBqaK63eJkL4BnySMc+ZLKCt4
-UQSsPFIBK63QFq8n6/vjuTDMJiBTsvzytw8zJt1Zr2HA71N3VIPt6NdJ/w5lgddT
-YxR7XudJZJ5lk3PkG8ZgrhuenPYP80UJYVzAC2YZ9KYe3r2BrVbut1j+8h0TwVcx
-2Zg5PorsC/EVxHwo4dCmIHceodikr3UVqHneRcrDBytdG6MoIqHhZJwBeii/EES9
-tpWwWbzYYh+38aGGLIF2h5UlVpr0bdBVVUg+uVX3y/Qmu2Qv4CrAO2IPV6JER9Ni
-wl3ktzNjOMAUQG6BCRSqRQIDAQABoxswGTAXBgNVHREEEDAOlwwqLmxvY2FsLmhv
-c3QwDQYJKoZIhvcNAQENBQADggEBAH5ThRLDLwOGuhKsifyiq7k8gbx1FqRegO7H
-SIiIYYB35v5Pk0ZPN8QBJwNQzJEjUMjCpHXNdBxknBXRaA8vkbnryMfJm37gPTwA
-m6r0uEG78WgcEAe8bgf9iKtQGP/iydKXpSSpDgKoHbswIxD5qtzT+o6VNnkRTSfK
-/OGwakluFSoJ/Q9rLpR8lKjA01BhetXMmHbETiY8LSkxOymMldXSzUTD1WdrVn8U
-L3dobxT//R/0GraKXG02mf3gZNlb0MMTvW0pVwVy39YmcPEGh8L0hWh1rpAA/VXC
-f79uOowv3lLTzQ9na5EThA0tp8d837hdYrrIHh5cfTqBDxG0Tu8=
------END CERTIFICATE-----
-`;
-
-const options = {
-  key: pem,
-  cert: pem,
-};
-
-test("TLS certificate extension encoding", async () => {
-  const server = tls.createServer(options, socket => {
-    socket.end();
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, () => {
-      const client = tls.connect(
-        {
-          port: server.address().port,
-          rejectUnauthorized: false,
-        },
-        () => {
-          // This should not crash process:
-          client.getPeerCertificate();
-
-          server.close();
-          client.end();
-          resolve();
-        },
-      );
-    });
-  });
-});
-
-//<#END_FILE: test-tls-cert-ext-encoding.js
diff --git a/test/js/node/test/parallel/tls-client-abort.test.js b/test/js/node/test/parallel/tls-client-abort.test.js
deleted file mode 100644
index 4679c1f0e4..0000000000
--- a/test/js/node/test/parallel/tls-client-abort.test.js
+++ /dev/null
@@ -1,57 +0,0 @@
-//#FILE: test-tls-client-abort.js
-//#SHA1: e4f4d09f8de79ff5f4bdefcdaf1bbebb49f3cc16
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-const tls = require("tls");
-const fs = require("fs");
-const path = require("path");
-
-const hasCrypto = (() => {
-  try {
-    require("crypto");
-    return true;
-  } catch {
-    return false;
-  }
-})();
-
-if (!hasCrypto) {
-  test.skip("missing crypto", () => {});
-} else {
-  test("TLS client abort", () => {
-    const cert = fs.readFileSync(path.join(__dirname, "..", "fixtures", "keys", "rsa_cert.crt"));
-    const key = fs.readFileSync(path.join(__dirname, "..", "fixtures", "keys", "rsa_private.pem"));
-
-    const onConnect = jest.fn();
-    const conn = tls.connect({ cert, key, port: 0 }, onConnect);
-
-    conn.on("error", () => {}); // Expecting an error, but not testing its content
-    conn.destroy();
-
-    expect(onConnect).not.toHaveBeenCalled();
-  });
-}
-
-//<#END_FILE: test-tls-client-abort.js
diff --git a/test/js/node/test/parallel/tls-client-default-ciphers.test.js b/test/js/node/test/parallel/tls-client-default-ciphers.test.js
deleted file mode 100644
index d337071777..0000000000
--- a/test/js/node/test/parallel/tls-client-default-ciphers.test.js
+++ /dev/null
@@ -1,52 +0,0 @@
-//#FILE: test-tls-client-default-ciphers.js
-//#SHA1: 8a9af503503ffc8b8a7c27089fd7cf417e22ec16
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-const tls = require("tls");
-
-if (typeof Bun !== "undefined") {
-  test = it;
-}
-
-if (!("crypto" in process.versions)) {
-  test.skip("missing crypto", () => {});
-} else {
-  test("tls.connect uses default ciphers", () => {
-    let ciphers = "";
-
-    class Done extends Error {}
-
-    tls.createSecureContext = function (options) {
-      ciphers = options.ciphers;
-      throw new Done();
-    };
-
-    expect(() => tls.connect()).toThrow(Done);
-
-    expect(ciphers).toBe(tls.DEFAULT_CIPHERS);
-  });
-}
-
-//<#END_FILE: test-tls-client-default-ciphers.js
diff --git a/test/js/node/test/parallel/tls-env-extra-ca-no-crypto.test.js b/test/js/node/test/parallel/tls-env-extra-ca-no-crypto.test.js
deleted file mode 100644
index 5b48f8f775..0000000000
--- a/test/js/node/test/parallel/tls-env-extra-ca-no-crypto.test.js
+++ /dev/null
@@ -1,27 +0,0 @@
-//#FILE: test-tls-env-extra-ca-no-crypto.js
-//#SHA1: da8421700b140b9bef4723eee10dbae7786423b6
-//-----------------
-"use strict";
-
-const { fork } = require("child_process");
-const path = require("path");
-
-// This test ensures that trying to load extra certs won't throw even when
-// there is no crypto support, i.e., built with "./configure --without-ssl".
-if (process.argv[2] === "child") {
-  // exit
-} else {
-  const NODE_EXTRA_CA_CERTS = path.join(__dirname, "..", "fixtures", "keys", "ca1-cert.pem");
-
-  test("Loading extra certs without crypto support", () => {
-    return new Promise(resolve => {
-      fork(__filename, ["child"], { env: { ...process.env, NODE_EXTRA_CA_CERTS } }).on("exit", status => {
-        // Client did not succeed in connecting
-        expect(status).toBe(0);
-        resolve();
-      });
-    });
-  });
-}
-
-//<#END_FILE: test-tls-env-extra-ca-no-crypto.js
diff --git a/test/js/node/test/parallel/tls-fast-writing.test.js b/test/js/node/test/parallel/tls-fast-writing.test.js
deleted file mode 100644
index 7656d5eb15..0000000000
--- a/test/js/node/test/parallel/tls-fast-writing.test.js
+++ /dev/null
@@ -1,97 +0,0 @@
-//#FILE: test-tls-fast-writing.js
-//#SHA1: 3a9ce4612ccf460fb5c0dfd4be6f8f5cad06c4a4
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const fixtures = require("../common/fixtures");
-const tls = require("tls");
-
-const options = {
-  key: fixtures.readKey("rsa_private.pem"),
-  cert: fixtures.readKey("rsa_cert.crt"),
-  ca: [fixtures.readKey("rsa_ca.crt")],
-};
-
-let gotChunk = false;
-let gotDrain = false;
-
-function onconnection(conn) {
-  conn.on("data", function (c) {
-    if (!gotChunk) {
-      gotChunk = true;
-      console.log("ok - got chunk");
-    }
-
-    // Just some basic sanity checks.
-    expect(c.length).toBeGreaterThan(0);
-    expect(Buffer.isBuffer(c)).toBe(true);
-
-    if (gotDrain) {
-      process.exit(0);
-    }
-  });
-}
-
-test("TLS fast writing", done => {
-  if (!process.versions.openssl) {
-    console.log("1..0 # Skipped: missing crypto");
-    return done();
-  }
-
-  const server = tls.createServer(options, onconnection);
-
-  server.listen(0, function () {
-    const chunk = Buffer.alloc(1024, "x");
-    const opt = { port: this.address().port, rejectUnauthorized: false };
-    const conn = tls.connect(opt, function () {
-      conn.on("drain", ondrain);
-      write();
-    });
-
-    function ondrain() {
-      if (!gotDrain) {
-        gotDrain = true;
-        console.log("ok - got drain");
-      }
-      if (gotChunk) {
-        process.exit(0);
-      }
-      write();
-    }
-
-    function write() {
-      // This needs to return false eventually
-      while (false !== conn.write(chunk));
-    }
-  });
-
-  // Clean up
-  process.on("exit", () => {
-    server.close();
-    expect(gotChunk).toBe(true);
-    expect(gotDrain).toBe(true);
-    done();
-  });
-});
-
-//<#END_FILE: test-tls-fast-writing.js
diff --git a/test/js/node/test/parallel/tls-net-socket-keepalive.test.js b/test/js/node/test/parallel/tls-net-socket-keepalive.test.js
deleted file mode 100644
index a0378791cc..0000000000
--- a/test/js/node/test/parallel/tls-net-socket-keepalive.test.js
+++ /dev/null
@@ -1,80 +0,0 @@
-//#FILE: test-tls-net-socket-keepalive.js
-//#SHA1: 9ae6965b63d37c0f9cb2ab7d068d4da2a68b8b1f
-//-----------------
-"use strict";
-
-const fixtures = require("../common/fixtures");
-const tls = require("tls");
-const net = require("net");
-
-// This test ensures that when tls sockets are created with `allowHalfOpen`,
-// they won't hang.
-const key = fixtures.readKey("agent1-key.pem");
-const cert = fixtures.readKey("agent1-cert.pem");
-const ca = fixtures.readKey("ca1-cert.pem");
-const options = {
-  key,
-  cert,
-  ca: [ca],
-};
-
-test("TLS sockets with allowHalfOpen do not hang", done => {
-  const server = tls.createServer(options, conn => {
-    conn.write("hello", () => {
-      expect(true).toBe(true); // Equivalent to common.mustCall()
-    });
-    conn.on("data", () => {
-      expect(true).toBe(true); // Equivalent to common.mustCall()
-    });
-    conn.on("end", () => {
-      expect(true).toBe(true); // Equivalent to common.mustCall()
-    });
-    conn.on("data", () => {
-      expect(true).toBe(true); // Equivalent to common.mustCall()
-    });
-    conn.on("close", () => {
-      expect(true).toBe(true); // Equivalent to common.mustCall()
-    });
-    conn.end();
-  });
-
-  server.listen(0, () => {
-    const netSocket = new net.Socket({
-      allowHalfOpen: true,
-    });
-
-    const socket = tls.connect({
-      socket: netSocket,
-      rejectUnauthorized: false,
-    });
-
-    const { port, address } = server.address();
-
-    // Doing `net.Socket.connect()` after `tls.connect()` will make tls module
-    // wrap the socket in StreamWrap.
-    netSocket.connect({
-      port,
-      address,
-    });
-
-    socket.on("secureConnect", () => {
-      expect(true).toBe(true); // Equivalent to common.mustCall()
-    });
-    socket.on("end", () => {
-      expect(true).toBe(true); // Equivalent to common.mustCall()
-    });
-    socket.on("data", () => {
-      expect(true).toBe(true); // Equivalent to common.mustCall()
-    });
-    socket.on("close", () => {
-      expect(true).toBe(true); // Equivalent to common.mustCall()
-      server.close();
-      done();
-    });
-
-    socket.write("hello");
-    socket.end();
-  });
-});
-
-//<#END_FILE: test-tls-net-socket-keepalive.js
diff --git a/test/js/node/test/parallel/tls-peer-certificate-multi-keys.test.js b/test/js/node/test/parallel/tls-peer-certificate-multi-keys.test.js
deleted file mode 100644
index d1cfe70e15..0000000000
--- a/test/js/node/test/parallel/tls-peer-certificate-multi-keys.test.js
+++ /dev/null
@@ -1,87 +0,0 @@
-//#FILE: test-tls-peer-certificate-multi-keys.js
-//#SHA1: d30d685d74ebea73274e19cea1a19a2b8cea5120
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-const tls = require("tls");
-const fixtures = require("../common/fixtures");
-
-const options = {
-  key: fixtures.readKey("rsa_private.pem"),
-  cert: fixtures.readKey("rsa_cert.crt"),
-};
-
-let server;
-
-beforeAll(() => {
-  if (!process.versions.openssl) {
-    return test.skip("missing crypto");
-  }
-});
-
-afterAll(() => {
-  if (server) {
-    server.close();
-  }
-});
-
-test("TLS peer certificate with multiple keys", async () => {
-  server = tls.createServer(options, cleartext => {
-    cleartext.end("World");
-  });
-
-  const serverSecureConnectionPromise = new Promise(resolve => {
-    server.once("secureConnection", socket => {
-      const cert = socket.getCertificate();
-      // The server's local cert is the client's peer cert.
-      expect(cert.subject.OU).toEqual(["Test TLS Certificate", "Engineering"]);
-      resolve();
-    });
-  });
-
-  await new Promise(resolve => {
-    server.listen(0, resolve);
-  });
-
-  const clientConnectionPromise = new Promise((resolve, reject) => {
-    const socket = tls.connect(
-      {
-        port: server.address().port,
-        rejectUnauthorized: false,
-      },
-      () => {
-        const peerCert = socket.getPeerCertificate();
-        expect(peerCert.subject.OU).toEqual(["Test TLS Certificate", "Engineering"]);
-        socket.end("Hello");
-        resolve();
-      },
-    );
-
-    socket.on("error", reject);
-  });
-
-  await Promise.all([serverSecureConnectionPromise, clientConnectionPromise]);
-});
-
-//<#END_FILE: test-tls-peer-certificate-multi-keys.js
diff --git a/test/js/node/test/parallel/tls-startcom-wosign-whitelist.test.js b/test/js/node/test/parallel/tls-startcom-wosign-whitelist.test.js
deleted file mode 100644
index fde4c90e29..0000000000
--- a/test/js/node/test/parallel/tls-startcom-wosign-whitelist.test.js
+++ /dev/null
@@ -1,82 +0,0 @@
-//#FILE: test-tls-startcom-wosign-whitelist.js
-//#SHA1: 6742ecdeeaa94ca1efad850b021d5308b3077358
-//-----------------
-"use strict";
-
-const tls = require("tls");
-const fixtures = require("../common/fixtures");
-
-function loadPEM(n) {
-  return fixtures.readKey(`${n}.pem`);
-}
-
-const testCases = [
-  {
-    // agent8 is signed by fake-startcom-root with notBefore of
-    // Oct 20 23:59:59 2016 GMT. It passes StartCom/WoSign check.
-    serverOpts: {
-      key: loadPEM("agent8-key"),
-      cert: loadPEM("agent8-cert"),
-    },
-    clientOpts: {
-      ca: loadPEM("fake-startcom-root-cert"),
-      port: undefined,
-      rejectUnauthorized: true,
-    },
-    errorCode: "CERT_REVOKED",
-  },
-  {
-    // agent9 is signed by fake-startcom-root with notBefore of
-    // Oct 21 00:00:01 2016 GMT. It fails StartCom/WoSign check.
-    serverOpts: {
-      key: loadPEM("agent9-key"),
-      cert: loadPEM("agent9-cert"),
-    },
-    clientOpts: {
-      ca: loadPEM("fake-startcom-root-cert"),
-      port: undefined,
-      rejectUnauthorized: true,
-    },
-    errorCode: "CERT_REVOKED",
-  },
-];
-
-describe("TLS StartCom/WoSign Whitelist", () => {
-  let finishedTests = 0;
-
-  afterAll(() => {
-    expect(finishedTests).toBe(testCases.length);
-  });
-
-  testCases.forEach((tcase, index) => {
-    it(`should handle case ${index + 1} correctly`, async () => {
-      const server = tls.createServer(tcase.serverOpts, s => {
-        s.resume();
-      });
-
-      await new Promise(resolve => {
-        server.listen(0, () => {
-          tcase.clientOpts.port = server.address().port;
-          const client = tls.connect(tcase.clientOpts);
-
-          client.on("error", e => {
-            expect(e.code).toBe(tcase.errorCode);
-            server.close(resolve);
-          });
-
-          client.on("secureConnect", () => {
-            // agent8 can pass StartCom/WoSign check so that the secureConnect
-            // is established.
-            expect(tcase.errorCode).toBe("CERT_REVOKED");
-            client.end();
-            server.close(resolve);
-          });
-        });
-      });
-
-      finishedTests++;
-    });
-  });
-});
-
-//<#END_FILE: test-tls-startcom-wosign-whitelist.js
diff --git a/test/js/node/test/parallel/tls-ticket-cluster.test.js b/test/js/node/test/parallel/tls-ticket-cluster.test.js
deleted file mode 100644
index 2def9c478c..0000000000
--- a/test/js/node/test/parallel/tls-ticket-cluster.test.js
+++ /dev/null
@@ -1,153 +0,0 @@
-//#FILE: test-tls-ticket-cluster.js
-//#SHA1: a65d425111990ee164b458fd373b9f5bb083f6df
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-const tls = require("tls");
-const cluster = require("cluster");
-const fixtures = require("../common/fixtures");
-
-const workerCount = 4;
-const expectedReqCount = 16;
-
-if (!process.env.NODE_SKIP_NO_CRYPTO_TEST) {
-  test("skip if missing crypto", () => {
-    const hasCrypto = typeof process.versions.openssl === "string";
-    if (!hasCrypto) {
-      console.log("1..0 # Skipped: missing crypto");
-    }
-    expect(hasCrypto).toBe(true);
-  });
-}
-
-if (cluster.isPrimary) {
-  let listeningCount = 0;
-  let reusedCount = 0;
-  let reqCount = 0;
-  let lastSession = null;
-  let workerPort = null;
-
-  function shoot() {
-    console.error("[primary] connecting", workerPort, "session?", !!lastSession);
-    const c = tls
-      .connect(
-        workerPort,
-        {
-          session: lastSession,
-          rejectUnauthorized: false,
-        },
-        () => {
-          c.on("end", c.end);
-        },
-      )
-      .on("close", () => {
-        // Wait for close to shoot off another connection. We don't want to shoot
-        // until a new session is allocated, if one will be. The new session is
-        // not guaranteed on secureConnect (it depends on TLS1.2 vs TLS1.3), but
-        // it is guaranteed to happen before the connection is closed.
-        if (++reqCount === expectedReqCount) {
-          Object.keys(cluster.workers).forEach(function (id) {
-            cluster.workers[id].send("die");
-          });
-        } else {
-          shoot();
-        }
-      })
-      .once("session", session => {
-        expect(lastSession).toBeFalsy();
-        lastSession = session;
-      });
-
-    c.resume(); // See close_notify comment in server
-  }
-
-  function fork() {
-    const worker = cluster.fork();
-    worker.on("message", ({ msg, port }) => {
-      console.error("[primary] got %j", msg);
-      if (msg === "reused") {
-        ++reusedCount;
-      } else if (msg === "listening" && ++listeningCount === workerCount) {
-        workerPort = port;
-        shoot();
-      }
-    });
-
-    worker.on("exit", () => {
-      console.error("[primary] worker died");
-    });
-  }
-
-  test("cluster primary", () => {
-    for (let i = 0; i < workerCount; i++) {
-      fork();
-    }
-
-    process.on("exit", () => {
-      expect(reqCount).toBe(expectedReqCount);
-      expect(reusedCount + 1).toBe(reqCount);
-    });
-  });
-} else {
-  const key = fixtures.readKey("rsa_private.pem");
-  const cert = fixtures.readKey("rsa_cert.crt");
-
-  const options = { key, cert };
-
-  const server = tls.createServer(options, c => {
-    console.error("[worker] connection reused?", c.isSessionReused());
-    if (c.isSessionReused()) {
-      process.send({ msg: "reused" });
-    } else {
-      process.send({ msg: "not-reused" });
-    }
-    // Used to just .end(), but that means client gets close_notify before
-    // NewSessionTicket. Send data until that problem is solved.
-    c.end("x");
-  });
-
-  server.listen(0, () => {
-    const { port } = server.address();
-    process.send({
-      msg: "listening",
-      port,
-    });
-  });
-
-  process.on("message", function listener(msg) {
-    console.error("[worker] got %j", msg);
-    if (msg === "die") {
-      server.close(() => {
-        console.error("[worker] server close");
-        process.exit();
-      });
-    }
-  });
-
-  process.on("exit", () => {
-    console.error("[worker] exit");
-  });
-}
-
-//<#END_FILE: test-tls-ticket-cluster.js
diff --git a/test/js/node/test/parallel/tls-transport-destroy-after-own-gc.test.js b/test/js/node/test/parallel/tls-transport-destroy-after-own-gc.test.js
deleted file mode 100644
index 1f7c20dda3..0000000000
--- a/test/js/node/test/parallel/tls-transport-destroy-after-own-gc.test.js
+++ /dev/null
@@ -1,39 +0,0 @@
-//#FILE: test-tls-transport-destroy-after-own-gc.js
-//#SHA1: e2ef35ad88444196d24664e93fb9efdad050c876
-//-----------------
-// Flags: --expose-gc
-"use strict";
-
-// Regression test for https://github.com/nodejs/node/issues/17475
-// Unfortunately, this tests only "works" reliably when checked with valgrind or
-// a similar tool.
-
-const { TLSSocket } = require("tls");
-const makeDuplexPair = require("../common/duplexpair");
-
-test("TLSSocket destruction after garbage collection", done => {
-  if (!process.versions.openssl) {
-    done();
-    return;
-  }
-
-  let { clientSide } = makeDuplexPair();
-
-  let clientTLS = new TLSSocket(clientSide, { isServer: false });
-  let clientTLSHandle = clientTLS._handle; // eslint-disable-line no-unused-vars
-
-  setImmediate(() => {
-    clientTLS = null;
-    global.gc();
-    clientTLSHandle = null;
-    global.gc();
-    setImmediate(() => {
-      clientSide = null;
-      global.gc();
-      // If we've reached this point without crashing, the test has passed
-      done();
-    });
-  });
-});
-
-//<#END_FILE: test-tls-transport-destroy-after-own-gc.js
diff --git a/test/js/node/test/parallel/tls-wrap-econnreset.test.js b/test/js/node/test/parallel/tls-wrap-econnreset.test.js
deleted file mode 100644
index 3f11b13be2..0000000000
--- a/test/js/node/test/parallel/tls-wrap-econnreset.test.js
+++ /dev/null
@@ -1,51 +0,0 @@
-//#FILE: test-tls-wrap-econnreset.js
-//#SHA1: 22f57b68ee3c5d271a9235972865773da523a34e
-//-----------------
-"use strict";
-
-const net = require("net");
-const tls = require("tls");
-
-// Skip the test if crypto is not available
-if (!("crypto" in process.versions)) {
-  test.skip("missing crypto", () => {});
-} else {
-  test("TLS connection reset", async () => {
-    const server = net.createServer(c => {
-      c.end();
-    });
-
-    await new Promise(resolve => {
-      server.listen(0, resolve);
-    });
-
-    const port = server.address().port;
-
-    let errored = false;
-    const tlsConnection = tls.connect(port, "127.0.0.1");
-
-    await expect(
-      new Promise((_, reject) => {
-        tlsConnection.once("error", reject);
-      }),
-    ).rejects.toMatchObject({
-      code: "ECONNRESET",
-      path: undefined,
-      host: "127.0.0.1",
-      port: port,
-      localAddress: undefined,
-      message: expect.any(String),
-    });
-
-    errored = true;
-    server.close();
-
-    await new Promise(resolve => {
-      tlsConnection.on("close", resolve);
-    });
-
-    expect(errored).toBe(true);
-  });
-}
-
-//<#END_FILE: test-tls-wrap-econnreset.js
diff --git a/test/js/node/test/parallel/tls-zero-clear-in.test.js b/test/js/node/test/parallel/tls-zero-clear-in.test.js
deleted file mode 100644
index 26283f4311..0000000000
--- a/test/js/node/test/parallel/tls-zero-clear-in.test.js
+++ /dev/null
@@ -1,81 +0,0 @@
-//#FILE: test-tls-zero-clear-in.js
-//#SHA1: 6014fd3aa5a294b4e8594a32f0eb8e7b3c206213
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-const tls = require("tls");
-const { readKey } = require("../common/fixtures");
-
-if (!process.versions.openssl) {
-  test.skip("missing crypto");
-}
-
-const cert = readKey("rsa_cert.crt");
-const key = readKey("rsa_private.pem");
-
-test("SSL_write() call with 0 bytes should not be treated as error", done => {
-  const server = tls.createServer(
-    {
-      cert,
-      key,
-    },
-    c => {
-      // Nop
-      setTimeout(() => {
-        c.end();
-        server.close();
-      }, 20);
-    },
-  );
-
-  server.listen(0, () => {
-    const conn = tls.connect(
-      {
-        cert: cert,
-        key: key,
-        rejectUnauthorized: false,
-        port: server.address().port,
-      },
-      () => {
-        setTimeout(() => {
-          conn.destroy();
-        }, 20);
-      },
-    );
-
-    // SSL_write() call's return value, when called 0 bytes, should not be
-    // treated as error.
-    conn.end("");
-
-    conn.on("error", () => {
-      done(new Error("Unexpected error event"));
-    });
-
-    setTimeout(() => {
-      done();
-    }, 100);
-  });
-});
-
-//<#END_FILE: test-tls-zero-clear-in.js
diff --git a/test/js/node/test/parallel/tty-stdin-end.test.js b/test/js/node/test/parallel/tty-stdin-end.test.js
deleted file mode 100644
index cb2f825045..0000000000
--- a/test/js/node/test/parallel/tty-stdin-end.test.js
+++ /dev/null
@@ -1,15 +0,0 @@
-//#FILE: test-tty-stdin-end.js
-//#SHA1: 66243635acf852b7a108d06e289e5db2b2573bad
-//-----------------
-"use strict";
-
-// This test ensures that Node.js doesn't crash on `process.stdin.emit("end")`.
-// https://github.com/nodejs/node/issues/1068
-
-test("process.stdin.emit('end') doesn't crash", () => {
-  expect(() => {
-    process.stdin.emit("end");
-  }).not.toThrow();
-});
-
-//<#END_FILE: test-tty-stdin-end.js
diff --git a/test/js/node/test/parallel/tz-version.test.js b/test/js/node/test/parallel/tz-version.test.js
deleted file mode 100644
index 04bac4dcdb..0000000000
--- a/test/js/node/test/parallel/tz-version.test.js
+++ /dev/null
@@ -1,32 +0,0 @@
-//#FILE: test-tz-version.js
-//#SHA1: 7c06414dda474dff448a3998499dddffdf084126
-//-----------------
-"use strict";
-
-// Skip the test if Intl is not available
-if (typeof Intl === "undefined") {
-  test.skip("missing Intl", () => {});
-} else {
-  // Refs: https://github.com/nodejs/node/blob/1af63a90ca3a59ca05b3a12ad7dbea04008db7d9/configure.py#L1694-L1711
-  if (process.config.variables.icu_path !== "deps/icu-small") {
-    // If Node.js is configured to use its built-in ICU, it uses a strict subset
-    // of ICU formed using `tools/icu/shrink-icu-src.py`, which is present in
-    // `deps/icu-small`. It is not the same as configuring the build with
-    // `./configure --with-intl=small-icu`. The latter only uses a subset of the
-    // locales, i.e., it uses the English locale, `root,en`, by default and other
-    // locales can also be specified using the `--with-icu-locales` option.
-    test.skip("not using the icu data file present in deps/icu-small/source/data/in/icudt##l.dat.bz2", () => {});
-  } else {
-    const { readFileSync } = require("fs");
-    const path = require("path");
-
-    // This test ensures the correctness of the automated timezone upgrade PRs.
-
-    test("timezone version matches expected version", () => {
-      const expectedVersion = readFileSync(path.join(__dirname, "fixtures", "tz-version.txt"), "utf8").trim();
-      expect(process.versions.tz).toBe(expectedVersion);
-    });
-  }
-}
-
-//<#END_FILE: test-tz-version.js
diff --git a/test/js/node/test/parallel/unhandled-exception-with-worker-inuse.test.js b/test/js/node/test/parallel/unhandled-exception-with-worker-inuse.test.js
deleted file mode 100644
index 6acae8cf95..0000000000
--- a/test/js/node/test/parallel/unhandled-exception-with-worker-inuse.test.js
+++ /dev/null
@@ -1,39 +0,0 @@
-//#FILE: test-unhandled-exception-with-worker-inuse.js
-//#SHA1: 4eb89fdb9d675dbef4f89ed61ab77225b9200b4a
-//-----------------
-"use strict";
-
-// https://github.com/nodejs/node/issues/45421
-//
-// Check that node will NOT call v8::Isolate::SetIdle() when exiting
-// due to an unhandled exception, otherwise the assertion(enabled in
-// debug build only) in the SetIdle(), which checks that the vm state
-// is either EXTERNAL or IDLE will fail.
-//
-// The root cause of this issue is that before PerIsolateMessageListener()
-// is invoked by v8, v8 preserves the JS vm state, although it should
-// switch to EXTERNEL. https://bugs.chromium.org/p/v8/issues/detail?id=13464
-//
-// Therefore, this commit can be considered as an workaround of the v8 bug,
-// but we also find it not useful to call SetIdle() when terminating.
-
-if (process.argv[2] === "child") {
-  const { Worker } = require("worker_threads");
-  new Worker("", { eval: true });
-  throw new Error("xxx");
-} else {
-  const { spawnSync } = require("child_process");
-
-  test("unhandled exception with worker in use", () => {
-    const result = spawnSync(process.execPath, [__filename, "child"]);
-
-    const stderr = result.stderr.toString().trim();
-    // Expect error message to be preserved
-    expect(stderr).toMatch(/xxx/);
-    // Expect no crash
-    expect(result.status).not.toBe(null);
-    expect(result.signal).toBe(null);
-  });
-}
-
-//<#END_FILE: test-unhandled-exception-with-worker-inuse.js
diff --git a/test/js/node/test/parallel/url-canparse-whatwg.test.js b/test/js/node/test/parallel/url-canparse-whatwg.test.js
deleted file mode 100644
index a6c920c536..0000000000
--- a/test/js/node/test/parallel/url-canparse-whatwg.test.js
+++ /dev/null
@@ -1,25 +0,0 @@
-//#FILE: test-url-canParse-whatwg.js
-//#SHA1: e1170e8b8d0057443bfb307c64dbd27b204ac2f0
-//-----------------
-"use strict";
-
-test("URL.canParse requires one argument", () => {
-  expect(() => {
-    URL.canParse();
-  }).toThrow(
-    expect.objectContaining({
-      code: "ERR_MISSING_ARGS",
-      name: "TypeError",
-      message: expect.any(String),
-    }),
-  );
-});
-
-test("URL.canParse works with v8 fast api", () => {
-  // This test is to ensure that the v8 fast api works.
-  for (let i = 0; i < 1e5; i++) {
-    expect(URL.canParse("https://www.example.com/path/?query=param#hash")).toBe(true);
-  }
-});
-
-//<#END_FILE: test-url-canParse-whatwg.js
diff --git a/test/js/node/test/parallel/url-domain-ascii-unicode.test.js b/test/js/node/test/parallel/url-domain-ascii-unicode.test.js
deleted file mode 100644
index 0a716939a9..0000000000
--- a/test/js/node/test/parallel/url-domain-ascii-unicode.test.js
+++ /dev/null
@@ -1,39 +0,0 @@
-//#FILE: test-url-domain-ascii-unicode.js
-//#SHA1: 717d40eef6d2d8f5adccf01fe09dc43f8b776e13
-//-----------------
-"use strict";
-
-const url = require("url");
-
-const domainToASCII = url.domainToASCII;
-const domainToUnicode = url.domainToUnicode;
-
-const domainWithASCII = [
-  ["ıíd", "xn--d-iga7r"],
-  ["يٴ", "xn--mhb8f"],
-  ["www.ϧƽəʐ.com", "www.xn--cja62apfr6c.com"],
-  ["новини.com", "xn--b1amarcd.com"],
-  ["名がドメイン.com", "xn--v8jxj3d1dzdz08w.com"],
-  ["افغانستا.icom.museum", "xn--mgbaal8b0b9b2b.icom.museum"],
-  ["الجزائر.icom.fake", "xn--lgbbat1ad8j.icom.fake"],
-  ["भारत.org", "xn--h2brj9c.org"],
-];
-
-describe("URL domain ASCII and Unicode conversion", () => {
-  // Skip the entire test suite if Intl is not available
-  beforeAll(() => {
-    if (typeof Intl === "undefined") {
-      throw new Error("missing Intl");
-    }
-  });
-
-  test.each(domainWithASCII)("converts %s <-> %s", (domain, ascii) => {
-    const domainConvertedToASCII = domainToASCII(domain);
-    expect(domainConvertedToASCII).toBe(ascii);
-
-    const asciiConvertedToUnicode = domainToUnicode(ascii);
-    expect(asciiConvertedToUnicode).toBe(domain);
-  });
-});
-
-//<#END_FILE: test-url-domain-ascii-unicode.js
diff --git a/test/js/node/test/parallel/url-is-url.test.js b/test/js/node/test/parallel/url-is-url.test.js
deleted file mode 100644
index de30ec10f0..0000000000
--- a/test/js/node/test/parallel/url-is-url.test.js
+++ /dev/null
@@ -1,28 +0,0 @@
-//#FILE: test-url-is-url.js
-//#SHA1: 337a63661b82d89cf2592ee32d91780acb8e5925
-//-----------------
-"use strict";
-
-const { URL, parse } = require("url");
-
-// Remove the internal module usage
-// const { isURL } = require('internal/url');
-
-// Implement a simple isURL function for testing purposes
-function isURL(input) {
-  return input instanceof URL;
-}
-
-test("isURL function", () => {
-  expect(isURL(new URL("https://www.nodejs.org"))).toBe(true);
-  expect(isURL(parse("https://www.nodejs.org"))).toBe(false);
-  expect(
-    isURL({
-      href: "https://www.nodejs.org",
-      protocol: "https:",
-      path: "/",
-    }),
-  ).toBe(false);
-});
-
-//<#END_FILE: test-url-is-url.js
diff --git a/test/js/node/test/parallel/url-revokeobjecturl.test.js b/test/js/node/test/parallel/url-revokeobjecturl.test.js
deleted file mode 100644
index 190ed562f5..0000000000
--- a/test/js/node/test/parallel/url-revokeobjecturl.test.js
+++ /dev/null
@@ -1,20 +0,0 @@
-//#FILE: test-url-revokeobjecturl.js
-//#SHA1: 573bfad806102976807ad71fef71b079005d8bfa
-//-----------------
-"use strict";
-
-// Test ensures that the function receives the url argument.
-
-test("URL.revokeObjectURL() throws with missing argument", () => {
-  expect(() => {
-    URL.revokeObjectURL();
-  }).toThrow(
-    expect.objectContaining({
-      code: "ERR_MISSING_ARGS",
-      name: "TypeError",
-      message: expect.any(String),
-    }),
-  );
-});
-
-//<#END_FILE: test-url-revokeobjecturl.js
diff --git a/test/js/node/test/parallel/url-urltooptions.test.js b/test/js/node/test/parallel/url-urltooptions.test.js
deleted file mode 100644
index 3cb50f21b5..0000000000
--- a/test/js/node/test/parallel/url-urltooptions.test.js
+++ /dev/null
@@ -1,48 +0,0 @@
-//#FILE: test-url-urltooptions.js
-//#SHA1: 0ba1cb976ec5888306f7c820a39afcb93b882d03
-//-----------------
-"use strict";
-
-const { URL } = require("url");
-const { urlToHttpOptions } = require("url");
-
-describe("urlToHttpOptions", () => {
-  test("converts URL object to HTTP options", () => {
-    const urlObj = new URL("http://user:pass@foo.bar.com:21/aaa/zzz?l=24#test");
-    const opts = urlToHttpOptions(urlObj);
-
-    expect(opts).not.toBeInstanceOf(URL);
-    expect(opts.protocol).toBe("http:");
-    expect(opts.auth).toBe("user:pass");
-    expect(opts.hostname).toBe("foo.bar.com");
-    expect(opts.port).toBe(21);
-    expect(opts.path).toBe("/aaa/zzz?l=24");
-    expect(opts.pathname).toBe("/aaa/zzz");
-    expect(opts.search).toBe("?l=24");
-    expect(opts.hash).toBe("#test");
-  });
-
-  test("handles IPv6 hostname correctly", () => {
-    const { hostname } = urlToHttpOptions(new URL("http://[::1]:21"));
-    expect(hostname).toBe("::1");
-  });
-
-  test("handles copied URL object with missing data properties", () => {
-    const urlObj = new URL("http://user:pass@foo.bar.com:21/aaa/zzz?l=24#test");
-    const copiedUrlObj = { ...urlObj };
-    const copiedOpts = urlToHttpOptions(copiedUrlObj);
-
-    expect(copiedOpts).not.toBeInstanceOf(URL);
-    expect(copiedOpts.protocol).toBeUndefined();
-    expect(copiedOpts.auth).toBeUndefined();
-    expect(copiedOpts.hostname).toBeUndefined();
-    expect(copiedOpts.port).toBeNaN();
-    expect(copiedOpts.path).toBe("");
-    expect(copiedOpts.pathname).toBeUndefined();
-    expect(copiedOpts.search).toBeUndefined();
-    expect(copiedOpts.hash).toBeUndefined();
-    expect(copiedOpts.href).toBeUndefined();
-  });
-});
-
-//<#END_FILE: test-url-urltooptions.js
diff --git a/test/js/node/test/parallel/utf8-scripts.test.js b/test/js/node/test/parallel/utf8-scripts.test.js
deleted file mode 100644
index e4c5a4bec4..0000000000
--- a/test/js/node/test/parallel/utf8-scripts.test.js
+++ /dev/null
@@ -1,40 +0,0 @@
-//#FILE: test-utf8-scripts.js
-//#SHA1: 103e32f817ebd35d617fba00e947304390c431d5
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-// üäö
-
-test("UTF-8 scripts", () => {
-  const consoleSpy = jest.spyOn(console, "log");
-
-  console.log("Σὲ γνωρίζω ἀπὸ τὴν κόψη");
-
-  expect(consoleSpy).toHaveBeenCalledWith("Σὲ γνωρίζω ἀπὸ τὴν κόψη");
-  consoleSpy.mockRestore();
-
-  expect("Hellö Wörld").toMatch(/Hellö Wörld/);
-});
-
-//<#END_FILE: test-utf8-scripts.js
diff --git a/test/js/node/test/parallel/util-deprecate.test.js b/test/js/node/test/parallel/util-deprecate.test.js
deleted file mode 100644
index 319c02c3b0..0000000000
--- a/test/js/node/test/parallel/util-deprecate.test.js
+++ /dev/null
@@ -1,79 +0,0 @@
-//#FILE: test-util-deprecate.js
-//#SHA1: 43c232bacd8dcc9f39194125c071db2ab14dfb51
-//-----------------
-"use strict";
-
-const util = require("util");
-
-// Tests basic functionality of util.deprecate().
-
-// Mock process.on for warnings
-const mockWarningListener = jest.fn();
-const mockExitListener = jest.fn();
-process.on = jest.fn((event, listener) => {
-  if (event === "warning") mockWarningListener.mockImplementation(listener);
-  if (event === "exit") mockExitListener.mockImplementation(listener);
-});
-
-const expectedWarnings = new Map();
-
-test("Emits deprecation only once if same function is called", () => {
-  const msg = "fhqwhgads";
-  const fn = util.deprecate(() => {}, msg);
-  expectedWarnings.set(msg, { code: undefined, count: 1 });
-  fn();
-  fn();
-});
-
-test("Emits deprecation twice for different functions", () => {
-  const msg = "sterrance";
-  const fn1 = util.deprecate(() => {}, msg);
-  const fn2 = util.deprecate(() => {}, msg);
-  expectedWarnings.set(msg, { code: undefined, count: 2 });
-  fn1();
-  fn2();
-});
-
-test("Emits deprecation only once if optional code is the same, even for different functions", () => {
-  const msg = "cannonmouth";
-  const code = "deprecatesque";
-  const fn1 = util.deprecate(() => {}, msg, code);
-  const fn2 = util.deprecate(() => {}, msg, code);
-  expectedWarnings.set(msg, { code, count: 1 });
-  fn1();
-  fn2();
-  fn1();
-  fn2();
-});
-
-test("Handles warnings correctly", () => {
-  expectedWarnings.forEach((expected, message) => {
-    for (let i = 0; i < expected.count; i++) {
-      mockWarningListener({
-        name: "DeprecationWarning",
-        message: message,
-        code: expected.code,
-      });
-    }
-  });
-
-  expect(mockWarningListener).toHaveBeenCalledTimes(
-    Array.from(expectedWarnings.values()).reduce((acc, curr) => acc + curr.count, 0),
-  );
-
-  mockWarningListener.mock.calls.forEach(([warning]) => {
-    expect(warning.name).toBe("DeprecationWarning");
-    expect(expectedWarnings.has(warning.message)).toBe(true);
-    const expected = expectedWarnings.get(warning.message);
-    expect(warning.code).toBe(expected.code);
-    expected.count--;
-    if (expected.count === 0) {
-      expectedWarnings.delete(warning.message);
-    }
-  });
-});
-
-test("All warnings are processed", () => {
-  mockExitListener();
-  expect(expectedWarnings.size).toBe(0);
-});
diff --git a/test/js/node/test/parallel/util-inspect-getters-accessing-this.test.js b/test/js/node/test/parallel/util-inspect-getters-accessing-this.test.js
deleted file mode 100644
index 78cec627d2..0000000000
--- a/test/js/node/test/parallel/util-inspect-getters-accessing-this.test.js
+++ /dev/null
@@ -1,64 +0,0 @@
-//#FILE: test-util-inspect-getters-accessing-this.js
-//#SHA1: 92c41c06f838da46cbbfcd7f695a19784af3f581
-//-----------------
-"use strict";
-
-const { inspect } = require("util");
-
-// This test ensures that util.inspect logs getters
-// which access this.
-
-test("util.inspect logs getters accessing this", () => {
-  class X {
-    constructor() {
-      this._y = 123;
-    }
-
-    get y() {
-      return this._y;
-    }
-  }
-
-  const result = inspect(new X(), {
-    getters: true,
-    showHidden: true,
-  });
-
-  expect(result).toBe("X { _y: 123, [y]: [Getter: 123] }");
-});
-
-// Regression test for https://github.com/nodejs/node/issues/37054
-test("util.inspect handles circular references in getters", () => {
-  class A {
-    constructor(B) {
-      this.B = B;
-    }
-    get b() {
-      return this.B;
-    }
-  }
-
-  class B {
-    constructor() {
-      this.A = new A(this);
-    }
-    get a() {
-      return this.A;
-    }
-  }
-
-  const result = inspect(new B(), {
-    depth: 1,
-    getters: true,
-    showHidden: true,
-  });
-
-  expect(result).toBe(
-    "<ref *1> B {\n" +
-      "  A: A { B: [Circular *1], [b]: [Getter] [Circular *1] },\n" +
-      "  [a]: [Getter] A { B: [Circular *1], [b]: [Getter] [Circular *1] }\n" +
-      "}",
-  );
-});
-
-//<#END_FILE: test-util-inspect-getters-accessing-this.js
diff --git a/test/js/node/test/parallel/util-inspect-long-running.test.js b/test/js/node/test/parallel/util-inspect-long-running.test.js
deleted file mode 100644
index 7fba0e08b7..0000000000
--- a/test/js/node/test/parallel/util-inspect-long-running.test.js
+++ /dev/null
@@ -1,28 +0,0 @@
-//#FILE: test-util-inspect-long-running.js
-//#SHA1: 2e4cbb5743a4dfcf869e84ce6d58795f96465aeb
-//-----------------
-"use strict";
-
-// Test that huge objects don't crash due to exceeding the maximum heap size.
-
-const util = require("util");
-
-test("util.inspect handles huge objects without crashing", () => {
-  // Create a difficult to stringify object. Without the artificial limitation
-  // this would crash or throw an maximum string size error.
-  let last = {};
-  const obj = last;
-
-  for (let i = 0; i < 1000; i++) {
-    last.next = { circular: obj, last, obj: { a: 1, b: 2, c: true } };
-    last = last.next;
-    obj[i] = last;
-  }
-
-  // This should not throw an error or crash
-  expect(() => {
-    util.inspect(obj, { depth: Infinity });
-  }).not.toThrow();
-});
-
-//<#END_FILE: test-util-inspect-long-running.js
diff --git a/test/js/node/test/parallel/util-primordial-monkeypatching.test.js b/test/js/node/test/parallel/util-primordial-monkeypatching.test.js
deleted file mode 100644
index 8f369c1d8f..0000000000
--- a/test/js/node/test/parallel/util-primordial-monkeypatching.test.js
+++ /dev/null
@@ -1,25 +0,0 @@
-//#FILE: test-util-primordial-monkeypatching.js
-//#SHA1: 72e754f1abd435e598620901f26b087e0bf9d5a7
-//-----------------
-"use strict";
-
-// Monkeypatch Object.keys() so that it throws an unexpected error. This tests
-// that `util.inspect()` is unaffected by monkey-patching `Object`.
-
-const util = require("util");
-
-test("util.inspect() is unaffected by monkey-patching Object.keys()", () => {
-  const originalObjectKeys = Object.keys;
-
-  // Monkey-patch Object.keys
-  Object.keys = () => {
-    throw new Error("fhqwhgads");
-  };
-
-  try {
-    expect(util.inspect({})).toBe("{}");
-  } finally {
-    // Restore original Object.keys to avoid affecting other tests
-    Object.keys = originalObjectKeys;
-  }
-});
diff --git a/test/js/node/test/parallel/util-sigint-watchdog.test.js b/test/js/node/test/parallel/util-sigint-watchdog.test.js
deleted file mode 100644
index 8f265aa240..0000000000
--- a/test/js/node/test/parallel/util-sigint-watchdog.test.js
+++ /dev/null
@@ -1,83 +0,0 @@
-//#FILE: test-util-sigint-watchdog.js
-//#SHA1: 8731497954a21e75af21af0adde10619d98a703f
-//-----------------
-"use strict";
-
-// Skip test on Windows platforms
-if (process.platform === "win32") {
-  test.skip("platform not supported", () => {});
-} else {
-  const binding = {
-    startSigintWatchdog: jest.fn(),
-    stopSigintWatchdog: jest.fn(),
-    watchdogHasPendingSigint: jest.fn(),
-  };
-
-  // Mock the process.kill function
-  const originalKill = process.kill;
-  beforeAll(() => {
-    process.kill = jest.fn();
-  });
-  afterAll(() => {
-    process.kill = originalKill;
-  });
-
-  function waitForPendingSignal(cb) {
-    if (binding.watchdogHasPendingSigint()) cb();
-    else setTimeout(waitForPendingSignal, 10, cb);
-  }
-
-  test("with no signal observed", () => {
-    binding.startSigintWatchdog();
-    binding.stopSigintWatchdog.mockReturnValue(false);
-    const hadPendingSignals = binding.stopSigintWatchdog();
-    expect(hadPendingSignals).toBe(false);
-  });
-
-  test("with one call to the watchdog, one signal", done => {
-    binding.startSigintWatchdog();
-    process.kill(process.pid, "SIGINT");
-    binding.watchdogHasPendingSigint.mockReturnValue(true);
-    binding.stopSigintWatchdog.mockReturnValue(true);
-
-    waitForPendingSignal(() => {
-      const hadPendingSignals = binding.stopSigintWatchdog();
-      expect(hadPendingSignals).toBe(true);
-      done();
-    });
-  });
-
-  test("nested calls are okay", done => {
-    binding.startSigintWatchdog();
-    binding.startSigintWatchdog();
-    process.kill(process.pid, "SIGINT");
-    binding.watchdogHasPendingSigint.mockReturnValue(true);
-    binding.stopSigintWatchdog.mockReturnValueOnce(true).mockReturnValueOnce(false);
-
-    waitForPendingSignal(() => {
-      const hadPendingSignals1 = binding.stopSigintWatchdog();
-      const hadPendingSignals2 = binding.stopSigintWatchdog();
-      expect(hadPendingSignals1).toBe(true);
-      expect(hadPendingSignals2).toBe(false);
-      done();
-    });
-  });
-
-  test("signal comes in after first call to stop", done => {
-    binding.startSigintWatchdog();
-    binding.startSigintWatchdog();
-    binding.stopSigintWatchdog.mockReturnValueOnce(false).mockReturnValueOnce(true);
-    const hadPendingSignals1 = binding.stopSigintWatchdog();
-    process.kill(process.pid, "SIGINT");
-    binding.watchdogHasPendingSigint.mockReturnValue(true);
-
-    waitForPendingSignal(() => {
-      const hadPendingSignals2 = binding.stopSigintWatchdog();
-      expect(hadPendingSignals1).toBe(false);
-      expect(hadPendingSignals2).toBe(true);
-      done();
-    });
-  });
-}
-
-//<#END_FILE: test-util-sigint-watchdog.js
diff --git a/test/js/node/test/parallel/uv-unmapped-exception.test.js b/test/js/node/test/parallel/uv-unmapped-exception.test.js
deleted file mode 100644
index c8a5147fdc..0000000000
--- a/test/js/node/test/parallel/uv-unmapped-exception.test.js
+++ /dev/null
@@ -1,47 +0,0 @@
-//#FILE: test-uv-unmapped-exception.js
-//#SHA1: 2878fb9a4523acb34f6283c980cde15b06fdc055
-//-----------------
-"use strict";
-
-// We can't use internal modules, so we'll need to implement our own UVException and UVExceptionWithHostPort
-class UVException extends Error {
-  constructor({ errno, syscall }) {
-    super(`UNKNOWN: unknown error, ${syscall}`);
-    this.errno = errno;
-    this.syscall = syscall;
-    this.code = "UNKNOWN";
-  }
-}
-
-class UVExceptionWithHostPort extends Error {
-  constructor(errno, syscall, address, port) {
-    super(`${syscall} UNKNOWN: unknown error ${address}:${port}`);
-    this.code = "UNKNOWN";
-    this.errno = errno;
-    this.syscall = syscall;
-    this.address = address;
-    this.port = port;
-  }
-}
-
-test("UVException", () => {
-  const exception = new UVException({ errno: 100, syscall: "open" });
-
-  expect(exception.message).toBe("UNKNOWN: unknown error, open");
-  expect(exception.errno).toBe(100);
-  expect(exception.syscall).toBe("open");
-  expect(exception.code).toBe("UNKNOWN");
-});
-
-test("UVExceptionWithHostPort", () => {
-  const exception = new UVExceptionWithHostPort(100, "listen", "127.0.0.1", 80);
-
-  expect(exception.message).toBe("listen UNKNOWN: unknown error 127.0.0.1:80");
-  expect(exception.code).toBe("UNKNOWN");
-  expect(exception.errno).toBe(100);
-  expect(exception.syscall).toBe("listen");
-  expect(exception.address).toBe("127.0.0.1");
-  expect(exception.port).toBe(80);
-});
-
-//<#END_FILE: test-uv-unmapped-exception.js
diff --git a/test/js/node/test/parallel/v8-collect-gc-profile-in-worker.test.js b/test/js/node/test/parallel/v8-collect-gc-profile-in-worker.test.js
deleted file mode 100644
index ff43b62a54..0000000000
--- a/test/js/node/test/parallel/v8-collect-gc-profile-in-worker.test.js
+++ /dev/null
@@ -1,36 +0,0 @@
-//#FILE: test-v8-collect-gc-profile-in-worker.js
-//#SHA1: 212956c00ed8e788f682c6335879f6844972a424
-//-----------------
-// Flags: --expose-gc
-"use strict";
-
-const { Worker } = require("worker_threads");
-
-// Replace testGCProfiler with a Jest-compatible mock
-const testGCProfiler = jest.fn();
-
-if (!process.env.isWorker) {
-  test("Worker thread creation", () => {
-    process.env.isWorker = 1;
-    const worker = new Worker(__filename);
-    expect(worker).toBeDefined();
-  });
-} else {
-  test("GC profiler in worker thread", () => {
-    testGCProfiler();
-    for (let i = 0; i < 100; i++) {
-      new Array(100);
-    }
-
-    // Check if global.gc is available
-    if (typeof global.gc === "function") {
-      global.gc();
-    } else {
-      console.warn("global.gc is not available. Make sure to run with --expose-gc flag.");
-    }
-
-    expect(testGCProfiler).toHaveBeenCalledTimes(1);
-  });
-}
-
-//<#END_FILE: test-v8-collect-gc-profile-in-worker.js
diff --git a/test/js/node/test/parallel/v8-deserialize-buffer.test.js b/test/js/node/test/parallel/v8-deserialize-buffer.test.js
deleted file mode 100644
index d84675a6c0..0000000000
--- a/test/js/node/test/parallel/v8-deserialize-buffer.test.js
+++ /dev/null
@@ -1,20 +0,0 @@
-//#FILE: test-v8-deserialize-buffer.js
-//#SHA1: ef80f8c41f9e9b893ea639f4558713addcf82b9a
-//-----------------
-"use strict";
-
-const v8 = require("v8");
-
-test("v8.deserialize should not emit warnings for Buffer.alloc(0)", () => {
-  const warningListener = jest.fn();
-  process.on("warning", warningListener);
-
-  v8.deserialize(v8.serialize(Buffer.alloc(0)));
-
-  expect(warningListener).not.toHaveBeenCalled();
-
-  // Clean up the listener
-  process.removeListener("warning", warningListener);
-});
-
-//<#END_FILE: test-v8-deserialize-buffer.js
diff --git a/test/js/node/test/parallel/v8-flag-pool-size-0.test.js b/test/js/node/test/parallel/v8-flag-pool-size-0.test.js
deleted file mode 100644
index 0b32378981..0000000000
--- a/test/js/node/test/parallel/v8-flag-pool-size-0.test.js
+++ /dev/null
@@ -1,24 +0,0 @@
-//#FILE: test-v8-flag-pool-size-0.js
-//#SHA1: 32e0b30d9305b4bf5509c6061176b2f87c47c66d
-//-----------------
-// Flags: --v8-pool-size=0 --expose-gc
-
-"use strict";
-
-// This test doesn't require any specific assertions or expectations.
-// It's primarily checking that the process doesn't crash or hang when
-// running with the specified flags.
-
-test("V8 tasks scheduled by GC are handled on worker threads with --v8-pool-size=0", () => {
-  // This verifies that V8 tasks scheduled by GC are handled on worker threads if
-  // `--v8-pool-size=0` is given. The worker threads are managed by Node.js'
-  // `v8::Platform` implementation.
-
-  // Trigger garbage collection
-  globalThis.gc();
-
-  // If we've reached this point without crashing or hanging, the test is successful
-  expect(true).toBe(true);
-});
-
-//<#END_FILE: test-v8-flag-pool-size-0.js
diff --git a/test/js/node/test/parallel/v8-global-setter.test.js b/test/js/node/test/parallel/v8-global-setter.test.js
deleted file mode 100644
index eb5fe888f2..0000000000
--- a/test/js/node/test/parallel/v8-global-setter.test.js
+++ /dev/null
@@ -1,37 +0,0 @@
-//#FILE: test-v8-global-setter.js
-//#SHA1: 8711ed3c5a3491001fcf441ed56e14fcca67c8ef
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-// This test ensures v8 correctly sets a property on the global object if it
-// has a setter interceptor in strict mode.
-// https://github.com/nodejs/node-v0.x-archive/issues/6235
-
-test("v8 global setter in strict mode", () => {
-  expect(() => {
-    require("vm").runInNewContext('"use strict"; var v = 1; v = 2');
-  }).not.toThrow();
-});
-
-//<#END_FILE: test-v8-global-setter.js
diff --git a/test/js/node/test/parallel/v8-serialize-leak.test.js b/test/js/node/test/parallel/v8-serialize-leak.test.js
deleted file mode 100644
index a8d0bb51e0..0000000000
--- a/test/js/node/test/parallel/v8-serialize-leak.test.js
+++ /dev/null
@@ -1,46 +0,0 @@
-//#FILE: test-v8-serialize-leak.js
-//#SHA1: f1b10774a48610a130cac36679953f9af1ed15e1
-//-----------------
-"use strict";
-// Flags: --expose-gc
-
-const v8 = require("v8");
-
-// On IBMi, the rss memory always returns zero
-if (process.platform === "os400") {
-  test.skip("On IBMi, the rss memory always returns zero");
-}
-
-test("v8.serialize should not leak memory", async () => {
-  const before = process.memoryUsage.rss();
-
-  for (let i = 0; i < 1000000; i++) {
-    v8.serialize("");
-  }
-
-  async function gcUntil(message, condition) {
-    for (let i = 0; i < 10; i++) {
-      global.gc();
-      await new Promise(resolve => setTimeout(resolve, 100));
-      if (condition()) {
-        return;
-      }
-    }
-    throw new Error(`${message} failed to be true in time`);
-  }
-
-  await gcUntil("RSS should go down", () => {
-    const after = process.memoryUsage.rss();
-    if (process.env.ASAN_OPTIONS) {
-      console.log(`ASan: before=${before} after=${after}`);
-      return after < before * 10;
-    } else if (process.config.variables.node_builtin_modules_path) {
-      console.log(`node_builtin_modules_path: before=${before} after=${after}`);
-      return after < before * 10;
-    }
-    console.log(`before=${before} after=${after}`);
-    return after < before * 10;
-  });
-});
-
-//<#END_FILE: test-v8-serialize-leak.js
diff --git a/test/js/node/test/parallel/vm-access-process-env.test.js b/test/js/node/test/parallel/vm-access-process-env.test.js
deleted file mode 100644
index 4bac2e235c..0000000000
--- a/test/js/node/test/parallel/vm-access-process-env.test.js
+++ /dev/null
@@ -1,38 +0,0 @@
-//#FILE: test-vm-access-process-env.js
-//#SHA1: ffc014abc0d92ea62b7c0510d69cad5e89d632af
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-// Tests that node does neither crash nor throw an error when accessing
-// process.env when inside a VM context.
-// See https://github.com/nodejs/node-v0.x-archive/issues/7511.
-
-const vm = require("vm");
-
-test("VM context can access process.env", () => {
-  const context = vm.createContext({ process });
-  const result = vm.runInContext('process.env["PATH"]', context);
-  expect(result).not.toBeUndefined();
-});
-
-//<#END_FILE: test-vm-access-process-env.js
diff --git a/test/js/node/test/parallel/vm-attributes-property-not-on-sandbox.test.js b/test/js/node/test/parallel/vm-attributes-property-not-on-sandbox.test.js
deleted file mode 100644
index 3cfeab76a7..0000000000
--- a/test/js/node/test/parallel/vm-attributes-property-not-on-sandbox.test.js
+++ /dev/null
@@ -1,23 +0,0 @@
-//#FILE: test-vm-attributes-property-not-on-sandbox.js
-//#SHA1: c864df0cb9b3ab90c8582ad86f50a8e94be92114
-//-----------------
-"use strict";
-const vm = require("vm");
-
-// Assert that accessor descriptors are not flattened on the sandbox.
-// Issue: https://github.com/nodejs/node/issues/2734
-test("accessor descriptors are not flattened on the sandbox", () => {
-  const sandbox = {};
-  vm.createContext(sandbox);
-  const code = `Object.defineProperty(
-               this,
-               'foo',
-               { get: function() {return 17} }
-             );
-             var desc = Object.getOwnPropertyDescriptor(this, 'foo');`;
-
-  vm.runInContext(code, sandbox);
-  expect(typeof sandbox.desc.get).toBe("function");
-});
-
-//<#END_FILE: test-vm-attributes-property-not-on-sandbox.js
diff --git a/test/js/node/test/parallel/vm-context-async-script.test.js b/test/js/node/test/parallel/vm-context-async-script.test.js
deleted file mode 100644
index 52d90dde39..0000000000
--- a/test/js/node/test/parallel/vm-context-async-script.test.js
+++ /dev/null
@@ -1,41 +0,0 @@
-//#FILE: test-vm-context-async-script.js
-//#SHA1: 411e3a9c4ea8c062420ae8f112c62ed7c2a1a962
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const vm = require("vm");
-
-test("vm.runInContext with async script", done => {
-  const sandbox = { setTimeout };
-  const ctx = vm.createContext(sandbox);
-
-  vm.runInContext("setTimeout(function() { x = 3; }, 0);", ctx);
-
-  setTimeout(() => {
-    expect(sandbox.x).toBe(3);
-    expect(ctx.x).toBe(3);
-    done();
-  }, 1);
-});
-
-//<#END_FILE: test-vm-context-async-script.js
diff --git a/test/js/node/test/parallel/vm-context-property-forwarding.test.js b/test/js/node/test/parallel/vm-context-property-forwarding.test.js
deleted file mode 100644
index ca3e22c38a..0000000000
--- a/test/js/node/test/parallel/vm-context-property-forwarding.test.js
+++ /dev/null
@@ -1,76 +0,0 @@
-//#FILE: test-vm-context-property-forwarding.js
-//#SHA1: 611b4eee260bc77dfbaece761208e11a57fe226f
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const vm = require("vm");
-
-test("vm context property forwarding", () => {
-  const sandbox = { x: 3 };
-  const ctx = vm.createContext(sandbox);
-
-  expect(vm.runInContext("x;", ctx)).toBe(3);
-  vm.runInContext("y = 4;", ctx);
-  expect(sandbox.y).toBe(4);
-  expect(ctx.y).toBe(4);
-});
-
-test("IndexedPropertyGetterCallback and IndexedPropertyDeleterCallback", () => {
-  const x = {
-    get 1() {
-      return 5;
-    },
-  };
-  const pd_expected = Object.getOwnPropertyDescriptor(x, 1);
-  const ctx2 = vm.createContext(x);
-  const pd_actual = Object.getOwnPropertyDescriptor(ctx2, 1);
-
-  expect(pd_actual).toEqual(pd_expected);
-  expect(ctx2[1]).toBe(5);
-  delete ctx2[1];
-  expect(ctx2[1]).toBeUndefined();
-});
-
-// https://github.com/nodejs/node/issues/33806
-test("property setter error propagation", () => {
-  const ctx = vm.createContext();
-
-  Object.defineProperty(ctx, "prop", {
-    get() {
-      return undefined;
-    },
-    set() {
-      throw new Error("test error");
-    },
-  });
-
-  expect(() => {
-    vm.runInContext("prop = 42", ctx);
-  }).toThrow(
-    expect.objectContaining({
-      message: expect.any(String),
-    }),
-  );
-});
-
-//<#END_FILE: test-vm-context-property-forwarding.js
diff --git a/test/js/node/test/parallel/vm-create-and-run-in-context.test.js b/test/js/node/test/parallel/vm-create-and-run-in-context.test.js
deleted file mode 100644
index e6e450ef9f..0000000000
--- a/test/js/node/test/parallel/vm-create-and-run-in-context.test.js
+++ /dev/null
@@ -1,61 +0,0 @@
-//#FILE: test-vm-create-and-run-in-context.js
-//#SHA1: 4583962cfdb3266d8b850442cec0b4cfa49bc6d2
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-// Flags: --expose-gc
-
-const vm = require("vm");
-
-describe("vm.createContext and vm.runInContext", () => {
-  test("Run in a new empty context", () => {
-    const context = vm.createContext();
-    const result = vm.runInContext('"passed";', context);
-    expect(result).toBe("passed");
-  });
-
-  test("Create a new pre-populated context", () => {
-    const context = vm.createContext({ foo: "bar", thing: "lala" });
-    expect(context.foo).toBe("bar");
-    expect(context.thing).toBe("lala");
-  });
-
-  test("Test updating context", () => {
-    const context = vm.createContext({ foo: "bar", thing: "lala" });
-    vm.runInContext("var foo = 3;", context);
-    expect(context.foo).toBe(3);
-    expect(context.thing).toBe("lala");
-  });
-
-  test("Run in contextified sandbox without referencing the context", () => {
-    // https://github.com/nodejs/node/issues/5768
-    const sandbox = { x: 1 };
-    vm.createContext(sandbox);
-    global.gc();
-    vm.runInContext("x = 2", sandbox);
-    // Should not crash.
-    expect(sandbox.x).toBe(2);
-  });
-});
-
-//<#END_FILE: test-vm-create-and-run-in-context.js
diff --git a/test/js/node/test/parallel/vm-create-context-accessors.test.js b/test/js/node/test/parallel/vm-create-context-accessors.test.js
deleted file mode 100644
index 6f55c5f5af..0000000000
--- a/test/js/node/test/parallel/vm-create-context-accessors.test.js
+++ /dev/null
@@ -1,54 +0,0 @@
-//#FILE: test-vm-create-context-accessors.js
-//#SHA1: af7f3fb956333bd0669014a9e3c8f3f308efc68e
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const vm = require("vm");
-
-test("vm.createContext with accessors", () => {
-  let ctx = {};
-
-  Object.defineProperty(ctx, "getter", {
-    get: function () {
-      return "ok";
-    },
-  });
-
-  let val;
-  Object.defineProperty(ctx, "setter", {
-    set: function (_val) {
-      val = _val;
-    },
-    get: function () {
-      return `ok=${val}`;
-    },
-  });
-
-  ctx = vm.createContext(ctx);
-
-  const result = vm.runInContext('setter = "test";[getter,setter]', ctx);
-  expect(result[0]).toBe("ok");
-  expect(result[1]).toBe("ok=test");
-});
-
-//<#END_FILE: test-vm-create-context-accessors.js
diff --git a/test/js/node/test/parallel/vm-create-context-circular-reference.test.js b/test/js/node/test/parallel/vm-create-context-circular-reference.test.js
deleted file mode 100644
index a088f700bf..0000000000
--- a/test/js/node/test/parallel/vm-create-context-circular-reference.test.js
+++ /dev/null
@@ -1,39 +0,0 @@
-//#FILE: test-vm-create-context-circular-reference.js
-//#SHA1: 30740bd812c7365e1f7b72a3d98c5ca91d8adbb5
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const vm = require("vm");
-
-test("vm.createContext with circular reference", () => {
-  let sbx = {};
-  sbx.window = sbx;
-
-  sbx = vm.createContext(sbx);
-
-  sbx.test = 123;
-
-  expect(sbx.window.window.window.window.window.test).toBe(123);
-});
-
-//<#END_FILE: test-vm-create-context-circular-reference.js
diff --git a/test/js/node/test/parallel/vm-cross-context.test.js b/test/js/node/test/parallel/vm-cross-context.test.js
deleted file mode 100644
index 52c716d18a..0000000000
--- a/test/js/node/test/parallel/vm-cross-context.test.js
+++ /dev/null
@@ -1,38 +0,0 @@
-//#FILE: test-vm-cross-context.js
-//#SHA1: c8f367f7edfa69a5b052feab2bb6c9326f16c9d3
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-const vm = require("vm");
-
-test("vm.runInContext should not throw when accessing console.log", () => {
-  const ctx = vm.createContext(global);
-
-  // Should not throw.
-  expect(() => {
-    vm.runInContext("!function() { var x = console.log; }()", ctx);
-  }).not.toThrow();
-});
-
-//<#END_FILE: test-vm-cross-context.js
diff --git a/test/js/node/test/parallel/vm-data-property-writable.test.js b/test/js/node/test/parallel/vm-data-property-writable.test.js
deleted file mode 100644
index e85965fb83..0000000000
--- a/test/js/node/test/parallel/vm-data-property-writable.test.js
+++ /dev/null
@@ -1,33 +0,0 @@
-//#FILE: test-vm-data-property-writable.js
-//#SHA1: fc562132c9b5c9f17d55e08df7456dea7a1f41e3
-//-----------------
-"use strict";
-// Refs: https://github.com/nodejs/node/issues/10223
-
-const vm = require("vm");
-
-test("vm data property writable", () => {
-  const context = vm.createContext({});
-
-  let code = `
-     Object.defineProperty(this, 'foo', {value: 5});
-     Object.getOwnPropertyDescriptor(this, 'foo');
-  `;
-
-  let desc = vm.runInContext(code, context);
-
-  expect(desc.writable).toBe(false);
-
-  // Check that interceptors work for symbols.
-  code = `
-     const bar = Symbol('bar');
-     Object.defineProperty(this, bar, {value: 6});
-     Object.getOwnPropertyDescriptor(this, bar);
-  `;
-
-  desc = vm.runInContext(code, context);
-
-  expect(desc.value).toBe(6);
-});
-
-//<#END_FILE: test-vm-data-property-writable.js
diff --git a/test/js/node/test/parallel/vm-deleting-property.test.js b/test/js/node/test/parallel/vm-deleting-property.test.js
deleted file mode 100644
index ac94e9a72d..0000000000
--- a/test/js/node/test/parallel/vm-deleting-property.test.js
+++ /dev/null
@@ -1,23 +0,0 @@
-//#FILE: test-vm-deleting-property.js
-//#SHA1: 20a3a3752a4d1b140cd8762c1d66c8dc734ed3fa
-//-----------------
-"use strict";
-// Refs: https://github.com/nodejs/node/issues/6287
-
-const vm = require("vm");
-
-test("deleting property in vm context", () => {
-  const context = vm.createContext();
-  const res = vm.runInContext(
-    `
-    this.x = 'prop';
-    delete this.x;
-    Object.getOwnPropertyDescriptor(this, 'x');
-  `,
-    context,
-  );
-
-  expect(res).toBeUndefined();
-});
-
-//<#END_FILE: test-vm-deleting-property.js
diff --git a/test/js/node/test/parallel/vm-function-redefinition.test.js b/test/js/node/test/parallel/vm-function-redefinition.test.js
deleted file mode 100644
index 6395cbd57e..0000000000
--- a/test/js/node/test/parallel/vm-function-redefinition.test.js
+++ /dev/null
@@ -1,17 +0,0 @@
-//#FILE: test-vm-function-redefinition.js
-//#SHA1: afca30c05276f19448e4a2e01381c8a6fb13d544
-//-----------------
-"use strict";
-// Refs: https://github.com/nodejs/node/issues/548
-const vm = require("vm");
-
-test("function redefinition in vm context", () => {
-  const context = vm.createContext();
-
-  vm.runInContext("function test() { return 0; }", context);
-  vm.runInContext("function test() { return 1; }", context);
-  const result = vm.runInContext("test()", context);
-  expect(result).toBe(1);
-});
-
-//<#END_FILE: test-vm-function-redefinition.js
diff --git a/test/js/node/test/parallel/vm-global-assignment.test.js b/test/js/node/test/parallel/vm-global-assignment.test.js
deleted file mode 100644
index bacb3cf2d7..0000000000
--- a/test/js/node/test/parallel/vm-global-assignment.test.js
+++ /dev/null
@@ -1,36 +0,0 @@
-//#FILE: test-vm-global-assignment.js
-//#SHA1: 54d8ce4e5d93c89a8573a3230065f4e244b198db
-//-----------------
-"use strict";
-
-// Regression test for https://github.com/nodejs/node/issues/10806
-
-const vm = require("vm");
-
-describe("VM global assignment", () => {
-  let ctx;
-  let window;
-  const other = 123;
-
-  beforeEach(() => {
-    ctx = vm.createContext({ open() {} });
-    window = vm.runInContext("this", ctx);
-  });
-
-  test("window.open is not equal to other initially", () => {
-    expect(window.open).not.toBe(other);
-  });
-
-  test("window.open can be assigned", () => {
-    window.open = other;
-    expect(window.open).toBe(other);
-  });
-
-  test("window.open can be reassigned", () => {
-    window.open = other;
-    window.open = other;
-    expect(window.open).toBe(other);
-  });
-});
-
-//<#END_FILE: test-vm-global-assignment.js
diff --git a/test/js/node/test/parallel/vm-global-configurable-properties.test.js b/test/js/node/test/parallel/vm-global-configurable-properties.test.js
deleted file mode 100644
index 860b260159..0000000000
--- a/test/js/node/test/parallel/vm-global-configurable-properties.test.js
+++ /dev/null
@@ -1,21 +0,0 @@
-//#FILE: test-vm-global-configurable-properties.js
-//#SHA1: abaa38afe456cd1fcf98be472781d25e3918d1b5
-//-----------------
-"use strict";
-// https://github.com/nodejs/node/issues/47799
-
-const vm = require("vm");
-
-test("VM global configurable properties", () => {
-  const ctx = vm.createContext();
-
-  const window = vm.runInContext("this", ctx);
-
-  Object.defineProperty(window, "x", { value: "1", configurable: true });
-  expect(window.x).toBe("1");
-
-  Object.defineProperty(window, "x", { value: "2", configurable: true });
-  expect(window.x).toBe("2");
-});
-
-//<#END_FILE: test-vm-global-configurable-properties.js
diff --git a/test/js/node/test/parallel/vm-harmony-symbols.test.js b/test/js/node/test/parallel/vm-harmony-symbols.test.js
deleted file mode 100644
index 1d8b86bdc4..0000000000
--- a/test/js/node/test/parallel/vm-harmony-symbols.test.js
+++ /dev/null
@@ -1,42 +0,0 @@
-//#FILE: test-vm-harmony-symbols.js
-//#SHA1: 36768ab105e0bcc19dccae0fea22801068fdaedd
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const vm = require("vm");
-
-test("The sandbox should have its own Symbol constructor", () => {
-  let sandbox = {};
-  vm.runInNewContext("this.Symbol = Symbol", sandbox);
-  expect(typeof sandbox.Symbol).toBe("function");
-  expect(sandbox.Symbol).not.toBe(Symbol);
-});
-
-test("Explicitly copying the Symbol constructor", () => {
-  let sandbox = { Symbol };
-  vm.runInNewContext("this.Symbol = Symbol", sandbox);
-  expect(typeof sandbox.Symbol).toBe("function");
-  expect(sandbox.Symbol).toBe(Symbol);
-});
-
-//<#END_FILE: test-vm-harmony-symbols.js
diff --git a/test/js/node/test/parallel/vm-indexed-properties.test.js b/test/js/node/test/parallel/vm-indexed-properties.test.js
deleted file mode 100644
index 6b9999fadf..0000000000
--- a/test/js/node/test/parallel/vm-indexed-properties.test.js
+++ /dev/null
@@ -1,21 +0,0 @@
-//#FILE: test-vm-indexed-properties.js
-//#SHA1: 5938ca1da86f05ceda978b0f2d9640734d6c0ab6
-//-----------------
-"use strict";
-
-const vm = require("vm");
-
-test("vm indexed properties", () => {
-  const code = `Object.defineProperty(this, 99, {
-    value: 20,
-    enumerable: true
-  });`;
-
-  const sandbox = {};
-  const ctx = vm.createContext(sandbox);
-  vm.runInContext(code, ctx);
-
-  expect(sandbox[99]).toBe(20);
-});
-
-//<#END_FILE: test-vm-indexed-properties.js
diff --git a/test/js/node/test/parallel/vm-low-stack-space.test.js b/test/js/node/test/parallel/vm-low-stack-space.test.js
deleted file mode 100644
index e4ccd2e9b2..0000000000
--- a/test/js/node/test/parallel/vm-low-stack-space.test.js
+++ /dev/null
@@ -1,33 +0,0 @@
-//#FILE: test-vm-low-stack-space.js
-//#SHA1: fffd6c9c17b9ff755e1dd126a42d6ea176282d00
-//-----------------
-"use strict";
-const vm = require("vm");
-
-test("vm.runInThisContext in low stack space", () => {
-  function a() {
-    try {
-      return a();
-    } catch {
-      // Throw an exception as near to the recursion-based RangeError as possible.
-      return vm.runInThisContext("() => 42")();
-    }
-  }
-
-  expect(a()).toBe(42);
-});
-
-test("vm.runInNewContext in low stack space", () => {
-  function b() {
-    try {
-      return b();
-    } catch {
-      // This writes a lot of noise to stderr, but it still works.
-      return vm.runInNewContext("() => 42")();
-    }
-  }
-
-  expect(b()).toBe(42);
-});
-
-//<#END_FILE: test-vm-low-stack-space.js
diff --git a/test/js/node/test/parallel/vm-proxies.test.js b/test/js/node/test/parallel/vm-proxies.test.js
deleted file mode 100644
index b713c7773a..0000000000
--- a/test/js/node/test/parallel/vm-proxies.test.js
+++ /dev/null
@@ -1,25 +0,0 @@
-//#FILE: test-vm-proxies.js
-//#SHA1: 3119c41e6c3cc80d380c9467c2f922b2df3e5616
-//-----------------
-"use strict";
-
-const vm = require("vm");
-
-test("Proxy object in new context", () => {
-  // src/node_contextify.cc filters out the Proxy object from the parent
-  // context.  Make sure that the new context has a Proxy object of its own.
-  let sandbox = {};
-  vm.runInNewContext("this.Proxy = Proxy", sandbox);
-  expect(typeof sandbox.Proxy).toBe("function");
-  expect(sandbox.Proxy).not.toBe(Proxy);
-});
-
-test("Explicitly copied Proxy object in new context", () => {
-  // Unless we copy the Proxy object explicitly, of course.
-  const sandbox = { Proxy };
-  vm.runInNewContext("this.Proxy = Proxy", sandbox);
-  expect(typeof sandbox.Proxy).toBe("function");
-  expect(sandbox.Proxy).toBe(Proxy);
-});
-
-//<#END_FILE: test-vm-proxies.js
diff --git a/test/js/node/test/parallel/vm-proxy-failure-cp.test.js b/test/js/node/test/parallel/vm-proxy-failure-cp.test.js
deleted file mode 100644
index 05d2c1e7b7..0000000000
--- a/test/js/node/test/parallel/vm-proxy-failure-cp.test.js
+++ /dev/null
@@ -1,23 +0,0 @@
-//#FILE: test-vm-proxy-failure-CP.js
-//#SHA1: d3eb5284a94f718a6ae1e07c0b30e01dad295ea9
-//-----------------
-"use strict";
-const vm = require("vm");
-
-// Check that we do not accidentally query attributes.
-// Issue: https://github.com/nodejs/node/issues/11902
-test("vm does not accidentally query attributes", () => {
-  const handler = {
-    getOwnPropertyDescriptor: (target, prop) => {
-      throw new Error("whoops");
-    },
-  };
-  const sandbox = new Proxy({ foo: "bar" }, handler);
-  const context = vm.createContext(sandbox);
-
-  expect(() => {
-    vm.runInContext("", context);
-  }).not.toThrow();
-});
-
-//<#END_FILE: test-vm-proxy-failure-CP.js
diff --git a/test/js/node/test/parallel/vm-script-throw-in-tostring.test.js b/test/js/node/test/parallel/vm-script-throw-in-tostring.test.js
deleted file mode 100644
index acd0eeb817..0000000000
--- a/test/js/node/test/parallel/vm-script-throw-in-tostring.test.js
+++ /dev/null
@@ -1,22 +0,0 @@
-//#FILE: test-vm-script-throw-in-tostring.js
-//#SHA1: 16675c8942dbb81a032c117fa42c9611cda082e0
-//-----------------
-"use strict";
-
-const vm = require("vm");
-
-test("vm.Script throws when toString throws", () => {
-  expect(() => {
-    new vm.Script({
-      toString() {
-        throw new Error();
-      },
-    });
-  }).toThrow(
-    expect.objectContaining({
-      message: expect.any(String),
-    }),
-  );
-});
-
-//<#END_FILE: test-vm-script-throw-in-tostring.js
diff --git a/test/js/node/test/parallel/vm-strict-mode.test.js b/test/js/node/test/parallel/vm-strict-mode.test.js
deleted file mode 100644
index e2f06f8555..0000000000
--- a/test/js/node/test/parallel/vm-strict-mode.test.js
+++ /dev/null
@@ -1,21 +0,0 @@
-//#FILE: test-vm-strict-mode.js
-//#SHA1: ab6c6c72920e9bf095b41b255872b9d0604301c7
-//-----------------
-"use strict";
-// https://github.com/nodejs/node/issues/12300
-
-const vm = require("vm");
-
-test("vm strict mode assignment", () => {
-  const ctx = vm.createContext({ x: 42 });
-
-  // This might look as if x has not been declared, but x is defined on the
-  // sandbox and the assignment should not throw.
-  expect(() => {
-    vm.runInContext('"use strict"; x = 1', ctx);
-  }).not.toThrow();
-
-  expect(ctx.x).toBe(1);
-});
-
-//<#END_FILE: test-vm-strict-mode.js
diff --git a/test/js/node/test/parallel/vm-syntax-error-message.test.js b/test/js/node/test/parallel/vm-syntax-error-message.test.js
deleted file mode 100644
index 49be35047c..0000000000
--- a/test/js/node/test/parallel/vm-syntax-error-message.test.js
+++ /dev/null
@@ -1,31 +0,0 @@
-//#FILE: test-vm-syntax-error-message.js
-//#SHA1: dbd3683e08ad5cf574d1824108446e9c425adf1b
-//-----------------
-"use strict";
-
-const child_process = require("child_process");
-
-test("vm syntax error message", done => {
-  const p = child_process.spawn(process.execPath, [
-    "-e",
-    'vm = require("vm");' +
-      "context = vm.createContext({});" +
-      "try { vm.runInContext(\"throw new Error('boo')\", context); } " +
-      "catch (e) { console.log(e.message); }",
-  ]);
-
-  p.stderr.on("data", () => {
-    throw new Error("stderr should not receive any data");
-  });
-
-  let output = "";
-
-  p.stdout.on("data", data => (output += data));
-
-  p.stdout.on("end", () => {
-    expect(output.replace(/[\r\n]+/g, "")).toBe("boo");
-    done();
-  });
-});
-
-//<#END_FILE: test-vm-syntax-error-message.js
diff --git a/test/js/node/test/parallel/webcrypto-encrypt-decrypt.test.js b/test/js/node/test/parallel/webcrypto-encrypt-decrypt.test.js
deleted file mode 100644
index 560edf8eb6..0000000000
--- a/test/js/node/test/parallel/webcrypto-encrypt-decrypt.test.js
+++ /dev/null
@@ -1,110 +0,0 @@
-//#FILE: test-webcrypto-encrypt-decrypt.js
-//#SHA1: 791cad35ebee437d2a982e6101d47daa2f775a4b
-//-----------------
-"use strict";
-
-const { subtle } = globalThis.crypto;
-
-// This is only a partial test. The WebCrypto Web Platform Tests
-// will provide much greater coverage.
-
-// Test Encrypt/Decrypt RSA-OAEP
-test("Encrypt/Decrypt RSA-OAEP", async () => {
-  const buf = globalThis.crypto.getRandomValues(new Uint8Array(50));
-  const ec = new TextEncoder();
-  const { publicKey, privateKey } = await subtle.generateKey(
-    {
-      name: "RSA-OAEP",
-      modulusLength: 2048,
-      publicExponent: new Uint8Array([1, 0, 1]),
-      hash: "SHA-384",
-    },
-    true,
-    ["encrypt", "decrypt"],
-  );
-
-  const ciphertext = await subtle.encrypt(
-    {
-      name: "RSA-OAEP",
-      label: ec.encode("a label"),
-    },
-    publicKey,
-    buf,
-  );
-
-  const plaintext = await subtle.decrypt(
-    {
-      name: "RSA-OAEP",
-      label: ec.encode("a label"),
-    },
-    privateKey,
-    ciphertext,
-  );
-
-  expect(Buffer.from(plaintext).toString("hex")).toBe(Buffer.from(buf).toString("hex"));
-});
-
-// Test Encrypt/Decrypt AES-CTR
-test("Encrypt/Decrypt AES-CTR", async () => {
-  const buf = globalThis.crypto.getRandomValues(new Uint8Array(50));
-  const counter = globalThis.crypto.getRandomValues(new Uint8Array(16));
-
-  const key = await subtle.generateKey(
-    {
-      name: "AES-CTR",
-      length: 256,
-    },
-    true,
-    ["encrypt", "decrypt"],
-  );
-
-  const ciphertext = await subtle.encrypt({ name: "AES-CTR", counter, length: 64 }, key, buf);
-
-  const plaintext = await subtle.decrypt({ name: "AES-CTR", counter, length: 64 }, key, ciphertext);
-
-  expect(Buffer.from(plaintext).toString("hex")).toBe(Buffer.from(buf).toString("hex"));
-});
-
-// Test Encrypt/Decrypt AES-CBC
-test("Encrypt/Decrypt AES-CBC", async () => {
-  const buf = globalThis.crypto.getRandomValues(new Uint8Array(50));
-  const iv = globalThis.crypto.getRandomValues(new Uint8Array(16));
-
-  const key = await subtle.generateKey(
-    {
-      name: "AES-CBC",
-      length: 256,
-    },
-    true,
-    ["encrypt", "decrypt"],
-  );
-
-  const ciphertext = await subtle.encrypt({ name: "AES-CBC", iv }, key, buf);
-
-  const plaintext = await subtle.decrypt({ name: "AES-CBC", iv }, key, ciphertext);
-
-  expect(Buffer.from(plaintext).toString("hex")).toBe(Buffer.from(buf).toString("hex"));
-});
-
-// Test Encrypt/Decrypt AES-GCM
-test("Encrypt/Decrypt AES-GCM", async () => {
-  const buf = globalThis.crypto.getRandomValues(new Uint8Array(50));
-  const iv = globalThis.crypto.getRandomValues(new Uint8Array(12));
-
-  const key = await subtle.generateKey(
-    {
-      name: "AES-GCM",
-      length: 256,
-    },
-    true,
-    ["encrypt", "decrypt"],
-  );
-
-  const ciphertext = await subtle.encrypt({ name: "AES-GCM", iv }, key, buf);
-
-  const plaintext = await subtle.decrypt({ name: "AES-GCM", iv }, key, ciphertext);
-
-  expect(Buffer.from(plaintext).toString("hex")).toBe(Buffer.from(buf).toString("hex"));
-});
-
-//<#END_FILE: test-webcrypto-encrypt-decrypt.js
diff --git a/test/js/node/test/parallel/webcrypto-getrandomvalues.test.js b/test/js/node/test/parallel/webcrypto-getrandomvalues.test.js
deleted file mode 100644
index 3ec9961927..0000000000
--- a/test/js/node/test/parallel/webcrypto-getrandomvalues.test.js
+++ /dev/null
@@ -1,26 +0,0 @@
-//#FILE: test-webcrypto-getRandomValues.js
-//#SHA1: d5d696eb0e68968d2411efa24e6e4c9bd46a1678
-//-----------------
-"use strict";
-
-if (!globalThis.crypto) {
-  it("skips test when crypto is missing", () => {
-    console.log("missing crypto");
-    return;
-  });
-} else {
-  describe("webcrypto getRandomValues", () => {
-    const { getRandomValues } = globalThis.crypto;
-
-    it("throws ERR_INVALID_THIS when called without proper this", () => {
-      expect(() => getRandomValues(new Uint8Array())).toThrow(
-        expect.objectContaining({
-          code: "ERR_INVALID_THIS",
-          message: expect.any(String),
-        }),
-      );
-    });
-  });
-}
-
-//<#END_FILE: test-webcrypto-getRandomValues.js
diff --git a/test/js/node/test/parallel/webstream-string-tag.test.js b/test/js/node/test/parallel/webstream-string-tag.test.js
deleted file mode 100644
index f8791dbe76..0000000000
--- a/test/js/node/test/parallel/webstream-string-tag.test.js
+++ /dev/null
@@ -1,34 +0,0 @@
-//#FILE: test-webstream-string-tag.js
-//#SHA1: 53f13b84555ff37eeee23ca4552540d76b88c2ad
-//-----------------
-"use strict";
-
-test("Web Stream classes have correct Symbol.toStringTag", () => {
-  const classesToBeTested = [
-    WritableStream,
-    WritableStreamDefaultWriter,
-    WritableStreamDefaultController,
-    ReadableStream,
-    ReadableStreamBYOBRequest,
-    ReadableStreamDefaultReader,
-    ReadableStreamBYOBReader,
-    ReadableStreamDefaultController,
-    ReadableByteStreamController,
-    ByteLengthQueuingStrategy,
-    CountQueuingStrategy,
-    TransformStream,
-    TransformStreamDefaultController,
-  ];
-
-  classesToBeTested.forEach(cls => {
-    expect(cls.prototype[Symbol.toStringTag]).toBe(cls.name);
-    expect(Object.getOwnPropertyDescriptor(cls.prototype, Symbol.toStringTag)).toEqual({
-      configurable: true,
-      enumerable: false,
-      value: cls.name,
-      writable: false,
-    });
-  });
-});
-
-//<#END_FILE: test-webstream-string-tag.js
diff --git a/test/js/node/test/parallel/whatwg-encoding-custom-api-basics.test.js b/test/js/node/test/parallel/whatwg-encoding-custom-api-basics.test.js
deleted file mode 100644
index b686f76961..0000000000
--- a/test/js/node/test/parallel/whatwg-encoding-custom-api-basics.test.js
+++ /dev/null
@@ -1,48 +0,0 @@
-//#FILE: test-whatwg-encoding-custom-api-basics.js
-//#SHA1: 8181a892b0d1e5885b29b1165631875e587b7700
-//-----------------
-"use strict";
-
-// From: https://github.com/w3c/web-platform-tests/blob/master/encoding/api-basics.html
-// This is the part that can be run without ICU
-
-function testDecodeSample(encoding, string, bytes) {
-  expect(new TextDecoder(encoding).decode(new Uint8Array(bytes))).toBe(string);
-  expect(new TextDecoder(encoding).decode(new Uint8Array(bytes).buffer)).toBe(string);
-}
-
-// `z` (ASCII U+007A), cent (Latin-1 U+00A2), CJK water (BMP U+6C34),
-// G-Clef (non-BMP U+1D11E), PUA (BMP U+F8FF), PUA (non-BMP U+10FFFD)
-// byte-swapped BOM (non-character U+FFFE)
-const sample = "z\xA2\u6C34\uD834\uDD1E\uF8FF\uDBFF\uDFFD\uFFFE";
-
-test("utf-8 encoding and decoding", () => {
-  const encoding = "utf-8";
-  const string = sample;
-  const bytes = [
-    0x7a, 0xc2, 0xa2, 0xe6, 0xb0, 0xb4, 0xf0, 0x9d, 0x84, 0x9e, 0xef, 0xa3, 0xbf, 0xf4, 0x8f, 0xbf, 0xbd, 0xef, 0xbf,
-    0xbe,
-  ];
-  const encoded = new TextEncoder().encode(string);
-  expect([...encoded]).toEqual(bytes);
-  expect(new TextDecoder(encoding).decode(new Uint8Array(bytes))).toBe(string);
-  expect(new TextDecoder(encoding).decode(new Uint8Array(bytes).buffer)).toBe(string);
-});
-
-test("utf-16le decoding", () => {
-  testDecodeSample(
-    "utf-16le",
-    sample,
-    [0x7a, 0x00, 0xa2, 0x00, 0x34, 0x6c, 0x34, 0xd8, 0x1e, 0xdd, 0xff, 0xf8, 0xff, 0xdb, 0xfd, 0xdf, 0xfe, 0xff],
-  );
-});
-
-test("utf-16 decoding", () => {
-  testDecodeSample(
-    "utf-16",
-    sample,
-    [0x7a, 0x00, 0xa2, 0x00, 0x34, 0x6c, 0x34, 0xd8, 0x1e, 0xdd, 0xff, 0xf8, 0xff, 0xdb, 0xfd, 0xdf, 0xfe, 0xff],
-  );
-});
-
-//<#END_FILE: test-whatwg-encoding-custom-api-basics.js
diff --git a/test/js/node/test/parallel/whatwg-encoding-custom-fatal-streaming.test.js b/test/js/node/test/parallel/whatwg-encoding-custom-fatal-streaming.test.js
deleted file mode 100644
index ce4cd6051f..0000000000
--- a/test/js/node/test/parallel/whatwg-encoding-custom-fatal-streaming.test.js
+++ /dev/null
@@ -1,61 +0,0 @@
-//#FILE: test-whatwg-encoding-custom-fatal-streaming.js
-//#SHA1: 325f0a1e055a1756532d2818d4e563dfbddb928b
-//-----------------
-"use strict";
-
-// From: https://github.com/w3c/web-platform-tests/blob/d74324b53c/encoding/textdecoder-fatal-streaming.html
-// With the twist that we specifically test for Node.js error codes
-
-if (!globalThis.Intl) {
-  test.skip("missing Intl", () => {});
-} else {
-  test("TextDecoder with fatal option and invalid sequences", () => {
-    [
-      { encoding: "utf-8", sequence: [0xc0] },
-      { encoding: "utf-16le", sequence: [0x00] },
-      { encoding: "utf-16be", sequence: [0x00] },
-    ].forEach(testCase => {
-      const data = new Uint8Array(testCase.sequence);
-      expect(() => {
-        const decoder = new TextDecoder(testCase.encoding, { fatal: true });
-        decoder.decode(data);
-      }).toThrow(
-        expect.objectContaining({
-          code: "ERR_ENCODING_INVALID_ENCODED_DATA",
-          name: "TypeError",
-          message: expect.any(String),
-        }),
-      );
-    });
-  });
-
-  test("TextDecoder with utf-16le and streaming", () => {
-    const decoder = new TextDecoder("utf-16le", { fatal: true });
-    const odd = new Uint8Array([0x00]);
-    const even = new Uint8Array([0x00, 0x00]);
-
-    expect(() => {
-      decoder.decode(even, { stream: true });
-      decoder.decode(odd);
-    }).toThrow(
-      expect.objectContaining({
-        code: "ERR_ENCODING_INVALID_ENCODED_DATA",
-        name: "TypeError",
-        message: expect.any(String),
-      }),
-    );
-
-    expect(() => {
-      decoder.decode(odd, { stream: true });
-      decoder.decode(even);
-    }).toThrow(
-      expect.objectContaining({
-        code: "ERR_ENCODING_INVALID_ENCODED_DATA",
-        name: "TypeError",
-        message: expect.any(String),
-      }),
-    );
-  });
-}
-
-//<#END_FILE: test-whatwg-encoding-custom-fatal-streaming.js
diff --git a/test/js/node/test/parallel/whatwg-encoding-custom-textdecoder-fatal.test.js b/test/js/node/test/parallel/whatwg-encoding-custom-textdecoder-fatal.test.js
deleted file mode 100644
index 14aa0d31c3..0000000000
--- a/test/js/node/test/parallel/whatwg-encoding-custom-textdecoder-fatal.test.js
+++ /dev/null
@@ -1,68 +0,0 @@
-//#FILE: test-whatwg-encoding-custom-textdecoder-fatal.js
-//#SHA1: e2b44e43b78b053687ab4a8dc5de7557f6637643
-//-----------------
-"use strict";
-
-// From: https://github.com/w3c/web-platform-tests/blob/39a67e2fff/encoding/textdecoder-fatal.html
-// With the twist that we specifically test for Node.js error codes
-
-if (!globalThis.Intl) {
-  test.skip("missing Intl");
-}
-
-const bad = [
-  { encoding: "utf-8", input: [0xff], name: "invalid code" },
-  { encoding: "utf-8", input: [0xc0], name: "ends early" },
-  { encoding: "utf-8", input: [0xe0], name: "ends early 2" },
-  { encoding: "utf-8", input: [0xc0, 0x00], name: "invalid trail" },
-  { encoding: "utf-8", input: [0xc0, 0xc0], name: "invalid trail 2" },
-  { encoding: "utf-8", input: [0xe0, 0x00], name: "invalid trail 3" },
-  { encoding: "utf-8", input: [0xe0, 0xc0], name: "invalid trail 4" },
-  { encoding: "utf-8", input: [0xe0, 0x80, 0x00], name: "invalid trail 5" },
-  { encoding: "utf-8", input: [0xe0, 0x80, 0xc0], name: "invalid trail 6" },
-  { encoding: "utf-8", input: [0xfc, 0x80, 0x80, 0x80, 0x80, 0x80], name: "> 0x10FFFF" },
-  { encoding: "utf-8", input: [0xfe, 0x80, 0x80, 0x80, 0x80, 0x80], name: "obsolete lead byte" },
-  // Overlong encodings
-  { encoding: "utf-8", input: [0xc0, 0x80], name: "overlong U+0000 - 2 bytes" },
-  { encoding: "utf-8", input: [0xe0, 0x80, 0x80], name: "overlong U+0000 - 3 bytes" },
-  { encoding: "utf-8", input: [0xf0, 0x80, 0x80, 0x80], name: "overlong U+0000 - 4 bytes" },
-  { encoding: "utf-8", input: [0xf8, 0x80, 0x80, 0x80, 0x80], name: "overlong U+0000 - 5 bytes" },
-  { encoding: "utf-8", input: [0xfc, 0x80, 0x80, 0x80, 0x80, 0x80], name: "overlong U+0000 - 6 bytes" },
-  { encoding: "utf-8", input: [0xc1, 0xbf], name: "overlong U+007F - 2 bytes" },
-  { encoding: "utf-8", input: [0xe0, 0x81, 0xbf], name: "overlong U+007F - 3 bytes" },
-  { encoding: "utf-8", input: [0xf0, 0x80, 0x81, 0xbf], name: "overlong U+007F - 4 bytes" },
-  { encoding: "utf-8", input: [0xf8, 0x80, 0x80, 0x81, 0xbf], name: "overlong U+007F - 5 bytes" },
-  { encoding: "utf-8", input: [0xfc, 0x80, 0x80, 0x80, 0x81, 0xbf], name: "overlong U+007F - 6 bytes" },
-  { encoding: "utf-8", input: [0xe0, 0x9f, 0xbf], name: "overlong U+07FF - 3 bytes" },
-  { encoding: "utf-8", input: [0xf0, 0x80, 0x9f, 0xbf], name: "overlong U+07FF - 4 bytes" },
-  { encoding: "utf-8", input: [0xf8, 0x80, 0x80, 0x9f, 0xbf], name: "overlong U+07FF - 5 bytes" },
-  { encoding: "utf-8", input: [0xfc, 0x80, 0x80, 0x80, 0x9f, 0xbf], name: "overlong U+07FF - 6 bytes" },
-  { encoding: "utf-8", input: [0xf0, 0x8f, 0xbf, 0xbf], name: "overlong U+FFFF - 4 bytes" },
-  { encoding: "utf-8", input: [0xf8, 0x80, 0x8f, 0xbf, 0xbf], name: "overlong U+FFFF - 5 bytes" },
-  { encoding: "utf-8", input: [0xfc, 0x80, 0x80, 0x8f, 0xbf, 0xbf], name: "overlong U+FFFF - 6 bytes" },
-  { encoding: "utf-8", input: [0xf8, 0x84, 0x8f, 0xbf, 0xbf], name: "overlong U+10FFFF - 5 bytes" },
-  { encoding: "utf-8", input: [0xfc, 0x80, 0x84, 0x8f, 0xbf, 0xbf], name: "overlong U+10FFFF - 6 bytes" },
-  // UTF-16 surrogates encoded as code points in UTF-8
-  { encoding: "utf-8", input: [0xed, 0xa0, 0x80], name: "lead surrogate" },
-  { encoding: "utf-8", input: [0xed, 0xb0, 0x80], name: "trail surrogate" },
-  { encoding: "utf-8", input: [0xed, 0xa0, 0x80, 0xed, 0xb0, 0x80], name: "surrogate pair" },
-  { encoding: "utf-16le", input: [0x00], name: "truncated code unit" },
-  // Mismatched UTF-16 surrogates are exercised in utf16-surrogates.html
-  // FIXME: Add legacy encoding cases
-];
-
-bad.forEach(t => {
-  test(`TextDecoder fatal error: ${t.name}`, () => {
-    expect(() => {
-      new TextDecoder(t.encoding, { fatal: true }).decode(new Uint8Array(t.input));
-    }).toThrow(
-      expect.objectContaining({
-        code: "ERR_ENCODING_INVALID_ENCODED_DATA",
-        name: "TypeError",
-        message: expect.any(String),
-      }),
-    );
-  });
-});
-
-//<#END_FILE: test-whatwg-encoding-custom-textdecoder-fatal.js
diff --git a/test/js/node/test/parallel/whatwg-encoding-custom-textdecoder-ignorebom.test.js b/test/js/node/test/parallel/whatwg-encoding-custom-textdecoder-ignorebom.test.js
deleted file mode 100644
index 43a7a005ce..0000000000
--- a/test/js/node/test/parallel/whatwg-encoding-custom-textdecoder-ignorebom.test.js
+++ /dev/null
@@ -1,35 +0,0 @@
-//#FILE: test-whatwg-encoding-custom-textdecoder-ignorebom.js
-//#SHA1: 8a119026559b0341b524a97eaaf87e948a502dd6
-//-----------------
-"use strict";
-
-// From: https://github.com/w3c/web-platform-tests/blob/7f567fa29c/encoding/textdecoder-ignorebom.html
-// This is the part that can be run without ICU
-
-const cases = [
-  {
-    encoding: "utf-8",
-    bytes: [0xef, 0xbb, 0xbf, 0x61, 0x62, 0x63],
-  },
-  {
-    encoding: "utf-16le",
-    bytes: [0xff, 0xfe, 0x61, 0x00, 0x62, 0x00, 0x63, 0x00],
-  },
-];
-
-cases.forEach(testCase => {
-  test(`TextDecoder with ${testCase.encoding} encoding`, () => {
-    const BOM = "\uFEFF";
-    let decoder = new TextDecoder(testCase.encoding, { ignoreBOM: true });
-    const bytes = new Uint8Array(testCase.bytes);
-    expect(decoder.decode(bytes)).toBe(`${BOM}abc`);
-
-    decoder = new TextDecoder(testCase.encoding, { ignoreBOM: false });
-    expect(decoder.decode(bytes)).toBe("abc");
-
-    decoder = new TextDecoder(testCase.encoding);
-    expect(decoder.decode(bytes)).toBe("abc");
-  });
-});
-
-//<#END_FILE: test-whatwg-encoding-custom-textdecoder-ignorebom.js
diff --git a/test/js/node/test/parallel/whatwg-encoding-custom-textdecoder-invalid-arg.test.js b/test/js/node/test/parallel/whatwg-encoding-custom-textdecoder-invalid-arg.test.js
deleted file mode 100644
index 6389f03fbd..0000000000
--- a/test/js/node/test/parallel/whatwg-encoding-custom-textdecoder-invalid-arg.test.js
+++ /dev/null
@@ -1,24 +0,0 @@
-//#FILE: test-whatwg-encoding-custom-textdecoder-invalid-arg.js
-//#SHA1: eaf5b5a330366828645f6a0be0dbd859cf9f1bda
-//-----------------
-"use strict";
-
-// This tests that ERR_INVALID_ARG_TYPE are thrown when
-// invalid arguments are passed to TextDecoder.
-
-test("TextDecoder throws ERR_INVALID_ARG_TYPE for invalid input types", () => {
-  const notArrayBufferViewExamples = [false, {}, 1, "", new Error()];
-  notArrayBufferViewExamples.forEach(invalidInputType => {
-    expect(() => {
-      new TextDecoder(undefined, null).decode(invalidInputType);
-    }).toThrow(
-      expect.objectContaining({
-        code: "ERR_INVALID_ARG_TYPE",
-        name: "TypeError",
-        message: expect.any(String),
-      }),
-    );
-  });
-});
-
-//<#END_FILE: test-whatwg-encoding-custom-textdecoder-invalid-arg.js
diff --git a/test/js/node/test/parallel/whatwg-encoding-custom-textdecoder-streaming.test.js b/test/js/node/test/parallel/whatwg-encoding-custom-textdecoder-streaming.test.js
deleted file mode 100644
index af2ab322ed..0000000000
--- a/test/js/node/test/parallel/whatwg-encoding-custom-textdecoder-streaming.test.js
+++ /dev/null
@@ -1,40 +0,0 @@
-//#FILE: test-whatwg-encoding-custom-textdecoder-streaming.js
-//#SHA1: d98fc14ce0348f22b3bae160b4e1e4882ce75749
-//-----------------
-"use strict";
-
-// From: https://github.com/w3c/web-platform-tests/blob/fa9436d12c/encoding/textdecoder-streaming.html
-// This is the part that can be run without ICU
-
-const string = "\x00123ABCabc\x80\xFF\u0100\u1000\uFFFD\uD800\uDC00\uDBFF\uDFFF";
-const octets = {
-  "utf-8": [
-    0x00, 0x31, 0x32, 0x33, 0x41, 0x42, 0x43, 0x61, 0x62, 0x63, 0xc2, 0x80, 0xc3, 0xbf, 0xc4, 0x80, 0xe1, 0x80, 0x80,
-    0xef, 0xbf, 0xbd, 0xf0, 0x90, 0x80, 0x80, 0xf4, 0x8f, 0xbf, 0xbf,
-  ],
-  "utf-16le": [
-    0x00, 0x00, 0x31, 0x00, 0x32, 0x00, 0x33, 0x00, 0x41, 0x00, 0x42, 0x00, 0x43, 0x00, 0x61, 0x00, 0x62, 0x00, 0x63,
-    0x00, 0x80, 0x00, 0xff, 0x00, 0x00, 0x01, 0x00, 0x10, 0xfd, 0xff, 0x00, 0xd8, 0x00, 0xdc, 0xff, 0xdb, 0xff, 0xdf,
-  ],
-};
-
-Object.keys(octets).forEach(encoding => {
-  describe(`TextDecoder streaming for ${encoding}`, () => {
-    for (let len = 1; len <= 5; ++len) {
-      it(`should correctly decode with chunk size ${len}`, () => {
-        const encoded = octets[encoding];
-        const decoder = new TextDecoder(encoding);
-        let out = "";
-        for (let i = 0; i < encoded.length; i += len) {
-          const sub = [];
-          for (let j = i; j < encoded.length && j < i + len; ++j) sub.push(encoded[j]);
-          out += decoder.decode(new Uint8Array(sub), { stream: true });
-        }
-        out += decoder.decode();
-        expect(out).toBe(string);
-      });
-    }
-  });
-});
-
-//<#END_FILE: test-whatwg-encoding-custom-textdecoder-streaming.js
diff --git a/test/js/node/test/parallel/whatwg-encoding-custom-textdecoder-utf16-surrogates.test.js b/test/js/node/test/parallel/whatwg-encoding-custom-textdecoder-utf16-surrogates.test.js
deleted file mode 100644
index 22c5f5f5da..0000000000
--- a/test/js/node/test/parallel/whatwg-encoding-custom-textdecoder-utf16-surrogates.test.js
+++ /dev/null
@@ -1,60 +0,0 @@
-//#FILE: test-whatwg-encoding-custom-textdecoder-utf16-surrogates.js
-//#SHA1: 0b74fafedb0961a831dff991c01aba65b15efb80
-//-----------------
-"use strict";
-
-// From: https://github.com/w3c/web-platform-tests/blob/39a67e2fff/encoding/textdecoder-utf16-surrogates.html
-// With the twist that we specifically test for Node.js error codes
-
-if (!globalThis.Intl) {
-  test.skip("missing Intl");
-}
-
-const bad = [
-  {
-    encoding: "utf-16le",
-    input: [0x00, 0xd8],
-    expected: "\uFFFD",
-    name: "lone surrogate lead",
-  },
-  {
-    encoding: "utf-16le",
-    input: [0x00, 0xdc],
-    expected: "\uFFFD",
-    name: "lone surrogate trail",
-  },
-  {
-    encoding: "utf-16le",
-    input: [0x00, 0xd8, 0x00, 0x00],
-    expected: "\uFFFD\u0000",
-    name: "unmatched surrogate lead",
-  },
-  {
-    encoding: "utf-16le",
-    input: [0x00, 0xdc, 0x00, 0x00],
-    expected: "\uFFFD\u0000",
-    name: "unmatched surrogate trail",
-  },
-  {
-    encoding: "utf-16le",
-    input: [0x00, 0xdc, 0x00, 0xd8],
-    expected: "\uFFFD\uFFFD",
-    name: "swapped surrogate pair",
-  },
-];
-
-bad.forEach(t => {
-  test(`TextDecoder with fatal option throws for ${t.name}`, () => {
-    expect(() => {
-      new TextDecoder(t.encoding, { fatal: true }).decode(new Uint8Array(t.input));
-    }).toThrow(
-      expect.objectContaining({
-        code: "ERR_ENCODING_INVALID_ENCODED_DATA",
-        name: "TypeError",
-        message: expect.any(String),
-      }),
-    );
-  });
-});
-
-//<#END_FILE: test-whatwg-encoding-custom-textdecoder-utf16-surrogates.js
diff --git a/test/js/node/test/parallel/whatwg-events-add-event-listener-options-passive.test.js b/test/js/node/test/parallel/whatwg-events-add-event-listener-options-passive.test.js
deleted file mode 100644
index a918709441..0000000000
--- a/test/js/node/test/parallel/whatwg-events-add-event-listener-options-passive.test.js
+++ /dev/null
@@ -1,62 +0,0 @@
-//#FILE: test-whatwg-events-add-event-listener-options-passive.js
-//#SHA1: e3c00da24b307d0e8466611bee33f70db48ad39c
-//-----------------
-"use strict";
-
-// Manually converted from https://github.com/web-platform-tests/wpt/blob/master/dom/events/AddEventListenerOptions-passive.html
-// in order to define the `document` ourselves
-
-test("AddEventListener options passive", () => {
-  const document = new EventTarget();
-  let supportsPassive = false;
-  const query_options = {
-    get passive() {
-      supportsPassive = true;
-      return false;
-    },
-    get dummy() {
-      throw new Error("dummy value getter invoked");
-    },
-  };
-
-  document.addEventListener("test_event", null, query_options);
-  expect(supportsPassive).toBe(true);
-
-  supportsPassive = false;
-  document.removeEventListener("test_event", null, query_options);
-  expect(supportsPassive).toBe(false);
-});
-
-test("testPassiveValue", () => {
-  function testPassiveValue(optionsValue, expectedDefaultPrevented) {
-    const document = new EventTarget();
-    let defaultPrevented;
-    function handler(e) {
-      if (e.defaultPrevented) {
-        throw new Error("Event prematurely marked defaultPrevented");
-      }
-      e.preventDefault();
-      defaultPrevented = e.defaultPrevented;
-    }
-    document.addEventListener("test", handler, optionsValue);
-    // TODO the WHATWG test is more extensive here and tests dispatching on
-    // document.body, if we ever support getParent we should amend this
-    const ev = new Event("test", { bubbles: true, cancelable: true });
-    const uncanceled = document.dispatchEvent(ev);
-
-    expect(defaultPrevented).toBe(expectedDefaultPrevented);
-    expect(uncanceled).toBe(!expectedDefaultPrevented);
-
-    document.removeEventListener("test", handler, optionsValue);
-  }
-  testPassiveValue(undefined, true);
-  testPassiveValue({}, true);
-  testPassiveValue({ passive: false }, true);
-
-  // TODO: passive listeners is still broken
-  // testPassiveValue({ passive: 1 }, false);
-  // testPassiveValue({ passive: true }, false);
-  // testPassiveValue({ passive: 0 }, true);
-});
-
-//<#END_FILE: test-whatwg-events-add-event-listener-options-passive.js
diff --git a/test/js/node/test/parallel/whatwg-events-add-event-listener-options-signal.test.js b/test/js/node/test/parallel/whatwg-events-add-event-listener-options-signal.test.js
deleted file mode 100644
index db5c7ef849..0000000000
--- a/test/js/node/test/parallel/whatwg-events-add-event-listener-options-signal.test.js
+++ /dev/null
@@ -1,176 +0,0 @@
-//#FILE: test-whatwg-events-add-event-listener-options-signal.js
-//#SHA1: 2282c25dbc2f2c8bec3b2b97e0a68f3073c75c91
-//-----------------
-"use strict";
-
-// Manually ported from: wpt@dom/events/AddEventListenerOptions-signal.any.js
-
-test("Passing an AbortSignal to addEventListener does not prevent removeEventListener", () => {
-  let count = 0;
-  function handler() {
-    count++;
-  }
-  const et = new EventTarget();
-  const controller = new AbortController();
-  et.addEventListener("test", handler, { signal: controller.signal });
-  et.dispatchEvent(new Event("test"));
-  expect(count).toBe(1);
-  et.dispatchEvent(new Event("test"));
-  expect(count).toBe(2);
-  controller.abort();
-  et.dispatchEvent(new Event("test"));
-  expect(count).toBe(2);
-  // See: https://github.com/nodejs/node/pull/37696 , adding an event listener
-  // should always return undefined.
-  expect(et.addEventListener("test", handler, { signal: controller.signal })).toBeUndefined();
-  et.dispatchEvent(new Event("test"));
-  expect(count).toBe(2);
-});
-
-test("Passing an AbortSignal to addEventListener works with the once flag", () => {
-  let count = 0;
-  function handler() {
-    count++;
-  }
-  const et = new EventTarget();
-  const controller = new AbortController();
-  et.addEventListener("test", handler, { signal: controller.signal });
-  et.removeEventListener("test", handler);
-  et.dispatchEvent(new Event("test"));
-  expect(count).toBe(0);
-});
-
-test("Removing a once listener works with a passed signal", () => {
-  let count = 0;
-  function handler() {
-    count++;
-  }
-  const et = new EventTarget();
-  const controller = new AbortController();
-  const options = { signal: controller.signal, once: true };
-  et.addEventListener("test", handler, options);
-  controller.abort();
-  et.dispatchEvent(new Event("test"));
-  expect(count).toBe(0);
-});
-
-test("Removing a once listener with options works", () => {
-  let count = 0;
-  function handler() {
-    count++;
-  }
-  const et = new EventTarget();
-  const controller = new AbortController();
-  const options = { signal: controller.signal, once: true };
-  et.addEventListener("test", handler, options);
-  et.removeEventListener("test", handler);
-  et.dispatchEvent(new Event("test"));
-  expect(count).toBe(0);
-});
-
-test("Passing an AbortSignal to multiple listeners", () => {
-  let count = 0;
-  function handler() {
-    count++;
-  }
-  const et = new EventTarget();
-  const controller = new AbortController();
-  const options = { signal: controller.signal, once: true };
-  et.addEventListener("first", handler, options);
-  et.addEventListener("second", handler, options);
-  controller.abort();
-  et.dispatchEvent(new Event("first"));
-  et.dispatchEvent(new Event("second"));
-  expect(count).toBe(0);
-});
-
-test("Passing an AbortSignal to addEventListener works with the capture flag", () => {
-  let count = 0;
-  function handler() {
-    count++;
-  }
-  const et = new EventTarget();
-  const controller = new AbortController();
-  const options = { signal: controller.signal, capture: true };
-  et.addEventListener("test", handler, options);
-  controller.abort();
-  et.dispatchEvent(new Event("test"));
-  expect(count).toBe(0);
-});
-
-test("Aborting from a listener does not call future listeners", () => {
-  let count = 0;
-  function handler() {
-    count++;
-  }
-  const et = new EventTarget();
-  const controller = new AbortController();
-  const options = { signal: controller.signal };
-  et.addEventListener(
-    "test",
-    () => {
-      controller.abort();
-    },
-    options,
-  );
-  et.addEventListener("test", handler, options);
-  et.dispatchEvent(new Event("test"));
-  expect(count).toBe(0);
-});
-
-test("Adding then aborting a listener in another listener does not call it", () => {
-  let count = 0;
-  function handler() {
-    count++;
-  }
-  const et = new EventTarget();
-  const controller = new AbortController();
-  et.addEventListener(
-    "test",
-    () => {
-      et.addEventListener("test", handler, { signal: controller.signal });
-      controller.abort();
-    },
-    { signal: controller.signal },
-  );
-  et.dispatchEvent(new Event("test"));
-  expect(count).toBe(0);
-});
-
-test("Aborting from a nested listener should remove it", () => {
-  const et = new EventTarget();
-  const ac = new AbortController();
-  let count = 0;
-  et.addEventListener(
-    "foo",
-    () => {
-      et.addEventListener(
-        "foo",
-        () => {
-          count++;
-          if (count > 5) ac.abort();
-          et.dispatchEvent(new Event("foo"));
-        },
-        { signal: ac.signal },
-      );
-      et.dispatchEvent(new Event("foo"));
-    },
-    { once: true },
-  );
-  et.dispatchEvent(new Event("foo"));
-  expect(count).toBe(6);
-});
-
-test("Invalid signal values throw TypeError", () => {
-  const et = new EventTarget();
-  [1, 1n, {}, [], null, true, "hi", Symbol(), () => {}].forEach(signal => {
-    expect(() => et.addEventListener("foo", () => {}, { signal })).toThrow(
-      expect.objectContaining({
-        name: "TypeError",
-        message: expect.any(String),
-      }),
-    );
-  });
-});
-
-//<#END_FILE: test-whatwg-events-add-event-listener-options-signal.js
diff --git a/test/js/node/test/parallel/whatwg-events-event-constructors.test.js b/test/js/node/test/parallel/whatwg-events-event-constructors.test.js
deleted file mode 100644
index 8f08b26d1b..0000000000
--- a/test/js/node/test/parallel/whatwg-events-event-constructors.test.js
+++ /dev/null
@@ -1,31 +0,0 @@
-//#FILE: test-whatwg-events-event-constructors.js
-//#SHA1: cf82cf4c0bfbf8bd7cdc9e9328587c2a1266cad8
-//-----------------
-"use strict";
-
-// Source: https://github.com/web-platform-tests/wpt/blob/6cef1d2087d6a07d7cc6cee8cf207eec92e27c5f/dom/events/Event-constructors.any.js#L91-L112
-test("Event constructor with getter options", () => {
-  const called = [];
-  const ev = new Event("Xx", {
-    get cancelable() {
-      called.push("cancelable");
-      return false;
-    },
-    get bubbles() {
-      called.push("bubbles");
-      return true;
-    },
-    get sweet() {
-      called.push("sweet");
-      return "x";
-    },
-  });
-
-  expect(called).toEqual(["bubbles", "cancelable"]);
-  expect(ev.type).toBe("Xx");
-  expect(ev.bubbles).toBe(true);
-  expect(ev.cancelable).toBe(false);
-  expect(ev.sweet).toBeUndefined();
-});
-
-//<#END_FILE: test-whatwg-events-event-constructors.js
diff --git a/test/js/node/test/parallel/whatwg-events-eventtarget-this-of-listener.test.js b/test/js/node/test/parallel/whatwg-events-eventtarget-this-of-listener.test.js
deleted file mode 100644
index 9de2361e15..0000000000
--- a/test/js/node/test/parallel/whatwg-events-eventtarget-this-of-listener.test.js
+++ /dev/null
@@ -1,120 +0,0 @@
-//#FILE: test-whatwg-events-eventtarget-this-of-listener.js
-//#SHA1: 8325e99e2f04d0fbf14abd12f002da81e4a6c338
-//-----------------
-"use strict";
-
-// Manually ported from: https://github.com/web-platform-tests/wpt/blob/6cef1d2087d6a07d7cc6cee8cf207eec92e27c5f/dom/events/EventTarget-this-of-listener.html
-
-// Mock document
-const document = {
-  createElement: () => new EventTarget(),
-  createTextNode: () => new EventTarget(),
-  createDocumentFragment: () => new EventTarget(),
-  createComment: () => new EventTarget(),
-  createProcessingInstruction: () => new EventTarget(),
-};
-
-test("the this value inside the event listener callback should be the node", () => {
-  const nodes = [
-    document.createElement("p"),
-    document.createTextNode("some text"),
-    document.createDocumentFragment(),
-    document.createComment("a comment"),
-    document.createProcessingInstruction("target", "data"),
-  ];
-
-  let callCount = 0;
-  for (const node of nodes) {
-    node.addEventListener("someevent", function () {
-      ++callCount;
-      expect(this).toBe(node);
-    });
-
-    node.dispatchEvent(new Event("someevent"));
-  }
-
-  expect(callCount).toBe(nodes.length);
-});
-
-test("addEventListener should not require handleEvent to be defined on object listeners", () => {
-  const nodes = [
-    document.createElement("p"),
-    document.createTextNode("some text"),
-    document.createDocumentFragment(),
-    document.createComment("a comment"),
-    document.createProcessingInstruction("target", "data"),
-  ];
-
-  let callCount = 0;
-  for (const node of nodes) {
-    const handler = {};
-
-    node.addEventListener("someevent", handler);
-    handler.handleEvent = function () {
-      ++callCount;
-      expect(this).toBe(handler);
-    };
-
-    node.dispatchEvent(new Event("someevent"));
-  }
-
-  expect(callCount).toBe(nodes.length);
-});
-
-test("handleEvent properties added to a function before addEventListener are not reached", () => {
-  const nodes = [
-    document.createElement("p"),
-    document.createTextNode("some text"),
-    document.createDocumentFragment(),
-    document.createComment("a comment"),
-    document.createProcessingInstruction("target", "data"),
-  ];
-
-  let callCount = 0;
-  for (const node of nodes) {
-    function handler() {
-      ++callCount;
-      expect(this).toBe(node);
-    }
-
-    handler.handleEvent = () => {
-      throw new Error("should not call the handleEvent method on a function");
-    };
-
-    node.addEventListener("someevent", handler);
-
-    node.dispatchEvent(new Event("someevent"));
-  }
-
-  expect(callCount).toBe(nodes.length);
-});
-
-test("handleEvent properties added to a function after addEventListener are not reached", () => {
-  const nodes = [
-    document.createElement("p"),
-    document.createTextNode("some text"),
-    document.createDocumentFragment(),
-    document.createComment("a comment"),
-    document.createProcessingInstruction("target", "data"),
-  ];
-
-  let callCount = 0;
-  for (const node of nodes) {
-    function handler() {
-      ++callCount;
-      expect(this).toBe(node);
-    }
-
-    node.addEventListener("someevent", handler);
-
-    handler.handleEvent = () => {
-      throw new Error("should not call the handleEvent method on a function");
-    };
-
-    node.dispatchEvent(new Event("someevent"));
-  }
-
-  expect(callCount).toBe(nodes.length);
-});
-
-//<#END_FILE: test-whatwg-events-eventtarget-this-of-listener.js
diff --git a/test/js/node/test/parallel/whatwg-url-canparse.test.js b/test/js/node/test/parallel/whatwg-url-canparse.test.js
deleted file mode 100644
index e8f7099fbe..0000000000
--- a/test/js/node/test/parallel/whatwg-url-canparse.test.js
+++ /dev/null
@@ -1,39 +0,0 @@
-//#FILE: test-whatwg-url-canparse.js
-//#SHA1: 23d2ea01c951bea491747284dca1abaa17596ff1
-//-----------------
-"use strict";
-
-const { URL } = require("url");
-
-// Note: We're not using internal bindings as per your instructions
-// Instead, we'll mock the canParse function
-
-// Mock the canParse function
-const canParse = jest.fn((url, base) => {
-  try {
-    new URL(url, base);
-    return true;
-  } catch {
-    return false;
-  }
-});
-
-describe("URL.canParse", () => {
-  test("should not throw when called without a base string", () => {
-    expect(() => URL.canParse("https://example.org")).not.toThrow();
-    expect(URL.canParse("https://example.org")).toBe(true);
-    expect(canParse("https://example.org")).toBe(true);
-  });
-
-  test("should correctly parse URL with base", () => {
-    // This for-loop is used to test V8 Fast API optimizations
-    for (let i = 0; i < 100000; i++) {
-      // This example is used because only parsing the first parameter
-      // results in an invalid URL. They have to be used together to
-      // produce truthy value.
-      expect(URL.canParse("/", "http://n")).toBe(true);
-    }
-  });
-});
-
-//<#END_FILE: test-whatwg-url-canparse.js
diff --git a/test/js/node/test/parallel/whatwg-url-custom-deepequal.test.js b/test/js/node/test/parallel/whatwg-url-custom-deepequal.test.js
deleted file mode 100644
index f3bc0a35f7..0000000000
--- a/test/js/node/test/parallel/whatwg-url-custom-deepequal.test.js
+++ /dev/null
@@ -1,17 +0,0 @@
-//#FILE: test-whatwg-url-custom-deepequal.js
-//#SHA1: 57a28f56bb87a00fe2433fabebd4a85cb2da39d0
-//-----------------
-"use strict";
-// This tests that the internal flags in URL objects are consistent, as manifest
-// through assert libraries.
-// See https://github.com/nodejs/node/issues/24211
-
-// Tests below are not from WPT.
-
-test("URL objects are deeply equal", () => {
-  expect(new URL("./foo", "https://example.com/")).toEqual(new URL("https://example.com/foo"));
-
-  expect(new URL("./foo", "https://user:pass@example.com/")).toEqual(new URL("https://user:pass@example.com/foo"));
-});
-
-//<#END_FILE: test-whatwg-url-custom-deepequal.js
diff --git a/test/js/node/test/parallel/whatwg-url-custom-href-side-effect.test.js b/test/js/node/test/parallel/whatwg-url-custom-href-side-effect.test.js
deleted file mode 100644
index e535f59ad2..0000000000
--- a/test/js/node/test/parallel/whatwg-url-custom-href-side-effect.test.js
+++ /dev/null
@@ -1,24 +0,0 @@
-//#FILE: test-whatwg-url-custom-href-side-effect.js
-//#SHA1: c2abb976ed209d25f38bb1ff1e7d8c2110ee51d4
-//-----------------
-"use strict";
-
-// Tests below are not from WPT.
-
-test("URL href assignment side effect", () => {
-  const ref = new URL("http://example.com/path");
-  const url = new URL("http://example.com/path");
-
-  expect(() => {
-    url.href = "";
-  }).toThrow(
-    expect.objectContaining({
-      name: "TypeError",
-      message: expect.any(String),
-    }),
-  );
-
-  expect(url).toEqual(ref);
-});
-
-//<#END_FILE: test-whatwg-url-custom-href-side-effect.js
diff --git a/test/js/node/test/parallel/whatwg-url-custom-searchparams-entries.test.js b/test/js/node/test/parallel/whatwg-url-custom-searchparams-entries.test.js
deleted file mode 100644
index 8d7bd72648..0000000000
--- a/test/js/node/test/parallel/whatwg-url-custom-searchparams-entries.test.js
+++ /dev/null
@@ -1,62 +0,0 @@
-//#FILE: test-whatwg-url-custom-searchparams-entries.js
-//#SHA1: 4ba98b18a2f44b46ac4e6e0ee5179e97083100be
-//-----------------
-"use strict";
-
-// Tests below are not from WPT.
-test("URLSearchParams entries", () => {
-  const params = new URLSearchParams("a=b&c=d");
-  const entries = params.entries();
-
-  expect(typeof entries[Symbol.iterator]).toBe("function");
-  expect(entries[Symbol.iterator]()).toBe(entries);
-
-  expect(entries.next()).toEqual({
-    value: ["a", "b"],
-    done: false,
-  });
-
-  expect(entries.next()).toEqual({
-    value: ["c", "d"],
-    done: false,
-  });
-
-  expect(entries.next()).toEqual({
-    value: undefined,
-    done: true,
-  });
-
-  expect(entries.next()).toEqual({
-    value: undefined,
-    done: true,
-  });
-});
-
-test("entries.next() throws with invalid this", () => {
-  const params = new URLSearchParams("a=b&c=d");
-  const entries = params.entries();
-
-  expect(() => {
-    entries.next.call(undefined);
-  }).toThrow(
-    expect.objectContaining({
-      code: "ERR_INVALID_THIS",
-      name: "TypeError",
-      message: expect.any(String),
-    }),
-  );
-});
-
-test("params.entries() throws with invalid this", () => {
-  expect(() => {
-    URLSearchParams.prototype.entries.call(undefined);
-  }).toThrow(
-    expect.objectContaining({
-      code: "ERR_INVALID_THIS",
-      name: "TypeError",
-      message: expect.any(String),
-    }),
-  );
-});
-
-//<#END_FILE: test-whatwg-url-custom-searchparams-entries.js
diff --git a/test/js/node/test/parallel/whatwg-url-custom-searchparams-foreach.test.js b/test/js/node/test/parallel/whatwg-url-custom-searchparams-foreach.test.js
deleted file mode 100644
index 233a679a00..0000000000
--- a/test/js/node/test/parallel/whatwg-url-custom-searchparams-foreach.test.js
+++ /dev/null
@@ -1,21 +0,0 @@
-//#FILE: test-whatwg-url-custom-searchparams-foreach.js
-//#SHA1: affe74306c7fdeb688aadc771c4d7d5b769fc236
-//-----------------
-"use strict";
-
-// Tests below are not from WPT.
-
-test('URLSearchParams.forEach called with invalid "this"', () => {
-  const params = new URLSearchParams();
-  expect(() => {
-    params.forEach.call(undefined);
-  }).toThrow(
-    expect.objectContaining({
-      code: "ERR_INVALID_THIS",
-      name: "TypeError",
-      message: expect.any(String),
-    }),
-  );
-});
-
-//<#END_FILE: test-whatwg-url-custom-searchparams-foreach.js
diff --git a/test/js/node/test/parallel/whatwg-url-custom-searchparams-keys.test.js b/test/js/node/test/parallel/whatwg-url-custom-searchparams-keys.test.js
deleted file mode 100644
index 0b4a13ea30..0000000000
--- a/test/js/node/test/parallel/whatwg-url-custom-searchparams-keys.test.js
+++ /dev/null
@@ -1,66 +0,0 @@
-//#FILE: test-whatwg-url-custom-searchparams-keys.js
-//#SHA1: 06abe929cfe842fcdd80b44cee8a0092358e5fdf
-//-----------------
-"use strict";
-
-// Tests below are not from WPT.
-
-describe("URLSearchParams keys", () => {
-  let params;
-  let keys;
-
-  beforeEach(() => {
-    params = new URLSearchParams("a=b&c=d");
-    keys = params.keys();
-  });
-
-  test("keys iterator is a function and returns self", () => {
-    expect(typeof keys[Symbol.iterator]).toBe("function");
-    expect(keys[Symbol.iterator]()).toBe(keys);
-  });
-
-  test("keys iterator returns correct values", () => {
-    expect(keys.next()).toEqual({
-      value: "a",
-      done: false,
-    });
-    expect(keys.next()).toEqual({
-      value: "c",
-      done: false,
-    });
-    expect(keys.next()).toEqual({
-      value: undefined,
-      done: true,
-    });
-    expect(keys.next()).toEqual({
-      value: undefined,
-      done: true,
-    });
-  });
-
-  test("keys.next() throws with invalid this", () => {
-    expect(() => {
-      keys.next.call(undefined);
-    }).toThrow(
-      expect.objectContaining({
-        code: "ERR_INVALID_THIS",
-        name: "TypeError",
-        message: expect.any(String),
-      }),
-    );
-  });
-
-  test("params.keys() throws with invalid this", () => {
-    expect(() => {
-      params.keys.call(undefined);
-    }).toThrow(
-      expect.objectContaining({
-        code: "ERR_INVALID_THIS",
-        name: "TypeError",
-        message: expect.any(String),
-      }),
-    );
-  });
-});
-
-//<#END_FILE: test-whatwg-url-custom-searchparams-keys.js
diff --git a/test/js/node/test/parallel/whatwg-url-custom-searchparams-sort.test.js b/test/js/node/test/parallel/whatwg-url-custom-searchparams-sort.test.js
deleted file mode 100644
index 2bbaa7c6a6..0000000000
--- a/test/js/node/test/parallel/whatwg-url-custom-searchparams-sort.test.js
+++ /dev/null
@@ -1,57 +0,0 @@
-//#FILE: test-whatwg-url-custom-searchparams-sort.js
-//#SHA1: 9a97c952cb19488375ead5a62f11fb579fbee211
-//-----------------
-"use strict";
-
-// Tests below are not from WPT.
-
-// TODO(joyeecheung): upstream this to WPT, if possible - even
-// just as a test for large inputs. Other implementations may
-// have a similar cutoff anyway.
-
-// Test bottom-up iterative stable merge sort because we only use that
-// algorithm to sort > 100 search params.
-const tests = [{ input: "", output: [] }];
-const pairs = [];
-for (let i = 10; i < 100; i++) {
-  pairs.push([`a${i}`, "b"]);
-  tests[0].output.push([`a${i}`, "b"]);
-}
-tests[0].input = pairs
-  .sort(() => Math.random() > 0.5)
-  .map(pair => pair.join("="))
-  .join("&");
-
-tests.push({
-  input: "z=a&=b&c=d",
-  output: [
-    ["", "b"],
-    ["c", "d"],
-    ["z", "a"],
-  ],
-});
-
-tests.forEach(val => {
-  test(`Parse and sort: ${val.input}`, () => {
-    const params = new URLSearchParams(val.input);
-    let i = 0;
-    params.sort();
-    for (const param of params) {
-      expect(param).toEqual(val.output[i]);
-      i++;
-    }
-  });
-
-  test(`URL parse and sort: ${val.input}`, () => {
-    const url = new URL(`?${val.input}`, "https://example/");
-    url.searchParams.sort();
-    const params = new URLSearchParams(url.search);
-    let i = 0;
-    for (const param of params) {
-      expect(param).toEqual(val.output[i]);
-      i++;
-    }
-  });
-});
-
-//<#END_FILE: test-whatwg-url-custom-searchparams-sort.js
diff --git a/test/js/node/test/parallel/whatwg-url-custom-searchparams-stringifier.test.js b/test/js/node/test/parallel/whatwg-url-custom-searchparams-stringifier.test.js
deleted file mode 100644
index 94028430ba..0000000000
--- a/test/js/node/test/parallel/whatwg-url-custom-searchparams-stringifier.test.js
+++ /dev/null
@@ -1,30 +0,0 @@
-//#FILE: test-whatwg-url-custom-searchparams-stringifier.js
-//#SHA1: 588663b1cad21e26a4b8e25c0659d204a5d96542
-//-----------------
-"use strict";
-
-// Tests below are not from WPT.
-
-test("URLSearchParams toString called with invalid this", () => {
-  const params = new URLSearchParams();
-  expect(() => {
-    params.toString.call(undefined);
-  }).toThrow(
-    expect.objectContaining({
-      code: "ERR_INVALID_THIS",
-      name: "TypeError",
-      message: expect.any(String),
-    }),
-  );
-});
-
-// The URLSearchParams stringifier mutates the base URL using
-// different percent-encoding rules than the URL itself.
-test("URLSearchParams stringifier mutates base URL with different percent-encoding", () => {
-  const myUrl = new URL("https://example.org?foo=~bar");
-  expect(myUrl.search).toBe("?foo=~bar");
-  myUrl.searchParams.sort();
-  expect(myUrl.search).toBe("?foo=%7Ebar");
-});
-
-//<#END_FILE: test-whatwg-url-custom-searchparams-stringifier.js
diff --git a/test/js/node/test/parallel/whatwg-url-custom-searchparams-values.test.js b/test/js/node/test/parallel/whatwg-url-custom-searchparams-values.test.js
deleted file mode 100644
index 5b7d88801c..0000000000
--- a/test/js/node/test/parallel/whatwg-url-custom-searchparams-values.test.js
+++ /dev/null
@@ -1,52 +0,0 @@
-//#FILE: test-whatwg-url-custom-searchparams-values.js
-//#SHA1: 7df0ccf30363d589199bb3f71c68e5559e9e4f59
-//-----------------
-"use strict";
-
-// Tests below are not from WPT.
-
-test("URLSearchParams values() method", () => {
-  const params = new URLSearchParams("a=b&c=d");
-  const values = params.values();
-
-  expect(typeof values[Symbol.iterator]).toBe("function");
-  expect(values[Symbol.iterator]()).toBe(values);
-  expect(values.next()).toEqual({
-    value: "b",
-    done: false,
-  });
-  expect(values.next()).toEqual({
-    value: "d",
-    done: false,
-  });
-  expect(values.next()).toEqual({
-    value: undefined,
-    done: true,
-  });
-  expect(values.next()).toEqual({
-    value: undefined,
-    done: true,
-  });
-
-  expect(() => {
-    values.next.call(undefined);
-  }).toThrow(
-    expect.objectContaining({
-      code: "ERR_INVALID_THIS",
-      name: "TypeError",
-      message: expect.any(String),
-    }),
-  );
-
-  expect(() => {
-    params.values.call(undefined);
-  }).toThrow(
-    expect.objectContaining({
-      code: "ERR_INVALID_THIS",
-      name: "TypeError",
-      message: expect.any(String),
-    }),
-  );
-});
-
-//<#END_FILE: test-whatwg-url-custom-searchparams-values.js
diff --git a/test/js/node/test/parallel/whatwg-url-custom-searchparams.test.js b/test/js/node/test/parallel/whatwg-url-custom-searchparams.test.js
deleted file mode 100644
index 7de337086e..0000000000
--- a/test/js/node/test/parallel/whatwg-url-custom-searchparams.test.js
+++ /dev/null
@@ -1,191 +0,0 @@
-//#FILE: test-whatwg-url-custom-searchparams.js
-//#SHA1: 8308ed9fc341a1caaadcf01653bd49b96cebf599
-//-----------------
-"use strict";
-
-// Tests below are not from WPT.
-
-const assert = require("assert");
-const fixtures = require("../common/fixtures");
-
-const serialized =
-  "a=a&a=1&a=true&a=undefined&a=null&a=%EF%BF%BD" +
-  "&a=%EF%BF%BD&a=%F0%9F%98%80&a=%EF%BF%BD%EF%BF%BD" +
-  "&a=%5Bobject+Object%5D";
-const values = ["a", 1, true, undefined, null, "\uD83D", "\uDE00", "\uD83D\uDE00", "\uDE00\uD83D", {}];
-const normalizedValues = [
-  "a",
-  "1",
-  "true",
-  "undefined",
-  "null",
-  "\uFFFD",
-  "\uFFFD",
-  "\uD83D\uDE00",
-  "\uFFFD\uFFFD",
-  "[object Object]",
-];
-
-describe("WHATWG URL Custom SearchParams", () => {
-  let m, sp;
-
-  beforeEach(() => {
-    m = new URL("http://example.org");
-    sp = m.searchParams;
-  });
-
-  it("should not modify own symbols when accessing searchParams", () => {
-    const ownSymbolsBeforeGetterAccess = Object.getOwnPropertySymbols(m);
-    expect(sp).toBeDefined();
-    expect(Object.getOwnPropertySymbols(m)).toEqual(ownSymbolsBeforeGetterAccess);
-  });
-
-  it("should initialize with empty search params", () => {
-    expect(sp.toString()).toBe("");
-    expect(m.search).toBe("");
-  });
-
-  it("should handle setting and deleting search params", () => {
-    expect(sp.has("a")).toBe(false);
-    values.forEach(i => sp.set("a", i));
-    expect(sp.has("a")).toBe(true);
-    expect(sp.get("a")).toBe("[object Object]");
-    sp.delete("a");
-    expect(sp.has("a")).toBe(false);
-  });
-
-  it("should handle appending search params", () => {
-    m.search = "";
-    expect(sp.toString()).toBe("");
-
-    values.forEach(i => sp.append("a", i));
-    expect(sp.has("a")).toBe(true);
-    expect(sp.getAll("a").length).toBe(values.length);
-    expect(sp.get("a")).toBe("a");
-
-    expect(sp.toString()).toBe(serialized);
-    expect(m.search).toBe(`?${serialized}`);
-  });
-
-  it("should update URL components when modifying search params", () => {
-    sp.delete("a");
-    values.forEach(i => sp.append("a", i));
-    expect(m.href).toBe(`http://example.org/?${serialized}`);
-    expect(m.toString()).toBe(`http://example.org/?${serialized}`);
-    expect(m.toJSON()).toBe(`http://example.org/?${serialized}`);
-  });
-
-  it("should clear search params when setting href or search", () => {
-    sp.delete("a");
-    values.forEach(i => sp.append("a", i));
-    m.href = "http://example.org";
-    expect(m.href).toBe("http://example.org/");
-    expect(sp.size).toBe(0);
-
-    values.forEach(i => sp.append("a", i));
-    m.search = "";
-    expect(m.href).toBe("http://example.org/");
-    expect(sp.size).toBe(0);
-  });
-
-  it("should update URL components when modifying pathname or hash", () => {
-    sp.delete("a");
-    values.forEach(i => sp.append("a", i));
-    m.pathname = "/test";
-    expect(m.href).toBe(`http://example.org/test?${serialized}`);
-    m.pathname = "";
-
-    sp.delete("a");
-    values.forEach(i => sp.append("a", i));
-    m.hash = "#test";
-    expect(m.href).toBe(`http://example.org/?${serialized}#test`);
-    m.hash = "";
-  });
-
-  it("should have correct iteration behavior", () => {
-    expect(sp[Symbol.iterator]).toBe(sp.entries);
-
-    sp.delete("a");
-    values.forEach(i => sp.append("a", i));
-
-    let n = 0;
-    for (const [key, val] of sp) {
-      expect(key).toBe("a");
-      expect(val).toBe(normalizedValues[n]);
-      n++;
-    }
-
-    n = 0;
-    for (const key of sp.keys()) {
-      expect(key).toBe("a");
-      n++;
-    }
-
-    n = 0;
-    for (const val of sp.values()) {
-      expect(val).toBe(normalizedValues[n]);
-      n++;
-    }
-
-    n = 0;
-    sp.forEach(function (val, key, obj) {
-      expect(this).toBeUndefined();
-      expect(key).toBe("a");
-      expect(val).toBe(normalizedValues[n]);
-      expect(obj).toBe(sp);
-      n++;
-    });
-
-    sp.forEach(function () {
-      expect(this).toBe(m);
-    }, m);
-  });
-
-  it("should throw for invalid forEach arguments", () => {
-    expect(() => sp.forEach()).toThrow(
-      expect.objectContaining({
-        code: "ERR_INVALID_ARG_TYPE",
-        name: "TypeError",
-      }),
-    );
-    expect(() => sp.forEach(1)).toThrow(
-      expect.objectContaining({
-        code: "ERR_INVALID_ARG_TYPE",
-        name: "TypeError",
-      }),
-    );
-  });
-
-  it("should handle setting search directly", () => {
-    m.search = "?a=a&b=b";
-    expect(sp.toString()).toBe("a=a&b=b");
-  });
-
-  it("should pass URL search params tests", () => {
-    const tests = require(fixtures.path("url-searchparams.js"));
-
-    for (const [input, expected, parsed] of tests) {
-      if (input[0] !== "?") {
-        const sp = new URLSearchParams(input);
-        expect(String(sp)).toBe(expected);
-        expect(Array.from(sp)).toEqual(parsed);
-
-        m.search = input;
-        expect(String(m.searchParams)).toBe(expected);
-        expect(Array.from(m.searchParams)).toEqual(parsed);
-      }
-
-      {
-        const sp = new URLSearchParams(`?${input}`);
-        expect(String(sp)).toBe(expected);
-        expect(Array.from(sp)).toEqual(parsed);
-
-        m.search = `?${input}`;
-        expect(String(m.searchParams)).toBe(expected);
-        expect(Array.from(m.searchParams)).toEqual(parsed);
-      }
-    }
-  });
-});
-
-//<#END_FILE: test-whatwg-url-custom-searchparams.js
diff --git a/test/js/node/test/parallel/whatwg-url-override-hostname.test.js b/test/js/node/test/parallel/whatwg-url-override-hostname.test.js
deleted file mode 100644
index 876de04206..0000000000
--- a/test/js/node/test/parallel/whatwg-url-override-hostname.test.js
+++ /dev/null
@@ -1,27 +0,0 @@
-//#FILE: test-whatwg-url-override-hostname.js
-//#SHA1: 22f2c5e784a47cc59c7f0b3229a68f4bbcfeff3e
-//-----------------
-"use strict";
-
-test("URL with overridden hostname getter", () => {
-  const url = new (class extends URL {
-    get hostname() {
-      return "bar.com";
-    }
-  })("http://foo.com/");
-
-  expect(url.href).toBe("http://foo.com/");
-  expect(url.toString()).toBe("http://foo.com/");
-  expect(url.toJSON()).toBe("http://foo.com/");
-  expect(url.hash).toBe("");
-  expect(url.host).toBe("foo.com");
-  expect(url.hostname).toBe("bar.com");
-  expect(url.origin).toBe("http://foo.com");
-  expect(url.password).toBe("");
-  expect(url.protocol).toBe("http:");
-  expect(url.username).toBe("");
-  expect(url.search).toBe("");
-  expect(url.searchParams.toString()).toBe("");
-});
-
-//<#END_FILE: test-whatwg-url-override-hostname.js
diff --git a/test/js/node/test/parallel/worker-arraybuffer-zerofill.test.js b/test/js/node/test/parallel/worker-arraybuffer-zerofill.test.js
deleted file mode 100644
index 7f9380841c..0000000000
--- a/test/js/node/test/parallel/worker-arraybuffer-zerofill.test.js
+++ /dev/null
@@ -1,43 +0,0 @@
-//#FILE: test-worker-arraybuffer-zerofill.js
-//#SHA1: 3fd8cc412e658cb491c61d2323ff3a45af4d6dd1
-//-----------------
-"use strict";
-
-const { Worker } = require("worker_threads");
-
-// Make sure that allocating uninitialized ArrayBuffers in one thread does not
-// affect the zero-initialization in other threads.
-
-test("zero-initialization in other threads", done => {
-  const w = new Worker(
-    `
-  const { parentPort } = require('worker_threads');
-
-  function post() {
-    const uint32array = new Uint32Array(64);
-    parentPort.postMessage(uint32array.reduce((a, b) => a + b));
-  }
-
-  setInterval(post, 0);
-  `,
-    { eval: true },
-  );
-
-  function allocBuffers() {
-    Buffer.allocUnsafe(32 * 1024 * 1024);
-  }
-
-  const interval = setInterval(allocBuffers, 0);
-
-  let messages = 0;
-  w.on("message", sum => {
-    expect(sum).toBe(0);
-    if (messages++ === 100) {
-      clearInterval(interval);
-      w.terminate();
-      done();
-    }
-  });
-});
-
-//<#END_FILE: test-worker-arraybuffer-zerofill.js
diff --git a/test/js/node/test/parallel/worker-cjs-workerdata.test.js b/test/js/node/test/parallel/worker-cjs-workerdata.test.js
deleted file mode 100644
index 0c0158346e..0000000000
--- a/test/js/node/test/parallel/worker-cjs-workerdata.test.js
+++ /dev/null
@@ -1,21 +0,0 @@
-//#FILE: test-worker-cjs-workerdata.js
-//#SHA1: 8e5d70084de66c757d227df54612de48d1048ad3
-//-----------------
-"use strict";
-const fixtures = require("../common/fixtures");
-const { Worker } = require("worker_threads");
-
-const workerData = "Hello from main thread";
-
-test("Worker with CJS module and workerData", done => {
-  const worker = new Worker(fixtures.path("worker-data.cjs"), {
-    workerData,
-  });
-
-  worker.on("message", message => {
-    expect(message).toBe(workerData);
-    done();
-  });
-});
-
-//<#END_FILE: test-worker-cjs-workerdata.js
diff --git a/test/js/node/test/parallel/worker-cleanexit-with-js.test.js b/test/js/node/test/parallel/worker-cleanexit-with-js.test.js
deleted file mode 100644
index 9e9acb2f4b..0000000000
--- a/test/js/node/test/parallel/worker-cleanexit-with-js.test.js
+++ /dev/null
@@ -1,34 +0,0 @@
-//#FILE: test-worker-cleanexit-with-js.js
-//#SHA1: f47fd2ea6e4a0adf79207268baf613eb071e493a
-//-----------------
-"use strict";
-
-// Harden the thread interactions on the exit path.
-// Ensure workers are able to bail out safe at
-// arbitrary execution points. By running a lot of
-// JS code in a tight loop, the expectation
-// is that those will be at various control flow points
-// preferably in the JS land.
-
-const { Worker } = require("worker_threads");
-
-test("Workers can bail out safely at arbitrary execution points", done => {
-  const code =
-    "setInterval(() => {" +
-    "require('v8').deserialize(require('v8').serialize({ foo: 'bar' }));" +
-    "require('vm').runInThisContext('x = \"foo\";');" +
-    "eval('const y = \"vm\";');}, 10);";
-
-  for (let i = 0; i < 9; i++) {
-    new Worker(code, { eval: true });
-  }
-
-  const lastWorker = new Worker(code, { eval: true });
-  lastWorker.on("online", () => {
-    expect(true).toBe(true); // Ensure the worker came online
-    process.exit(0);
-    done();
-  });
-});
-
-//<#END_FILE: test-worker-cleanexit-with-js.js
diff --git a/test/js/node/test/parallel/worker-cleanexit-with-moduleload.test.js b/test/js/node/test/parallel/worker-cleanexit-with-moduleload.test.js
deleted file mode 100644
index ffad2cb95e..0000000000
--- a/test/js/node/test/parallel/worker-cleanexit-with-moduleload.test.js
+++ /dev/null
@@ -1,38 +0,0 @@
-//#FILE: test-worker-cleanexit-with-moduleload.js
-//#SHA1: cdaed88b3a0ebbc07619e10f35ea0c62e5134b63
-//-----------------
-"use strict";
-
-const { Worker } = require("worker_threads");
-
-// Harden the thread interactions on the exit path.
-// Ensure workers are able to bail out safe at
-// arbitrary execution points. By using a number of
-// internal modules as load candidates, the expectation
-// is that those will be at various control flow points
-// preferably in the C++ land.
-
-const modules = ["fs", "assert", "async_hooks", "buffer", "child_process", "net", "http", "os", "path", "v8", "vm"];
-
-if (process.versions.openssl) {
-  modules.push("https");
-}
-
-test("Workers can exit cleanly while loading modules", done => {
-  for (let i = 0; i < 10; i++) {
-    new Worker(
-      `const modules = [${modules.map(m => `'${m}'`)}];` +
-        "modules.forEach((module) => {" +
-        "const m = require(module);" +
-        "});",
-      { eval: true },
-    );
-  }
-
-  // Allow workers to go live.
-  setTimeout(() => {
-    done();
-  }, 200);
-}, 300); // Set timeout to 300ms to allow for the 200ms delay
-
-//<#END_FILE: test-worker-cleanexit-with-moduleload.js
diff --git a/test/js/node/test/parallel/worker-esmodule.test.js b/test/js/node/test/parallel/worker-esmodule.test.js
deleted file mode 100644
index e08d58041a..0000000000
--- a/test/js/node/test/parallel/worker-esmodule.test.js
+++ /dev/null
@@ -1,20 +0,0 @@
-//#FILE: test-worker-esmodule.js
-//#SHA1: a40c6a55aa2fe45203bec4808e0d53efed2fa4e4
-//-----------------
-"use strict";
-
-const fixtures = require("../common/fixtures");
-const { Worker } = require("worker_threads");
-
-test("Worker can load ES module", () => {
-  const w = new Worker(fixtures.path("worker-script.mjs"));
-
-  return new Promise(resolve => {
-    w.on("message", message => {
-      expect(message).toBe("Hello, world!");
-      resolve();
-    });
-  });
-});
-
-//<#END_FILE: test-worker-esmodule.js
diff --git a/test/js/node/test/parallel/worker-invalid-workerdata.test.js b/test/js/node/test/parallel/worker-invalid-workerdata.test.js
deleted file mode 100644
index 1776a6d26c..0000000000
--- a/test/js/node/test/parallel/worker-invalid-workerdata.test.js
+++ /dev/null
@@ -1,25 +0,0 @@
-//#FILE: test-worker-invalid-workerdata.js
-//#SHA1: 2e1989d95e34d3603c30290e012335261767ae90
-//-----------------
-"use strict";
-
-const { Worker } = require("worker_threads");
-
-// This tests verifies that failing to serialize workerData does not keep
-// the process alive.
-// Refs: https://github.com/nodejs/node/issues/22736
-
-test("Worker creation with unserializable workerData throws DataCloneError", () => {
-  expect(() => {
-    new Worker("./worker.js", {
-      workerData: { fn: () => {} },
-    });
-  }).toThrow(
-    expect.objectContaining({
-      name: "DataCloneError",
-      message: expect.any(String),
-    }),
-  );
-});
-
-//<#END_FILE: test-worker-invalid-workerdata.js
diff --git a/test/js/node/test/parallel/worker-memory.test.js b/test/js/node/test/parallel/worker-memory.test.js
deleted file mode 100644
index d18eb5bccd..0000000000
--- a/test/js/node/test/parallel/worker-memory.test.js
+++ /dev/null
@@ -1,63 +0,0 @@
-//#FILE: test-worker-memory.js
-//#SHA1: e425b7d8f32d04fae4a6e0c697a78aeae4de2f60
-//-----------------
-"use strict";
-
-const util = require("util");
-const { Worker } = require("worker_threads");
-const os = require("os");
-
-if (process.platform === "os400") {
-  test.skip("On IBMi, the rss memory always returns zero");
-}
-
-let numWorkers = +process.env.JOBS || os.availableParallelism();
-if (numWorkers > 20) {
-  // Cap the number of workers at 20 (as an even divisor of 60 used as
-  // the total number of workers started) otherwise the test fails on
-  // machines with high core counts.
-  numWorkers = 20;
-}
-
-// Verify that a Worker's memory isn't kept in memory after the thread finishes.
-
-function run(n, done) {
-  console.log(`run() called with n=${n} (numWorkers=${numWorkers})`);
-  if (n <= 0) return done();
-  const worker = new Worker("require('worker_threads').parentPort.postMessage(2 + 2)", { eval: true });
-  worker.on("message", value => {
-    expect(value).toBe(4);
-  });
-  worker.on("exit", () => {
-    run(n - 1, done);
-  });
-}
-
-test("Worker memory is not kept after thread finishes", async () => {
-  const startStats = process.memoryUsage();
-  let finished = 0;
-
-  const runPromises = Array(numWorkers)
-    .fill()
-    .map(
-      () =>
-        new Promise(resolve => {
-          run(60 / numWorkers, () => {
-            console.log(`done() called (finished=${finished})`);
-            if (++finished === numWorkers) {
-              const finishStats = process.memoryUsage();
-              // A typical value for this ratio would be ~1.15.
-              // 5 as a upper limit is generous, but the main point is that we
-              // don't have the memory of 50 Isolates/Node.js environments just lying
-              // around somewhere.
-              expect(finishStats.rss / startStats.rss).toBeLessThan(5);
-            }
-            resolve();
-          });
-        }),
-    );
-
-  await Promise.all(runPromises);
-}, 30000); // Increase timeout to 30 seconds
-
-//<#END_FILE: test-worker-memory.js
diff --git a/test/js/node/test/parallel/worker-message-channel-sharedarraybuffer.test.js b/test/js/node/test/parallel/worker-message-channel-sharedarraybuffer.test.js
deleted file mode 100644
index 088cb1530c..0000000000
--- a/test/js/node/test/parallel/worker-message-channel-sharedarraybuffer.test.js
+++ /dev/null
@@ -1,41 +0,0 @@
-//#FILE: test-worker-message-channel-sharedarraybuffer.js
-//#SHA1: 567096de16f1ea1b7a50e53cbdbd47b531af0e2a
-//-----------------
-// Flags: --expose-gc
-"use strict";
-
-const { Worker } = require("worker_threads");
-
-test("SharedArrayBuffer can be shared between main thread and worker", async () => {
-  const sharedArrayBuffer = new SharedArrayBuffer(12);
-  const local = Buffer.from(sharedArrayBuffer);
-
-  const w = new Worker(
-    `
-    const { parentPort } = require('worker_threads');
-    parentPort.on('message', ({ sharedArrayBuffer }) => {
-      const local = Buffer.from(sharedArrayBuffer);
-      local.write('world!', 6);
-      parentPort.postMessage('written!');
-    });
-  `,
-    { eval: true },
-  );
-
-  const messagePromise = new Promise(resolve => {
-    w.on("message", resolve);
-  });
-
-  w.postMessage({ sharedArrayBuffer });
-  // This would be a race condition if the memory regions were overlapping
-  local.write("Hello ");
-
-  await messagePromise;
-
-  expect(local.toString()).toBe("Hello world!");
-
-  global.gc();
-  await w.terminate();
-});
-
-//<#END_FILE: test-worker-message-channel-sharedarraybuffer.js
diff --git a/test/js/node/test/parallel/worker-message-port-transfer-terminate.test.js b/test/js/node/test/parallel/worker-message-port-transfer-terminate.test.js
deleted file mode 100644
index c00d6d2251..0000000000
--- a/test/js/node/test/parallel/worker-message-port-transfer-terminate.test.js
+++ /dev/null
@@ -1,30 +0,0 @@
-//#FILE: test-worker-message-port-transfer-terminate.js
-//#SHA1: ca776ac07835f8e6306ba671531b8e5a73e25f27
-//-----------------
-"use strict";
-
-const { Worker, MessageChannel } = require("worker_threads");
-
-// Check the interaction of calling .terminate() while transferring
-// MessagePort objects; in particular, that it does not crash the process.
-
-test("Worker termination while transferring MessagePort objects", done => {
-  let completedIterations = 0;
-
-  for (let i = 0; i < 10; ++i) {
-    const w = new Worker("require('worker_threads').parentPort.on('message', () => {})", { eval: true });
-
-    setImmediate(() => {
-      const port = new MessageChannel().port1;
-      w.postMessage({ port }, [port]);
-      w.terminate().then(() => {
-        completedIterations++;
-        if (completedIterations === 10) {
-          done();
-        }
-      });
-    });
-  }
-});
-
-//<#END_FILE: test-worker-message-port-transfer-terminate.js
diff --git a/test/js/node/test/parallel/worker-mjs-workerdata.test.js b/test/js/node/test/parallel/worker-mjs-workerdata.test.js
deleted file mode 100644
index d3bfe6d442..0000000000
--- a/test/js/node/test/parallel/worker-mjs-workerdata.test.js
+++ /dev/null
@@ -1,22 +0,0 @@
-//#FILE: test-worker-mjs-workerdata.js
-//#SHA1: c4df37cd769b399dd8245d29bed7f385f1adb472
-//-----------------
-"use strict";
-
-const fixtures = require("../common/fixtures");
-const { Worker } = require("worker_threads");
-
-const workerData = "Hello from main thread";
-
-test("Worker with workerData in MJS", done => {
-  const worker = new Worker(fixtures.path("worker-data.mjs"), {
-    workerData,
-  });
-
-  worker.on("message", message => {
-    expect(message).toBe(workerData);
-    done();
-  });
-});
-
-//<#END_FILE: test-worker-mjs-workerdata.js
diff --git a/test/js/node/test/parallel/worker-nested-on-process-exit.test.js b/test/js/node/test/parallel/worker-nested-on-process-exit.test.js
deleted file mode 100644
index d198efaf1f..0000000000
--- a/test/js/node/test/parallel/worker-nested-on-process-exit.test.js
+++ /dev/null
@@ -1,29 +0,0 @@
-//#FILE: test-worker-nested-on-process-exit.js
-//#SHA1: a76202f79766e7ca3f39552cc00b4f31e8f38a56
-//-----------------
-"use strict";
-const { Worker, workerData } = require("worker_threads");
-
-// Test that 'exit' events for nested Workers are not received when a Worker
-// terminates itself through process.exit().
-
-if (workerData === null) {
-  test("nested worker exit events", () => {
-    const nestedWorkerExitCounter = new Int32Array(new SharedArrayBuffer(4));
-    const w = new Worker(__filename, { workerData: nestedWorkerExitCounter });
-
-    return new Promise(resolve => {
-      w.on("exit", () => {
-        expect(nestedWorkerExitCounter[0]).toBe(0);
-        resolve();
-      });
-    });
-  });
-} else {
-  const nestedWorker = new Worker("setInterval(() => {}, 100)", { eval: true });
-  // The counter should never be increased here.
-  nestedWorker.on("exit", () => workerData[0]++);
-  nestedWorker.on("online", () => process.exit());
-}
-
-//<#END_FILE: test-worker-nested-on-process-exit.js
diff --git a/test/js/node/test/parallel/worker-nested-uncaught.test.js b/test/js/node/test/parallel/worker-nested-uncaught.test.js
deleted file mode 100644
index 050f33a797..0000000000
--- a/test/js/node/test/parallel/worker-nested-uncaught.test.js
+++ /dev/null
@@ -1,27 +0,0 @@
-//#FILE: test-worker-nested-uncaught.js
-//#SHA1: 948558ccf744615abbd0df028a83b36d36ad7aff
-//-----------------
-"use strict";
-const { Worker } = require("worker_threads");
-
-// Regression test for https://github.com/nodejs/node/issues/34309
-
-test("nested worker uncaught error", done => {
-  const w = new Worker(
-    `const { Worker } = require('worker_threads');
-    new Worker("throw new Error('uncaught')", { eval:true })`,
-    { eval: true },
-  );
-
-  w.on("error", error => {
-    expect(error).toEqual(
-      expect.objectContaining({
-        name: "Error",
-        message: expect.any(String),
-      }),
-    );
-    done();
-  });
-});
-
-//<#END_FILE: test-worker-nested-uncaught.js
diff --git a/test/js/node/test/parallel/worker-ref-onexit.test.js b/test/js/node/test/parallel/worker-ref-onexit.test.js
deleted file mode 100644
index fb360433d4..0000000000
--- a/test/js/node/test/parallel/worker-ref-onexit.test.js
+++ /dev/null
@@ -1,27 +0,0 @@
-//#FILE: test-worker-ref-onexit.js
-//#SHA1: b34eb5ff18bd889eb47cd37e696410f428b0b11b
-//-----------------
-"use strict";
-const { Worker } = require("worker_threads");
-
-// Check that worker.unref() makes the 'exit' event not be emitted, if it is
-// the only thing we would otherwise be waiting for.
-
-test("worker.unref() prevents exit event emission", done => {
-  // Use `setInterval()` to make sure the worker is alive until the end of the
-  // event loop turn.
-  const w = new Worker("setInterval(() => {}, 100);", { eval: true });
-  w.unref();
-
-  const exitHandler = jest.fn();
-  w.on("exit", exitHandler);
-
-  // We need to use a timeout here to allow the event loop to complete
-  // and ensure the exit event is not called
-  setTimeout(() => {
-    expect(exitHandler).not.toHaveBeenCalled();
-    done();
-  }, 500);
-});
-
-//<#END_FILE: test-worker-ref-onexit.js
diff --git a/test/js/node/test/parallel/worker-relative-path-double-dot.test.js b/test/js/node/test/parallel/worker-relative-path-double-dot.test.js
deleted file mode 100644
index daed4389b1..0000000000
--- a/test/js/node/test/parallel/worker-relative-path-double-dot.test.js
+++ /dev/null
@@ -1,23 +0,0 @@
-//#FILE: test-worker-relative-path-double-dot.js
-//#SHA1: 2b605c02bfb9cfc2d42533a6a184dfdbd5a6e5b7
-//-----------------
-"use strict";
-const path = require("path");
-const { Worker, isMainThread, parentPort } = require("worker_threads");
-
-if (isMainThread) {
-  test("Worker with relative path using double dot", done => {
-    const cwdName = path.relative("../", ".");
-    const relativePath = path.relative(".", __filename);
-    const w = new Worker(path.join("..", cwdName, relativePath));
-
-    w.on("message", message => {
-      expect(message).toBe("Hello, world!");
-      done();
-    });
-  });
-} else {
-  parentPort.postMessage("Hello, world!");
-}
-
-//<#END_FILE: test-worker-relative-path-double-dot.js
diff --git a/test/js/node/test/parallel/worker-relative-path.test.js b/test/js/node/test/parallel/worker-relative-path.test.js
deleted file mode 100644
index a6971694c1..0000000000
--- a/test/js/node/test/parallel/worker-relative-path.test.js
+++ /dev/null
@@ -1,20 +0,0 @@
-//#FILE: test-worker-relative-path.js
-//#SHA1: 2d69899e96eee7500da11857679bf9f2ec18c259
-//-----------------
-"use strict";
-const path = require("path");
-const { Worker, isMainThread, parentPort } = require("worker_threads");
-
-if (isMainThread) {
-  test("Worker can be started with a relative path", done => {
-    const w = new Worker(`./${path.relative(".", __filename)}`);
-    w.on("message", message => {
-      expect(message).toBe("Hello, world!");
-      done();
-    });
-  });
-} else {
-  parentPort.postMessage("Hello, world!");
-}
-
-//<#END_FILE: test-worker-relative-path.js
diff --git a/test/js/node/test/parallel/worker-sharedarraybuffer-from-worker-thread.test.js b/test/js/node/test/parallel/worker-sharedarraybuffer-from-worker-thread.test.js
deleted file mode 100644
index 0a4c29b25e..0000000000
--- a/test/js/node/test/parallel/worker-sharedarraybuffer-from-worker-thread.test.js
+++ /dev/null
@@ -1,46 +0,0 @@
-//#FILE: test-worker-sharedarraybuffer-from-worker-thread.js
-//#SHA1: a33c9c03494dc79f7dd926382125f034d8ae4bbc
-//-----------------
-// Flags: --debug-arraybuffer-allocations
-"use strict";
-
-// Regression test for https://github.com/nodejs/node/issues/28777
-// Make sure that SharedArrayBuffers and transferred ArrayBuffers created in
-// Worker threads are accessible after the creating thread ended.
-
-const { Worker } = require("worker_threads");
-
-["ArrayBuffer", "SharedArrayBuffer"].forEach(ctor => {
-  test(`${ctor} from worker thread`, async () => {
-    const w = new Worker(
-      `
-    const { parentPort } = require('worker_threads');
-    const arrayBuffer = new ${ctor}(4);
-    parentPort.postMessage(
-      arrayBuffer,
-      '${ctor}' === 'SharedArrayBuffer' ? [] : [arrayBuffer]);
-    `,
-      { eval: true },
-    );
-
-    let arrayBuffer;
-    await new Promise(resolve => {
-      w.once("message", message => {
-        arrayBuffer = message;
-        resolve();
-      });
-    });
-
-    await new Promise(resolve => {
-      w.once("exit", () => {
-        expect(arrayBuffer.constructor.name).toBe(ctor);
-        const uint8array = new Uint8Array(arrayBuffer);
-        uint8array[0] = 42;
-        expect(uint8array).toEqual(new Uint8Array([42, 0, 0, 0]));
-        resolve();
-      });
-    });
-  });
-});
-
-//<#END_FILE: test-worker-sharedarraybuffer-from-worker-thread.js
diff --git a/test/js/node/test/parallel/worker-terminate-http2-respond-with-file.test.js b/test/js/node/test/parallel/worker-terminate-http2-respond-with-file.test.js
deleted file mode 100644
index c317604d79..0000000000
--- a/test/js/node/test/parallel/worker-terminate-http2-respond-with-file.test.js
+++ /dev/null
@@ -1,51 +0,0 @@
-//#FILE: test-worker-terminate-http2-respond-with-file.js
-//#SHA1: e8ce958ee3283a8ec8c83acc27cc3a02824ebfb7
-//-----------------
-"use strict";
-
-const http2 = require("http2");
-const makeDuplexPair = require("../common/duplexpair");
-const { Worker, isMainThread } = require("worker_threads");
-
-// This is a variant of test-http2-generic-streams-sendfile for checking
-// that Workers can be terminated during a .respondWithFile() operation.
-
-if (isMainThread) {
-  test("Worker can be terminated during respondWithFile operation", () => {
-    const worker = new Worker(__filename);
-    expect(worker).toBeDefined();
-  });
-} else {
-  test("HTTP/2 server responds with file", done => {
-    const server = http2.createServer();
-    server.on("stream", (stream, headers) => {
-      stream.respondWithFile(process.execPath); // Use a large-ish file.
-    });
-
-    const { clientSide, serverSide } = makeDuplexPair();
-    server.emit("connection", serverSide);
-
-    const client = http2.connect("http://localhost:80", {
-      createConnection: () => clientSide,
-    });
-
-    const req = client.request();
-
-    req.on("response", headers => {
-      expect(headers[":status"]).toBe(200);
-    });
-
-    req.on("data", () => {
-      process.exit();
-      done();
-    });
-
-    req.on("end", () => {
-      done.fail("Request should not end");
-    });
-
-    req.end();
-  });
-}
-
-//<#END_FILE: test-worker-terminate-http2-respond-with-file.js
diff --git a/test/js/node/test/parallel/worker-unref-from-message-during-exit.test.js b/test/js/node/test/parallel/worker-unref-from-message-during-exit.test.js
deleted file mode 100644
index 338155b933..0000000000
--- a/test/js/node/test/parallel/worker-unref-from-message-during-exit.test.js
+++ /dev/null
@@ -1,31 +0,0 @@
-//#FILE: test-worker-unref-from-message-during-exit.js
-//#SHA1: 8555ad4d197dfc269beffcf6b2a3940df8a41659
-//-----------------
-"use strict";
-const { Worker } = require("worker_threads");
-
-// This used to crash because the `.unref()` was unexpected while the Worker
-// was exiting.
-
-test("Worker unref from message during exit", async () => {
-  const w = new Worker(
-    `
-require('worker_threads').parentPort.postMessage({});
-`,
-    { eval: true },
-  );
-
-  const messagePromise = new Promise(resolve => {
-    w.on("message", () => {
-      w.unref();
-      resolve();
-    });
-  });
-
-  // Wait a bit so that the 'message' event is emitted while the Worker exits.
-  await Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 100);
-
-  await expect(messagePromise).resolves.toBeUndefined();
-});
-
-//<#END_FILE: test-worker-unref-from-message-during-exit.js
diff --git a/test/js/node/test/parallel/worker-workerdata-sharedarraybuffer.test.js b/test/js/node/test/parallel/worker-workerdata-sharedarraybuffer.test.js
deleted file mode 100644
index 4ff64a3328..0000000000
--- a/test/js/node/test/parallel/worker-workerdata-sharedarraybuffer.test.js
+++ /dev/null
@@ -1,45 +0,0 @@
-//#FILE: test-worker-workerdata-sharedarraybuffer.js
-//#SHA1: 2737167494699dbfe6986e4b879ecdeafd31a8a8
-//-----------------
-// Flags: --expose-gc
-"use strict";
-
-const { Worker } = require("worker_threads");
-
-test("SharedArrayBuffer can be passed via workerData and modified", async () => {
-  const sharedArrayBuffer = new SharedArrayBuffer(12);
-  const local = Buffer.from(sharedArrayBuffer);
-
-  const w = new Worker(
-    `
-    const { parentPort, workerData } = require('worker_threads');
-    const local = Buffer.from(workerData.sharedArrayBuffer);
-
-    parentPort.on('message', () => {
-      local.write('world!', 6);
-      parentPort.postMessage('written!');
-    });
-  `,
-    {
-      eval: true,
-      workerData: { sharedArrayBuffer },
-    },
-  );
-
-  const messagePromise = new Promise(resolve => {
-    w.on("message", resolve);
-  });
-
-  w.postMessage({});
-  // This would be a race condition if the memory regions were overlapping
-  local.write("Hello ");
-
-  await messagePromise;
-
-  expect(local.toString()).toBe("Hello world!");
-
-  global.gc();
-  await w.terminate();
-});
-
-//<#END_FILE: test-worker-workerdata-sharedarraybuffer.js
diff --git a/test/js/node/test/parallel/worker.test.js b/test/js/node/test/parallel/worker.test.js
deleted file mode 100644
index 7328a65dec..0000000000
--- a/test/js/node/test/parallel/worker.test.js
+++ /dev/null
@@ -1,26 +0,0 @@
-//#FILE: test-worker.js
-//#SHA1: 830c4e2ce132228fe7d49fd760271deed934db23
-//-----------------
-"use strict";
-
-const { Worker, isMainThread, parentPort } = require("worker_threads");
-
-const kTestString = "Hello, world!";
-
-if (isMainThread) {
-  test("Worker thread communication", done => {
-    const w = new Worker(__filename);
-    w.on("message", message => {
-      expect(message).toBe(kTestString);
-      done();
-    });
-  });
-} else {
-  setImmediate(() => {
-    process.nextTick(() => {
-      parentPort.postMessage(kTestString);
-    });
-  });
-}
-
-//<#END_FILE: test-worker.js
diff --git a/test/js/node/test/parallel/wrap-js-stream-read-stop.test.js b/test/js/node/test/parallel/wrap-js-stream-read-stop.test.js
deleted file mode 100644
index 6efe3f5df1..0000000000
--- a/test/js/node/test/parallel/wrap-js-stream-read-stop.test.js
+++ /dev/null
@@ -1,66 +0,0 @@
-//#FILE: test-wrap-js-stream-read-stop.js
-//#SHA1: 53e905da53ef7a130579672b04ddd6e65b7cb8d5
-//-----------------
-"use strict";
-
-const Stream = require("stream");
-
-class FakeStream extends Stream {
-  constructor() {
-    super();
-    this._paused = false;
-  }
-
-  pause() {
-    this._paused = true;
-  }
-
-  resume() {
-    this._paused = false;
-  }
-
-  isPaused() {
-    return this._paused;
-  }
-}
-
-class WrapStream {
-  constructor(stream) {
-    this.stream = stream;
-    this.stream.resume();
-  }
-
-  readStop() {
-    this.stream.pause();
-    return 0;
-  }
-}
-
-describe("WrapStream", () => {
-  let fakeStreamObj;
-  let wrappedStream;
-
-  beforeEach(() => {
-    fakeStreamObj = new FakeStream();
-    wrappedStream = new WrapStream(fakeStreamObj);
-  });
-
-  test("Resume by wrapped stream upon construction", () => {
-    expect(fakeStreamObj.isPaused()).toBe(false);
-  });
-
-  test("Pause and resume fakeStreamObj", () => {
-    fakeStreamObj.pause();
-    expect(fakeStreamObj.isPaused()).toBe(true);
-
-    fakeStreamObj.resume();
-    expect(fakeStreamObj.isPaused()).toBe(false);
-  });
-
-  test("readStop method", () => {
-    expect(wrappedStream.readStop()).toBe(0);
-    expect(fakeStreamObj.isPaused()).toBe(true);
-  });
-});
-
-//<#END_FILE: test-wrap-js-stream-read-stop.js
diff --git a/test/js/node/test/parallel/zlib-brotli-from-string.test.js b/test/js/node/test/parallel/zlib-brotli-from-string.test.js
deleted file mode 100644
index fa861d967b..0000000000
--- a/test/js/node/test/parallel/zlib-brotli-from-string.test.js
+++ /dev/null
@@ -1,66 +0,0 @@
-//#FILE: test-zlib-brotli-from-string.js
-//#SHA1: bb4656c195e75f9d49e2bad9e7b1130f571fa68b
-//-----------------
-"use strict";
-// Test compressing and uncompressing a string with brotli
-
-const zlib = require("zlib");
-
-const inputString =
-  "ΩΩLorem ipsum dolor sit amet, consectetur adipiscing eli" +
-  "t. Morbi faucibus, purus at gravida dictum, libero arcu " +
-  "convallis lacus, in commodo libero metus eu nisi. Nullam" +
-  " commodo, neque nec porta placerat, nisi est fermentum a" +
-  "ugue, vitae gravida tellus sapien sit amet tellus. Aenea" +
-  "n non diam orci. Proin quis elit turpis. Suspendisse non" +
-  " diam ipsum. Suspendisse nec ullamcorper odio. Vestibulu" +
-  "m arcu mi, sodales non suscipit id, ultrices ut massa. S" +
-  "ed ac sem sit amet arcu malesuada fermentum. Nunc sed. ";
-const compressedString =
-  "G/gBQBwHdky2aHV5KK9Snf05//1pPdmNw/7232fnIm1IB" +
-  "K1AA8RsN8OB8Nb7Lpgk3UWWUlzQXZyHQeBBbXMTQXC1j7" +
-  "wg3LJs9LqOGHRH2bj/a2iCTLLx8hBOyTqgoVuD1e+Qqdn" +
-  "f1rkUNyrWq6LtOhWgxP3QUwdhKGdZm3rJWaDDBV7+pDk1" +
-  "MIkrmjp4ma2xVi5MsgJScA3tP1I7mXeby6MELozrwoBQD" +
-  "mVTnEAicZNj4lkGqntJe2qSnGyeMmcFgraK94vCg/4iLu" +
-  "Tw5RhKhnVY++dZ6niUBmRqIutsjf5TzwF5iAg8a9UkjF5" +
-  "2eZ0tB2vo6v8SqVfNMkBmmhxr0NT9LkYF69aEjlYzj7IE" +
-  "KmEUQf1HBogRYhFIt4ymRNEgHAIzOyNEsQM=";
-
-test("brotli compress and decompress string", async () => {
-  const compressCallback = jest.fn();
-  const decompressCallback = jest.fn();
-
-  await new Promise(resolve => {
-    zlib.brotliCompress(inputString, (err, buffer) => {
-      compressCallback();
-      expect(inputString.length).toBeGreaterThan(buffer.length);
-
-      zlib.brotliDecompress(buffer, (err, buffer) => {
-        decompressCallback();
-        expect(buffer.toString()).toBe(inputString);
-        resolve();
-      });
-    });
-  });
-
-  expect(compressCallback).toHaveBeenCalledTimes(1);
-  expect(decompressCallback).toHaveBeenCalledTimes(1);
-});
-
-test("brotli decompress base64 string", async () => {
-  const decompressCallback = jest.fn();
-
-  const buffer = Buffer.from(compressedString, "base64");
-  await new Promise(resolve => {
-    zlib.brotliDecompress(buffer, (err, buffer) => {
-      decompressCallback();
-      expect(buffer.toString()).toBe(inputString);
-      resolve();
-    });
-  });
-
-  expect(decompressCallback).toHaveBeenCalledTimes(1);
-});
-
-//<#END_FILE: test-zlib-brotli-from-string.js
diff --git a/test/js/node/test/parallel/zlib-brotli.test.js b/test/js/node/test/parallel/zlib-brotli.test.js
deleted file mode 100644
index e97933cab8..0000000000
--- a/test/js/node/test/parallel/zlib-brotli.test.js
+++ /dev/null
@@ -1,101 +0,0 @@
-//#FILE: test-zlib-brotli.js
-//#SHA1: 53d893f351dd67279a8561e244183e38864c0c92
-//-----------------
-"use strict";
-
-const fixtures = require("../common/fixtures");
-const zlib = require("zlib");
-
-// Test some brotli-specific properties of the brotli streams that can not
-// be easily covered through expanding zlib-only tests.
-
-const sampleBuffer = fixtures.readSync("/pss-vectors.json");
-
-test("Quality parameter at stream creation", () => {
-  const sizes = [];
-  for (let quality = zlib.constants.BROTLI_MIN_QUALITY; quality <= zlib.constants.BROTLI_MAX_QUALITY; quality++) {
-    const encoded = zlib.brotliCompressSync(sampleBuffer, {
-      params: {
-        [zlib.constants.BROTLI_PARAM_QUALITY]: quality,
-      },
-    });
-    sizes.push(encoded.length);
-  }
-
-  // Increasing quality should roughly correspond to decreasing compressed size:
-  for (let i = 0; i < sizes.length - 1; i++) {
-    expect(sizes[i + 1]).toBeLessThanOrEqual(sizes[i] * 1.05); // 5 % margin of error.
-  }
-  expect(sizes[0]).toBeGreaterThan(sizes[sizes.length - 1]);
-});
-
-test("Setting out-of-bounds option values or keys", () => {
-  // expect(() => {
-  //   zlib.createBrotliCompress({
-  //     params: {
-  //       10000: 0,
-  //     },
-  //   });
-  // }).toThrow(
-  //   expect.objectContaining({
-  //     code: "ERR_BROTLI_INVALID_PARAM",
-  //     name: "RangeError",
-  //     message: expect.any(String),
-  //   }),
-  // );
-
-  // Test that accidentally using duplicate keys fails.
-  // expect(() => {
-  //   zlib.createBrotliCompress({
-  //     params: {
-  //       0: 0,
-  //       "00": 0,
-  //     },
-  //   });
-  // }).toThrow(
-  //   expect.objectContaining({
-  //     code: "ERR_BROTLI_INVALID_PARAM",
-  //     name: "RangeError",
-  //     message: expect.any(String),
-  //   }),
-  // );
-
-  expect(() => {
-    zlib.createBrotliCompress({
-      params: {
-        // This is a boolean flag
-        [zlib.constants.BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING]: 42,
-      },
-    });
-  }).toThrow(
-    expect.objectContaining({
-      code: "ERR_ZLIB_INITIALIZATION_FAILED",
-      name: "Error",
-      message: expect.any(String),
-    }),
-  );
-});
-
-test("Options.flush range", () => {
-  expect(() => {
-    zlib.brotliCompressSync("", { flush: zlib.constants.Z_FINISH });
-  }).toThrow(
-    expect.objectContaining({
-      code: "ERR_OUT_OF_RANGE",
-      name: "RangeError",
-      message: expect.any(String),
-    }),
-  );
-
-  expect(() => {
-    zlib.brotliCompressSync("", { finishFlush: zlib.constants.Z_FINISH });
-  }).toThrow(
-    expect.objectContaining({
-      code: "ERR_OUT_OF_RANGE",
-      name: "RangeError",
-      message: expect.any(String),
-    }),
-  );
-});
-
-//<#END_FILE: test-zlib-brotli.js
diff --git a/test/js/node/test/parallel/zlib-close-after-error.test.js b/test/js/node/test/parallel/zlib-close-after-error.test.js
deleted file mode 100644
index f336f5a950..0000000000
--- a/test/js/node/test/parallel/zlib-close-after-error.test.js
+++ /dev/null
@@ -1,22 +0,0 @@
-//#FILE: test-zlib-close-after-error.js
-//#SHA1: 1f561376d8af1a6b21f9f9abf6813a20cde33be6
-//-----------------
-"use strict";
-// https://github.com/nodejs/node/issues/6034
-
-const zlib = require("zlib");
-
-test("zlib close after error", done => {
-  const decompress = zlib.createGunzip(15);
-
-  decompress.on("error", err => {
-    expect(decompress._closed).toBe(true);
-    decompress.close();
-    done();
-  });
-
-  expect(decompress._closed).toBe(false);
-  decompress.write("something invalid");
-});
-
-//<#END_FILE: test-zlib-close-after-error.js
diff --git a/test/js/node/test/parallel/zlib-close-after-write.test.js b/test/js/node/test/parallel/zlib-close-after-write.test.js
deleted file mode 100644
index 05a029b37f..0000000000
--- a/test/js/node/test/parallel/zlib-close-after-write.test.js
+++ /dev/null
@@ -1,48 +0,0 @@
-//#FILE: test-zlib-close-after-write.js
-//#SHA1: 7fad593914e2a23d73598e4366e685b9aa91cc24
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const zlib = require("zlib");
-
-test("zlib close after write", async () => {
-  const gzipPromise = new Promise((resolve, reject) => {
-    zlib.gzip("hello", (err, out) => {
-      if (err) reject(err);
-      else resolve(out);
-    });
-  });
-
-  const out = await gzipPromise;
-
-  const unzip = zlib.createGunzip();
-  unzip.write(out);
-
-  const closePromise = new Promise(resolve => {
-    unzip.close(resolve);
-  });
-
-  await closePromise;
-});
-
-//<#END_FILE: test-zlib-close-after-write.js
diff --git a/test/js/node/test/parallel/zlib-const.test.js b/test/js/node/test/parallel/zlib-const.test.js
deleted file mode 100644
index a81535e446..0000000000
--- a/test/js/node/test/parallel/zlib-const.test.js
+++ /dev/null
@@ -1,23 +0,0 @@
-//#FILE: test-zlib-const.js
-//#SHA1: d85ad9e395d5781dbe5bf05e5514104bd9503be8
-//-----------------
-const zlib = require("zlib");
-
-test("zlib constants and codes are immutable", () => {
-  // Test Z_OK constant
-  expect(zlib.constants.Z_OK).toBe(0);
-  zlib.constants.Z_OK = 1;
-  expect(zlib.constants.Z_OK).toBe(0);
-
-  // Test Z_OK code
-  expect(zlib.codes.Z_OK).toBe(0);
-  zlib.codes.Z_OK = 1;
-  expect(zlib.codes.Z_OK).toBe(0);
-  zlib.codes = { Z_OK: 1 };
-  expect(zlib.codes.Z_OK).toBe(0);
-
-  // Test if zlib.codes is frozen
-  expect(Object.isFrozen(zlib.codes)).toBe(true);
-});
-
-//<#END_FILE: test-zlib-const.js
diff --git a/test/js/node/test/parallel/zlib-crc32.test.js b/test/js/node/test/parallel/zlib-crc32.test.js
deleted file mode 100644
index 5c1e51b63a..0000000000
--- a/test/js/node/test/parallel/zlib-crc32.test.js
+++ /dev/null
@@ -1,249 +0,0 @@
-//#FILE: test-zlib-crc32.js
-//#SHA1: a46ac98c5c568eec892b62f9da1effc368081b07
-//-----------------
-"use strict";
-
-const zlib = require("zlib");
-const { Buffer } = require("buffer");
-
-// The following test data comes from
-// https://github.com/zlib-ng/zlib-ng/blob/5401b24/test/test_crc32.cc
-// test_crc32.cc -- crc32 unit test
-// Copyright (C) 2019-2021 IBM Corporation
-// Authors: Rogerio Alves    <rogealve@br.ibm.com>
-//          Matheus Castanho <msc@linux.ibm.com>
-// For conditions of distribution and use, see copyright notice in zlib.h
-//
-const tests = [
-  [0x0, 0x0, 0, 0x0],
-  [0xffffffff, 0x0, 0, 0x0],
-  [0x0, 0x0, 255, 0x0] /*  BZ 174799.  */,
-  [0x0, 0x0, 256, 0x0],
-  [0x0, 0x0, 257, 0x0],
-  [0x0, 0x0, 32767, 0x0],
-  [0x0, 0x0, 32768, 0x0],
-  [0x0, 0x0, 32769, 0x0],
-  [0x0, "", 0, 0x0],
-  [0xffffffff, "", 0, 0xffffffff],
-  [0x0, "abacus", 6, 0xc3d7115b],
-  [0x0, "backlog", 7, 0x269205],
-  [0x0, "campfire", 8, 0x22a515f8],
-  [0x0, "delta", 5, 0x9643fed9],
-  [0x0, "executable", 10, 0xd68eda01],
-  [0x0, "file", 4, 0x8c9f3610],
-  [0x0, "greatest", 8, 0xc1abd6cd],
-  [0x0, "hello", 5, 0x3610a686],
-  [0x0, "inverter", 8, 0xc9e962c9],
-  [0x0, "jigsaw", 6, 0xce4e3f69],
-  [0x0, "karate", 6, 0x890be0e2],
-  [0x0, "landscape", 9, 0xc4e0330b],
-  [0x0, "machine", 7, 0x1505df84],
-  [0x0, "nanometer", 9, 0xd4e19f39],
-  [0x0, "oblivion", 8, 0xdae9de77],
-  [0x0, "panama", 6, 0x66b8979c],
-  [0x0, "quest", 5, 0x4317f817],
-  [0x0, "resource", 8, 0xbc91f416],
-  [0x0, "secret", 6, 0x5ca2e8e5],
-  [0x0, "test", 4, 0xd87f7e0c],
-  [0x0, "ultimate", 8, 0x3fc79b0b],
-  [0x0, "vector", 6, 0x1b6e485b],
-  [0x0, "walrus", 6, 0xbe769b97],
-  [0x0, "xeno", 4, 0xe7a06444],
-  [0x0, "yelling", 7, 0xfe3944e5],
-  [0x0, "zlib", 4, 0x73887d3a],
-  [0x0, "4BJD7PocN1VqX0jXVpWB", 20, 0xd487a5a1],
-  [0x0, "F1rPWI7XvDs6nAIRx41l", 20, 0x61a0132e],
-  [0x0, "ldhKlsVkPFOveXgkGtC2", 20, 0xdf02f76],
-  [0x0, "5KKnGOOrs8BvJ35iKTOS", 20, 0x579b2b0a],
-  [0x0, "0l1tw7GOcem06Ddu7yn4", 20, 0xf7d16e2d],
-  [0x0, "MCr47CjPIn9R1IvE1Tm5", 20, 0x731788f5],
-  [0x0, "UcixbzPKTIv0SvILHVdO", 20, 0x7112bb11],
-  [0x0, "dGnAyAhRQDsWw0ESou24", 20, 0xf32a0dac],
-  [0x0, "di0nvmY9UYMYDh0r45XT", 20, 0x625437bb],
-  [0x0, "2XKDwHfAhFsV0RhbqtvH", 20, 0x896930f9],
-  [0x0, "ZhrANFIiIvRnqClIVyeD", 20, 0x8579a37],
-  [0x0, "v7Q9ehzioTOVeDIZioT1", 20, 0x632aa8e0],
-  [0x0, "Yod5hEeKcYqyhfXbhxj2", 20, 0xc829af29],
-  [0x0, "GehSWY2ay4uUKhehXYb0", 20, 0x1b08b7e8],
-  [0x0, "kwytJmq6UqpflV8Y8GoE", 20, 0x4e33b192],
-  [0x0, "70684206568419061514", 20, 0x59a179f0],
-  [0x0, "42015093765128581010", 20, 0xcd1013d7],
-  [0x0, "88214814356148806939", 20, 0xab927546],
-  [0x0, "43472694284527343838", 20, 0x11f3b20c],
-  [0x0, "49769333513942933689", 20, 0xd562d4ca],
-  [0x0, "54979784887993251199", 20, 0x233395f7],
-  [0x0, "58360544869206793220", 20, 0x2d167fd5],
-  [0x0, "27347953487840714234", 20, 0x8b5108ba],
-  [0x0, "07650690295365319082", 20, 0xc46b3cd8],
-  [0x0, "42655507906821911703", 20, 0xc10b2662],
-  [0x0, "29977409200786225655", 20, 0xc9a0f9d2],
-  [0x0, "85181542907229116674", 20, 0x9341357b],
-  [0x0, "87963594337989416799", 20, 0xf0424937],
-  [0x0, "21395988329504168551", 20, 0xd7c4c31f],
-  [0x0, "51991013580943379423", 20, 0xf11edcc4],
-  [0x0, "*]+@!);({_$;}[_},?{?;(_?,=-][@", 30, 0x40795df4],
-  [0x0, "_@:_).&(#.[:[{[:)$++-($_;@[)}+", 30, 0xdd61a631],
-  [0x0, "&[!,[$_==}+.]@!;*(+},[;:)$;)-@", 30, 0xca907a99],
-  [0x0, "]{.[.+?+[[=;[?}_#&;[=)__$$:+=_", 30, 0xf652deac],
-  [0x0, "-%.)=/[@].:.(:,()$;=%@-$?]{%+%", 30, 0xaf39a5a9],
-  [0x0, "+]#$(@&.=:,*];/.!]%/{:){:@(;)$", 30, 0x6bebb4cf],
-  // eslint-disable-next-line no-template-curly-in-string
-  [0x0, ")-._.:?[&:.=+}(*$/=!.${;(=$@!}", 30, 0x76430bac],
-  [0x0, ":(_*&%/[[}+,?#$&*+#[([*-/#;%(]", 30, 0x6c80c388],
-  [0x0, "{[#-;:$/{)(+[}#]/{&!%(@)%:@-$:", 30, 0xd54d977d],
-  [0x0, "_{$*,}(&,@.)):=!/%(&(,,-?$}}}!", 30, 0xe3966ad5],
-  [
-    0x0,
-    "e$98KNzqaV)Y:2X?]77].{gKRD4G5{mHZk,Z)SpU%L3FSgv!Wb8MLAFdi{+fp)c,@8m6v)yXg@]HBDFk?.4&}g5_udE*JHCiH=aL",
-    100,
-    0xe7c71db9,
-  ],
-  [
-    0x0,
-    "r*Fd}ef+5RJQ;+W=4jTR9)R*p!B;]Ed7tkrLi;88U7g@3v!5pk2X6D)vt,.@N8c]@yyEcKi[vwUu@.Ppm@C6%Mv*3Nw}Y,58_aH)",
-    100,
-    0xeaa52777,
-  ],
-  [
-    0x0,
-    "h{bcmdC+a;t+Cf{6Y_dFq-{X4Yu&7uNfVDh?q&_u.UWJU],-GiH7ADzb7-V.Q%4=+v!$L9W+T=bP]$_:]Vyg}A.ygD.r;h-D]m%&",
-    100,
-    0xcd472048,
-  ],
-  [0x7a30360d, "abacus", 6, 0xf8655a84],
-  [0x6fd767ee, "backlog", 7, 0x1ed834b1],
-  [0xefeb7589, "campfire", 8, 0x686cfca],
-  [0x61cf7e6b, "delta", 5, 0x1554e4b1],
-  [0xdc712e2, "executable", 10, 0x761b4254],
-  [0xad23c7fd, "file", 4, 0x7abdd09b],
-  [0x85cb2317, "greatest", 8, 0x4ba91c6b],
-  [0x9eed31b0, "inverter", 8, 0xd5e78ba5],
-  [0xb94f34ca, "jigsaw", 6, 0x23649109],
-  [0xab058a2, "karate", 6, 0xc5591f41],
-  [0x5bff2b7a, "landscape", 9, 0xf10eb644],
-  [0x605c9a5f, "machine", 7, 0xbaa0a636],
-  [0x51bdeea5, "nanometer", 9, 0x6af89afb],
-  [0x85c21c79, "oblivion", 8, 0xecae222b],
-  [0x97216f56, "panama", 6, 0x47dffac4],
-  [0x18444af2, "quest", 5, 0x70c2fe36],
-  [0xbe6ce359, "resource", 8, 0x1471d925],
-  [0x843071f1, "secret", 6, 0x50c9a0db],
-  [0xf2480c60, "ultimate", 8, 0xf973daf8],
-  [0x2d2feb3d, "vector", 6, 0x344ac03d],
-  [0x7490310a, "walrus", 6, 0x6d1408ef],
-  [0x97d247d4, "xeno", 4, 0xe62670b5],
-  [0x93cf7599, "yelling", 7, 0x1b36da38],
-  [0x73c84278, "zlib", 4, 0x6432d127],
-  [0x228a87d1, "4BJD7PocN1VqX0jXVpWB", 20, 0x997107d0],
-  [0xa7a048d0, "F1rPWI7XvDs6nAIRx41l", 20, 0xdc567274],
-  [0x1f0ded40, "ldhKlsVkPFOveXgkGtC2", 20, 0xdcc63870],
-  [0xa804a62f, "5KKnGOOrs8BvJ35iKTOS", 20, 0x6926cffd],
-  [0x508fae6a, "0l1tw7GOcem06Ddu7yn4", 20, 0xb52b38bc],
-  [0xe5adaf4f, "MCr47CjPIn9R1IvE1Tm5", 20, 0xf83b8178],
-  [0x67136a40, "UcixbzPKTIv0SvILHVdO", 20, 0xc5213070],
-  [0xb00c4a10, "dGnAyAhRQDsWw0ESou24", 20, 0xbc7648b0],
-  [0x2e0c84b5, "di0nvmY9UYMYDh0r45XT", 20, 0xd8123a72],
-  [0x81238d44, "2XKDwHfAhFsV0RhbqtvH", 20, 0xd5ac5620],
-  [0xf853aa92, "ZhrANFIiIvRnqClIVyeD", 20, 0xceae099d],
-  [0x5a692325, "v7Q9ehzioTOVeDIZioT1", 20, 0xb07d2b24],
-  [0x3275b9f, "Yod5hEeKcYqyhfXbhxj2", 20, 0x24ce91df],
-  [0x38371feb, "GehSWY2ay4uUKhehXYb0", 20, 0x707b3b30],
-  [0xafc8bf62, "kwytJmq6UqpflV8Y8GoE", 20, 0x16abc6a9],
-  [0x9b07db73, "70684206568419061514", 20, 0xae1fb7b7],
-  [0xe75b214, "42015093765128581010", 20, 0xd4eecd2d],
-  [0x72d0fe6f, "88214814356148806939", 20, 0x4660ec7],
-  [0xf857a4b1, "43472694284527343838", 20, 0xfd8afdf7],
-  [0x54b8e14, "49769333513942933689", 20, 0xc6d1b5f2],
-  [0xd6aa5616, "54979784887993251199", 20, 0x32476461],
-  [0x11e63098, "58360544869206793220", 20, 0xd917cf1a],
-  [0xbe92385, "27347953487840714234", 20, 0x4ad14a12],
-  [0x49511de0, "07650690295365319082", 20, 0xe37b5c6c],
-  [0x3db13bc1, "42655507906821911703", 20, 0x7cc497f1],
-  [0xbb899bea, "29977409200786225655", 20, 0x99781bb2],
-  [0xf6cd9436, "85181542907229116674", 20, 0x132256a1],
-  [0x9109e6c3, "87963594337989416799", 20, 0xbfdb2c83],
-  [0x75770fc, "21395988329504168551", 20, 0x8d9d1e81],
-  [0x69b1d19b, "51991013580943379423", 20, 0x7b6d4404],
-  [0xc6132975, "*]+@!);({_$;}[_},?{?;(_?,=-][@", 30, 0x8619f010],
-  [0xd58cb00c, "_@:_).&(#.[:[{[:)$++-($_;@[)}+", 30, 0x15746ac3],
-  [0xb63b8caa, "&[!,[$_==}+.]@!;*(+},[;:)$;)-@", 30, 0xaccf812f],
-  [0x8a45a2b8, "]{.[.+?+[[=;[?}_#&;[=)__$$:+=_", 30, 0x78af45de],
-  [0xcbe95b78, "-%.)=/[@].:.(:,()$;=%@-$?]{%+%", 30, 0x25b06b59],
-  [0x4ef8a54b, "+]#$(@&.=:,*];/.!]%/{:){:@(;)$", 30, 0x4ba0d08f],
-  // eslint-disable-next-line no-template-curly-in-string
-  [0x76ad267a, ")-._.:?[&:.=+}(*$/=!.${;(=$@!}", 30, 0xe26b6aac],
-  [0x569e613c, ":(_*&%/[[}+,?#$&*+#[([*-/#;%(]", 30, 0x7e2b0a66],
-  [0x36aa61da, "{[#-;:$/{)(+[}#]/{&!%(@)%:@-$:", 30, 0xb3430dc7],
-  [0xf67222df, "_{$*,}(&,@.)):=!/%(&(,,-?$}}}!", 30, 0x626c17a],
-  [
-    0x74b34fd3,
-    "e$98KNzqaV)Y:2X?]77].{gKRD4G5{mHZk,Z)SpU%L3FSgv!Wb8MLAFdi{+fp)c,@8m6v)yXg@]HBDFk?.4&}g5_udE*JHCiH=aL",
-    100,
-    0xccf98060,
-  ],
-  [
-    0x351fd770,
-    "r*Fd}ef+5RJQ;+W=4jTR9)R*p!B;]Ed7tkrLi;88U7g@3v!5pk2X6D)vt,.@N8c]@yyEcKi[vwUu@.Ppm@C6%Mv*3Nw}Y,58_aH)",
-    100,
-    0xd8b95312,
-  ],
-  [
-    0xc45aef77,
-    "h{bcmdC+a;t+Cf{6Y_dFq-{X4Yu&7uNfVDh?q&_u.UWJU],-GiH7ADzb7-V.Q%4=+v!$L9W+T=bP]$_:]Vyg}A.ygD.r;h-D]m%&",
-    100,
-    0xbb1c9912,
-  ],
-  [
-    0xc45aef77,
-    "h{bcmdC+a;t+Cf{6Y_dFq-{X4Yu&7uNfVDh?q&_u.UWJU],-GiH7ADzb7-V.Q%4=+v!$L9W+T=bP]$_:]Vyg}A.ygD.r;h-D]m%&" +
-      "h{bcmdC+a;t+Cf{6Y_dFq-{X4Yu&7uNfVDh?q&_u.UWJU],-GiH7ADzb7-V.Q%4=+v!$L9W+T=bP]$_:]Vyg}A.ygD.r;h-D]m%&" +
-      "h{bcmdC+a;t+Cf{6Y_dFq-{X4Yu&7uNfVDh?q&_u.UWJU],-GiH7ADzb7-V.Q%4=+v!$L9W+T=bP]$_:]Vyg}A.ygD.r;h-D]m%&" +
-      "h{bcmdC+a;t+Cf{6Y_dFq-{X4Yu&7uNfVDh?q&_u.UWJU],-GiH7ADzb7-V.Q%4=+v!$L9W+T=bP]$_:]Vyg}A.ygD.r;h-D]m%&" +
-      "h{bcmdC+a;t+Cf{6Y_dFq-{X4Yu&7uNfVDh?q&_u.UWJU],-GiH7ADzb7-V.Q%4=+v!$L9W+T=bP]$_:]Vyg}A.ygD.r;h-D]m%&" +
-      "h{bcmdC+a;t+Cf{6Y_dFq-{X4Yu&7uNfVDh?q&_u.UWJU],-GiH7ADzb7-V.Q%4=+v!$L9W+T=bP]$_:]Vyg}A.ygD.r;h-D]m%&",
-    600,
-    0x888afa5b,
-  ],
-];
-
-describe("zlib.crc32", () => {
-  test("crc32 test case", () => {
-    for (const [crc, data, len, expected] of tests) {
-      if (data === 0) {
-        return;
-      }
-      const buf = Buffer.from(data, "utf8");
-      expect(buf.length).toBe(len);
-      expect(zlib.crc32(buf, crc)).toBe(expected);
-      expect(zlib.crc32(buf.toString(), crc)).toBe(expected);
-      if (crc === 0) {
-        expect(zlib.crc32(buf)).toBe(expected);
-        expect(zlib.crc32(buf.toString())).toBe(expected);
-      }
-    }
-  });
-
-  test("invalid input types", () => {
-    [undefined, null, true, 1, () => {}, {}].forEach(invalid => {
-      expect(() => zlib.crc32(invalid)).toThrow(
-        expect.objectContaining({
-          code: "ERR_INVALID_ARG_TYPE",
-          message: expect.any(String),
-        }),
-      );
-    });
-  });
-
-  test("invalid crc types", () => {
-    [null, true, () => {}, {}].forEach(invalid => {
-      expect(() => zlib.crc32("test", invalid)).toThrow(
-        expect.objectContaining({
-          code: "ERR_INVALID_ARG_TYPE",
-          message: expect.any(String),
-        }),
-      );
-    });
-  });
-});
-
-//<#END_FILE: test-zlib-crc32.js
diff --git a/test/js/node/test/parallel/zlib-create-raw.test.js b/test/js/node/test/parallel/zlib-create-raw.test.js
deleted file mode 100644
index 4bd60d6d8e..0000000000
--- a/test/js/node/test/parallel/zlib-create-raw.test.js
+++ /dev/null
@@ -1,18 +0,0 @@
-//#FILE: test-zlib-create-raw.js
-//#SHA1: 187539d5696ec6b7c567dfba0d1528c4b65d1e0a
-//-----------------
-"use strict";
-
-const zlib = require("zlib");
-
-test("zlib.createInflateRaw returns an instance of InflateRaw", () => {
-  const inflateRaw = zlib.createInflateRaw();
-  expect(inflateRaw).toBeInstanceOf(zlib.InflateRaw);
-});
-
-test("zlib.createDeflateRaw returns an instance of DeflateRaw", () => {
-  const deflateRaw = zlib.createDeflateRaw();
-  expect(deflateRaw).toBeInstanceOf(zlib.DeflateRaw);
-});
-
-//<#END_FILE: test-zlib-create-raw.js
diff --git a/test/js/node/test/parallel/zlib-deflate-constructors.test.js b/test/js/node/test/parallel/zlib-deflate-constructors.test.js
deleted file mode 100644
index d9a0411de2..0000000000
--- a/test/js/node/test/parallel/zlib-deflate-constructors.test.js
+++ /dev/null
@@ -1,281 +0,0 @@
-//#FILE: test-zlib-deflate-constructors.js
-//#SHA1: fdacb219f8fcceeeb4800473b37fca16fcf4c241
-//-----------------
-"use strict";
-
-const zlib = require("zlib");
-
-// Work with and without `new` keyword
-test("Deflate constructor works with and without new keyword", () => {
-  expect(zlib.Deflate()).toBeInstanceOf(zlib.Deflate);
-  expect(new zlib.Deflate()).toBeInstanceOf(zlib.Deflate);
-});
-
-test("DeflateRaw constructor works with and without new keyword", () => {
-  expect(zlib.DeflateRaw()).toBeInstanceOf(zlib.DeflateRaw);
-  expect(new zlib.DeflateRaw()).toBeInstanceOf(zlib.DeflateRaw);
-});
-
-// Throws if `options.chunkSize` is invalid
-test("Deflate constructor throws for invalid chunkSize", () => {
-  expect(() => new zlib.Deflate({ chunkSize: "test" })).toThrow(
-    expect.objectContaining({
-      code: "ERR_INVALID_ARG_TYPE",
-      name: "TypeError",
-      message: expect.any(String),
-    }),
-  );
-
-  expect(() => new zlib.Deflate({ chunkSize: -Infinity })).toThrow(
-    expect.objectContaining({
-      code: "ERR_OUT_OF_RANGE",
-      name: "RangeError",
-      message: expect.any(String),
-    }),
-  );
-
-  expect(() => new zlib.Deflate({ chunkSize: 0 })).toThrow(
-    expect.objectContaining({
-      code: "ERR_OUT_OF_RANGE",
-      name: "RangeError",
-      message: expect.any(String),
-    }),
-  );
-});
-
-// Confirm that maximum chunk size cannot be exceeded because it is `Infinity`.
-test("Z_MAX_CHUNK is Infinity", () => {
-  expect(zlib.constants.Z_MAX_CHUNK).toBe(Infinity);
-});
-
-// Throws if `options.windowBits` is invalid
-test("Deflate constructor throws for invalid windowBits", () => {
-  expect(() => new zlib.Deflate({ windowBits: "test" })).toThrow(
-    expect.objectContaining({
-      code: "ERR_INVALID_ARG_TYPE",
-      name: "TypeError",
-      message: expect.any(String),
-    }),
-  );
-
-  expect(() => new zlib.Deflate({ windowBits: -Infinity })).toThrow(
-    expect.objectContaining({
-      code: "ERR_OUT_OF_RANGE",
-      name: "RangeError",
-      message: expect.any(String),
-    }),
-  );
-
-  expect(() => new zlib.Deflate({ windowBits: Infinity })).toThrow(
-    expect.objectContaining({
-      code: "ERR_OUT_OF_RANGE",
-      name: "RangeError",
-      message: expect.any(String),
-    }),
-  );
-
-  expect(() => new zlib.Deflate({ windowBits: 0 })).toThrow(
-    expect.objectContaining({
-      code: "ERR_OUT_OF_RANGE",
-      name: "RangeError",
-      message: expect.any(String),
-    }),
-  );
-});
-
-// Throws if `options.level` is invalid
-test("Deflate constructor throws for invalid level", () => {
-  expect(() => new zlib.Deflate({ level: "test" })).toThrow(
-    expect.objectContaining({
-      code: "ERR_INVALID_ARG_TYPE",
-      name: "TypeError",
-      message: expect.any(String),
-    }),
-  );
-
-  expect(() => new zlib.Deflate({ level: -Infinity })).toThrow(
-    expect.objectContaining({
-      code: "ERR_OUT_OF_RANGE",
-      name: "RangeError",
-      message: expect.any(String),
-    }),
-  );
-
-  expect(() => new zlib.Deflate({ level: Infinity })).toThrow(
-    expect.objectContaining({
-      code: "ERR_OUT_OF_RANGE",
-      name: "RangeError",
-      message: expect.any(String),
-    }),
-  );
-
-  expect(() => new zlib.Deflate({ level: -2 })).toThrow(
-    expect.objectContaining({
-      code: "ERR_OUT_OF_RANGE",
-      name: "RangeError",
-      message: expect.any(String),
-    }),
-  );
-});
-
-// Throws if `level` invalid in  `Deflate.prototype.params()`
-test("Deflate.prototype.params throws for invalid level", () => {
-  expect(() => new zlib.Deflate().params("test")).toThrow(
-    expect.objectContaining({
-      code: "ERR_INVALID_ARG_TYPE",
-      name: "TypeError",
-      message: expect.any(String),
-    }),
-  );
-
-  expect(() => new zlib.Deflate().params(-Infinity)).toThrow(
-    expect.objectContaining({
-      code: "ERR_OUT_OF_RANGE",
-      name: "RangeError",
-      message: expect.any(String),
-    }),
-  );
-
-  expect(() => new zlib.Deflate().params(Infinity)).toThrow(
-    expect.objectContaining({
-      code: "ERR_OUT_OF_RANGE",
-      name: "RangeError",
-      message: expect.any(String),
-    }),
-  );
-
-  expect(() => new zlib.Deflate().params(-2)).toThrow(
-    expect.objectContaining({
-      code: "ERR_OUT_OF_RANGE",
-      name: "RangeError",
-      message: expect.any(String),
-    }),
-  );
-});
-
-// Throws if options.memLevel is invalid
-test("Deflate constructor throws for invalid memLevel", () => {
-  expect(() => new zlib.Deflate({ memLevel: "test" })).toThrow(
-    expect.objectContaining({
-      code: "ERR_INVALID_ARG_TYPE",
-      name: "TypeError",
-      message: expect.any(String),
-    }),
-  );
-
-  expect(() => new zlib.Deflate({ memLevel: -Infinity })).toThrow(
-    expect.objectContaining({
-      code: "ERR_OUT_OF_RANGE",
-      name: "RangeError",
-      message: expect.any(String),
-    }),
-  );
-
-  expect(() => new zlib.Deflate({ memLevel: Infinity })).toThrow(
-    expect.objectContaining({
-      code: "ERR_OUT_OF_RANGE",
-      name: "RangeError",
-      message: expect.any(String),
-    }),
-  );
-
-  expect(() => new zlib.Deflate({ memLevel: -2 })).toThrow(
-    expect.objectContaining({
-      code: "ERR_OUT_OF_RANGE",
-      name: "RangeError",
-      message: expect.any(String),
-    }),
-  );
-});
-
-// Does not throw if opts.strategy is valid
-test("Deflate constructor does not throw for valid strategy", () => {
-  expect(() => new zlib.Deflate({ strategy: zlib.constants.Z_FILTERED })).not.toThrow();
-  expect(() => new zlib.Deflate({ strategy: zlib.constants.Z_HUFFMAN_ONLY })).not.toThrow();
-  expect(() => new zlib.Deflate({ strategy: zlib.constants.Z_RLE })).not.toThrow();
-  expect(() => new zlib.Deflate({ strategy: zlib.constants.Z_FIXED })).not.toThrow();
-  expect(() => new zlib.Deflate({ strategy: zlib.constants.Z_DEFAULT_STRATEGY })).not.toThrow();
-});
-
-// Throws if options.strategy is invalid
-test("Deflate constructor throws for invalid strategy", () => {
-  expect(() => new zlib.Deflate({ strategy: "test" })).toThrow(
-    expect.objectContaining({
-      code: "ERR_INVALID_ARG_TYPE",
-      name: "TypeError",
-      message: expect.any(String),
-    }),
-  );
-
-  expect(() => new zlib.Deflate({ strategy: -Infinity })).toThrow(
-    expect.objectContaining({
-      code: "ERR_OUT_OF_RANGE",
-      name: "RangeError",
-      message: expect.any(String),
-    }),
-  );
-
-  expect(() => new zlib.Deflate({ strategy: Infinity })).toThrow(
-    expect.objectContaining({
-      code: "ERR_OUT_OF_RANGE",
-      name: "RangeError",
-      message: expect.any(String),
-    }),
-  );
-
-  expect(() => new zlib.Deflate({ strategy: -2 })).toThrow(
-    expect.objectContaining({
-      code: "ERR_OUT_OF_RANGE",
-      name: "RangeError",
-      message: expect.any(String),
-    }),
-  );
-});
-
-// Throws TypeError if `strategy` is invalid in `Deflate.prototype.params()`
-test("Deflate.prototype.params throws for invalid strategy", () => {
-  expect(() => new zlib.Deflate().params(0, "test")).toThrow(
-    expect.objectContaining({
-      code: "ERR_INVALID_ARG_TYPE",
-      name: "TypeError",
-      message: expect.any(String),
-    }),
-  );
-
-  expect(() => new zlib.Deflate().params(0, -Infinity)).toThrow(
-    expect.objectContaining({
-      code: "ERR_OUT_OF_RANGE",
-      name: "RangeError",
-      message: expect.any(String),
-    }),
-  );
-
-  expect(() => new zlib.Deflate().params(0, Infinity)).toThrow(
-    expect.objectContaining({
-      code: "ERR_OUT_OF_RANGE",
-      name: "RangeError",
-      message: expect.any(String),
-    }),
-  );
-
-  expect(() => new zlib.Deflate().params(0, -2)).toThrow(
-    expect.objectContaining({
-      code: "ERR_OUT_OF_RANGE",
-      name: "RangeError",
-      message: expect.any(String),
-    }),
-  );
-});
-
-// Throws if opts.dictionary is not a Buffer
-test("Deflate constructor throws if dictionary is not a Buffer", () => {
-  expect(() => new zlib.Deflate({ dictionary: "not a buffer" })).toThrow(
-    expect.objectContaining({
-      code: "ERR_INVALID_ARG_TYPE",
-      name: "TypeError",
-      message: expect.any(String),
-    }),
-  );
-});
-
-//<#END_FILE: test-zlib-deflate-constructors.js
diff --git a/test/js/node/test/parallel/zlib-deflate-raw-inherits.test.js b/test/js/node/test/parallel/zlib-deflate-raw-inherits.test.js
deleted file mode 100644
index 1eb9243059..0000000000
--- a/test/js/node/test/parallel/zlib-deflate-raw-inherits.test.js
+++ /dev/null
@@ -1,40 +0,0 @@
-//#FILE: test-zlib-deflate-raw-inherits.js
-//#SHA1: 9e1873864f4af27abf3a8a36a87edd2d036805d8
-//-----------------
-"use strict";
-
-const { DeflateRaw } = require("zlib");
-const { Readable } = require("stream");
-
-// Validates that zlib.DeflateRaw can be inherited
-// with Object.setPrototypeOf
-
-test("DeflateRaw can be inherited with Object.setPrototypeOf", done => {
-  function NotInitialized(options) {
-    DeflateRaw.call(this, options);
-    this.prop = true;
-  }
-  Object.setPrototypeOf(NotInitialized.prototype, DeflateRaw.prototype);
-  Object.setPrototypeOf(NotInitialized, DeflateRaw);
-
-  const dest = new NotInitialized();
-
-  const read = new Readable({
-    read() {
-      this.push(Buffer.from("a test string"));
-      this.push(null);
-    },
-  });
-
-  read.pipe(dest);
-  dest.resume();
-
-  // We need to add an event listener to ensure the test completes
-  dest.on("finish", () => {
-    expect(dest.prop).toBe(true);
-    expect(dest instanceof DeflateRaw).toBe(true);
-    done();
-  });
-});
-
-//<#END_FILE: test-zlib-deflate-raw-inherits.js
diff --git a/test/js/node/test/parallel/zlib-dictionary-fail.test.js b/test/js/node/test/parallel/zlib-dictionary-fail.test.js
deleted file mode 100644
index 4085281359..0000000000
--- a/test/js/node/test/parallel/zlib-dictionary-fail.test.js
+++ /dev/null
@@ -1,76 +0,0 @@
-//#FILE: test-zlib-dictionary-fail.js
-//#SHA1: e9c6d383f9b0a202067a125c016f1ef3cd5be558
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const zlib = require("zlib");
-
-// String "test" encoded with dictionary "dict".
-const input = Buffer.from([0x78, 0xbb, 0x04, 0x09, 0x01, 0xa5]);
-
-test("zlib.createInflate without dictionary", async () => {
-  const stream = zlib.createInflate();
-
-  await expect(
-    new Promise((resolve, reject) => {
-      stream.on("error", reject);
-      stream.write(input);
-    }),
-  ).rejects.toThrow(
-    expect.objectContaining({
-      message: expect.stringMatching(/Missing dictionary/),
-    }),
-  );
-});
-
-test("zlib.createInflate with wrong dictionary", async () => {
-  const stream = zlib.createInflate({ dictionary: Buffer.from("fail") });
-
-  await expect(
-    new Promise((resolve, reject) => {
-      stream.on("error", reject);
-      stream.write(input);
-    }),
-  ).rejects.toThrow(
-    expect.objectContaining({
-      message: expect.stringMatching(/Bad dictionary/),
-    }),
-  );
-});
-
-test("zlib.createInflateRaw with wrong dictionary", async () => {
-  const stream = zlib.createInflateRaw({ dictionary: Buffer.from("fail") });
-
-  await expect(
-    new Promise((resolve, reject) => {
-      stream.on("error", reject);
-      stream.write(input);
-    }),
-  ).rejects.toThrow(
-    expect.objectContaining({
-      message: expect.stringMatching(/(invalid|Operation-Ending-Supplemental Code is 0x12)/),
-    }),
-  );
-});
-
-//<#END_FILE: test-zlib-dictionary-fail.js
diff --git a/test/js/node/test/parallel/zlib-empty-buffer.test.js b/test/js/node/test/parallel/zlib-empty-buffer.test.js
deleted file mode 100644
index 553415206f..0000000000
--- a/test/js/node/test/parallel/zlib-empty-buffer.test.js
+++ /dev/null
@@ -1,28 +0,0 @@
-//#FILE: test-zlib-empty-buffer.js
-//#SHA1: 7a2e8687dcd6e4bd815aa22c2bbff08251d9d91a
-//-----------------
-"use strict";
-const zlib = require("zlib");
-const { inspect, promisify } = require("util");
-const emptyBuffer = Buffer.alloc(0);
-
-describe("zlib empty buffer", () => {
-  const testCases = [
-    [zlib.deflateRawSync, zlib.inflateRawSync, "raw sync"],
-    [zlib.deflateSync, zlib.inflateSync, "deflate sync"],
-    [zlib.gzipSync, zlib.gunzipSync, "gzip sync"],
-    [zlib.brotliCompressSync, zlib.brotliDecompressSync, "br sync"],
-    [promisify(zlib.deflateRaw), promisify(zlib.inflateRaw), "raw"],
-    [promisify(zlib.deflate), promisify(zlib.inflate), "deflate"],
-    [promisify(zlib.gzip), promisify(zlib.gunzip), "gzip"],
-    [promisify(zlib.brotliCompress), promisify(zlib.brotliDecompress), "br"],
-  ];
-
-  test.each(testCases)("compresses and decompresses empty buffer using %s", async (compress, decompress, method) => {
-    const compressed = await compress(emptyBuffer);
-    const decompressed = await decompress(compressed);
-    expect(decompressed).toStrictEqual(emptyBuffer);
-  });
-});
-
-//<#END_FILE: test-zlib-empty-buffer.js
diff --git a/test/js/node/test/parallel/zlib-failed-init.test.js b/test/js/node/test/parallel/zlib-failed-init.test.js
deleted file mode 100644
index 1f47ce229d..0000000000
--- a/test/js/node/test/parallel/zlib-failed-init.test.js
+++ /dev/null
@@ -1,45 +0,0 @@
-//#FILE: test-zlib-failed-init.js
-//#SHA1: a1c770e81c677ebefa0e5969e3441b28e63ab75a
-//-----------------
-"use strict";
-
-const zlib = require("zlib");
-
-test("zlib createGzip with invalid chunkSize", () => {
-  expect(() => zlib.createGzip({ chunkSize: 0 })).toThrow(
-    expect.objectContaining({
-      code: "ERR_OUT_OF_RANGE",
-      name: "RangeError",
-    }),
-  );
-});
-
-test("zlib createGzip with invalid windowBits", () => {
-  expect(() => zlib.createGzip({ windowBits: 0 })).toThrow(
-    expect.objectContaining({
-      code: "ERR_OUT_OF_RANGE",
-      name: "RangeError",
-    }),
-  );
-});
-
-test("zlib createGzip with invalid memLevel", () => {
-  expect(() => zlib.createGzip({ memLevel: 0 })).toThrow(
-    expect.objectContaining({
-      code: "ERR_OUT_OF_RANGE",
-      name: "RangeError",
-    }),
-  );
-});
-
-test("zlib createGzip with NaN level", () => {
-  const stream = zlib.createGzip({ level: NaN });
-  expect(stream._level).toBe(zlib.constants.Z_DEFAULT_COMPRESSION);
-});
-
-test("zlib createGzip with NaN strategy", () => {
-  const stream = zlib.createGzip({ strategy: NaN });
-  expect(stream._strategy).toBe(zlib.constants.Z_DEFAULT_STRATEGY);
-});
-
-//<#END_FILE: test-zlib-failed-init.js
diff --git a/test/js/node/test/parallel/zlib-flush-flags.test.js b/test/js/node/test/parallel/zlib-flush-flags.test.js
deleted file mode 100644
index 306fe03791..0000000000
--- a/test/js/node/test/parallel/zlib-flush-flags.test.js
+++ /dev/null
@@ -1,56 +0,0 @@
-//#FILE: test-zlib-flush-flags.js
-//#SHA1: 9fb4201163deb1a6dc1f74c5c7a2723ec1a9d342
-//-----------------
-"use strict";
-
-const zlib = require("zlib");
-
-test("createGzip with valid flush option", () => {
-  expect(() => zlib.createGzip({ flush: zlib.constants.Z_SYNC_FLUSH })).not.toThrow();
-});
-
-test("createGzip with invalid flush option type", () => {
-  expect(() => zlib.createGzip({ flush: "foobar" })).toThrow(
-    expect.objectContaining({
-      code: "ERR_INVALID_ARG_TYPE",
-      name: "TypeError",
-      message: expect.any(String),
-    }),
-  );
-});
-
-test("createGzip with out of range flush option", () => {
-  expect(() => zlib.createGzip({ flush: 10000 })).toThrow(
-    expect.objectContaining({
-      code: "ERR_OUT_OF_RANGE",
-      name: "RangeError",
-      message: expect.any(String),
-    }),
-  );
-});
-
-test("createGzip with valid finishFlush option", () => {
-  expect(() => zlib.createGzip({ finishFlush: zlib.constants.Z_SYNC_FLUSH })).not.toThrow();
-});
-
-test("createGzip with invalid finishFlush option type", () => {
-  expect(() => zlib.createGzip({ finishFlush: "foobar" })).toThrow(
-    expect.objectContaining({
-      code: "ERR_INVALID_ARG_TYPE",
-      name: "TypeError",
-      message: expect.any(String),
-    }),
-  );
-});
-
-test("createGzip with out of range finishFlush option", () => {
-  expect(() => zlib.createGzip({ finishFlush: 10000 })).toThrow(
-    expect.objectContaining({
-      code: "ERR_OUT_OF_RANGE",
-      name: "RangeError",
-      message: expect.any(String),
-    }),
-  );
-});
-
-//<#END_FILE: test-zlib-flush-flags.js
diff --git a/test/js/node/test/parallel/zlib-from-concatenated-gzip.test.js b/test/js/node/test/parallel/zlib-from-concatenated-gzip.test.js
deleted file mode 100644
index 1961f9e215..0000000000
--- a/test/js/node/test/parallel/zlib-from-concatenated-gzip.test.js
+++ /dev/null
@@ -1,99 +0,0 @@
-//#FILE: test-zlib-from-concatenated-gzip.js
-//#SHA1: cf8f45097fb201dc583ee154b34585b6a0a0dc34
-//-----------------
-"use strict";
-// Test unzipping a gzip file that contains multiple concatenated "members"
-
-const zlib = require("zlib");
-const fs = require("fs");
-const path = require("path");
-
-const abc = "abc";
-const def = "def";
-
-const abcEncoded = zlib.gzipSync(abc);
-const defEncoded = zlib.gzipSync(def);
-
-const data = Buffer.concat([abcEncoded, defEncoded]);
-
-test("gunzipSync concatenated gzip members", () => {
-  expect(zlib.gunzipSync(data).toString()).toBe(abc + def);
-});
-
-test("gunzip concatenated gzip members", async () => {
-  const result = await new Promise((resolve, reject) => {
-    zlib.gunzip(data, (err, result) => {
-      if (err) reject(err);
-      else resolve(result);
-    });
-  });
-  expect(result.toString()).toBe(abc + def);
-});
-
-test("unzip concatenated gzip members", async () => {
-  const result = await new Promise((resolve, reject) => {
-    zlib.unzip(data, (err, result) => {
-      if (err) reject(err);
-      else resolve(result);
-    });
-  });
-  expect(result.toString()).toBe(abc + def);
-});
-
-test("unzip concatenated deflate members", async () => {
-  const result = await new Promise((resolve, reject) => {
-    zlib.unzip(Buffer.concat([zlib.deflateSync("abc"), zlib.deflateSync("def")]), (err, result) => {
-      if (err) reject(err);
-      else resolve(result);
-    });
-  });
-  expect(result.toString()).toBe(abc);
-});
-
-test("pseudo-multimember gzip file", async () => {
-  const pmmFileZlib = path.join(__dirname, "../fixtures/pseudo-multimember-gzip.z");
-  const pmmFileGz = path.join(__dirname, "../fixtures/pseudo-multimember-gzip.gz");
-
-  const pmmExpected = zlib.inflateSync(fs.readFileSync(pmmFileZlib));
-  const pmmResultBuffers = [];
-
-  await new Promise((resolve, reject) => {
-    fs.createReadStream(pmmFileGz)
-      .pipe(zlib.createGunzip())
-      .on("error", reject)
-      .on("data", data => pmmResultBuffers.push(data))
-      .on("finish", resolve);
-  });
-
-  // Result should match original random garbage
-  expect(Buffer.concat(pmmResultBuffers)).toEqual(pmmExpected);
-});
-
-test("gzip member wrapping around input buffer boundary", async () => {
-  const offsets = [0, 1, 2, 3, 4, defEncoded.length];
-
-  for (const offset of offsets) {
-    const resultBuffers = [];
-
-    await new Promise((resolve, reject) => {
-      const unzip = zlib
-        .createGunzip()
-        .on("error", reject)
-        .on("data", data => resultBuffers.push(data))
-        .on("finish", resolve);
-
-      // First write: write "abc" + the first bytes of "def"
-      unzip.write(Buffer.concat([abcEncoded, defEncoded.slice(0, offset)]));
-
-      // Write remaining bytes of "def"
-      unzip.end(defEncoded.slice(offset));
-    });
-
-    expect(Buffer.concat(resultBuffers).toString()).toBe(
-      "abcdef",
-      `result should match original input (offset = ${offset})`,
-    );
-  }
-});
-
-//<#END_FILE: test-zlib-from-concatenated-gzip.js
diff --git a/test/js/node/test/parallel/zlib-from-string.test.js b/test/js/node/test/parallel/zlib-from-string.test.js
deleted file mode 100644
index a9b8900d7f..0000000000
--- a/test/js/node/test/parallel/zlib-from-string.test.js
+++ /dev/null
@@ -1,121 +0,0 @@
-//#FILE: test-zlib-from-string.js
-//#SHA1: 0514669607bbf01e20f41875fa716660ebfcf28b
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-// Test compressing and uncompressing a string with zlib
-
-const zlib = require("zlib");
-
-const inputString =
-  "ΩΩLorem ipsum dolor sit amet, consectetur adipiscing eli" +
-  "t. Morbi faucibus, purus at gravida dictum, libero arcu " +
-  "convallis lacus, in commodo libero metus eu nisi. Nullam" +
-  " commodo, neque nec porta placerat, nisi est fermentum a" +
-  "ugue, vitae gravida tellus sapien sit amet tellus. Aenea" +
-  "n non diam orci. Proin quis elit turpis. Suspendisse non" +
-  " diam ipsum. Suspendisse nec ullamcorper odio. Vestibulu" +
-  "m arcu mi, sodales non suscipit id, ultrices ut massa. S" +
-  "ed ac sem sit amet arcu malesuada fermentum. Nunc sed. ";
-const expectedBase64Deflate =
-  "eJxdUUtOQzEMvMoc4OndgT0gJCT2buJWlpI4jePeqZfpmX" +
-  "AKLRKbLOzx/HK73q6vOrhCunlF1qIDJhNUeW5I2ozT5OkD" +
-  "lKWLJWkncJG5403HQXAkT3Jw29B9uIEmToMukglZ0vS6oc" +
-  "iBh4JG8sV4oVLEUCitK2kxq1WzPnChHDzsaGKy491LofoA" +
-  "bWh8do43oeuYhB5EPCjcLjzYJo48KrfQBvnJecNFJvHT1+" +
-  "RSQsGoC7dn2t/xjhduTA1NWyQIZR0pbHwMDatnD+crPqKS" +
-  "qGPHp1vnlsWM/07ubf7bheF7kqSj84Bm0R1fYTfaK8vqqq" +
-  "fKBtNMhe3OZh6N95CTvMX5HJJi4xOVzCgUOIMSLH7wmeOH" +
-  "aFE4RdpnGavKtrB5xzfO/Ll9";
-const expectedBase64Gzip =
-  "H4sIAAAAAAAAA11RS05DMQy8yhzg6d2BPSAkJPZu4laWkjiN4" +
-  "96pl+mZcAotEpss7PH8crverq86uEK6eUXWogMmE1R5bkjajN" +
-  "Pk6QOUpYslaSdwkbnjTcdBcCRPcnDb0H24gSZOgy6SCVnS9Lq" +
-  "hyIGHgkbyxXihUsRQKK0raTGrVbM+cKEcPOxoYrLj3Uuh+gBt" +
-  "aHx2jjeh65iEHkQ8KNwuPNgmjjwqt9AG+cl5w0Um8dPX5FJCw" +
-  "agLt2fa3/GOF25MDU1bJAhlHSlsfAwNq2cP5ys+opKoY8enW+" +
-  "eWxYz/Tu5t/tuF4XuSpKPzgGbRHV9hN9ory+qqp8oG00yF7c5" +
-  "mHo33kJO8xfkckmLjE5XMKBQ4gxIsfvCZ44doUThF2mcZq8q2" +
-  "sHnHNzRtagj5AQAA";
-
-test("deflate and inflate", async () => {
-  const buffer = await new Promise((resolve, reject) => {
-    zlib.deflate(inputString, (err, buffer) => {
-      if (err) reject(err);
-      else resolve(buffer);
-    });
-  });
-
-  const inflated = await new Promise((resolve, reject) => {
-    zlib.inflate(buffer, (err, inflated) => {
-      if (err) reject(err);
-      else resolve(inflated);
-    });
-  });
-
-  expect(inflated.toString()).toBe(inputString);
-});
-
-test("gzip and gunzip", async () => {
-  const buffer = await new Promise((resolve, reject) => {
-    zlib.gzip(inputString, (err, buffer) => {
-      if (err) reject(err);
-      else resolve(buffer);
-    });
-  });
-
-  const gunzipped = await new Promise((resolve, reject) => {
-    zlib.gunzip(buffer, (err, gunzipped) => {
-      if (err) reject(err);
-      else resolve(gunzipped);
-    });
-  });
-
-  expect(gunzipped.toString()).toBe(inputString);
-});
-
-test("unzip base64 deflate", async () => {
-  const buffer = Buffer.from(expectedBase64Deflate, "base64");
-  const unzipped = await new Promise((resolve, reject) => {
-    zlib.unzip(buffer, (err, unzipped) => {
-      if (err) reject(err);
-      else resolve(unzipped);
-    });
-  });
-
-  expect(unzipped.toString()).toBe(inputString);
-});
-
-test("unzip base64 gzip", async () => {
-  const buffer = Buffer.from(expectedBase64Gzip, "base64");
-  const unzipped = await new Promise((resolve, reject) => {
-    zlib.unzip(buffer, (err, unzipped) => {
-      if (err) reject(err);
-      else resolve(unzipped);
-    });
-  });
-
-  expect(unzipped.toString()).toBe(inputString);
-});
-
-//<#END_FILE: test-zlib-from-string.js
diff --git a/test/js/node/test/parallel/zlib-invalid-arg-value-brotli-compress.test.js b/test/js/node/test/parallel/zlib-invalid-arg-value-brotli-compress.test.js
deleted file mode 100644
index 4fbb56f1a0..0000000000
--- a/test/js/node/test/parallel/zlib-invalid-arg-value-brotli-compress.test.js
+++ /dev/null
@@ -1,27 +0,0 @@
-//#FILE: test-zlib-invalid-arg-value-brotli-compress.js
-//#SHA1: fab88f892e21351603b5ae7227837d01149bdae6
-//-----------------
-"use strict";
-
-// This test ensures that the BrotliCompress function throws
-// ERR_INVALID_ARG_TYPE when the values of the `params` key-value object are
-// neither numbers nor booleans.
-
-const { BrotliCompress, constants } = require("zlib");
-
-test("BrotliCompress throws ERR_INVALID_ARG_TYPE for invalid params value", () => {
-  const opts = {
-    params: {
-      [constants.BROTLI_PARAM_MODE]: "lol",
-    },
-  };
-
-  expect(() => BrotliCompress(opts)).toThrow(
-    expect.objectContaining({
-      code: "ERR_INVALID_ARG_TYPE",
-      message: expect.any(String),
-    }),
-  );
-});
-
-//<#END_FILE: test-zlib-invalid-arg-value-brotli-compress.js
diff --git a/test/js/node/test/parallel/zlib-no-stream.test.js b/test/js/node/test/parallel/zlib-no-stream.test.js
deleted file mode 100644
index 871f4686a2..0000000000
--- a/test/js/node/test/parallel/zlib-no-stream.test.js
+++ /dev/null
@@ -1,21 +0,0 @@
-//#FILE: test-zlib-no-stream.js
-//#SHA1: 5755924e9363a20243c326747623e8e266f81625
-//-----------------
-/* eslint-disable node-core/required-modules */
-/* eslint-disable node-core/require-common-first */
-
-"use strict";
-
-// We are not loading common because it will load the stream module,
-// defeating the purpose of this test.
-
-const { gzipSync } = require("zlib");
-
-// Avoid regressions such as https://github.com/nodejs/node/issues/36615
-
-test("gzipSync should not throw", () => {
-  // This must not throw
-  expect(() => gzipSync("fooobar")).not.toThrow();
-});
-
-//<#END_FILE: test-zlib-no-stream.js
diff --git a/test/js/node/test/parallel/zlib-not-string-or-buffer.test.js b/test/js/node/test/parallel/zlib-not-string-or-buffer.test.js
deleted file mode 100644
index 5353bea54f..0000000000
--- a/test/js/node/test/parallel/zlib-not-string-or-buffer.test.js
+++ /dev/null
@@ -1,27 +0,0 @@
-//#FILE: test-zlib-not-string-or-buffer.js
-//#SHA1: d07db97d9393df2ab9453800ae80f2921d93b6e2
-//-----------------
-"use strict";
-
-// Check the error condition testing for passing something other than a string
-// or buffer.
-
-const zlib = require("zlib");
-
-test("zlib.deflateSync throws for invalid input types", () => {
-  const invalidInputs = [undefined, null, true, false, 0, 1, [1, 2, 3], { foo: "bar" }];
-
-  invalidInputs.forEach(input => {
-    expect(() => zlib.deflateSync(input)).toThrow(
-      expect.objectContaining({
-        code: "ERR_INVALID_ARG_TYPE",
-        name: "TypeError",
-        message: expect.stringContaining(
-          'The "buffer" argument must be of type string or an instance of Buffer, TypedArray, DataView, or ArrayBuffer.',
-        ),
-      }),
-    );
-  });
-});
-
-//<#END_FILE: test-zlib-not-string-or-buffer.js
diff --git a/test/js/node/test/parallel/zlib-object-write.test.js b/test/js/node/test/parallel/zlib-object-write.test.js
deleted file mode 100644
index 63934f60b2..0000000000
--- a/test/js/node/test/parallel/zlib-object-write.test.js
+++ /dev/null
@@ -1,28 +0,0 @@
-//#FILE: test-zlib-object-write.js
-//#SHA1: 8866194c1a944026a655101d66189f364b414ad7
-//-----------------
-"use strict";
-
-const { Gunzip } = require("zlib");
-
-test("Gunzip in object mode throws on non-buffer write", () => {
-  const gunzip = new Gunzip({ objectMode: true });
-
-  // We use jest.fn() to create a mock function that we expect not to be called
-  const errorHandler = jest.fn();
-  gunzip.on("error", errorHandler);
-
-  expect(() => {
-    gunzip.write({});
-  }).toThrow(
-    expect.objectContaining({
-      name: "TypeError",
-      code: "ERR_INVALID_ARG_TYPE",
-    }),
-  );
-
-  // Verify that the error handler was not called
-  expect(errorHandler).not.toHaveBeenCalled();
-});
-
-//<#END_FILE: test-zlib-object-write.js
diff --git a/test/js/node/test/parallel/zlib-random-byte-pipes.test.js b/test/js/node/test/parallel/zlib-random-byte-pipes.test.js
deleted file mode 100644
index fb37cf53f9..0000000000
--- a/test/js/node/test/parallel/zlib-random-byte-pipes.test.js
+++ /dev/null
@@ -1,166 +0,0 @@
-//#FILE: test-zlib-random-byte-pipes.js
-//#SHA1: ef7e7d3683660b911f9e24a6f40947a47be3dbba
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-
-const crypto = require("crypto");
-const stream = require("stream");
-const zlib = require("zlib");
-
-const Stream = stream.Stream;
-
-// Emit random bytes, and keep a shasum
-class RandomReadStream extends Stream {
-  constructor(opt) {
-    super();
-
-    this.readable = true;
-    this._paused = false;
-    this._processing = false;
-
-    this._hasher = crypto.createHash("sha1");
-    opt = opt || {};
-
-    // base block size.
-    opt.block = opt.block || 256 * 1024;
-
-    // Total number of bytes to emit
-    opt.total = opt.total || 256 * 1024 * 1024;
-    this._remaining = opt.total;
-
-    // How variable to make the block sizes
-    opt.jitter = opt.jitter || 1024;
-
-    this._opt = opt;
-
-    this._process = this._process.bind(this);
-
-    process.nextTick(this._process);
-  }
-
-  pause() {
-    this._paused = true;
-    this.emit("pause");
-  }
-
-  resume() {
-    // console.error("rrs resume");
-    this._paused = false;
-    this.emit("resume");
-    this._process();
-  }
-
-  _process() {
-    if (this._processing) return;
-    if (this._paused) return;
-
-    this._processing = true;
-
-    if (!this._remaining) {
-      this._hash = this._hasher.digest("hex").toLowerCase().trim();
-      this._processing = false;
-
-      this.emit("end");
-      return;
-    }
-
-    // Figure out how many bytes to output
-    // if finished, then just emit end.
-    let block = this._opt.block;
-    const jitter = this._opt.jitter;
-    if (jitter) {
-      block += Math.ceil(Math.random() * jitter - jitter / 2);
-    }
-    block = Math.min(block, this._remaining);
-    const buf = Buffer.allocUnsafe(block);
-    for (let i = 0; i < block; i++) {
-      buf[i] = Math.random() * 256;
-    }
-
-    this._hasher.update(buf);
-
-    this._remaining -= block;
-
-    this._processing = false;
-
-    this.emit("data", buf);
-    process.nextTick(this._process);
-  }
-}
-
-// A filter that just verifies a shasum
-class HashStream extends Stream {
-  constructor() {
-    super();
-    this.readable = this.writable = true;
-    this._hasher = crypto.createHash("sha1");
-  }
-
-  write(c) {
-    // Simulate the way that an fs.ReadStream returns false
-    // on *every* write, only to resume a moment later.
-    this._hasher.update(c);
-    process.nextTick(() => this.resume());
-    return false;
-  }
-
-  resume() {
-    this.emit("resume");
-    process.nextTick(() => this.emit("drain"));
-  }
-
-  end(c) {
-    if (c) {
-      this.write(c);
-    }
-    this._hash = this._hasher.digest("hex").toLowerCase().trim();
-    this.emit("data", this._hash);
-    this.emit("end");
-  }
-}
-
-test("zlib random byte pipes", async () => {
-  const compressionMethods = [
-    [zlib.createGzip, zlib.createGunzip],
-    [zlib.createBrotliCompress, zlib.createBrotliDecompress],
-  ];
-
-  for (const [createCompress, createDecompress] of compressionMethods) {
-    const inp = new RandomReadStream({ total: 1024, block: 256, jitter: 16 });
-    const out = new HashStream();
-    const gzip = createCompress();
-    const gunz = createDecompress();
-
-    inp.pipe(gzip).pipe(gunz).pipe(out);
-
-    await new Promise(resolve => {
-      out.on("data", c => {
-        expect(c).toBe(inp._hash);
-        resolve();
-      });
-    });
-  }
-});
-
-//<#END_FILE: test-zlib-random-byte-pipes.js
diff --git a/test/js/node/test/parallel/zlib-sync-no-event.test.js b/test/js/node/test/parallel/zlib-sync-no-event.test.js
deleted file mode 100644
index 9e821acfe9..0000000000
--- a/test/js/node/test/parallel/zlib-sync-no-event.test.js
+++ /dev/null
@@ -1,39 +0,0 @@
-//#FILE: test-zlib-sync-no-event.js
-//#SHA1: 382796f607eb25a85aa067e0dbc3d5103d321def
-//-----------------
-"use strict";
-const zlib = require("zlib");
-
-const message = "Come on, Fhqwhgads.";
-const buffer = Buffer.from(message);
-
-test("zlib sync compression and decompression without events", () => {
-  const zipper = new zlib.Gzip();
-  const closeSpy = jest.fn();
-  zipper.on("close", closeSpy);
-
-  const zipped = zipper._processChunk(buffer, zlib.constants.Z_FINISH);
-
-  const unzipper = new zlib.Gunzip();
-  const unzipperCloseSpy = jest.fn();
-  unzipper.on("close", unzipperCloseSpy);
-
-  const unzipped = unzipper._processChunk(zipped, zlib.constants.Z_FINISH);
-
-  expect(zipped).toEqual(
-    // prettier-ignore
-    Buffer.from([ 31, 139, 8, 0, 0, 0, 0, 0, 0, osbyte(), 115, 206, 207, 77, 85, 200, 207, 211, 81, 112, 203, 40, 44, 207, 72, 79, 76, 41, 214, 3, 0, 160, 120, 128, 220, 19, 0, 0, 0 ]),
-  );
-  expect(unzipped.toString()).toEqual(message);
-
-  expect(closeSpy).not.toHaveBeenCalled();
-  expect(unzipperCloseSpy).not.toHaveBeenCalled();
-});
-
-//<#END_FILE: test-zlib-sync-no-event.js
-
-function osbyte() {
-  if (process.platform === "darwin") return 19;
-  if (process.platform === "linux") return 3;
-  if (process.platform === "win32") return 10;
-}
diff --git a/test/js/node/test/parallel/zlib-truncated.test.js b/test/js/node/test/parallel/zlib-truncated.test.js
deleted file mode 100644
index 703ce49c04..0000000000
--- a/test/js/node/test/parallel/zlib-truncated.test.js
+++ /dev/null
@@ -1,99 +0,0 @@
-//#FILE: test-zlib-truncated.js
-//#SHA1: 79f9bcf3c52b3d0736ebe457652d579a856d1f7b
-//-----------------
-"use strict";
-// Tests zlib streams with truncated compressed input
-
-const zlib = require("zlib");
-
-const inputString =
-  "ΩΩLorem ipsum dolor sit amet, consectetur adipiscing eli" +
-  "t. Morbi faucibus, purus at gravida dictum, libero arcu " +
-  "convallis lacus, in commodo libero metus eu nisi. Nullam" +
-  " commodo, neque nec porta placerat, nisi est fermentum a" +
-  "ugue, vitae gravida tellus sapien sit amet tellus. Aenea" +
-  "n non diam orci. Proin quis elit turpis. Suspendisse non" +
-  " diam ipsum. Suspendisse nec ullamcorper odio. Vestibulu" +
-  "m arcu mi, sodales non suscipit id, ultrices ut massa. S" +
-  "ed ac sem sit amet arcu malesuada fermentum. Nunc sed. ";
-
-const errMessage = /unexpected end of file/;
-
-const methods = [
-  { comp: "gzip", decomp: "gunzip", decompSync: "gunzipSync" },
-  { comp: "gzip", decomp: "unzip", decompSync: "unzipSync" },
-  { comp: "deflate", decomp: "inflate", decompSync: "inflateSync" },
-  { comp: "deflateRaw", decomp: "inflateRaw", decompSync: "inflateRawSync" },
-];
-
-methods.forEach(({ comp, decomp, decompSync }) => {
-  test(`Test ${comp} and ${decomp}`, async () => {
-    const compressed = await new Promise((resolve, reject) => {
-      zlib[comp](inputString, (err, result) => {
-        if (err) reject(err);
-        else resolve(result);
-      });
-    });
-
-    const truncated = compressed.slice(0, compressed.length / 2);
-    const toUTF8 = buffer => buffer.toString("utf-8");
-
-    // sync sanity
-    const decompressed = zlib[decompSync](compressed);
-    expect(toUTF8(decompressed)).toBe(inputString);
-
-    // async sanity
-    await new Promise((resolve, reject) => {
-      zlib[decomp](compressed, (err, result) => {
-        if (err) reject(err);
-        else {
-          expect(toUTF8(result)).toBe(inputString);
-          resolve();
-        }
-      });
-    });
-
-    // Sync truncated input test
-    expect(() => {
-      zlib[decompSync](truncated);
-    }).toThrow(
-      expect.objectContaining({
-        message: expect.stringMatching(errMessage),
-      }),
-    );
-
-    // Async truncated input test
-    await expect(
-      new Promise((resolve, reject) => {
-        zlib[decomp](truncated, err => {
-          if (err) reject(err);
-          else resolve();
-        });
-      }),
-    ).rejects.toThrow(
-      expect.objectContaining({
-        message: expect.stringMatching(errMessage),
-      }),
-    );
-
-    const syncFlushOpt = { finishFlush: zlib.constants.Z_SYNC_FLUSH };
-
-    // Sync truncated input test, finishFlush = Z_SYNC_FLUSH
-    const result = toUTF8(zlib[decompSync](truncated, syncFlushOpt));
-    expect(result).toBe(inputString.slice(0, result.length));
-
-    // Async truncated input test, finishFlush = Z_SYNC_FLUSH
-    await new Promise((resolve, reject) => {
-      zlib[decomp](truncated, syncFlushOpt, (err, decompressed) => {
-        if (err) reject(err);
-        else {
-          const result = toUTF8(decompressed);
-          expect(result).toBe(inputString.slice(0, result.length));
-          resolve();
-        }
-      });
-    });
-  });
-});
-
-//<#END_FILE: test-zlib-truncated.js
diff --git a/test/js/node/test/parallel/zlib-unzip-one-byte-chunks.test.js b/test/js/node/test/parallel/zlib-unzip-one-byte-chunks.test.js
deleted file mode 100644
index f4fa2a0795..0000000000
--- a/test/js/node/test/parallel/zlib-unzip-one-byte-chunks.test.js
+++ /dev/null
@@ -1,32 +0,0 @@
-//#FILE: test-zlib-unzip-one-byte-chunks.js
-//#SHA1: 3c242140501ae0e8e9277c68696c231a04070018
-//-----------------
-"use strict";
-const zlib = require("zlib");
-
-test("zlib unzip one byte chunks", done => {
-  const data = Buffer.concat([zlib.gzipSync("abc"), zlib.gzipSync("def")]);
-
-  const resultBuffers = [];
-
-  const unzip = zlib
-    .createUnzip()
-    .on("error", err => {
-      expect(err).toBeFalsy();
-    })
-    .on("data", data => resultBuffers.push(data))
-    .on("finish", () => {
-      const unzipped = Buffer.concat(resultBuffers).toString();
-      expect(unzipped).toBe("abcdef");
-      done();
-    });
-
-  for (let i = 0; i < data.length; i++) {
-    // Write each single byte individually.
-    unzip.write(Buffer.from([data[i]]));
-  }
-
-  unzip.end();
-});
-
-//<#END_FILE: test-zlib-unzip-one-byte-chunks.js
diff --git a/test/js/node/test/parallel/zlib-write-after-end.test.js b/test/js/node/test/parallel/zlib-write-after-end.test.js
deleted file mode 100644
index c4e0586e65..0000000000
--- a/test/js/node/test/parallel/zlib-write-after-end.test.js
+++ /dev/null
@@ -1,29 +0,0 @@
-//#FILE: test-zlib-write-after-end.js
-//#SHA1: 0d11ed6c9992b52c81a45bdb3d6fe0db4ab2681a
-//-----------------
-"use strict";
-const zlib = require("zlib");
-
-// Regression test for https://github.com/nodejs/node/issues/30976
-// Writes to a stream should finish even after the readable side has been ended.
-
-test("zlib write after end", done => {
-  const data = zlib.deflateRawSync("Welcome");
-
-  const inflate = zlib.createInflateRaw();
-
-  inflate.resume();
-
-  const writeCallback = jest.fn();
-
-  inflate.write(data, writeCallback);
-  inflate.write(Buffer.from([0x00]), writeCallback);
-  inflate.write(Buffer.from([0x00]), writeCallback);
-
-  inflate.flush(() => {
-    expect(writeCallback).toHaveBeenCalledTimes(3);
-    done();
-  });
-});
-
-//<#END_FILE: test-zlib-write-after-end.js
diff --git a/test/js/node/test/parallel/zlib-write-after-flush.test.js b/test/js/node/test/parallel/zlib-write-after-flush.test.js
deleted file mode 100644
index 3bdcfb8d4f..0000000000
--- a/test/js/node/test/parallel/zlib-write-after-flush.test.js
+++ /dev/null
@@ -1,57 +0,0 @@
-//#FILE: test-zlib-write-after-flush.js
-//#SHA1: 2cd2c91ba7a105560cdf6831ece0e95174aac860
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const zlib = require("zlib");
-
-const compressionMethods = [
-  [zlib.createGzip, zlib.createGunzip],
-  [zlib.createBrotliCompress, zlib.createBrotliDecompress],
-];
-
-compressionMethods.forEach(([createCompress, createDecompress]) => {
-  test(`${createCompress.name} and ${createDecompress.name}`, done => {
-    const gzip = createCompress();
-    const gunz = createDecompress();
-
-    gzip.pipe(gunz);
-
-    let output = "";
-    const input = "A line of data\n";
-    gunz.setEncoding("utf8");
-    gunz.on("data", c => (output += c));
-    gunz.on("end", () => {
-      expect(output).toBe(input);
-      done();
-    });
-
-    // Make sure that flush/write doesn't trigger an assert failure
-    gzip.flush();
-    gzip.write(input);
-    gzip.end();
-    gunz.read(0);
-  });
-});
-
-//<#END_FILE: test-zlib-write-after-flush.js
diff --git a/test/js/node/test/parallel/zlib-zero-byte.test.js b/test/js/node/test/parallel/zlib-zero-byte.test.js
deleted file mode 100644
index 762ee875f2..0000000000
--- a/test/js/node/test/parallel/zlib-zero-byte.test.js
+++ /dev/null
@@ -1,56 +0,0 @@
-//#FILE: test-zlib-zero-byte.js
-//#SHA1: 54539c28619fb98230547ba0929ddad146f15bc5
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const zlib = require("zlib");
-
-for (const Compressor of [zlib.Gzip, zlib.BrotliCompress]) {
-  test(`${Compressor.name} compresses zero-byte input`, async () => {
-    const gz = Compressor();
-    const emptyBuffer = Buffer.alloc(0);
-    let received = 0;
-
-    gz.on("data", c => {
-      received += c.length;
-    });
-
-    const endPromise = new Promise(resolve => {
-      gz.on("end", resolve);
-    });
-
-    const finishPromise = new Promise(resolve => {
-      gz.on("finish", resolve);
-    });
-
-    gz.write(emptyBuffer);
-    gz.end();
-
-    await Promise.all([endPromise, finishPromise]);
-
-    const expected = Compressor === zlib.Gzip ? 20 : 1;
-    expect(received).toBe(expected);
-  });
-}
-
-//<#END_FILE: test-zlib-zero-byte.js
diff --git a/test/js/node/test/parallel/zlib-zero-windowbits.test.js b/test/js/node/test/parallel/zlib-zero-windowbits.test.js
deleted file mode 100644
index 32f4225a30..0000000000
--- a/test/js/node/test/parallel/zlib-zero-windowbits.test.js
+++ /dev/null
@@ -1,32 +0,0 @@
-//#FILE: test-zlib-zero-windowBits.js
-//#SHA1: 3f1f031d2f5ab37f2ea2a963d6de0e2ececa9d33
-//-----------------
-"use strict";
-
-const zlib = require("zlib");
-
-// windowBits is a special case in zlib. On the compression side, 0 is invalid.
-// On the decompression side, it indicates that zlib should use the value from
-// the header of the compressed stream.
-test("windowBits 0 for decompression", () => {
-  const inflate = zlib.createInflate({ windowBits: 0 });
-  expect(inflate).toBeInstanceOf(zlib.Inflate);
-
-  const gunzip = zlib.createGunzip({ windowBits: 0 });
-  expect(gunzip).toBeInstanceOf(zlib.Gunzip);
-
-  const unzip = zlib.createUnzip({ windowBits: 0 });
-  expect(unzip).toBeInstanceOf(zlib.Unzip);
-});
-
-test("windowBits 0 for compression throws error", () => {
-  expect(() => zlib.createGzip({ windowBits: 0 })).toThrow(
-    expect.objectContaining({
-      code: "ERR_OUT_OF_RANGE",
-      name: "RangeError",
-      message: expect.any(String),
-    }),
-  );
-});
-
-//<#END_FILE: test-zlib-zero-windowBits.js
diff --git a/test/js/node/test/parallel/zlib.test.js b/test/js/node/test/parallel/zlib.test.js
deleted file mode 100644
index d6b27408a1..0000000000
--- a/test/js/node/test/parallel/zlib.test.js
+++ /dev/null
@@ -1,233 +0,0 @@
-//#FILE: test-zlib.js
-//#SHA1: 0e67da3898d627175ffca51fdbd1042571d0c405
-//-----------------
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"use strict";
-const zlib = require("zlib");
-const stream = require("stream");
-const fs = require("fs");
-const path = require("path");
-
-const fixturesPath = path.join(__dirname, "..", "fixtures");
-
-// Should not segfault.
-test("gzipSync with invalid windowBits", () => {
-  expect(() => zlib.gzipSync(Buffer.alloc(0), { windowBits: 8 })).toThrow(
-    expect.objectContaining({
-      code: "ERR_OUT_OF_RANGE",
-      name: "RangeError",
-    }),
-  );
-});
-
-let zlibPairs = [
-  [zlib.Deflate, zlib.Inflate],
-  [zlib.Gzip, zlib.Gunzip],
-  [zlib.Deflate, zlib.Unzip],
-  [zlib.Gzip, zlib.Unzip],
-  [zlib.DeflateRaw, zlib.InflateRaw],
-  [zlib.BrotliCompress, zlib.BrotliDecompress],
-];
-
-// How fast to trickle through the slowstream
-let trickle = [128, 1024, 1024 * 1024];
-
-// Tunable options for zlib classes.
-
-// several different chunk sizes
-let chunkSize = [128, 1024, 1024 * 16, 1024 * 1024];
-
-// This is every possible value.
-let level = [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
-let windowBits = [8, 9, 10, 11, 12, 13, 14, 15];
-let memLevel = [1, 2, 3, 4, 5, 6, 7, 8, 9];
-let strategy = [0, 1, 2, 3, 4];
-
-// It's nice in theory to test every combination, but it
-// takes WAY too long.  Maybe a pummel test could do this?
-if (!process.env.PUMMEL) {
-  trickle = [1024];
-  chunkSize = [1024 * 16];
-  level = [6];
-  memLevel = [8];
-  windowBits = [15];
-  strategy = [0];
-}
-
-let testFiles = ["person.jpg", "elipses.txt", "empty.txt"];
-
-if (process.env.FAST) {
-  zlibPairs = [[zlib.Gzip, zlib.Unzip]];
-  testFiles = ["person.jpg"];
-}
-
-const tests = {};
-testFiles.forEach(file => {
-  tests[file] = fs.readFileSync(path.join(fixturesPath, file));
-});
-
-// Stream that saves everything
-class BufferStream extends stream.Stream {
-  constructor() {
-    super();
-    this.chunks = [];
-    this.length = 0;
-    this.writable = true;
-    this.readable = true;
-  }
-
-  write(c) {
-    this.chunks.push(c);
-    this.length += c.length;
-    return true;
-  }
-
-  end(c) {
-    if (c) this.write(c);
-    // flatten
-    const buf = Buffer.allocUnsafe(this.length);
-    let i = 0;
-    this.chunks.forEach(c => {
-      c.copy(buf, i);
-      i += c.length;
-    });
-    this.emit("data", buf);
-    this.emit("end");
-    return true;
-  }
-}
-
-class SlowStream extends stream.Stream {
-  constructor(trickle) {
-    super();
-    this.trickle = trickle;
-    this.offset = 0;
-    this.readable = this.writable = true;
-  }
-
-  write() {
-    throw new Error("not implemented, just call ss.end(chunk)");
-  }
-
-  pause() {
-    this.paused = true;
-    this.emit("pause");
-  }
-
-  resume() {
-    const emit = () => {
-      if (this.paused) return;
-      if (this.offset >= this.length) {
-        this.ended = true;
-        return this.emit("end");
-      }
-      const end = Math.min(this.offset + this.trickle, this.length);
-      const c = this.chunk.slice(this.offset, end);
-      this.offset += c.length;
-      this.emit("data", c);
-      process.nextTick(emit);
-    };
-
-    if (this.ended) return;
-    this.emit("resume");
-    if (!this.chunk) return;
-    this.paused = false;
-    emit();
-  }
-
-  end(chunk) {
-    // Walk over the chunk in blocks.
-    this.chunk = chunk;
-    this.length = chunk.length;
-    this.resume();
-    return this.ended;
-  }
-}
-
-test("createDeflateRaw with windowBits 8", () => {
-  expect(() => zlib.createDeflateRaw({ windowBits: 8 })).not.toThrow();
-});
-
-test("inflate raw with windowBits 8", async () => {
-  const node = fs.createReadStream(path.join(fixturesPath, "person.jpg"));
-  const raw = [];
-  const reinflated = [];
-
-  await new Promise((resolve, reject) => {
-    node.on("data", chunk => raw.push(chunk));
-
-    node
-      .pipe(zlib.createDeflateRaw({ windowBits: 9 }))
-      .pipe(zlib.createInflateRaw({ windowBits: 8 }))
-      .on("data", chunk => reinflated.push(chunk))
-      .on("end", () => {
-        expect(Buffer.concat(raw)).toEqual(Buffer.concat(reinflated));
-        resolve();
-      })
-      .on("error", reject);
-  });
-});
-
-// For each of the files, make sure that compressing and
-// decompressing results in the same data, for every combination
-// of the options set above.
-
-const testKeys = Object.keys(tests);
-testKeys.forEach(file => {
-  const test = tests[file];
-  chunkSize.forEach(chunkSize => {
-    trickle.forEach(trickle => {
-      windowBits.forEach(windowBits => {
-        level.forEach(level => {
-          memLevel.forEach(memLevel => {
-            strategy.forEach(strategy => {
-              zlibPairs.forEach(pair => {
-                const [Def, Inf] = pair;
-                const opts = { level, windowBits, memLevel, strategy };
-
-                it(`${file} ${chunkSize} ${JSON.stringify(opts)} ${Def.name} -> ${Inf.name}`, done => {
-                  const def = new Def(opts);
-                  const inf = new Inf(opts);
-                  const ss = new SlowStream(trickle);
-                  const buf = new BufferStream();
-
-                  // Verify that the same exact buffer comes out the other end.
-                  buf.on("data", c => {
-                    expect(c).toEqual(test);
-                    done();
-                  });
-
-                  // The magic happens here.
-                  ss.pipe(def).pipe(inf).pipe(buf);
-                  ss.end(test);
-                });
-              });
-            });
-          });
-        });
-      });
-    });
-  });
-});
-
-//<#END_FILE: test-zlib.js
diff --git a/test/js/node/tls/node-tls-connect.test.ts b/test/js/node/tls/node-tls-connect.test.ts
index bb8168e00a..0852df396e 100644
--- a/test/js/node/tls/node-tls-connect.test.ts
+++ b/test/js/node/tls/node-tls-connect.test.ts
@@ -3,8 +3,11 @@ import { tls as COMMON_CERT_ } from "harness";
 import net from "net";
 import { join } from "path";
 import tls, { checkServerIdentity, connect as tlsConnect, TLSSocket } from "tls";
+import stream from "stream";
+import { once } from "events";
 
 import { Duplex } from "node:stream";
+import type { AddressInfo } from "net";
 
 const symbolConnectOptions = Symbol.for("::buntlsconnectoptions::");
 
@@ -117,6 +120,31 @@ it("should have checkServerIdentity", async () => {
   expect(tls.checkServerIdentity).toBeFunction();
 });
 
+it("should thow ECONNRESET if FIN is received before handshake", async () => {
+  await using server = net.createServer(c => {
+    c.end();
+  });
+  await once(server.listen(0, "127.0.0.1"), "listening");
+  const { promise, resolve } = Promise.withResolvers();
+  tls.connect((server.address() as AddressInfo).port).on("error", resolve);
+
+  const error = await promise;
+
+  expect(error).toBeDefined();
+  // TODO: today we are a little incompatible with node.js we need to change `UNABLE_TO_GET_ISSUER_CERT` when closed before handshake complete on the openssl.c to emit error `ECONNRESET` instead of SSL fail,
+  // current behavior is not wrong because is the right error but is incompatible with node.js
+  expect((error as Error).code as string).toBeOneOf(["ECONNRESET", "UNABLE_TO_GET_ISSUER_CERT"]);
+});
+it("should be able to grab the JSStreamSocket constructor", () => {
+  // this keep http2-wrapper compatibility with node.js
+  const socket = new tls.TLSSocket(new stream.PassThrough());
+  //@ts-ignore
+  expect(socket._handle).not.toBeNull();
+  //@ts-ignore
+  expect(socket._handle._parentWrap).not.toBeNull();
+  //@ts-ignore
+  expect(socket._handle._parentWrap.constructor).toBeFunction();
+});
 for (const { name, connect } of tests) {
   describe(name, () => {
     it("should work with alpnProtocols", done => {
diff --git a/test/js/node/tls/node-tls-server.test.ts b/test/js/node/tls/node-tls-server.test.ts
index 6b0b9c393c..2cefec9c40 100644
--- a/test/js/node/tls/node-tls-server.test.ts
+++ b/test/js/node/tls/node-tls-server.test.ts
@@ -6,6 +6,7 @@ import { tmpdir } from "os";
 import { join } from "path";
 import type { PeerCertificate } from "tls";
 import tls, { connect, createServer, rootCertificates, Server, TLSSocket } from "tls";
+import { once } from "node:events";
 
 const { describe, expect, it, createCallCheckCtx } = createTest(import.meta.path);
 
@@ -662,3 +663,44 @@ it("tls.rootCertificates should exists", () => {
   expect(rootCertificates.length).toBeGreaterThan(0);
   expect(typeof rootCertificates[0]).toBe("string");
 });
+
+it("connectionListener should emit the right amount of times, and with alpnProtocol available", async () => {
+  let count = 0;
+  const promises = [];
+  const server: Server = createServer(
+    {
+      ...COMMON_CERT,
+      ALPNProtocols: ["bun"],
+    },
+    socket => {
+      count++;
+      expect(socket.alpnProtocol).toBe("bun");
+      socket.end();
+    },
+  );
+  server.setMaxListeners(100);
+
+  server.listen(0);
+  await once(server, "listening");
+  for (let i = 0; i < 50; i++) {
+    const { promise, resolve } = Promise.withResolvers();
+    promises.push(promise);
+    const socket = connect(
+      {
+        ca: COMMON_CERT.cert,
+        rejectUnauthorized: false,
+        port: server.address().port,
+        host: "127.0.0.1",
+        ALPNProtocols: ["bun"],
+      },
+      () => {
+        socket.on("close", resolve);
+        socket.resume();
+        socket.end();
+      },
+    );
+  }
+
+  await Promise.all(promises);
+  expect(count).toBe(50);
+});
diff --git a/test/js/node/tls/node-tls-upgrade.test.ts b/test/js/node/tls/node-tls-upgrade.test.ts
new file mode 100644
index 0000000000..a48f5c3e77
--- /dev/null
+++ b/test/js/node/tls/node-tls-upgrade.test.ts
@@ -0,0 +1,62 @@
+import net from "net";
+import tls from "tls";
+import { once } from "events";
+import { tls as certs } from "harness";
+import { test, expect } from "bun:test";
+
+test("should be able to upgrade a paused socket and also have backpressure on it #15438", async () => {
+  // enought to trigger backpressure
+  const payload = Buffer.alloc(16 * 1024 * 4, "b").toString("utf8");
+
+  const server = tls.createServer(certs, socket => {
+    // echo
+    socket.on("data", data => {
+      socket.write(data);
+    });
+  });
+
+  await once(server.listen(0, "127.0.0.1"), "listening");
+
+  const socket = net.connect({
+    port: (server.address() as net.AddressInfo).port,
+    host: "127.0.0.1",
+  });
+  await once(socket, "connect");
+
+  // pause raw socket
+  socket.pause();
+
+  const tlsSocket = tls.connect({
+    ca: certs.cert,
+    servername: "localhost",
+    socket,
+  });
+  await once(tlsSocket, "secureConnect");
+
+  // do http request using tls socket
+  async function doWrite(socket: net.Socket) {
+    let downloadedBody = 0;
+    const { promise, resolve, reject } = Promise.withResolvers();
+    function onData(data: Buffer) {
+      downloadedBody += data.byteLength;
+      if (downloadedBody === payload.length * 2) {
+        resolve();
+      }
+    }
+    socket.pause();
+    socket.write(payload);
+    socket.write(payload, () => {
+      socket.on("data", onData);
+      socket.resume();
+    });
+
+    await promise;
+    socket.off("data", onData);
+  }
+  for (let i = 0; i < 100; i++) {
+    // upgrade the tlsSocket
+    await doWrite(tlsSocket);
+  }
+
+  expect().pass();
+});
diff --git a/test/js/node/url/url-fileurltopath.test.js b/test/js/node/url/url-fileurltopath.test.js
index 6e77b1d864..f4cd211a11 100644
--- a/test/js/node/url/url-fileurltopath.test.js
+++ b/test/js/node/url/url-fileurltopath.test.js
@@ -1,9 +1,8 @@
 import { describe, test } from "bun:test";
+import { isWindows } from "harness";
 import assert from "node:assert";
 import url, { URL } from "node:url";
 
-const isWindows = process.platform === "win32";
-
 describe("url.fileURLToPath", () => {
   function testInvalidArgs(...args) {
     for (const arg of args) {
diff --git a/test/js/node/url/url-pathtofileurl.test.js b/test/js/node/url/url-pathtofileurl.test.js
index bdab051b4c..561cb3e3b8 100644
--- a/test/js/node/url/url-pathtofileurl.test.js
+++ b/test/js/node/url/url-pathtofileurl.test.js
@@ -1,9 +1,8 @@
 import { describe, test } from "bun:test";
+import { isWindows } from "harness";
 import assert from "node:assert";
 import url from "node:url";
 
-const isWindows = process.platform === "win32";
-
 describe("url.pathToFileURL", () => {
   // TODO: Fix these asserts on Windows.
   test.skipIf(isWindows)("dangling slashes and percent sign", () => {
diff --git a/test/js/node/util/bun-inspect.test.ts b/test/js/node/util/bun-inspect.test.ts
index 5d6e93b5f2..57151a7b5b 100644
--- a/test/js/node/util/bun-inspect.test.ts
+++ b/test/js/node/util/bun-inspect.test.ts
@@ -1,4 +1,5 @@
 import { describe, expect, it } from "bun:test";
+import stripAnsi from "strip-ansi";
 
 describe("Bun.inspect", () => {
   it("reports error instead of [native code]", () => {
@@ -11,6 +12,37 @@ describe("Bun.inspect", () => {
     ).toBe("[custom formatter threw an exception]");
   });
 
+  it("supports colors: false", () => {
+    const output = Bun.inspect({ a: 1 }, { colors: false });
+    expect(stripAnsi(output)).toBe(output);
+  });
+
+  it("supports colors: true", () => {
+    const output = Bun.inspect({ a: 1 }, { colors: true });
+    expect(stripAnsi(output)).not.toBe(output);
+    expect(stripAnsi(output)).toBe(Bun.inspect({ a: 1 }, { colors: false }));
+  });
+
+  it("supports colors: false, via 2nd arg", () => {
+    const output = Bun.inspect({ a: 1 }, null, null);
+    expect(stripAnsi(output)).toBe(output);
+  });
+
+  it("supports colors: true, via 2nd arg", () => {
+    const output = Bun.inspect({ a: 1 }, true, 2);
+    expect(stripAnsi(output)).not.toBe(output);
+  });
+
+  it("supports compact", () => {
+    expect(Bun.inspect({ a: 1, b: 2 }, { compact: true })).toBe("{ a: 1, b: 2 }");
+    expect(Bun.inspect({ a: 1, b: 2 }, { compact: false })).toBe("{\n  a: 1,\n  b: 2,\n}");
+
+    expect(Bun.inspect({ a: { 0: 1, 1: 2 }, b: 3 }, { compact: true })).toBe('{ a: { "0": 1, "1": 2 }, b: 3 }');
+    expect(Bun.inspect({ a: { 0: 1, 1: 2 }, b: 3 }, { compact: false })).toBe(
+      '{\n  a: {\n    "0": 1,\n    "1": 2,\n  },\n  b: 3,\n}',
+    );
+  });
+
   it("depth < 0 throws", () => {
     expect(() => Bun.inspect({}, { depth: -1 })).toThrow();
     expect(() => Bun.inspect({}, { depth: -13210 })).toThrow();
diff --git a/test/js/node/util/node-inspect-tests/parallel/util-format.test.js b/test/js/node/util/node-inspect-tests/parallel/util-format.test.js
index 1671f192f3..76d485bae8 100644
--- a/test/js/node/util/node-inspect-tests/parallel/util-format.test.js
+++ b/test/js/node/util/node-inspect-tests/parallel/util-format.test.js
@@ -430,6 +430,9 @@ test("no assertion failures", () => {
     }
   }
   const customError = new CustomError("bar");
+  customError.stack;
+  delete customError.originalLine;
+  delete customError.originalColumn;
   assert.strictEqual(util.format(customError), customError.stack.replace(/^Error/, "Custom$&")); //! temp bug workaround
   // Doesn't capture stack trace
   function BadCustomError(msg) {
diff --git a/test/js/node/v8/capture-stack-trace.test.js b/test/js/node/v8/capture-stack-trace.test.js
index a61aa32133..69dcf9307f 100644
--- a/test/js/node/v8/capture-stack-trace.test.js
+++ b/test/js/node/v8/capture-stack-trace.test.js
@@ -1,6 +1,6 @@
 import { nativeFrameForTesting } from "bun:internal-for-testing";
 import { afterEach, expect, test } from "bun:test";
-
+import { noInline } from "bun:jsc";
 const origPrepareStackTrace = Error.prepareStackTrace;
 afterEach(() => {
   Error.prepareStackTrace = origPrepareStackTrace;
@@ -376,18 +376,38 @@ test("sanity check", () => {
   f1();
 });
 
-test("CallFrame.p.getThisgetFunction: works in sloppy mode", () => {
+test("CallFrame isEval works as expected", () => {
+  let prevPrepareStackTrace = Error.prepareStackTrace;
+
+  let name, fn;
+
+  Error.prepareStackTrace = (e, s) => {
+    return s;
+  };
+
+  name = "f1";
+  const stack = eval(`(function ${name}() {
+    return new Error().stack;
+  })()`);
+
+  Error.prepareStackTrace = prevPrepareStackTrace;
+  // TODO: 0 and 1 should both return true here.
+  expect(stack[1].isEval()).toBe(true);
+  expect(stack[0].getFunctionName()).toBe(name);
+});
+
+test("CallFrame isTopLevel returns false for Function constructor", () => {
   let prevPrepareStackTrace = Error.prepareStackTrace;
   const sloppyFn = new Function("let e=new Error();Error.captureStackTrace(e);return e.stack");
   sloppyFn.displayName = "sloppyFnWow";
+  noInline(sloppyFn);
   const that = {};
 
   Error.prepareStackTrace = (e, s) => {
-    expect(s[0].getThis()).toBe(that);
-    expect(s[0].getFunction()).toBe(sloppyFn);
     expect(s[0].getFunctionName()).toBe(sloppyFn.displayName);
+    expect(s[0].getFunction()).toBe(sloppyFn);
+
     expect(s[0].isToplevel()).toBe(false);
-    // TODO: This should be true.
     expect(s[0].isEval()).toBe(false);
 
     // Strict-mode functions shouldn't have getThis or getFunction
@@ -480,7 +500,7 @@ test("CallFrame.p.toString", () => {
 });
 
 // TODO: line numbers are wrong in a release build
-test.todo("err.stack should invoke prepareStackTrace", () => {
+test("err.stack should invoke prepareStackTrace", () => {
   var lineNumber = -1;
   var functionName = "";
   var parentLineNumber = -1;
@@ -503,9 +523,8 @@ test.todo("err.stack should invoke prepareStackTrace", () => {
   functionWithAName();
 
   expect(functionName).toBe("functionWithAName");
-  expect(lineNumber).toBe(391);
-  // TODO: this is wrong
-  expect(parentLineNumber).toBe(394);
+  expect(lineNumber).toBe(518);
+  expect(parentLineNumber).toBe(523);
 });
 
 test("Error.prepareStackTrace inside a node:vm works", () => {
@@ -559,3 +578,122 @@ test("Error.prepareStackTrace returns a CallSite object", () => {
   expect(error.stack[0]).not.toBeString();
   expect(error.stack[0][Symbol.toStringTag]).toBe("CallSite");
 });
+
+test("Error.captureStackTrace updates the stack property each call, even if Error.prepareStackTrace is set", () => {
+  const prevPrepareStackTrace = Error.prepareStackTrace;
+  var didCallPrepareStackTrace = false;
+
+  let error = new Error();
+  const firstStack = error.stack;
+  Error.prepareStackTrace = function (err, stack) {
+    expect(err.stack).not.toBe(firstStack);
+    didCallPrepareStackTrace = true;
+    return stack;
+  };
+  function outer() {
+    inner();
+  }
+  function inner() {
+    Error.captureStackTrace(error);
+  }
+  outer();
+  const secondStack = error.stack;
+  expect(firstStack).not.toBe(secondStack);
+  expect(firstStack).toBeString();
+  expect(firstStack).not.toContain("outer");
+  expect(firstStack).not.toContain("inner");
+  expect(didCallPrepareStackTrace).toBe(true);
+  expect(secondStack.find(a => a.getFunctionName() === "outer")).toBeTruthy();
+  expect(secondStack.find(a => a.getFunctionName() === "inner")).toBeTruthy();
+  Error.prepareStackTrace = prevPrepareStackTrace;
+});
+
+test("Error.captureStackTrace updates the stack property each call", () => {
+  let error = new Error();
+  const firstStack = error.stack;
+  function outer() {
+    inner();
+  }
+  function inner() {
+    Error.captureStackTrace(error);
+  }
+  outer();
+  const secondStack = error.stack;
+  expect(firstStack).not.toBe(secondStack);
+  expect(firstStack.length).toBeLessThan(secondStack.length);
+  expect(firstStack).not.toContain("outer");
+  expect(firstStack).not.toContain("inner");
+  expect(secondStack).toContain("outer");
+  expect(secondStack).toContain("inner");
+});
+
+test("calling .stack later uses the stored StackTrace", function hey() {
+  let error = new Error();
+  let stack;
+  function outer() {
+    inner();
+  }
+  function inner() {
+    stack = error.stack;
+  }
+  outer();
+
+  expect(stack).not.toContain("outer");
+  expect(stack).not.toContain("inner");
+  expect(stack).toContain("hey");
+});
+
+test("calling .stack on a non-materialized Error updates the stack properly", function hey() {
+  let error = new Error();
+  let stack;
+  function outer() {
+    inner();
+  }
+  function inner() {
+    stack = error.stack;
+  }
+  function wrapped() {
+    Error.captureStackTrace(error);
+  }
+  wrapped();
+  outer();
+
+  expect(stack).not.toContain("outer");
+  expect(stack).not.toContain("inner");
+  expect(stack).toContain("hey");
+  expect(stack).toContain("wrapped");
+});
+
+test("Error.prepareStackTrace on an array with non-CallSite objects doesn't crash", () => {
+  const result = Error.prepareStackTrace(new Error("ok"), [{ a: 1 }, { b: 2 }, { c: 3 }]);
+  expect(result).toBe("Error: ok\n    at [object Object]\n    at [object Object]\n    at [object Object]");
+});
+
+test("Error.prepareStackTrace calls toString()", () => {
+  const result = Error.prepareStackTrace(new Error("ok"), [
+    { a: 1 },
+    { b: 2 },
+    {
+      c: 3,
+      toString() {
+        return "potato";
+      },
+    },
+  ]);
+  expect(result).toBe("Error: ok\n    at [object Object]\n    at [object Object]\n    at potato");
+});
+
+test("Error.prepareStackTrace propagates exceptions", () => {
+  expect(() =>
+    Error.prepareStackTrace(new Error("ok"), [
+      { a: 1 },
+      { b: 2 },
+      {
+        c: 3,
+        toString() {
+          throw new Error("hi");
+        },
+      },
+    ]),
+  ).toThrow("hi");
+});
diff --git a/test/js/node/v8/error-prepare-stack-default-fixture.js b/test/js/node/v8/error-prepare-stack-default-fixture.js
index 2586758595..17df9c6d9d 100644
--- a/test/js/node/v8/error-prepare-stack-default-fixture.js
+++ b/test/js/node/v8/error-prepare-stack-default-fixture.js
@@ -5,20 +5,38 @@ const orig = Error.prepareStackTrace;
 Error.prepareStackTrace = (err, stack) => {
   return orig(err, stack);
 };
+var stack2, stack;
 
-const err = new Error();
-Error.captureStackTrace(err);
-const stack = err.stack;
+function twoWrapperLevel() {
+  const err = new Error();
+  Error.captureStackTrace(err);
+  stack = err.stack;
 
-Error.prepareStackTrace = undefined;
-const err2 = new Error();
-Error.captureStackTrace(err2);
-const stack2 = err2.stack;
+  Error.prepareStackTrace = undefined;
+  const err2 = new Error();
+  Error.captureStackTrace(err2);
+  stack2 = err2.stack;
+}
 
-const stackIgnoringLineAndColumn = stack.replaceAll(":10:24", "N");
-const stack2IgnoringLineAndColumn = stack2.replaceAll(":15:24", "N");
+function oneWrapperLevel() {
+  // ...
+  var a = 123;
+  globalThis.a = a;
+  // ---
+
+  twoWrapperLevel();
+}
+
+oneWrapperLevel();
+
+// The native line column numbers might differ a bit here.
+const stackIgnoringLineAndColumn = stack.replaceAll(":12:26", ":NN:NN").replaceAll(/native:.*$/gm, "native)");
+const stack2IgnoringLineAndColumn = stack2.replaceAll(":17:26", ":NN:NN").replaceAll(/native:.*$/gm, "native)");
 if (stackIgnoringLineAndColumn !== stack2IgnoringLineAndColumn) {
+  console.log("\n-----\n");
   console.log(stackIgnoringLineAndColumn);
+  console.log("\n-----\n");
   console.log(stack2IgnoringLineAndColumn);
+  console.log("\n-----\n");
   throw new Error("Stacks are different");
 }
diff --git a/test/js/node/vm/vm.test.ts b/test/js/node/vm/vm.test.ts
index 9adfb20bcb..f0a66ec2e9 100644
--- a/test/js/node/vm/vm.test.ts
+++ b/test/js/node/vm/vm.test.ts
@@ -272,19 +272,42 @@ function testRunInContext({ fn, isIsolated, isNew }: TestRunInContextArg) {
       expect(result).toContain("foo.js");
     });
   }
-  test.skip("can specify a line offset", () => {
-    // TODO: use test.todo
+  test.todo("can specify filename", () => {
+    //
   });
-  test.skip("can specify a column offset", () => {
-    // TODO: use test.todo
+  test.todo("can specify lineOffset", () => {
+    //
   });
-  test.skip("can specify a timeout", () => {
-    const context = createContext({});
-    const result = () =>
-      fn("while (true) {};", context, {
-        timeout: 1,
-      });
-    expect(result).toThrow(); // TODO: does not timeout
+  test.todo("can specify columnOffset", () => {
+    //
+  });
+  test.todo("can specify displayErrors", () => {
+    //
+  });
+  test.todo("can specify timeout", () => {
+    //
+  });
+  test.todo("can specify breakOnSigint", () => {
+    //
+  });
+  test.todo("can specify cachedData", () => {
+    //
+  });
+  test.todo("can specify importModuleDynamically", () => {
+    //
+  });
+
+  // https://github.com/oven-sh/bun/issues/10885 .if(isNew == true)
+  test.todo("can specify contextName", () => {
+    //
+  });
+  // https://github.com/oven-sh/bun/issues/10885 .if(isNew == true)
+  test.todo("can specify contextOrigin", () => {
+    //
+  });
+  // https://github.com/oven-sh/bun/issues/10885 .if(isNew == true)
+  test.todo("can specify microtaskMode", () => {
+    //
   });
 }
 
diff --git a/test/js/node/watch/fs.watch.test.ts b/test/js/node/watch/fs.watch.test.ts
index ef9dd964aa..b758af71f0 100644
--- a/test/js/node/watch/fs.watch.test.ts
+++ b/test/js/node/watch/fs.watch.test.ts
@@ -1,5 +1,5 @@
 import { pathToFileURL } from "bun";
-import { bunRun, bunRunAsScript, tempDirWithFiles } from "harness";
+import { bunRun, bunRunAsScript, isWindows, tempDirWithFiles } from "harness";
 import fs, { FSWatcher } from "node:fs";
 import path from "path";
 
@@ -24,8 +24,6 @@ const testDir = tempDirWithFiles("watch", {
   [encodingFileName]: "hello",
 });
 
-const isWindows = process.platform === "win32";
-
 describe("fs.watch", () => {
   test("non-persistent watcher should not block the event loop", done => {
     try {
diff --git a/test/js/node/worker_threads/worker_threads.test.ts b/test/js/node/worker_threads/worker_threads.test.ts
index edb62b4dbc..6ed8af8ace 100644
--- a/test/js/node/worker_threads/worker_threads.test.ts
+++ b/test/js/node/worker_threads/worker_threads.test.ts
@@ -233,7 +233,7 @@ test("support require in eval for a file that doesnt exist", async () => {
     worker.on("message", resolve);
     worker.on("error", resolve);
   });
-  expect(result.toString()).toInclude(`error: Cannot find module "./fixture-invalid.js" from "blob:`);
+  expect(result.toString()).toInclude(`error: Cannot find module './fixture-invalid.js' from 'blob:`);
   await worker.terminate();
 });
 
diff --git a/test/js/node/zlib/leak.test.ts b/test/js/node/zlib/leak.test.ts
new file mode 100644
index 0000000000..4055bb02fa
--- /dev/null
+++ b/test/js/node/zlib/leak.test.ts
@@ -0,0 +1,96 @@
+import { beforeAll, describe, expect, test } from "bun:test";
+import { promisify } from "node:util";
+import zlib from "node:zlib";
+
+const input = Buffer.alloc(50000);
+for (let i = 0; i < input.length; i++) input[i] = Math.random();
+
+describe("zlib compression does not leak memory", () => {
+  beforeAll(() => {
+    for (let index = 0; index < 10_000; index++) {
+      zlib.deflateSync(input);
+    }
+    Bun.gc(true);
+    console.log("beforeAll done");
+  });
+
+  for (const compress of ["deflate", "gzip"] as const) {
+    test(
+      compress,
+      async () => {
+        for (let index = 0; index < 10_000; index++) {
+          await promisify(zlib[compress])(input);
+        }
+        const baseline = process.memoryUsage.rss();
+        console.log(baseline);
+        for (let index = 0; index < 10_000; index++) {
+          await promisify(zlib[compress])(input);
+        }
+        Bun.gc(true);
+        const after = process.memoryUsage.rss();
+        console.log(after);
+        console.log("-", after - baseline);
+        console.log("-", 1024 * 1024 * 10);
+        expect(after - baseline).toBeLessThan(1024 * 1024 * 10);
+      },
+      0,
+    );
+  }
+
+  for (const compress of ["deflateSync", "gzipSync"] as const) {
+    test(
+      compress,
+      async () => {
+        for (let index = 0; index < 10_000; index++) {
+          zlib[compress](input);
+        }
+        const baseline = process.memoryUsage.rss();
+        console.log(baseline);
+        for (let index = 0; index < 10_000; index++) {
+          zlib[compress](input);
+        }
+        Bun.gc(true);
+        const after = process.memoryUsage.rss();
+        console.log(after);
+        console.log("-", after - baseline);
+        console.log("-", 1024 * 1024 * 10);
+        expect(after - baseline).toBeLessThan(1024 * 1024 * 10);
+      },
+      0,
+    );
+  }
+
+  test("brotliCompress", async () => {
+    for (let index = 0; index < 1_000; index++) {
+      await promisify(zlib.brotliCompress)(input);
+    }
+    const baseline = process.memoryUsage.rss();
+    console.log(baseline);
+    for (let index = 0; index < 1_000; index++) {
+      await promisify(zlib.brotliCompress)(input);
+    }
+    Bun.gc(true);
+    const after = process.memoryUsage.rss();
+    console.log(after);
+    console.log("-", after - baseline);
+    console.log("-", 1024 * 1024 * 10);
+    expect(after - baseline).toBeLessThan(1024 * 1024 * 10);
+  }, 0);
+
+  test("brotliCompressSync", async () => {
+    for (let index = 0; index < 1_000; index++) {
+      zlib.brotliCompressSync(input);
+    }
+    const baseline = process.memoryUsage.rss();
+    console.log(baseline);
+    for (let index = 0; index < 1_000; index++) {
+      zlib.brotliCompressSync(input);
+    }
+    Bun.gc(true);
+    const after = process.memoryUsage.rss();
+    console.log(after);
+    console.log("-", after - baseline);
+    console.log("-", 1024 * 1024 * 10);
+    expect(after - baseline).toBeLessThan(1024 * 1024 * 10);
+  }, 0);
+});
diff --git a/test/js/node/zlib/zlib.test.js b/test/js/node/zlib/zlib.test.js
index ce4aa382b3..102bb91461 100644
--- a/test/js/node/zlib/zlib.test.js
+++ b/test/js/node/zlib/zlib.test.js
@@ -8,6 +8,51 @@ import * as stream from "node:stream";
 import * as util from "node:util";
 import * as zlib from "node:zlib";
 
+describe("prototype and name and constructor", () => {
+  for (let [name, Class] of [
+    ["Gzip", zlib.Gzip],
+    ["Gunzip", zlib.Gunzip],
+    ["Deflate", zlib.Deflate],
+    ["Inflate", zlib.Inflate],
+    ["DeflateRaw", zlib.DeflateRaw],
+  ]) {
+    describe(`${name}`, () => {
+      it(`${name}.prototype should be instanceof ${name}.__proto__`, () => {
+        expect(Class.prototype).toBeInstanceOf(Class.__proto__);
+      });
+      it(`${name}.prototype.constructor should be ${name}`, () => {
+        expect(Class.prototype.constructor).toBe(Class);
+      });
+      it(`${name}.name should be ${name}`, () => {
+        expect(Class.name).toBe(name);
+      });
+      it(`${name}.prototype.__proto__.constructor.name should be Zlib`, () => {
+        expect(Class.prototype.__proto__.constructor.name).toBe("Zlib");
+      });
+    });
+  }
+
+  for (let [name, Class] of [
+    ["BrotliCompress", zlib.BrotliCompress],
+    ["BrotliDecompress", zlib.BrotliDecompress],
+  ]) {
+    describe(`${name}`, () => {
+      it(`${name}.prototype should be instanceof ${name}.__proto__`, () => {
+        expect(Class.prototype).toBeInstanceOf(Class.__proto__);
+      });
+      it(`${name}.prototype.constructor should be ${name}`, () => {
+        expect(Class.prototype.constructor).toBe(Class);
+      });
+      it(`${name}.name should be ${name}`, () => {
+        expect(Class.name).toBe(name);
+      });
+      it(`${name}.prototype.__proto__.constructor.name should be Brotli`, () => {
+        expect(Class.prototype.__proto__.constructor.name).toBe("Brotli");
+      });
+    });
+  }
+});
+
 describe("zlib", () => {
   for (let library of ["zlib", "libdeflate"]) {
     for (let outputLibrary of ["zlib", "libdeflate"]) {
@@ -109,32 +154,24 @@ describe("zlib.brotli", () => {
     expect(roundtrip.toString()).toEqual(inputString);
   });
 
-  it("can compress streaming", () => {
+  it("can compress streaming", async () => {
     const encoder = zlib.createBrotliCompress();
     for (const chunk of window(inputString, 55)) {
-      encoder._transform(chunk, undefined, (err, data) => {
-        expect(err).toBeUndefined();
-        expect(data).toEqual(Buffer(0));
-      });
+      encoder.push(chunk);
     }
-    encoder._flush((err, data) => {
-      expect(err).toBeUndefined();
-      expect(data).toEqual(compressedBuffer);
-    });
+    encoder.push(null);
+    const buf = await new Response(encoder).text();
+    expect(buf).toEqual(inputString);
   });
 
-  it("can decompress streaming", () => {
+  it("can decompress streaming", async () => {
     const decoder = zlib.createBrotliDecompress();
     for (const chunk of window(compressedBuffer, 10)) {
-      decoder._transform(chunk, undefined, (err, data) => {
-        expect(err).toBeUndefined();
-        expect(data).toEqual(Buffer(0));
-      });
+      decoder.push(chunk);
     }
-    decoder._flush((err, data) => {
-      expect(err).toBeUndefined();
-      expect(data).toEqual(Buffer.from(inputString));
-    });
+    decoder.push(null);
+    const buf = await new Response(decoder).bytes();
+    expect(buf).toEqual(compressedBuffer);
   });
 
   it("can roundtrip an empty string", async () => {
@@ -144,19 +181,15 @@ describe("zlib.brotli", () => {
     expect(roundtrip.toString()).toEqual(input);
   });
 
-  it("can compress streaming big", () => {
+  it("can compress streaming big", async () => {
     const encoder = zlib.createBrotliCompress();
-    // prettier-ignore
-    for (const chunk of window(inputString+inputString+inputString+inputString, 65)) {
-      encoder._transform(chunk, undefined, (err, data) => {
-        expect(err).toBeUndefined();
-        expect(data).toEqual(Buffer(0));
-      });
+    const input = inputString + inputString + inputString + inputString;
+    for (const chunk of window(input, 65)) {
+      encoder.push(chunk);
     }
-    encoder._flush((err, data) => {
-      expect(err).toBeUndefined();
-      expect(data.length).toBeGreaterThan(0);
-    });
+    encoder.push(null);
+    const buf = await new Response(encoder).text();
+    expect(buf).toEqual(input);
   });
 
   it("fully works as a stream.Transform", async () => {
@@ -315,17 +348,17 @@ for (const [compress, decompressor] of [
     stream => {
       stream.end(compressed);
     },
-    // stream => {
-    //   stream.write(compressed);
-    //   stream.write(trailingData);
-    // },
+    stream => {
+      stream.write(compressed);
+      stream.write(trailingData);
+    },
     stream => {
       stream.write(compressed);
       stream.end(trailingData);
     },
-    // stream => {
-    //   stream.write(Buffer.concat([compressed, trailingData]));
-    // },
+    stream => {
+      stream.write(Buffer.concat([compressed, trailingData]));
+    },
     stream => {
       stream.end(Buffer.concat([compressed, trailingData]));
     },
diff --git a/test/js/sql/sql-fixture-ref.ts b/test/js/sql/sql-fixture-ref.ts
new file mode 100644
index 0000000000..af8f52dafc
--- /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 cef6943439..8c0089c760 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 0000000000..2bc99bd3ad
--- /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/common.ts b/test/js/third_party/grpc-js/common.ts
index e085a4f3d2..adc3f478a7 100644
--- a/test/js/third_party/grpc-js/common.ts
+++ b/test/js/third_party/grpc-js/common.ts
@@ -1,57 +1,33 @@
-import * as grpc from "@grpc/grpc-js";
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 import * as loader from "@grpc/proto-loader";
-import { which } from "bun";
+import * as assert2 from "./assert2";
+import * as path from "path";
+import grpc from "@grpc/grpc-js";
+import * as fsPromises from "fs/promises";
+import * as os from "os";
+
+import { GrpcObject, ServiceClientConstructor, ServiceClient, loadPackageDefinition } from "@grpc/grpc-js";
 import { readFileSync } from "fs";
-import path from "node:path";
-import { AddressInfo } from "ws";
-
-const nodeExecutable = which("node");
-async function nodeEchoServer(env: any) {
-  env = env || {};
-  if (!nodeExecutable) throw new Error("node executable not found");
-  const subprocess = Bun.spawn([nodeExecutable, path.join(import.meta.dir, "node-server.fixture.js")], {
-    stdout: "pipe",
-    stdin: "pipe",
-    env: env,
-  });
-  const reader = subprocess.stdout.getReader();
-  const data = await reader.read();
-  const decoder = new TextDecoder("utf-8");
-  const json = decoder.decode(data.value);
-  const address = JSON.parse(json);
-  const url = `${address.family === "IPv6" ? `[${address.address}]` : address.address}:${address.port}`;
-  return { address, url, subprocess };
-}
-
-export class TestServer {
-  #server: any;
-  #options: grpc.ChannelOptions;
-  address: AddressInfo | null = null;
-  url: string = "";
-  service_type: number = 0;
-  useTls = false;
-  constructor(useTls: boolean, options?: grpc.ChannelOptions, service_type = 0) {
-    this.#options = options || {};
-    this.useTls = useTls;
-    this.service_type = service_type;
-  }
-  async start() {
-    const result = await nodeEchoServer({
-      GRPC_TEST_USE_TLS: this.useTls ? "true" : "false",
-      GRPC_TEST_OPTIONS: JSON.stringify(this.#options),
-      GRPC_SERVICE_TYPE: this.service_type.toString(),
-      "grpc-node.max_session_memory": 1024,
-    });
-    this.address = result.address as AddressInfo;
-    this.url = result.url as string;
-    this.#server = result.subprocess;
-  }
-
-  shutdown() {
-    this.#server.stdin.write("shutdown");
-    this.#server.kill();
-  }
-}
+import { HealthListener, SubchannelInterface } from "@grpc/grpc-js/build/src/subchannel-interface";
+import type { EntityTypes, SubchannelRef } from "@grpc/grpc-js/build/src/channelz";
+import { Subchannel } from "@grpc/grpc-js/build/src/subchannel";
+import { ConnectivityState } from "@grpc/grpc-js/build/src/connectivity-state";
 
 const protoLoaderOptions = {
   keepCase: true,
@@ -61,93 +37,145 @@ const protoLoaderOptions = {
   oneofs: true,
 };
 
-function loadProtoFile(file: string) {
-  const packageDefinition = loader.loadSync(file, protoLoaderOptions);
-  return grpc.loadPackageDefinition(packageDefinition);
+export function mockFunction(): never {
+  throw new Error("Not implemented");
 }
 
-const protoFile = path.join(import.meta.dir, "fixtures", "echo_service.proto");
-const EchoService = loadProtoFile(protoFile).EchoService as grpc.ServiceClientConstructor;
+export function loadProtoFile(file: string): GrpcObject {
+  const packageDefinition = loader.loadSync(file, protoLoaderOptions);
+  return loadPackageDefinition(packageDefinition);
+}
 
-export const ca = readFileSync(path.join(import.meta.dir, "fixtures", "ca.pem"));
+const protoFile = path.join(__dirname, "fixtures", "echo_service.proto");
+const echoService = loadProtoFile(protoFile).EchoService as ServiceClientConstructor;
+
+const ca = readFileSync(path.join(__dirname, "fixtures", "ca.pem"));
+const key = readFileSync(path.join(__dirname, "fixtures", "server1.key"));
+const cert = readFileSync(path.join(__dirname, "fixtures", "server1.pem"));
+
+const serviceImpl = {
+  echo: (call: grpc.ServerUnaryCall<any, any>, callback: grpc.sendUnaryData<any>) => {
+    callback(null, call.request);
+  },
+};
+
+export class TestServer {
+  private server: grpc.Server;
+  private target: string | null = null;
+  constructor(
+    public useTls: boolean,
+    options?: grpc.ServerOptions,
+  ) {
+    this.server = new grpc.Server(options);
+    this.server.addService(echoService.service, serviceImpl);
+  }
+
+  private getCredentials(): grpc.ServerCredentials {
+    if (this.useTls) {
+      return grpc.ServerCredentials.createSsl(null, [{ private_key: key, cert_chain: cert }], false);
+    } else {
+      return grpc.ServerCredentials.createInsecure();
+    }
+  }
+
+  start(): Promise<void> {
+    return new Promise<void>((resolve, reject) => {
+      this.server.bindAsync("localhost:0", this.getCredentials(), (error, port) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        this.target = `localhost:${port}`;
+        resolve();
+      });
+    });
+  }
+
+  startUds(): Promise<void> {
+    return fsPromises.mkdtemp(path.join(os.tmpdir(), "uds")).then(dir => {
+      return new Promise<void>((resolve, reject) => {
+        const target = `unix://${dir}/socket`;
+        this.server.bindAsync(target, this.getCredentials(), (error, port) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          this.target = target;
+          resolve();
+        });
+      });
+    });
+  }
+
+  shutdown() {
+    this.server.forceShutdown();
+  }
+
+  getTarget() {
+    if (this.target === null) {
+      throw new Error("Server not yet started");
+    }
+    return this.target;
+  }
+}
 
 export class TestClient {
-  #client: grpc.Client;
-  constructor(url: string, useTls: boolean | grpc.ChannelCredentials, options?: grpc.ChannelOptions) {
+  private client: ServiceClient;
+  constructor(target: string, useTls: boolean, options?: grpc.ChannelOptions) {
     let credentials: grpc.ChannelCredentials;
-    if (useTls instanceof grpc.ChannelCredentials) {
-      credentials = useTls;
-    } else if (useTls) {
+    if (useTls) {
       credentials = grpc.credentials.createSsl(ca);
     } else {
       credentials = grpc.credentials.createInsecure();
     }
-    this.#client = new EchoService(url, credentials, options);
-  }
-
-  static createFromServerWithCredentials(
-    server: TestServer,
-    credentials: grpc.ChannelCredentials,
-    options?: grpc.ChannelOptions,
-  ) {
-    if (!server.address) {
-      throw new Error("Cannot create client, server not started");
-    }
-    return new TestClient(server.url, credentials, options);
+    this.client = new echoService(target, credentials, options);
   }
 
   static createFromServer(server: TestServer, options?: grpc.ChannelOptions) {
-    if (!server.address) {
-      throw new Error("Cannot create client, server not started");
-    }
-    return new TestClient(server.url, server.useTls, options);
+    return new TestClient(server.getTarget(), server.useTls, options);
   }
 
   waitForReady(deadline: grpc.Deadline, callback: (error?: Error) => void) {
-    this.#client.waitForReady(deadline, callback);
-  }
-  get client() {
-    return this.#client;
-  }
-  echo(...params: any[]) {
-    return this.#client.echo(...params);
-  }
-  sendRequest(callback: (error?: grpc.ServiceError) => void) {
-    this.#client.echo(
-      {
-        value: "hello",
-        value2: 1,
-      },
-      callback,
-    );
+    this.client.waitForReady(deadline, callback);
   }
 
-  getChannel() {
-    return this.#client.getChannel();
+  sendRequest(callback: (error?: grpc.ServiceError) => void) {
+    this.client.echo({}, callback);
+  }
+
+  sendRequestWithMetadata(metadata: grpc.Metadata, callback: (error?: grpc.ServiceError) => void) {
+    this.client.echo({}, metadata, callback);
   }
 
   getChannelState() {
-    return this.#client.getChannel().getConnectivityState(false);
+    return this.client.getChannel().getConnectivityState(false);
+  }
+
+  waitForClientState(deadline: grpc.Deadline, state: ConnectivityState, callback: (error?: Error) => void) {
+    this.client.getChannel().watchConnectivityState(this.getChannelState(), deadline, err => {
+      if (err) {
+        return callback(err);
+      }
+
+      const currentState = this.getChannelState();
+      if (currentState === state) {
+        callback();
+      } else {
+        return this.waitForClientState(deadline, currentState, callback);
+      }
+    });
   }
 
   close() {
-    this.#client.close();
+    this.client.close();
   }
 }
 
-export enum ConnectivityState {
-  IDLE,
-  CONNECTING,
-  READY,
-  TRANSIENT_FAILURE,
-  SHUTDOWN,
-}
-
 /**
  * A mock subchannel that transitions between states on command, to test LB
  * policy behavior
  */
-export class MockSubchannel implements grpc.experimental.SubchannelInterface {
+export class MockSubchannel implements SubchannelInterface {
   private state: grpc.connectivityState;
   private listeners: Set<grpc.experimental.ConnectivityStateListener> = new Set();
   constructor(
@@ -196,4 +224,11 @@ export class MockSubchannel implements grpc.experimental.SubchannelInterface {
   realSubchannelEquals(other: grpc.experimental.SubchannelInterface): boolean {
     return this === other;
   }
+  isHealthy(): boolean {
+    return true;
+  }
+  addHealthStateWatcher(listener: HealthListener): void {}
+  removeHealthStateWatcher(listener: HealthListener): void {}
 }
+
+export { assert2 };
diff --git a/test/js/third_party/grpc-js/fixtures/README b/test/js/third_party/grpc-js/fixtures/README
new file mode 100644
index 0000000000..888d95b900
--- /dev/null
+++ b/test/js/third_party/grpc-js/fixtures/README
@@ -0,0 +1 @@
+CONFIRMEDTESTKEY
diff --git a/test/js/third_party/grpc-js/fixtures/ca.pem b/test/js/third_party/grpc-js/fixtures/ca.pem
index 9cdc139c13..3f292fed8b 100644
--- a/test/js/third_party/grpc-js/fixtures/ca.pem
+++ b/test/js/third_party/grpc-js/fixtures/ca.pem
@@ -1,20 +1,33 @@
 -----BEGIN CERTIFICATE-----
-MIIDWjCCAkKgAwIBAgIUWrP0VvHcy+LP6UuYNtiL9gBhD5owDQYJKoZIhvcNAQEL
-BQAwVjELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
-GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDEPMA0GA1UEAwwGdGVzdGNhMB4XDTIw
-MDMxNzE4NTk1MVoXDTMwMDMxNTE4NTk1MVowVjELMAkGA1UEBhMCQVUxEzARBgNV
-BAgMClNvbWUtU3RhdGUxITAfBgNVBAoMGEludGVybmV0IFdpZGdpdHMgUHR5IEx0
-ZDEPMA0GA1UEAwwGdGVzdGNhMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC
-AQEAsGL0oXflF0LzoM+Bh+qUU9yhqzw2w8OOX5mu/iNCyUOBrqaHi7mGHx73GD01
-diNzCzvlcQqdNIH6NQSL7DTpBjca66jYT9u73vZe2MDrr1nVbuLvfu9850cdxiUO
-Inv5xf8+sTHG0C+a+VAvMhsLiRjsq+lXKRJyk5zkbbsETybqpxoJ+K7CoSy3yc/k
-QIY3TipwEtwkKP4hzyo6KiGd/DPexie4nBUInN3bS1BUeNZ5zeaIC2eg3bkeeW7c
-qT55b+Yen6CxY0TEkzBK6AKt/WUialKMgT0wbTxRZO7kUCH3Sq6e/wXeFdJ+HvdV
-LPlAg5TnMaNpRdQih/8nRFpsdwIDAQABoyAwHjAMBgNVHRMEBTADAQH/MA4GA1Ud
-DwEB/wQEAwICBDANBgkqhkiG9w0BAQsFAAOCAQEAkTrKZjBrJXHps/HrjNCFPb5a
-THuGPCSsepe1wkKdSp1h4HGRpLoCgcLysCJ5hZhRpHkRihhef+rFHEe60UePQO3S
-CVTtdJB4CYWpcNyXOdqefrbJW5QNljxgi6Fhvs7JJkBqdXIkWXtFk2eRgOIP2Eo9
-/OHQHlYnwZFrk6sp4wPyR+A95S0toZBcyDVz7u+hOW0pGK3wviOe9lvRgj/H3Pwt
-bewb0l+MhRig0/DVHamyVxrDRbqInU1/GTNCwcZkXKYFWSf92U+kIcTth24Q1gcw
-eZiLl5FfrWokUNytFElXob0V0a5/kbhiLc3yWmvWqHTpqCALbVyF+rKJo2f5Kw==
------END CERTIFICATE-----
\ No newline at end of file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=
+-----END CERTIFICATE-----
diff --git a/test/js/third_party/grpc-js/fixtures/channelz.proto b/test/js/third_party/grpc-js/fixtures/channelz.proto
new file mode 100644
index 0000000000..446e9794ba
--- /dev/null
+++ b/test/js/third_party/grpc-js/fixtures/channelz.proto
@@ -0,0 +1,564 @@
+// Copyright 2018 The gRPC Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This file defines an interface for exporting monitoring information
+// out of gRPC servers.  See the full design at
+// https://github.com/grpc/proposal/blob/master/A14-channelz.md
+//
+// The canonical version of this proto can be found at
+// https://github.com/grpc/grpc-proto/blob/master/grpc/channelz/v1/channelz.proto
+
+syntax = "proto3";
+
+package grpc.channelz.v1;
+
+import "google/protobuf/any.proto";
+import "google/protobuf/duration.proto";
+import "google/protobuf/timestamp.proto";
+import "google/protobuf/wrappers.proto";
+
+option go_package = "google.golang.org/grpc/channelz/grpc_channelz_v1";
+option java_multiple_files = true;
+option java_package = "io.grpc.channelz.v1";
+option java_outer_classname = "ChannelzProto";
+
+// Channel is a logical grouping of channels, subchannels, and sockets.
+message Channel {
+  // The identifier for this channel. This should bet set.
+  ChannelRef ref = 1;
+  // Data specific to this channel.
+  ChannelData data = 2;
+  // At most one of 'channel_ref+subchannel_ref' and 'socket' is set.
+
+  // There are no ordering guarantees on the order of channel refs.
+  // There may not be cycles in the ref graph.
+  // A channel ref may be present in more than one channel or subchannel.
+  repeated ChannelRef channel_ref = 3;
+
+  // At most one of 'channel_ref+subchannel_ref' and 'socket' is set.
+  // There are no ordering guarantees on the order of subchannel refs.
+  // There may not be cycles in the ref graph.
+  // A sub channel ref may be present in more than one channel or subchannel.
+  repeated SubchannelRef subchannel_ref = 4;
+
+  // There are no ordering guarantees on the order of sockets.
+  repeated SocketRef socket_ref = 5;
+}
+
+// Subchannel is a logical grouping of channels, subchannels, and sockets.
+// A subchannel is load balanced over by it's ancestor
+message Subchannel {
+  // The identifier for this channel.
+  SubchannelRef ref = 1;
+  // Data specific to this channel.
+  ChannelData data = 2;
+  // At most one of 'channel_ref+subchannel_ref' and 'socket' is set.
+
+  // There are no ordering guarantees on the order of channel refs.
+  // There may not be cycles in the ref graph.
+  // A channel ref may be present in more than one channel or subchannel.
+  repeated ChannelRef channel_ref = 3;
+
+  // At most one of 'channel_ref+subchannel_ref' and 'socket' is set.
+  // There are no ordering guarantees on the order of subchannel refs.
+  // There may not be cycles in the ref graph.
+  // A sub channel ref may be present in more than one channel or subchannel.
+  repeated SubchannelRef subchannel_ref = 4;
+
+  // There are no ordering guarantees on the order of sockets.
+  repeated SocketRef socket_ref = 5;
+}
+
+// These come from the specified states in this document:
+// https://github.com/grpc/grpc/blob/master/doc/connectivity-semantics-and-api.md
+message ChannelConnectivityState {
+  enum State {
+    UNKNOWN = 0;
+    IDLE = 1;
+    CONNECTING = 2;
+    READY = 3;
+    TRANSIENT_FAILURE = 4;
+    SHUTDOWN = 5;
+  }
+  State state = 1;
+}
+
+// Channel data is data related to a specific Channel or Subchannel.
+message ChannelData {
+  // The connectivity state of the channel or subchannel.  Implementations
+  // should always set this.
+  ChannelConnectivityState state = 1;
+
+  // The target this channel originally tried to connect to.  May be absent
+  string target = 2;
+
+  // A trace of recent events on the channel.  May be absent.
+  ChannelTrace trace = 3;
+
+  // The number of calls started on the channel
+  int64 calls_started = 4;
+  // The number of calls that have completed with an OK status
+  int64 calls_succeeded = 5;
+  // The number of calls that have completed with a non-OK status
+  int64 calls_failed = 6;
+
+  // The last time a call was started on the channel.
+  google.protobuf.Timestamp last_call_started_timestamp = 7;
+}
+
+// A trace event is an interesting thing that happened to a channel or
+// subchannel, such as creation, address resolution, subchannel creation, etc.
+message ChannelTraceEvent {
+  // High level description of the event.
+  string description = 1;
+  // The supported severity levels of trace events.
+  enum Severity {
+    CT_UNKNOWN = 0;
+    CT_INFO = 1;
+    CT_WARNING = 2;
+    CT_ERROR = 3;
+  }
+  // the severity of the trace event
+  Severity severity = 2;
+  // When this event occurred.
+  google.protobuf.Timestamp timestamp = 3;
+  // ref of referenced channel or subchannel.
+  // Optional, only present if this event refers to a child object. For example,
+  // this field would be filled if this trace event was for a subchannel being
+  // created.
+  oneof child_ref {
+    ChannelRef channel_ref = 4;
+    SubchannelRef subchannel_ref = 5;
+  }
+}
+
+// ChannelTrace represents the recent events that have occurred on the channel.
+message ChannelTrace {
+  // Number of events ever logged in this tracing object. This can differ from
+  // events.size() because events can be overwritten or garbage collected by
+  // implementations.
+  int64 num_events_logged = 1;
+  // Time that this channel was created.
+  google.protobuf.Timestamp creation_timestamp = 2;
+  // List of events that have occurred on this channel.
+  repeated ChannelTraceEvent events = 3;
+}
+
+// ChannelRef is a reference to a Channel.
+message ChannelRef {
+  // The globally unique id for this channel.  Must be a positive number.
+  int64 channel_id = 1;
+  // An optional name associated with the channel.
+  string name = 2;
+  // Intentionally don't use field numbers from other refs.
+  reserved 3, 4, 5, 6, 7, 8;
+}
+
+// SubchannelRef is a reference to a Subchannel.
+message SubchannelRef {
+  // The globally unique id for this subchannel.  Must be a positive number.
+  int64 subchannel_id = 7;
+  // An optional name associated with the subchannel.
+  string name = 8;
+  // Intentionally don't use field numbers from other refs.
+  reserved 1, 2, 3, 4, 5, 6;
+}
+
+// SocketRef is a reference to a Socket.
+message SocketRef {
+  // The globally unique id for this socket.  Must be a positive number.
+  int64 socket_id = 3;
+  // An optional name associated with the socket.
+  string name = 4;
+  // Intentionally don't use field numbers from other refs.
+  reserved 1, 2, 5, 6, 7, 8;
+}
+
+// ServerRef is a reference to a Server.
+message ServerRef {
+  // A globally unique identifier for this server.  Must be a positive number.
+  int64 server_id = 5;
+  // An optional name associated with the server.
+  string name = 6;
+  // Intentionally don't use field numbers from other refs.
+  reserved 1, 2, 3, 4, 7, 8;
+}
+
+// Server represents a single server.  There may be multiple servers in a single
+// program.
+message Server {
+  // The identifier for a Server.  This should be set.
+  ServerRef ref = 1;
+  // The associated data of the Server.
+  ServerData data = 2;
+
+  // The sockets that the server is listening on.  There are no ordering
+  // guarantees.  This may be absent.
+  repeated SocketRef listen_socket = 3;
+}
+
+// ServerData is data for a specific Server.
+message ServerData {
+  // A trace of recent events on the server.  May be absent.
+  ChannelTrace trace = 1;
+
+  // The number of incoming calls started on the server
+  int64 calls_started = 2;
+  // The number of incoming calls that have completed with an OK status
+  int64 calls_succeeded = 3;
+  // The number of incoming calls that have a completed with a non-OK status
+  int64 calls_failed = 4;
+
+  // The last time a call was started on the server.
+  google.protobuf.Timestamp last_call_started_timestamp = 5;
+}
+
+// Information about an actual connection.  Pronounced "sock-ay".
+message Socket {
+  // The identifier for the Socket.
+  SocketRef ref = 1;
+
+  // Data specific to this Socket.
+  SocketData data = 2;
+  // The locally bound address.
+  Address local = 3;
+  // The remote bound address.  May be absent.
+  Address remote = 4;
+  // Security details for this socket.  May be absent if not available, or
+  // there is no security on the socket.
+  Security security = 5;
+
+  // Optional, represents the name of the remote endpoint, if different than
+  // the original target name.
+  string remote_name = 6;
+}
+
+// SocketData is data associated for a specific Socket.  The fields present
+// are specific to the implementation, so there may be minor differences in
+// the semantics.  (e.g. flow control windows)
+message SocketData {
+  // The number of streams that have been started.
+  int64 streams_started = 1;
+  // The number of streams that have ended successfully:
+  // On client side, received frame with eos bit set;
+  // On server side, sent frame with eos bit set.
+  int64 streams_succeeded = 2;
+  // The number of streams that have ended unsuccessfully:
+  // On client side, ended without receiving frame with eos bit set;
+  // On server side, ended without sending frame with eos bit set.
+  int64 streams_failed = 3;
+  // The number of grpc messages successfully sent on this socket.
+  int64 messages_sent = 4;
+  // The number of grpc messages received on this socket.
+  int64 messages_received = 5;
+
+  // The number of keep alives sent.  This is typically implemented with HTTP/2
+  // ping messages.
+  int64 keep_alives_sent = 6;
+
+  // The last time a stream was created by this endpoint.  Usually unset for
+  // servers.
+  google.protobuf.Timestamp last_local_stream_created_timestamp = 7;
+  // The last time a stream was created by the remote endpoint.  Usually unset
+  // for clients.
+  google.protobuf.Timestamp last_remote_stream_created_timestamp = 8;
+
+  // The last time a message was sent by this endpoint.
+  google.protobuf.Timestamp last_message_sent_timestamp = 9;
+  // The last time a message was received by this endpoint.
+  google.protobuf.Timestamp last_message_received_timestamp = 10;
+
+  // The amount of window, granted to the local endpoint by the remote endpoint.
+  // This may be slightly out of date due to network latency.  This does NOT
+  // include stream level or TCP level flow control info.
+  google.protobuf.Int64Value local_flow_control_window = 11;
+
+  // The amount of window, granted to the remote endpoint by the local endpoint.
+  // This may be slightly out of date due to network latency.  This does NOT
+  // include stream level or TCP level flow control info.
+  google.protobuf.Int64Value  remote_flow_control_window = 12;
+
+  // Socket options set on this socket.  May be absent if 'summary' is set
+  // on GetSocketRequest.
+  repeated SocketOption option = 13;
+}
+
+// Address represents the address used to create the socket.
+message Address {
+  message TcpIpAddress {
+    // Either the IPv4 or IPv6 address in bytes.  Will be either 4 bytes or 16
+    // bytes in length.
+    bytes ip_address = 1;
+    // 0-64k, or -1 if not appropriate.
+    int32 port = 2;
+  }
+  // A Unix Domain Socket address.
+  message UdsAddress {
+    string filename = 1;
+  }
+  // An address type not included above.
+  message OtherAddress {
+    // The human readable version of the value.  This value should be set.
+    string name = 1;
+    // The actual address message.
+    google.protobuf.Any value = 2;
+  }
+
+  oneof address {
+    TcpIpAddress tcpip_address = 1;
+    UdsAddress uds_address = 2;
+    OtherAddress other_address = 3;
+  }
+}
+
+// Security represents details about how secure the socket is.
+message Security {
+  message Tls {
+    oneof cipher_suite {
+      // The cipher suite name in the RFC 4346 format:
+      // https://tools.ietf.org/html/rfc4346#appendix-C
+      string standard_name = 1;
+      // Some other way to describe the cipher suite if
+      // the RFC 4346 name is not available.
+      string other_name = 2;
+    }
+    // the certificate used by this endpoint.
+    bytes local_certificate = 3;
+    // the certificate used by the remote endpoint.
+    bytes remote_certificate = 4;
+  }
+  message OtherSecurity {
+    // The human readable version of the value.
+    string name = 1;
+    // The actual security details message.
+    google.protobuf.Any value = 2;
+  }
+  oneof model {
+    Tls tls = 1;
+    OtherSecurity other = 2;
+  }
+}
+
+// SocketOption represents socket options for a socket.  Specifically, these
+// are the options returned by getsockopt().
+message SocketOption {
+  // The full name of the socket option.  Typically this will be the upper case
+  // name, such as "SO_REUSEPORT".
+  string name = 1;
+  // The human readable value of this socket option.  At least one of value or
+  // additional will be set.
+  string value = 2;
+  // Additional data associated with the socket option.  At least one of value
+  // or additional will be set.
+  google.protobuf.Any additional = 3;
+}
+
+// For use with SocketOption's additional field.  This is primarily used for
+// SO_RCVTIMEO and SO_SNDTIMEO
+message SocketOptionTimeout {
+  google.protobuf.Duration duration = 1;
+}
+
+// For use with SocketOption's additional field.  This is primarily used for
+// SO_LINGER.
+message SocketOptionLinger {
+  // active maps to `struct linger.l_onoff`
+  bool active = 1;
+  // duration maps to `struct linger.l_linger`
+  google.protobuf.Duration duration = 2;
+}
+
+// For use with SocketOption's additional field.  Tcp info for
+// SOL_TCP and TCP_INFO.
+message SocketOptionTcpInfo {
+  uint32 tcpi_state = 1;
+
+  uint32 tcpi_ca_state = 2;
+  uint32 tcpi_retransmits = 3;
+  uint32 tcpi_probes = 4;
+  uint32 tcpi_backoff = 5;
+  uint32 tcpi_options = 6;
+  uint32 tcpi_snd_wscale = 7;
+  uint32 tcpi_rcv_wscale = 8;
+
+  uint32 tcpi_rto = 9;
+  uint32 tcpi_ato = 10;
+  uint32 tcpi_snd_mss = 11;
+  uint32 tcpi_rcv_mss = 12;
+
+  uint32 tcpi_unacked = 13;
+  uint32 tcpi_sacked = 14;
+  uint32 tcpi_lost = 15;
+  uint32 tcpi_retrans = 16;
+  uint32 tcpi_fackets = 17;
+
+  uint32 tcpi_last_data_sent = 18;
+  uint32 tcpi_last_ack_sent = 19;
+  uint32 tcpi_last_data_recv = 20;
+  uint32 tcpi_last_ack_recv = 21;
+
+  uint32 tcpi_pmtu = 22;
+  uint32 tcpi_rcv_ssthresh = 23;
+  uint32 tcpi_rtt = 24;
+  uint32 tcpi_rttvar = 25;
+  uint32 tcpi_snd_ssthresh = 26;
+  uint32 tcpi_snd_cwnd = 27;
+  uint32 tcpi_advmss = 28;
+  uint32 tcpi_reordering = 29;
+}
+
+// Channelz is a service exposed by gRPC servers that provides detailed debug
+// information.
+service Channelz {
+  // Gets all root channels (i.e. channels the application has directly
+  // created). This does not include subchannels nor non-top level channels.
+  rpc GetTopChannels(GetTopChannelsRequest) returns (GetTopChannelsResponse);
+  // Gets all servers that exist in the process.
+  rpc GetServers(GetServersRequest) returns (GetServersResponse);
+  // Returns a single Server, or else a NOT_FOUND code.
+  rpc GetServer(GetServerRequest) returns (GetServerResponse);
+  // Gets all server sockets that exist in the process.
+  rpc GetServerSockets(GetServerSocketsRequest) returns (GetServerSocketsResponse);
+  // Returns a single Channel, or else a NOT_FOUND code.
+  rpc GetChannel(GetChannelRequest) returns (GetChannelResponse);
+  // Returns a single Subchannel, or else a NOT_FOUND code.
+  rpc GetSubchannel(GetSubchannelRequest) returns (GetSubchannelResponse);
+  // Returns a single Socket or else a NOT_FOUND code.
+  rpc GetSocket(GetSocketRequest) returns (GetSocketResponse);
+}
+
+message GetTopChannelsRequest {
+  // start_channel_id indicates that only channels at or above this id should be
+  // included in the results.
+  // To request the first page, this should be set to 0. To request
+  // subsequent pages, the client generates this value by adding 1 to
+  // the highest seen result ID.
+  int64 start_channel_id = 1;
+
+  // If non-zero, the server will return a page of results containing
+  // at most this many items. If zero, the server will choose a
+  // reasonable page size.  Must never be negative.
+  int64 max_results = 2;
+}
+
+message GetTopChannelsResponse {
+  // list of channels that the connection detail service knows about.  Sorted in
+  // ascending channel_id order.
+  // Must contain at least 1 result, otherwise 'end' must be true.
+  repeated Channel channel = 1;
+  // If set, indicates that the list of channels is the final list.  Requesting
+  // more channels can only return more if they are created after this RPC
+  // completes.
+  bool end = 2;
+}
+
+message GetServersRequest {
+  // start_server_id indicates that only servers at or above this id should be
+  // included in the results.
+  // To request the first page, this must be set to 0. To request
+  // subsequent pages, the client generates this value by adding 1 to
+  // the highest seen result ID.
+  int64 start_server_id = 1;
+
+  // If non-zero, the server will return a page of results containing
+  // at most this many items. If zero, the server will choose a
+  // reasonable page size.  Must never be negative.
+  int64 max_results = 2;
+}
+
+message GetServersResponse {
+  // list of servers that the connection detail service knows about.  Sorted in
+  // ascending server_id order.
+  // Must contain at least 1 result, otherwise 'end' must be true.
+  repeated Server server = 1;
+  // If set, indicates that the list of servers is the final list.  Requesting
+  // more servers will only return more if they are created after this RPC
+  // completes.
+  bool end = 2;
+}
+
+message GetServerRequest {
+  // server_id is the identifier of the specific server to get.
+  int64 server_id = 1;
+}
+
+message GetServerResponse {
+  // The Server that corresponds to the requested server_id.  This field
+  // should be set.
+  Server server = 1;
+}
+
+message GetServerSocketsRequest {
+  int64 server_id = 1;
+  // start_socket_id indicates that only sockets at or above this id should be
+  // included in the results.
+  // To request the first page, this must be set to 0. To request
+  // subsequent pages, the client generates this value by adding 1 to
+  // the highest seen result ID.
+  int64 start_socket_id = 2;
+
+  // If non-zero, the server will return a page of results containing
+  // at most this many items. If zero, the server will choose a
+  // reasonable page size.  Must never be negative.
+  int64 max_results = 3;
+}
+
+message GetServerSocketsResponse {
+  // list of socket refs that the connection detail service knows about.  Sorted in
+  // ascending socket_id order.
+  // Must contain at least 1 result, otherwise 'end' must be true.
+  repeated SocketRef socket_ref = 1;
+  // If set, indicates that the list of sockets is the final list.  Requesting
+  // more sockets will only return more if they are created after this RPC
+  // completes.
+  bool end = 2;
+}
+
+message GetChannelRequest {
+  // channel_id is the identifier of the specific channel to get.
+  int64 channel_id = 1;
+}
+
+message GetChannelResponse {
+  // The Channel that corresponds to the requested channel_id.  This field
+  // should be set.
+  Channel channel = 1;
+}
+
+message GetSubchannelRequest {
+  // subchannel_id is the identifier of the specific subchannel to get.
+  int64 subchannel_id = 1;
+}
+
+message GetSubchannelResponse {
+  // The Subchannel that corresponds to the requested subchannel_id.  This
+  // field should be set.
+  Subchannel subchannel = 1;
+}
+
+message GetSocketRequest {
+  // socket_id is the identifier of the specific socket to get.
+  int64 socket_id = 1;
+
+  // If true, the response will contain only high level information
+  // that is inexpensive to obtain. Fields thay may be omitted are
+  // documented.
+  bool summary = 2;
+}
+
+message GetSocketResponse {
+  // The Socket that corresponds to the requested socket_id.  This field
+  // should be set.
+  Socket socket = 1;
+}
\ No newline at end of file
diff --git a/test/js/third_party/grpc-js/fixtures/server1.key b/test/js/third_party/grpc-js/fixtures/server1.key
index 0197dff398..8218f2933b 100644
--- a/test/js/third_party/grpc-js/fixtures/server1.key
+++ b/test/js/third_party/grpc-js/fixtures/server1.key
@@ -1,28 +1,52 @@
 -----BEGIN PRIVATE KEY-----
-MIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQDnE443EknxvxBq
-6+hvn/t09hl8hx366EBYvZmVM/NC+7igXRAjiJiA/mIaCvL3MS0Iz5hBLxSGICU+
-WproA3GCIFITIwcf/ETyWj/5xpgZ4AKrLrjQmmX8mhwUajfF3UvwMJrCOVqPp67t
-PtP+2kBXaqrXdvnvXR41FsIB8V7zIAuIZB6bHQhiGVlc1sgZYsE2EGG9WMmHtS86
-qkAOTjG2XyjmPTGAwhGDpYkYrpzp99IiDh4/Veai81hn0ssQkbry0XRD/Ig3jcHh
-23WiriPNJ0JsbgXUSLKRPZObA9VgOLy2aXoN84IMaeK3yy+cwSYG/99w93fUZJte
-MXwz4oYZAgMBAAECggEBAIVn2Ncai+4xbH0OLWckabwgyJ4IM9rDc0LIU368O1kU
-koais8qP9dujAWgfoh3sGh/YGgKn96VnsZjKHlyMgF+r4TaDJn3k2rlAOWcurGlj
-1qaVlsV4HiEzp7pxiDmHhWvp4672Bb6iBG+bsjCUOEk/n9o9KhZzIBluRhtxCmw5
-nw4Do7z00PTvN81260uPWSc04IrytvZUiAIx/5qxD72bij2xJ8t/I9GI8g4FtoVB
-8pB6S/hJX1PZhh9VlU6Yk+TOfOVnbebG4W5138LkB835eqk3Zz0qsbc2euoi8Hxi
-y1VGwQEmMQ63jXz4c6g+X55ifvUK9Jpn5E8pq+pMd7ECgYEA93lYq+Cr54K4ey5t
-sWMa+ye5RqxjzgXj2Kqr55jb54VWG7wp2iGbg8FMlkQwzTJwebzDyCSatguEZLuB
-gRGroRnsUOy9vBvhKPOch9bfKIl6qOgzMJB267fBVWx5ybnRbWN/I7RvMQf3k+9y
-biCIVnxDLEEYyx7z85/5qxsXg/MCgYEA7wmWKtCTn032Hy9P8OL49T0X6Z8FlkDC
-Rk42ygrc/MUbugq9RGUxcCxoImOG9JXUpEtUe31YDm2j+/nbvrjl6/bP2qWs0V7l
-dTJl6dABP51pCw8+l4cWgBBX08Lkeen812AAFNrjmDCjX6rHjWHLJcpS18fnRRkP
-V1d/AHWX7MMCgYEA6Gsw2guhp0Zf2GCcaNK5DlQab8OL4Hwrpttzo4kuTlwtqNKp
-Q9H4al9qfF4Cr1TFya98+EVYf8yFRM3NLNjZpe3gwYf2EerlJj7VLcahw0KKzoN1
-QBENfwgPLRk5sDkx9VhSmcfl/diLroZdpAwtv3vo4nEoxeuGFbKTGx3Qkf0CgYEA
-xyR+dcb05Ygm3w4klHQTowQ10s1H80iaUcZBgQuR1ghEtDbUPZHsoR5t1xCB02ys
-DgAwLv1bChIvxvH/L6KM8ovZ2LekBX4AviWxoBxJnfz/EVau98B0b1auRN6eSC83
-FRuGldlSOW1z/nSh8ViizSYE5H5HX1qkXEippvFRE88CgYB3Bfu3YQY60ITWIShv
-nNkdcbTT9eoP9suaRJjw92Ln+7ZpALYlQMKUZmJ/5uBmLs4RFwUTQruLOPL4yLTH
-awADWUzs3IRr1fwn9E+zM8JVyKCnUEM3w4N5UZskGO2klashAd30hWO+knRv/y0r
-uGIYs9Ek7YXlXIRVrzMwcsrt1w==
------END PRIVATE KEY-----
\ No newline at end of file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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 1528ef719a..3f292fed8b 100644
--- a/test/js/third_party/grpc-js/fixtures/server1.pem
+++ b/test/js/third_party/grpc-js/fixtures/server1.pem
@@ -1,22 +1,33 @@
 -----BEGIN CERTIFICATE-----
-MIIDtDCCApygAwIBAgIUbJfTREJ6k6/+oInWhV1O1j3ZT0IwDQYJKoZIhvcNAQEL
-BQAwVjELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
-GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDEPMA0GA1UEAwwGdGVzdGNhMB4XDTIw
-MDMxODAzMTA0MloXDTMwMDMxNjAzMTA0MlowZTELMAkGA1UEBhMCVVMxETAPBgNV
-BAgMCElsbGlub2lzMRAwDgYDVQQHDAdDaGljYWdvMRUwEwYDVQQKDAxFeGFtcGxl
-LCBDby4xGjAYBgNVBAMMESoudGVzdC5nb29nbGUuY29tMIIBIjANBgkqhkiG9w0B
-AQEFAAOCAQ8AMIIBCgKCAQEA5xOONxJJ8b8Qauvob5/7dPYZfIcd+uhAWL2ZlTPz
-Qvu4oF0QI4iYgP5iGgry9zEtCM+YQS8UhiAlPlqa6ANxgiBSEyMHH/xE8lo/+caY
-GeACqy640Jpl/JocFGo3xd1L8DCawjlaj6eu7T7T/tpAV2qq13b5710eNRbCAfFe
-8yALiGQemx0IYhlZXNbIGWLBNhBhvVjJh7UvOqpADk4xtl8o5j0xgMIRg6WJGK6c
-6ffSIg4eP1XmovNYZ9LLEJG68tF0Q/yIN43B4dt1oq4jzSdCbG4F1EiykT2TmwPV
-YDi8tml6DfOCDGnit8svnMEmBv/fcPd31GSbXjF8M+KGGQIDAQABo2swaTAJBgNV
-HRMEAjAAMAsGA1UdDwQEAwIF4DBPBgNVHREESDBGghAqLnRlc3QuZ29vZ2xlLmZy
-ghh3YXRlcnpvb2kudGVzdC5nb29nbGUuYmWCEioudGVzdC55b3V0dWJlLmNvbYcE
-wKgBAzANBgkqhkiG9w0BAQsFAAOCAQEAS8hDQA8PSgipgAml7Q3/djwQ644ghWQv
-C2Kb+r30RCY1EyKNhnQnIIh/OUbBZvh0M0iYsy6xqXgfDhCB93AA6j0i5cS8fkhH
-Jl4RK0tSkGQ3YNY4NzXwQP/vmUgfkw8VBAZ4Y4GKxppdATjffIW+srbAmdDruIRM
-wPeikgOoRrXf0LA1fi4TqxARzeRwenQpayNfGHTvVF9aJkl8HoaMunTAdG5pIVcr
-9GKi/gEMpXUJbbVv3U5frX1Wo4CFo+rZWJ/LyCMeb0jciNLxSdMwj/E/ZuExlyeZ
-gc9ctPjSMvgSyXEKv6Vwobleeg88V2ZgzenziORoWj4KszG/lbQZvg==
------END CERTIFICATE-----
\ No newline at end of file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=
+-----END CERTIFICATE-----
diff --git a/test/js/third_party/grpc-js/fixtures/test_service.proto b/test/js/third_party/grpc-js/fixtures/test_service.proto
index 64ce0d3783..2a7a303f33 100644
--- a/test/js/third_party/grpc-js/fixtures/test_service.proto
+++ b/test/js/third_party/grpc-js/fixtures/test_service.proto
@@ -21,6 +21,7 @@ message Request {
   bool error = 1;
   string message = 2;
   int32 errorAfter = 3;
+  int32 responseLength = 4;
 }
 
 message Response {
diff --git a/test/js/third_party/grpc-js/generated/Request.ts b/test/js/third_party/grpc-js/generated/Request.ts
new file mode 100644
index 0000000000..d64ebb6ea7
--- /dev/null
+++ b/test/js/third_party/grpc-js/generated/Request.ts
@@ -0,0 +1,14 @@
+// Original file: test/fixtures/test_service.proto
+
+
+export interface Request {
+  'error'?: (boolean);
+  'message'?: (string);
+  'errorAfter'?: (number);
+}
+
+export interface Request__Output {
+  'error': (boolean);
+  'message': (string);
+  'errorAfter': (number);
+}
diff --git a/test/js/third_party/grpc-js/generated/Response.ts b/test/js/third_party/grpc-js/generated/Response.ts
new file mode 100644
index 0000000000..465ab7203a
--- /dev/null
+++ b/test/js/third_party/grpc-js/generated/Response.ts
@@ -0,0 +1,12 @@
+// Original file: test/fixtures/test_service.proto
+
+
+export interface Response {
+  'count'?: (number);
+  'message'?: (string);
+}
+
+export interface Response__Output {
+  'count': (number);
+  'message': (string);
+}
diff --git a/test/js/third_party/grpc-js/generated/TestService.ts b/test/js/third_party/grpc-js/generated/TestService.ts
new file mode 100644
index 0000000000..e477c99b58
--- /dev/null
+++ b/test/js/third_party/grpc-js/generated/TestService.ts
@@ -0,0 +1,55 @@
+// Original file: test/fixtures/test_service.proto
+
+import type * as grpc from './../../src/index'
+import type { MethodDefinition } from '@grpc/proto-loader'
+import type { Request as _Request, Request__Output as _Request__Output } from './Request';
+import type { Response as _Response, Response__Output as _Response__Output } from './Response';
+
+export interface TestServiceClient extends grpc.Client {
+  BidiStream(metadata: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientDuplexStream<_Request, _Response__Output>;
+  BidiStream(options?: grpc.CallOptions): grpc.ClientDuplexStream<_Request, _Response__Output>;
+  bidiStream(metadata: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientDuplexStream<_Request, _Response__Output>;
+  bidiStream(options?: grpc.CallOptions): grpc.ClientDuplexStream<_Request, _Response__Output>;
+  
+  ClientStream(metadata: grpc.Metadata, options: grpc.CallOptions, callback: grpc.requestCallback<_Response__Output>): grpc.ClientWritableStream<_Request>;
+  ClientStream(metadata: grpc.Metadata, callback: grpc.requestCallback<_Response__Output>): grpc.ClientWritableStream<_Request>;
+  ClientStream(options: grpc.CallOptions, callback: grpc.requestCallback<_Response__Output>): grpc.ClientWritableStream<_Request>;
+  ClientStream(callback: grpc.requestCallback<_Response__Output>): grpc.ClientWritableStream<_Request>;
+  clientStream(metadata: grpc.Metadata, options: grpc.CallOptions, callback: grpc.requestCallback<_Response__Output>): grpc.ClientWritableStream<_Request>;
+  clientStream(metadata: grpc.Metadata, callback: grpc.requestCallback<_Response__Output>): grpc.ClientWritableStream<_Request>;
+  clientStream(options: grpc.CallOptions, callback: grpc.requestCallback<_Response__Output>): grpc.ClientWritableStream<_Request>;
+  clientStream(callback: grpc.requestCallback<_Response__Output>): grpc.ClientWritableStream<_Request>;
+  
+  ServerStream(argument: _Request, metadata: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientReadableStream<_Response__Output>;
+  ServerStream(argument: _Request, options?: grpc.CallOptions): grpc.ClientReadableStream<_Response__Output>;
+  serverStream(argument: _Request, metadata: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientReadableStream<_Response__Output>;
+  serverStream(argument: _Request, options?: grpc.CallOptions): grpc.ClientReadableStream<_Response__Output>;
+  
+  Unary(argument: _Request, metadata: grpc.Metadata, options: grpc.CallOptions, callback: grpc.requestCallback<_Response__Output>): grpc.ClientUnaryCall;
+  Unary(argument: _Request, metadata: grpc.Metadata, callback: grpc.requestCallback<_Response__Output>): grpc.ClientUnaryCall;
+  Unary(argument: _Request, options: grpc.CallOptions, callback: grpc.requestCallback<_Response__Output>): grpc.ClientUnaryCall;
+  Unary(argument: _Request, callback: grpc.requestCallback<_Response__Output>): grpc.ClientUnaryCall;
+  unary(argument: _Request, metadata: grpc.Metadata, options: grpc.CallOptions, callback: grpc.requestCallback<_Response__Output>): grpc.ClientUnaryCall;
+  unary(argument: _Request, metadata: grpc.Metadata, callback: grpc.requestCallback<_Response__Output>): grpc.ClientUnaryCall;
+  unary(argument: _Request, options: grpc.CallOptions, callback: grpc.requestCallback<_Response__Output>): grpc.ClientUnaryCall;
+  unary(argument: _Request, callback: grpc.requestCallback<_Response__Output>): grpc.ClientUnaryCall;
+  
+}
+
+export interface TestServiceHandlers extends grpc.UntypedServiceImplementation {
+  BidiStream: grpc.handleBidiStreamingCall<_Request__Output, _Response>;
+  
+  ClientStream: grpc.handleClientStreamingCall<_Request__Output, _Response>;
+  
+  ServerStream: grpc.handleServerStreamingCall<_Request__Output, _Response>;
+  
+  Unary: grpc.handleUnaryCall<_Request__Output, _Response>;
+  
+}
+
+export interface TestServiceDefinition extends grpc.ServiceDefinition {
+  BidiStream: MethodDefinition<_Request, _Response, _Request__Output, _Response__Output>
+  ClientStream: MethodDefinition<_Request, _Response, _Request__Output, _Response__Output>
+  ServerStream: MethodDefinition<_Request, _Response, _Request__Output, _Response__Output>
+  Unary: MethodDefinition<_Request, _Response, _Request__Output, _Response__Output>
+}
diff --git a/test/js/third_party/grpc-js/generated/test_service.ts b/test/js/third_party/grpc-js/generated/test_service.ts
new file mode 100644
index 0000000000..364acddeb7
--- /dev/null
+++ b/test/js/third_party/grpc-js/generated/test_service.ts
@@ -0,0 +1,15 @@
+import type * as grpc from '../../src/index';
+import type { MessageTypeDefinition } from '@grpc/proto-loader';
+
+import type { TestServiceClient as _TestServiceClient, TestServiceDefinition as _TestServiceDefinition } from './TestService';
+
+type SubtypeConstructor<Constructor extends new (...args: any) => any, Subtype> = {
+  new(...args: ConstructorParameters<Constructor>): Subtype;
+};
+
+export interface ProtoGrpcType {
+  Request: MessageTypeDefinition
+  Response: MessageTypeDefinition
+  TestService: SubtypeConstructor<typeof grpc.Client, _TestServiceClient> & { service: _TestServiceDefinition }
+}
+
diff --git a/test/js/third_party/grpc-js/test-call-credentials.test.ts b/test/js/third_party/grpc-js/test-call-credentials.test.ts
new file mode 100644
index 0000000000..54fb1e11ca
--- /dev/null
+++ b/test/js/third_party/grpc-js/test-call-credentials.test.ts
@@ -0,0 +1,122 @@
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import assert from "node:assert";
+import * as grpc from "@grpc/grpc-js";
+
+const { Metadata, CallCredentials } = grpc;
+
+// Metadata generators
+
+function makeAfterMsElapsedGenerator(ms: number) {
+  return (options, cb) => {
+    const metadata = new Metadata();
+    metadata.add("msElapsed", `${ms}`);
+    setTimeout(() => cb(null, metadata), ms);
+  };
+}
+
+const generateFromServiceURL = (options, cb) => {
+  const metadata: Metadata = new Metadata();
+  metadata.add("service_url", options.service_url);
+  cb(null, metadata);
+};
+const generateWithError = (options, cb) => cb(new Error());
+
+// Tests
+
+describe("CallCredentials", () => {
+  describe("createFromMetadataGenerator", () => {
+    it("should accept a metadata generator", () => {
+      assert.doesNotThrow(() => CallCredentials.createFromMetadataGenerator(generateFromServiceURL));
+    });
+  });
+
+  describe("compose", () => {
+    it("should accept a CallCredentials object and return a new object", () => {
+      const callCredentials1 = CallCredentials.createFromMetadataGenerator(generateFromServiceURL);
+      const callCredentials2 = CallCredentials.createFromMetadataGenerator(generateFromServiceURL);
+      const combinedCredentials = callCredentials1.compose(callCredentials2);
+      assert.notStrictEqual(combinedCredentials, callCredentials1);
+      assert.notStrictEqual(combinedCredentials, callCredentials2);
+    });
+
+    it("should be chainable", () => {
+      const callCredentials1 = CallCredentials.createFromMetadataGenerator(generateFromServiceURL);
+      const callCredentials2 = CallCredentials.createFromMetadataGenerator(generateFromServiceURL);
+      assert.doesNotThrow(() => {
+        callCredentials1.compose(callCredentials2).compose(callCredentials2).compose(callCredentials2);
+      });
+    });
+  });
+
+  describe("generateMetadata", () => {
+    it("should call the function passed to createFromMetadataGenerator", async () => {
+      const callCredentials = CallCredentials.createFromMetadataGenerator(generateFromServiceURL);
+      const metadata: Metadata = await callCredentials.generateMetadata({
+        method_name: "bar",
+        service_url: "foo",
+      });
+
+      assert.deepStrictEqual(metadata.get("service_url"), ["foo"]);
+    });
+
+    it("should emit an error if the associated metadataGenerator does", async () => {
+      const callCredentials = CallCredentials.createFromMetadataGenerator(generateWithError);
+      let metadata: Metadata | null = null;
+      try {
+        metadata = await callCredentials.generateMetadata({ method_name: "", service_url: "" });
+      } catch (err) {
+        assert.ok(err instanceof Error);
+      }
+      assert.strictEqual(metadata, null);
+    });
+
+    it("should combine metadata from multiple generators", async () => {
+      const [callCreds1, callCreds2, callCreds3, callCreds4] = [50, 100, 150, 200].map(ms => {
+        const generator = makeAfterMsElapsedGenerator(ms);
+        return CallCredentials.createFromMetadataGenerator(generator);
+      });
+      const testCases = [
+        {
+          credentials: callCreds1.compose(callCreds2).compose(callCreds3).compose(callCreds4),
+          expected: ["50", "100", "150", "200"],
+        },
+        {
+          credentials: callCreds4.compose(callCreds3.compose(callCreds2.compose(callCreds1))),
+          expected: ["200", "150", "100", "50"],
+        },
+        {
+          credentials: callCreds3.compose(callCreds4.compose(callCreds1).compose(callCreds2)),
+          expected: ["150", "200", "50", "100"],
+        },
+      ];
+      // Try each test case and make sure the msElapsed field is as expected
+      await Promise.all(
+        testCases.map(async testCase => {
+          const { credentials, expected } = testCase;
+          const metadata: Metadata = await credentials.generateMetadata({
+            method_name: "",
+            service_url: "",
+          });
+
+          assert.deepStrictEqual(metadata.get("msElapsed"), expected);
+        }),
+      );
+    });
+  });
+});
diff --git a/test/js/third_party/grpc-js/test-call-propagation.test.ts b/test/js/third_party/grpc-js/test-call-propagation.test.ts
new file mode 100644
index 0000000000..8da165c1d8
--- /dev/null
+++ b/test/js/third_party/grpc-js/test-call-propagation.test.ts
@@ -0,0 +1,272 @@
+/*
+ * Copyright 2020 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import assert from "node:assert";
+import grpc from "@grpc/grpc-js";
+import { loadProtoFile } from "./common.ts";
+import { afterAll, beforeAll, describe, it, afterEach } from "bun:test";
+
+function multiDone(done: () => void, target: number) {
+  let count = 0;
+  return () => {
+    count++;
+    if (count >= target) {
+      done();
+    }
+  };
+}
+
+describe("Call propagation", () => {
+  let server: grpc.Server;
+  let Client;
+  let client;
+  let proxyServer: grpc.Server;
+  let proxyClient;
+
+  beforeAll(done => {
+    Client = loadProtoFile(__dirname + "/fixtures/test_service.proto").TestService;
+    server = new grpc.Server();
+    server.addService(Client.service, {
+      unary: () => {},
+      clientStream: () => {},
+      serverStream: () => {},
+      bidiStream: () => {},
+    });
+    proxyServer = new grpc.Server();
+    server.bindAsync("localhost:0", grpc.ServerCredentials.createInsecure(), (error, port) => {
+      if (error) {
+        done(error);
+        return;
+      }
+      server.start();
+      client = new Client(`localhost:${port}`, grpc.credentials.createInsecure());
+      proxyServer.bindAsync("localhost:0", grpc.ServerCredentials.createInsecure(), (error, proxyPort) => {
+        if (error) {
+          done(error);
+          return;
+        }
+        proxyServer.start();
+        proxyClient = new Client(`localhost:${proxyPort}`, grpc.credentials.createInsecure());
+        done();
+      });
+    });
+  });
+  afterEach(() => {
+    proxyServer.removeService(Client.service);
+  });
+  afterAll(() => {
+    server.forceShutdown();
+    proxyServer.forceShutdown();
+  });
+  describe("Cancellation", () => {
+    it.todo("should work with unary requests", done => {
+      done = multiDone(done, 2);
+      // eslint-disable-next-line prefer-const
+      let call: grpc.ClientUnaryCall;
+      proxyServer.addService(Client.service, {
+        unary: (parent: grpc.ServerUnaryCall<any, any>, callback: grpc.sendUnaryData<any>) => {
+          client.unary(parent.request, { parent: parent }, (error: grpc.ServiceError, value: unknown) => {
+            callback(error, value);
+            assert(error);
+            assert.strictEqual(error.code, grpc.status.CANCELLED);
+            done();
+          });
+          /* Cancel the original call after the server starts processing it to
+           * ensure that it does reach the server. */
+          call.cancel();
+        },
+      });
+      call = proxyClient.unary({}, (error: grpc.ServiceError, value: unknown) => {
+        assert(error);
+        assert.strictEqual(error.code, grpc.status.CANCELLED);
+        done();
+      });
+    });
+    it("Should work with client streaming requests", done => {
+      done = multiDone(done, 2);
+      // eslint-disable-next-line prefer-const
+      let call: grpc.ClientWritableStream<unknown>;
+      proxyServer.addService(Client.service, {
+        clientStream: (parent: grpc.ServerReadableStream<any, any>, callback: grpc.sendUnaryData<any>) => {
+          client.clientStream({ parent: parent }, (error: grpc.ServiceError, value: unknown) => {
+            callback(error, value);
+            assert(error);
+            assert.strictEqual(error.code, grpc.status.CANCELLED);
+            done();
+          });
+          /* Cancel the original call after the server starts processing it to
+           * ensure that it does reach the server. */
+          call.cancel();
+        },
+      });
+      call = proxyClient.clientStream((error: grpc.ServiceError, value: unknown) => {
+        assert(error);
+        assert.strictEqual(error.code, grpc.status.CANCELLED);
+        done();
+      });
+    });
+    it.todo("Should work with server streaming requests", done => {
+      done = multiDone(done, 2);
+      // eslint-disable-next-line prefer-const
+      let call: grpc.ClientReadableStream<unknown>;
+      proxyServer.addService(Client.service, {
+        serverStream: (parent: grpc.ServerWritableStream<any, any>) => {
+          const child = client.serverStream(parent.request, { parent: parent });
+          child.on("error", () => {});
+          child.on("status", (status: grpc.StatusObject) => {
+            assert.strictEqual(status.code, grpc.status.CANCELLED);
+            done();
+          });
+          call.cancel();
+        },
+      });
+      call = proxyClient.serverStream({});
+      call.on("error", () => {});
+      call.on("status", (status: grpc.StatusObject) => {
+        assert.strictEqual(status.code, grpc.status.CANCELLED);
+        done();
+      });
+    });
+    it("Should work with bidi streaming requests", done => {
+      done = multiDone(done, 2);
+      // eslint-disable-next-line prefer-const
+      let call: grpc.ClientDuplexStream<unknown, unknown>;
+      proxyServer.addService(Client.service, {
+        bidiStream: (parent: grpc.ServerDuplexStream<any, any>) => {
+          const child = client.bidiStream({ parent: parent });
+          child.on("error", () => {});
+          child.on("status", (status: grpc.StatusObject) => {
+            assert.strictEqual(status.code, grpc.status.CANCELLED);
+            done();
+          });
+          call.cancel();
+        },
+      });
+      call = proxyClient.bidiStream();
+      call.on("error", () => {});
+      call.on("status", (status: grpc.StatusObject) => {
+        assert.strictEqual(status.code, grpc.status.CANCELLED);
+        done();
+      });
+    });
+  });
+  describe("Deadlines", () => {
+    it("should work with unary requests", done => {
+      done = multiDone(done, 2);
+      proxyServer.addService(Client.service, {
+        unary: (parent: grpc.ServerUnaryCall<any, any>, callback: grpc.sendUnaryData<any>) => {
+          client.unary(
+            parent.request,
+            { parent: parent, propagate_flags: grpc.propagate.DEADLINE },
+            (error: grpc.ServiceError, value: unknown) => {
+              callback(error, value);
+              assert(error);
+              assert.strictEqual(error.code, grpc.status.DEADLINE_EXCEEDED);
+              done();
+            },
+          );
+        },
+      });
+      const deadline = new Date();
+      deadline.setMilliseconds(deadline.getMilliseconds() + 100);
+      proxyClient.unary({}, { deadline }, (error: grpc.ServiceError, value: unknown) => {
+        assert(error);
+        assert.strictEqual(error.code, grpc.status.DEADLINE_EXCEEDED);
+        done();
+      });
+    });
+    it("Should work with client streaming requests", done => {
+      done = multiDone(done, 2);
+
+      proxyServer.addService(Client.service, {
+        clientStream: (parent: grpc.ServerReadableStream<any, any>, callback: grpc.sendUnaryData<any>) => {
+          client.clientStream(
+            { parent: parent, propagate_flags: grpc.propagate.DEADLINE },
+            (error: grpc.ServiceError, value: unknown) => {
+              callback(error, value);
+              assert(error);
+              assert.strictEqual(error.code, grpc.status.DEADLINE_EXCEEDED);
+              done();
+            },
+          );
+        },
+      });
+      const deadline = new Date();
+      deadline.setMilliseconds(deadline.getMilliseconds() + 100);
+      proxyClient.clientStream(
+        { deadline, propagate_flags: grpc.propagate.DEADLINE },
+        (error: grpc.ServiceError, value: unknown) => {
+          assert(error);
+          assert.strictEqual(error.code, grpc.status.DEADLINE_EXCEEDED);
+          done();
+        },
+      );
+    });
+    it("Should work with server streaming requests", done => {
+      done = multiDone(done, 2);
+      let call: grpc.ClientReadableStream<unknown>;
+      proxyServer.addService(Client.service, {
+        serverStream: (parent: grpc.ServerWritableStream<any, any>) => {
+          const child = client.serverStream(parent.request, {
+            parent: parent,
+            propagate_flags: grpc.propagate.DEADLINE,
+          });
+          child.on("error", () => {});
+          child.on("status", (status: grpc.StatusObject) => {
+            assert.strictEqual(status.code, grpc.status.DEADLINE_EXCEEDED);
+            done();
+          });
+        },
+      });
+      const deadline = new Date();
+      deadline.setMilliseconds(deadline.getMilliseconds() + 100);
+      // eslint-disable-next-line prefer-const
+      call = proxyClient.serverStream({}, { deadline });
+      call.on("error", () => {});
+      call.on("status", (status: grpc.StatusObject) => {
+        assert.strictEqual(status.code, grpc.status.DEADLINE_EXCEEDED);
+        done();
+      });
+    });
+    it("Should work with bidi streaming requests", done => {
+      done = multiDone(done, 2);
+      let call: grpc.ClientDuplexStream<unknown, unknown>;
+      proxyServer.addService(Client.service, {
+        bidiStream: (parent: grpc.ServerDuplexStream<any, any>) => {
+          const child = client.bidiStream({
+            parent: parent,
+            propagate_flags: grpc.propagate.DEADLINE,
+          });
+          child.on("error", () => {});
+          child.on("status", (status: grpc.StatusObject) => {
+            assert.strictEqual(status.code, grpc.status.DEADLINE_EXCEEDED);
+            done();
+          });
+        },
+      });
+      const deadline = new Date();
+      deadline.setMilliseconds(deadline.getMilliseconds() + 100);
+      // eslint-disable-next-line prefer-const
+      call = proxyClient.bidiStream({ deadline });
+      call.on("error", () => {});
+      call.on("status", (status: grpc.StatusObject) => {
+        assert.strictEqual(status.code, grpc.status.DEADLINE_EXCEEDED);
+        done();
+      });
+    });
+  });
+});
diff --git a/test/js/third_party/grpc-js/test-certificate-provider.test.ts b/test/js/third_party/grpc-js/test-certificate-provider.test.ts
new file mode 100644
index 0000000000..6a69185f75
--- /dev/null
+++ b/test/js/third_party/grpc-js/test-certificate-provider.test.ts
@@ -0,0 +1,160 @@
+/*
+ * Copyright 2024 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import assert from "node:assert";
+import * as path from "path";
+import * as fs from "fs/promises";
+import * as grpc from "@grpc/grpc-js";
+import { beforeAll, describe, it } from "bun:test";
+const { experimental } = grpc;
+describe("Certificate providers", () => {
+  describe("File watcher", () => {
+    const [caPath, keyPath, certPath] = ["ca.pem", "server1.key", "server1.pem"].map(file =>
+      path.join(__dirname, "fixtures", file),
+    );
+    let caData: Buffer, keyData: Buffer, certData: Buffer;
+    beforeAll(async () => {
+      [caData, keyData, certData] = await Promise.all(
+        [caPath, keyPath, certPath].map(filePath => fs.readFile(filePath)),
+      );
+    });
+    it("Should reject a config with no files", () => {
+      const config: experimental.FileWatcherCertificateProviderConfig = {
+        refreshIntervalMs: 1000,
+      };
+      assert.throws(() => {
+        new experimental.FileWatcherCertificateProvider(config);
+      });
+    });
+    it("Should accept a config with just a CA certificate", () => {
+      const config: experimental.FileWatcherCertificateProviderConfig = {
+        caCertificateFile: caPath,
+        refreshIntervalMs: 1000,
+      };
+      assert.doesNotThrow(() => {
+        new experimental.FileWatcherCertificateProvider(config);
+      });
+    });
+    it("Should accept a config with just a key and certificate", () => {
+      const config: experimental.FileWatcherCertificateProviderConfig = {
+        certificateFile: certPath,
+        privateKeyFile: keyPath,
+        refreshIntervalMs: 1000,
+      };
+      assert.doesNotThrow(() => {
+        new experimental.FileWatcherCertificateProvider(config);
+      });
+    });
+    it("Should accept a config with all files", () => {
+      const config: experimental.FileWatcherCertificateProviderConfig = {
+        caCertificateFile: caPath,
+        certificateFile: certPath,
+        privateKeyFile: keyPath,
+        refreshIntervalMs: 1000,
+      };
+      assert.doesNotThrow(() => {
+        new experimental.FileWatcherCertificateProvider(config);
+      });
+    });
+    it("Should reject a config with a key but no certificate", () => {
+      const config: experimental.FileWatcherCertificateProviderConfig = {
+        caCertificateFile: caPath,
+        privateKeyFile: keyPath,
+        refreshIntervalMs: 1000,
+      };
+      assert.throws(() => {
+        new experimental.FileWatcherCertificateProvider(config);
+      });
+    });
+    it("Should reject a config with a certificate but no key", () => {
+      const config: experimental.FileWatcherCertificateProviderConfig = {
+        caCertificateFile: caPath,
+        privateKeyFile: keyPath,
+        refreshIntervalMs: 1000,
+      };
+      assert.throws(() => {
+        new experimental.FileWatcherCertificateProvider(config);
+      });
+    });
+    it("Should find the CA file when configured for it", done => {
+      const config: experimental.FileWatcherCertificateProviderConfig = {
+        caCertificateFile: caPath,
+        refreshIntervalMs: 1000,
+      };
+      const provider = new experimental.FileWatcherCertificateProvider(config);
+      const listener: experimental.CaCertificateUpdateListener = update => {
+        if (update) {
+          provider.removeCaCertificateListener(listener);
+          assert(update.caCertificate.equals(caData));
+          done();
+        }
+      };
+      provider.addCaCertificateListener(listener);
+    });
+    it("Should find the identity certificate files when configured for it", done => {
+      const config: experimental.FileWatcherCertificateProviderConfig = {
+        certificateFile: certPath,
+        privateKeyFile: keyPath,
+        refreshIntervalMs: 1000,
+      };
+      const provider = new experimental.FileWatcherCertificateProvider(config);
+      const listener: experimental.IdentityCertificateUpdateListener = update => {
+        if (update) {
+          provider.removeIdentityCertificateListener(listener);
+          assert(update.certificate.equals(certData));
+          assert(update.privateKey.equals(keyData));
+          done();
+        }
+      };
+      provider.addIdentityCertificateListener(listener);
+    });
+    it("Should find all files when configured for it", done => {
+      const config: experimental.FileWatcherCertificateProviderConfig = {
+        caCertificateFile: caPath,
+        certificateFile: certPath,
+        privateKeyFile: keyPath,
+        refreshIntervalMs: 1000,
+      };
+      const provider = new experimental.FileWatcherCertificateProvider(config);
+      let seenCaUpdate = false;
+      let seenIdentityUpdate = false;
+      const caListener: experimental.CaCertificateUpdateListener = update => {
+        if (update) {
+          provider.removeCaCertificateListener(caListener);
+          assert(update.caCertificate.equals(caData));
+          seenCaUpdate = true;
+          if (seenIdentityUpdate) {
+            done();
+          }
+        }
+      };
+      const identityListener: experimental.IdentityCertificateUpdateListener = update => {
+        if (update) {
+          provider.removeIdentityCertificateListener(identityListener);
+          assert(update.certificate.equals(certData));
+          assert(update.privateKey.equals(keyData));
+          seenIdentityUpdate = true;
+          if (seenCaUpdate) {
+            done();
+          }
+        }
+      };
+      provider.addCaCertificateListener(caListener);
+      provider.addIdentityCertificateListener(identityListener);
+    });
+  });
+});
diff --git a/test/js/third_party/grpc-js/test-channel-credentials.test.ts b/test/js/third_party/grpc-js/test-channel-credentials.test.ts
index 99dd5b8a71..ff6588ea57 100644
--- a/test/js/third_party/grpc-js/test-channel-credentials.test.ts
+++ b/test/js/third_party/grpc-js/test-channel-credentials.test.ts
@@ -15,33 +15,164 @@
  *
  */
 
-import * as grpc from "@grpc/grpc-js";
-import { Client, ServiceError } from "@grpc/grpc-js";
-import assert from "assert";
-import { afterAll, beforeAll, describe, it } from "bun:test";
-import * as assert2 from "./assert2";
-import { TestClient, TestServer, ca } from "./common";
+import * as fs from "fs";
+import * as path from "path";
+import { promisify } from "util";
+
+import assert from "node:assert";
+import grpc, { sendUnaryData, ServerUnaryCall, ServiceError } from "@grpc/grpc-js";
+import { afterAll, beforeAll, describe, it, afterEach, beforeEach } from "bun:test";
+import { CallCredentials } from "@grpc/grpc-js/build/src/call-credentials";
+import { ChannelCredentials } from "@grpc/grpc-js/build/src/channel-credentials";
+import { ServiceClient, ServiceClientConstructor } from "@grpc/grpc-js/build/src/make-client";
+
+import { assert2, loadProtoFile, mockFunction } from "./common";
+
+const protoFile = path.join(__dirname, "fixtures", "echo_service.proto");
+const echoService = loadProtoFile(protoFile).EchoService as ServiceClientConstructor;
+
+class CallCredentialsMock implements CallCredentials {
+  child: CallCredentialsMock | null = null;
+  constructor(child?: CallCredentialsMock) {
+    if (child) {
+      this.child = child;
+    }
+  }
+
+  generateMetadata = mockFunction;
+
+  compose(callCredentials: CallCredentialsMock): CallCredentialsMock {
+    return new CallCredentialsMock(callCredentials);
+  }
+
+  _equals(other: CallCredentialsMock): boolean {
+    if (!this.child) {
+      return this === other;
+    } else if (!other || !other.child) {
+      return false;
+    } else {
+      return this.child._equals(other.child);
+    }
+  }
+}
+
+// tslint:disable-next-line:no-any
+const readFile: (...args: any[]) => Promise<Buffer> = promisify(fs.readFile);
+// A promise which resolves to loaded files in the form { ca, key, cert }
+const pFixtures = Promise.all(
+  ["ca.pem", "server1.key", "server1.pem"].map(file => readFile(`${__dirname}/fixtures/${file}`)),
+).then(result => {
+  return { ca: result[0], key: result[1], cert: result[2] };
+});
+
+describe("ChannelCredentials Implementation", () => {
+  describe("createInsecure", () => {
+    it("should return a ChannelCredentials object with no associated secure context", () => {
+      const creds = assert2.noThrowAndReturn(() => ChannelCredentials.createInsecure());
+      assert.ok(!creds._getConnectionOptions()?.secureContext);
+    });
+  });
+
+  describe("createSsl", () => {
+    it("should work when given no arguments", () => {
+      const creds: ChannelCredentials = assert2.noThrowAndReturn(() => ChannelCredentials.createSsl());
+      assert.ok(!!creds._getConnectionOptions());
+    });
+
+    it("should work with just a CA override", async () => {
+      const { ca } = await pFixtures;
+      const creds = assert2.noThrowAndReturn(() => ChannelCredentials.createSsl(ca));
+      assert.ok(!!creds._getConnectionOptions());
+    });
+
+    it("should work with just a private key and cert chain", async () => {
+      const { key, cert } = await pFixtures;
+      const creds = assert2.noThrowAndReturn(() => ChannelCredentials.createSsl(null, key, cert));
+      assert.ok(!!creds._getConnectionOptions());
+    });
+
+    it("should work with three parameters specified", async () => {
+      const { ca, key, cert } = await pFixtures;
+      const creds = assert2.noThrowAndReturn(() => ChannelCredentials.createSsl(ca, key, cert));
+      assert.ok(!!creds._getConnectionOptions());
+    });
+
+    it("should throw if just one of private key and cert chain are missing", async () => {
+      const { ca, key, cert } = await pFixtures;
+      assert.throws(() => ChannelCredentials.createSsl(ca, key));
+      assert.throws(() => ChannelCredentials.createSsl(ca, key, null));
+      assert.throws(() => ChannelCredentials.createSsl(ca, null, cert));
+      assert.throws(() => ChannelCredentials.createSsl(null, key));
+      assert.throws(() => ChannelCredentials.createSsl(null, key, null));
+      assert.throws(() => ChannelCredentials.createSsl(null, null, cert));
+    });
+  });
+
+  describe("compose", () => {
+    it("should return a ChannelCredentials object", () => {
+      const channelCreds = ChannelCredentials.createSsl();
+      const callCreds = new CallCredentialsMock();
+      const composedChannelCreds = channelCreds.compose(callCreds);
+      assert.strictEqual(composedChannelCreds._getCallCredentials(), callCreds);
+    });
+
+    it("should be chainable", () => {
+      const callCreds1 = new CallCredentialsMock();
+      const callCreds2 = new CallCredentialsMock();
+      // Associate both call credentials with channelCreds
+      const composedChannelCreds = ChannelCredentials.createSsl().compose(callCreds1).compose(callCreds2);
+      // Build a mock object that should be an identical copy
+      const composedCallCreds = callCreds1.compose(callCreds2);
+      assert.ok(composedCallCreds._equals(composedChannelCreds._getCallCredentials() as CallCredentialsMock));
+    });
+  });
+});
+
 describe("ChannelCredentials usage", () => {
-  let client: Client;
-  let server: TestServer;
-  beforeAll(async () => {
-    const channelCreds = grpc.ChannelCredentials.createSsl(ca);
-    const callCreds = grpc.CallCredentials.createFromMetadataGenerator((options: any, cb: Function) => {
+  let client: ServiceClient;
+  let server: grpc.Server;
+  let portNum: number;
+  let caCert: Buffer;
+  const hostnameOverride = "foo.test.google.fr";
+  beforeEach(async () => {
+    const { ca, key, cert } = await pFixtures;
+    caCert = ca;
+    const serverCreds = grpc.ServerCredentials.createSsl(null, [{ private_key: key, cert_chain: cert }]);
+    const channelCreds = ChannelCredentials.createSsl(ca);
+    const callCreds = CallCredentials.createFromMetadataGenerator((options, cb) => {
       const metadata = new grpc.Metadata();
       metadata.set("test-key", "test-value");
+
       cb(null, metadata);
     });
     const combinedCreds = channelCreds.compose(callCreds);
-    server = new TestServer(true);
-    await server.start();
-    //@ts-ignore
-    client = TestClient.createFromServerWithCredentials(server, combinedCreds, {
-      "grpc.ssl_target_name_override": "foo.test.google.fr",
-      "grpc.default_authority": "foo.test.google.fr",
+    return new Promise<void>((resolve, reject) => {
+      server = new grpc.Server();
+      server.addService(echoService.service, {
+        echo(call: ServerUnaryCall<any, any>, callback: sendUnaryData<any>) {
+          call.sendMetadata(call.metadata);
+
+          callback(null, call.request);
+        },
+      });
+
+      server.bindAsync("127.0.0.1:0", serverCreds, (err, port) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        portNum = port;
+        client = new echoService(`127.0.0.1:${port}`, combinedCreds, {
+          "grpc.ssl_target_name_override": hostnameOverride,
+          "grpc.default_authority": hostnameOverride,
+        });
+        server.start();
+        resolve();
+      });
     });
   });
-  afterAll(() => {
-    server.shutdown();
+  afterEach(() => {
+    server.forceShutdown();
   });
 
   it("Should send the metadata from call credentials attached to channel credentials", done => {
@@ -60,4 +191,25 @@ describe("ChannelCredentials usage", () => {
     );
     assert2.afterMustCallsSatisfied(done);
   });
+
+  it.todo("Should call the checkServerIdentity callback", done => {
+    const channelCreds = ChannelCredentials.createSsl(caCert, null, null, {
+      checkServerIdentity: assert2.mustCall((hostname, cert) => {
+        assert.strictEqual(hostname, hostnameOverride);
+        return undefined;
+      }),
+    });
+    const client = new echoService(`localhost:${portNum}`, channelCreds, {
+      "grpc.ssl_target_name_override": hostnameOverride,
+      "grpc.default_authority": hostnameOverride,
+    });
+    client.echo(
+      { value: "test value", value2: 3 },
+      assert2.mustCall((error: ServiceError, response: any) => {
+        assert.ifError(error);
+        assert.deepStrictEqual(response, { value: "test value", value2: 3 });
+      }),
+    );
+    assert2.afterMustCallsSatisfied(done);
+  });
 });
diff --git a/test/js/third_party/grpc-js/test-channelz.test.ts b/test/js/third_party/grpc-js/test-channelz.test.ts
new file mode 100644
index 0000000000..9efdb895c7
--- /dev/null
+++ b/test/js/third_party/grpc-js/test-channelz.test.ts
@@ -0,0 +1,387 @@
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import assert from "node:assert";
+import * as protoLoader from "@grpc/proto-loader";
+import grpc from "@grpc/grpc-js";
+
+import { ProtoGrpcType } from "@grpc/grpc-js/build/src/generated/channelz";
+import { ChannelzClient } from "@grpc/grpc-js/build/src/generated/grpc/channelz/v1/Channelz";
+import { ServiceClient, ServiceClientConstructor } from "@grpc/grpc-js/build/src/make-client";
+import { loadProtoFile } from "./common";
+import { afterAll, beforeAll, describe, it, beforeEach, afterEach } from "bun:test";
+
+const loadedChannelzProto = protoLoader.loadSync("channelz.proto", {
+  keepCase: true,
+  longs: String,
+  enums: String,
+  defaults: true,
+  oneofs: true,
+  includeDirs: [`${__dirname}/fixtures`],
+});
+const channelzGrpcObject = grpc.loadPackageDefinition(loadedChannelzProto) as unknown as ProtoGrpcType;
+
+const TestServiceClient = loadProtoFile(`${__dirname}/fixtures/test_service.proto`)
+  .TestService as ServiceClientConstructor;
+
+const testServiceImpl: grpc.UntypedServiceImplementation = {
+  unary(call: grpc.ServerUnaryCall<any, any>, callback: grpc.sendUnaryData<any>) {
+    if (call.request.error) {
+      setTimeout(() => {
+        callback({
+          code: grpc.status.INVALID_ARGUMENT,
+          details: call.request.message,
+        });
+      }, call.request.errorAfter);
+    } else {
+      callback(null, { count: 1 });
+    }
+  },
+};
+
+describe("Channelz", () => {
+  let channelzServer: grpc.Server;
+  let channelzClient: ChannelzClient;
+  let testServer: grpc.Server;
+  let testClient: ServiceClient;
+
+  beforeAll(done => {
+    channelzServer = new grpc.Server();
+    channelzServer.addService(grpc.getChannelzServiceDefinition(), grpc.getChannelzHandlers());
+    channelzServer.bindAsync("localhost:0", grpc.ServerCredentials.createInsecure(), (error, port) => {
+      if (error) {
+        done(error);
+        return;
+      }
+      channelzServer.start();
+      channelzClient = new channelzGrpcObject.grpc.channelz.v1.Channelz(
+        `localhost:${port}`,
+        grpc.credentials.createInsecure(),
+      );
+      done();
+    });
+  });
+
+  afterAll(() => {
+    channelzClient.close();
+    channelzServer.forceShutdown();
+  });
+
+  beforeEach(done => {
+    testServer = new grpc.Server();
+    testServer.addService(TestServiceClient.service, testServiceImpl);
+    testServer.bindAsync("localhost:0", grpc.ServerCredentials.createInsecure(), (error, port) => {
+      if (error) {
+        done(error);
+        return;
+      }
+      testServer.start();
+      testClient = new TestServiceClient(`localhost:${port}`, grpc.credentials.createInsecure());
+      done();
+    });
+  });
+
+  afterEach(() => {
+    testClient.close();
+    testServer.forceShutdown();
+  });
+
+  it("should see a newly created channel", done => {
+    // Test that the specific test client channel info can be retrieved
+    channelzClient.GetChannel({ channel_id: testClient.getChannel().getChannelzRef().id }, (error, result) => {
+      assert.ifError(error);
+      assert(result);
+      assert(result.channel);
+      assert(result.channel.ref);
+      assert.strictEqual(+result.channel.ref.channel_id, testClient.getChannel().getChannelzRef().id);
+      // Test that the channel is in the list of top channels
+      channelzClient.getTopChannels(
+        {
+          start_channel_id: testClient.getChannel().getChannelzRef().id,
+          max_results: 1,
+        },
+        (error, result) => {
+          assert.ifError(error);
+          assert(result);
+          assert.strictEqual(result.channel.length, 1);
+          assert(result.channel[0].ref);
+          assert.strictEqual(+result.channel[0].ref.channel_id, testClient.getChannel().getChannelzRef().id);
+          done();
+        },
+      );
+    });
+  });
+
+  it("should see a newly created server", done => {
+    // Test that the specific test server info can be retrieved
+    channelzClient.getServer({ server_id: testServer.getChannelzRef().id }, (error, result) => {
+      assert.ifError(error);
+      assert(result);
+      assert(result.server);
+      assert(result.server.ref);
+      assert.strictEqual(+result.server.ref.server_id, testServer.getChannelzRef().id);
+      // Test that the server is in the list of servers
+      channelzClient.getServers(
+        { start_server_id: testServer.getChannelzRef().id, max_results: 1 },
+        (error, result) => {
+          assert.ifError(error);
+          assert(result);
+          assert.strictEqual(result.server.length, 1);
+          assert(result.server[0].ref);
+          assert.strictEqual(+result.server[0].ref.server_id, testServer.getChannelzRef().id);
+          done();
+        },
+      );
+    });
+  });
+
+  it("should count successful calls", done => {
+    testClient.unary({}, (error: grpc.ServiceError, value: unknown) => {
+      assert.ifError(error);
+      // Channel data tests
+      channelzClient.GetChannel({ channel_id: testClient.getChannel().getChannelzRef().id }, (error, channelResult) => {
+        assert.ifError(error);
+        assert(channelResult);
+        assert(channelResult.channel);
+        assert(channelResult.channel.ref);
+        assert(channelResult.channel.data);
+        assert.strictEqual(+channelResult.channel.data.calls_started, 1);
+        assert.strictEqual(+channelResult.channel.data.calls_succeeded, 1);
+        assert.strictEqual(+channelResult.channel.data.calls_failed, 0);
+        assert.strictEqual(channelResult.channel.subchannel_ref.length, 1);
+        channelzClient.getSubchannel(
+          {
+            subchannel_id: channelResult.channel.subchannel_ref[0].subchannel_id,
+          },
+          (error, subchannelResult) => {
+            assert.ifError(error);
+            assert(subchannelResult);
+            assert(subchannelResult.subchannel);
+            assert(subchannelResult.subchannel.ref);
+            assert(subchannelResult.subchannel.data);
+            assert.strictEqual(
+              subchannelResult.subchannel.ref.subchannel_id,
+              channelResult.channel!.subchannel_ref[0].subchannel_id,
+            );
+            assert.strictEqual(+subchannelResult.subchannel.data.calls_started, 1);
+            assert.strictEqual(+subchannelResult.subchannel.data.calls_succeeded, 1);
+            assert.strictEqual(+subchannelResult.subchannel.data.calls_failed, 0);
+            assert.strictEqual(subchannelResult.subchannel.socket_ref.length, 1);
+            channelzClient.getSocket(
+              {
+                socket_id: subchannelResult.subchannel.socket_ref[0].socket_id,
+              },
+              (error, socketResult) => {
+                assert.ifError(error);
+                assert(socketResult);
+                assert(socketResult.socket);
+                assert(socketResult.socket.ref);
+                assert(socketResult.socket.data);
+                assert.strictEqual(
+                  socketResult.socket.ref.socket_id,
+                  subchannelResult.subchannel!.socket_ref[0].socket_id,
+                );
+                assert.strictEqual(+socketResult.socket.data.streams_started, 1);
+                assert.strictEqual(+socketResult.socket.data.streams_succeeded, 1);
+                assert.strictEqual(+socketResult.socket.data.streams_failed, 0);
+                assert.strictEqual(+socketResult.socket.data.messages_received, 1);
+                assert.strictEqual(+socketResult.socket.data.messages_sent, 1);
+                // Server data tests
+                channelzClient.getServer({ server_id: testServer.getChannelzRef().id }, (error, serverResult) => {
+                  assert.ifError(error);
+                  assert(serverResult);
+                  assert(serverResult.server);
+                  assert(serverResult.server.ref);
+                  assert(serverResult.server.data);
+                  assert.strictEqual(+serverResult.server.ref.server_id, testServer.getChannelzRef().id);
+                  assert.strictEqual(+serverResult.server.data.calls_started, 1);
+                  assert.strictEqual(+serverResult.server.data.calls_succeeded, 1);
+                  assert.strictEqual(+serverResult.server.data.calls_failed, 0);
+                  channelzClient.getServerSockets(
+                    { server_id: testServer.getChannelzRef().id },
+                    (error, socketsResult) => {
+                      assert.ifError(error);
+                      assert(socketsResult);
+                      assert.strictEqual(socketsResult.socket_ref.length, 1);
+                      channelzClient.getSocket(
+                        {
+                          socket_id: socketsResult.socket_ref[0].socket_id,
+                        },
+                        (error, serverSocketResult) => {
+                          assert.ifError(error);
+                          assert(serverSocketResult);
+                          assert(serverSocketResult.socket);
+                          assert(serverSocketResult.socket.ref);
+                          assert(serverSocketResult.socket.data);
+                          assert.strictEqual(
+                            serverSocketResult.socket.ref.socket_id,
+                            socketsResult.socket_ref[0].socket_id,
+                          );
+                          assert.strictEqual(+serverSocketResult.socket.data.streams_started, 1);
+                          assert.strictEqual(+serverSocketResult.socket.data.streams_succeeded, 1);
+                          assert.strictEqual(+serverSocketResult.socket.data.streams_failed, 0);
+                          assert.strictEqual(+serverSocketResult.socket.data.messages_received, 1);
+                          assert.strictEqual(+serverSocketResult.socket.data.messages_sent, 1);
+                          done();
+                        },
+                      );
+                    },
+                  );
+                });
+              },
+            );
+          },
+        );
+      });
+    });
+  });
+
+  it("should count failed calls", done => {
+    testClient.unary({ error: true }, (error: grpc.ServiceError, value: unknown) => {
+      assert(error);
+      // Channel data tests
+      channelzClient.GetChannel({ channel_id: testClient.getChannel().getChannelzRef().id }, (error, channelResult) => {
+        assert.ifError(error);
+        assert(channelResult);
+        assert(channelResult.channel);
+        assert(channelResult.channel.ref);
+        assert(channelResult.channel.data);
+        assert.strictEqual(+channelResult.channel.data.calls_started, 1);
+        assert.strictEqual(+channelResult.channel.data.calls_succeeded, 0);
+        assert.strictEqual(+channelResult.channel.data.calls_failed, 1);
+        assert.strictEqual(channelResult.channel.subchannel_ref.length, 1);
+        channelzClient.getSubchannel(
+          {
+            subchannel_id: channelResult.channel.subchannel_ref[0].subchannel_id,
+          },
+          (error, subchannelResult) => {
+            assert.ifError(error);
+            assert(subchannelResult);
+            assert(subchannelResult.subchannel);
+            assert(subchannelResult.subchannel.ref);
+            assert(subchannelResult.subchannel.data);
+            assert.strictEqual(
+              subchannelResult.subchannel.ref.subchannel_id,
+              channelResult.channel!.subchannel_ref[0].subchannel_id,
+            );
+            assert.strictEqual(+subchannelResult.subchannel.data.calls_started, 1);
+            assert.strictEqual(+subchannelResult.subchannel.data.calls_succeeded, 0);
+            assert.strictEqual(+subchannelResult.subchannel.data.calls_failed, 1);
+            assert.strictEqual(subchannelResult.subchannel.socket_ref.length, 1);
+            channelzClient.getSocket(
+              {
+                socket_id: subchannelResult.subchannel.socket_ref[0].socket_id,
+              },
+              (error, socketResult) => {
+                assert.ifError(error);
+                assert(socketResult);
+                assert(socketResult.socket);
+                assert(socketResult.socket.ref);
+                assert(socketResult.socket.data);
+                assert.strictEqual(
+                  socketResult.socket.ref.socket_id,
+                  subchannelResult.subchannel!.socket_ref[0].socket_id,
+                );
+                assert.strictEqual(+socketResult.socket.data.streams_started, 1);
+                assert.strictEqual(+socketResult.socket.data.streams_succeeded, 1);
+                assert.strictEqual(+socketResult.socket.data.streams_failed, 0);
+                assert.strictEqual(+socketResult.socket.data.messages_received, 0);
+                assert.strictEqual(+socketResult.socket.data.messages_sent, 1);
+                // Server data tests
+                channelzClient.getServer({ server_id: testServer.getChannelzRef().id }, (error, serverResult) => {
+                  assert.ifError(error);
+                  assert(serverResult);
+                  assert(serverResult.server);
+                  assert(serverResult.server.ref);
+                  assert(serverResult.server.data);
+                  assert.strictEqual(+serverResult.server.ref.server_id, testServer.getChannelzRef().id);
+                  assert.strictEqual(+serverResult.server.data.calls_started, 1);
+                  assert.strictEqual(+serverResult.server.data.calls_succeeded, 0);
+                  assert.strictEqual(+serverResult.server.data.calls_failed, 1);
+                  channelzClient.getServerSockets(
+                    { server_id: testServer.getChannelzRef().id },
+                    (error, socketsResult) => {
+                      assert.ifError(error);
+                      assert(socketsResult);
+                      assert.strictEqual(socketsResult.socket_ref.length, 1);
+                      channelzClient.getSocket(
+                        {
+                          socket_id: socketsResult.socket_ref[0].socket_id,
+                        },
+                        (error, serverSocketResult) => {
+                          assert.ifError(error);
+                          assert(serverSocketResult);
+                          assert(serverSocketResult.socket);
+                          assert(serverSocketResult.socket.ref);
+                          assert(serverSocketResult.socket.data);
+                          assert.strictEqual(
+                            serverSocketResult.socket.ref.socket_id,
+                            socketsResult.socket_ref[0].socket_id,
+                          );
+                          assert.strictEqual(+serverSocketResult.socket.data.streams_started, 1);
+                          assert.strictEqual(+serverSocketResult.socket.data.streams_succeeded, 1);
+                          assert.strictEqual(+serverSocketResult.socket.data.streams_failed, 0);
+                          assert.strictEqual(+serverSocketResult.socket.data.messages_received, 1);
+                          assert.strictEqual(+serverSocketResult.socket.data.messages_sent, 0);
+                          done();
+                        },
+                      );
+                    },
+                  );
+                });
+              },
+            );
+          },
+        );
+      });
+    });
+  });
+});
+
+describe("Disabling channelz", () => {
+  let testServer: grpc.Server;
+  let testClient: ServiceClient;
+  beforeEach(done => {
+    testServer = new grpc.Server({ "grpc.enable_channelz": 0 });
+    testServer.addService(TestServiceClient.service, testServiceImpl);
+    testServer.bindAsync("localhost:0", grpc.ServerCredentials.createInsecure(), (error, port) => {
+      if (error) {
+        done(error);
+        return;
+      }
+      testServer.start();
+      testClient = new TestServiceClient(`localhost:${port}`, grpc.credentials.createInsecure(), {
+        "grpc.enable_channelz": 0,
+      });
+      done();
+    });
+  });
+
+  afterEach(() => {
+    testClient.close();
+    testServer.forceShutdown();
+  });
+
+  it("Should still work", done => {
+    const deadline = new Date();
+    deadline.setSeconds(deadline.getSeconds() + 1);
+    testClient.unary({}, { deadline }, (error: grpc.ServiceError, value: unknown) => {
+      assert.ifError(error);
+      done();
+    });
+  });
+});
diff --git a/test/js/third_party/grpc-js/test-client.test.ts b/test/js/third_party/grpc-js/test-client.test.ts
index 09169c498c..4317ab7de0 100644
--- a/test/js/third_party/grpc-js/test-client.test.ts
+++ b/test/js/third_party/grpc-js/test-client.test.ts
@@ -14,44 +14,49 @@
  * limitations under the License.
  *
  */
-
-import assert from "assert";
-
-import * as grpc from "@grpc/grpc-js";
-import { Client } from "@grpc/grpc-js";
-import { afterAll, beforeAll, describe, it } from "bun:test";
-import { ConnectivityState, TestClient, TestServer } from "./common";
+import grpc from "@grpc/grpc-js";
+import assert from "node:assert";
+import { afterAll, beforeAll, describe, it, beforeEach, afterEach } from "bun:test";
+import { Server, ServerCredentials } from "@grpc/grpc-js/build/src";
+import { Client } from "@grpc/grpc-js/build/src";
+import { ConnectivityState } from "@grpc/grpc-js/build/src/connectivity-state";
 
 const clientInsecureCreds = grpc.credentials.createInsecure();
+const serverInsecureCreds = ServerCredentials.createInsecure();
 
-["h2", "h2c"].forEach(protocol => {
-  describe(`Client ${protocol}`, () => {
-    it("should call the waitForReady callback only once, when channel connectivity state is READY", async () => {
-      const server = new TestServer(protocol === "h2");
-      await server.start();
-      const client = TestClient.createFromServer(server);
-      try {
-        const { promise, resolve, reject } = Promise.withResolvers();
-        const deadline = Date.now() + 1000;
-        let calledTimes = 0;
-        client.waitForReady(deadline, err => {
-          calledTimes++;
-          try {
-            assert.ifError(err);
-            assert.equal(client.getChannel().getConnectivityState(true), ConnectivityState.READY);
-            resolve(undefined);
-          } catch (e) {
-            reject(e);
-          }
-        });
-        await promise;
-        assert.equal(calledTimes, 1);
-      } finally {
-        client?.close();
-        server.shutdown();
-      }
+describe("Client", () => {
+  let server: Server;
+  let client: Client;
+
+  beforeAll(done => {
+    server = new Server();
+
+    server.bindAsync("localhost:0", serverInsecureCreds, (err, port) => {
+      assert.ifError(err);
+      client = new Client(`localhost:${port}`, clientInsecureCreds);
+      server.start();
+      done();
     });
   });
+
+  afterAll(done => {
+    client.close();
+    server.tryShutdown(done);
+  });
+
+  it("should call the waitForReady callback only once, when channel connectivity state is READY", done => {
+    const deadline = Date.now() + 100;
+    let calledTimes = 0;
+    client.waitForReady(deadline, err => {
+      assert.ifError(err);
+      assert.equal(client.getChannel().getConnectivityState(true), ConnectivityState.READY);
+      calledTimes += 1;
+    });
+    setTimeout(() => {
+      assert.equal(calledTimes, 1);
+      done();
+    }, deadline - Date.now());
+  });
 });
 
 describe("Client without a server", () => {
@@ -63,8 +68,7 @@ describe("Client without a server", () => {
   afterAll(() => {
     client.close();
   });
-  // This test is flaky because error.stack sometimes undefined aka TypeError: undefined is not an object (evaluating 'error.stack.split')
-  it.skip("should fail multiple calls to the nonexistent server", function (done) {
+  it("should fail multiple calls to the nonexistent server", function (done) {
     // Regression test for https://github.com/grpc/grpc-node/issues/1411
     client.makeUnaryRequest(
       "/service/method",
@@ -88,6 +92,21 @@ describe("Client without a server", () => {
       },
     );
   });
+  it("close should force calls to end", done => {
+    client.makeUnaryRequest(
+      "/service/method",
+      x => x,
+      x => x,
+      Buffer.from([]),
+      new grpc.Metadata({ waitForReady: true }),
+      (error, value) => {
+        assert(error);
+        assert.strictEqual(error?.code, grpc.status.UNAVAILABLE);
+        done();
+      },
+    );
+    client.close();
+  });
 });
 
 describe("Client with a nonexistent target domain", () => {
@@ -123,4 +142,19 @@ describe("Client with a nonexistent target domain", () => {
       },
     );
   });
+  it("close should force calls to end", done => {
+    client.makeUnaryRequest(
+      "/service/method",
+      x => x,
+      x => x,
+      Buffer.from([]),
+      new grpc.Metadata({ waitForReady: true }),
+      (error, value) => {
+        assert(error);
+        assert.strictEqual(error?.code, grpc.status.UNAVAILABLE);
+        done();
+      },
+    );
+    client.close();
+  });
 });
diff --git a/test/js/third_party/grpc-js/test-confg-parsing.test.ts b/test/js/third_party/grpc-js/test-confg-parsing.test.ts
new file mode 100644
index 0000000000..a4115f7ff1
--- /dev/null
+++ b/test/js/third_party/grpc-js/test-confg-parsing.test.ts
@@ -0,0 +1,215 @@
+/*
+ * Copyright 2023 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import { experimental } from "@grpc/grpc-js";
+import assert from "node:assert";
+import { afterAll, beforeAll, describe, it, beforeEach, afterEach } from "bun:test";
+
+import parseLoadBalancingConfig = experimental.parseLoadBalancingConfig;
+
+/**
+ * Describes a test case for config parsing. input is passed to
+ * parseLoadBalancingConfig. If error is set, the expectation is that that
+ * operation throws an error with a matching message. Otherwise, toJsonObject
+ * is called on the result, and it is expected to match output, or input if
+ * output is unset.
+ */
+interface TestCase {
+  name: string;
+  input: object;
+  output?: object;
+  error?: RegExp;
+}
+
+/* The main purpose of these tests is to verify that configs that are expected
+ * to be valid parse successfully, and configs that are expected to be invalid
+ * throw errors. The specific output of this parsing is a lower priority
+ * concern.
+ * Note: some tests have an expected output that is different from the output,
+ * but all non-error tests additionally verify that parsing the output again
+ * produces the same output. */
+const allTestCases: { [lbPolicyName: string]: TestCase[] } = {
+  pick_first: [
+    {
+      name: "no fields set",
+      input: {},
+      output: {
+        shuffleAddressList: false,
+      },
+    },
+    {
+      name: "shuffleAddressList set",
+      input: {
+        shuffleAddressList: true,
+      },
+    },
+  ],
+  round_robin: [
+    {
+      name: "no fields set",
+      input: {},
+    },
+  ],
+  outlier_detection: [
+    {
+      name: "only required fields set",
+      input: {
+        child_policy: [{ round_robin: {} }],
+      },
+      output: {
+        interval: {
+          seconds: 10,
+          nanos: 0,
+        },
+        base_ejection_time: {
+          seconds: 30,
+          nanos: 0,
+        },
+        max_ejection_time: {
+          seconds: 300,
+          nanos: 0,
+        },
+        max_ejection_percent: 10,
+        success_rate_ejection: undefined,
+        failure_percentage_ejection: undefined,
+        child_policy: [{ round_robin: {} }],
+      },
+    },
+    {
+      name: "all optional fields undefined",
+      input: {
+        interval: undefined,
+        base_ejection_time: undefined,
+        max_ejection_time: undefined,
+        max_ejection_percent: undefined,
+        success_rate_ejection: undefined,
+        failure_percentage_ejection: undefined,
+        child_policy: [{ round_robin: {} }],
+      },
+      output: {
+        interval: {
+          seconds: 10,
+          nanos: 0,
+        },
+        base_ejection_time: {
+          seconds: 30,
+          nanos: 0,
+        },
+        max_ejection_time: {
+          seconds: 300,
+          nanos: 0,
+        },
+        max_ejection_percent: 10,
+        success_rate_ejection: undefined,
+        failure_percentage_ejection: undefined,
+        child_policy: [{ round_robin: {} }],
+      },
+    },
+    {
+      name: "empty ejection configs",
+      input: {
+        success_rate_ejection: {},
+        failure_percentage_ejection: {},
+        child_policy: [{ round_robin: {} }],
+      },
+      output: {
+        interval: {
+          seconds: 10,
+          nanos: 0,
+        },
+        base_ejection_time: {
+          seconds: 30,
+          nanos: 0,
+        },
+        max_ejection_time: {
+          seconds: 300,
+          nanos: 0,
+        },
+        max_ejection_percent: 10,
+        success_rate_ejection: {
+          stdev_factor: 1900,
+          enforcement_percentage: 100,
+          minimum_hosts: 5,
+          request_volume: 100,
+        },
+        failure_percentage_ejection: {
+          threshold: 85,
+          enforcement_percentage: 100,
+          minimum_hosts: 5,
+          request_volume: 50,
+        },
+        child_policy: [{ round_robin: {} }],
+      },
+    },
+    {
+      name: "all fields populated",
+      input: {
+        interval: {
+          seconds: 20,
+          nanos: 0,
+        },
+        base_ejection_time: {
+          seconds: 40,
+          nanos: 0,
+        },
+        max_ejection_time: {
+          seconds: 400,
+          nanos: 0,
+        },
+        max_ejection_percent: 20,
+        success_rate_ejection: {
+          stdev_factor: 1800,
+          enforcement_percentage: 90,
+          minimum_hosts: 4,
+          request_volume: 200,
+        },
+        failure_percentage_ejection: {
+          threshold: 95,
+          enforcement_percentage: 90,
+          minimum_hosts: 4,
+          request_volume: 60,
+        },
+        child_policy: [{ round_robin: {} }],
+      },
+    },
+  ],
+};
+
+describe("Load balancing policy config parsing", () => {
+  for (const [lbPolicyName, testCases] of Object.entries(allTestCases)) {
+    describe(lbPolicyName, () => {
+      for (const testCase of testCases) {
+        it(testCase.name, () => {
+          const lbConfigInput = { [lbPolicyName]: testCase.input };
+          if (testCase.error) {
+            assert.throws(() => {
+              parseLoadBalancingConfig(lbConfigInput);
+            }, testCase.error);
+          } else {
+            const expectedOutput = testCase.output ?? testCase.input;
+            const parsedJson = parseLoadBalancingConfig(lbConfigInput).toJsonObject();
+            assert.deepStrictEqual(parsedJson, {
+              [lbPolicyName]: expectedOutput,
+            });
+            // Test idempotency
+            assert.deepStrictEqual(parseLoadBalancingConfig(parsedJson).toJsonObject(), parsedJson);
+          }
+        });
+      }
+    });
+  }
+});
diff --git a/test/js/third_party/grpc-js/test-deadline.test.ts b/test/js/third_party/grpc-js/test-deadline.test.ts
new file mode 100644
index 0000000000..319509191f
--- /dev/null
+++ b/test/js/third_party/grpc-js/test-deadline.test.ts
@@ -0,0 +1,87 @@
+/*
+ * Copyright 2021 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import assert from "node:assert";
+import grpc, { sendUnaryData, ServerUnaryCall, ServiceError } from "@grpc/grpc-js";
+import { afterAll, beforeAll, describe, it, afterEach } from "bun:test";
+import { ServiceClient, ServiceClientConstructor } from "@grpc/grpc-js/build/src/make-client";
+
+import { loadProtoFile } from "./common";
+
+const TIMEOUT_SERVICE_CONFIG: grpc.ServiceConfig = {
+  loadBalancingConfig: [],
+  methodConfig: [
+    {
+      name: [{ service: "TestService" }],
+      timeout: {
+        seconds: 1,
+        nanos: 0,
+      },
+    },
+  ],
+};
+
+describe("Client with configured timeout", () => {
+  let server: grpc.Server;
+  let Client: ServiceClientConstructor;
+  let client: ServiceClient;
+
+  beforeAll(done => {
+    Client = loadProtoFile(__dirname + "/fixtures/test_service.proto").TestService as ServiceClientConstructor;
+    server = new grpc.Server();
+    server.addService(Client.service, {
+      unary: () => {},
+      clientStream: () => {},
+      serverStream: () => {},
+      bidiStream: () => {},
+    });
+    server.bindAsync("localhost:0", grpc.ServerCredentials.createInsecure(), (error, port) => {
+      if (error) {
+        done(error);
+        return;
+      }
+      server.start();
+      client = new Client(`localhost:${port}`, grpc.credentials.createInsecure(), {
+        "grpc.service_config": JSON.stringify(TIMEOUT_SERVICE_CONFIG),
+      });
+      done();
+    });
+  });
+
+  afterAll(() => {
+    client.close();
+    server.forceShutdown();
+  });
+
+  it("Should end calls without explicit deadline with DEADLINE_EXCEEDED", done => {
+    client.unary({}, (error: grpc.ServiceError, value: unknown) => {
+      assert(error);
+      assert.strictEqual(error.code, grpc.status.DEADLINE_EXCEEDED);
+      done();
+    });
+  });
+
+  it("Should end calls with a long explicit deadline with DEADLINE_EXCEEDED", done => {
+    const deadline = new Date();
+    deadline.setSeconds(deadline.getSeconds() + 20);
+    client.unary({}, (error: grpc.ServiceError, value: unknown) => {
+      assert(error);
+      assert.strictEqual(error.code, grpc.status.DEADLINE_EXCEEDED);
+      done();
+    });
+  });
+});
diff --git a/test/js/third_party/grpc-js/test-duration.test.ts b/test/js/third_party/grpc-js/test-duration.test.ts
new file mode 100644
index 0000000000..2c9d29e69c
--- /dev/null
+++ b/test/js/third_party/grpc-js/test-duration.test.ts
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2024 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import * as duration from "@grpc/grpc-js/build/src/duration";
+import assert from "node:assert";
+import { afterAll, beforeAll, describe, it, afterEach } from "bun:test";
+
+describe("Duration", () => {
+  describe("parseDuration", () => {
+    const expectationList: {
+      input: string;
+      result: duration.Duration | null;
+    }[] = [
+      {
+        input: "1.0s",
+        result: { seconds: 1, nanos: 0 },
+      },
+      {
+        input: "1.5s",
+        result: { seconds: 1, nanos: 500_000_000 },
+      },
+      {
+        input: "1s",
+        result: { seconds: 1, nanos: 0 },
+      },
+      {
+        input: "1",
+        result: null,
+      },
+    ];
+    for (const { input, result } of expectationList) {
+      it(`${input} -> ${JSON.stringify(result)}`, () => {
+        assert.deepStrictEqual(duration.parseDuration(input), result);
+      });
+    }
+  });
+});
diff --git a/test/js/third_party/grpc-js/test-end-to-end.test.ts b/test/js/third_party/grpc-js/test-end-to-end.test.ts
new file mode 100644
index 0000000000..56c5e20b35
--- /dev/null
+++ b/test/js/third_party/grpc-js/test-end-to-end.test.ts
@@ -0,0 +1,100 @@
+/*
+ * Copyright 2024 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import * as path from "path";
+import { loadProtoFile } from "./common";
+import assert from "node:assert";
+import grpc, {
+  Metadata,
+  Server,
+  ServerDuplexStream,
+  ServerUnaryCall,
+  ServiceError,
+  experimental,
+  sendUnaryData,
+} from "@grpc/grpc-js";
+import { afterAll, beforeAll, describe, it, afterEach } from "bun:test";
+import { ServiceClient, ServiceClientConstructor } from "@grpc/grpc-js/build/src/make-client";
+
+const protoFile = path.join(__dirname, "fixtures", "echo_service.proto");
+const EchoService = loadProtoFile(protoFile).EchoService as ServiceClientConstructor;
+const echoServiceImplementation = {
+  echo(call: ServerUnaryCall<any, any>, callback: sendUnaryData<any>) {
+    callback(null, call.request);
+  },
+  echoBidiStream(call: ServerDuplexStream<any, any>) {
+    call.on("data", data => {
+      call.write(data);
+    });
+    call.on("end", () => {
+      call.end();
+    });
+  },
+};
+
+// is something with the file watcher?
+describe("Client should successfully communicate with server", () => {
+  let server: Server | null = null;
+  let client: ServiceClient | null = null;
+  afterEach(() => {
+    client?.close();
+    client = null;
+    server?.forceShutdown();
+    server = null;
+  });
+  it.skip("With file watcher credentials", done => {
+    const [caPath, keyPath, certPath] = ["ca.pem", "server1.key", "server1.pem"].map(file =>
+      path.join(__dirname, "fixtures", file),
+    );
+    const fileWatcherConfig: experimental.FileWatcherCertificateProviderConfig = {
+      caCertificateFile: caPath,
+      certificateFile: certPath,
+      privateKeyFile: keyPath,
+      refreshIntervalMs: 1000,
+    };
+    const certificateProvider: experimental.CertificateProvider = new experimental.FileWatcherCertificateProvider(
+      fileWatcherConfig,
+    );
+    const serverCreds = experimental.createCertificateProviderServerCredentials(
+      certificateProvider,
+      certificateProvider,
+      true,
+    );
+    const clientCreds = experimental.createCertificateProviderChannelCredentials(
+      certificateProvider,
+      certificateProvider,
+    );
+    server = new Server();
+    server.addService(EchoService.service, echoServiceImplementation);
+    server.bindAsync("localhost:0", serverCreds, (error, port) => {
+      assert.ifError(error);
+      client = new EchoService(`localhost:${port}`, clientCreds, {
+        "grpc.ssl_target_name_override": "foo.test.google.fr",
+        "grpc.default_authority": "foo.test.google.fr",
+      });
+      const metadata = new Metadata({ waitForReady: true });
+      const deadline = new Date();
+      deadline.setSeconds(deadline.getSeconds() + 3);
+      const testMessage = { value: "test value", value2: 3 };
+      client.echo(testMessage, metadata, { deadline }, (error: ServiceError, value: any) => {
+        assert.ifError(error);
+        assert.deepStrictEqual(value, testMessage);
+        done();
+      });
+    });
+  }, 5000);
+});
diff --git a/test/js/third_party/grpc-js/test-global-subchannel-pool.test.ts b/test/js/third_party/grpc-js/test-global-subchannel-pool.test.ts
new file mode 100644
index 0000000000..2f7ea27fcc
--- /dev/null
+++ b/test/js/third_party/grpc-js/test-global-subchannel-pool.test.ts
@@ -0,0 +1,129 @@
+/*
+ * Copyright 2023 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import * as path from "path";
+import assert from "node:assert";
+import grpc, { Server, ServerCredentials, ServerUnaryCall, ServiceError, sendUnaryData } from "@grpc/grpc-js";
+import { afterAll, beforeAll, describe, it, afterEach, beforeEach } from "bun:test";
+import { ServiceClient, ServiceClientConstructor } from "@grpc/grpc-js/build/src/make-client";
+
+import { loadProtoFile } from "./common";
+
+const protoFile = path.join(__dirname, "fixtures", "echo_service.proto");
+const echoService = loadProtoFile(protoFile).EchoService as ServiceClientConstructor;
+
+describe("Global subchannel pool", () => {
+  let server: Server;
+  let serverPort: number;
+
+  let client1: InstanceType<grpc.ServiceClientConstructor>;
+  let client2: InstanceType<grpc.ServiceClientConstructor>;
+
+  let promises: Promise<any>[];
+
+  beforeAll(done => {
+    server = new Server();
+    server.addService(echoService.service, {
+      echo(call: ServerUnaryCall<any, any>, callback: sendUnaryData<any>) {
+        callback(null, call.request);
+      },
+    });
+
+    server.bindAsync("127.0.0.1:0", ServerCredentials.createInsecure(), (err, port) => {
+      assert.ifError(err);
+      serverPort = port;
+      server.start();
+      done();
+    });
+  });
+
+  beforeEach(() => {
+    promises = [];
+  });
+
+  afterAll(() => {
+    server.forceShutdown();
+  });
+
+  function callService(client: InstanceType<grpc.ServiceClientConstructor>) {
+    return new Promise<void>(resolve => {
+      const request = { value: "test value", value2: 3 };
+
+      client.echo(request, (error: ServiceError, response: any) => {
+        assert.ifError(error);
+        assert.deepStrictEqual(response, request);
+        resolve();
+      });
+    });
+  }
+
+  function connect() {
+    const grpcOptions = {
+      "grpc.use_local_subchannel_pool": 0,
+    };
+
+    client1 = new echoService(`127.0.0.1:${serverPort}`, grpc.credentials.createInsecure(), grpcOptions);
+
+    client2 = new echoService(`127.0.0.1:${serverPort}`, grpc.credentials.createInsecure(), grpcOptions);
+  }
+
+  /* This is a regression test for a bug where client1.close in the
+   * waitForReady callback would cause the subchannel to transition to IDLE
+   * even though client2 is also using it. */
+  it("Should handle client.close calls in waitForReady", done => {
+    connect();
+
+    promises.push(
+      new Promise<void>(resolve => {
+        client1.waitForReady(Date.now() + 1500, error => {
+          assert.ifError(error);
+          client1.close();
+          resolve();
+        });
+      }),
+    );
+
+    promises.push(
+      new Promise<void>(resolve => {
+        client2.waitForReady(Date.now() + 1500, error => {
+          assert.ifError(error);
+          resolve();
+        });
+      }),
+    );
+
+    Promise.all(promises).then(() => {
+      done();
+    });
+  });
+
+  it("Call the service", done => {
+    promises.push(callService(client2));
+
+    Promise.all(promises).then(() => {
+      done();
+    });
+  });
+
+  it("Should complete the client lifecycle without error", done => {
+    setTimeout(() => {
+      client1.close();
+      client2.close();
+      done();
+    }, 500);
+  });
+});
diff --git a/test/js/third_party/grpc-js/test-idle-timer.test.ts b/test/js/third_party/grpc-js/test-idle-timer.test.ts
index 0ac6fc7dd2..6a9f60f727 100644
--- a/test/js/third_party/grpc-js/test-idle-timer.test.ts
+++ b/test/js/third_party/grpc-js/test-idle-timer.test.ts
@@ -15,90 +15,181 @@
  *
  */
 
-import * as grpc from "@grpc/grpc-js";
-import * as assert from "assert";
-import { afterAll, afterEach, beforeAll, describe, it } from "bun:test";
+import assert from "node:assert";
+import grpc from "@grpc/grpc-js";
+import { afterAll as after, beforeAll as before, describe, it, afterEach, beforeEach } from "bun:test";
+import { ServiceClient, ServiceClientConstructor } from "@grpc/grpc-js/build/src/make-client";
+
 import { TestClient, TestServer } from "./common";
 
-["h2", "h2c"].forEach(protocol => {
-  describe("Channel idle timer", () => {
-    let server: TestServer;
-    let client: TestClient | null = null;
-    beforeAll(() => {
-      server = new TestServer(protocol === "h2");
-      return server.start();
+describe("Channel idle timer", () => {
+  let server: TestServer;
+  let client: TestClient | null = null;
+  before(() => {
+    server = new TestServer(false);
+    return server.start();
+  });
+  afterEach(() => {
+    if (client) {
+      client.close();
+      client = null;
+    }
+  });
+  after(() => {
+    server.shutdown();
+  });
+  it("Should go idle after the specified time after a request ends", function (done) {
+    client = TestClient.createFromServer(server, {
+      "grpc.client_idle_timeout_ms": 1000,
     });
-    afterEach(() => {
-      if (client) {
-        client.close();
-        client = null;
-      }
+    client.sendRequest(error => {
+      assert.ifError(error);
+      assert.strictEqual(client!.getChannelState(), grpc.connectivityState.READY);
+      setTimeout(() => {
+        assert.strictEqual(client!.getChannelState(), grpc.connectivityState.IDLE);
+        done();
+      }, 1100);
     });
-    afterAll(() => {
-      server.shutdown();
+  });
+  it("Should be able to make a request after going idle", function (done) {
+    client = TestClient.createFromServer(server, {
+      "grpc.client_idle_timeout_ms": 1000,
     });
-    it("Should go idle after the specified time after a request ends", function (done) {
-      client = TestClient.createFromServer(server, {
-        "grpc.client_idle_timeout_ms": 1000,
-      });
-      client.sendRequest(error => {
-        assert.ifError(error);
+    client.sendRequest(error => {
+      assert.ifError(error);
+      assert.strictEqual(client!.getChannelState(), grpc.connectivityState.READY);
+      setTimeout(() => {
+        assert.strictEqual(client!.getChannelState(), grpc.connectivityState.IDLE);
+        client!.sendRequest(error => {
+          assert.ifError(error);
+          done();
+        });
+      }, 1100);
+    });
+  });
+  it("Should go idle after the specified time after waitForReady ends", function (done) {
+    client = TestClient.createFromServer(server, {
+      "grpc.client_idle_timeout_ms": 1000,
+    });
+    const deadline = new Date();
+    deadline.setSeconds(deadline.getSeconds() + 3);
+    client.waitForReady(deadline, error => {
+      assert.ifError(error);
+      assert.strictEqual(client!.getChannelState(), grpc.connectivityState.READY);
+      setTimeout(() => {
+        assert.strictEqual(client!.getChannelState(), grpc.connectivityState.IDLE);
+        done();
+      }, 1100);
+    });
+  });
+  it("Should ensure that the timeout is at least 1 second", function (done) {
+    client = TestClient.createFromServer(server, {
+      "grpc.client_idle_timeout_ms": 50,
+    });
+    client.sendRequest(error => {
+      assert.ifError(error);
+      assert.strictEqual(client!.getChannelState(), grpc.connectivityState.READY);
+      setTimeout(() => {
+        // Should still be ready after 100ms
         assert.strictEqual(client!.getChannelState(), grpc.connectivityState.READY);
         setTimeout(() => {
+          // Should go IDLE after another second
           assert.strictEqual(client!.getChannelState(), grpc.connectivityState.IDLE);
           done();
-        }, 1100);
-      });
-    });
-    it("Should be able to make a request after going idle", function (done) {
-      client = TestClient.createFromServer(server, {
-        "grpc.client_idle_timeout_ms": 1000,
-      });
-      client.sendRequest(error => {
-        if (error) {
-          return done(error);
-        }
-        assert.strictEqual(client!.getChannelState(), grpc.connectivityState.READY);
-        setTimeout(() => {
-          assert.strictEqual(client!.getChannelState(), grpc.connectivityState.IDLE);
-          client!.sendRequest(error => {
-            done(error);
-          });
-        }, 1100);
-      });
-    });
-    it("Should go idle after the specified time after waitForReady ends", function (done) {
-      client = TestClient.createFromServer(server, {
-        "grpc.client_idle_timeout_ms": 1000,
-      });
-      const deadline = new Date();
-      deadline.setSeconds(deadline.getSeconds() + 3);
-      client.waitForReady(deadline, error => {
-        assert.ifError(error);
-        assert.strictEqual(client!.getChannelState(), grpc.connectivityState.READY);
-        setTimeout(() => {
-          assert.strictEqual(client!.getChannelState(), grpc.connectivityState.IDLE);
-          done();
-        }, 1100);
-      });
-    });
-    it("Should ensure that the timeout is at least 1 second", function (done) {
-      client = TestClient.createFromServer(server, {
-        "grpc.client_idle_timeout_ms": 50,
-      });
-      client.sendRequest(error => {
-        assert.ifError(error);
-        assert.strictEqual(client!.getChannelState(), grpc.connectivityState.READY);
-        setTimeout(() => {
-          // Should still be ready after 100ms
-          assert.strictEqual(client!.getChannelState(), grpc.connectivityState.READY);
-          setTimeout(() => {
-            // Should go IDLE after another second
-            assert.strictEqual(client!.getChannelState(), grpc.connectivityState.IDLE);
-            done();
-          }, 1000);
-        }, 100);
-      });
+        }, 1000);
+      }, 100);
+    });
+  });
+});
+
+describe.todo("Channel idle timer with UDS", () => {
+  let server: TestServer;
+  let client: TestClient | null = null;
+  before(() => {
+    server = new TestServer(false);
+    return server.startUds();
+  });
+  afterEach(() => {
+    if (client) {
+      client.close();
+      client = null;
+    }
+  });
+  after(() => {
+    server.shutdown();
+  });
+  it("Should be able to make a request after going idle", function (done) {
+    client = TestClient.createFromServer(server, {
+      "grpc.client_idle_timeout_ms": 1000,
+    });
+    client.sendRequest(error => {
+      assert.ifError(error);
+      assert.strictEqual(client!.getChannelState(), grpc.connectivityState.READY);
+      setTimeout(() => {
+        assert.strictEqual(client!.getChannelState(), grpc.connectivityState.IDLE);
+        client!.sendRequest(error => {
+          assert.ifError(error);
+          done();
+        });
+      }, 1100);
+    });
+  });
+});
+
+describe("Server idle timer", () => {
+  let server: TestServer;
+  let client: TestClient | null = null;
+  before(() => {
+    server = new TestServer(false, {
+      "grpc.max_connection_idle_ms": 500, // small for testing purposes
+    });
+    return server.start();
+  });
+  afterEach(() => {
+    if (client) {
+      client.close();
+      client = null;
+    }
+  });
+  after(() => {
+    server.shutdown();
+  });
+
+  it("Should go idle after the specified time after a request ends", function (done) {
+    client = TestClient.createFromServer(server);
+    client.sendRequest(error => {
+      assert.ifError(error);
+      assert.strictEqual(client!.getChannelState(), grpc.connectivityState.READY);
+      client?.waitForClientState(Date.now() + 1500, grpc.connectivityState.IDLE, done);
+    });
+  });
+
+  it("Should be able to make a request after going idle", function (done) {
+    client = TestClient.createFromServer(server);
+    client.sendRequest(error => {
+      assert.ifError(error);
+      assert.strictEqual(client!.getChannelState(), grpc.connectivityState.READY);
+      client!.waitForClientState(Date.now() + 1500, grpc.connectivityState.IDLE, err => {
+        if (err) return done(err);
+
+        assert.strictEqual(client!.getChannelState(), grpc.connectivityState.IDLE);
+        client!.sendRequest(error => {
+          assert.ifError(error);
+          done();
+        });
+      });
+    });
+  });
+
+  it("Should go idle after the specified time after waitForReady ends", function (done) {
+    client = TestClient.createFromServer(server);
+    const deadline = new Date();
+    deadline.setSeconds(deadline.getSeconds() + 3);
+    client.waitForReady(deadline, error => {
+      assert.ifError(error);
+      assert.strictEqual(client!.getChannelState(), grpc.connectivityState.READY);
+
+      client!.waitForClientState(Date.now() + 1500, grpc.connectivityState.IDLE, done);
     });
   });
 });
diff --git a/test/js/third_party/grpc-js/test-local-subchannel-pool.test.ts b/test/js/third_party/grpc-js/test-local-subchannel-pool.test.ts
new file mode 100644
index 0000000000..d7bbcd58f1
--- /dev/null
+++ b/test/js/third_party/grpc-js/test-local-subchannel-pool.test.ts
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2022 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import * as path from "path";
+import assert from "node:assert";
+import grpc, { sendUnaryData, Server, ServerCredentials, ServerUnaryCall, ServiceError } from "@grpc/grpc-js";
+import { afterAll as after, beforeAll as before, describe, it, afterEach, beforeEach } from "bun:test";
+import { ServiceClientConstructor } from "@grpc/grpc-js/build/src/make-client";
+
+import { loadProtoFile } from "./common";
+
+const protoFile = path.join(__dirname, "fixtures", "echo_service.proto");
+const echoService = loadProtoFile(protoFile).EchoService as ServiceClientConstructor;
+
+describe("Local subchannel pool", () => {
+  let server: Server;
+  let serverPort: number;
+
+  before(done => {
+    server = new Server();
+    server.addService(echoService.service, {
+      echo(call: ServerUnaryCall<any, any>, callback: sendUnaryData<any>) {
+        callback(null, call.request);
+      },
+    });
+
+    server.bindAsync("localhost:0", ServerCredentials.createInsecure(), (err, port) => {
+      assert.ifError(err);
+      serverPort = port;
+      server.start();
+      done();
+    });
+  });
+
+  after(done => {
+    server.tryShutdown(done);
+  });
+
+  it("should complete the client lifecycle without error", done => {
+    const client = new echoService(`localhost:${serverPort}`, grpc.credentials.createInsecure(), {
+      "grpc.use_local_subchannel_pool": 1,
+    });
+    client.echo({ value: "test value", value2: 3 }, (error: ServiceError, response: any) => {
+      assert.ifError(error);
+      assert.deepStrictEqual(response, { value: "test value", value2: 3 });
+      client.close();
+      done();
+    });
+  });
+});
diff --git a/test/js/third_party/grpc-js/test-logging.test.ts b/test/js/third_party/grpc-js/test-logging.test.ts
new file mode 100644
index 0000000000..8980c2838b
--- /dev/null
+++ b/test/js/third_party/grpc-js/test-logging.test.ts
@@ -0,0 +1,67 @@
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import * as logging from "@grpc/grpc-js/build/src/logging";
+
+import assert from "node:assert";
+import grpc from "@grpc/grpc-js";
+import { afterAll as after, beforeAll as before, describe, it, afterEach, beforeEach } from "bun:test";
+
+describe("Logging", () => {
+  afterEach(() => {
+    // Ensure that the logger is restored to its defaults after each test.
+    grpc.setLogger(console);
+    grpc.setLogVerbosity(grpc.logVerbosity.DEBUG);
+  });
+
+  it("sets the logger to a new value", () => {
+    const logger: Partial<Console> = {};
+
+    logging.setLogger(logger);
+    assert.strictEqual(logging.getLogger(), logger);
+  });
+
+  it("gates logging based on severity", () => {
+    const output: Array<string | string[]> = [];
+    const logger: Partial<Console> = {
+      error(...args: string[]): void {
+        output.push(args);
+      },
+    };
+
+    logging.setLogger(logger);
+
+    // The default verbosity (DEBUG) should log everything.
+    logging.log(grpc.logVerbosity.DEBUG, "a", "b", "c");
+    logging.log(grpc.logVerbosity.INFO, "d", "e");
+    logging.log(grpc.logVerbosity.ERROR, "f");
+
+    // The INFO verbosity should not log DEBUG data.
+    logging.setLoggerVerbosity(grpc.logVerbosity.INFO);
+    logging.log(grpc.logVerbosity.DEBUG, 1, 2, 3);
+    logging.log(grpc.logVerbosity.INFO, "g");
+    logging.log(grpc.logVerbosity.ERROR, "h", "i");
+
+    // The ERROR verbosity should not log DEBUG or INFO data.
+    logging.setLoggerVerbosity(grpc.logVerbosity.ERROR);
+    logging.log(grpc.logVerbosity.DEBUG, 4, 5, 6);
+    logging.log(grpc.logVerbosity.INFO, 7, 8);
+    logging.log(grpc.logVerbosity.ERROR, "j", "k");
+
+    assert.deepStrictEqual(output, [["a", "b", "c"], ["d", "e"], ["f"], ["g"], ["h", "i"], ["j", "k"]]);
+  });
+});
diff --git a/test/js/third_party/grpc-js/test-metadata.test.ts b/test/js/third_party/grpc-js/test-metadata.test.ts
new file mode 100644
index 0000000000..c3697e41fb
--- /dev/null
+++ b/test/js/third_party/grpc-js/test-metadata.test.ts
@@ -0,0 +1,320 @@
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import assert from "assert";
+import http2 from "http2";
+import { range } from "lodash";
+import { Metadata, MetadataObject, MetadataValue } from "@grpc/grpc-js/build/src/metadata";
+import { afterAll as after, beforeAll as before, describe, it, afterEach, beforeEach } from "bun:test";
+
+class TestMetadata extends Metadata {
+  getInternalRepresentation() {
+    return this.internalRepr;
+  }
+
+  static fromHttp2Headers(headers: http2.IncomingHttpHeaders): TestMetadata {
+    const result = Metadata.fromHttp2Headers(headers) as TestMetadata;
+    result.getInternalRepresentation = TestMetadata.prototype.getInternalRepresentation;
+    return result;
+  }
+}
+
+const validKeyChars = "0123456789abcdefghijklmnopqrstuvwxyz_-.";
+const validNonBinValueChars = range(0x20, 0x7f)
+  .map(code => String.fromCharCode(code))
+  .join("");
+
+describe("Metadata", () => {
+  let metadata: TestMetadata;
+
+  beforeEach(() => {
+    metadata = new TestMetadata();
+  });
+
+  describe("set", () => {
+    it('Only accepts string values for non "-bin" keys', () => {
+      assert.throws(() => {
+        metadata.set("key", Buffer.from("value"));
+      });
+      assert.doesNotThrow(() => {
+        metadata.set("key", "value");
+      });
+    });
+
+    it('Only accepts Buffer values for "-bin" keys', () => {
+      assert.throws(() => {
+        metadata.set("key-bin", "value");
+      });
+      assert.doesNotThrow(() => {
+        metadata.set("key-bin", Buffer.from("value"));
+      });
+    });
+
+    it("Rejects invalid keys", () => {
+      assert.doesNotThrow(() => {
+        metadata.set(validKeyChars, "value");
+      });
+      assert.throws(() => {
+        metadata.set("key$", "value");
+      }, /Error: Metadata key "key\$" contains illegal characters/);
+      assert.throws(() => {
+        metadata.set("", "value");
+      });
+    });
+
+    it("Rejects values with non-ASCII characters", () => {
+      assert.doesNotThrow(() => {
+        metadata.set("key", validNonBinValueChars);
+      });
+      assert.throws(() => {
+        metadata.set("key", "résumé");
+      });
+    });
+
+    it("Saves values that can be retrieved", () => {
+      metadata.set("key", "value");
+      assert.deepStrictEqual(metadata.get("key"), ["value"]);
+    });
+
+    it("Overwrites previous values", () => {
+      metadata.set("key", "value1");
+      metadata.set("key", "value2");
+      assert.deepStrictEqual(metadata.get("key"), ["value2"]);
+    });
+
+    it("Normalizes keys", () => {
+      metadata.set("Key", "value1");
+      assert.deepStrictEqual(metadata.get("key"), ["value1"]);
+      metadata.set("KEY", "value2");
+      assert.deepStrictEqual(metadata.get("key"), ["value2"]);
+    });
+  });
+
+  describe("add", () => {
+    it('Only accepts string values for non "-bin" keys', () => {
+      assert.throws(() => {
+        metadata.add("key", Buffer.from("value"));
+      });
+      assert.doesNotThrow(() => {
+        metadata.add("key", "value");
+      });
+    });
+
+    it('Only accepts Buffer values for "-bin" keys', () => {
+      assert.throws(() => {
+        metadata.add("key-bin", "value");
+      });
+      assert.doesNotThrow(() => {
+        metadata.add("key-bin", Buffer.from("value"));
+      });
+    });
+
+    it("Rejects invalid keys", () => {
+      assert.throws(() => {
+        metadata.add("key$", "value");
+      });
+      assert.throws(() => {
+        metadata.add("", "value");
+      });
+    });
+
+    it("Saves values that can be retrieved", () => {
+      metadata.add("key", "value");
+      assert.deepStrictEqual(metadata.get("key"), ["value"]);
+    });
+
+    it("Combines with previous values", () => {
+      metadata.add("key", "value1");
+      metadata.add("key", "value2");
+      assert.deepStrictEqual(metadata.get("key"), ["value1", "value2"]);
+    });
+
+    it("Normalizes keys", () => {
+      metadata.add("Key", "value1");
+      assert.deepStrictEqual(metadata.get("key"), ["value1"]);
+      metadata.add("KEY", "value2");
+      assert.deepStrictEqual(metadata.get("key"), ["value1", "value2"]);
+    });
+  });
+
+  describe("remove", () => {
+    it("clears values from a key", () => {
+      metadata.add("key", "value");
+      metadata.remove("key");
+      assert.deepStrictEqual(metadata.get("key"), []);
+    });
+
+    it("Normalizes keys", () => {
+      metadata.add("key", "value");
+      metadata.remove("KEY");
+      assert.deepStrictEqual(metadata.get("key"), []);
+    });
+  });
+
+  describe("get", () => {
+    beforeEach(() => {
+      metadata.add("key", "value1");
+      metadata.add("key", "value2");
+      metadata.add("key-bin", Buffer.from("value"));
+    });
+
+    it("gets all values associated with a key", () => {
+      assert.deepStrictEqual(metadata.get("key"), ["value1", "value2"]);
+    });
+
+    it("Normalizes keys", () => {
+      assert.deepStrictEqual(metadata.get("KEY"), ["value1", "value2"]);
+    });
+
+    it("returns an empty list for non-existent keys", () => {
+      assert.deepStrictEqual(metadata.get("non-existent-key"), []);
+    });
+
+    it('returns Buffers for "-bin" keys', () => {
+      assert.ok(metadata.get("key-bin")[0] instanceof Buffer);
+    });
+  });
+
+  describe("getMap", () => {
+    it("gets a map of keys to values", () => {
+      metadata.add("key1", "value1");
+      metadata.add("Key2", "value2");
+      metadata.add("KEY3", "value3a");
+      metadata.add("KEY3", "value3b");
+      assert.deepStrictEqual(metadata.getMap(), {
+        key1: "value1",
+        key2: "value2",
+        key3: "value3a",
+      });
+    });
+  });
+
+  describe("clone", () => {
+    it("retains values from the original", () => {
+      metadata.add("key", "value");
+      const copy = metadata.clone();
+      assert.deepStrictEqual(copy.get("key"), ["value"]);
+    });
+
+    it("Does not see newly added values", () => {
+      metadata.add("key", "value1");
+      const copy = metadata.clone();
+      metadata.add("key", "value2");
+      assert.deepStrictEqual(copy.get("key"), ["value1"]);
+    });
+
+    it("Does not add new values to the original", () => {
+      metadata.add("key", "value1");
+      const copy = metadata.clone();
+      copy.add("key", "value2");
+      assert.deepStrictEqual(metadata.get("key"), ["value1"]);
+    });
+
+    it("Copy cannot modify binary values in the original", () => {
+      const buf = Buffer.from("value-bin");
+      metadata.add("key-bin", buf);
+      const copy = metadata.clone();
+      const copyBuf = copy.get("key-bin")[0] as Buffer;
+      assert.deepStrictEqual(copyBuf, buf);
+      copyBuf.fill(0);
+      assert.notDeepStrictEqual(copyBuf, buf);
+    });
+  });
+
+  describe("merge", () => {
+    it("appends values from a given metadata object", () => {
+      metadata.add("key1", "value1");
+      metadata.add("Key2", "value2a");
+      metadata.add("KEY3", "value3a");
+      metadata.add("key4", "value4");
+      const metadata2 = new TestMetadata();
+      metadata2.add("KEY1", "value1");
+      metadata2.add("key2", "value2b");
+      metadata2.add("key3", "value3b");
+      metadata2.add("key5", "value5a");
+      metadata2.add("key5", "value5b");
+      const metadata2IR = metadata2.getInternalRepresentation();
+      metadata.merge(metadata2);
+      // Ensure metadata2 didn't change
+      assert.deepStrictEqual(metadata2.getInternalRepresentation(), metadata2IR);
+      assert.deepStrictEqual(metadata.get("key1"), ["value1", "value1"]);
+      assert.deepStrictEqual(metadata.get("key2"), ["value2a", "value2b"]);
+      assert.deepStrictEqual(metadata.get("key3"), ["value3a", "value3b"]);
+      assert.deepStrictEqual(metadata.get("key4"), ["value4"]);
+      assert.deepStrictEqual(metadata.get("key5"), ["value5a", "value5b"]);
+    });
+  });
+
+  describe("toHttp2Headers", () => {
+    it("creates an OutgoingHttpHeaders object with expected values", () => {
+      metadata.add("key1", "value1");
+      metadata.add("Key2", "value2");
+      metadata.add("KEY3", "value3a");
+      metadata.add("key3", "value3b");
+      metadata.add("key-bin", Buffer.from(range(0, 16)));
+      metadata.add("key-bin", Buffer.from(range(16, 32)));
+      metadata.add("key-bin", Buffer.from(range(0, 32)));
+      const headers = metadata.toHttp2Headers();
+      assert.deepStrictEqual(headers, {
+        key1: ["value1"],
+        key2: ["value2"],
+        key3: ["value3a", "value3b"],
+        "key-bin": [
+          "AAECAwQFBgcICQoLDA0ODw==",
+          "EBESExQVFhcYGRobHB0eHw==",
+          "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8=",
+        ],
+      });
+    });
+
+    it("creates an empty header object from empty Metadata", () => {
+      assert.deepStrictEqual(metadata.toHttp2Headers(), {});
+    });
+  });
+
+  describe("fromHttp2Headers", () => {
+    it("creates a Metadata object with expected values", () => {
+      const headers = {
+        key1: "value1",
+        key2: ["value2"],
+        key3: ["value3a", "value3b"],
+        key4: ["part1, part2"],
+        "key-bin": [
+          "AAECAwQFBgcICQoLDA0ODw==",
+          "EBESExQVFhcYGRobHB0eHw==",
+          "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8=",
+        ],
+      };
+      const metadataFromHeaders = TestMetadata.fromHttp2Headers(headers);
+      const internalRepr = metadataFromHeaders.getInternalRepresentation();
+      const expected: MetadataObject = new Map<string, MetadataValue[]>([
+        ["key1", ["value1"]],
+        ["key2", ["value2"]],
+        ["key3", ["value3a", "value3b"]],
+        ["key4", ["part1, part2"]],
+        ["key-bin", [Buffer.from(range(0, 16)), Buffer.from(range(16, 32)), Buffer.from(range(0, 32))]],
+      ]);
+      assert.deepStrictEqual(internalRepr, expected);
+    });
+
+    it("creates an empty Metadata object from empty headers", () => {
+      const metadataFromHeaders = TestMetadata.fromHttp2Headers({});
+      const internalRepr = metadataFromHeaders.getInternalRepresentation();
+      assert.deepStrictEqual(internalRepr, new Map<string, MetadataValue[]>());
+    });
+  });
+});
diff --git a/test/js/third_party/grpc-js/test-outlier-detection.test.ts b/test/js/third_party/grpc-js/test-outlier-detection.test.ts
new file mode 100644
index 0000000000..4cf19f0543
--- /dev/null
+++ b/test/js/third_party/grpc-js/test-outlier-detection.test.ts
@@ -0,0 +1,540 @@
+/*
+ * Copyright 2022 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import * as path from "path";
+import grpc from "@grpc/grpc-js";
+import { loadProtoFile } from "./common";
+import { OutlierDetectionLoadBalancingConfig } from "@grpc/grpc-js/build/src/load-balancer-outlier-detection";
+import assert from "assert";
+import { afterAll as after, beforeAll as before, describe, it, afterEach, beforeEach } from "bun:test";
+
+function multiDone(done: Mocha.Done, target: number) {
+  let count = 0;
+  return (error?: any) => {
+    if (error) {
+      done(error);
+    }
+    count++;
+    if (count >= target) {
+      done();
+    }
+  };
+}
+
+const defaultOutlierDetectionServiceConfig = {
+  methodConfig: [],
+  loadBalancingConfig: [
+    {
+      outlier_detection: {
+        success_rate_ejection: {},
+        failure_percentage_ejection: {},
+        child_policy: [{ round_robin: {} }],
+      },
+    },
+  ],
+};
+
+const defaultOutlierDetectionServiceConfigString = JSON.stringify(defaultOutlierDetectionServiceConfig);
+
+const successRateOutlierDetectionServiceConfig = {
+  methodConfig: [],
+  loadBalancingConfig: [
+    {
+      outlier_detection: {
+        interval: {
+          seconds: 1,
+          nanos: 0,
+        },
+        base_ejection_time: {
+          seconds: 3,
+          nanos: 0,
+        },
+        success_rate_ejection: {
+          request_volume: 5,
+        },
+        child_policy: [{ round_robin: {} }],
+      },
+    },
+  ],
+};
+
+const successRateOutlierDetectionServiceConfigString = JSON.stringify(successRateOutlierDetectionServiceConfig);
+
+const failurePercentageOutlierDetectionServiceConfig = {
+  methodConfig: [],
+  loadBalancingConfig: [
+    {
+      outlier_detection: {
+        interval: {
+          seconds: 1,
+          nanos: 0,
+        },
+        base_ejection_time: {
+          seconds: 3,
+          nanos: 0,
+        },
+        failure_percentage_ejection: {
+          request_volume: 5,
+        },
+        child_policy: [{ round_robin: {} }],
+      },
+    },
+  ],
+};
+
+const falurePercentageOutlierDetectionServiceConfigString = JSON.stringify(
+  failurePercentageOutlierDetectionServiceConfig,
+);
+
+const goodService = {
+  echo: (call: grpc.ServerUnaryCall<any, any>, callback: grpc.sendUnaryData<any>) => {
+    callback(null, call.request);
+  },
+};
+
+const badService = {
+  echo: (call: grpc.ServerUnaryCall<any, any>, callback: grpc.sendUnaryData<any>) => {
+    callback({
+      code: grpc.status.PERMISSION_DENIED,
+      details: "Permission denied",
+    });
+  },
+};
+
+const protoFile = path.join(__dirname, "fixtures", "echo_service.proto");
+const EchoService = loadProtoFile(protoFile).EchoService as grpc.ServiceClientConstructor;
+
+describe("Outlier detection config validation", () => {
+  describe("interval", () => {
+    it("Should reject a negative interval", () => {
+      const loadBalancingConfig = {
+        interval: {
+          seconds: -1,
+          nanos: 0,
+        },
+        child_policy: [{ round_robin: {} }],
+      };
+      assert.throws(() => {
+        OutlierDetectionLoadBalancingConfig.createFromJson(loadBalancingConfig);
+      }, /interval parse error: values out of range for non-negative Duaration/);
+    });
+    it("Should reject a large interval", () => {
+      const loadBalancingConfig = {
+        interval: {
+          seconds: 1e12,
+          nanos: 0,
+        },
+        child_policy: [{ round_robin: {} }],
+      };
+      assert.throws(() => {
+        OutlierDetectionLoadBalancingConfig.createFromJson(loadBalancingConfig);
+      }, /interval parse error: values out of range for non-negative Duaration/);
+    });
+    it("Should reject a negative interval.nanos", () => {
+      const loadBalancingConfig = {
+        interval: {
+          seconds: 0,
+          nanos: -1,
+        },
+        child_policy: [{ round_robin: {} }],
+      };
+      assert.throws(() => {
+        OutlierDetectionLoadBalancingConfig.createFromJson(loadBalancingConfig);
+      }, /interval parse error: values out of range for non-negative Duaration/);
+    });
+    it("Should reject a large interval.nanos", () => {
+      const loadBalancingConfig = {
+        interval: {
+          seconds: 0,
+          nanos: 1e12,
+        },
+        child_policy: [{ round_robin: {} }],
+      };
+      assert.throws(() => {
+        OutlierDetectionLoadBalancingConfig.createFromJson(loadBalancingConfig);
+      }, /interval parse error: values out of range for non-negative Duaration/);
+    });
+  });
+  describe("base_ejection_time", () => {
+    it("Should reject a negative base_ejection_time", () => {
+      const loadBalancingConfig = {
+        base_ejection_time: {
+          seconds: -1,
+          nanos: 0,
+        },
+        child_policy: [{ round_robin: {} }],
+      };
+      assert.throws(() => {
+        OutlierDetectionLoadBalancingConfig.createFromJson(loadBalancingConfig);
+      }, /base_ejection_time parse error: values out of range for non-negative Duaration/);
+    });
+    it("Should reject a large base_ejection_time", () => {
+      const loadBalancingConfig = {
+        base_ejection_time: {
+          seconds: 1e12,
+          nanos: 0,
+        },
+        child_policy: [{ round_robin: {} }],
+      };
+      assert.throws(() => {
+        OutlierDetectionLoadBalancingConfig.createFromJson(loadBalancingConfig);
+      }, /base_ejection_time parse error: values out of range for non-negative Duaration/);
+    });
+    it("Should reject a negative base_ejection_time.nanos", () => {
+      const loadBalancingConfig = {
+        base_ejection_time: {
+          seconds: 0,
+          nanos: -1,
+        },
+        child_policy: [{ round_robin: {} }],
+      };
+      assert.throws(() => {
+        OutlierDetectionLoadBalancingConfig.createFromJson(loadBalancingConfig);
+      }, /base_ejection_time parse error: values out of range for non-negative Duaration/);
+    });
+    it("Should reject a large base_ejection_time.nanos", () => {
+      const loadBalancingConfig = {
+        base_ejection_time: {
+          seconds: 0,
+          nanos: 1e12,
+        },
+        child_policy: [{ round_robin: {} }],
+      };
+      assert.throws(() => {
+        OutlierDetectionLoadBalancingConfig.createFromJson(loadBalancingConfig);
+      }, /base_ejection_time parse error: values out of range for non-negative Duaration/);
+    });
+  });
+  describe("max_ejection_time", () => {
+    it("Should reject a negative max_ejection_time", () => {
+      const loadBalancingConfig = {
+        max_ejection_time: {
+          seconds: -1,
+          nanos: 0,
+        },
+        child_policy: [{ round_robin: {} }],
+      };
+      assert.throws(() => {
+        OutlierDetectionLoadBalancingConfig.createFromJson(loadBalancingConfig);
+      }, /max_ejection_time parse error: values out of range for non-negative Duaration/);
+    });
+    it("Should reject a large max_ejection_time", () => {
+      const loadBalancingConfig = {
+        max_ejection_time: {
+          seconds: 1e12,
+          nanos: 0,
+        },
+        child_policy: [{ round_robin: {} }],
+      };
+      assert.throws(() => {
+        OutlierDetectionLoadBalancingConfig.createFromJson(loadBalancingConfig);
+      }, /max_ejection_time parse error: values out of range for non-negative Duaration/);
+    });
+    it("Should reject a negative max_ejection_time.nanos", () => {
+      const loadBalancingConfig = {
+        max_ejection_time: {
+          seconds: 0,
+          nanos: -1,
+        },
+        child_policy: [{ round_robin: {} }],
+      };
+      assert.throws(() => {
+        OutlierDetectionLoadBalancingConfig.createFromJson(loadBalancingConfig);
+      }, /max_ejection_time parse error: values out of range for non-negative Duaration/);
+    });
+    it("Should reject a large max_ejection_time.nanos", () => {
+      const loadBalancingConfig = {
+        max_ejection_time: {
+          seconds: 0,
+          nanos: 1e12,
+        },
+        child_policy: [{ round_robin: {} }],
+      };
+      assert.throws(() => {
+        OutlierDetectionLoadBalancingConfig.createFromJson(loadBalancingConfig);
+      }, /max_ejection_time parse error: values out of range for non-negative Duaration/);
+    });
+  });
+  describe("max_ejection_percent", () => {
+    it("Should reject a value above 100", () => {
+      const loadBalancingConfig = {
+        max_ejection_percent: 101,
+        child_policy: [{ round_robin: {} }],
+      };
+      assert.throws(() => {
+        OutlierDetectionLoadBalancingConfig.createFromJson(loadBalancingConfig);
+      }, /max_ejection_percent parse error: value out of range for percentage/);
+    });
+    it("Should reject a negative value", () => {
+      const loadBalancingConfig = {
+        max_ejection_percent: -1,
+        child_policy: [{ round_robin: {} }],
+      };
+      assert.throws(() => {
+        OutlierDetectionLoadBalancingConfig.createFromJson(loadBalancingConfig);
+      }, /max_ejection_percent parse error: value out of range for percentage/);
+    });
+  });
+  describe("success_rate_ejection.enforcement_percentage", () => {
+    it("Should reject a value above 100", () => {
+      const loadBalancingConfig = {
+        success_rate_ejection: {
+          enforcement_percentage: 101,
+        },
+        child_policy: [{ round_robin: {} }],
+      };
+      assert.throws(() => {
+        OutlierDetectionLoadBalancingConfig.createFromJson(loadBalancingConfig);
+      }, /success_rate_ejection\.enforcement_percentage parse error: value out of range for percentage/);
+    });
+    it("Should reject a negative value", () => {
+      const loadBalancingConfig = {
+        success_rate_ejection: {
+          enforcement_percentage: -1,
+        },
+        child_policy: [{ round_robin: {} }],
+      };
+      assert.throws(() => {
+        OutlierDetectionLoadBalancingConfig.createFromJson(loadBalancingConfig);
+      }, /success_rate_ejection\.enforcement_percentage parse error: value out of range for percentage/);
+    });
+  });
+  describe("failure_percentage_ejection.threshold", () => {
+    it("Should reject a value above 100", () => {
+      const loadBalancingConfig = {
+        failure_percentage_ejection: {
+          threshold: 101,
+        },
+        child_policy: [{ round_robin: {} }],
+      };
+      assert.throws(() => {
+        OutlierDetectionLoadBalancingConfig.createFromJson(loadBalancingConfig);
+      }, /failure_percentage_ejection\.threshold parse error: value out of range for percentage/);
+    });
+    it("Should reject a negative value", () => {
+      const loadBalancingConfig = {
+        failure_percentage_ejection: {
+          threshold: -1,
+        },
+        child_policy: [{ round_robin: {} }],
+      };
+      assert.throws(() => {
+        OutlierDetectionLoadBalancingConfig.createFromJson(loadBalancingConfig);
+      }, /failure_percentage_ejection\.threshold parse error: value out of range for percentage/);
+    });
+  });
+  describe("failure_percentage_ejection.enforcement_percentage", () => {
+    it("Should reject a value above 100", () => {
+      const loadBalancingConfig = {
+        failure_percentage_ejection: {
+          enforcement_percentage: 101,
+        },
+        child_policy: [{ round_robin: {} }],
+      };
+      assert.throws(() => {
+        OutlierDetectionLoadBalancingConfig.createFromJson(loadBalancingConfig);
+      }, /failure_percentage_ejection\.enforcement_percentage parse error: value out of range for percentage/);
+    });
+    it("Should reject a negative value", () => {
+      const loadBalancingConfig = {
+        failure_percentage_ejection: {
+          enforcement_percentage: -1,
+        },
+        child_policy: [{ round_robin: {} }],
+      };
+      assert.throws(() => {
+        OutlierDetectionLoadBalancingConfig.createFromJson(loadBalancingConfig);
+      }, /failure_percentage_ejection\.enforcement_percentage parse error: value out of range for percentage/);
+    });
+  });
+  describe("child_policy", () => {
+    it("Should reject a pick_first child_policy", () => {
+      const loadBalancingConfig = {
+        child_policy: [{ pick_first: {} }],
+      };
+      assert.throws(() => {
+        OutlierDetectionLoadBalancingConfig.createFromJson(loadBalancingConfig);
+      }, /outlier_detection LB policy cannot have a pick_first child policy/);
+    });
+  });
+});
+
+describe("Outlier detection", () => {
+  const GOOD_PORTS = 4;
+  let goodServer: grpc.Server;
+  let badServer: grpc.Server;
+  const goodPorts: number[] = [];
+  let badPort: number;
+  before(done => {
+    const eachDone = multiDone(() => {
+      goodServer.start();
+      badServer.start();
+      done();
+    }, GOOD_PORTS + 1);
+    goodServer = new grpc.Server();
+    goodServer.addService(EchoService.service, goodService);
+    for (let i = 0; i < GOOD_PORTS; i++) {
+      goodServer.bindAsync("localhost:0", grpc.ServerCredentials.createInsecure(), (error, port) => {
+        if (error) {
+          eachDone(error);
+          return;
+        }
+        goodPorts.push(port);
+        eachDone();
+      });
+    }
+    badServer = new grpc.Server();
+    badServer.addService(EchoService.service, badService);
+    badServer.bindAsync("localhost:0", grpc.ServerCredentials.createInsecure(), (error, port) => {
+      if (error) {
+        eachDone(error);
+        return;
+      }
+      badPort = port;
+      eachDone();
+    });
+  });
+  after(() => {
+    goodServer.forceShutdown();
+    badServer.forceShutdown();
+  });
+
+  function makeManyRequests(
+    makeOneRequest: (callback: (error?: Error) => void) => void,
+    total: number,
+    callback: (error?: Error) => void,
+  ) {
+    if (total === 0) {
+      callback();
+      return;
+    }
+    makeOneRequest(error => {
+      if (error) {
+        callback(error);
+        return;
+      }
+      makeManyRequests(makeOneRequest, total - 1, callback);
+    });
+  }
+
+  it("Should allow normal operation with one server", done => {
+    const client = new EchoService(`localhost:${goodPorts[0]}`, grpc.credentials.createInsecure(), {
+      "grpc.service_config": defaultOutlierDetectionServiceConfigString,
+    });
+    client.echo({ value: "test value", value2: 3 }, (error: grpc.ServiceError, response: any) => {
+      assert.ifError(error);
+      assert.deepStrictEqual(response, { value: "test value", value2: 3 });
+      done();
+    });
+  });
+  describe("Success rate", () => {
+    let makeCheckedRequest: (callback: () => void) => void;
+    let makeUncheckedRequest: (callback: (error?: Error) => void) => void;
+    before(() => {
+      const target = "ipv4:///" + goodPorts.map(port => `127.0.0.1:${port}`).join(",") + `,127.0.0.1:${badPort}`;
+      const client = new EchoService(target, grpc.credentials.createInsecure(), {
+        "grpc.service_config": successRateOutlierDetectionServiceConfigString,
+      });
+      makeUncheckedRequest = (callback: () => void) => {
+        client.echo({ value: "test value", value2: 3 }, (error: grpc.ServiceError, response: any) => {
+          callback();
+        });
+      };
+      makeCheckedRequest = (callback: (error?: Error) => void) => {
+        client.echo({ value: "test value", value2: 3 }, (error: grpc.ServiceError, response: any) => {
+          callback(error);
+        });
+      };
+    });
+    it("Should eject a server if it is failing requests", done => {
+      // Make a large volume of requests
+      makeManyRequests(makeUncheckedRequest, 50, () => {
+        // Give outlier detection time to run ejection checks
+        setTimeout(() => {
+          // Make enough requests to go around all servers
+          makeManyRequests(makeCheckedRequest, 10, done);
+        }, 1000);
+      });
+    });
+    it("Should uneject a server after the ejection period", function (done) {
+      makeManyRequests(makeUncheckedRequest, 50, () => {
+        setTimeout(() => {
+          makeManyRequests(makeCheckedRequest, 10, error => {
+            if (error) {
+              done(error);
+              return;
+            }
+            setTimeout(() => {
+              makeManyRequests(makeCheckedRequest, 10, error => {
+                assert(error);
+                done();
+              });
+            }, 3000);
+          });
+        }, 1000);
+      });
+    });
+  });
+  describe("Failure percentage", () => {
+    let makeCheckedRequest: (callback: () => void) => void;
+    let makeUncheckedRequest: (callback: (error?: Error) => void) => void;
+    before(() => {
+      const target = "ipv4:///" + goodPorts.map(port => `127.0.0.1:${port}`).join(",") + `,127.0.0.1:${badPort}`;
+      const client = new EchoService(target, grpc.credentials.createInsecure(), {
+        "grpc.service_config": falurePercentageOutlierDetectionServiceConfigString,
+      });
+      makeUncheckedRequest = (callback: () => void) => {
+        client.echo({ value: "test value", value2: 3 }, (error: grpc.ServiceError, response: any) => {
+          callback();
+        });
+      };
+      makeCheckedRequest = (callback: (error?: Error) => void) => {
+        client.echo({ value: "test value", value2: 3 }, (error: grpc.ServiceError, response: any) => {
+          callback(error);
+        });
+      };
+    });
+    it("Should eject a server if it is failing requests", done => {
+      // Make a large volume of requests
+      makeManyRequests(makeUncheckedRequest, 50, () => {
+        // Give outlier detection time to run ejection checks
+        setTimeout(() => {
+          // Make enough requests to go around all servers
+          makeManyRequests(makeCheckedRequest, 10, done);
+        }, 1000);
+      });
+    });
+    it("Should uneject a server after the ejection period", function (done) {
+      makeManyRequests(makeUncheckedRequest, 50, () => {
+        setTimeout(() => {
+          makeManyRequests(makeCheckedRequest, 10, error => {
+            if (error) {
+              done(error);
+              return;
+            }
+            setTimeout(() => {
+              makeManyRequests(makeCheckedRequest, 10, error => {
+                assert(error);
+                done();
+              });
+            }, 3000);
+          });
+        }, 1000);
+      });
+    });
+  });
+});
diff --git a/test/js/third_party/grpc-js/test-pick-first.test.ts b/test/js/third_party/grpc-js/test-pick-first.test.ts
new file mode 100644
index 0000000000..5d8468d914
--- /dev/null
+++ b/test/js/third_party/grpc-js/test-pick-first.test.ts
@@ -0,0 +1,612 @@
+/*
+ * Copyright 2023 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+import assert from "assert";
+import { afterAll as after, beforeAll as before, describe, it, afterEach, beforeEach } from "bun:test";
+
+import { ConnectivityState } from "@grpc/grpc-js/build/src/connectivity-state";
+import { ChannelControlHelper, createChildChannelControlHelper } from "@grpc/grpc-js/build/src/load-balancer";
+import {
+  PickFirstLoadBalancer,
+  PickFirstLoadBalancingConfig,
+  shuffled,
+} from "@grpc/grpc-js/build/src/load-balancer-pick-first";
+import { Metadata } from "@grpc/grpc-js/build/src/metadata";
+import { Picker } from "@grpc/grpc-js/build/src/picker";
+import { Endpoint, subchannelAddressToString } from "@grpc/grpc-js/build/src/subchannel-address";
+import { MockSubchannel, TestClient, TestServer } from "./common";
+import { credentials } from "@grpc/grpc-js";
+
+function updateStateCallBackForExpectedStateSequence(expectedStateSequence: ConnectivityState[], done: Mocha.Done) {
+  const actualStateSequence: ConnectivityState[] = [];
+  let lastPicker: Picker | null = null;
+  let finished = false;
+  return (connectivityState: ConnectivityState, picker: Picker) => {
+    if (finished) {
+      return;
+    }
+    // Ignore duplicate state transitions
+    if (connectivityState === actualStateSequence[actualStateSequence.length - 1]) {
+      // Ignore READY duplicate state transitions if the picked subchannel is the same
+      if (
+        connectivityState !== ConnectivityState.READY ||
+        lastPicker?.pick({ extraPickInfo: {}, metadata: new Metadata() })?.subchannel ===
+          picker.pick({ extraPickInfo: {}, metadata: new Metadata() }).subchannel
+      ) {
+        return;
+      }
+    }
+    if (expectedStateSequence[actualStateSequence.length] !== connectivityState) {
+      finished = true;
+      done(
+        new Error(
+          `Unexpected state ${ConnectivityState[connectivityState]} after [${actualStateSequence.map(
+            value => ConnectivityState[value],
+          )}]`,
+        ),
+      );
+      return;
+    }
+    actualStateSequence.push(connectivityState);
+    lastPicker = picker;
+    if (actualStateSequence.length === expectedStateSequence.length) {
+      finished = true;
+      done();
+    }
+  };
+}
+
+describe("Shuffler", () => {
+  it("Should maintain the multiset of elements from the original array", () => {
+    const originalArray = [1, 2, 2, 3, 3, 3, 4, 4, 5];
+    for (let i = 0; i < 100; i++) {
+      assert.deepStrictEqual(
+        shuffled(originalArray).sort((a, b) => a - b),
+        originalArray,
+      );
+    }
+  });
+});
+
+describe("pick_first load balancing policy", () => {
+  const config = new PickFirstLoadBalancingConfig(false);
+  let subchannels: MockSubchannel[] = [];
+  const creds = credentials.createInsecure();
+  const baseChannelControlHelper: ChannelControlHelper = {
+    createSubchannel: (subchannelAddress, subchannelArgs) => {
+      const subchannel = new MockSubchannel(subchannelAddressToString(subchannelAddress));
+      subchannels.push(subchannel);
+      return subchannel;
+    },
+    addChannelzChild: () => {},
+    removeChannelzChild: () => {},
+    requestReresolution: () => {},
+    updateState: () => {},
+  };
+  beforeEach(() => {
+    subchannels = [];
+  });
+  it("Should report READY when a subchannel connects", done => {
+    const channelControlHelper = createChildChannelControlHelper(baseChannelControlHelper, {
+      updateState: updateStateCallBackForExpectedStateSequence(
+        [ConnectivityState.CONNECTING, ConnectivityState.READY],
+        done,
+      ),
+    });
+    const pickFirst = new PickFirstLoadBalancer(channelControlHelper, creds, {});
+    pickFirst.updateAddressList([{ addresses: [{ host: "localhost", port: 1 }] }], config);
+    process.nextTick(() => {
+      subchannels[0].transitionToState(ConnectivityState.READY);
+    });
+  });
+  it("Should report READY when a subchannel other than the first connects", done => {
+    const channelControlHelper = createChildChannelControlHelper(baseChannelControlHelper, {
+      updateState: updateStateCallBackForExpectedStateSequence(
+        [ConnectivityState.CONNECTING, ConnectivityState.READY],
+        done,
+      ),
+    });
+    const pickFirst = new PickFirstLoadBalancer(channelControlHelper, creds, {});
+    pickFirst.updateAddressList(
+      [{ addresses: [{ host: "localhost", port: 1 }] }, { addresses: [{ host: "localhost", port: 2 }] }],
+      config,
+    );
+    process.nextTick(() => {
+      subchannels[1].transitionToState(ConnectivityState.READY);
+    });
+  });
+  it("Should report READY when a subchannel other than the first in the same endpoint connects", done => {
+    const channelControlHelper = createChildChannelControlHelper(baseChannelControlHelper, {
+      updateState: updateStateCallBackForExpectedStateSequence(
+        [ConnectivityState.CONNECTING, ConnectivityState.READY],
+        done,
+      ),
+    });
+    const pickFirst = new PickFirstLoadBalancer(channelControlHelper, creds, {});
+    pickFirst.updateAddressList(
+      [
+        {
+          addresses: [
+            { host: "localhost", port: 1 },
+            { host: "localhost", port: 2 },
+          ],
+        },
+      ],
+      config,
+    );
+    process.nextTick(() => {
+      subchannels[1].transitionToState(ConnectivityState.READY);
+    });
+  });
+  it("Should report READY when updated with a subchannel that is already READY", done => {
+    const channelControlHelper = createChildChannelControlHelper(baseChannelControlHelper, {
+      createSubchannel: (subchannelAddress, subchannelArgs) => {
+        const subchannel = new MockSubchannel(subchannelAddressToString(subchannelAddress), ConnectivityState.READY);
+        subchannels.push(subchannel);
+        return subchannel;
+      },
+      updateState: updateStateCallBackForExpectedStateSequence([ConnectivityState.READY], done),
+    });
+    const pickFirst = new PickFirstLoadBalancer(channelControlHelper, creds, {});
+    pickFirst.updateAddressList([{ addresses: [{ host: "localhost", port: 1 }] }], config);
+  });
+  it("Should stay CONNECTING if only some subchannels fail to connect", done => {
+    const channelControlHelper = createChildChannelControlHelper(baseChannelControlHelper, {
+      updateState: updateStateCallBackForExpectedStateSequence([ConnectivityState.CONNECTING], done),
+    });
+    const pickFirst = new PickFirstLoadBalancer(channelControlHelper, creds, {});
+    pickFirst.updateAddressList(
+      [{ addresses: [{ host: "localhost", port: 1 }] }, { addresses: [{ host: "localhost", port: 2 }] }],
+      config,
+    );
+    process.nextTick(() => {
+      subchannels[0].transitionToState(ConnectivityState.TRANSIENT_FAILURE);
+    });
+  });
+  it("Should enter TRANSIENT_FAILURE when subchannels fail to connect", done => {
+    const channelControlHelper = createChildChannelControlHelper(baseChannelControlHelper, {
+      updateState: updateStateCallBackForExpectedStateSequence(
+        [ConnectivityState.CONNECTING, ConnectivityState.TRANSIENT_FAILURE],
+        done,
+      ),
+    });
+    const pickFirst = new PickFirstLoadBalancer(channelControlHelper, creds, {});
+    pickFirst.updateAddressList(
+      [{ addresses: [{ host: "localhost", port: 1 }] }, { addresses: [{ host: "localhost", port: 2 }] }],
+      config,
+    );
+    process.nextTick(() => {
+      subchannels[0].transitionToState(ConnectivityState.TRANSIENT_FAILURE);
+    });
+    process.nextTick(() => {
+      subchannels[1].transitionToState(ConnectivityState.TRANSIENT_FAILURE);
+    });
+  });
+  it("Should stay in TRANSIENT_FAILURE if subchannels go back to CONNECTING", done => {
+    const channelControlHelper = createChildChannelControlHelper(baseChannelControlHelper, {
+      updateState: updateStateCallBackForExpectedStateSequence(
+        [ConnectivityState.CONNECTING, ConnectivityState.TRANSIENT_FAILURE],
+        done,
+      ),
+    });
+    const pickFirst = new PickFirstLoadBalancer(channelControlHelper, creds, {});
+    pickFirst.updateAddressList(
+      [{ addresses: [{ host: "localhost", port: 1 }] }, { addresses: [{ host: "localhost", port: 2 }] }],
+      config,
+    );
+    process.nextTick(() => {
+      subchannels[0].transitionToState(ConnectivityState.TRANSIENT_FAILURE);
+      process.nextTick(() => {
+        subchannels[1].transitionToState(ConnectivityState.TRANSIENT_FAILURE);
+        process.nextTick(() => {
+          subchannels[0].transitionToState(ConnectivityState.CONNECTING);
+          process.nextTick(() => {
+            subchannels[1].transitionToState(ConnectivityState.CONNECTING);
+          });
+        });
+      });
+    });
+  });
+  it("Should immediately enter TRANSIENT_FAILURE if subchannels start in TRANSIENT_FAILURE", done => {
+    const channelControlHelper = createChildChannelControlHelper(baseChannelControlHelper, {
+      createSubchannel: (subchannelAddress, subchannelArgs) => {
+        const subchannel = new MockSubchannel(
+          subchannelAddressToString(subchannelAddress),
+          ConnectivityState.TRANSIENT_FAILURE,
+        );
+        subchannels.push(subchannel);
+        return subchannel;
+      },
+      updateState: updateStateCallBackForExpectedStateSequence([ConnectivityState.TRANSIENT_FAILURE], done),
+    });
+    const pickFirst = new PickFirstLoadBalancer(channelControlHelper, creds, {});
+    pickFirst.updateAddressList(
+      [{ addresses: [{ host: "localhost", port: 1 }] }, { addresses: [{ host: "localhost", port: 2 }] }],
+      config,
+    );
+  });
+  it("Should enter READY if a subchannel connects after entering TRANSIENT_FAILURE mode", done => {
+    const channelControlHelper = createChildChannelControlHelper(baseChannelControlHelper, {
+      createSubchannel: (subchannelAddress, subchannelArgs) => {
+        const subchannel = new MockSubchannel(
+          subchannelAddressToString(subchannelAddress),
+          ConnectivityState.TRANSIENT_FAILURE,
+        );
+        subchannels.push(subchannel);
+        return subchannel;
+      },
+      updateState: updateStateCallBackForExpectedStateSequence(
+        [ConnectivityState.TRANSIENT_FAILURE, ConnectivityState.READY],
+        done,
+      ),
+    });
+    const pickFirst = new PickFirstLoadBalancer(channelControlHelper, creds, {});
+    pickFirst.updateAddressList(
+      [{ addresses: [{ host: "localhost", port: 1 }] }, { addresses: [{ host: "localhost", port: 2 }] }],
+      config,
+    );
+    process.nextTick(() => {
+      subchannels[0].transitionToState(ConnectivityState.READY);
+    });
+  });
+  it("Should stay in TRANSIENT_FAILURE after an address update with non-READY subchannels", done => {
+    let currentStartState = ConnectivityState.TRANSIENT_FAILURE;
+    const channelControlHelper = createChildChannelControlHelper(baseChannelControlHelper, {
+      createSubchannel: (subchannelAddress, subchannelArgs) => {
+        const subchannel = new MockSubchannel(subchannelAddressToString(subchannelAddress), currentStartState);
+        subchannels.push(subchannel);
+        return subchannel;
+      },
+      updateState: updateStateCallBackForExpectedStateSequence([ConnectivityState.TRANSIENT_FAILURE], done),
+    });
+    const pickFirst = new PickFirstLoadBalancer(channelControlHelper, creds, {});
+    pickFirst.updateAddressList(
+      [{ addresses: [{ host: "localhost", port: 1 }] }, { addresses: [{ host: "localhost", port: 2 }] }],
+      config,
+    );
+    process.nextTick(() => {
+      currentStartState = ConnectivityState.CONNECTING;
+      pickFirst.updateAddressList(
+        [{ addresses: [{ host: "localhost", port: 1 }] }, { addresses: [{ host: "localhost", port: 2 }] }],
+        config,
+      );
+    });
+  });
+  it("Should transition from TRANSIENT_FAILURE to READY after an address update with a READY subchannel", done => {
+    let currentStartState = ConnectivityState.TRANSIENT_FAILURE;
+    const channelControlHelper = createChildChannelControlHelper(baseChannelControlHelper, {
+      createSubchannel: (subchannelAddress, subchannelArgs) => {
+        const subchannel = new MockSubchannel(subchannelAddressToString(subchannelAddress), currentStartState);
+        subchannels.push(subchannel);
+        return subchannel;
+      },
+      updateState: updateStateCallBackForExpectedStateSequence(
+        [ConnectivityState.TRANSIENT_FAILURE, ConnectivityState.READY],
+        done,
+      ),
+    });
+    const pickFirst = new PickFirstLoadBalancer(channelControlHelper, creds, {});
+    pickFirst.updateAddressList(
+      [{ addresses: [{ host: "localhost", port: 1 }] }, { addresses: [{ host: "localhost", port: 2 }] }],
+      config,
+    );
+    process.nextTick(() => {
+      currentStartState = ConnectivityState.READY;
+      pickFirst.updateAddressList([{ addresses: [{ host: "localhost", port: 3 }] }], config);
+    });
+  });
+  it("Should transition from READY to IDLE if the connected subchannel disconnects", done => {
+    const currentStartState = ConnectivityState.READY;
+    const channelControlHelper = createChildChannelControlHelper(baseChannelControlHelper, {
+      createSubchannel: (subchannelAddress, subchannelArgs) => {
+        const subchannel = new MockSubchannel(subchannelAddressToString(subchannelAddress), currentStartState);
+        subchannels.push(subchannel);
+        return subchannel;
+      },
+      updateState: updateStateCallBackForExpectedStateSequence([ConnectivityState.READY, ConnectivityState.IDLE], done),
+    });
+    const pickFirst = new PickFirstLoadBalancer(channelControlHelper, creds, {});
+    pickFirst.updateAddressList([{ addresses: [{ host: "localhost", port: 1 }] }], config);
+    process.nextTick(() => {
+      subchannels[0].transitionToState(ConnectivityState.IDLE);
+    });
+  });
+  it("Should transition from READY to CONNECTING if the connected subchannel disconnects after an update", done => {
+    let currentStartState = ConnectivityState.READY;
+    const channelControlHelper = createChildChannelControlHelper(baseChannelControlHelper, {
+      createSubchannel: (subchannelAddress, subchannelArgs) => {
+        const subchannel = new MockSubchannel(subchannelAddressToString(subchannelAddress), currentStartState);
+        subchannels.push(subchannel);
+        return subchannel;
+      },
+      updateState: updateStateCallBackForExpectedStateSequence(
+        [ConnectivityState.READY, ConnectivityState.CONNECTING],
+        done,
+      ),
+    });
+    const pickFirst = new PickFirstLoadBalancer(channelControlHelper, creds, {});
+    pickFirst.updateAddressList([{ addresses: [{ host: "localhost", port: 1 }] }], config);
+    process.nextTick(() => {
+      currentStartState = ConnectivityState.IDLE;
+      pickFirst.updateAddressList([{ addresses: [{ host: "localhost", port: 2 }] }], config);
+      process.nextTick(() => {
+        subchannels[0].transitionToState(ConnectivityState.IDLE);
+      });
+    });
+  });
+  it("Should transition from READY to TRANSIENT_FAILURE if the connected subchannel disconnects and the update fails", done => {
+    let currentStartState = ConnectivityState.READY;
+    const channelControlHelper = createChildChannelControlHelper(baseChannelControlHelper, {
+      createSubchannel: (subchannelAddress, subchannelArgs) => {
+        const subchannel = new MockSubchannel(subchannelAddressToString(subchannelAddress), currentStartState);
+        subchannels.push(subchannel);
+        return subchannel;
+      },
+      updateState: updateStateCallBackForExpectedStateSequence(
+        [ConnectivityState.READY, ConnectivityState.TRANSIENT_FAILURE],
+        done,
+      ),
+    });
+    const pickFirst = new PickFirstLoadBalancer(channelControlHelper, creds, {});
+    pickFirst.updateAddressList([{ addresses: [{ host: "localhost", port: 1 }] }], config);
+    process.nextTick(() => {
+      currentStartState = ConnectivityState.TRANSIENT_FAILURE;
+      pickFirst.updateAddressList([{ addresses: [{ host: "localhost", port: 2 }] }], config);
+      process.nextTick(() => {
+        subchannels[0].transitionToState(ConnectivityState.IDLE);
+      });
+    });
+  });
+  it("Should transition from READY to READY if a subchannel is connected and an update has a connected subchannel", done => {
+    const currentStartState = ConnectivityState.READY;
+    const channelControlHelper = createChildChannelControlHelper(baseChannelControlHelper, {
+      createSubchannel: (subchannelAddress, subchannelArgs) => {
+        const subchannel = new MockSubchannel(subchannelAddressToString(subchannelAddress), currentStartState);
+        subchannels.push(subchannel);
+        return subchannel;
+      },
+      updateState: updateStateCallBackForExpectedStateSequence(
+        [ConnectivityState.READY, ConnectivityState.READY],
+        done,
+      ),
+    });
+    const pickFirst = new PickFirstLoadBalancer(channelControlHelper, creds, {});
+    pickFirst.updateAddressList([{ addresses: [{ host: "localhost", port: 1 }] }], config);
+    process.nextTick(() => {
+      pickFirst.updateAddressList([{ addresses: [{ host: "localhost", port: 2 }] }], config);
+      process.nextTick(() => {
+        subchannels[0].transitionToState(ConnectivityState.IDLE);
+      });
+    });
+  });
+  it("Should request reresolution every time each child reports TF", done => {
+    let reresolutionRequestCount = 0;
+    const targetReresolutionRequestCount = 3;
+    const currentStartState = ConnectivityState.IDLE;
+    const channelControlHelper = createChildChannelControlHelper(baseChannelControlHelper, {
+      createSubchannel: (subchannelAddress, subchannelArgs) => {
+        const subchannel = new MockSubchannel(subchannelAddressToString(subchannelAddress), currentStartState);
+        subchannels.push(subchannel);
+        return subchannel;
+      },
+      updateState: updateStateCallBackForExpectedStateSequence(
+        [ConnectivityState.CONNECTING, ConnectivityState.TRANSIENT_FAILURE],
+        err =>
+          setImmediate(() => {
+            assert.strictEqual(reresolutionRequestCount, targetReresolutionRequestCount);
+            done(err);
+          }),
+      ),
+      requestReresolution: () => {
+        reresolutionRequestCount += 1;
+      },
+    });
+    const pickFirst = new PickFirstLoadBalancer(channelControlHelper, creds, {});
+    pickFirst.updateAddressList([{ addresses: [{ host: "localhost", port: 1 }] }], config);
+    process.nextTick(() => {
+      subchannels[0].transitionToState(ConnectivityState.TRANSIENT_FAILURE);
+      process.nextTick(() => {
+        pickFirst.updateAddressList([{ addresses: [{ host: "localhost", port: 2 }] }], config);
+        process.nextTick(() => {
+          subchannels[1].transitionToState(ConnectivityState.TRANSIENT_FAILURE);
+          process.nextTick(() => {
+            pickFirst.updateAddressList([{ addresses: [{ host: "localhost", port: 3 }] }], config);
+            process.nextTick(() => {
+              subchannels[2].transitionToState(ConnectivityState.TRANSIENT_FAILURE);
+            });
+          });
+        });
+      });
+    });
+  });
+  it("Should request reresolution if the new subchannels are already in TF", done => {
+    let reresolutionRequestCount = 0;
+    const targetReresolutionRequestCount = 3;
+    const currentStartState = ConnectivityState.TRANSIENT_FAILURE;
+    const channelControlHelper = createChildChannelControlHelper(baseChannelControlHelper, {
+      createSubchannel: (subchannelAddress, subchannelArgs) => {
+        const subchannel = new MockSubchannel(subchannelAddressToString(subchannelAddress), currentStartState);
+        subchannels.push(subchannel);
+        return subchannel;
+      },
+      updateState: updateStateCallBackForExpectedStateSequence([ConnectivityState.TRANSIENT_FAILURE], err =>
+        setImmediate(() => {
+          assert.strictEqual(reresolutionRequestCount, targetReresolutionRequestCount);
+          done(err);
+        }),
+      ),
+      requestReresolution: () => {
+        reresolutionRequestCount += 1;
+      },
+    });
+    const pickFirst = new PickFirstLoadBalancer(channelControlHelper, creds, {});
+    pickFirst.updateAddressList([{ addresses: [{ host: "localhost", port: 1 }] }], config);
+    process.nextTick(() => {
+      pickFirst.updateAddressList([{ addresses: [{ host: "localhost", port: 2 }] }], config);
+      process.nextTick(() => {
+        pickFirst.updateAddressList([{ addresses: [{ host: "localhost", port: 2 }] }], config);
+      });
+    });
+  });
+  it("Should reconnect to the same address list if exitIdle is called", done => {
+    const currentStartState = ConnectivityState.READY;
+    const channelControlHelper = createChildChannelControlHelper(baseChannelControlHelper, {
+      createSubchannel: (subchannelAddress, subchannelArgs) => {
+        const subchannel = new MockSubchannel(subchannelAddressToString(subchannelAddress), currentStartState);
+        subchannels.push(subchannel);
+        return subchannel;
+      },
+      updateState: updateStateCallBackForExpectedStateSequence(
+        [ConnectivityState.READY, ConnectivityState.IDLE, ConnectivityState.READY],
+        done,
+      ),
+    });
+    const pickFirst = new PickFirstLoadBalancer(channelControlHelper, creds, {});
+    pickFirst.updateAddressList([{ addresses: [{ host: "localhost", port: 1 }] }], config);
+    process.nextTick(() => {
+      subchannels[0].transitionToState(ConnectivityState.IDLE);
+      process.nextTick(() => {
+        pickFirst.exitIdle();
+      });
+    });
+  });
+  describe("Address list randomization", () => {
+    const shuffleConfig = new PickFirstLoadBalancingConfig(true);
+    it("Should pick different subchannels after multiple updates", done => {
+      const pickedSubchannels: Set<string> = new Set();
+      const channelControlHelper = createChildChannelControlHelper(baseChannelControlHelper, {
+        createSubchannel: (subchannelAddress, subchannelArgs) => {
+          const subchannel = new MockSubchannel(subchannelAddressToString(subchannelAddress), ConnectivityState.READY);
+          subchannels.push(subchannel);
+          return subchannel;
+        },
+        updateState: (connectivityState, picker) => {
+          if (connectivityState === ConnectivityState.READY) {
+            const pickedSubchannel = picker.pick({
+              extraPickInfo: {},
+              metadata: new Metadata(),
+            }).subchannel;
+            if (pickedSubchannel) {
+              pickedSubchannels.add(pickedSubchannel.getAddress());
+            }
+          }
+        },
+      });
+      const endpoints: Endpoint[] = [];
+      for (let i = 0; i < 10; i++) {
+        endpoints.push({ addresses: [{ host: "localhost", port: i + 1 }] });
+      }
+      const pickFirst = new PickFirstLoadBalancer(channelControlHelper, creds, {});
+      /* Pick from 10 subchannels 5 times, with address randomization enabled,
+       * and verify that at least two different subchannels are picked. The
+       * probability choosing the same address every time is 1/10,000, which
+       * I am considering an acceptable flake rate */
+      pickFirst.updateAddressList(endpoints, shuffleConfig);
+      process.nextTick(() => {
+        pickFirst.updateAddressList(endpoints, shuffleConfig);
+        process.nextTick(() => {
+          pickFirst.updateAddressList(endpoints, shuffleConfig);
+          process.nextTick(() => {
+            pickFirst.updateAddressList(endpoints, shuffleConfig);
+            process.nextTick(() => {
+              pickFirst.updateAddressList(endpoints, shuffleConfig);
+              process.nextTick(() => {
+                assert(pickedSubchannels.size > 1);
+                done();
+              });
+            });
+          });
+        });
+      });
+    });
+    it("Should pick the same subchannel if address randomization is disabled", done => {
+      /* This is the same test as the previous one, except using the config
+       * that does not enable address randomization. In this case, false
+       * positive probability is 1/10,000. */
+      const pickedSubchannels: Set<string> = new Set();
+      const channelControlHelper = createChildChannelControlHelper(baseChannelControlHelper, {
+        createSubchannel: (subchannelAddress, subchannelArgs) => {
+          const subchannel = new MockSubchannel(subchannelAddressToString(subchannelAddress), ConnectivityState.READY);
+          subchannels.push(subchannel);
+          return subchannel;
+        },
+        updateState: (connectivityState, picker) => {
+          if (connectivityState === ConnectivityState.READY) {
+            const pickedSubchannel = picker.pick({
+              extraPickInfo: {},
+              metadata: new Metadata(),
+            }).subchannel;
+            if (pickedSubchannel) {
+              pickedSubchannels.add(pickedSubchannel.getAddress());
+            }
+          }
+        },
+      });
+      const endpoints: Endpoint[] = [];
+      for (let i = 0; i < 10; i++) {
+        endpoints.push({ addresses: [{ host: "localhost", port: i + 1 }] });
+      }
+      const pickFirst = new PickFirstLoadBalancer(channelControlHelper, creds, {});
+      pickFirst.updateAddressList(endpoints, config);
+      process.nextTick(() => {
+        pickFirst.updateAddressList(endpoints, config);
+        process.nextTick(() => {
+          pickFirst.updateAddressList(endpoints, config);
+          process.nextTick(() => {
+            pickFirst.updateAddressList(endpoints, config);
+            process.nextTick(() => {
+              pickFirst.updateAddressList(endpoints, config);
+              process.nextTick(() => {
+                assert(pickedSubchannels.size === 1);
+                done();
+              });
+            });
+          });
+        });
+      });
+    });
+    describe("End-to-end functionality", () => {
+      const serviceConfig = {
+        methodConfig: [],
+        loadBalancingConfig: [
+          {
+            pick_first: {
+              shuffleAddressList: true,
+            },
+          },
+        ],
+      };
+      let server: TestServer;
+      let client: TestClient;
+      before(async () => {
+        server = new TestServer(false);
+        await server.start();
+        client = TestClient.createFromServer(server, {
+          "grpc.service_config": JSON.stringify(serviceConfig),
+        });
+      });
+      after(() => {
+        client.close();
+        server.shutdown();
+      });
+      it("Should still work with shuffleAddressList set", done => {
+        client.sendRequest(error => {
+          done(error);
+        });
+      });
+    });
+  });
+});
diff --git a/test/js/third_party/grpc-js/test-prototype-pollution.test.ts b/test/js/third_party/grpc-js/test-prototype-pollution.test.ts
new file mode 100644
index 0000000000..abf64c1a57
--- /dev/null
+++ b/test/js/third_party/grpc-js/test-prototype-pollution.test.ts
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2020 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import * as assert from "assert";
+import { afterAll as after, beforeAll as before, describe, it, afterEach, beforeEach } from "bun:test";
+import { loadPackageDefinition } from "@grpc/grpc-js";
+
+describe("loadPackageDefinition", () => {
+  it("Should not allow prototype pollution", () => {
+    loadPackageDefinition({ "__proto__.polluted": true } as any);
+    assert.notStrictEqual(({} as any).polluted, true);
+  });
+  it("Should not allow prototype pollution #2", () => {
+    loadPackageDefinition({ "constructor.prototype.polluted": true } as any);
+    assert.notStrictEqual(({} as any).polluted, true);
+  });
+});
diff --git a/test/js/third_party/grpc-js/test-resolver.test.ts b/test/js/third_party/grpc-js/test-resolver.test.ts
new file mode 100644
index 0000000000..fbb22e8346
--- /dev/null
+++ b/test/js/third_party/grpc-js/test-resolver.test.ts
@@ -0,0 +1,624 @@
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// Allow `any` data type for testing runtime type checking.
+// tslint:disable no-any
+import assert from "assert";
+import * as resolverManager from "@grpc/grpc-js/build/src/resolver";
+import * as resolver_dns from "@grpc/grpc-js/build/src/resolver-dns";
+import * as resolver_uds from "@grpc/grpc-js/build/src/resolver-uds";
+import * as resolver_ip from "@grpc/grpc-js/build/src/resolver-ip";
+import { ServiceConfig } from "@grpc/grpc-js/build/src/service-config";
+import { StatusObject } from "@grpc/grpc-js/build/src/call-interface";
+import { isIPv6 } from "harness";
+import {
+  Endpoint,
+  SubchannelAddress,
+  endpointToString,
+  subchannelAddressEqual,
+} from "@grpc/grpc-js/build/src/subchannel-address";
+import { parseUri, GrpcUri } from "@grpc/grpc-js/build/src/uri-parser";
+import { GRPC_NODE_USE_ALTERNATIVE_RESOLVER } from "@grpc/grpc-js/build/src/environment";
+import { afterAll as after, beforeAll as before, describe, it, afterEach, beforeEach } from "bun:test";
+
+function hasMatchingAddress(endpointList: Endpoint[], expectedAddress: SubchannelAddress): boolean {
+  for (const endpoint of endpointList) {
+    for (const address of endpoint.addresses) {
+      if (subchannelAddressEqual(address, expectedAddress)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+describe("Name Resolver", () => {
+  before(() => {
+    resolver_dns.setup();
+    resolver_uds.setup();
+    resolver_ip.setup();
+  });
+  describe("DNS Names", function () {
+    // For some reason DNS queries sometimes take a long time on Windows
+    it("Should resolve localhost properly", function (done) {
+      if (GRPC_NODE_USE_ALTERNATIVE_RESOLVER) {
+        this.skip();
+      }
+      const target = resolverManager.mapUriDefaultScheme(parseUri("localhost:50051")!)!;
+      const listener: resolverManager.ResolverListener = {
+        onSuccessfulResolution: (
+          endpointList: Endpoint[],
+          serviceConfig: ServiceConfig | null,
+          serviceConfigError: StatusObject | null,
+        ) => {
+          // Only handle the first resolution result
+          listener.onSuccessfulResolution = () => {};
+          assert(hasMatchingAddress(endpointList, { host: "127.0.0.1", port: 50051 }));
+          if (isIPv6()) {
+            assert(hasMatchingAddress(endpointList, { host: "::1", port: 50051 }));
+          }
+          done();
+        },
+        onError: (error: StatusObject) => {
+          done(new Error(`Failed with status ${error.details}`));
+        },
+      };
+      const resolver = resolverManager.createResolver(target, listener, {});
+      resolver.updateResolution();
+    });
+    it("Should default to port 443", function (done) {
+      if (GRPC_NODE_USE_ALTERNATIVE_RESOLVER) {
+        this.skip();
+      }
+      const target = resolverManager.mapUriDefaultScheme(parseUri("localhost")!)!;
+      const listener: resolverManager.ResolverListener = {
+        onSuccessfulResolution: (
+          endpointList: Endpoint[],
+          serviceConfig: ServiceConfig | null,
+          serviceConfigError: StatusObject | null,
+        ) => {
+          // Only handle the first resolution result
+          listener.onSuccessfulResolution = () => {};
+          assert(hasMatchingAddress(endpointList, { host: "127.0.0.1", port: 443 }));
+          if (isIPv6()) {
+            assert(hasMatchingAddress(endpointList, { host: "::1", port: 443 }));
+          }
+          done();
+        },
+        onError: (error: StatusObject) => {
+          done(new Error(`Failed with status ${error.details}`));
+        },
+      };
+      const resolver = resolverManager.createResolver(target, listener, {});
+      resolver.updateResolution();
+    });
+    it("Should correctly represent an ipv4 address", done => {
+      const target = resolverManager.mapUriDefaultScheme(parseUri("1.2.3.4")!)!;
+      const listener: resolverManager.ResolverListener = {
+        onSuccessfulResolution: (
+          endpointList: Endpoint[],
+          serviceConfig: ServiceConfig | null,
+          serviceConfigError: StatusObject | null,
+        ) => {
+          // Only handle the first resolution result
+          listener.onSuccessfulResolution = () => {};
+          assert(hasMatchingAddress(endpointList, { host: "1.2.3.4", port: 443 }));
+          done();
+        },
+        onError: (error: StatusObject) => {
+          done(new Error(`Failed with status ${error.details}`));
+        },
+      };
+      const resolver = resolverManager.createResolver(target, listener, {});
+      resolver.updateResolution();
+    });
+    it("Should correctly represent an ipv6 address", done => {
+      const target = resolverManager.mapUriDefaultScheme(parseUri("::1")!)!;
+      const listener: resolverManager.ResolverListener = {
+        onSuccessfulResolution: (
+          endpointList: Endpoint[],
+          serviceConfig: ServiceConfig | null,
+          serviceConfigError: StatusObject | null,
+        ) => {
+          // Only handle the first resolution result
+          listener.onSuccessfulResolution = () => {};
+          assert(hasMatchingAddress(endpointList, { host: "::1", port: 443 }));
+          done();
+        },
+        onError: (error: StatusObject) => {
+          done(new Error(`Failed with status ${error.details}`));
+        },
+      };
+      const resolver = resolverManager.createResolver(target, listener, {});
+      resolver.updateResolution();
+    });
+    it("Should correctly represent a bracketed ipv6 address", done => {
+      const target = resolverManager.mapUriDefaultScheme(parseUri("[::1]:50051")!)!;
+      const listener: resolverManager.ResolverListener = {
+        onSuccessfulResolution: (
+          endpointList: Endpoint[],
+          serviceConfig: ServiceConfig | null,
+          serviceConfigError: StatusObject | null,
+        ) => {
+          // Only handle the first resolution result
+          listener.onSuccessfulResolution = () => {};
+          assert(hasMatchingAddress(endpointList, { host: "::1", port: 50051 }));
+          done();
+        },
+        onError: (error: StatusObject) => {
+          done(new Error(`Failed with status ${error.details}`));
+        },
+      };
+      const resolver = resolverManager.createResolver(target, listener, {});
+      resolver.updateResolution();
+    });
+    it("Should resolve a public address", done => {
+      const target = resolverManager.mapUriDefaultScheme(parseUri("example.com")!)!;
+      const listener: resolverManager.ResolverListener = {
+        onSuccessfulResolution: (
+          endpointList: Endpoint[],
+          serviceConfig: ServiceConfig | null,
+          serviceConfigError: StatusObject | null,
+        ) => {
+          // Only handle the first resolution result
+          listener.onSuccessfulResolution = () => {};
+          assert(endpointList.length > 0);
+          done();
+        },
+        onError: (error: StatusObject) => {
+          done(new Error(`Failed with status ${error.details}`));
+        },
+      };
+      const resolver = resolverManager.createResolver(target, listener, {});
+      resolver.updateResolution();
+    });
+    // Created DNS TXT record using TXT sample from https://github.com/grpc/proposal/blob/master/A2-service-configs-in-dns.md
+    // "grpc_config=[{\"serviceConfig\":{\"loadBalancingPolicy\":\"round_robin\",\"methodConfig\":[{\"name\":[{\"service\":\"MyService\",\"method\":\"Foo\"}],\"waitForReady\":true}]}}]"
+    it.skip("Should resolve a name with TXT service config", done => {
+      const target = resolverManager.mapUriDefaultScheme(parseUri("grpctest.kleinsch.com")!)!;
+      const listener: resolverManager.ResolverListener = {
+        onSuccessfulResolution: (
+          endpointList: Endpoint[],
+          serviceConfig: ServiceConfig | null,
+          serviceConfigError: StatusObject | null,
+        ) => {
+          if (serviceConfig !== null) {
+            assert(serviceConfig.loadBalancingPolicy === "round_robin", "Should have found round robin LB policy");
+            done();
+          }
+        },
+        onError: (error: StatusObject) => {
+          done(new Error(`Failed with status ${error.details}`));
+        },
+      };
+      const resolver = resolverManager.createResolver(target, listener, {});
+      resolver.updateResolution();
+    });
+    it.skip("Should not resolve TXT service config if we disabled service config", done => {
+      const target = resolverManager.mapUriDefaultScheme(parseUri("grpctest.kleinsch.com")!)!;
+      let count = 0;
+      const listener: resolverManager.ResolverListener = {
+        onSuccessfulResolution: (
+          endpointList: Endpoint[],
+          serviceConfig: ServiceConfig | null,
+          serviceConfigError: StatusObject | null,
+        ) => {
+          assert(serviceConfig === null, "Should not have found service config");
+          count++;
+        },
+        onError: (error: StatusObject) => {
+          done(new Error(`Failed with status ${error.details}`));
+        },
+      };
+      const resolver = resolverManager.createResolver(target, listener, {
+        "grpc.service_config_disable_resolution": 1,
+      });
+      resolver.updateResolution();
+      setTimeout(() => {
+        assert(count === 1, "Should have only resolved once");
+        done();
+      }, 2_000);
+    });
+    /* The DNS entry for loopback4.unittest.grpc.io only has a single A record
+     * with the address 127.0.0.1, but the Mac DNS resolver appears to use
+     * NAT64 to create an IPv6 address in that case, so it instead returns
+     * 64:ff9b::7f00:1. Handling that kind of translation is outside of the
+     * scope of this test, so we are skipping it. The test primarily exists
+     * as a regression test for https://github.com/grpc/grpc-node/issues/1044,
+     * and the test 'Should resolve gRPC interop servers' tests the same thing.
+     */
+    it.skip("Should resolve a name with multiple dots", done => {
+      const target = resolverManager.mapUriDefaultScheme(parseUri("loopback4.unittest.grpc.io")!)!;
+      const listener: resolverManager.ResolverListener = {
+        onSuccessfulResolution: (
+          endpointList: Endpoint[],
+          serviceConfig: ServiceConfig | null,
+          serviceConfigError: StatusObject | null,
+        ) => {
+          // Only handle the first resolution result
+          listener.onSuccessfulResolution = () => {};
+          assert(
+            hasMatchingAddress(endpointList, { host: "127.0.0.1", port: 443 }),
+            `None of [${endpointList.map(addr => endpointToString(addr))}] matched '127.0.0.1:443'`,
+          );
+          done();
+        },
+        onError: (error: StatusObject) => {
+          done(new Error(`Failed with status ${error.details}`));
+        },
+      };
+      const resolver = resolverManager.createResolver(target, listener, {});
+      resolver.updateResolution();
+    });
+    /* TODO(murgatroid99): re-enable this test, once we can get the IPv6 result
+     * consistently */
+    it.skip("Should resolve a DNS name to an IPv6 address", done => {
+      const target = resolverManager.mapUriDefaultScheme(parseUri("loopback6.unittest.grpc.io")!)!;
+      const listener: resolverManager.ResolverListener = {
+        onSuccessfulResolution: (
+          endpointList: Endpoint[],
+          serviceConfig: ServiceConfig | null,
+          serviceConfigError: StatusObject | null,
+        ) => {
+          // Only handle the first resolution result
+          listener.onSuccessfulResolution = () => {};
+          assert(hasMatchingAddress(endpointList, { host: "::1", port: 443 }));
+          done();
+        },
+        onError: (error: StatusObject) => {
+          done(new Error(`Failed with status ${error.details}`));
+        },
+      };
+      const resolver = resolverManager.createResolver(target, listener, {});
+      resolver.updateResolution();
+    });
+    /* This DNS name resolves to only the IPv4 address on Windows, and only the
+     * IPv6 address on Mac. There is no result that we can consistently test
+     * for here. */
+    it.skip("Should resolve a DNS name to IPv4 and IPv6 addresses", done => {
+      const target = resolverManager.mapUriDefaultScheme(parseUri("loopback46.unittest.grpc.io")!)!;
+      const listener: resolverManager.ResolverListener = {
+        onSuccessfulResolution: (
+          endpointList: Endpoint[],
+          serviceConfig: ServiceConfig | null,
+          serviceConfigError: StatusObject | null,
+        ) => {
+          // Only handle the first resolution result
+          listener.onSuccessfulResolution = () => {};
+          assert(
+            hasMatchingAddress(endpointList, { host: "127.0.0.1", port: 443 }),
+            `None of [${endpointList.map(addr => endpointToString(addr))}] matched '127.0.0.1:443'`,
+          );
+          /* TODO(murgatroid99): check for IPv6 result, once we can get that
+           * consistently */
+          done();
+        },
+        onError: (error: StatusObject) => {
+          done(new Error(`Failed with status ${error.details}`));
+        },
+      };
+      const resolver = resolverManager.createResolver(target, listener, {});
+      resolver.updateResolution();
+    });
+    it("Should resolve a name with a hyphen", done => {
+      /* TODO(murgatroid99): Find or create a better domain name to test this with.
+       * This is just the first one I found with a hyphen. */
+      const target = resolverManager.mapUriDefaultScheme(parseUri("network-tools.com")!)!;
+      const listener: resolverManager.ResolverListener = {
+        onSuccessfulResolution: (
+          endpointList: Endpoint[],
+          serviceConfig: ServiceConfig | null,
+          serviceConfigError: StatusObject | null,
+        ) => {
+          // Only handle the first resolution result
+          listener.onSuccessfulResolution = () => {};
+          assert(endpointList.length > 0);
+          done();
+        },
+        onError: (error: StatusObject) => {
+          done(new Error(`Failed with status ${error.details}`));
+        },
+      };
+      const resolver = resolverManager.createResolver(target, listener, {});
+      resolver.updateResolution();
+    });
+    /* This test also serves as a regression test for
+     * https://github.com/grpc/grpc-node/issues/1044, specifically handling
+     * hyphens and multiple periods in a DNS name. It should not be skipped
+     * unless there is another test for the same issue. */
+    it("Should resolve gRPC interop servers", done => {
+      let completeCount = 0;
+      const target1 = resolverManager.mapUriDefaultScheme(parseUri("grpc-test.sandbox.googleapis.com")!)!;
+      const target2 = resolverManager.mapUriDefaultScheme(parseUri("grpc-test4.sandbox.googleapis.com")!)!;
+      const listener: resolverManager.ResolverListener = {
+        onSuccessfulResolution: (
+          endpointList: Endpoint[],
+          serviceConfig: ServiceConfig | null,
+          serviceConfigError: StatusObject | null,
+        ) => {
+          assert(endpointList.length > 0);
+          completeCount += 1;
+          if (completeCount === 2) {
+            // Only handle the first resolution result
+            listener.onSuccessfulResolution = () => {};
+            done();
+          }
+        },
+        onError: (error: StatusObject) => {
+          done(new Error(`Failed with status ${error.details}`));
+        },
+      };
+      const resolver1 = resolverManager.createResolver(target1, listener, {});
+      resolver1.updateResolution();
+      const resolver2 = resolverManager.createResolver(target2, listener, {});
+      resolver2.updateResolution();
+    });
+    it.todo(
+      "should not keep repeating successful resolutions",
+      function (done) {
+        if (GRPC_NODE_USE_ALTERNATIVE_RESOLVER) {
+          this.skip();
+        }
+        const target = resolverManager.mapUriDefaultScheme(parseUri("localhost")!)!;
+        let resultCount = 0;
+        const resolver = resolverManager.createResolver(
+          target,
+          {
+            onSuccessfulResolution: (
+              endpointList: Endpoint[],
+              serviceConfig: ServiceConfig | null,
+              serviceConfigError: StatusObject | null,
+            ) => {
+              assert(hasMatchingAddress(endpointList, { host: "127.0.0.1", port: 443 }));
+              assert(hasMatchingAddress(endpointList, { host: "::1", port: 443 }));
+              resultCount += 1;
+              if (resultCount === 1) {
+                process.nextTick(() => resolver.updateResolution());
+              }
+            },
+            onError: (error: StatusObject) => {
+              assert.ifError(error);
+            },
+          },
+          { "grpc.dns_min_time_between_resolutions_ms": 2000 },
+        );
+        resolver.updateResolution();
+        setTimeout(() => {
+          assert.strictEqual(resultCount, 2, `resultCount ${resultCount} !== 2`);
+          done();
+        }, 10_000);
+      },
+      15_000,
+    );
+    it("should not keep repeating failed resolutions", done => {
+      const target = resolverManager.mapUriDefaultScheme(parseUri("host.invalid")!)!;
+      let resultCount = 0;
+      const resolver = resolverManager.createResolver(
+        target,
+        {
+          onSuccessfulResolution: (
+            endpointList: Endpoint[],
+            serviceConfig: ServiceConfig | null,
+            serviceConfigError: StatusObject | null,
+          ) => {
+            assert.fail("Resolution succeeded unexpectedly");
+          },
+          onError: (error: StatusObject) => {
+            resultCount += 1;
+            if (resultCount === 1) {
+              process.nextTick(() => resolver.updateResolution());
+            }
+          },
+        },
+        {},
+      );
+      resolver.updateResolution();
+      setTimeout(() => {
+        assert.strictEqual(resultCount, 2, `resultCount ${resultCount} !== 2`);
+        done();
+      }, 10_000);
+    }, 15_000);
+  });
+  describe("UDS Names", () => {
+    it("Should handle a relative Unix Domain Socket name", done => {
+      const target = resolverManager.mapUriDefaultScheme(parseUri("unix:socket")!)!;
+      const listener: resolverManager.ResolverListener = {
+        onSuccessfulResolution: (
+          endpointList: Endpoint[],
+          serviceConfig: ServiceConfig | null,
+          serviceConfigError: StatusObject | null,
+        ) => {
+          // Only handle the first resolution result
+          listener.onSuccessfulResolution = () => {};
+          assert(hasMatchingAddress(endpointList, { path: "socket" }));
+          done();
+        },
+        onError: (error: StatusObject) => {
+          done(new Error(`Failed with status ${error.details}`));
+        },
+      };
+      const resolver = resolverManager.createResolver(target, listener, {});
+      resolver.updateResolution();
+    });
+    it("Should handle an absolute Unix Domain Socket name", done => {
+      const target = resolverManager.mapUriDefaultScheme(parseUri("unix:///tmp/socket")!)!;
+      const listener: resolverManager.ResolverListener = {
+        onSuccessfulResolution: (
+          endpointList: Endpoint[],
+          serviceConfig: ServiceConfig | null,
+          serviceConfigError: StatusObject | null,
+        ) => {
+          // Only handle the first resolution result
+          listener.onSuccessfulResolution = () => {};
+          assert(hasMatchingAddress(endpointList, { path: "/tmp/socket" }));
+          done();
+        },
+        onError: (error: StatusObject) => {
+          done(new Error(`Failed with status ${error.details}`));
+        },
+      };
+      const resolver = resolverManager.createResolver(target, listener, {});
+      resolver.updateResolution();
+    });
+  });
+  describe("IP Addresses", () => {
+    it("should handle one IPv4 address with no port", done => {
+      const target = resolverManager.mapUriDefaultScheme(parseUri("ipv4:127.0.0.1")!)!;
+      const listener: resolverManager.ResolverListener = {
+        onSuccessfulResolution: (
+          endpointList: Endpoint[],
+          serviceConfig: ServiceConfig | null,
+          serviceConfigError: StatusObject | null,
+        ) => {
+          // Only handle the first resolution result
+          listener.onSuccessfulResolution = () => {};
+          assert(hasMatchingAddress(endpointList, { host: "127.0.0.1", port: 443 }));
+          done();
+        },
+        onError: (error: StatusObject) => {
+          done(new Error(`Failed with status ${error.details}`));
+        },
+      };
+      const resolver = resolverManager.createResolver(target, listener, {});
+      resolver.updateResolution();
+    });
+    it("should handle one IPv4 address with a port", done => {
+      const target = resolverManager.mapUriDefaultScheme(parseUri("ipv4:127.0.0.1:50051")!)!;
+      const listener: resolverManager.ResolverListener = {
+        onSuccessfulResolution: (
+          endpointList: Endpoint[],
+          serviceConfig: ServiceConfig | null,
+          serviceConfigError: StatusObject | null,
+        ) => {
+          // Only handle the first resolution result
+          listener.onSuccessfulResolution = () => {};
+          assert(hasMatchingAddress(endpointList, { host: "127.0.0.1", port: 50051 }));
+          done();
+        },
+        onError: (error: StatusObject) => {
+          done(new Error(`Failed with status ${error.details}`));
+        },
+      };
+      const resolver = resolverManager.createResolver(target, listener, {});
+      resolver.updateResolution();
+    });
+    it("should handle multiple IPv4 addresses with different ports", done => {
+      const target = resolverManager.mapUriDefaultScheme(parseUri("ipv4:127.0.0.1:50051,127.0.0.1:50052")!)!;
+      const listener: resolverManager.ResolverListener = {
+        onSuccessfulResolution: (
+          endpointList: Endpoint[],
+          serviceConfig: ServiceConfig | null,
+          serviceConfigError: StatusObject | null,
+        ) => {
+          // Only handle the first resolution result
+          listener.onSuccessfulResolution = () => {};
+          assert(hasMatchingAddress(endpointList, { host: "127.0.0.1", port: 50051 }));
+          assert(hasMatchingAddress(endpointList, { host: "127.0.0.1", port: 50052 }));
+          done();
+        },
+        onError: (error: StatusObject) => {
+          done(new Error(`Failed with status ${error.details}`));
+        },
+      };
+      const resolver = resolverManager.createResolver(target, listener, {});
+      resolver.updateResolution();
+    });
+    it("should handle one IPv6 address with no port", done => {
+      const target = resolverManager.mapUriDefaultScheme(parseUri("ipv6:::1")!)!;
+      const listener: resolverManager.ResolverListener = {
+        onSuccessfulResolution: (
+          endpointList: Endpoint[],
+          serviceConfig: ServiceConfig | null,
+          serviceConfigError: StatusObject | null,
+        ) => {
+          // Only handle the first resolution result
+          listener.onSuccessfulResolution = () => {};
+          assert(hasMatchingAddress(endpointList, { host: "::1", port: 443 }));
+          done();
+        },
+        onError: (error: StatusObject) => {
+          done(new Error(`Failed with status ${error.details}`));
+        },
+      };
+      const resolver = resolverManager.createResolver(target, listener, {});
+      resolver.updateResolution();
+    });
+    it("should handle one IPv6 address with a port", done => {
+      const target = resolverManager.mapUriDefaultScheme(parseUri("ipv6:[::1]:50051")!)!;
+      const listener: resolverManager.ResolverListener = {
+        onSuccessfulResolution: (
+          endpointList: Endpoint[],
+          serviceConfig: ServiceConfig | null,
+          serviceConfigError: StatusObject | null,
+        ) => {
+          // Only handle the first resolution result
+          listener.onSuccessfulResolution = () => {};
+          assert(hasMatchingAddress(endpointList, { host: "::1", port: 50051 }));
+          done();
+        },
+        onError: (error: StatusObject) => {
+          done(new Error(`Failed with status ${error.details}`));
+        },
+      };
+      const resolver = resolverManager.createResolver(target, listener, {});
+      resolver.updateResolution();
+    });
+    it("should handle multiple IPv6 addresses with different ports", done => {
+      const target = resolverManager.mapUriDefaultScheme(parseUri("ipv6:[::1]:50051,[::1]:50052")!)!;
+      const listener: resolverManager.ResolverListener = {
+        onSuccessfulResolution: (
+          endpointList: Endpoint[],
+          serviceConfig: ServiceConfig | null,
+          serviceConfigError: StatusObject | null,
+        ) => {
+          // Only handle the first resolution result
+          listener.onSuccessfulResolution = () => {};
+          assert(hasMatchingAddress(endpointList, { host: "::1", port: 50051 }));
+          assert(hasMatchingAddress(endpointList, { host: "::1", port: 50052 }));
+          done();
+        },
+        onError: (error: StatusObject) => {
+          done(new Error(`Failed with status ${error.details}`));
+        },
+      };
+      const resolver = resolverManager.createResolver(target, listener, {});
+      resolver.updateResolution();
+    });
+  });
+  describe("getDefaultAuthority", () => {
+    class OtherResolver implements resolverManager.Resolver {
+      updateResolution() {
+        return [];
+      }
+
+      destroy() {}
+
+      static getDefaultAuthority(target: GrpcUri): string {
+        return "other";
+      }
+    }
+
+    it("Should return the correct authority if a different resolver has been registered", () => {
+      resolverManager.registerResolver("other", OtherResolver);
+      const target = resolverManager.mapUriDefaultScheme(parseUri("other:name")!)!;
+      console.log(target);
+
+      const authority = resolverManager.getDefaultAuthority(target);
+      assert.equal(authority, "other");
+    });
+  });
+});
diff --git a/test/js/third_party/grpc-js/test-retry-config.test.ts b/test/js/third_party/grpc-js/test-retry-config.test.ts
new file mode 100644
index 0000000000..74210fdaf0
--- /dev/null
+++ b/test/js/third_party/grpc-js/test-retry-config.test.ts
@@ -0,0 +1,307 @@
+/*
+ * Copyright 2022 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import assert from "assert";
+import { validateServiceConfig } from "@grpc/grpc-js/build/src/service-config";
+import { afterAll as after, beforeAll as before, describe, it, afterEach, beforeEach } from "bun:test";
+
+function createRetryServiceConfig(retryConfig: object): object {
+  return {
+    loadBalancingConfig: [],
+    methodConfig: [
+      {
+        name: [
+          {
+            service: "A",
+            method: "B",
+          },
+        ],
+
+        retryPolicy: retryConfig,
+      },
+    ],
+  };
+}
+
+function createHedgingServiceConfig(hedgingConfig: object): object {
+  return {
+    loadBalancingConfig: [],
+    methodConfig: [
+      {
+        name: [
+          {
+            service: "A",
+            method: "B",
+          },
+        ],
+
+        hedgingPolicy: hedgingConfig,
+      },
+    ],
+  };
+}
+
+function createThrottlingServiceConfig(retryThrottling: object): object {
+  return {
+    loadBalancingConfig: [],
+    methodConfig: [],
+    retryThrottling: retryThrottling,
+  };
+}
+
+interface TestCase {
+  description: string;
+  config: object;
+  error: RegExp;
+}
+
+const validRetryConfig = {
+  maxAttempts: 2,
+  initialBackoff: "1s",
+  maxBackoff: "1s",
+  backoffMultiplier: 1,
+  retryableStatusCodes: [14, "RESOURCE_EXHAUSTED"],
+};
+
+const RETRY_TEST_CASES: TestCase[] = [
+  {
+    description: "omitted maxAttempts",
+    config: {
+      initialBackoff: "1s",
+      maxBackoff: "1s",
+      backoffMultiplier: 1,
+      retryableStatusCodes: [14],
+    },
+    error: /retry policy: maxAttempts must be an integer at least 2/,
+  },
+  {
+    description: "a low maxAttempts",
+    config: { ...validRetryConfig, maxAttempts: 1 },
+    error: /retry policy: maxAttempts must be an integer at least 2/,
+  },
+  {
+    description: "omitted initialBackoff",
+    config: {
+      maxAttempts: 2,
+      maxBackoff: "1s",
+      backoffMultiplier: 1,
+      retryableStatusCodes: [14],
+    },
+    error: /retry policy: initialBackoff must be a string consisting of a positive integer or decimal followed by s/,
+  },
+  {
+    description: "a non-numeric initialBackoff",
+    config: { ...validRetryConfig, initialBackoff: "abcs" },
+    error: /retry policy: initialBackoff must be a string consisting of a positive integer or decimal followed by s/,
+  },
+  {
+    description: "an initialBackoff without an s",
+    config: { ...validRetryConfig, initialBackoff: "123" },
+    error: /retry policy: initialBackoff must be a string consisting of a positive integer or decimal followed by s/,
+  },
+  {
+    description: "omitted maxBackoff",
+    config: {
+      maxAttempts: 2,
+      initialBackoff: "1s",
+      backoffMultiplier: 1,
+      retryableStatusCodes: [14],
+    },
+    error: /retry policy: maxBackoff must be a string consisting of a positive integer or decimal followed by s/,
+  },
+  {
+    description: "a non-numeric maxBackoff",
+    config: { ...validRetryConfig, maxBackoff: "abcs" },
+    error: /retry policy: maxBackoff must be a string consisting of a positive integer or decimal followed by s/,
+  },
+  {
+    description: "an maxBackoff without an s",
+    config: { ...validRetryConfig, maxBackoff: "123" },
+    error: /retry policy: maxBackoff must be a string consisting of a positive integer or decimal followed by s/,
+  },
+  {
+    description: "omitted backoffMultiplier",
+    config: {
+      maxAttempts: 2,
+      initialBackoff: "1s",
+      maxBackoff: "1s",
+      retryableStatusCodes: [14],
+    },
+    error: /retry policy: backoffMultiplier must be a number greater than 0/,
+  },
+  {
+    description: "a negative backoffMultiplier",
+    config: { ...validRetryConfig, backoffMultiplier: -1 },
+    error: /retry policy: backoffMultiplier must be a number greater than 0/,
+  },
+  {
+    description: "omitted retryableStatusCodes",
+    config: {
+      maxAttempts: 2,
+      initialBackoff: "1s",
+      maxBackoff: "1s",
+      backoffMultiplier: 1,
+    },
+    error: /retry policy: retryableStatusCodes is required/,
+  },
+  {
+    description: "empty retryableStatusCodes",
+    config: { ...validRetryConfig, retryableStatusCodes: [] },
+    error: /retry policy: retryableStatusCodes must be non-empty/,
+  },
+  {
+    description: "unknown status code name",
+    config: { ...validRetryConfig, retryableStatusCodes: ["abcd"] },
+    error: /retry policy: retryableStatusCodes value not a status code name/,
+  },
+  {
+    description: "out of range status code number",
+    config: { ...validRetryConfig, retryableStatusCodes: [12345] },
+    error: /retry policy: retryableStatusCodes value not in status code range/,
+  },
+];
+
+const validHedgingConfig = {
+  maxAttempts: 2,
+};
+
+const HEDGING_TEST_CASES: TestCase[] = [
+  {
+    description: "omitted maxAttempts",
+    config: {},
+    error: /hedging policy: maxAttempts must be an integer at least 2/,
+  },
+  {
+    description: "a low maxAttempts",
+    config: { ...validHedgingConfig, maxAttempts: 1 },
+    error: /hedging policy: maxAttempts must be an integer at least 2/,
+  },
+  {
+    description: "a non-numeric hedgingDelay",
+    config: { ...validHedgingConfig, hedgingDelay: "abcs" },
+    error: /hedging policy: hedgingDelay must be a string consisting of a positive integer followed by s/,
+  },
+  {
+    description: "a hedgingDelay without an s",
+    config: { ...validHedgingConfig, hedgingDelay: "123" },
+    error: /hedging policy: hedgingDelay must be a string consisting of a positive integer followed by s/,
+  },
+  {
+    description: "unknown status code name",
+    config: { ...validHedgingConfig, nonFatalStatusCodes: ["abcd"] },
+    error: /hedging policy: nonFatalStatusCodes value not a status code name/,
+  },
+  {
+    description: "out of range status code number",
+    config: { ...validHedgingConfig, nonFatalStatusCodes: [12345] },
+    error: /hedging policy: nonFatalStatusCodes value not in status code range/,
+  },
+];
+
+const validThrottlingConfig = {
+  maxTokens: 100,
+  tokenRatio: 0.1,
+};
+
+const THROTTLING_TEST_CASES: TestCase[] = [
+  {
+    description: "omitted maxTokens",
+    config: { tokenRatio: 0.1 },
+    error: /retryThrottling: maxTokens must be a number in \(0, 1000\]/,
+  },
+  {
+    description: "a large maxTokens",
+    config: { ...validThrottlingConfig, maxTokens: 1001 },
+    error: /retryThrottling: maxTokens must be a number in \(0, 1000\]/,
+  },
+  {
+    description: "zero maxTokens",
+    config: { ...validThrottlingConfig, maxTokens: 0 },
+    error: /retryThrottling: maxTokens must be a number in \(0, 1000\]/,
+  },
+  {
+    description: "omitted tokenRatio",
+    config: { maxTokens: 100 },
+    error: /retryThrottling: tokenRatio must be a number greater than 0/,
+  },
+  {
+    description: "zero tokenRatio",
+    config: { ...validThrottlingConfig, tokenRatio: 0 },
+    error: /retryThrottling: tokenRatio must be a number greater than 0/,
+  },
+];
+
+describe("Retry configs", () => {
+  describe("Retry", () => {
+    it("Should accept a valid config", () => {
+      assert.doesNotThrow(() => {
+        validateServiceConfig(createRetryServiceConfig(validRetryConfig));
+      });
+    });
+    for (const testCase of RETRY_TEST_CASES) {
+      it(`Should reject ${testCase.description}`, () => {
+        assert.throws(() => {
+          validateServiceConfig(createRetryServiceConfig(testCase.config));
+        }, testCase.error);
+      });
+    }
+  });
+  describe("Hedging", () => {
+    it("Should accept valid configs", () => {
+      assert.doesNotThrow(() => {
+        validateServiceConfig(createHedgingServiceConfig(validHedgingConfig));
+      });
+      assert.doesNotThrow(() => {
+        validateServiceConfig(
+          createHedgingServiceConfig({
+            ...validHedgingConfig,
+            hedgingDelay: "1s",
+          }),
+        );
+      });
+      assert.doesNotThrow(() => {
+        validateServiceConfig(
+          createHedgingServiceConfig({
+            ...validHedgingConfig,
+            nonFatalStatusCodes: [14, "RESOURCE_EXHAUSTED"],
+          }),
+        );
+      });
+    });
+    for (const testCase of HEDGING_TEST_CASES) {
+      it(`Should reject ${testCase.description}`, () => {
+        assert.throws(() => {
+          validateServiceConfig(createHedgingServiceConfig(testCase.config));
+        }, testCase.error);
+      });
+    }
+  });
+  describe("Throttling", () => {
+    it("Should accept a valid config", () => {
+      assert.doesNotThrow(() => {
+        validateServiceConfig(createThrottlingServiceConfig(validThrottlingConfig));
+      });
+    });
+    for (const testCase of THROTTLING_TEST_CASES) {
+      it(`Should reject ${testCase.description}`, () => {
+        assert.throws(() => {
+          validateServiceConfig(createThrottlingServiceConfig(testCase.config));
+        }, testCase.error);
+      });
+    }
+  });
+});
diff --git a/test/js/third_party/grpc-js/test-retry.test.ts b/test/js/third_party/grpc-js/test-retry.test.ts
index ba50a2a2f8..1b40ea7847 100644
--- a/test/js/third_party/grpc-js/test-retry.test.ts
+++ b/test/js/third_party/grpc-js/test-retry.test.ts
@@ -15,301 +15,351 @@
  *
  */
 
-import * as grpc from "@grpc/grpc-js";
+import * as path from "path";
+import * as grpc from "@grpc/grpc-js/build/src";
+import { loadProtoFile } from "./common";
+
 import assert from "assert";
-import { afterAll, afterEach, beforeAll, beforeEach, describe, it } from "bun:test";
-import { TestClient, TestServer } from "./common";
+import { afterAll as after, beforeAll as before, describe, it, afterEach, beforeEach } from "bun:test";
 
-["h2", "h2c"].forEach(protocol => {
-  describe(`Retries ${protocol}`, () => {
-    let server: TestServer;
-    beforeAll(done => {
-      server = new TestServer(protocol === "h2", undefined, 1);
-      server.start().then(done).catch(done);
-    });
+const protoFile = path.join(__dirname, "fixtures", "echo_service.proto");
+const EchoService = loadProtoFile(protoFile).EchoService as grpc.ServiceClientConstructor;
 
-    afterAll(done => {
-      server.shutdown();
+const serviceImpl = {
+  echo: (call: grpc.ServerUnaryCall<any, any>, callback: grpc.sendUnaryData<any>) => {
+    const succeedOnRetryAttempt = call.metadata.get("succeed-on-retry-attempt");
+    const previousAttempts = call.metadata.get("grpc-previous-rpc-attempts");
+    if (
+      succeedOnRetryAttempt.length === 0 ||
+      (previousAttempts.length > 0 && previousAttempts[0] === succeedOnRetryAttempt[0])
+    ) {
+      callback(null, call.request);
+    } else {
+      const statusCode = call.metadata.get("respond-with-status");
+      const code = statusCode[0] ? Number.parseInt(statusCode[0] as string) : grpc.status.UNKNOWN;
+      callback({
+        code: code,
+        details: `Failed on retry ${previousAttempts[0] ?? 0}`,
+      });
+    }
+  },
+};
+
+describe("Retries", () => {
+  let server: grpc.Server;
+  let port: number;
+  before(done => {
+    server = new grpc.Server();
+    server.addService(EchoService.service, serviceImpl);
+    server.bindAsync("localhost:0", grpc.ServerCredentials.createInsecure(), (error, portNumber) => {
+      if (error) {
+        done(error);
+        return;
+      }
+      port = portNumber;
+      server.start();
       done();
     });
+  });
 
-    describe("Client with retries disabled", () => {
-      let client: InstanceType<grpc.ServiceClientConstructor>;
-      beforeEach(() => {
-        client = TestClient.createFromServer(server, { "grpc.enable_retries": 0 });
-      });
+  after(() => {
+    server.forceShutdown();
+  });
 
-      afterEach(() => {
-        client.close();
-      });
+  describe("Client with retries disabled", () => {
+    let client: InstanceType<grpc.ServiceClientConstructor>;
+    before(() => {
+      client = new EchoService(`localhost:${port}`, grpc.credentials.createInsecure(), { "grpc.enable_retries": 0 });
+    });
 
-      it("Should be able to make a basic request", done => {
-        client.echo({ value: "test value", value2: 3 }, (error: grpc.ServiceError, response: any) => {
-          assert.ifError(error);
-          assert.deepStrictEqual(response, { value: "test value", value2: 3 });
-          done();
-        });
-      });
+    after(() => {
+      client.close();
+    });
 
-      it("Should fail if the server fails the first request", done => {
-        const metadata = new grpc.Metadata();
-        metadata.set("succeed-on-retry-attempt", "1");
-        client.echo({ value: "test value", value2: 3 }, metadata, (error: grpc.ServiceError, response: any) => {
-          assert(error);
-          assert.strictEqual(error.details, "Failed on retry 0");
-          done();
-        });
+    it("Should be able to make a basic request", done => {
+      client.echo({ value: "test value", value2: 3 }, (error: grpc.ServiceError, response: any) => {
+        assert.ifError(error);
+        assert.deepStrictEqual(response, { value: "test value", value2: 3 });
+        done();
       });
     });
 
-    describe("Client with retries enabled but not configured", () => {
-      let client: InstanceType<grpc.ServiceClientConstructor>;
-      beforeEach(() => {
-        client = TestClient.createFromServer(server);
+    it("Should fail if the server fails the first request", done => {
+      const metadata = new grpc.Metadata();
+      metadata.set("succeed-on-retry-attempt", "1");
+      client.echo({ value: "test value", value2: 3 }, metadata, (error: grpc.ServiceError, response: any) => {
+        assert(error);
+        assert.strictEqual(error.details, "Failed on retry 0");
+        done();
       });
+    });
+  });
 
-      afterEach(() => {
-        client.close();
-      });
+  describe("Client with retries enabled but not configured", () => {
+    let client: InstanceType<grpc.ServiceClientConstructor>;
+    before(() => {
+      client = new EchoService(`localhost:${port}`, grpc.credentials.createInsecure());
+    });
 
-      it("Should be able to make a basic request", done => {
-        client.echo({ value: "test value", value2: 3 }, (error: grpc.ServiceError, response: any) => {
-          assert.ifError(error);
-          assert.deepStrictEqual(response, { value: "test value", value2: 3 });
-          done();
-        });
-      });
+    after(() => {
+      client.close();
+    });
 
-      it("Should fail if the server fails the first request", done => {
-        const metadata = new grpc.Metadata();
-        metadata.set("succeed-on-retry-attempt", "1");
-        client.echo({ value: "test value", value2: 3 }, metadata, (error: grpc.ServiceError, response: any) => {
-          assert(error);
-          assert(
-            error.details === "Failed on retry 0" || error.details.indexOf("RST_STREAM with code 0") !== -1,
-            error.details,
-          );
-          done();
-        });
+    it("Should be able to make a basic request", done => {
+      client.echo({ value: "test value", value2: 3 }, (error: grpc.ServiceError, response: any) => {
+        assert.ifError(error);
+        assert.deepStrictEqual(response, { value: "test value", value2: 3 });
+        done();
       });
     });
 
-    describe("Client with retries configured", () => {
-      let client: InstanceType<grpc.ServiceClientConstructor>;
-      beforeEach(() => {
-        const serviceConfig = {
-          loadBalancingConfig: [],
-          methodConfig: [
-            {
-              name: [
-                {
-                  service: "EchoService",
-                },
-              ],
-              retryPolicy: {
-                maxAttempts: 3,
-                initialBackoff: "0.1s",
-                maxBackoff: "10s",
-                backoffMultiplier: 1.2,
-                retryableStatusCodes: [14, "RESOURCE_EXHAUSTED"],
+    it("Should fail if the server fails the first request", done => {
+      const metadata = new grpc.Metadata();
+      metadata.set("succeed-on-retry-attempt", "1");
+      client.echo({ value: "test value", value2: 3 }, metadata, (error: grpc.ServiceError, response: any) => {
+        assert(error);
+        assert.strictEqual(error.details, "Failed on retry 0");
+        done();
+      });
+    });
+  });
+
+  describe("Client with retries configured", () => {
+    let client: InstanceType<grpc.ServiceClientConstructor>;
+    before(() => {
+      const serviceConfig = {
+        loadBalancingConfig: [],
+        methodConfig: [
+          {
+            name: [
+              {
+                service: "EchoService",
               },
+            ],
+            retryPolicy: {
+              maxAttempts: 3,
+              initialBackoff: "0.1s",
+              maxBackoff: "10s",
+              backoffMultiplier: 1.2,
+              retryableStatusCodes: [14, "RESOURCE_EXHAUSTED"],
             },
-          ],
-        };
-        client = TestClient.createFromServer(server, {
-          "grpc.service_config": JSON.stringify(serviceConfig),
-        });
-      });
-
-      afterEach(() => {
-        client.close();
-      });
-
-      it("Should be able to make a basic request", done => {
-        client.echo({ value: "test value", value2: 3 }, (error: grpc.ServiceError, response: any) => {
-          assert.ifError(error);
-          assert.deepStrictEqual(response, { value: "test value", value2: 3 });
-          done();
-        });
-      });
-
-      it("Should succeed with few required attempts", done => {
-        const metadata = new grpc.Metadata();
-        metadata.set("succeed-on-retry-attempt", "2");
-        metadata.set("respond-with-status", `${grpc.status.RESOURCE_EXHAUSTED}`);
-        client.echo({ value: "test value", value2: 3 }, metadata, (error: grpc.ServiceError, response: any) => {
-          assert.ifError(error);
-          assert.deepStrictEqual(response, { value: "test value", value2: 3 });
-          done();
-        });
-      });
-
-      it("Should fail with many required attempts", done => {
-        const metadata = new grpc.Metadata();
-        metadata.set("succeed-on-retry-attempt", "4");
-        metadata.set("respond-with-status", `${grpc.status.RESOURCE_EXHAUSTED}`);
-        client.echo({ value: "test value", value2: 3 }, metadata, (error: grpc.ServiceError, response: any) => {
-          assert(error);
-          //RST_STREAM is a graceful close
-          assert(
-            error.details === "Failed on retry 2" || error.details.indexOf("RST_STREAM with code 0") !== -1,
-            error.details,
-          );
-          done();
-        });
-      });
-
-      it("Should fail with a fatal status code", done => {
-        const metadata = new grpc.Metadata();
-        metadata.set("succeed-on-retry-attempt", "2");
-        metadata.set("respond-with-status", `${grpc.status.NOT_FOUND}`);
-        client.echo({ value: "test value", value2: 3 }, metadata, (error: grpc.ServiceError, response: any) => {
-          assert(error);
-          //RST_STREAM is a graceful close
-          assert(
-            error.details === "Failed on retry 0" || error.details.indexOf("RST_STREAM with code 0") !== -1,
-            error.details,
-          );
-          done();
-        });
-      });
-
-      it("Should not be able to make more than 5 attempts", done => {
-        const serviceConfig = {
-          loadBalancingConfig: [],
-          methodConfig: [
-            {
-              name: [
-                {
-                  service: "EchoService",
-                },
-              ],
-              retryPolicy: {
-                maxAttempts: 10,
-                initialBackoff: "0.1s",
-                maxBackoff: "10s",
-                backoffMultiplier: 1.2,
-                retryableStatusCodes: [14, "RESOURCE_EXHAUSTED"],
-              },
-            },
-          ],
-        };
-        const client2 = TestClient.createFromServer(server, {
-          "grpc.service_config": JSON.stringify(serviceConfig),
-        });
-        const metadata = new grpc.Metadata();
-        metadata.set("succeed-on-retry-attempt", "6");
-        metadata.set("respond-with-status", `${grpc.status.RESOURCE_EXHAUSTED}`);
-        client2.echo({ value: "test value", value2: 3 }, metadata, (error: grpc.ServiceError, response: any) => {
-          client2.close();
-          assert(error);
-          assert(
-            error.details === "Failed on retry 4" || error.details.indexOf("RST_STREAM with code 0") !== -1,
-            error.details,
-          );
-          done();
-        });
+          },
+        ],
+      };
+      client = new EchoService(`localhost:${port}`, grpc.credentials.createInsecure(), {
+        "grpc.service_config": JSON.stringify(serviceConfig),
       });
     });
 
-    describe("Client with hedging configured", () => {
-      let client: InstanceType<grpc.ServiceClientConstructor>;
-      beforeAll(() => {
-        const serviceConfig = {
-          loadBalancingConfig: [],
-          methodConfig: [
-            {
-              name: [
-                {
-                  service: "EchoService",
-                },
-              ],
-              hedgingPolicy: {
-                maxAttempts: 3,
-                nonFatalStatusCodes: [14, "RESOURCE_EXHAUSTED"],
+    after(() => {
+      client.close();
+    });
+
+    it("Should be able to make a basic request", done => {
+      client.echo({ value: "test value", value2: 3 }, (error: grpc.ServiceError, response: any) => {
+        assert.ifError(error);
+        assert.deepStrictEqual(response, { value: "test value", value2: 3 });
+        done();
+      });
+    });
+
+    it("Should succeed with few required attempts", done => {
+      const metadata = new grpc.Metadata();
+      metadata.set("succeed-on-retry-attempt", "2");
+      metadata.set("respond-with-status", `${grpc.status.RESOURCE_EXHAUSTED}`);
+      client.echo({ value: "test value", value2: 3 }, metadata, (error: grpc.ServiceError, response: any) => {
+        assert.ifError(error);
+        assert.deepStrictEqual(response, { value: "test value", value2: 3 });
+        done();
+      });
+    });
+
+    it("Should fail with many required attempts", done => {
+      const metadata = new grpc.Metadata();
+      metadata.set("succeed-on-retry-attempt", "4");
+      metadata.set("respond-with-status", `${grpc.status.RESOURCE_EXHAUSTED}`);
+      client.echo({ value: "test value", value2: 3 }, metadata, (error: grpc.ServiceError, response: any) => {
+        assert(error);
+        assert.strictEqual(error.details, "Failed on retry 2");
+        done();
+      });
+    });
+
+    it("Should fail with a fatal status code", done => {
+      const metadata = new grpc.Metadata();
+      metadata.set("succeed-on-retry-attempt", "2");
+      metadata.set("respond-with-status", `${grpc.status.NOT_FOUND}`);
+      client.echo({ value: "test value", value2: 3 }, metadata, (error: grpc.ServiceError, response: any) => {
+        assert(error);
+        assert.strictEqual(error.details, "Failed on retry 0");
+        done();
+      });
+    });
+
+    it("Should not be able to make more than 5 attempts", done => {
+      const serviceConfig = {
+        loadBalancingConfig: [],
+        methodConfig: [
+          {
+            name: [
+              {
+                service: "EchoService",
               },
+            ],
+            retryPolicy: {
+              maxAttempts: 10,
+              initialBackoff: "0.1s",
+              maxBackoff: "10s",
+              backoffMultiplier: 1.2,
+              retryableStatusCodes: [14, "RESOURCE_EXHAUSTED"],
             },
-          ],
-        };
-        client = TestClient.createFromServer(server, {
-          "grpc.service_config": JSON.stringify(serviceConfig),
-        });
+          },
+        ],
+      };
+      const client2 = new EchoService(`localhost:${port}`, grpc.credentials.createInsecure(), {
+        "grpc.service_config": JSON.stringify(serviceConfig),
       });
-
-      afterAll(() => {
-        client.close();
+      const metadata = new grpc.Metadata();
+      metadata.set("succeed-on-retry-attempt", "6");
+      metadata.set("respond-with-status", `${grpc.status.RESOURCE_EXHAUSTED}`);
+      client2.echo({ value: "test value", value2: 3 }, metadata, (error: grpc.ServiceError, response: any) => {
+        assert(error);
+        assert.strictEqual(error.details, "Failed on retry 4");
+        done();
       });
+    });
 
-      it("Should be able to make a basic request", done => {
-        client.echo({ value: "test value", value2: 3 }, (error: grpc.ServiceError, response: any) => {
-          assert.ifError(error);
-          assert.deepStrictEqual(response, { value: "test value", value2: 3 });
-          done();
-        });
-      });
-
-      it("Should succeed with few required attempts", done => {
-        const metadata = new grpc.Metadata();
-        metadata.set("succeed-on-retry-attempt", "2");
-        metadata.set("respond-with-status", `${grpc.status.RESOURCE_EXHAUSTED}`);
-        client.echo({ value: "test value", value2: 3 }, metadata, (error: grpc.ServiceError, response: any) => {
-          assert.ifError(error);
-          assert.deepStrictEqual(response, { value: "test value", value2: 3 });
-          done();
-        });
-      });
-
-      it("Should fail with many required attempts", done => {
-        const metadata = new grpc.Metadata();
-        metadata.set("succeed-on-retry-attempt", "4");
-        metadata.set("respond-with-status", `${grpc.status.RESOURCE_EXHAUSTED}`);
-        client.echo({ value: "test value", value2: 3 }, metadata, (error: grpc.ServiceError, response: any) => {
-          assert(error);
-          assert(error.details.startsWith("Failed on retry"));
-          done();
-        });
-      });
-
-      it("Should fail with a fatal status code", done => {
-        const metadata = new grpc.Metadata();
-        metadata.set("succeed-on-retry-attempt", "2");
-        metadata.set("respond-with-status", `${grpc.status.NOT_FOUND}`);
-        client.echo({ value: "test value", value2: 3 }, metadata, (error: grpc.ServiceError, response: any) => {
-          assert(error);
-          assert(error.details.startsWith("Failed on retry"));
-          done();
-        });
-      });
-
-      it("Should not be able to make more than 5 attempts", done => {
-        const serviceConfig = {
-          loadBalancingConfig: [],
-          methodConfig: [
-            {
-              name: [
-                {
-                  service: "EchoService",
-                },
-              ],
-              hedgingPolicy: {
-                maxAttempts: 10,
-                nonFatalStatusCodes: [14, "RESOURCE_EXHAUSTED"],
+    it("Should be able to make more than 5 attempts with a channel argument", done => {
+      const serviceConfig = {
+        loadBalancingConfig: [],
+        methodConfig: [
+          {
+            name: [
+              {
+                service: "EchoService",
               },
+            ],
+            retryPolicy: {
+              maxAttempts: 10,
+              initialBackoff: "0.1s",
+              maxBackoff: "10s",
+              backoffMultiplier: 1.2,
+              retryableStatusCodes: [14, "RESOURCE_EXHAUSTED"],
             },
-          ],
-        };
-        const client2 = TestClient.createFromServer(server, {
-          "grpc.service_config": JSON.stringify(serviceConfig),
-        });
-        const metadata = new grpc.Metadata();
-        metadata.set("succeed-on-retry-attempt", "6");
-        metadata.set("respond-with-status", `${grpc.status.RESOURCE_EXHAUSTED}`);
-        client2.echo({ value: "test value", value2: 3 }, metadata, (error: grpc.ServiceError, response: any) => {
-          client2.close();
-          assert(error);
-          assert(error.details.startsWith("Failed on retry"));
-          done();
-        });
+          },
+        ],
+      };
+      const client2 = new EchoService(`localhost:${port}`, grpc.credentials.createInsecure(), {
+        "grpc.service_config": JSON.stringify(serviceConfig),
+        "grpc-node.retry_max_attempts_limit": 8,
+      });
+      const metadata = new grpc.Metadata();
+      metadata.set("succeed-on-retry-attempt", "7");
+      metadata.set("respond-with-status", `${grpc.status.RESOURCE_EXHAUSTED}`);
+      client2.echo({ value: "test value", value2: 3 }, metadata, (error: grpc.ServiceError, response: any) => {
+        assert.ifError(error);
+        assert.deepStrictEqual(response, { value: "test value", value2: 3 });
+        done();
+      });
+    });
+  });
+
+  describe("Client with hedging configured", () => {
+    let client: InstanceType<grpc.ServiceClientConstructor>;
+    before(() => {
+      const serviceConfig = {
+        loadBalancingConfig: [],
+        methodConfig: [
+          {
+            name: [
+              {
+                service: "EchoService",
+              },
+            ],
+            hedgingPolicy: {
+              maxAttempts: 3,
+              nonFatalStatusCodes: [14, "RESOURCE_EXHAUSTED"],
+            },
+          },
+        ],
+      };
+      client = new EchoService(`localhost:${port}`, grpc.credentials.createInsecure(), {
+        "grpc.service_config": JSON.stringify(serviceConfig),
+      });
+    });
+
+    after(() => {
+      client.close();
+    });
+
+    it("Should be able to make a basic request", done => {
+      client.echo({ value: "test value", value2: 3 }, (error: grpc.ServiceError, response: any) => {
+        assert.ifError(error);
+        assert.deepStrictEqual(response, { value: "test value", value2: 3 });
+        done();
+      });
+    });
+
+    it("Should succeed with few required attempts", done => {
+      const metadata = new grpc.Metadata();
+      metadata.set("succeed-on-retry-attempt", "2");
+      metadata.set("respond-with-status", `${grpc.status.RESOURCE_EXHAUSTED}`);
+      client.echo({ value: "test value", value2: 3 }, metadata, (error: grpc.ServiceError, response: any) => {
+        assert.ifError(error);
+        assert.deepStrictEqual(response, { value: "test value", value2: 3 });
+        done();
+      });
+    });
+
+    it("Should fail with many required attempts", done => {
+      const metadata = new grpc.Metadata();
+      metadata.set("succeed-on-retry-attempt", "4");
+      metadata.set("respond-with-status", `${grpc.status.RESOURCE_EXHAUSTED}`);
+      client.echo({ value: "test value", value2: 3 }, metadata, (error: grpc.ServiceError, response: any) => {
+        assert(error);
+        assert(error.details.startsWith("Failed on retry"));
+        done();
+      });
+    });
+
+    it("Should fail with a fatal status code", done => {
+      const metadata = new grpc.Metadata();
+      metadata.set("succeed-on-retry-attempt", "2");
+      metadata.set("respond-with-status", `${grpc.status.NOT_FOUND}`);
+      client.echo({ value: "test value", value2: 3 }, metadata, (error: grpc.ServiceError, response: any) => {
+        assert(error);
+        assert(error.details.startsWith("Failed on retry"));
+        done();
+      });
+    });
+
+    it("Should not be able to make more than 5 attempts", done => {
+      const serviceConfig = {
+        loadBalancingConfig: [],
+        methodConfig: [
+          {
+            name: [
+              {
+                service: "EchoService",
+              },
+            ],
+            hedgingPolicy: {
+              maxAttempts: 10,
+              nonFatalStatusCodes: [14, "RESOURCE_EXHAUSTED"],
+            },
+          },
+        ],
+      };
+      const client2 = new EchoService(`localhost:${port}`, grpc.credentials.createInsecure(), {
+        "grpc.service_config": JSON.stringify(serviceConfig),
+      });
+      const metadata = new grpc.Metadata();
+      metadata.set("succeed-on-retry-attempt", "6");
+      metadata.set("respond-with-status", `${grpc.status.RESOURCE_EXHAUSTED}`);
+      client2.echo({ value: "test value", value2: 3 }, metadata, (error: grpc.ServiceError, response: any) => {
+        assert(error);
+        assert(error.details.startsWith("Failed on retry"));
+        done();
       });
     });
   });
diff --git a/test/js/third_party/grpc-js/test-server-credentials.test.ts b/test/js/third_party/grpc-js/test-server-credentials.test.ts
new file mode 100644
index 0000000000..e9ed5e9aac
--- /dev/null
+++ b/test/js/third_party/grpc-js/test-server-credentials.test.ts
@@ -0,0 +1,124 @@
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// Allow `any` data type for testing runtime type checking.
+// tslint:disable no-any
+import assert from "assert";
+import { readFileSync } from "fs";
+import { join } from "path";
+import { ServerCredentials } from "@grpc/grpc-js/build/src";
+import { afterAll as after, beforeAll as before, describe, it, afterEach, beforeEach } from "bun:test";
+
+const ca = readFileSync(join(__dirname, "fixtures", "ca.pem"));
+const key = readFileSync(join(__dirname, "fixtures", "server1.key"));
+const cert = readFileSync(join(__dirname, "fixtures", "server1.pem"));
+
+describe("Server Credentials", () => {
+  describe("createInsecure", () => {
+    it("creates insecure credentials", () => {
+      const creds = ServerCredentials.createInsecure();
+
+      assert.strictEqual(creds._isSecure(), false);
+      assert.strictEqual(creds._getSettings(), null);
+    });
+  });
+
+  describe("createSsl", () => {
+    it("accepts a buffer and array as the first two arguments", () => {
+      const creds = ServerCredentials.createSsl(ca, []);
+
+      assert.strictEqual(creds._isSecure(), true);
+      assert.strictEqual(creds._getSettings()?.ca, ca);
+    });
+
+    it("accepts a boolean as the third argument", () => {
+      const creds = ServerCredentials.createSsl(ca, [], true);
+
+      assert.strictEqual(creds._isSecure(), true);
+      const settings = creds._getSettings();
+      assert.strictEqual(settings?.ca, ca);
+      assert.strictEqual(settings?.requestCert, true);
+    });
+
+    it("accepts an object with two buffers in the second argument", () => {
+      const keyCertPairs = [{ private_key: key, cert_chain: cert }];
+      const creds = ServerCredentials.createSsl(null, keyCertPairs);
+
+      assert.strictEqual(creds._isSecure(), true);
+      const settings = creds._getSettings();
+      assert.deepStrictEqual(settings?.cert, [cert]);
+      assert.deepStrictEqual(settings?.key, [key]);
+    });
+
+    it("accepts multiple objects in the second argument", () => {
+      const keyCertPairs = [
+        { private_key: key, cert_chain: cert },
+        { private_key: key, cert_chain: cert },
+      ];
+      const creds = ServerCredentials.createSsl(null, keyCertPairs, false);
+
+      assert.strictEqual(creds._isSecure(), true);
+      const settings = creds._getSettings();
+      assert.deepStrictEqual(settings?.cert, [cert, cert]);
+      assert.deepStrictEqual(settings?.key, [key, key]);
+    });
+
+    it("fails if the second argument is not an Array", () => {
+      assert.throws(() => {
+        ServerCredentials.createSsl(ca, "test" as any);
+      }, /TypeError: keyCertPairs must be an array/);
+    });
+
+    it("fails if the first argument is a non-Buffer value", () => {
+      assert.throws(() => {
+        ServerCredentials.createSsl("test" as any, []);
+      }, /TypeError: rootCerts must be null or a Buffer/);
+    });
+
+    it("fails if the third argument is a non-boolean value", () => {
+      assert.throws(() => {
+        ServerCredentials.createSsl(ca, [], "test" as any);
+      }, /TypeError: checkClientCertificate must be a boolean/);
+    });
+
+    it("fails if the array elements are not objects", () => {
+      assert.throws(() => {
+        ServerCredentials.createSsl(ca, ["test"] as any);
+      }, /TypeError: keyCertPair\[0\] must be an object/);
+
+      assert.throws(() => {
+        ServerCredentials.createSsl(ca, [null] as any);
+      }, /TypeError: keyCertPair\[0\] must be an object/);
+    });
+
+    it("fails if the object does not have a Buffer private key", () => {
+      const keyCertPairs: any = [{ private_key: "test", cert_chain: cert }];
+
+      assert.throws(() => {
+        ServerCredentials.createSsl(null, keyCertPairs);
+      }, /TypeError: keyCertPair\[0\].private_key must be a Buffer/);
+    });
+
+    it("fails if the object does not have a Buffer cert chain", () => {
+      const keyCertPairs: any = [{ private_key: key, cert_chain: "test" }];
+
+      assert.throws(() => {
+        ServerCredentials.createSsl(null, keyCertPairs);
+      }, /TypeError: keyCertPair\[0\].cert_chain must be a Buffer/);
+    });
+  });
+});
diff --git a/test/js/third_party/grpc-js/test-server-deadlines.test.ts b/test/js/third_party/grpc-js/test-server-deadlines.test.ts
new file mode 100644
index 0000000000..a6c6d39143
--- /dev/null
+++ b/test/js/third_party/grpc-js/test-server-deadlines.test.ts
@@ -0,0 +1,159 @@
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// Allow `any` data type for testing runtime type checking.
+// tslint:disable no-any
+import assert from "assert";
+import * as path from "path";
+
+import * as grpc from "@grpc/grpc-js/build/src";
+import { Server, ServerCredentials } from "@grpc/grpc-js/build/src";
+import { ServiceError } from "@grpc/grpc-js/build/src/call";
+import { ServiceClient, ServiceClientConstructor } from "@grpc/grpc-js/build/src/make-client";
+import { sendUnaryData, ServerUnaryCall, ServerWritableStream } from "@grpc/grpc-js/build/src/server-call";
+import { afterAll as after, beforeAll as before, describe, it, afterEach, beforeEach } from "bun:test";
+
+import { loadProtoFile } from "./common";
+
+const clientInsecureCreds = grpc.credentials.createInsecure();
+const serverInsecureCreds = ServerCredentials.createInsecure();
+
+describe("Server deadlines", () => {
+  let server: Server;
+  let client: ServiceClient;
+
+  before(done => {
+    const protoFile = path.join(__dirname, "fixtures", "test_service.proto");
+    const testServiceDef = loadProtoFile(protoFile);
+    const testServiceClient = testServiceDef.TestService as ServiceClientConstructor;
+
+    server = new Server();
+    server.addService(testServiceClient.service, {
+      unary(call: ServerUnaryCall<any, any>, cb: sendUnaryData<any>) {
+        setTimeout(() => {
+          cb(null, {});
+        }, 2000);
+      },
+    });
+
+    server.bindAsync("localhost:0", serverInsecureCreds, (err, port) => {
+      assert.ifError(err);
+      client = new testServiceClient(`localhost:${port}`, clientInsecureCreds);
+      server.start();
+      done();
+    });
+  });
+
+  after(() => {
+    client.close();
+    server.forceShutdown();
+  });
+
+  it("works with deadlines", done => {
+    const metadata = new grpc.Metadata();
+    const { path, requestSerialize: serialize, responseDeserialize: deserialize } = client.unary as any;
+
+    metadata.set("grpc-timeout", "100m");
+    client.makeUnaryRequest(path, serialize, deserialize, {}, metadata, {}, (error: any, response: any) => {
+      assert(error);
+      assert.strictEqual(error.code, grpc.status.DEADLINE_EXCEEDED);
+      assert.strictEqual(error.details, "Deadline exceeded");
+      done();
+    });
+  });
+
+  it("rejects invalid deadline", done => {
+    const metadata = new grpc.Metadata();
+    const { path, requestSerialize: serialize, responseDeserialize: deserialize } = client.unary as any;
+
+    metadata.set("grpc-timeout", "Infinity");
+    client.makeUnaryRequest(path, serialize, deserialize, {}, metadata, {}, (error: any, response: any) => {
+      assert(error);
+      assert.strictEqual(error.code, grpc.status.INTERNAL);
+      assert.match(error.details, /^Invalid grpc-timeout value/);
+      done();
+    });
+  });
+});
+
+describe.todo("Cancellation", () => {
+  let server: Server;
+  let client: ServiceClient;
+  let inHandler = false;
+  let cancelledInServer = false;
+
+  before(done => {
+    const protoFile = path.join(__dirname, "fixtures", "test_service.proto");
+    const testServiceDef = loadProtoFile(protoFile);
+    const testServiceClient = testServiceDef.TestService as ServiceClientConstructor;
+
+    server = new Server();
+    server.addService(testServiceClient.service, {
+      serverStream(stream: ServerWritableStream<any, any>) {
+        inHandler = true;
+        stream.on("cancelled", () => {
+          stream.write({});
+          stream.end();
+          cancelledInServer = true;
+        });
+      },
+    });
+
+    server.bindAsync("localhost:0", serverInsecureCreds, (err, port) => {
+      assert.ifError(err);
+      client = new testServiceClient(`localhost:${port}`, clientInsecureCreds);
+      server.start();
+      done();
+    });
+  });
+
+  after(() => {
+    client.close();
+    server.forceShutdown();
+  });
+
+  it("handles requests cancelled by the client", done => {
+    const call = client.serverStream({});
+
+    call.on("data", assert.ifError);
+    call.on("error", (error: ServiceError) => {
+      assert.strictEqual(error.code, grpc.status.CANCELLED);
+      assert.strictEqual(error.details, "Cancelled on client");
+      waitForServerCancel();
+    });
+
+    function waitForHandler() {
+      if (inHandler === true) {
+        call.cancel();
+        return;
+      }
+
+      setImmediate(waitForHandler);
+    }
+
+    function waitForServerCancel() {
+      if (cancelledInServer === true) {
+        done();
+        return;
+      }
+
+      setImmediate(waitForServerCancel);
+    }
+
+    waitForHandler();
+  });
+});
diff --git a/test/js/third_party/grpc-js/test-server-errors.test.ts b/test/js/third_party/grpc-js/test-server-errors.test.ts
new file mode 100644
index 0000000000..90188bc95d
--- /dev/null
+++ b/test/js/third_party/grpc-js/test-server-errors.test.ts
@@ -0,0 +1,856 @@
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// Allow `any` data type for testing runtime type checking.
+// tslint:disable no-any
+import assert from "assert";
+import { join } from "path";
+
+import * as grpc from "@grpc/grpc-js/build/src";
+import { Server } from "@grpc/grpc-js/build/src";
+import { ServiceError } from "@grpc/grpc-js/build/src/call";
+import { ServiceClient, ServiceClientConstructor } from "@grpc/grpc-js/build/src/make-client";
+import {
+  sendUnaryData,
+  ServerDuplexStream,
+  ServerReadableStream,
+  ServerUnaryCall,
+  ServerWritableStream,
+} from "@grpc/grpc-js/build/src/server-call";
+
+import { loadProtoFile } from "./common";
+import { CompressionAlgorithms } from "@grpc/grpc-js/build/src/compression-algorithms";
+import { afterAll as after, beforeAll as before, describe, it, afterEach, beforeEach } from "bun:test";
+
+const protoFile = join(__dirname, "fixtures", "test_service.proto");
+const testServiceDef = loadProtoFile(protoFile);
+const testServiceClient = testServiceDef.TestService as ServiceClientConstructor;
+const clientInsecureCreds = grpc.credentials.createInsecure();
+const serverInsecureCreds = grpc.ServerCredentials.createInsecure();
+
+describe("Client malformed response handling", () => {
+  let server: Server;
+  let client: ServiceClient;
+  const badArg = Buffer.from([0xff]);
+
+  before(done => {
+    const malformedTestService = {
+      unary: {
+        path: "/TestService/Unary",
+        requestStream: false,
+        responseStream: false,
+        requestDeserialize: identity,
+        responseSerialize: identity,
+      },
+      clientStream: {
+        path: "/TestService/ClientStream",
+        requestStream: true,
+        responseStream: false,
+        requestDeserialize: identity,
+        responseSerialize: identity,
+      },
+      serverStream: {
+        path: "/TestService/ServerStream",
+        requestStream: false,
+        responseStream: true,
+        requestDeserialize: identity,
+        responseSerialize: identity,
+      },
+      bidiStream: {
+        path: "/TestService/BidiStream",
+        requestStream: true,
+        responseStream: true,
+        requestDeserialize: identity,
+        responseSerialize: identity,
+      },
+    } as any;
+
+    server = new Server();
+
+    server.addService(malformedTestService, {
+      unary(call: ServerUnaryCall<any, any>, cb: sendUnaryData<any>) {
+        cb(null, badArg);
+      },
+
+      clientStream(stream: ServerReadableStream<any, any>, cb: sendUnaryData<any>) {
+        stream.on("data", noop);
+        stream.on("end", () => {
+          cb(null, badArg);
+        });
+      },
+
+      serverStream(stream: ServerWritableStream<any, any>) {
+        stream.write(badArg);
+        stream.end();
+      },
+
+      bidiStream(stream: ServerDuplexStream<any, any>) {
+        stream.on("data", () => {
+          // Ignore requests
+          stream.write(badArg);
+        });
+
+        stream.on("end", () => {
+          stream.end();
+        });
+      },
+    });
+
+    server.bindAsync("localhost:0", serverInsecureCreds, (err, port) => {
+      assert.ifError(err);
+      client = new testServiceClient(`localhost:${port}`, clientInsecureCreds);
+      server.start();
+      done();
+    });
+  });
+
+  after(() => {
+    client.close();
+    server.forceShutdown();
+  });
+
+  it("should get an INTERNAL status with a unary call", done => {
+    client.unary({}, (err: ServiceError, data: any) => {
+      assert(err);
+      assert.strictEqual(err.code, grpc.status.INTERNAL);
+      done();
+    });
+  });
+
+  it("should get an INTERNAL status with a client stream call", done => {
+    const call = client.clientStream((err: ServiceError, data: any) => {
+      assert(err);
+      assert.strictEqual(err.code, grpc.status.INTERNAL);
+      done();
+    });
+
+    call.write({});
+    call.end();
+  });
+
+  it("should get an INTERNAL status with a server stream call", done => {
+    const call = client.serverStream({});
+
+    call.on("data", noop);
+    call.on("error", (err: ServiceError) => {
+      assert(err);
+      assert.strictEqual(err.code, grpc.status.INTERNAL);
+      done();
+    });
+  });
+
+  it("should get an INTERNAL status with a bidi stream call", done => {
+    const call = client.bidiStream();
+
+    call.on("data", noop);
+    call.on("error", (err: ServiceError) => {
+      assert(err);
+      assert.strictEqual(err.code, grpc.status.INTERNAL);
+      done();
+    });
+
+    call.write({});
+    call.end();
+  });
+});
+
+describe("Server serialization failure handling", () => {
+  let client: ServiceClient;
+  let server: Server;
+
+  before(done => {
+    function serializeFail(obj: any) {
+      throw new Error("Serialization failed");
+    }
+
+    const malformedTestService = {
+      unary: {
+        path: "/TestService/Unary",
+        requestStream: false,
+        responseStream: false,
+        requestDeserialize: identity,
+        responseSerialize: serializeFail,
+      },
+      clientStream: {
+        path: "/TestService/ClientStream",
+        requestStream: true,
+        responseStream: false,
+        requestDeserialize: identity,
+        responseSerialize: serializeFail,
+      },
+      serverStream: {
+        path: "/TestService/ServerStream",
+        requestStream: false,
+        responseStream: true,
+        requestDeserialize: identity,
+        responseSerialize: serializeFail,
+      },
+      bidiStream: {
+        path: "/TestService/BidiStream",
+        requestStream: true,
+        responseStream: true,
+        requestDeserialize: identity,
+        responseSerialize: serializeFail,
+      },
+    };
+
+    server = new Server();
+    server.addService(malformedTestService as any, {
+      unary(call: ServerUnaryCall<any, any>, cb: sendUnaryData<any>) {
+        cb(null, {});
+      },
+
+      clientStream(stream: ServerReadableStream<any, any>, cb: sendUnaryData<any>) {
+        stream.on("data", noop);
+        stream.on("end", () => {
+          cb(null, {});
+        });
+      },
+
+      serverStream(stream: ServerWritableStream<any, any>) {
+        stream.write({});
+        stream.end();
+      },
+
+      bidiStream(stream: ServerDuplexStream<any, any>) {
+        stream.on("data", () => {
+          // Ignore requests
+          stream.write({});
+        });
+        stream.on("end", () => {
+          stream.end();
+        });
+      },
+    });
+
+    server.bindAsync("localhost:0", serverInsecureCreds, (err, port) => {
+      assert.ifError(err);
+      client = new testServiceClient(`localhost:${port}`, clientInsecureCreds);
+      server.start();
+      done();
+    });
+  });
+
+  after(() => {
+    client.close();
+    server.forceShutdown();
+  });
+
+  it("should get an INTERNAL status with a unary call", done => {
+    client.unary({}, (err: ServiceError, data: any) => {
+      assert(err);
+      assert.strictEqual(err.code, grpc.status.INTERNAL);
+      done();
+    });
+  });
+
+  it("should get an INTERNAL status with a client stream call", done => {
+    const call = client.clientStream((err: ServiceError, data: any) => {
+      assert(err);
+      assert.strictEqual(err.code, grpc.status.INTERNAL);
+      done();
+    });
+
+    call.write({});
+    call.end();
+  });
+
+  it("should get an INTERNAL status with a server stream call", done => {
+    const call = client.serverStream({});
+
+    call.on("data", noop);
+    call.on("error", (err: ServiceError) => {
+      assert(err);
+      assert.strictEqual(err.code, grpc.status.INTERNAL);
+      done();
+    });
+  });
+});
+
+describe("Cardinality violations", () => {
+  let client: ServiceClient;
+  let server: Server;
+  let responseCount: number = 1;
+  const testMessage = Buffer.from([]);
+  before(done => {
+    const serverServiceDefinition = {
+      testMethod: {
+        path: "/TestService/TestMethod/",
+        requestStream: false,
+        responseStream: true,
+        requestSerialize: identity,
+        requestDeserialize: identity,
+        responseDeserialize: identity,
+        responseSerialize: identity,
+      },
+    };
+    const clientServiceDefinition = {
+      testMethod: {
+        path: "/TestService/TestMethod/",
+        requestStream: true,
+        responseStream: false,
+        requestSerialize: identity,
+        requestDeserialize: identity,
+        responseDeserialize: identity,
+        responseSerialize: identity,
+      },
+    };
+    const TestClient = grpc.makeClientConstructor(clientServiceDefinition, "TestService");
+    server = new grpc.Server();
+    server.addService(serverServiceDefinition, {
+      testMethod(stream: ServerWritableStream<any, any>) {
+        for (let i = 0; i < responseCount; i++) {
+          stream.write(testMessage);
+        }
+        stream.end();
+      },
+    });
+    server.bindAsync("localhost:0", serverInsecureCreds, (error, port) => {
+      assert.ifError(error);
+      client = new TestClient(`localhost:${port}`, clientInsecureCreds);
+      done();
+    });
+  });
+  beforeEach(() => {
+    responseCount = 1;
+  });
+  after(() => {
+    client.close();
+    server.forceShutdown();
+  });
+  it("Should fail if the client sends too few messages", done => {
+    const call = client.testMethod((err: ServiceError, data: any) => {
+      assert(err);
+      assert.strictEqual(err.code, grpc.status.UNIMPLEMENTED);
+      done();
+    });
+    call.end();
+  });
+  it("Should fail if the client sends too many messages", done => {
+    const call = client.testMethod((err: ServiceError, data: any) => {
+      assert(err);
+      assert.strictEqual(err.code, grpc.status.UNIMPLEMENTED);
+      done();
+    });
+    call.write(testMessage);
+    call.write(testMessage);
+    call.end();
+  });
+  it("Should fail if the server sends too few messages", done => {
+    responseCount = 0;
+    const call = client.testMethod((err: ServiceError, data: any) => {
+      assert(err);
+      assert.strictEqual(err.code, grpc.status.UNIMPLEMENTED);
+      done();
+    });
+    call.write(testMessage);
+    call.end();
+  });
+  it("Should fail if the server sends too many messages", done => {
+    responseCount = 2;
+    const call = client.testMethod((err: ServiceError, data: any) => {
+      assert(err);
+      assert.strictEqual(err.code, grpc.status.UNIMPLEMENTED);
+      done();
+    });
+    call.write(testMessage);
+    call.end();
+  });
+});
+
+describe("Other conditions", () => {
+  let client: ServiceClient;
+  let server: Server;
+  let port: number;
+
+  before(done => {
+    const trailerMetadata = new grpc.Metadata();
+
+    server = new Server();
+    trailerMetadata.add("trailer-present", "yes");
+
+    server.addService(testServiceClient.service, {
+      unary(call: ServerUnaryCall<any, any>, cb: sendUnaryData<any>) {
+        const req = call.request;
+
+        if (req.error) {
+          const details = req.message || "Requested error";
+
+          cb({ code: grpc.status.UNKNOWN, details } as ServiceError, null, trailerMetadata);
+        } else {
+          cb(null, { count: 1, message: "a".repeat(req.responseLength) }, trailerMetadata);
+        }
+      },
+
+      clientStream(stream: ServerReadableStream<any, any>, cb: sendUnaryData<any>) {
+        let count = 0;
+        let errored = false;
+        let responseLength = 0;
+
+        stream.on("data", (data: any) => {
+          if (data.error) {
+            const message = data.message || "Requested error";
+            errored = true;
+            cb(new Error(message) as ServiceError, null, trailerMetadata);
+          } else {
+            responseLength += data.responseLength;
+            count++;
+          }
+        });
+
+        stream.on("end", () => {
+          if (!errored) {
+            cb(null, { count, message: "a".repeat(responseLength) }, trailerMetadata);
+          }
+        });
+      },
+
+      serverStream(stream: ServerWritableStream<any, any>) {
+        const req = stream.request;
+
+        if (req.error) {
+          stream.emit("error", {
+            code: grpc.status.UNKNOWN,
+            details: req.message || "Requested error",
+            metadata: trailerMetadata,
+          });
+        } else {
+          for (let i = 1; i <= 5; i++) {
+            stream.write({ count: i, message: "a".repeat(req.responseLength) });
+            if (req.errorAfter && req.errorAfter === i) {
+              stream.emit("error", {
+                code: grpc.status.UNKNOWN,
+                details: req.message || "Requested error",
+                metadata: trailerMetadata,
+              });
+              break;
+            }
+          }
+          if (!req.errorAfter) {
+            stream.end(trailerMetadata);
+          }
+        }
+      },
+
+      bidiStream(stream: ServerDuplexStream<any, any>) {
+        let count = 0;
+        stream.on("data", (data: any) => {
+          if (data.error) {
+            const message = data.message || "Requested error";
+            const err = new Error(message) as ServiceError;
+
+            err.metadata = trailerMetadata.clone();
+            err.metadata.add("count", "" + count);
+            stream.emit("error", err);
+          } else {
+            stream.write({ count, message: "a".repeat(data.responseLength) });
+            count++;
+          }
+        });
+
+        stream.on("end", () => {
+          stream.end(trailerMetadata);
+        });
+      },
+    });
+
+    server.bindAsync("localhost:0", serverInsecureCreds, (err, _port) => {
+      assert.ifError(err);
+      port = _port;
+      client = new testServiceClient(`localhost:${port}`, clientInsecureCreds);
+      server.start();
+      done();
+    });
+  });
+
+  after(() => {
+    client.close();
+    server.forceShutdown();
+  });
+
+  describe("Server receiving bad input", () => {
+    let misbehavingClient: ServiceClient;
+    const badArg = Buffer.from([0xff]);
+
+    before(() => {
+      const testServiceAttrs = {
+        unary: {
+          path: "/TestService/Unary",
+          requestStream: false,
+          responseStream: false,
+          requestSerialize: identity,
+          responseDeserialize: identity,
+        },
+        clientStream: {
+          path: "/TestService/ClientStream",
+          requestStream: true,
+          responseStream: false,
+          requestSerialize: identity,
+          responseDeserialize: identity,
+        },
+        serverStream: {
+          path: "/TestService/ServerStream",
+          requestStream: false,
+          responseStream: true,
+          requestSerialize: identity,
+          responseDeserialize: identity,
+        },
+        bidiStream: {
+          path: "/TestService/BidiStream",
+          requestStream: true,
+          responseStream: true,
+          requestSerialize: identity,
+          responseDeserialize: identity,
+        },
+      } as any;
+
+      const client = grpc.makeGenericClientConstructor(testServiceAttrs, "TestService");
+
+      misbehavingClient = new client(`localhost:${port}`, clientInsecureCreds);
+    });
+
+    after(() => {
+      misbehavingClient.close();
+    });
+
+    it("should respond correctly to a unary call", done => {
+      misbehavingClient.unary(badArg, (err: ServiceError, data: any) => {
+        assert(err);
+        assert.strictEqual(err.code, grpc.status.INTERNAL);
+        done();
+      });
+    });
+
+    it("should respond correctly to a client stream", done => {
+      const call = misbehavingClient.clientStream((err: ServiceError, data: any) => {
+        assert(err);
+        assert.strictEqual(err.code, grpc.status.INTERNAL);
+        done();
+      });
+
+      call.write(badArg);
+      call.end();
+    });
+
+    it("should respond correctly to a server stream", done => {
+      const call = misbehavingClient.serverStream(badArg);
+
+      call.on("data", (data: any) => {
+        assert.fail(data);
+      });
+
+      call.on("error", (err: ServiceError) => {
+        assert(err);
+        assert.strictEqual(err.code, grpc.status.INTERNAL);
+        done();
+      });
+    });
+
+    it("should respond correctly to a bidi stream", done => {
+      const call = misbehavingClient.bidiStream();
+
+      call.on("data", (data: any) => {
+        assert.fail(data);
+      });
+
+      call.on("error", (err: ServiceError) => {
+        assert(err);
+        assert.strictEqual(err.code, grpc.status.INTERNAL);
+        done();
+      });
+
+      call.write(badArg);
+      call.end();
+    });
+  });
+
+  describe("Trailing metadata", () => {
+    it("should be present when a unary call succeeds", done => {
+      let count = 0;
+      const call = client.unary({ error: false }, (err: ServiceError, data: any) => {
+        assert.ifError(err);
+
+        count++;
+        if (count === 2) {
+          done();
+        }
+      });
+
+      call.on("status", (status: grpc.StatusObject) => {
+        assert.deepStrictEqual(status.metadata.get("trailer-present"), ["yes"]);
+
+        count++;
+        if (count === 2) {
+          done();
+        }
+      });
+    });
+
+    it("should be present when a unary call fails", done => {
+      let count = 0;
+      const call = client.unary({ error: true }, (err: ServiceError, data: any) => {
+        assert(err);
+
+        count++;
+        if (count === 2) {
+          done();
+        }
+      });
+
+      call.on("status", (status: grpc.StatusObject) => {
+        assert.deepStrictEqual(status.metadata.get("trailer-present"), ["yes"]);
+
+        count++;
+        if (count === 2) {
+          done();
+        }
+      });
+    });
+
+    it("should be present when a client stream call succeeds", done => {
+      let count = 0;
+      const call = client.clientStream((err: ServiceError, data: any) => {
+        assert.ifError(err);
+
+        count++;
+        if (count === 2) {
+          done();
+        }
+      });
+
+      call.write({ error: false });
+      call.write({ error: false });
+      call.end();
+
+      call.on("status", (status: grpc.StatusObject) => {
+        assert.deepStrictEqual(status.metadata.get("trailer-present"), ["yes"]);
+
+        count++;
+        if (count === 2) {
+          done();
+        }
+      });
+    });
+
+    it("should be present when a client stream call fails", done => {
+      let count = 0;
+      const call = client.clientStream((err: ServiceError, data: any) => {
+        assert(err);
+
+        count++;
+        if (count === 2) {
+          done();
+        }
+      });
+
+      call.write({ error: false });
+      call.write({ error: true });
+      call.end();
+
+      call.on("status", (status: grpc.StatusObject) => {
+        assert.deepStrictEqual(status.metadata.get("trailer-present"), ["yes"]);
+
+        count++;
+        if (count === 2) {
+          done();
+        }
+      });
+    });
+
+    it("should be present when a server stream call succeeds", done => {
+      const call = client.serverStream({ error: false });
+
+      call.on("data", noop);
+      call.on("status", (status: grpc.StatusObject) => {
+        assert.strictEqual(status.code, grpc.status.OK);
+        assert.deepStrictEqual(status.metadata.get("trailer-present"), ["yes"]);
+        done();
+      });
+    });
+
+    it("should be present when a server stream call fails", done => {
+      const call = client.serverStream({ error: true });
+
+      call.on("data", noop);
+      call.on("error", (error: ServiceError) => {
+        assert.deepStrictEqual(error.metadata.get("trailer-present"), ["yes"]);
+        done();
+      });
+    });
+
+    it("should be present when a bidi stream succeeds", done => {
+      const call = client.bidiStream();
+
+      call.write({ error: false });
+      call.write({ error: false });
+      call.end();
+      call.on("data", noop);
+      call.on("status", (status: grpc.StatusObject) => {
+        assert.strictEqual(status.code, grpc.status.OK);
+        assert.deepStrictEqual(status.metadata.get("trailer-present"), ["yes"]);
+        done();
+      });
+    });
+
+    it("should be present when a bidi stream fails", done => {
+      const call = client.bidiStream();
+
+      call.write({ error: false });
+      call.write({ error: true });
+      call.end();
+      call.on("data", noop);
+      call.on("error", (error: ServiceError) => {
+        assert.deepStrictEqual(error.metadata.get("trailer-present"), ["yes"]);
+        done();
+      });
+    });
+  });
+
+  describe("Error object should contain the status", () => {
+    it("for a unary call", done => {
+      client.unary({ error: true }, (err: ServiceError, data: any) => {
+        assert(err);
+        assert.strictEqual(err.code, grpc.status.UNKNOWN);
+        assert.strictEqual(err.details, "Requested error");
+        done();
+      });
+    });
+
+    it("for a client stream call", done => {
+      const call = client.clientStream((err: ServiceError, data: any) => {
+        assert(err);
+        assert.strictEqual(err.code, grpc.status.UNKNOWN);
+        assert.strictEqual(err.details, "Requested error");
+        done();
+      });
+
+      call.write({ error: false });
+      call.write({ error: true });
+      call.end();
+    });
+
+    it("for a server stream call", done => {
+      const call = client.serverStream({ error: true });
+
+      call.on("data", noop);
+      call.on("error", (error: ServiceError) => {
+        assert.strictEqual(error.code, grpc.status.UNKNOWN);
+        assert.strictEqual(error.details, "Requested error");
+        done();
+      });
+    });
+
+    it("for a bidi stream call", done => {
+      const call = client.bidiStream();
+
+      call.write({ error: false });
+      call.write({ error: true });
+      call.end();
+      call.on("data", noop);
+      call.on("error", (error: ServiceError) => {
+        assert.strictEqual(error.code, grpc.status.UNKNOWN);
+        assert.strictEqual(error.details, "Requested error");
+        done();
+      });
+    });
+
+    it("for a UTF-8 error message", done => {
+      client.unary({ error: true, message: "測試字符串" }, (err: ServiceError, data: any) => {
+        assert(err);
+        assert.strictEqual(err.code, grpc.status.UNKNOWN);
+        assert.strictEqual(err.details, "測試字符串");
+        done();
+      });
+    });
+
+    it("for an error message with a comma", done => {
+      client.unary({ error: true, message: "an error message, with a comma" }, (err: ServiceError, data: any) => {
+        assert(err);
+        assert.strictEqual(err.code, grpc.status.UNKNOWN);
+        assert.strictEqual(err.details, "an error message, with a comma");
+        done();
+      });
+    });
+  });
+
+  describe("should handle server stream errors correctly", () => {
+    it("should emit data for all messages before error", done => {
+      const expectedDataCount = 2;
+      const call = client.serverStream({ errorAfter: expectedDataCount });
+
+      let actualDataCount = 0;
+      call.on("data", () => {
+        ++actualDataCount;
+      });
+      call.on("error", (error: ServiceError) => {
+        assert.strictEqual(error.code, grpc.status.UNKNOWN);
+        assert.strictEqual(error.details, "Requested error");
+        assert.strictEqual(actualDataCount, expectedDataCount);
+        done();
+      });
+    });
+  });
+
+  describe("Max message size", () => {
+    const largeMessage = "a".repeat(10_000_000);
+    it.todo("Should be enforced on the server", done => {
+      client.unary({ message: largeMessage }, (error?: ServiceError) => {
+        assert(error);
+        console.error(error);
+        assert.strictEqual(error.code, grpc.status.RESOURCE_EXHAUSTED);
+        done();
+      });
+    });
+    it("Should be enforced on the client", done => {
+      client.unary({ responseLength: 10_000_000 }, (error?: ServiceError) => {
+        assert(error);
+        assert.strictEqual(error.code, grpc.status.RESOURCE_EXHAUSTED);
+        done();
+      });
+    });
+    describe("Compressed messages", () => {
+      it("Should be enforced with gzip", done => {
+        const compressingClient = new testServiceClient(`localhost:${port}`, clientInsecureCreds, {
+          "grpc.default_compression_algorithm": CompressionAlgorithms.gzip,
+        });
+        compressingClient.unary({ message: largeMessage }, (error?: ServiceError) => {
+          assert(error);
+          assert.strictEqual(error.code, grpc.status.RESOURCE_EXHAUSTED);
+          assert.match(error.details, /Received message that decompresses to a size larger/);
+          done();
+        });
+      });
+      it("Should be enforced with deflate", done => {
+        const compressingClient = new testServiceClient(`localhost:${port}`, clientInsecureCreds, {
+          "grpc.default_compression_algorithm": CompressionAlgorithms.deflate,
+        });
+        compressingClient.unary({ message: largeMessage }, (error?: ServiceError) => {
+          assert(error);
+          assert.strictEqual(error.code, grpc.status.RESOURCE_EXHAUSTED);
+          assert.match(error.details, /Received message that decompresses to a size larger/);
+          done();
+        });
+      });
+    });
+  });
+});
+
+function identity(arg: any): any {
+  return arg;
+}
+
+function noop(): void {}
diff --git a/test/js/third_party/grpc-js/test-server-interceptors.test.ts b/test/js/third_party/grpc-js/test-server-interceptors.test.ts
new file mode 100644
index 0000000000..6c77eddfea
--- /dev/null
+++ b/test/js/third_party/grpc-js/test-server-interceptors.test.ts
@@ -0,0 +1,285 @@
+/*
+ * Copyright 2024 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import assert from "assert";
+import * as path from "path";
+import * as grpc from "@grpc/grpc-js/build/src";
+import { TestClient, loadProtoFile } from "./common";
+import { afterAll as after, beforeAll as before, describe, it, afterEach, beforeEach } from "bun:test";
+
+const protoFile = path.join(__dirname, "fixtures", "echo_service.proto");
+const echoService = loadProtoFile(protoFile).EchoService as grpc.ServiceClientConstructor;
+
+const AUTH_HEADER_KEY = "auth";
+const AUTH_HEADER_ALLOWED_VALUE = "allowed";
+const testAuthInterceptor: grpc.ServerInterceptor = (methodDescriptor, call) => {
+  const authListener = new grpc.ServerListenerBuilder()
+    .withOnReceiveMetadata((metadata, mdNext) => {
+      if (metadata.get(AUTH_HEADER_KEY)?.[0] !== AUTH_HEADER_ALLOWED_VALUE) {
+        call.sendStatus({
+          code: grpc.status.UNAUTHENTICATED,
+          details: "Auth metadata not correct",
+        });
+      } else {
+        mdNext(metadata);
+      }
+    })
+    .build();
+  const responder = new grpc.ResponderBuilder().withStart(next => next(authListener)).build();
+  return new grpc.ServerInterceptingCall(call, responder);
+};
+
+let eventCounts = {
+  receiveMetadata: 0,
+  receiveMessage: 0,
+  receiveHalfClose: 0,
+  sendMetadata: 0,
+  sendMessage: 0,
+  sendStatus: 0,
+};
+
+function resetEventCounts() {
+  eventCounts = {
+    receiveMetadata: 0,
+    receiveMessage: 0,
+    receiveHalfClose: 0,
+    sendMetadata: 0,
+    sendMessage: 0,
+    sendStatus: 0,
+  };
+}
+
+/**
+ * Test interceptor to verify that interceptors see each expected event by
+ * counting each kind of event.
+ * @param methodDescription
+ * @param call
+ */
+const testLoggingInterceptor: grpc.ServerInterceptor = (methodDescription, call) => {
+  return new grpc.ServerInterceptingCall(call, {
+    start: next => {
+      next({
+        onReceiveMetadata: (metadata, mdNext) => {
+          eventCounts.receiveMetadata += 1;
+          mdNext(metadata);
+        },
+        onReceiveMessage: (message, messageNext) => {
+          eventCounts.receiveMessage += 1;
+          messageNext(message);
+        },
+        onReceiveHalfClose: hcNext => {
+          eventCounts.receiveHalfClose += 1;
+          hcNext();
+        },
+      });
+    },
+    sendMetadata: (metadata, mdNext) => {
+      eventCounts.sendMetadata += 1;
+      mdNext(metadata);
+    },
+    sendMessage: (message, messageNext) => {
+      eventCounts.sendMessage += 1;
+      messageNext(message);
+    },
+    sendStatus: (status, statusNext) => {
+      eventCounts.sendStatus += 1;
+      statusNext(status);
+    },
+  });
+};
+
+const testHeaderInjectionInterceptor: grpc.ServerInterceptor = (methodDescriptor, call) => {
+  return new grpc.ServerInterceptingCall(call, {
+    start: next => {
+      const authListener: grpc.ServerListener = {
+        onReceiveMetadata: (metadata, mdNext) => {
+          metadata.set("injected-header", "present");
+          mdNext(metadata);
+        },
+      };
+      next(authListener);
+    },
+  });
+};
+
+describe("Server interceptors", () => {
+  describe("Auth-type interceptor", () => {
+    let server: grpc.Server;
+    let client: TestClient;
+    /* Tests that an interceptor can entirely prevent the handler from being
+     * invoked, based on the contents of the metadata. */
+    before(done => {
+      server = new grpc.Server({ interceptors: [testAuthInterceptor] });
+      server.addService(echoService.service, {
+        echo: (call: grpc.ServerUnaryCall<any, any>, callback: grpc.sendUnaryData<any>) => {
+          // A test will fail if a request makes it to the handler without the correct auth header
+          assert.strictEqual(call.metadata.get(AUTH_HEADER_KEY)?.[0], AUTH_HEADER_ALLOWED_VALUE);
+          callback(null, call.request);
+        },
+      });
+      server.bindAsync("localhost:0", grpc.ServerCredentials.createInsecure(), (error, port) => {
+        assert.ifError(error);
+        client = new TestClient(`localhost:${port}`, false);
+        done();
+      });
+    });
+    after(() => {
+      client.close();
+      server.forceShutdown();
+    });
+    it("Should accept a request with the expected header", done => {
+      const requestMetadata = new grpc.Metadata();
+      requestMetadata.set(AUTH_HEADER_KEY, AUTH_HEADER_ALLOWED_VALUE);
+      client.sendRequestWithMetadata(requestMetadata, done);
+    });
+    it("Should reject a request without the expected header", done => {
+      const requestMetadata = new grpc.Metadata();
+      requestMetadata.set(AUTH_HEADER_KEY, "not allowed");
+      client.sendRequestWithMetadata(requestMetadata, error => {
+        assert.strictEqual(error?.code, grpc.status.UNAUTHENTICATED);
+        done();
+      });
+    });
+  });
+  describe("Logging-type interceptor", () => {
+    let server: grpc.Server;
+    let client: TestClient;
+    before(done => {
+      server = new grpc.Server({ interceptors: [testLoggingInterceptor] });
+      server.addService(echoService.service, {
+        echo: (call: grpc.ServerUnaryCall<any, any>, callback: grpc.sendUnaryData<any>) => {
+          call.sendMetadata(new grpc.Metadata());
+          callback(null, call.request);
+        },
+      });
+      server.bindAsync("localhost:0", grpc.ServerCredentials.createInsecure(), (error, port) => {
+        assert.ifError(error);
+        client = new TestClient(`localhost:${port}`, false);
+        done();
+      });
+    });
+    after(() => {
+      client.close();
+      server.forceShutdown();
+    });
+    beforeEach(() => {
+      resetEventCounts();
+    });
+    it("Should see every event once", done => {
+      client.sendRequest(error => {
+        assert.ifError(error);
+        assert.deepStrictEqual(eventCounts, {
+          receiveMetadata: 1,
+          receiveMessage: 1,
+          receiveHalfClose: 1,
+          sendMetadata: 1,
+          sendMessage: 1,
+          sendStatus: 1,
+        });
+        done();
+      });
+    });
+  });
+  describe("Header injection interceptor", () => {
+    let server: grpc.Server;
+    let client: TestClient;
+    before(done => {
+      server = new grpc.Server({
+        interceptors: [testHeaderInjectionInterceptor],
+      });
+      server.addService(echoService.service, {
+        echo: (call: grpc.ServerUnaryCall<any, any>, callback: grpc.sendUnaryData<any>) => {
+          assert.strictEqual(call.metadata.get("injected-header")?.[0], "present");
+          callback(null, call.request);
+        },
+      });
+      server.bindAsync("localhost:0", grpc.ServerCredentials.createInsecure(), (error, port) => {
+        assert.ifError(error);
+        client = new TestClient(`localhost:${port}`, false);
+        done();
+      });
+    });
+    after(() => {
+      client.close();
+      server.forceShutdown();
+    });
+    it("Should inject the header for the handler to see", done => {
+      client.sendRequest(done);
+    });
+  });
+  describe("Multiple interceptors", () => {
+    let server: grpc.Server;
+    let client: TestClient;
+    before(done => {
+      server = new grpc.Server({
+        interceptors: [testAuthInterceptor, testLoggingInterceptor, testHeaderInjectionInterceptor],
+      });
+      server.addService(echoService.service, {
+        echo: (call: grpc.ServerUnaryCall<any, any>, callback: grpc.sendUnaryData<any>) => {
+          assert.strictEqual(call.metadata.get(AUTH_HEADER_KEY)?.[0], AUTH_HEADER_ALLOWED_VALUE);
+          assert.strictEqual(call.metadata.get("injected-header")?.[0], "present");
+          call.sendMetadata(new grpc.Metadata());
+          callback(null, call.request);
+        },
+      });
+      server.bindAsync("localhost:0", grpc.ServerCredentials.createInsecure(), (error, port) => {
+        assert.ifError(error);
+        client = new TestClient(`localhost:${port}`, false);
+        done();
+      });
+    });
+    after(() => {
+      client.close();
+      server.forceShutdown();
+    });
+    beforeEach(() => {
+      resetEventCounts();
+    });
+    it("Should not log requests rejected by auth", done => {
+      const requestMetadata = new grpc.Metadata();
+      requestMetadata.set(AUTH_HEADER_KEY, "not allowed");
+      client.sendRequestWithMetadata(requestMetadata, error => {
+        assert.strictEqual(error?.code, grpc.status.UNAUTHENTICATED);
+        assert.deepStrictEqual(eventCounts, {
+          receiveMetadata: 0,
+          receiveMessage: 0,
+          receiveHalfClose: 0,
+          sendMetadata: 0,
+          sendMessage: 0,
+          sendStatus: 0,
+        });
+        done();
+      });
+    });
+    it("Should log requests accepted by auth", done => {
+      const requestMetadata = new grpc.Metadata();
+      requestMetadata.set(AUTH_HEADER_KEY, AUTH_HEADER_ALLOWED_VALUE);
+      client.sendRequestWithMetadata(requestMetadata, error => {
+        assert.ifError(error);
+        assert.deepStrictEqual(eventCounts, {
+          receiveMetadata: 1,
+          receiveMessage: 1,
+          receiveHalfClose: 1,
+          sendMetadata: 1,
+          sendMessage: 1,
+          sendStatus: 1,
+        });
+        done();
+      });
+    });
+  });
+});
diff --git a/test/js/third_party/grpc-js/test-server.test.ts b/test/js/third_party/grpc-js/test-server.test.ts
new file mode 100644
index 0000000000..e992a89f8c
--- /dev/null
+++ b/test/js/third_party/grpc-js/test-server.test.ts
@@ -0,0 +1,1216 @@
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// Allow `any` data type for testing runtime type checking.
+// tslint:disable no-any
+import assert from "assert";
+import * as fs from "fs";
+import * as http2 from "http2";
+import * as path from "path";
+import * as net from "net";
+import * as protoLoader from "@grpc/proto-loader";
+
+import * as grpc from "@grpc/grpc-js/build/src";
+import { Server, ServerCredentials } from "@grpc/grpc-js/build/src";
+import { ServiceError } from "@grpc/grpc-js/build/src/call";
+import { ServiceClient, ServiceClientConstructor } from "@grpc/grpc-js/build/src/make-client";
+import { sendUnaryData, ServerUnaryCall, ServerDuplexStream } from "@grpc/grpc-js/build/src/server-call";
+
+import { assert2, loadProtoFile } from "./common";
+import { TestServiceClient, TestServiceHandlers } from "./generated/TestService";
+import { ProtoGrpcType as TestServiceGrpcType } from "./generated/test_service";
+import { Request__Output } from "./generated/Request";
+import { CompressionAlgorithms } from "@grpc/grpc-js/build/src/compression-algorithms";
+import { SecureContextOptions } from "tls";
+import { afterEach as after, beforeEach as before, describe, it, afterEach, beforeEach } from "bun:test";
+
+const loadedTestServiceProto = protoLoader.loadSync(path.join(__dirname, "fixtures/test_service.proto"), {
+  keepCase: true,
+  longs: String,
+  enums: String,
+  defaults: true,
+  oneofs: true,
+});
+
+const testServiceGrpcObject = grpc.loadPackageDefinition(loadedTestServiceProto) as unknown as TestServiceGrpcType;
+
+const ca = fs.readFileSync(path.join(__dirname, "fixtures", "ca.pem"));
+const key = fs.readFileSync(path.join(__dirname, "fixtures", "server1.key"));
+const cert = fs.readFileSync(path.join(__dirname, "fixtures", "server1.pem"));
+function noop(): void {}
+
+describe("Server", () => {
+  let server: Server;
+  beforeEach(() => {
+    server = new Server();
+  });
+  afterEach(() => {
+    server.forceShutdown();
+  });
+  describe("constructor", () => {
+    it("should work with no arguments", () => {
+      assert.doesNotThrow(() => {
+        new Server(); // tslint:disable-line:no-unused-expression
+      });
+    });
+
+    it("should work with an empty object argument", () => {
+      assert.doesNotThrow(() => {
+        new Server({}); // tslint:disable-line:no-unused-expression
+      });
+    });
+
+    it("should be an instance of Server", () => {
+      const server = new Server();
+
+      assert(server instanceof Server);
+    });
+  });
+
+  describe("bindAsync", () => {
+    it("binds with insecure credentials", done => {
+      const server = new Server();
+
+      server.bindAsync("localhost:0", ServerCredentials.createInsecure(), (err, port) => {
+        assert.ifError(err);
+        assert(typeof port === "number" && port > 0);
+        server.forceShutdown();
+        done();
+      });
+    });
+
+    it("binds with secure credentials", done => {
+      const server = new Server();
+      const creds = ServerCredentials.createSsl(ca, [{ private_key: key, cert_chain: cert }], true);
+
+      server.bindAsync("localhost:0", creds, (err, port) => {
+        assert.ifError(err);
+        assert(typeof port === "number" && port > 0);
+        server.forceShutdown();
+        done();
+      });
+    });
+
+    it("throws on invalid inputs", () => {
+      const server = new Server();
+
+      assert.throws(() => {
+        server.bindAsync(null as any, ServerCredentials.createInsecure(), noop);
+      }, /port must be a string/);
+
+      assert.throws(() => {
+        server.bindAsync("localhost:0", null as any, noop);
+      }, /creds must be a ServerCredentials object/);
+
+      assert.throws(() => {
+        server.bindAsync("localhost:0", grpc.credentials.createInsecure() as any, noop);
+      }, /creds must be a ServerCredentials object/);
+
+      assert.throws(() => {
+        server.bindAsync("localhost:0", ServerCredentials.createInsecure(), null as any);
+      }, /callback must be a function/);
+    });
+
+    it("succeeds when called with an already bound port", done => {
+      server.bindAsync("localhost:0", ServerCredentials.createInsecure(), (err, port) => {
+        assert.ifError(err);
+        server.bindAsync(`localhost:${port}`, ServerCredentials.createInsecure(), (err2, port2) => {
+          assert.ifError(err2);
+          assert.strictEqual(port, port2);
+          done();
+        });
+      });
+    });
+
+    it("fails when called on a bound port with different credentials", done => {
+      const secureCreds = ServerCredentials.createSsl(ca, [{ private_key: key, cert_chain: cert }], true);
+      server.bindAsync("localhost:0", ServerCredentials.createInsecure(), (err, port) => {
+        assert.ifError(err);
+        server.bindAsync(`localhost:${port}`, secureCreds, (err2, port2) => {
+          assert(err2 !== null);
+          assert.match(err2.message, /credentials/);
+          done();
+        });
+      });
+    });
+  });
+
+  describe("unbind", () => {
+    let client: grpc.Client | null = null;
+    beforeEach(() => {
+      client = null;
+    });
+    afterEach(() => {
+      client?.close();
+    });
+    it("refuses to unbind port 0", done => {
+      assert.throws(() => {
+        server.unbind("localhost:0");
+      }, /port 0/);
+      server.bindAsync("localhost:0", ServerCredentials.createInsecure(), (err, port) => {
+        assert.ifError(err);
+        assert.notStrictEqual(port, 0);
+        assert.throws(() => {
+          server.unbind("localhost:0");
+        }, /port 0/);
+        done();
+      });
+    });
+
+    it("successfully unbinds a bound ephemeral port", done => {
+      server.bindAsync("localhost:0", ServerCredentials.createInsecure(), (err, port) => {
+        client = new grpc.Client(`localhost:${port}`, grpc.credentials.createInsecure());
+        client.makeUnaryRequest(
+          "/math.Math/Div",
+          x => x,
+          x => x,
+          Buffer.from("abc"),
+          (callError1, result) => {
+            assert(callError1);
+            // UNIMPLEMENTED means that the request reached the call handling code
+            assert.strictEqual(callError1.code, grpc.status.UNIMPLEMENTED);
+            server.unbind(`localhost:${port}`);
+            const deadline = new Date();
+            deadline.setSeconds(deadline.getSeconds() + 1);
+            client!.makeUnaryRequest(
+              "/math.Math/Div",
+              x => x,
+              x => x,
+              Buffer.from("abc"),
+              { deadline: deadline },
+              (callError2, result) => {
+                assert(callError2);
+                // DEADLINE_EXCEEDED means that the server is unreachable
+                assert(
+                  callError2.code === grpc.status.DEADLINE_EXCEEDED || callError2.code === grpc.status.UNAVAILABLE,
+                );
+                done();
+              },
+            );
+          },
+        );
+      });
+    });
+
+    it("cancels a bindAsync in progress", done => {
+      server.bindAsync("localhost:50051", ServerCredentials.createInsecure(), (err, port) => {
+        assert(err);
+        assert.match(err.message, /cancelled by unbind/);
+        done();
+      });
+      server.unbind("localhost:50051");
+    });
+  });
+
+  describe("drain", () => {
+    let client: ServiceClient;
+    let portNumber: number;
+    const protoFile = path.join(__dirname, "fixtures", "echo_service.proto");
+    const echoService = loadProtoFile(protoFile).EchoService as ServiceClientConstructor;
+
+    const serviceImplementation = {
+      echo(call: ServerUnaryCall<any, any>, callback: sendUnaryData<any>) {
+        callback(null, call.request);
+      },
+      echoBidiStream(call: ServerDuplexStream<any, any>) {
+        call.on("data", data => {
+          call.write(data);
+        });
+        call.on("end", () => {
+          call.end();
+        });
+      },
+    };
+
+    beforeEach(done => {
+      server.addService(echoService.service, serviceImplementation);
+
+      server.bindAsync("localhost:0", ServerCredentials.createInsecure(), (err, port) => {
+        assert.ifError(err);
+        portNumber = port;
+        client = new echoService(`localhost:${port}`, grpc.credentials.createInsecure());
+        server.start();
+        done();
+      });
+    });
+
+    afterEach(() => {
+      client.close();
+      server.forceShutdown();
+    });
+
+    it.todo("Should cancel open calls after the grace period ends", done => {
+      const call = client.echoBidiStream();
+      call.on("error", (error: ServiceError) => {
+        assert.strictEqual(error.code, grpc.status.CANCELLED);
+        done();
+      });
+      call.on("data", () => {
+        server.drain(`localhost:${portNumber!}`, 100);
+      });
+      call.write({ value: "abc" });
+    });
+  });
+
+  describe("start", () => {
+    let server: Server;
+
+    beforeEach(done => {
+      server = new Server();
+      server.bindAsync("localhost:0", ServerCredentials.createInsecure(), done);
+    });
+
+    afterEach(() => {
+      server.forceShutdown();
+    });
+
+    it("starts without error", () => {
+      assert.doesNotThrow(() => {
+        server.start();
+      });
+    });
+
+    it("throws if started twice", () => {
+      server.start();
+      assert.throws(() => {
+        server.start();
+      }, /server is already started/);
+    });
+
+    it("throws if the server is not bound", () => {
+      const server = new Server();
+
+      assert.throws(() => {
+        server.start();
+      }, /server must be bound in order to start/);
+    });
+  });
+
+  describe("addService", () => {
+    const mathProtoFile = path.join(__dirname, "fixtures", "math.proto");
+    const mathClient = (loadProtoFile(mathProtoFile).math as any).Math;
+    const mathServiceAttrs = mathClient.service;
+    const dummyImpls = { div() {}, divMany() {}, fib() {}, sum() {} };
+    const altDummyImpls = { Div() {}, DivMany() {}, Fib() {}, Sum() {} };
+
+    it("succeeds with a single service", () => {
+      const server = new Server();
+
+      assert.doesNotThrow(() => {
+        server.addService(mathServiceAttrs, dummyImpls);
+      });
+    });
+
+    it("fails to add an empty service", () => {
+      const server = new Server();
+
+      assert.throws(() => {
+        server.addService({}, dummyImpls);
+      }, /Cannot add an empty service to a server/);
+    });
+
+    it("fails with conflicting method names", () => {
+      const server = new Server();
+
+      server.addService(mathServiceAttrs, dummyImpls);
+      assert.throws(() => {
+        server.addService(mathServiceAttrs, dummyImpls);
+      }, /Method handler for .+ already provided/);
+    });
+
+    it("supports method names as originally written", () => {
+      const server = new Server();
+
+      assert.doesNotThrow(() => {
+        server.addService(mathServiceAttrs, altDummyImpls);
+      });
+    });
+
+    it("succeeds after server has been started", done => {
+      const server = new Server();
+
+      server.bindAsync("localhost:0", ServerCredentials.createInsecure(), (err, port) => {
+        assert.ifError(err);
+        server.start();
+        assert.doesNotThrow(() => {
+          server.addService(mathServiceAttrs, dummyImpls);
+        });
+        server.forceShutdown();
+        done();
+      });
+    });
+  });
+
+  describe("removeService", () => {
+    let server: Server;
+    let client: ServiceClient;
+
+    const mathProtoFile = path.join(__dirname, "fixtures", "math.proto");
+    const mathClient = (loadProtoFile(mathProtoFile).math as any).Math;
+    const mathServiceAttrs = mathClient.service;
+    const dummyImpls = { div() {}, divMany() {}, fib() {}, sum() {} };
+
+    beforeEach(done => {
+      server = new Server();
+      server.addService(mathServiceAttrs, dummyImpls);
+      server.bindAsync("localhost:0", ServerCredentials.createInsecure(), (err, port) => {
+        assert.ifError(err);
+        client = new mathClient(`localhost:${port}`, grpc.credentials.createInsecure());
+        server.start();
+        done();
+      });
+    });
+
+    afterEach(() => {
+      client.close();
+      server.forceShutdown();
+    });
+
+    it("succeeds with a single service by removing all method handlers", done => {
+      server.removeService(mathServiceAttrs);
+
+      let methodsVerifiedCount = 0;
+      const methodsToVerify = Object.keys(mathServiceAttrs);
+
+      const assertFailsWithUnimplementedError = (error: ServiceError) => {
+        assert(error);
+        assert.strictEqual(error.code, grpc.status.UNIMPLEMENTED);
+        methodsVerifiedCount++;
+        if (methodsVerifiedCount === methodsToVerify.length) {
+          done();
+        }
+      };
+
+      methodsToVerify.forEach(method => {
+        const call = client[method]({}, assertFailsWithUnimplementedError); // for unary
+        call.on("error", assertFailsWithUnimplementedError); // for streamed
+      });
+    });
+
+    it("fails for non-object service definition argument", () => {
+      assert.throws(() => {
+        server.removeService("upsie" as any);
+      }, /removeService.*requires object as argument/);
+    });
+  });
+
+  describe("unregister", () => {
+    let server: Server;
+    let client: ServiceClient;
+
+    const mathProtoFile = path.join(__dirname, "fixtures", "math.proto");
+    const mathClient = (loadProtoFile(mathProtoFile).math as any).Math;
+    const mathServiceAttrs = mathClient.service;
+
+    beforeEach(done => {
+      server = new Server();
+      server.addService(mathServiceAttrs, {
+        div(call: ServerUnaryCall<any, any>, callback: sendUnaryData<any>) {
+          callback(null, { quotient: "42" });
+        },
+      });
+      server.bindAsync("localhost:0", ServerCredentials.createInsecure(), (err, port) => {
+        assert.ifError(err);
+        client = new mathClient(`localhost:${port}`, grpc.credentials.createInsecure());
+        server.start();
+        done();
+      });
+    });
+
+    afterEach(() => {
+      client.close();
+      server.forceShutdown();
+    });
+
+    it("removes handler by name and returns true", done => {
+      const name = mathServiceAttrs["Div"].path;
+      assert.strictEqual(server.unregister(name), true, "Server#unregister should return true on success");
+
+      client.div({ divisor: 4, dividend: 3 }, (error: ServiceError, response: any) => {
+        assert(error);
+        assert.strictEqual(error.code, grpc.status.UNIMPLEMENTED);
+        done();
+      });
+    });
+
+    it("returns false for unknown handler", () => {
+      assert.strictEqual(server.unregister("noOneHere"), false, "Server#unregister should return false on failure");
+    });
+  });
+
+  it("throws when unimplemented methods are called", () => {
+    const server = new Server();
+
+    assert.throws(() => {
+      server.addProtoService();
+    }, /Not implemented. Use addService\(\) instead/);
+
+    assert.throws(() => {
+      server.addHttp2Port();
+    }, /Not yet implemented/);
+
+    assert.throws(() => {
+      server.bind("localhost:0", ServerCredentials.createInsecure());
+    }, /Not implemented. Use bindAsync\(\) instead/);
+  });
+
+  describe("Default handlers", () => {
+    let server: Server;
+    let client: ServiceClient;
+
+    const mathProtoFile = path.join(__dirname, "fixtures", "math.proto");
+    const mathClient = (loadProtoFile(mathProtoFile).math as any).Math;
+    const mathServiceAttrs = mathClient.service;
+
+    before(done => {
+      server = new Server();
+      server.addService(mathServiceAttrs, {});
+      server.bindAsync("localhost:0", ServerCredentials.createInsecure(), (err, port) => {
+        assert.ifError(err);
+        client = new mathClient(`localhost:${port}`, grpc.credentials.createInsecure());
+        server.start();
+        done();
+      });
+    });
+
+    after(() => {
+      client.close();
+      server.forceShutdown();
+    });
+
+    it("should respond to a unary call with UNIMPLEMENTED", done => {
+      client.div({ divisor: 4, dividend: 3 }, (error: ServiceError, response: any) => {
+        assert(error);
+        assert.strictEqual(error.code, grpc.status.UNIMPLEMENTED);
+        assert.match(error.details, /does not implement the method.*Div/);
+        done();
+      });
+    });
+
+    it("should respond to a client stream with UNIMPLEMENTED", done => {
+      const call = client.sum((error: ServiceError, response: any) => {
+        assert(error);
+        assert.strictEqual(error.code, grpc.status.UNIMPLEMENTED);
+        assert.match(error.details, /does not implement the method.*Sum/);
+        done();
+      });
+
+      call.end();
+    });
+
+    it("should respond to a server stream with UNIMPLEMENTED", done => {
+      const call = client.fib({ limit: 5 });
+
+      call.on("data", (value: any) => {
+        assert.fail("No messages expected");
+      });
+
+      call.on("error", (err: ServiceError) => {
+        assert(err);
+        assert.strictEqual(err.code, grpc.status.UNIMPLEMENTED);
+        assert.match(err.details, /does not implement the method.*Fib/);
+        done();
+      });
+    });
+
+    it("should respond to a bidi call with UNIMPLEMENTED", done => {
+      const call = client.divMany();
+
+      call.on("data", (value: any) => {
+        assert.fail("No messages expected");
+      });
+
+      call.on("error", (err: ServiceError) => {
+        assert(err);
+        assert.strictEqual(err.code, grpc.status.UNIMPLEMENTED);
+        assert.match(err.details, /does not implement the method.*DivMany/);
+        done();
+      });
+
+      call.end();
+    });
+  });
+
+  describe("Unregistered service", () => {
+    let server: Server;
+    let client: ServiceClient;
+
+    const mathProtoFile = path.join(__dirname, "fixtures", "math.proto");
+    const mathClient = (loadProtoFile(mathProtoFile).math as any).Math;
+
+    before(done => {
+      server = new Server();
+      // Don't register a service at all
+      server.bindAsync("localhost:0", ServerCredentials.createInsecure(), (err, port) => {
+        assert.ifError(err);
+        client = new mathClient(`localhost:${port}`, grpc.credentials.createInsecure());
+        server.start();
+        done();
+      });
+    });
+
+    after(() => {
+      client.close();
+      server.forceShutdown();
+    });
+
+    it("should respond to a unary call with UNIMPLEMENTED", done => {
+      client.div({ divisor: 4, dividend: 3 }, (error: ServiceError, response: any) => {
+        assert(error);
+        assert.strictEqual(error.code, grpc.status.UNIMPLEMENTED);
+        assert.match(error.details, /does not implement the method.*Div/);
+        done();
+      });
+    });
+
+    it("should respond to a client stream with UNIMPLEMENTED", done => {
+      const call = client.sum((error: ServiceError, response: any) => {
+        assert(error);
+        assert.strictEqual(error.code, grpc.status.UNIMPLEMENTED);
+        assert.match(error.details, /does not implement the method.*Sum/);
+        done();
+      });
+
+      call.end();
+    });
+
+    it("should respond to a server stream with UNIMPLEMENTED", done => {
+      const call = client.fib({ limit: 5 });
+
+      call.on("data", (value: any) => {
+        assert.fail("No messages expected");
+      });
+
+      call.on("error", (err: ServiceError) => {
+        assert(err);
+        assert.strictEqual(err.code, grpc.status.UNIMPLEMENTED);
+        assert.match(err.details, /does not implement the method.*Fib/);
+        done();
+      });
+    });
+
+    it("should respond to a bidi call with UNIMPLEMENTED", done => {
+      const call = client.divMany();
+
+      call.on("data", (value: any) => {
+        assert.fail("No messages expected");
+      });
+
+      call.on("error", (err: ServiceError) => {
+        assert(err);
+        assert.strictEqual(err.code, grpc.status.UNIMPLEMENTED);
+        assert.match(err.details, /does not implement the method.*DivMany/);
+        done();
+      });
+
+      call.end();
+    });
+  });
+});
+
+describe("Echo service", () => {
+  let server: Server;
+  let client: ServiceClient;
+  const protoFile = path.join(__dirname, "fixtures", "echo_service.proto");
+  const echoService = loadProtoFile(protoFile).EchoService as ServiceClientConstructor;
+
+  const serviceImplementation = {
+    echo(call: ServerUnaryCall<any, any>, callback: sendUnaryData<any>) {
+      callback(null, call.request);
+    },
+    echoBidiStream(call: ServerDuplexStream<any, any>) {
+      call.on("data", data => {
+        call.write(data);
+      });
+      call.on("end", () => {
+        call.end();
+      });
+    },
+  };
+
+  before(done => {
+    server = new Server();
+    server.addService(echoService.service, serviceImplementation);
+
+    server.bindAsync("localhost:0", ServerCredentials.createInsecure(), (err, port) => {
+      assert.ifError(err);
+      client = new echoService(`localhost:${port}`, grpc.credentials.createInsecure());
+      server.start();
+      done();
+    });
+  });
+
+  after(() => {
+    client.close();
+    server.forceShutdown();
+  });
+
+  it("should echo the recieved message directly", done => {
+    client.echo({ value: "test value", value2: 3 }, (error: ServiceError, response: any) => {
+      assert.ifError(error);
+      assert.deepStrictEqual(response, { value: "test value", value2: 3 });
+      done();
+    });
+  });
+
+  describe("ServerCredentials watcher", () => {
+    let server: Server;
+    let serverPort: number;
+    const protoFile = path.join(__dirname, "fixtures", "echo_service.proto");
+    const echoService = loadProtoFile(protoFile).EchoService as ServiceClientConstructor;
+
+    class ToggleableSecureServerCredentials extends ServerCredentials {
+      private contextOptions: SecureContextOptions;
+      constructor(key: Buffer, cert: Buffer) {
+        super();
+        this.contextOptions = { key, cert };
+        this.enable();
+      }
+      enable() {
+        this.updateSecureContextOptions(this.contextOptions);
+      }
+      disable() {
+        this.updateSecureContextOptions(null);
+      }
+      _isSecure(): boolean {
+        return true;
+      }
+      _equals(other: grpc.ServerCredentials): boolean {
+        return this === other;
+      }
+    }
+
+    const serverCredentials = new ToggleableSecureServerCredentials(key, cert);
+
+    const serviceImplementation = {
+      echo(call: ServerUnaryCall<any, any>, callback: sendUnaryData<any>) {
+        callback(null, call.request);
+      },
+      echoBidiStream(call: ServerDuplexStream<any, any>) {
+        call.on("data", data => {
+          call.write(data);
+        });
+        call.on("end", () => {
+          call.end();
+        });
+      },
+    };
+
+    before(done => {
+      server = new Server();
+      server.addService(echoService.service, serviceImplementation);
+
+      server.bindAsync("localhost:0", serverCredentials, (err, port) => {
+        assert.ifError(err);
+        serverPort = port;
+        done();
+      });
+    });
+
+    after(() => {
+      client.close();
+      server.forceShutdown();
+    });
+
+    it("should make successful requests only when the credentials are enabled", done => {
+      const client1 = new echoService(`localhost:${serverPort}`, grpc.credentials.createSsl(ca), {
+        "grpc.ssl_target_name_override": "foo.test.google.fr",
+        "grpc.default_authority": "foo.test.google.fr",
+        "grpc.use_local_subchannel_pool": 1,
+      });
+      const testMessage = { value: "test value", value2: 3 };
+      client1.echo(testMessage, (error: ServiceError, response: any) => {
+        assert.ifError(error);
+        assert.deepStrictEqual(response, testMessage);
+        serverCredentials.disable();
+        const client2 = new echoService(`localhost:${serverPort}`, grpc.credentials.createSsl(ca), {
+          "grpc.ssl_target_name_override": "foo.test.google.fr",
+          "grpc.default_authority": "foo.test.google.fr",
+          "grpc.use_local_subchannel_pool": 1,
+        });
+        client2.echo(testMessage, (error: ServiceError, response: any) => {
+          assert(error);
+          assert.strictEqual(error.code, grpc.status.UNAVAILABLE);
+          serverCredentials.enable();
+          const client3 = new echoService(`localhost:${serverPort}`, grpc.credentials.createSsl(ca), {
+            "grpc.ssl_target_name_override": "foo.test.google.fr",
+            "grpc.default_authority": "foo.test.google.fr",
+            "grpc.use_local_subchannel_pool": 1,
+          });
+          client3.echo(testMessage, (error: ServiceError, response: any) => {
+            assert.ifError(error);
+            done();
+          });
+        });
+      });
+    });
+  });
+
+  /* This test passes on Node 18 but fails on Node 16. The failure appears to
+   * be caused by https://github.com/nodejs/node/issues/42713 */
+  it.skip("should continue a stream after server shutdown", done => {
+    const server2 = new Server();
+    server2.addService(echoService.service, serviceImplementation);
+    server2.bindAsync("localhost:0", ServerCredentials.createInsecure(), (err, port) => {
+      if (err) {
+        done(err);
+        return;
+      }
+      const client2 = new echoService(`localhost:${port}`, grpc.credentials.createInsecure());
+      server2.start();
+      const stream = client2.echoBidiStream();
+      const totalMessages = 5;
+      let messagesSent = 0;
+      stream.write({ value: "test value", value2: messagesSent });
+      messagesSent += 1;
+      stream.on("data", () => {
+        if (messagesSent === 1) {
+          server2.tryShutdown(assert2.mustCall(() => {}));
+        }
+        if (messagesSent >= totalMessages) {
+          stream.end();
+        } else {
+          stream.write({ value: "test value", value2: messagesSent });
+          messagesSent += 1;
+        }
+      });
+      stream.on(
+        "status",
+        assert2.mustCall((status: grpc.StatusObject) => {
+          assert.strictEqual(status.code, grpc.status.OK);
+          assert.strictEqual(messagesSent, totalMessages);
+        }),
+      );
+      stream.on("error", () => {});
+      assert2.afterMustCallsSatisfied(done);
+    });
+  });
+});
+
+// We dont allow connection injections yet on node:http nor node:http2
+describe.todo("Connection injector", () => {
+  let tcpServer: net.Server;
+  let server: Server;
+  let client: ServiceClient;
+  const protoFile = path.join(__dirname, "fixtures", "echo_service.proto");
+  const echoService = loadProtoFile(protoFile).EchoService as ServiceClientConstructor;
+
+  const serviceImplementation = {
+    echo(call: ServerUnaryCall<any, any>, callback: sendUnaryData<any>) {
+      callback(null, call.request);
+    },
+    echoBidiStream(call: ServerDuplexStream<any, any>) {
+      call.on("data", data => {
+        call.write(data);
+      });
+      call.on("end", () => {
+        call.end();
+      });
+    },
+  };
+
+  before(done => {
+    server = new Server();
+    const creds = ServerCredentials.createSsl(null, [{ private_key: key, cert_chain: cert }], false);
+    const connectionInjector = server.createConnectionInjector(creds);
+    tcpServer = net.createServer(socket => {
+      connectionInjector.injectConnection(socket);
+    });
+    server.addService(echoService.service, serviceImplementation);
+    tcpServer.listen(0, "localhost", () => {
+      const port = (tcpServer.address() as net.AddressInfo).port;
+      client = new echoService(`localhost:${port}`, grpc.credentials.createSsl(ca), {
+        "grpc.ssl_target_name_override": "foo.test.google.fr",
+        "grpc.default_authority": "foo.test.google.fr",
+      });
+      done();
+    });
+  });
+
+  after(() => {
+    client.close();
+    tcpServer.close();
+    server.forceShutdown();
+  });
+
+  it("should respond to a request", done => {
+    client.echo({ value: "test value", value2: 3 }, (error: ServiceError, response: any) => {
+      assert.ifError(error);
+      assert.deepStrictEqual(response, { value: "test value", value2: 3 });
+      done();
+    });
+  });
+});
+
+describe("Generic client and server", () => {
+  function toString(val: any) {
+    return val.toString();
+  }
+
+  function toBuffer(str: string) {
+    return Buffer.from(str);
+  }
+
+  function capitalize(str: string) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+
+  const stringServiceAttrs = {
+    capitalize: {
+      path: "/string/capitalize",
+      requestStream: false,
+      responseStream: false,
+      requestSerialize: toBuffer,
+      requestDeserialize: toString,
+      responseSerialize: toBuffer,
+      responseDeserialize: toString,
+    },
+  };
+
+  describe("String client and server", () => {
+    let client: ServiceClient;
+    let server: Server;
+
+    before(done => {
+      server = new Server();
+
+      server.addService(stringServiceAttrs as any, {
+        capitalize(call: ServerUnaryCall<any, any>, callback: sendUnaryData<any>) {
+          callback(null, capitalize(call.request));
+        },
+      });
+
+      server.bindAsync("localhost:0", ServerCredentials.createInsecure(), (err, port) => {
+        assert.ifError(err);
+        server.start();
+        const clientConstr = grpc.makeGenericClientConstructor(
+          stringServiceAttrs as any,
+          "unused_but_lets_appease_typescript_anyway",
+        );
+        client = new clientConstr(`localhost:${port}`, grpc.credentials.createInsecure());
+        done();
+      });
+    });
+
+    after(() => {
+      client.close();
+      server.forceShutdown();
+    });
+
+    it("Should respond with a capitalized string", done => {
+      client.capitalize("abc", (err: ServiceError, response: string) => {
+        assert.ifError(err);
+        assert.strictEqual(response, "Abc");
+        done();
+      });
+    });
+  });
+
+  it("responds with HTTP status of 415 on invalid content-type", done => {
+    const server = new Server();
+    const creds = ServerCredentials.createInsecure();
+
+    server.bindAsync("localhost:0", creds, (err, port) => {
+      assert.ifError(err);
+      const client = http2.connect(`http://localhost:${port}`);
+      let count = 0;
+
+      function makeRequest(headers: http2.IncomingHttpHeaders) {
+        const req = client.request(headers);
+        let statusCode: string;
+
+        req.on("response", headers => {
+          statusCode = headers[http2.constants.HTTP2_HEADER_STATUS] as string;
+          assert.strictEqual(statusCode, http2.constants.HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE);
+        });
+
+        req.on("end", () => {
+          assert(statusCode);
+          count++;
+          if (count === 2) {
+            client.close();
+            server.forceShutdown();
+            done();
+          }
+        });
+
+        req.end();
+      }
+
+      server.start();
+
+      // Missing Content-Type header.
+      makeRequest({ ":path": "/" });
+      // Invalid Content-Type header.
+      makeRequest({ ":path": "/", "content-type": "application/not-grpc" });
+    });
+  });
+});
+
+describe("Compressed requests", () => {
+  const testServiceHandlers: TestServiceHandlers = {
+    Unary(call, callback) {
+      callback(null, { count: 500000, message: call.request.message });
+    },
+
+    ClientStream(call, callback) {
+      let timesCalled = 0;
+
+      call.on("data", () => {
+        timesCalled += 1;
+      });
+
+      call.on("end", () => {
+        callback(null, { count: timesCalled });
+      });
+    },
+
+    ServerStream(call) {
+      const { request } = call;
+
+      for (let i = 0; i < 5; i++) {
+        call.write({ count: request.message.length });
+      }
+
+      call.end();
+    },
+
+    BidiStream(call) {
+      call.on("data", (data: Request__Output) => {
+        call.write({ count: data.message.length });
+      });
+
+      call.on("end", () => {
+        call.end();
+      });
+    },
+  };
+
+  describe("Test service client and server with deflate", () => {
+    let client: TestServiceClient;
+    let server: Server;
+    let assignedPort: number;
+
+    before(done => {
+      server = new Server();
+      server.addService(testServiceGrpcObject.TestService.service, testServiceHandlers);
+      server.bindAsync("127.0.0.1:0", ServerCredentials.createInsecure(), (err, port) => {
+        assert.ifError(err);
+        server.start();
+        assignedPort = port;
+        client = new testServiceGrpcObject.TestService(`127.0.0.1:${assignedPort}`, grpc.credentials.createInsecure(), {
+          "grpc.default_compression_algorithm": CompressionAlgorithms.deflate,
+        });
+        done();
+      });
+    });
+
+    after(() => {
+      client.close();
+      server.forceShutdown();
+    });
+
+    it("Should compress and decompress when performing unary call", done => {
+      client.unary({ message: "foo" }, (err, response) => {
+        assert.ifError(err);
+        done();
+      });
+    });
+
+    it("Should compress and decompress when performing client stream", done => {
+      const clientStream = client.clientStream((err, res) => {
+        assert.ifError(err);
+        assert.equal(res?.count, 3);
+        done();
+      });
+
+      clientStream.write({ message: "foo" }, () => {
+        clientStream.write({ message: "bar" }, () => {
+          clientStream.write({ message: "baz" }, () => {
+            setTimeout(() => clientStream.end(), 10);
+          });
+        });
+      });
+    });
+
+    it("Should compress and decompress when performing server stream", done => {
+      const serverStream = client.serverStream({ message: "foobar" });
+      let timesResponded = 0;
+
+      serverStream.on("data", () => {
+        timesResponded += 1;
+      });
+
+      serverStream.on("error", err => {
+        assert.ifError(err);
+        done();
+      });
+
+      serverStream.on("end", () => {
+        assert.equal(timesResponded, 5);
+        done();
+      });
+    });
+
+    it("Should compress and decompress when performing bidi stream", done => {
+      const bidiStream = client.bidiStream();
+      let timesRequested = 0;
+      let timesResponded = 0;
+
+      bidiStream.on("data", () => {
+        timesResponded += 1;
+      });
+
+      bidiStream.on("error", err => {
+        assert.ifError(err);
+        done();
+      });
+
+      bidiStream.on("end", () => {
+        assert.equal(timesResponded, timesRequested);
+        done();
+      });
+
+      bidiStream.write({ message: "foo" }, () => {
+        timesRequested += 1;
+        bidiStream.write({ message: "bar" }, () => {
+          timesRequested += 1;
+          bidiStream.write({ message: "baz" }, () => {
+            timesRequested += 1;
+            setTimeout(() => bidiStream.end(), 10);
+          });
+        });
+      });
+    });
+
+    it("Should compress and decompress with gzip", done => {
+      client = new testServiceGrpcObject.TestService(`localhost:${assignedPort}`, grpc.credentials.createInsecure(), {
+        "grpc.default_compression_algorithm": CompressionAlgorithms.gzip,
+      });
+
+      client.unary({ message: "foo" }, (err, response) => {
+        assert.ifError(err);
+        done();
+      });
+    });
+
+    it("Should compress and decompress when performing client stream", done => {
+      const clientStream = client.clientStream((err, res) => {
+        assert.ifError(err);
+        assert.equal(res?.count, 3);
+        done();
+      });
+
+      clientStream.write({ message: "foo" }, () => {
+        clientStream.write({ message: "bar" }, () => {
+          clientStream.write({ message: "baz" }, () => {
+            setTimeout(() => clientStream.end(), 10);
+          });
+        });
+      });
+    });
+
+    it("Should compress and decompress when performing server stream", done => {
+      const serverStream = client.serverStream({ message: "foobar" });
+      let timesResponded = 0;
+
+      serverStream.on("data", () => {
+        timesResponded += 1;
+      });
+
+      serverStream.on("error", err => {
+        assert.ifError(err);
+        done();
+      });
+
+      serverStream.on("end", () => {
+        assert.equal(timesResponded, 5);
+        done();
+      });
+    });
+
+    it("Should compress and decompress when performing bidi stream", done => {
+      const bidiStream = client.bidiStream();
+      let timesRequested = 0;
+      let timesResponded = 0;
+
+      bidiStream.on("data", () => {
+        timesResponded += 1;
+      });
+
+      bidiStream.on("error", err => {
+        assert.ifError(err);
+        done();
+      });
+
+      bidiStream.on("end", () => {
+        assert.equal(timesResponded, timesRequested);
+        done();
+      });
+
+      bidiStream.write({ message: "foo" }, () => {
+        timesRequested += 1;
+        bidiStream.write({ message: "bar" }, () => {
+          timesRequested += 1;
+          bidiStream.write({ message: "baz" }, () => {
+            timesRequested += 1;
+            setTimeout(() => bidiStream.end(), 10);
+          });
+        });
+      });
+    });
+
+    it("Should handle large messages", done => {
+      let longMessage = Buffer.alloc(4000000, "a").toString("utf8");
+      client.unary({ message: longMessage }, (err, response) => {
+        assert.ifError(err);
+        assert.strictEqual(response?.message, longMessage);
+        done();
+      });
+    }, 30000);
+
+    /* As of Node 16, Writable and Duplex streams validate the encoding
+     * argument to write, and the flags values we are passing there are not
+     * valid. We don't currently have an alternative way to pass that flag
+     * down, so for now this feature is not supported. */
+    it.skip("Should not compress requests when the NoCompress write flag is used", done => {
+      const bidiStream = client.bidiStream();
+      let timesRequested = 0;
+      let timesResponded = 0;
+
+      bidiStream.on("data", () => {
+        timesResponded += 1;
+      });
+
+      bidiStream.on("error", err => {
+        assert.ifError(err);
+        done();
+      });
+
+      bidiStream.on("end", () => {
+        assert.equal(timesResponded, timesRequested);
+        done();
+      });
+
+      bidiStream.write({ message: "foo" }, "2", (err: any) => {
+        assert.ifError(err);
+        timesRequested += 1;
+        setTimeout(() => bidiStream.end(), 10);
+      });
+    });
+  });
+});
diff --git a/test/js/third_party/grpc-js/test-status-builder.test.ts b/test/js/third_party/grpc-js/test-status-builder.test.ts
new file mode 100644
index 0000000000..2d87241a33
--- /dev/null
+++ b/test/js/third_party/grpc-js/test-status-builder.test.ts
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import assert from "assert";
+
+import * as grpc from "@grpc/grpc-js/build/src";
+import { StatusBuilder } from "@grpc/grpc-js/build/src/status-builder";
+import { afterAll as after, beforeAll as before, describe, it, afterEach, beforeEach } from "bun:test";
+
+describe("StatusBuilder", () => {
+  it("is exported by the module", () => {
+    assert.strictEqual(StatusBuilder, grpc.StatusBuilder);
+  });
+
+  it("builds a status object", () => {
+    const builder = new StatusBuilder();
+    const metadata = new grpc.Metadata();
+    let result;
+
+    assert.deepStrictEqual(builder.build(), {});
+    result = builder.withCode(grpc.status.OK);
+    assert.strictEqual(result, builder);
+    assert.deepStrictEqual(builder.build(), { code: grpc.status.OK });
+    result = builder.withDetails("foobar");
+    assert.strictEqual(result, builder);
+    assert.deepStrictEqual(builder.build(), {
+      code: grpc.status.OK,
+      details: "foobar",
+    });
+    result = builder.withMetadata(metadata);
+    assert.strictEqual(result, builder);
+    assert.deepStrictEqual(builder.build(), {
+      code: grpc.status.OK,
+      details: "foobar",
+      metadata,
+    });
+  });
+});
diff --git a/test/js/third_party/grpc-js/test-uri-parser.test.ts b/test/js/third_party/grpc-js/test-uri-parser.test.ts
new file mode 100644
index 0000000000..a94a13c282
--- /dev/null
+++ b/test/js/third_party/grpc-js/test-uri-parser.test.ts
@@ -0,0 +1,142 @@
+/*
+ * Copyright 2020 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import assert from "assert";
+import * as uriParser from "@grpc/grpc-js/build/src/uri-parser";
+import * as resolver from "@grpc/grpc-js/build/src/resolver";
+import { afterAll as after, beforeAll as before, describe, it, afterEach, beforeEach } from "bun:test";
+
+describe("URI Parser", function () {
+  describe("parseUri", function () {
+    const expectationList: {
+      target: string;
+      result: uriParser.GrpcUri | null;
+    }[] = [
+      {
+        target: "localhost",
+        result: { scheme: undefined, authority: undefined, path: "localhost" },
+      },
+      /* This looks weird, but it's OK because the resolver selection code will handle it */
+      {
+        target: "localhost:80",
+        result: { scheme: "localhost", authority: undefined, path: "80" },
+      },
+      {
+        target: "dns:localhost",
+        result: { scheme: "dns", authority: undefined, path: "localhost" },
+      },
+      {
+        target: "dns:///localhost",
+        result: { scheme: "dns", authority: "", path: "localhost" },
+      },
+      {
+        target: "dns://authority/localhost",
+        result: { scheme: "dns", authority: "authority", path: "localhost" },
+      },
+      {
+        target: "//authority/localhost",
+        result: {
+          scheme: undefined,
+          authority: "authority",
+          path: "localhost",
+        },
+      },
+      // Regression test for https://github.com/grpc/grpc-node/issues/1359
+      {
+        target: "dns:foo-internal.aws-us-east-2.tracing.staging-edge.foo-data.net:443:443",
+        result: {
+          scheme: "dns",
+          authority: undefined,
+          path: "foo-internal.aws-us-east-2.tracing.staging-edge.foo-data.net:443:443",
+        },
+      },
+    ];
+    for (const { target, result } of expectationList) {
+      it(target, function () {
+        assert.deepStrictEqual(uriParser.parseUri(target), result);
+      });
+    }
+  });
+
+  describe.todo("parseUri + mapUriDefaultScheme", function () {
+    const expectationList: {
+      target: string;
+      result: uriParser.GrpcUri | null;
+    }[] = [
+      {
+        target: "localhost",
+        result: { scheme: "dns", authority: undefined, path: "localhost" },
+      },
+      {
+        target: "localhost:80",
+        result: { scheme: "dns", authority: undefined, path: "localhost:80" },
+      },
+      {
+        target: "dns:localhost",
+        result: { scheme: "dns", authority: undefined, path: "localhost" },
+      },
+      {
+        target: "dns:///localhost",
+        result: { scheme: "dns", authority: "", path: "localhost" },
+      },
+      {
+        target: "dns://authority/localhost",
+        result: { scheme: "dns", authority: "authority", path: "localhost" },
+      },
+      {
+        target: "unix:socket",
+        result: { scheme: "unix", authority: undefined, path: "socket" },
+      },
+      {
+        target: "bad:path",
+        result: { scheme: "dns", authority: undefined, path: "bad:path" },
+      },
+    ];
+    for (const { target, result } of expectationList) {
+      it(target, function () {
+        assert.deepStrictEqual(resolver.mapUriDefaultScheme(uriParser.parseUri(target) ?? { path: "null" }), result);
+      });
+    }
+  });
+
+  describe("splitHostPort", function () {
+    const expectationList: {
+      path: string;
+      result: uriParser.HostPort | null;
+    }[] = [
+      { path: "localhost", result: { host: "localhost" } },
+      { path: "localhost:123", result: { host: "localhost", port: 123 } },
+      { path: "12345:6789", result: { host: "12345", port: 6789 } },
+      { path: "[::1]:123", result: { host: "::1", port: 123 } },
+      { path: "[::1]", result: { host: "::1" } },
+      { path: "[", result: null },
+      { path: "[123]", result: null },
+      // Regression test for https://github.com/grpc/grpc-node/issues/1359
+      {
+        path: "foo-internal.aws-us-east-2.tracing.staging-edge.foo-data.net:443:443",
+        result: {
+          host: "foo-internal.aws-us-east-2.tracing.staging-edge.foo-data.net:443:443",
+        },
+      },
+    ];
+    for (const { path, result } of expectationList) {
+      it(path, function () {
+        assert.deepStrictEqual(uriParser.splitHostPort(path), result);
+      });
+    }
+  });
+});
diff --git a/test/js/third_party/http2-wrapper/http2-wrapper.test.ts b/test/js/third_party/http2-wrapper/http2-wrapper.test.ts
new file mode 100644
index 0000000000..7faad0efb2
--- /dev/null
+++ b/test/js/third_party/http2-wrapper/http2-wrapper.test.ts
@@ -0,0 +1,89 @@
+import { test, expect } from "bun:test";
+import { tls } from "harness";
+import http2Wrapper from "http2-wrapper";
+import type { AutoRequestOptions } from "http2-wrapper";
+import http from "http";
+
+async function doRequest(options: AutoRequestOptions) {
+  const { promise, resolve, reject } = Promise.withResolvers();
+  const request = await http2Wrapper.auto(options, (response: http.IncomingMessage) => {
+    if (response.statusCode !== 200) {
+      return reject(new Error(`expected status code 200 rejected: ${response.statusCode}`));
+    }
+
+    const body: Array<Buffer> = [];
+    response.on("error", reject);
+    response.on("data", (chunk: Buffer) => body.push(chunk));
+    response.on("end", () => {
+      resolve(Buffer.concat(body).toString());
+    });
+  });
+
+  request.on("error", reject);
+
+  request.end("123456");
+  const body = (await promise) as string;
+  expect(body).toBeString();
+  const parsed = JSON.parse(body);
+  expect(parsed.data).toBe("123456");
+}
+
+test("should allow http/1.1 when using http2-wrapper", async () => {
+  {
+    using server = Bun.serve({
+      async fetch(req) {
+        return new Response(
+          JSON.stringify({
+            data: await req.text(),
+          }),
+          {
+            headers: {
+              "content-type": "application/json",
+            },
+          },
+        );
+      },
+    });
+
+    await doRequest({
+      host: "localhost",
+      port: server.port,
+      protocol: "http:",
+      path: "/post",
+      method: "POST",
+      headers: {
+        "content-length": 6,
+      },
+    });
+  }
+
+  {
+    using server = Bun.serve({
+      tls,
+      hostname: "localhost",
+      async fetch(req) {
+        return new Response(
+          JSON.stringify({
+            data: await req.text(),
+          }),
+          {
+            headers: {
+              "content-type": "application/json",
+            },
+          },
+        );
+      },
+    });
+    await doRequest({
+      host: "localhost",
+      port: server.port,
+      protocol: "https:",
+      path: "/post",
+      method: "POST",
+      ca: tls.cert,
+      headers: {
+        "content-length": 6,
+      },
+    });
+  }
+});
diff --git a/test/js/third_party/http2-wrapper/package.json b/test/js/third_party/http2-wrapper/package.json
new file mode 100644
index 0000000000..d2205f27e3
--- /dev/null
+++ b/test/js/third_party/http2-wrapper/package.json
@@ -0,0 +1,7 @@
+{
+  "name": "http2-wrapper-test",
+  "version": "1.0.0",
+  "dependencies": {
+    "http2-wrapper": "2.2.1"
+  }
+}
diff --git a/test/js/third_party/pg/package.json b/test/js/third_party/pg/package.json
new file mode 100644
index 0000000000..20b0102e47
--- /dev/null
+++ b/test/js/third_party/pg/package.json
@@ -0,0 +1,6 @@
+{
+  "name": "pg",
+  "dependencies": {
+    "pg": "8.11.1"
+  }
+}
diff --git a/test/js/third_party/pg/pg.test.ts b/test/js/third_party/pg/pg.test.ts
new file mode 100644
index 0000000000..3d55f4c1ce
--- /dev/null
+++ b/test/js/third_party/pg/pg.test.ts
@@ -0,0 +1,75 @@
+import { describe, expect, test } from "bun:test";
+import { getSecret } from "harness";
+import { Client, Pool } from "pg";
+import { parse } from "pg-connection-string";
+
+const databaseUrl = getSecret("TLS_POSTGRES_DATABASE_URL");
+
+// Function to insert 1000 users
+async function insertUsers(client: Client) {
+  // Generate an array of users
+  const users = Array.from({ length: 300 }, (_, i) => ({
+    name: `User ${i + 1}`,
+    email: `user${i + 1}@example.com`,
+    age: Math.floor(Math.random() * 50) + 20, // Random age between 20 and 70
+  }));
+
+  // Prepare the query to insert multiple rows
+  const insertQuery = `
+    INSERT INTO pg_users (name, email, age)
+    VALUES ${users.map((_, i) => `($${i * 3 + 1}, $${i * 3 + 2}, $${i * 3 + 3})`).join(", ")};
+  `;
+
+  // Flatten the users array for parameterized query
+  const values = users.flatMap(user => [user.name, user.email, user.age]);
+
+  await client.query(insertQuery, values);
+}
+
+async function connect() {
+  const client = new Client({
+    connectionString: databaseUrl!,
+    ssl: { rejectUnauthorized: false },
+  });
+  await client.connect().then(() => {
+    // Define the SQL query to create a table
+    const createTableQuery = `
+      CREATE TABLE IF NOT EXISTS pg_users (
+        id SERIAL PRIMARY KEY,
+        name VARCHAR(100) NOT NULL,
+        email VARCHAR(100) UNIQUE NOT NULL,
+        age INTEGER,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      );
+    `;
+
+    // Execute the query
+    return client.query(createTableQuery);
+  });
+  // check if we need to populate the data
+  const { rows } = await client.query("SELECT COUNT(*) AS count FROM pg_users");
+  const userCount = Number.parseInt(rows[0].count, 10);
+  if (userCount === 0) await insertUsers(client);
+  return client;
+}
+
+describe.skipIf(!databaseUrl)("pg", () => {
+  test("should connect using TLS", async () => {
+    const pool = new Pool(parse(databaseUrl!));
+    try {
+      const { rows } = await pool.query("SELECT version()", []);
+      const [{ version }] = rows;
+
+      expect(version).toMatch(/PostgreSQL/);
+    } finally {
+      pool.end();
+    }
+  });
+
+  test("should execute big query and end connection", async () => {
+    const client = await connect();
+    const res = await client.query(`SELECT * FROM pg_users LIMIT 300`);
+    expect(res.rows.length).toBe(300);
+    await client.end();
+  }, 20_000);
+});
diff --git a/test/js/third_party/postgres/postgres.test.ts b/test/js/third_party/postgres/postgres.test.ts
index ef60a79989..3800a062bc 100644
--- a/test/js/third_party/postgres/postgres.test.ts
+++ b/test/js/third_party/postgres/postgres.test.ts
@@ -11,7 +11,30 @@ describe.skipIf(!databaseUrl)("postgres", () => {
       const [{ version }] = await sql`SELECT version()`;
       expect(version).toMatch(/PostgreSQL/);
     } finally {
-      sql.end();
+      await sql.end();
+    }
+  });
+
+  test("should be able to resume after backpressure pause on upgraded handler #15438", async () => {
+    const sql = postgres(databaseUrl!);
+    try {
+      const batch = [];
+      for (let i = 0; i < 1000; i++) {
+        batch.push(
+          (async sql => {
+            const [{ version }] = await sql`SELECT version()`;
+            expect(version).toMatch(/PostgreSQL/);
+          })(sql),
+        );
+        if (batch.length === 50) {
+          await Promise.all(batch);
+        }
+      }
+      if (batch.length > 0) {
+        await Promise.all(batch);
+      }
+    } finally {
+      await sql.end();
     }
   });
 
diff --git a/test/js/third_party/pq/package.json b/test/js/third_party/pq/package.json
deleted file mode 100644
index b42b99ed32..0000000000
--- a/test/js/third_party/pq/package.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "name": "pq",
-  "dependencies": {
-    "pg": "8.11.1"
-  }
-}
diff --git a/test/js/third_party/pq/pq.test.ts b/test/js/third_party/pq/pq.test.ts
deleted file mode 100644
index bd2ad8889e..0000000000
--- a/test/js/third_party/pq/pq.test.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { getSecret } from "harness";
-import { Client, Pool } from "pg";
-import { parse } from "pg-connection-string";
-
-const databaseUrl = getSecret("TLS_POSTGRES_DATABASE_URL");
-
-describe.skipIf(!databaseUrl)("pg", () => {
-  test("should connect using TLS", async () => {
-    const pool = new Pool(parse(databaseUrl!));
-    try {
-      const { rows } = await pool.query("SELECT version()", []);
-      const [{ version }] = rows;
-
-      expect(version).toMatch(/PostgreSQL/);
-    } finally {
-      pool.end();
-    }
-  });
-
-  test("should execute big query and end connection", async () => {
-    const client = new Client({
-      connectionString: databaseUrl!,
-      ssl: { rejectUnauthorized: false },
-    });
-
-    await client.connect();
-    const res = await client.query(`SELECT * FROM users LIMIT 1000`);
-    expect(res.rows.length).toBeGreaterThanOrEqual(300);
-    await client.end();
-  });
-});
diff --git a/test/js/third_party/prisma/helper.ts b/test/js/third_party/prisma/helper.ts
index 2f94da797a..47a3d787c9 100644
--- a/test/js/third_party/prisma/helper.ts
+++ b/test/js/third_party/prisma/helper.ts
@@ -3,19 +3,19 @@ import { bunEnv, bunExe, isLinux } from "harness";
 import path from "path";
 const cwd = import.meta.dir;
 
-export async function generateClient(type: string) {
-  generate(type);
+export async function generateClient(type: string, env: Record<string, string>) {
+  generate(type, env);
 
   // This should run the first time on a fresh db
   try {
-    migrate(type);
+    migrate(type, env);
   } catch (err: any) {
     if (err.message.indexOf("Environment variable not found:") !== -1) throw err;
   }
 
   return (await import(`./prisma/${type}/client`)).PrismaClient;
 }
-export function migrate(type: string) {
+export function migrate(type: string, env: Record<string, string>) {
   const result = Bun.spawnSync(
     [
       bunExe(),
@@ -33,13 +33,14 @@ export function migrate(type: string) {
       env: {
         ...bunEnv,
         NODE_ENV: undefined,
+        ...env,
       },
     },
   );
   if (!result.success) throw new Error(result.stderr.toString("utf8"));
 }
 
-export function generate(type: string) {
+export function generate(type: string, env: Record<string, string>) {
   const schema = path.join(cwd, "prisma", type, "schema.prisma");
 
   const content = fs
@@ -60,6 +61,7 @@ export function generate(type: string) {
     env: {
       ...bunEnv,
       NODE_ENV: undefined,
+      ...env,
     },
   });
   if (!result.success) throw new Error(result.stderr.toString("utf8"));
diff --git a/test/js/third_party/prisma/prisma.test.ts b/test/js/third_party/prisma/prisma.test.ts
index 5a79450d54..d470225b7a 100644
--- a/test/js/third_party/prisma/prisma.test.ts
+++ b/test/js/third_party/prisma/prisma.test.ts
@@ -2,6 +2,9 @@ import { createCanvas } from "@napi-rs/canvas";
 import { it as bunIt, test as bunTest, describe, expect } from "bun:test";
 import { generate, generateClient } from "./helper.ts";
 import type { PrismaClient } from "./prisma/types.d.ts";
+import { appendFile } from "fs/promises";
+import { heapStats } from "bun:jsc";
+import { getSecret, isCI } from "harness";
 
 function* TestIDGenerator(): Generator<number> {
   while (true) {
@@ -19,23 +22,28 @@ async function cleanTestId(prisma: PrismaClient, testId: number) {
 ["sqlite", "postgres" /*"mssql", "mongodb"*/].forEach(async type => {
   let Client: typeof PrismaClient;
 
-  try {
-    if (type !== "sqlite" && !process.env[`TLS_${type.toUpperCase()}_DATABASE_URL`]) {
-      throw new Error(`$TLS_${type.toUpperCase()}_DATABASE_URL is not set`);
-    }
+  const env_name = `TLS_${type.toUpperCase()}_DATABASE_URL`;
+  let database_url = type !== "sqlite" ? getSecret(env_name) : null;
 
-    Client = await generateClient(type);
-  } catch (err: any) {
-    console.warn(`Skipping ${type} tests, failed to generate/migrate`, err.message);
-  }
+  Client = await generateClient(type, {
+    [env_name]: (database_url || "") as string,
+  });
 
   async function test(label: string, callback: Function, timeout: number = 5000) {
-    const it = Client ? bunTest : bunTest.skip;
+    const it = Client && (database_url || type === "sqlite") ? bunTest : bunTest.skip;
 
     it(
       label,
       async () => {
-        const prisma = new Client();
+        const prisma = database_url
+          ? new Client({
+              datasources: {
+                db: {
+                  url: database_url as string,
+                },
+              },
+            })
+          : new Client();
         const currentTestId = test_id.next().value;
         await cleanTestId(prisma, currentTestId);
         try {
@@ -73,6 +81,59 @@ async function cleanTestId(prisma: PrismaClient, testId: number) {
         expect().pass();
       });
     }
+    if (
+      type === "sqlite" &&
+      // TODO: figure out how to run this in CI without timing out.
+      !isCI
+    ) {
+      test(
+        "does not leak",
+        async (prisma: PrismaClient, _: number) => {
+          // prisma leak was 8 bytes per query, so a million requests would manifest as an 8MB leak
+          const batchSize = 1000;
+          const warmupIters = 5_000_000 / batchSize;
+          const testIters = 4_000_000 / batchSize;
+          const gcPeriod = 100_000 / batchSize;
+          let totalIters = 0;
+          const queries = new Array(batchSize);
+
+          async function runQuery() {
+            totalIters++;
+            // GC occasionally to make memory usage more deterministic
+            if (totalIters % gcPeriod == gcPeriod - 1) {
+              Bun.gc(true);
+              const line = `${totalIters * batchSize},${(process.memoryUsage.rss() / 1024 / 1024) | 0}`;
+              console.log(line);
+              if (!isCI) await appendFile("rss.csv", line + "\n");
+            }
+
+            for (let i = 0; i < batchSize; i++) {
+              queries[i] = prisma.$queryRaw`SELECT 1`;
+            }
+            await Promise.all(queries);
+          }
+
+          console.time("Warmup x " + warmupIters + " x " + batchSize);
+          for (let i = 0; i < warmupIters; i++) {
+            await runQuery();
+          }
+          console.timeEnd("Warmup x " + warmupIters + " x " + batchSize);
+
+          console.time("Test x " + testIters + " x " + batchSize);
+          // measure memory now
+          const before = process.memoryUsage.rss();
+          // run a bunch more iterations to see if memory usage increases
+          for (let i = 0; i < testIters; i++) {
+            await runQuery();
+          }
+          console.timeEnd("Test x " + testIters + " x " + batchSize);
+          const after = process.memoryUsage.rss();
+          const deltaMB = (after - before) / 1024 / 1024;
+          expect(deltaMB).toBeLessThan(10);
+        },
+        120_000,
+      );
+    }
 
     test(
       "CRUD basics",
diff --git a/test/js/third_party/prisma/prisma/postgres/migrations/20240316000224_init/migration.sql b/test/js/third_party/prisma/prisma/postgres/migrations/20240316000224_init/migration.sql
deleted file mode 100644
index 84dadf9681..0000000000
--- a/test/js/third_party/prisma/prisma/postgres/migrations/20240316000224_init/migration.sql
+++ /dev/null
@@ -1,49 +0,0 @@
--- CreateTable
-CREATE TABLE "User" (
-    "id" SERIAL NOT NULL,
-    "testId" INTEGER NOT NULL,
-    "email" TEXT NOT NULL,
-    "name" TEXT,
-
-    CONSTRAINT "User_pkey" PRIMARY KEY ("id")
-);
-
--- CreateTable
-CREATE TABLE "Post" (
-    "id" SERIAL NOT NULL,
-    "testId" INTEGER NOT NULL,
-    "title" TEXT NOT NULL,
-    "content" TEXT,
-    "published" BOOLEAN NOT NULL DEFAULT false,
-    "authorId" INTEGER NOT NULL,
-    "option1" INTEGER,
-    "option2" INTEGER,
-    "option3" INTEGER,
-    "option4" INTEGER,
-    "option5" INTEGER,
-    "option6" INTEGER,
-    "option7" INTEGER,
-    "option8" INTEGER,
-    "option9" INTEGER,
-    "option10" INTEGER,
-    "option11" INTEGER,
-    "option12" INTEGER,
-    "option13" INTEGER,
-    "option14" INTEGER,
-    "option15" INTEGER,
-    "option16" INTEGER,
-    "option17" INTEGER,
-    "option18" INTEGER,
-    "option19" INTEGER,
-    "option20" INTEGER,
-    "option21" INTEGER,
-    "option22" INTEGER,
-    "option23" INTEGER,
-    "option24" INTEGER,
-    "option25" INTEGER,
-
-    CONSTRAINT "Post_pkey" PRIMARY KEY ("id")
-);
-
--- AddForeignKey
-ALTER TABLE "Post" ADD CONSTRAINT "Post_authorId_fkey" FOREIGN KEY ("authorId") REFERENCES "User"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
diff --git a/test/js/third_party/prisma/prisma/postgres/migrations/20240316042522_users/migration.sql b/test/js/third_party/prisma/prisma/postgres/migrations/20240316042522_users/migration.sql
deleted file mode 100644
index 6a65b0b62f..0000000000
--- a/test/js/third_party/prisma/prisma/postgres/migrations/20240316042522_users/migration.sql
+++ /dev/null
@@ -1,7 +0,0 @@
--- CreateTable
-CREATE TABLE "Users" (
-    "id" SERIAL NOT NULL,
-    "alive" BOOLEAN NOT NULL,
-
-    CONSTRAINT "Users_pkey" PRIMARY KEY ("id")
-);
diff --git a/test/js/third_party/prisma/prisma/postgres/migrations/20240316044713_lowercaseusers/migration.sql b/test/js/third_party/prisma/prisma/postgres/migrations/20240316044713_lowercaseusers/migration.sql
deleted file mode 100644
index 62c35d72c6..0000000000
--- a/test/js/third_party/prisma/prisma/postgres/migrations/20240316044713_lowercaseusers/migration.sql
+++ /dev/null
@@ -1,16 +0,0 @@
-/*
-  Warnings:
-
-  - You are about to drop the `Users` table. If the table is not empty, all the data it contains will be lost.
-
-*/
--- DropTable
-DROP TABLE "Users";
-
--- CreateTable
-CREATE TABLE "users" (
-    "id" SERIAL NOT NULL,
-    "alive" BOOLEAN NOT NULL,
-
-    CONSTRAINT "users_pkey" PRIMARY KEY ("id")
-);
diff --git a/test/js/third_party/prisma/prisma/postgres/migrations/migration_lock.toml b/test/js/third_party/prisma/prisma/postgres/migrations/migration_lock.toml
deleted file mode 100644
index fbffa92c2b..0000000000
--- a/test/js/third_party/prisma/prisma/postgres/migrations/migration_lock.toml
+++ /dev/null
@@ -1,3 +0,0 @@
-# Please do not edit this file manually
-# It should be added in your version-control system (i.e. Git)
-provider = "postgresql"
\ No newline at end of file
diff --git a/test/js/third_party/prompts/prompts.test.ts b/test/js/third_party/prompts/prompts.test.ts
index 4d58ee36af..00765fe76d 100644
--- a/test/js/third_party/prompts/prompts.test.ts
+++ b/test/js/third_party/prompts/prompts.test.ts
@@ -9,7 +9,11 @@ test("works with prompts", async () => {
     stdin: "pipe",
   });
 
-  await Bun.sleep(100);
+  const reader = child.stdout.getReader();
+
+  await reader.read();
+  reader.releaseLock();
+
   child.stdin.write("dylan\n");
   await Bun.sleep(100);
   child.stdin.write("999\n");
diff --git a/test/js/third_party/svelte/bun-loader-svelte.ts b/test/js/third_party/svelte/bun-loader-svelte.ts
index c30a7bd11e..e90562b38f 100644
--- a/test/js/third_party/svelte/bun-loader-svelte.ts
+++ b/test/js/third_party/svelte/bun-loader-svelte.ts
@@ -11,7 +11,8 @@ await plugin({
         readFileSync(path.substring(0, path.includes("?") ? path.indexOf("?") : path.length), "utf-8"),
         {
           filename: path,
-          generate: "ssr",
+          generate: "server",
+          dev: false,
         },
       ).js.code,
       loader: "js",
diff --git a/test/js/third_party/svelte/svelte.test.ts b/test/js/third_party/svelte/svelte.test.ts
index 67167ecbe0..05a56e4c42 100644
--- a/test/js/third_party/svelte/svelte.test.ts
+++ b/test/js/third_party/svelte/svelte.test.ts
@@ -1,12 +1,13 @@
 import { describe, expect, it } from "bun:test";
+import { render as svelteRender } from "svelte/server";
 import "./bun-loader-svelte";
 
 describe("require", () => {
   it("SSRs `<h1>Hello world!</h1>` with Svelte", () => {
     const { default: App } = require("./hello.svelte");
-    const { html } = App.render();
+    const { body } = svelteRender(App);
 
-    expect(html).toBe("<h1>Hello world!</h1>");
+    expect(body).toBe("<!--[--><h1>Hello world!</h1><!--]-->");
   });
 
   it("works if you require it 1,000 times", () => {
@@ -14,7 +15,7 @@ describe("require", () => {
     Bun.unsafe.gcAggressionLevel(0);
     for (let i = 0; i < 1000; i++) {
       const { default: App } = require("./hello.svelte?r" + i);
-      expect(App.render).toBeFunction();
+      expect(App).toBeFunction();
     }
     Bun.gc(true);
     Bun.unsafe.gcAggressionLevel(prev);
@@ -27,7 +28,7 @@ describe("dynamic import", () => {
     Bun.unsafe.gcAggressionLevel(0);
     for (let i = 0; i < 1000; i++) {
       const { default: App } = await import("./hello.svelte?i" + i);
-      expect(App.render).toBeFunction();
+      expect(App).toBeFunction();
     }
     Bun.gc(true);
     Bun.unsafe.gcAggressionLevel(prev);
@@ -35,8 +36,7 @@ describe("dynamic import", () => {
   it("SSRs `<h1>Hello world!</h1>` with Svelte", async () => {
     const { default: App }: any = await import("./hello.svelte");
 
-    const { html } = App.render();
-
-    expect(html).toBe("<h1>Hello world!</h1>");
+    const { body } = svelteRender(App);
+    expect(body).toBe("<!--[--><h1>Hello world!</h1><!--]-->");
   });
 });
diff --git a/test/js/web/console/__snapshots__/console-log.test.ts.snap b/test/js/web/console/__snapshots__/console-log.test.ts.snap
new file mode 100644
index 0000000000..45f884b607
--- /dev/null
+++ b/test/js/web/console/__snapshots__/console-log.test.ts.snap
@@ -0,0 +1,45 @@
+// Bun Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`console.group: console-group-error 1`] = `
+"Warning log
+  Error log"
+`;
+
+exports[`console.group: console-group-output 1`] = `
+"Basic group
+  Inside basic group
+Outer group
+  Inside outer group
+  Inner group
+    Inside inner group
+  Back to outer group
+Level 1
+  Level 2
+    Level 3
+      Deep inside
+undefined
+Empty nested
+Test extra end
+  Inside
+Different logs
+  Regular log
+  Info log
+  Debug log
+Complex types
+  {
+    a: 1,
+    b: 2,
+  }
+  [ 1, 2, 3 ]
+null
+  undefined
+    0
+      false
+        
+          Inside falsy groups
+🎉 Unicode!
+  Inside unicode group
+  Tab	Newline
+Quote"Backslash
+    Special chars"
+`;
diff --git a/test/js/web/console/console-group.fixture.js b/test/js/web/console/console-group.fixture.js
new file mode 100644
index 0000000000..34d103720d
--- /dev/null
+++ b/test/js/web/console/console-group.fixture.js
@@ -0,0 +1,78 @@
+// Basic group
+console.group("Basic group");
+console.log("Inside basic group");
+console.groupEnd();
+
+// Nested groups
+console.group("Outer group");
+console.log("Inside outer group");
+console.group("Inner group");
+console.log("Inside inner group");
+console.groupEnd();
+console.log("Back to outer group");
+console.groupEnd();
+
+// Multiple nested groups
+console.group("Level 1");
+console.group("Level 2");
+console.group("Level 3");
+console.log("Deep inside");
+console.groupEnd();
+console.groupEnd();
+console.groupEnd();
+
+// Empty groups
+console.group();
+console.groupEnd();
+
+// Undefined groups
+console.group(undefined);
+console.groupEnd();
+
+console.group("Empty nested");
+console.group();
+console.groupEnd();
+console.groupEnd();
+
+// Extra groupEnd calls should be ignored
+console.group("Test extra end");
+console.log("Inside");
+console.groupEnd();
+console.groupEnd(); // Extra
+console.groupEnd(); // Extra
+
+// Group with different log types
+console.group("Different logs");
+console.log("Regular log");
+console.info("Info log");
+console.warn("Warning log");
+console.error("Error log");
+console.debug("Debug log");
+console.groupEnd();
+
+// Groups with objects/arrays
+console.group("Complex types");
+console.log({ a: 1, b: 2 });
+console.log([1, 2, 3]);
+console.groupEnd();
+
+// Falsy values as group labels
+console.group(null);
+console.group(undefined);
+console.group(0);
+console.group(false);
+console.group("");
+console.log("Inside falsy groups");
+console.groupEnd();
+console.groupEnd();
+console.groupEnd();
+console.groupEnd();
+console.groupEnd();
+
+// Unicode and special characters
+console.group("🎉 Unicode!");
+console.log("Inside unicode group");
+console.group('Tab\tNewline\nQuote"Backslash');
+console.log("Special chars");
+console.groupEnd();
+console.groupEnd();
diff --git a/test/js/web/console/console-log.test.ts b/test/js/web/console/console-log.test.ts
index d3d322de3d..64e94a2069 100644
--- a/test/js/web/console/console-log.test.ts
+++ b/test/js/web/console/console-log.test.ts
@@ -56,3 +56,14 @@ it("long arrays get cutoff", () => {
       "",
   );
 });
+
+it("console.group", async () => {
+  const proc = Bun.spawnSync({
+    cmd: [bunExe(), join(import.meta.dir, "console-group.fixture.js")],
+    env: bunEnv,
+    stdio: ["inherit", "pipe", "pipe"],
+  });
+  expect(proc.exitCode).toBe(0);
+  expect(proc.stderr.toString("utf8").replaceAll("\r\n", "\n").trim()).toMatchSnapshot("console-group-error");
+  expect(proc.stdout.toString("utf8").replaceAll("\r\n", "\n").trim()).toMatchSnapshot("console-group-output");
+});
diff --git a/test/js/web/encoding/text-encoder.test.js b/test/js/web/encoding/text-encoder.test.js
index 0eb1a001fe..af7aff0efe 100644
--- a/test/js/web/encoding/text-encoder.test.js
+++ b/test/js/web/encoding/text-encoder.test.js
@@ -23,6 +23,12 @@ it("not enough space for replacement character", () => {
 });
 
 describe("TextEncoder", () => {
+  it("should handle undefined", () => {
+    const encoder = new TextEncoder();
+    expect(encoder.encode(undefined).length).toBe(0);
+    expect(encoder.encode(null).length).toBe(4);
+    expect(encoder.encode("").length).toBe(0);
+  });
   it("should encode latin1 text with non-ascii latin1 characters", () => {
     var text = "H©ell©o Wor©ld!";
 
diff --git a/test/js/web/fetch/fetch-keepalive.test.ts b/test/js/web/fetch/fetch-keepalive.test.ts
new file mode 100644
index 0000000000..c0f2c5ebae
--- /dev/null
+++ b/test/js/web/fetch/fetch-keepalive.test.ts
@@ -0,0 +1,36 @@
+import { test, expect } from "bun:test";
+
+test("keepalive", async () => {
+  using server = Bun.serve({
+    port: 0,
+    async fetch(req) {
+      return new Response(JSON.stringify(req.headers.toJSON()));
+    },
+  });
+  {
+    const res = await fetch(`http://localhost:${server.port}`, {
+      keepalive: false,
+    });
+    const headers = await res.json();
+    expect(headers.connection).toBeUndefined();
+  }
+
+  {
+    const res = await fetch(`http://localhost:${server.port}`, {
+      keepalive: true,
+    });
+    const headers = await res.json();
+    expect(headers.connection).toBe("keep-alive");
+  }
+
+  {
+    const res = await fetch(`http://localhost:${server.port}`, {
+      keepalive: false,
+      headers: {
+        "Connection": "HELLO!",
+      },
+    });
+    const headers = await res.json();
+    expect(headers.connection).toBe("HELLO!");
+  }
+});
diff --git a/test/js/web/fetch/fetch-leak-test-fixture-5.js b/test/js/web/fetch/fetch-leak-test-fixture-5.js
index 88d0b7c1df..afcdb6e31b 100644
--- a/test/js/web/fetch/fetch-leak-test-fixture-5.js
+++ b/test/js/web/fetch/fetch-leak-test-fixture-5.js
@@ -66,6 +66,20 @@ function getBody() {
     case "urlsearchparams":
       body = getURLSearchParams();
       break;
+    case "iterator":
+      body = async function* iter() {
+        yield (cachedBody ??= getString());
+      };
+      break;
+    case "stream":
+      body = new ReadableStream({
+        async pull(c) {
+          await Bun.sleep(10);
+          c.enqueue((cachedBody ??= getBuffer()));
+          c.close();
+        },
+      });
+      break;
     default:
       throw new Error(`Invalid type: ${type}`);
   }
@@ -85,7 +99,8 @@ try {
 
     {
       Bun.gc(true);
-      await Bun.sleep(10);
+      await Bun.sleep(100);
+      Bun.gc(true);
       const stats = getHeapStats();
       expect(stats.Response || 0).toBeLessThanOrEqual(threshold);
       expect(stats.Promise || 0).toBeLessThanOrEqual(threshold);
diff --git a/test/js/web/fetch/fetch-leak.test.ts b/test/js/web/fetch/fetch-leak.test.ts
index 04b68de276..bf90582a79 100644
--- a/test/js/web/fetch/fetch-leak.test.ts
+++ b/test/js/web/fetch/fetch-leak.test.ts
@@ -99,7 +99,7 @@ describe("fetch doesn't leak", () => {
   }
 });
 
-describe.each(["FormData", "Blob", "Buffer", "String", "URLSearchParams"])("Sending %s", type => {
+describe.each(["FormData", "Blob", "Buffer", "String", "URLSearchParams", "stream", "iterator"])("Sending %s", type => {
   test(
     "does not leak",
     async () => {
diff --git a/test/js/web/fetch/fetch-tcp-stress.test.ts b/test/js/web/fetch/fetch-tcp-stress.test.ts
index 0188b9e4cc..9d8c7a2352 100644
--- a/test/js/web/fetch/fetch-tcp-stress.test.ts
+++ b/test/js/web/fetch/fetch-tcp-stress.test.ts
@@ -2,7 +2,7 @@
 // These tests fail by timing out.
 
 import { expect, test } from "bun:test";
-import { getMaxFD, isMacOS } from "harness";
+import { getMaxFD, isCI, isMacOS } from "harness";
 
 // Since we bumped MAX_CONNECTIONS to 4, we should halve the threshold on macOS.
 const PORT_EXHAUSTION_THRESHOLD = isMacOS ? 8 * 1024 : 16 * 1024;
@@ -101,7 +101,7 @@ async function runStressTest({
   expect(getMaxFD()).toBeLessThan(initialMaxFD + 10);
 }
 
-test(
+test.todoIf(isCI && isMacOS)(
   "shutdown after timeout",
   async () => {
     await runStressTest({
@@ -114,7 +114,7 @@ test(
   30 * 1000,
 );
 
-test(
+test.todoIf(isCI && isMacOS)(
   "close after TCP fin",
   async () => {
     await runStressTest({
@@ -129,7 +129,7 @@ test(
   30 * 1000,
 );
 
-test(
+test.todoIf(isCI && isMacOS)(
   "shutdown then terminate",
   async () => {
     await runStressTest({
@@ -144,7 +144,7 @@ test(
   30 * 1000,
 );
 
-test(
+test.todoIf(isCI && isMacOS)(
   "gently close",
   async () => {
     await runStressTest({
diff --git a/test/js/web/fetch/fetch.brotli.test.ts b/test/js/web/fetch/fetch.brotli.test.ts
index b5773ef676..23cfdf6d2b 100644
--- a/test/js/web/fetch/fetch.brotli.test.ts
+++ b/test/js/web/fetch/fetch.brotli.test.ts
@@ -1,18 +1,48 @@
 import { expect, test } from "bun:test";
 
+import brotliFile from "./fetch.brotli.test.ts.br" with { type: "file" };
+import gzipFile from "./fetch.brotli.test.ts.gzip" with { type: "file" };
+
 test("fetch brotli response works", async () => {
+  const brotli = await Bun.file(brotliFile).arrayBuffer();
+  const gzip = await Bun.file(gzipFile).arrayBuffer();
+
+  using server = Bun.serve({
+    port: 0,
+    fetch(req) {
+      if (req.headers.get("Accept-Encoding") === "br") {
+        return new Response(brotli, {
+          headers: {
+            "Content-Encoding": "br",
+          },
+        });
+      }
+
+      if (req.headers.get("Accept-Encoding") === "gzip") {
+        return new Response(gzip, {
+          headers: {
+            "Content-Encoding": "gzip",
+          },
+        });
+      }
+
+      return new Response("bad!", {
+        status: 400,
+      });
+    },
+  });
   const [firstText, secondText, { headers }] = await Promise.all([
-    fetch("https://bun.sh/logo.svg", {
+    fetch(`${server.url}/logo.svg`, {
       headers: {
         "Accept-Encoding": "br",
       },
     }).then(res => res.text()),
-    fetch("https://bun.sh/logo.svg", {
+    fetch(`${server.url}/logo.svg`, {
       headers: {
         "Accept-Encoding": "gzip",
       },
     }).then(res => res.text()),
-    fetch("https://bun.sh/logo.svg", {
+    fetch(`${server.url}/logo.svg`, {
       headers: {
         "Accept-Encoding": "br",
       },
diff --git a/test/js/web/fetch/fetch.brotli.test.ts.br b/test/js/web/fetch/fetch.brotli.test.ts.br
new file mode 100644
index 0000000000..492d84d9e0
Binary files /dev/null and b/test/js/web/fetch/fetch.brotli.test.ts.br differ
diff --git a/test/js/web/fetch/fetch.brotli.test.ts.gzip b/test/js/web/fetch/fetch.brotli.test.ts.gzip
new file mode 100644
index 0000000000..c326a57a90
Binary files /dev/null and b/test/js/web/fetch/fetch.brotli.test.ts.gzip differ
diff --git a/test/js/web/fetch/fetch.test.ts b/test/js/web/fetch/fetch.test.ts
index 37818cd03c..47099852e8 100644
--- a/test/js/web/fetch/fetch.test.ts
+++ b/test/js/web/fetch/fetch.test.ts
@@ -6,7 +6,7 @@ import { mkfifo } from "mkfifo";
 import net from "net";
 import { join } from "path";
 import { gzipSync } from "zlib";
-
+import { Readable } from "stream";
 const tmp_dir = tmpdirSync();
 
 const fixture = readFileSync(join(import.meta.dir, "fetch.js.txt"), "utf8").replaceAll("\r\n", "\n");
@@ -2074,3 +2074,188 @@ describe("fetch Response life cycle", () => {
     }
   });
 });
+
+describe("fetch should allow duplex", () => {
+  it("should allow duplex streaming", async () => {
+    using server = Bun.serve({
+      port: 0,
+      async fetch(req) {
+        return new Response(req.body);
+      },
+    });
+    const intervalStream = new ReadableStream({
+      start(c) {
+        let count = 0;
+        const timer = setInterval(() => {
+          c.enqueue("Hello\n");
+          if (count === 5) {
+            clearInterval(timer);
+            c.close();
+          }
+          count++;
+        }, 20);
+      },
+    }).pipeThrough(new TextEncoderStream());
+
+    const resp = await fetch(server.url, {
+      method: "POST",
+      body: intervalStream,
+      duplex: "half",
+    });
+
+    const reader = resp.body.pipeThrough(new TextDecoderStream()).getReader();
+    var result = "";
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      result += value;
+    }
+    expect(result).toBe("Hello\n".repeat(6));
+  });
+
+  it("should allow duplex extending Readable (sync)", async () => {
+    class HelloWorldStream extends Readable {
+      constructor(options) {
+        super(options);
+        this.chunks = ["Hello", " ", "World!"];
+        this.index = 0;
+      }
+
+      _read(size) {
+        if (this.index < this.chunks.length) {
+          this.push(this.chunks[this.index]);
+          this.index++;
+        } else {
+          this.push(null);
+        }
+      }
+    }
+
+    using server = Bun.serve({
+      port: 0,
+      async fetch(req) {
+        return new Response(req.body);
+      },
+    });
+    const response = await fetch(server.url, {
+      body: new HelloWorldStream(),
+      method: "POST",
+      duplex: "half",
+    });
+
+    expect(await response.text()).toBe("Hello World!");
+  });
+  it("should allow duplex extending Readable (async)", async () => {
+    class HelloWorldStream extends Readable {
+      constructor(options) {
+        super(options);
+        this.chunks = ["Hello", " ", "World!"];
+        this.index = 0;
+      }
+
+      _read(size) {
+        setTimeout(() => {
+          if (this.index < this.chunks.length) {
+            this.push(this.chunks[this.index]);
+            this.index++;
+          } else {
+            this.push(null);
+          }
+        }, 20);
+      }
+    }
+
+    using server = Bun.serve({
+      port: 0,
+      async fetch(req) {
+        return new Response(req.body);
+      },
+    });
+    const response = await fetch(server.url, {
+      body: new HelloWorldStream(),
+      method: "POST",
+      duplex: "half",
+    });
+
+    expect(await response.text()).toBe("Hello World!");
+  });
+
+  it("should allow duplex using async iterator (async)", async () => {
+    using server = Bun.serve({
+      port: 0,
+      async fetch(req) {
+        return new Response(req.body);
+      },
+    });
+    const response = await fetch(server.url, {
+      body: async function* iter() {
+        yield "Hello";
+        await Bun.sleep(20);
+        yield " ";
+        await Bun.sleep(20);
+        yield "World!";
+      },
+      method: "POST",
+      duplex: "half",
+    });
+
+    expect(await response.text()).toBe("Hello World!");
+  });
+
+  it("should fail in redirects .follow when using duplex", async () => {
+    using server = Bun.serve({
+      port: 0,
+      async fetch(req) {
+        if (req.url.indexOf("/redirect") === -1) {
+          return Response.redirect("/");
+        }
+        return new Response(req.body);
+      },
+    });
+
+    expect(async () => {
+      const response = await fetch(server.url, {
+        body: async function* iter() {
+          yield "Hello";
+          await Bun.sleep(20);
+          yield " ";
+          await Bun.sleep(20);
+          yield "World!";
+        },
+        method: "POST",
+        duplex: "half",
+      });
+
+      await response.text();
+    }).toThrow();
+  });
+
+  it("should work in redirects .manual when using duplex", async () => {
+    using server = Bun.serve({
+      port: 0,
+      async fetch(req) {
+        if (req.url.indexOf("/redirect") === -1) {
+          return Response.redirect("/");
+        }
+        return new Response(req.body);
+      },
+    });
+
+    expect(async () => {
+      const response = await fetch(server.url, {
+        body: async function* iter() {
+          yield "Hello";
+          await Bun.sleep(20);
+          yield " ";
+          await Bun.sleep(20);
+          yield "World!";
+        },
+        method: "POST",
+        duplex: "half",
+        redirect: "manual",
+      });
+
+      await response.text();
+    }).not.toThrow();
+  });
+});
diff --git a/test/js/web/html/FormData.test.ts b/test/js/web/html/FormData.test.ts
index 6adaee48b0..83f35cb1b4 100644
--- a/test/js/web/html/FormData.test.ts
+++ b/test/js/web/html/FormData.test.ts
@@ -620,4 +620,29 @@ describe("FormData", () => {
       expect(fileSlice.size).toBe(result.size);
     });
   });
+
+  // The minimum repro for this was to not call the .name and .type getter on the Blob
+  // But the crux of the issue is that we called dupe() on the Blob, without also incrementing the reference count of the name string.
+  // https://github.com/oven-sh/bun/issues/14918
+  it("should increment reference count of the name string on Blob", async () => {
+    const buffer = new File([Buffer.from(Buffer.alloc(48 * 1024, "abcdefh").toString("base64"), "base64")], "ok.jpg");
+    function test() {
+      let file = new File([buffer], "ok.jpg");
+      file.name;
+      file.type;
+
+      let formData = new FormData();
+      formData.append("foo", file);
+      formData.get("foo");
+      formData.get("foo")!.name;
+      formData.get("foo")!.type;
+      return formData;
+    }
+    for (let i = 0; i < 100000; i++) {
+      test();
+      if (i % 5000 === 0) {
+        Bun.gc();
+      }
+    }
+  });
 });
diff --git a/test/js/web/streams/streams.test.js b/test/js/web/streams/streams.test.js
index 6b8a3942d8..1caa6eb7ae 100644
--- a/test/js/web/streams/streams.test.js
+++ b/test/js/web/streams/streams.test.js
@@ -7,13 +7,11 @@ import {
   readableStreamToText,
 } from "bun";
 import { describe, expect, it, test } from "bun:test";
-import { tmpdirSync } from "harness";
+import { tmpdirSync, isWindows, isMacOS } from "harness";
 import { mkfifo } from "mkfifo";
 import { createReadStream, realpathSync, unlinkSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
-const isWindows = process.platform === "win32";
-
 it("TransformStream", async () => {
   // https://developer.mozilla.org/en-US/docs/Web/API/TransformStream
   const TextEncoderStreamInterface = {
@@ -427,7 +425,7 @@ it("ReadableStream.prototype.values", async () => {
   expect(chunks.join("")).toBe("helloworld");
 });
 
-it.skipIf(isWindows)("Bun.file() read text from pipe", async () => {
+it.todoIf(isWindows || isMacOS)("Bun.file() read text from pipe", async () => {
   const fifoPath = join(tmpdirSync(), "bun-streams-test-fifo");
   try {
     unlinkSync(fifoPath);
@@ -758,6 +756,55 @@ it("ReadableStream for empty file closes immediately", async () => {
   expect(chunks.length).toBe(0);
 });
 
+it("ReadableStream errors the stream on pull rejection", async () => {
+  let stream = new ReadableStream({
+    pull(controller) {
+      return Promise.reject("pull rejected");
+    },
+  });
+
+  let reader = stream.getReader();
+  let closed = reader.closed.catch(err => `closed: ${err}`);
+  let read = reader.read().catch(err => `read: ${err}`);
+  expect(await Promise.race([closed, read])).toBe("closed: pull rejected");
+  expect(await read).toBe("read: pull rejected");
+});
+
+it("ReadableStream rejects pending reads when the lock is released", async () => {
+  let { resolve, promise } = Promise.withResolvers();
+  let stream = new ReadableStream({
+    async pull(controller) {
+      controller.enqueue("123");
+      await promise;
+      controller.enqueue("456");
+      controller.close();
+    },
+  });
+
+  let reader = stream.getReader();
+  expect((await reader.read()).value).toBe("123");
+
+  let read = reader.read();
+  reader.releaseLock();
+  expect(read).rejects.toThrow(
+    expect.objectContaining({
+      name: "AbortError",
+      code: "ERR_STREAM_RELEASE_LOCK",
+    }),
+  );
+  expect(reader.closed).rejects.toThrow(
+    expect.objectContaining({
+      name: "AbortError",
+      code: "ERR_STREAM_RELEASE_LOCK",
+    }),
+  );
+
+  resolve();
+
+  reader = stream.getReader();
+  expect((await reader.read()).value).toBe("456");
+});
+
 it("new Response(stream).arrayBuffer() (bytes)", async () => {
   var queue = [Buffer.from("abdefgh")];
   var stream = new ReadableStream({
@@ -1055,3 +1102,42 @@ it("fs.createReadStream(filename) should be able to break inside async loop", as
     expect(true).toBe(true);
   }
 });
+
+it("pipeTo doesn't cause unhandled rejections on readable errors", async () => {
+  // https://github.com/WebKit/WebKit/blob/3a75b5d2de94aa396a99b454ac47f3be9e0dc726/LayoutTests/streams/pipeTo-unhandled-promise.html
+  let unhandledRejectionCaught = false;
+
+  const catchUnhandledRejection = () => {
+    unhandledRejectionCaught = true;
+  };
+  process.on("unhandledRejection", catchUnhandledRejection);
+
+  const writable = new WritableStream();
+  const readable = new ReadableStream({ start: c => c.error("error") });
+  readable.pipeTo(writable).catch(() => {});
+
+  await Bun.sleep(15);
+
+  process.off("unhandledRejection", catchUnhandledRejection);
+
+  expect(unhandledRejectionCaught).toBe(false);
+});
+
+it("pipeThrough doesn't cause unhandled rejections on readable errors", async () => {
+  let unhandledRejectionCaught = false;
+
+  const catchUnhandledRejection = () => {
+    unhandledRejectionCaught = true;
+  };
+  process.on("unhandledRejection", catchUnhandledRejection);
+
+  const readable = new ReadableStream({ start: c => c.error("error") });
+  const ts = new TransformStream();
+  readable.pipeThrough(ts);
+
+  await Bun.sleep(15);
+
+  process.off("unhandledRejection", catchUnhandledRejection);
+
+  expect(unhandledRejectionCaught).toBe(false);
+});
diff --git a/test/js/web/timers/performance.test.js b/test/js/web/timers/performance.test.js
index b5c10073df..b1c7b7bba8 100644
--- a/test/js/web/timers/performance.test.js
+++ b/test/js/web/timers/performance.test.js
@@ -1,6 +1,19 @@
 import { expect, it } from "bun:test";
 import { isWindows } from "harness";
 
+it("performance.clearResourceTimings()", () => {
+  performance.clearResourceTimings();
+});
+
+it("performance.setResourceTimingBufferSize()", () => {
+  performance.setResourceTimingBufferSize(10);
+});
+
+it("performance.onresourcetimingbufferfull", () => {
+  performance.onresourcetimingbufferfull = () => {};
+  performance.onresourcetimingbufferfull();
+});
+
 it("performance.now() should be monotonic", () => {
   const first = performance.now();
   const second = performance.now();
diff --git a/test/js/web/web-globals.test.js b/test/js/web/web-globals.test.js
index 6cc96812e2..f7a10a2bb8 100644
--- a/test/js/web/web-globals.test.js
+++ b/test/js/web/web-globals.test.js
@@ -27,6 +27,9 @@ test("exists", () => {
   expect(typeof PerformanceMeasure !== "undefined").toBe(true);
   expect(typeof PerformanceObserver !== "undefined").toBe(true);
   expect(typeof PerformanceObserverEntryList !== "undefined").toBe(true);
+  expect(typeof PerformanceResourceTiming !== "undefined").toBe(true);
+  expect(typeof PerformanceServerTiming !== "undefined").toBe(true);
+  expect(typeof PerformanceTiming !== "undefined").toBe(true);
 });
 
 const globalSetters = [
diff --git a/test/js/web/websocket/websocket.test.js b/test/js/web/websocket/websocket.test.js
index 97b9308bc8..e1736b1199 100644
--- a/test/js/web/websocket/websocket.test.js
+++ b/test/js/web/websocket/websocket.test.js
@@ -6,7 +6,6 @@ import { createServer } from "net";
 import { join } from "path";
 import process from "process";
 const TEST_WEBSOCKET_HOST = process.env.TEST_WEBSOCKET_HOST || "wss://ws.postman-echo.com/raw";
-const isWindows = process.platform === "win32";
 const COMMON_CERT = { ...tls };
 
 describe("WebSocket", () => {
diff --git a/test/js/web/workers/worker-fixture-preload-2.js b/test/js/web/workers/worker-fixture-preload-2.js
new file mode 100644
index 0000000000..4f549ea2a0
--- /dev/null
+++ b/test/js/web/workers/worker-fixture-preload-2.js
@@ -0,0 +1 @@
+globalThis.preload += " world";
diff --git a/test/js/web/workers/worker-fixture-preload-bad.js b/test/js/web/workers/worker-fixture-preload-bad.js
new file mode 100644
index 0000000000..812a56eebe
--- /dev/null
+++ b/test/js/web/workers/worker-fixture-preload-bad.js
@@ -0,0 +1,3 @@
+throw new Error(
+  "this is an error and this particular string doesnt appear in the source code so we know for sure it sent the actual message and not just a dump of the source code as it originally was.".toUpperCase(),
+);
diff --git a/test/js/web/workers/worker-fixture-preload-entry.js b/test/js/web/workers/worker-fixture-preload-entry.js
new file mode 100644
index 0000000000..dda5de8eda
--- /dev/null
+++ b/test/js/web/workers/worker-fixture-preload-entry.js
@@ -0,0 +1 @@
+self.postMessage(preload + " world");
diff --git a/test/js/web/workers/worker-fixture-preload.js b/test/js/web/workers/worker-fixture-preload.js
new file mode 100644
index 0000000000..c2fd929546
--- /dev/null
+++ b/test/js/web/workers/worker-fixture-preload.js
@@ -0,0 +1 @@
+globalThis.preload = "hello";
diff --git a/test/js/web/workers/worker.test.ts b/test/js/web/workers/worker.test.ts
index 4e038fde35..219406c6ee 100644
--- a/test/js/web/workers/worker.test.ts
+++ b/test/js/web/workers/worker.test.ts
@@ -17,6 +17,59 @@ describe("web worker", () => {
     }
   }
 
+  describe("preload", () => {
+    test("invalid file URL", async () => {
+      expect(() => new Worker("file://:!:!:!!!!", {})).toThrow(/Invalid file URL/);
+      expect(
+        () =>
+          new Worker(import.meta.url, {
+            preload: ["file://:!:!:!!!!", "file://:!:!:!!!!2"],
+          }),
+      ).toThrow(/Invalid file URL/);
+    });
+
+    test("string", async () => {
+      const worker = new Worker(new URL("worker-fixture-preload-entry.js", import.meta.url).href, {
+        preload: new URL("worker-fixture-preload.js", import.meta.url).href,
+      });
+      const result = await waitForWorkerResult(worker, "hello world");
+      expect(result).toEqual("hello world");
+    });
+
+    test("array of 2 strings", async () => {
+      const worker = new Worker(new URL("worker-fixture-preload-entry.js", import.meta.url).href, {
+        preload: [
+          new URL("worker-fixture-preload.js", import.meta.url).href,
+          new URL("worker-fixture-preload-2.js", import.meta.url).href,
+        ],
+      });
+      const result = await waitForWorkerResult(worker, "hello world world");
+      expect(result).toEqual("hello world world");
+    });
+
+    test("array of string", async () => {
+      const worker = new Worker(new URL("worker-fixture-preload-entry.js", import.meta.url).href, {
+        preload: [new URL("worker-fixture-preload.js", import.meta.url).href],
+      });
+      const result = await waitForWorkerResult(worker, "hello world");
+      expect(result).toEqual("hello world");
+    });
+
+    test("error in preload doesn't crash parent", async () => {
+      const worker = new Worker(new URL("worker-fixture-preload-entry.js", import.meta.url).href, {
+        preload: [new URL("worker-fixture-preload-bad.js", import.meta.url).href],
+      });
+      const { resolve, promise } = Promise.withResolvers();
+      worker.onerror = e => {
+        resolve(e.message);
+      };
+      const result = await promise;
+      expect(result).toMatch(
+        /THIS IS AN ERROR AND THIS PARTICULAR STRING DOESNT APPEAR IN THE SOURCE CODE SO WE KNOW FOR SURE IT SENT THE ACTUAL MESSAGE AND NOT JUST A DUMP OF THE SOURCE CODE AS IT ORIGINALLY WAS/,
+      );
+    });
+  });
+
   test("worker", done => {
     const worker = new Worker(new URL("worker-fixture.js", import.meta.url).href, {
       smol: true,
diff --git a/test/mkfifo.ts b/test/mkfifo.ts
index 1fd0457239..18956e845c 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/napi/napi-app/main.cpp b/test/napi/napi-app/main.cpp
index bf197d08f8..df4cfacbb3 100644
--- a/test/napi/napi-app/main.cpp
+++ b/test/napi/napi-app/main.cpp
@@ -4,11 +4,16 @@
 
 #include <array>
 #include <cassert>
+#include <cmath>
 #include <cstdarg>
 #include <cstdint>
 #include <cstdio>
 #include <iostream>
+#include <limits>
+#include <map>
+#include <string>
 #include <thread>
+#include <utility>
 
 napi_value fail(napi_env env, const char *msg) {
   napi_value result;
@@ -35,6 +40,13 @@ static void run_gc(const Napi::CallbackInfo &info) {
   info[0].As<Napi::Function>().Call(0, nullptr);
 }
 
+// calls napi_typeof and asserts it returns napi_ok
+static napi_valuetype get_typeof(napi_env env, napi_value value) {
+  napi_valuetype result;
+  assert(napi_typeof(env, value, &result) == napi_ok);
+  return result;
+}
+
 napi_value test_issue_7685(const Napi::CallbackInfo &info) {
   Napi::Env env(info.Env());
   Napi::HandleScope scope(env);
@@ -229,8 +241,7 @@ napi_value test_napi_delete_property(const Napi::CallbackInfo &info) {
 
   // info[0] is a function to run the GC
   napi_value object = info[1];
-  napi_valuetype type;
-  assert(napi_typeof(env, object, &type) == napi_ok);
+  napi_valuetype type = get_typeof(env, object);
   assert(type == napi_object);
 
   napi_value key;
@@ -374,8 +385,10 @@ struct AsyncWorkData {
   int result;
   napi_deferred deferred;
   napi_async_work work;
+  bool do_throw;
 
-  AsyncWorkData() : result(0), deferred(nullptr), work(nullptr) {}
+  AsyncWorkData()
+      : result(0), deferred(nullptr), work(nullptr), do_throw(false) {}
 
   static void execute(napi_env env, void *data) {
     AsyncWorkData *async_work_data = reinterpret_cast<AsyncWorkData *>(data);
@@ -386,21 +399,43 @@ struct AsyncWorkData {
     AsyncWorkData *async_work_data = reinterpret_cast<AsyncWorkData *>(data);
     assert(status == napi_ok);
 
-    napi_value result;
-    char buf[64] = {0};
-    snprintf(buf, sizeof(buf), "the number is %d", async_work_data->result);
-    assert(napi_create_string_utf8(env, buf, NAPI_AUTO_LENGTH, &result) ==
-           napi_ok);
-    assert(napi_resolve_deferred(env, async_work_data->deferred, result) ==
-           napi_ok);
+    if (async_work_data->do_throw) {
+      // still have to resolve/reject otherwise the process times out
+      // we should not see the resolution as our unhandled exception handler
+      // exits the process before that can happen
+      napi_value result;
+      assert(napi_get_undefined(env, &result) == napi_ok);
+      assert(napi_resolve_deferred(env, async_work_data->deferred, result) ==
+             napi_ok);
+
+      napi_value err;
+      napi_value msg;
+      assert(napi_create_string_utf8(env, "error from napi", NAPI_AUTO_LENGTH,
+                                     &msg) == napi_ok);
+      assert(napi_create_error(env, nullptr, msg, &err) == napi_ok);
+      assert(napi_throw(env, err) == napi_ok);
+    } else {
+      napi_value result;
+      char buf[64] = {0};
+      snprintf(buf, sizeof(buf), "the number is %d", async_work_data->result);
+      assert(napi_create_string_utf8(env, buf, NAPI_AUTO_LENGTH, &result) ==
+             napi_ok);
+      assert(napi_resolve_deferred(env, async_work_data->deferred, result) ==
+             napi_ok);
+    }
+
     assert(napi_delete_async_work(env, async_work_data->work) == napi_ok);
     delete async_work_data;
   }
 };
 
+// create_promise(void *unused_run_gc_callback, bool do_throw): makes a promise
+// using napi_Async_work that either resolves or throws in the complete callback
 napi_value create_promise(const Napi::CallbackInfo &info) {
   napi_env env = info.Env();
   auto *data = new AsyncWorkData();
+  // info[0] is a callback to run the GC
+  assert(napi_get_value_bool(env, info[1], &data->do_throw) == napi_ok);
 
   napi_value promise;
 
@@ -452,12 +487,18 @@ struct ThreadsafeFunctionData {
 
     // call our JS function with undefined for this and no arguments
     napi_value js_result;
-    assert(napi_call_function(env, recv, js_callback, 0, nullptr, &js_result) ==
-           napi_ok);
+    napi_status call_result =
+        napi_call_function(env, recv, js_callback, 0, nullptr, &js_result);
+    // assert(call_result == napi_ok || call_result == napi_pending_exception);
 
-    // resolve the promise with the return value of the JS function
-    assert(napi_resolve_deferred(env, tsfn_data->deferred, js_result) ==
-           napi_ok);
+    if (call_result == napi_ok) {
+      // only resolve if js_callback did not return an error
+      // resolve the promise with the return value of the JS function
+      napi_status defer_result =
+          napi_resolve_deferred(env, tsfn_data->deferred, js_result);
+      printf("%d\n", defer_result);
+      assert(defer_result == napi_ok);
+    }
 
     // clean up the threadsafe function
     assert(napi_release_threadsafe_function(tsfn_data->tsfn, napi_tsfn_abort) ==
@@ -510,8 +551,7 @@ napi_value test_napi_ref(const Napi::CallbackInfo &info) {
   napi_value from_ref;
   assert(napi_get_reference_value(env, ref, &from_ref) == napi_ok);
   assert(from_ref != nullptr);
-  napi_valuetype typeof_result;
-  assert(napi_typeof(env, from_ref, &typeof_result) == napi_ok);
+  napi_valuetype typeof_result = get_typeof(env, from_ref);
   assert(typeof_result == napi_object);
   return ok(env);
 }
@@ -555,6 +595,424 @@ napi_value was_finalize_called(const Napi::CallbackInfo &info) {
   return ret;
 }
 
+static const char *napi_valuetype_to_string(napi_valuetype type) {
+  switch (type) {
+  case napi_undefined:
+    return "undefined";
+  case napi_null:
+    return "null";
+  case napi_boolean:
+    return "boolean";
+  case napi_number:
+    return "number";
+  case napi_string:
+    return "string";
+  case napi_symbol:
+    return "symbol";
+  case napi_object:
+    return "object";
+  case napi_function:
+    return "function";
+  case napi_external:
+    return "external";
+  case napi_bigint:
+    return "bigint";
+  default:
+    return "unknown";
+  }
+}
+
+// calls a function (the sole argument) which must throw. catches and returns
+// the thrown error
+napi_value call_and_get_exception(const Napi::CallbackInfo &info) {
+  napi_env env = info.Env();
+  napi_value fn = info[0];
+  napi_value undefined;
+  assert(napi_get_undefined(env, &undefined) == napi_ok);
+
+  (void)napi_call_function(env, undefined, fn, 0, nullptr, nullptr);
+
+  bool is_pending;
+  assert(napi_is_exception_pending(env, &is_pending) == napi_ok);
+  assert(is_pending);
+
+  napi_value exception;
+  assert(napi_get_and_clear_last_exception(env, &exception) == napi_ok);
+
+  napi_valuetype type = get_typeof(env, exception);
+  printf("typeof thrown exception = %s\n", napi_valuetype_to_string(type));
+
+  assert(napi_is_exception_pending(env, &is_pending) == napi_ok);
+  assert(!is_pending);
+
+  return exception;
+}
+
+// throw_error(code: string|undefined, msg: string|undefined,
+// error_kind: 'error'|'type_error'|'range_error'|'syntax_error')
+// if code and msg are JS undefined then change them to nullptr
+napi_value throw_error(const Napi::CallbackInfo &info) {
+  napi_env env = info.Env();
+
+  napi_value js_code = info[0];
+  napi_value js_msg = info[1];
+  napi_value js_error_kind = info[2];
+  const char *code = nullptr;
+  const char *msg = nullptr;
+  char code_buf[256] = {0}, msg_buf[256] = {0}, error_kind_buf[256] = {0};
+
+  if (get_typeof(env, js_code) == napi_string) {
+    assert(napi_get_value_string_utf8(env, js_code, code_buf, sizeof code_buf,
+                                      nullptr) == napi_ok);
+    code = code_buf;
+  }
+  if (get_typeof(env, js_msg) == napi_string) {
+    assert(napi_get_value_string_utf8(env, js_msg, msg_buf, sizeof msg_buf,
+                                      nullptr) == napi_ok);
+    msg = msg_buf;
+  }
+  assert(napi_get_value_string_utf8(env, js_error_kind, error_kind_buf,
+                                    sizeof error_kind_buf, nullptr) == napi_ok);
+
+  std::map<std::string,
+           napi_status (*)(napi_env, const char *code, const char *msg)>
+      functions{{"error", napi_throw_error},
+                {"type_error", napi_throw_type_error},
+                {"range_error", napi_throw_range_error},
+                {"syntax_error", node_api_throw_syntax_error}};
+
+  auto throw_function = functions[error_kind_buf];
+
+  if (msg == nullptr) {
+    assert(throw_function(env, code, msg) == napi_invalid_arg);
+    return ok(env);
+  } else {
+    assert(throw_function(env, code, msg) == napi_ok);
+    return nullptr;
+  }
+}
+
+// create_and_throw_error(code: any, msg: any,
+// error_kind: 'error'|'type_error'|'range_error'|'syntax_error')
+// if code and msg are JS null then change them to nullptr
+napi_value create_and_throw_error(const Napi::CallbackInfo &info) {
+  napi_env env = info.Env();
+
+  napi_value js_code = info[0];
+  napi_value js_msg = info[1];
+  napi_value js_error_kind = info[2];
+  char error_kind_buf[256] = {0};
+
+  if (get_typeof(env, js_code) == napi_null) {
+    js_code = nullptr;
+  }
+  if (get_typeof(env, js_msg) == napi_null) {
+    js_msg = nullptr;
+  }
+
+  assert(napi_get_value_string_utf8(env, js_error_kind, error_kind_buf,
+                                    sizeof error_kind_buf, nullptr) == napi_ok);
+
+  std::map<std::string, napi_status (*)(napi_env, napi_value code,
+                                        napi_value msg, napi_value *)>
+      functions{{"error", napi_create_error},
+                {"type_error", napi_create_type_error},
+                {"range_error", napi_create_range_error},
+                {"syntax_error", node_api_create_syntax_error}};
+
+  auto create_error_function = functions[error_kind_buf];
+
+  napi_value err;
+  napi_status create_status = create_error_function(env, js_code, js_msg, &err);
+  // cases that should fail:
+  // - js_msg is nullptr
+  // - js_msg is not a string
+  // - js_code is not nullptr and not a string
+  // also we need to make sure not to call get_typeof with nullptr, since it
+  // asserts that napi_typeof succeeded
+  if (!js_msg || get_typeof(env, js_msg) != napi_string ||
+      (js_code && get_typeof(env, js_code) != napi_string)) {
+    // bun and node may return different errors here depending on in what order
+    // the parameters are checked, but what's important is that there is an
+    // error
+    assert(create_status == napi_string_expected ||
+           create_status == napi_invalid_arg);
+    return ok(env);
+  } else {
+    assert(create_status == napi_ok);
+    assert(napi_throw(env, err) == napi_ok);
+    return nullptr;
+  }
+}
+
+napi_value eval_wrapper(const Napi::CallbackInfo &info) {
+  napi_value ret = nullptr;
+  // info[0] is the GC callback
+  (void)napi_run_script(info.Env(), info[1], &ret);
+  return ret;
+}
+
+// perform_get(object, key)
+napi_value perform_get(const Napi::CallbackInfo &info) {
+  napi_env env = info.Env();
+  napi_value obj = info[0];
+  napi_value key = info[1];
+  napi_status status;
+  napi_value value;
+
+  // if key is a string, try napi_get_named_property
+  napi_valuetype type = get_typeof(env, key);
+  if (type == napi_string) {
+    char buf[1024];
+    assert(napi_get_value_string_utf8(env, key, buf, 1024, nullptr) == napi_ok);
+    status = napi_get_named_property(env, obj, buf, &value);
+    printf("get_named_property status is pending_exception or generic_failure "
+           "= %d\n",
+           status == napi_pending_exception || status == napi_generic_failure);
+    if (status == napi_ok) {
+      assert(value != nullptr);
+      printf("value type = %d\n", get_typeof(env, value));
+    } else {
+      return ok(env);
+    }
+  }
+
+  status = napi_get_property(env, obj, key, &value);
+  printf("get_property status is pending_exception or generic_failure  = %d\n",
+         status == napi_pending_exception || status == napi_generic_failure);
+  if (status == napi_ok) {
+    assert(value != nullptr);
+    printf("value type = %d\n", get_typeof(env, value));
+    return value;
+  } else {
+    return ok(env);
+  }
+}
+
+// double_to_i32(any): number|undefined
+napi_value double_to_i32(const Napi::CallbackInfo &info) {
+  napi_env env = info.Env();
+  napi_value input = info[0];
+
+  int32_t integer;
+  napi_value result;
+  napi_status status = napi_get_value_int32(env, input, &integer);
+  if (status == napi_ok) {
+    assert(napi_create_int32(env, integer, &result) == napi_ok);
+  } else {
+    assert(status == napi_number_expected);
+    assert(napi_get_undefined(env, &result) == napi_ok);
+  }
+  return result;
+}
+
+// double_to_u32(any): number|undefined
+napi_value double_to_u32(const Napi::CallbackInfo &info) {
+  napi_env env = info.Env();
+  napi_value input = info[0];
+
+  uint32_t integer;
+  napi_value result;
+  napi_status status = napi_get_value_uint32(env, input, &integer);
+  if (status == napi_ok) {
+    assert(napi_create_uint32(env, integer, &result) == napi_ok);
+  } else {
+    assert(status == napi_number_expected);
+    assert(napi_get_undefined(env, &result) == napi_ok);
+  }
+  return result;
+}
+
+// double_to_i64(any): number|undefined
+napi_value double_to_i64(const Napi::CallbackInfo &info) {
+  napi_env env = info.Env();
+  napi_value input = info[0];
+
+  int64_t integer;
+  napi_value result;
+  napi_status status = napi_get_value_int64(env, input, &integer);
+  if (status == napi_ok) {
+    assert(napi_create_int64(env, integer, &result) == napi_ok);
+  } else {
+    assert(status == napi_number_expected);
+    assert(napi_get_undefined(env, &result) == napi_ok);
+  }
+  return result;
+}
+
+// test from the C++ side
+napi_value test_number_integer_conversions(const Napi::CallbackInfo &info) {
+  napi_env env = info.Env();
+  using f64_limits = std::numeric_limits<double>;
+  using i32_limits = std::numeric_limits<int32_t>;
+  using u32_limits = std::numeric_limits<uint32_t>;
+  using i64_limits = std::numeric_limits<int64_t>;
+
+  std::array<std::pair<double, int32_t>, 14> i32_cases{{
+      // special values
+      {f64_limits::infinity(), 0},
+      {-f64_limits::infinity(), 0},
+      {f64_limits::quiet_NaN(), 0},
+      // normal
+      {0.0, 0},
+      {1.0, 1},
+      {-1.0, -1},
+      // truncation
+      {1.25, 1},
+      {-1.25, -1},
+      // limits
+      {i32_limits::min(), i32_limits::min()},
+      {i32_limits::max(), i32_limits::max()},
+      // wrap around
+      {static_cast<double>(i32_limits::min()) - 1.0, i32_limits::max()},
+      {static_cast<double>(i32_limits::max()) + 1.0, i32_limits::min()},
+      {static_cast<double>(i32_limits::min()) - 2.0, i32_limits::max() - 1},
+      {static_cast<double>(i32_limits::max()) + 2.0, i32_limits::min() + 1},
+  }};
+
+  for (const auto &[in, expected_out] : i32_cases) {
+    napi_value js_in;
+    assert(napi_create_double(env, in, &js_in) == napi_ok);
+    int32_t out_from_napi;
+    assert(napi_get_value_int32(env, js_in, &out_from_napi) == napi_ok);
+    assert(out_from_napi == expected_out);
+  }
+
+  std::array<std::pair<double, uint32_t>, 12> u32_cases{{
+      // special values
+      {f64_limits::infinity(), 0},
+      {-f64_limits::infinity(), 0},
+      {f64_limits::quiet_NaN(), 0},
+      // normal
+      {0.0, 0},
+      {1.0, 1},
+      // truncation
+      {1.25, 1},
+      {-1.25, u32_limits::max()},
+      // limits
+      {u32_limits::max(), u32_limits::max()},
+      // wrap around
+      {-1.0, u32_limits::max()},
+      {static_cast<double>(u32_limits::max()) + 1.0, 0},
+      {-2.0, u32_limits::max() - 1},
+      {static_cast<double>(u32_limits::max()) + 2.0, 1},
+
+  }};
+
+  for (const auto &[in, expected_out] : u32_cases) {
+    napi_value js_in;
+    assert(napi_create_double(env, in, &js_in) == napi_ok);
+    uint32_t out_from_napi;
+    assert(napi_get_value_uint32(env, js_in, &out_from_napi) == napi_ok);
+    assert(out_from_napi == expected_out);
+  }
+
+  std::array<std::pair<double, int64_t>, 12> i64_cases{
+      {// special values
+       {f64_limits::infinity(), 0},
+       {-f64_limits::infinity(), 0},
+       {f64_limits::quiet_NaN(), 0},
+       // normal
+       {0.0, 0},
+       {1.0, 1},
+       {-1.0, -1},
+       // truncation
+       {1.25, 1},
+       {-1.25, -1},
+       // limits
+       // i64 max can't be precisely represented as double so it would round to
+       // 1
+       // + i64 max, which would clamp and we don't want that yet. so we test
+       // the
+       // largest double smaller than i64 max instead (which is i64 max - 1024)
+       {i64_limits::min(), i64_limits::min()},
+       {std::nextafter(static_cast<double>(i64_limits::max()), 0.0),
+        static_cast<int64_t>(
+            std::nextafter(static_cast<double>(i64_limits::max()), 0.0))},
+       // clamp
+       {i64_limits::min() - 4096.0, i64_limits::min()},
+       {i64_limits::max() + 4096.0, i64_limits::max()}}};
+
+  for (const auto &[in, expected_out] : i64_cases) {
+    napi_value js_in;
+    assert(napi_create_double(env, in, &js_in) == napi_ok);
+    int64_t out_from_napi;
+    assert(napi_get_value_int64(env, js_in, &out_from_napi) == napi_ok);
+    assert(out_from_napi == expected_out);
+  }
+
+  return ok(env);
+}
+
+napi_value make_empty_array(const Napi::CallbackInfo &info) {
+  napi_env env = info.Env();
+  napi_value js_size = info[0];
+  uint32_t size;
+  assert(napi_get_value_uint32(env, js_size, &size) == napi_ok);
+  napi_value array;
+  assert(napi_create_array_with_length(env, size, &array) == napi_ok);
+  return array;
+}
+
+// add_tag(object, lower, upper)
+static napi_value add_tag(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+  napi_value object = info[0];
+
+  uint32_t lower, upper;
+  assert(napi_get_value_uint32(env, info[1], &lower) == napi_ok);
+  assert(napi_get_value_uint32(env, info[2], &upper) == napi_ok);
+  napi_type_tag tag = {.lower = lower, .upper = upper};
+
+  napi_status status = napi_type_tag_object(env, object, &tag);
+  if (status != napi_ok) {
+    char buf[1024];
+    snprintf(buf, sizeof buf, "status = %d", status);
+    napi_throw_error(env, nullptr, buf);
+  }
+  return env.Undefined();
+}
+
+// check_tag(object, lower, upper): bool
+static napi_value check_tag(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+  napi_value object = info[0];
+
+  uint32_t lower, upper;
+  assert(napi_get_value_uint32(env, info[1], &lower) == napi_ok);
+  assert(napi_get_value_uint32(env, info[2], &upper) == napi_ok);
+
+  napi_type_tag tag = {.lower = lower, .upper = upper};
+  bool matches;
+  assert(napi_check_object_type_tag(env, object, &tag, &matches) == napi_ok);
+  return Napi::Boolean::New(env, matches);
+}
+
+// try_add_tag(object, lower, upper): bool
+// true if success
+static napi_value try_add_tag(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+  napi_value object = info[0];
+
+  uint32_t lower, upper;
+  assert(napi_get_value_uint32(env, info[1], &lower) == napi_ok);
+  assert(napi_get_value_uint32(env, info[2], &upper) == napi_ok);
+
+  napi_type_tag tag = {.lower = lower, .upper = upper};
+
+  napi_status status = napi_type_tag_object(env, object, &tag);
+  bool pending;
+  assert(napi_is_exception_pending(env, &pending) == napi_ok);
+  if (pending) {
+    napi_value ignore_exception;
+    assert(napi_get_and_clear_last_exception(env, &ignore_exception) ==
+           napi_ok);
+    (void)ignore_exception;
+  }
+
+  return Napi::Boolean::New(env, status == napi_ok);
+}
+
 Napi::Value RunCallback(const Napi::CallbackInfo &info) {
   Napi::Env env = info.Env();
   // this function is invoked without the GC callback
@@ -605,6 +1063,22 @@ Napi::Object InitAll(Napi::Env env, Napi::Object exports1) {
               Napi::Function::New(env, create_ref_with_finalizer));
   exports.Set("was_finalize_called",
               Napi::Function::New(env, was_finalize_called));
+  exports.Set("call_and_get_exception",
+              Napi::Function::New(env, call_and_get_exception));
+  exports.Set("eval_wrapper", Napi::Function::New(env, eval_wrapper));
+  exports.Set("perform_get", Napi::Function::New(env, perform_get));
+  exports.Set("double_to_i32", Napi::Function::New(env, double_to_i32));
+  exports.Set("double_to_u32", Napi::Function::New(env, double_to_u32));
+  exports.Set("double_to_i64", Napi::Function::New(env, double_to_i64));
+  exports.Set("test_number_integer_conversions",
+              Napi::Function::New(env, test_number_integer_conversions));
+  exports.Set("make_empty_array", Napi::Function::New(env, make_empty_array));
+  exports.Set("throw_error", Napi::Function::New(env, throw_error));
+  exports.Set("create_and_throw_error",
+              Napi::Function::New(env, create_and_throw_error));
+  exports.Set("add_tag", Napi::Function::New(env, add_tag));
+  exports.Set("try_add_tag", Napi::Function::New(env, try_add_tag));
+  exports.Set("check_tag", Napi::Function::New(env, check_tag));
 
   return exports;
 }
diff --git a/test/napi/napi-app/main.js b/test/napi/napi-app/main.js
index 0f8aeffa86..d37ba09171 100644
--- a/test/napi/napi-app/main.js
+++ b/test/napi/napi-app/main.js
@@ -12,20 +12,40 @@ if (typeof fn !== "function") {
   throw new Error("Unknown test:", process.argv[2]);
 }
 
+process.on("uncaughtException", (error, _origin) => {
+  console.log("uncaught exception:", error.toString());
+  // 0 because one of the tests intentionally does this, and we don't want it to fail due to crashing
+  process.exit(0);
+});
+
 // pass GC runner as first argument
-const result = fn.apply(null, [
-  () => {
-    if (process.isBun) {
-      Bun.gc(true);
-    } else if (global.gc) {
-      global.gc();
-    }
-    console.log("GC did run");
-  },
-  ...eval(process.argv[3] ?? "[]"),
-]);
-if (result instanceof Promise) {
-  result.then(x => console.log("resolved to", x));
-} else if (result) {
-  throw new Error(result);
+try {
+  // napi.test.ts:147 tries to read this variable and shouldn't be able to
+  let shouldNotExist = 5;
+  const result = fn.apply(null, [
+    () => {
+      if (process.isBun) {
+        Bun.gc(true);
+      } else if (global.gc) {
+        global.gc();
+      }
+      console.log("GC did run");
+    },
+    ...eval(process.argv[3] ?? "[]"),
+  ]);
+  if (result instanceof Promise) {
+    result
+      .then(x => console.log("resolved to", x))
+      .catch(e => {
+        console.error("rejected:", e);
+      });
+    result.then(x => console.log("resolved to", x));
+  } else if (process.argv[2] == "eval_wrapper") {
+    // eval_wrapper just returns the result of the expression so it shouldn't be an error
+    console.log(result);
+  } else if (result) {
+    throw new Error(result);
+  }
+} catch (e) {
+  console.log(`synchronously threw ${e.name}: message ${JSON.stringify(e.message)}, code ${JSON.stringify(e.code)}`);
 }
diff --git a/test/napi/napi-app/module.js b/test/napi/napi-app/module.js
index d4295bcf76..6cb1280cf2 100644
--- a/test/napi/napi-app/module.js
+++ b/test/napi/napi-app/module.js
@@ -31,4 +31,243 @@ nativeTests.test_promise_with_threadsafe_function = async () => {
   return await nativeTests.create_promise_with_threadsafe_function(() => 1234);
 };
 
+nativeTests.test_get_exception = (_, value) => {
+  function thrower() {
+    throw value;
+  }
+  try {
+    const result = nativeTests.call_and_get_exception(thrower);
+    console.log("got same exception back?", result === value);
+  } catch (e) {
+    console.log("native module threw", typeof e, e);
+    throw e;
+  }
+};
+
+nativeTests.test_get_property = () => {
+  const objects = [
+    {},
+    { foo: "bar" },
+    {
+      get foo() {
+        throw new Error("get foo");
+      },
+    },
+    {
+      set foo(newValue) {},
+    },
+    new Proxy(
+      {},
+      {
+        get(_target, key) {
+          throw new Error(`proxy get ${key}`);
+        },
+      },
+    ),
+    5,
+    "hello",
+    // TODO(@190n) test null and undefined here on the napi fix branch
+  ];
+  const keys = [
+    "foo",
+    {
+      toString() {
+        throw new Error("toString");
+      },
+    },
+    {
+      [Symbol.toPrimitive]() {
+        throw new Error("Symbol.toPrimitive");
+      },
+    },
+    "toString",
+    "slice",
+  ];
+
+  for (const object of objects) {
+    for (const key of keys) {
+      try {
+        const ret = nativeTests.perform_get(object, key);
+        console.log("native function returned", ret);
+      } catch (e) {
+        console.log("threw", e.toString());
+      }
+    }
+  }
+};
+
+nativeTests.test_number_integer_conversions_from_js = () => {
+  const i32 = { min: -(2 ** 31), max: 2 ** 31 - 1 };
+  const u32Max = 2 ** 32 - 1;
+  // this is not the actual max value for i64, but rather the highest double that is below the true max value
+  const i64 = { min: -(2 ** 63), max: 2 ** 63 - 1024 };
+
+  const i32Cases = [
+    // special values
+    [Infinity, 0],
+    [-Infinity, 0],
+    [NaN, 0],
+    // normal
+    [0.0, 0],
+    [1.0, 1],
+    [-1.0, -1],
+    // truncation
+    [1.25, 1],
+    [-1.25, -1],
+    // limits
+    [i32.min, i32.min],
+    [i32.max, i32.max],
+    // wrap around
+    [i32.min - 1.0, i32.max],
+    [i32.max + 1.0, i32.min],
+    [i32.min - 2.0, i32.max - 1],
+    [i32.max + 2.0, i32.min + 1],
+    // type errors
+    ["5", undefined],
+    [new Number(5), undefined],
+  ];
+
+  for (const [input, expectedOutput] of i32Cases) {
+    const actualOutput = nativeTests.double_to_i32(input);
+    console.log(`${input} as i32 => ${actualOutput}`);
+    if (actualOutput !== expectedOutput) {
+      console.error("wrong");
+    }
+  }
+
+  const u32Cases = [
+    // special values
+    [Infinity, 0],
+    [-Infinity, 0],
+    [NaN, 0],
+    // normal
+    [0.0, 0],
+    [1.0, 1],
+    // truncation
+    [1.25, 1],
+    [-1.25, u32Max],
+    // limits
+    [u32Max, u32Max],
+    // wrap around
+    [-1.0, u32Max],
+    [u32Max + 1.0, 0],
+    [-2.0, u32Max - 1],
+    [u32Max + 2.0, 1],
+    // type errors
+    ["5", undefined],
+    [new Number(5), undefined],
+  ];
+
+  for (const [input, expectedOutput] of u32Cases) {
+    const actualOutput = nativeTests.double_to_u32(input);
+    console.log(`${input} as u32 => ${actualOutput}`);
+    if (actualOutput !== expectedOutput) {
+      console.error("wrong");
+    }
+  }
+
+  const i64Cases = [
+    // special values
+    [Infinity, 0],
+    [-Infinity, 0],
+    [NaN, 0],
+    // normal
+    [0.0, 0],
+    [1.0, 1],
+    [-1.0, -1],
+    // truncation
+    [1.25, 1],
+    [-1.25, -1],
+    // limits
+    [i64.min, i64.min],
+    [i64.max, i64.max],
+    // clamp
+    [i64.min - 4096.0, i64.min],
+    // this one clamps to the exact max value of i64 (2**63 - 1), which is then rounded
+    // to exactly 2**63 since that's the closest double that can be represented
+    [i64.max + 4096.0, 2 ** 63],
+    // type errors
+    ["5", undefined],
+    [new Number(5), undefined],
+  ];
+
+  for (const [input, expectedOutput] of i64Cases) {
+    const actualOutput = nativeTests.double_to_i64(input);
+    console.log(
+      `${typeof input == "number" ? input.toFixed(2) : input} as i64 => ${typeof actualOutput == "number" ? actualOutput.toFixed(2) : actualOutput}`,
+    );
+    if (actualOutput !== expectedOutput) {
+      console.error("wrong");
+    }
+  }
+};
+
+nativeTests.test_create_array_with_length = () => {
+  for (const size of [0, 5]) {
+    const array = nativeTests.make_empty_array(size);
+    console.log("length =", array.length);
+    // should be 0 as array contains empty slots
+    console.log("number of keys =", Object.keys(array).length);
+  }
+};
+
+nativeTests.test_throw_functions_exhaustive = () => {
+  for (const errorKind of ["error", "type_error", "range_error", "syntax_error"]) {
+    for (const code of [undefined, "", "error code"]) {
+      for (const msg of [undefined, "", "error message"]) {
+        try {
+          nativeTests.throw_error(code, msg, errorKind);
+          console.log(`napi_throw_${errorKind}(${code ?? "nullptr"}, ${msg ?? "nullptr"}) did not throw`);
+        } catch (e) {
+          console.log(
+            `napi_throw_${errorKind} threw ${e.name}: message ${JSON.stringify(e.message)}, code ${JSON.stringify(e.code)}`,
+          );
+        }
+      }
+    }
+  }
+};
+
+nativeTests.test_create_error_functions_exhaustive = () => {
+  for (const errorKind of ["error", "type_error", "range_error", "syntax_error"]) {
+    // null (JavaScript null) is changed to nullptr by the native function
+    for (const code of [undefined, null, "", 42, "error code"]) {
+      for (const msg of [undefined, null, "", 42, "error message"]) {
+        try {
+          nativeTests.create_and_throw_error(code, msg, errorKind);
+          console.log(
+            `napi_create_${errorKind}(${code === null ? "nullptr" : code}, ${msg === null ? "nullptr" : msg}) did not make an error`,
+          );
+        } catch (e) {
+          console.log(
+            `create_and_throw_error(${errorKind}) threw ${e.name}: message ${JSON.stringify(e.message)}, code ${JSON.stringify(e.code)}`,
+          );
+        }
+      }
+    }
+  }
+};
+
+nativeTests.test_type_tag = () => {
+  const o1 = {};
+  const o2 = {};
+
+  nativeTests.add_tag(o1, 1, 2);
+
+  try {
+    // re-tag
+    nativeTests.add_tag(o1, 1, 2);
+  } catch (e) {
+    console.log("tagging already-tagged object threw", e.toString());
+  }
+
+  console.log("tagging non-object succeeds: ", !nativeTests.try_add_tag(null, 0, 0));
+
+  nativeTests.add_tag(o2, 3, 4);
+  console.log("o1 matches o1:", nativeTests.check_tag(o1, 1, 2));
+  console.log("o1 matches o2:", nativeTests.check_tag(o1, 3, 4));
+  console.log("o2 matches o1:", nativeTests.check_tag(o2, 1, 2));
+  console.log("o2 matches o2:", nativeTests.check_tag(o2, 3, 4));
+};
+
 module.exports = nativeTests;
diff --git a/test/napi/napi.test.ts b/test/napi/napi.test.ts
index ab8660a69c..25144c80f7 100644
--- a/test/napi/napi.test.ts
+++ b/test/napi/napi.test.ts
@@ -1,6 +1,6 @@
 import { spawnSync } from "bun";
 import { beforeAll, describe, expect, it } from "bun:test";
-import { bunEnv, bunExe } from "harness";
+import { bunEnv, bunExe, tempDirWithFiles } from "harness";
 import { join } from "path";
 
 describe("napi", () => {
@@ -18,6 +18,124 @@ describe("napi", () => {
       throw new Error("build failed");
     }
   });
+
+  describe.each(["esm", "cjs"])("bundle .node files to %s via", format => {
+    describe.each(["node", "bun"])("target %s", target => {
+      it("Bun.build", async () => {
+        const dir = tempDirWithFiles("node-file-cli", {
+          "package.json": JSON.stringify({
+            name: "napi-app",
+            version: "1.0.0",
+            type: format === "esm" ? "module" : "commonjs",
+          }),
+        });
+        const build = spawnSync({
+          cmd: [
+            bunExe(),
+            "build",
+            "--target",
+            target,
+            "--outdir",
+            dir,
+            "--format=" + format,
+            join(__dirname, "napi-app/main.js"),
+          ],
+          cwd: join(__dirname, "napi-app"),
+          env: bunEnv,
+          stdout: "inherit",
+          stderr: "inherit",
+        });
+        expect(build.success).toBeTrue();
+
+        for (let exec of target === "bun" ? [bunExe()] : [bunExe(), "node"]) {
+          const result = spawnSync({
+            cmd: [exec, join(dir, "main.js"), "self"],
+            env: bunEnv,
+            stdin: "inherit",
+            stderr: "inherit",
+            stdout: "pipe",
+          });
+          const stdout = result.stdout.toString().trim();
+          expect(stdout).toBe("hello world!");
+          expect(result.success).toBeTrue();
+        }
+      });
+
+      if (target === "bun") {
+        it("should work with --compile", async () => {
+          const dir = tempDirWithFiles("napi-app-compile-" + format, {
+            "package.json": JSON.stringify({
+              name: "napi-app",
+              version: "1.0.0",
+              type: format === "esm" ? "module" : "commonjs",
+            }),
+          });
+
+          const exe = join(dir, "main" + (process.platform === "win32" ? ".exe" : ""));
+          const build = spawnSync({
+            cmd: [
+              bunExe(),
+              "build",
+              "--target=" + target,
+              "--format=" + format,
+              "--compile",
+              join(__dirname, "napi-app", "main.js"),
+            ],
+            cwd: dir,
+            env: bunEnv,
+            stdout: "inherit",
+            stderr: "inherit",
+          });
+          expect(build.success).toBeTrue();
+
+          const result = spawnSync({
+            cmd: [exe, "self"],
+            env: bunEnv,
+            stdin: "inherit",
+            stderr: "inherit",
+            stdout: "pipe",
+          });
+          const stdout = result.stdout.toString().trim();
+
+          expect(stdout).toBe("hello world!");
+          expect(result.success).toBeTrue();
+        });
+      }
+
+      it("`bun build`", async () => {
+        const dir = tempDirWithFiles("node-file-build", {
+          "package.json": JSON.stringify({
+            name: "napi-app",
+            version: "1.0.0",
+            type: format === "esm" ? "module" : "commonjs",
+          }),
+        });
+        const build = await Bun.build({
+          entrypoints: [join(__dirname, "napi-app/main.js")],
+          outdir: dir,
+          target,
+          format,
+        });
+
+        expect(build.logs).toBeEmpty();
+
+        for (let exec of target === "bun" ? [bunExe()] : [bunExe(), "node"]) {
+          const result = spawnSync({
+            cmd: [exec, join(dir, "main.js"), "self"],
+            env: bunEnv,
+            stdin: "inherit",
+            stderr: "inherit",
+            stdout: "pipe",
+          });
+          const stdout = result.stdout.toString().trim();
+
+          expect(stdout).toBe("hello world!");
+          expect(result.success).toBeTrue();
+        }
+      });
+    });
+  });
+
   describe("issue_7685", () => {
     it("works", () => {
       const args = [...Array(20).keys()];
@@ -79,7 +197,7 @@ describe("napi", () => {
       checkSameOutput("test_napi_class_constructor_handle_scope", []);
     });
     it("exists while calling a napi_async_complete_callback", () => {
-      checkSameOutput("create_promise", []);
+      checkSameOutput("create_promise", [false]);
     });
   });
 
@@ -131,6 +249,76 @@ describe("napi", () => {
       expect(result).toBe("success!");
     });
   });
+
+  describe("exception handling", () => {
+    it("can check for a pending error and catch the right value", () => {
+      checkSameOutput("test_get_exception", [5]);
+      checkSameOutput("test_get_exception", [{ foo: "bar" }]);
+    });
+    it("can throw an exception from an async_complete_callback", () => {
+      checkSameOutput("create_promise", [true]);
+    });
+  });
+
+  describe("napi_run_script", () => {
+    it("evaluates a basic expression", () => {
+      checkSameOutput("eval_wrapper", ["5 * (1 + 2)"]);
+    });
+    it("provides the right this value", () => {
+      checkSameOutput("eval_wrapper", ["this === global"]);
+    });
+    it("propagates exceptions", () => {
+      checkSameOutput("eval_wrapper", ["(()=>{ throw new TypeError('oops'); })()"]);
+    });
+    it("cannot see locals from around its invocation", () => {
+      // variable should_not_exist is declared on main.js:18, but it should not be in scope for the eval'd code
+      // this doesn't use checkSameOutput because V8 and JSC use different error messages for a missing variable
+      let bunResult = runOn(bunExe(), "eval_wrapper", ["shouldNotExist"]);
+      // remove all debug logs
+      bunResult = bunResult.replaceAll(/^\[\w+\].+$/gm, "").trim();
+      expect(bunResult).toBe(
+        `synchronously threw ReferenceError: message "Can't find variable: shouldNotExist", code undefined`,
+      );
+    });
+  });
+
+  describe("napi_get_named_property", () => {
+    it("handles edge cases", () => {
+      checkSameOutput("test_get_property", []);
+    });
+  });
+
+  describe("napi_value <=> integer conversion", () => {
+    it("works", () => {
+      checkSameOutput("test_number_integer_conversions_from_js", []);
+      checkSameOutput("test_number_integer_conversions", []);
+    });
+  });
+
+  describe("arrays", () => {
+    describe("napi_create_array_with_length", () => {
+      it("creates an array with empty slots", () => {
+        checkSameOutput("test_create_array_with_length", []);
+      });
+    });
+  });
+
+  describe("napi_throw functions", () => {
+    it("has the right code and message", () => {
+      checkSameOutput("test_throw_functions_exhaustive", []);
+    });
+  });
+  describe("napi_create_error functions", () => {
+    it("has the right code and message", () => {
+      checkSameOutput("test_create_error_functions_exhaustive", []);
+    });
+  });
+
+  describe("napi_type_tag_object", () => {
+    it("works", () => {
+      checkSameOutput("test_type_tag", []);
+    });
+  });
 });
 
 function checkSameOutput(test: string, args: any[] | string) {
diff --git a/test/node.js/.gitignore b/test/node.js/.gitignore
deleted file mode 100644
index edad843264..0000000000
--- a/test/node.js/.gitignore
+++ /dev/null
@@ -1,6 +0,0 @@
-# Paths copied from Node.js repository
-upstream/
-
-# Paths for test runner
-summary/
-summary.md
diff --git a/test/node.js/.prettierignore b/test/node.js/.prettierignore
deleted file mode 100644
index 42b5527ca1..0000000000
--- a/test/node.js/.prettierignore
+++ /dev/null
@@ -1 +0,0 @@
-upstream/
diff --git a/test/node.js/bunfig.toml b/test/node.js/bunfig.toml
deleted file mode 100644
index e630e9b8b5..0000000000
--- a/test/node.js/bunfig.toml
+++ /dev/null
@@ -1,2 +0,0 @@
-[test]
-preload = ["./common/preload.js"]
diff --git a/test/node.js/common/assert.js b/test/node.js/common/assert.js
deleted file mode 100644
index e38fe9c7c6..0000000000
--- a/test/node.js/common/assert.js
+++ /dev/null
@@ -1,273 +0,0 @@
-import { expect } from "bun:test";
-
-function deepEqual(actual, expected, message) {
-  if (isIgnored(expected, message)) {
-    return;
-  }
-  try {
-    expect(actual).toEqual(expected);
-  } catch (cause) {
-    throwError(cause, message);
-  }
-}
-
-function deepStrictEqual(actual, expected, message) {
-  if (isIgnored(expected, message)) {
-    return;
-  }
-  try {
-    expect(actual).toStrictEqual(expected);
-  } catch (cause) {
-    throwError(cause, message);
-  }
-}
-
-function doesNotMatch(string, regexp, message) {
-  if (isIgnored(regexp, message)) {
-    return;
-  }
-  try {
-    expect(string).not.toMatch(regexp);
-  } catch (cause) {
-    throwError(cause, message);
-  }
-}
-
-function doesNotReject(asyncFn, error, message) {
-  if (isIgnored(error, message)) {
-    return;
-  }
-  try {
-    expect(asyncFn).rejects.toThrow(error);
-  } catch (cause) {
-    throwError(cause, message);
-  }
-}
-
-function doesNotThrow(fn, error, message) {
-  if (isIgnored(error, message)) {
-    return;
-  }
-  todo("doesNotThrow");
-}
-
-function equal(actual, expected, message) {
-  if (isIgnored(expected, message)) {
-    return;
-  }
-  try {
-    expect(actual).toBe(expected);
-  } catch (cause) {
-    throwError(cause, message);
-  }
-}
-
-function fail(actual, expected, message, operator, stackStartFn) {
-  if (isIgnored(expected, message)) {
-    return;
-  }
-  todo("fail");
-}
-
-function ifError(value) {
-  if (isIgnored(value)) {
-    return;
-  }
-  todo("ifError");
-}
-
-function match(string, regexp, message) {
-  if (isIgnored(regexp, message)) {
-    return;
-  }
-  try {
-    expect(string).toMatch(regexp);
-  } catch (cause) {
-    throwError(cause, message);
-  }
-}
-
-function notDeepEqual(actual, expected, message) {
-  if (isIgnored(expected, message)) {
-    return;
-  }
-  todo("notDeepEqual");
-}
-
-function notDeepStrictEqual(actual, expected, message) {
-  if (isIgnored(expected, message)) {
-    return;
-  }
-  todo("notDeepStrictEqual");
-}
-
-function notEqual(actual, expected, message) {
-  if (isIgnored(expected, message)) {
-    return;
-  }
-  try {
-    expect(actual).not.toBe(expected);
-  } catch (cause) {
-    throwError(cause, message);
-  }
-}
-
-function notStrictEqual(actual, expected, message) {
-  if (isIgnored(expected, message)) {
-    return;
-  }
-  try {
-    expect(actual).not.toStrictEqual(expected);
-  } catch (cause) {
-    throwError(cause, message);
-  }
-}
-
-function ok(value, message) {
-  if (isIgnored(message)) {
-    return;
-  }
-  equal(!!value, true, message);
-}
-
-function rejects(asyncFn, error, message) {
-  if (isIgnored(error, message)) {
-    return;
-  }
-  todo("rejects");
-}
-
-function strictEqual(actual, expected, message) {
-  if (isIgnored(expected, message)) {
-    return;
-  }
-  try {
-    expect(actual).toBe(expected);
-  } catch (cause) {
-    throwError(cause, message);
-  }
-}
-
-function throws(fn, error, message) {
-  try {
-    let result;
-    try {
-      result = fn();
-    } catch (cause) {
-      const matcher = toErrorMatcher(error);
-      expect(cause).toEqual(matcher);
-      return;
-    }
-    expect(result).toBe("Expected function to throw an error, instead it returned");
-  } catch (cause) {
-    throwError(cause, message);
-  }
-}
-
-function toErrorMatcher(expected) {
-  let message;
-  if (typeof expected === "string") {
-    message = expected;
-  } else if (expected instanceof RegExp) {
-    message = expected.source;
-  } else if (typeof expected === "object") {
-    message = expected.message;
-  }
-
-  for (const [expected, actual] of similarErrors) {
-    if (message && expected.test(message)) {
-      message = actual;
-      break;
-    }
-  }
-
-  if (!message) {
-    return expect.anything();
-  }
-
-  if (typeof expected === "object") {
-    return expect.objectContaining({
-      ...expected,
-      message: expect.stringMatching(message),
-    });
-  }
-
-  return expect.stringMatching(message);
-}
-
-const similarErrors = [
-  [/Invalid typed array length/i, /length too large/i],
-  [/Unknown encoding/i, /Invalid encoding/i],
-  [
-    /The ".*" argument must be of type string or an instance of Buffer or ArrayBuffer/i,
-    /Invalid input, must be a string, Buffer, or ArrayBuffer/i,
-  ],
-  [/The ".*" argument must be an instance of Buffer or Uint8Array./i, /Expected Buffer/i],
-  [/The ".*" argument must be an instance of Array./i, /Argument must be an array/i],
-  [/The value of ".*" is out of range./i, /Offset is out of bounds/i],
-  [/Attempt to access memory outside buffer bounds/i, /Out of bounds access/i],
-];
-
-const ignoredExpectations = [
-  // Reason: Bun has a nicer format for `Buffer.inspect()`.
-  /^<Buffer /,
-];
-
-function isIgnored(...expectations) {
-  for (const expected of expectations) {
-    let query;
-    if (typeof expected === "string") {
-      query = expected;
-    } else if (expected instanceof RegExp) {
-      query = expected.source;
-    } else {
-      continue;
-    }
-    for (const pattern of ignoredExpectations) {
-      if (pattern.test(query)) {
-        console.warn("Ignoring expectation:", expected);
-        return true;
-      }
-    }
-  }
-  return false;
-}
-
-function throwError(error, message) {
-  if (isIgnored(error, message)) {
-    return;
-  }
-
-  if (typeof message === "string") {
-    const gray = "\x1b[90m";
-    const reset = "\x1b[0m";
-    error.message += `\n${gray}note: ${message}${reset}`;
-  }
-
-  throw error;
-}
-
-function todo(name) {
-  throw new Error(`TODO: ${name}`);
-}
-
-export default ok;
-export {
-  deepEqual,
-  deepStrictEqual,
-  doesNotMatch,
-  doesNotReject,
-  doesNotThrow,
-  equal,
-  fail,
-  ifError,
-  match,
-  notDeepEqual,
-  notDeepStrictEqual,
-  notEqual,
-  notStrictEqual,
-  ok,
-  rejects,
-  strictEqual,
-  throws,
-};
diff --git a/test/node.js/common/index.js b/test/node.js/common/index.js
deleted file mode 100644
index d0a24de37b..0000000000
--- a/test/node.js/common/index.js
+++ /dev/null
@@ -1,122 +0,0 @@
-// https://github.com/nodejs/node/blob/c975384264dc553de62398be814d0c66fc1fc1fb/test/common/index.js
-
-import { inspect } from "bun";
-import { expect, afterAll } from "bun:test";
-
-const hasIntl = true;
-const hasCrypto = true;
-const hasOpenSSL3 = false;
-const hasOpenSSL31 = false;
-const hasQuic = false;
-
-const { platform, env } = process;
-const isWindows = platform === "win32";
-const isSunOS = platform === "sunos";
-const isFreeBSD = platform === "freebsd";
-const isOpenBSD = platform === "openbsd";
-const isLinux = platform === "linux";
-const isOSX = platform === "darwin";
-const isAsan = false;
-const isPi = false;
-const isDumbTerminal = env.TERM === "dumb";
-
-function mustCall(fn, n = 1) {
-  const callSite = getCallSite(mustCall);
-
-  let calls = 0;
-  const mustCallFn = function (...args) {
-    calls++;
-    return fn.apply(this, args);
-  };
-
-  afterAll(() => {
-    if (calls !== n) {
-      throw new Error(`function should be called exactly ${n} times:\n ${callSite}`);
-    }
-  });
-
-  return mustCallFn;
-}
-
-function mustNotCall() {
-  const callSite = getCallSite(mustNotCall);
-
-  return function mustNotCall(...args) {
-    const argsInfo = args.length > 0 ? `\ncalled with arguments: ${args.map(arg => inspect(arg)).join(", ")}` : "";
-    assert.fail(`${msg || "function should not have been called"} at ${callSite}` + argsInfo);
-  };
-}
-
-function printSkipMessage(message) {
-  console.warn(message);
-}
-
-function skip(message) {
-  printSkipMessage(message);
-  process.exit(0);
-}
-
-function expectsError(validator, exact) {
-  return mustCall((...args) => {
-    if (args.length !== 1) {
-      // Do not use `assert.strictEqual()` to prevent `inspect` from
-      // always being called.
-      assert.fail(`Expected one argument, got ${inspect(args)}`);
-    }
-    const error = args.pop();
-    // The error message should be non-enumerable
-    assert.strictEqual(Object.prototype.propertyIsEnumerable.call(error, "message"), false);
-
-    assert.throws(() => {
-      throw error;
-    }, validator);
-    return true;
-  }, exact);
-}
-
-function expectWarning(name, code, message) {
-  // Do nothing
-}
-
-function invalidArgTypeHelper(input) {
-  return ` Received: ${inspect(input)}`;
-}
-
-function getCallSite(fn) {
-  const originalStackFormatter = Error.prepareStackTrace;
-  Error.prepareStackTrace = (_, stack) => `${stack[0].getFileName()}:${stack[0].getLineNumber()}`;
-  const error = new Error();
-  Error.captureStackTrace(error, fn);
-  error.stack; // With the V8 Error API, the stack is not formatted until it is accessed
-  Error.prepareStackTrace = originalStackFormatter;
-  return error.stack;
-}
-
-export {
-  hasIntl,
-  hasCrypto,
-  hasOpenSSL3,
-  hasOpenSSL31,
-  hasQuic,
-  // ...
-  isWindows,
-  isSunOS,
-  isFreeBSD,
-  isOpenBSD,
-  isLinux,
-  isOSX,
-  isAsan,
-  isPi,
-  // ...
-  isDumbTerminal,
-  // ...
-  mustCall,
-  mustNotCall,
-  printSkipMessage,
-  skip,
-  expectsError,
-  expectWarning,
-  // ...
-  inspect,
-  invalidArgTypeHelper,
-};
diff --git a/test/node.js/common/preload.js b/test/node.js/common/preload.js
deleted file mode 100644
index 8f3b714f19..0000000000
--- a/test/node.js/common/preload.js
+++ /dev/null
@@ -1,10 +0,0 @@
-const { mock } = require("bun:test");
-const assert = require("./assert");
-
-mock.module("assert", () => {
-  return assert;
-});
-
-mock.module("internal/test/binding", () => {
-  return {};
-});
diff --git a/test/node.js/metadata.mjs b/test/node.js/metadata.mjs
deleted file mode 100644
index 16a4fcf7de..0000000000
--- a/test/node.js/metadata.mjs
+++ /dev/null
@@ -1,32 +0,0 @@
-import { spawnSync } from "node:child_process";
-
-const isBun = !!process.isBun;
-const os = process.platform === "win32" ? "windows" : process.platform;
-const arch = process.arch === "arm64" ? "aarch64" : process.arch;
-const version = isBun ? Bun.version : process.versions.node;
-const revision = isBun ? Bun.revision : undefined;
-const baseline = (() => {
-  if (!isBun || arch !== "x64") {
-    return undefined;
-  }
-  const { stdout } = spawnSync(process.execPath, ["--print", "Bun.unsafe.segfault()"], {
-    encoding: "utf8",
-    timeout: 5_000,
-  });
-  if (stdout.includes("baseline")) {
-    return true;
-  }
-  return undefined;
-})();
-const name = baseline ? `bun-${os}-${arch}-baseline` : `${isBun ? "bun" : "node"}-${os}-${arch}`;
-
-console.log(
-  JSON.stringify({
-    name,
-    os,
-    arch,
-    version,
-    revision,
-    baseline,
-  }),
-);
diff --git a/test/node.js/package.json b/test/node.js/package.json
deleted file mode 100644
index 5136aaa87d..0000000000
--- a/test/node.js/package.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "private": true,
-  "scripts": {
-    "test": "node runner.mjs --exec-path $(which bun-debug || which bun)"
-  }
-}
diff --git a/test/node.js/runner.mjs b/test/node.js/runner.mjs
deleted file mode 100644
index 5507638616..0000000000
--- a/test/node.js/runner.mjs
+++ /dev/null
@@ -1,437 +0,0 @@
-import { parseArgs } from "node:util";
-import { spawnSync } from "node:child_process";
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, writeFileSync, appendFileSync, realpathSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { basename, join } from "node:path";
-import readline from "node:readline/promises";
-
-const testPath = new URL("./", import.meta.url);
-const nodePath = new URL("upstream/", testPath);
-const nodeTestPath = new URL("test/", nodePath);
-const metadataScriptPath = new URL("metadata.mjs", testPath);
-const testJsonPath = new URL("tests.json", testPath);
-const summariesPath = new URL("summary/", testPath);
-const summaryMdPath = new URL("summary.md", testPath);
-const cwd = new URL("../../", testPath);
-
-async function main() {
-  const { values, positionals } = parseArgs({
-    allowPositionals: true,
-    options: {
-      help: {
-        type: "boolean",
-        short: "h",
-      },
-      baseline: {
-        type: "boolean",
-      },
-      interactive: {
-        type: "boolean",
-        short: "i",
-      },
-      "exec-path": {
-        type: "string",
-      },
-      pull: {
-        type: "boolean",
-      },
-      summary: {
-        type: "boolean",
-      },
-    },
-  });
-
-  if (values.help) {
-    printHelp();
-    return;
-  }
-
-  if (values.summary) {
-    printSummary();
-    return;
-  }
-
-  if (values.pull) {
-    pullTests(true);
-    return;
-  }
-
-  pullTests();
-  const summary = await runTests(values, positionals);
-  const regressedTests = appendSummary(summary);
-  printSummary(summary, regressedTests);
-
-  process.exit(regressedTests?.length ? 1 : 0);
-}
-
-function printHelp() {
-  console.log(`Usage: ${process.argv0} ${basename(import.meta.filename)} [options]`);
-  console.log();
-  console.log("Options:");
-  console.log("  -h, --help        Show this help message");
-  console.log("  -e, --exec-path   Path to the bun executable to run");
-  console.log("  -i, --interactive Pause and wait for input after a failing test");
-  console.log("  -s, --summary     Print a summary of the tests (does not run tests)");
-}
-
-function pullTests(force) {
-  if (!force && existsSync(nodeTestPath)) {
-    return;
-  }
-
-  console.log("Pulling tests...");
-  const { status, error, stderr } = spawnSync(
-    "git",
-    ["submodule", "update", "--init", "--recursive", "--progress", "--depth=1", "--checkout", "upstream"],
-    {
-      cwd: testPath,
-      stdio: "inherit",
-    },
-  );
-
-  if (error || status !== 0) {
-    throw error || new Error(stderr);
-  }
-
-  for (const { filename, status } of getTests(nodeTestPath)) {
-    if (status === "TODO") {
-      continue;
-    }
-
-    const src = new URL(filename, nodeTestPath);
-    const dst = new URL(filename, testPath);
-
-    try {
-      writeFileSync(dst, readFileSync(src));
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        mkdirSync(new URL(".", dst), { recursive: true });
-        writeFileSync(dst, readFileSync(src));
-      } else {
-        throw error;
-      }
-    }
-  }
-}
-
-async function runTests(options, filters) {
-  const { interactive } = options;
-  const bunPath = process.isBun ? process.execPath : "bun";
-  const execPath = options["exec-path"] || bunPath;
-
-  let reader;
-  if (interactive) {
-    reader = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout,
-    });
-  }
-
-  const results = [];
-  const tests = getTests(testPath);
-  for (const { label, filename, status: filter } of tests) {
-    if (filters?.length && !filters.some(filter => label?.includes(filter))) {
-      continue;
-    }
-
-    if (filter !== "OK") {
-      results.push({ label, filename, status: filter });
-      continue;
-    }
-
-    const { pathname: filePath } = new URL(filename, testPath);
-    const tmp = tmpdirSync();
-    const timestamp = Date.now();
-    const {
-      status: exitCode,
-      signal: signalCode,
-      error: spawnError,
-    } = spawnSync(execPath, ["test", filePath], {
-      cwd: testPath,
-      stdio: "inherit",
-      env: {
-        PATH: process.env.PATH,
-        HOME: tmp,
-        TMPDIR: tmp,
-        TZ: "Etc/UTC",
-        FORCE_COLOR: "1",
-        BUN_DEBUG_QUIET_LOGS: "1",
-        BUN_GARBAGE_COLLECTOR_LEVEL: "1",
-        BUN_RUNTIME_TRANSPILER_CACHE_PATH: "0",
-        GITHUB_ACTIONS: "false", // disable for now
-      },
-      timeout: 30_000,
-    });
-
-    const duration = Math.ceil(Date.now() - timestamp);
-    const status = exitCode === 0 ? "PASS" : "FAIL";
-    let error;
-    if (signalCode) {
-      error = signalCode;
-    } else if (spawnError) {
-      const { message } = spawnError;
-      if (message.includes("timed out") || message.includes("timeout")) {
-        error = "TIMEOUT";
-      } else {
-        error = message;
-      }
-    } else if (exitCode !== 0) {
-      error = `code ${exitCode}`;
-    }
-    results.push({ label, filename, status, error, timestamp, duration });
-
-    if (reader && status === "FAIL") {
-      const answer = await reader.question("Continue? [Y/n] ");
-      if (answer.toUpperCase() !== "Y") {
-        break;
-      }
-    }
-  }
-
-  reader?.close();
-  return {
-    v: 1,
-    metadata: getMetadata(execPath),
-    tests: results,
-  };
-}
-
-function getTests(filePath) {
-  const tests = [];
-  const testData = JSON.parse(readFileSync(testJsonPath, "utf8"));
-
-  for (const filename of readdirSync(filePath, { recursive: true })) {
-    if (!isJavaScript(filename) || !isTest(filename)) {
-      continue;
-    }
-
-    let match;
-    for (const { label, pattern, skip: skipList = [], todo: todoList = [] } of testData) {
-      if (!filename.startsWith(pattern)) {
-        continue;
-      }
-
-      if (skipList.some(({ file }) => filename.endsWith(file))) {
-        tests.push({ label, filename, status: "SKIP" });
-      } else if (todoList.some(({ file }) => filename.endsWith(file))) {
-        tests.push({ label, filename, status: "TODO" });
-      } else {
-        tests.push({ label, filename, status: "OK" });
-      }
-
-      match = true;
-      break;
-    }
-
-    if (!match) {
-      tests.push({ filename, status: "TODO" });
-    }
-  }
-
-  return tests;
-}
-
-function appendSummary(summary) {
-  const { metadata, tests, ...extra } = summary;
-  const { name } = metadata;
-
-  const summaryPath = new URL(`${name}.json`, summariesPath);
-  const summaryData = {
-    metadata,
-    tests: tests.map(({ label, filename, status, error }) => ({ label, filename, status, error })),
-    ...extra,
-  };
-
-  const regressedTests = [];
-  if (existsSync(summaryPath)) {
-    const previousData = JSON.parse(readFileSync(summaryPath, "utf8"));
-    const { v } = previousData;
-    if (v === 1) {
-      const { tests: previousTests } = previousData;
-      for (const { label, filename, status, error } of tests) {
-        if (status !== "FAIL") {
-          continue;
-        }
-        const previousTest = previousTests.find(({ filename: file }) => file === filename);
-        if (previousTest) {
-          const { status: previousStatus } = previousTest;
-          if (previousStatus !== "FAIL") {
-            regressedTests.push({ label, filename, error });
-          }
-        }
-      }
-    }
-  }
-
-  if (regressedTests.length) {
-    return regressedTests;
-  }
-
-  const summaryText = JSON.stringify(summaryData, null, 2);
-  try {
-    writeFileSync(summaryPath, summaryText);
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      mkdirSync(summariesPath, { recursive: true });
-      writeFileSync(summaryPath, summaryText);
-    } else {
-      throw error;
-    }
-  }
-}
-
-function printSummary(summaryData, regressedTests) {
-  let metadataInfo = {};
-  let testInfo = {};
-  let labelInfo = {};
-  let errorInfo = {};
-
-  const summaryList = [];
-  if (summaryData) {
-    summaryList.push(summaryData);
-  } else {
-    for (const filename of readdirSync(summariesPath)) {
-      if (!filename.endsWith(".json")) {
-        continue;
-      }
-
-      const summaryPath = new URL(filename, summariesPath);
-      const summaryData = JSON.parse(readFileSync(summaryPath, "utf8"));
-      summaryList.push(summaryData);
-    }
-  }
-
-  for (const summaryData of summaryList) {
-    const { v, metadata, tests } = summaryData;
-    if (v !== 1) {
-      continue;
-    }
-
-    const { name, version, revision } = metadata;
-    if (revision) {
-      metadataInfo[name] =
-        `${version}-[\`${revision.slice(0, 7)}\`](https://github.com/oven-sh/bun/commit/${revision})`;
-    } else {
-      metadataInfo[name] = `${version}`;
-    }
-
-    for (const test of tests) {
-      const { label, filename, status, error } = test;
-      if (label) {
-        labelInfo[label] ||= { pass: 0, fail: 0, skip: 0, todo: 0, total: 0 };
-        labelInfo[label][status.toLowerCase()] += 1;
-        labelInfo[label].total += 1;
-      }
-      testInfo[name] ||= { pass: 0, fail: 0, skip: 0, todo: 0, total: 0 };
-      testInfo[name][status.toLowerCase()] += 1;
-      testInfo[name].total += 1;
-      if (status === "FAIL") {
-        errorInfo[filename] ||= {};
-        errorInfo[filename][name] = error;
-      }
-    }
-  }
-
-  let summaryMd = `## Node.js tests
-`;
-
-  if (!summaryData) {
-    summaryMd += `
-| Platform | Conformance | Passed | Failed | Skipped | Total |
-| - | - | - | - | - | - |
-`;
-
-    for (const [name, { pass, fail, skip, total }] of Object.entries(testInfo)) {
-      testInfo[name].coverage = (((pass + fail + skip) / total) * 100).toFixed(2);
-      testInfo[name].conformance = ((pass / total) * 100).toFixed(2);
-    }
-
-    for (const [name, { conformance, pass, fail, skip, total }] of Object.entries(testInfo)) {
-      summaryMd += `| \`${name}\` ${metadataInfo[name]} | ${conformance} % | ${pass} | ${fail} | ${skip} | ${total} |\n`;
-    }
-  }
-
-  summaryMd += `
-| API | Conformance | Passed | Failed | Skipped | Total |
-| - | - | - | - | - | - |
-`;
-
-  for (const [label, { pass, fail, skip, total }] of Object.entries(labelInfo)) {
-    labelInfo[label].coverage = (((pass + fail + skip) / total) * 100).toFixed(2);
-    labelInfo[label].conformance = ((pass / total) * 100).toFixed(2);
-  }
-
-  for (const [label, { conformance, pass, fail, skip, total }] of Object.entries(labelInfo)) {
-    summaryMd += `| \`${label}\` | ${conformance} % | ${pass} | ${fail} | ${skip} | ${total} |\n`;
-  }
-
-  if (!summaryData) {
-    writeFileSync(summaryMdPath, summaryMd);
-  }
-
-  const githubSummaryPath = process.env.GITHUB_STEP_SUMMARY;
-  if (githubSummaryPath) {
-    appendFileSync(githubSummaryPath, summaryMd);
-  }
-
-  console.log("=".repeat(process.stdout.columns));
-  console.log("Summary by platform:");
-  console.table(testInfo);
-  console.log("Summary by label:");
-  console.table(labelInfo);
-  if (regressedTests?.length) {
-    const isTty = process.stdout.isTTY;
-    if (isTty) {
-      process.stdout.write("\x1b[31m");
-    }
-    const { name } = summaryData.metadata;
-    console.log(`Regressions found in ${regressedTests.length} tests for ${name}:`);
-    console.table(regressedTests);
-    if (isTty) {
-      process.stdout.write("\x1b[0m");
-    }
-  }
-}
-
-function isJavaScript(filename) {
-  return /\.(m|c)?js$/.test(filename);
-}
-
-function isTest(filename) {
-  return /^test-/.test(basename(filename));
-}
-
-function getMetadata(execPath) {
-  const { pathname: filePath } = metadataScriptPath;
-  const { status: exitCode, stdout } = spawnSync(execPath, [filePath], {
-    cwd,
-    stdio: ["ignore", "pipe", "ignore"],
-    env: {
-      PATH: process.env.PATH,
-      BUN_DEBUG_QUIET_LOGS: "1",
-    },
-    timeout: 5_000,
-  });
-
-  if (exitCode === 0) {
-    try {
-      return JSON.parse(stdout);
-    } catch {
-      // Ignore
-    }
-  }
-
-  return {
-    os: process.platform,
-    arch: process.arch,
-  };
-}
-
-function tmpdirSync(pattern = "bun.test.") {
-  return mkdtempSync(join(realpathSync(tmpdir()), pattern));
-}
-
-main().catch(error => {
-  console.error(error);
-  process.exit(1);
-});
diff --git a/test/node.js/tests.json b/test/node.js/tests.json
deleted file mode 100644
index 8ef5ee4f3e..0000000000
--- a/test/node.js/tests.json
+++ /dev/null
@@ -1,166 +0,0 @@
-[
-  {
-    "label": "node:buffer",
-    "pattern": "parallel/test-buffer",
-    "skip": [
-      {
-        "file": "backing-arraybuffer.js",
-        "reason": "Internal binding checks if the buffer is on the heap"
-      }
-    ],
-    "todo": [
-      {
-        "file": "constants.js",
-        "reason": "Hangs"
-      },
-      {
-        "file": "tostring-rangeerror.js",
-        "reason": "Hangs"
-      }
-    ]
-  },
-  {
-    "label": "node:path",
-    "pattern": "parallel/test-path"
-  },
-  {
-    "label": "node:child_process",
-    "pattern": "parallel/test-child-process"
-  },
-  {
-    "label": "node:async_hooks",
-    "pattern": "parallel/test-async-hooks"
-  },
-  {
-    "label": "node:crypto",
-    "pattern": "parallel/test-crypto"
-  },
-  {
-    "label": "node:dgram",
-    "pattern": "parallel/test-dgram"
-  },
-  {
-    "label": "node:diagnostics_channel",
-    "pattern": "parallel/test-diagnostics-channel"
-  },
-  {
-    "label": "node:fs",
-    "pattern": "parallel/test-fs"
-  },
-  {
-    "label": "node:dns",
-    "pattern": "parallel/test-dns"
-  },
-  {
-    "label": "node:domain",
-    "pattern": "parallel/test-domain"
-  },
-  {
-    "label": "node:events",
-    "pattern": "parallel/test-event-emitter"
-  },
-  {
-    "label": "node:http",
-    "pattern": "parallel/test-http"
-  },
-  {
-    "label": "node:http2",
-    "pattern": "parallel/test-http2"
-  },
-  {
-    "label": "node:https",
-    "pattern": "parallel/test-https"
-  },
-  {
-    "label": "node:net",
-    "pattern": "parallel/test-net"
-  },
-  {
-    "label": "node:os",
-    "pattern": "parallel/test-os"
-  },
-  {
-    "label": "process",
-    "pattern": "parallel/test-process"
-  },
-  {
-    "label": "node:stream",
-    "pattern": "parallel/test-stream"
-  },
-  {
-    "label": "node:stream",
-    "pattern": "parallel/test-readable"
-  },
-  {
-    "label": "node:timers",
-    "pattern": "parallel/test-timers"
-  },
-  {
-    "label": "node:timers",
-    "pattern": "parallel/test-next-tick"
-  },
-  {
-    "label": "node:tls",
-    "pattern": "parallel/test-tls"
-  },
-  {
-    "label": "node:tty",
-    "pattern": "parallel/test-tty"
-  },
-  {
-    "label": "node:url",
-    "pattern": "parallel/test-url"
-  },
-  {
-    "label": "node:util",
-    "pattern": "parallel/test-util"
-  },
-  {
-    "label": "node:trace_events",
-    "pattern": "parallel/test-trace-events"
-  },
-  {
-    "label": "node:vm",
-    "pattern": "parallel/test-vm"
-  },
-  {
-    "label": "node:zlib",
-    "pattern": "parallel/test-zlib"
-  },
-  {
-    "label": "node:worker_threads",
-    "pattern": "parallel/test-worker"
-  },
-  {
-    "label": "node:readline",
-    "pattern": "parallel/test-readline"
-  },
-  {
-    "label": "web:crypto",
-    "pattern": "parallel/test-webcrypto"
-  },
-  {
-    "label": "web:streams",
-    "pattern": "parallel/test-webstream"
-  },
-  {
-    "label": "web:streams",
-    "pattern": "parallel/test-whatwg-webstreams"
-  },
-  {
-    "label": "web:encoding",
-    "pattern": "parallel/test-whatwg-encoding"
-  },
-  {
-    "label": "web:url",
-    "pattern": "parallel/test-whatwg-url"
-  },
-  {
-    "label": "web:websocket",
-    "pattern": "parallel/test-websocket"
-  },
-  {
-    "label": "web:performance",
-    "pattern": "parallel/test-performance"
-  }
-]
diff --git a/test/node.js/tsconfig.json b/test/node.js/tsconfig.json
deleted file mode 100644
index b2ad667c9f..0000000000
--- a/test/node.js/tsconfig.json
+++ /dev/null
@@ -1,27 +0,0 @@
-{
-  "include": [".", "../../packages/bun-types/index.d.ts"],
-  "compilerOptions": {
-    "lib": ["ESNext"],
-    "module": "ESNext",
-    "target": "ESNext",
-    "moduleResolution": "bundler",
-    "moduleDetection": "force",
-    "allowImportingTsExtensions": true,
-    "experimentalDecorators": true,
-    "noEmit": true,
-    "composite": true,
-    "strict": true,
-    "downlevelIteration": true,
-    "skipLibCheck": true,
-    "jsx": "preserve",
-    "allowSyntheticDefaultImports": true,
-    "forceConsistentCasingInFileNames": true,
-    "allowJs": true,
-    "resolveJsonModule": true,
-    "noImplicitThis": false,
-    "paths": {
-      "assert": ["./common/assert.js"]
-    }
-  },
-  "exclude": []
-}
diff --git a/test/package.json b/test/package.json
index 08096cce5d..5fc461dc32 100644
--- a/test/package.json
+++ b/test/package.json
@@ -4,11 +4,13 @@
     "@types/react": "18.0.28",
     "@types/react-dom": "18.0.11",
     "@types/supertest": "2.0.12",
-    "@types/utf-8-validate": "5.0.0"
+    "@types/utf-8-validate": "5.0.0",
+    "@types/ws": "8.5.10",
+    "@types/puppeteer": "7.0.4"
   },
   "dependencies": {
     "@azure/service-bus": "7.9.4",
-    "@grpc/grpc-js": "1.9.9",
+    "@grpc/grpc-js": "1.12.0",
     "@grpc/proto-loader": "0.7.10",
     "@napi-rs/canvas": "0.1.47",
     "@prisma/client": "5.8.0",
@@ -16,16 +18,18 @@
     "@remix-run/serve": "2.10.3",
     "@resvg/resvg-js": "2.4.1",
     "@swc/core": "1.3.38",
-    "@types/ws": "8.5.10",
     "aws-cdk-lib": "2.148.0",
     "axios": "1.6.8",
-    "https-proxy-agent": "7.0.5",
     "body-parser": "1.20.2",
     "comlink": "4.4.1",
+    "devalue": "5.1.1",
     "es-module-lexer": "1.3.0",
     "esbuild": "0.18.6",
     "express": "4.18.2",
     "fast-glob": "3.3.1",
+    "filenamify": "6.0.0",
+    "http2-wrapper": "2.2.1",
+    "https-proxy-agent": "7.0.5",
     "iconv-lite": "0.6.3",
     "isbot": "5.1.13",
     "jest-extended": "4.0.0",
@@ -47,6 +51,7 @@
     "prompts": "2.4.2",
     "reflect-metadata": "0.1.13",
     "rollup": "4.4.1",
+    "sass": "1.79.4",
     "sharp": "0.33.0",
     "sinon": "6.0.0",
     "socket.io": "4.7.1",
@@ -56,13 +61,14 @@
     "string-width": "7.0.0",
     "stripe": "15.4.0",
     "supertest": "6.3.3",
-    "svelte": "3.55.1",
+    "svelte": "5.4.0",
     "typescript": "5.0.2",
     "undici": "5.20.0",
-    "verdaccio": "5.27.0",
+    "verdaccio": "6.0.0",
     "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/preload.ts b/test/preload.ts
index 5e472661a6..811af099b9 100644
--- a/test/preload.ts
+++ b/test/preload.ts
@@ -16,4 +16,4 @@ for (let key in harness.bunEnv) {
   process.env[key] = harness.bunEnv[key] + "";
 }
 
-Bun.$.env(process.env);
+if (Bun.$?.env) Bun.$.env(process.env);
diff --git a/test/regression/issue/013880-fixture.cjs b/test/regression/issue/013880-fixture.cjs
new file mode 100644
index 0000000000..6c246f36fa
--- /dev/null
+++ b/test/regression/issue/013880-fixture.cjs
@@ -0,0 +1,15 @@
+function a() {
+  try {
+    new Function("throw new Error(1)")();
+  } catch (e) {
+    console.log(Error.prepareStackTrace);
+    console.log(e.stack);
+  }
+}
+
+Error.prepareStackTrace = function abc() {
+  console.log("trigger");
+  a();
+};
+
+new Error().stack;
diff --git a/test/regression/issue/013880.test.ts b/test/regression/issue/013880.test.ts
new file mode 100644
index 0000000000..90b84bebeb
--- /dev/null
+++ b/test/regression/issue/013880.test.ts
@@ -0,0 +1,5 @@
+import { test, expect } from "bun:test";
+
+test("regression", () => {
+  expect(() => require("./013880-fixture.cjs")).not.toThrow();
+});
diff --git a/test/regression/issue/014187.test.ts b/test/regression/issue/014187.test.ts
new file mode 100644
index 0000000000..dcccea4133
--- /dev/null
+++ b/test/regression/issue/014187.test.ts
@@ -0,0 +1,24 @@
+import { test, expect } from "bun:test";
+import { on, EventEmitter } from "events";
+
+test("issue-14187", async () => {
+  const ac = new AbortController();
+  const ee = new EventEmitter();
+
+  async function* gen() {
+    for await (const item of on(ee, "beep", { signal: ac.signal })) {
+      yield item;
+    }
+  }
+
+  const iterator = gen();
+
+  iterator.next().catch(() => {});
+
+  expect(ee.listenerCount("beep")).toBe(1);
+  expect(ee.listenerCount("error")).toBe(1);
+  ac.abort();
+
+  expect(ee.listenerCount("beep")).toBe(0);
+  expect(ee.listenerCount("error")).toBe(0);
+});
diff --git a/test/regression/issue/014865.test.ts b/test/regression/issue/014865.test.ts
new file mode 100644
index 0000000000..37e6b1bfbb
--- /dev/null
+++ b/test/regression/issue/014865.test.ts
@@ -0,0 +1,8 @@
+import { test, expect } from "bun:test";
+import { Request } from "node-fetch";
+
+test("node fetch Request URL field is set even with a valid URL", () => {
+  expect(new Request("/").url).toBe("/");
+  expect(new Request("https://bun.sh/").url).toBe("https://bun.sh/");
+  expect(new Request(new URL("https://bun.sh/")).url).toBe("https://bun.sh/");
+});
diff --git a/test/regression/issue/015201.test.ts b/test/regression/issue/015201.test.ts
new file mode 100644
index 0000000000..ab9ce799dd
--- /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/03830.test.ts b/test/regression/issue/03830.test.ts
index a4272dd96f..e55856d950 100644
--- a/test/regression/issue/03830.test.ts
+++ b/test/regression/issue/03830.test.ts
@@ -15,7 +15,10 @@ it("macros should not lead to seg faults under any given input", async () => {
   // Create a directory with our test file
   mkdirSync(testDir, { recursive: true });
   writeFileSync(join(testDir, "macro.ts"), "export function fn(str) { return str; }");
-  writeFileSync(join(testDir, "index.ts"), "import { fn } from './macro' assert { type: 'macro' };\nfn(`©${''}`);");
+  writeFileSync(
+    join(testDir, "index.ts"),
+    "import { fn } from './macro' assert { type: 'macro' };\nfn(`©${Number(0)}`);",
+  );
   testDir = realpathSync(testDir);
 
   const { stderr, exitCode } = Bun.spawnSync({
diff --git a/test/regression/issue/08964/08964.test.ts b/test/regression/issue/08964/08964.test.ts
index e97f0685b9..20e98b8456 100644
--- a/test/regression/issue/08964/08964.test.ts
+++ b/test/regression/issue/08964/08964.test.ts
@@ -10,7 +10,7 @@ test("issue 8964", async () => {
     stdio: ["ignore", "pipe", "inherit"],
   });
   const stdtext = stdout.toString();
-  const [actual, expected] = stdout.toString().split("\n");
+  const [, actual, expected] = stdout.toString().split("\n");
   expect(actual.replace("EXPECTED:", "ACTUAL:")).toBe(expected);
   expect(exitCode).toBe(0);
   expect(signalCode).toBeUndefined();
diff --git a/test/regression/issue/10887.test.ts b/test/regression/issue/10887.test.ts
new file mode 100644
index 0000000000..1fe7fa2ea2
--- /dev/null
+++ b/test/regression/issue/10887.test.ts
@@ -0,0 +1,41 @@
+import { expect, test } from "bun:test";
+import { bunEnv, bunExe, tempDirWithFiles } from "harness";
+
+test("does not segfault", () => {
+  const dir = tempDirWithFiles("10887", {
+    "index.ts": `
+      function deco() {
+        console.log('deco init');
+        return (target, key) => console.log('deco call');
+      }
+
+      enum Enum {
+        ONE = '1',
+      }
+
+      class Example {
+        @deco()
+        [Enum.ONE]: string;
+
+        constructor() {
+          this[Enum.ONE] = 'Hello World';
+        }
+      }
+
+      class Foo {
+        foo;
+      }
+    `,
+  });
+
+  const result = Bun.spawnSync({
+    cmd: [bunExe(), "index.ts"],
+    cwd: dir,
+    env: bunEnv,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  expect(result.stderr.toString()).toBe("");
+  expect(result.stdout.toString()).toBe("deco init\ndeco call\n");
+  expect(result.exitCode).toBe(0);
+});
diff --git a/test/regression/issue/14477/14477.test.ts b/test/regression/issue/14477/14477.test.ts
new file mode 100644
index 0000000000..b6dccc08d3
--- /dev/null
+++ b/test/regression/issue/14477/14477.test.ts
@@ -0,0 +1,23 @@
+import { expect, test } from "bun:test";
+import { bunEnv, bunExe } from "harness";
+import { join } from "path";
+import fs from "fs";
+
+test("JSXElement with mismatched closing tags produces a syntax error", async () => {
+  const files = await fs.promises.readdir(import.meta.dir);
+  const fixtures = files.filter(file => !file.endsWith(".test.ts")).map(fixture => join(import.meta.dir, fixture));
+
+  const bakery = fixtures.map(
+    fixture =>
+      Bun.spawn({
+        cmd: [bunExe(), fixture],
+        cwd: import.meta.dir,
+        stdio: ["inherit", "inherit", "inherit"],
+        env: bunEnv,
+      }).exited,
+  );
+
+  // all subprocesses should fail.
+  const exited = await Promise.all(bakery);
+  expect(exited).toEqual(Array.from({ length: fixtures.length }, () => 1));
+});
diff --git a/test/regression/issue/14477/builtin-mismatch.tsx b/test/regression/issue/14477/builtin-mismatch.tsx
new file mode 100644
index 0000000000..6e099b5356
--- /dev/null
+++ b/test/regression/issue/14477/builtin-mismatch.tsx
@@ -0,0 +1 @@
+console.log(<div></p>);
diff --git a/test/regression/issue/14477/component-mismatch.tsx b/test/regression/issue/14477/component-mismatch.tsx
new file mode 100644
index 0000000000..82fd908832
--- /dev/null
+++ b/test/regression/issue/14477/component-mismatch.tsx
@@ -0,0 +1,2 @@
+
+console.log(<Foo></Bar>);
diff --git a/test/regression/issue/14477/non-identifier-mismatch.tsx b/test/regression/issue/14477/non-identifier-mismatch.tsx
new file mode 100644
index 0000000000..a3f474fe22
--- /dev/null
+++ b/test/regression/issue/14477/non-identifier-mismatch.tsx
@@ -0,0 +1,3 @@
+// mismatch where openening tag is not a valid IdentifierName, but is a valid
+// JSXIdentifierName
+console.log(<div-:button></p>);
diff --git a/test/regression/issue/14515.test.tsx b/test/regression/issue/14515.test.tsx
new file mode 100644
index 0000000000..cdcc93ec64
--- /dev/null
+++ b/test/regression/issue/14515.test.tsx
@@ -0,0 +1,30 @@
+import { expect, test } from "bun:test";
+
+export function Input(a: InlineInputAttrs, ch: DocumentFragment) {
+  const o_model = a.model
+  const nullable = (a.type||'').indexOf('null') > -1
+
+  return <input>
+      {$on('input', (ev) => {
+        var v = ev.currentTarget.value
+        if (nullable && v === '') {
+          o_model.set(null!)
+        } else {
+          // @ts-ignore typescript is confused by the type of o_model, rightly so.
+          o_model.set(to_obs(v))
+        }
+      })}
+
+    </input>
+
+}
+
+function _pad(n: number) {
+  return (n < 10 ? ('0' + n) : n)
+}
+
+function _iso_date(d: Date) {
+  return `${d.getFullYear()}-${_pad(d.getMonth()+1)}-${_pad(d.getDate())}`
+}
+
+test("runs without crashing", () => { })
diff --git a/test/regression/issue/14976/14976.test.ts b/test/regression/issue/14976/14976.test.ts
new file mode 100644
index 0000000000..37e7c72df0
--- /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 0000000000..b1b9a61f14
--- /dev/null
+++ b/test/regression/issue/14976/import_target.ts
@@ -0,0 +1,2 @@
+"use𐃘unicode";
+export const mile𐃘add1 = (int: number) => int + 1;
diff --git a/test/regression/issue/15276.test.ts b/test/regression/issue/15276.test.ts
new file mode 100644
index 0000000000..8d65010414
--- /dev/null
+++ b/test/regression/issue/15276.test.ts
@@ -0,0 +1,17 @@
+import { bunExe, bunEnv } from "harness";
+import { test, expect } from "bun:test";
+
+test("parsing npm aliases without package manager does not crash", () => {
+  // Easiest way to repro this regression with `bunx bunbunbunbunbun@npm:another-bun@1.0.0`. The package
+  // doesn't need to exist, we just need `bunx` to parse the package version.
+  const { stdout, stderr, exitCode } = Bun.spawnSync({
+    cmd: [bunExe(), "x", "bunbunbunbunbun@npm:another-bun@1.0.0"],
+    stdout: "pipe",
+    stderr: "pipe",
+    env: bunEnv,
+  });
+
+  expect(exitCode).toBe(1);
+  expect(stderr.toString()).toContain("error: bunbunbunbunbun@npm:another-bun@1.0.0 failed to resolve");
+  expect(stdout.toString()).toBe("");
+});
diff --git a/test/regression/issue/15314.test.ts b/test/regression/issue/15314.test.ts
new file mode 100644
index 0000000000..303fcf1156
--- /dev/null
+++ b/test/regression/issue/15314.test.ts
@@ -0,0 +1,9 @@
+import { test, expect } from "bun:test";
+
+test("15314", () => {
+  expect(
+    new RegExp(
+      "[A-Za-z\u00c0-\u00d6\u00d8-\u00f6\u00f8-\u02b8\u0300-\u0590\u0900-\u1fff\u200e\u2c00-\ud801\ud804-\ud839\ud83c-\udbff\uf900-\ufb1c\ufe00-\ufe6f\ufefd-\uffff]",
+    ).exec("\uFFFF"),
+  ).toEqual([String.fromCodePoint(0xffff)]);
+});
diff --git a/test/regression/issue/15326.test.ts b/test/regression/issue/15326.test.ts
new file mode 100644
index 0000000000..37ad1bbd61
--- /dev/null
+++ b/test/regression/issue/15326.test.ts
@@ -0,0 +1,7 @@
+import { test, expect } from "bun:test";
+
+test("15326", () => {
+  const s = "\uFFFF";
+  expect(s.charCodeAt(0)).toBe(0xffff);
+  expect(s.charCodeAt(1)).toBe(NaN);
+});
diff --git a/test/regression/issue/__snapshots__/03830.test.ts.snap b/test/regression/issue/__snapshots__/03830.test.ts.snap
index ebaa50fa2e..da75c83eb3 100644
--- a/test/regression/issue/__snapshots__/03830.test.ts.snap
+++ b/test/regression/issue/__snapshots__/03830.test.ts.snap
@@ -1,42 +1,7 @@
 // Bun Snapshot v1, https://goo.gl/fbAQLP
 
 exports[`macros should not lead to seg faults under any given input 1`] = `
-"2 | fn(\`©${''}\`);
-    ^
-error: "Cannot convert argument type to JS" error in macro
-    at [dir]/index.ts:2:1"
-`;
-
-exports[`macros should not lead to seg faults under any given input 1`] = `
-"2 | fn(\`©${''}\`);
-    ^
-error: "Cannot convert argument type to JS" error in macro
-    at [dir]/index.ts:2:1"
-`;
-
-exports[`macros should not lead to seg faults under any given input 1`] = `
-"2 | fn(\`©${''}\`);
-    ^
-error: "Cannot convert argument type to JS" error in macro
-    at [dir]/index.ts:2:1"
-`;
-
-exports[`macros should not lead to seg faults under any given input 1`] = `
-"2 | fn(\`©${''}\`);
-    ^
-error: "Cannot convert argument type to JS" error in macro
-    at [dir]/index.ts:2:1"
-`;
-
-exports[`macros should not lead to seg faults under any given input 1`] = `
-"2 | fn(\`©${''}\`);
-    ^
-error: "Cannot convert argument type to JS" error in macro
-    at [dir]/index.ts:2:1"
-`;
-
-exports[`macros should not lead to seg faults under any given input 1`] = `
-"2 | fn(\`©${''}\`);
+"2 | fn(\`©\${Number(0)}\`);
     ^
 error: "Cannot convert argument type to JS" error in macro
     at [dir]/index.ts:2:1"
diff --git a/test/regression/issue/ctrl-c.test.ts b/test/regression/issue/ctrl-c.test.ts
index 6c336a2444..1a511a6df7 100644
--- a/test/regression/issue/ctrl-c.test.ts
+++ b/test/regression/issue/ctrl-c.test.ts
@@ -1,4 +1,4 @@
-import { expect, test } from "bun:test";
+import { expect, it, test } from "bun:test";
 import { bunEnv, bunExe, isWindows, tempDirWithFiles } from "harness";
 
 test.skipIf(isWindows)("verify that we forward SIGINT from parent to child in bun run", () => {
@@ -32,3 +32,72 @@ test.skipIf(isWindows)("verify that we forward SIGINT from parent to child in bu
   expect(result.exitCode).toBe(null);
   expect(result.signalCode).toBe("SIGKILL");
 });
+
+for (const mode of [
+  ["vite"],
+  ["dev"],
+  ...(isWindows ? [] : [["./node_modules/.bin/vite"]]),
+  ["--bun", "vite"],
+  ["--bun", "dev"],
+  ...(isWindows ? [] : [["--bun", "./node_modules/.bin/vite"]]),
+]) {
+  it("kills on SIGINT in: 'bun " + mode.join(" ") + "'", async () => {
+    const dir = tempDirWithFiles("ctrlc", {
+      "package.json": JSON.stringify({
+        name: "ctrlc",
+        scripts: {
+          "dev": "vite",
+        },
+        devDependencies: {
+          "vite": "^6.0.1",
+        },
+      }),
+    });
+    expect(
+      Bun.spawnSync({
+        cmd: [bunExe(), "install"],
+        cwd: dir,
+        stdin: "inherit",
+        stdout: "inherit",
+        stderr: "inherit",
+      }).exitCode,
+    ).toBe(0);
+    const proc = Bun.spawn({
+      cmd: [bunExe(), ...mode],
+      cwd: dir,
+      stdin: "inherit",
+      stdout: "pipe",
+      stderr: "inherit",
+      env: { ...bunEnv, PORT: "9876" },
+    });
+
+    // wait for vite to start
+    const reader = proc.stdout.getReader();
+    await reader.read(); // wait for first bit of stdout
+    reader.releaseLock();
+
+    expect(proc.killed).toBe(false);
+
+    // send sigint
+    process.kill(proc.pid, "SIGINT");
+
+    // wait for exit or 200ms
+    await Promise.race([proc.exited, Bun.sleep(200)]);
+
+    // wait to allow a moment to be killed
+    await Bun.sleep(100); // wait for kill
+    expect({
+      killed: proc.killed,
+      exitCode: proc.exitCode,
+      signalCode: proc.signalCode,
+    }).toEqual(isWindows ? {
+      killed: true,
+      exitCode: 1,
+      signalCode: null,
+    } : {
+      killed: true,
+      exitCode: null,
+      signalCode: "SIGINT",
+    });
+  });
+}
diff --git a/test/runners/mocha.ts b/test/runners/mocha.ts
new file mode 100644
index 0000000000..5c6a4881f9
--- /dev/null
+++ b/test/runners/mocha.ts
@@ -0,0 +1,15 @@
+import { describe, test, it } from "bun:test";
+import { beforeAll, beforeEach, afterAll, afterEach } from "bun:test";
+
+function set(name: string, value: unknown): void {
+  // @ts-expect-error
+  globalThis[name] = value;
+}
+
+set("describe", describe);
+set("test", test);
+set("it", it);
+set("before", beforeAll);
+set("beforeEach", beforeEach);
+set("after", afterAll);
+set("afterEach", afterEach);
diff --git a/test/v8/v8-module/main.cpp b/test/v8/v8-module/main.cpp
index 136d58e1ac..eceb771843 100644
--- a/test/v8/v8-module/main.cpp
+++ b/test/v8/v8-module/main.cpp
@@ -28,6 +28,12 @@ using namespace v8;
 
 namespace v8tests {
 
+static void run_gc(const FunctionCallbackInfo<Value> &info) {
+  auto *isolate = info.GetIsolate();
+  auto context = isolate->GetCurrentContext();
+  (void)info[0].As<Function>()->Call(context, Null(isolate), 0, nullptr);
+}
+
 static void log_buffer(const char *buf, int len) {
   for (int i = 0; i < len; i++) {
     printf("buf[%d] = 0x%02x\n", i, buf[i]);
@@ -50,6 +56,14 @@ static std::string describe(Isolate *isolate, Local<Value> value) {
     result += buf;
     result += "\"";
     return result;
+  } else if (value->IsFunction()) {
+    char buf[1024] = {0};
+    value.As<Function>()->GetName().As<String>()->WriteUtf8(isolate, buf,
+                                                            sizeof(buf) - 1);
+    std::string result = "function ";
+    result += buf;
+    result += "()";
+    return result;
   } else if (value->IsObject()) {
     return "[object Object]";
   } else if (value->IsNumber()) {
@@ -159,40 +173,55 @@ static void perform_string_test(const FunctionCallbackInfo<Value> &info,
   return ok(info);
 }
 
+template <typename T>
+void perform_string_test_normal_and_internalized(
+    const FunctionCallbackInfo<Value> &info, const T *string_literal,
+    bool latin1 = false) {
+  Isolate *isolate = info.GetIsolate();
+
+  if (latin1) {
+    const uint8_t *string = reinterpret_cast<const uint8_t *>(string_literal);
+    perform_string_test(
+        info, String::NewFromOneByte(isolate, string, NewStringType::kNormal)
+                  .ToLocalChecked());
+    perform_string_test(info, String::NewFromOneByte(
+                                  isolate, string, NewStringType::kInternalized)
+                                  .ToLocalChecked());
+
+  } else {
+    const char *string = reinterpret_cast<const char *>(string_literal);
+    perform_string_test(
+        info, String::NewFromUtf8(isolate, string, NewStringType::kNormal)
+                  .ToLocalChecked());
+    perform_string_test(
+        info, String::NewFromUtf8(isolate, string, NewStringType::kInternalized)
+                  .ToLocalChecked());
+  }
+}
+
 void test_v8_string_ascii(const FunctionCallbackInfo<Value> &info) {
-  auto string =
-      String::NewFromUtf8(info.GetIsolate(), "hello world").ToLocalChecked();
-  perform_string_test(info, string);
+  perform_string_test_normal_and_internalized(info, "hello world");
 }
 
 void test_v8_string_utf8(const FunctionCallbackInfo<Value> &info) {
   const unsigned char trans_flag_unsigned[] = {240, 159, 143, 179, 239, 184,
                                                143, 226, 128, 141, 226, 154,
                                                167, 239, 184, 143, 0};
-  const char *trans_flag = reinterpret_cast<const char *>(trans_flag_unsigned);
-  auto string =
-      String::NewFromUtf8(info.GetIsolate(), trans_flag).ToLocalChecked();
-  perform_string_test(info, string);
+  perform_string_test_normal_and_internalized(info, trans_flag_unsigned);
 }
 
 void test_v8_string_invalid_utf8(const FunctionCallbackInfo<Value> &info) {
   const unsigned char mixed_sequence_unsigned[] = {'o', 'h',  ' ', 0xc0, 'n',
                                                    'o', 0xc2, '!', 0xf5, 0};
-  const char *mixed_sequence =
-      reinterpret_cast<const char *>(mixed_sequence_unsigned);
-  auto string =
-      String::NewFromUtf8(info.GetIsolate(), mixed_sequence).ToLocalChecked();
-  perform_string_test(info, string);
+  perform_string_test_normal_and_internalized(info, mixed_sequence_unsigned);
 }
 
 void test_v8_string_latin1(const FunctionCallbackInfo<Value> &info) {
   const unsigned char latin1[] = {0xa1, 'b', 'u', 'n', '!', 0};
-  auto string =
-      String::NewFromOneByte(info.GetIsolate(), latin1).ToLocalChecked();
-  perform_string_test(info, string);
-  string = String::NewFromOneByte(info.GetIsolate(), latin1,
-                                  NewStringType::kNormal, 1)
-               .ToLocalChecked();
+  perform_string_test_normal_and_internalized(info, latin1, true);
+  auto string = String::NewFromOneByte(info.GetIsolate(), latin1,
+                                       NewStringType::kNormal, 1)
+                    .ToLocalChecked();
   perform_string_test(info, string);
 }
 
@@ -313,6 +342,9 @@ void create_function_with_data(const FunctionCallbackInfo<Value> &info) {
   Local<FunctionTemplate> tmp =
       FunctionTemplate::New(isolate, return_data_callback, s);
   Local<Function> f = tmp->GetFunction(context).ToLocalChecked();
+  Local<String> name =
+      String::NewFromUtf8(isolate, "function_with_data").ToLocalChecked();
+  f->SetName(name);
   info.GetReturnValue().Set(f);
 }
 
@@ -326,6 +358,10 @@ void print_values_from_js(const FunctionCallbackInfo<Value> &info) {
   return ok(info);
 }
 
+void return_this(const FunctionCallbackInfo<Value> &info) {
+  info.GetReturnValue().Set(info.This());
+}
+
 class GlobalTestWrapper {
 public:
   static void set(const FunctionCallbackInfo<Value> &info);
@@ -345,7 +381,8 @@ void GlobalTestWrapper::set(const FunctionCallbackInfo<Value> &info) {
   } else {
     info.GetReturnValue().Set(value.Get(isolate));
   }
-  value.Reset(isolate, info[0]);
+  const auto new_value = info[0];
+  value.Reset(isolate, new_value);
 }
 
 void GlobalTestWrapper::get(const FunctionCallbackInfo<Value> &info) {
@@ -371,6 +408,25 @@ void test_many_v8_locals(const FunctionCallbackInfo<Value> &info) {
   }
 }
 
+void print_cell_location(Local<Data> v8_value, const char *fmt, ...) {
+  (void)v8_value;
+  (void)fmt;
+  // va_list ap;
+  // va_start(ap, fmt);
+  // vprintf(fmt, ap);
+  // va_end(ap);
+
+  // uintptr_t *slot = *reinterpret_cast<uintptr_t **>(&v8_value);
+  // uintptr_t tagged = *slot;
+  // uintptr_t addr = tagged & ~3;
+  // struct ObjectLayout {
+  //   uintptr_t map;
+  //   void *cell;
+  // };
+  // void *cell = reinterpret_cast<ObjectLayout *>(addr)->cell;
+  // printf(" = %p\n", cell);
+}
+
 static Local<Object> setup_object_with_string_field(Isolate *isolate,
                                                     Local<Context> context,
                                                     Local<ObjectTemplate> tmp,
@@ -378,22 +434,28 @@ static Local<Object> setup_object_with_string_field(Isolate *isolate,
                                                     const std::string &str) {
   EscapableHandleScope ehs(isolate);
   Local<Object> o = tmp->NewInstance(context).ToLocalChecked();
-  // print_cell_location(o, "objects[%5d]          ", i);
+  print_cell_location(o, "objects[%3d]   ", i);
   Local<String> value =
       String::NewFromUtf8(isolate, str.c_str()).ToLocalChecked();
+  print_cell_location(value, "objects[%3d]->0", i);
 
   o->SetInternalField(0, value);
   return ehs.Escape(o);
 }
 
-static void examine_object_fields(Isolate *isolate, Local<Object> o) {
+static void examine_object_fields(Isolate *isolate, Local<Object> o,
+                                  int expected_field0, int expected_field1) {
   char buf[16];
   HandleScope hs(isolate);
   o->GetInternalField(0).As<String>()->WriteUtf8(isolate, buf);
+  assert(atoi(buf) == expected_field0);
 
-  Local<Data> field1 = o->GetInternalField(1);
-  if (field1.As<Value>()->IsString()) {
+  Local<Value> field1 = o->GetInternalField(1).As<Value>();
+  if (field1->IsString()) {
     field1.As<String>()->WriteUtf8(isolate, buf);
+    assert(atoi(buf) == expected_field1);
+  } else {
+    assert(field1->IsUndefined());
   }
 }
 
@@ -402,24 +464,28 @@ void test_handle_scope_gc(const FunctionCallbackInfo<Value> &info) {
   Local<Context> context = isolate->GetCurrentContext();
 
   // allocate a ton of objects
-  constexpr size_t num_small_allocs = 10000;
+  constexpr size_t num_small_allocs = 500;
 
   Local<String> mini_strings[num_small_allocs];
   for (size_t i = 0; i < num_small_allocs; i++) {
     std::string cpp_str = std::to_string(i);
     mini_strings[i] =
         String::NewFromUtf8(isolate, cpp_str.c_str()).ToLocalChecked();
+    print_cell_location(mini_strings[i], "mini_strings[%3d]", i);
   }
 
-  // allocate some objects with internal fields, to check that those are traced
+  // allocate some objects with internal fields, to check that those are
+  // traced
   Local<ObjectTemplate> tmp = ObjectTemplate::New(isolate);
   tmp->SetInternalFieldCount(2);
+  print_cell_location(tmp, "object template");
+  print_cell_location(context, "context");
   Local<Object> objects[num_small_allocs];
 
   for (size_t i = 0; i < num_small_allocs; i++) {
     std::string cpp_str = std::to_string(i + num_small_allocs);
-    // this uses a function so that the strings aren't kept alive by the current
-    // handle scope
+    // this uses a function so that the strings aren't kept alive by the
+    // current handle scope
     objects[i] =
         setup_object_with_string_field(isolate, context, tmp, i, cpp_str);
   }
@@ -428,7 +494,7 @@ void test_handle_scope_gc(const FunctionCallbackInfo<Value> &info) {
   // this should cause GC to start looking for objects to free
   // after each big string allocation, we try reading all of the strings we
   // created above to ensure they are still alive
-  constexpr size_t num_strings = 100;
+  constexpr size_t num_strings = 50;
   constexpr size_t string_size = 20 * 1000 * 1000;
 
   auto string_data = new char[string_size];
@@ -445,10 +511,12 @@ void test_handle_scope_gc(const FunctionCallbackInfo<Value> &info) {
     for (size_t j = 0; j < num_small_allocs; j++) {
       char buf[16];
       mini_strings[j]->WriteUtf8(isolate, buf);
+      assert(atoi(buf) == (int)j);
     }
 
     for (size_t j = 0; j < num_small_allocs; j++) {
-      examine_object_fields(isolate, objects[j]);
+      examine_object_fields(isolate, objects[j], j + num_small_allocs,
+                            j + 2 * num_small_allocs);
     }
 
     if (i == 1) {
@@ -467,9 +535,55 @@ void test_handle_scope_gc(const FunctionCallbackInfo<Value> &info) {
     }
   }
 
+  memset(string_data, 0, string_size);
+  for (size_t i = 0; i < num_strings; i++) {
+    huge_strings[i]->WriteUtf8(isolate, string_data);
+    for (size_t j = 0; j < string_size - 1; j++) {
+      assert(string_data[j] == (char)(i + 1));
+    }
+  }
+
   delete[] string_data;
 }
 
+Local<String> escape_object(Isolate *isolate) {
+  EscapableHandleScope ehs(isolate);
+  Local<String> invalidated =
+      String::NewFromUtf8(isolate, "hello").ToLocalChecked();
+  Local<String> escaped = ehs.Escape(invalidated);
+  return escaped;
+}
+
+Local<Number> escape_smi(Isolate *isolate) {
+  EscapableHandleScope ehs(isolate);
+  Local<Number> invalidated = Number::New(isolate, 3.0);
+  Local<Number> escaped = ehs.Escape(invalidated);
+  return escaped;
+}
+
+Local<Boolean> escape_true(Isolate *isolate) {
+  EscapableHandleScope ehs(isolate);
+  Local<Boolean> invalidated = v8::True(isolate);
+  Local<Boolean> escaped = ehs.Escape(invalidated);
+  return escaped;
+}
+
+void test_v8_escapable_handle_scope(const FunctionCallbackInfo<Value> &info) {
+  Isolate *isolate = info.GetIsolate();
+  Local<String> s = escape_object(isolate);
+  Local<Number> n = escape_smi(isolate);
+  Local<Boolean> t = escape_true(isolate);
+
+  LOG_VALUE_KIND(s);
+  LOG_VALUE_KIND(n);
+  LOG_VALUE_KIND(t);
+
+  char buf[16];
+  s->WriteUtf8(isolate, buf);
+  LOG_EXPR(buf);
+  LOG_EXPR(n->Value());
+}
+
 void test_uv_os_getpid(const FunctionCallbackInfo<Value> &info) {
 #ifndef _WIN32
   assert(getpid() == uv_os_getpid());
@@ -510,10 +624,13 @@ void initialize(Local<Object> exports, Local<Value> module,
   NODE_SET_METHOD(exports, "create_function_with_data",
                   create_function_with_data);
   NODE_SET_METHOD(exports, "print_values_from_js", print_values_from_js);
+  NODE_SET_METHOD(exports, "return_this", return_this);
   NODE_SET_METHOD(exports, "global_get", GlobalTestWrapper::get);
   NODE_SET_METHOD(exports, "global_set", GlobalTestWrapper::set);
   NODE_SET_METHOD(exports, "test_many_v8_locals", test_many_v8_locals);
   NODE_SET_METHOD(exports, "test_handle_scope_gc", test_handle_scope_gc);
+  NODE_SET_METHOD(exports, "test_v8_escapable_handle_scope",
+                  test_v8_escapable_handle_scope);
   NODE_SET_METHOD(exports, "test_uv_os_getpid", test_uv_os_getpid);
   NODE_SET_METHOD(exports, "test_uv_os_getppid", test_uv_os_getppid);
 
diff --git a/test/v8/v8-module/main.js b/test/v8/v8-module/main.js
index 1fdb23342f..ad5d9afc69 100644
--- a/test/v8/v8-module/main.js
+++ b/test/v8/v8-module/main.js
@@ -1,3 +1,4 @@
+"use strict";
 // usage: bun/node main.js <name of test function to run> [JSON array of arguments] [JSON `this` value] [debug]
 
 const buildMode = process.argv[5];
@@ -8,11 +9,18 @@ const testName = process.argv[2];
 const args = JSON.parse(process.argv[3] ?? "[]");
 const thisValue = JSON.parse(process.argv[4] ?? "null");
 
+function runGC() {
+  if (typeof Bun !== "undefined") {
+    Bun.gc(true);
+  }
+}
+
 const fn = tests[testName];
 if (typeof fn !== "function") {
   throw new Error("Unknown test:", testName);
 }
-const result = fn.apply(thisValue, args);
+const result = fn.apply(thisValue, [runGC, ...args]);
 if (result) {
+  console.log(result == global);
   throw new Error(result);
 }
diff --git a/test/v8/v8-module/module.js b/test/v8/v8-module/module.js
index b15152026b..91a7fe9b78 100644
--- a/test/v8/v8-module/module.js
+++ b/test/v8/v8-module/module.js
@@ -2,16 +2,23 @@ module.exports = debugMode => {
   const nativeModule = require(`./build/${debugMode ? "Debug" : "Release"}/v8tests`);
   return {
     ...nativeModule,
+
     test_v8_global() {
-      console.log(nativeModule.global_get());
+      console.log("global initial value =", nativeModule.global_get());
+
       nativeModule.global_set(123);
-      console.log(nativeModule.global_get());
+      console.log("global after setting to 123 =", nativeModule.global_get());
+
       nativeModule.global_set({ foo: 5, bar: ["one", "two", "three"] });
       if (process.isBun) {
         Bun.gc(true);
       }
-      console.log(JSON.stringify(nativeModule.global_get()));
+      console.log("global after setting to object =", JSON.stringify(nativeModule.global_get()));
+
+      nativeModule.global_set(true);
+      console.log("global after setting to true =", nativeModule.global_get());
     },
+
     test_v8_function_template() {
       const f = nativeModule.create_function_with_data();
       if (process.isBun) {
@@ -19,5 +26,24 @@ module.exports = debugMode => {
       }
       console.log(f());
     },
+
+    print_native_function() {
+      nativeModule.print_values_from_js(nativeModule.create_function_with_data());
+    },
+
+    call_function_with_weird_this_values() {
+      for (const thisValue of [null, undefined, 5, "abc"]) {
+        const ret = nativeModule.return_this.call(thisValue);
+        console.log("typeof =", typeof ret);
+        if (ret == globalThis) {
+          console.log("returned globalThis");
+        } else if (ret instanceof String) {
+          console.log("returned boxed String:", ret.toString());
+        } else {
+          console.log("returned", ret);
+        }
+        console.log("constructor is", ret.constructor.name);
+      }
+    },
   };
 };
diff --git a/test/v8/v8.test.ts b/test/v8/v8.test.ts
index d6df90d217..ad7b2b1a3d 100644
--- a/test/v8/v8.test.ts
+++ b/test/v8/v8.test.ts
@@ -1,9 +1,19 @@
 import { spawn, spawnSync } from "bun";
 import { beforeAll, describe, expect, it } from "bun:test";
-import { bunEnv, bunExe, tmpdirSync } from "harness";
+import { bunEnv, bunExe, tmpdirSync, isWindows } from "harness";
 import assert from "node:assert";
 import fs from "node:fs/promises";
-import { join } from "path";
+import { join, basename } from "path";
+
+enum Runtime {
+  node,
+  bun,
+}
+
+enum BuildMode {
+  debug,
+  release,
+}
 
 // clang-cl does not work on Windows with node-gyp 10.2.0, so we should not let that affect the
 // test environment
@@ -43,7 +53,12 @@ async function install(srcDir: string, tmpDir: string, runtime: Runtime): Promis
   }
 }
 
-async function build(srcDir: string, tmpDir: string, runtime: Runtime, buildMode: BuildMode): Promise<void> {
+async function build(
+  srcDir: string,
+  tmpDir: string,
+  runtime: Runtime,
+  buildMode: BuildMode,
+): Promise<{ out: string; err: string; description: string }> {
   const build = spawn({
     cmd:
       runtime == Runtime.bun
@@ -52,13 +67,21 @@ async function build(srcDir: string, tmpDir: string, runtime: Runtime, buildMode
     cwd: tmpDir,
     env: bunEnv,
     stdin: "inherit",
-    stdout: "inherit",
-    stderr: "inherit",
+    stdout: "pipe",
+    stderr: "pipe",
   });
   await build.exited;
+  const out = await new Response(build.stdout).text();
+  const err = await new Response(build.stderr).text();
   if (build.exitCode != 0) {
+    console.error(err);
     throw new Error("build failed");
   }
+  return {
+    out,
+    err,
+    description: `build ${basename(srcDir)} with ${Runtime[runtime]} in ${BuildMode[buildMode]} mode`,
+  };
 }
 
 beforeAll(async () => {
@@ -73,10 +96,18 @@ beforeAll(async () => {
   await install(srcDir, directories.node, Runtime.node);
   await install(join(__dirname, "bad-modules"), directories.badModules, Runtime.node);
 
-  await build(srcDir, directories.bunRelease, Runtime.bun, BuildMode.release);
-  await build(srcDir, directories.bunDebug, Runtime.bun, BuildMode.debug);
-  await build(srcDir, directories.node, Runtime.node, BuildMode.release);
-  await build(join(__dirname, "bad-modules"), directories.badModules, Runtime.node, BuildMode.release);
+  const results = await Promise.all([
+    build(srcDir, directories.bunRelease, Runtime.bun, BuildMode.release),
+    build(srcDir, directories.bunDebug, Runtime.bun, BuildMode.debug),
+    build(srcDir, directories.node, Runtime.node, BuildMode.release),
+    build(join(__dirname, "bad-modules"), directories.badModules, Runtime.node, BuildMode.release),
+  ]);
+  for (const r of results) {
+    console.log(r.description, "stdout:");
+    console.log(r.out);
+    console.log(r.description, "stderr:");
+    console.log(r.err);
+  }
 });
 
 describe("module lifecycle", () => {
@@ -157,7 +188,12 @@ describe("FunctionTemplate", () => {
 
 describe("Function", () => {
   it("correctly receives all its arguments from JS", () => {
-    checkSameOutput("print_values_from_js", [5.0, true, null, false, "meow", {}], {});
+    checkSameOutput("print_values_from_js", [5.0, true, null, false, "meow", {}]);
+    checkSameOutput("print_native_function", []);
+  });
+
+  it("correctly receives the this value from JS", () => {
+    checkSameOutput("call_function_with_weird_this_values", []);
   });
 });
 
@@ -190,28 +226,24 @@ describe("HandleScope", () => {
   }, 10000);
 });
 
-const itIfNotWindows = process.platform == "win32" ? it.skip : it;
+describe("EscapableHandleScope", () => {
+  it("keeps handles alive in the outer scope", () => {
+    checkSameOutput("test_v8_escapable_handle_scope", []);
+  });
+});
+
 describe("uv_os_getpid", () => {
-  itIfNotWindows("returns the same result as getpid on POSIX", () => {
+  it.skipIf(isWindows)("returns the same result as getpid on POSIX", () => {
     checkSameOutput("test_uv_os_getpid", []);
   });
 });
+
 describe("uv_os_getppid", () => {
-  itIfNotWindows("returns the same result as getppid on POSIX", () => {
+  it.skipIf(isWindows)("returns the same result as getppid on POSIX", () => {
     checkSameOutput("test_uv_os_getppid", []);
   });
 });
 
-enum Runtime {
-  node,
-  bun,
-}
-
-enum BuildMode {
-  debug,
-  release,
-}
-
 function checkSameOutput(testName: string, args: any[], thisValue?: any) {
   const nodeResult = runOn(Runtime.node, BuildMode.release, testName, args, thisValue).trim();
   let bunReleaseResult = runOn(Runtime.bun, BuildMode.release, testName, args, thisValue);
@@ -240,7 +272,14 @@ function runOn(runtime: Runtime, buildMode: BuildMode, testName: string, jsArgs:
         : directories.bunRelease;
   const exe = runtime == Runtime.node ? "node" : bunExe();
 
-  const cmd = [exe, join(baseDir, "main.js"), testName, JSON.stringify(jsArgs), JSON.stringify(thisValue ?? null)];
+  const cmd = [
+    exe,
+    ...(runtime == Runtime.bun ? ["--smol"] : []),
+    join(baseDir, "main.js"),
+    testName,
+    JSON.stringify(jsArgs),
+    JSON.stringify(thisValue ?? null),
+  ];
   if (buildMode == BuildMode.debug) {
     cmd.push("debug");
   }
diff --git a/test/vendor.json b/test/vendor.json
new file mode 100644
index 0000000000..bc704a7c45
--- /dev/null
+++ b/test/vendor.json
@@ -0,0 +1,7 @@
+[
+  {
+    "package": "elysia",
+    "repository": "https://github.com/elysiajs/elysia",
+    "tag": "1.1.24"
+  }
+]
diff --git a/tsconfig.json b/tsconfig.json
index e417b43288..e1e4627658 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -14,10 +14,11 @@
     "packages",
     "bench",
     "examples/*/*",
+    "build",
+    ".zig-cache",
     "test",
     "vendor",
     "bun-webkit",
-    "vendor/WebKit",
     "src/api/demo",
     "node_modules"
   ],